From 8720d95d98f5e0bbf1cefc64ac18c10e4806a097 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 07:43:35 +0200 Subject: [PATCH 01/21] =?UTF-8?q?=F0=9F=90=9B=20fix(crop):=20apply=20pixel?= =?UTF-8?q?=20aspect=20at=20every=20rotation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - `_orientation_transform` built its viewport with the raw source width for rotation 0 and 180 and applied `pixel_aspect` only in the 90/270 branch, while `MediaTransform.oriented_display_size` applies it to the width for 0 and 180. `MediaTransform.scale` then fitted against a box the mapping did not use, so `oriented_rect_to_source_rect` returned a rectangle outside the frame: the oriented `CropSpec(8, 0, 8, 8)` on a 16x8 source at pixel aspect 2 mapped to `x=8 y=-4 w=8 h=16`, twice the height of an 8 px frame and starting above it. Six of sixteen rotation/pixel-aspect combinations were wrong, every one of them a 0 or 180 rotation with a pixel aspect other than 1 — so the crop rectangle the user drags sat somewhere other than the region that was cut on an anamorphic source without rotation. - The viewport keeps the oriented display axes from `MediaTransform.oriented_display_size` but rounds the pixel-aspect width with the decoder's exact rule. Pixel aspect 1 is unchanged, which is what the existing crop, staging and controller tests pin. - Fractional display widths now use the decoder's round-half-up extent, so a 720x480 source at pixel aspect 32/27 maps against 853 decoded pixels rather than an 853.3333-pixel canvas. - 🧪 Tests: - Two matrices over rotation {0, 90, 180, 270} and pixel aspect {1.0, 2.0, 1.5, 0.75} in `tests/core/test_crop.py`: the mapped rectangle stays inside the source frame and round-trips back through the display geometry, and `oriented_point_from_widget` round-trips through `build_crop_geometry`. Twelve of the new cases fail without the fix. The existing rotation-270/pixel-aspect-2 case is one of the ten combinations that already passed, which is why the gap survived. - A four-rotation fractional-aspect matrix asserts the viewport against `_display_dimensions` itself rather than a written-out 853, so it fails if either side's rounding drifts from the other. - 🔧 Guardrails: third consecutive `fix:` touching `core/crop.py`, agreed with the maintainer rather than taken silently. It is not a hardening spiral: `a296a3b` bounded `fit_crop_aspect`, `cc9ec01` changed `clamp_crop`, and this changes `_orientation_transform` — three independent defects in three functions, and this one removes the duplicated viewport expression instead of adding a guard. The round-half-up rule does remain in two layers, because `core` may not import `jobs`; the fractional-aspect test is what holds the two copies together. Trigger: measured `oriented_rect_to_source_rect` over a synthetic 16x8 source at pixel aspect 2, rotation 0 — it returned a source rectangle at y=-4 with height 16; a 720x480 source at pixel aspect 32/27 produced a decoded width of 853 while the canvas extent was 853.3333. Refs #164 --- src/matteloop/core/crop.py | 24 +++++++--- tests/core/test_crop.py | 89 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 108 insertions(+), 5 deletions(-) diff --git a/src/matteloop/core/crop.py b/src/matteloop/core/crop.py index 8b4d671..b47b905 100644 --- a/src/matteloop/core/crop.py +++ b/src/matteloop/core/crop.py @@ -3,6 +3,7 @@ from __future__ import annotations import math +from dataclasses import replace from fractions import Fraction from matteloop.core.geometry import ( @@ -255,15 +256,23 @@ def _orientation_transform( source_width: int, source_height: int, rotation: int, pixel_aspect: float ) -> MediaTransform: _validate_dimensions(source_width, source_height) - return MediaTransform( + transform = MediaTransform( source_size=SizeF(source_width, source_height), - viewport=SizeF( - source_height if rotation in {90, 270} else source_width, - source_width * pixel_aspect if rotation in {90, 270} else source_height, - ), + viewport=SizeF(source_width, source_height), rotation=rotation, pixel_aspect=pixel_aspect, ) + display_width = max( + 1, + _round_fraction(Fraction(source_width) * Fraction(str(pixel_aspect))), + ) + return replace( + transform, + viewport=SizeF( + source_height if rotation in {90, 270} else display_width, + display_width if rotation in {90, 270} else source_height, + ), + ) def _orientation_transform_from_media(transform: MediaTransform) -> MediaTransform: @@ -279,6 +288,11 @@ def _rounded_delta(value: float) -> int: return math.floor(value + 0.5) if value >= 0 else math.ceil(value - 0.5) +def _round_fraction(value: Fraction) -> int: + quotient, remainder = divmod(value.numerator, value.denominator) + return quotient + int(remainder * 2 >= value.denominator) + + def _validate_dimensions(source_width: int, source_height: int) -> None: if ( not isinstance(source_width, int) diff --git a/tests/core/test_crop.py b/tests/core/test_crop.py index 7851fe8..7730870 100644 --- a/tests/core/test_crop.py +++ b/tests/core/test_crop.py @@ -2,7 +2,10 @@ from fractions import Fraction +import pytest + from matteloop.core.crop import ( + _orientation_transform, centered_crop_for_aspect, clamp_crop, crop_from_drag, @@ -13,12 +16,14 @@ ) from matteloop.core.geometry import ( CropGeometryState, + MediaTransform, PointF, RectF, SizeF, build_crop_geometry, ) from matteloop.core.specs import CropSpec +from matteloop.jobs.source import _display_dimensions def test_dragging_crop_moves_and_clamps_in_oriented_source_pixels() -> None: @@ -84,6 +89,90 @@ def test_oriented_crop_geometry_maps_rotation_and_pixel_aspect_once() -> None: assert oriented_point_from_widget(geometry, PointF(0, 0)) == PointF(0, 0) +@pytest.mark.parametrize("rotation", [0, 90, 180, 270]) +def test_oriented_crop_mapping_uses_rounded_decoder_extent(rotation: int) -> None: + """720x480 at pixel aspect 32/27 (NTSC DVD 16:9) decodes to 853, not 853.33. + + Asserting against ``_display_dimensions`` rather than a written-out 853 + is the point: the canvas and the decoder each round the same product, and + this is the assertion that fails if either one drifts from the other. + """ + decoded = _display_dimensions(720, 480, Fraction(32, 27), rotation) + + transform = _orientation_transform(720, 480, rotation, 32 / 27) + + assert transform.viewport == SizeF(*decoded) + + +@pytest.mark.parametrize("rotation", [0, 90, 180, 270]) +@pytest.mark.parametrize("pixel_aspect", [1.0, 2.0, 1.5, 0.75]) +def test_oriented_crop_mapping_round_trips_inside_source_frame( + rotation: int, pixel_aspect: float +) -> None: + source_size = SizeF(16, 8) + crop = CropSpec(4, 0, 4, 8) + display_size = MediaTransform( + source_size=source_size, + viewport=SizeF(1, 1), + rotation=rotation, + pixel_aspect=pixel_aspect, + ).oriented_display_size + + mapped = oriented_rect_to_source_rect( + crop, + source_width=16, + source_height=8, + rotation=rotation, + pixel_aspect=pixel_aspect, + ) + + assert mapped.x >= 0 + assert mapped.y >= 0 + assert mapped.right <= source_size.width + assert mapped.bottom <= source_size.height + + restored = MediaTransform( + source_size=source_size, + viewport=display_size, + rotation=rotation, + pixel_aspect=pixel_aspect, + ).source_rect_to_widget(mapped) + + assert restored.x == pytest.approx(crop.x) + assert restored.y == pytest.approx(crop.y) + assert restored.width == pytest.approx(crop.width) + assert restored.height == pytest.approx(crop.height) + + +@pytest.mark.parametrize("rotation", [0, 90, 180, 270]) +@pytest.mark.parametrize("pixel_aspect", [1.0, 2.0, 1.5, 0.75]) +def test_oriented_point_mapping_round_trips_through_display_geometry( + rotation: int, pixel_aspect: float +) -> None: + source_size = SizeF(16, 8) + display_size = MediaTransform( + source_size=source_size, + viewport=SizeF(1, 1), + rotation=rotation, + pixel_aspect=pixel_aspect, + ).oriented_display_size + geometry = build_crop_geometry( + state=CropGeometryState( + source_size=source_size, + crop=RectF(0, 0, 8, 8), + rotation=rotation, + pixel_aspect=pixel_aspect, + ), + viewport=display_size, + dpr=1, + ) + + restored = oriented_point_from_widget(geometry, PointF(2, 3)) + + assert restored.x == pytest.approx(2) + assert restored.y == pytest.approx(3) + + def test_fit_crop_aspect_on_a_corner_keeps_the_opposite_corner_fixed() -> None: fitted = fit_crop_aspect( CropSpec(2, 3, 6, 5), From 5d494c591691cbaa3b6aed7a5e7b2ebb50fb1952 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 07:27:11 +0200 Subject: [PATCH 02/21] =?UTF-8?q?=F0=9F=93=9D=20docs(design):=20plan=20exc?= =?UTF-8?q?lusion=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 📝 Design for user-drawn exclusion rectangles that force alpha 0 after segmentation, so a burned-in overlay does not survive into the cutout: - `FramingSpec.exclusions: tuple[CropSpec, ...]`, stored in oriented source pixels and mapped into cut space once, in a new `core/exclusion.py`. A region outside the crop produces no box and stales nothing. - The effective cut-space boxes enter the render, preview and union fingerprints only when non-empty, so cut sets and union metadata written by 0.4.1 stay byte-identical hits for users without regions. - Six consumers read cut alpha for framing; the enumeration and the three producers behind them are recorded, including the result player, which the first draft missed. - `_resolve_union` never reads `metadata.fingerprint` while the two render-side checks do — one predicate replaces all three. - Trim degrades to the untrimmed canvas when no pixel survives the regions, rather than aborting the job. - Regions are carried across a source change and clipped, not slid, to the new frame, so what is painted and what is masked are the same rectangle by construction. - 📝 Records a prerequisite defect found while verifying the design: the oriented viewport in `core/crop.py` omits the pixel aspect for rotation 0 and 180, which mispaints the crop rectangle on anamorphic sources. Scoped out as its own fix. Refs #80 --- docs/designs/exclusion-regions.md | 993 ++++++++++++++++++++++++++++++ 1 file changed, 993 insertions(+) create mode 100644 docs/designs/exclusion-regions.md diff --git a/docs/designs/exclusion-regions.md b/docs/designs/exclusion-regions.md new file mode 100644 index 0000000..a1bff13 --- /dev/null +++ b/docs/designs/exclusion-regions.md @@ -0,0 +1,993 @@ +# Design: Exclusion regions + +Architecture pass on 2026-09-12 for issue #80 +Branch: feat/issue-80-exclusion-regions +Repo: smb-org/MatteLoop +Status: REVISED after an independent adversarial review; no implementation yet. +Every `file:line` below was read on this branch. + +## Review findings addressed + +An independent review rejected the first draft. All nine findings were +re-verified against the code before designing against them; two turned out to +have a smaller root cause than the review prescribed, and one turned out to be +a defect that already ships. + +| # | Finding | Answered by | Verdict on re-check | +|---|---|---|---| +| 1 | The oriented→widget mapping is wrong for anamorphic 0°/180° sources | Decision 2a | **Confirmed, and wider than reported: the crop rectangle is mispainted today.** Root cause is one wrong viewport expression in non-frozen `core/crop.py:260-263`. Scoped out as a prerequisite fix, not folded in. The review's prescription — a new direct mapping for regions — is rejected: it would leave the crop broken and duplicate a transform. | +| 2 | Persisted regions are painted where they do not apply | Decision 1 (*Persistence*), Decision 2b | Confirmed. `build_crop_geometry` slides (`geometry.py:588` → `:387-395`) where `cut_exclusions` intersects. Answered by clipping regions to the source once, on `SourceLoaded`. | +| 3 | One dispatch per pointer move is a worker storm | Decision 6 (*Gesture contract*) | Confirmed, and worse than reported: `_schedule_facts` (`ui/transform_stage.py:412-442`) starts a `QThread` immediately with **no debounce**, and every dispatch rewrites ~12 QSettings keys (`ui/controller.py:486-504`, `ui/preferences.py:44-70`). Answered by commit-on-release. | +| 4 | The empty-union catch swallows corrupt frames | Decision 5 | Confirmed. `INVALID_FRAMING` also covers a non-RGBA frame (`geometry.py:1032-1038`), mismatched canvases (`geometry.py:770-775`) and a plan/frame size disagreement (`geometry.py:802-807`). Answered by a distinct signal, not a caught error code. | +| 5 | The "no re-segmentation" promise is not met | *Constraints* | Confirmed. The promise is narrowed in writing rather than engineered around. | +| 6 | Cache exactness is overstated | Decision 4 (*What this does not achieve*) | Confirmed on all three counts. Only the cheap one is fixed; the other two are documented instead of claimed away. | +| 7 | The downgrade dismissal is too strong | Decision 4 (*Migration*) | Confirmed. Restated as a bounded residual risk with the one guard that is free. | +| 8 | The render-loop copy ignores the ownership contract | Decision 3, site 2 | Confirmed — and dissolved. Staging before masking removes the copy entirely, so there is no second owner to register. | +| 9 | Governance and budget | *Implementation order*, change list | Confirmed. `main_window.py` is 351 lines and the ratchet only applies above 800 (`scripts/check_guardrails.py:124-126`), so it was never a baseline question; that flag is dropped. The scope entry moves first. | + +## Problem statement + +A burned-in overlay (Twitch chat, alert box, webcam frame, a bystander at the +frame edge) is read as foreground and survives into the cutout. `Crop` cannot +remove it when the overlay sits in front of the subject, and a +largest-component filter was measured to fail in both directions (#80). + +The user drags one or more rectangles over the source frame; those areas are +forced to alpha 0 **after segmentation**, as part of `FramingSpec`. Two +decisions are settled by the maintainer and are not revisited here: + +- **Rectangles only, several of them.** No polygon, no ellipse. +- **Post-segmentation, not pre-model.** The crop is part of the cut key + (`core/fingerprints.py:207`), so a pre-segmentation mask would re-segment + the whole clip on every drag, and rembg models judge the frame globally, so + blanking an input region is model-dependent. Zeroing alpha afterwards is + deterministic and reuses the stored cut set. + +## What already exists (verified) + +**Cut frames are crop-sized.** `_produce_cut_frame` (`jobs/render.py:1529`) +decodes, applies `apply_source_crop` with `request.crop` +(`render.py:1552-1558`), segments, and refuses anything that is not exactly +`(crop.height, crop.width, 4)` (`render.py:1585-1596`). Every stored and every +fresh cut frame is therefore in **cut space**: origin at the crop's top-left. +The crop itself is in oriented source pixels (`core/specs.py:108-109`, +`ui/crop_canvas.py:44`). Claim 1 of the brief holds. + +**Six consumers read cut alpha for framing, not five.** The brief listed five; +the sixth is the one a user looks at most: + +| # | Site | What it does with the alpha | +|---|---|---| +| 1 | `jobs/render.py:924` | preview: `alpha_bounds(cut, …)`; then `apply_framing` at `:929`/`:945` and `_immutable_rgba(cut)` at `:959` — the preview image itself | +| 2 | `jobs/render.py:1109` | render loop: `alpha_bounds` per frame into the range union; the *same* `cut` object is then stored by `self._workspace.stage` at `:1112` | +| 3 | `jobs/render.py:1338` | `_rebuild_union`: `read_cut` → `alpha_bounds` when the cached union misses | +| 4 | `jobs/render.py:1386-1387` | `stage_encoder_frames(partial(read_cut, private), …)` → `_stage_frame` → `apply_framing` (`jobs/transform_stage.py:122-124`) | +| 5 | `ui/transform_stage.py:705-707` | `union_alpha_bounds(_iter_stored_frames(…))` — the Transform group's framed size | +| 6 | **`ui/result_player.py:488-490`** | `_load_one_frame`: `frame_reader.read` → `apply_framing(cut, plan)` — the frames the result player loops | + +Missing site 6 would make the player show the overlay that the encoder +removes; missing site 5 would make the trim readout hug it. + +**All cut pixels enter framing through three producers**, each with a bounded +caller list: `_produce_cut_frame` (sites 1, 2), `WorkspacePort.read_cut` +(`render.py:158`; sites 3, 4; `FilesystemWorkspacePort.read_cut` at +`render.py:538-544` returns `opened.copy()` — `workspace/_models.py:245-247` +— so it is a fresh object per call), and `FrameReader.read` +(`ui/result_player.py:55-58`; sites 5, 6; `_DirectFrameReader` at +`ui/transform_stage.py:60-68` opens the file per call). Nothing else in `src/` +calls `alpha_bounds`, `union_alpha_bounds` or `apply_framing` (grep on this +branch). + +**The union cache.** `CutUnionMetadata(bounds, alpha_threshold, fingerprint)` +(`workspace/_manifest.py:112-135`) is written at `render.py:1126-1134` and by +CAS at `render.py:1348-1363`; the manifest parser refuses any other key +(`_exact_keys` at `_manifest.py:361-365`), so the format cannot grow. +`union_fingerprint` (`core/fingerprints.py:249-260`) hashes only `cut_key` and +`alpha_threshold`. It is checked in **three** places that do **not** agree: + +- `PreviewService._matching_union` (`render.py:989-997`): fingerprint **and** + threshold text. +- `RenderService._rebuild_union` (`render.py:1326-1334`): fingerprint **and** + threshold text. +- `ui/transform_stage.py:_resolve_union` (`:695-703`): **threshold only** — + it never looks at `metadata.fingerprint`. Claim 3 of the brief is therefore + understated: the UI cache would go stale with exclusions *and* is already + blind to any other fingerprint drift. + +External edits already drop the cache (`workspace/_cut_ops.py:380`), and the +UI skips it for edited manifests (`ui/transform_stage.py:695-696`). + +**`FramingSpec`** (`core/specs.py:244-291`) is a frozen dataclass with +`validate()`; it is rebuilt from flat `ParameterState` fields in three places: +`core/parameters.py:72-77` (validation), `ui/request_builder.py:97-102` (the +request), `ui/transform_stage.py:723-729` (the facts worker). Claim 4 holds. + +**Empty mask today.** `union_alpha_bounds` raises `INVALID_FRAMING` +(`core/geometry.py:781-786`), `framing_plan` raises when `trim` and the union +is `None` (`jobs/transform_stage.py:40-45`), and the render aborts — +`tests/jobs/test_render.py:1525-1552` pins that. The preview does not abort: +`local_bounds` becomes `None` and the display is `cut.copy()` +(`render.py:924, 941`). The UI facts worker fails and disables the Transform +group (`ui/transform_stage.py:123, 486-490`). + +**The crop editor.** `CropCanvas` (`ui/crop_canvas.py`, 359 lines) edits one +rectangle: `build_crop_geometry` (`core/geometry.py:570-615`) fans one +`CropSpec` out into eight handles plus a `"crop"` body with a fixed priority +(`:601-611`); `crop_from_drag`/`nudge_crop` (`core/crop.py:33-71`) move or +resize any rectangle given a target name; the two hooks `_constrain` and +`_crop_event` (`crop_canvas.py:261-280`) let `ResultPlayerCanvas` reuse the +whole machinery for a different rectangle and a different command +(`result_player.py:253-265`). `set_crop_edit` (`result_player.py:166-190`) is +the precedent for a mode switch on this canvas. + +**Frozen modules on this path** (`scripts/guardrails-baseline.json`): +`jobs/render.py` 2886, `core/geometry.py` 1141, `core/state.py` 882, +`ui/inspector.py` 897. Growth for a real feature needs the maintainer's +agreement and `check_guardrails.py --update` +(`docs/engineering-guardrails.md:279-303`). + +The ratchet only fires **above** the 800-line module budget +(`scripts/check_guardrails.py:124-126`), so a module under 800 is not frozen +however long its baseline entry is. `ui/main_window.py` is 351 lines: the +first draft listed it as frozen at 328 and that was wrong on both counts. + +## Constraints + +- Regions apply after segmentation and never enter the cut key. A region + change must not invalidate the stored cut set, and must invalidate the + preview, the render fingerprint and the union cache. +- **The re-segmentation promise, stated precisely** (review finding 5). What + holds: the stored cut set stays valid under any regions, so **Render and + Rebuild never re-segment** for a region change — they reread the stored + frames and re-measure. What does **not** hold: the *preview* is invalidated + like any other cleanup change, and `AppState` keeps only the displayed + `QImage` (`core/state.py:72`, `ui/presenter.py:177`), not the cut behind it, + so the next Preview press reruns the model on that one frame. Retaining the + unmasked preview cut in order to re-frame it locally is a larger change than + this feature (it is a preview-caching feature in its own right) and is + recorded in *Rejected alternatives*. Nothing in this document may claim that + a region change is free for the preview. +- No new dependency; Pillow already does everything needed. +- `core/geometry.py` is not touched. Everything new lives in one new + Qt-free module and the non-frozen files. +- Degrade, never refuse (G4, `docs/engineering-guardrails.md:189`). +- Preferences, cut sets and union metadata written by v0.4.1 keep working. +- String literals at every `translate()` call site; German catalogue entries; + README and generated screenshots updated (`CLAUDE.md`, *Keeping the README + honest*). + +## Decision 1 — Data model + +`FramingSpec` gains one field: + +```python +@dataclass(frozen=True) +class FramingSpec: + trim: bool = False + alpha_threshold: Decimal = Decimal("2.0") + padding: int = 0 + stretch_x: Decimal = Decimal("1.0") + exclusions: tuple[CropSpec, ...] = () +``` + +- **Type: `tuple[CropSpec, ...]`.** A region is an axis-aligned integer + rectangle in oriented source pixels — exactly what `CropSpec` already is + (`specs.py:108-134`). `crop_from_drag`, `nudge_crop` and `clamp_crop` + (`core/crop.py:33-90`) are pure rectangle arithmetic and take a region + unchanged. No `ExclusionRegion` type. + + **Correction (review finding 1).** The first draft also claimed + `build_crop_geometry` works on a region "with no adaptation". That is + wrong, and not only for regions: the oriented→raw helper it is fed from is + broken today. See Decision 2a — it is a prerequisite fix, not part of this + feature. +- **Validation** (`FramingSpec.validate`): `exclusions` must be a `tuple`, + every element a `CropSpec` (which already enforces `x, y >= 0`, + `width, height >= 1`). No upper bound against the source: a region beyond + the frame is clipped at apply time (Decision 2), and `validate_for_source` + (`specs.py:665-674`) is left alone so a region persisted from a larger + video does not refuse a smaller one. No count cap. +- **Ordering: none on the spec.** The tuple keeps user order, because the + canvas selects a region by index and a reorder under the pointer would be a + visible jump. Canonicalisation happens once, in `cut_exclusions()` + (Decision 2): sorted, de-duplicated, clipped. Zeroing is commutative, so + two orderings of the same regions are the same request everywhere it + matters — the fingerprint, the union cache, the pixels. +- **Fingerprint encoding.** The *effective* cut-space boxes, never the raw + regions: `"exclusions": [[left, top, right, bottom], …]` sorted ascending, + **present only when non-empty**. Rationale in Decision 4. +- **Reducer.** `ParameterState.exclusions: tuple[CropSpec, ...] = ()` + (`parameters.py:47-60`), validated by passing it into the existing + `FramingSpec(...)` call at `:72-77`. One new event, + `ExclusionsChanged(exclusions: tuple[CropSpec, ...])`, reduced like + `_reduce_cleanup_value` (`:322-337`): reject anything that is not a tuple of + `CropSpec`, **no-op when the effective boxes are unchanged** (not merely + when the raw tuples are equal — Decision 4), otherwise + `PreviewInvalidationReason.CROP_CLEANUP`. `ParametersReset` clears it + (`:218-252`, add to the reset and to the CROP_CLEANUP comparison). +- **Persistence.** A parameter, like the alpha threshold: it survives a + source change and a restart. The overlay of a streamer's layout is the same + on every clip of that stream, which is the case worth carrying. One + QSettings string `parameters/exclusions` = `"x,y,w,h;x,y,w,h"`; + `parameters_from_values` (`parameters.py:393-420`) parses it with the + per-key fallback the file already uses: any malformed entry → `()`. + + **Correction (review finding 2).** The first draft called a stale rectangle + on an unrelated video "harmless". It is not: a carried region that + *intersects* the new frame deletes those pixels, and one that sticks out is + **painted somewhere else than it masks**, because `build_crop_geometry` + slides a rectangle inward (`geometry.py:588` → `clamp_source_rect`, + `geometry.py:387-395`) while `cut_exclusions` intersects. Measured: a + carried `(1700,0,100,100)` on a 640-wide source paints at x 540…640 and + masks nothing. + + Carrying stays, but the regions are **clipped to the new source once, on + load** (Decision 2b), so a carried region is either a real rectangle inside + the frame or gone. Painted and masked can then never disagree, because + after the clip `clamp_source_rect` has nothing left to slide. + +## Decision 2 — Coordinates: stored in oriented source space, mapped once + +Regions are stored in **oriented source pixels**, the crop's own space. A +burned-in overlay is fixed in the source frame; if regions lived in cut space, +moving the crop would drag them along. The brief's claim 1 is right. + +The one mapping lives in a new Qt-free module, `src/matteloop/core/exclusion.py`: + +```python +def cut_exclusions( + exclusions: tuple[CropSpec, ...], crop: CropSpec +) -> tuple[PixelBounds, ...]: + """Map oriented-source regions into the crop-sized cut, clipped and canonical.""" + boxes: set[tuple[int, int, int, int]] = set() + for region in exclusions: + left = max(region.x, crop.x) - crop.x + top = max(region.y, crop.y) - crop.y + right = min(region.x + region.width, crop.x + crop.width) - crop.x + bottom = min(region.y + region.height, crop.y + crop.height) - crop.y + if right > left and bottom > top: + boxes.add((left, top, right, bottom)) + return tuple(PixelBounds(*box) for box in sorted(boxes)) + + +def exclude_alpha(image: Image.Image, boxes: tuple[PixelBounds, ...]) -> None: + """Zero RGBA inside each box, in place.""" + for box in boxes: + image.paste((0, 0, 0, 0), (box.left, box.top, box.right, box.bottom)) +``` + +- A region **fully outside the crop** produces no box: it is absent from the + pixels, from the union cache key and from the render/preview fingerprints. + Dragging it stales nothing — but only because the reducer compares effective + boxes rather than raw tuples (Decision 4, false miss 1). The first draft + claimed this while the reducer still compared raw tuples, and was wrong. +- A region **partly outside** is clipped to its intersection. +- `PixelBounds` (`geometry.py:142`) already refuses empty or negative boxes, + so the `right > left and bottom > top` guard is the only check needed. +- RGB is zeroed with the alpha, matching the canonical black that + `_decontaminate_edge_colors_in_place` writes under alpha 0 + (`render.py:1611-1620`), so the two edge modes produce identical bytes in an + excluded box. +- Alpha 0 is never "visible": the threshold table is strict + (`geometry.py:1108-1112`), so an excluded box drops out of every bound at + every threshold including 0. + +### Decision 2a — Prerequisite: the oriented→raw mapping is broken today + +**This is a defect that already ships, not one this feature introduces.** + +`oriented_rect_to_source_rect` (`core/crop.py:94-108`) builds an intermediate +`MediaTransform` through `_orientation_transform` (`core/crop.py:254-266`), +whose viewport is: + +```python +viewport=SizeF( + source_height if rotation in {90, 270} else source_width, + source_width * pixel_aspect if rotation in {90, 270} else source_height, +), +``` + +That expression is `MediaTransform.oriented_display_size` +(`core/geometry.py:305-316`) written out by hand — correct for 90°/270°, and +**missing the `* pixel_aspect` for 0°/180°**. The intermediate transform then +fits a 32-wide display into a 16-wide viewport, scale 0.5 instead of 1, and +stops round-tripping. + +Measured on this branch over rotation {0, 90, 180, 270} × PAR {1, 2, 1.5, +0.75}, comparing the painted `visual["crop"]` against the oriented rectangle's +true position in `content_rect`: **6 of 16 combinations are wrong — every +0°/180° case with PAR ≠ 1.** The review's worked example reproduces exactly: +coded 16×8, PAR 2, rotation 0, oriented rect (8,0,8,8) → raw +`RectF(8,-4,8,16)`. + +The single existing test pins rotation 270 with PAR 2 +(`tests/core/test_crop.py:63-70`) — one of the ten passing combinations, which +is why this was never caught. + +**The consequence today**, before any region exists: `crop_canvas.py:288` +feeds this helper, so **on an anamorphic un-rotated source the crop rectangle +is painted in the wrong place and at the wrong size.** Anamorphic 0° is not +exotic — it is DVD-era and broadcast 16:9 SD content. + +**The fix is one expression** in the non-frozen `core/crop.py`: make the +viewport the oriented display size for every rotation. Verified on this +branch — all 16 combinations pass. + +**Scoping.** It is a pre-existing defect with its own trigger, so it lands +**before** this feature, on its own branch, as its own `fix:` commit with its +own `Trigger:` line and its own issue. Exclusion regions depend on it and must +not be implemented on top of the broken helper — but they must also not +smuggle the fix in as a detail of a feature commit. + +Once it is in, regions genuinely do reuse `build_crop_geometry` unchanged, +which is what the first draft assumed without checking. + +### Decision 2b — Carried regions are clipped to the source on load + +`SourceLoaded` (`core/state.py:398-407`) already resets the crop to the full +frame via `default_crop_for_source`. Regions are carried instead of reset, so +they are clipped there in the same `replace(...)` call: + +```python +parameters=_parameters.clip_exclusions(state.parameters, event.value), +``` + +`clip_exclusions` lives in the non-frozen `core/parameters.py` and intersects +every region with `(0, 0, width, height)`, dropping what falls entirely +outside — the same intersect-don't-slide rule as `cut_exclusions`. + +- **Why intersect, not `clamp_crop`.** `clamp_crop` *slides* a rectangle + inward to preserve its size (`core/crop.py:73-90`, deliberately, for issue + #25). Sliding an exclusion moves it onto content the user wants to keep — + the opposite of what it is for. Regions intersect; the crop keeps sliding. +- **Why it cannot be bypassed.** Every source that reaches a READY state goes + through `SourceLoaded`; there is no other writer of `source_value`. A region + that survives into `state.parameters` is therefore inside the frame by + construction, which is what makes painted == masked a property rather than a + convention. +- **Cost.** `core/state.py` is 882 lines and ratcheted, so this is **+1 line + on a frozen module** and needs the maintainer's agreement plus + `check_guardrails.py --update`. That is the honest price of the invariant; + the alternative (clipping only for display) is in *Rejected alternatives* + with the drag-jump it causes. +- Clipping on load, not on every read, also means the fingerprint sees the + same rectangles the user sees. + +**Which crop.** Preview, render and rebuild use `request.crop` — a rebuild +finds its cut set by a key that includes that crop +(`render.py:561-591`, `fingerprints.py:207`), so the two are equal by +construction. The UI transform stage has no request; it reads the cut's own +crop from `manifest.cache_key_inputs["crop"]` with a `_crop_from_manifest` +helper beside the existing `_fps_from_manifest` +(`ui/transform_stage.py:741-748`), which reads the same mapping. + +## Decision 3 — The seam: one function, three producers, six sites + +`exclude_alpha` is the only function that zeroes, and `cut_exclusions` the only +function that maps. There is no *single call site* — the pixels arrive through +three producers, and the render loop must measure an excluded frame while +storing the unexcluded one — so the argument is a bounded enumeration, not a +choke point: + +| Site | Change | +|---|---| +| 1 preview (`render.py:913-960`) | `exclude_alpha(cut, boxes)` once, right after `_produce_cut_frame`. Bounds, both `apply_framing` calls and both `_immutable_rgba` images see it. | +| 2 render loop (`render.py:1108-1112`) | **stage first, then mask in place** — see below. No copy. | +| 3 `_rebuild_union` (`render.py:1338`) | `exclude_alpha(image, boxes)` after `read_cut`. | +| 4 encoder (`render.py:1386`) | `stage_encoder_frames` gains `exclusions: tuple[PixelBounds, ...]` and `_stage_frame` calls `exclude_alpha(cut, exclusions)` before `apply_framing` (`jobs/transform_stage.py:122-124`). | +| 5 UI facts (`ui/transform_stage.py:710-720`) | `_iter_stored_frames` takes the boxes and calls `exclude_alpha` before `yield`. | +| 6 result player (`ui/result_player.py:480-490`) | `FrameLoadWorker` and `_load_one_frame` take the boxes; `exclude_alpha` before `apply_framing`. | + +**Site 2 in detail (review finding 8).** The first draft masked a `cut.copy()` +so the unmasked frame could still be staged. The review was right that a +second full-resolution RGBA owner must be registered with +`RgbaOwnershipTracker` (`core/rgba.py:72-95`), whose peak and current counts +are reported in `RenderArtifact`. + +There is no copy to register, because the order can simply be swapped. Today: + +```python +bounds = alpha_bounds(cut, request.framing.alpha_threshold) # :1109 +union = _union_bounds(union, bounds) # :1110 +frame_records.append(self._workspace.stage(staged, index, cut)) # :1112 +``` + +Becomes: stage, then mask `cut` in place, then measure. `stage_cut` +(`workspace/_cut_ops.py:56-100`) opens the frame file and writes the PNG +synchronously inside the call and returns a `CutFrame` record derived from the +written bytes — it retains no reference to the image — so mutating `cut` +afterwards cannot reach the stored file. The existing `finally: cut.close()` +(`render.py:1113-1116`) is unchanged. + +Result: one owner, unchanged peak accounting, no tracker change, and one fewer +full-resolution allocation per frame than the first draft proposed. The stored +set still contains unmasked pixels, which is the property the whole design +rests on. + +Why the seam is not lower: `read_cut`/`FrameReader.read` also serve identity +work — hashing and rescanning in `workspace/_cut_ops.py`, external-edit +detection, the CAS's `_scan_cut_set` — where the bytes must be the stored +bytes. Zeroing inside the reader would make an edited-cut scan disagree with +the file on disk. Why not higher (inside `FramingPlan`/`apply_framing`): +bounds are computed before any plan exists, so the four measure sites would +still be explicit, and it grows the frozen `geometry.py`. + +What makes "missed a site" impossible in practice: the docstring of +`core/exclusion.py` lists the three producers and six sites, and the test plan +has one behavioural test per site that fails when that site is skipped. A new +consumer of cut alpha is a new caller of one of three functions, which a grep +shows. + +## Decision 4 — Union-cache invalidation and migration + +The manifest format cannot gain a key (`_manifest.py:361-365`), and it does not +need one: the invalidation goes through the `fingerprint` field that already +exists. + +`core/fingerprints.py`: + +```python +def cut_union_fingerprint( + framing: FramingSpec, crop: CropSpec, *, cut_key: str +) -> str: + payload: dict[str, object] = { + **_schema("cut-union"), + "cut_key": _validated_sha256(cut_key, "cut_key"), + "alpha_threshold": _canonical_decimal(framing.alpha_threshold), + } + boxes = cut_exclusions(framing.exclusions, crop) + if boxes: + payload["exclusions"] = [[b.left, b.top, b.right, b.bottom] for b in boxes] + return _canonical_hash(payload) + + +def union_fingerprint(request: RenderRequest, *, cut_key: str) -> str: + request = _validated_request(request) + return cut_union_fingerprint(request.framing, request.crop, cut_key=cut_key) +``` + +`_framing()` (`fingerprints.py:348-354`) takes the request instead of the spec +and adds the same `"exclusions"` entry under the same non-empty rule, so +`preview_fingerprint` and `render_fingerprint` track effective regions. + +**One predicate for all three checks.** `jobs/transform_stage.py` (already the +module the UI imports `framing_plan` from) gains: + +```python +def cached_union( + metadata: CutUnionMetadata | None, framing: FramingSpec, crop: CropSpec, + cut_key: str, +) -> PixelBounds | None: + if metadata is None or metadata.fingerprint != cut_union_fingerprint( + framing, crop, cut_key=cut_key + ): + return None + return PixelBounds(*metadata.bounds) +``` + +`_matching_union`, `_rebuild_union` and the UI's `_resolve_union` all call it. +The separate `alpha_threshold` text comparison in the two render sites is +subsumed (the fingerprint already hashes the canonical threshold, and both +are written from the same value at `render.py:1130-1132`), and the UI stops +being blind to the fingerprint. Three predicates that had already diverged +become one. + +**Migration — stated explicitly.** Metadata written by v0.4.1 hashes +`{schema, cut_key, alpha_threshold}`. Because the `"exclusions"` key is +**omitted when empty**, a request without regions computes the byte-identical +fingerprint: **existing union metadata stays a hit**, and existing preview and +render fingerprints are unchanged. A request *with* regions computes a +different fingerprint → miss → the existing recompute-and-CAS path +(`render.py:1336-1363`) overwrites the entry, exactly as a threshold change +does today. Removing the regions again is a miss again and a second CAS; +that is one pass over the stored frames, the same cost as any threshold +change, and it needs no second cache slot. + +Preferences: the new key is absent on first launch → `()`; nothing else in +`parameters/` changes. Cut sets: untouched, by design. + +**The downgrade risk, stated properly (review finding 7).** The first draft +dismissed it because "the updater refuses downgrades". That is not a +sufficient argument: it does not stop an older binary that is still installed, +restored from a backup, or run as a portable build against the same cache +directory. + +The concrete disagreement: a new build writes region-derived bounds into the +shared manifest. An old **Render/Rebuild** compares the fingerprint +(`render.py:989-997`, `:1326-1334`), fails to reproduce it, and recomputes the +unexcluded union — correct. An old **UI facts worker** compares the threshold +only (`ui/transform_stage.py:695-703`) and accepts the narrower +region-derived bounds, then applies them to unmasked stored frames. The +Transform group would show a framed size tighter than what that build would +actually encode. + +- **Blast radius:** a wrong readout in one panel of an old build. The bounds + are narrower, never wider, so nothing is encoded that the user cannot see; + and the old build's own render recomputes correctly, so no file is wrong. +- **The guard that is free:** the threshold text is written from the same + value in both builds, so it cannot distinguish them — but this design + already replaces that blind check with `cached_union` in the *new* build + (finding: the UI is blind to the fingerprint on `main` today, independent of + regions). Shipping that fix is what stops the next version of this problem; + it cannot retroactively fix a binary already on disk. +- **Residual risk accepted:** an older build, run by hand against a cache a + newer build wrote regions into, shows a stale framed size in the Transform + group until that cut set is rescanned. Not guarded further; guarding it + would need a manifest key the parser refuses (`_manifest.py:361-365`). + +### What this does not achieve (review finding 6) + +No **false hit** was found on re-check: the crop is in the cut key +(`fingerprints.py:207`), so a crop change already changes `cut_key`, and the +effective-box payload matches the pixels exactly. Ordering and exact +duplicates canonicalise away. Rotation is a source property and changes the +source fingerprint. + +Three **false misses** remain, and are documented rather than claimed away: + +1. **A fully-outside region still stales the preview.** The reducer compares + raw tuples, so dragging a region that produces no box dispatches a real + change. Decision 1's earlier claim that "dragging it does not stale + anything" was wrong about the reducer, though right about the fingerprint. + **Fixed, because it is cheap:** the reducer no-ops when the *effective* + boxes are unchanged, comparing `cut_exclusions(new, crop)` against + `cut_exclusions(old, crop)`. After Decision 2b a fully-outside region only + exists relative to the crop, not the source. +2. **Equivalent geometries hash differently.** One rectangle plus a rectangle + contained in it, or two tiles that exactly cover one rectangle, produce + identical pixels and different fingerprints. Merging overlapping rectangles + into a canonical cover is real geometry code for a cache miss nobody has + measured. **Not fixed.** Cost is one recompute. +3. **An empty union cannot be cached at all.** `CutUnionMetadata` refuses + non-positive bounds (`workspace/_manifest.py:126-129`) and `_rebuild_union` + publishes only a non-empty union (`render.py:1347`), so a legitimately + fully-transparent result is rescanned on every facts run. **Not fixed** — + it needs a manifest key the parser refuses. It is also the pathological + case (the user excluded everything), and Decision 5 makes it visible rather + than fatal. + +## Decision 5 — Empty mask: trim degrades to the full canvas + +A region can cover the whole subject, or the whole frame. Today +`framing_plan` raises and the job aborts (`jobs/transform_stage.py:40-45`, +pinned by `tests/jobs/test_render.py:1525-1552`). The user can fix this from +the UI, so G4 does not strictly apply — but a render that aborts because trim +found nothing is a refusal of the one thing the user asked for, and the +degraded result is trivially correct: + +- `framing_plan(source_size, None, framing)` with `trim=True` returns the + **untrimmed** plan (`global_bounds=None`) instead of raising. The output is + the crop canvas plus padding; if the mask is genuinely empty, every frame is + fully transparent — which is what excluding everything means. +- `RenderService` appends `"trim skipped: no pixel above the alpha threshold + survives the exclusion regions"` to `notes` (`render.py:1033`), the channel + the disk advisory already uses. Nothing in `ui/` displays `notes` today + (grep), so this reaches the log, not a dialog. Not adding a UI channel now. +- **What the user sees:** the preview's Result canvas shows the transparent + frame; the completion summary reports the crop's dimensions rather than a + trimmed size; the Transform group's framed size equals the crop. The + rectangles on the Original canvas are the explanation. +- `tests/jobs/test_transform_stage.py:34` and `tests/jobs/test_render.py:1525` + are updated to pin the new behaviour (test plan). **`test_render.py:1522`'s + `visible_size=10` minimum-dimension branch must survive** — it pins a + different refusal (a trimmed box below `MIN_FINAL_DIMENSION`), which is not + degraded here and must keep failing loudly. + +**An empty mask is signalled, not caught (review finding 4).** + +The first draft had the UI catch `ValidationError` with `INVALID_FRAMING` and +treat it as an empty union. That code is not specific to an empty mask — +`union_alpha_bounds` and its helpers raise the same code for: + +- a non-iterable argument (`geometry.py:748-754`), +- a frame that is not a real Pillow RGBA image (`geometry.py:1032-1038`), +- frames whose canvases disagree (`geometry.py:770-775`), +- and later, in `apply_framing`, a frame that does not match the plan + (`geometry.py:802-807`). + +Failure scenario the blanket catch produces: two externally edited frames have +different dimensions. The facts worker swallows the mismatch as "empty", +reports the full manifest canvas as a valid framed size and starts the player; +`apply_framing` then rejects the real frame size, and `FrameLoadWorker` catches +only filesystem and Pillow decode errors, so the failure surfaces somewhere +unrelated — or not at all. A corrupt cut set would present as a working one. + +Instead, the emptiness is carried as a value: + +- `core/exclusion.py` gains + `union_alpha_bounds_or_none(frames, threshold) -> PixelBounds | None`, + which pre-checks the one condition that means "empty" and lets every other + `ValidationError` propagate untouched. It lives beside the other new + helpers rather than in the frozen `core/geometry.py`; `union_alpha_bounds` + is not modified. +- `_resolve_union` (`ui/transform_stage.py:691-707`) and `_rebuild_union` + (`render.py:1338`) call it and branch on `None`. Nothing catches + `INVALID_FRAMING` anywhere in this design. +- `framing_plan` then receives `None` with `trim=True` and returns the + untrimmed plan. + +So an empty mask degrades and a corrupt or inconsistent cut set still fails +loudly — the test plan pins both, in the same pair of tests. + +The preview path needs no change: it already shows the cut unframed when no +union matches (`render.py:940-941`). + +## Decision 6 — UI: a mode switch on `CropCanvas`, geometry reused per region + +**Mode switch, not an extended priority list.** `build_crop_geometry` is in the +frozen `geometry.py` and its priority tuple names one rectangle. Extending it +to N regions means N×9 targets, a priority policy for overlaps, and growth in +a frozen file. A mode switch costs nothing in geometry and answers the overlap +question by construction: **in region mode the crop has no hit targets; in +crop mode regions have no hit targets. A region over a crop handle is never +ambiguous because the two are never live at once.** + +**Controls** (Inspector, *Crop & cleanup* section, one form row after +*Horizontal stretch*, label `"Exclusions"`), hosted the way `TransformGroup` +is hosted — a small widget module so the frozen `inspector.py` grows by the +five lines that construct, place, apply and tab-order it: + +`ui/exclusion_controls.py` — `ExclusionControls(QWidget)`: +- `edit_button`: checkable `QToolButton`, text `"Edit regions"`, object name + `exclusion_edit`. Checked = the Original canvas is in region mode. UI-local + state, like `TransformGroup.crop_edit_toggled`; it is not reducer state. +- `clear_button`: `"Clear"`, object name `exclusion_clear`, enabled only when + regions exist; dispatches `ExclusionsChanged(())`. +- `count_label`: `translate("Inspector", "%n region(s)", "", n)` — Qt's + numerus form, literal at the call site. +- Signals: `edit_toggled(bool)`, `command_requested(object)`. +- `apply(presentation, editable)` mirrors `apply_parameters` + (`inspector.py:487-516`): disabled until a source is loaded; leaving + region mode is forced when the controls become non-editable (a running job). +- Wiring: `main_window.py:224-225` already connects `command_requested`; + one more line connects `edit_toggled` to `original_canvas.set_exclusion_edit`. + +**`CropCanvas` in region mode** (`set_exclusion_edit(enabled: bool)`): +- `CropPresentation` gains `exclusions: tuple[CropSpec, ...] = ()` + (`ui/crop_presentation.py:12-21`), filled by `present_crop` from + `state.parameters.exclusions`. The default keeps every existing constructor + call and test valid. +- **Painting, both modes:** every region is painted whenever it exists — a + translucent fill (`#E5484D` at alpha 90) with a 1 px solid border — so a + persisted region is always visible on a new video. In crop mode that is all; + the crop keeps its handles. In region mode the crop is drawn as its dimmed + outline **without handles**, and the selected region gets the eight handles + and the focus ring. +- **Geometry:** `_rebuild_geometry` builds `build_crop_geometry` for + `_edited_rect()` — the selected region in region mode, else the crop. That + is the entire reuse: the same eight handles, the same + `crop_from_drag`/`nudge_crop`, the same accessible announcement, aimed at a + different `CropSpec`. +- **Press** (left button, editable, region mode): + 1. hit-test the selected region's geometry → a handle or `"crop"` starts a + resize/move drag of that region, exactly as the crop's drag today + (`crop_canvas.py:142-167`); + 2. else, if the oriented point is inside another region → it becomes + selected and a move drag starts in the same press; + 3. else → a rubber band starts from the press point. +- **Move:** nothing is dispatched. The region under the pointer and the rubber + band are both painted from canvas-local state. See *Gesture contract*. +- **Release:** exactly one dispatch. A rubber band smaller than 8×8 oriented + source pixels is discarded and dispatches nothing; otherwise + `ExclusionsChanged(regions + (new,))` and the new region is selected. A + move or resize dispatches `ExclusionsChanged` with that index replaced. + Regions are intersected with the source, never slid (Decision 2b). + +**Gesture contract: one dispatch per gesture (review finding 3).** + +The crop dispatches `CropChanged` on every move, and that is affordable +because the crop only re-renders a canvas. A region change is a *framing* +change, and framing changes are expensive on this path: + +- `_schedule_facts` (`ui/transform_stage.py:412-442`) starts a `QThread` and a + `_CutFactsWorker` **immediately — there is no debounce on this path.** The + module's `_debounce_timer` belongs to the frame worker, not the facts + worker. +- A superseded worker is cancelled but deliberately **retained until its + thread finishes**, because dropping the reference used to crash + (`tests/ui/test_transform_stage.py:506`). A drag would therefore accumulate + concurrent retiring threads, each scanning stored frames. +- Every parameter dispatch rewrites the whole preference block — about a dozen + `QSettings.setValue` calls (`ui/controller.py:486-504`, + `ui/preferences.py:44-70`). + +So a 200-sample drag would mean 200 threads, 200 cut scans and ~2 400 settings +writes. + +The precedent is already in the same module: the result-crop editor suppresses +reloads while editing and performs exactly one on exit +(`ui/transform_stage.py:300-315`, pinned by +`tests/ui/test_transform_stage.py:811`). Regions adopt the same shape: + +- `CropCanvas` holds the in-progress rectangle in local state and repaints + itself directly; the reducer sees nothing. +- `mouseReleaseEvent` dispatches once — or not at all, if the gesture was a + discarded rubber band or left the rectangle unchanged. +- Keyboard nudges dispatch per key press. An arrow key is one discrete edit, + not a stream, so no coalescing is needed there; `Escape` during a drag + abandons it without dispatching. + +This is pinned by a test that counts dispatches across a synthetic +press-move×N-release and asserts exactly one. +- **Keys:** arrows nudge the selected region (Shift = 10 px) through the + existing `keyPressEvent` path; `Delete`/`Backspace` dispatch + `ExclusionsChanged` without the selected region; `Escape` clears the + selection. +- **Hooks:** `_crop_event(rect)` returns `ExclusionsChanged(with index + replaced)` in region mode and `CropChanged(rect)` otherwise; `_constrain` + stays identity. In region mode the canvas calls `_crop_event` only on + release, per the gesture contract. `ResultPlayerCanvas` never enters region + mode, so it is inert there. +- **Leaving the mode** clears the selection, restores the crop handles and + keeps painting the regions. +- **Accessibility:** in region mode the description is + `translate("CropCanvas", "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels")`. +- Numeric fields for a region: not in this landing (see *Not in scope*). + +**New user-visible strings** (all literals, all with German entries): +`"Exclusions"` (form label, via `inspector_label` in `ui/copy.py:632-654`), +`"Edit regions"`, `"Edit exclusion regions"` (accessible name), `"Clear"` +(exists), `"Clear exclusion regions"` (accessible name), `"%n region(s)"`, +the canvas description above. + +**README and screenshots.** `scripts/screenshots.py:_state` (`:120`) gets one +region in its `ParameterState` so `main-window.png` shows a rectangle on the +Original canvas; README gains a short paragraph in the crop/cleanup +description; regeneration per `README.md:150-159`. + +## Not in scope + +- Numeric x/y/w/h fields per region, region naming, a region list widget. +- A UI channel for `notes` (the trim-skipped message reaches the log). +- Reset of regions on source change. They are carried and **clipped** + (Decision 2b). +- A cap on the number of regions. +- Merging overlapping regions into a canonical cover (Decision 4, false miss 2). +- Caching an empty union (Decision 4, false miss 3). +- Retaining the unmasked preview cut so a region change re-frames without the + model (*Constraints*). +- Touch hit-testing beyond what `InteractionGeometry.hit_test(touch=…)` + already gives the selected region. +- Anything in `core/geometry.py`, `core/state.py`. + +## Failure modes considered + +- **Region entirely inside the crop's excluded margin** — no box; the reducer + no-ops on unchanged effective boxes, so nothing stales; the rectangle is + still painted, and the pixels under it are gone anyway because the crop + removed them. +- **Carried region partly outside a smaller new source** — clipped on load to + its intersection, so what is painted is what is masked. +- **Carried region entirely outside a smaller new source** — dropped on load. +- **Anamorphic source** — correct only after the Decision 2a prerequisite + lands; regions must not be implemented before it. +- **A drag across 200 pointer samples** — one dispatch, one facts worker. +- **Corrupt or mismatched stored frames while regions exist** — still fails + loudly; only a genuinely empty mask degrades (Decision 5). +- **Same regions, different order** — identical fingerprint and bytes + (`cut_exclusions` sorts and de-duplicates). +- **Regions during a running job** — `ExclusionsChanged` goes through the + existing `can_edit` gate (`parameters.py:181-182`); the controls disable + and region mode is left. +- **Persisted string malformed** — `()`, per-key fallback. +- **Region mode with no source** — controls disabled; `set_exclusion_edit` + with `presentation is None` paints nothing. +- **External edit of a stored frame** — the union cache is already dropped + (`_cut_ops.py:380`); exclusions are applied on read, so edited pixels inside + a box are zeroed like any other. +- **`render.py` growth** — see the change list. The first draft's "≈0" was a + guess; this revision budgets +5…+15 and makes measuring it a gate in the + implementation order, not a hope. + +## File-by-file change list + +Line deltas are estimates; **bold** = frozen in the baseline. + +**Prerequisite, lands separately** (Decision 2a — its own issue, branch and +`fix:` commit, before any of the below): + +| File | Now | Δ | Notes | +|---|---|---|---| +| `src/matteloop/core/crop.py` | 291 | ~0 | `_orientation_transform` viewport: oriented display size for every rotation | +| `tests/core/test_crop.py` | — | +25 | rotation × PAR matrix; the current test is one passing cell of it | + +**This feature:** + +| File | Now | Δ | Notes | +|---|---|---|---| +| `src/matteloop/core/exclusion.py` | new | +95 | `cut_exclusions`, `exclude_alpha`, `union_alpha_bounds_or_none`, docstring enumerating the three producers and six sites | +| `src/matteloop/core/specs.py` | 697 | +14 | `FramingSpec.exclusions` + validation | +| `src/matteloop/core/fingerprints.py` | 465 | +25 | `cut_union_fingerprint`, `_framing(request)` with the non-empty rule | +| `src/matteloop/core/parameters.py` | 553 | +60 | field, `ExclusionsChanged`, reducer comparing **effective** boxes, `clip_exclusions`, reset, settings parse | +| **`src/matteloop/core/state.py`** | 882 | +1 | `clip_exclusions` on `SourceLoaded`. **Flag: frozen; needs `--update` with agreement** | +| `src/matteloop/jobs/transform_stage.py` | 177 | +30 | `cached_union`, degrade in `framing_plan`, `exclusions` through `stage_encoder_frames`/`_stage_frame` | +| **`src/matteloop/jobs/render.py`** | 2886 | **+5 … +15** | sites 1–4 (site 2 is a reorder, not an addition); `_matching_union` and `_rebuild_union` collapse onto `cached_union`; `union_alpha_bounds_or_none` at site 3. **Flag: frozen, and the first draft's "≈0" was not a safe estimate. Measure at step 3 and ask before touching the baseline.** | +| `src/matteloop/ui/preferences.py` | 91 | +6 | key + persist | +| `src/matteloop/ui/request_builder.py` | 112 | +1 | pass `exclusions` | +| `src/matteloop/ui/parameter_presentation.py` | 85 | +2 | field + mapping | +| `src/matteloop/ui/crop_presentation.py` | 63 | +3 | field + mapping | +| `src/matteloop/ui/transform_stage.py` | 721 | **+45** | `_crop_from_manifest`, `cached_union`, `union_alpha_bounds_or_none` branch, boxes through `_iter_stored_frames` and `FrameLoadWorker` — lands at **~766 of 800**. **Flag: tight. If it crosses, split `_CutFactsWorker` into a sibling module rather than raising the budget.** | +| `src/matteloop/ui/result_player.py` | 544 | +8 | boxes through `FrameLoadWorker`/`_load_one_frame` | +| `src/matteloop/ui/crop_canvas.py` | 359 | **+185** | mode, painting, rubber band, select/move/delete, gesture-local state and the release commit, announcement → **~544**. Over half the budget in one file; if it passes ~600, split the region mode into `ui/exclusion_canvas.py` as a `CropCanvas` subclass, the way `ResultPlayerCanvas` already is | +| `src/matteloop/ui/exclusion_controls.py` | new | +80 | the three controls, `apply`, `tab_widgets` | +| **`src/matteloop/ui/inspector.py`** | 897 | +5 | construct, add row, apply, tab order. **Flag: frozen; needs `--update` with agreement** | +| `src/matteloop/ui/main_window.py` | 351 | +1 | connect `edit_toggled`. **Not a baseline question** — the ratchet applies only above 800 lines (`scripts/check_guardrails.py:124-126`) | +| `src/matteloop/ui/copy.py` | 677 | +1 | `"Exclusions"` in `inspector_label` | +| `resources/matteloop_{en,de}.ts`, `.qm` | — | regen | `pyside6-lupdate`/`lrelease` per `docs/building.md:105-111`; German entries by hand | +| `scripts/screenshots.py` | — | +3 | one demo region | +| `README.md`, `assets/screenshots/main-window.png` | — | +6, regen | | +| `docs/v1-scope.md` | — | +4 | **first**, not last (G8) | +| `scripts/guardrails-baseline.json` | — | 2 entries | `core/state.py`, `ui/inspector.py`; only after agreement | + +**Two baseline questions for the maintainer, both +1 … +5 lines:** +`core/state.py` (the clip that makes painted == masked a property) and +`ui/inspector.py` (hosting the controls row). `jobs/render.py` is a third only +if it measures positive after the collapse. + +## Test plan + +Named after behaviour (G7). "Fails without" names the missing piece. + +**Cheap, Qt-free** + +| Test | Fails without | +|---|---| +| `tests/core/test_crop.py::test_oriented_rect_round_trips_at_every_rotation_and_pixel_aspect` — rotation {0,90,180,270} × PAR {1, 2, 1.5, 0.75}, asserting the painted rect equals the oriented rect's position in `content_rect` | **Decision 2a. Fails on `main` today in 6 of 16 cells.** Belongs to the prerequisite commit | +| `tests/core/test_exclusion.py::test_cut_exclusions_translates_by_the_crop_origin_and_clips_to_the_crop` | the mapping | +| `…::test_cut_exclusions_drops_a_region_outside_the_crop` | the empty guard | +| `…::test_cut_exclusions_is_order_independent_and_deduplicated` | sorting/set | +| `…::test_exclude_alpha_zeroes_rgba_inside_each_box_and_nothing_else` | `exclude_alpha` | +| `tests/core/test_specs.py::test_framing_spec_rejects_exclusions_that_are_not_crop_specs` | validation | +| `tests/core/test_fingerprints.py::test_render_and_preview_identity_track_effective_exclusions_only` | `_framing(request)`; a region outside the crop must **not** change it | +| `…::test_union_identity_tracks_effective_exclusions` | `cut_union_fingerprint` | +| `…::test_identities_without_exclusions_match_the_previous_schema` — asserts the canonical payload has no `"exclusions"` key when empty | the non-empty rule; failing it orphans every v0.4.1 union cache | +| `tests/core/test_parameters.py::test_exclusions_changed_invalidates_the_preview_as_crop_cleanup` | the reducer | +| `…::test_moving_a_region_outside_the_crop_does_not_invalidate_the_preview` | the effective-box comparison (Decision 4, false miss 1) | +| `…::test_source_load_clips_carried_regions_and_drops_those_outside` | `clip_exclusions` (Decision 2b) | +| `tests/core/test_state.py::test_loading_a_smaller_source_leaves_every_region_inside_the_frame` | the `SourceLoaded` call site — the invariant painted == masked rests on | +| `…::test_parameters_reset_clears_exclusions` | reset | +| `…::test_exclusions_settings_string_round_trips_and_a_malformed_entry_falls_back_to_none` | parse | + +**Jobs, existing fakes in `tests/jobs/render_support.py`** + +| Test | Fails without | +|---|---| +| `tests/jobs/test_preview.py::test_preview_zeroes_excluded_alpha_in_the_cut_image_and_its_bounds` | site 1 | +| `tests/jobs/test_render.py::test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_the_region` — stored PNG keeps alpha; output frame alpha 0 in the box; `union_metadata.bounds` excludes it | sites 2 and 4, **and the stage-before-mask order at site 2**: masking first would write masked PNGs and the assertion on the stored file fails | +| `…::test_render_peak_rgba_owner_count_is_unchanged_by_exclusions` | the no-copy order; a `cut.copy()` at site 2 raises the reported peak | +| `tests/jobs/test_rebuild.py::test_rebuild_with_a_region_misses_the_cached_union_and_recomputes_it` | site 3 + fingerprint | +| `…::test_rebuild_without_regions_reuses_union_metadata_written_before_exclusions_existed` — metadata hand-built with the v0.4.1 payload | the non-empty rule | +| `tests/jobs/test_transform_stage.py::test_framing_plan_skips_trim_without_a_union` (replaces `:34`) | Decision 5 | +| `…::test_stage_encoder_frames_zeroes_excluded_boxes_before_framing` | site 4 | +| `tests/jobs/test_render.py::test_render_with_trim_and_an_empty_mask_encodes_the_untrimmed_canvas_and_notes_it` (replaces the abort half of `:1525-1552`) | Decision 5 | +| `…::test_render_still_refuses_a_trimmed_box_below_the_minimum_dimension` — the `visible_size=10` branch at `:1522`, kept verbatim | that this degradation did **not** swallow the minimum-dimension refusal | +| `tests/core/test_exclusion.py::test_union_alpha_bounds_or_none_returns_none_for_an_empty_mask` | the empty signal | +| `…::test_union_alpha_bounds_or_none_still_raises_for_mismatched_canvases_and_non_rgba_frames` | **review finding 4** — a blanket `INVALID_FRAMING` catch passes the first of these two and fails this one | + +**Qt, offscreen** + +| Test | Fails without | +|---|---| +| `tests/ui/test_transform_stage.py::test_facts_ignore_cached_union_metadata_whose_fingerprint_does_not_match` | `cached_union` in the UI — **fails on `main` today** | +| `…::test_region_change_recomputes_facts_and_reloads_player_frames_without_the_region` | sites 5 and 6 | +| `…::test_empty_union_degrades_to_the_untrimmed_framed_size` | the `None` branch in `_resolve_union` | +| `…::test_mismatched_stored_frames_still_fail_the_facts_worker` | **review finding 4** — passes on a blanket catch, which is the point | +| `tests/ui/test_crop_canvas.py::test_a_region_drag_dispatches_exactly_once_on_release` — press, 20 moves, release; count dispatches | **review finding 3**; a per-move dispatch scores 21 | +| `…::test_an_abandoned_rubber_band_dispatches_nothing` | the release guard | +| `tests/ui/test_crop_canvas.py::test_region_mode_rubber_band_adds_a_region_on_release` | rubber band | +| `…::test_region_mode_discards_a_rubber_band_below_eight_pixels` | the threshold | +| `…::test_region_mode_gives_the_crop_no_hit_targets` — press on a crop handle under a region starts nothing for the crop | the mode switch | +| `…::test_click_selects_a_region_and_the_same_drag_moves_it` | press rule 2 | +| `…::test_delete_removes_the_selected_region` | keys | +| `…::test_leaving_region_mode_restores_crop_handles_and_keeps_painting_regions` | mode exit | +| `…::test_region_mode_announces_the_selected_region_bounds` | accessibility | +| `tests/ui/test_parameter_inspector.py::test_exclusion_controls_toggle_edit_mode_and_clear_regions` | controls | +| `tests/ui/test_parameter_persistence.py::test_exclusions_persist_as_one_settings_string` | preferences | +| `tests/ui/test_parameter_requests.py` (+1 assertion) | request builder | +| `tests/test_translations.py::test_catalogues_match_lupdate_extraction` (existing) | German entries | + +Screenshot regeneration and a real render on the #80 clip are manual. + +## Implementation order + +**0. `docs/v1-scope.md` first.** G8 (`docs/engineering-guardrails.md:244`) +makes that file authoritative and forbids implementing an out-of-scope design +requirement, so the scope entry is step zero, not a tidy-up at the end. Nothing +below starts until it is recorded and the two baseline questions +(`core/state.py`, `ui/inspector.py`) have the maintainer's answer. + +**1. The prerequisite, on its own branch and its own issue.** The +`_orientation_transform` viewport fix in `core/crop.py` plus the rotation × PAR +matrix (Decision 2a). It is a `fix:` with a `Trigger:` line naming the +anamorphic repro, it stands alone, and it must not be mixed into a feature +commit. + +Then, on this branch: + +2. `core/exclusion.py`, `specs.py`, `fingerprints.py` + their tests. +3. `jobs/transform_stage.py` (`cached_union`, degrade, encoder boxes) + + `render.py` sites 1–4 + jobs tests. **Measure `render.py`'s net delta here + and stop for the maintainer if it is positive.** +4. `parameters.py` (including `clip_exclusions` and the effective-box + comparison), the `core/state.py` line, `preferences.py`, + `request_builder.py`, `parameter_presentation.py`, `crop_presentation.py` + + tests. +5. `ui/transform_stage.py`, `result_player.py` (sites 5, 6) + tests. **Check + the line count against the 800 budget here**, and split rather than raise + it. +6. `crop_canvas.py` region mode and the gesture contract + tests. **Check the + line count here too.** +7. `exclusion_controls.py`, the five inspector lines, the main-window line, + `copy.py`, catalogues. +8. Screenshots, README. + +Each step is verified with the standard command from `CLAUDE.md`. + +## Rejected alternatives + +- **Regions in cut space.** Moving the crop would drag the overlay mask with + it; the overlay is fixed in the source frame. +- **A pre-segmentation mask.** Settled by the maintainer: re-segments on every + drag (crop is in the cut key) and is model-dependent. +- **Zeroing inside `read_cut` / `FrameReader.read`.** Would corrupt the + identity consumers (hash scans, external-edit detection, CAS) that share the + readers and must see the stored bytes. +- **Exclusions on `FramingPlan`, applied inside `apply_framing`.** Covers the + two apply sites but none of the four measure sites, and grows the frozen + `geometry.py`. The seam would be no narrower. +- **Baking exclusions into the stored cut frames.** Makes the cut set depend + on framing; a region change would re-segment or orphan the set. +- **Always emitting `"exclusions": []` in fingerprints.** Cleaner JSON, but it + turns every existing union cache and every existing preview/render + fingerprint into a miss on upgrade for users who never draw a region. +- **A new manifest key for the exclusions.** The parser refuses unknown keys + (`_manifest.py:361-365`) and the workspace modules are frozen; the + fingerprint field already carries the identity. +- **Raw (unclipped) regions in the fingerprint.** A region outside the crop + would stale the preview and the render for a pixel-identical result. +- **An `ExclusionRegion` type.** `CropSpec` is the same rectangle with the + same validation; a second type would need its own drag/nudge/clamp helpers. +- **Extending `build_crop_geometry`'s priority to N regions.** N×9 targets, an + overlap policy, and growth in frozen `geometry.py`; the mode switch makes + the overlap question disappear. +- **Reducer state for the edit mode.** `AppState` is in frozen `state.py`; + `TransformGroup.crop_edit_toggled` already shows UI-local mode works. +- **Emitting the rubber band live.** Would put half-drawn regions through the + reducer and stale the preview per mouse move; a second dispatch would be + needed to discard a tiny one. One dispatch on release is smaller. +- **Resetting regions on source load.** Loses the case the issue describes — + the same stream layout across clips. Clipping costs the same one line in + `state.py` and keeps it. +- **A new oriented→widget mapping just for regions** (the review's + prescription for finding 1). It would leave the crop mispainted on + anamorphic sources, and put two transforms where the codebase has one. The + root cause is one wrong expression; fix that instead. +- **Folding the `core/crop.py` fix into this feature.** It has its own trigger + and its own repro and predates this work; a reviewer must be able to see it + alone. Scoped out as a prerequisite (Decision 2a). +- **Clipping carried regions only for display**, leaving the spec unclipped. + Avoids the frozen `state.py` line, but the first drag of a clipped region + would snap it to the clipped size — a visible jump — and the fingerprint + would hash a rectangle the user cannot see. +- **Using `clamp_crop` to fit carried regions.** It slides to preserve size + (deliberately, for issue #25); sliding an exclusion moves it onto wanted + content. +- **Catching `INVALID_FRAMING` to detect an empty mask** (the first draft). + The code also means non-RGBA, mismatched canvases and a plan mismatch, so + the catch would present a corrupt cut set as a working one (Decision 5). +- **Masking a `cut.copy()` in the render loop** (the first draft). Staging + before masking removes the copy, the extra full-resolution allocation and + the ownership-tracker question together. +- **Dispatching region drags live, like the crop.** Measured cost: one QThread + and ~12 QSettings writes per pointer sample, on a path with no debounce + (Decision 6). +- **Merging overlapping regions into a canonical cover.** Would close false + miss 2, but it is real geometry code for a cache miss nobody has measured. +- **Retaining the unmasked preview cut to re-frame locally.** Would make a + region change free for the preview, but it is a preview-caching feature in + its own right and touches frozen `state.py` far more than one line. +- **Keeping the empty-union refusal.** Zero lines, and the user can fix it — + but the untrimmed canvas is exactly what "exclude everything" means, and + the render must not abort for it. Recorded as the fork; degrade chosen. +- **A region count cap.** Nothing measured needs one; clipping bounds the + cost per region to one `paste`. From aafc4d1a27b12d641b25271db725d48838c9f746 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 08:37:11 +0200 Subject: [PATCH 03/21] =?UTF-8?q?=F0=9F=93=9D=20docs(scope):=20admit=20exc?= =?UTF-8?q?lusion=20regions=20to=20V1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 📝 Scope: - Records exclusion regions as in scope: several user-drawn rectangles over the source frame, forced to alpha 0 after segmentation. No existing setting addressed a burned-in overlay — `Crop` takes the subject with it when the overlay sits in front of the chest, and a largest-component filter was measured on a real clip to keep the overlay at one sample and delete the subject's raised hand at two others. - Records the deviation that the rectangles are a parameter carried across a source change rather than a per-source value, and that they are clipped rather than slid to each new source, so the painted and the masked rectangle are the same by construction. - 📝 G8 makes this file authoritative, so the entry lands before any implementation rather than as a tidy-up after it. Refs #80 --- docs/v1-scope.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/v1-scope.md b/docs/v1-scope.md index 9a1e461..d15f3d1 100644 --- a/docs/v1-scope.md +++ b/docs/v1-scope.md @@ -51,6 +51,7 @@ Nothing else gates V1. When that sentence is true end to end, V1 is done. | Output | Lossless animated WebP, plus the still-image single-frame case. | | Timeline | Filmstrip, playhead, IN/OUT range handles, exact time/frame readout. | | Crop | Visual rectangle with handles, plus numeric fields. | +| Exclusion regions | Several user-drawn rectangles over the source frame, forced to alpha 0 after segmentation so a burned-in overlay does not survive into the cutout. **Scope reopened 2026-09-12 (issue #80):** no setting addressed a composited chat box, alert box or a bystander at the frame edge — `Crop` removes the subject with the overlay, and a largest-component filter was measured to fail in both directions. | | Preview | `Preview Frame` through the exact render pipeline, with the stale-result contract. | | Jobs | Exclusive modal job dialog with truthful stage/progress and working cancellation. | | Accessibility | Full keyboard reachability, correct tab order, accessible names and values on **standard** widgets, no colour-only status. | @@ -77,6 +78,12 @@ Nothing else gates V1. When that sentence is true end to end, V1 is done. `Delete outdated` as the agreed handling for a rembg namespace move (issue #22). Bulk re-download returned in #29 with confirmation, cancellation, batch progress and per-model deletion after verification. +- **Exclusion regions carry across a source change, 2026-09-12:** the + rectangles are a parameter, not a per-source value, because the use case is + many clips of one stream sharing an overlay layout. They are clipped — not + slid — to each newly loaded source, so what the canvas paints and what the + renderer masks are the same rectangle by construction. Sliding, which is what + `clamp_crop` does for a crop, would move an exclusion onto wanted content. - **Cut workspace location, 2026-09-10:** durable cut sets and disposable scratch now live under MatteLoop's user cache at `/workspace/`, rather than inside From e0a049bd52a5124d25258b6316a606b9b3c2745d Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 09:20:30 +0200 Subject: [PATCH 04/21] =?UTF-8?q?=E2=9C=A8=20feat(exclusion):=20mask=20ove?= =?UTF-8?q?rlay=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ Features: - `FramingSpec.exclusions` carries user-drawn rectangles in oriented source pixels. `core/exclusion.py` is the only place that maps them: `cut_exclusions` translates by the crop origin, clips to the crop and returns a sorted, de-duplicated tuple, so a region outside the crop yields no box at all and two orderings of the same regions are the same request. `exclude_alpha` is the only place that zeroes. - The effective cut-space boxes enter the render, preview and union identities only when non-empty, so every cut set and union record written by 0.4.1 stays a byte-identical hit for a user with no regions — the update does not invalidate a single cached cut. - 🔄 Refactor: - `cached_union` replaces three checks that had drifted apart: `PreviewService._matching_union` and `RenderService._rebuild_union` compared the fingerprint and the threshold, while the UI's `_resolve_union` compared only the threshold and never read `metadata.fingerprint` at all. - `RenderService` stages each cut *before* `exclude_alpha` mutates it, so the stored set stays unmasked and reusable under any regions and no second full-resolution RGBA owner is allocated. - `_iter_rebuild_frames` and the encoder's exclusion handling live in `jobs/transform_stage.py` rather than the render orchestrator, and `stage_encoder_frames` is split into named helpers — it was 66 lines against the 60-line budget. `jobs/render.py` is unchanged at 2886 lines, so the frozen module does not grow. - 🐛 Degradation: - `union_alpha_bounds_or_none` returns `None` only for a genuinely empty mask; a non-RGBA frame or mismatched canvas sizes still raise, because `INVALID_FRAMING` covers all three and catching it would have reported corrupt frames as an empty selection. Trim then frames the untrimmed canvas and records a note instead of aborting the render. - 🧪 Tests: - `test_identities_without_exclusions_match_the_previous_schema` pins the 0.4.1 compatibility above; it fails if the exclusions key is emitted unconditionally. - `test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_ the_region` pins stage-then-mask, and `test_render_peak_rgba_owner_count_is_unchanged_by_exclusions` pins that it costs no extra owner. - `test_union_alpha_bounds_or_none_propagates_invalid_frame_errors` pins that the degradation does not swallow corrupt frames, and `test_render_still_refuses_a_trimmed_box_below_the_minimum_dimension` keeps the minimum-dimension refusal that the empty-mask change could have taken with it. - `test_cut_exclusions_is_order_independent_and_deduplicated`, `test_rebuild_with_a_region_misses_the_cached_union_and_recomputes_it` and `test_stage_encoder_frames_zeroes_excluded_boxes_before_framing` cover the remaining seam behaviour. Steps 2 and 3 of `docs/designs/exclusion-regions.md`; no UI yet. Refs #80 --- src/matteloop/core/exclusion.py | 97 +++++++++++++++++++++++++++ src/matteloop/core/fingerprints.py | 55 ++++++++++----- src/matteloop/core/specs.py | 9 +++ src/matteloop/jobs/render.py | 64 +++++++++--------- src/matteloop/jobs/transform_stage.py | 87 +++++++++++++++++++++--- tests/core/test_exclusion.py | 79 ++++++++++++++++++++++ tests/core/test_fingerprints.py | 77 +++++++++++++++++++++ tests/core/test_specs.py | 17 +++++ tests/jobs/test_preview.py | 29 +++++++- tests/jobs/test_rebuild.py | 36 ++++++++++ tests/jobs/test_render.py | 94 +++++++++++++++++++++++--- tests/jobs/test_transform_stage.py | 42 ++++++++++-- 12 files changed, 609 insertions(+), 77 deletions(-) create mode 100644 src/matteloop/core/exclusion.py create mode 100644 tests/core/test_exclusion.py diff --git a/src/matteloop/core/exclusion.py b/src/matteloop/core/exclusion.py new file mode 100644 index 0000000..7d2212b --- /dev/null +++ b/src/matteloop/core/exclusion.py @@ -0,0 +1,97 @@ +"""Map and apply post-segmentation exclusion regions. + +All cut pixels enter framing through three producers: + +* ``_produce_cut_frame`` (sites 1, 2) +* ``WorkspacePort.read_cut`` (sites 3, 4) +* ``FrameReader.read`` (sites 5, 6) + +The six consumers are: + +1. preview (``render.py:913-960``): ``exclude_alpha(cut, boxes)`` once, + right after ``_produce_cut_frame``; bounds, both ``apply_framing`` calls, + and both ``_immutable_rgba`` images see it. +2. render loop (``render.py:1108-1112``): stage first, then mask in place. +3. ``_rebuild_union`` (``render.py:1338``): ``exclude_alpha(image, boxes)`` + after ``read_cut``. +4. encoder (``render.py:1386``): ``stage_encoder_frames`` passes boxes to + ``_stage_frame``, which masks before ``apply_framing``. +5. UI facts (``ui/transform_stage.py:710-720``): ``_iter_stored_frames`` + masks before yielding. +6. result player (``ui/result_player.py:480-490``): ``FrameLoadWorker`` and + ``_load_one_frame`` mask before ``apply_framing``. + +``union_alpha_bounds_or_none`` keeps a genuinely empty alpha union distinct +from malformed or mismatched framing inputs. +""" + +from __future__ import annotations + +from collections.abc import Iterable +from decimal import Decimal + +from PIL import Image + +from matteloop.core.errors import ErrorCode, ValidationError +from matteloop.core.geometry import PixelBounds, alpha_bounds +from matteloop.core.specs import CropSpec + + +def cut_exclusions( + exclusions: tuple[CropSpec, ...], crop: CropSpec +) -> tuple[PixelBounds, ...]: + """Map oriented-source regions into the crop-sized cut, clipped and canonical.""" + boxes: set[tuple[int, int, int, int]] = set() + for region in exclusions: + left = max(region.x, crop.x) - crop.x + top = max(region.y, crop.y) - crop.y + right = min(region.x + region.width, crop.x + crop.width) - crop.x + bottom = min(region.y + region.height, crop.y + crop.height) - crop.y + if right > left and bottom > top: + boxes.add((left, top, right, bottom)) + return tuple(PixelBounds(*box) for box in sorted(boxes)) + + +def exclude_alpha(image: Image.Image, boxes: tuple[PixelBounds, ...]) -> None: + """Zero RGBA inside each box, in place.""" + for box in boxes: + image.paste((0, 0, 0, 0), (box.left, box.top, box.right, box.bottom)) + + +def union_alpha_bounds_or_none( + frames: Iterable[Image.Image], threshold_percent: Decimal | float | int +) -> PixelBounds | None: + """Return a valid alpha union, or ``None`` only when it is empty.""" + try: + iterator = iter(frames) + except TypeError: + raise ValidationError( + ErrorCode.INVALID_FRAMING, + "framing", + "framing requires an iterable of RGBA frames", + ) from None + + union: PixelBounds | None = None + expected_size: tuple[int, int] | None = None + for image in iterator: + bounds = alpha_bounds(image, threshold_percent) + if expected_size is None: + expected_size = image.size + elif image.size != expected_size: + raise ValidationError( + ErrorCode.INVALID_FRAMING, + "framing", + "all frames must have identical source canvas dimensions", + ) + if bounds is None: + continue + if union is None: + union = bounds + else: + union = PixelBounds( + min(union.left, bounds.left), + min(union.top, bounds.top), + max(union.right, bounds.right), + max(union.bottom, bounds.bottom), + ) + return union diff --git a/src/matteloop/core/fingerprints.py b/src/matteloop/core/fingerprints.py index f1cb62d..c739f68 100644 --- a/src/matteloop/core/fingerprints.py +++ b/src/matteloop/core/fingerprints.py @@ -14,6 +14,7 @@ from typing import BinaryIO, Protocol, cast from matteloop.core.errors import AppError, ErrorCode, ValidationError +from matteloop.core.exclusion import cut_exclusions from matteloop.core.specs import ( CropSpec, FramingSpec, @@ -155,7 +156,7 @@ def preview_fingerprint( "model_weight_sha256": model_weight_sha256, **_edge_settings(request), }, - "framing": _framing(request.framing), + "framing": _framing(request), "pipeline_schema_version": pipeline_schema_version, "orientation_color_version": orientation_color_version, "rembg_version": rembg_version, @@ -240,7 +241,7 @@ def render_fingerprint(request: RenderRequest, *, cut_key: str) -> str: { **_schema("render"), "cut_key": cut_key, - "framing": _framing(request.framing), + "framing": _framing(request), "max_bytes": request.output.max_bytes, } ) @@ -249,14 +250,41 @@ def render_fingerprint(request: RenderRequest, *, cut_key: str) -> str: def union_fingerprint(request: RenderRequest, *, cut_key: str) -> str: """Identify the cut bytes and threshold consumed by range-union analysis.""" request = _validated_request(request) + return cut_union_fingerprint(request.framing, request.crop, cut_key=cut_key) + + +def cut_union_fingerprint( + framing: FramingSpec, crop: CropSpec, *, cut_key: str +) -> str: + """Identify cut-union inputs, including effective exclusions when present.""" cut_key = _validated_sha256(cut_key, "cut_key") - return _canonical_hash( - { - **_schema("cut-union"), - "cut_key": cut_key, - "alpha_threshold": _canonical_decimal(request.framing.alpha_threshold), - } - ) + payload: dict[str, object] = { + **_schema("cut-union"), + "cut_key": cut_key, + "alpha_threshold": _canonical_decimal(framing.alpha_threshold), + } + boxes = cut_exclusions(framing.exclusions, crop) + if boxes: + payload["exclusions"] = [ + [box.left, box.top, box.right, box.bottom] for box in boxes + ] + return _canonical_hash(payload) + + +def _framing(request: RenderRequest) -> dict[str, object]: + framing = request.framing + payload: dict[str, object] = { + "trim": framing.trim, + "alpha_threshold": _canonical_decimal(framing.alpha_threshold), + "padding": framing.padding, + "stretch_x": _canonical_decimal(framing.stretch_x), + } + boxes = cut_exclusions(framing.exclusions, request.crop) + if boxes: + payload["exclusions"] = [ + [box.left, box.top, box.right, box.bottom] for box in boxes + ] + return payload def _update_digest( @@ -339,15 +367,6 @@ def _crop(crop: CropSpec) -> dict[str, int]: return {"x": crop.x, "y": crop.y, "width": crop.width, "height": crop.height} -def _framing(framing: FramingSpec) -> dict[str, object]: - return { - "trim": framing.trim, - "alpha_threshold": _canonical_decimal(framing.alpha_threshold), - "padding": framing.padding, - "stretch_x": _canonical_decimal(framing.stretch_x), - } - - def _edge_settings(request: RenderRequest) -> dict[str, object]: matting = request.segmentation.alpha_matting return { diff --git a/src/matteloop/core/specs.py b/src/matteloop/core/specs.py index 13746a4..18c7c3c 100644 --- a/src/matteloop/core/specs.py +++ b/src/matteloop/core/specs.py @@ -248,6 +248,7 @@ class FramingSpec: alpha_threshold: Decimal = Decimal("2.0") padding: int = 0 stretch_x: Decimal = Decimal("1.0") + exclusions: tuple[CropSpec, ...] = () def __post_init__(self) -> None: self.validate() @@ -287,6 +288,14 @@ def validate(self) -> None: "framing", "horizontal stretch must be a positive Decimal", ) + if not isinstance(self.exclusions, tuple) or any( + not isinstance(exclusion, CropSpec) for exclusion in self.exclusions + ): + raise ValidationError( + ErrorCode.INVALID_FRAMING, + "framing", + "exclusions must be a tuple of CropSpec values", + ) def validate_final_dimensions(self, width: int, height: int) -> tuple[int, int]: """Validate fixed WebP dimensions before allocation or output replacement.""" diff --git a/src/matteloop/jobs/render.py b/src/matteloop/jobs/render.py index 1dda189..6b96005 100644 --- a/src/matteloop/jobs/render.py +++ b/src/matteloop/jobs/render.py @@ -36,6 +36,11 @@ from PIL import Image from matteloop.core.errors import AppError, ErrorCode, ValidationError +from matteloop.core.exclusion import ( + cut_exclusions, + exclude_alpha, + union_alpha_bounds_or_none, +) from matteloop.core.fingerprints import ( PIPELINE_SCHEMA_VERSION, REMBG_VERSION, @@ -79,7 +84,12 @@ from matteloop.jobs.models.cache_fs import BoundDirectoryCloseError, UnsafeCacheError from matteloop.jobs.protocol import PROTOCOL_VERSION, SegmentOptions, SegmentRequest from matteloop.jobs.source import DecodedFrame, SourceInfo, decode_frame, probe_source -from matteloop.jobs.transform_stage import framing_plan, stage_encoder_frames +from matteloop.jobs.transform_stage import ( + _iter_rebuild_frames, + cached_union, + framing_plan, + stage_encoder_frames, +) from matteloop.jobs.transform_store import store_transform from matteloop.jobs.workspace import ( AdvisoryFileLock, @@ -921,6 +931,8 @@ def preview( tracker, ) try: + cut_boxes = cut_exclusions(request.framing.exclusions, request.crop) + exclude_alpha(cut, cut_boxes) local_bounds = alpha_bounds(cut, request.framing.alpha_threshold) applied_bounds: PixelBounds | None = None exact = False @@ -988,14 +1000,7 @@ def _matching_union( ) manifest = self._workspace.validate(workspace) metadata = manifest.union_metadata - if ( - metadata is None - or metadata.fingerprint != union_fingerprint(request, cut_key=cache_key) - or metadata.alpha_threshold - != _decimal_text(request.framing.alpha_threshold) - ): - return None - return PixelBounds(*metadata.bounds) + return cached_union(metadata, request.framing, request.crop, cache_key) except AppError as error: if error.code in { ErrorCode.CUT_MANIFEST_INVALID, @@ -1078,6 +1083,7 @@ def render(self, request: RenderRequest, context: JobContext) -> RenderArtifact: ) cache_key = cut_cache_key_from_inputs(inputs) tracker = RgbaOwnershipTracker((request.crop.width, request.crop.height)) + exclusions = cut_exclusions(request.framing.exclusions, request.crop) self._advisory_disk_check(request, len(timestamps), notes) context.checkpoint("cut-staging") staged = self._workspace.create_staging( @@ -1106,9 +1112,10 @@ def render(self, request: RenderRequest, context: JobContext) -> RenderArtifact: tracker, ) try: + frame_records.append(self._workspace.stage(staged, index, cut)) + exclude_alpha(cut, exclusions) bounds = alpha_bounds(cut, request.framing.alpha_threshold) union = _union_bounds(union, bounds) - frame_records.append(self._workspace.stage(staged, index, cut)) actual_pts.append(actual) finally: cut.close() @@ -1323,32 +1330,20 @@ def _rebuild_union( notes: list[str], tracker: RgbaOwnershipTracker, ) -> PixelBounds | None: - metadata = manifest.union_metadata - expected_fingerprint = union_fingerprint(request, cut_key=manifest.cache_key) - if ( - metadata is not None - and metadata.fingerprint == expected_fingerprint - and metadata.alpha_threshold - == _decimal_text(request.framing.alpha_threshold) - ): - return PixelBounds(*metadata.bounds) - union: PixelBounds | None = None - for index in range(manifest.frame_count): - context.checkpoint("rebuild-union") - image = self._workspace.read_cut(private, index, tracker) - try: - union = _union_bounds( - union, - alpha_bounds(image, request.framing.alpha_threshold), - ) - finally: - image.close() - del image + cached = cached_union( + manifest.union_metadata, request.framing, request.crop, manifest.cache_key + ) + if cached is not None: + return cached + boxes = cut_exclusions(request.framing.exclusions, request.crop) + store = self._workspace + frames = _iter_rebuild_frames(store, private, manifest, tracker, context, boxes) + union = union_alpha_bounds_or_none(frames, request.framing.alpha_threshold) if union is not None: new_metadata = CutUnionMetadata( (union.left, union.top, union.right, union.bottom), _decimal_text(request.framing.alpha_threshold), - expected_fingerprint, + union_fingerprint(request, cut_key=manifest.cache_key), ) try: won = self._workspace.compare_and_set_union( @@ -1380,9 +1375,13 @@ def _encode_snapshot( overall: tuple[int, int], rebuilt: bool, ) -> RenderArtifact: + if request.framing.trim and union is None: + notes.append("trim skipped: no pixel above the alpha threshold " + + "survives the exclusion regions") plan = framing_plan((manifest.width, manifest.height), union, request.framing) tracker.include_size(plan.output_size) scratch = private.path.parent + exclusions = cut_exclusions(request.framing.exclusions, request.crop) framed_paths, delays = stage_encoder_frames( partial(self._workspace.read_cut, private), manifest.frame_count, @@ -1393,6 +1392,7 @@ def _encode_snapshot( tracker, context, overall=overall, + exclusions=exclusions, ) candidate = self._output_publisher.candidate_path( request.output.path, context.job_id, scratch diff --git a/src/matteloop/jobs/transform_stage.py b/src/matteloop/jobs/transform_stage.py index 417a52d..f9bc40c 100644 --- a/src/matteloop/jobs/transform_stage.py +++ b/src/matteloop/jobs/transform_stage.py @@ -17,32 +17,61 @@ import dataclasses import os import tempfile -from collections.abc import Callable +from collections.abc import Callable, Iterator +from contextlib import closing from pathlib import Path +from typing import Protocol from PIL import Image from matteloop.core.crop import clamp_crop -from matteloop.core.errors import ErrorCode, ValidationError +from matteloop.core.exclusion import exclude_alpha +from matteloop.core.fingerprints import cut_union_fingerprint from matteloop.core.geometry import FramingPlan, PixelBounds, apply_framing from matteloop.core.rgba import RgbaOwnershipTracker -from matteloop.core.specs import FramingSpec, TransformSpec +from matteloop.core.specs import CropSpec, FramingSpec, TransformSpec from matteloop.core.tokens import ProgressStage from matteloop.core.transform import apply_transform from matteloop.jobs.context import JobContext from matteloop.jobs.encoding import _map_output_os_error, _output_error +from matteloop.jobs.workspace import CutManifest, CutUnionMetadata, CutWorkspace + + +class _RebuildWorkspace(Protocol): + def read_cut( + self, workspace: CutWorkspace, index: int, ownership: RgbaOwnershipTracker + ) -> Image.Image: ... + + +def cached_union( + metadata: CutUnionMetadata | None, + framing: FramingSpec, + crop: CropSpec, + cut_key: str, +) -> PixelBounds | None: + """Return cached bounds only when their effective inputs still match.""" + if metadata is None or metadata.fingerprint != cut_union_fingerprint( + framing, crop, cut_key=cut_key + ): + return None + return PixelBounds(*metadata.bounds) + + +def _iter_rebuild_frames( + workspace: _RebuildWorkspace, private: CutWorkspace, manifest: CutManifest, + tracker: RgbaOwnershipTracker, context: JobContext, boxes: tuple[PixelBounds, ...], +) -> Iterator[Image.Image]: + for index in range(manifest.frame_count): + context.checkpoint("rebuild-union") + with closing(workspace.read_cut(private, index, tracker)) as image: + exclude_alpha(image, boxes) + yield image def framing_plan( source_size: tuple[int, int], union: PixelBounds | None, framing: FramingSpec ) -> FramingPlan: """Build the one immutable ``FramingPlan`` the encoder and the player share.""" - if framing.trim and union is None: - raise ValidationError( - ErrorCode.INVALID_FRAMING, - "framing", - "range-wide alpha union contains no visible pixels at this threshold", - ) return FramingPlan( source_size, global_bounds=union if framing.trim else None, @@ -61,6 +90,8 @@ def stage_encoder_frames( tracker: RgbaOwnershipTracker, context: JobContext, overall: tuple[int, int], + *, + exclusions: tuple[PixelBounds, ...] = (), ) -> tuple[tuple[Path, ...], tuple[int, ...]]: """Frame, crop, and resize the kept cut frames and persist them. @@ -88,6 +119,31 @@ def stage_encoder_frames( raise _map_output_os_error( error, "cannot create framed input directory" ) from error + framed_paths = _stage_kept_frames( + read_cut, + frame_count, + plan, + transform, + framed_directory, + tracker, + context, + overall, + exclusions, + ) + return framed_paths, transform.select_kept(delays) + + +def _stage_kept_frames( + read_cut: Callable[[int, RgbaOwnershipTracker], Image.Image], + frame_count: int, + plan: FramingPlan, + transform: TransformSpec, + framed_directory: Path, + tracker: RgbaOwnershipTracker, + context: JobContext, + overall: tuple[int, int], + exclusions: tuple[PixelBounds, ...], +) -> tuple[Path, ...]: kept = transform.kept_range(frame_count) kept_count = len(kept) framed_paths: list[Path] = [] @@ -96,7 +152,14 @@ def stage_encoder_frames( context.checkpoint("framing") framed_paths.append( _stage_frame( - read_cut, index, position, plan, transform, framed_directory, tracker + read_cut, + index, + position, + plan, + transform, + framed_directory, + tracker, + exclusions, ) ) context.progress( @@ -107,7 +170,7 @@ def stage_encoder_frames( overall_completed=overall[0] + position + 1, overall_total=overall[1], ) - return tuple(framed_paths), transform.select_kept(delays) + return tuple(framed_paths) def _stage_frame( @@ -118,9 +181,11 @@ def _stage_frame( transform: TransformSpec, framed_directory: Path, tracker: RgbaOwnershipTracker, + exclusions: tuple[PixelBounds, ...], ) -> Path: cut = read_cut(index, tracker) try: + exclude_alpha(cut, exclusions) framed = apply_framing(cut, plan) tracker.register(framed) finally: diff --git a/tests/core/test_exclusion.py b/tests/core/test_exclusion.py new file mode 100644 index 0000000..7fa078a --- /dev/null +++ b/tests/core/test_exclusion.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +from decimal import Decimal + +import pytest +from PIL import Image + +from matteloop.core.errors import ErrorCode, ValidationError +from matteloop.core.exclusion import ( + cut_exclusions, + exclude_alpha, + union_alpha_bounds_or_none, +) +from matteloop.core.geometry import PixelBounds +from matteloop.core.specs import CropSpec + + +def test_cut_exclusions_translates_by_the_crop_origin_and_clips_to_the_crop() -> None: + crop = CropSpec(10, 20, 100, 80) + exclusions = ( + CropSpec(0, 10, 30, 30), + CropSpec(80, 60, 60, 60), + ) + + assert cut_exclusions(exclusions, crop) == ( + PixelBounds(0, 0, 20, 20), + PixelBounds(70, 40, 100, 80), + ) + + +def test_cut_exclusions_drops_a_region_outside_the_crop() -> None: + assert cut_exclusions((CropSpec(0, 0, 5, 5),), CropSpec(10, 10, 20, 20)) == () + + +def test_cut_exclusions_is_order_independent_and_deduplicated() -> None: + crop = CropSpec(10, 10, 100, 100) + first = CropSpec(40, 50, 20, 30) + second = CropSpec(20, 20, 10, 10) + + assert cut_exclusions((first, second, first), crop) == cut_exclusions( + (second, first), crop + ) + + +def test_exclude_alpha_zeroes_rgba_inside_each_box_and_nothing_else() -> None: + image = Image.new("RGBA", (6, 6), (10, 20, 30, 255)) + boxes = (PixelBounds(1, 1, 3, 3), PixelBounds(4, 0, 6, 2)) + + exclude_alpha(image, boxes) + + for y in range(6): + for x in range(6): + excluded = (1 <= x < 3 and 1 <= y < 3) or (4 <= x < 6 and y < 2) + assert image.getpixel((x, y)) == ( + (0, 0, 0, 0) if excluded else (10, 20, 30, 255) + ) + + +def test_union_alpha_bounds_or_none_returns_none_for_an_empty_mask() -> None: + image = Image.new("RGBA", (8, 8), (20, 30, 40, 0)) + + assert union_alpha_bounds_or_none((image,), Decimal("2")) is None + + +@pytest.mark.parametrize( + "frames", + [ + (Image.new("RGBA", (8, 8)), Image.new("RGBA", (9, 8))), + (Image.new("RGB", (8, 8)),), + ], + ids=["mismatched-canvases", "non-rgba-frame"], +) +def test_union_alpha_bounds_or_none_propagates_invalid_frame_errors( + frames: tuple[Image.Image, ...], +) -> None: + with pytest.raises(ValidationError) as exc: + union_alpha_bounds_or_none(frames, Decimal("2")) + + assert exc.value.code is ErrorCode.INVALID_FRAMING diff --git a/tests/core/test_fingerprints.py b/tests/core/test_fingerprints.py index 5c4ebdf..f8a11c6 100644 --- a/tests/core/test_fingerprints.py +++ b/tests/core/test_fingerprints.py @@ -18,6 +18,7 @@ complete_source_sha256, cut_cache_key, cut_cache_key_inputs, + cut_union_fingerprint, provisional_source_fingerprint, render_fingerprint, union_fingerprint, @@ -411,6 +412,82 @@ def test_union_identity_tracks_only_cut_content_and_alpha_threshold( assert union_fingerprint(new_threshold, cut_key=cut_key) != baseline +def test_render_and_preview_identity_track_effective_exclusions_only( + tmp_path: Path, +) -> None: + request = request_a(tmp_path) + outside = replace( + request, + framing=replace( + request.framing, exclusions=(CropSpec(0, 0, 1, 1),) + ), + ) + inside = replace( + request, + framing=replace( + request.framing, exclusions=(CropSpec(10, 10, 20, 20),) + ), + ) + + assert render_fingerprint(outside, cut_key="ef" * 32) == render_fingerprint( + request, cut_key="ef" * 32 + ) + assert preview_fingerprint(outside, Fraction(1, 5)) == preview_fingerprint( + request, Fraction(1, 5) + ) + assert render_fingerprint(inside, cut_key="ef" * 32) != render_fingerprint( + request, cut_key="ef" * 32 + ) + assert preview_fingerprint(inside, Fraction(1, 5)) != preview_fingerprint( + request, Fraction(1, 5) + ) + + +def test_union_identity_tracks_effective_exclusions(tmp_path: Path) -> None: + request = request_a(tmp_path) + first_region = CropSpec(10, 10, 20, 20) + second_region = CropSpec(40, 40, 10, 10) + first = replace( + request, + framing=replace( + request.framing, exclusions=(first_region, second_region) + ), + ) + reordered = replace( + request, + framing=replace( + request.framing, + exclusions=(second_region, first_region), + ), + ) + outside = replace( + request, + framing=replace( + request.framing, exclusions=(CropSpec(0, 0, 1, 1),) + ), + ) + + assert union_fingerprint(first, cut_key="ef" * 32) == union_fingerprint( + reordered, cut_key="ef" * 32 + ) + assert union_fingerprint(first, cut_key="ef" * 32) != union_fingerprint( + outside, cut_key="ef" * 32 + ) + + +def test_identities_without_exclusions_match_the_previous_schema( + tmp_path: Path, +) -> None: + request = replace(request_a(tmp_path), framing=FramingSpec()) + + assert "exclusions" not in fingerprints_module._framing(request) + assert cut_union_fingerprint( + request.framing, request.crop, cut_key="ef" * 32 + ) == ( + "8e9f72c32c74a7feb4a7bc60345c74dfeee018fd73d4864d6bbc92e5bc96fb17" + ) + + def test_render_fingerprint_distinguishes_long_exact_decimal_values( tmp_path: Path, ) -> None: diff --git a/tests/core/test_specs.py b/tests/core/test_specs.py index 805704d..5d0be86 100644 --- a/tests/core/test_specs.py +++ b/tests/core/test_specs.py @@ -136,6 +136,23 @@ def test_crop_accepts_right_and_bottom_source_edges() -> None: crop.validate_for(100, 100) +@pytest.mark.parametrize( + "exclusions", + [ + [CropSpec(0, 0, 10, 10)], + (CropSpec(0, 0, 10, 10), (0, 0, 10, 10)), + ], + ids=["not-a-tuple", "contains-a-non-crop"], +) +def test_framing_spec_rejects_exclusions_that_are_not_crop_specs( + exclusions: object, +) -> None: + with pytest.raises(ValidationError) as exc: + FramingSpec(exclusions=exclusions) # type: ignore[arg-type] + + assert exc.value.code is ErrorCode.INVALID_FRAMING + + @pytest.mark.parametrize( ("crop", "source_width", "source_height"), [ diff --git a/tests/jobs/test_preview.py b/tests/jobs/test_preview.py index 7dfc7f3..d028022 100644 --- a/tests/jobs/test_preview.py +++ b/tests/jobs/test_preview.py @@ -8,7 +8,8 @@ import pytest from matteloop.core.errors import ErrorCode, ValidationError -from matteloop.core.specs import EdgeMode, FramingSpec, SegmentationSpec +from matteloop.core.geometry import PixelBounds +from matteloop.core.specs import CropSpec, EdgeMode, FramingSpec, SegmentationSpec from matteloop.core.state import JobKind from matteloop.jobs.render import ( FilesystemWorkspacePort, @@ -73,6 +74,32 @@ def test_preview_matches_render_cut_before_global_framing(tmp_path) -> None: assert preview.pre_global_trim_rgba.tobytes() == cut.tobytes() +def test_preview_zeroes_excluded_alpha_in_the_cut_image_and_its_bounds( + tmp_path, +) -> None: + render_request = replace( + request(tmp_path), + framing=FramingSpec( + False, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ), + ) + preview = PreviewService( + source=FakeSource(), + segmentation=binding(FakeSegmenter()), + workspace=FilesystemWorkspacePort(), + clock=FakeClock(), + ).preview(render_request, Fraction(0), job(tmp_path, "excluded", JobKind.PREVIEW)) + + with preview.pre_global_trim_rgba.to_image() as cut: + assert cut.getpixel((40, 30)) == (0, 0, 0, 0) + assert cut.getpixel((65, 30)) == (0, 60, 90, 255) + assert preview.local_bounds_estimate == PixelBounds(64, 24, 96, 104) + + def test_preview_fingerprint_tracks_the_prepared_model_weight(tmp_path) -> None: request_with_same_user_settings = request(tmp_path) source = FakeSource() diff --git a/tests/jobs/test_rebuild.py b/tests/jobs/test_rebuild.py index 9ab6224..96546bc 100644 --- a/tests/jobs/test_rebuild.py +++ b/tests/jobs/test_rebuild.py @@ -459,6 +459,42 @@ def test_identity_transform_rebuild_is_byte_identical(tmp_path) -> None: assert explicit_delays == default_delays +def test_rebuild_with_a_region_misses_the_cached_union_and_recomputes_it( + tmp_path, +) -> None: + workspace = FilesystemWorkspacePort() + seed_request = replace( + request(tmp_path), + framing=FramingSpec(True, Decimal("2"), 48, Decimal("1")), + ) + original = render_service(workspace=workspace).render( + seed_request, job(tmp_path, "seed-union-region", JobKind.RENDER) + ) + rebuild_request = replace( + seed_request, + rebuild=True, + framing=FramingSpec( + True, + Decimal("2"), + 48, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ), + output=replace(seed_request.output, filename="region.webp"), + ) + + artifact = _rebuild_service(workspace, FakeEncoder()).rebuild( + rebuild_request, + original.cut_workspace, + job(tmp_path, "rebuild-union-region", JobKind.REBUILD), + ) + + assert (artifact.width, artifact.height) == (128, 176) + metadata = workspace.validate(original.cut_workspace).union_metadata + assert metadata is not None + assert metadata.bounds == (64, 24, 96, 104) + + def test_trim_keeps_exactly_the_selected_frames_and_their_delays(tmp_path) -> None: """AC 2 / E2 / T7: the kept delays are a *slice* of the full non-uniform grid, not a recomputation over the kept count.""" diff --git a/tests/jobs/test_render.py b/tests/jobs/test_render.py index 7c6ac97..fd3cceb 100644 --- a/tests/jobs/test_render.py +++ b/tests/jobs/test_render.py @@ -1519,9 +1519,90 @@ def segment(self, frame, request): assert artifact.manifest.union_metadata is not None -@pytest.mark.parametrize("visible_size", [None, 10]) -def test_invalid_range_framing_fails_after_cut_promotion_and_preserves_output( - tmp_path, visible_size: int | None +def test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_the_region( + tmp_path, +) -> None: + encoder = FakeEncoder() + render_request = replace( + request(tmp_path), + framing=FramingSpec( + False, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ), + ) + + artifact = render_service(encoder=encoder).render( + render_request, job(tmp_path, "excluded-render", JobKind.RENDER) + ) + + with artifact.cut_workspace.read_promoted_cut(0) as stored: + assert stored.getpixel((40, 30)) == (0, 60, 90, 255) + with Image.open(artifact.output_path) as output: + output.seek(0) + output.load() + assert output.getpixel((40, 30)) == (0, 0, 0, 0) + assert output.getpixel((65, 30)) == (0, 60, 90, 255) + assert artifact.manifest.union_metadata is not None + assert artifact.manifest.union_metadata.bounds == (64, 24, 96, 104) + + +def test_render_peak_rgba_owner_count_is_unchanged_by_exclusions(tmp_path) -> None: + encoder = FakeEncoder() + render_request = replace( + request(tmp_path), + framing=FramingSpec( + False, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ), + ) + + artifact = render_service(encoder=encoder).render( + render_request, job(tmp_path, "excluded-owners", JobKind.RENDER) + ) + + assert artifact.ownership_peak <= 3 + assert artifact.ownership_current == 0 + + +def test_render_with_trim_and_an_empty_mask_encodes_the_untrimmed_canvas_and_notes_it( + tmp_path, +) -> None: + render_request = replace( + request(tmp_path), + framing=FramingSpec( + True, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(0, 0, 128, 128),), + ), + ) + + artifact = render_service().render( + render_request, job(tmp_path, "empty-exclusion", JobKind.RENDER) + ) + + assert (artifact.width, artifact.height) == (128, 128) + assert artifact.manifest.union_metadata is None + assert ( + "trim skipped: no pixel above the alpha threshold survives the " + "exclusion regions" + ) in artifact.notes + with Image.open(artifact.output_path) as output: + output.seek(0) + output.load() + assert output.getpixel((64, 64)) == (0, 0, 0, 0) + + +@pytest.mark.parametrize("visible_size", [10]) +def test_render_still_refuses_a_trimmed_box_below_the_minimum_dimension( + tmp_path, visible_size: int ) -> None: class SmallOrEmptySegmenter(FakeSegmenter): def segment(self, frame, request): @@ -1544,12 +1625,7 @@ def segment(self, frame, request): render_request, job(tmp_path, "invalid-framing", JobKind.RENDER) ) - expected = ( - ErrorCode.INVALID_FRAMING - if visible_size is None - else ErrorCode.INVALID_FINAL_DIMENSIONS - ) - assert exc.value.code is expected + assert exc.value.code is ErrorCode.INVALID_FINAL_DIMENSIONS assert render_request.output.path.read_bytes() == b"old-output" durable = _only_durable_workspace(render_request.output.directory) assert FilesystemWorkspacePort().validate(durable).frame_count == 2 diff --git a/tests/jobs/test_transform_stage.py b/tests/jobs/test_transform_stage.py index 53925e5..130d0c8 100644 --- a/tests/jobs/test_transform_stage.py +++ b/tests/jobs/test_transform_stage.py @@ -6,10 +6,8 @@ from fractions import Fraction from pathlib import Path -import pytest from PIL import Image -from matteloop.core.errors import ErrorCode, ValidationError from matteloop.core.geometry import FramingPlan, PixelBounds from matteloop.core.rgba import RgbaOwnershipTracker from matteloop.core.specs import CropSpec, FramingSpec, TransformSpec @@ -31,11 +29,11 @@ def test_framing_plan_matches_direct_construction_for_the_identity_framing() -> ) -def test_framing_plan_rejects_trim_without_a_union() -> None: +def test_framing_plan_skips_trim_without_a_union() -> None: framing = FramingSpec(True, Decimal("2"), 0, Decimal("1")) - with pytest.raises(ValidationError) as exc: - framing_plan((200, 180), None, framing) - assert exc.value.code is ErrorCode.INVALID_FRAMING + assert framing_plan((200, 180), None, framing) == FramingPlan( + (200, 180), global_bounds=None, padding=0, stretch_x=Fraction(1) + ) def test_framing_plan_accepts_trim_with_a_union() -> None: @@ -98,6 +96,38 @@ def read_cut(index: int, tracker: RgbaOwnershipTracker) -> Image.Image: assert all(event.overall_total == 6 for event in events) +def test_stage_encoder_frames_zeroes_excluded_boxes_before_framing( + tmp_path: Path, +) -> None: + frame = _colour_frame((255, 0, 0, 255)) + + def read_cut(index: int, tracker: RgbaOwnershipTracker) -> Image.Image: + del index + image = frame.copy() + tracker.register(image) + return image + + tracker = RgbaOwnershipTracker((128, 128)) + paths, _ = stage_encoder_frames( + read_cut, + 1, + FramingPlan((128, 128)), + TransformSpec(), + (100,), + tmp_path / "framed-inputs", + tracker, + job(tmp_path, "excluded", JobKind.RENDER), + (0, 1), + exclusions=(PixelBounds(10, 20, 30, 40),), + ) + + with Image.open(paths[0]) as saved: + saved.load() + assert saved.getpixel((10, 20)) == (0, 0, 0, 0) + assert saved.getpixel((29, 39)) == (0, 0, 0, 0) + assert saved.getpixel((9, 20)) == (255, 0, 0, 255) + + def test_stage_encoder_frames_clamps_a_crop_stored_against_a_larger_frame( tmp_path: Path, ) -> None: From e986fda2dacad66bfbae926237a3d2fc9fca334f Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 09:39:20 +0200 Subject: [PATCH 05/21] =?UTF-8?q?=E2=9C=A8=20feat(exclusion):=20carry=20re?= =?UTF-8?q?gions=20through=20the=20UI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ Features: - `ParameterState.exclusions` with `ExclusionsChanged`, persisted under `parameters/exclusions`. The reducer compares *effective* cut-space boxes rather than raw tuples, so nudging a region that lies entirely outside the crop leaves the preview valid. - `clip_exclusions` intersects carried regions with each newly loaded source and drops those that fall outside it. Intersection, not the inward slide `clamp_crop` applies to a crop: sliding an exclusion would move it onto wanted content. After the clip, the rectangle the canvas would paint and the rectangle the renderer masks are the same one. - The Transform group and the result player now honour regions, which are consumer sites 5 and 6 of the design's six. Without site 6 the looping player would show the overlay the encoder removed. - 🐛 Defects: - `_resolve_union` accepted cached union metadata on a matching alpha threshold alone and never read `metadata.fingerprint`, while the two render-side checks read both. It now shares the single `cached_union` predicate, so the Transform group's framed size no longer trusts a union recorded under different inputs. This was wrong before exclusions existed; a region merely made it reachable. - ⚙️ Guardrails: - `core/state.py` 882 to 883 lines: the one `SourceLoaded` line that applies the clip. Raised in the baseline by hand for that entry alone rather than with `--update`, which would also have recorded unrelated drift in four modules that shrank since the baseline was written. - `ui/transform_stage.py` is 750 lines against the 800 budget. - 🧪 Tests: - `test_loading_a_smaller_source_clips_carried_regions_and_drops_those_ outside` pins the clip, and `test_moving_a_region_outside_the_crop_does_not_invalidate_the_preview` pins that the reducer compares effective boxes. - `test_facts_ignore_cached_union_metadata_whose_fingerprint_does_not_ match` fails on the previous threshold-only check. - `test_frame_load_worker_masks_exclusion_boxes_before_framing` and `test_region_change_recomputes_facts_and_reloads_player_frames_without _the_region` pin sites 5 and 6. - `test_malformed_exclusions_preference_falls_back_to_empty_regions` pins that a damaged settings value degrades instead of raising. Steps 4 and 5 of `docs/designs/exclusion-regions.md`. Regions still cannot be drawn; the canvas and its controls are steps 6 and 7. Refs #80 --- scripts/guardrails-baseline.json | 2 +- src/matteloop/core/parameters.py | 82 ++++++++++++++++++++++ src/matteloop/core/state.py | 1 + src/matteloop/ui/crop_presentation.py | 2 + src/matteloop/ui/parameter_presentation.py | 4 +- src/matteloop/ui/preferences.py | 8 +++ src/matteloop/ui/request_builder.py | 1 + src/matteloop/ui/result_player.py | 16 ++++- src/matteloop/ui/transform_stage.py | 57 +++++++++++---- tests/core/test_parameters.py | 37 ++++++++++ tests/core/test_state.py | 40 ++++++++++- tests/ui/test_parameter_persistence.py | 8 +++ tests/ui/test_parameter_presentation.py | 20 +++++- tests/ui/test_parameter_requests.py | 2 + tests/ui/test_result_player.py | 25 +++++++ tests/ui/test_transform_stage.py | 79 ++++++++++++++++++++- 16 files changed, 364 insertions(+), 20 deletions(-) diff --git a/scripts/guardrails-baseline.json b/scripts/guardrails-baseline.json index ef42f3d..4e1a9f8 100644 --- a/scripts/guardrails-baseline.json +++ b/scripts/guardrails-baseline.json @@ -4,7 +4,7 @@ "long_functions": 1 }, "src/matteloop/core/state.py": { - "lines": 882, + "lines": 883, "long_functions": 1 }, "src/matteloop/core/webp.py": { diff --git a/src/matteloop/core/parameters.py b/src/matteloop/core/parameters.py index 67dc924..55f5f7c 100644 --- a/src/matteloop/core/parameters.py +++ b/src/matteloop/core/parameters.py @@ -10,11 +10,13 @@ from typing import TYPE_CHECKING from matteloop.core.errors import ValidationError +from matteloop.core.exclusion import cut_exclusions from matteloop.core.execution_providers import ( CPU_EXECUTION_PROVIDER, is_allowed_provider, ) from matteloop.core.specs import ( + CropSpec, EdgeMode, FramingSpec, OutputSpec, @@ -56,6 +58,7 @@ class ParameterState: alpha_threshold: Decimal = Decimal("2.0") padding: int = 0 stretch_x: Decimal = Decimal("1.0") + exclusions: tuple[CropSpec, ...] = () output_directory: Path | None = None output_filename: str | None = None max_mib: Decimal = Decimal("0") @@ -74,6 +77,7 @@ def __post_init__(self) -> None: self.alpha_threshold, self.padding, self.stretch_x, + self.exclusions, ) if self.output_directory is not None and ( not isinstance(self.output_directory, Path) @@ -129,6 +133,11 @@ class StretchChanged: value: Decimal +@dataclass(frozen=True, slots=True) +class ExclusionsChanged: + exclusions: tuple[CropSpec, ...] + + @dataclass(frozen=True, slots=True) class OutputDirectoryChanged: directory: Path | None @@ -163,6 +172,7 @@ class TransformChanged: | AlphaThresholdChanged | PaddingChanged | StretchChanged + | ExclusionsChanged | OutputDirectoryChanged | OutputFilenameChanged | OutputMaxSizeChanged @@ -198,6 +208,8 @@ def reduce_parameters(state: AppState, event: ParameterEvent) -> AppState: return _reduce_cleanup_value(state, event) if isinstance(event, StretchChanged): return _reduce_cleanup_value(state, event) + if isinstance(event, ExclusionsChanged): + return _reduce_exclusions(state, event) if isinstance(event, OutputDirectoryChanged): return _reduce_output_directory(state, event) if isinstance(event, OutputFilenameChanged): @@ -222,6 +234,7 @@ def _reduce_parameters_reset(state: AppState) -> AppState: alpha_threshold=defaults.alpha_threshold, padding=defaults.padding, stretch_x=defaults.stretch_x, + exclusions=defaults.exclusions, max_mib=defaults.max_mib, ) timeline = state.timeline @@ -257,6 +270,7 @@ def _reduce_parameters_reset(state: AppState) -> AppState: (parameters.alpha_threshold, state.parameters.alpha_threshold), (parameters.padding, state.parameters.padding), (parameters.stretch_x, state.parameters.stretch_x), + (parameters.exclusions, state.parameters.exclusions), ) ): reason = PreviewInvalidationReason.CROP_CLEANUP @@ -366,6 +380,25 @@ def _reduce_cleanup_value( return _invalidate(state, updated, PreviewInvalidationReason.CROP_CLEANUP) +def _reduce_exclusions(state: AppState, event: ExclusionsChanged) -> AppState: + from matteloop.core.tokens import PreviewInvalidationReason + + if not isinstance(event.exclusions, tuple) or any( + not isinstance(exclusion, CropSpec) for exclusion in event.exclusions + ): + return state + crop = state.crop + if crop is None or cut_exclusions(event.exclusions, crop) == cut_exclusions( + state.parameters.exclusions, crop + ): + return state + return _invalidate( + state, + replace(state.parameters, exclusions=event.exclusions), + PreviewInvalidationReason.CROP_CLEANUP, + ) + + def _reduce_output_directory( state: AppState, event: OutputDirectoryChanged ) -> AppState: @@ -451,6 +484,7 @@ def parameters_from_values(values: Mapping[str, object]) -> ParameterState: stretch_x=_decimal_value( values.get("stretch_x"), defaults.stretch_x, lambda value: value > 0 ), + exclusions=_exclusions_value(values.get("exclusions"), defaults.exclusions), max_mib=_decimal_value( values.get("max_mib"), defaults.max_mib, lambda value: value >= 0 ), @@ -540,6 +574,54 @@ def _bool_value(value: object, default: bool) -> bool: return default +def _exclusions_value( + value: object, default: tuple[CropSpec, ...] +) -> tuple[CropSpec, ...]: + if value is None: + return default + if not isinstance(value, str): + return () + if not value: + return () + try: + exclusions = [] + for entry in value.split(";"): + fields = entry.split(",") + if len(fields) != 4: + return () + exclusions.append(CropSpec(*(int(field) for field in fields))) + return tuple(exclusions) + except (TypeError, ValueError, ValidationError): + return () + + +def clip_exclusions(parameters: ParameterState, source: object) -> ParameterState: + """Intersect carried regions with the newly loaded source dimensions.""" + width = getattr(source, "width", None) + height = getattr(source, "height", None) + if type(width) is not int or type(height) is not int or width < 1 or height < 1: + return parameters + clipped: list[CropSpec] = [] + for exclusion in parameters.exclusions: + right = min(exclusion.x + exclusion.width, width) + bottom = min(exclusion.y + exclusion.height, height) + if exclusion.x < width and exclusion.y < height: + clipped.append( + CropSpec( + exclusion.x, + exclusion.y, + right - exclusion.x, + bottom - exclusion.y, + ) + ) + result = tuple(clipped) + return ( + parameters + if result == parameters.exclusions + else replace(parameters, exclusions=result) + ) + + def _directory_value(value: object) -> Path | None: if not isinstance(value, (str, Path)) or not str(value): return None diff --git a/src/matteloop/core/state.py b/src/matteloop/core/state.py index 54cf23f..8925b8d 100644 --- a/src/matteloop/core/state.py +++ b/src/matteloop/core/state.py @@ -403,6 +403,7 @@ def reduce(state: AppState, event: Event) -> AppState: source_frame=event.frame, timeline=timeline_from_metadata(event.value, state.parameters.fps), crop=_crop_state.default_crop_for_source(event.value), source_error=None, + parameters=_parameters.clip_exclusions(state.parameters, event.value), focus_target=FocusTarget.PREVIEW_ACTION, ) if isinstance(event, _crop_state.CropEvent): diff --git a/src/matteloop/ui/crop_presentation.py b/src/matteloop/ui/crop_presentation.py index 023ae33..9237738 100644 --- a/src/matteloop/ui/crop_presentation.py +++ b/src/matteloop/ui/crop_presentation.py @@ -18,6 +18,7 @@ class CropPresentation: rotation: int pixel_aspect: float crop: CropSpec + exclusions: tuple[CropSpec, ...] = () def present_crop(state: AppState) -> CropPresentation | None: @@ -60,4 +61,5 @@ def present_crop(state: AppState) -> CropPresentation | None: rotation, aspect, state.crop, + state.parameters.exclusions, ) diff --git a/src/matteloop/ui/parameter_presentation.py b/src/matteloop/ui/parameter_presentation.py index 1d8d47d..a88680d 100644 --- a/src/matteloop/ui/parameter_presentation.py +++ b/src/matteloop/ui/parameter_presentation.py @@ -11,7 +11,7 @@ output_directory_for_source, output_filename_for_source, ) -from matteloop.core.specs import EdgeMode, TransformSpec +from matteloop.core.specs import CropSpec, EdgeMode, TransformSpec from matteloop.core.state import AppState, ArtifactResult @@ -25,6 +25,7 @@ class ParameterPresentation: alpha_threshold: Decimal padding: int stretch_x: Decimal + exclusions: tuple[CropSpec, ...] output_directory: Path | None output_filename: str max_mib: Decimal @@ -62,6 +63,7 @@ def present_parameters(state: AppState) -> ParameterPresentation: alpha_threshold=parameters.alpha_threshold, padding=parameters.padding, stretch_x=parameters.stretch_x, + exclusions=parameters.exclusions, output_directory=directory, output_filename=filename, max_mib=parameters.max_mib, diff --git a/src/matteloop/ui/preferences.py b/src/matteloop/ui/preferences.py index d1c5493..7401054 100644 --- a/src/matteloop/ui/preferences.py +++ b/src/matteloop/ui/preferences.py @@ -20,6 +20,7 @@ "alpha_threshold", "padding", "stretch_x", + "exclusions", "output_directory", "output_filename", "max_mib", @@ -55,6 +56,13 @@ def persist_parameters(settings: QSettings, parameters: ParameterState) -> None: ) settings.setValue(f"{_PREFIX}padding", parameters.padding) settings.setValue(f"{_PREFIX}stretch_x", str(parameters.stretch_x)) + settings.setValue( + f"{_PREFIX}exclusions", + ";".join( + ",".join(str(value) for value in (e.x, e.y, e.width, e.height)) + for e in parameters.exclusions + ), + ) if parameters.output_directory is None: settings.remove(f"{_PREFIX}output_directory") else: diff --git a/src/matteloop/ui/request_builder.py b/src/matteloop/ui/request_builder.py index 1ad5ee2..7a3e0ae 100644 --- a/src/matteloop/ui/request_builder.py +++ b/src/matteloop/ui/request_builder.py @@ -101,6 +101,7 @@ def _render_request( alpha_threshold=parameters.alpha_threshold, padding=parameters.padding, stretch_x=parameters.stretch_x, + exclusions=parameters.exclusions, ), output=OutputSpec.from_mib( output_directory_for_source(parameters, inputs.source), diff --git a/src/matteloop/ui/result_player.py b/src/matteloop/ui/result_player.py index 704dba1..55d0032 100644 --- a/src/matteloop/ui/result_player.py +++ b/src/matteloop/ui/result_player.py @@ -31,7 +31,13 @@ from PySide6.QtWidgets import QPushButton, QWidget from matteloop.core.crop import fit_crop_aspect -from matteloop.core.geometry import _MEDIA_INSET, FramingPlan, apply_framing +from matteloop.core.exclusion import exclude_alpha +from matteloop.core.geometry import ( + _MEDIA_INSET, + FramingPlan, + PixelBounds, + apply_framing, +) from matteloop.core.parameters import TransformChanged from matteloop.core.specs import CropSpec, TransformSpec from matteloop.core.transform import apply_transform @@ -393,6 +399,7 @@ def __init__( *, budget: int = PLAYER_CACHE_BUDGET_BYTES, cancelled: Callable[[], bool] = _no_cancellation, + exclusions: tuple[PixelBounds, ...] = (), ) -> None: super().__init__() self._workspace = workspace @@ -404,6 +411,7 @@ def __init__( self._generation = generation self._budget = budget self._cancelled = cancelled + self._exclusions = exclusions @Slot() def run(self) -> None: @@ -417,6 +425,7 @@ def run(self) -> None: self._delays, self._budget, self._cancelled, + exclusions=self._exclusions, ) except _FrameLoadCancelled: pass @@ -442,6 +451,8 @@ def _load_player_frames( delays: tuple[int, ...], budget: int, cancelled: Callable[[], bool] = _no_cancellation, + *, + exclusions: tuple[PixelBounds, ...] = (), ) -> PlayerFrames: frame_count = manifest.frame_count display_size, cached = _fit_budget(frame_count, plan.output_size, budget) @@ -464,6 +475,7 @@ def _load_player_frames( plan, transform, display_size, + exclusions, ) framed_images.append(framed_qimage) transformed_images.append(transformed_qimage) @@ -484,9 +496,11 @@ def _load_one_frame( plan: FramingPlan, transform: TransformSpec, display_size: tuple[int, int], + exclusions: tuple[PixelBounds, ...] = (), ) -> tuple[QImage, QImage]: cut = frame_reader.read(workspace, frame) try: + exclude_alpha(cut, exclusions) framed = apply_framing(cut, plan) finally: cut.close() diff --git a/src/matteloop/ui/transform_stage.py b/src/matteloop/ui/transform_stage.py index f8bb700..11967d5 100644 --- a/src/matteloop/ui/transform_stage.py +++ b/src/matteloop/ui/transform_stage.py @@ -17,7 +17,6 @@ import threading from collections.abc import Callable, Iterator, Mapping from dataclasses import dataclass, replace -from decimal import Decimal from itertools import count from typing import TYPE_CHECKING, Protocol, cast @@ -26,12 +25,17 @@ from PySide6.QtWidgets import QMessageBox, QWidget from matteloop.core.crop import clamp_crop -from matteloop.core.geometry import FramingPlan, PixelBounds, union_alpha_bounds +from matteloop.core.exclusion import ( + cut_exclusions, + exclude_alpha, + union_alpha_bounds_or_none, +) +from matteloop.core.geometry import FramingPlan, PixelBounds from matteloop.core.parameters import ParameterState, TransformChanged from matteloop.core.specs import CropSpec, FramingSpec, TransformSpec from matteloop.core.state import AppState from matteloop.core.timebase import webp_delays -from matteloop.jobs.transform_stage import framing_plan +from matteloop.jobs.transform_stage import cached_union, framing_plan from matteloop.jobs.transform_store import load_transform from matteloop.jobs.workspace import ( CutFrame, @@ -564,6 +568,7 @@ def _start_frame_load(self) -> None: cancel_event = threading.Event() self._frame_cancel_event = cancel_event transform = self._store.state.parameters.transform + crop = _crop_from_manifest(session.manifest) worker = FrameLoadWorker( session.workspace, session.manifest, @@ -574,6 +579,7 @@ def _start_frame_load(self) -> None: generation, budget=self._cache_budget, cancelled=cancel_event.is_set, + exclusions=cut_exclusions(self._framing.exclusions, crop), ) thread = QThread(self) worker.moveToThread(thread) @@ -644,6 +650,7 @@ def _framing_from_parameters(parameters: ParameterState) -> FramingSpec: parameters.alpha_threshold, parameters.padding, parameters.stretch_x, + parameters.exclusions, ) @@ -667,6 +674,24 @@ def _fps_from_manifest(manifest: CutManifest) -> int: return fps +def _crop_from_manifest(manifest: CutManifest) -> CropSpec: + raw_crop = manifest.cache_key_inputs["crop"] + if not isinstance(raw_crop, Mapping): + raise ValueError("manifest crop inputs are not a mapping") + x = raw_crop["x"] + y = raw_crop["y"] + width = raw_crop["width"] + height = raw_crop["height"] + if ( + type(x) is not int + or type(y) is not int + or type(width) is not int + or type(height) is not int + ): + raise ValueError("manifest crop inputs are not integers") + return CropSpec(x, y, width, height) + + def _compute_facts( session: CutSession, framing: FramingSpec, frame_reader: FrameReader, cancelled: Callable[[], bool] = lambda: False, @@ -690,32 +715,36 @@ def _compute_facts( def _resolve_union( session: CutSession, framing: FramingSpec, frame_reader: FrameReader, cancelled: Callable[[], bool] = lambda: False, -) -> PixelBounds: +) -> PixelBounds | None: + crop = _crop_from_manifest(session.manifest) metadata = ( None if session.manifest.edited else session.manifest.union_metadata ) - if metadata is not None: - try: - matches = Decimal(metadata.alpha_threshold) == framing.alpha_threshold - except ArithmeticError: - matches = False - if matches: - left, top, right, bottom = metadata.bounds - return PixelBounds(left, top, right, bottom) - return union_alpha_bounds( - _iter_stored_frames(session, frame_reader, cancelled), framing.alpha_threshold + cached = cached_union(metadata, framing, crop, session.manifest.cache_key) + if cached is not None: + return cached + return union_alpha_bounds_or_none( + _iter_stored_frames( + session, + frame_reader, + cancelled, + exclusions=cut_exclusions(framing.exclusions, crop), + ), + framing.alpha_threshold, ) def _iter_stored_frames( session: CutSession, frame_reader: FrameReader, cancelled: Callable[[], bool] = lambda: False, + *, exclusions: tuple[PixelBounds, ...] = (), ) -> Iterator[Image.Image]: for frame in session.manifest.frames: if cancelled(): raise _CutFactsCancelled image = frame_reader.read(session.workspace, frame) try: + exclude_alpha(image, exclusions) yield image finally: image.close() diff --git a/tests/core/test_parameters.py b/tests/core/test_parameters.py index b6fd827..d6f1dc4 100644 --- a/tests/core/test_parameters.py +++ b/tests/core/test_parameters.py @@ -11,6 +11,7 @@ V1_MODEL_IDS, AlphaThresholdChanged, EdgeModeChanged, + ExclusionsChanged, ExecutionProviderChanged, GlobalTrimChanged, ModelChanged, @@ -73,6 +74,7 @@ def test_parameter_defaults_match_the_v1_mapping() -> None: assert parameters.alpha_threshold == Decimal("2.0") assert parameters.padding == 0 assert parameters.stretch_x == Decimal("1.0") + assert parameters.exclusions == () assert parameters.max_mib == Decimal("0") @@ -154,6 +156,28 @@ def test_cleanup_parameter_changes_stale_the_current_preview() -> None: assert state.stale_category is PreviewInvalidationReason.CROP_CLEANUP +def test_exclusions_changed_invalidates_the_preview_as_crop_cleanup() -> None: + region = CropSpec(8, 8, 16, 16) + + changed = reduce(_current(), ExclusionsChanged((region,))) + + assert changed.parameters.exclusions == (region,) + assert changed.preview is PreviewState.STALE + assert changed.stale_category is PreviewInvalidationReason.CROP_CLEANUP + + +def test_moving_a_region_outside_the_crop_does_not_invalidate_the_preview() -> None: + state = replace( + _current(), + crop=CropSpec(32, 32, 32, 32), + parameters=replace( + _current().parameters, exclusions=(CropSpec(0, 0, 8, 8),) + ), + ) + + assert reduce(state, ExclusionsChanged((CropSpec(1, 1, 8, 8),))) is state + + def test_output_fps_changes_sampling_and_stales_the_current_preview() -> None: changed = reduce(_current(), OutputFpsChanged(90)) @@ -176,6 +200,7 @@ def test_reset_restores_inspector_parameters_and_preserves_other_state() -> None alpha_threshold=Decimal("0.4"), padding=1, stretch_x=Decimal("1.2"), + exclusions=(CropSpec(4, 5, 20, 20),), output_directory=Path("exports"), output_filename="chosen.webp", max_mib=Decimal("12.5"), @@ -207,6 +232,7 @@ def test_reset_restores_inspector_parameters_and_preserves_other_state() -> None "alpha_threshold", "padding", "stretch_x", + "exclusions", "max_mib", ): assert getattr(reset.parameters, name) == getattr(defaults, name) @@ -386,3 +412,14 @@ def test_unrelated_invalid_saved_value_does_not_reset_valid_preferences() -> Non assert parameters.fps == 60 assert parameters.alpha_threshold == Decimal("2.0") assert parameters.padding == 12 + + +def test_exclusions_settings_string_round_trips_and_malformed_entries_fall_back_to_none( +) -> None: + exclusions = (CropSpec(1, 2, 30, 40), CropSpec(50, 60, 7, 8)) + + assert parameters_from_values( + {"exclusions": "1,2,30,40;50,60,7,8"} + ).exclusions == exclusions + assert parameters_from_values({"exclusions": "1,2,30"}).exclusions == () + assert parameters_from_values({"exclusions": "1,2,3,4;bad"}).exclusions == () diff --git a/tests/core/test_state.py b/tests/core/test_state.py index 4d7314a..6ddadb0 100644 --- a/tests/core/test_state.py +++ b/tests/core/test_state.py @@ -1,9 +1,12 @@ from __future__ import annotations -from dataclasses import FrozenInstanceError, dataclass +from dataclasses import FrozenInstanceError, dataclass, replace +from fractions import Fraction import pytest +from matteloop.core.exclusion import cut_exclusions +from matteloop.core.geometry import PixelBounds from matteloop.core.parameters import TransformChanged from matteloop.core.specs import CropSpec, TransformSpec from matteloop.core.state import ( @@ -47,6 +50,14 @@ SOURCE_VALUE = "metadata" +@dataclass(frozen=True) +class SizedSource: + width: int + height: int + duration: Fraction = Fraction(2) + average_rate: Fraction = Fraction(30) + + def loading_state( *, source_id: str = SOURCE_ID, request_id: str = SOURCE_REQUEST_ID ) -> AppState: @@ -881,3 +892,30 @@ def test_loading_a_new_source_resets_the_transform_but_keeps_other_parameters() assert loading_next_source.parameters.model_id == with_transform.parameters.model_id assert loading_next_source.parameters.trim == with_transform.parameters.trim assert loading_next_source.parameters.padding == with_transform.parameters.padding + + +def test_loading_a_smaller_source_clips_carried_regions_and_drops_those_outside( +) -> None: + carried = replace( + ready_state(), + parameters=replace( + ready_state().parameters, + exclusions=( + CropSpec(60, 70, 80, 20), + CropSpec(120, 0, 10, 10), + ), + ), + ) + loading = reduce( + carried, + SourceLoadRequested(source_id="smaller", request_id="load-2"), + ) + loaded = reduce( + loading, + SourceLoaded("smaller", "load-2", SizedSource(100, 80)), + ) + + assert loaded.parameters.exclusions == (CropSpec(60, 70, 40, 10),) + assert cut_exclusions( + loaded.parameters.exclusions, CropSpec(0, 0, 100, 80) + ) == (PixelBounds(60, 70, 100, 80),) diff --git a/tests/ui/test_parameter_persistence.py b/tests/ui/test_parameter_persistence.py index ab173ee..6f0de30 100644 --- a/tests/ui/test_parameter_persistence.py +++ b/tests/ui/test_parameter_persistence.py @@ -44,6 +44,7 @@ def test_parameter_preferences_round_trip_as_qsettings_primitives() -> None: alpha_threshold=Decimal("3.5"), padding=9, stretch_x=Decimal("1.2"), + exclusions=(CropSpec(8, 9, 40, 50), CropSpec(80, 20, 10, 15)), output_directory=Path("/exports"), output_filename="last.webp", max_mib=Decimal("2.5"), @@ -88,6 +89,13 @@ def test_unavailable_saved_provider_falls_back_to_the_available_cpu_choice() -> assert actual.execution_provider == CPU_EXECUTION_PROVIDER +def test_malformed_exclusions_preference_falls_back_to_empty_regions() -> None: + settings = _settings() + settings.setValue("parameters/exclusions", "8,9,40,50;malformed") + + assert load_parameters(settings).exclusions == () + + def test_failed_provider_is_not_reintroduced_by_a_later_parameter_save() -> None: settings = _settings() store = ReducerStore( diff --git a/tests/ui/test_parameter_presentation.py b/tests/ui/test_parameter_presentation.py index f7945f2..49fee4a 100644 --- a/tests/ui/test_parameter_presentation.py +++ b/tests/ui/test_parameter_presentation.py @@ -1,6 +1,6 @@ from __future__ import annotations -from dataclasses import dataclass +from dataclasses import dataclass, replace from fractions import Fraction from pathlib import Path @@ -15,6 +15,7 @@ SourceLoadRequested, reduce, ) +from matteloop.ui.crop_presentation import present_crop from matteloop.ui.parameter_presentation import present_parameters @@ -63,3 +64,20 @@ def test_parameter_presentation_exposes_the_transform_and_last_artifact() -> Non assert presentation.transform == transform assert presentation.artifact == artifact + + +def test_parameter_and_crop_presentations_carry_exclusion_regions() -> None: + source = Path("/clips/holiday.mp4") + loading = reduce(AppState(), SourceLoadRequested("source", "load")) + ready = reduce(loading, SourceLoaded("source", "load", Metadata(source))) + region = CropSpec(10, 20, 30, 40) + state = replace( + ready, parameters=replace(ready.parameters, exclusions=(region,)) + ) + + parameter_presentation = present_parameters(state) + crop_presentation = present_crop(state) + + assert parameter_presentation.exclusions == (region,) + assert crop_presentation is not None + assert crop_presentation.exclusions == (region,) diff --git a/tests/ui/test_parameter_requests.py b/tests/ui/test_parameter_requests.py index 21c0351..7551028 100644 --- a/tests/ui/test_parameter_requests.py +++ b/tests/ui/test_parameter_requests.py @@ -32,6 +32,7 @@ def test_preview_and_render_requests_share_every_inspector_parameter() -> None: alpha_threshold=Decimal("4.5"), padding=6, stretch_x=Decimal("1.25"), + exclusions=(CropSpec(10, 20, 30, 40),), output_directory=Path("/exports"), output_filename="holiday-cut.webp", max_mib=Decimal("12.5"), @@ -52,6 +53,7 @@ def test_preview_and_render_requests_share_every_inspector_parameter() -> None: assert request.framing.alpha_threshold == parameters.alpha_threshold assert request.framing.padding == parameters.padding assert request.framing.stretch_x == parameters.stretch_x + assert request.framing.exclusions == parameters.exclusions assert request.output.path == Path("/exports/holiday-cut.webp") assert request.output.max_bytes == int(Decimal("12.5") * 1024 * 1024) assert request.transform == transform diff --git a/tests/ui/test_result_player.py b/tests/ui/test_result_player.py index 8a31fd9..6c15585 100644 --- a/tests/ui/test_result_player.py +++ b/tests/ui/test_result_player.py @@ -12,6 +12,7 @@ from matteloop.core.geometry import ( _MEDIA_INSET, CropGeometryState, + PixelBounds, RectF, SizeF, build_crop_geometry, @@ -483,6 +484,30 @@ def test_frame_load_worker_reports_unreadable_frames(tmp_path) -> None: assert failures == ["Cut frames could not be read"] +def test_frame_load_worker_masks_exclusion_boxes_before_framing(tmp_path) -> None: + artifact = _seed_cut(tmp_path, "worker-exclusions") + manifest = artifact.manifest + plan = framing_plan((manifest.width, manifest.height), None, FramingSpec()) + worker = FrameLoadWorker( + artifact.cut_workspace, + manifest, + _DirectFrameReader(), + plan, + TransformSpec(), + (100,) * manifest.frame_count, + 1, + exclusions=(PixelBounds(32, 24, 64, 104),), + ) + results: list[PlayerFrames] = [] + worker.succeeded.connect(lambda frames, _generation: results.append(frames)) + + worker.run() + + assert len(results) == 1 + assert results[0].framed[0].pixelColor(40, 30).alpha() == 0 + assert results[0].framed[0].pixelColor(65, 30).alpha() == 255 + + class _CancelAfterFirstReadReader: """Read normally, but signal cancellation once the first frame is read -- simulating a supersede that lands while the worker is mid-load.""" diff --git a/tests/ui/test_transform_stage.py b/tests/ui/test_transform_stage.py index b2e6802..b3bba82 100644 --- a/tests/ui/test_transform_stage.py +++ b/tests/ui/test_transform_stage.py @@ -15,8 +15,10 @@ import matteloop.ui.worker_thread as worker_thread_module from matteloop.core.crop_state import CropChanged +from matteloop.core.geometry import PixelBounds from matteloop.core.parameters import ( AlphaThresholdChanged, + ExclusionsChanged, GlobalTrimChanged, PaddingChanged, TransformChanged, @@ -47,7 +49,13 @@ from matteloop.ui.result_player import PlayerFrames, ResultPlayerCanvas from matteloop.ui.store import ReducerStore from matteloop.ui.transform_group import CutFacts, TransformGroup -from matteloop.ui.transform_stage import TransformStageController, _DirectFrameReader +from matteloop.ui.transform_stage import ( + CutSession, + TransformStageController, + _compute_facts, + _DirectFrameReader, + _resolve_union, +) from tests.jobs.render_support import job, render_service, request @@ -338,6 +346,75 @@ def test_padding_change_recomputes_facts_from_the_shared_framing_stage( controller.shutdown() +def test_facts_ignore_cached_union_metadata_whose_fingerprint_does_not_match( + tmp_path, qtbot +) -> None: + artifact = render_service(workspace=FilesystemWorkspacePort()).render( + request(tmp_path, framing=FramingSpec(True, Decimal("2"), 48, Decimal("1"))), + job(tmp_path, "stale-union", JobKind.RENDER), + ) + framing = FramingSpec( + True, + Decimal("2"), + 48, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ) + session = CutSession( + artifact.cut_workspace, + artifact.manifest, + artifact.manifest.cache_key_inputs["sampling"]["fps"], + ) + + union = _resolve_union(session, framing, _DirectFrameReader()) + + assert union == PixelBounds(64, 24, 96, 104) + + +def test_empty_union_degrades_to_the_untrimmed_framed_size(tmp_path, qtbot) -> None: + artifact = _seed_cut(tmp_path, "empty-union-facts") + framing = FramingSpec( + True, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(0, 0, 128, 128),), + ) + session = CutSession(artifact.cut_workspace, artifact.manifest, 15) + + facts, plan = _compute_facts(session, framing, _DirectFrameReader()) + + assert plan.global_bounds is None + assert facts.framed_size == (128, 128) + + +def test_region_change_recomputes_facts_and_reloads_player_frames_without_the_region( + tmp_path, qtbot +) -> None: + artifact = _seed_cut(tmp_path, "region-player") + store = ReducerStore(_ready_state(tmp_path / "source.mp4")) + controller = TransformStageController(store) + canvas = ResultPlayerCanvas() + qtbot.addWidget(canvas) + group = TransformGroup(lambda _event: None) + qtbot.addWidget(group) + controller.attach(group, canvas) + controller.open_artifact(artifact) + qtbot.waitUntil(lambda: canvas._frames is not None, timeout=5000) + first_frames = canvas._frames + + store.dispatch(ExclusionsChanged((CropSpec(32, 24, 32, 80),))) + + qtbot.waitUntil( + lambda: canvas._frames is not None + and canvas._frames is not first_frames + and canvas._frames.framed[0].pixelColor(40, 30).alpha() == 0, + timeout=5000, + ) + assert canvas._frames.framed[0].pixelColor(65, 30).alpha() == 255 + controller.shutdown() + + def test_facts_ready_clamps_a_crop_left_over_from_a_larger_framed_size( tmp_path, qtbot ) -> None: From b1caf0ae4c8b9a01a7573926201936afbd910fbf Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 10:09:29 +0200 Subject: [PATCH 06/21] =?UTF-8?q?=E2=9C=A8=20feat(ui):=20add=20exclusion?= =?UTF-8?q?=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ UI: - `CropCanvas.set_exclusion_edit` makes region editing a mode switch: crop mode has no region targets and region mode has no crop targets, so overlaps do not become an N×9 priority list in `build_crop_geometry`. - `mouseMoveEvent` keeps the in-progress region local; `mouseReleaseEvent` emits exactly one `ExclusionsChanged`, turning a 200-sample drag into one dispatch and one facts worker instead of 200 dispatches, threads, and about 2,400 settings writes. - Arrow keys nudge by 1 source pixel, Shift by 10, Delete/Backspace removes the selected region, and Escape abandons a drag or clears selection; `Inspector.tab_widgets` keeps Edit before Clear in the keyboard route. - `ExclusionControls` keeps Edit, Clear, and the textual `%n region(s)` count in the inspector. The visible Edit label brings the row minimum to 122 px for the 322 px viewport while descriptive accessible names, tooltip, and count text remain intact. - 🧪 Tests: - `test_a_region_drag_dispatches_exactly_once_on_release` pins no command during 20 moves and one command on release; the rubber-band, 8×8 discard, mode isolation, selection, move, delete, keyboard, exit, and accessible-bounds tests pin the remaining canvas affordances. - `test_exclusion_controls_toggle_edit_mode_and_clear_regions` pins the three controls, their accessible names, the tooltip, clear behavior, and disabled state while editing is unavailable. - 🌐 Catalogues: - `pyside6-lupdate` extracted 535 source texts in both catalogues; `pyside6-lrelease` reports 535 finished and 0 unfinished for English and German, with `Edit` written as `Bearbeiten` in German. Refs #80 --- resources/matteloop_de.qm | Bin 69633 -> 70362 bytes resources/matteloop_de.ts | 189 ++++++++----- resources/matteloop_en.qm | Bin 61703 -> 62388 bytes resources/matteloop_en.ts | 189 ++++++++----- scripts/guardrails-baseline.json | 2 +- src/matteloop/ui/copy.py | 1 + src/matteloop/ui/crop_canvas.py | 370 ++++++++++++++++++++++++- src/matteloop/ui/exclusion_controls.py | 76 +++++ src/matteloop/ui/inspector.py | 7 + src/matteloop/ui/main_window.py | 3 + tests/ui/test_crop_canvas.py | 255 ++++++++++++++++- tests/ui/test_parameter_inspector.py | 37 ++- 12 files changed, 962 insertions(+), 167 deletions(-) create mode 100644 src/matteloop/ui/exclusion_controls.py diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index 9ea45c2a78cbcd445881a0ed63c855a3be88d98f..2e5f75703eda3d49deccff8f121cf5dc93c39074 100644 GIT binary patch delta 4864 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 Rf0Wk$qvJbrxwfA^{}*;$x�K delta 4324 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 CropCanvas - + Original video frame Original-Videobild - + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels + Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel + + + Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s Zuschnittgrenzen: x %s, y %s, Breite %s, Höhe %s Quellpixel; Quelle %s × %s + + ExclusionControls + + + + %n region(s) + + %n Region + %n Regionen + + + Inspector @@ -69,29 +86,29 @@ - - + + X X - - + + Y Y - - + + Width Breite - - + + Height Höhe @@ -118,31 +135,31 @@ - + Edge treatment Kantenbehandlung - + Output FPS Ausgabe-FPS - + Start Start - + End Ende - + Duration Dauer @@ -158,60 +175,65 @@ - + Horizontal stretch Horizontale Streckung + Exclusions + Ausschlussregionen + + + Directory Ordner - + Filename Dateiname - + Maximum size Maximale Größe - + Processing settings Verarbeitungseinstellungen - + Retry Rebuild Neuaufbau wiederholen - + Edited cut recovery Wiederherstellung bearbeiteter Schnitte - + Edited cut frames could not be validated. Retry the rebuild scan. Bearbeitete Schnittbilder konnten nicht validiert werden. Wiederholen Sie die Neuaufbauprüfung. - - + + Rebuild from edited cuts Aus bearbeiteten Schnitten neu aufbauen - - + + Manage Models… Modelle verwalten… - - + + Manage Workspaces… Arbeitsbereiche verwalten… @@ -231,173 +253,190 @@ Beschleunigung, Transformation, Ausgabeordner und Dateiname bleiben unverändert. - + Segmentation model Segmentierungsmodell - + cached locally lokal zwischengespeichert - + not cached yet noch nicht zwischengespeichert - + Model status Modellstatus - + Model download Modelldownload - + Standard Standard - + Decontaminate colors Farben bereinigen - + fps FPS - + High output FPS may increase render cost Hohe Ausgabe-FPS können den Renderaufwand erhöhen - + Output FPS cost warning Warnung zum Aufwand der Ausgabe-FPS - + Global trim Globaler Randbeschnitt - + Global alpha trim Globaler Alpha-Beschnitt - + Padding pixels Randpixel - + Output directory Ausgabeordner - + Choose… Auswählen… - + Choose output directory Ausgabeordner auswählen - + + Edit + Bearbeiten + + + + + Edit exclusion regions + Ausschlussregionen bearbeiten + + + + Clear Zurücksetzen - + + Clear exclusion regions + Ausschlussregionen löschen + + + Clear output directory Ausgabeordner zurücksetzen - + Output filename Ausgabedateiname - - + + Use one non-empty filename ending in .webp; path separators are not allowed. Verwenden Sie einen einzelnen, nicht leeren Dateinamen mit der Endung .webp; Pfadtrenner sind nicht erlaubt. - + Maximum file size Maximale Dateigröße - + Unlimited Unbegrenzt - + MiB MiB - + Unlimited means no maximum file size. Unbegrenzt bedeutet: Es gibt keine maximale Dateigröße. - + %s — %s download required %s — %s Download erforderlich - + Filename must be a single non-empty .webp filename. Der Dateiname muss ein einzelner, nicht leerer .webp-Dateiname sein. - + s s - + Crop Zuschnitt - + Crop overlay Zuschnitt-Overlay - + Reset Crop Zuschnitt zurücksetzen - + Reset crop Zuschnitt zurücksetzen - + Crop %s Zuschnitt %s - + Model status: %s Modellstatus: %s - + Open a video to manage its workspaces. Öffnen Sie ein Video, um dessen Arbeitsbereiche zu verwalten. @@ -448,7 +487,7 @@ Ordner öffnen - + Segmentation is unavailable because ONNX Runtime could not enumerate any providers. Repair the installation with: %1 Segmentierung ist nicht verfügbar, weil ONNX Runtime keine Provider ermitteln konnte. Reparieren Sie die Installation mit: %1 @@ -1883,39 +1922,39 @@ Freed %s. ResultPlayerCanvas - + Result Ergebnis - - + + Play Wiedergeben - - + + Play the result loop Ergebniswiedergabe abspielen - + Pause Pause - + Pause the result loop Ergebniswiedergabe pausieren - + Previewing the first %s of %s frames Die ersten %s von %s Bildern werden in der Vorschau angezeigt - + Cut frames could not be read Schnittbilder konnten nicht gelesen werden @@ -2510,12 +2549,12 @@ Freed %s. TransformStage - + Discard unsaved transform changes? Ungespeicherte Transformationsänderungen verwerfen? - + The current cut has unsaved transform changes. Discard them and continue? Das aktuelle Schnittset enthält ungespeicherte Transformationsänderungen. Sollen sie verworfen und fortgefahren werden? diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index 38ce644c187f16d2b45806f223b0e090e9d193ab..15416c5e8ce5bf98b5efc675a1f9c3dc8b0a7e44 100644 GIT binary patch delta 4884 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 CropCanvas - + Original video frame Original video frame - + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels + + + Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s + + ExclusionControls + + + + %n region(s) + + %n region + %n regions + + + Inspector @@ -69,29 +86,29 @@ - - + + X X - - + + Y Y - - + + Width Width - - + + Height Height @@ -118,31 +135,31 @@ - + Edge treatment Edge treatment - + Output FPS Output FPS - + Start Start - + End End - + Duration Duration @@ -158,60 +175,65 @@ - + Horizontal stretch Horizontal stretch + Exclusions + Exclusions + + + Directory Directory - + Filename Filename - + Maximum size Maximum size - + Processing settings Processing settings - + Retry Rebuild Retry Rebuild - + Edited cut recovery Edited cut recovery - + Edited cut frames could not be validated. Retry the rebuild scan. Edited cut frames could not be validated. Retry the rebuild scan. - - + + Rebuild from edited cuts Rebuild from edited cuts - - + + Manage Models… Manage Models… - - + + Manage Workspaces… Manage Workspaces… @@ -231,173 +253,190 @@ Compute acceleration, transform, output directory, and output filename are not affected. - + Segmentation model Segmentation model - + cached locally cached locally - + not cached yet not cached yet - + Model status Model status - + Model download Model download - + Standard Standard - + Decontaminate colors Decontaminate colors - + fps fps - + High output FPS may increase render cost High output FPS may increase render cost - + Output FPS cost warning Output FPS cost warning - + Global trim Global trim - + Global alpha trim Global alpha trim - + Padding pixels Padding pixels - + Output directory Output directory - + Choose… Choose… - + Choose output directory Choose output directory - + + Edit + Edit + + + + + Edit exclusion regions + Edit exclusion regions + + + + Clear Clear - + + Clear exclusion regions + Clear exclusion regions + + + Clear output directory Clear output directory - + Output filename Output filename - - + + Use one non-empty filename ending in .webp; path separators are not allowed. Use one non-empty filename ending in .webp; path separators are not allowed. - + Maximum file size Maximum file size - + Unlimited Unlimited - + MiB MiB - + Unlimited means no maximum file size. Unlimited means no maximum file size. - + %s — %s download required %s — %s download required - + Filename must be a single non-empty .webp filename. Filename must be a single non-empty .webp filename. - + s s - + Crop Crop - + Crop overlay Crop overlay - + Reset Crop Reset Crop - + Reset crop Reset crop - + Crop %s Crop %s - + Model status: %s Model status: %s - + Open a video to manage its workspaces. Open a video to manage its workspaces. @@ -448,7 +487,7 @@ Open folder - + Segmentation is unavailable because ONNX Runtime could not enumerate any providers. Repair the installation with: %1 Segmentation is unavailable because ONNX Runtime could not enumerate any providers. Repair the installation with: %1 @@ -1883,39 +1922,39 @@ Freed %s. ResultPlayerCanvas - + Result Result - - + + Play Play - - + + Play the result loop Play the result loop - + Pause Pause - + Pause the result loop Pause the result loop - + Previewing the first %s of %s frames Previewing the first %s of %s frames - + Cut frames could not be read Cut frames could not be read @@ -2510,12 +2549,12 @@ Freed %s. TransformStage - + Discard unsaved transform changes? Discard unsaved transform changes? - + The current cut has unsaved transform changes. Discard them and continue? The current cut has unsaved transform changes. Discard them and continue? diff --git a/scripts/guardrails-baseline.json b/scripts/guardrails-baseline.json index 4e1a9f8..bf1087a 100644 --- a/scripts/guardrails-baseline.json +++ b/scripts/guardrails-baseline.json @@ -88,7 +88,7 @@ "long_functions": 1 }, "src/matteloop/ui/inspector.py": { - "lines": 897, + "lines": 904, "long_functions": 0 }, "src/matteloop/ui/timeline.py": { diff --git a/src/matteloop/ui/copy.py b/src/matteloop/ui/copy.py index a17b9bd..d585ffe 100644 --- a/src/matteloop/ui/copy.py +++ b/src/matteloop/ui/copy.py @@ -643,6 +643,7 @@ def inspector_label(value: str) -> str: "Horizontal stretch": QCoreApplication.translate( "Inspector", "Horizontal stretch" ), + "Exclusions": QCoreApplication.translate("Inspector", "Exclusions"), "Directory": QCoreApplication.translate("Inspector", "Directory"), "Filename": QCoreApplication.translate("Inspector", "Filename"), "Maximum size": QCoreApplication.translate("Inspector", "Maximum size"), diff --git a/src/matteloop/ui/crop_canvas.py b/src/matteloop/ui/crop_canvas.py index 75e915b..fc1482f 100644 --- a/src/matteloop/ui/crop_canvas.py +++ b/src/matteloop/ui/crop_canvas.py @@ -25,6 +25,7 @@ SizeF, build_crop_geometry, ) +from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec from matteloop.ui.crop_presentation import CropPresentation from matteloop.ui.preview_canvas import PreviewCanvas @@ -67,6 +68,25 @@ def __init__( self._dragged: str | None = None self._drag_start = PointF(0, 0) self._drag_crop: CropPresentation | None = None + self._exclusion_edit = False + self._selected_exclusion: int | None = None + self._drag_exclusion: int | None = None + self._drag_origin_region: CropSpec | None = None + self._drag_region: CropSpec | None = None + self._rubber_start: PointF | None = None + self._rubber_current: PointF | None = None + + def set_exclusion_edit(self, enabled: bool) -> None: + """Toggle the mutually exclusive exclusion-region editing mode.""" + if self._exclusion_edit == enabled: + return + self._exclusion_edit = enabled + self._clear_exclusion_selection() + self._clear_gesture() + self._focused_target = "crop" + self._rebuild_geometry() + self._announce_crop() + self.update() def set_presentation( self, @@ -88,28 +108,46 @@ def apply_presentation( self._active = active self._editable = editable if presentation is None: + self._clear_exclusion_selection() + self._clear_gesture() self._geometry = None self.setAccessibleDescription( QCoreApplication.translate("CropCanvas", "Original video frame") ) else: + if self._selected_exclusion is not None and ( + self._selected_exclusion >= len(presentation.exclusions) + ): + self._clear_exclusion_selection() self._rebuild_geometry() self._announce_crop() self.update() def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] super().paintEvent(event) - if not self._active or self._geometry is None: + if not self._active or self._geometry is None or self._presentation is None: return geometry = self._geometry transform = geometry.transform if not isinstance(transform, MediaTransform): return content = transform.content_rect - crop = _qt_rect(geometry.visual["crop"]) + crop = self._widget_rect(geometry, self._presentation.crop) overlay = QColor(CANVAS_COLOR) overlay.setAlpha(105) painter = QPainter(self) + self._paint_crop_mask(painter, content, crop, overlay) + self._paint_exclusions(painter, geometry) + self._paint_crop_outline(painter, crop) + if not self._exclusion_edit or self._selected_exclusion is not None: + self._paint_handles(painter, geometry) + self._paint_focus_ring(painter, geometry) + painter.end() + + @staticmethod + def _paint_crop_mask( + painter: QPainter, content: RectF, crop: QRectF, overlay: QColor + ) -> None: painter.fillRect( QRectF(content.x, content.y, content.width, crop.top() - content.y), overlay, @@ -136,19 +174,47 @@ def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] ), overlay, ) - painter.setPen(QPen(QColor(ACCENT_COLOR), 2)) + + def _paint_exclusions( + self, painter: QPainter, geometry: InteractionGeometry + ) -> None: + fill = QColor("#E5484D") + fill.setAlpha(90) + painter.setPen(QPen(QColor("#E5484D"), 1)) + painter.setBrush(fill) + for exclusion in self._painted_exclusions(): + painter.drawRect(self._widget_rect(geometry, exclusion)) + + def _paint_crop_outline(self, painter: QPainter, crop: QRectF) -> None: + color = QColor(ACCENT_COLOR) + if self._exclusion_edit: + color.setAlpha(135) + painter.setBrush(Qt.BrushStyle.NoBrush) + painter.setPen(QPen(color, 2 if not self._exclusion_edit else 1)) painter.drawRect(crop) + + @staticmethod + def _paint_handles( + painter: QPainter, geometry: InteractionGeometry + ) -> None: painter.setPen(Qt.PenStyle.NoPen) painter.setBrush(QColor(ACCENT_COLOR)) for name in _HANDLE_NAMES: painter.drawRect(_qt_rect(geometry.visual[name])) - if self.hasFocus(): - focused = geometry.focus.get(self._focused_target) - if focused is not None: - painter.setBrush(Qt.BrushStyle.NoBrush) - painter.setPen(QPen(QColor(TEXT_COLOR), 1, Qt.PenStyle.DashLine)) - painter.drawRect(_qt_rect(focused).adjusted(-3, -3, 3, 3)) - painter.end() + + def _paint_focus_ring( + self, painter: QPainter, geometry: InteractionGeometry + ) -> None: + if not self.hasFocus(): + return + focused = geometry.focus.get(self._focused_target) + if focused is None or ( + self._exclusion_edit and self._selected_exclusion is None + ): + return + painter.setBrush(Qt.BrushStyle.NoBrush) + painter.setPen(QPen(QColor(TEXT_COLOR), 1, Qt.PenStyle.DashLine)) + painter.drawRect(_qt_rect(focused).adjusted(-3, -3, 3, 3)) def mousePressEvent(self, event: QMouseEvent) -> None: if ( @@ -163,6 +229,10 @@ def mousePressEvent(self, event: QMouseEvent) -> None: super().mousePressEvent(event) return position = PointF(event.position().x(), event.position().y()) + if self._exclusion_edit: + self._press_exclusion(position) + event.accept() + return target = geometry.hit_test(position) if target not in {"crop", *_HANDLE_NAMES} or self._presentation is None: super().mousePressEvent(event) @@ -182,33 +252,73 @@ def mouseMoveEvent(self, event: QMouseEvent) -> None: and self._active and event.buttons() & Qt.MouseButton.LeftButton ): - self._emit_drag(event.position()) + if self._exclusion_edit: + self._emit_exclusion_drag(event.position()) + else: + self._emit_drag(event.position()) + event.accept() + return + if ( + self._exclusion_edit + and self._rubber_start is not None + and event.buttons() & Qt.MouseButton.LeftButton + ): + self._rubber_current = self._oriented_position(event.position()) + self.update() event.accept() return super().mouseMoveEvent(event) def mouseReleaseEvent(self, event: QMouseEvent) -> None: if event.button() == Qt.MouseButton.LeftButton and self._dragged is not None: + if self._exclusion_edit: + self._finish_exclusion_drag() + event.accept() + return self._dragged = None self._drag_crop = None self._rebuild_geometry() self._announce_crop() event.accept() return + if ( + event.button() == Qt.MouseButton.LeftButton + and self._exclusion_edit + and self._rubber_start is not None + ): + self._finish_rubber_band() + event.accept() + return super().mouseReleaseEvent(event) def keyPressEvent(self, event: QKeyEvent) -> None: if not self._editable or not self._active or not self.hasFocus(): super().keyPressEvent(event) return + if self._exclusion_edit: + if event.key() in {int(Qt.Key.Key_Delete), int(Qt.Key.Key_Backspace)}: + self._delete_selected_exclusion(event) + return + if event.key() == int(Qt.Key.Key_Escape): + self._clear_exclusion_selection() + self._clear_gesture() + self._rebuild_geometry() + self._announce_crop() + self.update() + event.accept() + return + if self._selected_exclusion is None: + super().keyPressEvent(event) + return delta = _key_delta(event) if delta is None or self._presentation is None: super().keyPressEvent(event) return step = 10 if event.modifiers() & Qt.KeyboardModifier.ShiftModifier else 1 + edited = self._edited_rect() try: crop = nudge_crop( - self._presentation.crop, + edited, self._focused_target, dx=delta[0] * step, dy=delta[1] * step, @@ -258,6 +368,211 @@ def _emit_drag(self, position: QPointF) -> None: if self._presentation is None or crop != self._presentation.crop: self.command_requested.emit(self._crop_event(crop)) + def _press_exclusion(self, position: PointF) -> None: + if self._presentation is None or self._geometry is None: + return + selected = self._selected_exclusion + if selected is not None: + target = self._geometry.hit_test(position) + if target in {"crop", *_HANDLE_NAMES}: + self._begin_exclusion_drag(selected, target, position) + return + oriented = self._oriented_position(position) + for index in range(len(self._presentation.exclusions) - 1, -1, -1): + if index == selected: + continue + if _contains(self._presentation.exclusions[index], oriented): + self._selected_exclusion = index + self._focused_target = "crop" + self._announce_crop() + self._begin_exclusion_drag(index, "crop", position) + return + self._clear_gesture() + self._rubber_start = self._clamp_oriented(oriented) + self._rubber_current = self._rubber_start + self.setFocus(Qt.FocusReason.MouseFocusReason) + self.update() + + def _begin_exclusion_drag( + self, index: int, target: str, position: PointF + ) -> None: + if self._presentation is None or self._geometry is None: + return + self._drag_exclusion = index + self._drag_origin_region = self._presentation.exclusions[index] + self._drag_region = self._drag_origin_region + self._dragged = target + self._drag_start = self._oriented_position(position) + self.setFocus(Qt.FocusReason.MouseFocusReason) + self._rebuild_geometry(focused=target, dragged=target) + self.update() + + def _emit_exclusion_drag(self, position: QPointF) -> None: + if ( + self._geometry is None + or self._drag_origin_region is None + or self._dragged is None + ): + return + current = self._oriented_position(position) + region = crop_from_drag( + self._drag_origin_region, + self._dragged, + self._drag_start, + current, + source_width=self._presentation.width if self._presentation else 1, + source_height=self._presentation.height if self._presentation else 1, + ) + region = self._constrain(region, self._dragged) + if region == self._drag_region: + return + self._drag_region = region + self._rebuild_geometry(focused=self._dragged, dragged=self._dragged) + self._announce_crop() + self.update() + + def _finish_exclusion_drag(self) -> None: + index = self._drag_exclusion + region = self._drag_region + original = ( + self._presentation.exclusions[index] + if self._presentation is not None + and index is not None + and index < len(self._presentation.exclusions) + else None + ) + self._clear_gesture() + if index is not None and region is not None: + self._selected_exclusion = index + if region != original: + self.command_requested.emit(self._exclusion_event(region)) + self._rebuild_geometry() + self._announce_crop() + self.update() + + def _finish_rubber_band(self) -> None: + region = self._rubber_region() + self._clear_gesture() + if ( + region is not None + and region.width >= 8 + and region.height >= 8 + and self._presentation is not None + ): + self._selected_exclusion = len(self._presentation.exclusions) + self.command_requested.emit(self._exclusion_event(region)) + self._rebuild_geometry() + self._announce_crop() + self.update() + + def _delete_selected_exclusion(self, event: QKeyEvent) -> None: + index = self._selected_exclusion + if self._presentation is None or index is None: + super().keyPressEvent(event) + return + current = self._presentation.exclusions + exclusions = current[:index] + current[index + 1 :] + self._clear_exclusion_selection() + self._clear_gesture() + self.command_requested.emit(ExclusionsChanged(exclusions)) + self._rebuild_geometry() + self._announce_crop() + self.update() + event.accept() + + def _exclusion_event(self, region: CropSpec) -> ExclusionsChanged: + if self._presentation is None or self._selected_exclusion is None: + return ExclusionsChanged((region,)) + exclusions = list(self._presentation.exclusions) + if self._selected_exclusion == len(exclusions): + exclusions.append(region) + else: + exclusions[self._selected_exclusion] = region + return ExclusionsChanged(tuple(exclusions)) + + def _oriented_position(self, position: QPointF | PointF) -> PointF: + if self._geometry is None: + return PointF(0, 0) + point = ( + position + if isinstance(position, PointF) + else PointF(position.x(), position.y()) + ) + return oriented_point_from_widget(self._geometry, point) + + def _clamp_oriented(self, point: PointF) -> PointF: + if self._presentation is None: + return point + return PointF( + min(max(point.x, 0), self._presentation.width), + min(max(point.y, 0), self._presentation.height), + ) + + def _rubber_region(self) -> CropSpec | None: + if self._rubber_start is None or self._rubber_current is None: + return None + start = self._clamp_oriented(self._rubber_start) + current = self._clamp_oriented(self._rubber_current) + left, right = sorted((round(start.x), round(current.x))) + top, bottom = sorted((round(start.y), round(current.y))) + if right <= left or bottom <= top: + return None + return CropSpec(left, top, right - left, bottom - top) + + def _clear_gesture(self) -> None: + self._dragged = None + self._drag_crop = None + self._drag_exclusion = None + self._drag_origin_region = None + self._drag_region = None + self._rubber_start = None + self._rubber_current = None + + def _clear_exclusion_selection(self) -> None: + self._selected_exclusion = None + + def _painted_exclusions(self) -> tuple[CropSpec, ...]: + if self._presentation is None: + return () + exclusions = list(self._presentation.exclusions) + if ( + self._drag_exclusion is not None + and self._drag_region is not None + and self._drag_exclusion < len(exclusions) + ): + exclusions[self._drag_exclusion] = self._drag_region + rubber = self._rubber_region() + if rubber is not None: + exclusions.append(rubber) + return tuple(exclusions) + + def _edited_rect(self) -> CropSpec: + if self._presentation is None or not self._exclusion_edit: + return ( + self._presentation.crop + if self._presentation is not None + else CropSpec(0, 0, 1, 1) + ) + index = self._selected_exclusion + if index is None or index >= len(self._presentation.exclusions): + return self._presentation.crop + return self._drag_region or self._presentation.exclusions[index] + + def _widget_rect( + self, geometry: InteractionGeometry, rect: CropSpec + ) -> QRectF: + presentation = self._presentation + if presentation is None or not isinstance(geometry.transform, MediaTransform): + return QRectF() + raw = oriented_rect_to_source_rect( + rect, + source_width=presentation.coded_width, + source_height=presentation.coded_height, + rotation=presentation.rotation, + pixel_aspect=presentation.pixel_aspect, + ) + return _qt_rect(geometry.transform.source_rect_to_widget(raw)) + def _constrain(self, crop: CropSpec, target: str) -> CropSpec: """Re-fit a candidate crop before it is compared/emitted. @@ -275,6 +590,8 @@ def _crop_event(self, crop: CropSpec) -> object: keeps an arrow-key nudge on the result canvas from dispatching a *source* crop change (edge case E30). """ + if self._exclusion_edit: + return self._exclusion_event(crop) return CropChanged(crop) def _rebuild_geometry( @@ -286,7 +603,7 @@ def _rebuild_geometry( return try: raw_crop = oriented_rect_to_source_rect( - presentation.crop, + self._edited_rect(), source_width=presentation.coded_width, source_height=presentation.coded_height, rotation=presentation.rotation, @@ -328,7 +645,25 @@ def _announce_crop(self) -> None: presentation = self._presentation if presentation is None: return - crop = presentation.crop + crop = self._edited_rect() + if self._exclusion_edit and self._selected_exclusion is not None: + text = QCoreApplication.translate( + "CropCanvas", + "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " + "source pixels", + ) + values = ( + self._selected_exclusion + 1, + len(presentation.exclusions), + crop.x, + crop.y, + crop.width, + crop.height, + ) + for number, value in enumerate(values, start=1): + text = text.replace(f"%{number}", str(value)) + self.setAccessibleDescription(text) + return self.setAccessibleDescription( QCoreApplication.translate( "CropCanvas", @@ -357,3 +692,10 @@ def _key_delta(event: QKeyEvent) -> tuple[int, int] | None: def _qt_rect(rect: RectF) -> QRectF: return QRectF(rect.x, rect.y, rect.width, rect.height) + + +def _contains(region: CropSpec, point: PointF) -> bool: + return ( + region.x <= point.x < region.x + region.width + and region.y <= point.y < region.y + region.height + ) diff --git a/src/matteloop/ui/exclusion_controls.py b/src/matteloop/ui/exclusion_controls.py new file mode 100644 index 0000000..e23f675 --- /dev/null +++ b/src/matteloop/ui/exclusion_controls.py @@ -0,0 +1,76 @@ +"""Inspector controls for the source-frame exclusion-region editor.""" + +from __future__ import annotations + +from PySide6.QtCore import QCoreApplication, Signal +from PySide6.QtWidgets import QHBoxLayout, QLabel, QToolButton, QWidget + +from matteloop.core.parameters import ExclusionsChanged +from matteloop.ui.compact_widgets import compact_field +from matteloop.ui.parameter_presentation import ParameterPresentation + + +class ExclusionControls(QWidget): + """Small, reducer-facing control row for exclusion regions.""" + + edit_toggled = Signal(bool) + command_requested = Signal(object) + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + self.setObjectName("exclusion_controls") + self._build_widgets() + self._build_layout() + self.edit_button.toggled.connect(self.edit_toggled) + self.clear_button.clicked.connect( + lambda: self.command_requested.emit(ExclusionsChanged(())) + ) + + def apply(self, presentation: ParameterPresentation, editable: bool) -> None: + """Render the region count and current source editability.""" + count = len(presentation.exclusions) + count_text = self.tr("%n region(s)", "", count) + self.count_label.setText(count_text) + self.count_label.setAccessibleDescription(count_text) + available = editable and presentation.duration is not None + self.edit_button.setEnabled(available) + self.clear_button.setEnabled(available and count > 0) + if not available and self.edit_button.isChecked(): + self.edit_button.setChecked(False) + + def tab_widgets(self) -> tuple[QWidget, ...]: + """Return the row's keyboard controls in visual order.""" + return (self.edit_button, self.clear_button) + + def _build_widgets(self) -> None: + self.edit_button = QToolButton() + self.edit_button.setObjectName("exclusion_edit") + self.edit_button.setCheckable(True) + self.edit_button.setText(QCoreApplication.translate("Inspector", "Edit")) + self.edit_button.setAccessibleName( + QCoreApplication.translate("Inspector", "Edit exclusion regions") + ) + self.edit_button.setToolTip( + QCoreApplication.translate("Inspector", "Edit exclusion regions") + ) + self.clear_button = QToolButton() + self.clear_button.setObjectName("exclusion_clear") + self.clear_button.setText(QCoreApplication.translate("Inspector", "Clear")) + self.clear_button.setAccessibleName( + QCoreApplication.translate("Inspector", "Clear exclusion regions") + ) + self.count_label = compact_field(QLabel()) + self.count_label.setObjectName("exclusion_count") + self.count_label.setProperty("secondary", True) + self.count_label.setText(self.tr("%n region(s)", "", 0)) + self.count_label.setAccessibleDescription(self.count_label.text()) + self.edit_button.setEnabled(False) + self.clear_button.setEnabled(False) + + def _build_layout(self) -> None: + layout = QHBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.setSpacing(8) + layout.addWidget(self.edit_button) + layout.addWidget(self.clear_button) + layout.addWidget(self.count_label, 1) diff --git a/src/matteloop/ui/inspector.py b/src/matteloop/ui/inspector.py index 44f7728..6d8b724 100644 --- a/src/matteloop/ui/inspector.py +++ b/src/matteloop/ui/inspector.py @@ -64,6 +64,7 @@ section_title, ) from matteloop.ui.crop_presentation import CropPresentation +from matteloop.ui.exclusion_controls import ExclusionControls from matteloop.ui.inspector_disclosure import configure_disclosure, read_bool from matteloop.ui.inspector_reset import action_availability, build_reset_button from matteloop.ui.parameter_presentation import ( @@ -307,6 +308,8 @@ def _build_cleanup_parameter_controls(self) -> None: self.stretch_spinbox.setAccessibleName( QCoreApplication.translate("Inspector", "Horizontal stretch") ) + self.exclusion_controls = ExclusionControls() + self.exclusion_controls.command_requested.connect(self.command_requested.emit) def _build_output_parameter_controls(self) -> None: self.output_directory_edit = compact_field(MiddleElidingLineEdit()) @@ -510,6 +513,7 @@ def apply_parameters( self.max_size_spinbox, ): widget.setEnabled(available) + self.exclusion_controls.apply(presentation, editable) clear_enabled, reset_enabled = action_availability(presentation) self.clear_output_directory_button.setEnabled(available and clear_enabled) self.reset_parameters_button.setEnabled(available and reset_enabled) @@ -769,6 +773,7 @@ def _cleanup_controls(self) -> QWidget: layout.addRow(self._form_label("Alpha threshold"), self.alpha_threshold_spinbox) layout.addRow(self._form_label("Padding"), self.padding_spinbox) layout.addRow(self._form_label("Horizontal stretch"), self.stretch_spinbox) + layout.addRow(self._form_label("Exclusions"), self.exclusion_controls) return controls def _output_controls(self) -> QWidget: @@ -826,6 +831,7 @@ def parameter_tab_widgets(self) -> tuple[QWidget, ...]: self.alpha_threshold_spinbox, self.padding_spinbox, self.stretch_spinbox, + *self.exclusion_controls.tab_widgets(), self.output_directory_button, self.clear_output_directory_button, self.output_filename_edit, @@ -846,6 +852,7 @@ def tab_widgets(self) -> tuple[QWidget, ...]: *self.crop_tab_widgets(), self.trim_checkbox, self.alpha_threshold_spinbox, self.padding_spinbox, self.stretch_spinbox, + *self.exclusion_controls.tab_widgets(), self.disclosures["transform"][0], *self.transform_group.tab_widgets(), self.disclosures["output"][0], diff --git a/src/matteloop/ui/main_window.py b/src/matteloop/ui/main_window.py index 3e6e0a7..62b2579 100644 --- a/src/matteloop/ui/main_window.py +++ b/src/matteloop/ui/main_window.py @@ -223,6 +223,9 @@ def _build(self) -> None: ) for widget in (self.timeline_widget, self.original_canvas, self.inspector): widget.command_requested.connect(self._services.dispatch) + self.inspector.exclusion_controls.edit_toggled.connect( + self.original_canvas.set_exclusion_edit + ) self.render_button.clicked.connect( lambda: self._services.dispatch(RenderVideoRequested()) ) diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index d7af6d4..7f826c9 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -6,13 +6,17 @@ from matteloop.core.crop_state import CropChanged from matteloop.core.geometry import MediaTransform, PointF +from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec from matteloop.ui.crop_canvas import CropCanvas from matteloop.ui.crop_presentation import CropPresentation from matteloop.ui.preview_canvas import PreviewStage -def _presentation(crop: CropSpec = CropSpec(10, 10, 40, 20)) -> CropPresentation: +def _presentation( + crop: CropSpec = CropSpec(10, 10, 40, 20), + exclusions: tuple[CropSpec, ...] = (), +) -> CropPresentation: return CropPresentation( source_id="source", width=100, @@ -22,6 +26,7 @@ def _presentation(crop: CropSpec = CropSpec(10, 10, 40, 20)) -> CropPresentation rotation=0, pixel_aspect=1, crop=crop, + exclusions=exclusions, ) @@ -35,6 +40,12 @@ def _canvas(qtbot) -> CropCanvas: return canvas +def _source_pos(canvas: CropCanvas, x: int, y: int) -> QPoint: + assert canvas._geometry is not None + point = canvas._geometry.transform.source_to_widget(PointF(x, y)) + return QPoint(round(point.x), round(point.y)) + + def test_crop_canvas_drag_emits_oriented_crop_changes_from_shared_geometry( qtbot, ) -> None: @@ -50,6 +61,248 @@ def test_crop_canvas_drag_emits_oriented_crop_changes_from_shared_geometry( assert events[-1].crop == CropSpec(22, 16, 40, 20) +def test_a_region_drag_dispatches_exactly_once_on_release(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + for x in range(26, 46): + qtbot.mouseMove(canvas, _source_pos(canvas, x, 15)) + + assert events == [] + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 45, 15), + ) + + assert len(events) == 1 + assert events[0] == ExclusionsChanged((CropSpec(40, 10, 30, 20),)) + + +def test_an_abandoned_rubber_band_dispatches_nothing(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.set_exclusion_edit(True) + canvas.activateWindow() + canvas.setFocus() + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 10, 10), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 30, 25)) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + assert canvas._rubber_start is not None + qtbot.keyClick(canvas, Qt.Key.Key_Escape) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 30, 25), + ) + + assert events == [] + + +def test_region_mode_rubber_band_adds_a_region_on_release(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 10, 10), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 30, 25)) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 30, 25), + ) + + assert events == [ExclusionsChanged((CropSpec(10, 10, 20, 15),))] + + +def test_region_mode_discards_a_rubber_band_below_eight_pixels(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 10, 10), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 17, 18)) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 17, 18), + ) + + assert events == [] + + +def test_region_mode_gives_the_crop_no_hit_targets(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(70, 30, 20, 10),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 10, 10), + ) + + assert events == [] + assert canvas._dragged is None + + +def test_click_selects_a_region_and_the_same_drag_moves_it(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 35, 15)) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 35, 15), + ) + + assert events == [ExclusionsChanged((CropSpec(30, 10, 30, 20),))] + + +def test_delete_removes_the_selected_region(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + canvas.activateWindow() + canvas.setFocus() + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + assert canvas._selected_exclusion == 0 + qtbot.keyClick(canvas, Qt.Key.Key_Delete) + + assert events == [ExclusionsChanged(())] + + +def test_arrow_key_nudges_the_selected_region_once(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.keyClick(canvas, Qt.Key.Key_Right) + + assert events == [ExclusionsChanged((CropSpec(21, 10, 30, 20),))] + + +def test_leaving_region_mode_restores_crop_handles_and_keeps_painting_regions( + qtbot, +) -> None: + region = CropSpec(20, 10, 30, 20) + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(region,)), active=True, editable=True + ) + canvas.set_exclusion_edit(True) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + canvas.set_exclusion_edit(False) + + assert canvas._selected_exclusion is None + assert canvas._painted_exclusions() == (region,) + assert canvas._geometry is not None + assert set(canvas._geometry.visual) >= { + "crop", + "north_west", + "north", + "north_east", + } + + +def test_region_mode_announces_the_selected_region_bounds(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + + assert canvas.accessibleDescription() == ( + "Exclusion region 1 of 1: x 20, y 10, width 30, height 20 source pixels" + ) + + def test_crop_canvas_keyboard_moves_overlay_by_one_source_pixel(qtbot) -> None: canvas = _canvas(qtbot) events: list[object] = [] diff --git a/tests/ui/test_parameter_inspector.py b/tests/ui/test_parameter_inspector.py index a542738..2c4ecba 100644 --- a/tests/ui/test_parameter_inspector.py +++ b/tests/ui/test_parameter_inspector.py @@ -8,7 +8,7 @@ from PySide6.QtCore import QSettings, Qt from PySide6.QtWidgets import QAbstractSpinBox, QComboBox -from matteloop.core.parameters import ParametersReset, ParameterState +from matteloop.core.parameters import ExclusionsChanged, ParametersReset, ParameterState from matteloop.core.specs import CropSpec, EdgeMode, TransformSpec from matteloop.core.state import AppState, SourceState from matteloop.core.timeline import TimelineState @@ -260,6 +260,41 @@ def test_inspector_emits_parameter_commands_from_standard_controls(qtbot) -> Non ] +def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: + inspector = Inspector(_settings()) + qtbot.addWidget(inspector) + state = AppState( + parameters=ParameterState(exclusions=(CropSpec(10, 10, 20, 20),)), + timeline=TimelineState(Fraction(4), Fraction(0), Fraction(4), Fraction(0)), + ) + inspector.apply_parameters(present_parameters(state), editable=True) + commands: list[object] = [] + modes: list[bool] = [] + inspector.command_requested.connect(commands.append) + inspector.exclusion_controls.edit_toggled.connect(modes.append) + + controls = inspector.exclusion_controls + assert controls.edit_button.text() == "Edit" + assert controls.edit_button.accessibleName() == "Edit exclusion regions" + assert controls.edit_button.toolTip() == "Edit exclusion regions" + assert controls.clear_button.text() == "Clear" + assert controls.clear_button.accessibleName() == "Clear exclusion regions" + assert controls.count_label.text() == "1 region(s)" + assert controls.clear_button.isEnabled() + + controls.edit_button.click() + controls.clear_button.click() + + assert modes == [True] + assert commands == [ExclusionsChanged(())] + + inspector.apply_parameters(present_parameters(state), editable=False) + + assert modes == [True, False] + assert not controls.edit_button.isEnabled() + assert not controls.clear_button.isEnabled() + + def test_inspector_emits_edge_mode_from_the_standard_combo(qtbot) -> None: inspector = Inspector(_settings()) qtbot.addWidget(inspector) From 6ee2989dbb60abe6ca77466262a35b1dbcf260c9 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 10:18:19 +0200 Subject: [PATCH 07/21] =?UTF-8?q?=F0=9F=93=9D=20docs(readme):=20show=20exc?= =?UTF-8?q?lusion=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ✨ Feature - ✨ Seed one exclusion region through the screenshot script’s existing state seam. 📝 Docs - 📝 Describe exclusion regions beside the cleanup controls. - 🖼️ Regenerate all tracked README screenshots from the real widgets. Refs #80 --- README.md | 2 ++ assets/screenshots/main-window.png | Bin 215525 -> 215111 bytes assets/screenshots/model-manager.png | Bin 72694 -> 74507 bytes assets/screenshots/transform-expanded.png | Bin 210109 -> 209631 bytes scripts/screenshots.py | 2 ++ 5 files changed, 4 insertions(+) diff --git a/README.md b/README.md index 62512d7..0d06184 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ composite. MatteLoop is the whole path from that clip to that loop: - **Preview a single frame** to judge the cutout before committing to a render. - **Trim, crop and resize** the finished cut, and watch it loop on screen until it is right. +- **Mark exclusion regions** over burned-in overlays or other unwanted + foreground; those areas are made transparent after segmentation. - **Render** a lossless transparent animated WebP. - **Choose or clear the output directory** in the inspector's Output section. - **Replace the open clip** by dropping another video onto the window, or with diff --git a/assets/screenshots/main-window.png b/assets/screenshots/main-window.png index dcbac21b0325bb011931253db5c88b4ed4e80b6a..e61d46df3940c14b362e3295a5988864b777a917 100644 GIT binary patch delta 193838 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

`v-4qHHW(%_hUQH8SUP^U;*IRi0Vc}p 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 z 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 z z!Fk3b-}+ks*U(}W!SOB`ptsRScu*|-j!;tPnXd*Msv1ewdW+E$V%b*80MquT1n)3a z+c@pJ8--)8-buJjcF?|D4et~A&i8^e)V_w`r5js~*gG`>5(RwpCBn6cpCogXv9V|@ zdBiUMtmg5^GMG{0X4I9nUHk2AW;So5moR8mCgho#4w^DdlP8h}I7%=`X)|<22TYx6 znv^2ae;aFfySW)sWuPtX5hLgzK@nK3K6jpte~RFlwSYO##C|}^W?4&R^~l*k^;M1M zjWToa`61$ddZ2xz0rL$;c(bO{D9;GZo7|@H*b(cp?<5}Sk1NOG1tm=zv7p2!k9v+D z{pTrKAA-0;KKKB(Xp9YKzg}S#o9p$ZK3n#UyOX~)`1P!<^%!}V_qRJfdS!Y0UqcGx z*=fft+@tFCG&i>^qUgD;(J?LD`zzR-3bTlz=X^c)W&TarAFsO z*ya{_Ax?+W)AcPa2#GQwR$C);QH{)PqfFM`wduY%YAx!svoXq%&Dn2ag=QR9@jhrp z4bOf?qkgt7#lE^;0(qkcRkLDQ^LWODrM>7A0dVYb+X#b_@sf_|_)VM0Z)W4aeHZm} z(Xq)SssKw&S4;NoC*ih@Hc;&`rojgl5re5qiQD{IU(>*o6%Y4XZqd30iO_DZM&}1( zRyJ(aJj>CEiBZWWoyL>N zQCIzf2-M9cQBbSk82J&t?kLa#!+bX{6g>ZeS`dIY!`je-1v)MEk?e~CG+mQUNdMw< zi*Ze^1Yc~e(|&+nMg~6CyU*KDL_)oywyi&t4%ewEq-m}+U1yO?mqHOAIlP_((U})@ zZUjFz%AvOL@p0GRdTKTPV?Am#Aja^Vm4p_1M1VWKXn2Fx5eIF04rYHMsa3q39j-dS z0_-(giM;E*qMDeTER+uJK#jYiE?rT#b*NhlZz>9J zIU)C(7B`z$Q_~oQGEaz!?^fn7_M{&@{kJ}tL=`vdC|r8=*v~3x2U~e@g5c~DA%bFD zRkHr3S`1b@0D05LJY z^9=&BQX1;7+l>Q?-NqP0(=ptOjy0^HL0MT1lSf~xIVjW+ca?Ml&>pein~k;b z7PK^L&gKiT8ohJ1hzR%V5)Js(h<#={wW2UnAp8~bG^=T*)D4>3nA(MY|Ah-J#Im+? z9`$*i7bGoi5USE{tK%Byb+Hrx^+naQFZ#z+Il&0#1k;LFN?{uA3Ed|@ml8)_lyJ}M zL)twiVphxRm-x!(-?=uADnKbdVhi~};6h4m*=r0eb)<<~{sk+pEO-DD`*wl^!hCU)cmd2lf zmOIOFFlv+LkkZb6g%^7Yu_K|xRQfaXOzH%R+1e`E@0~Ggn(XA9@5*^A3Bs#$7wu;v zOPfZyC3DrEXfY-CZ+f_&ocbHo$;Xyz2)_!tUUmOWSp*`@$q*r)YO|9m<)-)%!%h zxK6IWeL3pk7R>C(ESDk>+vX%cPj8Ui7`jMN)}YxQ--K0WwMUQwq7g4EqLA1DcBZd= zqgUoi?a?@iOB#8-&Wv1RHtzwD_cx7plOe177N|95WER?V76mjiKTOM9oynlidT#Q1 z`~w1RsgeCXcb+m=o&XBCzC+EUZU9t9&#l3VD>{^rT&<$;jt{k!^l&G0S%^BAM4kai z6x4EfFp2qLvgiCY>R->X9c057xbj8q_gwfcw)}kv2nsrk>#JvG(9PYSubhc7}0e^ix#hf&=l82oPB7cLa9!jvgc>WBF z4O)N+Pbtx z>mc@56b)I_P%twnox2iUe|X%`_fr{;yj<9Qr06J>BZWL2BrXh!X=2q`x#EYV|FZ-_ zp7f^;3yliARpYctFdMV|_mq_jQu8?F*W4mctI;ROTt{-Mw+Qy+*gzYkWQeZ7Zf1SG znr9Iz^XgTnn542?i5_CV#pyqC@0RydW~8>$riVd%0)0+3=1-b{_ZZ3P^8ZwNla#mQ zV00LvB-$iCbr-78K#Zd&f19cMT0DTh@(>Ib0|^_J*lIAf+OxUrHxz4ejzdwAO(i>-dyX zFOj`)Mv}Hu36F3^C1Y%TUtw~xkXjpAeDd->=5zfj=?Y9s<}h}p z`jNNRMX=E8zF!D5OT0J!)kr@{{P0A2^^PX@ZI0cT_M8Ft>-lD<&Sy>^Rw0Wl4)7~A z2LyUcz|16SwaSCSDhPSMdqzDeuWloZmOn8iJ;%d~Qq(5-IM;Dyo_$waFm9LQnKt~B zCR~N*pDC4L(%{p`QaCs@HN$L23~Pkh6Iovh3Jy}_q&-LO{m{;A?~AnR zy`o3nTA<_Br>SI4$Ytu0rv}JrKHw}5em!gPFpFOFLEbPwXoIfNcK@q`0OBeHVGwd- z0KFM^y$`pzAGliF#JIvFeLzR9T*;h1MePCi2Ef1B16>z zPD)DFQU6?#2go{L+ZA=_8ggdRIanMX9&T}4i0pHHm~(xQ1db+A>@qj==)f#wM$cuM z%#HZba414C2-qP^Z0+SehZ7qf30gJGC61KaVsPA}76PyAN9U?}KTO=bnsY*UYU=&% zn1r_OxLR5+P0k#BE6LKqS{9?eGq*p9HbiAZf4hQS$%dqDPkY{qcKb3{t zt+Btq=NQ?6;VWVO{T1A~3r(t&*ghBx2uc#SLmCDmfX2y2&DokIv-wV-L}_->DR}>G zD_}0S$8`dZe)S+jJd3h~$t-p%YH`#wgOrh8~YIc}k^`9;!Hms(b`iejTR zX1wCcPM99E(ypysH!y!{;3+s$F{Dt8O*VTUy=aisbyi|9(I2a3o#3AMVZ>PD`5bka zb-t&f>RdQKHi?3cEh#Qz z!@6&aME2|I7v}&;$4jr)CoY;-or%dyNKUiG|lOg<_2Y+fuw;_rFHRtuaB9QfFiTMGgs?`1<9aO!y+%dk$Me zhJpJD--+!jRaXBcyY9pP8XL08_4?DMN4+U;$Tc6b4DoOVT%tEaj@p|4@yv)Pz z8NQy=Qq5dE7t04B zd_F5BrjC)Hk+Tx5H67J(Ai=sfa)qomjm2IO_@H=K2sv^!F1&3Qr^n?x_TUpZyWjcx zLKzzr_l8Wp+Z`L91nE9>h~g1hcdU-K+Tau@p;&)b-# zm&qMu#^vj3if^){x~_EbJLI|>^Lw_;y~ui-x><5Kl*Gv7 z^i9Hb{})!Jfaj+##B+vvIBZleVs#>`2s?O<>~c!ZR>X<%8*l0{$&2~RtE(z2D;wk^ zTAVy%^BXG#*uj3M6<=R(L-h1KG;NGNebM5qzz0bH+np}v=@-|DIK{&&LN>S%CyfbO z4BZJuqnlz`2<7_}^xBlPHIAa*xH!LEN`AIppG2WyK3@%ITmYO>*F$RK8PXO)LFwpLG;`O0w{#c z%|;q`c^Q>sQiuKoTtS3fODK>P2U6X(h;5e60&TteEE)L!Mh7 zaGfLjo6>b3Ryn^iiULWeSlb(9<|Z#@;}Y6?iU&8LBsJo>`(7RwZ4rL&>sO*cn8mhQ ztB=*F;<9zY4gKg@_k@knM|{qKFWg;|Io((MiVj(NdRcl#6f1%71L4TCB8euTfG{rl z!a8{E;kU`)7^pYD#+&m=B;O}!Rb|Jq;)KG)hhd^0tD_B{)#ZsQxeKCe4`UlZq4{LW zxDbfI9Ii&%aD*V%4h>}(eb()hv=q)GcO=Qmn(%{{` zS;vnjg>qTPkr;lM*P&UCpD?%pKL4c+RM6I?vPIDF>IAT~HXasEkM~~&N;O5<)+cKz0WN+i7 z^xYAUqU4}?0k8{Ur>UR%_?gwcVE2P{dgZvTTPuD9f<@e;A0j4OZqOz{&(iz*#Vdp*~- zo$}T1&EbkNhdD{wMBHmJGXpl0QxuqAmvc2tQ8#LtcE7A4280ns?~X0E?GNNJX68l? zD^}0Q59ZmQ1Db#Eq;5E!RyKZ4#F_R9>Pt_x?em|gw+5}bRfcBELQ3Nw)^>Pg6_4ory9TKd<&t}+^c%U%^-~a zksOc?{@mh;Sg;(z{Us0EeccZXpi{t=1lPc3V`BS`A$Cf=ptQIbnv|0YW=@= ziRwlD_66()3m)>d$K&SDbtRHu#_LwrYaeF@nTz1B9o>&Gi-s~M#`H&L3C#|}K-EN5l}(@`KQ%Sq zfwv!=SPT2Uo%b!Byot_BbF0j~5MSK9&v;X+w>RRLw+c&U^zqAoM}U!b89QNZOOp7- zGu1OuMP<(3mQ!OY2-)4HyIGruM+pa@=ETTZAwU0kbklN2a$Ehckc}{B zW#uuGo+lx$P$WKRq7%9w-(1TD>h<8{%4w7XP1%F+KYigIA$u$Mbu5|spxbjoZ`Lcn z3C#~U;QlP;h}6q2@K(1Db{-|jXs&S7)x?!`D&VIY4z;zBv(|aJL5_!`*rf7&Ff>(Q z(BuN>W4>;cK}8`L8C%_{f7buV!-ikhz%QNQx6bRQe5g}&yEh2gjKqjXJD#Hs;g>cR zmrsFBWgRuNX}ZkiZnJw79?WFrlnQkH8FABy+9*Uyfrx$_5B4CF&?eMD+mRTZgUW+8 zMwq>wAt>g2zO7c5znGzDYz#j&LDs;53+DS;-;h~EyBogKVc^PHfyFV7#c{I*>cW89 zJZF3xe)0M0p}r2)aTPT0+jY8E#eCh12feyO_G_k}Ya|X9tbz>BF!PwVp@bq1EMJX3 zySP~-X^19{E?iWGe#^3VtKR+i2=7%{Z`&MUXqKmTNdLca{#xw@SM3Ij(x$UQ*FTTBmzJ5tG-!6&F9vJ^0^c}`sw7?fs6L=&wpBG#WAPm z-n;M^>%LqUEC#VtCK}oNu>Z_VIZtW9E0x-4u$fBk_8ePj6-=9W0;wgN9R6z2=;jl2 zE_--I>~e4mkZ1jl!w@D=@yUrd)(ycSJZu;R!D=kJ+isA_|0;BhJU6%kdXfwlLC|gfpRs8;z9r!DLb^mA* zI2cI6=yiRl>Dk=b`L@4U7XWNa76_x(E$-igjwi5s;nydqn;ujj^F4Yx7v=r;zV`}% z_w^;nTwC0KF+eQ0*S(TCL0+ML-ofEQY4Bru>FsX#ML`du3P2?t^IVlDo_kfM>FRrWw&A(@!LbumPiO`Y>UeD2gaM;90rWM6|LYmu%e z$m&$Xy+8c>wx3EkHSc#|aAD@CjbOzv&Au6$=@Oj#i3w7CIj5qeCj_C4fFoP-dd~Nw z1|LOl7*a-q_+n5W=OHQy!r}Vyy(QkcG5TYp;pYMHr|rNKC-GCqyrR@Yvx%+JH3=JR z-c=3j7w=0dy-4+Z_ZXYWbj6oe1riYg-}m&uC0`xnf;kfYpljAc5okgZj2#y}G&aWY zDU|>A7rFNQ3%x($)KPsVQCy)Qo{?%E@okEy-_+)B8aPHPYxf(_IzKX5O1aRN5e&C~ z#;MM%tPX&_zQ>TaYsHnL4J5XdT(Oqzrr*9fdQ8lDXL$Hb#C*Gg(IC2+;aaR)4EQ6&A;NAt82OoR`% ztY!tvQQ$Zo>sMG@Mi!o-g73G<8vhbJKKTB_frkn>n`|PGG=0R^eU1*g-b1SjnQxxL zQCKoB9m;!9=!EI7=yM0X&w3niMvWSFMV2!^I01*u_u(j~5BFb)ANoa6^YH5$VC(OU z!rAE$+TGKk;=4bq$cZ#Kv3oi9{zc zmA`LslBs2kbDsFufIucxg3XsMBoM71`X!D=g{O?w&!Cq1+!i|{w!{>j?qq=;J+ICi zM2NX2KVpNb!$R5ngsBsJEaw*AKaBtuv%42r$*PRE#j!!r{E1&!Dm$_#ukwr|YXl>3 zKE7mE=6!_qrIaTpZln_(V*krOD%uQggS&<={&mW8?{UAiz=h&R>jF>fAql)n@v_Z> zAsWdX^{hC>cy0X~Wv*gzJA@u(N9}7)k9dXoRDOkd_Ypm#l#|-(_$x&{?l-f5dMeo? z8b!Uzz2OG4rbF~Obi&ZBvhtIgEv+qb0UagHeE)?RGgK?+-+#%I>@eK31x!%L zZWdB8{-kl`)~IJ!G=vv)-`#W8D*7sDI4i_|zL}ctY!X=rTq1(+eUaBm55gdlkHCEr za0J|(FasM=T|ej_CCT);Q`%R5ZTo*TeTO^Sf7o@XqA0Or6Kb!hP1Q=N)f%z)uDxqV z)d)hVO^n)&QKP8Y)`*>|5v#Oj5TlAJI^O)A=Xw8uT-W!?{kg|E=RP;4CVuS3`FHC8 zK|1(0I?qO6Fw{0n?02Vk-r8@Z%ix|Zt9M3at2|zyqI?u(r8ta4V3g*2ee!Y372?-n z>(q3(x`5l|;#*wcot))i@UZkNj@i9ZzBZqHB{wY`(AxFka}8~m^iZgrTz}47`l%0s z=&F(Y>V4p*VBOL2F&*C!sIeUzNmRzJ<4Z$nkY1_`(cXCitx+3GSNO6<*@sKNQ|=(jq#k3GkoHEp;CENOk+_Qn0DZ zNSU#5$2?inAst|BVYYL)^4_jg-3kbIc(CIG9LbBt|EzxwY-^}^OPO^ZE!17H562qo z(_LY^Xqy~(Sr+6%o-VEj-ni>wY)-O+YDD<)!uQ4JlLiF;y@4m{k#V6y_QL zcOwXAty%5cr<>(Zkm$F*WhOGNjT+A@B6yjPCmNiiVe+Q*f}^^gNGGfo$eB{Xf6aux z2M*MvVp?$`?H8ySSIK0!)saB0|hBOzF zF=h~Vml!*_v~8b`f=5NKTLkewC24`9g@uJUMv6)C0o~{xk=Rp}(&!T-6`Qw&D`OR6 zW~KF)j^1+kQ~&0QC`86J7K>Eh&2=UoQ2NvJUpJQF(Kc0-Zy$Mi(FZ47@EjZ`=Ug?Z zd|e@?yG1;FowdxNpY|&DSJOrB@x9|eM?(Hz`=gH65}(MZ^e%n>#lVSYSg?rwvv;|e zT{r;=(dy(BwVrS)J!GSQFm)f0MhUQ>{OltmzV-H=OXm|C-|wnS--cc&LvjH#&?#sr z`84j}MC5wmPyvok#ovF4{mhde11&k&1FUO<^M=)~7eDFh zgz*z@<4z!DEq8e2Y~&-%p_iJf4$2gBp`g zOrICJAcL7T=9&1PX^>%6UvuE2<(70dN0(c@kiq?4mbZ|r?*qN%ZFnWArZDfG1mCR! zI)4Z~OGO|kb;)5)c?AVl&-6#sB;23U9=97(7^Zm#;tZRo=AV9pSwe9QC6{;q@u;GY zz7do&aZ2(_0iaBR4~2I;Sj@l85YkP0$KLQ<_6+`)OZPtZMJ2N~eRWr8vcIe= zN5AR4+9xdhqxBb8?I)u^otEf0d~c<@oVWOw7+Hq5u%A2Mc5hJ4JAA#ITpAh?rziC$ zuxg^`3x+Mo^)Sf4U9k~BWpOp@ft?xrXrl#B7zA390BP6&j_%3AqHeHPE#hOBGcRTK zdFdMo$>Ly`71+ee9ButebSSgp;P~tEib_C-EctDx9Ulp{AA8d^k3<)^}P`Ov)A3q z;G2B~>O*q>!j}&HfEu~LQ<1~@S@_hswv}h28M-);F#P0jC+=xDXV%@3A%0&&ZE-Xj z9Ip#qr%zXxOpP~_5GCbqiAIK$7RAkt{5I!;e%HgcPqF?NbBAi(e4UlcmA^!BQLn61ULt#sbL}id@!;q1>F$qk) zOH|)jqoSbVJQ33IUApifx1U!F4bUyjt`pDa3NAGeBvOwwTE@y|PPD!&LGFZ-cF7>H zj90UlAYj_Skj7XbFa!CR$!#dkv*!95VaAde&jN$GIt+aHq!Yzy-jsc zX?#=FGls(sp2SH1q%pg@FDUBEEE-kYt)}(UcHp?g>;Bqdh4Kufb;`7%b6@$vBq}Yl z3&>HAd7J}>?JbR5#2+^gR)b~@HL)UYIuDo=tYFZ2B@2by71jjwj0TmliP;^pv8C$) zAfydCDIyo80Bmj&JZJ2jsNe;|1iWR0)Ln7XA?RfTb}hl$IoU){hP=&fP0Q%*F_3XP z7UDh6OTs3DTSl?H@?6Lr$VN!~c9ns$U$Tns!^bW2+sYw0D=@=j7n%qP#OzpzU|YY9 z^KBG^RW0dSluS;cDHc)3AJrP!(uM{;3+k7X_?M2SjXiNuVawnOTXae$PD5wmEc-KG_w2K_#M*`)>uPS z;H;GRgPuLcPN6*dqlqS@Atov${3@F+R#A!a^1#`LijljuOp@v>EqW!=EvkGE}dT!}T8=Aj7@W6nU5vb$&@ z+@8hkLaQ2T0GRUn`XmzOxd^Gr3I-Q47}=y!r90fn%8W_CW2#VzIslzIke_&)A+)5c z+5EKkN0ohSsCgiX#cE$M0y*)@BNmBE7uoe#Oqq(Qvmt$5Odg&g1G4z`oLPOfJL^+c zbZTAqI+GDs;Q&i+^A0EgYJy@fGb)a8@IJDTyJc})Y&=bF1Yyt5R;l$YvP)Uy;?@@y zrGbkCW64zA)2oIQE`)F^#C{ZQpv6(4>+Wqx^Nc3Xt;I*h%(o}3!_3laR;y)lIa?FcUy(fK;+elm8XsCZDw&riFgX~oxx?sY zmodC3ZsmZeM0@AQth9_0XK;wwQ{y9S&xA9~O7#B+hv!KF1LwOye>xD&3UG%t zg6CNgT9J!QBR?8YV)Yu({VE(YK;`1J+;Y;PIMB7$L5HXEe-f3AI$|_x6Qv^~6;Qts z2VkiR=m={fT#?yg>iVGzpt$rtH^Quml7)f6M&E9QHfE%d_4H=EvNv>*a_V^1 zFlOOuAoBjwSNIQ%DGY8Gg?B;l(X2(7p}0OJ#g+yY7?o|Q3UCL3j{2@1I`rov^BbRZj5IoD$SSctpP9Wuvx;+a3K1 z-fA_eX$;bW_qv1M0c z$9gv$-!PTf(RH6|!Ep9n`&W79aVIUx7a@L;n9$UbogLSRZ~L_bQW53UX218EOtPfH zyd^a6-7s}+ue<>C+8Xp0DMIDy;ov`&R22)2we^4}X%k9QX5a>9e_e}LcL>?-%185s z_w|oUmBniP;7P=n?^6zFkal$+%bUKe@KwP_tH15={8{!*F(ET(zcGuc5+bZ=_ch39 zpw*UBKQG9n84dHn>nJ5uw~K4yWJ6Eq+8*V*k$4K!GLhpONDA6dFF)U7ZY(a=qT7D^ zQ0wA{nAH6X+^3DnL+3R>p4$_>+QiMA9_Rv{1|Y2)E>a}I=28Mx2kU7Cp~Y6fURnEj_!MRZ8og`*0DuJzeoaz53R@E0KKZpB4T|c+OX1B!29>BCHp~knhqBq8B3)FLsE9f)$Xa<{Y zC1vnACSNZqtQXqjYjTKM0}&!Y%c8b;UwDFwsHx?-Ues}jxOBtYB2KWYDqzi|pBMhW zDkRb55A`i@^J||=dW7}Rlkg|ID@``ES_^a%0N`g=89p%BT6`z2z?q6KByBiI?QUK9 zK_lOMcLU8*MO{JHvCaA}CuTaO8Jz^e=u$y}^k7#f7D1Uh0O`vg)9qDVCuHjM-&4O= z5bWCz@4sNLw9y|XD~e1WR1gR6f*J)sN@uK!0SuHWln%~-oc)Oo zQ!VD|n24C2>-4`LL2OJN!j0b%DY0nzyO@BT!NEZ$7lU=oM?;yWQUj)3fN5&l666_! zC+Molj`q)VyYC8IqNo2ZhSYgg*44n6NmMz>Uz{~9YzYHIL2#MDESP_`1$`Iesx+(8 zAqiCF5E|VAC=-l69fGJ6C0dav-Hm70O7NVH)BP%GycETL!$xg3-j=%F9mfj03XN;2QR@5H0@14q*a-=Pv?pFBjJ*T~qdY>T^D zDOqeymVXJ;C)L6!yQqhP$SaG8niM%hQ}b@Ljz;Qy9-%%ASU&(WA)dq3crx;t2F4 z5j|RQNa6={T9K46rrArWE&c9R7@WhI75ug1Wz?94ViX=v^y;b`rvjSnpn?}}W0_gz zB9BWHT#0u9Uky74hJ=J%|73*0Iws_YgeS8f9>zdcSG01R5SZlwmZ&I& zgS0}@xEj!X)5`lb|K8hgf4E-(|LZV&w9w+q74T1;csMk0OVM86fAj3ujY(EJZnGbw z5J4C+8J`IdX-g2`6Dls8{xuWjuv74OHYhA-CBj%)U!G2DA<=CGcTUC>gatoGAVq1h z%34F>BO^Ld3jS8!KuEP~qZpNcgXJcoSy+^XTQlE;*vmTPGp@a#e;+A$jBT`egcO>} zd>)^wE9tYw(Sfh$8momBYVkN~ZGpQf_L1ojR~ESfMj7 zZCj*twig<+G0kNhj0gQ_JfH&Ge&tD%x6O?QMl<+w-(liBzMk%AJf6iv9mP7l{ z@%xQ73NADh*9w3jJtd6x)|~nL7RILqHRV3#`VuypIj%Psfp|r{F#p=r01$wmx5&si zTJ4TtB&jEw57wwn(jJ2}@#93}_KS83ZwBgot2z=1_zU6+*g16m>7mDRCfC{r-irQz z$W_f3A|D|&Tm12)<9T5p63-c!j~(K(r1T_~DE*P7Y^-{W8(nr-n*P2$$|I}}l&|ESP5SdV9v zU~NeeI57*^EAm;20))9gJp;8gyqbAR}X${JQ&S1@7y*X~-?lT_z7YKuB}HX@pK8BPD3 zzoOeu&w=Y;m3Kh;Y-D6)Vi*M|?q*x|3kwgqO~5g>ZCb7CKVQbaP|AP#nnV^Z#(CU+ znh|a z|C9FX%N0^oaSv4-28n7>ODkpGv4v^!f$A4|kqk{@%yjk&7-Mq}XdH5xE#NPW2=Znl z%n{~K`R$2m;`g%>t zn8jtx(gidYqIJKF%cv+N)bO)`ShdY~+11ua+iukuVyo{31g!^~kAg>C2NLn0Vdpgo zmQdrV7ccrwi6)#)QAM31CNP8Xw>g`@uYQwzfjTeq)Bcvit#k3{C8uA+8%BP*LpE^p`3OrzN z5~FoKyyWFY$uMh-JYo&Lbn=UM!HQHYdRjv@==My4&@O9~=)cl&b5-Uq=Vc%_D|3KS zrD){O_NSN&OzzC!yc2(r=sgmN3Jn8s<3?f9!jseHhNAvs5BP=sx-`?;`Gh3xt7GNo zX1H_&0>GZ^3U~-LYn4i!POd=H9&@=5d6Y(Uh!d8gB}J2;zOWA`sAP(dsNu!MVXIY> zm|Uy3rQCJS?9RJ8<73J;u=ds}kV$F_50T$xUdxASAaIM9(i~T7tdiA>?RN9BKDTRy zDQWhDNd;`+Jnu+X)XZUt2=KD(tTas^WuYl3a_pf5^O`p=_Q@{G_!wIyB0X3xi{t#N zQxS0@;9nAL-KfO#KKRP3LbS2Z%qRRpnL#VW)5%oN6CM;g-UV>$oZCqeBfls z5_V7NssH9q%c`I>{Ub5XvdFvNZVi*6tLo(mcDDc8GG}MApKw#M z?%bO2-YEQTVyBu8rY=5Jk~Iy)ZGgetVl5=y=H(}4Jerp z2gJyt_*|cdG#0(nvKG?yTbN>rg$WR*3pV2c%qA)q{mDukBuCRAR zaIfFr;dlF^7;@imgIgK&gr(2=sYCX+Y+HEVOgtUD6n-H=w{N?74ev*VC1NMvmR)v* zJ}&O^BjX)nB=^Y9B${Tl`1Uplr5L7U)LTlh91{a zChMfiwFP$BPmOcm9BzDvyx!=iQe*9H#U#6V4~1%e8h(WPlTK_iN7yKt2WCQ7dpTN< zvQ7)T{6y7@czC4nBl*T}NcdSF#qMXr?nZ3jvT=(`J~e;~+T(i>*An?@Z%9N)RP)>4 zkeI<=++i7M8$LO>>pM(@6lu7<<8K)0-&Ga1zc1vZg1A9~arVz=>-tP_Zz-lxqj{d_ z3)j5=+A5?siE}KGd&cc0Rd<++!b=K|v7$r9*jw$8c))=808w_3X4Q~jo$JaR)>$LF6 zfk`DH<3MfQ1cbI=AorD8;@WGEP|oLiq2T3!HywD=4VFc7s?Z)8=h2c#H3YA`INOe+b5JnCX?s<<=% zRvU>5ymW(!d$-%?P`DL6;%rn~ZA;&HH;A)BEaHWjOqXPWst;RPGI=8uY6fGP6nSux zu=?$`&0B_#pLJfc!mYj(vW*R2ANG9oizVuOcmt50yU77x@IxE)FxhP%aUh$(Y^WCU zmUfm84>&Uy#CmGAAUWQ828C*m@29Z?C0qlj(ZeSJ?Qf)6(T4}wEm3@YbYO(30aMXQ1bzTU^$eEGk3@eOht)Oy5JpG zy3mN37bCs2Qjcyu?rv6f1`zaRI?&_&$EK;xEV_Ckuf4ErKqMqiS6f#YJSbfy4M#-E zA#D#e+y56iUR=-GG}H;O)Fva^m}w#|LT5Ve{qy}c_TGksZiRbpnRzJ9@;S}h_8-n1 z58ivL2yKH=pEVYX%=&eo1kIj>@J+y8{<{j7%-@R3mER&RMb>>&X7e=NH<2nMsh$7w z^YxPd7il##OS#-M$kgWR(-TEF4g!7Ipibq5OetiRg;2*y>1$fM`SE52CI+@G89)Ia zoi%WhEEAW}c}i)-Zp=E0kRn7=*nfQgx7hojknrP6e3{gQS5-7JF!k}TAEsr$hwM#* zY3x{oI?|v%_`BXn(yNMtZmeZ+Gd$BpJXMoPa~yWpikqi(l&FnR#&Wde->B%c>iZdIO|lv_}kRCj^U!uA%~eMm{>y-&KpN*x3 zHEX8ska&KhLKVQ%;OlUc%}!2FtS-c;meGaU+h;}cwxBC?DCIP5`-{r`vQNeCG9^aA z?jA9E5xdvje$6vY1nHzj36ehRAPgUG{SfH7UnkLt617zE5~8h+5$1hv?O{rWT`Ctr z^*7CL5MvJh9~`nim7-9Rpum?wMY@18#5B4WC*IyGSAO9BZ7)g8w)|sP`@>I1p-+S^ zYbInJ?2O?baMLNLFs}A8;O~+|yB4efg?|zg&x35*~{KetA z0xJ0EdlGuTiF>Xwk4afDPR{WGwX^_ml=OLD!6dMF5u$|zZ3#R6b5Rd>do~4(j~k-q zbdpM1JaHIxe4z8KA&!iJOg7EDb53i%_$VOhYxC2;iWh57zt&s4v4>gc&u_%ytYF8h z*DCP$rz)E&QU8Aa^*b;rGN{EwIOIT$!yV2x)l^lZcldcCKJ|Qs<<6HA&-hXD;mOnu zSb)K)L}7k*axzi7oy-$S1pZ2Y2Ow{yjC+Bc!7fsE{Vx`ORdCYkwC%lpQiK}r+4%n5 z^Z2S%7~zSHkT2ol;;t6JfF{U_sPREq9eDOwZ_~4BrDA6RuspI{Nl06`{uODB0Jxj7 zbIb~st=T_3_iwDA;_us1HqW=J+a7rJ#*xUgebILzBn@_=wevdpVsHL*Dz;1w4 z7p@}Jn|$KjX75y=&*4|5hn+F{c)6eZHfg)R8P(gR{=z7*Iql7=*Umz zAyOJ4dFf+dJI^skb6yws**(`FCeuj~nXLA(r%#_gzO9K|cw-lJ(esyygxUh+0!tj_ zh43mL|7>#bFN#Sj5)08GxVA#yx8nCm~@*%{tKHFjxuAd&a#WnkC4lg|M|Q&o(JpKD=TEQs7N?nf!CM+DF$&z z`0jJ%Z`{QD|6oyRKG>fFVMTWWuJAT~w)x#cox=mTzF9MN)z|tPfE9ro-Zm9aDEV40 zT<~>I*kO-dW#p@Afeq~jvc>c2t}$8Kng)X>^1yjR{ieqsD%h(EQhaxpb7rE|$_xbE ztmJ%?DK8xQyc!Odfx&j>@Eh78IIO#=1JkGIUt_PmcDwgNOl~Jt8sAZp2}G`E>F^jT z(U)&6b{u}*ng(%ba;A6oNUEK0B^Ne|@;R<_U=}^fB5LZAwk?x7fMbK}!c*>$>cK%R z@|HC=Skf1{Q1e^ZUjyl#okdGo2;TB4Bro`NE=QU_N|CyDBJ9H$`~_~e&o<BvTvvkZrHy5C9xN&)A(3(n-?TSkHcauaiU0$W+0zk{2^%R2^13g$Yt@ZXR z@$q%XDETt`uU}W#;lA{hp=#8VD`EDZmKG~W=>yi%5KsSp|E5m=^&}Y%T5dv3Bl8Je%gYTWHX9@8ZBmCdDphZzjxO?}wvm*`tY|X1O&Jn3gIhEgdbL z`+2W;a?;etgKv8trTvlTB*u^9BGt;m{R`^7)Nvrq%&k6uA^7Q4^9``P4^1anM9@Pb zz8vk!S5d(^nb|5XDt-&#lPcx+zo8@rkTR!8)*y>}_cq6z8Rp*wE|vX_E$vtHmavAo zzWW$pJ!$k+RoIoN_$L90lmw}LYjM~FGb(!z9^H6o7C8a@bbSS9#CE(UsB9Hua>rR9<&$?5_V&!QwC^vBO5Kiyl}HK&*1y|70$ zlW*JZd9CE7`}P!=mM#PXbVZ0gc%Ec}e*POpLSu`esmHvRv@`~=;UmA=)9+F86@J8~ z*?`uN169qLyDiC1<%(G}gig9ED^dBDn95=z;K%8KZc1jW^@N|_9G!`e+Ei~y+-kY0 zT?BW^KCz2#{SF;JMVU}a+|AFpgO{gxoNmVmCU&6g{#+QAX;<)65!CPP>7xhi4R(cp zw!7^E&)GBCPoH*nVr;++-Q}RD&(tpP10Q9Hw2d*3GRX#Nz5|E%c|k;b5;p*s8EhpK zvv^HJ-Z~mxZoD+n)5+E%a>BXWyj9Tw0lP7vh-ZoEdB@On z`6=i6+`g_j&{Q8{0>4ZbVJx1oIP%s)DjB-B#at^F`zNiODHkq&>cH5vxM?1URG)mwj7;yt_%0n$hj+_-2# zklMd@t3`4=Iu7K!9lox1dFZ}97D=DQvUW)lz%$_;wG=maMDkBsYJ1^cz?Y$0;U_O8 zYj?}YyLTGjt!BN!4KUhQtGHgiv-*{0bp8NATK7FZr*x@#y(tb+S68l74I*VTnI^K* z7G{Hiw5z|RFGwEREeJmJo%Qkc=P%9)CSK%ZwKbmfFvX`0Ekv%N~=g>CE>fzXG|KD=u6Bo7kvBhtK z4bV&^9Q)q#IZwOA|0`+<74_zCGSpb9PIZ@JrhgGiiVg3}td5BXkY@tG;#6MBs&5+j zOD0(@EfNnpvD7E=vv*J4)tn$EVr-j2MMvOH-^B@YlD3R}TTb>W3Vj> zz>mId8>l~dozl$xHa<<8gXBZr2f%@hZ}8Qp&cWyW4<@PpOsdJ+tzdY|bv=D^yMeN8 z<##-Lgq7+&jdMa*c`J7~m;Gcp@#3y1GzOS{ZngfAf;)Vt%Y!H4?DO-=hb(MuhE`by zluEK1*_^gtrP4n7D2FCRug4+M^+h`DzQf%v=Vm|U%mYzuG)cZI=9`BftM!ROcphq* z)>{uzZN%mNe7Dt*wk02FPT5nDo*A!7GVr%XA$36!E^9o+V3zLM`=17Sg>jDq?K@iz zX-ruRx*U79`Jq;A8>~-BN)uzZNJbkTCD|vud`3Xmh zsN33zN%(aR<5s)LM4fvhk}&9bG$B?o;zV5opgSVrzx+sz>p@~w8iJKXmk|33rmwBe zdvAM9DKKClvetvS5(+SvraDBIQgiF)N#1K@%X_4jXqa=I6a_l?6JTaO|BhYef$L_& zuorNrZFju8R4%mGbVR#fJg(~r2Yj%GdW?BHL^&Ae>+f)+37lW*eW0GzAS$YtXQHcZ z3?RPT4_z~sE1@mkgPu`oi$Kls2>HT$Cqrc~>P3fi%auF;j<1ZsfYBrWbKe80R7O8kph;IP|)lv(7s zD1MWH&i~JGX9sH!sF}FP7n{~iwC2dtykd4GnQZNXEBGu1ypUO2$}%JI1C#X9K7ieiNAtnJ;q@hMAcaR>hZY&Yxb^o+aJxbVitEOo=X4e|94n_au7 z3yGmAnX@8foxs9g__?ru{kGLc4(r;`5~VO{L)sm$<6i*nA@Ra2@i?Jnw%d}&NJ`o2 zrbc|6SSP+a`HXlP$iQGq}O zzONB?%AUQ5-rCE#%Q1+O+Ar>X ze>{t8DID&gKJRVvHk7c;&+TC%bjZ0o(x1xkKlJ+^yBZ#kYg6@GK9K)n7rw98w;PGC zP?*!KX`hIN8_rsM$}h7#JP1V22R4nre${jtiKTh>;cl#TL->A}t^ezhzatz~aR2Xq zUv?Vj^be=^pS&&ny&CYM5{*#V+&|HI<40E_FeY*%F5W#C=wcwUeSo5XjZKGimQV{BcQBN2p(!N5{uvDerX2m+ymZGqxw` zPC~9{@n_*rS&j#_<6`8#0-tXglpjVbmvPoK!S85-1qHnSb5$V;P%fOTncWLv=$0-q zYHYXL1-^b#RMXVh?t_HTl+WSSc~eHC)p*j0hgPZ%ms`;d?Wd6$2;UX3Gg1T-{%5%z z6`U%PRE}=DoQ!yZApTHqUv7{*Zm#X}sCr`Ijl;ih6l&k1KZi>2cKEKyHwGIqySKru zDD7rtla%lY+JMKASi5`N<|-;H7;A?d%$2ir?6>v&uAqYweGx`yE0}gwou_5t50h`s ze?;x>cMwKw9@%Ghs^&_`D)deI`9v`6N`)FLaq$G&)3HXsEpeDR&!a>IhFd&(k#_t; z1l#QmFn=8&R!al+ow-o>QZF12`TZR}KOxoC>&EvmwZ%IqRm8*iu<|>y4Gq!~lo6@Q zsUm=yXSQ$u_wwCAD(Q97>9&xbJG`uS2s(lQzCC0&B06Vkz03V0Qnli*L4 zLq0bz^@ODt6yBy+@*tVE=5hAw##%o;ypl8K@;_vEpy_;CF?tkpA#xfVwE%wxTH-A( zkYSMb)gSU*;Ns>&>l!@_ntTl%sPPR-CCZ&W_dFj*dars$5oTg8JZ?gfeB0t}-KAI$ zI|Lt*YL}!bKv0LwYA<-eXP%9%<$-rI5?y0%-)2XwsSem z3&kJi`r8xVsu%kco`Q+U4}S8H&}}|XNs9BFv6pam`#?B()_0OqVph_3QvRlzvLrh^ zl>W!f-?ZW2qOD$LqnIcUxV=2f!o2_^i0^gheHkA4Ne*(u5MMZ@QXOA}M!6 zQJxh-iXUg(z5r8EX`6-PX?B=2Z8{AD`gw^~>=E5P9WE8{4gwROVeLy(B;Nz#rz1Zr zb7(GvHcC;syAOg(SqG(WAJ&o)iEm zZC8l5Zq@j9bdK;1??p#$|M-KkCitvQ>Qpv1HkQyuf4gCoP?#=9YMt!<*j$91xN9}S zM4}F(Vc>xCzr1z+ZTIR3OG~3aZOOD|x!L>vcwdVz!Cn4PD=gS(`n?gtHP>dS%J;uH za3uZ&SABV~>vAvkwv?adN_wZ1A?uLl1Hl3EhG&>8GKq z?#43a&k&8mNjc2Z%+)~k3GK%5u-Qp&Kb~*L4bf|#*PTz6Fi_m_*{k}dzA9GO<%V&?WC`peL5!m3XK*^df zvW7^FJ7D#7t~$$|&jAA9cSyZf=ysakGiGV(I^pbxeDZb+RiHZ;I!NHH6U(V>ER$9~ zUQ@ES!5_Myrs}P9{!v+I5)K2-_u5|R!qb^aS>KgnH)_UY(RF?I{m!?iT*QqsVhZDf zFeM}tH-dI(zm|6f&RkTb?dG_3x!GZ~OS+}nEmkdgE(H-TgZB`k!tscqOlRb)!bd-w zk|W6(Qgp9{+S`fRoOC|UqhmuMolv_GP;m`k#btB`(dZ{ZatN3v_}tsH?r&TTlKuO4SI6e8Qi0_%^gaFn|8^UHU|Zho~bU7@~)RIW~vf z@^pK`BB_$z$|EN6;Lop_!58p*YM|rr>!zxfMe5=4`pZkTHpgnNfE~i8^qpC@=SpxT37$N$4d=Rd zMg3}FUSC2CJa%tpqQT=!g^C_8GK_{YcF{Bm```%eypxODGqT%%o&-yG29E<$*i4C~ zZ>ON~O`PsSip{{4A;|>E`jA_Vz^F}It}0;^8sRGN9kW%C>BDMG7|)Rt{8;e7m1&99 z4ZF9y+ssbmLQ^!m{u#dBj2?*A^SYfa`pipj%(A}Ra7F$VSE{16{NE+~PqMnY@iF2y zZ?4q%N5|1gzL2)=)%&PlA4jj9RoQc&KNF*t$2dMt$CAFPd7SU|a1GDYZJo&m7^PV> zqdEnu0786{a3t|#nQV+7(5Yx~I-xbIrRnPQ*b@fTFbNjz6C~Uw6v7Trw!)b|!?k7` zkty;G==G5Tj8y3IOA%`y13zwzC}enSKNw7G8cD%7l}_&|u4C4>-?Y-;xTj1^rm^Y=$Ww5U|-^Y>YUrYSUoN4 z`zq5^)(1q7=!JL6WsB-!eOD4{oLsbJx4xB}C(=O}+J4dnX0@W3c&it$<4GV%j)>y! zFzDw*oTZj_xM^*9 z?eD3O+OKECMru5_o+sk!_1M-ZNX*SDZ~o(Y?D+>RBK|x`th3m*%Y&=6^Xo4kQg=|| zFFWnq*u$WZOjJSPD7Zz8LM6XR^{$FG*qe*-0cG4YMgZJd*x&Jg6YIO17oKDk9}-Oj z0C6dx6U=t_NM2D@oNoOF7d|9o6cHpwH$WZrE$@!m(f$@~6Pf;N3y<*F)e`i0puSNg zTmj%j9~Y3Mpl!_bQj`CeZHbqoTe5E3Qixg!(8)ORc%tz{9$@X#cLB2^0dve!y8`0S zGK?G@xE)l=6QZF{1mxxm#WnUD1JUyOuY$>47QzfUw7h9JTzaJdafMO0m9%Mm6;)AN z0wV4(&z`2&-pACB1F#PL(O;`4@{8zjK(WCX~^B=IQ>}^Ts5emA`MBtH)WsQ?cD`gD6$L>BO=bB!czHKdWs(ehT18t@ z_)^gf!zdR$BGZ=F%5DY|QTl`rK5j$|O=Cdh&!5TJ=0VqE@+L6|1S!y%B^@%1f-+~J z#ELtjHnbkm=xlZne$vr0QNqVuNt|sI4%_?gK}oAla7|L80!PHPP@q6o(|4S-E-lQM zDUp?)Y>%3+CA1$@enJHbW}(+gYQOOGJ6a_I>^_Ul>wZCWDvAKmG-)H%&_KEr@y3fD zem4+I8fUe9mzC*GU!dR5$wBSf{GQ9A_@_%fB*=-NSLi<9=;D*VaF1r)zg-~GA{b5~ zGWZ1QHV-&65IPR`y9!bNVdEnPHnL;XB3>pZ5{Ic30c$pd==H{SgE`rDU3VAMMN)b@ z3!uQt0t>k5ynp|ZNV<-VNHwVP!X6ro^_@jN*d#I!us@y!Y>|EBSrPYMKiYS7U&J){+Vc1zvGX2I9)qP6AR zCoG`Z;S-*ZO#Ll3GTDOs`#8E$c3t%T_7-1HoHNy0ZlaN-2Vrb~ptz+pJm@1raDXws zeWJy|O!lmje02+NI(qoUJsj8n#^3Fni&Q*g{|93mBpWXO#f7&bmD6C~J2{wSkH4m7 zHsW4A{n#Y~Wl86}r?~n<-Wy?%1z*5V*9pO@0zP+OIq+uVR2o3v$f`lCRTn#xIEqWr zw7Lxql`lyEBI;h_U!JaSIX*Twa7~98XeS_IZoqCs=6q+vB!IUnNbPz$JnZ(Om%@CF zY0`q;wZWqzWY@+>Q+KY`Vhv1gccMT3nyIeu$v>7#eqJF=34Y@Ivej{_q-wXpZSYlN z@ugW%D~_Hu!Jhc?(2fX6I%@CZrqad#n3n$n!QRk#uTmnME!qjjuig)FaLKwuQWqJi z7j`KoRZV67U{vBT&eT-YzPi&Q(c9J&$^rp@Eu)$;`7ta zS-Ng{G>D;%okRmNzf14BY(A4coi>8Co^aC#v1ppYV)HxzdgCJ6&f`P@hV$T%!3QNF z&E4P+X3RhYCGd((HR~X)g5c#p<*2x?Nr9gHvW+6Tq>++xXlbLB@C|4pZqkgyfZ&>x zRJ$=*K}HbfM2QIvy;~$H267q`HXw8PmyP4PFH9SQ3nx*xs#i<~e~`uVnQOfZSq*^q-P z99Q3d;>7awSu+IbwUkaF>V$1w3}LidJ|4;Kp&1AOWW*B*jgPcfIgWyp(P#1PX0xR< zv!2{}iOM%2njmq|Ci^ZV)2(~a~qNhZ`rqQQota`MN@q}|Hr^Vk6;uO<)rR*0y4a$qgF}H z;18mWf3;a6{eNokz%5@*oY6c^uz7TI^Y*{eY4UfAJ)_<9^WNn9DR0dAE#lNnT{L(y zgY`e;9khyb6Sv$Z_5FbX)3ivC{a1O_5En69W2$P48<7g9YfVg6e|- zHX#;S68Q=WJ7rJfXN3|B?1R3u(k=^$M0ptHP~51}1Ms+23fzkRTG$ydN`)vO#=uV< zR3UT-Bvy`?n`?(KnUV__H{jbo1~kL}upRgARpSw6P%_YC?aWNXQh=!fOzC@nDx^Fv z)b=(xpCG*x;ZBInN{>NvUt1#@cb(J5r~IWyjr&MA2o~-F0(1jiCe`g`C+U9DB@H?) zgsw(okpu8ul#?JH=@zrid|edN_$HD6%<4K#ANUcCHc?NFW6kd$uKpOEMJi0#+T@@o zi8E@58Gv^z4vif}J>A+6_{w?j@^oJ`MlB=7<=Ji3FvbQ|OcIMsjr_m34xI9681F)}g^*)yYLlRYwy zm60uFd=znTke!txdlRw~4#Gh=_Ce^FA=z>6&-ecQ?)yKN3)i_^@9}!Sp3m3wA$mt( z=stxYjL4r5bc=w*y<#6xmznvl@UtIGavoJfDSUmPE8J`L<;V+(JkA|X?1*AOo^vgR_4S2N za9^Q0eluI@H<|pEO#LQdwULmdc-HH6^v@Rp?f4y7bMeOR^i4^A_&Gu;<3DlOdI9k8 zT@uzJlC;0Jfna4$9@Tf_8oL6^+X~GO&jCYY$OjybkBsE&%lEtW97^}YY;Ta6NkM)E zr8xU;mT&Z&-cn8s=ib_0gNlBWvbUsGH?S%l(nvWXBcdR>9x{jyZ?2^&5ce3GEn%9D z53C+)6s3}o_vf4*#s*#zw=2n!d;>Jgi9{OS7-B>p5J9p{3SYBI>fN_CpwEiwXpT+yeK;dN4oQ@ zwC%*?f4Ij6UJWM%s%~JxwFybVUGApq`$Wd6Qj8p%>1o5nXasXXgjyyx1JB6|^Zdk{ zI_>d%!bAlFe|>1Au!m0{PjhR)R^xv#^T0+z>w(>@m-Q-(OE+wLDse2XRSpvG#JYEG za0KNW7U?kGCM9`FaaJFc#N44a8@Yhp4eftMEY~@7FS1^giA41!>}f@p@^$l}y5{|8 zV&RfZ({s9S1q-p&cGb65KLHy<-vU)B3f}57T_&emtE7ho`GSRn734DuZNL2^Hie*h1QYOh}tg=65fpNTGaQ{dt~J&dJhYc=Cwb{{Q$0pcPy$)-N| zr_q0{1bXkVZEHZ~??;-j4Ry|!CtzyU9+>reGMj%iJK8l`bJ1D@YLdYirfFK}_@c}Aspxn0NpwN5I~r6W?Z#qx6tI~(uwbC{o5Gg8ad zlCPkZ^>C!=WIUWt-tyKl##6Ap8?De4X1442?{Is19=O{ZP4SpY=tomk9eV>di=sI?8LJ{JUom*pFxVttO78eoZV6$NN<-Efc`l%t;c#I`esHqrU< zDEn|3x!MCQyqqtSD9=>q&qFl(-2TrGT{m2Sz;~EdOu8>uh+|w$RgHPMFvJnekB7@@6p5p6LW#K9CNd%3IT^_8CjU+f?$2J2)14=L{+uood0KYTvhW{^k# z{6(K&7a`Mp(sDu0E6x2p-nU`TxtsJRJ|6|h%gN8=8zfPmoTyDp6gqs)$Qld5XFWOE zKTUn|(sHekJsMOEA129k9wg*nZRTHr(R$8Z$DHB2_^b8N%c;@uPUXa|i|1XNb(x(E zknG~K%F*-TB?15tL{WaAJBHJ4VH=>PHXQ(CKlbjt8NCW03ALEow3u>~ZEN;FoN?wu z_?q9>kRKZK?PMt&I>;4Z_kX1o7yjTh;P|RO|At`gvE?-#-_)xf>n9H;FLJTxcKSK_ zBYr1Rzf2vNX!n0khIDXT!Tu6i6*o4gG_{|+hm>NZZyx z;}6#kp>buUnNaj+PpN>g3*LX*oZU5{mS-)QE6$p&z2d|L4MLO$0s-f0RMwf4A0V~Gd;#COyYDz#lBv?tJN7zP&9YhCUP}l;^u$x} z#tAmt5^Iu@M$^g<$`v`yl&b048do>3y35xog7;0pxB#v@l`6gkTbN zQcTdt+JTF`yc4sEQ6^@QgHCaz*jlLvstjofy99j!Xq^!+qjN#7Kh?(@-Ll@E4&b3g zzV;TDYO3nUkKB^(aK=%K;LqSB(zrC=?%+9|>U6=D+AU!z(3>dY$%mG%t|NS)}471_(!3=G} ztO^0|9Wp;3zB?VhtI)Zs0Qo9+f(3`t*TsOoq<9J|YGb3ixoYcyk9TU%uJ z{_6zjK{q)kGxbBUjknUF?S3`jqf`}=V&hgmOJ`+s*X3i&$68dEthf0=^|VvRjdmZV zRa*f64|ePG-HVoUjibt~+U?t~B?L&0)k?W}CCqN#L4zJ}!S&(cC?}LNB6KB-C030} zZvtXJ5fC^*>wk+xf=E@YU{set~%_+ z%977`yjW{}-%s0qf(e08eH;=jrlm4U90%$j!OMl{&I&*d(s225-s9v>#|PSj@^;kG zse_;2k4nY=s+42G-Ew}4YV@qsesA#Wg7dw8P5Nt$SIz8oYhtIeO7OaF&UH+id)>4JG#8Ue78`HAiZY@3!4! zwASr5bS4x#Jb&#i+1uH=gTku3a)320@|74R;-!jQA*GmOHg<6}w1C^lZ z7xVL1%Z!BCAtHN4){Zs4q`#c<_$SBpnI`~`-SMAHV4kq=1+F3BbZ_YokRf*VQ>-)K z>4`_@FOQ{Dv`qMRbNF`2Rl31V?$CMgOHb*`STLkqrem|@{CMhv(9oX|aP`p}C>}`J zT}pv*fP}4nV5gt(N7(KAY$N z4rP?rA1j~z%b-#8IRd~{eJlJz2Dm)IohuNAk}kC@Gq#tWbcSw%-{4$2d+5EV!%qCw zH5~2w?;HRz17Slo|4NoFlT;2?Rje}lZZy)cDeJ$0%F04W4JktE66k>)&Bn}E8-QMU zg)?8?Ktvc(U-*?|O<3b=4O6K|kR-}rmYsd3aXBPuW*h+&6_EY-)~+HwTd(@tdE%MH zbKB@uUEjF%YKjP_kqS*wLr1mDgIjkR>7M0GB@dV17*BotM$N#__{4tf;ao}*%v+4Qna?72h_ZNm?`wT@u7?vf7Ja_wo{MqydtuyIh1Oy5BKG@cl z#Mrgo!f(o;q_5SI_2B!6S(n~sTxa4=LSl5_BNRP}>cCLRSF%OUiah0&MTi#UsoZ4e zZ*LVkBc&3vZL-ZiKX!<4?Q0|PI3^@xLV?lFk+zT07xfV5o6Br33!iW`KhKGXb2Qli zG84`kR&Wm)T>>*_(d?-d5z@B8Fx!oK3V4mElZ%-lUXf)!6YK|;ZnMVvX@?zcDx23P zVR>MX{Z6+w>8LS+lGl9Gw!D$iSehh+t^gFy)HGb0u&jvoL##Zn{v+d*G~;>fup(>1 zTLD+2@w+WunN^KwD?Ga-eX>KO7J!w*F9dts6~eMgqckv9F7HQOE-uJNLOI$*n?!!C z8Qw)$GGIcCxO=8# zr@Ob%|HWxbgwB%=!sVWI)t|ZP&LG$4C;9(U_d@>r?FN;LhAzTI7h%fo$n?^Dy4v<) zns9E{u??naPZ(UTm0YG9R9uU^6+li5*C=uBYMxS(Xj3785+lT2iDY<~oW-^c)vK&5J*L5e3-XvY^WS3S_is6x zrRPQ$j*qXo0j{nxXrz|2Wuq6O($olHt6c`3=AM=D+@EO2SftvR!l$Et zRxD?CYk4y84PIaQ=S>0*m71rRPgMQfzo6WR)9KR?V5|B?I5BdymfvR0sY)lo-Hxh_ zMz`OY(Ylp8phBep^<{t9-41mtsSO9V7atNmVtlK|TgTqKmG`jG?!I`nHmsq`t^rAVXX(G9M8|?)tiAp! z!DveKS`XOp8C7n69=7*V-{?LHo}y;T6j}bd$i&C(7xyP-#fFQui|;YNLp+%trA0>) zLr1`X?699adSWjFlip-LoAGh=^!B#v3Rgk{!TLFcgGPj&9vYRuc}r)u`R8T%tql#2 zO{XrF2(NOg{-k8KuYucTDL{S`2)meHy87=nx*Qc0afIbx4NMH%Fls90FTGKkh3v1} zT}`X3PAFdvb^aT=le&2(!WpuO_%9v)FU^ya)>%*a96eyG1o#yLYycpr@oM4(tl z8x2_(Cj5CGKK-2Vk8mJ%VL(ky-Fd}Ez<`(pUG71PrHFs>m)mUJb5lTiPa}!UkzDf=ZNCXdOs$^ubr*#C?WHaN>1*$Z*YWutniWy3`Fq1+{%H2d++)>(jrQZ^=$A&TXp^}Ir6 zO`7Sf)ZymJtL7k+vzVYEbEVe9KOb?f<3xXpr9^Vw;!8;_U33?&-?BC^*jjx*TA%?H zt=}AdDp(?g_`UB;$o&jtK6#AhI+EbTlkwOFtKV|oZQ7z)7NOyU%_X>kF9~u@7z{xr zAq1m~qkvYpb0Qx)yKd%CNsN zppRmhiW0|!mW60IA}S>@wSicAc%5&jsv|xRRttv+SpMff(zYb3^3|INvPBAlxhh9` zwme4KED+7U7j|YOP0^_99}x&tARPaMRwxz*Cd7gTpv%u(p7EcS=CU*?_l*;Mm6hHZ z948&;KcjwMpL%C6@-ow_h@9ME_)sLX{M%RCKTY6z7u#>izi9dI9YGASrBYCcr~D#w zk$SaD0G8(;79M~_za1gX;4H1VeO&|}a53C4+WvR^Vf)EtO_Ivh^--mZ9oyTd(UPZo zSI0|NBTMHad!dWlSIzlnn_Yw@LdVoWS8|2RNGG|Ut5uvR&mj2Wt5U`-;j zmu0^!+`Ghqjy4+oI}JysIB;Pfd#htw%z@4=Q{dbcc!|-v7P$hVILX0!j4(>ritjva zvm->uaD;9oKjdgpP-t1v9P0SJ9I@W8_v?u4H>uT}xra58O@^K2taXXwoH@xxm4p@c z`4^H%4~((xAfNhW&DLKGnCe_2-31MvQB*03F7pa%MT*~FAR{pb6f}eQ#{KRhu1_|J1_JDk4?LmwC zo0=Y;*=Qomo^Cy{{;web!ubGLeIqW@xmyDTNl~B2@ITa3dKkg1FbFjqs%J(u&7N7> zj=COxOV@;pUuzQnvNLDU{*yz{dEgsmrM8Dl18!Gg!)4>UcGpzPlg2L{j-n8sk|w1U z-@duW-#}D&*S}j(@2$V>WBW{fAHB!#R{Uc7IVu*+MQf1xaj|xVLz59OL7=q1XHb6j znrB6r^wx1}cqk@2G(qgCxJ%dG`KzrpdGW;y1=-RP8P#FvBx!{rjxfRfXaNB(s4uc^ zx(o9NCHzhaR#xiZiX!K7Btd$L%&W!Du<{bS5K+nX-z87&;dRWb*>2tbHa^Z9_bGR) z+C`e1kBc9Hz@S6;5I`8Tp_h5EHbOe^wi>xpJy!%A&4w^ZeO=3ECu=+ak64>*6kIQU zy1i)>_NBSbymuKS5m@khCVk?u&)XiQ@x9eo)80OipWEjfdm4PSmm&H=(~r@O9> z><$?14iG9=2*`eZ_{mANP0JrX!bm1FqVum#*WY2r=BB0+pkdQVqJwaCVRyJS{WtC@ z;tS zX!5c&gMACLWkTfomm6jj9by>Y_%;bpB62D8iW@q%$qm9c$`Fxu zysBKh2#|mgMmM>#a(}+5+&v*ZSCjPZxzCM3BV!3IF5^)b&Z{x& zph;QcUBx%*4v}kEYi79@0n;i?&KzuG)jXt+WW>-1M$54G43?Uq3!U@p)#RQ-R$NnZ zuQ+buGk!=H_!KgaX{st#Uvrj8-e&v#!h}(S`p)6g5+it&KI7Zc(H=X7&%_(TFLMd&+Lg3%bqyh;>V=9x=G+PF=%C;JqTuRUCzD3 z3$d5ho4DuYkx+Gw5!UFX;~8rD(oS|8)VsH+c-*I_jzZ=?ZdU0=TBp9GkMJ-4UsI? zajMVOTxye@qu!`nI5@oNkq{w8GZ7Ue^Nr1Yfg|((+mBKw%*Aw`<#e9WcU@hFd;vqD`<0LDy8dJm z{*)*mmErRN6;F<)X7rf>h}%1u0y#|H1dy7SM_Atr-Fc{Tyg~y2J)9Q^0?6OX2MC1I z15QHh9$4!v>;M4)|8|$IIDsKB5B)!M?B$xl)!IXq^Kr2I1&H6P_pM`@>xwmBq?YM! z!ySo2Kvvklk6mXIDwlPfmvvoND*qCIi>34P3XVsKNr~zdko^^qMW%9cn{c)){u2D_ zV7IJW#k?AoJhDB($K7u@$2B)~wTU z+?KRngC9=>xs;n|1G8n0yG`iU9BG{EW148Ohs!G~o~GA7gk1A}Avbw8k>Zym$m&8& z>>9d{(lYg^BKv3+NojZ;b${q4h z(Y{aDcBW|X66!6LLSZ>3#>RuIyljuD1k++fuf2(&GZJub_oZ}0d7~$Yr5cA8N~{`8 zs)XRq+r=Rlsh5!?cpFY@JS!)9AV^*b7}yyMCX1TnkU#tGiYA;ooiWIqXl5G5?1gxc zzVArRTx^SPq~v6boF%m};&bxT!ewYD!pFBl=TItM7>Fg3X_?3BBw`bIMdPe)`)FXqkO_e8;BvLd+8?0Ahg; zV{wWs;m2bT$VTAx5inlu_`YTw1(!H65goZ^B=3hG{rY|f7l#>$FJhq8@)|wIkE+Y;if)EkTguTpfCVVewF>s7r#Q z$4ei<>)@DK8*S}Je%z~667UQA>_LrrddJP_weu7Lia+TBW z|HRzii*15cSG$*|{lL{KC*f@6sG_E`RmVD*-j{Ht1Uda7&$y9p{)F2FR-S3n9xe9o z_pQptz3|aC6~a#dPqYkn{wk6Z6X$}?O0L%OKSu*U`@OgKGPvpO z*b~seQ4Hbx)m67l*kRYnmPd`!XBFVW6#zMgJEMvHsVb-B`Gn5Bv)|sQ6NKMOr<{ae zInP@Z+7I{N3Ca50FyECdy%T`odFe2iZoYZRc1JyQA8-xKu6i@)&+*|)`iHu(WxmT< zcV~}-=c%oJo2JNbFDhPFRR2w=8Gq8mp;VbWB(G%OCO}o%DHuPaK3`J^eSly*VaY$( zM^#*V1>Q3r)HWK-nUmqKrwiWgiq0nUHU8eZl6r{k$7*Ukz0}?jTMmi(yIeBYD%@Us%oVWbDDXN{javavK9KZXRuQj}DodH-nYTO!q_Ckz-Dq>%ABoVdWh>8RS|rAyPk2GHy{s zYj;0b&D0}ZXi8S{w#?o18F7W=xg%T7!aA&i!S=a+@33byDV!83$m(Irgdg0~e#x!FgxoP8en%=t~Fmh!3IGVG#5jXHB@ak^aW3;{^ z@+y`flu@{*Bj^OPa{EW%+zl9%`$J%m&&xmEVwqJYb(kaD=|-gnZhqd43uU}+Z^XUH zTjZt>G^SD}1`jSTPWG_Isv4S~%@D(-0E?xoe_~i0Y5JpyQ*?-d!Om>WrTS?2hTY5X zR+;gK2X%7}G0#a`n-*PUMEitgf+h^7#KI5a*@6%;%?x(uKZf%EP2TA`8vU0w-wdWA z?)fjBuFw#+K(2Z8;%T|cxhb$+0&E%li>+DO`4?;O4-FjW|0_uy{JU9_e||y$cJeQm zu5biuh{`!ws#Yx>b6$a{nnmD1EbJsHbf=3fV(+qZkI-8~K)c<$+EzJR+TG*)*OC;f zVY;`_8HPXJ^^iZT0rj1$-Xy|C2>1#7T26OdRa{Y;3*+5gO9$Z6=ZHJpL6a>v-WZr~ z>uyXTwzW>EUQK3uBb#FaWO{s{+%8>rahR~Cb=oS<9x_`sXI%c`vwu^laDmE$^{M!% zxfgNo9pR>}G8aL&KvA~6j);X21nIWZ+PSCm zy>1Vo$oFY8U~hjPquRK$J91pfgQ&a_>8RyrM@E`k$Bn<*3_GbAeXn>nxmehFZ2yz7 zF{Zlx3rPS7gDi*H*a+@X|!i0Y+S=TW;-N$PWu_Z zkr8d3b%<#uE*BD_5cgW>?qy~2-ZlQPcagFxd#_v0()2nJOpTN_2wSB5@w=hh#?@tr zXV~CV?|K7`UMitRGdw#ijsmW*sv!(DEnD?n&E@%4?V(Qpdl68=}l$@4oE~=AMH3<#_l%d=rDRKv8}Rs=kcMrd!W$FA!$7iV2|Mp zp>jB(LI#2DCtZ!#{Hw}8%aXZFc^>S#a{G~wV%p*tZlB!`Mluy;nfIpw9>_wa{rt@f zUP_sxWec|KPR*~vPkQ*@EZ1{v8pf{upb_=h%0BdFw{ zNsdyXL-I|l{5?ekm=RPtp5+Ix9=qfudzBRwV90xPDU6JDeZ8AptJHbP z(yemFOSfB>ZK@jM)^bhXWZjfBzVDHh@EYJEmRwKKH%Q$6!<(tKMos-}kCWZXqvLra ztEnlY8Uw8+5>A{Pc$4;|jPuQS$Vu^~$L1`2QRnl96wwEFGI0oTu&vGI*oTnihNfq~ zeIm&Zv%M5z6YQ^#rYkIFSG8i|T5&NycdcsJDOfG-hWJU=zh5?sQZ*&EekMc(_oxAq zG?+HcsJQonb{(nSJNq*Q+KkYqP>;1^;=X6_dV1d49g$?IYYajRwA_Y0r4g^cqJ{@_ zdGFbYg88X9%OK@acilnIBTgP+Tp^V)EABt2>EVl!#<8L&RtuMH(^EXSJ@gIqbG;p* z_ao7dFx5{fBLWdnXhQallwA+2CP2qktvR>r?@#>0hDV~etyf<^lyI7n<$;Nw!nBc6 zC7rgc9%wxQ-tB}P* z^dvdnjLW8KO2Aa5l;Gd+`AYvL@ttq|XVX!OVEQlzedw<@x2`6;4ohfgyn*%HQPa4~ zHkA|qF0eHa5b9Sy`=>~(7Y? zU!qa;#bXvjPDJ%mXIDS)8kKyUej1R3lX@ws^w zajZb;k!Z=9+CDnXSmRTg5G?AQpG$#5pK|e#+pC2h2G@-r z1wj@tT`le2+oH;+`qIt~j0_A!&gKqaQA<}YWct=e+RuPfpXLscj+rS!$@qp^os)Re zBztA52@6Xs&)?ylb{)AXWjq7X0ELQ;N zH{kKyPRCY-C8@1ilT1ww=AkP%C2P>DH6>Hn8Q&xJyy~qGg`>9MuWBu$@r#Eig`ccr znjurn3QnI{5RSUG(`RF8ovBoivA_;)CR!J5L9@?^6wsJ&3l&|OZPf{N9{BzujR{l& zTu%}v4Fc*sJA8+6tuFVnp==daj$-y&PnmW^@{4)qn-&w7{|k`g5MF3|{vu^uy3O|z zEpwy%{5x1=2k!3eW4sdmAOWQv9=k}!0NS<%17+ zfW=s_bBu|m6uv;hgv``~>V@mw5YEb@;S6xoqg3g$gIWy7?+4`hGw?zp8D{PgXCs7) zJ~inb78NsGv>f7?MfpTBo>CQx`;`^HE96Wd`@{fMg%$Ec6t>xTD3V+90I6vE{9Y*eIwWa#&wv*+`@L`nmZa+w|Vd4CEZ z@(f4^vL|iEipIG9tgCGw#+T3by-&=d-&0Ey(P-URJiqYs1cIs~=Nl2jR^ongSo0bh z99IMrq%CYrR0W9Xrxc!k;?xt8aNCkpq&z+EzK1ampY`!$9*6+WF|NqE4U7QCP9$9vNzWg$ z(LcF9{H^7~1v2~d_@WEt>!~NvUwzx3^;0fx&1rU_0FR{h^K4O%mE=ERID5abBEtyE z?+_7e8Pmft=70x}1pAFmA1^iB^pt&7+?k_y2Q$~{9b;7;H)UlVc7P*wZ4GMCy?!$h zeG?v2%)_!m-f=aS)hTi_WAYPFp3HnIWPlQq%i8OIHeVy93 z>7+Q=0!YNHyh^1&epPU-YQ!=RVP>m`Ahd|j*hymKWZ(@v6ZXtR)D`%ysEM|1{qI4aM0m&~`txiVNs2|cCrtxkukfE>_%Io1x^kHe{-EOmTvXdZQ>nP? z1$okE!r;Mp_2p8`ZiQB|_HY?@#u|&EhUOSEQ7uML2nIJAoMo}D5NAP<)*5Sgpd?)+ zSo>^fzrK)}Wg`-R8t^~Hx0llz?I<9I-R?<8Ykp39=MVcN8W<^&66=V3-VVgZX7 z4brc}pm&3am<5shP@3-+q!uR$%6U`o9Nk`n8?3MZCPgadc+uG$)mZ-emyOArx4DPf zHUqVA4bmc7Zpov%{QUQm&z@*I`88bjTt=#UR5miH#^kG-GSaF-liz{jtrtWhOdHc8 z228I!y&d+aFS9H7IXn%F*x%a&sxSK+F8_xMuzXwF=WF)r^5Hld8)ACDU3)Z^?eeT| z6vHa~zCmZ9`sRzCaBBAcLSK43>#UeP>-Bju9v9|s3IiW&I$N&- zD>^fk+UABdr=;^Gd2NjM>|dpjkwH;#N>xuvIxCr+#d?(2G%LTyZ2%0KC@+tb%|WmF zLXQf_V`5S_IUwwuoMq+y80H*f_M~k7d+_5Piew?vEzhQWKjL01_Z>t)U791Rs??Zl zoR+1j32A}2?;w#!wPPW|IL`gehth=~){}A5+M~5P2lcRQ@1j}?tMoYao}^CYpxCStTWzYqVbHY9|cIsc}oFUK_Kx^>61Z z^MdzI$g>I8xoWK{p)T^i6zRjC*~$LcX9%emG7lJqv3{pJXuMJh)9f(TpXAT4=^FF4 zxa#QECqL#QCF&xXR{2eaxQt)qwTM+*?NG@E1>1Zqh|~CZ02r_j|7IU%_29+NoUFaR zK_q;#D_B-8Kyy7DriVbE~iL-SbM|v59?p%qyB!pVS_QRPQeBj#q4~c{uhj zea{sCddM~ZNStnq@!Uv>37ev*IAwyq{90&ySP=0FTa zQFFg;%t+Q2r4{eZ6^5`#MJEW#Ep1zsNw6lAgixtYYz|wd8h>wralxQ}N?Gu^9#9ux z{-h;Ms~2*wVpPNqp9+8jeQ3%gWLb=1 z^vcxP%k>Yhv*9W|!9fJYxu%4|*yhi!Ynd`8OK?bK$dTf6;|2AOinFNoZ{N6oGL&Em8p+UDZ;;}_X-(c52xB{^1B zcFm3HQ(YX#j^J?F4{7etD%DM3 zs@M3-89RJuLA@W9oE%CKu9!V?tmgKq9KO?jtE>q5oa1H&tLA-eO-;iAImR-;Nq6b_ zhivypEv$H=ETRT2D70zqp>~FCsd#hsARpdDBPN{!9$j^$!5rEHCJUgBB6umUx&1)3 z1`$!hUQ@sWRqtve6I+PZjI|$?O|lx`=k5%a?Ine|&G?j+dEI~~mgr5*l{{lrq|3fGwnzN)IPsq1oOQOUE8%oRT3h=M0DhhR6; zH+lZ03C9g5X};hf2!QtJH=!s?L8bUC2=>$hCXLY1Y$h7tv~ z=A+$z>6#H&I*Xc~`;`|9Gc3q#>vdS(lle@G<4_G$Y?} zLPe3IVBNO<@9@p54)Yf3(Z9Ac^WJELCL`JQL(d!+_qJ-gyCEuddR%-x=z1A_ey=v0 zfJIMfV$$-)ZKlP73CfTV`sW6fKg9oxZc<~6u1|j%e*%1Y%$ zs?m`_svwoZ2Mhw==4eTe=+NYx0U8e5uDdsRH^8zahlY%6a(TpatI9dq#xJ@WY?jZ~ z`W9Q?9pv__$oKe$g+Es_T*2=9n0vli`U*|3|goo z1IJvric{1m%B|d`G+Ne-|F|joVFgvIHHq%0XO+7_W91}L8mrChkB3naNc+2zsfUSK zRqNa_b=ZOjIv8y0N8Mn~LMfEzxP{@hZDh-*NdS{%@Vl$&-I9`0M~RhdgXvFhdZHhm z1T#^`Trtx*QP!my@p>mn?Ce)A4~Ifk%D1Ndg}(-^Cmz+_@xtjH|Ifu4^yONTaCcq! zD+qq5)BBBM>x(YBW?>kZn@Sr|Uo0N&=C1H{sDhPLI7{Z4-$RU&bR|#v$_v+Zlb7K@ ztc8s2;vW*SSCT6U#A8-EYQlC2PHvXYA8RrBh$ zflmXUzLd6@Yo9|BHY?M}?z2FNwq}DXpG@7d&B}jFiudw53s_ClY-BdQ=UAM_V_AU<#++GnKQyp59AR-06Puc6Wc> zArL7=T)D0+dVf-eC~NjD5(&EOEZNkUk*JQ2Sx-Ra)X;rUko#lfGr-qR7m_-NjBQP$ zHM*}OGQ3kcDo5m2#mBdUV4s$^Fi$f^9Y#3a>?=3@#3FULI?>V5kp_eO$}M|JYpQvz z1Z9f-=zw1s^xdv<_{Gqc>re6IQ-JM_yG#SD$9h}^V4~Ie`e3rw5w6_GH7kqSMG|k5 zEa8s!TGG$1Ycw-?1Lz5^VdP`nL)Aso))sG%=t z=~3zIngEM(am<0kKHDnf=X2b?oo-A`bL`suOwP4!{pa7myr(V_ERRO`@MoK9L?Aea zfgd9$#stLAzEb}R{*x~UEL=DY(BRE4nSb^-SW!OKR?vCwUYU|}4=#rGbsgHm+9MEy zW!Dib&-QOZr&)cX;%hF^6Q1|M8-<5V^uE8uXISw$ zN}~tV<*icZSoPoMhhDeCCN4!k539Rk;y+8XrjcK^zgX}=lRAxjT3Fk^v2NRJkrEiT zFrvGlDWTBbBR>2Fw1_&e(^!T?Fkg^HdESj9ALMf`ljo2rcLyWAG=zxLtRC=?u8rfU zfP^|+53UPTtyFw$oEW(Fxk7Zw7V;_Q;#jwZ9_b67iub>u`0w^>6YBy)1%554X7bQU!X+VbaWpI7cD0xG$Caf0iZ7D7 z_a5~aYMZVQlQQI}{7@vLEa5ht?t{lb55sFt8NK1BlPFsXM&H@vhRZQj|M$eI`_jr& z%!n!_Zc7znu2td}C8XpNzshMS64zaK zMp9BnP1RmnR!huH|0=0d{-Q}#G)&OY@A}8%|QD!*a zz9|M-__^(*Zb^Efwz`EJa@*b>ZRAz zgtXoW?+xjZ-p+w{746GOGQ0JO<#Ot_{^Bzd=6`@Myv%{>`k^I3PV4A!3UD=1I&Y8 z(NMD~V^D|^XEW6Vcs;88-(RTd8pgXPgxP7D_)emZi!UZNac&Hia5;Rn*W>TH0upJ? zb#j@VN!TwoemnGZA{jTf+XHd6#c5%Y$b0`L1YvjXl<3hvIsd0K+C?B4O3jSD=1U5D zeHdP}Z13U%y~$mg*5oBp2)DU$5=O)2)X~U9q{&;fAi{J4*j*Zrj9c+!S4{FpEfd3H z%MTOa4xa5>66kMc33YK;)={Qh&Y~a3VGN%Rg4NJWnntFBq%UkUyj*+!(`wpHH(HAh z^`=FaekbniQ(uDyF3w9w;buwu*<#)&IAHrMIhsN{OgY!0X;{D>`F&jf)Zpz~a@40v z0x7F$MVl!+QChG#x7SeGW*~xC{#`=j#$dQRr#ff``>yA(aXFEwmnsKwuutDN{lXo`% zdWtp~)YMlwz_!aR6JAp7<&o|@FZ8V{avqyK4?KT=x^N>uY<*o!3S+-|eO%Tx7xdkd zM&<H6?X4W*8d9F~=iG`6;J_dJX+27kJ90daL2sh}Sph?<;WJhOp495k2*v&DTA7 zrcx&>|8ze59!I>%onzc$rlpRL^2tz8ciem-(P|55LuFLS%n<^ zFgJ}GrKK6!kKbIRj!Q=LV$yT9cWxHmB!YSj4oAmU6gUiB(|I&>_K5MmbW;|t^APmJ z?aq2eQ+)7Iw7aWs0C8eqb!1BK^Aj|F2aL@?Ao1&ujC?%jlymz0rSVp8A-NWdCbEu28( zqr^WJ@M%8sk^zoRPi0k)qi2{oiJ3(qlp5GnPVS$`4&-nfE<%4N+{9s3?(_jbJtm@` zv==X$2bW8K=iIr&9$Tk;ygMKE{6BUH@ZOj3+hZ?mDYHU*t5EU#%Moe?2!u_2cy;`= zZ#4XTcdKVr-$y{z?Dor++d31oVbv5Aq}U)1(>G#HWuDYsa;G~)FO?}n_Jt$xN)Hb_ zEZa6=|-a$+>FR;zDLJOGGD3~D(|b2NvW6Vj zzu99+Ph#O8U3#-^82^qv*ls#HA(F@;tdBLv5ryiRQ5M0#!WEyxz0C*)jMREEm?JeV zg5Qpoiq0vxa$Lr)Qk95TM^v01vvXg4mHB*m zjf!#kAy!yTr!CGj?&Fa8)5~pI=vqkoh5-<*J|dCw6bkbUYVA~j@5a()PRmya z_`{_a{tNVaCgG4h@zI-U=ev)a0sdDM^0{g{$nA9Dkh54fYj!r@a0224>w`bDe}r?X zC=|y0@t+Ox^sjum6nI;l*1#*jYqtF@S)n385m=aGyCohps0=pC8}}Hud%k`PNsbvL zyOjJhQ9HerrR!ZezmPEJ3YwEyxor@dgJVz^o<^^}9u^rw2+0vN+wWn;WWWu9MzU(X z4+6#M?=NXU01fn*9D755&VApG5XC$AiA}Ga zAc9T^)imi>Z@g()w{-J`Qn{R60u?|!j*lTR5m~Z1J9CcR+)Pr>(>XUI?ML+sofVUX zR&0KS!3gU+l{ZdUH#Q=Fw%I$o!q+63zQ70olQpihUe>d(&*m6RGIknuy1Z^8kH5HX z8#D>RY#Lbf3Lfj%9Q=GUqgeS#4`S{dHt{~cuC8rn?F5xCr1#{F+hYI<4Hq&Bkv*9} zc>ZS)h=*U4neGzX2u(kd1=<3h!dtj)ae3Zka0lT0}K`LVm;9idUlB zBt<`07?;WR&&?NnTt+48-LQ_?Q~;q_+x%sFiRt{kwK>i4x;J$$xaT7IJ^*0JzS6hZ z=l89YjDO9Pr}&H`4(K75Hvql9+o^}s^x^m>;<9!d<{IM+c5xo_HI^V~iGD212&EmY zTPSO*LR|?0bbh|44u9c@l2 z)(X8jQ$Z=yPr$tP0E+cezJh6aC(?5@ML&$$50}?C?&8;uefEJw-Sr+mH(z1g37jsn zD!Y?^^u8r^CQ=~~+7K{GCNxtsuzTO&q%9#_3=pbJ59m;byIl*oH@iRBc5G<4gr(Ou zb~h~_xe~Mu&e1IXBzhY#CYP&%6_^Xu-V0SsbqIgl`fX79BeJ19v7Wm9~4b1dEUgKP}m)OF5I99CHbgD!F4T$iq2yxWQ*wK_0a}C$#V{P#l zHrCJ4R+WR0xNz^GhOg4{3g!cLB)TT-RxzKmPO#tL=0Z7(#8l5Fy?M^8e+$F_f)`>J zO?eOOS5D04C%Saq=7(gl-BOKTm%c|n-9GDP{+PZo!>C+tRZa%*6nea&qVwzhJ~UXr z;bIe2TltO|g8zX;9KW72?1|I?@4^+G7~La!9CX<7>}(E4tWg}!23kn5F+C;Q>q;SfZij9ZPA64tHVx=rUq`OgDn|&`e zaFWH^;=gc2xrBs7T)6%?uT@9V8EWtkU3Ynkz7y2wo49UCG@mpcX`W^S?e6bi4+kCI ze@8lWVVAE%T0C|*rEp=)pht%&+y4U7@kGM)5&Rp4fbLAgS~8RMY)zf!F@4Qvog;o? zt}paIR1#R#;XV26l!gf`EPE9HMd6@3F*_uQVSY#-_YP9{gkiiWJl zi(|&e{tuGEdBldVunehkeHU5?wHp+EpqKnOxd**2vnu8r9glByP22Iws|D`9!*#+k z;Zfk)bfWAX!g?PDS)n{-8@+Fg_r|#Xb@x1X%^35$*~ZYbpu5ebW+qQO{U^~bgiqg| zi82_64I4fwHbiDy+mxt)2T&kX0wYzl|Dp^qib!d@Sr}5T5qG$Evl8gL&&&+P=^Dz# zi^kMGzogz^p-Rgo?*F@HWeLyA7k)@;ibB}48)*19+Q(Z$Dk1tB-I?@nF9tT=`5g}B z%?6G><#ovxVM>gzEf2s06x&F3%Vt~+ndCUJ{n*a5M{HcT{FX(cYF!nw0AEF)MT81w z^2TaRN{$9wY-c;<3127YiS|mBuA19t+)p#r-w?JtbNmPQF-1OJh_%U+qK!(cdy3M$$CcP zWbITL>(k!pvhZh)`nbHRIXq%?bIdewV~7TqA!{U0&1bXqtTQXmCuFT3RCq<91Uhr| zRY2P;Wq?N@R6(uOV``XlMzZzb2vdp2$`1$_L}8hW7o3U52=^o=ua_mVktQ=Jxbm{7Yd=>Qp%|hy3ZB3!5;d|7jz}Dj9Dngd?M7=6OqXooqd>nr{v~ z$H6#h_|7rm_*92MBWzfu>XyFZ2@seVfcH|>K=Al7Ildec-SALWQBJIzg%x`}XZNlF zes}vy>pqne|AZ+wHyAp^FYgq;ma0GLEqW$v2M4fh(UvHtr>YVr#d{19I|U6b=iK|s zvkgm=N=Fe_I`O91&T=x_7#HDx_7&QY5EQ^KG{hTDt|^n-sHjFfy0T}P&WYX4=9qmW zjHNSNqssaKYdD$ORV2@HZ8)MQ3;`2O6wCBPDtJL%4&>0^6{)XrZrg4&#OTE7ui`IZ za21zwsN{h5FQiK%idKyC@i+=>^ug+3-H^X7c<7o_y6B#wUq@W^{{BKU4%QNy^^wT> zv5oy5&nJ$XY^R`d>vpkUu8-@UX8qR9s60e7CR)Ws{4f)=8t9$tGI883ukzLXKRtpg zHlPN-d8E~k9kq<< zI!Mhj_Xg9=XTAF``)-ocwIaw6iZM#@7^dp~VJYDDSy8(jS;=x= z50u%l-`uO7XnL8c^p4B3W&j0zWF>uG4>!OYefo{rhXp^gwD zG=8sH`9mtb#=tw*q=4;%uTHaOn(Y03n=jEbJ!dah&AKkS;e{inR`t$77TYm~8_qi! zvh+#6(qTN`O91k9yFv3$be}m@O2+j}#B;>y-v17%$O9buDbxV^>+*JXW83T{p2{i; z7~pYGRY0;Ttc{(9f>Gu=*kmSXx$;BUVDwTq5Wh{IHDj#53%ZAq1~+%Z|vnPMR5Il_DQW8jxUUA{~z6Kq1sS7@b&A zk{$0~NDv$lf&2%f6&fDF7{~R6xt_)RWnNYGom#5whW;EAKp8$xHH|h3K$^x*w0kr4 zF{C+Hp3ax!gQ$}v&BSE4bE`YtNIA96dDYkZO3!foN4!aQYkP-6vdREy5&@*PJam`9ctCNtWmLRPht;^bxuW-*>~BE`s0Z` z9PapE3|lAmq%Ss5zt_25YW(YTKUUl5PWvnC5A*zIa3MyUS@u;_dezL=my{#zSBK7J z4H|rnf&pXq-=NziP4m)>*oDmwuLvjMl<>re_RsoDo>{xfb00xsc!xKmwiNNyDb<v$Mwl!QJws(sO$1RBt5^QO? z^t)mkafP5|XOSI!4UNoVCLdAyjkLJR;!d-ci=+N-xene9t2~$44>mx4uuU9eJp4r` zIS1Ip$wP>tq{R&aaa2`-a6pL&hfT|42F}hBVA5GSmA(^1R=9^_f{^`@rCL>MPS%qu{RZf-XV90|d=94cNg`QQYA9g!# zmW0A=elU${!+pYW<<~pHe|OV?@EV?;BtgvsAymwVqO8k@nlGS(y}e#fQwKWK@7n%_ zDCyM3srMUdyX0l1RW~vYs^h;J#|#jt%efr8pT||4AeQe@QF4)%38)hx0#D{(9uJe| zw*Oj`9=2g<7catcdHq>g;A|^M!OV?w*>CZ7)!mG(W*mqai8TJ$KpQeB+!5Vq^W~L> zL(aqJUrn1z9&lzl%<@Vr^FkB&@hsx_yP#w|c%GxO!y-GkIGwRe*BY1Ev#q0}!Hjnz zHAo8onOz^i@b}91i7R7LgI{M$>K-?0t$eg1=T9>$84i!|W#In~RuT>P%_pOI%4W`PBq&OKnj5F|1ui*?WpVHNO9ps8eO`aL3ExOcYB$^ z!;fzc|GjW`o8#7kL|J{(_r+lDh2e2_mAIG!GM~z**g(9wthC{gx`%RaH_dBy_}Pc*>+`kS0(g-l>a1HB+38gBLb2}1<(Vljyt|ysK9B)d$aWB zWfwS-S@Dw3i5u4}qi=0omd-=y`Dk{k*zB&QmI8u&xYgeOeoxiC85X6aRFU!ADa1ll zrQV_ zrK$QOaym5lMJ0IW`mj-n6`6GYo)WB!G`I{(%pqI870?`Vxtu1?VTmqIRT;R$QRun! z&bLnc*Bra-&1X-7^YyuxvwB5pOf^R({3~#V<`PtZgRB*iHDDB$gSXb`g(H1`oeQ3f z`(rDHH;X0k>}`=Vdf`wms(P%acpP#&`pXr9!ezGk=1{HP#EDZx+!`v$S)>1J{%EBN zuBrInZQ`!ZKUQe(Q#Lqa z??o@?S3?Jk(I6g2cWO`A$MxmT+6kbEVULG#spZHE3Wix#J$BgIuvh>07W3B2D`|tF zSUTc$QC$?ubc0hi6KNyq^{&dz2UD4i%FYoGhZXUvJ{SN3`hte;T}4zKaIqEM{ghn_ z(c1RY;e&e{GA}89Ui|_BC^57vKxNy*fJ$Y9uL+OrwGtVDH%JXk{xS9L?$!F2v(_I0 z9-t?(;D$P{c7c0NyKtgl3y}`5aFmC3Xk~F(n5!Hseja%X-et zwx+pmPfRKiKPs{VbPt9#W9NcSPcw{-AN%rgQ)wgD+7RjpRODZmNs8HQ*r$@0s&h}J zv^q&mG)MFYQ}5lAjVO8fluEO&KekxEC=)g9DoB6$v#)8~vAIQ$WEtAh+SL~Jx(H;I z1t$Zc>}^s_6}SPf(sr>=sD8Juv`$>YT<@%B@6H$QX4Ptgx*6?q4l~rM1d4Toez`Tvx-I9=su%i<0dT(lyHdP$8nJ82D`FOlh1K_Ij|d3~34qE( z#-+R5uYcSxg4UAZcV}k)oQurL3Co^9#g-5NK!olfGR_$L(eEy`4LN|I8f?>RjR#bN zoU1+aG6T$+sm>8Kh8SUB$GqP8JHjiK0nuXb#uKF}GSeLruUsly3Bzo~-)^J3u zDm#8u+ukb;TOAbLM^es7Y84Tl@#)acq?boUj^J60q<+oy&Syw^s7FW zaYOA=h1)}2_`l^?VQlk+Bf!`94PBN-*VYTOP8lgtLgVr5;?X- z7=fBQb)UC@+_=JnRFTdJLFX8Yzac_Jp54OuNQb+b=l>;*+mvN-9+?Yn;>;&Pj8s(R z7zO_}(KdhGjCEmrO&as(5s`dxiD4=1{GS3nZ*Xe*r5Rum{91T$U~pjb{G4k=Jbk(9 zsPH5F7oEI8bPrpxef3IlbaA0ONi;-3jzZ(_c@;l@V5BVB6HT-pdS0E;@XzPW!Ipi62{yc*G%hQT}NC@v2bZwCG8&68VY@Mfuv#0s7bv$Obj{e4IUIEx3l% zR({WCMWU(KeuDG)*1E)}<0s4i`|^v=zyF=ODAT1lbAI!4Q+MYo8gKG<`iDc0n`U|X40xFN$V;&Lu%@j&<`RuM-7OM8G{8~Eyv6?QEO@H5 zp+GsV41Jt0WbsLGRY|QOINP8p>p5xI^MWtBWSj=}*%I+MNd{%QX=f=Mc@On#00e<( zAeBG6m}YmI;a1Y66Q0k<^Yf5}^ zauSx6ax|H5*Yp(~Kj6j(V_TS$lY_y$8Tn@N zz1)_a6jYx^*gb(2A{^~1^<$(p(jekMff1({X;m8pM zQQw7q^?(2*`+3ke!0-yp%Qq^DjU^62agM^zGqcTyed}Yi`?nT~h_gY<_PbJ7x9zP* zk``+jq*b-tJ`i^z23V}uX=5zSgaV}9W=c}EzyotWd6=AlQkgYsYwqQ7)O}9W>rroz zH|%^RD1!s+qt4%z3MK@UDn!Fkh@IEbKvu9}*A6B8f`CfeB}X&5`dOR9OffG=CC=f@ zFeWKWw!0bUhHW%*S(oGlp`%**xPFphIn~9`;&&`ZNdWS6wwhgVeL?QQ;!~{Nx|NhE z^F&yG(7%q~k^<%Vqc2T=paLi6zMwTbo2_Q-0*YZm0DkPR`}~(8_&spnZNlM;nM-?T zqyFr_OaHRJg7yrqjCMLSb@d3VDKTy$<%eeP6f$xo@R?cW{a@u5n(FlU#8DsGfnr#S z@SRy7wtZOkM!)OM_#=TIN?b3!UDa}#VIqky$3RgNx8i&A_W}H1s~J=hr5vOVy;yR* za?e0X;`0HiGS{9Qjp-q-_m8ylau2gImL%~l@neNEz*6|`@Gc+=dyH=ESG(xm9(I2- zpWFLOznAVS{xkW9e99gx18CEkX!dZUAiIDm_zkw#e3oB&^();g=397MFG#XKv^q_I zpBi*oq2ArBM`QpH0WG&tQ3HJPvYLsMK_I9&kCiXIC^*+#eEn-vssdkH83-_>LQW!9 zfs+m_arg*=;~9* z+>@)8U$FZ!RYt-$M}AaHd(^R(oU?z#LC zcbhT5up*mCRu?_&zzSDxU=WG2n$ivn3m_DLH+L5JlVvD)%+7n~>a&k+9ro}whv(bQ zrz6L zXT+Ce6|amf*}bQt%}Z8Nq#^IxM50ADqcHYT?y^jl>4{Q_w7JPj0PvMq-g>VOb03M;QK^hv9*;^grvJbvneAtO$@;qz4Go$AZ;}H-Ze61Boi1|*>d1!E8fgE0F)}qYxzr{#*x79$Z z(c7+hGwAJ<`)|&2~heos0 z*!jV3fzYzh6&a%>ebun{DY9{@GSPVH0+7mWIpyr5lMc!S-;859d_%a>53H+OMli;n z+1*#l8g^Em(JyU0i%S}?;;H}Zc`5Rrv{%=YW^%F58r)Oz2L3ebf3Ubj#+TPQkNBI2 z;sF5U2$j`>#Kx4&$DR_?@qG#C;bSS@(Vb!Wu}!bkOS~krv*O>JAMMw)xEq`i*5eh) z-ceTyqhupS!x8xmMo*FB=TBP+Yqsj~yhykOP&AiiGW>CGpF3KO?$y1aL?Yx0@v~)D znO-p$IxzT!xzbuo&=HZc%-yV&8xI!Ru{jNi*7g#j2{{T8BJ|mG5GvJWU^0G=1Dfa~ zp2b5=-O;HcV*K}6*_>7})ov@3@8G)yEgPe+Aoa7m@UAY^p=qq+69Bpd#>LO${uiUV znNd5z>!o8^addNjcRMKE8hqSEzkPZ-*?JiRv?A3Pr%6q|E@6x`C;dL_+HHB>;k%&u zsRTPLJX7})*Q|Pj4OOpV*CdQihwBb~MZI^oC?}5=LX>W{b*K<{S?#RvY4%zjhqPA;jcZbKyD?Sb&+lX}0-os}PuQOBF-cv!WIi+O|Tc zD{~tqZ*rF%W{Fhk1eBE>5hkHDqxmXLZ3DH2FneKuB;8FBKk#hXqtpH6qhWsCf5k zs>tD2P0`Om-wszMH83p|2o2iXla2alrP0f|aSv!cn!aoPq!G~xlzm~fg;6AY;SRFm z?RBDFkcN_4OA|PX}?IR5h@#G}u17#KlS@co8~2f^u7ToPw{po&EpfP0={0 zj=T}pG6+0WY*#OBm4CeDf= z;(U(>Ch!0xF=etA?9(g4?ViN?RYrWO;VsOx8X9deE5~Egl5VQIIXca_`=_)Z<ITue_+N4qXTEOeT{6Vvq(9fG$6hX`uRX6hm~TbzH1%z1f)sba5{o_RI?) zSUkYv@GKU8`Bzh+n0(R?@x2~#q3&DH{`&(cYSL9%0tn$prxP^ z0gx4D_sl2Q2|6kvr%aR6C8mRMSvcKWgszC3+^iLah9;3ZHJUF}s=>%Zha0O@yh3ZI zevV?Mj|(fhvUQo}Lc#UZI0Tj|;>5d7x<(4;`*IK*-glUn zGNP34c}i942hY!$u2*uCpL?ZP(b(b2=gTe6x0-+W8b6H1S@0X{TEFdm07dt}k4bxg zs8emS_%m`^$F$UB#CMliglL!PW2#67_eY&9I2TP^9&2O-ePGCPz=ewnShzS91VN}n z+DC%j%sXjW{(?Gj1Cw-9YjsiYQHh6iB;4yjziJcs04+~whQ6?H0Dv&c^gfK^rFYb1Y8?mZWJNEu>|(0$27>B% z*UY|^>5P7z-Ho*LI#Eoy^ZNI`l9zrr& z8XW5}miHN+*W`FU>_}yCXE=VOO8T7K@zbC$PRtF!F(r6+sXUv|^N{*D@=pD8`{C9> z2i*q6S&-*10@r6ZpTbv!$wD%ueJ!5;9XS%ri<{ef@Jli5gWO8o9gt&>$jCY!qeqJ` zgUT|_`bGTF1#PPM4!&OaOA9azmw<)jlTbv_3WJ&2^ALb@4hk>=QA-98d2c8Qf#gZj z2gcfo`=$s09T-R`I3v_M5k*#<+!XkQ0&E~(^H#G874qZCPl#@ZA5B4@p<#`w$uJ*r zUwR0L8^rrbgWsPiD&F*7^&3GZBDNYpWX|bsxpdV=ifNUbUELdqQzd+UO9l$z40rfd z+lw9aMt053RXV-lwwD_R_1I5+SB zDEk%Xns+XmorMsC8(X2mT}#%tAW1nT_c%>H&4nU{aP)re&vF_I^J1o0W(>dU=nmd_OITqXU zddxvyo2$EI)yzp1tRhwpDQ-86;aGqD=vgNMr~*(XY-%vMaSx71gb|3AlZp4f)H+GvczBrmdmBx9>#t$o5Ok35RtCP z2&HQRNI4OPqVCeT1<&$8b%&{4sT@g1h{17;M7(NFNHvyxd)B+J*d?do?n8EY;)WTS zsB1k2?H1|LJNkWk&PCc+Kvfkd(G)XAPhU0cT|Z0cLQfwn^fOjImXo#9=^n=e6(%;g@=N7c+Cu4iqL=T zRMfwRo&Vi@RP$3jY5)zKxSrIV@o#zLU48!r6RO*f}%Z6>i9p47PGIn5I~V6#KP5cs3Mi#Pid1b#0rd zh_p9W^)CCQeq7dKvUb7Dn?Bex%4{tl*w_EVW`9QQFQ~MS+gsuEehk*VCQD;WtSe_n zX>PZrRsj!M0H<2cOZv>u(KtYqv%$CRj~eC_Y?WrG(0Ovb>E-rE{;K(&S$;k%OieAM zGx6;w*j3-Ag4~(AeLx9U;+h_t)w&Gu=ENk_Q{%;jBFXA=b&{uJ1$mOfc~J|&7C-4D815n{hpZQU^dd^XWCX7Zk0pjF zi_89#7{T`>o{dzizT#a|5)RP%S5rY@G&<(?z9-N?4XU#UIv5Tfl!s9NM(4xWb z9+ttye@r@hQ+j1@mVGj#Dx}8j?c6-tw*&1$Ln9KVp(>KZLi+uo^aD>&&G9j0{eVar_qRK^`iC1=I!shqw)Pauj89RUOU-Qmj8V$a}NRe{Oum! z34-AVtqaGBBpytL*Gq0M6v%dTnRCA+zzuTRMoZXUFHq4_EDJ~oS+PkrYE|%&oEp<}vbVpg==H3ehGH_6x zX$7xFCVdZh@|S|x-U3ydI{d_t5K!V^RYE)4V$1C~BPGHGqKQT1=!}}s>0>Nn;Qeby zP-DE%%;JY_jlhbCREB~HoR0x_Z44?K`5MvO=oaNN>w{pCp%w>Z%a?H`$LOpy*bC1! zqa-caYpaBW49hV+nMFnhn%c4ITf-8AyVzO&4D_4MF)ag+C|UD4!*jewS&}9bv=3%i zCJwXvwIyUbfiuE#DocYuCNc*;%X~BwbojyHNij!KL#5l~jcs_$3nq?#>!{21!LD!G ztdGCstjKJZ3ug?y1Ou{xRrn-&qtXt&>0KdaZmk&Bkjc(B`#$3>%vtM*fhS;`^5`Z`AVbL6PUmaCS2?o`x8unNE9fXlK-^)cBn5UV@v)J-pw`Fs;uxs z`oZe_%_=t|$;K)VfWY{G1X^&SLv=i)VGZY!dvf}X{qpH`LX@>)4YOSkI@6^U;_}No z<2dH2q)R0P_sbE)FGy%1!1&%Y_qq5V%ccs1QdAsbp}_FQ)_@z-uG~Csw?_MZ#G?A& zTC&h6AOx&hPAbzmR)B!xMUN%({R9-io~GvVl_8FZJaBK_=BenX(B}$7w>zUT>(Xt~`l+bCfo&u!-W9v1}Gw24})zx)+dKycg z;o2SM^aT8hEq77jFHI*|V>G|Njf!N*IJD?BP;)mD6E%PCLS`xV8W6Kxj>IjKOU z3;`kw@*_%~_mfITb6ApW_v2d=9*f3HG;Xer%j&E>kw*>va4=@bz=` z!LGH~%xp^r1M)gyvR%M@Z64;qEEbpBFj#8X6Hm-rO3ahY2RWSPPu!{&&_?E;N_e|W z9sB&Ne@wa7MGkiLyH=YhBaCT*dD_FMmyjq34WLi2aYgnw%gBS_wpz;GCAZd=SEa}; zU%2neEM~ACbJR2Yufu+U^62>p#_>%@r9V+yqwBBIp~5ex8zkWgzbYvGOL_upXsL7_ z-vzPI!#*anGPRHd>acl=IeWQ-Ws`C^@L3c5rF%O9&jr=l$u~GA+enf>!qR^+=JTCt z2uZ)!C*u^M>X|xi&K65Tgg*MbkxQVWQ4LQe2b7PiXoIAsG6+h){%w-3nh(0}DA^9= zHu5zV7YCDa4$*@|>&H+61Fr>&Qx!No?UPYWZ%E^_2J18|*sQrrfFRDdEe$cE;T>l0 z8;v~bOB@{e!(KuLwTpmF@3W97{AGpE*m8R85k8)qw0zISdTf=et8~sTw9#bnHC#Ze zEuzK_g`_?vxQX_EOe!l9_gQ*$>g-8fLcgOw^90Vmfl3bmz}D}_$B!TOm&CP{a=giylvQP*F>X%4Dhe$(*MEoMq+TNOmE9F#l zNYa)SpwYMcjqU@EapU}J5c{fYebl2S_}i!Jr7U|L|Jj9&gH=i;V>4X$_aA^bneaPp z(NEa^9r2pO02PAuEC?7clk}thkdGj9^a(tlrK96Bin%$~ib8Lc<&>={@Y{{9sFs@h z+$_)V%P;KIx>qEbnIVE3M=U!BCQ{d3{MmTCi^yNDW6THX6^VVkkMtugE4*O-m*H8D zl{K^-vqP#$7YTL1oDs5o(|M|bOcy3cyMr?1d&&`_K&oAzMu$J`chrtasix2&e|>oE zM`}Ez7G_XVx?jJTJg3g3FAS#!0SHBKM)WeM$k0k^iSkrVNU@5-Lb2;UOltLxTNKU- zi==JG0_#4~C$ym=#S#ew_?a4$zS=o$&X{KANJ|zH@UPKTbk1Pj8vn=o!C#K?oay`- zmJLk}&iVq46ge)YC!B;LDcSto6!2A3CnTv{Y4-0Ie9C@7TawaG8?-(Wu%_yhcOqD? z@oylDtq%0?^Q|tWd5XIQ%8t80^V>D_JT2x_`R|dPJBy!^@mh57-e}M@$*KR!O_Vp` zFin>foAZef#+UXS=Q|Gq#%oRHj%4CoW(OsIY)rA-%X+UVR4g@sFwuD7tPY8PLJ#rf)}t## z?$(fd0oL;wyc+^=|7~Hy?@YcoG zxSWV4<}*h4;jZV1w@V6anqpK&$GZeRr)`(_7%x1BpfH>I&*3`!|N5_1#eY_$2?1Jv z+(jZhgI4^XNVj30o*%`oJfoz3qXXNaI!Ow!PDeft{TU3odGC6Yr$n^pq^00@{T-&z za`Gka+}{8aT+bFfT%f4nCZVJq)b6WA7Wx#Cd{FArr!#v+NKUEr!i6rK3@J+!*&dW9vUcNvL@&B!h*y)r+|@Cs`dDboxMopxC{^VI8tCmNH=G9 zQJpwd=E3MIyqu4O96;l=sWX6x_NZZmwHPVcNymBs!*)n#_IZTE8C z%5w5ij3By(E5)L2AQsTKLFmQ57OuxJ%VvHf04&`wOWQzO9zT^8A!lUO=t-B;ty20X zWflCAeWB!T1GB_Vd|4+!U?OVlE}!*d|89Q2)cA+n?<050`W5WrD~}~$j@&@MP$6E?3E`;^w*;eLiha?!KAC;0ivwCsQ^GLh0SNfr;IN5LXSs8 zda>A*AA4l5mI3)1BQ?a{sgl&ayQ8fxwOu$I(;{1cmtPw!ElGe&&Gh}mz2z}wInmUn zxZS*3DXNhoI`iqgOo(JLLS3H-Fc&7f%1MOLDY265ouVHfa#deI5&C@+D2y=TM=8i^Gt- zwIHgYx`|r%_&OqhiI8yX)vvqV^Hw_mp?C_dOd?kqweo_Gg%J#0>@4kz8GM-ZE7f=Q z^QyzNDl#Qd`a!XqskmM(gNjhG17;Y^w`FxcXuP{{v%jDP@o5Y>UEgZG-E|WdG6Lf; zkK5aY*1NM^tdOxmUWvjQlL{Omigoq%&B-e>e`}WA_@0LC?#uZ{*4C}d%g4@l|MP&8 zU)Ta!O3Ul{{7?LV-byp<`@5}^X1P))XpMdkH3iw9dy<$^sxw*s^9Oh2I%P?LJKdvy zh=acW!$`0A6}Z9Q{WwpkX;WjABXs3k9fS=I^oi}$zhenzJiItsfggtPc(Y5pQj9-| zZI~YG&Os`-BUpR*WnE!-Q9zY8-q7zZ%+_EPdg)iNdVTE1n0*|7d#W!6>pB(fH|f1@ z~eipWxM9n(Ps9-M&*?kD!cLVFaom^KkWeGXDhw=FelvxHp zqliHXecT+Pq2-9>fkn>4TrWvXHj}t09w+{1t}skfhQ1lRyDc|c>eV8^B0a!N>QFoC zU7g1%>+KEYTHqoxiEOhXT!3b4KKHI++8b`C)J!}=rNd+Tk6ikk!?JTJ_$?@4hX3d1 zzrUAW0SLK$JDxh(!|2jRlLn$?qSzjUvh2tPDwA}*pSw>rMwD==aBgF;=bGge)gPb(KtT+jzTmXcE7XJE7P_XODtfFB~M#?F|Ay<$k3l!C? z^bc39!S$?`Gkp0t#0_DjXA6qqE^d0QbuVdvvl#AG-`H2|W1g=sPM24bn~lq`?ir@f zNd=boL=V<*W`>cLnEuzUXgEtL(g9<-EwVH0#l%xkIjIExwm!~`ES?BQZ21KGVmj5? zB;Kr^yt_M-zFTu^SseS(Xewwz+Q;H+eT7+Q{yMB)Yso_8QEgH-6HpTvSbuXCh1p-2 z=cuS3^;McrPz6KiI@6-FqBHMij@SPGj46aI2%RBlf-i#q180|Ig8%Tre2Pn;1fjpH zdg+%diHtB4{1l3MrMCn)|ECd&LARF6k_^ymd?>u5;c*s0R2!idt!Z0TfN2P}^{4!#-eiCZ+SQeKLma%RI{sE+jtSu%?LN=D9oa4 zB!3O}rpgSTqW3X#sJknFfDt!*eY?H9WvNq8D;3qwO-w+RVSG+*$6(PxKjmRpONS9I>-U zD}yvmF;&hm1*c|-N&;*s0BqK)ZMaEI3%t=Xp*)tJv&7VC=))N!p9OSp-unqYMTdya zD0a7d4%@uyP>;=ynXEvYFQ0yGX);SoW<(lg9W|Jk#jTWu1YS19YmXL>)t;>Nw`q-} zRg~e}=p#QChFQmY)vAC&o^5V#iySi=|3M!$F`ov=2f=GDOO=A|N^uwJ8i_=}V~pxw z_j`El{SRdu_x0|P;+yc5P4C6gjq9g)9)2&QZ2T0DX!#1RN1Aq@Hk?^XvDr|PDxbqn z4=;Wjtb9(P+rGC;HoFu-pgoRs|q?_$>caK(L?TWmcvpeU< zcEYL6LKKCuLrOl5i#O$C@4#lmSK;>=(e&gqVVm_$!q8CQJ&#Jyg0C6(&G3Wazo6x# zdK2H=leum65?;J7F7Eo!^+Dog?4>FcGRvsyvo zDOlwcaLaz*TF~1~#QOdinrD#O49gJ}r)a&-5~MZ_S_=|S)XAXFLS;k!C4$C(Qg9I5 zNg^zWXai{nkx}!z97&BsHqGeZj(QrZuW(^DYlGg_JHP6BzAKyU79WGtWn@P6 zrJagcmN!&le5dz=)N@H4FJP&quNV~@B*m-d8bj`mg#H%op}F7rg3B0=Z@~D~N-Kgc zJh58f{Khih>)NB4mlWa+GIw(LmHy)Euq&{tsghtX&6e?B! z#Wuqi(QaAeNgbR32pt*cr0q+GJ{kBo`b^Od&V`3RPz*_Ee1c=C1hih#PnKVU*7@>8M`EMmVIW+inU- zvn9rUQ>Wg}Wlro~X$Q!-n|sU2s*$ifD-w)V=+Dfu9WY>Bp^Tcoj+~fI1 zVrj#vT={^5AO@sQ2p|Q1;D$T`e8hFudZ6ewegA&Q?22dbD|ntMbC9d|^`|IfDXA#* z8EHY95lp3r1vVhs!*XYHXyffZuo#rX=({2T^m)V_543>!@r7HX7WhH~cS3`?&o^Cc znwCx`9u!;Di8k#2Y_8pt(eSxlx}VyPd{+_;oLbqOy5Yc(Kw0o;;=N?xL>E7p4q%hpw-EG*0yUXkUCGRCo znkG%#q~Gs;_nvdlIh1NCtVW3RuR3?kQnZW^<$)w;>(J=8X2ygW6k+V6Q-%$C0z72c z^$iW0U|`e zWdOr3)o`)PT=5yn`;ti`*8vyBe&J8gra$kq`w``XZm^m#1Vv&dd4FD!m~6!@-V}s$ z7GK{IQ8oXI86du?;WyB zb0kVbzssClEZEbA}nC`c6!=iJR;ilE&{e7$2!$gM-4x(gZq{LO*6rDpVdf#|7u)EYN7-VDEn~^7%wy9ECsva zlD++>3}ZWxTIkLZ`RUB=eL?xkh@LJ^C?T-VO(bTQtuPr@1RxSBcO=sMb^lWkpC&%>iRmQ9Hr zLd08GQn7DeLETkf#Pj|LnczOoK@)y_0`-YvQXqJoDeo$o7x`@Mn<7ds$z^}X z?~D$oaxmh_xP9!O>gU_Noq81qf*3rAsS?9XJMaKnj{X4}q(ZVN1tocM+qx;~gOHpO zn3{C{RM?Oexj2&fXDf9A4V`LgL?$SB_;*i0mP|xf=PdHYLD8&#)BQ3QcU#r}lMPJILn-{C*nal)+==qmG)io?5UlZz6 zN&y|SNf((g{y^1W`C`xJ3Vj~yYKQC{GxjNT!qVR0*M%B7ziUcD;a=r5N*8$)np;gI zgt^!9`#rl9zL#Tl(jgv9YRgHlVAet}R zK~RU1A_Yk)kT{(nT%i0(AOH`4WCDQ|(x&1=?Y*`9k-*uJ?~sw=Tl8_l2yeR_{t};` z9N%6|Rj-lLVU#Uy@}PS!^;?iCrwP+c-g$)ns*A@aTcO`CY>I>)dP}P)_CD>X%8JNp ze;Zyr#z+d2kvdIzEiPK8hGl$Q04|1M>LU@ifa%E}jE-VK6j5_ohR-Yx^$q6R29x0W z2hhL}2#jN;MHn<;>l*y7&*Sf@7}Pb{Oi~^pKoTdo1QeGRObUvu&Qtt~9Gru>I1@}l ziaR^!*1l>-Tv<_GGdtG2I(B`%Tl(cqmcWBWbC$@HC6DVl-SAWonJ5~N`xXlsh3HCY z-ry|FTOas!1o=42$!Y~1`CY<~K^-t|dtJ-jAUUgO=<-7is?PqF8QTA3`!iLO86}5v zlFlxMXt zu{w=2T0`Dr+acpG%{@17&}kQ*O|yfPO5Q4!7Yn1UWbDBjt;o`9GWf|l zsHjW2sH|a_aOZQKPpC9Zw$k}=pENCxXvy;f!|IdaAa$^GR3KYKna{$?TBNF%PL;^t zP;DMJZvxyCLfo$jV{>lHP`7Noa_F3{bvP~|+%I01F{_|J_Ri_=LA-hx3+`7oGCIqL zztzkU)W6*|2!cF$8MrxO!3P0T8L^>#zbWD|A=1?I=wUHA{d*iA1-9wK)M+bv2C% z4uS-}!F$9F->^8`4hBfYBnaInx%(W3QYA9iyty5&vI=2Dtz7^S*i9XZLO#c+OaV+#Q9Es`&j$FpA~=-?q?0 zP!6ux-8GR@d~aQdj~{rgE63}|Y1IIQ0YL>YQcRQ)K{D(qx=AKnBgBgu+tnFy;XEGY zyLMO2Q?zVKM{KWCN-`LXj+wo5ZewUFl)q0lqUV8AZV8$U!{?*G)|dED;xo!U`k4_l(Z?Xw`@1A-tHj0} z5;kH}5j7ITfVgCV=rR_JgM=&RN#%PfrK-8*xTO1aLaI930wV`0{Jpvy0*)Bm5Xu@h z*Y}scN!r>Zn&w`eh8iJf3Q-QgP|YpNa@OsA{`%EmhF-w$5gn4S{m^A2;Qj$IL)}o2@*04#CFfU-FSy?$imo_Dd zh`#YPdR%x>z_Vmk>FTHNegNzWI#6M;9&<*tnHt+MDDhL zhaWH3m;a{c4ZT;F*RFqxoX3gW_8L9*w#?q2!ZGw>;im?83bcsZBI|#r`?SE-;c&pm zu;cXvQaO)#e`Ml@a63pPMp2N=`$uW(euki#!^j**>%Ln1U#GJK4;p+sx9@Bjd^FP#&T-+}5)EDJK-9kUGYbj`l7E?#>yZ?RTURz_Kn@PNYPV1JHpOI+_WYRX zVl|{ch0YF<74SLTxZju8(G10=8jJ6-vT@f<@6okQkStE);)@$<{sFy4WZ02-oGCt8 zBf*l<$*se}l+xK*LeF&;w!N`Q&!1xXj6!9#zP_gWw>~Maj0qnS+O2x@YyQZsS;!im z3%zy58>CB~RAf10B}ft3&&sY#)3bqQEJzk9{nRpR2kh}7np-xtwtirV^PO2DL7z1K z@Ikh6?6xVIpLk0?hzzwT?sJQb{O$!|jD@~&^O(%GLA*3A#R{(&eJ`3A=oM&FY87WX z^d|3(=Y>!F;gAp5U(p%KAWv6(0nI6YHH3zGz;hj>q+1=jH+zXEhV%YRn0U+!qsw_2 z68-)i8BpF_xw?P-E92ejJB7cm3mheI@GNI78*EJo*&Q#rm=ST%D#brj1S+v`P>0Q> z2WL4m{lihsr;9+XWLRFsW_;a6VS*}#lp35iToV?VKS=~8O~4M(gJFP*DkM^HRk=Rt zC>?6W)Af--uux;wC@5di&!NtDrpV=~X81E8;sL?_46+8qdU{WJ`ojVSkO~k9B(r=d zZ(y2pv_`pM*>11WrTf_;f1N6_uhlJ?A!8{Ko{C|lt4ne<&QQzy_6-flQh*{VR^4De z*x9q87=|XEKa`8bBsN}>MretQ)B9&pY^ESwI~+&(&k>G)qPXM)H6jfXQ2-87kg@oI zEHIrIUr?FpTuEk+pR0*1_xdyPsjT?R4M*i~H@*id!1E=rc-{v!!s2)5&j z@qSw5;iaq$(Vt{1W9^b2#OrprFqkl}?|YRJKCpVTQrptbroKvw+~j-h}s6cL7wl0V1~pGJvk<^XSLNT@{~me0V7OvittafQ;YEd%r(p z^DVouFpqWLo3<;cy;23Ce^aIV(8_6IF{tC^vHJxccmcfliaa=rEY}$qkHD+c`qP-Z zM&&cqz3qZ;-1m6=ab!GGPr&_V^`_-KN#tx0UMkujhua^cPj0Wt?OVd@5!0^SRxIuLC=$Esv?Cr}_z^`Xxv2~rb9guu29t|tETjd+qQfqLE8bf&LZ#Zp zuava0=$Iv#@xp$Ow-&sn@Y$@71X5xBE%AEol^QAnE^3bj8+skMoGX_hkIs^jI=DbX zyx{vAu+!*Zf-bW)bgIu{dZAh_o!$~1b?GmO4=O@XYdMZ2qgjF^dB)BW{l^M6659$G zkMPy*=;#&yj9fe_HIA9uQEx@2a^t><-jGB>V)s-Y%b7spS!L;cBvl4pcsIn#m7v6IS&zx!f!&iC>L$@kC#Xt-!J zpzyD%eCkas2cxjjq1mU+iT=;Ct{Q}68b^ZmJB;5WL;mZ~ot*ZbTc$Dz)^0?SDqzmP2+wYVB+!88cL zKfH^f)}H|yIf?q$Hy!l5N`hwW2i5U=<3$m{XSii#DVi!bf}UVpqTvcE6VEPpy^f3DYRzvps? zx9*_RqxCyVf!?)ys`dK>c-HiPJwCz)-0*nJ21^CF{{Wv@pzOQAY?bFIk5Bi-Ni%#c z(f1HiYlcn9x3Y48cjVKFVHn$>3-4$E--qRO_OdsxcTTh_^7zTMPU*>#xFKc0e= zD?C=78g%Niq5$^rX);skIUEFnL$b#dtPhK?kMVk`c*dGf@p!VLv@ONCO>ah|4pN^U zdP!&Br0RZYPC3d-8A+FD(Gq~Ak#Nl)w$|e04fO8udiPKjC-H<+!H;~A7cx@L$7ci7 z09;PgR>f5xpIqCm-M%7jZ9+T!WO{2VZQ%v01{jQH4hZU?2&eW!=~!crMZ}dtuM?Z1 z=4Cx#K$T4@uSa=h9VS&)cHQ~SlAkOlzCfuU-@_Wp-Lr-fyO)E5L*h>mCk{EV@I#1z%=-GaeRJW4JT(GtgDbU>dY1o>O^(SI5;gO z$q3(B88B<<&cABcJWYA|u)IvJlT2!Dz!kyb z`R!jBX7S<#nw_Mbcw!>mlYj3{E_KtigNZ5tfCjlFa$rg=~v!nT}#L5}rds6}QH z_){r{RMAJUh4gqYfAz;H$x+!LJnB*OL{5Up9}b0NKPgpMw=q)E$lp2(>I8&E5cL0^ zr2?`o4{XE=J(DxW0t(+rB^DoXjz%KJl7VpKz%s~GkTtcTBFq6eVmDSRH#HC+yUWn= zSD%XlGleJxRYR3XX(NTYaU&!@u1bi*!-&SJ@U!@!D`9G@JEnfJRQkST2FX5-kAPf- zDzyz%6`j{ZvQw^lgzUfoL2^`GT#p%@m80e0tex)%fub08vv5_vNF8KYpfwpP-fB&~h>bNZ5I zwq;>J7!Is@vcakzQhmN4RNiufgkvky&mO%pmu z%fNN#_4u0e`0CafDhQ5$A%K3i-qeB|PFimeI|$z^9}+CDtbqJOsr)?H{)#;PGir2x zT&RY$U;hM-4%0a7{Vp=r&y#_MmZN!KtM=wuLMOTX+Pa0 z$Ut6k?5A{JVaG+`b9?lNr*ntD)&j0-s~UHgb~lvO6?6zdzp5Mmwc5ijhW*|UA9TTq zpveunp^e`pZUy{kab%2Gpwu$^4fT}(`s?oPT5)ynf0(GEyo&^zz~P?n^0xHPe(vdl zi-wE)*$IWBCMyBTmfLqmUTmT`;T$1}huv$mSXfBKHWcsjBx7HbYYzBzp$0l!=s1JW zQ2k2HDs_)%T~#%L+0FH%751VjMB*Bj<q{HBaYcAaFXSKgad(oN+t*ot2Q?_?j$3Jcx*gB z_{KVJ4%Ha)J1{6Mhv|yyWXuWAu!h0Ov`=z#(K(&wGF5HB@&1ARlZx z4J~%xma%G77W2N9e)EuX`qhB>){y<>Lrk`i_x@!*>%`P1zRtJJmHXYa+VZWbovh$) znJQ7Uaa)_pN~o=kz3nwh-eo{{Kiu`cxyjAWR${TveIvGh@qX?)Eot`I!e)Agu3m%! zGxU|(kbo9|bsx&%ao_pKjBTz3b5QNgq?VHMAC*=2?w>gp^HH>5ZJ)tx-ju*W7nh7g zjqFJIs+%>QmP!dlMW6wHLfq;}k^fzeCmG}Ga2(5%zR97Wk@0r@CONgPv-0*sQ-N_PJ5&=Gwy=$2pTmoTp;41SR2j9r5x{13 za!8DFwQj{2VPKs74FiKDLR3>v<{s^24b;h5;T~SHsPdsC4UKthF-b&5tUuvkOVRH* zzN(SDHDD|d`k81|igv;`ZdeFTq-K=Id&UU%z9u@v>$XAByhJWJ`T|)?HMo$QJzLM{ z8v;P}-PzSZ0AibLwl!%1fjnKNeSwuH6BA=!E@{0L$)kzBx6UB{hWy0!x_Z?r7*rVe zT(Y+RX1J;HRX>B7#{Ix@;NWin&1sR&GR2D7n(gQCD z1j0)Z{X-s9C)ctEJrYw*mQ5|NY?!ue&;@dx^bV|_pwK2KYJX8_y}~+X3?ulDL%hbb z*245<=g;Yy*Z01iD>i7DusqA`hcnQj568_P`))J$)|L*gKpi9(aB0HBL)*#2HKFxi zLaprIh@i^ff6x~cep|qnK@NW>a^0Gp$AxYVDS-Vi_R1Acw?2F=K-q6PJ#8ivBja2yHEh+PwX>|k-qvLi1F&=r9*42rhj;1ckU(?CMp13r#Jj1G zXk-;N4B0mXncVMJPjJJy}g@HD(Fi4^>N^C;X6l$Qai+;0KoYZta#5`2yaXHhiu~W_; zl8(~t#9OJjRMbK5ftDK$9Ex+gn&NTxi81Vd>aUld{@8wJ$s=+UFuvyNPWZSWqcIbU zP9!{t5BaiZ?CWe1WsdEcjE5jf<|1&k{REBrQam0d!FB;-!!Xn*wU?Q&!sujN({v_vo+56Exqm3Jb5rcaqu>6M#0rujIw-F;|?&4m>! zSE$xuFNvJb>XO;A$$cTY*kQM+J`{)>#d4~wr(@qqtFwNPzWMUOuw~*7FlpQ8drk|W zWrkEXUhh}6{fhutn~sjIf(u{Ce@Qkk7|<@4(^s{C(nuF_fe}kPz+hd*LPbI=NgH>5 z8fkMk*VPu+sA|jj%ZH~jmRc6(A13;dS@84gye$p;_Q?pOiR=$Y*C7lF^Oo-7s9iZx zhT6K+U3BadpHD&Xa90d!r5BpMM31+1uONfNMSwjljVI?++$qT2fU z)OoYc<>k!9q00yG1%mx7-YI3p^aa83SW!BnE%t!+{UHfzr;}I3JPq|1ETf7Q`k)yN zorjKst80f$=>Zbb$ZsQq+l{!<8X5>D?1%lS^}3{Nvut{xv2nlxR z+!Bi%0C!NFVu=!q3dwJB@+?m(A`R2Fez&m1M?{K^a^w~&tFa?1Hd~)n)pEblF$21;+tE9POvU zA6MR9!if=$B&g;CX~T-s=|(3E2Fo&OzYu7@h|p^Jb2t8y0-V1G9{;sJE!*GT+y8ap z|AC=!vwkBQdA46(<+pZ`J9*ScZz%TR4TZx{WU5cLTGKZ^Y)&q} z^i@iu!Nd5IvHoze01o2g_MO+zaDau?7Uu{#TruNAOu+ZHn7@u~(=r=>>ZgejRDYj& zuz~zj)4u#pP&7fArUVer!WjFryS7@R$!$f>2THd>qu<1$Q}4E| z9R3_7Zs354msM3>#sGuqYxEVcSj1OXlgd~%Ed9J65i0x z^`PeP+Ka|QB5?spGEvRd;FavrY6;%x1b12GaI_La9N*g04Z!viW%R-&m#&yTP63JR zM>gU{g?kI%@H~P~v%B zeIjHsE%`s{ojGvHK88jscXX>Rh(${-@ZnlKuUeM(F1UPNhgqOOu+lB#JH%PO_W+wc0lU zxJh_maMEjlMvE<Sr|p@&q~}(Xz5SX<8XAnHe%rB0XZT zRs5SDiQgH9hlj(J(o;BUdj>q;qx5t-;F!>fQ+4OG8_dVa(tZz%>FPjMwTYJ@`D$uw za}>cj>3YP8i%6x<8@oV&+j8`FtQQ|A@s>CvX6j-M%4S^M@#9H z5346_@cTGd=SR@zDYZ=Tbi5w&ogC9(f@qNHIE>S{V*a zHFchyE~rGLroK|I$k&-pZsq=hlv@f5!q4iJ3)g`~5B^&{C~5}2Fygd@=^^1d7`cs> z?x28>1~{;jKp>D+(+mXyfoNh$@tu!x-x+S4)R%3Cm%y0His(ABOangei)p+2GCe!V z%Aro~lx1D<%h$3L#~sICuB_G{m}&w$2kvUf zZZ0@6a_tHmk@taJAuy68_85vAt_;_k9}E@#NmcqKlnAkH;rRhY8)#eVS0Bo zW7;QwDxa(QLvomF24aL&w&Y2r`k7IcJ_lPIK^0YoK%S}PFIkd=%lEy18Y68VWTy_!a!d$8`Tv!=-pO$ysffM z$0R|jr!4`29)`4TPh_>Be^%1i`$Z@nwk3uY)^A;nTxSE4$!&4+)cEBt>>7#_?Ifk; zzzl>Ya-)AO@~Bah5Wxg-B#60q-|ZTf^|X0go02R5NF*yI-5md3S($vrm9TnY#x9sx zQj!x%QS@!BY@wV0IzE#)JJXr#D0g+bvc98PK5-$8yAKC0^aPu8Mx-|e(Qp6tJyK*= zk^P}oS*94z0BNP-oW?+qovIUg3qOyr%F2hQBNn(tfO0lnc%CNnG+kc_o!r3Rp8CX3 za^*nAu0e*m>-OKBX?Q&4Z;~X>9|Tg#WlpAe6Ghj;@3ZQcO0bwHU&rP<+cmG-e=BnP zn^`LzgJNdDj<^lgKM1aI(a^bTx;7*&uVsOyhdlX(N#()RNPMDDY3^ZHNiK;ny${xS zwvp`c3}c-s{ny{}CJ7cK{DXt+8p|4*8hrtHv}4f6JKZcu^hflvGOup(wbMSHwzGja z+Hd38w!0n7%*wzi{3K?gnF{d`(fY1`LmHMIBj^)=c# z@tSXj-}i4Q1l(K%-`d;SzUt6hJ5Rn?K5c{-qRECfhT$5`>?(VkLyDKhpAU=lKt4LW z8@UmAjC%uY|DDVyCnq0k+}*%{vk)mMDGl}YCXrP46QSvWwIABAm#p1|+b^tYK3muV2Rq@<`l+ujQ;SM*$?o;C>+4Kr?<{zX{CNP6SIW3Cjq%aGMS znd<7$<7*h$AE;18Vk9mJat9QS-dbaq{o^xFEAU7ywW#`t`nf3j4G5HWv}dLn`AwNd z@!S~w;@Nv3k+Z$wF_AFRD$}w~>Oxf}pX=!auI)6=zFV`>c2u=1ftCQYZvao0ISa6PvpVuN;7 z@Dj%N@;-`54UKquXv+t%yk%ixd70zpeutjka^UkoeN(BeRxdRH>tJ&>4QeA!%yse< z%WFJb#vj#H@{j>~&v#}=-4<+hecMnX6HZNz2b14A1i^CNt#(z*$Cb91JoQ5|Dpk0f z0sh^NrAbaSHdiP*|9w&qM0(RxBioCBf;6+w zH{Nttlpqsg{f!IPpGiJt??|&bA3tM(0L=tdlu4aSnyQ6E6N3km<`XugEp2s~1?!`g ziSfG*kWsX+2EtJ=Y3`S3Kr~#8)v2UGN#c2ZGAcnN5>Qa0?Q9z&u2Q-zP2P=bRkKTP z_!j@%oVJ=SIR<-8SoNGXWuQIMcN0v1U0yG(e{{rC+)7FHmUH4uED?BOj@vU!hYORv zy=#rLwS8o@ZmgL5f-2K=wBME8JH6o>ke6#_mT;yi!Py-Gv7J~yc5OP+e6PR}tsgBTHj#tu z-+`MCXlED#b>40+c?=>ALQI64@612J_g{Noas1?S-qdFjz=@kKRxvtFym>aML@@We zoWwAKy)n~CHuL<4oVh;GzZ35;cEl@ly@_W4AMyFJ3$UZJq!3yL5XCMs%D$S6PN;hl zm|Kt$6U@MMt&3va7#Udh0dmwMdx67`haw>WAA*u%c2?mQBhB~yg+#w zM-4ZLfe;rV2~5`o3R|I*dL2|k{*d}v8wag7C&wQV9&2hzuih!gHmHmppA`@)8b$LF z3BWC&`Go3-6qZ8@%DCiP*w$F(h%BNQ5qj>YWSwoRK3gar51aWF$#Bbc;V@V zWI-=o;Td|0ZMzSSgM4xCl{)b#ov0;EIS3v*w)!DR!y5g3J-5ZQuBV+j|1w_hXMD_h zmF+Z&iz*eSVRAI5*?zwHH=KFt$Zl;Y5tyUlg`2oWu-%gdNEifyaiyaQIGM0=T2clk zrP!DF_wMtnCp)^)O1^si0hySube@Xe8yU zrWasfG%7Fi57xa2h;xyrSD7L}5Z8$L(M3OazR3(AugQJ6IP`F)O} z2Fe$BU~Ufz<+%lKduH&p=0S z-NLMqyHD2|rmL^}HX3yco1bfl>eAyOKcDfvg|IB~OlP&$$1Ox;Y$X*mLj@MnApCBVn4gH_<>>AJI*%G|81?tC z+B4deB3=D5j6F1@5wIbvw3J(c3VC!m=oJoUA{I^@D*hLgaRpXBw5y-@*hNnH!H~_maQ)6jn(C$vM;idU1x&ZUY{Ut#w=7l4wT2Ri&y@K0Rg-<9B@WDz#_f%U-?G(%Z{%U0dertsE*J7uR2~*|DjvEs>R%SSwd-_MNOs zafsdz>ouT7$by1nQNz>QeId3y&+qX3K@3qu(h@sF zSZrt@S|p_KgmzRiKs+0naTLkuu<1Du6*NT08HgkrltUvxjpPp^cyIXq9|uR_^9cGn zwMk~vdvnLc^dv{V**Jd6a4q>{I^07J9s9(q0yxe|`G|7UOF z7MV?ww1BA<960bTj}hyff7Hnq&sXa;hGJx6YpRo8So$VFDqu=OV|J{8U+C^-vH5~` zxa{2UcD#1(?bv5$4Xx={O75>BHfHG}zPt)2fpE%Ffb79-ZJSD&&iG(-IW|MNOFu)A zzMOFBiIx<7pqRW>HGd65o`8)3fhI@%4JM+Hy8FDoYoAcXRSR&qdFWhL_D?#eeB&l+ zvh0g@RqM6zgZjMJb#3;$3YexmhK`IkSh4HR0<{hKCvdJ>I+T90Pjb#`{3=Y+=CCN7H}d(k2L=rlu;RpnhaE2{k(6|}xf`Klm5|~K)2R7iFV0Mg?w%(HjFhTv}^9s$2WJ@Zj_akg!W)As%rU{nV+4XxnJ8N zrnC$YGHeF8tfED4DJvtDA%TfGb{^m*AjR@eVt z5M0nYs!AMAvU+*!S{Zp%EL8jOu)}~_!D2^B;dxfe&4cLuwT!60dXCJK;urmj*8$YJ zm2Pi(g8-C`SkBo|9d9xt%CUT?`t3Y@jFt!p?yn!N`$hLVwkY)dG?P~sGqd|HszU3f ziz}nVBZ(Zv;^z;;403bUUzH`0!HJa%L%j$p0fg~~cU-t=)dYwXG7o>X7?O|A%WcAC z(G>6|aRxQ(a!s=qOzF(SDdb|RBxMsvt!!PAFA1UX63^5UzJUSI{Fr`i{2vT zZY`h3@@g_f2buh7Le)D+*wt2NrpJx@#7T{iazn!30|}eg%l6XTAB3^8+qR3 ze;GB$i9jQ_Z9e(zyLozlhV>MnDB|^tTcly9M+xR-J^w0(H!0w0z1i$wusHkdXZ8t0 zv2Clsjo{K{KjwIFr87ffGAjq8d38EeErjyJKcl~S18l0g#qj;Hjqb2QA*}}kF)6ewE zgu^DZ`h;)fPa`X{ZHwO-P%)ge)V0zUI2{#+a$jyXPOit(#s+r-{qwc-@J3^}Q2u52 z!>kv?*lPc?FMDO8!jtdQh(7fCN~8S81&8wmhiQ*{t5qXj#_w6Hx@D#Q+32nKJg@vo z>@KT9qYBl|u0dL}rxpAYFVo%USGC3@{7b4OeCQxhd3PC>!?w->keSl0K0;p_J($_^ z$>w^58>)9l5(pkc*&j|^AfU+-j*Is8t3#}H3G6aK(LuoBH;LUw%^IcU%JRWT=wqJp z3hK3d$YL!RU#RVn-s|VLPEEVDK#^BWZvGKT6#Y$G(eFb-n3S;uvnE}sPV87wk>HgC zOE?xZmO-%jSRS;w4GWRPf%oe9=0f&X^d4WmRJ8RX^Bl(4(y+E5 zumzD{q5|$OkICLQG0(Tpoo%_ft_Su%cd4G2?Sxv^lJ8CIso&H!_9P0)*7hjM!%1%l z#@60D9uY<$&-5z(F&p1J-bDezIJ!kcV`7|S`X(;+*So2aAyhg3JEZ?X9 zi#0EnBn>C!XlTi&484O`z;^@R$jTqsBQ&?r0ryTqmKAP;Of#BLILJW@Ki=EBWf_&#F3j*&k6c3sULJy$^(dT3GTlJ+Ps z^yz{N9GckwA)FZN!S|J2A)#a(EP3{vc@hBx671Eq_Rs(PC9tOb;>WCL!uygz(ND2D z(GuVK&GZztob|bzn}5x8$!B?vtg+UbJvU5!EV<>?t%=XHH0=9?^0`OcM4(ro`S0a- z%G^5HHZ8o!ShJLdOt`kg&qdMto4H%A?zQgG#EpRopWomaGu$jOzl4$^ zGqZv#9m?QDQ7>)_sZe9Tm|5|ehTD)pr{t8wM|TNj?}53nSlA$~6D}>7o^>q~gx-_wGJE1O?MGt}2A>1tbU z#;_#fCe=egXDgX0dJY2FTADS{U^zcs^PNrzWu8^T(W9m43z3p7HE-tPN@{){6&VgIyJWVbr-$%{Jr*TCc@G#+AJGp-m7a_$c3hZYdtOU zdMGJE_Wom2EUbDmf&$il*sQS*O%yC#aI6d8GS3GlwV=1G)>3om7_eoibiU#Fs#Rg0 zj&{$5;QCc~D>dc;Y{?|wQYRdh`CWm@rnb5TFOjvRR0zbFd7Gh-P2n{Nq#30_w(-kS z35y;#3x&O=2X*Yza+1rwJcIc(zTrUIfYVG`vhs-vb^*W9M~#(W45RJEcb*mn3*z54 z2aSM3Bj01?`39NARJIR#-(we9NXMYRJic-NsgrptW(N5{PlUS~?(pjuLqpk#XD z=O*eOG{b|4bmBI>@v+*>dBKUOdeOEOJ^bLeUvTQ)s3_a7dYKSpsL3(*i*WMQI&Mjy zm)V(hT=-TOEn4&&3kqma88oO`s>q_Kk|YoT=BkwzGKmt0407KEGS$aNRJe#TTJkD> z$+9@c4~c1N_e50B{nBPmRy<_0*9N}ltJ^4AjEX}wGkz{lSYSq~o2W)>)%WrHnb|qo zvj~1ZhU}2gjPgeuZC@VBZDp9ygnD*2xhCz;=oj?z&k;)fk!|lTm>$BOqfw))a1CDs zROR{XdWJqR&-D!9CB!BWy&AQ)veIOUuW;(>vZTafEl@Uvedaf=G0i9#Q*g_0>2F6b zM{xhh-_ymEk=m1+U_d?IJE*X`sLewA4!+*>;=J$&*&z{I9UQEjjY^=PGpuc8rX3W8F`H@wx6$jSqu?tw)~FVKT2&OPr=GE0(Ty5_FKHl4Csv0 zEI+d7N7d1!k1(;S-I1+ey-{LC&YkV4Jh-Ksv3Z?qDI+E@QK>m}@mRChe8{j4d^5-I zhq`@;v|+BPt;J9sv9tWl$7BIZ69U&uhh;H*3Z(5e9Q>k73hB-v<+c{DHaTd@p5w=c z;5q7RF)Aqzg&0Hn`fSPH)Ue*X!TjAeZ&6pgOLX%;w7qpyRB!w6i-|=^w;-JY(xr&f zAl)F{AUX6_X%LWZP+&l$q~6+n zU9R~dPcNlzSNJC|QO+yHSg$}JzKb!YT9L=*7HxPu$Cq)kTAg?h_RtbD?uwYlG0Si`9F0o=IL$WORhZbY@K;nQZfX#^ zwoa^j2NtV4bdOV2BW5>WtEzB=a>W$8mRhg^|+%F5#u4!s6VJyYIop(2qVlU|pYZq4|-Sx??A^bK(BM3PfCK`T!c z{jV~2 z6$}=Gf-BPtGI@?ux!q(FRe6*!dc5;t`phX-MKUb$faObf-TKEzr(*P>CC4Axmhzi- zhgY@q!u?EERBwJQw2|>?FjkPFhYuy+b-&6LTYXWvKN6q4T)|$VQ|4uDvsO@GZ8TF7 zvKz%Kf?X-i$o*QH%8|t3C-ybOHGgs_W_(Ps(-plrwHc4JgX&jkl<^JQa_JN=aR`Ol zpDZj!01ZFlxnqUpnMlYuyW+)HE=hG%Ys#r8^P-tGp8x(fu^pNTqJ5_}Mcw=h#V8D7 z@_uyeBo*Ty$#nFv-OI&b7_9k)$cV?t9m>|+8mQ!+=QY?W3*hI1j>*Ep>jn*OZH}0A z`|juuzQrI>qJ3;@gMCJ|;R07W(s6lzkjAQ` zn0Tw!Z4e1BunYB8<}^Nd^fJ>wN7>*PhY`!**2}12E{>vH86B>uPY;PolWN)?Qahw3 zE?;>}pw&ysx~gA0sHpT$J`s81I%(hu*t(hd*LqEF7S^;+o^a?iZ3|_3Ph>$F{q|V9 z5neq-uzDu3kIRZsQ~Aywg#=*|0Y0m1Ir)K>>0OMnvWg$?MCcLqj@t{LE{8kim#m7= z>>#P>sF-r$o0L{da%c1p%)bfeft9j~H4gnFB4|xfNj<+)4L1dLZa)8QAJ%gKoMEoM zEUL^@3xBRb+CoVTSzb;*xf^HhrRUID5?qu;_(EzS=cyjnt=6oa(OqL_CQr z8x5=t+j)uEZ()^=E^N7<6I|m0faA(`zKR0X9&NP}ce`mhsg$tfk0kZ(L?Q%Ke5AQw z6lU#0h6^sXDqBqMFNZPmAf4h?0|UpWL0&s3?WIp_ucyZXr?_<|4;UXar{Sp^U_lMJEze! z*~Llg_7;IJoA|0UX{iL31_z!h)R?>C4+!N=KJvJWgR_5LGK?d)o^!ev!CJdNs>`fo z%mSR1UlqRV$B0t~Fe^R!noamZOlOCR`71N=k(I*xSB8^WjdJXfBKkmH)pm2`a%gp% zdjhjug>0v`X$(d!JBch#|I#LbIWi>t*Q%;S;rB<@6O#%M6_br@!bgp%X%8VPVjCYZ z@x_Uj$ihzc&iIG$dp@>&T^x~Y{A=&w4M757If7Evgx|i7gZtLzo;wY=D>Vheu+{6w zSjTne;?ezuccvU^B0NB>Q+h0RdEdWyJT>dvtryD~DBRol$^$$??NWo~oH=ZiUhc{y z`Bny`U`3AXB$d62r#~1nS1R-@ly_2JFUjlm+(4Vr^gngn-A}Y=M<)nm)MeQl+k7!8 zRBWJ1vau=nkZOKvZEv>l^fFA&Kz-*tU^$}}>AxTMB8;_k8$T9s^rGpHG>0aBw_YXW zOVChUeg5IN<+ac@U4{I^t6#77Lo1g)Uxa6eYc;A==5PsL86PShL|f)&M^;R2XSO6w zHL=U42kSWoK4OUt4rjF14A){h$oH>0zjIdUF}DHNO7X{!Qq>JKR^=Oc91wCuewdVW zgm>sS`*3C{n%md`_{Jrw!}>e@>QcdweE={kNNS6li%VIp`z7_HMM0pCPkk1yN|e;s zEa!hihuPZ8xQ<^Bon-23GWykz1~0mlykhrN)x7P_OcO8%h|O^)slwLemMtWwd|L(aML zwdb{V5h;hP?QZgAHGL8%DKs&{g1Eci`UPK7@tB6Gc3j0chfu#xmA!m5QWrNduRS%_ zOVT;adCJBiEG$e-eEFgd>Hpoy*p!{Px1;Y$rb<%KXa9I)z_!!3maLC!PkUUIE?Y`O zu>9)A$rG_8AoKl~MHmcIJLIH2eX`%dVmKb?*=Uvb#O*s9IJAE(S1R71;Z&#u#lU;t z!NyWaM7rg#@0R7+az$Aav3u7P#WpP(iZ};|hM&fWz5dd8gS3~9Gfp~DN~0EV3H}fc zR!u!K;pyDrBaRzs3ABbR_i9P#WqYXH|J1gx$5x~T*hLJt;YAvmSCpBS9p4(Str2>j z=QR_c>gS4WCpa%#Z~7)EU5t9=wKsc`fP3mP>)p1o@w#XyBlT=zEU1a~w7+kn9d{WP z7B(JDy*fT+hhKKYO|0IrxpJpaGd9S>%-=V9Q>uC~~YAHU>_v_wUSXOEVRSDJVOr<4K^HWNbuMs(9} zk!aLJfA<)%t$}t%KCN7sawtufYM=R1$+3;WMUK-V?Q4Zs%E|hf5@Ul15;GPJj=Q)_ ztJ0+G42$y`9G$PV9_ev*PavzTK=biltBF|JWB5;T z4~+#&c-T|b!eGx3`9qqxZ2XlXTR30THQ9G#)<>bluP!;F8zL~CFS?#oQ4mi!)F{@( z)&SIZP-9YzWKdctlXG3ruW+|!DL2W8B}D-Kd#TUJ!Oi;liIm_YMsT%q&|NY%JeN(X zK-xjCNTVn>$>L>_BD5=4Hg0p9-s8%Ru&eaZK5hAwV{OpaDaSLsNM`Ppdf0m7-pbFr zz0a}l@{+K_wBj)L8MQOobm#60Gw1%%RDdk#$yb_m>WwJt0{V|_790 z>YdLXLlCaW7lUZ1DIFC}na(#q@}-=42r>efN+9Y!E=$32eCG}rompTj9meTaOprRV z88VvWSKAP2WBjCS*ASh}bU!RL;=?K?`88+QL*L6Zmo>7gOCPvz<}K^hX);NIFMzfI z(+QiU58GzWJITk;5|yTWzQ?_-+27?-6WvBr^&$O$Lbn_ICRq>GnzWKBhAlS2xWBKX zM~ef`V$Y?{{yll=nJB)<0}t$v9oX6js=RcK*iprid|F+*iSrDlzz8{s*u>(KT#X9b z-uzDAry*^Nm*CmL;Se(TC^4ki9+Wj)NC?oAhPH zk?VHcEXj^U2#;xH6G>rq8};*NZ*?1o}Y*z_2aYcD^3ky*YF4Tx;sCSWU zq~yrVQYfLBVfa-zXFq~kS&Jjdf3O(;0fohK_{T9BRZ9|w?h{3`CgvTgL%pwKjy_5C zE6Hh-mF?3<&GDZ!(oramyvL8jtnFc@4>?~k@poM&q21q$8Wr;nMAQHy_s?RZ@p1Ql zyuaB0AzMW@xR?1gsVB*;Xc~XnTB(1owcNz;wIZ!+ngF=*QY0P>b%-2(V9EM?8^Y}I z^)cpTFysQOyhB*bwdJ}(xf5HFZ9hJiJ$p}y<|sb;h*;FzSIR1nMKPznTu;xV0nJRH z{cD(xhkD@=zpP?~zO^bKBgXx8f0*BCl=eD8H)sRI9^o_V96ud`bR@S-hdl zDy?!EjDlyhK(He;9g zki5*=xtpOy*U!5DWTxbkBJ5oKuyyL8K$Zm+7_EtfW)Jo%wvMOjehk7Xq3a76>zQpc z2a7lno}~oS)-_Pf)!7V=C)9=;4nyNLIRvWkKKxE?4b6uY4=b5Z>{%b*UUkVsxVo3%?x}T3TbV%&J$>HC;O8@qlUAzkn4J-i_c$e4-o*w5WX?`9L-6-T~$2V9AxKU#t*&Eg_FtkF$IX z=L&9D?j_??xTnic>|mlH!w`C&-4d`=BXjS2~Ohq_V3D^>r2kLx;Wh(~1t z#vF0LNy&JJ;^oxJVv=Rckc1p7r5ibq&O`YPqjbx>fh1+bj08_&z8^`7+JGUWs*U*F zh+WVgABg^CVV|{@b{}zC;Py88JU*scKR)6WoSBusBR)_gf-Q|@#LjQCH1#a4DnWVJ z@z5b|$GHizD6{jzCS_QoQHK%IeID85pqLB1SLl+}RdZYns#*z~IwoT@uiWH)#PTp> zeqCYb*C`Fp%;Oe{T5-?({V1NM6;56oL$1+u8eMM%-fKFz4ENeMetc<1GdszLsBa|u zD~W}Fb@6WT{I+`dZn^PccmH>Ap2?JImpwQ;!L!?~`53`P>GiQ=`Xnd6IkaNYta3aa zz-to;UusC3!i(;bZ;)o`>=`lXbj{RpB)5=p;Qm9Y!_=3_ zbI(Rwgd#1A!|oheycCYV#uk;dlGX$VdKllHzHO>9`=ZE5d%%#$=%&X!_+C5tS%sT^ z^j>_9tO2x>;V8~5d43R%&@+zhNyyFa?Drjr{W|HoM;CHWz4F6t8^oIEV+EP$*ZfWl zMN@j2JkP%UcF&Mh)rDIU?tQcq9n>QnDoGm_(a^ccU?*Ox@smqGpnt{f4j(5o98e^d zDH&FcO9*+WeAsLpr|O`PUwK!sjZ3*iG+Nva8h!{hWN+~HQ3*WYOf-J~sP%yY*-N$g z5K_e+;qd4Xy`rnKf<3((Rf=I-Q@KwQV-iN{7&C@G6$-D?f3nQIe_!DtGu)l5o^||_ z@$NtdPnJ4xFtFWU^(MZ$$F9O98EG?L5g-&L*)yttWYP3ym0b-RWikj&4F1`RVHKQD7bIN zeBb8vDr0Fyo_9}Jne{3uQ^u zK1++pXpP1dZ>V)WMMu}Y3b&d5CwKb$`aX)3ZKqUwwLj6B9*VTH%UCgInur<%fJ)5I^`Q1V`@d{ctzt_uPstjc!R<#hZyryW^7kPak2vtrl^ei7e8V-6*r+sKqyccEuhT4rj| zoZVESlaOy+b5x*WG4C9133aZ_2q$z{_24O4*(K#EVN5D`#OIox_em(rdC-_M!%|$s zV1U0jlnti28Tnn|mn9U{{G`ZoDq6O2E#OHN&kFfU+%46+#n4DXB{Ka@yOd}3*GU28 zmk|-+;D{oV}`Z<_@#yn-hy^;4Ocuw094C;duJbtF{k!gRGrg-R#$X<{-!B zS3*@XvQKt2gDh)Yx@o1&j?|Et&1_tNo)IudheoqHN~r5m_sT@p6l};VLFqY(ijtLH z+z2uwp-)dQutp69;4&7cJ83%Hbk_DC)HbNlNzQy9=Ls%ku3?}qE50AK^B$P-}(7f@|=6Vt6N~`=1UHiHv;VDMC@G4G71YUrmJ}ghY9}B6w`WHo4Q7o59U)& zsURNHkFH-SPk#MHPC?+(SbVhCbRjaDpN8?gnY8?H=H*E@bodYQu zP1heWa~p~Uvr(5pgm@i0`(DY$cN)sZ*M~F5mpqWW)RLyZAif*5tDLgXbe-c`OUnJ` z>y*4{B_Hw=LYlIY4GUPyQ{oEnNnZ%eb^7{I?a(m#HQ7a2-M9|#piJsethaHs%vDX% zY`!i6pknfypXEM@ASo>I%*|EMom)yWi>a*hOgoM)lxXA=dFrn`!`nCb1#RPoVti<5 z=-`KF+_kaL2Atinv&W;2LqkRFVRE<`PR7$!>+ex#gXN~uLL#F`ziiTZL-*6YoRW-- zw1$gE%`ck3rJ~TGxEp)1dD!u3G;tUPT__GXxd&Q)mDu>cOmK`>UVdx1Qhj-0XE6fR zvubbk_R(li)7g%n2XZH3Ms?b^$7^s?U_3c=VtZ?H@N{S9bye)Z@cV}3Wt1eX$le6~ zu5{isE)I@C%{BbTl{;Tepak>bH&!U(RQGeiobHLy?tI)pDKrW|>ja ze9COgb-HWWDX5m~v;ff4^PVKMX37HVD5hkBddyCsP@->6lqFrQD>DiPv~omPi|%Cd z*d_Ee5$*Ne*gCFHC{h=Rxatmh7VCj1;7qoHBdV&?A1E!>ChSOW)*01{Xq~@TWQ3(n9+uuaVRRzy#Z=?mj$wBQ0FE>uBkIR!7a(0wl zas)l({ZwJO(-ZQQP8zCJHPwt_J?l~z;TL+kRJ?0gx0B`67!#TM)+^A=%xf=EQ!R?D zkS@?Wcd60Bf*u^6C3*6*J7}O6?x~oClhZj4>6uT&o=7j?xjarRPjNR=J%{^MSfhS&(6*tULw9B=jWEN>07$ybR3JfGSm@T_ZPBnMZTRGUS}KYKsu zk=k1*7}%QCQ9+N?2T_MeDNwT;nq!rR^;()IT|B=I-LtW zL}50a!1cO|K!xTPP)epO;TGcMH!Qi^AY5_@c7YteFNE2@BX`rAqe4-)|Jx}ZOL<~3 zdXwBl^rG#d{tMasOja|#Nm3@Xo1~=lL}uMVhsWFjO{r*Pt`~)Y5{j(<$M4^2ftSD6 zqPOL4_fr;-OL-}YA+BQQ^HlUF7-jPI71 z0y2A4KQ=|FTk;kd?*-x}OkLZI^05wj&C2-cqs-AZkA9<^*=pPXj!Cf7*(J>QOC)o$ z!i!%TJjt}Z>ow$+Tru;%WMF~HNLQxTxcWM2g+#eu)-}9UM{7&uTv@5|E_fdw!xZ9Y z4TdSl?iUU0#5(q=g=8pNslO}pV+TSak^wH2_%m4|eT8XdTr~WfXmSTno!l3SLZ<$; zBZtVeXDysx@+Hkw$qzOgaV{<^Gg~y%JFKJEks1t#$+zjWk~b>)tc>tEd6(@qLeU9PVSsf8 zhtkfG1lAiu5B7uDxWT(1+s&#qoqcECe^;EpZK$h08-&(i&Eew|~O6TsJAe zcBX-j(Jh>>37!G8pv)`T&;)#r4)(5t{{tR`v|lP2{{D#b!=PeXK;$(mflg31W4-8X z&fD2i5BI;mC^7OV=*B-^8<)5#^3TUN{f69{TA#KEiYfQh^lIMz{bi<4AerOu!-4KP z%|9Q%uK^4{{_FYw?ex68{>wjmi&{f28Z4#*-`Y~_<^@#8o(^FWrZF8bx!58rkq;V0 z$6E;hlOtgBVgf|U?$#j!o11RnbU(O;|JSqh#$d;*yg4-%a)VJWKD~y{4Xeql`)o+S ze_fon<#@QWGX#YMaIWFMtGV-^OPm`v3nI`ca2d=Ly@kk3O|3scV4}lWSn#DPV`xT9iTQIPnZWj)WlL!e5Vir@fo*P|lpIsVaIhR*vbPYl0Y`!p?|>s1f_2gMp{% zyubyJ9dJ4Yne&_g)}_t}fRn{me|VJXlJESPbMpZ)fP$k@r{#uqd&Q>c9x&%znuGqliJYEoh7rrr0kJ$(LybG(kMi`KZ*(>YOjwcL4ICIXY zCt5KmU?1huaL&EFJ-$0#gL(m6eDT|ZvD)o|N%Vloo%WF&_sbc?!D)Hm2`5PCpbr>> zRSnF$p3R*ZxpuCC46m{KrrvAO!t>_{sl&L(}nCaFtfb!zu;vyWPtwX@DKi=P;Kkp(ix_Hla zul1teMG94I6L4_fl!BI0!JuhBH){TBO&GPRak(2p4tmyT6hS6{pN0x8FpAUdelEKL;FR(d?y;5}GCIb0{fk=>Dz@F0k2O(B$dXx?V zN2JwiFNU0?FB6n_X=y1NP}zP1qNvP2C_3aXcu$OyY+InUVKB) zP*bC#2m-&4*|(gvAenRPT6Sr{dH@THa5%_1k-qE)%Lo(z889_j5a8n5$r;!(^wnjy zp3m;8vX{pX1EwdJf)G_0%FD!S%E~4)@bW}>cE2)Zw|=j2J7&V_nzyygyT9k(__wCL zX3hv_iL;Lan2lK8fWbtjH*&-cxsqXmFUM)*cYKkLJxKWN7M>>EFbZ~Z&}j&j*_6!Gwn zb0G6BrG|9_Cs*#KfqRvP{735`GX{2gQtpC)%|$Zjp2k~gV$M#m8R1f=6ZC#yZnr0# zIpwC=c?%Li!liEEoZtFao;YapOM|U|E@}mLBsX6Y13BL9)V$u<)f73i{q%`uF|3`8 zEV$qNkF-eYT`ewa+}Z_u!5A{{c`~NUD&1dq)xC`Y$J}{alzAQDEYK{Ep;F{lK))Bbi-O*q?on6E|% z_>YJ5mq?SEmM%Djpm(w@>@P+~2E32g31~)mvQ5PbcH2J(D9=d0Pt~ShJ?(?@GEC(l_Lu)br~KR3I5-Y;_J2S82QkZo>F%ccINuc|rv!cf*M-3UO&gg- zf>{+brT?>{!FgB6_y6TJ!QcJg-u{pL`S0id&!Mhy<@1N7*9aQ-4;dyQC_^IYR&kzmtNPh|Z4pW20k{F4RvlsgXQ7glQ%Ei5=QusT%K(6HZOe0aDiR@C^_Gd-~GFcjQ14f+OO~87cwV7rqbh@#sfR z?;p8?L-jA?A?L$s&Z(;837`cX<*vK>JZ8^aKKmAp#~T1w$_bdZJ3|0qnNZf)*jVB? z^O^t@TvKyIodj`;tZTt|mb*Nqg3JcWQQUs$~vr z=vdySfIRiqt=7Qsa4+OM8f>?mj0`msET~|2QS(?#UGplptjD;%xQ^JY;Dib4_aHrE z?jM~9lI~9KisRvU$NxJ4il;j|o-m?ywEqym z^b%?s$k=oTrx@oSv+Vn~-Ki?^$Xu|p)W?{QgmL4S%|`=|b5UON6ZW{WPsPM!WV6pG zi1&*F0%V^`NzG48v^q?bSxl4T=t%p2{L7kqqn(kRc5$^X4S+3kwI3#Z1(N)*AIM>E zmb;=sjncSyNiAz>Z@*;)@XokyLQ}wkoRk+lC$I9x?49PDFN{GzhmF)x+Dhl2jO3u8 zpw`pk)`G;wlW{`;a}<_5ml9sUS{Si$24K(rSPRnoKhSEc@asR8Lm&KO@9l!7O01Fl zZcX3S^pUB!loSR84I!7Jcx%Tae~syy&NAjuv?HfMFWUbzzeZ14PbGboxo_Y|L^J$%Kj8&vzWnuk z(0usc{f9s2|33czKmGUf-}Jl3K>pEKZ)zwgsHiAt#;69{7AHH@M;(RMtyy9%=>JHz zcX?n2#y=s=e-t)wZyMJ-*KxkGKhkNGyd-IPj$F^8dK?-L4A*MX1)Tp}9>Wb@{ri31 z-3|>cNqW^1vvFGjzbnnidi|)R1;nO09xKr)mORXEgQ4$rU$aeL^#=@|H^vSNpOZQ zf)#i=*K+_2#N}$w6YD*vFYZM+1X4feQd+NOP4lO!2BlC*<+5PsCjV<5Nc;q>ZEOhW zBB$VH&%gb{8>{bzF! zmec9MnAlig=N^#zAC!Tp&E> zf21M~nLmT_2H4HiIstGKkS7Y6KMxf)a__H6F%7&xfVB_)(12Dv2ahm=ClfiYmz!$n zG4IC97Ay)h$!F+kkS6(3XHyQ@s9AyRySO2bpZzmpvt>b_Zk@d_TUj>A-g8^QFoAc# ze=)86GFlgN1UeoIH~#WSbWJX7bORS|tmj~XMlbRDwRDHHi=^_a=rh=vn$+=^VxH#x z>(Fyhi~IBoPRx3Y^n=ao1o&^}+}u3{o7H~>WSQ^SU>6~Q>ku1j>$0Xju?f!zTNIqN z6$Jtu*0Y;j>M@r&v+jc#yn*h+(e8r*7mXDa#!V3VR?dU!+#1;Vk}$$`Jxdnwz&H$| z22QZz*r9bPzy7BAi+|5mP>r1%g8R1ZfOXCKvbp0w=Z00%<=%s2)V-8{m!S`Elc{731l0-qm^)RdZS-1z-z{ss_Z0hrS}v^bmSv3?Y#*NS5+n zrpB6o6pg`^#9kehVO9{O)bxI!hwlHhNxW>lB*kw|-9Bw11$r{%eDUD@KeJ3C0yJC- z3JVkTUX_j6ua;-lZ+7USyNUx*p5;ogtn4&>VWC>kZwEDLO7pODU5ZeX6>yXcpyyjz zOx09Wb`h=MpTwI&jJaT;+Le>EsVOi{aRFlS=D_N3HUsDr-R9HgqwMn$zkJhPD}uut4MK&ZhVV=2+VzXEazO7 zA{31dFuhz_PoTvf1A|g;!G`qzL&G|V#r6|mcE^*Z6&^e|Ze5zyZQjFkk%t)<9XLoI zoq?{oaO>e%`NJXLqW#QqrgnE&+J~2@We3WOPLRIH<7Rcf*aYJnYNi)k(ZZPRq0GR+ z=Z2-H1IA4N>gq^U%&xao`f5mD+$6af=C}+7C9s1Rz) zj=;873=OGd2-g_&n_^GgBmNk5(i27~eMYh6<8>np=1h89zmP`4;~XjN-VbT@TPC^` zdiwNu9k?t6X?{^39@S&S5$F|Gtk6XXH|jDuq1OL!tM!6D2irz}C7lA24_v_FA^wLh z0M>c8>lzU#+QH);>rgpnt9;%M*&;Xj#?9@p7HHkgqet5wmX1$T2nb5HIBk#nQ%`vM z$uNZx&#cn)21=s_FFEIZTq=E6wlRI)!;=Nd8@qapI!`laii7mpcAHhd2R|keSmO1 zVU@bTRzVPp>RL`W!Uj(reS-)UWn>sX-1$IK#5hcvuSgVU{ruU>XC|btZ;}#KXlg}1 z`b@&kNGl_l_*?1DO?eq5B-|R3Fo%p??9YgGl=-0GC44cLGO@asCNK#2SbMQ3XZK}- z8w}DVE~Mw@O`^y!=kqHH>jS2GS0idfM7og?kA3zU)>X5lJl6+|H%mJgC@Ir=bxW>1 z##svoGY?J=sZNJ~e`ya@LL+EUT{+akNJMMvAOB-8)fIH}vj$|I?@FEFaRlofq3Dsy zsSA6H2bi#t!}~O3K#XU$b`q*3=G?9C9tYBx~~sx zjX4Apva=V-+yP61yo@5_F|74(Gjx%jYMyFta0kNx0S8OaTsM@*DXT%LSKAD-zOf!- zvqfU;b^0MBD$-uJc=Y7@4K(`7gc@ZX=C#YJmQGO#V5h2pb-H?7N8(%fIL{QI(1OHo ztr<pOBNG?-z@;ax%Eo1`ISFCQ=WTATVQwCu)7m=prk=)? zx%DXeE455`^=Nf|{>q2lK@WcxK8D2!QqB-UTzr~K&^Bm&$gE@Ym^+g4Vv`|d-ZF4Ju`&VB*(syf}H~%^){E)n*PI zP1QR2VKHc7r+F=g43i7EWhDlE>3@8{dcoagWbxDPF^SttXXi4)rQ-56U>}1LuXPfn zIJOzc&XC5=gmV(r*pDZ|EqjwO@xX&CteWy227G!^js4P2k>T7|(NutspI=z;PRcwP z{Z(;!t0ZA1D+kBcU^G^o;_`G;zu91j8qo#!t1_xC?U z6A(3j7xT2oy?JwIri!zbS&HGy*8vzzFqm+CASY!$TO7db*0KDutjwK;*4=JznaOKw z=M}aaK4*xpCL#et_MrWn2=&^X)^|iy*_>rdHrX_V-ODI zv1xqh_7oGk?9@+>g1ue$KQ%!tLI~X&W{tkK#ig8K*WP`nkTZDt9cbkS(9C0+!GxW- z^r)`wp`jtqtx+FL!+I?ST}Rk9QP=fxlU_CF;Gk@-3GeocU-J)Dez+n&Uj!P~u!xIu ze%@{nRt2-&`1#h;N`qEC1;~Gcz-70{Go~R^S>m(XaBxze35WqF*((e*P*V zbEh=V;%v`&0(;Tgpc-{|{!0Mr{f$eNOo`PaQFj|<)Q>@g+MT$BJmEBDS6A2DL0|N% z3IG$6Ych++qtW0;K57vptatf9G$G`=g*&m79*+5`NRpL@?elP$C1U;>$Sr-A3r6m zkB`qihKIxnJVy2VJ-zLcl9Jo!W1BN|YJj}FJl}5oe2X7^^$_HiKz1e>s&A@oOmgil z{At_Qb{8mAxk;5T7&snR&5s91y)6QU&g5Mqb5vGPxVX%4u?f5y+R@KRRW7L69#^Wn zTQc)~Q5va|CcZ9E1t)P`-P#$HO1K0>0=i~JbHeCEnS$#**stak5<&=_%Yd>l0@_bv zJ5x0;?hF;WU>zpPZ7eOxNDFOZ_fmL_V`44=fg!yId#kG#n>%W-bgYVpmIwH6MyPbX zKTF(lLy4W8y_HM zGtClviRX*ZjaiuxiM$sG?9KWx$WFq)*VmsDcgtAu>uYGZb*m04IylWAPS{l0#CltS zvbsMVA)Rs5IoDKy1kQhU3t0DIEDPX?bw0i0npm{gd_jNu-VCZW<4d;VP|uqu&DfvE zK1XYyOityO!CLXy!~{eqN7`oDCgO^*#}*-J3A$) z%ch3LwY4;0uRl}cddPB#evRAMH$lTXC(hXht)JQ)NmW(uiapo?%@7$-r1x1@X%zMK z_xA&aSD%?5VBT8t>z~+hFR zDahS#j;%gE*1!ue&DLO2&30uKJ&S;$%=^FM7_S-WRWqD-N%kVtJMVZ-$ z3`E&V1)t#j*sE{wOZ)~H*x&od*tx!R!;1OxRen@cMn+SL%s>?f8*ScC`p+X)FHKu5 zI%(Mc4y5nFgr(AKqXFG!4Z6iv7JSed`HvlZtXeqr&WQe=gyO`=H}*|ogEsLfSBSYL-hcT z^Bdd>imTCoH|n$cMxRZOwDE!K&^Nz^ni~B`YeqTfZ4cO!gzx zVx&H*QSAS@vrub3#dZ5S@naacxb<4Yu81AFgVTJ zKkx4tlhcYoI_S`gdh9Q}|0Gx(=m1iH7-UPqCE8P;pVLKCoHYjMgO8itGO;_;6#-`h zw2w_Fd1?sgp8lSh>1}LCy8F*7%;XN)CS!oBks5~yG05(GsoY>fp(^&g{R|ZD;{(00 z7GW!m5o@)N6oQSOGx$eqgTPVrgx~3g^KO36!@sSocTPTKHUw!#n1epGrKP34`RJ^( zG2OgZt?7x0T-;g5dmTZjGj4-(iv*TvX!7UJpI4PqXzoik+bxHJ0VA@Jja^{((H9Nw>jDA- ze=_=(7E-*BQ+}p(*KS;b_9grAub(gP1ATzA)&6I4VP`$^O2{CqfOI^ai``Ui=PT;P3vNc}Pe>K}2NslM#|M2J@1ya4bqf>2CTDc!pp?Vt*SOAC3>_Qlj|J^ju;jRagu71rZM>|ktZIX> zko$ombY$bGkU-Gd2W5xJvpJk%N6&_D#)UC5U+Uj(Y6L0)S{_{v08Cp0 z^Kyj??))>uYdd>KG*e2e>e=}C?9i8Zpz~qe=m;upm716s&@!HGpF>AAm>M^G+nsC) z0)=Whn=^%V;9CSMLP5nW6TZx<+AQg6{_2(W_PAP_O2Nx0Kv7xIpyu){HG|K%QNr+x zp&^5Wq+|$Tx>|0XjOCO(x;i&pakr0_L zo^QWuSFN2;tEZ(=YM`dv*S98s4)Z)h^UcatcPX^TcCw0{on0%o!V7$|V1R>mv5pgR zFYDrkh^T1Na;?6ChDI)7E@-NP#xKV=HEu+DmYCE?l^nsQlbc&*N+Gb`pPI4U-7@vf zN(tMDv4`?A3u+sr=Z&nct?4{lW0nJ@@oNp|Jv!)CPI9`;-;=rg-TAXs_uc6eqVfmj zYr9#WQrUt(^{(;~P&Wp)vqWVr6EC5+Mu%;m`nH(dA)?XZWnlOT{^q5DtfqFk7&i|O z`-!rC@*JQR;sVIan74uZ5dBWKxL<0rk$@%-X>}GU8w*R9?NhMH+P{qzLzByln`Y~Y zlCV3mgp3S)2eNvT5Cry7OOn@1gj9fuzw1ITZ)|vE%+_epvR?wLuKyu($77DaT6Lz< zVtt?^KVMBcYb@6XtUK%gI=Fsd;u2(3OmD~k3Yc_FfInSIT2xgXa54ZJsqrLR62&ES zk3lN!V(5E{2|wtT3}y>ZxzkpsTXe_x`T9Jd_-)FPaO>7BGUXOj}X)-~AL z0amyY;HSHD6Lo4i;JxmJ)^` z+CBk+oS{uk-QcWt!J^7<$4XtEiW5VdM3q^pM!Ow_?lUN}XxbZ0C!WpI^Ly_P0r=>B zbX^p1d9m>21sQb+p<$h~AK)|jI}b~PaYr{sQwxIuY#u?ula?Z6t6<=zvx3framBK?n!lUbd=DMS_kPDNCuwV2a{7nLxcU&0Jdq&MeCTH)}D^PLBRRS5dO6s4yMcdfGXV)p+Cnex*Fa4tSWVb7EI znu-3dF{GZ~Y96l6Z7nTrB?s+i`AW0m-{;X%IXL8P`t+|*1yXs%?D2<5lq!~`(ec)H|0h{D}Ft6y)<=PxDF!Yt+`xI^5TH@U>vYf{v?9$ zW`5yel5o2Kb_${M6gfN%$y- zRc6%d;M$!fEIQidxVEpa&l8LH(^i&FEz)%opUpV$-R0Mv9Z9ea)#^}o=0F*M8iCxv z<_Z~fdHzbt{ETTi-TYAm-60Gw@Cej}U?R%!rib_*5b zK8XMy^ey3)4o@C*)#Qh#0_A9`RmyByPg`FgK!$xbwQ!tTbBr7~9xJxcP$~uC(2*0e z9KAEsyo$&0AiOszE9Uj;_ow`8`ClJ^r>BX3w2|@OPft(TPnnF2@JK~;tDOR50`8m} z7mwl4sa!lh>tXG&J-ZB?#$(h}%GC}UC=?H&5)E{-Yx0G&LPp&ON8quC&u===87N51 zVIB@mR_HZ<4<@@kl!^D`Z7y_$1mykYLI0?$_6o24MiiZDPB^zsinn(qRw97P`cqtA zSezY9Ri7^`tl%*r#VJFSPrB186cqb^C@PE6hT%xGN+*-Q`K?D$H%4ixQl*&x~w}3hv`5o#noWdX$bB)Xu~Oe7FWRM`S|#B zAQ%Dz0@g+gy^B^56oNXHxaGF1eW3mAUCvg);%CHT$K$f_#=+ra+ib{oYl2(w+kj17 zpdh|~vwsxw`}eA|4kpPTAtB=>W>lU}pcfy0kw94w9z5^|iM$i?qJ@Axg8)nJMwHI$ z1JLr|Zs1{K>wh%S)}ES+bJM=)@9CBA#fg4vLZgiCB_*GstWC&f3y`VBP)uTcn?D&4 zwH^rw4FS;6beyhL35dp?{P~uBjp&$|WW4fn5bcaq=F4<Iem7xIXOorfk;_mj6uji4p%F*xEmG@0rj*XWd-CDDJB9?0exmS`4zmzGhl6eN z_oqm=;)Z$|+zYmt7%d3NY9~=yVzDpf2s%A-Y24}oiU-!*`l-%jm1ChzstiWJSnU<^ z9018{hfaRMTAIq4XG#Br>*)aS7%g=Cvuhc*?4CMs?^vJWcik^X}Z8*y{DF*hSCNk zLVkD*PqL|*P}|!Pq(5@dzm?FBd-oM z9yf!qSZ{qA!Yc+Vz1{kdRrp89l*Myuh<*4`e_UMlYUwoL!d)IJwwE5}stQf>g-Qh_2 zyWZad12OsWc|L7TpkjP}6nWCEVQINlt+TQ`yIQ_CoE(6G0T7?q*jPWe3%9Oqv(%oG zG%zXb*F^Jv_#Kp~>UV+cI!=)imy{&pg|_aMYYH6uaZ|}e2aO3v3UqZ%+O6ch!!K^Q z$X&v}Z{@PT`APU22<6Vs&T80qC&4o}p7W4GqaGaPmu>$)j0}3s$Nm&BJc}*H?RVmZ z6jP*dgcp{U?gDUGznE6{)L4l;W~v9xWLUl*3XBRsK``eIC0t7xt_5 zW-u8$Z@Dm6%A@tB*sTW&Ml7zc^X|r!ihh5xyIAFD3a`-CjjxTHHq)ElfPUv(E{H#V zb+j$$e56Sea95-LZ!k+6>R0F|MR~s5`q0WM7tEMH+Vl_ChXoyGbU*BnFAiYV*bG0;zoemc}9yWCnWZ2o7_x;>O>@R_xLyiX0`<;(B za9AP+rm{5P(g0Yu5oAX0>oqvorE zCO^~*M*;0Ywl~K9hhvEb8S{AQHW=AVw16AwTZF#Raav8X;NM4(=V%6$k!42(2Rm}l zNtkaCF){VzTLoz3TMvT9PZrA6EVl*+Ow~>67-(ttf!g(OWk?z=L5{k@cB{&6z2yBF z9;@*?d3kv|(_svZj8DjVN3b3My%JBcnb>PFoLYk6Y#r!uZO{W1lTin07B!T;HxA)3 zXuGg3ErHDA>h1&A3}rgWTVtsI0ISWNURN9D9FkYl<$5h(Ssns#bWbcVr`v>QZcXe} z8x`x}S#+`_LaW*-S+~b!ywuA1<4!yP77UCGpv%LHFa`~`qtoTb(~iqEu}fDq>``5P ziGZ_ZHytou?k1uPq2Yiy?AsS;3~JMrJ7*!`^Qzx;Jd|UTU6(#okr#QopRp1RrKk7t z7?-ArY`|1LjbHQnweiS|JZM$GL{+mdEJ={4WJj_au#6TY*Dg#K%I(Z|b)0W2O6KQ- zD-F?Jj@+}h-s4=HgJe_!7WxuMZj;n3fkKKsZ0My6U*Tli|WBn7uXFl%kQq{}YZx1n0QyY&T5h;KY%59p%toFatS}djUYMsE zZ8uMKb#%}PlxezIF%DKB-9VDrXJ900wI4UNmpT9G&~)LJSg9J{A1&H1(@sOk#@yUo zJf-=KtSpnMY1`cDp;HEd!D3A56p!7~!LrQ~{oAq?u$z{`d_seFrfTj~t`$J0`%9#w zsG`{K-M#xz*q9Bl8{{D!%CyO%N%EP4!rumpigr34>Pv6 zScz7-?gV^Gf?Qgtgo*raU8&{exz|)RkKlQyj>Z+Eo21`Ur9X=Odn}Of$VC-<+_3Q{wIBjt4!vB%*HG-h7B(=lud@Oywa~U2U{-rQS zeFLoMk7~#4AbfUH>?c^^)7Ip)6}@^7z#2>839@ga^8g~u5r0D)^NmR@-jedl%IR{O zPeU8B`>z1oLn3$<2rl*RU2e4lY334HkTe6wH2QC23APy7cO7K-{1d*{2?hGt#jA^y z?RgSQt!i!64CMbvp2lZMo3F|7s`8W|lK#%w}q5YMPO(n>@cY`_y%Ek5yvva^I7e>yNmRcfbB*4O43d zMyzfbOT*7!?OeL0jtU4jhrKpK(_%^iO>K6uR~p zk|Ng<`|*T6OOuAvdr3r0j39;gWyZ?QmXVZUItP*KOo>I!foG>K#@#vy4nOVwd2Jjb zVl`B>HUnF1R=Lr+z=Se_Hgmasf6cpG~Ao z96E7+Jdp;c8b7MWFSnpPlII(!ch80D|Ly5Wvm2MuV6VIh1r_B9>g|Xw%2xqX`W$M! zL?chV6lhebqX}a`BFtB;f`J2C?D{d10tkR>RDDYuox3L^-u63+hYSM8^)dj*CjPH= ztc;4Boq?RaYfKG>>A{Vdng_1x8AwSYIV35mxG+y%J^R))I%7ziW^|0Q#L`x}F9?M^ zJeF#jX&tn|U8hRDI=1<-Po{&zM=X)H^G8~0lFwAR+)bT|FST^SNm?%?(%>5%FlRAXwH~@EKRucp$#B%>>rc=^ z$Pn3bJH^P9x(t%|_=qd-S5aSV8_Ku5n(a?z$#=Niv8_yXvR}7e>ns=KFb`8lC*c^9 zEZ4-I!o=CiLY7NnUD66QbVs>(XR`Nq)c)?Cbgn*};*5+r@ z3cwOJ%$}hAQLD2V))nQ7Tr5=^9Zk}CI#$yKu5N_Eb0c#bFD2C|EwtT4aoXQEAm2U` z=XsfSd}XDXp-R|6$*amC8WWRyZrV#*OJ`f2`9?iDMJmiWWG2NJI&OvWGk1)$BWpmT z2srW4zkq&S9m+RgdK0rh`L5EL_uj$D={^CU?rFw!Qlixor@(YIaP4Uxjc+TQ=JxIH z?QI;`R&wjOA|k`4lKcCKc#E_STfTzsp>%w-HC8@9kqf<%mR|2$U5(X>)yg-tz~N(} zM^>8bI^;Q=DdFQDH}qR*l$uZ3UL}y{FfuCmK}`+K5;TZ=e&-20jV{f9W5c!-7sDvV2;0TdgDJ)h>$(TWb$95sqeUpyikGvx6-Ru)!i%Kk1; zL^CGF6ALwvu&a073riZG)7RfG(BH2Vw2x4_T-A=tvA+hg`)aZnNnY0?8~sT5XG$_8 zrs?nUoU1kCt_l{25jV`W>cWy*8h&axu&@?pwlW4+&EHo5&?prHLG6umZqzQ?Z>u`fq$J$<)yjK-^@hi6s_x_dQA||n z_FLx9iPj%}bJ@C<%-2)Y4&~lNY@90e_jzGScqM|I%sYVavG9UmP+yL8X3#C~>|(A3Hb*Y=XnRK7gtyILWKgg)-xUFSf; z0eR(#hJN38v`VcSc6At4qH-pvc#l+5E1Jahr?w@q9h`>%S;DZ@1)TtMzFp?h?p+_N zsx#k^r1{-E#mZx%Jp0H+MsijgtJb>Gmg=yepq0hd)0Q*;M2T2DkOH%toq#?fBPC4@mbyi(GuBM$||;FymRTe&9k{gr^p>eF|r z-3y#Uhq?1}8!oeb26U7v?%Xh$@Lbb4v(NK5Om=g*=`nHT+i(SL7ii^Wv3mJjsUZ54@#Il@Sc^<_XGcfjdrO>@ zeO6hj=ad4yC%Z%0>S@XuRB^_0Yje@T!K-r{MTV2jh09DlyxhR0!OsWin}^R1Wk~vi z@9b{v^euNhAM>Z4#s^ngIKl41#>G#*pKHMj&ZklNv4d5%6u1n*ygO22v+d0)7`H$8 z$-4Yv#3w{S@47G1y43G+T>gs{=X=ZNnnCI3EuE}-QboPSl2lOOz~AP0V|@9)3GqJ= zE%a{~ZNT}{@6D5>sLH0rNl7Y6Dm0SAKqQmuqU#pqsSb8E#aT~T+h2M__@Bf^h^riZQQpda!r zG`WEonlgkvjf4;p1W|{yeZ9Y-F*&Y*CSR@2UaTGy0k_y>>zLf+{gmPCSW#JyPP!)e zh!79)%=25hW1-uJcqvMo0aHM><)GX2FDxypS+<801O%H6InaX&&7vtk>jf;{^AQq?(fwF;ZTV4!88$V^*TrF!ve zy7a4TKc&AHR`bM!noZ3k;Ud%Bg~e}~@a@V8Uu&dr8P;sydWmc?m+f;lesb1@U$fA| z1{B%2vmAx=``iw1BmEPtJ38CjdshX*_w2P}X{e}-n%0U93s1-VS2%SDB0@su=jQf~ z1GJQ9pXLk{9n^l>irDMss;<-hO`wvcP31XKz5VOkI}br8s6ag%o!^aR@9Y5xCAJtf zeT{dFF9QX_qv7yu1=?X``KUREY8|u>#HMo8Cn&uOB zRuv=OPGAy^@eOYHG}FQrTJ;0j9S$bE{MI=w7+gk_C~=Qp&F&|o1#S%r@ptV4@~MPTIJ%>Q7>M$da!Ity7YU950{0W&RTl zhMEcj&K<=gUqK*4allOuY{Ubny;`^S!b10|A8lhMXU$aTW|0F&sIk>iy}z6bq0O$O zvEzS-?`;RY-b95ftj^2?MZlGJIE%oXf~~?1mLGHyOk7zK=f>KoN8R_@YWaxU7pffI z4RMn;ww^(F#Flo|+Q&08chcA~lGm($FNbCbntMaKA510SCrMx@6rc$@ILySwgCF-i z284-(NNT3_l@h^y6puQ&JPIZzrtJ2K?hx>A?vBBV>vVz!&J!CO|A^!1LiIZ!_R09K z-sh3wzMuFc8V@Gt7XFXVX#|lvcM}WJwE>Jrqt9co<#aauzGrB3#`l9us1->Ar-_{4r)o<^Dv) za?ON9F;k94i3ek&ql-Yv_FYsjoovOng2O^Rj>|2Puz)TYi0Jxi}G37?4%^D#LpL0=;aX-~TuHq3Jsc6etvuZo%5aK*C!=9=ySBBE%{g0e&^K@P}{_s$ik zouM`7&9M@Oi3H`2usBzq@wT>d&l{5CwNGMr>^6Wq{7L}B{J~#J%3z}&I^EYmo~<`v z3Z!XO4qfjQ4zWm@9{&e6z^gclZw`|Q?E#9x8L7`zp*tpr z=G=g-;anX<6~oK3Ky*^VnCP{$VH{!e(W=GGPn0#6-HiqvVW=oWyie^5{uAedpVQZG z%m&aox2$)!RyX}_p<0fWC4?i>(@olFXe`D`EC*Kd>m{SuOeT`|3-1Vin^W5mbcTkg z9yiyj)uWw8a##$dfcQ1%&iJ(o0tS0I8g;ygkQKZwDeQ_V$a-g6{$8r7@f3#DS6i z!k~_u+7BQVDbcE&>!)t>HHDJZDMPr82@?}7r6So@<9h4w|?N1`v2Q;Y2XI3Z~hc%e^Q^q{{Vtn>ozB4nBx(Lp5}J5eG% z?*0o_ECG*>CM(vdb}|^u7zBja)?g-L)SQu!fs+#eX`D|K6cns&q!siuU8<6j6n9NR z^_zeICP%&4wCx9lwHKMbPHT|~NpnjJ-hDDeNA3Am<<5@ZJzRRM|0Z;xRdNPtDT$1w zP1pIeLxqi)_GHlqadEgz6UAmdzezpxET`1--#3+P^7^g{ZZ;fi6r0j`zLAk|G+3Zc z&sR(hc;$URU4BvwE&t>G(kv6^cqx>84aSIcE|1SzajVFjK z)7?VYBri)pzlDN92u!P$A(ZSUeG4%@+Y6=Vr>76_*>*0x?p--v31aS+c~2Sd?35iR zGhpUdwCP7O>ow~I@^i#PS75TjLzW;)r`>p;J(~eFOW=?%6HtIlhS8f06{R2O_$_q> zk_c*#3DG@HR=|pEQc~GO-iYM%%zOk}4HZVbX6%+9=kas+_BB zv62UY?SQJL&eFrI0$g9MT}_38{4rgxMf&a0x^KxQedpaT67GNbNNWJ`Bll$m@ywYQ zRzMOjEL^3KzA;hmC!GEp7%t#zEhKIuWgq(`UwI3Foe08JTd;BRs1wAH=_=XkJInsM62BT&{WBG zV9;zBT(p4mQM3$VUZWv34au2k3CM*XVUb~>p)TBW?cnVI)KwRQu8kp`F}zHSi~>uB zodt`vM;pDb&=UR=0ivuo7Mk%@?79viER^|PU_^KqWrzuw00EF}y9c&y%i74TjRjO* zM~}c2p8%uG`U;oX5Ph{aU=O#i%5;TVYc7L>RbRUWU6C*dmW`T+;Zi`96bwM_o$0vG zHqE;+RlN+k5*H;d0M|^z*J?ss`#yb^7;YQG-MQBam2LWugb&uIWs?;E^&w+AQDbpV zpf_y{j2YcAyg>Y8ZoU!PrifhJD!}Xebh$K5PLAlXwz)dqtSxs0p@z1$HW2KG6wbd2 z{9)FKQ%~>N+QABimE4!lG?b2zDluPW>NBE3I-{|f?|_2z0pGue;y)-aukQi#3JM7UWAen+I>7c8Oj+&MQrIGdtxVn%m7!o zihVY_l(NchdZ{y#-wX^rEiEk|#`Ya~0G9)LO>kG2)+np(?Cd%^TMH~Dj>Vzhr9{PWQ zr$YY&P}KX5p{}Od{QiXKm zPWPA4iRJ%@!eMaO-4C!|X?w9r-n`fNE`j!cMcRpr9f+Pd&Qi}9n!m6%ENXvkC3tprmSS5c;7)+SLw|Iz z7w@`eU1?M*Cu8kx@T1)&W@;pj+g$O+$=7wLQ+rQUuwe$tMS`+!+67rkmk}O___>?U z|6PEF1LYFlBkVtqB^f?jaE}z5GJndEut}5t@nsh|#85--S@tx+`KsJzk&_2}gB-Wi zmNn&Wi4fZEVt5BCXQQM)NzDhO?VI+BQ)Y5}VuIeCaOKChVNr76C#n&UTrnSrC#xfy zx+$kgOeooTj2A(H#Ji-Ols2ai9)R;H;Riy+A2rUEi?Hg=S)!y1zWAZkte0LWWG*7q z)o9pZd89a(-+Xm$QF%#d3dFukskv_T(3i^z>@waz)p-HWy!85Bn0nlwxI!a@xYF&QCH=bN>eE`H0@` zSo9Hj_@ydr?p$p((G#m(3ExdxJ*;5qxDPY;!TGDQ+xcB(YCVqvd#fA6{Z9qFcC0&y zx<|Lfq1b|YQ3+pb&^l8$)UH?pQW2$KVW0`-I{Kkt;IHRFqddgL5&plPK5W@iC@AJi z+{nr7fM-@#W=0`|>!uYgwEiXG)2T9(UpL+|EH&o`IVvO zq}`x3?$x*&xtW0vuexpMq$s(Wp5F=YOv&nG3u!ao)ZBrA^u11Ko&*cqm3;4W3|_2D zebXz7RC5DNu#H13^i(r@UUwU@?gck}of%h~%tN`|kPmheg2i{1Ra8bvEoF5|Wf0ht zf+U-lmsczf=oM95dIaWOwfKOs<8iq#@GVYRorSsJXmCN2Zc@0-v;X?^zf2u^e@z|J zsl)3v)@n^ZJy^&Qe%e+8)Q-?N#0^PWOX2>**GI@xFHBUv`y^!;B8+r5VGsY*Aj4fA z_WnKk_}}-bd<^*>24`_BDSXsI(;(NF{-UJBqy#th{;P+n^&?{`qw3Kt_g_b&>zPHV zsLhAIOKZnRg~?%~6T%r}o_-~h@yaijE-dCUc;d^2(>%n{H3ZFtzN4N~dZIC2)Q%5M z1MW7=J#pt>GpF-EDu4IM%rY^hs#^t}hEd_!x2fqS%zWFulknk~V(heF50@Li5`F1D zI1Cp1Fh$*H$HMDMbK%O6KmDMTv^QIU52OEQ-T&{2)t%)xV9=+Bp)90p*IJ3in9{|H zf!YkfRwRBqUGGdog$=WMa2UIzGWPvZrMC#1|Q@8{JQymsePKE6ba?;ku z#x?7mM+-j32OG$ycqBm+-ZkhhMQJvX<=8c5*GU;1`h>)OgQT!+VQF?WL)w|tQ!|Il zapR3V_(>Ut46#5`A4-GGNtQcRX0MDUpIM@F*@7Qoz5iXbq3yAljV(`v)KI+qJbn#( z7iI8|XosUt@xnGG%C@A8e1}#X!`+~eHht+>^V#`%XJ~d}b(~Yr7r(xvax8>FV|j5= z+zNAR+<*+>)rR8icUm1IdmOGZCm(OiPg!t@! zq##LjYiPN+ytOZtLa24rrkB8dMo8-EojM%C5XXZ50QG2#u~u3%`PeGJ)FfDE(*3J{ zWHdjHJ#^g7;J1#8REvp<8sFKaWH%e+Sd2J8aUIErtZjMfW>F_Lv)QsrkU-O1n!xOvwO9OeEdZtL93T z%>W4kJdr>lGcX0h^WRA=Aa(tE|0$m>)EeKLq~j<1hI(7SJ>{2tc7<&58oT|~C4z>j z)FPF!`0~O^bkex*pzYg^U+*xv*~ySg;%hq691YDPqR9sxXVO^Pw!e<)JPXabjgidiIq} zgP=ffcF8k9o^qM&Hx9pqggo*)WwoD;8w8^E>^{$p(FjD;c$G4N;FUWa zg6X4DQr1Nj=u;a4{hUG@8||vPU^FaGS$)( zzxa>`ES1A9#Cs3nPIZUQHNU5YoVRx$ljux?vzM2PhK#!GH`~SG*MNL-vY(D}4J>^} zTSQ*M!4dkWDWRr=u9i(A_ec-8D;iHu!2kHFtNQ!6n;? z%{hQ~07P*&F%x!3sfy2svyaV(WARa?-Ad0fxRVtkvOD;kX*>1Ze!1dGz=2^D*IeF= z=)I+;U(LtO8YwWpP!gY|;R!WHK0i+?u&9hx;=@u;2{755tRx$eCMS{sfie-sZ} zQ80I1H+e+>q~)Ql;{qfPfMYZqIDA7Y62Qp2wWUQe9Vv_k%xDh%R6Vggb(|fzOFF|) z=ZZWq@-1%t`Z~f&+Gc>Wx#hpnb&r0cU8^K%xb(!7I(4JVhwAxrQ4V zVZX{4bk?XF|(1+(k&satH4 ztlm<@^0~|1FY)~m$;pJgsABm3+A8W9^FzdF%BiHF)>M2|Rj4A=ie$>nOpaEfbv=46 zji60qqwN?NaE`}}kZSAhY;`!TdP_}@i=J6}yAc1WNKB!+-9)|}0bP^|;J5-GJwC_~ zKAa>MA{%`>Zdl`V7nW;N0Q=QAP?W-jwwflOW?}ix#LzJI=p?w@J2{LtqgEv|pwbT6 zI58odu9T8YdCL%DXNf-32ZCJ-2?WRqY8UDf}M#1CGR04otUIIId&3Smr5*T(IZQF#pP-QaRvk}9<%jtkrwFLwU)_C)AV zbB)Lnh?FW>ja&+Kkr%aOxgsLbW}eLhAHR6S#PxLds9wFnx_v_eB}6<~p+h3{`6Hia zXu|2wL&T-XA-zWt_a)?L*>Z8^vxy8|JW;~;hfxTTp?v{9G-_;~kaTopO85^MBf0be zYq_~@@wD!Y)aW&?)Sxa$vyX1B3OPT^!k>LxXp~~L*(a_(-*cECONjp(rmI4JE6qp+ z5r+Nvc3nIxkl1DRG@9godG;-bc#@7*q&(Mb0*;cv1EtxhJigtV?spzC&{FKCrqyp& z?A`*Gc#aW}-Niu9wV|FPF7oD+UAHMqgt>WrdxvXGWVF7S(e~7&BBi5fLL0lX5DXS# zB9hz-3%%{r$i`xCZ$jdFC_!$U$LxPVLY{#Y@r0l!mfh^Mz(BD!Lc5d;RA2xP6cdFH ztw(eabd~Ky{|HX-d`XOPL6nKdgPs;Hw$aX0vbETg%8y@uLz_J7m*Nd1d%LIDT|1w$1ZD zy)I&Ecd{E)#Vqz)qEEemJ}#=7}~FyMGQ7M z#M^ zAYxSk@`el>mGQArP+J7IBeaQyorSqX=`B1AZW>*lxmp~l71YDns!EF^Bg4p5_xXNW zx0-a&8(7dG?JLTVC4B??m63AIm+Zy8FY4q;8B>{`V9sydd`ZXad?RpuDBZ@y#K%L? z4E9X1HNav_zt)KYm-F0Jbkxf{_)R0q2{hli>M{FHigNy>m)tv$kciLWgQ4M4Kuo2k zmX_*eS(QhWnYLRUsEuJY@lCCE3sF>56q1UB!4wsTzz0CJ4^TFl&!{`gDy8SP`^Wj4 zDFAFuOg7k?57imEj6@(ft+oiiJUjB-y5pWKcmaa};r zv}@Bhu6^$c@mephY|Z?+{uf}5Yt9)C8VXie#A$e)~L?wQW?k0|OZvduU}M z>3nuV!N~u$__n)2!()NN(sIa=g9PSMYyX6!i5S*Lf=i@%867gX=o0xaI-UG%K~XY& zp|%zgN#-KZzgowhlYP&o9+NTSM{I-oufRr+%n3I=bJ#P+g5LvQ#zs5%He+`tx;x`! zoQ%^c*7UXYN7l)5%3L`MR|zz;H=e?8}@$XXeycZ8Rh#3+MrlWVMS5a0c2;73ztYzFwy@a0$ldb3z}^* zYgI~(O%~UNBCbnVN=bK7C`<%De5wEzA4)JN;3Y*RD6o4SxVME^3eqM7Qr4XJE-r>F zG-2*_y6U9`2FuHZ_x2pU%mG@N)QfgAO)1i8u@%+5P5HWa}BXi+a z6r}aStXoswvFXBU`G$LQ0NWg_7O#=aaid8XRaK8Cg#KZhM~cAKh5@m4^>93sMJW^& zc3eOR+hY}BB0e$?X2+h zr-e;lsKgt89OAcd0hfyT_IYA@$+0k#bQY7sD{JGrFQ-voI8eS5-Ga%+@n@%pucf=Y z=Yy9R!>=qnIMM^?xHdM3v>;ylZYMY?Ez>Rc`Y&Hp?4#e2UkHhR;0Dz{q+kvQFA_fK zYzJsnWLQ4t4NmLCiBhp=+|<-r)=y`g>UId8sy2%I{7R5K_)V@hA3z9hxkLR5XD(wp zu2FAcGuG(Y=IRf2o}x(1?3b07I~3kk62n)-$S_E04qYFIu)wO70LiJVkCxe;Eld}+ zWNe;gMt3al^HqRAIDy=wuG8sIp>>%#yi@iZ69q;KKTAJ;M)9k9oH=~3RcaE>)JC680*+_Niq<*cjaty*bNwVOM4v7%r=3B7q zmE^4Imbkdg-VU%Krr-0D5|@_2mrP3U&fbgVyIc(sh&wtyBzZ*{94mNPnw3?Qm8CT4 z&auf;B?YPM3QbTRZN+H7UXlgJ@;L&NIOAX)gNE={Bh-BJ*G%0lIC@jfWi1W7eOfje zpOaB{MJ}%J;c^(mWr9|vJ(G6T6YlpS`U|{>O)y3rkv;doTm-|a_%uDrni{RnJL%^) zp7*Z0JVMQEdB`hT7$s(FYw8e)7IHSnfmcS=r0?giyTF$t&kq>4Mv?d1LJB_k@UHG#Qj-a_?_G@N%R!?5MSe$aL~luOu%94Jdh`%XrK(V7Keb!A;h)??q#UE7NrtEBHhi9y@_&nzcAoe(_mn#Qul{)%~MiG~%3}x|KeVJ8F1v{QaAFA{aP@ zy=9zp4>5Ln`?Fga^S4|2i$a%Wui$O8RDo~_gS`gN0WtC0LTQ+|cTZHwnSQT+=Y%rj z>8QB0e+qUv>}nnw;=_I_m`qHL18E&VU51MmYP!2Sx)K!99;J(DHHCyO7|AN!Kszi) z8~ofH>R}p@&b+ua)#m~?gxmOe)oXC(^se4dS4xzlhJmQr_l&CG%m?(xv!7S&+K?Ezv z=n$7D^W!%*EjCdw2^TnB%GSgL;->5SSm;>SL1zN4mQS|p4pc{sF`@)qx-dV3NaTfA z-k6t_P*jO_nL~bi-BqN%5ibZ8Kmi9s+$B+|rOZyL!HKac0`(RCX+q}&s_lofY7F;EVlp=%kH=Giz3Msr5x+NM|C4g4Px_K9_m3fKNmEr3dq#%@rs^r8CnT;FkzYHP>4l; zfPXrEzepiz$dLA0^DdRf#ANF0#fNl}aDI>dicy`o8na=@a*%@dhF(jV-G|Bs|G~GN z*&YNikUl7CCHBQjgFfV~kginwBg5pvQ^i%|29U~B|2(s39B&#ZB(PHcoEabd&RD8^ zEh1g7-GooIg`fRJW^lp)cjltC%lZqvYatX|Bv9B~JU++ttvgAHgQMSA*r^tXiR3ziN(Na6w@k-gx>j48*we@RdN1x~( zT#dK=2gISr-%UCFosZ`)1oj`?kH&I7wmh`pLi>VtKl&Lh({#SsCvtNZ^%j0EEMZV? z4GR)p;m5|qvl^{`KT!tz@@x$3gW$L-tbvCIDxn71Y)@ATHX7v>7WOwZHlBE*0^e)HSB%O}Ofu7y`BKu79TJiflG)i= zd=r)6Mh@B&+pV{XHMzzoOR5e<1WCc5mA>J`Z&W@!5vfX`o>IX!O7pV7uuB8}FtH&F zE1xy9>TTF@;>D;(`y{h%VEocyxv~N_(_zjpv!BHQ#Rmt)z51aC zCMG5kytBV`-wqGQ^KY}5(po`Q^w{VK#`BMt6*?;PI+VDo7jAO{9pCT6sF|25?beTG z>O69^s#6%V@idBp`@fJF@EQ`enb=jM8j>5i1}9f zD^&pppMpYN#I`!JJHI{*~MXY3pG`hFU7F@{P{5m z&2PbKXB$F({E&^~?*HviO0WKQP6bSKZW5V`Pl-r9e=2i@j~EJtL^0_c)8k_NQeh1AQS&tQpM*vO*&dj+bH*6lkOG zS?MB=G9_Uz85MDDC~&h^>;mHbB29yRaTc3cSTjH6yb6|pu#;U(4(lH<{N_$L5{AWJ zO*6&F2s$r?+L#%63Gb>dz!L;K!bPtpkt#~s#5hEooGx5GB2E#(yNf42k9>%Se-B26 z49=osTz4FH)f7WR>+-51ku)Ukfh$n@uG&_VmwU;jt+Pxn4gR@GIdSF)nbgvPLZ;RR z=@0CXA}xG_^LTDB_$@uI>i9~d``U}j8+L20-u};Cw%onR;`RHj!ZF%mx|al%a>V2{ zWjAnANbo>{9#=L_fR4}QDmbZyoUGg8LCFcok#5}3yYY-{F4}b3ACwpU_3JLHVRxUI zeUjyeFSo#G7w&o#BZKI`wwk`P&rgK_B`cv0xCDj25JG7HNt!Wgm#4yY6XhqdREkf2 zno{j+W;9a$mtKV3WlWT5luWm83b_b>G5ta=Kq^$c-Mq?bgsl3I@X(Mm{vjpTfaHv= z4$eOEMWM00Sp=ETtL%4XTOSVOLNa9^tywb)r;f*~f=KU3s&&)t~4jr!+w*MCLwN6)=9T4|op#l1UY?#0Qcz_!-2LZ^g6h7B7_jjqrE7dXctsWr zi6pXY8vM}n#o22%!C-mfh5aM(P6YyjkZyKu;t!12MHJagM-#n#?qXtg=V)7DH^x}UnULcj%v9is*;-f-Nmf`_qq+Xo zYaTs|zfITx2uHTlF<|HpB%`agdXV1Z8-bbC3!mW;5_0Vy1CmbVTHWJ+CBzlj2`;*x zoDcF-WhSwScx2?2mSWz++@44eQAq#pTOk0|3ClZ{*MQ%Ym|QiDRx2$OB_%CQCz8mZ zQR?YUlJ;tcmRP{W80bWh@=DrMbzRcO{SPE_G1iJHpLK?eDg=s`ur z3+UOvQ4J8GurFZza_RGDz(4Lgm!Z^iZ-R&RRDpOT`t9kHk1KsNCLSH+wj|y0x~U*` zM2zOwh~hGcy1ud55zDREpO-D!)vX7n{w8W`H8tPZwI>)nd6MoH)!XsJ*!VuAHepc& z2k#;ttq!x8@6H5Rfh=9DWsy%$7Ej$-@jt)ZR?PMSP3!2-pOrM2Ed`Xwt8qcJx=MQS z=ZHI|bdOvQs-cwSrrY@u57?)J1acWxoHTU5-Yp!WM+;I8`b32C>?0~i*~_KD(u%|Q zX=BmY0KZ)z@>ure8jx6_ei8Ktvz*BsFP2Af*6T5?Mq&WpB6mkrR8n#oFxg48g|78) z&I78MfxMwG8ky{Lm*lNoI4wy7E=5nxz0eruSn#bD*CGSJf-KnN+Eg6?gaKYJU<2k( z1I_Yq?^I1qjitx(g#$@@B+&$`^m5V3jW`|=FAiX-9gtVwwyKLCCVKPl(&z0Tk)`&EW52nK_&(o! zT;*!2q2U2WU3WO;2p6Rvl0QdvyvtCFA{>#NmP2qSy71kBMN}FZ8j#tZ9$)k*!0Z;b z##ilaXaxj035YVY5n$;~p}_*66(At+*^DfatlHCk z1}~el>JeE(^|2y*4kKaryFJlFC;Npy$bN*;!sqBfDuCAPOZC&^%6<>bs8AHgDHyeq zeb`5`w7s>nzl7lLAI-72xI%0Y(!lZEBuUqx94Ih=HV7zC0DJA&G1a1SZ3Y$?*kMF| z+~a2)5Nf3L2oT4T)_72DA0%<@uJ(n!11}Qn7&^SF3iPQjFI zOre1p@rjdt6_oMEiXuG|8>5&ps;cw@G|LM^N-&<-W{S!8Nz~FZRG`u@7Cy#tE`y+a zeP<^hkSMTP?a2}cclX?2?i;()3r}?@o-bA%iS6?^!?p9tiVzhn0^f$O4-#&!dr{d9w& zl+@7?zYsiuxIDI6Q6G-Gb?+QVe(fuT_7qQos%ne$ z>3d(_|IaloE-67bTl@N=!@on%ip>XjLvhptPCiZx4uBsIwm8Md#4xk6a&d93EXsX$ zMHfHLS{wl8qrR43>68L@CM^L_plHkQY;5pFt3T>axtMWqGL0b+%==e;Huc;h77@sm zYH!BE2(#tJ!HRrGyk;Utt@8ueowzbJ3P2>Y2NIX4MddqFOy5Q2b_GBAC`^E#^> zQFg>h9e6+dXcx2kB_y16cWL>&%)E$`Q=X}uW93c#*%6x4p=S=9o4#~VAFCmmOXqTB zOOCa=fj$Orox&#P$_0<3j#Q(<;-YT_5IoY#X0RMc*Jb`g3;?gRZ7&GyHk$NDiZ@!{ zUq)-fEDm;-!{Z^*IQ1X7LAiE?X87SU&v<^dxAx+n(Z%hsSyt1IvBB=;Y-5XsBp?jvpYDyj_&2lU!k76XjE@CdmHqWq2r)z0y0-r^HfeH6lhwud~=q((Tug&2H zO%8Teib_g8>0-eniSuyXTr6B1AQ!80Dv8C%$Hg7HTb6^^_#Nj3B`L^zHau5TYgAp; zHrQVMh`s8xkx?z_G%ywwo|lv3LlO<>f__~F!h;{)H$I&ywZpCiIHOF&j829J=QaX+ zhLT)f$Xy|JvPwUUgi3?sD%Y3owRMw|4^lM9-}J|%pV z6J5c;mHF_-Idj6Zvi|!V^dGp8Cmh~%v8+*pVn&4z>wW!(1Y?sG0?LCD6RWByZHdy`xnDu@jzaPK`$PV>QUEXBe`&BN z<41<1Q$KO!L2%~@Q4tA|shS{=DJ02J>_Bg|xf#tayt}>0uFu=bfBk5t>ok9XY%BUpiuU8Oawlyq9c{E8EVrCj=fjTW3skO7k;za znm?dRQt*t^*1i=$>fKo$t``#My>@B5ptZYuBd@x8n_X&+ruKYm`~%EkUsjt5RrSzN znO3|QK*O($41nfmrct5k^!gq+QmQagE-k$dceva-R!pG+P6Vag-`I-%gS(w{Fr(vJ zHh&s5?}t*6s-E87?M*(-v+KhZ-{#i$K_-bj-!JkyPR1BxygX9TGP}`u^(u4N4;Oef6+(6Iny)rn2H`xW)pl4;c(VeU>@91Its(W6m{rP^SuJXW4CNGbB zKadv$k+=pfj`G~gs0X(RnM?-s?62<~I=4Ed)ng;fz~=~4dFJ7eM*?esymK|Rv^3j* zq9&J+fWe^O+gEsmnE`3v|AGAMm(!q6v~Vfz<>4{m{Dy^UA_a2vNQ1N*N^&c?vh#iCq@p4Q}?nT9*z?N{9tR` zk{gGq7k;rY7kd`p+g(}g?P|l~^qvf}U=ZtohHr!^bfjnJ;P^E)-siSwM?Vqtq_-p} zjx`R(!)#E=si$xD)WM;vi4z-zb21c?hx@$WvuOM_S*I3dV{3!--PRF4cL42B8fMo~ ziXOspLViSTZs8D3M(SkMj`n7=?VgU@OB?~QX-HFlg$d~A;DN{b{QNxATsu8+!rXL^ zxISHY)0~X@MV)B6=P*Hlb(Z6-Y;A2dH30|$rR@Jwi+%3HaHsvJP>}w;qD`G_YHN!O z4>u{Yyc}-h=;l^sarAN%Vw&si*jeh^?5+>zC#yMv*nbif;NUa`1O%u2t=jt2uAH*q zbdOg3M9;M}E%8I>7b19P((B*iS~djE%OoJ1{P0uPAHi4m3VMH^#xg7eq|4V#zFD(L z;6{B_co@g4Aj$zZ>SNEmpy22Hni@s&*C$$;NH6V)X^0KX-6yM-eEaj4)kOp#+W!9j zYogb@xUYaos7zfA0cOAi)5W??++>Au3Ec6)tUsF!{O1YZEs#yKXPm8Bd}J^mr6?u= zHo3Y#-}62y&DD&J<-UPY1*)d*mG=a*0N`B!`p5z+Vs|PZn=PGg1>$Gp+e>xUHxG89 zRYmvC>Je!-P}gK>zHpx4l5yznwgFF$2^$B;85l75MTCd14&~YX0AuqVNvG)PUBDO{ z4u`{FzG>VD?rc;QWlfc5zrpL?{W|)S3SU=}u>@81c)ys1b9LmRksG3lG;*Y^kXkrE zF^6e4O)ZV>jxbC>ZqD7-BjLHdP)QJtvlJ|W;OFuQgKB;k-|qSI=R;q;Iu@9mk4K{odU23`kcF+It+Vst+ENV*d=AEv58GxG65GHY4BEi&dnX{5;jjD17NgXt zi#MDHzkJ`@ll@A?8?5aW>5(`HcG!f3gaSi6c-Fyz_>J1lKyh|-cxbHdlj(>zNCBCH zo2_@&H(Huea|iB`vqR21hcuf(QnW7PU$K>+MX%Uf=~~9@Ov>gG0^Mta!vL3BTOI{k zoSSp=3JUi?$wP!vJQMiHa1uz!nsr7 zRFgWoF^~D?$MU2jRTIJWNV@H*-!We4>$x%0>_rq+CI(qsS=HH=P)!1g90h@wwcBxq zL6h!f|7qJM2Cv|P1IVcCg|`%xtDfScK zCL&1^u*voBrehUHUi-xhS9c3mhHekhkA0G5qzfMk2~msUJe?%NOFn%z5C)^I(NIy+ zcmMSRWMm%SlST*1Q2b;AnqGeB3$J}o)-@A3@8>4uo<|^B4wgBU62Q$XS0VTNDIuO-whb--%z7Vi7S8Cn->ym^Wh}Dr?@(baCfv5h7 zg-!0{Cx8rYoWPlf%H)e}7G+)BX(JAK{+9RI)8>mtgjIfZ+D&OSI-(6UllRMYO&rcH zEPWgQePM7zb&&@KaxJ%|grYpiEEe$eL4byEP6N-%lFBxJAFqz7pNPCTb%D9^ngZ`r z;DFX*6@NmoobAgS=$%tlGi4aAG?u^Jy~hvxQwuJSaC=Yvx)0j}4{wQW`v#}NOJ!b4 zzL6DP27~u)WyLpWTA3cNgbo5I zWM)d&r~Bz|KbQ{(Bp4# zgbr_XlbH=cR~RjcQ;OFSZVJfP(vaLf@C;@oRo`l$JBwZ@x%lMmqQOO&BT_M~2)GsX zC$#nACuxPE)we#3!2(N5ujWH&0%z}{&x4wY6Mr&0nl9<@Y4)G>1(+{cS25sUm1d;~ zpL;V<=;?JPJySQBvD;K%e=DUk0Hig0USwIA&)#(p@~cP~qwnk+lg779c8^5P(McuZ zNprZ|4QW>uH-=MX?(5yT((xgv;nLNVF*zy=3ZZk%PkEQZN(fe^?`sqfrpTNLX; z52R27`U?|Eu#;mIsqidnw;?c27NeP|qtjLO**qJ$Q2kF3*iAq7eccFTtky!0k_jmJ z+#)$_Y|BIwcXr1^GIHU4bFA|2ib?rWEi5NMIUcPmCwg_{{34C&x zg|jn4TYIg3@027Cgy?rGY;H7ap1pfcj0yrW$eiXsBDjKcIfO5?bg?lo6wAH&Ni)00 zSd>MqREMH?bB{!WCcSv4!Z$Sd*i&Y7;l-F`5gZP|;dG~O(;5d4-sS(uq{P^7Xo%oi zU5=B$zyWgsao9dQND?|8ZUZXadLUImx?DV+#NxQdH#H3on;BA~7L$b6DHu?#Z;MOMm6#ULWOe%X_xN zUjvJ*9B#3N)|qb96%SUtNG#Vm$-Bi{{a5Z~V@U0oVB;7CLKdje8L?RQz`qhRufDlV z4fKCioWa>xGBEiD(KHU{9vC#Ii-cJN22@@U*6k?krat03R3s z+d_ze3upFR0+KgAT3rAO&wiBgSBqy36JRyEv1rkk_?9I$VAY{B#8SwThg7C3;E5H0`@~oezG( z6YEb{lmXqWIrtc1CHq$4e?5brpLxYUW$^5J=}A-b29NXqr{1U8!V$czMz0gg&(jlw zR{wmB+>ykYW3V3C$t7CwJ&w=S{%J=2+XU!c()wS*KE8pVav%5c?BC{ra#P^Hch#TQ nZ9hZCLLQ7!2Qwm954lTSAGkilBEAEo4ou_zLzMz$i|<>@1bf#_wifW%)L#P0{<8|5&aJaI@rL)2eUhYnHkh zz(J(g;1OV*Dh4F-4kOB%&NDn#1aJRzS`J;x%76F0IX_zK>3uKe(jzk}cC+|FJs((h zU5kXhclD8y+Q@p~Jzte!P)T-F;hg=`fx%Jsq2B!j9!bmIYPF+fI5jgRe%!bI2>GdE z^TR!9S)1R%;wWXxZJ&;1hTEU^XZSJkF*-c*%o~@fP*^OQO`SZQh_4pL1!239C$MA&_=ufPB3 z`qKwsQMbh=sg_H~ywJ4wIdI#VoO^xF%EU4>GB97^lv~?EjZ*=CTx+w!z8Zz};)wv# zKbMgTi2!H&K*nL~&B4uKo1vawGuZd-9^I0CJEp;M~mJ5p+z9(sx5~zMF+31)5_Zfx4-pmM+~R&d+dzU>kMv$c*9%0ELu%X*)5JWMQQtRHlOJzox{N?^J2{&6JV^QNM2@<$`J+jb zN{Yh5j?ee!EzPe=xr941wH$}1w6-?a^}XjdG^VEFC>q4?$RDwJ()`rexA;O+ljv1&02PT<}xXFDV{b^v+(lG(w zA)~U;4*%iZMTX0W7%M;jVTI%kCh2S2jRC@G8G~|ue*S2vM7xmy0XyqTq4oSvYDr$D z!GUAOl6^#Z67E>CO%Xz?r0YkmoI{J*3Ka`_>LBX@0#K9(As{RQ`f4VqU-d^UGV@_X51K z9&RFMkk8J5G*5BdSK5Cz3K_F*kM>d^yf!20hrs3PMD*6DcMGh+{C!4Le|*aS=OR}a3C;8D!WQ^+oR1~3%XF%r z3jQ1BNK~&1C9xsz)#G^2aXWd3zq}1&z>cw%K~hwG6t}7<7Plmi1)zrTDcS63zOk5a z6(vKjogBmc^*2b6kkFs(Hj4oY^^dvJaAC;cD&ee>H{0n@_HiT9n3PQaMT z7x1%7YbP7)>zav4weLw!6NNbceMSvS+UrkQTH5d4&1&K&7e5}xe;)MMzflQMUu#5) z1AftG23JCY7ktH^+%)KSW&R@Deak!X9~AG^HT2armc~nwX31ZAKZ$FXXNvo#Ko7L! zk^cMWo7CHmj@y8`)ZmLkq#F!cva<5>ayAaT_SaND{%xd>+7|m#UaVW~lv+`uJqFSq zeJcFwuC;8*$8P?QuR`r3YK^~-nl(Mfz{q>=R$B|TN7~a;oG2+TcR+o;PV}PY{oh7{ zcYPLRX!~YI^^Sf4Y|-aL+>fZ6M0IwBxwQZDT@i4!h$W<12RVAa?Aka$k&Bq%MfTsB z7vFu5Lafx8t5<(~iZmNy{3NbiOFS-1fe84l>7U|2A>ImW5YX`lk=Jc+*2&>D8aL`= z5b^)Hh<7?K9_o#jw}OI##$FLczN|Evo1v94NY7TnlhAv;8{3hSV}=64ucwpKg6Pk8 zvqaSYwdZSLRaMo4z$OU-k)FONe&-Zn{L<%^sk__Gq4DTCPWf61VGZED5%~`gk+`Q= z%Uj)7gNQ(&O@K-p`c5?-wmlp))lSRk=-jt039rTpR_Ckux(xBZvGaV>~%_rwI6UxGTje{Cm23$Uy zG9Y5Ubld6M?g@M@w7o%OsNL`@ygpw=6a>JdXN^a}h%LYK{>4%8jN3nwQvJ_-f7~NK zdj5A1KP%Q+45wm?r#elX&45F^8XH3-e)_X>42V`1+kxfeBUn`du=DJ@7xc2_TV>6c|W`HgFVUcbr{rDKkN2S zAdlsU&{++S#YnoK*`IG9V3PxjPHXnf_pLXS4eR3%7_Yxjq}+1ywg&-f}y@s%0n&Z)l*?y)0y;G^{b}7u?ExIA3s3 z@!QTmSZWlGcAiwdlh*g{ubo+OyxP#3oS8X0m_j5qc6}B6XI=es^%+Hr-d`T|Qa(h> zP^5@jj-)!Yh1)-@_#8&JoHtTV1Lax#zZFw7MdCw!|8lYroB;OS%>K^qkcCT z9z?GUn!N@$8MC~ve~N{;?#$BB&lo&hY`#iU5!|5Lq84ckN%1vU0snVs zTPp)u)WhSX7u*rc<5>T8`SVh}?@g4Jp^xumUXq^2-Py=Kxv=}?8f6dJRK4L_RbzL} z>EKAx(tS8_KNP4my?L%QQFVK7B-xquaN28#{qkq+2d(llElmwv)t!-ym4`o_vz37N zL*RuBCguGw|6oA7QT}ss6|(Cz9%b>RqHHjF?9yJRy|$Onm&*`x*K0F2wX=&n+ppRf z#1^}xqWQSedRJvWSQ0sAOHMBA%EHW?!eb-tdXb(^wgpfpvguz>e^95q+Y;wh8p;qp zYz@WtNKDv2p#S3gTV}=W zy-^zo#a2u`y$HEJ6GmRs3H(KMcBl^wGw~ z!24<{InwLus@AQRueNqyUj7<56FrVo5uf6HwR(_k#7TyplyEr7Yq$NCIu&kiekGax z=N13Trw{5k6d8CDL;|qECX)!K5&VK)!MT zB(+`7lln%B{BBr_YPt_jgIe9+Ue!OG)wKsc9Z75Zb!*&N(t$z5{t9ZW2N*J>%z{3CD%zQ@cruKyWuA; zhvi>ykyQllFP~A|Hmw}q3|<~NwA~zlvkffs1!I0D`wzrZ7BI>I@yz%KYBKf{ZOXVHy?!s4qphpz5JD8=qPM;Iwb4O%uA-f_D2?$;|Y z6LIJ`FO&jatA?X(NAs*%ej+!pIKLC{=GKSykO_F}chA*;6+^G?&NxcBHaU>>tvR&1 zt#=avg22IA^xa8{W!BB713en=!#iw?q4cv$z%-iOpy8X$h5amut!f##@!?*50`t4Ys;c89D{P*6 zhn2GCW*V~RfN=fR<|bEhYU+G)2N;k81A}o&U-}0Ijy+HHn`pd5(J?S=K7Lf3nB;xM z!Czn0mS(jFt5#Xt|Ar@IlISX^PuHjuOw_Z$;sC;5#< zRXQ8sNWA-Rtv}>|Q&&}}!*_^6XfE93ewY`J$@e5L_SF&@(yRinK2d67Tt+oWeiJ_; z{|9dsjCMRA8#6F|`_}k_l2IA@k9!(2bd<+#Y10li|BK6MD`~iazyGxHoTINj?uR_{ zKYWnz|M0=*<)bU(N=TpY2&CiuwWt-o1|t9M=XvtGitM~JB&5by#PKB#U*6;UMzWJc^r88R47{g|)Uzo-D-+dxJisaw{oO)^ ze4|1VJ44vxAOHm;@zsa>$vBmrMhe5tE_{_#aiD!XPa%n2ztOBeHk`fHQw1Pj+UaYR zF>vZ8Z1Fi0TK^h&u_yR=ZvpT2=i|S9t)a;BJ?^h7{cv)Op)7t^W4BP}%jLn2JDkP; z5R51X3EkoOr0PNA&A~{9FbJzlU`{1^Qo@tpc6VN)!;^tBUuS)CI-!C)R$Si7k|(lX zGf_tBv!AY04K9w0_W-F$iFRv_&X(tthE^mo&n8GNfStS~zifs_H5RCj;L2_Up&wkU z-zrf5(J1~&d^mI;>RzR#YPbY@Z_ZhU7HE|(=V$rN*RPZj^ZSY55)u)Cbfo|4glN%y z!44cnhnBO=@jSzg&GqMGt{osza2b3Bq;MKbJlq4lL#cd-`%wJBfx+kl;54It#S2sx z>{cr8@{$bvj=G6VqfF%0Dx_1+7Pc_xA96sz-kJ>lwzozjvJ2sOl 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ΠCritAnhRUY_I5fi* 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 diff --git a/assets/screenshots/model-manager.png b/assets/screenshots/model-manager.png index 59cb9e89dc95460f6fede705b14c670a75a36c7d..8b7ba95a9b823048dd8caa58c19c49b5f8cdd7a3 100644 GIT binary patch literal 74507 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 Qzses9vZ^xgrJud}Z+fIob^rhX literal 72694 zcmcG$1yCGcyT(b3OmGVXceg+85C*ppJh($}cMD;F5JG?uAcF=7?(PuW-QC^YVNdei zyS3lmueP?f?oI(c1@!dvIj3KFo?lPM+c#3ENCZd-2neV$(&EYp2#8#l3e9?U;sJU zJIwMbyv3hd4t1ZWKTl8BIE>}ERHBLJSLIhB(?L41o<2397Zc?+3{)7uS+e}*hx@i@ z?EK0{c3+5ZgKwa^T5(?iC!r>T`_G#|fI`S`MTq}AJAC0^0|DDluXUe-jrdQNKmS1S z7Vi<*U}lAapC2Hj5@7TC={5z}kUe(61RIS1-*)S4tYfjAs%iT@xX9W_6x?DnQ=uy* zm5DCK&QtlW(pJ~bb5lt*DJjX;c+QhUXJMN?$ws^K%&ZFo>Ml6Hu#ntk(rxvR!S4@x zERPTt_46uS*jQLt1O(*7#B{6Hatj+6=;^PncM83xPV_4b{KFd>gwNfFQVYw=%O4yy z+y#BNhN%e%2z+n|pb&gQLN70`i;Q3r2`=AT*b-$Ba`N!jm)nmYEk-h4RA%MozQo1- z>gp;9Iop|F6%?%d^~<>=;lcJ#&W26o(UiN37X>W=}AvlASrog%Hm&NUmrhH zHIIUdaEZ4Wup>dB;IXIWx678;|E|(kD7aq-jsOoR7knup7Y- ze!=VO89z2RvsENq9EN|2*Px9 zblSs%YaqYpMHEIy;Z1N`w}LsWP0!iUljHsE`VImbva}8Ez1ATT3e_^mTTk2zt>_3Z+$N zcTG=UkCRq9Iyq5LP|&~HIGD1svZG_k0ha!fq?}w&JdfS_`ntHJq&H z8?V;m$8t4#;v?rNe|HnlW5fQ>pnjeE z(SBlW(VkXZoSe7M6W86tqoXZ5>pJHxW$W5(I6SPch*~a2x9$}Y2FB0ybTD|UODWme zY;OB?LSE;WS65ThQxve-+4g*$YR9f&>L^+-RaI3j^fFt!gDUqUBdAgHWU=i;fxdvp z@pm}9`k!z8{rzgbzI}ZPv~Lo4J&tiIhMJ8&w7x4SDA2C3o-T3ODYM|1o)LJHEKKP; zPRP^m1J<*@`IC*l_`9)%ecP zN{2VeK~D%a2DGN82JIZ}Vt-By^6c3&Vj)k}Cg{lbXksFwZ&6X^14(^mr3Z7hDw;~g z22CHw$16~Gcsk=F>)de)KSnH5_4Fddc*LN-LN=Zm`bkG)@=}!#J?{92miYvukuEi2IF7Ub^Vju>jkZ~Y<@QZ4=n(J$N^1S^E zz7x&iZgNVB=G4@rq`J-CJD$p_%gfo>Su2ggn%Y|AnPgNXCMG6cw|yN6i8egrb~2c4 zAncOmyl=pd7#kZK4^N=qh6vg@I$D*LMRzCRXU2fj4&i5q^->kos^%`dIIR9i67u2UoSd9V z>+{Y?N;NgL{QNwu<(0KC7OGN3kL(Ei=w55yuZ|}FY{pkw_jmT9AR{YE%SXJ+s~8`r zjZ~yjgnz+^6ZCL&adB~UbmYOS$;eor9?J!z($s|4Wg@#c^}DXF?)PtwG|4cEs4jMM zDpr!VT(V!hUAiRb!@&{u6dDCO{XIPb9@{)#0$yDS1FZOk1#Kc;H+r76EX1(kWHY3wyWo7qQIu;t;^vN*j`cuA`sH-18d%PP6 z=7tI@M4X~0;s0FLZXSZtq);sEY`Q`+3fm0^#>Yf!#I*baO)AFE>AznUN9O7QV8zwX(wDw4Rrm+8lySYduq=+tkyjd4d{{ z!fxDtdVL+V(h+VV0}WR#kz0N2vc_giiaLB?Z|j}y%P^{aJk?4{LfG7NV?Jw>tn zf`T{RF;#vKzVO7+l6PhqX3e^j0o^&WEBBH(Na<;5PsmLy_Dtd$gj08-_u`y0UIE8bv1@ zzHyWu98iBZaC7d$`zY_q8Sd>a&jyc z`V_2PqY4W4J25F`sIdHBzY=iGi;g}!|3G}>cYn1t^3MNt1O{ngdODxq{bM3Da|??r z&h_lTHiVFZr;o+W2kA{p>WZ72o9pW9nVAqVLRvv$S*Z5X@IDy%@#^Ae9~3K}#8VF^ zZeJW7c?+h6WS4es8-s$NjMMnDD z{EFz3r-|w^QKrM;PwY2g=kmHlS2gLE))Pch_ZKz)(_dbJJ??IKGi>TgRZNc3A?)y+T^r~iKpl11OnrGZJ~IUmN|HS4|msLJD8Z^ zD=W($g7@2MRt-1zwYRso5#YZo#g0$(<($vx1b2Jkzw0MWBl3#(XX~9d&Jzz0i$H8q z%e_6{pQmiNI8PL~AQj~GTk-}cTYYsydNw-2lc!bgIg~2F$2YanpD5sadl^L=2}xO9 zHDR{dtEzg67CbUPpLEHjq%Ea=>XMi@q~FlHdgLA%PPuwU&+(EyEhjfOwqMdlckY6a zhefOEA4<9wv5n2Rl3Q-@oHH-c+>aUV7gL z!(Ti#3de+cKhj_Svf4&z_Yy2Z7Tp?7=T3~JpGe=BIG!xSV})U=YHHLpAD@L|d=B&B z_Za^5{rd(aB_d)*&O3H>byd*wbaT4g$|BpM#X88-!z=zr_azn%!lB(qm5JT4#+3bU zpFhh=Nj-Np&X)tx3xta1Oi@wu(9iR`Q>D+z#WOi<7tmgyp*6T4QGin(8_UnmzCz|v z3Z%pN4E9t|2@D6iLL4BTlQ~|44RO#tr<6@dV>v>R2#(HQZ!sL$8t>#Q;exJP{(l1}AAGVW}{EQzCxY=HP34ciq$-WBiRJZATy}*|h(R$pKM#jub)NkDF%;kbQDkb;xgLnZ5 z7B%hqL`AK6R`JZCnuvyezZ0VOf%-h&&xz zHoZY3Ua0U|NO}@1HO=>_QCud(bF*~|vm&*TvQS<__;v?hj?oHUe^%YZ-SS02er<1T ze8|C>fZ2QdmQ61k-QV;OZSwGh`V#7ha-aRTM}1-d0|nh6^2PZjLQbt4|Cr+VcjV?-k<ua&js?Gd(9Or+Zgn7G3*s zNhv$ARIMYwK=Xt5hV%`r1FRY+S9w0)2nYr1(5@ zh!@7_p6GTbYwzTQ9o`}L#fQIph>w;LoBZ@HW-q;sTI1tD=!JoaHG79ul3t_lTDmFb zlAl?9uRT78YuU~_{(z*rW7EwRuQQi&_IN{9Qcm}*fmCWp%8#th$xYg0qZmF;==(#A z_}N{itwtkOQBO;DDSQJ9E{EgM4VjQMA}Nt7FR#If6s$rlG=lTRq~5o>?O%v3c(yBz zgZTvnz9{sqGrx1*o=E$10H@(Kt%o9NGCumIp{c+(8eP(gS1Z$MEU}crtR6cvrdqy} zScf-P94}2xA>=#$Vz^AFFG-;k=)JyoCWxe0yw;mVm}6?umfPEQNXW}cl9aGd;>$H* z@rAd(4P|BGKNwAGO43Su?4;1^nHivvdT9^6^L<@iW@PeHwy(HbYccPt9>u8Zzk%y% z^bl|xnV6ckrJsm?P1Cj6+wJM;CYf&xdqz+E_;-;|Yc_RLysEb^LO=i!$MQ8tUsXlb{()%Qx{ z9bSnAqe?-tb8_I??=plGm1hYhr4$vVG!8bKd(*~3r^ER1+!=&vEGsU&O>5Yp zox|PJR`VK4nBj^tKLCkwgUb~YtX3ryc^?HHpXA?e}AH#CkY z>uPoxsf9Ksr2Z;1Is>J&Bl_+X{D{KzolLRpdvAH_DgacA2Sk1Ol*d{y7pIv?D$v*RF6}Vj&@h-vcGeVZFn5x;_^IQM$%|~+mo`f6p`*(@68#1Gb)=q$ zZ-YL|YEB6p=~!57VL@QujE3s3w{v7!Vi`F&>IJn{iMyH&ieAKNqtG#RiZ~kRYg^4+ zhs6`_?Dz>?%SlOftY&jyLfM~$dgH_-o*kd%&dTBS3!&i&t=seJHcXf_*vOcaED-pq zE1Vs*JYP*_Phxn-6B4UA$#Kr zFYn0;+$d4*?#h@rdT3_17WDUj-HnB}NKTW(g2Kv7dAM<0Zz|MOSJQI3KX(}V9lO_o zVN#1;Q;H1Nj*CZphbj)?YGDsH@^ha>_XC#j%uv$qlNwk!2xtZ6hNlKGRN=c!e zPuPHF&}5L3idjx%)Qg@86F&NUV)V75iCX1oim`KDyVUtCEoaAp35sKe|r_$ zv$FK!DeUe2j>b_j+e76sArVP(VzkG}HnpoUB@`0gakRGZb>!`YK`CLN3aBkxmh7W4 z`-luI^7C`WsJ>~%#hY?R{a}J-r8M}b{t{0cs`;Y%esM9yZUHC6tZzk$PIXC-J+ODf z(ew>CcizOr$vr8L7x;psh_(5&g;Cv~kEZ|?wT)&1tBpzt zF`-&o(@g4NmxH7$@3$P6<_E4@l;$SivSL7rmIw&9Uw~*S4SI`XGiH_811`9oHuYy^ zQ`2huk9MDtP*J|j2h&<9d2&8eP+;EbR~s8m|1(<(s5XT0n9X+H@o{lLz_ZL@EY3Vu zMiSO1O=kgR0u1B4T*r1??y>*Rv|L6dJSRP~<16p@rHXajC;JQ4V;W*S+~XV~vmHN` zvn?&R!%$JFuw)c;6UAwa7aW!y++lAiYa`oorpnKx^4LhiH~icQKY8XBYD^4f73APR zp8Dz3df%*b`G}=eBjeWivh6p`VZb74YRr7Z>TeAQ#<(~kPamJ-Qe!||(})svJBav- z3Ttv4v-%F zabM!%yu=}c3DPL04ZpAPyp!)^!hl|RRHGoaSe(8hLhBfvSg1Ln-F<@xg#@=mcH#WF zfCNF|ivi_skz&%^&lFcU&K|PI zr3+t4jM#5{*lZs|Kh1PS_sj6a&iH=Ej+EwP=XN02yJn!(_P#PfBum7FVJN`A5?fnt z6Nsm-(n`R^{>*JGKI`|bZv8iL*SAwQ1JujamR2?jzPJbL!c7iki~&tW<%H$-N6N%P z8NK~p9%ate_H!u)h|LF^hyrA3B8pz_qjR^uNQ@nd5~|ElvAg_yrMr@MG)4nuh+XZ)c#O%eB&ok zdy@GClHyZaDN;pPGU#@d^h62+s<7L>5YW%bCF46N2}u|7v$f)35Ipr?p1-fmxIfq% zM|X>Q`uI@=Ei?7h@6OJH8JDMzQ&JlCZ{bnIdwaxLcb10-PCmHRVaY(M`FyvXQeA!3 zJjEfbf71^aNN!mI>o_ZqP6|@b=-ab#!eg^gZhUex;{cPMEcRngHnB8sv&k`tq?4erAB1p}#FBW4v96)=&y z2PX1yv(`?b8+5laH<)mhu^F4e{>Q+kjR9FsD`2JL&%qRVDLEmjXL@oxkx ztB^7>m|6c(9A5{rm-p(TqQtXjMq8TrE=O4S?6jSicIm<2<>UARde(%Id_MSmi>lriN`%Teh4%LU z3DPN}8v`g|C_J`P((WE1|T@@N_y~6#pdg%=<0f0j4Qw};PPN1^YafL z#tv7vI8aee_%go96>eJSWO+05s5(fLLdQyTrb5_mCTRodw^ykt4Q~X|ZSwPn&9S%4j-@-8=2F@aa(8>3wqki~ z3|atbY`>SK`XW>qb@WWT7Jp7vL5D?3wCx+@wVswI$J1@eLr||zhC9m2e(6Z+?tR&e zHuS*!`I!HpZ|Gx9vHjf82=&gfLBv(XOUP3Y#+O}o#EgehZ`bHMcXif7mhV0}ex~?# zhW0qQFx^<+Z(yTqrAP~RCmHRR)rh%QMMasoFw#!H)YG4n=4Jbf9MAq`m|s!d z69N_hVG;Y$|C57`LAAmD-z>oYTNBf$gnZi5(v=rfZE9y9NFfQlY|adBbJ4rh-? zef5vQT#d`zE;g{2cXl{lG0a&j(nQ@{9I)Qje)H*R9d#bdQ6o(=M?ko=+g8)91JZuT zcVKOHTG#z`$QwS+H)xf;)vgVHz&<%zp+zBOBO(`1c`GPXzdEK%nRY)vKR>rM*wjSM z_V*zmumc219HeJ6Z^$rQ59W21m9g-zMEoo*_v<`Z^?tRrx0{)p6HhjhhQ~(QKlU&3 zxj8Q@D>G~fmN^Iu4ejagA0B**XM44sTL^5DhWl$PSVUm;RRUjWAah_Y1}0{)`_b}# zFW?qFROtZ?UEgmHc(IF%Z?!clJx4=UhTO4tCpIx9lnGMzl;5$G%4eb znityp^W`(ZE$!-JquZSQN-V&{gm`M!0GJEX(cGHOoc#Q(Kaa%|_cPS9Nn;h2k$-o- z#c85emX~{bd(lbx91j;oVT1o>)wkhA>dns&4JiT98<=Zg;G4LEf`f0at|X+Sz!$St zne;Msg=t&sCjB6zKY`6SVW#TpWL-^FwNtKn>gP`|z@RRqfQ{#A-fgSt zy|HDf=;<2T0-iu~%p}A2n3%aLhx+PjnfY=7aG7{qU*1SCL=zAZ0g6Fz!fQWWE;gK4 z$c)4Kow@l2gGeKwA+UjoE$AUDr{WY+X!rXov9Pf4U07Hwi!MW9ulId7r?!B$zWzdb zPfTwdS8jFs)bOyZcWYlfk75F^!_K&k4ohXx&qW)DVsUApWlxgIWYRN+zY-Rtr6nXk zy*}G9?TO*$l)g`Q`2sAOZ`5)ux+pAkOm%(-4XyJp88sxu1@HH34+?bZulslw-gcU7 zk(B5))VV#}uPel(pq%2d>eYE|uq?5}m6SO6884|=G42!_cYGz>XaEk-8#Epoel0y) zKFs@5_%uYgOPn3#f>gSCpBuBg>$Bxr^}KgWdwW90?Y$)> z?6AS@vD`HUpevFJc$NjV)i_>R#_~A;8H|+2_Ar7xmQ{b{YV)DCnoG3qgs#)x7Pii(OgJTHKYDlbG6E!&o~e8d}q2>i&I3Y!2#)Hn{W3jdTx z=eciSZ>79$R=c7oC@Ih%9HrL_CD~LNxajEKFTUP^bC@@HoJczS10i3+`wToxzA3(# zn1>UwA6mG`@yH>di$7ncXz1?+}*uB02725kQ5)U zt)iR%>(qBslDjr9&w8gKKf^2otS~9a)y>TSTuA%290zG_dd!N3h9*~|5EJrLo<>Dc z5q%~-H@C-x9SmY86%w#i+2K@J7Q?GDz;&{*w$4(`>7WV+U|6H{z-!2VIi_-Qp=#Rk zkxBcNM(GU=4dvx$x6hE5jaJqa^0PyT-D%z)osNx-!sX2xeeY)HI>OyZV`Jhns)WGm zec|IxTHerLIF>UOj7F^0=<5T5-O)-%vS3K7s}K^p0Kie!N&T#^m!20^&u3d$eIa^Yq~@!o18C^%5J#@S-~J3YWaCglK`#N&RrC>P5bDg6t0fYFQ^4UKm65nj2a z6$Se@VT6A3m3CLhYaWGqYwK&D&R;x*r2P6tMVed)n5-*rUr*2Lt&z;4#L0_9CR|2? zj;}s97b2dglK`RN;1Ij)qlQXLNIbilhyZD&ISgP|c#x;zq$27nDlHXM)YRlK;OxIT z;x#He*^G$5zzPBBlSQY>e&yN)Huz6`3P@lRcJl_s@2u`7?f{hmI2T9?tQD3&Qz5G; zOD3f6kAVE{6`xtpIJ0(ztth0tvNAY0_&K7hk`#z~(!aB<&W}XWr65c8yuj`@Dh5Wu zTDg*v($?nRM+pxSJg*={37DC82*6SUiSJ|VTMJJ1kkQG>te;W)QdzH}Wyglcb8_;q z27>+?npi?(qr0p2lh&@R9RP(KlmimXA0#q4TXFM2>KS-;@9@82DE>QCIn3iStEOz0Ctls^RILNJ{O3OhWnuG>Xxppej9drjBO4cqc_1iEn^7l*qbQ~)fLl{)!~`d^-Z`t+%=;W|e# zD1vXfW3yV|Uv=G1;{Y`ZI}1zy$cRc+;$L9VFnX*rtFf~3q61k?5CsW-dopkX&>t*p z>|}tR`SrwJWF-r~D8E3i1SMio0m%Bb)nO`wlarHG10yq)9rKq**hM0)%p)D2ND+R% z1N@=?_><`9Xcc8;KxzVKllc67t76PYvYF}Wgao2wT9JqNmdOgA+Qh`f%-D^eq5*CP zQ+o#oB0krrjpT^%rdw0F*z34ggvQ~zf3QXkRlJ*7bBEnW2%c%^+snKc4nspjpt}$y z1j(LJqhNJy9XQXvH+z-5L}=tDHa0#x;o8;Je3+P+pltZ91xlrXB(9y)Ee=8+TXBfZ zbQ!&n5G5t$$!YdT909>FrL0?t{ZcbP6I2OM$vKTyKXrtY?(FQSWRL2j5d$yX=X7%j zM4Lcko7pNhuqzvz!~N|u5)yr3-&RO8VTgSWK>3Q$VP zuWuv#S?~&aR^?dn|8HC-VD0`5UZjMr59niH6N71ZNkqitlQuIvd<-%W7`n(vOqEOp zwIZdzo&$uO)$U+(Gb~uNs2SruKZ8tPBdK^6god5e*EK_H&ebd@g_;o)XeNF20IsrcDbjT=XGe&;M@OD zi5ZE*6LlJ0!z43pW@;of;l8(CanvC+{A$A^QXqdx@P=97fH0AXUiXI)$@uh3^U zkmLhEKp`*Jfgi$7YqE`ti=m+G-QKo@kb@cvR5t3&Ju^K!AS*xjyK3w1mi?>rn`-^5 z8r)@z>iSLs6-56Jyrv=TI{+HmO^lB#B%j|e5A^gf^6+R-prqZmi&LHs{7`V(0f^|I zzlNyKegS-uv^eZ7AWTb4<)*AF{v*y<)Gpw*&+l<;B56hgmu_FOm&Hl1v|Gs2ZxkkH z6a6!P00b`3yz9%;EG^WlR@PDWK3Dd+P|)vj`aVw-pi_(R-xG!Uq`dY&v$6(TTEza#q@g2${&@aB z$j#7#d6*3pYCDj?_k>(rMLp>sL#VX$C-GNWaaxd+@fh5YAye0V{`SD0H6lUx!@ZeG z^8v)_sw!X%7^dh|JMyuz9;{|B?C$Maba%6J46Zf1&|a~}GEs6w^{fGX7ZlAnczC7n zxInRmzqKVuV)u0;VQ0dQiiQRkuTjW*b1{ja*+%)~571mI>T8}oX4 z>^uzbfNI$^GPAQa@&gnqrY0u4v(=@35BIJWu3yuL@KLVUnd3om-_qP%yh`UTU|^B~ zSRpnHudC}~TU&5Ny?_562$EafMVOg%Yt+5YyTVAU{_Qlv5+GZ4NXQv%F^;d zBdM_W&){F^rb8;;>O^*Op=j z*vZmG2u{swyi}2-o!XpWU40 z7GyUm2V+=T8p*-5l=MW&Fy70`{+*MM3mVp|;~04oF`t$YY??R8Y)`zpbMnW=hq3m! zIGO0^Fy2u83+Mdr;qLrRN5TGh=G}j{1kzL(3-yect{>}Vn`RzSa-@I8evEKw<*EHQ zpox3CZi&JTN#=Lro+4 z`}eAv8lytsr3jKJraB2HHv+CbQNRt2fO9j`=LU!!JD`jT4W}!_2HD8YZXi}uQ{?ut z<<{fm+2bZ2s|Le=RLy#S=;<%m-(DW=D`JG>=_<#=f3&u@g&aiVeQ=McCwffI*)cNG z(P6&ct0^H72=d)zg-fk7tu^KY#%*m$v?SpHj>F!X#c=nrara z3(}VP1AU1+ia@+*KgE|qBW2^@iJJ0& zLLUc0HH(d&ohxVq7PrnXmV)DnE{l#^r#8Dk!Vtc5cQDbnE*wO$XXGHntOMWMknMvs zRewCsL;qauyC+0wQt3lrEUvuoKfh$$bPmeR%?%CRNlr0j=K(fI<3E9eMT1BC`+oyS zG`N$ZcxrcJKt(wzlMFUqpqrbTYGi9`Xl~BR8n%2SmsxgWh=AbvOT%Rd@RMyh%ygX{ zNq`D)*%^n&#m%Et6Jug7Eic!&=8L#SF;K0ZV=Ykg@$rFPw+7rOqGhS2s|%!_|G{}u z!UluA-2QeNfE)VuEiN%pA#DiUb3o0O+WUsvdh&Jpkn7&`*x=wH(CK_1?j)U@LVy2! zJrhakR8lHt8<-&IGCVV5wfm0es2Bs>+Kn+Z*4JK;!SwzcRNdYoRL|F{e?OE83NCQ15{vlWc120U3D@#(^nWzh zdtCtB)O+hVeRnqxpTjIqr@ACPz4~8G9v-vKkH|=e+t#DmIwHUxxZe)b1HL}|NoK*+ zS)*dCdB<1c$NpqM4KnfqJt-)dU1?rs=I7514wCswp#jx+dwYCzRC+=DW$N&Ipq>;L zE6snJ+j^Roo2z}cB&q3ERU5ugYF-%-5D*uq^@mVhk&6@mV=4StCdYs>Fff2oZ9cFy z{ru$%M3B&VZ(Hq|VT3dlDk^G-VCOEl%WG?E3$)lTdQt@0V}JJijWYOwP|(Un3ZKIq z*x~ZHp<`21*#>F7E)P8_KO?%f2?)RhE)$0QZR=XwS;9?@zCT6~{-&qP3e-u-?(3TL zx;h})XJ=$cE?Y79zkaK!nO&7sUS5Hu_>^60_YLh2l0?HcE>2Fmtan(CI_3WQ%*9jI z&mwZU5TU#-a|E%=VKcKkysKm48ki5nk5}L{O^)6i$oeyHl@K z{nE|k$ocz+EFYsXtz3i`%Y@%=epQP21n-A2gm{g75Yn~I<&jUm-<$iW_U78SZ?szQ zJ}GNC_9Zh`VNHX90j*-ur6fr#>uU&pHob0~xzLfd8DTK3-OsHj?q&p|$n)yUs07p1Dg%w*H|>X{ z>*>eiJW(8V882i+=Y}rXkLqKlM@yaZj21X;kr=UT1-a*p+(oX-kXdJ{Ze`TtvP~7n z`Vw}K5zkdp3{dAsE9d$O>d#6tSk3SK6-4;M#HE>RcUy$bQO7?sSZD1n{n4>Jrrtlm zHMD2Cw^|H@gXU=!+&#&$kD4V8S|I+9lf`v!y>Ld$p3$f=6`S*4Xhau;LdcC>(yv;a zSu)fN6&)b-_u>bpX}Z&sk6e!Qdu8J*?7nSAzHkdvFZL+?zGD1Z0!%pcVCR-Wq3G4Iz6T8p-%2I%Z0 zA$)|nXhU8Pk;REE7j@s6t`GTBdIz|(S8ZF-H zGfR`oOEK5n{d>F9*W4`7Pj6_xaH~(9h#&v{y<$(4MAlFR-nF07yy`-`T4uL9`u)+j z@@W~rE7HP4_k?8QMnX8(N${3IEsMM6-WNKS98h_1RX7z}eG0BF&n3D+9ah=*)va4J zJ>zZk{T7V~-5i%wmsUrGcB%%{^tb(n#%s;>R!1mfY7Q1PjSaRa2eja!97yS3cUT?G z(2nz$*(IXNb4DX+?#1e}(wpb(>|ZO`xx1)}09GZe=-1#S1@=e7OB80m>e zZ)<2NI8V6FwRYveBAt_u0tXq?k;~4h=J+R@;=J!BwZx!mKd)(;m#8LEX{>L`hpJw2 zy0>YX1JNRfJ`zigU?5Y~C^?6k{R+&KgJ%=2&;CD&b=&IJZxI6zXL=vqUm(9@CJHH4 zQ7mlsFMAlg2t^LsDX=%OMfIDRWVsoCFDc=)8{dA$f`~P6SUEmi8z_Pz!IC87&T4uU2HCUe|dJDcO>XsqhX?mB) zz;|s@inpd9tl>nuKE5AkVDu{khT*tfSks&2L0M|KSN|Awjl_?7s?rnA>B2DN^y$2~ zs>B5y2}PA|UaUMaPyXAXd&mfK#iqwt{s^Llk!~25%Es|k9`4uEsTaObaG|B_NN^}v z>N2{8mHImP+>D*(M5oO+iad1Ybme&aX`fBBmh_zD%`uPaPn5mTzf4bWZ<(DgJ2rz2 zR&PXa)H9)u(s^*@>j*Ox*s)q{-Uw(cV)IDH28q4@^@#FZVdc>Giw{YL)&6>BERV6* z5$|js`82sESMyCS^r_&!f=|b8la{P_T}aLFoer*k$qOi?-0^Zlg&{V4Sc78O?=!=C zmo;qgm5N%tZ#OS&r%=*EZKOMTL_UcSu11Zz2fmzwEoTUGIGrwYWMRffrp$?Tb#ddY z@?$jG79`%+1r1>V_H>msYPaRCK`1QAe%#qQ9|ps|#06KofR%N*Q`2$f;{C`|dm%}A zde!9DbxEpeU7+N9JsYS4CG@=%>^%!sTBW_a_oJE!W%}2f;jwuZPs$tqQLFzkejf;* zJ{iu~!RLacly<#5v3B<4>=2%a|20@S-YNd&epl%&NQ@jcJlzD$-7)!#K~_ zPu#I`g`&59w>2bPd;;}W5p^riJXc8zLOCBNGrB)q1%1K8aQLXMXUA&D=lv**?z&f; z8k1KLcxL9U+Dnqmrphqif_FWJ2C8|hzK=rhx_KzHU)!5){;P*LNeUJjVm+QRcS%;7eUSkGHzauo=d z|NY!co2%l)MDN>tk6|Bvs#??jC%>8dUYPrTvjB7lneiJ*8nA{OF-T;{{qg_%hz9H`Y+s6N^-S&%d?L4a(l?eDjWk3h|>Q}|WpHpEO<^Gb0 z0_*1#|8CBk<*1tZdxr9cXbynsEBOkYI~Nr=(rX{n8J63hOZ40;AFlVr$&AN=1QDnW zG6QRO`~X$7vEmVL!l?_wrDC?#8h6FXG~dBMxV6 z0%L7rFvj-kk^Xlc^oh)eBnD#$iTq)?Nz`?!0y6h4L?aXkxj; z*wo?;QVP=L<2Y11WP``k^aCBPKDH>z&GnAKw3BeTdE7W+sAf;IN65sL}7AK&$0u4GIO2RGitH+Qi3#WEAOr9_EtD z(QJy6j!EIEc26B3`NTGh23a35y3NZ`jfWG%)S^L0FTciSmUG2aeX)f7nULDHRpzZ4 z#rB{~jq|tC;+)cAS=aQ`c3oL!D=f&MAR#e9h=E;}k@-(7l~KCh0CqUp{H25iHhy@# zh1j_e+Oy0+(9dznVO|sRWx>>|eBnv1C|Mp5fzA_=0++FgRp) zNG^WVq7_{D_7J$`+rmE5_jv^{3|Zd}S8!t_r!w`TLsUMe7e`Zgij>UG>QS|zs4iph zhYr3AjkXngS*p5Tc?znV)8kWxG?v6&E^(>LYW@AG7pKi4-u0c>KWn*iM#>4VAa0F8 zP1vVRZtbzd3<_M|D{2TSVO8FuopS2(N@8w$bhqE5)#q{G`Xc>MVy|o7#(Ajr)yLSE z`X4N{_%D1e&n$N1gFrSE(;wUOQJ%diYNCDrDd{-U;=nJ&awJ^XJnM~xSVvthpJ^De zh*Wf*3)`U^+v4#vjgedm5moycX{6R)nwP?m;hO~Z;v*1D5 zizb-%Qm7p3<~1l0>ZkG_-l>!ynRCFxcBZRplk4v8L+|DGZn)fzS$?UGmpc}ktJ__t z`dxlYIkTDVVa-wJKbNDoLi15GPZty5977@3u`s?lmuh2|va{aUb62giNEn(PLQE9A zCuOxNS{N7ZE+j1&xb!HYkEO+UxEm5lbCU_Bw@k3k_qf<;+9PVJ{*FXQ;}ej(wBKp8 zB~KAD(i7~U%~uCAst66SbY8ltp*z@p>IvG>?78@fi-#lIg8;HcU_}bke}+1 zh70Q#&)6{)X;+HHa1j9A6zsgYI<1bDnR`&L8Vyk(_Fh6|!FrULE}vty_StXYJmfd| zFEQG&a);Ukobh+@Z;ZP&ZZ6@HdH%_4?n z%){J_NUoGjTGWd~Z_$khmik_KSJH$;Dx3$-dLGsXs=ptCGN|FHiMLeC270UiuOEx@ ztMXw173_a#_juxe;Zs&t8`bc#RTdd|q;{ou$S z4iJcqJDZ!{Um}DxAL1k)zIbD~ICP(C0_J`*cU}+B4TjB6msI@x9;_w`$zfnmtd}oe zVq+UynKRzyR8>`Vc0#a1U_x9R9IPxX8T5>duiiI3CiU_0+47YYuJYR02O62D0O?^h z8#}w_-L;FMVai8tV1iRqQ+IqNjhYm8?u_{M?c49)rOSkc3sri`%BktuGJjFBqR$k* zza+%Pne^(a253JPS5~??5l&S4uxOo@SGa~hn41BW*m(=<|6uMbpt?-geN|L22$7KP zl9Fyv8Yw}fLt45)S_MT)q@|@qy1S*Nq`SMj>pnPppEG;!+4r2g)-BiUwOliM*2w?= zeee7H@amJ(0CGGc%Ks`2=+<)kKSRfmj%}=0KldVIdsb5^jJ( z;72sk^snG(c7LslA#0|oT&oO&F8_(8$>(f#!@X}25Z5QFwVp)1A-D>r z7vSq#Of1hwOX<~$r!6^214|rt0>BCLL*ozI*P!lHp#4na9(bp~-e)V&0V1S;KsBg% z@Rx`$mNp(eJ-x+vMMPB8eHJxPE)%-6tD7DyA~i%;&KK5&XF0GrmOe#*wS2c;H2%B9gGLij6R`kuGO3;lQk z3=weRIh~{EhAGwbco#Ys@nwq(3kN_FW+><8WmP>f@PHWg=H@0y)Z(TNc6MWV`aNNp zYT#7^0@Lbv7YD^F|7T}*Y3Wiu^dQK_1`Xk%ctOpH#&aPu2L7r5!)yF6?tb_QT{8~X zS6`W%2Msi~n~hS7HGyPEySMIuI;*Ycd@RFLBXFc6KJXP4kv1y6>l)8GgoY)Oyi^GHk}}i@onr9eQIsX%;sY)j8xj+ zWnf=z)F#fQ(>8g~lwx2IaW8&&f6wJmcmB+AVkh>%gx@PCCx^$OJ3r65$kBYk-WJKH zwKdrNWX)93KFq&82#;pKvqN1*Tc%M8+%9y=&e(t=s zrUaBdkrq+LP5MluN>u^peN%gxqSVx(_a%2oNa7A1|;R9xhx_cpSW=P_IRvFs@T4_jp}q z6RF|XJ$_rn@wg?HZ~0uS@P$Ixhu8b}XS+SJ%1*rz-`|~HTirW9JL&1!7#to3YsanI zS$SHR*bYooREQ)PF0qmEO73tf9|-_qRd|D5U^XC5UuBVq+eM3WWQ4u)^g%nf{4h~96 zO8N%lEF3JI?w>6TP4I}^Y3Tjmq77F#+9)Z75B966szDD898TjsJvNlfelulu?Ciea zPt?w@p9dX#s=(6o+2m9mUiF#%GhKXpp$JwP-Ne)g6$b|n!Nng(J0rY&XJ=;(9Z7?0 zbH{}y&ikuf{r%@>2NUqt$3}%|PC zri+PLZf-6E10Hl2cvwkxH{?zx)^2TWU8W#HA|vzKf6HEz1oJyuUL%HkowF^oa*1LC zy--%cs_P9+IB~A~5lMN=#>U8|MU&+op6uklj2;IQ7`*L+oCxgF9XY-F@r95@(( z;oCF#B{Wpu&=C9neW1t7?N$_7565oZtw;Ri+s`i9$41%9m%8?(S+~`maz{c?eRafl z&lijdJu%@S(VmrkF)1fa!2(Wm+PTU+_UjmGyvz@c3+tBsC(JRDSXo(TM?3G0GQkbH zEHDgQHD&P8I>MC;DO#nB8cB&5uKVxNf&v5UX11U$;OKNUDkhk|IsfN4A&F-UFXVuy zw+=-JZLHG4Vr#mgbuH{UHHhrt zL)`fm6Qz8c)4YV81BM6PjN!NC!P5z)Q3VCx?jd;=nha2ARrw_!>=Nf)ix4J9sqCD* zZy9OtR9I)sXkh_1mdQynK0ZEhqrrO&LlTH7kzc+Ldsb;ykN5T6XtnVTR8&x?=yCQ+ zy4}U3h*Vpy(-obMk7`WvhqOgh< zC@%l(*{Rz6swrf3*4G)R7^^3DZh%k*US0w=V_QiRNgJCx?*+SJQfT12A{3NqJFwnSC%3hS95i zsFbdX=CzrZ;^r$XFFzT|H{=;N)#F%7O_A-HX4Kdot~#^Wvvojq#h4^o$QHObUg@mP z890^El$GtQ`{9K|;^>$c91IpqS#a65B#ON|?N{s4j#tY+&m-e-;0rE*%I* zw%jqI_lc~@UkuR3r!F;ola30&=bE0I13}0UEHNX+J!pbpV?yRfzbsCxwaGyufotAu zJvayNhVz>dylJG<9>5EjdTm$DF}&AeJCWlqowe zbb)w8ZQqt$L>oqzkC!z}2=#@px=3r)-~qg2g^eZ%517OHDBS43qOu2y6$}gvRB?q= zRdJouQ@IMEI7-$}nN92BolhWt9mRXfF@h6|=@Kt>S}5p(+bh$#5* zcQ#5<6L$CZ+S}R?zq}PD9U94Y^K!KzhZuR+k}YNM(%RbC3e3utZZnNXcNXU6T9D#l zNM^ZM*Orr;xLs^M78w&76BQK|7q_vnFtD-+ND6K_e=LT`2M$c1TJ%22$=!>IXls*t zB6RnrE|}TtIF02j&Q{0Y=I;z#o+PF;U=^L8Ps_;Qt%$+7B^1Y6yT2{xN^nlW?^AN< z77`xjs%;8IkH*^OBD2$-8Q1XD>nnUq^(8j@#dl-qmz`@@_H zXN^+FN{Wf>MW_4uPQN_-cg~I$;-FvcL#2SIsAyQ&nc4jWoZ*oXWMpjKX6Hw%V-M(J zhVrx3OXXj@=qqNyxJ|*&UzPK@^Uo192h~uLpBO__N zthc^SD~5>2xW`GiioydHRyH@b7=3)bB_uAGn2QPuAT@v$MZ(SP1ipDN!mK*K8sl#A z+uhB}>t0-Z<-dgs?mQNj=g)17H@gzwzI}^e6eCRjEoI_fv{o!!r)D2N+_^h5GZSzf z@j_F@aqZX+CSNGrq@kvU&cD%7N1NQXm4R&db1T9V0dv+n+(p|mFE25tp)1WZzX@86F-+A^~&k;o+f=&vpT8V|Z&7e)FJL z;P~m$VA|rO{Vw-zE8|uDWPQNv5QS2{?N!HxN6>C$I?Kv#zx~>mj*cvm)HyWhhoqgo zJu@UTMn>{&ta0)1n*4BjipRb;ixX*SfdPdW&F%cC>ElPFT9Vo}V$VoTRsc;Gdjl5? zntmo`X0-;+Z|Xa=Cx+Hfx{$!9O-@A-9v)6XNgf%cM(hb)DjuKk;o}A9IuCW6*SWy% zyFOm2rmk*%%qne(**n@+p|ql-gdx~mS4YOd!NJJb+0dsyd3h4YvF1+9X|fDCIM?#; zekBvT?*9pw?IFGYllW)P;>MOL+Z(A?wJ@+D8sm1lh3Igw5zA4D7Dd9y7$B2!X&h84 zgIhbGQ4{)Z*N!1A{R){cCfW|*-IN6X~iR96%}cKwAw^xXG@FG zbdrR*xw$g(b5=Gx+xe0*H=BLag6eAb?6p1ctK6rQl9Ccv&$rL~(72KvmyrQ^I>UUM zJZN2IsMkQcb*ry8`XN0%0WPjJ#BFYTxRa$(ZeVVpsiNZD2Y)E2$f5-U;Oog6H=dEX z3D<>t1g`xP6Iv2R1%qihQ*?(ewL}3I%H;;_=}Kz=R|Sz^G#)DrjtvdXZ@1x5(X86A z6lSsH;m+xwo1KHNBr!2@1w0^}8IZwoI32W#;j$U$-q*&sch72dFt=(6kY9T{{cR$w zSbpg{sHnv`Il@RVsl0h}g|2Rx%_I^i9f|6p^hpmyRA!cqt{+BVy1t8y?7TI7BSvOJ z?IQJg3Y@ZQrfbpB(Ew+_DSg8$C!$spY`S$oER2roOjNnX@VbdQ9oKmEJD@Z`qhP>I zGDg|+wc>o0Ar*FZN%JIiD2gNv#x%uZRFsp`%r{sAc7&IgHwO6;p5h$Bu!=?{z3Nc9A%*Upq&aeDKRz4- zn}?fQ=LNk=UPu!-{xYh{d#ac3`P|!vqo&7D%Ft#IaMMtsO-f|sa0`d+p6w0C{f&w2 zbe_)se#L^xhbJ$rtgvmYt(TW$uM=@Go6NUK1XF>%ZSzQ@knPeVT8V3IHH5bHA+GvD zji=EdpD|iMOH~nzz%@*q96m0vy08u}bqZWWi<83}C*9u0oSz4_8U`p*)h4Mx!Y6!^ zo|)z51*yxaHfzGba@ z`?u@p>+9dR(Eu)Pe)n8;liE#Ba0o0_`U87H817CdAT|gna~7p`y_Jnln$B%`P~f^H#TzPs^@m( zjjf2@9DWb!hwNZ4wBa)SbmBn4_=0Mu_m%5QOZSrCIZLb+bJ!SPn0oTqJ}dVCLvjsCG7k3Fvj9SP_y zmb`!DQUzfS!MgXsDN>YAB?a8a$-likV{v3IRVtK?;~y(_pQt)JIp2x9`1L9U;FL6h zSn@OKQb)&kyf9Zb=m7V&HkwOD!`0QYln&er^ctxO6zAusrh0d}SGwlo;sW!AsX*hJ z4q3nBl)cMNXJ+Q?;o<8;o3AU9rgou0`!F&R@^}WTX4=|QhHJ)~z4^dwq=Q}ke+A%k*)F2(D?WXiw&7T#23A}6MUzgg zO=~|nz^ynm0wE82t*Ys*8CBYJk#g6AyGbDxyf7Q? zY@atjex#3Lr~Rauaa_3!v?oGpTwe{kTHhwh0?x`%lJ|Yc#bTuu{zm%PUI;-=NF(Mk@k=Xc&WUWAF&oQ!@#G2Q4~kNk-oGTt z<-+f3>dA?Ar41=az~#bkr-^)5AAi@9{H}3#J%d{=3r*^W)|M8iB{nymon2UfJP-zQ z&-!(zqnZJ^V1@=e+X`l8CJuHc_r7s^uBqu?D;3TgN-J6Af+M-H^hEClv$r_@%feE}QWO0C=GI`S zYJ&tDYt6Z>y`>{BVbmCu;6mMVGLn2=UY-U0-oyo=lz0iN;X1yf6P+82U6W_d2O1@o@s*Va2$VYBnQ0fK&@1!gNp9TK zOB|=d?y<48^>rCaS}1_U!@-#lcWiAr*d)E@t?&>da?tMYUVzZ2$wA`eV2VtZe-RRT zPY_O744<_8{QQK3gwQ@x1XmAdl?df~0G&1X#+sX{pHOh(o5R@!(MF{Bylra)R|H@N z09hR!?_iJ6F)-4H_d2QKCW5{bw@%})m~dGmWQ+yZCf5A>8}Eg1Oa=1k=M!5xCXitmRy)zTKZlvezBtmY_efNK{`oH85x<_xC|jce{63jyze0|WUv<* zYj4iUDR{)f2A?#9s%pvyv-lX;l~OcD;S`2I#`; zOJf$>2cZ9agy^l^fo)3C=wW4A+Si;%0@Yuk@3wXB=IQpGu*A6B)596r023muk9?rb zxNXm-esBI>pOge_F}uZZp6lr2de8c#`sHO{4zi+8xSS8x{L3FW%q{o*`0;Mw zB4z8~_(pI~PmhO_Q@vuJ1Lq)grUQ+kp`!~;{*SvYuj5=_Bk_!k)P(Ztp`oGDiV8Yr z=52U^f!nLJTdfn9wQz$G(%d`?=5=3RN%)-(IGz_1ki;E*g zwSN=&wQFk!O^E3C(S-zs@bML)*os2E%yw_N?~4r+Ob%LZrMtgsg>=-y3lf5Yg0nTt zvFs?*^75>gds96gz_T&@w`XH-SaZB!q`yD1QT+Lf7nN2s++=#i(c?|!&@;&kMM|TXlNeV z;rsRxJL%tCL5ON^%qq@Mt~x#0s4iA7_@191{FoT#THTIOE|he{-MR{;7i6sXm)?4L zE_@k?N=#aAYOU%I=OgI?fNB4*{!$*PS9w(MB zMOiEj#_jaZLScAUnIqb!EXP&j2Qibse*IV%KX2fDFwPGdrpUntMte#`b7gxf;!U}F zkq5&N)EE|x)mQXqVe~!{>I^eu-Kcb3TeHI zuayXK%s^|wOY-$ACwi!F)~q`#XiPAKdeFbGn}Yt3#I!VSbdBRzuFOQo0?j~Lg%4*b z=e3!a7^@Xp&((RM=I7_Z!xj`A#MWp6wsPl_zQF^_?j#8~Xf~c@CME`#l^t8!p}XKh z*6NGY{MP-Z+~S)zZvq1gzx4H!K^-MWPqnzm#>V!$FB_J0oDjzFnP3ICBz64|xj)0u z$Q04W^zdNu?@zEQ#Ps7&Vrbjn8i?D zvd2i5Y`a`wARuy1{7;XGPfvFOAj11jD1o+gN#wb!>zS7O*~WB3Nq>KsW7*ElaYyc$ z^{J`AST`!ZvrqZ?EMea>GYN=@;FOLHYdo|b3P*|uR0??~$lr{W+NjBBY8KoiAc&bw zn%&;ctM?QJCf@TiGz9z#B)f6r28YG?C=^f-r$8+Y2v~5;%EW!UmGv$%D&oM{74}2i z3P*qV@F!Hk!NvQ;3KcZ~&dZ7lUTmfCx2Q10xOUf@6I2@HZG7->U3?<;2?-Yne+5-s z55f4a{3m_RQU0=n@S$J4KIL3+ld-ie03~XXok`^Ra~Vw;Rw|T$IA)Px;h@@anJ%>+*wO($43@MI za$43vh|{8q5ISkC1H%XG-7hNl_tU}B9gvNx2=rxvW+s4Kb{?vc-riNg(f6M}Ka*}x zMIwPO(89t(mD6l(*e)$C~mjVr1(88 zh%~L1M3g$}2u}9_v^zLzAFqC~pFTa!Fh4un+sAi{-&(J~EdmyCFfhl+W6A%Ur4v?29*YRJUSEO#p@e;b94l=QO-FIF;E$^G? z@3&{=d_90#USzg&7m2fZV;UquGqcLE)>fPHg`b$T#%bwCyyIV0Zv}kq>+gr%IQ;_y zQ7&8W0|Nv9ke5MQhHwh_ML07wHI$T^rgES_r9nglc)WLcjam=3j$k`S4NzF1Fh9V- zDg3Q4mzi2Z5z5cz=H|8vLvu)6=j9jr2ULfIHGYR;!wSdz0ei;WOc+J&92_op1l3JN zdviZmI;d|nU=nOL@NNg8?1#}5&=+sLP^(8=P!i*%A_p^tR;7H*Ip0kWWNSom+dZ@| zeA(bL*CNp({=;o=9Aspn!<=?n>QBq7vpU%l%*?{1smVukXe+bUrMbBaI=Y?GUmlS> zdbD|xIpMyrHCE#r@E?M)&Er1=$~C#=)GFoxQ(79|3AS9+^v&abmf!a`N*-6)kBX=!Hd&PRECbcPno3U)Ytn zDqcv%N)fU-*+Q~dQj#T1Sy}mT$S_XgVS3iL{u%>aswO0ojF1l>%2F2WK|2J06Bk$M z@G$&c;B)dg7TO6&sbpQ%0D@d%=(~E%I3yrh{0U4JqX4$SO37uSrG>&P21-g%NFA>9 zXTG{}g83Seh?7Begzm+_muCk_MTjH;^dk{%RJW{hEg1V5ABL)GX$4%aw;9ONxL?^x z0*PDrC8;8EOHJ^dFDeW?Tn9GbbnvVU4GKa(Yw$u-)wkG~oh@)V@@Wb%$;`l7+aF`8 zNAYlvezCug6kou4Q&9ZH3(SC~lD&sw{%bFju!GnIoF z6wx||g&BT#YrLDKKVRZL72LNB;l60y{jvQuIubuef7SFqQ=&pcQjY!%o`e zFicF+{rvo1&?-HortXMk12c7GLV{Q2He|R|xVQ)d!lS~=8@2r_cvYaaXS!Zuu&cLM z0TB@qSpDnQwBf{P31`$@;^X_6@tE?S_g_e}JEzE2OTeiG_pnXX*J5%vOAHA0D%j zBG-$x;)$^E(DyMYcW&L%&L1j3ij2)NcT`b^nomq7;jMbqPgvsi9zfC zz;2{-d5U-ov*UN!j|{8!JTQVCPk&RGmHtIx{`!pC%q&|~P3^ezL){cL##137A$Yc4 zasMGVV|`ctn?(Hj+T)8qAkDd$`s9x(ONED_byKji4TXHC#A-&FE^KkYOE5m?SX~l8 zK1py3KFUHSCJ52&QDY`q7#J8F*2r- zfT5O!Wv6NhzE0SBc6q#jX-!o01I*->cTK)lS!=>{qTCg7L8q>)@tiF3$IC}m$IIyl zL+S3Ue*!T#yvN7K+p6y%Aw5QtqYlBNp@ES$IXU1}fhD>(d8#TlHa2CjBjkcLm+}qU z;X+|mEqSFg+5l}zT%scHe~Z|S{gws>-@e-2^vKn&`!I!Hgd`#9N*x_jyiGT3S>KL(w0Lcszic%YxYtx}2X?w0UE$yM_GbmNlazAGS z$0C_-B6vSvR<|AFa+pUK7Y~3NMV^x;7e`7;8pP$C0Z@x}ZTE5pK&}1o;m-A#p=yh2 zP=@2D-hKQi4qyoG3LzqEEuC=g#R>S4+uQZGlO(=(dZCPa$kH=xADxDUDSAE|NoO}V zOyP}?B1T)Zb+WOsfnyU@;1v9-RH>%6w!2`V0cvrO_Mbt7=d;I;-+-Y8!ofh|&^yT( znHY*u(t?_M6wnl)Rpk=#B}6Y@&&XOnD9H&;(3X1)WKg~{8K+|cASTXjvea`)=~j0^ z5QNYC&&u@R#?M+@9(%Y%O!Y+?V05dxICq8;gVZH=`pTo7+!tN7YiQE$o0C^(usnJO zn~h8Xzf@05Y-Bn^uR7CXn z@ECl@*WPaKbP9;VLN^q!K7dxUYS-iY?fCe(`uupJ!Pg4J)E(OeWS3Vu*s(=L_AV|i zA|j5exHGN#TBI$K1SCm-*rP+>m<{{#8BDlu(Skxlk-4ptzJ8qqK_;R47Qpy_l7wA| zTM0>K0r&xI4G&+KUS{6B`pFZJ?O?W9HdMBGgHr=UN{;|SFc1h^{DV6Db}R$9S|&2S z%8U$FZf;x|TCWDcWX?x3TQk7hL9Z078?_i?+uq)Wr9B`j3g3qb3Hm<3UT0=(Y)`Td z)iK|{&G-JJ#TLmyD$}UvY3tKc^(^A#qN1D5v_*uTzc8ew31YaivL>SW@GkqUpv=R~ z+I+Yo_4}f>@zbCG;*^!(y|oUdXI^(D8h;Ku4RmO*7~rsKwc;O;?f4t?c)|k6 z8_sL<%T7~28j6Y(?U3#8Q4SX3r06QwJGpPaCoN%Sd}&~Ce)R4JBFgGU%GmQ1nbh=j zXnKSj7smUh#>U$y(p|kF!S1dpF3?Ev4L1DEW1Z};L9m9Uy9be&t+m^{;~$ z*QP0eU?74;tXn=joa$nKWGG{m4ljy=Lp}@Od|=CMc3q!-1EZ-*!br!&aND+iXa1Mb2B^XAP*EDo}KC%9=6_|Z2^$CJ1@jY z!(eY~Tb~AN0cip{4Re)21LEfwI66FLP&0tj0{IS)zsHJ@(7tz*i07~4?0zC1`_Z;h zUM7;QSjiUBea&q9kCC&%B(pimXf4HrUmx7Irf(_=B$Rwwn=&5@J!^4pP ztB#MIf*Gq8sTRg7PXq-8eI%d$D?WVf6#?ee?rzwU0Ny%|i4ryrj)NXnG?Uo%3YC0A z_-JupPeX$oQatputfEy1d(}-f&sN7U{F6ty=s!HlW+U@BXqKNR8nC0`m4pc=e@I(A&*0`W?DxzI-_epUjUs zGMJ@dUO-2`ufbjd{%hzU()(>j7DE~u8g6XTdMc?4hAU_#8!{;eGcrXcUlav9kl1%p z-UD3(j1TYk%hwQ4VRq(V1l@lE<@czFP~Bw)Z0}&-J51UzDk=&xPsO2ZAK&sX;0jba zAU|vlRADiciR3-1?EIPXVRN63OyY@^g5knSKJ9;~s1?$drK6xl18}62`hxc0!Qol| zM)l5NR&c9{``+zV;^Q5k1|0%q{xatSbL{W|B~w<`#^=-_qZPbQ2$>`3QZtWJWbO8B za|c30F`vABat9kX@{3ECJDipGY@r9SG|yVwG&p#{-k#J`P|yts+t;8c_xNHPx}VTGe+#aI~)yStu3ud!DjUiH|=N`1DRFH+xf zbD1s`&!@YHFByT4#bbBjgI##gf6EK?f8dfE9`3oR*7?{vE3eqW+FG^BrD3M2P*Ks> z{$xF{mxA5PqiF^f|2czd?1=_G+F#EMIarB3ff{$GRmuzrr;7UGW(Bqtr-!caU4S&x z@0)o8_2B$yKnn^X;;!}WFZF4FYXwR?g_Mt40w!}LHHAe)?`s-|*~ z8Qry?Qi?X9=jiIf^XD~qr7^>oZlb{{E^cE2Yg| zqTj}440_3wiHvM_EL^O#WHx_*`-d)XC$A2;EidU4bMf$$@Dc{Jn}Y!o1Vj1jH1OoC ze!iyiWcThD6{RLUW-vCUrKj*fekjiEJQX|_0@YVYFkT<#q^Fx0QbB+6=gx)J=9aq^ z!58S{q=8S9@47X@W-szRDiv%oEvv%P@;q5)u)bu3_EGB93Mx(gk0iK0LgY0orT zKoaSm;Ggu(?15|u{%k>W_4a;MgE;NOhvQ3?Lh>s{Mt;-N({5!c|7zUU&l&nluT2<)jLk(%^vA#Zf8X6o)32A9NOUqx~ zk)p(C;7ba3Iofu{IiOlcXcFO%BO-K4OUtXsOQ0j&?fsP<`~c5gPC>yB&Bxo@>SDdT zSHTH}-42a%s4vXcs6J22Y;S5(l2@rs_FIiMt$mL9?=YtG!8${3ZcFFINL>%u*tJ~u zUN|^(!b=OxCJNyx1tsN89^KChs7^iKYaUyF`%7(9@MCNw?*02L&i!;xIzZBa;yl?1 zW(pc6@7kBZJ6ep)duyaiNJ&}SS>ao7+@@eZvq(4eMj&p`q1r+;+D~Ah!YJmY%V(586Y=-9_yw zq1EiS4aQF63fqfaS9o@uTz%*e{;iVv*8(faEy%a?f^y z9@1A%Wo2{v`hd+z;z>|Y(t#5P4|$o>o^f00m!Cg>GFGcQEl!f;W=g6$OSH5oWo!6y z-v>E}%Wm1r?Y8NwzrEl01pn~LUqd0pFe}c?Wb+UF241I`Mmsu+f6=e2`Ph-hk!2+G ze_d$stWGv(lKkBZkVB;wr)p3V@bMh?JeJ^7Vq# z&7kMdrqnv;!+$=E3K)?vz{_<`*q?xBA3{k9;pR7alz;gKbuV_vxT&e76N>7jF$81z!*;NmYVJS)*KcCy)!gC^Hc3l&4vowfn1J=)0o50Vac2{a798di zRbx`4*B&vkF+F-zqp7CK(B0Elr&(NF3@#=#TZ4+$98+C}-P}k5!B!;2Ba^Y>=WWGq|;C|YfK zzq0^n$9zHt3|34`Y)d2N3VKNa*^DS&VA2t|IMo#v_MH4f`EAtXsC)%$Dlb;DFEoIW z86IYqbr`SlqO^Yks#gx`f#?19?c3K-i5g`P<>LMeI1gs; zOSXy2ASnf^fJMc`>Wt=c4tu9{7-49Qwh^G><{s|p*~u&y)zl=6krA+*eDexoHhK+2UyyMEOALGG+UTe1wJ$6e8yBp-Z1Rh{o}TrvrQl9?$}8jL#WpLuv-#DbSCE?r zqVTt@N+k_xzDJK9HMh2^m0Ih=4;4z=(z(0>rYx;W;UHY|a*K+Qf3}hHNZB0|28Dzin_xFb}5bky)65v_fSqy*r zmMgk1_tL;q$fL#s0ozN9)}V52JWXVz^>+3~$iFdBKY_anJ{>@{nO4g8@7t^&=FV{2 z%!{io|L>4yeKn^3F$qkAKm@j)=_G$SIV(G>t%Dt~Lq~EN1w}>Sp>qTalNtqkiJ6$R z0wfm_6zqyZtxPHz?CQFgZrl=-%*!9wpo4>lcXD_NoNKvhgoYR*2i+=kMf`zyN zTHt|c0~aX}*iyX_Wo1;5orQCl6Cbt{mX~}Nw=8?30$^h=BxGMH+g!bx$$Yeg%Vq%y z<-OQ1c(7M5PC$gJoSAufL83gDX_@=p!ntD)0*|gC z{MW8$wd}&TXfRAH??5f*^CbwC*g8E_(L4_jIA2tAS5q75nw-=SSRF2EXCa;>uJ&at z!UJp2NM!|Yu`^JA3E#>hJ78M z^!dwTUTtz&*+ZaSS$1MeBe(>cJNnuA&*ed%N=q}|nQzw|sjM$zFnT{ims{$vp~*>K zQB*{^xjFR&8JrIK-T%sMJVrOjD@pR~+(-krZf52^jB2;F;oj8ex#>4(73pMUo{A!6 z{ynpulC>@Yl?V9-9nrf*BOH^NNEV&UK^PcfcJ|h}1LQb3q=CKNr`E5dU`_a6=)@XS z;REN(m|;(L7chMrxN%)<;e26W$j%;o^~&#WDl9meRpiy+7Vq!4?5lQO{04x#VH;Bf zRZGC77HrdFv3&x;8_&Hr7xN7v4GF)L-68Xuob2tfeDi@3q%vOj^%q&qH16;3L*qHn zGxQo|yXR*ogL1Scv|wDggUzr@e>mN6$AmULG+hw{r?CnN)LXYI9X4VIDRp#pHPqQ3 zMM&M82}|B^Ai4FI>N8UO*78gymda37seYZ2DL#)u8&Loe zYLoIsCBLP5L6J&Y7E}DXgc+(Jp;{43ge>~B&V;7vqwfmFuC9E7A6xV^%k7cN*I+qL zyIQf6*31uKQISl0<;txQ|3S6?lzRa#9mifrdVq`j@N-M7=1A@feuobAlfHEL(s*_^ zcD|Nf6~%?##PQvP%1Q!fwTp~c>TOxW2tLG5^LU@#$)tCPQV zbP5&=OU~7|yI%iIk$Uj5IN;xi)U~lhwJ*6&6se8gb69gmK4-n*{WsTY=D)HKPtXnI z<&ndKgE=gQMhBZ)Iy>EucWGd4X*|h-TSvT*SI*rWmb<=xDO@w4?pBK792FDF_D}L{?Q{3vUShd| z)oo1L2Yv;30~Sf6;u58S)*y5&u5~d zH{T~LLw)S`@2~U=o1y(wQ;||p7>rm-vK-9JPoLdF@fs<2xLnfls$JmxaK;7Utm@)~ z1oBlRG{!n1qO@|U3IHs?S}b{I=f}Gr4umv<)I7B5<>ez|V=+>SkJ#DSnVG8sgM0{< z%X`7D3`WiJ^7814(|4WN;7Ii&;IZ%h-bJ5D4<;jw+aeCJS+Er>Bm{%ZUt8Y{p5Az% zBg4b7>7yxA?Q&^P%|)S`;(bIa&fCY((DLAqlzC>pN9)Yi;Ob4-sH3e-Bk~!v0{|gN z@v(%$ip0Smg}ZS7!E5}~*f^nqzH+&+C!pEH^O=KeG0b`Q{sJL0 z(cB{0g$qstn)XLa6T$N`paqs&p=`}kAIu}Cx({s`8EFrvQpo-TBv(TBc#|x?R+-)s zM6+^eaS(Pd5iCylS2o4Tf+UPzpI8Z_NRvSqNyPyN@r%M(5c2xU$&Hy!kkolFngaJy=6WLjF zU=!gZy%5=5a+?Pz_zd+z0@XG#K{eG^X0KTR{JEbn% zA$nD2#aGGl_k&{|MG}5(4tm9eOmRLj6zyg6HF`OBd&H>{s5TGrtjZBGU(>6xR8sh)(K4kVCKnq{Lc|=F)=C_%y$ne z?^F=M4~}ntaMfRy2tnP$bs!BJ85IdVGPtV5*@%N{K0(r`ZB zMP|VJCe?NK4zg=_{JTI_E%&PG>I*{mi%$NNYA6yJt#U1gQ&SMS#6{NE@v80ZW4UY$ zl$F24#ZACQ5;Q?bZNVNA-!lp=nXJ^Tbv3H@g5CiEjC9nN*0wP9Vvb~ar+UAAdv$*p zoSCs%g!^R!%hL1nUmAKC3@qWx#g?WgCQY^!ZJJYk9x{2L320tVv?uHy@Q z*^V(gkv3aMDg$+Ob&ZXbWHU?6J#auR`Qve{j}#xk@($O^N)bjM_2`%bqQOoJe7$W@ zk0T;*;4esMM906Ts<3V8K2+PcE? z@+b~-TL%X??P9~j4fRZ~UukY@E6B}l?PytAU4@1nWjaM6p{%Pdq=GNRvrx2c)=z4bg=mAt*oa_yp$;rt@i;(p^VC%f$87T+j zCke?^U%JokZb2wJ?bQqXn^#_$m^=^uj)_@N&*QC^M|0)PW8!Fjn{Op0(9C5AGg@>k zfK14P0x#zK@vCLlyCCUibv3bemn&~zqz2Fey>BO?4z&W43y;pf#;*sc2SQf3rK6+& z*RQ+$&g`&5&*ivVHjb-q=zBqdt&!F^Wi|G`3~S!N0sa06 zj-UVf`neZsd0AOnYP!X6!4k`jQPe0|#73imMu$lkp>x*#ZCL*GVi9qa~ z^Ou_lz74?oilp>F*Fm5tl~~gO0YNHFsyc%4t5-oS-zcg>g@vC1&IC&ASuy0LMZkIh zFdu56uzWGGv71y_nf>K<)E`&ih!CUc=;#19fKPz0tDEf=eWxo{AWjPfJnQO}PV`h9 zP2JtgT{B*wB!zwcT%evSC?nI~)kQ;0Tm#in@#}(D-b6%{79YStK?a0-tqxO_TU9fX zswzuq(Wl5Gy}VQ?J);Pkh9-iqU#SlfPw^XZSRJ{z#?Jydf=EdZ&0=H6#x$@Q)RB;p z5#p+L^Sb51U!(__-4znb{N&^td&G}uYL6nNHa*C-J_32NvP=)YB~@Hp{pyPjeB9|Z zAzDVm{2>s^!FdD5r7LgPOa|(kCSa=r!j~?vlUlL_@b{o*3u%n@>oHE z)%&T)u>1BVaiBrMCxj~>{Sv_P+TYh_4s!OZp}Y}?^{+AyuKa>b-qcpluU}|aY6j~) z8+5K-F&{61z;7!sjR_uSY~}73=is&p3Vsgv$9(5N7#g-afaPWs$OSZgB7}7zjwk!5 zGKrr*e;zqTR)S4?d}Qi5lg@W8VSWIe<<>508VhJXwX1 z$(fnD(;DHJSYk*1+gX0gtILt3v@09#N$KhN1sSFdKA0%``_Mk}xLvzW|EAPDxSY_U z+CTaE`2@%=uCJE`fB7PuoTr=-83}VeUEZzIMUg;=Hw*q)+udcoQUgYQE~cqrCnX1L z<9Rhz6$5>J5qZ+9SDvKEKuS|zD$eSMKh-PSn;s7C!v1Xpxdfw1=P0X{yj-F67|RU$0h z4^1;-I9@HMuPsf@jj_T%PjYDg{_f>5a+Naz0s`QWg>pGxq&vmM)!2{Tpd}XyE5 z2r%h~(h!IbLvRjWHmfiwdC~w9vcWfjOze}NdaF(;WVTm7`E@Hp2@|-{+*Tga z(i9dILOszeeO{Q4PhR*yENEgf5zHb|QW;t6Y*!vjNO&u5Z7t|td<>=<&rCGn4-}_k zcsQ-9j}BkY_Y*Q>a=9)XKgf~u@RS4d2Wb}QCVH2PUr1alZLOhhZj_mkF#Jrb>1K^h zQ*2}7G0&Ejdv#iYIktl`7EQNt;LQS2;C)OS zz3NltGBjT6wi1@vJQCI)*4QWt?$Iaxnc3MJYfDV5tQ8I$guV?<$E-0n#nw_YUu9m; zCYQqd3;uyD)k4^X%YEn0j)z+!pXT-W1eOPI>|S}ZnX?H(X?M4LlIwoPQ0{0h*qs{s(*S9nS^d_YMClMI}Tbm6bHC%HEN^N=nOU z8X)^@6US#2r;p<`X(<>qO)-H*hpSdx-nDh3_G{ z$geXFpX%?xVyBxy^;ng$Tfvplg`=H^NbOKe!uEv_FcIMu!Hm25i190=QNl7 z?G4YmI$O;b>)!7^WaU+J0GaOz2^dG}=qPZW;_PeXK6WfVC9_7?pP#^pfWFdF2}J`| zG7sRNuX~Dwzp=tFVaqdV{aDLj zVO?!Ca6I}y`9ZSn0rhL?$Zz7fe z>0zI%EX;o@(?p#5O)k=7>RGb;7(do3TpQoMO@(|2Y;{g9E(Tg!5)r2(gn*#PBZm(Q zuV@=dk{ltUF%v86_|{SNJ^js_-TE5I?-Us+jvP5UJ3EUPgD;gM;x6nrOYU5-Qc*!1 zu`UsUC{Z2Y;31rcJgyi-&&hR&hu0bt8$eK8U7Xx25bW>C&rH=YtMRihm#(K|sx8~7 z01Q0oog6|!D{ITM7h_)U5EE2NYJ&Mh7KCzp=r}}}xAxHc_r8?UHRSh&e z&FlMlg9wkCpAS4EQTXXebu6c|sVOS@1r(suzrSBdc-kvLpd+t2kXN<2`eSrl>j zfsY^6Hr6tNXN~TrUq62Qu7N=(V&Vr>d}wyLf^>)eBOve2nU}`J%K%%S&Z?0TkR90e z*_;D>iYtN7#GX^PZ&v_xR?Ize|@>F>4tA(?|k5t#7{Pyx&GJB>CvWm<68i)F>{q+8SKtHy%in&!W@{iz0zW)dWXou}WYhE(zvbwa)US|t z;Mtn>`1#NhK9!e)wy~@o(H9EFQB6-eHh>UF*7?>a-dmc(>gcr z{cvqe2^0bw>rbZg=v38a81M$ArcVC+d1hl<#k~Qo`YeX^)k|N*8l@a}Y6n-PcykYV zGUSS>X{_|izs%*C{4^iNop~Zw+ZOa*i9rNBa6oZ+Mm7{y zm#qD%9=-Z5=g~Z)HbcYV(*)pZ!qN5pQm(ntKJXL5bX3B7MWmsl%zEGC_cQwDhrRs%S zzdl(8y=>M_Rq~SWBP$Ey8S>BJDW0WmsCy7wX=I4yh9(9-HXFoJ>W>YToi*->6Z`9jtWKMak-QBWX6 zby{l`y_Hi`%=mCdwq<^L`UASjN*kd+7ME_`1bfF9lxfF}HCt_C%w&bHZlxNiKB#gTd2fX?t+v6 z;|DaUr3fG0xpO9>@7gJD?xwF_IfYNa1~OPO4tA0I_9+uSNos1c>{}sT5sX@0U7b*G z@6NY;myt2so-qt>-{fm*7~v#@G=WAK5OX7$Q&x6$Wf_Mk7~*4TtMRX133$uAKKn3w zuiUL$5#dtrlVfqXvji(|BP751+__JJkIDSOv4`sH&6-OBf?+ajv!ljsx zv#=D}T@8$m&TiB>o&?Mq&Y8oBi4XSgKLCn?)9k=OhlO!C2Qmy~J$qIeU*TU8A$n_i zDOR$ZrYy0=%A-<>UmYj%ZxHvHY{|0>}F>)c&VA zIg6dvg@zAM@IG4mTxXyA_>!`UX7ifX8n(dQpp%O~%2=La4P;XLj4jlp80%tQ99;Dp z!my)9?uu2{5D{w7!%+~!y^ZyY zyVdNYdC`K+G2)MqE(2D4{P=N+&jm(}0xJ%FuGY4;0iCtlhK4gZV&FIK<5L3@+iorU zT`L~su^^ZV97)CCv+2)pjC1k2v+=U8tCH3&`;D)@5uk(3EH1+Fj+hXua$QM7!#XbY zX{U=)Y0EOA9! z+ZfZZWae-^F#$X$d;6)GMe&bT6Ljp<{bR#yTqjQ4RtPP282L5&q>%6I+33?;n{Pi} z{`A+{nEKn=U}NL3G+h>8_#1=(}}Q#&{!Aczy8`*#v*)T z7;&Ba#$9K4k8Tu+vnD=xpfu!>-_enu-=V6rbP()5F{`=ju+ZwvarWskuL?SDm7U$o zwX~5F6ciUHk(#)d+QGl{HvB4J_`=s9PI2^Tmd(uF9trsG*6kvmT7A$v*{$W`a^fY! z%j8ZWs9cfd_;IKC^{h-t z+60gDbA|Rg;3r>Kep^{(IK{zM0PdpgtPJiPMmTG}gC)t&7ju(AXO zqpA{LUZz2{zf_I+6w37jh(9X#Mu5bn{;yo)Yh*MOX}g_1T|Q4^RoG)~Ih5ngq8h4R z{9CA`=#fZ2am+pyIXTq-GfM*l6$M3w4vvm_D*;sl#l>O@Qc^%8Fb*Z$4*$cm*L?3S zVc~=wQKc`jLWkxJdS<`^tJ@VLYBL=RU2fy6SLc*fRnucX1T@J?KAAc-RbcH*AV4XB z7)tEZi%}xS6+U@9b?=*5QvG`8oH+fFh=}m=<19 z&Dhsp54o@%PJD3RCgWEGiecx?wDkD+{-)Co)s30@O@RCb`;pX86D@j}5Sx%7^)8ml z7x&6-_EWWb#?A}u=08ps;3%Y0`=elBAi>PNr&)QnE`UMEH842%9-Pn*AAT1fpMlWQ zgKX++6RA8$hKF>hBYYibV0Mke6;aX2ru{TlrT)eZ1I^_wVlB?yZx=Nqmfv$)>!;X# zcWiub7Yq5sxH~`3ndy(2r1KvdyBZr?JMCEo1kkYD)%y)h5R-)2KeNb=_q3p(q@)`p zyEHdgy+F1A{ke2cc4jur(14BZ`S=J53*(FaadCaE@|EiJP``U{@zSsGU^F*7}p17SE=kBOfk+W$UywFv9o?$HEmgNuc5)uDv^RHG*9$j58>gVuMyZ@TPQwnYd zYHD!BHIp~pT@npk4yLeT_J!LBAhf_!2aqsK;(~*@=O?>W`2hY54BI!@4OTG3fL_j)*xk0rDJz_&Zj&fMJQ7(t+eh@=Ws{n|I5Lq$K% z04@j?T6v!dt|v(WaN8cU2R#oMC@Ns&mUdtAMDNh=nn;Wf)Y{m34Y)ARN2dSNlN*5|-mMO=KdG0_{Njstsk5(r|NWGla$I=M@AQ?A_%mSY*!Jk9GF z9u%Yj!!)A^-Jj|H7h67Tix9o5SvS^I*aZlIDXp`!*SI&kf4E2-c?vA7Jy?J#Z{F-8 z+|1{Yror#L z6%|nIRaaMIu({ozftZlMasnE}KN~+@$E0bOo|w%X_U+Pps9+{VbbPvOcQN-G9Y^yI zFc--D{FaxO<*ozv*haXXdx^%j0H)p$>*1P$0bAw?eJoc{RB(dR)M@9M4SsvSWJ7rT z@?|atJ2(UhvBkwsy=X}mHy|)|8o8`@{W|SbhTximQsI8>J$BK1AFCvxWibFt_aM(r z8z~!nYz_`0#&4&s0E+g9@7T`EMmsS9H#hTJIUuOatv#JhJI!XJ`y}BPPl!Hr-qz;k z?~-GsWo2>CZj3Zp5I#k9=74s{U@w{t$>5;ESnvsz4I>4}Z`;wSHO3@tBdn~hGKktK zU17dFb$O>x&B;srwZa!Z6|_3`d%aSke^fic&bPTK2$&fAFMflK` z0x;9&-|o9Lzg?TvXVeB*m$`(b%RiK89NR`Jke-@fqWhn2#3Inujft>mOhM0n@`3Z zHxojj{G{K}T$A3mJ9CakqpjD+N@&n`bKR@N5R#;JKvbFXXZ5fK|X35h;)r4jG>9}Xj% z9uE60zjs(=h4^+$`M!vX>Ryt+d9%ZP-(dp5M#O32rv3eEk^I)2Nf*%mUe{}bKwkDx zLwR}o_bSMM;Wh-K2dt+|$)2L!M45Z{*RQn}&A&hs+d283#GZB2`G=+AvEJVAfO0&J zl65k13U-l!CBUwmwn#l!DSvkjOTRx88Ro(2s)2tcy2GTLoUpXeX?%EdG$)ixwE}!I zat6_S(^>c2T%uNH7Qs``D+7IJa(=;MXmD^q#wjA%c0e==1fyP-OD*}&kTO$DGuB{{j1kT6@C zPK=Dmbf*TUqk*RX10AtLT%F_q?=`yFp=Bu`o-g?}E0ooU^KpXbP86A zJ;m$&E$^2mCsTI{?IjQ};Kn=KwB<1W<_+@Bh5j-V3T0&7MKH0lvV9RIA0JXtR>mma z0MhUKl=pzKV#JhXQ{%sum4Oz6C4o~VL#H<1e6{Y~wS)Tl`at_D^8xFFv3KauMcevQ zg26uC1slcjUw(Qp5D1_yfX)DV031WNXx5@2qB?0535kgOg4+AvV-~&|nZ~_hgirs0 z;xHUZx%@N!BHqiAD<#Fn8$-T_F*ye4j8ud}hYoKeKr>@xIR4SxOh{N5zKO_wZ)iwp z8fm?I_c!UTs8ZS^bm#bay^D|33J=ZnyJVV$$HXxF;okdW@VB0}xH#!9*Drle>z2+} zt{l+)Udbahn^QP$*=cw}lwpQx$xjV)-_FsJAzryHgJ zc2FKpbv@mYQp{0e=I$A)V2NPtI#9tgrMj0cDJ_GuZpG>auB0$S=-IxPG7SNRB78z0 zdDir7YBZoJu)R^(7x!pk)TZ6Lqu9xbkI!m-eFwa_X-Qc{L<(`QpAc>}@aH#UWMgMn zl9%62Lb6mXK=gSF!<;qq^;LfKwHFVF=`|@ic|Cl-s;W9CvUFoh7%bnSL{s7m2@a{P zt6G-O7C*!ISklwX%uMGD?X^@53C^~bcg+Yw2+*4C{UOiEt(BEzZR zw02!f<RG1TvLKC|SqWhhVdeC*AtE598w&nR>*@%Bik?69#-wNHIMYExV5p zidgzA*5d-&!JGEvK_qvV{|x5adE**>;V#oYRl@DzZnN6(t-9SX8}0`7_60dP{QnMs zAP`D*>sXRl-d&8@K=)~P*wI8U*`loI75sMr9B*Zxg*F9HU%0RXgpj}JmuVWs0K*OS z^L}BJV_|oA*A9j6liX1vwp-@00H$CR08KTJ&{c9kb8GGMW9fv)sD;5qlC+L{^hk@7 z@Ut>7J}k!1?(Yc0&4GzZ>94G;?9_V+CbM6CyS21%WkuHF!Fe}fVxbeQ&awHW8x&7Yn+)c0g(@4Yj$7*Sz+9rq3e(YPHD z&hW6g<=DuG;Nc^MQ=yKpUJ=3Ee2AEJbZ%>aE+wNnI{I*I^dW2+4KodI=w53*aN`E} zDw>*6z(d&7Q%pYOK+r>Y*g^Yu?4r%k>i+#J4i1u7z5v-+P6O@w(R>B>U7&I$h+5-@ zMpTrKaQAH^WE=O^dG2m)DabFlw8*H)R*eo@PJxBM_`CVd`&-#CKvc<{A@Z%eJv|wh z9LUbW*56UPjX=&IA^^v3Pbuuxn?-g9c|G?mF=TCYCp#EnrlFu9PfkY0m^K4~6Z2AP zop^<~;dJ{?bSDG?bmb~egsn7QV$;yQ-v9LI!H_M;bm!Bjkz$mTUH(^0pfPPm#zNcU^+|v0%2LUz z(!3m^`)+i!v@9%4+&cI}pOKtE*cf1-u46_hTYrCi$ra}npAqKIpC=}!WMc?(IRGtQ z+`7J&tK<9f<@JXT74-D3tE*G%zCp0TJdC^wPYRh0R90rOzqnOdRn=2y8*F_ZT&$kx zXlS%>_m+SC3g0cr!@_fr9fY&9tD7I4_v=K_K5J8@01<|r!OQ7gd^o)o<>aa>o8f$D zY02!1hBHIAekdpPW6))TTZbcRWqOzmFmSTBow$)}()aw7T3H#Kl(lvcfW+z@WN;Q+ z@E5TC)h#qiFU3OX?d_GT9wybl8{5!}PX3C;F0h>|(1r5xsl(rkT#9*Gv zOUQN8t_OwxW8=9PQLww9+5XFUFHGP_T~$?>-QwiQ2%rFeW<~Xi8tH5!B7%=`aSe}; zKPkN}$I>{fTQ5jX?Dgy?8f>Dlh5msGo!74wsks85Kkq1Zyan$gZyM>s?lwb4rc*97 z`}-a;{1Z&!(+}C{s`JMtwlrYIff(KWQMd0YWO;bm?q)}xITOa|Qp~DI-sxvHGKzXC z^!XfHfrq4+7&fR)JW6Z%-KBNWLHE*acdr=>>GJTaAj0+9r3cU2S z^DWLEJBBe5f$%Ab?I44rojvQ4&%A;G{1=K86IoT&E(fu(vE{&&RAgbMijMDghHOf; zZB#@kEcQhQEbTFC>a=F}OJ zE4;cqC2nJ~{B01jO%OTHZgGqpz%ja@dTjU7_>ib*_lW)o79aSoQa6{5X2s5YQVKjg ztKF(1@IPihWY1`P0~V$f7-ED5Qum#rJf$Z6v%hlzARaVo`|ua(u{AYI)~XzGbu%FpJZ?|jYa@_3yG>Ig z@@P~frcbC-@MUL5H+%`IvG#@rMpn)`<8GufhrJAt4Z9D2R$kAyC07{q5rM&@`>08` zhCoPJo~h_{TIJwBk@G|*o>g_T^g9uqKO_#QC(S>apVlhs$Tm8h+6@VeG;+x-EcC#wz>H<=V|PLmFd16g!769uRT17bx*-* z{qB0^|6cF@Sk;{Nm+qQGXJ(aSe!kGp<;FPY($*U^ zz1D@s4Zw6sP_prt)BJ~eSK{W_{=czS3^0MaZwa)j@c-soNMFps_zy99OLF|Vv ztft1NriK*IVM5?PFbrsUJ+iX0-pDt5?Ya3YO6pwu0Rj?PRAL0xG&CYXrH0Fw%0+;| z!}T$txPhcD30#w?V!faGes)rV1dj}m`15DUMc>IM&NzbCBw%gT4Q)7DN>`OANfqL4 z7g;bs{Fsq}#>TZidLK*&z+`XItux`nRUH)_jX42HgWt^t0mmpy)0UhJA75XL*5hUU z$;i&eJkZ%r(9zR-=4syh>ew^S_Kptqt5@ge7ch5PS)revpT)`@n_?g#_y2VJ3>dIr zNC>v)Y1tPB?zjQ|6!=8v&wtYX%0vM=`HP5914BbI?hQO3=IJ^%Ht-bFQBmo6lqR}k zeLY?Y(2Ja!qHE52?O3brvMu;5T3TB7ghnN(P%ojHsQjj~jquYXcWS6+KR6`>QZi&n zIEm1#mHs5gO>lMIOC<^5JF~BfpWl?Q&}FsDdAph$8bJF{bYk;-77LSc-0E?U7BN)C z-nPoNLg~s*&Bn>;m!Wr`E`BKQF`k;9L49wo>1>w4S@eUbX^6Hnv9i97i!1$JdX{g& zt}>5eVtICX@WVgh6ztwDUwx1bMIiXfa5+H6GtDR`(LbRIcyCb-f(;PtLqT|~#5X@P z6DM^!GBOfUyPcb;fdpJxxlZJK@9y55z60hXujRaQ1mCtyIn;_dwsuz5)=1o8;^85M z;-p$Z5pjY6acJy3Ue+Mrra8VPfoRy^oFI9S!y`=pTYubgE4`h`!}HB)GfI%BtkXkX zt4=2ajVl6?5DT%5V9=84>0c7E#or(iGiMb%eghU|{At=voxic*6OT^@X4L@@XKHW|*^XD#)%{Kg1pJ)rEh&LAV_;w_(sy|_>v&mtZ=o&sM^~g| zAx0kR4*-L%O($7c2C|*LfGuEKPeQ}KMDJSqdu%M}^=nQLafO7w_4J5|i^sg%%0X@a z`O~pvoa*3lghHMXKckv-LN3~$`JC6~Yu9dFyH;R3s}ujATBsoZZ_|8mz0maDO27Nm zwP+nan3v4kOv1JW3*r(i)5!os;8#BtFtSNxm#e;Er+x<{QdrpAP?FP5^}en_M1YB~ zsOUbz2gg+_6{Xzlo*xj;5a0M8%MQN$quhdlH|XE79&Xl+{vXtO`$)o`S0!ndTAF~% z>byqRd~WU-5CLeRkjAr8HG85|*8MAT6#r`_24}(;s*TLmGIHJA{&z?XCMBep({q!b z8HC95M8{(212hIxOGF;h?5BQY>`cBSMR_o)6i`5VMuxYq?~m`_+w;s%&{nJNrR-v9 zEgyW*^6m87ee;%v1QF|TeZ!OzDu%_yce@SYF!@0L(CD4Syu`$`oJA!Q6IkMwH#A@) zCO=)}?SoJZ|mg+}^D`i3xZkQR%jXy`Akon5YF3Nx52px1#zR8eam>;So+221bTsKwpQyR+y0@1 zgfc%rvghA_&n+w-1u>wq^M6re;G!|wmUj;!^3NerTwOeh4K8b!{e7fz_83XCH}m67 z`m)$2UL8FXx{BFt;vQ#r8vXZJ0Mn-vL2EL(iiwYU({X{)96X3AB^lw&>v(FGSoz|T zmlnbha<+bYW~e7MIWd-JKiuL*DlDzDCs6JR#3a1D+}y`Q4}?ySg`w(Ezd4jqahMPQ zrOMBrI6tYtq8AiYo9a3GfC_N3Q!(-TYd4P>o12>r3=T#{X+j+6DP^}YE;!tGe*gZ$ zgoFcAB(4G0%jtrXSb7iTu{GJ-1Q3z0RyKs45c4}gp1KE z%z+m!#&2IYM`RR^(t-Yd*TNss{9K;l&!b;hO=>(tMiZv;fq~1p;2P@2saVWCsLQ7% z9jXjG2FpysV-SPUe*mGEmzM|qVvM7)`digd&UXOkDu-l_+eGhW=0AZ@Lt7ggIXO98 ztaP-rVs?=}?7wRJy1F!=zQwGam9rR{Do9Jf3|COBwy?Cew6em(j2HRT|x0; z#`R(i=QqW;C;_(~5Bh98mTcbuj6tbZN!dr)L?9A@>i>p*>{}oQhK{-eqFc}+m?9}$ z&Y$;XAv~_#MHxhCvp+EK*uS65AJjk8gyrAB(kjgweCUu>dj7{(e-3h-9{(k!c>?VN z$H|kG_4OqdBX?zFSf5IwIk;KHsk%l zyoR52{I7@33h{F-Vt8FSwy?0+nKQ9uJ5>+M1y4_F%3w-^hi|tLZrrGU&(7iPbtyW1 zVRoJkIlAERldp)cRm_W*OP3QsV|*OExju!luYRT(*o(MLV2C@_o#QXV<~%)p2i%yn zv|cwi5=sg(kG+Bnca0uQ4E%l;nY)8PJvs_{3bAYjh@_~b@I_T|k2RS9oDKQZ9ZAmlv0NY*qmhnb5JB7mOA?DZ!>sD+V%LA;bI_2};_4SIOJ7rsay zJu;3F$0YR3n;Yxc+8}|kUAq}0VoGT_wzd%a&&3Cs75)rYuUEm4@TjVjDtle<=!9bpMm1>HnPa z;D5U9{s-Md+opnM+1+%U%2LcT3@M5fRG6I3E-qH|nNW$PpWRPMc{%L0Bn4H!Cd8Hy zIX!#!Y;84TWwg&ESO0Aj;LE&@8D?f&t%VaY^)`)5-oM6%-|^M=D@39 z$cNi(102Q-Ym@UU|JafXdK^T~t#NNLL^NpAU%mSE`RQJ$2Q=akvI9EfeCX)jBhtU) z|G(L^E5&x-8xVl}x^m69%V%@Sld9KY))!q^m0Hrt1K%J703dw&ot9BY?(UJb>J4qk zhw}7ihtRusbhKep$w=>GxEdG-)B4LX30iq}gT#*4=_<}!2d2W)06Vcgqogzc!5Ao9 zN}4;%Sk3I979d7*ED$I})T ztnP1^nzr^@ThOjeyXLwPk$EV}%fk`CP)~1ZFmxT1qFn?C6bg(@dULF`0V+8=i@$$$ zcdUhDFE#sh*uGRERQW9|ODzV!9b|}!so3ATDG2T^WJKY{U| z=?#RUoH$tB>u#gQDve`8wfVdHd*MBLae6tnB#^V1#4|2w`uQ!)&wjam2J_!m?L}E> z>A%yvz2szq}3Uip@9s)>6N%fJZ zI5|~dky~WXpOggKHXyXXd_ZZBd>4D4>RfA!?INQa9{C^L2QZkLgpd^scj%g#l3X93 zfLi@O2rFDJYOjoN>k1r3f~m^Ii|}kA(v#)Ti!83o7Z~fj0dx8LA4k5&%MyFMtUt%S zjlj*rQ&yHYRkOdW%+Sc_-P^Y-cJ|=RI69I8T5oS_n_nbH%oYfSPzK6uC3;UcU%8xpErsZ#B=+v7{yEff@I#m3=00Z zvcyy&I0T|uynP(|d_VR&>yqu8S%?b>&1g4dVv55iM8+K9Q+SrauYO|$(rzO>sgIOb zkynoq+X7_f_*Q;4TpD?1FAeQbbxqBOtSk<$Bqk2%0RW-=WhAVf=K%UuI~WKUzm3fC zk?wl_s$190y7%Y6fLkFo^+xsVxvg{p(_d~FI$~2ZpWF{l@-{-tKSv0@RaNaEU@Rz; z+SAmD5SjXday0s7m4mQ*%>GeF38AW5;$7&M4c4L#NW`4b`1i*;maZZd$eP zZ}$>n6B7q9_eXi6Am>mh_un)F6gM<)>UjNSW1vCCu%Nx<2{KHjv`fVfIO2dXvk61` zCW)lLub58*P+)ui9tX{;oxSx$*G_`oLpx$Zz>5vVuGf{7YcrEar>Mak_-!G??)3x~ ztk)mi*^g`oxI6&j+_QT(=qP`g8FUvO+WaN`9ocv?sSnb-U<0y%Se3#ZxD*x^<_x>@ zaVS}JE*Rk%z*;gn!q3}#Y-;LVYN~>w{byslCj-kTU)J~!X6L=Rp&@yr8Zq%fwG$RA|x2Ip09q$11G z$({m+25fBoe={@yIkKW+m~;LSoa7OOL!nMG?a6Zb?_z=^Kwt6k=9oX8d4aw-S6)o} zUl|-|nHxXS9~qkvrGjqysN-3lIqc9an}%guY%nPy#w3F^8NYw-Z?Jyr=#+4HM8q*> z=B}2sUWC44q(LA66+yvBXlQF&LUhK!hBB}NZR0eTxKh_u@&HS;Kv%C^In8$3#zQmP z@CL@2;?X}gS%qBp)62}PE`l-m$npA}tzC^Nsjs~%`hnpR2rP{?Eib5@ zqQDsY`u`vlu=j-M_QUcSnMP^!_fAw*16$4u&I^vFhGCuDvg~xl=0rpzhJ1yNKG= z&a0k(O-d|Dd0xGeae3X8H;zSu;y}q-^kTJmP_TUr_hjC%{G{^z&qTzlbD0*>w}2do zRoe{ZIqi@H_IbZ9Qcy?7QJ$r-(010EIW~H~ee^t)6|MZNtV8Xy!!{I1-9ZhBb_UQY%%9h6*Xrx_cDH?e;2koL z>gM9woALlAiBgIEeSOXwwi*Dd@rRn4>t7V9sgJSC5)nlPk9*%~1N@KVUk?iW{W|9? zySutDxH+L5t|!_k#3!brnz(;|Ul0%bwa#JNTP$T2-cq2yTMI?O1V>oMXJVb0X-V;; zIlNX}6cT~Pg6`t8^61LlyRX2u4iC38(lk<5=0IlKSqGvpC00t$zWsd&G0i??6c745 z_`I9k8(t4X?RS++$qFl(&>HhcOEK3jFGVC8%NFeN?X9FDA!1kGiQGYxm*-jb>+^(n z1xk^4mOrbDRoh(k9w26lTUptq_<|k7ldp;$Sr1+KMt>E;XRm%Kx~96S&Nk4pW%0f) zppcFs5XP|FEk>KGkWvqyIX8+Go5WwP{ulj^i2f4j{@&FkvZQWea>+zbPfkUp?pp}` z>Vm_PjxViedF?`oh>D!jC$0yKZl~EmsnIAhZTbpe0=%;>()_TP7`%VJzF~ZpFnEld zy6!E_JaUhv#K>iM$Fjo)=8&*80SUMey+%q(O~K+MZ*!}?tQb^6+dmJpCsGC%2z^`NfdW zexgGgL7mZ2A%oT(^%WIB$ChK}iF6IF{hbStbL1?uFx%LWZ-iK}nE6mmcE(}n{*`&? z$TV_on80IPv8dRwN?!S1^ZTI#2aY%lPj;I-$84E`^YR+W5|_C7?dxzQUW6}qV`Gz= zS`+BGwjw>nz0RS+K_qb>8UmV<))yywdkcG3R`Q=slfbne_+Q^~FLjQF{V(0s3!F7O zN2XUPdOz3haH9y>%Bn6;(y_lo`xS<~>@A@M&td5@Hg*`?zFW_+yf8S1??|rW(!R## zW)L%E&asgYJt;2MlHTcEKWuIE<^CO7Soc=wWOO$2k$wStR#i)j^Wg%kf7SgL)f$RG zLqRPyVDciE}ZV^Vo$z$!7gR6=_~sCS~VkN1CCZ@k5#_idEb%Bc0XJ> zmSimId%3pbzha30Fymj0JOBFgfG33{_)bnj3!FVd0^?slayftok`}_LN^ku0@qqzp z{OkOl|Bb)4z8OTbo9Hu$({pokV)wMeKYoN61Hej8snITV)sqKc7}jnEm(#YU0LeIu zN0vWl1LP8-Wkjp)n|Yg^etP%*eU@7rgBJJcoYe}mZ4WK*7*1)?x*PQtU$}N{QITgP z;)fC0$|h5x^*5UHk6fRLK}EPTKao2$fQTad$h7672?)rDmDP3 zfWC*_0DW!$APXh-TrCn;cF*hvNdhsOG_G+Sue8BlFO?|ei#HN8usOfVelznV8#lKY zr`T$_H())5Z>=defD$Ra=x2Xlno`I3k z#K6FTg)`$*&Kny&yDs;KKHzQqhCC{doW;l6c3flEPIp>gnX!VOG}Q?e3v2E4hFYVB zSP3`)VxNP8DMNx2j+}vybd$z`EtgST8wPt-g)qdkyBR*Vy>(?pC~w{`(QD1qZJO58yua%eVo>DSxeL zxVQIgyzKrZOBlC&!rXFk^v65tM39P0OxM49)3jq&9?Ys-wuqoQ#6NlYI5e+uC%U_@ z;DUGR9Gz!bmp3x1?H0C9QZaX!{^Mv<;e&dcKG&E4^zYK{gx?BDS`VfD5Ub^0N zaLH3r*padZ4BUBhJtt}SE0?g}W^cwJBhUyO20_ox?~wIprlg{(X!pH90O05fML?+`hY327krKF+Jy?fVg z4nhzQvN(U@b-1txDIn*UnfWscgrJ;=Z zr@wJzC!At~XYTOOklA56Kq5tj*>*^w8yIM8tDKz`_PqmZQEg}o95g=X&mW$C$_^NW zhsOfbflbc~@loQ=VoYaCVe=C5?wW&xgR+tmvN)Lk8Yj1=-l{h+d~RsiT>Vmt`GJTt z>nYpikBE!{&=D+`Fn3}k=+C!rZyOsasnn?2#bDzT9$s~dIO^G#zAZuN!-tG+;EsNh zaE0oILefF3B=+YQ-O{NF2QEraGjr_^?c+&lj zO&hv(k)|du8FPA24Pw%iD^QS|pYJ903fn+l>u+ZY-{`%&cki6Fs0w-jrvp2Cd#D5v zZ;FKs;%lDykXEkA%u-ARhdbF-9*?V6es8Xsi-|FTN2R~W&?SsC*r>XfLJz!PL*A7) zi=61OzP>y94?HQt&)oUtzHh9k$htP1H~9P~oZ)@@Yid@qlQkDeB}v*lg&{jxiJ6Jv zH!e=)%$PX3Mkyqq*KzYEII#;oc}+ilWQC^BpwI~{3{1F`%qA*=>veNwj0-N+b2G8x z)s@#j+}=k2u!Bd|<yLH3A>`YBf*#JsgNtg3h5h*oF z>DQH5C_xG3H*9-M5iV#j^yA$oD=RCrn;*R(MAvt_3ar0ZhZ<5xa8canDY%x2C7+xu z2X1an4SQi(i+HUPVFSVfqc| z5D+fQznOnS-g9VV?hgTuV)*!=ceB?cxb@O!;6pQM@!3n z5qrJ|-<}I*=pxtd>g18^qrx&L4;&G)kYlHg5j0;I{b2xcHvgj@(miCI%pwx*`( z3;h#n3`zL{!r1Sk%*;oaGErVuz06E5%1%|EJj7$!(TrEby`f7X=|M*SyvuXy^wC2+ zd>;4soeJexBuO;$9Be1@Ey3tAlRekp&K>vR&4<|74z*kd!F9BHCx<&$Ddx#I+xCN1 zw-6Us8g*w|XQz3d#%5CzS{cMa?3WbXXQvV_P}M&8h5vEe5kJ4|?5;!Vkk5|)PDjEQ zm)2U}XTP{R7g>YDB7>OQ-Bpa2L-y?Ed$*klHV9XsLo6&z8Rw9cQ&yf>w;y5DOMX{k zyQ8t33qIpIt!nlDFeEBR1g$)eM0Ctc57z6*vpCM_oBkSF=78;et z#>PUkK`+De;G4LwtiVzL5s=7TAf-QtzFC!zi`fm(b|y4K_{r&M4=+x?tOwCKk|);! z9`%M4sl_$@X#N3v7p$r2&nT_7?bvm)qxHOY$&+$Qh<(%?xGr39g^>bC{IFn!@{oqQ zSc(K;;kpl;ZC2ab#=is`PMFm*qDakbZl*4vk;+~ZLn-O zA$*Ik5;0Fmp%xbSQGbzOR|hw!gMfmm9i2L}75ohJ?v{ zw)o)Spch|i^6f)(w4ghRT>RO}(UPL|<#sYAZU}~s5is4}8&s~--^);XD*tobZ_-~M z+F2cySe_mo`5D@fDiI-Q@B(^apF`q>4mSk!8_U2xXWV)0&B@R2fBwAs?i$irL9NBC zjoIzr`p#8viPkiT7<~@u8VlDIyWDaf`&tr3seVE80y=LHQcLgrr%?n8*)@Gh2SlH= ztS#?7L(0w1@9*gs=pcwHT*1k}<=vY%c~0vch;JUMi%5E(IQVPa3}jebPn@A+&O<(n zD#o}fAz~o5$wzuqm(_{Gp}gJUQ2m>pmZj?58kM`N-vd2So&Ot&d2a6cP%rYPK{t zSG#&Oibwy|yxdsZl7MuGjFg*V;|C2RG?sxB47dgnZa8A$4pG?4v)PLbZa=xI>iQs0 zIvp~K8FtF6bE5^S(9@%0e)w=S%MzA3SqKj+o8Eu_T$mh-yR6&AaFKSMOkX6ZLv6fP zzr^-dbMnvus-qKUO79eQ+faJ);1>0>m{!zljh#7c3uA}!w~T>uWMov&SeSifg3&`V zrPF>tWHIXOT(-u@az(rMHZp%CBuZ`M3(!HzXhzaJmFzpz8*D4sF39ziga8Qs+ln^BUgHu!f6p{>SR~)8iMgrqyk0foucEr7V$jJ7P?c0Y^=tf@Sz20c@ z-jw~v(sSF3gDQ4=?#5dA$^e?h`!LmU_9CN@#DF|hQ@DRGV!%x!u%-Kz|nz4@#fU( zOei(y%>y(HF^E_8j7>@Th1*+K*MkB!SUrXMm}wlwp1m0LXJ&rB$b41h@U1_0e(^?l z{Ta56_>y%Jqh+l;vk-VXT3M-sREj&6UexRSo}n`lwOR!Wp>RRc)qSuWwJ=(Ow zhf&ihDJyq=FXf86=eqE-biJ#vFmrCMxj7S&a`gT=Q;WTWek_tF*?9)$^fw(>7x~k2 ziic4^Rx6>kMe=`+5vU*LdJs@`AKD4Cu)SPF+a+KD z_3G93M+{cv;o)>sy{&ROJ6+DhP3K+mZN$K&8ogvE{er_Cr21PO?su+3SOGL=W-90> z!e+;xtN(u;AeeKvO!c#%Iw{ELeTjCT=-&I~ z!$ha`@6k~wPgci_{91`k@qvg+Z@)TmC3CZp6g@Qei40FYJh*OVk}ydnUe>J*_l@zo zu#5bKVL(jG)L6gp{pp|T+c~eFah@!+1+aQIU4WC5lbKoL;{k+(zj*%qBvQaTtOqIs z`zt!Djqafn=zef=h8~i$h&;GSf@5T zWqce&XS8c;$&eqW&6PxpIG*Nz4T4S4>LQnRUdk&;;~7dZ!S(fe9>76xpOaP}}EcVty+*KEA1^h=k}fs$m{pUg4ax+L9H-My1=Y0Yf1=VR`MpuG<$E zeI9ZZ39cUEubU2y@f%W*5KWA}W^aG=#P0*0{vbk`zI57udhCMmhUB4vGm>b>bmm>xZrNLmA1qo%28|SV&Lc))n$iv zH6uIwE5pT?XTF=c9pA_;p9zT?juIu1WC?k=Fdt>eOjM*<1QuX&+4|{Z7|px4@6e!Y zl{n2#m0W|Y*2ACHk7CcheTX0rHJnAnDq7{WwL$i4b(0&($WgA zz4G#wfg)=aR{A|7iJ9a%iVpxiI|_1`lft{~|EldPqoVHHt?%0$r4a-~KvKFvkQg00 z1!1H?y1QGY1O#qCx*Sj%hDMN3=>{nY0VS0#8Twp4>%3pi`{6zBI_Gim!7npw*8l&D z>)Lx?ds{nhJ|pYZ3m$~(7Wzki{>%)?b)LHGHprPKne_@w;{KKvMz{*VkZ3!u&3+T= zpY4aokR|sgKr}JYV`c8)$^4x-s{h)*(~A@|*Tb7VK3H{x5ogEEG8loxyv)Cum- z5GVv7)Nz)G;3TlsH%M=+t+gA~`LuO(j6=ITFu=pl&n_wHyk5WG(B6I%Z7CTTaNM6U zTjKz86xvl*LzxC2n0Zt(_+^xoTsNk@VIc62b7oaVRaFHT5pI7mR|>#=534`A@46d+ zpeG_CVlMphwhO|vCdI7=pMqKM&!x&&uP)==oEyqjaV0~90Ojr?_O*_2w$DlAHt1PT zTmTonC1Ujt0LQ481IrX-emG9tY4WBFgSx{8o^VSYnw%1Q zi&Q}RPoDRt2tYluFy;$GzHlZ`SW*Bt6AO_wUzod;`tr)By=P?om6bU;L%DS-VBJ0d z_8*3QZ$-gG&L1Op&;CCx2<`dq`?f($#8O$r_0z1t{*Jq?k23DBp9T2>eGmJ;V)rJ! zpz-Hc0_rhvLrfL2WqJP0+kW>mV{*#Az50hWs$gPB7K2V=4>^x?obfX-u$U6VF}pbp zR#jIeavH8Ry5>P@Hjn8%tbYb?MsTp!^6>)C+q3;~BT307gz7KshTb_t*K&%ucLh*R z_$|H4%9#>@+^;?T`8fnMIB(tvZ-pHXTC+RB7X7K-`@fo@wnJcYZPukgrcv-eqV1GBF`4Ab`hHUQNSD8XirDiAPPM!mh3iwD5Pct~hf*^;G z#^#}xI%s-rnx4b7N#-|Sz!;610~r4}p*Y}CobC=FE3y#q+(V6%K_sfJ{WX76_VT6l z3<+NkSkRGu;At2`BT;`i-lwQ22+e?Tyqd%AB>#Y(^HOmjm>C-ze}WpmJ&Hz8L$3%^ z@N>Np(q>uaCo0)Aa(h!Gd{@UxT$an$zw)6la{&07l;e6+Dk0qgI-`V)+JYDjgY*on z!3SCrl4xSxYMTTzW!(`&JuQv{{M7sQHjouSbuNIwz!NLgZfY>_Uvv9!Hu+-dBStC| z%QB&bx3UIW=rj^uvy$1^_Z>%vN%*X-z?nmg(qtE6TKF{Sz6ug(T{}}p$ALwc(??nT zeSJ}{UP&YN1y@9^e=u1l5zYQ(;wo}~a?-_88#rnhApr-3Ca>)idn0TI^7p8tJ;lj6 z($N9t;!k#Lu!fD?h7CBJ^Dm%AQ#XaIcK`zIgE_X&D}wy|Hu+eia+AwRJ&o{fbM!%w z8eqQ5fLeju9*ifU%pf2N%wPGT{Rhnn{!H}qx50!M`F#TwgGMj{s;Rlc1IEd8yicEH z`xET#b7*sxYrjIa9mHkSBIp4XDqbVnJiL|W?-f@9eGN=4CMBj$nj~?L#6E^CI>&9_+&0e|Lv340Z%;s?5ufLeYme{$HACde{Sh-Xz?gz%ZOO z1)c){L3CSW>u5iX&hjij8%1Y%?>B&wQc|c&BQvEJ)7J?Nt9>9l0Q7b6p1Dx@1~ivM zgu~{Sm&1s6cK4OQRkXA7W6#w+I;ZbHLc)kzY8*~W+IYG3DmYnJECAz5x3cpvM++tO zv}GkWa^$e$Qo__&ryG5F()w(a81+(??GH*%GMsrBAxeCHn;5mULFLvF9H{)u0Z z7kVPE%scU27XW6QVF=c?6Fxg7x!v^6?tzRYaaf=5Pg4fAHF?0WJqRXybt?4@3@m$b z-xqs6E5x%n%+_3Fqg0R~nR|P7zaDpHGPqw96-8j$J~0(t={PqwTfgm?7d)yq4wIw9 zCB083culkByFvjPR%QlC;Qy znhcg4T9JX|8d1Iv)YfER*dHh;JDkTy8@*D5uqPK6*VD?)Dd?P%{{D-?vHJT7$6=2+Y@G8pF-E5ER@0Wso$)_1%r zZ#=(qDNwa$Ub%E}`{L$MjP(hPj!41Ql0x?r(`q(s>6>s(;& zqFvGm_W^!Hc(h0I9Pf;Sc(`<`fTgP3eH?R@?I11+tav_}paJQ*8g@;ZG*&jJi$)>% zAMIBw`1cb~*0g`aKFNvPg-~ztd0&2>yJE{SV>+|(8SWXawrN_>Sw4RJr9k5@zH+7Y4W`wr9+ zZXUP+G>4YsbQK>MATIS$-wSeBT3)6PhA7rtm5kI>_GPiLA2-(@f`9?nc=f#UERj*x z%+mZ@gY$65IN%l&X8Z~LZ(w!~7%Mgoj^o2ahG2kmbt}9SfDD0K1*l0$&PckJvGH-4 zU^(cdW|{+uc+^K84qk_VfssF#ZGKw|boqq30~-;_TE1_U*@ z&A}mc=iD$J!^WY}xp1&~?urMNEqO2xzuxQ*TmIAX(0^Y75Z#>B($%jQ{7+mQX@)99 zNoC=)9^jksYVzTaj<7Zyj8#txS;0>brzL9Mm=u4pCSOC7K9aEt9WSu=AMa)Ro(23% z2q6CNCinkmQUZAzB1~avX<@Dm6Ds2LNAQJ*Pyv(Y{Sf#a(sF4Mk*jks78T<21IfJ5&g6Rv_zd^|`3%;!;{KkqHd-aJ zr({+B(iRo$e6)K>jU!RmHNPv#7T@&lNj9yorxp_~$}q%k^##1yXqPr2iG5&q{M#w{ zqvbQ}u}1g#`Kg)Gt|M8;tUvk-gA4x~LW*CK-p)CBdEoac#~>mmIuU)?6x6q3K5hFm zt}Vh)NQh78=XNvUlkIbXi&BgYBgFUJX=M6sc_EtF}3rSUmuHav3 z>1_ylBydfcP~a+XI}x!pJ(J`tl%t?o#o zjc?wW+Y8?9@vq;u;w_(-(~4FM7bS~XCf0a_oe{ZzaGnpvr~2~AV(;g-j;=2Cp`t6H zp#u8p<~>ljT8LRFUoF}YncBX=B33_lF6)mRE3?FwI;bnvD+BP`*B@nVHl0=|z5buS z7gX{+SP^TCYCzfZ7#y$s}9rTCq?~x-VKq1+d+r3Wk3Wc4S~+KiZw3(8Y$pP;qldQhfMnWs4l>oow_pvQ{YQ zIG^Uj7xV7EN?&C?FB?4gJm@M3swau-Mx+ezz%%bXAj*cAg5qxQ;5#KPZlk)%Z0?C< z1g6f_Vjx9A$-sb7n0u^a99z6bgR=Tsh5_GcKEXjHWkq_8POcyN^~AW2PeD{v1D$3& zi%QQSmLTSl`~yVB`SJ7_@~kr;R={;B1~2ePK}k*|r3dHN$H25ThSUJ0CKMn?Lj3r+79UyAPP z*AWmH{g$ta7+BuERfoW6F}GRxAKU(1Y4ApOtD&hytPoP@lIJ~KoqgPaTA{=h<<+L> z*9U_94mLLIoSloiIE$rI#3d7F^@rBZB(#07{AO}3G}-t4-QCA_^9Vqq%oRG`fMsXn zMj;?^$(DL*q}7W*ft}h2C8bex{)WC=&|El7=HuJVg%$kK=RsVW=+XC4(=Qs*JsoG0 zf3JrbYX@xLfs*HW5D7|DXMhC7lDmYsL9w(v@pUqx(cgZsk^+@qm0z}CDyA16PR!50 zVLwuIFGbnBe1?2sQP8EXq^i)8XMUzpg-z4O-5otvnWyg{#Q|uUcHsRoD$b4j(@X0_}2hpP=mAG~&w` zcNZ$zhS4vjf8@x;Rs;1>?LPD2Krpbnt>8H^jN9%{*1ro3+^z6j1ZPHidgCm8I;Np3 z1h;UjxhlE2{yRI@`!A(K{2ylMb-+~psKwq&VPSV!*!QM@ylpOu-mK=QGy0*aHo7)P zGyca=^P;SZ*OME4Juv6o{1tf((+=Ijdg?M2tB)fu8*hDl9>*->@byt?m{ELv>SQln zpnlEtDFl2VFoT0-)9DTO9A~S(DsPZBf?pXGcR!+q7ODEJ(b5sbcC$_XjWs7WGuX|k z3eUS|N2^0Q`Pkve(z<4xAY;y>tQiDmvsezgU!Sv+ws$?>ppo%YO^2eKxs93dHz& z-RUn;r@3cIGHp3>Q9Jt09-EuT%REkS@5IoGzA~m%(V57%d=w0Rd-q*%5469wgvaNF zhJ-{_)5K?G#SokDr!c>Jr<7PS=RzH*Q+bPi?*RGS+4)*mSAkyORR6O7*=+KL{{4Ch zR#-3Q%(3#fjU^&lj5}myU{8pSXAZi z29}P!-M#X!Vyta!Zdr&{Bt$uv)Yc_@x*PivK@V^eU3}Be0)_B$_33um&_Z^jk8%k0 z1gm|5eKv({6_w9Tr&sO-M_k9#CMUlwd^|Di7Mow-YN<4pK$aw~sgbaS@W5d>$j3!I>emAredsH%`6 zi=GnsjrtLjhyQT0MSQMlq75()mGC7EZ|z;PQ&4bLD1UIrswrxk*#{2YQoJRs&WDZV zED9mPk+hW5FII{m=vGuvad$bRXJuXK#7H$p`37bfx~Uj02n+I4;**9ito=y;=O3r_ zqy66AVz3DYrQ~f%J8csemn=#DkAP2 zo9oKTid7XA(ugQ3Q)(I-7;TO;PEL5Y7@zkDgiRUgc~>vbDte#1-$VaoqnrKv^q6Wt zZf0a?Wbn-}6`V9MUtmns0`nOKn(U~TeM|ZPd?As@x#_y^EullN6O0;t+6v6Ho;ZV2 zH!Zc^?$c+23QA$?)ZMq%{VgTMk=OBH{lRkKD}R57C#=Jklg(#B&1hU|v!!o0J1Jz} zy_yGa2b}OG(zKwrZ<7h}qczfyyGn01IQ+7&&CFsGej^yQLJm?bmIF-@(cn~lYV3zWYF zO)7QR-L8Zvt80u~+1ZgHaKCP)0^81Utp&@#f5yM&m*h+}Y`U24csG1qK@g^) z^>)wD*5!niavUXJ?g{$r7FNZzIOJnFI(yX78d|x-pJsKi&kmo} zn6{_G^_-wY0XbA#E)yE_A2wyJ^NY@%=bWBA`3)Fsmbmx*mbL<})r+W3i#^W^m@RC4 zo?$}M^#&*FZoxcILyLKCmKg3TeeX%yz6NJd7fzzVS|fM5-v2Jx|q*Uo=mV$kZo$Rg%VEN1q;xN z7lYuFAb*k7CfuCG2I~7=NI+5D^WY4^q$U}u85l%4PBWc2k>@uw=*ui3?`bZyGrfIR zqWjZW!o`ed-jIy6ps@ZH{o9@q|I?-YOAw3m%Vw2QHp}**U?@54}HR($sdW> zw=x6+#z1-<7uUSlH!l?Tk|~&2MJEJ(wjpKA7}I0_X6Uu3-OaGRFZXykx!4|$5B7S+ zb+2Ktypkx*TO}Bb;ZA_YW4x$b7{}lMS7QS-bgA9T+rMmV1*@u|UYQ_Yyu_fMG!Z1t zGCnqfz@04F%Oaeq>&(6cE;UalQ--GeUdO&G$wB4aKu~54IF_KhyL)Ltn-_}Hkc^Rg zr$%niIgy(nTq_LQB3R^h&Ed0$?f%M#;)X;LK}nar>5L8sRcMnUjVWWL*9!6SD!jyJ z_E+zf8Z{eRS-qd~%{$&PrxtcV?Whu5^go4r5w@h4cYCGf9}JCy16e0|C)j82X~o3t zF0sGFUp6&mLM0ofgO46o)5;x+h=|Xt>H`ju8P*w9U7jDDnvsOv_BGQHpsQc2 zfBQ1K%q49SEpl5J)j2r01x#y1P3#Bh*?Rxu$?DaPb8%TFQWMkpgN>;?tmT`WoEzJ` znica}tGeS0GHF9OMhguO5arsO8Uh*(|EOB>rYPTx3?WvOSES{ecKNCnX&OkI_n57@ zSSQMuRaCTq>(gSpn}U^R2*u!5eqL$BZK`$gB_qaW)( zMx!OHKVNbe`g1nF$B9snHR%hTGFgu~6dLDoS^N_j!b?;?K7B+fc$wzCaM z!4NEO#;+1S)@dt^X!PIhZtYDUm`7`&g`v*uSl;ylrohjR1Ql2Gq@i7w+?@PEEUS$T z3c;sI<>e$C`3_S6%PA!(UgZwyQ7X{`${$YblV6_J@e$wy?(TcHtz%?-lz)Hkh=6ih zx5z81jc4MpZldoPg;85@;2cs+LyF=+Ut{;AF0<+HtO1_h0S+$jiNs6~E|z#5L&Iod zADGOt(oQ~(Adjdieu}2t7ku-$0OzYHpb=k#C9)%wGctO_zs5wWz)DuCUGu8+v-Z~T z!06`edHK1gpAuo-mrnVka-!MC4!#SSJNAw>b~3{Nm5;ys9o>HKT~(Fl9pYEj)s0?1 zNe%g7>J&mEPPj=`H%Pfi!+)=z&&LFX9UW}e`a>-0E{xePHhQ00{MsYR3MY^HowT)I zngf|1{3*&XA2M1bemhTPS8P3o_fkZ9?eGQGYvjsL3D;rhy2B zekEuo&oj%oMQ_GP8o|tbw?wCsom=uD6KPv(`zbC6FQdP+Kj1mB581X=Xk?^9mLxb$ zKwQ{+O0TBFX!!rQN}8YFDdboCF|sE2oVG?uT@OJydKi`10wLVU*}G}~B}tma^(*J~ zgfEpze5jZGYSlEGgY6zo92};8z^-eB=vu_1CUbgX1d~e-_-L!Zz_O>~RWTLMx5HEy zukK~>naWx$xyn%IG35cG5#oS^`b-WQcAJs>tu48H`&B8$Zqw^26<$LqV2cypnQO0H zw72I9EwnN4H?TLzD2?t{i=_XT1WdN0_3KnjEv@Kd1qJI-#TaA^4SFOKZnN74A!j0s z)F6d#tDDxjJTFn-zHUJ&X!G=7w{XCu%LhrluWNRKhs~9Y@S< zNw7--jQ6WuVjL-#sHlvFlIc<}9Ur~`ydTfyM0lk}c@##QyV=X31ew&rPIXZLpK?q~ zWJ>luKu932fy3_~oRc(M)6lTVc)lIT`Czr9csHPplD~>z)LxTI2 z>3Adq!{C%;U{3&_gUOw#Cm1!Rx>unG7l;y)ldBvDHo|YPM4vcl-i`6~^*<5Z zEqt5rNhdHr!*bbMlN&Ou- z?8piGJE9w~r65jXl#K@XK>lsJtOH8fY&SXrxu^Gv*rZZhDwJRoW4X2UDPzp?Q_>9* z67QYYz?&BxY)nKELp0ND1Wm;5UI00PfR;~zWB)(JR04Mfgr zP=+QnvG4Dlkh5uCdp7^&BD0pJBot0VmfX_>dsJaASRN{`0EsyNKX&=qqCoo zyp-loX|-LbHlME%R`@iBUt3X%#rE{||9N2xn|AH56Uh>~PtF#0{f4Y_i*ht(KSCt@ z@j@bHC|^qbZB_F~tWeG6P-6h}apv_)Xsu3tlp65w>gr2QlHV@Nub4>Qup$lHob z5?o1zg@oMSdeFw)^+b)2G-!>FIJu-6YHFIj!8)1>uyd@oS&r{;;TnVtm`JOgJDv!` zijFXB3sm`9XJ*=M5JXn3I5N^2FB+!z6P1?w_NmeH2X9JCyVfvw$*xo3qs`3|Kx#fv zx@c=--e&iZ^JX(>o4u=Fwwat5F5NA10C$?RcWF;p?=PAcB~IB*L@bmltrHxVkX#Qb zp);vd5=`o`cista`=L5On6;;}(B{C#BD}G{mbGbbm#dtq2`3_ibaQB(um6&LzQJ-J z^Mvk(z(qz=hUXt`?fl}-lKYM(BN2an!(V9QS=m|SNa8X2`RmEEjaLKni)NM{?i_!u zJgFa;9R}$9ult1mpV+x(*iN?EosZ{_g>k7bnd0`a*J}R0&9X)HG}Ybl8xB`f3;6zP zin?i^>*xYTl8=@EGwVBuoe?RED9;Ie6kMID-`=)&9AA)L>FiIiyP1Ge&mKZh>c^bk zddWnZqKH<j4Zf?EY7iX z4i84#_I@hRo6>NX@RVn*E`5Lp+|j`FYWF4!ofiBv1h)B+kdS_tWavJrzh2^VA5M8X z15Wiu`LENCb|)ZKUS98X^R?f-9$Q^DoN?D%&;{?nVXfPXuA>iYgsn0lL63u*6%^5% zvqARWFar+Y3#Y~YG%KiTH(n7`^{M@SB`1Q^h=iC}3BSb?CPK}GhX$&0d=jCyv2_#- z4#7mK{scxtEC30Kr@8E57-&4Gs9gpE77n-5Jq?wWmDl4l{kM{94et_C9U68sj+ZLU z`eUB%+p+UB`J7fhtJ*x?--4=~+Qq5oTY)FeB7P(Vg6DjH2K=#GUz#7ccVN}Jl~Qau zl4fmLk=U|1o?^>&etq10-79+AUtvBNPDIV5p_qDBi4q_MGJ-oA!GDJUB5voy9}>y8 zXKVrg66|M4k#GJY`!nY6lE70&(1j-ePY*)D4p>ix`OQ=xKThV09tvz0mo{+S@w}y` zrlo#zd1~D_zim8f*dKj77)2cJ&zXMZB zfA{O+!tpi7Ap0Nyh`{;lb79*=gQb#HQ1_swLx6WDXAve6k^)qL9=FMfEdOr88=X+O zplYPl8dn$i(Tcs9;};iortCINuppGB$The4b=q?v7ZoZBiBp}( zS0sJfDB*5s^k2WeyqwXaN*z|p6!Cw0d^nv&K_V-sx$z(8^4(dvAg=7uKX+`onu;L( zK;8fD&-R-Lh)jDZm)>S`YOy5_!mkbm8|0p~od!`c#iGmD#*)f#F;A;&As$VUvYe?x z%=jA?a;73OAbtDpi7yTt3F#}vzvqaAbVBku_N|O2q7OgN<{a;6eS5zx`ZOZyv#qZ6 z9LZ3vq_FhQlt@h;_k$1DMt)ccoUFj{Q93TuEuWXyQbTiD%lz_~_h!7-!BXS(m^1}I zmEG)n-96*IdQ0f=aMSz2ex66t{rTq^`u{ZP)A-^;^D)j?C_Zyp(^+Vu(XtnuK~xqr z)3R@Hz36)VaQ$?m=;$+{rYw9J^>hpgIm*y6TxvRWwe7RidFul?DdjrUGp5HAfTus)rOKApRc zh@^tKl7|oqyFHR_x^RW~QHId2tkoA>FYb;$R=IifCprKd>1cIZji2~f%2bPAR)aG5NHhRUM(z@ zJO`ZRHX}=q3g-ob3;rEIfvAF;CyZtgGpkx07D4l=%PKeD=J7syyXiNOB?Z4IjY0D`b#(dU`@*fBx;eI~A7`C!;m1sNt@;~tcdUAz&j?L~z zi}liKGA+5A|3J)f)49^1IK3EB!Lxr%1Mx{xh!VNmDNXV{eh7G<+I-Y-&7xiRNhmeb zbJ;u5@NRl<^TV=NXQn>z@cZ}oS3b%}e`A9E|E#W!7LEY?8^@`fenL$ zm(Mev+J;*F*C2vNH|Glutq%?RrLJjbq_7*Hr?|{p+SrVC_FmrTZhUG+pOu=>(5rnD zF@&WkT&L;#bu$7!5CD>|oY~@VI9~>=llopApkCE^9M12TwPtCv_`w%oyZeIo5aq>$ zezT+I>t*;+V-#4k%gs}Gs^sJ4x<2C-Dg9Vbz5Xvn; zGdVr21R6|WceJ)gHT1iop$xd1vkZ7_L*7pF9U1-ryZ`cZpSgTl>WLYJQKsvDw&V$G zc36^#629u{b$kHTtB0aBA!g0=JL~VI@V}o{UfhBQG<_#tT6)^uNxwp z8`ZkWn)rAEJf0jsJvI&|mLoU@zV{ocG-J7z5VPM<~uqK)q6Zbs8E8Q!)?DZ&}2Ti#j5un<}w(<)^KAo;~dTj zyPK{BZJ<0opnO<%>eSFOxIJ_P;7Ms%NPKLsSN#Q1E&E%FV6zpFWtYv=qH=H12;0&gb(#Si{#H47tr>)}zbyHjTe_m!0|28|xgt0k3znXaS! z+k-}rXE+DVbpt57V`=w4xl|dxzbWu)4CVyKV#?M zEk(GT##UcXU*CnE2vT1xilNQ3_A>?gh2>?=5%DzDIrpWEj36Mv+`waQp(^+M_C85Z z_;J>h+rkaz)EP0T_l<-fcRFGBcQci92ebrO z3~{wB4|_VUTT+f%X>Morj!ip#p?e1h4QnZ$FGUlLZX>xz1Zs0~V!>xnC^`XK%14#3 zM7F^#`oq#xUclEuYv!V#>2Ox;^S?k$pG>4yEi=vz&OqpL%~j3ie&+lyV+ncr!6i>1 z5lrE|@j=VTed_MARhjT_>S{Fal`l_?yYX5XK6kr_XMIk)2?saN5(8U^%H6^5<~2bw zKWl4`X(%6e7!Y1-IQ7HRP45#N5yqWv4VRGtOJWRutLUCbOO@Aa^2>fxyg;4P>iyI9 zs0bhATc_;;&3-`jkruYdW1j@5>TYr(zd>O5IsboJ&t>3u+C7D?RjQxtBL-@2_D7(g zX-h7h=>jrxd>RS1(8)Op#f`T+YUbmGWs&?ps)Px#Vep)p#-V^rQ$=%L$O>^;;-cC_dc0Ar;!3)!S-|Y73sbvo;mz#YI zH_tW@tWEc9@7CSF$q!2aSPZJX3hga@eXbn6H#b$wz3!4NudgqU=IhhJ+J)$BKIdVh z!ipen%TfNrp-PC=%oSA7(+>N+QJq)+crG*7oE-qbg10kS3D9{5X|t^-8nrTgeB@g; zf3H$>508Dw=C?upV+ds$-QrZC4rJx+?d>l0LSs;n86tWFVo4EkVZG}%*Lkt8A?EVY z^7&p#GB+!_a-xw@p5n1#h1>1KJ_6RtrTs>2k9U6SX8J$A2*IZG*~l_Fo@-tosvNbo zw=Ju!pY~b4fAQeod>rpw|pSJ#c)P?zj;XT zOGp6}`T*?0MC)zgSFtl`8T}RztDYg9V$HI-lQmamp(|3@^{BvhlaIL#6y`K?`)zd< zCVV^FBHWlix+4;7X><0!P=_N~U|ta1=f1Q8-EJ6KoSqlRjSpN`WRx6|E9~eyK_3U}Wygif-Xf>~zYw4d~6+i7%FqiJ`9L%2$44y`%x!gvF z0RQy*z0!7MAZRg?ApwG4A6eTTTiMz&WY?b)9s%y29B*ymHBg#P34}~o6Xm!qMyRvB z(FqRcnv1VbvJg`zXc->u9N1Xf7VB7eUSkZ_d}um3_yjzC@rV0hlM7%0mIpgj;8*`b zRr1}P59D3uD1I0n^}v=(%P}?)7b^yU!k!{z!1%Y zuifr#m)it|_ty!7rC_Ljj_l)&fnz=9W0d6d|mGQ^@v08-ORr} zt*-5HrMvJa4%$M4QaC8*>iL&BKrj9r>nAQu3@nkWn{`U~j+>%Fh7_Dl5lc}1aHWwxuw)~Xs# zOtb?lH?Q318x^j6tm0mF8c3P&hr#Mi7fw#rypz{fsSrR?}hk` zWBa*_vx{Bs=`@e6^HGsa_~WC$?>4)3)%BE|jb72z2eadhCGzxi!sc7mH;f6P>>}3~ zIES#>T8m`F&!Ixgw0gI>(5$TXtQ;j|KfnKLnEhB+7x(>_AKctM1WE}pv_H=<^|~Wq z0d=9K+B{x97qFUy?DMrg9h&Oe=BmdHWpB5Asc!Xpn>dKD(!EngWaJ0YCs9%8vSgvY z&&~|?%QE0;q1SHVDuT16)wZ{0%ssRlA(iYZ@>Z`ESWZ-i-@%8m{X`?5(|AQv`vs;% zrb;YgQ=5c($Kzu7^stbd3C40lvI*)%@0m{}W{xM`St=3^K zg|0N+jKV3!KC0}CP>t;DH|8!r^4;yK@r&*e7~DfCI$Be|8O}^;KI7r^PM_LpYWyrR zQMqI~_?4#qC0@9PfQUNlrd`f`2_nOdQ>n}(@O3XIQsd(ys5!|*i=jG;9a2fs1lc1K zHIH{S-o>2Pvf2j9+S*?XVDF>XVR zXVJ5CpSsCJd&c4=nG)I9YVzXAw6>C*6mh6SQ4)$vP1js*xTI=+jxiBWe1a+*M6j>* zDy1iY{0sIVks$>jE4T3!0c&$>zS_(Fd`$ zx}3oO(l#WdGUKv*BxxaPj>nxgKG31D63fP^2yUqcv7&L=cQd1)mHO5q{N<1RrEKD~ zT?#*$B$EpQ#G=LAXz)D?*!ZSU+9G+!A9_e#Z1!K;MqazTVi+m7g2y+lr;0sRZdd<2>&aG-!}_hABf`*RNfq?Q>_}L zH&E_*@W`nS(T6dMzqUCZF9#r`Vd6;P)$1$fc0eK=&bF{8a4>5D`Xtg3q=*Ao7O zs$Rl^Du0n3XIyKaQ1{JyZJIau{O;XIDlzGFIhfT(jt^%q;G9p&$sx|B1Bx2rlS+P} znUY1&;DEZi2+GkqF$&+uhDJPB>FUyV)Ryxzn)=4WmsyCt7jM+;vc8orOEB?685Hyo zacXU&k!`zNTVAxSJ(&ww+p59+r|%R<;W$i_i{E$4%Og{CP1 z;Wq;_zb~IBtx?xm$jH=BYJg>L(wX1*TazmlR#6aRxiL0+yjCLVlEZ;Prv2xp8riVi zKfbE$1Hx2uQo0_Y7NE#2F;6sx!NR$VB1VcOD;B?Heb>zaab~L;x+npSO{1(Vl^a@%cohybtC@5;BkE+PuF(W!Y8|1W2rCP9hDdm=2xxGqYdPPNW8x! z{S09v75l;PSdJ4-W9^hbKLzy|m3?Q^!AUaZ&#X!n-(_uvRkJSFCjV|4r>!h8BPcmWOPUV1?B$LR&Kh?I;%#)@3sDp6KbwI!2zqf6uI-`~u>jwl`72(e5B^N^2$=W$5&!dXvhISo$LC5a@9M9*OQr!1# zV>in8r`4Zrm6Nz$;+qAPEG(?Ol0014t0`5Alr3b$w=X31qoU6KWERS>7E44eI8CcM z)MY0{Ll{BLmo`)SeNk(E>t_> z%gmG}*HU=6#2vlbhvJqNLJCH-Q3XA+Bfx~rV+yM4ANa`B@@oi~w+p1EKua{^TA$L8 zJ=QE!A<441(W(JC{YH^r9e&5=Mv{=H?V+wk?ELuS1Dx=bCXuAU$x!XVUP~_AP{2Wf zLnaISwf7YzS%eoQiV}T?l|J)US5w{C!X7~)#c*T0LUt$le9_rY15i)>#AFxqIz)^o zG*!KfOeDf#@sh@Ho-dz|KafaTe<==k9k=VR9=ipXW(S<|38L;4k}keAy+X)`j&+iu z@sxwB?>`_9&KMZuLq$b?WsgLO0)Q~zp6XC2NS5OyG)~pwAz6pNDUO0za)VMX( zJ+8WeJ5s+}92R}#{KrViRPIaUN{(Oh9_;=N(!6g|6C`@VJ%bboh7J4-ZYFVCEBIQ_ zp@xUCRzSQCR(_%ydV{`yQWsJXURk4_P96mL+QVOLzxiF&OuyN(r%ZM9lXSVYq79T# z;|G=OgJ)no721d%HNZ7k0#YvlvFnR`agsbq6|)i=qx)x#HQO#oAj&iyYd>sr!v2FPa= zx6yL3ve^Vi6`PFxDpzkFe_}Bv)pO5(ha~gK5aEPZp!yt01IkhBjQDEglu7){Z{By6 zn^DH29E8p~HBjZoWPP4(i!HE}GWl>CL`@+)dMU`oLB}qAq7Jw(P6kJu}2s;JZ*@6p}(l`fOU7Q#?pS3=k7%?1l1R!miQ31>)@P?2#Q% zCdCM(6+DaNMES^p8=Yw-8R;POrIZ5n-j(BwZgwbBCbeDtP#!1x`P|=h8jTlf4iv-G zb8j^)@m6F?RlRXuyustfAua9l?4UO{fFMb8p@Lt-A=CO1M;t{J@Gf!OJglkeyS6Uo zSdnbqL_koe;9`=rP($N&W+;j87#;^Ms!Q_AeWiDaA>cv`R^oI_TCg`UwJ3!zs;Tj* z5}AVgHZ!!OZKxkhs(%vt=9vCF+O)OOqE0}C^)W-l^>HdGFe(ui8Qw@aq~3& zffU{W!}9UxPQmw!zLWQaVSN$OAtZ)aR9B|YumHg(F?>ko(Y-2T!MJpurdEoaXVyuq zdNvu(7)b2rSeU(81;4W-=sjVW#TD_k5-X3h4vEfB4^NjQ-NZK#Qg6aq$d5ij|rgY)y^mnYLy zf%=?c(r1wkw0lm5taBErJD)DzHe`YC-zgjCRO7n83jE7Zqj_j2cDd*lYmY!*P{Xp> zpm$FHwo}oW4qN>D42P9zRC-RdwNU$8jmtZt&3DAOy<9O|l{lzAa5WzEp*VWlSCyIH zO(ID)BSt4d0^soSfITVIats!A$jj;3V4%RbG^Cu~K9}QETEK*EE$p3UVUORhyu1ca zcfT{ENZlK020rcxX>s0<+?BF^e|?gt#aaKsdDQv#mt@3w_$0YG_n6+x9}o!m__pPS zyFsvFUboN7tm!Ipq#J$P&ArMe(iEe*s;WY@lZGb57v+j_r#x=x;3$o|vN(q>u@9z&e<%Jf3<8sX5%e7D|lQ1ckFvAvuA*r)TMq={UTC;!EX`J)@B- z<|L`>9f44+yrxbBL3WBR(4`qe9iF2K77KopE@sSi({Q6X&~F3jI|f2@zbS?n(P|Pc zwfIP%UXZEK7|lSOzxqq{y|$+Cy#ff(GCHG{vhvPex3q`$D^Z(fhH*A>f3!PzDXHc{ z(XFTo7l<@%hy@olNPCxj`uO|mO0vhbNnJP$I!QFjp)zF04X5Uf373kU4lbH8-ohw< zeM>DC$J#l-z)33tQQstp-*BtR*#wyy+br&lsYLmgd&(JH<+hFMCv^y5c)+`y4eaaGPe zR8yE+#$6hfz9MOH1Nrg?I`WG`$_{0Wh#tPZLlxH?{g=)RlaxO3WMr#Zxk|o%ctbc{ z82bjjr~SIsbM!_?=eFozXL3)#sU);JN`yrJ6b!}IMF4# zVhS`)Hf9*c73fJOaE6jqw@-pvSXG_^Zz`|7QqXZ9Z3|)~V>)Jd*&#eb*d6-B`70p| zv{yRc|FIRKf@V&bbc{TMl9dBv}bK=+;2YO1n&5U^yRh|rkT>5W9-&bWG}rO~?#dC7OD zFI0?Og$>Jp90yUGTUC7sq1*tY!gNn@39-V_CLmm4(Hsjh-!Z2MspyTsbur#QE3EhK zd%0Y0Vw!~aq?2g9QPt0~=}Sj;z}VDOR2~zO5x^0(cet^6M^XxVHO=3~RqEN-5PAIN z(ej3=)D20igD+x*tV(IxuiI!}J}{xmH& z6vT-#(G_u;Eu0&q>u{;Q8hZ;mCYqrxDZLsZz=9l$p|D=J$>((JHIPH|Jn&XG1|Bonddl-$WrNN@cZr_3QqJ9g z^OP*M+yOO51W{GJ=!~Tlv~PUvr4pTs zii~+_8v&9Bj=SpD{%-1 za4H&F@tD(YP2%`r)gEf|=wsZ*bAbbXTZ_!vY}fT-=77hpyh~D##6c0M8RWlt%`B~? z)KW?Rij2xbb$ZTcm)?b|tYGCTco3qjPAvEPlX>VGqXsJ-iRX)=Vv?#~wjMB`V7Z3r zR%Wf=b2yrX5uz&BqQ8`CVZ&xvO*6C%hz892wtkb{ZW>%G= zts~Gp(7oxf2=SM91h+2i#NTYO6^%9`T$+F>Ks?2!AjfLLO!EHtjmnOX)YB!U8XvQ&K z{7q;TyGftcz`KEWSN@W^+zSJi)(rdMxs{3RN%gBG&7#0XF3izS!xr6j;x7fLpZuV2 zX`{njg}Kp92ceMTeGVZ0Y~^zEIhNDUyZtCO3k~5ixg@!qXJInmygx8SIgyqgqhLSA zPOWf?zuDbvu<__ur@}O$of?aH%N0YS#$mCP&GwhBGtX&}To3!WsouL&Yx8^gk3LWm zX*hIl7X3q1w<1XmjP~HwYtbRO86?OD#^UV1hVU*tRtLOLi^tP|tu%a$?yJy9M{S5| za2ME%I$`aH0-Xu2t;LzJ@{pBE3F38@IIUbNM?Ag8r2^{w?U+7vJvs1uZxgmjzMosh zn3K0tNN{x8!0mUh{;ZeDyiDF6w!=H^#=9xBNjmQ-)QTpBb+|&>2{S<&0_c#g(KoR& zYg$pViGSloIu%9&Z+{+n$1namRcCCEPLV5NAtp%sBtzBUPrIotPLwlx<98!?#HxYs{H^FNR2nnXT=w#D<7oIj?Wh?6j_iu7YZb(D>uK z&1mb}#XUOt;IK^tMEn_=`xavr-s7wv@>RxeYeXMdrZ+El)YBQPNtz>c0eMSdVTEJV zuQBDupQmBwK`bwDBajH+;S?tjy3uQZY6i#?wy)2v*3Mwo%a^=D!PtaelGuhWj z)L-hu&NJs#QDD>Apx7-`>27FLU=uoPyy>cT>dM$-LQ>$waTbPwtsU(Rs_h=<7+8}Q zlKTM{6}isbjvw4ypDelS2^O5mTQ@MUFK%0AI876#2W~Qma=?ApvX)g97|bTD9VM*t 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

Ax^Q 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%0AkDl(MLc?WjP5c2qKbzK#1Yt&mYblSZ9s3 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

FXWn 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"`B(4u zv!;2B+unz3LK4}dl?t1?UDv$r<>OmihTtQ#<}gK};Jl$!?x;KZ->;h^_C}V@o0{*3 zaql-~4!fRp|4UnJzTKeWiUB~Y+ zy3Q;fM*e*+7ULyGWR6$c&Qj=M_(~M+zdzCc33-cF_TDQoUjHa~xGH#a6nzoC!9vn` z;OV_6?GGNWezTz#u@TMKarp0BK>l|1;@e?(P{&F#&xGawUe_7GC-gkk)fVob@86Tt z59ZxTO8Q^-NoHmv&K#tCv-d#vM5Xc4BDDGh$2XkU6-Chr2=w}7gr6z@s3ogV6cD1R zWs7O@^s!LSTht2biKL}}({8omRJ1E{gQc+RFkwh*3JTTDgKG}YHZWo4eTiPJV>aIA zkb9Nz;@FBSR^@tDi`D3Gx3CY{%f)8*NEhTQNf=Mz?^qkcw@^sR6WhXm95vu0W#FOj z=Npuj`jtt7hb;&FaKR&lj89A}^2wO8co1EOB zj8l!hU^7>f%TBHcEcBD1lxxc)N*9;ep^TE0Z6_9%nuCvkav2dNv!?1QnA=jZk?gHiP#kKvlfr-xBN=OAIpnmuOm1b z#wz{;h6S-z-nQ}QEq+>lg_t%N8yg>M%a87`1-q#v48dmxhJHh#uVQK`j%yo)CHyg= z_&rbJvg@$G*74maI043(YPAY}AM&SnYb*Q{_lnR02`Z)?(n6a}%UwhL+=;n#a&+5Y z!?o@=RoYe97*J*EsY@d?A{Pd0p zA43QqP);eq2g;)bv^vnBt6gwzp`bf0Weg4=Adu0M-1&4iEXknMoN8p#zSZ#b`;u+s zYyvX6ch$$l$nJ$2M)@bV;a1WwhoQdZulCcvua@+1RaNtD`RMTS+sBgX^C)(zb7+_< zla*qF`LZMJXtXldrV3w6eEPJh@7KZE+Mg}PA*LT4yP0V5OyXbJTh{exsr}75pTZdx zM)RAggM#Y~4)3<(0Sm9zE96i%#t#@O%fbt-?HVjVhK=w^U|lxagzE5K-IAxgxjW6j za6b$g&#reat@7$To3^=|vI*a`stH>`kf?vmKglTVJLx*~ZiO96KN2h$M?)}Ywd~^q znWd{Sldd(&=Z@ApFD2wQjcTqr#&52@FKfQtw6hdaw%^w=-qdleuTRf=p>OQ?5E<1j=5Rd12DT~<+(huWc}|uY-%@i&f7^2 zS^kMM0u{B?KG7<1qlgT0TQ6U?4YCJmp@waB=Dw#R_3KE|m1~z=crn#nK zzUS=)>eEtG;A&H_#^J-w4J*Fk0WkPfG<_w7&}=CPNwGFy4sxVaJ-73)-?9t#EKx$g zFke;v(GFK4QA%nRCKqWBWhMM%7Sk|lRk77DT^ah^U+N8NfjmW_F5EY?)pE;j2;oPQ zB}KxlT-eweX9=>L2U{odqkYdW+dor)HcM$tr4ecbpuk`jWl|>dc-kTe%Rtu%bIyLT z;V^XWdi~2XzIpX>8;ckqj%D z@yF-Z!=s=YQ0Vg#xXL=;XQ*+AtOO|?!(1?1yz9{GhNx1L>9W=-W*%e!O_mY^L=x7u zcU`^57C@IyjpR*l^Aay8t>%FzZPwDoS)P=MqW73@90l_w6eY)1dTttP)o)eyzZF@f zLa_Ia*-CxVZ*&<0e^<2Puv%k1PMg#)d3>r5auwfe9?Q)xkowS;teiWv!c)V1X3%I@ z^1))cH0&3X>%Y21u;0qYLB)_(Jz&37v#_bY-=xL_t>%RCsee?O9hBP7D^+LzC~FfNwgJV=BgX5Nf6hmE|B z5(xWA7~Oe{3hKOZ|90;FZOgrDiz8xs@Mi&cd;Zl)(Ck;r!|GeDA)7hajRoDjA~m7ctE*7i?V!_oJ2ii0sP2aw z7EqNp%Cgp0ao*GU+et3>EHvb-0t@cj`R?vtK3k0?NvEyd$BN|ANEe)c{v^5)T_UD% zA_F))dTXKi%w-wn1^1c)=om%k61}Y`oTI0jB2%&_4Ir1B3q#LX?~TkBs)q<_`aE5r zA44%%sh9nE#8mkCF)qvOVl?WJ+L#iZQwJdgB8a6chC%f!oE$OFjnACLYp1or;%{H* zj`IcqSjZ6WfSc>uN5*ses2Ks?{Crtj`Pk7#){|DW1JQ~Zp>HQe7^D*LT`6hI5ZkOZDiOo{@ zMa|$LiNfuXLyG+Mamt(9pMwloK8NT|tHbca(5n#}2Fz!$j6sH*Tl-dwqsw(2+4JAq z5>&x6JT~|%|MLCTf`?Wb?gjMcC>(~^Twp02Mb~ufRbO;$%T0XpzAA6NU0lASj|}Qq zr+?TlxSObV_70w|&kwj=|KHkUurRv3o*dmNaEYt_c=BOp{ZdUMMP4$a)*{IsCJJ2s z0P@QX=~X|sUZ!?CxgN8wy%=)6&{i`_^es<$sG7dL{v*BBBwy& zqa}}(#rW|_(_*f1j*Cl36Di!-=;~Qi_an>uM-dbiA~b+hV+I?mkOC?*S6B zRts+n^EkVodZ0eCt5l{^E>YCkmH2EGj~4yb#_u!JC4UZ72m|UG^&LB-#`gC$sdRsv z^^dOKX1cFIoioV3+9z_ZTYK+Ev2bo=^LXW6;cj9I zZ!r8~@!{WHvk925s&JP-`NMLoId+B4%ihe6ba}e(J^2^-{vBg9Z#~$JBR=r7x=j%g zF@aH<4(#A=ty_AEyMIlw_rpiIp>o+E1`9wjdHm7d`bodu+xJ2P-Y+xF@Wv=)pDZ~v zM16L2;c8W0K(C8ync0`FzQth2p$*ZZ6UM5Y;!*)p`POLjw{PEnB*C(n4bXd1s5X=V!(e$cRUu)~pkRk(^{7zJh|pJN|(nbO0H z(KVD>8_)uav321!ZPsNiL^niZOyW1;5@Z3db4qv>}SakMdqTaW{UaBao^xcZJYBVUbm*NF+ z6+Qh@+*N>NwWAUSV&nO9SYmsP)%GQ9i(C{tVdTQh>HKz?5=@nY2k7e{uavct*HBKR zc1~dM^O#r+5q~j~Ln>m-!Kt>0|KW@Yl{a|0*3fwBc1Ne6CG{T!YJM1B?n1K&{4jQ# zdnX&>m7i)1W>%MfSW+-sR^y(H=Xctz8|#FvF2MF1{-u>@DrPuQbwv_KoJ>-@^fdY5 zCc@tkw}N_~Whdn5Z@SvA(waXUy$3JZiZZ&;d}JvJdi`v=tHo$kaOQypU18 z=SIsBn5$MJ>-#-No{*jDc77HTBaS3xmZYGm{ZLVj$^#>s?ra%#{{$GQc5RQPjfr|8znrBrLhM?$dbbJT=vy7v0+9(*h?# z)OMOaL12)Il)H|p7>(wBAWfubiq{%%;XZ>jrD{()(j_q)HCuxshYy^(Ok4z1I3lN4!kV zvczHaMq-z%9cUW<)k^++U~bVOly0tZ!!)$?&SZI8=+!KEIQ(EHAoksavGi=1U_AX= zPv++$3SYspegx9wvFFiA-lLtsbA=%u+SS&`p z@Ax>s2{vlPJE*uj>}v$k%$(WT5RuN>8H4Z>5uC4IfKiTM?y}wBbnM71GF~@ea#|>t ziqWHYUJ2rUx|1u&+`jA;h9)l2blLBwQ?~pDT&)>o0wiCEO@}Fd=8-`ZDIBjZ*Hdg- zeCjgDa0^RDHi6rZUI^qAy?VWz|{@80z~)u9DNj-B9KO+o=_N0bL~)P{m12xgjhXnLZUq zM}9Oj&{6Zodier_;Xdaf$eiYyR&7w{q2f)zo@X-=;>hCLS;75@fWk@kc-YpzOeP5x z_Op)Q3SEo|+N)|_3OgOGApEwGh1Oe!AFuT%QIF+&3P1bbbVE%AEuO(@x*5MKdltAt zH`J5%Rx@{_PP$5rvc3X1k?|nC&IAv4Srq^7E!ksIvUW}?8CIY`@*eumtvPfzWQtvi z_+>$-{pZDPd&>BHHFGon@OhrN4=>3Wg6`JyKQ4lKLNB(MJ64CbH2Z;j_MiKil9ID( zmAAmk+WX34g_en5Kfqg~S<_g3#Psb}tM@Wk5Tm1&G>Iy1(CBxQk1=SFV;+6|!;=PV zdRMG!k1&g_LrpY@Qllp=EBJAGSNonsBG_fTaG>hS=@1OvsZBp!zH~CucsoInDLWd_ zSnnjPn0G*{7u%UwBrUIXXlP*lc$`bD*2Qj1?@+3Dy%3IWFR%|ScVnW`K+8+{&7UL7 zHMwAu=&uZDHmCksLz#4~DRE~s^aHB~`VDc27UCH!2i@@oga?eU3(|hU*mBeo;~w2W zJuQ##!_I=wXSb7KPx7)C$4|pI?9&@%BTy30xu47i-Czie~b^L95;W_v1@2ZBN zS9PoHi_WVM>Z|IXy(Pra)6+HhuKF$v3{4W3ZeZM=i%+9hi>@xRxo^yV6 zXgdBVbG$wGuH>?`f6`7(%E0V|=Eb~7GF+7oD(&o`{b8gb5KOsl`fjC0?zlDEFo=?^ zo<0lZckHs$o82y2b6QJK7)d_aKiJ&Ak_F*T0>6-HKSS%{ks4V+jG9b)mM#UP1Op2C z2pQ2jw-r&TXf{&+!SLco-1UAL}XeJU?!yFWvtA) z|D0F;YwW@){8f2ge5=)%Q@)`KWv4{2#+J)Q5S^4g8J3(i*wss~IFSyS#}WkU4*G{@KLy9~0t|H@2bf}8fhq0A+eW!~Itglyn7 zeo)^9L8oBgsU-aGbt2bwqU_LhYTywE(&FvnW&8E8V=M!g&)ADNmF25-0BOtiT)Yk; zX*G9Wd2!%H6V!1tQ5?Ghp8G#x@RP7+^TX5voAEF3SZU|pgC5f}58|=PpP>}{>1OjW z_b1&f`+ietRgcawHFjQXAMSRe#Vi=rXdUfN=&}c7RXQw%nk@&8Yj|}HK33qp!Cb1B z@H@2L#6^9X*BF5^Ks(p>VJ{*#P$C!K*OSdW+aRK$#&`kJB=dwxgoV>OcW9&>4m_W*tMRW`|sJp}=x*2+TX&Jg?OEwRpZn0=Ly z&VY|D-6NBi1VXk`aY&%ez;YRqs+A^e|dTSj!TLpP`oMB5; zh}!*XR7{7IDH11@sECHBH|q(k9ySa(5_e`xMpS7N0W4iRv2sr<4K}l& z3`o0wUi3|TFZoONnT8jOFl>I10xTPd790xZ_LSKd#AI3T9ISi`-BdCTE9Wx@Cuihz zc&*$uxkhg^q&ImUH0yuhN*gk+ZK-<^9D^9_T{$Quf?t|Qm-yIf*4xqc?4!9488&O_ zM3=sOmH#1C4!U04!#cn|QY67vDK|Em1@*pTLZ0r=r@CpRZA z?1^uBT%~&Gsk&|6Lb)1Lkhp30J-k0M^YiLRF*`2{yhGTCX}?)I%`pRTsDYvl#GToF z!QsuO<3o{+#9Dgv#%faT-Gun%{Ao>G;40er6K2?0VT%@99wV;J^8MnG6`Touz-7PN zW}}Mv>=sNIRC(@QU9jq-IxXC{w?g3DwCA*ccU3r@BQ}_QhI9S zrt~diFsi;*1g5BRqRu3Jvw>u&MYXhUIwq|)H4kTPg$ATuHuGCWnnOPiBSh zdd5M+-Ss;25cVe)VimW%feAgh1r`q`{+6+7bZST*Z+uH>s#alUIkWsLoQm+sd7Nt4 zNi5A+wkvshJX8W(R+C?lR)F`CqI3(hDU+3OY#JBw$NgAa>v=z{*Oh1MgH>fdYT>&{ zz5<|)P&NT9LEt|h7Du6_xy3VL=e()!&;>(Tk_Z))tv7P|oJHu_TZZ36;}!~0gD}xy zigI%F$u*(qgkw30S(fu>c3b1l`iud~VeiO@F+aHn_CqTV zCYUxkE|KQFPJO$jP4e8RI~&e%|(zU<}Inx+CEH5e!@tTqN&Uavc?~ z3OFy9UndDXCi%f-nw;EizG3dSj7rrAC~Z1+`j*a~0J%t}9IsvN+*dS>PYN}F1dTAg z>Lx+)IvZ0!_S^Cd80Z1uyOoZsqsxG$%LA76`@_ITs>frhwtefRiz30co%1SRlcxp~ zDe!(O@V?TsZ7&h84N#W${|KBLde{Q+yKmpVaRF@@hU8TjVe(Pb;ca_vz)&XL0A6P{ za3o3s2K$@z-23aL_N|=rl*7ig>&FwOMWVG81uE~esfV6G*oObo<8Ia6pJ?Ety&raL zJso+x=(v7(-1z4B_<8AWm~f)(sk=J~uJU+Rsb2B5^)T`cm>4+6QP zTc_6_1XN6(pP+%}`&HW^G(3%z?_Va;yPNQ9?Q|o}=>Vk_rRqxw>swt$z~^<=qZA`* zGc3%^E&{dfXR>8JP@@^|>WxvWo;?0cAzs+?IV6_5S>@XfAzv2uamA5lq{TSzH=Y!~ zjCNu4i#^xkfqUfK$x3f+h~CR7Lw_|aw(H-;!RI3uH{}u!YQ+m4CQV5njKs#Iise(E zxFfGx%kR&eb;(@}IEOBHxFQmDhbI@fXMHombwAPdF2Ewg6+Qea1|uWkk|)0-$hWnxukE<$FoYBISY`c64gxAT|Fyo7WU?2h2=F=hg)U8z>cIXD>AY zs?sld_w#hQs87JHDaY1i)dSVi{Xt-dK6}GRmJ&;f7I3aU9vNqKXoO1;Bq3hEvx%Gj- zeH^n3Ycr490{f>^Qq}f3n5lO}2WL0TR_<*Pb~ar7=5epNOasHk#J7VF1GH`NNg!VcsZ@fN z4T2iZ5~Se_^D2Wih7RVV(~^S7f|X$+_!e$k0(I2ybufrmG(Q9;jrJ6sz7ZP}f^`e` zf~6Xh@XeuULVn--8RbSYN{RVBm9R=U|2#_i9=`f!@-_uS!gZwnQh4jO?0FPxb$Eyj zmSr3|sz(JYUD|J~MUfDai4pDwQmNlxQBf?*dx)83Tg^oxH5Hg%@rq!TeAM|3A~Jfv z9}}xe#xN)a&!)>q{|nNtp%@VEFLafDo%Lk}?V4hgir9a|$MFwD4{>?+sFfb>1e zkR7=z-RZ;*oDTwjWjJtxI7v_}l;ntj

%ThU@|n76}8Ibs1zm(&k0WwO%3g#>gGbcH9mBHF?}K~O|_)jS>Xo&|Fbe}6yt&i>UX^?v5Yd$6 z{Z<yH z*fk+s;jLGm9>WEj5GY18@SPGOMU{Si0OR4?FnZM(^s4^E3s*()EFlZhbR9`gPp98E zE%PQzzxiufLrRPr#oE*oJA>#UOib5S_Fqy_P6_Wqcda&DG{inoEIquDC=B=#L(vI`{|h{Puio;Oe+j6KE%seH^UWTcr`jIetBeXw zaB$+Zj9rKM54{HBq6dp5u1odWcPBlU{6|-A_qzc?dkUp-ZA7%={N)m50CUF!dB?Fz z$JGmUpH;$+mA#G&g}{A^)6X6EFPAQ2Mj!8nUyvLC@3+ql_;*+Cc+;PTdbO?Kc>UMW zR~~!L@#a1gP+2Xux3@p^ncdA_wqO2;HLOYglazBtkMv`~W3Dif6WC0T^rZpdiBNad zTxq$}0~ceySn((1BuHg!461Tz3*1a z`jJ5NSbE2JI-6lFyfwT)7b}kjEo)kQR(uV4g329XNz>*+!{wSM&)J7!t< zsbx&oW~39cfPz&|_2WuyM7KQAGnq7ZxAP1$@f(T)$r6W7(&Tm@!Txkk zVYBBQ8z$3noh#Fa(Xu|<=27b-+3H6~6*e3X!qr(^V)LYM1n1u~_Ph z-7}_VN@Z0RLNI0o#d_brFt|lHWPcKjX72jJhX=-}ms0w+&<=dTa1P;D^3K;P+3JZD z(cy4gWtAqGx7MA^8pv9RfronMLtlkz)N>1|b`|48tvi2aN2d0S%=pE#F?BES*|^3* zzR{0;-Oc$@LoGOD5aEn4K(0i5PLl9cXMEeGwll`V%7*JG|DfI@vh z-BeAs#|pLTvE^}mt+H{oJ3PYdes+p7t_^vafy)~!$g|^CylWB3>2l$+^>*P9kQJC- zC#JQ&Q(JD_%&>1?o2)`PN|HR+2Fm1U4}2lh%NxP=b%wxmfM;J)mEE`uT)tfG)6Tg| zrqkUy&3W*4^cnY*d>m?Lmzm2X;q=>&dpuQtNXorgj*xI`6?kgL_oaXpgdsMLfOAJu zf%zHS1}+qEXb{?2die%f&m_pZDZlUaF<>rjoy>8mx2-51mDLx-jzNSPu#G-(^lhUZ zz@+$4suKqXs8^Fy_q-1r)TkL(=;iiPZHgnn=KT1~CtLHNW(t-X9nX|k{q;W&(9A7e z=Qsql)*%gCl3ewia_|{;)Yw5|6&blrhcYBSR$e;OMp1>ZS7@vPlXc9_HRGI)Y>tKf z-+O+_>84;Nq49EIaUOFiRHO+bA6WGE|4c8dF<6+4%FF9W-)=`|^3A0$ zV_I}7; zWIf$Rbv{_3{K{QlYoeTJWXkbRHQA(E=Rrp||1|n0qmfEsqqmJ|&K>2YrJI)9#WQb8 zv4heLgu+l(aH~>idZn7LT9JYP8aWTTCX_)2%B1;ph23cM*Leccss$JRw0AI~s+jm2 z!u9Qi6}w3`diimTFLPj{_pbKT<>XqmipkO&aBRTmme?}2oJ>t-81<}Z!k@sz~< zY+CDj74p@9JNrWNk9qgfv3Uo0ynpyPo@3}m4&XUcySgHt2X~UU#gc@T zY{0C<%X!yP0Bu>{5!%91#oa1;lAo;Q0~(KzkEgfZ?Y2r)5UwGD*p0N? z{yqQEG=9eVQOcp0H-==a_TT6Beu(2-RlIDnS^s3+esaLU8DiHL(AGv5qfc-8iYzU@ zN^6;;Gk=iD3ayHt=_~IJQ{V)AKu%f>KWW0d^V8qolF{QU%o?QZG840|J59Gfqqz&7 zVOel)ayVS_#-ABBL4wkJ$#O-j8s?K@1Q)J%Q-K(YSH zKvk~nSC+24TnIW!)NEoCsFND^GmcWeF$&Qa%mj$a)H#rw%UM`|UZ31NZ5oyCp_J}6 zE{2;ZvR4bkr`<=Ov0OSR2vcGH1M%><{>qSb>H#Ny#~13?bQREcbrtNC(j^MpjkJM& z`P{2lb-GnzTpxMM^ZrwlO}v9Bg}j7$X{wIIw;N_Qv!sE}yAYwz((8xxMEbinJ3XU}4%p{yH>uQR<77E0ZJ2-sUI6voCqwmEH zZIabJEip!$w?we2=67`&z{6+c%Pw9sOOhs)NwdkOAqnyhlR+}Rg|FE!EZUx^GfPDRrc3g55)D+bveJOx=9D1RnJ#q8*p|MmDBR6K zUMCDt9&f`(AlYUrTYqoQ1B|gV#GzXMuK$k?aC&=Hlon_e!`kt%XL`}*7@&=v34oZ3 zzyeqbT)GYL?USi&Jvr7KH1S+Gui*0fyYx^wg>+S#`>=G-yvK=z@Y_g<>)5MoLH6s@ z^SeIn*dIdde-vD7q*Yii^QIrysMcUdcrt`kUn=hgT0)mp2glF7|2F)^38f;ar9B2@{gv4XJYIWuVNb8B!-{Yri{yIGUwZU`Lb+CQl?K#a9cd zl=6mSDncfq7D$GfvWRzbXwb9!S6%79-QWBBi+{~zVAv5Mz?~xY5UjVTp2~sp}ykFt z1DD!t3?J4g12@uBmv#fW4e#+@mp^t1dEB=NdB8=P&ok30!G791Jck5?NkJ7yFD=D$ zF-IIe{SL5#5_qD(gr&mV$rWOmnQc7yl0@@P`H{`gSdzUvq;w1jj7*cbyBZhji+IZnOQ zGsf*)aC}(C2xW1({r98e_{~xs(CsueHTeiXb$%FmzyTKap5Kk!I%HSm{m&c;Wla^; z$mR24Q-h(QK$~(cG_HtTJIFsL!#zHX-*QE2=?{7w0hdMjS*?sMkVCd5HZ)$N#*ExT zig$2viG_>v)^|(Zv2T;2^f#~eN2YReIYp{l$3?#Res^m>p`@w^sKzutD7)$k%hcT# z8t8Lb@uDSDUAm_1s0|&pnE4Av&kzC^jCb2|^DuE;C>!4=BjM55*ckq@3Nt!Q)?-qI z=H(gZU8OW~Jd5|gAQ@T#^YOTPa%*oZ&Z#DO`)Fz}+TX%3%~@a5t-%K%dM?jk%;ic8 zT9c}}9-E7kVU5ZN_!ar7#(8DzHwcuMSx1-NSvdtsW}IOZ!7kJLmTn?JXn@baB(2kD zO6f;Kj-1R&x;!nj@#+3>?WX2QBR&WkEUJptem|gl_)!iw>Z~j4l$%{=l8-PU-43vz zom6uV2le@XO%zZDn*nNoefEHq+oaLcP_oRK*XJ+t!e!Gsoa4YU7?_IEU0Bv6a<4ZH z9@uxS(LX#YW#L@tx^+h8Xz1klm+P(3qXnT}MipHF-7O|OnW=iuK;XTj`HYJ1GLbM< zxxMpnspR?H%bQt9i%*)}{eJn3P%$N3BOu;a$@;_Xhr=#8fASw4UM*Hi{}S7vPckn~ z1GK_4YzGmjzpcHOEt_MkhD{ju zT0a;5vyV@dnwDF;(E3r;m5QC}rXGo(jp5BNrvs=%3D2u~)UUBeq0Z8Xd8MgBHF{7& zlY)x<5+stl@ep8*w3KOO_R zfN{INAyRd&gbK!sBxF#`8;P!Jq%7xSc$% z?nWQQkPaS-1OpE-B#wNMOo3YPVLI;4A9P)L==ZPO^gcuPIo2iy614eW!yIjcE1<5| z)orcq+Iu)y@?M?PTk@VVdE90Sv`euxy9(J_@>(;B+~&<~y8kA)==Ig(enr7C5_Il( zcjGH@wu0w>NBCpW2Y^QW&Qc#wj^n6Gvz}^4R6xO~(A~iQ0PA<6PtakM_ivfsSM2-S zM(eok6h@4x&KBPy0OxuM_RTi$i0@x4CptHqYwL9`n|3~v#r^(uhW&@B^SRR~+Cjk& z`?>Dlrt$|hJ%#wHA}dN?Q3G)?0)1M0FQw%W(Z!he# z;A!+&jGeBO#GzrK{Q2=x&7AHgB;M}AHZ}sh#5-a!l?w=L{$!QDhTeHP7|!X@+fx1t zEkax*DEeS3riV=#R0X0qOvL)HN(ygKd9k%LaLnVimxd% z%|T@b$qNg$`&Zz67J``QS@K@hUZUU)TFP%312l03v8bS~H+7qR+#fz}IP>X-L~9VJ zbrURdfJi%$`9`SFz)85IK#&Ca2JAkzAqxn2*1x+O{CtYgBKZtNzx?!p8xPb7M zLudSCrT&r=!}5~i9MsR?+fXE$ceu17RPjL4k?X1B9)UYhT0Vh);k8LQy_=%{R;S8! zLVD~j!N#V?^@(n{`hbMmzwWRG|MAILhddj5AHw{Wm)8S>4W?A#@`>f`eY!q9XqvC_ zZ@n>-P*xf`EhNJls#F?#{cF0$g?`>bir)g6D2k!S^(Q&YMAVL^2K_PE2}EoWCX_XU z_`=m+r(5Va7dl{X1Pg;=G4!6BXzpi%J66qI4Y3mR7&;96Lm?*2R6%|0ujQKC)&ESU zW47YAW~a-4-4kIvv$r>yVo2q5@8;pnwxDga7wSUeKu2SQIZYK}^G;%iGO-o2_wS;x zjI%XnHkXEgElhVPGiV)v_P9(~t*lF`7fgX-gThnNY4e9v3Xyo5(O7fBCG|jkOc1d zciab}G;ZbiKKwDeaV*9Gd@PTfnH@Xi$amXu_g4Vv=VqJEb)V7k004#ZauTQMb7t2R zOU{RF3WQEKXT_5DvX0(!m#sTEX=VY}FLEC5NW>nmkFVbdF5N9SdaZ@xQJMxnEiYLh zBu1gTz3a}}j_sd5M1qgG+Uloy-^MIoukpo%v2B*00 zrcQxHB?;ChnY(zPIY+V6|D6c~I!oN5#6N!fGS%C5uKZuiVbiD*7MN*>Vb=MK4(-Rq z7=UTv+vK51X**)jSzh8N1#&4a&>)eRfFTdLw(qkox})&OwND3iqAqWhGO!cF z!pYQWt(PHU4x=He3JiH0%hHvR*ciy@(c}8&c zS<`NDH?lZ~muxzNY1ObhYd8Di2f}x^D^*8y;|-L-k`7cO+$YE2V?y7iYMRU3;{6dL zWdlJRy1`D>31o`jygnB>$mT=U@10!3?Z3Xu!70L*h&^jDE#0QWwA_!}8EfjMaNioL z>o4pfNc<{-Ms$Y)13)aH{SZ)^Vm#} zhT`R)R~8adV&)MlTQ_!3_aIRaEDMHnpugTqdJ2CtoXxxmOb+^0Q*vmhMtCiZ#;%np zQlQHqyY17dnZokiVpfdk(DJttmHN0)i&&v$#EzzJ3Qwvr7EwfB)F2WKW5mE91@1Wh zKPPBd09qY9-2nG_ZOhC2_&j4GSHcii4Q0%j!tkiBE#8nFi#0j<g;HD0c)B87Te)AA_IpG7VsUJG(pU2~oo6v{*2c2fHD(^=wDf1@ z$RZXl!A9O^>b++&I>@|IU+jdpAX|o$=4~aL#zJ6dkmgG&gEDji5KMYcsZuPhvU$Er zXv%E*PnS8gcWy-Of1)S=)m*8R?qT3^@PLVPUxegc!u1x_!;ymNRS1c(^YsQT!2=zJ zmFs_(mDO75l-N1oJ3aygB!sz==NZLnO95+uCngjSq|B!IFHE(w3p747?;*9`?R6Y{ zBCqrXn!Q`Sfb*%<(~k3hRaXa79k`u=*H;4_dybFUfZq}UF}y4XtYnWDZHM>KW@qvM zU&ve4cJY4Hck#6S$iU3$-hIk{pxo@7@Nt=nvY_*6iBbT9743e?fI5;F5ga}g7z!Lm z?7L1y(>5SmJcOXHTYb$6JAV53%!h>gE)HL(A!2V?!aqbb73|p1Ms0jfTA1yoT|>8} zCstlYX3wOFot*F%I6Yi0h*w#$nXwC*o5>V92bxUN7jg7MH$B@cH!!DrZKaP{F!4>NIIa8kf!N%y{<=kueo_+S&Ap~>HsOHcpD=qQa6 zC#GSE*k)39#HJ#Gs5Qj0SwTJl=YY7t=E+cCWr$mhh4^sr&Nrq52GfW2MONVY4rS+d zGk}l=*G$ORNN!|R<9}dD|J8~3#U-`Cvc;}7|3bH(c@+5|N4Lj}dmEp|vP)H!W=oI# zezlZTR+|?|`gXcUItG>=4nv6BqX!pm2Q|8qmg09=sLIH7E6Kqa6nCXJi)f%x1kv5 z)Fw8*=B9(f$zXD7J#7j=w2-*la(rMb)+u=K$R7 zRS$sDW76!ley8W@X-pN8st2ptMcU&@tbdjNP5l$@D0!VEi7X`tz!HKF!;aU)NP-J~ zr+Xc@Z}7y=mLao~?hEHrCYO(Qw}FAD7?NJVgOuu_>T#LrVb<*aFz0lC3;aKK{sM64 z6Xq3FjL<9o;K-=pL^(Vaoa->OrYQQ`wWE`UkE=I3UCc9Q?><%&bEh>wXfmV`o~SX> zRKmww!%Z%nS7t?7{JSn4ltma351XQ-wb(DYK|7|oQXX8Lh-%9-wmD>W(O*fR`M zq}M!p(?8b3*dHl1qQ?JHQjsa)dH@_n&Q4pHR-`ky3Xh_EM#6*uxP9Z9C$~H|k z*#3Ty8!9s3X7FX;yf%lForFh(CnE0C7{XbvM3lK}B|EAuuF*YEAm_MLdoPFK9Ka8o; z*v|IhG8td=GbbXE$~abaPI=gKbtft8K4nqlC@ypB;xkkc_#7BaB1*VhDV(4doGvuH z7V)%=(km+ZIZ^V=y=^>-MK}w(DN?Db`d@5HVm`C<%EN^U<@&T4ql}_rxwVyP4!4xP z9!@nUBZXBxSAlT4dBVdhl}6~|D%NDe(+OAEJT197nD|^XqNmDYttdZrA*2*DkZghW z^i-&1^S4lpp^~aocb~kF&Z$rSkZAj^-=&%O%6w0O$)Lb`J_z#vv3AUk+lNa@U>&s| zsI;#KUTr$w3@`am1y$WeadiMMp>;+`o+MBJ3@pyleU#%ZmF~G&$0$v-EB-6QurS8>znsaN6lxdWyu$}j`JKh6@Ad@_rGwxB!5=rqZhH34aReA-XpY7vO zeFauyA)FW8b6L+^l=`AZN+ep6_AkYL^@+VGcBA&>b$_RU&epiOPNNE6^CUwy)^*j^ zv9Yfs8w~~@dH+s<$$V|X7kVz+0|YGqvk%~QOP4xAgaUE6T&TVBtuqVwk3q`SLNW+D zktQPys%OyWF?90?V>)8&&Q@mou-Q6HRB-S=*s2-^KNsf$5EbZCi3hWxPR)~K_?lTy3AxxA_2$UkdY9$qZo51+6KrSepp%TJ7*RFmq z$HmEAmbxiNB$^>(K3`5L%-Z{vy!e_OxwXbWgdQ#PiI8oR>h0`$E~uPt`n~_VYmTq6 zqXlR{s1k_31&{|4xi^kJY+{D=Md>~4CX+0ke;3g*``7pDsX4M0deciv8Xmc4z_I5M zLfQ3mcycoISc7j01|NLhWk^9xKrHv^i=lL{G3jq!x;QE9fXNtG1-G1^1YuQy6-HF> zP$m0kb8(IH+X+`+pdhs8p*F!{vV*dE(5t+4enY%qw`n#OiGMdhGZZlpb1 zf`BkYNTM%67nxa6S02z)T53#Fe{y`cKZ5zDi^45A{v;lgtqJB6-qIz2MT4Oo%%mRdRF8T{_MGZZ% zDPoh}F7Nw#o%b=#7E2U2c6%PVyKn!QW!+HcVElc@EN^dded2XQ;RrrZ+x$AR`%X7pr=;cP#Vsp9rf~--!I7c&U6Wa#kSsvZjBGX5o4=}ZiE>&|nAJ`M z#IB?Wwk4}M4gs;w8D#Bx3kW-Lv@@8$y!6vM1)$E!O4kA$1FTAMl%=n zHA2aETRI9cAkCh%NJ9+~$8*MivohwLojf*KofEi@OE!ChFuW8XW# zb7H^xkZQ=P^l5ujz|;w269W>F*SPI8%juw&p~wfD%iXpDy5*lfNobaZ{^^<&EmZ74 zHdUl#4sqQ`(BKm&J6h1eO!aZay~N)_16^woS>2v~ap;m$wM%tHr)H#vRi`71#1{BQ z4ZqPnRg7Fog>w}CPStk(#`hV&qO*cUG)KA@yN*YbwoHo#_e+HVJ65xK1T~rp>+$^V z2V|r-Gi+#<1gZ2aUnXg@nq`)yEKCS7)|%p5qf5{S21VmwpL<@TQ^ywbajm^-QEO}Z z>>aa!^$sc$yJndX5x%hx#kOGtCH}muzL|_Kzw+Wd*E9PoE>^MRy)?VYz4&+}^v;w0 zToPqG{ynhS_-Qx3q+2DZW{GJ4j6o zvCa9*k_}3*<60$SPYf%Rdu{(?}56>4d3qxK615z|v zg0m!Z56tkg`h&p)b`S1e+GLSewa`fmNK8-sKtj=1r8<0%RAA7GvQpxNIo}`-uIs5Y zpY~RQkTii1vMT*vGQrTbyC%Jr)k-q^2|0#4{A0C4^+)c%q~e+wideCNd|48d((duv zU0LOj`wYFu`ijbFQ1v*e!GG4LEYLi=&4MAe(Hh(zRT^ea%XUNd&OBc48Lowg#r8HN zEOrcPl2`SY?HxB) z4)P%)Pk;?yFE8I^mld8ZT zazM9xvL!L|^RV&$VtDwQ_>a3|AgjXcp**n3+v4;AgL3*Fn54a#xp>z`d$L|EM%G#U z*r8s&+Z7QoS#DOhmc;e=t4ic8-9;w=kq6`XVf^{(^nY4_WmMXe@5K_s=0=%DfMUYt zr{dH24Ivyplz~$7bcDz_l8}>o=ZebxXa7me3n9eAbX&8=8czB8>`g-&e^fp1P>F4<}YZK^Y$f9z8FQ z@mQDaKe%7}q|gyUT-XdL5bODGKvAy> z-57CKKRNDc)p5U1i0p*)31H!J@E@}(Cf3CY#|f9)l|FwFj1aRy?c8@#oG3ukTxbi+ zmX^*qrv9X=OKg!!G&@8c>km)w1S0CSIZbK=6zJ_j(&1m7oDuT{N%j&9S!4)$t=O)V zXf3}MU6Zxs%n)~ zG03H}e~kF%o~f0I=b#MpSYEdHSy^?F_B-#N(Z6~7vfl@x*LRT9LC=p*{>uUa=S=>( zK6nI8W&&a8&r=snl384N9Ii0l=f|^*kxe@}s&xY<0Be3a;hUnHm#z@Ztdw!F!xcJNAzSH#tTtO&=>c%9SzdK$$$KWNmhAOi} zR!5+|Nd4n)${=Hjp~S+#G9L@KPi7$kC2$FYi34IFv!e#Zm4jBBzrHt!`B0kh&XeLp zK`g0JUAoAiL69XwcdB5s+lEMG6OXmYXqo?);qchqF^X(O{XZ}bCY0`yR0Z<>EDoLf zyTQ=@r!)5H8nwjkIr^#YfAV|y36#cLl+u0NSAX1h+jV=TF=-^}y+>yf4ZLrF5h$L% zFPD@Lj*C5La0Fj#^*S8%QLa49bP(F=VTlUpzsDM}X>ru^67Q=RNBuh*=at;X!WGdl z(cq|=mdb^DQDTCFbbySKJ!UsUM{d*H%iB@RTdT|^Y>q~xj$_GancPt}xe}D#!Zoaj zFBkfek)6++%edhbig^e_uzva;~!uOO?u`hc8t1E@CSzjId-{yIrGHiuRulUib* zaY?azdn2_5O49;9+h$vTZi}cR%TwFL^5ZN#rN||(QPW5DnZ^`SL`F3bHW?ZiLQdO$ z?;_-p>@wy^)q>|0<%zd6*{JQ9JJq2g*U|NZ&FlE0ypM@oz&wH8XkYx zBWdU#_Nk!62W&i>gV!!g8vY-66p>$2gIp#7rI_pv7~w$w?Y>F!+(Q?H=P=`Pof;|T zaN(*(0U{KA<{Shs9#D3QUwi-FE`vX=pv8B}8>SSdZpnhtYn+R0eQ8-CWTk^PlsBCW z2aRc+cbVv}pnDa*&2w7(D9rj5f0D5DtCnD9@9r)pB{e=TdHVbBs+Ot_;RCDTBnfry z%3&p>%WH!YV-2M|)Ia?MOmGZeV<*e&hkfqmDO3%C$*gfruhY`96t*80?!ih&7^B9N z;yK_*HW)e_TOT%|zq1DVWCk<`J_wVve-@o5!*!tp{IF{I{{{%eJE^_&MN%VCcAV6% zT)EW69kUL{KVCX6cr0!Dll1r5&McFg5D5QB9r;#e;^FWaMmZ0r^zzzk$Kd+lfMXY4 zG%f`G|2W&z6Pqv~*n&S<5j6|iMI^#r(ec#`!T4Cy%TtI(;W1AjBCK?@9OMHaJ$C1; za}|veH9qNeD3_+DCn>&`eUt%+Wu%W$D$fRRg5QvhpdtDF`o%C;)pS+pN~3~w#IiKf zx-CWYEJnji%31)Q@Y=;d=PToy@aP#UD{{zgP7(qg!Oo0w+@e=kks%buDuv`KETro} z0D9I#v*^OC;DqD;x**CF6VX|(>x4!Vj;4xMhyOWN(L-Dci;&QD&;Y+Pt7My={6&ws zuI<;e+$7ZJp7mMokeCIb%JL}12@~A`F%g0UWW|HT#LNi(D|#x+16_#%Wj7(XJUw!L zE=R910p~Zx1fiOqiV7V)D_2fdIz)F?Shzt}x&<1OP{PZQ2z=h~b#y5}+P%QTzLizC z39%VsAUJTU!=_bJs$gR7oq@*~52p-+)6r`C{Wy=UBe~SQge)vbqk?g9%&S;ZO>;?a zYg!siuG!vmQG{r3hJf$4eH%^*j4u`olv{E$TH3|DWq0w8F)dkKJs96g^nE{^X)J;7 zB7Fb$ZyEi&KaW9`$MBrn#i`WVyFItKZiWavX#qwsR}yW|gR%xAe|-?yp3wEBdtKWO z{-ZX2#NbSlv|`qHrAfg=9+bz3p)fljwhNbKs!HVh0Idm$j6~|p{^i=e%3U`A;f2UQ z+rncM)N_G*$IKOYyWh3_3$C5`QqCKFbMJtHfdq2)WYmffH6R;lDYKre5Z2+;q6H!Q zDM47m967}|`Un|gO*Ta!oOm_^r6Gk1k+3j^NVI4=_w29hL77}w>+;Oy9(aQ#@mwwq z7NkH38|kN`*yCM$C5QEXG-Be{&n5e~)zj5#T6Qoy$=J=kESp+oMMmxC%^F^BiL~E# zHwxdBNMM_!UETH1T9e;zZ2hgfF~M`-8UJgkk6n;Kf;aHr&i?;@)B!60EL^XSjWAyH z;lHG60cWUJ#G=nHU*i4{@ht!}xcVCzVl<5pg;#XS`TqGCb+HDMy@cV<2k7%Ovy_qW zUqmn}XtFZOyqkUYqh~?d{P~+T;flr@xcyt+=-!$NbY=z&&^%l-CMP{|5YX{K=){aL z!+pCZ@d|5)8Ar(EGiZ=&xFFiJkZ_uoms@t2Q&RQeH$3ncpF^pYVAD}0;Yc*&pcP|I zKvEurJ!ltgp%~rQFH{Mtp-+7mn>8#(2%4X7JM?uY@9$diU(!CeaAtxMC?Tp@b+wEX z5HfOa_YF_zn+V73*=A>+qnIxrEygByR;p0&^|;hPXq-sDVG<^_ltZJ7-V0E0;0Xhi z$z~S+mdvsf?+`WpAv|)72|cN+E_NoXwoA;NmYjY|iBmAZxWC8(Z3}r1TIt!Eq|%N(^Yux|Neh=4x7+rDvc6FVq&D{p9_viWc=yg{flZe zflNqkm-neb7E$4!hqEmM%-;K~e9+f9MhrL)3YWKVV?@xo?QqjkA0@^vQ~sfT$E<)M zGy6Hz=Rm$91h}szzNgA+x?B?zzoI!e!Xr;IS4y)QOYB^E>!H{u2M~{`C z12mr{t*+>u$u6}yh?X(F3-NNZi&9XVRX6|FIxHP<*;JRmmQRoA3}3M2qn>4%;{4HeD z#&t?4FA~m{*`^8)n}Ft?vzkET|iPmIO})Lch2uR^T+OW?SK0|^UgDK&pr3B90n|S zB_>L>J`=RC7g%xo0kiOufRd{Iw~zOq@17|%H-xQ|x9Ee#)?a1b;i)(z&$GIx#98c~ z{DvjD^f`&g-`;~x^O6{@5Q_m{9VF-^4?6%)6AXS{?Kzw=?YA|GucK2;{7%C z5KHNwVdHRk>{%@;ksy(Qb{9mp0+4*bQuq+ zKFO&j=|*5Hz6-+$j!*zT>E-A01t;9IkB`6Ect$|~9$SdMUx0@a{qPcNQb`dp){i12 z9#JXUh}FXM#BL&bI=-l3tPHr$r(?j{vld1=N9B_=)n4`%Xs+u$N>yYj;w@r%&g~{# z*yOBX<2Y@^5yM`v!xX15t}w2T7X1V(vS+00>xCy(lMIfYQ8U?uk+`w7W^YN2Y%<~( zztF5Xl6j&uAZ93$X5NB{9zuDQaK-LwN)fGQDenu<=o~7m`w_72eHB}?QtjlEsQxkAvS54|5%m3&gv1x}{jl*=3)xSfhtJDRC)~2)Trl4q&lXK9Nk198SC;$(iCbD% z`jUf$~2 zwH6^z7;ipU{1kEu#}llR@{F$;vKR!rVZF)jUl&j=`A#A4CDMB~z7FQ}BA^n>OVQG& z$40MnjG8r`TLU5~m5ZV=tfgq4KAFRn2Y$r%Qg~Lby8u->g$sBQZjyM$ZNBWLC1VY^ zy(@p!#T9`y+6&<(^^h>R%0PJO1=|1+94O>8d0W{u@KZUKHd7e=NLOe>WpV1`Fb z1p<}Lq(LyK9VXvtZh$g70dL~nGb>e$b1Y$S3kyuG7x-yI^jER6{_^8jttrr@$){b( z1CDpO|GOUj-=FIVFmzxguZu%th3Z@x2OV6mklPu;MxkQN^dE=U7(?(UF{SgES#q(k z8NGDJ@I0*JUvg#5i4{Hy8hfE-k)Xph`T`uX@Y$!|?5T*J@bH)$c+UTuUQ>Y=f~|9f zdOTX68fs2EcF_bQpQbi}cB)+}Efr#m+Ha+lw+qy=fS$t}ZET1@Bmfw7aB1Y95%LmB z^EWBv?lC{}fm-Hy2=u^JDWj{KP+E_955Gy1a|l9YJj(*~Mu2e_gl=7Sj_K$s+=%&B zvTWfNqcwRkMjhZgB+qsJf*|EJUl_-Yv=MT2)+_95&mco+dDIriE-3d4BG(0HPSIdZ zqmlBrO_8Yn_<;&W=QNtvw6sJ4d&xKT^^Oj0hkleIBkQv$mQpg%It$AXye7Go%Ds|W zX|CdZggNGW6H=B`SjJM{pFQ76I^44_S@XxAiTwSfj`&%9&Ns|n_1e&?2ar?s^nLmA zZ@rlFXGYiJeD|*2-cidJ%Z^RqZvY6hcX~`H%HJ>&pF>0fHKUDacIzuno5rsT$PAmU zKD6u;TBu2f!tBc%Zo!H}w>*yC!6~~>n_{C7QtKd-_quqr7GF9OVs3DNEG)fqA8;_} zdUMU>82gbUv)ED1nCe?arif9xZ$-=RMaQk)ztfy^p;JsO^Zj&XMjHHrXLt0)Xg0h^ zJ_?gyQ3o9%zci$b;~^D5pb$eQXJ@9Rv{G@k**I2PE`ex7myfMclXhNUp*l+*!8OnM z1A_C@WA&uwccboUL*}1BlwyvKUp|k~!MfI}b03@`>My2U4w@{`LndkiiKEdq-zm4B zOP(cqLiym zsSImeF9WR9l*j4fkB1Kt!6Ua&F>nS=)%AI8BXSCqYbE)X=2Bo#(hV%e5nMaTOBHl^}@>}-Vp4MryIJn{2uio#p z%OtTPk4Mrn`^_)$X;p^yLlBHKNYXePC zu7F26mi}d3vC&Xce$z4+&C@mu>xJ&7G^IYBG40_o{ia00PHvCEV{UFR*ZF$;8%5u+ zL3+C#Yx!kDnn(4ys?3WJjA50`*fy2-n^LU?q2}D9&sDtd3pq3h+zMQqG`q^eozOiE zkH+V3!Zd-DM(5AIrfl(3b1RK;<6?9T$^iu94W|ICzsoc*&%R1*Nxg5LDBGDz#fHyG zSyNKt(nwjytHdZP=VhM&z)#+ZG4!y14?K0l51x0aX z&$q1NZEWBq*?hz}Yo?kW6-(Lq2hD6VOl%a9P<^KI>xkxLcS&nb4zDe2u1h+difT}J zNVMLTW7*DlCf(qUWxBZ0tK@jN)<`bm2PuJ)6)3U7-2+$Rh9l-9}oi6Ac6D*GHAlsYP$3&Aw7nV z{=)#=ZETFd`Hh!tnwKp<)=yN~BjUfUlOfL5U#^)sQ9J@GDS}Ubh#+t^%~4*LmM;6^7`g(T)wk8zdqdq~ zzNlG{jEF$QibciJV38yw!^fPA;Ou5b5@;qW1aCYzGEMz93Q$2Ql8Vi{EckJbh1oJ!Aq$ z%EW(S$8m{(D)60HGBp-e){^iuV`p)+O9-Pf+{eXj((na9Lf@*BYu=_qDPe%BsWlFL z5;+k0B_ags=E(-4d};%HjZ$8XN}=F=9mrufjPo^Qa|sNi!(0o^*A^(%Z6d2hkkn?R z7E1374M-G`+tFdbEcIQ)I6yRmVO$Bdq%?!00n~1jVhHbmzbiL42C8oz9E@4gIkd3* z?WvKk#6~NM1Iykp=~AI7Dldb(k6Lk$d{d8oZdZI7%$j< zCyu1WvR;}^kzi%C=4FXz;g+}4a>HHsUzB_oJ}&itN>RF08(Q)Ml79Zsh?ouo}&ChZSY-t+!U=UoADO4U@AXoYKhLexS++QF^wZ>^h_;x&u0bHDr7 zfsWY~@78$)xfMp*eqgMXdhy{L%LsIcQ&_)w^Jc>dpn(@*csBnIzwv#FC+&H#MghrHQ7V zFMC-82T{o)RcX35OUDic zGmF?+A2zI2HXb&3v@2>o9+iHg5{uY!@PpMplJBff(n)j#B%If2B_xwY%h-3mmDvD; zZLOszNcKazne^rqJTJddRo9Bb$RQx8Sk#N$_4%CP(En7%$AUHa%krjhDSZK zcW|>`&+CTQmDn||w2!<|wF_fp36R%$n{xYcar;V$tj&Qk1W1?%v`bi%vx5@;jTE?;NY13N5xG6#-W(#OB(-`m+mRIUj}kV`HO%wHMT8( zXu@1vnW_MWb%M{VgMBdfg_k#7+{meOiHD0QoJ3{LZvPwl7(-9;^#VI zA@y<^le6Q1a27P~hksxS`q1RphMiamLY)-u@Lx!NZ>VS#Jshjgpcwnwe8n_=F2Jf$ z4nHv7CbRaKXYsfJYGYkRBv~jEw54^6%8> zrl+>CljG|tbkCZTeJ4Q(KwR~V^2+(g_b2CYJjKYzERO~Z>wv-JWg`nD0wM(}H3ia% zu~3rH^h7^leEcTyb$Cok@{^(zOSufYaHiN7Qasi*_;2-X72v(2B8_7XwG9r-5?i7Y zRxB&gB>81@L>}VY9{Pps-S6xx(!=86b^c05n`Oz6>b4Ky#7ZC;A* zbjc?7YY5Q*Zzg3m8`eo)UR%?Dq@uzKiVh#|IlF$Lak+7EMs^*nbW$4FA0}&pyr*Hd zxY;|b>f3Dlpd5I3d)?aYaMZWlt(i;uNsr|tX(}m0FE0&F>F2L7({AOI+-7CiLIa7` z(h@B=A;OJhztqzE>3de=SC(v61nQCL^*a?l9p|dAr&L7uZi|Bzv}ua-d$KyG1}wb@ z9*5_1Dk_HSCsM9+667J7AspoC%fC#PlbLdv^CMm)M3c<1xbYitH7(17#$9`PxtY}ERm{U@{+KW?>|Mtf zG9RTNk@qV6_;-t+vJ{!{Vjja^J#kj>7P3#FBXSyxEwR%A;ng8jD@JP2B51nwmt0dq zOZmYiDF${Nx-l`F;W|*pU`EKK-CfPkAo}e_o_pDz5Gf4WNjYZU`t9Olqluu@oWCbB zsx}XSWKw@ReYWW@%!P4|LIM?54_`}y}>R;^s#m0nG2 zT(O}>j?Zjfdu0ZA%C=a_O3igBd!5}ObE2Y@(VLs`@_!f$*foY^Sx`|c3%sQxLt9l} zWnqd-OGZY7k9T}tFl^Y({l5P#JR`v;)maUPNX)A_R%kW$Z^WY0an_T`Q7Imk&px>q z&gv3lfT3OR*~`469B}QgadD-~k6wUDsm`s`6HD=Fi@?X!S=yw*!DXuX^?^o9l+>^U zbyG?&DlddDKZ6YPpAw8^xyYA4?!;G~Zhn3N0TpEfv1*_4;VKRDiIfEpkaOJplOcmL z&CdI3vb-{MCCr1+3!vW*uaqMN8S@nuQ$c=5`)FVbN3G4El+Z+9`_lSZ0N45>#+5KR zY!CrIomq}e5wGd;=ZdxY`FZp~7ZEiP*Ld1_RMe-yb#V~$4LSz6cBQ)E9vr;e9f2u_ zk+P1<-xKksSN;0+Gw41>|4+N>VsUN-{9cT8N-rSRnvbezvt>0>Ixr7n4ffus_Ce75*H51xvf4ah^(__}vtMAA7b6}nlNBYCx#{iK@>a&sWse0qE1Su!N?w- z?$v32956q&RHr6|R)wx=#lWVEeu{9ifD;hGuB)aW7WmZXzgz$q9(&QOmH4o0FmF7R zBlq$)UetwdPnPGds{A*yZ_WW}W)!V7NLUSdahQxav zGp5D+dmXcDw4YBWgeRYsdL*_K?TrKCfW&Gh9x_kQYB3-Udr!Q@)eao2VNWbH0ME<9 zRi@0?wHcY?+RoSksP@XkoS;DRDL4^^T4~v~r}5ZlmDh=QX+E~LiLD`7yxB&!9E!}) z&lvo*!Za-VsP!%xE+#pz<1f+A32-qIc@q|ygH%iFxnt*_WV93=5{_Z5qfoh$@pys7 z(KS&>eR~IchYtw4gSJ%GZ#t!FC3@kF4fWRGU=`3Dnpr8W^Y^0ImG-Ww-mo^qW7zza8F}w?a8mTy!$W*GpBk58b^r7o;4is%mEWGag@_1Nc{!W97gZ>aB0EVcmNBa7X!!9ZYlf}r}i zvUM8j0A$i;>yL2-fZG-qnW7_41PyxZ*RB^t4ptUK(>LD zW(^7vltly2{S-7Vq9DoY$sl*4=UxuDoy^KyD$sn%5o{@`*E!7H^h6S{NwV+Z*vQse z^lCSqm%?OA=HPkXn?{GBH%kK~$>-Un=&L2lpd10SG`DophAGCX%oFj#%VICb`$}Nv z@p2S&&v>6z3Rm{>MU>}W$ow#s>A1?eQ~NPs5^966t?E_#>=R1jqhuP}x@RJYB4$rC z{Q=tDFTN08JxOrP0@CHYbo0gnZyQQoe2tM`^1nuj^#@|LUQJDORF3l@v^5}Cf81-O zIv{H>mMrwiUMEZz*m`L^`GuNi>K+_O5023Z#vh1(<6P^kkU7g6DYL3@Wd2KhhF_v* zi5noVn3yL`0%T=TsrV}96J0p*v-Avk_VcZvRCW1zmIxzEd!Ogxlw^MOuPaGpdxocw z9Cifs^qZ6JOOKX7ow9^h)ZZqR>HW2rHr-gxaSrzLnb++3Q9TiwXwLGjXsg7xjW-QDZ1Dq#Qs zB=<8$51T5KI3@=#aJnhE1Q;C;OjE8^@s+<<7>be6I12{?vQ0)H05N3SqxkJN#*N!A zxb_B?-RhF-B3m2j#E;a^=` z&aVo6`(?d6zhYcio_$o0p5wy;P2OZ)vN|TFzE_YiBgx z{Aw>VM6f4&maumIdrO6=gW=c{2;*CO-h2bQih64&Wrd?H1|VZ$*{eClLLkNd$p$4N z7zP9ouq*a_t9a+a^jrR7{_nich*{>3p1`f+?cUxW*b^#|FaDWS4C3T2ie`8iuEtXq zjsbB8fjk7`6DfAA*Pf6lCX(l^%Cg?IlA2L%#&^A2*{ncRSC11v#f^+gXQP+NBq;$V zwh<6{svHYGdX2T&c#7|tkzDu?eS}S7eN<9Ja&msO$5i_`7h-^?yPlFop#@s1zw!mX zM8xZWqED<>VK^`Tw5b2It>}Ve&ifl0Hf7LoMD_Hci=lcjag?m0VdRF2>Qx%!5&F%Q zeA-OFlJJD7f(B!*8$yojWzPdZ8aF%&BbuJ z^;u(GFw8xB?AnE4gTX+R!vIDRim?2{*eAzspld($lAM)IsxJ?W38BMWr5mekbcn@h zi5>e_@%%qC6u_mc>hv4ypQsb{KBoAH_gkZ}+6MM$d9efoB1%Zr9^^qlg`eSydQFt@!|LV@><@oA zG*R#@iQ4n5baBTq`(9CF3O*|@O48^waV?Gk=3zs1r;>^yM{8nOy1G}T-pwvy%6Y%D z2FdGk>c(!F5y|h@VKLm2lD>@ru)85E-KP_j7WNZRDsT6kiEC%8QLOLdVhqk9YFDF7 z#n(#94GwJ%4jzrO*roOJE!-pK`gR98S2L=D!YxW}`|3Zfrr;$2zfX-nN-tLc}4W7ubW;*DvD&VfQ+LSD3)o8*UkI>xz&#uy5_m@tBl z_O52L7)f!7deNatOv%3V{Q5(OqnTN^ybt#sZuTkfsc$=6H{{M6)n7PL$ivhGMMG6+ zKE%Tl^S?cQ(j4$4-rX<-{0$#>Zn|KNyz4~R$7OmI%JS^Y%=)mUB|RP2L;qf`7d{M6 zHAq3{<``!z?r+}cj{zwvUY4miW!) zHTNi9coec8y;tdb!!t+>a39s6Au5JAv0}3Ub_M#LK~-=&;c)RP1fC8ow>PQ)`Vmtk zc5WjsZh6dZz1?Rd*8Kl3Uq7Nl?04^i%l@@)znkV(nyY!Rbw3(+iae{T=s~LUL2A8K zlew?)j~-F!2Rs4+AvKy+=m8@mMzO>M6)PgfX*yT|i%`!>hJ<1yT?cx=rdo}opx&C( z)sjO|=!4&Hn&;z@i~(>M$y&qM==6Q_{O9kqZ282Q_DU}gEjvsQ>9iy18 zrL+0ma5NjyuB{5xtSiLA?Jdw&O-|-c?D5&j3}A=&8#~GI`3}WMN3`=zqOi#^Kw~^B zMuk<)C{_BQmqSUmj%zC`{K?5!P>Ly&L9x4rTkuLjec`*h`O&dQQ5N%k8bW=Dk}by#6?GTT{SY`{OgD#OB2H{fj>z{^hU>`PyPPW$npjQJe#cDVzp! zAu*E?!G3zR^PdeD*4WDwW1l8nw`vjb5HMmRRC0(YYQZ^c2`=u99;>4O@^~m2d#d8& zXDkW}ZH-57JhHxn!mju;jeJL<5sXlsI`X+hBgA{?>Pr~Ja`Xwy1ynF{n|D1mnQ*L0 z7(RzpNcqA2Nazu!@B7(M6;d$?d!OZoc@a0NDcSpL1;p?5FgtO&kCdo2SA))Acx-ZE zI?KAePWoBsRw0(LL>R1dl-YozrIsK5r>Ejq*y+3K0h6zSdZMd{Y9aCNnf?B+4u@j{ zvST8kGS%nDed-^y=HQ3srLlHQ`|Aj5a^ErDa?fXS9NiESx!go(04cb_cx9y_=&#GI z%h-PCh4{w!f6|=)m&0Bgy#Nfn?qjPLHTga`c;Bj)dIFAptkF=tYrlpiRpH%1;dgpe z3O%4dwMbcQy%Ut^IBL(x+sJyzDJu_Q%&%$|A_48Jt@MtOJRz`Y;wKb%bCo{+m6e@j zLh6)6IFew9n#RL>?P_K9s{&I3=iu~NPGL;-q@<#GVW=OCzHd;mmM6_8CmSO?Xs|Po zX0zh_c25}SC0g5{zYNb3AFcgZ$z@rHtr8xO8I8zuW6IA;?W_#WBppi_dNW0e@yu5J zTcKZY&1;QI=G+}~>nUS<9>Uryaxd9TEmNw!H6eX3+k#5oSU^Y?Ef%9VE&XB;?HBH1 zA+Imy2>_;wdXMFI#sSOkmJOCa*9$vnanyr7xknOr3y>3tWH{rn6h&D+PL>Pl&?-Xe zM^<8LyWr?oC!Qt=O1@`bR~|jsbU8JiYB?V+0)D-l@~V33zhw|eVUpi;1dch{KYeO!o}erb~Lwwe3mJA>ZM2@qQ7N^BfN;E6mQ!P;^uX zJ#o%m7O`GYS9#@)O`QeHCwI9r(;VOeegg0#3hfJlQ6))uX+0UYEe;OLBt{;{=4M{b zA?^8mwTiFyP0*?=zSD8k6%P_T|7H-6n*}0eK2M#aHhDu4;Al!rlE(N}vjc zu6>2BP_~AN3~miSh6#9Uq5SvlL{!k7`=4XkdD;6rZ?{?ls>_W3FHv>sV{!JEZZ-DX zTyzs0M{0Y*2bMbCh2in{i5EwkinjB=_}xAc$L+oX6_ z+Hf`s?YUbP?tGp`j*Zq93UsdmP+E9N)^dU?o}Qsdp?o&++WV^1`U_cU$R94aD$LSR zv{8vjx3lebsKh!VF9wJOTJt*^>)}{^66tkO)RP4%WA)w7v&u6cj=EM^I{r$S$O!=X z#)C;du4zxt6#i&~KV|M7Yxs5PiEKN)=wG&5TOr6jsNo(!N7GYp4>7v>;;?5)NBWlO z0V_jt0)bb~w8})Fgyi>>k5}mlKDlxmP=dIAJz{YDTO5-^X(GAMX}t*W^vts^wleAr zs?c3el?q!cX>nP*F5pvd#U?HlIhIVD$l0EFn$b?BcEMyay~Bn}C;NoV_FrS#5U(WV-2x9K)y&*0e}MFyG_4UpJL=`(tlS`-%whTQSV^r zn5qdrDO={oamq z!~_IRz53$o?#%gd=}d8LbfT$jo&57#&&jxqUCNk(T#`y5eqO(BmNfjI9A`I*&DrH} z*__W!A^F;<{g@mwM_gLBDV^t|8tLwRiowfj?PC-A_db_<*#~Dr1HZ+i(xV2bGy}3_ znC}v!zpdiZ1_N+P5LnxtdV`#Q!Z_LYbD%22mn}tQZq@`Gs=E9@<@Ym>Fpdtdu)B;U zpy9zg=r#q4_eU<=C=+8H6R7swVh3(Fg?3Tm*KyR=0;7f#ywcDwL;{L1ERts&oF*koc%i68?Gr(QA!Ms2 z0^`WXU8QkG1~-;q;Di?=u_*rbBAFibk*|jq%}>8))3++t*Agv!AxLoyYKV(Y7qzc& zSZk;rTLmzovFNCtQ)jXHBD<+dI@j(Ku?fx>C@zMSUk9p9VxHa*J; zxGZ}7r;TSWhq$xZy03ut$EF)+!_iMl zx@mm4{@5eLMeg*&jXh@V2i9Q{ky;!Jkn;;enf5g^Np5*%BO^-mDC1lLh=N_aQr@Pp>q_3C?=d}0Olqg3kM)XXl-E`|Y z_s$rirgwJGN6HKqv=I+=*wjAj{UjA0#@X#lUveK_h&IW-E#!zjt;d|Lo@JFV0 zDj`p(=6h(JBmyWT>Lp$3dvvkQ!qS(ijAx`Ghpl7B#P|kM`J{}evn$T|%4|Z&=3{1} z5q6o~P7ji2RQh>hW!$t|H|bPAQ2A*^fcx#Zgx&YjObHGJ^fnnKZ#!N;`!xc`6Rot= zd@ztHcHT-q#j3PEQSitr%_9i}o>FX#qVr_DaYRdi?WBx6#+H9fw=p=O37fWFRy)Zb z)_8os2@P_(o4G3(@aT2O6$h+~J$E@d+FcH+Z4V%BCvO)8_xE}slqpP47C#A975#Hg zs(fTI%ym%#Mx@9`w0)2t*rZoUbfF1DhA2KlaKbwuk*S@o?2gU!PBG|12V|m!JT_^bQo8 zuyQrgS9=k8;{3a_IRkq`W=&P5NdtR_*c0KOv=ztq+*#CZGg)1Xr3P>rmYV6^pV|QyXs1Nm#&IZGgEHp; zy)AQrfh`36>&CK$I30$OscF#RM}O&mS+#s-*`FN$?R#a^y-%Z*NOpYY;KH%}TdDcA zzf@5!oo`KZ%HN)DJ9ljO%x`7mLMJa{{K)haXLfiHoC2v#Xuz5dSLn=eJ#{I%(;tNvd-J=Wwd$07Q< z9miw{IRzo-5@CWiZg)?TB){EU|1&6Hmb(bw%LcKRexX8U?wt~EMW|nD5R=k^??OH& zIQ;WQ<9$Xb0*?v$<@Q`9JZF&g?=|x$k-8+=P$03gif@p2aH8^0A5Kr>y}TeM9mQaR z7)=~T*sV7L+br8X{sg$+yvA$7!x+JtZ>$8mB=hy#sKBTcb-{*bP8p3m^WC43&5ejh!TAOfevzZSl4*9c&X31<)TA)c zlHnsxz4R@kxrPMgzomrt>1fgGOo?z_f9jyyN~L&c?mI4Lpn2T;Xi+?3=LoVB+kT?q z@6~?8^I%L40y~_cxQMUF_$*siw3o%C15IXfqL8V_jBP=@_}>^7wA*|SUa&44el(jE zl|X|{x=L}^X>a;d=iFMNPCo>EE!Xz@clH}IKp53~&29L3Q*x|goGvBn((B)nLVDVT z^4$TpKRptf{Q$U|SF=KgN$)KcOUjVtoP91|4(n#fTVO_URg!#LECmY}vi$x!@pVym zJw1tbncO@1WpJIEdj3Y9Pb>z^>2%xk213i5#)VpH;VQ-C1+^3`R$?q4EMowWH3;K# zrYP#Rx1CaZ&%ZoM0JwWK?W**V#_co_lGMKfS>5zFVOfm(%!{(*Vv z2;=;gEV-?O5j?R|3x*stzv*BM&2C|$j1LZmWc7C`{xMH5!+W?tNAJA>G97omBVRageXf(aXKcTJWxT7Nvg)SlB)mWub?=y97_LkG~f0) zD-np|DSr5>n}L1l2;9zCFyVYPbs;RiqZL2G1l5X;a=p_-zMf(T5T$xTyIAd zraL{Jn=CHXV;y08N@iaR5Hk|eub;Yfm9QAh3j0J-iQ zBvF>5Pm7%tNUU-m+9xLxBV-dQ6_Opfj7ju8JU9XlQzey`Vy#MQd1LKR>rv}*;ecOT zZQT$l3c}P)gUmV3Lq?6UBA~<+ojpBME7Z+aMCxAx1%$=nlSnzdLQNeV4xE5n$At<@ zT{^D7vg@La;!w3{)>dzFMD~yqhRyyjx+yl7hmpU$c8{_FR4gwc2^Wr&mLOjYfK>&WQH==anwRD)w1!9F*vE;uBF@T~GXb%=dD64lfrH?Jt~X=z`HzMj?3 z4r3ymcrS&P>&SGG`k5N4}vvpoWE_*c*oO^7gn*DTTw_Lu#V6Z%~ zH}TI;;lU^)Y+2KkhhGcj4;FoPM(Dobd}|JZ@5bT3sLJ*9;`~M2kNdOrUDHY#qrZRH z8a)03__Y%rxHh%408R#+9+u`W483;$xk1~n>~}0+EnNK1ybo#)UAE`k?P|h#Ut+Y*L0nYLqUCOx?znv73ke( z!B8D}iez;Y>T{gVvDHjc*i8t(50)_&B(#8^*D8Yrp`A)elO5H(E%c0A zrWW}8Q;IZ?pEYk{x;g#uAU2M16kxGPuG3^F#iEs=FZx8@nm*eL5S581c-~LKoZw!%Gg&d7L!TJozPb1HHpSw)wD8?< zb*_(0`3_B`2JG$Te;E{z`Gxl0`o;_6slQD!b&FIQEPv?Z*txKG!@! z(&n8r(P`s?qRqU+d!##&Z;X9paDzdCmu6C_Gv9YLdq_`NB)c(IR?%75@^|ay9W=|) zzx>{HpG5F2X+*Ht9}M+dkav?shTrPL4KPA#|c zXmkASa`A9?dAf5mZ&-&)@g6Y#$DRCV8+=hge-Cp~83IWY%FD}_;q%LeLK%PFqeDv- zPT7I$-gjEmeO1ukGefWa@;B)F06d=a&dJpJ_Ff3nv?Yr8v3WnyaRi?is{P?mB;oDk zY$On-z`im$=l^L?_?xu>_49xeXSdG6^k*?d8RVcmHtn7lB=x(t5z<2|Gky?cy6We` z@bHq@&&d$hGbG4yhd(Y?F4jAFPuI;$jED`_LQb)JwXKhlT7{1eX&QQ5K*B%sxlLrs z?X9@)%asz&nfyJ9kHJxXa^tBXevVR7q2k%!8Y=YBqt|%Bh`ss%o3>wlKCl`+cguE- zy>u6AjYO{vlzuilM7rX5`a@sa?KtCwP+>5hZPhomhh%5_Lr*_9zrVX^AlI?-p{e=L z+0M?Uuivi*QoRHDaA~BBL>?zO8e8beoAu9z$0WMvrc1t%Gp8aN()HVV1FdAY>~Br= z_*lz74t%c5F$~dS!OK^rE29G}@bp3ff(;s9-cLxbFQ1G`AE*%@X@@6vu(z+T-b*s{ zG?fqjzUt@exZjLzc*qHQIE-zOy?v0fe#jX(dN}iTcql;ndc!n(Q}WM$v70}}eI3rY znEI#S>`)Q#A_QNFP1gMjPdb$9{rCc+6ICcsHwx{Ic-zy>vP`L!Y$r_YjwuP(sY_`| zHn1m^REa^iN|W>9En6^~yC~#^o&mZqrQAeKfY1qdJ5FdpvIXR+8N)0eR#xUDQ@^(< zA7?p2+SnA9_;haoi#X!bOPVl6W>$sxgdjoA!EvP_F{xdNp5?w33J$zQW1@&#nv=|> z`1i9<1Y(7mF{R?~`2_CiF(i46euCwxw)L+&2AU<;GlG#$%MGh*4a>An<&9%)&EoQN zEoiLlbi=zN`TYA_%eSQ4!uYKu-Bl^(sQ1x)O5OlYI zPJR5T?Mwclxuy&q50}dw4;LDZ3~c3i|Ehz2disyMRHD~|P6eNUjDu~t_xO~aQpbb$ z=YdyvJ5kx^$BWB;5_F6V?Y~WKZ(tfqzs~SivEV>CmuRD zIrArR(&EpaqXwUwyn81ZC_%rXbumKtuWZMplbSg)6BM@BSPOhOgUa_ zTSTrkmk*CgnHHxhnyt~{IY40u$*)vNcotbzJHK8SwCl!@Qkh5$atj9VPrp=dsg6UC zTk!<4yBclfZ%pbD3det8|y}T7#rGmrguDJZKlN-{>eac)X#2VRi`Zl zk)rFZ;U1K-22%sTO4v1e)%Ek!MH2X!e&Sh=(=DDNpTF3x#}>rR=#A!tt1k8YU5w@2 zynmTbrW1)e=Osk1Fy5dEDv&_9N)R}^ilPJ1qHXEJHBru3bI({it-QKqvcM{!rKYbnhyZj%Cx?Q~Gs}eCg(z&nC zyjcod$xDmQiO5x33tnW{U z7rAliB-NSR4~*QutH{+MTCmv#H+-(#wT2u#$tbYHR6kAkxV~ISaC1-UA&X+pGBT*m za#>OMae~qyb-5oTKK>Gw#V$Ww9Tu&g*cfgz8FaZwREEsJq+qJ+nE6WMBWS z-;<{M)y5sH%vQ$8ScWF#jnu69kA^nZ zmNm`b{^X|;S15k@ezduf62!#Y{rBliL=4#fm+z}gzlb*`@u;=YMoTBXEe$b5C6o}D z;PI(`z6Tvwe3~F|JG_{9Fa{PtHPMQ(NJt1KD3o2FXG>{~f#&`UKObl=PKw$B!dUe1 zQb-57!=UT#%Y5IfI)$#08$JedQrFw7SNBpVX~Uc!_w-dEq6Z)Sf4trl+vVHp^MB@l z9LoKl0EBgO^qReBFE1rlp-pOb6V2#|fm0)#qtIF`jH+68nqkkqe`PMX4|p>UV&pz( zd~(Od&VuMr98*SwjWhDf?Q)f;pb6PUmk)&NAG&1M!dgIn_z?hICS;3}w;)wF);jR` z@yh<(kfgb~Vk_AIaz?c&%I-DYzBVzDXv&JQ=O>mK30OLq3)8N@LSbyoj?+h#@>HGbL*tidQS(JN z(X)Af`*sI&9#7Z0Mnt5}l3In-oDP=z<8F4XT!0JAgnKZ{Bcc`P{$oH0pxhfzXMQP5 zFPM;gLMN>g9UJB^b}*3|mBX9*aMyg`AQV@Zde^Q{@Lx3MKi|jX=rIXth?@G=lIq6n z)fWCibP)CmE4F{VM`efj+UuDOwawMk4)2D3n@&m>TCGvFI@Y_yCQIRHlK4SEVNVL{ zNWV0B3l)2I81fR(xky`_ov9tks%mZ0r&vd>1mkc-JtL9Vj3J&mf+xP6GFbjTzpBSx zlsvm-HX(1%p*A$OB(2;UOMFcJvCexcpY9E{!deJR-)8b8>%xmyUi&~G0=PDz;YsF# z;T%_(Hfzvh(WZ}SVr(4H+R}1=CTm`?8>JCDHwy1bxRAkhB2ZPu=Ew(yERJS@T58R8 z-1Js>$hylQB*%@T+Vxp}!H#2%Xk=@-p~9SS|BfE?zo`1|csASbf0PN&1jOq)P5R;*_8kZ zI$wQ3{Y*+vrikDr%@s45q1_;*(Z%&Y6u9f{;Bk56p?6d3t09SaKJRhuln?$lp5o%g zdZy>0glo;1ccN5UicM0L^BW^&=5=I2RW$r6^Yr&4DHc3Lw<&F;9^jcD;f|?zhOFp< zz$)|I-gGpKKKLrDH7Bxk{g#gDg1<;!k< zhMaFYWF3Eg+twsd!_jVyXz(E+An*hX;VisZ6~<`6c_C~xQoJe3N{V3+F4Zfhj`{u8 zdBP7Vs}#%f{(6%j&%c*5p2TDf*M}+ER+B5PS`p3ckKGHUR!SNHIYl|_;esj3eBn5I zI}EnYSWk$lq-p((NfokF(xD!pW6<$bgENbYLd#N}I36PU8~2H1B$31>TgSo3O4t$e z7h~lRGIne9UQ+hZvkqDz_?wO>m5bh}&I+U6yW5doh13P<4TnI5|HRvWueY|?Ji&-9 zD=S2y^y{C#qLpaB!9}vG%&5KXTlKmii|p0Po)PfVEG@2P;1I=Ip=?ydDvge8)B17C zT1(sEt+()pBTz(A%g%W zOF?bUYLTA7m}HsewomEK?|leG?EM3}@En4Mm479^;8=f1CWU-Lr<85>AR6Hsrk zKT|+W|HGA{)0tr5^C#J8?UUD%dc=6GP4*7Ok$(8|#5jD&j@I!MtWQ|Oe$=EUO<%R3 zxbWG1Tyme?Zm;bV9nT>`9uDu1iD(u~3=oL^k;zlyIQIk&OKBM+Bf^NrYr_xkW$YJG zM>=f`;j(wl11bfh24iAYyCa+&w(ZeHPZhjZo%9%NLT@(Xth}7lZbkYMx4=n3Ohw79 zOGr?`TtNol084;l;gsp!q0`1i=Q&&Fn{(;!LMQ}M1giQ1E^R4dg0d?RZJ+uo6DTv^ zL?{i#3a>xFLK0c_oDaB02yhaC`rsHlfF4YWzFmqaMl_uLbH5@k%|zB@P}@qY&ogm_ z#raN=l};JW&kY?*fj{Jzx~G}iE!m51DY;^WIX#|4#>@L1xOf;fZ!N|h>>Z`v^MaGI z9BdQ_%{Ks_wfLQ}$X{n>%`6{hGrP#k!=Be(0A-IpL^0n8m?iuh*75uW)8{QvSi1E4 z#3~Xhalu$J(oRH0C2``^pHlz8yUy+YNGCn#0*?PlhTzh53NLF)=1VkQe<}I$wU{mQw&qA?r1m&4?Jz?hwsXU0pu-iMN~211wREjX!gZ&bve2{^L`Vbwc{l zq6PR(c{oYC?KX>WBS4Gc1rk>~9R?VvSR!jJywrK?B?^Z|SWg{xGS-#h6 zwC&QKV=7sWOw_vOuC9~3Ej0VzpW2Gdt~UL)sIJHZeF=p7^zNIQOZ%KFgxnLF%vdHH z|Dy$}I{&Im0{-|X>+M5d$(Kh&CM8KEJtZ@rXNM@f={^Sa-JDJ=6P=fE@0)olgKQjZ zO|=LQas2j;MjlQ#PPj{1m|0jb$M@P8N5()lc!x}|Ag|Ldid^n(ivXjK4Vk#41ArZ< ztdprB?ja6n?42T=2ODA)6ogR4-vHZ<57w#qK3?1@N|EZeX1FiUy1oDhk5UEg8=zXWn0;Dt>JKEf39j`xT4m+-SoaT_A}ckF6P(09`lX9Q=rx?%B`=#l zs^R zvj~gGIU>l3GDUiB$mJI1{ynWdx@JG7^9!ny#Rw0&9?v=bmHqi-l=6UjUyvl#H8SE; zgd`U{%?!@dxgZnqivHtTmi|_GZ;t8&mqLDiglYQZ0}2Wh$~e;&zu#+0eC$wHMpIbdV>Qg;! z8bHt81ekP*?4M*gh*2!k@z{fzfS;2vZT7Xkmtq5qk_*&c%qQQ=#&?TxrA%@TqlWF- zzwhkR#fglXt#hi!-u3;VQ|zrjJzL$sJUTmDZCv;+3D|L`1{NvEh{^7|fjy1Mw94|q z2}xku@2UM)>5nJW2zEOdPr_7&mZEXrrV$zNd_J!4s^NKe+ z#;!UiKW>heKKr|w_-0MZ)PJQqd*)!4>vNFcTXTBil$&a%cXWF(VlEbP?;EYt$(Mq> z3-%j2{GBd0hv5sI{A@vamM*HQoIXcM>J6wW@G zU&t)-1S?D;`ckbaIQ=_08u>$|-<8!){kj`jY;x}X$f1>&NLMxBeTcvW4^|H^E*Jv( zVh`0rza|+p&h9v4NMFC3)u+)6`7MNi#qy@wSRs1C@fu{lF=?JrCYB329kw{l>59kU zd>7;~@=EO#U{d*z*CjNM#(YK5q!t9l4H?;RL5&TU!=!t7r2pt|B|x-11PA-H)eb9b zXN33vx;6wH&iPnR@4?4@vD|JnUIiGs{Ygy@z$qq z^)RmvGpcjG-XuW2gSR_8GIvPUJafEh89T*V(mB71TIAVZ2sSZq3p^?{%^WTkXdQns zs}MAS`#yjFlvj7`Q=0;{z<$ia?BFg!QTERJU(_3Zr160W-L+tdnRMclkH}FT>P*e^ zqzj*!T<~nhad=m+x&0W%WXr$=wqh8LB+1~{$V{>~5Emabw^uH(8(`x%Gnj3gF~#?e z!^1Ujec6=A(7nhzDVKwPnROs~fA^lM27S|a2kVqX7)p)F-I+u&2dDuwCgY#ZFjm!9 zOEF`LBdM{+AD|=v2MQ;^86j3{zRMqS^6|WQAhK7Z9fi2bNSgA5Zu*KA{lt0G8S;a2 z$70pr-~1N%k6M1s+LgJa?=N3@Uo8GAP>b3S&n2La$DRJ5l3`bkR{Q8bW{29CmfBBPHTd$s)FRoHj@=<_G~u3#~=TX z&*Pt8S6HtHYx_b;h2FQnBG=6QS0(vl#vaH05?WvH|z4`Fn9t=IgPRbl<{ZK6>8 zy9xD_M~k2LMZO-bejl{(3vD)bSD-*5W47O&j-v+gYBf@D)v5$PsYA`Ixd}!kGfL8{ zt0-b)(TevI_>tT)?27hRRYf`Kl1ZI!RO7#b2EN*mW|Ul3m2VzTS71NK7XeSdOnE_T zIjb?TdoA^Ks-D*H-@HWloZ=iNOLbeTbAMI!7@y1l=If?RI9$JJ^GE#hKk4h^d@&$n zgR$VdbB1Qp6KKL=pDcYZZm(G9>TqG`!S&_kz(R}cF*I-t{G-3HC=VwX`i> z(0+8QlN=~o=-X**Av$$}NR8-S)O9kBpNf;;wz~}2(xO2)NFrdZ^`s~EHd)o;t=_c? z&zNOiYm4dPGS}2X(P#FGa9)w+h4|s!*S%d@uh9<|0H`iwPNSs%HFg)n@jqy z^I`!*ZS8p#xgU_uT>KGQO!tC;j-EGj*YNMM;y|D0N(^tQg-j=3IdAYg-&eAJ%Pk(Y zoV)F+fO~%-WWqcwZ;fsqy#N#xr*f^fF`hd0e3~slW|`Iv@1RHov&{ zwqpKuv+t!gIHx%bhSBI&|7Fu&*mlSvI|3zu7&_*`YOjZL%JsaaPxHyBq!B?kRo7=uH`x_M6`SL%l%?V4oS!b&HwuJoUR`7cvLfgcfQ zO2Xx!LXxwU@p|D1^&j_GyGLLOcg2O>Dlh@AjWgdxN_#)P5-*QL&aif3XcCx^AJf_HDUY6xO zCT6$pz>--+zHI%7So)tgRNWtqq;^cgVT3=BHRi!^?kC^c~9?-5dwgjTJbxD^2@7;M^bwkG30iu|6nXw_| zmb@5P6RQlRbdA^$d{0WEif<(V*<67)F%ECFAr?}ENFty0KK<*9BsoE0H3?4wJpD11x9L*GyvWaYy04os8wkZuR)s+%yIoWZvQVJtmL2 zCe6@n5Z=l8FV+d#AK=j$d)*l%dr;@KA-v`T@IgdCD)-;Z_71metx9J?-1wuV+d(lyk1jq?B~I47lx$P?<- z%`zJ|go32mSm7B5ys2I^m6SMAs+9s-mcSD6NNK<0HN?C(2*wUKnASoc=DOJE0Nr&& z_fSl-YrNK*xzrb`<-PZ8)v9V~L%qy(phH9u@VRS9m|Il@p7AGdzn4mMdFo{oMNb*#S8!sd@LY%>Nt?|HOj(SPtW`OY872>z87B z=z4{nVe|au@#Q$rryfEtDc@tBc;Muxhs}n0e#ag0iF!fwBPfSpcaOZq-GaKs@$Bba zZgz`pv%7BBoHm%vx%WX9fjI?p$2$v8nPv*i4}7+aF+GCv)->j-X5bInap4vlea8pl z+w1i$4tf);dA2&Le5fB+O@U=DrB6y1wa=PSjh}pu^(o_i>d6{%{Z)b7OMvlSsyghu zH-Hauuz5haFee)*4>RS@Qv!58a6Tx9qe1H1sXY5~C|PGCjb-{LRcmr}PU0T51&u$L zNP6|WqC!`AsrRki6uvwgTmiT>I06`2c=QEY$Y5j-ab_L~)Pnbu93FUiAbp;LTo%4Wd~_F)B~Z+Elv?<`>et=e?dgO-rGqQL^JqI|iG7>cnW= zG^{zP@Ss$%7%pOa!=Oiid;pn>O>@N zswkTAV_duu?(H@6h34V;_0gZ=7WHh)>Ge~+W0ue#!Xct4 z3vQq67G0zlRALW5SwFw@o2dc(a>3vF{xN?$4=7xs(xWhXjpEU$pB=RMAzLlBGtgW! zwC|x_Nrs#U-Ii=9>e08Za)gmG%epZo0`KPU`rNcj+v!6I~H z9H|HG8?_W#4VJNwr&_k4sAuZiC5pXQKY#uSq3Gje81;9Ut24hmqX>MX){QZerX6=T zEs@OZ9$Fyi)4;JksC&8Xq{#NmpEch_IR{1NB}N71%hQB2U`^N~d#aKEJqfDQju%FB z;u*Oo00LXr^hqzV%E0Wm38Mdd8ywxk#`rc?pCaJm9V*z=?y6zoywdEROXG>P-^S@f z`R(@Swoh+K5LY8T$6>d|Eti#n*C%2ZCnh@zjHyqdd@44$6#cXf@51#A<{dGH_medi znQKw+I3A+;?{z%`QHYfQtMouG``?x^{Lts|KK|qBgOPXq#*s1Wufpjk8LxrzP7{M1 zc9-L9AAILanrm}v@v)^X$fJ&=VN32`yz1=446cvWsa1g=gFGt0Ok@4{CY~*3215aQ zlYJDmzbaw)CN2vB(qBeU_hG2A-FN2CQM7>I>m&7(1Lqw>$5eE#QQ%KW)SgTJrc2KY zFf5j-3XS)M`;7Qf$%*0p_FqvxCpIA)ay>e+32wibMWBhbXs?bIbRL^If0-KBeYHq# zo%n=*lGI}cuaX*zf_0;ZxZcdw!C+Rb)tOtxS%OF+ieDZP$*sbLPf75dG)H0=hrnza zs(9~o={{>eFE8zYW>bh}ExBZe(I5O#@D>Un3EC)k_m8^XlH0$SzpHQ^xx;N<*eCam zUFbDG2E4z%;CaDfdC-6Sb|riIKo6XHR&AV+gKKNlESn4IY(uGZBr3DvKGb98tM$QCJ53;7 zZ2Jst{?_QmZdKN^O)t5!-4*9Le_T9X+-P^1wPDp6O;p%n<+v!&kF&bw+CAYBBp8pA zF|+Tdmwg&%-?mnz?2GS`)?sF!GEuWR@_9+vWg08Zsex3aZo~>W7S{rRVwRm&D z1+5zYTG0mWvbA4fLa&k9qH?sK8$eV0t-?T!MJAU#K%?0<_lE73)2UzUfB*Ed?k~qL zdV5hYhkpUSFzsTEN0a+YiB?b85q)iCO$#DpCBMBUU}S3)X2Zo&yW#Cj$DsCY6? z%&aJ#8r%s$V#Lb7F8lw6gcbg=l=rS;y?Pa*s#(;>LEwee{W^KA>1E;a z7dpWe(}K}5kZ%}T{6ChW_fAd{g2&!_HPwDdukR1kY(1p@x|*)YQ?E@pjpp5mfPZR? z1ctj)yDvPJkT30jU#x^zFs(%Mhu5eS)zPVKQfhpF(9J0LbYWp`%b!TZ%}%VLrnXyR zY)`4m+_y%N@GVh9_=$>(X#pE1pavS2h-ksIn%C_wSJjq@Rj(;(Of=3E2=NFNX?*_cmzNsLd`dCz`t6ab}bKh*8ubUd8PZFWnR zPb<0?;GoblZH3aH-Bw{!r{M_ib%%~-B#w%ksJ*$b_j))gaA4&?rCi0Ji;dgf{=r1P ztghn+>4E+N60(Jk$021lBl*f-?QeVjq&BMo>$O1a;qTW`ViQ&<_s1aMM-q~fkmyVl zpM&kP)ZF)7!s|B&oE4V-6_#xkF25%SFAKKsd=%nuk?I4-w*h#gf8?%s->`_FRdg5(i~u@ht;j-#&`+%2;#Gp z`%rP_#~b=?jES@_t9QGpraJf%l*)fg6jCxoK7x!>KjafosOn-+3n9*Bx^z2e{krS- z^vm$3NYVH^z=j|H8Fsfzx)x(wOhnx zTzQuhluvy~goE4={t#;}P9Q@UV1ynFIFW)9vIdNk-(0T_`MtB|jg6(kE1J2H)ZH-{(z7mv`4jb0#p^ z=B=iJ^5mmmxyY@C?u8oQpeO@-u=7X$*HQ@4{GH+J#J$#cy0uyBCDScM#c=oKoYCXu zwbXmwzC#A{nMCCvJ-iiE41C)0DL#I|$;XP}pY7kEnq_Fg9Hap(4Ejle2*7n+st$iI zDh(2cPAa}=xzU3PUB>Jj%$wa8X80%L_9u)?J@tDkGzdhlugv?a+d>CuqH`xC{9FR( z>h`P5h3D#Q3b#c+JTqK8h5V-fMXv}xS*)9iovjv_@gE-oY35+cZ7DwgZ5DR$S_+iT zZu>lytZ3rUQXlIIrD-36GXhni#rhfzxRFkzl=(0Un1&$~$=5{`N`lhwy@|w0p;l%G zX+!geBl`CGf-+2v2(li{4|!LlLP%nyyK-VKHJv^bXH1^Ipa?@Kz3}oXh6~+PrLNtN zuA*NOpJGUy!yczpg5QxB-pzXN=EGN#$!I|{KVB>%WKZk_ySiB-OnDiD8H?pbh z`t%7yHU#QBamPBhv3a%`CG#hHVdY=QF0e1B0S<2}8*D5u6)Cr;_?DlTp$Oy02*|;g!s*XR{4v%%-Z>a|dL`-JSp7_$4wR#c2pAl2*IIivcXw?XVe&?b zTKm3`O1JhIy}8!-3QAC)L)E(ErUV7Q_eBYmc#3t+K!AA6hmX)iw#p?C$q%$zp@uu7PkRX4e2)it22*p~`1YSz({Y2r zaPu6JVo`zwcin#dXNDg%xW$2aMu6$E*l@*mMxm9KF$W@wm=az#R4z)Eh{@J=r_c(% z0B68QklI#Z_R3TpI0KCXjR&f_0`*c+jDs2>%IvcooYhSFmvyz+?Z9H=g4Q?!j(<-?G?cxvIJ*f(O(<<>lfLYpzR%4kFvP_cJK$`I2G9 z0-n^TN>H@w7Zin&>5!4Zk6+CEUgeyCg5QqLI|*d=C-Sm=s@Q^QvEVg3XUu*{aQOhP4|^2%&uY`Tk)pKhC4W}0D3_&{ zrKmaoiR!Gj)^$4P#KVJO!pj!PQFFP6SfA5Z_yZ$xg`6rDh@+yVuNz~@r zc8on)4f3bmU?c4Mt`)_gBAqeeUu>|qjx**x5-0HD-1oJinY^rFq;@Y$+{z54?lL#D z8=Y<=hdl<4(~mEjv!1mIB29ic2#F&xi++bNvdeI}cY z#6;s?lrka=h`mHPq`GjwAFEXh$6iqAl?Kg_8I1jb)Z=r%c$oE>U1F|9otP-VC_}MB z>9?+g$2jAI)Yt7Zu+OSE1Let*-^F!-;%+kwldkKfY~2cJ#D6rety|Ap54f6PXK4omx0vqgq)$Vl*KZ5{-l zq~30u;bR6kZX~#g)>0YreD+U!GiX`6#y_^@6IDH*y!QPh8AN`FZ@D$tQnqM%L3|I) za(7YQDP`|VT*#+tP#uM&8YET zPY#sX)SWHt%`N9|e!I>%!;l;u7Nlubu}HM+1lW6i02JSEomd(1mwIG=mJuN_?a-OU zIVkW2C`yCn_MV0!b)za!!aF;iVcZBgKhiJcMta}x75?&bVbii{@{|I-z_m<=KwM_p z@vAXHCNXxgWN~sy_!C4fHCh9h;lmEKZ7_#vG@Sfh((ZOJUByDOrB}c2O^~oZ$?f(N z7s;z1lRialhZ>%PI!yt+5FhTY=mLVFrWa6-PO+l7beo7X(4!r-dk! zLVhgKS{I8`!hhh*-`gpUoCX1us*rAb!;v&~MqMm`It5x{&A;4&EVtsEpj>NorthxnvS19QWm1X)B4}@+LIMM_DO9}hj^r-g#8|9F>#l7H=)yL-RCNoW*&Qq-IWIwy|Q zz?DC?zVIMs!VHvVSDaM#i|gZ)@V>%}`VNa}-0NRJMcq@npD0`SAT@!Wd(wOyH;UI) zR8s9?aTWcFPt<{nmB!w_gs(}m9`SIUoT?wya4(9#Dg{*4R8qdXeZ4>DvMFLY^jUGY zMZXh~*zoq%;6Vf!1TufU|{XVlgXTZ;haz!K$!&2U=`~1bSzO4 ziX`Q)dcs~y_Q+eJX|IdFr-St_ODrs{;>zKYVY;DosDnnq9h+}X6lJ*c`y&KD(O*v* zNd}h)ppkvKgKh>k%CH6Y!2ETNDhz~J{ZOU9fsA;Kevi^7awazmPmGjr1ABZq5fxgq zfnI?>c@Cd9oRU7}_oe;F&hU1W^kP5uhDYA_Y;&*lQ%jNhkGE~}3xAJY6#RJZ z+LQP5;)54|PGngzm3#^eURDv->zhu}g&e#}E~f9M!c&SD9dnFK%?2J}!+E3rG! zO^i_)_{vtVAWxkeN76&mhYnz!l!#!Ee)2=kaglYMMn#-~p-j?cD81nP^V&-p52;JO zu1VDbyi+gpbQ@e(-zMsH-_05rijOS?UIxuUqPl-eS!nmn%opNe2lwbl8t^&WJ-%WT zu3ki{(O1Q{Lb|VM(CT29QB!cmdi>i!uaTj28#henvYvL7DIA50W-u^5G~VD>)&r-g z$Dkn6LkS_=iRiIS9Q-8x`7eK8&hHCreseOm{!@2ar3=D9`w%uQsPL~|XcoPuR z5MAsuLfR^g`>q|&*udz8Wa*Duy*cho!O1t=ANb`NLwh(rnjs*wZ$s3P3Der^x-3D0 zze!bXqE%ET=V!`3Wx^m__mX*!9rcP|^BSc%4ZN4j9+K^k8cYi`s7RFl&gLJ%&LF2Y zWC`YZw|@ArB{=ywLcgvd6&KwXl&$j zb+*6Tc6(Z}@BVHs0s!qddZ%Z%ZlrGF%lXD-!&ViH1|>toiuvKOIF+XPu~a#piNsS@ z%N?^T-{=pWcFP|6kwleO^P&Td7wC+9ij_Ipfv=1`RQO1Qlx$0JBRn;DDEisZ&EX|F z8tjeMYBss*&L%^#IQ|#4>S|bh!q_h^4*aTfy!OBk#!=uZ)tZDX0AE<`ajw8hgvV{N zi(9}lrj1<0O^Vz3Xg0h>UFykIbXc%#)%(NFO`W@d-R_RYCcxtL)y6%We^QB+Ufluf zD9(FQOqUSVdrbPwH2FLwMgKV{6reaPJ2h;4R9Gim`Uy{^js0Fh z__RrUpSxK}j#q3uZK3aXP7J)-}aQxW@Tx;JG=`D z_C3$iq>&50X#9@i*JSWF+74gX(Vaw3kXNWc^+@AY@pNfE=+_c)_JNU?ot!Tz{koew zhE?3VlGze=3=h(K@*0Q`3XAyeTe)bk#Xc z)@7CrDkIe?x8y*%8;`BWNE^wV$SGcTRpA(<);Zdhnk@J(v%BW{A5L@h0bGt)r2dyI90}(^5edfNLmbXgg zQJ4}bCN24cjhoB4_~F9lZ0$c=n7p0M?Xh?Q>8zSs%*8hKsGL)($3*wLA6I z5r8?)!D-yo{QHPsgHRJIjpN}I+ePlvg1L+8BFp)jfb7EKAGtk2HP9UXZjs^-+7t0i z6TAllBvo1p){!u4uo{b3Sc?AdpH*tD_7d@$H;IDfCQs=#OkSEK*+*1KD)B)L@=P*m z?8`U!9|6dh+C0|cw7lM|=^OuL2_5^?mx%8INbE;KIQg#RDPU+pQ~MCb{&&_J!k<2D zg~KwHtf4f^2em>#Vzy(uf(k4~YlLIj7IZV+b~{<8e(-`_Rx<$ldX&nXH0f~cKL)zvu#Hi74=Fle@WA$@&irH!akelRgE4Hh=} zqK{+)a@*VT12^OlawUlZ;K`7PkOS&0%5V4i5O|8J@Awn@G81^YABuN$GMMl3DW};H z`HA|p01j$nN7lj*RyP`N*_&ORT0Oh}+D0hIya_DjudENc!H{L`4}OO>yB0MblLpeb z)ZAvJ_C9O5{p~kGS05uAm?GzLQNZDKIDCC+A%Ari_k3iW3UdKyuI}GO#XE10&`4R# zr(@LF;#Z@L4Byvu^gf^aw0gcXEAdY##Et|f6@wF5qhO}}Jr55E&RE@HQn8}us$hu} z{yy^)GQQ`|?f#@Cs_Mni)RGd>LBR!LNe5fhBTdd|ZA}fFAHv}U_IKcu;wxt~QpsT}R0p1aj)i4I}Yr{@yoKA!#LD>s2Z9bNdl$v zf+@i}^-4($KE@K^8HcmbPzhP7aPu+XKvq>Bf=(oBEJnuY(@=OJ#F6bdnSH>Qbmry@ z-3DOlK046j|7@cFx{6@E(ekVnXp(Ci>B}}Z&~MH0U>D>{s{Wr%+2}S$IY|A@!kN0+tI@R}4y;b+tZlD?(I5>72>Ziuay!FS z@k6!G1|lt4>h{O#gnp$pXigfTG8$%q$Pjo2Y-*w!uA4u0s$$aEl{cj7MBwKlhcqI{ zHu*wDL?b3n6%9*_qx)&#g0VA-K436cG}`LWnQarwO~@WyJhy7D?lwAT3}y%lVfOXG zf}Njl4P-ZguQnB$Hw!QQ6oPF<JX3L`I=Psr8T4D31Q41yCJ`ctcNpMmy@@ct;Qqygqs1W0has9p@|@h2lY?0l-9lk(sd^D+#doq^Ew2I>!GMZx6U@ES3WblD8uub`=C9^~>-+T$$pZC>_+8Dw08M?mItV$Lth&lsv>Z@;O zz~H>$IcsE!KxDJHtM=VJsS{2znwT%`ZgZCu4o?J@*Dn`hPI4g;6k(0*5Tv@9@Z4eB z-BB+l%E^H<%}cthG)oC1=EvEOV;sE-Lra-dkXduLQ%W2F99Bg)OHaOpgR6vsS`&+sSKepgd(P?G}^wB4id2Xo2`^II8LxP z?pGg6FjkNoKl6thBr@y`ph@Ti;VX)H>*#btkSYf26cOLy=3t#0%wj#Zo(|*4$Jpq3 zzzjdrbC8YfYT<@kzZE%7b!w88#lHJmbB_`aEb!xyfI|oXy(T;o)#un!KZV0r+ib07 z>mnB>hnJwC)^!o^L=uou(j|U{^=!M+(2oHh1lk3aHLZJK3mj~Ek3C_E zJ~HUaur?EXx&K`a9Fezkx?Y<|ja|D8(D%uQ-KH1dFB+d;1(e+zVc-w2irYEt&X&|U z#jKnT{7p}58|?osr+4v25UD_;5C~bw+E>*hvV-AMC~}C%3F~BP;-vkg)+I0r?SZoO z;J5E}psQs1srL|r>P}FQfm$8CWTCkFYXkC(hWGUv-nQ$N0z;q3)A!?}qL%K?Tb-CG zFzYo~essLC+}47d8A75lN!0?>AM>#ycl5JM+PC28aX{a%7acdx2gvZe^V%OALBGn837B_V1> zfc#0%M{tDvcXq{Wz~DoK*f|viUu}|&m!-i&T>#xEKS4NAS1y^DeyBA*&O=^L zpw>b1$O$NvQ55is3xqv~QX)E@S$VOG?T{olsd#_!O~?o9g6?zS2eV)8vxW!HWHkSp zHa+W+d8o8lzdUUcKz^&qagAA)qB)&@;PMX!e;Zv4OOogop=clAQJK`CF`?85Gx&@j zb!Snct3mFgka3@;%IX_y5;1SV^%WZaL~yzCdBvH-vqOXSX%2iJ&&XwE$ z(9~hhMytvZcVtrp3&MICLkU}&1oZ}(E0vGN`uor){h#q|PT*)5rR|uB>B7CZ+!iZ+ zK-2q(E!9J%!UAeg-vQUt^DbqZ5u%i3P31_A0u2zz-}ddzAT>aoDwhPUGvp15 zLuJkZZKF+g@>_BEQ9InWx?DdIY%Mb^sPZ(5S--Pqz)&1?^OiEA1W|?=oC5uThR2k+ zOR=6|i7b=;L%kne2?!f7F-c79-y)0uJ0Ie%@*l+Z7LJNcl!vo8h`K9Wym&c>< zULKcam8VP?BiUcffyMabe@cfv_BbP1^C|*N2<0pHS6^QLd6FI5UHkZoPCDHEFd*nO zb4Db>)G29|{D3o+6v3Q0`ou*i-Y>O#qnw^cb6hCskbW76qug}F9KMX6+t z!VwH|pd@^J&6JyyWZVs1dRs6Gn_p-TEvT;ZeidO~hsCnAr2F)z;YuoGk8B<{mbZQ< zdm6dT9#Sdr$?hHB(&9-RyAf2eUr)%$o~B9bi8wJ}^shcc{TFm>5-Xqa#!aO6mQkr6 z);MN2HL6Ev3Z{cA)ts52m_wl1?@F}2M4~cTmJcXs#MlTwyvc|nrzFnk`x-3mSpQxd zm)tzgO}>P*{CR5lz$wl(Fn!UINM4@s&j8o0-c4+qh0Cf3&zQq*1^#^}9#qBSSXmyVeK)0Oczlda4grH_XlKpbf(D;vV!K z^RG0sE(36G4`%|$qqh+Jk*Xt+igMRW&O*kzXi(K=#)N{5&&<-zX|B2`WteXnn|pki zc(rO2yhJ$`v1M*8@U9(DFAk+%y9l`7HG$=s|E>qfXD^tm?&!R_i!vOsOVz*U>Ej_T zImvDws`8xT6^r(#jm}Kw{tChsh=j&gr zTdcD)tur)W(gE#`iiA`ABCKGgzxqGAYOy0+Y|j>jdu_wl=ObvE)|vwm`MYy+fxWDA z_W4wv1{)g+N79cIXc6Fk4gO>AuvD?hKBW=fM@j(k`)=$>O?F*ElW@emCNV;j8S=BU z3!FbgiXhJMeb{>b$boDYw$&dyUjkHV%eB8(3aM}^b1CD#jcTg^8h?>)>o6SZ>$!p`pW^_xqW;sQs#- z8$bE%=P&8%O}&zG)#VJnMzLOSIFaK*!H_9n{!9Lr!<|Rc_^K#dJ+?PB$+c!@#eWA| zJoPYZ&4@-+-b*10Nh8x7Lj`J%#158;oD3X({@2cfNr=Q*;1D}XH|zxegCGmMq@c?} z=jCfg0HD*Gy8=Fl&}P_7Lz(oe4St)*@+ngA!rYZtuJ^KD`ZV#6v|jpeKdSgWP3$iJ zV7|6w&*h-+pG-QKa)9T#Dh)s1Y=`ik>H-@j*dtFbj0ihljaT?pXVcSIj*==H#71K*Z!P~tWLHJa$P1dP@>-<=y!qPIjOH(d8NU#< zmQz^FAD-m)XH9$nE(SWArX_WX^JB0Y6(7*BO+S2dALJrk;zzZts|6Z)rAAduK_XGy zNvkLFTD|);Y4(`Cp9NVWT#Djv>NF7aKV%^GgzKRn;sC?{q#^)_t&axQj@SgK&W^GA zL9x;4V-6vZX-!!*L4}BMa_9ffD#VTe*w;1cPbO1OsQ{FqUiNZt9lCT9R$pEEQRx`E2S3ar+vst{iS>*dFVBpc=7Hr-g-u!(*#eVJb=z&mc&6gsY&3Hq< z`I%3?+|oy$Dis{@U9;I@o&7~`PS59j0#C+(K6LBH3KjRjcuK^IePod!UZr;_LbLch zcG9vcL?ONC%Rk$;1)$`wc-8D>INaVb);KCzt7-=}zBUGW2+A4*aSsoS{%;MuS(Vps zpSn^2csZjUdRvpd4o#)e*yJ@~>_Ml>*>JY6D5N++Y)QIQajkne-op}YQ^T4;%?3c> z^s>i~Y0X}wMuF8G0v)g$MXqiN8RcvW&iEv9@c1C$0S%4DM<&Qaf03UGOcq(J>SRYB z&1+vXX{=Ky=qZ8*9w}pl z=koj_yJxlYZ@Rd4)>4v1hBhfH=HZ-!py(!rqZF~u)!)N1>ys#s3yF71bqKK#W<PyYpM9I5Sb3?=m!X z8Xotmk)BO`Pm@o%Vh)Hpz;Yz(p0`zBc@+KP6%$7N1p>*^ObDWM!_tD(=In7r3FVY& zaH4iu2hv4>+O_v>GwyBpR`Whc1p)Q+k^sc)(Qq%#I;WULoU>yr+66U!J~&-r8FY1q zbwIB#HyLmL)~w`*WOkv^It!5T6}2E0Z(4uVGGZbP7<{kFcYc=n^o5Hs$RY=;dn5?8 z7Au=OkA51eNgC?k!i4x#9F53`9uOV_QWx+}beT^$Fo;tT*JdGsW{&Be)KpK>&r4{57XubPv80wxCoy|a7TPC);M*gB8LX5j%u z7e6*H2cD|yuas=J_nId4wlN*kj+8nsWj^qIvRqSoBycu6%9uJX>3?-k3T2QLq<^gR zH%#a@_GzD3*xzQgi`1c3X*WM@Z8>95#md7g@3mPI%u@(U^|v=pWnHsgM*okhzYJ>Y z@7h3NoItVQrD$;X;>CiyTan_$-5maMK|<{;Gpsg z4m72JBQEp8WnwULm$os?&K8Z1ACqsvF?c~M3t&(m)DJJNrV&@ygpooS-Ho;2iKk>t zT^8gB33#=N%bRV(d=^xdu1uwnavvv}-_aPLfHK3|YL1UAM_aW&eVm7W{u-b1gjkT& zy?d}K$K(|m@lq8y<#ErNMb=og_7+?q z-(&xjajD3U8C{ABmXdZrV+|2Tk)^tnbfSfZBT{!*QA7v=|Iq2DMZFoaqnc`D1%Vj2 zltZQ$$y?WO2zYB*iVj&k&lX?pBf~1bMumXznf>i8%{ki4y^23@^^jzeIU2F`*)F_H zYzwx$T!LyEU*dS0gdca+R%*7l+t}{1-*`6Omfhd)x7}vPolT3XG&xm1>bJZ6oc9Gq z9cQ%reYglezdN}4rsaU`QYKcb#EGmQ$r20 zDYcvpqX6pJ5wMBK2KL^jyV|-;0Df%)lSVXWVq?DP{XJ$4+aYuL_DA#c2+A*m-U`*W zHow6yV`xSaNRl{=DDH2~249=_APzy6$LAmBUtV`VJ)bshq*>^t!rKmTZH)_U(<34816hpX=Xcm83uaj*Kde+2`{t5`oK)P$VA_E^1oW zUx5M59rmHUiHtiq2zskTeC|NRl*vK>QaO$sEX2_-5`&t6-Bd}2y$(~gmkl%|iy#f} zBW-Rj8;fgu2E%EK-r$PBSZxhsaJr5BfuO+<0y3}lIc*1xydhX|1_YI zR%~d?)Hn2)LM!g-LV8_)tKrPi{$e02qBdb^K?h&2 z;#2{btmVgvPw0|BbjIOrlZ}Dy28fBhIR7DyRGPZaR}*wIIN++yN+U^CO{3Sz(zUs) z?g-aiG_CJm$HWO%I*IwZzi0g6No?)5g`+CiH92za&A=3m?V8O><^o|A znnWpJ2BccV4+M0uT!ayRnw$>_tW)ya0MEz zL^1e!KNMKc$48S|i5yU5;obRUyLr*H@ONKoWH19kaO_71YFzGawb0bJ!u}>}!6w@n zGsg`Bum7Hp2yh9vSmwALqSrrv%Cwa|k-H#1DSh`#T? zm~QHjiKighJR)3gaeE!mSmkt^fN2SPh{SFRYv}uFXo5Fv=$yY@#n#f5ufdnCN z3AZ=?OXsT>G6jHTBlD;*a(%U^qnD~@(p!#Zdu3ZT)micr04{P9XSuw*4Mt`}@ZtJ; z3ovBJLQj)71gGr*!#QK81OkPJfp=1>(WQLQDDy(H7mz>)g$w!y zw$SncyaW=wuf6!eT^$XrUkZ+?W;EV!>#ONRWk%X4r+T=4RVzvlOLLQmJkO4`d^+o-p3wt$GmGGs`eC>o=v2AF`K!1Uy>T z`Z*Zxwtqp&!_`B*s>#i~DuZZU<*>5r(qgw#)HrTn)*NIfUI&3JCO9lfRZ6u)2L-0$ z-74#a{Cb;R@$qR@{I6@o^}fSY;2x0cUo#COlnq+~e9UaiPQ$m<@-heB#%PA0JJCz> z2&ygye!BvNYH6|X2L?|~H|8WPls8G;;;we?$bfG|ub)>!JtVii{C&L#xtizH_J7uddvuM8 z98tS!h_&m;$CF)FZguwgyN^w*uX>A}BEZ$Kyz*T<6954mc?yP19ddV)Cg*Qp?jU_*b-q$k@ML$ zyvO<^!>u@<7FLK4<{bSE1^=Qh9}`{8-B9D`DGcBwngFV7qs;eQaKwpOv_Ynf(S?oN z0&GSxRNoWpCWn1+=9E<#X$O%K)UYE(27UQ2yP2IHp+B|Ew4VAM7x z!1}@`_2sK!!qiLj#(LZVi!QE`mgvapHx#GCz@2>Cv^*^GhNuQLZeW%En{3_H8Ty>agQKL`3 zZxm7vCS;mP=M4pMc`rTN)AwR6Unis`1aPYnh^5GfGz0s%wRDs^1WT>C?0`@M`~9n3 zBW6%pl)1{# z`BR=)V^w+P=iuC99}WhQLhNY+A<+-gecSiWhAP;{e8DN|L&l;67qZASl$1<+5YePPg}eZW~`R+=;~a9aNoz=tnpzd)@+k}zOTZMq|*iB zZxi47p2~BgCSc&<7YKl~3BFkj8gEv6H%C<){hm6y<2KT_I1F(X#g|%P^VaPG$6T8L z=vgwPFE4K_yYKSjnC1>$jM?JT9unf=fuZnNl-{w+@A9uYN|Daq z%lR#j**yf1*rU$1P(O+s|CH8F*|?S{Res9}xxcKOUxEPG+-)>#2AGcdx`cSupKudH z#!#5`(Z@*tAW1Qj01_I!KdWiaLF-w^)~F2kLnB!1q3s`yIjZ$+xI$noJxFPT5!*lV za@NF+%WZ3Ix|&4p;Yyq=ax%+y0UVvW=9_-_!36(%!={XV+xwBGM$tDE&QeciqQf@|I73R03(kcvZ0)#df%M|N1V z+Vgvb%@^k>4-3WNESXG|&#DuHAmO+`6_4`5b7TlUcVYce)q9m9F%-E^f-?uOe~Z$S z@)4>yz)Vr~{lhhTconySV| z+O2$;zG{mySFoOsQs4)Ea3(Rpe%!!zsfd!t_FCHAy!np6;^D&s?a3q+E(QoxNMz7j z;yvQA)TmI^z>DqKYBg*{l133kTpe#_ykNrpDqX!1E;n}d_cgw6q)Dc{>gU7-U%}~A-xwb;2GIlCDDh+%u1mYw7G?I8?@FMM`Dzt^ly;L6}gFY$WGGl18xPS z_2jwNTFE8mltQ8i8yIL8L9-3Iwd!t7m&&v;konBEyDAen;#fI!d@JYdvd=G1xh_*J zl3o-MS>ue59IXI}`1=}iWv;bOc<1<`%HmR8wN3qTHdPJQqu(TPSSa*4IpgfQ7-%*l z>9n?#)a$^AUz2WO5pOUk^C$KzYzA6MEh)3QrVbGe3rzJipyOoZG3U^Q1+!jdM^yqq zXw~}~Rx=-7x$&0Y-|505qj7N;23=#%tLA8U5>$B)J2?&y5=GmSxP#1#6U1d^mu>8! z^$3aY;tTjFvCb{CWI^tl2K#rCv3s|HAAw6 zH96b2UU7RijL^&B?N_|N>icK(9I)Tb@^xdtxc2pR;q}E>v}61~?&QCZUxKh=OYOB3 z_OfKY^zEk=A2(+NN=~$E`;WSb&uXiW6>E=t3+t{z5#G^OQdQ46zVy5wDvLO646uGC zM-YAxCic9(xPMfoXbi6yEQ3+l2w=!^(tMF4PV02BIH?YZG}owOMdv{K2FSU3(ec34$X)mChlLC ze1cqGvRz1Ux5)E-|0He2RHQ<{9POOHq2fJb`nGavL(9UXv$C3VQK=OmSLicOp0W>; z7UE8{%(8}7a(gbPJ7X)R*NBn%?cxd@O_V;AN6FXjw84GoNKwn0v-z*bhZ0WjJtt~= zJ82hxbLSR=YVONLdIG&lK6Ff~vVFsqT|aMOQCNSm%+v#aJJL%W0^fm$&Ry^|x(r`R zjkR1smVo##uXk`xcTPpq_4=2?*qV6H+mZn7vuLi1{`n=xV0JR-ncL~`ijee;H;>DL z)&m)Bj1Wl@y)A0%`B1cf8{S}986V+)xboi$u~suPT??^Z9#P!#2Ll)TTkvm+l zE#^sF=eL1^#Gu2I>D6z(3i4y?X(N+IGoVH>1-ReVsz6rlzO*0-B?X_#1kiYIW_l0w zCv|zFHBMdsdFpKXk)HX+Da7x^guc>uS(hs(1}=)`HFIb?I5UooaXT2!RriGs{_+1` zqhWWB|JW~n?LrMN*UUz*9ctT8$;EZq8gg{F+=rJrF$P!>NPUcRExhwV+$GDj(jIk> z$u#WZtQHZDy6;xY$YaKOP}0ihq6Dd^MWNY*jGwt!Nn)1u z=^)8MxO{pRSZ8*;KP?zXr=x*)*=Lsv)>qAh59~nSOX98E z2r&XWl*FKBROI~V&u9#k#ps&lf{Q+fR$SV|z|5nOf<-Jt-IjEMasUFDJ`N1lMsI!8 zKHk2+fL$&vUKQvb7FG@2H%k@lGg2~Rg$#tr?o+6Y-(>Bp2H1!`TzK{x{~>&;=IP&Z z^S`g4SRHFZQ*@TW{-+$Idm%}2B2x%1P_I2UHw7st z1tG!TQr5HNhgW#Y7e13CpX`yReBaSgQ(%vOVam%Dlq7{Cm_3e_3&p?&=kjtJ$m_x0 z^;H=FN|+}u!J4DBh_)xTgr{}i zYn6!sXc5cZsFsGib#hTLQY_loH~3TlvppcgihRtL6|%vEDZF5VD?(hJWLh^ME4&t~ zzBVsr5DtCCW6$KZ80oc-m|StF;sizOLUt#{;Z~w&M9pvY-oF&G+LlPh<3oK>mp9Wk#n7OJUgG zd}BouN8LoIjn3Hu8h7};`RRrvef%k?fTiT$3Iq*;-?#y!+^Uc*@pMwdZ3Rr&Q;!u9 zfLu~UNU-#Ayso^cspwgcSPQN4B$T2|0^YNG%gIof3b#XE1x*X%ZQR%gl)`U6WoxK- z2$bH-;dC&u9gnu^N-3abxFvYx>-<2@#3PXc9V3T2VTTM%O zrYV;de01 z`1H|TT%%}tIqVCbx9RxE!$h-%Vhi~jgwLHrO~vtjxI8T_Ninhhud5F~$fs)t&WNu}?-5 zUZs$MSpLQW%xH?Z&H8(C+%=vi!QAilE@dQCuwZPcEEj6{Bw3KjtoAdfFhV{(=x`HA zzIA`{CkE<}RCx*rf=(46q9;sX^v~9de(Uq16+qo4XK*+%^~Ncc;8C(w z|3I65s?UTG9*Qrgg{i@6BUJ?AV}11A36{3(FZxUe_N znvdWg>j#}(tUV3>{+!%Zi~!iR3m^k^9utl=heXgKRB$lYSzA+A1PUeJ&RBirJlkr} z>zJsDuCd!r)@pYK`(v%r*TR&XZ0lcV{eDL7%nkjdwtBidP;}+yaHK%=yo1_b>rK+T zCZ9p|TJ)M1>QBoCgZK-9yv^{by41&Ot?g3jumzPL+T0Tl-b7~0wz+~=AKP0X6JsVR zhDGrUO$GEJDq^MnYcXac<2cthrYz6IugY+sU?@qoVTWX91OTjAm0~ex3YM2S*)D|f z>7buKp0yIdG2m`5(h5rmgQ+8tXufy!v1Ju-uaI>U3zC9*AZmH(G03b%EOHyNf{`Y~ zD#ovenkZ``jnqXogWvoQwtrX&WwA-Ad9b^lqOgAL8W$WQuu-lbixP@1Th6!4Cjm1u z%Q+f-tFfWBC2#u_{xNwM*StBIN2yxHOdBVJ#^CDe{&J8aet&TAYWv=$ljD0aLo1uq zI2bI(d$?qbmyx;5XZRAm8))}b6CT*YEOt`7X&jSqL3^>|a0!ajLHY1#r29v~WbEEENepaPWoT28&2msE8-$N0w;`NlQ(O+5%4};Z8_vZM1LqFko)%jm za1#Xc5y?)u(5O?yJaFMQnbOK9h;_yGAAA8)73ZTT##~WLD8XpqDkbiQ(W#U`hhio= zNlog-NGzS&X1{zBlwLX;>SCqOXkZUPy&;&oyMG;=+opxyLv7=V4Ww}mbb(=*`W#2J5WV_yFMgVrz%&OoSqmd*LVEuIq`RUEK%_|m(;Zn z?`_*`m@(&=^T+OIenlJqI-Nd+YJvsJ9G&`&nX(*y@WkNvv&0H4ys)p3wxoyZ=7lrY2g5QnEzX~& z(!uDnQEA9FthyqN%YYtFlxh=Kao-RLpCm4)!`t`^HMoCdeKb<^Q2ed zXKe2*0nb<&|F6~B;nuIllVZ|az_<7FO*V&E% z{vf#P&hLKP{iXACmAbMmgxULH?`G<|aO}UKssOvU4{^fBhBGEo21c#*BnwCB9pp^WRxU-!l|c9)UB#rPdN|0 zx~r_N?p3#vCTmCx8zKh4qoDUBP@fc`wjyWu24Ve}C~?l^~(;X+of zpH|26riU6FY-&?v&8Qxgifn_$|MfDM6@i?bW$eXOY~%>ugi6u`)#?0(Mvxw7BfjQnHS>A!9hFi z4Qw3EpGjMnJSL>b8Q$b)=GZbumzPP@=LvVkRM6Zbm(Jp3@%kjCtgQ%84@g`es1hzQq37SZ5tiq-4%91&Mv60jO*zfHloIWOJedn=AH0O|Sr@^!Y0arlc|WJm84l@10hGw!aj3o z`XsA|(SPvGwrB41XMP9IQ%o$(T_d6Q9&Xb_fL7ZC9BOmDw9reR;?rm>NKSy~xoSP!GsdQJ&cEgrrT&hdO%0MidBDh z4;H_Q2{EZCs^Ici#rfLChDIQkhztP&%zNf?vt?EO#)}r9EiCX}u z!vMh()wMJM6ylUcNx`#)S9>cBq6Ngnry-}kc4sEXALrpB_Q87m+IIU^O8M&okeD7H4w+CE&v{DzyCEBsl6@)y zD^7tddHoc3LtO3xtvksyF%n!CfG#-nK0n`9`8w=S+(x48`J-|M)iXFd(y>rrB+iJ5 zKIt_A0#*&4Xp)f zG{KtV^{~*X1q;3LsM~8N9nk=ZP5wzqL08k}(0vcL`R}CwTD+Tl1lhuPxrzq+DW-yS zlfA#V67ufa*w{G0bfwW-V}DLwpo_C-$cFI)&PfTEw*OPnw_(qVanC(gujMU^g2U zs9Zj`v2nIBTMU8yj?T_BOz;J#u3{jD; zAM20X86Q#MhOJQ}4EFv9eCz9gO?>R}6xH*8yTZh4240nrL4h~-F`^0-e~7AdM5Q(% z;(fzWO}_QAAC_N@#BYH`$;QFroK!(5&RvYLrG0yg7_k6Il$?!}IePMz6KplkwJ|uE zecmTqWQs%Mpb}v#uyRAKcGv@i(dv2LXuO*X_6^W;o|%nh82o*>JjXAHXR30IMZ2HK zzJ8VD`vzmQN1rVh`pN^8(T=6~gfK`n?90b)j49pmuNj744?0M*9YbanxYRKE*K}dYqBPp0Ndm zoDv*Jh6%iO^4t#+!Z#Y3lR*e5lXD-l&pSFZ(xw*%)grc|*Rzd^%sM5*eD9;JM&3Ej zhy+dn-K$au0-)rr*AF!T6CZr4yPSz4sG}Y4dnWz^>^=mO8{TGUC!wun>R@A|%rU66 zK+D9fm|9(V26)2OB&I8+w1#JUHBxZRFU}#jcF;CmDaVLw zOmQrf_g;=equ9H>TU4{q+Y8#tT^@XLQus4dLjid^C0xA~j zff*`N*zicOu2|0@Sien7iC9~mp4!HC_$1B=O+m8XP$^6de90jcY!+y9a8`{H$@!Q3 zIxlBIpX?=x^C4T2lq^^=5Iy<0G^XIq_ORn6|Nk_g&|VrR#i!xF_IMn4zew)z0*wqV z*}D&ytcWyX@&w;UF6V!4R;Oajz)64r_(LayENvEsMHqc#IjzvonLNiRX(e(sDf!hy za2R;@krI1wX-l;oTi?4>JVqEszNI7%&g*cl1Pa+v{=}*w0(fLaYmz{J$?K!EDFA42 z@FQkTr#h598~}oe)VuGwvf9tgvR0_^cAa(@}bV>6IItYU}F>${+ z4ztE~?81a(rax$LHnuh_w>Qj_^uj}=@)Giy$Z;6JGwR>3Ej~B!dg`QZeMlDRRCOfdQfd{)Fn_30(2p>x*I#xQlJ|@?L4S^xi~zPV6NeD4RwsDoNX~-^{umH z$DaQFAhgc-GBXhPAFd-6!5AN<=`yyw{KSK8d z56!fRc4sp&S{7W$^w9^wvfkEGd#t@wy-ocKyo9uEl|#dwpUy1Y(Bl2P5N~K`rCpJ( zi*GPZAlUO0EFGgn3*yUjCyh`vSc-Gu+ZNB|akyh#I~^l;J$-VT0E$(EfG;!s~QqgXTnR3`;}mOt2n z{0G7kU3|EF)z4WH>9(a5Wga1D+K&Bm8 zd4F&oO2=8IX6gZLIBBnIfmba(uXm{=q7T7WT-;%fVQ@7PsE`+q7H=gb0N3anUad9F1xrvmsU2S0pi{$K_4nI&9RiCMBUB zVFAZhX{84y7Drblsa@+PiM-Dv65$xjryi{U5b4X!TomM-B?d`QWs))pk=ixr7A1UIhBr2^?n{HA(W3q<%k zxy7Gt($?JlO!QZ$Ixpu}jektujjcnDqw#c2{=x)Q^;ez7FSx<%Uu5*{Qv;|U{MAqW z3dr1283N~%sZ`hp(j+k454nyOnM!G z)wZ8`5KE5L@A>#<^Rh@wH?OTzpKPLd?heF1e72O~x^AZOV3y%#jZQT!&wL-qBx~sv z*hs8`Y1ZsYL6*%RCNP2o#rJ5L`Y8x8-Vwz@`hpHAS`0@4n!Bp2MwO-R6h$-X+xF@Y zw7Hn|-qxTnn0m67k5jt{UpiV3;+z?t!w5;GxK5sY z4U)#2SweU~w^OliLEC#4*PA$L5QZI3u%X@WqH3SDlL1W1b3vlH!=gMMBIlJi2$PYk^_7!-lc~ z=%KOjG|6c$K_`Z&nm5syGD==%{EM;aaAI8tIS>FbnB0O~* z;SY(o*%LO6nmk)Rvbk5dSJ1_i*piMSQ0p?DI*V-dd z!xw8{+?PwkU1Nt=m-|;?o*&5NUBRoZ&z5;`ju_fTMJgTsMo&eYr8?}}_KA@TP;pUN zoBIl}^>@L1=WO-|yvn`r+RQd!_H3`(#_JZ=CrTZ@(yPDPgwjtu6yim5xCQ>zv78_= zFbwH5xN^Nwh@O{Vr4hg)=Nv*z>SP)tg2U;FL6PxeaMH>|2h@`9S`L*+(r>rkDyM1F zbR^_X#T12kTiY(R>`e(jiCxnt+fgAf&_J#=fUs+6+V;m{9m{cD^{D#Tbx_Peu(|6& zaAxB84@a1BV)Edk_|1`4!EitVCH2i=NKAEIdKCgl-%cQsmHZqs&pP<0lJBD@3R`wSFuO-xF?nG)4p}gyW{Ie zKUMyo#1maaejOsR#&LXk@m@b_V7=EX@TC8>v&J|OAQxOk=&{0r)3p0 z4f7@tC>E5R>VkoYG)?O-hm=)@tw_)eX&@|zpG#7VXVYCBl()E+QKITn|KlcDRiYJ5 zwU(=~hDa|d#XxZ5sz)ILf+ zF)c+4SSrY`z}MSn1HGg)Dtz_owonXpq11w=$z7UTu8wa@25~)OYv6F4Vz)fV< zXB~R>216SjBs;wkefda$R#}6?O8@gaR7@!?S#hLZSFJre-=kiL>T$_i8D7=?ZV)})6}LLSvCECb zy2m7^Uu!rk=EL$^s;PX`yqmcK`7iy0c?WuaJ)ocGS>`CNZ=_o9yH{p!O7cN#6yXzB z7UG)DSkCOG0^a(%EHsn3whXZ0V^Gi=13V&<={?B4=Td zW3T~Pn$j`ha1MQD#D*2xGz(reIRWtfbnW{89E@~WKkf%$r*SbKOCS7J)FIkD?@Q;E z?FmKO&m)T5=$NL)-juu#UpR7$r^I1@|2Q%cw;Iy)#`WxYjlIuSqni!UV6)Asf>C5!g#dHPsX<1ORQ_K;<@%ZmQ!~AX zkD{G{kGCdi%bd;!8YLOcLaK6XqX=ChT-Yo91&5LWf$Vg z4-Z+(n*#51_2X?1pux+9;k>&@mNMwiI*bK*MfmXn&LjDP(ohU2%|B!+*t+b9u*O&f zQ=!1B6ve*ii?#h#YeQ9%T2y%?0XG#0N%r-6EDjZIE?+*kL6+4H$UBqFFy2>>|2&BH zdM42MEdJ?xMLLfWJomTir1Ez|)VH(gV|Qx8Pe8&E*k>(2&&RvA8y5G5qs$e{Pu*gDp%yt^^tv&g?;o$tVbJ~3 zf1qAGm69ePDOPQ*!WYvZjBhFSgT;owI7*cnL<+7OhcbjJFDnJ(D7I)bc`izJAp%D& zm8UQHC3PfM;JROnwn~Pw%`*ZkyOtY2-?Bf75Kk-K%jms$T_cQ~S4FGym!twwjNY%X z5?Q9uUfbnVwMZeXq$nmzLTike9HW`unM$rd>q7CG&W^D$4JIVjoZWR>DHFpbSI!Cek=iT zDB!HRz&s8}H9T8Uf*pG{}2o!5aWpL=@1%I_5%#bt= zk^nZChC%OL@I)eUQA!i0{zeQSEYO^g4oOF?Rnk>xZs8!G`3Hy7QJ85W99(fQ7?bT0Pb0XTS2Gm)8ky^m+wA4 z(|;SV7sxyQ&MXLBE`uVJ*J5@8+&Y_MQT3N?ZJ(tdfB&BT#>tqhvb}v97a-mD0%+X`phlpQqzk6}(v-KW=0#ohPDnvAl}hF$ z0EF5E^!5oQ$Hz5Is7gk<_?RCF>=mH(Q>F0mB#2q`eXS{{Qwf~}wcb&qQ9zX~)Q%O8 zck223%jC%lW2n$dEEtPYUhbP+-RXyRysjtxVzw7~_L3Fi-3Cl7V}!z<9D1-o$S+`% z;!$-)95xs%2GXBCEY{vA_YFE?lr}9o+5Ra1*%~;dAFb;Z?L2(M8QYVN>z{g`gy-Tql`^~an!WPS`VyLN~b>?b;O18FuwTT zLhJvX4gQS>$guHX1E>9YyI=|7?U%-!E+R#Rr=guc8)evdIVdvSo}|ASe|5HY03xm> zm2KpNT1eT#MmMUog!lkZU9D)z1#1B;JV6 z+b}M_(7}*tqVjkD$wv z361Bj9ZDqjq@=;s+S=_b%R*zF01Sp}&-nRFxLGZg(`A@K!HC3-?1xbcEtm*%)l2Z6 z8}33uz^1zcKExr}M(!MGCmPsTOrx11UI<-gO{Gbq!Yz~l&$7t=O*n&Ws-hlFAX<*r zu_yprhA|V)AvABl#nR);#;qtHq6Gamq(_43S92lg-$hi3zF@sLIoP|xQcKbi6cFUm ztgo8u)7U-37WJFzvI(`gVL_R!qY`!Acq+dJD>UW856r>Vo=q5z>%?lRa6FDxFd+rD zRXvP62y^djZ~!V1C~$T~9ep+=8yBF;$AgpQmi(jNR(5tGGLhI#D#cJr-|MB^XT2ujX zyJkItqDLw6E|5q4x>13&Fe!GYCCyv6_`SoCZGy5R1}XzcFEg!p@t|x)gik>lAo*jI zcaRdk`EiI>Ly88J#20*m5CrwELSS&Ky*#}>UFmHqVzHc8G0}qS$gQ!8xvM{FxXdXK zu1#jsOpfIsJQn`47W=3jl2_6wlL-?`oT8KAxCO{qd6#A$wXz(yrl~91J0^x=b=%S! zQ?x*SGs~t%nLBdah!IOtd2`tN^c%BZQG;hk%JqEqfmH%o%7u5l=0polp4eO)^?T`~ z7J6x%#tFh1-S7e@!_{LaK#aS_IpwX=2FuNx(g+qto*)Oz@4# zGx$i;y;F9J0VlOYDAFJ_D0C77xN2`u{`KUkA1Mb=~7I?(PyO zMN6>+3Is3iPJrUl1}UYu7I*iO;O8MER>2#u?F7ckZZ7yde$4<#;Xmk$o$&cu{;qiw z{9r78cP9u>FeqZa`WV2VzHMXWu>Yfd#uy%Bkm2Ra4fmW7?+ z`hMBy6-Pb_HUpI$^%PEm8v-XGGSFR?q@)F#G!;iH)Mv(_`Q;4iN<0RMjC=|_tDh*j zV#4A4dm{w0uux}kS;b++u-H;RcXzFENfW!Bnh{CrP1HL;BK?EjV8S@@tq-G$x_=Yg zj7PIw)!b>KYlen(Sw!wshh0m@zwf)w=TB7=tlUS}1|Bbgfdpp>cM-DetRhp+l`CnE z5f9!k`Yy8rk5`S}dDReFC%$(68usx-P>_GQ$!KmiF()ecDYwIu@EdE}cl55t*)j2J zeTdYwl7)hdj;fFhABH~$SujWmit-yc{8|2og=HesUr?aU*|3xXhT{f}NGw(u2Z}L? zQY@$%=)n|&VxhwCvXEs7>rZ!6G9ngvES=&ODCvB(zDVM2Af)%^B}xaBR{-(E8t zd7}a2{vZC1W@5G}&vzDN^||yuKO=()*U)X4MNZ`2mb1bVL1*ws6NlKB!e(6VBmnua@u!Cru~;wY%S<)lX&AKCuRLQwc%kQFg`>9=;Bf;T+P zYMH{&FCb9ax#S*HKnjMsH%0z1I)8EmP=2MO@QBfq)gVHH8}YsaxG=gh4)Vut0pnXz zajq)L;rub^P*I}3`Qpw>_BC6)mx1KsN8^S0%<^AtIp6VXau(ZukKS{QB5ISxVG|fqj%?cnW^G?AwNAPFJT~@&uxMiBFTRWzu%xOwv!E-T zcK2KJG-Y!F{-$^tNu>p0*Wi@T6(J(*3I8^6qAQTe4JbUwdufXu7{x%*exMWmxyoCQ ztA~n+G%>Y5lAuVV!fYBK2kir2Z8c9yKgSc3c_j>wBI+dFJX-T{=x)$2kkn)RHBS4!NT|QG951HQYi2h&u0J_ENnfcIL8B#@`c~GY z9#$lcdaa+GXLZh)znO##rVWDR>C6<0c z%!YHEmGEBYsTLR;#^8Rzpys>+p|Z?!wmo4?8#xGnirq(KM812aMMc;Ev`<&VhQ`EP z*?HO)A6cc69*8>{!@4a=@~bRdP^4nggRpCM{hlKKgLs2_^@?d@S!)nHERuzVzjp!y z&lQGz|5kL*ErZ+2XWohof#drUudWT0-wO4$;XW!tZQgxM<=+AAf)cF9-t=i0&rC0K zPwNR4EJ93JAs*_X`<1b{CD03afnXL;N`)C%$Ao(o6yLqcl^-KvzUN(QgOw(;04C>r zp;tQ;Tmbw+8nRGv7D)|D&P)l4W!9b;H6=WF@%n1rNvnrqe6>}{-qm46LXo$4Wlht! z25_w*BEw+M6O@9MkY)fbhUgQK~U8E%bi4rws|#s|o8xqKgO%=@3qs+4t`DH$ux z*wGm@8FZ*{Vh;w+qj(DNXgFA4!Bi)|?#F#xC$C9|4?8o8WzEr8@(LEQh!9ip%WT>U@7SI=!$aNxw*m%RtDy4PB!kq{bwU9RioyM3eedAkAVbl3~q`y2Z*uV@E zA+4WDT)Bv_h2ePgS|EFZIMqth37#nHmDA@btmj4bk|e#p(vkyOLzAX|VsId*M;C24 zk&ufRpI_zh5A6hPXkA%Ab2X(zXNn{u?8e?X2_)sTWHL|xW^(Rcra9V9;{#2tqI9bz z7ag{yCX4Acb}JdO$J2_#2&A2GsFOQS;cTBe3C>BC5%*y!7GI9vpTF^GmER?ns|v^Rf+A+5YX-7@{-`0l}< zqnD`}4o(6k>>SorDbicKWFqCzXR3_fGPEEm&;YXm#quhUHuNF%T`3x`#=(n|LhtY; zgx)W@BK)!6$H0I92~LurA#dcbu!+xviPxSGS736S<%N+a@Pj>Cy4N6@&|C zUt&a7%+)lmYp`2I%N6x|8#p8;Em0to2GC;=_qYrlTSKUT@+=0=E6F|{%hN~AiLb!yj$@WmHNO*n*m;K0fA2w71vp&+@G7m>EILr5g$-JpuG!DCi#lSO7?X>S05o zOdn0`m_)B9R~qe_Wi2*liVo)3R?pmJ&&Mita4LEM5C$RzdV?>W97VXVs(LzB=6UVa z>PR$YeXopMe!*_>w#j$ckTYP=`Nfv4el%3jU6|deIM4SlLP;eX$0A?O3VOtzqmvtI zNTd8E{cUZEMyNajF;ikW)4TDX9~c6d-=}x|&A#q%4G4JFE$qJ~?0+uY^+)h}`FuTu zSaSB#=>HH7_q@e(Clk#0?A$L4KMymyn|}iR1*8S124R|SZYD+lvdaKfqb2p(t#x7J z-=$(+-~P^ETml=7xoccywclv;Wi2t*n!s7;=u3}&FH)(;>~hYYPl-sqH^7wI5YS3E zgz;-8h>yyqC<;k-gmajFG>&?3=h&rq5M}?+<;-{xAYR~scF`UEWxScmt-MgR!~EbV z*o&Cl0G1JU5$0`ZC4e(}&T^Eu!u%1~{(9oiq=Uzhj_xpy-8*J%yXB10*BH=~cwjy7 z3!Gf*9q+-FwqJ&X7yxJT*XIaDvA8AvpK#oD9<+!|atAziY5^82WVPuuq4yT`s<<}Y z;ajeI9_|_KB^HkOtYt#pq-`3C=rYVO=I{&|*-x#-_hH>ilqY2)enQk`PQto82Nuv; zyF`keHJD2P_R!kx6G_!og$v1gm=M+)drv?`(mO}uY%G4AQu&9(k9h<7xr{78&(jTmP z7_cm9n#o(MHJhq`B2DWhXt@F^n3tD7|E@PfTU3aojz$aN@;hlb8y?2$tfEo0(_-c4)-6HzO&k>}z&`sT^~Gi-g!y)SC& zGOaP)om}e#bOm6=f9FH@)@wE@eiER9NSTt0Itx4Jrrop1BE@NrD(boaUoHS3Wj{+e zE!qQP$o=KRD&kZL;1ZUj%=%~y9ys(mhA0luRdr}I*W=Bo(p}-(XDQaly z>T2p*yJUy~#@h95*s@R%`}K;p!jA{ITF~9+wHqZe@XV_O4r}jNp*AY|zBL+55iK?l zK~w5c>D$D9EO#Cwmn>IE(sznd(M=r5*49d~%yPKUV|!bV-lzmFd45JIhM%=WY#%V* zdSs!YEW9j+JS1e0u_XQMAICUSiV?|kblPI-A-~?d<7)XJwc=sv?wvg+*OK~Dd2>f2 zPPywp6vjw@KSBJc^+gzs&+G9#;H2}8ifHKnuA}wOy-4bTH}5Q^QI9jkE5YZWK7$B( ztPjx4usVa928d2=&hO`PX>?~5EIGR^*-_WG{C?lFpTa5j;j62OqNgu!3fsACJ=bU$ z!_stV!?w2C5VD|Amp@-KccX3de(enh&UkDk&)LPf*FzqQd8t%*#IY-yPl?|kTgj4W zr|W>{rH5|;e(YGR-U?++nu)~;6DY>}u%#c9{Ei*)9>_xTaqNBlgyX)~s`wXK1oK6Z z`sgy@wgpKWxdn!`;b;vy)P-0Y02KbCb^4(wI{!&0l7i4G1lV#Nr#?P^n&4E8r)9$%NIC|$b={*aHTBbboz+Q*ni zeVbpWttNIBCW#o6HbD#)Sbt0Ez@a|H^Lk}OKRYmIEyC1c;^0K_S{hT!3H9BOA)6t) zBx=~!kJ-L}yPI~`A@%0obIUuA6{DN^(mvW8K}la9a~_S1A*ri(5>F3%5r_TmX|hA< z>&O0s8h1x7I%DSymP>I8>S#qXsm(s@4CkE^8{&*pmw8tvf2z4IUTFOKmeu*ayqPiM z$G?O1iJfH{7`uLAZ-)39wx7wt%pqij&Qdm1ap06^J3Gkmg-O;JQp*JE#rJmWqeZFD zY^gv$A&~Jp)|N?II8)h0F$@)T>iRmfYIYz-5;mVL3=zjh-_~>gv)xxgJ%1dWTQVYtsB>&AoSd zknCL8%w4YMm4-Itx*`;m(pmQ1e|3+)$1~}h_d{6d3skhw8I~$CWl|OPX+JoR)b0 z_>wRSnXxpUBC0;oQ$s@?w5*jk+)CU|E*zd{&Ik8DbC%u9pN=?8fqg94hkbp&odB-- z4F~E6-2Z6;>pNTc<`-dNUEF~9|ECgEha(A;`h5I+uFdvCGw2>_bVyU`fdUcO>c21q zNb!Npmm+JV(K<9f=5p^@>aN6p_EVpX{@mrZiIxh`8_$*Hbvt3o>r!(3{&M>5^QwV6*l0FGQ!~)RZ*&;=p`ryIZ=5Kh7GuC35ye^|$;kvw zVoipTJ3r5*h(v72ZOg3^7+ZD1;H|vMD*2t-_P6G+(yBg(0mSmM-Vd0n`j#%42eYnj z7!@z8!cOn>wM7lj`$4shU`IzZ9f*p`B)6jzIxVTEj4y-fA~}hE2R*pBVeUt<*_G(N zZnIk-B4!fiXF-RbFeq6c#i>$^BFE{TjKs_6)|}Qmmr5;8b$SE~pch0j3{VLR(P1}f zTVQ{|B&aoECnSV04BGkfa<-cMSZwNnBK?;$_}JTv{W#Y;ru|Rh_M+L|Qh#v0+GTDr zui{^Bjw%dbnEl{=X@Ir?Hub00avaOpWqO+;@E&}_;P=8*b zW`7dN>HLc~FA^a96xQ_5`zL6I8qsOL=xfQKzAVt6p0-PoC0$4rP%O7YcZla_Qt*{gSzdABCMrfCR&Z*?RRWpugm*QJ`B+jT^!F+kWQM ze12)kSn#yhXs1E(m5aCTmH-n48#`LWtoC?O;7_AyI8Qqya(F}wOk;av7u+B+rW)MXybPV~^bTLZ%X z8KFc5ra)Ws`^`kcP%XA8^3Y7W+&1zcc|->VdeYEvL@{}1gC?>{{mGGa=VF~@MK*!p zVy_1^+?m@ZUBmc4$SRDJ`?sGX=XSdE1tkz>QZiL7s)CK6DgVQ_%z5< zE$X=(;J2cH8bO(d7{rb+F^LSO^WxM8M^3IJ10K{ZL!ca+s#G-SAg|5F(nLN#hi{!qO#ooBgOke|?cIK4?a{*__2WYFr zZ(*`|RG2q!7;GR#?vDv%A<{a(TEMWe990oVni>Le`G~stMcR1{uFt;1%a$>a!}7{} zffDBg3sxM>F{kCb=lKOr*;w$hfRj_ziptX#1of?~txsj1T=-TLFb2uKY4O$B;qo z3LQBL;ooC6cg@LW$zs_41r`SDnevio5P4b18ohBqVVh*1_FJ-;>?na-~v?JrIH)3Vs?iV7!)T}cm)Up+=Q zy}OgMDWvQ%y~9kkaHeg@>TcSFrlcA~t6Y_e7|lO;VQ>A-0lPBIyxFM^{}O*QaTK`_ zTM>-P%Lyz_@I*1SX@qES9}&TY1;3H$xhKN!r$LSk zz#@&1hbj@PtWB{|6&JP7otid#S*~0sRItDlu;NfR8hSAGavM6S{-c0|9=pb4cI_STD6s!Vk&828y5FI)TKs_pEc*P_uj&)~ zk69aEH0D-e-{)D=#}2*ICNOCy~)W+WS`?Out`BJVw{k;)e(F#vR#wcYEDoUWgQhY z0^1{N58LVceBsi&ja@Sm1Qu6yE%v2YJ`IP zRWDFI-*cHx;v2r}2XJJRT+v{X&Fo4YHam8`7!Lh+C7MuOa6U>2bbvoqL;znEElETV zUwk@sg?o&(MbOfAEpZvg0!m6sg+@7(HH4H-2GvzU<@7^}3e!3b> z;Qqii2kjv9_}034Yr~mPv*lnWJ-<1u(y)@=UDenk*v(n}dda53A0~Kl(e}|pOE*Q6 zm$EeH2iNE*z|3r8vf!XsAl0x6X{?As1wY*sy%~(=o|XgiP%nBo zx&jfK4Omznj|!PSgVz_6O2gzCK^y!PREb9_S9E$eWB;*n@vt?gWm=LdQoiE%_g8pp zjI$aHA4*^DG||Ru9a|KBC0RZ+wD?L)z(QsZWs?ilGQr0RX$uN1yP*}rr({Z%rVC;z z_Mf@-t?V=}o(4e-25l>CZJ0At+arhd;v#XO)3zM;^v8tn`#0cM7GFPST#`*hn1}WinF12MQQHsX%>5$D*Q)p*}0M#EPR3 z9RtxK$A-|$=p9d)_tE;};Lxy{|MYla#*YDaOH!xjlBZ%_=VA%GMqt4Ii$WP=;0JAi zx@QS`L_Q1~Sji)rR^Y~>*UEkwy23TJS?@#4*LD){0bDB1T)Q8TTtR20IlnaRi(uWH zWE(bRFRGw{oDYP*iU3^;=X1Xj41=3ztJ+?+xmBcfT3PH%96P|vr;XeBvAdm}@9KF5M$giKPM%~*fghH1CM-N?FqMG0xv zJKQLo%qz0RnX;(Z0lgS|9r7KOoHL&HQR*Z0Suzlw?G~-spR{cPDC|`1JDewK>bPMU z2MPiJ=kDw%6V|s4TMjc%{h##;e=?QXj~J;qW2+{o>Kt@r#JFm66=URX%o~^Mu**fR z*RWxGvLskD&RR3Nx|=%d3PMIj68f}U;@^Z>4ZuTF%H!<6?}>qu3h2f}AltNBymF~J z*qb`hqFF^DZdswqI(WKHwL2#>-%6tV>BTY1GR5NcejVF=?NG-;padErCo<=AZxJw~ z!>gy;X}Fc50Y$;pv{%N7_JK1DzlVH6Al!Qim4f=C$LK5FP&WTc)X#*01r zxX*8Va}oW@Z)ZI3e34J3A~9A0GqW@tQyV8=@cV`WjQRGiUbd2g0Czm8;-|DDh#9w3 z5<=LDPKw)nb-Y-a#?FJ6m;AzZ>y=8+$DDb33aXc!)wljLwXC=T4BqD7sNUbh;M;== z*S*0TWP<@ym7S!oWn7AKItQ68cWO@Aii;o#{nJA_(eLuU6wRz+CiCy0d2xolNoMsN z7av{A1&je zQ{u!d6|ZoF3cUoyxNX3< zTW^a)t@T$|2bL|?qw7gOU@kVY&5!=>;P?1ypt(3l;W7_zTZA)7{pdW{O?joH(cQn1 zmtDI{fh|&=n(f`TQr>pB=1WM$AVMryd#|7H$7H+;B7uyij8q8!Vn1H__URQMkR&ya z2$Oy|GH#j44B|>lk&5FvV|AdhOgXFZ))*Wd85#D{xA3s}P$yl73>paUl`pQ=I5`1~ z7-{s&X#hk*`k6JR0ooM|gQ>%m&eF_Qfp(0~V~=ENGH}dx|5R#4-c7GIxSuO1H`ZCL zXboyLx2AYU`smSNH}Pjy477`=v!GO02#uKGsH$*_XP>h-XopOdQ3>kbU97wrDqed?GdNJj)fL6JKY>Y;Ev`H97& z<2*Jx=Jb;ix?=P^`^W5d#zm9Kn}YI$tYUH(acE=fx7(T7oGBp&x1&j&U!d$?CPx=j z@kv6NUlVE#rH^tRILKyP{y`x|UoEFs-94o^58&GG=8(>yNO{B1X8z2OKia;fmb5rv zY;@GP)I2EQ!~-SLVsJ9ds+M9?LHcZOnk0$DvwUf7Y03Q9b04S-Up5nu9ABDAkaRsX z!u~}UiX3I=b6nAyA0#XqI>%y{y<(kdGf0rH{I&8VC4P1y#?h1G|#RoSs!0ywWn){?$mLG#O1=9EYs7rE{lAh z|BOm-BN`BYw|XN;Ot^Ey3!dORiE@-n^b zBx*n6GQV@9Kj(L>&8PLp zyMXhKQ@>N+fGz81clCz1ertDr<9;Wus3wxl_gr0nDuvHb{*UmD1GzEc&oM?*ffIjX zABIKAi`PvC7urpClqvf}ezoM(jSbZ(*ck2(ZtSs6P3pRSzG`6(`&FURCiM4ctzIoh zf>D~|Q|HYY9Qqo^=rxSYRdHFseH(WW_~Us5&?ZxHeoVWWLZg+up3wT8C2P{O@?0rW z!4Rxel{uDvi>%^M84(|*1%@=M?pit*cpxMgwby}bj&gYK4+sPgYX)#fV6qXi#_ZWR zsBce35sS;unNJ|A^A$sl0bV z!i7~h(>jt=orR&%7+o*BK*&s(>bEeEx0MD&uYU_UI3YEwC5h8Mur0d~{Js-J$w##i z)KgVf=O1Fn7HJ48)gugsnQ{a&)n7T)SUMF}?=I{dT)}n7us;<=|6C zIPt#M*^l7`$73Vb!w&Q1$g;~l47#DTeR@To@YfwT)c@1LP572Ma;iyS*(2-n>bM7H zG6~XhN|AuCiu|Q=xecIx&bV-$eLYn2#3|Tmi#ko+TlbmPf zOGV?D&!F8)aMh3{!W-dDGnD1Zseq^$;Kl^8-fnM!cb0W?p@nZVKUvZLa{2jG4^C@I zHBljIldaVcuQ-@2QENPX)*C6e%|IGTPI`wdqs2FXkVMQ!(;_+y8NU*?5LinBzWZ=j zq}(e}3gC9cC1M2iMOtWJ2acazNLJ^KFfAn|-qrQY9BKH}57h>pWZjzg z{hIAJqaSmKQ`$PaP$|v-7iN@nts?=~VA=d|$U7!Jr+LV7sJn6735_bmoQ+DM$`tt^ z$;6&hYfT|_e8_!>U?=h%06H2451;raWGXDaAaJmw%!(9Xls7#t0hCYeywG4ycR=$N z&X?JZ&U77h(EKq|lBK-VTmH*6D71va5o`YSKvH&FMOP0FI#EPRxg95->oYRtIrqxy z5fwa7vd^hHDyAx?98t1$&17J9%=r11!1cVKEe4!TN#?dQDQ2%O|0wWIv-7hJxD zDnfG&(#&TRs!)w&*n--MHX$UE?FETmVK(&O;0s;SieVXzk(;mBb%*@k=(5Ska#nv< z*eG*aB8#I~8=aDz9PqVIDx)dBMN||yeuPoO z#|(XUH|#_iSeuLB=1-8axOaAgPi3Y?^7OLDp3yRe<*g(q7iriDS>t=An&oP95`t%c zOZ07@*z%%7rmlE?;#R}BliFZ~%{G0uo%(>ces9+!X8)`&B5fFZ?pMCMw^ucB+@n(u zOEh|6kJcxuH`kfBwu?TNt3ZbMYKfe)tCkFAsIj@O`^RD323ksWzYwoiN5GMqc~@Av zzLeQJ`I2j|!(BjA+bqXC+msspXtdZ}eC@Q2lfCCEMm+Xj+Behx4oGPqYBOmf%xA+4 zoJ0=LC$OKnE&9Ha?@aL$ow-$*DLTGmD!i|*n#B?l91>+RYL)k1!%4O=>wOw3K@rO9 z^26IsP0l)}<_5XbhMDY0`v@v>ZEI#IfFaAVOQ~R-04s4hJ5m;2@VUo?xJKLCF1hyX zipSyI%gl@k(Ou@BmwxG@a@Z+c%IvN7lZ?_!ITfaYuY@SSO}vJ?u?2T*oX>p%7_g}| zi;%L!;=z@(LOHNvD&h8%WGwNt`_1LPW&4RkGhp_O?;-O})WIYnM#v}z7u(wl`)87h zBRd<%W%eg1isaf`%_O7|Aw)CMk-azbk4WA-ABX6{AhM>kFZ|(SzpUMcqsICHOp)&9 z)zN_EsaGQU1_}C@LGjL4T?>tvXe~EcJO9hx(g<$r+E>3u+a1}k*tt7tJ3W_rI#1yB zS)9tb6_7fQPw%?_)dw_j&8|f?Kf^Q!+I+-_+#~$>*Ia|c=~JJuf1mN{pU>9Re&g4l z#v`QelkQILT3joC{a@tKf*wgYcYDT6lneP|`=OM@%7l97`?KBPp`z;e0l90DTkBBla>1`b6lRF} zMMDQxBXq7wqQU12-A8iabl8YuFv4~{_3G-%{wtj}jlS!!LlM$6{nC@2REG+~sf4Q< zV-^Or)+4I~`OmH3Uujillj}e84@BL8G>L2iRCuFf((Y$o=FeRKs%aKLMKNGB~9z7Rz(&E9g| z&A5TKmAoFGDp{$SV3rr5;ENoG0!9!srfSw+1~vNmG(^;!^CH=3IB6Bi%lE&It`A!* zH(j#s#xw)wrf_p7zy0|v;X~*va@FE3KEnM?e#C z?sL*W)2NbDJnr<>WX=Do(F__G!@AU~N>8W&wQH_M8KttpFdR z8w#F)bcmpWjJ0oG5&;T!s8RYNELeh|n;>qVt^pHoN5<{6oU>N&`*1jeI??9$iby|* zV2mLE%Bb$f(mI+6`M~dxKa0uJQl%dEg4A6u>g9*Rcor*T4vq;{+^PMY|CbBUR!7T( zf&vryyUmQ|*{Fk;0wfpi#nOwz;bdd3D6(N@!WD=t_+Bw^OvCwe-NPVSq^%{*#6=q$ zgujl9lnA5XK4^%lRQ{^b(MTXm;~cd+$(!XQq&to1)I^wIJEQ@&;&!);UOlRCZZ#8a z#3ifRVZ`sLVsrRTz0a|K_BOo&%`ok*s3N?Wr`aH#DZ-6Rg&QJ!%EvyQo7iF*FzrAmG_VRb+xA=9RljeUR zL@%^0WH51V*>xP9_|t7H<|FbJb+P(*fAVzR_OxmK7$bJtexBL6pV@izqm!U}D);f? z-_3iy;%UBije_7F2Hf4<^#Nbe8XcXUO6}t3)Hf~O@jd-Y@Z4jm?6gUmKdV1!J@g(A zcvO_SolNk*C{)DSq;KDg>3ku1-=yhxP|WAI|HJGmP3rfS6zV$P<3JZHb3Vv}g0uM9 z-`oHuN#ee<*{06RhtsF6u3Lkr?`wCyYaVyUo+y7Kp3bn54n_RfPP60g#Kv!vJh%Pn zkytH4NLsFQU1a>GibLvV>lxBB`CqVXAxsqHc8*<#7(Cn0!uam{IV5lLiT#`^j**gl z`-;aRVPJ)V9irW+8YOmX?}YEu27X(o@7mpJfYZ$%&YAxd6HI(Z(tjwwe=PQgMqU78 z(}K~fQ;Te1O$qt8YGt;1PVzN4b3XYGaWPx{Cf$<461oC)Rb(HHNFPR?TO19;UHcMI zp+iSSu21Jbxa-Q*x3XI!-iR2$PT$*Xr;?4Ky3M@%={~#RAj)P_OR!>9SCrl6G6s*7 z$9vHZ{(5Ht);btA*p_Iw)*!)cv#sUF(_L>&HHmI5#8q=TW09-S{LXsL^m^V^AZ$Px z1EVE8FbFvaCy)Jswwb1`m!-05+vMx#i6q!C3F)T5HGhMSAAw_r|TDcXI-v^luCGW#6yI)VX`KF7X=0db|h!ih3P?C&7n>- z6$#bn;a=Gvb=Fin{bYE6G+HzsCdWBa&Cs~-T{!q|uIMoGn6EVTvv>_d+9@IImdaLP zG$%>1BN&z^$yK*za<7Y^B8T7|OPapt@<^&+RU-*3HsoAP6=|mk29bMD@GL{3n4;h~ z&w-olh>{)LYG;H@TUb~kEYvWPt>V~NB$h()y`ZPAwN>CEhP1=$vkX|1`=QT!j5U+3 zR}TU!r~YoLD6hzmEV^k&CW8#r?qXwl(_{HAKN%;88C*<6OZge*GDRuoFUdEnrlBL3Yub6Lzjefl8Fos5Ih}J| zFy95%tAmSB@fxxrATWN~zI2E`0B!0d5&NzMarFsTg_+S;$BrnIkLDdU+D+5`9n-FkAZl6;qA80Yd zHi}7JbB2vPU;gA`TwdH%KjU*?7J~LgMGK`~IH>bGH?G(KWG&%=Mh{CUu2qCvMUdqPUDIjIE{~ z${7S_5c)W6fBT|${lSd)=WgI(iI-8*$IB4W>+tL6qy3C0_4Qo`1ewe}r>wFW zuk#(abD0bm#1-|9G$A0IdsoTP*{b%}FW;80jBoAg8`5`HPbRdU zkBP0_&OY-SQSEedfqL)dM<5|sQ~MUfX<3`&@%aXEz~6r%I-0b; z6F5)y?jF@#XYCE6X05C1yOm_TrenLh^NiBwTWc}9@u4UGhQ{%qXiIE=lP)!jcCxhU zxy(6-KD1Ffwr4Qp&^v0p+FLv+6ktYs+x|c~O1T6WuyYF51qsRWAHuFDsx3C*aWY}3 zcwnRtRMw`SBcoDYO^R_UWOuUXeU8}PNCK^lvi5T`@#FiFKPQ1Fwf4oX(5U1xgaPXoe{WeZC}$ z*`fU4fN!TD}&gOUdsk7Re z?oqLi;k3mgq3t}Bt=XFYOX_0%&D44gq3VO?kj~Ro-Sm^2iR(k5?uV0;J<*K^$`;nI zL}S3O2ZxqUU_{pNaG!~6rGF;8#r5zi6o$Qwqj1Kg6;j|jGtF0Vn~ffhwzY_lHou}i z3TX6Hr|8G42z{67MYCiIBz_rafEgCo7xTsmU^PThl(eW?=(KHt5w|qj&Y+v9gqSfI z9ms-bJOU<6Fgb4@`>P+_r$_qThe;v|p%}6_k4dED5pHtLNhBav5K6sHH0o^ZvpQ0^ zt;8U*_oz)VCV{=M0L?Qda-HmE?wy>XCFA3v`O^8q3I*MbYT@s4@hYD@ruI&N+GNTb zCblOP`YJ&1A46>wEQ^W?wpW*bV5(!lUlasXjZXHjY(Z8es+6sPsE&isqmzvSmQ6Ve zOEMXT$>JQR$u^F6K7Tfv^*u}Q)92*X4U;Fbn@qj_r0}lzI|t0v>ZtTOK>J|CbA2r7 z#JtaH_-fzLsOanJCRm2rYZK?Di`GzhTxb0#ldq@Z>RD($zFOKysr?>~{mR*g{W$S` z8=;hSu9Qvxe_IjIQ;q8xFh$&j+wJZGmfLw0pP+^t_b3lDJH z|M>yQex;tWcExQvdl@{Joskit$D7=MdxHS?A3uM=$3N`|~_N*LFK_D^OMHp%QY)vdXDv(Dlk}Zoec@&eGY_z?th8u66y(^GAfC z#6Uw~`zHv33FWYgpq>KlIwOiHDsKz~jp!%!1!KSs*C@U-of?7ih%CdpCJ*@HbfHPl(X)=Z;#DRaKpu<(y7>Kb1{v zHBdm^7(}1(6`h2O8Bqk_{A%iuQ46dP=_m$E_y-FOPIuFfrl66RSbUgr2xV3fKB_{` z-n#M&w&H2e75kam+xXY{Jz#=99~zmUJ`*^py9ah9Nz$B_&!mpY&`V8ia#~9x7`P@R zk=ss=c2pkT@-8(wLKPRJ6iEgSVtw4?cOr>we*{Gi3nwjjB($}Jy(CcA+>a7jKNHa{ zP=7a}Z{gP)9=9$S!mlJFaDCAl08FHju*_AaZNgny{msDT^D{cP;j5T$hw0H~{%PDS zIpbLKkt7;RSwp+p$B#L#{WD~nHJ#h!QB;ao{+RrI4Mf=+Ek6F5EAQ>jhQ&)3W^~d_ zrK~MnxN78kI#4!o$qDgP;L{1dx4ULJUb_o$g}@;Y;{9ueR()UOMJ*P-z{7IV#X(AfrxPgD8%_EVs8T|EYI zBB(5VSZgJx`Ypp-M>7==I{5jK0RaJyGz}p8sysr^oNxyvOUNGgvcurl*=scn7h)Ug zuTjG9kN=KvDKfvE2dwX%gqbQ?KF0zHOTp~HKN}vPD)#XTYwyr{5Dy5+6DP^wMA<^3^Td&Ipl8DwmKt`sutd zmFHOWh_G@NOa3`93|R1-UC`R|v&_rHbv%eW1^Wq^>HOhI>q9{W$6#Ulpw+7Tes6{E z&tvMGPrG4DSJ$^S)}&~ab|hd%iFq-@1Z->C!Q`2SvX)BwVTVvOeA3ryc?GSELw%Me z#NGfGA+Cyt3WLT1=)odv&XI_{p@)_HX12`opD->tiZYY(PtnCq@m*RESb|3YU^`%O<5)SYKxzc2fcShbH>N__2LUo*hxQ}fefH9D#j zp6^!gK+F?T$BP_)b~_Q_zn|{EAM^BwI$&S5lcKxQ{DB9#tkeVYU(1A|ivJnzJN3VA zyYs(vuk{)Ti=jqs|C1Kr8_|urF8l0$z4oc}=|a%_Trl@xA(wFd7vB>-Qb>r1h~R*% zv$pR_oH}3gJ^kU+|1RQfn|F7ESOPWPqWNY=M(2!S#jn-bIpkJm}5 z!vmb8Y*6x`l$I9w>^%pR3QFc;1^W_NG~8Cv9tH!spn-(xO)_wv1pPA$4qzrW3*}&?hrriB6Adoz%IoXMq`Weja*WORUNW4{Je> z5{srYdBdtiCwPSiqhDqTCPdNWsS+XbwfX?W4hmymRE}%tTOQ_VC}a^*$8mp0G8~yT z(C~tizcBI#IeKbLxexE>WRm7ngA)f0qL)7FC;8(DL`u51TpWwxvb$a5!PS+1a{uxl zScIiv?OeoRAM*I)lNyqx0C90rMb%&SzV44v+*9g3@x!>zMln#zraj|i0Lg*n;2~tv zas*UPXdI!2I5UxVZp`ZlMzft>#2^7UGIIrz=BHr&Q!V9t-JOqu4IaR8>QY8coCDq% zbwNn^CF9$x(`zUpD?-hJgXDRQX(6mHPjb@#PYeSudspgTtJ6w!x9!crc=VWZJT+#( z(B^HfP}8*QBlmpcy=@*>$I4iI3Yget^}bnOqTr^kBVp^?e2JVI23~IGPpEZfI={^u zfJmwxLqu$-qgW{R~9qL^TcG54HR7?2th>;f1pdes}d4p8GOp4B9H zR3cFyUY^mzk40U0Rn^khOXn=`ifKnfr_x^nMA1v523f?2e3t2MeHfzt#ZM;$cA5&i$6=eghOGzlw(%s$N-O}9+ z4&B`i(p}OBgLHSN1Bi5|fOJULefiEgYhC{E2Np2Q?AiOtoS`Kkrp64=7CG_$STLVF zWu_a70A(vMQw?A_X;QEbe7NV${A8xHKxIlDm8JF4^lmINR1k(7mLCH;g*6w-RUWy! zcKiEkT~CX==bE=EqY}h$!BD3(*7vU&i$9GbmQfa%J3g7kW9P)TxQ#z1JgK|ILJLG0fS4dZK$#u!!epW{3(&$ zpvha|9Z6{c6$s3QPU5bhzXXTHhz8au&`^oBzV8l^Bqi%3MUz!ZZn!nFji2`I5qZFM zt?Ig6u5lH|a0{@{^PkUlg|LkfUU5mE8Nc$YVvw16mg_R}@0waCwRm8!tPI@vEoQOo z#fnAm$C?UH#ggHK&v69*+I8h1XGe3z)XuUY#H3ctgxaJ<8QJ$=-|sp=2-xiCz7jyK z*vhsg<_qZYc{noPBG|YqBXIO14%!#o=M%Z45P{kJ z+4J<1hnsu2O5=KoXVqz?s)hYZA2^*8E4+TEd}~bab-uUE5W0vqu5I7FS#b=Ubp7T! z^O5Vlgbzq)^Vy~}vLT=zZm ze(Pc2wLbqb!Tb)OAR&UH_YMig8B;GOO;`8**YS0%JT9w zrK~X(hV=Fbotv1EI|+&|imV8|z}@ju-DVVay;kwA%%=eL8AZocrfW)Cgr2r2?oawe zpNf6&3i6;4eB3>NfA)`pxd+tp%f$31trNWthP&GW-oO5HdALWRj<=Q^i=nlQzk}nx z^o`Q6H~k>ojczea-@xfteEjK0@9ZUe>oNyjIKOl4{m)4JmWMI9(F_yCmPD0|emL~r zpstD;>Z{doG={U8-07ha-8*nQC+0#q4dq^H$q`T|=th%nj|$rmSJA9r;H%@##=qQm ztZBcfXj_n#4NYk}Cw=|(^Le`RYP9$*?9cPj3&xNrJi6mJX)?44$@glB zb+!k7ySX?Ls_uJmW>%-|)n|{n4Q=03Lp)84W~3w8bOB*CsGXDu{g0pq%!rw_@WvPw zW@56WFkzBpP_Wwj84g%by6KQy5vn{LaoyK~#2E({vg$qEIL*>~_*_0t?jJGsVOR*E zwAG>n>ct~NFdkuoywi7HIvD=oNRugh^*`K)>?Bj4np9LZxF@0mPU3Ak&)Ko#%ldl!&UBM9w_gezA`*xta# zyKMZtO8h?OoO9Yy6Wk;fuR9mcxszy*YO|#`KLq`GjVnl}WBZpNlZ<9t`_iQY_)~TF zBT7lbEE8eSj8~p=CaYE%_3G9a*uvK9)>CBG*{P|a#M$#3!|2$_qH_ND@9u(N?KIrP=w zDj{KWf|R~Kuo^Uoq?!7vm|WII1-mHe{FsmkwwWZTVcv`=#xTK0^d||aW zoxG%^uB0g3ty+Dk=vW_eA?~{d_8I9B#pgZgeD@hq$Zz*A#VNXGWGP^N@Zq91-p$gqO)sMKw#j;Y%vRUbNlz@{iO2mQ zKyv)fzl%1--QI6vdLGZ&&}hSQ^xGi_?G=+;F!DWV-HH@;Td{9hf8PsPKab$?8}al* z2&$~<_IYKtYFMf?zB-)xa<2lDf32H;UGoAcqFU3!A16w7>L`;aP%Q>C#o&80i+AgP zf*guRjC`4b8my&f$NOg9UK$Zy!SVx)iQgYu6k%o!@Pzo zCO+n(_1yaQ5EuvSe|CJRyB92H)i!?4!VEU=e;Z1IxoqgX#2UY1a5nF>9-rNiD`OXG zx_X=ODn-j2v2l@~sZ?(?= zf^bd5BZh08m6)0ABx8^nQz#i`JW0jQ+=58U>MFl_Yq)W1h*2h++2sa_bX3tCvrBCv zg^ooV=(@}zC$AmKf2S%*q?ix(=9;qdaZwf?17|75+l$ctf7*}*RNvp{?p zDr|L3EIJc$xcZnDq6DX&GljDv;JWwD)lAL=T2&+`SXNU8wp5`1j>OrwBBlDwszH~s zRBJBzr&-;iF2oZ%HgBlE(Txth6iwxCdpx4vuTOui4HrJt!5*?k@-7mV4dJcQAk@># z^p+G4Pkli@!WG@srBU-_$8>FA&64SN@rcw+icx`hXe7K-{b6V{5ubkV_xkatd5K{$ zr!Lia?-o2owec=~mG`bdcv*Ijv}SPoC+)n1JJwJPQN`RuQK9c2FD53HsIpbR z)lFbC<7teFIbea|^JBhmkf8=gez5uTTAb|#*&4iv|M&FmC;&2n5=c7JO%+MWR*3mc zX8G|tSm5diQE6l~KHJyfzyEzMoMhUb;-QvCgI>HHIx`Au0|8mRXC`#DUT*7qeGTFt z=wx24PG+sF$xawb(H*J$NtBFS(c>5w+nV-xV)%roR+56$K@>#=LB}4EGCzf)@F|>E zLVnj0<~D^GB`cR#Av%r18QLx~sTz)dsX1ae8$L4VET59gD*3QN&salvDs#a%+l zi4=BMdy^B<0|G0=1EQeasY)clDA=TvxY|n26PTf!fvgz024wNxy4rT(i9}N6Ihg{~R>Ix6cXxmJLQ%~+|8*rO(ylt%mUgsyD1+Gr= zOoexo6|^+nTZUHl^ccHNyzN1K13x!>Z@wjUk&#nO zZxxeN-D_!K));vINwZ~W+ld$0{#lw~)E;>9k!Ka{IBv-70*G?*2Ud-D2|oXdp`I2K zx+ramV@Q4N6YP5Jh(M97w1i-#$3G*!ov$bU}T^VCGl`(ljlpbly;avMpO<%8SJOaZeRGt5g7G3y>0Fq3TuXAbYb+)jD_lkGb6LG(3@5f)Ida(H@cdo7EK|m zE0FF<8kTqh6})J=7bNXvKs@ee%}Nr*S8AkYmbA#r%i!#$Cr`JeD8*Ykd+Wb3_0X*# z*MFLSRjb43v3Hes@5hGBYEI5W!ZgJ7__?MuAIRr2+wnSHjJi2Wf}#h1_0cTHi}}K) z8EdgIs7OiboS5B^1y15;`>O94QP@In$y$ddz(`AR@>kCM)?876BY>d8$8WgKwH0w# zVReGdgBff|Sal1WJMPR6>UqE7DRF3uW7MCb#%I~%O?rm+xml}X+t5GPofpJMvB zc?{QU1Ld|><+;9iEyx#t_?xZL@K$Nncz+9wY+EU0)6vC6vJVx1!6ZD1Uugb~{1`+P|^1G_N zJvW-5kV2T-QZt!E;amu`alNG0zA=S80dcWbO{$YRkHcYb+B6388g3lCZAP|IG(oTl z965qOpX&88cwAz|kf?d&KqS5{m3`OF3Q9rVzlI!XaQO~zT9!lI){Nn&7}H^9rmp1n zxx)1L`sjceTWa!%ga?l%L))$??Eo6A^Mbeo#3>?&-z3{~x4*0mEDs@^;qt`Is#ieM zg+OLS!+90H=Q3g-!Us!~AmyVWn(z)FN>?L7CxK1Hr>D!4!?1Ud!MS<-h&3U!K>}Q5 zt(ASqQiTp}t=Xu$kw30-J+UoqyIUP?fr;a1Yi(^S48iecOD#NLJy2o9nHX|WXaDlu zns3C9^lbC(@bFp;jWYVzk5l!z5N5OI`Nol?`+ljx`m6)!3uEbq>(%zV*M6ENd7f@P zd;uBpPXTcNypl+#Koon~J0^p^LlwO1^tX_1`w2 zKU+6G!4bTOzW8GZ(73inSJ?o0yH?|WVq4RBIZprZ?&+4N>wYiCalL12^n>>kCUM}O zH0^cw1;dN07>4Tq5T=gTXU{-jLQUnZB;{;(@YRC z6Ok}q??*e{WCuKmY_@VZJLPn`mim1__`xQ^1F=^2MX#BCxUIhP-MaE@^MD`^O~o$n zX*-vGo;D5fHh_$UJ>%>T5IWz*a3F=)KnCPK**HMAyOWk;udOTwK$ zna>u^U9Jw>Q zlZ_f?WFrq8wMm_tMr;R0ZHTSA?p$$^ZJ?a#IHA67Z(#doU4K%7Mg3yojd9BL>L$$4Tg(sl$NhjueL4PJbr2T5w+J);O$k3>PtAe?saC|b1U<*)+11#-13~zV*HwV z1noED+Wj~1<)R~S-*Y`v?cuQI{xHX(T~5;I+P21LI@So7KK^be%`NLbwt%R-=cRq2 zbB_xO7!d6`mR2o+2ND#3VRFIfu`U0xt!33kVdGXAINN~2g~yJB;~G~=kl+?DK;~~- zHUb`dUV2`x3G`#Ip#pDk0-KxJ-i(;$VYO{--d7UUG2Uc_+mCntHa%4mU}b-eVC~9e$Va;!0%Ioa6bE8*nR%C z?)*&n(vxQG@BarN<-#FM>7nY?9nKc6{mgKS@jt|0B>K{hf9r%CD^hj!`FLr^Wz6~e zcHgf64214Xlr6ij=`8)iII=Ufx`^Dszg%?VmiWqwMUWN4Ed6G9>jLAT{J zr7ZP8`_@WfO7sSCVq z^eK7NI`z@6P8F=>{(+*cx5VWb_rS9r(rA6(UXP%XG0$XBGgbe})B_H0ZoUy(A+AmM z53O_(pWTWd*_?M%A)1YmFo&obSM6DWs!tE$(v=>mUuSu-3C-02Cq;5~3bR~{X&fF; zHJes>wc;)$u1EDsIkOFy6Q1diiOp~(9#^&EQ{VD%xgR&k53SFJP-}LeyiFEtg)l3< zgo2h71(yNE=EI}OQGG98UJgTAGWvU8QXzf2d~ezfU^_xGp>5xXR9Sp#ktMgYa!L?8 zmff^jCR4(~eDAuzW*W!i6Dklgv-P-fdg@ROvVv!KjcSVu@0R`5wL)k)Hh?7VDz8Q( z4k5Ln^B&c!PtUzl8CQ{azAXps7VMMloBqn(lCEYAO=LxaWo=~>C2bjv$f}_3j#gKn z>d3<6<8!7pAC%*=x4SE=!dRwuitPWCMx@r!Y8XE~6XNVO*NWM>lKiXjP7f8T;ExSp zCF~7Oj~o&kV#OkeLD9w0ZNag$70%5;y|qWRo|-rV8aa-iuYjQloQc+>61AHXL}g05 zoYTB-_%JH8Og)c-*GoWZ-+dcKh_A zAMlEl5csrg56B>RB$tx_AgVIps3mYkBmX>%W)KWWz9wSR?Wpt~!GLE+K;&u5miW4y zfw@NzyZhPxY|(h%xMyF;>tP1kAYjSz%+?{}WBYdpM@N}^8R1J+0KQKF3*WX) z#ZqY-y3e7$Y@)uL1K+kKM0mG?`fBfX3=Gb@#_vKW6rKUQA6{En1k2B_mD^t2Yy8&$ zI$)b^K?@#2bJqRn4-EWVqR;<-lex}Ae}OsXn(&gyD5&n5I1f{*@^ zBD6)l0Qx<|{0%rL6pJ8Hm}ThZHQ$|hULYEl7hSw)Myb@Q92P7HVximZOti}_A+Qh8yn?_A?@ERLv*#kMpfr@ zew1`8VlWt+BZ6l@VcSo|MdrwC|3twm$F+|U+@{B#msL6}z)#33bD)FVR#LrUA{R}r zIL-LuwJHIT9AG5pZw)iD?LBoE_hO}JopSXVvHcGX7B~BKAUu!Nm}Fb{K);)ze8bX@ zBkRR=W`3+S^dd^9TK;;_SQgZlMloOX^p62OjTCl%D^ocWY9$jS>PWuUX$QrR7N%D; zavZZB?d#IwSE_ugPK?|GsnIX{`zE^PD?jPS8eKPHXH++ zleM}OF66SAd7rEzd(F=JE}Nf|7u^wq0^MG1gfpcvNv9Pp2UYSNtRE{@uhw9>Fi}2) zCU93c6ZJ19CbXwx`xCzpsuqJj(QiVHJxPH^p_OV@1{CjvnPfb#!SdkYRkg=V8kvxr zG^37-?|&@?|JyNe5=VM9HC?Cg6LI+dm@P{!W4MH5ePYssKxrY!9a^1o`xNacBg?1A z%2ynzEjYi&XvD(|iH;kuLn8;#TlOV4o%iGff7GqQdZ#fV@xJ<#O_kB_Iw75DVJl?2 zNoQ)8-rNwvU$Pj4NCx7>g@<}@IoL_%gN(cT@~R94%&l+|li>GIvr=0sQ{|FyW%4uj zdS0u%n-H z>>aE~L->-Q<&S@wM1fgsjN}f76_eHE?E|EC%YbKDWNsyt%p@NthnwOEjP?W-YAHHz zrU7n08=JX~b1N&y;w*c8WwLLE8mk`!s%8*{qb8ccJbrf1aQK}8)ZQ*>uQ@iLlvfwj zvpi*=9xrIO(l2bCoj1YzWm*aQe%p{CW7Qto3W>;EV$sTNj2b6RD(eKfoonjW-q7!6 zb^Fxy%J+1m?eQhgw`EUXAof1dRjc6_5}8L#D&M~EjMCc+aR6WP%^%p?;=j^TZAfq& z*KyXp&#UQw9!hdImj5(%cK_`R>2ROkmtx;W&{8lSlre&cJ~o|}n{OQyc^)~EWP%z(bZ zO*vSBrR(1(K>xt;?fxt3#>JLUWx)2v>m$pPasJ)nNC0<``gdh>DyKh8j^00GjV}T1 z?4xhbV?xgX3GCfAjsL~Xn@qcf$tXqXJB!(9K&cBe~`wA21TUC(k&v&=aC2{@W`q%Qy5Unb}lbq(qsq?~K zB)?)&CVCu+F)>Wl73U9pJd{H`kxkdIqrD*TmnrK&RFWsMk#Y1mAp-)p!98Dr@sTO! zW0ClD-0j*>A@s?WzfA~C??Kn#CoKQ@$6x%(reE;j?2g05t%}SGryhFsHAldz( z(n2QwU#qdc9>%9iECmKk zR%yJo$n+ngZ8*3X%J~PTk*oN+x~MP<+2W$V`X$o;6=N;h7AA=}88RDf%dEHu&&x`_ z#}G>{VJ>B6t4m{N#Jde$P>V4nVj?*BBEHGduz_MqllWJO+4Q*bQ+D=I% z8}r}?oHPC zh#)3~zs^mZ%@7DwAh96kwDg8;jRM3ub(uQ)yx;S`*u^=S(~H_t0jPS295t35Xk@CG zhx(0gu}EntYPF|l5W8|n(}8k9M#N8|XVvle>FWA$l^9Ml;H0bk3lEQoUb`v)_Gt0DG?cP^Sd{>)}ECz5n%fhl|BeD&Hrp zT}gQM#5frCYk0DaCJXJA1$WSMV}GSYeJk9J$L48q|9D~5>0VGuTTR6C!V*xKZQjjJ z1Ki7|{fHpGRjA$xh|Ba)!BwHfM;d`_NT}}DFAc-zBjWL9_vO^28r;c@bx-Tbp^bfD z#1?is_xgvw?WAhzvP|V^YK`R;W)N`m<+pSGn93}SP!cxcB7wu+4LUgLOw1%G!b%mn zw*FilelzDp@H>& z$q$Pu+Z8Wjc$0R>ActT2Q>S_rWkM@&qs5GP;b=c@ny~oIfFc(VR8B{AAmH2&DYRnK z#Lwa$#Grg%qpM@~qSj%CB{ZudKg}NqNg08Y6fCdDl`OvhtPL*l zG7R08sB)~8t{a%&)zDhO?)W*qq46*4o3b~<4Lw@~@nh?Volk#Q0&jQ(ABE2R9iukk z9oqh+1A47t&#ogwsMCi*nt2BudG9@rZ`auycX6tA1CWUGw@-6F8Hz-kD8*3wXEg6pSvDbGmoRbiC#? zwV%&{0I?T)k;|k6gTQC?fIr#+me=Pv1Lwe~-d^c>zOOrZ`~IHoPdz>x{VjsaH-0VfLqfEdGPL|_Bhal74Y5WIk|@7^6^dAZpSd;~{#Bu+Ny|NDuP0%u>(23R|fEm?e*ej0hGZ2j*% zH4Tvq-jU=@JlpoQzt&-!JbUOG_LOuh84FkiRrzLVeIVM+y&Qo7r;FzEIW9 zfBlM*=!rCvUTiwJgH#uOzXr7~6T@Qpc-3-vn~a#HK8EsNqd_-dei+k(Hw-i7 z|B46!ojN#Cw6d}x$x)Kg(C9eF<*t@Ng;AC68p_j!n;@Ylb+lP(_A=y0kup+F!g2f_ zl{3%&sUm(TNvT93*-wNHM`4BT?B1dV;WWT5pBnaoZR;C=IVHE?Xl*Dk&u?=`X2{|v z7&M7MrUldXCvoqD5+|H|ygM(cCO(q0;@#GKO$<$Ul)H6zoSMtOcv-s^*Y6hcKheVd zOKht}#5;+<@Ng>g5KuOhZLc+qa^&H&$c!rCE~J#D@gICxQs5QL+qW9(%a27g3$RDZ zPM5<>&GJN|6PO2auWa>nAae2TwQ`B$Lm6Xc>Pvbo^manE`|~XsYlH^$dUymMx099y zPjiM!Z{|aX=oz(W6ezTk#m(X5C{|caN)}vLHY=&GdC{WBw1<`|dHZ%?#<4zomT)A) zg{;SN6V){yWFzljspS-0Y3i+RMqduAopWn&&#Emu4@I^1vlfln>2H>;CvCuI9-5a@FC zRe97M=>IUWT&NLKN5DKgouz)WNp$8na=l>4bMz=9d^ipD#!CR0psm3pP2dyFoAq_U zp|#2V^i7)fnhz|UQx88zQj;9fFAmGW*Xn-)CfF@dU$vk-Sxl8cUd|Q!IesR{6mbM z>-Q~J_kN5{z(VMMb{nv98*p}8?RF)THtwF7&55bB?bkw*iy;g4JigA4SfCO{wrE{uec@9g^JSMMAk4&(9zD=Aqn}K;QOryr*6@ zPbiY5K&fN_T?)nd=~v806JuYGXQP>Agx`;~YR|#(pG0b@7=Y!_QTOG}ey!A_W2M3^ z?5uWZ%#Z#YO3SbH`%&L;=tg{Kr&Xi)icYBz7p4v`k^REQKXV)hO1tEtTJI6bEMAH<`K|^FelTXnj}zKFM2xy1WnFx zp>!6VM@a{_dJdvEF+01eqM7+lvJ|W8<$63>j;-MXIlWRYS9D;@+Gc6abrlRgq`PkgW&l5ya zaf=^C{j`se?W(0d4$;!kXekr%4UYA`$Hs^)SM-3AhUcn}I^p18LiViwO)ZIRakhMcIryD{^20%? zk^c`Lf9i&u;M78)UC!k9`*<31b7Mq%hoi&rxT86k{z6%2(}Xm<Xn5t}Jqq&B?n;L!g&!uxA@LMllCM zvdBJiRLviFMD3GT{a!0a; zadmIz8NO-_mIXqIJ|}8h@~I@mSj~0t{+|}WoU>F~Vp@us4=3_A8k+7f%s}3%OqDDo z>PP%!Cwrm!AiHz~TCD7X+=hEY^^vVZaw0`V=ug!P@U&i-_~S=77o|zrZKBO#r%D6^ zlkzh`4p)iYeOD{FFZ1q3vkmy1vlq)_=B5~~vFogu>TyXGQBVi!%Lk9T3v5Z*X=>OK zM#uwZxDlqRoE`c$<#2)0&>S;r^32%^vZkyt4RFxwjbShda+uN=vgBiZ7Fv}EYE4Fm znrd9<+Y%7pf9>>zmV6dbNaMKXzv1KeNUx?JM1Mk$$_6^ubb5nkG&uPgnIh@CQv;yQ zQk;9Y24}xgz|^W>d~@$y+9~>MTrRQ=IsVP@{KwkL)41^>nnQp@pu>NvEzeaS5E|5u z#yy=WrMjlMl`ZYrxw=w>+^flx z(_Kn)bn5+BgEm?ZDE2x(^%Kx6%Uohe8X8C^^utbuvvOtGJ3LiF;hr%am9vk4wVqoVt8BdN`DOk)^W4lLhC}3NR2B#? zrr!Qv>w(+8Pxe-Idlv@_RZd5?XT|bMB;go2;x0I%2s8=b+hlVQUjBVOr5KhfkuR$u z7?W2OrdJX^m5?TBq7nH+rh9Y;B^}kC6I8A2du2)Zv>^ipIqYDJNGZQD&zc@gv5 zhU^n zCMRa%fN!saLtC#A;h?B7Sb0M|h0l`crQ&_TH>cMRRL#6|>X; z3}@WpXF5;8=E+k$J}UinpTZak(=*x1FdII|{ z`~z7F*!1RPf9#`haRfm=$KqwGZ!D|^wjHn{^I5x|J?I`jq++0V1doO<%F1K9$C7z% zOaaT(g8M0LDIjwdHa>>z#|{Z*^ciZWXuOZDOWM!8v7rMGRY46^)$7&MA=E@*V4~AM z;)yDzh45mm$qq_Rdl}JJFj8qA1{5ds4(?jL8ze2}E*?m>JQUN^jaOOzBOOgN zk5)|^$Ui4k{p}Eaozv#fQF;_<`2It67kV2afB)A5jcmhqI_=!0*2~{RpArDO%Go5% zvMH#jZn}smpP;j&6 z&dv>$(>Sx!aACQ!*P;_dt2@(}QoC?bghaLG=sIiiv?6WxBZt{8A`RwJdb7i(vF_{@ zpdnrk14<3qB|Xo?WyK#(%cEF4WHE5lujigBWA!aBAN>Gv6G^3I-Y zA3UMLM@TQDQ`mf!*YMEKfF>r|81pStTbi}!5|J0fP8W0$LSl~*Qzywj*l!w-oTbbM z&Q>Hgy=XY&xDv75Nm6uq z@;u6lzZy1JiE6V6BVW@P}Htuuqs zd*N^rDiU)lte8Ue;j;v!KsYmEqoqgq{;OuhrJ{gr$DmPZ>2Q{j_8DgRs-mC%+UE;w zR<>gz;wgh6eui%D+}ci760sNqMcf~#p=m%P`Gw?Y)4>6ySDd4StjtA`G!l)!FXFtS zT7*Nvn!AG|hae;Oo1qI>q-&b$Qh8lrz^q#*^_L3YsuSmbG>QJ36l2PF!*`&8B>p%K zP$xvTBjqbCX0_YC;ZM|l{O06Nxln%4FX+oc-%I`f!7XdQ6eQceubF&YIPqx$Kj)mW zG-F3L-aN6=5XC@z8CJvh=r>0t2564n-!)S;hT0Qp1A-OTffxS4ol* zMhUq&TQ5AyA32{=9L~~86E<^*JhWA_?O2{}RO;b$cCP{;9HMJM>q|?^%ls`}O=+$u zRI%O41nAMU{S&_@zXB$gZfm6b82q(#*Kbq%4S9Lh8|kyo@`f90{!>ejEzOapqo-7C znH_eJ)99%3a_^g=0_kv_-qTIE^z}s|u#z1q1-BIq3PQ+tNhgLZME`|I)|P(P$udbe zOtHZmUsgNPWNx06?DS;KIfyGAi184@{eGZiHmm8FkE-Spo}sSjn==M_Xg2mt5fwrM z6+2kci58usPLso5$A{w9JKDFvDyfE%#JU-eCQ1dtt~UJq6;G6fZ8hqR{nsotW0^XxqsX!YDv{}4bOb$C@ zB0WALO10b9@-d>-&NI!=3HU2wUQ&#;7oWsaOUgcpQ9hj?D3b_~m#IkhZ=a)(l1H#* zfk9vMvzCH$f0~Wb;km-lpye+M4ndMjl2i{VscsB7zO#OC#rWHf8*$4BQ;=G(gM9Ti zBUrGn)ZVk1S?Fh7NmhsLE_>2Zp+OoCpnftEjuanivEv^2kjKX_Y!)rdGK?3IV|l}> zYQ7JBKhQYaST4cA5t&t-sre#xayI^mtgGdi1aqQ?pT$+V@W>ocA#*muUzTK~OwnZH zozGY^l_>1Y5!#jw0&qAQGkEQk3|OrC2qbaAqxM+tyWcaOXq^O$jQo7Nblcc=A`-w>;;~p#+SJT#>hpp?9B+!f?sVUHr&b zo4CxqZbPDnhSUF6PwyI!@k7K}i}x3lFMnUskH7mjvhOP!oQJBj=OR|BF3Myh-z*Eo zYrc-_x{}0_VVnSCFOOG9r6WW`I zT5=TJ|3KO-;NwJ(`EyURU48Tb>;UHT?rVOm_Ityi-?pbWRL){QW74Y=>>^|tF{F)( zcvq=xAbZFOCIXS_?)x9u1g105de`PsnPz2L6~1tXx+2E#%&(!?h)>Fge+DdhxWEsdV-EckB!DxwBV``WfvNQjFW<__M%y0HSBlyq* zul^Ioo-QDduR}}1FA%nH*OHS&fh{NlZ4VoznB@#0gOos6Agog@_C6$La`fddUN zg$5HV5S(&!vXeZJV93Y5$0=oL$>FLbC;q-e4?+%`drk@XoeRJF;qLSA6P3y52QaQ_K1Fz<$k%St1>%#v(UT&Tsq zz3|aZ3(x@T@iAl62iN3TwhvJ{Y6}yhgv-HjE;S`)Wu%S@8EPAg1cnRfvI=7oMgV6y zWCqB*2MWM+b*vn9wUmD|8QS`0+q;j{%*aTYqkZN#t@IF`9pqMMm!NsDu78Y!811D8 zw@Kg4_Mv!~(P&tHWdF_|f>6#z0pS}bpH^WW+TMLT(#oySPZ zbi_jiWpz%wfojwU9X0XD%(v-vcrjey8p&3Xu9LY1{^D8io14u{2(S5Xv{ey}lifyv zo4xAwz208@#N>WITYxSm3g7=Rn7yf*-UEmL+~%5yGQKHZL1@o03&#s##_`5l>y494 zz@5phIvY&$NMb`|wX;*+e%y!Lr5QOtCxq*BaLOL^C9OaHPG<1WM==~f?gcY#bI_pf zl`b)4+~#y(j^A(N@UDL0yS$Q4TeV+FNh4I}F9gz7C?Xr_MlnCRjB36ak;9@Fj>&%+ zZr|)g@#Mexj=`zuybre~c>CD;tt5w^6bdwvTxAce2yqH`dY7(s>B`v#Y*~7xY0K@l zi-!qpFWEJ>wJqH?oZNfRQ7MKiS{U%*P{N5@)U!6#nnfyiNm3uo{TrR;Fx`r`>99)r z5zQAxl#Zww$8$#|`cVv4#l9Nob#MV)&Hh#Y{@9JV$C|(qC8wjOcj9w?3<*LPHNpfH z;}NdhJ9C87^+iYbB}M2H(aSTYhN+QPz%Q{X`&inM7F~pB1Krrx&%=At8`lG@#*El} z)=jZFCaPBw9pJ65YG2jd zE>*^Z1WR&x(UCsnK=10N#e{?-DY1HL^1vRt&o~pR#w~lltx88V*$&d83eVD@`;(rzmf4u9Hrpu4jlXB;_7!}!y+zMz zhLM!|Aj?Vdc~MsqqCs&KBLL+Znp4+w1iuH*00pHmNkEAcYn**hAAfpc^HZp!&l}2) zN8kCHSmfYd6bIrZKo@^y(3RLS<;Cb>I^s@t)+ba0rKde5mOAxeY3GF>Rj{q{IH}mf zdmVTZ;VNsaaH3?rz4>6084M{}pm6-u^`!J9_g}b{V+V-2^Z{h52K%59N`dc?w z$1GLSFH$F$Q0*_Z=Uy@&%igQ_uVn@c;ntkiwT{Jy*X#VWL`+YLCG^&jHgcJjlPq3+ z_l^%IzN~%A0gy)%*|%k-p>etH7D*WG3eIjZA&CMH4^wF`5t5k^WLEJbqmAPRgT@DF?^g7Fd_eoSf`EwF1HSA=&aTnrP%TQQ5xCmUXzzEiH4R zloe-GR8}4%w6L<0AP~6FQk)zv%IW<@obJYL7i)+9n57PK?0qdqzT*^5>=4YUC{R45 zx{W4g5hY1H)_um!ZFQCBkeNasg-KdU+h@Y8IQ`2Y#`eG5PhLz* zif&MTo08bzBWU-jfPDewOQ&5V=(8mTPQwCcUgZwLvTK0!glteoXPl+cr-YI$)eRuGx2{yX!iFt`*0&%i0611hVcU@+4@~je>k4} zhONVA4j3d(u$wuJK|TL`;xb9(gcg}ZKEL4k!b=X{E_F`Wx-igeq`P3JXWMdBW;~tU zSPdCnvysA`6otX?gU^+Fii$hsU|D{G#J0;oY$D9`G&r(UGk>o_BYuy2OK4b0qFkyU znD5T?m9)~*+?Whch4Y8K#=QE7H5f=H`5cWHWlUiPzx@b>L7Mmr!e^M4g}&9y;J+76prLCK#uI8Y`|z&c)ypk|3~{n_ z&21iqbiC=q!oTyVpKQfVUwV47_xY~o+cjq|*;VxW@wT>3rM^c0KdRn4n$7rsAGS)A zBDPW^V(-|k-Pp0Wsy&L@)Ls?DXzdWxsy$k(wKuhbmZC+>qNu(1lh5b-{r#TjxsyL~ zPEO9bbME*3y07bcUGM7!qJzq*i6yOR1uZuo%%$37JsROx|6}V~U}5FC5p*!J!hK2P zSw3`ndO9{XCZ@#?g*|s_{wWNl#{tD=#@knrIMMRq;fQ4X!l&_Im6>8s^C4iOQe)0} zu|vdI2R4q|^h&gLq~&yUoAdSe^Q)P|bKc<4zuhPtcBROOnz)?FVncJaR4hveUv%L?gn2z7;?!LNSd%G&12+LqlCv_FLg zgpRe-r&eEw6+RLIN_SG6{GCV>m?XL4u&SNaJWZd?@sti}{2RhE?&#M%d6N6$*Rua~6kzIh8zR0|aL8&J$S6l~sjyLQ;}`JAgv#CV zE0mtiLQB=2xUVHPFiV~^YQl8$IXR(#INp;hMn0?ac3)7h&nvfAA~EcJeeVz` zg8ryg{V4p6A_pg=9*9aRZDC3VZMXH6A4&YO^=oNmzl9sv5$8GU_nWdIrJ)!pw>^?A*_K^ZaP?xZH+H(Ryvg{PBMf_7t6bSrWaj*v6_l#7_ zEz9#~J)Oj&yH1xL;WI2ANwHItV>=OBg?@|@uYVmd4q$C8gPSaOR`=^&SS#Pz(%t0* zW3XM{f36bt`Nc)!VrPN0wv1uy6bwTG8~zkM~rogaFnM8YC> zBb|11aRTaMwcJ`sS}plAKhdL!o1NcsYsG$hyeh}sS>QxGDg;7Uc)pkGj1><=P9THd zbsq-&=%2a^_iEC6po7Cj{WJNUH`k^6#?s3s`F2!zGm_y$kkw7PO>eq`!Rks1Hokb@ zzm0D?PC22Q4Gonh5GePaO>rMm2!P|Nqgj9N#_D*eXatF!QBD+HCkMH&GZi9MspNcSZGWzAZD4ekznG*)^r*Ju6~T~uSt z@0#^vON^<`=neLVzxVx9yq=!!$tLqdK0SYY#5u|NAzPbDbb*$9f_YdZ3OhiF(!!f3 zy@aY4?Uo&Fss=a3)bWSOoEn_ZKbOx#K9^L}aTn;xW#zrx!Xb`pLb z6R2(xxC8>U66%#ippW`yw2H({`G&6a(Md1%-N%&jfab)A6JD{?at_0V>i7o}DIAR4 z7UNBxM<5_R@EHFWv<=KFIO%3^jd21qnT(Gp2d3!e-W|7W-x48lH#O6JKORRg-v<_L zJ!45!KP#t0cEnCx7fC1n5`IVZ-zeIGDEtGBw=y^V_nfN(U58P{nW{i}mP~f!W^wLp z@J5M8xFyL}>dv{rOjkgImlSp>)vg@tF}>m)OoK^U1$D_Ef&*pu38arvkt5!eAzf0&)Fy$VrXJHS7bjrgfJzB0MPIvgoL26TH0v zL$QYX3-Pz|N$7+cO;bNb!r6s1oRw*LPTYq(I6#stDZin+4-WXwiRG@bDbC6;TuP@f z_43Qc`MO$V98>4N!a}3+ToLJ|>Sacv(QykM^Y#3LQ(K-gPu>sqZTXI7kr%)tnE)1WBAJ#>1Sb+GaW(&1m;v5PGhoT5m`sVz;FXGzU+ou<^GgC>q^i2N}p5O{C z->vAzEv9RFJkVWkCb7v*V@`MohEg5pv=F}>ySbgeyuT~M++XW7-S6hhhcrJEz{paX zHOwzvc=};)^6;sP*sl9nY;f*v&Zv&W*|-0>?`v0@VzBq-gNw=XplEPjSS#mO76?TW zZD8k3U)KaN6H5+_745pEp`*p0(tMVok2-QMPLA{-wYwLelm5Xq=3h*7};^qbbZ!0eS*nYL=O$f&=u=_vzE$g zQ>AS9>fDrn9{hoe2cJgpMH~^{i1{@wV3g@@L2ABy8I3CHp(sc_TZh@}kh6cArjRk3-wLozz(#`%f4em5`Cra~}N3W2amt%)+1TZ1;0o{Dq7eYC=Z z>i&1d@nnM&Pua24?`nWAy`;3u!lVRQ_Q-Z`-IUOEC#+liPY8@sGdl2S5%pq7LS%g5 z`~8?^#0dUYGyu4wp3wI3?|v|rQn2EvLlq6nW_c140V%8-rBtE`68i6$F*4qV#nQq$ zY4McAe9pyf`2TDyKNNl=FH4ew1=ZZ~vTsp_lWr|@n#!Lsfi@Gku)_`xHsbS0$ zi$V*x$HALrEXkKN@BebSt+L%7BMLQ=+*_0G2R&QSzA^tNW{d z>zNq}87+tQAI3QpF1(ezy!uCsq#E(XiYqTK7g6w{3U7$)klUXD{K%|0kyq$yi^oLp z2ALO@u;X4#P!g%xpb0nR96yqsU2w3?MkI^TaW92g+4<}-z>p3nB}Keo4B$za604jZ znOIkNu|mUW`eauoEn0*6^NpzSKu3nZ2pp`zo(ushvVzMJx8hy|uoTmzelZvaM}c%j z5xDX72wdF|vSWnc<6)4N?At7EJnVeXFT3%U6bZpZvT@ zbHBG2`lLnpbZXd~YQ-KeD#hX7FLT$Lim%bM$3uyUpI{)L2(+py9z~C}Si#AS#*cB1 zGzBysa`iNQQw=PmnBr#yqGCuNj=ILDWtOF)?umMrRG?opN z@h?z=u&7^CgB@(FL9~4&m9)unB2wNj9q-VKVgfQ;b{|7eCw(9_-)GhTrGkCEYhJ?eBz3{=fA_5`nERu5a_& z!}Gq=S445~Tn_dpherF8klTRbC@vwwXS>*{hn zD;Me)uO4sFNz;*o&YZU1eO94pu{g2qBZndeZGTzc5Kc2 zbG>ufmh(nj(K_MDnD&6AXM+3JEHeVr#<8~Bu&$+vINgZz4)Cc76<` zDgp&TdP7VfWb)X7>GQuQRhIJCZR;n!4x!zLaD6g4QXSsu%kUbcp5enI5&8A)!5cL#R*Lx-XPGa z*A=B@`+>tnTnFJxP!cnv{1>;Ujp0E>$x@{>iIj)JNZ`# zBchEm%r;R*bD)HCX2;QbU(xABF1|M@wYuyeOYg(Q4#ua38Oj0B?GHnuJ&&r}soH@d zRn2aJ+1A=P{oN_5q{`X!|B7^O+PeVq;dbFETo{w2^zdzN=66feIFR^4MR32yK>d@7lgC*=FG{|uR5fXbpIHJ4 z+#iO95Pz|M1}EA1F=-O`JP{z1O{#~-?7Y`;zBn<*DE{!h&0oDqGPPoMoF?CdYLTu? zte>_yM})u*t`h~J{4%xu4wA+b6DwR-ZNEqVqz)oKiGdhUEA?fAF>lA!gGcyB6?uOr zDI5Y~6o$V~j{>?u+M~UDKYe+-l2+Hi-(dEy;K>N|v6xmvJRbeOcWd!|w<~*JU*wmW z!9{adVxuaR=tr>o>;Q#vVig8UIC7^0HS8hTzHbTaMY!y zNVTBiqFsGF_6Y)C19O59GVyj#WA+oX#Y>jalaX}09e0XjrYp z?$=g4FEk}x{+Eco_`4%_mTc*{_f7Ja!{vF^=s|k zhLguN$sx(V!;<(doti^R%X!L<5LzqeZxhwFfzC-*k^{aeqvoefdHe^`)bC6(rA_$c zF+p!pMcFII&ot;tExR3M6RoGUx(OE0xN&T5D$Hag+wATww)%CA8UHif;1 z{o8KE_RSfc@4kGMnN74ge1li+S#84dh?dkVg*~E3P*_c&KAVbtQm1S{Mj^x;xmKTx zTpSw{p!KzJ;8e0d;`Y)!r@!k@aYV8{P{mpXAN|1&WLtCB|3H`ca0v1lx3`CW*xRTu zmLwn~YX@cR=vJvEjRe`}GB8Dz>H+_Hp)$J%@x#|wd=miy#lgu9hW{i}<5aKw;JWH3 zub-2FIJJSwm9&!2O}X1ybOuS+T>OerLKuo48=OT&X@C1G!4GLcwJ;`zA=o&-(TK+F7qQGvPcDu%NwG=gfwW0CM?K)@*I?>T zOtrw}$Wk*+@9Wce+SV2rK=I0~)r?}eJxAFPKnd^_)%3|lB2FY8*+#!|ZBWe$49JS^ zX}gp%=;f^*(aOk*%aHCVF%`cQY=vA;Q*Xp{&?%*+6w?2XJ{G+P-$81imx*sn>T;@KWSxx?A zPG<3<3pYKQUG=0G54B8?b@H-k+*C|jJ!(txxN1mR{wviS-7Q^%bCB_Aih9JKGT{yAnQ9S?O`=C#E#Z<=;L5&7uwt^e4*?jezfCf9D4a zQ^h}OAMwZv-k)hZUBrBRH7^4HySngzp5Q(7G2|QUwX&8DLIJE#98y#aO6S7Wa+oaT zcsaO^J2di9+OD^k{P`^c2f?0-zs0eV3}leYS}b8xfV@LWdp85;zqEYl-aNx=W1Pv9-)hpde{Cx!OLDMOy?=cE+v zF$9Ro(&Tv&Kg0*UUYX!xBlt-}1rKPtMOQ@0#!Jr}&vz&fVgC>tOBOG3%$l#CegUA6 zVaJH_$HcA|{7C<%>ijGofRhB8Ai$+Jmfq3BrMFFn^}oAxtdyo9K~Qy?s@!e$9VW-1 zq3y+qUv2(FT)b}nlQ|K7v2@pG)k^apu>xCBVjcCuJ+rEiiEAF}|EQ za+k-zMobsl%+5U>aC>@bU!W6B{Y|c`a&nxTT-_#T3>zN~CqvZ{FlZ40mCVBEPOGV4 zUqM8go^6}*a(6A0*;I*pSa^7oubta@Y~M9`6U*LSrHT+H&NM?As*D2>b$qX2Kb@hx zpBD!s#IfZhmf|KnE(D92zN%@i3eQsImx55`qRj4w`9BIp;YZpucH}(-*~bJ^ilnH~ zMAdL|MRLuKKVS6s{0`xHMZKZi%fsJG0jcayRj{@pC87in^AH=B1{yoVs8dGk z+wTwL`aZvT1|&WoSU^X&j2*j&PnVh%KjI)4297MqBr~tjuC$n|ALw4QQaUsIaVCy1 za{N6tFNs+UZ4N%(ynb`))Y_#9wcq0NQFtq+_GFcHm}rS_f^-L0gBDTCkd;bdt<6i9 zt7eM=<0h+`o|NRA=B1$9eG~dKtajf#Gx~7GJBFMZuFgj;wu$c=xV8mS0%s(m0PSke zn3Fp4kyDfmXbZVREkAuaN88nzH=w<*{F+wCHLqdPmH3OQMs+9#6C~MSu%GaIGMEMj zc@bY81UIv)#@DUTG>W5ORv-c>J)8Egk@oU_(3-}hKwRZ1h0DZBl>enPuMS|@FLVxT z3HcuW<;CjULZ*8|S6Jdr#e$fRl8N%A7eUvn0IX%VE(cQwG zL*Gsf()71o{*)aYBj|f>f}y@!0yCSLnwj2L8lhz z_BoJJQY!qti||`X8R9fK*ZWke9=c5KZthnE8q09%=tZ;)}>?8@oQy(YtxT;wpM;% zYHnGx1HD8a7H1qfE-^^?*;vm5l}VGYX4W|u_c`4GKa;#S;%2YEqkJux(i8gcK zGXF=pd1?hHf9-{eL{Sx|q)!{lm-gXK9sgcRin`}S$^2wZ+l1Skm6cUjpy>X_jG=Ot zGduvOM!vr#`}(l6`P7r7$+yamN0UlHp?^g^w`cibwy_osuIG8*ilx`JON;_V%(cV9aBwteXr)y}vaQfAU`R>701hr4I zwk)>kfFF^s;SWS1K~~81{!X!(%3wwnE@c<#LCmq)xai>l4OhL!Er0>2y#jrksOV+( zMHXr}%PR}cLgYwHW84ROnLGK*uxHZTHIc~q$hxU^Z`4+c#u_BBtwO_0n3`HyAPiDm z0W$L#v6`&=^!F<;sAqPN023sTw~WEpx8zGV0oP|a_xop_e@B4|m-fNQMEtBN?VZWP zQGcH!>^1ikU#I9MHM~1TJmh+yp2~Uo3+LC=#~fwCUmyYJrW~UO{KX@v4U8-#XdN$` z*JPlmazkcdd8ar>73%MQyr}i1VmnBgs!9zW6I#}(18r(|0uwWCkiHC?PEiYEeSW|w> zIGlC)_#{@)3zZmjGOS8FFs0l@X8HP9)t*lfX<>JJ@^9<%53`olmjQL^BvU~a=bx%? z0)9_?{<B8s|o(F(RN}_6oXPhw&ouSQ|?qBhhgb@6=C)MqPbG_ z7x>44L$ZJA>mXl0GATC`8l>3lIm)tE_|COkkYUhc@eiNTGwY4`kn7}%yeb9hq{D}v zX0n9*gOSH_P-SobUaxi3hE`V|i%m>f&@%GMpbfKx1AbKrFFsW+X!wQ?=@aD;F}zeD z*Q~CAl`3A9r#wZ>u*q{s#mTNU^7qT^zab8Qs(%Q8I!2gQ*%{%UIBbo2hldA;pRe5Q zy^(&B@;h6sg|ZMMqqWgy7MKr(Tlg}$}Po@B~g9I3dp z=Jt@@Pzzgp->uNC9s;KshAVg4HWc~NB9lOpX28bvd{id2-JQfojsJ@w{-^Wt4cqy^ zJ1C%Ssvt&Ga#|YQW&3fy*r6RsyN}x?;6a%E!Bj7ygFe3cy&J$%#*P<}wK;j~do;C* z@fi#X4L#l%%L&X=hR0>40@Gs}YdMe~1ymaheo@+N$%gXOEr?T(VHF3fwO&%k4?H$XVo=$YLvLMvKw$z%n)VhnkQ?)ae^&?^^;&tR z-0%11_dD-zSNyx~r&fHg4kyC*MpxAmOhMT2%jfvWVs+WH)KRlsFk4=uDM3&Z1w;G{ z)X*>ZqrX1WwoFMx1&7}YZOx39W`P zEUH*Hoz9nijtU<5t|=3Zh%0r@GfxnfcJfM*pcyyLJQDBrB zV(=BUS`wNG`BtVMlqJ-%?zQqmjn%R8K3Sn(qqrbd5{E+X^=2c$UkLNnHk`sJAsyu= zvg3%sdF2WzV{y8}IrMN%o>-t6RunTGan7ERvhr00Og2I3Z0O#YgXlNy5zcesU zBSjHzlJdR?$9hN@`qL|4eQ^^V(h|7b3$EjL#H$ho&%TZvrK0H1Yk5NqBo_X~`(;Wv ziPVwz3#DUTsdF}`&3lA{G&A|Re^ZmcKg;{rHbDMnpo@>e2gB0RG~{Xy=_b@N)*9$I z6D(boNG+BNk}xLO!-O4lbFVyg#f@ zzGX6SXzTwu%XVmaVa3gEFd9Gv^NW7ujAZCfk6XMBI%{|(jUt1hN@_j9nL;{G)Lt4T z#RnpwaAIXPh^XkX`=`p9xS6CvQ%P$_guNQ;tmY@MO?57tS+U9iP&N%f=rXcf`GZ`t zZNOGUv>)pew|CBwai93#p2>gc$A7RR7>hgTmNhqXPyU6+vh$2X(yf}sTZe+G_gMf; zNv9Hdon6&$L*Fo2Sy0`Ch=xC-IvRa1_$gW3Y9+|8YEF1_|J37ovo|9H%& z{SD_l-?BOT^voDGe)e1(V>(V7T1O)`+wTNyYNaOfra?haayv4-Vt5t`C0&RsH7P11 zO6kPMn)^Ac`Cx&&XVZIe+_MaTqYg~%0rqRd7I0MnFex*zvtuh|E2SLw`$%SIcpgPE z)j(Qs_e6lgZLZUNG+==4^Xbm2lc*H4dm4FyJnv80@X$hT?IhZJ^C8vD*@?wDy0G)N zl*3MTn*UQ3=-5Pw`}^IHw_)cSW2gR0?UyUN)8zY~7Gd8TYsEw<;AS~whmtfjFP;0> zE9;J8>MEU({ZO;mp9@+MOuz3&C91vY%G;U|uw$7q(FDU8IT6Cf7CZtQJtH8lZaSXN z<|&VE-w;GcM5y;*`?m@ESkbF${)Zsm{fx)@B9vy99I$>A(1sQ2S^Z}XY!4QNe$lGY zN|Si0>OemD%|XY&&7A$=<|`FT?!PN&nOkuQ~0gfXek1VTV^9gsDQEa zBYNeLO+Ku>aTQu_i(^wiBmQa1FDzk?MV39}I-HayFK6$~v5Z!l29&9PNusIUK-`pTG#d|!a#|CG9sz>+_9UfBA|xhWNy?H+}u7B zM`L+1*_VqQEJ>P@R__lE`dLdurmgP(eq4 ziO2>Yha`Pov!W$m+4)AAmz%kSXE|$jxud|k)w|3t^l)b@+Nz(UvpihTzlT9d8b7#H z(x6R0W`3BAMQ%Yw{^jl`c(c&0rxa!pgMWgV_vpObm~WDtHEAn_0gh`C?`!L|i1*z! zO@$PR;7+E^Ejc+3Z>wOBv@J9y7}Q7J)sPT3aC#8}URC1k?eEF8-+Mk4aO~v2ZRFpG zgxT0Sl50F2eEST?s3yBT5hqtF&dJfy;h_zlD2dh3vqXZMzxz-X7N>eN(700XIqMpwZE5Q@AX7?Y=(UNDt9_J&F@r4mJYj<`rl zM2M~m4$#?cZvV4}U`|OqIM(jO`zaHde-n%Q7!stAXbAB_h1$mirU!}IK)ZL|a!&(y zkVavdh@qiBdI@jj90QtogR0+=s87B5(si}h=5c>HIDdaN(R8~Aq7kPYu3XkXC-Q@&^bG;Vu4@qED(T%aEq%QH!XGkJr;ZGKBqGkmhCuQ zS`C9)Qxpur5&$HkAhGG0MjjHNx3;s`KDSI?Th0gmb|(U=N6%vNH0{iBWPSR|iN+(Q0VuMm&KnGv|J5@yr#*l!bY=?n+6W!hx$69#=4t z9oT-nP$6#!wyVL>UUYLvM~$^j1fI(PNn6VjptdcY9QSJk-GT>1zY{CT zV{aVfGdpFft$J<+DFMiql@)~LCQVB^H6rTiO%{iDCcH!nz547ch`%$Loz0AKc*MGn zt=Hb>$aQ<#y#fA}X|8BvaSFV{k!NhHDok+??743#Xz?=c2#Go3;jdLFY+1AHvo`|g zB;B6Ju<036QDmtbYqmpG^f{+-e=^`G9}*oY5%5)2@Wb@&44b2Ho~FSc^aGt~9f2wR zy{o@dP_TYOCpH;8An#MHWA{9xY2-SVmUdtl`NHWsLBD&GtJVfqXwmLLG{H6u6ih|3D$g`<&H@ zO&D*Sn9@N#9y|d{0uvI8{L&?Y2v(y#ZSuyy)wT>dZW#wZsjZ-e;=PFcl2E8kt&lxQ7SqAMi@MY z=2~9#y8hzV7Ybu$qPLLf6BX1MPsN|(+rtr=J8Cbf%P8@`vn=QT!yf;60WjjmhqVIN(wd>p|qsT@S|PLd8XY!2NNA<_I%kdcP|8s1H%4U6*;7` zw3W*_-I{nu(m}ooX=+w)xBMS3fV#}}!KQsiSZ{0omyzQ$`L?5c7x(tWP4(ZScZGCU z%NEZ%!#)rQE20=hxv&bH^de?)QF))#A$9FAK*kTWxcdgX%Er!@LVdpE8v%ZI1otah z5|HuXsltsgG{$2#wxtD%fkP=?rA9(cmHE~x_8gviJ;Kh9_|FH|&+eLi_i4-48*{aB zg+UZVXxO#O>&HXIdD>L_3! ziow;_U&=nXAA2evw9yc)w8~GMBPo%ougkN$N&A-TPZG;3ZxL!>6PLv&_Uhkg8Z4_A zXodl`GlE7AP4igDp(hZz1OAFIMPjG=UAJKmyVCu0%7R1CLy*-dSay<~cU(>i!~nF< z)0B)8BTq`N&TjP@CZJGv>@+lO**D^%{iM5s2-vSLy*g2g*emSXpOkEiqRu8)sWb_9E=88-aM_PZFKJu>9_)Z3@LN-rM5 z+&AZR)9eg}W+_q^sJ-!wz{`aWqo@^E>`9K5r1Y5e_elK}&lR~;buR2wX4iM|lDe*B zR@b7vr*#G{XS{wF>rk_XY0Pi&%;;YC5m|j#2>IQaw}0OLuIxo&@#)kcQFz__Y-4$t z_JlkLb_0G_=l4ASN4$<~O`hQ0)Qg7yf?dHBXn(Is+vU8!WY_&&&izV~{LR6ea8Vz2 z@)toOUar;9pV<;0;C`L}jrfm8(_27wv%ccQ z)lC_#hVozEq4W<48Y_+JghjZPONecZl}N=OdY=3J`xDg?p;g!MkjSePIZ}qCC>>cs0mu>XTHzrIJw0h*WSo{ z?g@xQK-A%;rtqwUTfL9riNt-vnQXSUghLqAEA0CCd^YzuIpK85dpnfJfviMA%OJ26 zR+&}_5aF10Mnd%UP@J?5q!T%4u_kA^FA_R#dFE8pV0GP7ou)lU9FgFiaVB*bRC)O? zriYVtq~3${`~YC)cWqpw^fQsza|OmsCa5@I&wzQtJmf1nQk~+{jL(xeV^0Z8IhtqV zea=9tbTXnvCoq~lU0o}9br2i*=EHTixg%u^qhqr&9Dk#GCpx^4!9%4kQ)yxX4|$e$4UbITNpm=(RsykeR-KhkhJ^q{gT`NN*?R3X?E z>I=$``OWN-5kYWMq7tT(`K|RJf#{@ed1zMJY$7!}U#Iwjw>i;FPVu(hvc-MkmXH-l zAO9rtUumr90a#kP_a#k@vS3G-{K5ccH}-sx)afbk2j=#rBUWEOzCB;MtCGLli``!u zODh&~U-@C98n8(Uj}`*PC}MDM96`oFps_;bI5EyEZWvgPLW+u69mud;AFt;8s3>;N ze=w~6-v-vMkjcIS1wj*w7ayrH;xTb?YUm}aJY~yJRz{hsnF8=i#leZ_a{cb3gK_4+ zc?pA%kqrQMpIarXLsn!;5f5<$9|0+0w?+NrGc(tAUSrhC3Z_HVwAq1wi&msPH!iE$ zg%p*QTG>9v{_NL^_DqT2A8l{P4~TSyk^1@F4GcDw;cF_iY;W)Gt`BpIxjk$arqX$( zNV{CGTS10RMip&q3j&mRgN^wMQ+wlR$E|pcIh5XI!b0LhA>G2(8g>jX;qGzqR`6!*A~;p%K-R zthNWbg#~~Q9~OQm3j)~mogP#j|8&;ZkAzgdPbZFmcJphRKL>MZW#|e*3|xBa{|TIIji}VVB}r=gq(lU6?CD$2a5fYu++qExI_Uj<9q6q*h_ z(^KW|dD0jWj8#$#qF$G1$#ltw5DNZH&7i-m{v!AObFj$`y5?4Fa(FgCti5^NLRIK8 zYxjT>MVKUJ$ouT1g+DP<+pKeuCsXTkvh(66^8Uf2wEqGcD>8^EDo|c)sWbRk{%&XK z{xH@fEFjoV7U-ZFpbiiQCLmmw*#cwAN;Hq1%RD20s9BcdF^5T7hS$c7Q<$)qAKvY!uLf6>Si5ZXaIkZP+jh#Gs zdL=qmR#Q(>0mZrs<^2K>yc5ZUJnn{}HTumS0tdvc#oT6Rv3Pox_llMCs2juW_Juzi zBC3p3BVwMs;qxd6BD6Eyw{~(z7r~bmC@8hH(cs>q0X0+Uous@|C>X@{?+GX*G}I?F z^m%{B{Fd)_2bGtrC>1ndQc>I;E1?WeFgy(kVn_4ifW&BQ z01cUhiNPOA(f>9W1QQb#CMn+AID-6zbkGO2fFtV|)!q0wH8{##xFtm(p>2~}iB+!Q zb$oU{iXOscLz2m1OYAk2Y;D2AM5<(OPY|WphvJahzUr1zP<@-4e(X5O;$Awx7UG|k zgxM={3gV>M-==Hj`M+(L|9-Hd`Y(X7%yaIPAuc&?Vy9^=CCVc_+4_;swM6C>9>nb( z*x0Mtb`MyI5`1&yETi$MJtX;ZyQzyJ%=Yc}=+or{$?%q4%@H!$7w)+qX8HWBY{z6e zpXPnOGVoTG-y{ul4)ysEom6Tn@9K8-N;OwLus5LXI{9&0S znq8o8BnA&Yr@%+bW&y3&2!cmW)eYpwraXKdGP+ zUo*fy%ONJvf5#n(W>y5M2{**MOqWDvt@p6E6hEQd+sfPc5zLRt96%0?@#rc&UYEf$ zHGD!FX~IW70_kA0r8WA1)yuLE4i3g)EMFnA?U_dd&t=!lN9j_Aj(8YS{wh$kze(P5 zu*_Ter#-3g(B9Q8&&jO>_11l*j(_xMEfx!HqRc$BxF(qYru>V96Uk5xS#thz9P5A! zA~GoYDHR6|oL1fSY<^58s}=DlWxyJw@`3{7naH1NfonA8G$QO5cju=WJGYq!qdQ(J zy_HG@q25lLzLiEiK=&|jTRzAK6L3C`TsS=xE~;ODG3J`e)`Lp#q49nP@!lkOCT3glv--I??Y>i6&Rr>ImESZ!H{0OT z%=3eSR1~?Q0^q%hDZaxiICWJ1wLpdvcKo&eXFWLhmzyIFvK?zR{u^|1_tF<5@CZ7I z^BvVbp%+I$S>A%iQL6%B+m5twI5OL{Q1oCV>fmF*zY*U$luq^KL)4$N;H4vq{|fxB z>{O^M!=;Xn%Rcg@JOA*Dz4N6-3qF#CVA^LbD#dD)Gscid%FEV3W8liP-~*ftkm9%R z0_8VnPwN7nijLqJ z91%U!Mt;eBbvedUsEl5v?!Icaoql^LK@BM`NKl9dY0X2FQ<&HT!qIRNimy>Zp$Gsz z@iE&nI+!X!Xd z&|64x&Jt!xpu<05arb8%0{O)r1Q}+RPNh-szRLQ3jbZTc6 zgZs=))eysQ?w0#Z@X0u6azs%t!z}*05a{t^=J&_c0_-?!h;%|#d(KLTV)~^^(f+4- zO#SuY_aqGa(Vb~mxmRJ>`m^5uzm_s>!|oY^YstG5@=gis_gZ-y;;ZT!zgOmV>@#zF669?sOfxTEHE)b8%#R6c;}rdS5RvHEUj&z8m&sV=~00^T!#&{rW{mD;G2Z0dZwhZDd$5#t*3$KD6}~v8;`24 z(O#SSNo3_C#bSe;jg~)wakIJ}(5#lz+PoDs77J??36GHKz}o~gGt4yxoHGC-=TyX<1?U)LmXV==ojgu%!Dwq zIumlfX$}?Kcm#@+1QcZFDiGEdSPU)RniTQ!9x6Bg4Q|A1pFLDc&1&h|)~`p;8Qz#b zd|+$)a_ddo%H8e(=d--mC#=~o)s*y&3=L>1f2KO>8X2hq=?jV@c`M=rc|KGVGl8;O z(Op9Q;3#@O)VRBrfg9&jyyTJG=~w!=oSN*OfI>rcX-S87#Y)M}ae~$IlCL$&6XLe{ z1Nx1sxHS8pt80P?oYmakEWi{WJ|=c7jT7r)j;L{jvZ?`NW7HH<8`Msfjub4ve7tvb z+n%*%>*|>K7pj`p+%fX`fOO6KzZ(C|Fe~USChTHIM;_}`JY2Jq@3^krH`6hD8S&dI zX%(1KVT>Kfd)2w~bSIvs!PZfk+D9R<&f88jZwRVVN@XZZMP`yUy=G|m#}>twFkK<$ zkkEFE5hg`dTN)X?vX;;%gb$+;)WZlBGYWpecy)=?OC~<6AqMZlT)Pd$rj{s2X*D;Z z%+!M7i7O_O;OEK{k;nFL#TsmWbp#%7+}(A$f^nuDtGOyGON;1YG#Wx}^j!ZS6F`58 zcDl_hl3V_IUZ4i&vlh%B`}Y|pm^sai$w7c)OawnsWFP0wU-GoF#N38?l)%<1wAmHJ zAEft3E7&@|w7U9qqWoaXAYhENk_-x@5s!bs(ExPY@O8lmzp5LrZVcuuEZfe1yAtbO)7DY|l5w@pA5WL5Mf!4P zgVoMiZOjd8sM$oOD~vtz5&y0_sST#; z9*e3veI){@h@}k^D~RljpaXbI8ebHqPgaLa%7UmU3diFkUbXVU(Ib+)&wres--;Zx zc$3bkk!$avESfv+iQfE_{Qp9g75{#0+n2VzJ6}r2JjB4V>2es7ae$6Q)^4XUx%*#! zrL2zkzT2o8HB08lyx*@bTmMDo_jA*e)8rD!}XiL;-KD&t|+p6c_u31J#kD1nx; zQEQDC9I6utXCWB+BRF?o6cFkusTBg^NF|ImxA&N*Kep;j`99TJGn7>;*HCqqt>Zd_ zHiTE;;itgAdG7qyGyLAMsqGn4m>iQfvsB)<*gmOuR5*xtACsQ@4&=}e z|IuSdNo${q1)|!keh|6-`D+8xKE&=|Kv!s0jAxq6nRop*H;2{KYOgszJu9=>p8@J3 z6k!@3ZP(s(+YeR~T%c_i@n6FXGF;q@UTWmrijQZimq=@UG!q~8p8s1-P~WbPlr((d z+d?5_>`moUxcO1SCVM8H|LreoGufx@jn>7&4mIg`xakSSXQ=B&8RN~2GJ*U{?Wxyk z%VY7ePF|ZEuY9zYvrgq72fCJ~stLBTQnQT<^l#U7I`e(XoV@E1s`VJVS3xSxjFlfG zd`<`l?kqD*zx%>DSi-$?)x|$~8;`#nvL}%5A=BXWQ)(u;qCK{V=ujk8VHhT~skyxO{+^h23dy-2u=N>S(3htO+v ze?kETZ}Sna^7w0V`lCBUNceIe{EH~j8Q|2(Y|wCO5C?-M-s{Dfn7??3$SNyPf^lPp-m0Z+-kf((V7Wgfp=XpAh`KCw8BrPOS2YJ@jRX z&qjSJI?07fLS-kamS@hHSIK*)zArR!+>J$N%vUwMzgzM&zwq6sW7n;RwXO_Iy#STC ziTot_-JXow#cO>wZF)4h9zNR0#M(R0_*bGf)*vp&6_M)#1J9x3G8>YcS$SMmI z%m%q-WFXQfF_;b-#ieuOc=Nd2vZcz|Z)dMG*A0K72~rcmu7(fX$h2uW7knzi=*uQz zr{v}3Wtfwu(o+d>;=E zbLqsV;u6U@*btxAf5T&}o2hPvh$>LHowROlsGG;r!q^LOV<&-ooQElUWJ+Lvw_D%Fv^P)fdFU{7`I zBb0xpW^+)X1Ah$%u5R=dbXk2|Cyifc@lv^wGj0q{I-ZXr^9#EeC-~x1RHoYUx~qMM z_OU8^fLPyU!ZoqtLmoOjqKU?|GOgb&uaEG8cYhm7uHQVmz*xP-TOs*z_YUtM)O2ZP z$vn2}#fR{vmHQ8equ2>7&yU0JS7PPG?rUy7+wtA+{2IA`8m4)f!)-3aS^Qz`MiH0S$`CcnLa&$Z~|s+K1&E=ctsz{aBmX^HA;IxzwlsE)~t%hs=e1 z1O_FJ)xMVxI>q26qg=lVM8M+z)L&O;+9Y_X|374XWmKDMw=D!I?i49Sg1ZEF2^7~* zq&O6Jcb8yA3WebAQoM!YUfc^5EACL-Z}$G~Irp4#pI`h+1|#pY-nHhOYfe@J5lfDo zri!JjVpdC8S?3H@ka>1iF=DA=NqPBe4XwkbMm2nO5MO?{KI44!>nYVYc3=Pf~hgIxV1i%(NqxGypB1bAsy#1-mKAW1>5NFl zOm+t36lHX)RAe4tiOt{U0@g)jMpdoZ42us#bJ2RzS!J-KWG;L@?lP%32YRznvR7N; zrp1T%Mvx34Pvn_OwHaQO(5%ux6xd~oz3?O+P=OAA5&W8N(ejhSj=)frO!ojXTBvkc z31Qb z!`(7r(50$74!#S%asKP{wDFB^9iV@-(>n0bkGb@mcVMGY;*(|tF`1oe2=m9#R$cu; zRZEtE`&3}HhPoaag@ZPgJ38m6^qc8Rai-m7jc>pEb)*ipV_j^<#*eT8UrYO9uTPWR z3f0+cd{Rj=IwnbIl(f9&3OJBIX`@@24OR_Jqfw~ksB*Z&Kz^GZfI+HorvoH^!%u3N zT@pThFaGyB+x|_HfV=l%F^67bEjq)8zBI6>O>%3G5r$_O8U^AAWdk<)&A?wZ=U=^>zR5M{8a;Es`tf=xBNZ@9AU} z_nXg%ESRz1u4bqalJ~oZ;ws1$gXq)Y&z1-=2tTw~%;e*laJN{` zqGv1MfS!o!1y>M(>;WtxbirACZ^^}qJ!(-vw1wqyi5T*+YiVYda`^Z)zld4`?aH$uM=|CP%A>z9+%spn$zd zDW!aCJj%1YS4us3;dR)aeN3Jmg!1M1&hI=l2>Hf{c48>SVvC_L-K0@@D>+}Vg+`c$oRX2OB&7itNy5r2zwaKFl~JgG7{#^QRmvqItO78 zPN+mac3jX3ki5jWxcDUtpc}PTTRm9whpdqh8oADG$Xw?so4zKrQ_%?$V z5+aeoCc)}N#Ye3tPPOP&-WvoGw0o1`KPVZ z(d3yn$XI5~7}|%jZ0Say&Be-XJ9XHzQ;ZskBta{7a;TqA)FFd=;+B#6o-)@DSPmD# z7BL7F_CK*N-f8k7I(=fq3nMBkMzE0k_Kr7c8JTpL+3jzZW_de@Yn!qHH9XirOV?(m zHeY(G2;3vZm<@ARO9|YIl4??UKSN7mZbhQ0(SV$>_zj-8D$fOaI|e9O{0WUAK8&2k zwfuOE6*AtuJ-TzqUI6=aX?B0|^Z=LPo?JVXt+@E!`e%hAfVIg&wIV*fZynzEh$&OP zHgrj!DS=c*4;HTLmZDo2|8y6oEd4o}8x-(0FtG!-NkmbNxp-mGx7B(z8aM%G4pMy;ItJzKXE4P$49TxSnQ z=NraHG!>1mqd2gqGDOc)wp=`j^dxKzh&T1kWxTHrwJ!pE`OAEm9Qm{-T^rqZ@ zIreYr&xaXT21libQuc!eLF0#0Z^}2C7S^IGu)eRr}%V7wiL}DLqJ_19AE|n*+EOP=R z$<-i4{BLNR#S;y{g4CmNL;8oa@;#Hi`WYER_+IETMA3qIU!trIX^I zL!;r=%un`ap^Nzz`67*uNgVGP5F~r#>3BY40W*UX3Vlb#6aWy6B!%FmDoT=bEIegI z%Vk`L=>U~8bADFQ8Qmo>-aki2f2V~V7p|mAXoIF()AMTFE7)7+f|>as?Sv{(49Uxwk*RudRG+%ls6%EZ!2{Y z^xIGGS0=p-HD)yLS8ysyDmJ|{R14olNUD$vm8QRL&>V#z);a#tBRQFI&nU4GjW-#8 zu%4Q}DdxoY$oR3(J-`b`W_2>MV`5@bKZTk^J`5Xbf02RZ2~`PlMX#^kQ=PPKK0Hv{ zauFny9wemnD4fX=STC+C{_!{i^5ZaGa)n*zVuqO02iFSZ-|xEm?%<_$ z)_yrqNPi&^_)N@cGQ3N`;Lq{7GVa-XsAcw!JVl~0t3^n{t!j5O7IR^fo(~GgpE^^B z-(&Va%U8wDzUODJ`;)oZ0bcjMf4F#K9DO0SIKC^eIeOG3ohZC3^eVD;b5vkEB^FqR zfQJDs8Ht_Ve9C-C$QAd$J$rU+A)LQtDkfqrb}z|*C5=LDGH{|~#3;Q2_S*m&b&m6d z^U~ZeI8+k zd=ftuW@?G#ie(LLj~FsMtAPnTiy-?!`qyhM>1FBf%CA^~-fS1>e;Tr2~Scs-pkeD)M^s{puuvpk7>+xa_ z_cK)%AsZ2VDn#JnEC~;uF4?`3F3`RHjz_a4XS*po^fS-muFZCTVFK;F16x{H7F8~$ zmIIBfVNN~q#~9Z6Avc;c&#I3Bdn$`LXG-2P(yq~rY)A1V6UL6KcDn8F0yzPLr~HTk z&27dGdQ`hGSc%s`rW$%LA<&wzvrDhQ=bbYg)gt2o}Av-aOx}1 zL4t`i<+)(vWoH?yDR@AT^ZWIoYt0-z@{}S5SOa@DTbMUm_rcZqnV^s4$cD4Gx4$Tb z+6md>H*#1~anWS}3vDtOe5he%8Tk&}XjVxsiEpz_oca-&7H?|XFr!E^ViE$Z-v%q- zp&^2m4!On*Qm%7K*w(D#yKL&QPG`rT8RD%9BndAC)l3jrNnUdt*eJ-?;`98)j_>rJh^J->cBe;TA(dwRUvok-B~ru~Xc zW}zN>K%|sJRE(U7nunGY4y2bB1uuU>)3l-@WYdubD^~@>PE@O-8Lk$T{p3ed^03%Ph9h7T{jE=o<-_xYlj*gtY?n?@>4A2?GtCU}8?Nr8XahdcSA z3{*q{PR}{%g462muUe;<*#>`1?gu-Y4YRN7C*f|sQbbxFesE;dB#sZQW~VgC)0R0Kp%H&uV5itqj%EYjDv#^xpKBS zD3B}O0e6zLh*Y!Gj5J)kVnLOkL6heJ+Ib}49aj@+gr$Gs;an$-Al>z@$5g1ZCXBJv z_dWKl4rti*W&X{=i3Kv9lO5JFRv+C3HR+2L+M7z@G|N z3}3ktgvI&oY=%F1$us*J$X;zC>;cB;@tb>O8{)8o6~_fHSrqs)NG0*YlIJ0FuxpGP z^&}A#2*(p}so*&Ctxb?u?c``WAVKT-)RRy&`upsq^!m_9uUE&_1aVM~ZhK?egoK&#)YqiSmG?TC3%QK2nw=}oW@amX z;xzW}KLfJ^-?9faKMEXScS}F|ToXCD-7-852rS&ZJ-kZJ&Fomy?1XJBE0*l>K);8>5lHkKVk=$~ zLdy$C$!Xpw)L;32Ko-k%MC-C|^+u;lQVB&GY6gKnTZFFvUa?2U<$}#XsHiA0>!~Ao z%F2oD#1ks;5}9L*XrhT25>0sAEVBR(Wn;=vb^}7iP1DlK3TonpqO6M7@Q9{J)4h92 z;ILk5!Qs!9l|WKojkp`eKGQ{ z-)fp+N#JRBQ~B6%s7&aXqntLf?Z+0si{~ff=j)b1m;0;pI=QO@aGQ=M551;sk9-(1 zFIvBJy+$70nASQBik8vu-<_!+HJ*J#q;zaugkOT8=2feuoFwX_sDj1!(4k-jO|2>W z_)Sggsw_~nJjG`vI0kCF@8!q3g4ZCsEtq3l4al(7fe$llH)4O!XUemTetke;@%E@5^|kvTg95rSI(dTZIpXAS-ICSdW! z|8cPQ_Ry4~G=q$2@d)x?1_1wdD;uxhglu|svASK397R;M(B;rLSM8I#$!}7WwF&)( zhcMTEkusuG8U0{0C&ki!xiS_eBRLapx-j(=GL) zXDY2SDD&8NB+d5WCT1@H-%aW-pW;~Y&)l&P&NJoltY8ma7j&vlh>TiK_Tfh}Z%wz| z%=|jF@lL}ig72$j!ThV;LZ3JaSb8Ue{9jHsms`Thi%LcM!H|q9M-G;8d{~l#mX|u*e!1zqituLd3MtHcRhIwJdqK%!5V>y|?M`@R($)KxCmCg6c5m;wH zYXB%f{v}8r>yPwNTm&ziqe+fHIiL1(xDk|Xm!)-k#97>#tD*(%a7QPJXP+2SyAdEMUwfz)Jx@RZMnxpm$}!~Al_-k-=xTdF!`hXshw$4#AJOQa z&VQrf{EXh+_Si(iX^@crqv+~dC$l~{qH8Tk=qbTi4L9nXX#v||ijP9I0sprj&)Ad7ugnI)7 zQ7cjYov^uLu9>h;_HVI5%l9Rq>@ivT- zCNL1*qYRd-CMj_72x0nB3s;0%SSZh=!x|n|k1X~I{y3IYl;C}6y}%2p_yxm3NM!Dj zeT6K^Lko}s*s!1$TU+vuVFQ#j6XT#RqEGjSoQgqy3za9@bK^KH0IBiWQ(5hVQ8^VS zUb|8IC9(o$W*`OwX3e>WhcrABKpT&Sd0>9u$LRO zT{HEEo;m4Kp5T3<@Acx}IXWIP2OlXO9$Mh;6e%sURGsJBh}Z|CMAg@tFl2~!F&2DD zRl@)A{9+R~=;Z}x5MD~vD|J}3(t8rI;PyotWCH;5a)tui0_8D05+<#H9I(dr-S12* z6_A(9E`+{U65Y&o0xjECV582pGZsDr6}!ud%oIqc_h!r#2Orp!Z2R|v!G5V`1t@>U za6p+IatyS(+A;{*4hL_6#oQa80lqUXHoe_GO!AHILaJLhn1ypA%#1=3S#nJ3zw4vs zArmP|7e*h$hM#JJsC=tPWj^th4lNeTd$UTk{QrqMuP%WXD@VUDZv0|^j4=AAdyKl*)LB6e zIF&NL7htlHRe$Ar*Zx(sN3agj#amS&W6qi@T8=ADrLS29>KgqWhk^bLFWv$~ zmh;rZ{Aw7(%9a+hXcNwj!;8~;ou7HaQ!GIaw)Phe>GWV8da;sn$^`TMbQ(!S;XIj{ zy@(>brS9;!=&Ot2AhG$upM+Hzf@7fNzJogmvCd`edhxYnjHWz{bC;mg$iCX`J9b*Y zPK;jCr=8yfV9+sZUJ7k_3vA@^U&1M)U0^5ID$TEK$bGwo>TqYi_O#18A!2OxaG3?6DQNCvE{Z^H3J;$X` z%$X?Jw&#daL*K;FccQC1`p3CDB$1C2HnP(3O&$Twd z*Y97hk26;$Js22>P-(-)-S1Px<=zI6x6h+ZxLbbYUv;%WMbnNz0{~0(`^tuk)MFIN zN;q&lY*`BMU4*k;s}gYGSoO)6cPJ%Xk~5MWt;{ejrn;FD%PuP-b%Q50hi+I}!SF>{ z6P#!JK4y$4E~3Q+(TYI6$E{=vHKZS0+n)AX567bZy#!@~1Sa;m=ZpCQG05(ud}8+b zcjbt(m7FDy+fy=;MiT(rfyIvwwEQYL#ojakUjxKiOy$|jm7L}Ur}$hGBbQvNeqkxPbp@vRsJvINs?JsBNyA!2@gm!Pm=6ZkkW1m2!Yc=>7qNO>@Z5u-Y%q(9Da5Nb3@#jjR zp3D{4irE-EY0bM8J~$+o|r@_t|T$bzD?wr#VwS2VV{J-;1mKZUp9xIW9^qq>hbn98UBMb}bHU@a%h8YK^fBE45b(sw4x|k7G_Ep95Ro zwDyQsaLHO#7s+oJ9Ypz&ZMtrg; z#3TCD2T_w7L)W9%QrY$%4Y)TX(w;pMeyyCmKEX&?+9$XKU4fcPTt7LIUbnR;;0Gl< z<0pRxY9*r;Bt}BUuJym!Ann53V0YwchkQQlTmBqt#3Y|fAzkzg9w@8AG-MY zf!uZrNkTfZ*etFZKDsxwAEJ5o@tfu)5%zen0Z=`%`{$FBljF77~c3*s3=su@d%5S@`$UL8_DXeV=j;9tg%cy8;d2T2pP@fz1)XQKfAks=~`m~W_ zB<1;$;(pUn;K&m2Za?-)HnyUIY0_OCSV(qWmX{8X-_p~tYs5-~#(jP}BK?N95&QHFG=ja3^a=2+`kC@dXg`?ic&N zd`Wp9Cq}ZHn~Cmz61TS=DQw&*1piKPd25=v@FCy>s!s8TT|aKkKo=FSSi6ZTjPENN zHNBC$zP&y%WyN-=K-Lne5v_1nobT-9#L@OMF_oJ|6(?R#D>a<`@^LdoLa7B`E};Ys zq&&go=gxwnqT-*LJc|n}QVK3gwLtj92(Td&OAiT(goLO~LDj@R_~Q`M%w=U$-Zu_X zF?4+(xX>)CgtTd0*hKdmxU58N(1sjQj(^NZgS%;9*LqM5pB6u89 z(WNw`UirVqk0Z*Svel6lZg`sP40^bJT0YOErEIX^f8(Bjb!EaU^+(b-((j_LoKSS> z=u|^pB|#mfK0R7YS$e4ahl@&?q7Ef@%8}9+j>cSs{ecy~Ya%{fseMxv;Tc88-0TL$ z8GjMuXQKvC%?!tj-mz;yNG)ZOPIo3}i^z}W2@kDv_o#?C*YRBirQ7g8mu1vI6~g8n zw;w-dP9IKgwK}6a&^fb*y*%|TpQoJm{`%LwyL#BT4tRQlyL|iJm%*^wjiFPra^+tL zZ6X+0Pz)X7RZZxg$fW`u1d{Tk{}V+pfs0#ly_rDua=*~|xLpc&XJ|WB-uq0OL@Z8I z$(1zjY{A6Dzybh;APkJ6G489310?TNZ4c|O0fvZv{fQ(Kum$q3@-H20*iYkCd&Qq&)<22y<59Y*$oLA9 zLoU?4_TA(_0z^6l83c%!W0T6P5KX00_MlYFR=8`@^0Czwz9xh@y=QR7Ta*F^H+O|m zJ4rJO3MNoM1@Rz)>(7Nm>n-$|D;O?rm3TDl!l%V(twqyx5b04YknOHqvJ$lzqC`%) zcnM*eifg!DUS7S=;!PsOa~6QJ6y{68nD-x0-eIhy#^|*HVsR5jyOh@_X63`Jz_SNh-ryL$WN91p3|3&bTy=u|YMQis z3?4KEL3D#g%Pgkq1Rr@3)vn$<`v0ju{*{0HW6_T7{fDLA`q!rI=D~s+-8zM*E$s!P zkU??#+or%xLC-oBy<%U6iDmZ&m8To3rV|`~q&&n)- zA{720RW$$;p=FyzLdQi;!ox|-6)K28AnxGIxgbMRi|UtzFRDr!4JCd_!RlYKFXLeh>Th5fbiG(T#Q+`K#^Ah`fim8CjfdRs)UgYn7=7VkN4Fh@W`$2}oj z?*e*{{3%sT#kJfNNWy52p{}@i>iMuz!`i=eNs$EG@W>jN*@ttgd46MP#154`$PO`0 zV|K6cNBSV`#EN}jdp>h-(-mZ)4-Mci@6iwd+GMRK$4_vU#3?eW9KxNUnKH~T083Fe zwLk@>e?oI{`bj38Oh(;QO<)fFMjQk7QbUCF#TA2@o7_Kp6uMUotWc|$X%gF}tEnST zzWJPY7gM#|Qt35TZ4st(*)pK%7yXmz@4w}?_`rZ;F@gu?H`dV zR-X3bIfJw#KK~8>&YZ4`>~98}9%NrWcO+ugPXAEP**3~RqM5)K%o%g~SEcTcUtOuk z`10tSJ_~1x6jAeJd+j{DSXVM19{#BaozL4dZ7nx4#>ixp@>a^1_!_C`sMDFv2$BvV zcEpmhG`tPcz(flz3U%nX#(~^A6wgKuKY2`4+VlzG@RNCfU>3uTd}~`&+O+rFPof*5 zVYoDGg%wn&KsF@JjmKOdYZV>NkW|v(hB36G#Pjgk`>QYHM!((HmzOMQfVf#11C|tT z=-@NIODLIv7M|f@xPWcA;MEX;5pBT(%h3R397KYwKFf`3(ogR#>DJT1>EGax_j>ky z7mZk4T}HF=8cFa;&h#r>J3xWLpk^rwuLTJSgT2vl9jA?-OPC4l$^GR4!$WbSLub}N z20Xqd0BT=yx+t>HcfWDk(5uqLEl9!)@3#BsR=^cSJ$sNkd%zlQZwJ;xqbb-J^x33& z>Q%S{^!1o#(OB{5D1)+xq7{toVVyO>Talo3- zAs7CLlW2P<9B?_hFlMc7!EPNNBI4(blZ_KqO_f+1otT&$cI%~VOA=TD4DjcqNv^u7 z)elS-`F`6iDr2|qJ6oX8bj>UeAkE$mkP$gJ-Qwi+FtGaHdar-~_yFJEbwa4^tlcMH z6Zq}VulqOr`us}oX?}fr#`RG{X3wpoHfx;)?1K_$-t;(f_9*r>=C0G|s20;v40|k) z82nc=_r6Ef_}#|0BOjjT`po~*0vJM1ztbK5p3l_5U(j>DL1mBQC*;Yoq`k1Jxz|SU zet&CNhN?pp4->4%6NF-tNG^$kifJYYXySEDf)mNORYWP(e%czQC6;^>{ai4c>?#~@ zeg!8PPEVWOn1p$@duFrOOt>dlWWKGYEUjy`S~&J>Yt!_FHZ_@bUs^~LC~}1?0>KkT zG#FDm)9$jH`r3B{`5j<7g`J45De)tuq@azB-Tz-VbO=BDQM6ySVFz zw(%G=%NeWucgjsU12)3h$rOWiRM&?4kjw?R(1$Ovym)3>!^4#k4@RWH3SZWBIlq3- zM5FvI%CAV*i>f*6GeW<+#1Z_1OyM@#3Lmv7O{X)8aU&olTus#?A|US}OQ&MYbLpLk z#N)kKk7lx2&CK3!{0)0B171IGV?jWD&ZyycTLqEK(&}{|q2HjSEi1||PKdQH;xe~B z=ii?kf6O}9lo2;1Ou6cGBpxlsdAk8ygoY{~B!rNkyGS;P=T&BNF^m^MK6lv9ZP_zk zH*L?5+xeW;e>KDiiDaAmmv>Un`5u!LRG%=U6?H}rXFaaZXG(Je?{8aPZug^ZoE}!w zDaQzb3}9JRD1+0kJnoG?V=#OYkR9u@ERUVWeJ|`au~l$6&zss9@j|b;4(}V~L+NDW z%@_ykEU}Rz#zv%L%J?>uOGFd*Pqe;)W~=~Fx`fVO&E8j~%0aNKRKn$QpbW)$_He)R zKfLgnVg<%)Z9{;KH*BrS>K11}t!#QYp_xu3zu?vDxYw#$T`Wy73ikEI&gEf&Ng@b+ z=yxu`ITPi;(}4MP#&QFZqc2A-d>^bM^^Zy+z?+N~H?O zvu53^nTc{Uh_gj>GeE{0^3{)o=Y%m(m}H-l=HRf@r@{sDfMf)1nhfArKp!ZxbJ$(b z(zQa1YO0F7AEKnw+Wj+eenuGK+i!F=(!Mb~=P9N*z98@Ywc4x=w2Y-zLP?wb2|_dn zY6Tl}PN@j*JO*{GRG@;Zimx?4H=qo80N%<%p;_6I%!&PYQTAp)APulWyn*Zed?paI zMse}YnX)6v+DOK08c7L#OZlxMBO55q`wp`);+6f1j7{&P(Ej%6KR@D+Pl3OltVsSF zP24b!`R5hBj!8SRteu%QG|3W5^9@7Dpu=ESI3Xltp^$JQyw)P1%jfHp>~HdJ(GL|m zXA#8noDNB)-9CCx4@Kgg{(UdA+?`biLGfz@=|0TI3%fowyNt^@)#bHA*DNciq;9Po z30Vr9wc#4MIn!6KBRE+4emtTefk0=O3}wi3?(XnMKVF- z^alwy&(Ejm;Cvaitwl5!2-+Coq7{Ge+pd&fU07b@aLl&>7&LnYFm6>h32e=RVt!X@Tfapg`90_FGeD(ucCt3%Tl9rtc7=&ok5;8OVH#k|Z) zp&`&+fi}kL`|)Bik`QRV%7@q?SR+kVs)PlN5!-CM4O{7oH;D73)e zdbBHrzF8&0pTzlDU(X*4FNe@el$(zZ|vif7ujF=Cj6>S9DDns;WB35nuc95<3Rlb`R1c!#_!u z2XHmqb<3`^Fn_5kWBERf`lo zUk$rU^roAtwodJ<*=YaAF{je&I;Wea$_?<2c=I`m)kf>RP5Y0&t`_>6 zg(VK`PyU9zf4c0|l%kB@nta%5MkGa)Y+<&MdPRVT4Zvwb7sNtnTpLJ<`>hK7is#&Q zY~PZG;pap$AEm-@yaJMsQ(4Ix?#$*a4#Pc{+0`xpg`($wu-4|1ltexHqJm!rPt!GQ zF;ygzrKu>-&~2Hvp>HMcDgtRp%AT zqqmOQXCt3d2P>7a;t_PoG9(~F?s5I0?09Y#F3#?_Oucd{n#|B{(;Va1GSIkNO!4f? zJ(9Y+r57gC+YJ$~H`r3Ol2yV9>~}*eEgrLdJlIujy?;tk`?QsGb8Eh7T6y1j;puy% z*BMCL*_j&j`b+!XV&xEp9Q+IrO40#A*sFuzLiU$4h>U`NN0MU4=tkh9o-+b`=TsEH9M6 zX3((^NL?w7#T~9Ia6Zy>=kHh`4JAL%I|7*UN+WUga#TcyV34QmC4Mt;g~sh=xs7up zlve-|5j1vRB*A89G%*!YMCYplD$Bg_2?a61D6XbkSn49hjRi17f)I1b5=IfHGO8wZ4- z@D@*nF9xiUie}<)7+b*pv!W^#3biFFrjb@$X=LFJ|0PtJ$03cgy4oH6)p=ZqzX4C? z@B@{<>~ECHebHll5YX$-?dhJ<(eS5)$~6bK6>8#)(IDLMwKWHSxNodu z%UlXqZ<~k1;`KMlt>rrX@jU}~pJv=cu000ID*8oQH^#Bo304Vzq9dSYcI;mh z9d2LdkLtG8Y+q-jMVs4`9tkL$YO3D&II|*3Cf;k1(w=<+Lokbf8OPBXWSr;(qYg9A8cz1#NRkrlb;&c4O!Z+W1&UkYY=Noi3Ff= z*SX2c&ho|&+PQTYjHPY?NFrF3I54D}jf|#`>FNH28X|%tXOGX2(#QD;9lDYoBku~f z!nvDOzaSn0aAdW4QRYr6v3p36=^^h7Qn&Y=1tG-v9wHkNZjW1qU-a+7(XnGl$8k{@cv0snhDvlND6njJN3Z08lG=+8+ zID``fMCku|EEfPb%?eo@H2scat{rmB22=KU-;BqKpsF| zMs!(uSuj|RhgT~F@32y0;kYSPI0F$wkVSPJ83Ca+IGkUwhE_6)PTqPPof{9xlTS;> zr7nAH##B+J7zd9JF(=aC!zjp4ows`<8Ikz5UPcF42gt|(zKMb16MWT@0~3LrP!;KB z(G~g@-rl&)?M zBFn_(x3n#@1fxRxYO21KVR3;S0<4!L4d7Ww zXaFf1^2=_$KyimOZ&iiwO{}1UcQ(O0pKZjwMGGI#aLgJ3}2{`I`BVquAC!k z?y}kstkjC=9lc4RC?qxWiE*4=5k9|r4E!wyI!2Usq>gcN-wA{fa!*9vWaib9w2G5t6v78!r`1|sGa6^2sXd(JL~TamaCaQBZ&^ zm~f}esNQ@wB_P362|R>C)1fAf(<$vnX$2K=3vcd~2aP68m0YmoEDUQanBprf$2X>! zgS`scG-Bdn8V~VeS#~+>3e+Nu1-s*Z9IC@VzkoUhTnJYo-(TgDbJ=$tzGY#2i-wO^ zwpBvv9sxO2AQ+*9p=`n*N>}UK`k-k2804yq{MSMbJyO~ zh8xh}BkC?P^S63OWb24%^L@20slYG^&4XHZVMuk634#Z~k$8NHDWv9!WoEV-Qjh|9 zGzRIPubjc7^2&y1L^2j8q;wU*^5MaeB_{ZiM3V+Y+6ahXv!Z7YeeFURGL_65a|A6g z0us7y3BlYb-dh5EC}IeqrmPt+eoD@q-bXRw8hNzci4wVQN-8M#WB+wJ)#CsoiL zCP^wuK-+AZ-SRE9EqK7zs4&S(2NwdS1+^Qr_w7N0g-Ct+8OZ(e`5QIN-gSg{N#i3hOEB&o=L-4!_K+iEGcam;%?k9sr*{wtG3TG5D3=gbj7IFX_;>9-#~7 zeUNRuoTR(pbvlSbippa}HcyN*O64jdN5WXU#0*nL{JPA&;0K#Tn~dpL=ZZDicEx(Gs!o4fQCDzqO)9 z@HhH@=e5Ov7%o$LULLTx)KC{N=|AWS(6Au5|3L=Q8K4QuO+~88;e8U>beON$Cjosx z6LdVbL@lwjugC*1m@El7q9W6|7qk9M&XxgcSj*VUB8Dqx9&R5$X$nvdYiKZQs@oN+ z#}UzTy}=8$A)=DS!ukb`&jPT1b$5G}j0m-XsLOzNV~||-3w<4G7g`1RyFQ{T*MtY| zcWOCbQVLoIbUr9Tv!}x%3uh1*3pLG^y13oPQhfsHW^G(J%1u?exJNe#&s7Ql;9ry? z2`a&vg~Wp)-yfI^DnIJ^8aUpRM0)r;6^LKi&pi-+ePZvE@D_nb+x9 z%4$f-9AGC{zBS$n<$<3Z6d(`;C3U`$^AgN~zw0`muBn2=vOj%7pF={>+A!G2q6MpK zXh+vMEL}Xvnm=r~Z`B{IUVU?08^nQzpke>QFDQ#CL)Fki;Xy@)KlId5mXaFaMlG{4 z(mdcD^=@lBzXKN%2b2t-F@(c+_l;sjc3h#C*(=ME_ACR9_#fz))cRK6q3$^X215VA z{P@?Iw2?Y4NJ#3`)N*E9p}%PGFHa4TWvJ!$f|Q~&f-&$rvsB?})~>#H{lvK$&O!pK zu`JYY>R})m&Kh({2X(FZg^@XBwJ4-8%mJgMP$@zba`4$I;jetQ04)I{?Mr_LLl4B= z6y0c6T2IL>=umJlg{JA=k3P4zDVb=p8U+C3c7qQNKf=o@*4_zcCH>EHPF)|onaPc+ zt$Q}KjKwQ?S`*}YR%r+>nw|aYt$!#!)uH_t>)X8x?E_9~*_+Y<G!0GW zuwsX2e;Fr3Ovjdk1ZqpUrCSlRBZ=Wp$Esgk3S***)QkzS2}0t9bvR4xX0LwwicC$@ zwq(TuwS=JbZP$zzMP%;JbOZXO02}}xEj{1y2idtFOCL71pT2+38VzDwdBv)~Eu2x_ z=y7qq?G_*w>qK`;+TWLPWB2A#M~D1QX@+<8O*dRLuDDA9!ly~jVByi`)HOtE6-HgK zwG)@4zb4^~()y5XG;#pn0W8a|9ivLyS-NHVDNiqwFrN5XPD+yNC@jp{*Z(p%^s8`2 zYl%!l(t1;-yZM>%bS+Y5MJNVLvW0+ss%w-c6@_>luRz}XHGGCIL*=nKJY2q`D1;2A zZ62}`7bDz~PWd^j;$wQ2O!GH6y`iEbjd6k478nM^Z7I>|2usFgYuS3%h*BCiIkpGf zAHm1QY7yf&T|^~GkSa2T30e$Vds+faAcInXQ-m;o@D^n-u%#QLG)ikDVr-`i^7X5F zDqEfFU`N2X9_vORyVB19VYHUww+IN5ppgCy6!R$lqp+2(9}YTfssn*9H}C9o`>h30V$4erd*z^U{MW(3az>aR zBIo6{zh&B#jBpdd_wQ)(MiR)6!hA zm$A;+c??9w=G2xQ-J$?i0I126X%Km+0WA1Q^-ySN3^7zv*+5+bAjBofAx}3@rU8K{ z6EVx#1Y80U(r^9W^i^1{Sn=>2%wgH~236Qj?=#MF-3FJF+%QKO^C*$9h8m>Ez> z6KaAn$+_9d#3W1(MN3p^BnXPOHhM_`yo()|92>=hd)K9@KVBS5nGQ+U zZElShHC=LoJ3YMANQdRWDUrc@C{~cs${X+IrYXqaLuJs#^m8-mrzNzg1bFvAoq4}9+j*3?cEM@z&O&LApbIAW;>n)(-P?|R3VbI_j+#Q0udmuQ0!QI^@ zIKkcBA?Og?T?4^`y9IZ5`{&+o-`#!p{Cy4#XP6o2>guZMs;8btZcBG_WZJE~D;i^3 z8oCEo`F8#=T4FKg+J~OpsKib};E8HrB#~`WLyMv^h@!ezC#t6Pe#U%WbC)Q9ni*}H zi}MAid|w%k=5{5Wf&V)1_)j<_h(u-Fw_Wgb;rs;YR$kctE>8txOeRVpy#tu-kq1eN zBdmv^1GV>wwoeTRvsglV)iR+$}I zZ0NdGL4i||GQMCU*f@o`y#%RAP2q*+Q>qXg6n)ImhyG9&)jQoSKYa>v`#L4z;B2}> z1jWwCx1Vj|oMV}RK9wJ(fcN7DL_yAH3YV|%4xI0l$|?j)VQ@rI6mow%G<1c0o~R#K9ZO&~Q2c6X ze#=XSTf~I=l(YqHB=E-hlVf`Z<{~<$LU3bEy9rEUx$X-URt&S>wfSSl_2QKAYy+u{ zmQ)MFadR*tVtiC0M=AVPS585VR2~+t?$0Nu5{?4a!#(nzSv<9f6op|mC?D4ZWoo)I z-Qw50N!lxy*2@VE<_eKAI!eM=izT$HmbOspz9#&KS|eLD=DUf(roB zt-A*(2}~=<|B0i|YWCjX8T;+p_vB9B-U2k&<8)Ail~4mxOG#0w0UOF3tzICc4AUJ! zQA{>u$s=3k40!Us(IK!!y+<8q;C=Cim-U_x1fB zFY-oMs;k3g4gwGYY5`TTXBUNy?^o-&ghGv89oCP)THf50jm`!{AdJlKGCc_>{F_>f zr&Rn#!cm1AB&Z?qCjeCHs;if~vkip8xD$h01eII6`IvYsRL_dc-cRd`IU&c~=Ukzs z5i-pIDl3A5Qjsv#M_4BLYy{p=mK=%mjE|;DJGXXt7Jc|B)92N`O>13@H0*_vnisdu zQ|Iu31G(pVyz5W%uPe6P_fhp4%r7%t4rY*D^->W)oEIC0R?Si>0b;eWlq`0p#z336 z?LnUXiRBoMz{bJOPFN_4>-)!TogGlSK?4BD05AYjpCYYGvGx>udPB>~5KjJ(^Fxy| z4U#DkRw=AB=+BX?9{pJejh3;^(Ln{kn8F)|+j4hYZZQ>Uq|q{M(cg%mMx9e(KvdA3hs-(g@qsDs~5ajqlqsNcQt5Ji?Ldc}haa1K>smP9vG1)N)+3*9N z$S8s_B=Hi`KRmd4Jx;!FcfTE1zKy=WZutA#+%7+mO}E|vRO|C|Suq34gEtv#ua*(# zLG*@ukbGC!U|;LPLYfH(CpNR~^=6m2N7pU#_uHtz>)WH_)6G^I#FejXKpL2Lm5E2{ zs0xpZ-*kt%yLtS5{8anVNPSg^3C<_ot`D!D_nTdgU+>qN6aR@DFL5sHuH(4L|EIFB zorh`W_8^^gkpl5zq#;Z0SvR~@XO1~k-Sy%%Qnl4sh|g}PrmJID@%K^iBly2tiyEZw z(6(xL-g+Zxf|ueneLRbfkFZJpg9R8H((s*sXz*3}m6Lhi1Zum--FIWM+Wvr%K5dfq zQIK}?TNz)TV7u)MbqqftlIj#R>T6O!at~g>7(i5ye8TF6Ohs&YSr!Rh#~@6uvKE%Y zRPr-`?b01)&O<5KzoU_S5L~;>m#x3N4axZvjere@!eJs8mfzQ|L9#fuu+_DeKv*uZ zSvqV93?1hZnLxY%im$E{c*BMTM1a#ZViv-RZev|6M`ULdi7b1A^Bs0Wn4C`ma0&21 z4C#donfd(CNHFIZn+eaj+)D1jU${6IMB4>A}4H3d)*+IS;e&-P(4 zot&uk(O#U(50wF35Ios8J3+@=o0>WXJuTiabG&3B?4#HiJwN|<%pyL$pFV6J?3K%* zBi%fgpU@M&huf<{YgMNojH|TaWz{-YkC4F!AFf){h&K=tcb$iGWB(p;F2M$I8W}%7qgF9vO?p z$oRe(pPWuadHFE1@$SgZMFp~v2xlXi>p@8PPUIS)l7QV4{{bJl5>y_fzq06sA6P6H zEY{EF>p?~^Q9|D>*MDn#zrYX1*bB@eD;BiB2j`lJ{t-MHrkH{q9~)x zDI@<90>lE;KOnYMW&4Eg7CK#WgMx~T~|S(k-p|rZ(@Y4=|~7ww7yTYT1TF+ zo}a+;LfpQDR*D&@r4Z#UZgO8K@3{Nj38S(3V>aVtn%vBj%^Ig2`cx}7&;M1Qqomx1 zr~D`Vp(?UOsulV!W&@z-smqIoV;>{o_%`+}tj513oA{>}KE8{vnPZrJ(kt5PTGoq# z5#dmC%_@B?fV&F+6iZwOc74i0p1WLRK{5_T^}*$1J57P;yq(NrF9}b^;H*Lf_51Om zr0Kz;T_5Lscm^M>IxI-}1H(rNY*hKJ-$%gA!Vl#Xl5}8>uX@n=dPUKDbaggkR*p<5 z)GgwW8xo;pBngGARWNGFhcU(i01$jFzKiQbIJOKFPCgcC4HQBCl27z%mE|BNP4ezY zCs7mgvTQ$UgU$YNtI`sm`rt%4Ju3M?9;mIQPMYu7+i|~ey*pa!!HNC}ZEE%glas7_?i8|4+lOi(c&bR1Nhk;f zrq!dr?+1gb(=C{@d}U9j>aQf${X7m(NGI7gLFKn3yqnyqGn2lg-+0;pi^5D z?^f`M;$%?NVfdc$&yX*uIhd>(KBlG|o4}di z+m9^##JGLVe5W>qH&otGCwhO=v8s9#`LQ6s)H&(CFLb?b6jxmb^0h=bscB)Zma7Vnl z1bieT+n0d+m_iee%g+?&`^wFB!I>M&@2_WQLn4udu2Nc#1%?VU`o~RHlH-}*sI52F zH`G909+U>%DHQ*$^T+Y9L`s_#%{ZmhpOEm&#N@mE))FV}X!n(u89I4h`qg?0E)H=1 z_U%>oXCv!B&=>4}T+JPO&OG`W)8~oEv<6I71l_Oeao& zvUP$7csWE@_>Pc{POR0d{nb=WoQewQc!VfvYEE(1@9eP!7mv+``dy^qI@1u&&{B^T zdq%8$I?jXe%e{UNTZ#u>5BMIEhaUmwTW1S7Ci>z1kT6XsD`6n_G6j@|@S4St=@&=L zvg+x)828S}0?aW@F1kAPtJ%US`AK$g88dumI3fD};%;P2?}Ib`JfCw6vH1P1j}OPy zr3(xFTfrxVi;b6gHqSzko3S6IW?`kn8H{_gq{(rSLx=#0P=N{GQG1ou+eFzbjoE8L z(eYVB19owDHRXD94B=f*Hb;>*mADI~&BGEQ zjoJw(ZDpb!wi~+VslyP>l*z}5V7Lpqf0E>m!%i#NI5;KL;(7WjAv5=V8XNJ zu>^A-PfW~N{AjqGQYT=qqQn4-Gf;c#^Jn}UHAonlhlxmykc816jd=1mPJO z30k<@lmnVP3Nv2N6#D_h@zCam3#~b#R41cc(4fWxiIs;Es~nkiYi3i6KBVV8W@lYO{||`Xqi)UWyauyfcoCq7c<-lm9Z5jUo_I z_{DYo6)!0-Fbtc&w0SKlRuCs2^g0QxcG{OhPC-6>@G`{*218m+a}}lU^|9az&lGxX zI~dKQL)Fshm8luP6takl_`RQi+`uD{a=d5(r)ydO-Y!862Bs?drF#44^o&+R_kc2M z3QX7@Q8o0&s;u7Q!AT!dNKE;E#+z9JERjEn9C#Vfo)1#U*l3wBrS zVD%!d&7>`!KdS1-OYhXxa~|z2Wevs+cI)m&uEzzYs;z#e7i_FnRNdDHVp$zNBP4d_ zEh>xY(#u8L2KQ+c7#PXZR4S-mO^p2Oim_rwhEgDbSc<&22e!GXtf3?VToE`&E{1uX zo2@ozLWiA#90~x20%G18A=r0TaLD%pT$Rx?3ba`A54!vHq%*; zLRrhb2~JELlm1v7uTs0#qqu>wxTz~I90z8iX2Q|uj4RkO_0j17Fk(^pV79@7AP4ao zO>7E&lA8sY*jBrhJ#B-HqduIkuy^jl28CZPTZMhw{9fc-yk3=wVr8V%5DJAymQ1{# zaAZLmU>8}_G1*U|fv*aK%xYmMqzmnnU*S{0>hl~5n8NF=Vbh;)`-27aCs@P39KDX5 zDSg+;MV{ZA#1Z$!Wt8y6e$xC)_(S8(wp`>Q)pD8^_pW;6v*Sf@t=-;dB$2?ic|3cJ zzq#v%Dm$SI@i$j#XyKI~eCU(EWZCTVA3nwkR`4{sBiq$$XZA|c+y*b2IhoEg-c_q; zP)UnCz8(H!%Kc5q3V|4W`|0$di@*Uo0JbC&oAX+SQVE^4+qQ`B+w}Yb1XSWk9S`k( zK*T3KK@KVV;Fr;rfuGQi+Jp_NWA5S5L4~NxL0cY4c$OaMDu5rN=rPvTca3OcA|K2F z=D*car9dfFhUT9oIk0d@Uv9lR^(War1CGTf(dj8L*Z_Emz|UM{fH1(K7YkcQ2LZZU zARe?D^r7E~D<&!k6vZYR9m1IZ{6)$X5Z;3T>LoRZtu9qn@e%90q{Y=FoeO;;v5pj3jgeP#yzYVfd*k(wrB}gp3e9E%3Q>*@%n) zgCA<>V8iI-I!C!shv1BF(e=2EJfHw79n}j4hV{79b_GSYMCjW+Agg2F=JxEzQ>2N((1aNBJ05!qT|kL&IGArWpV-SIs6AH}b6)xY z^}KTu6OEG6)3nEw6U7gCy8k$3yzGfMeLP8Py4l=ZMAJOe!FVruVW_C#_NYyi!A2_X zDYJLjJP@oZ(C9Ya^`FkLXDs&2>JCrd!`R9EJo6HTnuGiZ zdMoj)7YBED%cM8o&4RN|yFQryYgb`$|8x-_xu=V`3TlWa-ZuEq*)@lb0cy0;QLdpI zpfk4ygNtA!0Yz}aBaQY!Xr&8iy6Ojro4{5wW-oqHfaI(iwj@(Hccnu|oV6tK0lx-T zD9>#uo+}COPj9TxYGiueSx@-i55h+Z1(VIbtPbnUA*&fjSKceE4C0}a50Fv(M()Ie zZuej}l>(@X?$Ke2Bdg2;BEnm-^6v|X9YkP7B~7qNfkOwMi%Z1zgSTDzvt!}+b+25u z_sTeZrRhd7^F79$T&Ab|4^2t_NNpyaY2a~?E926YzEgX6+kFmDWKZOrjC)kc`@hQ^ z372?~I>(2D<;3?H)6a=c7H0e9QlvUBdVz_=4Xib=+YG<-Jdo<`+PAIY*W2TBfYL{1 z>aeI5suj6*kFG-ub0FF*l~L#%r)K3vz0z;X)r>dVF}HO%Qwtr$``%r zNKsubJX-dU;YP}yviY9mv6IQK;`W6oKY&oZG7e7xl4R4kd9wisuj;G-Xjs58cP5k} z?eFy7k9r**a6lm|>vF0B9a%*w!u}_7X9D@8zNhV1i@pgrsP)hG;;cWm+5(_w4k+Pz z3=I(@^(-$Z!s_s|+(;yQ8kD&r(1Y9xEC3WLoJkaYQ?k(eyhIG5g;$N7fFWgUJCGDJ z1`&X<0C3$(ISmFa$X2D+F6pfHrK#F$*>*d#nu z4O>bpHLS2KotPryJGfknR1o5QQ7|BsA^~@ty&~}Z9)|L+Kfz!I?`{G^b24icPVf_+ z?@XrH%+nS6a0;g^Tm1KcGEq@7ac5&Z$rW^;WGr^4?*lTyG67{dlEhQ!zj~x=OJLo7 zA~h`+LJRE(A-DKODB4$XE#MG~Fox5&NUDiwd2I1)T^c(4^i;9clb zT9*>t(gLLfeD1*qKyx+svHI?^|50ZqR8snwP6FP&ywNi$o$_^%)BZ8C@28+-@FWg z7m)tuGRc-p>|iPSJldYN@fdy47YhnpSYgL;=df5C#1y)(~3@*Ony1 zlkTc@BZ%{RFDj1&XOuHguwt;n6Tn!7ixx?K=fi|fSkv{3UiYaaE$~6ICwbP-Jp2*@h050Roc|%I8>w~j+*0>5Sk8;iHucn zi|}DMjwwjSgP?}iKM6fqwK!}$_sKL{#YUKeiW*CIZG}>vFs0j!<^s5?k%w88>~y;0 z4|SInXni?0Ew?&Xx?J8A=ef}2uL}~n!PMu_w)0FTTN;8(NyP$*y=|$H3-7Kxr9e5!%s#00i4Y>wHA8 zp{NXMD~xMEY#9}E_y?$2Nrl3|GOK$jc^pXg0s}uljp=g)z&d}}fr~@!pVBWC49v@6 zjw2a>4FvL}W286Y%=kv(mi@-V zt(2o*k!q@29wlakyd~xlYyjE6Ma~i;zH}3?xu&Ifs%klzp(q zee#kr+b8GEv+Y*{pvc0-_&?Gg{*GX6&KBBM9@JQCDov`UAZZ+p07t`M3dU^2bwqww z6GMT*AI1=1djclOmC zZ>oDGK_GR|u%x-6_44Cy4smC5WuBP00xRDOw&alzaxzReDfBvw0E&2MQ&Aul8Jw{x zjYd2pU^oC9AP*XNcI=#AkUP!haIdl-163V#q~@Dcfv+6tS{(;$+1>^e(*N6cnn2Di z8y`H}jjD=TAr$Q=Ltee!ZzT3NW2@H#+Euwv>-GL2&|b^50}Pnn>YxvD6^^$D>WAJ2 zr10x+6uxo*^Q=mXoY)V~I?hE*-H8G$TACtVtYq&YNBJ>#AL@~)x(y-MjCvJR#0OvrOUiurk+)gBrW%dw7VNx^SU`94qEPa?o)y}&`Q#> zx>5_Mi-IN-LDYek`+3M-x}EV&Q~tT0{^j@v&!he?uaFQU+xM)uJ?^|!+P_U_eW3x) zyaJB~{{pr9S)tLVN^Z|_LmXp|Qs-W?IQOY(Q5wK>Iy@;QIUEQ`VRg z3=GAmYymZp76?FBC@cwTK-VVijH`@OIL>LAkBa+SSaaZ59xl`KO2~%+je%az*m{ti ziLHx0pjhy%2L+~4k%&kC6}Bm%Tv%w;A_(MnMuwmbvl+8pPQt&ybnjv0{>J{X8*WPn?90@68jKz_6iD#`_< z{-Q2$p-F2)cU%k&rl$7<^|0k;SPp-+Ad>r$Dt|RS0GjqD z_eZ%Tr2^>)0^vyY$aV49C{*58M$nZLa>yxL3;C17DAV8>7@Vo=pie0%z-3YiWr#B1 zc}_Pqfe!tsqhMWLS5cXO6C&JLA~(>>|F0!^#}kxH66pz0xZ^pWPF+-OZLUk>MlL$* z7^5GKte__?HBwiNr5?`-6;xj?k{@7N8~(Xkdgr+DupXnZTTfuY)Uju4c1|#}c80Zp ztP}}1U4vc!+%hM*wq#+w%xFbBDcktv6w83}%kOCBrJmG{RV2gZcHBMr4-UbtKaGl0 z)Xz8L&6(9@hJHDkR{Jl#^xUZ5eylP-jlE~1IdlINqHUygi5Lpn&-xIxNq_A;&1b}L zE1HeS+eVo2v?3F=*yZ^}uf_5mrQ*ym9FXjOFCDBP(8z3$tmr-Z;zjG}@hKfN``SDY zj4F5QzvFcLRj;2+bCtRK>ScIWb2&*cJ*X|X(Dc*yg`x>_dGpfv%bd>SUy&(glRtTG zr6NIe){mb;C4*-zNXOP|eXe=Ws56K8n*~EY9cNCswSOKPYbhqGi{byRz%*GunIz!j5e$X)anCkUtMw6k!dAa1em_qc0riOFY690uCoQB7=aUwNNm=!dGypq!R*+ z;uNg{?#q6Lp)ocu)Q7!}vj_iIH9y+_pQD`8FI1?c+{R!bFYDKRCCwd8_3!;nhIn_+ zXFJ6SIZEzu+kem5x2-$n4(y|1s5nud>xW86Y_rm=XL_J`cbDAqpVVzyiSdD7Gz;Yy z|Js|M8rE;qCv*>ft>m7KJH`|6IAz`gMpjq8CU8m^#(o$aKVU3GArd5$SoqVXv7m@m zs(TkalXaak1DublUkMij)H^k}snx8>k|2=-pl54kC|b0b5T?jbkgN=KWT7$m^ePcu=xxcWFp?KXs;#({En-y`tPvU#AOUYVU4M ze|^438f<9fq46vN;SBw}ONnN^8T3m!gVso2HW}_F{&RDDPiUbxqJD_q{Bk9%c<{)Pr&P#D2)4bn7r)<2Sn;%andOGa@-u%+g)M1>uc7CV751VVFBfNlYty!$DCz5FO#$%^-kUvJ_Lg~@^ z;Pyk>SJm0~I$8oVi&pakwDXJ%^~iU-+rGYRZwm_-@rC;|_n!|dGUHiK>{@C`>0K%2 z8?=&N7u=h^tWR0=)Q_G=wE}4?yRd(pq}Hsx=`ARR?=-5g=Dx`)5u!m5y|reV&PM&e zwd$FOcWTJBf=E5})@F>57;kBEIm~0;v73Bsg#Ie+rsAn<-&l&^_q#1AQ`&dBAv1L^M>7KRwP@d34?F)=DiX_* z^`Y=hqTC?guF$`y+N_bm$Gbj4-FX|rHppgMYCB$bVvR8$k;idP`ft6MBJb62wuj5W1Y21lc9{y&yT!xTz-5Je7ZK;w+=)#%|&&ge$;`$Ny}`@>y^mXirLhWvT4?yI~@ zr2RRCJIe*5gB-!aL#*;9JbFX;?~T%Y5w?x|jvD6~nPLD9;~;cJR6VA>g@*OP z)BN&!Z-dQ}cq6-t3$njD%VsJKmnl8tW9mv5TMJ|X!k2_x)=Pb}ug zzq_zc!wi+mVE{qV4nrD444o+NV^QZb8Q7#BP?EgP1G+qf7=8AH^WJrxsF&Sxh$YD5V^4t3KUdK$Mr@_<5^VQvEL10--m*|TU)5-|<*_DVP z^83$+T?og|pQ~=4w;PGk$-8sPmF_s(cj2xnzvDl?V&X%xxNq-%@2P@SuY~+)K+H4@mN5``RMqx4gqSbtG+k zpV48BBv}liF1DFUr=t_L2`PCdT(~|V$R_Kv6r@SJb-K~cb{sZ=#lcPQc%NnbaQEuz zay!gGxWn&7Q=K{xnw^7HS}m}GfI;c&(B%H!(QRX+9Q5vR;ALq=bxC&6;i{SQH5X zm!WrNwq>%!+ZRz@L+3i@7=oCO`eocU4{!k8@LJEGuAlx8uU-s)-wxdR3F4V96)2iP znKQ{W`xT#TJKs8;?#13ibx81reRsgJ{ zbCgxGD>kML!2H3*FEf$98Qb)$%)I5J=Je(ruO`1@cgHvkr(G;uV0#*n7CUZv<}d{$ z2$P&`J8+{C&C%+mWpmXNllfu;=LC!yyNE(LEF(Cn8jZNaLrEHwvA6y@@|Wy+p6ljN z9|{E7YjE<5EgxgF=>N(jjJrk3%+cMckJ+}VG39Q-SvhSz#av`MnwNJBn7K(3ch?~& z)}QHfAM-(Mxw3MyB#Js5$Z3&YVza2v+x(L|O1r>5Bl{t#!2VitgWwn4KdJ2v)SOWX z4iGfQ9AKgCEpJ0auj;nIFdp4^W?o~18}J7PdT#G%+?bGw&eO&G>2b6@vUASs$yta5 zEldKGDy70}OasGVn{~1KdgX4VvK=)K3%p8G9a)Fc_gK68#Li?ZqYb8%BMDzTH(UU@BO$v zqXX$ZO(c!|?-I#{68%}J zzd7<&#i?+{6?NEnO5RA+v5_i1?a&M+Ct^2n9odbG%RKP` zsmMc98;deyvT|B7?^0dyI}New2|0h9Vg&rW-%M=q+(_o&L!^U#hUT_-qUf>*?d?sdSMS30L zGwI}iJo)CN3|RUN+ivo4;Ym_EAm-II(Mmu%(=`8)DFgG8#_b^KCu82%%c07ec4BK` zj&s2%9+$JUEYT#aQQE@?K|NT7m8nqLp_AdaO&{<3gw73k_X{@(-c}pN`U>X6V*Kv2 z+ka6D+l1f4XNBr}2b$9+{T(L8f=j;g(z1m^s-AXYOmJ+_4$EcT!5#q1%(9ZSZ_HJd zCi~fph&09&C;F~bvd0n#Y?2rp5*(C6uow-M(mn5aodR)5g>Cn6K41%z#a>w0;D88y zr;V6nw=V-+Mqgk|IwAti*&@o8><925xy8R9O*pL!c@PJDBM7(%IvlX8#9(of%g6>% zaPUks8r#=J5Hrn7N=xDK2(~dMmA^!B;8Pv#Z%y!(HfPI3%P;K58!gvQ%u0`&L$O+HsUT){q z-;*&a-wb*k%4vKH_k6Vpo73ffEZKCxGW+kv1T>sGTQT~hj_%3Ki)Z;8kGiC*Gf7HC zD}OVyKQoL$+Etmj0#_dodKy$(-lnVz8n8|r<_h?@Pi)Pdr#3zzX-&BGG;N5CS4>ti zmG05)>m|Pz`bJGE{%)1bvDW`m&}qXbA~x#bhP|u6utQw+7&Om(Sm}4GAws_|=G>vP zVP4PGitD?r{rH^~fVDyL zXP(|M1=n%SM>E<7otgWk(*)bi=Zky6`*j?SR529}x;T}O)B7jRcP~@c1(mN4qe9hH zFLU|C4pZtH+yW{;Umn}RPgIKu-ZZE-B&p`F3uP=DN_jrgY$M$zG5v`aZtH3GyAAZM zYtEAwDvG%!yB{d@g_u4wV#LtZ^9wYar_t>f&Aw6XP>lIKMHjkmUr zCd?#IEq6_}mMQ+KV!eC*HY}vgp7G7Bj04drypRr}QIG`2CvV(3-k&dxzLaS8JCJ7w z3d$jBI*a!=ez-`ryiAx_W4@SSv~W4J z`Rb}G1T!nTf$b4h)O2*(EvJT1+-`Fi82CXTw~64ZLDvRX&(h*i2;;~3yoprWL=K|> zD5aR;FZvN-R;o{jZEs&OsjqJP#dez+qqUvzdAY>U70G@j$z5M;o*Bt)eb zcRo1U1};ZS{@f4=Zsa{FJ{1XCAiZ{#54lw}D4_bqAH8(-*E&n= z`<-23_-M0KY(rJCYry<{saYcvi(}Jtoi#~p5&1rNJ5wv28!1v%mwZ-gogk?|5lX2D2V8o$u;P!Ud+HU6sw?o5$B{H$PsL5l+ZhlSu z$!JYVrMFHe^l`cKdkw#M^GBAcWjnUk)!F5yuaym9fg+!giiU($uD@b?Bk-T`-~;9r z@A5F65LAf7u|aBTm9`Oo=_JWfcPqaBD5pz#xnW{tG{B+J_r&Uuj0}v{Hpe0l`6abo1vY6%%ySt>CFo(x%Q%c*%hlpY zxb)iG%d5`RRJ0OgQ!J*Pd?mK8a2QiR>D9U}UE#RJWXR8^$IfK%dOB@?o2v#*4f+xi z{9|bNL;U+OH`WA31y^AD1OGTXCl{b2L~Q)O8rQ8;BV0 z2|I1v#}1RmhW?D`QL6i`wWi2ASJ<_BRGzs-DeMr}D}=z?--@er;W~iKDFo;xq7*BA z#@p$Bjj<#+SZKF{mw$S9MR_u^Xf`d%aBtO_;}tv-y2qrR7-wIXFpy1Ruv~n!ZOyo| zyq(8kLfrw6zK_pfGi?(x8GPSSnUHJR8*MTd|IrvM)Ad(Jul;O+Mdx{pd!q-8H9$~3 zM&MBXvOO@2BCP#0Mklx|lQ^(3^;~9`C@qyVn(KH(OM8uWqmii<*HdY$3ivO0JDlZeyAa~rRdrCpTDmd@~weaDiE%U2tx(My-q z?GxtaM=x#>v*xZaPY>FAJRYPuocPriChN=I-!XU}8F>9mdA-FADA7`{pZf_KrI>_W zoN`^XyF&LSZ7zd9o=<*!-*|Gg@dawS;I8o2|FXM>GOUzb@<)+U!4}tg)P5_V^cHvE zt{5!wIEyU=d4w}YZSzi;{&gh^Oi7DQ28X_6v1oWe(r zw?kdQGm(Rl;E|`N&|h*IMOg%d5@2C020{*q4QOiO4j!9s8$60j(@Iw`5ld|C{YkIARack(wo}&3rnQsF0I;R~>y3yGQu6jx_G5 zRePI-xb5ta4&3HKuF-XXKb&<_3h%_DgjzD~W#Vu-|47;onJ${t_WF#EI#%a?je^Nc zxXw5&4Rd>-7vn0$!C!iJ)_k_`zO~*l3r)KrgQ)XQa+xBFQzKlHmg5lf`qy&xOfE&r zU}b}-fwiexR2zLG0?tvi zP22*b+9MgGR3l5q-=i*=D7b8Htc!mJI)u!}SzVVle#>$BL0FNhL7HH`Fq+jlqist+ zB0wlc=XesCR=*W^9t>J@QKe&g+Ocw={+4*2vnoggVLt>#Ju=3)yw9+E)L)%%jyF$t zNKYK``WKToym?Me=+|?T2B`~cNeS~jGmmf(4rO}hyvNLr(0as78Z!DK=B3ReVErU0 zSzMqky#np0wk&P7>WpVc=;NP%xNbgNYsWvu2{Owo1|F$ z*YqIeU0(jJF{OwHvUmYLFueTgD;jhHU$2i>k6G2~<0Un@a3pPV1k~zJ&5?Ar-+3OS z5*iov!71o+*K%>kHNVQjcPV~VibQJ^+to=}pvjt#TU2@$@J5PcYXo^kl)3&yDtL$FDE)ef^DA%3DO~l-P4k#D%c@+qg&nGLD|S z?hns{e4)l&U(KS_N$We-nXW={go?cQ=AzVUQyWU$$NoaCearFG4jo%9hf!Z!rkby! z48iCjW7^$~F8<}#j|tjYM%O!y%N-S(qjR2lm^{x8Z${jSc~XFQ8@E^?*|#t8uS`s+ z!;{ybZWT!5!1q@(;ZMU-2ZjuXz{m zb(6@Nx{i*{5#-v;c{0ewdH)RCzjv!Plfy|g8X6j5=!$}u0}yJzJV7s41qFrjV<13N zA;2Uj8WMJu%K_**+t-E4^j>oWp~Rn+av|^j8HL2s!urL5%6-XmKO%`{*bx9AOi?RG z`uDQ|2b%4tT{`utRQ*%+7L$py(11UQfdBQ+MR>oz-s^Cm)m={{(I}nG$%R4#7U>Wm zAMnq}Y9Vy!U~_n$kO-B}rs{_R*kZ%*{`;E%g;mn`hoLNoF1~XHd{lrTCHeoJ%3t1G zR-?YXjID#^#+47WxsF%E21^dzud;eb0A(4^a-_wU|236|9j7Z8O(eyCCPAo~xP?HT z?e}!Zv~VV9`nza2Nji?8@tc!Ed#KRs&CK)d@y7CUNy(s1)#G@bncRxb>60@A9q)6k zvjGPGL?-9t=C+5>2o!^10G3JrnV*&nJCPI7VDxa(7GB-VvMH~k;MRc9{c^o1q$R}v zHCEuv(xdWN0%W#(Selnw#3PP?gM&j&4-KG8)G7OSrhu#{-dL74%RU93-R?Bm#H~fs zv*Nn*u4nh-d7=>+UNfHa0g?@vj6Wb3x z-*GM-`&OyCmkNVd2=Hou-8;|IYqyf4R4GqiPmfsqw<-JW?Jarm(b3V<(~~?6mN*?F z<8vIb$Exut(}wSTXY+dI#-Bg&#H|qQ(?4f70s;c|j4{aKxE?Ow&S@Cv)tP>=hf=|Y zNXkL<9jd%;*89BkeUPx)B5&O$YJJ#QLZV-erE~V@)!WJ~=}oy9(#KEf0v`6Ns;cX! zB{PSRyFAsf=Xf}GnueS@R?gbZGN)N4GgD4v5VmIW-p1y2?6@o@Dv)rQ81^7A(oBra z{}B*33nK@Slc4!Yda6y>38(4bqAybBytzJC5hqs=sdmjM3WT8Re|vj8u~Q9274jNM zrY8?>b=mm#;-Hi*=%vN^ilHm^F5n%epLzPc?y-o>?0G;_Fms_*}L z3s3BG@sGmi3Hw4;b?FYCUyJuI{~}Z^iHmjch&tV zvsT^C+Wk5`qg)7jD)Z~Z-HJo|^@M=NCxhId#KJzN^=}#SdsXe{en;h{e|Z(PV+GzG z(ED=R&l8Gx{_?)P#&mZ>Sl>7N-(S)DlId0TbA+DPz0XG{Q0rU|hnm;Djw_qjms{o1 zNM9d@zHIkNMV)o+=R)=-lP9n7!-de@Dy2j3xPABZ?5yj4jt687IXpG>{~2!=5@`GC z-%e_WDo;nD0a+{@|FK%-ebE)!Y?S?yc*-QC-h9%DJrpZRl0gnb4e zggEc}^Ewt?55@>aU&a%QLdAlF=U%jURxhFqUMPZDou-R|(D>YDe22G~$bM|!(7O*|@o}0Sh`2>TSlT?@@a@55<6#eCn*6)AC-a0h>&b)tR;t)o5CF=^|9j5WRQ*od=MH1- zcMm3UdIp3~mRo%W`hJf#)vt^>iec#1*48wNncp5Tq;sf`-Ju_Tck=NYo8!_sBgP-8sZ2}L`r#Yw$tnu6Wxg+{=(0b ztB6nm?ri_@jIB|HWj}aoi_D!QBqZ*(a5VJ!oCm_)V`^Lvr&q&Rx^AX}&;-BrMbJ{A zwY#4-O?Ew>)Sn9v5&OS{Z}lG^AM3=%=lGfQ2Er~4-ftMRcHDv+BhZ9j@?*SGnOJlo z5G7{w|ClHPh~|s<`>gAf1*5-RUGx*zP8CSRO_cED`ra)O`n^Aw&y-aC;@uEFUKt|x zJ~?gPxU2Smt*EVKvs$%V&_ffv=;?s;=f1z17C3D9Ee-m;K5^+F0g{9N<7hG%ve(mJ zM^2(>lc0E-o(O+Cv;hbtviUISr`Pp3&$Y1GlgrFMR>^cEX4pShaDUGK_Hd@u<6QsW_5EW& zqCNBq1k8v0GuN72rgE*-g6(?<@ub9%hQHAfi~MUyc{l4VZpmBUtU>w{lB&NEvC4b< zdv5poP*Gpw zr{EV1?>{Fqnk3ocr@K>ch*2?LfslCQ(5sg0_{u`eHML0hPV>SWcVwacTH859AC^E^ zw2Ijf(Kl{T0}OLo|05(%D~?V!$kuC=aqzjBl4c?l8C&3WTb?z5kba?{pbYoNiRfQl z%P~LRX>IsHtPo;!ljC?QB%*n=F?e1+(J<%X;xZ#FmCtYE&f$0Sf|$=VCLQga`lf@mcAfjPL;0su|L&ZecW3}N6yaubGO@7GgF*G=|Hs~Y zKt+{x-J;dnDmF?G1(npGhysEN0umJoq5>ikB&vW&&NGofn~%6Vz64#45=Psx0*+d@YWh=-5g9{v48{j~)jNBHgYH;*HpygKqHe7b^$++PZB z_UJ)+@50VRnrd3DNhD?+L3~m)`F!M$OZmGA@H5MmKbwvC|Jd6~nhVgL zw=y#RF%<$k8_3yp?W&MD6wX5HE)&Pox5D8#Q7YHeJFVOk( zTK=a_@b6vD|KU%wb6EqYtWJ6@-8Ml+UnPaqq!+0CJt+Tu&kiE>qSx-|K6YdWb^cretsU&16rCUgmEd92Eg6Sy}jnYg!d^6FwHSxXpRXo*rd- ztFe0nq0Sf-tGn6E1-+OpR2~s$Pw+X^_j7;e-}q2pUr&SpbzzzY%3tfkMVuW-#$5@c z1VNw_TO$039L`~}KVn+H)#gBwTuVLVO-4wcHmFA|rVf`@t~^ccHZDSiMvgQNnpE4^ z4x8&i+r39k!m>090ZRicSv-w8wW2;2 zRcKuBJ2LMZ8hIYrEAZfO4y4`7`u;E4vcg;4Wh*7D`l)FdLfG<+z-ifN0Ywldl$Dd8 zrgODlz8(@1!sHI@08q||w4<)BgtfJ`goFeM6ckxd&CShlk?69OO2BJY=uVcR54j9|KtJ939j=o zlw}Y$xPFVSE`bjKJ`6<6V&w3r%YZlxv!}BhaLcy2^8RwC&-cF`AmaGxP&JXg)o)Yd zc}NjK^ND3>wR)b3Lek?M+$bSN#(S^Nbzj+f_B(9bFSZSoe{(8G?s5xcNh;P65%~PP zRcZL_5d`hszvm$`@Ki&sbdW8>t%PY}`)kde)>vp7%%hBfYLr^(TlfbW<1of~Ggtt?zmjsEzopZtq-K0htavuYF^}(MQz>X8Nc;#^jO3CB zdDVJax)_PD!)E_WPx{y2!#ifS0i^CM7vY_OZ(Vt}KPM$>vT+Rt)j_a-LG{dz!S9RS z2Vny1tlsRn%EyuOg76TN=XrXwGNvFcT-S)u;N;4FQ&^bcG|i_U#-%kfvb*6h@xF?M z)L&@#jfRFs?r_mc;i9e?;#2-#l9xi@c=-N9+6#WnowV`mNx;Z9MxtUh(4$pa=rjmK z*B!8$1I8nfhVrgIu!nMK6`Q@x9nO==-V)?TJUMfK5sY%Fxw0+@8+3!h<+&6*tI4K~ zJRiw%Ru)iPlqhf~l}e`pDN-7fk~(T8ccd$RLr!?>nN82E2)1NteQ#&OGPWn)(O-v2 z@YsWZryb4NGd2L7TQUnDhSG3p7Hb|qfq2+*AVVc_G?|?Z_q;?q`6j7tQ*xq-HRb`e zq(6hOQ-6+*Jr-rlDC**rD`YxSzOylUiYY@yJ~E%qtojEg_h)PcLs?}7hFX3X93JPI z)tqE~rl@qKWu*c);&6cuarOGa6rd`yGjD5(mnsS!Z#2ZPOC&$3Rw>3>)WF2`xqS29l6~) zFT15#HLSOKa4S`==s|5i;h7Ofw6j5T@FT8$iOyWJjyUDn)@u%{bxmSeG%6d|ERpQg zm7hHvT6Tent2=pUW7zYg{Mp!utP~o|Rlcg{>+9R}4KU+tpOK1|=H@_8qO$ajTsVqj z)Ry4fB=-FI^U+FY?0{`-XuR-dSk+}x$EA{n)tBFnlhK8j0rjZB4mh@teH|Ez-y5Ha z4BCEh(+%mOiz&C?5F-JoeNn`yzy0%lpMiUb7vKJhyQI<{lOf8Q*M>7S=6!2{V)8m| zufp?Zd3bm(UpJ?#+L?)*{4Rn6H6RytMJB?kf! z+;cm@rB-T$9xiFhRJ7>n?bS4|J4d|FBbh?`t=yu!9sZ&lAL-fHo3$MGw~RCs8o%Br z=}MA`*uGCAUiM-^ zM-rcba(5^w^`E}|#R>1ErKaA&!b1v#XQQ6dbQW@v;a(B(qCnJzKXh$Kkq=vmlc(CD zH(oEBjNVmRrs2DO#^2QTA1F$o)CKkv3;*R0CIdBr+CLjfJk9~Z`TyVkyKn!;`=t4i z26Spp>hq_0#rGRlI`Wh~{j&diwc~<{*$Dlpcm8I&2N*8e$m| zIe+Y5f>67lAR68 zfn0JIQ*B}vY5!w!U0vM}MdC}N3_CYmFeFHD;SQ1wD@{Aisz_vl#MfJ2F{Gy2m3iOk zme9T|l^9t*X;TF4lPFofo-AUMo+&=mD3JQ%t3?37$(VS$BOQT8@vja7;~AjQXlMb&TMDIUzd(hq*9UMOK_Y+l z9fg?JBlQ#256xAa4F)+5q6q>K9R8<10DJJh|Em%I<=d+#dCkVE<>RHuFY=^xzk`Zg z&|jSNw}u~1(5>zu87p=n#&4hn^Yq$WUe=QWW*(T)0x|aM3HnX{iGRzKOcq@XQxAlFyIAI0YewyWp1j-n4&mTq#=t#nyE?1oYWa92)Df#50u`riE_5 z1+tJMP$l(MxT4Z?h!>W>%NH4X!VZ{)_O-BX4s`ok&z}O{KcZl_mWouLTqO1N-8qo1 zks?A%Ip18cWs9XY%NRFCC&HqZ=ymrTou)t#S*bc!8EIVje$oy! z+!EjYT`bp)832MX5O**`nSLh`?MZ)CF|YP2$O&85g(!Pa_zA72KsxfIs9f_kZ4JL^ z2{VnpP?8iqd#v#Zj#>^oz*&b!`& z+S`z;10?;}-R|m<3P{s8{mIiO>s>Kl<%vO-Mm?d|PPcF@aYjJzD~zcuM}&Rb#8!jk?X_C+Wx|M>P~WJCnmu%N6YMp87q-jG0;V7dK> zx^EMWGOP`g9I?it27Z!q*?Cmqh;>+SO}6ScJdSWWa*!goFF!9dnm@tlL?L#b->mEi zD#jJPqqV=FoE&A*tRN>d01|u9X8r9x^}Id`5 zQj8fiv;{r@HH>AT^khs<)9lF{YNby8!Zua&^^syk21Shs4jq)hXHvSB zMC>u>1|m!fmQ4oMG6lt00}~dgRK)Pi1N5rgYBL>iMhXM+W>_5%ao)Xb2;%(EK6Xgd z-3-`a#!A>vi0#V+V?w`|SW|BB%T6@a8OM)gHt{P`B%7wA2+8Ho6HSTZ4v#pP0IP z`rbk9CX_=ppZ~(k+SPF;_mA9qMB&k#&XWRAV)2kk8L{!F7;jGayY6WhhBNNZH3VIe zc^on7D*tWi&VANS@J%TWbIS3eX;kmi%6gBI*EozIa zaG)w9(0OmXX@}m6aYWmHJto@5%iG=ONg*O^hoh)T7THRrsL3ZphH6C0CTCafE*!ai zYQzP8lTW}^U9JcS7qA{wuC!>zxSg2BI03WL4Wp%{WrX?}OyeydExOPj`8`fU2Ne@4 zap3Cu8hsqWYknaAvP%B}!S9opw#8~qDFos|o;`c^;ew?@o+8T8ij>Kyphtz?S34W)=z`zdIeLPOj(5pt zdU~449dwD-2;s7A8K_kz{2kVmbakhX&1zAIspP!)`iQIY*;F3LVYFg%qgA7McR&{7 zfocJbmcupo)fu&o`y}^0$z&3hv;^)<2P^mqqx*a7qj2@KOzxn?2o{;IRA5drfn`Gz z?X0L;3jF#$3DAh8_pDLp#fotzU8Xtjad`V#nHV1P?bVlwoI1ioKVlYPc7caM98E|| z7Yr#)34t-YVu`$iV`q&mXW}b8Nv9yv(Rv`^m#3wrIbzZ0#EABe-l&h8vC z)?q>UJ_)(#=96&;q7Vg=1`Z^P$0STaO~baM&dc`FV^m2}SaiJX?o;UF;S$TB(D84c z&JH*^QGD$vQJFI;Leg7L!T8=6S4lx*!YWH zAKBK157&szkg*sEROYQmA~$%esnr;|R-Cbdii*(-3kKOcZ3P1++6_@7>B=j+yQS&b zJ2GYUAbrh7JDQM;@6u)wwkHz}QOPo+_+GyBv^10LeVLXpF10estLF~b^kh$!YZW9J zUc+*T4*0#<8NU11#+s@`@8~uM6ZVhqQ2!aBjWt_sREJ+*kXg@Vk4K z$dv-Drsz(S9OS0Fv^20eE54&3S~2tqe2|09#%m~Q+CNKG0juN^BGk}SZoebWkoT;3 zo2dY){jn3G+uxt-DLzxWg1v7K#X-~ZwfdT^R(QNMq_VP=FH$7qA5#^Gh0qD?F%fg3 zj0(4{WMk&FXp0mBKGu`L;f=lhbCb8)U|69SUP$<1XiIRhOfM{@6Qf_E6)RpCsfK+fOzz3C_A`)J$(f8q?N)88ER{%J zf;4MLIkvrUjn$I^Z#5MA(~tavOI=Bnmpn`hrb8`fzn87xaeXE~KCC;a=JZaVYHHUt)h$6fcZSWDn{;k5xkE-XTgXps@|73aoBO8I z%8lHsm*GRHgJ=qHz~0_oL7@xGEORuKX0M3C$jbq^u!1&Qro|D(Jd@!?{57Km4{{vX zQ$`$pN`Ir1kUtTYHEt#{t4s>FcQY7%~( znm_51l%GmLj(MGWf9*lK?LRLQ!2_V>c8kt6sy)CG06RT^wMY|pzYm*Ix zB|TBv8!ukm*WPzrsSJ}%wiL`zsoVqS#7+mfYca~^=*7s3BY5nPwECqr$Q)6d(?Jow z1MThL@=h`QU4LZ_A~B;*OpyIgjz_rNwl@)G3PR1Ntd)mi*Lj%$B=l7-Q=oRcLpY@e-@ z)^fJ8qjy<^u)%MS@w7|@>;5>J>w!bhGcIUMHIkhS?Dv+Pnx9gEqz8Z1Y&0Kw%#G|};#25|bL^VY8`-1kxFJ{B*qCJnB_&Lzsf#w` zbTy+6LHE_QhDVGb@o3=}yqEU)M)$$DqI%mFMnvhNsY=e+e!QQML6tK$H7yNrOeB6* zu85{2^A#q&%^|CDy}1H2IN8QG8!LkOaM_wtqQf++(gM`3?95EuUb}XnNvz;Pqp2%S zZHSy9N=O}2O+nSZ2FB*RAo;-j?x=>cV$b}fe;B}Hy`6R4zJ2sA%qnsQ9)5STmdqmj zt~W@qo^(#D5>zgjLGY+-PxxGtI<vTR8C|%J}#K9tKJavLi2~M8|Xi_HdBn#nzrtPmPON*yzR^- z3Aq0I1zXI`hEvM}@lqt8UpECxG3+d6XBXf4D4y0RvbZKJS@UOLK=1<8t0xvnq!{d< zk&OE_xpG?HY5xWCAH8F1J4Fp7l%bJX8}#sW{U`z5exFP_@hRxwM9D3AVF8H5Us zAu-@m9xAJ3H;udAZ{U^BNI`)$NQ=-ZxX#9aqLK9muu~^|8*yCj;cl4q7g$(e&lUm* zy$jt8_&mufY1{Z*o|bX%#?&Zb1l|$G^zS>4?wfS3_bAAU0E=?KEZOg$=DU2ofzERC zToqn1@Hm)|PBFm&X5&uMxS&%m1(E4aPYXL@GP2OYtv>CEkNQ?(Z8ZZyb$43x(Rxh1 zYt*IZbKQY4hv1_3fxZi1xlYPgx8sDhnaJZV1~1CUq#|*OAFKpWaQ;buVa}qp{z<>( zfxOu$*EZ?b5({7+h=uq$e80CqEvz6#Pne;LqUMsn&_yvQ9My(N`8A5P8f@4tR}N)? zU1B1N|b>Bz#2WZauQTL3J4m_fa&jRpdb-()miyCFz+*P>Hz z>Emes%3CDbwpuS)&XvH@Aif)kj_J z=RQ-^D9hd10ob(HswWb3`3`=){XTZsQL9t041ZLNgd1#SJD(etDpv6ERTd9#v5ND4 z4A`0ul8lCuV9+!H-?Y;}XDfCkXdXuDEx!A`u_lprV_!Ydd80pw;#W2R4=cii)FP;^ zHN=JQv(?`x7p4>A-yS+ z0S^vRxXUXgeKC;N22yXIF=ohKbg^~Lm5LQ~c+o9&lR&}c;e5~*r0+NAeJnqp1{|GoFW%=>j6F8mBNyiTye?pbFr)Qhlv*~WUsFoEx zy|d;|DC;h`+W^wH3duMg$N1oi@|!Ri2(a9M-vtv(cpOvt;_I)LNE|*OR#3pv(1R-~ zw!zxtzzeYYj-qDL)p5eVXgH!tM~nn3x>^kh6OQHejlezM1*}$0O<7GX?0dp}5=aA1 zI|=fx+mqLUOmuhacLfIc3@F{iDLw|`c9Mp$m$_pqA#b>UGp8wDp@m4-E|1 zU0PEe+^LH~H((NsIPQ<(Mv=UjX=~s3bWOCdI<~unpRa z7sW`nPP1oYS#7gZveQYK#N~sRF?bMxkPZMt$pu!cuNU>lm6w-8KdhwZ+u(YV;Bt|zQ&G*b3Skk?hf>f~B^Un|D#A*lLSN%B@HF<=+*&)*^l#!zIeQlD@ zxpB-zH|04MA_EaxyXv zE9&Q(OZ#xhN?wxhe$rCzJ&NG*;-7vx`^@Dh@8UY=ufoMY%_(N%yx+R9Xm%XQ)!;by zWZ-AxYiEBl?v#$mmv(WbYhBKy=nOQwS{_5rAQHH;6SHFP8f0m(<-|YgVSZZT@~vCz zNnhrB$m9t~34yexwl-ni$qW9|$nrg8o@F1}H`4 zQ#=reMn|M)QwMNS6K1p3TACk9)T(D|_DD`==1Q;Cx#IJz268cBnuAa|OGv2oqZceJ zPmn0e&mUs_5PNguHf0kMDfi$(xbW=cZNt82g6<8IcXV^Qcw%={@U1NbA$mdUCAjAG zQrndg_WOZYd0L%x-*yd@|!Gug~yqQT6TMHpGSMc ziPW(h^LxcEZf&o9K763#fAgZGVp!+afKef1pJ__R&n`138*Np4szjr#n=zkUw0eGA zD7$(!hu7#l4FjcofxNxilNVc6$ZI_lbZ#`q{&24SE+`yHm5UX*d9$OgjwQYKSydYc zb6s5`b7xu)iz01EQS%kbo99oVIy-w!`*U`ZV|fXiL7m$Rtrw1RF}7zJ3r-uqRd7sr?NMWEEl`KC?)Pb zJ;Ojr`AFQoNvB!R=JB1qNA1()<2@ce0vV`*j9$D}(?nTSDMN*c8HO!*AQB|wDFdJmUb){J=`XV0K6Qd| zQ#4bwVO>wtWyT)!QSTz}hrFR>+fhftH-C{Ci;{_n2~Yr@o1W19#lJgPCsT=?`7~`k ziYIB;;R4>ruzd`3a?)BL+G`Wtldgx1VV=m;Uv0QB+jIT;vgb;#OP&?Ba*QiO7uRMj$+~S9$O%>1&CT3l zY1?RpcuNruj(nH>oHW-{u32jN23r>?OCX_3`d_?2t)wM>TvKEWj2x5!J%+uzqf+J= zm|k{A{_e)NZ{PdA2SMB4i$k+~JD8r=sQ*QQYJ6NAgX89S1A}w_yag2Lv^LbP0*{0`j#yR62#oFzCkq$!V z@0Ikr^%!i4_>NWBj-uNu-MqpdOHzK^8`}>;M_pxJ>~+R9YWwfFa=6Y+%f)oWOOl;8 z`{-3JM@b^W~;%(wl5K6O;KR+X=)iA4H;kC8HEF3OHKvNoC# zYazMR4W4l%M_*VAYwRkPe*SguGuA?!Q zH&~f&-V?VVo7uzTFlq9Uw+%7#4VEE&$K5o=OKs+J?I)Y^CVJPX3Qb4R$XPmweT;g0 zmEc3^*+-fPc%th(l%Pw;pA=GwZs-)G5x-c%6G(yawh za4y@G0mo)CGEeQLwn>}ik;yeXaq;*LJE0h;(|st}pz`z~y}DNs#xnkrkV(#oH+)Xm0@5MC_y8Z+OT|1KCDIZCkG znJzHw^Y$vytSBz#S9>`=<;nPw8%w3z7GP0^dd>b!M1ay=Me+;-`>vAC5JM{~^}tK|_95kaZ|}5>4E0Ko`f5(Z&_p9p_6`rc+qoy~+SWwuNOba(JGD$8sV*Mspe8-$ci8`lpLEn|2)ZE;s_Vi|W zr|-Y)$|C2MsW1JaX zx6da_Zv6CsA+qgt-mwg?_IWFl(aQbSeW&%C*=g9V^h%7#QD3liUdODZG(`FhHvlnS$( zfXJbNa(MKRO5%s3mfnKv0r9rfkM&QVAo0%;h?EaU{%~dg@gpMSzc{bt4~MVwZS&#Y z0z3PK!*BI!qrdBv00#?4C9nHdT!f1o+% zE1S#>rLmw?7d!Ea-It!0xx<{w*N>;UDO**~XiDk#9Gb9W9-7BIVaCrEC0me(prA}O6M!aoxxZ60 zC^glnibK9eTmOUi)Ee>ncy-A);FCnmUMg@(Pp@YLkdAq0Z4EDS{-aZ5O(`hDS`uw2 z5QIeaz~<@amuRZbX)KoXX&fG`6uy#|n3)+uED_s`3_B~+&yUj7p3`Xgmrwn_Dz^RC zL;8PXVEy+`zWGNsGW&duE&rJH9?2t}Ck?Cz802tj0bugAF*Y)Ye)T3qmnVH|KOP#K z|K@p9QWcW@E=is$QsIEflr}jf6!zzJ{1LU@lBy3C8t-l`50zTOqrtt5tMG-e9fDS& z(KUdug_^=f{a%#c)Obws6OX#O+ur+7u+Hwd9Ukr^aZu9};@SBjS~j`dcog5MX2ReI ziwisEwMl)v%TcEs&?6J-aN_J7_dk|Y{(j~kTXLB0GdNFyb4>Zki+!wT9)7ELsA?~_ zZrP@xp#j#i=3?vbn4!%rVoVRuleeGR-|$eGFmf>uJRi6um0X2E_Kn(OE6j^VFbjr+ zvjHah`bSS_Y8ul3HVY3<5#2vZ{_0g6ti+z0{8T9@E+xfsg=M#xkCB$DD@Fc3wQy>q*BIM9xOG3YrfY}@F*-PHI;cC$v4v2(y~#A zjNvZ2=T^M$x}^2xRbtW2npgHKsG>3}w9$?8Z0zhb94h>iJ$+HK$+?Q@J$_Zoy-;$m zudnrbAT8bGeU6>5)@)UVLhE@#`DfI6HX2j|=BKdMdT6Ce6t_nT?HfU@6g$`W@(q8o zy2{20OS`l6DtF~f5$Z1ttSppzGW5GxlV$b$vNAQZZOc%O*k#x8I+`M5oZ>)Q-y*B1 z9YJ@0x2~bV=YfPoUEc+$beF3>Q_rxnd$T@em|eoAJ>MBG>6x#lYGBqWoeQ}F&d|bP;3pgXMOAY-!oZY9Si_uYgJRc|4V6l5^M6S^{EqW zGrs}y?<21o?<9-%&~TQ4)5|71PK`G~8WdM8sDy@>uTDJDDBC)3H9e-=Qb`$5>5P+f z_f)1`0OinevaJXm&OZ;1k5j|>3%rLj!OvGO^1S((S>l}p-byp?wFV$%&M?EtBpJdE z@(ksBAHx?n&WleiqLbK} z?7gn$d8)!-BHH#EX@0$9s^FWx>A5NTSng%P~+9oW^l8J%zhc07YT#F^?0 zRXUk91eKvH!}t;0O7>{Zy*txCAEq&gdlP2CK3=lP8_9V+s$Jbsw3!l6ieiGz~) z6-;gnmEO|WnjJ&b-jlo}8BpVglVldzPn^Ehmu@?hS>&=iQ2y%?!+ZDcy?Qzk_Nely zl16H?yr$-ceLPu8UDNXy*C`-G2#;glhh#MysFBk(8bw5;Ju?LgyhyAEfGOwO^R;X~ z{DoF~^(X%zac@bxdbM1wOVm{}F@n+k0-uce!PiltR6%-i%fn zXnSJl#V@ntK7ov_eIoBp!lSV7IKsB}$lfu9SSN?E5H}4@@Lw$U6=i$r(6>?t)cevJ z59IdXSZmJ)QZQC&&t?rG8E3z!Mnydz7$A!HD25`e(7+dMJ*)}J!qSqIlvL1qA)#+k zgR>8c)HsabN|t(o11zuv;y>J$=JyYt_A4_VA9nG>Daw-RnMiaAE^Br5hGm5V7~l40 zTQAHwY_UasZ$0`E{~_V6W4ZE|Oeq3F*p*|xxHaiSa6dzJ zXr+dDOpL(o+boLW%r)P%9L9G9Sx469Ss8sA-{;<w^IQyB_kkd2 zIpg9~PsSOxxV@%L46;{*_v>j*a#S-xfM*U2i7t5Erb@Yk#xc5VuQiNRILMS*PPFm) zQU>g9eG}J#tsU5vGAIJlJx}}i`FZ>K8T6!0_ht?`U>8DyL9z+kS}d|&EDR0~h8WCj zvD~9vg~gxv0skW<4?ZfYuttpX0thqEXW8e4rlv1&>p8EwJhkYg@u8ts$?TAqf9PCa zHR7NqUT8G5V8;LWN*CC9jERZQ@!7NBTQjVdvqBrg8$Q&|Sv5k7WDkk!DgJ!@tYTs5 zKYYWYdwrUHiB)TA#zhI2-RB) z1@qdb7X06bKZ9{2#&IQ<8ylqE;7@z%xan4Xkeu+OMM*GfrHt?uIn!p#Pq($`*^|wv zq^g<=YCU8~Hcn2;fTbum<_U`uGDZOo<`b4=Y_O(O*Qc=~-u~e!-D}j{=b-fj*oFrD z>@<{~-{e(QORZaa0bPYghh+8`XluXXx!4AGOVe&G5i$b@vy>m5^Q-3W8t5^gdM{tT zd{nu+3wzWEJ8kC>#XX6HY6D>`cP2YeK*yJR!grq+1@8DMH$w5CRrAOS^QR*w`xZZ>+DE7tlX+jFtI0@ee~xpSj2&Hx7}VS#%E{jLRZBmoq@?iwcA;^?!{@}| z!~BPYt)_9`4!ZvLeE|;Z7ypeQ_P>`uK}nU^(lIfrm+wz4Y)iZ={NyM1uj1^VxBb^> zM)>HH)&B`9g!o@7to@rj?7uiUpgJ!vFUe^-1m05;?`Yp!eau{<&*EPxzv6QyW`Stg z<)0DwMG#Q;Y!fpJ;Yv^g*023p07GW*(!5Z)Aq0sdH10= zsYI>LtqZ5DxBa-xm~Q?d-jxd(CS+-K=y799eGcQ4r{h+k)HLrOyxD)^_CH+z8s8Y%&cfK|dAuA82`B z$B0_q-r(tHC$i_>wpI9brqdHg#UHO~`>)FujNhAb#p~VQc}6~F?c+jx3Jsi?5c^#Q zLZPj9y+uHzkUuPC@HZ`6Jm1)O=xzLRoH}nHql=a&Vq-6R=_t)v|Axu5jGUommb!O( zRSpkOrEy0Ev87&z+ewJ8na`hLR1iG&wi@IV_J81y{~IFm|3h;|;n^F~g>A~v#{Xo_ z1c>sn3XW+*oc)wFdGb)r{NEIj|AVn!aaj0_(mExntx{ZP#Jjk8+*dN*h7Lh<>`+&q zlT98pe|GoKuy`AkFJP>r^LT%i1f=ESxi>r)E54q8eZ%9O6llT&Mmr{9YRgY%gRk5Y z;7vL4;Gr=mGtOp(WI_I5V7!g9Z{cMQbbg`r#Qzn~yC1EclH-L^CXe#7WXkqkW_q69 z2Ai|Hh$K)TcPiPo>S9@r6 z6Lm3Ex}3@^J+z4LO#Us3`l9kmN~%|wRWp0fT!^4O&Km<*;_fJx=ArUBgp0pn% z3nrrk50Ba3a#l$w&H3qwUG*HHzQh&<&mCi8h5=lV_s>sK_U_(&AdBR?}kt074IyguuHXfE_h6QJF12RjZ;^s%$xDsh1|&M_8U5x3J_ zx5quhfKz~AKrV_87jekSLr*vDa( z4W?kWklgsYN!2?o25qi8(_wNYAWXdZR(~3Qs`Jymqi$c#U{MF7^TcFi@KDPJ=}-95 zCLJE$_j3F;ODa&kp10wPY&%VRTfkw;3uS`kt*@;;?^{1SJgk6zb?YK+LjxnQGM5Q= z(LA`S+4uTgNyoHR{yy#9XjpY#`<`lLDB78Y&=)90%$J7ZCNHcS2e{VJ5#I5^bH z?bcus%bb~j#N{hjUiYN+FyAul^(4|se^X}Wk0;24ZtQ%$US%XNIX6;)tH7fA0EGYc z8wF)kYpc`vI~wqGd^XzhTkTPP1ltrC^IVLUokdpdIbjpZI!kRMdFHchjE4+(B0%7I z-@vF=XjH}&Q9EyS@zimjIt$nkOtW)65G)NoUP|e{-ri>e znu1szg&1_hg1fuP3Bu`M@nK=9Tjr|RjDMcD@Xo{G#A9h`SY2S7#ptqMm^qZ@X9kM^ zuU>*K2G{Fr4vmZF=#6h(45^5VkAtOPZTO?RvvjTCS}`8tgq0h414~5t$iHRUpsRGN z<`}8zMaM4xMb}f`rJ$O8gcx-mTrzay;XD{I)dPlu`Oh78!_!=|s?Y+iHcP#kkxwhu zK#|k3Xkw9;mgcJ5j`P}tHMx!LOp1;sBjqJ(MJBKUXSc5k&%!J(A8_B}6m~ zL$*tEur-5$!2+zt0ohbDy9#aEbJS?K_zNr`h21w)ip@TI@fdVBsy?})vpS}fsVWEC z!iay6jJM6Ml8b)D8=04z3!Cx)d+E;B8WqL&XZJ0}IxR^1N?L|8(g5fyJ7ja<&z6bA zJnboJ@S|7TtE15yUWCi03TTVugKpK(w})M6O{*sT!sq5-&&%s-rL997O{sDW!Vb^G zU&HP#Cd1c1f8K(bEDozmS$co{Rin)2oJuD1IxGmxR4YPzvu8b!mCdrrNRD;bg|avE z`a(K4tT8%H`4RT{@rxFe(7`MXOxB}1^Y!y;YsEon@>v{+PxcbR_fHZRHwC~lD8!N5-lJdM@`W*W=>iUIAJU(-LVn5-H(m0cF#{Y9$~l@C+3d(3ty+p59(cYWqLT zj!=@(3pmZSk8f{ZQA#g(IOYqxD5UFUu`;J#OMN&Q;+9?RG6sSISm0;)c@L@CT_BMlzR5n&9 zL7|Z(a>Dyo4-L|~=GF7xjGI;&BU@S`VZ%<1uF@FAw7p5@37fJmsbu9+wsd0w^|;Y<{;%K z(|Ha3m2T}gJo4g7kbY-^^u{c*NYz-6o8OFSz9&yFzTP*jP)A3ne|Z{~1CLD~

B+ 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 z zIT2k~_=3d=l=o(mJM;?b0!1huAAZExrrG#T5jL#6pNzs({*?j!sYHVMyhg((gcc+W z{q*SVe=#$BBR;NK5{ zNDxxQx-t~AkzfdQ`g{1kNACPYwNu&mmP(APu|A@F^`#RslWMKKz+kQWAvsNah{}8$ z7t3SWGcP|#j}z}>6kz$Q9RV=b4zYg$2FRQtEcUvM%GN6H<5(BJki?Ut_>^!tynz*u zs#pIAzTewX)E%0A_-LLH zG39u*Bf!Ami8gO!DbkdB>AFfB&F?uFEnBxQ2EW#0G;_BPpjNr>PXiTWliMilFk^*u zwzVbKacr^a*(HU;s!}b4W<<^~B#VJBBq@(bL zd?TMQVe=);x*3uJRcX1mgqKNZ-{S__W_B*+!eE-L2~k2ex~fECmO)!6^!h}Rb~?nc ztC$Wii)!+s&Wa-^kjRvmu9<3w)k_9rwVx|hFcQOgoQ@Y8x#oT)b!IP{wHItsh8bgN z#bR;ArmI7nZpPJYWiR22Z*hfTOCfJ7IJ9kUoS*?>o)mC!P$6!~wl@`?sAfYTx!l#} z^{b2x%+<#{G_k;-2iF?KMLK^GOrgY=R2==9UO$|HdlF^bQx<58SaweYA1tF`d- zU(G+C1UK)P`9L&6y_>xGMdFR$;B=kXSQK(0eS>IxdyQQ_Yw;zSTGm!khjCa{Ohyp| zr^|#D8TRFJVIKIeWQ}0k#zO<&98Jf(D-3dR}z2r3&OZ)t^DQe){+ZBog zIK=t)=XgHdua2Vt4%FJWK!+VbI=0*dBOT=jaLFcrUoRSJs;gh_&nHEMA>Zb#8s?>? z1zi5pTz1~c0TP{r>?S?dKrRA^_*u1UHou6YHJyeL!Xx9I%v;aog-gXBL6 z2!_9>P9*C~NHj9B2Nxut@J5+G*1$Q#aOBMBFcv1K91QQ*JGK;{9n3dqhWjmAY~9o# z)5F=$yx@3L$W%18P8DNIkhW#S`l&I143{1mN*)SHPPD_wP_3Di)0TTfIZn9%DG*=u zI47MK{?Tr)e#ywA!K~lr0Jv)dW+m{7y{*xPWk6~QuwZ9xxu}VjHW2a|v!l>yH|b5$ zjLQ@a=wz2Bt+kry0&-*qZW9AQb~-YGM)A`ckg69r?ZE_c%Q(od;{eXWl#*ycd!@tv zbcx!E|9ucTF2q{x40s|}JQfcF-~9$9DG5A3tfd(~NmJ|tEf;_kdA3tmr024GnysOw zJYZO}4hDO2AMY@W-X9!9`upE*r9GeLJp<`eTpS#SC-3uC@AC+&&Ih=iT+btiW>udI zzZR&^RfeVAllSnVqq6m0{SOjG&X+_IW>T)d>S!n!m)^T55q&vY^tmr=Hc{;fij1t- zB-WC|vKa|dV2yc# zeh1zdHD0ZX0=MThLpX&-vZxw))-lZ(XTnK+V>6j(MVStVDl!>SdHS~l0VjTD#6XPq z7cEItF&*~ahrxs9*-jaxLj*P%HM7+@d?|ho{m`P5eA=tI)VU1tF3x%z`<)XB>1e^U zj@XsVn*%#*m$AZp`fYd#iROc`u=ysmppg7NJJjJ^N}98ZwN|HuK$V0&iHy3*gn23G z{0HWW$iYboqFisP*0O^;L5s~QH|R!!P#4J5F)*U7gx#~)xd%RhMv=%x^Osk|oNEjh z4Tf5++xnXiR63;vtNlx*1LsgH-5N;)E^cAAfja4fNVpf!mpZn?HCjXYU9G`BZX!j> z*X{S7E5&q+JLKDBwlk@PkV599j}bCo*g~*URn6$lwdIofH;i#~ytp~56T_q#)oj(Q zsI_ZRIoQ1;28Pbwq&AB?IOL7-?+`VOr|z#Z8ET5Sc6zQ>>e+@Vh+B;0$--2~0iE}d zyKnBYzy-Pt3=F(>TB`+?@!*czW}q6Ptu5l?lg6Tth=d5N+P%a?RfpRLls{rsyvyxWtTxM_qX43_ueui*x@>yTUvQy`6 zcYt2)HuPI;=U0H$bp*6Ix>!WV)o-<%=h%t6e%c@fyhZg|ES4Q?8K9vY+s{qi%kxgG zgHIIo2p}D$?2<%@zW4nBgCp8S}5wg?bU1U8-vVbV%5^njGm6mjdXI!5@X{2v@4dWqUk&h zmLM`L>$8X2*nl#sTWTrigQ3MEe(LI*3^x6oU+ZQPZUr-B(GgH-;jH=#<=CIiMrwC5 zRg<+bkR};~$a){o*R)L3r2|+1DFbnRRmZQm>BL>;_=n$Aj#>{fBv_G0A>z`pq*4LQ z662IbD|3R>1h_m=5^{vBC4#?GAbxA~ffyq>-@4Ip`rX)w7WrIOmNt3&-8Eo*@GDZx zt--8i{q2WwqIW+{@1e6zKTNBvVQoTql7D7$Y11T4T13>TQl%GSh}l*Q{!~!?1hGgA zV?#Ex#e8?>RS=k@xb!>*yLO z%@G-viJn~?{@ppmURO-wX<+WHu6|nw2t;LkdwDRMmgZ<$)Vu0WxO{W75f27h0st)n zmai6%AyY~@e9k6!_fo=FH>OvHIz`qb?$at)edh9M7zxQPdx_MTGzw(-K(jk!0~Uv^9^`UJp{r~6S}cn)Ke>19@0+Urhu8n@+!VW3vY;dKJDBOMwV8gP4%eymwh z-@(kv>Up?W(C`2JX>$S&3HPX|zRQ5#^d%8b+=Ws$rZShUr!o~<9-UA!nWS-4pW6B- zxnz%5>sdC}RhUJNJ;#K+w=yGH$03y3K>H}_xQ#vt?eM&}Rp*(zSO_qMb)8Poxw)!eta;OcD6vJ`j1l{hKysQkO-)85$qZ>bs-E zVf6dQ4LL(GknQT|B(-{zoRT8R3;4R;9tAAd4?=+j09Tr{zdC`+3qtfi$yz zvmHP+{53Np0x+SDAFl%>+?MNRk%jM>Obn`w)|Q_efdYmLZw@x}y^ize?iBE9V}|5I zGebfNmnvI?gxN~$3FA`o7V~{?fE{OJJdaJ0< zSVa0>>OFm|OQyPX+fyeuxGh%_%yA^V#+Ix#EtC$4HP1zqkuYOZ$i=U%EYmnx7=9>t z)FXxW%j2ybaor>P(ADpu=|qL%h$U#~Wa$tF9SVfbkeCcAq*~kj(!xekG@B>KAXhhI zP>dQ@sJ_3QsMDF!4*HVii%OK%>YOt%;Bk)-E8)^LD=ugoC&OMV<(0cE!T8Au=4DXJEG`J};AQvL%a(af*y5Ys~dVZ!z63RE2V?uW4!9 zX;o#Ahwl2h>NkYUQcXNbROZzT%<9-4LZz**OWT+MzF(vER#{o*buq&JYSzK5Tt-m| zEH*aw1%K6WLb%(3R{CKzLHSqFkA~*-!%166rDR#Dh%>YI2lE@3H)n82^5F_o$t0}! zB*EQau@Elg)F>?^`a&ubNvgINH7~I^1`#ucY9c~-3e6GsszZbg>rd`{4GuA1bX3{I zAE{3s|4@6rzHEN>=dwM#s|fA2&$@J>uB{Z^AHTTMO##*fQ1|>pLwI^#X=nh%uN8nr z|7wMnv39Dtw*3MQSX(^#OgJxjjeL6f`k>xkmmeKYtaE++#QcG}cGGSNGKhUSFgl7U zHW%IM3t%_-R2Jd=25Isi2|v+9pS&*XX8Rn+fuiNm(0;&X0&SkJD%)GH^NNO!Y+=DW zYdWmv)1r=!lj8u<^AT6W(LA89R|CL}y9cV|tSt{wYD)aKM=eKs)n_fOtxE~G`d+u# z1*HsStQ`+%ZJ(|H*Qw4ULH0Q{$U2NP#hPAlI@Pn2bZ0k_!V1b;i7s~i@3t{g5E9y8 zZ8qJwd5X*|p03Dz!ifw;dh_xgOkDZjGN1eA@s%v`v05mCr*uG+*3<~BIzwlh3hP#5 zcJ}mfiI8(VRIt-Vtl3y<_V~xmgf2wwz~*&3!()eKo5w(uMaI%c6c40|l zB->(!_2D6%sr>^SLa#Y>GlO)}<piZC{;!qUEdqtxEUR2J2@X;Ste>nQ)T2NWK&+<30+ zd{F0@Q(Tw@^Ro*wLq4Udv$eBL^0RFU{oeEF!|td_hr@UK@2lwLWmjh2e*C#cbXMH3 zwq=aW!%TG6w1pp1OHwc-%(SW6RPmzVs;4ux3BukoX>nH5$i5!5TSLgOklFh>gM(gM zFO!ivGxECHNSt7jjd^Qu2*<3%s7?78Z^3c(Rddc`UOX<)7q$~wJLFdSMdteTeV*S@ zli+bh;oEP3gd=dwO|;&gv+z9!r7*T1%-2c-J#_PZyxX*IZ{a2i z&Bg_AJ)xAqpCAEp93Lfs3tUp1BVfM|;T+@Z_Li7!ALTag^1DCocm^1m z#+Rj}uTcnoJ`X%Owx8zZl-Yn&($dQ6o(>)3vjyDmzH|nY20#;{pO4YxQ<-9M0Qq#N zc_`4lpw@r+&OyH=CCxG5v`{l*ccPy}6yQ!P3$5J%yc~AdR9;(vo!zkX$!9nR(X1XB z$?1C^J}LduL?l%dyn7A)eMCA|Ek25RW1=WDAe)%2Q^KwfTScNPM{wO2f#~RYkrRu7 zW;oZKqDJv$rk~2{RLMC3zULoyy%2s{U>G_I`9N9x%~km;mpq3gI%|!OuV@qeR}9j zrWR~a(TT;Qp0>WWT5To8$!PPLyKWiJjUr&D8r!{eV=nR> zJ2LU57(9g9eEuuB1w;6Zh_0!$W*76Ax#9g%P8kr?GIBoGZ6-lrO#yx48|*7N=(CNc z2wdo_A!=UO!Ss{dZKM*Ti;$(1xY_uCTt!K@bV+`8Y$$~a8UCYiJ~3l`vx|1N=es1Q zC0qE(0oG{Oh2qz9*uPVnz;H| zR{COJMTgG(-EEn;`!9>HeTW%iPWG{eoU^kUw~y{kw~}2O+;x+3wuK>Y%b8JmVBu;L zBvrMd_#}FCv{YrtL%&dIe+s453{S4-LQ+hnAqUM4Q*jY8A>)Ku(=#Iv>O}btpM(+Y zyN=$q+xM;o2<Qh+_C))K}LZfloE@uFzip#2G zlbQ1Q>lo4wW(OR!&ot)i&%(6PCZK%<7pjELUkGn#&8Y_8$hh>tt}e_@RCm1*M3MqZ zb8N3^cMExVW}hY}7f7l)tIOEt+!vBWB;etCw(A>h-F+wd*eLu%LR?VkjIKjty;XpW z!~z>CnzfOfBSFw6Khsgn3y)3e5Jzn;G@4A>{6lNX1k84Z;apYP$5~6N6dZ9q+6t1@Pee6zJAd7IgUlu-JVZwt}RBu&##jpTHG^yxNyB^ zlKZp8OLF_1E;CRU73N;0^-Il6W6&sEL59vh`mm!v% zkr(;yX58k)?R;yQe9g(yP-7Dd&bqvufd&SSatQ&c7wk#lGMHHc9xsS?K$J(AF|b1v z-DzF+@~y9BP3E9$RH(W>rmZCCeq z--B23>bxduxI4el_bM^Tp;l?KDW13AAGJI`-3z+yegHb4B67DY-a~80U!##M0RmQ_ zS50A80Gt2CL_ewDMRjc$@9L+6IKiWl@o~>Fb$;Wn5NQ%WuKt}x0~PdTybe}$X6YH19n~L#Wx+F-j@8}Yk6oFM}EHn0-=CO4;&!Xm;<<#oS9_8C12dR^ksW zK9)Zw+hDohAx-%r^+CsY1UFOccDw>ov1JW5-20BD)N{z2nti zfX=p8sbwwcvEoxu6(%cyfS%&^U||Z7#f%*N6xA?SdUCy%1p;|Wq1KxUroqgVJ#veh z8qm;S&6&L4=ICtB;=|F0%8M-9q0$}j!p&vrrTnWE0drVM4H+byY^xHKS!~qt0(8z- zl1omBH?|nm`L(f9SJXcE3j-S!rUu8w$c=mypFOG+nkL^89NV4AEv@#zQUW2pHfJ~{ z$$D9oox;M0>y$`+<+>7YR)}e6;v90q$yQVk-@56yNXc!b*n7p4u`$`K!ECGagk>R5 z-+}glH80YaL|;mhITq_i1rO4L;{>Wqv+PiR{YnoCt^X)qf&aZ>Dr z5*HU1R^3Eq`B!X?S8{NnZ^@bKjBk7=)3$yw;Fa1NnZ)ysZ=5G2iy;Q+E7E;DKHaW4 zk&BluWn#3tYgP4X&7_v^-nc}sp6OxIlKIB%BU4)t+CPleNqBJ2Idnk{;pX<>l#l*bzpmxpCl} z8-$VBoE-7&yp6;WXjUF+1^j|1p1!Y^esW))a~{?#7upNi@FDg3k)$k~)13H65%XxX zGT0%y2gu#Mjn>6!i2{}YYV)UAeNRANS9*44FJgFgBtSk_09k>NhGgMp>Al6>uxc)~ z@{3Fpa+;ycm}j4Q4?-!4OLRieqTNe};n1-^8wr*2Ko;x0vP71KeQ(Q5`KX()4#lXK ztCBO&ahlw2;@}G@C?T@WBDSwiJjU}YWaYEAaJyPz1JV8Iq z_nqrH0<~A#lhrD%!c{n1@jaKhd3yO#=_dFrdA^&J@mp$NQAk~!(O#Y zqX-o)BVES2Fn!={c3w^eGLMidW7#_$;@a~&&%@fwhWmgjlMPEoo`(->;4QlVGx}7T z`<&C@CN)?-J!h`NIsL`5fe+9(;k$6k8*5IzL|Ev(p+E?A1`m^>EI(xDZMG!{0Imhh#x=D%SZtAZiD@ETyZGnIL}uM64EX5)(DX zonyMVG9t2ItBMp3K@U3q=bP^MC0@aBaTIqHJ3Iq$cpXo0=fZwe*gJP6|8S#syj;^W zA2m03aM=(zu}qAu3I{k8qci4qPVs_*QQZ9la?Hch3t2n3`Zv(U5RGN5wcOQ%3NH{% ztno<9@xx{dwB`29jpsOHbmWqfqqM8OC7T3;5;cB)(9tFDcx(5@gdT~Dc-3?DDg5g0 zV)63W_hh~=RyTs0W*cTM^y$2h@H9F`jFH`ZXtOKm<^2Kvln70}Yj{qF+g=U*aqIm> zlCoFZ3Q(b%o*MVP+bgal&IwpfwqNuBi2uTO109f=agpm|$>??#1_lB^pH`eVQpIFD zU$X_cJ})Tlyz)t%A^0sbZ~vt_XJ@zJ$g?G~RPJVh?{12Q=-jHWBgH+E>irz6FEknU zFlKmexqgm?1i{2|T!0hj{T3}R4>lJY zWUvTQr;8Bb#A&L@VUsurlg&92a@xsdY!&4=5d?K5buuBUlWfS{;tC)T4I)>FOlX9x zm4#vul{ctROd@$JMQY$I^HO`hGa>xg)eh_@@?7~)i!EAFf$-7FF*pb5TlWqTJ|ur& z*>|>yR>7`{Rc8ddmJ-dwJyw~OQ?OoblR!XRhdqTa@!NX9J3iG~RMI$Z-lC9*xt-3H z@-BL^>TX)dOkBTg)rYw0q!YFBZc44h$E7BkX2lcCg^xtE1RG8Uu!nk!DcXGST~?Ow zJzs{#J-&Bnjo9lU$l)$j@N^Mo=}KUwnT*kY0g=-=FdA3_`}D8TJ`@=Wt|8poK5~l< z*@2Y_NQhO#%(~fHhivh3KLzM}&*M~-w?g%3$P3YtUyF5qodn?Zj#q7Mp=SEGPXTQu zcrfJb4T=cql0}iXNH)yy=tTQYWmsFX=ibr+8L@Y+myL^B7{$~SL6{9 zb5yBomwJO!b2m5L*6V%oCIRb|@NdvY)_Pb^C^2>U;1TB-JqaQ)S<+?r!t?p$)8ob} zC)vxq`exT379t*bEEwQhUX9pEi9}sFx(D6Q_2dO6?8*ksNQ{NU&A(DlrW(Uuq90x? z>zQqkU;B1=E`YnUi9qfC0nUbC-v${xOP0sOj9rcf`zYrn)Gh?pd>#D0q7Fxu1Id`J z))ao{>y953{{(7Kc2o+MQ~;4B=LkI;!CAcAAUe5Gyt=KP;bx%t#{oe2HBSp zS9KuU=dpp8FGd%B>L95q2*`+4Q$sYy+5?u1${HV{`&eV=VsP*8!p~{4P<#gnwCtpfS6%7nwF5SJuJq;G_tYe!|RwnW-H zmH=(l&g|Zy>q=leME-cV1R{s22vi-KY(9RH)Wnb6jWE+RcSl2+jQ0~{{*^}}uF@x^WYeoxc$!wh9M=~{1)bzXdK`v^2E z0Gz+3SPk2{+fHIvkFW1Nt+R|+r{rD{(Z6wl=SzGF93R!qnWoR#(!|6#^*c+C&#dHO zSp`M9E2vIm3FjaD6p-wXHd#kRNNrMdL0t2CTbrUZDbk{ODl-=n66=-|O&rJpVYqTy zv@46)Ur5hKLCVwMz~UmbdFh^_z_6%k^;%p*{A*=1hgpVq?;%Ko0q=txJG-Sf=z@)q z3O0dFNW{c~UY3oXgKpSzQ%CA2;tew=sLsOPYLbSY1I1)8jCMH9JX5ZgtB!s&lk)oX zFu>+GP}ISHuk5VwSEpRktISAh>!b)Q>EdIzo_c?F3!LiVx}%G(9~8Yh4Ob`ZT-OnviGEj;KJ&C**=$J+m0>&}jA`(kIIB`O;JrhZW z3_Oc8>P%g?RG^1FH&_dd5S14kp{hfWk?v0r(Vg8#K{GgUcR`y{MlsMi;sODQBORWq zfL236mtjXiy+^nOkC66aLz<=K&L$3)95`H;L-=(jZ3_);=*yY%nf{hz12$Mh0ze$%h+Nr%!c1uGIeg}?PSYzk%-UaW6I9q#&oU39K8{a} z+AcYfIhe!x|BI)yjA{egwsr6z#ogU0?(XgcFRq2+7NEGhyA^jRUff*@v{-R>cYQhc zp8NhJBY!jYSbOfZ=K7}Vce}32jyZH_T(>YoAM7wLBvQ|C}Yddz#bGz?pbC<^*CSMvC_;{odyi6azG&WoAWBYVX zGAxSU^kv(c>7X?`eG&%*7P3D1$@-nBT-NA#uCJV+K*OeI9aS*UmX4<0Uw4wHNDIg} zQlF!yko_5h3)E8>E42U|{RB`4_5;OgXHKbsf#vQI3kfuRr=uM8w?eRE^cXk_phlu` zECrNrssA|0Ox|T3$-bZ5@xJeNjeI=I&TI%Ws4^=PoUP{W1)==%PZu|^=5<>0#!H_< z6;MYT9zQGGhd=RUR!q-qM>N_^31#tJ9a{Tmb8U#OcY_6$eau;9h8L}8LP9gY%SQ;} zbU5HUcBWH#O@rK_i<-U-+IW^l4l*tq!=d1aBcx14_N$ABVvG{O-TME<9HI>}jY zMQ8#FfAr1+P1Nu5a75JaKa#cX+6hK8pLxaPQ1i(fKP?AH1g<*oFwT?idW$Kdi zAq6r7`@LFsKBieWBxyPJI>>~X6&^BG z=^(3*v)dQKB9EKFXpj%QwP;*_(W@aUz6B>+lcCg+#ZP6vuz=VIzIeX2{qF~?_FW)D z%NOzBNL@|_B5q^!a2L3i1|p*TOYbQ~kDX&KCIB9I%jm1h28ydp@Z$8DsdxoBWV-dW zx_cqK?&9d>%XyUsdOc?gV-y$5jnHXwTEX|MA4}ZG~lnbN=X&FE_3j7$a>-4@|*6Y^YYSwop>XPJ=O+3JVS-gP)rh zh){c$5)u&3qiGzwVrHq9{PD^*^JzkbM=?py+s&&$ct(p~;|RI9;TFE*?%tHvVq|i1 zaJr#tG$lj=Od&|AgHEJb49bM_D|a`6!`I}{vtxpn*!!8%YZ7yZuFTP5(KSt;vYzhn zK-%SZdAfUhH8#mVq7-dt`k$rP*+S{)d;}wnpkO4sjQAu%qLSx8+WK;L`|Gonr9EqemEg=U*?JLF* zz|uCC5;{r;wfR=tefQ7ty~wfism%Xo{^QJttjklQwAcj~9zT#E&2Lgp*ShZ8^dJ3p zy>@%N2+Q9=gMT}(wl4(2ET25~9($V?;T3lG23c@;ZGY+lq42SRk%|O=xLw2ne{f-P zlKIv$CM@f+Tu3L-5*8)24p&!<{x-c~)_RPuRAzrnP5JX?8EZ#RAUQRraf9+sG(Oz~ zu30d9f!({G@U}(jvqGQn*(KjX-C&|hq@&Z}P9uuvWLxjMpPpw~*Zy_+Gp&G9s~fH! zckSI`fCbBvn3Yz(1Od@Pib+Rq99KS27--=g^fdJHTJnl|`a(#^<>Z!$2T;6P7+8t04heSoNS0QGq77Z+3mtpy&F&QJrT@Bx72^ zg_+tItp6Kw!v3>={iwHPNyAqUaTV1V!@HVysB706uW=zdkq){@k9{h&P_)j#z|-)r zs#30t{iS>KYC;Uv3q@JbUrNwOkKCCj1w-)rs?fya5Hh0!8{LDds)wi);&{XYgI&_{!hTf#4QE;WHaY>(U#B-GL`JzBy-RQY0 zN7HC|Q@hrt{!asPUn#R_EG>v&XXkFY(m1E8d;GlPNzwE=%fDG_`|Vb>1?Ot8_?MX8 zDr_i`mG^mP-Romw)~Q^EAP8GIC(OZx;J zt5}8>mZ+&4f@0JsN~vXm8et{w@zZ1B z(Vbarr3d1_kk``8>LTAR#q2$G@bwz=rvS;(BkIrzx`5DX0VYl~^)qg=%O9_~|NI}d zA0lXTW~`*Q!+##w(xyR|NHG+r2uw809%V9pJ0QoUSC43*kL6UbI|}`=p)NIKuaU(F z{01+>O|qD&*QH=bgXX z*Os^E4NXe`B%Ag)3=gYreSEj6G?AIbubWr=W#2)V7eR%s+_vzpC#Kf?^#GwE?0E0wBrcbWpf9c;8m9R#2J zpQ0m5)>#cZavXE(%3oz@)r}1}&apD(bO+YxaUT4x*RSsrG^GCM1Hj`0+=8LRb6Ryb zygp}Gu7}}50~jgYFE;Lc?%}ka?0p$iF5FWjTC}XjY1I0%j)1W7j1eA3g4B2=;C zaVUhV>36?YL0Ig@+0&t`BFfye^YeOla+;NKD@~{v=&{{RMkkyia%l1q`cPO|YPBSW zQT~Lygwu#VehEw^1%)(B^}sP^8VMlwcv5o9pOsbZu8(7#_->b_w{-ujz6X)q&e0qw z0XSxHIn1otTr}Huey={eOSn0rgT~rbpu5}dc)2uV_t|j`ljugj^a6ch1Q`12ZcRAxoHL zO%`(Z8}5c;O@mD|D@sI0WN;g9lbJJK)yn^-h|K@_F?5j#JW0gOkk{q=*#iKy*xWI7RHk9CwJBg+Oyp z@2ldqIhm5WmHeN`p!Yno;gxuM(EeCP6^B|9OFiWBF337%eN0@%}zfC^-4ju5vMycBb9q@w|7p9m)J6 za+hFc?AedS?BnplOJJEA(GzHJtZAVoJeDk(P&A6GVR0b&J3&?tu1G`u0*f6`@l?=` zUns_&a5*9TYF+2^aflnT+(;>^EJMc_S42-c+%Q_j$S@%{s( z4fNfJZ-0}-xs7!N>B*sYlYPIQl~v8}Y4iLbHCT+C0LURh12l`FfdP;|lHaa41u(fF zfGDO!pK^fAYQ+!`YBG}A9496Rj~H;8!#R!CWyWLLN9iUoCyc!zbnW=IuCw9K<^9li z)#H=pFQ7=4I=p3_9gggb(E&AaWl?&Ej@W4e&wC+ky|M`QNAG248jOXwt5%UNoBvol zQxHM}T)HwRp5k0FnDFkwZ+9y?ff<4dTN**;R0T3TNu7opvF6hbT=<$@muX-5A+M2- z`iS^}H`9xM7oGQi1%uJAZ{6$}cb@v_M8BhtuooRNpT9fEAqZB}r`DIa;1| zFi~oAb;9=WWG;|$>YY^DrB=Y!K$IVbF5;X955i7s4X2*$Y*kQ<~Bmc%67xTZ&FNnqkZPd&|T119mJQ1LEU&i5N5mu=z6CENrGl~ob5`M{c~k*2VQ zLpB2?ZrR9hpvsTCfnync1XzHCm07YrCkjMS2=CK)s;?&8;gn$x>Oot8a6#L@k zhu?jOmXEcrn=Vv7wZc+Zc|d7ekl5t@1>MY#>q}Lw14@cr#*}MloJ?H2dp!UbMNQGY zK#W!b2rIQIpwvqKv=;XmTjV2{L6EIfwo~cWfTa}{;?|A5%Si81qGc6Oo8@6{K6Z&3(s1$0ENDKa%J-hp>3SGP-ycL!mNgHf9s!dTBg5AMDQKejZC6C-WD9B zYvsQFZ1yJ~;d-K21lGbeJ$I>s8-CyG5F#1MEV;9%qsrp*Q9bVka@U#bs&|V1d16@V zfz(%L^$9frx(pZ?p(wJ+WA+@1^O*p=Fu{WU_xJ9Ne-~$@0tDrd>vDG}GUYR74#-j? zH8;Vy$J4r%$}>z-6bTZQD){0v$Q*E;q7Dy&N7k@n|^VY>TGv27m3L+Ap4)?;)A#!%mi02ai0Hs;`-7$f3U5h_=wJ>H)&1ti>SG3xI%4=PwtY~a z#7=hq;CXmZm*|=q5^z$Cs)Jy2K6K3F)8%=-{<5D)*73(OxiPs+FUzJ*Gqr?lP(z;9 zJbE<+ERa2gl#q&lej1`q-!#`v2dgd3Lz*w_@0Vrm#=)69_iWS)vL&ZSAtpV4Ha*Q@ znX52IM)C6mL;we+paGG9YAQvL41Iv4+c3Y~H`}DdpO$pTaOxJ(nKdqzF0#1l0Ju{_ zP^xKwrGUAMscN|X8li^@ZKICQ@}KSULiQiO`s-}W4T%aH?c(6uQaXDr%@+6d*KUj3 zye`O*a>}?(jZ`Th!7{^&SY#*l(OFb{WoL6JD{ZUAqKo4zu>fUR;O-Fa_FduB-q@!w zv+fO|X;LCzdTz!H<8P17T!otTMwPLC#;COi+%7=RFG8h2+p*= zwS#wQIhR`AXc@qc(pA@WQ=&rr9!~bgmTeKr4&E}XF#6^CL1gShb?sEP!Our{@9Ck3 zL@OZ!?=ejgj1C=2UVE2902SM8n8n;`YpI&FJ!{LIrR4W&ay@<~=!xdziP~?}gVwv& zC(bUsfLWXZPMfxx?;PD}!t7V-);0nq&>r}CbBC^{SHu?s7zfXDhAuT5p@iY|$u_*C>Q%ov zyY=rJ+ypR=hNsXZt0lG-5D z$a_cGMP)VR%KFszcc0iLHv+p)GNPapZ?kS=<*9}jt-BrX%!J|#WhG}eZSs|TS_yNB z<#|}(eaZntZDrx8)x5l(cAhBPq+rL31Vc)H7IEdZo7?^7R->wj@Y}>i*GFHYx`YB> zN6-Az-@49ouusUGZk#YpU#x7=)-)+Fws*I>LLm^EpjXep(o$efJY3l{lGr)3Y_3EX zr%~wWg7h(uF_&R36I(6>j{b*RV#z4>&>LkoK}DC%QhXO{kH^8E&B-{`R zBKITRpU=CHyC0r#}59SB62nz`EI1!9%1k1HPqNtNX%lS@Ta;+j1S+fqkHm39%7PJ zpDvyE^N*k>R!^cHDH|Dwz>5@^%z#A^5sgjd%;D;+bOw-&r><7Vjqi|{u^BYzfrMh| ztjVBytmpS^$If>Dg9MjsoV`Zt8JU^4ummc6n?eM(!o>8@qlWS2R{!fEq+k_`?ayZ%8 zjTQ2P+3N@~&K0RZSy|2XGy5?Ph#grfuq}~OqMG*)m)++N{)SucUYQ%{pZjWGe*%8d zH>>}hTlmW3N#*I<+2phMLEsJ+=Iy8X8vzb{p8Rl;1ISR5+3Hknw5@$~y@dBP(0L9H zHd5v1FhHJGA+hemg<7GOEnI2>D3T{J*u}yGVd4ZH^HI$gFj18aD`|7HZdnj1e1zur zdZ^m{vOYM*xq8>`)AN$M@!0yY*z<|(U=?megf8L{``77-Q`V`?XP6a%RV zv_CF|^ldN(s-_u~=rbP3KCESVj*P>mM|q+!5SJPHTO>#^sRCO8kz*`#ArE>j(W{ke zybBIoAO!#^N|N#prmW1(?f*nBn`jps;jec2c(Sb? zp@#34ZxC55yJ~9b6T&9wdrBHV_XQFXpWi>$=;SI(8lRni`n~~Ep(ZC){kT*yV;>SA860l&aVGkq+P#N( zc;7Dmr*%+4cjo51XhzHkIL*Lro9%OyQ2BKwN=7*c4aPa_z{cxJRlbn0Fey&WADjOL z4PLqSPAEIAYH>9=PlUCYDGQ(nUJsPn3X)U;*eZ!fW-q`8I~P0KlO24?YoOsbI-!7%Ll$!nsue z_XZqT-LU&=uqrc0HJ5Fia$P-Bple^YBG!u0GxJ2G4PqQFD@_g+AVbM|hdLdBT_7FL z^7j#VJbTj0`OnYkVP}L;o?&SWT3c@~w+{LS=4@~tvo)f5jyAZgp3GxskWQYwG z-vEV4Adrtb=jA*}_}!)U{i`F%Q4+B%Jz?PcZ-;_KM9|0~XonbB@Kqs^sx38f#!NYG z)370I4@?Irv;e@=CkmS`j~|x~MMoV}=Jqm`AoA9s8J@8kV==@sCjshHM5OnTuR9A2 z5*f4M(Cd$yB*){Z(R$w04N#-;$xy%>xqwPvihoIKw!mpglboRmi2frV7 zu5MA(Vg2|NtCFh^<&AT58L16YOZqa^uQp9QS*KL2hn5E%*TH*F)IOI3J*d=nr5rP4 z!r$9O0jd{n2rt21i}uP;=ulWtNED%Sqo|<}jkSm0tF`BK+pl$O&$H*Ydg88ye{xPv zyiS;(JEpQosJYxPiK%44=v2zgw8x;LLSIi_$QyRdjOgd4=pvjku6w3?EIK zfSw5!53*N7vO~@!^xs*zab$ck3bBennvRsv7p4lf$f0wB0+e&|)^!WRR-X^TnNkAM zGBH2*%lP8fzPVC(y_a~-CPTuJ)qQ3%n2x{BZXW=#fvAn0-fl^>b;Ef(Dy;}HMY9zN zNdPE*U=TI8!pZ#X;on6grl`tF1)Ab2g#$J3_p9igEfZc;Gf^N36f{-gL3kr%Vj7zO zMu*pME2P(g&Sfa+WdjzcWW3UrS z%0zcKi&;{$;L4B26c|157l)`34z@Wqq>A#Sj|0hh=K&oG5Ij)g3?nfajNssQ86T}_ z5yUd4iLRYQI)SP z>|w)eATURXHaK^U?L4CrX<+F_3uGBloZ>dEhpHM!_H2|85G`S>?_ckKQsBua)M>{S z@F1!Z)sHNs>XpfE$noQc0vN9v0ULGKllg6(f` zqx51Y`5+_)xgs4)(^$80Vv;iXqg zx_ZdrPan2j&l>9mkYc;=ix{?Ic*Rqcn65KaY*ZHZet%@-jInTh>^Co!zh-tc&=>)0 zR@8=Tybg@Flde--bbE6Lb?JgPX6awHr5Zb%VnYp^|LQBV7;(rkV9fGAnCYu1@ZCbk zo)2BIV+99rDGsnH+~mmRBXH>4a2BBdKkp9u|y+Aoov^H2Gj{K?WYu}~erP~3v zt|PR)?pG8!+(0N#?_2|z8gP`MJWYdMrqZ0OY92A^`h90Xxf1?RBQ?YL9NG>!u(~Qp z%)oBE!J^-GzjS_gn&j{k!pjRni7RTz0pz>Sv->7nVItr6_9qLn_04GdA$a5cIo;tx zrfXER?R$NzzapFn78EoF{{d`30yIWsdE6l_r6y>&y_zGLI4=h`%qAswwTlJSW4w>t z#d7u^KXa*S1}6;&1hP%q)x#Zf&YBe3&>UmNB(3)_F;jh=Q~x+>BK)4DQYKVZI~}W~ z8UE3!9)nz35Lr_zbeFXSH!@=A$`=zsR1yjH`J|)#kXmIr@Wm%{#*6Boo#u~yArV)5 znc${>8e;;9F3vQu#O=_Rr3%DVn@Lu^lM60RIOcx}hZNzZuqAX)6cBI_wawCEGQ{m5 z9+{$Y^BB18F|XA#H1FIz?yyL3B21PzUl7++(|tsad&|4(aH1qsu8PGs>A0prw#yVL z+JoxmVFnthv#dyZ*dVcjC;#*~aXaP7THIv{Tm^~(Dollk?Q^4^2QiUfALHF|t2d2T z_E~O}b@OW%@&`FpmDf)<2Lo#)7CI@RjlTo4~;xAhLR+W+}vELH6trJ zFb~0Pa9uaY;|*HguW^O{h=c!`XK%X>LVB}?MENXlBdLF6zSp!YkyKCS(snr4c<2xq z@fd7iN;FJ69J(^>!3KP3d*&3Aq`-vAAQVBLD%0)8jZnOcO?B>2UT!)!O&-HASc**z z>IHj9+AFp?)9l9&*awohaAc_h*hv#X`9> zGh`wtLRX3xousy_{|JT$bic-b4NfM3!NMS?m=O5OpcgKIuFkGl8Y!Gv3Xz;om&wTw z`T0uLR=ippPs8bc4+a;+B=^AuL}>Ate4m;C8Kt%w*h8p^KY8S>H5h&fZCp$@3?kbu zZh*V!Huw*fmIU)+kB^phVHF*Nyk%B@iHoR4UV$7)I>{%T#9i&3OqEepj0})GJCes_ zMizd>@OQb0Clz^jeY1PcavPL>3&|?A3EN^mX&0&bO)co~=NT#8F}rkOSRt}3b<5_; zMY5NVArIp3l8v&14rXAzZkw;G&Zeoj?|e5AQ_>$_wpfjXF-g+k*tW=GOSpI`oYovw zOQWF#2KsHf3pj&7YeubDaHsS$90xfEPk9%%tmIZE@L6RowcjyA2L;Z!k*Lixm-P@_ zw{;my?mZD4J3S7#3A%Z9;>m<_W2`Mf3N#N?ABqqDN9$*AW%=Fy_uCax)k@M*;G`sX zV128nn37%|T9^b*#Ytw&gk>M2_EuX__5ELMw zS)9h?EW>*sr)s9j^o#eV?@78F3U1uPKjdo6y6VM^OV0Fz>mek7gA|t7z%;eV2=GKA z(g2|hH+6NcES6%)ms04Wg93M9HOX9mWoXfPPnSAE*8``(R0#>t$8{L;a6z)Xjc9GI znQEKGzx~hCh~;_}g6h4^WUu{41|5t(cjJp~CLkZ8<+obFk-a;%ren0WynJ?X4ijO7 zW_2{r$Xfh+1x<*>WBf-G4R<<_Wi$ zO5F=0V&(q8K!;lGPY>Q~AB0~t*l7>tC0tuit>RCrd8y*g)bI2alL|FU+V_94xxat! zc0+}-mfuFekW0k|(+s^kr3Vya%X8c{vG&$6npcCm33Fp%kt#y}1V!dh(K;=#n}cxm zPgGj}k=??H>807z1ATF1R&F9Q6EjJEn$T_vlyFf9Xeh;K$dOwmG>^LEIM z9?+rKHa8qVNzJtWwASr&NYvrSrm3RS|Cd?aHn6huf!n30@JLcyguI{MPzeeB3|J6! zcfECUd5q_pstvljldLZh=Iin?)x7Vx16b z*VwmbaBW1ukx0ePHP5aRM`bzbMKIX=H(1KI)|>xo$SY4AP>Ee-NXLtjdY=ZtJ(kTH^}J8l#bO6DuaQ!MNhshZvEI|L&N#pn?wY)_zP zSjU5)Kp=*hdHoY~?=KreIo8CoKMt6faxkL+fdmBT>WGLpQgx#X?7Akbn1!TFu81{bHOXz@m$nr7mf?^Eup#<9WNgt_p6q$mh2 z)x~ZBm6K&@HhgV2&HuW3y!|RE?43*uU0o+;sjS2dN!J|<@<_gVW3hD%VJlM9SExld z8^CV$x2-Ex2HC9(P7ww2a*KdDdo8~&@IL?2g=sqU_%is-A!e!zz_ef`0)EuqvJ4+r? zzuN0qMyf0`z2($q9m~He$_Ao=(*h;pDcEui7nIG=CaXA>r-Xn9 z5e1;blLCXwiNeIou=F*lJI*a}_eE=A^v)URbY9wjuTMxq&0LHn>Gpys zCi(%Gxc1h61G@84X0`sfuKGZ~q-Chg&>O*_TX(g4TNWLzu=;Ku9WFq67g<0noX9Xm z9~y(EPz)Qn3zXB*3aI^9?rjil6Um6+jl-{;FWoGKi-s0Mxax>k$xB&p3YmkVI432> zFRUJICKGTG$0pp#7+PMY2M$n=CD~%q_e?U0rCNqXc(3_kdqyTkK=nQhRMO8cb7jU& z2+?qKmjw_f#}~Ko*$Fn(L>j&^<(PuU5dYj=;Sd7?ARV9hlQr91 zalohpb1a5@W|BGoQP{yAbFq{rYx(rK36S2tC;)4)p|PcTGUFoKs!=e?t*DwY>*Vd{{+bmwjYgS*5G3{d3Cb8Nue=EkGJ2N-Kb>AjlTmp9|@!q?QZGZgAR|LuaI zVH>ld#Z8d#W(h&(3)bdl&*hi={na5$Qsz9*==65C_dP-JZ#>+zCOnYbi4Ni4cF6`vDIO2t@P4tRfTN(uoI*A>)iaqydz2v&e1K zH%IqsT#nJ>Jo$aWD8EabNI^L>-|YNd#fwawAsVQW)TqHI1BF8Vmb*^iqX*)UGPK1-6D>qjVZSo%Vl(+{)AHuN37x>e^dCXzNm1n98F8JQq* zj!S8ACS0*RgD-dEc+r-$L|crVUO)F`nquK}AKmIhhWY+T5aIdYvW&P+fr@4qXrSy2 zzDlA;Pl+u?m}a)Fd*MrIO@3Qn#5Hy!FO)K^emb1JQun=WW(%5|Dy5Q1v|cuGEL%K- zNlv@A=Wvg6Imn^0sAkNzTqa*(s%ofIfZuvzjG|&i5iU_mohePW5Qr3-L8Cg8WsFce zsbu{*Ng0C4CISAa;ThuSen0+s;XTv3_Ns zaKgc9u&=^6ab`)jrt%+Ozyy$E(3mB!@u^0zaZ+Kz^ih^?Zp#prjRQ{tS$KyyUW*A5 z<_>qQ2B)~CWpr@1SHeR~MhO_Ets;NTvoi;jGb2-2sPCqY;z!3MUzLllM(<=WXEtb& zCb-h$6bSJPNA{!gA4Dt>%D7pC4yx4cj6$B#phG(-El`OoHTCCQcr}xn6}|@wvD*}$ z-FD(VM!U>dgrA^nUTVmQ^BxIM$%k36I}(_d zS^_@l2H|4G0idNxHn`F+?51BLm=79$=__*x~k-zqM2 zzYC~dc#ErK#_F_1;bnUIiSOBONF4N_q$wkJ3v`T|IsLqXM^`rIOuEL4I6}&FbOUoN-cE47$oo5FxUubKs2drOHi&*_nUx~BIrt7ZU@-pip2 z9ndQ@G0>l9Oz^Fc0;V2H-v-32`hx%+z3qp46rQg4)GJ;a+c7aG`EQz#vDbW1;0lj{ zchRL8>@?9B5yq#9&L3@U?YEs`u#{oJETA<8c4pwZA|B`dkqx#aBdn5_8>PXS0iSFV>gsN(s<62jp@FxH? z8|!#GVvQxXG=L2s_4^Fd^&jj|H6#46JTkTbns9ntlpryS6tPJO8*+pIDT|s!319_F z6y%lN+Vh%*)0eLK@Ggr+w}S}dUUb=9Wc;@B&r#^(sDm|6l+aBOoJJAFteiWWW9CwNP^4z%!F=2H708Yg zGGJ(M%^~E%6;SLAYwTOO*5g2}BJJ(JJphj`G~5l%87EKb;@Z@XS z5IUd)P0<`+(DYacz)00tSV7B=-&hmwB=ZOrrM2@2dl@j=NQbbb<6YP{0%*iR1Oj=f z^M!|6pC=5}ozo+r=BZ81tQmDy)Vw2ll?DqNw8`}kisK+*p*ua#Te6{0L2*=4JkgGoz%julznevhQ%@CAyNiJn!90;r^>!VpwIrW+0tVVMhwP&;nhAUa*Y z7lf(cPU6ITE3mEs7U?pPc;~^Lx^?JfQBd(8Fyu}r8P$^0?(apGZis+y=IAZDo}Xr(Kqy12 z=VFWXOL#-+v{PAlW7_>@wwY~r<}R>m|8B9p*4phny!w)>%VVa@+Dab|2_Ghg#NV|Q zZ7s#ORyoP=m^C!pw0d)H^{h?M10ux%n9z%bbO1CMgxMeV&j&n$flUl{4M2xT8iN30*bL7Ti1t zTgstM?CI0h`w%VEJnWTsAx%O88;4P1VnXRO{gaATLW;tYMT!m%3DyeQFb=*@10g)T zJXmr}1Es18-*;rpR%EOfP<&UZ`4%cNr%bAl5#ubI z6ocdKglM;e7R$fzXW%Ii1FJ~X{gnXUZYHH!jAd&iQp!h zAWE=cpD%{}7WT?cB+2WWN`%Lb$?d2@8wZ2C9iFk3g+5W z5ydIt!8SQ21k^6fP$k4Vp^=~_;KmGSA{#FH^S)=?QE<|t@1{mpinZ#3>=`3s%F0KK zeKhtw(JLy{+_8H5{deD_M-*brMt!uuF2j?mv!MWLi$G7&X666s91fF2SjgOS64&Lb z?qG_YvlV37k%UqwOZ6Kx4s#k?pl^k1@W=F{ zHTY%Ag#!5wZwGqQlNv4bQ&SHr*v{odVSl9Fht3TeW>zv|YHBUuQ%K=I?IL;bTz+Q= zO^`sctx>0sz*m3l*77qUVH7>|q=F(30k|yR{#p6z@9+Qmst0KRXxVa{xeH3vyQZ?2 z+zXu{jM*igm2n% zCl(Hpf^FLI?Wuj&MyFN}54;W9&Rd#L0}nrUwk=o1+N5MHx~31SaIcxAy|cEdjEwk{Qjjv;vcfej0u~xwU_#oGOo){KGG?cf3#|U*x3lM_?S>v^ zQYJG6{y`zRL=6aCK%0I5P2?$3+FxkG|MA=hoQFJU#NjG+O3XH--sWFV21^kvB+L(X z5qha2>-7A17p7)#5AXxpZYv$-T)p<*P;GL=Y`;5=ph1^3E#x()?x>VL1<__=5nN^Dx=;{R$|sapC35Q7ER_PGAl7>sq@Z%-Qf^~T5{NA3_2qs^9I zgUK&0;(ps&A#&S+&``9?mAjWreS!urpVjGi(T%GC?z8v)s=%2mfi1n@ti3zgFQAiZ z3C&s2Nq$_;7FDDMNCoo<3rc!)lgW!ph+?it9{HHYr{<|xsgmZ$&BzSn*W5b&_UvX| z)=v)FRFkKLCU2T%!#7|vkSa;BfTgz%)H*fHvlz3N;E5M}o1U%VJN18k_mPJ1yYOx5 z=hMf{%?@%{rSq)wlDaSQiOC)iU|{#nO2yu$*B1R;tW-p@Fumc)@pRGBVGT>QQ+1|< zwtXkUmC3Nkf?HO%%j8dBP#yghnF#Y=DQE@ixKMB3=R zJ7fgt0;hS#$;YK-3`APLfwLtEDCyBXrZ=3D;q^6J^_0%x?a%z&U2}IJRxV8PLd?fY zi~AD60moGzX(TtWNUl<4WfqMlER*=xGlCtXoV?taxFYiD365%Limt9V7%?zU9>9E4 zp1eT{;wUNK!5?`fg^6tjnw+rb>aD>NAxxkX~tHrdULw6GyK13f3G} zf8CO>@AYd@zKHMJG^wBjwgjcY=W%=VdxT(;14HbQL6e-D98OS4lNBX^c{~YUNYq5; zM+)rLlL&^ix|{E-1QU+TmW9x|D4*7fraq3X{+=FaKa~Nh7unO{6D8Y0_-DGzSG<4SsICAO5s_mZMONfLM|4;~U_*|Jl^o_{(5w?$A)sk@b3&i&cy4eH<@sIdGAuifoo`&Vn*x0)!pMDc9N zc0FHy$cTSxwz)3;BfpFHByE>(Zg6rkUDpMYSNubb9vcuuy<`z=f3Kt{EL=vDTf{4T zMEnN(M*4=@r4a9(K?(_^`Mxx@9~8Qz?(=u;dLOgOu{3;ik|@)&!hl>3xBPLMCL=mL zJT%-#d+ER`U!EG)X>rH;GiRw}xDJ_AKOb+EVao0AboacD6+XKl*GXK&lmxJ)iV7X* z%fpM{qKRQ+rqtI+4%KN?)zb>NfECDM)Pq#f={vo%rk&KAF_ZL z_F~EdVlN#XtL{-bDScUqBIKALH|$0Cy_{qT6;--{EdY9D!|4M;kd$o=ph>!K^P5P# zl$)I=7wP@h(JtoRHY$mL+u`pY1H64q3Qk^D(7=OMWnPTwBa9YP0`1T*7*6Jr-1ZnS zK)~jVJW+op7p#}nE@!x?Q*v-m5~`RRUa`K(iMs(m08y=4QZZvqWB6*Wo%w_qs$-9v z8-n3=vuzu?{y0K9z(}W_)mu(?{r1lmJ}(oT4Xby)&IyDSLouj?s%n7(YO}LKWk5mm z$}{1wxT|C$ALK#%)(50`JDv!$qV*Bh6lMGHQc{q|sl-`@(96SC3)3|RTaRcC2<7X% z1;%2r7MlbxvMPa6ZWs*8n#|zE5F@7b4tkNF9D80LcV@`+CZ1Q zi*30GJ9XBdPVzgmr3MRI+#~79@g12iBO8BwE*;jTz80Ylem}42Q1_=sXS6F?|1GHW zoS4E9OG!CP4lpjLLH{-zBJ zwJwN)^4ZJLvN)sw4D!Fbm5R~@eiEDHTJI8`iAF%nw~F>c2;cLk`N6Ixe`n5XO0;fb@g3m z;ya&UW@9P!;^NIs7frktm7NqAjGa#y=WB$%-p1)Adg1l%kaH^u$xifB?JT4jUwHTJ zVB7^)Ywpc_P*74`MSTYbFx8=&G!Bm(rvQ~}2ao?BO<(yJWw>=czyL!J-6=>4f=G8r zNlLfU-Q6%qcQ=yK4bt5(NSAbXcfE7Y`Fc#V%jh*3E783)*ZLV~P*2^sy{c1A=pNP50yhXBm8{b9G&vpH+QbRs3sPHC8s+>m_%N&*Q8Uag1^ilY&bkM_t{V z*IpZ2cn_~x#W!W|tA_dMS3oFO#+bPn{KcB zUC%cdV8L4l*5TD^GuBGJs@%{@PRD~CLL?gc-!!x8JZUU+>ZTqglfqGuM!2E1S@d2e z>`V;tiC8}j`ZNE4Z{pK(NF5!9j`GRMMca*UoqHBER^~pSW0Q2xTZNCi?w^Olg$=xP zRE&JtO#`Kgla+wQGHH`9_P4K{xl;ION&psrDc{SyZ5#7tnbA)#!d@sc#+i@k^j^fo zrX9hmx!fi>L*MS>ehdV>y0k>Hr?;di6Pm{o)eyllS~vDdmi(Qvjl6R5K`vVZj;stg zUg8{cVeaNfO)4{;*9!$U9D*SjKJDT9x}K#hXb)?;+dq~lAas+n0m^R`#V!QVuQEuK ztXhl7?<3jD6wg~cR+VB${Y7)Kh*uQaFcq$jSoGhN3Jc9Oc>PIGbi?#t+Cy%KGd6Fa zdEMt9baoyxYi1!J02*_#cOeK+c1c-{+GfXPDsH5L8`p77m?5}x!uNi;QSVfV>yW}G z#_8m$A>*Qy&w8}8J+jhz_$H}c# zlba{sVaWO@jZ@?8>Hr`0FR*0ht=rvgK990C0*dRL7Z&YE3m#wiCT+M17Lgbcx>VgF zXY>zp$$?Z~zu2PoFB!e_1I=PfOeDDs6f4)y)BHibA!_=If3;BvcT3AtgE7LQ&~Ujc zMW$t1ktK4+VagX7!J!MlB+gk^q9v=qsv%o#wL;!e`DG3heD~T8Tg{)QHoHUhBnAk7 zw7l==?ECE|(G=Sssl@@iYEtsys4z0Q;cfNyceXkk#(xo@HCd=;2&SI|m55sMRa)W0 zSEk!l8Af=tUoLz^CJn7`_gWU>nYTa`|G$(Naes+Yc6Kf{fTCYyI=P8x43)P{OysOS zsGKNEOGJNrTtC}##t^M;bTs^gkn4f!Pa$h-2tJ@Dk8SKO$Ha7otP2k|Bmeg ztnA@h1CAt8$AM9e3dkSiTv$<}yU;`H%Ws$BCEC;b|LiXpg8F$Krsdc!C9y;`2DhKT zFGi`cr~J%f2iTG?_!Sb)p&#^TljI@4|CzqQ^Orv2TwCC^b@|S-9nU*yd~aaJBiX@z zJwRlp!S8TrbMaNPTgQ;&_D71CTf0*fZ2IBzdS|J+!+gcgmYXKO9YM5sX*{YK7xup|8}5on zJPKaa_J-)IXurTHMCDfl#3jxEJXr)l+>ACFHDQD#ndJ0=g;p5nK^(Y<#YRi>+wP|( zgv5bX1Wo~FqqTRYei(jj-?_PlK)dIg2Xz6vzDjazxDM|Ikl19wTlj;b)uQ%oO6&!n zdAY@c=Fqpah!AZPy#+^qZ#p4&?q`m(%csg5k@TpS)uo`<^YOBM(_4R@n3^RhKM8Ia zJ2bsXt%K|Ag1FERjX}y1(=f?9-hl#q&KoeWy>w=%Vu1m{-R|frzBf11^dXAmw*pRj z8tpuXcgS-~wWY8DmuXaFD@(A%L`^LTh1JkT@8D=D&PCKxkOY%bz=JafI#r-31|vTn z2l%5*(>7lXWFSxEnAN4>aelqFcfXpe$iR@ZZodMEaLC55nq#R&h7J%FzB>zYsbm-x zU=A-IyUgS2&lLuB1C1FWE{zP1m~GnqzYA;+E2OEf`o-kJT>>R&fihae+4Gy`9B!^@ zc}xGTuzb$<>gVA&WYt>b5Or;Yd2b|hS@%o?+jeZ59Mq<|PmSvUfN0PAxBxTnKJEqJ zYH2>oypk|}+3%?L;Sz0;y`D*r13Ts^#{!fZj)>3&4D(j!(YNIvpVF1GB76*i!+@_5 zRN17yD&Nl<^yvPi6S^cXm%6%)uS>_%rm5}J?J1IE1-Ed)cq;B@HAC+c!oZfCU+GA} z0z}bi1z1EZgf0);`}<{sF=)MTHB1o}Njr640dp>h)CGfsoln=_Xs8PbAj&gum#-Rr zSFc!q=doJ>-A{ZIHks&dx3?9a#Z>f&e_NHri>PyGn5YpH-VxE4DD9^OPw`EusmT;x z=I7JSsgzoG?B5}YDe0-fQ|TCIR}2@cNVMjYQ#*oA`7BU2^LqH!zNTD12h1OQmnmv{ zZca9{E_r|#;bE?>%^NjLTJHHLJ!_l#gd<93kFj|j-)k>f*e1=iKcWC-n5k2M(p7br zJ}bd;5dnz4&cmZl3MzZF$-v%?#^@Pz(S5N|oa3v?Z~QBY5r-X?MYScVtDQQA!t?VJ zCZYQ0n)8h;Rwa4MMPw$zi2To-#dW1xhrG9L_c+7HJ^J&T{ z3PDEh-@IO3={zmAxH_w*Hx}hPxRLT=BBu`%>uKSFCGsKFBGw3Np}L=n#khuqQtVFh zfdC#IV-q#WI3!bQ2$iFH#u5-y8ZXf4bDvD0G;IMg@Rwr<{Z%Q8+&#jX;D1I6Sp9qJ z>?xD8hp5v{4)h1sMY{R#yx%+gfB;x{&jzntUjRo6&emf>;4u^${krH~yw-NdL#2(dj#qo0du(#0Th?Ps6*YJZ+xEbY-GSU2jB{KZfWnkZ~ z{u6A+cr&NxJnL+Gr&G=mG&hA{BNb88Jl621m)Jmjv^n@6p7&xsWWIHc+01=9wWzo* zLx<*Yhx}T-%iIhcE{+EE2nks9*pn~Ep%T)aQH(B@jYGo6QbK=e_Mm|v6eRNH^OL%T+Q(0QMBx#TdP zOpOP-VGBA6u|u%+tRDWN(WG*P4!LT4kN87v*-4o3$+vwe}C@R!A+0BricU0iHxbiP`v_#5GW zBf`2H$XA|<(H#mSr|R44K507D`YD-xgS)Y)MVd*7j`Q~eK}2oomZ)OVO@&UAS;X`D zI`N`NWcMdzDw$|@oiQ6d|`&LuyY%yt6dYd1T`K|NB!|W*G zsQM_63d*{DSy==^Z%PH1;^R1%exjWk}8Nr-3q5H?sPf@E}s-|88PO?XteeKVtUY8>wiZ# z@CX17AkNpXR}XCr;d{t2`8)&?=q!aZ4#wp!P;H}4o-}tXK>o#omt6&&==Ah7XEY?9 zBYr^bvn1ZO=2VpLo2dE+aboRW_YI)tVNX4o!#~#%1AAosf2eSPP-+$zcJOjDDG0bA zp|7irL&TjnIyw=_JRDYm^bhr{<#}rE%4zZVpQmNUJjcFnMKXRu6Et>llZ&l2kZ{~x z!k8cmeGqB5S4ZXjiMV^x_SCOlH$(`}L^vB}(cS7Iaja3e$a?P{GNt!(zj1QVanu)a z#w03E7p$pSVoqvEl!MTD{HxGxrJ$DWL81i zA`4fA#ORP?K5*6dXmw)M?~UHifnWZIStPzcnKXk6JCHf}dalL^oyKpKTJhNj}(pt!Vtj$WCLn{>$hN1Jr)Ctp;BK8$Zhq_LiuA~BxEFFgVk~< zGYtHEIMZ0cN?;dkvj2l%nu0Y_*3G$G=HCvvTZceHq2sr;64z`nNGQ$=6Tr4fG8gNg zV%*_9+VzRe`DJo(`D%bwCyO*Jg{kJRDR+8cTGZdJDdyE7q9vZvtasBuWKI(f-zuA( zTV8N8<4_=^Xe~2OaF(_!O|Ak&r^d>Pnl{b2tRwk;(L!W|D z{$FasYPB#~9hO!$KC?wjm$Vora<6Zv@V~_ix0Q>7F=DHB?m0B-SP7GMM<{P`{cZQ1 zmk+=giOPAEcn|nXgym8f^ecY|8FMv7(loQea!Z#di>2cZdKWtsl3RdEty+Xh9ZLld zvvo=HdJ%e3(oid)gXC^WOR}SKkVO}v5ub&49?Hi``{H{_fB;0S+Q=uZw@(bp`hrnC zDz`t5kT#PkJL>mvN+wT2o(PG(ve&!h)3<`9s5cSmdFxKT`dv@0s?YzSRW~2@te?27 z6(;=icqGQb_e_isR(_)xy^HL&Mse+;#zG_p|Hj6?vx*96mqMKcQciJSIMa!FKbxv<9;Ds0+O=5@u+c`3Iq3B5j#ZXKW;u9ULUNd$>f zhF!M(X8M-+Wzdy#m0na*O%rP%2;*ZFDq+D@$NU*1xuEB>c`PPil8@Ig^=~~1X+Ho@&*_I&>#`|u;|S}_RInS ze~j%aWh!gIq^8PsVwLw?_1X}OtDf`xMkgans|02`$+9O}@$)R$#3o4o#aJ6qR)EzJ zJJzFyLh37nl5zE7P4Y#is7U*xal-H{-V1K$_JB7Kck9Ht|LFMQ!LvSw)TN-DH9 z@$ezNzZ!~IKB*|%cY6t?WeIq?p5JCvk@mWrT((_ihXHA1smt5+10nI#;Q%+=id*fUk#Hc?j( z-S>8}cTU7_xC%$GDjcnKhN1$_$llqXkLg<^5t`_!&83$X@PsFZ#|CZOf4q9TyxGo| z8a!?`;{Mf#Lpjb| z0@a?;rP;E%)D{4ObI14b+x?TtwlzX(*Oa3@hm@&!2RgY97`F~|`cr?&WOqvneXtLB zV8PtJG%Jm`449ZwbYJci^jgDf|MzEXlyZfusbr!RCWi9%o;w5u3`e#uqo2h@LCyE= zCd6mUCy|zk-1mG^3M)qlgUG=iR62ij7ZS8i?)2L-!9;S2Qfn)~MvW9lTPigJM}&y< zaOvaK=_#~sZvxgmNhU(Tk#2#YZn$+)w>9s#mriu3u*dxlshjOehYwnM4;zSuLH6;$ zUa^p0nFjlJx#eEDTjj_VY?H*4lH{UhB2(V(CR5&47x6I0M<^BNCdx#Y#Bw=CB)5%# ztdXQl_6{|E38_A}jYJ^xtAeriV>Lz2RnVvz8xb)|G7iz`C5>Noc%FA7!_t5~|MZWv zi+aoEZcl6S1#Qzk^VV@mH+6HDm0_*(p(+u)o;)W>P^dpbTEP zv9rb4<6Q;rv^wZS&9#J`oX?y4@61@b$%BR>map^PX$7qcYJ-Zl$CrH7NC`0|oP&b- zh%I+dz9>4nAU!%`vOAaK4p@ro^mwC}rZu7c%OnHELEh5^Gb|vQI(O5Ai1O7ZEr-23 z(>*5uC4ymqE7&5wK;}3q&Ven=Yt%R50su46`^ z<=}3=Pxcc4$xW)C?Ri)tl@p4+o|{oA;UNbxj<&qd1H;GTFkvVNvE3U`D*8G3#S^-u zq)q+*q4JsfKQrZ?Dm|MkI*_Jn>Pz2l6KFJ?9z(!C$hFp!zu!mvH5OYepJtM_pPMFs z4DdDdNbkZV7ZmQ2Gj`1CKt)>A*C6yu{Z_uNTcKh=N28t>ufnnJLzIg3Hp<0UZL0b{ z)M^t)CyNxsiD}-VpZ;^jmu(y0J=ZbdCX>X80R9h$sB9--EaTPd7cLfqBXiU)kxQ*G zoLCC$gUzfzMSFPn3L{4ZoYXcd5Jls{ zbi&$&j8o9bgub8K8mM?u?rpW z4%VYSd1!q-(mlQYvPyy_CL1gZ)bPMVhv^?&(TCtB9|*AB2~Ly-q7W7erY!~^u%`iN z3n5A#I?QJa{DTDTI9>2WfiW)DaMVC50CixrP)6_DP3u<7DJAsMQg627KPv@TQanG| z#HZt79dy+U^m~xF`^>5)*oJeTw*a|1q04KfNrrPcvGPGk&>tZ(=Wqb`OG+upX&JuA zERbDUC6_&`!*qg@{`yBDq4qkM3Kv{LPqMnH03j^QLN72wqfYPrKWj%Z($b*Sncz4O zwacn3ImT0vqOg}U-{@!$`qYq@GhAIMCnkKX8PHTm4eV~$wsqR(;LXQarxI(wDhul< z**^K*-7E_~zqSgy-$BPoxicG(0s+MZD#{aSfuV;jm?pz0#X&XEAvpq1-nY+bE(7=H z=aWv<4JApooZd;-Zs{fTc=IS7BDW5j=xuv z*t`NAu>8CdDdE|zRpmtv1Xt?$G;Z~y9n2NJ6f!QY=(%nVMRpI=z2(v)TN*owGv8(0B2aT4Vf zS>wBsT1e}Y<}-5NFsT)AH1>vM3KE-cesCQX7d#0f!;6Vj+Nj|Tj1x+31V^io_p314 zWi?=;TnS7>U$2j{zKl_v0Z3+*=hZ9B-cC3n{mE)J|!E*Hg03RcT9zd`FAG8#MW~2 zW3>@@2w$`0=asQYQOZQNfUo!Y^?G6rCB4t!z?>Fdf0zPoFzg$jI^IgbbyD-fp35A2%T5mof0oSOTn9#!KYG52i;rYiZoQc-1Bt;~ltYnB3J^dgqBSYDt)P$l6wb;3AfA!Vi_9_8GsOn_{OGy;GMnK5bZ zB98%^J!fKzp`>hTF}&d48adV@axwnfrh#A5KzsWJK%6HnGr5o*u4o!PSRg$!`>Uy> z7P)}0N(!$fZ->Lx3gxpsClS)RzQFNae1_K+=~J&nT*WBja=MZnk`7u4Gw$m~=kvFd z^M>WBvy-#C$M(`n?{gQM!x7DI2tWzsT>pzyve3F=6ZE|CPXvb5vY1Hcxo>U!VLi%`%3q%zVk~?1Kr{>hUs^UydlM z&PC>qk;-dTD?gq_8ki$GbGBQnhT3FR=-nrSUy`D6S;-p+t4Zxmkup!}4JKT)xeMg# z_1OgN6Z*dYF)Sxx2f`nh72sS34IhbO9NfAUuoi&seMk{;c#2g6SkCon`W zBGVkCb+o*#!$h_9&xZmQ#M2A*As3Eu_-e|ms1ag8Sjq)coF`Zz5)2@?UU#1T!V7oK zKQ34AIo>(N(;hE;+Gptgp{#bZH8_z?nRR@6+8JQ^m(<+|o3W}iD1WQ}2lfpez`SsT z=4usmw&;NgolBb2W>Qm7$htcYQi%)q+%_2>-U{zvn4vFx8SzA8Nba{`?N^EVQId4& zIPurU@g%Sc3cYZQzFwl$Zhq`g^WMghgX+TrdR$Sb`+s)JBAK?EI>?lJBh2S`$b?p2 zwN~QxIb3Lactj%rK+0S<)dsPD>x70WhfUJu6%9&X%-g1K)^66Q+=Y3w7z*>gdzaCB z{c<)jEu+yCCrbni{o#?RpOcJBh;`B8JCl|@^HDPm`p$QJKub^;Zie=%`1X+V_A2~p z)7Ll@A*nuIXW24DXyU<<1|^h)$$!j1z3gp;(geKi-)@$xV2hH1`Iy8pf&^v7;~3j7 zOyP8hMzp+zF5mC#*eF;1yzP(Xj`Am=h9AGi7Yx-d&3LHKshzYVRQpq;Vq0h-kj8}q z+|%Yr1Q0@{2QB@ za+^5UPMe*T?I`Rpa422;l5O;2*ZH)0_Ihil@}U4cu)tD9=u#~@qqd^>6i~MGKpXwE z6(=I9vg@Ir5*+@S8fXV(M`lK$0>Xsj$y4L7rDt7kCeMU?Jb4~gmu>5v-nlof=Hu0s z2nu~}prZ;7l@-yOUyp1;;;D8cN^Or&g{RGQiU-B2W|~ran&z!3+&9sY-4Ah8ZhGc^ zAPy+gA%@Bc7`752%l;cez1R>_Bn#uF{qXDa32Bd21ggNdZIe|^D!>rN&6lCFYCR(006qlN_vS+bz9etwt65&$1KXppd-I*V(vc-q zfbtS0$CNV%HFZ+B*gAu3L-f&-s$??lmL_u#l^Un;cu_)-!RzJxo$WFDVC$e1eM}BH z^oqu*vh;8&cwOwB8e|)G@+{z&&9=Mtw0b8MHn#=jWid^VYFwopEKyIdMnZ@tNP4?Z zn0R{GICZb@Y~rW5wb7#_Cj(-sY3Z23X;Mk2;q~WLmWg5|@UUhf-?D0=s+fx*;q7DV z@;w#@^-EzDHyBY%6jY^cF8*(Ow0m!hLk5r+;4)~o8Yc9a*R9^!X^KLdR9)FN*@x5P zV(>Ou09A$0_mob!7%e%A?YCVin&~e$W0?K>6K@k@`asThmu9gD2?%rda<@PFos3~d z2}xGi?C&xe16d!E_ax0~>DMFsyhgKCjUk{>g~d`GD#=~PKd3XUEht+$l+yL#SfNO# z(rO=pWTXpgt!?GXP|8}OX|nqG+=X-(6k(%He$yH2E}C6X$@q_Con&YWt^CN6Y(??( zB5WEQar{VjI}HrfP=P}ZG%U6D#JQDHrun9WQ0gB#uv89P-DMNb1)(#<{$`K^tE$af zD}O*GjE$_2RA0(I3>i zdu)yp%qq!B8W-{N<*EWw?j*{t8-B-L` zHJ>~i8atO!jRK6uPChU33TJEqvxz1D>iA|G>|C?pLXQj>E*8j|*$y)ube}t&GA}WG z_zc_}aR2nNGWm20X;s&mbj$Y(DRob}q+UE1q4GEK@yU%ODNuI^Rj`t*_P3;m9+Cbo zpjh>>q~K`j7{S~p)WUjNv(I8P5nUxY4x1HW6FTtCj)-&I9 zpUpCDz>TtHpfrT42I-pPH)CqaOe&;iQ-AwsyAF)8ZvZvx7l23~^5D2gzCA9- z6ni}6Q@)%(*`3Br)5bYEa(FymA9y=3ZAnWbD#d}}HfXOxrjG~gfwXXob%Xw6)as~I zxmdIZ5xtMSQr}258D|R%{|^cCBWo)K4n|O^cVkwBZm` z3gb-m1>xa*tfT#=Pws}ZVP>6r@H;=s1&vK@#au%JxCNe>vHX-B62=DzSIbUlD&3p^ zV$fvoSydtcAy(2q$|LTTm=nXa5e+JRTB26fx180UT!;Ec^;h|*p*dKVT8?6*!Y)?P zCEr+%&&dIScO9(Eb`|OcNh|@pKnW1+4NPrN#NIJg6gaWU(1`x$jL3bj?KAdwwz*VZ z)4lR}X*UDEPomB9q}rp+4bYHUj-)G!>H-{gX&D9v&B3vU?Q8Hq1(scla?rPdNq4FS zT5vur$1+i{ie>(Z*b9cMCCZU6E0_V1xRlWe$=f|Rj3Ug}xsOt9DW_IA5h ztM+#QeK0r_vRf_oR;v9k%yqufYcD_%eGA#oX5(uk%WRNT&V*5^P;BlM zaL7mJo?UXvnLYdrc>)OX1}4EXxiwINgU-yY?0_FWCi)>f*@mBVV4+BSYu` zrLFD%n!DX)QX~EJvLY%#F)&@~dC&P2@^&}>cFMNqBq^k0T&(qZ;;6h_VJ~8D0&8?c zt*+da_amtl_WEfSHw161y+&g1$opdJ&2lGUm||3>!wj6gNNe#0X(LHg`+< zKQ0M5Zr$UEeDnW!eiIrcUoQA?)x&vGSaVy(J#t|kLeXx>Wn1FA?h2jWLDuhaD96&L zE2@td02pSOOdJ2R-qo-%Q-1MX*aWiKIUd~Ahi{qFhNlSI%KM}=?vz;_m;Q$7M|O{m zu_P_5k#=6~TDA59zgp;-$nTWb48;D$X}}_r43Ev1#zEQBB^#8cE##OhIKCTvVT*~G z)|@wqV`}GKI4Ij+wX!qE-P{$UhWY{4`3JdS|r z>983GL!<(pQ{-J5gUDlBvi`t8m?R+Q(@m8y&T3~P|BnJGEK158XtAW0HVmmo0j~Sg zu_*twu~QVH%J6+`2x>!pyFJ2smvtQdrO9@6pU$E~ zb6d;SQX>)HNyN2Aww!S^FV|N%I&aCtet-{G5;YDOhaeTC%-(jl9QJ7VOStS_8bs`k z0UPqu30bGQ+cDGsMxEy|0DLz*|8U@2p}pz&+6x}NviPU8`A&)+?MJ#`qV?4N{%h*C zawQd_K`}NaA`R@GZ?0fK!s-rLPZgx9bCY0rM{Yq4lw(AZDG8MZn$jWCAnTmo<~z{5 zM78&dd!0e`EsD0U0^tBfahz8bPFe-2okd)+r@Dx~4m zI`Kky*pTYv=MyBugdGiBcvYR;>al0B5twugU5$CIDH?qX16zIDgGZ6!ZKT-gR=#+6 z>D7Tb(MZ))$@k= zyVHv~eLv4Ax<#1>4+ONT8JX+{(ATxhxtEd`MCxpgGD2_E6ye+(8lE;oa44a-KD|Z1 z0q=U6f6%P0vzv`KXHN1F-qhlKvGJiNf*0v(w5F~i4N*4)QG+uNTp;qqQntK}=zt0v zZ*2_6g(7VL;Gbh;KpI?4`*&XjxQ$~Gp!MBPf28J+YPSC6m;IA0o+({?G<=S|5Ae#l z67;Cfacq&uII?tjmeVoLI00p7K|;b=wE3hZIATWqq65Rouy8*0yA%E`a^tP6(Qus! zPigXC0nbXaUa6Eh zNeZ~_o_W4!nk}xME;rPms}gOM>lH{^Slf)zz|<7hD6cDOR$-`0(-$~2`QWmS$IY@; z9?^>3MP#iFm#RDA*AuU^e=E$R4?l#437o#on&>kW{=kny5(IF?4PUB&zGvMSqegT- zoD`pRu)DWY{;HLoauoI#@4s#>u4Bt4GfEMhgZ1BMBtP@p1)iqw3&~%t4NEm>t++VK?^)AcKSW!5_5e7)(3=6{ggI(e6wC?Pg%S&6=i^mH&Fkv1^)Ly^?`<5LN@ zI~g24ASN6(ue}y)xGhi>5#`lz`W+usUGoL#&>NwPXKjy-?}EX+giG~NS}4N>PWyok zv~2lDXSyV7xOVuLH6DU?xM$|)^NQIT3PF8KdqXc2YlbJ9snWyYhflT)=ar$v@B+A; zE9jnJFC zA{7ksKT3cIe7jv_lG=>qZFk*h_9(0!Ft$OY?MnNDr%C${_L&+oC3P5mR#PfjTuWUL zpB;w8P(#21PGH)^E`8y&rA@y##kb-di$Yw+9s8NL3x58yb`Png$L;&vA+v7ebLu&c zXnfI?h^^9c8oDs@nkYtaAdOI(;@b{4<=f5E*$NRR5b4YcVD;;+KkgwUCK^-GG^qPt zQSk7;3D6N7*fN%g*+~zNEb3Rg^c}W9yy$U`DQl{!@(54%9UR#BH!`ty+17{>GY5q| z2sV7?6xIk z(pLvxOL-glgReFf)W7g7zl0h^?N8JGFiljEmZ22`t z@HeeWPkWqLYt2U#lx9wpX&WlZBJSqut^*<$S@^wuX#?<&LH0h=Mt`+x?)$5JVV>@1 zFS7=1P27=}2jydR2L~me-bdqAXRuvzP2~NL3vlV%**PQ+>ehUI9(|g4Jv?dkDo~T? zMxiF5obw*)6ed00OYOl}q zSg}c&Sli$a?}7tJ=h8^O3p0mHjosv7myt9U!1c!!qq7i$4?sY`!9h`BLWN6R^eXFq zS+8iKpz!6&prC}i`O+#OhBh1?_m{oTK~*P3qJ}^PjPbJ<4DST$mXgJoGUg$nP($k; zDakhL6sCysIy`%OnfQF+?a9F}NCPwsZJ>#FC@%yLv~Y&ivc$O1mPFEmbHTK#&i2mF z7iI=8J6>m}m^dQTv}#|TcaMgV4anU|Lt8-6|DQ><5fiSFxE{;q`CfA{v&zR27%M+A ze4`Lh@!M{3s>%=vXnA(p*b8ptvy-B;9;~rz;p|krAMhy0QGw>%W*CuczQt4EHAG{U z2_>ru%w@06ZpQtIUNN6C#tmCA8M_+#v^nYKa&)I%cE5FiK!cy zE07&H%7mY?pA(tYu#F1qbCz8~b9%e}+f9GHi z^`w%-kof>J3SDoHMxJihGgK-gQD^zhpYPoQz!t)rS zNznXxXFX%zAGo`F$HutcqT*xV?N{Gp`Q5lZF^((7L}TS(JC-L>;fYCUGk@@}VUb1G zr$MtvwaHT&4VCWG{xq-kz0>zn_n(*13}v!VX5#h!j4IbUcjd@`%F=%V!N0O6PqR$Me& zes-KKspICAoT^%l_d6-}?kaXr(Y=!x9fL1AsJD-oU!0u&6~l<8SuWL)0B8MaLsv*$rei zP(G|{uI7(9ZYkzpRAjv$4jZrvCli&vOH{b9$rsR|OGt=;7$J$Jl@TK|t7!n1M0LKf zX^;%S5QM&-rK503Ga)6rwtwVRbv9w8>LA>7BVyjK^3m%{09C9i4W~+cpX|s_9qL`p zGEN2K0^x_}Pt<+C2@8EMg1Bwl-OT3MFpH%ox-xvpEEs`#N*v*di9Iv#-H+rkR;8;; zjIpV4Ie6%t%RQB+=7(92UgD?T9SLV|$Gm_4G2HH8?dAVxhF`rm7cde)R43eDf}u7d z9W}kQCP^aVE*2wbiXB`RJm4do{gym;OI{>AHGto^=5hcbn~+!_NYD&Jw<N|foANF>>`f_kkBwenDJraalp@qJ~{e!U|D0p;#_~tjw>Z^>q~QG5rySXk#21s&4@V z0*L^KpI8vxJY4qX-U^f82*-)yHYXM~N+}KMHL;q!N4ZW|maDb0NTLU3xnkB1K zBfE_}=75i+OPT)6CCZjJ%f=Cg5oWr6%L`{cNa9LW1dhO5K)N4u*k{h zh5ap0Q!I3J&nwi7W1@g+sI^{*I|yh9lJi=yW=-ZI3>q6EOU1_q@L-;EWLm@c>>N~J zqXN~=98|jCcQ|5TnZiO22OPvN2vk(kAJk~EQQ*>oN}>|Aj}|gOjpO+V1KV_ zp=arc-Hs>QRVI%E&1NRg-7(wkYhw+O!+vl7s0N>zK|vA{(geJSb{rL0DGnc1NmD|T z%CbUvT1xmP%6+S7J_G4SjyA~KD69E zQei$WNSnki5S6e>$ditcAkE^+)Nj}Jaj$z_A7nFFBFSa>*~wbdha<-V`{W@1D*z%Z zy!NO02P3d^=~a)1(1Z*YM+zd?uhy#j!`%_c-j)B^>PW7yL{U7VLxLj^FL^JjGj%j81{)utB3;^+j4v?!~J{sj)Jxbkl-HR5Rl-OjLjl0%jDU~Pb5v>q^{Nj zSl5j=Nt^pA8X#eUvt=Dg0fB3n9MB9ASw-IH8s9%%w)NTc^uBy-7&U2bcSw&^j>~HJ z!e~?xGs!i_fJl?2paGO1f_$^m@LYjDjtmqlYN?s0RJu-QqZ!<(8Nk(a_}*Na|1rYD z4wPqM9Il;tGQ{J}uTcLfk*|nDGsWtVU;DUCPdQCxHrJA_LQvlB;VviS+pt7XNX)Te z$@*sl_@}0@)vakv_ef?0AO5=taBA41cBBvbbwTzC=pwetS>86xYl|-wwvkv?rT3 zMG{@gU_|TwfIL%l=NWo3fq?RtF8PnlM{Ib)icqZ|#+2zq&k(IdSc@#1_3aC@6;Rrr z_pv2Bms1PYp^H>3^ns07Jc)&ypZbc~Zta@SH|T|(PRG)+YtsAa~&q^-+^rOU%(mt@EI(GZ+f(Yo+AFv&-ebg%<5w~M^3(Q@jgNdAlN6K&_TdIbqiI5H`$_T?#6foW={6h=yIFGFv9yK~x?q=dQ<-$8NNuZ%&om4b zcxWFT(Wz&YQ|l++Q%4oR6bmIG?=cev%ubvD1h(|_EtVm#AtZSlB?S4-8D2MwfiHpm`{p5q9h z;La12^+=Z{f!`;CX{%dm)m$FUrV1F|=}~Nc*1peSgV4MA zj>}4~Zzqv7G>9xho)eKhKz|7+Zy}zn`}QGjjQ8V)*J+21Nuk$9qFhv!REC0R)$*(i z?A_xv!!DL)<*1aYx#aaydS{qIF+!G@aKwtg1^lk(P@wZz8g?oS!%Jf!ot-Z&#f~d% z+sBdfeiD9^5`M)Mo;LR$5+5T}~$1#}tOd7tft)KM8kPg~sZ#pJK1 z2}g=+9TcYIG#YN3>=s`xJv~D=u+;g`H~4zHMfnZP|Fd(y@#=2P!*}nne|(e>H@`(P zxsX*+PnlLG54YIp+U4`*4Tu+y^}tk1Sn;WZwfuCK8Fs;wg)#S1R_J4GoSpb;wCoa` z9v4j~`M~0DU(OeBKlU$qTK{hce+2y`4a7b7k%hW6Z9>)mme_js+AIU=u@RZ9MD8n= zW*@?-JeB3E0J(sqDt8gL&PM794isu1#@lirSCP#gfq4%3W zUc2iE5mu40UowW`YoStu0UTB|W)+{l;Bs*Ly{-yt8Jzudcva;Nb7|%$u| zpfF6QzrV1saKGkvYvy+{?|bt4boSO#_0-b&vd~-gSX>3~U-gh)^-yH@_!C#{rc}dc z?WAetw!Gf)zoE1F{$|}g>hR_LT|lw}X(5M429LVH=)#20z_`vy0!UE7e=K{_*SIFw z=ShM#Pnqx*i?#Im;j1Us0B+9*@T|S2=T9604RDeBo;8329Hf( z%t=`AZjkUdKIynp)ZzQ2^{??Ha^Xt;X_5sEarkkc`2d#1^>We{fUxd)YND;oI%&Mr zhR-{{zh0frHPB}-bU3$kUM!YrbnO50=#>U$YvsSMppxBH0fJ4HU}sdyVBd4WGm0dg zGzD8>pIf=J)@dy6(X5lcG@6O>&p;e;qw=ZnALl?aZ}RkXs-mA@oL!{h0-0oF5+YY|TQncH%Mimaz$mG4*;n^GIoMDiY*Y#9I4yu4np9YZDEDhJ#@=OSxYp@^?KFCo5yUN>H~e zx>{%y7B!Fnt|DqmoAJkPk%cs4Av#W>M@Sm-Y%<~ONml2HWD}^5emzdudrdq>@L@4! z#bYhYt%GNJcWF1twkkz)N(LSz+YLR1QVLy%XmI7+UsgT;Kc2oatmy~rdW1Ma*$5dS zF+xhZySqE2n@I~uHv-b#NayH~2E~DNgLJ2KgTTB0^Stl7Yu7$(AAk4mIQO~FN%Yq> z=@yaNYD#HpnnAv~cX7aVwcO|lUmb}mP!!bYmxcUXFI-FByEpWXT5o!S@shq5OvztV zk4$onBtenEs;#N#s)PHb-UR$HlGa#l;Hw1evD&i}X7k@`SJr<^7G>>~)90T|CU=7+ z<=yv{-S+{$zgl9#f1W(9oIK{9+~v;9%!ob}ih56FtuD3MbsQR<+|Rruzuj>{?v>;G zcMQ9)3|T*XKP}x-2^?;6T z82xI;Z%tTozo+N6QyKs33lwp*$$waTdcU0iHi|C0hvp4!=$9OC$nxd?HHmd>O|c^o z9wEr_R#Li6Yn8Umt*fyWX`ll%hj3SuT{DW(6l`zlOb(;|>u93^1m?Qj*e(kJ)smuq zeC0XtEki|VLR%yk1oZY8MX1Z8*PJ56-2&}T%(JYh_Ka2;xBHZ zG_at>z);fkJp4oSYICMCB&Yj!OV&xy&Ev&;Vk;1)yqNE+a5fIKpr+Ia(6%NK#WIO; z+oSZO;aK&G&qD_K7Y@eu(eGT!_0#&Wfi2+0bbO{^S?$;{n*m9*`2H>I88|obn~hl)MEKGi9ANqU4!)7tWdR ztKS{LN30%)?icxbfs=<t__jfnHc%5-Ux0ClaV*<)V4OylFd%3;Ky!U6 zPUswI^E>AB58>2t1$Xj0UB>Nt_B(kQ_>%mysox_3;NSW4-H^LByaxU_b@I?f@lZ$6 z?(ukkXnfPA+j*cZdY2@M3GiI<+U@@L6mW-(_-4_7z5G?5hsD+N*_MBktdEm^gJTeudGlt&bJxUOhsiC|A^|qm!UP@7Z}fTXSEZ zR(4D2l6-)?~O9K7_n`{FMms#4bQ z=kj4$QOm+edyZrG>XFBsszZ?%xg;7HCJm2!u7L8#CKV$MOMTW80+n4A_;u8be?QIZ zMptQab2JDByJN6cgc8VZA}cKR#!DQ?uH^W%AN~hyyPRT8ZqMn-3Z*<}Ugucxtr8cs zUII}G(0sL&FDIqr6}J>p$qd^BLs&yAyZeZkL56uWRKdm-vp(g)^Z>dMd+QuN3mgD; z@FY4YqcDQ4f$ilg$TYetrD+r^oW71R%e%4NXZs9ZO1{7CZLv9hx9HgJygqAq;$Qc^ z9&6KD_+Mq5|LM)@!f_M(aP8Ro6fCbQk${9y~8$zq)+bdevi}T1@z|y zwWHx60u5mj2~BJtz@Ozm6_xo;3d!-MEG`JWnf+@)rb@3;`Y6ZJsgr9RAErt=d4Rd& z-K=Jgq0R;K1YpDBb8PVIG`)?Io*VzMo2MVF|2F0Ve)9g?ecly)K3-h)Kk2*?x!)_) ztub!(I2!ySa@z~poPo_fJ@Ir6)P2rGaew+n z^l}~d3rO_px2pevW}ffshx$I$mD>iJ+*Dys^#rbXBn>L&m9wFne&vt+VhQs)((EIi!?qj!hgWt*9-LdMeJ=xjuLHp;W zJM2o*T^&`2?_AvS1@I$y6`$oRD$mS5NzL42Pq()?CkK3uYd&5`vki9vFJppb$9HuL z<{y4X+lRklctL3vq8gwQ1swB@J-RznG8Y)i)dmHMM2JwLXUZ*(CoiRYQm_B!v|!x! z{)tj5A3k?2`S9b9br60hPT042u5Tz@&VaXnpyYUxZ_>gi@W!Yk06<%ZQO7FZePJS= zwn)^`C}u1sm_sHoNJD{%JJ$wCg$|DF?cd8np4J(p0k9-5^UEv4r3RM|R2+kcOqs~*orEgiT2S{Fz8Ej+)3 zz_N5>W;>svl<}=%l<|(L6yH)gI2qMog!ImqgwiSFTTGkQHg&qw-plam6`l)eh7ZuE zwe_`fo!G+A8WghuXuPFZ?hnYW3?zn%ec^UNZ)_f!h2n1XT>5;OwR#<;>x*nu9r#He z4+E}hh_FBt$ReM)`c%{XxQ-iedsP$ASDgEl(k7&&MbK(z?A*eEe@bpN4QB*D4M1O(Tgo94A33 z)GkV-eoki|JfAGQYcthZiXy8_NDDaL|0!|l&DcDXQS2H!V!Q{lYN*C7+t#H?Th(Fl z+iq?}N8r!{u;Rhe2y(KQ84fRfC@2Fd<2imZ(kO(>R3E=~Vn@$#u##ygXmEq$B!GkX zn+d^S)Xx-+=8-`FK!+j+tiFO==jZZBj=*9qX{pMWJB2D?no z(y^t0ej|N#;Ki@6s{T6-d2QbxGSd8i3rB{u;lL^@D`Ay3s(B1i)w2tF(RIxRE|)AW zuTX=zx{lv?agreRzH+geK|(wukFI=jo-+3@l{1OqaGp-3eK>q-8QML}f==}ofHqpp zDy*V45ESwqM04eZG_)}% zXA41X@py@>vfa|?&gihU(E{V+0ZOe@K|oo{4&-BH6>4;G%qh5yY9Cv5TaT7mbGdz6 zVkc1cW#Rj`95G1+Vl;oPejsX4axZ;uXG7#{oAT&Zr{^f~`$GGdVXPugFgV?9Y#jb;) z36BGuegg?jOMUK7SGJTWN*j8B6c;aYNR|77zSg|q{t=F>yAgW>CHzKkceXM`#nruZ zXJE5xUh!omt#Le`&-LG5Ux`rG>iWt5tG!PLx~$bd10Img>+7=8fY(G?4msxz8$(2Y>L8r$xlh@j* z@)<>Y#Y1+I?zFhFz%$f1@QDCSr?VuH!m&C~-i6TPH|_HMxQ$AORSb77jFwM-@hY}1 zQQ}bQC!4Y;Hej!H1!I{on%y+|ZI*rLfO%5mC84bq{_bIZVEhjdHGqRt0;g-DED#X? zArVz>OD(oyxp%Zoy_99Xfs_eR#;ok=`Eri81_`5Y=2wVZ?#DfE%dT|SFPyjwN~d1( zM5Xzk=~nS`FLe^|SHbhTwo@-U9a)t*-`G_c!OIxF7*I=C#%l8e-dwxyRLPRK{=K>n z`eUVEvwBih)%w)tA^$TN)E;S|IMZbRscULe%FnvxJUAF+lVTm~%eiy6RoO5K$wB4q6i{PD#k7>PjgQw*!`0g)aFEC@PP; zRgCfBji)C@q+8K@`jOxa`Hwo5(yGL=gO@rwxxO3n(q#mOACHBzgk8*zCU;I3dQJkm zkVqLeI%~jP%fAiQCyM85*?>!v2y19|%pCI(P2~efmjZjydd51QN}qQMai4Eh|Iq*laz=y5 z`pm*q+aB41C7GZF%gf6pXB5x3{Q;-kqW_q$ydzmDmpahGxS_rO(BwYw22Zv5XOc1mP;B2eC05N~%d(0xs-8 z{8k}YCKZE*!3zpNSYd4--P=qO^#_n{6pP(?mt%0vP&m!8v5%`KU)xa^tMUE~mV*aI z$kmm zntiENWd6?v=#MOvIciBZ74jjICUPk1wSGT}z+&#STpU|$EHt7%dz;eDSH`pN(B+20j&>R35FgBzn{9u@jGUt%3~)9I zZr;|ukZ~JE^ko$At-nbg@Ml;e&NZ(oA-2}MwhuW&v&tRGh8=RfQ*2KIqdRxF> z4a|HhSpPoXg_1r)sDHU{M-egfIhEGYAR+=_4_B@EGY3*F@FwUH6{2fv1^$!-1mIw>{7%lCIC~R02HGO)wyV-(CGyQ=VI!E$^1f?sW7DHKj*z`t&60@ zR7)&b5OA34t^J#8(2$xrAtqh`Ki)l{ZGj89yI-!7w{oC^WxhQIC?cC_uUMp8q>+>F zCaKAT)6>XU_r5aVbmgY&X7#Z>02dH&UwYy{h5VMV=JPM%o283b&wo#zzH^>kCyyr- zuVkIPkw5-L0<}NK{tY8L;~DIlZ$rv<0ZBL~sT5YgMEPu7uM9~~TNwS`MA@%Tpi z&BXw8a!U#w_&{WPbAufx8%#F&Xmk2#`vdk@o1bWztwa>$G+#`bYx~!8imsY}5apZ0 zaBvPCAaexkHypF`^3!g06SJH8V4y+&0Mdz1vOGo;AwFXZr4*Q?YJOX#N}AT{p+{Q?LO z8X7iMBR@ReLQAYnS#vJJv`HLAeFG5f?D#39D&{r2wU@wsTr3u9<8Eti`ZYWNUq!AHI%-dQ&~Sy2A4oMw^4GEc6(4 z$A)1U5fHJkqIg?&W$eihgDd>#MY$VO)m~><4)X^69QW$`Fe=Ff6uUPOfpjBKH|-dM zbw9A3uV!kYPD+ThdGx}b(3pIA-~O<3gV+9~MHre3-`SzxDWh#QOX2baUCm(^(_O$Wm3B7s8rAD0BSX&ps|q*SbjacMXj2>6 zw7WimzWNqoPl)wgrJp}-SK7(_{o!Skdy!I0H(sYM4M}D-Ql7ksNZ?5cs^a@6nfkgR zI9YZzwg2V1(o@dQzixfAaq?glQEcf&A(8%Xgt3`m;P?vWOMlxP9-S}gFCK*DOGqkx zM0AoQBN6)6){&#lo-zpqkNGT9BA~U;tk{iXF)tV`J+wso?}DdnAXMWM)Sp43O-SUF zLMl|es*bhwa5inpAA^c(gdP!I_yxr08j-yfCeJZR=N>t+0HKBlyn%vI3b=U`B6|Bl zm?;txU}d>b1#kp`-CP1=_8}dQdZOJxjtar2sp))G?wj^~g_?%01w#`fclku?)`rNs z3cG_nKcMpIw&|`xbd1JeW)b6%Js-*Ov9l#~a^aJJk%hxi2=a)av#7!T{59k}|IhMD zln9%wG;$PRZ=Gt%9X#PPBG8wRJ0~j_VXf;M2~ zN8FYbk3(m^&szzqFbB{KcsuPg)f#dg5*V4osyg&73!`*c+6thQ!)>4*SokWqF0_}* zTGCLJG?N`nAcXZ<$YZnCnvC;l+pV{^i)@Vkhoz8{<%6C^1`DP;yWnG@l#o8y!L5ST|#81#dske*~;Y%$rA%apmv;_Hbh zNE@q>1*`m1qn{Og&gjtk(b2}wp?GS)M4k~^1Pm1~B1_3c2Q~f3IXcYbvH(!fa-g8^ zwAr;W!Q`S6s@!?xn?^id{v5r}q{EyUr)lL_aykD+`YUC@#Nk#zMvA#thm6P~7OHT+s${Ms z#KZbUrw8+!qO_MNj?klY)ryizCvJouRsp|r!LtPVdcY~D(w2?n;b2=v0e#~lY2#0A z!Zz>;1f;O){g)6I$|||mcF9Qm$k9JEOcm>~&{t(hGA$RPc%isB?iF%pEstk~> zVQ>Eh9BdPpUJ?ZWJL)ra?K7RUHDgoU&r@p~O^vkWHvUK8IO94k6uq|SKHcH%-p%*y zhdf`ZK3}H!-=&qdvvlnJd%Rf<=s)sYs{L=Ci@^0gMO!_cUkx~Pdcpv({mgs5^I1Vc zwIUa9kp&rxm$jGususYPY-QUE@ZWi-{MRBEGeZ|YEuODg9%OwRi#Cx+EmV4i!lqr5 z?j%+z!q>hq!Z}D1A@(_N91#QxK$!Fn_~5|T3P^!gW*`7ekG3@7?6kV{hnI-~ zMXQI}u!$G?=}<=?$1qCJgJNjG4nZU-;2_wB?HY$*LG`7{_JbED9{vDkJ zQ#;WvL(`vj6f?4u83C(CQX6++)ltX4SFoBB&L*;)3XGtQDhnX$@MyyCKc$>j&1U2N z0Du|_$6qH#6hQMqL6RIk$rsqN?aJ}t0G{HKmTjr?J2w;8{{6HMdj{P0zW5dD{3P|Y z_3H14fmo2haVaexPIf&D3lKE{%p`@HYCBO%Ds!BM2L*6K8oPAw38K>YRQ^iDI-}uD zR@>za{gGv886iYHMn$Lnmwk;Ua*Ix5m)RKbrfGJ(%^MRRTt{(?lVEYw$r1h`s?5QF zEow3{oonBTUfoJlW{YFGyg>%`Yh})A+LBuzo;^Wn{t8mrEw}sp=(j6!(TA^X#Mz)R zB>n3@-iTN5SE9W8*pq+N{x!NjCb2RN?fws*{=3M1+0w#Fm)UxfqbSHq|8ZKidmTwr z<3s{aMx7q-5mqE^w2tP%7Ul@D!)-qvSIeg*qp9$RjXpdCHAsKwvCfw z9aVky!8G~vDb8Pu7w5b&rB}7`tJ6E#oPkt*G$V!YjQ9_;ag7;XfFgkW_73q}3|L)u zzo8NYW^fRCq!_rEML9=10%!hqfe~L~^W(xa_4MS)_M>rK+k%O{zPbXf9UW@0hIU~e zf2=b1!br3@Dr{K=xItR{DX~O>38two5F8aDukpR3vZ28705O*}SL1q0)}fFsp>FW* z2Mn>Aim1)>^#-bje`~^9cm6R%^~G0|1Y3m^`v=p*21Xix%A?8#F36Va-dN3jihhn9LEcRnsN`+doq@!18S zWwfM)FX!X}C=7DAMv5Yz*l0&Gjz#^B4h5Y;h%&wavOpga4Ud5CiGLu{5o&)N zS8xUAf*Pe5UP=;pL=Co0n@4l&z~al)(9yvceI1v%SKa;_|0F3sTXI#TQ%@vr>X}E< z=8C3Uu{(Z$lnRTR_otNFn%o}hXYKC0AVnrUl+EF)eo#xg>1;Y3*&-p}+q3@h>W>0bh zY~h8qGTJ&KCtK{HC3eX?GUX6{89E7zPe!_<`w$~@hYh8OI_6I3i*&kKoI1yG_@!W{ zap~f|wU=WI`vTB(3zSZnKx8XJEe?LYuvaiedhAG=6yJ=TV(R55z&UAk7|2G1*aA>t zUj%BDS_81#O2AVl52_7avo!BobVXgy7&X$uAe4dG=@H~L2LaW(xL~`Fk)oXWpawG8 zp`T}bcBjxYNGoAGWC|p!)bc3wEC0hjtzAV% zrlXSxRNQ9%76(a)`1UL|&OVUV4j0t-jfAI8Ddu#ZTpJ>HX&qAphdn`(5md;5qkcL| zH_`VOKeoc3DzrKjD>WDgLXWN(A4A+IHe4i}nbq7j7})9wU+VE@HwK zZ(XH(w~8kU01ao0k1rkNx5=3?0GIRFCl|&|;EP3wL#fRpz=kKUrx7LkvtSHy=M4NK zF@`KU{k_|s6OBNHu``+nl|7chX=ozRy{rlIyGMgt=uvjhy*U_^I{ zb}SnGssw`*V62K2P22C{fmGGKQr=`7dVcMrMVk8+OfohO`Qh^`R=Rv|DhC}PWUZ4d z75I~A$_Q+!>GrE~BSYX35b=sOD7vEBYtI4t(k4y=CJEExTCvtzb4QaV*0x-pV)Pvc zg#6R;*bQOA?`hlB={)g@%5A;{ejlWE0yWa$YCiQbpZ5rk^^uweq%fph;;g_e zmb938w7XFndmr-%pA6uV$~Mb33qXmMKS?Jq4-=o5y<0CMLHgk22r1$tnWR!;17dOu z^o1|v)rbo%dVEH&P6S%6f6LY+k6lUY|KBhnLUq&#wxD3BB?_Z@sCt{-5@_(XfE(9# zWi5k5(E|6>!WkD!Y$DsBkA0aJv^%LWIui-O9edGkTDoRV1OiQ8&V96A`k7<2^;v;z zs(PJsy|->W8-K<+o@4D5%y`NDCRbV4ha^8TmsSdjWbn7L$Rgc2f6MRF{HD3ru#>Ln z991aqNJ8s59(6PzFff!R2rfPAPPdkiuA^^r*A%qy$Z{=Sbu*wfz}Da3BT#{lG)zMZ z8|{CVVwPVUGrdS41Qcjp0rmM1bgngvy0++iOy?k!f%zg$O6^`=WqjEts8S4z1t1JT zT$$obX-4&)EW6@F(By-?xhr^D4x@NCiG$RF70vWtHY(A=bj8uDsfCq>L^3zp-2n34 z?Dze>d^w{pKjFO_;Tz7$FNQdRe8PZi8O#so6%`pF8CJcEsQnq5uS;GnRLL|}}|9vM<>i6Fh-sA`fK@=7Eb)ac79&}cL29IG~ zEEEd=79Pcp#{iGM2@>Y}I{6vS4UDbe2vyV8CUATQbVCm;ss0LGTwbApN;4{du#2gw zFn6bQndQ~c&*D?0%v58dg_21wbJ-=NWeM7u)80cWK#BmW;wm=)TZN1Qsallu2Lp%& zDkb9)+DirRKf?M11|MzDdO1LtF+Jm zH<_f~k~t^gktsh|b5W2Npja7KxQUmzcEDyGGpcH20{NOuK!gKT%zITGt-~+@ytTiO zw{KZN(zf--aI?`_OwL5Ix+W!1sYAMEt+ALZAYpPq2BqS!>&W3yB0`z;U@@GyZIXB%XI}>SPoN}l=*YxZ?m0IF! z&mjmksw|RYiR^OV+8O#`!!pQnw&!^+)FeZNKJv;Xg;s(1sGa~Ng*{|>*|BuKO+={* zb7X*58RzfEAM8PP*K?d~7y^oBk%bzt!1X!ZUNT z!00`Io)uvp&qMNW1B?D1SwPf zcguk~AMkCYcygt9sy8Ds?!7QO?;%(mxIi3QKv#-y>zDUg$K9RhwKOQ}Y>7B71(@!U zOEn$X*Knu5@D8&vu|qSszBm-Mk%i_c&>5YNZG99uXnsjA)1GM6th`zFXQ2{5!2|?G z7tkK(Xj5O!MfdDho9;|k8dkr%zl)LwMRONsSC2gDDy}9Dcura<@Ei=7ovPNK} zay#7!3B~yLqP^%r4w;>bSY?38FIUry)`~zeT42$H?UBap>lBpO%$}Dh)r6r++L2Ka ziryCguk^ViOJDz|7dP=oNfcj>L{DFtlXcazMpzxppaA;ygGEYG`x1VYQv<-t znn5bB;GJyQcAD>46+_Ej&-wHfW(iH*JnkG*z0HU&YJ`?fp~}h-Q9N|AaF85jyP(`I z%v!sVjPn5|3?e7Un1iOFWF%4`GYKt&mnTRKukBv!sF&9RAEVEDlQguox!FPLKq^<9 zUQRb;TgfoR1v{vi`<>M$)U+~IpDejAiy$ck!gXXwHMX+CrKKRWwpPJ4S=K#u6Nq>> zpc;1*yAEhVZ&#x@rg`=OXc=$Y*dRFHC6j{+uQSlMXl$Of3hXPwVUU5s+ZVETw$_=_ z8o1PFdKt4g=hoI7WOvc|Q8x#^UXLQL9Q)HZA(bXj=6XoOtBgV_YiVJW^|fztA&V2o znIm|e&&@(>(O;7nr3ON9Kkl9=b0Zs8YGec)y^UE z020F1@J(Y7(w_hh%Lx1P#T4n>nIRcH0olwdF(jC=E!F*mBMnP#C?S?Nk7-Ed2fjRk zrRt>>b|j?~Qb8lvZ1sp=Ne%MHd`sjiudLYnbWwnibLi^ z1{!GtnA9sd1f4`lIdUsam9bX|Ocp%YiDb6f|KE!eMWKi9NH5INFq@5SlwIA9yri3i zSrqa&5plD#8D7%%N4crX=`nKY>0%aSc=T?65yJs#kFDdQ2FljO~^V>0=>ejkOk zkTz2-2no+9-%DfEZSAQ8&{LqVBLbrc7?z{V8j<8M{)DpRHyd&&nDP->K!Ceup$7b% z6ve`g z_qAtBjmCb>BWuo>>hkF>Y|-L6@jbnQ((^K_v^f6V*k)m;QQQ=fl$dx>XCt-j8nKI! ztyd>sj1B)NRi0Z{zDM$ABlbh%2bk>_CllSG!WcFF2^7;3eh<8C|+W&OV{h$58 zWX`C(L6S`A@Az_=$ab*U6^XxngBIPXsA8XTT0XBSSvYE~X9v+y(pbn^@kdfs$T7!j zj@NxM>#U)byZnJH4+$U(OAOFqHd_dwA0l2?3wgF%YzuiR9Mtw6Ha|4gG1`5)G7@+L>)uOhoDvN)~bv zX91HG6HCh5mz!t~*~~4+S*&954)?Ouc>ls288^x%;%haE8f7#V=oYNp;}N(Z?tYN@ z3-Y!%Trw!)pll2SGBjSYEq#6^fxWiI7bUSm7O|4oG>mT!_`x9Ywn!b5q ziiG>_0s-HCG|e2hHvJ%h{{hyg$tl>er_@lpS<-1K3rCT`717W__Gr$mq^0m^Igt8b zp%C9GE^$~05MiH&#BsQkEeKrEBXWZXf}LbK9o1*F7f!Ugs`)w0wRMr~(xS3z3}`|0 zOistr3QvTp@Ex(Wp1$Y{IRoN1vCt6vvg`)^>IRlTbTI&y@=>R3yjoiO;@nistF(o2 zE=zgRZM@P(Gcj6IH3@EXn&QUaAGMLY_NDm;N5RM3IFrQ%a-lh0>;KBh1_p42sn}e| zg}j?KHC@8)C~F6?o%>ek1Q_ebN9pk_vu#HA*|LqXOVk7HH3vhHkse`k;U>~1HnUtV z_Cw~jew*3fZU29o16*rX(RX<-@3F~xl*w%8MjW%J2fjowE9Hn>`wxBSCNOi<9xL}R zK;pS1>+{~tw(uZH9Ee3UyUtAfi+Ndej?vpT4TB^Ng>o(zW@sRLAKkPbHI}) zot&*7jBzrpvinylRs7oLZ7ThEzcf{^$jlzb2J6EnJ=~oYKxcPFN9Qn@ ze*lqCfY{|VVwn@D5Z-*K4saLw#91q1bFt!R_7%6IAy8Pdi~Q`#O^iBXzM>+zo-(B& z+(L?`P@W0(O_)>!$m@IiX4T?S2T52G4RI`nN*3hj@fDMm{vE`lvbWW3myp4MnKL>( zq@+BC8#$Q4-H~k{B>;%~63yb1c1lk$wB67!N2sA(eHOCWD6f>5P%pMu$VCOMt+jvGzRq5%LsDYn8##+pN-^kcLe6-zx2^COtot%wQ za@jFao%fmN9t6e`qU`(<2T=aauyz=`Mn}EQ!N2kQ)1YpX^K7-!X#xOP9%KcZR{fZX z6==`g(gCTHl2QWk8KkQU70aH$WhBLS5AmMAB$3DmsED(k*hd zzR1o#gc4d;4y3tNsQh488(Gb0fuzGo+S>Lc)Yyq!UX+>o#)c(zpU&vXrC*C=uoH7ekJ83e}51ncpJV5KPF zEpn~srf4`j!UImQMAgF+h{C4tUC2H&jqG3!%2GFr2d%EVp@xbGY#?G1X*D1l$OkL-%0A{s~aIi?Dm^>OfQMhj5(*%*@K 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 diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index 04a2c0f7a8916deb9dbb5dbd14027959ad5d8f87..af374a7ef6dd0c13967c5837bfd7e762ca6a7e2e 100644 GIT binary patch delta 5056 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 delta 4455 zcmX9?c|aBA7dm2MqNYT$KstC7SbGi9X$i3EA>GIWZq0)nxdF)U1bO~0;6O9TCmMl! zF3^W<0gQ*y#xDUj?AnVqtAfc`L#G$Bfb@NE?o|W4c^W-^9?*gUyz^ly&~Azym$tU! zHVuP&`~y_f!l&0ez{_2DzbFvswHoi2#t^+Rvd0=8v z1As0Gc+yDxy;eZw8HT2n&^2%v@Yyn<`)|vEAy0)qj-7%3`U-t)hq;mGPGJQ1#oRW; zj(|lK{N*mdNktg@A`*gP6+(Qc0orLHbTMO?_Ky%5!tcUOVL=^ZKF7n3%hQCI$@hWr zg+j8|E77_NUj_LBo7xF`r-T5XM+({1`+$~$aI`~T3bH`3oql&6#n)OWJ48#dRj6>@ z3wX^ID)lYs+DzfTdj*LVi(*~7e{* zD;7}1zT&x8>2)#nH45q(@q(4-IL;JHH^ajfAiFdYj0J>fmYfH{T zFmx9m^>w2tH;Z*1=O|KVJ4W@f<7R*H&yHOv)+n8BPz{i{N+*3n*LU8db6h$N_#;o} zRM?6k8>nlSqyfPvbX}TAXxlhlw-#4<&PZKPCwkI0_^htCH&uQ&TNhyS0rv0HP0#cK z>i6lw&QryKiMogey7+vqF6mkf4|Lb1qzBT{pLMA}#Q~qL)Md0k3bdcC%g^Py@V>fI z|Hn+*xw_IM5s0{`yXN}<$T8?{4GIC=%XN3h4WlQTUZV|54(aYS)&qCu=xSq9fgg|P z{?+loM_)<~Z(gBVJtU`reE(gYG%SRcRZNsZEc{+FN(!H_7x-ed6rs`Ox9>`8O~mQH zN*h1t`^t7wf)6cUnJXoaC;$RB*fF}B9kb8BLW=I8tCU)?6=@teSs zU^`xVE*(5Dk!hG99lYrb9Q#|!&D%n)CQ5~|JfLQ+^uw!l>jR{7Ynp(sL!}b&7@y;$ zi;H4`#gTSQvPn0h8T$>BrCVE80tJJmx<*?A&|)?JAl~{~`n`f$xOG{25yOdl_PEL2z3HL1*UG&vUIfm@%Duh4fULE$ zyW+~8@QvK}f7hvv=JMbK7vM^RJj9?QYVuIqG#?;0T^@dbA2$9f`->S6gkAEexmSVR znex~r%+oeU3z7cTrW>w*q`~kQl6Fn1JK$gM=U0R^g4OrDt^CsU0(7N z-&aM;%PP*3XqLQUCW+}Q<+zO@tOrqYe45PfC9*C4U>`P_6gjb@H}JP!-Z`xbxH?fz zpUVTkdLr+SBC+p|%g55j0P+9H`FE&^qYd);dRjO>ME+w7f4`wzL1{}`l&VM~3s?_N z#dx&>Sl&-D6}$kxQ5CHv3H0+*99B^ay^54JAJ9OxxlM5#cn3JQS?QR#jjr#dxMsKk zle#K{{4^4HTN&)j*1N{03=SK?1vl(iDvpzuUpe%=w?N2@O&{Un&8iPn9K2B>YB$vh)zsvyJVgvQo(a-b+(fZ;D}QU9TjS zklB0H%H~(tDooj)Hkxg8ijsl>K(i8MM=TF)8K&%6LV^c8mGleT&||o=*N;uiHN}o` z%U`1)pH)s9k3mqMDQ5%e;rpGHAFpyBml!+R-W#Hn>?E_Q50o2oiddPhyhcHtt~?B& zC)zbBb!%5r8}Ukm-&Ww)2BqOt6A%`ucc|p|L0S49U(gdj&(*uXXb*&p)DQfHv3ISq zV_dP`GntmQ{!{N&#LD_vx!$|QS8R5Udf&7G?Ej5l>wOx)w)8!&a0zI4ne;IXUz?rv_pw8@U8 zqx65Sh-EYJw&MyP{S!U4GA-O-Db-lfA`Hzk*_1x$VQ_Hy7jPJ3Xgk`6J)@by`G^~^ zrK6#Db|{62pe5~ZHHla59VjoUBd|V4Di1= z!-&cz;P7L^xK261PaO^8vMtQt&+K?N)DWK5g4yt?VQw8&o;$=4#d?K~%MHNLiJIO}T(W=!A`Cy;T+gwhX?2E$>EXegnU}G>4-YZ)eRU}qAuLu8Tj|0y0m693zbe?f3JbvZLGSXri7)p zqxwa#j!o&Yy6sp7#VV^`wICsHgSxxE9nic~-7omE*Qjc75Z7Hzwy7m|Xz4j$JC>!W zHQ7AKD^-2a_6$etU23g+14Xw+{q2kkQ0=e&*{_~y`Muhh7(h$@HHudlf^WYy>Iyh= z5B|dFe&aYtxN4*C(-7dDb;gf!C_4Q@CSH#pk8LCdYvcjsGlD+h6;z|KD^o zbwB$Kuye1emlItb`K8Hi09}(2V;by|$00J+%!2GzD+E z&n~H&!s2=G??I;UEkutRQ+U=e7OVTsC}koK`VjDqfNF+Br>(ww7U2jD`e1X zv>`gwv~~$&<@SatwTKoDSz*e81{^Fm?O%77g=CT`zhMh-D$-QYf{Zg0P2aZuh%Pmn z3ggBwH0MplK5h_n?M;7;$^mBjn4UE7hO_fivwF29+xsN5#d8d^qLW$sgIK=X+$mkh znKRk^wmgRUAAi`~$AJqkY&7@RcVVe)Ywq7>D)YC*?D@UK$;fODc$?#RfoKkFm&(|- zF;D!2-`9;cPj>kWXuHNd^)+5I&)i6&MVfiue{%t;gL&!N$t+M0&C$(waS-WhjuE_o zq1EQ~2kV)Japp~vY^>S;I+@ce?$fm=%|`~ru-SAq=Pmk}%rni$pOM&{FYS2hs=4Hz z!l5(Md_kMWLX%{^)HW1IPBz~zq(xN6Ydn);{`EU|iu#uMS@~8rvnGr2c>wFkIg7<9 z0eI5g;#kOi-`!{FZ*#2To$Y{S!eqv1K!qjDS>WK{W0~=4iVY~SL~f^=9da%6I|h+? zf@NXWbk2BLmKC>MAc(6itC}Z3kl(Vb9XN$!`9#b5A$rb+U)pg)vL${#4-U0jw$31t zyt|g&CTga)WJ%i`4Se#Q#g@K@6VCMImc3ad;Nxj2>+H?Z>K#jU^>*g(L`!Wn^E%69 zsasCbIqlJKWijsqi#1&Ye?PgNxR;@tsp=Sk61`uljoVod>}sP;$m9Vt%e9bmEqE_@sZGjvVBuP$&CHXTMILtiAxX=cQp1U8 zx|aQQ2jH(9Ezjc&ukfzgiEm@rtZdoZ_amr&_}X#dyINryYxJ?H+NF8E?DGX$nddYT zsMjv%bm7eaE=??!)i#+M}6|DY8jgUF!f~*)LY*LIlTl)v6CZ z$~sYIRYe_dLPxDF+taXpZLN+kNW@m$-|CvSi0LI-J!UPW%I8~sHzolchFSdZ(vw8n-tus$5J zuJ@~FTQ0Z8|IGFE-qvJ+hRmz9rfg?=?s#TRZQP6@NOHGk&tNQ5GOYRKWLVeAT6q04 z;GcHZpVPT<^hs;=d1C(4F{Z<*Y(#nJDZAJiWm T-_}bw+T`@K+0j4T0{{9yCUsVd diff --git a/resources/matteloop_de.ts b/resources/matteloop_de.ts index 8cc3e8e..84435b5 100644 --- a/resources/matteloop_de.ts +++ b/resources/matteloop_de.ts @@ -30,22 +30,29 @@ Original-Videobild - + Exclusion region mode: %1 region(s); no region selected Ausschlussregion-Modus: %1 Region(en); keine Region ausgewählt + + + ; blanked before the model + ; vor dem Modell ausgeblendet + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; vollständig außerhalb des Zuschnitts - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; teilweise außerhalb des Zuschnitts - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel @@ -81,8 +88,16 @@ ExclusionControls - - + + %n region(s), blanked before the model + + %n Region, vor dem Modell ausgeblendet + %n Regionen, vor dem Modell ausgeblendet + + + + + %n region(s) %n Region @@ -276,17 +291,17 @@ Arbeitsbereiche verwalten… - + Reset to defaults Auf Standardwerte zurücksetzen - + Reset inspector parameters Inspector-Parameter zurücksetzen - + Compute acceleration, transform, output directory, and output filename are not affected. Beschleunigung, Transformation, Ausgabeordner und Dateiname bleiben unverändert. @@ -371,49 +386,59 @@ Ausgabeordner auswählen - + No region selected Keine Region ausgewählt - + Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel; vollständig außerhalb des Zuschnitts - + Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel; teilweise außerhalb des Zuschnitts - + Selected region: x %1, y %2, width %3, height %4 source pixels Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel - + Edit Bearbeiten - - + + Edit exclusion regions Ausschlussregionen bearbeiten - + Clear Zurücksetzen - + Clear exclusion regions Ausschlussregionen löschen - + + Blank before the model + Vor dem Modell ausblenden + + + + Re-segments the clip: the stored cut set is not reused + Der Clip wird neu segmentiert: Der gespeicherte Schnitt wird nicht wiederverwendet + + + Selected exclusion region Ausgewählte Ausschlussregion @@ -2983,7 +3008,7 @@ in %1; %2; %3; %4 bei %5; %6; erstellt %7; Zweck: %8; Lizenz: %9; %10 - + unknown time unbekannte Zeit diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index 43968717389d88fec7fcb946b2b20892ed642d5e..3935733dbffcb33e9cfd96eb8785006138c28a35 100644 GIT binary patch delta 4974 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 delta 4449 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 diff --git a/resources/matteloop_en.ts b/resources/matteloop_en.ts index 43c94c9..3465b68 100644 --- a/resources/matteloop_en.ts +++ b/resources/matteloop_en.ts @@ -30,22 +30,29 @@ Original video frame - + Exclusion region mode: %1 region(s); no region selected Exclusion region mode: %1 region(s); no region selected + + + ; blanked before the model + ; blanked before the model + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels @@ -81,8 +88,16 @@ ExclusionControls - - + + %n region(s), blanked before the model + + %n region(s), blanked before the model + %n region(s), blanked before the model + + + + + %n region(s) %n region @@ -276,17 +291,17 @@ Manage Workspaces… - + Reset to defaults Reset to defaults - + Reset inspector parameters Reset inspector parameters - + Compute acceleration, transform, output directory, and output filename are not affected. Compute acceleration, transform, output directory, and output filename are not affected. @@ -371,49 +386,59 @@ Choose output directory - + No region selected No region selected - + Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop - + Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop - + Selected region: x %1, y %2, width %3, height %4 source pixels Selected region: x %1, y %2, width %3, height %4 source pixels - + Edit Edit - - + + Edit exclusion regions Edit exclusion regions - + Clear Clear - + Clear exclusion regions Clear exclusion regions - + + Blank before the model + Blank before the model + + + + Re-segments the clip: the stored cut set is not reused + Re-segments the clip: the stored cut set is not reused + + + Selected exclusion region Selected exclusion region @@ -2983,7 +3008,7 @@ into %1; %2; %3; %4 at %5; %6; created %7; purpose: %8; licence: %9; %10 - + unknown time unknown time diff --git a/scripts/screenshots.py b/scripts/screenshots.py index 9526f1f..260cac2 100644 --- a/scripts/screenshots.py +++ b/scripts/screenshots.py @@ -125,6 +125,7 @@ def _state(metadata: object, source_frame: QImage, result_frame: QImage) -> AppS model_id=_MODEL_ID, output_directory=_OUTPUT_DIRECTORY, exclusions=(CropSpec(560, 32, 150, 88),), + exclusions_before_model=True, ) ), SourceLoadRequested(_SOURCE_ID, _LOAD_REQUEST_ID), diff --git a/src/matteloop/ui/crop_presentation.py b/src/matteloop/ui/crop_presentation.py index 9237738..1a3bc2a 100644 --- a/src/matteloop/ui/crop_presentation.py +++ b/src/matteloop/ui/crop_presentation.py @@ -19,6 +19,7 @@ class CropPresentation: pixel_aspect: float crop: CropSpec exclusions: tuple[CropSpec, ...] = () + exclusions_before_model: bool = False def present_crop(state: AppState) -> CropPresentation | None: @@ -62,4 +63,5 @@ def present_crop(state: AppState) -> CropPresentation | None: aspect, state.crop, state.parameters.exclusions, + state.parameters.exclusions_before_model, ) diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index 5c3c522..6f8bc90 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -6,6 +6,7 @@ from PySide6.QtCore import QCoreApplication, QPoint, QPointF, QRectF, Qt, Signal from PySide6.QtGui import ( + QBrush, QColor, QContextMenuEvent, QKeyEvent, @@ -177,9 +178,7 @@ def _paint_crop_outline(self, painter: QPainter, crop: QRectF) -> None: def _paint_exclusions( self, painter: QPainter, geometry: InteractionGeometry ) -> None: - effective_fill = QColor("#E5484D") - effective_fill.setAlpha(90) - effective_pen = QPen(QColor("#E5484D"), 1) + effective_brush, effective_pen = self._effective_exclusion_style() ineffective_fill = QColor("#E5484D") ineffective_fill.setAlpha(32) ineffective_pen = QPen( @@ -201,7 +200,7 @@ def _paint_exclusions( self._paint_exclusion_rect( painter, effective_rect, - fill=effective_fill, + fill=effective_brush, pen=effective_pen, ) continue @@ -218,16 +217,30 @@ def _paint_exclusions( self._paint_exclusion_rect( painter, effective_rect, - fill=effective_fill, + fill=effective_brush, pen=effective_pen, ) + def _effective_exclusion_style(self) -> tuple[QColor | QBrush, QPen]: + effective_fill = QColor("#E5484D") + effective_fill.setAlpha(90) + effective_pen = QPen(QColor("#E5484D"), 1) + presentation = self._presentation + if presentation is not None and presentation.exclusions_before_model: + effective_brush: QColor | QBrush = QBrush( + effective_fill, Qt.BrushStyle.BDiagPattern + ) + effective_pen = QPen(QColor("#E5484D"), 2) + else: + effective_brush = effective_fill + return effective_brush, effective_pen + @staticmethod def _paint_exclusion_rect( painter: QPainter, rect: QRectF, *, - fill: QColor | None, + fill: QColor | QBrush | None, pen: QPen, ) -> None: painter.setBrush(fill if fill is not None else Qt.BrushStyle.NoBrush) @@ -701,19 +714,30 @@ def _announce_crop(self) -> None: if presentation is None: return self._emit_exclusion_selection() - index = self._selected_exclusion - if self._exclusion_edit and ( - index is None or index >= len(presentation.exclusions) - ): + if self._exclusion_edit: + self._announce_exclusion_crop(presentation) + return + super()._announce_crop() + if presentation.exclusions_before_model: self.setAccessibleDescription( - QCoreApplication.translate( - "CropCanvas", - "Exclusion region mode: %1 region(s); no region selected", - ).replace("%1", str(len(presentation.exclusions))) + self.accessibleDescription() + + QCoreApplication.translate( + "CropCanvas", "; blanked before the model" + ) ) - return - if not self._exclusion_edit: - super()._announce_crop() + + def _announce_exclusion_crop(self, presentation: CropPresentation) -> None: + index = self._selected_exclusion + if index is None or index >= len(presentation.exclusions): + description = QCoreApplication.translate( + "CropCanvas", + "Exclusion region mode: %1 region(s); no region selected", + ).replace("%1", str(len(presentation.exclusions))) + if presentation.exclusions_before_model: + description += QCoreApplication.translate( + "CropCanvas", "; blanked before the model" + ) + self.setAccessibleDescription(description) return assert index is not None crop = self._edited_rect() @@ -746,6 +770,10 @@ def _announce_crop(self) -> None: ) for number, value in enumerate(values, start=1): text = text.replace(f"%{number}", str(value)) + if presentation.exclusions_before_model: + text += QCoreApplication.translate( + "CropCanvas", "; blanked before the model" + ) self.setAccessibleDescription(text) def _emit_exclusion_selection(self) -> None: diff --git a/src/matteloop/ui/exclusion_controls.py b/src/matteloop/ui/exclusion_controls.py index 6c399f3..73b39e9 100644 --- a/src/matteloop/ui/exclusion_controls.py +++ b/src/matteloop/ui/exclusion_controls.py @@ -4,6 +4,7 @@ from PySide6.QtCore import QCoreApplication, Qt, Signal from PySide6.QtWidgets import ( + QCheckBox, QHBoxLayout, QLabel, QSizePolicy, @@ -13,7 +14,10 @@ ) from matteloop.core.exclusion import cut_exclusions -from matteloop.core.parameters import ExclusionsChanged +from matteloop.core.parameters import ( + ExclusionsBeforeModelChanged, + ExclusionsChanged, +) from matteloop.core.specs import CropSpec from matteloop.ui.parameter_presentation import ParameterPresentation @@ -33,16 +37,34 @@ def __init__(self, parent: QWidget | None = None) -> None: self.clear_button.clicked.connect( lambda: self.command_requested.emit(ExclusionsChanged(())) ) + self.before_model_checkbox.toggled.connect( + lambda enabled: self.command_requested.emit( + ExclusionsBeforeModelChanged(enabled) + ) + ) def apply(self, presentation: ParameterPresentation, editable: bool) -> None: """Render the region count and current source editability.""" count = len(presentation.exclusions) - count_text = self.tr("%n region(s)", "", count) + if presentation.exclusions_before_model: + count_text = self.tr( + "%n region(s), blanked before the model", "", count + ) + else: + count_text = self.tr("%n region(s)", "", count) self.count_label.setText(count_text) self.count_label.setAccessibleDescription(count_text) available = editable and presentation.duration is not None self.edit_button.setEnabled(available) self.clear_button.setEnabled(available and count > 0) + self.before_model_checkbox.setEnabled(available and count > 0) + blocked = self.before_model_checkbox.blockSignals(True) + try: + self.before_model_checkbox.setChecked( + presentation.exclusions_before_model + ) + finally: + self.before_model_checkbox.blockSignals(blocked) if not available and self.edit_button.isChecked(): self.edit_button.setChecked(False) @@ -73,7 +95,11 @@ def _format_selection(template: str, exclusion: CropSpec) -> str: def tab_widgets(self) -> tuple[QWidget, ...]: """Return the row's keyboard controls in visual order.""" - return (self.edit_button, self.clear_button) + return ( + self.edit_button, + self.clear_button, + self.before_model_checkbox, + ) def _build_widgets(self) -> None: self.edit_button = QToolButton() @@ -92,6 +118,19 @@ def _build_widgets(self) -> None: self.clear_button.setAccessibleName( QCoreApplication.translate("Inspector", "Clear exclusion regions") ) + self.before_model_checkbox = QCheckBox( + QCoreApplication.translate("Inspector", "Blank before the model") + ) + self.before_model_checkbox.setObjectName("exclusion_before_model") + self.before_model_checkbox.setSizePolicy( + QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred + ) + cost = QCoreApplication.translate( + "Inspector", + "Re-segments the clip: the stored cut set is not reused", + ) + self.before_model_checkbox.setToolTip(cost) + self.before_model_checkbox.setAccessibleDescription(cost) self.count_label = QLabel() self.count_label.setObjectName("exclusion_count") self.count_label.setProperty("secondary", True) @@ -113,6 +152,7 @@ def _build_widgets(self) -> None: self.set_selected_exclusion(None, None) self.edit_button.setEnabled(False) self.clear_button.setEnabled(False) + self.before_model_checkbox.setEnabled(False) def _build_layout(self) -> None: layout = QVBoxLayout(self) @@ -124,6 +164,7 @@ def _build_layout(self) -> None: actions.addWidget(self.edit_button) actions.addWidget(self.clear_button) layout.addLayout(actions) + layout.addWidget(self.before_model_checkbox) layout.addWidget(self.count_label) layout.addWidget(self.selected_readout) diff --git a/src/matteloop/ui/inspector_reset.py b/src/matteloop/ui/inspector_reset.py index 3a170da..ad9aa43 100644 --- a/src/matteloop/ui/inspector_reset.py +++ b/src/matteloop/ui/inspector_reset.py @@ -25,6 +25,10 @@ def can_reset_parameters(presentation: ParameterPresentation) -> bool: (presentation.padding, defaults.padding), (presentation.stretch_x, defaults.stretch_x), (presentation.exclusions, defaults.exclusions), + ( + presentation.exclusions_before_model, + defaults.exclusions_before_model, + ), (presentation.max_mib, defaults.max_mib), ) ): diff --git a/src/matteloop/ui/parameter_presentation.py b/src/matteloop/ui/parameter_presentation.py index a88680d..e3ea84c 100644 --- a/src/matteloop/ui/parameter_presentation.py +++ b/src/matteloop/ui/parameter_presentation.py @@ -26,6 +26,7 @@ class ParameterPresentation: padding: int stretch_x: Decimal exclusions: tuple[CropSpec, ...] + exclusions_before_model: bool output_directory: Path | None output_filename: str max_mib: Decimal @@ -64,6 +65,7 @@ def present_parameters(state: AppState) -> ParameterPresentation: padding=parameters.padding, stretch_x=parameters.stretch_x, exclusions=parameters.exclusions, + exclusions_before_model=parameters.exclusions_before_model, output_directory=directory, output_filename=filename, max_mib=parameters.max_mib, diff --git a/src/matteloop/ui/preferences.py b/src/matteloop/ui/preferences.py index 7401054..310c752 100644 --- a/src/matteloop/ui/preferences.py +++ b/src/matteloop/ui/preferences.py @@ -21,6 +21,7 @@ "padding", "stretch_x", "exclusions", + "exclusions_before_model", "output_directory", "output_filename", "max_mib", @@ -63,6 +64,9 @@ def persist_parameters(settings: QSettings, parameters: ParameterState) -> None: for e in parameters.exclusions ), ) + settings.setValue( + f"{_PREFIX}exclusions_before_model", parameters.exclusions_before_model + ) if parameters.output_directory is None: settings.remove(f"{_PREFIX}output_directory") else: diff --git a/src/matteloop/ui/request_builder.py b/src/matteloop/ui/request_builder.py index 7a3e0ae..38831b3 100644 --- a/src/matteloop/ui/request_builder.py +++ b/src/matteloop/ui/request_builder.py @@ -95,6 +95,11 @@ def _render_request( model_id=parameters.model_id, edge_mode=parameters.edge_mode, execution_provider=parameters.execution_provider, + exclusions=( + parameters.exclusions + if parameters.exclusions_before_model + else () + ), ), framing=FramingSpec( trim=parameters.trim, diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index 586936a..88a8637 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -19,6 +19,7 @@ def _presentation( crop: CropSpec = CropSpec(10, 10, 40, 20), exclusions: tuple[CropSpec, ...] = (), + exclusions_before_model: bool = False, ) -> CropPresentation: return CropPresentation( source_id="source", @@ -30,6 +31,7 @@ def _presentation( pixel_aspect=1, crop=crop, exclusions=exclusions, + exclusions_before_model=exclusions_before_model, ) @@ -733,6 +735,45 @@ def test_selected_exclusion_announces_when_crop_does_not_apply( assert canvas.accessibleDescription().endswith(f"; {status}") +def test_model_exclusions_are_painted_hatched_and_announced(qtbot) -> None: + region = CropSpec(20, 10, 30, 20) + canvas = _canvas(qtbot) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation( + exclusions=(region,), exclusions_before_model=True + ), + active=True, + editable=True, + ) + canvas.show() + canvas.set_exclusion_edit(True) + qtbot.wait(10) + + image = canvas.grab().toImage() + assert canvas._geometry is not None # noqa: SLF001 + rect = canvas._widget_rect(canvas._geometry, region) # noqa: SLF001 + left = round(rect.left()) + right = round(rect.right()) + top = round(rect.top()) + bottom = round(rect.bottom()) + colors = { + image.pixelColor(x, y).rgba() + for x in range(left + 2, right - 2) + for y in range(top + 2, bottom - 2) + } + + assert len(colors) > 1 + assert any( + (color := image.pixelColor(x, y)).red() > color.green() + for x in range(left + 2, right - 2) + for y in range(top + 2, bottom - 2) + ) + assert canvas.accessibleDescription().endswith("; blanked before the model") + + def test_crop_canvas_keyboard_moves_overlay_by_one_source_pixel(qtbot) -> None: canvas = _canvas(qtbot) events: list[object] = [] diff --git a/tests/ui/test_parameter_inspector.py b/tests/ui/test_parameter_inspector.py index e2d6b64..40d79c6 100644 --- a/tests/ui/test_parameter_inspector.py +++ b/tests/ui/test_parameter_inspector.py @@ -1,5 +1,6 @@ from __future__ import annotations +from dataclasses import replace from decimal import Decimal from fractions import Fraction from pathlib import Path @@ -8,7 +9,12 @@ from PySide6.QtCore import QSettings, Qt from PySide6.QtWidgets import QAbstractSpinBox, QComboBox -from matteloop.core.parameters import ExclusionsChanged, ParametersReset, ParameterState +from matteloop.core.parameters import ( + ExclusionsBeforeModelChanged, + ExclusionsChanged, + ParametersReset, + ParameterState, +) from matteloop.core.specs import CropSpec, EdgeMode, TransformSpec from matteloop.core.state import AppState, SourceState from matteloop.core.timeline import TimelineState @@ -305,6 +311,68 @@ def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: assert controls.count_label.text() == "0 region(s)" +def test_before_model_checkbox_dispatches_and_is_inert_without_regions(qtbot) -> None: + inspector = Inspector(_settings()) + qtbot.addWidget(inspector) + empty = AppState( + source=SourceState.READY, + source_id="source", + source_value=object(), + timeline=TimelineState(Fraction(4), Fraction(0), Fraction(4), Fraction(0)), + ) + inspector.apply_parameters(present_parameters(empty), editable=True) + commands: list[object] = [] + inspector.command_requested.connect(commands.append) + + checkbox = inspector.exclusion_controls.before_model_checkbox + assert not checkbox.isEnabled() + checkbox.click() + assert commands == [] + + region = CropSpec(10, 10, 20, 20) + with_region = replace( + empty, + parameters=replace(empty.parameters, exclusions=(region,)), + ) + inspector.apply_parameters(present_parameters(with_region), editable=True) + assert checkbox.isEnabled() + checkbox.click() + assert commands == [ExclusionsBeforeModelChanged(True)] + + enabled = replace( + with_region, + parameters=replace( + with_region.parameters, exclusions_before_model=True + ), + ) + inspector.apply_parameters(present_parameters(enabled), editable=True) + assert checkbox.isChecked() + assert inspector.exclusion_controls.count_label.text() == ( + "1 region(s), blanked before the model" + ) + + +def test_before_model_count_label_names_the_blank(qtbot) -> None: + inspector = Inspector(_settings()) + qtbot.addWidget(inspector) + state = AppState( + source=SourceState.READY, + source_id="source", + source_value=object(), + parameters=ParameterState( + exclusions=(CropSpec(10, 10, 20, 20),), + exclusions_before_model=True, + ), + timeline=TimelineState(Fraction(4), Fraction(0), Fraction(4), Fraction(0)), + ) + + inspector.apply_parameters(present_parameters(state), editable=True) + + assert inspector.exclusion_controls.count_label.text() == ( + "1 region(s), blanked before the model" + ) + + def test_reset_is_enabled_when_exclusion_regions_differ_from_defaults(qtbot) -> None: inspector = Inspector(_settings()) qtbot.addWidget(inspector) diff --git a/tests/ui/test_parameter_persistence.py b/tests/ui/test_parameter_persistence.py index cd99214..974600c 100644 --- a/tests/ui/test_parameter_persistence.py +++ b/tests/ui/test_parameter_persistence.py @@ -78,6 +78,19 @@ def test_parameter_preferences_round_trip_as_qsettings_primitives() -> None: assert actual == expected +def test_exclusions_before_model_persists_as_a_bool() -> None: + settings = _settings() + expected = ParameterState( + exclusions=(CropSpec(8, 9, 40, 50),), + exclusions_before_model=True, + ) + + persist_parameters(settings, expected) + + assert settings.value("parameters/exclusions_before_model") is True + assert load_parameters(settings).exclusions_before_model is True + + def test_persist_parameters_writes_no_transform_key() -> None: settings = _settings() non_identity = ParameterState( diff --git a/tests/ui/test_parameter_presentation.py b/tests/ui/test_parameter_presentation.py index 49fee4a..a014eec 100644 --- a/tests/ui/test_parameter_presentation.py +++ b/tests/ui/test_parameter_presentation.py @@ -72,12 +72,19 @@ def test_parameter_and_crop_presentations_carry_exclusion_regions() -> None: ready = reduce(loading, SourceLoaded("source", "load", Metadata(source))) region = CropSpec(10, 20, 30, 40) state = replace( - ready, parameters=replace(ready.parameters, exclusions=(region,)) + ready, + parameters=replace( + ready.parameters, + exclusions=(region,), + exclusions_before_model=True, + ), ) parameter_presentation = present_parameters(state) crop_presentation = present_crop(state) assert parameter_presentation.exclusions == (region,) + assert parameter_presentation.exclusions_before_model is True assert crop_presentation is not None assert crop_presentation.exclusions == (region,) + assert crop_presentation.exclusions_before_model is True diff --git a/tests/ui/test_parameter_requests.py b/tests/ui/test_parameter_requests.py index 7551028..47569f2 100644 --- a/tests/ui/test_parameter_requests.py +++ b/tests/ui/test_parameter_requests.py @@ -1,6 +1,6 @@ from __future__ import annotations -from dataclasses import dataclass +from dataclasses import dataclass, replace from decimal import Decimal from fractions import Fraction from pathlib import Path @@ -49,6 +49,7 @@ def test_preview_and_render_requests_share_every_inspector_parameter() -> None: assert request.segmentation.model_id == parameters.model_id assert request.segmentation.edge_mode is parameters.edge_mode assert request.segmentation.execution_provider == parameters.execution_provider + assert request.segmentation.exclusions == () assert request.framing.trim is parameters.trim assert request.framing.alpha_threshold == parameters.alpha_threshold assert request.framing.padding == parameters.padding @@ -58,6 +59,13 @@ def test_preview_and_render_requests_share_every_inspector_parameter() -> None: assert request.output.max_bytes == int(Decimal("12.5") * 1024 * 1024) assert request.transform == transform + enabled = replace(parameters, exclusions_before_model=True) + enabled_request = _render_request( + _preview_inputs(Metadata(source), timeline, parameters=enabled) + ) + assert enabled_request.segmentation.exclusions == enabled.exclusions + assert enabled_request.framing.exclusions == enabled.exclusions + def timeline_to_sampling(timeline: TimelineState): from matteloop.core.specs import SamplingSpec From fd87af9c473dc5ccf87d624570917ad34af1d30b Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 16:34:01 +0200 Subject: [PATCH 21/21] =?UTF-8?q?=E2=9A=99=EF=B8=8F=20config(guardrails):?= =?UTF-8?q?=20allow=20the=20pre-model=20call=20site?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ⚙️ `jobs/render.py` 2886 to 2889 lines. `_produce_cut_frame` gains the two halves of the pre-model path: `blank_model_input` on the cropped frame before it reaches the model, and `exclude_alpha` on the result, because rembg composites the input RGB back into what it returns. Both have to sit between the crop and the model call, and both are in that function. - ⚙️ Raised by hand for this one entry rather than with `--update`, which would also record unrelated drift in four modules that shrank since the baseline was written. Refs #80 --- scripts/guardrails-baseline.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/guardrails-baseline.json b/scripts/guardrails-baseline.json index bf1087a..f23e809 100644 --- a/scripts/guardrails-baseline.json +++ b/scripts/guardrails-baseline.json @@ -24,7 +24,7 @@ "long_functions": 1 }, "src/matteloop/jobs/render.py": { - "lines": 2886, + "lines": 2889, "long_functions": 11 }, "src/matteloop/jobs/segmentation_host.py": {

B)Ph&jk6!|3jg(6KPHi!i1}+u%(If3Z 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%0Dp`_BImi>%Ds8YIYJ1`cVcw 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 z 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 diff --git a/scripts/screenshots.py b/scripts/screenshots.py index 24ac54c..9526f1f 100644 --- a/scripts/screenshots.py +++ b/scripts/screenshots.py @@ -29,6 +29,7 @@ from PySide6.QtWidgets import QApplication, QStyleFactory, QWidget from matteloop.core.parameters import ParameterState +from matteloop.core.specs import CropSpec from matteloop.core.state import ( AppState, PreviewRequested, @@ -123,6 +124,7 @@ def _state(metadata: object, source_frame: QImage, result_frame: QImage) -> AppS parameters=ParameterState( model_id=_MODEL_ID, output_directory=_OUTPUT_DIRECTORY, + exclusions=(CropSpec(560, 32, 150, 88),), ) ), SourceLoadRequested(_SOURCE_ID, _LOAD_REQUEST_ID), From 75fad6fec5b935f2840be803b210f22c41c28fa3 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 10:59:07 +0200 Subject: [PATCH 08/21] =?UTF-8?q?=F0=9F=90=9B=20fix(exclusions):=20preserv?= =?UTF-8?q?e=20raw=20region=20edits?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - `_reduce_exclusions` returned the original state whenever the old and new regions produced identical effective cut boxes, which threw the raw tuple away with the recomputation. A region lying outside the current crop could therefore not be cleared at all — Clear emitted `ExclusionsChanged(())`, both effective sets were empty, and the reducer ignored it. Deleting one of two effectively identical regions and reordering regions failed the same way, and a region moved outside the crop vanished on release although the design requires it to stay painted. Every valid tuple is now stored; the effective boxes decide only whether the preview is invalidated. - With `crop is None` the tuple is stored without invalidation, because there is no preview to invalidate. - `SourceLoaded` clipped carried regions into `state.parameters`, but settings were written only through `_dispatch_parameter`, so the clipped value never reached disk: quitting without touching another control restored the old region on restart, while touching any unrelated control wrote the clipped tuple and made the loss permanent. `_source_loaded` now persists the reduced parameters, so what is saved no longer depends on what else the user happened to change. - 🧪 Tests: - Five tests asserted something other than their name and passed with their production code reverted. The worst is the one that should have caught the defect above: `test_exclusion_controls_toggle_edit_mode_and _clear_regions` checked only that Clear emitted a command and never sent it through the reducer, so it stayed green while Clear did nothing. It now routes Clear through the reducer and asserts the tuple is empty. - `test_region_mode_gives_the_crop_no_hit_targets` clicked without moving, so it would have passed with crop dragging still enabled; it now drags. `test_leaving_region_mode_restores_crop_handles_and_keeps _painting_regions` checked geometry keys that exist in both modes; it now checks rendered pixels. `test_render_peak_rgba_owner_count_is_unchanged_by_exclusions` had no unexcluded baseline; it now compares one and checks the stored cuts, the output alpha and the union bounds. `test_malformed_exclusions_preference_falls_back_to_empty_regions` passed even if the setting was never read, because the default is already empty; it now proves the setting is read first. - A new test crosses settings, `SourceLoaded` clipping and restart, the path the persistence defect lived on. - The gesture contract is now asserted on every path that can mutate a region, not only the drag: resize and rubber band emit once on release and never per pointer move, and keyboard nudge, delete and Clear each emit once. Trigger: repro — draw an exclusion region outside the current crop, press Clear, and observe that nothing happens. Refs #80 --- src/matteloop/core/parameters.py | 7 +- src/matteloop/ui/controller.py | 4 ++ tests/core/test_parameters.py | 7 +- tests/jobs/test_render.py | 20 +++++- tests/ui/test_crop_canvas.py | 99 +++++++++++++++++++++++--- tests/ui/test_parameter_inspector.py | 15 +++- tests/ui/test_parameter_persistence.py | 70 +++++++++++++++++- 7 files changed, 202 insertions(+), 20 deletions(-) diff --git a/src/matteloop/core/parameters.py b/src/matteloop/core/parameters.py index 55f5f7c..d4db4bf 100644 --- a/src/matteloop/core/parameters.py +++ b/src/matteloop/core/parameters.py @@ -387,14 +387,17 @@ def _reduce_exclusions(state: AppState, event: ExclusionsChanged) -> AppState: not isinstance(exclusion, CropSpec) for exclusion in event.exclusions ): return state + updated = replace(state.parameters, exclusions=event.exclusions) + if updated == state.parameters: + return state crop = state.crop if crop is None or cut_exclusions(event.exclusions, crop) == cut_exclusions( state.parameters.exclusions, crop ): - return state + return replace(state, parameters=updated) return _invalidate( state, - replace(state.parameters, exclusions=event.exclusions), + updated, PreviewInvalidationReason.CROP_CLEANUP, ) diff --git a/src/matteloop/ui/controller.py b/src/matteloop/ui/controller.py index 724b3b4..ecd9573 100644 --- a/src/matteloop/ui/controller.py +++ b/src/matteloop/ui/controller.py @@ -441,6 +441,7 @@ def _source_loaded( _as_app_error(TypeError("source adapter returned an invalid result")), ) return + before = self._store.state self._store.dispatch( SourceLoaded( source_id, @@ -449,6 +450,9 @@ def _source_loaded( loaded.frame, ) ) + after = self._store.state + if after is not before and self._settings is not None: + persist_parameters(self._settings, after.parameters) @Slot(str, str, object) def _source_failed(self, source_id: str, request_id: str, error: object) -> None: diff --git a/tests/core/test_parameters.py b/tests/core/test_parameters.py index d6f1dc4..36d8b7c 100644 --- a/tests/core/test_parameters.py +++ b/tests/core/test_parameters.py @@ -175,7 +175,12 @@ def test_moving_a_region_outside_the_crop_does_not_invalidate_the_preview() -> N ), ) - assert reduce(state, ExclusionsChanged((CropSpec(1, 1, 8, 8),))) is state + changed = reduce(state, ExclusionsChanged((CropSpec(1, 1, 8, 8),))) + + assert changed is not state + assert changed.parameters.exclusions == (CropSpec(1, 1, 8, 8),) + assert changed.preview is state.preview + assert changed.stale_category is state.stale_category def test_output_fps_changes_sampling_and_stales_the_current_preview() -> None: diff --git a/tests/jobs/test_render.py b/tests/jobs/test_render.py index fd3cceb..9a35124 100644 --- a/tests/jobs/test_render.py +++ b/tests/jobs/test_render.py @@ -1550,6 +1550,14 @@ def test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_the_region def test_render_peak_rgba_owner_count_is_unchanged_by_exclusions(tmp_path) -> None: + baseline_path = tmp_path / "baseline" + baseline_path.mkdir() + baseline_request = request(baseline_path) + baseline_request.source.write_bytes(b"baseline-video") + baseline = render_service(encoder=FakeEncoder()).render( + baseline_request, + job(baseline_path, "unexcluded-owners", JobKind.RENDER), + ) encoder = FakeEncoder() render_request = replace( request(tmp_path), @@ -1566,8 +1574,16 @@ def test_render_peak_rgba_owner_count_is_unchanged_by_exclusions(tmp_path) -> No render_request, job(tmp_path, "excluded-owners", JobKind.RENDER) ) - assert artifact.ownership_peak <= 3 - assert artifact.ownership_current == 0 + assert artifact.ownership_peak == baseline.ownership_peak + assert artifact.ownership_current == baseline.ownership_current == 0 + with artifact.cut_workspace.read_promoted_cut(0) as stored: + assert stored.getpixel((40, 30)) == (0, 60, 90, 255) + with Image.open(artifact.output_path) as output: + output.seek(0) + output.load() + assert output.getpixel((40, 30)) == (0, 0, 0, 0) + assert artifact.manifest.union_metadata is not None + assert artifact.manifest.union_metadata.bounds == (64, 24, 96, 104) def test_render_with_trim_and_an_empty_mask_encodes_the_untrimmed_canvas_and_notes_it( diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index 7f826c9..6773fee 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -2,7 +2,7 @@ import pytest from PySide6.QtCore import QPoint, Qt -from PySide6.QtGui import QImage +from PySide6.QtGui import QColor, QImage from matteloop.core.crop_state import CropChanged from matteloop.core.geometry import MediaTransform, PointF @@ -129,7 +129,11 @@ def test_region_mode_rubber_band_adds_a_region_on_release(qtbot) -> None: Qt.MouseButton.LeftButton, pos=_source_pos(canvas, 10, 10), ) - qtbot.mouseMove(canvas, _source_pos(canvas, 30, 25)) + for x in range(11, 31): + y = round(10 + (x - 10) * 15 / 20) + qtbot.mouseMove(canvas, _source_pos(canvas, x, y)) + + assert events == [] qtbot.mouseRelease( canvas, Qt.MouseButton.LeftButton, @@ -171,14 +175,33 @@ def test_region_mode_gives_the_crop_no_hit_targets(qtbot) -> None: events: list[object] = [] canvas.command_requested.connect(events.append) - qtbot.mouseClick( + qtbot.mousePress( canvas, Qt.MouseButton.LeftButton, pos=_source_pos(canvas, 10, 10), ) + for x in range(11, 31): + y = round(10 + (x - 10) * 15 / 20) + qtbot.mouseMove(canvas, _source_pos(canvas, x, y)) assert events == [] assert canvas._dragged is None + assert canvas._rubber_start is not None + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 30, 25), + ) + + assert events == [ + ExclusionsChanged( + ( + CropSpec(70, 30, 20, 10), + CropSpec(10, 10, 20, 15), + ) + ) + ] + assert canvas._dragged is None def test_click_selects_a_region_and_the_same_drag_moves_it(qtbot) -> None: @@ -207,6 +230,39 @@ def test_click_selects_a_region_and_the_same_drag_moves_it(qtbot) -> None: assert events == [ExclusionsChanged((CropSpec(30, 10, 30, 20),))] +def test_resizing_a_region_dispatches_exactly_once_on_release(qtbot) -> None: + canvas = _canvas(qtbot) + region = CropSpec(20, 10, 30, 20) + canvas.apply_presentation( + _presentation(exclusions=(region,)), active=True, editable=True + ) + canvas.set_exclusion_edit(True) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 50, 20), + ) + for x in range(51, 61): + qtbot.mouseMove(canvas, _source_pos(canvas, x, 20)) + + assert events == [] + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 60, 20), + ) + + assert events == [ExclusionsChanged((CropSpec(20, 10, 40, 20),))] + + def test_delete_removes_the_selected_region(qtbot) -> None: canvas = _canvas(qtbot) canvas.apply_presentation( @@ -264,23 +320,46 @@ def test_leaving_region_mode_restores_crop_handles_and_keeps_painting_regions( canvas.apply_presentation( _presentation(exclusions=(region,)), active=True, editable=True ) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#123456")) + canvas.set_frame(frame) canvas.set_exclusion_edit(True) + qtbot.wait(10) + region_mode_image = canvas.grab().toImage() + assert canvas._geometry is not None + handle = canvas._geometry.visual["north_west"] + handle_box = ( + max(0, round(handle.left)), + max(0, round(handle.top)), + min(region_mode_image.width(), round(handle.right)), + min(region_mode_image.height(), round(handle.bottom)), + ) + + def accent_pixels(image: QImage) -> int: + accent = QColor("#B7F34A").rgba() + return sum( + image.pixelColor(x, y).rgba() == accent + for x in range(handle_box[0], handle_box[2] + 1) + for y in range(handle_box[1], handle_box[3] + 1) + ) + + region_point = _source_pos(canvas, 35, 20) + region_pixel = region_mode_image.pixelColor(region_point) + assert accent_pixels(region_mode_image) == 0 + qtbot.mouseClick( canvas, Qt.MouseButton.LeftButton, pos=_source_pos(canvas, 25, 15), ) canvas.set_exclusion_edit(False) + qtbot.wait(10) + crop_mode_image = canvas.grab().toImage() assert canvas._selected_exclusion is None assert canvas._painted_exclusions() == (region,) - assert canvas._geometry is not None - assert set(canvas._geometry.visual) >= { - "crop", - "north_west", - "north", - "north_east", - } + assert accent_pixels(crop_mode_image) > 0 + assert crop_mode_image.pixelColor(region_point) == region_pixel def test_region_mode_announces_the_selected_region_bounds(qtbot) -> None: diff --git a/tests/ui/test_parameter_inspector.py b/tests/ui/test_parameter_inspector.py index 2c4ecba..db2abc9 100644 --- a/tests/ui/test_parameter_inspector.py +++ b/tests/ui/test_parameter_inspector.py @@ -264,13 +264,22 @@ def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: inspector = Inspector(_settings()) qtbot.addWidget(inspector) state = AppState( + source=SourceState.READY, + source_id="source", + source_value=object(), parameters=ParameterState(exclusions=(CropSpec(10, 10, 20, 20),)), timeline=TimelineState(Fraction(4), Fraction(0), Fraction(4), Fraction(0)), ) - inspector.apply_parameters(present_parameters(state), editable=True) + store = ReducerStore(state) + controller = SourceController.__new__(SourceController) + controller._store = store + controller._settings = None + controller._closed = False + inspector.apply_parameters(present_parameters(store.state), editable=True) commands: list[object] = [] modes: list[bool] = [] inspector.command_requested.connect(commands.append) + inspector.command_requested.connect(controller.dispatch) inspector.exclusion_controls.edit_toggled.connect(modes.append) controls = inspector.exclusion_controls @@ -287,12 +296,14 @@ def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: assert modes == [True] assert commands == [ExclusionsChanged(())] + assert store.state.parameters.exclusions == () - inspector.apply_parameters(present_parameters(state), editable=False) + inspector.apply_parameters(present_parameters(store.state), editable=False) assert modes == [True, False] assert not controls.edit_button.isEnabled() assert not controls.clear_button.isEnabled() + assert controls.count_label.text() == "0 region(s)" def test_inspector_emits_edge_mode_from_the_standard_combo(qtbot) -> None: diff --git a/tests/ui/test_parameter_persistence.py b/tests/ui/test_parameter_persistence.py index 6f0de30..cd99214 100644 --- a/tests/ui/test_parameter_persistence.py +++ b/tests/ui/test_parameter_persistence.py @@ -1,9 +1,12 @@ from __future__ import annotations +from dataclasses import dataclass from decimal import Decimal +from fractions import Fraction from pathlib import Path from PySide6.QtCore import QSettings +from PySide6.QtGui import QImage from matteloop.core.execution_providers import ( CPU_EXECUTION_PROVIDER, @@ -16,8 +19,13 @@ ParameterState, ) from matteloop.core.specs import CropSpec, EdgeMode, TransformSpec -from matteloop.core.state import AppState, SourceState -from matteloop.ui.controller import SourceController +from matteloop.core.state import ( + AppState, + SourceLoadRequested, + SourceState, + reduce, +) +from matteloop.ui.controller import LoadedSource, SourceController from matteloop.ui.preferences import load_parameters, persist_parameters from matteloop.ui.store import ReducerStore @@ -33,6 +41,14 @@ def _settings() -> QSettings: return settings +@dataclass(frozen=True) +class _SourceMetadata: + width: int + height: int + duration: Fraction = Fraction(2) + average_rate: Fraction = Fraction(30) + + def test_parameter_preferences_round_trip_as_qsettings_primitives() -> None: settings = _settings() expected = ParameterState( @@ -91,9 +107,57 @@ def test_unavailable_saved_provider_falls_back_to_the_available_cpu_choice() -> def test_malformed_exclusions_preference_falls_back_to_empty_regions() -> None: settings = _settings() + settings.setValue("parameters/model_id", "u2net") settings.setValue("parameters/exclusions", "8,9,40,50;malformed") - assert load_parameters(settings).exclusions == () + class ReadingSettings: + def __init__(self, source: QSettings) -> None: + self.source = source + self.keys: list[str] = [] + + def value(self, key: str) -> object: + self.keys.append(key) + return self.source.value(key) + + reading = ReadingSettings(settings) + actual = load_parameters(reading) # type: ignore[arg-type] + + assert actual.model_id == "u2net" + assert actual.exclusions == () + assert "parameters/exclusions" in reading.keys + + +def test_source_load_persists_clipped_exclusions_for_the_next_start() -> None: + settings = _settings() + saved = ParameterState( + exclusions=(CropSpec(60, 70, 80, 20), CropSpec(120, 0, 10, 10)) + ) + persist_parameters(settings, saved) + + store = ReducerStore( + reduce( + AppState(parameters=load_parameters(settings)), + SourceLoadRequested("smaller", "load-2"), + ) + ) + controller = SourceController.__new__(SourceController) + controller._store = store + controller._settings = settings + controller._closed = False + + controller._source_loaded( + "smaller", + "load-2", + LoadedSource( + _SourceMetadata(100, 80), + QImage(100, 80, QImage.Format.Format_RGBA8888), + ), + ) + + assert store.state.source is SourceState.READY + assert store.state.parameters.exclusions == (CropSpec(60, 70, 40, 10),) + restarted = AppState(parameters=load_parameters(settings)) + assert restarted.parameters.exclusions == (CropSpec(60, 70, 40, 10),) def test_failed_provider_is_not_reintroduced_by_a_later_parameter_save() -> None: From dda9e09fb0cb86e3a172bd9c8c57b3403a10a797 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 13:00:07 +0200 Subject: [PATCH 09/21] =?UTF-8?q?=F0=9F=90=9B=20fix(exclusions):=20answer?= =?UTF-8?q?=20the=20third=20review?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - A gesture kept its own region index while the canvas cleared only the selection when the tuple shrank, so releasing a drag after the region under it was deleted recreated that region at index 0 and raised `IndexError` at index 1. `_reconcile_exclusion_state` now cancels a drag or rubber band when the source, the index or the region's value changes underneath it. Selection lives in the canvas while the regions live in the reducer, and this is the seam where the two disagreed. - Region painting and presses were gated on `model.crop_enabled`, so unchecking Crop hid the regions and made Edit inert while it stayed checked — and the hidden regions still removed pixels from the output. Regions now have their own activation rule. - `TransformStageController` compared raw framing tuples, so moving a region that lies entirely outside the crop rescheduled the facts worker and reloaded every frame of the result player: up to 300 PNGs re-read for an edit with no effect on a single pixel. `_effective_framing _changed` compares the mapped cut boxes while the raw framing is still stored, the same distinction the reducer makes. - `action_availability` left exclusions out of its comparison although `ParametersReset` clears them, so Reset stayed disabled after drawing a region and only woke up once an unrelated parameter changed. - ⌨️ Accessibility: - A keyboard-only user could not create a region, could not select one, and therefore could not delete an individual region — full keyboard reachability is a V1 scope commitment, so this was a scope defect rather than a rough edge. Insert, N and Space create, Tab and Backtab cycle the selection, Delete removes the selected region. - A nudge compared the candidate against the *crop* rather than the region being edited, so a region that happened to coincide with the crop could not be moved that last pixel. - The canvas announced "Crop bounds" while in region mode; it now announces the mode and the selected region. - 🔄 Refactor: - The region mode moved out of `ui/crop_canvas.py` into a new `ui/exclusion_canvas.py`, leaving 410 and 594 lines rather than one module pressing against the 800-line budget. - 🧪 Tests: - Three seams had no test crossing them, each with a production edit that would have broken behaviour while the suite stayed green: deleting the `main_window` signal connection left Edit checked while dragging still edited the crop; swapping `request.crop` for an origin-zero crop of the same size misplaced every exclusion, which no fixture caught because they all used origin-zero crops; and writing a union fingerprint computed with empty exclusions kept the pixels right while missing the cache forever after. One test each now crosses them. - `test_region_state_change_cancels_an_in_flight_drag` pins deletion, replacement and reindexing under a live gesture; `test_region_change_outside_the_cut_does_not_recompute_or_reload_frames` pins that an ineffective edit costs nothing; `test_arrow_key_can_move_a_region_onto_the_crop_bounds` pins the final pixel; `test_region_mode_keyboard_creates_a_region` and `test_region_mode_keyboard_cycles_selection_and_deletes_it` pin the keyboard path end to end. - 📝 The German catalogue carries the new announcement strings; 0 unfinished in both languages. Trigger: repro — press and hold on a region to start a drag, Tab to the inspector's Clear and activate it with Space, then release the mouse. Refs #80 --- resources/matteloop_de.qm | Bin 70362 -> 70580 bytes resources/matteloop_de.ts | 19 +- resources/matteloop_en.qm | Bin 62388 -> 62592 bytes resources/matteloop_en.ts | 19 +- src/matteloop/ui/crop_canvas.py | 321 +--------- src/matteloop/ui/exclusion_canvas.py | 594 ++++++++++++++++++ src/matteloop/ui/inspector_reset.py | 1 + src/matteloop/ui/preview_canvas.py | 4 +- src/matteloop/ui/transform_stage.py | 28 +- tests/jobs/test_rebuild.py | 37 ++ tests/jobs/test_render.py | 45 ++ tests/ui/test_crop_canvas.py | 151 ++++- .../test_main_window_state_and_source_drop.py | 52 +- tests/ui/test_parameter_inspector.py | 17 +- tests/ui/test_transform_stage.py | 35 ++ 15 files changed, 995 insertions(+), 328 deletions(-) create mode 100644 src/matteloop/ui/exclusion_canvas.py diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index 2e5f75703eda3d49deccff8f121cf5dc93c39074..d7a983c9274cf65e4685deae2f0eb396bc52e5cc 100644 GIT binary patch delta 4509 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 CropCanvas - + Original video frame Original-Videobild - + + Exclusion region mode: %1 region(s); no region selected + Ausschlussregion-Modus: %1 Region(en); keine Region ausgewählt + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel - + Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s Zuschnittgrenzen: x %s, y %s, Breite %s, Höhe %s Quellpixel; Quelle %s × %s @@ -238,17 +243,17 @@ Arbeitsbereiche verwalten… - + Reset to defaults Auf Standardwerte zurücksetzen - + Reset inspector parameters Inspector-Parameter zurücksetzen - + Compute acceleration, transform, output directory, and output filename are not affected. Beschleunigung, Transformation, Ausgabeordner und Dateiname bleiben unverändert. @@ -2093,7 +2098,7 @@ Freed %s. Videodateien (*.mp4 *.mov *.webm *.mkv) - + Choose output directory Ausgabeordner auswählen diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index 15416c5e8ce5bf98b5efc675a1f9c3dc8b0a7e44..fb239e8dbec587116420b08546e86fc0ea02d8c0 100644 GIT binary patch delta 4498 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 Jo9$r# CropCanvas - + Original video frame Original video frame - + + Exclusion region mode: %1 region(s); no region selected + Exclusion region mode: %1 region(s); no region selected + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels - + Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s @@ -238,17 +243,17 @@ Manage Workspaces… - + Reset to defaults Reset to defaults - + Reset inspector parameters Reset inspector parameters - + Compute acceleration, transform, output directory, and output filename are not affected. Compute acceleration, transform, output directory, and output filename are not affected. @@ -2093,7 +2098,7 @@ Freed %s. Video files (*.mp4 *.mov *.webm *.mkv) - + Choose output directory Choose output directory diff --git a/src/matteloop/ui/crop_canvas.py b/src/matteloop/ui/crop_canvas.py index fc1482f..2caf1dd 100644 --- a/src/matteloop/ui/crop_canvas.py +++ b/src/matteloop/ui/crop_canvas.py @@ -25,7 +25,6 @@ SizeF, build_crop_geometry, ) -from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec from matteloop.ui.crop_presentation import CropPresentation from matteloop.ui.preview_canvas import PreviewCanvas @@ -68,25 +67,6 @@ def __init__( self._dragged: str | None = None self._drag_start = PointF(0, 0) self._drag_crop: CropPresentation | None = None - self._exclusion_edit = False - self._selected_exclusion: int | None = None - self._drag_exclusion: int | None = None - self._drag_origin_region: CropSpec | None = None - self._drag_region: CropSpec | None = None - self._rubber_start: PointF | None = None - self._rubber_current: PointF | None = None - - def set_exclusion_edit(self, enabled: bool) -> None: - """Toggle the mutually exclusive exclusion-region editing mode.""" - if self._exclusion_edit == enabled: - return - self._exclusion_edit = enabled - self._clear_exclusion_selection() - self._clear_gesture() - self._focused_target = "crop" - self._rebuild_geometry() - self._announce_crop() - self.update() def set_presentation( self, @@ -104,28 +84,27 @@ def apply_presentation( active: bool, editable: bool, ) -> None: + if presentation is None: + self._dragged = None + self._drag_crop = None self._presentation = presentation self._active = active self._editable = editable if presentation is None: - self._clear_exclusion_selection() - self._clear_gesture() self._geometry = None self.setAccessibleDescription( QCoreApplication.translate("CropCanvas", "Original video frame") ) else: - if self._selected_exclusion is not None and ( - self._selected_exclusion >= len(presentation.exclusions) - ): - self._clear_exclusion_selection() self._rebuild_geometry() self._announce_crop() self.update() def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] super().paintEvent(event) - if not self._active or self._geometry is None or self._presentation is None: + if self._geometry is None or self._presentation is None: + return + if not self._active: return geometry = self._geometry transform = geometry.transform @@ -137,10 +116,8 @@ def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] overlay.setAlpha(105) painter = QPainter(self) self._paint_crop_mask(painter, content, crop, overlay) - self._paint_exclusions(painter, geometry) self._paint_crop_outline(painter, crop) - if not self._exclusion_edit or self._selected_exclusion is not None: - self._paint_handles(painter, geometry) + self._paint_handles(painter, geometry) self._paint_focus_ring(painter, geometry) painter.end() @@ -175,22 +152,9 @@ def _paint_crop_mask( overlay, ) - def _paint_exclusions( - self, painter: QPainter, geometry: InteractionGeometry - ) -> None: - fill = QColor("#E5484D") - fill.setAlpha(90) - painter.setPen(QPen(QColor("#E5484D"), 1)) - painter.setBrush(fill) - for exclusion in self._painted_exclusions(): - painter.drawRect(self._widget_rect(geometry, exclusion)) - def _paint_crop_outline(self, painter: QPainter, crop: QRectF) -> None: - color = QColor(ACCENT_COLOR) - if self._exclusion_edit: - color.setAlpha(135) painter.setBrush(Qt.BrushStyle.NoBrush) - painter.setPen(QPen(color, 2 if not self._exclusion_edit else 1)) + painter.setPen(QPen(QColor(ACCENT_COLOR), 2)) painter.drawRect(crop) @staticmethod @@ -208,9 +172,7 @@ def _paint_focus_ring( if not self.hasFocus(): return focused = geometry.focus.get(self._focused_target) - if focused is None or ( - self._exclusion_edit and self._selected_exclusion is None - ): + if focused is None: return painter.setBrush(Qt.BrushStyle.NoBrush) painter.setPen(QPen(QColor(TEXT_COLOR), 1, Qt.PenStyle.DashLine)) @@ -229,10 +191,6 @@ def mousePressEvent(self, event: QMouseEvent) -> None: super().mousePressEvent(event) return position = PointF(event.position().x(), event.position().y()) - if self._exclusion_edit: - self._press_exclusion(position) - event.accept() - return target = geometry.hit_test(position) if target not in {"crop", *_HANDLE_NAMES} or self._presentation is None: super().mousePressEvent(event) @@ -252,64 +210,25 @@ def mouseMoveEvent(self, event: QMouseEvent) -> None: and self._active and event.buttons() & Qt.MouseButton.LeftButton ): - if self._exclusion_edit: - self._emit_exclusion_drag(event.position()) - else: - self._emit_drag(event.position()) - event.accept() - return - if ( - self._exclusion_edit - and self._rubber_start is not None - and event.buttons() & Qt.MouseButton.LeftButton - ): - self._rubber_current = self._oriented_position(event.position()) - self.update() + self._emit_drag(event.position()) event.accept() return super().mouseMoveEvent(event) def mouseReleaseEvent(self, event: QMouseEvent) -> None: if event.button() == Qt.MouseButton.LeftButton and self._dragged is not None: - if self._exclusion_edit: - self._finish_exclusion_drag() - event.accept() - return self._dragged = None self._drag_crop = None self._rebuild_geometry() self._announce_crop() event.accept() return - if ( - event.button() == Qt.MouseButton.LeftButton - and self._exclusion_edit - and self._rubber_start is not None - ): - self._finish_rubber_band() - event.accept() - return super().mouseReleaseEvent(event) def keyPressEvent(self, event: QKeyEvent) -> None: if not self._editable or not self._active or not self.hasFocus(): super().keyPressEvent(event) return - if self._exclusion_edit: - if event.key() in {int(Qt.Key.Key_Delete), int(Qt.Key.Key_Backspace)}: - self._delete_selected_exclusion(event) - return - if event.key() == int(Qt.Key.Key_Escape): - self._clear_exclusion_selection() - self._clear_gesture() - self._rebuild_geometry() - self._announce_crop() - self.update() - event.accept() - return - if self._selected_exclusion is None: - super().keyPressEvent(event) - return delta = _key_delta(event) if delta is None or self._presentation is None: super().keyPressEvent(event) @@ -329,7 +248,7 @@ def keyPressEvent(self, event: QKeyEvent) -> None: super().keyPressEvent(event) return crop = self._constrain(crop, self._focused_target) - if crop != self._presentation.crop: + if crop != edited: self.command_requested.emit(self._crop_event(crop)) self._announce_crop() event.accept() @@ -368,195 +287,12 @@ def _emit_drag(self, position: QPointF) -> None: if self._presentation is None or crop != self._presentation.crop: self.command_requested.emit(self._crop_event(crop)) - def _press_exclusion(self, position: PointF) -> None: - if self._presentation is None or self._geometry is None: - return - selected = self._selected_exclusion - if selected is not None: - target = self._geometry.hit_test(position) - if target in {"crop", *_HANDLE_NAMES}: - self._begin_exclusion_drag(selected, target, position) - return - oriented = self._oriented_position(position) - for index in range(len(self._presentation.exclusions) - 1, -1, -1): - if index == selected: - continue - if _contains(self._presentation.exclusions[index], oriented): - self._selected_exclusion = index - self._focused_target = "crop" - self._announce_crop() - self._begin_exclusion_drag(index, "crop", position) - return - self._clear_gesture() - self._rubber_start = self._clamp_oriented(oriented) - self._rubber_current = self._rubber_start - self.setFocus(Qt.FocusReason.MouseFocusReason) - self.update() - - def _begin_exclusion_drag( - self, index: int, target: str, position: PointF - ) -> None: - if self._presentation is None or self._geometry is None: - return - self._drag_exclusion = index - self._drag_origin_region = self._presentation.exclusions[index] - self._drag_region = self._drag_origin_region - self._dragged = target - self._drag_start = self._oriented_position(position) - self.setFocus(Qt.FocusReason.MouseFocusReason) - self._rebuild_geometry(focused=target, dragged=target) - self.update() - - def _emit_exclusion_drag(self, position: QPointF) -> None: - if ( - self._geometry is None - or self._drag_origin_region is None - or self._dragged is None - ): - return - current = self._oriented_position(position) - region = crop_from_drag( - self._drag_origin_region, - self._dragged, - self._drag_start, - current, - source_width=self._presentation.width if self._presentation else 1, - source_height=self._presentation.height if self._presentation else 1, - ) - region = self._constrain(region, self._dragged) - if region == self._drag_region: - return - self._drag_region = region - self._rebuild_geometry(focused=self._dragged, dragged=self._dragged) - self._announce_crop() - self.update() - - def _finish_exclusion_drag(self) -> None: - index = self._drag_exclusion - region = self._drag_region - original = ( - self._presentation.exclusions[index] + def _edited_rect(self) -> CropSpec: + return ( + self._presentation.crop if self._presentation is not None - and index is not None - and index < len(self._presentation.exclusions) - else None + else CropSpec(0, 0, 1, 1) ) - self._clear_gesture() - if index is not None and region is not None: - self._selected_exclusion = index - if region != original: - self.command_requested.emit(self._exclusion_event(region)) - self._rebuild_geometry() - self._announce_crop() - self.update() - - def _finish_rubber_band(self) -> None: - region = self._rubber_region() - self._clear_gesture() - if ( - region is not None - and region.width >= 8 - and region.height >= 8 - and self._presentation is not None - ): - self._selected_exclusion = len(self._presentation.exclusions) - self.command_requested.emit(self._exclusion_event(region)) - self._rebuild_geometry() - self._announce_crop() - self.update() - - def _delete_selected_exclusion(self, event: QKeyEvent) -> None: - index = self._selected_exclusion - if self._presentation is None or index is None: - super().keyPressEvent(event) - return - current = self._presentation.exclusions - exclusions = current[:index] + current[index + 1 :] - self._clear_exclusion_selection() - self._clear_gesture() - self.command_requested.emit(ExclusionsChanged(exclusions)) - self._rebuild_geometry() - self._announce_crop() - self.update() - event.accept() - - def _exclusion_event(self, region: CropSpec) -> ExclusionsChanged: - if self._presentation is None or self._selected_exclusion is None: - return ExclusionsChanged((region,)) - exclusions = list(self._presentation.exclusions) - if self._selected_exclusion == len(exclusions): - exclusions.append(region) - else: - exclusions[self._selected_exclusion] = region - return ExclusionsChanged(tuple(exclusions)) - - def _oriented_position(self, position: QPointF | PointF) -> PointF: - if self._geometry is None: - return PointF(0, 0) - point = ( - position - if isinstance(position, PointF) - else PointF(position.x(), position.y()) - ) - return oriented_point_from_widget(self._geometry, point) - - def _clamp_oriented(self, point: PointF) -> PointF: - if self._presentation is None: - return point - return PointF( - min(max(point.x, 0), self._presentation.width), - min(max(point.y, 0), self._presentation.height), - ) - - def _rubber_region(self) -> CropSpec | None: - if self._rubber_start is None or self._rubber_current is None: - return None - start = self._clamp_oriented(self._rubber_start) - current = self._clamp_oriented(self._rubber_current) - left, right = sorted((round(start.x), round(current.x))) - top, bottom = sorted((round(start.y), round(current.y))) - if right <= left or bottom <= top: - return None - return CropSpec(left, top, right - left, bottom - top) - - def _clear_gesture(self) -> None: - self._dragged = None - self._drag_crop = None - self._drag_exclusion = None - self._drag_origin_region = None - self._drag_region = None - self._rubber_start = None - self._rubber_current = None - - def _clear_exclusion_selection(self) -> None: - self._selected_exclusion = None - - def _painted_exclusions(self) -> tuple[CropSpec, ...]: - if self._presentation is None: - return () - exclusions = list(self._presentation.exclusions) - if ( - self._drag_exclusion is not None - and self._drag_region is not None - and self._drag_exclusion < len(exclusions) - ): - exclusions[self._drag_exclusion] = self._drag_region - rubber = self._rubber_region() - if rubber is not None: - exclusions.append(rubber) - return tuple(exclusions) - - def _edited_rect(self) -> CropSpec: - if self._presentation is None or not self._exclusion_edit: - return ( - self._presentation.crop - if self._presentation is not None - else CropSpec(0, 0, 1, 1) - ) - index = self._selected_exclusion - if index is None or index >= len(self._presentation.exclusions): - return self._presentation.crop - return self._drag_region or self._presentation.exclusions[index] def _widget_rect( self, geometry: InteractionGeometry, rect: CropSpec @@ -590,8 +326,6 @@ def _crop_event(self, crop: CropSpec) -> object: keeps an arrow-key nudge on the result canvas from dispatching a *source* crop change (edge case E30). """ - if self._exclusion_edit: - return self._exclusion_event(crop) return CropChanged(crop) def _rebuild_geometry( @@ -646,24 +380,6 @@ def _announce_crop(self) -> None: if presentation is None: return crop = self._edited_rect() - if self._exclusion_edit and self._selected_exclusion is not None: - text = QCoreApplication.translate( - "CropCanvas", - "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " - "source pixels", - ) - values = ( - self._selected_exclusion + 1, - len(presentation.exclusions), - crop.x, - crop.y, - crop.width, - crop.height, - ) - for number, value in enumerate(values, start=1): - text = text.replace(f"%{number}", str(value)) - self.setAccessibleDescription(text) - return self.setAccessibleDescription( QCoreApplication.translate( "CropCanvas", @@ -692,10 +408,3 @@ def _key_delta(event: QKeyEvent) -> tuple[int, int] | None: def _qt_rect(rect: RectF) -> QRectF: return QRectF(rect.x, rect.y, rect.width, rect.height) - - -def _contains(region: CropSpec, point: PointF) -> bool: - return ( - region.x <= point.x < region.x + region.width - and region.y <= point.y < region.y + region.height - ) diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py new file mode 100644 index 0000000..f2017c7 --- /dev/null +++ b/src/matteloop/ui/exclusion_canvas.py @@ -0,0 +1,594 @@ +"""Region-mode extension for the source crop canvas.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QCoreApplication, QPointF, QRectF, Qt +from PySide6.QtGui import QColor, QKeyEvent, QMouseEvent, QPainter, QPen +from PySide6.QtWidgets import QWidget + +from matteloop.core.crop import ( + crop_from_drag, + nudge_crop, + oriented_point_from_widget, +) +from matteloop.core.geometry import InteractionGeometry, MediaTransform, PointF +from matteloop.core.parameters import ExclusionsChanged +from matteloop.core.specs import CropSpec +from matteloop.ui.crop_canvas import ( + _HANDLE_NAMES, + CropCanvas, + _key_delta, +) +from matteloop.ui.crop_presentation import CropPresentation +from matteloop.ui.preview_canvas import PreviewCanvas +from matteloop.ui.theme import ACCENT_COLOR, CANVAS_COLOR + + +class ExclusionCanvas(CropCanvas): + """Add source-region editing while retaining CropCanvas's crop hooks.""" + + def __init__( + self, + parent: QWidget | None = None, + *, + title: str = "Original", + object_name: str = "original_canvas", + runtime_root: Path | None = None, + ) -> None: + super().__init__( + parent, + title=title, + object_name=object_name, + runtime_root=runtime_root, + ) + self._exclusion_edit = False + self._selected_exclusion: int | None = None + self._selected_exclusion_value: CropSpec | None = None + self._drag_exclusion: int | None = None + self._drag_origin_region: CropSpec | None = None + self._drag_region: CropSpec | None = None + self._rubber_start: PointF | None = None + self._rubber_current: PointF | None = None + + def set_exclusion_edit(self, enabled: bool) -> None: + """Toggle the mutually exclusive exclusion-region editing mode.""" + if self._exclusion_edit == enabled: + return + self._exclusion_edit = enabled + self._clear_exclusion_selection() + self._clear_gesture() + self._focused_target = "crop" + self._rebuild_geometry() + self._announce_crop() + self.update() + + def apply_presentation( + self, + presentation: CropPresentation | None, + *, + active: bool, + editable: bool, + ) -> None: + previous = self._presentation + if presentation is None: + self._clear_exclusion_selection() + self._clear_gesture() + else: + self._reconcile_exclusion_state(previous, presentation) + super().apply_presentation( + presentation, active=active, editable=editable + ) + + def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] + PreviewCanvas.paintEvent(self, event) + if self._geometry is None or self._presentation is None: + return + if not ( + self._active + or self._exclusion_edit + or self._presentation.exclusions + ): + return + geometry = self._geometry + transform = geometry.transform + if not isinstance(transform, MediaTransform): + return + content = transform.content_rect + crop = self._widget_rect(geometry, self._presentation.crop) + overlay = QColor(CANVAS_COLOR) + overlay.setAlpha(105) + painter = QPainter(self) + if self._active: + self._paint_crop_mask(painter, content, crop, overlay) + self._paint_exclusions(painter, geometry) + if self._active: + self._paint_crop_outline(painter, crop) + if not self._exclusion_edit or self._selected_exclusion is not None: + self._paint_handles(painter, geometry) + if not self._exclusion_edit or self._selected_exclusion is not None: + self._paint_focus_ring(painter, geometry) + painter.end() + + def _paint_crop_outline(self, painter: QPainter, crop: QRectF) -> None: + color = QColor(ACCENT_COLOR) + if self._exclusion_edit: + color.setAlpha(135) + painter.setBrush(Qt.BrushStyle.NoBrush) + painter.setPen(QPen(color, 1 if self._exclusion_edit else 2)) + painter.drawRect(crop) + + def _paint_exclusions( + self, painter: QPainter, geometry: InteractionGeometry + ) -> None: + fill = QColor("#E5484D") + fill.setAlpha(90) + painter.setPen(QPen(QColor("#E5484D"), 1)) + painter.setBrush(fill) + for exclusion in self._painted_exclusions(): + painter.drawRect(self._widget_rect(geometry, exclusion)) + + def mousePressEvent(self, event: QMouseEvent) -> None: + if not self._exclusion_edit: + super().mousePressEvent(event) + return + if ( + not self._editable + or (not self._active and not self._exclusion_edit) + or event.button() != Qt.MouseButton.LeftButton + ): + super().mousePressEvent(event) + return + geometry = self._geometry + if geometry is None: + super().mousePressEvent(event) + return + self._press_exclusion( + PointF(event.position().x(), event.position().y()) + ) + event.accept() + + def mouseMoveEvent(self, event: QMouseEvent) -> None: + if not self._exclusion_edit: + super().mouseMoveEvent(event) + return + if ( + self._drag_exclusion is not None + and self._dragged is not None + and self._editable + and event.buttons() & Qt.MouseButton.LeftButton + ): + self._emit_exclusion_drag(event.position()) + event.accept() + return + if ( + self._rubber_start is not None + and event.buttons() & Qt.MouseButton.LeftButton + ): + self._rubber_current = self._oriented_position(event.position()) + self.update() + event.accept() + return + super().mouseMoveEvent(event) + + def mouseReleaseEvent(self, event: QMouseEvent) -> None: + if not self._exclusion_edit: + super().mouseReleaseEvent(event) + return + if event.button() == Qt.MouseButton.LeftButton: + if self._drag_exclusion is not None: + self._finish_exclusion_drag() + event.accept() + return + if self._rubber_start is not None: + self._finish_rubber_band() + event.accept() + return + super().mouseReleaseEvent(event) + + def keyPressEvent(self, event: QKeyEvent) -> None: + if not self._exclusion_edit: + super().keyPressEvent(event) + return + if not self._editable or not self.hasFocus(): + super().keyPressEvent(event) + return + if self._handle_exclusion_key(event): + return + super().keyPressEvent(event) + + def _handle_exclusion_key(self, event: QKeyEvent) -> bool: + if event.key() in {int(Qt.Key.Key_Delete), int(Qt.Key.Key_Backspace)}: + if self._selected_exclusion is None: + return False + self._delete_selected_exclusion(event) + return True + if event.key() == int(Qt.Key.Key_Escape): + self._clear_exclusion_selection() + self._clear_gesture() + self._rebuild_geometry() + self._announce_crop() + self.update() + event.accept() + return True + if event.key() in {int(Qt.Key.Key_Tab), int(Qt.Key.Key_Backtab)}: + if self._cycle_exclusion_selection( + backwards=( + event.key() == int(Qt.Key.Key_Backtab) + or bool(event.modifiers() & Qt.KeyboardModifier.ShiftModifier) + ) + ): + event.accept() + return True + return False + if event.key() in { + int(Qt.Key.Key_Insert), + int(Qt.Key.Key_N), + int(Qt.Key.Key_Space), + }: + self._create_exclusion() + event.accept() + return True + if self._selected_exclusion is None: + return False + delta = _key_delta(event) + if delta is None or self._presentation is None: + return False + step = 10 if event.modifiers() & Qt.KeyboardModifier.ShiftModifier else 1 + edited = self._edited_rect() + try: + region = nudge_crop( + edited, + self._focused_target, + dx=delta[0] * step, + dy=delta[1] * step, + source_width=self._presentation.width, + source_height=self._presentation.height, + ) + except ValueError: + return False + region = self._constrain(region, self._focused_target) + if region != edited: + self._set_exclusion_selection( + self._selected_exclusion, value=region + ) + self.command_requested.emit(self._crop_event(region)) + self._announce_crop() + event.accept() + return True + + def _delete_selected_exclusion(self, event: QKeyEvent) -> None: + index = self._selected_exclusion + if self._presentation is None or index is None: + super().keyPressEvent(event) + return + current = self._presentation.exclusions + exclusions = current[:index] + current[index + 1 :] + self._clear_exclusion_selection() + self._clear_gesture() + self.command_requested.emit(ExclusionsChanged(exclusions)) + self._rebuild_geometry() + self._announce_crop() + self.update() + event.accept() + + def _press_exclusion(self, position: PointF) -> None: + if self._presentation is None or self._geometry is None: + return + selected = self._selected_exclusion + if selected is not None: + target = self._geometry.hit_test(position) + if target in {"crop", *_HANDLE_NAMES}: + self._begin_exclusion_drag(selected, target, position) + return + oriented = self._oriented_position(position) + for index in range(len(self._presentation.exclusions) - 1, -1, -1): + if index == selected: + continue + if _contains(self._presentation.exclusions[index], oriented): + self._set_exclusion_selection(index) + self._focused_target = "crop" + self._announce_crop() + self._begin_exclusion_drag(index, "crop", position) + return + self._clear_gesture() + self._rubber_start = self._clamp_oriented(oriented) + self._rubber_current = self._rubber_start + self.setFocus(Qt.FocusReason.MouseFocusReason) + self.update() + + def _begin_exclusion_drag( + self, index: int, target: str, position: PointF + ) -> None: + if self._presentation is None or self._geometry is None: + return + self._drag_exclusion = index + self._drag_origin_region = self._presentation.exclusions[index] + self._drag_region = self._drag_origin_region + self._dragged = target + self._drag_start = self._oriented_position(position) + self.setFocus(Qt.FocusReason.MouseFocusReason) + self._rebuild_geometry(focused=target, dragged=target) + self.update() + + def _emit_exclusion_drag(self, position: QPointF) -> None: + if ( + self._geometry is None + or self._drag_origin_region is None + or self._dragged is None + ): + return + current = self._oriented_position(position) + region = crop_from_drag( + self._drag_origin_region, + self._dragged, + self._drag_start, + current, + source_width=self._presentation.width if self._presentation else 1, + source_height=self._presentation.height if self._presentation else 1, + ) + region = self._constrain(region, self._dragged) + if region == self._drag_region: + return + self._drag_region = region + self._rebuild_geometry(focused=self._dragged, dragged=self._dragged) + self._announce_crop() + self.update() + + def _finish_exclusion_drag(self) -> None: + index = self._drag_exclusion + region = self._drag_region + original = ( + self._presentation.exclusions[index] + if self._presentation is not None + and index is not None + and index < len(self._presentation.exclusions) + else None + ) + self._clear_gesture() + if index is not None and region is not None: + self._set_exclusion_selection(index, value=region) + if region != original: + self.command_requested.emit(self._exclusion_event(region)) + self._rebuild_geometry() + self._announce_crop() + self.update() + + def _finish_rubber_band(self) -> None: + region = self._rubber_region() + self._clear_gesture() + if ( + region is not None + and region.width >= 8 + and region.height >= 8 + and self._presentation is not None + ): + self._set_exclusion_selection( + len(self._presentation.exclusions), value=region + ) + self.command_requested.emit(self._exclusion_event(region)) + self._rebuild_geometry() + self._announce_crop() + self.update() + + def _exclusion_event(self, region: CropSpec) -> ExclusionsChanged: + if self._presentation is None or self._selected_exclusion is None: + return ExclusionsChanged((region,)) + exclusions = list(self._presentation.exclusions) + if self._selected_exclusion == len(exclusions): + exclusions.append(region) + elif self._selected_exclusion > len(exclusions): + return ExclusionsChanged(tuple(exclusions)) + else: + exclusions[self._selected_exclusion] = region + return ExclusionsChanged(tuple(exclusions)) + + def _oriented_position(self, position: QPointF | PointF) -> PointF: + if self._geometry is None: + return PointF(0, 0) + point = ( + position + if isinstance(position, PointF) + else PointF(position.x(), position.y()) + ) + return oriented_point_from_widget(self._geometry, point) + + def _clamp_oriented(self, point: PointF) -> PointF: + if self._presentation is None: + return point + return PointF( + min(max(point.x, 0), self._presentation.width), + min(max(point.y, 0), self._presentation.height), + ) + + def _rubber_region(self) -> CropSpec | None: + if self._rubber_start is None or self._rubber_current is None: + return None + start = self._clamp_oriented(self._rubber_start) + current = self._clamp_oriented(self._rubber_current) + left, right = sorted((round(start.x), round(current.x))) + top, bottom = sorted((round(start.y), round(current.y))) + if right <= left or bottom <= top: + return None + return CropSpec(left, top, right - left, bottom - top) + + def _clear_gesture(self) -> None: + self._dragged = None + self._drag_crop = None + self._drag_exclusion = None + self._drag_origin_region = None + self._drag_region = None + self._rubber_start = None + self._rubber_current = None + + def _clear_exclusion_selection(self) -> None: + self._selected_exclusion = None + self._selected_exclusion_value = None + + def _set_exclusion_selection( + self, index: int, *, value: CropSpec | None = None + ) -> None: + self._selected_exclusion = index + if value is not None: + self._selected_exclusion_value = value + elif self._presentation is not None and index < len( + self._presentation.exclusions + ): + self._selected_exclusion_value = self._presentation.exclusions[index] + else: + self._selected_exclusion_value = None + + def _cycle_exclusion_selection(self, *, backwards: bool) -> bool: + if self._presentation is None or not self._presentation.exclusions: + return False + self._clear_gesture() + count = len(self._presentation.exclusions) + current = self._selected_exclusion + if current is None or current >= count: + index = count - 1 if backwards else 0 + else: + index = (current - 1 if backwards else current + 1) % count + self._set_exclusion_selection(index) + self._focused_target = "crop" + self._rebuild_geometry() + self._announce_crop() + self.update() + return True + + def _create_exclusion(self) -> None: + if self._presentation is None: + return + width = min(8, self._presentation.width) + height = min(8, self._presentation.height) + region = CropSpec( + (self._presentation.width - width) // 2, + (self._presentation.height - height) // 2, + width, + height, + ) + self._set_exclusion_selection( + len(self._presentation.exclusions), value=region + ) + self.command_requested.emit(self._exclusion_event(region)) + + def _reconcile_exclusion_state( + self, + previous: CropPresentation | None, + presentation: CropPresentation, + ) -> None: + source_changed = previous is None or ( + previous.source_id != presentation.source_id + or previous.width != presentation.width + or previous.height != presentation.height + or previous.rotation != presentation.rotation + or previous.pixel_aspect != presentation.pixel_aspect + ) + if self._drag_exclusion is not None: + drag_index = self._drag_exclusion + if ( + source_changed + or self._drag_origin_region is None + or drag_index >= len(presentation.exclusions) + or presentation.exclusions[drag_index] != self._drag_origin_region + ): + self._clear_gesture() + elif self._rubber_start is not None and ( + source_changed + or previous is None + or previous.exclusions != presentation.exclusions + ): + self._clear_gesture() + index = self._selected_exclusion + if index is None: + return + value = self._selected_exclusion_value + if value is None and previous is not None and index < len( + previous.exclusions + ): + value = previous.exclusions[index] + if value is None: + self._clear_exclusion_selection() + return + if ( + index < len(presentation.exclusions) + and presentation.exclusions[index] == value + ): + self._selected_exclusion_value = value + return + try: + self._selected_exclusion = presentation.exclusions.index(value) + except ValueError: + self._clear_exclusion_selection() + + def _painted_exclusions(self) -> tuple[CropSpec, ...]: + if self._presentation is None: + return () + exclusions = list(self._presentation.exclusions) + if ( + self._drag_exclusion is not None + and self._drag_region is not None + and self._drag_exclusion < len(exclusions) + ): + exclusions[self._drag_exclusion] = self._drag_region + rubber = self._rubber_region() + if rubber is not None: + exclusions.append(rubber) + return tuple(exclusions) + + def _edited_rect(self) -> CropSpec: + if self._presentation is None or not self._exclusion_edit: + return super()._edited_rect() + index = self._selected_exclusion + if index is None or index >= len(self._presentation.exclusions): + return self._presentation.crop + return self._drag_region or self._presentation.exclusions[index] + + def _crop_event(self, crop: CropSpec) -> object: + if self._exclusion_edit: + return self._exclusion_event(crop) + return super()._crop_event(crop) + + def _announce_crop(self) -> None: + presentation = self._presentation + if presentation is None: + return + index = self._selected_exclusion + if self._exclusion_edit and ( + index is None or index >= len(presentation.exclusions) + ): + self.setAccessibleDescription( + QCoreApplication.translate( + "CropCanvas", + "Exclusion region mode: %1 region(s); no region selected", + ).replace("%1", str(len(presentation.exclusions))) + ) + return + if not self._exclusion_edit: + super()._announce_crop() + return + assert index is not None + crop = self._edited_rect() + text = QCoreApplication.translate( + "CropCanvas", + "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " + "source pixels", + ) + values = ( + index + 1, + len(presentation.exclusions), + crop.x, + crop.y, + crop.width, + crop.height, + ) + for number, value in enumerate(values, start=1): + text = text.replace(f"%{number}", str(value)) + self.setAccessibleDescription(text) + + +def _contains(region: CropSpec, point: PointF) -> bool: + return ( + region.x <= point.x < region.x + region.width + and region.y <= point.y < region.y + region.height + ) diff --git a/src/matteloop/ui/inspector_reset.py b/src/matteloop/ui/inspector_reset.py index a28e39d..3a170da 100644 --- a/src/matteloop/ui/inspector_reset.py +++ b/src/matteloop/ui/inspector_reset.py @@ -24,6 +24,7 @@ def can_reset_parameters(presentation: ParameterPresentation) -> bool: (presentation.alpha_threshold, defaults.alpha_threshold), (presentation.padding, defaults.padding), (presentation.stretch_x, defaults.stretch_x), + (presentation.exclusions, defaults.exclusions), (presentation.max_mib, defaults.max_mib), ) ): diff --git a/src/matteloop/ui/preview_canvas.py b/src/matteloop/ui/preview_canvas.py index 3742988..fc368fd 100644 --- a/src/matteloop/ui/preview_canvas.py +++ b/src/matteloop/ui/preview_canvas.py @@ -274,14 +274,14 @@ def __init__( self, parent: QWidget | None = None, *, runtime_root: Path | None = None ) -> None: super().__init__(parent) - from matteloop.ui.crop_canvas import CropCanvas + from matteloop.ui.exclusion_canvas import ExclusionCanvas from matteloop.ui.result_player import ResultPlayerCanvas self.setObjectName("preview_stage") layout = QHBoxLayout(self) layout.setContentsMargins(16, 16, 16, 16) layout.setSpacing(8) - self.original_canvas = CropCanvas( + self.original_canvas = ExclusionCanvas( title=QCoreApplication.translate("PreviewCanvas", "Original") ) self.result_canvas = ResultPlayerCanvas(runtime_root=runtime_root) diff --git a/src/matteloop/ui/transform_stage.py b/src/matteloop/ui/transform_stage.py index 11967d5..f35f2ee 100644 --- a/src/matteloop/ui/transform_stage.py +++ b/src/matteloop/ui/transform_stage.py @@ -355,7 +355,9 @@ def _state_changed(self, state: AppState) -> None: return parameters = state.parameters framing = _framing_from_parameters(parameters) - framing_changed = framing != self._framing + framing_changed = _effective_framing_changed( + framing, self._framing, self._session + ) edit_scan_completed = ( self._edited_cuts_request_id is not None and state.edited_cuts_request_id is None @@ -365,8 +367,7 @@ def _state_changed(self, state: AppState) -> None: refresh_external_edits = edit_scan_completed or edited_cuts_became_true self._edited_cuts = state.edited_cuts self._edited_cuts_request_id = state.edited_cuts_request_id - if framing_changed: - self._framing = framing + self._framing = framing if self._session is not None and (framing_changed or refresh_external_edits): self._schedule_facts(refresh_external_edits=refresh_external_edits) transform = parameters.transform @@ -654,6 +655,27 @@ def _framing_from_parameters(parameters: ParameterState) -> FramingSpec: ) +def _effective_framing_changed( + current: FramingSpec, + previous: FramingSpec, + session: CutSession | None, +) -> bool: + """Compare framing inputs after source regions are mapped into cut space.""" + if ( + current.trim != previous.trim + or current.alpha_threshold != previous.alpha_threshold + or current.padding != previous.padding + or current.stretch_x != previous.stretch_x + ): + return True + if session is None: + return current.exclusions != previous.exclusions + crop = _crop_from_manifest(session.manifest) + return cut_exclusions(current.exclusions, crop) != cut_exclusions( + previous.exclusions, crop + ) + + def _thread_is_finished(thread: QThread) -> bool: """A ``RuntimeError`` means the QThread's C++ object was already collected -- itself proof the thread is done. diff --git a/tests/jobs/test_rebuild.py b/tests/jobs/test_rebuild.py index 96546bc..160a106 100644 --- a/tests/jobs/test_rebuild.py +++ b/tests/jobs/test_rebuild.py @@ -495,6 +495,43 @@ def test_rebuild_with_a_region_misses_the_cached_union_and_recomputes_it( assert metadata.bounds == (64, 24, 96, 104) +def test_rebuild_reuses_union_metadata_when_region_inputs_match(tmp_path) -> None: + workspace = FilesystemWorkspacePort() + seed_request = replace( + request(tmp_path), + framing=FramingSpec( + True, + Decimal("2"), + 48, + Decimal("1"), + exclusions=(CropSpec(32, 24, 32, 80),), + ), + ) + original = render_service(workspace=workspace).render( + seed_request, job(tmp_path, "seed-reusable-region-union", JobKind.RENDER) + ) + + class CountingWorkspace(FilesystemWorkspacePort): + def __init__(self) -> None: + super().__init__() + self.reads = 0 + + def read_cut(self, workspace, index, ownership): + self.reads += 1 + return super().read_cut(workspace, index, ownership) + + counting = CountingWorkspace() + _rebuild_service(counting, FakeEncoder()).rebuild( + replace(seed_request, rebuild=True, output=replace( + seed_request.output, filename="reused-region-union.webp" + )), + original.cut_workspace, + job(tmp_path, "reuse-region-union", JobKind.REBUILD), + ) + + assert counting.reads == original.manifest.frame_count + + def test_trim_keeps_exactly_the_selected_frames_and_their_delays(tmp_path) -> None: """AC 2 / E2 / T7: the kept delays are a *slice* of the full non-uniform grid, not a recomputation over the kept count.""" diff --git a/tests/jobs/test_render.py b/tests/jobs/test_render.py index 9a35124..c549eed 100644 --- a/tests/jobs/test_render.py +++ b/tests/jobs/test_render.py @@ -48,6 +48,7 @@ RenderService, ValidatedCandidate, ) +from matteloop.jobs.source import DecodedFrame from tests.fixtures.media_factory import make_video from tests.jobs.render_support import ( FakeClock, @@ -55,6 +56,7 @@ FakeEncoder, FakeSegmenter, FakeSource, + FakeSourceInfo, frozen_segmentation_result, job, render_service, @@ -62,6 +64,26 @@ ) +class _OffsetSource(FakeSource): + def probe(self, path, context): + del path, context + self.probe_calls += 1 + return FakeSourceInfo(width=160, height=160) + + def decode(self, path, timestamp, request_id, source_info, context, ownership): + del path, source_info, context + self.decode_calls.append(timestamp) + image = Image.new("RGBA", (160, 160), (0, 60, 90, 255)) + ownership.register(image) + return DecodedFrame( + image, + timestamp, + timestamp, + request_id, + FakeSourceInfo().revision, + ) + + def _validated_candidate( publisher: AtomicOutputPublisher, target: Path, @@ -1549,6 +1571,29 @@ def test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_the_region assert artifact.manifest.union_metadata.bounds == (64, 24, 96, 104) +def test_render_maps_offset_source_exclusions_into_cut_coordinates(tmp_path) -> None: + render_request = replace( + request(tmp_path, crop=CropSpec(16, 16, 128, 128)), + framing=FramingSpec( + False, + Decimal("2"), + 0, + Decimal("1"), + exclusions=(CropSpec(48, 40, 16, 16),), + ), + ) + + artifact = render_service(source=_OffsetSource()).render( + render_request, job(tmp_path, "offset-exclusion", JobKind.RENDER) + ) + + with Image.open(artifact.output_path) as output: + output.seek(0) + output.load() + assert output.getpixel((32, 24)) == (0, 0, 0, 0) + assert output.getpixel((48, 40)) == (0, 60, 90, 255) + + def test_render_peak_rgba_owner_count_is_unchanged_by_exclusions(tmp_path) -> None: baseline_path = tmp_path / "baseline" baseline_path.mkdir() diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index 6773fee..f9e40cf 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -10,6 +10,7 @@ from matteloop.core.specs import CropSpec from matteloop.ui.crop_canvas import CropCanvas from matteloop.ui.crop_presentation import CropPresentation +from matteloop.ui.exclusion_canvas import ExclusionCanvas from matteloop.ui.preview_canvas import PreviewStage @@ -31,7 +32,7 @@ def _presentation( def _canvas(qtbot) -> CropCanvas: - canvas = CropCanvas() + canvas = ExclusionCanvas() qtbot.addWidget(canvas) canvas.resize(200, 100) canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) @@ -91,6 +92,85 @@ def test_a_region_drag_dispatches_exactly_once_on_release(qtbot) -> None: assert events[0] == ExclusionsChanged((CropSpec(40, 10, 30, 20),)) +@pytest.mark.parametrize( + ("index", "updated"), + [ + (0, (CropSpec(60, 10, 20, 20),)), + (1, (CropSpec(20, 10, 20, 20),)), + (0, (CropSpec(30, 10, 20, 20), CropSpec(60, 10, 20, 20))), + ], +) +def test_region_state_change_cancels_an_in_flight_drag( + qtbot, index: int, updated: tuple[CropSpec, ...] +) -> None: + regions = (CropSpec(20, 10, 20, 20), CropSpec(60, 10, 20, 20)) + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=regions), active=True, editable=True + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + x = 25 if index == 0 else 65 + qtbot.mousePress(canvas, Qt.MouseButton.LeftButton, pos=_source_pos(canvas, x, 15)) + qtbot.mouseMove(canvas, _source_pos(canvas, x + 5, 15)) + canvas.apply_presentation( + _presentation(exclusions=updated), active=True, editable=True + ) + + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, x + 5, 15), + ) + + assert events == [] + assert canvas._drag_exclusion is None # noqa: SLF001 + + +def test_exclusion_editing_stays_active_when_crop_is_disabled(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(), active=False, editable=True + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 10, 10), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 30, 25)) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 30, 25), + ) + + assert events == [ExclusionsChanged((CropSpec(10, 10, 20, 15),))] + + +def test_persisted_exclusions_are_painted_when_crop_is_disabled(qtbot) -> None: + canvas = _canvas(qtbot) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=False, + editable=True, + ) + canvas.show() + qtbot.wait(10) + + color = canvas.grab().toImage().pixelColor(_source_pos(canvas, 30, 20)) + + assert color.red() > color.green() + + def test_an_abandoned_rubber_band_dispatches_nothing(qtbot) -> None: canvas = _canvas(qtbot) canvas.set_exclusion_edit(True) @@ -312,6 +392,75 @@ def test_arrow_key_nudges_the_selected_region_once(qtbot) -> None: assert events == [ExclusionsChanged((CropSpec(21, 10, 30, 20),))] +def test_arrow_key_can_move_a_region_onto_the_crop_bounds(qtbot) -> None: + canvas = _canvas(qtbot) + region = CropSpec(19, 10, 30, 20) + canvas.apply_presentation( + _presentation(crop=CropSpec(20, 10, 30, 20), exclusions=(region,)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.keyClick(canvas, Qt.Key.Key_Right) + + assert events == [ExclusionsChanged((CropSpec(20, 10, 30, 20),))] + + +def test_region_mode_keyboard_creates_a_region(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.set_exclusion_edit(True) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.keyClick(canvas, Qt.Key.Key_Insert) + + assert len(events) == 1 + assert isinstance(events[0], ExclusionsChanged) + assert len(events[0].exclusions) == 1 + + +def test_region_mode_keyboard_cycles_selection_and_deletes_it(qtbot) -> None: + regions = (CropSpec(20, 10, 20, 20), CropSpec(60, 10, 20, 20)) + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=regions), active=True, editable=True + ) + canvas.set_exclusion_edit(True) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.keyClick(canvas, Qt.Key.Key_Tab) + assert canvas._selected_exclusion == 0 # noqa: SLF001 + qtbot.keyClick(canvas, Qt.Key.Key_Tab) + assert canvas._selected_exclusion == 1 # noqa: SLF001 + qtbot.keyClick(canvas, Qt.Key.Key_Delete) + + assert events == [ExclusionsChanged((regions[0],))] + + +def test_region_mode_announces_mode_without_a_selection(qtbot) -> None: + canvas = _canvas(qtbot) + canvas.set_exclusion_edit(True) + + assert canvas.accessibleDescription() == ( + "Exclusion region mode: 0 region(s); no region selected" + ) + + def test_leaving_region_mode_restores_crop_handles_and_keeps_painting_regions( qtbot, ) -> None: diff --git a/tests/ui/test_main_window_state_and_source_drop.py b/tests/ui/test_main_window_state_and_source_drop.py index f2f96c6..292ee11 100644 --- a/tests/ui/test_main_window_state_and_source_drop.py +++ b/tests/ui/test_main_window_state_and_source_drop.py @@ -2,15 +2,19 @@ from collections.abc import Callable from dataclasses import dataclass, replace +from fractions import Fraction from pathlib import Path import pytest -from PySide6.QtCore import QByteArray, QMimeData, QSettings, Qt, QUrl +from PySide6.QtCore import QByteArray, QMimeData, QPoint, QSettings, Qt, QUrl from PySide6.QtGui import QDragEnterEvent, QDragLeaveEvent, QDropEvent, QFontMetrics from PySide6.QtTest import QTest from PySide6.QtWidgets import QApplication, QLabel, QPushButton from matteloop.core.errors import AppError, ErrorCode +from matteloop.core.geometry import PointF +from matteloop.core.parameters import ExclusionsChanged +from matteloop.core.specs import CropSpec from matteloop.core.state import ( AppState, ArtifactResult, @@ -60,6 +64,14 @@ def dispatch(self, command: object) -> None: self.commands.append(command) +@dataclass(frozen=True) +class _SourceMetadata: + width: int = 100 + height: int = 50 + duration: Fraction = Fraction(2) + average_rate: Fraction = Fraction(30) + + def _ready() -> AppState: return reduce( reduce(AppState(), SourceLoadRequested("source", "load")), @@ -67,6 +79,14 @@ def _ready() -> AppState: ) +def _ready_with_crop() -> AppState: + state = reduce( + reduce(AppState(), SourceLoadRequested("source", "load")), + SourceLoaded("source", "load", _SourceMetadata()), + ) + return replace(state, crop=CropSpec(10, 10, 60, 30)) + + def _current() -> AppState: running = reduce(_ready(), PreviewRequested("preview", "preview-request")) return reduce( @@ -545,6 +565,36 @@ def test_replace_dispatch_includes_replace_intent(window, qtbot) -> None: assert services.commands == [ChooseVideoRequested(replace=True)] +def test_edit_regions_switches_the_original_canvas_to_region_mode( + window, qtbot +) -> None: + value, services = window + value.render_state(_ready_with_crop()) + qtbot.mouseClick( + value.inspector.exclusion_controls.edit_button, + Qt.MouseButton.LeftButton, + ) + canvas = value.original_canvas + assert canvas._geometry is not None # noqa: SLF001 + start = canvas._geometry.transform.source_to_widget(PointF(20, 20)) + end = canvas._geometry.transform.source_to_widget(PointF(50, 35)) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=QPoint(round(start.x), round(start.y)), + ) + qtbot.mouseMove(canvas, QPoint(round(end.x), round(end.y))) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=QPoint(round(end.x), round(end.y)), + ) + + assert services.commands + assert isinstance(services.commands[-1], ExclusionsChanged) + + def test_invalid_saved_geometry_falls_back_to_default(window) -> None: value, _ = window settings = value._settings diff --git a/tests/ui/test_parameter_inspector.py b/tests/ui/test_parameter_inspector.py index db2abc9..e2d6b64 100644 --- a/tests/ui/test_parameter_inspector.py +++ b/tests/ui/test_parameter_inspector.py @@ -297,7 +297,6 @@ def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: assert modes == [True] assert commands == [ExclusionsChanged(())] assert store.state.parameters.exclusions == () - inspector.apply_parameters(present_parameters(store.state), editable=False) assert modes == [True, False] @@ -306,6 +305,22 @@ def test_exclusion_controls_toggle_edit_mode_and_clear_regions(qtbot) -> None: assert controls.count_label.text() == "0 region(s)" +def test_reset_is_enabled_when_exclusion_regions_differ_from_defaults(qtbot) -> None: + inspector = Inspector(_settings()) + qtbot.addWidget(inspector) + state = AppState( + source=SourceState.READY, + source_id="source", + source_value=object(), + parameters=ParameterState(exclusions=(CropSpec(10, 10, 20, 20),)), + timeline=TimelineState(Fraction(4), Fraction(0), Fraction(4), Fraction(0)), + ) + + inspector.apply_parameters(present_parameters(state), editable=True) + + assert inspector.reset_parameters_button.isEnabled() + + def test_inspector_emits_edge_mode_from_the_standard_combo(qtbot) -> None: inspector = Inspector(_settings()) qtbot.addWidget(inspector) diff --git a/tests/ui/test_transform_stage.py b/tests/ui/test_transform_stage.py index b3bba82..32c5bba 100644 --- a/tests/ui/test_transform_stage.py +++ b/tests/ui/test_transform_stage.py @@ -415,6 +415,41 @@ def test_region_change_recomputes_facts_and_reloads_player_frames_without_the_re controller.shutdown() +def test_region_change_outside_the_cut_does_not_recompute_or_reload_frames( + tmp_path, qtbot +) -> None: + artifact = _seed_cut(tmp_path, "region-outside-cut") + initial_region = CropSpec(200, 0, 8, 8) + ready = _ready_state(tmp_path / "source.mp4") + state = replace( + ready, + parameters=replace( + ready.parameters, + exclusions=(initial_region,), + ), + ) + reader = _CountingReader() + store = ReducerStore(state) + controller = TransformStageController(store, frame_reader=reader) + canvas = ResultPlayerCanvas() + qtbot.addWidget(canvas) + group = TransformGroup(lambda _event: None) + qtbot.addWidget(group) + controller.attach(group, canvas) + controller.open_artifact(artifact) + qtbot.waitUntil(lambda: canvas._frames is not None, timeout=5000) + initial_reads = reader.calls + + store.dispatch(ExclusionsChanged((CropSpec(208, 0, 8, 8),))) + qtbot.wait(500) + + assert reader.calls == initial_reads + assert controller._framing.exclusions == ( # noqa: SLF001 + CropSpec(208, 0, 8, 8), + ) + controller.shutdown() + + def test_facts_ready_clamps_a_crop_left_over_from_a_larger_framed_size( tmp_path, qtbot ) -> None: From 7500ee8413c368ce4d879dd3b9d9d4d817750cdb Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 13:25:45 +0200 Subject: [PATCH 10/21] =?UTF-8?q?=E2=9C=A8=20feat(ui):=20add=20source=20co?= =?UTF-8?q?ntext=20menu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ Features: - Right-clicking the source frame now offers the region actions where the user is looking, instead of only through the inspector's Edit toggle. `ExclusionCanvas.contextMenuEvent` builds the menu from what lies under the pointer: *Exclude this area* over empty canvas, *Remove this region* over a region, plus *Remove all regions* whenever any exist and a checkable *Edit exclusion regions* that mirrors the inspector. - `_create_exclusion` places a region sized at 20% of the source frame, clamped to it, selects it and enters region mode. The action creates a default-sized region rather than starting a rubber band, because beginning a drag gesture from a menu is unreliable; the handles that already exist resize it. - Every entry is one `ExclusionsChanged` through the reducer, never a direct canvas mutation, so the menu cannot drift from the inspector. - The menu is absent while editing is unavailable, rather than offering entries the reducer would silently drop — this is the first context menu in the application, so it sets the pattern. - `contextMenuEvent` carries Shift+F10 and the Menu key, and the keyboard path opens at the focused region rather than at the widget origin. - 🔄 The two menu shapes are built by one path with the entries in the same order in both. A region under the pointer implies at least one exists, so a single condition covers what were two duplicated branches that also placed *Remove all regions* differently in each. - 🧪 Tests: - `test_context_menu_lists_region_actions_for_empty_and_occupied_canvas _areas` pins both menu shapes and the checked mode state. - `test_context_menu_excludes_a_clamped_default_region_with_one_dispatch` pins one dispatch, the clamp, the selection and the mode change; `test_context_menu_removes_the_region_under_the_pointer` and `test_context_menu_removes_all_regions_with_one_dispatch` pin targeted and bulk deletion at one dispatch each. - `test_keyboard_context_menu_uses_the_focused_region_position` pins the keyboard route and a position that is not the widget origin; `test_context_menu_offers_no_actions_when_editing_is_unavailable` pins the capability gate; `test_source_context_menu_edit_action_keeps_inspector_mode_in_sync` pins that both surfaces agree. - A `QAction` carries no accessible-name API — assistive technology reads the action's text — so a dynamic property of that name was a no-op that looked like accessibility work. It is gone, and the test that asserted it now asserts the text is present instead. - 📝 Decision 6 of `docs/designs/exclusion-regions.md` records the menu, why it creates a default-sized region, and that the inspector row remains the discovery and keyboard surface. Catalogues carry the four new strings, 540 total, 0 unfinished in both languages. Refs #80 --- docs/designs/exclusion-regions.md | 25 ++- resources/matteloop_de.qm | Bin 70580 -> 71033 bytes resources/matteloop_de.ts | 28 ++- resources/matteloop_en.qm | Bin 62592 -> 62993 bytes resources/matteloop_en.ts | 28 ++- src/matteloop/ui/exclusion_canvas.py | 190 +++++++++++++++++- src/matteloop/ui/main_window.py | 3 + tests/ui/test_exclusion_context_menu.py | 189 +++++++++++++++++ .../test_main_window_state_and_source_drop.py | 22 ++ 9 files changed, 471 insertions(+), 14 deletions(-) create mode 100644 tests/ui/test_exclusion_context_menu.py diff --git a/docs/designs/exclusion-regions.md b/docs/designs/exclusion-regions.md index a1bff13..3931ca8 100644 --- a/docs/designs/exclusion-regions.md +++ b/docs/designs/exclusion-regions.md @@ -642,6 +642,28 @@ five lines that construct, place, apply and tab-order it: - Wiring: `main_window.py:224-225` already connects `command_requested`; one more line connects `edit_toggled` to `original_canvas.set_exclusion_edit`. +**Source-canvas context menu.** `ExclusionCanvas.contextMenuEvent` is the +first context-menu pattern in the application and remains deliberately small. +It builds its actions from the oriented source point under the pointer: + +- Empty canvas: `Exclude this area`, checkable `Edit exclusion regions`, and + `Remove all regions` when at least one region exists. +- Existing region: `Remove this region`, `Remove all regions`, and checkable + `Edit exclusion regions`. + +The menu is unavailable while `capabilities(state).can_edit` is false, and +each mutating action emits exactly one `ExclusionsChanged` command for the +reducer. `Exclude this area` creates a default-sized rectangle derived from +the source dimensions (20% of each dimension), centred on the click and +clamped inside the frame. It does not start a rubber band: beginning a drag +from a menu is unreliable, while the existing handles let the user resize the +newly selected region immediately. The menu handles keyboard-origin context +events at the selected region, or the frame centre when no region is selected. + +The Inspector row remains the discovery surface and the keyboard path. Its +toggle and the menu's checkable toggle stay synchronized in both directions; +the menu is an accelerator, not a replacement for the Inspector controls. + **`CropCanvas` in region mode** (`set_exclusion_edit(enabled: bool)`): - `CropPresentation` gains `exclusions: tuple[CropSpec, ...] = ()` (`ui/crop_presentation.py:12-21`), filled by `present_crop` from @@ -728,7 +750,8 @@ press-move×N-release and asserts exactly one. `"Exclusions"` (form label, via `inspector_label` in `ui/copy.py:632-654`), `"Edit regions"`, `"Edit exclusion regions"` (accessible name), `"Clear"` (exists), `"Clear exclusion regions"` (accessible name), `"%n region(s)"`, -the canvas description above. +the canvas description above, `"Exclude this area"`, `"Remove this region"`, +and `"Remove all regions"` (context-menu actions). **README and screenshots.** `scripts/screenshots.py:_state` (`:120`) gets one region in its `ParameterState` so `main-window.png` shows a rectangle on the diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index d7a983c9274cf65e4685deae2f0eb396bc52e5cc..35e3ca72f3098dcab96b322fdf6477c7ecc9108e 100644 GIT binary patch delta 4647 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�LJdnWVWKgtqV2zne#a#OqzlYPe{aQ#i%?@(Kg;6|5;NqW+b^8uKKmN7S{7?vUoc7APttmNQR=H6+93`s z$9ZeDUb-_R(o5@gyB0{>sr74<37oy8^~S;ma_G<+f8Fd3jzEtPoh9r*TW%s_b>UCqfqyb|s~=T! zY6-eEPm0-?F6q|$t2u0T>JpBn0{0K;er-TPy^rd4RkdJFtkfM)d9cxB>54}4y(@!s z#SiFd-digcyX&50@Sxs9bWn>;@}oufws#dfo2{;9gEu|d zqZe*a`s_fxI`40e$v%3gisQ`wSiQ%m0KmaXKQqjq4aZ#{WMa}CkJSgcw50U^)i0WQ z6ljyBUlJa}oG|O7Gwj%k{q!3Xx#C#{=(o0w;${_N#p`kUZCwjEWi40q+h_YSxklO1TGqt`g^U&{MZ8hy;bvBMz#7sbNN3+HrTi_6z+`;&7V7SEw3y&))VFdLG^u=rUVkm6%lGI|-mQN9=~lSpL3Ttj5hO^(-ED=sk` zRxV;_>`xhz3g}_q4u&)+z}}^X1FIggU+4`v)tk9t*&6a1knnC7L;kuk3_+No$la0k z|E1XQZe%7fxytad`g+|8Xw;Q8VyyK>)3;-|B3(8re-STv8QY|&Ii?30yG#5ZJ;CVQ zknf#$Hull9g9?SlKFy{A>q3m*o)fuX95;G*=N6rnZuD)D#GEQHP8`eo%f1*V+rQ&N za?d!`{vGSTiIZ{GS~AQ%VGLh6nT=ga;`VgKB2IK?-7Z(eC1m!}K@nFj24b=mLvwoYOE;zIt--`Kip}dj z%=UUpr|BDjH|>?qFGx&sQyePUqOTrMoIBdFQ`Rc30}Ht6WwvA44pMIas{mc% zmHYdtgv(3iQIRw6_f}rcde3FmqE}uw_2woMW0tQ3bKGW`HU3%rb`Lk}1T}m6Y;&WQ z^lWFL+2$*WoPK2Pki39jH0kCZv%}aQT9`c-zT`BkHV@gJP30z=eLk|4pR6?p){^In z3iHenq5Qt+XAXIE73gridy<^Up$r#3uH0N9=vB&4k`L}*zC@z>UrO@z_spiL*iQOE{PuiyN hOriginal-Videobild - + Exclusion region mode: %1 region(s); no region selected Ausschlussregion-Modus: %1 Region(en); keine Region ausgewählt - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel @@ -45,6 +45,30 @@ Zuschnittgrenzen: x %s, y %s, Breite %s, Höhe %s Quellpixel; Quelle %s × %s + + ExclusionCanvas + + + Exclude this area + Diesen Bereich ausschließen + + + + Remove this region + Diese Region entfernen + + + + + Remove all regions + Alle Regionen entfernen + + + + Edit exclusion regions + Ausschlussregionen bearbeiten + + ExclusionControls diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index fb239e8dbec587116420b08546e86fc0ea02d8c0..7bda2a7ef5c21e2dfd60233257863614037a194f 100644 GIT binary patch delta 4650 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 delta 4350 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 ZR|JbaHD%yY@1x&-eMmeSQt$Zl{{aI4BSQcH diff --git a/resources/matteloop_en.ts b/resources/matteloop_en.ts index cb9ddc4..0071cf1 100644 --- a/resources/matteloop_en.ts +++ b/resources/matteloop_en.ts @@ -30,12 +30,12 @@ Original video frame - + Exclusion region mode: %1 region(s); no region selected Exclusion region mode: %1 region(s); no region selected - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels @@ -45,6 +45,30 @@ Crop bounds: x %s, y %s, width %s, height %s source pixels; source %s × %s + + ExclusionCanvas + + + Exclude this area + Exclude this area + + + + Remove this region + Remove this region + + + + + Remove all regions + Remove all regions + + + + Edit exclusion regions + Edit exclusion regions + + ExclusionControls diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index f2017c7..a786513 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -2,11 +2,21 @@ from __future__ import annotations +from collections.abc import Callable +from functools import partial from pathlib import Path -from PySide6.QtCore import QCoreApplication, QPointF, QRectF, Qt -from PySide6.QtGui import QColor, QKeyEvent, QMouseEvent, QPainter, QPen -from PySide6.QtWidgets import QWidget +from PySide6.QtCore import QCoreApplication, QPoint, QPointF, QRectF, Qt, Signal +from PySide6.QtGui import ( + QAction, + QColor, + QContextMenuEvent, + QKeyEvent, + QMouseEvent, + QPainter, + QPen, +) +from PySide6.QtWidgets import QMenu, QWidget from matteloop.core.crop import ( crop_from_drag, @@ -29,6 +39,8 @@ class ExclusionCanvas(CropCanvas): """Add source-region editing while retaining CropCanvas's crop hooks.""" + exclusion_edit_toggled = Signal(bool) + def __init__( self, parent: QWidget | None = None, @@ -63,6 +75,146 @@ def set_exclusion_edit(self, enabled: bool) -> None: self._rebuild_geometry() self._announce_crop() self.update() + self.exclusion_edit_toggled.emit(enabled) + + def contextMenuEvent(self, event: QContextMenuEvent) -> None: + if self._presentation is None or not self._editable: + event.ignore() + return + position = self._context_menu_position(event) + menu = self._build_context_menu(position) + if not menu.actions(): + event.ignore() + return + self._show_context_menu(menu, position) + event.accept() + + def _build_context_menu(self, position: QPoint) -> QMenu: + menu = QMenu(self) + presentation = self._presentation + if presentation is None or not self._editable: + return menu + index = self._exclusion_at(position) + if index is None: + self._add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Exclude this area"), + "exclude_area", + lambda: self._create_exclusion(position), + ) + else: + self._add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Remove this region"), + "remove_exclusion", + partial(self._remove_exclusion, index), + ) + # A region under the cursor implies there is at least one, so this one + # condition covers both branches -- and keeps every entry in the same + # place in both menus, which is what makes the menu learnable. + if presentation.exclusions: + self._add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Remove all regions"), + "remove_all_exclusions", + self._remove_all_exclusions, + ) + self._add_edit_context_action(menu) + return menu + + def _add_edit_context_action(self, menu: QMenu) -> None: + action = self._add_context_action( + menu, + QCoreApplication.translate( + "ExclusionCanvas", "Edit exclusion regions" + ), + "edit_exclusion_regions", + None, + ) + action.setCheckable(True) + action.setChecked(self._exclusion_edit) + action.triggered.connect(self.set_exclusion_edit) + + @staticmethod + def _add_context_action( + menu: QMenu, + text: str, + object_name: str, + callback: Callable[[], None] | None, + ) -> QAction: + action = QAction(text, menu) + action.setObjectName(object_name) + action.setToolTip(text) + action.setStatusTip(text) + if callback is not None: + def trigger(_checked: bool = False) -> None: + callback() + + action.triggered.connect(trigger) + menu.addAction(action) + return action + + def _context_menu_position(self, event: QContextMenuEvent) -> QPoint: + if event.reason() is QContextMenuEvent.Reason.Keyboard: + index = self._selected_exclusion + if ( + index is not None + and self._presentation is not None + and self._geometry is not None + and index < len(self._presentation.exclusions) + ): + rect = self._widget_rect( + self._geometry, self._presentation.exclusions[index] + ) + return QPoint(round(rect.center().x()), round(rect.center().y())) + if self._geometry is not None and isinstance( + self._geometry.transform, MediaTransform + ): + content = self._geometry.transform.content_rect + return QPoint( + round(content.x + content.width / 2), + round(content.y + content.height / 2), + ) + return self.rect().center() + position = event.pos() + return position if self.rect().contains(position) else self.rect().center() + + def _show_context_menu(self, menu: QMenu, position: QPoint) -> None: + menu.exec(self.mapToGlobal(position)) + + def _exclusion_at(self, position: QPoint) -> int | None: + if self._presentation is None: + return None + oriented = self._oriented_position(position) + for index in range(len(self._presentation.exclusions) - 1, -1, -1): + if _contains(self._presentation.exclusions[index], oriented): + return index + return None + + def _remove_exclusion(self, index: int) -> None: + if self._presentation is None or index >= len(self._presentation.exclusions): + return + exclusions = self._presentation.exclusions + updated = exclusions[:index] + exclusions[index + 1 :] + if self._selected_exclusion == index: + self._clear_exclusion_selection() + elif self._selected_exclusion is not None and self._selected_exclusion > index: + self._selected_exclusion -= 1 + self._clear_gesture() + self._rebuild_geometry() + self._announce_crop() + self.update() + self.command_requested.emit(ExclusionsChanged(updated)) + + def _remove_all_exclusions(self) -> None: + if self._presentation is None or not self._presentation.exclusions: + return + self._clear_exclusion_selection() + self._clear_gesture() + self._rebuild_geometry() + self._announce_crop() + self.update() + self.command_requested.emit(ExclusionsChanged(())) def apply_presentation( self, @@ -384,7 +536,7 @@ def _exclusion_event(self, region: CropSpec) -> ExclusionsChanged: exclusions[self._selected_exclusion] = region return ExclusionsChanged(tuple(exclusions)) - def _oriented_position(self, position: QPointF | PointF) -> PointF: + def _oriented_position(self, position: QPoint | QPointF | PointF) -> PointF: if self._geometry is None: return PointF(0, 0) point = ( @@ -456,20 +608,40 @@ def _cycle_exclusion_selection(self, *, backwards: bool) -> bool: self.update() return True - def _create_exclusion(self) -> None: + def _create_exclusion(self, position: QPoint | None = None) -> None: if self._presentation is None: return - width = min(8, self._presentation.width) - height = min(8, self._presentation.height) + if not self._exclusion_edit: + self.set_exclusion_edit(True) + width = max(1, round(self._presentation.width * 0.2)) + height = max(1, round(self._presentation.height * 0.2)) + width = min(width, self._presentation.width) + height = min(height, self._presentation.height) + if position is None: + center = PointF( + self._presentation.width / 2, self._presentation.height / 2 + ) + else: + center = self._clamp_oriented(self._oriented_position(position)) + left = min( + max(round(center.x - width / 2), 0), self._presentation.width - width + ) + top = min( + max(round(center.y - height / 2), 0), self._presentation.height - height + ) region = CropSpec( - (self._presentation.width - width) // 2, - (self._presentation.height - height) // 2, + left, + top, width, height, ) self._set_exclusion_selection( len(self._presentation.exclusions), value=region ) + self.setFocus(Qt.FocusReason.OtherFocusReason) + self._rebuild_geometry() + self._announce_crop() + self.update() self.command_requested.emit(self._exclusion_event(region)) def _reconcile_exclusion_state( diff --git a/src/matteloop/ui/main_window.py b/src/matteloop/ui/main_window.py index 62b2579..c6cf7b7 100644 --- a/src/matteloop/ui/main_window.py +++ b/src/matteloop/ui/main_window.py @@ -226,6 +226,9 @@ def _build(self) -> None: self.inspector.exclusion_controls.edit_toggled.connect( self.original_canvas.set_exclusion_edit ) + self.original_canvas.exclusion_edit_toggled.connect( + self.inspector.exclusion_controls.edit_button.setChecked + ) self.render_button.clicked.connect( lambda: self._services.dispatch(RenderVideoRequested()) ) diff --git a/tests/ui/test_exclusion_context_menu.py b/tests/ui/test_exclusion_context_menu.py new file mode 100644 index 0000000..0a4b87f --- /dev/null +++ b/tests/ui/test_exclusion_context_menu.py @@ -0,0 +1,189 @@ +from __future__ import annotations + +from PySide6.QtCore import QPoint, Qt +from PySide6.QtGui import QContextMenuEvent, QImage +from PySide6.QtWidgets import QMenu + +from matteloop.core.geometry import PointF +from matteloop.core.parameters import ExclusionsChanged +from matteloop.core.specs import CropSpec +from matteloop.ui.crop_presentation import CropPresentation +from matteloop.ui.exclusion_canvas import ExclusionCanvas + + +def _presentation( + exclusions: tuple[CropSpec, ...] = (), +) -> CropPresentation: + return CropPresentation( + source_id="source", + width=100, + height=50, + coded_width=100, + coded_height=50, + rotation=0, + pixel_aspect=1, + crop=CropSpec(10, 10, 80, 30), + exclusions=exclusions, + ) + + +def _canvas( + qtbot, + exclusions: tuple[CropSpec, ...] = (), + *, + editable: bool = True, +) -> ExclusionCanvas: + canvas = ExclusionCanvas() + qtbot.addWidget(canvas) + canvas.resize(200, 100) + canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) + canvas.apply_presentation( + _presentation(exclusions), active=True, editable=editable + ) + canvas.show() + return canvas + + +def _source_pos(canvas: ExclusionCanvas, x: int, y: int) -> QPoint: + assert canvas._geometry is not None # noqa: SLF001 + point = canvas._geometry.transform.source_to_widget(PointF(x, y)) + return QPoint(round(point.x), round(point.y)) + + +def _action(menu: QMenu, text: str): + return next(action for action in menu.actions() if action.text() == text) + + +def test_context_menu_lists_region_actions_for_empty_and_occupied_canvas_areas( + qtbot, +) -> None: + empty_canvas = _canvas(qtbot) + empty_menu = empty_canvas._build_context_menu( # noqa: SLF001 + _source_pos(empty_canvas, 5, 5) + ) + + occupied_canvas = _canvas( + qtbot, exclusions=(CropSpec(20, 10, 30, 20),) + ) + occupied_menu = occupied_canvas._build_context_menu( # noqa: SLF001 + _source_pos(occupied_canvas, 25, 15) + ) + + assert [action.text() for action in empty_menu.actions()] == [ + "Exclude this area", + "Edit exclusion regions", + ] + assert [action.text() for action in occupied_menu.actions()] == [ + "Remove this region", + "Remove all regions", + "Edit exclusion regions", + ] + # A QAction carries no accessible-name API; assistive technology reads the + # action's text, so that is what has to be present and meaningful. + assert all(action.text().strip() for action in occupied_menu.actions()) + assert all(not action.isSeparator() for action in occupied_menu.actions()) + assert _action(occupied_menu, "Edit exclusion regions").isCheckable() + assert not _action(occupied_menu, "Edit exclusion regions").isChecked() + + occupied_canvas.set_exclusion_edit(True) + checked_menu = occupied_canvas._build_context_menu( # noqa: SLF001 + _source_pos(occupied_canvas, 25, 15) + ) + assert _action(checked_menu, "Edit exclusion regions").isChecked() + + +def test_context_menu_excludes_a_clamped_default_region_with_one_dispatch( + qtbot, +) -> None: + canvas = _canvas(qtbot) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 95, 45) + ) + _action(menu, "Exclude this area").trigger() + + assert events == [ExclusionsChanged((CropSpec(80, 40, 20, 10),))] + assert canvas._exclusion_edit is True # noqa: SLF001 + assert canvas._selected_exclusion == 0 # noqa: SLF001 + + +def test_context_menu_removes_the_region_under_the_pointer(qtbot) -> None: + regions = (CropSpec(10, 5, 20, 15), CropSpec(70, 20, 20, 15)) + canvas = _canvas(qtbot, exclusions=regions) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 75, 25) + ) + _action(menu, "Remove this region").trigger() + + assert events == [ExclusionsChanged((regions[0],))] + + +def test_context_menu_removes_all_regions_with_one_dispatch(qtbot) -> None: + canvas = _canvas( + qtbot, exclusions=(CropSpec(10, 5, 20, 15), CropSpec(70, 20, 20, 15)) + ) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 5, 5) + ) + _action(menu, "Remove all regions").trigger() + + assert events == [ExclusionsChanged(())] + + +class _ContextMenuProbe(ExclusionCanvas): + def __init__(self) -> None: + super().__init__() + self.shown_position: QPoint | None = None + self.shown_actions: list[str] = [] + + def _show_context_menu(self, menu: QMenu, position: QPoint) -> None: + self.shown_position = position + self.shown_actions = [action.text() for action in menu.actions()] + + +def test_keyboard_context_menu_uses_the_focused_region_position(qtbot) -> None: + canvas = _ContextMenuProbe() + qtbot.addWidget(canvas) + canvas.resize(200, 100) + canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + canvas._set_exclusion_selection(0) # noqa: SLF001 + canvas.setFocus(Qt.FocusReason.OtherFocusReason) + + event = QContextMenuEvent( + QContextMenuEvent.Reason.Keyboard, + QPoint(0, 0), + QPoint(0, 0), + ) + canvas.contextMenuEvent(event) + + assert canvas.shown_position is not None + assert canvas.shown_position != QPoint(0, 0) + assert canvas.shown_actions[0] == "Remove this region" + assert event.isAccepted() + + +def test_context_menu_offers_no_actions_when_editing_is_unavailable(qtbot) -> None: + canvas = _canvas(qtbot, exclusions=(CropSpec(20, 10, 30, 20),), editable=False) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 25, 15) + ) + + assert menu.actions() == [] + assert events == [] diff --git a/tests/ui/test_main_window_state_and_source_drop.py b/tests/ui/test_main_window_state_and_source_drop.py index 292ee11..f5401a4 100644 --- a/tests/ui/test_main_window_state_and_source_drop.py +++ b/tests/ui/test_main_window_state_and_source_drop.py @@ -595,6 +595,28 @@ def test_edit_regions_switches_the_original_canvas_to_region_mode( assert isinstance(services.commands[-1], ExclusionsChanged) +def test_source_context_menu_edit_action_keeps_inspector_mode_in_sync( + window, +) -> None: + value, _ = window + value.render_state(_ready_with_crop()) + canvas = value.original_canvas + assert canvas._geometry is not None # noqa: SLF001 + + menu = canvas._build_context_menu( # noqa: SLF001 + canvas._geometry.transform.source_to_widget(PointF(20, 20)) + ) + edit_action = next( + action + for action in menu.actions() + if action.text() == "Edit exclusion regions" + ) + edit_action.trigger() + + assert canvas._exclusion_edit is True # noqa: SLF001 + assert value.inspector.exclusion_controls.edit_button.isChecked() + + def test_invalid_saved_geometry_falls_back_to_default(window) -> None: value, _ = window settings = value._settings From 63af7adc416226d7ffbdb94e2a19cac108034531 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 14:17:05 +0200 Subject: [PATCH 11/21] =?UTF-8?q?=F0=9F=90=9B=20fix(exclusions):=20sync=20?= =?UTF-8?q?region=20gestures?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects:\n - Region creation now cancels a different in-flight drag before the new selection can be nudged or released.\n - Bracket keys cycle regions without entering Qt's focus-traversal path, and crop handles stay hidden when Crop is disabled.\n- 🧪 Tests:\n - The drag regression covers N, a reducer presentation update, an arrow nudge and the later mouse release.\n - The keyboard regression uses a real window with a second focusable control and checks the Crop-off rendering.\n\nTrigger: repro — drag an existing region, press N, nudge the new region and release; with another focusable widget present, Tab moves focus instead of selecting a region.\n\nRefs #80 --- src/matteloop/ui/exclusion_canvas.py | 19 +++--- tests/ui/test_crop_canvas.py | 93 ++++++++++++++++++++++++++-- 2 files changed, 101 insertions(+), 11 deletions(-) diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index a786513..0e52457 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -257,9 +257,12 @@ def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] self._paint_exclusions(painter, geometry) if self._active: self._paint_crop_outline(painter, crop) - if not self._exclusion_edit or self._selected_exclusion is not None: + show_controls = ( + self._active and not self._exclusion_edit + ) or (self._exclusion_edit and self._selected_exclusion is not None) + if show_controls: self._paint_handles(painter, geometry) - if not self._exclusion_edit or self._selected_exclusion is not None: + if show_controls: self._paint_focus_ring(painter, geometry) painter.end() @@ -364,12 +367,12 @@ def _handle_exclusion_key(self, event: QKeyEvent) -> bool: self.update() event.accept() return True - if event.key() in {int(Qt.Key.Key_Tab), int(Qt.Key.Key_Backtab)}: + if event.key() in { + int(Qt.Key.Key_BracketLeft), + int(Qt.Key.Key_BracketRight), + }: if self._cycle_exclusion_selection( - backwards=( - event.key() == int(Qt.Key.Key_Backtab) - or bool(event.modifiers() & Qt.KeyboardModifier.ShiftModifier) - ) + backwards=event.key() == int(Qt.Key.Key_BracketLeft) ): event.accept() return True @@ -581,6 +584,8 @@ def _clear_exclusion_selection(self) -> None: def _set_exclusion_selection( self, index: int, *, value: CropSpec | None = None ) -> None: + if self._selected_exclusion != index: + self._clear_gesture() self._selected_exclusion = index if value is not None: self._selected_exclusion_value = value diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index f9e40cf..a3037dd 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -3,6 +3,7 @@ import pytest from PySide6.QtCore import QPoint, Qt from PySide6.QtGui import QColor, QImage +from PySide6.QtWidgets import QPushButton, QVBoxLayout, QWidget from matteloop.core.crop_state import CropChanged from matteloop.core.geometry import MediaTransform, PointF @@ -129,6 +130,49 @@ def test_region_state_change_cancels_an_in_flight_drag( assert canvas._drag_exclusion is None # noqa: SLF001 +def test_creating_a_region_cancels_the_previous_drag_before_nudging_it(qtbot) -> None: + original = CropSpec(20, 10, 20, 20) + created = CropSpec(40, 20, 20, 10) + canvas = _canvas(qtbot) + canvas.apply_presentation( + _presentation(exclusions=(original,)), active=True, editable=True + ) + canvas.set_exclusion_edit(True) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.mousePress( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 25, 15), + ) + qtbot.mouseMove(canvas, _source_pos(canvas, 30, 15)) + canvas.setFocus() + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + qtbot.keyClick(canvas, Qt.Key.Key_N) + + assert events == [ExclusionsChanged((original, created))] + canvas.apply_presentation( + _presentation(exclusions=(original, created)), + active=True, + editable=True, + ) + assert canvas._selected_exclusion == 1 # noqa: SLF001 + assert canvas._drag_exclusion is None # noqa: SLF001 + + qtbot.keyClick(canvas, Qt.Key.Key_Right) + qtbot.mouseRelease( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, 30, 15), + ) + + assert events == [ + ExclusionsChanged((original, created)), + ExclusionsChanged((original, CropSpec(41, 20, 20, 10))), + ] + + def test_exclusion_editing_stays_active_when_crop_is_disabled(qtbot) -> None: canvas = _canvas(qtbot) canvas.apply_presentation( @@ -431,27 +475,68 @@ def test_region_mode_keyboard_creates_a_region(qtbot) -> None: assert len(events[0].exclusions) == 1 -def test_region_mode_keyboard_cycles_selection_and_deletes_it(qtbot) -> None: +def test_region_mode_bracket_keys_cycle_selection_in_focus_chain(qtbot) -> None: regions = (CropSpec(20, 10, 20, 20), CropSpec(60, 10, 20, 20)) - canvas = _canvas(qtbot) + window = QWidget() + qtbot.addWidget(window) + layout = QVBoxLayout(window) + canvas = ExclusionCanvas(window) + button = QPushButton("Other focusable control", window) + layout.addWidget(canvas) + layout.addWidget(button) + canvas.resize(200, 100) + canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) canvas.apply_presentation( _presentation(exclusions=regions), active=True, editable=True ) canvas.set_exclusion_edit(True) + window.setTabOrder(canvas, button) + window.resize(240, 240) + window.show() canvas.setFocus() qtbot.waitUntil(canvas.hasFocus, timeout=1000) events: list[object] = [] canvas.command_requested.connect(events.append) - qtbot.keyClick(canvas, Qt.Key.Key_Tab) + qtbot.keyClick(canvas, Qt.Key.Key_BracketRight) assert canvas._selected_exclusion == 0 # noqa: SLF001 - qtbot.keyClick(canvas, Qt.Key.Key_Tab) + assert canvas.hasFocus() + qtbot.keyClick(canvas, Qt.Key.Key_BracketLeft) assert canvas._selected_exclusion == 1 # noqa: SLF001 qtbot.keyClick(canvas, Qt.Key.Key_Delete) assert events == [ExclusionsChanged((regions[0],))] +def test_crop_controls_are_hidden_when_crop_is_disabled_but_regions_are_painted( + qtbot, +) -> None: + canvas = _canvas(qtbot) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation(exclusions=(CropSpec(20, 10, 30, 20),)), + active=False, + editable=True, + ) + qtbot.wait(10) + + image = canvas.grab().toImage() + accent = QColor("#B7F34A").rgba() + + assert any( + image.pixelColor(x, y).red() > image.pixelColor(x, y).green() + for x in range(image.width()) + for y in range(image.height()) + ) + assert not any( + image.pixelColor(x, y).rgba() == accent + for x in range(image.width()) + for y in range(image.height()) + ) + + def test_region_mode_announces_mode_without_a_selection(qtbot) -> None: canvas = _canvas(qtbot) canvas.set_exclusion_edit(True) From e64f10c8aed1c85f4c39e1fe9402a212e5283c5a Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 14:25:10 +0200 Subject: [PATCH 12/21] =?UTF-8?q?=F0=9F=90=9B=20fix(context-menu):=20valid?= =?UTF-8?q?ate=20live=20actions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects:\n - Context-menu actions now revalidate editability when triggered, and removal resolves the captured CropSpec instead of a stale tuple index.\n - Keyboard context menus pass the selected region directly, so overlapping regions share one deletion target with the Delete key.\n - Open menus are deleted after dismissal, including the no-action path.\n- 🔄 Structure:\n - Context-menu behavior moves to ; stays below the 800-line budget.\n- 📝 Corrections:\n - claimed every context-menu entry emits ; Edit changes UI-local mode and emits none, so that commit record is corrected here.\n- 🧪 Tests:\n - Keyboard-menu tests use Qt's Menu key, pin the focused position, and cover overlapping deletion.\n - Regression tests cover stale permissions, stale targets and four open-and-dismiss cycles.\n\nTrigger: repro — retain a menu, change editability or replace its regions, then trigger the old action; open a keyboard menu over overlapping regions and remove the selection; repeat open and dismiss four times.\n\nRefs #80 --- src/matteloop/ui/exclusion_canvas.py | 169 +++------------- src/matteloop/ui/exclusion_context_menu.py | 225 +++++++++++++++++++++ tests/ui/test_exclusion_context_menu.py | 115 ++++++++++- 3 files changed, 363 insertions(+), 146 deletions(-) create mode 100644 src/matteloop/ui/exclusion_context_menu.py diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index 0e52457..bd5a982 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -2,13 +2,10 @@ from __future__ import annotations -from collections.abc import Callable -from functools import partial from pathlib import Path from PySide6.QtCore import QCoreApplication, QPoint, QPointF, QRectF, Qt, Signal from PySide6.QtGui import ( - QAction, QColor, QContextMenuEvent, QKeyEvent, @@ -32,6 +29,17 @@ _key_delta, ) from matteloop.ui.crop_presentation import CropPresentation +from matteloop.ui.exclusion_context_menu import ( + build_context_menu, + contains, + context_menu_position, + exclusion_at, + handle_context_menu_event, + handle_context_menu_key, + remove_all_exclusions, + remove_exclusion, + selected_context_region, +) from matteloop.ui.preview_canvas import PreviewCanvas from matteloop.ui.theme import ACCENT_COLOR, CANVAS_COLOR @@ -78,143 +86,30 @@ def set_exclusion_edit(self, enabled: bool) -> None: self.exclusion_edit_toggled.emit(enabled) def contextMenuEvent(self, event: QContextMenuEvent) -> None: - if self._presentation is None or not self._editable: - event.ignore() - return - position = self._context_menu_position(event) - menu = self._build_context_menu(position) - if not menu.actions(): - event.ignore() - return - self._show_context_menu(menu, position) - event.accept() + handle_context_menu_event(self, event) - def _build_context_menu(self, position: QPoint) -> QMenu: - menu = QMenu(self) - presentation = self._presentation - if presentation is None or not self._editable: - return menu - index = self._exclusion_at(position) - if index is None: - self._add_context_action( - menu, - QCoreApplication.translate("ExclusionCanvas", "Exclude this area"), - "exclude_area", - lambda: self._create_exclusion(position), - ) - else: - self._add_context_action( - menu, - QCoreApplication.translate("ExclusionCanvas", "Remove this region"), - "remove_exclusion", - partial(self._remove_exclusion, index), - ) - # A region under the cursor implies there is at least one, so this one - # condition covers both branches -- and keeps every entry in the same - # place in both menus, which is what makes the menu learnable. - if presentation.exclusions: - self._add_context_action( - menu, - QCoreApplication.translate("ExclusionCanvas", "Remove all regions"), - "remove_all_exclusions", - self._remove_all_exclusions, - ) - self._add_edit_context_action(menu) - return menu - - def _add_edit_context_action(self, menu: QMenu) -> None: - action = self._add_context_action( - menu, - QCoreApplication.translate( - "ExclusionCanvas", "Edit exclusion regions" - ), - "edit_exclusion_regions", - None, - ) - action.setCheckable(True) - action.setChecked(self._exclusion_edit) - action.triggered.connect(self.set_exclusion_edit) - - @staticmethod - def _add_context_action( - menu: QMenu, - text: str, - object_name: str, - callback: Callable[[], None] | None, - ) -> QAction: - action = QAction(text, menu) - action.setObjectName(object_name) - action.setToolTip(text) - action.setStatusTip(text) - if callback is not None: - def trigger(_checked: bool = False) -> None: - callback() - - action.triggered.connect(trigger) - menu.addAction(action) - return action + def _build_context_menu( + self, position: QPoint, *, target: CropSpec | None = None + ) -> QMenu: + return build_context_menu(self, position, target=target) def _context_menu_position(self, event: QContextMenuEvent) -> QPoint: - if event.reason() is QContextMenuEvent.Reason.Keyboard: - index = self._selected_exclusion - if ( - index is not None - and self._presentation is not None - and self._geometry is not None - and index < len(self._presentation.exclusions) - ): - rect = self._widget_rect( - self._geometry, self._presentation.exclusions[index] - ) - return QPoint(round(rect.center().x()), round(rect.center().y())) - if self._geometry is not None and isinstance( - self._geometry.transform, MediaTransform - ): - content = self._geometry.transform.content_rect - return QPoint( - round(content.x + content.width / 2), - round(content.y + content.height / 2), - ) - return self.rect().center() - position = event.pos() - return position if self.rect().contains(position) else self.rect().center() + return context_menu_position(self, event) + + def _selected_context_region(self) -> CropSpec | None: + return selected_context_region(self) def _show_context_menu(self, menu: QMenu, position: QPoint) -> None: menu.exec(self.mapToGlobal(position)) def _exclusion_at(self, position: QPoint) -> int | None: - if self._presentation is None: - return None - oriented = self._oriented_position(position) - for index in range(len(self._presentation.exclusions) - 1, -1, -1): - if _contains(self._presentation.exclusions[index], oriented): - return index - return None + return exclusion_at(self, position) - def _remove_exclusion(self, index: int) -> None: - if self._presentation is None or index >= len(self._presentation.exclusions): - return - exclusions = self._presentation.exclusions - updated = exclusions[:index] + exclusions[index + 1 :] - if self._selected_exclusion == index: - self._clear_exclusion_selection() - elif self._selected_exclusion is not None and self._selected_exclusion > index: - self._selected_exclusion -= 1 - self._clear_gesture() - self._rebuild_geometry() - self._announce_crop() - self.update() - self.command_requested.emit(ExclusionsChanged(updated)) + def _remove_exclusion(self, target: CropSpec) -> None: + remove_exclusion(self, target) def _remove_all_exclusions(self) -> None: - if self._presentation is None or not self._presentation.exclusions: - return - self._clear_exclusion_selection() - self._clear_gesture() - self._rebuild_geometry() - self._announce_crop() - self.update() - self.command_requested.emit(ExclusionsChanged(())) + remove_all_exclusions(self) def apply_presentation( self, @@ -343,6 +238,8 @@ def mouseReleaseEvent(self, event: QMouseEvent) -> None: super().mouseReleaseEvent(event) def keyPressEvent(self, event: QKeyEvent) -> None: + if self._handle_context_menu_key(event): + return if not self._exclusion_edit: super().keyPressEvent(event) return @@ -353,6 +250,9 @@ def keyPressEvent(self, event: QKeyEvent) -> None: return super().keyPressEvent(event) + def _handle_context_menu_key(self, event: QKeyEvent) -> bool: + return handle_context_menu_key(self, event) + def _handle_exclusion_key(self, event: QKeyEvent) -> bool: if event.key() in {int(Qt.Key.Key_Delete), int(Qt.Key.Key_Backspace)}: if self._selected_exclusion is None: @@ -441,7 +341,7 @@ def _press_exclusion(self, position: PointF) -> None: for index in range(len(self._presentation.exclusions) - 1, -1, -1): if index == selected: continue - if _contains(self._presentation.exclusions[index], oriented): + if contains(self._presentation.exclusions[index], oriented): self._set_exclusion_selection(index) self._focused_target = "crop" self._announce_crop() @@ -614,7 +514,7 @@ def _cycle_exclusion_selection(self, *, backwards: bool) -> bool: return True def _create_exclusion(self, position: QPoint | None = None) -> None: - if self._presentation is None: + if self._presentation is None or not self._editable: return if not self._exclusion_edit: self.set_exclusion_edit(True) @@ -762,10 +662,3 @@ def _announce_crop(self) -> None: for number, value in enumerate(values, start=1): text = text.replace(f"%{number}", str(value)) self.setAccessibleDescription(text) - - -def _contains(region: CropSpec, point: PointF) -> bool: - return ( - region.x <= point.x < region.x + region.width - and region.y <= point.y < region.y + region.height - ) diff --git a/src/matteloop/ui/exclusion_context_menu.py b/src/matteloop/ui/exclusion_context_menu.py new file mode 100644 index 0000000..4eb6ba4 --- /dev/null +++ b/src/matteloop/ui/exclusion_context_menu.py @@ -0,0 +1,225 @@ +"""Context-menu behavior for the source exclusion canvas.""" + +from __future__ import annotations + +from collections.abc import Callable +from typing import TYPE_CHECKING + +from PySide6.QtCore import QCoreApplication, QPoint, Qt +from PySide6.QtGui import QAction, QContextMenuEvent, QKeyEvent +from PySide6.QtWidgets import QMenu + +from matteloop.core.geometry import MediaTransform, PointF +from matteloop.core.parameters import ExclusionsChanged +from matteloop.core.specs import CropSpec + +if TYPE_CHECKING: + from matteloop.ui.exclusion_canvas import ExclusionCanvas + + +def handle_context_menu_event( + canvas: ExclusionCanvas, event: QContextMenuEvent +) -> None: + if canvas._presentation is None or not canvas._editable: + event.ignore() + return + position = context_menu_position(canvas, event) + target = ( + selected_context_region(canvas) + if event.reason() is QContextMenuEvent.Reason.Keyboard + else None + ) + menu = build_context_menu(canvas, position, target=target) + if not menu.actions(): + menu.deleteLater() + event.ignore() + return + try: + canvas._show_context_menu(menu, position) + finally: + menu.deleteLater() + event.accept() + + +def build_context_menu( + canvas: ExclusionCanvas, position: QPoint, *, target: CropSpec | None = None +) -> QMenu: + menu = QMenu(canvas) + presentation = canvas._presentation + if presentation is None or not canvas._editable: + return menu + if target is None: + index = exclusion_at(canvas, position) + target = presentation.exclusions[index] if index is not None else None + if target is None: + add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Exclude this area"), + "exclude_area", + lambda: canvas._create_exclusion(position), + ) + else: + assert target is not None + + def remove_target() -> None: + remove_exclusion(canvas, target) + + add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Remove this region"), + "remove_exclusion", + remove_target, + ) + if presentation.exclusions: + add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Remove all regions"), + "remove_all_exclusions", + lambda: remove_all_exclusions(canvas), + ) + add_edit_context_action(canvas, menu) + return menu + + +def add_edit_context_action(canvas: ExclusionCanvas, menu: QMenu) -> None: + action = add_context_action( + menu, + QCoreApplication.translate("ExclusionCanvas", "Edit exclusion regions"), + "edit_exclusion_regions", + None, + ) + action.setCheckable(True) + action.setChecked(canvas._exclusion_edit) + action.triggered.connect(lambda enabled: toggle_exclusion_edit(canvas, enabled)) + + +def add_context_action( + menu: QMenu, + text: str, + object_name: str, + callback: Callable[[], None] | None, +) -> QAction: + action = QAction(text, menu) + action.setObjectName(object_name) + action.setToolTip(text) + action.setStatusTip(text) + if callback is not None: + + def trigger(_checked: bool = False) -> None: + callback() + + action.triggered.connect(trigger) + menu.addAction(action) + return action + + +def context_menu_position(canvas: ExclusionCanvas, event: QContextMenuEvent) -> QPoint: + if event.reason() is QContextMenuEvent.Reason.Keyboard: + region = selected_context_region(canvas) + if region is not None and canvas._geometry is not None: + rect = canvas._widget_rect(canvas._geometry, region) + return QPoint(round(rect.center().x()), round(rect.center().y())) + if canvas._geometry is not None and isinstance( + canvas._geometry.transform, MediaTransform + ): + content = canvas._geometry.transform.content_rect + return QPoint( + round(content.x + content.width / 2), + round(content.y + content.height / 2), + ) + return canvas.rect().center() + position = event.pos() + return position if canvas.rect().contains(position) else canvas.rect().center() + + +def selected_context_region(canvas: ExclusionCanvas) -> CropSpec | None: + index = canvas._selected_exclusion + if ( + canvas._presentation is None + or index is None + or index >= len(canvas._presentation.exclusions) + ): + return None + return canvas._presentation.exclusions[index] + + +def exclusion_at(canvas: ExclusionCanvas, position: QPoint) -> int | None: + if canvas._presentation is None: + return None + oriented = canvas._oriented_position(position) + for index in range(len(canvas._presentation.exclusions) - 1, -1, -1): + if contains(canvas._presentation.exclusions[index], oriented): + return index + return None + + +def remove_exclusion(canvas: ExclusionCanvas, target: CropSpec) -> None: + if canvas._presentation is None or not canvas._editable: + return + exclusions = canvas._presentation.exclusions + try: + index = exclusions.index(target) + except ValueError: + return + updated = exclusions[:index] + exclusions[index + 1 :] + if canvas._selected_exclusion == index: + canvas._clear_exclusion_selection() + elif ( + canvas._selected_exclusion is not None + and canvas._selected_exclusion > index + ): + canvas._selected_exclusion -= 1 + canvas._clear_gesture() + canvas._rebuild_geometry() + canvas._announce_crop() + canvas.update() + canvas.command_requested.emit(ExclusionsChanged(updated)) + + +def remove_all_exclusions(canvas: ExclusionCanvas) -> None: + if ( + canvas._presentation is None + or not canvas._editable + or not canvas._presentation.exclusions + ): + return + canvas._clear_exclusion_selection() + canvas._clear_gesture() + canvas._rebuild_geometry() + canvas._announce_crop() + canvas.update() + canvas.command_requested.emit(ExclusionsChanged(())) + + +def toggle_exclusion_edit(canvas: ExclusionCanvas, enabled: bool) -> None: + if canvas._presentation is not None and canvas._editable: + canvas.set_exclusion_edit(enabled) + + +def handle_context_menu_key(canvas: ExclusionCanvas, event: QKeyEvent) -> bool: + if not ( + event.key() == int(Qt.Key.Key_Menu) + or ( + event.key() == int(Qt.Key.Key_F10) + and bool(event.modifiers() & Qt.KeyboardModifier.ShiftModifier) + ) + ): + return False + if canvas._presentation is None or not canvas._editable: + return False + position = canvas.rect().center() + context_event = QContextMenuEvent( + QContextMenuEvent.Reason.Keyboard, + position, + canvas.mapToGlobal(position), + ) + canvas.contextMenuEvent(context_event) + event.accept() + return True + + +def contains(region: CropSpec, point: PointF) -> bool: + return ( + region.x <= point.x < region.x + region.width + and region.y <= point.y < region.y + region.height + ) diff --git a/tests/ui/test_exclusion_context_menu.py b/tests/ui/test_exclusion_context_menu.py index 0a4b87f..a03b670 100644 --- a/tests/ui/test_exclusion_context_menu.py +++ b/tests/ui/test_exclusion_context_menu.py @@ -139,14 +139,17 @@ def test_context_menu_removes_all_regions_with_one_dispatch(qtbot) -> None: class _ContextMenuProbe(ExclusionCanvas): - def __init__(self) -> None: + def __init__(self, *, trigger_text: str | None = None) -> None: super().__init__() self.shown_position: QPoint | None = None self.shown_actions: list[str] = [] + self.trigger_text = trigger_text def _show_context_menu(self, menu: QMenu, position: QPoint) -> None: self.shown_position = position self.shown_actions = [action.text() for action in menu.actions()] + if self.trigger_text is not None: + _action(menu, self.trigger_text).trigger() def test_keyboard_context_menu_uses_the_focused_region_position(qtbot) -> None: @@ -159,21 +162,117 @@ def test_keyboard_context_menu_uses_the_focused_region_position(qtbot) -> None: active=True, editable=True, ) + canvas.show() canvas.set_exclusion_edit(True) canvas._set_exclusion_selection(0) # noqa: SLF001 + canvas.activateWindow() canvas.setFocus(Qt.FocusReason.OtherFocusReason) + qtbot.waitUntil(canvas.hasFocus, timeout=1000) - event = QContextMenuEvent( - QContextMenuEvent.Reason.Keyboard, - QPoint(0, 0), - QPoint(0, 0), + assert canvas._geometry is not None # noqa: SLF001 + expected = canvas._widget_rect( # noqa: SLF001 + canvas._geometry, canvas._presentation.exclusions[0] # noqa: SLF001 ) - canvas.contextMenuEvent(event) + qtbot.keyClick(canvas, Qt.Key.Key_Menu) assert canvas.shown_position is not None - assert canvas.shown_position != QPoint(0, 0) + assert canvas.shown_position == QPoint( + round(expected.center().x()), round(expected.center().y()) + ) assert canvas.shown_actions[0] == "Remove this region" - assert event.isAccepted() + + +def test_keyboard_context_menu_removes_the_selected_region_when_regions_overlap( + qtbot, +) -> None: + regions = (CropSpec(10, 5, 40, 30), CropSpec(20, 10, 30, 20)) + canvas = _ContextMenuProbe(trigger_text="Remove this region") + qtbot.addWidget(canvas) + canvas.resize(200, 100) + canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) + canvas.apply_presentation( + _presentation(exclusions=regions), active=True, editable=True + ) + canvas.show() + canvas.set_exclusion_edit(True) + canvas._set_exclusion_selection(0) # noqa: SLF001 + canvas.activateWindow() + canvas.setFocus(Qt.FocusReason.OtherFocusReason) + qtbot.waitUntil(canvas.hasFocus, timeout=1000) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + qtbot.keyClick(canvas, Qt.Key.Key_Menu) + + assert events == [ExclusionsChanged((regions[1],))] + + +def test_context_menu_actions_revalidate_editability_at_activation(qtbot) -> None: + canvas = _canvas(qtbot) + empty_menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 5, 5) + ) + events: list[object] = [] + canvas.command_requested.connect(events.append) + canvas.apply_presentation(_presentation(), active=True, editable=False) + + _action(empty_menu, "Exclude this area").trigger() + _action(empty_menu, "Edit exclusion regions").trigger() + + assert events == [] + assert canvas._exclusion_edit is False # noqa: SLF001 + + regions = (CropSpec(20, 10, 30, 20),) + canvas.apply_presentation( + _presentation(exclusions=regions), active=True, editable=True + ) + region_menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 25, 15) + ) + canvas.apply_presentation( + _presentation(exclusions=regions), active=True, editable=False + ) + _action(region_menu, "Remove this region").trigger() + _action(region_menu, "Remove all regions").trigger() + + assert events == [] + + +def test_context_menu_removal_revalidates_the_region_identity(qtbot) -> None: + regions = (CropSpec(20, 10, 30, 20), CropSpec(70, 20, 20, 15)) + canvas = _canvas(qtbot, exclusions=regions) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 25, 15) + ) + canvas.apply_presentation( + _presentation(exclusions=(regions[1],)), active=True, editable=True + ) + _action(menu, "Remove this region").trigger() + + assert events == [] + + +def test_context_menu_is_deleted_after_each_opening(qtbot) -> None: + canvas = _ContextMenuProbe() + qtbot.addWidget(canvas) + canvas.resize(200, 100) + canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) + canvas.apply_presentation(_presentation(), active=True, editable=True) + canvas.show() + + for _ in range(4): + event = QContextMenuEvent( + QContextMenuEvent.Reason.Mouse, + _source_pos(canvas, 5, 5), + _source_pos(canvas, 5, 5), + ) + canvas.contextMenuEvent(event) + qtbot.wait(1) + + assert canvas.findChildren(QMenu) == [] def test_context_menu_offers_no_actions_when_editing_is_unavailable(qtbot) -> None: From c00b67c42601884f495a964491d00bfa69a3b3ee Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 14:26:32 +0200 Subject: [PATCH 13/21] =?UTF-8?q?=F0=9F=93=9D=20docs(exclusions):=20clarif?= =?UTF-8?q?y=20menu=20emissions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 📝 Corrections: - The checkable Edit action changes UI-local mode and emits no ExclusionsChanged; only region mutations dispatch the reducer command. - This explicitly corrects the overstated every-entry claim in 7500ee8 without rewriting the pushed-history commit. Refs #80 --- docs/designs/exclusion-regions.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/designs/exclusion-regions.md b/docs/designs/exclusion-regions.md index 3931ca8..f74620c 100644 --- a/docs/designs/exclusion-regions.md +++ b/docs/designs/exclusion-regions.md @@ -663,6 +663,9 @@ events at the selected region, or the frame centre when no region is selected. The Inspector row remains the discovery surface and the keyboard path. Its toggle and the menu's checkable toggle stay synchronized in both directions; the menu is an accelerator, not a replacement for the Inspector controls. +The checkable Edit action changes UI-local mode and emits no +`ExclusionsChanged`; only actions that change the region tuple dispatch that +reducer command. **`CropCanvas` in region mode** (`set_exclusion_edit(enabled: bool)`): - `CropPresentation` gains `exclusions: tuple[CropSpec, ...] = ()` From 62ec9066ca2dbcd6f34b092b2ad555d6b9806c5e Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 14:36:07 +0200 Subject: [PATCH 14/21] =?UTF-8?q?=F0=9F=90=9B=20fix(context-menu):=20retai?= =?UTF-8?q?n=20region=20identity?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - Match retained remove actions to the captured CropSpec object, so an equal duplicate that disappeared cannot delete its survivor. - 🧪 Tests: - Cover the duplicate-target race and dismiss four real QMenu.exec openings. Trigger: repro — retain a remove action for one of two equal-valued regions, replace it with the other, and open and dismiss four context menus. Refs #80 --- src/matteloop/ui/exclusion_context_menu.py | 8 +++-- tests/ui/test_exclusion_context_menu.py | 42 +++++++++++++++++----- 2 files changed, 38 insertions(+), 12 deletions(-) diff --git a/src/matteloop/ui/exclusion_context_menu.py b/src/matteloop/ui/exclusion_context_menu.py index 4eb6ba4..a9b19a8 100644 --- a/src/matteloop/ui/exclusion_context_menu.py +++ b/src/matteloop/ui/exclusion_context_menu.py @@ -157,9 +157,11 @@ def remove_exclusion(canvas: ExclusionCanvas, target: CropSpec) -> None: if canvas._presentation is None or not canvas._editable: return exclusions = canvas._presentation.exclusions - try: - index = exclusions.index(target) - except ValueError: + index = next( + (index for index, exclusion in enumerate(exclusions) if exclusion is target), + None, + ) + if index is None: return updated = exclusions[:index] + exclusions[index + 1 :] if canvas._selected_exclusion == index: diff --git a/tests/ui/test_exclusion_context_menu.py b/tests/ui/test_exclusion_context_menu.py index a03b670..d4e44ed 100644 --- a/tests/ui/test_exclusion_context_menu.py +++ b/tests/ui/test_exclusion_context_menu.py @@ -1,6 +1,6 @@ from __future__ import annotations -from PySide6.QtCore import QPoint, Qt +from PySide6.QtCore import QPoint, Qt, QTimer from PySide6.QtGui import QContextMenuEvent, QImage from PySide6.QtWidgets import QMenu @@ -255,24 +255,48 @@ def test_context_menu_removal_revalidates_the_region_identity(qtbot) -> None: assert events == [] +def test_context_menu_removal_rejects_a_gone_duplicate_region(qtbot) -> None: + first = CropSpec(20, 10, 30, 20) + second = CropSpec(20, 10, 30, 20) + canvas = _canvas(qtbot, exclusions=(first, second)) + events: list[object] = [] + canvas.command_requested.connect(events.append) + + menu = canvas._build_context_menu( # noqa: SLF001 + _source_pos(canvas, 25, 15) + ) + canvas.apply_presentation( + _presentation(exclusions=(first,)), active=True, editable=True + ) + _action(menu, "Remove this region").trigger() + + assert events == [] + + def test_context_menu_is_deleted_after_each_opening(qtbot) -> None: - canvas = _ContextMenuProbe() - qtbot.addWidget(canvas) - canvas.resize(200, 100) - canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) - canvas.apply_presentation(_presentation(), active=True, editable=True) - canvas.show() + canvas = _canvas(qtbot) + opened_counts: list[int] = [] + + def dismiss_open_menu() -> None: + menus = canvas.findChildren(QMenu) + visible_menus = [menu for menu in menus if menu.isVisible()] + opened_counts.append(len(visible_menus)) + for menu in visible_menus: + menu.close() - for _ in range(4): + for index in range(4): event = QContextMenuEvent( QContextMenuEvent.Reason.Mouse, _source_pos(canvas, 5, 5), _source_pos(canvas, 5, 5), ) + QTimer.singleShot(0, dismiss_open_menu) canvas.contextMenuEvent(event) + qtbot.waitUntil(lambda: len(opened_counts) == index + 1, timeout=1000) qtbot.wait(1) + assert canvas.findChildren(QMenu) == [] - assert canvas.findChildren(QMenu) == [] + assert opened_counts == [1, 1, 1, 1] def test_context_menu_offers_no_actions_when_editing_is_unavailable(qtbot) -> None: From 70293e084b305f909baf9487bfddb2fa1b0da502 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 14:50:31 +0200 Subject: [PATCH 15/21] =?UTF-8?q?=F0=9F=90=9B=20fix(exclusions):=20show=20?= =?UTF-8?q?effective=20areas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - Paint each region's `cut_exclusions` intersection with the existing solid red treatment and fade the inert remainder with a dashed outline. - Keep full-region geometry for handles and announce partial or wholly ineffective selections. - 🧪 Tests: - Render and compare effective, ineffective, inside, and outside canvas regions; assert the painted fragment is reconstructed from `cut_exclusions`. - Cover truthful accessibility announcements for partial and wholly outside regions. - 📝 Docs: - Record the effective/inert painting rule in Decision 6 and regenerate English/German Qt catalogues. Trigger: repro — draw a region across the crop edge over a bystander's face; the result shows only a narrow edge bite while most of the marked face remains. Refs #80 --- docs/designs/exclusion-regions.md | 15 ++-- resources/matteloop_de.qm | Bin 71033 -> 71723 bytes resources/matteloop_de.ts | 23 +++-- resources/matteloop_en.qm | Bin 62993 -> 63635 bytes resources/matteloop_en.ts | 23 +++-- src/matteloop/ui/exclusion_canvas.py | 101 +++++++++++++++++++--- tests/ui/test_crop_canvas.py | 121 ++++++++++++++++++++++++++- 7 files changed, 251 insertions(+), 32 deletions(-) diff --git a/docs/designs/exclusion-regions.md b/docs/designs/exclusion-regions.md index f74620c..b7b30a2 100644 --- a/docs/designs/exclusion-regions.md +++ b/docs/designs/exclusion-regions.md @@ -672,12 +672,15 @@ reducer command. (`ui/crop_presentation.py:12-21`), filled by `present_crop` from `state.parameters.exclusions`. The default keeps every existing constructor call and test valid. -- **Painting, both modes:** every region is painted whenever it exists — a - translucent fill (`#E5484D` at alpha 90) with a 1 px solid border — so a - persisted region is always visible on a new video. In crop mode that is all; - the crop keeps its handles. In region mode the crop is drawn as its dimmed - outline **without handles**, and the selected region gets the eight handles - and the focus ring. +- **Painting, both modes:** every region is painted whenever it exists. The + effective part is derived through `cut_exclusions` and keeps the current + translucent fill (`#E5484D` at alpha 90) with a 1 px solid border. Any + ineffective remainder is faded further and uses a dashed border, so the + distinction is not colour-only; a fully ineffective region is faded in full. + In crop mode the crop keeps its handles. In region mode the crop is drawn as + its dimmed outline **without handles**, and the selected region gets the + eight handles and the focus ring. Handles always follow the full stored + region, not its effective part. - **Geometry:** `_rebuild_geometry` builds `build_crop_geometry` for `_edited_rect()` — the selected region in region mode, else the crop. That is the entire reuse: the same eight handles, the same diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index 35e3ca72f3098dcab96b322fdf6477c7ecc9108e..e592906d3982022c168c6eb147c1d4e4acba52bd 100644 GIT binary patch delta 4562 zcmZu!dt6WV|9_tIIp=)t=QGMssFWEdavizttI$R+#pV`CsF8G0F+Qk>Qiu?XA&q$dD+vHkU2hV$*zwYQHC+$M3)IANBm4^FHs_`}w-R-mmsc2aZT<+E||h_yTb0 zZo?`KaXg>>ZCKR-5ZeLQgNTuUt`_KV4JfMydJ=Eg1HInjAfR^{aW*h)ERg*G814l$ z845gI4{S`bVbw^8e%C1{6XG1ov+90;SWMxU#zEs#Nx`Qety~K12!NE54V)+;9tO%E zK-xDIFm1Bomp5&Ab1S5S$AM)RAf1r_ixyJFNuXjH(T&sjv=kCCpR17Qf13E-tSZM;WD?aVCj0erfr@b}+zWr^uG|`4{MqtEv4=dm{ z2V+(h0*^++e?mSF7BMb`8;;Gw7kQ@uhj|#kmEWDMwc%wSOxR14w!Vo;_n!c(o@4Tx zy@2yM8{Yp3fz4ZSeHdmux(eL7h=_J>K&!(xjQ$F7Z{>ZTjpSVGL7Ms;vgS1c#%0)s z47xuUIcXI@cm;z`FI+uBO|f1mciRc{ z4G=1|b~No~;gLr*ivQX5BTZT@djFUE zlnfhM`isHOUs0i%V%V>=(8+-qg$$a| z7h=NoWe_w~Vp=UV41X+cNx2J*o+Iv<{Ws99N<8#J1^%rQkL+p$&UlDZmAT}*q2f_zxKY~eW$Cb4uKiNvMZ@S@dOyxpw}aQV7ewZRE!TOwAMoP{7c zicfmFQ^R<%rrUW2X)_x}x3ghtfAN{KD}yyoqw#zQB+t`G<7oOe=^BRx(}5?uHLVJp z(`9`%t=Ev~7yC4>jU=@8Q_Y8VH+YVx=A%|&%>R#%YPt+$l;6$L_*%Vy-5WJC_6}gN z*r=I#iBUXqi6*R$Ccdy;v*u<35A@Jv=J-+5Gn%X)lL5cEn!LmOKKKJo>F^g!*Kkeg z8j%+KUUSp?F|hBI=B{S|(78zS^Z3EEz;+u(Wov$EsAc}&nX0Ky$O4LTH2-LL(BmY@ z{{1pWsjJkgFW;ZJD-8~yM%R3$05jKr7$k*E+zG7wL<&=B>dI@E9uJoL?ANAhAH7vMLd0- zI7Yggz8LtnvsBYi2iPsOVZ~bM_i`(JUr{L4`*9(xQpRHo;Qv_GP4ES#Pm^24GhdU> z%5Hm>0G>f|huTyi%SrAyke2xneGJ~ST7Gf!1v25s)zu-VZ94Bj4YSk{6a=BGF8FQ7DON zE9K->0nGnUIVD@>`YAc(U=P-nWI4@wAn^M?vUTh9`@mISIVYS4Zum{!A4g_q_Q)r) z#{x-D<-97!!r{mArCMq@ZlwH2I=@dWQc&8Anx!d{$b!}0T`}A!2V&bR#{7C#)YppI zj0C#%R_vEB20ENjT7E_a^-UFrzE!}vc*Qww11;aisgJwF#`G);MKN37PdTQ`Wu3=6WR~dlcKI zpOT3_zD>;`b(EVd&=MXk6*JK;6nDY(=;iz)PZ~}r{qn!1l ziGQ|JF5I9TmuMUI_fSfz!C)S8K=Q*3y@e+Hikrpmfnj z9S#EuQnd?~=mDSA+HKnhGhP4E?pwWxY4njcw@(0xJk%a?qQJ}oZQ-Fv_6&b*QTvA^ z;%CDojkY+G>r)14OUI4`p0&{ayp3|_KYNQ-;KxDQXNwZqGzQu*uBY~;mO(Ogg3es3 z0{f@v-rLLOGqjb?zTH27{aBsjC@=N~LFabN9Y|}U>yjJH=H#dAHsL<-+YVjtJ@(9+ zv%0?34APE!bVGb->gy@Gp`DnP(bsf7`U0T#E1gfJwGqgDq#N&Y2sqzFH$K=o=VY=`dM)v^^UHp7Lm#)yQy1{yIEK8UAq7q2mqC0($rVfqQoo*niT3vBT z6c3)FyU_kT3)pVmg?=RVEJt_s87<*brYl#dkbki5cdG|YQFu$&uxL8--&NNrv|<{) zvEjyJdhKBn^nR(=+1HZT6}@hMDzo5Ey?H<1kC>}(K9|Hh%lhUgxnG{6|ImL2N3DhW zj(z^-MD$!gpc4tM-J}1cwJYFwSwAL@={)w5erzwgBG*%IotQ_BR_Ewvw|D0xdrBX@ zzb#PrwSK|FbwGWcKIxY_b}t|O%7-N^wN3P^Cu!Jp9_crn*abXzso!izLVaK9x7D@= znwIMK3*LZ?8K7;KUHrv>eR z`~CILdet%wgY*q)zSQK2K`f)`PaQI7^8W-rUTpBF_=Y1|nZf(N0YH~n!{|c{Hf^+F zR`etmo@7Iana`)o3?XgkBJq+Tq)!{5(-1>!&@rIhYs10?iHwnPhJ;)<&WP6ShBccw z1I8~mWVDUvczxN1H_Hu~or{1`c7`pp{WyYU7*1KkDA?UlUcUk8?qay-L`}Z^&Twx< zBz^B~`1LfO=Z`Qt^rdTtO*T6I)&scdWbAmhJFsbkv2!b0IxNZP-iMaSjyCpdcar&E zon{=+aEOOv0TG_YNoyamo4q#9OyR-R-o}u0qWcYF$iBfWP{qc$ z$Ehqx8;uM77Xy<&FuM#;hVL*e}eu4=S*?$hd#S z&&+?<(Z;;Gbl{sHW4;|3?_6U1uEl7Y)L<-39!uBc8;iZ%Iciyq&qp2tX7n_^tm6%4 z(=e0%Ml;61Xp_1BSY}02lllko${LePj)pVkN>f*v&q+H>J?y!!WTC0I)|HjfWa`~A zh-rJu)c>5s{J+y+^6koTJMV?buXPrEYcNe7#}DE^F$K2c^~}-D6!Z>bO`)quwBTRU zyjS6X#Evni*XmaN}zI@TwF zy`{P7IqvIW( zPB#7ay$7SZ)b#rLdN!|TX2Tm_){k$@=2oe|Uyf#nLdxs0(cIhNKCfg4%o79YqMpU( znQj8-gr4SEZ->-RPnjdE8H{H8!{$h5e=@h4qxa3=ESG6sbgv!I7-3%0G!=s2U|!yL z8pm#5bJ8F!XTKyHCayH6MDpN3nAguDk)zkl+l-a*UNt&WfqC=Q7Pkfyuc{6;y*Uehu677c1D?-O zJ64mJK2hy-nf4q~e=bnRZ>A* z=lb_|YIRSmH=5BZ5M6*pj*{uNR+Cu&Iy973=T=ksK zE_%+}hVwe8h1o38NBq^F=6SQNTl3Yc{il;am3r-vD-g0$t$d?WK&5(rFD)^ktNKfE z53Vm#pM<_(kd0PrTKEDnmo3WWFt+2@7VV_ttP|%fdQroh&T&h#Hq>l~$>LB?B84AX z+Go$_&F6)s+w5r8i|LjjF;95^_p}V%a+3MKa<667OV<1XZ_CU^5?$eBnKe9$7ldV& zh+nR7$doK`M>}wGF z1cLUx^gl{IKHjg%Mp3w#-eB*NF4={M@Z9)JBRC3y>DD`r=@AQ>8Y6Yw2!(%B(qrs~ zHTQH54vPwj2%a71JU2QjGGuzNb5O+G@btCz_QLi5m*W6WI3o(d2*GT`yu(QTcgFt` bJo&BQW}eRBfe}&vLu`DRU0#`;uv_>)sfl#G delta 4387 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 Huv7RyhEr0B diff --git a/resources/matteloop_de.ts b/resources/matteloop_de.ts index 88c4098..184032b 100644 --- a/resources/matteloop_de.ts +++ b/resources/matteloop_de.ts @@ -30,12 +30,22 @@ Original-Videobild - + Exclusion region mode: %1 region(s); no region selected Ausschlussregion-Modus: %1 Region(en); keine Region ausgewählt - + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop + Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; vollständig außerhalb des Zuschnitts + + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop + Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; teilweise außerhalb des Zuschnitts + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel @@ -48,23 +58,22 @@ ExclusionCanvas - + Exclude this area Diesen Bereich ausschließen - + Remove this region Diese Region entfernen - - + Remove all regions Alle Regionen entfernen - + Edit exclusion regions Ausschlussregionen bearbeiten diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index 7bda2a7ef5c21e2dfd60233257863614037a194f..1f85b4f5026606ebd776e27d276e86f65bd907f8 100644 GIT binary patch delta 4604 zcma)9XIK?yw_Rt>nK^w<6pV_9h!C&`MX?)0F<7vGQAAJ_1PlSBTkv4S5=BI@7YqVX zP|yejdlV2g0SAI5U?*9y`Z6Fm0f*~|@qi`)aJvW`{S4^Wg1qnFg5Ln{eD`QA@Yy6F^F1)e z6EOV&{JI`kT4TZLzajWtq8xh&Us9e~GYUe@ETD8Mls-2opgmMyF9y~uf+`~y*twFp zA2<%E3TFWNCJRolw&3ygQ0*%P;^Uz@ssiM`P+czve$YUS`x?k`ff&C7$Zmjms2QlT zfjT@J&{?6qcP7kOz83A%rjc=bbZ&|QGH$`K=R?5y26}kXD<4cj-?2G>%^(X#Ot4_u zU<~O_>kfOtvu9u6_E-3<$`5dIz-M*ofa5)k>i!j=eS%T_HvrzL7K{tA;B6m_4RAFB z_Jx?ZvJyDw4F9ResMrCYXYhj^8JJRW7--iM0o(ar(Mk)Jxnk-by0n9YX?LCh^Ist7 zpFIqr*@D#z5YpC`gcoA=qYJ=^Wr%Zf1ls>$!SJh?*CMZQGFBCv_tDk&ku#U^(p|+) zYy`$NBX7-h;G`W6CG*AO|KO+tpD&(>nz~3}dnvB=SOhr45W8t zz!0DqBX(iz4=biL#Q_g)DuTU20poK;STbX{YP=#Yn9mhIDiWSE=F=4xoHIj_9`Xnn zo2}S9tR-pF6kGhgfQ6Nc{F%W(;88{KgKq(=fr`>j{ebiC3iHtc%b9#8#f1a36e|=B zj`<|?LUBWFMb~apJaTOSW-Jzj-2TjBXFLi7`Q=o^!eSisN*$wG3Y2qY$%1+(W8>eUMADRw~aNg=(G zNfUfgNWVmU6eO%^q=liKg>4x>13s;UT~U7kJueC+uVvuAn{c4uJx~xRRJ5k0GfRXM zsVvEiB;j;Rc^%wj!6&Xlt%-WtUKQ%rk;oTe7CdNn5pMSB4U`=e?r!J=bQ&Z)J$sUh zw+PSr^`eE7h39=vGf9Ii7{1Dasi%aO_Fb5)o0Q7I4}k@9m8#F_`VJLJoB5%P{X3;? zWm|?UN!c-rM8{21c6m=iY3WKAt1Ij;70MpA(X9Wz%ay%{Gs`QhmA+Vg6w;jrrTSMPzZpQz3XWxRi-s!v)$}45f$z_VpN4t@n@)-&_wqdX196O5pe1()h~r|f(2{=QloZxw+YiK9 zzm@<$*Nd~=_+j}4adx6R>s28}Ra66QUW?JmB(U0EOibhRgBQejzWiXIxEoS73z^P7R#y&Upl?mb+`{BTa6QX&0=p8bACFaFaVY-J{G>^;* zs>HI~NkGawvEnXsVcT@^d?PI!+gJQ8o9`z%OQ>tZ@BAc{z=qYOous?c0L;-!`eRK% zmW?F0A%UJFCF?ZifK#Z{el!i#Y?f>W-39ixmF(ASV2G>Dl5;^XV4|Ni*jomcluJXr z*zsbjr6J)y93H+F-1D2{y_o{9mr5gDXi3}#X^gNN2yu|cw<0mmKq=w?1^#ebniKyy zzxz)5V!nz=*-c7$Pr@H$O7jn}9NPv;izIs7{gt$MZ91^hd{@dkOJ)OlOY2&&jkB~d zcRa^tptKbOIlptHZA+=pYK^ojg#_0NQeG_ucHJfAdsnhw+_qryY70JCBOTS10Z+b^ zPWsWsr*}wau27DhvjyD?q_f*e?Bqe|dQ26Q`irfWi^tcb=gSt+wdK+q@AbghI_b@k z_uNgA)z&xYp*~6K?yKp6{d%=)lN~UAzk1Lu#@xQ61(PqUhi;~YA5K>ft77MzD5{5B zZQ)Q$QhVi+z^%h-uh-0#po?nn91^JVQID=@ng3bQ>M`p(v7ywdCl)s{mO<)R{}u}h z)d~Bffjyq;`Dt3<({T09Z#-CLN$SGYsVt+7>f(XHoNA-hC7md6MT)wzB%U+FUtQ(= zkVLvzFr~e^W-FijH>v9;jRP)iR^Qu6xsg^aXa>GZP`^xF3W$GN@C&v2t(r+P>4nBv zC$oc{)_kys!{?J>8f&M&fY#eI9mabC4+}Mp2YUgFmS}nxhcS6~Yx+#R1JpWd+;>~E zYBp*HJ!O)9G+E>ALsuVus~OpyWf{>y<S6WR`CU7HAYb@fq*Kuvz7!r3eYulFdd$F(9#eWx9tx|2b zfq!r#+NT}XodnY^Ye#hK!VPGEcH+FtTujTglln6hTl#6uffckUb+k6hxfkHNO`BNc zz|CZ`cK*Y4z@0Mfiu-Rky%gH7AD(4{%GIu(rX=&$+6`p|z?mlP7Aq3!w_Llku_JTB zOIxJyVx#fb*7)o+v=57^r(Z|y;|?c)9wlb&Q&+zDwt0;&r=OKhxJ=jQOFHGT-+{jVI@jypGy4N{UVjDy-Hz!dlrY)UCS640 zG_G=cb&*Ei=l_o`(vBe#PU#{C+A$Pwbt$tBa%FSWEttQQo%E_Mz1WdEqWOX@YcqGi z1UubEhb7!pKCum-xG$V%UJN)9t-Lbd6+sVGbvh(_$w)FJOcKTieX>jIh{Sc>e)_?6Y z{jlZ|#?qvpu)&jSbhAF-++`qasD9eoN1SF^`tS@Yt}WI_W)r*h&_@<}utA;B&wHH7 zh7_b<;J*m)8>ctVAdyMa^^0q+vLm*#VC*vevJ{5O>7YKRiU#(7sxO2LY?!PsT7Hl9 z-ziUD@g|$AmtKF&ij3DL>5sRYz#Z<8zH-$h;FoUt8qZ$9y}9~V<4S<3&-8EKT%tv3 z2JMwL%z?=U<50d=_SPW(M*Kd)&^b@ZopQC|W0ChMWd=8Ees|!p!Cl=2c${HyZ$FEc zcQy6#xb|($9{>3K4oRuWHr`$02 z?^rLpgY|&Tm8uA+G$vaVog9Fn! zTb3KjlO~e*PQ&-_%w#rw4ljtgA%?T}`QLZH&`>LfatAaSe(Dg$p)}lZyOI_$JO0J| zqlRC8aOD&WF}%C9o~~CIb^rLXe`FbrwwXY~aHCBn<@MfVbho*~U$W!Izz~M$;}T=I zqk?-vZ(~HulIpSC7-!zdY;OJ17;o>-A#~W7SU8(5o?%SA&1$&&$e7le0v}i#mkpW; zL?1J*_(aVldS$`H-;5dYRQ&luJ&Mgl?DHUGpG5l5L*5a~IqocMV&^&UaMq z_LRi5O1b+@w(uhXvYU$|bETtM9yFo~*z7F(I*@72M{>aSMqs&%9Jq%H0)6D*(^lO3 z=gTuHtl7CjRc=l&TB7P-oWGaqsTnl2ZA(}^3+mvVWZ6F~Qg@}cAD^sFeK@+n~C zMp!U(vRs+V7QL-T{%Nik$GZ8Rd|_xP30#vemUQ8GOqOr_BU8Zd@|`{O#DHk|evKQS zuack5dCjf1tNgs3FQ-?vNve(JILOLG*%}v!h*_81k1=PIlNemKs63??xp4np-pT!_n zL!n?jVS4tLR-g46Y#$b#5E&O1HP1dKF(E!OG|YZhTudzU89EPMc!WeJg~Th!6-WM0 jrQ5$MV-Z4;3ICc|c8h*naN0=bXErJIGeq%a&y#8f0xDOh|l|WGj`SL9%3YnHD5MGPWYg-eO6{ zu1J4JGDA$t0MZ%}bAjWlA?}?77!p;S z;IHC|mJkmd24-s@o)7`kIf(c2fs-2`%~=6#ISMH<4OlxB(y?0L>>lVsQvh8C8vCq< z4e`y;cu63zayMFhngJw+!>MBhP&X7EyeetIuju-1I?%90#gHc|F1`d0mk+?vTkz`G z6?pg+1{IA2TIOL;X&f;EgI#{)MRPH@dn({%Qt|t@Dn7W2Z^ydYfTr&7Pb>tA^ARxa zBv2<0qm#H{i#^5^{0!7Tfw5b;Zcif>51zreJ#=ZK^$2`i1uTfhgn#!iWEK?*4Vc`} zk?)O|_TmOTVTU=+PBb7^#gJeu{Bqu|O03Mb9iXefNBZo~fIb-8umSjXB{Gxm0jCb& z*nBQLu>vPr@_o!x6qkkroBQKVhZvx_26uh?0KLZHVRaFSI-=@t80MjA|M~~!PmRXSz9mpLPUB`f$b($3YkYYwCj3Bb&KSSc43%0j_5(Fz zKFtB1hG~MlgBja}nvnU7;qu3tIYE4{xvZI6&6o!!s~B3NiJSZa7}7$svCo&JRWzFd zyn*Q9nw?XEnAg6V?B~0HuP$m1H|qwJT+rA~e6x(nm!`RqM@z9>Q|7c2=n}2Dud7Gb zI%{6ImH|OlLCEM1{FpBo_D29SjtefcdEmtW!M(*73l9hbvMvF;+X~))ai8|7il%BI zeA9l9>VFxbD6}VaN$dN zuYI{}CQ~znj(R6)dZ>@cFFmPqL*0Hc5LndmQtRc~% z71~yxNhqeSwr#!JyvJMH!7+mM?^<8mxi7Q)tiRUJ<^`x? z;yqoQeNwyTP8_SFT)R1QBrQFtO~15~V&khV$mRO~S*|S|`i|wgPg}Z1pa)&Fcf2cs zln>fRy@G(&`P!#rJ?Vj0Dh40cKC7)^{h#?p`zkIS*f&=Dx0V-OyeHZ4BJ=p8_ln z6AR;caAB@^J}V2DGf=$n<7Z&mT(Lwr!si(A+PrvRYQBmKpNjWl8S6+d@li?)u)VWb zUHcxePF3;b1@X5s8)JX+AMw*jzL;1kq0$QYhDiExe!%EoCC6CS>%u{j)9xieSDVzX zW;L*)q13)FJ>#4zb-Z>B*jZQV+_w*q{Ga41x1k3Tq;7xSr2w6iJXSjc`OZ>5y%sn! zN*WOC1*G~(1NZa)x#`kSn?Oq*6-&cr-3Ahhq%jLvmv-sW)Ymz{gFtDT8#f*flBPwu zvtE;>83pHodP}8<`6Q5-BSkIY`@A4&!6p8GdV#d4>gBeVJ^xggMai zPr30B8Ys7x?R!3!<&jX(_i)o_2q^~D(+e& z`)uTaclyf%+tQL*t>mG?ZVFSLJiHEx^{@8s!`quF%&%HKtcK)^A1!DkXy z9OdXdmZM#j93#`?-D2dWYvZVQwwdyp5;E&{N?!K`>*mWFGKRDHRLPssgXPpg-V)CX z>ok#fEFi(PYvjzUJh08z@=l*Z>cV#_MmebXw26Gecm$~US3WzEE-rGBFW%-k4*4o} z>nfLQC9%`}VWXzlFS21d`uJ=Y-SnrLlPZ5=KSc zjGw6UNhg7`cXdMwzV!c9pL9dlH>1Rk*ZF7HFqYN2Spl@*g}ZKUZUm5ZQy0C&0QCK! z+qT`4WhUzOu3F48a?)k@2qKaDx}0V_FhSN8=0pPXpX-X+RFKF)6{B|RiZ}DUf1<8* z)G**iYu(drJa<~g7qkJng6{3&cs7lA6~j_>A9YNUk@t4h6(FI`;_ zryuCTvJBa)_cfdbu5Z=*-nV@QehSc!ZIJ`)Pt%Xhwot>(DxS5|hiB9SqF(D~RWrNS zzthLgoTk6n<^lz5yZ)jF ziQUN1-*`(;IMnLPWE$kF)&FL5r7QMc*Vir%rVA(NKWiM>oyMye8)MMrlAyH~I#fBn-ZF~VOioS1{(WVp7xt$?uUrXS2r6Iav9ffItVfnN7 z>|V)+6%{3v+Rlbmfm$}5?S|ANS-^!v!=`#9)V020TTK&|*)799jW@IVxuH0K`|=MP zN}kZtJ%K77tTj|*^PVpI4V4b3sSh4D!z))Vd=Y7QecBl~muh(1y@qA@hoLsvkCtQ@ zg(RsG#DBpLeV>hWBU+ zIK>$kOg#iNJ7ioG9nahdHpXQ;QJRB{Yc_K9n{7K_+|V+XBi9iXPmC~b?pVaO8*kh) zV!`KIOlUVoNww=o5T7akY*Z@>c#PSrD^P?Tfmen zrogo?*bSSSLX&v$rtrO<)b63Cg_Wx*MAfE60WrYva+7TmiTJ-UEiJx7 zCETWBgqnZ<^zr>oTBMi_x9bDvE6tYPTz4qWth^x}{%CHI zsRa%?n7@|zJa2&6&5rwWBF*l)R#ZfLvwP#IEZ1Cf?{gw>=Azl}>wB#KZGV|ZHc4kp zdzvSV=7QPb=E=^#Gh6-4Q~w_m&C?T8IInw}qZ9Z!)~~lYwr&~_zStb6>BG;jRP*u! zH5|1(&1)x7l5fv6XO_`}5C1VA>Ji6YQs10E&!5TK(R}nD5(@lV#q_u4l4mvGEWY@n1hmaZ`)MaW!zW)M8)A zgF8A~-0dH8*AUD2$qY>=4@;<%hMqlT3HvgX_OEZ5vw_L`)nZFz^8gYbXo<4zoyOU% z#G_&vN}%v~kuLOoidS0)wMQ6k?e)AJ>k&nOjlpHcQssbJ4|qhxPy29*A* zte20i~jMM*Sq diff --git a/resources/matteloop_en.ts b/resources/matteloop_en.ts index 0071cf1..4c1706c 100644 --- a/resources/matteloop_en.ts +++ b/resources/matteloop_en.ts @@ -30,12 +30,22 @@ Original video frame - + Exclusion region mode: %1 region(s); no region selected Exclusion region mode: %1 region(s); no region selected - + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop + + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop + + + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels @@ -48,23 +58,22 @@ ExclusionCanvas - + Exclude this area Exclude this area - + Remove this region Remove this region - - + Remove all regions Remove all regions - + Edit exclusion regions Edit exclusion regions diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index bd5a982..8b267fc 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -11,6 +11,7 @@ QKeyEvent, QMouseEvent, QPainter, + QPainterPath, QPen, ) from PySide6.QtWidgets import QMenu, QWidget @@ -20,6 +21,7 @@ nudge_crop, oriented_point_from_widget, ) +from matteloop.core.exclusion import cut_exclusions from matteloop.core.geometry import InteractionGeometry, MediaTransform, PointF from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec @@ -172,12 +174,77 @@ def _paint_crop_outline(self, painter: QPainter, crop: QRectF) -> None: def _paint_exclusions( self, painter: QPainter, geometry: InteractionGeometry ) -> None: - fill = QColor("#E5484D") - fill.setAlpha(90) - painter.setPen(QPen(QColor("#E5484D"), 1)) - painter.setBrush(fill) + effective_fill = QColor("#E5484D") + effective_fill.setAlpha(90) + effective_pen = QPen(QColor("#E5484D"), 1) + ineffective_fill = QColor("#E5484D") + ineffective_fill.setAlpha(32) + ineffective_pen = QPen( + QColor("#E5484D"), 1, Qt.PenStyle.DashLine + ) for exclusion in self._painted_exclusions(): - painter.drawRect(self._widget_rect(geometry, exclusion)) + region_rect = self._widget_rect(geometry, exclusion) + effective = self._effective_exclusion(exclusion) + if effective is None: + self._paint_exclusion_rect( + painter, + region_rect, + fill=ineffective_fill, + pen=ineffective_pen, + ) + continue + effective_rect = self._widget_rect(geometry, effective) + if effective == exclusion: + self._paint_exclusion_rect( + painter, + effective_rect, + fill=effective_fill, + pen=effective_pen, + ) + continue + region_path = QPainterPath() + region_path.addRect(region_rect) + effective_path = QPainterPath() + effective_path.addRect(effective_rect) + painter.fillPath( + region_path.subtracted(effective_path), ineffective_fill + ) + self._paint_exclusion_rect( + painter, region_rect, fill=None, pen=ineffective_pen + ) + self._paint_exclusion_rect( + painter, + effective_rect, + fill=effective_fill, + pen=effective_pen, + ) + + @staticmethod + def _paint_exclusion_rect( + painter: QPainter, + rect: QRectF, + *, + fill: QColor | None, + pen: QPen, + ) -> None: + painter.setBrush(fill if fill is not None else Qt.BrushStyle.NoBrush) + painter.setPen(pen) + painter.drawRect(rect) + + def _effective_exclusion(self, exclusion: CropSpec) -> CropSpec | None: + if self._presentation is None: + return None + boxes = cut_exclusions((exclusion,), self._presentation.crop) + if not boxes: + return None + box = boxes[0] + crop = self._presentation.crop + return CropSpec( + crop.x + box.left, + crop.y + box.top, + box.width, + box.height, + ) def mousePressEvent(self, event: QMouseEvent) -> None: if not self._exclusion_edit: @@ -646,11 +713,25 @@ def _announce_crop(self) -> None: return assert index is not None crop = self._edited_rect() - text = QCoreApplication.translate( - "CropCanvas", - "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " - "source pixels", - ) + effective = self._effective_exclusion(crop) + if effective is None: + text = QCoreApplication.translate( + "CropCanvas", + "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " + "source pixels; entirely outside crop", + ) + elif effective != crop: + text = QCoreApplication.translate( + "CropCanvas", + "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " + "source pixels; partly outside crop", + ) + else: + text = QCoreApplication.translate( + "CropCanvas", + "Exclusion region %1 of %2: x %3, y %4, width %5, height %6 " + "source pixels", + ) values = ( index + 1, len(presentation.exclusions), diff --git a/tests/ui/test_crop_canvas.py b/tests/ui/test_crop_canvas.py index a3037dd..586936a 100644 --- a/tests/ui/test_crop_canvas.py +++ b/tests/ui/test_crop_canvas.py @@ -6,6 +6,7 @@ from PySide6.QtWidgets import QPushButton, QVBoxLayout, QWidget from matteloop.core.crop_state import CropChanged +from matteloop.core.exclusion import cut_exclusions from matteloop.core.geometry import MediaTransform, PointF from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec @@ -32,12 +33,16 @@ def _presentation( ) -def _canvas(qtbot) -> CropCanvas: +def _canvas( + qtbot, crop: CropSpec = CropSpec(10, 10, 40, 20) +) -> CropCanvas: canvas = ExclusionCanvas() qtbot.addWidget(canvas) canvas.resize(200, 100) canvas.set_frame(QImage(100, 50, QImage.Format.Format_RGBA8888)) - canvas.apply_presentation(_presentation(), active=True, editable=True) + canvas.apply_presentation( + _presentation(crop=crop), active=True, editable=True + ) canvas.show() return canvas @@ -215,6 +220,89 @@ def test_persisted_exclusions_are_painted_when_crop_is_disabled(qtbot) -> None: assert color.red() > color.green() +def test_partly_outside_exclusion_paints_only_the_cut_intersection(qtbot) -> None: + crop = CropSpec(10, 10, 60, 30) + region = CropSpec(60, 20, 20, 10) + canvas = _canvas(qtbot, crop) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation(crop=crop, exclusions=(region,)), + active=False, + editable=True, + ) + canvas.show() + qtbot.wait(10) + + boxes = cut_exclusions((region,), crop) + assert len(boxes) == 1 + box = boxes[0] + assert canvas._effective_exclusion(region) == CropSpec( # noqa: SLF001 + crop.x + box.left, + crop.y + box.top, + box.width, + box.height, + ) + + image = canvas.grab().toImage() + effective = image.pixelColor(_source_pos(canvas, 65, 25)) + ineffective = image.pixelColor(_source_pos(canvas, 75, 25)) + assert effective.red() > effective.green() + assert ineffective.red() > ineffective.green() + assert effective != ineffective + + +def test_wholly_outside_exclusion_is_faded_and_has_no_effective_part(qtbot) -> None: + crop = CropSpec(10, 10, 60, 30) + inside = CropSpec(20, 15, 10, 10) + outside = CropSpec(75, 20, 10, 10) + canvas = _canvas(qtbot, crop) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation(crop=crop, exclusions=(inside, outside)), + active=False, + editable=True, + ) + canvas.show() + qtbot.wait(10) + + assert cut_exclusions((outside,), crop) == () + assert canvas._effective_exclusion(outside) is None # noqa: SLF001 + image = canvas.grab().toImage() + assert image.pixelColor(_source_pos(canvas, 20, 20)) != image.pixelColor( + _source_pos(canvas, 80, 25) + ) + + +def test_wholly_inside_exclusion_keeps_the_solid_treatment(qtbot) -> None: + crop = CropSpec(10, 10, 60, 30) + region = CropSpec(20, 15, 10, 10) + canvas = _canvas(qtbot, crop) + frame = QImage(100, 50, QImage.Format.Format_RGBA8888) + frame.fill(QColor("#ffffff")) + canvas.set_frame(frame) + canvas.apply_presentation( + _presentation(crop=crop, exclusions=(region,)), + active=False, + editable=True, + ) + canvas.show() + qtbot.wait(10) + + box = cut_exclusions((region,), crop)[0] + assert canvas._effective_exclusion(region) == CropSpec( # noqa: SLF001 + crop.x + box.left, + crop.y + box.top, + box.width, + box.height, + ) + color = canvas.grab().toImage().pixelColor(_source_pos(canvas, 25, 20)) + assert color.red() > color.green() + + def test_an_abandoned_rubber_band_dispatches_nothing(qtbot) -> None: canvas = _canvas(qtbot) canvas.set_exclusion_edit(True) @@ -616,6 +704,35 @@ def test_region_mode_announces_the_selected_region_bounds(qtbot) -> None: ) +@pytest.mark.parametrize( + ("region", "status"), + [ + (CropSpec(60, 20, 20, 10), "partly outside crop"), + (CropSpec(75, 20, 10, 10), "entirely outside crop"), + ], + ids=["partly-outside", "wholly-outside"], +) +def test_selected_exclusion_announces_when_crop_does_not_apply( + qtbot, region: CropSpec, status: str +) -> None: + crop = CropSpec(10, 10, 60, 30) + canvas = _canvas(qtbot, crop) + canvas.apply_presentation( + _presentation(crop=crop, exclusions=(region,)), + active=True, + editable=True, + ) + canvas.set_exclusion_edit(True) + + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=_source_pos(canvas, region.x + 1, region.y + 1), + ) + + assert canvas.accessibleDescription().endswith(f"; {status}") + + def test_crop_canvas_keyboard_moves_overlay_by_one_source_pixel(qtbot) -> None: canvas = _canvas(qtbot) events: list[object] = [] From 2cf9c8a63b11adeb89fc40600c4ccba8787f6039 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 15:08:15 +0200 Subject: [PATCH 16/21] =?UTF-8?q?=F0=9F=90=9B=20fix(inspector):=20show=20r?= =?UTF-8?q?egion=20bounds?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 Defects: - Removed `compact_field` from the count label and placed it on a full-width line, keeping “1 Region” visible at 322 px. - Connected canvas selection to a readout of stored oriented-source coordinates and classified crop overhang through `cut_exclusions`; no selection clears stale values. - 🧪 Tests: - Added one behavior test for count width and three for selected, empty, and overhanging readouts. - 📝 Catalogues: - Regenerated English/German sources and binaries with 547 finished entries and 0 unfinished entries each. Trigger: repro — at the 322 px inspector viewport, the Exclusions row painted “1 Region” as “1 Re”. Refs #80 --- resources/matteloop_de.qm | Bin 71723 -> 72434 bytes resources/matteloop_de.ts | 47 +++++++--- resources/matteloop_en.qm | Bin 63635 -> 64272 bytes resources/matteloop_en.ts | 47 +++++++--- src/matteloop/ui/exclusion_canvas.py | 17 ++++ src/matteloop/ui/exclusion_controls.py | 80 +++++++++++++++-- src/matteloop/ui/main_window.py | 3 + .../test_main_window_state_and_source_drop.py | 85 ++++++++++++++++++ tests/ui/test_minimum_layout.py | 37 ++++++++ 9 files changed, 285 insertions(+), 31 deletions(-) diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index e592906d3982022c168c6eb147c1d4e4acba52bd..42397c46bebd0735bf4dff6de97aae452be3f88e 100644 GIT binary patch delta 4704 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 Wu2heocZ#Original-Videobild - + Exclusion region mode: %1 region(s); no region selected Ausschlussregion-Modus: %1 Region(en); keine Region ausgewählt - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; vollständig außerhalb des Zuschnitts - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel; teilweise außerhalb des Zuschnitts - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Ausschlussregion %1 von %2: x %3, y %4, Breite %5, Höhe %6 Quellpixel @@ -81,8 +81,8 @@ ExclusionControls - - + + %n region(s) %n Region @@ -371,27 +371,52 @@ Ausgabeordner auswählen - + + No region selected + Keine Region ausgewählt + + + + Selected region: x %1, y %2, width %3, height %4 source pixels + Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel + + + + ; entirely outside crop + ; vollständig außerhalb des Zuschnitts + + + + ; partly outside crop + ; teilweise außerhalb des Zuschnitts + + + Edit Bearbeiten - - + + Edit exclusion regions Ausschlussregionen bearbeiten - + Clear Zurücksetzen - + Clear exclusion regions Ausschlussregionen löschen + + + Selected exclusion region + Ausgewählte Ausschlussregion + Clear output directory diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index 1f85b4f5026606ebd776e27d276e86f65bd907f8..a7cb46f24265d6430971c68c4727282d3b65a3ba 100644 GIT binary patch delta 4748 zcmZ8kd013++rDScoHP3w6*+-fF`$z|c1Q4e)FLj`aZEp8~87 z0>=3Q?J9sLYk{RsHar~wWza>+F+=%D0#-mlLhzJ(9mKc%AW_+aQd`s1Pv6A#(&b^*pu9|X9x zV$$+zD{wX)lV?-`_V+L~hX=OY#k9(=00$pT-^}Nww{3VR8#8v&nO$ch_|{_}!w0ke z-U)QSWW(AE2<_}l!mAMZ-~w>`I^x}2d9AhK9CxI)$=g$k6=kKsnxQC|XKe-a>#+sv zfk~54wDKxYoq)s1eDU}M93@L+?m%t5g~T+t+;<`1T8ArRMgZ^j!1bp!K$mTJ{6hfH z?IK>a5YJ~TaP1gF(@XJ2&?sQCpy=}?9q_79csMeXe(0g__>yvlu2+n)QZ7Ckr5Ix| z14akMII${5VBj0d@)t62f0=S$Nh`2ppR%$8 zEsYSA$1+%)xo4H9SXemt%!WheTczlKCUIby?u8Ok394*)8yYUS;9-GLq} zl}&ZWskmAB_^tj-%2MUi!Kav|`)z2sW5Y$Al+VpQStTC|!m#^H!dgK!m9Fn*5FFFO zfeV3xb9HBiY^cz66^TyVE%a<9p--;~z3nbhk3s0`9Lw%;Ll`iUNp3ymAOu)_fpt|v z8l+qg-3g;LX3QG?^i0z%wk|cu_{)k z>#NIE*?QuPiK^uv^Zv04Rjw~R5L>UxA5#VR71=Pp*oOH_+K|b2CRJ6?xRw_FsM=Ff z!le3BwWqcdU>Rt`Lqk-hduFj5x2sBja0LnqReLM)=+XhI>LpZgdcNvp+qq;}b?Vbr zAZM7WPI-{meyZ>0F9D*{ZMblU>S`u)AVsgbk++aJ_e%A&#rhKHu#P{7CvsHJ8krO) zPN-f7@jARz#6uGh&{x#V2mof5iO!j<P1hC7vK8z3LDo_ad@s9@YOT%U5!9=7T>dm`vMy~ilg`NL286J zPDxAdel7;iy#%aSE>25fy>@XG!=9A0)%Fx4J$Uf2n;4no$vU1Y##EjJI;+LlWD;1J zBqlB5^9naH-%t z?8MFCw}2ylV$obG%+42gr;^ytF5ye zXEBx@(yBT#^Ujjiv|*=V()z*)9H;xFjqqZ5g-Dy0P@#RGv@L}M*MBG#oufea-=$*z zYW9o4HcY)|!v_zfqq>7YQ?+zFh#o%ut91Gj<(SiLX!ZI_s@qIvHEQWux}hO6`4} zv3H5LVOnqXJNdMMX5E9v{F7Hlx%j?zEP4QS)X&}YQ|`f zkw}Lu9d0n|rv-}eK z!q(23+!xnKAX;;tZvR)sTj!^MV6{j}=6BbnOW^j?+#`WnBmA zv{QyM6q}Z7XI9c8>sD<{ul~T0pS4N5U4Uz)+O+#?*r2r9rFUO)x=qzCyI)6wue6^B z3nU(;U3ahq_;#XpgB=NZ-q3Do?#i4HwYwF5O!8gY+Q~e3Bu!g)n}(M4wAy|gI;p*1 zMn#_S+J{cZ*eC>T(;&Y1*jxMLm>W#eg%F@+(r>T7-b1NUn6KL?frvqtD&y}ZbkveBTu)RE)8)L?vv?^TX9$UhMee{JYd zBydRGGYk}`u>Kcl4IcJ9c);7>sqP8L_toV#MU;k;7>uw<>_W;HEhmi&u5+8KWQhF>^khYWvRT+0wlHR}EjU>|vC zG&<)3SJoOGt0{NTGoz=~@fKjpFwP8RtcD22C|3m+hb&`s+cxWW!x+DwS#7u1m|&hv z=CUzqS0s163S-7iR>eIp(+Z&g@tLBdAXTy~Dj5!HZJnehq+GrBl z5^3C`r=h+7G8V4M@^s#(6Q@BOlB0f{xF%Bt*C_WloL zy%P{M}$SFI1ADowGSK4z`J0#Dk5Lr#mHZ0AScYSo9 z-vbBbvaQ{Li`8<);A89$JLJP(XR$F^Psu07lrVHYHjFHls|(qy3!LQh^ZYpHx5^jZ z31>&_D}P_!lV33Bp_Bd_=1Tmv3^cUN$X>dP&zlGA;FQ z=JuOz%K4V(FB~=HD`-I2S<}Y#ZDqO8RM4`9OKhmAEP5f{#%Erp%8O)Hf8SJnr0A2kz2lHh9fz6chQ=qxq?+TB5)&-p5$3S?xVd?Xu675U99<29D+2QJJGpo0 z5D;gMkBG9w#hMc$Vj{v4Bl65WIvwzNV~5y&FoF<)82*JJk^jT<7It^(sUa7z4B-%D zI}mP;NC}HcN@$Z|6V;|>Z2JE{4Kv~?B?=bAAr{`ePT`*$2B9x8_21uv|NWiJcfzSN z`rms)@_g(%Dm?N6?43vdPy2}fX}9V0Hm8`~2K6zT fiDowsb3$BFd{~5et|cWRCeNpv{edR;J?H)lnYWUU delta 4400 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 UsBP+EDxBw*D;7@fxaZ>k0A~#}mH+?% diff --git a/resources/matteloop_en.ts b/resources/matteloop_en.ts index 4c1706c..93fb2ab 100644 --- a/resources/matteloop_en.ts +++ b/resources/matteloop_en.ts @@ -30,22 +30,22 @@ Original video frame - + Exclusion region mode: %1 region(s); no region selected Exclusion region mode: %1 region(s); no region selected - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; entirely outside crop - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels; partly outside crop - + Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels Exclusion region %1 of %2: x %3, y %4, width %5, height %6 source pixels @@ -81,8 +81,8 @@ ExclusionControls - - + + %n region(s) %n region @@ -371,27 +371,52 @@ Choose output directory - + + No region selected + No region selected + + + + Selected region: x %1, y %2, width %3, height %4 source pixels + Selected region: x %1, y %2, width %3, height %4 source pixels + + + + ; entirely outside crop + ; entirely outside crop + + + + ; partly outside crop + ; partly outside crop + + + Edit Edit - - + + Edit exclusion regions Edit exclusion regions - + Clear Clear - + Clear exclusion regions Clear exclusion regions + + + Selected exclusion region + Selected exclusion region + Clear output directory diff --git a/src/matteloop/ui/exclusion_canvas.py b/src/matteloop/ui/exclusion_canvas.py index 8b267fc..5c3c522 100644 --- a/src/matteloop/ui/exclusion_canvas.py +++ b/src/matteloop/ui/exclusion_canvas.py @@ -50,6 +50,7 @@ class ExclusionCanvas(CropCanvas): """Add source-region editing while retaining CropCanvas's crop hooks.""" exclusion_edit_toggled = Signal(bool) + exclusion_selection_changed = Signal(object, object) def __init__( self, @@ -129,6 +130,8 @@ def apply_presentation( super().apply_presentation( presentation, active=active, editable=editable ) + if presentation is None: + self._emit_exclusion_selection() def paintEvent(self, event) -> None: # type: ignore[no-untyped-def] PreviewCanvas.paintEvent(self, event) @@ -697,6 +700,7 @@ def _announce_crop(self) -> None: presentation = self._presentation if presentation is None: return + self._emit_exclusion_selection() index = self._selected_exclusion if self._exclusion_edit and ( index is None or index >= len(presentation.exclusions) @@ -743,3 +747,16 @@ def _announce_crop(self) -> None: for number, value in enumerate(values, start=1): text = text.replace(f"%{number}", str(value)) self.setAccessibleDescription(text) + + def _emit_exclusion_selection(self) -> None: + presentation = self._presentation + if presentation is None: + self.exclusion_selection_changed.emit(None, None) + return + index = self._selected_exclusion + exclusion = ( + presentation.exclusions[index] + if index is not None and index < len(presentation.exclusions) + else None + ) + self.exclusion_selection_changed.emit(exclusion, presentation.crop) diff --git a/src/matteloop/ui/exclusion_controls.py b/src/matteloop/ui/exclusion_controls.py index e23f675..fcc1ef4 100644 --- a/src/matteloop/ui/exclusion_controls.py +++ b/src/matteloop/ui/exclusion_controls.py @@ -2,11 +2,19 @@ from __future__ import annotations -from PySide6.QtCore import QCoreApplication, Signal -from PySide6.QtWidgets import QHBoxLayout, QLabel, QToolButton, QWidget +from PySide6.QtCore import QCoreApplication, Qt, Signal +from PySide6.QtWidgets import ( + QHBoxLayout, + QLabel, + QSizePolicy, + QToolButton, + QVBoxLayout, + QWidget, +) +from matteloop.core.exclusion import cut_exclusions from matteloop.core.parameters import ExclusionsChanged -from matteloop.ui.compact_widgets import compact_field +from matteloop.core.specs import CropSpec from matteloop.ui.parameter_presentation import ParameterPresentation @@ -38,6 +46,41 @@ def apply(self, presentation: ParameterPresentation, editable: bool) -> None: if not available and self.edit_button.isChecked(): self.edit_button.setChecked(False) + def set_selected_exclusion( + self, exclusion: CropSpec | None, crop: CropSpec | None + ) -> None: + """Render the selected stored rectangle and its effective crop status.""" + if exclusion is None or crop is None: + text = QCoreApplication.translate("Inspector", "No region selected") + else: + text = QCoreApplication.translate( + "Inspector", + "Selected region: x %1, y %2, width %3, height %4 source pixels", + ) + values = (exclusion.x, exclusion.y, exclusion.width, exclusion.height) + for number, value in enumerate(values, start=1): + text = text.replace(f"%{number}", str(value)) + boxes = cut_exclusions((exclusion,), crop) + if not boxes: + text += QCoreApplication.translate( + "Inspector", "; entirely outside crop" + ) + else: + box = boxes[0] + effective = CropSpec( + crop.x + box.left, + crop.y + box.top, + box.width, + box.height, + ) + if effective != exclusion: + text += QCoreApplication.translate( + "Inspector", "; partly outside crop" + ) + self.selected_readout.setText(text) + self.selected_readout.setToolTip(text) + self.selected_readout.setAccessibleDescription(text) + def tab_widgets(self) -> tuple[QWidget, ...]: """Return the row's keyboard controls in visual order.""" return (self.edit_button, self.clear_button) @@ -59,18 +102,37 @@ def _build_widgets(self) -> None: self.clear_button.setAccessibleName( QCoreApplication.translate("Inspector", "Clear exclusion regions") ) - self.count_label = compact_field(QLabel()) + self.count_label = QLabel() self.count_label.setObjectName("exclusion_count") self.count_label.setProperty("secondary", True) + self.count_label.setAlignment( + Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter + ) self.count_label.setText(self.tr("%n region(s)", "", 0)) self.count_label.setAccessibleDescription(self.count_label.text()) + self.selected_readout = QLabel() + self.selected_readout.setObjectName("exclusion_selected_readout") + self.selected_readout.setProperty("secondary", True) + self.selected_readout.setWordWrap(True) + self.selected_readout.setSizePolicy( + QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred + ) + self.selected_readout.setAccessibleName( + QCoreApplication.translate("Inspector", "Selected exclusion region") + ) + self.set_selected_exclusion(None, None) self.edit_button.setEnabled(False) self.clear_button.setEnabled(False) def _build_layout(self) -> None: - layout = QHBoxLayout(self) + layout = QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) - layout.setSpacing(8) - layout.addWidget(self.edit_button) - layout.addWidget(self.clear_button) - layout.addWidget(self.count_label, 1) + layout.setSpacing(4) + actions = QHBoxLayout() + actions.setContentsMargins(0, 0, 0, 0) + actions.setSpacing(8) + actions.addWidget(self.edit_button) + actions.addWidget(self.clear_button) + layout.addLayout(actions) + layout.addWidget(self.count_label) + layout.addWidget(self.selected_readout) diff --git a/src/matteloop/ui/main_window.py b/src/matteloop/ui/main_window.py index c6cf7b7..6ad3c44 100644 --- a/src/matteloop/ui/main_window.py +++ b/src/matteloop/ui/main_window.py @@ -226,6 +226,9 @@ def _build(self) -> None: self.inspector.exclusion_controls.edit_toggled.connect( self.original_canvas.set_exclusion_edit ) + self.original_canvas.exclusion_selection_changed.connect( + self.inspector.exclusion_controls.set_selected_exclusion + ) self.original_canvas.exclusion_edit_toggled.connect( self.inspector.exclusion_controls.edit_button.setChecked ) diff --git a/tests/ui/test_main_window_state_and_source_drop.py b/tests/ui/test_main_window_state_and_source_drop.py index f5401a4..47bfdcb 100644 --- a/tests/ui/test_main_window_state_and_source_drop.py +++ b/tests/ui/test_main_window_state_and_source_drop.py @@ -12,6 +12,7 @@ from PySide6.QtWidgets import QApplication, QLabel, QPushButton from matteloop.core.errors import AppError, ErrorCode +from matteloop.core.exclusion import cut_exclusions from matteloop.core.geometry import PointF from matteloop.core.parameters import ExclusionsChanged from matteloop.core.specs import CropSpec @@ -617,6 +618,90 @@ def test_source_context_menu_edit_action_keeps_inspector_mode_in_sync( assert value.inspector.exclusion_controls.edit_button.isChecked() +def test_selected_region_readout_shows_its_stored_oriented_rectangle( + window, qtbot +) -> None: + value, _ = window + region = CropSpec(20, 10, 30, 20) + state = replace( + _ready_with_crop(), + parameters=replace(_ready_with_crop().parameters, exclusions=(region,)), + ) + value.render_state(state) + qtbot.mouseClick( + value.inspector.exclusion_controls.edit_button, + Qt.MouseButton.LeftButton, + ) + canvas = value.original_canvas + assert canvas._geometry is not None # noqa: SLF001 + point = canvas._geometry.transform.source_to_widget(PointF(25, 15)) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=QPoint(round(point.x), round(point.y)), + ) + + assert value.inspector.exclusion_controls.selected_readout.text() == ( + "Selected region: x 20, y 10, width 30, height 20 source pixels" + ) + assert ( + value.inspector.exclusion_controls.selected_readout.accessibleDescription() + == value.inspector.exclusion_controls.selected_readout.text() + ) + + +def test_region_readout_reports_no_selection_after_leaving_region_mode( + window, qtbot +) -> None: + value, _ = window + region = CropSpec(20, 10, 30, 20) + state = replace( + _ready_with_crop(), + parameters=replace(_ready_with_crop().parameters, exclusions=(region,)), + ) + value.render_state(state) + controls = value.inspector.exclusion_controls + qtbot.mouseClick(controls.edit_button, Qt.MouseButton.LeftButton) + canvas = value.original_canvas + assert canvas._geometry is not None # noqa: SLF001 + point = canvas._geometry.transform.source_to_widget(PointF(25, 15)) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=QPoint(round(point.x), round(point.y)), + ) + canvas.set_exclusion_edit(False) + + assert controls.selected_readout.text() == "No region selected" + + +def test_overhanging_region_readout_uses_the_cut_exclusions_intersection( + window, qtbot +) -> None: + value, _ = window + region = CropSpec(60, 20, 20, 10) + state = _ready_with_crop() + state = replace(state, parameters=replace(state.parameters, exclusions=(region,))) + value.render_state(state) + controls = value.inspector.exclusion_controls + qtbot.mouseClick(controls.edit_button, Qt.MouseButton.LeftButton) + canvas = value.original_canvas + assert canvas._geometry is not None # noqa: SLF001 + point = canvas._geometry.transform.source_to_widget(PointF(61, 21)) + qtbot.mouseClick( + canvas, + Qt.MouseButton.LeftButton, + pos=QPoint(round(point.x), round(point.y)), + ) + + effective = cut_exclusions((region,), state.crop) + assert effective + assert controls.selected_readout.text() == ( + "Selected region: x 60, y 20, width 20, height 10 source pixels; " + "partly outside crop" + ) + + def test_invalid_saved_geometry_falls_back_to_default(window) -> None: value, _ = window settings = value._settings diff --git a/tests/ui/test_minimum_layout.py b/tests/ui/test_minimum_layout.py index ccff4ea..03d40e3 100644 --- a/tests/ui/test_minimum_layout.py +++ b/tests/ui/test_minimum_layout.py @@ -3,8 +3,11 @@ from collections.abc import Callable from PySide6.QtCore import QSettings +from PySide6.QtGui import QFontMetrics from PySide6.QtWidgets import QApplication +from matteloop.core.parameters import ParameterState +from matteloop.core.specs import CropSpec from matteloop.core.state import AppState, SourceLoaded, SourceLoadRequested, reduce from matteloop.ui.main_window import MainWindow from matteloop.ui.theme import install_theme @@ -99,6 +102,40 @@ def test_inspector_content_minimum_width_fits_each_scroll_viewport(qtbot) -> Non application.setFont(original_font) +def test_exclusion_count_is_fully_visible_at_the_narrowest_inspector_width( + qtbot, +) -> None: + application = QApplication.instance() + assert application is not None + original_style_sheet = application.styleSheet() + original_font = application.font() + try: + install_theme(application) + settings = QSettings( + QSettings.IniFormat, QSettings.UserScope, "matteloop-test", "count-width" + ) + settings.clear() + state = AppState( + parameters=ParameterState(exclusions=(CropSpec(10, 10, 20, 20),)) + ) + window = MainWindow(Store(state), Services(), settings) + qtbot.addWidget(window) + window.resize(1100, 720) + window.show() + for _button, body in window.inspector.disclosures.values(): + body.setVisible(True) + application.processEvents() + + count = window.inspector.exclusion_controls.count_label + text_width = QFontMetrics(count.font()).horizontalAdvance(count.text()) + + assert window.inspector_scroll.viewport().width() == 322 + assert "…" in count.text() or text_width <= count.contentsRect().width() + finally: + application.setStyleSheet(original_style_sheet) + application.setFont(original_font) + + def test_empty_has_only_restrained_source_surface(qtbot) -> None: settings = QSettings( QSettings.IniFormat, QSettings.UserScope, "matteloop-test", "empty" From f6e9eb96934440b4da4d05e54a24f69c28bb9855 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 15:13:57 +0200 Subject: [PATCH 17/21] =?UTF-8?q?=F0=9F=90=9B=20fix(i18n):=20translate=20t?= =?UTF-8?q?he=20readout=20as=20sentences?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 🐛 The selected-region readout was assembled from a stem plus the appended fragments `"; entirely outside crop"` and `"; partly outside crop"`. A fragment carries no grammar of its own, so it forces every language into English word order and cannot be translated at all by one that has to lead with the qualifier or restructure the clause. German happens to append too, which is why it looked correct. - 🛠 Each case is now one complete literal sentence chosen by `_selection_template`, matching how the canvas announcement added in `70293e0` already did it. `_crop_relation` names the three cases from the same `cut_exclusions` mapping the renderer uses, so the readout cannot disagree with the painting. - 📝 Catalogues regenerated: 547 strings, 547 finished, 0 unfinished in both languages; the two fragments are gone rather than left obsolete. Trigger: review of the strings added in `2cf9c8a` — three catalogue entries for one sentence. Refs #80 --- resources/matteloop_de.qm | Bin 72434 -> 72802 bytes resources/matteloop_de.ts | 32 ++++++------ resources/matteloop_en.qm | Bin 64272 -> 64644 bytes resources/matteloop_en.ts | 32 ++++++------ src/matteloop/ui/exclusion_controls.py | 66 ++++++++++++++++--------- 5 files changed, 75 insertions(+), 55 deletions(-) diff --git a/resources/matteloop_de.qm b/resources/matteloop_de.qm index 42397c46bebd0735bf4dff6de97aae452be3f88e..04a2c0f7a8916deb9dbb5dbd14027959ad5d8f87 100644 GIT binary patch delta 4472 zcmYLNdq7V2|9_qHoO7P%JeTuq5Yf;2#z)%l(UIwl|2l^0ibOHLl!V!Si72;yx{n0?qA3&fV z@a9n9$p&D{W;@n|tV?NWyA%rDuqy6S3Te%9VAo7YNm;%{#))gO>@Cj#blJI;D& z$D4a0?K=#tyawr{1X%TuZWI8w=0J{G0~B_G9K8+L`v&A=jlg{u=)=+g<3Y3uNCvj; zM4M&fVMC6FPA_Hv*}LG}vj%8+5^wuGB;8YZ=fg~(-DEp1YHi1j8V2_G3#hDxU(a`d zm)r1u@hG6@a=c#_PxQs`9xHgzd<^fq5%@UJjtLv=_;Nfx9P18rTY`_*7TJK>i3lEd ziU*7MB#9p!U4Su##{tJn7`v70-#6N^d<@3zrvExU#P~apf#jE%@ZWC0x!jJ`cQC0{ zTN2)dX%EVQpQ{k%;>>4@9b*y^^J>5114zu{ zE#M#i+!ZG~bA6LHO3K24f>>O8I~M3Z8`p>VFt{J$=elANeH)K&1_51?@vM>fYpsB) z(+o{3q3ft2z~_sF?oXBggPseXj-7#j`Usu}xsUf&VVI5kVs;y0Sa?Ukq6&dBRdiet z#=MAvpjd?v|EYj>QV3nZ7-sz?M1^o&xGBu7W6WoH*l|gg5I^YwFs?{Q_j#pISK+H* ze_&lZVdvx!;EO0BuX-2ILJ$sj=tK3L5>CFm3b@o-u$3R6rPv@;I`0I0W(rmM=5+0D z;emT4iIs?AR$n0FiKy<41eRYGd(7d6k9DF~r&kunh=X%}q)VTR{?GZHvdNBCZ!z@u ze`rvc82N}EIzCaHm&4G`w1^ApWnfJQ(dHKiWOlcS@eA7nCtbz(B8p~~D8^T;fS|7z zQ|f8q+y-$=(k)>05^=|jznEY3V*XPNf}|4<!l;4@XvMvUyhU_HM;!vJ!z$hIPDi{?H7Ds)lN$G zqvf&trSxH^fS@&YjO%8{yz_Q^0l$=!YFq24Ryo)<3yXAX5Jc;JY zOCv~3UnM854PiZqk(07yu9wP5`#jlWGGtpyM_=F%y}Whm9pLH&IeRt_{OXy!Cx*nn zJ1QT^8Vw}Q2=Ksq=4cd#lU5c*tM*hIo_HYke@Fg@G6RAQAJ;5}QGvV2`UOY3SSwUo@>t5(*(!d79* zrmT@{qmz{k^aI`~RkkGXz!qW3j)f$+*IUWHzzscyDmw#;0M`sVCN6o6f_z3fX*>c! z{Z~0NiXMK@S^42A_i>50<9maY(yb(ByYqo^V^%RM)0NjKsMC~3LG(nsCZ%p=EVYrO zGz4q_erZq|PBZ~wQF@0et`Er7_xO^Y_-VG@{Y85qWVpWn&y2n69XlqL=)KcvY3twg zKET$Y^Z}VKW4&`q{y>#OR}+yFU^r+NNK$Oa(sNs^9+g5T=`;&;4>K)9Gz}UcV3$`BR_Yf%|2a z>5KBC*-NJAi(P9-B7itL4YR+u<)G)h_D&IfI5W{+fj!O)2^ZEYrCd1mRtPe-?49QQc zfc1L}CvMZ_k?Rd78i|_TP*OUV1R@PTxSnG{D=_?E8%Tyv4;jjTqf1<>4V4Nl8#CAN zt2;eX^2pG*bSmqChoMPmON|)qxaF*>-%p~$W!2zNPlC5q!=7Z|Kd6>HeE(6b+G-XJ zaCcB!74Um`rrIrd2S>5BYWIGBabkL@`t%^djYn16d+oXaZM&-<$1uOg-c(2T9YGHa zS3fJHMe7c!GhE$({-x@?J)MES_o<6&*0WIQ)YbPJ*xkmcYideadONCLj@Pj%Jykaz z$)Q+f^{eJ2mD-6N6-x_tNIA0I^(&&EUC`Y(z zqyO^|;GI>*kMb!x{XFCJdE+_jWf;RPd_G-m3~$d6iRX>s{n`V)Y@>|}rySx;ry3V8 zN}yOmjq!QT95VMCQ`0#luG(na)H#mh_XRuNd|=GzSqubsHg1_QiX&Q%@whFL8+#io zUu@*y-`jY*0}VNK!FYRBG-DrZd~|}(i^iKA`!h6wGfYmucmg-wOx@4C!~Ea6)6}yq zT^+UAPCOl*dMO|^M{+puY15QshYx)c<`^m zrtmbPM~x{wcL)nsr77lNG7Ho$)8gP*VA4pFZ6b+GDKRZCxyA|^Y{$4z)5?W8%zw8x zO_{~CaL`gyE;L|Yg=x>Kdn_aqO@$3yPMCqp2uyG(&UVRO06b zLD$~&`-prX!q4=qp#s?Ysad_+0(dmhZ1En=tmtIc{zt6XZtj$=7d!u zA)onwVXfIq--V^p$?Vl;3iG$r?0r@O?wQR&y*ZAb63wI9WiqyH%o9H0`l^xUNiM$w zPAkk)UgI@$#99(9*35JMnGHxC%!^h|Vu5;Oj%&7!gGg6%yx;>2t~RgUSI;y|G_RY; zlKppEb9SZe0bP6Ce5hYMn@v}9!TgWOe7E`NzqDx9W;>p^YA(I6aOm7^zMxHIp-DAg zatZ~~)6KVwXc5)%8c%1KfBB9#n{&6!|5j{ZGi$OK{|jOrIcKr7O$MHIw>TDY-*%ZBMBQgF|*-9*jwk}O&4 zT zzyeJd$-kdePu$5+MQFNR^u+y>nl!@=V-zx?VwAO+;lj(ypZS2;1 z-dfvepY7%W5fxg{+CW|4;-zfaY2C)aQynx^G_-2wPLUn}r9 z&HK8mcI?}DHmf}C?64e0&gO6bG4EZiD2p}v$Q13;9DnxtQ(C$AR1&DyF6VdQ%_Uu{ z`cLBqwc4HC^u%Ca?S6?T*ORoz5l<t@$9C1KAAgv2qTH&AI^Kj1 zTU)fJVY{5HjxR{0#LMcMHJ|675Un0F=27L*R{yoBK!+jLfCZ2F--Q9zp<4<#W*1sV zK4a}K3buwdk#M4$b$Z}jUL@98qwZhi@Y&oNbMP%rG!fQ>um;wL1J>06^=!)()}){K zeZ8+WU7#Uzs;n8Cn4VkywPrT12U6XwdDCO@E;4egg%xC2*UDOS{d3^2cGjP=xpCZa zYxQ}eSG={Rb2d-DX?-x@4)EEh;Sfw64i9{Dje7X3)9DsM$>#elg;r^2drwK*J=6lTj>*?J0yzl$`p5J=9dqDcFNXlq8rR^mE;lQ0O z#1TN-mv+2!8W7t7l_D`7Fw_BlKLb}516|(XUcmny)&K#QfvYB<-!LF|0nk4fXxtZg zyb4(FVaGdlE7F_V%3nhlR>fW6ke2ez+ zCkt)fP6f93!`=HH(5x68g71^=0etvb7T^+L$HZ-R%*;ZM_OF48Lj8!&u1 zHx%g+Ui<^l@+?Mdk;rxI>!9Hjs6*H$2&0?*UXuOw_sB3 zMW8wwaqZmstlBZLC1$@nue3Lo73>7^#v*IFtpPA6VH4H>qb1~|UjuIV;=nAvShXLA z+_=7~94E`8fqfdTbVvd|pl`!^0iic>{Ye>#dg4*_0Km-!Z|aFp5(QM10Lfd0_lMBw z5hlUw@qdA!#e$!c8}R!H!S8#X)1!kBX5+bt$rr++TLYRb^q1Sx_iKdkw{Z}pO+rM- zM8H}sM9!iQH>U`35nLClg&9xi^J%4aoa-wjkE>;{4i?t-VuV%{3+sl40ORCmMx^T&zpr}MxEnPNa2T9~4Wee%vw(#2xP@7$-XvEzGzV&scIY0v~Q<`*hd z{6b8~qietXPMlRI1B-Www%~;f!h<$3Inf39p;$~VWzbApDJEa~8iJA}rq|KJ_+)Xz z@*BWVv$$pIYvx&!Sol(dAZCiY^BRC77scYnv~>DCv1Hy1AiGjLF)f~!`TUE5VSsqf z%8Ob~63bVT$bWt8c*?pj{V-SPfR?|~Az!uCr_18_>)(d#%uZud%C?4#pi+M$fe+trN zTuJ7I-n#WULx8xEx~wzHfZ>`h&t)&*8m%kd#eGpHbmjeDGHs{o$}?D@rbXzkgxm*q zuGQV>9szV3ue&{>FO~Sqj-IiiBN`E6(T4W+d&XQ8U%hHa#JOlKetfh2*W(v;{?U-(r zt}SE?EdEuxk(mS>JSRP=x4i-!=J5~W^-j{$N(ROCanjo%e4d^tu1_Om3${+9G!qQoCe=!dNyyeehD`-hqIXsd1>QpFC zcw7k7kCG?(apT2r8s>rsS!YiDlgBLxgIXtmhbdqetOC2t%HE)-^v>&-XgDm|jY0Aqz6k6lqh*YdzWE-4>-(vsw{N`G-H5UVN!8T zHlqOL%Q+G-aj}xvK*Eh*D06l*O`U9iD@jTo(A!s8up*hhY_4RSCbQmg%F1`xe1ftj zdmx+AZ_0WE0*#I<8&Y^-(+SF!L=wy|S8~qrz)n|{+|W|i3okpSn*T*X8mJsH?t@@R zRgMm!!gu#5rz&`kyMrBVK^K+N8_Dd(b>-SuWvoyW{zXCmM)_p`m2mk>d9o;pvEi(| z3SGr+nXJ4z*Z@ot^$t~B?-rgN{9Bn%2H*N0A^jo3N|7ISu$x~kt7y*p=T3_hO^S&FS zFD;A*mcP`OdE6tB0z0N|(Vtu|*?@61`to6)1HTsQZ*Stkv(xN&wnqPaUJ9E^kR9h% z=-=oWE93t(Sjsh4wg$s{+t{4K4jCNU{lV@w$k1|NFa&wC!F`Vpuwu8NV?iW?_%}o6 zk+(Q=ePjsO>cH&z!qDv@gVj6K5E^EqB*q%T)DjYDX$Y%o0Cq1ljA&B` zoZ4*|QD9;IKDXno*M{iqCP3-~L+leqdBH`)!kK)&_`V^vf_0&&ry=cS6$x}R9K1=X zr@0vp))TEd!^zV#82t@~QywQ+$U+RKY(2>Aw?2l8&ncCAoS{;oMgNfuPkm#66Eh9< z^CnWlQbU8_49s0`$Mu6${Vo#hw^}tg)Uo+YQw`hGfIl--%Xa=gP*ajmW?QWc0dZ=^mtpxtbRF~X&1&n;CF1^RGIBU21&1fB)(n59hzC7UmYIR)` z66(2D-Bi~KXmUo~E`+e)tW!@8<-W_F>ggI9T2^VZ|8c=fy;s1CditpMTb8g;c&iV6 zUqMhCtB*_C0k?0c&;9F|jz`q`^Z~SFiBY^v=?{Nq)E)kn?X;EA_u76&f1EMo_XwbK zGvlB_2Ae*?I5}Z7gW1a%ZQ=8gIAgR6T_m10MhChu25k3@i4*n!p6iTr=cKTtzBVQo zxYO4`#*DQb5*M{Iu5nw)@%ywLt7aJ2dzZ02?=fzeI)uU2#rT6QhD6GZm2X#bKsjo> z=}JQmjW*s~9M7z(HU4st&xub>PTlC5Pu`kZKJepMUt;n)`XT%O20xRxGo_yHVe$#2 zG`S9@9_@-aMEaO|)fWPvcQ6fF9n3NNC)0>Cmw_48rqL^E+11vWqL%aG$F-*DOrmeR zDLTI|us_l?`+gd*-QP5KXcF+nZIf**iHsj^T5$3T+i2MP=-|A{Q(tHr5HJVD74Wo-jnN9}# zKoAN|FFr2>CRdo=yy7R+`UhsU!jbL$h1t?`7)Pz|&Dt~K&mGNea&*9XPje@E81sMG zM`k|wa^x&8YxbL+=A24O`cIg7Phc{q-2LXFnS&X{UCsOdBC!|`JN_`yeEN<8LD$uMPMgSC zv9tiqsGx!T_Y_~?gAyQuuOh8&3+bciCe>{cHCi!Z#|UET`URtlPGbZ zW!}wpl)RB;e&aL}`oXfO+js`kGs}|Rdd`R*c3k3VSsu@eCv38;noJ`5VlA6YG}L>Q zC41#UVA$stTh10vIFV*cZaxY0DYsm73!?O8mb-V?P=RNbhYOkCTQ^vq{FlMkDoexV zS^O^0Yq}V|KQ@V&%S!i`ru!e2xc#XnjR|IcPtv5hwDd(IOcIAN6 zODpPJ!un9G9XOKAW@XFQj)mpXbs=_)KdqH!vsUkUsa=>J!ajdMyV!FgD`JxNb75QN zv!_<|w+4KesNLE|C3;`b?ws`Fy0i9Z%1Z{>3++ks0i1lkv?}Lf*p}B>^`rL!L&jQF zQO7T$T~hzXGY{ySoJ+fy42Uc1;PfcLq&{;!gJ>q{Cx?4ZqP(Q{1zJ!UPKoP@4e*Tq_ViOe2twU%D}g03jA{*=RmzYeqB zJxla=u-ExclusionControls - + %n region(s) %n Region @@ -376,44 +376,44 @@ Keine Region ausgewählt - - Selected region: x %1, y %2, width %3, height %4 source pixels - Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel + + Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop + Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel; vollständig außerhalb des Zuschnitts - - ; entirely outside crop - ; vollständig außerhalb des Zuschnitts + + Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop + Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel; teilweise außerhalb des Zuschnitts - - ; partly outside crop - ; teilweise außerhalb des Zuschnitts + + Selected region: x %1, y %2, width %3, height %4 source pixels + Ausgewählte Region: x %1, y %2, Breite %3, Höhe %4 Quellpixel - + Edit Bearbeiten - - + + Edit exclusion regions Ausschlussregionen bearbeiten - + Clear Zurücksetzen - + Clear exclusion regions Ausschlussregionen löschen - + Selected exclusion region Ausgewählte Ausschlussregion diff --git a/resources/matteloop_en.qm b/resources/matteloop_en.qm index a7cb46f24265d6430971c68c4727282d3b65a3ba..43968717389d88fec7fcb946b2b20892ed642d5e 100644 GIT binary patch delta 4462 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 L?ogxG{tN#DyLU<@ diff --git a/resources/matteloop_en.ts b/resources/matteloop_en.ts index 93fb2ab..43c94c9 100644 --- a/resources/matteloop_en.ts +++ b/resources/matteloop_en.ts @@ -82,7 +82,7 @@ ExclusionControls - + %n region(s) %n region @@ -376,44 +376,44 @@ No region selected - - Selected region: x %1, y %2, width %3, height %4 source pixels - Selected region: x %1, y %2, width %3, height %4 source pixels + + Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop + Selected region: x %1, y %2, width %3, height %4 source pixels; entirely outside crop - - ; entirely outside crop - ; entirely outside crop + + Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop + Selected region: x %1, y %2, width %3, height %4 source pixels; partly outside crop - - ; partly outside crop - ; partly outside crop + + Selected region: x %1, y %2, width %3, height %4 source pixels + Selected region: x %1, y %2, width %3, height %4 source pixels - + Edit Edit - - + + Edit exclusion regions Edit exclusion regions - + Clear Clear - + Clear exclusion regions Clear exclusion regions - + Selected exclusion region Selected exclusion region diff --git a/src/matteloop/ui/exclusion_controls.py b/src/matteloop/ui/exclusion_controls.py index fcc1ef4..6c399f3 100644 --- a/src/matteloop/ui/exclusion_controls.py +++ b/src/matteloop/ui/exclusion_controls.py @@ -53,34 +53,24 @@ def set_selected_exclusion( if exclusion is None or crop is None: text = QCoreApplication.translate("Inspector", "No region selected") else: - text = QCoreApplication.translate( - "Inspector", - "Selected region: x %1, y %2, width %3, height %4 source pixels", + # One complete sentence per case rather than a stem plus appended + # fragments: a fragment forces every language into English word + # order, and a language that must lead with the qualifier or + # restructure the clause cannot translate it at all. + text = self._format_selection( + _selection_template(_crop_relation(exclusion, crop)), exclusion ) - values = (exclusion.x, exclusion.y, exclusion.width, exclusion.height) - for number, value in enumerate(values, start=1): - text = text.replace(f"%{number}", str(value)) - boxes = cut_exclusions((exclusion,), crop) - if not boxes: - text += QCoreApplication.translate( - "Inspector", "; entirely outside crop" - ) - else: - box = boxes[0] - effective = CropSpec( - crop.x + box.left, - crop.y + box.top, - box.width, - box.height, - ) - if effective != exclusion: - text += QCoreApplication.translate( - "Inspector", "; partly outside crop" - ) self.selected_readout.setText(text) self.selected_readout.setToolTip(text) self.selected_readout.setAccessibleDescription(text) + @staticmethod + def _format_selection(template: str, exclusion: CropSpec) -> str: + values = (exclusion.x, exclusion.y, exclusion.width, exclusion.height) + for number, value in enumerate(values, start=1): + template = template.replace(f"%{number}", str(value)) + return template + def tab_widgets(self) -> tuple[QWidget, ...]: """Return the row's keyboard controls in visual order.""" return (self.edit_button, self.clear_button) @@ -136,3 +126,33 @@ def _build_layout(self) -> None: layout.addLayout(actions) layout.addWidget(self.count_label) layout.addWidget(self.selected_readout) + + +def _crop_relation(exclusion: CropSpec, crop: CropSpec) -> str: + """Say whether the stored rectangle is fully, partly, or not in the crop.""" + boxes = cut_exclusions((exclusion,), crop) + if not boxes: + return "outside" + box = boxes[0] + effective = CropSpec(crop.x + box.left, crop.y + box.top, box.width, box.height) + return "inside" if effective == exclusion else "partial" + + +def _selection_template(relation: str) -> str: + """Return one complete translatable sentence for each relation.""" + if relation == "outside": + return QCoreApplication.translate( + "Inspector", + "Selected region: x %1, y %2, width %3, height %4 source pixels;" + " entirely outside crop", + ) + if relation == "partial": + return QCoreApplication.translate( + "Inspector", + "Selected region: x %1, y %2, width %3, height %4 source pixels;" + " partly outside crop", + ) + return QCoreApplication.translate( + "Inspector", + "Selected region: x %1, y %2, width %3, height %4 source pixels", + ) From 2b08dbf9c38fd9a2a84750ba9cd79a5624aede5b Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 15:42:46 +0200 Subject: [PATCH 18/21] =?UTF-8?q?=F0=9F=93=9D=20docs(design):=20plan=20pre?= =?UTF-8?q?-model=20exclusion=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 📝 Decision 7 adds regions that blank the frame *before* segmentation, so a bystander at the frame edge is never read as a person at all. Zeroing alpha afterwards removes them from the output but leaves the model treating them as foreground, which distorts the matte of the wanted subject — the post path cannot fix that. - One global switch rather than a flag per region: about 60 lines against about 200, and the request-level shape is identical, so it can grow into a per-region flag later without a migration. - Pre-model is a superset of post, never an alternative: with the switch on, a region acts in both stages. - The boxes enter the cut cache key only when non-empty, so a user with no pre-model region keeps every cut set stored by 0.4.1 byte for byte. Verified case by case against the literal key pinned in `tests/core/test_fingerprints.py`. - The fill identifier lives inside the key's value, so changing the fill later invalidates only pre-model sets. - 📝 Records a trap found while verifying it: `_validate_cache_inputs` accepts only exactly known keys, so without a validator change every manifest carrying a pre-model region would be rejected as invalid and the cache would silently never be reused. - 📝 The fill is to be measured, not asserted. A hard black rectangle is itself an edge and a model may read an edge as an object, which would make the feature worse than not using it. Six candidates, a paired harness against a real model, a metric, a rejection rule, and `imagenet-mean` as the fallback — the one candidate with a model-independent argument, being the normalisation zero of twelve of the thirteen models. - 📝 Marks Decisions 1 to 6 as implemented; the document still claimed no implementation existed while fifteen commits had landed. Refs #80 --- docs/designs/exclusion-regions.md | 587 +++++++++++++++++++++++++++++- 1 file changed, 577 insertions(+), 10 deletions(-) diff --git a/docs/designs/exclusion-regions.md b/docs/designs/exclusion-regions.md index b7b30a2..66f1017 100644 --- a/docs/designs/exclusion-regions.md +++ b/docs/designs/exclusion-regions.md @@ -3,8 +3,11 @@ Architecture pass on 2026-09-12 for issue #80 Branch: feat/issue-80-exclusion-regions Repo: smb-org/MatteLoop -Status: REVISED after an independent adversarial review; no implementation yet. -Every `file:line` below was read on this branch. +Status: Decisions 1–6 are REVISED after an independent adversarial review +and are **implemented on this branch** (`b1caf0a` … `70293e0`). Decision 7 +(pre-model regions) is a second architecture pass on 2026-09-12 and is **not +implemented**; its `file:line` citations were read at `70293e0`, the earlier +decisions' at the commit that preceded their implementation. ## Review findings addressed @@ -37,12 +40,18 @@ forced to alpha 0 **after segmentation**, as part of `FramingSpec`. Two decisions are settled by the maintainer and are not revisited here: - **Rectangles only, several of them.** No polygon, no ellipse. -- **Post-segmentation, not pre-model.** The crop is part of the cut key - (`core/fingerprints.py:207`), so a pre-segmentation mask would re-segment - the whole clip on every drag, and rembg models judge the frame globally, so +- **Post-segmentation by default.** The crop is part of the cut key + (`core/fingerprints.py:212`), so a pre-segmentation mask re-segments the + whole clip on every change, and rembg models judge the frame globally, so blanking an input region is model-dependent. Zeroing alpha afterwards is deterministic and reuses the stored cut set. + **Reopened 2026-09-12, Decision 7.** With the post path alone the model + still reads a bystander at the frame edge as foreground and that distorts + the matte of the wanted subject. A region can now *also* be applied before + the model; the re-segmentation cost is accepted and keyed in the cut. The + post path stays as the default and the instant-feedback path. + ## What already exists (verified) **Cut frames are crop-sized.** `_produce_cut_frame` (`jobs/render.py:1529`) @@ -133,9 +142,12 @@ first draft listed it as frozen at 328 and that was wrong on both counts. ## Constraints -- Regions apply after segmentation and never enter the cut key. A region - change must not invalidate the stored cut set, and must invalidate the - preview, the render fingerprint and the union cache. +- Post regions apply after segmentation and never enter the cut key. A + post-region change must not invalidate the stored cut set, and must + invalidate the preview, the render fingerprint and the union cache. + **Pre-model regions (Decision 7) are the one exception by design:** they + enter the cut key, and only they do; a user without them keeps the key + 0.4.1 wrote. - **The re-segmentation promise, stated precisely** (review finding 5). What holds: the stored cut set stays valid under any regions, so **Render and Rebuild never re-segment** for a region change — they reread the stored @@ -764,6 +776,503 @@ region in its `ParameterState` so `main-window.png` shows a rectangle on the Original canvas; README gains a short paragraph in the crop/cleanup description; regeneration per `README.md:150-159`. +## Decision 7 — Pre-model regions: blank the model input, keyed in the cut + +Second architecture pass, 2026-09-12, on top of the landed post path +(`70293e0`). Settled by the maintainer and not re-argued here: a region can +optionally be applied **before** the model sees the frame; that changes the +segmentation input, so it enters the **cut cache key** and a change to it +re-segments the clip; the post path **stays** and keeps its instant feedback. + +The reason it is urgent, in one sentence: with the post path alone the model +still reads the bystander as foreground, and a person at the frame edge +changes how the model resolves the wanted subject — the post mask removes the +bystander's pixels, not the model's opinion of them. + +### 7.1 Data model — one global switch, the rectangles reused + +**Chosen: a global switch.** One new boolean on the parameters and one new +tuple on the segmentation spec; no new rectangle type, no second tuple in the +reducer, no per-region flag. + +```python +# core/specs.py +@dataclass(frozen=True) +class SegmentationSpec: + model_id: str = "birefnet-portrait" + edge_mode: EdgeMode = EdgeMode.STANDARD + alpha_matting: AlphaMattingSpec = field(default_factory=AlphaMattingSpec) + execution_provider: str = CPU_EXECUTION_PROVIDER + exclusions: tuple[CropSpec, ...] = () # regions the model must not see + +# core/parameters.py +@dataclass(frozen=True, slots=True) +class ParameterState: + ... + exclusions: tuple[CropSpec, ...] = () + exclusions_before_model: bool = False +``` + +- **Where each kind lives.** A pre-model region is segmentation input, so the + request carries it on `SegmentationSpec` (`core/specs.py:205-240`), the spec + the cut key already hashes through `model` and `_edge_settings` + (`core/fingerprints.py:213-220`). It is *not* framing: `FramingSpec` + (`specs.py:244-298`) keeps `exclusions` exactly as landed and the post path + is untouched. +- **Same rectangles, oriented source pixels.** `SegmentationSpec.exclusions` + has the same type and the same validation as `FramingSpec.exclusions` + (`specs.py:291-298`, copied verbatim): a tuple of `CropSpec`, no bound + against the source, no count cap. They are mapped into the cut with the + existing `cut_exclusions` (`core/exclusion.py:40-52`) — verified in 7.4. +- **The switch, not the spec, is what the user edits.** The request builder + (`ui/request_builder.py:94-105`) fills both specs from the one tuple: + + ```python + segmentation=SegmentationSpec( + ..., exclusions=parameters.exclusions if parameters.exclusions_before_model else () + ), + framing=FramingSpec(..., exclusions=parameters.exclusions), + ``` + + With the switch on, every region is blanked before the model **and** still + zeroed after it. Pre-model is a superset of post-model, never an + alternative to it, so the request builder is one expression and the six + post sites (Decision 3) need no change. +- **The stored cut carries the blank.** `_produce_cut_frame` zeroes the + pre-model boxes in its result (7.4), so a pre-model cut set has alpha 0 + there *by construction*. That is what makes the two tuples independent: a + request whose `framing.exclusions` differs from the set's + `segmentation.exclusions` (the picker's Rebuild with a changed layout, + `ui/workspace_presentation.py:142-183`) is still correct, because nothing + the model produced inside a pre-model box survives in the stored bytes. No + cross-spec invariant, no validation in `RenderRequest.validate`. +- **Reducer.** One event, `ExclusionsBeforeModelChanged(enabled: bool)`, + reduced like `_reduce_trim` (`core/parameters.py:352-361`): reject a + non-`bool`, no-op on an equal value, and — like `_reduce_exclusions` + (`:383-402`) — **no preview invalidation when `cut_exclusions(exclusions, + crop)` is empty**, because the request is then byte-identical either way. + Otherwise `PreviewInvalidationReason.SEGMENTATION` (`core/tokens.py:26`). + `_reduce_exclusions` picks its reason by the switch: `SEGMENTATION` when it + is on, `CROP_CLEANUP` when it is off (`:398-402`). `_reduce_parameters_reset` + resets the flag and compares it in the `SEGMENTATION` branch (`:255-259`). +- **Persistence.** One QSettings bool `parameters/exclusions_before_model`, + parsed by the existing `_bool_value` (`parameters.py:569-577`) with its + per-key fallback; absent → `False`. `ui/preferences.py:15-27` gains the key, + `:44-72` persists it. The region string is unchanged. +- **Why not per-region (the fork).** A per-region flag is the more general + model and it is *not* chosen now, for three measured reasons: + 1. It is not the smaller diff. Two tuples through `ParameterState`, + `ParameterPresentation`, `CropPresentation`, preferences, the request + builder and the reducer, plus a selection identity that spans two tuples + in `ui/exclusion_canvas.py` (745 lines; the mode/select/drag code is + `:252-690`), plus a per-region checkable action in + `ui/exclusion_context_menu.py`. Estimated +200 lines and a split of the + canvas module. The global switch is ≈ +60 lines of `src/`. + 2. The coexistence case — a post-only chat box *and* a pre-model bystander + in one clip — is plausible and unmeasured. The maintainer's report names + one bystander. Ship the switch, measure whether mixed clips occur. + 3. It is upgradeable without a migration. The request-level shape + (`SegmentationSpec.exclusions`, the cut key, the manifest key, the + pipeline call, the fill, the tests in 7.8) is identical under a + per-region model; only the reducer/UI grain differs. A later + per-region flag reads the bool as "all regions flagged". + The alternative is recorded under *Rejected alternatives* with the two + shapes it could take. + +### 7.2 Cache and fingerprint — the non-empty rule, verified against the cut key + +`cut_cache_key_inputs` (`core/fingerprints.py:188-222`) gains one entry, +**present only when the effective boxes are non-empty**, and the preview +identity gains the same entry under its `segmentation` sub-object +(`:154-158`): + +```python +def _model_exclusions(request: RenderRequest) -> dict[str, object]: + boxes = cut_exclusions(request.segmentation.exclusions, request.crop) + if not boxes: + return {} + return { + "model_exclusions": { + "fill": MODEL_FILL_ID, # core/exclusion.py + "boxes": tuple((b.left, b.top, b.right, b.bottom) for b in boxes), + } + } +# cut_cache_key_inputs: {..., "edge_settings": _edge_settings(request), **_model_exclusions(request)} +# preview_fingerprint: "segmentation": {"model_id": ..., **_edge_settings(request), **_model_exclusions(request)} +``` + +**Why the fill identifier is inside the value.** The fill (7.3) is part of +what the model saw. If a later measurement changes it, the cut sets it must +invalidate are exactly the pre-model ones; bumping `PIPELINE_SCHEMA_VERSION` +(`fingerprints.py:30`) would orphan every set of every user. Carrying the id +inside the only-when-present value scopes the invalidation correctly. + +**Why tuples, not lists.** `_freeze_mapping` (`fingerprints.py:382-391`) +turns a list into a tuple but does not descend into it (`:387-388`), so a +list of lists would leave mutable inner lists behind the "recursively +immutable" docstring (`:197`). Tuples of ints freeze as-is, and +`_canonical_value` (`:394-399`) renders tuples as JSON arrays. + +**The key does not change for a user without pre-model regions — verified +case by case:** + +| Case | `segmentation.exclusions` | `cut_exclusions(…, crop)` | Entry | Key | +|---|---|---|---|---| +| Switch off (every 0.4.1 request) | `()` — request builder | `()` | absent | **byte-identical** to `tests/core/test_fingerprints.py:610-646`, which pins the canonical JSON literally | +| Switch on, no regions | `()` | `()` | absent | unchanged | +| Switch on, region entirely outside the crop | non-empty | `()` — guard at `exclusion.py:50` | absent | unchanged, and correctly so: the model input is pixel-identical | +| Switch on, region clipped to zero width or height by the crop | non-empty | `()` — same guard (`right > left and bottom > top`) | absent | unchanged | +| Switch on, region intersecting the crop | non-empty | boxes in cut space | present | changes → new cut set | + +- **Crop.** Boxes are crop-relative (`exclusion.py:46-49`), so a crop move + changes `"crop"` (`fingerprints.py:212`) and the boxes together. The same + region under two crops yields two keys, which is right: the model input + differs. +- **Rotation.** Regions and crop are both in oriented source pixels + (`specs.py:108-109`); rotation is decoded from the file and is covered by + `source_sha256`. The boxes are in cut space and carry no orientation, so + nothing further enters the key. +- **Manifest round trip.** `CutManifest` re-derives the key from its stored + inputs and refuses a mismatch (`workspace/_manifest.py:168-171`, `:295-301`). + `_freeze_json` accepts lists and tuples (`_manifest_validation.py:188`), + `_thaw_json` gives lists back (`:198-199`), and `_canonical_value` passes + lists through to `json.dumps`, so the hash of the thawed manifest inputs + equals the hash of the request's tuples. Verified by reading; pinned by + the round-trip test in 7.8. +- **The manifest validator must learn the key.** `_validate_cache_inputs` + (`_manifest_validation.py:76-90`) applies `_exact_keys` to + `cache_key_inputs`, so a manifest carrying `model_exclusions` is + `CUT_MANIFEST_INVALID` today — `find_matching_cut_workspace` would swallow + that (`render.py:592-599`) and re-segment on every render, and the set + would never be reusable. The validator gains an *optional* key: the exact + set is extended by `"model_exclusions"` when present, and a + `_validate_model_exclusions` helper checks `fill` with `_bounded_text` + (`:278`) and each box as four ints with `_bounded_int` (`:272`), + `0 <= left < right <= MAX_CUT_DIMENSION`, same for top/bottom. The module is + 344 lines, so the ratchet does not apply (`scripts/check_guardrails.py:120-128` + fires only above 800); the helper stays under 60 lines. **Not a baseline + question.** +- **Old binaries.** A 0.4.1 build reading a pre-model manifest gets + `CUT_MANIFEST_INVALID` from the strict schema and treats it as "no cut + set": it re-segments without the blank — degraded, not broken — and its + picker lists that set the way it lists any unreadable manifest today. + Sets without the key are untouched. Residual, accepted. +- **Two sets on disk.** Flipping the switch produces a new key; the old set + stays. Flipping back is a cache hit (`find_matching_cut_workspace`, + `render.py:571-600`, called at `:1049`) with no re-segmentation. The disk + cost is one extra set per clip, visible in the workspace dialog like any + other. +- **The picker's Rebuild.** `request_for_workspace` + (`ui/workspace_presentation.py:142-183`) rebuilds a request from a manifest + and must reproduce the key (`render.py:1224-1231` refuses a mismatch). It + restores `SegmentationSpec.exclusions` from `inputs["model_exclusions"]` by + translating each box back through the manifest crop: + `CropSpec(crop.x + left, crop.y + top, right - left, bottom - top)`. A + clipped box is inside the crop, so `cut_exclusions` maps it back onto + itself and the key matches. + +### 7.3 What the blank is filled with — measured, not guessed + +A hard black rectangle is an edge, and a segmentation network can read an +edge as an object boundary. If it does, the feature is worse than not using +it: the bystander is gone and a rectangle-shaped artefact takes its place. +**The fill is not chosen in this document.** It is chosen by the measurement +below, and the identifier of the winner is what `MODEL_FILL_ID` carries into +the key. + +**What the model actually sees** (`rembg/sessions/base.py:40-65`): the +frame is converted to RGB (`:49` — alpha is dropped), resized to the model's +input size (1024² for BiRefNet and ISNet, 320² for U²-Net; `birefnet_general.py:34-36`, +`u2net.py:32`, `dis_general_use.py:27`), scaled by its own maximum (`:52`), +then normalised per channel by `(x - mean) / std`. Twelve of the thirteen V1 +models use the ImageNet constants `(0.485, 0.456, 0.406) / (0.229, 0.224, 0.225)`; +`isnet-general-use` uses `(0.5, 0.5, 0.5) / (1, 1, 1)`. So a flat fill at the +model's *mean* is the input the network's first layer treats as zero — that +is the one candidate with a model-independent argument, and why it is the +fallback. It is still a rectangle. + +**Candidates**, each a pure function `(image: PIL RGBA, box: PixelBounds) -> None` +in `scripts/measure_model_fill.py`, the winner promoted to +`core/exclusion.py::blank_model_input`: + +| Id | Fill | Structure it introduces | +|---|---|---| +| `black` | `(0, 0, 0)` | a strong edge; normalises to ≈ −2.1 per channel | +| `mid-grey` | `(128, 128, 128)` | an edge; ISNet's zero | +| `imagenet-mean` | `(124, 116, 104)` | an edge; the zero for 12 of 13 models | +| `ring-mean` | the mean colour of the 4 px ring around the box, inside the frame | a softer edge; adapts to the local background | +| `blur` | the box contents under `GaussianBlur(radius = max(w, h) / 4)` | no edge, but a skin-coloured blob where a face was | +| `mirror` | the adjacent in-frame strip reflected into the box | no edge; **re-introduces whatever was next to the box**, including the subject's own edge | + +**Measurement.** Needs a real model; runs by hand; recorded in this +document, not in the test suite. + +- *Input.* Pairs of frames `(control, test)` at the same framing: `control` + has the wanted subject alone; `test` is `control` with a bystander + composited at the frame edge (a cutout of a second person from another + clip, pasted at two positions: touching the frame edge, and 40 px inside + it). At least three subjects × two bystander positions × two models + (`birefnet-portrait`, `u2net_human_seg`) = 12 pairs. The #80 clip has real + bystander frames and no control; it is used for the inside-box metric and + a visual check only, never for the decision. +- *Procedure.* For each pair and candidate `C`: fill the bystander box in + `test`, segment, take the alpha `A_C`. Also `A_none` (unfilled `test`) and + `A_ctrl` (`control`). Inference is deterministic on CPU, so the noise floor + is the spread *across pairs*, not across runs. +- *Compared.* Outside the box: `err_C = mean |A_C − A_ctrl|` and the IoU of + `A > 2 %` (the default threshold, `specs.py:248`) against `A_ctrl`. In a 16 + px band around the box: the same error, reported separately — this is where + "the rectangle edge became an object" shows up. Inside the box: `mean A_C`, + diagnostic only, because 7.4 zeroes it anyway. +- *Rejects a candidate.* `err_C > err_none` or band error above `err_none` + on **any** pair: the fill did more harm than the bystander it replaced. +- *Decides.* Among the survivors, the lowest mean `err_C`; the winner must + beat the runner-up by more than 1 IoU point on the majority of pairs. +- *Inconclusive.* Winner within 1 IoU point of the runner-up on most pairs, + or fewer than two survivors: **fallback `imagenet-mean`**, on the argument + above (the network's zero for 12 of 13 models, zero structure of its own). + `mirror` is never the fallback: it is the only candidate whose structure + depends on what stands beside the box. + +Whatever wins, `blank_model_input` is Pillow only (`image.paste`, at most +`ImageFilter.GaussianBlur` — both already in the tree) and `MODEL_FILL_ID` +names it. A different winner later is a one-line change in +`core/exclusion.py` that invalidates exactly the pre-model sets (7.2). + +### 7.4 Pipeline call site — inside `_produce_cut_frame`, two lines apart + +`_produce_cut_frame` (`jobs/render.py:1529-1608`) is the only +decode → crop → segment → cleanup path (`render.py:13`), shared by preview +(`:923`) and render (`:1104`). Both calls therefore see the blank without a +change of their own. + +- **The regions map with the existing `cut_exclusions`.** `apply_source_crop` + (`core/geometry.py:718-724`) returns `image.crop(...)` — the frame in cut + space with the crop's top-left at (0, 0); pre-model regions are oriented + source rectangles like the post ones; `cut_exclusions(regions, request.crop)` + (`exclusion.py:40-52`) is exactly the translation-and-clip both kinds need. + Verified: no second mapping. +- **Fill on the Pillow image, not the array.** `np.asarray(cropped)` at + `:1564` hands back a **read-only** view (measured on this branch: + `flags.writeable == False`, and `ascontiguousarray` returns it unchanged), + so writing into `input_frame` would raise. `cropped` is a fresh image from + `.crop()` and `paste` works in place — the same call `exclude_alpha` makes + (`exclusion.py:55-58`). So: + + ```python + cropped = apply_source_crop(decoded_image, crop_bounds) # :1558 + tracker.register(cropped) # :1559 + model_boxes = cut_exclusions(request.segmentation.exclusions, request.crop) + blank_model_input(cropped, model_boxes) # new + ... + input_frame = np.ascontiguousarray(np.asarray(cropped, dtype=np.uint8)) # :1564 + ``` + + The fill sits **after the crop and before the array conversion**, i.e. + before the model at `:1574`. No extra allocation, no tracker change. +- **Zero the box in the result.** rembg composites the *input* RGB with the + mask (`jobs/rembg_runtime.py:159-165`; `rembg/bg.py:296-314`), so the + filler pixels come back with whatever alpha the model gave them. After + `tracker.register(result)` at `:1606`: + + ```python + exclude_alpha(result, model_boxes) # new + ``` + + In place on the returned image; `result` is the only owner. This is what + guarantees 7.1's "stored cut carries the blank" and keeps filler RGB out of + every consumer, the preview's `_immutable_rgba(cut)` included (`:968`). +- **Relative to `_decontaminate_edge_colors_in_place`** (`:1611-1631`, called + at `:1600` on the model output): the fill runs before the model, the + decontamination on its output, the zeroing after both. Order between the + last two is immaterial — decontamination writes canonical black under + alpha 0 (`:1620`) and `exclude_alpha` writes `(0,0,0,0)` — but zeroing on + `result` rather than on `segmented` avoids touching the read-only array the + host hands back (`tests/jobs/render_support.py:114-117` models that). +- **Cost.** Three lines in a frozen module (2886, baseline `scripts/guardrails-baseline.json`). + `_produce_cut_frame` is already over the 60-line function budget, so the + `long_functions` count does not move (`check_guardrails.py:130-133`); the + module line count does, and that fails the ratchet. **This is a baseline + question for the maintainer**; the alternative — a wrapper module that + re-implements the pipeline to avoid the three lines — is rejected below. +- **The segmentation host is untouched.** It accepts any `H×W×3/4` uint8 + frame (`jobs/segmentation_host.py:605-621`) and never sees the regions. +- **The post path is not slower.** Nothing on it changed; with the switch + off `model_boxes` is `()` and both new calls are loops over nothing. + +### 7.5 What the user sees — the cost is named where it is paid + +Two rounds on this branch shipped controls that looked live and were not. +Everything below either dispatches a reducer event or is derived from state +the reducer already changed; nothing holds a checked state of its own. + +- **Inspector.** `ExclusionControls` (`ui/exclusion_controls.py`) gains a + `QCheckBox`, object name `exclusion_before_model`, text + `translate("Inspector", "Blank before the model")`, tooltip and accessible + description `translate("Inspector", "Re-segments the clip: the stored cut set is not reused")`. + `apply()` sets it from `presentation.exclusions_before_model` with signals + blocked, and enables it as `available and count > 0`, exactly like + `clear_button` (`:37`): a switch with no regions is inert, so it is + disabled rather than checked-and-idle. Toggling emits + `ExclusionsBeforeModelChanged(checked)` through the existing + `command_requested` signal (`:25`, wired at `inspector.py:312`); no + `main_window.py` change. +- **Count label.** Two literals, chosen by the flag, both Qt numerus forms: + `tr("%n region(s)", "", n)` as today (`:31-32`) and + `tr("%n region(s), blanked before the model", "", n)`. The literal is at + the call site; the flag selects which call runs. +- **Canvas.** `_paint_exclusions` (`ui/exclusion_canvas.py:174-221`) keeps + its colours and, when `presentation.exclusions_before_model`, draws the + effective rectangle with a `Qt.BrushStyle.BDiagPattern` brush in the same + `#E5484D` over the translucent fill and a 2 px solid pen instead of 1 px. + Hatched = the model never sees it; plain = removed afterwards. Not + colour-only. `CropPresentation` gains `exclusions_before_model: bool = False` + (`ui/crop_presentation.py:21`, filled at `:64`). +- **Announcement.** `_announce_crop` (`exclusion_canvas.py:699-745`) appends + `translate("CropCanvas", "; blanked before the model")` when the flag is + set — the same append pattern the selected-region readout already uses + (`exclusion_controls.py:57-59`, `:69-71`). No variable reaches `translate`. +- **The cost is shown by the stale-preview banner, for free.** The reducer + invalidates with `SEGMENTATION` (7.1), which the presentation model already + words as "Segmentation" (`ui/presentation_model.py:14`) — the same banner + a model change produces, which is the honest comparison: the next Preview + runs the model, the next Render segments the clip. With the switch on, a + region drag also invalidates as `SEGMENTATION`, so the user sees at the + first nudge that regions are now a segmentation setting. +- **Nothing new in the job dialog.** A render with a new key is an ordinary + render; the progress stages already say "Cut frame n of m" + (`render.py:1129`). +- **New strings** (all literals, German entries required): + `"Blank before the model"`, `"Re-segments the clip: the stored cut set is not reused"`, + `"%n region(s), blanked before the model"`, `"; blanked before the model"`. +- **README.** The bullet at `README.md:29-30` ("made transparent after + segmentation") gains one sentence on the switch; `main-window.png` is + regenerated with `scripts/screenshots.py:127`'s region and the switch on, + so the hatch is visible. + +### 7.6 Degradation — the post path's empty-mask handling carries over + +- **A pre-model region covers the whole frame.** The model sees a flat + fill. BiRefNet then min-max-normalises a near-constant prediction + (`birefnet_general.py:41-44`), which can produce NaN and an arbitrary + mask; alpha matting raises on an empty trimap and rembg falls back to the + naive cutout (`rembg/bg.py:298-309`). None of that reaches the output: + 7.4 zeroes the box in the result, and a whole-frame box zeroes the whole + frame. Every cut frame is fully transparent → the union is empty → + Decision 5 applies unchanged: trim is skipped, the untrimmed canvas is + encoded, `notes` records it (`render.py:1378-1381`), the UI facts worker + degrades through `union_alpha_bounds_or_none`. **Carries over; nothing + new.** +- **A pre-model region covers the whole subject.** Same path; what the + model does with the filler's edge inside the box is zeroed, and what it + does *outside* is exactly the band metric in 7.3. +- **A pre-model region entirely outside the crop.** No box, no key change, + no re-segmentation — the 7.2 table. +- **Switch on, no regions.** Inert control (7.5), no invalidation (7.1). +- **Switch flipped while a job runs.** `ExclusionsBeforeModelChanged` is a + `ParameterEvent` and goes through the same `can_edit` gate as the others + (`parameters.py:191`); the controls are disabled. +- **A persisted `True` from a build that knew the switch, read by one that + does not.** Ignored — `load_parameters` reads only `_KEYS` + (`preferences.py:30-34`). Regions still apply post. Degraded, honest. +- **Nothing refuses.** No new `ValidationError` on a user-reachable path. + +### 7.7 File-by-file change list + +Estimates; **bold** = frozen in `scripts/guardrails-baseline.json` and over +800 lines, so growth fails the ratchet. + +| File | Now | Δ | Notes | +|---|---|---|---| +| `src/matteloop/core/exclusion.py` | 97 | +22 | `MODEL_FILL_ID`, `blank_model_input(image, boxes)`, docstring: the model-input site | +| `src/matteloop/core/specs.py` | 706 | +9 | `SegmentationSpec.exclusions` + the validation block copied from `FramingSpec` | +| `src/matteloop/core/fingerprints.py` | 484 | +14 | `_model_exclusions(request)`; spread into `cut_cache_key_inputs` and `preview_fingerprint`'s `segmentation` | +| `src/matteloop/core/parameters.py` | 638 | +34 | field, `ExclusionsBeforeModelChanged`, `_reduce_exclusions_before_model`, reason selection in `_reduce_exclusions`, reset, `parameters_from_values` | +| `src/matteloop/jobs/workspace/_manifest_validation.py` | 344 | +16 | optional `model_exclusions` in `_validate_cache_inputs` + `_validate_model_exclusions`. Under 800: not a baseline question | +| **`src/matteloop/jobs/render.py`** | 2886 | **+3** | `_produce_cut_frame`: `model_boxes`, `blank_model_input`, `exclude_alpha(result, …)`. **Flag: needs `--update` with agreement.** | +| `src/matteloop/ui/request_builder.py` | 112 | +1 | `exclusions=` on `SegmentationSpec` | +| `src/matteloop/ui/workspace_presentation.py` | 214 | +8 | restore `exclusions` from `model_exclusions` in `request_for_workspace` | +| `src/matteloop/ui/preferences.py` | 91 | +2 | key + persist | +| `src/matteloop/ui/parameter_presentation.py` | 85 | +2 | field + mapping | +| `src/matteloop/ui/crop_presentation.py` | 63 | +2 | field + mapping | +| `src/matteloop/ui/inspector_reset.py` | — | +1 | compare the flag | +| `src/matteloop/ui/exclusion_controls.py` | ~95 (in flux) | +18 | checkbox, `apply`, `tab_widgets`, count-label variant | +| `src/matteloop/ui/exclusion_canvas.py` | 745 | +12 | hatch in `_paint_exclusions`, suffix in `_announce_crop` → **~757 of 800. Tight; nothing else may land here without a split** | +| **`src/matteloop/ui/inspector.py`** | 904 | 0 | the checkbox lives inside `ExclusionControls`; `tab_widgets()` already spreads (`:834`, `:855`) | +| `src/matteloop/ui/main_window.py` | 357 | 0 | `command_requested` already routed | +| `resources/matteloop_{en,de}.ts`, `.qm` | — | regen | four new strings, German by hand | +| `scripts/measure_model_fill.py` | new | +90 | the 7.3 harness: six candidates, the pair loop, the table. Run by hand, not a test | +| `scripts/screenshots.py` | — | +1 | switch on in `_state` | +| `README.md`, `assets/screenshots/main-window.png` | — | +1, regen | | +| `docs/v1-scope.md` | — | +3 | extend the exclusion-regions row: pre-model option, keyed in the cut. **First** (G8) | +| `scripts/guardrails-baseline.json` | — | 1 entry | `jobs/render.py`, only after agreement | +| `tests/jobs/render_support.py` | — | +2 | `FakeSegmenter` keeps `frames.append(frame.copy())` so a test can see what the model saw (`:119-128` records only requests today) | + +**One baseline question for the maintainer:** `jobs/render.py` +3. Everything +else is under budget. Nothing touches `core/state.py`, `core/geometry.py`, +`jobs/segmentation_host.py` or `jobs/transform_stage.py`. + +### 7.8 Test list + +One test per behaviour, named after it (G7). "Fails without" names the +missing piece. **unit** = cheap and Qt-free; **Qt** = offscreen widgets; +**model** = a real rembg session, run by hand. + +| Test | Fails without | Kind | +|---|---|---| +| `tests/core/test_specs.py::test_segmentation_spec_rejects_exclusions_that_are_not_crop_specs` | the validation block | unit | +| `tests/core/test_exclusion.py::test_blank_model_input_fills_each_box_and_nothing_else` — every RGB inside is `MODEL_FILL_ID`'s value, alpha untouched, outside byte-identical | `blank_model_input` | unit | +| `…::test_blank_model_input_with_no_boxes_leaves_the_image_byte_identical` | the empty loop (post-path cost) | unit | +| `tests/core/test_fingerprints.py::test_cut_key_without_model_exclusions_matches_the_canonical_schema` — extends `:610-646`: switch semantics with `segmentation.exclusions=()` produce the pinned JSON, and `"model_exclusions"` is absent from `cut_cache_key_inputs` | the non-empty rule; failing it orphans every 0.4.1 cut set | unit | +| `…::test_cut_key_ignores_a_model_exclusion_outside_the_crop_or_clipped_to_nothing` | the `cut_exclusions` guard feeding the key | unit | +| `…::test_cut_key_tracks_model_exclusion_boxes_and_the_fill_identifier` — two regions, two keys; monkeypatched `MODEL_FILL_ID` changes the key | `_model_exclusions` | unit | +| `…::test_cut_key_inputs_with_model_exclusions_are_recursively_immutable` | tuples, not lists, in the payload | unit | +| `…::test_preview_identity_tracks_model_exclusions` | the `segmentation` spread | unit | +| `…::test_render_and_union_identities_ignore_model_exclusions` — they depend on `cut_key` only | that nothing was added to `_framing` / `cut_union_fingerprint` | unit | +| `tests/jobs/test_workspace.py::test_manifest_accepts_model_exclusions_and_reproduces_the_cut_key` — `CutManifest.create` with the new inputs, JSON round trip, `cache_key_for` equals `cut_cache_key` | the validator's optional key and the list/tuple round trip | unit | +| `…::test_manifest_rejects_malformed_model_exclusion_boxes` — inverted box, negative, non-int | `_validate_model_exclusions` | unit | +| `…::test_manifest_without_model_exclusions_still_validates` — a 0.4.1 payload verbatim | that the key stayed optional | unit | +| `tests/core/test_parameters.py::test_exclusions_before_model_invalidates_the_preview_as_segmentation` | the reducer | unit | +| `…::test_exclusions_before_model_with_no_effective_region_changes_state_without_invalidating` | the empty-box no-op | unit | +| `…::test_region_change_invalidates_as_segmentation_while_the_switch_is_on` | reason selection in `_reduce_exclusions` | unit | +| `…::test_parameters_reset_clears_exclusions_before_model` | reset | unit | +| `…::test_exclusions_before_model_settings_value_round_trips_and_a_malformed_value_falls_back_to_false` | parse | unit | +| `tests/jobs/test_render.py::test_render_blanks_model_exclusions_in_the_model_input_and_zeroes_them_in_the_stored_cut` — `FakeSegmenter.frames[i]` carries the fill inside the box and the original outside; the stored PNG is `(0,0,0,0)` there | the two `_produce_cut_frame` lines; masking only after the model passes the second assertion and fails the first | unit | +| `…::test_render_with_model_exclusions_reads_the_original_pixels_outside_the_box` | that the fill did not leak (e.g. a ring or blur candidate overrunning the box) | unit | +| `…::test_render_with_the_switch_off_sends_the_model_the_unblanked_frame` | the post path's cost contract | unit | +| `…::test_render_reuses_the_unblanked_cut_set_after_the_switch_is_turned_off` — render, flip, render, flip, render: the third finds the first set | 7.2's two-sets claim | unit | +| `tests/jobs/test_render.py::test_render_with_a_whole_frame_model_exclusion_encodes_the_untrimmed_canvas_and_notes_it` | Decision 5 carrying over; a NaN mask from a flat input must not surface | unit | +| `tests/jobs/test_preview.py::test_preview_shows_no_filler_pixels_inside_a_model_exclusion` — `PreviewResult.cut` is `(0,0,0,0)` in the box | `exclude_alpha(result, …)` | unit | +| `tests/jobs/test_rebuild.py::test_rebuild_of_a_model_exclusion_set_reproduces_its_key_from_the_manifest` — through `request_for_workspace` | the reverse mapping in `workspace_presentation.py` | unit | +| `tests/ui/test_parameter_inspector.py::test_before_model_checkbox_dispatches_and_is_inert_without_regions` — dispatch count 1 per toggle; disabled at count 0; reflects state, never holds it | the checkbox wiring; a stayed-checked control scores 0 dispatches | Qt | +| `…::test_before_model_count_label_names_the_blank` | the second literal | Qt | +| `tests/ui/test_crop_canvas.py::test_model_exclusions_are_painted_hatched_and_announced` — sample a pixel of the pattern; accessible description ends with the suffix | canvas + announcement | Qt | +| `tests/ui/test_parameter_persistence.py::test_exclusions_before_model_persists_as_a_bool` | preferences | Qt | +| `tests/ui/test_parameter_requests.py` (+2 assertions) — switch on fills `segmentation.exclusions`, off leaves `()`, `framing.exclusions` both times | request builder | Qt | +| `tests/test_translations.py::test_catalogues_match_lupdate_extraction` (existing) | German entries | Qt | +| `scripts/measure_model_fill.py` on the 12 pairs of 7.3, table pasted into this document under 7.3 | the fill decision — **must run before `MODEL_FILL_ID` is set** | model | +| A real render of the #80 clip with the switch on and off, compared by eye | the reason this exists | model | + +### 7.9 Implementation order + +0. `docs/v1-scope.md` row (G8), and the one baseline question answered. +1. **The measurement first**, because its result is a constant every later + step reads: `scripts/measure_model_fill.py`, the pairs, the table into + 7.3, `MODEL_FILL_ID` decided. If it is inconclusive, `imagenet-mean`, and + the table still goes into the document. +2. `core/exclusion.py`, `specs.py`, `fingerprints.py`, + `workspace/_manifest_validation.py` + their tests. +3. `render.py`'s three lines, `render_support.py`, the jobs tests. **Measure + the delta; stop for the maintainer if the baseline is not yet agreed.** +4. `parameters.py`, `preferences.py`, `request_builder.py`, + `workspace_presentation.py`, the presentations + tests. +5. `exclusion_controls.py`, `exclusion_canvas.py`, catalogues + Qt tests. + **Check `exclusion_canvas.py` against 800 here.** +6. Screenshot, README. + +Each step verified with the standard command from `CLAUDE.md`. + + ## Not in scope - Numeric x/y/w/h fields per region, region naming, a region list widget. @@ -778,6 +1287,11 @@ description; regeneration per `README.md:150-159`. - Touch hit-testing beyond what `InteractionGeometry.hit_test(touch=…)` already gives the selected region. - Anything in `core/geometry.py`, `core/state.py`. +- A per-region pre/post flag (Decision 7.1 chooses one global switch). +- Choosing the model-input fill by argument; it is chosen by the + measurement in Decision 7.3. +- Retaining an unblanked cut set's frames for a pre-model set, or any + migration between the two (they are two keys, both kept on disk). ## Failure modes considered @@ -804,12 +1318,17 @@ description; regeneration per `README.md:150-159`. - **External edit of a stored frame** — the union cache is already dropped (`_cut_ops.py:380`); exclusions are applied on read, so edited pixels inside a box are zeroed like any other. +- **Pre-model regions** — whole frame, whole subject, outside the crop, + switch without regions, an old binary reading a new manifest: Decision 7.6. - **`render.py` growth** — see the change list. The first draft's "≈0" was a guess; this revision budgets +5…+15 and makes measuring it a gate in the implementation order, not a hope. ## File-by-file change list +**Landed** with Decisions 1–6; kept as the record of that work. The +pre-model addition has its own list in Decision 7.7. + Line deltas are estimates; **bold** = frozen in the baseline. **Prerequisite, lands separately** (Decision 2a — its own issue, branch and @@ -855,6 +1374,8 @@ if it measures positive after the collapse. ## Test plan +**Landed** with Decisions 1–6; Decision 7.8 lists the pre-model tests. + Named after behaviour (G7). "Fails without" names the missing piece. **Cheap, Qt-free** @@ -919,6 +1440,9 @@ Screenshot regeneration and a real render on the #80 clip are manual. ## Implementation order +**Landed** for Decisions 1–6; Decision 7.9 gives the order for the +pre-model addition. + **0. `docs/v1-scope.md` first.** G8 (`docs/engineering-guardrails.md:244`) makes that file authoritative and forbids implementing an out-of-scope design requirement, so the scope entry is step zero, not a tidy-up at the end. Nothing @@ -956,8 +1480,10 @@ Each step is verified with the standard command from `CLAUDE.md`. - **Regions in cut space.** Moving the crop would drag the overlay mask with it; the overlay is fixed in the source frame. -- **A pre-segmentation mask.** Settled by the maintainer: re-segments on every - drag (crop is in the cut key) and is model-dependent. +- **A pre-segmentation mask *instead of* the post mask.** Re-segments on + every drag (crop is in the cut key) and is model-dependent. The post path + stays the default; the pre-model path is an *addition* (Decision 7), not a + replacement. - **Zeroing inside `read_cut` / `FrameReader.read`.** Would corrupt the identity consumers (hash scans, external-edit detection, CAS) that share the readers and must see the stored bytes. @@ -1020,3 +1546,44 @@ Each step is verified with the standard command from `CLAUDE.md`. the render must not abort for it. Recorded as the fork; degrade chosen. - **A region count cap.** Nothing measured needs one; clipping bounds the cost per region to one `paste`. +- **A per-region pre/post flag** (Decision 7.1). Either a second tuple + (`ParameterState.model_exclusions`) plumbed through every presentation, + the preferences, the reducer and a two-tuple selection identity in the + 745-line canvas, or an `ExclusionRegion(CropSpec)` subclass carrying + `before_model` that every drag helper would have to re-wrap because + `crop_from_drag`/`nudge_crop` construct plain `CropSpec`s. Both are larger + than the switch, the mixed-clip case is unmeasured, and the request-level + shape is identical, so the switch can grow into either later. +- **Pre-model boxes in cut space on `SegmentationSpec`.** Would save the + reverse mapping in `request_for_workspace`, but puts a crop-dependent + rectangle type on a spec that is otherwise crop-independent, and the + regions the user draws are source rectangles; `cut_exclusions` already + does the one mapping for both kinds. +- **Requiring `segmentation.exclusions ⊆ framing.exclusions` in + `RenderRequest.validate`.** Unnecessary once `_produce_cut_frame` zeroes + the pre-model boxes in its result (7.4): the stored set is correct under + any framing, and the picker's Rebuild needs no union of the two tuples. +- **Keeping the filler RGB in the cut and relying on the post mask.** The + picker can rebuild a pre-model set with a different post layout, and the + filler would then show through with whatever alpha the model gave it. + Zeroing costs one `exclude_alpha` in the producer. +- **The fill identifier in `PIPELINE_SCHEMA_VERSION`.** Invalidates every + cut set of every user for a change that touches only pre-model sets. +- **Always emitting `"model_exclusions"` in the cut key.** Same rejection as + the framing case: it invalidates every 0.4.1 cut set on update. +- **Filling the numpy array instead of the Pillow image.** `np.asarray` of a + Pillow image is read-only (measured); a writable copy is one crop-sized + allocation per frame and an ownership-tracker entry, for nothing. +- **A wrapper module around `_produce_cut_frame` to keep `render.py` at + 2886.** The pipeline is one function on purpose (`render.py:13`); a second + copy of decode → crop → segment for three lines is the spiral the + guardrails describe. +- **Declaring a fill without measuring.** A hard rectangle may read as an + object edge to the model; if it does, the feature is worse than not + using it. The measurement in 7.3 decides, and `imagenet-mean` is the + fallback only because it is the network's own zero for 12 of 13 models. +- **`mirror` as the fallback fill.** Its structure depends on what stands + beside the box; a mirrored bystander is a bystander. +- **Reducing the switch as `CROP_CLEANUP`.** The banner would say "Crop & + cleanup" for a change that reruns the model; `SEGMENTATION` is the reason + a model change already uses and is the honest cost signal. From 7c4d09eece998d1c05113743e95666e2d57eb3d6 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 16:28:46 +0200 Subject: [PATCH 19/21] =?UTF-8?q?=E2=9C=A8=20feat(cuts):=20key=20pre-model?= =?UTF-8?q?=20regions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ Features: - `blank_model_input` fills model boxes with `imagenet-mean` `(124, 116, 104)` while preserving alpha; `_produce_cut_frame` blanks before segmentation and zeroes the result afterward. - `_model_exclusions` emits immutable cut-key `boxes` only for effective non-empty regions, preserving the canonical no-region key; `_validate_cache_inputs` accepts exactly the optional manifest schema. - `ExclusionsBeforeModelChanged` selects segmentation invalidation, while effective empty regions remain inert; `request_for_workspace` reverses manifest cut boxes into source-space `CropSpec` values. - 🧪 Tests: - `test_segmentation_spec_rejects_exclusions_that_are_not_crop_specs` pins segmentation validation; `test_blank_model_input_fills_each_box_and_nothing_else` and `test_blank_model_input_with_no_boxes_leaves_the_image_byte_identical` pin fill scope and empty-path identity. - `test_cut_key_without_model_exclusions_matches_the_canonical_schema`, `test_cut_key_ignores_a_model_exclusion_outside_the_crop_or_clipped_to_nothing`, `test_cut_key_tracks_model_exclusion_boxes_and_the_fill_identifier`, `test_cut_key_inputs_with_model_exclusions_are_recursively_immutable`, `test_preview_identity_tracks_model_exclusions`, and `test_render_and_union_identities_ignore_model_exclusions` pin fingerprint identity and immutability. - `test_manifest_accepts_model_exclusions_and_reproduces_the_cut_key`, `test_manifest_rejects_malformed_model_exclusion_boxes`, and `test_manifest_without_model_exclusions_still_validates` pin manifest compatibility. - `test_exclusions_before_model_invalidates_the_preview_as_segmentation`, `test_exclusions_before_model_with_no_effective_region_does_not_invalidate`, `test_region_change_invalidates_as_segmentation_while_the_switch_is_on`, `test_parameters_reset_clears_exclusions_before_model`, and `test_exclusions_before_model_settings_round_trip_and_malformed_value_fall_back` pin reducer behavior. - `test_render_blanks_model_exclusions_and_zeroes_stored_cut`, `test_render_with_model_exclusions_reads_the_original_pixels_outside_the_box`, `test_render_with_the_switch_off_sends_the_model_the_unblanked_frame`, `test_render_reuses_the_unblanked_cut_set_after_the_switch_is_turned_off`, `test_render_with_whole_frame_model_exclusion_notes_untrimmed_canvas`, `test_preview_shows_no_filler_pixels_inside_a_model_exclusion`, and `test_rebuild_of_a_model_exclusion_set_reproduces_its_key_from_the_manifest` pin the shared pipeline and cache reuse. Refs #80 --- docs/v1-scope.md | 2 +- src/matteloop/core/exclusion.py | 21 +++ src/matteloop/core/fingerprints.py | 18 ++- src/matteloop/core/parameters.py | 41 ++++- src/matteloop/core/specs.py | 9 ++ src/matteloop/jobs/render.py | 5 +- .../jobs/workspace/_manifest_validation.py | 68 +++++++-- src/matteloop/ui/workspace_presentation.py | 20 +++ tests/core/test_exclusion.py | 34 +++++ tests/core/test_fingerprints.py | 142 +++++++++++++++++- tests/core/test_parameters.py | 78 ++++++++++ tests/core/test_specs.py | 17 +++ tests/jobs/render_support.py | 2 + tests/jobs/test_preview.py | 23 +++ tests/jobs/test_rebuild.py | 40 +++++ tests/jobs/test_render.py | 97 ++++++++++++ tests/jobs/test_workspace.py | 58 +++++++ 17 files changed, 660 insertions(+), 15 deletions(-) diff --git a/docs/v1-scope.md b/docs/v1-scope.md index d15f3d1..9b92ff4 100644 --- a/docs/v1-scope.md +++ b/docs/v1-scope.md @@ -51,7 +51,7 @@ Nothing else gates V1. When that sentence is true end to end, V1 is done. | Output | Lossless animated WebP, plus the still-image single-frame case. | | Timeline | Filmstrip, playhead, IN/OUT range handles, exact time/frame readout. | | Crop | Visual rectangle with handles, plus numeric fields. | -| Exclusion regions | Several user-drawn rectangles over the source frame, forced to alpha 0 after segmentation so a burned-in overlay does not survive into the cutout. **Scope reopened 2026-09-12 (issue #80):** no setting addressed a composited chat box, alert box or a bystander at the frame edge — `Crop` removes the subject with the overlay, and a largest-component filter was measured to fail in both directions. | +| Exclusion regions | Several user-drawn rectangles over the source frame, forced to alpha 0 after segmentation so a burned-in overlay does not survive into the cutout. **Scope reopened 2026-09-12 (issue #80):** an optional global switch also blanks those regions before the model; effective boxes are part of the cut key, so changing them re-segments while post-only edits keep the stored cut set. | | Preview | `Preview Frame` through the exact render pipeline, with the stale-result contract. | | Jobs | Exclusive modal job dialog with truthful stage/progress and working cancellation. | | Accessibility | Full keyboard reachability, correct tab order, accessible names and values on **standard** widgets, no colour-only status. | diff --git a/src/matteloop/core/exclusion.py b/src/matteloop/core/exclusion.py index 7d2212b..749ddc5 100644 --- a/src/matteloop/core/exclusion.py +++ b/src/matteloop/core/exclusion.py @@ -36,6 +36,9 @@ from matteloop.core.geometry import PixelBounds, alpha_bounds from matteloop.core.specs import CropSpec +MODEL_FILL_ID = "imagenet-mean" +MODEL_FILL_RGB = (124, 116, 104) + def cut_exclusions( exclusions: tuple[CropSpec, ...], crop: CropSpec @@ -52,6 +55,24 @@ def cut_exclusions( return tuple(PixelBounds(*box) for box in sorted(boxes)) +def blank_model_input( + image: Image.Image, boxes: tuple[PixelBounds, ...] +) -> None: + """Fill model-excluded RGB pixels while preserving their alpha channel.""" + if not boxes: + return + alpha = image.getchannel("A") + try: + for box in boxes: + image.paste( + MODEL_FILL_RGB, + (box.left, box.top, box.right, box.bottom), + ) + image.putalpha(alpha) + finally: + alpha.close() + + def exclude_alpha(image: Image.Image, boxes: tuple[PixelBounds, ...]) -> None: """Zero RGBA inside each box, in place.""" for box in boxes: diff --git a/src/matteloop/core/fingerprints.py b/src/matteloop/core/fingerprints.py index c739f68..33f6c78 100644 --- a/src/matteloop/core/fingerprints.py +++ b/src/matteloop/core/fingerprints.py @@ -14,7 +14,7 @@ from typing import BinaryIO, Protocol, cast from matteloop.core.errors import AppError, ErrorCode, ValidationError -from matteloop.core.exclusion import cut_exclusions +from matteloop.core.exclusion import MODEL_FILL_ID, cut_exclusions from matteloop.core.specs import ( CropSpec, FramingSpec, @@ -155,6 +155,7 @@ def preview_fingerprint( "model_id": request.segmentation.model_id, "model_weight_sha256": model_weight_sha256, **_edge_settings(request), + **_model_exclusions(request), }, "framing": _framing(request), "pipeline_schema_version": pipeline_schema_version, @@ -218,6 +219,7 @@ def cut_cache_key_inputs( "pipeline_schema_version": pipeline_schema_version, "orientation_color_version": orientation_color_version, "edge_settings": _edge_settings(request), + **_model_exclusions(request), } ) @@ -287,6 +289,20 @@ def _framing(request: RenderRequest) -> dict[str, object]: return payload +def _model_exclusions(request: RenderRequest) -> dict[str, object]: + boxes = cut_exclusions(request.segmentation.exclusions, request.crop) + if not boxes: + return {} + return { + "model_exclusions": { + "fill": MODEL_FILL_ID, + "boxes": tuple( + (box.left, box.top, box.right, box.bottom) for box in boxes + ), + } + } + + def _update_digest( source_file: BinaryIO, digest: _Digest, diff --git a/src/matteloop/core/parameters.py b/src/matteloop/core/parameters.py index d4db4bf..dd225c5 100644 --- a/src/matteloop/core/parameters.py +++ b/src/matteloop/core/parameters.py @@ -59,6 +59,7 @@ class ParameterState: padding: int = 0 stretch_x: Decimal = Decimal("1.0") exclusions: tuple[CropSpec, ...] = () + exclusions_before_model: bool = False output_directory: Path | None = None output_filename: str | None = None max_mib: Decimal = Decimal("0") @@ -138,6 +139,11 @@ class ExclusionsChanged: exclusions: tuple[CropSpec, ...] +@dataclass(frozen=True, slots=True) +class ExclusionsBeforeModelChanged: + enabled: bool + + @dataclass(frozen=True, slots=True) class OutputDirectoryChanged: directory: Path | None @@ -173,6 +179,7 @@ class TransformChanged: | PaddingChanged | StretchChanged | ExclusionsChanged + | ExclusionsBeforeModelChanged | OutputDirectoryChanged | OutputFilenameChanged | OutputMaxSizeChanged @@ -210,6 +217,8 @@ def reduce_parameters(state: AppState, event: ParameterEvent) -> AppState: return _reduce_cleanup_value(state, event) if isinstance(event, ExclusionsChanged): return _reduce_exclusions(state, event) + if isinstance(event, ExclusionsBeforeModelChanged): + return _reduce_exclusions_before_model(state, event) if isinstance(event, OutputDirectoryChanged): return _reduce_output_directory(state, event) if isinstance(event, OutputFilenameChanged): @@ -235,6 +244,7 @@ def _reduce_parameters_reset(state: AppState) -> AppState: padding=defaults.padding, stretch_x=defaults.stretch_x, exclusions=defaults.exclusions, + exclusions_before_model=defaults.exclusions_before_model, max_mib=defaults.max_mib, ) timeline = state.timeline @@ -255,6 +265,8 @@ def _reduce_parameters_reset(state: AppState) -> AppState: if ( parameters.model_id != state.parameters.model_id or parameters.edge_mode != state.parameters.edge_mode + or parameters.exclusions_before_model + != state.parameters.exclusions_before_model ): reason = PreviewInvalidationReason.SEGMENTATION elif parameters.fps != state.parameters.fps or ( @@ -398,10 +410,34 @@ def _reduce_exclusions(state: AppState, event: ExclusionsChanged) -> AppState: return _invalidate( state, updated, - PreviewInvalidationReason.CROP_CLEANUP, + ( + PreviewInvalidationReason.SEGMENTATION + if state.parameters.exclusions_before_model + else PreviewInvalidationReason.CROP_CLEANUP + ), ) +def _reduce_exclusions_before_model( + state: AppState, event: ExclusionsBeforeModelChanged +) -> AppState: + from matteloop.core.tokens import PreviewInvalidationReason + + if ( + type(event.enabled) is not bool + or event.enabled == state.parameters.exclusions_before_model + ): + return state + updated = replace( + state.parameters, exclusions_before_model=event.enabled + ) + if state.crop is None or not cut_exclusions( + state.parameters.exclusions, state.crop + ): + return replace(state, parameters=updated) + return _invalidate(state, updated, PreviewInvalidationReason.SEGMENTATION) + + def _reduce_output_directory( state: AppState, event: OutputDirectoryChanged ) -> AppState: @@ -488,6 +524,9 @@ def parameters_from_values(values: Mapping[str, object]) -> ParameterState: values.get("stretch_x"), defaults.stretch_x, lambda value: value > 0 ), exclusions=_exclusions_value(values.get("exclusions"), defaults.exclusions), + exclusions_before_model=_bool_value( + values.get("exclusions_before_model"), defaults.exclusions_before_model + ), max_mib=_decimal_value( values.get("max_mib"), defaults.max_mib, lambda value: value >= 0 ), diff --git a/src/matteloop/core/specs.py b/src/matteloop/core/specs.py index 18c7c3c..616d8ee 100644 --- a/src/matteloop/core/specs.py +++ b/src/matteloop/core/specs.py @@ -209,6 +209,7 @@ class SegmentationSpec: edge_mode: EdgeMode = EdgeMode.STANDARD alpha_matting: AlphaMattingSpec = field(default_factory=AlphaMattingSpec) execution_provider: str = CPU_EXECUTION_PROVIDER + exclusions: tuple[CropSpec, ...] = () def __post_init__(self) -> None: self.validate() @@ -238,6 +239,14 @@ def validate(self) -> None: "segmentation", "alpha_matting must be an AlphaMattingSpec", ) + if not isinstance(self.exclusions, tuple) or any( + not isinstance(exclusion, CropSpec) for exclusion in self.exclusions + ): + raise ValidationError( + ErrorCode.INVALID_SEGMENTATION, + "segmentation", + "exclusions must be a tuple of CropSpec values", + ) @dataclass(frozen=True) diff --git a/src/matteloop/jobs/render.py b/src/matteloop/jobs/render.py index 6b96005..c00bc77 100644 --- a/src/matteloop/jobs/render.py +++ b/src/matteloop/jobs/render.py @@ -7,7 +7,6 @@ | | v v durable promote framing -> encode - rebuild: durable cuts -----------------> private snapshot -> framing -> encode ``_produce_cut_frame`` is the only decode/crop/segment/edge-cleanup path. The @@ -37,6 +36,7 @@ from matteloop.core.errors import AppError, ErrorCode, ValidationError from matteloop.core.exclusion import ( + blank_model_input, cut_exclusions, exclude_alpha, union_alpha_bounds_or_none, @@ -1561,6 +1561,8 @@ def _produce_cut_frame( decoded_image.close() del decoded, decoded_image try: + model_boxes = cut_exclusions(request.segmentation.exclusions, request.crop) + blank_model_input(cropped, model_boxes) input_frame = np.ascontiguousarray(np.asarray(cropped, dtype=np.uint8)) tracker.register(input_frame) options = _segment_options(request) @@ -1604,6 +1606,7 @@ def _produce_cut_frame( segmented.tobytes(order="C"), ) tracker.register(result) + exclude_alpha(result, model_boxes) del segmented return result, actual_pts diff --git a/src/matteloop/jobs/workspace/_manifest_validation.py b/src/matteloop/jobs/workspace/_manifest_validation.py index 2c51381..000e5f8 100644 --- a/src/matteloop/jobs/workspace/_manifest_validation.py +++ b/src/matteloop/jobs/workspace/_manifest_validation.py @@ -74,18 +74,21 @@ def _frame_from_payload(value: object) -> CutFrame: def _validate_cache_inputs(inputs: FrozenJsonMap) -> None: + expected_keys = { + "crop", + "edge_settings", + "model", + "orientation_color_version", + "pipeline_schema_version", + "rembg_version", + "sampling", + "source_sha256", + } + if "model_exclusions" in inputs: + expected_keys.add("model_exclusions") _exact_keys( inputs, - { - "crop", - "edge_settings", - "model", - "orientation_color_version", - "pipeline_schema_version", - "rembg_version", - "sampling", - "source_sha256", - }, + expected_keys, "cache_key_inputs", ) _validate_sha256(_string(inputs["source_sha256"], "source sha256"), "source sha256") @@ -151,6 +154,51 @@ def _validate_cache_inputs(inputs: FrozenJsonMap) -> None: minimum=0, maximum=_MAX_INT64, ) + if "model_exclusions" in inputs: + _validate_model_exclusions(inputs["model_exclusions"]) + + +def _validate_model_exclusions(value: FrozenJsonValue) -> None: + exclusions = _frozen_object(value, "model exclusions") + _exact_keys(exclusions, {"boxes", "fill"}, "model exclusions") + _bounded_text( + _string(exclusions["fill"], "model exclusion fill"), + "model exclusion fill", + ) + boxes = exclusions["boxes"] + if type(boxes) is not tuple: + raise _manifest_error("model exclusion boxes must be an array") + for box in boxes: + if type(box) is not tuple or len(box) != 4: + raise _manifest_error("model exclusion boxes must contain four integers") + left = _bounded_int( + _int(box[0], "model exclusion left"), + "model exclusion left", + minimum=0, + maximum=MAX_CUT_DIMENSION, + ) + top = _bounded_int( + _int(box[1], "model exclusion top"), + "model exclusion top", + minimum=0, + maximum=MAX_CUT_DIMENSION, + ) + right = _bounded_int( + _int(box[2], "model exclusion right"), + "model exclusion right", + minimum=0, + maximum=MAX_CUT_DIMENSION, + ) + bottom = _bounded_int( + _int(box[3], "model exclusion bottom"), + "model exclusion bottom", + minimum=0, + maximum=MAX_CUT_DIMENSION, + ) + if right <= left or bottom <= top: + raise _manifest_error( + "model exclusion boxes must be positive rectangles" + ) def _fraction_payload(value: FrozenJsonValue, field: str) -> float: diff --git a/src/matteloop/ui/workspace_presentation.py b/src/matteloop/ui/workspace_presentation.py index 5f4bddd..410016c 100644 --- a/src/matteloop/ui/workspace_presentation.py +++ b/src/matteloop/ui/workspace_presentation.py @@ -147,6 +147,25 @@ def request_for_workspace(manifest: CutManifest, base: RenderRequest) -> RenderR model = _mapping(inputs["model"]) edge_settings = _mapping(inputs["edge_settings"]) matting = _mapping(edge_settings["alpha_matting"]) + model_exclusions = inputs.get("model_exclusions") + segmentation_exclusions: tuple[CropSpec, ...] = () + if model_exclusions is not None: + model_box_values = _mapping(model_exclusions) + raw_boxes = model_box_values["boxes"] + if not isinstance(raw_boxes, (list, tuple)): + raise ValueError("manifest model exclusions are not an array") + crop_x = _integer(crop["x"]) + crop_y = _integer(crop["y"]) + segmentation_exclusions = tuple( + CropSpec( + crop_x + _integer(box[0]), + crop_y + _integer(box[1]), + _integer(box[2]) - _integer(box[0]), + _integer(box[3]) - _integer(box[1]), + ) + for box in raw_boxes + if isinstance(box, (list, tuple)) and len(box) == 4 + ) mode = { "standard": EdgeMode.STANDARD, "decontaminate": EdgeMode.DECONTAMINATE_COLORS, @@ -173,6 +192,7 @@ def request_for_workspace(manifest: CutManifest, base: RenderRequest) -> RenderR _integer(matting["erode_size"]), ), base.segmentation.execution_provider, + exclusions=segmentation_exclusions, ), framing=base.framing, output=base.output, diff --git a/tests/core/test_exclusion.py b/tests/core/test_exclusion.py index 7fa078a..73b0176 100644 --- a/tests/core/test_exclusion.py +++ b/tests/core/test_exclusion.py @@ -42,6 +42,40 @@ def test_cut_exclusions_is_order_independent_and_deduplicated() -> None: ) +def test_blank_model_input_fills_each_box_and_nothing_else() -> None: + from matteloop.core.exclusion import blank_model_input + + image = Image.new("RGBA", (8, 6)) + image.putdata( + tuple((x, y, x + y, 20 + x * 8 + y) for y in range(6) for x in range(8)) + ) + original = image.copy() + boxes = (PixelBounds(1, 1, 3, 3), PixelBounds(5, 0, 7, 2)) + + blank_model_input(image, boxes) + + for y in range(6): + for x in range(8): + inside = (1 <= x < 3 and 1 <= y < 3) or (5 <= x < 7 and y < 2) + expected = ( + (124, 116, 104, original.getpixel((x, y))[3]) + if inside + else original.getpixel((x, y)) + ) + assert image.getpixel((x, y)) == expected + + +def test_blank_model_input_with_no_boxes_leaves_the_image_byte_identical() -> None: + from matteloop.core.exclusion import blank_model_input + + image = Image.new("RGBA", (4, 3), (10, 20, 30, 40)) + before = image.tobytes() + + blank_model_input(image, ()) + + assert image.tobytes() == before + + def test_exclude_alpha_zeroes_rgba_inside_each_box_and_nothing_else() -> None: image = Image.new("RGBA", (6, 6), (10, 20, 30, 255)) boxes = (PixelBounds(1, 1, 3, 3), PixelBounds(4, 0, 6, 2)) diff --git a/tests/core/test_fingerprints.py b/tests/core/test_fingerprints.py index f8a11c6..b348781 100644 --- a/tests/core/test_fingerprints.py +++ b/tests/core/test_fingerprints.py @@ -4,6 +4,7 @@ import json import os import threading +from collections.abc import Mapping from dataclasses import replace from decimal import Decimal, localcontext from fractions import Fraction @@ -607,7 +608,9 @@ def test_fingerprints_reject_malformed_canonical_identities( assert exc.value.code is ErrorCode.INVALID_RENDER_REQUEST -def test_cut_key_uses_a_canonical_versioned_json_schema(tmp_path: Path) -> None: +def test_cut_key_without_model_exclusions_matches_the_canonical_schema( + tmp_path: Path, +) -> None: request = request_a(tmp_path) canonical_json = json.dumps( { @@ -644,6 +647,143 @@ def test_cut_key_uses_a_canonical_versioned_json_schema(tmp_path: Path) -> None: cut_cache_key(request, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA) == hashlib.sha256(canonical_json.encode("utf-8")).hexdigest() ) + for segmentation in ( + request.segmentation, + replace(request.segmentation, exclusions=()), + ): + no_regions = replace(request, segmentation=segmentation) + inputs = cut_cache_key_inputs( + no_regions, + source_sha256=SOURCE_SHA, + model_weight_sha256=MODEL_SHA, + ) + assert "model_exclusions" not in inputs + assert cut_cache_key( + no_regions, + source_sha256=SOURCE_SHA, + model_weight_sha256=MODEL_SHA, + ) == cut_cache_key( + request, + source_sha256=SOURCE_SHA, + model_weight_sha256=MODEL_SHA, + ) + + +def test_cut_key_ignores_a_model_exclusion_outside_the_crop_or_clipped_to_nothing( + tmp_path: Path, +) -> None: + request = request_a(tmp_path) + baseline = cut_cache_key( + request, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + for exclusion in (CropSpec(0, 0, 1, 1), CropSpec(0, 3, 2, 1)): + changed = replace( + request, + segmentation=replace( + request.segmentation, exclusions=(exclusion,) + ), + ) + inputs = cut_cache_key_inputs( + changed, + source_sha256=SOURCE_SHA, + model_weight_sha256=MODEL_SHA, + ) + assert "model_exclusions" not in inputs + assert cut_cache_key( + changed, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) == baseline + + +def test_cut_key_tracks_model_exclusion_boxes_and_the_fill_identifier( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + request = request_a(tmp_path) + first = replace( + request, + segmentation=replace( + request.segmentation, + exclusions=(CropSpec(2, 3, 20, 30), CropSpec(40, 50, 10, 12)), + ), + ) + second = replace( + first, + segmentation=replace( + first.segmentation, + exclusions=(CropSpec(2, 3, 20, 31), CropSpec(40, 50, 10, 12)), + ), + ) + + first_inputs = cut_cache_key_inputs( + first, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + assert first_inputs["model_exclusions"] == { + "fill": fingerprints_module.MODEL_FILL_ID, + "boxes": ((0, 0, 20, 30), (38, 47, 48, 59)), + } + original_key = cut_cache_key( + first, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + assert original_key != cut_cache_key( + second, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + + monkeypatch.setattr(fingerprints_module, "MODEL_FILL_ID", "future-fill") + assert original_key != cut_cache_key( + first, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + + +def test_cut_key_inputs_with_model_exclusions_are_recursively_immutable( + tmp_path: Path, +) -> None: + request = replace( + request_a(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(2, 3, 20, 30),) + ), + ) + + inputs = cut_cache_key_inputs( + request, source_sha256=SOURCE_SHA, model_weight_sha256=MODEL_SHA + ) + model_exclusions = inputs["model_exclusions"] + assert isinstance(model_exclusions, Mapping) + assert isinstance(model_exclusions["boxes"], tuple) + assert isinstance(model_exclusions["boxes"][0], tuple) + with pytest.raises(TypeError): + model_exclusions["boxes"] = () # type: ignore[index] + + +def test_preview_identity_tracks_model_exclusions(tmp_path: Path) -> None: + request = request_a(tmp_path) + changed = replace( + request, + segmentation=replace( + request.segmentation, exclusions=(CropSpec(2, 3, 20, 30),) + ), + ) + + assert preview_fingerprint(changed, Fraction(1, 5)) != preview_fingerprint( + request, Fraction(1, 5) + ) + + +def test_render_and_union_identities_ignore_model_exclusions(tmp_path: Path) -> None: + request = request_a(tmp_path) + changed = replace( + request, + segmentation=replace( + request.segmentation, exclusions=(CropSpec(2, 3, 20, 30),) + ), + ) + cut_key = "ef" * 32 + + assert render_fingerprint(changed, cut_key=cut_key) == render_fingerprint( + request, cut_key=cut_key + ) + assert union_fingerprint(changed, cut_key=cut_key) == union_fingerprint( + request, cut_key=cut_key + ) def test_preview_identity_tracks_playhead_and_matting_values(tmp_path: Path) -> None: diff --git a/tests/core/test_parameters.py b/tests/core/test_parameters.py index 36d8b7c..bc89d87 100644 --- a/tests/core/test_parameters.py +++ b/tests/core/test_parameters.py @@ -11,6 +11,7 @@ V1_MODEL_IDS, AlphaThresholdChanged, EdgeModeChanged, + ExclusionsBeforeModelChanged, ExclusionsChanged, ExecutionProviderChanged, GlobalTrimChanged, @@ -119,6 +120,73 @@ def test_segmentation_parameter_changes_stale_the_current_preview() -> None: assert changed_again.preview is PreviewState.STALE +def test_exclusions_before_model_invalidates_the_preview_as_segmentation() -> None: + state = replace( + _current(), + parameters=replace( + _current().parameters, + exclusions=(CropSpec(10, 10, 20, 20),), + ), + ) + + changed = reduce(state, ExclusionsBeforeModelChanged(True)) + + assert changed.parameters.exclusions_before_model is True + assert changed.preview is PreviewState.STALE + assert changed.stale_category is PreviewInvalidationReason.SEGMENTATION + + +def test_exclusions_before_model_with_no_effective_region_does_not_invalidate() -> None: + state = replace( + _current(), + parameters=replace( + _current().parameters, + exclusions=(CropSpec(200, 200, 20, 20),), + ), + ) + + changed = reduce(state, ExclusionsBeforeModelChanged(True)) + + assert changed.parameters.exclusions_before_model is True + assert changed.preview is PreviewState.CURRENT + assert changed.stale_category is None + + +def test_region_change_invalidates_as_segmentation_while_the_switch_is_on() -> None: + initial = CropSpec(10, 10, 20, 20) + state = replace( + _current(), + parameters=replace( + _current().parameters, + exclusions=(initial,), + exclusions_before_model=True, + ), + ) + + changed = reduce( + state, ExclusionsChanged((CropSpec(20, 20, 20, 20),)) + ) + + assert changed.preview is PreviewState.STALE + assert changed.stale_category is PreviewInvalidationReason.SEGMENTATION + + +def test_parameters_reset_clears_exclusions_before_model() -> None: + state = replace( + _current(), + parameters=replace( + _current().parameters, + exclusions=(CropSpec(10, 10, 20, 20),), + exclusions_before_model=True, + ), + ) + + reset = reduce(state, ParametersReset()) + + assert reset.parameters.exclusions_before_model is False + assert reset.stale_category is PreviewInvalidationReason.SEGMENTATION + + def test_execution_provider_changes_stale_the_current_preview() -> None: changed = reduce(_current(), ExecutionProviderChanged("CUDAExecutionProvider")) @@ -428,3 +496,13 @@ def test_exclusions_settings_string_round_trips_and_malformed_entries_fall_back_ ).exclusions == exclusions assert parameters_from_values({"exclusions": "1,2,30"}).exclusions == () assert parameters_from_values({"exclusions": "1,2,3,4;bad"}).exclusions == () + + +def test_exclusions_before_model_settings_round_trip_and_malformed_value_fall_back( +) -> None: + assert parameters_from_values( + {"exclusions_before_model": "true"} + ).exclusions_before_model is True + assert parameters_from_values( + {"exclusions_before_model": "not-a-bool"} + ).exclusions_before_model is False diff --git a/tests/core/test_specs.py b/tests/core/test_specs.py index 5d0be86..bfe9618 100644 --- a/tests/core/test_specs.py +++ b/tests/core/test_specs.py @@ -153,6 +153,23 @@ def test_framing_spec_rejects_exclusions_that_are_not_crop_specs( assert exc.value.code is ErrorCode.INVALID_FRAMING +@pytest.mark.parametrize( + "exclusions", + [ + [CropSpec(0, 0, 10, 10)], + (CropSpec(0, 0, 10, 10), (0, 0, 10, 10)), + ], + ids=["not-a-tuple", "contains-a-non-crop"], +) +def test_segmentation_spec_rejects_exclusions_that_are_not_crop_specs( + exclusions: object, +) -> None: + with pytest.raises(ValidationError) as exc: + SegmentationSpec(exclusions=exclusions) # type: ignore[arg-type] + + assert exc.value.code is ErrorCode.INVALID_SEGMENTATION + + @pytest.mark.parametrize( ("crop", "source_width", "source_height"), [ diff --git a/tests/jobs/render_support.py b/tests/jobs/render_support.py index 435887c..1aa93c0 100644 --- a/tests/jobs/render_support.py +++ b/tests/jobs/render_support.py @@ -119,9 +119,11 @@ def frozen_segmentation_result(result: np.ndarray) -> np.ndarray: class FakeSegmenter: def __init__(self) -> None: self.calls: list[SegmentRequest] = [] + self.frames: list[np.ndarray] = [] def segment(self, frame: np.ndarray, request: SegmentRequest) -> np.ndarray: self.calls.append(request) + self.frames.append(frame.copy()) result = np.zeros(frame.shape[:2] + (4,), dtype=np.uint8) result[24:104, 32:96, :3] = frame[24:104, 32:96, :3] result[24:104, 32:96, 3] = 255 diff --git a/tests/jobs/test_preview.py b/tests/jobs/test_preview.py index d028022..9599221 100644 --- a/tests/jobs/test_preview.py +++ b/tests/jobs/test_preview.py @@ -100,6 +100,29 @@ def test_preview_zeroes_excluded_alpha_in_the_cut_image_and_its_bounds( assert preview.local_bounds_estimate == PixelBounds(64, 24, 96, 104) +def test_preview_shows_no_filler_pixels_inside_a_model_exclusion( + tmp_path, +) -> None: + render_request = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(32, 24, 32, 80),) + ), + ) + + preview = PreviewService( + source=FakeSource(), + segmentation=binding(FakeSegmenter()), + workspace=FilesystemWorkspacePort(), + clock=FakeClock(), + ).preview( + render_request, Fraction(0), job(tmp_path, "model-preview", JobKind.PREVIEW) + ) + + with preview.pre_global_trim_rgba.to_image() as cut: + assert cut.getpixel((40, 30)) == (0, 0, 0, 0) + + def test_preview_fingerprint_tracks_the_prepared_model_weight(tmp_path) -> None: request_with_same_user_settings = request(tmp_path) source = FakeSource() diff --git a/tests/jobs/test_rebuild.py b/tests/jobs/test_rebuild.py index 160a106..7f97fe7 100644 --- a/tests/jobs/test_rebuild.py +++ b/tests/jobs/test_rebuild.py @@ -12,6 +12,7 @@ import matteloop.paths as paths_module from matteloop.core.errors import AppError, ErrorCode, ValidationError +from matteloop.core.fingerprints import cut_cache_key from matteloop.core.specs import ( CropSpec, FramingSpec, @@ -19,6 +20,7 @@ OutputSpec, ResizeSpec, SamplingSpec, + SegmentationSpec, TransformSpec, ) from matteloop.core.state import JobKind @@ -34,6 +36,7 @@ RenderService, ) from matteloop.jobs.transform_store import load_transform, transform_sidecar_path +from matteloop.ui.workspace_presentation import request_for_workspace from tests.jobs.render_support import ( ExplodingSource, FakeClock, @@ -414,6 +417,43 @@ def _rebuild_service(workspace: FilesystemWorkspacePort, encoder) -> RenderServi ) +def test_rebuild_of_a_model_exclusion_set_reproduces_its_key_from_the_manifest( + tmp_path, +) -> None: + workspace = FilesystemWorkspacePort() + seed_request = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(32, 24, 32, 80),) + ), + ) + original = render_service(workspace=workspace).render( + seed_request, job(tmp_path, "seed-model-rebuild", JobKind.RENDER) + ) + rebuilt_request = request_for_workspace( + original.manifest, + replace(seed_request, segmentation=SegmentationSpec()), + ) + + assert ( + rebuilt_request.segmentation.exclusions + == seed_request.segmentation.exclusions + ) + assert cut_cache_key( + rebuilt_request, + source_sha256=original.manifest.source_sha256, + model_weight_sha256="ab" * 32, + ) == original.manifest.cache_key + + rebuilt = _rebuild_service(workspace, FakeEncoder()).rebuild( + rebuilt_request, + original.cut_workspace, + job(tmp_path, "rebuild-model-set", JobKind.REBUILD), + ) + + assert rebuilt.manifest.cache_key == original.manifest.cache_key + + def test_identity_transform_rebuild_is_byte_identical(tmp_path) -> None: """AC 1: an explicit identity ``TransformSpec`` and the ``RenderRequest`` default must reach the encoder with the same paths and delays and produce diff --git a/tests/jobs/test_render.py b/tests/jobs/test_render.py index c549eed..d66c5c6 100644 --- a/tests/jobs/test_render.py +++ b/tests/jobs/test_render.py @@ -1571,6 +1571,103 @@ def test_render_stores_unexcluded_cuts_but_unions_and_encodes_without_the_region assert artifact.manifest.union_metadata.bounds == (64, 24, 96, 104) +def test_render_blanks_model_exclusions_and_zeroes_stored_cut( + tmp_path: Path, +) -> None: + segmenter = FakeSegmenter() + render_request = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(32, 24, 32, 80),) + ), + ) + + artifact = render_service(segmenter=segmenter).render( + render_request, job(tmp_path, "model-exclusion", JobKind.RENDER) + ) + + assert tuple(segmenter.frames[0][30, 40, :3]) == (124, 116, 104) + with artifact.cut_workspace.read_promoted_cut(0) as stored: + assert stored.getpixel((40, 30)) == (0, 0, 0, 0) + + +def test_render_with_model_exclusions_reads_the_original_pixels_outside_the_box( + tmp_path: Path, +) -> None: + segmenter = FakeSegmenter() + render_request = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(32, 24, 32, 80),) + ), + ) + + render_service(segmenter=segmenter).render( + render_request, job(tmp_path, "model-exclusion-edge", JobKind.RENDER) + ) + + frame = segmenter.frames[0] + assert tuple(frame[23, 40, :3]) == (0, 60, 90) + assert tuple(frame[30, 31, :3]) == (0, 60, 90) + assert tuple(frame[104, 40, :3]) == (0, 60, 90) + + +def test_render_with_the_switch_off_sends_the_model_the_unblanked_frame( + tmp_path: Path, +) -> None: + segmenter = FakeSegmenter() + + render_service(segmenter=segmenter).render( + request(tmp_path), job(tmp_path, "model-exclusion-off", JobKind.RENDER) + ) + + assert tuple(segmenter.frames[0][30, 40, :3]) == (0, 60, 90) + + +def test_render_reuses_the_unblanked_cut_set_after_the_switch_is_turned_off( + tmp_path: Path, +) -> None: + segmenter = FakeSegmenter() + service = render_service(segmenter=segmenter) + pre_model = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(32, 24, 32, 80),) + ), + ) + post_model = request(tmp_path) + + service.render(pre_model, job(tmp_path, "reuse-pre-first", JobKind.RENDER)) + assert len(segmenter.calls) == 2 + service.render(post_model, job(tmp_path, "reuse-post", JobKind.RENDER)) + assert len(segmenter.calls) == 4 + service.render( + pre_model, job(tmp_path, "reuse-pre-again", JobKind.RENDER) + ) + + assert len(segmenter.calls) == 4 + + +def test_render_with_whole_frame_model_exclusion_notes_untrimmed_canvas( + tmp_path: Path, +) -> None: + render_request = replace( + request(tmp_path), + segmentation=SegmentationSpec( + exclusions=(CropSpec(0, 0, 128, 128),) + ), + framing=FramingSpec(True, Decimal("2"), 0, Decimal("1")), + ) + + artifact = render_service().render( + render_request, job(tmp_path, "whole-model-exclusion", JobKind.RENDER) + ) + + assert (artifact.width, artifact.height) == (128, 128) + assert artifact.manifest.union_metadata is None + assert any("trim skipped" in note for note in artifact.notes) + + def test_render_maps_offset_source_exclusions_into_cut_coordinates(tmp_path) -> None: render_request = replace( request(tmp_path, crop=CropSpec(16, 16, 128, 128)), diff --git a/tests/jobs/test_workspace.py b/tests/jobs/test_workspace.py index 4c4e27f..a640941 100644 --- a/tests/jobs/test_workspace.py +++ b/tests/jobs/test_workspace.py @@ -2120,6 +2120,64 @@ def test_manifest_rejects_non_authoritative_cache_key_inputs() -> None: assert exc.value.code is ErrorCode.CUT_MANIFEST_INVALID +def test_manifest_accepts_model_exclusions_and_reproduces_the_cut_key( + tmp_path: Path, +) -> None: + inputs = _cache_inputs() + inputs["model_exclusions"] = { + "fill": "imagenet-mean", + "boxes": [[1, 1, 3, 3]], + } + staged, manifest = _completed_staging(tmp_path, inputs=inputs) + decoded = CutManifest.from_json_bytes(manifest.to_json_bytes()) + request = RenderRequest( + source=tmp_path / "source.mp4", + sampling=SamplingSpec(Fraction(0), Fraction(1), 15), + crop=CropSpec(0, 0, 8, 6), + segmentation=SegmentationSpec( + exclusions=(CropSpec(1, 1, 2, 2),) + ), + framing=FramingSpec(), + output=OutputSpec(tmp_path, "output.webp"), + ) + + assert decoded == manifest + assert decoded.cache_key == cut_cache_key( + request, + source_sha256="a" * 64, + model_weight_sha256="b" * 64, + ) + assert staged.cache_key == decoded.cache_key + + +@pytest.mark.parametrize( + "box", + [ + [2, 1, 1, 2], + [-1, 0, 1, 1], + ["1", 0, 1, 1], + ], + ids=["inverted", "negative", "non-integer"], +) +def test_manifest_rejects_malformed_model_exclusion_boxes( + box: list[object], +) -> None: + inputs = _cache_inputs() + inputs["model_exclusions"] = { + "fill": "imagenet-mean", + "boxes": [box], + } + + with pytest.raises(AppError) as exc: + CutManifest.cache_key_for(inputs) + + assert exc.value.code is ErrorCode.CUT_MANIFEST_INVALID + + +def test_manifest_without_model_exclusions_still_validates() -> None: + assert CutManifest.cache_key_for(_cache_inputs()) + + def test_manifest_cache_key_matches_the_task_4_authoritative_fingerprint( tmp_path: Path, ) -> None: From 3b862ea62f801000021655f3bac7c112c0b67532 Mon Sep 17 00:00:00 2001 From: smb Date: Sat, 12 Sep 2026 16:29:26 +0200 Subject: [PATCH 20/21] =?UTF-8?q?=E2=9C=A8=20feat(inspector):=20show=20pre?= =?UTF-8?q?-model=20mode?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ✨ Features: - `ExclusionControls` dispatches `ExclusionsBeforeModelChanged`, disables the inert switch without regions, and names the re-segmentation cost in the checkbox and count label. - `ExclusionCanvas` uses a `BDiagPattern` hatch and 2 px red pen for effective pre-model boxes, and appends the literal accessible announcement suffix. - `ParameterPresentation`, `CropPresentation`, preferences, and `_render_request` carry the global flag; `scripts/screenshots.py` captures it in the generated main-window image. - 🎨 Style: - README describes the separate cached cut set, and regenerated English/German catalogues contain all 551 finished messages with the four new translations. - 🧪 Tests: - `test_before_model_checkbox_dispatches_and_is_inert_without_regions` and `test_before_model_count_label_names_the_blank` pin dispatch, inert state, checked state, and count wording. - `test_model_exclusions_are_painted_hatched_and_announced` pins visible hatching and the accessible suffix; `test_exclusions_before_model_persists_as_a_bool` pins the QSettings bool. - `test_parameter_and_crop_presentations_carry_exclusion_regions` and `test_preview_and_render_requests_share_every_inspector_parameter` pin state projection and switch-dependent request tuples. Refs #80 --- README.md | 4 +- assets/screenshots/main-window.png | Bin 215111 -> 499643 bytes resources/matteloop_de.qm | Bin 72802 -> 73536 bytes resources/matteloop_de.ts | 63 +++++++++++++------ resources/matteloop_en.qm | Bin 64644 -> 65306 bytes resources/matteloop_en.ts | 63 +++++++++++++------ scripts/screenshots.py | 1 + src/matteloop/ui/crop_presentation.py | 2 + src/matteloop/ui/exclusion_canvas.py | 62 +++++++++++++----- src/matteloop/ui/exclusion_controls.py | 47 +++++++++++++- src/matteloop/ui/inspector_reset.py | 4 ++ src/matteloop/ui/parameter_presentation.py | 2 + src/matteloop/ui/preferences.py | 4 ++ src/matteloop/ui/request_builder.py | 5 ++ tests/ui/test_crop_canvas.py | 41 ++++++++++++ tests/ui/test_parameter_inspector.py | 70 ++++++++++++++++++++- tests/ui/test_parameter_persistence.py | 13 ++++ tests/ui/test_parameter_presentation.py | 9 ++- tests/ui/test_parameter_requests.py | 10 ++- 19 files changed, 338 insertions(+), 62 deletions(-) diff --git a/README.md b/README.md index 0d06184..b7409c9 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,9 @@ composite. MatteLoop is the whole path from that clip to that loop: - **Trim, crop and resize** the finished cut, and watch it loop on screen until it is right. - **Mark exclusion regions** over burned-in overlays or other unwanted - foreground; those areas are made transparent after segmentation. + foreground; those areas are made transparent after segmentation. Turn on + **Blank before the model** when an excluded bystander is distorting the + matte; this re-segments the clip and uses a separate cached cut set. - **Render** a lossless transparent animated WebP. - **Choose or clear the output directory** in the inspector's Output section. - **Replace the open clip** by dropping another video onto the window, or with diff --git a/assets/screenshots/main-window.png b/assets/screenshots/main-window.png index e61d46df3940c14b362e3295a5988864b777a917..9c2ffd17a0b85dc3914b224851c1fc900cac1d8f 100644 GIT binary patch literal 499643 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 T80R&MP&fD+{<9NCINp-7|rN_ry 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