640 lines
21 KiB
Rust
640 lines
21 KiB
Rust
//! Unique replacement matches that explain removed and added objects.
|
|
|
|
use super::*;
|
|
|
|
#[derive(Debug)]
|
|
pub struct Replacement {
|
|
pub removed: usize,
|
|
pub added: usize,
|
|
/// Explanation matching is never object identity or geometric equivalence.
|
|
pub match_rule: &'static str,
|
|
}
|
|
|
|
type Group = (u16, Option<Layer>, Option<String>, Option<Bounds>);
|
|
|
|
fn group(object: &ObjectChange, bounds: bool) -> Group {
|
|
(
|
|
object.kind,
|
|
object.layer,
|
|
object.target.clone(),
|
|
if bounds && object.target.is_none() {
|
|
object.bounds
|
|
} else {
|
|
None
|
|
},
|
|
)
|
|
}
|
|
|
|
fn unique_groups<'a, K: Ord>(
|
|
objects: &'a [ObjectChange],
|
|
key: impl Fn(usize, &'a ObjectChange) -> Option<K>,
|
|
) -> BTreeMap<K, Option<usize>> {
|
|
let mut groups = BTreeMap::new();
|
|
for (index, object) in objects.iter().enumerate() {
|
|
if let Some(key) = key(index, object) {
|
|
groups
|
|
.entry(key)
|
|
.and_modify(|value| *value = None)
|
|
.or_insert(Some(index));
|
|
}
|
|
}
|
|
groups
|
|
}
|
|
|
|
type ShapeKey<'a> = (u16, Vec<(u16, &'a [u8])>, &'a [(u16, Vec<u8>)]);
|
|
|
|
fn shape_without_layer(object: &ObjectChange) -> Option<ShapeKey<'_>> {
|
|
if object.layer.is_none() || !(is_polygon(object.kind) || object.kind == RTAG_PATH) {
|
|
return None;
|
|
}
|
|
let fields = object
|
|
.fields
|
|
.iter()
|
|
.filter(|field| !matches_layer_field(object.kind, field.tag))
|
|
.map(|field| (field.tag, field.data.as_slice()))
|
|
.collect();
|
|
Some((object.kind, fields, &object.properties))
|
|
}
|
|
|
|
fn layer_replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec<Replacement> {
|
|
// Most small edits touch a single numeric pair.
|
|
let Some(layer) = old.iter().chain(new).find_map(|object| object.layer) else {
|
|
return Vec::new();
|
|
};
|
|
if !old
|
|
.iter()
|
|
.chain(new)
|
|
.any(|object| object.layer.is_some_and(|pair| pair != layer))
|
|
{
|
|
return Vec::new();
|
|
}
|
|
let a = unique_groups(old, |_, object| shape_without_layer(object));
|
|
let b = unique_groups(new, |_, object| shape_without_layer(object));
|
|
a.into_iter()
|
|
.filter_map(|(key, removed)| {
|
|
let removed = removed?;
|
|
let added = b.get(&key).copied().flatten()?;
|
|
(old[removed].layer != new[added].layer).then_some(Replacement {
|
|
removed,
|
|
added,
|
|
match_rule: "unique_layer_change",
|
|
})
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Pair only unique candidates in the remaining multisets. Ambiguous groups
|
|
/// remain additions/removals; no identity or geometric equivalence is inferred.
|
|
pub(super) fn replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec<Replacement> {
|
|
if old.is_empty() || new.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
let mut result = layer_replacements(old, new);
|
|
let (mut used_old, mut used_new): (BTreeSet<_>, BTreeSet<_>) =
|
|
result.iter().map(|pair| (pair.removed, pair.added)).unzip();
|
|
for bounds in [true, false] {
|
|
let a = unique_groups(old, |i, object| {
|
|
(!used_old.contains(&i)).then(|| group(object, bounds))
|
|
});
|
|
let b = unique_groups(new, |i, object| {
|
|
(!used_new.contains(&i)).then(|| group(object, bounds))
|
|
});
|
|
for (key, index) in a {
|
|
if let (Some(i), Some(&Some(j))) = (index, b.get(&key)) {
|
|
result.push(Replacement {
|
|
removed: i,
|
|
added: j,
|
|
match_rule: if old[i].target.is_some() {
|
|
"unique_kind_target"
|
|
} else if bounds {
|
|
"unique_kind_layer_bounds"
|
|
} else {
|
|
"unique_kind_layer"
|
|
},
|
|
});
|
|
used_old.insert(i);
|
|
used_new.insert(j);
|
|
}
|
|
}
|
|
}
|
|
result.sort_by_key(|r| (r.removed, r.added));
|
|
result
|
|
}
|
|
|
|
pub(super) fn field_changes<'a>(
|
|
old: &'a ObjectChange,
|
|
new: &'a ObjectChange,
|
|
) -> impl Iterator<Item = (u16, Option<&'a [u8]>, Option<&'a [u8]>)> {
|
|
let mut fields = BTreeMap::<u16, (Option<&[u8]>, Option<&[u8]>)>::new();
|
|
for field in &old.fields {
|
|
fields.entry(field.tag).or_default().0 = Some(&field.data);
|
|
}
|
|
for field in &new.fields {
|
|
fields.entry(field.tag).or_default().1 = Some(&field.data);
|
|
}
|
|
fields
|
|
.into_iter()
|
|
.filter_map(|(tag, (before, after))| (before != after).then_some((tag, before, after)))
|
|
}
|
|
|
|
fn polygon_heading(object: &ObjectChange, rectangular: bool) -> String {
|
|
object_heading(object, object_name(object.kind, rectangular))
|
|
}
|
|
|
|
fn object_heading(object: &ObjectChange, kind: &str) -> String {
|
|
match object.layer {
|
|
Some((layer, datatype)) => format!("{layer}/{datatype}: {kind}"),
|
|
None => kind.to_string(),
|
|
}
|
|
}
|
|
|
|
fn object_xy(object: &ObjectChange) -> &[u8] {
|
|
object
|
|
.fields
|
|
.iter()
|
|
.find(|field| field.tag == RTAG_XY)
|
|
.map_or(&[], |field| field.data.as_slice())
|
|
}
|
|
|
|
pub(super) fn write_unmatched(out: &mut String, object: &ObjectChange) {
|
|
if object.kind == RTAG_PATH
|
|
&& let Some([xmin, ymin, xmax, ymax]) = object.bounds
|
|
{
|
|
let vertices = XY::points(object_xy(object)).len();
|
|
if vertices > POINTS_PER_LINE {
|
|
let heading = object_heading(object, "path");
|
|
let width = object
|
|
.width
|
|
.map_or_else(|| "absent".to_string(), |width| format!("{width} dbu"));
|
|
writeln!(
|
|
out,
|
|
"{heading} · width {width} · {vertices} vertices · bounds ({xmin}, {ymin}) to ({xmax}, {ymax}) dbu"
|
|
)
|
|
.unwrap();
|
|
return;
|
|
}
|
|
}
|
|
writeln!(out, "{object}").unwrap();
|
|
}
|
|
|
|
fn vertex_count(xy: &[u8]) -> usize {
|
|
XY::points(xy).len().saturating_sub(1)
|
|
}
|
|
|
|
fn rectangle_size(xy: &[u8]) -> Option<[i64; 2]> {
|
|
let [xmin, ymin, xmax, ymax] = XY::closed_rectangle(xy)?;
|
|
Some([
|
|
i64::from(xmax) - i64::from(xmin),
|
|
i64::from(ymax) - i64::from(ymin),
|
|
])
|
|
}
|
|
|
|
fn translation(before: &[u8], after: &[u8]) -> Option<[i64; 2]> {
|
|
let mut old = XY::points(before);
|
|
let mut new = XY::points(after);
|
|
if old.len() != new.len() {
|
|
return None;
|
|
}
|
|
let (Some(a), Some(b)) = (old.next(), new.next()) else {
|
|
return None;
|
|
};
|
|
let displacement = |[x0, y0]: [i32; 2], [x1, y1]: [i32; 2]| {
|
|
[i64::from(x1) - i64::from(x0), i64::from(y1) - i64::from(y0)]
|
|
};
|
|
let shift = displacement(a, b);
|
|
(shift != [0, 0] && old.zip(new).all(|(a, b)| displacement(a, b) == shift)).then_some(shift)
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct ShapeCounts {
|
|
rectangles: usize,
|
|
polygons: usize,
|
|
boxes: usize,
|
|
}
|
|
|
|
impl ShapeCounts {
|
|
fn total(&self) -> usize {
|
|
self.rectangles + self.polygons + self.boxes
|
|
}
|
|
|
|
fn add(&mut self, object: &ObjectChange, replacement: Option<&ObjectChange>) {
|
|
let is_rectangle =
|
|
|object: &ObjectChange| XY::closed_rectangle(object_xy(object)).is_some();
|
|
match object.kind {
|
|
RTAG_BOX => self.boxes += 1,
|
|
_ if is_rectangle(object) && replacement.is_none_or(is_rectangle) => {
|
|
self.rectangles += 1
|
|
}
|
|
_ => self.polygons += 1,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct LayerPolygonChanges {
|
|
changed: ShapeCounts,
|
|
moved: ShapeCounts,
|
|
removed: ShapeCounts,
|
|
added: ShapeCounts,
|
|
displacement: Option<[i64; 2]>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct PolygonChanges(BTreeMap<Option<Layer>, LayerPolygonChanges>);
|
|
|
|
impl PolygonChanges {
|
|
pub fn replacement(&mut self, old: &ObjectChange, new: &ObjectChange) {
|
|
let counts = self.0.entry(old.layer).or_default();
|
|
let displacement = if old.properties == new.properties {
|
|
translation(object_xy(old), object_xy(new))
|
|
.filter(|_| field_changes(old, new).all(|(tag, _, _)| tag == RTAG_XY))
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(shift) = displacement {
|
|
counts.displacement = Some(shift);
|
|
counts.moved.add(old, Some(new));
|
|
} else {
|
|
counts.changed.add(old, Some(new));
|
|
}
|
|
}
|
|
|
|
pub fn unmatched(&mut self, object: &ObjectChange, removed: bool) {
|
|
let counts = self.0.entry(object.layer).or_default();
|
|
let shapes = if removed {
|
|
&mut counts.removed
|
|
} else {
|
|
&mut counts.added
|
|
};
|
|
shapes.add(object, None);
|
|
}
|
|
|
|
pub fn write(&self, out: &mut String, layers: &mut LayerRows<'_>) {
|
|
for (layer, counts) in &self.0 {
|
|
out.push_str(" ");
|
|
layers.record(*layer, out.len());
|
|
if let Some((layer, datatype)) = layer {
|
|
write!(out, "{layer}/{datatype}: ").unwrap();
|
|
} else {
|
|
out.push_str("unknown layer: ");
|
|
}
|
|
let groups = [
|
|
("changed", &counts.changed),
|
|
("moved", &counts.moved),
|
|
("removed", &counts.removed),
|
|
("added", &counts.added),
|
|
];
|
|
if let Some([dx, dy]) = counts.displacement
|
|
&& groups
|
|
.iter()
|
|
.map(|(_, shapes)| shapes.total())
|
|
.sum::<usize>()
|
|
== 1
|
|
{
|
|
let shape = if counts.moved.rectangles == 1 {
|
|
"rectangle"
|
|
} else if counts.moved.boxes == 1 {
|
|
"box"
|
|
} else {
|
|
"polygon"
|
|
};
|
|
writeln!(out, "{shape} moved by ({dx}, {dy}) dbu").unwrap();
|
|
continue;
|
|
}
|
|
let mut separator = "";
|
|
for (action, shapes) in groups {
|
|
let terms = [
|
|
(shapes.rectangles, "rectangle", "rectangles"),
|
|
(shapes.polygons, "polygon", "polygons"),
|
|
(shapes.boxes, "box", "boxes"),
|
|
]
|
|
.into_iter()
|
|
.filter(|(count, _, _)| *count != 0)
|
|
.map(|(count, singular, plural)| {
|
|
let shape = if count == 1 { singular } else { plural };
|
|
format!("{count} {shape}")
|
|
})
|
|
.collect::<Vec<_>>();
|
|
if !terms.is_empty() {
|
|
write!(out, "{separator}{} {action}", terms.join(", ")).unwrap();
|
|
separator = " · ";
|
|
}
|
|
}
|
|
out.push('\n');
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct ReferenceCounts {
|
|
singles: usize,
|
|
arrays: usize,
|
|
placements: u128,
|
|
}
|
|
|
|
impl ReferenceCounts {
|
|
pub fn add(&mut self, object: &ObjectChange) {
|
|
if object.kind == RTAG_AREF {
|
|
self.arrays += 1;
|
|
} else {
|
|
self.singles += 1;
|
|
}
|
|
self.placements += reference_placements(object);
|
|
}
|
|
|
|
pub fn write(&self, out: &mut String, sign: &str, target: &str, first: &ObjectChange) {
|
|
if self.len() == 1 {
|
|
writeln!(out, " {sign} {first}").unwrap();
|
|
return;
|
|
}
|
|
write!(out, " {sign} ").unwrap();
|
|
self.write_counts(out, "");
|
|
write!(out, " to {}", cell_label(target)).unwrap();
|
|
self.write_placements(out);
|
|
out.push('\n');
|
|
}
|
|
|
|
fn len(&self) -> usize {
|
|
self.singles + self.arrays
|
|
}
|
|
|
|
pub fn write_change(&self, out: &mut String, target: &str, added: &Self) {
|
|
write!(out, " {} · ", cell_label(target)).unwrap();
|
|
self.write_counts(out, "-");
|
|
self.write_placements(out);
|
|
out.push_str(", ");
|
|
added.write_counts(out, "+");
|
|
added.write_placements(out);
|
|
out.push('\n');
|
|
}
|
|
|
|
fn write_counts(&self, out: &mut String, sign: &str) {
|
|
if self.singles > 0 {
|
|
let suffix = if self.singles == 1 { "" } else { "s" };
|
|
write!(out, "{sign}{} ref{suffix}", self.singles).unwrap();
|
|
}
|
|
if self.arrays > 0 {
|
|
if self.singles > 0 {
|
|
out.push_str(", ");
|
|
}
|
|
let suffix = if self.arrays == 1 { "" } else { "s" };
|
|
write!(out, "{sign}{} array ref{suffix}", self.arrays).unwrap();
|
|
}
|
|
}
|
|
|
|
fn write_placements(&self, out: &mut String) {
|
|
if self.arrays > 0 {
|
|
let suffix = if self.placements == 1 { "" } else { "s" };
|
|
write!(out, " ({} placement{suffix})", self.placements).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn reference_placements(object: &ObjectChange) -> u128 {
|
|
match object.counts {
|
|
Some([columns, rows]) => u128::from(columns) * u128::from(rows),
|
|
None => 0,
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct ShownReferences {
|
|
shown: usize,
|
|
total: usize,
|
|
removed: u128,
|
|
added: u128,
|
|
row_start: usize,
|
|
}
|
|
|
|
impl ShownReferences {
|
|
pub fn replacement(&mut self, old: &ObjectChange, new: &ObjectChange, row_start: usize) {
|
|
self.shown += 2;
|
|
self.removed += reference_placements(old);
|
|
self.added += reference_placements(new);
|
|
self.row_start = row_start;
|
|
}
|
|
|
|
pub fn unmatched(
|
|
&mut self,
|
|
removed: &ReferenceCounts,
|
|
added: &ReferenceCounts,
|
|
row_start: usize,
|
|
) {
|
|
self.shown += removed.len() + added.len();
|
|
self.removed += removed.placements;
|
|
self.added += added.placements;
|
|
self.row_start = row_start;
|
|
}
|
|
|
|
pub fn count_change(&mut self) {
|
|
self.total += 1;
|
|
}
|
|
|
|
pub fn complete(&self) -> bool {
|
|
self.shown == self.total
|
|
}
|
|
|
|
pub fn annotate(&self, text: &str, annotations: &mut Vec<(usize, String)>, old: u64, new: u64) {
|
|
if (u128::from(old), u128::from(new)) == (self.removed, self.added) {
|
|
return;
|
|
}
|
|
let at = self.row_start + text[self.row_start..].find('\n').unwrap();
|
|
let totals = if old == new {
|
|
let suffix = if new == 1 { "" } else { "s" };
|
|
format!(" · {new} total placement{suffix}")
|
|
} else {
|
|
format!(" · placements {old} -> {new}")
|
|
};
|
|
annotations.push((at, totals));
|
|
}
|
|
}
|
|
|
|
pub(super) struct LayerRows<'a> {
|
|
names: &'a BTreeMap<Layer, String>,
|
|
name_changes: &'a [LayerNameChange],
|
|
rows: BTreeMap<Layer, Option<usize>>,
|
|
}
|
|
|
|
impl<'a> LayerRows<'a> {
|
|
pub fn new(names: &'a BTreeMap<Layer, String>, name_changes: &'a [LayerNameChange]) -> Self {
|
|
Self {
|
|
names,
|
|
name_changes,
|
|
rows: BTreeMap::new(),
|
|
}
|
|
}
|
|
|
|
fn write_transition_layer(&mut self, out: &mut String, layer: Layer, side: Side) {
|
|
self.record(Some(layer), out.len());
|
|
write!(out, "{}/{}", layer.0, layer.1).unwrap();
|
|
if let Ok(index) = self
|
|
.name_changes
|
|
.binary_search_by_key(&layer, |change| change.layer)
|
|
{
|
|
let change = &self.name_changes[index];
|
|
let name = match side {
|
|
Side::Old => &change.old,
|
|
Side::New => &change.new,
|
|
};
|
|
if let Some(name) = name {
|
|
write!(out, " ({})", cell_label(name)).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn record(&mut self, layer: Option<Layer>, row_start: usize) {
|
|
if let Some(layer) = layer
|
|
&& self.names.contains_key(&layer)
|
|
{
|
|
self.rows
|
|
.entry(layer)
|
|
.and_modify(|first| *first = None)
|
|
.or_insert(Some(row_start));
|
|
}
|
|
}
|
|
|
|
pub fn finish(self, text: &str, annotations: &mut Vec<(usize, String)>, legend: &mut String) {
|
|
for (layer, first) in self.rows {
|
|
let name = &self.names[&layer];
|
|
if let Some(at) = first {
|
|
let at = at
|
|
+ text[at..]
|
|
.bytes()
|
|
.take_while(|b| b.is_ascii_digit() || *b == b'/')
|
|
.count();
|
|
annotations.push((at, format!(" ({})", cell_label(name))));
|
|
} else {
|
|
writeln!(legend, "{}/{}: name {name:?}", layer.0, layer.1).unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn write_layer_transition(
|
|
out: &mut String,
|
|
old: &ObjectChange,
|
|
new: &ObjectChange,
|
|
layers: Option<&mut LayerRows<'_>>,
|
|
) {
|
|
let (from, to) = (old.layer.unwrap(), new.layer.unwrap());
|
|
if let Some(layers) = layers {
|
|
layers.write_transition_layer(out, from, Side::Old);
|
|
out.push_str(" → ");
|
|
layers.write_transition_layer(out, to, Side::New);
|
|
} else {
|
|
write!(out, "{}/{} → {}/{}", from.0, from.1, to.0, to.1).unwrap();
|
|
}
|
|
let rectangular = is_polygon(old.kind) && rectangle_size(object_xy(old)).is_some();
|
|
write!(out, " · {}", object_name(old.kind, rectangular)).unwrap();
|
|
}
|
|
|
|
fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String {
|
|
let before = object_xy(old);
|
|
let after = object_xy(new);
|
|
let old_size = rectangle_size(before);
|
|
let new_size = rectangle_size(after);
|
|
let mut out = polygon_heading(old, old_size.is_some() && new_size.is_some());
|
|
if before == after {
|
|
out.push_str(" modified");
|
|
} else {
|
|
match (old_size, new_size) {
|
|
(Some(a), Some(b)) if a == b => out.push_str(" moved"),
|
|
(Some([w0, h0]), Some([w1, h1])) => {
|
|
write!(out, " dimensions changed ({w0} x {h0} -> {w1} x {h1} dbu)").unwrap();
|
|
}
|
|
_ if translation(before, after).is_some() => out.push_str(" moved"),
|
|
_ => {
|
|
out.push_str(" vertices changed");
|
|
let (a, b) = (vertex_count(before), vertex_count(after));
|
|
if a != b {
|
|
write!(out, " ({a} -> {b} vertices)").unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
pub(super) fn replacement_summary(old: &ObjectChange, new: &ObjectChange) -> String {
|
|
if old.layer != new.layer && old.layer.is_some() && new.layer.is_some() {
|
|
let mut out = String::new();
|
|
write_layer_transition(&mut out, old, new, None);
|
|
return out;
|
|
}
|
|
let polygon = is_polygon(old.kind);
|
|
let mut out = if polygon {
|
|
polygon_replacement(old, new)
|
|
} else {
|
|
let mut heading = object_heading(old, object_name(old.kind, false));
|
|
if let Some(target) = &old.target {
|
|
write!(heading, " {target:?}").unwrap();
|
|
}
|
|
heading
|
|
};
|
|
|
|
let mut separator = if polygon { "\n " } else { " " };
|
|
for (tag, before, after) in field_changes(old, new) {
|
|
if polygon && tag == RTAG_XY {
|
|
continue;
|
|
}
|
|
let change = match (tag, before, after) {
|
|
(RTAG_XY, Some(a), Some(b)) => {
|
|
if let Some([dx, dy]) = translation(a, b) {
|
|
format!("moved by ({dx}, {dy}) dbu")
|
|
} else if matches!(old.kind, RTAG_PATH | RTAG_NODE) {
|
|
let (a, b) = (XY::points(a).len(), XY::points(b).len());
|
|
if a == b {
|
|
"vertices changed".to_string()
|
|
} else {
|
|
format!("vertices changed ({a} -> {b} vertices)")
|
|
}
|
|
} else {
|
|
let points = |data: &[u8]| XY::points(data).collect::<Vec<_>>();
|
|
format!("coordinates {:?} -> {:?} dbu", points(a), points(b))
|
|
}
|
|
}
|
|
(RTAG_COLROW, _, _) if old.kind == RTAG_AREF => {
|
|
let counts = |dimensions: Option<[u16; 2]>| {
|
|
dimensions.map_or_else(|| "absent".to_string(), |[a, b]| format!("{a} x {b}"))
|
|
};
|
|
format!(
|
|
"columns/rows {} -> {}",
|
|
counts(old.counts),
|
|
counts(new.counts)
|
|
)
|
|
}
|
|
(RTAG_WIDTH, _, _) => {
|
|
let width =
|
|
|n: Option<i32>| n.map_or_else(|| "absent".to_string(), |n| n.to_string());
|
|
format!("width {} -> {} dbu", width(old.width), width(new.width))
|
|
}
|
|
_ => {
|
|
let name = if tag == RTAG_STRING {
|
|
"text".to_string()
|
|
} else {
|
|
tag_name(tag)
|
|
};
|
|
format!("{name} {}", format_field_change(tag, before, after))
|
|
}
|
|
};
|
|
write!(out, "{separator}{change}").unwrap();
|
|
separator = "\n ";
|
|
}
|
|
if old.properties != new.properties {
|
|
let properties = |items: &[(u16, Vec<u8>)]| {
|
|
items
|
|
.iter()
|
|
.map(|(attribute, value)| format!("{attribute}={}", quoted(value)))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
write!(
|
|
out,
|
|
"{separator}properties [{}] -> [{}]",
|
|
properties(&old.properties),
|
|
properties(&new.properties)
|
|
)
|
|
.unwrap();
|
|
}
|
|
out
|
|
}
|