From 0316160395d69e350702e5b0d4568dbe8b464743 Mon Sep 17 00:00:00 2001 From: Levi Neuwirth Date: Thu, 2 Jul 2026 21:55:26 -0400 Subject: [PATCH] Phase 3 tranche 1: casting-off, K1 schema-fill, value-restoring undo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The chosen Phase-3 attack, run as two parallel waves. 829 workspace tests pass; clippy -D warnings, fmt, and rustdoc clean; all three spec documents build with zero undefined references. Casting-off (epiphany-engrave/src/casting.rs, wired into the Engraver): - Greedy first-fit system breaking per region at measure-start barline columns; a measure that would overflow the content width starts a new system. Hard SystemBreakAt/PageBreakAt always honoured; soft breaks honoured unless pathological (skipped with the spec's warning + IrOverride-recorded decision). - Vertical stacking from real content extents with the inter-system gap read from the vertical band model; page overflow starts the next page. World frame: pages stacked vertically, coordinates baked into glyphs/strokes, so the SVG renderer, hit-testing, and the GUI viewport are unchanged. - Real ResolvedPage/ResolvedSystem trees (1-based page numbers, content bounding boxes, staves from staff-line segments, measures from barline columns); every chosen break appends an EngravingDecision with MUSCLOID EngravedBreak provenance, UserOverride-attributed via the new ConstrainedLayoutIR break_origins sidecar; staff lines split per system with synthesized continuation provenance. - Break-constraint evaluation flips: satisfied iff the layout breaks at the slot. The two single-system tests invert deliberately (a hard break is now honoured; a user break is honoured and attributed instead of warned). Geometric constraints evaluate in the pre-casting spaced frame (documented). - Page geometry is engraver-side PageGeometry (A4 portrait at an 8 mm staff: page 105 x 148.5 staff spaces, margins 7.5, content 90 x 133.5; arithmetic documented) — Canvas.layout_defaults has no graph home and is a schema-major addition (P12-I7). ENGRAVER_VERSION = 2. Goldens regenerated: ten_measure_single_staff engraves as 2 systems (viewBox 84x20.6, was 103x11); valid_score_rich as 3 systems; stub goldens byte-identical. K1 schema-fill (Operation Catalog 0.4.0 -> 0.5.0, ratified first; wire discriminants strictly appended): - CreateStaff (24 / tag InsertStaff 24): set-union mint of a global Staff; CreateStaffInstance now preconditions that its referenced staff is live. - SetTimeSignature (25): value-carrying meter-change LWW keyed by (region, resolved position); the carried TimeSignature mints set-union; StructuralFieldCollision on meter_sequence. - SetTempoSegment (26): LWW keyed by (scope, resolved start) over the score or region tempo map; a write that would malform the map refuses with the appended PreconditionFailureReason 11 (TempoMapMalformed). - SetStaffLayout (27): LWW advisory over the staff instance's three inline layout fields. - Create score/canvas remain deliberately unavailable slots: the root and canvas are inline singletons with no addressable object model (P12-K8), not force-designed. Value-restoring undo (P11-C8 narrowed; catalog §UndoTransaction rewritten and per-primitive undo notes updated): - Canonical-order write chains (base-seeded) across all eleven LWW families. StrictInverse restores each written key to its chain-predecessor value iff the transaction's write is still the key's last writer, else refuses the whole undo with a TransactionConflict naming the superseder; BestEffort restores the still-last keys. Clean compensations are Applied; only minted- object tombstone repairs ride AppliedWithRepair (no new repair vocabulary). Mixed mint+overwrite transactions compose; strand guards refuse tombstoning mints still referenced by live non-members. - Undo-of-undo pinned and tested: restorations are chain writes, so undoing the undo's transaction restores the undone value, and a second undo of the same transaction conflicts (absence-restores repeat idempotently — documented asymmetry, P12-K11). - Permutation invariance pinned across five delivery orders; the convergence generators gain the new ops and a tx-then-undo flow. - Still deferred in normative text: delete resurrection (needs a system-derived tag outside the ratified closed set), Transpose inversion (P12-K2), Cascade dependent closure. Trackers: Binary Format companion 0.1.0 -> 0.2.0 (appended wire/tag tables, PreconditionFailureReason 11, payload layouts, history row — a schema-minor evolution under its own rules); nine new Pass-12 rows (C5, K8-K11, I7-I10); core-spec OperationKind listing gains the four kinds; revision-history rows in core spec and companion. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01NEs4aYiu8MXjdYdMxw8PTd --- crates/epiphany-core/src/codec.rs | 9 + crates/epiphany-editor-core/src/barriers.rs | 29 + crates/epiphany-editor-core/src/lib.rs | 84 + crates/epiphany-editor-gui/src/main.rs | 6 +- crates/epiphany-engrave/Cargo.toml | 10 +- crates/epiphany-engrave/DECISIONS.md | 160 +- crates/epiphany-engrave/README.md | 43 +- crates/epiphany-engrave/src/casting.rs | 1187 +++++++++ crates/epiphany-engrave/src/lib.rs | 853 ++++-- crates/epiphany-engrave/src/spacing.rs | 6 +- crates/epiphany-layout-ir/DECISIONS.md | 29 + crates/epiphany-layout-ir/src/barrier.rs | 7 +- crates/epiphany-layout-ir/src/constrained.rs | 62 +- crates/epiphany-layout-ir/src/lib.rs | 12 +- crates/epiphany-layout-ir/src/provenance.rs | 38 + crates/epiphany-layout-ir/src/roundtrip.rs | 43 +- crates/epiphany-layout-ir/src/solver.rs | 2 + crates/epiphany-ops/DECISIONS.md | 133 + crates/epiphany-ops/src/decode.rs | 1 + crates/epiphany-ops/src/effect.rs | 7 + crates/epiphany-ops/src/fuzz.rs | 65 +- crates/epiphany-ops/src/lib.rs | 11 +- crates/epiphany-ops/src/migrate.rs | 10 + crates/epiphany-ops/src/payload.rs | 264 +- crates/epiphany-ops/src/reduce.rs | 2326 ++++++++++++++++- crates/epiphany-ops/src/v0.rs | 5 + crates/epiphany-ops/src/validate.rs | 8 + crates/epiphany-ops/src/valuegen.rs | 68 + crates/epiphany-ops/tests/graph_reduction.rs | 914 ++++++- .../examples/render_fixture.rs | 5 +- .../epiphany-render-svg/tests/acceptance.rs | 4 +- ..._measure_single_staff.engrave.snapshot.txt | 6 +- .../ten_measure_single_staff.engrave.svg | 293 ++- .../valid_score_rich.engrave.snapshot.txt | 2 +- .../tests/golden/valid_score_rich.engrave.svg | 102 +- crates/epiphany-testkit/src/generators.rs | 210 +- crates/epiphany-testkit/src/layout_stub.rs | 1 + spec/PASS12_BATCH.md | 15 +- spec/binary_format.pdf | Bin 200616 -> 203014 bytes spec/binary_format.tex | 51 +- spec/core_spec.pdf | Bin 1273973 -> 1275330 bytes spec/core_spec.tex | 25 + spec/operation_catalog.pdf | Bin 98975 -> 110162 bytes spec/operation_catalog.tex | 236 +- 44 files changed, 6700 insertions(+), 642 deletions(-) create mode 100644 crates/epiphany-engrave/src/casting.rs diff --git a/crates/epiphany-core/src/codec.rs b/crates/epiphany-core/src/codec.rs index a1b09e6..036670a 100644 --- a/crates/epiphany-core/src/codec.rs +++ b/crates/epiphany-core/src/codec.rs @@ -2124,6 +2124,15 @@ canonical_value! { // Score settings (M2d) — value-typed set-* payloads embed these. ScoreMetadata, MetricGrid, + // Phase-3 ops tranche — value-typed create/set payloads embed these. + // `TimeSignature::dec` re-validates the beat-group sum through + // `TimeSignature::new` (the "reject at construction *and* at decode" + // discipline the operation catalog's §"Meter and Tempo Overwrites" + // requires), so a malformed value never round-trips. + Staff, + TimeSignature, + TempoSegment, + StaffLineConfiguration, } #[cfg(test)] diff --git a/crates/epiphany-editor-core/src/barriers.rs b/crates/epiphany-editor-core/src/barriers.rs index 30328d5..673725d 100644 --- a/crates/epiphany-editor-core/src/barriers.rs +++ b/crates/epiphany-editor-core/src/barriers.rs @@ -378,6 +378,35 @@ pub(crate) fn subjects_of(kind: &OperationKind, score: &Score) -> BarrierSubject ctx(location.map(|(r, _)| r), location.map(|(_, si)| si)), ) } + // Phase-3 first tranche. A staff is a global (score-root) object with + // no regional containment; a meter overwrite edits its region's grid + // slot and names the carried signature it mints; a tempo overwrite + // names its region scope (the score-level map is score-wide state); a + // layout overwrite names its staff instance. + OperationKind::CreateStaff(op) => { + one(TypedObjectId::Staff(op.staff_id()), EditContext::default()) + } + OperationKind::SetTimeSignature(op) => { + let mut objects = vec![(TypedObjectId::Region(op.region), ctx(Some(op.region), None))]; + if let Some(signature) = &op.time_signature { + objects.push(( + TypedObjectId::TimeSignature(signature.id), + ctx(Some(op.region), None), + )); + } + BarrierSubjects::Objects(objects) + } + OperationKind::SetTempoSegment(op) => match op.region { + Some(region) => one(TypedObjectId::Region(region), ctx(Some(region), None)), + None => BarrierSubjects::ScoreWide, + }, + OperationKind::SetStaffLayout(op) => one( + TypedObjectId::StaffInstance(op.staff_instance), + ctx( + region_of_staff_instance(score, op.staff_instance), + Some(op.staff_instance), + ), + ), OperationKind::SetMetadata(_) | OperationKind::DeclareTransaction(_) => { BarrierSubjects::ScoreWide } diff --git a/crates/epiphany-editor-core/src/lib.rs b/crates/epiphany-editor-core/src/lib.rs index 25c92de..db320df 100644 --- a/crates/epiphany-editor-core/src/lib.rs +++ b/crates/epiphany-editor-core/src/lib.rs @@ -5233,6 +5233,90 @@ mod tests { .expect("an Event target does not match a Pitch-kind barrier"); } + #[test] + fn phase3_operation_kinds_derive_subjects_and_gate_on_barriers() { + // The Phase-3 tranche (CreateStaff / SetTimeSignature / SetTempoSegment + // / SetStaffLayout) participates in the barrier gate: a whole-score + // barrier naming each tag refuses the matching edit before minting. + let mut session = open_plain(7); + let region = session.score().canvas.regions[0].id; + let instance = session.score().canvas.regions[0].staff_instances()[0].id; + let staff = session.score().staves[0].id; + let instrument = session.score().staves[0].instrument; + let anchor = epiphany_core::TimeAnchor::Region { + id: region, + edge: epiphany_core::RegionEdge::Start, + offset: epiphany_core::AnchorOffset::Zero, + }; + let edits: Vec<(OperationKindTag, OperationKind)> = vec![ + ( + OperationKindTag::InsertStaff, + OperationKind::CreateStaff(epiphany_ops::CreateStaffOp { + staff: epiphany_ops::valuegen::staff(staff, instrument), + }), + ), + ( + OperationKindTag::SetTimeSignature, + OperationKind::SetTimeSignature(epiphany_ops::SetTimeSignatureOp { + region, + anchor: anchor.clone(), + time_signature: None, + }), + ), + ( + OperationKindTag::SetTempoSegment, + OperationKind::SetTempoSegment(epiphany_ops::SetTempoSegmentOp { + region: Some(region), + start: anchor, + segment: None, + }), + ), + ( + OperationKindTag::SetStaffLayout, + OperationKind::SetStaffLayout(epiphany_ops::SetStaffLayoutOp { + staff_instance: instance, + instrument_override: None, + staff_lines_override: None, + visible: false, + }), + ), + ]; + for (tag, kind) in &edits { + session.set_active_extensions(vec![extension_prohibiting(0xE7, *tag)]); + assert_eq!( + session.apply(kind.clone()), + Err(EditorError::BarrierProhibited { + extension: ExtensionRef(0xE7), + operation: *tag, + }), + "a whole-score barrier naming {tag:?} must refuse the edit" + ); + } + assert!(session.applied_operations().is_empty()); + + // With no barriers active, the layout advisory applies end to end (the + // spec declares no advisory preconditions for the tranche). + session.set_active_extensions(vec![]); + session + .apply(OperationKind::SetStaffLayout( + epiphany_ops::SetStaffLayoutOp { + staff_instance: instance, + instrument_override: None, + staff_lines_override: None, + visible: false, + }, + )) + .expect("an unbarred layout write applies"); + let materialized = session + .score() + .staff_instances() + .find(|(_, si)| si.id == instance) + .expect("instance survives") + .1 + .clone(); + assert!(!materialized.visible); + } + #[test] fn an_unsafe_edit_crosses_the_barrier_and_records_the_tombstone_obligation() { let mut session = open_plain(7); diff --git a/crates/epiphany-editor-gui/src/main.rs b/crates/epiphany-editor-gui/src/main.rs index c6a79ac..cb3d4b1 100644 --- a/crates/epiphany-editor-gui/src/main.rs +++ b/crates/epiphany-editor-gui/src/main.rs @@ -123,6 +123,10 @@ fn payload_label(payload: &OperationPayload) -> &'static str { OperationKind::InsertEvent(_) => "InsertEvent", OperationKind::RespellPitch(_) => "RespellPitch", OperationKind::DeclareTransaction(_) => "DeclareTransaction", + OperationKind::CreateStaff(_) => "CreateStaff", + OperationKind::SetTimeSignature(_) => "SetTimeSignature", + OperationKind::SetTempoSegment(_) => "SetTempoSegment", + OperationKind::SetStaffLayout(_) => "SetStaffLayout", _ => "primitive", }, OperationPayload::ResolveConflict(_) => "ResolveConflict", @@ -176,7 +180,7 @@ struct EditorApp { impl EditorApp { fn new() -> Self { let score = epiphany_testkit::fixtures::ten_measure_single_staff(0); - let session = EditorSession::open(score, Box::new(Engraver)) + let session = EditorSession::open(score, Box::new(Engraver::default())) .expect("the ten-measure fixture renders under the real engraver"); EditorApp { session, diff --git a/crates/epiphany-engrave/Cargo.toml b/crates/epiphany-engrave/Cargo.toml index dda1df1..50c1981 100644 --- a/crates/epiphany-engrave/Cargo.toml +++ b/crates/epiphany-engrave/Cargo.toml @@ -5,18 +5,18 @@ edition.workspace = true rust-version.workspace = true authors.workspace = true repository.workspace = true -description = "Agent I's Epiphany engraving solver (spec Chapter 9): turns a ConstrainedLayoutIR into a ResolvedLayoutIR with real geometry. A deterministic horizontal-spacing pass (the first axis of the planned two-pass spring layout) that evaluates the declared hard constraints and reports SolverTier::Minimal. The vertical spring pass and casting-off are deferred to a later tier." +description = "Agent I's Epiphany engraving solver (spec Chapter 9): turns a ConstrainedLayoutIR into a ResolvedLayoutIR with real geometry. A deterministic horizontal-spacing pass plus Minimal-tier casting-off (greedy system breaking at measure boundaries, vertical system stacking, page assignment) that evaluates the declared hard constraints — break constraints included — and reports SolverTier::Minimal." [dependencies] # The solver consumes/produces the Chapter 7 IR stages and implements the # Chapter 9 `ConstraintSolver` interface — all defined in epiphany-layout-ir, -# which re-exports the epiphany-core ids/types the solver references. +# which re-exports most of the epiphany-core ids/types the solver references. epiphany-layout-ir.workspace = true +# The casting-off pass matches provenance sources by their typed id (staves for +# per-system staff records, measures for per-system measure records). +epiphany-core.workspace = true [dev-dependencies] -# Tests drive the solver from real score fixtures via epiphany-core's generators -# (and a couple of leaf id/time types). -epiphany-core.workspace = true # The criterion-6 round-trip test mirrors the hand-off gate's fixtures, including # epiphany-testkit's `ten_measure_single_staff` (testkit does not depend on this # crate, so this dev-dep introduces no cycle). diff --git a/crates/epiphany-engrave/DECISIONS.md b/crates/epiphany-engrave/DECISIONS.md index c7cb974..e48e4f3 100644 --- a/crates/epiphany-engrave/DECISIONS.md +++ b/crates/epiphany-engrave/DECISIONS.md @@ -15,26 +15,30 @@ on the product side of the spec's core/product boundary, so replacing the `StubSolver` *inside* `layout-ir` would blur it (`spec/PHASE2_QUICKSTART.md`, crate topology). -**This phase ships the renderer-against-stub slice** (QUICKSTART, Agent I, +**Phase 2 shipped the renderer-against-stub slice** (QUICKSTART, Agent I, "Development pattern": build the renderer against the stub solver first, then -grow the real solver). So this crate is an **honest scaffold**: `Engraver` runs a -genuine deterministic *horizontal spacing pass* — the first axis of the planned -two-pass spring layout — placing each spring slot left-to-right by its preferred -width, rather than echoing the stub's input columns. It does **not yet** run the -vertical pass, the soft-spring stretch/compress solve, or evaluate the IR's -declared hard constraints. +grow the real solver): a genuine deterministic *horizontal spacing pass* — the +first axis of the planned two-pass spring layout — later joined by real +hard-constraint evaluation (which earned the `Minimal` tier). + +**Phase 3's layout track adds CASTING-OFF** (see "Casting-off (2026-07)" below): +greedy system breaking at measure boundaries, vertical system stacking, page +assignment, a populated `ResolvedPage`/`ResolvedSystem` tree, and full break- +constraint evaluation. Still deferred: the vertical soft-spring solve within a +system, per-system justification/stretch, and optimal break search. ### Honest tier By the same rule `layout-ir`'s `StubSolver` follows, a solver that does not evaluate the declared hard constraints and computes no quality metrics MUST report `SolverTier::Stub`, never `Minimal` (Chapter 9 §"Conformance Tiers"). -`Engraver::tier()` therefore reports `Stub` today; it is promoted to `Minimal` in -the same change that lands real hard-constraint satisfaction. A regression test -(`reports_the_honest_stub_tier_until_it_earns_minimal`) guards this so the tier -cannot be silently inflated. The quality-metric vector stays the conservative +`Engraver::tier()` reported `Stub` until real hard-constraint satisfaction +landed and now reports `Minimal` — which it fully earns after casting-off: the +break constraint family is genuinely supported (spec §"Conformance Tiers", +Minimal row), and `Minimal` makes no optimality claim, so greedy first-fit +casting-off is legitimate. The quality-metric vector stays the conservative all-worst placeholder (`QualityMetricVector::unmeasured`) until the Quality Metric -Catalog lands (Phase 3, explicitly out of Agent I's scope). +Catalog lands (`Standard` tier work). ## Implementation decisions (QUICKSTART "Decisions you'll need to make") @@ -69,6 +73,106 @@ Catalog lands (Phase 3, explicitly out of Agent I's scope). layer; it changes only `position`.** It assigns each glyph the `x` of its spring slot and keeps its baseline `y` (the vertical pass is future work). +## Casting-off (2026-07) — decisions + +1. **Greedy first-fit system breaking, at measure boundaries.** The casting-off + walk visits each region's spaced spring-slot columns in x order and breaks + before a **barline column** (this projection draws each measure's barline at + its *start* column, so breaking before the barline keeps every measure + intact; the region-final barline closes the region and is never a + candidate) whenever the measure beginning there would overflow the page + content width. Rationale: `SolverTier::Minimal` requires the break family + supported and hard constraints satisfied, with **no optimality claim** + (Chapter 9 §"Conformance Tiers"), so an optimal (Knuth–Plass-style) search + is deliberately rejected at this tier — greedy first-fit is deterministic, + linear, and easy to validate. Consequences accepted and documented: + a region with no measures never wraps automatically; a single measure wider + than the page yields an overfull system (no mid-measure emergency break). +2. **Break-constraint semantics: "breaks at slot S" ⇔ S starts a system.** A + `SystemBreakAt`/`PageBreakAt` is satisfied iff the final layout starts a + system/page at that slot (a region's first slot is trivially at a + boundary). Hard breaks are always honoured (mid-measure if necessary — a + `Required` constraint binds absolutely); soft breaks are honoured unless + the closing system would carry **no musical content** (no notehead/rest + column) — the pathological path: the break is skipped, the soft violation + warned, and the unhonoured preference recorded as an + `EngravingDecision` with `DecisionSource::IrOverride` (spec's + override-resolution rule: record, never silently drop). +3. **Frame of constraint evaluation.** Geometric constraints (no-collision, + alignment, position-within) are evaluated against the **pre-casting spaced + geometry** — the frame they are expressed in. Casting-off then relocates + whole systems by per-system rigid motions, which cannot un-satisfy an + intra-system geometric obligation; evaluating post-casting would instead + make *every* `PositionWithin` (whose rect pins the region's source-frame + vertical envelope) unsatisfiable for any casting-off solver, which cannot + be the spec's intent. Break constraints are evaluated against the **final + break structure**. +4. **Page geometry is an engraver parameter (`PageGeometry`), defaulted to A4 + at an 8 mm staff.** The spec names `Canvas.layout_defaults` ("paper size, + margins") but never defines the type, and core does not implement it; + adding a graph field now would violate the companion's frozen-layout rule, + so the graph home (`CanvasLayoutDefaults`) is **staged to the data-model + schema major** and the engraver takes the geometry as a constructor + parameter. Default arithmetic (1 staff space = staff height / 4 = 2.0 mm at + an 8 mm staff): A4 210 × 297 mm → **105 × 148.5** staff spaces; 15 mm + margins → **7.5** staff spaces; content area 180 × 267 mm → **90 × 133.5** + staff spaces. 90 staff spaces wraps the ten-measure hand-off fixture + (≈ 99 staff spaces spaced) into two systems — an honest multi-system + default golden. +5. **World-frame convention: pages stacked vertically in one world.** Page 1's + top-left corner sits at the origin; page *n*'s frame begins a full page + height plus `INTER_PAGE_GAP` (8 staff spaces, a presentation constant) + below page *n − 1*'s. Every glyph/stroke position is **baked** into this + single y-up world frame (per-system rigid translation: x back to the left + margin, y to the stacked position), so the SVG renderer and the hit-test + map work unchanged on the flat lists — no per-page transform exists + anywhere downstream. The inter-*system* gap is read from + `VerticalBand::inter_system_gap` (preferred 4.0 staff spaces), so the + casting-off gap and the band model cannot drift. +6. **System-spanning strokes are split; the split is provenance-honest.** The + five staff lines span the whole region; a break cuts them at the systems' + content edges. The first segment keeps the original stroke's exact + provenance (round-trip preservation); each later segment is synthesized + (`SynthesisKind::Registered(SYSTEM_CONTINUATION_SYNTHESIS)`, the codebase's + convention for kinds the normative vocabulary does not name) with a + `continuation_instance_key(original stable id, ordinal)` instance key. The + round-trip contract in `layout-ir` was relaxed accordingly (containment + + declared-synthesis additions; the stub still must add nothing). +7. **Engraved-break decisions.** Every chosen system/page break appends an + `EngravingDecision` whose **target** is the `MUSCLOID` id synthesized from + the owning region's source under `SynthesisKind::EngravedBreak`, keyed by + the breaking slot's (content-derived) identity. Source attribution: + `UserOverride(id)` when the break constraint was projected from a user + break override (the id flows through the new + `ConstrainedLayoutIR.break_origins`), else `Automatic`; a skipped soft + break records `IrOverride`. A boundary that actually opens a page records + `PageBreak`; a later page opening at a region's own first system records + `PageBreak` too; other boundaries record `SystemBreak`. +8. **Inverted tests.** Two tests that pinned the single-system semantics were + deliberately inverted and renamed: + `a_hard_break_cannot_be_honoured_by_single_system_minimal` → + `a_hard_break_is_honoured_by_casting_off` (Unsatisfiable → Solved with the + system count increasing), and + `a_users_break_flows_to_a_soft_violation_not_a_failure` → + `a_users_break_is_honoured_and_recorded_with_its_override` (soft-violation + warning → clean Solved, break at the anchor's column, decision recorded + with the user's override id). The pathological-soft path keeps the old + warning semantics under a new, honest name + (`a_pathological_soft_break_is_skipped_and_recorded_as_ir_override`). +9. **Deferred refinements** (named, not implied): per-system justification + (stretching the soft springs so every full system ends at the right + margin); the vertical spring solve (band heights are carried, not yet + renegotiated; systems stack by real content extents); widow/orphan control + and optimal/lookahead casting-off quality (a `Standard`-tier concern, with + `casting_off_quality` in the metric vector); casting-off caching / + incremental re-cast (the spec's incremental-layout section names the + casting-off cache; `solve_incremental` currently re-solves from scratch, + which remains observationally equivalent); per-system clef/key restatement + (cautionary signatures at system starts, `SynthesisKind::Cautionary`); + multi-system-aware x→time inversion for editor click-to-insert + (`epiphany-editor-core`'s `position_at` interpolates one global x axis and + is correct only within the first system of a wrapped region). + ## Pass 12 candidates See `spec/PASS12_BATCH.md` (rows P12-I1, P12-I2, P12-I3) — all three are now @@ -85,3 +189,35 @@ resolved: - **P12-I3 (resolved by I-4a)** — `BRAVURA_METRICS` is re-extracted from the same SHA-pinned `bravura-1.392` font the outlines come from, with bboxes rounded outward to contain the drawn ink (a `render-svg` test proves containment). + +### New candidates from the casting-off slice (proposed rows; spec not edited) + +- **P12 (proposed) — `Canvas.layout_defaults` is named but never defined.** The + spec references layout defaults ("paper size, margins") on the canvas, but no + chapter defines the type, its units, or its defaulting rules, and the core + graph does not carry it. Proposal: define `CanvasLayoutDefaults { page_size: + Size2D, margins: Margins }` in staff spaces in the data-model chapter, + staged to the **data-model schema major** (adding the field changes the + canonical graph encoding); until then, page geometry is a solver parameter + (this crate's `PageGeometry`) and the spec should say a solver MAY default + it. +- **P12 (proposed) — break-constraint satisfaction semantics.** Chapter 7 + defines `SystemBreakAt { slot }` but not what geometric fact makes it + *satisfied*. This crate pins: satisfied iff the final layout **starts a + system at that slot** (page analog for `PageBreakAt`); a region's first slot + is trivially at a boundary. The spec should ratify (or correct) this + predicate, since `Unsatisfiable`-vs-`Solved` conformance hangs on it. +- **P12 (proposed) — user-override attribution across IR stages.** The decision + record for an honoured break must cite `DecisionSource::UserOverride(id)`, + but the normative `LayoutConstraint` carries no origin, so the override id + has no channel from the logical stage's `EngravingOverride` to the solver. + This implementation carries a non-canonical `break_origins` sidecar on + `ConstrainedLayoutIR`; the spec should bless that channel (or widen the + normalized constraint record). +- **P12 (proposed) — synthesis kind for split continuations.** Casting-off + splits region-spanning strokes (staff lines) at system boundaries; the + segments in later systems are engraver-synthesized objects whose kind the + normative `SynthesisKind` set does not name (`EngravedBreak` is the break + itself, not its artefacts). Carried as + `Registered(SYSTEM_CONTINUATION_SYNTHESIS)`; the spec should either add a + continuation kind or bless the registered id. diff --git a/crates/epiphany-engrave/README.md b/crates/epiphany-engrave/README.md index 1879bfe..8b678ae 100644 --- a/crates/epiphany-engrave/README.md +++ b/crates/epiphany-engrave/README.md @@ -6,29 +6,38 @@ production-side replacement for `epiphany-layout-ir`'s interface-only `StubSolver`; the two live in separate crates so the spec's core/product boundary stays sharp. -## Status: honest scaffold (renderer-against-stub phase) - -Per the QUICKSTART development pattern, Agent I builds the SVG renderer -([`epiphany-render-svg`](../epiphany-render-svg)) against the **stub solver** -first, then grows this crate into the real two-pass spring solver. This commit is -the first increment: +## Status: `Minimal` tier, with casting-off - `Engraver` runs a deterministic **horizontal spacing pass** (the first axis of - the planned two-pass spring layout): each spring slot is placed left-to-right by - its preferred width instead of being echoed verbatim. -- It honestly reports `SolverTier::Stub` — it does not yet evaluate the IR's - declared hard constraints or compute quality metrics, so it has not earned - `Minimal`. It is promoted to `Minimal` in the change that lands real constraint - satisfaction. + the two-pass spring layout): each spring slot is placed left-to-right by a + collision-aware advance derived from real glyph bearings. +- A **casting-off pass** (Phase 3's layout track) then breaks the spaced line + into **systems** at measure boundaries (greedy first-fit against a + `PageGeometry` — default A4 portrait at an 8 mm staff), stacks systems + vertically at the vertical-band model's inter-system gap, assigns **pages** + by content height, and populates the real `ResolvedPage`/`ResolvedSystem` + tree. Every position is baked into a single y-up world frame (pages stacked + vertically), so the SVG renderer and hit-testing consume the flat + glyph/stroke lists unchanged. +- The IR's declared constraints are **evaluated** — geometric families against + the pre-casting spaced frame, break constraints against the final break + structure (hard breaks are always honoured; a pathological soft break is + skipped and recorded as an `IrOverride` decision). Chosen breaks are recorded + as `EngravingDecision`s with `SynthesisKind::EngravedBreak` targets, + attributed to the user override that requested them when one did. +- It reports `SolverTier::Minimal`: hard constraints (break family included) + satisfied, **no optimality claim** — the quality-metric vector stays the + honest all-worst placeholder until the Quality Metric Catalog lands. -The vertical spring pass, soft-constraint solve, hard-constraint evaluation, and -the quality-metric vector are the next-phase / Phase-3 work. See `DECISIONS.md`. +Deferred: the vertical soft-spring solve, per-system justification/stretch, +optimal break search, widow/orphan control, and casting-off caching. See +`DECISIONS.md`. ```rust use epiphany_engrave::Engraver; use epiphany_layout_ir::{ConstraintSolver, SolverConfig}; -let report = Engraver.solve(&constrained_ir, &SolverConfig::default()); -assert!(report.satisfied_hard_constraints); // for constraint-free stub-pipeline input -let resolved = report.layout; // hand to epiphany-render-svg +let report = Engraver::default().solve(&constrained_ir, &SolverConfig::default()); +assert!(report.satisfied_hard_constraints); +let resolved = report.layout; // real pages/systems; hand to epiphany-render-svg ``` diff --git a/crates/epiphany-engrave/src/casting.rs b/crates/epiphany-engrave/src/casting.rs new file mode 100644 index 0000000..12dbc4e --- /dev/null +++ b/crates/epiphany-engrave/src/casting.rs @@ -0,0 +1,1187 @@ +//! The **casting-off pass** — Minimal-tier system breaking, vertical stacking, +//! and page assignment (Chapter 9 §"The Constraint-Solving Stage": the solver +//! "resolve\[s\] page and system breaks"; Chapter 7 §"ResolvedLayoutIR" defines +//! the page/system tree this pass populates). +//! +//! ## The algorithm (greedy first-fit) +//! +//! [`SolverTier::Minimal`](epiphany_layout_ir::SolverTier) requires the break +//! constraint family to be supported and every hard constraint satisfied (or an +//! honest `Unsatisfiable`); it makes **no optimality claim**, so casting-off is +//! a deterministic greedy first-fit, not an optimal (Knuth–Plass-style) break +//! search: +//! +//! 1. **System breaking.** Per region, walk the spaced spring-slot columns in x +//! order. Break into systems at **measure boundaries** — the barline columns +//! (`to_constrained` draws each measure's barline at its start column; the +//! region-final barline closes the region and is never a break candidate) — +//! whenever the measure beginning at a barline would overflow the page +//! content width. A **hard** `SystemBreakAt`/`PageBreakAt` is *always* +//! honoured at its slot (the slot begins a new system/page); a **soft** one +//! is honoured unless doing so would close a system with no musical content +//! (no notehead/rest column) — the documented exceptional path, recorded as +//! an [`EngravingDecision`] with [`DecisionSource::IrOverride`] per the +//! spec's override-resolution rule (an unhonoured override is recorded, not +//! silently dropped). A region with no measures has no automatic break +//! candidates: it stays one (possibly overfull) system unless breaks force +//! otherwise. A single measure wider than the page yields an overfull +//! system — Minimal does not break mid-measure on its own. +//! 2. **Vertical stacking.** Each system's height is its real content extent +//! (glyph boxes plus stroke extents — the vertical spring solve that would +//! renegotiate band heights is deferred, so the constrained `y` geometry is +//! authoritative); consecutive systems are separated by the vertical-band +//! model's **inter-system gap** ([`VerticalBand::inter_system_gap`], the +//! preferred height — genuinely read from the band constructor so the two +//! cannot drift). Systems that no longer fit the page content height start +//! the next page. +//! 3. **Page assignment and the world frame.** Pages stack **vertically in one +//! world**: page *n*'s top edge sits [`INTER_PAGE_GAP`] staff spaces below +//! page *n−1*'s bottom edge, page 1's top-left corner at the origin (world +//! is y-up, so pages grow downward in −y). Every glyph and stroke position +//! is **baked** into this single world frame (each system is translated +//! rigidly: x back to the left margin, y to its stacked position), so the +//! flat glyph/stroke lists remain the renderer's and hit-tester's single +//! coordinate space — no per-page transform exists anywhere downstream. +//! +//! ## Region-spanning strokes +//! +//! A stroke confined to one system (a stem, a ledger, a barline-anchored mark) +//! translates rigidly with it. A stroke spanning several systems — in practice +//! the five staff lines, which `to_constrained` draws across the whole region — +//! is **split** at the system boundaries: the first segment keeps the original +//! stroke's exact provenance (so the round-trip's preservation contract holds), +//! and each later segment is engraver-**synthesized** from the same source +//! ([`SynthesisKind::Registered`] under [`SYSTEM_CONTINUATION_SYNTHESIS`], the +//! codebase's convention for a synthesis kind the normative vocabulary does not +//! name), keyed by [`continuation_instance_key`] so segments of different lines +//! can never collide. +//! +//! ## Default page geometry +//! +//! The spec names `Canvas.layout_defaults` ("paper size, margins") but does not +//! define its type, and the core graph deliberately does not carry it yet (the +//! graph home is staged to the data-model schema major — see `DECISIONS.md`), +//! so page geometry is an **engraver-side parameter** ([`PageGeometry`], a +//! constructor argument of [`crate::Engraver`]) with a documented default; see +//! [`PageGeometry::default`] for the arithmetic. + +use std::collections::{BTreeMap, BTreeSet}; + +use epiphany_core::{StaffId, TypedObjectId}; +use epiphany_layout_ir::{ + continuation_instance_key, is_rigid_width_stroke, synthesized_layout_id, BreakClass, BreakKind, + ConstrainedLayoutIR, DecisionSource, EngravingDecision, EngravingDecisionKind, + EngravingOverrideId, GlyphObjectId, LayoutConstraint, LayoutObjectId, Margins, Point, + Provenance, Rect, ResolvedGlyph, ResolvedMeasure, ResolvedPage, ResolvedStaff, ResolvedSystem, + Size2D, SpringSlotId, StaffSpace, Stroke, SynthesisInstanceKey, SynthesisKind, + SynthesisRegistryId, VerticalBand, VerticalBandId, +}; + +use crate::owning_glyph; + +/// The registry id for the engraver's **system-continuation synthesis**: the +/// segment of a region-spanning stroke (a staff line) that casting-off places +/// in a system after the stroke's first. The normative [`SynthesisKind`] set +/// names no purely visual continuation rule, so — like the constrained stage's +/// staff-line/ledger/accidental syntheses — it is carried as a `Registered` +/// extension kind (Chapter 7 §"Behavior Under Unknown Extensions"). +pub const SYSTEM_CONTINUATION_SYNTHESIS: SynthesisRegistryId = + SynthesisRegistryId(0x5359_5354_4D53_4547); // "SYSTMSEG" + +/// The vertical gap between consecutive **pages** in the single world frame, in +/// staff spaces. Pages are separate physical sheets; this gap exists only in +/// the continuous scroll-like world the renderer and hit-tester share, so it is +/// a presentation constant, not engraving geometry. +pub const INTER_PAGE_GAP: f32 = 8.0; + +/// Namespace bit for a synthesized *system* provenance instance key (a region's +/// second and later systems), disjoint from the page namespace below and — by +/// 128-bit-hash construction — from the slot-identity keys of break decisions. +const KEY_NS_SYSTEM: u128 = 1; +/// Namespace bit for a synthesized *page* provenance instance key. +const KEY_NS_PAGE: u128 = 2; + +/// Page geometry the engraver casts off against: the page size and margins, in +/// staff spaces (Chapter 7 §7.2: IR coordinates are staff spaces). A parameter +/// of [`crate::Engraver`] because the score graph has no home for it yet — the +/// spec's `Canvas.layout_defaults` is named but never defined, and adding a +/// graph field is a data-model schema-major change (see `DECISIONS.md`). +#[derive(Copy, Clone, PartialEq, Debug)] +pub struct PageGeometry { + /// Full page size, in staff spaces. + pub size: Size2D, + /// Page margins, in staff spaces. + pub margins: Margins, +} + +impl PageGeometry { + /// The horizontal content extent a system may fill: page width minus the + /// left and right margins. Non-positive geometry disables automatic + /// wrapping (treated as unbounded) rather than failing the solve. + pub fn content_width(&self) -> f32 { + self.size.width.0 - self.margins.left.0 - self.margins.right.0 + } + + /// The vertical content extent a page may fill: page height minus the top + /// and bottom margins. Non-positive geometry disables page overflow + /// (treated as unbounded) rather than failing the solve. + pub fn content_height(&self) -> f32 { + self.size.height.0 - self.margins.top.0 - self.margins.bottom.0 + } +} + +impl Default for PageGeometry { + /// **A4 portrait at an 8 mm staff height** (rastral ≈ size 1, a common + /// full-size instrumental-part raster), 15 mm margins. The arithmetic, with + /// 1 staff space = staff height / 4 = 2.0 mm: + /// + /// * page: 210 mm × 297 mm → **105 × 148.5** staff spaces; + /// * margins: 15 mm each → **7.5** staff spaces; + /// * content area: 180 mm × 267 mm → **90 × 133.5** staff spaces. + /// + /// 90 staff spaces of content width wraps the QUICKSTART's ten-measure + /// hand-off fixture (whose spaced width is ≈ 99 staff spaces) into two + /// systems — an honest multi-system default rather than one that only ever + /// produces the degenerate single line. + fn default() -> Self { + PageGeometry { + size: Size2D { + width: StaffSpace(105.0), + height: StaffSpace(148.5), + }, + margins: Margins { + top: StaffSpace(7.5), + right: StaffSpace(7.5), + bottom: StaffSpace(7.5), + left: StaffSpace(7.5), + }, + } + } +} + +/// What the casting-off pass produced: the final world-frame geometry, the +/// populated page/system tree, the engraver's appended break decisions, and the +/// break structure the constraint evaluation consults. +pub(crate) struct CastLayout { + /// Final glyphs, in input order, positions baked into the world frame. + pub glyphs: Vec, + /// Final strokes: the input strokes in order (each translated with its + /// system; a system-spanning stroke replaced by its first segment), then + /// the synthesized continuation segments. + pub strokes: Vec, + /// The populated page tree (empty when the input declares no regions). + pub pages: Vec, + /// Break decisions this pass made (chosen breaks in reading order, then + /// the skipped-soft `IrOverride` records in walk order). + pub decisions: Vec, + /// Slots at which the final layout breaks: the first slot of every system. + pub system_start_slots: BTreeSet, + /// Slots at which a page begins: the first slot of each page's first system. + pub page_start_slots: BTreeSet, +} + +/// One realized spring slot in spaced (pre-casting) coordinates, with the +/// classification the greedy walk needs. +struct SlotInfo { + id: SpringSlotId, + /// Reference x: the first member glyph's spaced baseline. + x: f32, + /// Leftmost content edge (member glyph boxes plus their rigid strokes). + lo: f32, + /// Rightmost content edge. + hi: f32, + /// Member glyph indices into the (parallel) input/spaced glyph vectors. + members: Vec, + /// The column carries a barline glyph — a measure boundary. + barline: bool, + /// The column carries the region-final barline (never a break candidate). + final_barline: bool, + /// The column carries musical content (a notehead or a rest). + note: bool, + /// The directly-manifested barline glyph of a measure *start* (glyph + /// index), for the per-system measure records. `None` at the final + /// barline: that measure's start is not marked by any column in this + /// projection, so its record is omitted rather than fabricated. + measure_barline: Option, +} + +/// A break requirement a constraint declares at a slot. +#[derive(Copy, Clone)] +struct BreakReq { + page: bool, + hard: bool, +} + +/// The boundary decision that opened a system (absent at a region's first). +#[derive(Copy, Clone)] +struct Boundary { + slot: SpringSlotId, + source: DecisionSource, +} + +/// One cast-off system: which region it slices and which of that region's +/// slots it carries. +struct SystemPlan { + region: usize, + /// Region-local ordinal (0-based). + local: usize, + /// Indices into the region's ordered slot vector. + slots: Vec, + boundary: Option, + /// A page must start at this system (a page-break request sits here). + page_forced: bool, + /// Attribution for a forced page start (the page-break decision's source). + page_source: DecisionSource, +} + +/// A stroke's casting fate: ride one system rigidly, or split at system +/// boundaries. +enum StrokeFate { + /// Translate the whole stroke with this system (`None`: not covered by any + /// region — left untransformed in the spaced frame, on no page). + Rigid(Option), + /// Per-system segments, ascending system order: `(system, from, to)` in + /// spaced coordinates. + Split(Vec<(usize, Point, Point)>), +} + +/// The content extent of a system in spaced (pre-casting) coordinates. +#[derive(Copy, Clone)] +struct Extent { + min_x: f32, + min_y: f32, + max_x: f32, + max_y: f32, + any: bool, +} + +impl Extent { + fn empty() -> Self { + Extent { + min_x: f32::INFINITY, + min_y: f32::INFINITY, + max_x: f32::NEG_INFINITY, + max_y: f32::NEG_INFINITY, + any: false, + } + } + + fn add(&mut self, x0: f32, y0: f32, x1: f32, y1: f32) { + if [x0, y0, x1, y1].iter().all(|v| v.is_finite()) { + self.min_x = self.min_x.min(x0.min(x1)); + self.max_x = self.max_x.max(x0.max(x1)); + self.min_y = self.min_y.min(y0.min(y1)); + self.max_y = self.max_y.max(y0.max(y1)); + self.any = true; + } + } + + /// Normalized: a content-less system is a zero box at the origin. + fn normalized(self) -> Self { + if self.any { + self + } else { + Extent { + min_x: 0.0, + min_y: 0.0, + max_x: 0.0, + max_y: 0.0, + any: false, + } + } + } +} + +/// The MUSCLOID target of an engraved break decision: synthesized from the +/// owning region's source under [`SynthesisKind::EngravedBreak`], keyed by the +/// breaking slot's identity (the slot id is itself content-derived from the +/// region and its column, so the key is the column's semantic identity, never a +/// layout-position ordinal). +fn break_target(region_source: TypedObjectId, slot: SpringSlotId) -> LayoutObjectId { + synthesized_layout_id( + ®ion_source, + SynthesisKind::EngravedBreak, + SynthesisInstanceKey(slot.0), + ) +} + +/// The decision source for a break honoured at `slot`: the user override that +/// asked for it when the projection recorded one, else `Automatic`. +fn origin_source( + origins: &BTreeMap<(u128, bool), EngravingOverrideId>, + slot: SpringSlotId, + page: bool, +) -> DecisionSource { + match origins.get(&(slot.0, page)) { + Some(id) => DecisionSource::UserOverride(*id), + None => DecisionSource::Automatic, + } +} + +/// Casts the spaced layout off into systems and pages. Pure and deterministic: +/// a function of the input IR, the spaced geometry, and the page geometry. +pub(crate) fn cast_off( + input: &ConstrainedLayoutIR, + spaced_glyphs: &[ResolvedGlyph], + spaced_strokes: &[Stroke], + geometry: &PageGeometry, +) -> CastLayout { + // ---- Slot table (spaced coordinates) -------------------------------- + let mut slots: BTreeMap = BTreeMap::new(); + for (i, (glyph, spaced)) in input.glyphs.iter().zip(spaced_glyphs).enumerate() { + let name = glyph.glyph.as_str(); + let x = spaced.position.x.0; + let lo = x + glyph.bounding_box.left.0; + let hi = x + glyph.bounding_box.right.0; + let entry = slots.entry(glyph.horizontal_slot).or_insert(SlotInfo { + id: glyph.horizontal_slot, + x, + lo, + hi, + members: Vec::new(), + barline: false, + final_barline: false, + note: false, + measure_barline: None, + }); + entry.lo = entry.lo.min(lo); + entry.hi = entry.hi.max(hi); + entry.members.push(i); + if name.starts_with("barline") { + entry.barline = true; + if name == "barlineFinal" { + entry.final_barline = true; + } else if entry.measure_barline.is_none() + && glyph.provenance.synthesis.is_none() + && matches!(glyph.provenance.source, TypedObjectId::Measure(_)) + { + entry.measure_barline = Some(i); + } + } + if name.starts_with("notehead") || name.starts_with("rest") { + entry.note = true; + } + } + // Fold each rigid stroke (a ledger line) into its owning slot's extent, so + // an overhanging ledger widens the measure it belongs to (mirrors the + // spacing pass's extent rule). + for (stroke, spaced) in input.strokes.iter().zip(spaced_strokes) { + if !is_rigid_width_stroke(stroke) { + continue; + } + if let Some(glyph) = owning_glyph(stroke, &input.glyphs) { + if let Some(entry) = slots.get_mut(&glyph.horizontal_slot) { + entry.lo = entry.lo.min(spaced.from.x.0.min(spaced.to.x.0)); + entry.hi = entry.hi.max(spaced.from.x.0.max(spaced.to.x.0)); + } + } + } + + // ---- Region partition ------------------------------------------------ + let mut region_of_glyph: BTreeMap = BTreeMap::new(); + for (r, region) in input.regions.iter().enumerate() { + for id in ®ion.glyphs { + region_of_glyph.entry(*id).or_insert(r); + } + } + let mut region_slots: Vec> = + (0..input.regions.len()).map(|_| Vec::new()).collect(); + for (_, info) in slots { + let region = info + .members + .first() + .and_then(|&i| region_of_glyph.get(&input.glyphs[i].id())) + .copied(); + // A slot no region claims (out-of-pipeline input) is left out: its + // glyphs stay in the spaced frame, on no page. + if let Some(r) = region { + region_slots[r].push(info); + } + } + for infos in &mut region_slots { + infos.sort_by(|a, b| a.x.total_cmp(&b.x).then_with(|| a.id.cmp(&b.id))); + } + + // ---- Break requirements ---------------------------------------------- + let mut reqs: BTreeMap> = BTreeMap::new(); + for constraint in &input.constraints { + let (slot, page, kind) = match constraint { + LayoutConstraint::SystemBreakAt { slot, kind } => (*slot, false, *kind), + LayoutConstraint::PageBreakAt { slot, kind } => (*slot, true, *kind), + _ => continue, + }; + reqs.entry(slot).or_default().push(BreakReq { + page, + hard: kind == BreakKind::Hard, + }); + } + let mut origins: BTreeMap<(u128, bool), EngravingOverrideId> = BTreeMap::new(); + for origin in &input.break_origins { + origins + .entry((origin.slot.0, origin.class == BreakClass::Page)) + .or_insert(origin.override_id); + } + + // ---- System breaking (greedy first-fit per region) -------------------- + let width_limit = { + let w = geometry.content_width(); + if w > 0.0 { + w + } else { + f32::INFINITY + } + }; + let mut systems: Vec = Vec::new(); + let mut skipped: Vec = Vec::new(); + for (r, infos) in region_slots.iter().enumerate() { + let region_source = input.regions[r].provenance.source; + walk_region( + r, + infos, + &reqs, + &origins, + region_source, + width_limit, + &mut systems, + &mut skipped, + ); + } + + // ---- Stroke fates ------------------------------------------------------ + // Which system each slot landed in, and each region's slot span / per-system + // clip intervals (the interior cut points for system-spanning strokes). + let mut system_of_slot: BTreeMap = BTreeMap::new(); + for (s, plan) in systems.iter().enumerate() { + for &i in &plan.slots { + system_of_slot.insert(region_slots[plan.region][i].id, s); + } + } + let region_spans: Vec> = region_slots + .iter() + .map(|infos| { + infos + .iter() + .map(|s| (s.lo, s.hi)) + .reduce(|a, b| (a.0.min(b.0), a.1.max(b.1))) + }) + .collect(); + let mut region_systems: Vec> = vec![Vec::new(); input.regions.len()]; + for (s, plan) in systems.iter().enumerate() { + region_systems[plan.region].push(s); + } + let mut clips: Vec<(f32, f32)> = vec![(f32::NEG_INFINITY, f32::INFINITY); systems.len()]; + for (r, sys_of_region) in region_systems.iter().enumerate() { + let last = sys_of_region.len().saturating_sub(1); + for (local, &s) in sys_of_region.iter().enumerate() { + let lo = if local == 0 { + f32::NEG_INFINITY + } else { + systems[s] + .slots + .iter() + .map(|&i| region_slots[r][i].lo) + .fold(f32::INFINITY, f32::min) + }; + let hi = if local == last { + f32::INFINITY + } else { + systems[s] + .slots + .iter() + .map(|&i| region_slots[r][i].hi) + .fold(f32::NEG_INFINITY, f32::max) + }; + clips[s] = (lo, hi); + } + } + let fates: Vec = input + .strokes + .iter() + .zip(spaced_strokes) + .map(|(stroke, spaced)| { + stroke_fate( + stroke, + spaced, + input, + &system_of_slot, + ®ion_spans, + ®ion_systems, + &clips, + ) + }) + .collect(); + + // ---- System extents ---------------------------------------------------- + let mut extents: Vec = vec![Extent::empty(); systems.len()]; + for (s, plan) in systems.iter().enumerate() { + for &i in &plan.slots { + for &g in ®ion_slots[plan.region][i].members { + let glyph = &spaced_glyphs[g]; + let (x, y) = (glyph.position.x.0, glyph.position.y.0); + extents[s].add( + x + glyph.bounding_box.left.0, + y + glyph.bounding_box.bottom.0, + x + glyph.bounding_box.right.0, + y + glyph.bounding_box.top.0, + ); + } + } + } + for (fate, spaced) in fates.iter().zip(spaced_strokes) { + let half = (spaced.thickness.0 * 0.5).max(0.0); + match fate { + StrokeFate::Rigid(Some(s)) => extents[*s].add( + spaced.from.x.0 - half, + spaced.from.y.0.min(spaced.to.y.0) - half, + spaced.to.x.0 + half, + spaced.from.y.0.max(spaced.to.y.0) + half, + ), + StrokeFate::Rigid(None) => {} + StrokeFate::Split(segments) => { + for (s, from, to) in segments { + extents[*s].add( + from.x.0 - half, + from.y.0.min(to.y.0) - half, + to.x.0 + half, + from.y.0.max(to.y.0) + half, + ); + } + } + } + } + let extents: Vec = extents.into_iter().map(Extent::normalized).collect(); + + // ---- Vertical stacking and page assignment ---------------------------- + // The inter-system spacing comes from the vertical-band model's own + // constructor, so the casting-off gap and the band spring cannot drift. + let gap = VerticalBand::inter_system_gap(VerticalBandId(0)) + .preferred_height + .0; + let content_height = geometry.content_height(); + let bounded = content_height > 0.0; + let mut placements: Vec<(f32, f32)> = Vec::with_capacity(systems.len()); + let mut page_systems: Vec> = Vec::new(); + let mut cursor = 0.0_f32; + let mut page_floor = 0.0_f32; + for (s, plan) in systems.iter().enumerate() { + let ext = &extents[s]; + let height = ext.max_y - ext.min_y; + // Every opened page immediately receives a system, so an overflow test + // against a non-empty page list never opens an empty page — a system + // taller than a whole page stays (overfull) on the page it opens. + let overflow = bounded && !page_systems.is_empty() && cursor - height < page_floor; + if page_systems.is_empty() || plan.page_forced || overflow { + let p = page_systems.len(); + cursor = page_top_content(p, geometry); + page_floor = cursor - content_height.max(0.0); + page_systems.push(Vec::new()); + } + let dx = geometry.margins.left.0 - ext.min_x; + let dy = cursor - ext.max_y; + placements.push((dx, dy)); + page_systems + .last_mut() + .expect("a page was opened above") + .push(s); + cursor -= height + gap; + } + + // ---- Break structure and decisions ------------------------------------- + let mut system_start_slots = BTreeSet::new(); + for plan in &systems { + if let Some(&i) = plan.slots.first() { + system_start_slots.insert(region_slots[plan.region][i].id); + } + } + let mut page_start_slots = BTreeSet::new(); + let mut decisions = Vec::new(); + for (p, on_page) in page_systems.iter().enumerate() { + for (j, &s) in on_page.iter().enumerate() { + let plan = &systems[s]; + let starts_page = j == 0; + if starts_page { + if let Some(&i) = plan.slots.first() { + page_start_slots.insert(region_slots[plan.region][i].id); + } + } + let region_source = input.regions[plan.region].provenance.source; + if let Some(boundary) = plan.boundary { + // A chosen intra-region break: a page decision when the system + // actually opens a page, a system decision otherwise. + decisions.push(EngravingDecision::with_source( + break_target(region_source, boundary.slot), + if starts_page { + EngravingDecisionKind::PageBreak + } else { + EngravingDecisionKind::SystemBreak + }, + boundary.source, + )); + } else if starts_page && p > 0 { + // A later page opening at a region's first system: the page + // start is itself an engraved decision (forced or overflow). + if let Some(&i) = plan.slots.first() { + decisions.push(EngravingDecision::with_source( + break_target(region_source, region_slots[plan.region][i].id), + EngravingDecisionKind::PageBreak, + plan.page_source, + )); + } + } + } + } + decisions.extend(skipped); + + // ---- Bake the world frame ---------------------------------------------- + let glyphs: Vec = spaced_glyphs + .iter() + .zip(&input.glyphs) + .map(|(spaced, glyph)| { + let (dx, dy) = system_of_slot + .get(&glyph.horizontal_slot) + .map(|&s| placements[s]) + .unwrap_or((0.0, 0.0)); + ResolvedGlyph { + position: Point::new(spaced.position.x.0 + dx, spaced.position.y.0 + dy), + ..spaced.clone() + } + }) + .collect(); + + // Per-system staff-line marks, for the resolved staff records below. + let mut staff_marks: BTreeMap<(usize, StaffId), StaffAgg> = BTreeMap::new(); + let mut strokes: Vec = Vec::with_capacity(spaced_strokes.len()); + let mut continuations: Vec = Vec::new(); + for (spaced, fate) in spaced_strokes.iter().zip(&fates) { + match fate { + StrokeFate::Rigid(sys) => { + let (dx, dy) = sys.map(|s| placements[s]).unwrap_or((0.0, 0.0)); + let stroke = translated(spaced, dx, dy); + if let (Some(s), TypedObjectId::Staff(staff)) = (sys, spaced.provenance.source) { + mark_staff(&mut staff_marks, *s, staff, &stroke); + } + strokes.push(stroke); + } + StrokeFate::Split(segments) => { + for (k, (s, from, to)) in segments.iter().enumerate() { + let (dx, dy) = placements[*s]; + let provenance = if k == 0 { + // The first segment carries the original stroke's exact + // provenance: the object survives, re-shaped. + spaced.provenance.clone() + } else { + Provenance::synthesized( + spaced.provenance.source, + SynthesisKind::Registered(SYSTEM_CONTINUATION_SYNTHESIS), + continuation_instance_key(spaced.provenance.stable_id, k as u32), + spaced.provenance.dependencies.clone(), + ) + }; + let stroke = Stroke { + provenance, + from: Point::new(from.x.0 + dx, from.y.0 + dy), + to: Point::new(to.x.0 + dx, to.y.0 + dy), + thickness: spaced.thickness, + layer: spaced.layer, + style: spaced.style, + }; + if let TypedObjectId::Staff(staff) = spaced.provenance.source { + mark_staff(&mut staff_marks, *s, staff, &stroke); + } + if k == 0 { + strokes.push(stroke); + } else { + continuations.push(stroke); + } + } + } + } + } + strokes.extend(continuations); + + // ---- The resolved page tree --------------------------------------------- + let resolved_systems: Vec = systems + .iter() + .enumerate() + .map(|(s, plan)| { + build_system( + s, + plan, + input, + ®ion_slots, + &extents, + &placements, + &staff_marks, + ) + }) + .collect(); + let mut resolved_systems: Vec> = + resolved_systems.into_iter().map(Some).collect(); + let pages: Vec = page_systems + .iter() + .enumerate() + .map(|(p, on_page)| { + let first_region = systems[on_page[0]].region; + let region_provenance = &input.regions[first_region].provenance; + let provenance = if p == 0 { + // Page 1 carries the first region's own provenance, as the + // degenerate single-page output always did. + input.regions[0].provenance.clone() + } else { + Provenance::synthesized( + region_provenance.source, + SynthesisKind::EngravedBreak, + SynthesisInstanceKey((KEY_NS_PAGE << 64) | (p as u128 + 1)), + region_provenance.dependencies.clone(), + ) + }; + ResolvedPage { + provenance, + number: p as u32 + 1, + size: geometry.size, + margins: geometry.margins, + systems: on_page + .iter() + .map(|&s| resolved_systems[s].take().expect("each system on one page")) + .collect(), + // Nothing in the Minimal pipeline is a page-level free object + // (region content is all system-bound); left empty rather than + // fabricated. + free_objects: Vec::new(), + } + }) + .collect(); + + CastLayout { + glyphs, + strokes, + pages, + decisions, + system_start_slots, + page_start_slots, + } +} + +/// The world-frame y of page `p`'s content top: pages stack downward from the +/// origin, each a full page height plus [`INTER_PAGE_GAP`] below the previous. +fn page_top_content(p: usize, geometry: &PageGeometry) -> f32 { + -(p as f32) * (geometry.size.height.0 + INTER_PAGE_GAP) - geometry.margins.top.0 +} + +/// Greedy first-fit walk over one region's slots (see the module docs). +#[allow(clippy::too_many_arguments)] +fn walk_region( + region: usize, + slots: &[SlotInfo], + reqs: &BTreeMap>, + origins: &BTreeMap<(u128, bool), EngravingOverrideId>, + region_source: TypedObjectId, + width_limit: f32, + systems: &mut Vec, + skipped: &mut Vec, +) { + // Measure look-ahead: `chunk_hi[i]` is the rightmost content edge of the + // chunk beginning at slot `i` — through the slot before the next breakable + // barline (the region-final barline closes the last chunk, so it never + // starts one). + let breakable = |slot: &SlotInfo| slot.barline && !slot.final_barline; + let mut chunk_hi = vec![f32::NEG_INFINITY; slots.len()]; + for i in (0..slots.len()).rev() { + let next = if i + 1 < slots.len() && !breakable(&slots[i + 1]) { + chunk_hi[i + 1] + } else { + f32::NEG_INFINITY + }; + chunk_hi[i] = slots[i].hi.max(next); + } + + let mut local = 0usize; + let mut current: Vec = Vec::new(); + let mut has_note = false; + let mut current_lo = f32::INFINITY; + let mut open_boundary: Option = None; + let mut open_page_forced = false; + let mut open_page_source = DecisionSource::Automatic; + + for (i, slot) in slots.iter().enumerate() { + let slot_reqs = reqs.get(&slot.id).map(Vec::as_slice).unwrap_or(&[]); + if current.is_empty() { + // The region's first slot is already at a system boundary, so a + // system break here is trivially honoured; a page break still + // forces this (first) system onto a fresh page. + for req in slot_reqs { + if req.page { + open_page_forced = true; + if open_page_source == DecisionSource::Automatic { + open_page_source = origin_source(origins, slot.id, true); + } + } + } + current.push(i); + has_note = slot.note; + current_lo = slot.lo; + continue; + } + let mut break_here = false; + let mut page_here = false; + let mut source = DecisionSource::Automatic; + for req in slot_reqs { + if !req.hard && !has_note { + // The documented exceptional path: honouring this *soft* break + // would close a system with no musical content (e.g. a bare + // clef/barline line). It is skipped, and the unhonoured + // override is recorded as an IR-stage-overridden decision + // (never silently dropped). + skipped.push(EngravingDecision::with_source( + break_target(region_source, slot.id), + if req.page { + EngravingDecisionKind::PageBreak + } else { + EngravingDecisionKind::SystemBreak + }, + DecisionSource::IrOverride, + )); + continue; + } + break_here = true; + page_here |= req.page; + if !matches!(source, DecisionSource::UserOverride(_)) { + source = origin_source(origins, slot.id, req.page); + } + } + // Greedy first-fit: at a measure boundary, break when the measure + // beginning here would overflow the content width. + if !break_here && breakable(slot) && has_note && chunk_hi[i] - current_lo > width_limit { + break_here = true; + } + if break_here { + systems.push(SystemPlan { + region, + local, + slots: std::mem::take(&mut current), + boundary: open_boundary.take(), + page_forced: open_page_forced, + page_source: open_page_source, + }); + local += 1; + open_boundary = Some(Boundary { + slot: slot.id, + source, + }); + open_page_forced = page_here; + open_page_source = if page_here { + source + } else { + DecisionSource::Automatic + }; + current.push(i); + has_note = slot.note; + current_lo = slot.lo; + } else { + current.push(i); + has_note |= slot.note; + current_lo = current_lo.min(slot.lo); + } + } + // The region's last system — or, for a region with no slots at all, its + // single (empty) system, preserving one-system-per-region as the minimum. + systems.push(SystemPlan { + region, + local, + slots: current, + boundary: open_boundary, + page_forced: open_page_forced, + page_source: open_page_source, + }); +} + +/// Decides how a stroke rides the cast systems (see [`StrokeFate`]). +fn stroke_fate( + stroke: &Stroke, + spaced: &Stroke, + input: &ConstrainedLayoutIR, + system_of_slot: &BTreeMap, + region_spans: &[Option<(f32, f32)>], + region_systems: &[Vec], + clips: &[(f32, f32)], +) -> StrokeFate { + // A rigid-width stroke (a ledger line) rides its owning glyph's system, so + // it translates by exactly the same delta as its notehead. + if is_rigid_width_stroke(stroke) { + if let Some(glyph) = owning_glyph(stroke, &input.glyphs) { + return StrokeFate::Rigid(system_of_slot.get(&glyph.horizontal_slot).copied()); + } + } + let lo = spaced.from.x.0.min(spaced.to.x.0); + let hi = spaced.from.x.0.max(spaced.to.x.0); + // The owning region: the one whose slot span is nearest (ties to the first). + let mut best: Option<(usize, f32)> = None; + for (r, span) in region_spans.iter().enumerate() { + let Some((rlo, rhi)) = span else { continue }; + let distance = if hi < *rlo { + rlo - hi + } else if lo > *rhi { + lo - rhi + } else { + 0.0 + }; + if best.map_or(true, |(_, d)| distance < d) { + best = Some((r, distance)); + } + } + let Some((region, _)) = best else { + return StrokeFate::Rigid(None); + }; + // The systems of that region the stroke's span overlaps. + let overlapped: Vec = region_systems[region] + .iter() + .copied() + .filter(|&s| lo <= clips[s].1 && hi >= clips[s].0) + .collect(); + match overlapped.len() { + 0 => { + // In the sliver between two systems' content: nearest system. + let nearest = region_systems[region] + .iter() + .copied() + .min_by(|&a, &b| { + let da = interval_distance(lo, hi, clips[a]); + let db = interval_distance(lo, hi, clips[b]); + da.total_cmp(&db).then(a.cmp(&b)) + }) + .expect("every region has at least one system"); + StrokeFate::Rigid(Some(nearest)) + } + 1 => StrokeFate::Rigid(Some(overlapped[0])), + _ => { + // A system-spanning stroke (a staff line): one segment per system, + // cut at the systems' content edges, y interpolated along the + // stroke so a (hypothetical) sloped spanner splits consistently. + let (x0, y0) = (spaced.from.x.0, spaced.from.y.0); + let (x1, y1) = (spaced.to.x.0, spaced.to.y.0); + let point_at = |x: f32| -> Point { + if (x1 - x0).abs() < f32::EPSILON { + Point::new(x, y0) + } else { + let t = (x - x0) / (x1 - x0); + Point::new(x, y0 + t * (y1 - y0)) + } + }; + let segments = overlapped + .into_iter() + .map(|s| { + let a = lo.max(clips[s].0); + let b = hi.min(clips[s].1); + (s, point_at(a), point_at(b)) + }) + .collect(); + StrokeFate::Split(segments) + } + } +} + +/// Distance from the span `[lo, hi]` to a clip interval (0 when they overlap). +fn interval_distance(lo: f32, hi: f32, clip: (f32, f32)) -> f32 { + if hi < clip.0 { + clip.0 - hi + } else if lo > clip.1 { + lo - clip.1 + } else { + 0.0 + } +} + +/// A stroke translated rigidly by `(dx, dy)`. +fn translated(stroke: &Stroke, dx: f32, dy: f32) -> Stroke { + Stroke { + provenance: stroke.provenance.clone(), + from: Point::new(stroke.from.x.0 + dx, stroke.from.y.0 + dy), + to: Point::new(stroke.to.x.0 + dx, stroke.to.y.0 + dy), + thickness: stroke.thickness, + layer: stroke.layer, + style: stroke.style, + } +} + +/// Accumulated staff-line geometry within one system, for the resolved staff +/// record: the extent of the staff's line segments and the provenance of its +/// bottom line (the segment that anchors the staff in this system). +struct StaffAgg { + min_x: f32, + max_x: f32, + min_y: f32, + max_y: f32, + bottom: (f32, Provenance), +} + +/// Folds a world-frame staff-line stroke into its `(system, staff)` aggregate. +fn mark_staff( + marks: &mut BTreeMap<(usize, StaffId), StaffAgg>, + system: usize, + staff: StaffId, + stroke: &Stroke, +) { + let half = (stroke.thickness.0 * 0.5).max(0.0); + let (lo_x, hi_x) = ( + stroke.from.x.0.min(stroke.to.x.0), + stroke.from.x.0.max(stroke.to.x.0), + ); + let (lo_y, hi_y) = ( + stroke.from.y.0.min(stroke.to.y.0) - half, + stroke.from.y.0.max(stroke.to.y.0) + half, + ); + marks + .entry((system, staff)) + .and_modify(|agg| { + agg.min_x = agg.min_x.min(lo_x); + agg.max_x = agg.max_x.max(hi_x); + agg.min_y = agg.min_y.min(lo_y); + agg.max_y = agg.max_y.max(hi_y); + if lo_y < agg.bottom.0 { + agg.bottom = (lo_y, stroke.provenance.clone()); + } + }) + .or_insert_with(|| StaffAgg { + min_x: lo_x, + max_x: hi_x, + min_y: lo_y, + max_y: hi_y, + bottom: (lo_y, stroke.provenance.clone()), + }); +} + +/// Builds one populated [`ResolvedSystem`]: a real world-frame bounding box, a +/// staff record per staff whose lines reach this system (top staff first), and +/// a measure record per measure-start barline column the system carries. What +/// the pipeline does not know is left empty, never fabricated: a staff with no +/// engraved lines yields no staff record, and the final-barline measure (whose +/// start no column marks) yields no measure record. +fn build_system( + system: usize, + plan: &SystemPlan, + input: &ConstrainedLayoutIR, + region_slots: &[Vec], + extents: &[Extent], + placements: &[(f32, f32)], + staff_marks: &BTreeMap<(usize, StaffId), StaffAgg>, +) -> ResolvedSystem { + let region = &input.regions[plan.region]; + let (dx, dy) = placements[system]; + let ext = &extents[system]; + let provenance = if plan.local == 0 { + region.provenance.clone() + } else { + // A region's second and later systems are engraver-created objects: + // synthesized from the region under `EngravedBreak`, keyed by the + // region-local system ordinal in its own key namespace. + Provenance::synthesized( + region.provenance.source, + SynthesisKind::EngravedBreak, + SynthesisInstanceKey((KEY_NS_SYSTEM << 64) | plan.local as u128), + region.provenance.dependencies.clone(), + ) + }; + let bounding_box = Rect { + origin: Point::new(ext.min_x + dx, ext.min_y + dy), + size: Size2D { + width: StaffSpace(ext.max_x - ext.min_x), + height: StaffSpace(ext.max_y - ext.min_y), + }, + }; + + let mut staves: Vec = staff_marks + .range((system, StaffId::from_raw(0))..=(system, StaffId::from_raw(u128::MAX))) + .map(|(&(_, staff), agg)| ResolvedStaff { + provenance: agg.bottom.1.clone(), + staff, + bounding_box: Rect { + origin: Point::new(agg.min_x, agg.min_y), + size: Size2D { + width: StaffSpace(agg.max_x - agg.min_x), + height: StaffSpace(agg.max_y - agg.min_y), + }, + }, + }) + .collect(); + // Top staff first — the reading order of the system. + staves.sort_by(|a, b| { + let top_a = a.bounding_box.origin.y.0 + a.bounding_box.size.height.0; + let top_b = b.bounding_box.origin.y.0 + b.bounding_box.size.height.0; + top_b.total_cmp(&top_a) + }); + + // Measures: each measure-start barline column opens a span that runs to the + // next such column in this system, or to the system's content edge. + let slots = ®ion_slots[plan.region]; + let marks: Vec<(usize, usize)> = plan + .slots + .iter() + .filter_map(|&i| slots[i].measure_barline.map(|g| (i, g))) + .collect(); + let measures: Vec = marks + .iter() + .enumerate() + .filter_map(|(k, &(i, g))| { + let glyph = &input.glyphs[g]; + let TypedObjectId::Measure(measure) = glyph.provenance.source else { + return None; + }; + let start = slots[i].lo; + let end = marks + .get(k + 1) + .map(|&(next, _)| slots[next].lo) + .unwrap_or(ext.max_x); + Some(ResolvedMeasure { + provenance: glyph.provenance.clone(), + measure, + bounding_box: Rect { + origin: Point::new(start + dx, ext.min_y + dy), + size: Size2D { + width: StaffSpace(end - start), + height: StaffSpace(ext.max_y - ext.min_y), + }, + }, + }) + }) + .collect(); + + ResolvedSystem { + provenance, + bounding_box, + staves, + measures, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn default_geometry_matches_the_documented_arithmetic() { + // A4 at an 8 mm staff: 1 staff space = 2 mm. + let geometry = PageGeometry::default(); + assert_eq!(geometry.size.width.0, 210.0 / 2.0); + assert_eq!(geometry.size.height.0, 297.0 / 2.0); + for margin in [ + geometry.margins.top, + geometry.margins.right, + geometry.margins.bottom, + geometry.margins.left, + ] { + assert_eq!(margin.0, 15.0 / 2.0); + } + assert_eq!(geometry.content_width(), 90.0); + assert_eq!(geometry.content_height(), 133.5); + } + + #[test] + fn pages_stack_downward_with_the_inter_page_gap() { + let geometry = PageGeometry::default(); + assert_eq!(page_top_content(0, &geometry), -7.5); + assert_eq!( + page_top_content(1, &geometry), + -(148.5 + INTER_PAGE_GAP) - 7.5 + ); + } +} diff --git a/crates/epiphany-engrave/src/lib.rs b/crates/epiphany-engrave/src/lib.rs index aa32924..a4fc8ee 100644 --- a/crates/epiphany-engrave/src/lib.rs +++ b/crates/epiphany-engrave/src/lib.rs @@ -9,31 +9,49 @@ //! crates so the core/product boundary stays sharp (`spec/PHASE2_QUICKSTART.md`, //! crate topology). //! -//! ## Phase status — `Minimal` tier +//! ## Phase status — `Minimal` tier, with casting-off //! -//! [`Engraver`] runs a genuine deterministic **horizontal spacing pass** (see -//! the private `spacing` module) — placing each glyph-bearing slot left-to-right by a -//! collision-aware advance (its preferred width floored by the real glyph -//! bearings) — and **evaluates the IR's declared constraints** against the -//! resolved geometry, routed by [`LayoutConstraint::strength`] (Chapter 9 -//! §"Strength Levels"): a violated `Required` constraint (no-collision, -//! alignment, position-within, a hard break, an unverifiable extension -//! constraint) is reported unsatisfied and the solve is -//! [`SolveStatus::Unsatisfiable`]; a violated `Preferred` constraint (a soft -//! break this single-system solve does not honour) surfaces as a +//! [`Engraver`] runs a genuine deterministic **horizontal spacing pass** (the +//! private `spacing` module) — placing each glyph-bearing slot left-to-right by +//! a collision-aware advance (its preferred width floored by the real glyph +//! bearings) — then a **casting-off pass** (the [`casting`] module; Chapter 9 +//! §"The Constraint-Solving Stage": the solver "resolve\[s\] page and system +//! breaks"): greedy first-fit system breaking at measure boundaries against a +//! [`PageGeometry`], vertical system stacking at the vertical-band model's +//! inter-system gap, page assignment by content height, and a real populated +//! page/system tree (Chapter 7 §"ResolvedLayoutIR"). Every chosen break is +//! recorded as an [`epiphany_layout_ir::EngravingDecision`] whose target is a +//! `MUSCLOID` id synthesized under +//! [`epiphany_layout_ir::SynthesisKind::EngravedBreak`], attributed to the user +//! override that asked for it when one did +//! ([`epiphany_layout_ir::DecisionSource::UserOverride`]). +//! +//! The declared constraints are **evaluated**, routed by +//! [`LayoutConstraint::strength`] (Chapter 9 §"Strength Levels"). Geometric +//! constraints (no-collision, alignment, position-within) are evaluated in the +//! **pre-casting spaced frame** — they are region-frame obligations, and +//! casting-off relocates whole systems by rigid motions that cannot un-satisfy +//! them within a system (see `DECISIONS.md`). Break constraints are evaluated +//! against the **final break structure**: a `SystemBreakAt`/`PageBreakAt` is +//! satisfied iff the cast layout breaks (starts a system/page) at that slot. A +//! violated `Required` constraint makes the solve +//! [`SolveStatus::Unsatisfiable`]; a violated `Preferred` one (a soft break +//! skipped on the documented pathological path) surfaces as a //! [`SolverWarningKind::LargeSoftConstraintViolation`] warning under -//! [`SolveStatus::SolvedWithWarnings`], never a failure. A solve is -//! [`SolveStatus::Solved`] only when every declared constraint holds. +//! [`SolveStatus::SolvedWithWarnings`] plus an `IrOverride`-sourced decision, +//! never a failure. A solve is [`SolveStatus::Solved`] only when every declared +//! constraint holds. //! //! Having earned it, [`Engraver::tier`] reports [`SolverTier::Minimal`] — which //! (Chapter 9 §"Conformance Tiers" / QUICKSTART) means *hard constraints -//! satisfied, no claim about optimality*. It therefore makes **no -//! normalized-metric claim**: the quality-metric vector stays the conservative -//! all-worst "no claim" placeholder ([`QualityMetricVector::unmeasured`]) until -//! the Quality Metric Catalog lands (Phase 3 / `Standard`). Still deferred to a -//! later tier: the **vertical spring pass** (glyph `y` is the constrained natural -//! staff layout, preserved verbatim) and **casting-off** (a single system, so it -//! cannot honour a forced system/page break). +//! satisfied, no claim about optimality* — greedy first-fit casting-off is +//! legitimate at this tier. It therefore makes **no normalized-metric claim**: +//! the quality-metric vector stays the conservative all-worst "no claim" +//! placeholder ([`QualityMetricVector::unmeasured`]) until the Quality Metric +//! Catalog lands (Phase 3 / `Standard`). Still deferred to a later tier: the +//! **vertical spring pass** (glyph `y` within a system is the constrained +//! natural staff layout, preserved verbatim; systems stack by real content +//! extents), per-system justification/stretch, and optimal break search. //! //! ## Architecture decision (see `DECISIONS.md`) //! @@ -44,18 +62,21 @@ //! //! [`epiphany-render-svg`]: ../epiphany_render_svg/index.html +pub mod casting; mod spacing; -use std::collections::BTreeMap; +use std::collections::{BTreeMap, BTreeSet}; use epiphany_layout_ir::{ all_available, Axis, BravuraCatalog, ConstrainedLayoutIR, ConstraintId, ConstraintSolver, ConstraintStrength, GlyphCatalog, GlyphObject, GlyphObjectId, InvalidationSet, - LayoutConstraint, Margins, Point, QualityMetricVector, Rect, ResolvedGlyph, ResolvedLayoutIR, - ResolvedPage, ResolvedSystem, Size2D, SolveReport, SolveStatus, SolverBudgetUsed, SolverConfig, - SolverState, SolverTier, SolverVersion, SolverWarning, SolverWarningKind, Stroke, + LayoutConstraint, Point, QualityMetricVector, Rect, ResolvedGlyph, ResolvedLayoutIR, + SolveReport, SolveStatus, SolverBudgetUsed, SolverConfig, SolverState, SolverTier, + SolverVersion, SolverWarning, SolverWarningKind, SpringSlotId, Stroke, }; +pub use casting::{PageGeometry, INTER_PAGE_GAP, SYSTEM_CONTINUATION_SYNTHESIS}; + /// The glyph a fixed-width stroke (a ledger line) belongs to: the same-source glyph /// whose baseline falls within the stroke's horizontal span (its accidentals sit /// outside the span, to the left). The stroke is anchored to this glyph's column so @@ -75,25 +96,45 @@ pub(crate) fn owning_glyph<'a>( } /// The Epiphany engraving solver (Chapter 9). A `Minimal`-tier solver: it spaces -/// glyphs horizontally and satisfies the IR's declared hard constraints. See the -/// crate docs for what each tier claims and what remains deferred. +/// glyphs horizontally, casts the result off into systems and pages against its +/// [`PageGeometry`], and satisfies the IR's declared hard constraints — break +/// constraints included. See the crate docs for what each tier claims and what +/// remains deferred. #[derive(Copy, Clone, Debug, Default)] -pub struct Engraver; +pub struct Engraver { + geometry: PageGeometry, +} /// The implementation version of this solver (Chapter 9: within a fixed version, -/// identical input produces identical output). Distinct from the stub's `0`. -pub const ENGRAVER_VERSION: SolverVersion = SolverVersion(1); +/// identical input produces identical output). Distinct from the stub's `0`; +/// bumped to `2` when the casting-off pass landed (the resolved geometry of a +/// wrapping score differs from version `1`'s single endless system). +pub const ENGRAVER_VERSION: SolverVersion = SolverVersion(2); impl Engraver { + /// An engraver casting off against the given page geometry. + /// [`Engraver::default`] uses [`PageGeometry::default`] (A4 portrait at an + /// 8 mm staff — see its docs for the arithmetic). + pub fn with_geometry(geometry: PageGeometry) -> Self { + Engraver { geometry } + } + + /// The page geometry this engraver casts off against. + pub fn geometry(&self) -> PageGeometry { + self.geometry + } + /// Resolves geometry: a deterministic horizontal spacing pass over the spring - /// slots (each glyph to its slot's `x`, baseline `y` preserved), then - /// evaluation of the declared constraints by strength. A malformed input — an - /// unknown glyph, a forged catalog identity, or invalid structure — yields - /// [`SolveStatus::InternalError`]; a valid problem whose `Required` - /// constraints cannot all be satisfied yields [`SolveStatus::Unsatisfiable`] - /// (naming the unsatisfied constraints). Both are diagnostic-only; neither - /// panics. Violated `Preferred` constraints yield soft-violation warnings - /// under [`SolveStatus::SolvedWithWarnings`] — a valid, renderable layout. + /// slots (each glyph to its slot's `x`, baseline `y` preserved), then the + /// casting-off pass (system breaking, vertical stacking, page assignment — + /// see [`casting`]), then evaluation of the declared constraints by + /// strength. A malformed input — an unknown glyph, a forged catalog + /// identity, or invalid structure — yields [`SolveStatus::InternalError`]; a + /// valid problem whose `Required` constraints cannot all be satisfied yields + /// [`SolveStatus::Unsatisfiable`] (naming the unsatisfied constraints). Both + /// are diagnostic-only; neither panics. Violated `Preferred` constraints + /// yield soft-violation warnings under [`SolveStatus::SolvedWithWarnings`] + /// — a valid, renderable layout. fn resolve(&self, input: &ConstrainedLayoutIR) -> SolveReport { let structural_valid = input.validate().is_ok(); @@ -109,23 +150,51 @@ impl Engraver { // stem behind. Both gate on structural validity: a malformed input must // not leak geometry into the diagnostic layout (which reaches // canonical_bytes / the renderer). - let (glyphs, strokes): (Vec, Vec) = if structural_valid { + let (spaced_glyphs, spaced_strokes): (Vec, Vec) = if structural_valid + { let remap = HorizontalRemap::build(input); (remap.glyphs(input), remap.strokes(input)) } else { (Vec::new(), Vec::new()) }; - let resolved_glyphs = glyphs.len(); + // Casting-off: break the spaced line into systems, stack them, assign + // pages, and bake every position into the single world frame. Pure + // geometry, so it runs whenever the structure is trustworthy (the + // catalog gate below only guards constraint *evaluation*). + let cast = if structural_valid { + Some(casting::cast_off( + input, + &spaced_glyphs, + &spaced_strokes, + &self.geometry, + )) + } else { + None + }; + let resolved_glyphs = spaced_glyphs.len(); - // Evaluate every declared constraint against the *resolved* geometry, - // routed by its strength (Chapter 9 §"Strength Levels"): a violated - // `Required` constraint is unsatisfied (the solve is `Unsatisfiable`); - // a violated `Preferred` one is a soft-violation *warning*, never a - // failure. A structurally invalid or bad-catalog input is not evaluated - // — there is no trustworthy geometry — so it reports no evaluation work. + // Evaluate every declared constraint, routed by its strength (Chapter 9 + // §"Strength Levels"): geometric constraints against the *pre-casting* + // spaced geometry (their frame of expression — casting-off relocates + // whole systems rigidly), break constraints against the final break + // structure. A violated `Required` constraint is unsatisfied (the solve + // is `Unsatisfiable`); a violated `Preferred` one is a soft-violation + // *warning*, never a failure. A structurally invalid or bad-catalog + // input is not evaluated — there is no trustworthy geometry — so it + // reports no evaluation work. let (evaluation, constraints_evaluated) = if structural_valid && catalog_valid { + let cast = cast + .as_ref() + .expect("casting ran on structurally valid input"); ( - evaluate_constraints(&input.constraints, &glyphs), + evaluate_constraints( + &input.constraints, + &spaced_glyphs, + &BreakOutcome { + system_starts: &cast.system_start_slots, + page_starts: &cast.page_start_slots, + }, + ), input.constraints.len() as u64, ) } else { @@ -157,9 +226,10 @@ impl Engraver { if structural_valid && catalog_valid && !unsatisfied_constraints.is_empty() { warnings.push(SolverWarning { kind: SolverWarningKind::UnusualLayoutDecision( - "one or more declared hard constraints are not satisfiable by this \ - single-system Minimal solve (e.g. a forced break, or an unverifiable \ - extension constraint); see unsatisfied_constraints" + "one or more declared hard constraints are not satisfied by this \ + Minimal solve (e.g. an unverifiable extension constraint, or \ + colliding geometry the spacing pass cannot separate); see \ + unsatisfied_constraints" .to_owned(), ), affected_objects: Vec::new(), @@ -167,28 +237,23 @@ impl Engraver { }); } - let pages = input - .regions - .first() - .map(|first| ResolvedPage { - provenance: first.provenance.clone(), - number: 1, - size: Size2D::default(), - margins: Margins::default(), - systems: input - .regions - .iter() - .map(|region| ResolvedSystem { - provenance: region.provenance.clone(), - bounding_box: Rect::default(), - staves: Vec::new(), - measures: Vec::new(), - }) - .collect(), - free_objects: Vec::new(), - }) - .into_iter() - .collect(); + // The final layout is the cast world frame: real pages and systems, + // glyph/stroke positions baked, the engraver's break decisions appended + // to the pipeline's (Chapter 7 §"ResolvedLayoutIR": decisions "including + // any the solver itself made"). + let (glyphs, strokes, pages, engraving_decisions) = match cast { + Some(cast) => { + let mut decisions = input.engraving_decisions.clone(); + decisions.extend(cast.decisions); + (cast.glyphs, cast.strokes, cast.pages, decisions) + } + None => ( + Vec::new(), + Vec::new(), + Vec::new(), + input.engraving_decisions.clone(), + ), + }; SolveReport { status, @@ -198,7 +263,7 @@ impl Engraver { pages, glyphs, strokes, - engraving_decisions: input.engraving_decisions.clone(), + engraving_decisions, catalog: input.catalog.clone(), }, unsatisfied_constraints, @@ -209,7 +274,8 @@ impl Engraver { // conservative all-worst "no claim" placeholder, like the stub's. metric_vector: QualityMetricVector::unmeasured(), budget_used: SolverBudgetUsed { - // The horizontal pass touches each slot once; report that honestly. + // The horizontal pass and the casting-off walk each touch every + // slot once; report the spacing pass's touch honestly. iterations: input.horizontal_slots.len() as u64, nodes: resolved_glyphs as u64, constraint_evaluations: constraints_evaluated, @@ -353,23 +419,37 @@ impl ConstraintEvaluation { } } -/// Evaluates the IR's declared constraints against the *resolved* geometry — a -/// constraint's id is its index in the IR's constraint list — routing each -/// violation by [`LayoutConstraint::strength`] (Chapter 9 §"Strength Levels"): -/// a violated `Required` constraint is reported unsatisfied, a violated -/// `Preferred` one becomes a [`SolverWarningKind::LargeSoftConstraintViolation`] -/// warning and never fails the solve. +/// The break structure the casting-off pass produced, for constraint +/// evaluation: the slots at which the final layout starts a system, and the +/// subset at which it starts a page. +struct BreakOutcome<'a> { + system_starts: &'a BTreeSet, + page_starts: &'a BTreeSet, +} + +/// Evaluates the IR's declared constraints — a constraint's id is its index in +/// the IR's constraint list — routing each violation by +/// [`LayoutConstraint::strength`] (Chapter 9 §"Strength Levels"): a violated +/// `Required` constraint is reported unsatisfied, a violated `Preferred` one +/// becomes a [`SolverWarningKind::LargeSoftConstraintViolation`] warning and +/// never fails the solve. /// /// Geometric constraints (no-collision, alignment, position-within) are checked -/// against the resolved glyph boxes. A break is never *honoured* — a -/// single-system, single-page Minimal solve casts off nothing — so a hard break -/// (`Required`) is unsatisfied and a soft break (`Preferred`) is a warning. An -/// extension `Registered` constraint this solver cannot interpret is likewise -/// not claimed satisfied (Chapter 7 §"Behavior Under Unknown Extensions": +/// against the **pre-casting spaced** glyph boxes — the frame the constraints +/// are expressed in; casting-off then relocates whole systems by rigid motions +/// (see `DECISIONS.md`, frame of evaluation). Break constraints are checked +/// against the **cast break structure**: `SystemBreakAt`/`PageBreakAt` is +/// satisfied iff the final layout starts a system/page at that slot — so a hard +/// break is `Unsatisfiable` only if casting-off failed to honour it (which +/// cannot happen for a feasible, structurally valid input), and a soft break is +/// a warning exactly when it was skipped on the documented pathological path. +/// An extension `Registered` constraint this solver cannot interpret is not +/// claimed satisfied (Chapter 7 §"Behavior Under Unknown Extensions": /// conservative). fn evaluate_constraints( constraints: &[LayoutConstraint], glyphs: &[ResolvedGlyph], + breaks: &BreakOutcome, ) -> ConstraintEvaluation { let by_id: BTreeMap = glyphs .iter() @@ -392,7 +472,8 @@ fn evaluate_constraints( Some(g) => within(g, region), None => false, }, - LayoutConstraint::SystemBreakAt { .. } | LayoutConstraint::PageBreakAt { .. } => false, + LayoutConstraint::SystemBreakAt { slot, .. } => breaks.system_starts.contains(slot), + LayoutConstraint::PageBreakAt { slot, .. } => breaks.page_starts.contains(slot), LayoutConstraint::Registered(_, _) => false, }; if holds { @@ -409,8 +490,9 @@ fn evaluate_constraints( magnitude: 1.0, }, affected_objects: Vec::new(), - message: "a preferred (soft) constraint is not honoured by this \ - single-system Minimal solve" + message: "a preferred (soft) break is not honoured by this solve \ + (skipped on the pathological-system path; an IrOverride \ + decision records it)" .to_owned(), }), } @@ -508,14 +590,14 @@ mod tests { fn reports_the_minimal_tier_it_has_earned() { // It evaluates the declared hard constraints, so it reports Minimal — above // the interface-only stub, below the metric-claiming Standard tier. - assert_eq!(Engraver.tier(), SolverTier::Minimal); - assert!(Engraver.tier() > StubSolver.tier()); - assert!(Engraver.tier() < SolverTier::Standard); + assert_eq!(Engraver::default().tier(), SolverTier::Minimal); + assert!(Engraver::default().tier() > StubSolver.tier()); + assert!(Engraver::default().tier() < SolverTier::Standard); // Minimal makes no normalized-metric claim (the catalog is Phase 3). - let report = Engraver.solve(&fixture(), &SolverConfig::default()); + let report = Engraver::default().solve(&fixture(), &SolverConfig::default()); assert_eq!(report.metric_vector, QualityMetricVector::unmeasured()); - assert_eq!(Engraver.version(), ENGRAVER_VERSION); - assert_ne!(Engraver.version(), StubSolver.version()); + assert_eq!(Engraver::default().version(), ENGRAVER_VERSION); + assert_ne!(Engraver::default().version(), StubSolver.version()); } /// Builds a tiny valid constrained IR — a clef and a single note — and lets @@ -593,7 +675,7 @@ mod tests { !input.constraints.is_empty(), "the pipeline declares real constraints" ); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); assert_eq!(report.status, SolveStatus::Solved); assert!(report.satisfied_hard_constraints); assert!(report.unsatisfied_constraints.is_empty()); @@ -623,7 +705,7 @@ mod tests { .id(); vec![LayoutConstraint::NoCollision { a: clef, b: head }] }); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); assert!(report.satisfied_hard_constraints); assert!(report.unsatisfied_constraints.is_empty()); @@ -644,7 +726,7 @@ mod tests { .id(); vec![LayoutConstraint::NoCollision { a: g, b: g }] }); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); // A valid problem whose hard constraint cannot be met is Unsatisfiable, // not an InternalError (which is reserved for solver/structure failures). assert_eq!(report.status, SolveStatus::Unsatisfiable); @@ -653,33 +735,94 @@ mod tests { assert_eq!(report.budget_used.constraint_evaluations, 1); } + /// Total systems across all pages of a resolved layout. + fn system_count(layout: &ResolvedLayoutIR) -> usize { + layout.pages.iter().map(|p| p.systems.len()).sum() + } + #[test] - fn a_hard_break_cannot_be_honoured_by_single_system_minimal() { - use epiphany_layout_ir::{BreakKind, LayoutConstraint}; - // A hard break maps to ConstraintStrength::Required: a single-system - // solve cannot honour it, so the solve is Unsatisfiable. + fn a_hard_break_is_honoured_by_casting_off() { + use epiphany_layout_ir::{BreakKind, DecisionSource, EngravingDecisionKind}; + // Inverse of the pre-casting-off pin (`a_hard_break_cannot_be_honoured_ + // by_single_system_minimal`): a hard break maps to + // ConstraintStrength::Required, and the casting-off pass ALWAYS breaks + // at it — even though that leaves a clef-only first system — so the + // solve is Solved and the system count increases. + let baseline = + Engraver::default().solve(&with_constraints(|_| vec![]), &SolverConfig::default()); + assert_eq!(baseline.status, SolveStatus::Solved); + assert_eq!(system_count(&baseline.layout), 1); + let input = with_constraints(|c| { - let slot = c.horizontal_slots[0].id; + // Slot 0 is the clef lead (trivially at a boundary); the note + // column is the non-trivial break target. + let slot = c.horizontal_slots[1].id; vec![LayoutConstraint::SystemBreakAt { slot, kind: BreakKind::Hard, }] }); - let report = Engraver.solve(&input, &SolverConfig::default()); - assert_eq!(report.status, SolveStatus::Unsatisfiable); - assert_eq!(report.unsatisfied_constraints.len(), 1); + let report = Engraver::default().solve(&input, &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + assert!(report.satisfied_hard_constraints); + assert!(report.unsatisfied_constraints.is_empty()); + assert_eq!( + system_count(&report.layout), + 2, + "the hard break splits the line into two systems" + ); + // The chosen break is recorded as an engraved decision; no user + // override projected this constraint, so it is attributed Automatic. + assert!(report + .layout + .engraving_decisions + .iter() + .any(|d| d.kind == EngravingDecisionKind::SystemBreak + && d.source == DecisionSource::Automatic)); + } - // …but a *soft* break is ConstraintStrength::Preferred: not honouring it - // is a soft-violation warning on a valid, renderable layout — a - // Preferred violation is a warning, never a failure. - let soft = with_constraints(|c| { - let slot = c.horizontal_slots[0].id; + #[test] + fn a_soft_break_with_content_before_it_is_honoured() { + use epiphany_layout_ir::{BreakKind, DecisionSource, EngravingDecisionKind}; + // A soft break whose closing system carries musical content is simply + // honoured: a clean Solved two-system layout, no soft-violation + // warning, and an Automatic engraved decision. + let mut input = two_off_staff_whole_notes(); + let slot = input.horizontal_slots[2].id; // the second note column + input.constraints.push(LayoutConstraint::SystemBreakAt { + slot, + kind: BreakKind::Soft, + }); + let report = Engraver::default().solve(&input, &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + assert!(report.warnings.is_empty()); + assert!(report.satisfied_hard_constraints); + assert_eq!(system_count(&report.layout), 2); + assert!(report + .layout + .engraving_decisions + .iter() + .any(|d| d.kind == EngravingDecisionKind::SystemBreak + && d.source == DecisionSource::Automatic)); + } + + #[test] + fn a_pathological_soft_break_is_skipped_and_recorded_as_ir_override() { + use epiphany_layout_ir::{BreakKind, DecisionSource, EngravingDecisionKind}; + // A soft break at the first note column would close a system containing + // only the clef — no musical content. The documented exceptional path + // skips it: still renderable (a Preferred violation is a warning, never + // a failure), the constraint is reported as a soft violation, and the + // unhonoured preference is recorded as an IrOverride-sourced decision + // (the spec's override-resolution rule: record, don't drop). + let input = with_constraints(|c| { + let slot = c.horizontal_slots[1].id; vec![LayoutConstraint::SystemBreakAt { slot, kind: BreakKind::Soft, }] }); - let report = Engraver.solve(&soft, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); assert_eq!(report.status, SolveStatus::SolvedWithWarnings); assert!(report.status.is_renderable()); assert!( @@ -694,25 +837,46 @@ mod tests { magnitude, } if magnitude == 1.0 ))); + assert_eq!( + system_count(&report.layout), + 1, + "the pathological break was skipped, not honoured" + ); + assert!(report + .layout + .engraving_decisions + .iter() + .any(|d| d.kind == EngravingDecisionKind::SystemBreak + && d.source == DecisionSource::IrOverride)); } #[test] - fn a_users_break_flows_to_a_soft_violation_not_a_failure() { - // End to end: a user system break on the score graph projects through - // the logical stage's break override into a Soft break constraint, - // which this single-system solve does not honour — surfacing as a - // Preferred-violation warning on a valid, renderable layout. + fn a_users_break_is_honoured_and_recorded_with_its_override() { + // Inverse of the pre-casting-off pin (`a_users_break_flows_to_a_soft_ + // violation_not_a_failure`). End to end: a user system break on the + // score graph projects through the logical stage's break override into + // a Soft break constraint, which casting-off HONOURS — the anchored + // column starts a new system at the left margin, the solve is clean + // (Solved, no warnings), and the engraved decision cites the user's + // override id (DecisionSource::UserOverride). use epiphany_core::generators::valid_score; - use epiphany_core::{AnchorOffset, Event, TimeAnchor}; + use epiphany_core::{AnchorOffset, Event, EventPosition, TimeAnchor}; + use epiphany_layout_ir::{DecisionSource, EngravingDecisionKind}; let mut score = valid_score(3); + // The latest pitched onset: a mid-region break target, so the closing + // system carries musical content (the honoured, non-pathological path). let event = score.canvas.regions[0] .staff_instances() .iter() .flat_map(|si| si.voices.iter()) .flat_map(|voice| voice.events.iter().copied()) - .find(|eid| { + .filter(|eid| { matches!(score.events.get(*eid), Some(Event::Pitched(p)) if !p.pitches.is_empty()) }) + .max_by_key(|eid| match score.events.get(*eid).map(|e| e.position()) { + Some(EventPosition::Musical(p)) => Some(p.clone()), + _ => None, + }) .expect("valid_score has a pitched event"); score.canvas.regions[0] .content @@ -725,22 +889,55 @@ mod tests { }); let constrained = to_constrained(&to_logical(&score)); - assert!( - constrained - .constraints - .iter() - .any(|c| matches!(c, LayoutConstraint::SystemBreakAt { .. })), - "the user break projects into a break constraint" - ); - let report = Engraver.solve(&constrained, &SolverConfig::default()); - assert_eq!(report.status, SolveStatus::SolvedWithWarnings); - assert!(report.status.is_renderable()); + let break_slot = constrained + .constraints + .iter() + .find_map(|c| match c { + LayoutConstraint::SystemBreakAt { slot, .. } => Some(*slot), + _ => None, + }) + .expect("the user break projects into a break constraint"); + let origin = constrained + .break_origins + .iter() + .find(|o| o.slot == break_slot) + .expect("the projection records the override attribution"); + + let engraver = Engraver::default(); + let report = engraver.solve(&constrained, &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + assert!(report.warnings.is_empty(), "an honoured break never warns"); assert!(report.satisfied_hard_constraints); assert!(report.unsatisfied_constraints.is_empty()); - assert!(report.warnings.iter().any(|w| matches!( - w.kind, - SolverWarningKind::LargeSoftConstraintViolation { .. } - ))); + assert!( + system_count(&report.layout) >= 2, + "the honoured break increases the system count" + ); + // The break lands at the anchor's column: the anchored slot's glyphs + // now start their system at the page's left content edge (up to the + // ledger-line extension, 0.3 staff spaces, which also participates in + // the system's extent and may sit left of the notehead box). + let left_edge = report + .layout + .glyphs + .iter() + .zip(&constrained.glyphs) + .filter(|(_, c)| c.horizontal_slot == break_slot) + .map(|(r, c)| r.position.x.0 + c.bounding_box.left.0) + .fold(f32::INFINITY, f32::min); + let margin = engraver.geometry().margins.left.0; + assert!( + left_edge >= margin - 1e-3 && left_edge <= margin + 0.5, + "the anchored column starts its system at the left margin \ + (edge {left_edge}, margin {margin})" + ); + // The decision record cites the user's override. + assert!(report + .layout + .engraving_decisions + .iter() + .any(|d| d.kind == EngravingDecisionKind::SystemBreak + && d.source == DecisionSource::UserOverride(origin.override_id))); } #[test] @@ -760,7 +957,7 @@ mod tests { if widths.is_empty() { continue; } - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); for s in report .layout .strokes @@ -885,7 +1082,7 @@ mod tests { "off-staff whole notes earn ledger strokes" ); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); // The wide whole-note columns re-space (their deltas differ), so a midpoint- // anchored ledger would translate by a neighbouring column's delta and drift. // The owning-glyph anchor keeps every ledger at its notehead's offset. @@ -920,7 +1117,7 @@ mod tests { let mut checked = 0; for seed in 0..16 { let input = to_constrained(&to_logical(&valid_score_rich(seed))); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); for s_in in input.strokes.iter().filter(|s| is_rigid_width_stroke(s)) { let lo = s_in.from.x.0.min(s_in.to.x.0); let hi = s_in.from.x.0.max(s_in.to.x.0); @@ -968,7 +1165,7 @@ mod tests { let mut ledgers = 0; let mut pairs = 0; for seed in 0..32 { - let report = Engraver.solve( + let report = Engraver::default().solve( &to_constrained(&to_logical(&valid_score_rich(seed))), &SolverConfig::default(), ); @@ -1010,7 +1207,7 @@ mod tests { #[test] fn solves_the_stub_pipeline_and_preserves_provenance() { let input = fixture(); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); assert_eq!(report.status, SolveStatus::Solved); assert!(report.satisfied_hard_constraints); assert_eq!(report.layout.glyphs.len(), input.glyphs.len()); @@ -1049,7 +1246,7 @@ mod tests { input.validate().is_err(), "the out-of-range stroke is invalid" ); - let report = Engraver.solve(&input, &SolverConfig::default()); + let report = Engraver::default().solve(&input, &SolverConfig::default()); assert_eq!(report.status, SolveStatus::InternalError); assert!(report.layout.glyphs.is_empty()); assert!( @@ -1069,7 +1266,9 @@ mod tests { // from the stub's verbatim baselines. let input = fixture(); assert!(input.glyphs.len() >= 2); - let engraved = Engraver.solve(&input, &SolverConfig::default()).layout; + let engraved = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; let stub = StubSolver.solve(&input, &SolverConfig::default()).layout; assert_ne!( engraved @@ -1092,7 +1291,9 @@ mod tests { // The spacing pass re-places glyphs; the strokes that track them must move // by the same horizontal map, not stay at their constrained coordinates. let input = fixture(); - let engraved = Engraver.solve(&input, &SolverConfig::default()).layout; + let engraved = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; // Constrained x -> engraved x, per glyph. let glyph_map: Vec<(f32, f32)> = input @@ -1134,8 +1335,12 @@ mod tests { #[test] fn solve_is_deterministic_and_quantizable() { let input = fixture(); - let a = Engraver.solve(&input, &SolverConfig::default()).layout; - let b = Engraver.solve(&input, &SolverConfig::default()).layout; + let a = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; + let b = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; // Byte-identical canonical output across solves (Chapter 9 determinism). assert_eq!(a.canonical_bytes(), b.canonical_bytes()); } @@ -1210,7 +1415,7 @@ mod tests { }; let constrained = to_constrained(&logical); - let engraved = Engraver + let engraved = Engraver::default() .solve(&constrained, &SolverConfig::default()) .layout; let mut noteheads: Vec<_> = engraved @@ -1300,7 +1505,7 @@ mod tests { }; let constrained = to_constrained(&logical); - let engraved = Engraver + let engraved = Engraver::default() .solve(&constrained, &SolverConfig::default()) .layout; let x_of = |name: &str| { @@ -1342,8 +1547,8 @@ mod tests { #[test] fn incremental_is_observationally_equivalent_to_full() { let input = fixture(); - let full = Engraver.solve(&input, &SolverConfig::default()); - let inc = Engraver.solve_incremental( + let full = Engraver::default().solve(&input, &SolverConfig::default()); + let inc = Engraver::default().solve_incremental( &input, &full.state, &InvalidationSet { @@ -1386,7 +1591,7 @@ mod tests { // round_trip_with asserts the full provenance contract; a Solved // status also confirms the Engraver satisfied the pipeline's hard // constraints (the stub pipeline declares none, so vacuously). - let report = round_trip_with(&score, &Engraver); + let report = round_trip_with(&score, &Engraver::default()); assert_eq!(report.status, SolveStatus::Solved); } } @@ -1396,7 +1601,7 @@ mod tests { // survived a real geometry change rather than a pass-through. let constrained = to_constrained(&to_logical(&valid_score_rich(11))); assert!(constrained.glyphs.len() >= 2); - let engraved = Engraver + let engraved = Engraver::default() .solve(&constrained, &SolverConfig::default()) .layout; let stub = StubSolver @@ -1426,11 +1631,11 @@ mod tests { fn the_editing_loop_holds_through_the_real_engraver() { use epiphany_core::generators::valid_score_rich; for seed in 0..16u64 { - let report = - epiphany_testkit::editloop::run_edit_loop_with(&valid_score_rich(seed), &Engraver) - .unwrap_or_else(|| { - panic!("seed {seed}: no clickable notehead to drive the loop") - }); + let report = epiphany_testkit::editloop::run_edit_loop_with( + &valid_score_rich(seed), + &Engraver::default(), + ) + .unwrap_or_else(|| panic!("seed {seed}: no clickable notehead to drive the loop")); assert!(report.graph_changed, "seed {seed}: graph unchanged"); assert!( report.selection_preserved, @@ -1439,4 +1644,348 @@ mod tests { assert!(report.render_changed, "seed {seed}: edit not visible"); } } + + // ---- Casting-off (system breaking, stacking, page assignment) ---------- + + /// The QUICKSTART ten-measure hand-off fixture through the default page + /// geometry — the honest multi-system case the goldens lock. + fn ten_measure_constrained() -> ConstrainedLayoutIR { + to_constrained(&to_logical( + &epiphany_testkit::fixtures::ten_measure_single_staff(0x000A_11CE), + )) + } + + #[test] + fn greedy_wrap_breaks_at_measure_boundaries() { + let input = ten_measure_constrained(); + let engraver = Engraver::default(); + let report = engraver.solve(&input, &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + + let layout = &report.layout; + assert_eq!(layout.pages.len(), 1, "two short systems fit one page"); + let systems = &layout.pages[0].systems; + assert!( + systems.len() >= 2, + "the ten-measure fixture (≈99 staff spaces) wraps under the \ + default 90-staff-space content width; got {} system(s)", + systems.len() + ); + // Every wrapped system fits the content width (no measure in this + // fixture is wider than a page), and every system starts at the left + // content margin. + let geometry = engraver.geometry(); + for system in systems { + assert!( + system.bounding_box.size.width.0 <= geometry.content_width() + 1e-3, + "an automatically wrapped system must fit the content width" + ); + assert!( + (system.bounding_box.origin.x.0 - geometry.margins.left.0).abs() < 1e-3, + "every system starts at the left content margin" + ); + } + // The greedy pass breaks at measure boundaries only: each wrapped + // system after the first begins with a barline column. + for system in &systems[1..] { + let top = system.bounding_box.origin.y.0 + system.bounding_box.size.height.0; + let bottom = system.bounding_box.origin.y.0; + let first_glyph = layout + .glyphs + .iter() + .filter(|g| g.position.y.0 >= bottom - 1e-3 && g.position.y.0 <= top + 1e-3) + .min_by(|a, b| a.position.x.0.total_cmp(&b.position.x.0)) + .expect("a wrapped system has glyphs"); + assert!( + first_glyph.glyph.as_str().starts_with("barline"), + "a greedy system boundary sits at a measure boundary, got {}", + first_glyph.glyph.as_str() + ); + } + // One Automatic engraved decision per chosen boundary, *appended* to + // the pipeline's own decisions (which are carried through unchanged). + let appended = layout + .engraving_decisions + .iter() + .filter(|d| !input.engraving_decisions.contains(d)) + .collect::>(); + assert_eq!(appended.len(), systems.len() - 1); + assert!(appended.iter().all(|d| { + d.kind == epiphany_layout_ir::EngravingDecisionKind::SystemBreak + && d.source == epiphany_layout_ir::DecisionSource::Automatic + })); + } + + #[test] + fn a_hard_page_break_starts_a_new_page() { + use epiphany_layout_ir::{BreakKind, DecisionSource, EngravingDecisionKind}; + let mut input = two_off_staff_whole_notes(); + let slot = input.horizontal_slots[2].id; // the second note column + input.constraints.push(LayoutConstraint::PageBreakAt { + slot, + kind: BreakKind::Hard, + }); + let engraver = Engraver::default(); + let report = engraver.solve(&input, &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + assert!(report.satisfied_hard_constraints); + assert_eq!( + report.layout.pages.len(), + 2, + "the hard page break paginates" + ); + assert_eq!(report.layout.pages[0].number, 1); + assert_eq!(report.layout.pages[1].number, 2); + assert_eq!(report.layout.pages[0].systems.len(), 1); + assert_eq!(report.layout.pages[1].systems.len(), 1); + // Page 2's system sits inside page 2's world frame (a full page height + // plus the inter-page gap below page 1's frame). + let geometry = engraver.geometry(); + let page2_content_top = + -(geometry.size.height.0 + crate::INTER_PAGE_GAP) - geometry.margins.top.0; + let system2 = &report.layout.pages[1].systems[0]; + let system2_top = system2.bounding_box.origin.y.0 + system2.bounding_box.size.height.0; + assert!( + (system2_top - page2_content_top).abs() < 1e-3, + "page 2's first system starts at page 2's content top \ + ({system2_top} vs {page2_content_top})" + ); + assert!(report + .layout + .engraving_decisions + .iter() + .any(|d| d.kind == EngravingDecisionKind::PageBreak + && d.source == DecisionSource::Automatic)); + } + + #[test] + fn vertical_stacking_respects_the_inter_system_gap() { + use epiphany_layout_ir::{VerticalBand, VerticalBandId}; + let report = + Engraver::default().solve(&ten_measure_constrained(), &SolverConfig::default()); + let systems = &report.layout.pages[0].systems; + assert!(systems.len() >= 2); + // The gap between consecutive systems' real extents is exactly the + // vertical-band model's preferred inter-system gap. + let preferred = VerticalBand::inter_system_gap(VerticalBandId(0)) + .preferred_height + .0; + for pair in systems.windows(2) { + let upper_bottom = pair[0].bounding_box.origin.y.0; + let lower_top = pair[1].bounding_box.origin.y.0 + pair[1].bounding_box.size.height.0; + let gap = upper_bottom - lower_top; + assert!( + (gap - preferred).abs() < 1e-3, + "inter-system gap {gap} != preferred {preferred}" + ); + } + } + + #[test] + fn page_overflow_starts_a_second_page() { + use epiphany_layout_ir::{Margins, Size2D, StaffSpace}; + // A deliberately small page: 50×10 staff spaces of content, so the + // ten-measure fixture wraps into systems (≈7 staff spaces tall) of + // which only one fits a page — the multi-page path. + let geometry = PageGeometry { + size: Size2D { + width: StaffSpace(60.0), + height: StaffSpace(20.0), + }, + margins: Margins { + top: StaffSpace(5.0), + right: StaffSpace(5.0), + bottom: StaffSpace(5.0), + left: StaffSpace(5.0), + }, + }; + let engraver = Engraver::with_geometry(geometry); + let report = engraver.solve(&ten_measure_constrained(), &SolverConfig::default()); + assert_eq!(report.status, SolveStatus::Solved, "{:?}", report.warnings); + let pages = &report.layout.pages; + assert!(pages.len() >= 2, "a 10-staff-space content page overflows"); + for (index, page) in pages.iter().enumerate() { + assert_eq!(page.number, index as u32 + 1, "page numbers are 1-based"); + assert!(!page.systems.is_empty(), "no page is emitted empty"); + assert_eq!(page.size, geometry.size); + assert_eq!(page.margins, geometry.margins); + // Every system lies within its page's content frame. + let page_top = -(index as f32) * (geometry.size.height.0 + crate::INTER_PAGE_GAP); + let content_top = page_top - geometry.margins.top.0; + let content_bottom = content_top - geometry.content_height(); + for system in &page.systems { + let top = system.bounding_box.origin.y.0 + system.bounding_box.size.height.0; + let bottom = system.bounding_box.origin.y.0; + assert!( + top <= content_top + 1e-3 && bottom >= content_bottom - 1e-3, + "system [{bottom}, {top}] escapes page {} content \ + [{content_bottom}, {content_top}]", + page.number + ); + } + } + } + + #[test] + fn the_resolved_page_tree_is_populated() { + use std::collections::BTreeSet; + let report = + Engraver::default().solve(&ten_measure_constrained(), &SolverConfig::default()); + let page = &report.layout.pages[0]; + assert_eq!(page.number, 1); + assert!(page.size.width.0 > 0.0 && page.size.height.0 > 0.0); + assert!(page.free_objects.is_empty()); + + let mut system_ids = BTreeSet::new(); + let mut measure_ids = BTreeSet::new(); + let mut measure_records = 0usize; + let mut previous_top = f32::INFINITY; + for system in &page.systems { + // Real, ordered bounding boxes: non-default, stacked top to bottom. + assert!(system.bounding_box.size.width.0 > 0.0); + assert!(system.bounding_box.size.height.0 > 0.0); + let top = system.bounding_box.origin.y.0 + system.bounding_box.size.height.0; + assert!(top < previous_top, "systems are ordered top to bottom"); + previous_top = top; + assert!( + system_ids.insert(system.provenance.stable_id), + "each system has a distinct stable id" + ); + // One staff record (the fixture is single-staff), spanning the + // system and standing four staff spaces tall (plus line thickness). + assert_eq!(system.staves.len(), 1); + let staff = &system.staves[0]; + let staff_height = staff.bounding_box.size.height.0; + assert!( + (4.0..4.5).contains(&staff_height), + "a five-line staff spans four staff spaces, got {staff_height}" + ); + assert!(staff.bounding_box.size.width.0 > 0.0); + // Measure records: within the system box, ordered by x, distinct. + let mut previous_x = f32::NEG_INFINITY; + for measure in &system.measures { + measure_records += 1; + assert!(measure_ids.insert(measure.measure), "measures are distinct"); + let x = measure.bounding_box.origin.x.0; + assert!(x > previous_x, "measures are ordered by x"); + previous_x = x; + assert!(measure.bounding_box.size.width.0 > 0.0); + assert!( + x >= system.bounding_box.origin.x.0 - 1e-3 + && x + measure.bounding_box.size.width.0 + <= system.bounding_box.origin.x.0 + + system.bounding_box.size.width.0 + + 1e-3, + "a measure record lies within its system" + ); + } + } + // Nine of the fixture's ten measures are marked by a start barline + // column (the final-barline measure's start is not marked by any + // column in this projection, so its record is honestly omitted). + assert_eq!(measure_records, 9); + } + + #[test] + fn casting_off_is_deterministic_byte_for_byte() { + // Chapter 9 determinism over the full multi-system output: two solves + // of the wrapping fixture produce byte-identical canonical layouts. + let input = ten_measure_constrained(); + let a = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; + let b = Engraver::default() + .solve(&input, &SolverConfig::default()) + .layout; + assert_eq!(a.canonical_bytes(), b.canonical_bytes()); + } + + #[test] + fn staff_lines_are_split_per_system_with_synthesized_continuations() { + use epiphany_layout_ir::SynthesisKind; + let input = ten_measure_constrained(); + let report = Engraver::default().solve(&input, &SolverConfig::default()); + let systems = &report.layout.pages[0].systems; + assert!(systems.len() >= 2); + // Five lines of one staff, one segment per system: the first segment of + // each keeps the original stroke's provenance; each later one is + // synthesized under the continuation registry kind. + let continuations = report + .layout + .strokes + .iter() + .filter(|s| { + s.provenance.synthesis + == Some(SynthesisKind::Registered(SYSTEM_CONTINUATION_SYNTHESIS)) + }) + .count(); + assert_eq!( + continuations, + 5 * (systems.len() - 1), + "one synthesized continuation per staff line per later system" + ); + // Every input stroke's provenance survives (the first segments). + for stroke in &input.strokes { + assert!( + report + .layout + .strokes + .iter() + .any(|s| s.provenance == stroke.provenance), + "an input stroke's provenance was lost in the split" + ); + } + // Each system's staff-line segments stay within their system's box. + for system in systems { + let staff = &system.staves[0]; + let box_left = system.bounding_box.origin.x.0; + let box_right = box_left + system.bounding_box.size.width.0; + assert!(staff.bounding_box.origin.x.0 >= box_left - 1e-3); + assert!( + staff.bounding_box.origin.x.0 + staff.bounding_box.size.width.0 <= box_right + 1e-3 + ); + } + } + + #[test] + fn hit_testing_resolves_a_glyph_in_the_second_system() { + use epiphany_layout_ir::{to_render, HitShape, Point, PrimitiveRef}; + let input = ten_measure_constrained(); + let report = Engraver::default().solve(&input, &SolverConfig::default()); + let first_system_bottom = report.layout.pages[0].systems[0].bounding_box.origin.y.0; + // A real notehead that wrapped into a later system (below the first). + let (index, glyph) = report + .layout + .glyphs + .iter() + .enumerate() + .filter(|(_, g)| { + g.glyph.as_str().starts_with("notehead") && g.provenance.synthesis.is_none() + }) + .min_by(|a, b| a.1.position.y.0.total_cmp(&b.1.position.y.0)) + .expect("the fixture has noteheads"); + assert!( + glyph.position.y.0 < first_system_bottom, + "the lowest notehead sits below the first system (it wrapped)" + ); + // The baked world frame is the hit-test frame: clicking its box centre + // resolves to the same glyph and its score-graph source. + let render = to_render(&report.layout); + let map = render.hit_test_map(); + let region = map + .regions + .iter() + .find(|r| r.primitive == PrimitiveRef::Glyph(index)) + .expect("every glyph has a hit region"); + let HitShape::Box(bounds) = region.shape else { + panic!("a glyph hit region is a box"); + }; + let click = Point::new( + (bounds.left.0 + bounds.right.0) / 2.0, + (bounds.bottom.0 + bounds.top.0) / 2.0, + ); + let top = map.hit(click).into_iter().next().expect("the click hits"); + assert_eq!(top.layout_object, glyph.provenance.stable_id); + assert_eq!(top.source, glyph.provenance.source); + } } diff --git a/crates/epiphany-engrave/src/spacing.rs b/crates/epiphany-engrave/src/spacing.rs index 561219d..6b818ed 100644 --- a/crates/epiphany-engrave/src/spacing.rs +++ b/crates/epiphany-engrave/src/spacing.rs @@ -15,8 +15,10 @@ //! accidental zone). Reserving the next slot's left overhang against *this* slot's //! advance is what protects a note's accidental from overlapping the previous //! note — a single per-slot `preferred_width` could only reserve space to the -//! right of a slot's source. The vertical pass, the soft-spring stretch/compress -//! solve, and constraint evaluation remain `Minimal`-tier work (next phase). +//! right of a slot's source. The casting-off pass (`crate::casting`) then breaks +//! this spaced line into systems and pages; the vertical soft-spring +//! stretch/compress solve and per-system justification remain deferred (see +//! `DECISIONS.md`). use std::collections::BTreeMap; diff --git a/crates/epiphany-layout-ir/DECISIONS.md b/crates/epiphany-layout-ir/DECISIONS.md index 7065de0..1afe0f1 100644 --- a/crates/epiphany-layout-ir/DECISIONS.md +++ b/crates/epiphany-layout-ir/DECISIONS.md @@ -349,6 +349,35 @@ object is covered); the provenance-preservation contract itself is unchanged. > `req:binfmt:condition-depth`), and adopts the open-value `ObjectKind` > decode stance (P12-E3, `req:binfmt:object-kind-open`). +- **Casting-off support surface (2026-07, the engrave casting-off slice).** + Three small, non-canonical additions made for `epiphany-engrave`'s + casting-off pass, kept here because they are IR-shape/contract concerns: + 1. **`ConstrainedLayoutIR.break_origins` (`BreakOrigin`)** — the spec's + `LayoutConstraint` enum is normative and carries no origin field, but a + casting-off solver that honours a user break must record the decision with + `DecisionSource::UserOverride(id)` (Chapter 7 §"Note Layout" / + §"Engraving Overrides"), and the override id would otherwise be lost at the + logical→constrained boundary. The projection therefore records the + attribution *alongside* the constraint list (slot, break class, override + id) rather than widening the normative enum. Non-canonical, like every + constrained-stage value. + 2. **`continuation_instance_key`** — the stable + `SynthesisInstanceKey` derivation for engraver-synthesized *continuations* + of an existing object (the per-system segments a casting-off break cuts a + region-spanning staff line into): keyed on the original object's stable id + plus the 1-based continuation ordinal, hashed under `MUSCLOID` domain + separation so segments of different lines cannot collide for one + `(source, kind)` pair. + 3. **Round-trip contract: solver-synthesized additions.** `round_trip_with` + previously asserted the constrained→resolved provenance maps *equal*; a + casting-off solver legitimately synthesizes new objects (staff-line + continuation segments), which Chapter 7 §"Provenance" explicitly allows + for engraver-synthesized objects. The contract is now: every constrained + object survives with its exact provenance (containment, not equality); + every solver addition must declare a `SynthesisKind` and derive from an + already-laid-out source (so the recovered source set is unchanged); the + `Stub` tier must add nothing. + ## Pass 12 candidates (ambiguities for the spec, not resolved in code) 1. **Strength attachment to constraint instances.** Chapter 9 §"Strength Levels" diff --git a/crates/epiphany-layout-ir/src/barrier.rs b/crates/epiphany-layout-ir/src/barrier.rs index d912993..64bf3f3 100644 --- a/crates/epiphany-layout-ir/src/barrier.rs +++ b/crates/epiphany-layout-ir/src/barrier.rs @@ -1100,16 +1100,17 @@ mod tests { tag: 7 }) ); - // Operation-kind tag 24 is one past the v1 vocabulary. + // Operation-kind tag 28 is one past the v1 vocabulary (the Phase-3 + // ops tranche appended 24..=27; encodings are append-only). let mut bytes = vec![0u8]; bytes.extend(set_blob(&[])); - bytes.extend(set_blob(&[vec![24u8]])); + bytes.extend(set_blob(&[vec![28u8]])); bytes.push(0); assert_eq!( EditBarrier::decode_canonical_bytes(&bytes), Err(BarrierDecodeError::InvalidTag { kind: "OperationKindTag", - tag: 24 + tag: 28 }) ); } diff --git a/crates/epiphany-layout-ir/src/constrained.rs b/crates/epiphany-layout-ir/src/constrained.rs index fae3f78..5f27c7d 100644 --- a/crates/epiphany-layout-ir/src/constrained.rs +++ b/crates/epiphany-layout-ir/src/constrained.rs @@ -106,6 +106,12 @@ pub struct ConstrainedLayoutIR { pub strokes: Vec, pub vertical_bands: Vec, pub constraints: Vec, + /// The user-override attributions behind the projected break constraints in + /// `constraints` (one entry per break constraint that originated in a user + /// break override), so a casting-off solver can cite the override id in the + /// decision it records. Engraver-independent constraints (tests, tools) have + /// no entry here and are attributed `DecisionSource::Automatic`. + pub break_origins: Vec, pub engraving_decisions: Vec, /// Engraving-coverage gaps surfaced rather than hidden: a pitch with no /// resolved spelling, a glyph the bundled metrics do not carry. Not a hard @@ -176,6 +182,29 @@ pub enum BreakKind { Soft, } +/// Which break-constraint family a [`BreakOrigin`] attributes: a +/// [`LayoutConstraint::SystemBreakAt`] or a [`LayoutConstraint::PageBreakAt`]. +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +pub enum BreakClass { + System, + Page, +} + +/// The user-override origin of a projected break constraint (Chapter 7 +/// §"Engraving Overrides"): the spring slot the override's anchor realized to, +/// which break family it projected into, and the override id. The +/// [`LayoutConstraint`] enum is the spec's normative shape and carries no +/// origin, so the projection records the attribution alongside the constraint +/// list; a casting-off solver that honours the break cites this id in its +/// engraving-decision record (`DecisionSource::UserOverride`, Chapter 7 +/// §"Note Layout"). Non-canonical, like every constrained-stage value. +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +pub struct BreakOrigin { + pub slot: SpringSlotId, + pub class: BreakClass, + pub override_id: crate::engraving::EngravingOverrideId, +} + #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] pub struct ConstraintRegistryId(pub u128); @@ -497,14 +526,18 @@ const TIME_SIG_X: f32 = 0.5; // a time signature sits this far right of its barl const TIME_DIGIT_X: f32 = 0.8; // x advance per time-signature digit /// The horizontal half-reach of an emitted `PositionWithin` region, in staff -/// spaces. v0 performs no casting-off, so a region imposes no *horizontal* -/// bound on its glyphs — a conformant solver may re-space columns freely along -/// the open canvas. The containment obligation v0 can honestly state is the -/// **vertical** envelope (which the spacing pass computes from the very glyph -/// geometry the solvers preserve), so the emitted rect pins that envelope and -/// leaves the horizontal span at canvas scale: wide enough for any plausible -/// re-spacing, finite because the validator rejects non-finite constraint -/// regions. +/// spaces. The constrained stage performs no casting-off, so a region imposes +/// no *horizontal* bound on its glyphs — a conformant solver may re-space +/// columns freely along the open canvas. The containment obligation this stage +/// can honestly state is the **vertical** envelope (which the spacing pass +/// computes from the very glyph geometry it emits), so the emitted rect pins +/// that envelope and leaves the horizontal span at canvas scale: wide enough +/// for any plausible re-spacing, finite because the validator rejects +/// non-finite constraint regions. Geometric constraints are expressed — and +/// evaluated — in *this stage's frame*: a casting-off solver that relocates +/// whole systems (a per-system rigid motion) evaluates them against its +/// pre-casting spaced geometry, where the obligation is meaningful (see +/// `epiphany-engrave`). const POSITION_WITHIN_X_REACH: f32 = 1.0e6; /// The registry id for the engraver's **structural-line synthesis** (staff @@ -583,6 +616,7 @@ pub fn try_to_constrained( let mut vertical_bands = Vec::new(); let mut horizontal_slots = Vec::new(); let mut constraints = Vec::new(); + let mut break_origins = Vec::new(); let mut constrained_regions = Vec::new(); // Regions tile left-to-right; this advances by each region's width so all // coordinates stay globally monotonic (the solver's coordinate remap relies @@ -1348,6 +1382,17 @@ pub fn try_to_constrained( } else { LayoutConstraint::PageBreakAt { slot, kind } }); + // Record the attribution so the casting-off solver's decision can + // cite the user override that asked for this break. + break_origins.push(BreakOrigin { + slot, + class: if system { + BreakClass::System + } else { + BreakClass::Page + }, + override_id: override_record.id, + }); } // A staff band per manifested staff that carries glyphs, in first-glyph @@ -1398,6 +1443,7 @@ pub fn try_to_constrained( strokes, vertical_bands, constraints, + break_origins, engraving_decisions: logical.engraving_decisions.clone(), diagnostics, catalog, diff --git a/crates/epiphany-layout-ir/src/lib.rs b/crates/epiphany-layout-ir/src/lib.rs index 816b0e2..b9de1f6 100644 --- a/crates/epiphany-layout-ir/src/lib.rs +++ b/crates/epiphany-layout-ir/src/lib.rs @@ -92,10 +92,10 @@ pub use cache::{ ResolvedSystemCache, SystemId, }; pub use constrained::{ - active_clef, is_rigid_width_stroke, to_constrained, try_to_constrained, Axis, BreakKind, - ConstrainedLayoutIR, ConstrainedLayoutRegion, ConstrainedValidationError, ConstraintParameters, - ConstraintRegistryId, GlyphObject, GlyphObjectId, GlyphStyle, LayoutConstraint, - LayoutTransformError, SpringSlot, Stroke, + active_clef, is_rigid_width_stroke, to_constrained, try_to_constrained, Axis, BreakClass, + BreakKind, BreakOrigin, ConstrainedLayoutIR, ConstrainedLayoutRegion, + ConstrainedValidationError, ConstraintParameters, ConstraintRegistryId, GlyphObject, + GlyphObjectId, GlyphStyle, LayoutConstraint, LayoutTransformError, SpringSlot, Stroke, }; pub use engrave_theory::{ accidental_glyph, clef_glyph, flag_glyph, has_stem, key_signature, notehead_glyph, rest_glyph, @@ -123,8 +123,8 @@ pub use logical::{ VerticalExtent, }; pub use provenance::{ - manifestation_layout_id, stable_layout_id, synthesized_layout_id, LayoutObjectId, Provenance, - SynthesisInstanceKey, SynthesisKind, SynthesisRegistryId, + continuation_instance_key, manifestation_layout_id, stable_layout_id, synthesized_layout_id, + LayoutObjectId, Provenance, SynthesisInstanceKey, SynthesisKind, SynthesisRegistryId, }; pub use render::{ to_render, ColorConfiguration, ColorSpace, PassthroughRenderProducer, diff --git a/crates/epiphany-layout-ir/src/provenance.rs b/crates/epiphany-layout-ir/src/provenance.rs index 927a3a8..2b49211 100644 --- a/crates/epiphany-layout-ir/src/provenance.rs +++ b/crates/epiphany-layout-ir/src/provenance.rs @@ -194,11 +194,49 @@ pub fn synthesized_layout_id( LayoutObjectId(p.finish_trunc128()) } +/// Derives the [`SynthesisInstanceKey`] for an engraver-synthesized +/// **continuation** of an existing layout object — e.g. the segment of a +/// region-spanning staff line that a casting-off system break places in a later +/// system. Keyed on the original object's stable id (which already encodes its +/// full semantic identity — source, manifestation, line index) and the 1-based +/// continuation ordinal, hashed under the layout domain tag so keys from +/// different originals can never collide for one `(source, kind)` pair. The +/// ordinal names *which continuation of that object* the key identifies (its +/// second system's segment, its third's, …), which is the segment's semantic +/// identity — a casting-off artefact exists only relative to the break +/// structure that created it. +pub fn continuation_instance_key(original: LayoutObjectId, ordinal: u32) -> SynthesisInstanceKey { + let mut p = Preimage::new(DomainTag::LAYOUT_OBJECT_ID); + p.push_bytes(b"synthesis-instance/continuation"); + p.push_u64_le((original.0 >> 64) as u64); + p.push_u64_le(original.0 as u64); + p.push_u64_le(ordinal as u64); + SynthesisInstanceKey(p.finish_trunc128()) +} + #[cfg(test)] mod tests { use super::*; use epiphany_core::{EventId, RegionId}; + #[test] + fn continuation_keys_are_stable_and_distinct() { + let a = LayoutObjectId(0x1111); + let b = LayoutObjectId(0x2222); + assert_eq!( + continuation_instance_key(a, 1), + continuation_instance_key(a, 1) + ); + assert_ne!( + continuation_instance_key(a, 1), + continuation_instance_key(a, 2) + ); + assert_ne!( + continuation_instance_key(a, 1), + continuation_instance_key(b, 1) + ); + } + #[test] fn stable_id_is_a_pure_function_of_source() { let src = TypedObjectId::Event(EventId::from_raw(0x1234)); diff --git a/crates/epiphany-layout-ir/src/roundtrip.rs b/crates/epiphany-layout-ir/src/roundtrip.rs index 5c6d958..6a3ccf8 100644 --- a/crates/epiphany-layout-ir/src/roundtrip.rs +++ b/crates/epiphany-layout-ir/src/roundtrip.rs @@ -128,6 +128,12 @@ pub fn round_trip(score: &Score) -> RoundTripReport { /// and `stable_id` — must survive that re-spacing unchanged, and the recovered /// source set must still be exactly the set laid out. This is the strictly stronger /// statement: a solver may move geometry, never lose a provenance trace. +/// +/// A conformant solver may also **synthesize** additional objects of its own — a +/// casting-off pass splits a region-spanning staff line into per-system segments — +/// provided each addition declares a [`SynthesisKind`](crate::SynthesisKind) and +/// derives from a source that is already laid out (so the recovered source set is +/// unchanged); the stub passthrough must add nothing. pub fn round_trip_with(score: &Score, solver: &S) -> RoundTripReport { let logical = to_logical(score); let constrained = to_constrained(&logical); @@ -231,10 +237,39 @@ pub fn round_trip_with(score: &Score, solver: &S) -> RoundT .map(|g| &g.provenance) .chain(report.layout.strokes.iter().map(|s| &s.provenance)), ); - assert_eq!( - constrained_map, resolved_map, - "provenance not preserved constrained -> resolved" - ); + // Every constrained object survives into the resolved layout with its exact + // provenance. A conformant solver may additionally *synthesize* objects of + // its own — a casting-off pass splits a region-spanning staff line into + // per-system segments (Chapter 7 §"Provenance": engraver-synthesized + // objects declare a `SynthesisKind`) — so the resolved map may be a strict + // superset; the stub tier, a verbatim passthrough, must add nothing. + for (id, provenance) in &constrained_map { + assert_eq!( + resolved_map.get(id), + Some(provenance), + "constrained object {id:?} is not preserved (with its exact provenance) in resolved" + ); + } + let constrained_sources: BTreeSet = + constrained_map.values().map(|p| p.source).collect(); + for (id, provenance) in &resolved_map { + if constrained_map.contains_key(id) { + continue; + } + assert_ne!( + solver.tier(), + SolverTier::Stub, + "the stub passthrough must not add objects (added {id:?})" + ); + assert!( + provenance.synthesis.is_some(), + "solver-added object {id:?} must declare a synthesis kind" + ); + assert!( + constrained_sources.contains(&provenance.source), + "solver-added object {id:?} must derive from a laid-out source, not invent one" + ); + } let render = to_render(&report.layout); for (resolved_glyph, primitive) in report.layout.glyphs.iter().zip(&render.primitives) { diff --git a/crates/epiphany-layout-ir/src/solver.rs b/crates/epiphany-layout-ir/src/solver.rs index f6f74a4..51cd85c 100644 --- a/crates/epiphany-layout-ir/src/solver.rs +++ b/crates/epiphany-layout-ir/src/solver.rs @@ -607,6 +607,7 @@ mod tests { strokes: vec![], vertical_bands: vec![band], constraints: vec![], + break_origins: vec![], engraving_decisions: vec![], diagnostics: vec![], catalog, @@ -693,6 +694,7 @@ mod tests { strokes: vec![], vertical_bands: vec![band], constraints: vec![], + break_origins: vec![], engraving_decisions: vec![], diagnostics: vec![], catalog: GlyphCatalogIdentity::default(), diff --git a/crates/epiphany-ops/DECISIONS.md b/crates/epiphany-ops/DECISIONS.md index dfd0d15..c710cfe 100644 --- a/crates/epiphany-ops/DECISIONS.md +++ b/crates/epiphany-ops/DECISIONS.md @@ -783,3 +783,136 @@ equivocation fuzz plus the unchanged `run_equivocation_fuzz` gate this). ~87K env/s at 1K / 10K / 50K — the 50K row cleared its budget by ~8.7x, the gate printed its XPASS promotion notice, and the row was flipped to `Pass` in the same change (see `epiphany-testkit/DECISIONS.md` F1). + +## Phase-3 first tranche: staff/meter/tempo/layout ops + value-restoring undo (2026-07) + +The ratified catalog text (operation_catalog §CreateStaff, §"Meter and Tempo +Overwrites", §SetStaffLayout, and the **rewritten** §UndoTransaction) is the +contract for this tranche. Wire facts are strictly additive: +`OperationKind` discriminants `CreateStaff = 24`, `SetTimeSignature = 25`, +`SetTempoSegment = 26`, `SetStaffLayout = 27`; `OperationKindTag` +discriminants `InsertStaff = 24` (Create→Insert tag naming, cf. +`InsertRegion`), `SetTimeSignature = 25`, `SetTempoSegment = 26`, +`SetStaffLayout = 27`; `PreconditionFailureReason::TempoMapMalformed = 11`. +No other discriminant table changed. Decisions the catalog left to the +implementation: + +- **The differing-value re-create / re-carry precondition reason is + `TargetMissing`.** §CreateStaff makes a byte-identical re-create idempotent + (`AlreadyApplied`) and a differing value under a live id "a precondition + no-op", without naming a reason; the reducer reuses `TargetMissing` (the + generic dangling/unusable-target reason `ModifyCrossCutting`'s malformed + branch already uses) rather than minting a new discriminant. The same + discipline (and reason) applies to the `TimeSignature` value a + `SetTimeSignature` carries. A tombstoned id refuses as `TargetTombstoned`. +- **Tempo-map well-formedness is checked against the chain state, under the + coarse resolved-position key.** The resulting-map precondition + (`TempoMapMalformed`) evaluates the scope's prospective segment list built + from the tempo write chains (base-seeded under `reduce_onto`), ordered by + the same `resolved_anchor_position` key the LWW slot uses: carried-start / + key agreement, per-shape end data (a non-constant shape needs `end` + + `end_tempo`; a constant `end_tempo` must equal `start_tempo` — the graph + invariant checker's rules), resolved ends ≥ their start and ≤ the next + key. Removals cannot malform a map (the gap rule holds the prior tempo) and + always apply. +- **Graph normalization on removal.** A meter removal that empties a grid the + meter writes themselves created normalizes the region's + `default_metric_grid` back to `None` (unless a whole-grid write or the base + holds a grid independently); a tempo-segment removal that leaves a region's + local map empty and `initial`-less normalizes `local_tempo_map` to `None` + (an empty local map would *shadow* the score map rather than fall back to + it). Both keep "create on set" and "remove last" inverses of each other. +- **`CreateStaffInstance` now preconditions a live staff — graph-aware only.** + §CreateStaff makes the check normative now that staves are mintable; like + the insert preconditions, it is enforced when a graph is present (base-free + reduction has no staff universe), which keeps every existing seeded-base + scenario vacuously green. `CreateStaff`'s own instrument/group resolution + preconditions are graph-aware for the same reason. + +### Value-restoring undo: the write-chain design + +Every LWW overwrite family now maintains, per key, the **canonical-order write +chain** `WriteChain { base: Option, writes: Vec<(op, tx, value)> }` +(replacing the former `last_*` last-writer maps; each chain's last write is +still the LWW concurrent-differing comparison point). Families: event modify, +identified-pitch modify, respell, cross-cutting modify, metadata, metric grid, +meter change (new), tempo segment (new), staff layout (new), and the user +system/page breaks. The reducer applies operations in canonical order, so +appends are inherently canonical and every verdict below is +permutation-invariant by construction (pinned by +`undo_restoration_is_permutation_invariant` and the convergence gates). + +- **Seeding.** `seed_from_graph` seeds each chain's `base` with the base-graph + value (events, pitch values, cross-cutting values, metadata, grids, meter + changes, tempo segments, staff-instance layout fields, break anchors, and + explicit user-chosen per-pitch spelling attachments). Mints seed the chains + they create state for (`InsertEvent` → event + pitch chains, + `InsertIdentifiedPitch` → pitch chain, `CreateCrossCutting` → structure + chain, `CreateRegion` → grid/meter/break/tempo chains from the carried + content, `CreateStaffInstance` → layout chain), so a chain-predecessor is + defined identically under `reduce()` and `reduce_onto()` for op-minted + objects. Only base objects in base-free reduction lack seeds — the + established API-divergence caveat (see M2d) applies unchanged. +- **Undo verdict per written key** (`WriteChain::undo_verdict`): if the target + transaction's write is still the key's last, restore the chain-predecessor — + the latest non-member write, else the base value, else *absence*; if a later + writer superseded it, `StrictInverse` refuses the **whole** undo with a + `TransactionConflict` (`caused_by` = undo + the canonically-first + superseding writer) while `BestEffort` restores the still-last keys and + skips the superseded. Keys whose owning object is tombstoned — or is itself + one of the transaction's mints, about to be tombstoned by the same undo — + are skipped entirely (no live slot to restore; not a conflict). +- **Absence semantics per key.** Optional slots restore literal absence: the + grid clears, the meter change / tempo segment / break is removed (with the + normalizations above). The canonical bookkeeping maps (`spellings`, + `breaks`, `page_breaks`) return to **key-absence** whenever the predecessor + is the *base* value — base state lives in the graph, not the operational + ledger — while the graph restores the base value (spelling attachment, + break anchor). Always-valued families (event, pitch, cross-cutting, + metadata, staff layout) with no known predecessor (reachable only base-free, + for pre-horizon objects) restore nothing — a bookkeeping-only outcome. +- **Effects.** A fully clean compensation is `Applied`; `AppliedWithRepair` + carries **only** the minted-object tombstone repairs (`CascadeDeleted`), per + the catalog — restorations add no repair vocabulary. A transaction that + minted nothing and wrote nothing this reduction knows of stays the + `TargetMissing` no-op (the pre-tranche behavior); a transaction that *did* + write chains is now genuinely undoable — the sanctioned semantic change to + previously-TargetMissing overwrite-transaction undos. +- **Mixed transactions** compose both passes; `StrictInverse` refuses the + whole undo if *either* part fails (a tombstoned mint keeps the pre-existing + `TombstonedTarget` conflict; a superseded key raises the + `TransactionConflict` above), and the refusal applies nothing. Two new + strand guards protect the mint pass: a minted `Staff` still manifested by a + live non-member instance, and a minted `TimeSignature` still referenced by + a meter change that survives the restoration pass, refuse under + `StrictInverse` (a `TransactionConflict` naming the blocked object and its + referencer — reusing ratified conflict vocabulary rather than minting a new + kind; a dedicated "stranded reference" kind is a Pass-12 question) and are + skipped (left live) under `BestEffort`. +- **Undo-of-undo (pinned).** A restoration that restores a *value* enters the + key's chain as a new write by the undo operation. Consequences, both + pinned by tests: (i) undoing the first undo's own enclosing transaction + restores the value the first undo removed + (`undo_of_undo_restores_the_pre_undo_value`); (ii) a *second* undo of the + same target transaction finds the key superseded by the first undo — + `Conflicted` under `StrictInverse`, skipped under `BestEffort` + (`a_second_undo_of_the_same_transaction_sees_the_first_as_superseding`). + An *absence* restoration is not representable as a chain write and leaves + the chain unchanged, so repeating it is idempotent — the one asymmetry, + accepted until a chain-native absence entry is worth its weight. +- **Deferred residue** (unchanged from the catalog's "Still deferred"): + delete resurrection (P11-C8), `Transpose` inversion (P12-K2) — so a + transpose between a write and its undo is *not* re-applied on top of the + restored value (the chain predecessor wins; transpose composition is not a + chain write) — and `Cascade`'s dependent closure (`Cascade` remains + `StrictInverse` over the same set). + +Proposed Pass-12 rows from this tranche: (1) the `TargetMissing` reuse for +differing-value re-creates/re-carries (vs. a dedicated reason discriminant); +(2) a conflict-kind vocabulary for undo strand-blocks (live-reference +tombstone refusal) instead of `TransactionConflict` reuse; (3) whether an +undo's chain write should carry a distinguished provenance so a second undo +of the same transaction could be defined as idempotent rather than +conflicting; (4) P12-C5 stands as filed (the decomposition pre-pass still +honors only the first governing meter — the reduction semantics are pinned +here and tested under `a_mid_region_meter_change_reduces_cleanly_p12_c5`). diff --git a/crates/epiphany-ops/src/decode.rs b/crates/epiphany-ops/src/decode.rs index 0dd173b..fb5c701 100644 --- a/crates/epiphany-ops/src/decode.rs +++ b/crates/epiphany-ops/src/decode.rs @@ -220,6 +220,7 @@ fn precondition_reason(reader: &mut Reader<'_>) -> Result Ok(PreconditionFailureReason::ContainerNotEmpty), + 11 => Ok(PreconditionFailureReason::TempoMapMalformed), tag => Err(MaterializedDecodeError::InvalidTag { kind: "PreconditionFailureReason", tag, diff --git a/crates/epiphany-ops/src/effect.rs b/crates/epiphany-ops/src/effect.rs index aa73886..45cbf87 100644 --- a/crates/epiphany-ops/src/effect.rs +++ b/crates/epiphany-ops/src/effect.rs @@ -152,6 +152,11 @@ pub enum PreconditionFailureReason { /// has live children (an empty-only delete; the caller deletes contents /// first). ContainerNotEmpty, + /// A `SetTempoSegment` write whose *resulting* tempo map would be malformed + /// — segments out of order or overlapping, a non-constant shape missing its + /// end data, or a carried segment whose own start disagrees with the + /// operation's start key (operation_catalog §"Meter and Tempo Overwrites"). + TempoMapMalformed, /// An extension-declared precondition failed. ExtensionPrecondition(ExtensionPreconditionId), /// A registered precondition code from a versioned registry. @@ -173,6 +178,8 @@ impl PreconditionFailureReason { PreconditionFailureReason::Registered(_) => 9, // Additive (Group 3); keeps the ratified 0..=9 discriminants stable. PreconditionFailureReason::ContainerNotEmpty => 10, + // Additive (Phase-3 tranche, SetTempoSegment); appended past 10. + PreconditionFailureReason::TempoMapMalformed => 11, } } } diff --git a/crates/epiphany-ops/src/fuzz.rs b/crates/epiphany-ops/src/fuzz.rs index 4b6d95a..62fc42b 100644 --- a/crates/epiphany-ops/src/fuzz.rs +++ b/crates/epiphany-ops/src/fuzz.rs @@ -30,12 +30,12 @@ use crate::causal::CausalContext; use crate::envelope::OperationEnvelope; use crate::opset::OperationSet; use crate::payload::{ - CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, CreateVoiceOp, CrossCuttingValue, - DeleteCrossCuttingOp, DeleteEventOp, DeleteIdentifiedPitchOp, DeleteRegionOp, - DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, InsertIdentifiedPitchOp, + CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, CreateStaffOp, CreateVoiceOp, + CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, DeleteIdentifiedPitchOp, + DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, InsertIdentifiedPitchOp, ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, OperationKind, OperationPayload, - RespellPitchOp, SetMetadataOp, SetMetricGridOp, SetUserPageBreakOp, SetUserSystemBreakOp, - TransposeOp, TupletCompensation, + RespellPitchOp, SetMetadataOp, SetMetricGridOp, SetStaffLayoutOp, SetTempoSegmentOp, + SetTimeSignatureOp, SetUserPageBreakOp, SetUserSystemBreakOp, TransposeOp, TupletCompensation, }; use crate::stamp::{HybridLogicalClock, OperationStamp}; use crate::support::AuthorId; @@ -85,7 +85,7 @@ fn pitch(n: u64) -> PitchId { /// Generates a random payload over the shared id space. fn gen_payload(rng: &mut SplitMix64) -> OperationPayload { - let kind = match rng.below(21) { + let kind = match rng.below(25) { 0 => { let voice = VoiceId::new(ReplicaId(7), rng.below(3)); let position = MusicalPosition(RationalTime::from_int(rng.below(4) as i32)); @@ -196,7 +196,7 @@ fn gen_payload(rng: &mut SplitMix64) -> OperationPayload { region: RegionId::new(ReplicaId(7), rng.below(3)), grid: rng.chance(2).then(valuegen::metric_grid), }), - _ => OperationKind::SetUserPageBreak(SetUserPageBreakOp { + 20 => OperationKind::SetUserPageBreak(SetUserPageBreakOp { region: RegionId::new(ReplicaId(7), 0), anchor: valuegen::region_start_anchor( RegionId::new(ReplicaId(7), 0), @@ -204,6 +204,57 @@ fn gen_payload(rng: &mut SplitMix64) -> OperationPayload { ), present: rng.chance(2), }), + // Phase-3 first tranche: staff mint, meter/tempo overwrites, layout + // advisory — over the same shared id space so mints, re-carries, + // overwrites, and removals genuinely interact. + 21 => OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff( + StaffId::new(ReplicaId(7), rng.below(3)), + epiphany_core::InstrumentId::new(ReplicaId(7), rng.below(2)), + ), + }), + 22 => { + let region = RegionId::new(ReplicaId(7), rng.below(3)); + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: valuegen::region_start_anchor( + region, + MusicalPosition(RationalTime::from_int(rng.below(3) as i32 * 4)), + ), + time_signature: (!rng.chance(3)).then(|| { + valuegen::time_signature( + epiphany_core::TimeSignatureId::new(ReplicaId(7), rng.below(3)), + rng.below(3) as u16 + 2, + ) + }), + }) + } + 23 => { + let region = RegionId::new(ReplicaId(7), rng.below(3)); + let at = rng.below(3) as i32 * 4; + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: rng.chance(2).then_some(region), + start: valuegen::region_start_anchor( + region, + MusicalPosition(RationalTime::from_int(at)), + ), + segment: (!rng.chance(3)).then(|| { + valuegen::tempo_segment( + region, + MusicalPosition(RationalTime::from_int(at)), + 60.0 + rng.below(4) as f64 * 30.0, + ) + }), + }) + } + _ => OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: StaffInstanceId::new(ReplicaId(7), rng.below(3)), + instrument_override: None, + staff_lines_override: rng + .chance(2) + .then(epiphany_core::StaffLineConfiguration::default), + visible: rng.chance(2), + }), }; OperationPayload::Primitive(kind) } diff --git a/crates/epiphany-ops/src/lib.rs b/crates/epiphany-ops/src/lib.rs index f928f6f..23b341e 100644 --- a/crates/epiphany-ops/src/lib.rs +++ b/crates/epiphany-ops/src/lib.rs @@ -117,11 +117,12 @@ pub use migrate::{migrate_v0_envelope, project_v1_to_v0, MigrationError}; pub use opset::{AcceptOutcome, OperationSet}; pub use payload::{ ChangeRegionTimeModelOp, CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, - CreateVoiceOp, CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, DeleteIdentifiedPitchOp, - DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, InsertIdentifiedPitchOp, - ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, OperationKind, OperationKindTag, - OperationPayload, PositionRemapping, ResolveConflictPayload, ResolveEquivocationPayload, - RespellPitchOp, SetMetadataOp, SetMetricGridOp, SetUserPageBreakOp, SetUserSystemBreakOp, + CreateStaffOp, CreateVoiceOp, CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, + DeleteIdentifiedPitchOp, DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, + InsertIdentifiedPitchOp, ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, + OperationKind, OperationKindTag, OperationPayload, PositionRemapping, ResolveConflictPayload, + ResolveEquivocationPayload, RespellPitchOp, SetMetadataOp, SetMetricGridOp, SetStaffLayoutOp, + SetTempoSegmentOp, SetTimeSignatureOp, SetUserPageBreakOp, SetUserSystemBreakOp, TransactionCategory, TransactionDescriptor, TransposeOp, TupletCompensation, }; pub use reduce::{ diff --git a/crates/epiphany-ops/src/migrate.rs b/crates/epiphany-ops/src/migrate.rs index 687f69a..afd8d05 100644 --- a/crates/epiphany-ops/src/migrate.rs +++ b/crates/epiphany-ops/src/migrate.rs @@ -167,6 +167,11 @@ fn project_kind(kind: &OperationKind) -> V0OperationKind { OperationKind::SetMetadata(op) => V0OperationKind::SetMetadata(op.clone()), OperationKind::SetMetricGrid(op) => V0OperationKind::SetMetricGrid(op.clone()), OperationKind::SetUserPageBreak(op) => V0OperationKind::SetUserPageBreak(op.clone()), + // v1-native (Phase-3 first tranche): projected verbatim. + OperationKind::CreateStaff(op) => V0OperationKind::CreateStaff(op.clone()), + OperationKind::SetTimeSignature(op) => V0OperationKind::SetTimeSignature(op.clone()), + OperationKind::SetTempoSegment(op) => V0OperationKind::SetTempoSegment(op.clone()), + OperationKind::SetStaffLayout(op) => V0OperationKind::SetStaffLayout(op.clone()), } } @@ -309,6 +314,11 @@ fn migrate_kind(kind: &V0OperationKind, context: &Score) -> Result OperationKind::SetMetadata(op.clone()), V0OperationKind::SetMetricGrid(op) => OperationKind::SetMetricGrid(op.clone()), V0OperationKind::SetUserPageBreak(op) => OperationKind::SetUserPageBreak(op.clone()), + // v1-native (Phase-3 first tranche): identity round-trip. + V0OperationKind::CreateStaff(op) => OperationKind::CreateStaff(op.clone()), + V0OperationKind::SetTimeSignature(op) => OperationKind::SetTimeSignature(op.clone()), + V0OperationKind::SetTempoSegment(op) => OperationKind::SetTempoSegment(op.clone()), + V0OperationKind::SetStaffLayout(op) => OperationKind::SetStaffLayout(op.clone()), }) } diff --git a/crates/epiphany-ops/src/payload.rs b/crates/epiphany-ops/src/payload.rs index ebd5603..3da7d60 100644 --- a/crates/epiphany-ops/src/payload.rs +++ b/crates/epiphany-ops/src/payload.rs @@ -33,9 +33,10 @@ use epiphany_core::{ Beam, CanonicalValue, Event, EventDuration, EventId, EventPosition, IdentifiedPitch, - MetricGrid, MusicalDuration, MusicalPosition, OperationId, Pitch, PitchId, PitchSpelling, - Region, RegionId, RegionTimeModel, Rest, ScoreMetadata, Slur, Spanner, StaffInstance, - StaffInstanceId, Tie, TimeAnchor, TransactionId, TupletId, TypedObjectId, Voice, VoiceId, + InstrumentId, MetricGrid, MusicalDuration, MusicalPosition, OperationId, Pitch, PitchId, + PitchSpelling, Region, RegionId, RegionTimeModel, Rest, ScoreMetadata, Slur, Spanner, Staff, + StaffId, StaffInstance, StaffInstanceId, StaffLineConfiguration, TempoSegment, Tie, TimeAnchor, + TimeSignature, TransactionId, TupletId, TypedObjectId, Voice, VoiceId, }; use epiphany_determinism::{sorted_canonical, CanonicalDecode, CanonicalEncode, DecodeError}; @@ -154,6 +155,21 @@ pub enum OperationKind { /// Set a user page-break preference (LWW advisory; the page-break sibling of /// `SetUserSystemBreak`). SetUserPageBreak(SetUserPageBreakOp), + // --- Phase-3 first tranche: staff mint, meter/tempo overwrites, layout + // advisory (operation_catalog §CreateStaff, §"Meter and Tempo Overwrites", + // §SetStaffLayout). Discriminants extend additively past 23. --- + /// Mint a global staff on the score root (set-union creation). + CreateStaff(CreateStaffOp), + /// Set, replace, or remove the single meter change at a resolved position + /// in a region's default metric grid (LWW structural overwrite). + SetTimeSignature(SetTimeSignatureOp), + /// Set, replace, or remove the single tempo segment starting at a resolved + /// position in the score-level or region-local tempo map (LWW structural + /// overwrite). + SetTempoSegment(SetTempoSegmentOp), + /// Overwrite a staff instance's inline layout advisories as a unit (LWW + /// advisory). + SetStaffLayout(SetStaffLayoutOp), } impl OperationKind { @@ -183,6 +199,11 @@ impl OperationKind { OperationKind::SetMetadata(_) => 21, OperationKind::SetMetricGrid(_) => 22, OperationKind::SetUserPageBreak(_) => 23, + // Phase-3 first tranche; appended past the golden-locked 0..=23. + OperationKind::CreateStaff(_) => 24, + OperationKind::SetTimeSignature(_) => 25, + OperationKind::SetTempoSegment(_) => 26, + OperationKind::SetStaffLayout(_) => 27, } } @@ -215,6 +236,11 @@ impl OperationKind { OperationKind::SetMetadata(_) => OperationKindTag::SetMetadata, OperationKind::SetMetricGrid(_) => OperationKindTag::SetMetricGrid, OperationKind::SetUserPageBreak(_) => OperationKindTag::SetUserPageBreak, + // Create→Insert tag-naming convention, cf. `InsertRegion`. + OperationKind::CreateStaff(_) => OperationKindTag::InsertStaff, + OperationKind::SetTimeSignature(_) => OperationKindTag::SetTimeSignature, + OperationKind::SetTempoSegment(_) => OperationKindTag::SetTempoSegment, + OperationKind::SetStaffLayout(_) => OperationKindTag::SetStaffLayout, } } } @@ -250,6 +276,10 @@ impl CanonicalEncode for OperationKind { OperationKind::SetMetadata(op) => op.encode_canonical(out), OperationKind::SetMetricGrid(op) => op.encode_canonical(out), OperationKind::SetUserPageBreak(op) => op.encode_canonical(out), + OperationKind::CreateStaff(op) => op.encode_canonical(out), + OperationKind::SetTimeSignature(op) => op.encode_canonical(out), + OperationKind::SetTempoSegment(op) => op.encode_canonical(out), + OperationKind::SetStaffLayout(op) => op.encode_canonical(out), } } } @@ -284,6 +314,12 @@ pub enum OperationKindTag { DeleteVoice, SetMetadata, SetMetricGrid, + // Phase-3 first tranche. `InsertStaff` follows the tag layer's + // Create→Insert naming convention (cf. `InsertRegion` for `CreateRegion`). + InsertStaff, + SetTimeSignature, + SetTempoSegment, + SetStaffLayout, } impl OperationKindTag { @@ -313,6 +349,11 @@ impl OperationKindTag { OperationKindTag::DeleteVoice => 21, OperationKindTag::SetMetadata => 22, OperationKindTag::SetMetricGrid => 23, + // Phase-3 first tranche; appended past the golden-locked 0..=23. + OperationKindTag::InsertStaff => 24, + OperationKindTag::SetTimeSignature => 25, + OperationKindTag::SetTempoSegment => 26, + OperationKindTag::SetStaffLayout => 27, } } } @@ -378,6 +419,10 @@ impl CanonicalDecode for OperationKindTag { 21 => OperationKindTag::DeleteVoice, 22 => OperationKindTag::SetMetadata, 23 => OperationKindTag::SetMetricGrid, + 24 => OperationKindTag::InsertStaff, + 25 => OperationKindTag::SetTimeSignature, + 26 => OperationKindTag::SetTempoSegment, + 27 => OperationKindTag::SetStaffLayout, _ => return Err(DecodeError::MalformedDomainTag), }) } @@ -1132,6 +1177,150 @@ impl CanonicalEncode for SetUserPageBreakOp { } } +// --- Phase-3 first tranche (operation_catalog §CreateStaff, §"Meter and Tempo +// Overwrites", §SetStaffLayout). ---------------------------------------------- + +/// Mint a global [`Staff`] on the score root (operation_catalog §CreateStaff). +/// Carries the full global-staff value (v1): identity, name, abbreviation, +/// instrument reference, default staff-line configuration, and optional group +/// membership. Set-union creation, completing the structural-container family +/// upward: staff *instances* reference global staves. A repeat create carrying +/// a byte-identical value is idempotent; a differing value under a live id is a +/// precondition no-op. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct CreateStaffOp { + pub staff: Staff, +} + +impl CreateStaffOp { + /// The minted staff's identifier. + pub fn staff_id(&self) -> StaffId { + self.staff.id + } +} + +impl CanonicalEncode for CreateStaffOp { + fn encode_canonical(&self, out: &mut Vec) { + push_lp_bytes(out, &self.staff.canonical_bytes()); + } +} + +/// Set, replace, or (`None`) remove the single meter change at the anchor's +/// resolved musical position in a region's default metric grid +/// (operation_catalog §"Meter and Tempo Overwrites"). Carries the full +/// [`TimeSignature`] value (v1), minted set-union under the same discipline as +/// `CreateStaff`. LWW structural overwrite keyed by `(region, resolved +/// position)`; concurrent differing writes collide on the field +/// `meter_sequence`. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct SetTimeSignatureOp { + pub region: RegionId, + pub anchor: TimeAnchor, + pub time_signature: Option, +} + +impl SetTimeSignatureOp { + /// The anchor's resolved musical position — the canonical LWW key (the + /// same coarse resolution the user-break advisories use). + pub fn resolved_position(&self) -> MusicalPosition { + resolved_anchor_position(&self.anchor) + } +} + +impl CanonicalEncode for SetTimeSignatureOp { + fn encode_canonical(&self, out: &mut Vec) { + push_canon(out, &self.region); + push_lp_bytes(out, &self.anchor.canonical_bytes()); + match &self.time_signature { + None => push_tag(out, 0), + Some(signature) => { + push_tag(out, 1); + push_lp_bytes(out, &signature.canonical_bytes()); + } + } + } +} + +/// Set, replace, or (`None`) remove the single tempo segment starting at the +/// resolved position, in the score-level tempo map (`region: None`) or the +/// region's local map (`Some`; a set on a region with no local map creates +/// one) (operation_catalog §"Meter and Tempo Overwrites"). LWW structural +/// overwrite keyed by `(scope, resolved start)`; a write that would malform +/// the resulting map is refused +/// ([`PreconditionFailureReason::TempoMapMalformed`](crate::PreconditionFailureReason)). +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct SetTempoSegmentOp { + pub region: Option, + pub start: TimeAnchor, + pub segment: Option, +} + +impl SetTempoSegmentOp { + /// The start anchor's resolved musical position — the canonical LWW key's + /// position half (the scope is the other half). + pub fn resolved_start(&self) -> MusicalPosition { + resolved_anchor_position(&self.start) + } +} + +impl CanonicalEncode for SetTempoSegmentOp { + fn encode_canonical(&self, out: &mut Vec) { + // Catalog: an Option discriminant and (when present) `region`, then the + // length-framed `start`, then an Option discriminant and (when present) + // the length-framed `segment`. + match &self.region { + None => push_tag(out, 0), + Some(region) => { + push_tag(out, 1); + push_canon(out, region); + } + } + push_lp_bytes(out, &self.start.canonical_bytes()); + match &self.segment { + None => push_tag(out, 0), + Some(segment) => { + push_tag(out, 1); + push_lp_bytes(out, &segment.canonical_bytes()); + } + } + } +} + +/// Overwrite a staff instance's inline layout advisories as a unit +/// (operation_catalog §SetStaffLayout): the three non-break layout advisories +/// with a graph home (`instrument_override`, `staff_lines_override`, +/// `visible`). LWW *advisory* keyed by `staff_instance` — no conflicts. The +/// richer engraving-override vocabulary has no durable graph home yet and +/// remains projected layout state. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct SetStaffLayoutOp { + pub staff_instance: StaffInstanceId, + pub instrument_override: Option, + pub staff_lines_override: Option, + pub visible: bool, +} + +impl CanonicalEncode for SetStaffLayoutOp { + fn encode_canonical(&self, out: &mut Vec) { + push_canon(out, &self.staff_instance); + match &self.instrument_override { + None => push_tag(out, 0), + Some(instrument) => { + push_tag(out, 1); + push_canon(out, instrument); + } + } + match &self.staff_lines_override { + None => push_tag(out, 0), + Some(lines) => { + push_tag(out, 1); + push_lp_bytes(out, &lines.canonical_bytes()); + } + } + push_u8_bool(out, self.visible); + } +} + #[cfg(test)] mod tests { use super::*; @@ -1142,9 +1331,9 @@ mod tests { // GOLDEN LOCK: the discriminant byte leads every canonically-encoded // primitive payload (operation_catalog §"Value-Typed Payloads"), so the // literal values are normative wire facts. Encodings are append-only: - // new kinds append past 23; the values below never change. + // new kinds append past 27; the values below never change. use crate::valuegen; - use epiphany_core::{MusicalDuration, MusicalPosition, StaffId}; + use epiphany_core::{MusicalDuration, MusicalPosition, TimeSignatureId}; let r = ReplicaId(1); let event_a = EventId::new(r, 1); @@ -1155,6 +1344,7 @@ mod tests { let instance = StaffInstanceId::new(r, 6); let voice = VoiceId::new(r, 7); let slur_id = SlurId::new(r, 8); + let instrument = InstrumentId::new(r, 10); let event_value = || { valuegen::insert_event_value( event_a, @@ -1167,7 +1357,7 @@ mod tests { let slur_value = || CrossCuttingValue::Slur(valuegen::slur(slur_id, event_a, event_b)); let anchor = || valuegen::region_start_anchor(region, MusicalPosition::origin()); - let table: [(OperationKind, u8); 24] = [ + let table: [(OperationKind, u8); 28] = [ ( OperationKind::InsertEvent(InsertEventOp { staff_instance: instance, @@ -1313,6 +1503,41 @@ mod tests { }), 23, ), + ( + OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff(staff, instrument), + }), + 24, + ), + ( + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: anchor(), + time_signature: Some(valuegen::time_signature(TimeSignatureId::new(r, 11), 4)), + }), + 25, + ), + ( + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: Some(region), + start: anchor(), + segment: Some(valuegen::tempo_segment( + region, + MusicalPosition::origin(), + 120.0, + )), + }), + 26, + ), + ( + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: instance, + instrument_override: Some(instrument), + staff_lines_override: None, + visible: true, + }), + 27, + ), ]; for (kind, expected) in &table { assert_eq!( @@ -1430,6 +1655,10 @@ mod tests { OperationKindTag::DeleteVoice, OperationKindTag::SetMetadata, OperationKindTag::SetMetricGrid, + OperationKindTag::InsertStaff, + OperationKindTag::SetTimeSignature, + OperationKindTag::SetTempoSegment, + OperationKindTag::SetStaffLayout, ]; let encoded: std::collections::BTreeSet<_> = tags .iter() @@ -1442,14 +1671,14 @@ mod tests { fn operation_kind_tag_decode_mirrors_encode_exactly() { // Every non-registered variant round-trips through its 1-byte form, and // the registered variant through its 17-byte (tag + registry id) form. - let mut tags: Vec = (0u8..24) + let mut tags: Vec = (0u8..28) .filter(|d| *d != 16) .map(|d| OperationKindTag::decode_canonical(&[d]).expect("known discriminant")) .collect(); tags.push(OperationKindTag::Registered(OperationKindRegistryId( 0x0102_0304_0506_0708_090A_0B0C_0D0E_0F10, ))); - assert_eq!(tags.len(), 24, "the full v1 tag vocabulary"); + assert_eq!(tags.len(), 28, "the full v1 tag vocabulary"); for tag in tags { let bytes = tag.to_canonical_bytes(); let decoded = OperationKindTag::decode_canonical(&bytes).expect("round-trips"); @@ -1465,10 +1694,10 @@ mod tests { #[test] fn operation_kind_tag_decode_rejects_malformed_bytes() { use epiphany_determinism::DecodeError; - // Unknown discriminant (24 is one past the v1 vocabulary): rejected, + // Unknown discriminant (28 is one past the v1 vocabulary): rejected, // never normalized. assert_eq!( - OperationKindTag::decode_canonical(&[24]), + OperationKindTag::decode_canonical(&[28]), Err(DecodeError::MalformedDomainTag) ); // Empty input. @@ -1480,6 +1709,21 @@ mod tests { assert!(OperationKindTag::decode_canonical(&[16; 19]).is_err()); } + #[test] + fn phase3_tag_discriminants_are_golden() { + // GOLDEN LOCK (Phase-3 first tranche): appended past the ratified + // 0..=23; the values below never change. + for (tag, expected) in [ + (OperationKindTag::InsertStaff, 24u8), + (OperationKindTag::SetTimeSignature, 25), + (OperationKindTag::SetTempoSegment, 26), + (OperationKindTag::SetStaffLayout, 27), + ] { + assert_eq!(tag.discriminant(), expected); + assert_eq!(tag.to_canonical_bytes(), vec![expected]); + } + } + #[test] fn reassign_remapping_is_order_independent() { let e1 = EventId::new(ReplicaId(1), 1); diff --git a/crates/epiphany-ops/src/reduce.rs b/crates/epiphany-ops/src/reduce.rs index 9e7e8be..d479748 100644 --- a/crates/epiphany-ops/src/reduce.rs +++ b/crates/epiphany-ops/src/reduce.rs @@ -33,11 +33,13 @@ use std::collections::{BTreeMap, BTreeSet, BinaryHeap}; use epiphany_core::{ canonical_pitch_bytes, derive_promoted_voice_id, AnchorOffset, AnnotationAnchor, - CanonicalValue, Event, EventDuration, EventId, EventPosition, GestureAnchoring, MetricGrid, - MusicalDuration, MusicalPosition, OperationId, Pitch, PitchId, PitchSpelling, RationalTime, - RegionEdge, RegionId, RegionTimeModel, ReplicaId, Score, SpellingAttachment, SpellingDirective, - SpellingScope, SpellingSource, StaffId, StaffInstance, StaffInstanceId, TimeAnchor, - TransactionId, TypedObjectId, Voice, VoiceId, VoiceOrigin, + CanonicalValue, Event, EventDuration, EventId, EventPosition, GestureAnchoring, InstrumentId, + MeterChange, MetricGrid, MusicalDuration, MusicalPosition, OperationId, Pitch, PitchId, + PitchSpelling, RationalTime, RegionEdge, RegionId, RegionTimeModel, ReplicaId, Score, + ScoreMetadata, SpellingAttachment, SpellingDirective, SpellingScope, SpellingSource, Staff, + StaffId, StaffInstance, StaffInstanceId, StaffLineConfiguration, TempoMap, TempoSegment, + TempoShape, TimeAnchor, TimeSignature, TimeSignatureId, TransactionId, TypedObjectId, Voice, + VoiceId, VoiceOrigin, }; use epiphany_determinism::CanonicalEncode; @@ -53,11 +55,12 @@ use crate::encode::{push_canon, push_len, push_lp_bytes, push_u8_bool}; use crate::envelope::OperationEnvelope; use crate::opset::OperationSet; use crate::payload::{ - CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, CreateVoiceOp, CrossCuttingValue, - DeleteCrossCuttingOp, DeleteEventOp, DeleteIdentifiedPitchOp, DeleteRegionOp, - DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, InsertIdentifiedPitchOp, - ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, OperationKind, OperationPayload, - RespellPitchOp, SetMetadataOp, SetMetricGridOp, SetUserPageBreakOp, TransposeOp, + resolved_anchor_position, CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, + CreateStaffOp, CreateVoiceOp, CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, + DeleteIdentifiedPitchOp, DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, InsertEventOp, + InsertIdentifiedPitchOp, ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, + OperationKind, OperationPayload, RespellPitchOp, SetMetadataOp, SetMetricGridOp, + SetStaffLayoutOp, SetTempoSegmentOp, SetTimeSignatureOp, SetUserPageBreakOp, TransposeOp, TupletCompensation, }; use crate::stamp::StampTuple; @@ -618,6 +621,220 @@ pub fn reduce_operation_set_onto(op_set: &OperationSet, base: &Score) -> GraphMa } } +/// One write in a per-key canonical-order write chain (operation_catalog +/// §UndoTransaction, "Value restoration"): the writer, the transaction it was a +/// member of (if any), and the value it wrote. +#[derive(Clone, PartialEq, Eq, Debug)] +struct ChainWrite { + op: OperationId, + tx: Option, + value: V, +} + +/// The canonical-order write chain of one LWW-overwritten key (operation_catalog +/// §UndoTransaction). `base` is the key's pre-operational value — seeded from +/// the base graph (`seed_from_graph`) or from the value a mint carried — so a +/// chain-predecessor is defined for keys that exist before the first overwrite; +/// a key with no base entry restores to *absence*. `writes` append in canonical +/// processing order (the reducer applies operations in canonical order, so +/// appends are inherently canonical and the chain is permutation-invariant). +#[derive(Clone, PartialEq, Eq, Debug)] +struct WriteChain { + base: Option, + writes: Vec>, +} + +impl WriteChain { + fn new() -> Self { + WriteChain { + base: None, + writes: Vec::new(), + } + } + + /// Seeds the base value only if the chain has neither a base nor writes + /// (idempotent seeding; a mint never clobbers recorded history). + fn seed(&mut self, base: V) { + if self.base.is_none() && self.writes.is_empty() { + self.base = Some(base); + } + } + + /// Appends a write in canonical processing order. + fn record(&mut self, op: OperationId, tx: Option, value: V) { + self.writes.push(ChainWrite { op, tx, value }); + } + + /// The most recent write, if any (the LWW concurrency comparison point; + /// the base entry never participates in conflict detection). + fn last_write(&self) -> Option<&ChainWrite> { + self.writes.last() + } + + /// The key's current resolved value: the last write, falling back to the + /// base entry. + fn current(&self) -> Option<&V> { + self.last_write() + .map(|write| &write.value) + .or(self.base.as_ref()) + } + + /// The undo verdict for transaction `tx` on this key (operation_catalog + /// §UndoTransaction, "Value restoration"). + fn undo_verdict(&self, tx: TransactionId) -> ChainUndoVerdict { + if !self.writes.iter().any(|w| w.tx == Some(tx)) { + return ChainUndoVerdict::NotWritten; + } + let last = self.writes.last().expect("chain has a write by `tx`"); + if last.tx != Some(tx) { + return ChainUndoVerdict::Superseded { by: last.op }; + } + // Chain-predecessor: the latest entry not written by the transaction, + // falling back to the base value, else absence. + let predecessor = self + .writes + .iter() + .rev() + .find(|w| w.tx != Some(tx)) + .map(|w| Predecessor::Write(w.value.clone())) + .or_else(|| self.base.clone().map(Predecessor::Base)); + ChainUndoVerdict::Restore(predecessor) + } +} + +/// The chain-predecessor an undo restores: a prior operational write, or the +/// key's base (pre-operational) value. The distinction matters for the +/// canonical bookkeeping maps (`spellings`, `breaks`, `page_breaks`), which +/// return to key-*absence* when the predecessor is the base value — the base +/// state lives in the graph, not in the operational ledger. +#[derive(Clone, Debug)] +enum Predecessor { + Write(V), + Base(V), +} + +impl Predecessor { + fn into_value(self) -> V { + match self { + Predecessor::Write(v) | Predecessor::Base(v) => v, + } + } +} + +/// The per-key outcome of undoing a transaction's write chain. +enum ChainUndoVerdict { + /// The transaction never wrote this key. + NotWritten, + /// The transaction wrote the key but a later write superseded it. + Superseded { by: OperationId }, + /// The transaction's write is still last: restore the chain-predecessor + /// (`None` = the transaction introduced the first value; restore absence). + Restore(Option>), +} + +/// The staff-instance layout advisories `SetStaffLayout` overwrites as a unit +/// (operation_catalog §SetStaffLayout). +type StaffLayoutValue = (Option, Option, bool); + +/// One key restoration a value-restoring undo applies (operation_catalog +/// §UndoTransaction "Value restoration"). For the always-valued families +/// (event, pitch, cross-cutting, metadata, staff layout) `None` means the +/// chain knows no predecessor (an object minted before this reduction's +/// horizon, reachable only base-free): the undo verdict stands but there is no +/// value to write back — a bookkeeping-only restoration. For the optional +/// families (grid, meter change, tempo segment) the flattened `None` *is* the +/// restoration: clear/remove at the key. The canonical bookkeeping families +/// (spelling, breaks) keep the [`Predecessor`] distinction: a base predecessor +/// returns the ledger map to key-absence while the graph restores the base +/// value. +enum ValueRestoration { + Event { + event: EventId, + value: Option, + }, + Pitch { + pitch: PitchId, + value: Option, + }, + Spelling { + pitch: PitchId, + predecessor: Option>, + }, + CrossCutting { + id: TypedObjectId, + value: Option, + }, + Metadata { + value: Option, + }, + MetricGrid { + region: RegionId, + value: Option, + }, + MeterChange { + region: RegionId, + position: MusicalPosition, + value: Option, + }, + TempoSegment { + region: Option, + position: MusicalPosition, + value: Option, + }, + StaffLayout { + instance: StaffInstanceId, + value: Option, + }, + SystemBreak { + region: RegionId, + position: MusicalPosition, + predecessor: Option>, + }, + PageBreak { + region: RegionId, + position: MusicalPosition, + predecessor: Option>, + }, +} + +/// Whether a tempo segment's shape carries the end data it requires +/// (operation_catalog §"Meter and Tempo Overwrites"): a non-constant shape +/// needs both an explicit `end` and an `end_tempo`; a constant segment's +/// `end_tempo`, when present, must equal its `start_tempo` (the same structural +/// rules the graph-invariant checker applies to tempo maps). +fn tempo_segment_shape_well_formed(segment: &TempoSegment) -> bool { + match segment.shape { + TempoShape::Constant => segment + .end_tempo + .as_ref() + .map_or(true, |end| end == &segment.start_tempo), + TempoShape::Linear | TempoShape::Exponential | TempoShape::Curve => { + segment.end_tempo.is_some() && segment.end.is_some() + } + } +} + +/// Replaces (or removes, for `None`) the segment at `position` in `map`, +/// keeping the segment list ordered by resolved start position — the same +/// coarse anchor resolution the LWW key uses, so one resolved position holds +/// exactly one segment. +fn edit_tempo_map_segments( + map: &mut TempoMap, + position: &MusicalPosition, + segment: &Option, +) { + map.segments + .retain(|existing| resolved_anchor_position(&existing.start) != *position); + if let Some(segment) = segment { + let index = map + .segments + .iter() + .position(|existing| resolved_anchor_position(&existing.start) > *position) + .unwrap_or(map.segments.len()); + map.segments.insert(index, segment.clone()); + } +} + /// The working state of one reduction pass. struct Reducer<'a> { op_set: &'a OperationSet, @@ -633,20 +850,33 @@ struct Reducer<'a> { minted_by: BTreeMap, event_pitches: BTreeMap>, voice_occupancy: BTreeMap>, - last_respell: BTreeMap, - // LWW working state for the Group-1 field-overwrite ops: the last modifier - // and the value it wrote, used to detect concurrent *differing* modifications - // (the resolved value itself lives in the graph, not in MaterializedState). - last_event_modify: BTreeMap, - last_pitch_modify: BTreeMap, - // LWW working state for ModifyCrossCutting (Group 2), mirroring the leaf-field - // modify maps above: last modifier + value it wrote, keyed by structure id. - last_cross_cutting_modify: BTreeMap, - // LWW working state for SetMetricGrid (Group 4, M2d): the last writer and the - // grid it wrote, used to detect concurrent *differing* grids (the resolved - // value lives in the graph). SetMetadata is advisory LWW — no working state, - // no conflict — so the latest write in canonical order silently wins. - last_metric_grid: BTreeMap)>, + // Per-key canonical-order write chains for every LWW overwrite family + // (operation_catalog §UndoTransaction "Value restoration"). Each chain's + // last write doubles as the LWW working state the concurrent-differing + // conflict detection reads (formerly the `last_*` maps); the full chain is + // what value-restoring undo walks. Advisory families (metadata, breaks, + // staff layout) keep chains for undo but record no conflicts. + respell_chain: BTreeMap>, + event_modify_chain: BTreeMap>, + pitch_modify_chain: BTreeMap>, + cross_cutting_modify_chain: BTreeMap>, + metric_grid_chain: BTreeMap>>, + metadata_chain: WriteChain, + break_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain<(TimeAnchor, bool)>>, + page_break_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain<(TimeAnchor, bool)>>, + // Meter/tempo overwrite chains (Phase-3 tranche): `Some` = a set/replace at + // the key, `None` = an explicit removal. The meter value is the graph-level + // `MeterChange` (anchor + signature id) so a restoration can re-install it. + meter_change_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain>>, + tempo_segment_chain: + BTreeMap<(Option, MusicalPosition), WriteChain>>, + staff_layout_chain: BTreeMap>, + // Carried values of set-union-minted staves and time signatures, for the + // byte-identical-re-carry idempotence check (operation_catalog §CreateStaff: + // identical re-create is idempotent; a differing value under a live id is a + // precondition no-op). Seeded from the base graph. + staff_values: BTreeMap, + time_signature_values: BTreeMap, structures: BTreeMap>, // Live child sets for the structural-container empty-only delete (Group 3): // a region's live staff instances, and a staff instance's live voices. (A @@ -704,11 +934,20 @@ struct WorkingSnapshot { minted_by: BTreeMap, event_pitches: BTreeMap>, voice_occupancy: BTreeMap>, - last_respell: BTreeMap, - last_event_modify: BTreeMap, - last_pitch_modify: BTreeMap, - last_cross_cutting_modify: BTreeMap, - last_metric_grid: BTreeMap)>, + respell_chain: BTreeMap>, + event_modify_chain: BTreeMap>, + pitch_modify_chain: BTreeMap>, + cross_cutting_modify_chain: BTreeMap>, + metric_grid_chain: BTreeMap>>, + metadata_chain: WriteChain, + break_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain<(TimeAnchor, bool)>>, + page_break_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain<(TimeAnchor, bool)>>, + meter_change_chain: BTreeMap<(RegionId, MusicalPosition), WriteChain>>, + tempo_segment_chain: + BTreeMap<(Option, MusicalPosition), WriteChain>>, + staff_layout_chain: BTreeMap>, + staff_values: BTreeMap, + time_signature_values: BTreeMap, structures: BTreeMap>, region_instances: BTreeMap>, instance_voices: BTreeMap>, @@ -950,11 +1189,19 @@ impl<'a> Reducer<'a> { minted_by: BTreeMap::new(), event_pitches: BTreeMap::new(), voice_occupancy: BTreeMap::new(), - last_respell: BTreeMap::new(), - last_event_modify: BTreeMap::new(), - last_pitch_modify: BTreeMap::new(), - last_cross_cutting_modify: BTreeMap::new(), - last_metric_grid: BTreeMap::new(), + respell_chain: BTreeMap::new(), + event_modify_chain: BTreeMap::new(), + pitch_modify_chain: BTreeMap::new(), + cross_cutting_modify_chain: BTreeMap::new(), + metric_grid_chain: BTreeMap::new(), + metadata_chain: WriteChain::new(), + break_chain: BTreeMap::new(), + page_break_chain: BTreeMap::new(), + meter_change_chain: BTreeMap::new(), + tempo_segment_chain: BTreeMap::new(), + staff_layout_chain: BTreeMap::new(), + staff_values: BTreeMap::new(), + time_signature_values: BTreeMap::new(), structures: BTreeMap::new(), region_instances: BTreeMap::new(), instance_voices: BTreeMap::new(), @@ -996,6 +1243,9 @@ impl<'a> Reducer<'a> { for staff in &score.staves { self.objects .insert(TypedObjectId::Staff(staff.id), ObjectState::Live); + // The carried value backs CreateStaff's byte-identical-re-carry + // idempotence check against base staves. + self.staff_values.insert(staff.id, staff.clone()); } for group in &score.staff_groups { self.objects @@ -1010,6 +1260,8 @@ impl<'a> Reducer<'a> { TypedObjectId::TimeSignature(signature.id), ObjectState::Live, ); + self.time_signature_values + .insert(signature.id, signature.clone()); } for layer in &score.analysis_layers { self.objects @@ -1020,11 +1272,54 @@ impl<'a> Reducer<'a> { .insert(TypedObjectId::View(view.id), ObjectState::Live); } + // The score-level LWW chains seed with the base values so a + // value-restoring undo of the first operational write can restore the + // pre-operational state (operation_catalog §UndoTransaction). + self.metadata_chain.seed(score.metadata.clone()); + for segment in &score.tempo_map.segments { + self.tempo_segment_chain + .entry((None, resolved_anchor_position(&segment.start))) + .or_insert_with(WriteChain::new) + .seed(Some(segment.clone())); + } + for region in &score.canvas.regions { self.objects .insert(TypedObjectId::Region(region.id), ObjectState::Live); - if region.content.staff_based().is_some() { + if let Some(content) = region.content.staff_based() { self.staff_based_regions.insert(region.id); + self.metric_grid_chain + .entry(region.id) + .or_insert_with(WriteChain::new) + .seed(content.default_metric_grid.clone()); + if let Some(grid) = &content.default_metric_grid { + for change in &grid.meter_sequence { + self.meter_change_chain + .entry((region.id, resolved_anchor_position(&change.anchor))) + .or_insert_with(WriteChain::new) + .seed(Some(change.clone())); + } + } + for anchor in &content.user_system_breaks { + self.break_chain + .entry((region.id, resolved_anchor_position(anchor))) + .or_insert_with(WriteChain::new) + .seed((anchor.clone(), true)); + } + for anchor in &content.user_page_breaks { + self.page_break_chain + .entry((region.id, resolved_anchor_position(anchor))) + .or_insert_with(WriteChain::new) + .seed((anchor.clone(), true)); + } + } + if let Some(local) = ®ion.local_tempo_map { + for segment in &local.segments { + self.tempo_segment_chain + .entry((Some(region.id), resolved_anchor_position(&segment.start))) + .or_insert_with(WriteChain::new) + .seed(Some(segment.clone())); + } } let instance_set = self.region_instances.entry(region.id).or_default(); for instance in region.staff_instances() { @@ -1034,6 +1329,14 @@ impl<'a> Reducer<'a> { self.objects .insert(TypedObjectId::StaffInstance(instance.id), ObjectState::Live); self.instance_staff.insert(instance.id, instance.staff); + self.staff_layout_chain + .entry(instance.id) + .or_insert_with(WriteChain::new) + .seed(( + instance.instrument_override, + instance.staff_lines_override.clone(), + instance.visible, + )); let voice_set = self.instance_voices.entry(instance.id).or_default(); for voice in &instance.voices { voice_set.insert(voice.id); @@ -1077,6 +1380,10 @@ impl<'a> Reducer<'a> { let event_id = event.id(); self.objects .insert(TypedObjectId::Event(event_id), ObjectState::Live); + self.event_modify_chain + .entry(event_id) + .or_insert_with(WriteChain::new) + .seed(event.clone()); let mut pitch_ids = Vec::new(); let mut pitches = Vec::new(); event.collect_identified_pitches(&mut pitches); @@ -1084,6 +1391,10 @@ impl<'a> Reducer<'a> { pitch_ids.push(pitch.id); self.objects .insert(TypedObjectId::Pitch(pitch.id), ObjectState::Live); + self.pitch_modify_chain + .entry(pitch.id) + .or_insert_with(WriteChain::new) + .seed(pitch.pitch.clone()); // Register base synthetic pitches in the mint registry (same // rule as promoted voices above). if pitch.id.replica() == ReplicaId::SYSTEM_DERIVED { @@ -1126,6 +1437,10 @@ impl<'a> Reducer<'a> { for slur in &score.cross_cutting.slurs { let id = TypedObjectId::Slur(slur.id); self.objects.insert(id, ObjectState::Live); + self.cross_cutting_modify_chain + .entry(id) + .or_insert_with(WriteChain::new) + .seed(CrossCuttingValue::Slur(slur.clone())); self.structures.insert( id, vec![ @@ -1137,6 +1452,10 @@ impl<'a> Reducer<'a> { for tie in &score.cross_cutting.ties { let id = TypedObjectId::Tie(tie.id); self.objects.insert(id, ObjectState::Live); + self.cross_cutting_modify_chain + .entry(id) + .or_insert_with(WriteChain::new) + .seed(CrossCuttingValue::Tie(tie.clone())); self.structures.insert( id, vec![ @@ -1148,6 +1467,10 @@ impl<'a> Reducer<'a> { for beam in &score.cross_cutting.beams { let id = TypedObjectId::Beam(beam.id); self.objects.insert(id, ObjectState::Live); + self.cross_cutting_modify_chain + .entry(id) + .or_insert_with(WriteChain::new) + .seed(CrossCuttingValue::Beam(beam.clone())); self.structures.insert( id, beam.events @@ -1173,6 +1496,10 @@ impl<'a> Reducer<'a> { for spanner in &score.cross_cutting.spanners { let id = TypedObjectId::Spanner(spanner.id); self.objects.insert(id, ObjectState::Live); + self.cross_cutting_modify_chain + .entry(id) + .or_insert_with(WriteChain::new) + .seed(CrossCuttingValue::Spanner(spanner.clone())); // Record the spanner's event-anchored endpoints so a later event // tombstone re-anchors it through the same rule table as a created // spanner (keeping the graph and ledger consistent on delete). @@ -1241,6 +1568,24 @@ impl<'a> Reducer<'a> { self.objects .insert(TypedObjectId::ChordSymbol(chord.id), ObjectState::Live); } + // The base score's explicit user-chosen per-pitch spellings seed the + // respell chains, so undoing the first operational respell restores + // the base attachment value rather than dropping it (the bookkeeping + // `spellings` map still returns to key-absence — base state lives in + // the graph, not the operational ledger). + for attachment in &score.spelling_attachments { + if attachment.layer.is_none() && matches!(attachment.source, SpellingSource::UserChosen) + { + if let (SpellingScope::Pitch(pitch), SpellingDirective::Explicit(spelling)) = + (&attachment.scope, &attachment.directive) + { + self.respell_chain + .entry(*pitch) + .or_insert_with(WriteChain::new) + .seed(spelling.clone()); + } + } + } } fn run(mut self) -> (MaterializedState, Option) { @@ -2017,6 +2362,14 @@ impl<'a> Reducer<'a> { TypedObjectId::Beam(id) => { score.cross_cutting.beams.retain(|value| value.id != *id); } + // Phase-3 mints: a tombstoned staff / time signature leaves the + // graph (the undo path preconditions no live reference remains). + TypedObjectId::Staff(id) => { + score.staves.retain(|value| value.id != *id); + } + TypedObjectId::TimeSignature(id) => { + score.time_signatures.retain(|value| value.id != *id); + } _ => {} } } @@ -2059,7 +2412,7 @@ impl<'a> Reducer<'a> { OperationKind::RespellPitch(op) => self.respell_pitch(env, op), OperationKind::CreateCrossCutting(op) => self.create_cross_cutting(env, op), OperationKind::ChangeRegionTimeModel(op) => self.change_region_time_model(env, op), - OperationKind::SetUserSystemBreak(op) => self.set_user_system_break(op), + OperationKind::SetUserSystemBreak(op) => self.set_user_system_break(env, op), OperationKind::DeclareTransaction(desc) => { self.descriptors.insert(desc.id, env.id); OperationEffect::Applied @@ -2080,9 +2433,13 @@ impl<'a> Reducer<'a> { OperationKind::DeleteStaffInstance(op) => self.delete_staff_instance(env, op), OperationKind::CreateVoice(op) => self.create_voice(env, op), OperationKind::DeleteVoice(op) => self.delete_voice(env, op), - OperationKind::SetMetadata(op) => self.set_metadata(op), + OperationKind::SetMetadata(op) => self.set_metadata(env, op), OperationKind::SetMetricGrid(op) => self.set_metric_grid(env, op), - OperationKind::SetUserPageBreak(op) => self.set_user_page_break(op), + OperationKind::SetUserPageBreak(op) => self.set_user_page_break(env, op), + OperationKind::CreateStaff(op) => self.create_staff(env, op), + OperationKind::SetTimeSignature(op) => self.set_time_signature(env, op), + OperationKind::SetTempoSegment(op) => self.set_tempo_segment(env, op), + OperationKind::SetStaffLayout(op) => self.set_staff_layout(env, op), }, OperationPayload::ResolveConflict(op) => self.resolve_conflict(env, op), OperationPayload::UndoTransaction(op) => self.undo_transaction(env, op), @@ -2094,6 +2451,7 @@ impl<'a> Reducer<'a> { fn set_user_system_break( &mut self, + env: &OperationEnvelope, op: &crate::payload::SetUserSystemBreakOp, ) -> OperationEffect { if let Some(effect) = self.layout_region_slot(op.region) { @@ -2108,8 +2466,12 @@ impl<'a> Reducer<'a> { } // The LWW bucketing key is the anchor's resolved musical position. - self.breaks - .insert((op.region, op.resolved_position()), op.present); + let key = (op.region, op.resolved_position()); + self.breaks.insert(key.clone(), op.present); + self.break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (op.anchor.clone(), op.present)); OperationEffect::Applied } @@ -2146,9 +2508,12 @@ impl<'a> Reducer<'a> { } } - fn set_metadata(&mut self, op: &SetMetadataOp) -> OperationEffect { + fn set_metadata(&mut self, env: &OperationEnvelope, op: &SetMetadataOp) -> OperationEffect { // Advisory LWW: no conflict, no idempotence short-circuit. The resolved - // value is the last write in canonical order, held in the graph. + // value is the last write in canonical order, held in the graph. The + // write chain backs value-restoring undo only. + self.metadata_chain + .record(env.id, env.transaction, op.metadata.clone()); if let Some(score) = self.graph.as_mut() { score.metadata = op.metadata.clone(); } @@ -2184,9 +2549,10 @@ impl<'a> Reducer<'a> { } } let prev = self - .last_metric_grid + .metric_grid_chain .get(&op.region) - .map(|(o, g)| (*o, g.clone())); + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); let effect = match prev { Some((prev_op, prev_grid)) if self.concurrent(env.id, prev_op) => { if prev_grid == op.grid { @@ -2209,8 +2575,10 @@ impl<'a> Reducer<'a> { } _ => OperationEffect::Applied, }; - self.last_metric_grid - .insert(op.region, (env.id, op.grid.clone())); + self.metric_grid_chain + .entry(op.region) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.grid.clone()); self.graph_set_metric_grid(op.region, &op.grid); effect } @@ -2226,7 +2594,11 @@ impl<'a> Reducer<'a> { } } - fn set_user_page_break(&mut self, op: &SetUserPageBreakOp) -> OperationEffect { + fn set_user_page_break( + &mut self, + env: &OperationEnvelope, + op: &SetUserPageBreakOp, + ) -> OperationEffect { if let Some(effect) = self.layout_region_slot(op.region) { return effect; } @@ -2237,8 +2609,12 @@ impl<'a> Reducer<'a> { } } } - self.page_breaks - .insert((op.region, op.resolved_position()), op.present); + let key = (op.region, op.resolved_position()); + self.page_breaks.insert(key.clone(), op.present); + self.page_break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (op.anchor.clone(), op.present)); OperationEffect::Applied } @@ -2359,6 +2735,21 @@ impl<'a> Reducer<'a> { self.objects.insert(ev_obj, ObjectState::Live); self.minted_by.insert(ev_obj, env.id); self.note_minted(env, ev_obj); + // Seed the write chains with the minted values (the same value the + // graph materializes), so a later modify's chain-predecessor is the + // inserted state in graph-free and graph-aware reduction alike. + self.event_modify_chain + .entry(event_id) + .or_insert_with(WriteChain::new) + .seed(graph_event_from_insert(op, target_voice)); + let mut carried: Vec<&epiphany_core::IdentifiedPitch> = Vec::new(); + op.event.collect_identified_pitches(&mut carried); + for ip in &carried { + self.pitch_modify_chain + .entry(ip.id) + .or_insert_with(WriteChain::new) + .seed(ip.pitch.clone()); + } let mut pitches = Vec::new(); for p in op.pitch_ids() { let p_obj = TypedObjectId::Pitch(p); @@ -2544,7 +2935,12 @@ impl<'a> Reducer<'a> { Some(ObjectState::Live) => {} } - match self.last_respell.get(&op.pitch).copied() { + let prev_op = self + .respell_chain + .get(&op.pitch) + .and_then(|chain| chain.last_write()) + .map(|write| write.op); + match prev_op { None => { self.materialize_respell(env, op); OperationEffect::Applied @@ -2595,7 +2991,10 @@ impl<'a> Reducer<'a> { /// in `MaterializedState.spellings` and lost before annotation derivation. fn materialize_respell(&mut self, env: &OperationEnvelope, op: &RespellPitchOp) { self.spellings.insert(op.pitch, op.spelling.clone()); - self.last_respell.insert(op.pitch, env.id); + self.respell_chain + .entry(op.pitch) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.spelling.clone()); self.graph_respell_pitch(op.pitch, &op.spelling); } @@ -2661,6 +3060,12 @@ impl<'a> Reducer<'a> { self.objects.insert(sid, ObjectState::Live); self.minted_by.insert(sid, env.id); self.note_minted(env, sid); + // Seed the write chain with the minted value, so a later modify's + // chain-predecessor is the created state. + self.cross_cutting_modify_chain + .entry(sid) + .or_insert_with(WriteChain::new) + .seed(op.structure.clone()); self.structures.insert(sid, endpoints); OperationEffect::Applied } @@ -2710,9 +3115,11 @@ impl<'a> Reducer<'a> { }, ); // Drop the transient endpoint/LWW indices so a later event tombstone's - // re-anchoring pass never re-processes the deleted structure. + // re-anchoring pass never re-processes the deleted structure. The write + // chain goes with it: a delete is not inverted (P11-C8), so a + // tombstoned structure's chain can never be restored. self.structures.remove(&sid); - self.last_cross_cutting_modify.remove(&sid); + self.cross_cutting_modify_chain.remove(&sid); self.graph_delete_cross_cutting(sid); OperationEffect::Applied } @@ -2763,9 +3170,10 @@ impl<'a> Reducer<'a> { // the graph; MaterializedState records only the effect and, on a // concurrent differing write, a StructuralFieldCollision. let prev = self - .last_cross_cutting_modify + .cross_cutting_modify_chain .get(&sid) - .map(|(o, v)| (*o, v.clone())); + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); let effect = match prev { Some((prev_op, prev_value)) if self.concurrent(env.id, prev_op) => { if prev_value == op.structure { @@ -2788,8 +3196,10 @@ impl<'a> Reducer<'a> { } _ => OperationEffect::Applied, }; - self.last_cross_cutting_modify - .insert(sid, (env.id, op.structure.clone())); + self.cross_cutting_modify_chain + .entry(sid) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.structure.clone()); self.structures.insert(sid, endpoints); self.graph_modify_cross_cutting(&op.structure); effect @@ -2905,8 +3315,47 @@ impl<'a> Reducer<'a> { self.graph_create_region(&op.region); self.mint_container(env, robj); self.region_instances.entry(op.region_id()).or_default(); - if op.region.content.staff_based().is_some() { + if let Some(content) = op.region.content.staff_based() { self.staff_based_regions.insert(op.region_id()); + // Seed the region's layout/metric write chains from the carried + // content (empty of typed children, but it may carry a grid or + // break advisories), so a later overwrite's chain-predecessor is + // the created state. + self.metric_grid_chain + .entry(op.region_id()) + .or_insert_with(WriteChain::new) + .seed(content.default_metric_grid.clone()); + if let Some(grid) = &content.default_metric_grid { + for change in &grid.meter_sequence { + self.meter_change_chain + .entry((op.region_id(), resolved_anchor_position(&change.anchor))) + .or_insert_with(WriteChain::new) + .seed(Some(change.clone())); + } + } + for anchor in &content.user_system_breaks { + self.break_chain + .entry((op.region_id(), resolved_anchor_position(anchor))) + .or_insert_with(WriteChain::new) + .seed((anchor.clone(), true)); + } + for anchor in &content.user_page_breaks { + self.page_break_chain + .entry((op.region_id(), resolved_anchor_position(anchor))) + .or_insert_with(WriteChain::new) + .seed((anchor.clone(), true)); + } + } + if let Some(local) = &op.region.local_tempo_map { + for segment in &local.segments { + self.tempo_segment_chain + .entry(( + Some(op.region_id()), + resolved_anchor_position(&segment.start), + )) + .or_insert_with(WriteChain::new) + .seed(Some(segment.clone())); + } } OperationEffect::Applied } @@ -2935,6 +3384,23 @@ impl<'a> Reducer<'a> { if !op.instance.voices.is_empty() || !op.instance.measures.is_empty() { return container_not_empty(); } + // With staves mintable (operation_catalog §CreateStaff), the instance's + // referenced global Staff must be live — the mint must leave the graph + // satisfying reference resolution. Graph-aware only (like the insert + // preconditions): base-free reduction has no staff universe to check + // against, and the base-seeded scenarios satisfy this vacuously. + if self.graph.is_some() + && !matches!( + self.objects.get(&TypedObjectId::Staff(op.instance.staff)), + Some(ObjectState::Live) + ) + { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }; + } self.graph_create_staff_instance(op.region, &op.instance); self.mint_container(env, iobj); self.region_instances @@ -2944,6 +3410,16 @@ impl<'a> Reducer<'a> { self.instance_voices.entry(op.instance_id()).or_default(); self.instance_staff .insert(op.instance_id(), op.instance.staff); + // Seed the layout-advisory chain with the minted instance's fields, so + // a later SetStaffLayout's chain-predecessor is the created state. + self.staff_layout_chain + .entry(op.instance_id()) + .or_insert_with(WriteChain::new) + .seed(( + op.instance.instrument_override, + op.instance.staff_lines_override.clone(), + op.instance.visible, + )); OperationEffect::Applied } @@ -2975,6 +3451,457 @@ impl<'a> Reducer<'a> { OperationEffect::Applied } + // --- Phase-3 first tranche (operation_catalog §CreateStaff, §"Meter and + // Tempo Overwrites", §SetStaffLayout). ------------------------------------ + + /// Set-union creation of a global `Staff` on the score root + /// (operation_catalog §CreateStaff): fresh id mints; a byte-identical + /// re-carry is idempotent; a differing value under a live id is a + /// precondition no-op. Graph-aware reduction additionally preconditions + /// that the referenced instrument is live and, when `group` is present, + /// that the staff group resolves. + fn create_staff(&mut self, env: &OperationEnvelope, op: &CreateStaffOp) -> OperationEffect { + let sobj = TypedObjectId::Staff(op.staff_id()); + match self.objects.get(&sobj) { + Some(ObjectState::Live) => { + let identical = self + .staff_values + .get(&op.staff_id()) + .is_some_and(|known| known == &op.staff); + return if identical { + OperationEffect::NoOp { + reason: NoOpReason::AlreadyApplied, + } + } else { + OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + } + }; + } + Some(ObjectState::Tombstoned { .. }) => { + return OperationEffect::NoOp { + reason: NoOpReason::TargetTombstoned, + } + } + None => {} + } + // Reference-resolution preconditions are graph-aware (like the insert + // preconditions): base-free reduction has no instrument/group universe + // to check against. + if self.graph.is_some() { + if !matches!( + self.objects + .get(&TypedObjectId::Instrument(op.staff.instrument)), + Some(ObjectState::Live) + ) { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }; + } + if let Some(group) = op.staff.group { + if !matches!( + self.objects.get(&TypedObjectId::StaffGroup(group)), + Some(ObjectState::Live) + ) { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }; + } + } + } + if let Some(score) = self.graph.as_mut() { + score.staves.push(op.staff.clone()); + } + self.mint_container(env, sobj); + self.staff_values.insert(op.staff_id(), op.staff.clone()); + OperationEffect::Applied + } + + /// Set-union mint of a `TimeSignature` carried by a `SetTimeSignature` + /// (operation_catalog §"Meter and Tempo Overwrites"): fresh id mints; + /// byte-identical re-carry is idempotent; a differing value under a live + /// id — or a tombstoned id — refuses the whole operation. + fn mint_time_signature( + &mut self, + env: &OperationEnvelope, + signature: &TimeSignature, + ) -> Result<(), OperationEffect> { + let obj = TypedObjectId::TimeSignature(signature.id); + match self.objects.get(&obj) { + Some(ObjectState::Live) => { + let identical = self + .time_signature_values + .get(&signature.id) + .is_some_and(|known| known == signature); + if identical { + Ok(()) + } else { + Err(OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }) + } + } + Some(ObjectState::Tombstoned { .. }) => Err(OperationEffect::NoOp { + reason: NoOpReason::TargetTombstoned, + }), + None => { + self.mint_container(env, obj); + self.time_signature_values + .insert(signature.id, signature.clone()); + if let Some(score) = self.graph.as_mut() { + if !score.time_signatures.iter().any(|t| t.id == signature.id) { + score.time_signatures.push(signature.clone()); + } + } + Ok(()) + } + } + } + + /// Sets, replaces, or removes the single meter change at the anchor's + /// resolved position in the region's default metric grid — an LWW + /// structural overwrite keyed by `(region, resolved position)` + /// (operation_catalog §"Meter and Tempo Overwrites"). The carried + /// signature's beat-group sum is validated at construction and at decode, + /// so a malformed value never reaches this reduction. + fn set_time_signature( + &mut self, + env: &OperationEnvelope, + op: &SetTimeSignatureOp, + ) -> OperationEffect { + if let Some(effect) = self.layout_region_slot(op.region) { + return effect; + } + if let Some(signature) = &op.time_signature { + if let Err(effect) = self.mint_time_signature(env, signature) { + return effect; + } + } + let key = (op.region, op.resolved_position()); + let written: Option = + op.time_signature.as_ref().map(|signature| MeterChange { + anchor: op.anchor.clone(), + time_signature: signature.id, + }); + let prev = self + .meter_change_chain + .get(&key) + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); + let effect = match prev { + Some((prev_op, prev_value)) if self.concurrent(env.id, prev_op) => { + if prev_value == written { + return OperationEffect::NoOp { + reason: NoOpReason::AlreadyApplied, + }; + } + let conflict = ConflictRecord::new( + ConflictKind::StructuralFieldCollision { + winner: env.id, + loser: prev_op, + field: FieldPath("meter_sequence".to_string()), + }, + vec![env.id, prev_op], + vec![TypedObjectId::Region(op.region)], + ); + let cid = conflict.id; + self.conflicts.insert(conflict); + OperationEffect::Conflicted { conflict: cid } + } + _ => OperationEffect::Applied, + }; + self.meter_change_chain + .entry(key.clone()) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, written.clone()); + self.graph_apply_meter_change(op.region, &key.1, &written); + effect + } + + /// Applies a meter-change overwrite (or removal) to the region's default + /// metric grid, keeping the sequence ordered by resolved position. A set + /// on a region whose grid is `None` creates the grid; a removal that + /// empties the sequence normalizes the slot back to `None` unless a + /// whole-grid write (or the base) holds a grid value independently. + fn graph_apply_meter_change( + &mut self, + region: RegionId, + position: &MusicalPosition, + change: &Option, + ) { + let baseline_grid = self + .metric_grid_chain + .get(®ion) + .and_then(|chain| chain.current()) + .is_some_and(|grid| grid.is_some()); + let Some(score) = self.graph.as_mut() else { + return; + }; + let Some(region) = score.canvas.regions.iter_mut().find(|r| r.id == region) else { + return; + }; + let Some(content) = region.content.staff_based_mut() else { + return; + }; + match change { + Some(meter) => { + let grid = content + .default_metric_grid + .get_or_insert_with(MetricGrid::default); + grid.meter_sequence + .retain(|existing| resolved_anchor_position(&existing.anchor) != *position); + let index = grid + .meter_sequence + .iter() + .position(|existing| resolved_anchor_position(&existing.anchor) > *position) + .unwrap_or(grid.meter_sequence.len()); + grid.meter_sequence.insert(index, meter.clone()); + } + None => { + if let Some(grid) = content.default_metric_grid.as_mut() { + grid.meter_sequence + .retain(|existing| resolved_anchor_position(&existing.anchor) != *position); + if grid.meter_sequence.is_empty() && !baseline_grid { + content.default_metric_grid = None; + } + } + } + } + } + + /// Whether the scope's *resulting* tempo map is well-formed with `written` + /// installed at `key` (operation_catalog §"Meter and Tempo Overwrites"): + /// the carried segment's own start equals the operation's key, every + /// segment's shape carries its end data, and resolved ends neither precede + /// their own start nor overlap the next segment. Read purely from the + /// tempo chains' current values (which seed from the base map), so + /// graph-free and graph-aware reduction agree wherever both represent the + /// scope. + fn prospective_tempo_write_well_formed( + &self, + key: &(Option, MusicalPosition), + written: &TempoSegment, + ) -> bool { + if resolved_anchor_position(&written.start) != key.1 { + return false; + } + let mut segments: Vec<(MusicalPosition, &TempoSegment)> = Vec::new(); + for ((scope, position), chain) in &self.tempo_segment_chain { + if scope != &key.0 || *position == key.1 { + continue; + } + if let Some(Some(segment)) = chain.current() { + segments.push((position.clone(), segment)); + } + } + segments.push((key.1.clone(), written)); + segments.sort_by(|(a, _), (b, _)| a.cmp(b)); + for (index, (position, segment)) in segments.iter().enumerate() { + if !tempo_segment_shape_well_formed(segment) { + return false; + } + if let Some(end) = &segment.end { + let resolved_end = resolved_anchor_position(end); + if resolved_end < *position { + return false; + } + if let Some((next_position, _)) = segments.get(index + 1) { + if resolved_end > *next_position { + return false; + } + } + } + } + true + } + + /// Sets, replaces, or removes the single tempo segment starting at the + /// resolved position in the scoped tempo map — an LWW structural overwrite + /// keyed by `(scope, resolved start)` (operation_catalog §"Meter and Tempo + /// Overwrites"). A write that would malform the resulting map is refused + /// (`TempoMapMalformed`). + fn set_tempo_segment( + &mut self, + env: &OperationEnvelope, + op: &SetTempoSegmentOp, + ) -> OperationEffect { + if let Some(region) = op.region { + if !matches!( + self.objects.get(&TypedObjectId::Region(region)), + Some(ObjectState::Live) + ) { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }; + } + } + let key = (op.region, op.resolved_start()); + if let Some(segment) = &op.segment { + if !self.prospective_tempo_write_well_formed(&key, segment) { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TempoMapMalformed, + }, + }; + } + } + let prev = self + .tempo_segment_chain + .get(&key) + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); + let effect = match prev { + Some((prev_op, prev_value)) if self.concurrent(env.id, prev_op) => { + if prev_value == op.segment { + return OperationEffect::NoOp { + reason: NoOpReason::AlreadyApplied, + }; + } + let affected = match op.region { + Some(region) => vec![TypedObjectId::Region(region)], + None => vec![], + }; + let conflict = ConflictRecord::new( + ConflictKind::StructuralFieldCollision { + winner: env.id, + loser: prev_op, + field: FieldPath("tempo_segments".to_string()), + }, + vec![env.id, prev_op], + affected, + ); + let cid = conflict.id; + self.conflicts.insert(conflict); + OperationEffect::Conflicted { conflict: cid } + } + _ => OperationEffect::Applied, + }; + self.tempo_segment_chain + .entry(key.clone()) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.segment.clone()); + self.graph_apply_tempo_segment(op.region, &key.1, &op.segment); + effect + } + + /// Applies a tempo-segment overwrite (or removal) to the scoped map. A set + /// on a region with no local map creates one; an empty, `initial`-less + /// local map left behind by a removal normalizes back to `None` (an empty + /// local map would shadow the score map instead of falling back to it). + fn graph_apply_tempo_segment( + &mut self, + scope: Option, + position: &MusicalPosition, + segment: &Option, + ) { + let Some(score) = self.graph.as_mut() else { + return; + }; + match scope { + None => edit_tempo_map_segments(&mut score.tempo_map, position, segment), + Some(region_id) => { + let Some(region) = score.canvas.regions.iter_mut().find(|r| r.id == region_id) + else { + return; + }; + if segment.is_some() && region.local_tempo_map.is_none() { + region.local_tempo_map = Some(TempoMap::default()); + } + if let Some(map) = region.local_tempo_map.as_mut() { + edit_tempo_map_segments(map, position, segment); + } + if region + .local_tempo_map + .as_ref() + .is_some_and(|map| map.initial.is_none() && map.segments.is_empty()) + { + region.local_tempo_map = None; + } + } + } + } + + /// Overwrites a staff instance's three inline layout advisories as a unit + /// — an LWW *advisory* keyed by `staff_instance` (operation_catalog + /// §SetStaffLayout): no conflicts; the latest write in canonical order + /// wins. A present `instrument_override` must resolve to a live instrument + /// under graph-aware reduction. + fn set_staff_layout( + &mut self, + env: &OperationEnvelope, + op: &SetStaffLayoutOp, + ) -> OperationEffect { + match self + .objects + .get(&TypedObjectId::StaffInstance(op.staff_instance)) + { + None => { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + } + } + Some(ObjectState::Tombstoned { .. }) => { + return OperationEffect::NoOp { + reason: NoOpReason::TargetTombstoned, + } + } + Some(ObjectState::Live) => {} + } + if self.graph.is_some() { + if let Some(instrument) = op.instrument_override { + if !matches!( + self.objects.get(&TypedObjectId::Instrument(instrument)), + Some(ObjectState::Live) + ) { + return OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }; + } + } + } + let value: StaffLayoutValue = ( + op.instrument_override, + op.staff_lines_override.clone(), + op.visible, + ); + self.staff_layout_chain + .entry(op.staff_instance) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value.clone()); + self.graph_set_staff_layout(op.staff_instance, &value); + OperationEffect::Applied + } + + fn graph_set_staff_layout(&mut self, instance_id: StaffInstanceId, value: &StaffLayoutValue) { + let Some(score) = self.graph.as_mut() else { + return; + }; + for region in &mut score.canvas.regions { + if let Some(instances) = region.content.staff_instances_mut() { + if let Some(instance) = instances.iter_mut().find(|i| i.id == instance_id) { + instance.instrument_override = value.0; + instance.staff_lines_override = value.1.clone(); + instance.visible = value.2; + return; + } + } + } + } + /// `Some(effect)` when `obj` cannot be deleted (missing, idempotent /// re-delete, or non-empty); `None` with the resolved minter when the /// empty-only delete may proceed. @@ -3430,49 +4357,39 @@ impl<'a> Reducer<'a> { } } + /// Forward compensating undo (operation_catalog §UndoTransaction): the + /// minted-object tombstoning pass plus, per this revision, the + /// value-restoration pass over every LWW write chain the target + /// transaction wrote. `StrictInverse` refuses the whole undo if *either* + /// part fails; `BestEffort` compensates what it cleanly can. A fully + /// clean compensation is `Applied`; `AppliedWithRepair` carries only the + /// tombstone repairs from minted objects. fn undo_transaction( &mut self, env: &OperationEnvelope, op: &UndoTransactionPayload, ) -> OperationEffect { let targets = self.tx_minted.get(&op.target).cloned().unwrap_or_default(); - if targets.is_empty() { + let (restorations, superseded) = self.collect_restorations(op.target, &targets); + if targets.is_empty() && restorations.is_empty() && superseded.is_empty() { + // The transaction minted nothing and overwrote nothing this + // reduction knows of (unknown, rolled back, or all its written + // keys are gone): nothing to compensate. return OperationEffect::NoOp { reason: NoOpReason::PreconditionFailedUnderReduction { reason: PreconditionFailureReason::TargetMissing, }, }; } - let all_live = targets - .iter() - .all(|t| matches!(self.objects.get(t), Some(ObjectState::Live))); match op.policy { UndoPolicy::StrictInverse | UndoPolicy::Cascade => { - if all_live { - let mut repairs = Vec::new(); - for t in &targets { - let minter = self.minted_by.get(t).copied().unwrap_or(env.id); - self.objects.insert( - *t, - ObjectState::Tombstoned { - deleted_by: env.id, - minted_by: minter, - }, - ); - repairs.push(RepairRecord { - kind: RepairKind::CascadeDeleted, - target: *t, - }); - } - repairs.extend(self.materialize_graph_tombstones(env, &targets)); - OperationEffect::AppliedWithRepair { repairs } - } else { - // A target was already tombstoned/modified: strict undo conflicts. - let stuck = targets - .iter() - .find(|t| !matches!(self.objects.get(t), Some(ObjectState::Live))) - .copied() - .unwrap_or(targets[0]); + // A minted target already tombstoned: strict undo conflicts + // (the pre-existing minted-object discipline). + if let Some(stuck) = targets + .iter() + .find(|t| !matches!(self.objects.get(t), Some(ObjectState::Live))) + .copied() + { let conflict = ConflictRecord::new( ConflictKind::TombstonedTarget { target: stuck, @@ -3483,35 +4400,582 @@ impl<'a> Reducer<'a> { ); let cid = conflict.id; self.conflicts.insert(conflict); - OperationEffect::Conflicted { conflict: cid } + return OperationEffect::Conflicted { conflict: cid }; + } + // A minted staff still manifested by a live instance, or a + // minted time signature still referenced by a surviving meter + // change: tombstoning it would strand the reference + // (operation_catalog §CreateStaff undo semantics). + if let Some((blocked, referencer)) = targets + .iter() + .find_map(|t| self.undo_strand_block(t, &targets, &restorations)) + { + let conflict = ConflictRecord::new( + ConflictKind::TransactionConflict { + transaction: op.target, + failed_members: vec![env.id], + }, + vec![env.id], + vec![blocked, referencer], + ); + let cid = conflict.id; + self.conflicts.insert(conflict); + return OperationEffect::Conflicted { conflict: cid }; + } + // A written key superseded by a later writer: strict undo + // refuses the whole compensation, naming the undo and the + // (canonically first) superseding writer. + if let Some(by) = superseded.first().copied() { + let conflict = ConflictRecord::new( + ConflictKind::TransactionConflict { + transaction: op.target, + failed_members: vec![env.id], + }, + vec![env.id, by], + vec![], + ); + let cid = conflict.id; + self.conflicts.insert(conflict); + return OperationEffect::Conflicted { conflict: cid }; + } + let repairs = self.tombstone_undo_targets(env, &targets); + self.apply_restorations(env, restorations); + if repairs.is_empty() { + OperationEffect::Applied + } else { + OperationEffect::AppliedWithRepair { repairs } } } UndoPolicy::BestEffort => { - let mut repairs = Vec::new(); - let mut tombstoned = Vec::new(); - for t in &targets { - if matches!(self.objects.get(t), Some(ObjectState::Live)) { - let minter = self.minted_by.get(t).copied().unwrap_or(env.id); - self.objects.insert( - *t, - ObjectState::Tombstoned { - deleted_by: env.id, - minted_by: minter, - }, - ); - repairs.push(RepairRecord { - kind: RepairKind::CascadeDeleted, - target: *t, - }); - tombstoned.push(*t); - } + // Tombstone the still-live, non-stranding mints; restore the + // still-last-written keys; skip the rest. + let tombstonable: Vec = targets + .iter() + .filter(|t| matches!(self.objects.get(t), Some(ObjectState::Live))) + .filter(|t| self.undo_strand_block(t, &targets, &restorations).is_none()) + .copied() + .collect(); + let repairs = self.tombstone_undo_targets(env, &tombstonable); + self.apply_restorations(env, restorations); + if repairs.is_empty() { + OperationEffect::Applied + } else { + OperationEffect::AppliedWithRepair { repairs } } - repairs.extend(self.materialize_graph_tombstones(env, &tombstoned)); - OperationEffect::AppliedWithRepair { repairs } } } } + /// Tombstones the minted objects of an undone transaction and materializes + /// the graph-side removals, returning the `CascadeDeleted` repair records. + fn tombstone_undo_targets( + &mut self, + env: &OperationEnvelope, + targets: &[TypedObjectId], + ) -> Vec { + let mut repairs = Vec::new(); + for t in targets { + let minter = self.minted_by.get(t).copied().unwrap_or(env.id); + self.objects.insert( + *t, + ObjectState::Tombstoned { + deleted_by: env.id, + minted_by: minter, + }, + ); + repairs.push(RepairRecord { + kind: RepairKind::CascadeDeleted, + target: *t, + }); + } + repairs.extend(self.materialize_graph_tombstones(env, targets)); + repairs + } + + /// `Some((blocked, referencer))` when tombstoning `target` under undo + /// would strand a live reference: a minted `Staff` still manifested by a + /// live staff instance (operation_catalog §CreateStaff), or a minted + /// `TimeSignature` still referenced by a meter change that survives the + /// restoration pass. References held by objects the same undo tombstones + /// do not block. + fn undo_strand_block( + &self, + target: &TypedObjectId, + targets: &[TypedObjectId], + restorations: &[ValueRestoration], + ) -> Option<(TypedObjectId, TypedObjectId)> { + match target { + TypedObjectId::Staff(staff) => { + self.instance_staff + .iter() + .find_map(|(instance, manifested)| { + let iobj = TypedObjectId::StaffInstance(*instance); + (manifested == staff + && !targets.contains(&iobj) + && matches!(self.objects.get(&iobj), Some(ObjectState::Live))) + .then_some((*target, iobj)) + }) + } + TypedObjectId::TimeSignature(id) => { + self.meter_change_chain + .iter() + .find_map(|((region, position), chain)| { + // The prospective post-undo value at this key: the + // restoration's value where one applies, else the + // chain's current value. + let prospective: Option = restorations + .iter() + .find_map(|restoration| match restoration { + ValueRestoration::MeterChange { + region: r, + position: p, + value, + } if r == region && p == position => Some(value.clone()), + _ => None, + }) + .unwrap_or_else(|| chain.current().cloned().flatten()); + prospective.and_then(|meter| { + (meter.time_signature == *id) + .then_some((*target, TypedObjectId::Region(*region))) + }) + }) + } + _ => None, + } + } + + /// Walks every write chain and collects, for the target transaction: the + /// keys still last-written by it (with their chain-predecessor + /// restorations) and the operations that superseded its other writes + /// (sorted, deduplicated). Keys whose owning object is tombstoned — or is + /// itself one of the transaction's mints, about to be tombstoned by this + /// undo — are skipped entirely: there is no live slot to restore. + fn collect_restorations( + &self, + tx: TransactionId, + targets: &[TypedObjectId], + ) -> (Vec, Vec) { + let mut restorations = Vec::new(); + let mut superseded: Vec = Vec::new(); + let slot_live = |obj: TypedObjectId| { + matches!(self.objects.get(&obj), Some(ObjectState::Live)) && !targets.contains(&obj) + }; + + for (event, chain) in &self.event_modify_chain { + if !slot_live(TypedObjectId::Event(*event)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::Event { + event: *event, + value: predecessor.map(Predecessor::into_value), + }) + } + } + } + for (pitch, chain) in &self.pitch_modify_chain { + if !slot_live(TypedObjectId::Pitch(*pitch)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::Pitch { + pitch: *pitch, + value: predecessor.map(Predecessor::into_value), + }) + } + } + } + for (pitch, chain) in &self.respell_chain { + if !slot_live(TypedObjectId::Pitch(*pitch)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::Spelling { + pitch: *pitch, + predecessor, + }) + } + } + } + for (id, chain) in &self.cross_cutting_modify_chain { + if !slot_live(*id) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::CrossCutting { + id: *id, + value: predecessor.map(Predecessor::into_value), + }) + } + } + } + match self.metadata_chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::Metadata { + value: predecessor.map(Predecessor::into_value), + }) + } + } + for (region, chain) in &self.metric_grid_chain { + if !slot_live(TypedObjectId::Region(*region)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + // Flattened: no predecessor and a cleared-grid predecessor + // both restore "no grid". + restorations.push(ValueRestoration::MetricGrid { + region: *region, + value: match predecessor { + Some(p) => p.into_value(), + None => None, + }, + }) + } + } + } + for ((region, position), chain) in &self.meter_change_chain { + if !slot_live(TypedObjectId::Region(*region)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::MeterChange { + region: *region, + position: position.clone(), + value: match predecessor { + Some(p) => p.into_value(), + None => None, + }, + }) + } + } + } + for ((scope, position), chain) in &self.tempo_segment_chain { + if let Some(region) = scope { + if !slot_live(TypedObjectId::Region(*region)) { + continue; + } + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::TempoSegment { + region: *scope, + position: position.clone(), + value: match predecessor { + Some(p) => p.into_value(), + None => None, + }, + }) + } + } + } + for (instance, chain) in &self.staff_layout_chain { + if !slot_live(TypedObjectId::StaffInstance(*instance)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::StaffLayout { + instance: *instance, + value: predecessor.map(Predecessor::into_value), + }) + } + } + } + for ((region, position), chain) in &self.break_chain { + if !slot_live(TypedObjectId::Region(*region)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::SystemBreak { + region: *region, + position: position.clone(), + predecessor, + }) + } + } + } + for ((region, position), chain) in &self.page_break_chain { + if !slot_live(TypedObjectId::Region(*region)) { + continue; + } + match chain.undo_verdict(tx) { + ChainUndoVerdict::NotWritten => {} + ChainUndoVerdict::Superseded { by } => superseded.push(by), + ChainUndoVerdict::Restore(predecessor) => { + restorations.push(ValueRestoration::PageBreak { + region: *region, + position: position.clone(), + predecessor, + }) + } + } + } + superseded.sort(); + superseded.dedup(); + (restorations, superseded) + } + + /// Applies the collected restorations to the bookkeeping and the graph, + /// recording each restored *value* into its chain as a new write by the + /// undo operation (so a later undo sees the restoration as the key's last + /// writer — the pinned undo-of-undo discipline; see DECISIONS.md). An + /// absence restoration (no predecessor at all) leaves the chain + /// unchanged: a repeated undo of the same transaction re-restores absence + /// idempotently. + fn apply_restorations(&mut self, env: &OperationEnvelope, restorations: Vec) { + for restoration in restorations { + match restoration { + ValueRestoration::Event { event, value } => { + if let Some(value) = value { + self.apply_event_value(&value); + self.event_modify_chain + .entry(event) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value); + } + } + ValueRestoration::Pitch { pitch, value } => { + if let Some(value) = value { + self.graph_modify_pitch(pitch, &value); + self.pitch_modify_chain + .entry(pitch) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value); + } + } + ValueRestoration::Spelling { pitch, predecessor } => match predecessor { + Some(Predecessor::Write(spelling)) => { + self.spellings.insert(pitch, spelling.clone()); + self.respell_chain + .entry(pitch) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, spelling.clone()); + self.graph_respell_pitch(pitch, &spelling); + } + Some(Predecessor::Base(spelling)) => { + // The ledger returns to key-absence (the base state + // lives in the graph); the graph attachment restores + // the base value. + self.spellings.remove(&pitch); + self.respell_chain + .entry(pitch) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, spelling.clone()); + self.graph_respell_pitch(pitch, &spelling); + } + None => { + self.spellings.remove(&pitch); + self.graph_remove_respell(pitch); + } + }, + ValueRestoration::CrossCutting { id, value } => { + if let Some(value) = value { + self.structures.insert(id, value.endpoints()); + self.graph_modify_cross_cutting(&value); + self.cross_cutting_modify_chain + .entry(id) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value); + } + } + ValueRestoration::Metadata { value } => { + if let Some(value) = value { + if let Some(score) = self.graph.as_mut() { + score.metadata = value.clone(); + } + self.metadata_chain.record(env.id, env.transaction, value); + } + } + ValueRestoration::MetricGrid { region, value } => { + self.metric_grid_chain + .entry(region) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value.clone()); + self.graph_set_metric_grid(region, &value); + } + ValueRestoration::MeterChange { + region, + position, + value, + } => { + self.meter_change_chain + .entry((region, position.clone())) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value.clone()); + self.graph_apply_meter_change(region, &position, &value); + } + ValueRestoration::TempoSegment { + region, + position, + value, + } => { + self.tempo_segment_chain + .entry((region, position.clone())) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value.clone()); + self.graph_apply_tempo_segment(region, &position, &value); + } + ValueRestoration::StaffLayout { instance, value } => { + if let Some(value) = value { + self.graph_set_staff_layout(instance, &value); + self.staff_layout_chain + .entry(instance) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, value); + } + } + ValueRestoration::SystemBreak { + region, + position, + predecessor, + } => self.restore_break(env, region, position, predecessor, false), + ValueRestoration::PageBreak { + region, + position, + predecessor, + } => self.restore_break(env, region, position, predecessor, true), + } + } + } + + /// Restores one user-break key: a write predecessor re-enters the ledger + /// map; a base predecessor returns the map to key-absence while the graph + /// restores the base anchor; no predecessor removes the key from map and + /// graph alike. + fn restore_break( + &mut self, + env: &OperationEnvelope, + region: RegionId, + position: MusicalPosition, + predecessor: Option>, + page: bool, + ) { + let key = (region, position.clone()); + match predecessor { + Some(Predecessor::Write((anchor, present))) => { + if page { + self.page_breaks.insert(key.clone(), present); + self.page_break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (anchor.clone(), present)); + } else { + self.breaks.insert(key.clone(), present); + self.break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (anchor.clone(), present)); + } + self.graph_apply_break(region, &anchor, present, page); + } + Some(Predecessor::Base((anchor, present))) => { + if page { + self.page_breaks.remove(&key); + self.page_break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (anchor.clone(), present)); + } else { + self.breaks.remove(&key); + self.break_chain + .entry(key) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, (anchor.clone(), present)); + } + self.graph_apply_break(region, &anchor, present, page); + } + None => { + if page { + self.page_breaks.remove(&key); + } else { + self.breaks.remove(&key); + } + self.graph_clear_break(region, &position, page); + } + } + } + + fn graph_apply_break( + &mut self, + region: RegionId, + anchor: &TimeAnchor, + present: bool, + page: bool, + ) { + let Some(score) = self.graph.as_mut() else { + return; + }; + if let Some(region) = score.canvas.regions.iter_mut().find(|r| r.id == region) { + if let Some(content) = region.content.staff_based_mut() { + let list = if page { + &mut content.user_page_breaks + } else { + &mut content.user_system_breaks + }; + apply_break_lww(list, anchor, present); + } + } + } + + fn graph_clear_break(&mut self, region: RegionId, position: &MusicalPosition, page: bool) { + let Some(score) = self.graph.as_mut() else { + return; + }; + if let Some(region) = score.canvas.regions.iter_mut().find(|r| r.id == region) { + if let Some(content) = region.content.staff_based_mut() { + let list = if page { + &mut content.user_page_breaks + } else { + &mut content.user_system_breaks + }; + list.retain(|existing| resolved_anchor_position(existing) != *position); + } + } + } + + /// Removes the user-chosen explicit spelling attachment for `pitch` — the + /// inverse of the attachment `graph_respell_pitch` installs, used when a + /// respell restoration has no predecessor (the operation introduced the + /// first spelling). + fn graph_remove_respell(&mut self, pitch: PitchId) { + let Some(score) = self.graph.as_mut() else { + return; + }; + score.spelling_attachments.retain(|a| { + !(a.layer.is_none() + && matches!(a.source, SpellingSource::UserChosen) + && matches!(&a.scope, SpellingScope::Pitch(p) if *p == pitch) + && matches!(a.directive, SpellingDirective::Explicit(_))) + }); + } + // --- Group 1 (M2): event & pitch leaf-field ops. ------------------------ // // The modify/transpose ops follow respell's field-overwrite discipline but @@ -3554,9 +5018,10 @@ impl<'a> Reducer<'a> { }; } let prev = self - .last_event_modify + .event_modify_chain .get(&event_id) - .map(|(o, e)| (*o, e.clone())); + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); let effect = match prev { Some((prev_op, prev_event)) if self.concurrent(env.id, prev_op) => { if prev_event == op.event { @@ -3582,15 +5047,27 @@ impl<'a> Reducer<'a> { // First modify, or a causally-ordered intentional overwrite. _ => OperationEffect::Applied, }; - self.last_event_modify - .insert(event_id, (env.id, op.event.clone())); - // Materialize a move only when it is a sanctioned metric move (`Moved`) *and* - // the replacement is well-formed — so the graph and the occupancy index move - // together. A malformed (empty) pitched replacement is not materialized in the - // graph (`graph_replace_event` skips it), so it must not move occupancy either. + self.event_modify_chain + .entry(event_id) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.event.clone()); + self.apply_event_value(&op.event); + effect + } + + /// Applies an event *value* (a modify's replacement, or an undo's restored + /// predecessor) to the graph and the occupancy index. A move materializes + /// only when it is a sanctioned metric move (`Moved`) *and* the value is + /// well-formed — so the graph and the occupancy index move together. A + /// malformed (empty) pitched value is not materialized in the graph + /// (`graph_replace_event` skips it), so it must not move occupancy either; + /// a refused or non-metric placement leaves placement untouched (only + /// same-placement field edits apply). + fn apply_event_value(&mut self, value: &Event) { + let placement = self.metric_placement_verdict(value); let materialize_move = matches!(placement, PlacementVerdict::Moved { .. }) - && !matches!(&op.event, Event::Pitched(pe) if !pe.is_well_formed()); - self.graph_replace_event(&op.event, materialize_move); + && !matches!(value, Event::Pitched(pe) if !pe.is_well_formed()); + self.graph_replace_event(value, materialize_move); // Keep the voice-occupancy index in step with a materialized move, so a later // insert sees the freed/changed span (the same index its overlap check reads). if materialize_move { @@ -3601,14 +5078,13 @@ impl<'a> Reducer<'a> { } = placement { if let Some(events) = self.voice_occupancy.get_mut(&voice) { - for slot in events.iter_mut().filter(|slot| slot.2 == event_id) { + for slot in events.iter_mut().filter(|slot| slot.2 == value.id()) { slot.0 = position.clone(); slot.1 = duration.clone(); } } } } - effect } /// The verdict on a [`ModifyEvent`](OperationKind::ModifyEvent)'s placement: does @@ -3771,6 +5247,12 @@ impl<'a> Reducer<'a> { self.objects.insert(p_obj, ObjectState::Live); self.minted_by.insert(p_obj, env.id); self.note_minted(env, p_obj); + // Seed the pitch's write chain with the minted value, so a later + // modify's chain-predecessor is the inserted state. + self.pitch_modify_chain + .entry(pitch_id) + .or_insert_with(WriteChain::new) + .seed(op.pitch.pitch.clone()); self.event_pitches .entry(op.event) .or_default() @@ -3836,9 +5318,10 @@ impl<'a> Reducer<'a> { Some(ObjectState::Live) => {} } let prev = self - .last_pitch_modify + .pitch_modify_chain .get(&op.pitch) - .map(|(o, v)| (*o, v.clone())); + .and_then(|chain| chain.last_write()) + .map(|write| (write.op, write.value.clone())); let effect = match prev { Some((prev_op, prev_value)) if self.concurrent(env.id, prev_op) => { if prev_value == op.value { @@ -3861,8 +5344,10 @@ impl<'a> Reducer<'a> { } _ => OperationEffect::Applied, }; - self.last_pitch_modify - .insert(op.pitch, (env.id, op.value.clone())); + self.pitch_modify_chain + .entry(op.pitch) + .or_insert_with(WriteChain::new) + .record(env.id, env.transaction, op.value.clone()); self.graph_modify_pitch(op.pitch, &op.value); effect } @@ -4879,11 +6364,19 @@ impl<'a> Reducer<'a> { minted_by: self.minted_by.clone(), event_pitches: self.event_pitches.clone(), voice_occupancy: self.voice_occupancy.clone(), - last_respell: self.last_respell.clone(), - last_event_modify: self.last_event_modify.clone(), - last_pitch_modify: self.last_pitch_modify.clone(), - last_cross_cutting_modify: self.last_cross_cutting_modify.clone(), - last_metric_grid: self.last_metric_grid.clone(), + respell_chain: self.respell_chain.clone(), + event_modify_chain: self.event_modify_chain.clone(), + pitch_modify_chain: self.pitch_modify_chain.clone(), + cross_cutting_modify_chain: self.cross_cutting_modify_chain.clone(), + metric_grid_chain: self.metric_grid_chain.clone(), + metadata_chain: self.metadata_chain.clone(), + break_chain: self.break_chain.clone(), + page_break_chain: self.page_break_chain.clone(), + meter_change_chain: self.meter_change_chain.clone(), + tempo_segment_chain: self.tempo_segment_chain.clone(), + staff_layout_chain: self.staff_layout_chain.clone(), + staff_values: self.staff_values.clone(), + time_signature_values: self.time_signature_values.clone(), structures: self.structures.clone(), region_instances: self.region_instances.clone(), instance_voices: self.instance_voices.clone(), @@ -4906,11 +6399,19 @@ impl<'a> Reducer<'a> { self.minted_by = s.minted_by; self.event_pitches = s.event_pitches; self.voice_occupancy = s.voice_occupancy; - self.last_respell = s.last_respell; - self.last_event_modify = s.last_event_modify; - self.last_pitch_modify = s.last_pitch_modify; - self.last_cross_cutting_modify = s.last_cross_cutting_modify; - self.last_metric_grid = s.last_metric_grid; + self.respell_chain = s.respell_chain; + self.event_modify_chain = s.event_modify_chain; + self.pitch_modify_chain = s.pitch_modify_chain; + self.cross_cutting_modify_chain = s.cross_cutting_modify_chain; + self.metric_grid_chain = s.metric_grid_chain; + self.metadata_chain = s.metadata_chain; + self.break_chain = s.break_chain; + self.page_break_chain = s.page_break_chain; + self.meter_change_chain = s.meter_change_chain; + self.tempo_segment_chain = s.tempo_segment_chain; + self.staff_layout_chain = s.staff_layout_chain; + self.staff_values = s.staff_values; + self.time_signature_values = s.time_signature_values; self.structures = s.structures; self.region_instances = s.region_instances; self.instance_voices = s.instance_voices; @@ -6985,4 +8486,561 @@ mod tests { ); } } + + // ========================================================================= + // Phase-3 first tranche: CreateStaff, SetTimeSignature, SetTempoSegment, + // SetStaffLayout, and value-restoring undo (operation_catalog + // §CreateStaff, §"Meter and Tempo Overwrites", §SetStaffLayout, §undo). + // ========================================================================= + + fn tx_member( + replica: u64, + counter: u64, + physical: i64, + ctx: CausalContext, + tx: TransactionId, + kind: OperationKind, + ) -> OperationEnvelope { + let mut env = prim_env(replica, counter, physical, ctx, kind); + env.transaction = Some(tx); + env + } + + fn declare_transaction( + replica: u64, + counter: u64, + physical: i64, + ctx: CausalContext, + tx: TransactionId, + ) -> OperationEnvelope { + tx_member( + replica, + counter, + physical, + ctx, + tx, + OperationKind::DeclareTransaction(crate::payload::TransactionDescriptor { + id: tx, + label: String::from("phase-3 undo scenario"), + category: None, + }), + ) + } + + fn undo_env( + replica: u64, + counter: u64, + physical: i64, + ctx: CausalContext, + target: TransactionId, + policy: UndoPolicy, + ) -> OperationEnvelope { + let id = OperationId::new(ReplicaId(replica), counter); + OperationEnvelope { + id, + author: AuthorId(0), + stamp: OperationStamp::new(HybridLogicalClock::new(WallClockTime(physical), 0), id), + causal_context: ctx, + transaction: None, + payload: OperationPayload::UndoTransaction(UndoTransactionPayload { target, policy }), + } + } + + fn seen_r1(counter: u64) -> CausalContext { + CausalContext::new().with_seen(ReplicaId(1), counter) + } + + fn respell_kind(pitch: PitchId, nth: u8) -> OperationKind { + OperationKind::RespellPitch(RespellPitchOp { + pitch, + spelling: crate::valuegen::spelling(nth), + }) + } + + #[test] + fn create_staff_set_union_mint_discipline() { + let staff_id = StaffId::new(ReplicaId(9), 7); + let instrument = InstrumentId::new(ReplicaId(9), 1); + let value = crate::valuegen::staff(staff_id, instrument); + let create = prim_env( + 1, + 0, + 10, + CausalContext::new(), + OperationKind::CreateStaff(CreateStaffOp { + staff: value.clone(), + }), + ); + let identical = prim_env( + 2, + 0, + 20, + CausalContext::new(), + OperationKind::CreateStaff(CreateStaffOp { + staff: value.clone(), + }), + ); + let mut differing_value = value.clone(); + differing_value.name = String::from("something else"); + let differing = prim_env( + 3, + 0, + 30, + CausalContext::new(), + OperationKind::CreateStaff(CreateStaffOp { + staff: differing_value, + }), + ); + let mut set = OperationSet::new(); + set.accept_all(vec![differing.clone(), identical.clone(), create.clone()]); + let state = set.reduce(); + + let effect_of = |id: OperationId| { + state + .effects + .iter() + .find(|(e, _)| *e == id) + .map(|(_, eff)| eff) + }; + assert_eq!(effect_of(create.id), Some(&OperationEffect::Applied)); + assert_eq!( + effect_of(identical.id), + Some(&OperationEffect::NoOp { + reason: NoOpReason::AlreadyApplied, + }), + "a byte-identical re-create reduces idempotently" + ); + assert_eq!( + effect_of(differing.id), + Some(&OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }), + "a differing value under a live id is a precondition no-op" + ); + assert!(matches!( + state.objects.get(&TypedObjectId::Staff(staff_id)), + Some(ObjectState::Live) + )); + } + + fn create_region_env( + replica: u64, + counter: u64, + physical: i64, + region: RegionId, + ) -> OperationEnvelope { + prim_env( + replica, + counter, + physical, + CausalContext::new(), + OperationKind::CreateRegion(CreateRegionOp { + region: crate::valuegen::region(region), + }), + ) + } + + fn set_meter_kind( + region: RegionId, + at: MusicalPosition, + signature: Option, + ) -> OperationKind { + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: crate::valuegen::region_start_anchor(region, at), + time_signature: signature, + }) + } + + #[test] + fn concurrent_differing_meter_writes_collide_on_meter_sequence() { + let region = RegionId::new(ReplicaId(9), 3); + let create = create_region_env(1, 0, 10, region); + let seen = seen_r1(0); + let ts_a = crate::valuegen::time_signature(TimeSignatureId::new(ReplicaId(9), 1), 4); + let ts_b = crate::valuegen::time_signature(TimeSignatureId::new(ReplicaId(9), 2), 3); + let set_a = prim_env( + 2, + 0, + 20, + seen.clone(), + set_meter_kind(region, pos(0), Some(ts_a)), + ); + let set_b = prim_env(3, 0, 20, seen, set_meter_kind(region, pos(0), Some(ts_b))); + let mut set = OperationSet::new(); + set.accept_all(vec![set_b.clone(), set_a.clone(), create]); + let state = set.reduce(); + + assert_eq!(state.conflicts.records().len(), 1); + assert!(matches!( + &state.conflicts.records()[0].kind, + ConflictKind::StructuralFieldCollision { field, winner, loser } + if field.0 == "meter_sequence" && *winner == set_b.id && *loser == set_a.id + )); + } + + #[test] + fn identical_concurrent_meter_writes_reduce_idempotently() { + let region = RegionId::new(ReplicaId(9), 3); + let create = create_region_env(1, 0, 10, region); + let seen = seen_r1(0); + let ts = crate::valuegen::time_signature(TimeSignatureId::new(ReplicaId(9), 1), 4); + let set_a = prim_env( + 2, + 0, + 20, + seen.clone(), + set_meter_kind(region, pos(0), Some(ts.clone())), + ); + let set_b = prim_env(3, 0, 20, seen, set_meter_kind(region, pos(0), Some(ts))); + let mut set = OperationSet::new(); + set.accept_all(vec![set_b.clone(), set_a.clone(), create]); + let state = set.reduce(); + + assert!(state.conflicts.is_empty()); + let effect_of = |id: OperationId| { + state + .effects + .iter() + .find(|(e, _)| *e == id) + .map(|(_, eff)| eff) + }; + assert_eq!(effect_of(set_a.id), Some(&OperationEffect::Applied)); + assert_eq!( + effect_of(set_b.id), + Some(&OperationEffect::NoOp { + reason: NoOpReason::AlreadyApplied, + }) + ); + } + + #[test] + fn a_differing_recarry_of_a_live_time_signature_is_refused() { + let region = RegionId::new(ReplicaId(9), 3); + let signature_id = TimeSignatureId::new(ReplicaId(9), 1); + let create = create_region_env(1, 0, 10, region); + let set_a = prim_env( + 1, + 1, + 20, + seen_r1(0), + set_meter_kind( + region, + pos(0), + Some(crate::valuegen::time_signature(signature_id, 4)), + ), + ); + // Causally later, same signature id, different value, different key. + let set_b = prim_env( + 1, + 2, + 30, + seen_r1(1), + set_meter_kind( + region, + pos(4), + Some(crate::valuegen::time_signature(signature_id, 3)), + ), + ); + let mut set = OperationSet::new(); + set.accept_all(vec![create, set_a, set_b.clone()]); + let state = set.reduce(); + + assert_eq!( + state + .effects + .iter() + .find(|(e, _)| *e == set_b.id) + .map(|(_, eff)| eff), + Some(&OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TargetMissing, + }, + }), + "a differing value under a live signature id is a precondition no-op" + ); + } + + #[test] + fn set_tempo_segment_refuses_writes_that_would_malform_the_map() { + let region = RegionId::new(ReplicaId(9), 0); + let anchor_at = |at: i64| crate::valuegen::region_start_anchor(region, pos(at)); + let malformed = |counter: u64, op: SetTempoSegmentOp| { + prim_env( + 1, + counter, + (counter as i64 + 1) * 10, + if counter == 0 { + CausalContext::new() + } else { + seen_r1(counter - 1) + }, + OperationKind::SetTempoSegment(op), + ) + }; + // (0) A clean open constant segment at 0 applies (score scope). + let clean = malformed( + 0, + SetTempoSegmentOp { + region: None, + start: anchor_at(0), + segment: Some(crate::valuegen::tempo_segment(region, pos(0), 120.0)), + }, + ); + // (1) Carried segment start disagrees with the operation's key. + let key_mismatch = malformed( + 1, + SetTempoSegmentOp { + region: None, + start: anchor_at(2), + segment: Some(crate::valuegen::tempo_segment(region, pos(3), 90.0)), + }, + ); + // (2) A non-constant shape missing its end data. + let mut ramp = crate::valuegen::tempo_segment(region, pos(4), 60.0); + ramp.shape = epiphany_core::TempoShape::Linear; + let missing_end = malformed( + 2, + SetTempoSegmentOp { + region: None, + start: anchor_at(4), + segment: Some(ramp), + }, + ); + // (3) An explicit end overlapping the next segment: a segment at -4 + // whose end (at 2) runs past the existing segment's start at 0. + let mut overlapping = crate::valuegen::tempo_segment(region, pos(-4), 100.0); + overlapping.end = Some(anchor_at(2)); + let overlap = malformed( + 3, + SetTempoSegmentOp { + region: None, + start: anchor_at(-4), + segment: Some(overlapping), + }, + ); + let mut set = OperationSet::new(); + set.accept_all(vec![ + clean.clone(), + key_mismatch.clone(), + missing_end.clone(), + overlap.clone(), + ]); + let state = set.reduce(); + + let effect_of = |id: OperationId| { + state + .effects + .iter() + .find(|(e, _)| *e == id) + .map(|(_, eff)| eff) + }; + assert_eq!(effect_of(clean.id), Some(&OperationEffect::Applied)); + let refused = OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { + reason: PreconditionFailureReason::TempoMapMalformed, + }, + }; + assert_eq!(effect_of(key_mismatch.id), Some(&refused)); + assert_eq!(effect_of(missing_end.id), Some(&refused)); + assert_eq!(effect_of(overlap.id), Some(&refused)); + } + + /// The base scenario of the value-restoring undo unit tests: an event with + /// one pitch (r1c0), a pre-transaction respell to `spelling(1)` (r1c1), a + /// transaction T (declared r1c2) whose member respells to `spelling(2)` + /// (r1c3). + fn respell_undo_fixture(tx: TransactionId) -> (PitchId, Vec) { + let pitch = PitchId::new(ReplicaId(1), 50); + let e0 = + insert_with_pitch_content(1, 0, 10, 1, 100, 0, pitch, &crate::valuegen::pitch_value()); + let pre = prim_env(1, 1, 20, seen_r1(0), respell_kind(pitch, 1)); + let declare = declare_transaction(1, 2, 30, seen_r1(1), tx); + let member = tx_member(1, 3, 40, seen_r1(2), tx, respell_kind(pitch, 2)); + (pitch, vec![e0, pre, declare, member]) + } + + #[test] + fn undo_restores_the_chain_predecessor_spelling() { + let tx = TransactionId::from_raw(21); + let (pitch, mut envelopes) = respell_undo_fixture(tx); + envelopes.push(undo_env( + 1, + 4, + 50, + seen_r1(3), + tx, + UndoPolicy::StrictInverse, + )); + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let state = set.reduce(); + + assert!(state.conflicts.is_empty()); + assert_eq!( + state.spellings.get(&pitch), + Some(&crate::valuegen::spelling(1)), + "undo must restore the pre-transaction spelling" + ); + // A pure value restoration (no mints) is a clean `Applied`. + assert_eq!(effect_at(&state, 4), Some(&OperationEffect::Applied)); + } + + #[test] + fn undo_removes_a_first_spelling_write() { + // No pre-transaction respell: the transaction introduced the first + // spelling, so undo restores absence. + let tx = TransactionId::from_raw(22); + let pitch = PitchId::new(ReplicaId(1), 50); + let e0 = + insert_with_pitch_content(1, 0, 10, 1, 100, 0, pitch, &crate::valuegen::pitch_value()); + let declare = declare_transaction(1, 1, 20, seen_r1(0), tx); + let member = tx_member(1, 2, 30, seen_r1(1), tx, respell_kind(pitch, 2)); + let undo = undo_env(1, 3, 40, seen_r1(2), tx, UndoPolicy::StrictInverse); + let mut set = OperationSet::new(); + set.accept_all(vec![undo, member, declare, e0]); + let state = set.reduce(); + + assert!(state.conflicts.is_empty()); + assert_eq!(state.spellings.get(&pitch), None); + assert_eq!(effect_at(&state, 3), Some(&OperationEffect::Applied)); + } + + #[test] + fn superseded_undo_conflicts_strict_and_skips_best_effort() { + let tx = TransactionId::from_raw(23); + let (pitch, mut envelopes) = respell_undo_fixture(tx); + // A causally-later respell supersedes the transaction's write. + let superseder = prim_env(1, 4, 50, seen_r1(3), respell_kind(pitch, 3)); + let strict = undo_env(1, 5, 60, seen_r1(4), tx, UndoPolicy::StrictInverse); + let best_effort = undo_env(1, 6, 70, seen_r1(5), tx, UndoPolicy::BestEffort); + envelopes.extend([superseder.clone(), strict.clone(), best_effort.clone()]); + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let state = set.reduce(); + + // StrictInverse refuses the whole undo, naming the undo and the + // superseding writer. + assert!(matches!( + effect_at(&state, 5), + Some(OperationEffect::Conflicted { .. }) + )); + let record = state + .conflicts + .records() + .iter() + .find(|record| record.caused_by.contains(&strict.id)) + .expect("the strict undo records a conflict"); + assert!(matches!( + &record.kind, + ConflictKind::TransactionConflict { transaction, .. } if *transaction == tx + )); + assert!(record.caused_by.contains(&superseder.id)); + // BestEffort skips the superseded key: applied, nothing restored. + assert_eq!(effect_at(&state, 6), Some(&OperationEffect::Applied)); + assert_eq!( + state.spellings.get(&pitch), + Some(&crate::valuegen::spelling(3)), + "the superseding write stands" + ); + } + + #[test] + fn undo_of_undo_restores_the_pre_undo_value() { + // PINNED (see DECISIONS.md): an undo's restoration enters the write + // chain as a new write by the undo operation. Undoing the undo's own + // enclosing transaction therefore restores the value the first undo + // removed. + let tx = TransactionId::from_raw(24); + let (pitch, mut envelopes) = respell_undo_fixture(tx); + let undo_tx = TransactionId::from_raw(25); + let declare_undo_tx = declare_transaction(1, 4, 50, seen_r1(3), undo_tx); + let mut first_undo = undo_env(1, 5, 60, seen_r1(4), tx, UndoPolicy::StrictInverse); + first_undo.transaction = Some(undo_tx); + let second_undo = undo_env(1, 6, 70, seen_r1(5), undo_tx, UndoPolicy::StrictInverse); + envelopes.extend([declare_undo_tx, first_undo, second_undo]); + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let state = set.reduce(); + + assert!(state.conflicts.is_empty()); + assert_eq!( + state.spellings.get(&pitch), + Some(&crate::valuegen::spelling(2)), + "undoing the undo restores the originally-undone spelling" + ); + } + + #[test] + fn a_second_undo_of_the_same_transaction_sees_the_first_as_superseding() { + // PINNED (see DECISIONS.md): the first undo's restoration is a write, + // so a repeated strict undo of the same transaction conflicts rather + // than double-restoring. + let tx = TransactionId::from_raw(26); + let (pitch, mut envelopes) = respell_undo_fixture(tx); + let first = undo_env(1, 4, 50, seen_r1(3), tx, UndoPolicy::StrictInverse); + let second = undo_env(1, 5, 60, seen_r1(4), tx, UndoPolicy::StrictInverse); + envelopes.extend([first, second]); + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let state = set.reduce(); + + assert_eq!( + state.spellings.get(&pitch), + Some(&crate::valuegen::spelling(1)), + "the first undo's restoration stands" + ); + assert!(matches!( + effect_at(&state, 5), + Some(OperationEffect::Conflicted { .. }) + )); + } + + #[test] + fn undo_restoration_is_permutation_invariant() { + // The write chains append in canonical processing order, so the undo's + // restoration verdict and restored values are pure functions of the + // operation set: any delivery order reduces to byte-identical state. + let tx = TransactionId::from_raw(27); + let (_, mut envelopes) = respell_undo_fixture(tx); + // Add a meter overwrite + undo flavor alongside the respell flavor. + let region = RegionId::new(ReplicaId(9), 3); + envelopes.push(prim_env( + 2, + 0, + 15, + CausalContext::new(), + OperationKind::CreateRegion(CreateRegionOp { + region: crate::valuegen::region(region), + }), + )); + envelopes.push(undo_env( + 1, + 4, + 50, + seen_r1(3), + tx, + UndoPolicy::StrictInverse, + )); + + let baseline = { + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + set.reduce().canonical_bytes() + }; + let mut rng = epiphany_determinism::fuzz::SplitMix64::new(0x9E37_79B9_7F4A_7C15); + for _ in 0..4 { + let mut shuffled = envelopes.clone(); + shuffle_envelopes(&mut shuffled, &mut rng); + let mut set = OperationSet::new(); + set.accept_all(shuffled); + assert_eq!( + set.reduce().canonical_bytes(), + baseline, + "value-restoring undo must be permutation-invariant" + ); + } + } } diff --git a/crates/epiphany-ops/src/v0.rs b/crates/epiphany-ops/src/v0.rs index 645eb4c..9de3bd3 100644 --- a/crates/epiphany-ops/src/v0.rs +++ b/crates/epiphany-ops/src/v0.rs @@ -92,6 +92,11 @@ pub enum V0OperationKind { SetMetadata(crate::payload::SetMetadataOp), SetMetricGrid(crate::payload::SetMetricGridOp), SetUserPageBreak(crate::payload::SetUserPageBreakOp), + // Phase-3 first tranche — also v1-native; round-trip by identity. + CreateStaff(crate::payload::CreateStaffOp), + SetTimeSignature(crate::payload::SetTimeSignatureOp), + SetTempoSegment(crate::payload::SetTempoSegmentOp), + SetStaffLayout(crate::payload::SetStaffLayoutOp), } /// v0 `InsertEvent`: the event was a bare [`EventId`] plus the reduction-relevant diff --git a/crates/epiphany-ops/src/validate.rs b/crates/epiphany-ops/src/validate.rs index a34bc22..7055bf1 100644 --- a/crates/epiphany-ops/src/validate.rs +++ b/crates/epiphany-ops/src/validate.rs @@ -40,6 +40,14 @@ //! applies to it identically (the replacement's span must not straddle the //! region boundary any more than an inserted one may). //! +//! The Phase-3 first tranche (`CreateStaff`, `SetTimeSignature`, +//! `SetTempoSegment`, `SetStaffLayout` — operation_catalog §CreateStaff, +//! §"Meter and Tempo Overwrites", §SetStaffLayout) declares **no advisory +//! preconditions**: every precondition those entries name (reference +//! resolution, mint freshness, resulting-map well-formedness, target +//! liveness) is invariant and enforced by the reducer in all modes, so this +//! module gains no new checks for them. +//! //! ### Implemented here //! //! * InsertEvent / ModifyEvent duration-not-crossing-region-boundary diff --git a/crates/epiphany-ops/src/valuegen.rs b/crates/epiphany-ops/src/valuegen.rs index 5a4bb9a..1f4f435 100644 --- a/crates/epiphany-ops/src/valuegen.rs +++ b/crates/epiphany-ops/src/valuegen.rs @@ -288,6 +288,74 @@ pub fn metric_grid() -> epiphany_core::MetricGrid { } } +/// A minimal global [`Staff`](epiphany_core::Staff) (Phase-3 tranche) — the +/// value a `CreateStaff` mints: a five-line staff named for its counter, +/// referencing `instrument`, with no abbreviation or group. +pub fn staff(id: StaffId, instrument: epiphany_core::InstrumentId) -> epiphany_core::Staff { + epiphany_core::Staff { + id, + name: format!("staff-{}", id.counter()), + abbreviation: None, + instrument, + default_staff_lines: epiphany_core::StaffLineConfiguration::default(), + group: None, + } +} + +/// A well-formed `numerator`/4 [`TimeSignature`](epiphany_core::TimeSignature) +/// (Phase-3 tranche): `numerator` quarter-note beat groups summing exactly to +/// the measure duration, so [`epiphany_core::TimeSignature::new`]'s beat-group +/// invariant holds by construction. Distinct numerators give distinct values, +/// letting a harness drive the set-union mint's identical/differing re-carry +/// branches deterministically. +pub fn time_signature( + id: epiphany_core::TimeSignatureId, + numerator: u16, +) -> epiphany_core::TimeSignature { + let numerator = numerator.max(1); + let quarter = MusicalDuration(epiphany_core::RationalTime::new(1, 4).expect("1/4 is valid")); + let measure = MusicalDuration( + epiphany_core::RationalTime::new(numerator as i64, 4).expect("n/4 is valid"), + ); + let beat_groups = (0..numerator) + .map(|i| epiphany_core::BeatGroup { + duration: quarter.clone(), + subdivision: None, + accent: u8::from(i == 0), + }) + .collect(); + epiphany_core::TimeSignature::new( + id, + epiphany_core::TimeSignatureDisplay::Standard { + numerator, + denominator: epiphany_core::PowerOfTwo::new(4).expect("4 is a power of two"), + }, + measure, + beat_groups, + ) + .expect("beat groups sum to the measure duration by construction") +} + +/// A constant [`TempoSegment`](epiphany_core::TempoSegment) (Phase-3 tranche) +/// starting at the given region-relative musical position, open-ended, at +/// `bpm` quarter-note beats per minute. Its start anchor resolves (under the +/// operation layer's coarse anchor resolution) to exactly `start`, so it +/// satisfies `SetTempoSegment`'s start-key agreement precondition when keyed +/// by the same anchor. +pub fn tempo_segment( + region: RegionId, + start: MusicalPosition, + bpm: f64, +) -> epiphany_core::TempoSegment { + epiphany_core::TempoSegment { + start: region_start_anchor(region, start), + end: None, + start_tempo: epiphany_core::Tempo::quarter(bpm).expect("positive finite bpm"), + end_tempo: None, + shape: epiphany_core::TempoShape::Constant, + } +} + /// An explicit, user-chosen per-pitch [`SpellingAttachment`] — the engraved-layer /// spelling a materialized score carries after a `RespellPitch`. The v0 → v1 /// migration recovers a respell's spelling from exactly these attachments diff --git a/crates/epiphany-ops/tests/graph_reduction.rs b/crates/epiphany-ops/tests/graph_reduction.rs index 9843db7..1b9837f 100644 --- a/crates/epiphany-ops/tests/graph_reduction.rs +++ b/crates/epiphany-ops/tests/graph_reduction.rs @@ -6,16 +6,18 @@ use epiphany_core::{ AnchorOffset, AnnotationAnchor, Comment, CommentId, CueEvent, CueRendering, Event, EventDuration, EventId, EventPosition, GestureAnchoring, GraphicGesture, GraphicGestureId, Marker, MarkerId, MusicalDuration, MusicalPosition, OperationId, PitchId, RationalTime, - RegionEdge, RegionTimeModel, ReplicaId, Score, SlurId, StaffInstanceId, TimeAnchor, - TransactionId, TypedObjectId, VoiceId, VoiceOrigin, WallClockTime, + RegionEdge, RegionId, RegionTimeModel, ReplicaId, Score, SlurId, StaffId, StaffInstanceId, + TimeAnchor, TimeSignatureId, TransactionId, TypedObjectId, VoiceId, VoiceOrigin, WallClockTime, }; use epiphany_ops::{ valuegen, AuthorId, CausalContext, ChangeRegionTimeModelOp, ConflictKind, CreateCrossCuttingOp, - CrossCuttingValue, DeleteEventOp, HybridLogicalClock, InsertEventOp, NoOpReason, - OperationEffect, OperationEnvelope, OperationKind, OperationPayload, OperationSet, - OperationStamp, PositionRemapping, PreconditionFailureReason, ReanchorReason, RepairKind, - RepairRecord, SetUserSystemBreakOp, TransactionCategory, TransactionDescriptor, - TupletCompensation, UndoPolicy, UndoTransactionPayload, + CreateStaffInstanceOp, CreateStaffOp, CrossCuttingValue, DeleteEventOp, DeleteStaffInstanceOp, + HybridLogicalClock, InsertEventOp, ModifyEventOp, NoOpReason, OperationEffect, + OperationEnvelope, OperationKind, OperationPayload, OperationSet, OperationStamp, + PositionRemapping, PreconditionFailureReason, ReanchorReason, RepairKind, RepairRecord, + RespellPitchOp, SetMetricGridOp, SetStaffLayoutOp, SetTempoSegmentOp, SetTimeSignatureOp, + SetUserSystemBreakOp, TransactionCategory, TransactionDescriptor, TupletCompensation, + UndoPolicy, UndoTransactionPayload, }; fn envelope( @@ -2751,3 +2753,901 @@ fn referent_reanchoring_is_permutation_invariant() { ); } } + +// =========================================================================== +// Phase-3 first tranche: CreateStaff, SetTimeSignature, SetTempoSegment, +// SetStaffLayout (operation_catalog §CreateStaff, §"Meter and Tempo +// Overwrites", §SetStaffLayout), and value-restoring undo (§UndoTransaction). +// =========================================================================== + +fn seen(replica: u64, counter: u64) -> CausalContext { + CausalContext::new().with_seen(ReplicaId(replica), counter) +} + +fn prim(kind: OperationKind) -> OperationPayload { + OperationPayload::Primitive(kind) +} + +/// A single-replica causal chain of primitives (each member sees its +/// predecessor), optionally under one transaction. +fn chain( + replica: u64, + start_physical: i64, + tx: Option, + kinds: Vec, +) -> Vec { + kinds + .into_iter() + .enumerate() + .map(|(index, kind)| { + let counter = index as u64; + let ctx = if counter == 0 { + CausalContext::new() + } else { + seen(replica, counter - 1) + }; + envelope( + replica, + counter, + start_physical + counter as i64, + ctx, + tx, + prim(kind), + ) + }) + .collect() +} + +fn set_meter( + region: RegionId, + at: i32, + signature: Option, +) -> OperationKind { + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: valuegen::region_start_anchor(region, MusicalPosition(RationalTime::from_int(at))), + time_signature: signature, + }) +} + +fn set_tempo( + region_scope: Option, + anchor_region: RegionId, + at: i32, + segment: Option, +) -> OperationKind { + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: region_scope, + start: valuegen::region_start_anchor( + anchor_region, + MusicalPosition(RationalTime::from_int(at)), + ), + segment, + }) +} + +fn effect_for(result: &epiphany_ops::GraphMaterialization, id: OperationId) -> &OperationEffect { + result + .state + .effects + .iter() + .find(|(e, _)| *e == id) + .map(|(_, effect)| effect) + .expect("every accepted operation produces an effect") +} + +fn precondition_noop(reason: PreconditionFailureReason) -> OperationEffect { + OperationEffect::NoOp { + reason: NoOpReason::PreconditionFailedUnderReduction { reason }, + } +} + +#[test] +fn create_staff_mints_into_the_graph_and_checks_references() { + let base = epiphany_core::generators::valid_score(300); + let instrument = base.instruments[0].id; + let staff_id = StaffId::new(ReplicaId(60), 1); + let envelopes = chain( + 60, + 10, + None, + vec![ + OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff(staff_id, instrument), + }), + // A staff naming an undeclared instrument is refused (graph-aware + // reference-resolution precondition). + OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff( + StaffId::new(ReplicaId(60), 2), + epiphany_core::InstrumentId::new(ReplicaId(60), 99), + ), + }), + ], + ); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + + assert_eq!( + effect_for(&result, envelopes[0].id), + &OperationEffect::Applied + ); + assert_eq!( + effect_for(&result, envelopes[1].id), + &precondition_noop(PreconditionFailureReason::TargetMissing), + ); + assert!(result.score.staves.iter().any(|s| s.id == staff_id)); + assert!(matches!( + result.state.objects.get(&TypedObjectId::Staff(staff_id)), + Some(epiphany_ops::ObjectState::Live) + )); + assert!(check_invariants(&result.score).is_empty()); +} + +#[test] +fn create_staff_instance_now_requires_a_live_staff() { + let base = epiphany_core::generators::valid_score(301); + let region = base.canvas.regions[0].id; + let instrument = base.instruments[0].id; + let minted_staff = StaffId::new(ReplicaId(61), 1); + let envelopes = chain( + 61, + 10, + None, + vec![ + // Referencing a staff that was never minted: refused. + OperationKind::CreateStaffInstance(CreateStaffInstanceOp { + region, + instance: valuegen::staff_instance( + StaffInstanceId::new(ReplicaId(61), 5), + StaffId::new(ReplicaId(61), 9), + ), + }), + // Mint the staff, then an instance referencing it applies. + OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff(minted_staff, instrument), + }), + OperationKind::CreateStaffInstance(CreateStaffInstanceOp { + region, + instance: valuegen::staff_instance( + StaffInstanceId::new(ReplicaId(61), 6), + minted_staff, + ), + }), + ], + ); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + + assert_eq!( + effect_for(&result, envelopes[0].id), + &precondition_noop(PreconditionFailureReason::TargetMissing), + ); + assert_eq!( + effect_for(&result, envelopes[2].id), + &OperationEffect::Applied + ); + assert!(result + .score + .staff_instances() + .any(|(_, si)| si.id == StaffInstanceId::new(ReplicaId(61), 6))); + assert!(check_invariants(&result.score).is_empty()); +} + +#[test] +fn set_time_signature_sets_replaces_and_removes_in_the_grid() { + let base = epiphany_core::generators::valid_score(302); + let region = base.canvas.regions[0].id; + let ts_a = valuegen::time_signature(TimeSignatureId::new(ReplicaId(62), 1), 4); + let ts_b = valuegen::time_signature(TimeSignatureId::new(ReplicaId(62), 2), 3); + let envelopes = chain( + 62, + 10, + None, + vec![ + set_meter(region, 0, Some(ts_a.clone())), + set_meter(region, 0, Some(ts_b.clone())), + set_meter(region, 0, None), + ], + ); + + // Set: the grid is created around the meter change; the signature mints. + let mut set = OperationSet::new(); + set.accept_all(envelopes[..1].to_vec()); + let result = set.reduce_onto(&base); + let grid = |result: &epiphany_ops::GraphMaterialization| { + result.score.canvas.regions[0] + .content + .staff_based() + .expect("fixture is staff based") + .default_metric_grid + .clone() + }; + let after_set = grid(&result).expect("a set creates the grid"); + assert_eq!(after_set.meter_sequence.len(), 1); + assert_eq!(after_set.meter_sequence[0].time_signature, ts_a.id); + assert!(result.score.time_signatures.iter().any(|t| t.id == ts_a.id)); + assert!(check_invariants(&result.score).is_empty()); + + // Replace: the causally-later write overwrites the single slot. + let mut set = OperationSet::new(); + set.accept_all(envelopes[..2].to_vec()); + let result = set.reduce_onto(&base); + let after_replace = grid(&result).expect("still present after replace"); + assert_eq!(after_replace.meter_sequence.len(), 1); + assert_eq!(after_replace.meter_sequence[0].time_signature, ts_b.id); + assert!(check_invariants(&result.score).is_empty()); + + // Remove: the slot empties; the grid the set created normalizes away. + let mut set = OperationSet::new(); + set.accept_all(envelopes.to_vec()); + let result = set.reduce_onto(&base); + assert_eq!(grid(&result), None); + assert!(check_invariants(&result.score).is_empty()); +} + +#[test] +fn a_mid_region_meter_change_reduces_cleanly_p12_c5() { + // P12-C5: a mid-region SetTimeSignature reduces cleanly and materializes + // into the grid; the decomposition pre-pass still honors only the first + // governing meter (P12-H4) but must not crash on the multi-meter grid. + let base = epiphany_core::generators::valid_score(303); + let region = base.canvas.regions[0].id; + let ts_a = valuegen::time_signature(TimeSignatureId::new(ReplicaId(63), 1), 4); + let ts_b = valuegen::time_signature(TimeSignatureId::new(ReplicaId(63), 2), 3); + let envelopes = chain( + 63, + 10, + None, + vec![ + set_meter(region, 0, Some(ts_a.clone())), + set_meter(region, 8, Some(ts_b.clone())), + ], + ); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + + for env in &envelopes { + assert_eq!(effect_for(&result, env.id), &OperationEffect::Applied); + } + let grid = result.score.canvas.regions[0] + .content + .staff_based() + .expect("fixture is staff based") + .default_metric_grid + .as_ref() + .expect("the sets created the grid"); + assert_eq!( + grid.meter_sequence + .iter() + .map(|m| m.time_signature) + .collect::>(), + vec![ts_a.id, ts_b.id], + "meter changes stay ordered by resolved position" + ); + assert!(check_invariants(&result.score).is_empty()); + // The pre-pass tolerates the multi-meter grid (P12-H4 owns honoring it). + let _ = + epiphany_core::derive_annotations(&result.score, &epiphany_core::PrePassProfile::default()); +} + +#[test] +fn set_tempo_segment_materializes_in_score_and_region_scope() { + let base = epiphany_core::generators::valid_score(304); + let region = base.canvas.regions[0].id; + let score_seg = valuegen::tempo_segment(region, MusicalPosition::origin(), 120.0); + let local_seg = valuegen::tempo_segment(region, MusicalPosition::origin(), 90.0); + let mut ramp = + valuegen::tempo_segment(region, MusicalPosition(RationalTime::from_int(4)), 60.0); + ramp.shape = epiphany_core::TempoShape::Linear; // no end data: malformed + let envelopes = chain( + 64, + 10, + None, + vec![ + set_tempo(None, region, 0, Some(score_seg.clone())), + set_tempo(Some(region), region, 0, Some(local_seg.clone())), + set_tempo(None, region, 4, Some(ramp)), + set_tempo(Some(region), region, 0, None), + ], + ); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + + assert_eq!( + effect_for(&result, envelopes[0].id), + &OperationEffect::Applied + ); + assert_eq!( + effect_for(&result, envelopes[1].id), + &OperationEffect::Applied + ); + assert_eq!( + effect_for(&result, envelopes[2].id), + &precondition_noop(PreconditionFailureReason::TempoMapMalformed), + ); + assert_eq!( + effect_for(&result, envelopes[3].id), + &OperationEffect::Applied + ); + assert_eq!(result.score.tempo_map.segments, vec![score_seg]); + // The local map was created by the set and normalized away by the remove. + assert_eq!(result.score.canvas.regions[0].local_tempo_map, None); + assert!(check_invariants(&result.score).is_empty()); + + // The region-scoped set alone creates (and keeps) the local map. + let mut set = OperationSet::new(); + set.accept_all(envelopes[..2].to_vec()); + let result = set.reduce_onto(&base); + let local = result.score.canvas.regions[0] + .local_tempo_map + .as_ref() + .expect("a set on a region with no local map creates one"); + assert_eq!(local.segments, vec![local_seg]); + assert!(check_invariants(&result.score).is_empty()); +} + +#[test] +fn set_staff_layout_is_an_advisory_lww_with_tombstone_noop() { + let base = epiphany_core::generators::valid_score(305); + let region = base.canvas.regions[0].id; + let instance = base.canvas.regions[0].staff_instances()[0].id; + let staff = base.canvas.regions[0].staff_instances()[0].staff; + let instrument = base.instruments[0].id; + + // Two concurrent differing writes: advisory LWW — no conflict; the later + // in canonical order (greater replica at an equal stamp) wins. + let earlier = envelope( + 65, + 0, + 10, + CausalContext::new(), + None, + prim(OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: instance, + instrument_override: Some(instrument), + staff_lines_override: None, + visible: true, + })), + ); + let later = envelope( + 66, + 0, + 10, + CausalContext::new(), + None, + prim(OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: instance, + instrument_override: None, + staff_lines_override: Some(epiphany_core::StaffLineConfiguration { line_count: 1 }), + visible: false, + })), + ); + let mut set = OperationSet::new(); + set.accept_all(vec![earlier.clone(), later.clone()]); + let result = set.reduce_onto(&base); + + assert!( + result.state.conflicts.is_empty(), + "advisory LWW never conflicts" + ); + assert_eq!(effect_for(&result, earlier.id), &OperationEffect::Applied); + assert_eq!(effect_for(&result, later.id), &OperationEffect::Applied); + let materialized = result + .score + .staff_instances() + .find(|(_, si)| si.id == instance) + .expect("instance survives") + .1 + .clone(); + assert_eq!(materialized.instrument_override, None); + assert_eq!( + materialized.staff_lines_override, + Some(epiphany_core::StaffLineConfiguration { line_count: 1 }) + ); + assert!(!materialized.visible); + assert!(check_invariants(&result.score).is_empty()); + + // A tombstoned target is a no-op: mint an empty instance, delete it, then + // aim a layout write at it. + let fresh = StaffInstanceId::new(ReplicaId(67), 1); + let envelopes = chain( + 67, + 10, + None, + vec![ + OperationKind::CreateStaffInstance(CreateStaffInstanceOp { + region, + instance: valuegen::staff_instance(fresh, staff), + }), + OperationKind::DeleteStaffInstance(DeleteStaffInstanceOp { + staff_instance: fresh, + }), + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: fresh, + instrument_override: None, + staff_lines_override: None, + visible: false, + }), + ], + ); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + assert_eq!( + effect_for(&result, envelopes[2].id), + &OperationEffect::NoOp { + reason: NoOpReason::TargetTombstoned, + }, + ); +} + +/// The full value-restoring undo sweep: one transaction overwrites every LWW +/// family (and mints an event), and its undo restores each family to the base +/// state (operation_catalog §UndoTransaction "Value restoration"). +#[test] +fn undo_restores_overwritten_values_across_every_family() { + let base = epiphany_core::generators::valid_score(306); + let region = base.canvas.regions[0].id; + let (staff_instance, target_voice) = target(&base); + let base_instance = base + .staff_instances() + .find(|(_, si)| si.id == staff_instance) + .expect("fixture instance") + .1 + .clone(); + let base_event_id = base_instance.voices[0].events[0]; + let base_event = base.events.get(base_event_id).expect("base event").clone(); + let mut pitches = Vec::new(); + base_event.collect_identified_pitches(&mut pitches); + let base_pitch = pitches[0].id; + + // A same-placement replacement value with different pitch content. + let mut replacement = base_event.clone(); + if let Event::Pitched(pe) = &mut replacement { + pe.pitches[0].pitch = valuegen::pitch_value_nth(5); + } + let ts = valuegen::time_signature(TimeSignatureId::new(ReplicaId(70), 1), 4); + let segment = valuegen::tempo_segment(region, MusicalPosition::origin(), 120.0); + let inserted_event = EventId::new(ReplicaId(70), 100); + let inserted_pitch = PitchId::new(ReplicaId(70), 101); + + let tx = TransactionId::from_raw(70); + let mut kinds = vec![ + OperationKind::DeclareTransaction(TransactionDescriptor { + id: tx, + label: String::from("overwrite everything"), + category: Some(TransactionCategory::Structural), + }), + OperationKind::ModifyEvent(ModifyEventOp { + event: replacement.clone(), + }), + OperationKind::RespellPitch(RespellPitchOp { + pitch: base_pitch, + spelling: valuegen::spelling(3), + }), + OperationKind::SetMetricGrid(SetMetricGridOp { + region, + grid: Some(valuegen::metric_grid()), + }), + OperationKind::SetUserSystemBreak(SetUserSystemBreakOp { + region, + anchor: valuegen::region_start_anchor( + region, + MusicalPosition(RationalTime::from_int(8)), + ), + present: true, + }), + set_meter(region, 0, Some(ts.clone())), + set_tempo(None, region, 0, Some(segment)), + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance, + instrument_override: None, + staff_lines_override: None, + visible: false, + }), + OperationKind::SetMetadata(epiphany_ops::SetMetadataOp { + metadata: valuegen::score_metadata(7), + }), + ]; + kinds.push(OperationKind::InsertEvent(InsertEventOp { + staff_instance, + event: valuegen::insert_event_value( + inserted_event, + target_voice, + MusicalPosition(RationalTime::from_int(100)), + MusicalDuration::whole(), + &[inserted_pitch], + ), + })); + let n = kinds.len() as u64; + let mut envelopes = chain(70, 10, Some(tx), kinds); + let undo = envelope( + 70, + n, + 10 + n as i64, + seen(70, n - 1), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::StrictInverse, + }), + ); + envelopes.push(undo.clone()); + + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let result = set.reduce_onto(&base); + + // Effect: the tombstone repairs only (the inserted event + pitch, and the + // transaction-minted time signature); restorations are not repairs. + match effect_for(&result, undo.id) { + OperationEffect::AppliedWithRepair { repairs } => { + assert!(repairs + .iter() + .all(|r| matches!(r.kind, RepairKind::CascadeDeleted))); + let targets: Vec = repairs.iter().map(|r| r.target).collect(); + assert!(targets.contains(&TypedObjectId::Event(inserted_event))); + assert!(targets.contains(&TypedObjectId::TimeSignature(ts.id))); + } + other => panic!("expected AppliedWithRepair, got {other:?}"), + } + assert!(result.state.conflicts.is_empty()); + + // Every overwritten family is back at its base value. + assert_eq!( + result.score.events.get(base_event_id), + Some(&base_event), + "the modified event's base value is restored" + ); + assert_eq!(result.state.spellings.get(&base_pitch), None); + assert!(result.score.spelling_attachments.is_empty()); + let content = result.score.canvas.regions[0] + .content + .staff_based() + .expect("fixture is staff based"); + assert_eq!(content.default_metric_grid, None); + assert!(content.user_system_breaks.is_empty()); + assert!(result.state.breaks.is_empty()); + assert!(result.score.tempo_map.segments.is_empty()); + assert!(!result.score.time_signatures.iter().any(|t| t.id == ts.id)); + let restored_instance = result + .score + .staff_instances() + .find(|(_, si)| si.id == staff_instance) + .expect("instance survives") + .1 + .clone(); + assert_eq!( + ( + restored_instance.instrument_override, + restored_instance.staff_lines_override.clone(), + restored_instance.visible + ), + ( + base_instance.instrument_override, + base_instance.staff_lines_override.clone(), + base_instance.visible + ) + ); + assert_eq!(result.score.metadata, base.metadata); + assert!(!result.score.events.contains(inserted_event)); + assert!(check_invariants(&result.score).is_empty()); +} + +/// Replaced (rather than first-written) keys restore the *pre-transaction* +/// writes, not absence. +#[test] +fn undo_restores_the_pre_transaction_writes_for_replaced_keys() { + let base = epiphany_core::generators::valid_score(307); + let region = base.canvas.regions[0].id; + let (staff_instance, _) = target(&base); + let ts_pre = valuegen::time_signature(TimeSignatureId::new(ReplicaId(71), 1), 4); + let ts_tx = valuegen::time_signature(TimeSignatureId::new(ReplicaId(71), 2), 3); + let seg_pre = valuegen::tempo_segment(region, MusicalPosition::origin(), 120.0); + let seg_tx = valuegen::tempo_segment(region, MusicalPosition::origin(), 90.0); + let tx = TransactionId::from_raw(71); + + let kinds = vec![ + // Pre-transaction writers. + set_meter(region, 0, Some(ts_pre.clone())), + set_tempo(None, region, 0, Some(seg_pre.clone())), + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance, + instrument_override: None, + staff_lines_override: None, + visible: false, + }), + // The transaction replaces all three keys. + OperationKind::DeclareTransaction(TransactionDescriptor { + id: tx, + label: String::from("replace"), + category: None, + }), + set_meter(region, 0, Some(ts_tx.clone())), + set_tempo(None, region, 0, Some(seg_tx)), + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance, + instrument_override: None, + staff_lines_override: None, + visible: true, + }), + ]; + let mut envelopes: Vec = kinds + .into_iter() + .enumerate() + .map(|(index, kind)| { + let counter = index as u64; + let ctx = if counter == 0 { + CausalContext::new() + } else { + seen(71, counter - 1) + }; + let tx_of = (counter >= 3).then_some(tx); + envelope(71, counter, 10 + counter as i64, ctx, tx_of, prim(kind)) + }) + .collect(); + let undo = envelope( + 71, + 7, + 20, + seen(71, 6), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::StrictInverse, + }), + ); + envelopes.push(undo.clone()); + + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let result = set.reduce_onto(&base); + + assert!(result.state.conflicts.is_empty()); + let grid = result.score.canvas.regions[0] + .content + .staff_based() + .expect("fixture is staff based") + .default_metric_grid + .as_ref() + .expect("the pre-transaction meter survives"); + assert_eq!(grid.meter_sequence.len(), 1); + assert_eq!(grid.meter_sequence[0].time_signature, ts_pre.id); + // The transaction-minted signature is tombstoned and gone; the + // pre-transaction one survives. + assert!(!result + .score + .time_signatures + .iter() + .any(|t| t.id == ts_tx.id)); + assert!(result + .score + .time_signatures + .iter() + .any(|t| t.id == ts_pre.id)); + assert_eq!(result.score.tempo_map.segments, vec![seg_pre]); + let instance = result + .score + .staff_instances() + .find(|(_, si)| si.id == staff_instance) + .expect("instance survives") + .1 + .clone(); + assert!( + !instance.visible, + "the pre-transaction layout write returns" + ); + assert!(check_invariants(&result.score).is_empty()); +} + +/// A mixed mint + overwrite transaction: both compensation parts compose, and +/// `StrictInverse` refuses the whole undo when *either* part fails while +/// `BestEffort` compensates what it cleanly can. +#[test] +fn mixed_transaction_undo_composes_and_conflicts_by_policy() { + let base = epiphany_core::generators::valid_score(308); + let (staff_instance, target_voice) = target(&base); + let base_instance = base + .staff_instances() + .find(|(_, si)| si.id == staff_instance) + .expect("fixture instance") + .1 + .clone(); + let base_pitch = { + let event = base.events.get(base_instance.voices[0].events[0]).unwrap(); + let mut pitches = Vec::new(); + event.collect_identified_pitches(&mut pitches); + pitches[0].id + }; + let inserted_event = EventId::new(ReplicaId(72), 100); + let tx = TransactionId::from_raw(72); + let tx_ops = |replica: u64| { + chain( + replica, + 10, + Some(tx), + vec![ + OperationKind::DeclareTransaction(TransactionDescriptor { + id: tx, + label: String::from("mixed"), + category: None, + }), + OperationKind::InsertEvent(InsertEventOp { + staff_instance, + event: valuegen::insert_event_value( + EventId::new(ReplicaId(replica), 100), + target_voice, + MusicalPosition(RationalTime::from_int(100)), + MusicalDuration::whole(), + &[PitchId::new(ReplicaId(replica), 101)], + ), + }), + OperationKind::RespellPitch(RespellPitchOp { + pitch: base_pitch, + spelling: valuegen::spelling(2), + }), + ], + ) + }; + + // (A) A superseding respell after the transaction: StrictInverse refuses + // the whole undo — the minted event is NOT tombstoned either. + let mut envelopes = tx_ops(72); + envelopes.push(envelope( + 72, + 3, + 20, + seen(72, 2), + None, + prim(OperationKind::RespellPitch(RespellPitchOp { + pitch: base_pitch, + spelling: valuegen::spelling(4), + })), + )); + let strict = envelope( + 72, + 4, + 30, + seen(72, 3), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::StrictInverse, + }), + ); + envelopes.push(strict.clone()); + let mut set = OperationSet::new(); + set.accept_all(envelopes.clone()); + let result = set.reduce_onto(&base); + assert!(matches!( + effect_for(&result, strict.id), + OperationEffect::Conflicted { .. } + )); + assert!( + result.score.events.contains(inserted_event), + "a refused strict undo tombstones nothing" + ); + assert_eq!( + result.state.spellings.get(&base_pitch), + Some(&valuegen::spelling(4)) + ); + assert!(check_invariants(&result.score).is_empty()); + + // (B) The same set under BestEffort: the mint is tombstoned, the + // superseded spelling is skipped. + let best = envelope( + 72, + 5, + 40, + seen(72, 4), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::BestEffort, + }), + ); + envelopes.push(best.clone()); + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let result = set.reduce_onto(&base); + assert!(matches!( + effect_for(&result, best.id), + OperationEffect::AppliedWithRepair { .. } + )); + assert!(!result.score.events.contains(inserted_event)); + assert_eq!( + result.state.spellings.get(&base_pitch), + Some(&valuegen::spelling(4)), + "the superseding write stands under BestEffort" + ); + assert!(check_invariants(&result.score).is_empty()); +} + +/// Undoing a staff mint refuses while a live (non-member) instance still +/// references the staff (operation_catalog §CreateStaff undo semantics), and +/// `BestEffort` keeps the staff alive rather than stranding the instance. +#[test] +fn undo_of_a_staff_mint_refuses_while_an_instance_references_it() { + let base = epiphany_core::generators::valid_score(309); + let region = base.canvas.regions[0].id; + let instrument = base.instruments[0].id; + let staff_id = StaffId::new(ReplicaId(73), 1); + let instance_id = StaffInstanceId::new(ReplicaId(73), 2); + let tx = TransactionId::from_raw(73); + let mut envelopes = chain( + 73, + 10, + Some(tx), + vec![ + OperationKind::DeclareTransaction(TransactionDescriptor { + id: tx, + label: String::from("staff mint"), + category: None, + }), + OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff(staff_id, instrument), + }), + ], + ); + // A non-member instance referencing the minted staff. + let mut instance_env = envelope( + 73, + 2, + 20, + seen(73, 1), + None, + prim(OperationKind::CreateStaffInstance(CreateStaffInstanceOp { + region, + instance: valuegen::staff_instance(instance_id, staff_id), + })), + ); + instance_env.transaction = None; + envelopes.push(instance_env); + let strict = envelope( + 73, + 3, + 30, + seen(73, 2), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::StrictInverse, + }), + ); + let best = envelope( + 73, + 4, + 40, + seen(73, 3), + None, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: tx, + policy: UndoPolicy::BestEffort, + }), + ); + envelopes.push(strict.clone()); + envelopes.push(best.clone()); + + let mut set = OperationSet::new(); + set.accept_all(envelopes); + let result = set.reduce_onto(&base); + + assert!(matches!( + effect_for(&result, strict.id), + OperationEffect::Conflicted { .. } + )); + // BestEffort skips the stranding tombstone: nothing left to compensate, + // but the undo itself applies cleanly with no repairs. + assert_eq!(effect_for(&result, best.id), &OperationEffect::Applied); + assert!(result.score.staves.iter().any(|s| s.id == staff_id)); + assert!(matches!( + result.state.objects.get(&TypedObjectId::Staff(staff_id)), + Some(epiphany_ops::ObjectState::Live) + )); + assert!(check_invariants(&result.score).is_empty()); +} diff --git a/crates/epiphany-render-svg/examples/render_fixture.rs b/crates/epiphany-render-svg/examples/render_fixture.rs index f328b9b..2d879ab 100644 --- a/crates/epiphany-render-svg/examples/render_fixture.rs +++ b/crates/epiphany-render-svg/examples/render_fixture.rs @@ -85,7 +85,10 @@ fn main() -> ExitCode { let config = SolverConfig::default(); let (report, tier) = match solver.as_str() { "stub" => (StubSolver.solve(&constrained, &config), StubSolver.tier()), - "real" => (Engraver.solve(&constrained, &config), Engraver.tier()), + "real" => ( + Engraver::default().solve(&constrained, &config), + Engraver::default().tier(), + ), other => return fail(&format!("unknown solver {other:?}; known: {SOLVERS}")), }; diff --git a/crates/epiphany-render-svg/tests/acceptance.rs b/crates/epiphany-render-svg/tests/acceptance.rs index f5ad078..b5b54f9 100644 --- a/crates/epiphany-render-svg/tests/acceptance.rs +++ b/crates/epiphany-render-svg/tests/acceptance.rs @@ -263,7 +263,7 @@ fn engrave_pipeline(score: &Score) -> (ConstrainedLayoutIR, RenderOutput) { use epiphany_engrave::Engraver; let constrained = to_constrained(&to_logical(score)); - let layout = Engraver + let layout = Engraver::default() .solve(&constrained, &SolverConfig::default()) .layout; let out = render(&layout, &RenderOptions::default()); @@ -285,7 +285,7 @@ fn engraver_output_is_golden_locked_well_formed_with_every_glyph_drawn() { for (fixture, score) in fixtures() { let constrained = to_constrained(&to_logical(&score)); - let report = Engraver.solve(&constrained, &SolverConfig::default()); + let report = Engraver::default().solve(&constrained, &SolverConfig::default()); assert_eq!( report.status, SolveStatus::Solved, diff --git a/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.snapshot.txt b/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.snapshot.txt index c082312..cca4ab2 100644 --- a/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.snapshot.txt +++ b/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.snapshot.txt @@ -2,12 +2,12 @@ fixture=ten_measure_single_staff solver=engrave glyph_count=51 path_count=51 fallback_rect_count=0 -stroke_count=91 -provenance_count=142 +stroke_count=96 +provenance_count=147 layer_count=1 hard_constraint_count=90 xml_well_formed=true -view_box=[-3.059857 -3.632 102.98304 11.024] +view_box=[5.4999995 -26.090391 83.99065 20.589813] class_counts: barline=10 clef=1 diff --git a/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.svg b/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.svg index e41a03b..e931b2f 100644 --- a/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.svg +++ b/crates/epiphany-render-svg/tests/golden/ten_measure_single_staff.engrave.svg @@ -1,150 +1,155 @@ - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.snapshot.txt b/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.snapshot.txt index ba9c1ea..613aa77 100644 --- a/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.snapshot.txt +++ b/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.snapshot.txt @@ -7,7 +7,7 @@ provenance_count=49 layer_count=1 hard_constraint_count=15 xml_well_formed=true -view_box=[-3.1598568 -3.632 31.588375 11.024] +view_box=[5.4999995 -38.57536 15.298422 33.074783] class_counts: barline=1 clef=3 diff --git a/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.svg b/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.svg index 7c71015..61663e7 100644 --- a/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.svg +++ b/crates/epiphany-render-svg/tests/golden/valid_score_rich.engrave.svg @@ -1,57 +1,57 @@ - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/crates/epiphany-testkit/src/generators.rs b/crates/epiphany-testkit/src/generators.rs index 235cf96..e8b4dff 100644 --- a/crates/epiphany-testkit/src/generators.rs +++ b/crates/epiphany-testkit/src/generators.rs @@ -33,17 +33,18 @@ use epiphany_ops::{ AnomalousReplicaSegment, AuthorId, CausalContext, ChangeRegionTimeModelOp, ConflictId, ConflictKind, ConflictKindRegistryId, ConflictRecord, ConflictRegistry, ConflictResolutionState, CreateCrossCuttingOp, CreateRegionOp, CreateStaffInstanceOp, - CreateVoiceOp, CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, DeleteIdentifiedPitchOp, - DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, ExtensionPreconditionId, FieldPath, - HybridLogicalClock, InsertEventOp, InsertIdentifiedPitchOp, IntegrityAnomaly, - IntegrityAnomalyKind, IntegrityAnomalyRegistryId, MaterializedState, ModifyCrossCuttingOp, - ModifyEventOp, ModifyIdentifiedPitchOp, NoOpReason, ObjectKind, ObjectState, OperationEffect, - OperationEnvelope, OperationKind, OperationKindRegistryId, OperationPayload, OperationSet, - OperationStamp, PendingReason, PositionRemapping, PreconditionFailureReason, - PreconditionFailureRegistryId, ReanchorReason, ReanchorReasonRegistryId, ReanchorResult, - RepairKind, RepairKindRegistryId, RepairRecord, ReplicaAnomalyReason, ReplicaAnomalyRegistryId, - ResolutionAction, ResolutionRegistryId, ResolveConflictPayload, RespellPitchOp, - SerializedCanonicalInputs, SetMetadataOp, SetMetricGridOp, SetUserPageBreakOp, + CreateStaffOp, CreateVoiceOp, CrossCuttingValue, DeleteCrossCuttingOp, DeleteEventOp, + DeleteIdentifiedPitchOp, DeleteRegionOp, DeleteStaffInstanceOp, DeleteVoiceOp, + ExtensionPreconditionId, FieldPath, HybridLogicalClock, InsertEventOp, InsertIdentifiedPitchOp, + IntegrityAnomaly, IntegrityAnomalyKind, IntegrityAnomalyRegistryId, MaterializedState, + ModifyCrossCuttingOp, ModifyEventOp, ModifyIdentifiedPitchOp, NoOpReason, ObjectKind, + ObjectState, OperationEffect, OperationEnvelope, OperationKind, OperationKindRegistryId, + OperationPayload, OperationSet, OperationStamp, PendingReason, PositionRemapping, + PreconditionFailureReason, PreconditionFailureRegistryId, ReanchorReason, + ReanchorReasonRegistryId, ReanchorResult, RepairKind, RepairKindRegistryId, RepairRecord, + ReplicaAnomalyReason, ReplicaAnomalyRegistryId, ResolutionAction, ResolutionRegistryId, + ResolveConflictPayload, RespellPitchOp, SerializedCanonicalInputs, SetMetadataOp, + SetMetricGridOp, SetStaffLayoutOp, SetTempoSegmentOp, SetTimeSignatureOp, SetUserPageBreakOp, SetUserSystemBreakOp, TransactionCategory, TransactionDescriptor, TransposeOp, TupletCompensation, TupletCompensationKind, UndoPolicy, UndoTransactionPayload, }; @@ -409,7 +410,7 @@ pub fn conflict_registry(rng: &mut Rng) -> ConflictRegistry { /// A typed precondition failure (every core and registered variant). pub fn precondition_failure_reason(rng: &mut Rng) -> PreconditionFailureReason { - match rng.below(10) { + match rng.below(12) { 0 => PreconditionFailureReason::TargetMissing, 1 => PreconditionFailureReason::TargetTombstoned, 2 => PreconditionFailureReason::WrongRegionTimeModel, @@ -418,7 +419,9 @@ pub fn precondition_failure_reason(rng: &mut Rng) -> PreconditionFailureReason { 5 => PreconditionFailureReason::PositionOutsideRegion, 6 => PreconditionFailureReason::PitchSpaceMismatch, 7 => PreconditionFailureReason::VoiceMissing, - 8 => PreconditionFailureReason::ExtensionPrecondition(ExtensionPreconditionId( + 8 => PreconditionFailureReason::ContainerNotEmpty, + 9 => PreconditionFailureReason::TempoMapMalformed, + 10 => PreconditionFailureReason::ExtensionPrecondition(ExtensionPreconditionId( rng.next_u64() as u128, )), _ => PreconditionFailureReason::Registered(PreconditionFailureRegistryId( @@ -637,7 +640,7 @@ pub fn operation_payload(rng: &mut Rng, events: u64, pitches: u64) -> OperationP } _ => {} } - let kind = match rng.below(24) { + let kind = match rng.below(28) { 0 => { let pitches = if rng.boolean() { vec![obj_pitch(rng.below(pitches))] @@ -773,6 +776,52 @@ pub fn operation_payload(rng: &mut Rng, events: u64, pitches: u64) -> OperationP ), present: rng.boolean(), }), + // Phase-3 tranche: staff mint, meter/tempo overwrites, layout advisory + // over the shared id space. The signature's value derives from its id + // so an id re-carry is byte-identical (the idempotent mint branch); + // distinct ids give distinct values (the differing-value branch). + 23 => OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff( + StaffId::new(OBJ_REPLICA, rng.below(2)), + InstrumentId::new(OBJ_REPLICA, 0), + ), + }), + 24 => { + let region = RegionId::new(OBJ_REPLICA, rng.below(2)); + let signature = rng.below(2); + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: valuegen::region_start_anchor( + region, + MusicalPosition(RationalTime::from_int(rng.below(3) as i32 * 4)), + ), + time_signature: rng.boolean().then(|| { + valuegen::time_signature( + TimeSignatureId::new(OBJ_REPLICA, signature), + signature as u16 + 3, + ) + }), + }) + } + 25 => { + let region = RegionId::new(OBJ_REPLICA, rng.below(2)); + let at = MusicalPosition(RationalTime::from_int(rng.below(3) as i32 * 4)); + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: rng.boolean().then_some(region), + start: valuegen::region_start_anchor(region, at.clone()), + segment: rng.boolean().then(|| { + valuegen::tempo_segment(region, at, 60.0 + rng.below(4) as f64 * 30.0) + }), + }) + } + 26 => OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: StaffInstanceId::new(OBJ_REPLICA, rng.below(2)), + instrument_override: None, + staff_lines_override: rng + .boolean() + .then(epiphany_core::StaffLineConfiguration::default), + visible: rng.boolean(), + }), _ => OperationKind::Registered( OperationKindRegistryId(rng.next_u64() as u128), rng.byte_vec(0, 16), @@ -831,6 +880,19 @@ impl Session { /// predecessor) with a prior-history DVV (own history always seen; others /// sampled). fn author(&mut self, rng: &mut Rng, r: usize, payload: OperationPayload) { + self.author_tx(rng, r, None, payload); + } + + /// As [`Session::author`], additionally stamping the envelope as a member + /// of `tx`. Same-replica sequential authorship makes each member causally + /// cover its transaction descriptor (the descriptor-precedence rule). + fn author_tx( + &mut self, + rng: &mut Rng, + r: usize, + tx: Option, + payload: OperationPayload, + ) { let n_replicas = self.counters.len(); let replica = ReplicaId(r as u64 + 1); let c = self.counters[r]; @@ -875,7 +937,7 @@ impl Session { author: AuthorId(replica.0 as u128), stamp: OperationStamp::new(HybridLogicalClock::new(WallClockTime(l), logical), id), causal_context: ctx, - transaction: None, + transaction: tx, payload, }; debug_assert!(epiphany_ops::well_formed(&env).is_ok()); @@ -1122,13 +1184,83 @@ pub fn graph_edit_session( ); } + // Phase-3 tranche: the targeted tx-then-undo flow. One declared transaction + // overwrites LWW keys across the families (spelling, meter, tempo, staff + // layout) and is then undone, so the convergence gates genuinely exercise + // value-restoring undo (a randomly-generated undo almost always hits + // TargetMissing). The overwrite keys (position 400) are disjoint from the + // random-edit keys below, so the undo's verdict — restore vs. superseded — + // stays a pure function of this deterministic seed. + let region = base.canvas.regions[0].id; + let instrument = base.instruments[0].id; + let far = MusicalPosition(RationalTime::from_int(400)); + let undo_tx = TransactionId::new(OBJ_REPLICA, 7001); + session.author( + rng, + 0, + OperationPayload::Primitive(OperationKind::CreateStaff(CreateStaffOp { + staff: valuegen::staff(StaffId::new(OBJ_REPLICA, 7000), instrument), + })), + ); + session.author_tx( + rng, + 0, + Some(undo_tx), + OperationPayload::Primitive(OperationKind::DeclareTransaction(TransactionDescriptor { + id: undo_tx, + label: String::from("tx-then-undo flow"), + category: Some(TransactionCategory::Layout), + })), + ); + for kind in [ + OperationKind::RespellPitch(RespellPitchOp { + pitch: obj_pitch(0), + spelling: valuegen::spelling(6), + }), + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: valuegen::region_start_anchor(region, far.clone()), + time_signature: Some(valuegen::time_signature( + TimeSignatureId::new(OBJ_REPLICA, 7002), + 5, + )), + }), + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: None, + start: valuegen::region_start_anchor(region, far.clone()), + segment: Some(valuegen::tempo_segment(region, far.clone(), 132.0)), + }), + OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: targets[0].0, + instrument_override: None, + staff_lines_override: None, + visible: false, + }), + ] { + session.author_tx(rng, 0, Some(undo_tx), OperationPayload::Primitive(kind)); + } + let policy = if rng.boolean() { + UndoPolicy::StrictInverse + } else { + UndoPolicy::BestEffort + }; + session.author( + rng, + 0, + OperationPayload::UndoTransaction(UndoTransactionPayload { + target: undo_tx, + policy, + }), + ); + for _ in 0..80 { let r = rng.below(2) as usize; - // Mix the original edit kinds with the Group-1/2 (M2) ops so the real-Score - // gate exercises their *graph* materialization (reduce_onto + + // Mix the original edit kinds with the Group-1/2 (M2) ops — and the + // Phase-3 meter/tempo/layout overwrites — so the real-Score gate + // exercises their *graph* materialization (reduce_onto + // check_invariants), not just the bookkeeping projection. Each targets a - // live object minted by the phases above. - let kind = match rng.below(9) { + // live object minted by the phases above (or the base region). + let kind = match rng.below(12) { 0 => OperationKind::DeleteEvent(DeleteEventOp { event: obj_event(rng.below(total)), tuplet_compensation: TupletCompensation::NotInTuplet, @@ -1181,7 +1313,7 @@ pub fn graph_edit_session( 7 => OperationKind::DeleteCrossCutting(DeleteCrossCuttingOp { structure: TypedObjectId::Slur(SlurId::new(OBJ_REPLICA, rng.below(n_slurs))), }), - _ => { + 8 => { let k = rng.below(n_slurs); OperationKind::ModifyCrossCutting(ModifyCrossCuttingOp { // Re-point the slur's end to another even (replica-0) event. @@ -1192,6 +1324,44 @@ pub fn graph_edit_session( )), }) } + // Phase-3 tranche: meter / tempo / layout overwrites on the base + // region, keyed away from the tx-then-undo flow's key (400). The + // signature value derives from its id so an id re-carry is + // byte-identical (mint idempotence) while distinct ids differ. + 9 => { + let signature = rng.below(2); + OperationKind::SetTimeSignature(SetTimeSignatureOp { + region, + anchor: valuegen::region_start_anchor( + region, + MusicalPosition(RationalTime::from_int(rng.below(3) as i32 * 8 + 200)), + ), + time_signature: rng.boolean().then(|| { + valuegen::time_signature( + TimeSignatureId::new(OBJ_REPLICA, 7100 + signature), + signature as u16 + 3, + ) + }), + }) + } + 10 => { + let at = MusicalPosition(RationalTime::from_int(rng.below(3) as i32 * 8 + 200)); + OperationKind::SetTempoSegment(SetTempoSegmentOp { + region: rng.boolean().then_some(region), + start: valuegen::region_start_anchor(region, at.clone()), + segment: rng.boolean().then(|| { + valuegen::tempo_segment(region, at, 60.0 + rng.below(4) as f64 * 20.0) + }), + }) + } + _ => OperationKind::SetStaffLayout(SetStaffLayoutOp { + staff_instance: targets[rng.below(targets.len() as u64) as usize].0, + instrument_override: None, + staff_lines_override: rng + .boolean() + .then(epiphany_core::StaffLineConfiguration::default), + visible: rng.boolean(), + }), }; session.author(rng, r, OperationPayload::Primitive(kind)); } diff --git a/crates/epiphany-testkit/src/layout_stub.rs b/crates/epiphany-testkit/src/layout_stub.rs index 45bf6f6..c718a9b 100644 --- a/crates/epiphany-testkit/src/layout_stub.rs +++ b/crates/epiphany-testkit/src/layout_stub.rs @@ -372,6 +372,7 @@ pub fn gen_constrained_layout_ir(rng: &mut Rng) -> ConstrainedLayoutIR { .collect(), vertical_bands: vec![band], constraints: vec![], + break_origins: vec![], engraving_decisions: (0..decisions) .map(|_| gen_engraving_decision(rng)) .collect(), diff --git a/spec/PASS12_BATCH.md b/spec/PASS12_BATCH.md index ea7e65d..f49bb2f 100644 --- a/spec/PASS12_BATCH.md +++ b/spec/PASS12_BATCH.md @@ -57,7 +57,16 @@ code instead is the failure mode this batch exists to prevent. | ~~P12-E2~~ **RESOLVED (Binary Format 0.1.0 §8.2, `req:binfmt:condition-depth`)** | `epiphany-layout-ir` E | The spec places no bound on `BarrierCondition` recursion; the decoder needs one against adversarial bytes. `MAX_CONDITION_DEPTH = 64` implemented — the companion pins 64 as the normative bound (decoders MUST reject deeper; writers MUST NOT emit deeper). | ✅ done | | ~~P12-E3~~ **RESOLVED (Binary Format 0.1.0 §8.1, `req:binfmt:object-kind-open`)** | `epiphany-layout-ir` E | Barrier `ObjectKind` byte form = the `TypedObjectId` 16-bit discriminant (2 LE bytes) with open-value decode (unknown kinds never match, preserving append-only forward compat). Representation and open-value stance ratified. | ✅ done | | P12-E4 | `epiphany-editor-core` E | Barrier matching for operations with no graph target (`SetMetadata`, `DeclareTransaction` — implemented: score-wide barriers only) and for opaque `Registered` operations (implemented: fully conservative match) is unspecified. | G (Ch. 8) | -| P12-E5 | `epiphany-editor-core` E | The unsafe-edit tombstone MUST has no defined mechanism: the manifest-side form (drop declaration + preserved roots? an explicit tombstone record?), interaction with `required = true`, and whether crossing immediately deactivates the extension's remaining barriers (implemented: yes, recorded via `extensions_requiring_tombstone()` for the next bundle write). | G (Ch. 8) | +| P12-E5 | `epiphany-editor-core` E | The unsafe-edit tombstone MUST has no defined mechanism: the manifest-side form (drop declaration + preserved roots? an explicit tombstone record?), interaction with `required = true`, and whether crossing immediately deactivates the extension's remaining barriers (implemented: yes, recorded via `extensions_requiring_tombstone()` for the next bundle write). | G (Ch. 8) || P12-C5 | `epiphany-ops`/`epiphany-core` C/H | Mid-region meter changes: `SetTimeSignature` (catalog §Meter and Tempo Overwrites) reduces a second `MeterChange` into a region's grid cleanly, but the decomposition pre-pass honours only the first governing meter (P12-H4's single-meter simplification), so derived notation ignores the change until multi-meter decomposition lands. Reduction semantics pinned; the derived-annotation gap is H4's. | G / Pass 12 (decomposition) | +| P12-K8 | `epiphany-ops` K | Create score / canvas remain unavailable K1 slots: the document root and canvas are inline singletons (no `TypedObjectId::Canvas`; the root is never op-minted — genesis is `Score::empty` + bundle creation). Turning them into operations needs an addressable root/canvas object model. Decide: define one, or ratify genesis as deliberately outside the operation set. | G (graph model) | +| P12-K9 | `epiphany-ops` K | Differing-value re-creates (a live id re-carried with different content: `CreateStaff`, the carried `TimeSignature`, container creates) refuse with `TargetMissing`, which misnames the situation. Decide whether a dedicated `PreconditionFailureReason` (appended) is warranted. | G / Pass 12 (vocabulary) | +| P12-K10 | `epiphany-ops` K | Undo strand-blocks (StrictInverse refusing to tombstone a minted object still referenced by a live non-member, e.g. a staff with a surviving instance) reuse `ConflictKind::TransactionConflict`. Decide whether undo refusals deserve their own conflict kind. | G / Pass 12 (undo) | +| P12-K11 | `epiphany-ops` K | An undo's value restorations enter the write chains as ordinary writes by the undo op, so a second undo of the same transaction sees the first as a superseding writer (Conflicted/skip) while absence-restorations repeat idempotently — a documented asymmetry. Decide whether chain writes need distinguished undo provenance so repeated undo is uniformly idempotent. | G / Pass 12 (undo) | +| P12-I7 | `epiphany-engrave` I | Page geometry has no graph home: the spec names `Canvas.layout_defaults` ("paper size, margins") but defines no type, and adding a `Canvas` field is a schema-major change under the companion's frozen-layout rule. Casting-off therefore uses an engraver-side `PageGeometry` default (A4 at an 8mm staff: 105x148.5 ss, 7.5 ss margins, documented arithmetic). Define `CanvasLayoutDefaults` with the data-model schema-major; until then solvers MAY default. | G (graph model, schema-major) | +| P12-I8 | `epiphany-engrave` I | Break-constraint satisfaction predicate: implemented as "a `SystemBreakAt`/`PageBreakAt` is satisfied iff the final layout starts a system/page at that slot" (a region-first slot is trivially satisfied). Ch7/Ch9 never define satisfaction for break constraints; ratify the predicate. | G / Pass 12 (solver) | +| P12-I9 | `epiphany-layout-ir` I | Honouring a user break must attribute the decision to its override (`DecisionSource::UserOverride(id)`), but constraints carry no override identity; implemented via a `ConstrainedLayoutIR.break_origins` sidecar populated by `to_constrained`. Bless the sidecar or widen the normalized constraint record. | G / Pass 12 (solver) | +| P12-I10 | `epiphany-layout-ir` I | System-spanning strokes split at system boundaries need synthesized provenance for continuation segments; implemented as `SynthesisKind::Registered(SYSTEM_CONTINUATION_SYNTHESIS)` with a deterministic `(original, ordinal)` instance key. Add a first-class continuation synthesis kind or bless the registered id. | G / Pass 12 (provenance) | + ## Not yet open elsewhere @@ -65,7 +74,9 @@ Agent I (Track A) has contributed P12-I1..I6. Track B's Agent K has contributed P12-K1..K7; H has contributed P12-H1..H7 (H6/H7 from the 2026-07 spec-compliance audit follow-up, alongside K3/K4). The 2026-07 Push-3 wiring work added C1..C4 (re-anchoring), D1 (bundle operation index), and E1..E5 -(edit barriers). Agent J's Binary Format companion now exists +(edit barriers). The Phase-3 first tranche (casting-off + K1 schema-fill + +value-restoring undo, 2026-07-02) added C5, K8..K11, and I7..I10. +Agent J's Binary Format companion now exists (`spec/binary_format.tex`, v0.1.0): it ratified the P12-D1/E1/E2/E3 inputs (struck through above) and discharged the crates' provisional-codec notes (core P11-4, ops "provisional canonical encoding", bundle P11-D2/D4/D5). Its diff --git a/spec/binary_format.pdf b/spec/binary_format.pdf index cb415b60f2b906e829eb0b8d3c392ba6106b90a4..ba7c6f1173e256951abaf28e29c0cb3b554b6a48 100644 GIT binary patch delta 62115 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%0DcE|} z`G!mWyk{C>vYmEVyvLOJ564<{Pw|7f)xtzB;75H+0~hxNU*5SyiQE@Q?0&DbHR9EJ zEDNd9A}uX-+jL^bYyPEEGI=Zial*BhmA|e#-=*rf=Q6+8-eVm+G;p}N9vIl&V;t<_ zq?7eOC79K9xu-Ivo2<9|`3v@-2j9>_>pE!pscEMJ-}-1T4NTr)EV~;?lR+pD1V}7Q Q%*@=J@Dvnc3gYnp2Mrr00{{R3 delta 59855 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 diff --git a/spec/binary_format.tex b/spec/binary_format.tex index 0aec1d4..cfb90b0 100644 --- a/spec/binary_format.tex +++ b/spec/binary_format.tex @@ -235,7 +235,7 @@ {\Large\scshape\color{epiphanyslate}Binary Format}\\[6pt] {\large\itshape\color{epiphanyslate}A companion to the Core Specification}\\[14pt] {\color{epiphanygold}\rule{3in}{0.8pt}}\\[24pt] - {\normalsize\color{epiphanyink}Version 0.1.0 --- Phase 2 (canonical wire format: primitives through bundle physical layout + K0 payload framing)}\\[4pt] + {\normalsize\color{epiphanyink}Version 0.2.0 --- Phase 2/3 (canonical wire format: primitives through bundle physical layout + K0 and Phase-3-tranche payload framing)}\\[4pt] {\small\color{epiphanyslate}Normative for the byte layouts it defines} \vfill \end{titlepage} @@ -1287,7 +1287,7 @@ AcceptLoser, \tablenums{1} KeepWinner, \tablenums{2} Override \label{req:binfmt:kind-discriminants} The \texttt{OperationKind} wire discriminant is one byte, golden-locked to the table below. The vocabulary is \textbf{append-only}: new primitive kinds -take discriminants past \tablenums{23}; the assignments below never change. +take discriminants past \tablenums{27}; the assignments below never change. \end{requirement} Each row also pins the payload's byte layout; the field \emph{set and order} @@ -1385,6 +1385,25 @@ sequence sorted ascending by canonical bytes. \texttt{region} (16) \cat{} $\mathrm{lp}$(\texttt{TimeAnchor}) \cat{} \texttt{present} (bool, 1) & \sectionsc{Score Settings} \\ + \tablenums{24} & \texttt{CreateStaff} & + $\mathrm{lp}$(\texttt{Staff}) & + \sectionsc{CreateStaff} \\ + \tablenums{25} & \texttt{SetTimeSignature} & + \texttt{region} (16) \cat{} $\mathrm{lp}$(\texttt{TimeAnchor}) \cat{} + option tag (\tablenums{0}/\tablenums{1}) \cat{} + $\mathrm{lp}$(\texttt{TimeSignature}) if present & + \sectionsc{Meter and Tempo Overwrites} \\ + \tablenums{26} & \texttt{SetTempoSegment} & + option tag \cat{} \texttt{region} (16) if present \cat{} + $\mathrm{lp}$(\texttt{TimeAnchor}) \cat{} option tag \cat{} + $\mathrm{lp}$(\texttt{TempoSegment}) if present & + \sectionsc{Meter and Tempo Overwrites} \\ + \tablenums{27} & \texttt{SetStaffLayout} & + \texttt{staff\_instance} (16) \cat{} option tag \cat{} + \texttt{instrument\_override} (16) if present \cat{} option tag \cat{} + $\mathrm{lp}$(\texttt{StaffLineConfiguration}) if present \cat{} + \texttt{visible} (bool, 1) & + \sectionsc{SetStaffLayout} \\ \bottomrule \end{longtable} \endgroup @@ -1429,7 +1448,7 @@ assigned independently of Section~\ref{sec:ops:kinds}, with both encode and validating decode. One byte; only \texttt{Registered} carries a payload (its \texttt{OperationKindRegistryId}, 16 big-endian bytes, total 17). Unknown discriminants and wrong lengths are decode errors. Append-only past -\tablenums{23}. +\tablenums{27}. \end{requirement} \begingroup\small @@ -1450,15 +1469,19 @@ discriminants and wrong lengths are decode errors. Append-only past \tablenums{9} & \texttt{InsertRegion} & \tablenums{21} & \texttt{DeleteVoice} \\ \tablenums{10} & \texttt{DeleteRegion} & \tablenums{22} & \texttt{SetMetadata} \\ \tablenums{11} & \texttt{InsertStaffInstance} & \tablenums{23} & \texttt{SetMetricGrid} \\ + \tablenums{24} & \texttt{InsertStaff} & \tablenums{25} & \texttt{SetTimeSignature} \\ + \tablenums{26} & \texttt{SetTempoSegment} & \tablenums{27} & \texttt{SetStaffLayout} \\ \bottomrule \end{longtable} \endgroup -\textbf{Naming mapping.} The kind-to-tag projection renames two pairs: +\textbf{Naming mapping.} The kind-to-tag projection renames three pairs: \texttt{OperationKind::\allowbreak CreateRegion} projects to \texttt{OperationKindTag::\allowbreak InsertRegion}, and \texttt{OperationKind::\allowbreak CreateStaffInstance} projects to -\texttt{OperationKindTag::\allowbreak InsertStaffInstance}. The mismatch is +\texttt{OperationKindTag::\allowbreak InsertStaffInstance}, and +\texttt{OperationKind::\allowbreak CreateStaff} projects to +\texttt{OperationKindTag::\allowbreak InsertStaff}. The mismatch is intentional (the tag space predates the M2c naming) and is pinned here so barrier authors target the right tag. @@ -1529,7 +1552,8 @@ trailing bytes are decode errors. \tablenums{6} PitchSpaceMismatch; \tablenums{7} VoiceMissing; \tablenums{8} ExtensionPrecondition \cat{} id (16 BE); \tablenums{9} Registered \cat{} id (16 BE); - \tablenums{10} ContainerNotEmpty. \\ + \tablenums{10} ContainerNotEmpty; + \tablenums{11} TempoMapMalformed. \\ \texttt{RepairRecord} & (struct) \texttt{kind} (\texttt{RepairKind}) \cat{} \texttt{target} (\texttt{TypedObjectId}). \\ @@ -2519,7 +2543,20 @@ layouts of Section~\ref{sec:values:representative}. forms (P12-E1/E2/E3); pins the no-varint rule, the frozen-positional schema-evolution keystone, and the id-leads envelope property; \texttt{SnapshotId} derivation deferred (open question). \\ - \bottomrule + \today & Operation wire forms & 0.2.0 --- Phase-3 first tranche: appended + \texttt{OperationKind} wire discriminants \tablenums{24}--\tablenums{27} + (\texttt{CreateStaff}, \texttt{SetTimeSignature}, + \texttt{SetTempoSegment}, \texttt{SetStaffLayout}) with their payload + layouts, the matching \texttt{OperationKindTag} discriminants + \tablenums{24}--\tablenums{27} (kind-to-tag naming gains + \texttt{CreateStaff}~$\rightarrow$~\texttt{InsertStaff}), and + \texttt{PreconditionFailureReason} \tablenums{11} + (\texttt{TempoMapMalformed}) --- a schema-\emph{minor} evolution under this + document's own append-only rules (Chapter~\ref{ch:evolution}); no existing + assignment changed. Semantics: Operation Catalog 0.5.0 (\sectionsc{CreateStaff}, + \sectionsc{Meter and Tempo Overwrites}, \sectionsc{SetStaffLayout}, and the + value-restoring \sectionsc{UndoTransaction} revision). \\ +\bottomrule \end{longtable} \end{document} diff --git a/spec/core_spec.pdf b/spec/core_spec.pdf index 16e86352efc0322ec90935141ee9c69cba516d26..7894d782a7954becc371154cd5fd693ab5d8d7ed 100644 GIT binary patch delta 211671 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

&%MkUf0`S&EIqUNb#3P`)iz*D-7^&J zT4%}YswMd^WSJHuoS-k2;}WZzA4Yfg{r5xSUPEE@?5y2U!S;}wsE_y;HzrlY4fWc} zwRvXEKQBfsk+pc~e2)b`$RELztuTbsxce&*9CJnmFbl0zX%mZud@d$yw0bK!0i*#d z1#dblEw$izVV3O~ma+OW6xst=KN?&1OP$GlpeidQEk8rE`YE-65S*e(AB@D`pXUu? z)09Oda@nLOn^weET*Ug83h`!Nsc`DgnyzWSmVcVg zsx5y$bGOBs?oZ<`$n2MT64{spAiGw~{Nz1P*lTcG$iS1f+tR)~xs!4tJpSTUr`@*$ zp>ID6=KWbm=n98D7J$AAX_&nr)=28QmUv8T8j|L3plu)KvKchjPgO~hf2PX*1I=@U zs~8PHR|ornQqhpQZh4qaoJtdG(20$rSMFt7X{q}!h?ExFfc(@JuvldP_ETJHfk`u) zW2~}WMWS?DHYAdt#3>V~;C=Wig8jTG7PApkkc8!*pfikPLtnmm{DxoP?AZRtdl}iG z#_9YdA92G)BU8(z)r}rzaoJcXPEvgCKoZ~*)GmU`&&a@Y#BeIYV;$B5aZ^NxVQ_0w zxIZ8A(O&I}1PK^|Ux!S4uPdh7>qy4sGr3?N>w1nYaSVl(Gytqa*~_Hg5AH8n;@#Wm zkb19AXC-A!3I{S@vya%c)k*(Ui>Mr{PXn!!fJ1oF%wCn0!zlgKgt_`Uu%U~MW^0HK zwkMUm&H2Z87oJ~qx(cLF?LoJciIqfEW(C2r*75C-0W#pLV!Y(S2S17#ng&q4TJaGk zA4y$2Niy^})^Aw6myGla7Yztn#V)y*0%G)<1DzGz-UOu!Y8=kxI^!oF^B5^W6+6$O zlYa6Jg=00Ct8p8Efx;-i_LAR9syW#4d*mp4EY`N#S7+zyc>Q&+8|wy_se^LDYp5H` z)%rUU5FcM#ykQUibBMNCX-Iz>AZ6(5WlozERS}d`yN~YA7XR1(1@uo5XfB7sg|AOn z$}iV-nT~*pDG3H^7xzlUaGoJP+)|3?f#I2pH{i4J2}G_uWbqg#vjZ12WZPOQ-yXW!p+baRdRyNw zqdsxAcq9C0Q-gmjSG9kx0LO?A%4{tZW-Js<)e%aKcx#b9AO>se5nSS(@h5g>rE}bgHJ>PrZ`GOz_DU5aCC@E%{ z;A8-1CXWBtze>j(wEpfsQ9DIQop=E;#}M>0_V03GY8k@g@twq57IbwQ-H}JtD3lmq z@NI10x@R-ptfwebAEHwAp;3IieJ22i{~p{W`8XMP=CCJg4eFVP{IJ@(oxzt!`MQJ4 z4ulzKvC7t;_V}Qt`CugkY^^2@y|eID>=k6ny0Mbl&+K%=@_z`!`h!tl-5xPOPJa;4 zE^Nc;x$^Tn(9xog+Y|EQ;-VWu?0}(bRsvq{7j9qZADD}*ii3<)!=mZC&~Rda_~M;* zLqGtd^lFw}@mxF(M|p|(%hU&~n-$LObT4O^9=T?0aobW@g{AI*{A7x~EGyKUV(vRn zZ$%~AzsW3V;C~YKD0e!N%V4L&Obe};A=2b1SUHPo}^dQK9*#&>cfk}W{ z;zb9tMUQ#EZQR!EVdCBChu*4zlNdVZuc4FW6M<@kLKnB;h7~W!JSuw7-H;6vh-(_; z-JT6s(`aRYVH@=UFf`tJrOaD7NsNe@_s6eJ)hP|HeYs5}yoTFsHNsu<`ktGru9hKb z{E0KoYo!9+{GWRLFNE8a7IcPm54t=Xb?Zfus~)5>uyKi+3WuI&PtgJRwKjzee9dup z?uXmstJXVR;39LpBp{+hXZ+g5PH)dLYN}yCT!WrDC;Hz273bI6h1&;u`&FPb{5@u_ z?>Z?;)C6s~;ecn{zwsIC7j1v&o4UGzvd{3F9)+m{0_`-FALJWv8OCR^v|JHqDT5gB zHE}hFht+Qt83!rQ17X$Trf&xT-MC-vTabUITfWIi9ngLqxI>2BDMOA0*khQVX*1en zDM}!GG=-A_1SyUt3XH~F{hpa*U?AmH?(E7q)NLyi2}0&p(#zx9BQe5QoGhyETbdah zRL=#5#rbZnxf8|jSfEqzq-=US9-OIpo-P=094GR}-^hX>F$)=8n2+<@DM#vQ%0Qpo zmDuq%ue#J=ET$)ESr<tN2Z=ry=w@y2F!K9fQZoG8yopK7iw$Uh|OwMVW`5( zq~zedz}$%#`A8dm>tNkj=|p|+rL!GflS$X2y`6EV1*GaQyA%`f;or<1$t2tPb|D3? zGJ4a-)!teCHU7tkEQYqiwB0h66nPdr7|nD6@N)~T`5ToY5;-Y>M4a3|k~{0gb$vce z0lPtAE^~$1vdoim)h;%l22-V|Xm_aX)vi_$S+~IiX6piG$;MSd!?sVRaMS8I2*2OA+HDs1e zv%PY^Ar(7sBZp9XIlSg_QA>&Bb!;pEL>nhOiMTwBZsoDIk?3#Th3mBi@VR>9W`Sb9 zQbrvGGt#rk$W@^mP;O~-n_O&@qoO?xRVdU|XUaaBlJV8^upx!1WE@)?7h3cz)`#tx zH|PWMt6IGnauo0*qTC4-%hpt7q%+c|56h6lx>UMP)eahPE9bH`;4qjH))u@0!E#O* zVTC-EqS>#xn-1v9l_s|`gauY0V_)rwg*gKbuMJ5mj9Ejk{*{aw6Ng&r2Ti*#0A7%hC-Vo>9`NIw!bul9w z#yk2xZ(Q*3QGF2I#mW~y#q82up5*jejaUQh4#GRXv<}%2CD!yBEX>+IDZxk0BAzg) zoP8d~6dTu@x-wLpwi_#~N|qIJ=m*PaHC||nJEr#xAPUSKkGZ0+9h*}F=o%)BQ7(f1MnaXwnDSmM;6ld=+*?1<|S&+-&Ix#tG>oCZtn{GCh zod_Q!>HJN1c^84Bdy6huZ0AU@D4dFbye%)JGlpSF0Sh@zz&#irTf2#2B4w|vto9p) zGtCjR=W_6it$CK>oO}`ngkm%tWT_2ZJ`VErT_TZqT)7sMD0`%0(uX7vW`$5@$_Wf2 z_z$s?Dz-dFt6|C=5955mCPg0^Fwf?WFwtc)$qpqcs;(S z#Y@Kc5{mbiW5qHP+o~@*YleMSZM#|_CA7CgD6K5-U~z+zz}UYM=(9xf5ynZAQVJI+ zlS|{R@D6Yw40cQ#K$Zl&GVN7q$*s03=;{hZY2rFn2#RM6&?WOxzc$`Lz!#OFY1WnA zuxUAXH!1=HRkDnS5A-`T%9aVrz``_|>NcQq_QSnd5m&GroAm3>K8fMDdqGnj*{zP(JVP;&~2 z@H!s@p*R*0f-GZ1FmQ;L-%OZas|X>WI6L`<#evJMhwxP3oG=h0b)XEi5TnYf+d8Ae zvV-&|+CoLmmP}P73u0Zu6*|HXjt%X$5|Ix|42BW4O^rcMzuILTe$P6*I9Qy)iTQG~ zYcj-CAZXdn0+vKt0(5P?c*X1R^i)6=9g>^T-#llUfyMo1Csbzt(R#J2*#~x*A&|pI zC)jd|Bk)Uq1mnrEq-+n&(3|9>Xr5=BEAKqED*k-SfVh+VTR!c)7{Sq>=w z@;&c9Xl78T2s-_#i*^|33roveNgFG7r?exQCoJ#)RA$;=dIqTnC4$cq0 zsf(WB3gE8J!DLg|#su*SUqx5Te8*tmT*e^{MYc2;Ds=x5F*H8QUWnYK9s`Ll3ON~G zhE4F>fsTW0sd+IBErt@CkvUhy!3Fca^Xm2q)Cn;yD`$kXlhjyolkw&zZF~X;hn&L< zeAGGn-%~8*f;O9RI!OVuuL6!fKl+-5gr?133qZWhx#%fNWETw*^=mvpHeuQEo6o|E z6!=%T7d!$J#7LO`w84d0*pB{%h|}3XAUi8{uQc61uXI!g`^?pT98;I%e{iOvEd1hG zPElM*gKkJeI^tQp2orcNuJb{O`7DlUiaZyR7mfL4 z@c=hmgXHa#*S4bRGm7G%OHrRi%1WlX1q;9;ykpifOm@M_)Zk$ zfu#dox0Wf>E=t9va85rhH<9weJ_lg>6M^y{o_@+<$K;AxaAlSxo;$B`*&%<4m&CAO zaZZCPv6z{w3w_a{kwLqIj=U67_y)4g0GeD*-cLC1;;A+clN5|~QwZ#CK3J<7%jOzg4kge$mzQ` zmQxns+s9919RJf{p8Sti^GWa3f3!A!XxZk#wSc&z-A`j4M~D19cvemS3m7?#H?S?V zoL49Ry`z}d0mjZ2w@gAA<(+B528>#vOm8VQMd$6WOg%qfn&ohoaog4U+uGx;)MSPj zWpu55k++LB%}g4tTmY$UtO|6ZlPIpB>aW|Fu+l1lQJyx`G#! zPUc_t!xt%4=qbXrdD{;KLt7{H>mQgp-JCbW1TDpIAZ=n6fMABaYWE{{`oK>4x*klA zukY2jhS$70)xZB;!|QmLgK-YC@{{N8qKbFn1IK-eO$O2*jP{19^W3rN38eM3^diHxmLn zd_*ftO%x_R!1EnDs(azW3z&C*mqXCZ=~q|7pxrM|kq6|{DX>QtmOO;(YJr*)gEfJg zq+<|UKmnK&@)W)6OGc->47D6yV+yZd*%;%jMbjk)okM`IEKBGgld^%(diZu^3oTN6 zwkEa|Xcofd5C%q7&px{9nB$0TpIWD*j3YWODv35!0A&xPh4D1GFNZoM?!tNXtMCtv zz5u7*@gEv~Nk24Hr@^U7a|xYxJ`83C`VCBoWp%48@8y?D&v@L|K`irX<+z9co(_pA z6oeAl*fsq_g|BiCZnk%`m8snGSZwxeL4|Aeo|ECaGu){g*o@711L3^pxnI6v>cX$i zd;}zSo+_(Vbk?36)|opKbjoYczpsFxh!9?ogL}XKI+NW?hnD%6SFkMb41)BQmzwi=$BW^!loPqFx0hC(_9L z3i)!xp$SuXi?sDzLu3R>k(3>F3f!IwR+sU2P>-Ic?T)ESDF|Zb&5na0@z*0u4|P8& zd^9q1c7b>%sjqMhK{`VFt#(Fl<|v=`n_Hu(S!&}8%g|u2gCU=j`ab76JBA^E=vCj9 zLyA1rWr+FRtzPgZ73DZvOaceTYawj_a%Qf(4>IiVr23g2Lj_W1^TACp)c;@*@wm3k zsnM>sOyvGfNup%fyA2AKS$B){EHKcvrkIDu2}Q?VmKbi|6>e2bf4i3~(zd7DOS5WE z^1vDb{?viTAf+q8n|zJ9aP=M_cVA`hFg;A~LX@J4{d1Y!npeYa=KWOI0is;%6Wa{& zh9I$PUlc7o-$Gb4Ps1CsSi0qSFQB~T@r8!oui-giSqRZOGYtww-9mUYg^%V{&H{SO zF7n|$og(?3EM2kRWG3B2eR}4h!G3C<*Qew5?8kXW`w+gHW~ROp(ZdF4CN=4>`Pvr7 z3w3V5Q20>=Jo+@8*UUC{urv|&%qN1=1rMBs54?Bb3d110FTaL5MTt?luJ{y(`5%y& zPyPO$p6e$3B8`_u00b0ZN)zAGKOQ=psi{|LWkLrK={v1#?CuBUb`SO1ofLz{24{3u z646b14`l--R08gfWnBO()0yd9R*ns)1sQ3w$jBalpI}AKE@G3gndj7-gml3$&D31e zKR>wbv(D}1ywH{($cAx!vQ7rCRuV_zGafSrT`OJuq=KoDAEpoV3>3W2r*t$H`- z^!hM^=p$evJTRKYTT#ZK4hn!UV#MJ=%FU7gbL5O@V0OJXgn+n5e7XfrAFpESiosvF zhFvpGwck|j-v2EAy`pnm`aQw*9NYNNn;*;yw zH8E7(nWuuEcI>dR!@UKqqDpc(cyS_o0Y*I7O&1qwGAAM0X>p3Q?2#h*kz&cArX&4c z87b0JA`Qj|SNNy3J?E<5>?K<6C*^K~s&A$Jq$=r2?1dOM;f8P057Z z^HqoH3UX%+mgfOcik83&y-FVk?0+0L$}H;FolX9yccc+=1Puh9NP3a%TFN9K4FwsA zZ@k|OW``FC_y79s#5`;I$*0ca1Dxh}ySIDbDNI1#kjisIkUl932AF9ghuG19h^PhZ zR;q$A(k9|UGe(>or~JT5|DboTC#g&Bq@RLSo`n;(kDpT(8eqhY<8IW+!x#F7CAGEo zkD>i;rL1P8;k`nYTEGGVDB*7sKlDb*7zv`ZX>CIy)n@9;@zHAXW=4g2Y8m75HYq_? zWfMT0%}2M^goKY0=tIJwQx3wWZ8qte6ULv+n*$n-xMOE zgJqUlqb8!}mdlz)-POwY%T)0$R#Q%E(d7WbCr(Kz`7(5wT~N~naM1ux+*}{qb&v`x zdF=sf7}`Hu(3|J)keF*4l4kk%8c<*kY%{7PNtMbh(hT0HR7n5!-V5=R%E%9+O~)w8 z8uFkb7h|7DP<(c(VH^-OMc-`Zr4@=X2#iJ1U8 zoFDfCx(i92$u<=Cy_GgP>1OVd{c?p4s z1%GpHH%QitA7fFwQ?4CSs98vKj=P+n=MF7phd%P`Hcupt#~9Dv{_uklq)ev@f`CsJ ziBkieR-rDQuq14oF#|!KHS@l-4WB^teBkH8q5Awc5#<75W@kyUtpmpa%s~PVf_rZm z+XW+Bouy6n!S5f&?!=J9BNZvSsLjAH>q2xe^H#-Egy&0y$7uTM91_j*x49>MMI61R zJifS{ohVs;(tUbc?x@`ef6?l^*&N)r+%(&KPk%;^_sqvU!+W~Wmd)t#(d~Fsr?iTd zY~J6w#2LaxI95RUzPf(`_DF&pg)FHHq5qxzO z1CMo_X`m~pGxOCI!^$k`S4`F?F{jEdz0nZVdW&X&(H6%*%v`qw?c)Yqub`{36#l-aoe^3S}@qujkB>R~z2M(DL-174d-~3yF@V*Cy z+!arI(V6|GX*GNW_`dFqJUVQJMzIwsda4M~OKqr-Ll<&xOVuLSB}=hW+yZ?QmVL)^ z>oXkyz#dCzYnO`x;|3d&xpM3XF(}7!)BnJ zf6gN5hg-cjv$m{?`-F|&xa%qz*(^Zze%Zbm7E=5x^wB&A%ziwb6u|>04&LIn7b|?L zC#z|i7w@(brL|L8y_T0+w1al7@MxsrshJwJut-ZQS-}#TYo<$K|E8&I+=GY}^9~_} zuXrDqk7ucfiCDCfcq7FpxfIMXUnQB$4`sssJ?36ZL?_R6<+o@q;;w~yel38j8dq8G ztG_%tOx|?`@P0E@26~ukA=IGNuMb)ZGhWblOMwMVU}=>M4)K-Csl%XTD9xE7#};4q zXVds~oX$6-vHr2O%$eY$kBs3o)-^q!SaNg|uJR`N{Fl-QIGRrX{$qG48vWAzUc}GD z28M-0-dwj2rT)trv`NPxF^O0vI2_z*RQJ~ykK8N`AX)#Q0Y+bOwg(CHx5fqa{wvo7 zZm4yd0G4NHiqHl5MLc3t7^6$PwS*x?7{)i~4irMVsP?qHrWk?2D`K00l#)&)Z?{7u zt8SLcnuu^<%$zdh>jGyMeH*_HS-uO$?s@_kq#R6cRG%GMs7S(GP@37Q5FKQa-NI8P z^m(Ci*U3|u9juM+b23an!I>s0#B;ls?b5&rfUW#2Z`SbUPjCOkSkST*6Hi2eJMf_A zU8BK3Ww*5nc@~)PKK~2w$LYh~%*yIwa`j8U&TT%GY3JD{Rs*Jx2uzTg4hf;La}S5Q zeBl#5sqygzEQbvkkQk=EB%VM`eZ%;o*A*AM5?-oLN!(JOFaD;hm&k~u8eGEv8v4jXT3!Z z3NFcCWt2jLdy!<8DE^Dk!Bb2~xBSTT*k7}bI8~<$qE&6yj*+DzRV_z0QUBjz+!6B*8d1pG z3p>_>v8P3EN^6Z_MyMA}K-tu2BfCY>QQ(OQ$8*6&QLVq|5$T2keP?Al!5ZhYt4&D+ zXgREJh}#*Y5rP=VJoi8221j$U`)=nd4|NwNo!5f#vVT=yPxB~RPk-~G0(gr%G)odc z-(a=y`#?41i0dny%v6}0bG?-EYh>@OH~?8rO;TThuv;i=1LHN}fEKRkiCBXiY-gU< z%Vq&OyjVHZ^;3rKZKXzWd0@RS+AVphA^!J2Y)6$u$)`!XbL zH~md}^d$d@<|s+gmpZ0uCc`x3zwiT{3gj4A$FPL9ZS+K@52_u<_Wh45?Qh`wUoQ6L!U86I0aW4ryui%AQs{#E}4hOXJbkU zglP)|V6U&FTEiJiJKO^(EePi#YZByK;?B0c%BwI@ zCzokn4sWnc=E_DX5dh2%_I)Ia5ZjnzW9!MLfACTheJk1a_GB-`x%ONC(pFbX1B)SY z3W^eL^i;I?efwT8B|;d|s$*k$opv5>_g$a6(09?3WqI^LKbq@~I{kY+R>z&4XTGY6 zdig@1+u-{ypx@AO?)Kl-QF1oFDJst~s5JYK%8CjeisbgILt*ft>*0ikH-@Yplil5uMoJlv*;yKa;SeB<^3;wtO`^etcxW7_uVC3$heUe5t++%lxef=q)n_en zP(3$e04g9CMVOfl_1;#s^-8+amcc{WcB8253ZsD8GuD$-J~GHAOmR!7N}2ZUF;ibu zrAR%-8e`9VOmQ_9MIvQi)fdYHaC>a5cu0j3u-hy}7>*J}2W#=O zAa0`)7RA@om0vaLj`ihJG^~!s?PD@GoR`d|1!UXg-m^Ta zU}}-KJ>v7R#aXOD%Prs81QT!f3ErI4&ML9{I@08$!ZK(nGSgl{T0%-*e#?BD$Ud622nG&R+N#g^-~w?rs2z4w-)0Lz%4o5u&uiK-=HpAxRzOY&xkd#($-a|Xf!G^ z#-KEYx}x!=vjeHrMng5xv27O3h1^H~p*mYcm1#%@XAv8W{npcT7iqQ0RkonND;ZS{61NM{H;pn`6` z_#dZn-14-90$;W2H5k!JTK@c`9dDHKp*E-@Mz+Ksc@z>vk!%#7tw?tpVg`HaEv&?B zQM}?ZU1KT+C&hK~tOcodJuz4UVtzY?;14i%0@ZyV<)b}ofB7d(53$gz0LjK(m0vH4 zzdIUm8;KQ1Qz6Jva<3K;(6LGN_^u0&DBY8#KuQ-CtF^3YXZ zv$Fc~uqdjlYFe6UmV9dt7n=p1D)44s2 z!X#CR(13DKtI*Mc(P}Z70@!R>AZR&J*Vr^X+W1X7>4kM@ysmf`g3b?sJnobfZ!bUK z5i3{S^U`TK5>|VfjXC0f&MXvss~x^t_nkKg9^GF^CL6P0o8{-Q%b9H2F=rQ22M53<&?=1^y>Hr>BFu*u-ac-2>yqqQrvE?0M#@`AC>*y00JDRl&w6fl)@#aph`}bgsv!W>7dmt z%IO*lN8=G}ODV7mR9hbur-z$(*76p5etl5(#xr84+!hKy+@XCvLjbOdIj zg>ah z?fN&}9v-c$Fre%9IbfB^C_}qyx9++@-hh|2Y5};(fxJ&?3V{a-~|2x;l&MM zhf*X%K&^F$+qTv~n;(@}`fWDKIi?XIdXL^Ajf~?)D0xI~kL z)Y+KXO9W+&e{CYF1ep?P6;Bej*RU;A_BKZwuc!9~fA@ym{1fQQ_k4yZ zDD_(f@5{yF^#b9dSut|?E2aQxzyAho&_~>C_ z2fuJpm+AmeIRBeJQ289Ho4TxW{rliSFPR_U>yt|ZAqBPArVp0 z*w$FUsn3>$S9+tn!sb5AInkL-kn5pYQNcSAYOn;jIP=ly(L*y(be;gjfi(Kr=yuaA zgXNvwogCRskYgbEjDDXdk~=g{bFwc>sz|lVmIozu%WL9W%uDYT1}YYBg8htrURyuv z1;~q%CWI5683E&`E~8FapK!;MnQ9I*35(ymX5PbgIkzb~I{5tK?KME3YO>TRJv4xC z2yXySRgjpTf)#NiON7I1+&xlD{Kdi)(HYNI&MiRVWQXXL_V%Mi-aDUP;w5n;fI`ZH z?5ZmUEa2wrbKxu|1_BKGVF7RsE*U4FD$cQf#OTMNM##yr5z)kl?{qWWI6qtVyBnlN z^FjbhLeF#xK~)lYeBod|_;@5Ig{>5rqy%uXjw<%)q#=hpRhTt}M6E(&6uN9}P^J%j zg)@?v-h9hsrpaE*%G^u`cgiKC7J*{K5>$=0ETUF-GrN>#YEIrrzIpwwPf0BVj4UW& zGv3#aXTDxq-%`HD#%D!we(9V5H+@6nX+>1Q%Qg((hlYBj!=W7tJ{B^T!x)bqmH zquA+HwZ~KQ7!TARBj(F7r@BDAtCer8Edi=ZI9travjz3`8)X-Ot49BAwX!$)XVF4? zGvkqgSTc6Zh|!Jd9V2eWVyj8!7#Ofn=1QxzHw6;^EF$kB?!cHiU-YK)3CWhHCemE@ zjr?UnQk2;eB9S&{WrfW7P-{DchtZlpChfHOQjy zSCuX!R!Kh`#lLG6tk!M?P%~bC` zon>q#q{>>nJx%01M(Fh3gL5C>=U5W0;R%?5*{y1}1$HCy_=ZP<_DQDWc8vGIC^Asq zpD{AbgzQx^R=YFNdzTy&CT#%U*6w_Fec1#3ha=}NsS88gSIeZOXs3gkmE6KYI@e?> zRn=b1l3{8uu9PYgE60NHrh`SX=;oPrX3mn1a2Y7B(sBAz!N9dAWq#s^S3UekRtYx0 zn=`T8@C4Wr;SH+h@WQ&nPLi_F>+FLyqe@L@)>kf-Q4x&SeG7^xrBuk*NTDewubYl23T%ZzMn7y#Y zVEH&djz3Xe*k7_C%@|4WfR?*iGZNAi6^t*TVn}wr^h(3_Ha9yh4J|fw>-cMRYe8ik zoY`X4Me}1+KkF#gv{C@R=c2iByQN(+r&;m9D^TA2kQ*Fi;v_e{{$?-(J+JmkR2WCx z|KaK!yEAK|ZXMfpI_}uE)3I&a)*ainZQHhOr(+v^@{IRAAI|v!yY`w@HTD>_YR_wq z$#ZBrd>uRReI zi3BSLs)=LV6=Mld*b_Dsyy*hv#B$bq)Uz41Gi9%uPSS~TA_Ihd(b_>?g*owcSWYLq zr$sCj!4^7=aP9jrv6`mjcF$3@6NF9B?x=ayBV5tO!om(co#dtxRQ+6V7p!9L+dz#S zvZEqRX}OC2jZJK5MJ_?hzj(|;+VP2dcmj!ep}{A$1=_&aEm^ORiO?1Mjpr7f7KGhz z%O<9g2;dNPuZegUd|Jxsd!<0Ti(>jEJ zAYA2V67U;X$x+onPY4RlTuM00#*aQLc1r>0w;9>*)YbenF~f$SXgGQi7WbwsKfCrJ zj`#|?O!b?L*o=asi|7SiAZl7}q#$CydKGr6wp8(q-^Ozf5iR#?XM)Eyh#|kJlO?b3orw+Q`=!nK}vu4hAChkf?PcyawmyTAnSF=|fU;#5@53 zYjMQHDqa%Xeh{9aW`vE9um*{>s(72TEV&7uWFF;m{CoX@6M-+{&{(sKNE9ciR%0`` zzM%!k>(F2rvom*L0Mv#YQFp3;&}r%W=|1P{`xzj=c0BWr#GBv1B)#V0*gPue3<(@;^BI)a)!N+BQr{Ko0qNn%FO`bP0{Be;;)Fob1g`B~4{+Et z`E{L7QFZ}rRgGy1^m8S?b_J8hc3j*7DZ7ppVx!)txbH|DebN3MV{+k@X8mh=#u>DE z^)&8plQh>64rIjwWgQ-anO#3~7L_h>Ex6Dm3Du06f?hHP_4X`9L7C8cNqQ__AI6AR08j8!sqBPkm1xNeDp`Pn9!%u13WJOFh$DN{C+vbB84NQd9S zB*v<;qEf3xrpZOiO<0x~QGtFGrZuO{QVjK2vf3yKg)RuUX@=uoquQw2OXFfpvcwuy zfmO{GHa`aYvRK)Mh)MNJ8U&#Tmtav|&h=~JB@m#AL<`{MvwfvNn}(d_JUHXhQO8E~7o-Kb8tfeg6No&paQ z#7Se95$+f2x~I_qM_SXGSzt)WF3yfWGbof!w1nEMJ%u4|EH@xDubC3tP}y7x`V_C0 z*~*{fj_gxCpVQyC?{=uc_3_Pm!M+N9&52Lajb4Tkn_l6KA&g+f%Ug6313SW3i?tzO#{kr~x$1;>TIiwsqz^*qb9)x+QrhlCGtfX7)bbb!hVR+l zC5*&>MxCLRf2yl_0@JH)#?Zh;AFzV!W*e<@8mMFhOZgfvE4uhnO&tXbllFi%4!hG( z2RFKu@N^0Bt{Qgdi>WB+K7o+Z;fXD^OhroixksZX4GbzzR?VtmqXMdp4x#L0g5=gM zUFQ_!h@{ak(L;)0POOtCI0%lQwSZ$b-c?R5ocH~3O<2_0?B8PI@x50gQjQls#9hz& zpKOG)AiVK=LG~!Brv?OyA7w&3s|&`PmnE$?smr-}PnSamyx8TTwc#iXVVLdYOlm*;|EZg{)6*jz>KN% zFg7YXO3|NNj5_bh`5p&EQ7 z)4OQ0FI<-b+So<9wJMUNPCNxgr>XY|&DH2^XW*q4UW(%~p?Br=GVQq?9*iBBTjCYm zN{zB%`$V|buGOuE58^p8ru2s63c27qHPJ`a>sm~%GV0G=S`ZHIiD3B1+@93EqIr^k zc;XjBnyP@EVF2bUza%NEl->c&AGJMo1|b7FlswE+xefYs=|W_M#Wtf;_qVhuPl zEHBle9wDrL4wbCz>?eh`w37=a@%OI2hu<%W3oPj5Ia^{gNxPet;wYbF*%TV1b~Ko3 zqD1_-!B^ouRR&4?QkQ?+evekIvo+#IzZY=3c5NO5bC+U`hC4`?hJ2A26SweBAPvAQ& z>~BdM*HoVcHQqoz`ru5(8WCs4QGA|)OSuf0ngMYYsLTswGTBA;{nnRv%vD^Oi5c6c zyxF}$g&tkWT}vt5S&bpaC#`ne3UZdR6@c*dF7$;>W6n}MXXCXSkgU|? zU|+Opt_v0-muS2WRbsAVO9dBibTJE|m=zYH;?}$jk==p*PTV>?QRyr)y@cJX@Jq}Y zn_;JoXEKVA?*tqfzmqY*wC)8!$YO zK5gxLm5Cv6fzY42gVOw$KB*He47a2Q&k|nBQ;g0^Aco@s0j<+?W>VvPp_M;_4CFv? z6^wlzi0fT7Aw!CKfY#av7ETNre;OyGRpVcEeZ8cJg_-rzp^xEV6N6_k{IP3e9c%Z{ z$#q>MgtZ{QQEK2Q`3{8`B{X8n4IoHiX7sch2Bwz+E?%kTTlR%M)%_IdJ<7Ie3W3!3q>9*Q~QP-0w`CWiMs~>=piD zFl*+g?p(*BQk4!8+Yoj&4InK*cxUD%C`Ko4o4P_w6WOV`FX&v2yU)&YjgsN4>z~9R z0?}(j!-(!+otMKsE*y8(gPYA71EgqN~)Ui9|#n%)y9Efa`8=&@R<~l$#o5V9$ zs`8ke`Yz@Q&c;Up5w&7{rp)kg#wZIdWSB09vK9?67dt%T;+?GS41M4!9bnUgb{-el#c4*Ams}Wqm?8L_6(t zw)I?FCU2l@ki%q`IF(+}^7wKy$m}@ik3CKb<#8*lf~uxOS~nw!e)IDZs3}eTZMs|* z6Me)(&M?!(P1i%z*oqeS1V=fxeCF1p^SG$%Aaj`f=hd`=qacz9|5sn|RJ7u*RqJJs zu5_W4{}XXm8!+}i?J9pRn4fkPCmUlbp*$=W0O92J3kW5=AA}ins@nB}Z4=V1r14}< zcj~aNw^xu!B0kA_U3Q(yl&r$K)Pf32a70Vc^7ZsTOwXD=$7ku_q(fei#qq9*`>Ew? zZSNGz_XW2$BtP74ZF>Ng(HHmPZH@NjT2ruZ!UwxMbfHmg1^D~tY3n{Bz%-CV)`=J3 z?S=b)Aw71r0Iz~1tBIh3D6LPHqEDMR(h3OM<56!Y1&}>k${Y@jO!6;tAqIXwD}?N4+gUifE$D_*$&$0 z3+C~0(M-brRS3z{v$5)atWJKAT*e^527OF_k)BD;-nVTxOMgvJ$V zvg3s)+{auo%I6-wfBa2D(K!DESvDtQTF-Jq1oJpVyETiHG7S_XjMU~YiK$?i6bV=O zk+fTq@xQ%ypEDzDXjrT$HWv&6%p>%< z4l5K*DpdA?9;AA^dvg>zFdvl(^FSS3nzRq_X0vG=GIOY@gJp;J?*I7SUSc*12f-+V zbXP{F9vWOpgGUD@wznR30~f9P*^;6^3)$Vx+QnN5y?bBd{8QVGuIMP_Zv)!1Kly-# z^YQWvR{XdIC$i{LTUp%2JDdFo%199CFMT^6HJcQuFY_Ia!aS7Wlxz2ay)~R!R=~3v zZGVqJC`Q2NIFx)AL`mg{3>)#LKBvFrOyeCP0?g#r$7{=u`Eu)W20lRC6Df1DS%7*u=o9!D#%> zUBHzYI&2V6{qRHUS1$y;#6m5OhIYH>?rM6e)P_eT_2h>3SsZ0nuN{$ncDF9bC#AKW z5w(+?29kDXS8Q0$mp7_OP*qNdt)mh4+}nJS`|hE>VVEN4sfhQ?|#cer9^wSX6KJmQg`=po}9>G1+N8S*=+F*DgJxn@d0t^l}p} zmta`G!$Eu1J{T=XZ$Gq98vj?hxey9O@79falcnFo{<9<*9cQI7yp4H7?M1R%>R_Bm@6wDz(HJZUQ?r+6&$dt{PuJDDyvXbD? z?Z&|(2Ob8wtn3Z^OuRkOz~!dwc5->&yqc%datIb4MOGbz(oYfoTD=mef zcv^1yt_o8xMu}V;9tjU53i1Fu}|H>*9@S`sX4C;ZIRGo~}e&>T(D+KJPh)^(AG86yo zR$qLAe_$c9ip=@egjen`@EtVO(?tE31#fi%7@PQ=y9nxu8oZ%JqstHCFz|}GkJ*&xVPg)3k{-2}yQDO1&rz(=E zjg)C??7if-rOZqy7l)b_$k0^68VTt82bECM(U{MuoM~Fkl#gQ0DZ#gD{%zqhtJ6$a zoud>068cAaR|YFy(T{Wv38)8Q65Q5ce~l&&~j3@U_9;3}s7Zr{bv2zQ>(6zwEpWYgMWFSNZO-6QmO zuM#(UCA?$q#-#W43#%%n4>Z85+Qn0c0LzVbWw3*9S~7^AI@Y}5!!^Ks1BZT1#aiI+ zAqvaXSO9)ePzkqfDZ7zCj6#1@^@soL(>;-(xAZX$viL%@w6$9jm zUa8_IV;OY^s3scWYe zKYysN*omh%R5!n(*#MwTh4V}z-L}G&#41A|}0I7`o(A-btI}ZjrQ~!G02JN`TcrvUDFKbbQ7@LcgfBlH2 zt|dbM5gi8;^hPAda`zM(v3V9w4hn=*!&P-q;9F-3lsdqzj$B8i8Bh#-=gm1F=lj5K zHW4BWl=PIlWJxds&hdr|^t3Xe0q(u$KlJaG*>|+J=YYO549FJ{l+-a2K0sL?lVixfH2+;1da$-rpz&kHqz!Y&|`Y*(e^Uir}i1D^hKm5fU>jxDVMT8 zSQV1A?~btVlKxhoN>UxBi1Vn-5h0UikA;g4JaZcg@CJMwPUiFi$Z?2SB-&5zv_REp*>kX%}fIWrJ+#6#TlR%4YLX8S__w$w0vrW=dOuh8=wUUkM{I)>DKlX;sW?1xgTT%SpS3R509@&0DH zOdI%WQ2a3cSc;;^NgtXAIr90$x0exEc%{rectQv}!w=!xRLD`8q?U>pr{_FNO5uFRxh;fx>n8cYF-{98SrN)8WTr4^W4h zCtkV&d=2zW2{H}&Wn+8s`rQ4Q^N5p1rE`W(1f-{{VrkqW7xj95ZIYTeEB+3K=B&yF z8l-ptflYoJ7hbrI)L(YoE z{M#;!^0^(=7RjwL@o@tT9?`BdZ(k6ZJk;I+z>2*c=(?UcwM}cHwbSEp+<;7F8vpU5 zyXhyRkDnnsOl0>8rE`WKWCc#pna&)V3#;#&Ssbg0ots2U%dJQ7oNsKVK!lf2$!~`Ds7HUkuKLwEJI4<4I zyZ&ObR?bsYdFKbsLf_7A5@B3~k~QR8szcRYVx4L=$F4EvgQ$szaLre<-wtSz(H7r5 zC}J?`>p3%3<)A0`-PI)cHHj`o&|X;#C_3=0hB{?)vLC$vUIW^F$I!`;cW0x9+CSrP zB!;?kEEc~JfyiqxZ4Gl4a~5$Q9oWEwF&I#- z89+M@8y&-2*x(2Tij4-XssX)Jhgi5k_1+LQtX1#&5mj1PSk$s(Z3=y5IsjL4m23c^ zYanL&SM_qv0!>82vqcKcpZ_0AhATZ1 zrW}~@)!VW3ZcgFi0p6kZrf{(H8Irk4ht?w*6Rm8%el_U{LOLir@T`MDr1nm8Ew?062=UD8xcb(ZyI(t)39S=)zo@&1Gd4W86jW3{0A0sbns@ z`VAf)sd&0!O(*IT()txyjLWKB90|@O+i%ih`|yuVoK!L;-SuN$$&GbjS?r*N*4YtW zdDP}?$6{(~^!b)&mo~aJabn5_rUkoVC*AUZRyO$w^|1I_72tMhz_s)u_96?!s>mCp z0@Z$4lSgg6W{;ve$kdwdSvl`ozCD|Qn z?Nu20l)>X8e^MoVHH_)dnb!mjLy>&-6oe_d!EB(Vvz&6ltTwr;v__92Ff3auQ-I#s zK>aBh%_VCo6A@`5z^Jwk$DzrpVGa3$37Mt>N-R16pQKKNmL3d!RK|Vc);?uv0(J8^ z#iymSNflP3mQaj&NEri-{YG#=uD|eB8d=ei3WtesfY^ziqZHZsIcH%Dtjq?_A5X8$ z_BDAljU^JMBmPf4#Xnd8I$5$iZ5gCyUonZQ;Z%c>RJ$fJKwND|!iazAu3nDYB6{iy zs@3NCe!d40GMn>cQ5M%lFL!1n>-H^_Vg{a!w%*wp)yZ5Vh(OB!NEG4`X3=GTn}8+G zF-exCF%_GoG<@Y5BT!Xmymp>pX3g#pm;C@2(s7&GOOMuwKs?QhB7Qa!bP=@2G13j%9{rMLKcqAz&my(I$39OG7y?vOwnQh76rL6n8yBVqS zxULp1-r(=nBfwaKvc}Fh<-m2A$boaQI6H`8YPO;+fw-@!0~I0ZKyOorz{7?xUC`mh zQH(v+ZCj76sphoP*$nGkKSB`WPJh!7rsGvpe1A6d)SlAnfOL`&&fNvzlfS|6Pacek zt+A7H>fB!lMG$7@)VXMQj8v{O2s%K0YS!6#jhl+vYDcSb!iPk`D>hjLi$pVhdE-2BbD2{4Ss6>{C2E8v7vPGUNd5eXMaf zfkJ&NB7D$cf@n~wm4HBr6-FzxF8Qh=q&<-ieIWM`NZ~qi#L+wu{0F)0$z?PVeaH}@ zyW79$pgr;&_TL!4SQN4B2_gU@0zjvfSY@cdDSIV0l|ssAbnTEs(`Rt>OoF(@;lfqNBTd0Ro3>wxqH(8x|`@@RLCXtM9= zhG4^Bq~n>2EM1_4$W$(ha9zoofpe1|hn3TUABO?@vJ0*L2v~sq?UFu25}(X?g+IGu z<-bm)4iRw6VPr>~icD}nsV&xFRhJ|tYw`q0XgiT1EY?BOtc&zdsc?%FJRuu}^%-!~ z?FOZp1TvTUQkjw%ZiC<`;1uoS5^vG_vS8K(2bj6_K0AWTOJZt=d$Ax;My zd=3P+{pw@3D;JfWs}u~PIR$b`xQ@_ zUMvk;Grf0kYED}nU0xgY96&Km>@WQ1FP(9r-N-#ah4Ypeebroa5G zadxKXV-^tk&^VjR-`mFH^|^_d`uX^hoAdAEGBPriKd0AQQU8ZZXa?Z^IJw+MUH5s# ztL5eUct7ZjY!nChz8?&~JrDxkdHFvl10l_JbND;GLB7(;@ta%ll7^WY1fi`iI5%Dp z2|g`k+G1@7;Aey1WhCiPQR5>gHvD?Kpx2~aD*#yw%yV)FrtYX#px@^Z`eAb9PX-Q5 ztW}1mI$toigOR!Px_rKOkLwDlrKx`Co$I>@-#|~6 zM5zYX5WbLW6jg^o-2AC0*AT>9twM6h82OjwA9PfQAtPKV6XvTe6%7CE;hBZn+t)$F zA!77esHg|8VB6%Mf01>qNSop2s6L-T;I5_$-9WGdn!EVfcUcktMaX`BnSFFe-jIWb-o?czs6Np3bKjXjH%s3Fr6$LIm2i>6%a6t=3wxB zGL)GD%wCO1kF4893Ea<6`YcxZqEZv&E+B{p0oMt`1&=Rbbj~6PL+`@T6}<8U0Xs~O zAQ2#(eMbFS=%}i4_dau?&O+G)WpkI<*|hT8jr?XO^Q3*R9ZG4f%ss3>_Lqi?-3GUX zU=DU}1X-xAd!7;*c(0uNS{dv8ejXf9r$=W7fD8|0VYIc*SrYpi)TC``73HwK)I=qV zIa(FL(8?k6;B^&j{(bD+`J%;UxL}nUH0(Yy$gvifzbguv&#j@!icP7h z$7Q(g2)$e?ajAlRGgX%|*>*k$J9(cjpD;NO+F04KrwK$VXhGWyEb+8FcA2Aw-KpOK z1P0fOsP{qb$Pg)T(`RFQOKRG=2nz-Fy5~_LwB|iLqAi6PhXIS%Pw#aMY{2E?SniA}Eh$^_d}H-3Lx zojmRRx(8i4(o0_N3ugY+Ue^a!@5xwko|6r|kl$WrS5jEWl19J*x`;&$TWI>@rmpH2 zdGx|-_;=IgrNer~x=_CrUQDs-gl2}0jA!C*Z*cop9ec>SC(G6F5DR;zTce$K*#pFY zBKx0)dA>dT8FT%$|5Mx?Voig^7U$oja{_0HBaNZPpif`r3rfwcgA$rD2i#^1G~J>C zIeLESxq7eK)a4vZ|vLi@oby9U{}PjQ6n3pB|^gKOr>o|xNUbj@a#O{rD6h8|1<(z$lu77T6NgtmcF z)RgcYa#ub?t#y(J`-;tg>0P(=Q#1}pA3S;J>#WtD7~F{_5bW=mOPCwLw?z2_5tlJ) z#7f~mmNjhmaaVYQnyO68H;-({@jbL$UIUud!pUM(YygU;r!28~{GW>ra!-r3xoZ!$ z%6dt#gFyCsuRJ*hgj&4nFyNvjhtY3YaKe9)4 zpyI4*LYcXefmhDTaq5P>CR&_CD;urr?0^VN0Un5xOj@mgpa3Hcy!8`SigKA8eEf%pOH2N3pf4^x_&q0r2GpH`T{ z&4tKPrEGHEMhj%A6=Z6%lsLp4YZJU?O~M4>DpkzlNg9=%ZTK*AW;&Zj;Q7nzTLm=6 zoWC-y&Gh;J-zbB=QWKw_Wn2!rIHNc9Z$G5DC{!xA$en8Z7DyYxiHFr{g0|+z1;O}! zobFb_C<>iDkDMvUJ7b-o>HWK@GoiBrnLC1fVE zbts~!ifK4{$=4SJGP!!;V<*@!^`~XH8r*fnc$2ePhiYnySC z^Y1|z_d=Sz$LXE*2Pl`V8@Q)@Vs8b^c`ehyT}x}z@#_bWo-CQJ#z|971+G=i3+KJG zlLH+<)y(zYutsm|el)fLJ;+`zrouV^6KK0XK=y@uMGca*5qiD=q1dd&-Lz!hBQkhf zZ7tEzm_9ShwAm!Cp9HGK-xOBK*T3JI4CZPGqr}D9C+W8?bLUwiM3qMf>g@NTi7vrL z%qmshoh4kC+e%2l4U$ORsn2P0`p2@X$^0h(28EW!-^7W@R~($9>wz01fCXD?#|~Jj zQPejoyE;p14eS>1Vh3E2HIX=wcke8o>-T5~2q zjk4|Htr$g3jk50RWbz*Z@K}@N`B*7qSgPzp2D5KZ9={H`SQ1Tc`I3h+|m8nLa~PG7{`#eFECst z)2)H8v^cl>%ezTtp>NC3Xk6~cqr)90zIhqKnYyH@DQU0?OquatL- zbl+jZW12_6xu#)mueWy3hc3;39PIl$6XdKnQO%NWEk0deF311nVEb~>4Uv7*w#^+p zK8zBk_WFAB$Y+3%;WbLa*`Fou{dC0%$322V#a~gnw96L-&+U&UMpeHZxv*-D^osYr z-r$UmU}HE>-w+mxu+c-;^-Go>itf!X(|Z83B&;=xrwJuf$YzQA>hC$EO~Ync%(GUo zU?w>mmU(6b^VOdGJug3S7y~Nz#!pC2fd+|_<5W@HQDcwKhEJb2q)_*Z1v~5oQnA4- zBNAyUp*R=CewJ1nMR%IS>)=MbB%WhIu$dy5v#!sMAzdMu#1SZ4@Asn}$yD;qPdb2X zhB_i!F1i1|J1g&zUcNncNFX5o`wm3le=-mE$D_xkxrd`BWNaG=id5w7ngNEA5lur@ zcTfAvLT4}_e0%&ukAw+8T=!q>e&0gCM%FwS3LMn=3uhQPl{~Ze+r50fpKoV0#1?%2 za3zK`!az1hAF>I9Tc<1yRCx9ySJ(jfu2wA>lY9A$-}u<7R;Vt(tsXm%dEm3RB22U{ z=ANGoOM*ZsggN0ATtvEEz=4GDsbR0KRp;lI<7IKZ- zoyrDQZ0LRX%cg!v=IC1lEj-tkXhPEbbl6CF8conMJOjukQ(^&s$aosaV{AYy#`(@h?E#Gg|Y6;PC4qFNnghjO_)ytzPT9OqaczNMmE8U2JDx9V zrShtLo;9B&iL910rEz(GR;nvneki_kqyEo+(Sdyi;at+?&gSUMT)zPCuped&o-2Py zdOmg#(3au@y3`NX3;5QpDRLbIW~u%EtU^@D$5fh-ibBY1f@bC%GEsXI;A*dL3CkWQ(8rq3gOGlXnp@VRPl!_7vt>D_S>`` zIqBap4~%7*3~ihH18NAU=o8YPE``TPWSicD9j3NjRI?4SHSY<{zUYrXId@2RNQ=@9 zZN?8ZxuN_JVMh4j5E9{pmV-3YrcoK%p(Tj2^tD{|C8ye+<|DHcQaM>~VRo8o{y9u{ z1qm||Yi^XgB`|hQNVrBJN6|*ZF7He2;+;R+OQOXQL|Bq8n56`$4IN{*m(&|!^ZfKM zw#9ex@E-n-osA`dAHR8H-x}F`YKe?pV!vq*7^)IOG5N3;7RH*!GDOGJBIU{g_lo}Y zAUZ2PvsvRp?32mvGEY>N)4D~=ixVr_UGYC=V*6%Oa>@`7lp@1%oDEp1BY~3?L45|v z&DmW^g&`k{zMP!`aP z3@Xy#kx@_Pf}~$}EKEvqpcRX#i#@=QhEWKlbAhP%EZG!`reKrtwia%2VloRQJp5r* zI#Uss$xnf@iKkX_(3N!)lO+)&$G;&PmT`BggSus6ruq1ZP;3_%`x6apX>$&5FGHk_ zqy9c?ZA`tvIr(Xf^9#C5C}Tv>g-_VpQ7XnZUQQ)bK{WGD@m2vV!;r>yF4QQoTw01d zE7rXEuc4^1Lut8#jD}aBRe1411!rCLS%if{4q;vgP6Sn2EEj0oj*qw%gt5uvX(Ci% ztI|?H30o4N%i!S|h$M_Xid|(5{BnWSzpRdGK&ntN-;5cyV`?tIS_Oxb)x_~(n@xlB zzVEH%hBdVc{8x;_`RCP;6!ShZj`&7jmJC-P6?w(_uVVzWnKzD3yijuZLA?pOida>j z`GC=_jF-?Y5m}~$pbT9J5$ZB_+E|fCHvZBvC^UD#7*%K(SP64qHm>k6(JJbC1LbKD z7fQ?vDggC_1cvG-xQVOu;hbv8K<*b}rr^dMMi`{{tf7vFoOM38DvM=(_bJ^<-}GZ& z)mB!63s*OG6Cuu!w__1*?;Z%3^XRipeFO^k`)x$idZBRnzajo-;a^2lkUK(an6v-p zULn*0$#YX;4)@WfGElEKsjQ61;DSE*23`SvyJS}PGhh-LiFPnw)Ks4aVforMGpZ5})&6Vnx z4p8g&ZP^X3xWVJF)SfZYNy$1FywAWC->j2LWf zt;h}98WyB&O(Q8OpIxlzGR7wkN;1)t7laK23igq0I|d(&I=0F%mMf`AhOD*#z@WO^ zU25W^Nw_H3j$_+}n=J}EdjmCH$iX6Ypt)lDJkg#hp}@P(NjhI0PkaAL9BKK8ldGyw1hx1 zlmBI*^QxJwMm52h*Hk+IhfS*l5IU?Z7%07^hWiBIK!-BPu{EhE>I)VmgoHVPOV#9| zWf?EwWS{#bc%dC9DOa=I5rQJ1f77!^j6NPmoFGmkR5OWqfTW<#{fZzd5sr3N(DxhC##+ZQ0ELWag(YsIq;? zpZ#5w;9ddZ-OYXOW)|G)FHj-X#L7F9vXg1AYO0OWC?{WUrH$dfp_PfY#@AU7Z15jv z2;8hesdtUDz*I!mm`SKM`@?RNaq9FI=E>8Z9fYh-VZqA^grA#vzdsF5$9CD$*GY5E z8ulDMiy+)0nHmVQ=m@k5Sch_A)0Yg6#)+L?04j5bDasjFE#YG%*QA_)wJ2Nw06jp)!0$~L3HDx;wbX<>nbA} z=yTHkk~M^2;$2WVjHJFJ4r3h$w&)s8#OA7oyYo?!Q3jvr!Z^pB8S_Ac+c~)uC1OS8 z%22w2_K_4?IAwzxu%FIs*`!AQ#U%01IlZ%z*@(F5-d6wDqa-)^z@7%}el3&cN+)B; z(3tZeP~M?7^*esGM237*C;I*g-9eGO4px7ZB|Cy+o0ud=esb_kk!^Wr!kmy{@v_py zpPxL8j@W%lz-ej4J>L`8>j}&9onTnjQ1t~&?UwQx)`if2=-+8{#M57%ul6j>&_ zsq=>P^&aaJKstP4r2v<9I7XsYl8ANSNb;kn*?MepP>AV=<|!Vvg)HNK5u>)P1n`G2 zT3h&aUR_6zxRHF=sS4Eo(*$>i5dxBlMgf7nh(FV)41q|Rs@S~*>0BubmnsgOC>=ih>GYn^&5j{Lp zDx{pw{Fa$o2lR*yn5V;WiMr`M@mL#0vx^IoK|DQD#B8lsy6*3$kmJg?LNw@@tvcF# z&?XJAXkjxxsFaNJ5N-W3t$QWcO7*Lo`tB-63WdBjya?PdjR*EbbH?&A-!kiP@g4AG zTk3>Pz^btAHS+y1LvGFLQ>CPE6>Y}qts8h)OU2tD5BI@MMEUFWL5H4BFSd)L0XdfV zP3If+-X)i$QL6%h_J^?ugExWW7Cvw&mmxj>to&QR@ zv25n@!V;HLr%B+hD5Ks@Oh+rk@Mz^U zz$H#>lkBmdjE!mvD=*<}TMfuhS^q z!MNo+RSdVv7GrlEc{g-iouq4!te&etju^hzTaf(Jf`&~93BckG*u06|3Vjx~(`2p3 zVo?;ICj(amVQKm!t7yL2jqn=v5#Q%ouY$b{=KnY>I3OS?0gV4&s#GFLEBsHY)FUG& z-1JMKWU-_+dgsK?8T#a2kUQZA6@tzk`uPP!`g*w{EyY~8uG`s#^XHNr%I_DHpWftR zZDJb7Cj~jhK4C5azg!mQ>0NEz?P|~&;qL6F?+3Q0;K$+mV? z+*N)*O~nvP?FM}G1&Dr}Giubp`zVz9$JWMm*>*oSG5Z1ezd2HJ<*__Uxxz&+zu*;> zc@(6QZfCk9y3b_02)rzDiUD&8QE5$YQj2#-}5++aC&1e^718g*RQkuk$7M1auXG*LP}Hk#VC z$jvAdnO)y|7THyrLx&mFMp%eTo=tNRZ;u57F+3)GPaq?97jhKzP8(nANoDNq{aHl+ zaUce+9qSt`f_=q84QtosdID4Ns;FU5R{+%!HC^KF?hssq zySux)28Td!9o*gBU4y%Oa1U<5-5r+i+uhoKtERio%=DYNQ}5M%Q+>P7sg62nbw{); zsFWIx5}OljmD@U=hi<=#8!m0(0xm)|w?D+qp6>?k_7tyNA^vO)RC@076eLAR*BIS^ zgHLBP2d&-R=f^P)bZLPS9|@}5Etdg^2DYlJx$^zXEZ91Q22`+{ilRYxkctvH$foq} zWvzYG*ey6Ur0K_*pKsnDr+dP^3vX{*Y~opvVJ>{O+1Hh7zX6_Va@(9@pikD0RQT!` zPKR&3-|kokkBDj}#aO3zQ%x6;uI}qUoP#NHh-@yw&HE{&> z@$G>tx#o#oCWVIr@oLAb9nOE5IJraT4T&`AC73r$hAr^Euc-b{(`qyVY z*S1?x7QP!)jvM4opCEOmLz5SiCuojwc{G7YNB`E38UL$SJbw#=(J_{M{YL);0eG4{ z+cmc3q;SM&`9*T%_${XpsP1HF)IS_~dVfOU8whr%V8L1>my zbiLlRwJ!iU@TD;29`Nr}Tv>Bv3W|e9YEeHe$V6at>ggyu!nPW=Po&Aj)4`}&hMwZN zZnQ}8Dj{i6cVbQTPmPm6?D1=<9^`0OREZ8qDN(b*3Ov2@7k{RG4VsvBu~Z7p(Y(R7 zI+;rHx7z|)W!Vlk0BIw8B;d6FOd_6Cl{7N(FHO}19JVrsEPKRY%2}E-ISN%U!S$`d zZtL*n-jkH5H{PlBEq8nftiv~CVOB^QsS2pJ5iJAnW>yHAb;N8_b{0jEopIm%_lSv{&s3ViZgTOVCak_nL)aj8%Spdjnmo5|92 zCMpEddt(^|J;Wi*0i%O{0d9}s3Q9 z#Cg+?W}ulQw9~jI2?e_#m^#uvq_Byf9({*CXej@0gF89pFC)3biU`JP$m+C#RZ{~5 z(5?ZwI&t_w50%pb?OvHAGZpc$`nPecOgB2TOp!8kHcd)6Jv1@4zUW)=SzE-o8IN*} za!>Bj{zsfF0^VApN962iinZd&YHV!bM%8V~e?Yq6%*%Xw{_ye-6XkEmB!qj>^|Y&5 z`|Ge22LUd$+11VTMrC`b4UQ$E4M!q7vWG?am_BUJTy%2yf^yO&x@ZWm^?nECi^_9> z0W7QGK2o%0`@v zwa$XSTJjQZs7$Z}@b7fZQ&Y=*GP*kZUe;Cgj%wh>vgJOvEF*yId+-Oi0Y#9mT}de zZqbiiF4dKL=JSh?zs%@DD3(*?X1qmBofieyu#aoQ{X71YfAvJ2G%G-)Mv#76Y zuHQL2eP?q)YE=D72N%$dONd1YP}8K>dyc(N>k-H5w#$GpIa$)*s0I2dh??pLM*{xE zeCT#QLtnZSUas5#r^ZeV?2SR>miThKCHAs%f(4AX!ukLR_ zxB{aVBvX(klOOP<;d=#STS2zn7Z9z!L6=S=5YlH4p$l~1%IN1bg9Y|WLc3TxN?c7@ z&b9T6%OsbWsHxHipUPLik_UfL3juNY$CM1YjYwwW3lY|iMy2H6a*lviIhv1$!k-BD zKSPkV#>(7v=AfnGVfPNzFGU>^e>b}EsS0SjwL!4KtIJL{M3lHC^*8r$%(y(Xk@NJt z6oIow!~!c6Mh2GklD z>o*Qm9f@zS>DoG;Y{pg>+d;)meMl+7FU_N)u660rv}?`eR{rK#J{YzKlnc*81+14R zgk17|Isq2GG{z&4^a~9UFF-wWSS=R%Tg}2Pw8Sm{ToBt z!fnmk;<=FgeqN$#YJ7&9{m#cb9Z68@qeP$sg6jEG9u_qo`V|1ckLD!GIF8n%i)ZUgNzM z();b!N4*kLaIA(pgqZ5EAu07v;ly3HegQNQHoxky*dTg7Sh3T%-ibSsFJ$6A$;<-Y z2WbaNVCMaLb6(^QJ>Y1bsvtgdCC}X#4V{rXb&gDEP*1eR{+rO=l>s8(NPwIWlGXuD z0x1-2?o6H@jK{mF6xe?LOD^hBZ$m8=Q(Ww$+|kE$xX*eEMQpL?zOjws4A67L_-iXc z)mO8$()HHsK$y37qB5-A=LpXwVQTibCndu}k0WMNq^3D)Gz&V6zkg3>402R#eO*XR zG(E7WM-?%vVB+1jt19QWXAN$+_bh8J>sNgpqX1czZAnkH1sHUM)T;Ve8bfh}*?%+r z3n0d#!H9}ZHq+GqS&3Ewg__AzI3Gu<$nx!EI4-e|<4`3xYBc;O`hV{8~*RnNLj`J>KJKuL3%1!9y zbDC^7bAm+7NI+-K73$54odMRt0_xvgfHwXr>K&%eiKpR0LP0}roKm06{pd(hF$H2! zZ)=+{=#?WS2-l8> z6r^}+bOIGK5Xb0W8rP{<`Y01P%;3@-4jDfT7`9N^=-O93P)(a<;O5!F5tYIj)9@EL z>%CorH-{}G znM5T8p;69qrrN3{M}9n>A=|Nv7BSI-e2Qj zTmT$&OMF7fmcl%D`jsxig!2p@AcacG8`t3QMV5sFGaQh5|A?Vk?}&bVpCya4z(G4N z!(z8U*yxHld2inIz^T0WPuPK~d`gB#Np7E|VQ77mJ@QFjTPZ-g)||d`^6Do8Ldl|D zY`;>mP`Mo(BzLA_WGyPKM0JJyz|pgrIzZepZly1C(?Zj!l(I8Tao2BZaB{pTIMT@v zN(e(KL5xzVE+)(LDuZ^KlxA=av_LPoP`q1%Sc}YQ zG}Q}JUck|_W%EaEw$;gIz(bR@{#vu9il8F<7yb0s|9 zliMBG3e2>MkxYDg{I$zsB(L5X17HL54r-1E_Z>@LvUAf7I5+J5v;P@m4BBLMXyGzp zMR;)@25>US(IFC*b;rQr%gaiUW0S6|CLcL=iHOMtX2{mWN1UsPD`xQA-~&&=C>7}* zK(Pd#*rIo!6OgjWeoBrcFuinOLx1~q+20f42g|uGn+$s@{?f)<6rsS-7HA4QpY5Aj zeyaK2A%y|+9a?hTTt+#67ZxZv}rsLO!(@86G} z>Zry3bGS@lrh~6L_Ex0qpfU9w`@GPQ8AV2vfKy;SzWv$i74293{2A%Oph*022kb$N z6#h415E_65{bev;2K!}jUk3kW2w#TyWk_F!+!BC=GKB)LGO_)CiG^Yv?nL?)#Hn|> z;dDZ|$VcTScK=FxP42{Zmejx%?j$Y$tfxzS5)ib>gR_f7nN?0!+nnA|Wa!ts)3F?c zHw(p;zRv^a*L}0*Ecg!_^f&y|V`6}}`TfxX2lD)@J5=;@`-=GKmRtE!AO7xr9B7$G z7F<=`u>N)Y#kEjxPDhp6taNj{_HOudxYevGcDTJicSXx9^m6I15##5_!{fYRkI$Fl zHp7YaruF1}`xK5=;d>uZlvlrDP!C<>;y7-%X{|R6roiOwFC@$!55;$%gKmF8#Hra4 zbq~)vP|2al0oSwr_aVtQU;dm68-VudzVTUS_ZXm8Z1JB_=*be9$V|-r3~ceF1k~te7_Npb;T`lHXi@|m)n+vD~s)E@&_Fvo1Lm& z|9)jT7W<*GfY!b3EtDn7q<;#SCF8DzHH+L2+59XH@WT>?vJ?<&IDg&%7GQfI$O2!9 zfM7Fw$~tHOHMs-{Bt+>u*5aV7U&fbK-e6hG-ZsYO@vTE7PnUHeToCJW%6zmyOif@+6KWkVL8(q zsB_6h_h4z76bGR@R{wiFs-*-aop)Z!TjaLM5EW@HZ#bdkM}HvaHy)t%X4sw84#ue1 z7%B+L;;V|~L{IDP8_}IU3}+{9tO-oZunX6}P-1uoOR^ad4eKtFF>+D1G^ME+j#P#w z4?aP;1R`>N+YtezRlgxD$L(NON)!1Fk)z0OZ%&qyP2P>pR%=tDe+UJPgz1x= z;L49-dh*kQxQr&Xz)%66D+J?VRpV-8+<-ofrr>6Ck{{RT)1$_S@JPHFo|iY2tdDgK zALVWGJAc0z**uPH5ZTiOy2%9-N`K~5H9^@;m?R@MhKR$4A}foHZT%g_Kf;awwmVPX zD&JXeYKezNWcp|%P|y1+U^-2yqO}yqrnQj8`ems~%wl>f+7y3PK zA(FGnPB~gNaI-5J=pC9ci$W11!E)a*gOijc9%UbF{I$?y{MSRSq&;KR$|d4h=dYJqewn4@MCp&(IS_DPHTM4g32hm zz4+eA7EKe(Mlcm1L%oR-=4JV&kv_5j{*QDprkD)LM93j+G$yPegp<4j-xOt)phMka z&Kz0j1Xpxf-`n1-h>nie zVb~re3i+Vx*HyfY0Z6=}oM{PqqGbMNU0|aJj#;2W)y)KOVG8veBYU7UNW+vTvP?a>@A1Y3eT&ka9_RG1b7F5?oaf4*F2upG9lJ?Cyos}Vme>@ro2tgX#a{E55dm*g1&wu)pEjdFF#$480 z;uw0$&#q@@6;~vJ&w2>5eqgwff#$fZHo_^EO|Uc$brAi*5Z#JnK0B-5q~b|T+gQb> zR8Z_58MHF2{rwP55ivNJkwGDVv*!}-*l;`u^p?pd$D3X=AE200DLj^x-48F|`RVvz zqfnXfu8$=s|2Ud;MT8>S&5W1P@!O4mOH^PQ6ZUdO>Ju6JIS_6Ya%KTzo=y)Djd7md zk?BRNrRXeM9xxFAtE|X+mGqI;SwFG|Y9RhE-(TitRkPczIe0e$>2%zoDPfpRb3%Oy z$k}vm7{t9vRbKZ3%s6R(Bm9_G@BJ zYU`q>=$1=5{AI%A&|CGT#E$JyVZ2BKU>H%q7o6?DNL^!_B*=%RT_m$bu&_ufMWqfR zU`z*ZCaRXWpHny~Fc-s(y{mcN)7mfaVL!UgrX!Wcia%;Vx`4Vys_UN~>@m6FJuR+6 z-GAgY_wl8GTsCt;K`uvU=$=X$2Kc6Y;Ep| z=LPXRA55(DFXEk!|5i%6l@pi(v_04FFm^7vi#DE)Nx?1N|2D@P1`=|47(prJ_c_Uj z`K;Gn35R?4{-g&$z$;U2vT-~C{2a)Ou-c~P z6jqF6M;pmn5~F1Pe=PF5HK2wy^_jE0Ihndo&Af|)2%1#{{3)n=m$9kS7z(3g14F`6 zR~h55D;r(&ed4sMPgK+jdVDX{(8SDKls(XL<$_!(EKKApV?f0BmRZy{o@g{0pUb-` zGKH9FqpIB^|Dko+?GShaF9&henm>(uJy4vlUIQK-uozX}lDGa|RZpLa$f_mes%O;% z#=5fOeExZn-anc9P`@^FtGgU=`B5k?372Zpt1||hQZHP~z7?UZdy*NW7W3F4&-iN` z*A+(wMPPVCz;uaYI*X(U=V$(BzVr6;Y9PJ74ELSYf>Vn(tcgM?AUa@Xu{6O(p-j5r z$`t0 zUYMw@Zc+8GBjzy<|F(g?>b) z*}u>((GsN;X*blw?(Jk!SJ+&K1qm4L;mFj_mIW)-;yo`_Qr9HQBjG_jR0Z2Z_+@jm z!-n4;ec<+Nj~8=HL92tCT%TXSkkxQcrohgaZ<6Q2PuWyRJ>Uw7Xv`&!5RovK7?Ak9qWsQNR-w14HSU00-o+bJ6($b9S zvA+~N+pF%@Z2N3VR-7BbkJM;>!XESLVX?c5WgbT5$o4xER?AKVl10l{xyTRT$-iJv z`;I(Xi~o)82Il!Iq$K$D4O*F5YMo+Jhazn8!@2HCnLqYs|#03bj(~=9M}^ZF*vu;0K)Q#8`JxkZ=|nI+Rtxsu)`x928%25;L{xW3ONEyG>0iW&2ewMx4|bSmpY7J!)@K_)wmPUAa|qej%3ZVhOq znwO>u{z}ImJGBymjMOFtC`=9JWOIzXN}lx6E4}_Crvb&?B-xOk36x&&l`!(!89vQI zu&Aff=`uweXk_)@?2WL|w2F;c-0E^bb!7$?dTEmVlMl+J8vbB0tX8q?+CW%0f2g4= z(V3eSlL9#V<@IV&Cu;Cb@p2M!U-wmEjxer397CHYN3ByPRZNHi!QYp*^r(@WJEMCD zOM>XaYOJra*pe|V!QsM6h(MKJHNg|E3}16{QK^9857ftH)}C;%`@o7+{jW$11XdfE8v}ZhZ4`hxbL;Na(fgoCjC|Q%J3F5@i&Lcfv zL2=OF%B$M}b7JFY5pD-lfM=Z`9fJ{$=XhnMS1v-f`bW)q?x4C;7g7?i79q8oaZTY5 zGI>rTOR5}?)(B&ErL{)15P^wdrFiZ|enZ*NNq|>oeVqlSVk@>#q~w$-J_lg0iPNNI z(m?%tHnOLTRGi4jq#;#qY50bFmd4JRD6GviX#CAQmxjfThACx`<$+i$;Fi=eh=Pkr z1xc%~wJyII8X{DVmE9DwPL(t`0KAkRYa&@J+$az=Q-?YeoRXBlmV@nFjVveFqX?9v zSH3yRKi|igfRCe!%Qo87X$dee8cat#j}))yLfv7e>(h3({Yt+g>h?`p7(vvsBm@-0 z>oSu?;z>LtWur9p{Wvs%ajzzf7rw@Gs1sWiYP^J3pu^ADol}sHRKZ^=!6DMk@aLAW zt>~LO-um>tJ^$=#>w5mTSh?)Rx%Kw)PT2iAGOqdQbbEZ-BDmh|g9TJo!E9~3y-sR! z=JH35bLRfF*;@C0epy@QRQ!AxKacE4tu>rvIh0h)S@*Wv5@4k_|HsdpZEnUf<*306 zFg#8b|8Y~yc^emJw<+bGTx44*=h$0scw^Rt_vXz#@Ma$B@daikS)*6Er_CHKp+_dT zCY{oyk3>#@m;H;yT0js0UR`}{`&dSl1vLj&NQqjhgk4A*i~)~#yr@HAe&w7xD!iwt zf~pDOx&1}ibaklvW-1H&5svA;-RyumArJM>=bvtdzD|#C7tMsH#xE}i4a)^Rwe~= zeI0Ml&wsjc8os~1jjTUuqyo|SPH7*?6S zl{R*UgYbv`(}$k5+^a|!vf*-Aq}4i+4ezGnojVR5L!k_or5jP%*v=BW%?Wn)`oeGx z>U`MK-l18tz!2NtS@ZqnsNH4jTHH`x^?C%H+Ol-fjD~EnL7qan9jybiQZo7o?6n8` zX3iu`0o{J#c}t(Qs2f<=5$jKzQm+Iy=t@57l^&_b;jUy)b0qEVz41y$r;EikgG$$4 zRVEJlE!0qL20B!en3@8C`^FLLc>DWc%tSfs5=+@8fcE(&eKQ~fDV-=sLk&Q);N8=i zD11?oWmWrr*_tolB-t@V)7by#m+WAd|2b2V8jJ3ur^g{fs$=OUhwJa0rIVp_hv)oZ z_&;kV=5v_VSv(^P6fShehZ+_o)}FZPH&Mgn`A1}3BJrlr!Q-q( zo5fNUdQ6J$pjYDYW9-lOx5;eg93=JN0$(yc)>R_Y#$(o+s;bf~)%M>yc#AqxG~dVN z80@v=WE|5Hy#_Vnm$1L!ucGxsw z0H~!V+UY87tL2GRy@fg#i^F`-33TQAG1`@dK^Kc9o!(xUO`%RC@yT`4my0@dna?sh z$Rk4aNN|soKB%86o zw$Sb2Y7gwJ)mO#F(3nns-Tl@mL#rvN1+bM`U1^pQ(H{`+bPQ2MnOW(@f4$q>K^jzB zH|0Be=2q2b2lNa)h%Z~YO!(B(j@LP#zuO!l2_SSUYPcSRIu|@J_B(R(+?5m5W38ff zX)GmN2+^K{2YbcL6a0F%31GN{=$Lcq?EXCZw+Ej03Nq+=>8!pQn-}(ERST4 z*vA!=bky!bnj)yes<863C4?MV7m%;}l#i|6*)GyV?hq6z+o44kEN(VdT;VX8fj8~h zpc6P>NnK_rB`e*+CzN zpY{EWzaLR(4t>qHJ%$v-zr}IMf=Fk109|<`Z6I%VmIOeEx`gWAL!wi3H*9f-seuXV zZ+n<-o_bTMBlNa3E>?j-7vY{2q6KAu7d` zXQ1=#d4Gd(`s3m5K62z>bge@Ycs;pzu%Ig(D7>`)xP6{(k?hxM?d`t*=55$<2~Js* zYsngsei?&VbK_piNPM?3ZZcM9$Y4x)&l-e#Vu8cDK5aJf&j%m)V=hV{N9}$;IuMag zh7HNOI$buIG&9+oh~~z?wBC%Gn=!-0&=opv-4%-3nzTL*k~*h~=`ULzg9v^<8TRS^ zJis`;TFdkof1HttJ}{x#|BN@OrAY$lmEZ@1CRxt0XjS#f*pWYH_G3+UyWgr@R=t<^ zij`H}WJL(DQDg$1s`-2JH2ZUI8c!6Q3-Ar357ogM<~)*xs+kB&Thby?5fjz8# z0~2c8O9ZKK^+pp~+)yfx{!U9(A%|vj1oEw43>t=+l1BodF)c7%z-kKL;3{sXJ#?t( z+#T9v>=V08H7PJ{#GOaAwi(8A8%S!I7%vT9CVwzF!~zfh+cqRb>gxYTiHKJRM{4j_ z%65r2BIY6m)76^nILWY`lH11LgvV{jyjXrBKQF1u{K-q zy1nU&?x&6CDwbUj!|VOc+D|V(+whhJRWTtlw|qcJNYPLX({D*r8S?JReweoYq@r}J z&Tn|#6c+Cl4vy~eUKLW%=UJ^!aZ_H)Wjy7cO;_V8jkkr?{Y3Q z6hP72?d%T2bS_H)TH;eo-rHE41d+D1!If;Qde<}p9`_KO08-bjgeJ6#Epz_5 z5mc<(yfAND?q|SLiy?HEoB$Tqt)c=lt0@CVV#aBFoWgLw;0S3n*H$c4P@9Ay^`D6F zuL$>=Yx+I;XFOh)@$dD;^eZYUx+Z{&o9g@hb{A_l-x7rj;eo)AoxR8gmHaWWcp0*caQ59B_enGT1D1 zfvxYHx>xSk=E=95lUUehUT~3V`rx{}Sh~dab2ol@vfKS1TLqGKW%ali_6>^7#;%%jrMWV(?e zcgRc>Ko+bYg-SR>3zN5t4#ic(|2Aa^|~(wyFD@vVj@2pZVDLfR#RRt$I= zolPVW_;o`b7AtqzOgNpax;7^1=CQOik;Ac_6G;Vn(dLP^oih}_O)FZT)07RhPII{u zvxY)L6w-PTw`&~cg-r8L+Rw{a5o}%7cdKmE){yhtPYd zUi<>Ihjzpc)5goL+u!@%l}O!=BW<(mIN^LHw`Xq(gT!1rx6eXQPc&-e&@YGpt1D8>R6)F{%ZCK$HMiNJ_jo8| zQ9W|2E2hEd1gNji|0w!T9HA9g&)TV<*TxXxvOFF?g5zb;>;MY3EMC_}3_fMFLDo)% zG#MbIwhRnN8Wz~Nl=wIIwY#t#+_oZQE$J&bqL<8?f@+%Jbx93nr%HTX_PKaW95<_k zwWCW5*>Qr#+*={l!fw(ZQmXg(ueLCl!pIUFngh>+MkFL<`Jvr(;CZ_ZuY=-=75IfI z014|rj88A+_xjhE0V^$NYPAOZqCJw=elm#<0dVvw`SKh zl6z58c^m1{#uVp2J3f_zdrie(j1TrQCM!z<#HT!~3>|4?27e=6*70b)>S9hsf22|k z!l&M1ox}%Y67rsBgemR$k3OK0nxD00z; z>nl+qqN+8~{r&46tx1)bI1DRsl^ghagX4pwUcdVV@9u`LVKIEqX|@78aG~qJ3DxFlM-wZ{ME_szCz(+Bzs3ex;Dg;8(CWVXA~rOH-a^9jU?C5IH4J6P zJ|On8>9w;N>{7aTo>sA@O}(b=UNdeZOITZzwt9%8$yNbQan9ht_h2OtK*WqlREPIo z|1GaJ7vo>9Xo8OA_KmMdA9jjCxYk4&5vzjp+EfzxEuw~6w9%<(g8z9JgccLNiY_b;+iX#;EDvSyUdghrzKiJRe@;0eG`wMS`^uA*J)ePL;FyP(i zjdw_QV3mbEaT{p*_IKL_c&)P2e)Xz56#tU$EJWxsLcpc z9vV}Xx}A-|2kX9ZI{I>G$<+B0(qdsJf79r{HJAf|PqwgeL4WCDw&8TVa93~P z0X_hZLKGiLOi*wHvyDt43F7vkQ+HA4Y2sYyHe$OiMC1zNc9SOxIK-pt$vVfkq6IA* zkTnzURPNZ_Huhw8+9o$4+W@Q{xLKzINEAgq?yoj8r_5L_h}z9VdmR9R4Y2rUZA0*9 zFwIYet2Qyh)lK{o_s}tyQkIS(-7Fp%j!^ge$A ze%Q0=vBcgtxx-0-xO!Rt)Y#kA-?q7f%Ov)P+lW!(e_ZOm6FwzEDYv;R(%o-@;~`K- z{sq}z;^z#%#Epu7(}6Ki076lwmlHO-UO`j`|XW#<1 z_3i3~E|n6?)61)$$h|8=x4$1gu)yU{eu1VeAnL^x*>8hc`Uv51ZHQR4xFX5kS0SMS z<@<{2nkE=SD0<34)a?ZjvnvE~!)QF`%QNRzZ@J2?c(?^;5iDXun3!P|bQLIL;CgX= z!5EMFOy;I{*J@#Ue4wTCbHZT0SvB@`{bFw)#@#%>FY>FKB6V%BTb91(*q#4Y!_#E! zxGFj*mxY3;*thNiIr?{sB6N{)TD}KNufexAXxKpp4N7(~9%|uK$ z;Jdj4tz73O(=alwd&J8?{Kk_71Xf2BGg#y}_}Ra{sdu@+*Wpot!Z2yqyboaBLrTLcuPOCcr&j3k#I+6qCqf9y0?Qs`Ytm^giA+DKcAi7xlx(vUihaCM*oG`1 z7Q7}27#4$mqjp6%0D zW5#X2ziEgnyKM4D6OAU`Z&q--kKTOk$^`160JH^rKIfAY8B@eufUv2+fB~%{PXujD zG~$r9#(-hKV7d}(Uehr;BvsSNd-uNhThy@oy|O`*!1)jP*(*&C9p?&)ZmiFOMMH5B zrM(`_S!f_v-7EP5t(vmd1gd;+naIX6AKtu7#jt4~gT+9d=V0b&PFI|++Z=NXM%YWH z`K5A*2`8^x$LoZk0@k^VvUVw7EE>qb6@c&hH@4E*Q-mOgYnX^78=2B2W^-pFZoqO9 zn9@B6UzDFGFfC-$*=W+dv?@EVRQ)WwXmZcsJP$DQ=v*V>$H@TYZczpIi||!T3kLak z=J3MHSq#qbbS+k4_S|bYwb%b_jejc>kcFa3I!$0DA_v zjSuWF5QD$>>t4K{58ouk9Geh=;tY8kKi!0x^j}GMv~TO~)S;F2mgZ}OUm8CsH6*nzC{-+5) zBj1J^(XwLOCLbk(+0hF`0dYK;DWnh=of81%W7pHtnGVl)WDN=&#+GS?MIT`j7b&(J z-WJEhn7cAXbwq%QF6N~~dP?~%i?Bo%Ak(Wo8-*%TiSrEvV-hOU#jUI&%!C0~mDw>BnlR6Cn%y}(yn{z#CapC#W(ABLwYM#V2t76dT@=`h zcbo^`{Q;AQwiRX$t4h8=T{8YbRu*@_gu@Lt`ZN5 zSP~nAkB)nmU`!-m#7_8JZV_@S<&{3g0?sk`7I?2Su13DX_76v_8Z<55Y!^Inf;!BP z$*u$g0cu==V{n;;kdK>rA!)TCTnc@Z#VvdnpM%AA2Y#Snh&lepD25-&Z9Bk`Hkemw zp5b6w6;btXhO3{%3@Mt7cz0gR^Z+_^xC_hzDZ0aG5h)tn4LKv6f}HRtEasrncQd{) z(@NMgb31isJW-R-0GE{|3@nKX) z1daV;%xQ5{8xP0sM=GU&o_*L!J5F5 z{Npr{8F*n#`B*@17W*^l2tnI+%YW(&t3k3?$CoT)r@%44Z)E0taLPS z7C{*Vu`rZ-pc)wp9=>tHnprt2&VMd$K}QQ$G-Q~eXZ*Zx5&YZ( z-p+eIZa+WoKR;eSU*7?-m(MPN9y{W(pPw&^pQoR1_ghw%FgaL@W1pL1kfiwqaPcb2 zfn}=kLTn^2%YyI6#2+zm?UmaWm~0`4bPc$?V!;u^KhufQMoD%#9K-(Ah^(>UNJ1Jh z7h(nW*)mC=*vci)@&buMroe>_WA^tC!;hPvz^jwEJT@80{%VKui@kdrvc2JO%GS73 zBLczB0_s&Dy6vz-9Cb3t>E=(HsF)vyMMPNXU3JGZxTsVYY8VEw@(B?T1tQ{b%I`wK z-Q^?}h&&SeO9Uv&P8w1?iAC0d(kiSSjD{_Xua5Uj()l4lIzaF$s!sABawut2v{13` zK!;CM{;%4fJP|L>w+(7fd|luZP7X4r)p&**io$*-Dkw~s_Rmjl%)Y%Z60FwF6l9Dz zeQ;hIkj@1Oi=eeiCDb>AP?_KZH6KAbv-*}7 z22u1xh#qI}O9vnD^KR~S^>T@=xOP?$#@~AF=$u=Z_%{X~7_~&NVi?SK^pkohOX(iQ zhI7h`5p|9{l`>g;B^ovmKcZq#kSppT!QX}V-EY@F?tynb3rl-w8ARAqI(G7?T8J0^ z+ZrTV|Lgnq&-*U0<3qTj>8uT69l;kGVlT{cO zyC8i*CZ#QjT8mc@wrnqmno9}sD<3!7fLmyGt~35W`u@=+_pI`#PNFyq-`c)0Wh@jDTR ztM#N@g+z6F`YiPW3oG7`!Fb!7u45ctXQ6F;Q~Rh+QxocDy3wb8bKl4;k5IJg&)#c= zI`|&m;P2}f#Q*$jrOiojb5dY>xm+Nx`l;7P&44MKFTaTsIL;n)lmQ7fcl$7Fl{&e} zY+K065f&5yL0U{2T&AiVYU!QV|5vSST08h!SKz^fHN;D2=fOD)4!w^&YHXiYWZ{GB z&lX&#=;&6HzSoI$r)l}d%C?Z_roddGN8E&NK2mx4aULmGkJ1xqdW*<;bkO>V)7N7G zcu|F5TGGWAy&|+j_BDYb*f>>R)%MEgk4?ZNvg;J`5ka5|D;N;0>wATU zkG$$8GTmA>%xccs8KCuJRnAVOyv~naV%N5WBVQnpQ~a`WT}GNWHGyNkKq=S!!I*x^ z`~ejYG~FjDM97?&fw(NM1I||i^tYO|LQ;Z!8}|-z@i#w}dKyH~uiX*-;ASfadJ2a5 zA{Cp0B-?Bq^kTD9w*0&=XoCC&&vlJH%ad&DAB6Q^^MD$kD+Op%>J`bB1|N_t1;V-Q zH-+o9|Kp|@kPc&!>xFOSA-PKfp|%lD(5N}7y&*S=F}lGnk>L#eA0>NiNO-@x>)269 zER>vNDugC!u40uz;NMI!dci*bLh}}!!5WThLq09F^6wBAKFED3x?_AW!wCcf6Ww20 zz2$wpQ^Tv}!>cHEc42NJIHKp6fjM+gkiW7##dds3pVZyAX#6mnova;#AKwGte!s zLk(Z70#ewR$Xn-x;b|ynZGi}q^`{#4QO#bVwN&}7fHq0u8oudrVM-Y|`kLXD!IOgL zzU14nWD1wWw5g*_YWI0)9+bStvR7w?q%h6X#tK~P%d+XMsU~}rV?S6tPa{Vsq0?_e zTN)foU8jBfZ^n%!rf9(fSugd5M zrZ%p0M9eUOnFUFp%IE;f|BbQ2$S=ZtCy8oKSemA=dx$YE=T@GJP;n|K!YnopO3+9O z`HG!I?w5K9*wLCZzogAxL;pBl$eGET$B0SL;DIET(K)_hX#G^1`@?gZ=(0q0TBUel z;WOoW>%<=rp~2$PrR0G^QkHbHoqwHvP7szorR= zG~+Rmc!HZ`Z7PH5r#~qaFUO%wHmIu1(38Rze z8#-9vWec%_1fw!gK1kGlPpn2~ohH+7T#(yKzUjU2W-O)WRI&1FTX_EBpQl?J=noJ% zH%h6Z%6PJlKjh%z21B%Rc(314EqM&*wGrTfqY1kj~f}g*^-o z6ISf&4=H)>gR3Gp7qBIbygDZJZio5eR3HvHSvvymZHcyv9YT9AgD!<3rqR2hQN0bz zx{NRAwnTe2_}|d^&vZT_RcPjnG|%)jgigt;!A^T!7Rb17df}`0-)_E^q2)YoO5Ojt#rYVY zo-GC<507^}+TC+FKKF+9Y757C`V(D(O23XKAJ);5JRTN4`%C`{d8~m*ifeSE$?MOC zveiev{uQ_-U^Vgs3|7P^qfeH4)oWU#e|9sonKl~aY}J#$-*nBj4?L+5%CA_(W*0S% zwuv%luWSyb*NH$K56nHLaG8wH`A$AqV;Z3CZIU^M&2+I=;2W7$V1>)svn>5P;6%`s zv*Xy`;od%VbtiMnq_!qWEcx2l2zC#X!(>$oGTeZ2j?wFmRgjHOut`i@ z6lk6ar!qwg!X4NF@ij^HD%mT&?P`Z1MHuqI&z|BE@m!>fyeNb7NzMvShFg5&DFe8# z>BXYKaHd5TsQtd+c_4%G1EGFy1Kd@$qgTJ+@Hy-!j<}(9Y{Uqcv%i9)HkmV`C_g>Gp$7k~A{G03p6;I= z@15rompCap4Rm4)8H5qo8AvaFVF8ROs0A+!t)+06MmKJ4%enPX>k=(DSj0}YC z-ut>3p?WsI*!4@~Yg~TUA=XlCZI#?+pCh?oD_p$`gmt$)*&GK9oHFGMX7#;#@O2u(1?%kPJ35QJ7r4RZ&p!6^A0jS00V(K$g#r8O@6W#R>-->`A z>uP>hM%4jHwI(gHe%G(@t;A0BnStmhuv7%t5E*=#ie2hbJsc^OL7Ly-BM~0Yl z%&6t34Nxy*gi+&=0e5-}6MC6>74ME!(HD+dZ0~Kz^mT92TW0kB$os1*KN#iqh^F4akH?^4-9}tm0&U6lwA(^5y$rldVzellf zJ7Z7o`uevO(~^@hZJ>C44CnnZXvghWNK!ItrKKxA2k?@_0|WjaP@t~990N=n@nHd# zkCc*+?0dau<-HGZ&UD{#X@I*lATM~IZ1w}jyVy#g$QCh|vtuG|I_$@TJ2G;r<4%vz@zX-Ov<-?8#(gSjoyKsdxK(>MV4#+JI= z-C}oBx&s7mng~c8%haA(RLJv2YYv*e5M0jw5{U;>lLjZJGF9zetJHbYI)H zV#0=}Si}Oc6*M#dHUuM3OKO;`v+miDGYP!@3+2sU`Df*UA-+95&@lRFK~3>Lkm?yx zA$zt2g2rGdjJ|NJM8f48udp0PT!ehlc2D)__T7#vFubR79dhxF&3FzOg?5fccwh|8Joj1 z)RtQ$$@(uNdF>Qu6S*2&A8j~M1Yi_dxMF; zcCRmL&WtfBH2iFy)gsx&*x$0d?Zx2I$a!!3P~1Adi1Q$KFWOdxZZFAd>qS2aLso+^ zsmS<%0c=00K;Y8Ri(+8b*DRG8;A0#tpG>W)8Al6EOhLiL@|2h$H^8&sqT_cC=YF>A zDH(VuRw|q@Pj0Vo0x-`Sk$8HVhTIrE0|meOxN`@}ow*0ak;{sOVOm~}EN*$^twN37 z;+0n3eiFj0GUfpU9Jc(m3t&-w~cY@r6{a8d9B3Yy0*I@~C;Lx_Yt;#m+*OKoTC zfyLc+c!#e*6c<1yc!a_wkGS3t)^vmn4P4{&GY}i{j8@F9}*~nA+dK2_fp9E*qPw4LU7lPqg;1u)%9>*#U!ertwv zf6zm5>X|TJKzCd8Hhn+wuHd4 zB$<{BX9;05JHBOzyY!@8d(uXD(FTSz9q3UnmX2_|{Rqxj8F+$ZlhMb-tALH?;dFSx z5X1Y9oSCTy%Flj53g)2y!J3U1L`zXI?ENY$;fL^YqD%MqCin9Lyxtpux!wuao_Shr z?F|mYRA7f3rjvgE&}+Rt*TFdpUAycI8|$^9<8Xw;D_;}q#Z+H9L{B1j)rZ6dh!*gV zU#3w%8^$HLY6m{58XVw%;zu+cbzAw!%itu9hJd1PVvyDiI%$tLCTElh2T=Tg8gKvKge-i^B%Mb?kUZc*;p;`6R%{*Z z{5&dMG&Rq??U&r8Bi*F!wGz7hpD zW`cGh3OVPvODUG?XlWth)Hj&QZr&K}=LW2h@r_J?mgRl&a_Rf`w9QrsbC}AY!kkE? zwlGw3vP6-V?ENGyHxCOL?u|eKdj~;kJBAp5`rda5UOQ;C`w4|J^wjo+L_th zRtib;2DA@+bbpuW_c7fl9^}yL1{|DH6sCT8`kI##&wF6AAyIm>oY5TB5YQ-{t|(Vy z2}5D1-GHS+!OU0%A%yP4&Tp0Sz>lwmGvLK&`8v-V*fimKNyoVzmq}%vnW#O7BLcc6 zuQm{ZlvD4n2mOvgMz~(6uVWeu9&pjbsl?)V(C_@)vrQ#G)9{kJA;3U*!!kc4wYAko zhSk{Ep#4pRudn@eWpbK9X-b8M_Q;bJYoMpL6svJytFGo>;}hety(wgV!a7}DLG5va z#Z~RMi+)UgZ;V};zqth>W2GXd>GF2{w#@>ngvIw@+f}yucZBd)inkSpX{^^V^rt zwGIf$ZENB$KF$aC70QTc}xBj63g8+0?#Od=-c zp$Mz?#s~{en{r~0iF0p_a6SIBp3n7gyJtPov=iAk<`;OF^thimCf$%)B0ugV+>5WN zikUdjA0J{{hi=yJ*5?L^2a;(i4J`XPi{`k5+okE19=8%{E_cQ++3zPN2K*a zTX7AA_fviMllj#RC-uMaMCD|76kG=8n4#PX$8imEbmf<<);}ERhThu%6buTA`C5vD zGIjLrH9Nm$6j>8%O;p#uA|jGmLy$9W>PSkMU!wCNoe+JF&)V!WW%f`ti-s|z+I5m~ zGhY9C^$R`+7HW!C9EeUw!>RU~k&9&CE%pb=@$6JzV~N#we3jV{Qf})$6(izf!vxft z&yZ5v3kSMY1lZ1FdIZk}U_>uv7WA93MyFSq-}1Y>6n^@Pfe;5eJgZ3Q3Hi#OwT|B! z!+T-CgWA(=k;K!EGw`q|@pxtObSd$4we@tpZqok1vi{FtMjjiO`{lI)I8E%eT%D(KB;5+0?sIkvez(#5(v{MZM z!ZWmJiqyl=@97E55uT!!$|UK`ijO&fTUf`V>gJdG26qi{a<_`!H%c2;=L5SGd%Jsl zh2>)pAvccHV#B~DDtkn4Fq}c`e?$a(*6zZ1xc>9pKPJY2`C>J4(>WU?UdggCG@D=@ zDBdVs#WXdOB=5F0c3!BaJ%6WW2_HG=Mk0~@FF6Ros4mI7C`T|Xo6M0xe707}!%P@Y zOg%Z>5?+Dm2Qp#a-}rqMRAanlE*7iY0Ey;)@n-4+sAQZ*JX5PPXs8xQk*m7zda+*| zErjhzUj6AEerps$vCbZH1xB3Ag?nIKcd94$$L$ioqv~IKioEtjbj!+^SfMW3>UBcrzv=M z{ZS8H%|llVVYz8oFaCM#;(fXTBlAD+q)zsZgVe)BTB&iy(~t1Sgh&O0@j>T9NBv$n zi<+S0#TIJM(e-$k$23e0W4pnv*G3#$TG~W!RIY+_n|6ChH($YK#Am{hdjNHyvJ+i) zeTQOto1C>d%L~0(_`q%(V;)GMDc!i0rfAjnQTR~qKy>5~NjWpev=I{GK;D*fV3CmS z|7&c@Mpq$ioE^;kg#BFVIU+0;ksWz~l3N~eix^PD?NziQk&-CV^YVvIw2{wM&iqcp z$Yz7{29sF1NeQLdz0wfcf-Z)^*PLo$a#wG)T`Y~pz{wZm3y=@;yAD7vCA}yAdR(G# zrfZ*K_E2NXYfq#{Fz@4%FUlojo7mi}Xhe9|Eq&fHHbCcTnb@qqOZM>MrpGMfY@6?& z7`0)|>9O5=Gp#3yrz7BTcNrZ09rp)m@@-2oTl0+B{!>ejPKmD*#sbfSBC!gJU4PS% zkbS}`$Ojn;eSaEjz`2fO(sM+1yf{4y3F6 zE`L8;RxSGvv3&Sn|HiZ5A<=mK0CQrc8u7oY5PCSg0FZ^V*eWOE6ZA?b75j?wOMr0R zQwRRH>*34iv`zKhdvMhC3-xf+CzS5Bp;YXXZEGMpNN5*r{<_oxL%z@Kbq|py7{i^F zE^QN4H&fH<$b&arXyRMV86HBv0;4PYG*hZw0tCk#$lZMyO}9$wNt+|Lk1boLy_ZnX3xzLOM1iRBp2AXgzC)CN>Dt}_;c;R5c`ePYRpg(8A1E3 zWa)`1|ESpBywINc*;{ryH5nYf*ZjHv3XXd=lMJ5~zU*~5nEFrGxlcd$fX^@BOH2lS zrkdN>99*WFCev+I$g4si0R2cN!kf3ppMhl z(TX;4aD1DO(ueXT8TBmWC@D6#mYqNMn`XS}*;|$#j%OCm0%Vany%N5O>n+~qc;10G zcJ-D8eD}1#caM6Qqc4pqs5H(ly@vq_>Sp^+QHe$;k`Z7)^vmdp zN9dP%{7nE%K!T$GwB!#X3FZo~$Q)ix#Ist{@?C`Vo9!VvR0Z=Y1C zeypxcuIJ9LR4Hb~UvigO_IkW^MLDa^;o8OM9At6|;f7WrtCJM&S=`nvyv;j`+}XO8T{P4eT((c8NhizY7`+@2KT#)+blOJ*xkKb1TuahgwCln zV@-3lXB^RNO9PfX464QoeGh&naPr%?SqLQgd-QZim;r2X|L7YX7+#w&SHTE;M$qoS z=MS7gZG*q6ioqA5_Phz8BB*z{33RLi?poo{es#Z<4Q42&4knaeH~+6#g>E2msQj?ngOw{5T1_80>x3UwiGv2C~Wy*$o6 zrYFYm%U>JK^CCU7fQ{?L6?0a_JHG*zd%h;%)9qGG6a@}q zJoqyxo|Cfr7V4ie$=vZ-=ngJPiX1)#Zum@li)LDI3ltcSk;yb;p_5K(RM^ByQT9Z8 z`G;!Nf2qhCpZDQqrmv&HEuIWN{>1$asx$_oFX2V1zXb2u!~@+RvIGJd+=vC@W67kr zms!rN!na6SS*t(`}7; zL`3{kK8D|w3rrpLghb-P`#i%%?z4H$vW>X65$vWhqZ}SxtKmWKxN4NCidQl*{HEc2 zT_^icbYKQ$I&0RSjw$k&m&~ANn^ozX0b+R+?qUeEER)07l>6S>OIj98I z{b?@)*tr4+}kY$igK)-{{r57Oj-l$v>+vv zWM7UInM*Nh`c^We-hOn13{EgbAD=*;wT@8`q7!YBKvDq^bm&dkAK<)?0`m%LlQc*y zlQ~uC>h7U0i`DndEMd~sp95J!;9x89H0QHwElYmmeDLYe=aqe6LkaOTc_1IvW`J5)3K4rD3iQ zthmAazr*()(p{h!qdi|T0R4bEg*z~pkZQ(cFtXCa24_6~@Q=<2D@s9VwN}8!gKj4B&?ps;+OQ9T;U@P?ICWRyZonQ z)r!xEdb^Vug29EVV=*90&?YDg$|>h_#tyQ^T;Y^O>KI>`+7?a!f@eD*2mtl6Lvi}D zel&2%b*ryZTGw-@zyh{esh5&^L+Q11B~H)$;8Cl7XaQ+h@0bI??+dN}glF3b$N5xz zj=p>rNOsDz@Z9kc2em5MU5uhrQ}x0H)SCE7%MvJk9$=Dk&NK9^zy>Nnl3L@aqD?3| zxm8bGqWg0=Tiam|cfK28_Y!T585+g7X+wxg7kjQ;#92Jz=@iB-%oSMg0_o@#otPE zTPMhT>^zLiN+6~KxD20jT1stX)W2=9DcrVcV!diP#FV>l;@1Xtn>q!jPRD9Pz zv#V?szyD}!)wjen#<*h3xO4CifEJqCGvrb$@=)2zloK9iK2TRT&z$kK*$`wvx>h~*oC zIi$p&tUVkUgh6UZgqAU2(TrU%-6u@G*U=R0VD8GTQT;go_p0>RC#8txS}8L01B;Fx zV)FAIl)!2!;)iY);H+iLk?_`m@HU`YDh-uu^l~FKrvgV00~?;e#?S^WPjWr>7OU48 z=jB?xd-)bwzmM>zLUB3l9`abYN%ht-G)a)fh6hY`|Q8w z?w^3`Xu>t?+Y^itOAZ#_@H!E66puE7wMWwHyLfD+?f{?iJHXk*Sz-}Tfh8)K$ zR}5oFFUex#*uar}z+J4dTl<*3c=k{J+wK$jLZe_>de1X?4(oEKrR|L?ZSfi*YhWwo zsnx9iLyGef=SFrW{*u|G6Uadph71Z?8$cv#5aFFr!IBI6uPvX+Eco=?Se2c)yilU# z_Ca3vI=f}D{_A9Hvf(P0py|c+z{VJiKS>*=iv-4N2&GO$eB{*cUl`;4=c%|fx7&et zY3aYPy)Q!e?t6V7S&{NI!HH^hu7i}JBx4Fc7cxc>*>YPiTU=9%4IgdsgQ>maV z%$1xSXg^yWVWb}g;D`genF6F({R*#z-fI(1MQ0LDodqTR-ULul^1JJJs_0mT{8K{tnhy zc#swU9hIB7y*$iLVxei#y`kiY4&yQxa3b1;%)~AjHD7YT1!6qKja|kSEa|XJreGX> zrmZx)x&QO0cD+AUm3=zd)e=w!SEm@xjg#h+dqX{Xw|W@A6pqN2+x5ohmU-@)Or>Wg zPzoXUF3{xZW`?xIl6!|HHh@}_EfITOBwGPQ))YMex?6s~=x6-!`k^pEDZK^JPx#?K zhAaeWFFwIP5e1@XC12T=7F+Ty*?0Iz--^RtcaXO(L{GLax%H5>E@rkmTHK9o2IrCR z;0Me8)+c98!rf(p+qo>ly39osePZ9d|1fAXnHWryZ@aGk9ygUAz~@1Gn`^qsTZ z(|ycWV2k=!R>vpO*mPXXNSncMJq}q5J%xT8OFe~NoHtiBch+-iY0HDu-B^YE;WEkd zxG!k`I%LUVS~AI0;#_c;>WimFRR_t_&-Xhtb1%GUS^!MW?$0vLX83-7#qYiSNut_! z`b=JSe@*Pe=svVCs()KbDTk^A5r%K)kJJM8DAZ+*jrc42o`pGPxkub3$22McyMz0-K4rRUqgP1JW& zBq{F;vLiM#k_p{szN!J_RfXtLakla%qeH07Wet~;#FYHmJxCA8mQSgB9}I52Ro?Uy zI`{JheY;<5e5YdBXDM{3I#dKK$m!{l&(wd^%{Rg}O7UWD4)^LhY8Wg_ar7=tSwEZ% z5dO6B0?dhC*sYtV?C+M_e|=?x696c;>(42AlFxj};w|ocSGZY@`(4vr=ekJq{Fz+q zTyN!s#kOdQ10InY5%#Qgn+ad^@ue{$s6G-zi?(j1emY^g_9qo?(uKJUr!U~2o;~OrQ4JDkgh@E;)eu$Gyl;BbR(INzF&+nm3grxO*>2Mm zhu@NM$(1^-iyhoDH9tr&qYR{R9bw=j@pAJ1|4A+yKtSmKIhHuvXrP9n$?@+U>+pE( zaj{}B5?=l&j^b)WJ;s~;DkA*VlWzK_j>Hw_i?*I`vkd~2`_hyzRbEklke!-RKJaWi zx4UIoDj0>OLD-UYd8E3G+t!utojv|KJhG(4G4*5@Dk+q7MC-(UNz=9MQLoVjcA%|4 z3{P2p3M)O9>RvIW>}lKUCf}AR#h4`Po7B}skNap(*wjb0m+nP?8=60o7e0O=Yp@wR zeOY2d??)%B?w*w9Arm+R6%g~&7(a=;6aK3{X+D;KR{7!m6h@Fpw<)m`JjPGg+&<^P zm5eK0RtN9RttRNQpdkqHu=w??=6T{g%gx8Cyw@ny@(N5^%`I%wT?W{Lc=oorusI@1T=bof}ZMS+gd`KT(R zD96}#?0W&FM>6w9qR25^siuB=63&DHxg>GTwjKs|U}yauV=Fw*?I&Ja$LAry}-+K*5#xlG6|K3e&lKpR=0pReX!i*Xk* zl4ht};d@z4`PhQ*h+}1W8a*Qg&V?jsOk+(i$70IJ+F0@OqRoF0{cBQ(Oe1U-W5p%^ zX+!%+@D3$CsBqztU7mJG`B9&Jx7>yl1gJzD0e?6)mMrk;h%4t5=f0ujRG^Q!c;w8W{f`xMh#R;R?oZ?WJJkAV+Du zhj^&OdVZ-_h^G(!@H2`m^vCrF8uh&tiL>H-orumEfp->c5F$MLeI1*B($PO8@pvca+tXB%^ zLIt6pZDsd7Ap@Hj_!F*dHM>$9yT}sm=d;MGmyN7ewt4Fz-WM+_{neZNE{DP-r^Hej zFTnpv`KzR;9~&{_FjKFekL^eqeKhuc58F!~vD-~4%O-##F@6lsem{lP_*@Tz=nGno z=|+#kzms?ZEQi=td^toY=ZG?vp#Q_;Rma@~N5|vo)$-#h?CD`)`DyDZ2wda!a5VBn zg#UMBYtt=6Z&K83$?$#uGjr0{w(;RS0i$Ac z+9RcRQNGTT;dxgl2W;?n2(g#KkB@e*YR7K zBT&Enl-)7FW>i{^ULk%V7-}-#gjsVg`Edae_yryHK{GdD@<*=bNNx+A)$KQyGN=ns zK=nB2n!SPp_y2q+<-;PUg`1cup8zH1F-vmBzjuRDc^^uPHhvl<&f_MxX2- zeT}w}Lnlrr!HZji>i%^VZ;j%8-BQE}dsI-M|4oS-+VNGtcY|hS%jppbTyq@Ufx$5$ z@Pj}YiFd3>MpEj{DlKB&xybZS!c}m6^=7g>uL1NNH9n<=npa0Di1Va)u!`Krcvgk0 z$(5}Fz1VMJuZ*wQivqN!$=0OK=MB#>$L!sQIAmdM zY4`l?!}|?qM_j%GHEshnS=xfxNPB08uoFVmL*%X@K) zWtod*3mQ8cC~K~A4OPJmVJPs`RFI-30}=?h%aQN5y}IiLPfl;rVe^DcENiacVv#%< zoBDf@?@g1pzQy(i0aq1Ark{Dx+&_C^&?2lsipbzgh}Ug>a8u9JO$?nEH^ zrp?Sm9Z@jlNUPbm5+8lYMu8>O#T_I}soPG$40g`wP)FH-eAkMLA4mHG?#1naw;5OR z*(rRf73j6WPO_dCf1%oR&EsKJ=e0+UCyNd3VJ|(arg3AHXk`VXmUf!}g)&*ELR7O7 z6UN(xE1{^}_m?~&t42OYYr9v!>$ZlEwKfWu={^2d7zXK9Dva*c?k@J?Hn5Cq=_FJ= zl*w9N{C(6mGb{a&nF|8R_JzldHvN;BVIfvBk3@%<6w1*+5BAac(iTCM4eO~lUmrz zIq@u8?LeHw(kr^@L%IFpL5FlLN0FlWEUmkq=8z!V50>t#49)$USxO!$Lqc_Xb654( zhX%`1@v1Vxg7`-Nk94XMdZa8{wr_|U+KW2~l>8wH72?Cwwsg0ntLfiFvUvDEgZLX4 zlDi#uq^at=uxhrV?_GMSJcGp&otL)vKnpB#t%!{p$l zNFd+U+dMflq%Wpjsdj5zhP@u8&ULK0Bqg&W;7&YxHNz)J-{QTKh(GNU=HZ+J9R8wU zW`&?Oe$F8idU`3uw`r*G?>#@vEn6Pk)&Huo<^#>ybaBm>-f@~=G@MLaOjxlbWLOUa zyg5!C3cni#OdhFN+)`Rh6=bQDVMnRPe@O|skHdJRKTb++M-&%_jAG(x*oaPyKQ>J~ zW)%mfajcS-jVmfg5hkkVRMWle2Y7U3rF{{!?zhjarwqK~T}4mIF&+52K1^wC(*G&V z<|couvyt4SsEL#L=hmlP9fr-t9rCucVhAo(n{#ST%mfzprcAFtl4s=3UL{CGv@a^z zTRw4ekG)mE%574ABzvhS!@fmfxiJ&W`JILQF5cEJ-86^;4Z<9WG!BfRs!EuA7uJiO0465MxD77ujy6*l=wL~s6a8xDNeFRGgKl|BSte2Q9K{NM zz{;ceIQ6#b8+9*Rl&3Xs&!b6mZlH6_QTqiY8y5;~au`VjE<9JS785E+_Q!hW$Gm-; z+u!Q{F@VZP((qrIV@Ww2_K^IkQb_Akj0|HY-9T+*U#5yv?jQz8TV}XgW~!6MrQbDA ziq${QK0R=KmfR$2u7-?ZCj_sxxS9H+F5WV&iUYTm3vc19_1D-iwv%}>);=m_je+tt z$alf?FG+gcftch|UX|-A%2`syJ0fAY&!S?%^q1DMJ%5sow-{{G5$m-iWg@UTAGO*| zYRJZsd#eC=MEb8kM}gq2;OOx?JJSB91h zd((Spt9Z7P<(GZTco8l)oU^xfJKJ1YTw6VjyQwYE6)FhpMkhk@(^j1btGb@^25#Gh zc)wni>O|7glw(Pkw<;05A4<{v9I1rbJswvn5r+@B^mtWT3{Cgb{K}|Ek%~&uWrdRJ z7!%6#l(+h6zK85z7(_QMeNl3LTiEbzJn0+VLXVoKatp&`g1=2%i_?vr_{vsu%wM&C z8%xpsi%AnZgmz>j&7S1%5)5Y5yV&I;dPtFQiL8E^3?mkbwVh>q=f&1&AWSonGtk7= zNQDLgEaddtn>&-G{Yh3e*;;22^b7?K?K4o>l%W~F&B60Q-0Ep3Fu3pvK6MFI&ri5h`rTu>zkta= z7EB}tpwzPnS2 z^>Z0fY42QWqzsdO{mqrl!#QRlY;9W5=P?YGjo-;qi1$+={v4Zj=T#X-ql$+llO-MH zf-97I#K59qapPtt63x|Wd)>(C6~xN&ahs2X#D@}v0VOOS?`Lp6kljbElWq{RQ_(XI zHjS9oi*7Yy?pz@3)6W^gn*bm;509CD`L&H~^w1SLS)%z_V5nEJ`HffCS-(|%rZXKc zUC-tnQmkV2jkpxOrbD~hXcR%_5&jP-!GJCjmG1nsC+9bAv=A*zw1QgMC`)cPdSNzq zg9VL9F?ZHI_6F`F2nMMaTru}{O(w+9loHQ0-C!>6)}Geq$>ng;=?0i`x_NGKr}m5Y zf#v!~^l#eYf6Q03&z~sTzeTGEY{||=&yS_B9SR?n|23h4<|r!)vRO<4Oy)WrRm&+YkiFc8_ z<9^`t-BQifx&;bksUJ@Z~Gt1?OsMXQmaFz*0&sXBtC3+<*L&X zUpueiJ9p+{o_3n#EgzvO4Bv}8luRlSYx8~Z+BQ2s<~OxkO%ADqXXZ&#gM2KOpL*o) zLQo?6W(bliKRFJveOl!V>!`Z?uV;BSiW0TTxqu>~g4EtD+9-W8_edHy+d=JXpJ=`+ zMv2Nv`#q608v>bMKba!Y(C}2!*CwM(!S`0Pz5k?P>uA+I*SzkIplq>7@1VE|h4=9+ z`cS>=ESO&p%g(Es3)5VT^C&!rx~n#yBPVS?2Hj~F&=rl;UzRpwcc zUUO0PgG1});L86i#D8Yv=wuwW$DT#RX+qHKOz5{n?)hRm2_uF_`Bw-2&OadrFS=|H z|4h~%J?!`|HZN%~U?b4IOHSH?%zkz|1+wr&G*r_SX9ooR9#yVq3mJzE>U2?P5-PAH z;FLYIHW@GbnJ_#`sTLnagFcD`a0^xIqEK>HUXUgSF&le%$HneEt7bc4vH`Lxe> zs|>O1N3>%X#wGJ@n%Un{MUxf)%QHz^DwT727u5aODm?PUC3JFl``1+nQ$Z9zbBSNi zS;}wiNFO1&g%^Nz7ca9p@g9sfH25hZe-^wNFcYbCu*y!i{5#{U{(F%7uuS+1_(9k6 z70*B;Y}dvQmq_exiD)?x97qj8;RrA>r;f*uV7DH!~v(!F2p#ax|~owaMQyI$UX!S<;(rD{Q4EIMPQ3W21<#@sV7j zrSbUD=?~9-HodV`PwNX~VQ#TyI%~bVokRcgZKa)s?hnO8I|kjKfM4wx1rDNE>mZ6? zDa{OYTPmp!a+c=C9MJ*9UZqD^mr;FDaj4bCv0OJBg}F5Z`P5AJwWXZ;`&|3`%)V87 z8yKZKcW40uu`$Kh1d&o$*pVq;niA`@(T1jfx{(d;%{PPV_bW%IVJeD;&JI&jU&^2r z+=_05KeUl8_w0J&oFsl1wRmz8OS57LC%`}e)2@y1wlbn#DGvZ|tLUIW{7(^iU@G`h z$NoT))J1>gyK7g5^hMN@k1phNa;g+anVHxTGB0mEb1QEZFwyYhkHHA-<^mVY8MHsR$NSb(A7a*onPaU6qRa)`Emm4P_ zc02D`iZ%pT7|<)(P%UIkKffO>PDZF*$#iI=pd}W^6HES7D}Sy|HJlL#T|U^UKl+P; z8yoWJkT;UjPv*IwY)r;i(EeSA>bkRmVA2&FS4xWuhmL~OR4#ekfspM|1|aos?z3;O zo$SjY#P{?CHdJ|J8ggfFQ+`7Jl`(r3d&0kgYO8;LM5XxX;x~ysA!y%jZYv|nG`4_}x6L;TrNangTI9#ACd z#+k8p5{ezkRYP^alzhvxho^fx?D-jplhJYkH0!!?~JXN`f~y;rOCm!(46WUh&8 z46C1GAgXefc~r1q4=%iG@5DX@;EHnUr-+dPCnr4!)Tw4G)!f0mH$96BBkYAkDV9*xXSAZh zY7$w&A&MB+_p0lkFAhHnf@YB17DEqzBN_E)7*mlb36-qSM%S?*z)}=3zaG|3+Tcd^ zKTTodn>~SqO^w&yH;qG$*`tgB-J~;d?Zv~il;*$mMu$!m9UnE))Tn~W4IWQOp1uIB zf2IzbNA7*#YVN+MEP?(A?;wl8Egh(Y_$%-cI5*mz_D=X#OGAT_T}@!HJ4UJuUK(V{*IoOO zeg&R-v>l1|#rcuQ;EL>;VRi9xrqZeQDn@f=*T8M0XI9_c>H9)oSj^Ja_vXn2Pvchx zqzZ$#6!1zo?voZ~*Tql7N7t>#SdlB|zfHh;@?Fskc$TaERlfr0$*@;}i;q_+${Z$q zyM?9)JLXjM_V;tyUd&HRB{-xw3XjP5u`GDxxWsAK?|^#to6F}kY;Ko22l!=P-!H|0UY=67kB zTX`g=urlM$m7UvpuC2FoKmQHZuf#(*__?P4J?E2G@x_yG9XBKmh6+yz&-32`E|fuV z0hbW}|Fip`QFYCmCda`C!q?|0?PM>J&~!@95xs<5N;OT>2#fpoI$57O##Tr>{6D?Z zxMFZ_`YA+#yGS!8|=0)zwgvc`qV#%H=G4)t}qq=*b{#&sT(rER4oRQV6u+6Kug z##3ZDX6xEwWK(5(%9Va{e+HE8$Os>BNqs9iz6l+YpT4xWv4o`g#9AjSn;ftZD_z=I z{t7Id)Q$PBajI)i)WKBORuF8W=+j*YMRI4gV*tK0$;s)f>+{lV0!%$4EDg17v@gK$w9C1;M)RrR|CCp+NDeCeFx1b7fNhaEnpqk&m zs`JwYk=$`b+nVn^>MM3OS?aVByMTgGF8Wmzk>p$j(7@p=d!sG~7A1t?2i2nT?UusP zo;FLyLe|L7?K*=7zphZHBv>h_ECUmu9T>cbk%xPZ9F?#&sY%aBiX=VgBO@HO2)@g) zKtU3qk>Zeu*rv`9i$~#x7TOc`#k@l?lHp>Qx39k8Pz`XG&ZH0q5#-`-R0EpGgv!x& z62Avd31h-q^2>$=?+L#uMYFbuNfv3bERu5-;s@zRC$|%BR1c{AVbrO14sJd&hoQ5y zpP3|-*P|Vo+jSD3Q4;&Dn~#2tVkrEi<0#D3sZGgv)l?o?A7>%KTm(ypV1y(@akZm{ zWN3q&Wr@6jTsrvUN;VqGiVE;zgl@1pa%5PMziU@FT%XxXEm)e_Gv|3K7_Is4OCn$g zjqiTPJ+d5Vyi5dMp|&@WSx+`={qi;PdYk2BP>K+3F&lc?xW)9t$Pa5CIIt<43J30X z2obR+^s;qR2t=!d=9MADnzPW^k>heOyyUV(w#ncrE8*g1qdle05#XT7Lah^y(Nchq z_JCCTfRv;vyv3i6t{@5H;Zome>@&Qry!8`@@wyD)wn>8N33!Xoq$K8cVw zTI|^VN|d1p3-s;pcAyXzIf8a%UWbKWd`6i#eVn3{%A7?H1=|=I_3!&XLMyHB&r4e0 zJ9yuRKXqI0FI#_KPk}$rz}NQ*{f`;|IBA2=5AbTK4Z*+rg21auGfhI^A6=@C!X4V- z{<$Ief<;$lU^43?mwZ~>gKdZ8_}`byzW0oE0u(Ner*b7VfVP4~4Zq^3{77=`PZj9C zC^^S578l-gK0MNJw~1m^MBE4m&zipK=hlybi}t$Dp+sN!FJrh;1mu-Ws^OHPr>y)7<{evO_OwA7s(#PnF`S91 z=|uNe8({+r4RR3SdV&KF%>tBk_ovZWY?~pKz-3_eLDp%}aql_q?X7_G0w4G5#zV&O zIK=eH)V`21{tS@^RrC=GKW3;3bX;-XdD3uyFDE)OcBpaCc?@e$faL#ybN;dxGq%OX z77}FJ`7lF6ldp1f1T#4P91o6%!$dLdhLUkl~F3fXEDk8HXxF z;ft?K+3}?mHZUsDb;!|k$RY5{s&nG5HRl+IQ5g}cUSmWRc5%cbvX|(#0n&yKzLN<$ z8B}HhEgNlQ*uRP|kD^6XQ~_yY!p~_4I+UJFJ@(*(!zW&-fDe!?`wT;xGc)fG_Uk4` zrc_r=VB$f%vARX#2Yt26JZYI2`ZW3`~e9nRzma9 zmx+Hs&(V1*n<}Nr?wuMZeEJMP81AdC{5P+#1E#bwpEOpyH3ifmrw3d3`ln#)2OInn=MAyPbjiazvkRR#$6cntKDM?7LTTfLh9JfDcP z)qMtk(@CD_b)RKSNQbJTX7MMfnN0ad!O|bwuFtJ;HRnPq8A#VBg|x2Z5XxL?+Y92# zBW&HBw5xuBb9n~(*q)=ZR!(>q6=&tcE-1sTW|aIj$k5#ev}2Z$OJJ5v{@SYm|CZGN z6C0ciz)M%|v1XrT10P0c6<-#znKcp0!h{%h!Yy}_bgtglRuti^e!)GpiA7l{wFweK zDHT%TE{VGIjU#3y>}$;CP;7~4SK_CE0xBKuW)-Xh|rs*2^|fc41-91M8@eZP6Rw>{SLC&?88l=5)n ze@Ep63MjlPKB2E3{AoesnJgdM zedB3n3qnI@P*%w0vFs^F;scLdj`Ijr1m#v+W>0H(?pN!(75^=y!%4ur#T=mSW>CSB zD(rvOiuwFIV?(1bkH4u$Cp{|Re4!}t2F+7v(>>H8XyPvlPIO^^A4@3I`yc}1UEImf zJm&V1(Zw|~d81rti*P4Ggk727IjQY%JHq4iB3r_^0&iw@NnV!)IbL~oCz1(moVoc5 zR~$Lj(#0YJubUUpZFIWVcnJXh`B#!8md$ zpSa>^SInPwYH@~m3Dl?`J3p&@vD!<1Y{978e_9G(a(c3%qPhWiBM`QobP8uBr^>UE zSyitphm87FBECcXq%ULpTPtG;Bcvb_esw?Uqj^bP;l(Vy;4NL5n_7J5C0EkkFS*^# zsiQ~YH>qs1pjV+lZ>i zEV#eZSH18|n;mx_O$l|wR86t;%hsQO?+BQxAOIY@7&tNHAFitAohs-Rd*PbCRh|Hz zsSX6=t-;K(Y7i^-QH*o6ph)-G>`=G5S&HV<2YSS+b|qD9`F9B|`8Vn|CLnEWU$)U> zyvpleVc_}6&`c$}mNi2Oep2$CN{hxc5sFV5azZv^pZt!^bZYgzmR-xduuKeu0Q+At zIGjQj3tEveqsm6bPzKyqj7-1O%Fdif)+osM{73lNM+DHe7nrN>6$?{`Yrh zv8wCn1@Cuz{ft>)U5QbQasNRTBUG8oO!D;3YJHgi9u?_38ZnJA-Qz9-hHOWPM7Y)% z6Q`3-f{Le;Rx9yT4|ij&_dgq_%1(8FbYDoeb+0D;u-TDVo zb;z*&qQS|go1ev`qz}%GCw~4|+ixZdc{OG2xs;RK{5&Eg1cva)ZtzwyIG$bjl=L@l zJT)?4>TmV4nGK(%@q8FWG5g2DuAFP^pDivUs>MH?bg~A0U0FBWN+~;1r}Sv8$eqa( zZH}YOq-uc@_DrK3Ed^P%Kb zVY>u}S{9`MhB7GjPE7oth2K9{X{+bK);SiypAQR=>?%itw??d}C@-(x6^Zdl8#|vP zFXtB%Ffm@=VcXo9ja8{;x>R4Y>znTWvTBMye`ajK8AvFhihOr&{B=ZVYs|HEBe!*Y z(M2=~J17>ch`z01$u!Qk51GO4VRCE!(~yLqxjN-CfnLLcW*ll6;)%ZJQx#o;e+cNB zF%ENYSqrSyDz3dQxG36b{Z#ebtMAUnsr1RD@W*{uOw)jd5i-1XMCuslphWY$9+jKTkn;ek2>dkn4aSJ>^G*Ub~f;{Qj7{ z&70*NrDo&#X|LX`706Z3F2`C-dL=lUmM-fD2DKR$Ps(ND^4Gp|o156U#S{JZvbrMd zrhVTKP%FixZjm(Q+YdVzm4rSA6-W)*TV^ezrJ1wQp@lEr2{%)g@jSpsTM8)pwiwRB zJf}4+${V^bR-AnDI&U5QalR_^N9*eg6F-x-l?t<+oHZ#2>AtvgQe-xlNjJfX@_&QC!cP4REUWUIsPs-jM5MtqJO4k8TdHHHHUj_iz5lB zPI2zbTG!2@Wr8P*>wqEY1a`JmSw~M5#xX~mdyA39_?mI2y*zwkkS9yh;{bm+v0jAB z&BVaHF{3DIt>)VYg{6;mzcaT8mfE2$x}hcGPR0|?1#6`?UI4RxgV4bIz!~i49)sx8 zAD8#W3KD*GOFZ*t1QNxUa$#)KgF^mb2#aCh3lj6P!7_^L>|AkmY zry|I3NGJW@ZY+yUznt|MFV3zWX4hMd} z^XVC*rzGeVHv1PW&2L-<0?!^Ozc=YxuQ0WorRumP>oEHMnQuL*seWlUY1#nAU0#5D zSo69?apw9pv%4hlo4;^v^?~bqKYWjzR`qs}0S&f=gBtC0zJIpKFz)EXxmp~vS4O?o z0N#J}Q3f=O8q-=P1+xP)Zm21}a`(P`3-0w@taxt!0fV4icnIFQBNSz{a&#;lwtR#GiE z@Xti#gr6VtIrCqgO1K!`K3vP#6vm{VC)NTh`~N8&Ml4VISEp9i*!H8(ZPwypxx#SCyo5Wg7?fh(K>?~_84oej zHPfzTSfd}i8L<8&Z@zRJh2wUvfp^$5V{V2vUiP6XKu}ZJ{8p>1rqEUgoztyVA8&1R z(T&?p-3;K0b6w5KOs0doIb>-S*x}7g_9QLdteTT5m^D^Qe zUMn-eSG>+F!vk|u2gje(&6k|1M`|ZSqdaXmegb+3f;a~QXN;6|FFFL0GYd&%O{Wce zgJX81;+up_Y=;A)DbJ{HdJF0MJR`l44bOMw$6Naz&)qwPTRPSMEt-Gr;GSAQT}wS@ z29GCgxTl|(%=bI4KxTaFQ$bn2`cI9X4o!6`V+R;Ndu1w~v&*e4kX#!aY?)x5gMmSW zhZ?YIXRKF-F3W=ImA<4D_Bkw9p_RFK8O6u5z46Pz0Pz#yts$yURicP|>xf4#^p@2% z(qqf8%T^{T712LUj3*0xuR3_}@}M=*M)fHxVIDhH%;I_JxmmbOsq?GzxlbY#mEBuu zwcCJ7q=kmWr!}E7=yW$@3<082I`BysowI?IJ`HzI!`$NYk##h^Xjbfcd`ep4dYN(` z54CLb`p(~hu6*2+Ma{nYCyk!Tt#yQB2g<9x*0foYRrLfAXQ>~}Qugj~b=u0i1 ztDKil=0p5V7L>UDPAPojoNp$xerc075IhWgGdMYURMG59>wJ+8(FS}`BV66Tvf3|P zAO{g+MucVp7G+pCoZwHn^Q?V}3h=cd)7t%~$}x%;Ed+A|@kh~RJX9~-|6bO=l%a#K zH2gie7F#;n%*KFa=H8+q$8h4ekB3TWA$VD;;s3_k4y9R<0})2thXE0is1QHaOryzP zbvM2;0B`Uz@TM>_Lc+C2!sVx8mI}-qI+|UkpxV&EfxW1?P{fhhyAQVxoxj08Uz1tZ z(BY07^Tbvf`8;>p?A{m+2!hI-Q#Rx zn)~2E%X-NBIq{YA+?zq~$>UARH>WS>lA3~WE3Nx(q`j^k;Xy)1g~c~lHCW`FXj`4x z2X(D3-RHFYisvsclSo+>_Blu8o)3!=v6=r7`TI`TVpGTGu6o&txi}64(x=lO!4(t$ zH(L2vA5uo4dX8s~;0avZG5PFca5D~t;3)EL{ByAGInb7QlofBYvu&O~N8I1$^*MTu zhP9o3UUyzp_B+0fZv*w|^IWQb>*KY&y~+jK_t_kaeVs(p;evcpNmyLPRxhwJ#is+qr2aMjf z^_*+IzBJ$_X^u`hhba`#@w*?1@%~TTJKX4%cYOVmLAm6u(cpb>@;Kp&{q2DtC7Qwa z6nEO>ZJW&6pB+PyOEe(-Q&#kYSL<{huAN){ly{MQBow$?!S(~9%}FH}&V@O%{^i$2 z$F7ieP0+5JRbSJQ3SND{lMx=D4aGt(ZU@2_hofZ=o7Gbq?%B)ABR%j-pENp zq$FuXIs`YboDSar>546(YAZw%GSggg{x{F^{o{=RXHD9UBP13y58Idj!*8*2{D1ka zfm$jayY5$plOvw?FVu;cu#6Azwoluq#%NsKVX*vPJr@7k!!`Y0%0Z0TJe3vIA5&2o z$SUEnlh~KOv z?fsXtjJnfx-L-TEb$t;eKG=KGJxO?spY}WNFlmM{v3{{pH9Zh@2;wRBIrzR`e8 zdzwB|{8~upqnrNIYB+}VD!OfyIZ~noyMdlF4A8+c2+@wojSYD=gX}Fn$RON<4Cf%i zVsea^I~+YcK>NW-!dZ=DZx|7Z>w{>d1eMs_?r^2y=RkS`i2NaAm~*_ZG5HK9J1L<* z=-eQkKP-hELUtOCl!ikMaG(riBQxxf`k>5ld}Jjb<_PMAo%GQ4*P4lL8|IrC;>aQ= z#sTJRg}W_{Gf`wkIQBqqP^#E-XNLM50(ky^IC>YcNMZzKmLknr+FYV=XfyE(+}IE}H0w^72EMI%LM9xD%LM!`(e z+TDfx9&JKyV>uFKQiI9SV9X;zH~2@rt_s+hbFgv{$i|w~YW|E9jm}=H`8}A?T(2(H zur=RF3>x3e2^2` zxGtPviJs(FXq*i!3wR5%!63`fILc0$=%|$HMaX<(@|b(vQ$G%qU^4S)A|x4(04IP0 z9@kVW)Tol1(I(yT3i_AvNM;q@;!33!Vj%&u21`>2Ur_`>t3O*NiI{DALo6|QIWc#s z*>y;`8N@>180Yk0JEU)MV7d_a5-kq61{=fh@y{C%R5gU|&4n+dvv@4-b~V8CGm)^z z4!}<0lWR14z^3c23E4id6hG*BCIBTA8~$h{>=&V&gx|txL|`gtaTCD10Cl(X9j!nY zo}`(x&tW5MvYPzbKHoVyNv#V{j}#{ySPS~lu>Bj%=JD3XY8s9tq+c_Z@}OUUuPn;< zb>31Q%%8DVv0|7=GK>oTXr@s#TDz?B9WY-XJY+t9_qt%6)ar@v@21EYDFkB7eV7(^ z1I&x(w4|?X|B#miE|5Bm$fN~@kYh4PPaKRt|pd%vpt`+oXur6_?!_Dtsed}VH0Ra;RquAWpfE-}|9 zreF`uh0O`tGNlbN{ypq_I|S^3Rt%1aOGz%~7dx1o%@{X)o!)0Z(=Q#P5oTus+vB z>=l3F8=0~5T-|VYlSM8M>6V^RmWFRH7vbF|RiA}?EGLQaQ<{LB9s#VM)Crufs%rZ^ zUnJpA{ed%Mfv4D%I?N}~Bj1TBT-KD~+=HE#0P;E6;BC?f>va}KsV#*=Bf)7vT1^9K z`wH)AK;Go9R`8qS{pu=eB*zI%dne8!^tUz{F9eVu;DsT{aiQh?W7#YaL&{gg1jmT{5E?7O%galD?BIfM>~9m58(oW* zRb^`nXAOkpYwY-oC{;NKInE}CqRc|V&!1X0eg!?`OgiXMm#cHWd1P++w)WRo(CPi?&y@PtAjN|p@FKd59E~44$N6e|rjWG{ zIZn7=t~#8gR-V!MaWOH;qR_Vx5$J~6pa79ER*K&Qn6q4^AHo@_XsAGxtmI_H@#*O3 zDpGO?2o=1(WcTe?)67Sx}(a~-?Ip_5rc`Sfgp;}Dk!cYvb7 z772fOmRM!mU*eN)R;xl05{6&eTQPVE_0|wbP-;QJv2aUVe1vaubFH#-aM*+aliL9! zhC%RzVBQWo=W1p8y}_>RRI}_h=vE@BkQO-<9=1q9`?{uV_s(~=1wQ) zAbt9DlD+d{5<5xtr&678a~Y(qU7_!gsrF(PCm(V6Me7{&bBLC#Yo} z7DYh9i=LP8SV|6m@I%DMbAt&|z9u7AqoePZ6gi)R<;iD{p}rs`D0q0fWOGICU!U@S zU9KMU;E>P@VE8#H@>^Bf4!1B*#;FM%Qr*su6h{qmCpYhD(WN~;yxfUBy!;>hC{Gk= zMJGwYZFa&|VHgIsTDNvoOOxqUWm4!$WX`{BtiQ3`nX$9I`i#!2>=&1?%(A&L>HZMz zzc2ok3u97jyh+0G5}KVqv`X2%54KXO1Ga ziu_@oLe?&;ccy@wc@Rg;0NN~igxcJr7{$V!K!OyfFTiVYawBKhC~ufptR0sz4LOUR zK-C6>%K(XMf?_m3bNUqy8L2m?T(FnO>b+#a1dAHF>6ies#^_o{%K z8+6gYG_+VyKpK{raPFB|TDxH#JDj@ui8&wC`F?`iw*Ixdbc%DDImplg3H zh!kU97hkDUuS)M!$uwgbkdlA{(|d>5Ybj;Fi&%Hb>JTl|DRLPPrH7LCZww;5#+D?1 zS$zYne$Bc1G)6r6aE)+0aBa(AC;!t1HtKCMC@WbB-$gf_zgfMOhW_?zU65gQxl=;M zKoS$yzKKF8=OFVst0D$;{lXM|mv+rMo;N(ezZ#x39|6H=ecR9jey7Sy>+Wg;L2?7l zF4r(_Cxx1z0GKB*<(yH3c#Fv`O4*^zIm;(pEFiDrRFwo9QwUu^pj3oyFc|vH$;Clm|v6hT)>xi zq|uBCh!*XzK2%x?iCJ|o-Q%w#bcRB`vo;YMjxYd$7hwrk#bDq_TDIgQWxmWkFcCRE zX%GdmoSPt&dPbL6kx*Lo?q&ZXHMQz;YW8Vf=nY(QsuG%4>uN(3lW+0G^_f%`>^?wDXS7fb!ARrg@Y+TQ1u3%}^H$c1W~{OzTIk;2#xk_M+X{OlOKn?rZU2 zIok`8%JBr2JL^Y9>Kb}s>1q$kwI9b@#{=i@p_t>0Upd0*&ps>&?0IM-;0*pj;O=$< zPStsC)nzLm_6c4b{T&}$mILnuUT*=?rv(;Zw)+H$D1H{ttc07#4!nQ)LiS6(toDIp!TpqgP7hWImZW#-3 zRc74N7?Bb*+$S5+tz7Y#z#`zj&{&?$wDd1n6-!H%;_JTuPnY)jpV|3;%$TEMnVUL* zzfm1O_*BF;pXFQ*nu@qj$KwdJ^SZyoGO`}PwujMHb@A(jH+P;E4degd1n(?9w{PXS zMSvQMe+xkjiY~r#HX#nlA}XToUO$;R3UgT12aSC)5efx}yM@0FV4F!W#0S*2gQG3DHWFSLsENk>>Y>YnW{}cRM?RA|Co2W-ek@aD!%3EdrB)R_mKJ_CG29AKs5S45EbC?^ zCK2JiA(G*x=Z$tj;9Z?D^<6#V%ff-?^-L--iH`*wYHBm-E`Li%l9R;7dU1I1N4Mro zLhoTL`|FUGLpG~3?61~Usf?9;Q{?^m@zA@MVQ@0IAO!-hn|=VvL4A-?&KpPadAIZv zsQK#YrTtIZUxXdcvYA$P^YQiBH#<$mqOVnUME|6^isiOzUVABsxlcC7m5HQ# z3roPMRS6Ht*M_{%biv#YkLr|u>d$AX#rtg}0kSt8UJqS#fj!$-kq;Z0vEj;a)nb#3t0Whu7zU0~a0fia!bJuDGZt zjKuTW+~sA1!T_$xYb!qA#~2LFqf293ed>&@;pNU;w`cw68k_xXkkH-Jij!}qo$k1B zta_>^F5D^oIDeIntH8-kwe>=a2g?>Ii5JIfLfy&dZ)Tj;T%jZ$i})_vD_&Fk+Q59J z&5mJj_i=^Y^r=XHXBU@~Ad!j2L!(btJ?WE?z_AD#al<0YCa##`EB*J=$0Z4uRFo4& zqIqqu^0G$ZXw&iK-VoS7NAvIwca>Aq(28}gL66>rWw}hmib!7s=hlC5xgNlHjDojH z%rO`y@Y+6YvAyCV^ZH}yl`?$S%MOr?YV+a;b5G3F$%N&EJJ5(g+(!*b8 zgB=LH`QAJbFKwv94@3L|mmJrA@}LG}Nl7<-!2zphyD(lP1Xo=26GpOTRY-D)%JF3o zJQ8a2nXy8DK&pOp8TWK!6b8;HICWgSBcs_8&*DeT;k~3u{p;5i{3I{(YycF3fdj9j zfv?P3G3XKLOvjgkx!Ym(VO@`)FAt;vZrM!ZAlXnvD$a<7cxn6%qcn-{U>U zSEeNhgCD_5;Q{bKMtrGd#u&8!iAUn+yW{?bId#FLj7U~Wuv?;uso>MwG%wNzS6s|h zMyh77(vBL@aa0Fl3vDwFVAL`7LlKWciClV;gYX7;ER(}SYLmuuUz0D#+7UP6A7ygI z8gbTB{Q?#RT$7v?ny5+IK)fS3?y8~W$ZBxpc2!wyxqF?RbbCA(Rav>JI=ZutYo#W7 zu3ya1cg;KKg3vX`mxndJ86Zg=>}Kuom|bFhgifc^}oXG`6poc zV#};WTgkF1f7)EQfFwjGy1DqJAq1B3c>co`XNorJC^$)oX5Li)AJ6k&ZAmOk2 zm1FFQv{$*$y0G5gCYuJpE0Tf$VFXwkF_R6=+vxD>*T9^ZYcr8Pc>sQ#AEn8Y(EOI8 zn#3%VKN4S$OC0&x6!`~#{*fUSrwdCgmkWyrA9y@F8r?1E>e70)jQ-L8@kr}9!+nZS zStFBmDZKGN9@copuP&`8(ejTu=NI3d+7qf z-MmHxc_&VWHCQyfb*#$|tmnvY*^^!wbbNd7Rm-w41LdZ)cxo(uC7;UW8~ixZsx4;O z6kb31z0pn0;)PLZ=u@XCag>~H6v9l>6>H(%Xf4fz>{CNkP9?&1HWO}aO^9K>(wD#h zu!oiRGn1thYyi+iAOEwE`Jk_Jgc`vp>x?Rn5&whMlY^iO zQLvB{cpYwdcx89UYItd5uJqe}p$m{9>zF&XA* zuf@7TNXYYgi-J%ayOa!PEgXWGiOnoD~`@Qve-HS-OlEY~p5B1vnJweCgY;V0K9G@peEQ8q_+nJqcf zoY^k`dj??4>5==iUDW#pYsm2=ej-SLB=LBH4q(sY*|(?R_&a2+w3K4-FfME^dgu|z zt#Ccm4PU~n0IcTU4PPq~ANcWxmN>|O-R~hDc_J5{eqni{WMA$ItM5SQ zIZu!~?eqHBb94o($w~P!i`qAdEfSaw#Zf@zyTI;I;h$k`r9N5!M*!PC8}9xTD=MH? zHs&JfGivaQI7uK@fuHiru2lKA2gMzSL4lB2 zJW0_WrI!Pk7f+~G8vV6T`ozt5A~QqMvUS+<#4UF+9brwW26T@Orn6Ol)X0`4&BTGe zO>wE7`4ta)j92BC8PK77P@DGTvN@+oUoFqmCyM^Xx4{eKXU#@w< zt|a?40X=V2{Ndcam6MzKM8p@7Ap{O08hh+-bHc3Pmh)7|IDPlCASU>JO(+OQk;H?e zcp%azxNO)s8ncWe5nXad_4%Xt0kG@(OTXjCHDZcjTs8xC@M9#(WKdtD6-tO(5%u3J z+TS*SjA;vMP@4PADSeZpf}iV7k!@STa=(j-oj+cA@qIkQ*^fWVj zy0w~;;*bfX<#w0Kt$O=owO*sO*$S`mNnyS+K5ed)&JERr+CpXI9rVg|fQ7Dd%}G|+ zO!oqDm1pL-5%I{4J!36mglu91M%}g}BR`Po5mT*h-!Fe$v0h)WHDSa2z>2-EC1dMr z!J~_GZtI5F0ZoZ2c-T~{+{X=}ZwU?w$j*vZ{K28C(gb=m=-?|LWcu<+t#E%cn7(;E zQz;;o?gi^*BGq>9Nu)frjcljQ8WX0BTy`XDays{d zF)gbj{jk!+j#^|v`gg&CAzZB&x3FXlmXG;}LltnMIN_=vLUmBf07T>#;`a}bi)kb( zTNm+4u)Au01z?L85wOK|2-sp3>7T**LYmn|TNb`r05^_-2SJK{Ih12%r_%V2noB_{ zxc&}}#@Eq+M#bTMRmW#FJ%f7-uGlSr%(Rzqw$^rD>)D^AR)z8u zWZeP@DAjO5@bS2f129v9E{lI5g+N4h|Jgb#4XzIg6`Grq?f)=R94!BTMhcuvaO05S zVzx)BODv)g1|N>lqemt_q%9QBjUR#V2e+^}fBG*pv?`a6vf>+F0z`4SYT^lDl9i$h zHEy76(zPNkySUuDz7~F|PA*gLWO~ba$^Gb1ew_i%7*c_vvKGlzubI?$MT+w}-!)R8 zVm?;Gt9UFhl|K>tuH=uD0K3kcaKyaKCqE^H4>d3OvySjTgW7ju<_eo zO_^5t6yX3rNFN!{I?s7=G`C!da4=2B$*!;KMpT4`syxtLh?f@a&B;~qVTm(GYQjL( z{n49GfH2y+N`TO8sGy+*3N2BjOiu|~+J5c~ODFSs@g9{*rYU`z9&Hl8c5c}VfP<4( zosqq;T#&TjWUio<7Ms>g*6A@ujbQ>+Y@4^lbKR1w@Bh@;c2gNFsj;i48%vhwKw4$Y z*ZzJ+s5xuLT^2xn54mJ*N|zFC<$94^DPG(_-2=&O<*+)BN*?n$VMmnEfMWJIgyU;W z^)?h#ip^)s6A+c@Bw`@+$Nfq!po>i?%bHwQB|b8li9DFaIrOyHp==^}jUxgvuA}Hn zG2=?+iT#K%mPoo8^i^?$ocN>_76xA98oJ}pVDPd7L=!|Yy>=roU=N3xis^|lV=*#` zlPa5vRU=DaVXzC$mnuwXA6LmsVBL*p&JV%<`93=xeC(85Z6#klT~GmFopz@~Vc4uX z5@G5#^ixqb$c&=M=d@>@5=7Jt+ldaPoO7AURJQD{!XZIv9HJumj$0a|t+<>{mnu{% zSDu=wA|bXDGDyF1CatOgAzwIL$Ea}l8N#(-PT`^zXCw9Vv5?#-^+kCdzuzPmzUo<@ zux9c)QVOY{H+;s!S49R?_fVE9=OQTw0$-9d$(Y1>GBcUp0>itgTaUI@Vamn7D+rL= zi<8glD??A0>P)x5AceOxoS~t>;?h6$XT4NqrN8(uRQil|8pDUV`Wcrz<33>5Mm|v($Iaoon;2j(KGX?afQNxM;#3*lzRd>OU0IAzjSQEyUu6hS z|1zwaby7zYSMONWmraxzuGKU>Js)x3kT^XAg6aw!I-#GBfQ{IXy{D0~m0ym5iBM;8 zfTUO~fk%?Eg~e&Ez*@3yBX4L~0ZCPVeRUwBXhqS^;svtKzpVzU&>BXN$w6PE0Z(sz z!0YweFTuBG_rGs*zy3ZQ#sRN8f4}~<+55!=@ZQh=I-dLH_t$>w{e3RaM%BPRPVksg z;rlvKW^zx#YZ=%3&8Xn}_+T^P>gUp^)%Uo*_a{-8n$?MVo;a%LWXoWd!5OI$sTc`F ziQk*?EuqF3 ziJsAtU#-qMyHKf8$*@$y6q)8!UE&;*Qf{(ssK5czp_4vOx^NOMHTn1NV4z%KqOg`| z)D@eLHf?(?$u)cEv6Tg{)x|YN$h<=rr7D&b6IT-0wGtM2d6Qv2-sP>+W0o?DBV&}3 z`Y$Ycv2IbO;!qVoZuMK;zG*Ro_&ry(xZkw6%T4SZE1J$Z8OIWPL!{#sOC5rMgwTZW zvJw+2s0>zzzS-x-sH>Zdilxd)TKH@h%$a1)B>{1c{pf`7(vyJL>7L6p3mWFU3}k*4 z7;;K-x?uDV(in;a|AX_zMCX+`QOK4Oz=C7?x0Y5Wi9`vOi6UV394`kU%9 zlO>BjqI7zfiUYgTE1PKL@6CCFB(m%%YmahuX%@aI)V~eM#O3O?F~IOc74;T|bpJI> z2hXR(;%<5A%YO@eWrdsPV%xrG zO#lrsbpiQ`QO-jAS^bo?l$(|XCso$vl2_N6@;JOGv@EwAloLs+HcAB2cy*{=m{}^y zy5QW)zUO+{uRYY%d4z#jpI}!F$*+UFRg@pW)g;7u{gpeNyVd&2+y>Oeipc~Uf|YFl zlo?=U{zM=&uTpQ;=`JcYZ(Nx?NnA58sa2a<=ESh0=mu_JpzJ~+j4~O!aLB^Ll@|wu zb#s^aro%GpBO`8yeiav8CQ2?mjz&{Z0;!tTB&vj$l2HacugaxwUDIW=3rVpxc_5iO z5;;soAXL>#2Ox!pSZz*l=5opd!uvHo=1LrWM@k+Zl(0z&^Yc&n3<5a8t=2(6Z1d$| zQ->d83fG+$kxgkFr?YMWXLgaCfM*0EkO)FjRbs_#NQR-rkgYJH8ss+dw-;b;+5_!- z1PmYmNVLY~!&n&DJH_F7;WQ<>Wo2INfPqu}_idbZp!PKmHQCUgrGEed0!60MuD_V5 zAmW1}V884|QHHkkxqb(gq&-y?f0-q*5Th%s5CcZ$*}Fo3xXsMuGQL6T4CiLXQgRO( zc7+N`vGpAEbX`rDbaqJa%5c2oV87gVn5(sPxl}11p(Nr|w~s9$b&_TCOZ z_TG_XRAU6wxKV*`&4h3>uwYC;PM!!ruT4IhP+xmY&0n)r?HRdgMpTrHQ|Oxm*mUu< zumlyU;U)ipADQcQx3aUTJfdSdFoJB06n6>rxER>a));~bwQgio3K-%$ zu95iG3QM|Wzv{5PM!fVrHVjzO5XnYFk%8ijH6x&JLe0uu=P^?W!%&vyI>k41Qie{L%&vtf>>djT;z9Z zkkMnqa4EDvY=*9eVqI>lh9dJ1=*w-R$9+!k#6lVwUz(ITzXdQzEadyq^Qi|xRi6FR zH(J!L3jlp%E*hmIQ7^Sx2C}H7A_hT-m0Es*{|`j^dFTb&@c1-&pXQG*92>M7@wiWl zt!P_F13R4LNmgO^*t@jiuG5JcIFAkpn-+zlQ;-N>4|QE3M1JC`UGh48*4wyl?A+6D zoJSB&V&oK=rjiBM{h2>-HNt&|{O(N*5Tt5DBYnV89sOPv8@2?x9!?uf5Uf*%l%$e_ zRAIu9l}DByQh}xpTxL0Li~aWJf}wB6EowV#iHU+X+YUoe_!sUB)>(H=&IzE$w_tXz z2Fm(iUDj#OE_|-`I7v~SbJD8~)1tcZC2DQ8!T_w5R#G_s$ zt;DTf^b@qRrDPTKtE7_MN|qwx7?U@h>;Mu2 z7~3wZt|A}Y|GqB$eG%3?6KP%3)k7Sswv!@NU$hhb`_;PYI}LB*Wqoe=!>ET>=idC2 zv)m=qCSf2Tcv4aXulzA&b_V(~&RtG%e0A=t2CZtrF2lVsB%uC4mGiOki)BQ^8 zB)8A7bM)<8nBO&|bj4S(HP9)Y7=)^Cr*ehT{jmfPBC=DJ>6;yj^zK~BTI~LUpzI(2 zgrMvZ|72RQO?LfLq(HdfAg@Enj`<_AmSwkL!F6EBARc2_$S29Sh*R)c+%M<5kX?I9 z{1n=~jaCUToiw#J8SyD#GZ0bcD+sdXh(qnS`a0>+AUat_!0b|9Q}KUM^%X#MM9a1~ z1b24{?(XjH5D4xPf&_=b-GaNjy99Ul;C66#*L?1~zkdB!HPf|gPtWdsrl#twX<40_ z!+VzlD>!^-Kw{Di;Q55%^>E}IAsYQrc7b8>Q8f3yXlQw}6q;u3e8i;iJ1)TmS9sJ2 zQQxqv083>e8S(J|_7%ky=27Q41~`IEUTUw_UB}JW7Fb6!U`tRvy|d+|VyB&HkFH5e z%}3YL$M-)OhM6?hJt3rLc5n6Z|Dzxs``O?KF8G4=Z5^O^u9rSZ-8`i*1I2p>A?n8~ zvqPrr%}?}DVO9=5Imhme6OSHrqx=R};0uN`8nKK7M|`$p^&@)$BY1kp`bliVj?$DC zx;oKfGcTx+C5vBj!=bcqT{@v)n=jy@W-SHxGwx7Ua&_dkklcPxv{Htks-+`62g87C zB?8J4=@VtKc`E@nAzSgq zkM@*NIeV>Izxg|O&|oMH*a77tR8QtWI#_Cg4hER|p3wb`uXon)^)KS#B@aTw!}`se zy|%!XabzaHNM#V%Zh{^3Q&&vOpR}_ zOrQ7rkINSQ0+HW=v)w%gmI+L`-15v%?karp{JXuk1wOil!>+_(@PIuR&hd!|l{F#* zapsEqo3VJGfn#K%BkoY-nHzj0a&E71sf>HGEy$U*_>sohd4CVvp42_9PR_z%TMn`4 zYhFR#3sZ9a4ej=cBeHLz^Nlj(Iza7(4;Q zIhJ-|gSH%fS}Gk<6t`Z_M^vlX#1meSLxq$iWNccWlMR=g_<4Nv1_izK4_B+9mReO8(OBYH47Eogo22wMV#y+iug2XThJAH@@wQW$CglsO=|gV*6um(P+DXSw6JFkb zhM#sTAO8p>;wHIVgNIL+;QrRBnT)bGNdK=6qCD+sRkc9Nn$yY;)r_PaaS3~^4latn z7K66zVxL2R>+@HaJ(e+F%2m$v=EuiYRVQ-b|K}FB3wbrwgCwUu7*sE73;7v(c0GTC z)D?(5&PZu7W?1}YrImsJJ5N;@t4>PxcrQr{!oz)-M}e`{OtWRRQYMDo7Hv~02j-!u z4TDI$wo@lduWV!e7#2Gu4HBHVE4~T$b93CxYk+)0hw)hG_~I)6YI)}5e~!hSbKR=s zXEfte8A8%#o{qQrrtO6kMkHOQrYK9%G!p3MfB{H|tIjJnCa-;SjfXJ=SnMLkaK3|s z=RI_FZXB#Bx`-5go^l!k$L+#=_uk;Zh`D5eebug825ZM`)jyH&p_qfVjG3yK%uT>g z3Du6dzAuu;-Wf)||LW|2U%T4`vitnBsQP4C-ya_Z|NK61^Gls)%HokRs;T`M(_>(? zjqBe+rI=F!mm&_8Np^K`)q@7%K>*QO})SbS>KO0B+rDscUiLZ?PNyGKXHT^^^(WUkeg=P>~FwH%*c*0`l2 z=l>LHre|8SVrZ!la@`mgg_vS*<>C2R+hahpt?%Ed)K>@Ll@+88eLy9j6AHiOn??;A z^0BeY{dPY0JjqvnSxcOv3~>aaXbat4TSscg0z&v5@f&y>C>H{q<`Ly2iX+@iQ~BmzXybu!7%aj9*LMA&!SiE#=-Rldy9K?wD`0TQe%8|ej^dvVr2 zm>&g%z8AQ@tUP_la+8dWx$T~a8$SPN^(n2K4_eJIY)@5Yk~<>baS+gh1*@9s)F}vs zcka|F4aMZ2{7QJj>Za)YQ8cfNpoH_~5rOWLT^Yh$*=st*0JJe)v{rq9GRyQF%j#~$ zO}rW%>bk4a?!oR-4~&V9yi&KUubtK2KeTCM=(N~hFdiv7GZ&;7cxzkC?_5UBsx)qzZ=8yZ(BF0%;Se7%DT>eQu4w|~Fb?BC4QeO%~VD{BG4@27X0^*+rS z4GLLc)GcKg0BBF>7y0r{M8lK*$op(f%nGbz(~KD&C{f@SM5bD?lApT!i9~IYZ>nm$ z<**vQbm%WaqD4m+opE}qUIUq{-#w#$pteFJ*79> z@p&zaJ=pA%PydDweA<+u{InUq_c6!Xg0S#&xCsSdvB}C4IXI1iVl$i`sB@sUVRWWe zL7Ar9;2eF$mg#?|i2P>Gh0I`^;RSAS?#w)sXnzvyuOb)fy_Us~D}c;=%F|J~dsPqL z8O7}t$qA2xHiB3L-J?!@#B%KT+LPDycXwf4RE%$V302bqS2UEX0FF;VZoSK_Gyyp! z3z-@C)tY%kI;$?@%BR4l|Nq3gP)TV5e2X&ei98z9#|q_a!>CYusSgaK^$9z!%sgfH zpi0g_3+_pluw3~@U0|`e_YzsxDeBgJ(G&K+M%$8_U++{l`%(Em25QtBod79$!o{XA z@^4wUOOlWg`3?J=u&3?-6Z?NrfW+7BPC$%2;cBxR;&lWyfQU@LthPGvGe+ zt||7&Q4!A+cc=US+`C*rlP5eiE6bUoZ$01zbzp8yRs>_0LBE=b%^||n%CKYmkxwGl z_E^A>R;SE)nXI?##O1Y{AN|1lqetVT1Gp#r%G_IYjMoc&!1f&MxX6J81U+?DS_s4} zSMPnm75dsP5sc8M9->3zI_}85m?>`{&T@rxVfepp+vWTkq0DSI_d=iAsL#5UA11u) zmdJ49cHP5+t2ITRGDIAa44ABOye|2i*XsrIRnCCl5L z)}G+xyLM~vRFLR-Ta*bznVR7ZkFdr3-Y>fHueVXjX>;E)qfw-%k@t~a(S~IIVuPyH=xO=tG zljd@(4QV+yX^505%MCOc*?Jt~BBy;ka|0k;#;O_^)v5#^K!l_4)@-29dOHq!p`R@1 z>zd#@L@bIyY@j_J>>3+#GnLjZwR-zk;a^!FNhhZZIK&`1 zv|acr-QX`%g=HZ9kjNP>HSsM{YGU;k@9JOaSiNeBs2&ssBscGWE2pXsKA8bodHz?N zN^g8>vl(sUk+!iCN7J1k9uf*1etD(wD8Hgv3S0J6(vK3_=J4GMS@t<$;5TMTq)Q*! zq0@m_OqXzxmBG4N#NuFuq1-R)FPb9mErs#2dsK%|{Atw_D{Jr8$kkqMf-bM1#X4R?aZ@rWqbtNM7jjTVa}WoE+eEu6m;4w*$vYUboY7Pc$vW zbcZregot&z7C?w~(mV;49$e_qfQ^k9W>sNflTy1XEmRZfEr=IZAh)oj9humbi#XLvZNF zyefv1tdeG^2&~*45wcJt0oo7-NE0(my3u|J5fY#@(6$GfZzmtERRosyuk=k~fW&^+ zA1g6jDn6Y!5TcTZo=r9+8J2rCf|^`#HZ@o=#5CC;bGl$t9wJA-vrKOn;&gCQ{@^Ty zdvy?$8fgvKa-6lH`8FJ(22{e0k!bMY3=+{v7?zVFR<=0X)PqFm{Fqs=+21zjym0LJ z6?Q)SK+ zF6-Tp#B?rVQ`s2=mkRbKkMCSQnGNG z3rOmU)L1l74c}_YRN}+wob)6EX(Se3!H&r&GDQ1KOT#F2U8WqFRYRIr)A<{dzH&pL z(;UcYoW1mz{Zd9`{5AEV2U3hTN|&dNQgki z^@ND9)&0t!6ZvG0YDAL3TUC+Gr!<0m?2}uKTirOc5~mF3f+bj`b5L@HjvGN=?m=S3 zTm{MYnSPGYbmQGA$mu#o)x}Ko-~cNgQt&Sf1-xQ1a{OOwp^~pZu*CZKhhR4$tiG?u zd5F*2$DQ|)AtMF2Ca_!~5&fVk$`h~87xjI=*9P9N4@rc5y#Ebp3^GkcH!#9EBMWE~ zKNw3#h|l#ToOTkPjU((sxYk}~7!!5%POuNsD6-TUlo~pxGS{b%63+3^W9U7ty?(5A z_#0dQN1SI`Ii_<^&^G}&zp2;m&Ae=mR-0{?xQtV!ES_u}SMi#7CZa$L$h!n@I3;fu z-Zj)pSXG`pnuz2m(H8|#9^nNWWo{49x$7h-iN79{pk*Qk*ne_9U zMT&Qb*YO}-zL*&cXqt!x>+9m`73QP$8-&kJXBvdF>JY9H7YqV<=d6M&*(D`@Jdj~%gi4$}Ac54O%#MXT(Lz0^69J-V791WiDU(ND(2Wtt4k$Ew&z_krlwiiccwel@-$LN zN6r^gMfU5Md(?L-JnLw6)^;}19GX~Ai1wk_Ee^q!u%8_j<{_mW;Vd@#84Y)U@;^i++J3JVECd>bg!_s&dU7P z*GLO3hx$}w&Qyl4a?#zr!QM{WCyYW|;^nFEY37{Ml^3pz*d-p{8I_#BXBQAloWkOQkotRjDXi@#;M zTF5mTi_L<%ICh2gw#H>&^|yedqacz?ejj{b>wtRq6K#}5>oNYI`o^`5@@(*8`q+xe z^phlmj5AGzb>1LG2yqrx(?nwpR%#} zU)!k99UlMEVd`E^R6SN@u&-Q7WkmMc6bMfGNK-nbt&GBteKGUO{@Lxh^3W-n;BO3E z642^ox_Y>%-yXg zGKqA_T%MfDCJxfzQwhs!s(!bW53ZP?`A_-cd3RBd)qYxJ+K*# zm`PpdMgf`gwT^d-drg|rJ|XqT{~SV!CYPQG&v)-A!ah11k}O-%7i_Ucdn{5e~pAN^^tHT1X?FYuMk&HD99*c}%8JV_Ik0%Vf2dYQp67U-xr~ z4~!iNmloOKa{xn%8uO3okQwMFhL zg`4lF!HYYL{#14ts>>17b|D$UqVIRt|7kb))*t$>3Me0Ov4or4l`bd>ViBS~AnSZb zT9UU~Bkp(CEWU1-h*w``LCDGIfBh@?enRr^Z7JWF@lCzGF+bBKx1C1uw2TJ=~$kA`K1S@E74R=Og$?>^|D27zH-Vgm(jxz<#ZPZgm5CVqaE7 zKRkwJp~}3#rThr1`!k-P23pn!q*c7{zY3u}CT$K-7XT9{NIgt7@t3IUYYyOWA52i2 zuNXq$lMS2T`sP)hNI&V^hfX+qhQaXQOtAwNmf%Wii`@f%_EgYql4f45hA+WME80GA z!{xBqiOujwEx3Utx7u{Tuq@W^%5$kRY=RxFmp{Ywgk}6$2RkxP2?+6pBHc`saW|Jf zUOLDF5`pjj1VcplVaA#Lr#FKs-dLW!oC8_O(mo?2ortGi>5&4RUq!618`*;^oHcyc5%ghmC)MWi}V(;b#DkM zyqvNR)2;7%&3VP2NkUR!_=FWJ`iLyNN%Dc*z2geau{-<}z7C?^hw0dJYe@mmKB{iP z2ZdES1tQroyG?mbusu(C^cn%X{B_-qf}=i{vaP%Zn~&2Lut#Va{EtT8p9$Bmi=Iih zfb(isVVKJPQ@GCkW_PtssuplCu&HAhe_XdosuUM5L0q_PkN402MKRtg?iTr=XJ#-& zKe6w&9pExg0^R3Rtmm7dqf5_@nwJr>PsZ| zeIB2QZAJb!MDJN|o6i1}>C-g`MB_(3K%sZbg&Wdf=->Tagr)DbdFQx6N2lS&sNdty zCcLW~94G*i`GoxlspIDd^wyK&xeAf5q7!7de0xg*wD8tu%Vdrr+8EWFcSiS#yoQpU zepSsp%$xgK5y4yFg)}7Ozy1X)P;AOQeLLb?zi%VURp=x08{%7MHTRYD+g5eEIsVn{ zJ`?wqS5^DN$iFia&-F9QP|T@*_TqV*9yX+u;ia;pGB5MSSZ|E(s1obBj3?u}^+6zJ z>*Il`PHBbq^!t78gQ2rx+Cf($O5iS`U=){=vzL^w$Ccam?mp+!KiC~*OwtrI6f~@q zBw93yl;%t{WWYyPzWKZy>C6(77+e$`oh7=_;6}^hO3O11C|~AXGjcvU8)ubLOX_+` zK6@V19$#S|*PdOhj;mPQtofl`rpBz=F5uNR@a|OMDO-^eI$SizTqDW+tE~g4yKyC0 z{GF|r1WQ=!M3e2I3Q5ut%iru=MSD#18qPD|4=IE836P(y^nFG@_|FMe8X#hws*aN_ z5nTOMyXV_cL`AwviUB7)luefn3B=lh3*24BAZi%351gI$5*aE23B>)0Jsi|SrFg#a zzIdV0Ldb+~_y{V#&U4(DB@arSP8nuIzb>Pw2U5i<%``Kse<>Iu>x_y(t^8{)Bw~uF zgjuDK0s!h%V|TeqvpfMqbtK?B%Jf5K7djP(t%QHlfPj&OdYc0whYL0Kc9s7PNhyNh zarp_o7bigiN%uJr>%{xn$kiw+my(CnPKmr~WEi?eMogfaxJsu5-BpajxgdWgMVFj1MgXp!(cXejZR zU6Eq)>Zg*~a%0Ny+L36_YfDThV{;_98Qml23XfU@1UebS5Sp7})rz>7P zK2ZQ-(3aP7dyWD01+hJbUy?h7#>j09{vsmK?MS9Z(8Ct=mzxAa)pin#d@0=GC6k>$pD4r(V`dl_?tNd=(cO=r2R?)Dvu$!GV|^ z`7UziXc`9rWFSH^d0PD>{}Ev-B5D=0F_Eb`H5ez{y(4e||L-OFQ)V}+n0z_V7-%Y4 z)tnZIushIs6*)nSrS3Yjv_BXCLlpx)^Im`o|hOZTCWpsUv^mLK!gWoX@1@Wg*15x`Ai;? zHH!|02v`>y-2-bq8(Dzjqw*bwc+JP~)@Q0;_e_IY(d7HfH1O}`bPE7p8+!DFGZZm? zHT~^gixJS7{>J=;Xs>;1aTo4rPq>{0u&Hk+Z+!}HzZZRQb|J`3%`Or z*D4uHv_GzyZVjRbTv`g>B&6x13q1Vu3F*NQ1o^D|W|+p2OEEKq=D+AHev{Oh(E6D9 zg)#Ty_EJZ}-5Ykd&*KSbq6=P;2zu~eIk0Ve-FABd{oQ+i?|Xn`%6GSq*{@%p2tG23 zYBBybQJ+$OM3$_hAodF9!G;u;(7=XZ!*=4$#k`ewvj;(B{zXP?%G5_j)Ra|KMwC<> zR6<*v`3<_IQ0Zjp_e^C`uHCS*B)~5=3qQH8%`gGe=P6yFpcmJel6}Uymxc@{oZoR z5+Lv=(n{?)OMjvEDa%9qdoa{sp&4_D_zq_QDH6p zX!Db~+Wg2d1in>8`Y3PJ3HvdIsHBd!uklxKy(y4C*D|FlS|F2eS{#9%cn|?>sbWe^ zG^9&crakTh8-ML%XrKL2rsnt?6FhNWek0=|MvOcyq+seV*;3zZI@wEuuV;;VNg5_K?rsTH(UyN zy=WNQN-XLDxMOH82nO(ksFhfO>4EqO3ATi?1PKQ2m+(Fw)y)3Wac8Ip8cevG_`;3g zHAR_c<8~JzWJ*0?&$~+{F`P>V0Q$F^x&&e|KnmS?x; zt{!YSQV;Y$f}9ENFr+T?uyv5$>t6(th}vurBTgpLAM*+K0xuvJ=pVoJ>-KL!{7nE! z;uaMhEKjke(@O5HOGBhR!lTnV;qfLsc!)zj!RjbhyNSUCmn=o=Oag3SJUzcD8fT@) z*~4^tljl~o^mu-RE$``obA48}$6<(`DndHX7Qldm>_H)5o-zQnUqb4#zh95w3_uOK zj=oatQ6qoq7D6q#wGS9}aJ~raH9$smnz+IUjFnY2AOY7?5M^2=At@*7UO~pBfcYk< zg82N%{pXo|#xf?tbL~-B-0T@papA3e?58N9u;lM}aN47hwpH?SkY<%?k1mj)b!ja4_1ND|V(tzUbrNo8J*aUu z5f%NKJeQ7xO^BtCDJ;U2Zp>d9rQ)0KAFKT66CUh?6X%#QsXY7uLyF*&8uYw_T!1L3B$;2sef0xC01``bTJtpOSd&`%eQ z|D~!rknx4yhymxu39cDfPe-SyFUbqC`o)IAck@?2?MlN>f-Z_?Pk||mT5SLC2&qht z{t*s2SMD%`{${nCI8;xuW-$W{X+`O`jw90+wDR$oyQ@>57)&m7MEd|nbr=N)-nXv93_62I1i&u zNNGVDq(+Yvj9j|_qXqr$M&in@tjMVv13Vlab9>=MN6ShL*O1OEdh-$XON5OUjNtJH zU%FWczWnBB5DoI0BkXZ{v_;Nu1(oEv1x{@bsM|0tZTA+AaDY_F`;X1p$s_H2kp!mI zQ$o%9;BO+LJt89W%I83GRaVyebR2kv^x1Hbyw|Dq;tbb-`;sOUoq}fyMZ^J-lZ3u< zIm;JwZyH(b168#@nUfIm45KpNp5f&LlE~w@M|BYQR2OW@e^QyLf)e0O>r!`SQ7CBO zEhaVmXV96;g(YUmEpSz>esNI4Q$*yMk8DCaqXqjGSxSm#t28ydX$wYpcG}{=N>r!f zKVDUf5nbZ~UJFf?H#0%!5$nFjyV^+>JI6#4sIh+*ubnG&+U`6D3k*pjsPUw=n*3hb z_Ll8Dmo%Z7Ow(J(}tPq-PEuxs5Jm2;=A}``F5Q2?+{e*@pB_Qa}$ZsY+iKCr< zgTp2D*VkOKJH$Qjo&KA??r*_%|NN`JidYgzo%&%%OEoVOCb7Qr1b~m{obLD8uq!(YW+CGPH-44u^Foh@tw|!& z%aBK6;q&BF?Xp!~UkF4QFPIsdr;6FeG$B3O0qVgwH`u@y6ql;Z!3$*fT?(-i%WnQX zM~Wjnvz3?8_U={He;A@$<`#Vx#-yw3YNg9zQ>%CJ$AI}z!fFK#Vf5%gQ@H98}Vn2b*hgB27L3r8q5b5UB9zkTcVpaYEB63 zkz7xtIt~u6qTRt;>(x;%zjZCVLW#&(u9RBtb8Ln8pLCo~%Vi}`JG#w~9qJ07E-xvc zrMbfY7I7d5wtD=dN}6)9lZ`D3L8L zeK*j8U*Hhcr|}!U!0J%(`y#bTBl3y@mQ}}v?0stbX4#H(QrFK6MYnH9;N!&KaCxWd z*mC*uciR$g>wepW_570FN5^Er?In@*JQu;otge1G^h@&^&iUg<8|u+^Pq3IEponcq zbGO`s1JC>KJO&rr@`69SRwO1`VqiBd+$e%m1;=j%5W z{nxbdkey-TKe;?54d+u}dxsv&AP#u4sk5vY;5`$WCG#r7wPq&SJzI5SjtZNm-Y z3(eb)+kVj98rK~aH-Dh)nvE$00S5x#R`G>4IJ-zt1j(&+iq6&ikhS4)-D)xaL_l_^ z_q}F+_Bp~!Y2C%vaXT`|M;s+3RZnRCu=Mfk&n*+|D{!lMV$&SA#?%X3gf|oq>?e}* z$y?v&W!u>5<%%CqvtL}DWh&ND)6buJx7>VmuP|7Xj-bI&z_FnO)=Hkbfj6vMs_V&V zXAg#_aJH;`oVP~Z4=i6qPm%(hCt@h3E5TL0kJeu3mnRtF$jgtAT0iZZ<2rwB%X_UW zkXws)o0-BE+~yJSdE}d};Jy&Kmv^r6Etc3;0m)?b+&uS@pkk3dII_bAtN?OCjvj22 zC9Lm9S7VP5H*;6_uBZczj(WlTq?^GGP+HG#;g~*QjhH>@A>Zz zOERDzc2-w`mZex`LH(6c^JWVx?UBoh8_iOKA!~BCW1Gi!Xs~+!3zZ4AZ$qm+7 zffegpfy;%uZP(uvK6l4LEi#4#VrxaQjc%cmFI7tC>s8I0-+MA*o&Uko1v}>b7p;8o zeWDc(-v5PGbQRMnE0ES-F+Cs<(c?k*1}nZf4p%~#-hedAE#Ih|T;y>cJ;u94P*7k{NFRD&TkT(#ozG{v@rxukq{iTm%@jimh8up&LWW(pTSQsj0Y zTL1F3n6g5w5i~c;@)L341LvTGyxRE_^GPderc+UVCtZbAycF)dEDsOv)jUi5OkY+A zI|uE%q3@p8B(9UT8pBLwODcSl*b}(zJL#Io7W(Se2>yzOO6TbqN(;ja<$boTM*BmU zbXp01q}_{&&2f6R?$BCw1!SzYko*#a$S|820}dEu+-VZ+_Z4L$09J!BELwmUSPA4Y ze*&oy9CWT*MOg4d7`h4gN04lqOrXzDKna%?Lm&sOsedQ*LZP5ZaH$MqPao6SXMz40 zAR1DNx>Y(3zh$}ifK`o_9o z!wX(jI{wxJuw+0l$L?ty<_KFcyyKVMK<8e_0a%aUq7ss24_H{6^E#^0@_d~6EL5H9 zow*7lEcpTEfnul#l{zI~(O_Io!{GHJmaq`c+K`9D=)8@CJ5_PCuF&8sp^DAY9;ZrB z^XN*GdMEmI;U>IA6llH-%;DW8?nCA%>OJpt@)G#;h$I0?%!nE^eUhkV`}CXFjkC{Y zoPNHZ{U{JH4uK2JwZmRwoi5l}h>Q5brcFJ}+F58&R9N%@nrrj{MsYOZqhsfA>(FNv z;5deoc5zmfW(;t+3T4{G(4Pb<>~xgpT_(M;rS#ZOq&8txzOvADKcWA=j9HC{Wzrj- zCDhAufPDe%(2=BAW{ooi;gh&<$6Gzk<-=6##288Gd_xSI;#Cr93IfKZByq>^j2R?z zNk-Iy92cI)UZNsW8zHXh^3Bif6cgy13u9!+KvPd~TG|rORYuTsnf9oXdUzz81@Z&1 z-3OT3hn7&k{oO2`B@J})+R25Mo%?u?xPuCLwBLZ)Mav%OYvW5)@-JWRz*E9dkc_}^ zPNQ7vV-7r_e+50s2w+Z#k}9ZO$7`KuBjo}?92re_e8~0M zna2PDEQS$Aj(k{Xcc&xzS_MdD-I27l_M?kWagNBUTKaA{1lF$B>ip z<`EY?SZ1dXqh8-(k;t#coTR3EBBT|AkvlZ$5aV*e)r0(|2%4c^TM>SSA2HDLIT3sG zWT9QrdQy`cmE{GJLhz{3^qI)QTketgd!GXLvEBb}4gYn8B#NHE58QA4dw)Ls%r}I6 zoivOs!E{>b6q)VLnSOpI%#M6NbC5VY45qPD*@o8tcP}R1NP_(bvoUIm*{?D7kjIY; zB?j`*w3{rD1h)Eomv^cL0;bEdv=dR0trUICIa?eI+3^=Du)br_s4^W)TqnRMFix3Mb@u1 zp2z?x;zGb|M5`E-$wOu$wx=^fn!-BlB={tiB=5OD+SM!dy3`#RSb53 z&p~%0l+SrMT&zIBwGO-D|AD<$>6mMn zANKXmYl^w0CCG4MLXv?3_q#8!t;k{#F2o*SZ-?b>qT@~f8?wK^K@lq9diWMBL^hZr z_QiCgz`Pv=iVm(hsK=(r`ZFJ=ftQJrV=6q~b>+~b#R4Z;DUgDBVC&xp;W z+!3^m_A^=t?o&!Gw{>=wy;6`Ro`SUg~?(Cedx@xd6;90Uy09)0=O zTK)1g_0Ks5cTwmE{#kAs6!C>Jy1RagGP+1giXE!GbIt%VzWc*W0t{%U3zdX})Q7(u z1>bLqGfje!&?EnM41$;9j|BWWpAyFzk*%6>SftdAf)P=OR48$vTP;ex&b{yI$D72} zaEp^efW7qNz*a$U_ETVR+B#<8C>IUkQ-O?L-`1{eJ0vhEzi2{#&?tj?_6LctU)Zx! z+{YNt?# z@82I8K4IJ5PX;fqaK|E`}g+f z?W?>3>&a4N>pG%tB)A>w*0~qAq}sxM)}!3`S`qUP(jNoD{p>$r1T*DO98D77{$C^# zNuREhgHp8MLxW%~KYuubwW|?VlFQs!%gyfYinF(1%7}|hv)^9^b~oMg%BvnJh zbc7fVoHT?h-T9>W1^y6??#!k?QfTtao%m+pK`fs0QTfojGOMw9!`KBjn4~dQlwsme7V=uigJrj()nM*#6kiOOI#AVpnJ^ z&sNGp_tk=7?H{qq8u9;0+bb+sBIjlJiOS299=i9$Dgw^SAeEfyRG5m!1wS?Hw4R{g}LB|USG#BAif zAcrQJ3fU)&)gTw56p(|+A+Vws=|^f@fTM)uBRlJe-17{um8ssnBN;_{X!YNN@mUwi z{u!+4a+m1>Iog@}gS0KO1ku)71e1H2s1%Cqy{gw1?vOou1;lvQ9NLv6qQbAsB(h;5}w1^=ej#9oz&cL!r z!MPfZw8YFwafVDcE&7mCK7tBbkkw2IH9xRDgvJFIB3|E5)Oik^X#MJ|%k>fz2Hzhw z3c1jDq|}+-HoEChh|bkAB#)--)!N(`b%OTEIUMlClQJaQ0l!Aa0t#Y#*#&Z00`3&K?&Ni$jXT1M`roEcJ?F+*$diBeohMp(sU;68vbt z8of{dPNet_U9C78=IjTZ-gjXZ5`@BjGE4+IddUHgDXgHcKjB-A{ME$KW~cZH!&F#! z&PE|BYb5xwM>I8!4z+7kwlys{es04a;)er)&~_Z&UYg8~-b8Lt3oWd%T~BAM8r+XveP7*I3L%^r_R<8$ z87pRWhY`)L@q$CES!x`KPVm=nd7)fi%aKVGlWw6a9jbAj)K@co@hn1TzD6We6W5x~ z><~%4j_~bUQgL_qs{7mSnX>jkV4 zjS=V(ylCVdj0=kV`PDD}B`?1iv;c}DNQws)&K-F{1Ixc0CP zgn5@UP1vqSW+{7-icb(cmQm-u{_0s1bhjcWJ0ucn z3)&&@Q$yZ|kNt3o;}g_v1;A+55(0RqcvJ1lNf2O75sT~z8-*4^ zg9B+5iSHJD4?v}4MbSWGJ;>D5ARD@4(zF=y*}40%k$akW8-uaX(cU4!%UJ)0mLGfQ z9{X%8#=zH1Ki_#`(t!jY;gr0sjzozbpfpwYuYIV2l1I1Z#V&)Tra#?#}Q@-$KEhu$X9?~Kty}yj{k1IAU|NGiL zt7EG&9={Z@p+xpjK`x*kZ|u2h$fKPm^D@NyHJ-M7_$kl1DD;5-R{4^Hxy`=AG`sEP zx{trM{Q+mw*kF5Kltt%%}&lj)KeBaQ%KwNPQY{r=l$)JV|A3 zOsEz%5!OIpZE?9Hc=n`!#y z@9v6aYSNL!O;{Xo^I;{nSTGOqyNtqSS(A~(&mXLGSq2*1s%ITSY`)C5vlPRMmiK00 z))|z1Z37(&L3KP^-)hG~3pc`Taf%9#d5fdIJy!$JGkeu&=bx<^tmS%*P48!|=Ovt* zjvIO+ayfnof)rKqkd!e|0OT^Ns4nALt(@|SfIcpuO-IE&Ct(wFHrRV9_}FQwy{)r5 ziskSO7qj2GpHz`+C8U?Dr4BlfOZqAzZ~2G)-elag11@eU3XJ#D+dflMeNDmhz5OIj zLOa0F9vk5hVP!@Tf*yVI;?!ak#(P@Mb_rXZ9jA?Epi&A)(_O5R^_Kn@2Xm2&>N-Ho z$IF%gex9a<>#mq3);d{NwX_D%gTD-R6*V4vHQo`L=;G0!X2>umZ+b@fc)h*<{t;kS z+-v(yKW;+)wS3PZJ~F_npS3|^vqS5S1QEwvysnG*fM{@|uX&nP4uF6D2d)$0vh!br z(yj1`P*_?2e|O1$5DHZpn#AEZ$x1Nri?`-HRe8QuQIg3<;Cn$iTL2EGkJFr@7>I=3 z8P=ePYX^(@wDY?~$}nH`H)dyoCES!2foiks8-txBn=bD}r=o4`Yt@>}an03Q`V`Nk z+0^6ra^Aynrw$u-7%D?XY2Isqz9lAlz>Ok#oaoe^a>8^DYoG;{(;l>QmGko z`Z=r8Pmmmpzj>t>Pf5E1&)H#(e562m7!eo67-g3~zDb9N@uA z8thKQx4|>%Y`4o5^hBip!1N6gRhL_>;N6Z_398UvUIP|5sF}n!bTuo)&P*?;4n#p! zjVm16OXkXVM!{w#=~|SaGB~V~bTlo@Jq@V0n>y>7gOO-q>o#6^BsdxmCn4#dQw9_L zW3d5@VTxXLCU-awVi8EJ;wf}LKKnqS+mOi){(ZR{GEg{WQ5mPPd2Em@mo^(K*YK3! zLQE`wFaqLDu^jB-*=e0WB#Ld!;95DF5P!Zn8nu>}xL}-x<+)_>$O?u0DX`Tn5z7$6 z|Mjx)g?kSN`@~LVkptpE-^!XZ9vh7%#o`dQNlwoKJPnO)QvZ7_q+DgZf@am9Mm=gH z_55;8a!`+YRkMtIMfn0i9YZ>G0=&J)0w1UNjDQRsFZA8V|Mij#!9IPwkir&aN*OKH zpjcUvkmyAD)4e?Vi|H=O(%l)34_vo(Y7bu9ZV0!Oe1j0YTjGQM$+89V{;rk$&~%p5 zUX~^z)xCIn=&FMPcecdm@0~j@H)42nl=>RB$(Y-fa|)R$bOveAHXBXri*H41)(r@Q z5Z{Bkp{BY09YP9V9jHT05on2U4~EdzeWzJ)N@m_g9B)<5A2F+6%MxPmlfPX-h7O9$ z!y>Dy5Wyl>K)yhbzm(wc>m#3$sCPB0;^Nx^ooK zA?Fi4y9K&KOZQlYz{z)N_Mv{a7y+&UrFtXOL8N8gJ|GlWLFn%|-$o3<6PH}!cy^W; zqV#$NyC`LX6Sw{kRc93xN1%1IAcZZON@C@P_UMHX&ZN(5fT+eHD zPs41(HtaA=B$814Zhv0J66xPHDU679-o059QAGK;@M1K8^Mcut##c#o&hXUe&?6>g z_%m317kFmu%6|O7?Z`ewA!P$z;@-KK4i$LA!O)Rc+=qP?NSoh3u?HE_w;?!w{qqiyD9(Xe|7~^PHw-Tuly3^&q9g*?)7A#U@A0n?wlNVSh6J&F zzu6+d(HC$f>5CiPt${em9Y9;+tFv&_WHBpy$hrIZuE8-)FN>YsmecoGIa*R=z9t)U z7KF%xXnVJwDIIu*Ikv5DymZ%zWS<$G0ctCRuAdtept7Jf(ET?sc+~XeDmQODi&=Ts zDQB6w`tPDU>N$Hm<^dI3M|caXp9RnlDWf34VN!mZ7Z_9uCe1&g(k^77v`AO7?c50406v z4rt$FMqwIc7XcyxKiG*;>e?6}c0wQq1+~rQ3z$DXw!^^wU*`Z&b}w#qo6FKV#Pl+ud#F z@blScJ|&y=;4jZ4U#^gqVo(hE4PX&DG)7a&FU)0_jf(D**)?oOrh`;@Ya5(I`f9Gsm=y3h9Q$}@>iJU8l5~xwuksA3ZwiJ zd#dQJf*SHkxKgI0#Y}*&?*{HV_*@(L{?QgRw*is0dsN6#j1vx#0N~ z2MA9;cAs>m_By7a)cw8D#4Qu}EKo-(K_!~OS7~5#yf+^b8uPl@Sp9A=V|__}%ROQ9 z8*r6Oc|C)n)Ylp)x}YB_&(@Sb7P2Zr^VzCt6YrqDhou_(QXr~XKrP5XXv`}JqeEsE zU%Xlx@EQym%sFBB7L=N85DI8V{E?`18Xg=Ed9DM0jfJhj&N# z;_ggsIQ*aE;FuPTR>lz_yG_z zG%r_cCvdQW5;vj-12XF3KU*O=e8wR2Vz;Z_^3B_i3&N=Q`K<2Bb`2`8yyVfi?W?2kbH;XPw8gQ?|N#bxQRw z_X>+Vc}W#Q9$Ls-e`jbzg}{j#49Ks?N#4X0_#P|cV~CSyUW(!!i^Lf%&{=6o(wg)& zpkXL8!Of`QQ&{jCHU8Zxoe_@EIxHlpDg8IYj3(LTf~2iz6!DX|60sXT&lW`?%&`(-O}*F;vpBHTrl zAZa8NoiwQ|cMCtsh`-As<8EFP?V_9Ca zfGlosmLM`5o6P(`sXDRXGy=SGnnDx{P{h{6TqscVvwKiMMB_b8&!>6K^MP8~MHjvK z`%EdYS9uhJ9z{+?A1ep784+r8E}F~_D4}ycRzx{S5A$I2)pqgD z69oKepzm19b&A58u?cjYb)7)p*}hN_Q>^1Gj&CI{=r~&0pKTXw9auE%*6r z(JV&4y|RBdlM5uL6UzvvnPXIN9wpf~C`QV=cz~L{w*;lj%`PnZZ+I}-qw~9}7As2Y z-aWE)Ar5Lt-Y1M9hX?IO!5s~fs@n3_WyTl6siTL?rb>Q@I#&Z9EH&peuu))Vwyv_Y zlO|{E!UQte3V6EjuwA)GzvP#lE&}&}L;Bg=Jj3Iph5uFz(z2JrSw+@n5z?oml7nlB zccGOBf$q#l!w4teI&wzT#HAK8TL`qG2m81Uo?{7jyup1^8tu3~bd)36C`k++Q~UCw ztYYqBQ|i>Gt6ev#=(^JcwKvBx&zeD*=z|-7yvK&*pelD1G`^`?=EXSST zCHDI`ab~f-KygaGQAMh;kAXr~hdNsheQJkk-Tt?&&F)*OUt5~TA7+IgjecuUW&rA< zF=-Y|*>bM6oXlW^N7NSW!)wIkk! zj?;P;;Kz38>z{J7F}#giNe{Qgy6#^z?H(Ggc&?WhXI18yQMofXT14C7AwEI8JjV|7 z{X5iLwuaxL_U*~8c%6BNrYlNPH8$o9Jy&ERx23pA#^v?y5gZJkDrS%LSL3nqLrR+* z_iwAqYLbinlgODn;bq&O4kv4m>(fAW>v!>E;QC1N8QtO3y>+_5k$Ejv%95qY5A1W6 z(N55DaicJ!-lBDe`I{c#CMm8n9_E)@ojaYTyDZP-FP{Lz4ic&`{7RaJ1yZ2XZ6mo2 za=UjllbG#O>pl`(bvhCEeq-%qLDN7QTzAaNQkmVCV73QAcx;(n+^&6?&kTo;05k!B zij63@+*$b1fmXjM(g!3@h|u}Fh_5Jt^4lLLoB3lgyCYxJd_rMI`c0cDOC{rHP;tvi zOn_nCp3>oE&fiDXUnk_rBa9WzKdLf+$uh{ml}q#Pn12I&Gw%4vx^2t9;V?1Sey&9I z;HKv}yFfhdAlNDhOuZA`h`HFYHU`LED7V+cI-ekK1+SxgycVa5KqyF!@!1R4LeSuj zk@o9L``#GNXyGln*)!C8l4p1R#fyYs8yE9N4n9=zy1=NjZoij0H@sDUl?f$RgFiWE z(+pmf!`Aor-zs0SNMur$)7gJ;{+YGkwJW$cHaa^{H%>r;L)=ukd7&Ckb%1;PuNDz7 zdetJl{}X3T(o;;{VaEMC$sz=Y`GQc%QG(Rx+=MC_0`Y=wYGDxsMHZ|#sHZCd|i zxLsd8=k`K62aBG>wk4##}lUAx6&xdUib%ouHyvK(vO zb0ea%HCrxQAr+Hd@^6+B(aKX*hFB3Y1!->}bk@U<=J65!#V9~w^Q1*K-?UB`V8T|s z>Sn_JiopE7*#?D`HnJ3fQ1`Ihr-1S@12n4oFTO ze2>hAZbd_Y)?+kCpbKmS1%$|&rcK!C57fq_({z`JES!97NN5=MJsxJV8-8=`5 zNLQ8}`Kmfni;M4z^zIH?2~7y%tx5lIVz&=X@a;LDn)zmEamnnov{G|n;D>7XQ9IO% zjU`T5wr07xSDcb-Y7oKaw*^z^TV(gMGB_CDKYuPx7P+G6L=x@2jiSTr`K;5+HG>kTnmfm#iM=3KQ6so@kX!ZPH`ihH=&Eb;S@K(6y{wkbk! zRZ8={k?7mB-xKi!kGU>Fyu8{7X}u_INW6C=sPHm@f_;Buh1+O?kcBoeCxg1L!^-pm zq6Mbx=ZFVprsaV1FbE1U4PRupIBlJqgm@e68@5ojO_YAB>o5+av|h6G*T5k9S>E^o zCdEX-W|X9~9_`nU^)qDI*!84sYPPA@AeWC92o3=ndM>rI)shaHJo9a}!Y4Z8EP(~) zg2yh&)5LI(l#`^lUOD2`U^QNjV~h-OPkufWl5(xRKyN^|H#ycTbZj%fuAUDp`I8U4 zGhgx@p56|7tHdgppXmCHYZ^bwmh2DYRx)*78>|ELMa~~sH9#FtU-NuYmJ3FkKq}Z3v5EcwA16r(|D{zu6XoBL>}KWF$T!lR?l^L~jU8q@$d5uL z%=|YAtYJvN6c`sjmazE9guM-3NbQR`k$Nb#fJIOyn_VeL#5JButp=0(LUPG9i!TOY z{GIihJSlc759 z0S0wnZSQLQp5iSXiM**4)h*t=KB?a@t76Fyu$L3y4hAKnW7EKGwJdnKg8vA-u` z9mUFJD4zM8*UMdHVqnO|5#5t#1Xm*KQ`1v)R?)v`-qRQ<*4lZ5mvLtbCg?bkd*I87 zMX=0gv2Gum)7S-6QrdciHWSM@gf?8S%mct?BZlI<9U*@Mn_@!tmI@V*`X75>Hnd$9HeV@ut6PAX`sX$Fjj z&YByJ=m0v!HN0_4$w{_7iCxe7ISFC|*@lDOZ+bU)c7lp+{rAZ%Pl@E7^biC{)&K_k z6tk0v9}enm2~+>_M_s?4qjiINoF#H4L$^XC*vdw3T!_xFn@gs!0&z!)_tS2*1{U~+ zkn;?11W{RNMPmz^`k}~q@Dw6&JI?}^kkd;dEHSvAL;tU{m=Zy_e-I>^NF6|>=EED` zK}LwR_h|6U&q-UzK{>7)q0(fiQ$YA83hId697LnfTX@Xb#*ajx6+drxm#jB$w7M#` zI;?I6X_~Y59fknO&&lN{#3QX-Za-}L`QR-&ANCZ4-n0F0pDw2!%6bR3fDGTL@edL) zZ{)!I?>?_Dd^mESzrd7OO-?WpMJ;V8$2D~qW$C|iA`gi%M|83BnytBI2>?uTIG@!h zt0b52Cw)M9JfjiOS%Y23U5ul8r)as6T8IW-*+_O?cq<@ZAB`1iL+i%bRNS%Oih*su z=-kBi&hWZWkrLbU&;Tv5jaIBU%r>>;ge_#Fv0}vzfparyeE@v+taO4_bseVyuL3h8 zYNNsc-8-Bha)}gEUAL320rXEkzGrkJRJcr5ju5!N)ZG3cV!HVo5Vxc5d=99ok@@cHvpD4aNFrjfO*UowbQL%aO`xq!sK+0XYyx3ggFyt)0 zG{&ybv^x~31q-Ae@o# zHOn}|qjBL>aV|aj)nEEHr=zW-LMc`zfb{qitK@%bJq-<1g>{^!Oy$;Gwi~EEJR2-N z!?IRf<;epWNle61ea7RFU*9ywH^`7z5ZFyeXG?ajJk=PRf;~6?~=Emw9Z%>@a7J$2S zOeAkBR<`el+?YuB7H+;7`cKo}`0Px+4KoSQ&rZ6@`D3y;-ddCTLy+kZsW=HxPZ(6A zi(?q_#h`_IYjuxEzHP-36?Sdw`Y>25_3q`X^v-=z+`a9k7xN{3qim86Qq-FQH4)U^ z#0cNORmAlBpoh8dy;B;Ez7IX+fq>%E&Bx|ufl1ZnP8@Vy z*8r5rAKxo}sr_E;vHEI;LC@ED34%#BSBJ&@bvsc@$i;|)E=%Q?ilO6{ZZ9L`WZ?7Q zt052_*JLpFQcj9A>mtSfb!zh3j}i}wWshO!v029a7%o-%n^=7o94+bB&512m1Wwa=3|$m6_N(#&`q6T> zAU+0*_gc!XQ3JbFKGLVPgLU69Ao28J!|1ie?A_>f@x0oL`R*m3i)|NU3E;>W*~SFA zN~$F-Bu;d@gDYJrE3M(m7R`axSP5LnPR%);#iuzl@Guj6-1;8q~``fLv-{7=qzocb*y5qpZpL!TO>ZA_9Bpv6J*TdpVVk9 zgU4DO4y=Y&8XtP}(>SqAzN<_s>$oXZYj67(skxfZBK$p5GGAT4pZa|`D|s>tU8$q) zz$XM;_Joh_PT5tGRbr*GxbbhJ@zfX{!w}sl zLMZ<+>TWKXD3)6l70eF6bym$eTzVOJ7SzQ-7u$QNG z*yAWwE#Ks9nsP1lu8qOj(MYv5YiD#J=)OJ{6XU@Kj!~Q_(RbP9eLGP-o|xxp(WU5^*qvNiaz*f~#T!bbH*v&!;<0wDnf135NsDJ;-%@}=K| zgDdHelPoMdue;t3H6WLiEWj_*BG@5u_9^OY{|G<-=?19-88+^IPdgRoaj#6-cEQiw z*nCmpiKm_>PTdr591VRL^)lBSfI1i*= zcDvWvyrU&wna!~f4zQ(-|v~JPKdv2iKC~Q7$^Un{Zp?G;|FT> z(;fb_r0fzmcf$sfe_}KFJE*$f+dw4$K%lW3sH(S%+5FiGK@4zMuaEm3(Yduf@4qZo zRd%z`wyYs#>;a89{~>0*NGlp+iRK@gf^xpf&)s?K5>or={?KbcHw0qg2}?ll3bZ4G zc#P?UUJtVP2dWHoD&4ndy5WhT5V!7&8KKa>vvZLKj|>*C=kqb?z!G-0M^=DuSaMLH z?da^=)x?Ahlx6+d567RZs6ok7!|PLsV9NU6D{$|2z-u@T(<$o0&(oqH{8`2~=~-|q zJ7R&hc5p#a#u;8W&(O;Q+9Lu#550MV8o}4|7!b_*e z<7X#;S792wz3;o1ahz4f6mgH!9qV205fRmf@ zb(&2pTzC*|%PA3qzc=;DdrVR~OLd^afSou&PHQ@|ID0ab1*ejR-Ojmy&PV*f6JM*S%TxIiN(`7o9fzSRdU!7HA?uYumfT2e6ACsJ8g1 z&elOnmg|BN+g>pJ4Zh8%0lC$t6bgyS+r}QI{r%^Ep)u&k+mE7a#*14QX?0%fhn6_& zh?70A-#`U?^|eqI2YCVf+WL8VJDIJ&AwWo}9DbG*t`VW z8TP4=`S}m|_*tZO#6!VjY93nuRULf}IGRA}r+CIPOzHLZANub}u;r^UAxj;buaUxx zyR(Epe8$hyixfPwN<>I3g$4MD40jxM^DTA*5b#QyU4`bl?7Fq?iu0jCU3b^){6IBF zOq*9zOOlyE0j|MUyNDUDnFqRoMfSV#coZMY6Jx<`Kzh<(oF-(^ngCIiKaASfMi{{O zXxAm8yD)3jlnE-+<@-vYV9Hc*Kt^8ta_;4^xz#gTRhfq@4eA%Y=% znH>U(sQIFml&(3M5URGVa1t$dRC*g5X&?o{d8SkCuMIu>4=WzB&x=5p0dlV8eSDon zX!FM&R)fZ|iQ&b5YXVXm4lGiVnlfPOZ7qUSen2Y-m76E=EwB8M4Bc7J0lEgEti|Ua z;A~5elg#RoaL?mNcooIqX>v}+h-}RApnFU*vgXtbAB@c}vUF%E(*Z<|OI}?V&E*u& z8#Q(e7SA7?6A>A7bJdt_ZB=tI|Nd0t*hrUE3mw%DCH`B!qwbA8uYOMc*1ZOhHli2h z3fs>WrV~YpI{$_{^_G`5H8<;{z-Fy6!~90Nf3su6Wg|ukgzQ(~DBoa(J|D5NzBwEl z`FeFg7Q%X$R=VJCuo6S!@^DgUU)$%U1*EkRHQez1W8NJvBC=p8mYqH_PZL&A@;6~Z z)vyvqy17qNuiLe}6<$`(EHzzJK9<;ZTIwE8 z@wW%nxyz!_tda?Rrqs;ngIZYudb6mFj2AyW5pklHz+5UuN`+{vquyp8G&i-2e$(vz z#+zmn#O&ZQHF6TdN4}7iLY(k@Z-zwEoiI!z_pi~I7@I)?hF*VeBIgi*rrIP5uR`bU zZn|9?Qk2$6XW>N)Z4u;U6KPcm^TrKfD{Qs&#lkoL)aVf~Sg+BeEY<6Ns;VX{P}x3M zRL(SNmlW9GtFwO(qL0$?oFBRs_?RF24L!=Ep6^RD1(fHA^CjfS+&3;5n+p1M=Z9JX zek7eNG*w(& z^P7^G^acT8lSPj}LOfx=G@x=G2PMo~7B>t(3m-2`*2(1U@KE41!wm}ZSM7_;tZutQ zZ1i&L<}Oa%KOLedO%&M)(c@?!Hr*pu$OpwMr}C~+p-a6dBuHB^5QwA}mA~M+>mmu# zFX~%KNi40x*CFb02??~!r)29QrYApR(Ob&C+j+yYFD8a@L*_OWIThA79>^1F~)LzR{Fm&ZE*nvmTPK2v_2IQv?8+0Xfp zw9xBr=>&~rPkI4EEt9hv?h0EA7;d5qcQp&^b@o-OHmie{*|(ReG35J~U2#QDHF!71 zSM6d^Qiiwp8i zRfUI|TobqoTL&ulq!|o<#%ukhLEWj0Wg{JEVu>Y*)uDC=adJw*;1|&T%YBAvNOaj7hh;f_jvqs2Td^Ee{p#6TV#MSLUmRY zA^XPtgWk*gP0*O;W=LLVf#PMx04=@bNn^Q47oZ7~f7E*KDWZa8@kUfu&I#8LH|_w&Ce7pBtp#Z@V+YvB1EAcUrKa7XP(l%fZnH z{{0kKn5d7D4D%bZ+X6hU%?C&dLPWTitoj1Tn9Lzae>wNQoaIZHkmHo!~Lt36bjyL{3fv%>ERCY zA)l_j;e%U;vq}a2ZPSD5VOJm#G|GQ8oz1L%8C8+m+-Y! zyMAS*lmrJw^M{M=ajfn;pd~ka6gF&BZ+TX7;_No1)86VDM30lPo%aR@oQd>Hz7dCk29^Kal3Ka94^11S~7@JZ!! z?$`BSUc&}Dsn(e8{~CpJoI6|z%XwuRZO<5feHlF~Yv{z1GqN{c_w~BZTAVzwzYcwF z@;Y_^hi=&Fb1uAwIiU9%m;cyb1>qWqwq>n7TS3FKoQ9-t&5Wc2MR_d6dn)59t|eG|UqrknFeFC9B!eo&-=E7rTt2r2OBlZ(w(RcL=By zpbr_c@%|z`hp)|hCaKCW3wl5BgGl#Z&wh4jfR3*wwx%k-+32G@=7WR;D(169z;1Nl z4CZLo;wv(0?GtJ`Z!QMhWS9(1*X6;oY@+b5kRbLQT?Xd27HKFL9}tqLL8^=5}!CZtws_gZQb|G#~BgTQ^D8=Btb!-PFY*w zuYV!|?ZVm{R(4%?R|Je(^7O8rAPD0S41_$0rVNiIaYF!&l`0LmgicdFxeZ-QyFpEcAX|}; zixc-Mf~awq=(U5#WmK(W)MirXs_G?qnm*~fsTWG5TGLc&tD$4|3y*-aLP3z+bZ0K= zu9`u!ZJ&4QD_wtv>ac<$6RXkJDrqwZ8zxq5pE*G-W3Ez4XIzAht8#o|CLK{SnZta1 z3Qpkta0)LqJUjje`nWF1G}*LLd|Hu`c$tZq>C#)ikRLH`H4Ub)T(pXrk8O)(1kNkU zz8EL$Y*{kf|%^LW0W=sBAZfF#5A@TVlAlF`u#UmzJl=b}VsnN+Q%QNXHX2?Pc zgIjaq|FQN*KXz=WIcHB-#w`CTu(0^6y1_p{UcSJ-#PxV2MfzvLah5-^9z~I=s!q6i z|DmbekzV9|c66if#j7AJNG?gtJTUx)6>h9O znuc@m#WMWpE%Wl9!-}?`8XdFw+3@Tv5;!ts;)fxTbmiCBF2wIVTe1tK%xFgnB|&i+ zDE)awGcS*!v1#)AAO45hqANs%Mf1D_=%RT;zVNN?i4bjxmq0Pnn5o4StXhs-DlyY} zu;94-@t3y9h?fKdh3I}@f(2M@rsOwzBqN5K=herN4Ch|q#m}Ltb<40^jOIpDq^~S$ zdeeN&4+wU`rLdbT+f!^NHWM#I-mGOgQ{(Cm3MAr z=XS5Z_linf$cw8<;ISWy1Sga;Kog<310}WwhP()Mfd~_NuOJ3IUpH3CJ_0psOJ}Vh z7qpv^SgRaV>wn$9@JnA5kzji32@D^dN<#8i=E4)b|Or|t~u zac;b;HkjofRx|v&$e1|KihhmJMUF1mxac`n2|gu zO_(wy*!a9Lj;WDFnCQ`pcX>$a(l|+QIsdXvWsm660=cLr;f(M_p>xHm5w|)@byis- zdLAPm@}_wyF$e=`6)0MRX`a&|JmS-4NzIBe=`6|XDp(ypJ%V0N4`z;a1aY0ORS1M; zihPP5uA}<)Om%Y6?kw`pv$B(Vnl{}FtD8!Ywb5O?jqy3~e}#Wq2oLSi?qy~}0`yI? zV~UCbgq1Aw{X16bi$ep_{i-%!gqP>u;xuEY62=KUI-mQj0S6euI)NOB(OpOH0@Jw4 zj}be@E7<}|BvuYbeI4H$9vGy8ee=2CjR@AZ!aJhy*D@U^4*v@NTN7E7G*a5LpmWHU zD++B({`F{dAa`!Z_gC{JRTD@A)^hzcAoe*CaI8qisuW4bht!Gic&_q~yx4u5$@Zho%Z8d-CDq}n)^>BPD zOw~yZdF2IW&E)&Jrog|HJ+N;vb#7fheVpiwS|4!_;fcA5eE8NG-_@$v^Gx*55_*TH z02nmGkR{x2b{RI@{AXHM=z-Ht%p8(ik@fw(+R_)9`xdDO#x|cjN~-%Tv^^1Ea6iEK z=ID}O^|lHFhN4XE!u9{oyt_JEnA-hkN}&SdAg6Q(;>ZI0|FfJ)Q;J6{!wk6-m&wYF z1YNjbR%Ji;2zqX2ot<&nF#gK@LGw2w`yX6aHCDbzt47l6Vq z%M9YRRz>~ki6IkvPN0YUg&;*O_X4QK-*^ZAndOrvcltL}Lv4ETA40X6@XcvnX%-v2 z>6;C#)-JDDF<54^#8Es8YA^uKf7eQ5WOnXYf=RyS+{vNnVXBy0^vnr4Neik!%# zYemQ(=Fitg_=TIfYnkEb(lU40h|5n@)yb~RR4=7#*^oPFX=NlkY1My9&&mNCyt+PwGqNxX|CmAZwS;H>$C@!6i%(jQ z^cED!X>TZMBgqu(kH2p@*5nm@NCC>_WnQ#|l}9WI+~OnoHI`V2Ouva(P~@u?mAf3q zCAt+3vpFcS>9RSehEMiu)lDU$m-2$yl0wWWwOQvZEb!6|*$mOxvGBd<017=tT!E71 z;>5Y$(7@g3((-<1CMG?_DH?gYw#mTE&m8!#geFBZWHWOP3lmai_@6W+cyWbeEuGZp|WwfP>}h2CJYZgO=_} z2kl@mrv@&A$8Q^@&S}nWZf`Dn?_63V$s(OXJBjzGgBns_t3m>RjZ*Cku;Cxpmp~sht^0qU zE}12CDz*r&G|PUmyp2#K5mPHe3T91Vt%@~h_@U$76IF`%3q{te-vOPp>Yn3QStbub z#E8rZzx!^AoX{EqQ&*71f~ zb1n!c8EGG&lnm8AbN5*kNA$s+;eT2zw-fu(FxR(}=28bSjz-0lZz1ywp7{%3>Kqcg zKWIEr+8e^x^Y`mC)9{Kd|I@}s(zVbisyn*x*ssff$;|gj2JZ#xa%duY4 zl3r4~vYnA(TEFLJm;4hwmJcmw^hh>{W-K6ztMWQMOTKgyAFGnW8|Nq11pa+I|1}^! zny{62wn;9oRaDUZOz`xvIs+=_?${-wVf1Hw#E)tb2J1t6IBvvYDy&-$gQ9f|Ub1_K z`ANNeUh7FUAOarJddL>XsTRWcD$W)ygLaJ%V=CT!a(EBJ2N}#-UNgO1*XBW%^*nw< zx@|_YTyiSY9>ZRSMXw<{+Y-(LZTW&Xb^8?UAFDey9WDdxpi(c(oE}o0Pg_B)X!=bR z!fwOI^?CMhJIom8^G?cBO(mglo;zYF3obg>bVB=?VBmwfVC#xsiQ7PINVn5hYJ$MnMs+6Sv380Loi8!XptrU>X7PwC7q z&4zUhzXP)JEUyrWE?;M8khnO9{UYB)P>KCw21qmoyp&I~qGF%2uckgdIPSjHANH%> z#NpEZ{bc=`>v$HEW^{V%NtZRG&h8)$Bno&c%GY1F7IhqaH#BV==F8*ix#P~BBibbB zSY0rlrL}GG&UXqDj9?Essv9GZ?aQ6a0Z5F z4pxSPXY@Z02i=W2@zukWmE`QdMk|bUqIS^H%mL`#B~R^&$8{(#xjW&DIi#o?cAW>C z<#*i#mNUcH9r4#=9mK#5b&lD8huj=H{12e6N>}PS{Y`j-k5et{7fv7A9Y`b24?w_O zi3twn?|rF5wNneO#2+j=7=k#v&pe6QH0%01+5Mk%feJ472_(qn!li<-{wv7v{5WUlmviJ5d)4s?8 z#pu8}z%8~1pCHO_Z}uF!iE>+)*WcWF_XkLNzyzBv^MYm@jyZC7XKm@IEuY?n6T#O$ zFO^F9c3N*9H>#!d3kqYnEm7J(8#&11F{RY1HHBRz|35 zKT%V)@ZLM&bjY=-*NW})@XEb6l!ePRtKsB2YdxuLmtsAja&A{y>>F8cB_Bs0$yo>t zfpy>3=zpY03MCi^CB^#(j!cSPB@Pad%u$4s=|fNsl8UEVeC@@!)gw^6_G09wCYy>` zNlW;fV>o|6rFUZD6{0lblk!UbX!^wLaClW@Bg5?CN{O?D-N!YW(To*&tUsvx#J`>u zqHCCui|54t+?_Mm=4rj0&~h{9tu%tCZ!j~@UP7v6j`Kb*3t-S_GuJO}XT$(De=>0? z@P$C$BFqcdrwGKyyyw$LC%3Y|Kc3Ag=H|1KEm%Wuh?(=VzMC7I!;-VGruw=#7u}!h zeyK~mDC56&07T~kmn-_nIf3zKsA{tu|AgdI_eN>Qm~rB zxl18)Y@i?az#pKZA6$jk>v%8OJsuh3zbA_%=WgP${s+QSI#>a5e#4WNf(x4(Fh?c2 zG1G;^Eem}gjA_;DL(nXd!5hoCBoQwxceC;r|4U3-WrH(?(5h1IrT_V2(~ zkA>v2e%g?m{ReZ6eJGDeTpyZ^2FlL?-+vo*JZ>8*DJ2N%gvu=(QPPbzBHQ|)$QfiqeKqS0>~Kjk z0eub)lCgn2nExDh{W)&<1zB(gyzcqQK+kj-|w z-6IbNvpjkpI=)1&WGwXjPZv}iU6sf`@MmaC zrvD&`(e+Q%wbc5W}AL6!e8|;z#U5QH42V7S;FxE-ay1HFdJpqMBcLgQr-9z_L6& zCbal(zoF6?ePrBcr;|t454~GH#-5x05@Di;@?0;YyOBj$eLm%)jXY~+}iZI;dd znU_64E9|4}waKpMQdVoZBkvR9%P&!RcUd2fIuFE2Nh44SkV`AIy`^`2s~6CGeHe}dBd2=h-F%dIzrv{9aq zAI%MZpS0-9xv`)%$lPZS_I!5Ngzfe^kSj9k`ud5@?yPdOfRG&X74zbi$alh zq(1I4`4c$<6AK=z?iHujgRXO1#eKrUH|@+OZei$(ruohgW^=BLDDWM z2vTmqj(c&ei0jh2sw%xhQzv@yp?Zh_BFz98Dsi_94Wpcsh(QorG-mrtMqbrK`?y!M zjGOb$pB!gK1^V|#S6B{6*=eIl+TLjcMMw~qowEcwF$i*;9%4iZN`)(;{i9zwDDatq zNcepu=j;w*jUJZpd*9I+%s!*b`vR8z^r9f3MYTFmNMYVPAl2@;ly-*Fj~qM2KOj|2 z6boDNlXYL$)Kesgo17@XyTNo0`J+|9{*M3(|E9Og8%6(#=7zJ1Dc|RQc>7F96}H$+ zJ9qu3|N8GQoS-}u=!ow5(#F16Q{j&cC_aSL5p5$Sy$I!gUlSo25y+1q?4c4QV5@a@7`gxV+yG!BWpSJzkZ4_hRgh)JHi~_ zR`^2=L6;Njd6877fvc6#lX{k~_c9uvIW-oh2jNgyy5zPKk2f2`tVf zj|!P+xOSgns!$w(IxnaKs~Rg#08Ai2#FvGm+4w2nJ@>88Gi87Pdya^dUX_FcjO^w2 z`O^LR!iC2+#LOTCu1(Z|nRFBr{(e#AqTAJjAl&+rI2WOPADgOKn(K1?enX+j^$t_q zN{q-~4Y~*wyhjQf)p((PNg=ah0pEE_u_+$j`uD};#H+lboVunv=YqvN|&4vJ~xlzHq+DfiPRmB`Xb z@Ed~sO&&4sbuJw%jVC?tMO|c~cTJ6$fK}A!{&zv(?hNek(iJlj*!d3Pl-#*lRkcti z2n3zaTU5V+u>ei2htUu_z~*@cyV#ti%OUI(r`8l3=~e;mrK%23+TDJNENptcYTCK? z{Q0RbW3!RA&Gdf4By-n+cwl!%2N||wea=|CDvoW3YVDLMaY|E7Q=A8CLU=C-9>3Xn z4fwv3Z~!e-5xs-)7(UiOOj^o|Kn4Wm>yt0(4@ZYhH+QYi6VO^E|13`f4{oap$K@hm+?==$5}D_Vy?8pZk?vlE4Ag;8U=V;33(a{oPuY4-(PfXsajd zH&Pv+WzVJ&7?l^jV+!_v&c-+;ykb##`2N@Ec&)vhFyg){4ShJqVJh2RIzaiXtH`n) z7OmQ@L-fJ$_+81*kRg@NpFyQ>7xF1_{)LZBOK+o!>4#7u#I!_9=|g_ry2}s6?fDO> za(>U}-%b}zMpb|z;_wV$hK)YlQ|NOcx=3Ia0ty8IBe{nT}#j#~W;mp75-@JD~t;Gry3}aI|#Hkmlo|LnGSs5nU{^m>aO@V-2rJ8`w zU0x%4i0J>gI;*fM!f5%Tup+UMqq`MpGM!Fk8x^vMDKRd4f z+IydTr!xn0@XYrH^5WFm*ib-MVf_Hq&TaGyJcNpg?RYp`w633TFdYW~ZRh z-ddk-q>))BfP;#7r+*?fp=Yapg+2|Igv$6|$tWi8(Q_nGo%nd_$J}J%VH;|Nk!F&-6$BH|&1{@5GJ`Vh)*9W1~|@dqlnHZN!_Z2jb$Fx+X}t0}8HrzDQX%LkLU* zD9|4XxE&KQZx#z@tqh}9M3IDa_d(;LQC%VIp%9DdRHhBuwL< z=a3Md@I3@;Fbj7(Rs~&D5Q;W3nM#wQ^A0Ej8GF@aJQ~#3Jm$S3CBr>9(*q$|$hqsLa$6DMQbMH^r=+OxI`@fc+;h8vFCsN$m~CIAqkmBHdvvF&C5uTv$Gks(d++dE)`uB>)TS+mn>V{UU!;2h zKukVq*n?wbN^BtJ-tdYf1;g;5>)Z}-_UH2&ut;3CEeLV8@dPB|ivz|7A#&Um0u<5R z_r;S-rs&9)^{x& z!FAAeRE$4qt$(WvJBGr6cs@+tqIyGUIBalGfnNntvhny4|F4FG|<1ioJ;;)%ESUBSF^{3`< zzowm_Nt{jaZL1IJ!r1iN-xSl!CjIn1W@qLMPg7S6<09{!2is4Qr?jN+Bv0!=?z-`> zfX{9FHGUdT1y~gOf=`LeoNW*EY=~_$n$kZv2OL~ixG*n$in^PYyr3*3A*MLlAKv;@)>Ld*U$4K#sF?IW zLbT3iK3FMHxD$Bk=P-3eAaDGhch<-m(fzJQX}!G+nN@l~2V(9i)@OKrcLCqh-)af| zdRGg+aBB{uUN)F0P)^$CZ+4=1*{XLSP#H5~>H@A>az^}c z<^{5$>wcOAOxb#7qS`cdelOCAG(Kg4DBH~W{c81LKMibUM?IN_8r&XmSbY$J-KX+@ zy1N$4YU|~;R<3Gg6mD4+))*zIfRo^b&BXkv@K6`9e<5uNj)N{Fn|#zyF^hg?3acdM zs@pC@sd;kI(5A=-nwJA#KE5u~HJZIF<~_1LkEqRgTJwfA6)a@OJp0_ppv8T?vFX@h zp4P~?Z~yXo(|!6=h^I?h4FCSo`)5Yg#Vak)O=Kmfao#3R$7b>CN|KE(%*?ZK!eip9 zy7S7$gKf{5{u>B_Lj#Uqh8ElWHyPEAzD{O#Z)#k+K{-DR zL<%Hpv$bRO57A_9hz^sgqY|FpfV&Qk$U{?L;WtA|^{A%;&7FL%2oTdVooU+aH~N zc!h=`;=LpulPE-E3oA5xkZR;t1s0POHUYFH(=3eyT}*eTMQ-^xhvN&@#Q@zKNf8kn zi@M}^>*}f>=ewR#a@F7to=-gXlPxqKa0AKSiVAHQ^;k>!pr;c!W^tMw&>AR>KYce5 z1E6H~h|_(M%k8w9TkpJ@1aSIC*!_aYWtaq*)!K~5ZWcM~ z9}&~LhMkc7F?(xU`@;63_;Qp45b#`e|Dx4L+rB3a3hL|Q@(WAX-2Y1@iaNyo8Bb`n zVI?SBC5^n8uOJErZ}!GJ+erU5Fj!HhNzq?Y%0JvLG@os1d+LNA6F_RuB{GRyf9Fjo zV~;KraF-+|QA~lJsc2W@nq4}~lQS&_Pn@ zm6otI%civ!hK$f~Owsa>ri(TyuT9m(U`4_?}{lz;Ih?v4qTzMjEQ2j z;~4=UM$Kzx!LnG7m(8!651V5RvE7aWIcD`;`1=Hm@+F%rBbBKBrQX4Ws%=h5SKZ)o zI)jo=s;b3mfV<*ccMpMoW_PYzQ;c*FuK0ZjrAB2yFpyYAgGS2p`4Qs}HXZ}F_KkI>(S$Pn<^Cdxf@~>cZQR^%niycUvuGmJ%BvB)O`=(_0bGe zAL0`UAc;I-il8DAW`R+c8J;_n=^ohzc1 zp8d?#HFwL0VbJf9yjU-{fg-K|sU#CZYD)IgOo=6cST6s=ht>S)coz(6i!?=FXlZN- zH(>Cpo4_)G{EFC?g=NESlYm0b-v^`+V;#No`eAVXZ^C6l<4)-y#{+BKL~2%tu6#pmnjXXU#pY^-_DmE={P`rQ ze>Y?r6LW>QOq6*u9nin+?KMhhTVA!#Iep7)utUawYUOnc*S@-UHD$9mziFJAqjxu9 zac27G%_pWmg#oc*dLY6XR)zH1QPKj!8iIG)U>DsdqR#JL>7;{p^H!y;NpRh`<`Hn+ zNSD7UQi-Z|;JUlMjVi9x(>)&qIAnqLtIX^ZSj^UWUvR{A^r2^R8|{^_pgsY-eb-h= zd$e@ei=MLrp^5v)e|dFhTRIcM?$5 z`0d|DP!6$n#nhqmI1OCaEck0)WZ4YwHl3@E_#j#b^=1NOHo*tSI6k2T$uc&=LPT1A zqL+i$c9@(VujGwmMOhSjP4C@J zMQx0i2v$BH3*xU>a-G99vh1GU4%v`B#{V6$wn*Ok;Nu{w^;_S#sTAjaC)o?OiFL41 zK&^_d^&aPb?L6mh$;wIy-Ol*%iESIccZ};%XgK^nxE-N&1${)b`puGXT*0_utidQB%dX5<~Y8)Z%DEaBdFn^1EVJjkp632d|Vu2nCL zd#Q#Ps(kavVM{_0#CT}>mbtILU*BTP>!oes(Ac)?zBYSdukc2U&4;%?eDx@X zPQf!{K5IFAmCTC;2LR5+U+DFDgm8ioUL4exJkVVg9^QGHd6Hc@)Cjgdp!k?}q`JlI zRMjawe0gbWBHBqSthtcZFSHuxrT+HHD)OO8gKfx5?N>&>p0%W1nM#n{E9aism2#)! zvz&n?`GN?iLW6=MB|v*7%IY(qA&zzXSCwE}FJzv;RgDCHAs1^@(Pa}bOaZ-QqP(C$ zMjcuItDq`a@V2kZ_rDA>{}b9yaft}|kD<(?JA#kE<;$}!2U9Rj{NX$22465Qm92o% z{F|CQ+A=vN9lcH+y^;F&rqpfT_F_!x;Reerb+WH}%z2m~8Mo(0<>4oSlP?AD8b13r zFmmxbS_fQGr`T&UtT)oE1D=EkGV*Oa`P_oDjN8tMlQD_neBqMd+M4g++7GxJiyO_z zMWm;?eAcu6{k!34tF`2KJD}~aRgg$2SqcqnE1}qD^MB|lnbDa#RMmu&hdHF}7#Sm2 zFwjAfOFtw;hs?hqGj1cA{hxFsP|pQ;p-it#n=njF_`U~57UH#v z?&>COsC85};hU(Fl=`O#1%L(ANmirCvHTXg#6Pnsx$iH0!zVioDYiF|MOF_E%~ouM zE@Hzm+KDSpYw6&Y0psfOG^!&*X#rOD!7V?6|Jrxizc;(4(P!#XzNyI`JdmWPH-TlL zZ+oLx7-n6U*M-lUeENphm>$cdJf)B*6mM)PZ=cpilVRF@?tu%Gd@lHspd!~}_{Lr- z?-7oy%jP06`=xA@zEdKeK+>J$Nk%tW@W?0X8^rFuVKx}=4=`P1kK1$HaG$7r-@Mu2w7Qh)_RVG zg{V6-eRm|{?vUy}``>hTh96(*i9=Aw)kOqxPL&c-`4fXl#X3<|5Aq4*2M9yerFOR~Fj$aQcCYg*^|; zf6}Kum2RbfeMmFMuS_#rMvVVGE_G~o9vrx8w=Vu1dz3xiw%=_t+M9WbpGfO8jY)F= zl3NU`5-ohX$z~$jwy?dje+OUlxIqz-iTV?WM`XV41^ipao-BM zs))M^obKg26~U%%m05+gV125GnGj(8ox&|z_i9`x3On3>NT-q64Jpt)!C_PU97iFj zbI0@$ka7K2WbX+J7!~#MH4?U3IiDF$6hZL~Td$=KJG3P6HJ2(<055LUJw0r9!HFup z9^r_3$SQjEvAs2+Kui!zq02wn!pkr_{P}3Yum%StzQtAQu5VMGBD8;G@PL7SHK{0z z9GY0&+Ou~dwFkA z#oSF0!LAK%Kz>nVOzTVT)oMTQmUsqF{hPn;{eAqz%3W-h_4q_AdH(?WZA{S({@!MJ z>#_L9QnMw^lrQ6Dt>xvMKvsgCp)P%qj~!V`7^hCRM%F)~OQY3&@}u8(G&}OE2U#aP z0_|6w3U+MIKUpoG)qQB6>IR}7V(SjZR&Eul_)iS08ZvGg52RD(TYYDD?M+>M(C2f$ zChb%RE!;BHX*_InSnz1>yZzF$^r;?c;*lH>1CL&o{l2--G2@Hq01^~V+NS9aduk6z z8w6z(s2;Xx+qu&8>(0f5r`f)?+cDZ?Jt+OMS|KtpMUPAUJ;vs!wJJk@c3v>PrDU_S z^i2Q4k3soL97BNG_sbUrUO9ar3l7FDeDlS(&S;(1u-k79KD+Tp(|TGpK5hKAhZ!Z# z3s2}7>VEXIIE)z>1$Z15SYtj8T;E+=CMba{@xbHLmj6ETbAvZ}u|QpeV`i@R@YB*n z?A7?Grx`}ve8z0@+196ay@<61hM75AQ3t-|MEnkJVv=7se(%#Olf>mLEk3N`fHgsH zFj2EUN$y-0wmpm{W;SJsHDS}AyI+2mGc1dHLQV9SA6WbInSj2vrvsev*?w*Bq_F03 zwmZp}tElhYY%1ni%K3d+7hW)$(6SE|z{DB#pH*0|7TcPKnc0cEKdsGncNIRFj%!c5 zL_jy&d(W4U^WDav18ld)!E-BRlo_+q;!g0(B$yY;)B$aLM$l-(&nwuSAM|8}{W7Kj z$r7US)w_@>0~*g@9X^!my*JpPs+yswwO2}OG4Rs6_!>Cd4|u$UHC^a`SFRv=Etub} zLUnjSy<2#4OQ?qG|B~(M0d66;H{^E%fPvt zuF(AxrOQTu=VNSL_FYJIb}Fm0?ryl?f^67K=tVFJ!znlP1hTEaK=gcn8p;Y4h{8f4 zpqHq`m3>wVJR)*st@VD+*m@lcc1p?d!o*3zu6%2;a&Y`#j{E%ff175qX(O5DkMDN#8MGdy4U9J{;d3-r_(!9 zF*LdkS8*6ecU-lyB?2AH1_cN*A9}HEv+;1TW3%zk5>$7`)3lO|1V2(}Z3P)JmBOr` zTG4dXww4d}TsSt90qXYSo`ed%AIEG(MY!476=+eA75%8@KJIQ^q&FZN?n}x< zMGVlU^_gr~`++{izEh)-(Ys)BMPBEx(hKe46^%@+d+2}q=>Kd zz7bh!F^1s6dVl2VKv_P2mN_6GPQNb4OoWs7#-lT;>pe78tfVS{q5EJKUyc|8qA~VK zmF2J!^`jzU5DlXGSr>ID!g0pUE4|wuvL|R7+&N91KD%%Fj%-p~22q}aB8DbiDG}i+ z8*ME_)8+jdA&^3zTE-g~sOD&0{-C}R63|sa^G_-YE=Hu2KJdWg#ckxo}v$<%>W%T#YweQ#8d9)G4 zh6+?Lh-YNI|C}Ol^*e%Nl>RFh4?ByEj)VPN812xpo(DkO1}Q;aF04&tEB_mV8}47s zQOq}J70NUhE5#r!ED-7^AwWcJ><;oa4&-;A6ozz|DJc{V&} z)F#HEmu`g?7%LTb72)&*;!0A$ItzD=J601dw){ddEIXr(*b)?orxQ!1jC+F2=^N1A z>ZewZ5e;}y|6K;Xv%>`i2$z^M_V}g#b;#H;qx<{I{)Tnp$4(%kT3f83gkP@2d`y{) zzwOsj<)mB7p37J@?zr@0y*a2h^|M^H8FPh(e}!kRzIlqtgvP$1?A(WWzF+52SK@kD zd!;T7VUu#Ks`UAKDzOaL+v=pA*n2WLhZ0^2o~6KjEy#vZAgZ(!*D`)oCG0Z%n~0?h z_fEnoI?7D!pjrSGBTZZDs~eWfBQRb zPqb%{x`l6%vSYS(>EvGQvYI?k-1sFe_=gs^cr%t}b^WQA3h zyRz;sIVi&Z=m%w0zeEcb4K184-a2Y88=M8HFB{lx9lO8?t-HUXcbxCR+XZ(N)kUE_ zC>5<}WoK=1Jx2Qy4FVsFH=o6Xvxuh#1v-aHI%VWTyw{*x*ZC{ndqqn>FGGMVNQXx+ z#`mk54TL+(Rp`u&ej@F=V>SebTb$SIyS|W4ZTVX?0GBS}7dfyO`rElK z!d30pBqwlIqm#yMMfw~MbQVZ$`_>)kv&DL1y0;2xlUrug@7^j<Xs$v}R6c){qB-FpDfE3wgwhA(_IXqI$jhXev>4dVSl++76 zmtCD`oH~2O@^3P;9eG|#?nLPBF?iJa!o~C>FL(8tI+Kh1_?y|enE*(ScQ8GFSGi$> z<}`%ZfewWlPU%E&vwjmrK;3G6gJZOTW2nXRsM}d_LmP}D(qya4-S&FJn5s`dik|L6 zma*x|#@@lDJO9A)Qf@9sTzLkNv{5dH8G3)DO0|An)teB@Vd1w}ym5ISoDt4$_j=fCfn}gmge--qrnc zR|`>ay9@?^c6sjYgRGE8wBGs0*>!@K16!wjhxbfY`8^kfaD~*9 zkBf)-g7e$%(3J30MeG{yc9C!LuO}V#Ar-d^@M{O(#5M~nhQfVz9ge)?DnY`Z12QKE z9YjQaJ2cZ4?pI*`$FG`%*P9`GN{WlbR$~Dne#Laam^EfAZrLZiG6~L3e{9s~ap%uf zXX;raM(N&@Qk}pl&x-ERMcFd9pt9HLnGg!->fZ+Xn$!i}Wr-IHi0Z}2GJELvnjk(R z{;BXXq1PkS6n|?0#8r4(;(xz2veX*?!|4*p-ntWV}74)Cjco-y_ zx6;b;nLEPSe~{BquG`K z=xFQsV-A12j_iF}`d=l-q#0k_1(aQ>D8ehUn6$d|`8>~Vi?5*wDJt_7BO1oWeFWY0 z1{Z2E@V4GdQ;haj!%|0I<)8Npd95fmne|Wh`=Z&5FktO6_Kgh0D+MoSgHtJt(KIblwrjKNeG-YP_4H3+uzqn?iOd$TyStq=S( zt_FQ#T?YOWJ^0ntRhYGAe35T({gzB-6!KNeik^WEnZ>u2okj|8cPE_yj3!4|A?8M! z%=*9KVO0C{v8#A?bdIry(qjG0DiY{I5Y&Us@M;LWNn?VZ@L+k2V~m9$=z zwL0xm4nAqz7uc-G&9*S6QMV0aeYMT^LdA$ULh8C)3{Tto(XiBd3}abe(=>AI#)6PX z1!Y8?Witjv3+Noz`hb$))S%MyM7GK=?dzM!ddwjaOzKJa29&AvV?#8Sv^qK^CSP+P zEAau9>vgk#LWD+H?NnQ*naj*azZ@R>2g?b1(aNZBBsvR%^AwkHIk@~mBc;@se$9%r z6d+kOHKv`778I1#(%N?9q!A?zYk6y0p3#57es16P#k!J{lYl?r6(uM-O0KGK{>6Dw zxC$C+{#DHZ2LvQEhSd>hThfBeN_ZcyWb;0U(+;@{;=OvZNQI60Ck`X2eL&96_f{t# zW;9b2O)x}O^)^f7)YPm_?g|)@yFme~*S4suI+|)g%1~!f^GcJ+esw5^%TvUPN>c4@ zFq$3d8}1yYZ~&6yNeC$d;cc-QT;LS_-*+0@ZExE+dr_{EnX}ofGV8cJJ1~UJDI*Ao zpZYuly~3$RNOoc3wxSA&5i#u$75Ec)^TUYIOqdiTPA!LM`gXpG?Tq}&%(oOdH9AMm z@+l-szOF1WBQR$RqZ#?~>ts_#!S{f&S+W&5K(+O1{U1OzhSDV)+~TOD{3G4%gSML3 zm0>1gw~3#sMJven5I<_2T{nWV0lBQZ)=(lLHLvNXjs?0zPCK|B;E>ij8S#3yGV$qJ~r6*C-Qj|;9F1l z%05_Nun>TMk;H?aEqo*#bKO3PfgEvi#pLm2BG~ueL@f*ZB_}Fr<#pCDFQxlXN^O=P zz_zB-iSoQ}|CT*D8Q1l0n*yuE|K@??R|DJZ?hg!D?6$K$t+aMKo_^{T>~5PlCTu3> zL916Utvb1yupp#RLZ~*I-PA0NIy41J`X*V zzckFLoIaYj1AM>j58RjAjqCqF|Lc>tHfu=m(BMhV=2;eVx_Hq{I*}8-%`*EF;VHlu zesK4S({175lU{Pyy$3L(8+Bam3;Mi0pP*`PjQ8mWe%%$$R1cafBtS zL2{3U&P_?o~Zz!!70|*zB`!^-<=oX&e?NGkm zEvGWje&!+as>RNZ>#(B5?z$B1oMkqzZdIc(Sb($L&SNmsiVz$_p^N_Hg^8HPJgE{wK?gUy~T!*3Pr2wJ|hnxAB@%nBdB&!1nYzjv$Jw z3hC#)U;jA%p{idU9%s5nWWcn#Gp)!f+>-!!>GmrWSM<_v>=bnO6&z(7H{x zgE~m$m3>9;BXN85(di@l#rH3Jb-#`23q^DA#L32OkP*92gE&dg)=>YDh0^G-2Z7w; zSO`-fb}nhh?KS` zIrQbBzcAbnevHZctE3z~P%L$>8PjKH!v)Vxj<3Q$&Hj={aODAn~kG{ty zlA2D(Nr8CD0%-mq2BxU0BuHJm(*?oys;Ukc^Ce6 zs@2tPyn^8n`wtW~b)GG4#6b!bw}Gm~7r{14O@y(Es)>tgYMKyN%>w)%ia#jhSlvZ9 z-XqhI8AzT$7#HL40;rWHB;?cf$m0i?e3>dE7qY~*8w^%iP?+lB>m-x#1}d@`N-$Lc zTlhGbbH#W>BbOiHBqshGZ!{QwAIj*z^7@NY#TkXz@>US0f_7f2B1HDX$uNXbS4&tj z0|m*#%s33b0T^#GiD(3C5=LAZ74og^z@RY6q)tq+@?nnYMEHXKz{IjN>5tv=vxqA1 zw{Pk77vtvk!!7a$hg?5PM6+o!Foq5TbJ}t{4Tro`uk#d)WUo(K`mZku$#~=OsSu9) zv)2ybbwaqq#k*-AAQ z(Pxtfy<2t%m|&al@B*~EZG^dbw%Hz0U^fxpT&??L4~vqEmeoVA4#HWqSf#+()1Kc5 zSa!iXlmzcz?6Z^mDoptEu`iQhV#ecKfX!1;Y0%RSnYlnu9Z}|=du}+f)%3HEi+A3> zl`MT@_dhOq2fR=d!^h6?15;vl|M)JKY_VNuc|l*6I=qTKjD;6sr^kIu6Tr6O&kiEd zIInM2TZC7m&cB?UOoz)4Da=5==Y2{)Q~Pw=`i_2$mhW8QGfUIo<>(==zyk z>tG&YJ1S5z`kg_lEBQJh?v_DJpHsE_oV;WhG?yhc_mJDeCs`6ZBHpGwy4*%sIq~Zp z>-S0$%?b*H3mP%g&v%>x!Kln6?zsxcz!v9cXno*-EWIg0jFRXGdS<-%)dUnOhv)%= zA^0)XZry@GVwob5W%h-L@-#sOWikPplg&d5*N%0(z42Q@Gwr%gq`FTl7X=n;GQUcd zT#)1UB(2{GlKrtpls2%wN8ML-*W4jE`|;2jMzibJ9i83!4w*wk6I>f^m#qI8|Egf8 z{w+af{Uw|Y7zpXG`5}*+D)0|$pbSN+`}Y&bzQxiY`gf~DJJKlqtQ%aH_Lm)M@sbq9 zD%dYKj9AW7HHPf{lYd>Lu1R4~0uJId!1|b|-WmbSh#eZmyuE+`Hm%1%s-A{Dwl@

()~gaRWim*V}FE$0wApjxkT=X52h)c`6Y>6u^8Q| zHp`k*f*Q_$tRFNyUN%_I6vZbxJqY^ZxShlcU6wVPtX*wL<@sP~eooWVMuFHxIg4hW z#{H_Yxn=C6fZo*XNm3+!ZCr!{ViX+Me8+$7OT=_miOz_#nyvW`m;PqKM0sf1*I&cF zem!-)2O6>)$Jn0X+Iii-EvF2^JqyZDO!Bt(7NOVlbS|puX&NZJ96rUy+#J?&DXnoU zX~d*=;MGe7;Ms1@EF|kp+r8B$?gFyEz3fvz_CEx4egXzHp-yG`D880itKH8#t0!sg zn{cu+Xt7FPP^ z*VFye&+px972Yg&mn~KL4CDG2SDn{nSsv@JDbKGkB<`-Y|CM4a2eD{U)_-GByhR!I z|JAkCdgISGp{+dPegc2>me%WKTE^+<4sz@0|7N-9zmRjc9g7F>vX$5EzH|w z6F-0e+pR_a6LbrRm#7`_0hRVzlJp&FgkdsO`MDT0F#QdJG93l2PXrNa>;_er%^`^z z<3PaML0x~cP0KVIEt>TOi%fMQEk0J}bfK&eO(FV6pdXQ4$Cn1spI6SZ`*E$pfE2p| zzfhxALD}u0>CW#bL3TzGn@I>c(DdIwg1ywu?Aa}O5Jv#7uVE-mdQnZ`OcG$7Rq^=5 zN~Cf|3mE3M z@OLSdIUzs;-<9N1l7L79Pv~7S!I#Y^eg|#cWK1Od!Q_sCTHXTt!G0p69BtJqfm;*( zXSpHwI`J`FaAG}z{sj}KJxj$5GOEe1myPDnP#G5$eNio{l1sEzl1sEF=df{2{!e%s zSg7fASoS&yf8;4hhrA`8si+Xj7iq+zG&ZWmPUZojx~^d=zF>=ro{h6C2 zLU;s}M)};UaIoJW;LR0pFEQ;qhr@#zD%NF8wDEQBuiz#`PtD1)htvw$FvC7cjuqz9 zFoRFa)igu!6#L+4aQ!Da)V0dQwD|sgojxd6Gq6u0EvDimlgpbFp^+`VBy$JD+iR6o z$~h`y$?Idcb#eUtqQdA^t@gGQ)o&?Y6>JKuyV66F4XYH8L|j(8QP>xcg9yFdMimWb zk;w9C7;(XL&?IW0-||&x?_2^x&#w>P2tavj+N;<6&VAfL)9F) z&4SOlp$HqWQ?c4tUvi1QJyQ^`+COp02&L;9Wcz>KPiJ)Jjpb1B#LFN)WEM^qot6Q5 zxSJp&(%4D2Y4-V(D)@xP}O#D#z&&_xnXmSbHdt->=vKlvk~ z&~LNl#c#@A>$$P><(d4oZ0R-3MPFL!BAZDuWxo!1QcTAzy!ZAHoF<3vYGF>tTw71LM79Kcy02N?ZjM%F=03f4 zy{M$LnAk7KMtRmeD-I~~((}9L^c){Yc-c3te*}BsjXjyc&*=Yj_|BB%R&%9i}MnvMYwkNez)7>a)+)z0f5nK$D zfYCN`Y*j;t$JPS9SeR6`wi0>zVBO*vOG2L zm?o+2nRS8Wen97$ljX{bp$lO1p~21pBb--GOAqwZ7*{eZ;uu%+Z&E&-L{uSZ06S|pG3hMy7$pOFu?GUXD-k6yp0zZ zUJ4b0_SE#_;;`#Pe+egiSUmMSlcxyZHFj6~9*QIG(VVhNuUw6y#Wymg zpFgnIEmIw$dCk`QjAYKb7+Eih%eDpgZY`bFq%7J-o-IA*n~Cd-D-hB>cve0Jqxl@) zZxym-;s_5z#h~9=H^Jy4T>k`e!h}egnTN#;aV86(h(YAYsq5RPD#H!#>-^6U;2=gpwZYq`3FT zdD1cd4&sq$Cmf2qnHwL!*E+v)e7j}HgC#lfh=cnUFl4D8x6;6$3Tpt_H$?1~4nmV3&@8~-Cr&dT$S8;5fUONK4PnfGs=Z)cvmS<9M zhK|5h7Y;NYfMnQnw;*T%422OfDT)0Wv>)eM)hbLh-4JR`c(?z-r%i}HyVrvMgCE+c zCcWi^3c?fA*C1>FUNDJ08t(Sz(-@`<&9(@pXZ4YPw&hXBt*MX{^NStgler-YWJ>Hr zvuCk4QZn$Qp^7{rz!mnlIy!Ps4*x|LhIZ55?UTV4(9zeqfxzF!H`+9Tf4e&{WyGTJ zG&@1I*l!hPr3K5ES){I-`VKC&hO36qk@#ZiWDc@P&;BP;_r~51@+*;VOz~=;-=E1} zpBme1kqp7NCfMO46ot)-f9l%;5yt1#mOjiR!!P6I>fEvR^AtAk;2vHOBk93`!Af$gRpD(X= zY!b+wo1iN2v0Xc@$Fwj9N3;eB{@3IPuW&1+j%ojyVjx^RDcy2d;wfvLSQvnobnVV> ztheAI0FF#!*Le#r$p1ug-pFin0@rjRQ1O4^io9gf6lEM%RLe3kO!|lIy5Cc**fh?W zU;%pu7X4gJ&8ifMRvE&|EAP2T{ZdbhUQS|P3*MJfKKdimv~ys9>bR79OM@u|Fa2;j zY>^Fv(xknO;R6i7C(^3B0fE!JYHtaKn z6LG%>s3Zn((WiMd#<2HAmpX&xt=?l=EQIqRY*cqJ;L#wke5SRZld_Jr=AJgm5(!}8 zYW(nmHSYc!FmD{~v)@iM{r=eu5mALYor%tceaystm5_pb0&w`c@$qV#JA6f|y5|`g zhfq0~aMTqOjQSnjT=Pyr)M^d>~1Rx_-RPo@o&V5UU0SLK9z1b7>ESN#!A*$M&I! z@gxY1zZ3&?rDD#V17fmmIq4ZS{prR)+|TiscFL=zUId)+=k%oBmlh|IW-_@aXo z3Fn9sJwxk^D{wDIb5`;9i-gD@!l#t)B7W7^W7cBGA`Mwf zl->Jn0RnoxN)0%9-9L#jiOMnL9lY~wO@s1KAKi;p;7lhe=8yw(6hY|&Ni#zEqC-%$ zqAsEwJJWLOW64w{lVclZdSf<-E>?oxl6uk@#tA;tO(vmWN_!DcrO1q3k5Nh$@O=4J zS2>&G&S|4^R@uMadwsdvdV}1&fK2(jgnf@pC&H zi2YLfoUIr!`yfi0q`R1&Lex*DcI+UiIzya)#8JwFap=+g>dCc3{nEiiL-%ea- z;V;!Iz!Zo^#+yy-N~oxtRjgt5gaR^MU7vucXc4|afQ2fWPlr|iRq2j4V0+dDyPKR! zF&}22cyXu`5*2*85m3({=ZZG}%mxtqiGPIqge>{GS$zh(?i-C098N(`hg^`ajE-xB zF87S?tmLJd2E|2y|0S1n9Neu#8>LUEbJNL=2!DlJ5T`N^6ZqwdALS#5!0EyrNywjF z0bk1Mxx^xg1*wvLCiB`>qK82JHZa{s+(W6V6~t2^xGod`s=w?nY{jqu0|0|lB~xvf zn%1=Ldu-zCeCLgf)#su29=3(yQ_edCSf_S*gJz9#b$uwUR$09Qw^lyr$EjqCbMX@B z$5cKAS&L{|`)m7u{L-Qi+6MzWnx>5@ZdpZ&7cm~7X~HCfZf$2nw=byjZEXrmA7@^% z5W0!zZeA<@_;<7lbWXBm<^%8crEJSG_8U9)jbmshL>1(x$nnm1=zP@udHt(RjqHi2 zg&;W{rM_$wdKN_&wM^T0M`VT6WCKjLZm)VdW-#>?0>+qifnr)SC7yZi=KM(cE=u+U z*%FM60h`y|Sv#tQhbo&xul_pSVJmD3FxdW67rfH5=HVQUY zvVS|xG!*&e6pm$>uk3bIN{f6`$bU%vKeo;>IFqpJ*3rbaZJQI@wllFY6DLn>Ta#yE z+qP}nwsrEJ@B4Ays`IC-x~sdZ>#nZ5cI~~^wS2V}JYM5o;hDs)*u8BV2yQa$eaBS! zu2m1ZuU2{8d{bBa4S73buogM*A)~=RB0zPJ?o$)Sk?!+2$FGR_K2|V&TwjY)iA!RK z9|BrTPcv`v&z0UUk9UXK|9I5_M%u8PmnK^h+u$)5KCni__v{{o7zb7O!+rU@1p_3F%b-3}XYwX1o{F9&&n}#| zw>Vk|o+WpHhH|c-Hii(ZFOpXiAIur`tXNy0+fy>xI!|zdW420rSbKATnP*S@XJNw| zRcE+a7fQ<~!_*O7b=R*eh>dqFHK3~JWOP$Tw&7UrCn?`hYgp>3*Xdb>EfJ};on#OeEv@zaJ^cE#3T!&k_!hEtqYJ71dNu3>rcr5kYm$TvRz5Ux&VxvX}%hWDjz z$+?G@WbYyi96W<#ZQ3uu`S#Qck=^Lo#@9j@*4Iuyd(FjXUbW4~=UmBdvV_CuJYbA2Qsrmwq)Mvcy4(E0NuVT8ZByOdwZQ%TV5=9D-5Cu>O5^J;fnfRQ8s5s3cIp-P>{^Qw;m%n8iuL$CHpB=)DadZW-@p zUH>?>v>GrBwig=O$#vvM%MQFJFs6!ErEZr*FII*ST~!!NL`Ndfy)IaAm18rrofX8K zXz$JD)Xy;`BBHs^*v=AvlOox>^pXIO2hPud!au|R3BRjTA&?5>3HKy6BMf3JSRsQG zuor8J74-Ni3kfL1<6!faMPPb`9z%cJauV_f0KgmaGKLQ>5dwwqiNd+^f;E;CVGn?5Bf*c>tAXRLLi$Mn_tYefO zhx5Uzd4W&_An#nqfNHR}h@)WhsQUwmbpwBUn;apWVS{F)aENs)!%KkBLHeSAmZy%(D(ktN}S66hy(W3W`IiIh;&B|qlkF7>2cvRupUQ3FAv{x9 zYgkPMS`w2qXckgigyX)0DdbXu7CKn(U|j`ouKuH$Mx&>a32)>xr$jRdY3iXbQ~Ddz zHtfgsclg(J&@ojb2$2xLQepHl1j6sZm+21A0+Po*OWQh#JI@+>u0=jrSs1YtOx4Eu z3~4q{t{T2r`xheXmYjA}7?7s-!K)${zlW*OVOapxk8F=odypO*)FyU`4-ETH2U)k5 z!i(H!k*Iu_Umg%&Y~@tSM64SXZa!edR8Xf)HBg7FP@<%psYe-5%AZF5*V+wIpu|-~ za(;V)g%oreU4prEe}XOv+JQO-Bdr&&Q3qzu4__bGZIX2y72bgwWFEKO_(ua~ImPDX zYK)$vHG%*!sCjWMYU^qTnE?1M3pACbQCwUx%G^J)U*T@m2hjck*YHfUQ03e#W*d&y z74myw36l0k5Y_5{_&MLys&LxiAAfyW@Ve1`wL57~K;;CWZ@M*n?!8jooZ8%^LAf+A z^2YseX}RI1$cfymzD%i43Kx+<$(8)!NI_`8O6nuPR&lsVyUXG83_Exg!JmV*JaD_2 z^lsVx49g1^|B;NV*tlbD7B_^ZS1R;pGUzErk(D@X|;tcU5^A_Kr8PmEdNJ0=FYPq;lJ|Q)C zNG11@^bl(Xh7siX2v$S%A+6oW-rAM?_G^OAa3b8aS=R6uYGWKf!blJW5Jb8ioPai| zf(HWO-$!^NNDyt9Ggr_t%A3#brY|2sNEUs$UEsa|^+@wqwqXnNXB<>&*7saH%E^a5_mRNhFmTNgrP0(6glpIqHF0JjS?Vw-hx5xdv}f3%@z6{sew5; zdY(FVf|Bjoqau1<`rJA58r~|}&~cc>s=|eb?>4ekJANqZkf^zApUXBjN>o(eU$Tc# z$iZ1=0`AS22=F0lG>)-fbGtYrw#5`AE#FXM678iApj1r7o}g0w!Hqvj{z*m%Qivl! zo52J|ycrE%k-FIDqy-V(HaXkS(GAvJ>oEuvqw|5lIMa+0q>1Adt@~J$;RiBLHNF`X z2w6ls-|i;_Hzv3u$e-0&X9AFQ*bB7oO}i3NMG&(Tdl*05v4Sr@;@DDnp)H37+OKPE zqn{MKSRjh%LVIJ{zyJN)+sudgF`Rn<(0R-Up;~Oq;Z>?$=mGyBwO2smWn}5n!AZzn zO0D{>Oh5+YI`3)!!jbk{CL^PXCTy6VC&44Z|aO(87%^vUfE;&C4wgf?u~iLRCVO{;p6s;8k|Fm;zJB9Usg*af*E}OOu$6b14x=8+kbNbk#`~WydX)mJePhE zJ%IN#9=?JKmqmVn2OOXM44ihtCvW(dlhQ6&jZZ9=F;9_ru;*%fPNy2?M64)HyxD~U zt@pE3Uca**woCg8Ik&7MCxeM$2+i0=HU~Ew z5R`diOIz^l7I3(#Nbt;}r(b08ZVQA`c(1leA^Q}3-{y82dESAF$!4zpn+gS)k0tFX zhPU;N^ z&;r>Ufo_KyNmE%H%u1C&M%)<3EePGBjXSDy8{|LYRJs9gQ9iP^nrP*&p1EX|&KWkc zwjE>I9zTQ{h$MJRH8YY8z0sgvhLT~(x&n57 z2fA+^DIu&P_MotWj4C?onI2CxN)>*n(4ZHUZP?L@go*HBxP-X}$XCWOJG3G|s7sGl`8_TbvUE>Tfph$!SW{UPV)!eP9Bpc0xpx zqdRHhF{-lZq&%S3avW2nnvbS{on%i!xfVgOPV4|xxKa$!z)Wm^yQWeE#y$5hh>hz^ z&}vVapb98#tOw*a6>~4uZZpG^So=6PSRJ?Y-{^Fvw)Lao{Ch0EeXGDO< zHAWJ>^u{{csUMb-{ZfJwdjOUabz-p!>R+`&xF0eqEgb-+(wen5g$q(#B}cA1?A$pA zU$26#!HZ-FJ^QNXisDHEr(}`+ZS{zRfoUDKQHU73ie)^brgEepwk~g7v3oyK8 zsnhwyR5*+C%h!GuSCbNNzxKJ>MCDb_cilTOb!`CF=@EJe!I(=2a9z=)NcHy5e}#Wy z@8cW3BGK$c&iiE*a@Hyj+4}V%Y&$b(dg<0E zB@_ujB~g0JvqEX%z`97_`m15UvNixWYD#VZOWP>Wk6d0;wSLVlpahXz*r>2ysd1|O zXEJ68nr4s2j=Qu;@?LUtVR*UYX9<7tRqG?h&w?E@j38CreX$p_0NOtuqpi7SgcVP}TY2pk50x3jHpc755A5H=Z9?JW@S^?5VY_0{{+#f1oe`Ap9C2?f+=3nDbZICc z;Tsq09~|F#lzPE)|H|K!FhwPZ7b4yD;=hw6QU~5Q6R?EVMY0ILMKSI#BQ`^hd5bw1(h7<8#{!|}ul9?CU z>6x-6Lu9{N@`1i;$al?V=T9eScCR!WO^ch#80{l4~+7O3!)vP9@P&j7LtAQ$LI#}voOgWB7%AZg2snd?O9m8AOwxgI7?)P%2} zYh|mSOS*h$E5^au0n6}4Nf9;^@x;b`4zoVop>_-NPS06{G4#0zb6NFs;~98))jRdz z1f|pWjmcknF5)*u`VHS@iA2W#Onf%tj`Z_1P z+<1Wws@{6pZVN54ig!mpe(T5ORL_fo9pQCnbPoc(rIhh<1Y(f>xQJe!#Pz*AS07d{ zP<>|fEdrT97V#p!C~jFvjBmsl%sSk<-f0n zWwmLm(9tQlZUqokcRtW@^-dJOgChn28Hm}ojqt^luJ0|fq8BmMu_A&!YI#%s!yCjI z!x2eGVms$aFi;!nHN&tB>5m{2@}94t?eCK*JX*XWF7ilT)ZH7^m$__#qN!-!!qxTS zz{g!*m7)Gg1p=3^<>EY*?4lp(_dW)*^ryp0Mxki=mqftZjp96kO_C2JaqB;n|2vQ2 zNxd=umdA4cm!c$HzV@;hMeIMm9KRPD*#8hx_}T-%6956gqzz4xYe)C#rUw{dGc$7x zsj8IhDtGlK-{ju~DIed~UG+AJj`a=$nx?W7f3>#-=iS^`x}l7!EV8d?SF?}f_(%h- zVR=C1ZnT*lv;QBAQJLt}0%w5s#2#zi819r-nI?l=1wClkU==8=qNbfPvmZucu1g#G z&JLJkH^`+U<4?BDV5l_0;LynU9|Z>dnmag}RFSg@`aa~KHcP{l-@ORBZkcuo2QbKM zDWNzV&4S7Qx?#<=ny_(Ha0_#j0N%CY}3Y4;=kVppvWPI^u}D9dV2Sb_VaLXJLz&8$L!i-ebsh5#yu zX_=6#!Y=l!9#=<$o4R2`Ct#q2bGNqE&tfH)+G@9SdpN5Z)?gpsFBMX1H=u>?t_MgO zv8JC(Q06D(^Xt2zE+km1HJ7_b8J|G^iyG%S&s2_u+I%Gw`#y8|K;a=hUlP*HEZnM} zcp*P!4rQv=xvVu+UVxZvED4Tfz9GSKG(pl)7xPbC->4pn7~R}_)VdB8R~_XiFA1HM z#~=L>%)HW9vGASEtz8BgMC62!||m0y(rofct4kup&Dn<)Qysh_Ho ziw|=da(RT5ed*T8>S2`1TH>1Y5w?C&zxU3SJC^L#3K_lgOmG<#%8p0-G5%Ils@JZ{ zPn7P5%-Cq)aHrYWHxVkl&;+9_2t~H9E$n|tbSEp1j8Ev5l>a;>jATs>jh2Drey&%p zuiTaawv_7uPEN-uGQd+?)?HR=iqAW?*szm#nx{PF*Tl$rM#Id*P-%H=u8Ii^to!%4 zfopaMcN}q5M3G?FKX*;U79VNwF&0i`Mh zi38?jO;|V5U*;9(%XyC{SOZYOUlhCatnhA1@*?dmL)Mu1d~FECm=!^BGx*e57aoEu zAXuOA#C|Y}P1@Qk6QqpL1UyssAT}sYA=m-%;Z6210Dp$tJ7eI9K8Kka0s}og9tsD9 zM{pFNpbiK0MiDuNd6pyis8@DJVft1go7o5)BL); z$6GfJFAbmgr3M(aGelo8qM>O^TgOPBR9(@2Bccvnm~j=Hzxk+#dr0>^6C5u=@n8Ts z(`V8m8U19+_pt#T!OKXni@3Xrkdsy>8Iw1s^ItqmCxEU+tgm_B>82RXz_sJZ9-`lP zK1B~)ui}kW-qTe}(?imNxMGA&yo2t~qIS;v0A|6*sSiIx# z!N(=F?2ju|z1pR^kH%Gn51)cm7uT?&4Fm`N8LoRBenKPI!|)TKsu<0WenODZ5g%Ko zsmGIpy-u+!nyHiSuDOXfo0sIymbS`ws}HEJQQ-Pb_u94QsEym|H5;<P0Qx1PMO; zSnc-OMBe|F83Ya8VNHCk0PkO{c{)3u4Pgd1r*82AiXNA`+60-}sx%`Jx~yZS+&?*| zW=*(f1c5-!*Q2?skk2f`8@GF#D{s8^>`esC*OQGE;KtQlW?g9?(s||&uU4B9;Ni}f zXjaLK-Ezgp$7###lShNz2|$*8%JrY3t|m_nR|nu^Z`@zshwXKr$ncr--susr`S!qX z&q?LAwzq-cqw2CYZSm>Zusr?b!J~Uj7kK%w+e9?ckmKOXHZt$2FOT-yq_5@(atUG=+ujS^$~d}S zY#XJk*K8ctO}SrwO)#qhrdI3{cZ&R$;EU!?82iEljv)1>Y2Vi@ZTx&%f9T9dy-Zb%FCs5$!J4E*j zlIheX^#4{Upd6{jXh>xLQNEG@*#BGjnl7KR(fYq0o;ZkZpq**b{@-(As=9MQ!xEtG zEQb70qD><;STHRJ`N5(O{!4L1QXlQtq(?pX=p5vHr(rWB5XDq5*N>(iE*i7F? z@j}dE9zKVjL^boOGGAH6c;EP{vD~jJLeBT=RlvoyNiBY;m(j}I4gpqy#V4 zo29f2^57>*^yE@(n>I=zZh)2y8x72$)Bi;gn-70EErzAlfQS#2A(LLD(h9hTQ2!cbP?DF}43-J*0Ses9 zK#@O-@df!Sk_io3d2FM4|HM;+f4=6EYBVqMNN9-lkF`>{##=p?!7%beic25HxdvF+ z7X`$n6&X~5Fy$xhg`<>uYHCS=3v_6XrElR%FU%Pvm%t5^#wU?FafmL^5H-IC2~MC7xqfkuZ6{8>cAY+LsinV4}#66 zE92ELC>XJ~_aqxmOOdGl1UdLV#ByJh_>1)w9mP5SAar|moU<-ApG!gCSUsFPa(W$aPWLcx3Oj%^wxdDVI!vu3p zBWVW2#gLb!$OjkrmTiWRy&QWkPK7~pSY+r@mDi#D(zcVvS)2Ef)ljTT7*}i1(ID66 zk%ZpjtNC#-9P3FhPS%AEQxct5SFkWQ^lokcj9hbf-@{f_gv8;KygzTgjchY&Vogq` zEsPw|E}MkyOrEp4(l>m=<^#Acv&bj()m{s4FR9K$^Ej!UUFgHz?-x>6K~N367Vcj4 z2O%bQUMNj=F&*`SB{f%Foh8#*Bovo4&L=FSw|^OTHL>|V7}$$%@YVlKs!OPujWDp< zH$*cgR#J^d19dEGZMv<(0qknZ12wLPwyB8zryru&SPo(TlmR#v{??OpeSK7Qy(`cE z0WxiK$FprQ#Yq!kIxGJByb178jLoowEui>f!P&oYsacV$e-b>>{km7!lbyal@^%1T zudu7UGzy;U2u8F^D$e)Ep19qoBtGfiZ_L)q-~W#P%_bz`i(Q<3`UGeC9P{^SH$`Tp zTGQ*c*0@S?bPKR^)_jw7RbY6DwZAHLpzGNXF*Sc2KKLZ>yA@xx@rmM9V`yeTXB9*6 z)Ta_l@KQkeb~v>AG|ZGOvleGa>aiBLMW2lDlzxEqQsB^V)ikb+aVhe1QFAR!(q1o} zzukV|jov2HwQMYzvm;-?ZFN8E+#0W7ath>3ioIFT@EXACdiru?t`^b#B(BQX+VCONyXf)?Tm?T-rqb=ZLUFcD=-*m_s%1f42=9pb}weD z?9`Hc&-Tn#jRck*v2B65k7-&+*UZI!GhSCVUxihdCAz#G>G$c#1~|3^k5*%&VH5iRktK39uto3|W` zvB0q>Ibg7FOMxZchqH8p-94F)i!K4*r{V`aVNncLmwbnl+xhij6J$MdnwL_B=G#HY zs}~sC23KZLQ;Mz2eElE6-{t6H~dU^Bfwn;N4FcKkW*PEyu0Z(AGqzS-J83G z5d36CCWH{s=5EpMPMC424qekLre!L&>AhO;Ou-jd>io4%pv~Ln>f))si0i&(M&Rd4 z!QZ2$^v&62sj2%4kIsSzsS1aDpZrY`9h3IQl;HXfs>tZZYSl_U@fYqz&Zf8M`~|~# zU%*+jNn?V0 zrL3J1JiT0Op8j%j)jzJPJ6J!S@?O)+0_ZR_>28U99Ss~;0HVGhlJcv58#qq}nG}4W zy57YEo9eZ{#ZXY?T>(5ed>~` zTg>B+j&@yL&x{So{~Wn4@IXfaAAM6=wgOIkZJSq(j%8m2G3`5FH!M0|T(vE!O#2>$ zXPUQ;&Bcw0M|mQfx5vM|Td0}frX1kle5ScL!T7rv7$8P@l3!i?O*XqO=pk;0n(~^2 zlzvkji{uSa-8D%}jXlZa4}tm=^hm~cuvdRqr3TMLZp=>R|0NjVU`gCbCx!Sn6mxy^ z?;#1klX(8$=1GUXbSwdnbLX4p{>+{zEskCQ1TGjP;WAbq_OeSg|F!T(DXjg!8N2%V z5I`qc+K3!v;u_ruZ&E}uUe|J9k2r1*(^>%MvH00Q08AuXAM7Tib3vbqkuv(a_$>vYAQCQS>rWz#%NfsKmcUwc&Y! z{-}=wwb97f;970C2|#{1&YurJqNS^}4%dLL zEVlvDaIAP5x~X(8ej2t3Vssl<>D0A|rrj?~$&5_a5P|M#oi0WCQR0&y-)VvF=x`sx z65_RoN%|yV*r>a`dCVg_{%;e$A?_fg+k|xF#{k1ci{WYC&fo_s=Kj)jE%hJr)XQ9# zb*4HJ_tWTnarQcpUt=_YL6NB!5~mz*|8L_e0c6^#D_;sb z&g<@7D(tJ8Qq(q{woctsL-K0xN$O`mSeGC^x?nrXufUaE{aHsmlQAYxvMcbjyGG?i z-@FmKs&%z)POxy!cU)>VXB=6WU3{X}J_;G! zuVAg>z{^aBp-q~u<{b@D64iJE+G|sO7$aQgBW#QMyYCesFMrxgi)EN+QPFtw%ht{H zE6t*>@0s4XTKO+JUUX!JqQ<1gaB1nXJa-#_q*{D%b2&}V?-_TEC{bMg5kY5w$>=xQ zO{tk`H2uu|kFEhGY)<8{e!SC(%#UBTm5j3zj3ORYWK=6gP0=3axfqh%=ks7*X4bWC zP0AUz*FANBLu9_?*1T$Zui|6L^uN_B&n&N*yM8fKq#WSY&?^|!7+pf2$n!V2Jm9BP zzERog%HbG%kOz5})mwgcdz5XEt>Z}54j|5=>-n4A5)Yie)A}ZG(X}HuWioH7$gMZx`?I4tP=P@o5Uq%hI+)G20)?L z?Me6fheceS?$l#%Ku@t(=#&#Z$u@SOq}2VuIJri!KuqSLZn6B@0-z8J=HuyV0*7h{T=_uIEA!LOsO_vCZ1NvNOY`w|RaUhACu`uk^|Y;@sA%~O}v z&+VFYCE~4$*7R3sBy`%xPFsl+=vzzG2}Cka;iGo~&O-_<99dgWh!IZ}sy5s=Q1mxA z_jFm$BL^+0Aog?yPY&;MJ>?4eND%4*+f9)Ge-2PBJs4M2kbL^Gfkp^F-*~V_3StPo zc#u{MHA%4QicA|>KYFi+>3F|_ryMfSBMm!G)M{VxIW*9la7I_L?f26vsO2hHOg=P? z4Yc^0vOYO6>aC)F;|)1Uv3#&eH!*Uxf20A?QTb$`wJ2*SevfA%1fW`V)?0g3?BDy3 z7lW0MW!;i(Gw%6~<{5^1W|#RKmOsX0g1fTYGF^XYqxV*j-H$bML5L>WwL?L(5*ua$ zP>_x)UNGir+>Kw=BYaAw`>}AeOH;6c!WEWl@Q_uSd%XCRFl4UW^bk^g(RiTbBwO)* z*S#1p?scWp@gQjnza+s%O_d8tK|9OvK4wmh8$_iayg*n7#_DN{7 z%-u6SxXt~I2NsscyS;z5()MsVx{eHvLjhg4O#;5pWDgHjM4vZHUGJ|uihwu3bCu%P z$H7BWm+k_QfbaYDkz!ZJ=WVd0D_`i>%LAb6{8vA%jLF+38erw1<2$$Bt95~H-t*(m zq3WwHR@nufL7``c$!WB}w?q*ac)s2p2)EPhpsOW^6p5i#9V3ng>CW$4_q$Ql`5uZe z;TO#Yv$wC0_shwWp@w<{sCW~=c$xu!<5d5-rmbR)V7^tB{jJ@l34wR2;c9wu*k%17 z-W26efZ0Rw@xTwcC%+${atMCuICah3SQ7{_7QfAXrw{T^KrU}%a)RL`&JXRD7Vt&v z6=&dzMW-h6r;+%#IL?WDUoY-bWe30RPwoarkpN$3S7Jd{s{v@|p^$a}V!NCotQiI3 zx{bYbsUfnCB_n=xP8Wz+h$;AO;T@@qA2cG&Q1}4;P-7!arR4=s8mqwTib+I}(|}lq zbcN!vt3fZ-&t`~^w^%HDeOA?H{?J4%Jh|v+16R4jhwi(Ck&kP*UlOw8N_|<)7nICL zk9mxL`7m}aX4eFmn3P%o$rsoPbbaHa|4JxGUoUX9Lt#}d!&7DjU7-Fn)Fe&DYhEJ} zUIAlno);(mv)ScJgh?Z|Ii)2Fh0`AXN~Hp$mhO(oKwdUh#N z%^%CnqLIKZkT1OQj9w~~#%j4CD@up76xDLOJm1Yx%Dj)HVDA+H=raFS6Oo-$?LP*3 zB+bgdp=85JDvx5O>*65(z7>NKkCiD*cYes1lw3YO+!7IKtR_IufuA5pV2)imObC)~ zyPVP34Z@wwmnQAZ`72g&#X^7j6;GE1onGhoG*c8!K4l@3d7_%{g$`pFWuHKL=c_+T z6Oh_Bi?qd`5PhNyAgutSqNz#0=))kmoqxH9<0Y~&dy!;2NKOhxqnPW4(@Q_r zP0X*E?UOdtbLHrf3>eXU9oKCwY)Vq*g`aNqO|Z4TMM~%A z;_+13=Y^^N9qEhSoFKhp96~E=!wZphkVK~3(RPVO|JWS?kn4_R^@s4|$&Xp5ip`bO z(3`NiPgeeQi{-cw0*SKZ7Pjo+jmiRB2qm-@A1U?OB;EzyZcwVJfw<1a3F=0RoYOPFFN5*2r zOJ@|eI%#Py7CK*VU3zJE)H5*cFve3Vu{fo$vzxjDye;yXgpi^Cnp!GjbUjj8B00?v zm6Jn0B%1ew5yu%cF{h5*;22>3XttiY9D-Ces04Lo5U(g1Ob5I660lHF>=;X!Ku=aw zp_<_oCkgogbuK{gXjW(N_z_sPDqljzoG7$rp}6 zS#ACUV3LY&KcKxvDp&Lr-9b4wcv(Xa1wn(tCaft7#AA1j(uNOy>{LXkedx8x5tfk} zK$vb53GDTE>}|@)F%QPk(w&)dqM4wkNVl(bOahA_yP}C(+L)JuTz`s#6|0Fx8 zxnb0cmiERB3(RmIH9IUAN0d=$y(ibNkZv!k@zs}3Jn_fnZ<}|&cuUL9o%b1RuMH9e zq=&&eTY{{V2htPE(Q~^lQxCT{DWLBaD^jLULP1J zV~K{Be+K2mVp+Q4U@_M^d z#4W8^po9AUma#BPksCSN{e#?~xeA>h%B50@HF0i86fos1MnpC5NcoYhfkml|rCL1E z;2XTwpS710tMjB32?D!De%k&$qE98r&Bi-U6N{eGungJvdYw-r?+;e_hYDb#? zOgzdZSb2?aUt4)LeV;&&BbKovFl^Tk9Cpk~*hl`#Ny8ddeFF7D4`pDzHjl>C%3_i% zljUJ*zyE@OCSkPjXH;A$0DH-=D#aeo1D()53ApUZQr0y3-ZAG}nDxjvO;N5RZ*oyV zioIKg-g$d&&Ma;_O4BLU*W=Rx6JeB)yMCGYwZ*vqGMUmE^cwaD=>~pDG9w4cYi8hH zbM0zBF)`dGG~1@Q(wgZ(Z+}Mzso3#}Rd@7Cfzd&{^Xak!Y7d4VpsHXrseCQ(CZ?wp zMBhLB{A{!Dl1~tui@&HjDZg@IhoBxiq;;!hT8m5NBx0d%)w`^%qlCE<+%@vVcPhZ3 zlt-amlliY883m!d?LL`tETMD(hiQouxIp1^G2O|qrkrsM!SF zfp6V4*8NxXMa#M#p0LWeA^3^87EV3pYm-EQ({G!JnC0{rI4F-%WmNVOa)a2)1}xnF zw6-*#Cv5F`Ll+)b3$M#X8=6$IQNTgaC~HKw3iBW$f4mlvPw*Wp{P;|@r3kwQ^~uPQ za7oC9es|3T?E8H};!|rN8@E_<%I-}jJ%@{AbR_?P8x;>QS|C3-Jfi`)=4}ZeAFEpP zCg~_ERWnPM_!y`T(G|R@EfZp}p}u0SQB=@d;wlT(DFH93y>q4P&Z%uPdR8U91pW5Y zMfuMw;&_6OVaO#g!c(koHTKCh&|%BdBe;4k)|7()4bcp)&rwt~cZhTck%`zw?UfXm zRJZdFPRX~eYifLO-V$Y3=M}_O;>JSw%K7EMd<{+SUMFIi`vk{|p|XMCpOjIEUe!%t zX2LyDK{}G>#kK=Yr>_XgarLCBwVeXw39Sr>5vs09v1+ceNk4K|SM+@JnIa>0y_pZ@ z$qQuwV%!fpSh`A?EL8&Wi9}nPvp>D|qZr&o$$62axlz~%FH7_0 z%^l94p3RkS6@5P0OU04Z>y%m4vwUf_FgrFI)Xv6cQBT9~CJyZvbu8j7S;XSaM3M>g zaD%&ktOw`hzSJqTD^6WXXIxfs*aaN1H?+!tV-stGXgHTBv8OmGk6m(9)e=DaXw5cs z@<|RV%jAo+8UjMPxT#l|SoU5od9F#skzRg&HczTk)cQkQBnyRo;_wXt)Y!hx^a=-S zE~M9d*mJ0L0kGMcOZ8X`i!g%fEGkObv^?oK{U@hKPs?;Bipqv4Z(j$_h(fFfqftv`?z}oz zqUK0DgrpOV~r2DU7T!;JXR zGp86W2Uuc;-iSRoN7vM0&|p~-Nj47r={vFc7oADPu3DpkRmsZ znZn1S*T|XgW!cR_1&lG{S=yrNL)aoGQJT(Kj8sq9lv66}>ci*ES>&JRFJYftDpyF@ zyf0&cVTdr1fS?6pc}H8ziC|?WWQ3NsT(QIGV-EM{NR)aMrk5#-WHz0v6--LJq>E_V zOK!M_$m-eiCE65%Un;3}J2>1W){ z6S+?TjhJu;ewJ?4FJy$*sOTsln50umxsnjEz_uCsx8kIP@kSvcUu(p)**4X*w#~1> zJ$`pUlor@88+DMF#kjH*>CHm9oxIT)>0h5r=fWZobi3rp!V(O)#nC%AKQr7I&`}k< z!#b1u7&owmeyDS=!8yH~{V{&g=?%)<+&Pfhvz3j?i2RohxB_QtD8P2OE62FSak)#p zKnHLVSbXapD5x;#8E|+Qc~&wc4E~lnZ)kM+55Gplb6^pjSxfx@%756l1u>*JXf;FV z0&O=axHY%yb^-vF^KZKp^^f62h2^i9L>-{wbR7U*A;>#fFc>58Ss+DP#BP|O zrCXN34J0&~oH+KCJNg&mR38lV5MY$P&%ND!7%M|elm!QlR!w2y39&*DMiFwt^iY1b z_b+s-e|sJfyy@SCSaHIV#Xzw_@QAL%2QeV7Q8isE0|Iv~^vX%U?eD4j+F;iP4zvVu zNQ0t2_5ga+n56^Mi0Y$Pn#w~}jJ+^JINbx(Q#e{F3?%X_n8_tsJyJ31e`JDk!|L|G zX0TMdQXIpfI}LVwXO^gl-zf)aFGesnO2@@EvC%IAe$r<40DrK)`^%L?iEpN%(}JTi zW;s)+4Ibq#&xex0ujB`?fCXeYj9FVkDFrvZ(f|SyRn?QDtlR9GyhLYCWl-5Msn-hq z0{ew77*hIjdxRbyf~&m<88>AT#uBT5&Tl^374qgla@aH9Lh{=qJGi2ZCo1F^JOp0G3GC ztP8>Mj#5n~2i;gxDz@fe`(!G`#q9r-h_!A1^8+e8KtgQT{V`@Imhv0L%%>++PZi20 zD^(|)E+_UK2m@V3h1gP?*1s_rh{KfFs~Ru``@T{S&9IFW#F$F)eG`7Nxuu39j_TDw za3GUCQk+h66jR*5E?kogTRnjJIjK~^66d;XzzU-(%CG`D2ec=%RF0I`a^iGJ3H6%N zkO>9y$ z&Nn$*K2I+Wf*&_s4qN(Ll}mP_y$+8EUriTZw{ML(9BYk!U3pRtIeLJuZNYXy`=+fk z{^Mq_dcfyn)A9A{dgq!T)6*re<#A)_QQO1ba%xa8XsOYl`otFV!2(``FXgH`RJ+Yt#3057Wvn_3QQh z`{c7KNU`zr5$Ny*c;3T|*>Ttcd?`wzM{yN<2UZ)YGv7Qa6hw&Iqq8Ew1#RveAwmaN zMq4jQtbBTX*?0O7-rsSEMNIy zRexO+ZTVIy6~R6LygxoBqo)8b2UlS#*1^wqCJ@{qro`Vu*g`A)^} z6IIRNK=?g{LuM+9aWuw1C3LUo-xEyyRz{Uc_LI^nFa13uN$%e;k??ut{l#aX$Y&%6 zUBW)Fb1{F?K)&!4@>WKjuZ50m%y)t|ILOP|KUO&9uW$)AIK(^6 z5E`8Z`LM~uWmG+E^r6$)Ip7-`453xNx*Fz9$FSg!6zn}#3U};nCvhuz75TS#Z52Mi zACjbUkGn#+q%s>}yHh|C?^7YmZWECe6M$PHcdhRO?5rnp_|I00!8{`foRBr(YF5;JsJ z`;*27&=`>A-%YDt?zNSXTlXL=rjH=i(AGtm+CvGi2vNP7j}JcdDtsA7+oIlL-;!rH zbZ2ovSNu`=vKh}mtGgGb-CrH!h!_TM@8*TY5c?~aYRV^lpqKnGg3cb&SXd1k*#Eny zO6bLmelL~comJJBCDJ11vHK?8Fi&4<maQAc@)z%^=}D*B_p=sXUuGfImpLgQYx| zU7drh_XVzKTM7I~!duJl)Bom_t z@A{^w{vJdW{zPF&U^#32ag_PreXEC`^;Ss<-OB+eZoZAq>W5$h44kpy?P3UwzkF~AO*c^LC)5B zsPQ_4ui}rIcUz)^X$g)Ogccug`jN1MW=}2|7koNC@XFcPzF3xmzw~pmx55|_6C~gb z8}bEzjRBtwr=j94vsabY<_PrBD1<L$M z>Yg|OD*Cba>{XaOI!o%NcaOSLMJ<4D1p*w#F(fdx6qj*k0Uk~k9TjrvYVx51IS~Az zDd1hZK9a`bL7lgb%@0FCBj5jXI)05;p^>FIbG8%s*vvl#({u)et#>^^t9mRxVK`PH z&)1N7mOkIWNuA}{esZGuR%_(uFd_dgdO0O=Eg$2 z&t`S46%NvbBwlQ!1yc=qV3sw`G0gI+&#eAS$A8j*4`^1wt^2M07p~w05p=qDXtiD! zq||iZ6*@9twm}v9z%|Ge>k4X=;XxYMG|rimc(%DxM*CG}5X!^{lg^9-eT@Ngv}rHBa12DGe7;S}j8kB4K;jB^YE3cD!7-X5HJ(^& zDop|@qg7$)B8fU?ULs{mI9HxZ_m=|;*Y#hjmrI6P!AO76n+B*F=uAteOM3#e!IkbG zKLvF3=B~Ba0v(5;Y(7(){{`baC>O%OQY<0S>X%Oim7QoxanQ_>J7N4WncC z(ulI5AiKeLwu;ri%KJq-t(`<-C0hayQ&VwApk2-UL@T!rv1%_PCq87C@WihK7e^h; zZv#Tc?IFTB2m=c5&I5p~6=Rgvb{fq|483===GF#oJF{%c&c$#TT5@8^JBs_X!D^0F z*|n11Ux59iT5INu%p`!O&mV@J%%sad)rk?n{vU7GqRuv$^jWDFV1=mogp_3dhaQ6y z?+n5R$zIKC3zH(dIGlwINI?smqvKKM^dOX9$is-RWkQ)x=m3XxWIcVE^w}q6X!3Xy z5NW-*Os<@x%@a~fV{rP1IsxheeA^8xRkfE-??-Q-0^NVX#C(+0YxKP4&1#~nj%|gZ zQQQL8K?nlR{N{R_zuRlYBM`AwI$TaS+QIeq-LwY~<2^Kc;g**jg+iUp6BKmC{08mCsCA|A*_2ym=dumd>1 zf4Fijb&rzO8TEKg%f_ZTrC^>QUDQSVacD5Yis!QO>=$)O2WVm z>SDZ^BA^jRmYsZ^-cjMUO1#Z8h zAOYVWG9nv3tJI1V?w0{r&?e9M(O^v89g*YfIsmf)#gKvgJz8%Ky}Xx#?HY0e3aRQc z?hMC0T8{x2LHrS*0C$3GjIS|sBoqu`DHCC-Ku{nA1cnOS{zfU`67(VSRBiC1^#G{M z0;a)rMyZ*?i(!OOvNGi8;gm-zJ!wdvc>qrrY1thEBoV1gZ-A6?MA4B1*}~Lt0d*QN zw|#@GFmR9w(nw>7!Vsja+`L!V0K(pFXb0MuD+RF?9g~9O3?1U*00Z$9?Zc3`P(xU9 z#BR?`j@I?x3Voec?Z`9HK~4A-sRuZ0>{}X~BM9$_uvW&xgtk9}J|B}RVV*^W@c_=0 zd1HFeb*edz!CSnU5h8ebO~)OtX>`(mwLBaoL(oQ6l~eK4Th*eM<}De#dAW7tYsf4y zi0d>7Z$@MU$A;OtP9jWZgX8yW*lKPONA``X@nXM1bT#2Y36IBiUx0OwI|{(gn4Pn< zQy9WfrL?BmItR4n1z$fUSzhSx`vE86LSayw$bsTTE>^l zNjNfzWHX9YUmzQ+6#Jbp7A<4eIS|jhmaQr7vfDV@H>(0knzG|YgoLQJEN*6A$xZ}6 zeSH99eFrMkT0jwDG?))nquvdAeg0)@t^X$SUJhda+%4r?enxk#Z`0ztuBdFw5o=+e zOkj0M%cLjGhy>-BS3{KlLm-`9F9X?py%wbg0p;d0z{+YHgygclQkLa#i@av zVM`Nc0*>@~2u4n?Ed{SL4G*j;cO;$Lke^X9%7KB|Rul|?99@ulZhANWF{b<|rANQP zTrDNN(MTotmsLzVb7$kdOKx)6n=o%W0@&nkIbTkR5vw6jj(bX66`-Q=FVlv*n~Ry% zKK2E?bIT|J5W)$tMNv(ce;0LqJxJ>M=$T$EANMiEw68t3dvV>bIi;S+j;87#;4FX8 zMQ8<2l^<_h+}1GDqdyXR`l=N+-o(0vpj($vZ8QIlg}YJ=c|xFS*|c?1KjV}AD;WYSBnZ0NFR>OHE6u&<@0cwO3#>N;|A zvv=<$S@@WIFGqh>9ipz*y7))%g+Kg3Tn*Or=EY2wMy!RM%&lCM!P(i4c} zHDe%&Y$J~+fK59>o_FkfcbciP3s`x>4W6 zC$@5TsdA3y(F=$=b{8sV)4{0H(yt!;8c*O(QTJGu59;7znWhhyncTW zZTm+LYiRPbV+u$myGO$*F*&=REbPepw}uHvCUj$h*RIS7=E~Pp^xf8`phdb>`{Qs% z79^ohvg0frV2*mn_16|TrAw$TJ6B}Sy=UGMB$(W8gEQa}0+Pt-JoV$PdyT|d9Mn0R za@`w0**_P6J;!g+NKa%TdIVGr;`9KoVxgVwmZ(%m<@4*|<9*;PFV}05?$x-0lS61` zMj`aJ2$LyCm*ebsU3_@A&_kmh>0$V}`9}TmU;PVrio5{)AN*f+{_Ecp)S{l@O+#zo z6U^a3Ap3x%oA7mBlMh@(iH{UtBa%`+di$ds&M+SoR~1s1l+=olOj1F@6) zO~*JC5(-ss+dmj`khL-K4KH9~H?-&d?$d-Z-FU>!Fx@nBZeT7akWu($Ns|&({vNUe zlLxxB&k1N@CyHR>^&r}^C+pnDzx`r8ORDM0#!CUi?4A6hcp}dkw7Cf8MV3=LZ_Y|! zJ5|;6VOU>uD7yE;6fo;cxDE~=z#qLZ7n0rYH6&(|Q0(7wW1Z5$YT4sQFTjuX;)6mNruGh~6p)DBC z&EYKTSVFg%wXcuC!Z!B;Ka^H+eD=QGN4uDyo9)t1)2j!=bUt?RBj0Rg8&Uv5vw)f%rkOb_u5x4B(9e65QpWWwhtO^8^Pp*QZ#(`-2o|+6K!-m=@d-# zXa2Bg5!Hr_5F}C$Ds10iAUXA5X+O#7ug6!!g@pRRTsm+u>XjlpzuYdRq)>4*)^^?zz^kVt@h!n?oG zsZR&n+NcMMMT7mJ&mg$s7F%?qCnH_!R6G_G6ZdBwh<8rdEGK?#8xAVme(|jt+&}B- zJQf7IxH8zvO2u}2ZQnWMY+qP5qQ=?nl$X|$27#nBU zVP6okW=0`!u%IM(LgASoTHSs2P791us@cTakC~*4rsd@6x+=uL4k8AmS;A?W-je zR88%F+XzZrXx*EJ34d-i>&O~CnhupLmyiSjO!2;CQBhqGGa5h=^|bD#hLjieCia81 zm+$eZoGIakIp{44xj9{c^Umi?K+9gyW=eymkSCcj z={zrmyvEN*#Pn082Ll55H$T9GLaJr|kxxQP<9tOX`$v0cW=jJm2m6;)V*Ovd_Z(gM zI{Y^H?HA3d#_csy6*O`pCL}g1O!~;eX@+r8A<08Yl+o^u>OvF zAH2JZ_++*jy}?F?3|T!Y3c_OYQZMl|GJ!eUpDN8iC@WZLc&o0^!vm7W&<*+r^X2m&{chw8Zw8s!yGI{%76v&)kDsSGA7(c=pq$YW^MIIx_`>k z6%fRzMlF*1v)vS!W2Msrwugzon(__r6FetE#vZM&Apj_;ij`ks)elWCCO7@aFa{tj2WmUDP0~VR*B5p9app(X)~LnyBgbG1ukjpXH#~$qL`bLeDXmCGCiV;Dwuao{cN#sY=c3mNqyv+G@RF}kHlgvT2r#d(mcuE#!i*a@gWiT|TxjK3Bwla=syCe{Dr>P?F8kg$jT(yEY zxOb;n-2~spDcudRrZ0cHlPAsorf5*Eu>TNmy_LE)e8!T#md239xi-bs&L(q@RBk%o z!{i4hcSp2|=`jm*#!!r55UXuC@dOOrmj-n0q~dAf{(I=F!`#SR@J2};rd$osN<^D` zSqOWy2P$~ArizHe@1}Mp=H)z>Ff#W%>KnwB&6#sE)io);=%ujf9_zue{Xtyp--pm6 zq~nM6+1W53;d&m6JmDi9`qiYf+Sk$r%SX*ZZN^V|ij20SO74{Nn>SiK>QSl@FciqX~C*;IE$eOF`TW zzKQ*5iFHYgB%CjFh1x=0(w5;<$KT*ni4Bxs&V{_o`(ug0DY$h)93+ZUe!4Nf=fzCk z-qGfLmS~1cqWtKx$m<(gbxE#nN+)mH_qpZ;7#-_Qw_F|Z`J<{j z1HjAmVqadbm!Fqk>p#w+wBp5|5x?o-;~IADMj5whj|K{Fik^|(5rC@g$HDA%Ue(Qh zrdxF0o#d_VM%UR@)~aC^-jC1M3F5A=$Jg|YpupGX*>>1VU9YG5_wDiYg<#Le(*b4O zv)S))L4%*Cv1iU&z{f$@?hZib^l2CH`E>SGwi5aJ)c5oLNC>d50eoyO0t8zSM!%nr zr*D4gWF=E5r3l>119bHZMiflbdUpUkt2_6G-ViveHqU~tHKt>k)&v@wzNPBzi!}Ok zG(v$VrSea}WO3V^8*G)CZq&|ALcR>5rauphre{N>X9qctUcz2DKKpJ8yjHu{m$RJS zu%b~8O`g6O8#dWCLUC*!W_K-L8b8mw45k6mx`%{M_wF2{fZK>@!SDOY#gDd|?~n5= zer`I<%ZUPBr{M0hzuR{Th|9c+hY=c155pPi>TcY79iF3Ox}V9LUo(a0{Oe!74_m{e zyS<%=6%=%0FC(L-^Jf%Z=+u{`p^MkU9ul1w2&#Nd?rIy53%(-hDhHdIE~OH2RZeAU zuhA;q50JLqfH)^FSaP$mGd3!HyV))3g(l3Mn%UCh3%g?Pk}{YFJ>%Eks_6nn4&8`i zioYh%KagRB$}8J>tVWl5C>sj#kfa~o%2;W?Lx|Q3{t|Nd(e97Q`Kv!~&@!^w#^*2>_#-uHmm>Fv6Mg#-`*g64EPDGM^os z&vBf)8Jx31cDEQ^MXVm%-+a<-YZW-xuX9c3DYjly@h=-Ak{kMWc8o(u6es1XDdcc^ zS3CK*07Yxt>o)<4B?k>)w;Q;cziFGtztZ)mZ!=L8-%c0d8LU4!Rx$$|&9v4^4ua;qUx`~vPNEa=16na# zny0f$u71(~#hTPY@JfOmS1{%^rwFVl~ z-h%w+Wi*21kLkbqwgL4qln(r7=`T;Qzr<6|m^a9~08%h9R1h3eJP3%BkPr&gI0 z5mK@#)mXo%9N2XN2p?CLe7+r!JLouW{|?YQ#4V?PKQJ6Z%wQ2JZVDrJLjvGtxRG0# zI9dd2j?o_g3ypo1CxR2kC{nLq3-!WDn8< z{YY^Ik4p#cg?cKV&l#`-_J4rtH9pbpf7|?z@qYlCo)TLRI4{=I>3q(hoqquEKj{Aj z&JU9XVJX^TY!ugCGpU%*$OAbu(HvRx7XO?a`2N%B$pGe0z<+rEmrwNIWIp%HFE}=f zxolzQ>upE-IBx)4CadL4K6lXZ{~u_2{DtiCpPhjJW9D4+cG@lREIVWKW_;7#&W)&^ zHSfX7V-LZKJ!Qs}G$8jsV5OH0m>@kulw7w82=RaQIU8R5YZn9+gPj@V7~RqK z?RoVDt0A?Fap^Mp+cdmbiGQO0!SvQ(-Dfl+#vdvYSHZB;D$<7;UrNifpxobxjwsbf zgiarRuIw$7HgKl&+`0@JD$BPGA5M?1pIK~P_eG}bj+-z*!lESx5jAdvj7|4U?q~Q< zM?&1s@W_7BXYVP*&+zP}M1Vz8>^RaX)vEB;{K#yIt=rG@(`ddm|3ZsN{;TsALlCk# z-p#=!=;8xJx2OsHyL5n=%=`~F0r%p92ds4Qb@&qge1W)&B{IIwWwewp@P>h)mhZI@f-5_=!O z85g~~Yi=;q*oD=To~i|t)oTMMy>1o! z0^F4jNh7_)98;gV9maWH6tKa&JtdXGAnJwE1_slI4qDq&kQ4_NU2o@~n707^vm9dP z27+;W2dS3Dj4w&~>&SGxV7}qOISC0S;LF-`SFjTmFpEC8o=O3u1mt$>67_0Gbm+me zFquq-xzS^R7;ScPN+saxI$Da9w5yc3x_#+0QjCr`6^>Nn3nnMy*;K2<`$d(qkiI(M z`Roa=^}i;``pfe;_pk!I!Q%k$_26^bu>C!IL)tkwS!emJgRxXyLA6+T}2M=O7PD>UayU^}gE9}Xk5C;c^tcCH z*qbHLzOpc1dhc{k#r=RZN?6l#>A&CxwA-@!a@p~9XXY0>YqEH5WZvz+aqvKhr$3g4 zi)L5?{!QaOH`u&66bvd<2Ldu9#e8#<-C(K6V6MoZoqOTt33kMLPg8P|N2b%lD=}yc zHD!*USmJTc6>#F&mP2-}s2qvW&OHI~y{v6qQebeBfABNYohN`W^%&k62cywyfvL=M z$R{`)HQWc^q;R~ufKO=r9c8lcw_*bz8&q~ox;Ng+T$Tr>nG_;c03}u+F&l-fW_17& zY`xV^^=GFX;IP!kCF8_XVUWufLp!ggpv`@Q?21oJ>6ZHv3>iMgPmKR)6+7msxZvQ} z2;7r)FiPogdf^wa0okOz(ct0WT4c@I~Ku@ z3RiIY+pQ`fB3Ef#I*IhQGC-M~PyXmfop;4t_6Bi+?6YOM;!!g(?^~YFF25moCptRO z^{AxqF~QOn6ixUY^Hpqj5fGfzucmM&coQ6#6#b~#BM(^6VdTGxcI~N-AmA~bw&0dH z$+<(mx9)R3;k=xnz$>Rh2wG zJl#O=S^`AQs8s0bJDuq#%o~{9;)@{$$nT@#m(i;oD@*1Iow|m*ARw<^Aen;xQa{oa*vG^i~*IpPsy6qIw~Vw^4G z{iZqNIV6*o?m$Q|+{gE^&0lj>I@=voY|lBCwgy->v&)w!9r6s5Nl(wN#UY`Jv+0G- zJ&~u5AaoQ`Ycvn?Xw#L?u*wjCXPTicUmzt#C;l5wTbzsC?4)G@i_TJX&0e&^gZmHUBDfjOf6|pf*|`5x8%zYi#rnUb+H-U!YsvlvmOg0D z5haqv62RaKB=U%y{rygv=EnjDul~LW}wyrWPr$B zWJG4Z#NwGEY`~}=F}}t>D)8bSsEZQS1i3(X4=uDv& zg%VJH(?SdWxbi+=wa{fXM97aVSj0*t`L~AUn6Sl*?eU3OEJJii*=(Pg?E;ZedW0jk z6?@9Ez=2iM?d<5U3wv8+*K*Gv;P2Xlhd4ACzuZxU2QNd*nNHK>^x{b&+W~W2MDbf> z(c=@r{;a3DrtsLGlXGAwCJdl(0f8SjhmMi)dyNT%tFRzftA&=XBSwR9dcH_p(_)cv&~ z)ia@ZQRn0J4$>nvu~0%-Z`~6mdSkc2Ss%c(iC?`m4G%$+ zkt;-xAD4%LRi!g%*bINOH4zJV7)j@;d07(GO>!`6Q!VYZJqVa z%P5$_;(+5WQ1gk!@wIQoD%gikQmomzG_2vF97?oWaLTR9<@n=7T5u9IL|brPsnx48 zG+7vt3ouF#jgLad3k<}8atcO|=mNwFjxa|Z{#Mgbaizq49cMyAD{3o;I2 zxju-y?Jv(5+~*s?$0`l@u&v@~4vQ9OsHfrpx45WrYOt`&iUDW?53C)+I-UYE6_xev zmM@qCSEm0ujmJgq5Pi;cVP~nb_cB{w;oXQ%t*kM1) zcPCqv-t=8C24PgQwc%3OI!=G2tgAf}<2!feG1Wz=Udwll6lg|ehF1;TwhPDj#qtvQ zIP25fp(q5uUjb()b-R9F2W|i8tZp7xP-C-s-_N`MLOPGDeLs^wU(ZizyR+<@b)Rpm zhJIuHZL>1H!#|%#i+O%;N2|MiZ}^v>f?toIwaZz3pG^J_0v-edB>{->orv1Vz1c`{ zkiCCn1#g9V`LHjN0BG0A^L^#8u^x(Zo~}6 z4Fh5qLXljW(o(;|j7sX?L8Y(C>H_c|nVQ{()h;I1c_qFZdKYRKU_I1$Q1{|CzjZd{ zF61`zxubQ)DuSGM!sHZlJ1X+b|13TWyB=oj+$#K;wq3An$)3PmbizHbDlsxpnE^GQ zAvMphH3gNyBiN!c&a?#^es{U#ouSC#oBz)7LZo&&EIcXjUOzR3Wv()w3&+C`%wVC%i`)C}j1+dHxrMw$Pn8=B+LZgW-ha z{E?Cs=uoqdQLUWR;!AsmRhI`{Zc=Q|P%$TLoB|Y$4GIMFt2b9fw$>GHt3}&;i0V37 zK16cVVdqTCqD`O)no!ZXN|Tn~GA11GCx9 zZ1l*|FO=A_Vm_CG^omJ5W4~|tD4sfoUI9N(lm^{azjaN1znIl9w?68%U)sLetEKTv zCnwOvsg?bXt!V>xm&(CJjNL@~)Vqz&+St;-S=`CGE}XQ0Eo(qio7 z#9WwH_vc;Y?`QVPP-AtNl_h6&^b^xOsn_HZ!^rc1WLNQ-+aj5rD9p5|$g_HCcN?JK z?KEehTUlqW`6@tK2T4aGo{a-L4P)I!hndYT=uC@wp_^KDCrqyyxU;VC4=+cW-9@XB z^&}E~R+f~2cUZ5&Xm9XHuhH{E@#t%95&cIpTPsiNss8Hp55CEW$TRWr2R01xrRiE} z+l+X#r)*Z5PLWZ~1^Xg;(UDAUC=B3Y?1?u19t5gR=n_0Wh3CTH3qj;DG~_~;lhexg zYz52;Bm}+2weTWF!yw=kmZ%X(`{mO;UUo5#v4R@AYr`V$>4+n!n@JQK_UO3qYo2_m zqlKZjcgdDalQ}E3B7G>PR39#3U+pUS^kdPFep zSv&s@#8c*2=(9*=NI~Q5;|mP1y=A@mjqThH@#pQz=dHWV>J!V-g4ehA)lP(0V=tTI zC1%Jg{e6^`e`Uz8GgI>@I88d+UOl!>nvdUjjH%C`lcUPBbEH4!9pto9F9nnB%VFlb zXFp*wEd8{kuqU*V@#!|dSb;#~tP+H6Yh#Hd-Bg;$Kl2CCpO$jgejpl($yX^(_ zlUXMH8RkQBH~Biztx+G)sG(rdbAIIJ)hYV17$u7TOk{X9f2bm1gyal zb#@r#Oqx0~gro+D0hU6xLd5xtju4gFqvc7(bpmc-i9Epz8U4q}>s8W6RlS6p*m5V6 zr`6AjKus=4DsCdE+|u;iVUjy_b&{Y8rd+i)$#z_@c>gBmmXyD=EqQzY>ESw>arGLH z{@XbF*KJDgK4ggRhP&He@YuH_d2^=}**&IxGovfV)6T+g05IdzuqXwkP5Te7NAFl(AWR3hTkSIsF3FY^OcBrjl6AmhuTQ?(S}NSE}}4 zayFB+ofbn_sKHsec}wIiu{r&J~`We+S} zN{L1`$*yE)1)w;94$=FQv4Cc{D9{^QM|h-C*}MvyGxquJ;L9?P_25*Yy>ihw&EAN~ z)|e%c6>|38+xh+4akkT8#aQH}KOB7$otCB9kphaV_-1B+u-{3Z=g;tb?C4wQ3mP$t z`um4vnGM1d_@=a?=OAmRMfIaV|7*kp^*+Usme%ooNDCc~(VG`l9I) z`ZR@J+Jg5A$pnrOC=NeR0FlEq+WE6Pj&STjPTro2CG@(_PXzx1+SSKxU0~a^d6R19 zce6mtiqGQTUquE9-;fy!%?oJ>5-4bC^+YHX|2~_U)1uK)umNVQ3Ev>{a1nvmUTZn) z^U`i{P$i;;LOOh}H<;&F%97Z|Bj&SgBH3L{G?z~Y^8zV=V)cNhQ0_jNCR`;2c-j{Tx0 zRbD`#&XScC@dOx{UrbgM9aQeHoAAH~V?9|dS2$zdvC(GH^CPxuY9>~l_jtTZt=ekm zZ9WT0R`Mc4NDm&7dC_GiD*QHxpS<7)U##y#Vb*`vL{ZWgcukSmaMScTjvXoz;Dbw% zPp8OdwuH!Jn&3{#4N#fGYX&lxqXDDOfEy2_BQX_|NCZ$vzT=jOo&S;BHYj#yKJ7}| zvGGy=t&#k{$P@&Zt5~SD>Gt)Dv1WRiU)t|=7vIL zsjgq@l`(`E?4ANStfCXfm<}bPvPHLq6Jf;3)OjqtbH(Vv$~K~W!TBQzU$Q?`ETWJ4 zRX1hY9;>avKWh15--$@LVy1O}5sPVY@@{@02wZnp@2D=nnkT;5EQ+!F1N6F$P4b^h z4#LiymVk-E0nC;*j)_7Aa0C|PK;a1Q$5QE>)LD(2cdNR>y4tY&^4P51y;{q3Lu+9% zH%2GDFNl~Y#JSCTmxKpIL#MxnWpCyn@avCQMt5-Ebi4>qo_OZI_*zEJmRV-jZhxIu zK|Z_vw!Jvz=@i#^Uo7AWns7BtFy1z2N)r7v~%y&)Q`+9u=_!P9JSy4jsy}wi0 z?rKzP6O^EN;-dzc|97T-W-aoHy{+~3_V?Mz?sMfKPEM;PDJRWx^+10vc5>CnWA)bf zdD_mASIHb>?!tPEqPr60SN=jW9hYmEy!xPuUX7`iewGb%i{qkpU0&cD`l2 zot52Ahx7(n61%KBz)Gt}hImzm7YbIkd^}8NqeQh_t4O=EK-`KAp}XC)X~N7p*#<6# z$9H!UKC74_MVb1_48Gbg{3_*o-YRAR)Cr!JzOA64yXA}xG)SzfS#)*syk(e9R9#J_ z>eQ<;VnaBm^dsWIoti(TNWVGjdCmaGlF&7qNBE-x9UV;`a906gP3RhCS9C&qPRob> z;tAh9`x^Fk!tMT>IE2pgof6>=<|09yD<{xp0}ey_F0$VQB8eJ&F;VAHfal%6_rpI7 zp}?QXV%)j~B1j{P{m^OMRzZ#-;#YetTg-|x1%YN51N5Ea(rPlR$@{FY6!y+`kT z4i~(aa3*RFK-L)O43F*<0jgyGjUt&6=Q##3xW;SG-#erwa+3LWuurDH2wqQ&3 z7#nfVQGo>y6Gr1FdFlR4sP1AlCXnrV9Js2J9S7KUhMBR>UId-vRw3qolpcH>xT&Tc zv-!LuJ#@u51QQN6MEdCW2@%Vr30Z1h=$F)$RyNag4A{XoUK( z>?G4I`D`@u96u-^)VS1Y34LPO;&cfEWK5dOKS5Z5O^N&2dzW)X!k=Mwknh4=*f1f) zFwB~k04}}m*u=twdRV@GE&P&EUDAU)M>~k1^7K)oMsIv34U4FagMA>!EI8IJ^Q{L# z7g!6~zpo|*nVPS$!3Xg^d&vh|5&W@kw=64QV#A9<6bYTTo0@_}e{3Qm{0Rq<2w**Y z>=h2sIklJe6+A#OjPNw-W%^Nn_r2@rB&qss0cPnCV5g3JO2TU-#B-VG$?r%BUMBhi z*GQ!Dm&?xyDj^{zzyP4_(*C-4tgq7D@b;o+k~JtxkBE8{{ZIZ?*V^;er5N=*P4$Ul zYJ(jfA?G4ZOf1r$kmWEL}9 za8LWL+Lw_yaNFRbxPh@sA%w5hbJHP) z+k(8w^P?^agp5=AL5zeID!;hYORHsK0BO*|j=uy;bIcV+F~Z7U1wOroUigE;D?QVv z0S?^mBZ3FC7Yt2TS*N*8+YV!swqncb=~uml?ah>>AftAmC`IH?hFx}#lyP8}=1*ek zio-0MdDwqqdQU7lo}c;$`qb!M5+ow-EuC}245+iw6omhn1r9XrhsmoCF(oUA3R%lU z?`W+l#KQ?s4ef_9A`Q#MXFTldh_=r0koGH%RShqH=A31k|IM^EoWA#Q_4D+rEDfzj zKfSIL1XkER68f)ww2}-3E^R9S7ze=0`oDxw^i`B?f|!u}UNjFIOwnRmTEUU4XZ{Yg zvd~|$$CRP6g<2ARzC>YeHbOAmZu`3LN;0@*lV?~;nB=L=I%7#MhpP}xyCwA9cohRo(e?|Hw+?; zDVrv|ki#W9D#2-8y~wYY?DxqLf8?*n9$brxB?v=`J%(GN65msk z?5-N0^J-e?p@iW)V(^~}SToXWW*rZi1gcS{ITE0t@zMu|R@ks^;LLtIIvTN^HHAzg zcxLrj9P|F1K6FjX_T6L~rYzLO34*@x)a4^P{O~oVIb)6z#-i12{nr$O(VNsUnD#l}sD2Gu4xN#Ch7uRHO!Acm0eZ0BzF5yN@nhtk{>9 z=yfhTOx~t{TwviRooe8gj@FC&5gevkM!;1)Hy(p$o26(bV^^e~GSK=j>*AiAdOUXr zX75dmlJNez$b>fC7l(dq2Y$#2OT2HF06-|b3`RC(w}l!Ov?nM~qnJOs0XVqN;L0pFLXyKUgDTAyk@@o^(Nt{kP#Fq4Cz3I~WQYTARC)&v%b05@(1v~JJ z8=Njx1aptJU0i~Evo0QO<#;$FMHMZ%u0FUDb5&yMD)C?$`0R5aIKx~$`^$aOko68zHTHUYlj z$wF(z?=g=n_i~@|tSAre!!8eV_nS^ez>_>9#e@$5VH&Z?y2kekdI_Sq^WB6ki_fu1 zD}lhnFy}Jhr3_A&3rAdYq?t5fLU9Zkx`a&ps8nJM;Ls@^lwMeM z4(5?y;&umQ*ju(bUr6egv{Weu5ygR*&D3JT64-+j$_pG6LMj*}J2*B{BNdjkn#h1u z5eke%Dj4aA#h{dd^Kicec>;NHx5m)?mcn_x1# zzQu>v!Hdp`2gQk|);~K^TgmfZ(W|njq{tDxh6CH+dF;Ot5SJBcAxE@GxZ>l%RbIUI zCOM?SDdYqtklxW5k8LI1%s=Qmy}h6d{C@H!&lSpu$v9f89EBKD;Arh^P!!yB@kBJX zOmD~-)8KQP?!24z+iltAqV@X$M$a<(uQ%;KF$drvc#1SPQWP=(>?VDc_nCasJPbQD zGr{vNC!rf6KiR|a(X>TjA%hJwcDO)`89WXa#Q-~l(=uGam?H|Ag1_RFZEoNC7Bvd` ziGr^StB9K3#`DEj2bZDgyOT}TD-d2-zU2)J@%m?{?RC^Z2S!jZ9VyWKGKF4r@6dJ3 zBtagY`#jzgnZz1kJ93nDx^f9|h6+w8@kBr$Psb$jppYlD6O}YEdI7Jo@((o3_sta& z$$NmWd#2e$mAZ;`%*dF396}z5fOa<{e`~0j)t>5DSwP$9@;b{X;H^y~@lWKlZi=;P zDCcVS=Dul!?ea$KiRKmN$**iM0Y6dcqr%TOaKG4)IT-V_BncFhG(w?&TTd1y3QgJ` z844;uRg+-shJ0cg968xRQ*Tnf)kafo7-&+*2Mt(KH$`P$pD;We2|5la)CejLWhY=4 z3Ct4)g~YKY0DZ%s3RdNIp!2-;YNM7eMZ+QlMx#oU9~0r=QvAy0=WQnYA?ty6_kp|b zEiqV0DxQp6kjrJY)>l^(A}rW*@`U5Fu)z^f>cFEoOi$e2CN;AiYYM(aQot)5KLhJY zp360R<_>%Oh;K05zz`fycGmnaKe4qc%kToNpfF!?V3LB9A^GT((bo5aqnHt=cg+Z^ zM!n=XuPogdPZgt55V>$0CAL0uc*+$bLHVFnw`8fZQfpANY~53+R$(x4zV?#p{ihk= zh*Lr*mr$uhs6IT-K}l(4MkrB%)~K1=V_@abNJB1Pq%Fz6a$s6A=e{L%Th8vIG#)DG10^cmD|$7z6`UQ zehyj_`a@h+Jf{#dnf7Q1JDZEs);1TgZbg!(hn{cm2n;GgHEB5vn;;9a0c?q$pRcHl zF5gMWS8HV057Q4Ec1O_-)a8>6N^S(mhnSQbsv zfIVBMvm5%of9W!3ot1A8`HG$be@21Iw%nwU{WoTMa*G7G&DBfLx!NukL_bNh#Gw0(p||8FEa>gc@ilbk({qFID`Jf49XK?=vkHB2;v9G>)07rX?&3*X}G;lpW#~{WR2hSv{oGZ|=9VG3l@zpT^xy*-Lh<~wG z4mR0pE&g|JJdjJ_+VIP{p!{qu(io0Y_j<6{dG;Ofnl0j9_JN8`;M%6rB5{t5Gp4-! zm!<1jmPmrBbyTouV%L=7Yyw_`DCn&Vb78k+Jt_ux?eqFNYIWyiPp7ao0DW>+qP{@Y}?Kk+cqY) zZQGgHw#`3h?{o2=i>~U6uCD4;YxR28`#yLrDkBAt)6-OdX=^kFsMXX2i8W`oFV~rH z`dT?D6+RGHTdU}Ds~fWplsJ1uP*SoIaw~m(LWYUR85zy|`EqP+@p);Ps(JmZr`1M* zXFsEZ$8cxnOCLi!2U#zUS|(@2@9g4(kj*n*u-BWA;d&ZavSgyo5!*$SIJI9w$`6S+ zHQYuT5kEAp4;l;y$m%-zHxR#xXx@QEi|umig<>mu`kmal^A$$)i)H4Ul5EAEBMqyf zaL%@_thOo--TdHV=#NhD?jQfgq!LZz*`v#aZp1kx#kL;K?LYn3b8T_CltW#HxChG( z$qJ@4HKi6Ozg{5T`cNFSm+f0=AfDzEuoQ&MEmbThcZq+}j=>Ca&9s?Qu%)g1Y^@p_ z8;$?$H6(*0`?jbPFfmiRsnOR`=wcNZCzSZkZOOiZYIR45UBcp?kM-*zeo^ zc;uWH0BE#rx^8u5w6F4q*bYpH>E&xsWFQNWj|OMr*|{aV!dp?5Y(c)mJy1h5=2yj4 zmS%R3gQg7&Y=#%ah#)h8a7V<3n+=EW>)<cbEyBua~~#| z9tGeiD#-??_lH^zsfDiJPpZbmw8+NXYe4Q|!zLE+wqL*Tv&qNC{Rfl&00u@>2r>|M z_EcIL6l_4si~Kx90HNy=X>hZ2Vo{gNg{0-mikK_i-BXhb0_CFqKnd1V)|`1K)l-Mh zvYh4P(c2qAB3FyfzVU@!HHJ%q^g6g=Wkz$3#Fv&{1>qm`?ebkO7xbp_2|Ycxq2q#& zFGn|}jg6I#V-;evR{ZOqibCf$?iFC4WZB2<>YphpMbjInI6k?Xy8L=E z|5%C1WvJC))21kI7bawnV=MeXsCH4N$}i(|L`*@wO?D;(Rodz^Iuz^v*RjRotX!J7 z>ercS*5>T#$J}w+D@DeRPy=j}9M>E;3OW5qK}zew-_2k_6d^$rV;Cy^%#TSyHzY%~ z7DzuvYAAQ4^aQZ-pq~EZ7O?Weg-o!2nNXStOr>ZGM;B=L1m?D!;Qulu_|rlPrV|Qk zX!MK`c*Ehb|5B z-xo7J-^j6bxKoDBx+NnfB$e%4IdAn5!mHgQtCkL*l~ZT8ZyGa(THkIyZN{tX`EObX z3zw^aBhPn3MdNdkbrHOA%kAR*FD~>HACdk71)ap$Y;%X@1^=6>eNe z!-V1>1}+Bfs~eO{S~5U?Y>n%?tc9|BEc&7`-M8zelLOU5FdtrLhR~z^$S^*($1v{T z_KQ=smm+M@#rU?+wG%jJQBcG(G@jfAscfe7_@9}xKY3G8YNt{~&KA1oSRz-LgpI1X z|Du|P#N~;^3?~@!@lGj{vB)C_2M&*>d9qBi`S+xX2la2#!A~1XaE%euIM&xG( zII~Au)blC_XOo{myt*yqIi|8+#mm9 ziOHeZ1GfQFNGRF1QUr`> zQG&HY|JvV5>$FARUlT@a-4LPg5ouk&NB}^zXfMu|Od(hw7 z!GN9Bj19=%kPk<V(dUFuFz*R$+fAILdh%S*KmY_EX zaBxk|t*(!lxc+?Rwp+`W+j?#glcQB2T>{XdW2ih+}=w6lVB0LAQ{z{=x^7AmF(sRCQCc|!p$X-~P@+0zqy=e$1~;QS7J z@8OYpzjs|y8li$oNreogCC$vFrAz$2q`nq|a^J!O)gjtArUt!~dE!(R=;%pCFn$^mAjV8sCNwlNT6zk33bRO$5=IqG9(-@GIb>nDR-=|MfM*B}%z-rSW{S#v zk4pp`_c-xGB?U(~g&#Ir@XHHKwkD)w9JdRej{9CDS2Pxl9}it>D0u8JSxYQrUHEqe zyaV`*k<(f)tZtL60S*BC{e=}F0ys{nNU1ij-ohutJ}&KL-#OmGSyN$%TAM1i7sRyG zDQ|@lJ?Lgy;RP!L&~<#HqI-0&QP0w~Q3_HjpqV*MX^yDD<@wfbWV&{qH&?)9@h7}( z5V~ro$t$ZH@z%!MI+`iFzHH;*;v%9|&(&pa$}EQ;ky6A*&W zaeE!5w=hs;vI2M$b`?r|#BDN9C%WDR8D_~~3>IY}d!Rc3U=aG-J^klo(yMHWwI~gw zDtB=a0D%!Jx*O`i67!W3{LI$*=64)Aj6XB5eDX2gKq4m49af(9VMc5fB6fp=4M#`3 zC{U$XlS<6bc>fh8Tg}&S$S`Q6yI54b*eH&dDQ&1xAFsVPX0F>vRwQW$LM|Jyx@3>w zc7GdE`faWa$jN!R0VT%2pEn`CLuFk|FUVaXRO5W1aI>K<>o2ki$J zk&>XKB>P8#C60=aGvbSYj}Y^_>m&S|x|W~?1rCJv1P-D}ibCV|BE*cnx@-f^yf4Zi zYp~xORre*=eJ$Os=Jz+q?6#hk6cTK@C$WjfDR4y|0D&xT4z3$MpHVK1IpvEJlm8A@ z9i}u+p23elx?dw{Lt8t@jAk(Y0N6DkZ!8zo8kgl)*RT&n2Oioo)Z5@_CJE#x@!5K0 zCRA>)&EdgqFo{rFgE3Zkfxm3{8?7{&6xP(nDbm&HVU$fDQ_iZXg93DBFD+(iZyu|; zdi-D(;CPIwec)nyb=PKN_?zy`PJzr+5Y$mNU(jq(S@g70Gu7{F#Iy>3h}FAey11=9 zS68=LhAJJ=TzAo;(&aI|Qruj~Ok{V3&VUJ)RKFD6f2kB0cV2^q&L2|7)yW8m{#a|x zg#d!ZHioK4jq($hz$707j*D_Pw&fNeYvis6P+?A!iSc2X7 z*{MYN0!g}$rj$v zfK90<@Yn1bRdD(zXY1E_gh==t5PZpFcY4vbg37#bSmfZRYy~mi=8vZY<4oT$`?p01 zfIDQ?vb3PC4V*9A&jaQiLz7%?ur&ug>y4;ks%yVpu{CRj%Wz2#{4yvB)B*;`abE~){LzVJJ z1{fg$)}|8=dD53&pdyCkxPO3udr7_p_&S<&`z~SY&RP^(!IL|{qHRKTF}1w$$l?Is z9_n$l?Oii*$k-q=7f|aGrlmkXmv(G$G%~fMz{pU@+%kZ}*5-=yZ&djEFM3;2>;-@K zzWUSj`5kFn3j9DRv&mX9qFbU>NFukQEx&R!d%vq^Oct`!>eP=63i}i`AcRZ+5W{7e zLRC6S`Bw}Q!E09O8mAhk3}@JhVb4e;KzA<4aSwJOnrh9FtjqN#&V<38=oj+>+ifd| z%7v|RbVYltqy0e!|H%OU%|;-6ek{%C5i6^b>QXJZ$6LThXFyu|8uZ=fj^Fvz2nl8Upp9N?Ry&k}wR_Z?s}kg;%k|EgTdUFS@`RT7gcjZU z7f8>`%F&W)WBYgXU|iXODF#ODg?G^#zUYVVzcEV*G1!FTDGk|HK^`3-+GdQzP2(aX zploFpGThA}0c9Pnj(8OXz@eqhBB=EuOJ{eg_-iP8C#@GcQg`N4l{-&%u+wYTKR!vP zrpMhQC9i5N6O6VyZUZo%kGbvcZg;Y55g2{>DzwH?C@T6#l*FO45@a4K#28+T18rZ> zYn$Dx_ZYL;^GAh9XV=F;0}N^L&;?|3XRb|YuGAjHz}e*um1`$_01gm){fSPZkXo5~ z%~%-*$eJpvw?BBtYiY0)`lNsF2>yQhi)8P8JpObc3|{CVi3a7W9EaB!3jupR`_^7M zZ)lx6n!FYN9LoxPDW+q^9|HL}QWBGQHJDmeWVjhvM~Lmikdj~{k9l8%cRHyP7N+bC zdD9v0wmT3Uzx|~Jz%>{18;tH-;6l#oDd!%iv1)%xQ2787Z+3Q^40&>LMAYBfHebl*v`cuWf1inP0oNstf&-S;T z+C%3-_ecA(*UqcDp!i$~J~tZuq=VSWdLNYd(myJ@71kD4mRBe=II+7P z+@KL9)~4&-Pt<`rU4B`W6)eYAX%Uu4>KpV*O1FOM7fLX4ooMfZjb8+Pl-Bv1rs#b~XP**8{e^ zURCmJ4$WiP*(t-O!1+JpC%lFhh@OM>z^A;b)iXEOjLOIS_?m7AmV`>WN!(wk5*eZK`ld0*RTI^zWYjRt%wA|KS7?wmYG0XcLXqWq=ZH*E8bJv~bJTX4XG8sNhqY7hTWwwa%;-bY=e`dY7IiQ5B? zf3t}80fIMLjFjWW`V$5A+$v0xQZmhMJ`Xfzfv+sz>gz?`Me^XPXT>iSX9FG@iE&2Q zIXb6FelhA5%!S|Iva|Z~MNQw?7PSep?gU$(L_VMCSk0WS*YM?*{_swgmUM#NlzdVd z05~?cyEZSqhIQfk@Pp90Q__&2B~UI}eVwtU9|dl#Kl+Y6A>zb_@t5^2B3u!^w%7}2!#vo{!RwjaWv$~MVEVs?V?>_W zaeYd0QNL%KTm>O5tM5|KF;gx*4Os4(I|24U+dL$GpXgPNHKoGl(oTn5%(x6eTw2rG zD2@FNvOX9?_E(yB=?!@0BiHh`JRR>5h}*L-#yHeD6F@4(mFKUZ%Nr3T3lb6DiFIuE z;U&N}Y6y=F_T~FEHpiVh-)K)8Spam`^JB<2L?FjYW+j7EilDW#tik%GTKFkmasVHp zJL(hSYap825bH)(!_~q|4E2V+?yp-pwCltO=?H0X1)~K|G}%L!p}0trgtb5BA37>2I!$4UbK=L8*AL3^9c%ISKKgHWe2%daR*bgoO^Lwa5K!`=0~5 zMwS%t#qjrZ1Ni3WGG$z#N)_d@6~HwvI>V65OIlEBgf>u;d{w2D9d;Jgerrak#b)PM z%)Rrf50Zc|_~*Lsl=%ChzrwZ)-(UohtO<5_%5{)+(u3L-BnbcSz&^J%wcG{QK1ln6 z$L57D%=X*t8x$_e@*1?rngoO8_C-8VD@N;3@7=6D+M&$5yV757VeMiXCye$%m3(Mg z*l;E8JT9#azeJgMl)>lXBS9D!elyM$r)3JwU2iU0#)kLhZa(qDe2C!v=P;YfsE$CE zDkgw}46qF%Kh$QW zG{r1V4!xMbn#&LU$(gcei$sOujgdoxl97ju@K7rW^;b)Pk zgSG87GFup4b=4Ap-Hr;Y2M!VmCV0DEn?#o@4bSSpL=NkZ$7Jufz8idYK|BR z)DJ=KhbPC9njnaR1Bg;BrDj^1db6w(g>(KLq^VF!VN=Ivkq<5cMIwL_lw9%)Pfdak zjtVAC9~26Vl?qDbw+LALn|=}o`kd4)qbP15{6SM5aMmqETXWO&)aY9fRuV6wU z2M2-sdVB?Afp2s43$OwNVYWRkzdmhX?0abCdE=F48T#I_|`3{liHyjdB`NS&Rv= zGF6%eI!#I=Yrr@j8(4Yr8229y7}UQp$wj450gZ_;salU&P-c5RhGc@s4N#c<$!Uf^ zjWXVNd2LdDa<5D6%XV;s0LAJP-svpU9A}n9T6y~^RN&M=NDBAF^;CP_vpTy+)17QW zL&+E}K7n(HZK2w)fv1`2s`hLL)L)VP*JWh8Kvp(R_IMG6wm= zx}lKrCNOE(Sw1Y?azRU|h=VA$n`RDy^&EdtbF=s?k*;}s6|vnI|nICs^j^{h3&j2Vu_d7uiX=@^*T zMsJta9~}6rlbAo+?Z|9u=^y|@35gt;ZHE;>vj6Wx0E6ssEcjO(d>A6iT0d?_FnH_f zzeBFOCyuSB7NF~q*itWCoTGa=y}@9qO4!T;Ou*df8ukQqGZ~{sHu^pvUO@25ZuT46+<`}1f9qtS0U$+j~s9gf)VzF`A102|; z7#N0uM;Z@sDyzr$AN`U;uG}IKv`F03S!ub7@g&?Fk=7Fiyi_>43 z*4{Z0PzIPSin;=j{Yy}6zYQXKgoA~I_T`w@i@Ts@%`4BJblO2H4|ghitxPKg#E;CdKQb`GJkf&9KgmQqn$=C3iciqT2uLWBg*B! zKfc392S6)9?%Xsl*op3MD>qiy)i#ux4b%-$?RzFVVR~;-N~*O?4vW!UikFi)QIM-PGv3MV4n0<5wI-!kNNXdg!npS z^&ALttk96?FNIL&5ZT^R50buz*I!YadKFa|HxUP3<=Zjy& zaue<7Li&YZjuPq_51_xbB;liNejms6vEPf)*yX>EuAaM9Av z#XfOhU#U_}E8RvcwIT=*yj%TgtTtXW* z3vS;$9XrlA=_oGQL{1?b00>o`d;I958H*`1Q#wl=DM8QW`Fe|5DcPy33)K4a-o%<) z^>{zHJ}5h&ptO7LEtZ)Vag8_zitaG=-$F0@|7-@#pzJK1sW=iS1OSwzl$Cl!Q}$8+ z*Ib1em6SeopUk~6fm}wf1`)*e-H0|1$WmbEgV#MkO`rW zT|`GlMjIL)+;JS0rW~?R6~#y@-C3$t9HhpA93|-%8N4cy?Zssr!y;a+8Zo8+P1Y1{ z%$eXv!5T_q>CBKcfu~WQJYt0Q#GN6bZlY=Ui`OL-tgB^ypaF=HoIkG1LLe0SD}rsT ztrjI7ega1XisUcBBJ!K88!9z0cm$(Hz$^TgGrU%Ig`&arWH=ExQqV9=A`*E$H``mB z-#@*hnohm{KEpH(VFWS! zqETX%Zf#Pbnbe8p`zuw8uXxC#ta-jh!(+7{e{xC{_=h%q&dc(^rA;d=7rU@g}4UWK2~Va|TfkUcF|Oy)~npBiLIdmze`Gk?a_W0SUX8Yv0|gjzTyp zK59*>5wY*bJRwGAk%s%Vc;CCKz79pl<7CUgO{5OT{@t|l?XdU8u+uE|)3CEUq+T4i zw?a7BAJtwKZCJ!f^Hfpa&SBNy0$JGUJ~e+QZ?)l+6|=Cs`VL&@om$Wz@geI-r-CeK zn)eHg>;MmLC>v8>>C&8ZsLlr&TcJDE3}v|~XF1W_(T;18qk5dO`-1!+6vH4Uf~7rB1# zdq{V*$EmLAATb*c7!d(Lv+G=TFuwjjf&knrBe=^6>W4MBS}zrw^2XGAX%sRr&!}0W zR9qPpLa;V=+mKX2pPyC?!+%z2YNQOxFGvT+$J@t;xt4Mn6gm(v~-(TMLt(cajvdc zA;cL#Sdg@FP*t5+du|5pdD`cU89mRkhOVB6rr=X28R_j__fOn zvf@aU1d2k)EngBbUKSJyJwu%R!AwUjs#5~KKU37svl65)-^#n|#l8(OPhKfN+JC@TBMsgqtRfGav5kwot3fAx( zlS?0ke2A(*H@+HjJ__Qog^M9e2yLs?ho(Q6b3bZ;IbQECo!B{^c;X+ zV>H2kCnZ~|KtBo>fRTZXiSz$&Ob>ZM>MQ?y{)XLURi{GS=JjwC1m==nag z627~;YCHD6;>>lL_CdsBwkH_azYVc<*lOkhEN*)Qc2zW#lzaxsPFD-&Jbi7b!$uE8 z6ZfiEqcMxY=FBUYot@PMx(O=0oy*~Kmqg0fo&R-JZR?+MEuX^! zY1IFoSTb3k+Ntuxz%Xwc-o^$~i0#w<6c9zK@?}en@o6E9yEHnQ-&&q{YqJ zyx`TL@zH)e{9~uvZqaafCwpGSZjHx2H$S||IlI0!!P&byKR30ty~Q}Y%HONBCqv%g z=IH3Uccfu(ZPPY1mHxHr)gkN6rXrtXauN%Dk8;msG!ADt2}n~fXHN0R^a#Zo>70l%+cF|!KuwpNG&Y5~=VMMzAC@sQWnfO%n6x%UU{2K-r7=xm zz-N+9H<@%a1#d{u7^*Z~Vz5egne;RTZHQkTv^H&KSc-ygNM0SbHnUF0os=7nsWbci z3qa-vZ5)uM4-o4oVa%R1I3jb3Y@5RAYdDDBi$2o09lqN->Ke%G%^b~~%1Q8%ai1VzIWnj)P3@~Us1iu0dP55a;uP&LG5X=KJCEJBZ;h5!R1*r zSz+^PUpKYFsfnT9%YDlbh3|#A7Qunscyf{)GmB;+M)_DX^ZvkgMFvh^ zk|r}^M6O^Rqx|F_!)8S`+=ckS+i95-1@_^M*dBOL3E*PnWF%!Ir4%hDbRLyqN{uDfQ$`+EHKP4tAmYp7(MkUy?q3dDf!0kZU2q1; zbC^U7uOJNAlftN#x$sZkU%NKch+m$=l>j@+^q|Mi-_|2DghnE(bJ4FCMcZe5|8m6R zS1awT%>!gbK0v-zaYmFgeTVS$ZX6xB`BTf|62ck;+?W`H4}hc(Nelk@YMDMC8WRt690-Yt43zdtSo^e+Hcw`Y_>=CG8Et}UM zp$7?<)uO7bgquMP@FRG;%awfl1aud@K;R00m*N)anvZxGRh`U$Oz#7?Cb%IZB4OEO z^7tEV+a!`R40MBjpP?|Lh*vR~<}!>BGZJ;0PWBM;Y+GAns1BkxHl!cEebU~5JFlkF zYoHJiWq&@M&wFyfsUK(m2JPshT^dG&w)=hl{s?V6n1zmE%5IYCpn*aLklcW(66rl! zBbO$`_&c!wd1zh&*SVsmnpuyYk*6^?811ay;9Gv;-69=Ef*tDx1dDWe#RH1m!v{|N zhyV?rK#YkM8EF4E3_=u>ja;X46-5K}s~y`4yVLn7tt-61SM#ajMrifZO_Y_XnU<0h z?WuJ~+bm&I8UJ9{F#>FV^J6&Gvh zbj_Qjb5mDi4Q}&hbJ&#$YH0vs)l;A!maSIRqCm*~U(Ytu?hN>2x$`Jw(DvKnlH)-= z>j65f9hAze6;d}l5;=5G%LL016=K0Rt{moZN$9N6f;2r3lv{v422iavd_8#mbn|u|8;R6QLch%s ztIKk;Cp02z8NC1Ag!12+T(9?w?!3`LcY!-}C%kdq`$O{5xy^DYGKQ;S;wMX(7K<0| zl|>Ix-?Z#TKYV+5X8AsLP~VRk#^vYQkOQ?Dt)GYFEq7uZfcluRzxhN=wV)n(dSE%? z-ubM}5+lYO!PJ?UUBcN6^+|%47&UMolU&Zf3aR{ViJ&*xJtKn`=vA`JD={#M4oJd` zs77^Bh<1_s{7km0QwB)i&QK!DOJW{x1%W!b;~x|z)I(X@_)n{jPl{!bXji+KL^m7E z-(0l`D5j_pV1_4fz{)DEnnV9Bz=+S*>v;%4M-g0KA{#kRst)TAFSD3$sqXr-&~dXy zt`!0K+nih?qH6^vOQR}3_+{TrwqLQdjb6B*QlV#L^cHQkVOzg-Tei4S|w@>+{99`cT zU}6r?lKPt)uApORff^MPl7fh+LZv0at2}!kNP877duHtzGwH+AIwZeg7y<#jWHfx- zdOku4+^*SRy2Y1Xf z7_n{nu}8))PFAk|kMg`Mkd0?FqvL&7Dzpaq*JW+~bq9#PG-9y@tX8Q!))a!aKOgrK zA!@tR)q16+5}Po&GbPve1&Llsp)xNZgM*jnFb78d21vdLvTE|_`7!P%X!u-k#*>E& zRu>Y_43z6FaPUvWifzO%-{br>P_5|ns*erK@=NoFv-3~BtYA0|I%5K(5n^5hdryvW zT=bY7uxY6ha6(P%ce{s@@p&)rn5-~ZJn3P85%=$~ zx89Ubr;4SN z(4v(RZHcO>lcin3lI}rapjg3`_^5tiNdjJusLr8hIHJzo&<=MtUH4Fc;en8=94Y7+ z+AZ84+m)}eC;2YhKKW6a0MCFOWGM}|pyO|lqH-48(D_YbZc`b}&UgaYYx~5%evKzt z1VPJ4=8dM2s-okD6#gip;bqBkJNXF95>CjM=3FbW^%G3gksVe|+4f+zRa_DwAG+>M z)CPkxr2TsXe2ek;;pB;*y-HnkTukLHl=l$_Y= z7%EsQ*tKKOX$F(s@;L@fzEXK>k^Tk;a*N$ExL|t;Kb^Zgu#SN*@j`JRdI;+;9DQo@ zM76i1Hq|w=c>i~cV3|qBCzW}}!si8}Z9(3};bd`@5EHS|u6R>GqJK&)@0cnU$v0~zE zvB_KRo_PgBz!pjY6YEOHi#zsYF9;tnB`{i=>uV9ybMpwh#XXqI2bF$N+T96%kRu;M zZ}b_vKS6vekCjx`0yDZ4a;xC7d*%-M2v?bc%e0$Yfv@OaP#hcOD zj_l&&C8w1ZC{6|}>5cO5)rL;VxA zB5}3>OIDQnb#%@_}d)P)CoQT+4`3D7S@@NI%SorPBHg>`St(r__e0QI4?=eYC_iJ$PQs(AN1%00Cf z-KN<4F-#VwhbDKGsL`m5l=o`o2y$qO0ybOm*T#j-a4zBvof?)f_Dkb=XGMEOCu~pe zOoSewbc1^QEJ=727lp0vmii|L42-KBF3Mo|n?$wtCdYa+sY+Sq2O*PDVVa;#dErG+ zU@BKo&1M<=dpxvQi3-sS3-9sqYnhM}L3o5WA{I7{E?{lN^5{xzvEOkms8rU+a9Lsh zqhs)U&B(Sj0GAHN2|kVfEpO^7fCJI-Ul}C;EtI;_-fR!9IZBPoL_l3caa>~x=9sf= z1;|7R+nJzK({E($8Hr>IG-htve{>jBEqTc7bTy!Pa#8ICaAeR7s@&VS*;3N*1NI0?iwtDOAX{jqn{NBM38hRCuF>KyZu0Q1%_l~Ny57)K zmyiYP6I$QKT{3Qr#ERWXeDN;TQ+Z|Y7=r1J}7tD^a2@}Ri0d;E8G`E|E>mip}f+_@x zs15R94v|vSnuHMv(9;h-ZW~@Vkc{>ttq&M*qu4@7yPAGjY7Y~3`w!NL&{(J?V=b%f za~r;A9`W_|wZ`GjyUG4aV|Xe+X@Y5OMK-9>b1zkG_01_%S=91)ECJ8b0UAq%ya`o9 z@@Xw%t^OP*6Oy)m>>{E5({z`W0ZaQTX+ZPA-^%)a(5b^q1!$9bp6$O~SX;Fq@%~J% zm@kx7%B?=En&%%CprKhipAD&cG^ng|a_!+MEzyY0dU(QtRyS4wi+HYp7Hh;J>4z#H z*!srMp~E;#J(Q>?iya=EER3R*c>zaQ*gJ6?_4+NZBG+0J|4$})D6V9nSOEk(w<&SfNK%MrA8$VIq_we)78RUL+aKiP2G! z&cN~_F0WFg0V(w%A)Q$&Rc~k};LUvY{~kOl#5H8JwjYbY(M#9?)yUa3Hm?`=OH<5h ztLs&$HMQq_b_Q%I#ShE;zDR)W$GsKZZZR^;LQzlRmbpUn1EglJsM^fDLy?gYazyJ~ zda|YfCRI)sCE6tF#toMrOAL!0=AbI@mm=EGF@ZW*uo1}6zu?rs+b<2`3*81q3}_jXT5!;?*K?2W63K?IluX?%JZ>{!U+CMmrnX=^i_B7v*hT~! zpN*&|lX%#JBp6+6qukGs4XD$J_aQ88e_3Ps?4+_5B*Vkkblq~C*}|jTORLuNae7lO z$NUz8;mQ-awjW_S@jYaL#(bFeZd3OQR?!Eeizj7xte^WmRr0RxRlaK_@*S5)dnJAV z+NM|tC+`a&m}v5ywEmm>Plt_v8V!IZ@@VxK@*aPL$B`9Rg=c3VJGRCN>7(&BQPPlo z4Kg&O0DM9t78T)ef@1l_J~y>0#O{;`hQ4c5@vR_l`|lSLQuD`lgnvaA)p2eG3?`Uy zP~kjBOM+ReKez1-{ED=Qm@ZDNXd^bZJz`JfHntleGwKJs#t`lgvX_gjG=9FgE%O61 z;m8AQq>rMsJYZu{GN;H?xqdGPe^INL|cPZw^i+&CporPt-vDyrszkOrc*2J5h^M%p zdvuBqg`QOikC8VJY`GgL*V-&v$~Cx~wBgB-bSXHNW>*Q91PzR1AgO|!t;fYmLdX_~ z6#krpz!INR3(Mhphv zlZ zo-qrmkLZFSaYyO=erMWK7iEUZ;ubMr%H)%n7)2O}GZ@qP&(5cNEx{)NRy>dk4NIBT zJfE;)y0t)1>LRn)Wf2@OJ(x7Vz0uT>m``WZytzHBUKxd`9#X`KOY@>$WT=2yt zYY4;5^lXRD zErFXd3$H25^oI~kA9%jk%Gm^PRHL4Oq0SEUC0t(H5&u1W#HyNIoXmqKXFDH^?+-9& zGOKT}*jF2dUY9=Jg7rGx@M>!-n}&Cc1{4yn$Y{g%ST7jbGZ6lM=sz=-uelcWIler)kuy2?iIgP6GlIVmxOF>V1vE z6x`w%Q)}f>sbB~YqEW!eRt4b*9M_l@Bq>_Vy(4=-UJn-B{8mfMNY8?$(BfVXvaB}- z7OO-OMH4k^Qzr}{skE1m&?5xb&?T7)6In^3A=@7fwf3%LA%sv!lLTzKIG(q?gElpK zY>4lUB{me*SDsk2SLXo$nY48pW6X(x18f zHD{da1k&+EP#mNLA=@_qa6OOor?t;;ZZTd8Dj~8|12pZ5Tj?0vJ$92b&f-Lr0IvXZhyuw4#2Z<%|%LYC~t1vMbvI3N@}h>!6)L)vnTFC*Nw$n65BPB<;@sOa&** ztoH~ZV|9S8$VO)WB;$#%n2g?cd$PQ|?w#%&Ps`|Dvc&A_{9Jm2mdK1<9GIDg3z3*@ z%WVM6a7xB(?$or1soEK2yeBO4B;3=)^t9atME-B;y-|RuLjUb)H=uL9^CD;f8Ry4> zIMlm+Kj_91OAe)P%R2TiQeZ6IUc$D?c70j`gU_rle})7`%{C|UQoy=zD5%7X#ojYs z?>PH}_MW<%*RzN-s4uQL77J1>v~$SWWu#90%|m|k9@*NnkHxaUmU)ggauRafz7CQq zlqZKz>pfAUzu?+IM39+s@u|NmuG(@DZZoyZcq8~7*Pj?*CaA2t&9kmKQ%F7TTETv5 z@-tC|rW%!+e`01NF5+1UsXg{TYyrH7ZyVwhE2Cg2A?1ClKx91TBH-2%&y~Etvy)Iz zfum4Rf)+mS-<~xTF<}3^l@}h(8%+D!CLz~Z1t6Z~hHFL$j-QoLS3Z)QRWb4seoGY+ zB41$;{uFT}#N%@={6~EpY4h%FLavUw4%sjm{C#GMxw8#gG)im}g^8Nl~1O86|;`ad_{Y}()A?2#@Rvex zn3g0HbNi;X5nCE~IOcWKef#vRI+yf^-p`zLnfKp#-}_p3IIQQ`D-FjZ@s2Zu)#g&+WLK;i}Kg~&`K4;NyP61A>cPrAQ&&o`BtLIA(wTqZp z;CC8MITkazas@e0s*#^?Me0K=KxilTw*jnX9?R+o&6_$@l5L|P_!Ul1xbTxXGU4S& z>oA#t0r`)FKYt;-bze&ldTQ0DpJbq}9=CnK7`T7z7W<)KS|-r%Y?z;X~;cPJ}(~P*OonokkVUilj z#?ngR_Ky@RNgokGexllXFW&>tNYi_A&ve5}xB)eL?_sHyVw{nplTn0qTWl}A$iyqwgsJ+aTs=}LTBbOg&lq5gt3Krh7E_kl7HL+!vMsB< zk4auslbU`J`7IwTyBqR0@go}oe+1jCCdT}Dt^ZvuUk(8%z0W}|gp5l+H5Fk7O;?~$ z?EePu47GngFU#d#z=0;EU{4zxdM%`5(397%zw(^;Z!wiZTro#YbUk3kqg{#bG(%-} zedlWOlPT{<^sEs_zB!?5b*zyqG_ZB8uVwaoMW zl#~d3p3sg=>B|&e4S{f*ZFl@80j5W8`Gca`n;SC~i$2pFb6O{NwIjr1o43r-AsLr6 z7K_h@LyC@n2$Xfd{vZK-okU$OLehL_KlSMC3VwU!y@Jy#(0ttb;}>4$mV6q^5VZnv z;kcSXBGRD8zyAm2!gT_|&&zi&o}=0{dQ~w}xde~&<=|m% zv%iT+>|%W&d3|9i14w69E~f|_VA)a-Qh7+UagSc`O)>bA~v+W;?HOuH{7>0AXKe|X!cx)1%9=h6> zaLn^Vtz!H&(Mhq20s-#|VBI}l{VMudfzlV5H%}kpP;}hW=dF&Nf6jZzD5k*l<;%wA zi~@0)8gbY^72y5F-M(Axsa|cWoX({g`AywLf|@bb)B*PfhTU+cC>cn!SHSOV)8!wP z+p@TO2_3HNi4x>KCd_15+R zNnkv0Uu3|_fr$)bTQsc_`&b`e=bgcIWJOwJCD32BlAiFp|HAHtkojG`$ESRk zOeEwPNpI;^c{kleHy$%vK5X4pZOygazDLaO(Hwt8qCd2_39dwQ1TW+6 z`5BD7c~HqesJUajJjduk)%t1JIjmeQdkhEi)Qa^ZRZ2c)rb>q$!b?&7pz^g{!rNJ` zUJp2`xRuJ58HeGcK^YlfSdtZN&>dTv$Mxj*y4q0Hlz6B9MNiQ;7D;n{-Wowq72~LM z%_!rZ(IJ^NrTS(M;z>8@ys{n)5;oA2fF!Q>{@N0EU$T$#G4xAVTUZ6T+2O(ina`Ay z;hVTSE$?mQMP+0C`yZ&*dFYB(e5E!%JEE^lh@8e4Gq(1wRA9*g!H#@FfQ_{;*VOJF z)Og;UwX>xsM%>M}5ze@pX(&zA>U8$h>UEfoR@gxdm}x;viDr>BZ?FFzpVT*_YC1#b zk9b9-?US4DooHu=3=bj=oT0Bx%+P<9&IrT+dszaw{XSO`&KasC(dP=dCRd^ zpDG_Xv)9k*PM<&SD}Fboo>9lS{8+@VUC%@s%7}n`_HoI1IK)!Le}2q^@*icmJ*J zefzns!(c{n#?>IPy}m95;(PD=L}l2EPuk(=Y4Bn5JHU%Q<$PAif_qsM`|-^3s}(*A z=;|9~*=G3s4JAo$sQrd=wD?E$cD0>XE!Af#EtqGaB54*rEfHaMb9+K#V&uZlSbveU zvJ`3!j|}k_JMuaZ{4<;y@Kts*7Xo_9YtA**c=qWCtd>QW6qAVc`5_f{+yJ*?^{$x^>0U6D%R z$M-fG4z>-sM-<+}xP z-t}+ez~!crDl)c%RrFMy$7?+=zmfmthYZ*6oA8Be-e{HV{!aDuiCf6Qk>alRdSk+^ zbwguau_|iO(PYfs==t<1Dg$b4fp>y{Uj5!;b!I@QWd1d*_7o3oEPg?C>@*ugQoqnT z{}~VXxTts@CfNpiXLoSk(4T?ft^1bUEPt&$e?R59QaqID%9%S)v)WV|C_h0o+X(O7 zes2W_4u05u82%3IaT_twInPBO2!y=Rd;4KA;qS}Lj1tgu(W3i@gIJA{+w|6C$IGLt zH18sAWU_(&*n;sB2c)y66*zk9%PrnW9@6f=+TL$C4>-~YgUC2Y7Z!ZHKjY#We#Da8 z+dm}Q`j4KO;=aU-|IuPLBn6TEe1;=&r%l6QPxH?rQ@Af7^4~kBS!4?=X*f5J?tErD z$P{rT8t%lK+_X57XHp(6^*{Z|(ozV?d2q#F{Qu9!5|Xpx-4}oH--jzdB^SXFhc6>&h=s&o2r4^xdVP2% zBqkw|cK8mT0T31e{hyN22@7+tIpx&gk&5=YY0*3-Ypun6z49Z`(=O_`zih*v=L+hT zLzb%Ji3Vi*71_t4?hi@tIp_&5l*L8A%lR#F=9IIw`AyK^Yuv==Nu>`$RQ)TnlxBEO z^uEG77mr@l~XxvF(zil?~D4vcSxf>@A!podS>-1`lzN<(&gB4L~8uwQ0TLt35Q%1 zcKlh9GAfU;)&7y8KT&JCLtalvCfjoifEOPQsGyl=U0&hYL|v1wE8(OeX(z+HAHz<1 zjuT~h6UYqKP4cxa9{5$c&)RbtNZ<-E>Tj3c7yG&6+{I9{b}n|uw=4E)A6k-jc?F7B zl0pRz-@Ja+GOdKy5{oKh1XaqYF;ToAEVW&-XRO*ITi5Gw`bt7YgIoVX*!YEDJK)5h zQ2n$TD>D@9aX_AXWND@H;%)D@<6#I_>w&3Jyb>lz6KDQ&UGcJDYbs^N$C2vLxGNfA z8J@raoi~&(UyfD&`LdLrr72RGDzpKm=pe{Yc)_PnH23gJ@`j%sZB}^t{SxLx=xTMo zX)w+^h1dBVkl{zH?!-->5+xz8AL9V1upClK_m9PWM`N@qM^HvwoteqVM|zJW-eQs0 z@~<3)A}C*-SG9aH?xYt{c|;)j0v;ujWpidP`Y!&D3|`lx5w2Rj8IL8XTDMFFsV-l5 z;+Ih<&YWm?x;-#4Kw$D5|Ly6id2^}pc&hx_DGI{WGPtpZoKpF zhnd8ws?PNfgYI6&TusHL>1M!t`aY=hMW?E5J^bEA7_sJQGXpz+Ai3@oF41!`VL_&6 z9@0W@Nz21d5kP|9KqzPYKR%{RAW7H(hvOBgS)?Z&8facd)i7A&_&HE9U0@MtDjFD@!MkZFEuZoZ z?ab_r*%8$)z1ImQUHiGS)9wG6{f&y+ zIA1Hu>+O81VKZR=$|GuEnrHXL{;l0xdj*g?=m7K(6lu$60+bPhJBr64&z(&w z%?d|frBD^u(yK5MtCSIlG49)V=~B?KBiWuNPnI>gFSvo@-YjnFGR6Msf4zPDc1Vn* z)yO4I7xYo|RU++)fz!z{P1&}s^Ga3SH%?xE7|OQn*V}G?=j4z#;ff$OA8uk7_PpuC zWSg_xWE{flWQ-xb6Ht~*!OPvPrd9>hEB(KpQuo2kOIN9Qo4Wl&cJZpI`^e@>na_TH zAx?|Z4nj;zOW@9C_Kb?*SN?vxDG_GJ%R4imR$u+{{7EN-R4z<`gr$RvESBY^hYCHO zCq*CTixEphN}mh6r+L(TeLOIaiR7=^S zQtUoivtsE&`0|y>_TOL_X+xZqWj~clp)`dL5?`3j!Rw?$fF8MD`2|Jx>{T!}BUqOj z%tV!pH%j?0ypJIsg@1}TJ#V3XSa1r3-GuV}b>f{bPk+u{s!4C|a2XrEo*Ab$JyFQ! zpiZ{|i){EBWI{mpm!~Cg<%wm#_jg8^8Jx|VG)_8YEW*}3s9@A3o<&uf%^`yAZ(=SZ ztoAj`=glZFpgQ|pReDv$-0A3pM90GEBUkAMuw*6g0Xh~nm1ogGiV<~>txC!#)Ly=< zO-ffx&8IF=rQTsvHD%+D>3q-qs$<_S-#SchGmT|7fgmL@{@(YTiLdX83CN`Dc)LBc zR-U4Ia0-?M9N|4_xm?e9x(p=e4v_Y#umhSa9KgC@@>^b9j^;1eC$0Xt9O8%^ ztsj$J^b;@toL9kZ+Es;?#tWIHl?ZZtiuZf-%l0!V$h00m;{5zc|9@gthusA=mcw5$ zw%a?&sCE5yo;eRJulMz1Wju%9d9p@)K{I*~1KJ`8t@j5@+Y{ z3xt~iqUl6JEFX9cR6#y^zS3L$sDE}^+fO*X!{JgtRWp}!huufvl3V=@arCsmm*;=C z_stGWCoxAbCwyeSJeY%xH~k*ym-LbdoT@+#S%xCukEc~Lx8E4N_MQ9YaHGPAvM2OY#ZsJ<2|ia3oHH^XUyp8 zJ0TQWXze{+&*Y`YDnh@CtGN6yzVlh%1ssQ8es;I59eet0@8PomU+1BZ zMLl%69L}*@JJNEpPOxi9!3jrlKXDPJA1h-tgB%jBf$v^l2_&}i=h;o^FZeh?8~76e zN4AODb{i0YZdxVMqCVlB{^s~tS349;9_zdpPQ zyly%l>PsEm9=kre4h%94x-Gi=r^=17dclykf#X&JG=1iq1D;Sj-= zl8r{7Fnh(x%}HWGe6c>9vaspqK_fsi;M>4_TOwsnh{vk)^S92<#t{Sj44U&O~hMkcZ`=5=?xE@-f?H@l(KIZxrcGSB) zxF552QH%pX$tJu~@7L}54`qUi%W#+xkc>aS?#a+kZ}4k&YUKktU!T_m zO-6>&osO9CKCobkJa`HHZh>0NG8_y5P`6@jlD8jDR1VJqoa=K-J%Ki$?ey~n=JJlZ z{u6LS-P&y*3JTBW@cOo?t#-W?{8!A)wRk52Vj@!{-2gd05ee8V>4qBK)D|zymkVx8 z?N+7-N?w^*mY+9GH5ivfVStY2qy8`gDUwu~15mfCX=|3HM|xbb12rBQ*wIdsthR$q zC8D?HWY^OpB$ll4SI_U5L_$}?@n(tU+gFgk2MO#gw}%V{o~-}c4hg_!;eI05uA#n8 zCs%c;M5bqT+Qtuk3yS5oI&UG4+iL5Jhmd*-Zi?#crCPROODc&>YQWu*9KxKl`D}gC zYWazs+@n96TvPfhfSAuy%r=oDcEatau!!s2w%C`2j-Na-A*mE|4KJnFndV+M z%RRpBrPG$hp6qPt4i4z(>WVYBetY|(w_jUx?13QLx$p$I^BsXoE+LAnU0g|C^j+w4 zAm8X+_c-#=Q%(M=f-c|*Rlx(?hF>(cX)H?=+=TZzAKl}1mkbGb#5wH2kfIcK!vfTh zR;HzrG=o|`k|!U~G9X;#^qDy}(+-U|nLn-fP`if^W(o|SEhRrM_lPIpbQ4O5olT2SG?rhd36;#NH-rdmVS>A{ICdrU4U|0>u0cc5JQIK)RL6O z48GKC13Z46z6`<$(CcT!lYHKk-bvr^Kx=D6(e|iX8)+MTO~-2u>Kk06OIY*1M~DW~ zQu#?L@o0o0m+<6Q86B%4{6id;?o)kYGPPt<+0ef(DtkA;0_oFFy-!s|HNz`T_vstT z^;4INo}6X2_V*QWQoiYR5rKu5OK7?Pdsa3Lwh3}FLS45eKxKuLl){VJW4PrhRnPgu zCYG>I~WCD(&>u)Z+^;h@=KJa-VEF;}S0l7NR2rPW zN{p;xm-acHZ6rS?dKy5}kZlq-{q{)oiG)P(WU+HQlk#KS9*4_9N88w9vA5xHqV%>J zE%#CDsqgI>kpPzd9#-vM8&^9+u+rOVEe+JORI%(LZ#de0XLw3ZzaZXh4=pr!n?jtna6^4P{Dhy>DJ>&}a~)qm*SY z4|MGKzLj>pR_bQ)gvS?p-k+Wqrbk|V6Jphqntga9j{r7qL!zQhsTdh0GHq!HRDU9# zbp>`${C3I_DR2_KA!NuSX=mc+}*n! zd;x}9@dF!E)Mr*G4_n?#w$YHN(IN$2lC1pJzAo1j)`LAfa>rW>C-UL)|DHcl1) zv>68P-M@#xGB#3E$LrE*M6#&buZ1#MWymKH?l1ESQ4C zco}KTAWA;_%GsJxO@DD(plh+levsXmpcJbaor?TzPqkNklV|YfM!G8psFz+dLuJzrmhQG+WovnJChr@cwSK8CE11mA-Uwe(6$ls5l02IXZ_a7QOW5 z>&V5hc^H<7Ql~s`+)52b+8Qi{QhumtL0T`C573JpcS{}^4sN%!eE(rF;wI3Rym34; zfw{yw*56oI8I>5GB+Sj&Lqq;Nuu2yM4+3kLGxklvl3AgFoo$wVu~Gp@$;evo+HUNA zpxIQ8|5oqJ5q4$mda|?rQ=|Ip6}g+enXQ_${VOAV^}iX7e%sA{;}K1bb&S*`t-3kJ zmed=fWiid=Hmp-`uPm^NzPrmW1Pk~D7kT^2pDNY;UH#3lyn0p1u(RT@x#B9wzXDMG zTVE?-w#qzJ^{;J|xurVQZ#(@{&FuR&T8HtgWtCK=*GClmQBYd=5kw=A3s)+g`9<89Fe7mP#o*V8M1H-1JKS7-rb(M*d1#xZLR ze4uUdp~`3E^n_{zraI%}W{L4+A#VWRCl8&(@K;}L(~y2|A^$gSw!Fyb?mr*gS-4f$ z;+t)-(Z)YE!`sEb5;fNYAAj0YLo!&k&f3O23u3LS!yN>^s0=ia6Ua{19)zrstR<}N9BE#Zx0G%PLe@-8Q;v^{ zTLjz&458*XMmGylSLU6PGD1@uPSUfL*If+eE)t78E8RKNBa1h&GUO@-%WZ~M>pq_8 zX=UeZ)PGskzPPXlitYnOKaywPojmL~JjDzs}jdKKwg%TjuO zqp4tD3VI*R^9F*Q^BWj1ylJIgeXQbauN?t3Hyv&b8Vg#zvJ6%XJTy1u5M(yXPl|qe z`(Rwb9er4klGT%b2_dFmGXcPrvIR|YZV zm&;j!>^Je9>8o!&p&9+Q_lqLjvN`Wgb^dilLgPi6S$X-lD z#114ZE^cElY9}TFwzCno6Mbh77P&KwmJqg=llg!3NbBVwe|BF;DDAG)2`BJE?Ehq3 zMgQ1WuABMNZ03Of)Ar_u{-^zEK-{%`mp!(>U0ELaAaaOIJUq~l{Pk|pkO8~31;Q&U z@8)>CIM4gT@bBijx;*3Afxf=J^Xyw;bLEL3+L9(7bLA9f+U^?rRjeQ_tNp1v_1V!q zKobOj9z*Qx2K%@YlalN{%x6$SZk$!sNshndJ*p9s_Igo(w3T6j$21`#pooME(`WsC z7u?rB@UDCGRF!|zIpim5(0aV1dZ$Ze>yi3aHPyzUXC&2LG8KYnWXEmil5d}7h4Wy`vb3L zbqYopImC?`a6k>yqWVoyXi3x{6g7fp(WhiF#BMQQZ!t`1(Qjyh7PT1kwiqFr*Xq-p zAL5@MaG4)wobR`sN6XF+24PdK;IUE@V`U%OjiM*%12&&Cfp?=+ps~HsP)=xc0W=%} zjo*NVP(!2Apr4JQaZ}JRacE2fG$QRc7dagu(EnacV8b^| z#@DaMhX(Ntdh(4tF6~n*9pWh+a8&JSm)E|{*{;_k@-TtdnPhmIq@9>#6HO<^O{W8z z)5+**6#q1=Y#Qk@o%(k=i*Y(Ba~jcBN!VOX-&{iwP)!|BLvmHkeC2hIz>}1~>kUjO z|MmBj@L9Dg&2SG16?Zlj50PGXzFrR*PIneg4^V+SPl1ON#GM1;A-3Tzu;C#`?f#tF zLnzIiJIzDV*qzq+hFMRMlJ z46Fq+ExlyIyklC{Wm@sbT2jrzIAkrGX01T2mXxe8_EyV=Rx92MOPUK9mxbj&Y_`jb zxpS*oE@W4OL2^s4!`R1=;*K`jfp;DcBa7$K@&~N)hr(?Kylp}?ZW?lSr*Ta;2P4(N>R{9h`WjAJ z-~HSRhTs5o)=^#6o)|F)xq?6^4}o-@&ogHi2i z+fJQK(^<5#faN)tjLGx^UNUeyY{f1AbWu`TS-*nUid7BS2-a?B!lT#T$%?Ex|o zlWF?5>af)tespr$7EgJ5bZIi%T0yR8%ESk4m{iWF1|=d3Q>;3=XPtN9c=V%t0&chT zN5uMdYegd%rqQ3d?$l30I`yAn^@Gjyh{VA@C?%}xKLG#(>;|)QMdK!(JQaVZFQyJ- z4H`wRJBD-gH_bWZe;%r2YnpkEu1%&*VRM_zLl}W_;H%oHd5B4nZMO?-Rj|3>qW)+F zw#pozkMIGJcOORizNud0f(iV6zm>~o9@VBMoN1RIDa|=!Q<_41%OWq@Kj~_V++q>_ z2??^~kn06pRqI2f$B=uD;HZE~2+U=B{)2;{`bOl6{?5-<)%rXDKKV~ySbJW+zy5Dq z{sqnvAKg4BkEjBb++D)X@bvTprCQb0(kbAc!BTSVySX7?BHNr#`DO>c zi`Fhc^n>VOyFcm+5ZoYo_-;;20ip<$0pInqEz5FlyTE=h2Ggej=GtA;jvYM$+?#Ci+~bv%vS@WP??)P-FSPStu=4g63APUU%1 zz^Q$^>eaU=BW;02LtojhzGrGQqNYwf>MKXP$S$sVG+FIE36V750SsZECK-~8ws zI3*`<=bd~^{JHxNo#I7m^w$AT*h=7tNR9fs8f;|&AyQ+$ZU$Sij1s9)S@(ynSYtCp zYK+&FVJm_+5abM}mvH~#*~r*X1;`hMl8i4vT!Vb!s63#)L89b)+G^=pfy4Tjp=&nC zm6^kO;t=cMJ0?|6;_q1kvW{Ei9)T>qa108kGc1Sq-dbL!(llnXA}FK{N^u%~-|OtUIi?3^lWDSl`ItTP8xY zSFsUThxKnm`xtfA^4K=@@s=eT&8~lV{=&}SjySMBnY?ovr%wid^7{M2y-kzOo4N$*w_=u;9i#VE%L#7N!Eyr>WB_J^Z7L#U zYg90mO3U*anj&&+$e}D)CELc?bkiman5x%6vL-n2&YU6;qU?5LV0F(8to#^qH#Jqm zGp!f}_Uubm^PIYE%0hwi;PaLPc?b*88f-r7))v{%um2Kt2eyL!vRgK0aBIzOwlmC; zL;gn%dyfvbv&nvk*2F+jk7c&As9}fJ$iNe}GxTjDIC^0Gjc41<;;4oY0x-j1RQH%S z#sVK*e8&vko-JNCi&(3*TEVW|sB;mcpcDA~?FVjja*_j=K*nmnIX^lL?#3dJy~;hx zg*HxfL#}eS@uCfq9a2{v^d!&*Fo&$wEto9YAk~4p9JWgPFMBl5@ZuEXsG23jKN{$L z5s#r$%`%lA4b;3C#!Lgmb#NJ{kv#PslUXGT@%|c!0kVQ~(b7V`-wS)Ic}%n#zy>Y9 zaehu@@6Q3vid7Ykv-6Lk7p_;;2j5IFyB4IN4Nu7%-eTLzU^2k0RGC8=_+z6cY-8k> z4c(B!oW6Q7sO^xSIrN2XME+(&WXuZu1|~j}43_G9Lhh?^1f)(UtxNZlXdg|UBewX2 zS^DQ}jF1;f;195dvs95WC9np}*I-{{%nYWj=FyERT4YQGYz8|M46fg31&zU5fMc(K zQ#gWq4;Y!Q$A!1t{;M&3q9-ifZ~WF0Ny{f}EW_4se6iuiz$0(XVD9Y)t5`e#u=P-# zI$Fik09Iky{bB39I(1Ah+l4>&N<`i$7z%S+{V5`>1;^>0930_CY#T7Fel&$`t_8OuEmd!PLgKVUP>_Fs`|s0nmP&RMS_(UAY5V> z&vxN&^k_7ZHuwZkXatf zU5d1EKnrh733WoVC{UL?=(fZWfnWrMg_$V24K|WQF@Fx^A{vRQa?->DGbrXSYZzN= zM6%Ci0bA@o^LY|*xEKV+3R+*pA#Ro8+t3UdlmcLqfmm{|tq=IdaHBX^eMNfgKIVVr zn}vMo6fF}kEMGr&;$jm(Q3T4dpsAAtVH8*cHZ(;FHwSS{%>(sn3iX;NgB*Cb7e^n6 z)=Hmm57yl0ttR8Gd0bLWS5kxTRBfbpV14`gJFq@G$WS|-o z?%dU*+5t3XOp54|19zDTya}BFLc>D=>|AZ@=Rhnq|4ek*Ot{NT{NI@n#+j(h3w1rN zMeAIrJsWhD=J)@5=K3(glP1FJfeOcGwGFk~EZv)|b3jqq>q)OCL$B9;PERsUug3+R zbOm1c5Kk(I7x4zi=WP+y+i>Vj`1?o4O&7?D-OyJddZ9sw)CmD z4Dq%MIH`U;`7u^!*-*cZp>IJ@%$^BZ`VWpyTe}_;?;ly|ZSL089<>fks(ualJT`=j z5L5lSn3a!+09B>Qsy)7*xy@Q<9_(#BW#j&r23(C{^)IIPvkoP#5A5|e_j~eFJQO!s zg3;o4X|U>7c`a?;#gf?Tf8sa8B-lP}?2sT9Nii%7vivFT6nTBw>?Q?*v7m3%Cr5`Q z-id)B#OoT5r?6wS9BHEes5bsrE^POl3jCDHUZ}@Xf!zeeJ>O`0*^DtyXaz8%s>{R) zV}Z06H<)VG<%RvRKn6VgnE%8J$LA|%Z6}^0TAuQ|g$$B{=`^A?ABkMXY?mfcWF7EW znvIPnVa!T1DY7PnEzNpIg)rYsdoP{a{}VmVo%yQE-8Ew;T^{dHjgsb-_IiHT;kEfG z$VZq-XE?>ewei+yeJY?u)}a14`?4uzc2Jwr_s!$Q!t{0N0c~nu8^}$kfa)?NV|1XL z2NK;}B^|)_S>9O7$-fxEzt{aj!w(~Y-Q)~S>Ork0Z>*rflfg)b=RHi~sut1qrXhwV z`e-|?q#{TrfcX3MD6~|YXUslTi?U+bXm3TxN=H~TFk|GRV-{roYE5Y?Sjy4@9yb%B zD{O{-GMtR)wx4g8os?A6oE+^oy@sr@oBlA(S2B%5j}KA#E-S<@iwGD9_eu$?aHOPN zTBQExBbW+4sYQr-(UysO4e3BljYtp>wdRaC+;Lj`E3jVasPqOa6+h#iDb2^k=-zC6}AuA&(%G`)+B@ZI*{N!o1B zNuR9ugBt&=HU2ed4$(!}`J13U50w_|*Q-j8a!Z5w$2KpF-Sf((LMKuy>3nFjvcGOS9ji zqC4Fq=Z1vb?a{GWfnklfSDv5RiWvh6XSkRKR8c?I=5smjc!HxVKh(xGktF{go?)3R zqb&ZcGV%0GQL6!w%PJR4X|QuVza-}l5Q%b7l~q;}o$LNhQ2&ohASUawl8&Q;PA znE30-3{>Sj8>|+yjrCBQkI|J38*EfUI~?Nl#{X>Ty9&(VsK=Tj_TvfhOpp^a0h5v* z=6``&KQU^rJmfLvWWN8k%uis)Q6Q38(u%^y!N{IrOz;S%!Q18`1M%P%FKpslC_8!t zG@Q5|rXYEHaK~zUVp=$bvwt^RQC6&o?Jd8|G9b@B@kXed{U*2_d=n3e6?cu?@Z>i3 zBKIw6a>z#ayyEMXiv10aRgkLYB-nCcIu}$cYC=o53GTg#j&H4CUBEzni489mK=XoXKqvB9c&@O|hp3dMyh{h2^qAPavK}NMlUg z{Lf9^;lps`6y_=ruyJvz8w%tr<2dbV08PxK>&|52PPC9GtWykE4F}7iHzRT?S4l;aztORz1rq!Y7!kTUCGN|);u+@Eb}fm)bDKk@OZ<6cFL<63By=JlMA3x;^WEH z!;ErkcZR6J4EgyYgM~6fF@b#~si_lQ>+fiT{s6cxU$_Q~xH-!^!kxRdcFXfy8kr;9 zlk0wbm^UrVzt1~Rx~kk0`R|@~VbLl?ep|__TB4*X3ORs@-*p<4InqZ@>uOSZXcMnK z)LIe|H8hQzSX+7GO4ML_EUoTzZV7>YZn%gPoEWEQ+ko(M(jQkBBF#=`oM)BAPuHKt z>j3&0-gZ5npbbwv@sc9m1-H!4*L4XORvgVpe+)}$-=*`&W)2H^(7uh)uT+7fEF``& z*YV^Vj(6`;Z5c)5x?HBiUY82rz(# z1+~tN~ou4YpjfWW%c zUTtmjd7_orZnf98=8BI;* z+bK6t7|qlZhzA1MiqV`O%rSc#xK}f-c-s`o+Y~ZK+q-uY8|3o^t7^5(stkzsT?V|D zPq@f1N{ahD@q{W3Vp(s`9Iq=3D9Vh@;yXRpZ%Q^Ff3o%h!P?Rl5Quhj#H2IzUg}Ls zc0ec~j%|feB?8wH(PK@KJL6rAuAB)6v2|!s@KrgOLPdIE4ZIeUDHT92U=NqRst23Ncx2)<}OPYFU*IK5goi0Foq_)vN9b z4AmgJF*uVxcLO=QVuEj353w(|gXKfh+;%;cEWhVA5kYPD$jGMl(;8-Sclax+lSa6L z)UCEYY?y`QkfNf<^o~d8zm3ffYK79|jEQ3CoCk;}1BW+gfZi{4m?%{5#C*>t<2|~F7qSjbHvethjNQEHy#t;l97!}=4SaIry5%6!l<1gS;=I0;A8{C zRPo)8We%urI+1@mN$8sdN4)Kth`@@`PHfHaN<5H2a*njFL&)$It$%7P&c3v?MrJCR z=xRDgG%lED3x)3%tgTl5tEG}oIc|!c^LvA)J%lbS^9D~96BbE2W#Yx|&{g6Rc*2mI z4l9p)$WGWz5#BSe(0Crk#OrK-i^a@~o4EFRzM=;5=8M;1Wyw=?Hi9v%!?el(CF=oi z3&3-mxW6m(lj>7DwYV-oNFo52j5=NI1X>bF|Q%K67I1ShpL0a zZ{L5JG*5G(4cKu}=k$Co?k=xg)Wq7_84&olkkPh@z;W-+_|J`&uMZUK!?bd71&W)A zzcWQ1C75jKvTjY^X^K&qkfF$46J6Nw0(xjWSUpfGZuMyMN^)Db=-*T1h{je~l!v$f z! zild#X5jdy^vA&OCV(2Nd=+tzSizG2Ie`@=2tYvt^5mWe2bv;H%!7BBgrn>DaX--%C zq*2xh%@lcSWPs@i?T@>hVd;&ibvIlxCZ-YTp~N2lXVKnAxJOd_A4)sDsg6)&;QM`< zpMO3e5F@9VyRjvi9^O@-1{5uT@HNwZDeGycp5lIvtWHUbPQ&>x9RJx&!xA&Ca$D7j zq@4g032SyQQ*9_ko4QY?VSgk(!6#Oq3RbSI(4FgAt=o!1Y1QSoc8;nTc52FySd0|| zIMe<_i5{w;InU{iG=^roooi~oWQ`8w>n@%&8jNg6L%!nU6OLr1^#!IhHdsWJx}2Ia z1E76U8717?EnCDZ(n*asP(yGN(gs5`-*Jbf8{-rZ)aUMzg*Ecl>N|>s{Y1%wsIm$h zP$u;5rD$H4y=e@3+DcubjH5^F@cR6b)e_Nyv3|I{Y5bb$OSEw78e~I-HnpcgvI$%6 zbkmu|(EiSmC#u&SU@7nvqb@1pv+9nUJpBbc4LF2~{3j-jt&UvV^XBR1B5Et5Ie6sJFUlRm!y6i4W^tbF{LIh0SL%WCDy5{Q?GXTbnmiB}@yP?|( z9R&7vAS*Jy_|#sRNGc5Dd_gsShS1~~tjrEyNIBiZmC0D_+eF=D8o2V=U=>wHag?;s zY!v~4$CCn}*ug0??jO_L+`F+VT^v5PcY0T}G1j;Y&rsDsA$u{>}%-uQ>7X>TQsAo@PKV}>&6he5qh z1Tbczhnam^Ol$UXOVXl$X2N9SN~?wUV(2%pEVF>Q;N48IqEU_!6aCSx;)fu)7@h?e zZ`o!TfXOe`=7((^FRQbMD0>=eJ^mDl@Rn=|miMOac0Naa1AmlgC9obq%e3DC(fl@( z^>K{$i!_fZuxOaXw3V>oBF)q%0?*{U*IoJ&88J=aclb)Vzx>=Oqr^98;M^iSs%?|g z3n(-lj+-yy@Sl1LBJhJ5pMP{4kNs!OP)iL=ZhO|SITg~fyAEjW_V)D#i<`-e%nn~# z)E_+*ETaAYO1kc-rq1`@)X0}z=Z1_&#)RA|M3i0sG;BoamlsSqS^TNmpR zRAhx!r3%P40zm?ZWC(<$$R0vXAgDkv1R1h^>GyX|{>aIBPm+7@xzGE2#`C$IYN;7n z?VY&ItK;c?!(`&QoFL_J>Y|NxdH#U;&Z`^qv7&y z(L70Xj7UM6|8df)80a5lt!*|~Pzq<`Z>dklcN3anXN2)kN=SWd}#fCy_UKe zCjrK`LlpKi9`@B>Qx&C!ljiSHZC7A^nY)& z%83JepI7))i_erSr9&OSb&PGZqb4RZc0O{7CyI-_qU7}Fb@LW-9xlG~EyMXUbP7TU zsrwNF?A8!{wwem-m1uH4U@X%_ADU_7@p;hTDORt!WflEtJM%jXIN;x_Lex1l`wKrP zVxd~zZeb#!dhxhICDEry;de$o>Jhw=DUs4dN6}ZF$-IC8Gp4?4SuSyA6x*yDDprmf z+jkvc@@*)8>uryzWlaYrso)B2=H+8xXQ_8HMpB7o9cMY-t3N7s{bG6}J9E9`ZRZ%tL%*{`RuZiqz#vX(YHaqZK}%KHkLk}f zF%c_&D6aq7wr{*%)yem(x9zQ-s`a|cZ(HJj?NyTcOiq)M&YsAq2S(kAK{>dq;Wikw zuSYM;J~xcV*JP!F^{fN`u?HKTEOe3?xDX$r|HZ}b7$dwD|Vq(Us0rKN-OXcys zmgc(N>_zo|``cL~#RT?y%ek&j;U{ioynb=7@&v~LOx$c;vtC5JL@5(+^X^0w$dpM@ zD0)w;07t3S18SNm4SQnh|F~|l6u_Nab<-SvdL#OQ;Fx8o{tA&<-r`j%>(=J|XYctweG`6w(KWHTMgs-!R*O$LrT&ie*du0V|YP65l(qW1R%J-G7 zrr`eSey*-jpFvY=jeGG<9AhvXO{cvU7J>SSE;8$qX9g#z?PrQJZgdEI2`2FKK487; z9Uy!3UXhV;kXC-!~jtHaq2*b8jCi}w^zqAtHuWSOZ<7cBXz3rtT^Xm|z;-TTC1JA-vnsklC;p-qR z&r%IvIlOrBTVXF7UHY_$Y?BFmKDs#WS6bABQ;2=>;;>V44+0D3N@h1^(DmeT+p}f;csOl8F~!_O;SY(^yt{y~gZq0zdQXW2>87yVmnQ#c)XC)p=DS@GEYmv2nro zV-N>wDf!qM^3jcx|F4515>~9V+%%du^`WU+V9ohPdW8-3pTTfo>QjRkV|dRD_%kBJH_Z4EeW`dLrsb2IIuaHE1?eB{~1Gk(eG%F?Yc35>3M>>&V}s!JB^HgkA_Vo&eCJ4kFlut7 z_T*$uZIyMx8#!`Lgl^@0mVK)X$VYyKdpGO3|4Cux{WZQP-IJMS z6F>1mxA@swIaX_!bgSL=79u~lUdtlQnGVPchFwBsYC>Gurx{P;t|nqFtyg#wTr`k; zK8P`$d|kag_uUXAu8hn3!I|NS;(epEN|DS2apDd`FJz7)Zqy+~>I2tYF3}xq<<>hY zQ77g_`N&k94+(r3kmdyCd;=|geKaa?Kqq)PIbnJ4;K=QEv*Hu^e`9OO+FqnwV7vLC zoVn%(gx)2otJ*v-ssA$hY}9o76i}48-jb-FOxq=7B$pXg*8gc-=hu5qO7ws4(AESG zmgBNKr|ES11J7KC@Ge{!Z{*T#>6X_)iy$XBmz9VZQ{PXw4gc?k%NQ+gwJPk(DhYg% zc9fbJ5K;MqIQWIkU1(m#*$YJUsO>3I$*gO%GLM?JFTPB2q-2?{T?MpDKb*nymkKW` zapEu7vdxNm1`AaQv&W0yAGCKpuT~YZeBfdXUmEP8$b&~H~Q?j z|D+bObwTZu60IBTTHi43oRI5qFE(oQ4lw}DV;{rOhC|Zoj4I{9(&H7WvQjJ0$!X(B z&;In2h^yn&(#sQ}cK7Lw+jEfFGN`j)pa0Cs?Wga=S4aYDFY6c&9EtM=!C4?$EdQh@ z-tFC4WXli73)@okhnh!6-GB28Eo@;IJt=}rIWAx)V26$MSA-g1L*hS;$O#ud|(4f>~oR=a84o`*YI+x;icN2fDo5Y7TeW) z9tb6IpptZkj+5^=iZi=?4mA;e)+zlN2fKM^*8oK+b9y%?&bm?!cQb#>Tk7HCbwiLx zw1WW;hS%@a4xSPcwrd$fzrXVbZn+M!BK8tdHj+P$I1J8ZKU6Fc78_z3p769t;GT60 z0fc&*i@`Agxm$FTh8B`zf0UE}?5S!Qoi;HRkFF2v4H!vw7??gH|4ElwO3kIL-1WSv z6;S`~JxD}`C-2ajPj=X#*U zql9Zk&@{R>wMmxm#65XOPOGNZ zn`_i%)7Gd)*gYUAgN^R(#h*!ulYZm+`McW6iqllXD}t(poW!!dbCneUtGnvN)NSKY zYP+|uho<0~;=j?Hi$4kmuFwxEE?Ehr`w0~lCT#-peo>{!D=Ej*{T93$u~IsU?mjqC zt=HC^j?19azc;L-(im+=yiC*0s8(M_JyGZ*3+%l7Xg!Q)YZ3m_^J4#U6~E^S$)HA@+@&Tl`&%3DL&~Ajko<3qIx76uisJ*}8)uA<&gn>iDB-KnAji!fR z`FvWiw6~-(>;=BVMIRaV9rM+6 z6|$6WN~_L+ev{>?`G)q8WE>8yl(cxd1cmY={>SxN48{TMfVWiQQwZ)k8v>IJU^lmj zCKIV!RyibwFUpC?E83bioEoX22)FPSL0k-UV#Y~uny{B(HCHhOQ^V&dp^BnlO#pa*PVE{9lL3b zXARU!_aUEsoB;&#zJdL$s!UHJ)0rjs@n+CHA6CECnPLJ)X3E4w<5lmm07{zWdSS_z zGtGlPL`T^5x)r`*+-Up>#Y5CRC|ENTf%A>DbKqjQKNNem`psU@Q*PefrRD((|pn+n$xtq};6Y-sez-sNrCx*t*93WBvdfW96v_R>oGUCHzB#i&(_Pf3DhNz{jFD zaDRd4!)%|DNHtN$8i(0lf|p~v*HXNm`Pa8yOH$*`quf$*w_FY)?~gdJ3YfQ@EARL) z_cSdb=9q|D+W-nIB}Ufok!kV1+Gg0;t*2OPT)EL-G2dW%ctOiZVv!kk8@%oxG_j%X zmy|=+#0=emPxNNtvFWuk1LSCc(A(3kSCd1mw(zUhFKz8rat&dH%Xg4LUX%DKM{#&9 zPbcEf5lht+%%;k4@*F_dExqI9s(iBP+o4gu%6M-USbvFEd~9`TOT6}=W7Ft~Ud{O{ zp;yD_p7y#aG@U=$?`vZRTKQt@F|s6?!FEo|bx8vRh4NWbJN52c!TeO^nt z#U^ux{J3iw#N5S;a{RZx5B=&3e#q>`n?&1QhM{S3c#2(c5nzR#OsQ;3Ag5UlRH-@< zc18)Aqd9Gem>D2 z6diMkQhLkZZGL{5=Ys7QE>!j8fYMmafJR~q?=V&PU*&?^R3Z5LO_%gU1|O{m8SBwP z-wU=I`G8rm5G0k$sbl^a-yHiUpXGxOW@$JztxbsbzdzxqG4gs>4u^P#`eWSsUFkqP zxQRKYD!9{t)1khPfGe<|HoxtOi?(L~(3cfqwjbqR!eb&NW~~EwhK&x5NAw*NU1CAU>%%-BWKZ+BX5g zKh{UEH7Fb_%ijiABW>R}!zAPiuGN_1qAFd}s853@JW&%ee+0+2VPq0bm&5$slmrjB z%8l1S&)*Ak2MSfE-a98*xNL;9rxYKr!JtFtQPRYYeg0xC=aWgS+|9ofy8`FG0A3WT zbp9v1#$eSIcan!K2$g;Qg&zpE2n%OkUYtN4_8KFk8a~gVX$bWqxDt?nD=u&TNXoSM zeAQmZ*^FaGj74Wj?apgH@~v;BeZUE=KRa=Ye9*iPn8h?qalV|>Q<8tDoz!CzJ7KEs zy7T3-Qk?9N_%vs=kEF)U1r$L2-Im1K26lGFGmzBfB=nr;Fp$S3e}XazSBM8&vT3k3 zg;a~pUncIiB5t}v60f7v)B8lE^#-t+9{jiZxaN~`!vqX*uXOMi*DsFPGje^>((LO9W7ooNk^jWyDxgE{Bl{im9ios}COHvx zNj9nNPooep|^@cLuP1EM&aO4(59Wv!Z4H+Q`o@nzk`8@ z#@F~!daCjpA!Aif(?iM2sQpdh`%q3&oLnkTQsy#geO{{A^K3Bk*kXmR=rWAr zS*Xq}vxjYr1~-RB|=s zj(fMsw-W-%&GU-V)RUngSZuIuLI1C)Bb>fQon(2fGT?v2r=_aK92EI|Im!H6uVxol zNmEDbKB?ZS@|nSLYCNhX`m|^Q|Ah9yi2c?G^U-r|aSi}pXXfN&3wqZy&eTI~DpG-b zuMOgEF09RonxiyjQ!BQR%&QLd~$3>u3Y#%4jLNw zBQg&RUa9Bjjear5#D2w5s`VNp;rWW2HH*Dn*AfQVY&Acl;@&Dg2ait~e_lqLK?}TH zZAVvWeXdEcZ65nEK6olMzWfXT!?tAP=)jl_m)xBuvgMMdr5>@7#_)n+#|*k-s@P)u zr_`3{AGsux;qnTBT>Wk5(nN<|iNG990+swGj|f%3th^f;%V0y@&na7kOcabcpm@DD zDHyBX^((xFY&nLu$V#P9l#VQ#q~==-`@>A4dTQo7$)6}UX)1u@HJt@5QuED%W>=K0 zQX(iV>~sc|xb5+<&z;?Z z`ScuN^V~AIGE8u2?6Ml&51i5Dlufv4#`)-wrqf2lain~ji!kpIQO8xfx1{2u5p@wK zs|OoUL#hqH71@CnGqGz*^D#$~_OQ2t)SuOKGF(?ryQS2P^14kLq98ilmj4MI{y=$cSaC`6>^c`PyR<6hiOXO`;Kz}a9( z3B{V|`ZLt?GVGQV?QPp-p4kI1a{LB(M;GN3)BA&trpHJ>u`MFH0!DKCe8nmHFrhA3 znJ#VS&De6T;l5QJD^5g!N|2rNyiJRep5|hyNwqhLck?Ly1_$p}n7HU)zyA`%<`Ke%DW9qMPJ+9i{c z@>Fd&wm-2qa}x_bl+)BVN``5e*xEKt-bk*9q$B7m?AU{@!4_G8h7r=#Ld^2xImmE~ z$fPZt*`Xk}8%=6TvM`N|^t2N|CW5^yl;yX7)Jc zY01J7qNNK!^lUu)wetozn`vFISZc>@!9Mi`3Y{f0`#8;h6YpblYuC;LYO4#!yy)pt zP0#Zj_oTTOx7lE+Oqtn#gOX&O8fzh`&#-MytVbW`>PW95AlAi2|DzO;` zTbAc@VzT>1CJy4nTT5ElgRv;Ea_#E03QyPHcxEoiP08_CzSZvP0two~pBh%m z5gl1zKE!2dua5N26RBQ$+-Aho#k_(&gN60mt+rj2Ou;OkpEe~+x3jJha%^XblW_o* zsNAGdP9aTd8SvD+wD4I@7h!D5-F5noO%&N}6?-dW{IS*VGU=3h|rN1zHW z{?#)_MFn?8EoBfXqhxCk=CkwInA|AlRKHPxRQ-0o`wkwPl zkhqw*o;SFzS0YP)BHbb|4?Z%GU)IutTp6lQpJlr;8=nF7C7(J}B0GruY9#zLim|_+ zI@{(tzAYD?qz2rrq&c-jmt_mCno}~_W?ZYSu5s;{ux)4_Uz`qzCfmslmmC@~%Nl)H zp;lxkLasFQlE#5j8rk~eHv(AA0uoEndIlmhY#X;hu_lPAyP^qPLG=? z`mh3L`E8`u%1z+@Ll$@;h5~nSly9v~HXj6nbPm102A5`B)~ppBw1>9$LO8_Z{CC0& z1Nupg%ZGG;CB&4UdK@Y7`rYgTc2zrAT*jo;3dbTk7@5}&i!SaIknM+wIwI`?#`eAV zC=ZGA(BK$S##!M_+1w#PrsAu`*lcOd?InPap}P$OJl7dGL%l!oy! zFiGxd4rAwUDoqo_-49Oc`%Ui2V!VEv_b5&aXo|MPG``Qm$E4RT?L+#GpV$KSz@;m# za!JQxp7Sk!$-LwuWeS?!Bj?~V@Jr!MQdHu6Xh7o4X7686wys_|gQI^){r{%o_xs|Q zgOxhTFf6~M;_2Z7uwvJMSIQvq-$TynX{#{o85`WdDotnbSXO3!j_kQvI{gJLr3a`# zQ7NqiiRl}_1qu(fl@m-A-2D+01B_=D+X)BvXMuzb|`W8xy&PQ5!C<*3&59aZZ zIi%$-X-l_xTLbb9S>`;!JqpA#F~Ns&W3-xLYH9n0WaQFs{(-g_wFL|8NkWeaIQP~8 z;fT`ZOdNo&{%cz^trBkd^l2Jk6~S5o^QRokE6xxOw2WlGF z8b35uR`jgh{rZjT(*8y16B^??rN!qUAzoPU;mi=i7iBv*n7@UfN&#`{2S4F@DGHpO zcablx2xF1I8abkgUs|5;wAmj@?$$#X>J)~A;=@+|+Soehl=uf3wgzh(wl^cM}I zX^B=j2L{gK4&;-+gNmElJM#!;4k$DNY*8rH9l)ad7Hag0kEO3FRR60YnQ?>Cd+1%ZTe>&ryYA<33gE)jkGd1AfcOh2W|8qE^a%Yu+m5g>;)DX5 zxFl^abL@{3wNI5w53)!=J)dlOi6@0$LNWJ*eK!k}l#Ov=_+ZKCIM_r@>d%^OY?Kq_ zDEs0t<4#&ccP#!T6#H(Gvkf-;i)j+u=e!P;m5#H+>xIu>mz zHRSYL6LIVVNgn+LQflKG^|_|#;~$Q4cv|y0H*lW#1p=$Ta;4vON@H;p!8*VcObskI z>C6Q0rg^;_x6pWn&%@gB1z(G37| zcfQfl05084q_m^c4~~M>gFnoEpHJ3tS6vCV-Q#|x_g6pD$p_7u(&>2v|0_za9q3st z`w(7WPI+q6QSJnYLCBps7f_mU!5=-hyOo%MVasYzr%SfER|Wccxw?a(s#oZ)#$Ydw zzWF&@Djl+#%q7EDI;&9DJ-VY2x@Ocokx|83J!% z)tgqmkKz=ZC|%5GRE?{6_nc40`7n>zhu_eL%6Q&5XDX`ON6Q0UN4DJLVC=UNO!Yc>ywzof+Zxr!r9#OfR% zKzZsGOG}HGJRaxuB!E-oHUVeOC z-_F`-T=}dfkXmCF(=SrSHAo~jpn;PtHPd9wA7#IxnD@&x!_7GeRkl{fKQGNEuOYg% z-F#3KOW)jHH3B=M44qKXY(%x3JT&X=_c1O(ZaeH-yc&uYq~b0HFH(J2B(uhygG2;J z=`R$7P`+59hs{Z^>@QL)ZE*wbq&Z}5k#Rj#iHts%QGA@rmu~-M1(+bQ6MYZUq4ue( z-x^O};EXOuXa8s6B+mGuzoAX}>PwSMBd7q*SOd(S}+`&Jb zyzsdM~p$Bta+hrmAR zG@TXiw7+(u)NZj_T7@^fc$EP;QrmaoNm2wS`z50v-qtUNYmJT$v#BKmtY$}M{t11| z^bpNX&CAO^rHo`?DLX9s^~kWYA#9RzOrQ%7D%`^b+L(#fExKU+W3_9|~r>yH?Fo;hCVeJPtr0WE8ih`;ny>+!kHX5x#~xTAJL0`J$f zO_V@BJ^`byC(!A2iKl9w4F>LlOI@Cjx5Hnye>%Fj<}8e4NJ$9Zga-jAK>a9$kGBl=EKtw}Wk{O6vsLS(YMVs1QzX)I=T&M8Kh$KK2Pd?i?6f zIv*V%SHdyNdll7WZkF{^TaWdSqKGG^$)pn^33U=L)Vkk0n%Y_ooBUFTLh-&=B{GuPaffveai`>Pe5%ipW$c4FB9H4&(!+McCHSN@#L)WttDd_KJSF@ zNFqe0)b7eYBGc~EZc$>XwCL(YzyAZM#`InZj@kDyr`=exN}c`PAIjfd``JJgwVpSA zyeU#+F{zbD9>=0*QhYo_g!KFcOwJ#9GX|5zO2&_D4d1j6V$EO7GSZZR;mc>zTx}ei zvQt|W3Sg4Ync;i1Mza&GMv7Y;QA|~X$*_i-|B<`uF3KD~_kffQXbp_Dm@yg?OwGNz z{mdM+q{1(|d!QzyHeeRy=^O-S;Rceq+|sQQ-Lx?nVhz$<2Y|_gaLiN=P&z){YsiGlt`iV6@vKL7$JpCQG@~!AJpW z8qU05eg5)vd#H9$*5grMY<~NN9QF<=M|nFw2d)}2TJDhpRByZI6uII?6EHarH?aAm z??SD=xa7#N*k&dvM}vlKru*e6Z0F5%0o_Y)0m0Hr`dJ0KyH4}c<VB40zB{6*-zptul|@1nkgQ5%jFbb6d(O>y&WyAkMj=!- zc%eqDUOa6b_5McGzm8EttYq4gqY>RGkBoqQy&V7{C{Ohy+P>PdaLpMlI75URlLCa=96bFY~eDHW@+gE)y zC{`TkA`XsH36%RXlT<>_sRYXtPlzg*u>U2VAaa6yJVW9=1Lb)qk)A;wo*3Z2)^aFV zp3DFY;Z9lvI#^&~7D4Wfp`^w@=f>dh#vp}8OhRmsQ|y29Xf^X3|9QUleAncBkNrG% zM)TF5n%(C#<+6WQkS70#X0MxOCsDH}Ra3C9kY!NF`&cMXH(|@uO%R2>&4t``H1B`u zCf&MdPQd?07{h^PS~#P4j&bMzXBWqt<+FB`3$lmng2?GhNSfU6aq#7n-i6)oK-$ zPLVsCHj5V5irb+#sz21)FUd1CDjUwXFK0}J0_Gc)JNNyzojgr*!(vr}{{Q6te}cw; zCl9-V@mLM>LQ<&6`H#ruUy;kc$mKxfvc>=2xFDD1FZqYY$mR3M<)4wuUdUx6a{2iG z7Rc9_A?F_MU$u@oV{)IRA ztNH7<*YmUD0UvOW&+Sm}!btBsGd`&eKH2cmlvJd6o2u-c`o$-E&?oDQck-^$n;9dwdq;|mM|0kd{#mqkpe5#; zggVuYI-Ok7F$LoH$;93Iq_f-@Tm6_rWzp)mXq8-|$t>x3t{%I4+x=zl@G170v;56t zX&zfmfRATDPH68rpP}uI7ud+lRZ%5X7qcpTEH;Y8!@6u=es}lpKnZq8pM4{wC_!az z*tj?1*R(HF53?c52E7p%(++NPt9W&ZVOaOe5o;S&yf-#s*tp9PzkfVCS$J%GiF$qNJmC0c1y600)OAp4zb5M3=ZrrH1{x3~q|x&Eer+uB9TO?sD!wo6 zu!kOIuG7Ae!rqe7iA|?HG8;(1S*S@=h1en5R#*(_7zV5pBMe)C+ZjEPm6b;rJg zA`Wy`|gE9r72bXL+TB*9F+5+enNioaR3_ zX9iW$o^R=OBh6#RczNO|f_>rT9)UQ%>GNNo$`J0{f6tn$w0B<@X9a+M6WU}ZY-iIroP^Rp&2R{*YgGHGZedNFkpFT!Yc;W_=@bcZj`7=N`o7)g2H{DsMj-=7 zk=|K{`Utw!5)s_HGp(FMWyD_rb~B{>Sx~_~=Xo^c*X$Kyr`GsEN$3X&DqS%>{po({ zsYm;*4E5+F!CvSwSOI+cdp#AsdZ>MKc-`#D-B$(uRU;A^g-c+RCUhv!^GqbQdWs0L z*(&>IjtfK^W-kX})+J9mOmB!cBFoG|+Frroq@T<&8oIGYywQfNAwyY!`{(nkY@>SP zPUpxIbG4w-#I+O473YbWFU!qq+iYU?8XhRS>lNh1l|>D|nYw5m#|`4d`(qK&hQk+I zyWJRqG(jqxcRz20U^!2&hS8PCkluYmUDPT~m+)}7ubQNGF)9;2Q&Cz=DXa$cwbGT< z&+NY~>464v=gK2Y-r4qm9PU(64l*A6aE~JG112mrlL%IylJ|vrWVJum_vR=3AHrd_ zWN9jMax7Dfwrcxj+Xm)MGs%rpo8e{NShhoQ<7AhI1eI;w18E5{C+L}kx_>~f{0xO$ z-U2Llg4XcqmX0f(I%ZKa6uDAmpKxQ6iE5{O6}_pJ6pxTkgYi=VV-ef%q7KcdEwI3f z0%htG8B9oL4`T05mMz_!4)p$SD*Y65@NKqcbKx~~hO-{TBUz8kD70_vw?w0hTm*M| zbC82Wcvu5RHK7d6`Jb$E;`{Mqaa8eYM)4)%+5eF+LkDBCQo(2MM~XGV-i|oaHXGfc z`sx$$1ZiZmtqNdfqsHDMav>{FRj1P>V+>HC$(W}Um^E4gyVj4#cTRqstoqdA+* zxma_qRGQL6gvKat+j^qz1g??{-JP3u%I!s{cjgq!vw(_v2ETm%$ynm0JmK{YCkTBf z{8fFFC+t;!(qeSPkRKiitzq0^0b}W{nO4;VLGu7Z60k2;PuD}+Y~dzzk?M|EoaOTc zlicc`j-;_46UfOxFItOTtbyuRg3c|bE3jN*nmNOyk5`s=`ge$jHbZgeLFkxbe-lQu z(U{7K&%BUm@_Lwj1Y_Nvi*p6jyyK`o6r`tjVxipvGBUc}ljlyirYtnq*>6WT&AzCu zt7QCWK@t2ICU1}s_Nf}zF5piZAlclc?Khd^T1+i1xO-lOi>SY8o_Y=SuFx%Ck1b6E z^N+7LUsErSxmbhX8!2i+UJ2qLxtHD16~NarL8qU%YC14DJX&xJUw8~3@Q;D~80e3I z{TO(A3?D?X92hGL2UEJkE-*2`C)?CMn(yh!#90%3W7g=~Kgv`Ih04d&#;UT?YUa27 z@=7^%QyUMQ=d3+W$(W}uvZW00@%ivbQmU&$ zj%K!fSY8;@JFpkSJSpGr`&IezarQ1cNu@M{M5if~&dYQu@T-TjR1gvTowrvtVi`33 zCJ_d<^y&JkpeCeCcx>;lO;1?=0hC=2lkoQpUURCO^YNQcB-0S@!J*(>&b<77abo6_gUSy%u#iVX0lTv!M)88(m^ zzMfcLo;ir~wxyxsOq8}=&}}!=r;r_7_&o(JG%f^;r}_k^bUm=5c^OGh&W znGowheFmyyeD-!)@}b*Vd>}t@P{TT&Xf_gllikena^x>y{;=nIHHdpNXm}vj zE&;cGY9)1B@VHjXwd2I)Qx?I~^*8SE3KTJxz_LT$7E)S+OQE<=j&ofEXiAQXRfB+m zNkYjeds!BZJZJVrv`vHFU>mj(qG^p099fy^1Sy*!C=%R@jVkO8VKPV#_?V2vAfgb8 z3vym_LT~|qCMm|_X^ic>ahIh-1mt}wyly|1L1^zLmgMmDDmK^)Y@aq(LzJsi^DZ@1G1a@=?-7gO&vVu?x!4hv z?mAS^^~tEA%fFl)QboU~`ola|vW9G}HVRm#(2#EcF|{zwORVw2%dCns{LNAIW zJKrjX7X9=uh9-$b@;QBh1=)5%zB3~wCnL;vC+n}+!AA97@Wd0P#b-futPh3LZ z_O=Ja;Bdi#22A`z-f=ePJz9gi=!f8P9*Cq?t3Poxag1|`J7;=!xQnwu@#1IdT^$gG zZmlV(8qI_Q4(=&y7V10r@2)njbnGKWN>lNCO)T=&b-XsXVdu|z90{=Bg{X$(czS_@ z$2ju+hue59`S$gB?AfcsI(GhpQ;8WBKj4>@+nm9avL`>E!@HYoNhqF5^t3|=`7TTT z1Jx3#+@%EaUpw|s$<7n1WdGEuzu>p<^@@`JV*}uog!0F1AI547&W-@;0=G^zTlz7Kkxh@u*6tWi=!7=qlDn;4gzI=4SG6{>!v;ge;!sXe< z1KX|0mZp9~Po`LK20lG=Z|{KmlLc3W9gHx`cAJDCv?rF(n!>Hrg;1k+v5sY zDXjCWUXeVzwWE{mH@%dlIO$g%oMxrF1gEyof|stz)b1>9XeX%itGF@*s&k8%%CJfu zFax7Yq{o8nYO9F#WktHb9e@y5D2cqe3&(A~>$3NA2-{9noaGqH4qpi?iJz<@))HRC z?$DRwGR9Nf&7e;v{ll;MDXy5qEN&PiKjfZY6WmE6mby3HOA7KME#a*Uzzm44BfMm- z))6SNY(LWPGaFc=k1=m_Tdvzz_Cz*oiKDKqw-ST=$&1w5BJ@BE0L?PCBcH!*?}`+; zL`pVRLx{ou$)Z?8trEY%6bjG8%L=B-20Tvxno(i~#^&$`96t^C>Z)xxk`o@$(g|2S z4hlZ+eD!TtSGMmL+MAsm7BM`zm7y^5 zwEW_N!^Udylkh3wDHGdxz#|-*ug~=$&TM7avp(xM^iam8%KtY_0^n;%jI`dgbyPRiFif$p{56^KeEPn0OtLkk*SJJ@LPQ)s z2%31j*rsnp4Ki45NQHK8%W#_(%i{vJ@tIUvveA7?TWx&D=tk2~W;<^>FySYlTQ*e- zXrIta(Fqf4gxBoG=+Ltcda1Yeypt}^S$q_RLd8Ga+JxW$KdK5gQU9Nr6C}q>X8Ksf zB{~yx{xYWyeddUn8acoDP^%>c1(KI>i2Fl&g^zzGk?C_2@5h7F%#Y_1437!3*Yo^= z;o`#nlT9*!)5FIqCS!b(7mi8+^R7H#Q!$0|0;480VR9K|elU<0x@c5dr#iYNq7f5j zZtQajqYPM>C+!Jq`maP7BcB;=9h9mVD~i|F0smnL%@$()Qx!#`)A1RR)J(`~sO1|< z7DQ~0rMSmcqd1>old+}C`JkfMwLAnDbg$c}PuaK@OrdS;?wzAm7kZtU3z^H?wsMEW zAHi(v9%5{O^Z#H>V2r70e=&&Uo6}Eisa-DXa2j|@uDe_5?jJv(hRA`vQdQ#d{t;BZx z*kPl34oiZZiSXAue@|4}&-wPA`MX*@_KIt^D)AEii6>VS{K-&dfuX~hhp7AYxp+p#9KoYe61E#k)sFz;z&HIuFN-F&CZbuxf@?3>xb1SWuddQL5KCu z5HHGH+|1;WnDK;7As8N@OZ%vWx|;C{g8mNUFTHHdM%tdnGMHM5PzKZA+G1MPV6p$g z<%t57l%<65hUFqd!D~w#R5LI?eR0{E`LA8FO2}4phGVFy(Kd1Xy!WH{<1hdtTWn-S zy$@@m?<+BT2@iG^RE=rUWQBFIdrQn_~?G%idTC)FjRmmKIvC@{yopvGc>>}0&HKRd)@377K}3mmH8KF89D)Ycqk3)y zTmkUd-yn?dyO%aMtZ~+@98rAdHnOIa<~a3dU}HN7MzyF#x4>38!wUY&bRs{^iFEnz zYOSGSZ3~UtzjgV{MfNk}Asc^$h(2f+I7@{eWBv=Ucm1r(I-B2=F&By#<8mX4^X{1HYRC7#l{0ateo^o%W)^75+NneQJ;EjTMqsdiz+{x-Fka>lvUF`xT8y zJ;Ewd1ki*V;_L|tTW9&SJ6JZv9#w#-H$n_d%G|P&%V#rv6?hxxV5E7+KxK`v9?tFjHWuFh=OU1bRALeJbzmwlB)qU5`ggMDVd1Vy*Cdv=gfro% zdmqFHbHY6x1}GEnbwBwL&7b@<_a)y<_A$W*gqSG7axST?Dg7w%q(~Sl`E9e54?aO* zz5W0?a)#kfKse&Uy!CHrCe}k0(GrGoNFp}+qiDO(lO&zN|gY`Or_h|ay#6d!PCdU1H~k23A1r;#@2{^bhMhfsy*w&C7BakMX;$Bh+I>&ByTlw&0lYU6|4!wt z*p-7w8pP7imL0761O3uvH!oSY?+TzyLvduk#o^zI$2RMs3s(IS(hzTx$?~OR^QV=6e;^0vt1oLdVsrQa>9@y z`e5uh$*Ved$@3u_pdd0W-Bg13LO{37<^4rggT2y^d&E6`|4Yu)>s97;>(-GoCP#d) zC?!g&j@vAA6(>7mOK-keZ)y5LU|HbuOyZ9}Jp1=w9)Z_>CX6t!H#0Ic1lxnoDATU| zujhYH>Hp*djQhTMs3Mwy`Zk9b;>rLR)OlZvsnU_Zc5}*g3fBa>Zc;)==4?ul9jjT((kLAdCZw`$A}7&4GdB zgZikd0lSCqfEG1~KHTVJNJG$Z z1&uLMDl!&3uYf*mQ_>{4qG^@Ki996XxS?pipFDJI075>Fu7+8eGl>Q9@{SaVV4Nh( zl0i$N<^{4g*eg_~Et9=TTXDUZAEFXXMau2|YCDwauVr2NyBef`%9ps6)>6H{D zF1+jtB{r$$@AtH}rQ~)c@^VOvPr?;ogtK)i6S5lU)Toz|=ShAWcAIH|_)teuj% zHH2$pfMQ6V`vVB7!H+?7d=$-CKC)t7rRMt^(Lx}NLF8K*lDm4hNxGI$0rK#+F)pF@ z#waSWN1zj*C58_$lMLXh;H;cmOEmC&38e~d6v%|v(&46ARnUA2P?dv9jtW&WTnii@ zHG;DT5u&;eBE9$ZwCYx9bJ$qvM^FS757Ckez;c{iFXQGrgyX3BOITQWhI28VJteh79F%lQhG#1In8$2mChgZb76t7`F zK!n@dzni0T@fJ>VDUK^+9U&u1sG4J(N=5e3UGD_!e5%l6Lmbg&WuW+%nzUVXIX2`$ zPSikk(pWm#VO$Yx{m`l7%65i&Mu^@f%sB~F=BT|)u4!A4gt~9kFq9}-y`MTl;E1JD z8B^Xkk3-a1}+bX_$Y8~zF%e#J! z86n`C$eKOS-^fk5#7fD1lx`_*&u>W;=JKWzru)JcMhyE~b+ACWIe$+VGIJ?HaZH)M z4HEMP!!zLqe`aJ`vro*Vms2i$KHL*`0Oq*~81l4mWD-Mb zR7^lK*%|^PB6C5~Wgqf6?YzO;79S}2aQY(;&E6+5EDKr7*%Z8V+p%AXNiU;7L(LR<25Lt%A{cL=f# zPn@|Fi>XQs!*^w!t1nCgt{u)O+m5QuYsPc_N}g}=Z9(7x6EkQC9eLm#EKs@#9{ZE< zx;Wy)PlJoUnH{#r-^sdMlYBk|y)~^Y{Z>^mVc{ef{KINlGdz#Sz!VM%8X+owcgKI- z-_EKo{Kj0%3M0FgdF+3jr;F5q*RD)uWQ`~?+-__hU$r7Vn$#f-z|?M3G^yz1tWEpJ ztw@DPgTC%%o`Zu;6KYOz&NDiOCb3RcB{~bU6&0o3VuKEy(++P>nsf!fDkfK_%ByS0 zQQTO;3(VH2+!$nDjEp%942b6HqY)luILvcdm>Ki}qe&O6z>J(1tPp*KEu;@sBtsOO z*h4RDT^CSRS15PtZq7Mo#YFF~!8!*dqX4_cL z3U}OEOHL0@on?tw2}{f2bjnu(g&fB1idV5&kU3cg`wWJo5Y5eJ0G?&IMHW>j+g^ZV z2p$i&wbNYyXez>OMf{hSYFbNHtkwGATbB7i4f-KI&?wG^o#gF%TOj6a=NhO+0sIrB46b>TMvv*INb>0!{A+o z)t|AkHI{m5z@b411|DiFYz)*Hs%b=Ad>^~sEi{b)PW$Ym6YK&z-nnRDm5lhJ)#2$P z$=ZK|a#z?PCe>-#yt_<#dBVbqYQ5vr5pD4v63DNY1m*^1-O`gTiEKfQ%ImIDnirZ%Q03Vs!Uyltp zv>%E%&y2}*pjb39BR(U1^Xxq5ffb0^!E-*gIJ5kRxIT)_Q|(3khk3kYceB^VC9A2o zlPc0cz-&?2`R`^NFbh#F9=U5skbpB}ZXJ+wJyL$qbL3fuf_AKhYU#QyBB~Ujf308w=8HjLx-}c>HaX!I1vZ;7JoXqBkd<0qRSwKmT%~}E{ zXFSqAis1wCJ+@(zrGMb$=s*bsQ%Wa8maV5IR}P+JvPVVM=P;{v&wK9fbBnTI`L844 z7USXyCDBBElh$`Xc#(U!-rAi`{@k!LrLD{17pDC*F&3PWYQHiB7Ge88h^F6piLd_d z7e|68mMzDzWnG(Fp(GRv!hmAX1G^&c9RaigLYRa3NRAyQfb&zG8h=*-nh1b#>V&w+o@ z_$(E#z9e4%adt!|J|cF=A`Z6byWn@af2@U#_ytPGR1kJ^nf=4-gl}5I$bU=`FZwdd z{DI7ZZ1mOvd}8se=r$tVTp+VRo+aMX8iuDw?%9WDo~}<{88Fcp?Jx1|==^wZ3MHGl z{Hc$*7%PE5I4j%Zv>&0#%?Z90L5`OX+o@5m%SDVs*b<@tdVn*SIil^*<;#`?#abAz zmF~@e7vCJspDqKuJ;@g+tG3U>w?a#&#j$!fG7i8s3!XG70?nS~@0ceEzbBG2sPIGn z<6?rpax!wFRrr4eW7D3MbT#1PAC+0b^Ty+agg%+ha_rw-b#_|7My7AMbBPh=NE*7p zZh9qsA#TXBzE?XmtjkI|7;fx-*tz*78LV}E4(sxybI&luGhfp};&*LnvgUsR)s-d< za}O{=%m=E2T58{^>K9taUm_0w6pzO3AV9#RmnV2Ng}dgn^*Ljyl6j6xn zV>%2cz$vai7Na&WCBEOncI{O~*<9`n2B6o2E!xVMw7wxPkkSsf$=Qq?r&@iYn()YW zs%&Fk;A^b{L8AlHh_AoDqp50j|f|8})e3dNmNGWsx- zE^joP!AR!lPYjHm0>h<}@>m4$1D?Fj8R}x$p7%INqn>Cz!1LjvOMnj9v#0A!K%FfL zsB6SEKf~Zx_W8q2`c3=Zfg{k8!0?&RqR?K+&$bU?5JR!S<@d<;mpA>2jE%!>fW^B6 z-@gQy1=+gl4+(8gEHlekK3IJ;mXcGIY7(0ftZhw#qabG{W=Hf3SAl<59~TTCxj-kr z-yX^+{&N@A4Im`apOaS9354OxfQk4u3}28mtYTSFg~6de1q>S=3tC}TgN3VoZ}F;l zwC!qC2_{)OcXxgyZd#|LD6^vzs0kkukc2%1m`1?+#W7xRt(hl)OfsQ-7r%OvC$=0t78nVSN&( z|Mb(De`&bQXXjRg2iDlS!tAn8EnLf`$i+N%vu+~wHDi088dVtsKT#YnD5MrH9rQK{6kXf6LpxDs@}^i6#-(kn((C07E2Q9^fO+QM+wLeJuEQ}3$BT`jMTGTl*s z)O9Z~mkg9o+Emeo03`DSZalpcXFQ$*{bIfPrzsb%y?v=_8Ti1yuOT2lF)=634f=%{ z102?V0RUsYFfA@J3%agWTpU0YApe&kEkG2{CgU!31aDVR9@axqdH&(A6A`>ZoyCcG z%yeE>NRW{|fCmQxO(bE{V0Hooxu6~Su)y&NmfZTY@pBsW1S|oa5{1D_IrY&HPw$cy zJSxtansv3iJBul_wNWdI(?|JfY4sbB2$&0)r86!FJ?&0V#eIQLNKk!f@BNbWMMW<Gl&KMV)9fxK!(Sww94`^Zr}nYJu1JK}H!HnVhv5WprZeI%t<_5hYxM+-siy$;Cc zXwX#GPjHInz*?i-73@EU2LsC0+64mWeW*DUFnEL7={OXW_XhS&;htw=QL;GCQm!$0 z#fpxbEx>5Rb>mkqqpxqZ@b{70J41z8QQ?F;I-O5thubG49|_;5kA>#2R8F=wh2vxv znrUYk1LQeA7iQ5eM+jP9d+pw5G?1BD(3EV+bdxAd|JGkiw%CxuRZWD5l~51qz1}^TGB}mhV#gU~=?9gAEQIpwWpa~F^Abs- zE?3B`(`@~=Wj0Ohc8$4zs)C|&h&nY!nq5^vlp866o{F?`>Z!i4)|zsONx!&Hn6b%0 zBhbP8+r2?}Hc!gtHmAq?^QB5&5{*T^JMKY6L4Yl0=XfI@{)F; zs=xprq7yQ|G+~^-pN}5|>HU4*pOV;dDNohQ&I8lDGKqlkr{WOFw}=pfF%8RqpCz)q z(7%={JpKHe21`0O2VC4j*)Gx7b6|TY%veO}fN%t-Sn}PpVp$#^o0j%QY zBTxBhuw?d-%>%EXK!a2O5_B`PG+pidbGIgs{yOTvg7vtW~b|;8~xRuo{t`0 zPxQ1=a^}CQG6FS08OMcys7+MSD|BNW;VFH|3MB4Jf|UjNFOb%e%=j7l>8#RJmrmJ~ zeMc0aThzDYX(#($muUYtE$H7Vg< zr%GR_LHABnXjlpRkLzH++{|iUKtS#u046R4juA3Q-}XShtzc{1E(}SZYf9(NbRY_0 zb56PeexCmxr?tv@|K1V&CTSciX%gW+IH^XkS6d`U;ir#gq9^dMcn!07Z-_cp<-2I%NXmiCj;WFoUnNDY3*|dexS+^%N``9!6qaL*P1&YfboH=v;g<~n zL6Y*JsV~QXT%B;~JhBo#YWVoCnf*3P@KV;dXZ3`-prYd$uC6K6$c%u(dZRU1LajYG zQ2_VMRCc1#><3}PW^gexDV&>%=m}CW`PYoh>MmqWI>;KLE^-lsgc};ml3cREeB*oSf&DhI!LSrK_K?isdZbOS^Lwq#sbI zr_Uzkgi1mM0Z$4!O7BwT5N5f1a89Asrpgj&rx}>MY9*#un5(rCNf6uJHIPi&qnoKK zxt}D$xD-u6Q{3|-NSfCBw98$QaUKPyU(^CI2yxT^?58O3wr(8BnOu+)Ze#mt2L^D{ z>S_ijqH7{2G;uwnk?E4!XUD4T-ci*g^z#aUUt0t@gz^)pCsPu-BN zEwaomj>tv}c&-`YCli;n{(264RbZ-Nx~M!5C9G!A`b%uc`g!`t!+XlV^U}1D=Y_|x zm|au^fB|I(17H7dZ67a`mpD;eI{Jp1h578#N&zo1bqidcYfj83)bVn!f$z79pYe+7 z74VYh(A10G`=h2?`=V}ot6P^HpPfKe83hHI{>PnPX1~J3Vv`WY#(Mz{w+HoUSyD|@ zT?}*U3JVCuFGgc1!}SQ@3+?K>r!IRR-@poL0PcETOl?FpWpXwef4cu-wYyw@fw){y znY!I0SJMTa6t@ISC*?%nF{V}%%a@jfsW^i`2ddd>2zWr+k)>F_v<0;`*P-Ig7sTxc zxGJ-2QW4nZjUq+H3$OVAb=iz3@SsGDhDGNsRy_rsNTd$XuXYX97E>N~h-W1|=%plg z03G={BZ4&&t0RivZN_PkLpBLfufVf4pB3f;yLEKdQyOcKp>@pwRx0t_PNT+#dgXbR z8+ff_ncFziW>P5>@VI-kZI6{U_jS>wffPn1b;tUY-B?*~y1G8Ur+%0TgLkS{$w1LX z(sc=@lDb^{pB(S*wqdb%Rfv9)F4rI@0E7v!)-T^CBD}E3?sa=s22`-yAp$j_QHST{ z*34Frluk-cldj6=)TZ)z#&;<43TJJiLwYrqN+b6Eo?XCPso$bjmB_0 zgH?OCUm8Ti{2b?=_8V#k-uApE3%bh{;K9>;JU&l^jt>r*{>oRF3&pvxi3B;-03#ap zAHYle)JCg>jUfVQQun(+kHWGm;B;H<@Tj|DQr*;$rg@ak7-yo9)WuZiM^{ozq2rCp zY+e;rDS^A}g)$fCWL8^AlXt8v6gDQ0+Ey7WfmFuzillpRH=HbB%`x>CXeN#(d^sNi z>M7aCnU^v($g!=0uCS-soEzl;;kVh$RccmlA467Mu;m7^cSq8>da`#^`|4_ZNWqZU ze)B`;G?hzDrA=dU4~b7`6_W`wR*J!&K*cY0ik7A*O)_Z!llb6s1X)s> zGO+g1t!!*hvCpE~km@ZT2OFzUfqPg5zpF4wA@lxSfLr@E<0Fw0q)wdra~e&{um-=T z!nwg#jrku=`k01~UGI&IRa^H_??ZJqt*YiB542CDLF24M^HsI(w66?{#hYqdcLAIlk~7h*b(NV^MU-|WQbD@Ct6NtC zqA24Ffd<76>j!u>0SlPB*uy)1V~Jz3C0 zf)*(0YT4$F{P#`AYZJx+x<+%2gGSC0Fb8E-Jxs=xr3PvUtgrf1MPeUHK$YTQ{$k7z z&0L#I7J@paXUYzE+aLYT0H+2aMxUGETZtxSm1;H54ResO-X(Ll!s}EK9RuT5hC6M( z*x9nswb;aJ6Yqtehx#CY1!OC>hBb7NY}@YSsXw|#%pMcNv3C)!ga@l(R&C%34os7G zl@;N@G_&I$c?xg3gwKB)gDp}8xmP<(cJijT$NRIm@j5Y6ta+Ll53SbDx|5~V_a+!e z$xAifP!Ckkf0#X<&|J{fF*l@gn%cXq*n?=hspozD{QWclOwbnIC;Qd#S$*b$x#pF? zo8MYM3YeQQ7ECESTExnnT>0W}x$_NiqmRqaZ-b*u4bjDeBUb8)HU8 zK&L6bg#BCD-rxXd{<{Ir6Vx0&yS~Z`JqL-I=3wTE?Nif&hvjD2ChMSjuNnquKT~<( z!hHLtQNc<;n_m*l-YhVU-Wc=ds0gqQQm}KYSKr z8!ExF)WH^oxAp^WFK&WdF!v5Rf2ODh4!u`xo-F%xWZU~nY5}EjXTwI<#iagrabemA z^ECIm8~xF5++;KS15SkErAuj>Tjd{{d3NR{y#y`5r6yyDP-|!;iP)lin#PD)SW5%h zrCmPFjl$o+xje0*dG*?{xnd;@Xnp5qTjxQ0?S@Nq4S%atyiEWfhJ^jkO`eH(_v{Ha z-06*+!n=^@6KJAsi?P3c*fMwxM|e#%@D)ML5*xI!FL<#|9duQL86uJd)Rhtuov&>_HV->?TFQR@e<}w`DO1I_A zaHGir-rc*Vq;}NJ(cER~jO3Jx;O;6(5TsgplO(fU`b{>1XsuPX*{ zt#&q$65=u$xK&>G4&@-kd;+Na+50m@V9t_sl++w2J)w5_rse>79f8JtIyxD09Ml0I z6{m+@YJ7pgHe>FZvb(%^1pi3gfLNiw}U(0P*;(Hl@7y3=}(zECsVa?|If~9AFs@L=L&b&Aesl@bT z{p{g&eZSVqKm=n1uS{niJN7u&3~4VO47PBa)N+L?YyGUm_F1{h;IW^M7QSNfXJ);V zq<_0p#-p#Rj6jZKJ~3n5sdO)2#Q!SSh2YfUsjW}+>Ijof>-T#`g;E#lz)lT-iO?!W zKB?M5ta$6PhQe%D|D5{eGA=bSc?2x(QfFd9N336O%0L-ghEUbToYEcmMXD1B9Srwg zFdu8hG-?M7gV-em_R;t+zs=hVNWwPBG7P-)Iee5|B@T8U)%(h`m)@ld#vyOBCO27) zkus)e=ys3N{V9Y=?O>Trn&28BkDpdG15AK!I@uaof%f>eQkoz{*iPEA_>AZyK=4?V z5*=o>vra{|BP#SUbanW2qpqMNho{0btp}#_N%IcPfXE2#chbZm9U)uEYPE{%uV9_*5l-&p25P4pu$N`BYFX?jVS(V+@C}|sps$J|4c+>vi zcP>4_ZWD0E^=Q?!QLJ~7(DM$7F0;1wAM)mD5-elFjfl;#kX}8;H(2r`nKuL;t~t z50+1ib*faoCDm1N)|owdTvPrnXpV&~}BXYQ9?d4Q1@m=}2YS(tA5@XqbQd^suOrQ}jcrJ)j z_1C){`UVvNWTd{At$GGC0`Axcn{``-|ARPmq^YN(JZfIx?ViH!IDy;vU&?tsHe6YW7)0Fwl2OXvJ%}q9pSiDMZa)xy z!!=*{b&U7PAupyw=lRo#343KyTS00iA>b1s1oIja{!8okuU4hZxigomWBb#J5J~mb zbntByv-|G?@LaD{^}n8l!TiqG>iP$>$>i zlJ{p6mYA=1p8j5>L(Y|+2xHTilxvKKdIr4)!P2$$`+s@8f1GWxl^BK~ z0$iDwcV3H=>}hwJ~FQ+(oVd#lI2gk##rEU??Xq@`l+{esI2|$tx&oU?Y{M!)h!J} z*S3*@-uU9nm>%5^*O);kae~LQpJqq5;@foJP#P35$b8+C$u7lc2nI)1O;aj&UvZL? zx77v7gv1VcKR_HfWXV^F65zR7Dppc@N3rOllNz>@h7)H!lK0ZM!mk=-rM=XU?m#RS zjY^3Um@p32E%|u5b!kT4Xxb=}Y+*>yKNu((tcW$smXx5dg4t-ns;zT!BGQ`OJ6A|2 z%PNse@=mB&B}^hsf=!Vp#G?rjg`Jxo$gVn^vLO<>%Q2jQrY)M42S}M-@@2Qy=g(#9 z)-r2!-x8SZ7GlcYsJxoWskX0#Ev}B}`2&RRUeLRw%tGTTN&t{u1d%fGZ4w@VRFsKl! z*(yVYo~$c3L{*kT3>a}=4e+Brmhq@32vm5A4|^Ax3xI%XsJqXX8xGHeuRWTOpUMC` z>N~xdU@?vX=SeNdafY68NcSQT3RYnl#uWaE^LLkLJTNMqVz z%th@`*0L`RTpT+VBLy@l@no8G)Y^M;t}BK=vzb|o|@#UvDe^FekBNUw__A>}mi z6k|ishyrYVRA5(w6&NxZ!YtRs4t8Cvz~`6{#XX)dgr?m#g%EO_Ep%bFjz4!iaEBp< z6hXpZ+^*$fX!%5urrOe-h-gG6b*}uB1;%(^3c9pIh24gxHoOtPmDt|ViISEX9$=#2 zjR3z9C(4=AEtO|~+{v+JjH}0}3Wb+`_|e1em5v;wV+K|@r-~RV#Q?p9_X3!1aZ}9#=M=KKP#deP4XF5a~ZGe#s`Y1y3Fb~t2#V{QT?38Na zym4VT41V?_(AGN|y`_as1Qebm#RZFvXG@TZqgs(F)v#>}?nZexS;8THdZ0DG&yiM= zS=OK}-yOGqD^VrWyJH%e>ygr%S-f;>qIfm1dB*a$0XBzgR)5>@_~M5h#H*?bR^eh# z3iwEkNHLcejD`hoWL@yt&O6ynXdMNfcM~&2ly^hy-w9LzJa{Q2t0+`bs^DxU`YD!< zho=4BG?U)|6tHywjtdGSrNQ4WBPE*c3vK#FIp2nV*pc5e4^W(>9i+C)*$nOaD2nG z@x$XiEFQQ4f&H$Xk8HBanbl<{TqC0Bad$Co73nV6 zNz$QQE7#C8bFy8z(A|Z5j)XU%V3bQXoxbINi@T22=Jc+^ahM_`il3ACQ05%A>EKd8 zD3qaUq@&cLAy)=WzMpSd%H>Tyy-ODUPzOA1UU6eW*X2+ZEp0gmngqX~0Y#ZhFS{NZ z#8%lMN~=m)$|4Ajqmq_p;lk(ofk1m_tQ)7P>5S>nB~cJ>0Vk%pHRxDGFS z3VHP$F#&PL#bcpk`V+sDV{XH4zAX;TrRfiEAPxUBh;T z$>1NdZ-}D>nvBRU;|oc~HMll2M>nfv*F=~i?cbVADWtDyKHH?BY`k5A#M(H27WOB5 zJuKQ*LMyrE+^84Paz>ODHTkGD4ZUbf-~tE0UxI;crEvNJ7%7}O8sTxK4e+?7=mwU)YBlu^oC8nPs|y@Bz%f#Ho-2x_Tig9xoxWm= z3irLdrAt9x=214?Oc+@<4xhicVkJvGygLtV#n?2SeV)y8zA1P+E_KDbdgc0@UZ zMJ?z2SV|%14YJ3DRLy_qvZPHWcTttG&`{L_t5j1R+kjr(O|rF&H&KMepkWVTY)XVJ z4HkBam&f27_{J~E)T8eDOuZQ292J7{DovADNo`-ut6W+f8{s9hMh;qkfXVIKluSuS zT;m=A+f*IB(y{49EaB;W!KumG*B#b$IHCr!yXa%@7OK(Fq434Bbq*9<#KZL0o5p7Pgq}mtN6x$rYt$?LlW#o@w}PyYngQ70`GTe0F3VK!UEpU?^9?}$zFf< zJv!04Nj04V~71T{C*-I%k#}0I}eZ z6hKKhPVnB%YxCO?{+j_*&E0tOqEpgjz3VP;YTLG_g9Y98Zz>3$o5yAZI&gpvlBPg{ z(nn3~4T1>Dh~(;QlvgZRH{O%k=hrhF4+myTgn<+tI+=y@Qe!)vz$FRZl8i*=(Hq^G ztF$4%7=x{+d~t_=5%%a{4||6&4Vo>KO%LkR-YNY<6ZuI!3?M0&4(J;D7`@-(<;&)( z2J-#VlHE047)DM#?R3$;k?%KK{LRppWw3lAy0Fcu5GSeI=3WLW8)`Aks&4Fx+t%Pk z4z%OpgC4N%U`6GEMZ4^hm`gr5S?k59yTwG zn*;}sH;8S94^q!(-~-jcjDio2*%Ep2WhZPgKrI^8K^e)v1xUr2acW_XUr^N%PSV|@ z_CS6qT}8Ih*6gLu&UZ@m2vnoJfz~ZBtTf)CdND<2aT~ysh=sWESz7@=z7<%$c*5~M zNo7MK+xeG&JI_tKdxPtu?{%?M>yS7-ab)Mg;!2Q9Q@m-ioZ!or zi0#s;DS9dqpg*OGvfh#2H|vwrN*>Wre-!-Md!BKy9cQYMs$}VbREp>A;H5~q&YnSK zzU;`N%dDFVkz408bWKOARNe+0J72oAZgars(_mbG7UC&Vri%()=vdpMu@u9+YLdH3 zZ{4=K6#dGci{=+?6L?go>_UE69+ytyg}bv2{%PBsu!8Y;km;a@tw!RBdlul(97%WSo@E_m|GRpheGH_0@)=1q(H2p5fuq@9bowm~*`=Wn?YW9ifUwbf2arNWbu3IZgNqk(0^ZG%WD&+f z+@~l#-0%PkLQM{;k?ouQ+)oGGn%<)0sAf7o_dqfj>&n4%Dbc|(?RT z@HYLwwKQ5V501wmjd)zAG)6KdXVT;Y-e_=D&9hmZbY1}tiyRMC`ou+oJmoX1eXU`L)-Dvl57+;cP}l*E^R z4M|kYwHgyC4GY39*~;ZB9xD~o0<;WaCgu(gtT69qrJ@DRW-6M6Lfg4c!4$we%V#hz zJ#tOu?cuBQWTarqhkJT5#KH5-{kVlEbCUQKo($3arac+q0D#N;dNKnKEB9nNY4Czn z#gsY8GlDKn#)OhQ*NdJziPM(0R)j2n4AVNyCh@Um<;K@IiKe-;6ak8+v=sMl%co-A zo>}p33`B=e%@~MVf5~GGeQq-%*OlTOWnsfv)b}LTN>_2bI1wX)gILipIYYV~FAMFf zAzQ1cifiU$(!e0YY0o}sZ@0K1dKuK;#L^P2{CGB9U!e9IK%h;`J6qc6#M@zjHxKZJ^k}9*(sE^VKSw=ym2{%c3yaTWPD0w@;Dyzqmc4(&30qcb#K{N z={L0qHa;c$t^kfWc%CieTUdmX#ILXjMDyFV2xSdg1FJ*bz#`1not4bv1h!oqPuEHJ zJZSBl_1xC|JFPD-K;FB5?zqIk^K4PvVtt(?e#QDCnjhamdN=35IcCb0s`qubN{;ft z!#bUiVwQSo=y?#U&$RBPQa!lA^v{g7RvHz~j#?*ac9Y}om9u8hU0!Q?vSLceQOq@G zf7a89PNY@Gw_|#M(@V3IQUq46gf)Mq6VEAnc1})Y;%h&h=#A!oZrxjfjO%Q^UB7dh z{7WYzEn`x=TZm7=&LQSo$8|BrH}yDzf{yO#a3BNEGbiB|{>CZVSGXHU^1HWjGj9V- zh$(;B=1$(mz{ASDjb552)~Qr}GTq8^x;qKA`UpAQok(3q(_+N<-Oj3P2~D*Ot~Sr7 z_&WV~KW3+Ot?5gDnkh50WFPgea7|(A#r*(xg(WDcG&6&c9fdX9Itk|6#6RFLh;~zN z;VrSU<%V%*?g*AM2hStKy#ZK0N&9lJoJoF1%eO+ymczXH`^M%+9@dSPdug1im*v(P zYs#rly<{IQYE7~EUP`qu4-s8q%D-bgKAU(Di7w-&WR>iH%pLH?e~SKc`uxErSc1*7 zVW!9V8p~=!rqQ8Nem2V=@kXPF4?bN~=&$!iqZP0U@A=FWO z*aJ?{zG4r5Ad=s6T&*-rh47X+u6-A;_YP7nY+>($XT)~{P#1T{UOKF>>I{D7|9C%ncGVG=KAc?uX zRH}J~LB8dg->)^YP=bG*q{mLp*LsJw999o%+GKJx*mpM9hU|F+NBj7))r zc)>0`qSrI8qPycXlfL|28ol(_+s^0d(_j7%bpj4bm(iyO69P0emr=k5CIU4$mbwQP zf1~#xhVKV35P|@S0pB*+o8yCa9-D&|#K|GQpCVa&HlJ z{>>*WCj^eULBk4`g})Ss^^h;enZt~_ ztd$g;NG0B2xz@nEl$jXyx`!*~e**(Yo!d2LJ;^2uw1buhog^8tRKhYyq5xXdNeX0D zKL_bwDW_oqTfx_y*syOke9fYc0R2lfd@9g8($Dv_-+{XDJ!tIVF_EAdf2G$bk8uQh zjJ?AsZ1a7LDdT34pDRjkD0#v!JG-OgAp*x@7P2*Y|Y9K!U-m zP)sHX^Ri%W=G8O^C{6^QBXEn!Z%athRShAEMJ?pDiq~5~vmByEirQs+gfgaxl&+)H zQ{=rfEjCDz0H1n9&?dJBec}Pi`BtMQ>FR2T(d{P!7B=9=+5g4{zkHdRY+m3bJrZuSZEj z**(*Ih`_P;Rj%Ome=LDs@AV+W-+PK(dHz?oOR+cb&&Spw)t={7VeO>wR4`ntu5CzI zP9rrl8=5TYS5w9WBV2Uw<>8W~9Q<&k_zlzl8dR#jXEcNe9D8ZLf?ikxy_>S zuE0)9px3h#Lj1itIe8g0;a^`ya1D2>#w6$5yhieXGHOae3X9u1${r<%a z#RfCOzL-Xs!JgfwX5rTL51epjJ8IrG&wXPGog`vFpMKn8^#di;vW^-fqOOlMP#dHQ zBuZE@lc;a&RD&@=jJ;>XpD;MiT=#240gJ$25e6X4fA3+yHNpS}!q4v*1+?>THwb9x zs7vF#(No)_3+$Vurlac+jduzKHdz*%LV(eR`6wX8H^J_?ZPpp&2%si1?idog#hr7G zXeQ?@>BH@+;mYC=+E9ZtqsIV<)`M2lO>*8o8uM|RvJ->SkUMhnf< zrsSv1e=8rFxT#|bjA`Uuv(t#dapp~4!!cb1{tCwwVSaZ^ui}_;PMFg7bWJ-9Htd`> zl)SgxnOCdK+MdjlhS+#&<|gA*Zoa^x17&wDCLj&|lYsm+12 zL?y9ihQha2kIaN2+TAsChZr1ZUd=Teq($Jbe{hfx=DVss%>IgygfW(E>`Sz(p%(aa zsgMmC{7_ZQVzwb=+I@M7p;c9_8$SO2)}<;ELT}ixJMubWaGWvdHF$jy_$zoFVZJL~ zFK?F7gzBW3>&U+6*YH%ZHy$t1zf4aH`>a5D^^DT%>dSeSfHk9(dAq7~rWw&N{EiZX ze;6ERY<>-iSp@zHi9wj}(>f^dcsa|}>2Ju1Mi8a%s=E<`FKiLzKrWf}&6eWf({$awJ)Npe-||u8 za6`Ki`|Un|-jbIe>$KZ{`Asg?Yf0Sfe>3*!jYT7w+aNjCA4|>n4<9v7I#Q+s)eVbU zF4${H{TAQA#H=EU-8H&H430BL_$n{_T>}1^cm770-+k(<_|z7bPq2IX)Ex#J_NiM+ z4keM4w5m@qm6z$f(F=<5p=N{LH+Kr+{F@H%nq5E)jx+Uj4NbTR{1uuIVZP5if0y&m zkeTiQ-Sc5x%>RDv!@T_*@oi%F$^LTcK*aCqA0!NpGgiKWR4fBuFBJ*qyL>YVrwVKh zpTC>4=GU4`&ot9whUGad|^Dpr61fYL}pK^yznUZrsI0XiDmN=&H zN}g9O*vAY$PxtjJ@DcyRrGA$?APL{t`p>rE-Ry>x;l&%08bSsCrne*Qh*H|B_$oDF z!pqdC2ymu9{`((*XLS}7tKg-J{Eud&%_s;gE2=dUo*s+y#3Lqr11)ap?JX#bqRBqFVT5qqM* za5}D3A}sxhFv0fyS~teY`2<#1SXJmT(BiDMqH3uqR8@1K5O%9HC&WcHOWl^xsb~}< z8n-Mw6xV}A=-;MQo?(6Ae?leaWrY@TU|O%OLzdD1I+OXkTAr^}q0E9Hi;yXttR5BtHG2*_R6dHC+;d8Q5`)2#l%_sIu z;%ou(A$||ICLn2kf0f5KV0rVEtXf4g=?PpUQuVrzac(8^K(MhQkCS{Hl_bef3cQ0*B9e^x-hf5^Vu6FZO_{m&YYfvOS$BJ*3-{m)iufKQa9z!k5FbL zQJiy7+11K<91RG2P=j;LP_*Ns#)RJDq;MjjnW$wk8?pW_VOy>DqAck~mUJsh%Bd-L zdWiQehntVXea52&6ChHwtd~Sh$~AvT%!#{uDD;6oe~hFz8i?V#V#lOOpwcukx2v^$3nIOdBN*C`$2B5NKw}^B`v>?0- zccllPBQcZC<85Mw8F%2=G)?u@A<7Km#c(YfuK?NfkN_l?CNQjul=!>ZMOa;b$GPWH z?8`IkBp8X+vs~lua<6Z2ck|mIaZqw4af35ge=B*~E$LhmVIJY8UNyW2*ZteIKAe@Pb;#Y7$dDCEJ?5>d85&>XH+(hU?77c!TGlO z4)$|VT2)_`v3RNW?vU|xv`A|2&1RO+ZV+ZLZC8dFIKmWW^-tk3GgON>Y3HqD>uH`$ zf8b2z2R~K5ae*-ur})*9IE5*w8;ENFBntLvA7=g_F2>xD)QHqUO`J4q583$mquo<7 z(^Z_(%K7KQoU|lj5I_~;;@4;8OxTmk8yXMD+`{LWxs6_vj}iWM@gTf{8u& z$Xam2Kx-9qagL+nLPd82_p_)pp5;r9e`8u4&68x7$LYYz#rXO#GDQCIK;cXY3(=ZN zpOoWlU`^#qA3yku&Upz>PE~-^ZxcEf!TS5q&fEyw6Cf1Cbh?;QlrceB;+~|-d6#4e zJ*cbFA2f%muI1#cQhnD$?%7xe-#YgDY0}`&hYn=r@(Ie%a!9nI(&~A92-687f8%4@ zy=eN`Y|qyauyOR0Wxtz>hHPV6PxFYybg5S7CDxmV`w!_-tToy(CyBLowqa-e)VGG<&9lFproCh;FLkAefwq2xl0)GkZz=#9KR}33C`d{eyD#p;y6-IDJc*1%?!= zm)XFqB0Tk=I^7eM=$^~Ojw#DmD`3G!J0tjoEF61Y!ops2DicC7S$c)te~7cK$zn&W z>qM|ZalmCU^ikeCs3+jPZ zaB0Cxlq@^8)VmdNbXAO0fBK=0kA3<@>tt?6xb3r-Z|(bVB5ld1oi^&eLYEtWY84jUbC*ZXU#yqM!!%uv{!6w zujobgiY?kJcG_OOBHssFL?}ak`Qc$;uKa7GZfdW*Q1)?Gb|H&CfAyz0oyhp-} z<9mJS9*O=ucmy(~>>98+RXbnX)KgVbSIK8g9hiq1RlEu4FL0x9+-2^t->-06Y!@mH z*$EX=Jd5Ze;Slc*e~wagYED_`cBN~&Paa5*{Xf9jQqe?2F66AzjmV{*Jm zYc2#SW2!Xkj4$dnl=*-_xTR##bB11@U{=Qg=hKPybULxO9^fvg)2=2Dn=t2X{2o-0 zFXw0j8C``#YETWMyB(B5Hpg(B?{$b_hORPqgjXKNY{gTlkxnT)Q3q>utmmk#6(gSu zR7o}F^D|oFf2c-pP+1ocg#H)Bz;Rr60+8lrk7;vcC2%P*B}JD!uNfhmkmx08O$@bz z1f!~s3PPkKT4dGd6CB3%$#VfdHt5`}rs)xdT@(BxTlqJ%zQ-bKn?{B9;N| zcP9FDtoTl)L_Sm%mWPL#Xr0MgsXmQR zr+kt^y3fl9*(r%3(Nd2Q(>Osr=`m#Q~F2kjOvS!{TbUl zKm2i4FZh<~Sl5>a&x@8XeMBF)#A&XhFk9m5)py#+khQ^ukgy0dPb1Cv@elt80va6F zlQGT{m&xV^MFKK6mk{R$M1O7Xa%QT#-c?;)UYsaUg;r!GjrScD!L^=na#O9@u#Fc}ZB%Fhuq}G| z4lJoS2cA^%3~x25bq+e_$jP*kvV+4Ba9z13%)6U&V5t+?0qS%B!=RENzf zaEBBSrUEk};`|Nwieljv^A)kq5jattPZ4r*1wAS#Ez-b@Rd`1ShAN%}fdN-kP*hZa ztcrz*nv+C;q2%ETqKa~spcY2JHAZ-z4)9?G@gO9Dr+|853I+o)F*2Zu_z)vgk}hI3 z@Z_LawZY%;6n`6B5jaG=a7CadR>t{ZRggMhvr;tO!84Vz30A?ADV)w{)hV5=am1%| zV7pQ*AtsnJRv=(>%(+o`4cMumE5w*{20aDrf_p(w0Sf>IL{VZs1+>MTd`hRh3-JP? z0#l?6sahR^P)XG~>4sHFZNO(Geeozfh4jULU{2Dvfg}zX;ohdeVk3Q`*jEE}XzdIz&ZU@#h(Z^M&hfHtXtFJ&lU;0hT| z7^L7JCpWBF24~br%K@38v|%)`!Un36g#Z_F3AM+$fU4jENL+&=(Gpy5rBWnqiD4}r zd`l5gXaw8~?p81~r536Z{H&B;YEPj6L!pC6fD39V5QsTH>NFJ{b5vL( zj_?$x)OO(=9eC-$wSu#aY78TPNDW4~E~wgR(4d~MqHes7+M|Q|8elez@Z{)0&4*b* z-C%yO9I0BXn&+p&}g{a|PaJ*LX!DpYHefOUi=VzZke|~X! z_V~9SF8S^6KRy5V*%ucte>{Krq`)wj@6Y~r_RZPDC$jtUIc|G=_VvYocNb@m{`~aC zi}U9{{`7l(_?HI{&b~c=cKHPQF;hEgZ8<25Wn_aA*4A^h?;kw))0%J}-Gm#S3-z0n zTqY(W7nQXEe|ZzIm+VwIrDvd@#Le&~)&~654ZskeOzOkpWNKK&%Deg%;D;AKU%Y($ z;_0*V3||-wyr&^=cxQO6&%H2UsVpQ*Fmo=c*k-Ne-_3PVF4p}H-$v)ymV&pDQUgc4G9hY;)bd?+=9;CQ&1z4 zAqE`9HiPR5YcsfacVD4nb!q~ema!RwyFqa|7+W2xgp3UZ)({Ru`c+QDa=c#c-y{IXBGb>mUOxZrmmi=e|EkOeE}Q|$g#{*v)r(P8_v}oN4$Vb#Aw5k&fj~EIqlNqd2RG;3&g`3xh|;${=R* z<+KwU$H;K*&C2bm&Jzeb>HN<^3x#V)pNVx3tcQetaFtEt&OxVC_n<=}&mx{BGG7 zM|k95-Kvk4VdE z@ISHqJ36>WCfu#b(y|(lm`>hi(vhcChc8%rm003f)%GW4 zc208(`orHX`&2*u`i?!%M)gIxFiaS=n!vVb3SNwXCXIM}!1;G>m~ypcOS3J~FJ{sg?wrcHT}pBm4Cjt%Rd18x$f0E!e| znHRW8%rj$hB|hAg@4HnP-IiWFo$55{nN5pWvW{3Ov4ni^WGmyS)%uVeVzs&`U1q8B z?rcCrn{jEI4TxrUhmWF&@kCF$t$hIVe`5>-K27TbnAWK#Tu*;83(Os7S|6PfU4Lhu z^#{T<)`(o#qD^4?*$}Ys(>M1{S&$w+t1mi>f~MCfv;3lOcPMvRAAA~Hytfs(@nk>S z^95XJwl&q!b7NOi_|Q`8W<24tYh|K^rxTJh;mPiT!V}bS8V5E%sr--A6FgDUe|?(P zJ+RwvWAuAhKe6%->>~Li?2W@Vsv}pdnB51MQDFIcz3(kZmO06`IJLmem~1_;B6)j!3~oWN4K!Pr@&yL7l_<0mTbS0d^;V*I z&FrR68nEUWPCWZhmw9+-J6@}R#-lOt-dP(8zC#efp7)(cX6{$pl|}O_e@L{j1eVRo z_>Ky2I2(G`AWg=W=Uc$kY>^*hXX~PrU3XDLQKQA?N&HrG2MvS$Rsz}>A}+)D)`slX zHqlP~tuVbwED z3FNCu4r9$5RNd*bCm`&;(Xs4;uSV3L;%5;_OOF>_qrJ`tfIwMmXJm2gqZ@q@TkpP4b^;s zQ$Ofz_G6Y2-O^9(9%v12K3|mGA=Zu9nMI%VqlK@!qgC9Uy!bD#d$q%t(WeI!mx}fV zCx0|CH$FZJb98cLVQmU{+T|R}jw846p0DU1P@C@uAP7N##DH&`?9K2&JDS-X>>zdy z`TZ1GMY70dYou9Wyz5|BqiHrD^ENf0%iq7>w*8j+8I^v(M|+38x_=hv^OujycYl*hT%%KN`S`L(v4%yt)datM zy!?0+LOCI|6;cKI_Cm@F{4Rww^7PZkAC|vf0vCn?f*gpU#e;1K{{ zf>&sLIw%v5LI-FSFQKTsf%>e?V@%36+9X(ALj zta{!!!Ag%<+1R0F3tDQ8Ap~8}Qow{@5z7V}&NRY0pf_Oljc+1pRv#CsSFi-q9-}$Zd>q;s)}KuJ z25Lh)oYq>VCxat$tEKN3oWY!Fh1^>mOV3ke)1{TtB&lN=l-pkF683PAA6(^Mt zuz>+(>j;g8hdtL8Rc2Jw+eSn=&v+&n(%QBMmQWOkR_RqoO`%o;pUK-mUJ0YJZHgOev+xMDl)&h_qpDn+YjeqZ^%pIGbBSmr#VO;v@ zJf0n6<8QMAK)JYjFe47$fp=n?h?lu{j}GMnOslLL@oH3{Bcb8=mXf;cFaT_q>=k%@btEl_u7 zosS()3A)VOMwjg-5kt0|oC`OGb7EX|h}L0oh~Q(YD(NMdR*KoMCn1(NXZ%!T&NN;s1&}Z#*?b zO#t|0ExH`&_hvQDL_cpN#n3C&-(}g`L*?%w3SkXWEoP0T3w7V&6%7(lzH`LGb-{AA z`luTG=$&eva{W2`E%ljd0CdXz=NNjf15nTK(SOD39Fe&n*7E%b`K|uu{+tiAwB94t z@~%f#OSMGR3E(R^7wKS`(CSBWw8sw7o)YWJ(Ux#JC^wI`V6$goj!Pe48YZ|Fv~q41 zP;&OxfD*3oYCx&1)Q3%nXnKwYPH-;S8ieZ70(NtJYZ`=B+``5J%A4GZZc(J1qA0OD zeSgw9&iHi7i==mXdDTFuF~qdER7VyGmGdw&HWzwQ=&+JPN)|rNbUZis<)_m@Q`)XA z@ESljaf+ZC5-AtrIKJh%fPu0N;nyXoB^GnQH1&Dvcsh>|V!pDVi)g0AS>zF2N&r}Y z!uFaJj5Cq1DUw^#bQwh*r#!`px^Q-Bt$$(7+Ts*ZB4ljk1kkR(W$B=r1H(u$3%-Vy z@F`ga+Gtp|WzVN5Fzt2FIX9|y0?-?k^cvDd(d=!nLI3C+P=-xa5vSA1V^^H$;KuJ8xvQ6r-HV7c~pJd2} z9{2EN0(6H@&0jjEtuLdHbjoK0um~ArNqUl3s6|=+ekWO;$>N)|C=JY%>>l~Ee8~IQ zf?rF%*nr(a|~W?^vP_MaDXOFn*aZ3_Z>o`dVUo8y4VyDPTnL<^AGnGEnKwYC4Ru zHCoGb4(Mm_W#vZc(D&1OD4zzC@wrD2Rj%;wC_WQHyl+rSjhGWf6<(VA*&yVPP&kQx z#;rPP?$ckdp}ToknYbw*s(S7C*9;k*%*D}Q9B8iQDtdZ zy(l|Z%b^;KRrZMo=zZ(f05-VGuV?IDP~BGgTVSM46@2kAi|#;VP(U{&WSUN!}*MUPSk#foq( za}!Y$rfyRlsQK0c>~u3Os;la&%$a3Ouv%Pf?R{`)wMSNtT9NkL9D42@>sp_j6!a7H z4uX}f--A)1-pmx*tG=tjJa$afP=wpMzO24_N8LC3X|TdXWq`XLDB!@ZlMd(Mc@sc*``H~=W&F5e@3V!wJQ088XzEX&+PfSYjvpFb zFvZ1z=WebhU4MA3^1Yk&KFq?*#|nWi*(PUBim|2|QQBi*GJyQ7=pIX_dF)(OSFSk8dPq58k2`~bIBKqZ$ZDj&SHP2a`!pjch|%=)_CO$d7{SAob*%-6)*qp6>_g?$9vJwJQw| z)0YKbVg0q zb86!{WaROX2dhSG;^y34RazhWa7eu&dEq^-XEgK}zA(*f!T5%m1PicKqQ9V4*E{#u zB7Zx_2w@IG@Lro4RkglHuV}^0G*b*>bl!Q)PiyWF^LQ(TBDzW{ZMHDv(|9L=yH{3X z#Yn4m1DpJl?&_O)-2ojP@D|k+$7TeG=LSFPUtrWj=B5PzN-fF#34>Y^`G&vClyc0` zn&sfUSyc!nkzwE?HYx6#Vfyf={{a~DYXMD{(WeI!m)->jDFHc`4^amfe=#|cxuX6Fit}R?AeP0P5 zVRXEzX@P5gd_Vp06Pp}yf12y*{b^#9*okW*t(o2*e%(;YHDy9k#w{KVW$Xao8D)}f ze|!JS^!NAoXG+#gF+;Rq9ba|GhpJs`=2)Kr>+gUF zaeuxeZrYg?Dx>zcYwysxbP_2MU4EdBQr2bg!R)!|P;B!rq5ey<>PX1ed;9OF`J=5gkz+2eF9NqqMdY z3Kav31|;n??AwR;)3wK#k(KZpH!K_l@-`;qkn!UHWJ#11JPe$PLz7;O2#Q}%Fe*f* zbXw1Ozz@WhngoDdDO>cYV&jU_eJoCNn4(uzj@xLP5GBaWR)Xtig-fdQN|1ftANt*t zmBxywjI!&0Og z70YepxNQAPju>fzVojcW8SN7++T#q#V-52{DpQxN95n#5v!9PU9P{cDFX!;f)UnsS zFcVh;B3&KatWN;y*N08Z?*};Efl_#UVZMRwgJS&M7B&zWy8XWtvgyA;i{|=0v25{2 za9EnF>&mAJbqbBg|Mj*gj|h)LK{J!JNBBe~eaaW&?wIL60} zE(ri|{nF#eb!nNz;S?pyhCf=@WG)(TEmn0e-bm)cFeA>Gnpdfd{8vm1pHUUQ*l&Xt zRS93R)*J0%JX>#Nix+z^bheIb>h@aHZ^}4IPT_~@n1BbN{YgM3dq;<7Hr*$V#StIA z$~rwlJJNO~*S6}^RyN+aQOL{yLz-m|526ZCNg=RT1Z~ks1$jgex^YQ1tO332km;QM zgm+(lX&F^z8^kPIvsf*qN1ik>kQG~#b!>fNGde_{sbGQ2MZ^UgT;k-M!qMCoN;2|l z{d@gBpn&1@r?!L~KVV+4ilkr_X*dWLj%IFydO{huDd zq=8==xGa%a`oyHZgjTNkijPCh0ok7T!tB zNRFtVHbbm_$_QswIic$JDAHfvh}vZ=tko%-&La!@fIp^ec2#P{dZcN|pm57z`$=mu z6E=222%ZC)(8JTButFGGn+V5l9CE3EStN`On;Dxp*}`6|XJv5wDRAoW+olm#?968b zmLaoWE=LhnA`Sj&qqBweNS<%U|5;ou>IQ_h6;2U<#iW4aP? zDt63DrBj<`a$vnSLS|g?HMPIfrrjpeI99XXe-R6W3+p%I$=bR4{xQH>&`-r?5;XR~ z4=R5020R9HCCFs~sLn&1)M)ns(zpCrvf8F}{fR2aQH4hmm~^B#Oq*-jKd{f3vd1vI zDRP-w3O^E7(sqX5e>F+Xs~VUw{HkSdGQs4|&@86M6h+WXy9zPOHFt_TR+*k9Rq}Co9q0yWK;C%4neehE8 zj5D5Z=d@Fo(<2gVuFP<99UIK3sfezAG5;j_RAX{b;W|`DRo_@bCRPT1VRcdxMwU^- z|Us@A2o&s!GV8tMIYx*o|9a7 zL|=^YI9)yXnCfD7SBrNCF!+U4lg>?7lTywgy}VG*Bxs+dq(rE+JSpjWkKS4T24IQy zSzW#XS@lhtiIa?INi@T(+Gs(4d>A%Q;giDEX%QOLgy+s>caJ_WactU#tf@BPCRxm! z(P;5?1`AP-i4MmNeGMdqg<{EDb+Rv;jB8(@9#OE)7evscQUtC6oK?_I?^RUQdleBV zYeS_>SN=fbQRdZz$;?u0lK0y!Z89Q>-7bQ0;#z>K*+U2&(m8mHvP-ty*W;nJxn!K6 z|4xnrF@b@pqsN@la4-mXCZ_mnJ?n@L)G?#}uLi{0Ow_4%OIZ*=Or|1K%CKR@l!pF} z2xh7*ry88q$%pc@U#B-Cmzj_k1UR{k=2HMI<@MjJWUnkCfy}EK;)q^+S~MyJ=>z%a zlKgV7Y`9$NfsmxA*-Jv-Ao>tjB!e~BuGP#7Yn##Ob6$G^moWOV{LcA6b za8Br<4ms%RW*Ri$nD2#-9m{nxAgo)Kh3%FyyrUDRvK9>++U$)gzlWg2-Pm?v{L9kb>T)%=dqa#F)b)$u&b8kx0W~ zFpk=C0Ug94(RH(Um*uBbVxo&4gT=BZtO^O@X}o9Rd4F$hhX?tg6Hwp!Jbh`x6%-`G zXRokPVNi-O=92Sd>(?Z0-C$ItnW zbRmx)nXcR^@cx>K{F34W{o0h1f!jy};rd0Y4d{47xP$q{)-_`#wX+o$Rr;G)`@nc% zP7-t)x!g_>NY?sqo&ZN!gf>~uo`}ZBVpzdSreJ8Le_FoEgGTt2Cu^XY2&0*%o6-mH zldF;-KcsjfWX7=KPqho!P^3HD;c%sP0-UA|r?o8^y5sh?eX_czqq6&h5`u%@_)n+0 z@c=XWDkqQTfWgL!hA480cl3+u8#uojt< z^f)e#X!8X&r`1prOe|WnA{tIA{|2~uc+}9$T_{dZJGo|15del{fWq!zS>tCmN@OQM zqAyN_`n?l1cSbi#w&e;uDvD(8Dkb6d4w#Qn6|5MxKel0o8DC@7V;9^EERMaE`fiP6 z&3O9*kuXY%_lF$FF~SMs7Lzi|Sd^L_R7%|;ov9|>4k;a7_p&pbDT6%C5^oTuR21?k z^f87k=Zbi~<{Kz?n+Kz~;tl;})Nt&cDOs}My`Ol~)K%4@PK%&y92E07JJXu59sq7{ z{FgK}uOJ5$ie15+4``qRx4Z*>!)9){A{qn{;()FHQ;jsnYbR5iv=>rIV$k?q?Z0xLTh|XMmWQ9=75}Q z5i>Psf;6w7_3}SmJ9U}uzcduEfw-}*>I(rxBuQyaGnaB~5e7-%eNZh%!~N$QUriym zmTXB~jGEL)Mp?o_(`Nez6~Qn{6{YixKKxpVBUj4Wn14T9VP=9UzFeWJZUFoYO)r)? z#`-z_5Mah#h)`;D9m)}vqzjMq+F=ZWDeQk4loOzj_ypVCEYUwUcH&-t3qW3gdX zs@(QjpNdDqw{^TXYZ&qN$WLmZa%P|_JMf@#2Rrw4+?^7+uXMM#AaaGTdXVX|$U@tk za~B?(o~5hO19N|GXN`+X4gm($ z?h`2-VeE4;_`V@&RIK9r{Kb`g;kuQ`f@i$*=KLy7ABH|V(mxw1P#lz*`4=_s*TYrb zSB|4Yt$>#fXO_h$3$$+~`Ai-I71QV2y&9ZY80ku%`F2XD8&3?8EdVK=Z}JQLF4df_ zH>cNTF%B+x(U%%!yEeM;0hxW>?RwhSt?pEGua&l>pM7aA@k@UB;p$DNH053Y@)NwY zemur3lnfm%MGe;!IpnV{%cTfBpX{kAZ`phEh;7EHgrk-mSAM#Elvs!2ZL+Y(Yv3bL z0`=~Of6@(ipD489O@Q{4Go7lXBlth!+6G5xA5Y3+p+fiC<)$Nb`utf6?A$9I&ThW3MhHpJ*t2D{R3CZh)e z2i*D;n$kz|ac_i~P6~_Ia2w3qji=uKZR7Z0aNr92P<)l_lf>w^^$P1qBB*5(S@?By zx|#EZn3XdR|Gzvz7!d~K4?+D9^bf)O5bO`Z{Sf>QA^Z?x3lRp=G!lS`la=NFo!KqY zHPs^7{HGP_hsjo z>v>DT)(*gRaQe#c$+1j*fNhnQT?63d!mPh%;vy{9kGlVgeBScBnaG*xkrxmE@Tg#= zhN>SejmO$MAb8$DnmX*p<^<=kR5u+4KQ~s;HSI2Lrl7L6M=3px)v>#8&_EVEWgG!V+E`|SO%&d{TBF6_sikmNl1tF4HFkd zftvcvM|!LZkzbhExsz7)!m3zZF)OA@TDm%Hy|PYYb$&P0vnCY#u40sN?)gYLMFg%3YQ#y_a2VJh8{GT zn7`A6+ZX*uDf~~sDIHbgDc2jizCuWVMjs#s z26YV1VOLi|VymkrRfH=5M7%66lq@Byuus+vfkgMV9zzO1_Q&3cPrHNgbl9f?`)#!IZCC30s?kCH&(#o=HnREbHh)fiuo@Tj!>b6)~72R8)=TdoS)Im zXi~I>A)Hy1G(?q(O8#B^WTICI({!$esBnJCkV8h2v!VqzQ?}7Fv5zeGcl}8A%t`*j zd}=EZHP9z=sVG33LCi+_{DG&Pv^OhyhyXnOdms`l_TUeKakB};A&M7$Gb2Ft-z+lK zznMxP;+#UP;m!>1A!G4dIS95;!(bUCm;2Z?ROgklxU{rLcr(!PVK27pU^%&a&4(b) zldx+5FN|fczD=p9_>-Lpmqw1!?b*)kRvj3qHI9ad!M}J;Sj`T7A=y$iLpqaW&6rqg z#CVw%o~2mM3*frn%5G$tOj`h|RXwzzpP9Kzh!pd0pu!fSWUwOylym*PlfqyrwrDrS z{G$0rRL?S2r5WurwnA72QTWR?S^=-C3zJd_N2JW0I&1@$Ypsm9xp815HDj)Zc}<$g z3wiuPT|+9|he4~Ek7n~)ZzHW-ZKb2sxtIEf$p{0^gsn{L{3=?k>N$Y7v5iyNad?MR z`n8sw$8ZyRwmMiOl<^g$oTave+vz>kp?b=%>x{sbq385Hb@XQR0eN>7l8|*zNy0Ai zuJTTYQy3DcLQF2nd7z4g)w^sAWOv`L>-p$K>Gg%vUqYyWocx2tg-qL~9bP{nd(m)- zGKYycc}KB!1b+DnyiNcC#Ohq0aF>UEkD{pkQ44S+k#E?O%NDa;N}E8WG0qx#%F_A( z0cvx3S3Ub337A=gWcIPSemA z(Q5FF|Kx&*OYS1R(HO(JN(1%#j*rc=Egl! z^cxLfB!U$~eKOEi6g3YO{+nC`=6l~jU@Lp;)}`ssAj8nsqcN>6@SYt3n$oCcsdkHD z`0~PG{0~l?vv=CMoxXQ4NIJ0vLP!@0a*gXE8Anr*)gFWP+_3U-Tw@i9e(-xl|q>6!)S=W>`)TIGgj z(D4A4wi+~oA@pSDd)}4T39Knx4}%s%hl?3s$8$|^EAMME5@wtJz?ufhES=fxV1kEA zbc;xIhbJD~29c_sIh~sEwvo*wc6R83*X#mJs(J11Rlcw!y%GqXG4?=G1ZW*RJXobb0)A?@Lj zT{YTlf^ZQD1UQ-uYlDiecg@ngSX*B`nW`8j-N?sZ)`a$6nkXT6W@yiw29X(g&Iy}M zmEb8+W^W2!rb%VAFU@i_yo;x)-$jD^EkPBuBPn1(-j8CjooyRk;qYuTv-SphXMei) zKLu)DMMfKFEx8XtoJ$uWdT0@S(bT_hr=G*EzrY=h6uAE)Q=z8ZFe8ZrINAQ+*XpL8 zUL4+to$pM|$w&pzSry575Ey;*O7bOE8x*}w54KMdrx^&(nF)BzVAhE_vI1lKrPaq8HYNU%^Q6%z!jqb*7H9~cNrnnWflm8na^G*NWW zcZJ&1)Kz^z1eYP2?O5dTYPPAZawT3J);cM

MN2 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

Bg>6HWFDtCn}=8N@G4&SZ(a!h zv4Q{Hclob1f$tt~KgGg$*G5{0%2(g%1SBZ`V*!}|ZXhVt_Z>b)vj3^k{oDLhCn^^g zb;txkLX2{{Ad=wfoK5sG+gGe?sdq{#dD7pfm}rs zMkrYf?r*lyzh8^YS}dLpj6Sv@tJ=YbEo~yAP6K5z*xrP_1=6I#C?+-lReBeHp5(1z zaNuTm%aB8J%&H?n^Ezh9UQ*e|=j0x|STb*ql-m2O=FJ~s6x;C3nTA?KB$`C>sVh1r zX6ny3;$&AEDw6O}gW|-s&8wb%~VU8fi@$obcyOSy+)Bnh4aR`(Isu{oD78$&*;~h0jTL6w#{syxf5e zRMB)lQp!g~sTJmp(74h#P(W8%G>1Z8=3U{|6;ia?=hN?{fL1eHiX5kD&MIu8DW(}c zG1co~;`-O@r|SlGYKvJNzhu)D>AT{r%#Ec=F#NhoRddu>P6Q*9V>Ts+T1l>}-G0KD zrJZmgTf?iC7k95bcNT5UAce)QZ7_t zFbu#*^5irWh_zxgGl;goRC2fQ_+DeYwEy5d9Dr46??Aj3CEKTxse81h8lBO00im)bV#E+6C#HgcTRr2`c z74U7swEQns`l)Sk4n9syR4-^iQCQ6|VQLP7L7b?VKX4ZYFVz;Bb<5N!gi_q!X;cp^ z0s#X-@C8;gVI#5$o|DK5sv@TLzKn}}6ZWx4^AEq->L#Pes|Hg#8q%L%NaFK)-jBJFhW6z*y6qyHo zNrdW8W}HOO9po&FEv;^FpYNYa}tNKdnXXs86D{(oM`=J0J;NZ})HqNhTOu-hg+Ov@tmF1zFAgV$*?zl21b2o^J*M!LC|z33CAmItAqUT=fot=Iz&! zLx?`r)fzpAp}jhuYitdHK3+UMVbWKQJ&j^@f-7Ln+wqfLO~xRU8yzG!A`;jLa=1_$ zWKPa@45A*(QwhIeSv31y|5*eckJ55Q{CwZTV6&NC0m6iQhI)Wne7(s8al)8XPP0s1GPtRj8gr+GR&NLH=B64Q7K{I=;1}l*%)>>`PDn*#jmY8BB~Te< zU4>s3=6p-WD2Y<`^gv(66zK;EH791q3I5rmpL8DXl=~*1h_`%Mp!mGeOJE#C&kGK& z=ZF5}87&ExY^i7ON;Z{!;mu{lO? zj|vgu->JoH>`e7qQ+u<`;Ik+TC7sz2=f#s}Sh2vW9ozaiSpm@W?gs z|B3tXSA(q!KGTQ4#**VL7LisJqFwJ&n-rC6_(QX-T^I#McIXAJ_8vDJ$QqO5e3asR zSjg`6COqnnljFU06*@~Ss1QF)BYzBFz`@xlDmSXsNM+X-9qAyaNHpXakqtSm(@;m9 zG(V1=G=R*sY|imT{!!Fmn2psycyP#4R#Tm#zOpTSe!c3$L&t>7sM%GQ6EBNHo?RW0 zSDuxcwG9}R87!zIIS0(H8Qt#tH$J8R()K<4yTaoLDoDAsge@z*`ONmpSg(OS;p8FV zUp-eLU#6^GB8q6EC7I{NS~n##&h1r_PF>Rz%2o|o9R7T#(p+6Hn$XP>i)-dj$a1!7 zSA5iAb#QX)7KG|sW8r3J&QAJ&@9~v~OaaJW9&8S)*Z|e?7~H}}tV}|G3?;=#UPbzU zvuTzuR>v{|M?V9Axq)E(bD_@6&3(GR6&Gd`t|^nZ9hVwa*>ctj=VaNTP}Q zsvJ|-=vssGh1b{%nm8zL6Qk?|40zRjUCq|)z3FXD<}ND)=>naG2Mm=l-Y9z$-@Uv@ zQpZ$yEi}AU6^M>`1f!{TJ)@IG5V%SfJ!3qY4iN4u(i}DceeREu)`d|&U}N<$g)nRN zvcf{%;>KA^Cb0;mm#y)&vj$xTj@I$DePFtnL!*-`Wys{zsliv-I7+zF>2$T;$#b8g zP`JRO&8+>)q23AUW_w7B%v)uH{aL$8 zk6V)d(@Gg|qPdpUl3_~lw({||LAt%dQry(%CZfN)OGZKWQLRgGC0QqCL3Nls@-PR4 z{qh&T8F;wS9L)j!b|4#=20PED;C3<3%Yr0XIXKQbe=lW&K@ZQoN43C z-%D6FG}QL}x&9fKH}UspoU)*bnP9IUUyMyOu;sOPx`(Gt5~(&fBVD~OcXCP(_QLcL zLUhjQ--v_k$n4)xHj3Z)${W;7^>$5t_x%&b!N*0OloLry?FoS&XB^G9)~R_9o=u)h zi_9=*|EIOfoqToT%=Le`JV0x2hu?3X{<@D5LrlAa--F6=<1ubHgh@goxhM(fKL7D( zI$!#M+LuFlyVbO5J&E}^N`N(Ao4l#PCtW6)dXNa{AsQg26*o9-XZ!MHCbsw2ceg5h zdVVhHV#-b3xGlPBm_uDqP~Q;lysPGp~h zdDuQXo^O_C0~~V0lk~5Pxpe^J$Yn=A^`Gur-&AGtaTg82ApYP7Wmd6?tT({9TI{%o*Z(YD}#Y?iw`>$Y8 ze@nq*yibZMz90N-KV?OZ$;cLj$b!Qi#Y0z7{ekeTiReC|TjO~B3wzRyfUB)VxbCn{ z$bp8!2G~sCcYVl^&~5dd8I+hX@52kD_?FBoGU#3K?=p0m6@+vEF>BvvU&tMO+)IpP z!>|2xJ54j6ebv@10;_?s_FbF+t811Qu;^#7&pV`w*g++eZ^emb^`#OFPU+%<$j}f7 zKN!8T3zk1rcmM_rp;F!g;(z)&!_)g^Hs=*`I}JJ${RWlm77>i;5xWQ))Km5yu?!o4 z379y|zynDe%vw;8frdWAgvi_|bVuZ@ND9nX=f9MR#u)u!eFRRc&kQ@0zV`Kcd*k6Q zq}2(vekad=pAUUixwTq)SIc#TlwCX1LWPYjxgbD=%)d#`ovnbWZBu{62bnLgQwFtM zDjx|`T^NvYK~BD0-agNf27UZHBjxJkKF@}r_49Xw!!a(9d|idN?Y5{czXcLLU<3aE zSdkjGG00rHH{c=T7F^<~n84(_l>3U9yQ7RC^0)6Hg83q$4n+4jdukj&<^At#*fo1q zWykeT=&Mno9-R*7xGh#+g*w)^kcDUGYM{ld7k8`L6zO>MuVbX(h(}5LbbR{Ok$d2d zktHx%a>5M)fdyF5BQ7;wTNSTJr0;9Q;3sEgo;lG+0UM)+d-!WI5I!ihZLtL;`_S>V zY4WG?dByJWi(pyBKQZWQsN4re(&j$NP6#Ld?k+3O&L`nin2zli5#BAFj;>iqBhPp6 zBp7eKXaT3oH-{C8J!JNp5vJSP2(}~U{qHHJ(c?gxUrMKEhsa7igwwR}BTUE3+Zo

0}4>ZlLUh1qFOkB3riDioc4lIELB~z2LgIZ)4kvf9O{C;MuzO%o>LDufCll zeKcZGtWLWAD-^o8&DD+t=2WtpoRpbPJ4>0?7rCPJCvY1275!lHU1$J^%N>U5#yn2W zuB$GGYkbEi9_8jQ@{Oy)5FSUZYZ0cR^XNt-W2@G5CjCIS6}ReDtEsMEDzhoE{vrra zv9o{G3hgU<=YJP1a>Lq6;|RmRhUDZ(bD_bI0{$1(g`ciMDm5MQ+B3EnWDGU+7NOyC z&H>T*^~Ajg^tw7sI(8;@^@>?f zqSf&36!Ka7qL-@BaXF!Rm-wKcaNOZfwEsww<4Omjnz+Lw{}g~;s8~kVslt`aGZaP( zeEr7@%}ZV^mUpsFfsQny$53h-%9k=s?U7H9PN@e*1Vy07!F?~{8KrXy4*Hm?{D-?U zrI3?~VW?H3Q`0rQOtxWw)#tD{aJiTUca32{NfRqs)o;; z9fCDwpV5)E{VpIoVZ@QV0&z4X5S6iw`#3(iJ)o!=2PW;vlS~YM#{NoZv~$go(hYSaH9eY>-8XhC`o#4jIOoq=n!KJ>OqvaMAmYDK(V^4R4>KpDaXW6tj{`y zlzlPB*A*(5;FOF4?0{i|F_7|hW#GZ^oyxoxsY~?h@`Kf>C=0N7R3aD&Dt{jA1Fa^# zBPL_<^UEh&osk&$;Oi)zVr-K~lb66OPDLvB&=h1Vldvb_LVuj5-g3=h!ik{on6#D1 zOZZF91;hM3DYG&WC>p$4(~2_r8QaXv&bU#8eO|~6xGGvaS)nWtyrtM8 z*!CLzNWZ|Tz^IhDa-lV0QH?L*Wx-j>m-WM`-YZy!hx%YV+59Pd{)b95V)jHFRJ9e4 zM#~eyU|2Q5<63_tbh3yaS-l`sY_!F|EKNN)SM+`P-Y$8@V}8jE3@KStep_sMl$PFT zc2s)o28yKY&)son0aiKbvCKxE30HZ2(=p`nktpmvz=`-97n}w5Cs)A?e9j`R6$9NH z8tHrs6s8lpZ@MMB(p-YrUcu@?kAai{I)y+sDo9h~D24}pJKGDp28L$gC%Q9YGpdFJRaZ_f^&poWE z)uR6Iz;$(ZbyXQ>8Gm9b1*5-Uc^k`mN4XkXyG$ifoU+_LrRUFhs|m5sxw;ClYtVca=D_B`5#lg+ zi?hdv40b{x3gg7LhYPb+z7ps1(@ScCg4j@>$AUO3YruktBKPYI*yz~D*AuG) z`21s^U8H2=pn$FBQL8sq({hr->r`8T3vE9}cA~f5q-=SEvX_HJ|L!pv4wZS8n>~Rb zvKx~h$~*0d_XAb?zx<8yrfHn+MyWc6}rQe+#+4w0nZ1BIJM9_{z<{e(+Oylh>K z@piLK)ddT>{b})*-@lVSJ^XHupiP+sc1=sOeCsJDavT2Q{6ySWh%fUX5OX zSOI;S7V@!l-+NBfQMWMky%|609ZcLx(Q&v>pmf-lts-n-`oYYen|>_QN_sp5ki6x6 zFUzX!$A_%(tFQl*j8qn17C~Pb_4GVGi4aVLIzWk1-+mA39&bW>=sDycVExy&-19a? zusQp-Li@&h=cBBva>rJ`{ZRakEcPFF2clC3lf>Ap^8+=gRlj8VqpqW#0={V3@P+pj z?fIFT$O)d?&+0s^JL1T4s)7U#7((e@P^*ITUmS5AVuSzTdHwvu8L1~6s$q~@Pne`8 zxjPmr6?&6j%%RQKff(E~gNp2vPO|j;N1WMtcK6y`$BdBWJ2G40QJe|6@BJc4pIxGL zmy&4UGJhIWXmmI)c9bH+)i2fQt-bIHm;Qk z@IWLH6dvg1&8ub8;lxN}`=Xn5fel|!1tIbJ@u{I+^q9L(_>a-{XP+33F_^W<`)azb zTdWZ%vay%7{oIFz=Xoq(Q&83(#QKo?VBRHef59TT3%j{eLi(T@atrO$x@AAbVm64i zj`E6Sm;?8M(qR#?hVR*KX3uOu_&C^$)6*w$)FLt1(`zwt{9CjO-6Sp&E9f?-M!bew zKK=ROI%li4utr&Fm^au^1Y>GJ-&h!svUjZn5e4yE4M*nP76$^Yhg!j)3x};RkhiQT z7FbU4L`-ap^e`8p#gEDtvnCn-&1&z+H*@Q9HS5{9CJic>nCqo~%Rw!9NCu3n{v-Ns zHQaW{sR?QzB2WtrTk`FhX#IuY&@L`Ya8gbMjl5q4Ri|5AgoGWh7Ug~HlH^@*wt1UO z^VaSf&>nX;LrnW?4~+rE&(4|V{NHFq;Qxo6{n8bh&Pq{2p9w-`#60D|+%xiO6_%Pnpc8D2un`LeKlYSL;|ZGh!YuAvHOfMq8OH*M=M~ z&Xdx@1}ZDj${0`c&v({VQ^1{g8Hty9#9hSJ3WAL! zH6v@Wk9kx`%O};NS6*}DdHV${6uf|1kuc;kEHph&eI6D&>m%?aK=OC`GOe(r&@7q# zBPKT;)euER6E;*1gtL<4cO1BvKK#G)#!s0a7^XA7nC?|f=7zU z$ypck={XB?;DN$)o!?QCFPQ9awFY7u89DRVIDyiQ^g;a*7L6LFwM*C#{w8GI(CL-g zOJ4i@SLHZrY4G4}HJ-s<>j2U3THMZ9fzs@sp{3@3G&RWodPQoLt_d?bxfN$lq(w1o z8s>EE!GZ9Xfpaq9mBGGa?4-iP5>Fbdga>7Zd_qlxkp-eaB+ixaIz8MN__llH1~#D> z9q15+m;;>*&XAOl2}}KcJx;MZhV?lA)(UbSRiOi#equwU#@^6EzTtOlY1dzfVHxBk@-B4~IDptE;s6`{?x%Y{SBa%H zU8yQXP`Lz*kW3<7j`=<1*r(&8ar;~NAnJDARUkCWRxs)babwFOfOw4X3z80P9)1xw z#+)pRvC3qIYoVMpCMuJy1^JNtnvFq&q96zswaGjy-D&j9dxdm#EIYg>7bcW4S>;cpaB7aqDK*=;!7(3*?qje3~ny|sM* ziBM!=wyXEyYc=V`Pr85?qWsxR$9?r92xXv{VO-{A9+DcEY`$?dlFmc)-#_KqWbQY5 zM)`&IP#F4VXT;N?zqz~u?5o@N0Lo=hkuR^k*$+UK6is4&&!sk$l?Ana#Y}DYlBdwwkkyeV_Y+n4NkQ&FeS#0Q%@M8#JM*_n2q$-eYxSu0({I@VfP~^Ce!Ernle*Xo7OSO84-x66*>t2Su+rfn(DB8P`sTwh1XRoa#vx)hrZYT8kqZ(< z{wS^%3?x|vzVmL%Z=|VspH3@#KZcQI8}o&8AB0WK#F1S+|6@b)A1}u3B;TS12L(L8 zn7=c1+jmiSJ+`I|1(8+EGI;l>WbPSl(}`D`-9T=}f?>LVRo}6AqO5$CWpLp`l@mOY zCr`L3k*7#Sa}Zp2`_*0|haZ(^Vf!Dpof7YV?ozCGVq^zQQuRX+U8T1-C{LIr3r!#y z$FFdoP?IKq2XE9vk;yDIR(W|tWcSv@Ph}-Jy?@G9%R$vb+AW)uxxajC=%02SLe>?~ zJdIADSUAZA@;61-nQImce!p66kQwDfHD%eg?ZNTQ-Q4PKqg2H`sy0c;Xc<}&zNYnB zDj4Lo`z`3?G1VUhm+wdNo zj9_seAP(`wfQE+NqI3CE7_p{GH4l&zUI~m?-MJuu)p5BV-+|=Y9DNT-1~+>=UZpb2 z=gXp$HUabLl;1DP-@g8wkTG0IWLde6+c@qVi6^}>CHiN(-k;q%1@mvVuK3L7^~ zC(~mUQDJ9GAFyuYCVKw3!T+>RLF z;Q3#<@(&DU;kF4S(*wsakWoZRZuPL#LHYZSB;9)>vG=~KMpnAWtL0)b(63UW<|FOS z4yAU*>cjb}3x(eUJbx26_Ap7(Zh6@dTE{I6g5uYp&uxr3R*M|i;omr!3i%5d`nG2G zV+zw^#j?PToCH=oNPtDw_eWzf`z7iJul5Wye+zA*6r&Lw$cQTV^R;iC{12MlZ5sZn z)n`oME#5|%O?F$Ne7)DD@j7{I!JMWVMm76u0XXPM7$ zorI#u@epnZoS;Oyyk0zN#L|FJMTq$sxkyBnzUD64+Nz8V?0jE`L)Mtnwrr zgI7?{+4_PwU2w2tMiei0V68b#@U|pVvBDrkI{4CppuU%`M55_y;ln+^YGF~TG2;9} z)bK>Rh#ajUL;`R&)K~fj`w`QjG>t>^#6DY5V%I?b`7Fd(fFA*3Y@M?(>G3&>)w#&I zAHY%4!_$sfBQ}75)AB0|ErB@C6emT|S3cF@xDEuZFxBus%sSek`F<#PL!I9Ww7_i; zjr#WdK+Vt+4?)#Pn`sh6@Q|R-W=1L0+&5VJD_X&NW&)(hck?@Zp+gD-g0oxL@)CG* zNu*7K!~&ee$uXSg88OJ|!5|1V9$Y)-OajOo4q1*7)B|aD6yt|@=)kCy1-!qNoAQHz zMjbkmwx3B4BV(;G6_uTm^?5{SD2z59?##$tfz*_l$@V5~tzv3mU4h`N6A}(3T3C50 zXH7$L4=_6dLdm!1oS*(ulTs!)d?#;c{)*B8BGZC23_yd$xS~vA06Ds0R&2pM2x@K7 zaJNVVffscnQXZ_U=5@p(sW5gjxkdL(h^{qdtb@-g3t=fcehU(w{FaWI_UdrA9qIl| z1H@MB(cX3II6@MUjwwm4I9!HfFSP~4Gl3u(0bh=-Vq==Vb#8Vg#Lwhiu$684xlu zC zmLx8h!R>e+E)t4ZhO#z@LWR0X*PIsfUd#5G zv6h!9k$(J8SiQw|r0vHu{eC+5Yg7s1y`DF1O>F0MlLt|x+Uc{~n;Y#DAlcn6h596l z{IEdA{Y`0iNWhKE9PSYYM-cO|5wB6|ZTNQYAn`ETrOkQ_S~_jh$P+0>x7Ui+nMfZd z2YX>jemC#p;&-HR&5P$okBQp$aN%2AT&Dfqt+-e)m<6Mzi82+Q{`Vn^Gw{cjq{NyQ zJ?D7*!Q;@J;GI+-ChI{4z*7+{{l2ao2o-1y=7McZxy%+zZ)(hg3Y?F!kudHT86(B- zNAiijdK4^5Fc!4ZVPYY|&4qf5G_`kWKLoqXosv7ad`s|KBp2KH8ghQnBIFo6Do$0) z`3b{D_RA|P=Gno3HzlUyr&Ch%uwTLb7n9;J;SCl;bJx=DQ%h3^0JVczTf8Y80uDw~ z@Gc95vV;9v<61jDc+e}87=Kpn)4?De_$xLGo6Wyt32^(6mzfYy5k4a3q^S9RJ!i~mq2 zNxoq7Z(4h>KPHV`9ZsR13jViM%k0`e6w&Vi&)#G3Qg}RL@V+;BP@;{F2Pc7KvM2Wr zN9-(if+e4Td!dW))edUdJqJH)iM$cs@C&|c4?oBHt3dHp1b&W(QsXbLQ>FO>YX_bc zx7Wl24SpZw>QH?RV2>aerH8XRCrFg{HbD81HT?KYv5Lu8q>eDHH5LIb=!+N?(IAQv zn1|}&i)q1CLEh?u*(Rd1&L-r;A=%`)_%k^gtosPXSJ*zM@yl9=)dQdUv&vWjYl3J~&-#JR3_7f2pDbiil{QdRJ zr6hjrPp@8U^*1)T(ILqDngFysbUPf?Ox* zy~JSu$E3tC$8M>1>~mk7(T3g<#N0)VnRYdZ$oL34pvV6<-^AJAqXM_cpide<*$$oj z`=F+4EPbY%1)=zWa6vDmcBts@9!&*!;f+Xg5 zV;V|JIDeAJr5<6pPBb0H{CdKfG(+Y))9OAEp`9GK$V4irVHg{iA`==dxN(~ZHMble zh#ZSE_bRbT)Ekz(A$fxVAl@PeiV@Lj4^g)U)9WHM#{uW&?eor0e1%CFP|I|!#L-?eeF3l2C0FN8zco#`Cs+6v?BTtvw z@+9vSr4<{@RocZnmZhGJ^8E)gucGUmToA>@2<(Q0YAkjhhAcUl^cO7TcXUC`awRb= zB<-INNEAOm1F?C`ZZHO7E^Lejv9@+!w!xHNekd46>cy=YBNW!arqTzQ)%9q`pY54P z!q};XcN(M6pWtIONMpr7nTV)|-oVbInTq4cXj7TlVZ$KS$vD~5#JQbV*IyuG{=$h* z6hd=}yNOfAWsxpq=dBY|bs0!N(+FYwVk9`BPkbp_03041I{~lHqHl6z@)-4Z{i(qF z!KCQ>ZJKC|-nBuAFwL{!(CUG=9RdMRMfJyxq&ZUX)@=Q@(UB?vLUci>Qg|_(=ABpc z>41|UW$@lR66(n}09$c)WfHF7!A}og?i}vh8oZB^Frp^mCiGlro}mscgWBsx*S5A^ z0pUvquzA7+IQc87UqgM+OtfA9*?iC`K`e5*?_5TB4Krl0d5GNjq$XO+l%ss2p|pZF z&GbGed1D&6a(#SQ&vN1s2R;uqavQxx7l9LS?<7+NXwl|{=Dl}H^f-mlHEipIgrBSe zESY*y#5FN-_URyEXuD;^&KQ7e{et3L_zf69$GnUz6Xd469}X&FyEVZwW>A1$f4zq! zW=V04h(AmJM!YpY4<;go(kr4}R{BKZ`F{(rwt={RdZ{toc}6EGN(u%jZerrPO{Y`i%r2 zn`>pBi}@m&lu@!0)U_XfDCWU8Px}-}ie6IQv(#+4$B*hle)NA3iS9eB>X8KNtV;h&vo0jdz_mN+GzP-cIIJ5ZvzLhedLs zCoF{*xr%ntNJ9qa%fa>lLAJelOympLj(w`@kr^_4^xDQ!dhI78d3Dqw^6mGicDjh9 z?p|!{9F3xGJt(@1jK}+>p)6CM2=f{sN_aNIaeM$JFKJ*I)iJ?L`n#@Ibs7q)a+CCg zhXa^f=aZbAxw9-yDdHY%uDw4Z+XLstG}?3$FrQSz!5$sDQnIHFDPGb3s9FM0U-I)_ zGP>g9-iw{GJ^4-sj{AktxxF;m3X-7Ov${>-zBBC|J9qs%9P59xNiz?X)&gzD4y@f_;d=UiLV>WFV?JGuvU zR@D4UTeGVjHFsNNOBE;@mKF;@ckpIs#Ka6Kyy^#8A^9mxvE1$${SgyTG7wr9Cd{bk6D)~k;DRiE2U0C3I&dO z-UKv@NfQ}TlRgRj(j$D$Gq!8fNRJKa@^4*|eaK4Mz?=@fnF~E~z4xi_?v7zU$ihYr z9TOMNuuljM>T0Tu4XU%eP|iPz=e^RBUG%`mwkAV7oVp$R>dPUrF#Yt@M4LP^%it3i zQCjWbsX)^jn_5oo)Td^BHSL|Da7#_d zK!~@Yo|G>qEw|D}tNB7elPK7<`r}t;$;z{=CXKF5V!3{~B}}}2ot7OZ!3b;&kdE}# zY})S1P|uY^kj#_#h7=w_8HqF;+xs57_{IAVo2MlZN#(a@8-5v{%GqbN z>R49qe;m$YGK8Lp!3nUYLE;KjS+F!HgBr$?@}XX6J&cyS1`q^9zO-Tk3I~Y%y=XNU z)MzqLEf7Ik#>CYOUwJCGig5?ZfzfYaSo6hveTc>Ol=hr{&K9$9+73?v!Y`t}AaoaV zVw7P@P!XR_r0LBw$V^ZR-MEM; z?IF?@L)lO*W~8Qil$qN?S*z%rA{w@WFWrIH;+-C-N)QXaGoWoVuSg*6v2rMgwt~PM z_~op@3GF*g4k*xUf`pjO(r!2x)QH#zbSu3nU}cRW^^oV(A_%pWcWdbKERC$uUcd3)e`(TRi6sOe=ZaPDwHztF%{BGY1`cDdGD z1g)0xWKw^u7$P$2V;R2$?-^$jviz-V%oBdN;50j9{u`4%xmAjBAU|hJK-2@v6kPF> zqmPX+E!8C60I6Kwp?;X%=l~X@JiCRzY)0H`Y4*H71jmy|Js<)J_)JBQ=3aA}UXJs- zVF=f>T&hn;bxG11@^^wV3uawpwrS9mDdyLaVhD1@5n9X%Y+-nxrQbW!evdO>jt3xBg5es%wZvFU=owjrBF!5P`ag>)MoawujKfUJS{elN2x)1`v#+~k zhmKf^rp#>~htJ^T2k42DDvm89EznW@NOk87vb8tkEU1rM_LufS#1_LD_?0yhy7Q>A$3@B6N88euQ*db@}$rlP{ zaLNAN10NF2V+bqT6dM_^Z5-c3*9+4l{-8PkrTe#@BL%1;4=TlvL6uGUHY}^!o3ah- zgHs#uvtB!YxTRd9s|4pnlb-c^_dR1Zi-jYiY*6JaB6m=TdLk3!xLFU5#)qZ^T=0uD z2jfw*5%B(Z65!^(_9AF40p4Dp&p+xo7pCBj@2m+nM4L`ux$)BqJMaF!^0SX^?GA~6 z4DRz$39=u}a%0=iqUVv}{ZG(t9y4Fn>bfTsdfe|U^W?PJ4Z$h(U7+l7d{_}fFwV!y zkF{yTfx55&;jZJfc$%VHgtwBPI6%23osyy;)_(P8@Kpqg|K*SJh1AY zlzOTv*}S%^+IN9G|JV`s#mz7Kyi@d!C0-IGpHE;{Ly}B)C?B%rwf>>lgmOppBzf zX0gs|8P!0u;4{Vs+u>pfEl0+NvZ75w9DGohGOy%4&=3U~*0EqXuSxXaOcl)=V>8C3j=tHC#7vr?VI1N_Cn%u!T) zHl7t@RUz`dsdpv!R81%Qib7z?SGTS^Tv7B8$w-_HhX{S9B~-&OCk!}t9a#YZFG4iU#5X`W`&d7v0MIq z+8Ozt^UCErk?(TI5}CSM>+$0qxb6MHre=5g$LhgJR7d!4xJ17=$$-gw+r|yO;|s?3 zFFCXcXiHT+PC<5j8zR7k!K(iu9uwMpM;P0i*@ByATcp~HRAa-_sx#cq*e#cmol&sm zD}m)T3S%=`OX*!wE(Ph7cX#7F>?%!ryXDDBhGB6YjNw!sXl(};r2jckzM?JQc?|wH#(>~V3zYrOqSyb$xtWr#lzQ5P5^|s$ zszsgzjgYuHJRGU=eJe@#F1LE_RS)R6sD-<){TxM~he%HEGwP&lhW`&$XAx9auy$?Sogl%T;0X}i2_D?tgS*?=xCRM<;O_434#C~sEgalA zANRkL|4zDkum`)U2feD-dY`3kKueXZdn`uloQ(!1+SVHRoYE1#nm;Xyg=R(|j(g=y zATdPTp|EY*7@O<4UsXXEU_M7TmZ9unOo!lHooW;8V6=d=*}aCWz-~-OgN)LV40GUj zJ%|u&4LLAcFE(TVj#I zJSdU_k44&B%(AhRCEdCgsX)f{6hgPE@_hE| zFfOg6)f{v|;u!=6TlmfPU+o%T^qY3w1mqxc4hD^?lzDM%s9IJD3ZJqtI?Q-^`5h5>*`pte7S|cA`E{n<~{|MQc^_7y*JAY#^RW;vfd(KZE1$cw^%n=?IAMa=(hZg zjn5}3J}YbI%Be!16dgeNMm!By*F0mLK=^!hgYlgwu6)73Z{IYOCCU@(jO!$a;D0=V#M%dZLN(LsW6+$U zC-5V`%@{=!ux+b3j#-G$q)3pY`Z8*d#C)u;wxGXY%G}J2&dl z_A5J#cQ&_f{{*^W7aSXtr>CJ#xBlh2;1=EL#uX!X=fJG(g=kIO&D*%i|e0V<5DLDt%u~- zvw~9#fxc-;rCk(RW0yuklVzS7dra3Z--JS%LeDl|n(zx6D{}xg;2IZFFT(F}+|j_{ z>(Ep3x5MOKgg-=e8unai;Wy$6wx4ifUb~p4-^JIsg$mQ;d9s;6y^8=(9<|ASgYdB0 zLs9b)(i>i!SXo7Wg1HajK9m_gn$Zzd$3$Np#Oa?4Osi%|&R3}1H994+`ejG7RFo!sMA620?Zt0!R=7&j8D(}90}1N_$;RFB0x^U}iWY*ItA z6itJcv~g)+NPAAyyM><0M`D!!k_tgNacNKlD59c5LQMWAJV7V9bu1^k-~8cURMRD0 z3$krS-+lojK5!XPe6d{AZ|(n-pEh*UByMy&$X+jwHkb6jk-I;6<$yxC@7-Ib=c^eE z;`&BZSg*-4fewee7;to~W_;>Qfp^zP#fLC$7bY-Z&kp1er&Zwq9446Vc+1 z?E^*R-xB{r#4J~ttPrSA7_+d@j=ot71Ta&H&EH^(0js8umuc4qY%qkkEwIR*nG~pj z$FF(UcyE(F>w$*o0km?^Yky<#{?t9hA(Zkx}gzk3Ulu zkjTDgHd19n43~D z6koxA_8jH5qeS|$XvCz6I?sxAz*5Qcy3LkSefX?T)6$p(x0Ym*HM7I$1p7xby|rZP zVdkJ?90VC&8MCdwrD%G5Wea^D%9wd=Yto`ZYyP4{Y1IXd6KRMjm4_uhM1PlehM6Z> zV$hhg)-u+#L1h9cYy|@Gs6G?d^gHbR#5+s;P_s9N0-N3~Tf(bQeG0cnjgN@=3%?5* zNyD?U@Po!ug-9S?ZWSR*;>_L(b)bT;ycFDnU1lGdg>GzW*gk8F;7O8?l`)&vw5T{I zd3=9wZ4F~zZJl)=dz*Hsxz=wvt--WC{05ReXaeTzbbnOfkB@DB^%!-k)L4E&PaKNZ zx14ZpC|uMSH1Z$DM&&RKYCOcn3?g+XbHO*;EMqnzR0`15y~vuFOzB8-rApk$3MRA~ z!8uOfOOvX_nB5!+%Rg0x36|I6l>g16l~nUQ1;hKK9~m>2vh|3Z!3VjZ`n+XyqT|e% zrt2pB<|FiEIxs9cMi!WbE=z-n?DH>vJTx2J0`O>arv<$%siAXor4HW4Mh^6462^ zdK5nB4(XP>xkN;w2ehqH#3}r?5*))M4qC@t?E{fxz@;Qd0hC2PmUR%f8IwAu15d8D zSMn4y>^Ed&aS&ChC{0WvS1N;brWNIHxl5F3CM0bepmMZcN65OYH z^N1^=fz-uplmqDWO>d(4!*8+9^bv`%e~lOml%b3ib5b&VtuRU8FXUoU!+djwl&?<= zty)4kXRkhK78fCT<<~I6e%<=;Qw0vK811Dx*W8lu&(|gU4+Vs_lQC43x7oV8a1q(p z)`oo|&xEMb*~P>1rD$7VBgzt+1)B=!h!3(yqTKF?UY}Ry}QAo{*rw- z>IpyLA|mx^SWPJ5gFgkEBz#eey^8xDrL`12BEwt*lLW9szLY^8UMIWWe*DPziWUFc z{Ry~$yuIEFcU?k3t&-<86)8N zQfd&-cI&#_eX6f`%I|5Dr6;h>(vdm7u?xt#@m!M`OjveZE)q05>`}f_k2bL}|rVyHWXn+iu|r zKgV<;0JcG!6~2Pcs2%zW%R6~|)21PcHL9x!Sw22O(Eh?D_E5w7-y5Mt7>rh-906F* z#GEN8^Q4>+tJV=PLXG0HAy$#A_XbUPXF;QkQn9~1PCIn7tmDF>Iw)14EbYB~#}6SH zy4oHlxcAZe(j7W3@A0E-!0fyqxE0zk?T3r78$O}wPFvd9)<2jdw z@V_ep3_<7}cfp2Z7>b;4Ua(UYgQ)(_S?r!v-R4gTwLwq?T`GDaU?x&e%4rywr>Rkd zKv&}1$q&nlY1;M;@_j!NsdO?yCQEKacOQ|<))HC6H9l@=R}aStm0jSDX#xRjH=}~N%L>Gyn-|z+d()3)eNTHpitpWkyhsyTQCO*6t;2ObOXK1tyvTTATBa~kDepLr zabpL=<24V#_Bo+3#=bMOmM}cl-SHgx@g-ya*Edg03L=hUN zd?y%zjo+UMMwJVS!z9Wc3L(r2g6vrFTWl!lZW1bZo%RBpCtNAF0Kf>}h?)g$+Pw*0 zj^5ngvKR$qaZqxBzkuY{yLb1;(;hIr$IkH#^M!&ipC-s7$-wZCXZyFQR~2qBXO=LW z;FSfG;)V9)O_ajP(|6(ia}%IS_pYCQ?2t(;W&618^3SdzYUbs#{R>>j;d9!>;V4YE z^=w=FVta?^++G$sU|Az@dv?J$LWk^S%(=zvH+4BD6jeO75GoAz3hD3Gg2u`t6dXMDULF#1`#Xb4@X;MZyQ+krNN!{|XIm7;FiEHC+h4F>}suniIDtPCuCzLFT(ocTU^4C=vo{)>ba*4QRZ z=FdrWgZmYR<`f=hl{Nb|$uE&0^f#*(@E#`ObD{|=UuF>13J*D9?sKA)X`&;Jswdkv zZKIk7N$3}8mv~BjBtYYX)OQ(es391xKdIl%s_>YvDlPnmxi**>jP;}p8R$+C$_&iN zRL1`JP5ia@yg`Fs3hNAQSqiJimOPs+mC2qZvUkBKW9_2;k-uSIR;?Clipn&}s*6&F zZ;pDwYiq?20sYtre+)&yJSE!-$JAat*n8u{9EYsEt=j` z7<^*V^iUlFD^w^dx|r*1i+q2S_d=azxrE=`jl$y9VmqEpaqSas=us}pEC6$9%1}! zSbkYVX>7-i+#=chc(#u2Wmtq`Ki;$?aV=5YFL0F?<9O? zyXuaXa_djD+q@On>Nk|r%H^xQ}xceI*y zJqDIWsbM85TPf6tyxb6cK^rlWvdH00Ddp*!;trAYa7Ldx6l{LR!1y}HP(<2yvurC- zAYpx~O$#4Wt;SK`#|sm-fq*5XSc6w9^5Kli5&B#G+E;}f+G|}PTWyQ&@oS^3#P8B@AzJ24RjcoK|6;Q9J!WVNuzV%!h9$

---pSRXu{Z4*Gej5UoxAkjDHD6f-Cwad!8Fy1hL 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

R11+ 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 M@Az>W;`x352c(5N^#A|> diff --git a/spec/core_spec.tex b/spec/core_spec.tex index 93adc50..b6454a2 100644 --- a/spec/core_spec.tex +++ b/spec/core_spec.tex @@ -5713,10 +5713,16 @@ pub enum OperationKind { DeleteRegion(DeleteRegionOp), InsertStaffInstance(InsertStaffInstanceOp), DeleteStaffInstance(DeleteStaffInstanceOp), + InsertStaff(InsertStaffOp), + + // Metric-model operations + SetTimeSignature(SetTimeSignatureOp), + SetTempoSegment(SetTempoSegmentOp), // Layout-semantic operations SetUserSystemBreak(SetUserSystemBreakOp), SetUserPageBreak(SetUserPageBreakOp), + SetStaffLayout(SetStaffLayoutOp), // Transaction declaration. Carries metadata; member primitives // reference the transaction by id in their envelopes. @@ -14553,6 +14559,25 @@ layouts they own versus inherit: closing the representational gap that blocked the logical-stage override projection §Engraving Overrides requires. \\ + \today & Phase-3 first tranche (casting-off + catalog) & + Companion movements, no core-spec byte or architecture change. The + Operation Catalog (0.4.0 $\rightarrow$ 0.5.0) gains the Phase-3 + schema-fill tranche --- \texttt{CreateStaff} (set-union global-staff + mint, plus a staff-liveness precondition on + \texttt{CreateStaffInstance}), \texttt{SetTimeSignature} and + \texttt{SetTempoSegment} (LWW structural overwrites beneath the + whole-grid \texttt{SetMetricGrid}), \texttt{SetStaffLayout} (LWW + advisory) --- and a rewritten \sectionsc{UndoTransaction}: + \texttt{StrictInverse}/\texttt{BestEffort} now perform + \emph{value restoration} for overwrite primitives via + canonical-order write chains (delete resurrection, Transpose + inversion, and Cascade closure stay deferred, P11-C8 narrowed). + The Binary Format companion (0.1.0 $\rightarrow$ 0.2.0) appends + the corresponding wire discriminants. This document's + \texttt{OperationKind} listing gains the four kinds. The create + score/canvas slots remain deliberately unavailable pending an + addressable root model (P12-K8). + \\ \bottomrule \end{longtable} diff --git a/spec/operation_catalog.pdf b/spec/operation_catalog.pdf index 430e3a6eb34af0061668ac5688abe01017edf10e..93306cee11fc163a1b7ec7336a61814ae694b987 100644 GIT binary patch delta 85285 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 IMNa}o3bJZ;x&QzG delta 74084 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 z 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 z%0A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 \}} sets, replaces, or (\texttt{None}) +removes the single \texttt{MeterChange} at the anchor's resolved musical +position in the region's default metric grid, carrying the full +\texttt{TimeSignature} value (v1); \texttt{SetTempoSegmentOp \{ region: +Option, start: TimeAnchor, segment: Option \}} sets, +replaces, or removes the single tempo segment starting at the resolved +position, in the score-level tempo map (\texttt{region: None}) or the region's +local map (\texttt{Some}; a set on a region with no local map creates one). + +\textbf{Canonical encoding.} Time signature: \texttt{region}, the +length-framed \texttt{anchor}, then an \texttt{Option} discriminant and (when +present) the length-framed \texttt{time\_signature} value. Tempo segment: an +\texttt{Option} discriminant and (when present) \texttt{region}, then the +length-framed \texttt{start}, then an \texttt{Option} discriminant and (when +present) the length-framed \texttt{segment}. + +\textbf{Reduction rule.} Last-writer-wins structural overwrites keyed by +\texttt{(region, resolved position)} (time signature) and \texttt{(scope, +resolved start)} (tempo segment). A carried \texttt{TimeSignature} is minted +set-union under the same discipline as \texttt{CreateStaff}: fresh id mints; +byte-identical re-carry is idempotent; a differing value under a live id is a +precondition no-op. The time-signature value's beat-group sum is validated at +construction and again at decode, so a malformed value never reaches +reduction. A tempo-segment write preconditions that the \emph{resulting} map +is well-formed (segments ordered and non-overlapping; a non-constant shape +carries its end data; the carried segment's own start equals the operation's +\texttt{start} key) --- a write that would malform the map is refused as a +precondition no-op (\texttt{TempoMapMalformed}). Graph-aware reduction applies +the meter change to \texttt{default\_metric\_grid.meter\_sequence} and the +segment to the scoped tempo map. + +\textbf{Conflict cases.} Two concurrent differing writes of one key produce a +\texttt{StructuralFieldCollision} on the field \texttt{meter\_sequence} or +\texttt{tempo\_segments} respectively, with the standard winner/loser +recording; identical concurrent writes reduce idempotently. + +\textbf{Undo semantics.} Value-restoring per Section~\ref{sec:k0:undo}: undo +restores the key's chain-predecessor value (or its absence). + +\textbf{Re-anchoring.} An event-anchored \texttt{anchor}/\texttt{start} whose +event is later tombstoned degrades by the framework's anchor rules; the +overwrite keys on the \emph{resolved} position, so the recorded change +survives its anchor. + +\begin{openquestion} +\textbf{P12-C5.} A mid-region meter change authored by +\texttt{SetTimeSignature} reduces cleanly and materialises into the grid, but +the notational-decomposition pre-pass currently honours only a region's +\emph{first} governing meter (P12-H4's single-meter simplification), so the +derived notation ignores the change until multi-meter decomposition lands. +The reduction-level semantics are pinned here; the derived-annotation gap is +P12-H4's. +\end{openquestion} + +\section{SetStaffLayout} +\label{sec:k0:set-staff-layout} + +\textbf{Payload schema.} \texttt{SetStaffLayoutOp \{ staff\_instance: +StaffInstanceId, instrument\_override: Option, +staff\_lines\_override: Option, visible: bool \}} --- +the non-break layout advisories with a graph home: the staff instance's three +inline advisory fields, overwritten as a unit. + +\textbf{Canonical encoding.} \texttt{staff\_instance}, an \texttt{Option} +discriminant and (when present) \texttt{instrument\_override}, an +\texttt{Option} discriminant and (when present) the length-framed +\texttt{staff\_lines\_override}, then the boolean. + +\textbf{Reduction rule.} A last-writer-wins \emph{advisory} overwrite keyed by +\texttt{staff\_instance}. Preconditions: the staff instance is live; a present +\texttt{instrument\_override} resolves to a live instrument under graph-aware +reduction. The richer engraving-override vocabulary (stem direction, notehead +shape, custom positions) has no durable graph home yet and remains projected +layout state --- extending this primitive to cover it is staged with the +data-model expansion. + +\textbf{Conflict cases.} None (LWW advisory). + +\textbf{Undo semantics.} Value-restoring per Section~\ref{sec:k0:undo}. + +\textbf{Re-anchoring.} If the staff instance is tombstoned, the overwrite is a +no-op (\texttt{TargetTombstoned}). + \section{DeclareTransaction} \label{sec:k0:declare-transaction} @@ -911,12 +1039,39 @@ policy: UndoPolicy \}}, with \texttt{UndoPolicy} one of \texttt{StrictInverse}, \texttt{BestEffort}, \texttt{Cascade}. Value-complete. \textbf{Reduction rule.} A forward compensating edit computed against the -materialised state at the undo's canonical position (never literal time travel). -The prototype models the compensation as tombstoning the objects the target -transaction minted: \texttt{StrictInverse} conflicts (\texttt{TombstonedTarget}) -if any minted object was already tombstoned; \texttt{BestEffort} tombstones the -survivors; \texttt{Cascade} is \texttt{StrictInverse} over the same set -(dependent-closure undo is a Phase-3 refinement, P11-C8). +materialised state at the undo's canonical position (never literal time +travel). The compensation has two parts. + +\emph{Minted-object tombstoning} (as before): every object the target +transaction minted is tombstoned. \texttt{StrictInverse} conflicts +(\texttt{TombstonedTarget}) if any minted object was already tombstoned; +\texttt{BestEffort} tombstones the survivors. + +\emph{Value restoration} (this revision): for every last-writer-wins overwrite +the target transaction performed --- event and identified-pitch modification, +respelling, cross-cutting modification, metadata, metric grid, meter change, +tempo segment, staff layout, and the user break advisories --- the reducer +maintains, per overwritten key, the \emph{canonical-order write chain} of +(writer, value) pairs. Undoing the transaction restores each written key to +its chain-predecessor value (or its absence, where the transaction introduced +the first value), \emph{provided the transaction's write is still the key's +last writer}. Because the chain is keyed by canonical order, the restored +value is a pure function of the operation set: permutation-invariant by +construction. When a causally-later or canonically-later write has +superseded the key, \texttt{StrictInverse} refuses the whole undo with a +\texttt{TransactionConflict} conflict naming the undo and the superseding +writer; \texttt{BestEffort} restores the still-last-written keys and skips +the superseded ones. Restorations are expressed in the effect status (a fully +clean compensation is \texttt{Applied}; a mixed one is +\texttt{AppliedWithRepair} carrying only the tombstone repairs) --- no new +repair vocabulary. + +\emph{Still deferred} (P11-C8, narrowed): re-introducing content tombstoned by +\emph{delete} primitives (a deterministic resurrection needs a system-derived +identifier derivation the ratified closed tag set does not yet include); +\texttt{Transpose} inversion (interval algebra, P12-K2); and +\texttt{Cascade}'s dependent-closure computation --- \texttt{Cascade} remains +\texttt{StrictInverse} over the same set. % =========================================================================== \chapter{v0 \texorpdfstring{$\rightarrow$}{->} v1 Payload Migration} @@ -987,21 +1142,26 @@ a fresh design. structural metric grid, advisory page break). \end{description} -\section*{Remaining framework slots (Phase 3 --- unavailable, MUST reject)} +\section*{Implemented in the Phase-3 first tranche (now in Chapter~\ref{ch:k0})} \begin{description} - \item[Create score / canvas / staff] - The remaining structural mints (the document root, the canvas, and global - staves) the Phase-2 slice does not exercise. Discipline: set-union creation. - \item[Set time signature / tempo segment] - The finer-grained metric-model overwrites beneath the whole-grid - \texttt{SetMetricGrid} (Section~\ref{sec:k0:score-settings}): a single meter - change or tempo segment rather than the region's entire grid. Discipline: - last-writer-wins structural overwrite. - \item[Set layout] - The non-break layout advisories (the page/system-break advisories themselves - are implemented --- Sections~\ref{sec:k0:set-user-system-break} and - \ref{sec:k0:score-settings}). Discipline: LWW advisory. + \item[Create staff; set time signature / tempo segment; set layout] + Sections~\ref{sec:k0:create-staff}, \ref{sec:k0:meter-tempo}, and + \ref{sec:k0:set-staff-layout}. The disciplines are as drafted: set-union + creation, LWW structural overwrite, and LWW advisory respectively. +\end{description} + +\section*{Remaining framework slots (unavailable, MUST reject)} + +\begin{description} + \item[Create score / canvas] + The document root and the canvas are \emph{inline singletons}, not + id-addressed objects: \texttt{TypedObjectId} has no Canvas kind, and the + root is never op-minted --- genesis today is the empty-document + constructor plus bundle creation, outside the operation set. Turning these + into operations requires an addressable root/canvas object model (a + graph-model decision for G, filed as a Pass-12 row), so the slots remain + deliberately unavailable rather than force-designed. \end{description} \begin{nongoal}