From 0d0fc366f408548b8523ab1b65f4f91d67e09671 Mon Sep 17 00:00:00 2001 From: Derrick Chambers Date: Fri, 24 Apr 2026 14:42:47 +0200 Subject: [PATCH 1/7] start api-redisgn --- src/dasjax/core.py | 122 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 src/dasjax/core.py diff --git a/src/dasjax/core.py b/src/dasjax/core.py new file mode 100644 index 0000000..6cff0e8 --- /dev/null +++ b/src/dasjax/core.py @@ -0,0 +1,122 @@ +""" +Core modules for DASJax +""" +from typing import ClassVar + +import dascore as dc +import jax +import numpy as np +from pyparsing.tools.cvt_pyparsing_pep8_names import camel_to_snake + +COORDTYPE_CODES = { + 1: np.float32, + 2: np.float64, + 3: np.int32, + 4: np.int64, + 5: 'datetime64[ns]', + 6: 'timedelta64[ns]', +} + + +class PatchPyTree: + """ + A Dataclass for representing Patches as pytrees. + + Patches get automatically converted into pytrees when entering a pipeline. + They are rebuilt on the other end. + + Parameters + ---------- + data (dynamic) + The array data. + dims (static) + A tuple of dims. + static_coords (static) + Any string coordinates. + dynamic_coords (dynamic) + Any numeric coords. Note: datetime64 and timedelta64 are converted + to ints and marked in the coord_type dict. + static_attrs (static) + Static attributes. Note: these will only be populated with values + requested by the pipeline. + dynamic_attrs (dynamic) + Dynamic attributes. Note: these will only be populated with values. + coord_types (dynamic): + The name and type of coordinate. This is mostly for re-assembling + the patch. + """ + data: jax.ndarray + dims: tuple[str, ...] + static_coords: dict[str, jax.ndarray] + dynamic_coords: dict[str, jax.ndarray] + static_attrs: dict[str, int | float | str] + dynamic_attrs: dict[str, int | float] + coord_types: dict[str, int] + + + +class PatchOperationBase: + """ + A jax-accelerated patch operation for DASCore. + + To implement a Patch Operation, subclass this then define the required + parameters (data-class style). Next, define the required attrs as either + dynamic or static. Then define the data_func and/or metadata_func. These + normally run in parallel with the data_func compling to fused jax kernels. + + Parameters + ---------- + static_attrs + A tuple of the attrs that should be treated as static. These should + not change frequently from patch to patch as each new value can + trigger a re-compile. + + dynamic_attrs + A tuple of attrs that should be treated as dynamic. These should be + strictly numeric but can very from patch to patch without triggering + recompilation. + """ + # Parameters go here. + + # Class level + static_attrs: ClassVar[tuple[str, ...]] = () + dynamic_attrs: ClassVar[tuple[str, ...]] = () + + @property + def pipe_method_name(self): + """ + The name which will be added as a method on DASJax pipe. + + Can be overwritten by subclasses as simple parameter. + """ + name = self.__name__ + return camel_to_snake(name) # Need to define this. + + + def data_func(self, pytree: PatchPyTree) -> PatchPyTree: + """ + A function that is applied primarily on the patch data + (or sometimes coord) values. + """ + return pytree + + def metadata_func( + self, attrs: dc.PatchAttrs, coords: dc.PatchCoords + ) -> tuple[dc.PatchAttrs, dc.PatchCoords]: + """ + A function that updates the metadata (coords, attrs) for a patch. + """ + return attrs, coords + + def cross_metadata( + self, pytree: PatchPyTree, attrs: dc.PatchAttrs, coords: dc.PatchCoords + ) -> tuple[PatchPyTree, dc.PatchAttrs, dc.PatchCoords]: + """ + A function that allows the metadata to be updated from a pytree. + + This should only be defined by a subclass when necessary as it will + break the complication chain (eg each PatchOperation with cross_metadata + must be at the end of a compiled chain). + """ + + From 5cf20df461bc11ad495617a77eb8c911dc90c0b6 Mon Sep 17 00:00:00 2001 From: Derrick Chambers Date: Fri, 24 Apr 2026 17:49:31 +0200 Subject: [PATCH 2/7] redsign API --- .agents/{README.md => GUIDELINES.md} | 3 +- README.md | 16 +- src/dasjax/__init__.py | 21 +- src/dasjax/core.py | 482 +++++++++--- src/dasjax/core_ops.py | 852 +++++++++++++++++++++ src/dasjax/operations/__init__.py | 23 - src/dasjax/operations/basic/__init__.py | 5 - src/dasjax/operations/basic/impl.py | 404 ---------- src/dasjax/operations/basic/specs.py | 224 ------ src/dasjax/operations/common.py | 139 ---- src/dasjax/operations/filters/__init__.py | 5 - src/dasjax/operations/filters/impl.py | 415 ---------- src/dasjax/operations/filters/specs.py | 122 --- src/dasjax/operations/patch_ops.py | 424 ---------- src/dasjax/operations/registry.py | 40 - src/dasjax/operations/signal/__init__.py | 5 - src/dasjax/operations/signal/impl.py | 521 ------------- src/dasjax/operations/signal/specs.py | 144 ---- src/dasjax/operations/spectral/__init__.py | 5 - src/dasjax/operations/spectral/impl.py | 560 -------------- src/dasjax/operations/spectral/specs.py | 182 ----- src/dasjax/operations/types.py | 75 -- src/dasjax/pipeline.py | 407 +++++----- src/dasjax/pytree.py | 102 --- tests/test_core_api.py | 292 +++++++ tests/test_method_equivalence.py | 175 +++-- tests/test_patch_ops.py | 239 ------ tests/test_pipeline_cache.py | 56 +- tests/test_pytree.py | 121 --- tests/test_registry_architecture.py | 124 ++- 30 files changed, 1898 insertions(+), 4285 deletions(-) rename .agents/{README.md => GUIDELINES.md} (60%) create mode 100644 src/dasjax/core_ops.py delete mode 100644 src/dasjax/operations/__init__.py delete mode 100644 src/dasjax/operations/basic/__init__.py delete mode 100644 src/dasjax/operations/basic/impl.py delete mode 100644 src/dasjax/operations/basic/specs.py delete mode 100644 src/dasjax/operations/common.py delete mode 100644 src/dasjax/operations/filters/__init__.py delete mode 100644 src/dasjax/operations/filters/impl.py delete mode 100644 src/dasjax/operations/filters/specs.py delete mode 100644 src/dasjax/operations/patch_ops.py delete mode 100644 src/dasjax/operations/registry.py delete mode 100644 src/dasjax/operations/signal/__init__.py delete mode 100644 src/dasjax/operations/signal/impl.py delete mode 100644 src/dasjax/operations/signal/specs.py delete mode 100644 src/dasjax/operations/spectral/__init__.py delete mode 100644 src/dasjax/operations/spectral/impl.py delete mode 100644 src/dasjax/operations/spectral/specs.py delete mode 100644 src/dasjax/operations/types.py delete mode 100644 src/dasjax/pytree.py create mode 100644 tests/test_core_api.py delete mode 100644 tests/test_patch_ops.py delete mode 100644 tests/test_pytree.py diff --git a/.agents/README.md b/.agents/GUIDELINES.md similarity index 60% rename from .agents/README.md rename to .agents/GUIDELINES.md index 958e217..1943cf7 100644 --- a/.agents/README.md +++ b/.agents/GUIDELINES.md @@ -4,4 +4,5 @@ - Target roughly one meaningful comment for every 5-10 lines in dense array code. - Comment the reason for a layout transform, cached constant, broadcast shape, or numerical safeguard. - Do not add filler comments that simply restate the next line. -- When splitting modules, keep package-level re-exports stable unless the task explicitly narrows the public API. +- Write tests, follow red green TDD. +- Ensure all methods, functions, modules, and classes have a docstring. Private objects can have a single line, public objects should have a full numpy docstring with examples (following doctest). diff --git a/README.md b/README.md index 987e175..37dbd67 100644 --- a/README.md +++ b/README.md @@ -38,18 +38,18 @@ print(out.shape) ## Development -### Three-Tier Architecture +### Architecture -`dasjax` is organized as a small three-tier stack: +`dasjax` is organized around one core operation model: 1. Pipeline layer: - `src/dasjax/pipeline.py` records operation chains and compiles reusable patch transforms. This is the main user-facing API. + `src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API. 2. Operation layer: - `src/dasjax/operations/` defines the operation registry, execution policies, validation rules, eager patch implementations, and compiled leaf transforms. + `src/dasjax/core.py` and `src/dasjax/core_ops.py` define `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and the registered operation classes. 3. Kernel layer: `src/dasjax/kernels/` contains the array-level JAX and callback-backed kernels that actually do the numerical work, grouped by domain (`basic`, `signal`, `filters`, `spectral`). -This split keeps the package easier to extend: add or update numerical behavior in the kernel layer, describe how it plugs into compiled execution in the operation layer, and expose it through the pipeline layer. +Operation authors use `bind(boundary)` for Python-side metadata planning, `kernel(patch_tree)` for JAX-side data transforms, and `update_boundary(boundary)` for static metadata changes. ### Roadmap @@ -90,10 +90,10 @@ These need either more work in the kernel layer or are shape-changing (segmented ## Development Guidelines -- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one operation spec in the relevant `src/dasjax/operations/` family module. -- The operation spec is the single source of truth for pipeline support, validation, and shared parity test cases. +- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one `PatchOperation` subclass in `src/dasjax/core_ops.py`. +- The `PatchOperation` subclass is the single source of truth for pipeline support, metadata binding, and boundary updates. - Every new patch method must be tested against a DASCore baseline across the shared mixed-patch fixture in `tests/conftest.py`. - Prefer comparing internal operation behavior and compiled pipeline outputs against the closest native DASCore method or operator. If DASCore has no direct method, compare against an equivalent `Patch.update(...)` baseline. - Method-equivalence assertions should check data closeness with `equal_nan=True` when needed and should also verify coordinate preservation. -- Compiled pipeline parity should come from the same declared operation cases rather than a separate hand-maintained test matrix. +- Compiled pipeline parity should compare `JaxPatchPipeline` output against DASCore baselines for each registered operation. - Install Git hooks locally with `prek install`. diff --git a/src/dasjax/__init__.py b/src/dasjax/__init__.py index d01e789..b9f6eac 100644 --- a/src/dasjax/__init__.py +++ b/src/dasjax/__init__.py @@ -10,11 +10,26 @@ jax.config.update("jax_enable_x64", True) -from . import pytree as pytree -from .operations import list_operations +from .core import ( + PatchBoundary, + PatchOperation, + PatchPyTree, + get_patch_operation, + iter_patch_operations, + list_patch_operations, +) +from . import core_ops as core_ops from .pipeline import JaxPatchPipeline -__all__ = ["JaxPatchPipeline", "list_operations"] +__all__ = [ + "JaxPatchPipeline", + "PatchBoundary", + "PatchOperation", + "PatchPyTree", + "get_patch_operation", + "iter_patch_operations", + "list_patch_operations", +] try: __version__ = version("dasjax") diff --git a/src/dasjax/core.py b/src/dasjax/core.py index 6cff0e8..18f67e7 100644 --- a/src/dasjax/core.py +++ b/src/dasjax/core.py @@ -1,122 +1,412 @@ -""" -Core modules for DASJax -""" -from typing import ClassVar +"""Core authoring API for JAX-backed DASCore patch operations.""" + +from __future__ import annotations + +import re +from collections.abc import Iterator +from dataclasses import dataclass, replace +from typing import Any, ClassVar, Self import dascore as dc import jax import numpy as np -from pyparsing.tools.cvt_pyparsing_pep8_names import camel_to_snake - -COORDTYPE_CODES = { - 1: np.float32, - 2: np.float64, - 3: np.int32, - 4: np.int64, - 5: 'datetime64[ns]', - 6: 'timedelta64[ns]', + +from . import kernels + +SUPPORTED_DTYPES = (np.bool_, np.integer, np.floating, np.complexfloating) +TIME_DTYPES = (np.datetime64, np.timedelta64) +_DTYPE_TO_CODE = { + np.dtype("bool").str: 1, + np.dtype("int32").str: 2, + np.dtype("int64").str: 3, + np.dtype("float32").str: 4, + np.dtype("float64").str: 5, + np.dtype("complex64").str: 6, + np.dtype("complex128").str: 7, + np.dtype("datetime64[ns]").str: 8, + np.dtype("timedelta64[ns]").str: 9, } +_CODE_TO_DTYPE = {value: np.dtype(key) for key, value in _DTYPE_TO_CODE.items()} +_PatchTreeChildren = tuple[Any, tuple[Any, ...], tuple[Any, ...], tuple[Any, ...]] + + +def _camel_to_snake(name: str) -> str: + """Convert class names into default pipeline method names.""" + name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name) + return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower() + + +def _matches_dtype(dtype: np.dtype, candidates: tuple[type[Any], ...]) -> bool: + return any(np.issubdtype(dtype, candidate) for candidate in candidates) + + +def _encode_leaf(array: Any) -> tuple[Any, np.ndarray]: + arr = np.asarray(array) + dtype_code = _DTYPE_TO_CODE.get(arr.dtype.str) + if dtype_code is None: + msg = f"Unsupported coordinate dtype for JAX patch conversion: {arr.dtype}" + raise TypeError(msg) + if _matches_dtype(arr.dtype, SUPPORTED_DTYPES): + return arr, np.asarray(dtype_code, dtype=np.int32) + if _matches_dtype(arr.dtype, TIME_DTYPES): + return arr.view(np.int64), np.asarray(dtype_code, dtype=np.int32) + msg = f"Unsupported coordinate dtype for JAX patch conversion: {arr.dtype}" + raise TypeError(msg) + + +def _decode_leaf(array: Any, dtype_code: Any) -> np.ndarray: + out = np.asarray(array) + dtype = _CODE_TO_DTYPE[int(np.asarray(dtype_code).item())] + if _matches_dtype(dtype, TIME_DTYPES): + return out.astype(np.int64, copy=False).view(dtype) + return out.astype(dtype, copy=False) + + +@dataclass(frozen=True) +class PatchBoundary: + """DASCore-native metadata owned by pipeline boundaries.""" + + attrs: Any + coords: Any + coord_names: tuple[str, ...] + + @property + def dims(self) -> tuple[str, ...]: + """Return ordered data dimension names.""" + return tuple(self.coords.dims) + + def axis(self, dim: str) -> int: + """Return the data axis for a named dimension.""" + return self.dims.index(dim) + def coord(self, name: str) -> Any: + """Return a DASCore coordinate by name.""" + return self.coords.coord_map[name] + def coord_dims(self, name: str) -> tuple[str, ...]: + """Return the dimensions associated with a coordinate.""" + return tuple(self.coords.dim_map[name]) + + def coord_index(self, name: str) -> int: + """Return the ordered dynamic coordinate slot for a coordinate name.""" + return self.coord_names.index(name) + + def to_patch( + self, + patch_tree: "PatchPyTree", + *, + coerce_numpy: bool = True, + ) -> dc.Patch: + """Rebuild a DASCore patch by swapping dynamic values into metadata.""" + coord_values = { + name: _decode_leaf(value, dtype_code) + for name, value, dtype_code in zip( + self.coord_names, + patch_tree.coord_values, + patch_tree.coord_dtype_codes, + strict=True, + ) + } + coords: dict[str, Any] = {} + for name, coord in self.coords.coord_map.items(): + out_coord = coord + if name in coord_values: + out_coord = coord.update_data(data=coord_values[name]) + if coord.units is not None: + out_coord = out_coord.set_units(coord.units) + dims = tuple(self.coords.dim_map[name]) + coords[name] = ( + out_coord if len(dims) == 1 and dims[0] == name else (dims, out_coord) + ) + return dc.Patch( + data=np.asarray(patch_tree.data) if coerce_numpy else patch_tree.data, + coords=coords, + dims=patch_tree.dims, + attrs=self.attrs, + ) + + def new( + self, + *, + attrs: Any | None = None, + coords: Any | None = None, + coord_names: tuple[str, ...] | None = None, + ) -> "PatchBoundary": + """Return a copy with updated DASCore metadata.""" + return replace( + self, + attrs=self.attrs if attrs is None else attrs, + coords=self.coords if coords is None else coords, + coord_names=self.coord_names if coord_names is None else coord_names, + ) + + def with_metadata( + self, + *, + attrs: Any | None = None, + coords: Any | None = None, + ) -> "PatchBoundary": + """Return a copy with updated DASCore metadata.""" + return self.new( + attrs=attrs, + coords=coords, + ) + + +@jax.tree_util.register_pytree_node_class +@dataclass(frozen=True) class PatchPyTree: - """ - A Dataclass for representing Patches as pytrees. - - Patches get automatically converted into pytrees when entering a pipeline. - They are rebuilt on the other end. - - Parameters - ---------- - data (dynamic) - The array data. - dims (static) - A tuple of dims. - static_coords (static) - Any string coordinates. - dynamic_coords (dynamic) - Any numeric coords. Note: datetime64 and timedelta64 are converted - to ints and marked in the coord_type dict. - static_attrs (static) - Static attributes. Note: these will only be populated with values - requested by the pipeline. - dynamic_attrs (dynamic) - Dynamic attributes. Note: these will only be populated with values. - coord_types (dynamic): - The name and type of coordinate. This is mostly for re-assembling - the patch. - """ - data: jax.ndarray + """JAX-friendly dynamic patch state with only dims as static metadata.""" + + data: Any + coord_values: tuple[Any, ...] + coord_dtype_codes: tuple[Any, ...] dims: tuple[str, ...] - static_coords: dict[str, jax.ndarray] - dynamic_coords: dict[str, jax.ndarray] - static_attrs: dict[str, int | float | str] - dynamic_attrs: dict[str, int | float] - coord_types: dict[str, int] + attrs: tuple[Any, ...] = () + @classmethod + def from_patch(cls, patch: dc.Patch) -> tuple[Self, PatchBoundary]: + """Convert a DASCore patch into a tree plus boundary metadata.""" + coord_names = tuple(patch.coords.coord_map) + coord_values = [] + coord_dtype_codes = [] + for name, coord in patch.coords.coord_map.items(): + values, dtype_code = _encode_leaf(coord.values) + coord_values.append(values) + coord_dtype_codes.append(dtype_code) + return ( + cls( + data=patch.data, + coord_values=tuple(coord_values), + coord_dtype_codes=tuple(coord_dtype_codes), + dims=tuple(patch.dims), + ), + PatchBoundary( + attrs=patch.attrs, + coords=patch.coords, + coord_names=coord_names, + ), + ) + def to_patch(self, *, coerce_numpy: bool = True) -> dc.Patch: + """Reject reconstruction without boundary metadata.""" + _ = coerce_numpy + msg = "PatchPyTree.to_patch() requires PatchBoundary.to_patch(patch_tree)." + raise RuntimeError(msg) -class PatchOperationBase: - """ - A jax-accelerated patch operation for DASCore. + def tree_flatten( + self, + ) -> tuple[_PatchTreeChildren, dict[str, Any]]: + """Split dynamic JAX leaves from static dims.""" + return ( + (self.data, self.coord_values, self.coord_dtype_codes, self.attrs), + {"dims": self.dims}, + ) - To implement a Patch Operation, subclass this then define the required - parameters (data-class style). Next, define the required attrs as either - dynamic or static. Then define the data_func and/or metadata_func. These - normally run in parallel with the data_func compling to fused jax kernels. + @classmethod + def tree_unflatten( + cls, + aux_data: dict[str, Any], + children: _PatchTreeChildren, + ) -> Self: + data, coord_values, coord_dtype_codes, attrs = children + return cls( + data=data, + coord_values=coord_values, + coord_dtype_codes=coord_dtype_codes, + dims=aux_data["dims"], + attrs=attrs, + ) - Parameters - ---------- - static_attrs - A tuple of the attrs that should be treated as static. These should - not change frequently from patch to patch as each new value can - trigger a re-compile. + def coord(self, index: int) -> Any: + """Return one ordered coordinate-value slot.""" + return self.coord_values[index] - dynamic_attrs - A tuple of attrs that should be treated as dynamic. These should be - strictly numeric but can very from patch to patch without triggering - recompilation. - """ - # Parameters go here. + def replace_coord(self, index: int, value: Any) -> tuple[Any, ...]: + """Return ordered coordinate-value slots with one value replaced.""" + coords = list(self.coord_values) + coords[index] = value + return tuple(coords) - # Class level - static_attrs: ClassVar[tuple[str, ...]] = () - dynamic_attrs: ClassVar[tuple[str, ...]] = () + def new( + self, + data: Any | None = None, + coords: tuple[Any, ...] | None = None, + *, + dims: tuple[str, ...] | None = None, + coord_dtype_codes: tuple[Any, ...] | None = None, + ) -> Self: + """Return a copy with updated JAX leaves, matching Patch.new style. - @property - def pipe_method_name(self): + ``coords`` are the ordered coordinate-value slots carried by this tree. + Coordinate names and DASCore coordinate objects live in ``PatchBoundary``. """ - The name which will be added as a method on DASJax pipe. + return replace( + self, + data=self.data if data is None else data, + coord_values=self.coord_values if coords is None else coords, + coord_dtype_codes=( + self.coord_dtype_codes + if coord_dtype_codes is None + else coord_dtype_codes + ), + dims=self.dims if dims is None else dims, + ) - Can be overwritten by subclasses as simple parameter. - """ - name = self.__name__ - return camel_to_snake(name) # Need to define this. +class PatchOperation: + """Base class for clean, class-authored patch operations.""" - def data_func(self, pytree: PatchPyTree) -> PatchPyTree: - """ - A function that is applied primarily on the patch data - (or sometimes coord) values. - """ - return pytree + method_name: ClassVar[str | None] = None + register: ClassVar[bool] = True - def metadata_func( - self, attrs: dc.PatchAttrs, coords: dc.PatchCoords - ) -> tuple[dc.PatchAttrs, dc.PatchCoords]: - """ - A function that updates the metadata (coords, attrs) for a patch. - """ - return attrs, coords + _registry: ClassVar[dict[str, type["PatchOperation"]]] = {} - def cross_metadata( - self, pytree: PatchPyTree, attrs: dc.PatchAttrs, coords: dc.PatchCoords - ) -> tuple[PatchPyTree, dc.PatchAttrs, dc.PatchCoords]: - """ - A function that allows the metadata to be updated from a pytree. + def __init_subclass__(cls, **kwargs: Any) -> None: + super().__init_subclass__(**kwargs) + if not cls.__dict__.get("register", True): + return + name = cls.operation_name() + if name in PatchOperation._registry: + msg = f"Duplicate patch operation method name {name!r}." + raise ValueError(msg) + PatchOperation._registry[name] = cls + + @classmethod + def operation_name(cls) -> str: + """Return the public pipeline method name for this operation.""" + name = cls.method_name + if name is not None: + return name + class_name = cls.__name__ + if class_name.endswith("Operation"): + class_name = class_name.removesuffix("Operation") + return _camel_to_snake(class_name) + + def bind(self, boundary: PatchBoundary) -> Self: + """Resolve DASCore metadata into static kernel parameters.""" + _ = boundary + return self + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + """Apply the JAX-compatible dynamic transform.""" + return patch_tree + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + """Plan DASCore metadata changes without reading computed array values.""" + return boundary + + def update_boundary_from_result( + self, + patch_tree: PatchPyTree, + boundary: PatchBoundary, + ) -> PatchBoundary: + """Update metadata from computed results, forcing a segment boundary.""" + _ = patch_tree + return boundary + + @classmethod + def overrides(cls, method_name: str) -> bool: + """Return True if a subclass overrides one base hook.""" + return getattr(cls, method_name) is not getattr(PatchOperation, method_name) + + +def get_patch_operation(name: str) -> type[PatchOperation]: + """Return a class-authored patch operation by public method name.""" + try: + return PatchOperation._registry[name] + except KeyError as exc: + raise AttributeError(f"Unknown jax patch operation {name!r}.") from exc + + +def iter_patch_operations() -> Iterator[type[PatchOperation]]: + """Iterate over class-authored patch operations in registration order.""" + return iter(PatchOperation._registry.values()) + + +def list_patch_operations() -> tuple[str, ...]: + """List class-authored operation names in registration order.""" + return tuple(PatchOperation._registry) + + +@dataclass(frozen=True) +class Identity(PatchOperation): + """Return a patch unchanged.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.identity_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Scale(PatchOperation): + """Scale patch data by a constant factor.""" + + factor: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.scale_kernel(patch_tree.data, self.factor)) + + +@dataclass(frozen=True) +class Add(PatchOperation): + """Add a constant value to patch data.""" + + value: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.add_kernel(patch_tree.data, self.value)) + + +@dataclass(frozen=True) +class Abs(PatchOperation): + """Take absolute value of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.abs_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Clip(PatchOperation): + """Clip patch data to a fixed range.""" + + min_value: float + max_value: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.clip_kernel( + patch_tree.data, self.min_value, self.max_value + ) + ) + + +@dataclass(frozen=True) +class Real(PatchOperation): + """Return the real component of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.real_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Imag(PatchOperation): + """Return the imaginary component of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.imag_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Angle(PatchOperation): + """Return the phase angle of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.angle_kernel(patch_tree.data)) - This should only be defined by a subclass when necessary as it will - break the complication chain (eg each PatchOperation with cross_metadata - must be at the end of a compiled chain). - """ +@dataclass(frozen=True) +class Conj(PatchOperation): + """Return the complex conjugate of patch data.""" + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.conj_kernel(patch_tree.data)) diff --git a/src/dasjax/core_ops.py b/src/dasjax/core_ops.py new file mode 100644 index 0000000..1188e9a --- /dev/null +++ b/src/dasjax/core_ops.py @@ -0,0 +1,852 @@ +"""Core PatchOperation ports for the public pipeline operation surface.""" + +from __future__ import annotations + +from dataclasses import dataclass, fields +from functools import reduce +from operator import add, mul, truediv +from typing import Any, ClassVar + +import dascore as dc +import jax +import jax.numpy as jnp +import numpy as np +from dascore.exceptions import ParameterError +from dascore.proc.basic import pad as dc_pad +from dascore.transform.fourier import ( + _get_idft_dims_steps_axis, + dft as dc_dft, + idft as dc_idft, +) +from dascore.units import get_filter_units, get_quantity +from dascore.utils.misc import iterate +from dascore.utils.patch import get_dim_axis_value, get_dim_sampling_rate, get_patch_window_size +from dascore.utils.transformatter import FourierTransformatter +from scipy.fft import next_fast_len +from scipy.signal import ShortTimeFFT, get_window + +from . import kernels +from .core import PatchBoundary, PatchOperation, PatchPyTree + + +def replace(obj, **changes): + """Copy frozen operation instances without calling custom constructors.""" + out = object.__new__(type(obj)) + for field in fields(obj): + object.__setattr__(out, field.name, changes.get(field.name, getattr(obj, field.name))) + return out + + +def _dummy_patch(boundary: PatchBoundary, dtype=np.float64) -> dc.Patch: + return dc.Patch( + data=np.zeros(boundary.coords.shape, dtype=dtype), + coords=boundary.coords, + dims=boundary.dims, + attrs=boundary.attrs, + ) + + +def _tree_boundary_from_patch(patch: dc.Patch) -> tuple[PatchPyTree, PatchBoundary]: + return PatchPyTree.from_patch(patch) + + +def _get_data_units_from_dims( + boundary: PatchBoundary, + dims: tuple[str, ...], + operator, +): + if (data_units := get_quantity(boundary.attrs.data_units)) is None: + return None + dim_units = None + for dim_name in dims: + dim_unit = get_quantity(boundary.coord(dim_name).units) + if dim_unit is None: + continue + dim_units = dim_unit if dim_units is None else dim_unit * dim_units + return operator(data_units, dim_units) if dim_units is not None else data_units + + +@dataclass(frozen=True) +class Flip(PatchOperation): + """Flip data and, optionally, associated coordinate values.""" + + dims: tuple[str, ...] = () + flip_coords: bool = True + axes: tuple[int, ...] = () + coord_axes: tuple[tuple[int, tuple[int, ...]], ...] = () + + def __init__(self, *dims: str, flip_coords: bool = True): + object.__setattr__(self, "dims", tuple(dims)) + object.__setattr__(self, "flip_coords", flip_coords) + object.__setattr__(self, "axes", ()) + object.__setattr__(self, "coord_axes", ()) + + def bind(self, boundary: PatchBoundary): + dims = self.dims or boundary.dims + axes = tuple(boundary.axis(dim) for dim in dims) + coord_axes = [] + if self.flip_coords: + for name in boundary.coord_names: + axes_for_coord = tuple( + idx + for idx, coord_dim in enumerate(boundary.coord_dims(name)) + if coord_dim in dims + ) + if axes_for_coord: + coord_axes.append((boundary.coord_index(name), axes_for_coord)) + return replace(self, dims=dims, axes=axes, coord_axes=tuple(coord_axes)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.flip_kernel(patch_tree.data, self.axes) + coords = patch_tree.coord_values + if self.flip_coords: + for index, axes in self.coord_axes: + coords = tuple( + jnp.flip(value, axis=axes) if idx == index else value + for idx, value in enumerate(coords) + ) + return patch_tree.new(data=data, coords=coords) + + +@dataclass(frozen=True) +class Roll(PatchOperation): + """Roll data along one dimension.""" + + samples: bool = False + update_coord: bool = False + kwargs: dict[str, Any] | None = None + axis: int | None = None + shift: int | None = None + + def __init__( + self, + samples: bool = False, + update_coord: bool = False, + **kwargs, + ): + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "update_coord", update_coord) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "shift", None) + + def bind(self, boundary: PatchBoundary): + if self.update_coord: + raise NotImplementedError("Compiled roll currently requires update_coord=False.") + kwargs = self.kwargs or {} + dim = next(key for key in kwargs if key in boundary.dims) + coord = boundary.coord(dim) + return replace( + self, + axis=boundary.axis(dim), + shift=int(coord.get_sample_count(kwargs[dim], samples=self.samples)), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None and self.shift is not None + return patch_tree.new(data=kernels.roll_kernel(patch_tree.data, self.shift, self.axis)) + + +@dataclass(frozen=True) +class Standardize(PatchOperation): + dim: str + axis: int | None = None + + def bind(self, boundary: PatchBoundary): + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=kernels.standardize_kernel(patch_tree.data, self.axis)) + + +@dataclass(frozen=True) +class Detrend(PatchOperation): + dim: str + type: str = "linear" + axis: int | None = None + + def bind(self, boundary: PatchBoundary): + kernels.validate_detrend_type(self.type) + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.detrend_kernel(patch_tree.data, axis=self.axis, type=self.type) + ) + + +@dataclass(frozen=True) +class Normalize(PatchOperation): + dim: str + norm: str = "l2" + axis: int | None = None + + def bind(self, boundary: PatchBoundary): + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.normalize_kernel(patch_tree.data, axis=self.axis, norm=self.norm) + ) + + +@dataclass(frozen=True) +class Differentiate(PatchOperation): + dim: str | tuple[str, ...] | None + order: int = 2 + step: int = 1 + axes: tuple[int, ...] = () + dxs_or_spacing: tuple[Any, ...] = () + attrs: Any = None + + def bind(self, boundary: PatchBoundary): + dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) + if self.step > 1 and len(dims) > 1: + raise ParameterError("Step in patch.differentiate can only be used along one axis.") + axes = [] + dxs = [] + for dim in dims: + coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) + val = coord.step if coord.evenly_sampled else coord.data + dxs.append(dc.to_float(val)) + axes.append(boundary.axis(dim)) + attrs = boundary.attrs.update( + data_units=_get_data_units_from_dims(boundary, dims, truediv) + ) + return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): + data = kernels.differentiate_kernel( + data, axis=axis, dx_or_spacing=spacing, order=self.order, step=self.step + ) + return patch_tree.new(data=data) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return boundary.new(attrs=self.attrs) + + +@dataclass(frozen=True) +class Integrate(PatchOperation): + dim: str | tuple[str, ...] | None + definite: bool = False + axes: tuple[int, ...] = () + dxs_or_spacing: tuple[Any, ...] = () + attrs: Any = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary): + dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) + axes = [] + dxs = [] + for dim in dims: + coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) + val = coord.step if coord.evenly_sampled else coord.data + dxs.append(dc.to_float(val)) + axes.append(boundary.axis(dim)) + attrs = boundary.attrs.update( + data_units=_get_data_units_from_dims(boundary, dims, mul), + coords={} if self.definite else boundary.attrs.coords, + ) + if self.definite: + out_patch = _dummy_patch(boundary).integrate(dim=dims, definite=True) + out_tree, out_boundary = _tree_boundary_from_patch(out_patch) + return replace( + self, + axes=tuple(axes), + dxs_or_spacing=tuple(dxs), + attrs=attrs, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): + data = kernels.integrate_kernel( + data, axis=axis, dx_or_spacing=spacing, definite=self.definite + ) + if self.definite: + return patch_tree.new( + data=data, + coords=self.out_coords, + dims=self.out_dims, + coord_dtype_codes=self.out_dtype_codes, + ) + return patch_tree.new(data=data) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return self.out_boundary if self.definite and self.out_boundary else boundary.new(attrs=self.attrs) + + +def _taper_window(window_type: str, size: int) -> np.ndarray: + return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64) + + +def _taper_slices(boundary: PatchBoundary, kwargs: dict[str, Any]): + dim = next(key for key in kwargs if key in boundary.dims) + axis = boundary.axis(dim) + value = kwargs[dim] + coord = boundary.coord(dim) + if isinstance(value, (tuple, list, np.ndarray)): + start, stop = value + else: + start, stop = value, value + dur = coord.coord_range(extend=False) + clses = (dc.units.Quantity, np.timedelta64) + start = start if isinstance(start, clses) or start is None else start * dur + stop = stop if isinstance(stop, clses) or stop is None else stop * dur + stop = -stop if stop is not None else stop + _, inds_1 = coord.select((None, start), relative=True) + _, inds_2 = coord.select((stop, None), relative=True) + return axis, inds_1, inds_2 + + +@dataclass(frozen=True) +class Taper(PatchOperation): + window_type: str = "hann" + kwargs: dict[str, Any] | None = None + axis: int | None = None + weight: Any = None + + def __init__(self, window_type: str = "hann", **kwargs): + object.__setattr__(self, "window_type", window_type) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "weight", None) + + def bind(self, boundary: PatchBoundary): + axis, start_slice, end_slice = _taper_slices(boundary, self.kwargs or {}) + length = boundary.coords.shape[axis] + start_len = start_slice.stop + end_len = length - end_slice.start + if start_len is not None and end_len is not None and start_len > end_slice.start: + raise ParameterError("Taper windows cannot overlap") + weight = np.ones(length, dtype=np.float64) + if start_len is not None and start_len > 0: + weight[:start_len] = _taper_window(self.window_type, 2 * start_len)[:start_len] + if end_slice.start is not None and end_slice.start < length: + weight[end_slice.start:] = _taper_window(self.window_type, 2 * end_len)[end_len:] + return replace(self, axis=axis, weight=weight) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)) + + +def _taper_coord_inds(coord, values, relative, samples): + error_msg = "A len 2 or 4 sequence is required for taper values" + if not isinstance(values, (tuple, list, np.ndarray)) or not len(values): + raise ParameterError(error_msg) + if isinstance(values[0], (tuple, list, np.ndarray)): + return reduce(add, (_taper_coord_inds(coord, item, relative, samples) for item in values)) + if len(values) not in {2, 4}: + raise ParameterError(error_msg) + out = [None] * len(values) + for idx, value in enumerate(values): + if value is None or value == ...: + if len(values) == 2: + raise ParameterError("Cannot use ... or None when only two values provided") + out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1 + else: + out[idx] = coord.get_next_index(value, samples=samples, relative=relative) + return [[0, *out, len(coord)]] if len(out) == 2 else [out] + + +def _taper_curve(coord, ind_1, ind_2, window_type, reverse=False): + taper = _taper_window(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1] + return taper[::-1] if reverse else taper + + +@dataclass(frozen=True) +class TaperRange(PatchOperation): + window_type: str = "hann" + invert: bool = False + relative: bool = False + samples: bool = False + kwargs: dict[str, Any] | None = None + axis: int | None = None + weight: Any = None + + def __init__(self, window_type: str = "hann", invert=False, relative=False, samples=False, **kwargs): + object.__setattr__(self, "window_type", window_type) + object.__setattr__(self, "invert", invert) + object.__setattr__(self, "relative", relative) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "weight", None) + + def bind(self, boundary: PatchBoundary): + kwargs = self.kwargs or {} + dim = next(key for key in kwargs if key in boundary.dims) + axis = boundary.axis(dim) + coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) + inds = _taper_coord_inds(coord, kwargs[dim], self.relative, self.samples) + weight = np.zeros(len(coord)) + for i1, i2, i3, i4 in inds: + weight[i1:i2] += _taper_curve(coord, i1, i2, self.window_type) + weight[i3:i4] += _taper_curve(coord, i3, i4, self.window_type, reverse=True) + weight[i2:i3] += 1 + if self.invert: + weight = np.abs(weight - np.max(weight)) + return replace(self, axis=axis, weight=np.asarray(weight)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)) + + +@dataclass(frozen=True) +class GaussianFilter(PatchOperation): + samples: bool = False + mode: str = "reflect" + cval: float = 0.0 + truncate: float = 4.0 + kwargs: dict[str, Any] | None = None + sigma: tuple[float, ...] = () + axes: tuple[int, ...] = () + + def __init__(self, samples=False, mode="reflect", cval=0.0, truncate=4.0, **kwargs): + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "cval", float(cval)) + object.__setattr__(self, "truncate", float(truncate)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "sigma", ()) + object.__setattr__(self, "axes", ()) + + def bind(self, boundary: PatchBoundary): + dimfo = get_dim_axis_value(_dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True) + axes = [] + sigma = [] + for dim, axis, value in dimfo: + sigma.append(float(boundary.coord(dim).get_sample_count(value, samples=self.samples))) + axes.append(axis) + return replace(self, axes=tuple(axes), sigma=tuple(sigma)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.gaussian_filter_kernel( + patch_tree.data, sigma=self.sigma, axes=self.axes, mode=self.mode, cval=self.cval, truncate=self.truncate + ) + ) + + +@dataclass(frozen=True) +class HampelFilter(PatchOperation): + threshold: float = 10.0 + samples: bool = False + approximate: bool = True + kwargs: dict[str, Any] | None = None + size: tuple[int, ...] = () + + def __init__(self, *, threshold=10.0, samples=False, approximate=True, **kwargs): + object.__setattr__(self, "threshold", float(threshold)) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "approximate", approximate) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "size", ()) + + def bind(self, boundary: PatchBoundary): + if self.threshold <= 0 or not np.isfinite(self.threshold): + raise ParameterError("hampel_filter threshold must be finite and greater than zero") + size = get_patch_window_size(_dummy_patch(boundary), self.kwargs or {}, self.samples, require_odd=True, warn_above=10, min_samples=3) + return replace(self, size=tuple(int(x) for x in size)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.hampel_filter_kernel( + patch_tree.data, size=self.size, threshold=self.threshold, approximate=self.approximate + ) + ) + + +@dataclass(frozen=True) +class PassFilter(PatchOperation): + corners: int = 4 + zerophase: bool = True + kwargs: dict[str, Any] | None = None + sos: Any = None + zi: Any = None + padlen: int | None = None + axis: int | None = None + + def __init__(self, corners=4, zerophase=True, **kwargs): + object.__setattr__(self, "corners", int(corners)) + object.__setattr__(self, "zerophase", bool(zerophase)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "sos", None) + object.__setattr__(self, "zi", None) + object.__setattr__(self, "padlen", None) + object.__setattr__(self, "axis", None) + + def bind(self, boundary: PatchBoundary): + from dascore.utils.misc import check_filter_kwargs + + dim, (arg1, arg2) = check_filter_kwargs(self.kwargs or {}) + filt_min, filt_max = get_filter_units(arg1, arg2, to_unit=boundary.coord(dim).units, dim=dim) + sr = get_dim_sampling_rate(_dummy_patch(boundary), dim) + sos = np.asarray(kernels.design_pass_filter_sos(sr, filt_min, filt_max, self.corners)) + return replace( + self, + sos=sos, + zi=kernels.pass_filter_initial_state(sos), + padlen=kernels.pass_filter_default_padlen(sos), + axis=boundary.axis(dim), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None and self.padlen is not None + return patch_tree.new( + data=kernels.pass_filter_kernel( + patch_tree.data, sos=self.sos, zi=self.zi, padlen=self.padlen, axis=self.axis, zerophase=self.zerophase + ) + ) + + +@dataclass(frozen=True) +class Pad(PatchOperation): + mode: str = "constant" + constant_values: Any = 0 + expand_coords: bool = True + samples: bool = False + kwargs: dict[str, Any] | None = None + data_pad_width: tuple[tuple[int, int], ...] = () + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def __init__(self, mode="constant", constant_values=0, expand_coords=True, samples=False, **kwargs): + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "constant_values", constant_values) + object.__setattr__(self, "expand_coords", expand_coords) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "data_pad_width", ()) + object.__setattr__(self, "out_boundary", None) + object.__setattr__(self, "out_coords", None) + object.__setattr__(self, "out_dtype_codes", None) + object.__setattr__(self, "out_dims", None) + + def bind(self, boundary: PatchBoundary): + patch = _dummy_patch(boundary) + pad_width = [(0, 0)] * len(patch.shape) + dimfo = get_dim_axis_value(patch, kwargs=self.kwargs or {}, allow_multiple=True) + for dim, axis, value in dimfo: + coord = patch.get_coord(dim, require_evenly_sampled=False) + if value in {"fft", "correlate"}: + target_length = len(coord) if value == "fft" else 2 * len(coord) - 1 + pad_tuple = (0, next_fast_len(target_length) - len(coord)) + else: + if not isinstance(value, (tuple, list)): + value = (value, value) + pad_tuple = ( + tuple(int(coord.get_sample_count(x)) for x in value) + if not self.samples + else tuple(int(x) for x in value) + ) + pad_width[axis] = tuple(pad_tuple) + out = dc_pad.func( + patch, mode=self.mode, constant_values=self.constant_values, expand_coords=self.expand_coords, samples=self.samples, **(self.kwargs or {}) + ) + out_tree, out_boundary = _tree_boundary_from_patch(out) + return replace( + self, + data_pad_width=tuple(pad_width), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=jnp.pad(patch_tree.data, self.data_pad_width, mode=self.mode, constant_values=self.constant_values), + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class Hilbert(PatchOperation): + dim: str + axis: int | None = None + + def bind(self, boundary: PatchBoundary): + if boundary.coord(self.dim).step is None: + raise dc.exceptions.CoordError(f"Coordinate {self.dim} is not evenly sampled as required by hilbert") + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=kernels.hilbert_kernel(patch_tree.data, axis=self.axis)) + + +@dataclass(frozen=True) +class Envelope(Hilbert): + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=kernels.envelope_kernel(patch_tree.data, axis=self.axis)) + + +@dataclass(frozen=True) +class Dft(PatchOperation): + method_name: ClassVar[str | None] = "dft" + dim: str | None | tuple[str, ...] + real: str | bool | None = None + pad: bool = True + axes: tuple[int, ...] = () + dxs: tuple[float, ...] = () + real_axis: int | None = None + pad_width: tuple[tuple[int, int], ...] = () + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary): + patch = _dummy_patch(boundary) + dims = list(iterate(self.dim if self.dim is not None else boundary.dims)) + real = dims[-1] if self.real is True else self.real + if isinstance(real, str) and real in dims: + dims.append(dims.pop(dims.index(real))) + pad_width = [(0, 0)] * len(boundary.dims) + work_patch = patch + if self.pad: + for dim in dims: + axis = work_patch.get_axis(dim) + target = next_fast_len(len(work_patch.get_coord(dim))) + pad_width[axis] = (0, target - len(work_patch.get_coord(dim))) + work_patch = dc_pad.func(work_patch, **{dim: "fft" for dim in dims}) + axes = tuple(work_patch.get_axis(dim) for dim in dims) + dxs = tuple(float(dc.to_float(work_patch.get_coord(dim).step)) for dim in dims) + out = dc_dft.func(patch, dim=self.dim, real=self.real, pad=self.pad) + out_tree, out_boundary = _tree_boundary_from_patch(out) + return replace( + self, + axes=axes, + dxs=dxs, + real_axis=work_patch.get_axis(real) if isinstance(real, str) and real in dims else None, + pad_width=tuple(pad_width), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + if any(before or after for before, after in self.pad_width): + data = jnp.pad(data, self.pad_width) + data = kernels.dft_kernel(data, axes=self.axes, dxs=self.dxs, real_axis=self.real_axis) + return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class Idft(PatchOperation): + method_name: ClassVar[str | None] = "idft" + dim: str | None | tuple[str, ...] = None + axes: tuple[int, ...] = () + steps: tuple[float, ...] = () + sizes: tuple[int, ...] | None = None + real: bool = False + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary): + patch = _dummy_patch(boundary, dtype=np.complex128) + dims, _steps, axes, real = _get_idft_dims_steps_axis(patch, self.dim) + out = dc_idft.func(patch, dim=self.dim) + out_tree, out_boundary = _tree_boundary_from_patch(out) + sizes = tuple(out.shape[axis] for axis in axes) + new_dims = FourierTransformatter().rename_dims(dims, forward=False) + out_steps = tuple( + float(dc.to_float(out.get_coord(dim).step)) for dim in new_dims + ) + return replace( + self, + axes=tuple(axes), + steps=out_steps, + sizes=sizes, + real=real, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.idft_kernel(patch_tree.data, axes=self.axes, new_steps=self.steps, sizes=self.sizes, real=self.real) + return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class Whiten(PatchOperation): + smooth_size: float | None = None + water_level: float | None = None + kwargs: dict[str, Any] | None = None + axis: int | None = None + window_len: int | None = None + sample_step: float = 1.0 + patch_template: Any = None + + def __init__(self, smooth_size=None, water_level=None, **kwargs): + object.__setattr__(self, "smooth_size", smooth_size) + object.__setattr__(self, "water_level", water_level) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "window_len", None) + object.__setattr__(self, "sample_step", 1.0) + object.__setattr__(self, "patch_template", None) + + def bind(self, boundary: PatchBoundary): + kwargs = self.kwargs or {} + dim = next(iter(kwargs), "time" if "time" in boundary.dims else boundary.dims[-1]) + axis = boundary.axis(dim) + sample_step = abs(float(dc.to_float(boundary.coord(dim).step))) + window_len = None + if self.smooth_size is not None: + fft_dim = FourierTransformatter().rename_dims(dim)[0] + fft_patch = dc_dft.func(_dummy_patch(boundary), dim=dim, real=True) + coord = fft_patch.get_coord(fft_dim) + window_len = coord.get_sample_count(self.smooth_size, enforce_lt_coord=True) + return replace( + self, + axis=axis, + window_len=window_len, + sample_step=sample_step, + patch_template=_dummy_patch(boundary), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + source = jnp.asarray(patch_tree.data) + shape_dtype = jax.ShapeDtypeStruct(source.shape, source.dtype) + + def _callback(data): + patch = self.patch_template.new(data=np.asarray(data)) + kwargs = self.kwargs or {} + return np.asarray( + patch.whiten.func( + patch, + smooth_size=self.smooth_size, + water_level=self.water_level, + **kwargs, + ).data + ) + + return patch_tree.new(data=jax.pure_callback(_callback, shape_dtype, source)) + + +@dataclass(frozen=True) +class Fbe(PatchOperation): + overlap: Any = 0 + samples: bool = False + detrend: bool = False + taper_window: str | np.ndarray | tuple = "hann" + fmin: float | None = None + fmax: float | None = None + kwargs: dict[str, Any] | None = None + prepared: dict[str, Any] | None = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def __init__(self, overlap=0, samples=False, detrend=False, taper_window="hann", fmin=None, fmax=None, **kwargs): + object.__setattr__(self, "overlap", overlap) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "detrend", detrend) + object.__setattr__(self, "taper_window", taper_window) + object.__setattr__(self, "fmin", fmin) + object.__setattr__(self, "fmax", fmax) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "prepared", None) + object.__setattr__(self, "out_boundary", None) + object.__setattr__(self, "out_coords", None) + object.__setattr__(self, "out_dtype_codes", None) + object.__setattr__(self, "out_dims", None) + + def bind(self, boundary: PatchBoundary): + patch = _dummy_patch(boundary) + call_kwargs = dict(self.kwargs or {}) + dim, axis, val = get_dim_axis_value(patch, kwargs=call_kwargs)[0] + coord = patch.get_coord(dim, require_evenly_sampled=True) + window_samples = coord.get_sample_count(val, samples=self.samples, enforce_lt_coord=True) + step = dc.to_float(coord.step) + sampling_rate = 1 / abs(step) + window = self.taper_window if isinstance(self.taper_window, np.ndarray) else get_window(self.taper_window, window_samples, fftbins=False) + overlap = coord[:window_samples].get_sample_count(self.overlap, samples=self.samples, enforce_lt_coord=True) if self.overlap is not None else 0 + hop = window_samples - overlap + stft = ShortTimeFFT(win=window, hop=hop, fs=sampling_rate, fft_mode="onesided", mfft=window_samples) + frame_times = np.asarray(stft.t(len(coord))) + frame_starts = np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid + frequencies = np.asarray(stft.f, dtype=np.float64) + mask = np.ones(len(frequencies), dtype=bool) + if self.fmin is not None: + mask &= frequencies >= self.fmin + if self.fmax is not None: + mask &= frequencies <= self.fmax + prepared = { + "axis": axis, + "window": np.asarray(window), + "frame_starts": frame_starts, + "selected_bins": np.flatnonzero(mask).astype(np.int64), + "sample_step": step, + "detrend": self.detrend, + } + # Reuse the existing DASCore STFT metadata construction by running on zeros. + out = patch.stft(**{dim: val}, overlap=self.overlap, samples=self.samples, detrend=self.detrend, taper_window=self.taper_window).abs() + ft_dim = next(dim_name for dim_name in out.dims if dim_name.startswith("ft_")) + if self.fmin is not None or self.fmax is not None: + out = out.select(**{ft_dim: (self.fmin, self.fmax)}) + out = out.sum(dim=ft_dim, dim_reduce="squeeze") + out_tree, out_boundary = _tree_boundary_from_patch(out) + return replace( + self, + prepared=prepared, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.prepared is not None + data = kernels.banded_stft_kernel(patch_tree.data, **self.prepared) + return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/__init__.py b/src/dasjax/operations/__init__.py deleted file mode 100644 index 1733457..0000000 --- a/src/dasjax/operations/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -"""Operation registry package.""" - -from .patch_ops import EagerPatchOp, OpResult, PatchOp, PatchSpec, PatchState -from .registry import ( - get_operation, - iter_operations, - list_operations, -) -from .types import ExecutionPolicy, OperationCase, OperationSpec - -__all__ = [ - "ExecutionPolicy", - "EagerPatchOp", - "OpResult", - "OperationCase", - "OperationSpec", - "PatchOp", - "PatchSpec", - "PatchState", - "get_operation", - "iter_operations", - "list_operations", -] diff --git a/src/dasjax/operations/basic/__init__.py b/src/dasjax/operations/basic/__init__.py deleted file mode 100644 index 6969b8a..0000000 --- a/src/dasjax/operations/basic/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""Basic operation family.""" - -from .specs import OPERATIONS - -__all__ = ["OPERATIONS"] diff --git a/src/dasjax/operations/basic/impl.py b/src/dasjax/operations/basic/impl.py deleted file mode 100644 index ba9e72b..0000000 --- a/src/dasjax/operations/basic/impl.py +++ /dev/null @@ -1,404 +0,0 @@ -"""Executable implementations for basic operations.""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any - -import jax.numpy as jnp -from dascore.constants import PatchType -from dascore.proc.basic import flip as dc_flip -from dascore.proc.basic import roll as dc_roll -from dascore.proc.basic import standardize as dc_standardize - -from dasjax import kernels - -from ..common import get_axis_from_dims, update_patch -from ..patch_ops import EagerPatchOp, PatchOp - - -@dataclass(frozen=True) -class IdentityOp(PatchOp): - """Compiled identity operation.""" - - def kernel(self, data): - return {"data": kernels.identity_kernel(data)} - - -@dataclass(frozen=True) -class ScaleOp(PatchOp): - """Compiled scale operation with signature-inferred state binding.""" - - factor: float - - def kernel(self, data): - return {"data": kernels.scale_kernel(data, self.factor)} - - -@dataclass(frozen=True) -class AddOp(PatchOp): - """Compiled add operation.""" - - value: float - - def kernel(self, data): - return {"data": kernels.add_kernel(data, self.value)} - - -@dataclass(frozen=True) -class AbsOp(PatchOp): - """Compiled abs operation.""" - - def kernel(self, data): - return {"data": kernels.abs_kernel(data)} - - -@dataclass(frozen=True) -class ClipOp(PatchOp): - """Compiled clip operation.""" - - min_value: float - max_value: float - - def kernel(self, data): - return {"data": kernels.clip_kernel(data, self.min_value, self.max_value)} - - -@dataclass(frozen=True) -class RealOp(PatchOp): - """Compiled real operation.""" - - def kernel(self, data): - return {"data": kernels.real_kernel(data)} - - -@dataclass(frozen=True) -class ImagOp(PatchOp): - """Compiled imag operation.""" - - def kernel(self, data): - return {"data": kernels.imag_kernel(data)} - - -@dataclass(frozen=True) -class AngleOp(PatchOp): - """Compiled angle operation.""" - - def kernel(self, data): - return {"data": kernels.angle_kernel(data)} - - -@dataclass(frozen=True) -class ConjOp(PatchOp): - """Compiled conj operation.""" - - def kernel(self, data): - return {"data": kernels.conj_kernel(data)} - - -@dataclass(frozen=True) -class FlipOp(PatchOp): - """Compiled flip operation over patch state.""" - - dims: tuple[str, ...] - data_axes: tuple[int, ...] - coord_axes: dict[str, tuple[int, ...]] - flip_coords: bool = True - mutates_spec = False - - @classmethod - def prepare( - cls, - patch: PatchType, - *dims: str, - flip_coords: bool = True, - ) -> "FlipOp": - resolved_dims = tuple(dims) if dims else tuple(patch.dims) - data_axes = tuple(patch.get_axis(dim) for dim in resolved_dims) - coord_axes: dict[str, tuple[int, ...]] = {} - if flip_coords: - for name, coord_dims in patch.coords.dim_map.items(): - axes = tuple( - idx - for idx, coord_dim in enumerate(coord_dims) - if coord_dim in resolved_dims - ) - if axes: - coord_axes[name] = axes - return cls( - dims=resolved_dims, - data_axes=data_axes, - coord_axes=coord_axes, - flip_coords=flip_coords, - ) - - def kernel(self, state): - coords = state.coords - out = {"data": jnp.flip(state.data, axis=self.data_axes)} - if self.flip_coords: - new_coords = {} - for name, axes in self.coord_axes.items(): - new_coords[name] = jnp.flip(coords[name], axis=axes) - if new_coords: - out["coords"] = new_coords - return out - - -@dataclass(frozen=True) -class RollOp(PatchOp): - """Compiled roll operation using selected-axis inference.""" - - shift: int - selected_dim: str - requires_materialized_patch_for_prepare = False - - @classmethod - def prepare( - cls, - patch: PatchType, - samples: bool = False, - update_coord: bool = False, - **kwargs, - ) -> "RollOp": - if update_coord: - raise NotImplementedError( - "Compiled roll currently requires update_coord=False." - ) - selected_dim, _, coord = cls._resolve_selected_context(patch, (), kwargs) - shift = int(coord.get_sample_count(kwargs[selected_dim], samples=samples)) - op = cls(shift=shift, selected_dim=selected_dim) - object.__setattr__(op, "_prepared_attrs", {}) - object.__setattr__( - op, - "_prepared_selected", - cls._prepare_selected(patch, (), {"dim": selected_dim}, op), - ) - cls._validate_kernel_bindings(patch, op) - return op - - def kernel(self, data, selected_axis): - return {"data": kernels.roll_kernel(data, shift=self.shift, axis=selected_axis)} - - -@dataclass(frozen=True) -class StandardizeOp(EagerPatchOp): - """Unified eager-backed standardize operation.""" - - patch_impl_fn = staticmethod(dc_standardize.func) - - -def identity_patch(patch: PatchType) -> PatchType: - return patch - - -def identity_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.identity_kernel(data), coord_leaves - - -def scale_patch(patch: PatchType, factor: float) -> PatchType: - return update_patch(patch, kernels.scale_kernel(patch.data, factor)) - - -def scale_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - factor: float, - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.scale_kernel(data, factor), coord_leaves - - -def add_patch(patch: PatchType, value: float) -> PatchType: - return update_patch(patch, kernels.add_kernel(patch.data, value)) - - -def add_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - value: float, - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.add_kernel(data, value), coord_leaves - - -def abs_patch(patch: PatchType) -> PatchType: - return update_patch(patch, kernels.abs_kernel(patch.data)) - - -def abs_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.abs_kernel(data), coord_leaves - - -def clip_patch(patch: PatchType, min_value: float, max_value: float) -> PatchType: - return update_patch(patch, kernels.clip_kernel(patch.data, min_value, max_value)) - - -def clip_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - min_value: float, - max_value: float, - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.clip_kernel(data, min_value, max_value), coord_leaves - - -def real_patch(patch: PatchType) -> PatchType: - return update_patch(patch, kernels.real_kernel(patch.data)) - - -def real_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.real_kernel(data), coord_leaves - - -def imag_patch(patch: PatchType) -> PatchType: - return update_patch(patch, kernels.imag_kernel(patch.data)) - - -def imag_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.imag_kernel(data), coord_leaves - - -def angle_patch(patch: PatchType) -> PatchType: - return update_patch(patch, kernels.angle_kernel(patch.data)) - - -def angle_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.angle_kernel(data), coord_leaves - - -def conj_patch(patch: PatchType) -> PatchType: - return update_patch(patch, kernels.conj_kernel(patch.data)) - - -def conj_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.conj_kernel(data), coord_leaves - - -def flip_patch( - patch: PatchType, - *dims: str, - flip_coords: bool = True, -) -> PatchType: - return dc_flip.func(patch, *dims, flip_coords=flip_coords) - - -def prepare_roll_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - samples = bool(call_kwargs.pop("samples", False)) - update_coord = bool(call_kwargs.pop("update_coord", False)) - dim = next(key for key in call_kwargs if key in patch.dims) - axis = patch.get_axis(dim) - coord = patch.get_coord(dim) - shift = int(coord.get_sample_count(call_kwargs[dim], samples=samples)) - return (), {"axis": axis, "shift": shift, "update_coord": update_coord} - - -def validate_roll_compiled_input( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> None: - _ = patch, args - if kwargs.get("update_coord", False): - raise NotImplementedError( - "Compiled roll currently requires update_coord=False." - ) - - -def guard_compiled_roll_case( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[type[Exception], str] | None: - _ = patch, args - if kwargs.get("update_coord", False): - return ( - NotImplementedError, - "Compiled roll currently requires update_coord=False.", - ) - return None - - -def roll_patch( - patch: PatchType, - samples: bool = False, - update_coord: bool = False, - **kwargs, -) -> PatchType: - return dc_roll.func(patch, samples=samples, update_coord=update_coord, **kwargs) - - -def roll_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - axis: int, - shift: int, - update_coord: bool = False, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims, update_coord - return kernels.roll_kernel(data, shift=shift, axis=axis), coord_leaves - - -def standardize_patch(patch: PatchType, dim: str) -> PatchType: - return dc_standardize.func(patch, dim=dim) - - -def standardize_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - dim: str, -) -> tuple[Any, tuple[Any, ...]]: - axis = get_axis_from_dims(dims, dim) - return kernels.standardize_kernel(data, axis=axis), coord_leaves diff --git a/src/dasjax/operations/basic/specs.py b/src/dasjax/operations/basic/specs.py deleted file mode 100644 index 63d95a7..0000000 --- a/src/dasjax/operations/basic/specs.py +++ /dev/null @@ -1,224 +0,0 @@ -"""Registry specs for basic operations.""" - -from __future__ import annotations - -import dascore as dc -from dascore.proc.basic import angle as dc_angle -from dascore.proc.basic import conj as dc_conj -from dascore.proc.basic import flip as dc_flip -from dascore.proc.basic import imag as dc_imag -from dascore.proc.basic import real as dc_real -from dascore.proc.basic import roll as dc_roll -from dascore.proc.basic import standardize as dc_standardize - -from dasjax import kernels - -from ..common import prepare_complex_patch -from ..types import ExecutionPolicy, OperationCase, OperationSpec, empty_call -from . import impl - -OPERATIONS: tuple[OperationSpec, ...] = ( - OperationSpec( - name="identity", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history=None)(impl.identity_patch), - patch_op_cls=impl.IdentityOp, - leaf_transform=impl.identity_leaves, - test_cases=( - OperationCase( - case_id="identity", - resolve_call=empty_call, - baseline=lambda patch, args, kwargs: patch, - ), - ), - ), - OperationSpec( - name="scale", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.scale_patch), - patch_op_cls=impl.ScaleOp, - leaf_transform=impl.scale_leaves, - test_cases=tuple( - OperationCase( - case_id=f"scale-{value}", - resolve_call=lambda patch, value=value: ((value,), {}), - baseline=lambda patch, args, kwargs: patch * args[0], - ) - for value in (2.0, -0.75) - ), - ), - OperationSpec( - name="add", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.add_patch), - patch_op_cls=impl.AddOp, - leaf_transform=impl.add_leaves, - test_cases=tuple( - OperationCase( - case_id=f"add-{value}", - resolve_call=lambda patch, value=value: ((value,), {}), - baseline=lambda patch, args, kwargs: patch + args[0], - ) - for value in (2.0, -0.75) - ), - ), - OperationSpec( - name="abs", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.abs_patch), - patch_op_cls=impl.AbsOp, - leaf_transform=impl.abs_leaves, - test_cases=( - OperationCase( - case_id="abs", - resolve_call=empty_call, - prepare_patch=prepare_complex_patch, - baseline=lambda patch, args, kwargs: patch.abs(), - ), - ), - ), - OperationSpec( - name="clip", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.clip_patch), - patch_op_cls=impl.ClipOp, - leaf_transform=impl.clip_leaves, - test_cases=tuple( - OperationCase( - case_id=f"clip-{low}-{high}", - resolve_call=lambda patch, low=low, high=high: ((low, high), {}), - baseline=lambda patch, args, kwargs, low=low, high=high: patch.update( - data=kernels.clip_kernel(patch.data, low, high) - ), - ) - for low, high in ((-0.25, 0.25), (-1.0, 1.5)) - ), - ), - OperationSpec( - name="real", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.real_patch), - patch_op_cls=impl.RealOp, - leaf_transform=impl.real_leaves, - test_cases=( - OperationCase( - case_id="real", - resolve_call=empty_call, - prepare_patch=prepare_complex_patch, - baseline=lambda patch, args, kwargs: dc_real.func(patch), - ), - ), - ), - OperationSpec( - name="imag", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.imag_patch), - patch_op_cls=impl.ImagOp, - leaf_transform=impl.imag_leaves, - test_cases=( - OperationCase( - case_id="imag", - resolve_call=empty_call, - prepare_patch=prepare_complex_patch, - baseline=lambda patch, args, kwargs: dc_imag.func(patch), - ), - ), - ), - OperationSpec( - name="angle", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.angle_patch), - patch_op_cls=impl.AngleOp, - leaf_transform=impl.angle_leaves, - test_cases=( - OperationCase( - case_id="angle", - resolve_call=empty_call, - prepare_patch=prepare_complex_patch, - baseline=lambda patch, args, kwargs: dc_angle.func(patch), - ), - ), - ), - OperationSpec( - name="conj", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.conj_patch), - patch_op_cls=impl.ConjOp, - leaf_transform=impl.conj_leaves, - test_cases=( - OperationCase( - case_id="conj", - resolve_call=empty_call, - prepare_patch=prepare_complex_patch, - baseline=lambda patch, args, kwargs: dc_conj.func(patch), - ), - ), - ), - OperationSpec( - name="flip", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.flip_patch), - patch_op_cls=impl.FlipOp, - test_cases=( - OperationCase( - case_id="flip-time", - resolve_call=lambda patch: ((patch.dims[-1],), {"flip_coords": True}), - baseline=lambda patch, args, kwargs: dc_flip.func( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="flip-all-no-coords", - resolve_call=lambda patch: (tuple(patch.dims), {"flip_coords": False}), - baseline=lambda patch, args, kwargs: dc_flip.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="roll", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.roll_patch), - patch_op_cls=impl.RollOp, - leaf_transform=impl.roll_leaves, - prepare_call=impl.prepare_roll_call, - validate_compiled_patch=impl.validate_roll_compiled_input, - test_cases=( - OperationCase( - case_id="roll-samples", - resolve_call=lambda patch: ((), {"samples": True, patch.dims[-1]: 5}), - baseline=lambda patch, args, kwargs: dc_roll.func( - patch, *args, **kwargs - ), - compiled_guard=impl.guard_compiled_roll_case, - ), - OperationCase( - case_id="roll-coord-update", - resolve_call=lambda patch: ( - (), - {"samples": True, "update_coord": True, patch.dims[-1]: 3}, - ), - baseline=lambda patch, args, kwargs: dc_roll.func( - patch, *args, **kwargs - ), - compiled_guard=impl.guard_compiled_roll_case, - ), - ), - ), - OperationSpec( - name="standardize", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.standardize_patch), - patch_op_cls=impl.StandardizeOp, - test_cases=( - OperationCase( - case_id="standardize-time", - resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}), - baseline=lambda patch, args, kwargs: dc_standardize.func( - patch, *args, **kwargs - ), - ), - ), - ), -) diff --git a/src/dasjax/operations/common.py b/src/dasjax/operations/common.py deleted file mode 100644 index c571e4b..0000000 --- a/src/dasjax/operations/common.py +++ /dev/null @@ -1,139 +0,0 @@ -"""Shared helpers used by operation-family modules.""" - -from __future__ import annotations - -from collections.abc import Callable -from typing import Any - -import dascore as dc -import numpy as np -from dascore.constants import PatchType -from dascore.exceptions import ParameterError - -from .types import OperationSpec - - -def get_axis(patch: PatchType, dim: str | None) -> int | None: - if dim is None: - return None - try: - return patch.dims.index(dim) - except ValueError as exc: - msg = f"Patch does not contain dimension {dim!r}." - raise ValueError(msg) from exc - - -def get_axis_from_dims(dims: tuple[str, ...], dim: str | None) -> int | None: - if dim is None: - return None - try: - return dims.index(dim) - except ValueError as exc: - msg = f"Patch does not contain dimension {dim!r}." - raise ValueError(msg) from exc - - -def update_patch(patch: PatchType, data: Any) -> PatchType: - return patch.update(data=np.asarray(data)) - - -def prepare_operation_call( - operation: OperationSpec, - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - if operation.prepare_call is None: - return args, kwargs - return operation.prepare_call(patch, args, kwargs) - - -def offset_patch(patch: PatchType, offset: float) -> PatchType: - return patch.update(data=patch.data + offset) - - -def baseline_update( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], - fn: Callable[..., Any], -) -> PatchType: - return patch.update(data=np.asarray(fn(patch.data, *args, **kwargs))) - - -def baseline_patch_method( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], - method_name: str, -) -> PatchType: - return getattr(patch, method_name)(*args, **kwargs) - - -def get_evenly_sampled_dim(patch: PatchType) -> str: - for dim in reversed(patch.dims): - if patch.get_coord(dim).step is not None: - return dim - msg = f"Patch does not contain an evenly sampled dimension: {patch.dims}" - raise ParameterError(msg) - - -def get_preferred_transform_dim(patch: PatchType) -> str: - for dim in reversed(patch.dims): - if patch.get_coord(dim).step is not None: - return dim - return patch.dims[-1] - - -def resolve_even_dim_call( - patch: PatchType, - **kwargs: Any, -) -> tuple[tuple[Any, ...], dict[str, Any]]: - out = dict(kwargs) - out["dim"] = get_preferred_transform_dim(patch) - return (), out - - -def prepare_complex_patch(patch: PatchType) -> PatchType: - data = np.asarray(patch.data, dtype=np.complex128) - return patch.update(data=data + 1j * data) - - -def prepare_fourier_patch(patch: PatchType) -> PatchType: - from dascore.transform.fourier import dft as dc_dft - - dim = get_preferred_transform_dim(patch) - try: - return dc_dft.func(patch, dim=dim, real=True, pad=False) - except Exception: - return patch - - -def prepare_even_patch_for_dim(patch: PatchType) -> PatchType: - dim = get_preferred_transform_dim(patch) - coord = patch.get_coord(dim) - if coord.step is not None: - return patch - new_coord = dc.get_coord(start=0, stop=len(coord), step=1, units=coord.units) - return patch.update(coords=patch.coords.update(**{dim: new_coord})) - - -def validate_registry(operations: tuple[OperationSpec, ...]) -> None: - seen: set[str] = set() - for operation in operations: - if operation.name in seen: - msg = f"Duplicate jax patch operation {operation.name!r}." - raise ValueError(msg) - seen.add(operation.name) - if ( - operation.execution_policy.value == "leaf" - and operation.leaf_transform is None - ): - msg = f"Leaf operation {operation.name!r} must define leaf_transform." - raise ValueError(msg) - if ( - operation.execution_policy.value == "patch" - and operation.leaf_transform is not None - ): - msg = f"Patch operation {operation.name!r} must not define leaf_transform." - raise ValueError(msg) diff --git a/src/dasjax/operations/filters/__init__.py b/src/dasjax/operations/filters/__init__.py deleted file mode 100644 index 06db4fb..0000000 --- a/src/dasjax/operations/filters/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""Filter operation family.""" - -from .specs import OPERATIONS - -__all__ = ["OPERATIONS"] diff --git a/src/dasjax/operations/filters/impl.py b/src/dasjax/operations/filters/impl.py deleted file mode 100644 index e11184c..0000000 --- a/src/dasjax/operations/filters/impl.py +++ /dev/null @@ -1,415 +0,0 @@ -"""Executable implementations for filter operations.""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any - -import numpy as np -from dascore.constants import PatchType -from dascore.exceptions import ParameterError -from dascore.units import get_filter_units -from dascore.utils.misc import check_filter_kwargs -from dascore.utils.patch import ( - get_dim_axis_value, - get_dim_sampling_rate, - get_patch_window_size, -) - -from dasjax import kernels - -from ..common import update_patch -from ..patch_ops import PatchOp - - -@dataclass(frozen=True) -class GaussianFilterOp(PatchOp): - """Compiled gaussian_filter operation.""" - - sigma: tuple[float, ...] - axes: tuple[int, ...] - mode: str = "reflect" - cval: float = 0.0 - truncate: float = 4.0 - requires_materialized_patch_for_prepare = True - - @classmethod - def prepare( - cls, - patch: PatchType, - samples: bool = False, - mode: str = "reflect", - cval: float = 0.0, - truncate: float = 4.0, - **kwargs, - ) -> "GaussianFilterOp": - _, prepared = prepare_gaussian_call( - patch, - (), - { - "samples": samples, - "mode": mode, - "cval": cval, - "truncate": truncate, - **kwargs, - }, - ) - return cls(**prepared) - - def kernel(self, data): - return { - "data": kernels.gaussian_filter_kernel( - data, - sigma=self.sigma, - axes=self.axes, - mode=self.mode, - cval=self.cval, - truncate=self.truncate, - ) - } - - -@dataclass(frozen=True) -class HampelFilterOp(PatchOp): - """Compiled hampel_filter operation.""" - - size: tuple[int, ...] - threshold: float - approximate: bool = True - requires_materialized_patch_for_prepare = True - - @classmethod - def prepare( - cls, - patch: PatchType, - *, - threshold: float = 10.0, - samples: bool = False, - approximate: bool = True, - **kwargs, - ) -> "HampelFilterOp": - validate_hampel_filter_patch_input(patch, threshold=threshold) - validate_hampel_filter_compiled_input( - patch, - (), - { - "threshold": threshold, - "samples": samples, - "approximate": approximate, - **kwargs, - }, - ) - _, prepared = prepare_hampel_call( - patch, - (), - { - "threshold": threshold, - "samples": samples, - "approximate": approximate, - **kwargs, - }, - ) - return cls(**prepared) - - def kernel(self, data): - return { - "data": kernels.hampel_filter_kernel( - data, - size=self.size, - threshold=self.threshold, - approximate=self.approximate, - ) - } - - -@dataclass(frozen=True) -class PassFilterOp(PatchOp): - """Compiled pass_filter operation.""" - - sos: Any - zi: Any - padlen: int - axis: int - zerophase: bool = True - requires_materialized_patch_for_prepare = True - - @classmethod - def prepare( - cls, - patch: PatchType, - corners: int = 4, - zerophase: bool = True, - **kwargs, - ) -> "PassFilterOp": - _, prepared = prepare_pass_filter_call( - patch, - (), - {"corners": corners, "zerophase": zerophase, **kwargs}, - ) - return cls(**prepared) - - def kernel(self, data): - return { - "data": kernels.pass_filter_kernel( - data, - sos=self.sos, - zi=self.zi, - padlen=self.padlen, - axis=self.axis, - zerophase=self.zerophase, - ) - } - - -def prepare_gaussian_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - samples = call_kwargs.pop("samples", False) - mode = call_kwargs.pop("mode", "reflect") - cval = float(call_kwargs.pop("cval", 0.0)) - truncate = float(call_kwargs.pop("truncate", 4.0)) - dimfo = get_dim_axis_value(patch, kwargs=call_kwargs, allow_multiple=True) - axes = [] - sigma = [] - for dim, axis, value in dimfo: - coord = patch.get_coord(dim) - sigma.append(float(coord.get_sample_count(value, samples=samples))) - axes.append(axis) - return (), { - "sigma": tuple(sigma), - "axes": tuple(axes), - "mode": mode, - "cval": cval, - "truncate": truncate, - } - - -def gaussian_filter_patch( - patch: PatchType, - samples: bool = False, - mode: str = "reflect", - cval: float = 0.0, - truncate: float = 4.0, - **kwargs, -) -> PatchType: - _, prepared = prepare_gaussian_call( - patch, - (), - { - "samples": samples, - "mode": mode, - "cval": cval, - "truncate": truncate, - **kwargs, - }, - ) - return update_patch(patch, kernels.gaussian_filter_kernel(patch.data, **prepared)) - - -def gaussian_filter_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - sigma: tuple[float, ...], - axes: tuple[int, ...], - mode: str = "reflect", - cval: float = 0.0, - truncate: float = 4.0, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.gaussian_filter_kernel( - data, sigma=sigma, axes=axes, mode=mode, cval=cval, truncate=truncate - ), coord_leaves - - -def validate_hampel_filter_patch_input( - patch: PatchType, - threshold: float = 10.0, - **kwargs, -) -> None: - _ = patch, kwargs - if threshold <= 0 or not np.isfinite(threshold): - raise ParameterError( - "hampel_filter threshold must be finite and greater than zero" - ) - - -def validate_hampel_filter_compiled_input( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> None: - validate_hampel_filter_patch_input(patch, **kwargs) - if not kwargs.get("approximate", True): - raise NotImplementedError( - "Compiled hampel_filter currently requires approximate=True." - ) - if not kernels.is_finite_array(patch.data): - raise NotImplementedError( - "Compiled hampel_filter currently requires finite input data." - ) - - -def fallback_gaussian_filter_reason( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> str | None: - _ = patch, args, kwargs - return "gaussian_filter uses a host callback in compiled pipelines." - - -def fallback_hampel_filter_reason( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> str | None: - _ = args - if not kwargs.get("approximate", True): - return "hampel_filter(approximate=False) is not natively compiled." - if not kernels.is_finite_array(patch.data): - return "hampel_filter with non-finite input data is not natively compiled." - return None - - -def guard_compiled_hampel_case( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[type[Exception], str] | None: - _ = args - if not kwargs.get("approximate", True): - return ( - NotImplementedError, - "Compiled hampel_filter currently requires approximate=True.", - ) - if not kernels.is_finite_array(patch.data): - return ( - NotImplementedError, - "Compiled hampel_filter currently requires finite input data.", - ) - return None - - -def prepare_hampel_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - threshold = float(call_kwargs.pop("threshold", 10.0)) - samples = call_kwargs.pop("samples", False) - approximate = bool(call_kwargs.pop("approximate", True)) - size = get_patch_window_size( - patch, call_kwargs, samples, require_odd=True, warn_above=10, min_samples=3 - ) - return (), { - "size": tuple(int(x) for x in size), - "threshold": threshold, - "approximate": approximate, - } - - -def hampel_filter_patch( - patch: PatchType, - *, - threshold: float = 10.0, - samples: bool = False, - approximate: bool = True, - **kwargs, -) -> PatchType: - validate_hampel_filter_patch_input(patch, threshold=threshold) - _, prepared = prepare_hampel_call( - patch, - (), - { - "threshold": threshold, - "samples": samples, - "approximate": approximate, - **kwargs, - }, - ) - if approximate and kernels.is_finite_array(patch.data): - return update_patch(patch, kernels.hampel_filter_kernel(patch.data, **prepared)) - return update_patch( - patch, kernels.hampel_filter_callback_kernel(patch.data, **prepared) - ) - - -def hampel_filter_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - size: tuple[int, ...], - threshold: float, - approximate: bool = True, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.hampel_filter_kernel( - data, size=size, threshold=threshold, approximate=approximate - ), coord_leaves - - -def prepare_pass_filter_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - corners = int(call_kwargs.pop("corners", 4)) - zerophase = bool(call_kwargs.pop("zerophase", True)) - dim, (arg1, arg2) = check_filter_kwargs(call_kwargs) - coord_units = patch.coords.coord_map[dim].units - filt_min, filt_max = get_filter_units(arg1, arg2, to_unit=coord_units, dim=dim) - - def pass_filter() -> float: - return get_dim_sampling_rate(patch, dim) - - sr = pass_filter() - sos = kernels.design_pass_filter_sos(sr, filt_min, filt_max, corners) - return (), { - "sos": np.asarray(sos), - "zi": kernels.pass_filter_initial_state(np.asarray(sos)), - "padlen": kernels.pass_filter_default_padlen(np.asarray(sos)), - "axis": patch.get_axis(dim), - "zerophase": zerophase, - } - - -def pass_filter_patch( - patch: PatchType, - corners: int = 4, - zerophase: bool = True, - **kwargs, -) -> PatchType: - _, prepared = prepare_pass_filter_call( - patch, - (), - {"corners": corners, "zerophase": zerophase, **kwargs}, - ) - return update_patch(patch, kernels.pass_filter_kernel(patch.data, **prepared)) - - -def pass_filter_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - sos: Any, - zi: Any, - padlen: int, - axis: int, - zerophase: bool = True, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.pass_filter_kernel( - data, sos=sos, zi=zi, padlen=padlen, axis=axis, zerophase=zerophase - ), coord_leaves diff --git a/src/dasjax/operations/filters/specs.py b/src/dasjax/operations/filters/specs.py deleted file mode 100644 index 66f771d..0000000 --- a/src/dasjax/operations/filters/specs.py +++ /dev/null @@ -1,122 +0,0 @@ -"""Registry specs for filter operations.""" - -from __future__ import annotations - -import dascore as dc - -from ..common import baseline_patch_method, prepare_even_patch_for_dim -from ..types import ExecutionPolicy, OperationCase, OperationSpec -from . import impl - -OPERATIONS: tuple[OperationSpec, ...] = ( - OperationSpec( - name="gaussian_filter", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.gaussian_filter_patch), - patch_op_cls=impl.GaussianFilterOp, - leaf_transform=impl.gaussian_filter_leaves, - prepare_call=impl.prepare_gaussian_call, - compiled_fallback_reason=impl.fallback_gaussian_filter_reason, - test_cases=( - OperationCase( - case_id="gaussian-filter-default", - resolve_call=lambda patch: ((), {patch.dims[-1]: 3, "samples": True}), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "gaussian_filter" - ), - ), - OperationCase( - case_id="gaussian-filter-constant", - resolve_call=lambda patch: ( - (), - { - patch.dims[0]: 3, - "samples": True, - "mode": "constant", - "cval": 0.25, - }, - ), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "gaussian_filter" - ), - ), - ), - ), - OperationSpec( - name="hampel_filter", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.hampel_filter_patch), - patch_op_cls=impl.HampelFilterOp, - leaf_transform=impl.hampel_filter_leaves, - prepare_call=impl.prepare_hampel_call, - validate_patch=impl.validate_hampel_filter_patch_input, - validate_compiled_patch=impl.validate_hampel_filter_compiled_input, - compiled_fallback_reason=impl.fallback_hampel_filter_reason, - test_cases=( - OperationCase( - case_id="hampel-filter-approximate", - resolve_call=lambda patch: ( - (), - { - patch.dims[-1]: 3, - "samples": True, - "threshold": 3.5, - "approximate": True, - }, - ), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "hampel_filter" - ), - compiled_guard=impl.guard_compiled_hampel_case, - ), - OperationCase( - case_id="hampel-filter-exact", - resolve_call=lambda patch: ( - (), - { - patch.dims[-1]: 3, - "samples": True, - "threshold": 3.5, - "approximate": False, - }, - ), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "hampel_filter" - ), - compiled_guard=impl.guard_compiled_hampel_case, - ), - ), - ), - OperationSpec( - name="pass_filter", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.pass_filter_patch), - patch_op_cls=impl.PassFilterOp, - leaf_transform=impl.pass_filter_leaves, - prepare_call=impl.prepare_pass_filter_call, - test_cases=( - OperationCase( - case_id="pass-filter-bandpass", - resolve_call=lambda patch: ( - (), - {patch.dims[-1]: (1.0, 10.0), "corners": 4, "zerophase": True}, - ), - prepare_patch=prepare_even_patch_for_dim, - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "pass_filter" - ), - ), - OperationCase( - case_id="pass-filter-lowpass", - resolve_call=lambda patch: ( - (), - {patch.dims[-1]: (None, 12.0), "corners": 2, "zerophase": False}, - ), - prepare_patch=prepare_even_patch_for_dim, - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "pass_filter" - ), - ), - ), - ), -) diff --git a/src/dasjax/operations/patch_ops.py b/src/dasjax/operations/patch_ops.py deleted file mode 100644 index 86b1851..0000000 --- a/src/dasjax/operations/patch_ops.py +++ /dev/null @@ -1,424 +0,0 @@ -"""Unified PatchOp runtime for compiled patch-state execution.""" - -from __future__ import annotations - -import inspect -from collections.abc import Callable -from dataclasses import dataclass, field -from typing import Any - -import dascore as dc -import jax -import numpy as np - -from ..pytree import _decode_leaf, _encode_leaf - - -@jax.tree_util.register_pytree_node_class -@dataclass(frozen=True) -class PatchState: - """JAX-friendly dynamic patch state.""" - - data: Any - coords: dict[str, Any] - - def tree_flatten(self): - return ((self.data, self.coords), None) - - @classmethod - def tree_unflatten(cls, aux_data, children): - _ = aux_data - data, coords = children - return cls(data=data, coords=coords) - - def with_updates( - self, - *, - data: Any | None = None, - coords: dict[str, Any] | None = None, - ) -> "PatchState": - return PatchState( - data=self.data if data is None else data, - coords=self.coords if coords is None else coords, - ) - - -@dataclass(frozen=True) -class CoordSpec: - """Static reconstruction metadata for one coordinate.""" - - name: str - dims: tuple[str, ...] - dtype: str - coord: Any - - -@dataclass(frozen=True) -class PatchSpec: - """Static reconstruction metadata for one patch state.""" - - dims: tuple[str, ...] - attrs: Any - coord_specs: tuple[CoordSpec, ...] - - def apply_meta(self, meta: "MetaDelta | None") -> "PatchSpec": - """Return a new spec with a metadata delta applied.""" - if meta is None: - return self - return PatchSpec( - dims=self.dims if meta.dims is None else meta.dims, - attrs=self.attrs if meta.attrs is None else meta.attrs, - coord_specs=self.coord_specs - if meta.coord_specs is None - else meta.coord_specs, - ) - - -@dataclass(frozen=True) -class MetaDelta: - """Static metadata changes produced by a PatchOp.""" - - dims: tuple[str, ...] | None = None - attrs: Any | None = None - coord_specs: tuple[CoordSpec, ...] | None = None - - -@dataclass(frozen=True) -class OpResult: - """Normalized output of one compiled patch op.""" - - data: Any | None = None - coords: dict[str, Any] | None = None - meta: MetaDelta | None = None - - -def patch_to_state_spec(patch: dc.Patch) -> tuple[PatchState, PatchSpec]: - """Convert a DASCore patch into dynamic state plus static spec.""" - coord_specs = [] - coord_values: dict[str, Any] = {} - for name, coord in patch.coords.coord_map.items(): - encoded_values, dtype_token = _encode_leaf(coord.values) - coord_values[name] = encoded_values - coord_specs.append( - CoordSpec( - name=name, - dims=tuple(patch.coords.dim_map[name]), - dtype=dtype_token, - coord=coord, - ) - ) - return PatchState( - data=patch.data, - coords=coord_values, - ), PatchSpec( - dims=tuple(patch.dims), - attrs=patch.attrs, - coord_specs=tuple(coord_specs), - ) - - -def patch_from_state_spec( - state: PatchState, - spec: PatchSpec, - *, - coerce_numpy: bool = True, -) -> dc.Patch: - """Rebuild a DASCore patch from dynamic state and static spec.""" - coords: dict[str, Any] = {} - for coord_spec in spec.coord_specs: - values = _decode_leaf(state.coords[coord_spec.name], coord_spec.dtype) - coord = coord_spec.coord.update_data(data=values) - dims = tuple(coord_spec.dims) - coords[coord_spec.name] = ( - coord if len(dims) == 1 and dims[0] == coord_spec.name else (dims, coord) - ) - return dc.Patch( - data=np.asarray(state.data) if coerce_numpy else state.data, - coords=coords, - dims=spec.dims, - attrs=spec.attrs, - ) - - -class PatchOp: - """Base class for unified compiled patch operations.""" - - _subclasses: list[type["PatchOp"]] = [] - _register_subclass = True - mutates_spec = False - requires_materialized_patch_after = False - requires_materialized_patch_for_prepare = False - compile_category = "kernel_fusible" - - def __init_subclass__(cls, **kwargs: Any) -> None: - super().__init_subclass__(**kwargs) - if cls is PatchOp: - return - if cls.__dict__.get("_register_subclass", True): - PatchOp._subclasses.append(cls) - - @classmethod - def iter_subclasses(cls) -> tuple[type["PatchOp"], ...]: - """Return registered PatchOp subclasses.""" - return tuple(cls._subclasses) - - @classmethod - def compile_category_table(cls) -> dict[str, tuple[str, ...]]: - """Group registered PatchOp subclasses by compile category.""" - categories: dict[str, list[str]] = {} - for subclass in cls._subclasses: - categories.setdefault(subclass.compile_category, []).append( - subclass.__name__ - ) - return {key: tuple(sorted(value)) for key, value in sorted(categories.items())} - - @classmethod - def prepare(cls, patch: dc.Patch, *args: Any, **kwargs: Any) -> "PatchOp": - """Default prepare: instantiate and bind inferred patch attrs.""" - op = cls(*args, **kwargs) - object.__setattr__(op, "_prepared_attrs", cls._prepare_attrs(patch, op)) - object.__setattr__( - op, - "_prepared_selected", - cls._prepare_selected(patch, args, kwargs, op), - ) - cls._validate_kernel_bindings(patch, op) - return op - - @staticmethod - def _kernel_parameters(op: "PatchOp") -> tuple[str, ...]: - params = inspect.signature(op.kernel).parameters - return tuple(name for name in params if name != "self") - - @classmethod - def _prepare_attrs(cls, patch: dc.Patch, op: "PatchOp") -> dict[str, Any]: - prepared: dict[str, Any] = {} - for name in cls._kernel_parameters(op): - if name.startswith("attr_"): - attr_name = name[5:] - prepared[attr_name] = patch.attrs[attr_name] - return prepared - - @staticmethod - def _requires_selected(op: "PatchOp") -> bool: - return any( - name.startswith("selected_") for name in PatchOp._kernel_parameters(op) - ) - - @staticmethod - def _encode_bound_value(value: Any) -> Any: - encoded, _ = _encode_leaf(np.asarray(value)) - if np.asarray(encoded).shape == (): - return np.asarray(encoded).item() - return encoded - - @classmethod - def _resolve_selected_context( - cls, - patch: dc.Patch, - args: tuple[Any, ...], - kwargs: dict[str, Any], - ) -> tuple[str, int, Any]: - _ = args - selected_dim = kwargs.get("dim") - if selected_dim is not None: - if selected_dim not in patch.dims: - msg = f"Selected dim {selected_dim!r} is not in patch dims {patch.dims!r}." - raise ValueError(msg) - return ( - selected_dim, - patch.get_axis(selected_dim), - patch.get_coord(selected_dim), - ) - dim_keys = tuple(key for key in kwargs if key in patch.dims) - if not dim_keys: - msg = ( - "Kernel requested selected_* binding but no selected dim was provided." - ) - raise ValueError(msg) - if len(dim_keys) > 1: - msg = ( - "Kernel requested selected_* binding but the call matches multiple dims: " - f"{dim_keys!r}." - ) - raise ValueError(msg) - selected_dim = dim_keys[0] - return selected_dim, patch.get_axis(selected_dim), patch.get_coord(selected_dim) - - @classmethod - def _prepare_selected( - cls, - patch: dc.Patch, - args: tuple[Any, ...], - kwargs: dict[str, Any], - op: "PatchOp", - ) -> dict[str, Any]: - if not cls._requires_selected(op): - return {} - selected_dim, selected_axis, selected_coord = cls._resolve_selected_context( - patch, args, kwargs - ) - prepared = { - "selected_dim": selected_dim, - "selected_axis": selected_axis, - "selected_size": len(selected_coord), - "selected_coord": selected_dim, - "selected_start": cls._encode_bound_value(selected_coord.min()), - "selected_stop": cls._encode_bound_value(selected_coord.max()), - } - if selected_coord.step is not None: - prepared["selected_step"] = cls._encode_bound_value(selected_coord.step) - return prepared - - @classmethod - def _validate_kernel_bindings(cls, patch: dc.Patch, op: "PatchOp") -> None: - for name in cls._kernel_parameters(op): - if name.startswith("coord_"): - coord_name = name[6:] - if coord_name not in patch.coords.coord_map: - msg = f"Kernel requested unknown coordinate {coord_name!r}." - raise ValueError(msg) - elif name.startswith("selected_"): - prepared = getattr(op, "_prepared_selected", {}) - if name == "selected_step" and "selected_step" not in prepared: - msg = ( - "Kernel requested selected_step but the selected coordinate " - "is not evenly sampled." - ) - raise ValueError(msg) - if name not in { - "selected_axis", - "selected_coord", - "selected_step", - "selected_size", - "selected_start", - "selected_stop", - }: - msg = f"Unsupported selected binding {name!r}." - raise TypeError(msg) - - def _normalize_result(self, raw: Any) -> OpResult: - if isinstance(raw, OpResult): - return raw - if isinstance(raw, dict): - unknown = set(raw) - {"data", "coords", "meta"} - if unknown: - msg = f"Unsupported OpResult keys: {sorted(unknown)!r}" - raise TypeError(msg) - return OpResult( - data=raw.get("data"), - coords=raw.get("coords"), - meta=raw.get("meta"), - ) - msg = f"Kernel {type(self).__name__}.kernel must return OpResult or dict." - raise TypeError(msg) - - def _bind_kernel_inputs(self, state: PatchState) -> dict[str, Any]: - bound: dict[str, Any] = {} - prepared_attrs = getattr(self, "_prepared_attrs", {}) - prepared_selected = getattr(self, "_prepared_selected", {}) - for name in self._kernel_parameters(self): - if name == "state": - bound[name] = state - elif name == "data": - bound[name] = state.data - elif name == "coords": - bound[name] = state.coords - elif name.startswith("coord_"): - bound[name] = state.coords[name[6:]] - elif name.startswith("attr_"): - bound[name] = prepared_attrs[name[5:]] - elif name == "selected_coord": - bound[name] = state.coords[prepared_selected["selected_coord"]] - elif name.startswith("selected_"): - bound[name] = prepared_selected[name] - else: - msg = f"Unsupported kernel parameter {name!r}." - raise TypeError(msg) - return bound - - def apply(self, state: PatchState) -> PatchState: - """Apply one op to patch state and return updated state.""" - result = self._normalize_result(self.kernel(**self._bind_kernel_inputs(state))) - next_data = state.data if result.data is None else result.data - next_coords = state.coords - if result.coords: - next_coords = dict(state.coords) - next_coords.update(result.coords) - return state.with_updates(data=next_data, coords=next_coords) - - def reconstruct( - self, - previous_patch: dc.Patch, - spec: PatchSpec, - state: PatchState, - ) -> dc.Patch: - """Rebuild a DASCore patch from state after one compiled segment.""" - _ = previous_patch - return patch_from_state_spec(state, spec) - - def meta_delta(self, spec: PatchSpec) -> MetaDelta | None: - """Return static spec changes implied by this prepared op.""" - _ = spec - return None - - def compile_key(self) -> tuple[Any, ...]: - """Return a stable cache-key component for this prepared op.""" - entries = [] - for key, value in vars(self).items(): - entries.append((key, _freeze_value(value))) - return (type(self).__name__, tuple(sorted(entries))) - - -@dataclass(frozen=True) -class EagerPatchOp(PatchOp): - """PatchOp wrapper that materializes state and delegates to patch_impl.""" - - _register_subclass = False - args: tuple[Any, ...] = () - kwargs: dict[str, Any] = field(default_factory=dict) - mutates_spec = True - requires_materialized_patch_after = True - requires_materialized_patch_for_prepare = True - compile_category = "eager_boundary" - patch_impl_fn: Callable[..., dc.Patch] | None = None - - @classmethod - def prepare(cls, patch: dc.Patch, *args: Any, **kwargs: Any) -> "EagerPatchOp": - _ = patch - return cls(args=args, kwargs=dict(kwargs)) - - def kernel(self, state): - return {} - - def reconstruct( - self, - previous_patch: dc.Patch, - spec: PatchSpec, - state: PatchState, - ) -> dc.Patch: - current_patch = patch_from_state_spec(state, spec) - patch_impl = type(self).patch_impl_fn - assert patch_impl is not None - _ = previous_patch - return patch_impl(current_patch, *self.args, **self.kwargs) - - -def _freeze_value(value: Any) -> Any: - if isinstance(value, np.ndarray): - return ( - "ndarray", - str(value.dtype), - value.shape, - tuple(np.asarray(value).reshape(-1).tolist()), - ) - if isinstance(value, dict): - return tuple((key, _freeze_value(val)) for key, val in sorted(value.items())) - if isinstance(value, (tuple, list)): - return tuple(_freeze_value(item) for item in value) - try: - hash(value) - except TypeError as exc: - msg = f"Unhashable prepared value {value!r} cannot be compiled." - raise TypeError(msg) from exc - return value diff --git a/src/dasjax/operations/registry.py b/src/dasjax/operations/registry.py deleted file mode 100644 index 8827b50..0000000 --- a/src/dasjax/operations/registry.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Assembled operation registry.""" - -from __future__ import annotations - -from collections.abc import Iterator - -from .basic import OPERATIONS as BASIC_OPERATIONS -from .common import validate_registry -from .filters import OPERATIONS as FILTER_OPERATIONS -from .signal import OPERATIONS as SIGNAL_OPERATIONS -from .spectral import OPERATIONS as SPECTRAL_OPERATIONS -from .types import OperationSpec - -OPERATIONS: tuple[OperationSpec, ...] = ( - *BASIC_OPERATIONS, - *SIGNAL_OPERATIONS, - *FILTER_OPERATIONS, - *SPECTRAL_OPERATIONS, -) - -validate_registry(OPERATIONS) - -_OPERATIONS_BY_NAME: dict[str, OperationSpec] = { - operation.name: operation for operation in OPERATIONS -} - - -def get_operation(name: str) -> OperationSpec: - try: - return _OPERATIONS_BY_NAME[name] - except KeyError as exc: - raise AttributeError(f"Unknown jax patch operation {name!r}.") from exc - - -def iter_operations() -> Iterator[OperationSpec]: - return iter(OPERATIONS) - - -def list_operations() -> tuple[str, ...]: - return tuple(operation.name for operation in OPERATIONS) diff --git a/src/dasjax/operations/signal/__init__.py b/src/dasjax/operations/signal/__init__.py deleted file mode 100644 index 4abcfd9..0000000 --- a/src/dasjax/operations/signal/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""Signal operation family.""" - -from .specs import OPERATIONS - -__all__ = ["OPERATIONS"] diff --git a/src/dasjax/operations/signal/impl.py b/src/dasjax/operations/signal/impl.py deleted file mode 100644 index 25ce38c..0000000 --- a/src/dasjax/operations/signal/impl.py +++ /dev/null @@ -1,521 +0,0 @@ -"""Executable implementations for signal operations.""" - -from __future__ import annotations - -from collections.abc import Sequence -from dataclasses import dataclass -from functools import reduce -from operator import add -from typing import Any -from operator import mul, truediv - -import dascore as dc -import numpy as np -from dascore.constants import PatchType -from dascore.exceptions import ParameterError -from dascore.proc.taper import taper as dc_taper -from dascore.proc.taper import taper_range as dc_taper_range -from dascore.transform.differentiate import differentiate as dc_differentiate -from dascore.transform.integrate import integrate as dc_integrate -from dascore.units import get_quantity -from dascore.units import Quantity -from dascore.utils.misc import iterate -from scipy.signal import get_window - -from dasjax import compat, kernels - -from ..common import get_axis, get_axis_from_dims, update_patch -from ..patch_ops import MetaDelta, PatchOp, PatchSpec - - -@dataclass(frozen=True) -class DetrendOp(PatchOp): - """Compiled detrend operation using selected-axis inference.""" - - dim: str - type: str = "linear" - - def kernel(self, data, selected_axis): - return { - "data": kernels.detrend_kernel(data, axis=selected_axis, type=self.type) - } - - -@dataclass(frozen=True) -class NormalizeOp(PatchOp): - """Compiled normalize operation using selected-axis inference.""" - - dim: str - norm: str = "l2" - - def kernel(self, data, selected_axis): - return { - "data": kernels.normalize_kernel(data, axis=selected_axis, norm=self.norm) - } - - -@dataclass(frozen=True) -class DifferentiateOp(PatchOp): - """Compiled differentiate operation with metadata updates.""" - - axes: tuple[int, ...] - dxs_or_spacing: tuple[Any, ...] - order: int = 2 - step: int = 1 - dims: tuple[str, ...] = () - new_attrs: Any = None - - @classmethod - def prepare( - cls, - patch: PatchType, - dim: str | tuple[str, ...] | None, - order: int = 2, - step: int = 1, - ) -> "DifferentiateOp": - dims = tuple(iterate(dim if dim is not None else patch.dims)) - dxs_or_spacing = [] - axes = [] - for dim_name in dims: - coord = patch.get_coord(dim_name, require_sorted=True) - val = coord.step if coord.evenly_sampled else coord.data - dxs_or_spacing.append(dc.to_float(val)) - axes.append(patch.get_axis(dim_name)) - if step > 1 and len(axes) > 1: - msg = "Step in patch.differentiate can only be used along one axis." - raise ParameterError(msg) - new_attrs = patch.attrs.update( - data_units=_get_data_units_from_dims_local(patch, dims, truediv) - ) - return cls( - axes=tuple(axes), - dxs_or_spacing=tuple(dxs_or_spacing), - order=order, - step=step, - dims=dims, - new_attrs=new_attrs, - ) - - def kernel(self, data): - out = data - for axis, dx_or_spacing in zip(self.axes, self.dxs_or_spacing, strict=True): - out = kernels.differentiate_kernel( - out, - axis=axis, - dx_or_spacing=dx_or_spacing, - order=self.order, - step=self.step, - ) - return {"data": out} - - def meta_delta(self, spec: PatchSpec) -> MetaDelta | None: - _ = spec - return MetaDelta(attrs=self.new_attrs) - - -@dataclass(frozen=True) -class IntegrateOp(PatchOp): - """Compiled integrate operation with eager fallback for definite integrals.""" - - axes: tuple[int, ...] - dxs_or_spacing: tuple[Any, ...] - definite: bool = False - dims: tuple[str, ...] = () - new_attrs: Any = None - mutates_spec = True - requires_materialized_patch_after = True - compile_category = "compiled_boundary" - - @classmethod - def prepare( - cls, - patch: PatchType, - dim: tuple[str, ...] | str | None, - definite: bool = False, - ) -> "IntegrateOp": - dims = tuple(iterate(dim if dim is not None else patch.dims)) - dxs_or_spacing = [] - axes = [] - for dim_name in dims: - coord = patch.get_coord(dim_name, require_sorted=True) - val = coord.step if coord.evenly_sampled else coord.data - dxs_or_spacing.append(dc.to_float(val)) - axes.append(patch.get_axis(dim_name)) - updates = {"data_units": _get_data_units_from_dims_local(patch, dims, mul)} - # A definite integral reduces the dims away, so any coordinate - # metadata the attributes still describe has to go with them. On - # DASCore's dev branch the attributes no longer carry coordinates at - # all, and there is nothing left to clear. - if definite and compat.attrs_carry_coords(patch.attrs): - updates["coords"] = {} - new_attrs = patch.attrs.update(**updates) - return cls( - axes=tuple(axes), - dxs_or_spacing=tuple(dxs_or_spacing), - definite=definite, - dims=dims, - new_attrs=new_attrs, - ) - - def kernel(self, data): - out = data - for axis, dx_or_spacing in zip(self.axes, self.dxs_or_spacing, strict=True): - out = kernels.integrate_kernel( - out, - axis=axis, - dx_or_spacing=dx_or_spacing, - definite=self.definite, - ) - return {"data": out} - - def meta_delta(self, spec: PatchSpec) -> MetaDelta | None: - if self.definite: - _ = spec - return None - return MetaDelta(attrs=self.new_attrs) - - def reconstruct( - self, - previous_patch: PatchType, - spec: PatchSpec, - state, - ) -> PatchType: - if self.definite: - return dc_integrate.func(previous_patch, dim=self.dims, definite=True) - return super().reconstruct(previous_patch, spec, state) - - -@dataclass(frozen=True) -class TaperOp(PatchOp): - """Compiled taper operation.""" - - axis: int - weight: np.ndarray - requires_materialized_patch_for_prepare = True - - @classmethod - def prepare( - cls, - patch: PatchType, - window_type: str = "hann", - **kwargs, - ) -> "TaperOp": - _, prepared = prepare_taper_call( - patch, - (), - {"window_type": window_type, **kwargs}, - ) - return cls(axis=prepared["axis"], weight=prepared["weight"]) - - def kernel(self, data): - return { - "data": kernels.apply_1d_weight_kernel( - data, axis=self.axis, weight=self.weight - ) - } - - -@dataclass(frozen=True) -class TaperRangeOp(PatchOp): - """Compiled taper_range operation.""" - - axis: int - weight: np.ndarray - requires_materialized_patch_for_prepare = True - - @classmethod - def prepare( - cls, - patch: PatchType, - window_type: str = "hann", - invert: bool = False, - relative: bool = False, - samples: bool = False, - **kwargs, - ) -> "TaperRangeOp": - _, prepared = prepare_taper_range_call( - patch, - (), - { - "window_type": window_type, - "invert": invert, - "relative": relative, - "samples": samples, - **kwargs, - }, - ) - return cls(axis=prepared["axis"], weight=prepared["weight"]) - - def kernel(self, data): - return { - "data": kernels.apply_1d_weight_kernel( - data, axis=self.axis, weight=self.weight - ) - } - - -def window_function(window_type: str, size: int) -> np.ndarray: - return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64) - - -def _get_data_units_from_dims_local( - patch: PatchType, - dims: tuple[str, ...], - operator, -): - """Derive data units for dimension-wise math without eager patch execution.""" - if (data_units := get_quantity(patch.attrs.data_units)) is None: - return None - dim_units = None - for dim_name in dims: - dim_unit = get_quantity(patch.get_coord(dim_name).units) - if dim_unit is None: - continue - dim_units = dim_unit if dim_units is None else dim_unit * dim_units - if dim_units is not None: - data_units = operator(data_units, dim_units) - return data_units - - -def get_taper_slices_local(patch: PatchType, kwargs: dict[str, Any]): - dim = next(key for key in kwargs if key in patch.dims) - axis = patch.get_axis(dim) - value = kwargs[dim] - coord = patch.coords.coord_map[dim] - if isinstance(value, Sequence | np.ndarray): - if len(value) != 2: - raise AssertionError("Length 2 sequence required.") - start, stop = value[0], value[1] - else: - start, stop = value, value - dur = coord.coord_range(extend=False) - clses = (Quantity, np.timedelta64) - start = start if isinstance(start, clses) or start is None else start * dur - stop = stop if isinstance(stop, clses) or stop is None else stop * dur - stop = -stop if stop is not None else stop - _, inds_1 = coord.select((None, start), relative=True) - _, inds_2 = coord.select((stop, None), relative=True) - return axis, (start, stop), inds_1, inds_2 - - -def validate_windows_local(samps, start_slice, end_slice, shape, axis): - max_len = shape[axis] - start_ind = start_slice.stop - end_ind = end_slice.start - bad_start = samps[0] is not None and (start_ind is None or start_ind < 0) - bad_end = samps[1] is not None and (end_ind is None or end_ind > max_len) - if bad_start or bad_end: - raise ParameterError("Total taper lengths exceed total dim length") - if start_ind is None or end_ind is None: - return - if start_ind > end_ind: - raise ParameterError("Taper windows cannot overlap") - - -def get_taper_coord_inds_local(coord, values, relative, samples): - error_msg = "A len 2 or 4 sequence is required for taper values" - if not isinstance(values, (Sequence | np.ndarray)) or not len(values): - raise ParameterError(error_msg) - if isinstance(values[0], (Sequence | np.ndarray)): - out = [ - get_taper_coord_inds_local(coord, item, relative, samples) - for item in values - ] - return reduce(add, out) - if len(values) not in {2, 4}: - raise ParameterError(error_msg) - out = [None] * len(values) - for idx, value in enumerate(values): - if value is None or value == ...: - if len(values) == 2: - raise ParameterError( - "Cannot use ... or None when only two values provided" - ) - out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1 - else: - out[idx] = coord.get_next_index(value, samples=samples, relative=relative) - if len(out) == 2: - out = [0, *out, len(coord)] - return [out] - - -def get_taper_curve_local(coord, ind_1, ind_2, window_type, reverse=False): - taper = window_function(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1] - if reverse: - taper = taper[::-1] - if not coord.evenly_sampled: - old_coord = coord.select((ind_1, ind_2), samples=True)[0] - new_coord = old_coord.snap().change_length(len(old_coord)) - old_x = dc.to_float(old_coord.values) - new_x = dc.to_float(new_coord.values) - taper = np.interp(new_x, old_x, taper) - return taper - - -def get_range_envelope_local(coord, inds, window_type, invert): - out = np.zeros(len(coord)) - for ind_set in inds: - i1, i2, i3, i4 = ind_set - left_taper = get_taper_curve_local(coord, i1, i2, window_type) - right_taper = get_taper_curve_local(coord, i3, i4, window_type, reverse=True) - out[i1:i2] += left_taper - out[i3:i4] += right_taper - out[i2:i3] += 1 - if invert: - out = np.abs(out - np.max(out)) - return out - - -def validate_detrend_patch_input( - patch: PatchType, dim: str, type: str = "linear" -) -> None: - get_axis(patch, dim) - detrend_type = kernels.validate_detrend_type(type) - if detrend_type == "linear" and not kernels.is_finite_array(patch.data): - raise ValueError("array must not contain infs or NaNs") - - -def detrend_patch(patch: PatchType, dim: str, type: str = "linear") -> PatchType: - validate_detrend_patch_input(patch, dim=dim, type=type) - axis = get_axis(patch, dim) - return update_patch(patch, kernels.detrend_kernel(patch.data, axis=axis, type=type)) - - -def detrend_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - dim: str, - type: str = "linear", -) -> tuple[Any, tuple[Any, ...]]: - axis = get_axis_from_dims(dims, dim) - return kernels.detrend_kernel(data, axis=axis, type=type), coord_leaves - - -def normalize_patch(patch: PatchType, dim: str, norm: str = "l2") -> PatchType: - axis = get_axis(patch, dim) - return update_patch( - patch, kernels.normalize_kernel(patch.data, axis=axis, norm=norm) - ) - - -def normalize_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - dim: str, - norm: str = "l2", -) -> tuple[Any, tuple[Any, ...]]: - axis = get_axis_from_dims(dims, dim) - return kernels.normalize_kernel(data, axis=axis, norm=norm), coord_leaves - - -def differentiate_patch( - patch: PatchType, - dim: str | tuple[str, ...] | None, - order: int = 2, - step: int = 1, -) -> PatchType: - return dc_differentiate.func(patch, dim=dim, order=order, step=step) - - -def integrate_patch( - patch: PatchType, - dim: tuple[str, ...] | str | None, - definite: bool = False, -) -> PatchType: - return dc_integrate.func(patch, dim=dim, definite=definite) - - -def prepare_taper_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - window_type = call_kwargs.pop("window_type", "hann") - axis, _, start_slice, end_slice = get_taper_slices_local(patch, call_kwargs) - shape = patch.shape - validate_windows_local( - (start_slice.stop, shape[axis] - end_slice.start), - start_slice, - end_slice, - shape, - axis, - ) - weight = np.ones(shape[axis], dtype=np.float64) - if start_slice.stop is not None and start_slice.stop > 0: - start_len = start_slice.stop - weight[:start_len] = window_function(window_type, 2 * start_len)[:start_len] - if end_slice.start is not None and end_slice.start < shape[axis]: - end_len = shape[axis] - end_slice.start - weight[end_slice.start :] = window_function(window_type, 2 * end_len)[end_len:] - return (), {"axis": axis, "weight": weight} - - -def taper_patch(patch: PatchType, window_type: str = "hann", **kwargs) -> PatchType: - return dc_taper.func(patch, window_type=window_type, **kwargs) - - -def taper_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - axis: int, - weight: np.ndarray, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.apply_1d_weight_kernel(data, axis=axis, weight=weight), coord_leaves - - -def prepare_taper_range_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - window_type = call_kwargs.pop("window_type", "hann") - invert = bool(call_kwargs.pop("invert", False)) - relative = bool(call_kwargs.pop("relative", False)) - samples = bool(call_kwargs.pop("samples", False)) - dim = next(key for key in call_kwargs if key in patch.dims) - axis = patch.get_axis(dim) - coord = patch.get_coord(dim, require_sorted=True) - inds = get_taper_coord_inds_local(coord, call_kwargs[dim], relative, samples) - weight = get_range_envelope_local(coord, inds, window_type, invert) - return (), {"axis": axis, "weight": np.asarray(weight)} - - -def taper_range_patch( - patch: PatchType, - window_type: str = "hann", - invert: bool = False, - relative: bool = False, - samples: bool = False, - **kwargs, -) -> PatchType: - return dc_taper_range.func( - patch, - window_type=window_type, - invert=invert, - relative=relative, - samples=samples, - **kwargs, - ) - - -def taper_range_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - axis: int, - weight: np.ndarray, -) -> tuple[Any, tuple[Any, ...]]: - _ = dims - return kernels.apply_1d_weight_kernel(data, axis=axis, weight=weight), coord_leaves diff --git a/src/dasjax/operations/signal/specs.py b/src/dasjax/operations/signal/specs.py deleted file mode 100644 index 82f8d3b..0000000 --- a/src/dasjax/operations/signal/specs.py +++ /dev/null @@ -1,144 +0,0 @@ -"""Registry specs for signal operations.""" - -from __future__ import annotations - -import dascore as dc -from dascore.proc.taper import taper as dc_taper -from dascore.proc.taper import taper_range as dc_taper_range -from dascore.transform.differentiate import differentiate as dc_differentiate -from dascore.transform.integrate import integrate as dc_integrate - -from ..common import baseline_patch_method -from ..types import ExecutionPolicy, OperationCase, OperationSpec -from . import impl - -OPERATIONS: tuple[OperationSpec, ...] = ( - OperationSpec( - name="detrend", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.detrend_patch), - patch_op_cls=impl.DetrendOp, - leaf_transform=impl.detrend_leaves, - validate_patch=impl.validate_detrend_patch_input, - test_cases=tuple( - OperationCase( - case_id=f"detrend-{kind}", - resolve_call=lambda patch, kind=kind: ( - (), - {"dim": patch.dims[-1], "type": kind}, - ), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "detrend" - ), - ) - for kind in ("constant", "linear") - ), - ), - OperationSpec( - name="normalize", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.normalize_patch), - patch_op_cls=impl.NormalizeOp, - leaf_transform=impl.normalize_leaves, - test_cases=tuple( - OperationCase( - case_id=f"normalize-{norm}", - resolve_call=lambda patch, norm=norm: ( - (), - {"dim": patch.dims[-1], "norm": norm}, - ), - baseline=lambda patch, args, kwargs: baseline_patch_method( - patch, args, kwargs, "normalize" - ), - ) - for norm in ("l1", "l2", "max", "bit") - ), - ), - OperationSpec( - name="differentiate", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.differentiate_patch), - patch_op_cls=impl.DifferentiateOp, - test_cases=( - OperationCase( - case_id="differentiate-default", - resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}), - baseline=lambda patch, args, kwargs: dc_differentiate.func( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="differentiate-step", - resolve_call=lambda patch: ((), {"dim": patch.dims[-1], "step": 2}), - baseline=lambda patch, args, kwargs: dc_differentiate.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="integrate", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.integrate_patch), - patch_op_cls=impl.IntegrateOp, - test_cases=( - OperationCase( - case_id="integrate-indefinite", - resolve_call=lambda patch: ((), {"dim": patch.dims[-1]}), - baseline=lambda patch, args, kwargs: dc_integrate.func( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="integrate-definite", - resolve_call=lambda patch: ( - (), - {"dim": patch.dims[-1], "definite": True}, - ), - baseline=lambda patch, args, kwargs: dc_integrate.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="taper", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.taper_patch), - patch_op_cls=impl.TaperOp, - leaf_transform=impl.taper_leaves, - prepare_call=impl.prepare_taper_call, - test_cases=( - OperationCase( - case_id="taper-time", - resolve_call=lambda patch: ( - (), - {"window_type": "hann", patch.dims[-1]: 0.05}, - ), - baseline=lambda patch, args, kwargs: dc_taper.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="taper_range", - execution_policy=ExecutionPolicy.LEAF, - patch_impl=dc.patch_function(history="method_name")(impl.taper_range_patch), - patch_op_cls=impl.TaperRangeOp, - leaf_transform=impl.taper_range_leaves, - prepare_call=impl.prepare_taper_range_call, - test_cases=( - OperationCase( - case_id="taper-range", - resolve_call=lambda patch: ( - (), - {"window_type": "hann", patch.dims[-1]: (10, 20), "samples": True}, - ), - baseline=lambda patch, args, kwargs: dc_taper_range.func( - patch, *args, **kwargs - ), - ), - ), - ), -) diff --git a/src/dasjax/operations/spectral/__init__.py b/src/dasjax/operations/spectral/__init__.py deleted file mode 100644 index 8496948..0000000 --- a/src/dasjax/operations/spectral/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""Spectral operation family.""" - -from .specs import OPERATIONS - -__all__ = ["OPERATIONS"] diff --git a/src/dasjax/operations/spectral/impl.py b/src/dasjax/operations/spectral/impl.py deleted file mode 100644 index db1ed5f..0000000 --- a/src/dasjax/operations/spectral/impl.py +++ /dev/null @@ -1,560 +0,0 @@ -"""Executable implementations for spectral operations.""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any - -import dascore as dc -import jax.numpy as jnp -import numpy as np -from dascore.constants import PatchType -from dascore.exceptions import ParameterError -from dascore.proc.basic import pad as dc_pad -from dascore.proc.whiten import whiten as dc_whiten -from dascore.transform.fourier import dft as dc_dft -from dascore.transform.fourier import idft as dc_idft -from dascore.transform.hilbert import envelope as dc_envelope -from dascore.transform.hilbert import hilbert as dc_hilbert -from dascore.units import invert_quantity -from dascore.utils.patch import get_dim_axis_value -from dascore.utils.time import is_datetime64, is_timedelta64 -from dascore.utils.transformatter import FourierTransformatter -from scipy.fft import next_fast_len -from scipy.signal import ShortTimeFFT, get_window - -from dasjax import kernels - -from ..common import get_axis_from_dims -from ..patch_ops import EagerPatchOp, PatchOp - - -def _pad_encoded_value(value: Any) -> tuple[Any, str]: - arr = np.asarray(value) - if is_datetime64(arr.dtype) or is_timedelta64(arr.dtype): - return arr.view(np.int64), "int64" - return arr, str(arr.dtype) - - -@dataclass(frozen=True) -class PadOp(PatchOp): - """Compiled pad operation over patch state.""" - - data_pad_width: tuple[tuple[int, int], ...] - coord_pad_widths: dict[str, tuple[int, int]] - coord_generators: dict[str, tuple[str, Any, Any, int]] - mode: str = "constant" - constant_values: float = 0.0 - mutates_spec = True - requires_materialized_patch_for_prepare = True - compile_category = "compiled_boundary" - - @classmethod - def prepare( - cls, - patch: PatchType, - mode: str = "constant", - constant_values: Any = 0, - expand_coords: bool = True, - samples: bool = False, - **kwargs, - ) -> "PadOp": - if isinstance(constant_values, tuple | list | np.ndarray): - raise ParameterError("constant_values must be a scalar, not a sequence.") - pad_width = [(0, 0)] * len(patch.shape) - coord_pad_widths: dict[str, tuple[int, int]] = {} - coord_generators: dict[str, tuple[str, Any, Any, int]] = {} - dimfo = get_dim_axis_value(patch, kwargs=kwargs, allow_multiple=True) - for dim, axis, value in dimfo: - if not samples and patch.get_coord(dim).step is None: - msg = f"Coordinate {dim} is not evenly sampled as required by pad" - raise dc.exceptions.CoordError(msg) - coord = patch.get_coord(dim, require_evenly_sampled=False) - if value in {"fft", "correlate"}: - target_length = len(coord) if value == "fft" else 2 * len(coord) - 1 - pad_tuple = (0, next_fast_len(target_length) - len(coord)) - else: - if not isinstance(value, tuple | list): - value = (value, value) - pad_tuple = ( - tuple(int(coord.get_sample_count(x)) for x in value) - if not samples - else tuple(int(x) for x in value) - ) - pad_width[axis] = pad_tuple - coord_pad_widths[dim] = pad_tuple - if expand_coords and coord.evenly_sampled: - start_value, _ = _pad_encoded_value(coord.min()) - step_value, _ = _pad_encoded_value(coord.step) - coord_generators[dim] = ( - "range", - np.asarray(start_value), - np.asarray(step_value), - len(coord) + sum(pad_tuple), - ) - else: - coord_values, dtype_name = _pad_encoded_value(coord.values) - if np.issubdtype(np.asarray(coord_values).dtype, np.integer): - coord_values = np.asarray(coord_values, dtype=np.float64) - null_value = np.nan - else: - null_value = np.nan - coord_generators[dim] = ( - "pad", - np.asarray(coord_values), - np.asarray(null_value, dtype=np.asarray(coord_values).dtype), - 0, - ) - return cls( - data_pad_width=tuple(tuple(x) for x in pad_width), - coord_pad_widths=coord_pad_widths, - coord_generators=coord_generators, - mode=mode, - constant_values=float(constant_values), - ) - - def kernel(self, state): - out_coords = {} - for name, kind_data in self.coord_generators.items(): - kind, arg1, arg2, size = kind_data - if kind == "range": - before, _ = self.coord_pad_widths[name] - out_coords[name] = ( - arg1 - - before * arg2 - + jnp.arange(size, dtype=jnp.asarray(arg1).dtype) * arg2 - ) - else: - out_coords[name] = jnp.pad( - jnp.asarray(arg1), - self.coord_pad_widths[name], - mode="constant", - constant_values=jnp.asarray(arg2), - ) - return { - "data": jnp.pad( - state.data, - self.data_pad_width, - mode=self.mode, - constant_values=self.constant_values, - ), - "coords": out_coords, - } - - -@dataclass(frozen=True) -class DftOp(EagerPatchOp): - """Unified eager-backed dft operation.""" - - patch_impl_fn = staticmethod(dc_dft.func) - - -@dataclass(frozen=True) -class IdftOp(EagerPatchOp): - """Unified eager-backed idft operation.""" - - patch_impl_fn = staticmethod(dc_idft.func) - - -@dataclass(frozen=True) -class HilbertOp(PatchOp): - """Compiled hilbert operation using selected-axis inference.""" - - dim: str - - @classmethod - def prepare(cls, patch: PatchType, dim: str) -> "HilbertOp": - if patch.get_coord(dim).step is None: - msg = f"Coordinate {dim} is not evenly sampled as required by hilbert" - raise dc.exceptions.CoordError(msg) - return super().prepare(patch, dim=dim) - - def kernel(self, data, selected_axis): - return {"data": kernels.hilbert_kernel(data, axis=selected_axis)} - - -@dataclass(frozen=True) -class EnvelopeOp(PatchOp): - """Compiled envelope operation using selected-axis inference.""" - - dim: str - - @classmethod - def prepare(cls, patch: PatchType, dim: str) -> "EnvelopeOp": - if patch.get_coord(dim).step is None: - msg = f"Coordinate {dim} is not evenly sampled as required by envelope" - raise dc.exceptions.CoordError(msg) - return super().prepare(patch, dim=dim) - - def kernel(self, data, selected_axis): - return {"data": kernels.envelope_kernel(data, axis=selected_axis)} - - -@dataclass(frozen=True) -class WhitenOp(EagerPatchOp): - """Unified eager-backed whiten operation.""" - - patch_impl_fn = staticmethod(dc_whiten.func) - - -def get_dim_freq_range_from_kwargs_local( - patch: PatchType, - kwargs: dict[str, Any], -) -> tuple[str, Any]: - dim_set = set(patch.dims) - if not kwargs: - expected = {"time", "ft_time"} & dim_set - if not expected: - raise ParameterError( - "No dim name provided in kwargs and patch has no time dimension." - ) - return "time", None - if len(kwargs) == 1: - dim, freq_range = next(iter(kwargs.items())) - fft_dim = FourierTransformatter().rename_dims(dim)[0] - if dim not in dim_set and fft_dim not in dim_set: - raise ParameterError( - f"passed dim of {dim} to whiten but it is not in patch dimensions." - ) - return dim, freq_range - raise ParameterError( - f"Whiten kwargs must specify a single patch dimension. You passed {kwargs}." - ) - - -def check_smooth_local(fft_coord, smooth_size, water_level): - if water_level is not None: - if not isinstance(water_level, float) or water_level < 0 or water_level > 1: - raise ParameterError("water_level must be a float between 0 and 1.") - if smooth_size <= 0: - raise ParameterError("Frequency smoothing size must be positive") - if smooth_size >= fft_coord.max(): - raise ParameterError("Frequency smoothing size is larger than Nyquist") - - -def check_freq_range_local(fft_coord, freq_range): - frange = np.asarray(freq_range) - diffs = frange[1:] - frange[:-1] - min_size = fft_coord.step * 2 - if np.any(diffs < min_size): - raise ParameterError("Frequency range is too narrow") - - -def get_stft_coords_local(patch, dim, axis, coord, stft, window): - ft = FourierTransformatter() - time = stft.t(len(coord)) - if is_datetime64(coord.dtype) or is_timedelta64(coord.dtype): - time = dc.to_timedelta64(time) - new_dims = list(ft.rename_dims(patch.dims, index=axis, forward=True)) - new_dims.append(dim) - coord_map = patch.coords.disassociate_coord(dim).get_coord_tuple_map() - new_units = invert_quantity(coord.units) - coord_map.update( - { - dim: dc.get_coord(values=time + coord.min(), units=coord.units), - new_dims[axis]: dc.get_coord(values=stft.f, units=new_units), - "_stft_window": (None, window), - "_stft_old_coord": (None, patch.get_coord(dim)), - } - ) - return dc.get_coord_manager(coords=coord_map, dims=tuple(new_dims)) - - -def pad_patch( - patch: PatchType, - mode: str = "constant", - constant_values: Any = 0, - expand_coords: bool = True, - samples: bool = False, - **kwargs, -) -> PatchType: - return dc_pad.func( - patch, - mode=mode, - constant_values=constant_values, - expand_coords=expand_coords, - samples=samples, - **kwargs, - ) - - -def dft_patch( - patch: PatchType, - dim: str | None | tuple[str, ...], - *, - real: str | bool | None = None, - pad: bool = True, -) -> PatchType: - return dc_dft.func(patch, dim=dim, real=real, pad=pad) - - -def idft_patch( - patch: PatchType, - dim: str | None | tuple[str, ...] = None, -) -> PatchType: - return dc_idft.func(patch, dim=dim) - - -def hilbert_patch(patch: PatchType, dim: str) -> PatchType: - return dc_hilbert.func(patch, dim=dim) - - -def hilbert_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - dim: str, -) -> tuple[Any, tuple[Any, ...]]: - axis = get_axis_from_dims(dims, dim) - return kernels.hilbert_kernel(data, axis=axis), coord_leaves - - -def envelope_patch(patch: PatchType, dim: str) -> PatchType: - return dc_envelope.func(patch, dim=dim) - - -def envelope_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - *, - dims: tuple[str, ...], - dim: str, -) -> tuple[Any, tuple[Any, ...]]: - axis = get_axis_from_dims(dims, dim) - return kernels.envelope_kernel(data, axis=axis), coord_leaves - - -def whiten_patch( - patch: PatchType, - smooth_size: float | None = None, - water_level: float | None = None, - **kwargs, -) -> PatchType: - return dc_whiten.func( - patch, smooth_size=smooth_size, water_level=water_level, **kwargs - ) - - -def prepare_fbe_call( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> tuple[tuple[Any, ...], dict[str, Any]]: - _ = args - call_kwargs = dict(kwargs) - samples = bool(call_kwargs.pop("samples", False)) - detrend = bool(call_kwargs.pop("detrend", False)) - taper_window = call_kwargs.pop("taper_window", "hann") - overlap = call_kwargs.pop("overlap", 0) - fmin = call_kwargs.pop("fmin", None) - fmax = call_kwargs.pop("fmax", None) - (dim, axis, val) = get_dim_axis_value(patch, kwargs=call_kwargs)[0] - - def stft(): - return patch.get_coord(dim, require_evenly_sampled=True) - - coord = stft() - window_samples = coord.get_sample_count(val, samples=samples, enforce_lt_coord=True) - step = dc.to_float(coord.step) - sampling_rate = 1 / abs(step) - window = ( - taper_window - if isinstance(taper_window, np.ndarray) - else get_window(taper_window, window_samples, fftbins=False) - ) - if overlap is not None: - overlap = coord[:window_samples].get_sample_count( - overlap, samples=samples, enforce_lt_coord=True - ) - else: - overlap = 0 - hop = window_samples - overlap - stft = ShortTimeFFT( - win=window, hop=hop, fs=sampling_rate, fft_mode="onesided", mfft=window_samples - ) - frame_times = np.asarray(stft.t(len(coord))) - frame_starts = ( - np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid - ) - frequencies = np.asarray(stft.f, dtype=np.float64) - mask = np.ones(len(frequencies), dtype=bool) - if fmin is not None: - mask &= frequencies >= fmin - if fmax is not None: - mask &= frequencies <= fmax - selected_bins = np.flatnonzero(mask).astype(np.int64) - return (), { - "axis": axis, - "window": np.asarray(window), - "hop": hop, - "frame_starts": frame_starts, - "frame_times": frame_times, - "selected_bins": selected_bins, - "sample_step": step, - "detrend": detrend, - "dim": dim, - "window_samples": window_samples, - "sampling_rate": sampling_rate, - "stft_obj": stft, - } - - -@dataclass(frozen=True) -class FbeOp(PatchOp): - """Compiled fbe operation with custom reconstruction.""" - - axis: int - window: np.ndarray - hop: int - frame_starts: np.ndarray - frame_times: np.ndarray - selected_bins: np.ndarray - sample_step: float - detrend: bool - dim: str - window_samples: int - sampling_rate: float - stft_obj: Any - mutates_spec = True - requires_materialized_patch_after = True - requires_materialized_patch_for_prepare = True - compile_category = "compiled_boundary" - - @classmethod - def prepare( - cls, - patch: PatchType, - overlap: Any = 0, - samples: bool = False, - detrend: bool = False, - taper_window: str | np.ndarray | tuple = "hann", - fmin: float | None = None, - fmax: float | None = None, - **kwargs, - ) -> "FbeOp": - _, prepared = prepare_fbe_call( - patch, - (), - { - "overlap": overlap, - "samples": samples, - "detrend": detrend, - "taper_window": taper_window, - "fmin": fmin, - "fmax": fmax, - **kwargs, - }, - ) - return cls(**prepared) - - def kernel(self, data): - return { - "data": kernels.banded_stft_kernel( - data, - axis=self.axis, - window=self.window, - frame_starts=self.frame_starts, - selected_bins=self.selected_bins, - sample_step=self.sample_step, - detrend=self.detrend, - ) - } - - def reconstruct( - self, - previous_patch: PatchType, - spec, - state, - ) -> PatchType: - _ = spec - coord = previous_patch.get_coord(self.dim, require_evenly_sampled=True) - stft_cm = get_stft_coords_local( - previous_patch, - self.dim, - self.axis, - coord, - self.stft_obj, - self.window, - ) - ft_dim = stft_cm.dims[self.axis] - coord_map = { - name: value - for name, value in stft_cm.get_coord_tuple_map().items() - if name != ft_dim - } - dims = tuple(dim for dim in stft_cm.dims if dim != ft_dim) - return dc.Patch( - data=np.asarray(state.data), - coords=coord_map, - dims=dims, - attrs=previous_patch.attrs, - ) - - -def fbe_patch( - patch: PatchType, - overlap: Any = 0, - samples: bool = False, - detrend: bool = False, - taper_window: str | np.ndarray | tuple = "hann", - fmin: float | None = None, - fmax: float | None = None, - **kwargs, -) -> PatchType: - _, prepared = prepare_fbe_call( - patch, - (), - { - "overlap": overlap, - "samples": samples, - "detrend": detrend, - "taper_window": taper_window, - "fmin": fmin, - "fmax": fmax, - **kwargs, - }, - ) - reduced = kernels.banded_stft_kernel( - patch.data, - axis=prepared["axis"], - window=prepared["window"], - frame_starts=prepared["frame_starts"], - selected_bins=prepared["selected_bins"], - sample_step=prepared["sample_step"], - detrend=prepared["detrend"], - ) - coord = patch.get_coord(prepared["dim"], require_evenly_sampled=True) - stft_cm = get_stft_coords_local( - patch, - prepared["dim"], - prepared["axis"], - coord, - prepared["stft_obj"], - prepared["window"], - ) - ft_dim = stft_cm.dims[prepared["axis"]] - coord_map = { - name: value - for name, value in stft_cm.get_coord_tuple_map().items() - if name != ft_dim - } - dims = tuple(dim for dim in stft_cm.dims if dim != ft_dim) - return dc.Patch( - data=np.asarray(reduced), coords=coord_map, dims=dims, attrs=patch.attrs - ) - - -def baseline_fbe_patch( - patch: PatchType, - args: tuple[Any, ...], - kwargs: dict[str, Any], -) -> PatchType: - call_kwargs = dict(kwargs) - fmin = call_kwargs.pop("fmin", None) - fmax = call_kwargs.pop("fmax", None) - out = patch.stft(**call_kwargs).abs() - ft_dim = next(dim for dim in out.dims if dim.startswith("ft_")) - if fmin is not None or fmax is not None: - out = out.select(**{ft_dim: (fmin, fmax)}) - return out.sum(dim=ft_dim, dim_reduce="squeeze") diff --git a/src/dasjax/operations/spectral/specs.py b/src/dasjax/operations/spectral/specs.py deleted file mode 100644 index fbb90dd..0000000 --- a/src/dasjax/operations/spectral/specs.py +++ /dev/null @@ -1,182 +0,0 @@ -"""Registry specs for spectral operations.""" - -from __future__ import annotations - -import dascore as dc -from dascore.proc.basic import pad as dc_pad -from dascore.proc.whiten import whiten as dc_whiten -from dascore.transform.fourier import dft as dc_dft -from dascore.transform.fourier import idft as dc_idft -from dascore.transform.hilbert import envelope as dc_envelope -from dascore.transform.hilbert import hilbert as dc_hilbert - -from ..common import ( - get_preferred_transform_dim, - prepare_even_patch_for_dim, - prepare_fourier_patch, - resolve_even_dim_call, -) -from ..types import ExecutionPolicy, OperationCase, OperationSpec -from . import impl - -OPERATIONS: tuple[OperationSpec, ...] = ( - OperationSpec( - name="pad", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.pad_patch), - patch_op_cls=impl.PadOp, - test_cases=( - OperationCase( - case_id="pad-constant", - resolve_call=lambda patch: ( - (), - { - "mode": "constant", - "samples": True, - get_preferred_transform_dim(patch): (2, 3), - }, - ), - prepare_patch=prepare_even_patch_for_dim, - baseline=lambda patch, args, kwargs: impl.pad_patch( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="pad-fft", - resolve_call=lambda patch: ( - (), - {get_preferred_transform_dim(patch): "fft"}, - ), - baseline=lambda patch, args, kwargs: dc_pad.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="dft", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.dft_patch), - patch_op_cls=impl.DftOp, - test_cases=( - OperationCase( - case_id="dft-real", - resolve_call=lambda patch: ((), {"dim": patch.dims[-1], "real": True}), - baseline=lambda patch, args, kwargs: dc_dft.func( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="dft-full", - resolve_call=lambda patch: ( - (), - {"dim": patch.dims[-1], "real": None, "pad": False}, - ), - baseline=lambda patch, args, kwargs: dc_dft.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="idft", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.idft_patch), - patch_op_cls=impl.IdftOp, - test_cases=( - OperationCase( - case_id="idft-real", - resolve_call=lambda patch: ((), {}), - prepare_patch=prepare_fourier_patch, - baseline=lambda patch, args, kwargs: dc_idft.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="hilbert", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.hilbert_patch), - patch_op_cls=impl.HilbertOp, - test_cases=( - OperationCase( - case_id="hilbert-time", - resolve_call=lambda patch: resolve_even_dim_call(patch), - baseline=lambda patch, args, kwargs: dc_hilbert.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="envelope", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.envelope_patch), - patch_op_cls=impl.EnvelopeOp, - test_cases=( - OperationCase( - case_id="envelope-time", - resolve_call=lambda patch: resolve_even_dim_call(patch), - baseline=lambda patch, args, kwargs: dc_envelope.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="whiten", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.whiten_patch), - patch_op_cls=impl.WhitenOp, - test_cases=( - OperationCase( - case_id="whiten-default", - resolve_call=lambda patch: ( - (), - {get_preferred_transform_dim(patch): None}, - ), - baseline=lambda patch, args, kwargs: dc_whiten.func( - patch, *args, **kwargs - ), - ), - OperationCase( - case_id="whiten-band-limited", - resolve_call=lambda patch: ( - (), - { - "smooth_size": 3.0, - get_preferred_transform_dim(patch): (5.0, 10.0, 20.0, 25.0), - }, - ), - baseline=lambda patch, args, kwargs: dc_whiten.func( - patch, *args, **kwargs - ), - ), - ), - ), - OperationSpec( - name="fbe", - execution_policy=ExecutionPolicy.PATCH, - patch_impl=dc.patch_function(history="method_name")(impl.fbe_patch), - patch_op_cls=impl.FbeOp, - prepare_call=impl.prepare_fbe_call, - test_cases=( - OperationCase( - case_id="fbe-default", - resolve_call=lambda patch: ( - (), - { - patch.dims[-1]: 64, - "samples": True, - "overlap": 32, - "fmin": 2.0, - "fmax": 10.0, - }, - ), - prepare_patch=prepare_even_patch_for_dim, - baseline=impl.baseline_fbe_patch, - ), - ), - ), -) diff --git a/src/dasjax/operations/types.py b/src/dasjax/operations/types.py deleted file mode 100644 index d32724a..0000000 --- a/src/dasjax/operations/types.py +++ /dev/null @@ -1,75 +0,0 @@ -"""Shared types for operation specs and registry assembly.""" - -from __future__ import annotations - -from collections.abc import Callable -from dataclasses import dataclass, field -from enum import Enum -from typing import Any - -from dascore.constants import PatchType - -from .patch_ops import PatchOp - -LeafTransform = Callable[..., tuple[Any, tuple[Any, ...]]] -PatchValidator = Callable[..., None] -CompiledPatchValidator = Callable[[PatchType, tuple[Any, ...], dict[str, Any]], None] -CompiledFallbackReason = Callable[ - [PatchType, tuple[Any, ...], dict[str, Any]], str | None -] -CompiledCaseGuard = Callable[ - [PatchType, tuple[Any, ...], dict[str, Any]], - tuple[type[Exception], str] | None, -] -CallResolver = Callable[[PatchType], tuple[tuple[Any, ...], dict[str, Any]]] -Baseline = Callable[[PatchType, tuple[Any, ...], dict[str, Any]], PatchType] -PatchPreparer = Callable[[PatchType], PatchType] -CallPreparer = Callable[ - [PatchType, tuple[Any, ...], dict[str, Any]], - tuple[tuple[Any, ...], dict[str, Any]], -] - - -class ExecutionPolicy(str, Enum): - """How one operation executes inside compiled pipelines.""" - - LEAF = "leaf" - PATCH = "patch" - - -def _identity_prepare(patch: PatchType) -> PatchType: - return patch - - -def empty_call(_: PatchType) -> tuple[tuple[Any, ...], dict[str, Any]]: - return (), {} - - -@dataclass(frozen=True) -class OperationCase: - """One shared test case for eager and compiled parity.""" - - case_id: str - resolve_call: CallResolver - baseline: Baseline - prepare_patch: PatchPreparer = _identity_prepare - compiled_baseline: Baseline | None = None - compiled_error: type[Exception] | None = None - compiled_error_message: str | None = None - compiled_guard: CompiledCaseGuard | None = None - - -@dataclass(frozen=True) -class OperationSpec: - """Read-only operation spec for patch namespace and pipeline support.""" - - name: str - execution_policy: ExecutionPolicy - patch_impl: Callable[..., PatchType] - patch_op_cls: type[PatchOp] | None = None - leaf_transform: LeafTransform | None = None - prepare_call: CallPreparer | None = None - validate_patch: PatchValidator | None = None - validate_compiled_patch: CompiledPatchValidator | None = None - compiled_fallback_reason: CompiledFallbackReason | None = None - test_cases: tuple[OperationCase, ...] = field(default_factory=tuple) diff --git a/src/dasjax/pipeline.py b/src/dasjax/pipeline.py index baf8b35..d31ea9e 100644 --- a/src/dasjax/pipeline.py +++ b/src/dasjax/pipeline.py @@ -3,20 +3,17 @@ from __future__ import annotations from collections import OrderedDict -from dataclasses import dataclass +from dataclasses import dataclass, fields, is_dataclass from typing import Any, ClassVar import jax import numpy as np from jax import tree_util -from .operations import ExecutionPolicy, get_operation -from .operations.patch_ops import patch_to_state_spec -from .pytree import patch_to_leaves, patch_from_leaves +from .core import PatchPyTree, get_patch_operation _COMPILED_CACHE_MAXSIZE = 128 _SEGMENT_CACHE_MAXSIZE = 128 -_VALIDATION_CACHE_MAXSIZE = 64 @dataclass(frozen=True) @@ -28,6 +25,32 @@ class PipelineStep: kwargs: dict[str, Any] +@dataclass(frozen=True) +class PipelinePlanSegment: + """One planned execution segment for a patch pipeline.""" + + kind: str + operations: tuple[str, ...] + fused: bool + jitted: bool + input_dims: tuple[str, ...] = () + output_dims: tuple[str, ...] = () + reason: str | None = None + + +@dataclass(frozen=True) +class PipelinePlan: + """Diagnostic execution plan for a patch pipeline.""" + + segments: tuple[PipelinePlanSegment, ...] + uses_core: bool + + @property + def fused_kernel_count(self) -> int: + """Return the number of JIT-fused execution segments.""" + return sum(segment.jitted for segment in self.segments) + + class _BoundedCache: """A small insertion-ordered cache with LRU eviction.""" @@ -98,70 +121,21 @@ def _freeze_value(value: Any) -> Any: return tuple(sorted(_freeze_value(item) for item in value)) try: hash(value) - except TypeError as exc: - msg = f"Unhashable pipeline argument {value!r} cannot be compiled." - raise TypeError(msg) from exc + except TypeError: + return repr(value) return value -def _build_segments( - resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...], -) -> list[tuple[str, Any]]: - """Split steps into compiled segments and eager patch-executed steps. - - Returns a list of tagged tuples: - ("patchop", tuple_of_resolved_steps) — compiled PatchOp segment - ("leaf", tuple_of_resolved_steps) — compiled legacy leaf segment - ("patch", (op, args, kwargs)) — eager patch_impl step - """ - segments: list[tuple[str, Any]] = [] - patchop_run: list[Any] = [] - patchop_has_structural = False - leaf_run: list[Any] = [] - for op, args, kwargs in resolved_steps: - if op.patch_op_cls is not None: - if leaf_run: - segments.append(("leaf", tuple(leaf_run))) - leaf_run = [] - if ( - patchop_run - and patchop_has_structural - and getattr( - op.patch_op_cls, "requires_materialized_patch_for_prepare", False - ) - ): - segments.append(("patchop", tuple(patchop_run))) - patchop_run = [] - patchop_has_structural = False - patchop_run.append((op, args, kwargs)) - patchop_has_structural = patchop_has_structural or getattr( - op.patch_op_cls, "mutates_spec", False - ) - if getattr(op.patch_op_cls, "requires_materialized_patch_after", False): - segments.append(("patchop", tuple(patchop_run))) - patchop_run = [] - patchop_has_structural = False - continue - if op.execution_policy is ExecutionPolicy.PATCH: - if patchop_run: - segments.append(("patchop", tuple(patchop_run))) - patchop_run = [] - patchop_has_structural = False - if leaf_run: - segments.append(("leaf", tuple(leaf_run))) - leaf_run = [] - segments.append(("patch", (op, args, kwargs))) - else: - if patchop_run: - segments.append(("patchop", tuple(patchop_run))) - patchop_run = [] - patchop_has_structural = False - leaf_run.append((op, args, kwargs)) - if patchop_run: - segments.append(("patchop", tuple(patchop_run))) - if leaf_run: - segments.append(("leaf", tuple(leaf_run))) - return segments +def _operation_key(operation: Any) -> tuple[Any, ...]: + """Return a stable cache key for a bound core operation.""" + if is_dataclass(operation): + entries = tuple( + (field.name, _freeze_value(getattr(operation, field.name))) + for field in fields(operation) + ) + else: + entries = tuple((key, _freeze_value(value)) for key, value in vars(operation).items()) + return type(operation).operation_name(), entries class JaxPatchPipeline: @@ -181,7 +155,7 @@ def steps(self) -> tuple[PipelineStep, ...]: def __getattr__(self, name: str): """Record only known JAX patch operations.""" - get_operation(name) + get_patch_operation(name) def _record(*args: Any, **kwargs: Any) -> "JaxPatchPipeline": step = PipelineStep(name=name, args=args, kwargs=dict(kwargs)) @@ -232,74 +206,133 @@ def _validation_signature(patch) -> tuple[Any, ...]: coord_sig, ) - def _resolve_steps(self) -> tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...]: - """Resolve operation names into operation specs once.""" + def _resolve_operations(self) -> tuple[Any, ...]: + """Return class-authored operation instances.""" return tuple( - (get_operation(step.name), step.args, step.kwargs) for step in self._steps + get_patch_operation(step.name)(*step.args, **step.kwargs) + for step in self._steps ) @staticmethod - def _freeze_resolved_steps( - resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...], - ) -> tuple[Any, ...]: - return tuple( - ( - op.name, - _freeze_value(args), - _freeze_value(kwargs), - ) - for op, args, kwargs in resolved_steps - ) + def _build_core_runner(operations: tuple[Any, ...]): + """Build a class-authored PatchPyTree operation segment.""" - @staticmethod - def _compile_leaf_runner( - resolved_steps: tuple[tuple[Any, tuple[Any, ...], dict[str, Any]], ...], - ): - """Compile the leaf-native execution path once per pipeline definition.""" - - def _run(data, coord_leaves, dims): - for op, args, kwargs in resolved_steps: - assert op.leaf_transform is not None - data, coord_leaves = op.leaf_transform( - data, - coord_leaves, - *args, - dims=dims, - **kwargs, - ) - return data, coord_leaves + def _run(patch_tree): + current = patch_tree + for operation in operations: + current = operation.kernel(current) + return current - return jax.jit(_run, static_argnums=2) + return jax.jit(_run) @staticmethod - def _compile_patchop_runner(prepared_ops: tuple[Any, ...]): - """Compile one unified PatchOp segment.""" + def _plan_core_segments( + operations: tuple[Any, ...], + boundary: Any, + ) -> tuple[tuple[tuple[Any, ...], Any, bool], ...]: + """Bind operations and statically advance boundaries for JAX segments.""" + segments: list[tuple[tuple[Any, ...], Any, bool]] = [] + start_index = 0 + while start_index < len(operations): + bound_ops, boundary, needs_result_boundary, start_index = ( + JaxPatchPipeline._plan_core_segment( + operations, + boundary, + start_index, + ) + ) + segments.append((bound_ops, boundary, needs_result_boundary)) + if needs_result_boundary: + break + return tuple(segments) - def _run(state): - current_state = state - for prepared_op in prepared_ops: - current_state = prepared_op.apply(current_state) - return current_state + @staticmethod + def _plan_core_segment( + operations: tuple[Any, ...], + boundary: Any, + start_index: int, + ) -> tuple[tuple[Any, ...], Any, bool, int]: + """Bind one executable segment, stopping at result-dependent metadata.""" + segment_ops: list[Any] = [] + current_boundary = boundary + op_index = start_index + while op_index < len(operations): + operation = operations[op_index] + bound_operation = operation.bind(current_boundary) + segment_ops.append(bound_operation) + if type(bound_operation).overrides("update_boundary"): + current_boundary = bound_operation.update_boundary(current_boundary) + needs_result_boundary = type(bound_operation).overrides( + "update_boundary_from_result" + ) + stops_segment = needs_result_boundary + op_index += 1 + if stops_segment: + return ( + tuple(segment_ops), + current_boundary, + needs_result_boundary, + op_index, + ) + return tuple(segment_ops), current_boundary, False, op_index - return jax.jit(_run) + def assert_no_fallback(self, patch) -> None: + """No-op compatibility method; core pipelines have no legacy fallback.""" + _ = patch - def _get_compiled_fallback_reasons(self, patch) -> tuple[str, ...]: - resolved_steps = self._resolve_steps() - reasons = [] - for op, args, kwargs in resolved_steps: - if op.compiled_fallback_reason is None: - continue - reason = op.compiled_fallback_reason(patch, args, kwargs) - if reason is not None: - reasons.append(f"{op.name}: {reason}") - return tuple(reasons) + def plan(self, patch) -> PipelinePlan: + """Return a diagnostic execution plan for this pipeline and patch.""" + return self._plan_core_execution(patch, self._resolve_operations()) - def assert_no_fallback(self, patch) -> None: - """Raise if any step would use a host fallback for this patch.""" - reasons = self._get_compiled_fallback_reasons(patch) - if reasons: - msg = "Compiled pipeline would use host fallbacks:\n" + "\n".join(reasons) - raise AssertionError(msg) + def _plan_core_execution( + self, + patch, + core_operations: tuple[Any, ...], + ) -> PipelinePlan: + """Plan class-authored core execution without running kernels.""" + _, boundary = PatchPyTree.from_patch(patch) + segments: list[PipelinePlanSegment] = [] + op_index = 0 + while op_index < len(core_operations): + input_dims = boundary.dims + bound_ops, planned_boundary, needs_result_boundary, op_index = ( + self._plan_core_segment(core_operations, boundary, op_index) + ) + reason = ( + "requires result-dependent boundary update" + if needs_result_boundary + else None + ) + segments.append( + PipelinePlanSegment( + kind="core", + operations=tuple(type(op).operation_name() for op in bound_ops), + fused=len(bound_ops) > 1, + jitted=True, + input_dims=input_dims, + output_dims=planned_boundary.dims, + reason=reason, + ) + ) + boundary = planned_boundary + if needs_result_boundary: + if op_index < len(core_operations): + remaining = core_operations[op_index:] + segments.append( + PipelinePlanSegment( + kind="unplanned", + operations=tuple( + type(op).operation_name() for op in remaining + ), + fused=False, + jitted=False, + input_dims=boundary.dims, + output_dims=(), + reason="requires executing previous segment first", + ) + ) + break + return PipelinePlan(segments=tuple(segments), uses_core=True) def compile( self, @@ -310,9 +343,8 @@ def compile( ): """Compile the recorded steps into a callable `Patch -> Patch`. - Leaf-native operations are fused into jax.jit-compiled segments. - Patch-native operations run eagerly via patch_impl between those - segments, so compiled pipelines can mix both execution modes. + Class-authored operations are bound against a patch boundary, grouped + into JIT segments, and reconstructed through the final boundary. """ target_device = _resolve_target_device(device=device, backend=backend) cache_key = self._compile_cache_key( @@ -324,105 +356,40 @@ def compile( if cached is not None: return cached - resolved_steps = self._resolve_steps() - segments = _build_segments(resolved_steps) - # One inner cache dict per leaf segment (None for patch slots). - compiled_by_segment: list[_BoundedCache | None] = [ - _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE) - if kind in {"leaf", "patchop"} - else None - for kind, _ in segments - ] - validated_signatures = _BoundedCache(maxsize=_VALIDATION_CACHE_MAXSIZE) - fallback_checked_signatures = _BoundedCache(maxsize=_VALIDATION_CACHE_MAXSIZE) + operations = self._resolve_operations() + core_segment_cache = _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE) def _compiled_patch_fn(patch): - patch_signature = self._validation_signature(patch) - if ( - assert_no_fallback - and fallback_checked_signatures.get(patch_signature) is None - ): - self.assert_no_fallback(patch) - fallback_checked_signatures.add(patch_signature, True) - if validated_signatures.get(patch_signature) is None: - for op, args, kwargs in resolved_steps: - if op.validate_patch is not None: - op.validate_patch(patch, *args, **kwargs) - if op.validate_compiled_patch is not None: - op.validate_compiled_patch(patch, args, kwargs) - validated_signatures.add(patch_signature, True) - - current_patch = patch - for seg_idx, (kind, seg_data) in enumerate(segments): - if kind == "patch": - op, args, kwargs = seg_data - current_patch = op.patch_impl(current_patch, *args, **kwargs) - elif kind == "patchop": - prepared_ops = tuple( - op.patch_op_cls.prepare(current_patch, *args, **kwargs) - for op, args, kwargs in seg_data - ) - prepared_key = tuple( - prepared_op.compile_key() for prepared_op in prepared_ops - ) - seg_cache = compiled_by_segment[seg_idx] - compiled = seg_cache.get(prepared_key) - if compiled is None: - compiled = self._compile_patchop_runner(prepared_ops) - seg_cache.add(prepared_key, compiled) - state, spec = patch_to_state_spec(current_patch) - if target_device is not None: - state = tree_util.tree_map( - lambda x: jax.device_put(x, device=target_device), state - ) - out_state = compiled(state) - out_spec = spec - for prepared_op in prepared_ops: - out_spec = out_spec.apply_meta(prepared_op.meta_delta(out_spec)) - current_patch = prepared_ops[-1].reconstruct( - current_patch, - out_spec, - out_state, + patch_tree, boundary = PatchPyTree.from_patch(patch) + current_tree = patch_tree + current_boundary = boundary + op_index = 0 + while op_index < len(operations): + bound_ops, planned_boundary, needs_result_boundary, op_index = ( + self._plan_core_segment( + operations, + current_boundary, + op_index, ) - else: - leaf_steps = seg_data - prepared_steps = tuple( - (op, *op.prepare_call(current_patch, args, kwargs)) - if op.prepare_call is not None - else (op, args, kwargs) - for op, args, kwargs in leaf_steps - ) - prepared_key = self._freeze_resolved_steps(prepared_steps) - seg_cache = compiled_by_segment[seg_idx] - compiled = seg_cache.get(prepared_key) - if compiled is None: - compiled = self._compile_leaf_runner(prepared_steps) - seg_cache.add(prepared_key, compiled) - data, coord_leaves, aux_data = patch_to_leaves(current_patch) - if target_device is not None: - data = jax.device_put(data, device=target_device) - coord_leaves = tree_util.tree_map( - lambda x: jax.device_put(x, device=target_device), - coord_leaves, - ) - out_data, out_coord_leaves = compiled( - data, - coord_leaves, - aux_data["dims"], - ) - next_kind = ( - segments[seg_idx + 1][0] - if seg_idx + 1 < len(segments) - else None + ) + segment_key = tuple(_operation_key(bound_operation) for bound_operation in bound_ops) + compiled = core_segment_cache.get(segment_key) + if compiled is None: + compiled = self._build_core_runner(bound_ops) + core_segment_cache.add(segment_key, compiled) + if target_device is not None: + current_tree = tree_util.tree_map( + lambda x: jax.device_put(x, device=target_device), + current_tree, ) - current_patch = patch_from_leaves( - out_data, - out_coord_leaves, - aux_data, - coerce_numpy=next_kind != "leaf", + current_tree = compiled(current_tree) + current_boundary = planned_boundary + if needs_result_boundary: + current_boundary = bound_ops[-1].update_boundary_from_result( + current_tree, + current_boundary, ) - - return current_patch + return current_boundary.to_patch(current_tree) self._compiled_cache.add(cache_key, _compiled_patch_fn) return _compiled_patch_fn diff --git a/src/dasjax/pytree.py b/src/dasjax/pytree.py deleted file mode 100644 index 1a01c0a..0000000 --- a/src/dasjax/pytree.py +++ /dev/null @@ -1,102 +0,0 @@ -"""JAX pytree registration for DASCore patches.""" - -from __future__ import annotations - -from typing import Any - -import dascore as dc -import jax -import numpy as np - -SUPPORTED_DTYPES = (np.bool_, np.integer, np.floating, np.complexfloating) -TIME_DTYPES = (np.datetime64, np.timedelta64) - - -def _matches_dtype(dtype: np.dtype, candidates: tuple[type[Any], ...]) -> bool: - """Return True if dtype is a subdtype of any candidate.""" - return any(np.issubdtype(dtype, candidate) for candidate in candidates) - - -def _encode_leaf(array: Any) -> tuple[Any, str]: - """Return a JAX-friendly leaf and a dtype token for reconstruction.""" - arr = np.asarray(array) - dtype_token = arr.dtype.str - if _matches_dtype(arr.dtype, SUPPORTED_DTYPES): - return arr, dtype_token - if _matches_dtype(arr.dtype, TIME_DTYPES): - return arr.view(np.int64), dtype_token - msg = f"Unsupported coordinate dtype for JAX pytree registration: {arr.dtype}" - raise TypeError(msg) - - -def _decode_leaf(array: Any, dtype_token: str) -> np.ndarray: - """Restore an encoded leaf to its original dtype.""" - out = np.asarray(array) - dtype = np.dtype(dtype_token) - if _matches_dtype(dtype, TIME_DTYPES): - return out.astype(np.int64, copy=False).view(dtype) - return out.astype(dtype, copy=False) - - -def patch_to_leaves(patch: dc.Patch) -> tuple[Any, tuple[Any, ...], dict[str, Any]]: - """Split a patch into dynamic leaves and static reconstruction metadata.""" - coord_names = tuple(patch.coords.coord_map) - coord_leaves = [] - coord_meta = [] - for name in coord_names: - coord = patch.coords.coord_map[name] - encoded_values, dtype_token = _encode_leaf(coord.values) - coord_leaves.append(encoded_values) - coord_meta.append( - { - "name": name, - "dims": tuple(patch.coords.dim_map[name]), - "dtype": dtype_token, - "coord": coord, - } - ) - aux_data = { - "dims": tuple(patch.dims), - "attrs": patch.attrs, - "coord_meta": tuple(coord_meta), - } - return patch.data, tuple(coord_leaves), aux_data - - -def patch_from_leaves( - data: Any, - coord_leaves: tuple[Any, ...], - aux_data: dict[str, Any], - *, - coerce_numpy: bool = True, -) -> dc.Patch: - """Rebuild a patch from pytree leaves and static metadata.""" - coords: dict[str, Any] = {} - for meta, leaf in zip(aux_data["coord_meta"], coord_leaves, strict=True): - values = _decode_leaf(leaf, meta["dtype"]) - coord = meta["coord"].update_data(data=values) - dims = tuple(meta["dims"]) - coords[meta["name"]] = ( - coord if len(dims) == 1 and dims[0] == meta["name"] else (dims, coord) - ) - return dc.Patch( - data=np.asarray(data) if coerce_numpy else data, - coords=coords, - dims=aux_data["dims"], - attrs=aux_data["attrs"], - ) - - -def _flatten_patch(patch: dc.Patch) -> tuple[tuple[Any, ...], dict[str, Any]]: - """JAX pytree flatten hook.""" - data, coord_leaves, aux_data = patch_to_leaves(patch) - return (data, *coord_leaves), aux_data - - -def _unflatten_patch(aux_data: dict[str, Any], children: tuple[Any, ...]) -> dc.Patch: - """JAX pytree unflatten hook.""" - data, *coord_leaves = children - return patch_from_leaves(data, tuple(coord_leaves), aux_data) - - -jax.tree_util.register_pytree_node(dc.Patch, _flatten_patch, _unflatten_patch) diff --git a/tests/test_core_api.py b/tests/test_core_api.py new file mode 100644 index 0000000..b74cea4 --- /dev/null +++ b/tests/test_core_api.py @@ -0,0 +1,292 @@ +"""Tests for the class-authored core operation API.""" + +from __future__ import annotations + +from dataclasses import dataclass, replace +from typing import ClassVar + +import dascore as dc +import jax +import numpy as np + +from dasjax import JaxPatchPipeline, PatchBoundary, PatchOperation, PatchPyTree +from dasjax.core import get_patch_operation, list_patch_operations + + +@dataclass(frozen=True) +class RenameTimeToFtForTest(PatchOperation): + """Test operation that statically changes the time dimension name.""" + + register = False + method_name: ClassVar[str | None] = "rename_time_to_ft_for_test" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + dims = tuple("ft_time" if dim == "time" else dim for dim in patch_tree.dims) + return patch_tree.new(dims=dims) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + coords = boundary.coords.rename_coord(time="ft_time") + coord_names = tuple( + "ft_time" if name == "time" else name for name in boundary.coord_names + ) + return boundary.new(coords=coords, coord_names=coord_names) + + +@dataclass(frozen=True) +class AddBoundAxisForTest(PatchOperation): + """Test operation that must bind against the current boundary.""" + + register = False + method_name: ClassVar[str | None] = "add_bound_axis_for_test" + dim: str + axis: int | None = None + + def bind(self, boundary: PatchBoundary): + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new(data=patch_tree.data + self.axis) + + +@dataclass(frozen=True) +class ResultRenameTimeToFtForTest(PatchOperation): + """Test operation that only knows its boundary after execution.""" + + register = False + method_name: ClassVar[str | None] = "result_rename_time_to_ft_for_test" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + dims = tuple("ft_time" if dim == "time" else dim for dim in patch_tree.dims) + return patch_tree.new(dims=dims) + + def update_boundary_from_result( + self, + patch_tree: PatchPyTree, + boundary: PatchBoundary, + ) -> PatchBoundary: + _ = patch_tree + coords = boundary.coords.rename_coord(time="ft_time") + coord_names = tuple( + "ft_time" if name == "time" else name for name in boundary.coord_names + ) + return boundary.new(coords=coords, coord_names=coord_names) + + +def test_patch_pytree_roundtrip_restores_patch() -> None: + """Round-trip a DASCore patch through the new PatchPyTree model.""" + patch = dc.get_example_patch() + + patch_tree, boundary = PatchPyTree.from_patch(patch) + out = boundary.to_patch(patch_tree) + + assert out.equals(patch) + + +def test_patch_pytree_flattens_dynamic_coord_values_and_codes() -> None: + """Expose ordered coord values and dtype codes while keeping only dims static.""" + patch = dc.get_example_patch() + patch_tree, _ = PatchPyTree.from_patch(patch) + + leaves, tree = jax.tree_util.tree_flatten(patch_tree) + out = jax.tree_util.tree_unflatten(tree, leaves) + _, aux_data = patch_tree.tree_flatten() + + assert len(leaves) == 1 + 2 * len(patch.coords.coord_map) + assert aux_data == {"dims": tuple(patch.dims)} + assert out.dims == tuple(patch.dims) + + +def test_patch_pytree_restores_datetime_coords() -> None: + """Restore datetime coordinates after dynamic JAX conversion.""" + patch = dc.get_example_patch() + + patch_tree, boundary = PatchPyTree.from_patch(patch) + out = boundary.to_patch(patch_tree) + + assert out.get_coord("time").dtype == patch.get_coord("time").dtype + assert np.array_equal(out.get_coord("time").values, patch.get_coord("time").values) + + +def test_patch_boundary_swaps_dynamic_coord_values() -> None: + """Rebuild coords by replacing values while preserving coord metadata.""" + patch = dc.get_example_patch() + patch_tree, boundary = PatchPyTree.from_patch(patch) + distance_idx = boundary.coord_names.index("distance") + coord_values = list(patch_tree.coord_values) + coord_values[distance_idx] = np.asarray(coord_values[distance_idx]) + 1 + + out = boundary.to_patch(patch_tree.new(coords=tuple(coord_values))) + + assert np.array_equal( + out.get_coord("distance").values, + patch.get_coord("distance").values + 1, + ) + assert out.get_coord("distance").units == patch.get_coord("distance").units + + +def test_patch_boundary_exposes_author_metadata_helpers() -> None: + """Provide a compact metadata API for operation binding.""" + patch = dc.get_example_patch() + _, boundary = PatchPyTree.from_patch(patch) + + assert boundary.dims == tuple(patch.dims) + assert boundary.axis("time") == patch.get_axis("time") + assert boundary.coord("time") == patch.get_coord("time") + assert boundary.coord_dims("time") == ("time",) + assert boundary.coord_index("time") == boundary.coord_names.index("time") + + +def test_patch_pytree_new_updates_data_and_ordered_coord_values() -> None: + """Mirror Patch.new-style immutable updates for JAX patch trees.""" + patch = dc.get_example_patch() + patch_tree, boundary = PatchPyTree.from_patch(patch) + distance_idx = boundary.coord_names.index("distance") + coord_values = list(patch_tree.coord_values) + coord_values[distance_idx] = np.asarray(coord_values[distance_idx]) + 2 + + out_tree = patch_tree.new(data=patch_tree.data + 1, coords=tuple(coord_values)) + out = boundary.to_patch(out_tree) + + assert np.array_equal(out.data, patch.data + 1) + assert np.array_equal( + out.get_coord("distance").values, + patch.get_coord("distance").values + 2, + ) + + +def test_operation_subclasses_register_pipeline_names() -> None: + """Register class-authored operations by snake-case class name.""" + assert "scale" in list_patch_operations() + assert get_patch_operation("scale").operation_name() == "scale" + + +def test_compiled_pipeline_uses_class_authored_basic_operations() -> None: + """Run a fully ported class-authored chain through JaxPatchPipeline.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().scale(2.0).add(1.0).clip(-1.0, 1.0) + + out = pipeline.compile()(patch) + expected = patch.update(data=np.clip(patch.data * 2.0 + 1.0, -1.0, 1.0)) + + assert np.allclose(out.data, expected.data) + assert out.coords == expected.coords + + +def test_core_planner_binds_against_static_boundary_updates() -> None: + """Bind later ops against planned boundaries before running a JIT segment.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time") + + out = pipeline.compile()(patch) + + assert out.dims == ("distance", "ft_time") + + +def test_core_planner_keeps_static_boundary_updates_in_one_segment() -> None: + """Static boundary changes should not force a core segment boundary.""" + patch = dc.get_example_patch() + _, boundary = PatchPyTree.from_patch(patch) + operations = ( + RenameTimeToFtForTest(), + AddBoundAxisForTest("ft_time"), + ) + + segments = JaxPatchPipeline._plan_core_segments(operations, boundary) + + assert len(segments) == 1 + bound_ops, planned_boundary, needs_result_boundary = segments[0] + assert len(bound_ops) == 2 + assert planned_boundary.dims == ("distance", "ft_time") + assert not needs_result_boundary + assert bound_ops[1].axis == 1 + + +def test_pipeline_plan_reports_core_fused_segments() -> None: + """Expose the planned core execution path without running kernels.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time") + + plan = pipeline.plan(patch) + + assert plan.uses_core + assert plan.fused_kernel_count == 1 + assert len(plan.segments) == 1 + segment = plan.segments[0] + assert segment.kind == "core" + assert segment.operations == ("dft", "normalize") + assert segment.fused + assert segment.jitted + assert segment.input_dims == ("distance", "time") + assert segment.output_dims == ("distance", "ft_time") + + +def test_core_planner_restarts_after_result_boundary_updates() -> None: + """Result-dependent boundary changes stop planning until after execution.""" + patch = dc.get_example_patch() + patch_tree, boundary = PatchPyTree.from_patch(patch) + op = ResultRenameTimeToFtForTest() + bound_ops, planned_boundary, needs_result_boundary, op_index = ( + JaxPatchPipeline._plan_core_segment((op,), boundary, 0) + ) + out_tree = bound_ops[0].kernel(patch_tree) + out_boundary = bound_ops[0].update_boundary_from_result( + out_tree, planned_boundary + ) + out = out_boundary.to_patch(out_tree) + + assert out.dims == ("distance", "ft_time") + assert needs_result_boundary + assert op_index == 1 + + +def test_pipeline_plan_reports_unplanned_result_boundary_tail() -> None: + """Show where planning must pause for result-dependent metadata.""" + patch = dc.get_example_patch() + _, boundary = PatchPyTree.from_patch(patch) + + segments = JaxPatchPipeline._plan_core_segments( + (ResultRenameTimeToFtForTest(), AddBoundAxisForTest("ft_time")), + boundary, + ) + + assert len(segments) == 1 + assert segments[0][2] + + +def test_pipeline_plan_reports_core_segments_for_all_operations() -> None: + """Expose core execution segments for formerly registry-backed operations.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().detrend("time").normalize("time") + + plan = pipeline.plan(patch) + + assert plan.uses_core + assert plan.fused_kernel_count == 1 + assert len(plan.segments) == 1 + assert plan.segments[0].kind == "core" + assert plan.segments[0].operations == ("detrend", "normalize") + assert plan.segments[0].fused + assert plan.segments[0].jitted + + +def test_metadata_hook_uses_dascore_native_objects() -> None: + """Pass native DASCore attrs and coord manager into metadata hooks.""" + + @dataclass(frozen=True) + class _MetadataProbe(PatchOperation): + register = False + + def update_boundary(self, boundary): + assert boundary.attrs.__class__.__name__ == "PatchAttrs" + assert hasattr(boundary.coords, "coord_map") + return boundary + + patch = dc.get_example_patch() + patch_tree, boundary = PatchPyTree.from_patch(patch) + metadata_op = _MetadataProbe() + + assert type(metadata_op).overrides("update_boundary") + out = metadata_op.update_boundary(boundary).to_patch(metadata_op.kernel(patch_tree)) + + assert out.equals(patch) diff --git a/tests/test_method_equivalence.py b/tests/test_method_equivalence.py index 6da6305..e504119 100644 --- a/tests/test_method_equivalence.py +++ b/tests/test_method_equivalence.py @@ -1,107 +1,104 @@ -"""Compare internal dasjax operations against DASCore baselines.""" +"""Compare core pipeline operations against DASCore baselines.""" from __future__ import annotations +import dascore as dc import numpy as np import pytest -from dasjax import JaxPatchPipeline, list_operations -from dasjax.operations import get_operation, iter_operations +from dasjax import JaxPatchPipeline, list_patch_operations -def _assert_patch_data_close(left, right) -> None: - """Assert two patches have numerically close data and identical coords.""" +def _assert_patch_close(left, right) -> None: assert np.allclose(left.data, right.data, equal_nan=True, rtol=1e-5, atol=1e-6) assert left.coords == right.coords -def _assert_same_exception(left_exc: Exception, right_exc: Exception) -> None: - """Assert two operations failed in the same way.""" - assert type(left_exc) is type(right_exc) - assert str(left_exc) == str(right_exc) - - -def _iter_operation_cases(): - """Yield every public operation together with its declared test cases.""" - for operation in iter_operations(): - for case in operation.test_cases: - yield operation, case +def _complex_patch(patch): + return patch.update(data=patch.data + 1j * patch.data) + + +def _even_patch(patch): + return patch.select(time=(..., patch.get_coord("time").values[-2])) + + +def _fourier_patch(patch): + return patch.dft("time", real=True) + + +def _fbe_baseline(patch): + out = patch.stft(time=64, samples=True, overlap=32).abs() + ft_dim = next(dim for dim in out.dims if dim.startswith("ft_")) + out = out.select(**{ft_dim: (2.0, 10.0)}) + return out.sum(dim=ft_dim, dim_reduce="squeeze") + + +CASES = ( + ("identity", (), {}, lambda p: p), + ("scale", (2.0,), {}, lambda p: p * 2.0), + ("add", (2.0,), {}, lambda p: p + 2.0), + ("abs", (), {}, lambda p: p.abs(), _complex_patch), + ("clip", (-0.25, 0.25), {}, lambda p: p.update(data=np.clip(p.data, -0.25, 0.25))), + ("real", (), {}, lambda p: p.real(), _complex_patch), + ("imag", (), {}, lambda p: p.imag(), _complex_patch), + ("angle", (), {}, lambda p: p.angle(), _complex_patch), + ("conj", (), {}, lambda p: p.conj(), _complex_patch), + ("flip", ("time",), {}, lambda p: p.flip("time")), + ("roll", (), {"time": 5, "samples": True}, lambda p: p.roll(time=5, samples=True)), + ("standardize", (), {"dim": "time"}, lambda p: p.standardize(dim="time")), + ("detrend", (), {"dim": "time", "type": "constant"}, lambda p: p.detrend(dim="time", type="constant")), + ("normalize", (), {"dim": "time", "norm": "l2"}, lambda p: p.normalize(dim="time", norm="l2")), + ("differentiate", (), {"dim": "time"}, lambda p: p.differentiate(dim="time")), + ("integrate", (), {"dim": "time"}, lambda p: p.integrate(dim="time")), + ("taper", (), {"time": 0.05, "window_type": "hann"}, lambda p: p.taper(time=0.05, window_type="hann")), + ( + "taper_range", + (), + {"time": (10, 20), "samples": True, "window_type": "hann"}, + lambda p: p.taper_range(time=(10, 20), samples=True, window_type="hann"), + ), + ("gaussian_filter", (), {"time": 3, "samples": True}, lambda p: p.gaussian_filter(time=3, samples=True)), + ( + "hampel_filter", + (), + {"time": 3, "samples": True, "threshold": 3.5, "approximate": True}, + lambda p: p.hampel_filter(time=3, samples=True, threshold=3.5, approximate=True), + ), + ( + "pass_filter", + (), + {"time": (1.0, 10.0), "corners": 4, "zerophase": True}, + lambda p: p.pass_filter(time=(1.0, 10.0), corners=4, zerophase=True), + _even_patch, + ), + ("pad", (), {"time": (2, 3), "samples": True}, lambda p: p.pad(time=(2, 3), samples=True)), + ("dft", (), {"dim": "time", "real": True}, lambda p: p.dft(dim="time", real=True)), + ("idft", (), {}, lambda p: p.idft(), _fourier_patch), + ("hilbert", (), {"dim": "time"}, lambda p: p.hilbert(dim="time"), _even_patch), + ("envelope", (), {"dim": "time"}, lambda p: p.envelope(dim="time"), _even_patch), + ("whiten", (), {"time": None}, lambda p: p.whiten(time=None), _even_patch), + ( + "fbe", + (), + {"time": 64, "samples": True, "overlap": 32, "fmin": 2.0, "fmax": 10.0}, + _fbe_baseline, + lambda p: dc.get_example_patch("chirp"), + ), +) -@pytest.mark.parametrize("operation_name", list_operations()) -def test_list_operations_matches_registry(operation_name: str) -> None: - """Expose every registered operation through list_operations.""" - assert get_operation(operation_name).name == operation_name +def test_case_table_covers_registered_operations() -> None: + assert {case[0] for case in CASES} == set(list_patch_operations()) -@pytest.mark.parametrize( - ("operation", "case"), - list(_iter_operation_cases()), - ids=lambda item: getattr(item, "case_id", getattr(item, "name", repr(item))), -) -def test_operation_patch_impl_matches_declared_baseline( - example_patch, - operation, - case, -) -> None: - """Match each eager operation implementation to its declared baseline.""" - patch = case.prepare_patch(example_patch) - args, kwargs = case.resolve_call(patch) - - try: - expected = case.baseline(patch, args, kwargs) - except Exception as expected_exc: - try: - operation.patch_impl(patch, *args, **kwargs) - except Exception as out_exc: - _assert_same_exception(out_exc, expected_exc) - return - raise AssertionError("Expected internal patch operation to fail like DASCore.") - - out = operation.patch_impl(patch, *args, **kwargs) - _assert_patch_data_close(out, expected) - - -@pytest.mark.parametrize( - ("operation", "case"), - list(_iter_operation_cases()), - ids=lambda item: getattr(item, "case_id", getattr(item, "name", repr(item))), -) -def test_compiled_pipeline_matches_declared_baseline( - example_patch, - operation, - case, -) -> None: - """Match each compiled pipeline operation to its declared baseline.""" - patch = case.prepare_patch(example_patch) - args, kwargs = case.resolve_call(patch) - pipeline = getattr(JaxPatchPipeline(), operation.name)(*args, **kwargs) - - if case.compiled_guard is not None: - guarded = case.compiled_guard(patch, args, kwargs) - if guarded is not None: - error_type, error_message = guarded - with pytest.raises(error_type, match=error_message): - pipeline.compile()(patch) - return - - if case.compiled_error is not None: - with pytest.raises( - case.compiled_error, match=case.compiled_error_message or "" - ): - pipeline.compile()(patch) - return - - try: - baseline = case.compiled_baseline or case.baseline - expected = baseline(patch, args, kwargs) - except Exception as expected_exc: - try: - pipeline.compile()(patch) - except Exception as out_exc: - _assert_same_exception(out_exc, expected_exc) - return - raise AssertionError("Expected compiled pipeline to fail like DASCore.") +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_pipeline_matches_dascore(case) -> None: + name, args, kwargs, baseline, *rest = case + example_patch = dc.get_example_patch() + patch = rest[0](example_patch) if rest else example_patch + pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs) out = pipeline.compile()(patch) - _assert_patch_data_close(out, expected) + expected = baseline(patch) + + _assert_patch_close(out, expected) diff --git a/tests/test_patch_ops.py b/tests/test_patch_ops.py deleted file mode 100644 index 45424fe..0000000 --- a/tests/test_patch_ops.py +++ /dev/null @@ -1,239 +0,0 @@ -"""Tests for the unified PatchOp compiled execution path.""" - -from __future__ import annotations - -from dataclasses import dataclass - -import numpy as np -import pytest - -import dascore as dc - -from dasjax import JaxPatchPipeline -from dasjax.pipeline import _build_segments -from dasjax.operations import get_operation -from dasjax.operations.patch_ops import PatchOp, patch_to_state_spec - - -@dataclass(frozen=True) -class _SelectedAxisOp(PatchOp): - dim: str - - def kernel(self, selected_axis): - return {"data": np.asarray([selected_axis])} - - -@dataclass(frozen=True) -class _SelectedCoordOp(PatchOp): - dim: str | None = None - time: object | None = None - distance: object | None = None - - def kernel(self, selected_coord, selected_size, selected_start, selected_stop): - return { - "data": np.asarray( - [ - len(np.asarray(selected_coord)), - selected_size, - selected_start, - selected_stop, - ] - ) - } - - -@dataclass(frozen=True) -class _SelectedStepOp(PatchOp): - dim: str - - def kernel(self, selected_step): - return {"data": np.asarray([selected_step])} - - -def test_scale_patch_op_uses_signature_inference() -> None: - """Infer scale inputs directly from the PatchOp kernel signature.""" - patch = dc.get_example_patch() - op = get_operation("scale").patch_op_cls.prepare(patch, 2.0) - state, _ = patch_to_state_spec(patch) - - out = op.apply(state) - - assert np.allclose(np.asarray(out.data), patch.data * 2.0) - assert out.coords.keys() == state.coords.keys() - - -def test_selected_dim_inference_uses_dim_kwarg() -> None: - """Resolve selected bindings from an explicit dim kwarg.""" - patch = dc.get_example_patch() - op = _SelectedAxisOp.prepare(patch, dim="time") - state, _ = patch_to_state_spec(patch) - - out = op.apply(state) - - assert np.asarray(out.data).item() == patch.get_axis("time") - - -def test_selected_dim_inference_uses_single_dim_kwarg() -> None: - """Resolve selected bindings from a single dim-matching kwarg.""" - patch = dc.get_example_patch() - op = _SelectedCoordOp.prepare(patch, time=(2, 3)) - state, _ = patch_to_state_spec(patch) - - out = op.apply(state) - time_coord = patch.get_coord("time") - - assert np.asarray(out.data)[0] == len(time_coord) - assert np.asarray(out.data)[1] == len(time_coord) - - -def test_selected_dim_inference_rejects_missing_selection() -> None: - """Reject selected bindings when no dimension can be inferred.""" - patch = dc.get_example_patch() - - with pytest.raises(ValueError, match="no selected dim"): - _SelectedAxisOp.prepare(patch, dim=None) - - -def test_selected_dim_inference_rejects_ambiguous_selection() -> None: - """Reject selected bindings when multiple dimensions match the call.""" - patch = dc.get_example_patch() - - with pytest.raises(ValueError, match="multiple dims"): - _SelectedCoordOp.prepare(patch, time=1, distance=1) - - -def test_selected_step_requires_even_sampling() -> None: - """Require evenly sampled coordinates for selected_step bindings.""" - patch = dc.get_example_patch("wacky_dim_coords_patch") - dim = next(dim for dim in patch.dims if patch.get_coord(dim).step is None) - - with pytest.raises(ValueError, match="selected_step"): - _SelectedStepOp.prepare(patch, dim=dim) - - -def test_flip_patch_op_matches_patch_impl() -> None: - """Match the flip PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().flip("time").compile()(patch) - expected = get_operation("flip").patch_impl(patch, "time") - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_pad_patch_op_matches_patch_impl() -> None: - """Match the pad PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().pad(time=(2, 3), samples=True).compile()(patch) - expected = get_operation("pad").patch_impl(patch, time=(2, 3), samples=True) - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_patch_op_segment_chain_matches_eager() -> None: - """Match eager behavior for a mixed compiled PatchOp chain.""" - patch = dc.get_example_patch() - pipeline = JaxPatchPipeline().scale(2.0).pad(time=(2, 3), samples=True).flip("time") - - out = pipeline.compile()(patch) - expected = get_operation("flip").patch_impl( - get_operation("pad").patch_impl( - get_operation("scale").patch_impl(patch, 2.0), - time=(2, 3), - samples=True, - ), - "time", - ) - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_patchop_segment_builder_keeps_pad_with_axis_only_followups() -> None: - """Keep pad in the same PatchOp segment before simple axis-based ops.""" - resolved_steps = tuple( - ( - get_operation(step.name), - step.args, - step.kwargs, - ) - for step in JaxPatchPipeline() - .scale(2.0) - .pad(time=(2, 3), samples=True) - .normalize(dim="time") - .steps - ) - - segments = _build_segments(resolved_steps) - - assert [kind for kind, _ in segments] == ["patchop"] - assert [item[0].name for item in segments[0][1]] == ["scale", "pad", "normalize"] - - -def test_detrend_patch_op_matches_patch_impl() -> None: - """Match the detrend PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().detrend(dim="time", type="constant").compile()(patch) - expected = get_operation("detrend").patch_impl(patch, dim="time", type="constant") - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_standardize_patch_op_matches_patch_impl() -> None: - """Match the standardize PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().standardize(dim="time").compile()(patch) - expected = get_operation("standardize").patch_impl(patch, dim="time") - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_differentiate_patch_op_matches_patch_impl() -> None: - """Match the differentiate PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().differentiate(dim="time", step=2).compile()(patch) - expected = get_operation("differentiate").patch_impl(patch, dim="time", step=2) - - assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6) - assert out.coords == expected.coords - - -def test_integrate_indefinite_patch_op_matches_patch_impl() -> None: - """Match indefinite integrate through the unified PatchOp runtime.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().integrate(dim="time", definite=False).compile()(patch) - expected = get_operation("integrate").patch_impl(patch, dim="time", definite=False) - - assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6) - assert out.coords == expected.coords - - -def test_normalize_patch_op_matches_patch_impl() -> None: - """Match the normalize PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().normalize(dim="time", norm="l2").compile()(patch) - expected = get_operation("normalize").patch_impl(patch, dim="time", norm="l2") - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords - - -def test_roll_patch_op_matches_patch_impl() -> None: - """Match the roll PatchOp path to the eager patch implementation.""" - patch = dc.get_example_patch() - - out = JaxPatchPipeline().roll(time=5, samples=True).compile()(patch) - expected = get_operation("roll").patch_impl(patch, time=5, samples=True) - - assert np.allclose(out.data, expected.data, equal_nan=True) - assert out.coords == expected.coords diff --git a/tests/test_pipeline_cache.py b/tests/test_pipeline_cache.py index f96c95b..2c1cb54 100644 --- a/tests/test_pipeline_cache.py +++ b/tests/test_pipeline_cache.py @@ -8,12 +8,13 @@ import pytest from dasjax import JaxPatchPipeline -from dasjax.operations import get_operation -def _run_operation(patch, name: str, *args, **kwargs): - """Apply one internal operation through DASCore's pipe helper.""" - return patch.pipe(get_operation(name).patch_impl, *args, **kwargs) +def _fbe_baseline(patch): + out = patch.stft(time=64, samples=True, overlap=32).abs() + ft_dim = next(dim for dim in out.dims if dim.startswith("ft_")) + out = out.select(**{ft_dim: (2.0, 10.0)}) + return out.sum(dim=ft_dim, dim_reduce="squeeze") def test_compile_reuses_cached_callable_for_same_pipeline() -> None: @@ -80,13 +81,12 @@ def test_assert_no_fallback_passes_for_native_pipeline() -> None: pipeline.assert_no_fallback(patch) -def test_assert_no_fallback_rejects_host_callback_pipeline() -> None: - """Reject fallback assertions for host-callback-backed pipelines.""" +def test_assert_no_fallback_accepts_core_pipeline() -> None: + """Core pipelines no longer have legacy fallback branches.""" patch = dc.get_example_patch("chirp") pipeline = JaxPatchPipeline().gaussian_filter(**{patch.dims[-1]: 3}, samples=True) - with pytest.raises(AssertionError, match="host fallbacks"): - pipeline.assert_no_fallback(patch) + pipeline.assert_no_fallback(patch) def test_assert_no_fallback_passes_for_fbe_pipeline() -> None: @@ -114,20 +114,7 @@ def test_cached_pipeline_callable_still_matches_expected_output() -> None: compiled = pipeline.compile() out = compiled(patch) - expected = _run_operation( - _run_operation( - _run_operation( - patch, - "scale", - 2.0, - ), - "add", - 1.0, - ), - "detrend", - dim=patch.dims[-1], - type="constant", - ) + expected = ((patch * 2.0) + 1.0).detrend(dim=patch.dims[-1], type="constant") assert out.equals(expected) @@ -141,15 +128,7 @@ def test_compiled_pipeline_with_fbe_matches_eager() -> None: .fbe(time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0) ) out = pipeline.compile()(patch) - expected = _run_operation( - _run_operation(patch, "scale", 2.0), - "fbe", - time=64, - samples=True, - overlap=32, - fmin=2.0, - fmax=10.0, - ) + expected = _fbe_baseline(patch * 2.0) assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6) assert out.coords == expected.coords @@ -164,18 +143,7 @@ def test_compiled_pipeline_with_fbe_in_middle() -> None: .abs() ) out = pipeline.compile()(patch) - expected = _run_operation( - _run_operation( - _run_operation(patch, "scale", 2.0), - "fbe", - time=64, - samples=True, - overlap=32, - fmin=2.0, - fmax=10.0, - ), - "abs", - ) + expected = _fbe_baseline(patch * 2.0).abs() assert np.allclose(out.data, expected.data, equal_nan=True, rtol=1e-5, atol=1e-6) assert out.coords == expected.coords @@ -188,7 +156,7 @@ def test_compile_accepts_explicit_device() -> None: compiled = pipeline.compile(device=jax.devices()[0]) out = compiled(patch) - assert out.equals(_run_operation(patch, "scale", 2.0)) + assert out.equals(patch * 2.0) def test_compile_cache_is_bounded() -> None: diff --git a/tests/test_pytree.py b/tests/test_pytree.py deleted file mode 100644 index e698143..0000000 --- a/tests/test_pytree.py +++ /dev/null @@ -1,121 +0,0 @@ -"""Tests for JAX pytree registration and pipelines.""" - -import dascore as dc -import jax -import numpy as np -import pytest - -from dasjax import JaxPatchPipeline, list_operations -from dasjax.operations import get_operation - - -def _run_operation(patch, name: str, *args, **kwargs): - """Apply one internal operation through DASCore's pipe helper.""" - return patch.pipe(get_operation(name).patch_impl, *args, **kwargs) - - -def test_patch_pytree_roundtrip() -> None: - """Round-trip a patch through the registered pytree hooks.""" - patch = dc.get_example_patch() - - leaves, tree = jax.tree_util.tree_flatten(patch) - out = jax.tree_util.tree_unflatten(tree, leaves) - - assert out.equals(patch) - - -def test_patch_pytree_restores_datetime_coords() -> None: - """Restore datetime coordinates after pytree reconstruction.""" - patch = dc.get_example_patch() - - leaves, tree = jax.tree_util.tree_flatten(patch) - out = jax.tree_util.tree_unflatten(tree, leaves) - - out_time = out.coords.coord_map["time"] - in_time = patch.coords.coord_map["time"] - - assert out_time.dtype == in_time.dtype - assert np.array_equal(out_time.values, in_time.values) - - -def test_patch_tree_map_updates_data_and_coords() -> None: - """Apply tree_map updates to both data and coordinate leaves.""" - patch = dc.get_example_patch() - - out = jax.tree_util.tree_map(lambda x: x + 1, patch) - out_distance = out.coords.coord_map["distance"] - in_distance = patch.coords.coord_map["distance"] - out_time = out.coords.coord_map["time"] - in_time = patch.coords.coord_map["time"] - - assert np.array_equal(out.data, patch.data + 1) - assert np.array_equal(out_distance.values, in_distance.values + 1) - assert np.array_equal( - out_time.values, - in_time.values + np.timedelta64(1, "ns"), - ) - - -def test_pipeline_compile_returns_callable_patch_transform() -> None: - """Compile pipelines into callables that transform patches.""" - patch = dc.get_example_patch() - pipeline = JaxPatchPipeline().identity().scale(2.0).scale(3.0) - - compiled = pipeline.compile() - out = compiled(patch) - - assert callable(compiled) - assert np.allclose(out.data, patch.data * 6.0) - assert out.coords == patch.coords - - -@pytest.mark.parametrize("operation_name", list_operations()) -def test_pipeline_accepts_registered_operations(operation_name: str) -> None: - """Expose every registered operation as a pipeline method.""" - pipeline = getattr(JaxPatchPipeline(), operation_name) - - assert callable(pipeline) - - -def test_pipeline_chains_multiple_operations() -> None: - """Match eager behavior when chaining multiple pipeline operations.""" - patch = dc.get_example_patch() - pipeline = ( - JaxPatchPipeline() - .add(1.5) - .scale(2.0) - .clip(-0.25, 0.25) - .detrend(dim="time", type="constant") - ) - - out = pipeline.compile()(patch) - expected = _run_operation( - _run_operation( - _run_operation( - _run_operation(patch, "add", 1.5), - "scale", - 2.0, - ), - "clip", - -0.25, - 0.25, - ), - "detrend", - dim="time", - type="constant", - ) - - assert np.allclose(out.data, expected.data) - assert out.coords == expected.coords - - -def test_pipeline_rejects_unknown_operations() -> None: - """Reject attempts to call unknown pipeline operations.""" - pipeline = JaxPatchPipeline() - - try: - pipeline.mean() - except AttributeError as exc: - assert "Unknown jax patch operation" in str(exc) - else: - raise AssertionError("Expected an unknown pipeline operation to fail.") diff --git a/tests/test_registry_architecture.py b/tests/test_registry_architecture.py index a23aaf0..31eeb36 100644 --- a/tests/test_registry_architecture.py +++ b/tests/test_registry_architecture.py @@ -1,83 +1,69 @@ -"""Architecture-level checks for the operation registry rewrite.""" +"""Architecture-level checks for the core operation registry.""" from __future__ import annotations -import inspect - import dasjax - -from dasjax.operations.basic import impl as basic_impl -from dasjax.operations.filters import impl as filters_impl -from dasjax.operations import ExecutionPolicy, PatchOp, iter_operations -from dasjax.operations import basic, filters, signal, spectral -from dasjax.operations.signal import impl as signal_impl -from dasjax.operations.registry import OPERATIONS, list_operations -from dasjax.operations.spectral import impl as spectral_impl - - -def test_registry_operation_names_are_unique() -> None: - """Keep registered operation names unique.""" - names = [operation.name for operation in iter_operations()] +from dasjax import PatchOperation, get_patch_operation, iter_patch_operations + + +EXPECTED_OPERATIONS = ( + "identity", + "scale", + "add", + "abs", + "clip", + "real", + "imag", + "angle", + "conj", + "flip", + "roll", + "standardize", + "detrend", + "normalize", + "differentiate", + "integrate", + "taper", + "taper_range", + "gaussian_filter", + "hampel_filter", + "pass_filter", + "pad", + "hilbert", + "envelope", + "dft", + "idft", + "whiten", + "fbe", +) + + +def test_core_operation_names_are_unique() -> None: + names = [operation.operation_name() for operation in iter_patch_operations()] assert len(names) == len(set(names)) -def test_leaf_operations_define_leaf_transform() -> None: - """Require leaf operations to expose only the leaf transform path.""" - for operation in iter_operations(): - if operation.execution_policy is ExecutionPolicy.LEAF: - assert operation.leaf_transform is not None - else: - assert operation.leaf_transform is None - - -def test_all_operations_define_patch_op_class() -> None: - """Ensure every registered operation exposes a PatchOp class.""" - for operation in iter_operations(): - assert operation.patch_op_cls is not None +def test_all_operations_are_patch_operation_subclasses() -> None: + for operation in iter_patch_operations(): + assert issubclass(operation, PatchOperation) -def test_patch_op_subclass_registry_is_populated() -> None: - """Register concrete PatchOp subclasses for runtime introspection.""" - subclass_names = {cls.__name__ for cls in PatchOp.iter_subclasses()} - assert "ScaleOp" in subclass_names - assert "PadOp" in subclass_names +def test_list_patch_operations_preserves_registry_order() -> None: + assert dasjax.list_patch_operations() == EXPECTED_OPERATIONS -def test_patch_op_compile_category_table_contains_expected_groups() -> None: - """Expose the expected compile categories through the PatchOp table.""" - table = PatchOp.compile_category_table() - assert "kernel_fusible" in table - assert "compiled_boundary" in table - assert "eager_boundary" in table +def test_get_patch_operation_resolves_all_registered_names() -> None: + for name in EXPECTED_OPERATIONS: + assert get_patch_operation(name).operation_name() == name def test_package_root_exports_only_runtime_surface() -> None: - """Keep the root package export surface intentionally small.""" - assert sorted(dasjax.__all__) == ["JaxPatchPipeline", "list_operations"] - - -def test_list_operations_preserves_registry_order() -> None: - """Preserve registry order when listing operation names.""" - assert list_operations() == tuple(operation.name for operation in OPERATIONS) - - -def test_operation_families_export_specs_from_packages() -> None: - """Expose operation spec collections from each family package.""" - for module in (basic, signal, filters, spectral): - assert hasattr(module, "OPERATIONS") - assert module.OPERATIONS - assert module.__file__ is not None - assert module.__file__.endswith("__init__.py") - - -def test_operation_impl_modules_avoid_private_dascore_imports() -> None: - """Avoid private DASCore imports inside operation implementations.""" - for module in ( - basic_impl, - signal_impl, - filters_impl, - spectral_impl, - ): - source = inspect.getsource(module) - assert "from dascore" in source - assert " import _" not in source + assert sorted(dasjax.__all__) == [ + "JaxPatchPipeline", + "PatchBoundary", + "PatchOperation", + "PatchPyTree", + "get_patch_operation", + "iter_patch_operations", + "list_patch_operations", + ] From ac033b0c29cc14db78ccac9725f74c304ce0d18f Mon Sep 17 00:00:00 2001 From: Derrick Chambers Date: Fri, 24 Apr 2026 23:16:45 +0200 Subject: [PATCH 3/7] refactor, add more functions --- .agents/GUIDELINES.md | 2 + .github/workflows/docs.yml | 67 ++ .gitignore | 3 + README.md | 73 +-- agents.md | 2 +- benchmarks/readme.md | 6 +- benchmarks/results/current.json | 241 +++++++ benchmarks/test_pipeline_benchmarks.py | 117 ++++ docs/development/architecture.md | 17 + docs/development/documentation.md | 36 ++ docs/development/index.md | 9 + docs/development/operation-coverage.md | 7 + docs/index.md | 1 + docs/static/dasjax_logo.png | Bin 0 -> 2536421 bytes docs/static/favicon.ico | Bin 0 -> 4151 bytes docs/tutorial/compiled-pipelines.md | 34 + docs/tutorial/index.md | 10 + docs/tutorial/performance.md | 15 + pyproject.toml | 7 + scripts/build_api_docs.py | 484 ++++++++++++++ scripts/build_benchmark_docs.py | 29 + src/dasjax/__init__.py | 1 + src/dasjax/benchmark_cli.py | 519 +++++++++++++++ src/dasjax/core.py | 125 +--- src/dasjax/core_ops.py | 855 +------------------------ src/dasjax/kernels/__init__.py | 36 +- src/dasjax/kernels/domain.py | 150 +++++ src/dasjax/kernels/filters.py | 534 +++++++++++---- src/dasjax/kernels/spectral.py | 46 +- src/dasjax/operations/__init__.py | 160 +++++ src/dasjax/operations/basic.py | 501 +++++++++++++++ src/dasjax/operations/common.py | 54 ++ src/dasjax/operations/correlate.py | 64 ++ src/dasjax/operations/detrend.py | 30 + src/dasjax/operations/differentiate.py | 57 ++ src/dasjax/operations/dispersion.py | 111 ++++ src/dasjax/operations/filter.py | 495 ++++++++++++++ src/dasjax/operations/fourier.py | 151 +++++ src/dasjax/operations/hilbert.py | 130 ++++ src/dasjax/operations/integrate.py | 85 +++ src/dasjax/operations/mute.py | 102 +++ src/dasjax/operations/normalize.py | 31 + src/dasjax/operations/numeric.py | 205 ++++++ src/dasjax/operations/pad.py | 104 +++ src/dasjax/operations/spectro.py | 142 ++++ src/dasjax/operations/strain.py | 167 +++++ src/dasjax/operations/taper.py | 163 +++++ src/dasjax/operations/taup.py | 80 +++ src/dasjax/operations/whiten.py | 100 +++ src/dasjax/pipeline.py | 148 +++-- tests/operations/__init__.py | 1 + tests/operations/helpers.py | 50 ++ tests/operations/test_basic.py | 104 +++ tests/operations/test_detrend.py | 48 ++ tests/operations/test_differentiate.py | 45 ++ tests/operations/test_domain.py | 195 ++++++ tests/operations/test_filter.py | 246 +++++++ tests/operations/test_fourier.py | 57 ++ tests/operations/test_hilbert.py | 72 +++ tests/operations/test_integrate.py | 42 ++ tests/operations/test_numeric.py | 142 ++++ tests/operations/test_spectro.py | 89 +++ tests/operations/test_taper.py | 65 ++ tests/operations/test_whiten.py | 43 ++ tests/test_benchmark_cli.py | 114 ++++ tests/test_core_api.py | 86 ++- tests/test_method_equivalence.py | 104 --- tests/test_package.py | 20 + tests/test_pipeline_cache.py | 182 +++++- tests/test_registry_architecture.py | 136 ++++ zensical.toml | 85 +++ 71 files changed, 7148 insertions(+), 1284 deletions(-) create mode 100644 .github/workflows/docs.yml create mode 100644 benchmarks/results/current.json create mode 100644 docs/development/architecture.md create mode 100644 docs/development/documentation.md create mode 100644 docs/development/index.md create mode 100644 docs/development/operation-coverage.md create mode 100644 docs/index.md create mode 100644 docs/static/dasjax_logo.png create mode 100644 docs/static/favicon.ico create mode 100644 docs/tutorial/compiled-pipelines.md create mode 100644 docs/tutorial/index.md create mode 100644 docs/tutorial/performance.md create mode 100644 scripts/build_api_docs.py create mode 100644 scripts/build_benchmark_docs.py create mode 100644 src/dasjax/benchmark_cli.py create mode 100644 src/dasjax/kernels/domain.py create mode 100644 src/dasjax/operations/__init__.py create mode 100644 src/dasjax/operations/basic.py create mode 100644 src/dasjax/operations/common.py create mode 100644 src/dasjax/operations/correlate.py create mode 100644 src/dasjax/operations/detrend.py create mode 100644 src/dasjax/operations/differentiate.py create mode 100644 src/dasjax/operations/dispersion.py create mode 100644 src/dasjax/operations/filter.py create mode 100644 src/dasjax/operations/fourier.py create mode 100644 src/dasjax/operations/hilbert.py create mode 100644 src/dasjax/operations/integrate.py create mode 100644 src/dasjax/operations/mute.py create mode 100644 src/dasjax/operations/normalize.py create mode 100644 src/dasjax/operations/numeric.py create mode 100644 src/dasjax/operations/pad.py create mode 100644 src/dasjax/operations/spectro.py create mode 100644 src/dasjax/operations/strain.py create mode 100644 src/dasjax/operations/taper.py create mode 100644 src/dasjax/operations/taup.py create mode 100644 src/dasjax/operations/whiten.py create mode 100644 tests/operations/__init__.py create mode 100644 tests/operations/helpers.py create mode 100644 tests/operations/test_basic.py create mode 100644 tests/operations/test_detrend.py create mode 100644 tests/operations/test_differentiate.py create mode 100644 tests/operations/test_domain.py create mode 100644 tests/operations/test_filter.py create mode 100644 tests/operations/test_fourier.py create mode 100644 tests/operations/test_hilbert.py create mode 100644 tests/operations/test_integrate.py create mode 100644 tests/operations/test_numeric.py create mode 100644 tests/operations/test_spectro.py create mode 100644 tests/operations/test_taper.py create mode 100644 tests/operations/test_whiten.py create mode 100644 tests/test_benchmark_cli.py delete mode 100644 tests/test_method_equivalence.py create mode 100644 tests/test_package.py create mode 100644 zensical.toml diff --git a/.agents/GUIDELINES.md b/.agents/GUIDELINES.md index 1943cf7..efd3b51 100644 --- a/.agents/GUIDELINES.md +++ b/.agents/GUIDELINES.md @@ -6,3 +6,5 @@ - Do not add filler comments that simply restate the next line. - Write tests, follow red green TDD. - Ensure all methods, functions, modules, and classes have a docstring. Private objects can have a single line, public objects should have a full numpy docstring with examples (following doctest). +- All lines must be covered by tests; delete unreachable edge case code or test it using public API and minimal monkey patching. +- Keep Markdown prose unwrapped. Do not hard-wrap paragraphs or list items in `.md` files; let editors soft-wrap them. Code blocks and formats that require line breaks are exceptions. diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..4d10d65 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,67 @@ +name: Documentation + +on: + push: + branches: + - main + pull_request: + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: pages-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + pages: write + steps: + - uses: actions/checkout@v4 + with: + fetch-tags: "true" + fetch-depth: "0" + + - if: github.event_name != 'pull_request' + uses: actions/configure-pages@v5 + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install documentation dependencies + run: python -m pip install -e ".[docs]" + + - name: Generate API reference + run: python scripts/build_api_docs.py + + - name: Generate benchmark reference + run: python scripts/build_benchmark_docs.py + + - name: Build documentation + run: zensical build --clean + + - name: Upload Pages artifact + if: github.event_name != 'pull_request' + uses: actions/upload-pages-artifact@v4 + with: + path: site + + deploy: + if: github.event_name != 'pull_request' + needs: build + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore index 697dbf2..9428243 100644 --- a/.gitignore +++ b/.gitignore @@ -74,6 +74,9 @@ target/ # docs docs/api/* +docs/benchmarks/* +site/ +.benchmarks/ _autosummary .quarto/ docs/site_libs diff --git a/README.md b/README.md index 37dbd67..f83b164 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,8 @@ # dasjax -An experimental package for accelerating [DASCore](dascore.org) with [JAX](https://github.com/jax-ml/jax). +![dasjax logo](https://raw.githubusercontent.com/dasdae/dasjax/main/docs/static/dasjax_logo.png) + +An experimental package for accelerating [DASCore](https://dascore.org) with [JAX](https://github.com/jax-ml/jax). ## Installation @@ -10,11 +12,11 @@ python -m pip install -e ".[dev]" ## Usage -`dasjax`'s main feature is the ability to create compiled DAS pipelines that can run on CPU, GPU, or TPU. These also perform kernel fusions for increased efficiency. +`dasjax`'s main feature is the ability to create compiled DAS pipelines that can run on CPU, GPU, or TPU. These pipelines fuse adjacent JAX-backed operations where possible and cache metadata planning for repeated calls with the same static patch boundary. ### Compiled pipeline -Use `JaxPatchPipeline` when you want to compile a reusable sequence once and run it across many compatible patches. +Use `JaxPatchPipeline` when you want to build a reusable callable once and run it across many compatible patches. ```python import dascore as dc @@ -42,55 +44,54 @@ print(out.shape) `dasjax` is organized around one core operation model: -1. Pipeline layer: - `src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API. -2. Operation layer: - `src/dasjax/core.py` and `src/dasjax/core_ops.py` define `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and the registered operation classes. -3. Kernel layer: - `src/dasjax/kernels/` contains the array-level JAX and callback-backed kernels that actually do the numerical work, grouped by domain (`basic`, `signal`, `filters`, `spectral`). +1. Pipeline layer: `src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API. +2. Operation layer: `src/dasjax/core.py` defines `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and registry helpers. Registered operation classes live under `src/dasjax/operations/`, grouped by DASCore-style domains. +3. Kernel layer: `src/dasjax/kernels/` contains the array-level JAX kernels that actually do the numerical work, grouped by domain (`basic`, `signal`, `filters`, `spectral`). Operation authors use `bind(boundary)` for Python-side metadata planning, `kernel(patch_tree)` for JAX-side data transforms, and `update_boundary(boundary)` for static metadata changes. -### Roadmap +### Operation Coverage -The table below tracks what is missing and roughly how much effort each addition requires. +`dasjax` currently registers 75 pipeline operations. Most operations use native JAX kernels; a smaller set of DASCore-compatible numeric transforms still use host callbacks where a fully static JAX kernel is not practical yet. The current operation set includes: -#### Near-term — straightforward pure-JAX array ops +- Elementwise math and masks: `abs`, `clip`, `real`, `imag`, `angle`, `conj`, `exp`, `log`, `log10`, `log2`, `is_finite`, `isinf`, `isnan`, `fillna`, `where`, and scalar arithmetic operations. +- Reductions and aggregation: `aggregate`, `all`, `any`, `max`, `mean`, `median`, `min`, `std`, and `sum`. +- Coordinate-aware array transforms: `flip`, `roll`, `pad`, `taper`, `taper_range`, `detrend`, `standardize`, `differentiate`, and `integrate`. +- Spectral and signal operations: `dft`, `idft`, `rfft`, `stft`, `istft`, `spectrogram`, `hilbert`, `envelope`, `phase_weighted_stack`, `whiten`, `fbe`, and `correlate_shift`. +- Filters, mutes, and DAS-domain operations: `pass_filter`, `gaussian_filter`, `hampel_filter`, `median_filter`, `notch_filter`, `savgol_filter`, `sobel_filter`, `slope_filter`, `wiener_filter`, `line_mute`, `slope_mute`, `correlate`, `decimate`, `interpolate`, `iresample`, `resample`, `dispersion_phase_shift`, `tau_p`, `velocity_to_strain_rate`, `velocity_to_strain_rate_edgeless`, and `radians_to_strain`. -Implemented in the current package: +Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. `rolling` returns a roller object rather than a patch, and `dropna` has data-dependent output shape, so neither fits the current static compiled-pipeline model directly. -- `real`, `imag`, `angle`, `conj` -- `flip`, `roll`, `pad` -- `standardize`, `differentiate`, `integrate` -- `dft`, `idft` -- `hilbert`, `envelope` -- `taper`, `taper_range` -- `whiten` +## Performance Notes -#### Medium-term — moderate effort or shape-changing +- The intended fast path is to build a `JaxPatchPipeline`, call `.compile()` once, and reuse the returned callable. Patch-specific metadata binding and JIT segment creation happen lazily on the first call for a static boundary, then cached plans and segment runners are reused for subsequent calls with matching dims, dynamic coordinate values, coordinate units, and attrs. +- Equivalent pipeline definitions reuse cached compiled callables automatically. +- Callback-backed operations preserve DASCore compatibility but execute their operation body on the host, so they generally do not benefit as much from JAX fusion as native kernels. +- Benchmarks live under `benchmarks/` and compare compiled `dasjax` pipelines against equivalent DASCore operation chains. -These need either more work in the kernel layer or are shape-changing (segmented pipeline execution, same mechanism as `fbe`). +## Documentation -| Method | Implementation notes | -|---|---| -| `notch_filter` | SOS filter; same pattern as `pass_filter` | -| `savgol_filter` | polynomial fitting per frame; JAX-doable | -| `rolling` | rolling-window reductions (mean, std, …); needs strided views | -| `correlate` | cross-correlation via `jnp.fft` | -| `stft` / `istft` | expose the STFT kernel already used by `fbe` | -| `decimate` | anti-aliased downsampling; shape-changing | -| `aggregate` / `mean` / `std` / `sum` | axis reductions; shape-changing | +Documentation is built with Zensical. The public API reference is generated at build time from the installed `dasjax` package, so run the API generation script before building or serving the site. -## Performance Notes +```bash +python -m pip install -e ".[docs]" +python scripts/build_api_docs.py +zensical build --clean +``` -- The intended fast path is to build a `JaxPatchPipeline`, call `.compile()` once, and reuse the returned callable across many patches of compatible shape and dtype. -- Equivalent pipeline definitions reuse cached compiled callables automatically. -- Benchmarks live under `benchmarks/` and compare compiled `dasjax` pipelines against equivalent DASCore operation chains. +For local preview, run: + +```bash +python scripts/build_api_docs.py +zensical serve +``` + +Generated files under `docs/api/` and `site/` are ignored by version control. GitHub Pages builds the same generated API docs and static site on pushes to `main`, then deploys the `site/` artifact through the `github-pages` environment. ## Development Guidelines -- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one `PatchOperation` subclass in `src/dasjax/core_ops.py`. +- Add new JAX patch methods by defining an array kernel in `src/dasjax/kernels/` and one `PatchOperation` subclass in the appropriate `src/dasjax/operations/` module. - The `PatchOperation` subclass is the single source of truth for pipeline support, metadata binding, and boundary updates. - Every new patch method must be tested against a DASCore baseline across the shared mixed-patch fixture in `tests/conftest.py`. - Prefer comparing internal operation behavior and compiled pipeline outputs against the closest native DASCore method or operator. If DASCore has no direct method, compare against an equivalent `Patch.update(...)` baseline. diff --git a/agents.md b/agents.md index ba777d7..ea04ae3 100644 --- a/agents.md +++ b/agents.md @@ -2,7 +2,7 @@ This file gives AI/code agents a practical checklist for contributing safely to dasjax. -Keep Markdown prose unwrapped. Do not hard-wrap paragraphs in `.md` files unless a specific format requires it. +Keep Markdown prose unwrapped. Do not hard-wrap paragraphs or list items in `.md` files; let editors soft-wrap them. Code blocks and formats that require line breaks are exceptions. ## Scope and priorities diff --git a/benchmarks/readme.md b/benchmarks/readme.md index 85efcd4..d131ac6 100644 --- a/benchmarks/readme.md +++ b/benchmarks/readme.md @@ -17,12 +17,14 @@ pytest benchmarks/test_pipeline_benchmarks.py ## Benchmark Structure -The first benchmark suite focuses on side-by-side comparisons between: +The benchmark suite focuses on side-by-side comparisons between: - compiled `dasjax` pipelines - equivalent DASCore-native operation chains +- individual compiled `dasjax` operations +- equivalent individual DASCore operations -Each comparison is exposed as a separate benchmark test per engine so CodSpeed output is easy to read. +Each comparison is exposed as a separate benchmark test per engine so CodSpeed output is easy to read. Pipeline benchmark groups use names like `scale_fbe`; individual operation benchmark groups use names like `operation_fbe`. To export benchmark results for ratio comparisons, use: diff --git a/benchmarks/results/current.json b/benchmarks/results/current.json new file mode 100644 index 0000000..1daf2a0 --- /dev/null +++ b/benchmarks/results/current.json @@ -0,0 +1,241 @@ +{ + "command": "/home/derrick/Gits/dasjax/.venv/bin/python3 -m pytest benchmarks/test_pipeline_benchmarks.py --benchmark-json=.benchmarks/current.json --benchmark-min-rounds=3", + "environment": { + "dascore": "0.1.15", + "dasjax": "0.0.2.post5+git.b91ea38d.dirty", + "jax": "0.9.2", + "machine": "x86_64", + "platform": "Linux-6.8.0-110-generic-x86_64-with-glibc2.39", + "processor": "x86_64", + "python": "3.14.0" + }, + "generated_at": "2026-04-24T21:02:20+00:00", + "rows": [ + { + "case": "large-f32", + "dascore_mean_s": 0.01680247585863981, + "dasjax_mean_s": 0.027737313893080033, + "group": "operation_detrend", + "speedup": 0.6057715582485342 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.02056590126647077, + "dasjax_mean_s": 0.039724797681794204, + "group": "operation_detrend", + "speedup": 0.5177094023538874 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.00280651622404241, + "dasjax_mean_s": 0.00464291289685484, + "group": "operation_detrend", + "speedup": 0.6044731586378832 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.006594007113993652, + "dasjax_mean_s": 0.005276114980069589, + "group": "operation_detrend", + "speedup": 1.2497845742373646 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.2184312981997209, + "dasjax_mean_s": 0.07017438086671367, + "group": "operation_fbe", + "speedup": 3.1126929158748164 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.22405660559925308, + "dasjax_mean_s": 0.12280043924988604, + "group": "operation_fbe", + "speedup": 1.8245586658148782 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.060894481812397316, + "dasjax_mean_s": 0.016618491196748467, + "group": "operation_fbe", + "speedup": 3.6642605571985847 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.06038897700011603, + "dasjax_mean_s": 0.02635550172517469, + "group": "operation_fbe", + "speedup": 2.291323368829388 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.02410416859510449, + "dasjax_mean_s": 0.029323925272613204, + "group": "operation_normalize", + "speedup": 0.821996658735737 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.0442047530001067, + "dasjax_mean_s": 0.04763245468166133, + "group": "operation_normalize", + "speedup": 0.928038525319286 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.005262831870463686, + "dasjax_mean_s": 0.0038589278446091823, + "group": "operation_normalize", + "speedup": 1.36380675731362 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.007819257648463918, + "dasjax_mean_s": 0.006448505770629922, + "group": "operation_normalize", + "speedup": 1.212568915434202 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.14351405271424614, + "dasjax_mean_s": 0.23610140819982917, + "group": "operation_pass_filter", + "speedup": 0.607849202630677 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.1569610861667267, + "dasjax_mean_s": 0.3055325966664289, + "group": "operation_pass_filter", + "speedup": 0.5137294281503193 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.04044847061532682, + "dasjax_mean_s": 0.0535740397895815, + "group": "operation_pass_filter", + "speedup": 0.7550013173207222 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.04170220657137439, + "dasjax_mean_s": 0.07101005280043561, + "group": "operation_pass_filter", + "speedup": 0.5872718710486379 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.08525154969258718, + "dasjax_mean_s": 0.04037866288265778, + "group": "scale_add_detrend_normalize", + "speedup": 2.1113019502486257 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.09698225289994297, + "dasjax_mean_s": 0.06014784300008186, + "group": "scale_add_detrend_normalize", + "speedup": 1.612397852734486 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.011251645377685943, + "dasjax_mean_s": 0.0058049622475484265, + "group": "scale_add_detrend_normalize", + "speedup": 1.938280543071194 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.02263596206534124, + "dasjax_mean_s": 0.010735889017007016, + "group": "scale_add_detrend_normalize", + "speedup": 2.1084385307525992 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.2694122765991779, + "dasjax_mean_s": 0.08099217654555767, + "group": "scale_fbe", + "speedup": 3.3263987719558927 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.2593546889997924, + "dasjax_mean_s": 0.12906283150005038, + "group": "scale_fbe", + "speedup": 2.0095226951509364 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.06117705750011737, + "dasjax_mean_s": 0.016964814050000616, + "group": "scale_fbe", + "speedup": 3.606114238553363 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.07161363979964032, + "dasjax_mean_s": 0.026488216809411824, + "group": "scale_fbe", + "speedup": 2.703603655727949 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.2429028071997891, + "dasjax_mean_s": 0.09134150290010438, + "group": "scale_fbe_normalize", + "speedup": 2.6592819199114746 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.24544560220019776, + "dasjax_mean_s": 0.13214524928558344, + "group": "scale_fbe_normalize", + "speedup": 1.8573925549889214 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.06755474915399436, + "dasjax_mean_s": 0.01810524253948917, + "group": "scale_fbe_normalize", + "speedup": 3.731225859396876 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.07054645092817477, + "dasjax_mean_s": 0.028195836228561737, + "group": "scale_fbe_normalize", + "speedup": 2.5020166224654417 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.19576208779981244, + "dasjax_mean_s": 0.29107356519998573, + "group": "scale_pass_filter_abs", + "speedup": 0.6725519291499785 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.1968337761663861, + "dasjax_mean_s": 0.303922596749544, + "group": "scale_pass_filter_abs", + "speedup": 0.6476444274678019 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.04842030686383871, + "dasjax_mean_s": 0.055725851882444284, + "group": "scale_pass_filter_abs", + "speedup": 0.8689020486574726 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.05123172271426787, + "dasjax_mean_s": 0.07264519385755973, + "group": "scale_pass_filter_abs", + "speedup": 0.7052321013103953 + } + ], + "schema_version": 1, + "source": "local" +} diff --git a/benchmarks/test_pipeline_benchmarks.py b/benchmarks/test_pipeline_benchmarks.py index c8af98c..c736bf9 100644 --- a/benchmarks/test_pipeline_benchmarks.py +++ b/benchmarks/test_pipeline_benchmarks.py @@ -81,6 +81,73 @@ def dascore_scale_add_detrend_normalize(example_patch) -> Callable[[], object]: ) +@pytest.fixture(scope="module") +def dasjax_detrend(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax detrend operation.""" + compiled = JaxPatchPipeline().detrend(dim="time", type="constant").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_detrend(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore detrend operation.""" + return lambda: example_patch.detrend(dim="time", type="constant") + + +@pytest.fixture(scope="module") +def dasjax_normalize(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax normalize operation.""" + compiled = JaxPatchPipeline().normalize(dim="time").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_normalize(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore normalize operation.""" + return lambda: example_patch.normalize(dim="time") + + +@pytest.fixture(scope="module") +def dasjax_pass_filter(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax pass_filter operation.""" + compiled = JaxPatchPipeline().pass_filter(time=(2.0, 10.0)).compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_pass_filter(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore pass_filter operation.""" + return lambda: example_patch.pass_filter(time=(2.0, 10.0)) + + +@pytest.fixture(scope="module") +def dasjax_fbe(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax fbe operation.""" + compiled = ( + JaxPatchPipeline() + .fbe(time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0) + .compile() + ) + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_fbe(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore fbe baseline operation.""" + return lambda: _run_dascore_fbe( + example_patch, + time=64, + overlap=32, + samples=True, + fmin=2.0, + fmax=10.0, + ) + + @pytest.fixture(scope="module") def dasjax_scale_pass_filter_abs(example_patch) -> Callable[[], object]: """Return a warmed compiled dasjax filtering pipeline.""" @@ -203,3 +270,53 @@ def test_dascore_scale_fbe_normalize( ) -> None: """Benchmark DASCore fbe+normalize chain execution.""" benchmark(dascore_scale_fbe_normalize) + + +class TestIndividualOperationBenchmarks: + """Benchmarks for individual dasjax operations and DASCore baselines.""" + + @pytest.mark.benchmark(group="operation_detrend") + def test_dasjax_compiled_operation_detrend(self, benchmark, dasjax_detrend) -> None: + """Benchmark warmed compiled dasjax detrend execution.""" + benchmark(dasjax_detrend) + + @pytest.mark.benchmark(group="operation_detrend") + def test_dascore_operation_detrend(self, benchmark, dascore_detrend) -> None: + """Benchmark DASCore detrend execution.""" + benchmark(dascore_detrend) + + @pytest.mark.benchmark(group="operation_normalize") + def test_dasjax_compiled_operation_normalize( + self, benchmark, dasjax_normalize + ) -> None: + """Benchmark warmed compiled dasjax normalize execution.""" + benchmark(dasjax_normalize) + + @pytest.mark.benchmark(group="operation_normalize") + def test_dascore_operation_normalize(self, benchmark, dascore_normalize) -> None: + """Benchmark DASCore normalize execution.""" + benchmark(dascore_normalize) + + @pytest.mark.benchmark(group="operation_pass_filter") + def test_dasjax_compiled_operation_pass_filter( + self, benchmark, dasjax_pass_filter + ) -> None: + """Benchmark warmed compiled dasjax pass_filter execution.""" + benchmark(dasjax_pass_filter) + + @pytest.mark.benchmark(group="operation_pass_filter") + def test_dascore_operation_pass_filter( + self, benchmark, dascore_pass_filter + ) -> None: + """Benchmark DASCore pass_filter execution.""" + benchmark(dascore_pass_filter) + + @pytest.mark.benchmark(group="operation_fbe") + def test_dasjax_compiled_operation_fbe(self, benchmark, dasjax_fbe) -> None: + """Benchmark warmed compiled dasjax fbe execution.""" + benchmark(dasjax_fbe) + + @pytest.mark.benchmark(group="operation_fbe") + def test_dascore_operation_fbe(self, benchmark, dascore_fbe) -> None: + """Benchmark DASCore fbe-equivalent execution.""" + benchmark(dascore_fbe) diff --git a/docs/development/architecture.md b/docs/development/architecture.md new file mode 100644 index 0000000..7e3bca7 --- /dev/null +++ b/docs/development/architecture.md @@ -0,0 +1,17 @@ +# Architecture + +`dasjax` is organized around one core operation model. + +## Pipeline Layer + +`src/dasjax/pipeline.py` records operation chains, plans metadata boundaries, and compiles reusable patch transforms. This is the main user-facing API. Compiled callables cache both JIT segment runners and bound metadata plans for repeated calls with the same static boundary. + +## Operation Layer + +`src/dasjax/core.py` defines `PatchOperation`, `PatchBoundary`, `PatchPyTree`, and registry helpers. Registered operation classes live under `src/dasjax/operations/`, grouped by DASCore-style domains. + +Operation authors use `bind(boundary)` for Python-side metadata planning, `kernel(patch_tree)` for JAX-side data transforms, and `update_boundary(boundary)` for static metadata changes. + +## Kernel Layer + +`src/dasjax/kernels/` contains the array-level JAX kernels that do the numerical work, grouped by domain. diff --git a/docs/development/documentation.md b/docs/development/documentation.md new file mode 100644 index 0000000..56bcae1 --- /dev/null +++ b/docs/development/documentation.md @@ -0,0 +1,36 @@ +# Documentation + +Documentation is built with Zensical. The API reference page is generated from the public `dasjax` package API immediately before the site build. Benchmark documentation is generated from the checked-in benchmark snapshot. + +```bash +python -m pip install -e ".[docs]" +python scripts/build_api_docs.py +python scripts/build_benchmark_docs.py +zensical build --clean +``` + +Preview the site locally with: + +```bash +python scripts/build_api_docs.py +python scripts/build_benchmark_docs.py +zensical serve +``` + +Generated API reference pages are written under `docs/api/`, generated benchmark docs are written under `docs/benchmarks/`, and the static site is written to `site/`. These outputs are ignored by version control. + +Refresh the benchmark snapshot before building benchmark docs with: + +```bash +dasjax-benchmark refresh +``` + +## Local Checks + +```bash +python -m pip install -e ".[test,docs]" +python scripts/build_api_docs.py +python scripts/build_benchmark_docs.py +zensical build --clean +python -m pytest +``` diff --git a/docs/development/index.md b/docs/development/index.md new file mode 100644 index 0000000..22f679e --- /dev/null +++ b/docs/development/index.md @@ -0,0 +1,9 @@ +# Development + +Use this section when you are changing `dasjax` internals or extending the operation surface. + +## Pages + +- [Architecture](architecture.md) explains the pipeline, operation, and kernel layers. +- [Operation Coverage](operation-coverage.md) summarizes the registered operation surface. +- [Documentation](documentation.md) describes local docs builds and checks. diff --git a/docs/development/operation-coverage.md b/docs/development/operation-coverage.md new file mode 100644 index 0000000..cc298b8 --- /dev/null +++ b/docs/development/operation-coverage.md @@ -0,0 +1,7 @@ +# Operation Coverage + +The package currently registers 75 pipeline operations. Most are implemented as JAX-backed kernels with static metadata planning; heavier DASCore-compatible numeric transforms can use host callbacks when a full static JAX kernel is not yet practical. Callback-backed operations are compatibility paths and generally offer less fusion benefit than native kernels. + +Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. In particular, `rolling` returns a roller object and `dropna` has data-dependent output shape, so they do not map directly to the current compiled `Patch -> Patch` pipeline model. + +The generated [API Reference](../api/index.md) lists the current operation registry. diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..612c7a5 --- /dev/null +++ b/docs/index.md @@ -0,0 +1 @@ +--8<-- "README.md" diff --git a/docs/static/dasjax_logo.png b/docs/static/dasjax_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..23d140ced8d8c3cda942360337620c0d18d1770a GIT binary patch literal 2536421 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

gZV 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

XsN1*Iocce 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

;`1>;ptpz)ruP7^zKcmk#4&kua# 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⪑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

MkK)R;TM*U!K3 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%0DBD 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�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

xn@? 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%0DS1L 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�ZTM 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

Q~{mSIJUmEtFu znqk-WomMnclbfQ=nAC_=)yNE13T>=!a47{=6yxy-MT6#Igeq0&NC#GB6u&oIUQrv$ zxIt+ej8n2Q*rZ1vJ!ltSc%hzi#u@U!p@aG_AN(i#$)9-x?c2N0?z{Is4A$1snd*_5 zk87%Ks;Is^jMq?L1#D(T3)o=PjNNIRa%S^XE6W%RhO~3nPUMkN9;}s(;b7*@d+zzm z%PxK5FXxR7YUdkLadwx3k%dG^B#ks{#Uh&tBn@(pRr^J$SJ$1Rr6_VPj~NxMB#ryM z&c4x*JL6`^*@)N}EJmeh%eh0~Lfk-`W6KNNNr{Ry*6DO{T6dc*ZmiSBxWT9t`{L&^gn*de*3MzLx1ehyr|6MK9yW+8XFDlbzu$+Nqkd8e70WnrP`m$NLU$2D5}<}I$HM<_xsaSr9@0bO>R`c!Xm~gp;K2_-`G?E z(YTCBL_D#f7ITOJHXJuxv_T3RKy3;DweeUXtTZ>b-2k9i(VWM~jW7N4XbdF-QPR4u zcsv?fztQ8RI;*TohUgnW=FB`&y&GYJtIh)pIEzxB!$?t%Q=sR8hj`i`Bd@KmPj8MlpEox( z{rOVH6<}juz`8VFO+ebV2`vB-Y{_8sxf6?p(u!a~Qq$tNgi zC`Cf8?@xv}j2ibz zNQkCzlK*2yp-yP+RJ_mKdc&PSNiFGwT`Ax`+dNr{v|h^wh6qjA8RLQ5Uw57annYZ4*6STzdFYW7!`Gw3K05mY7g0P|S9v;O) zt)Rift8AXs3lAl=sOM&N!3KGqbOJ`t$h7=e~g6|CfJS_C4!aa%yD-ODhX@+OFO7 zz3+X?bkN{uf9j3+tv`G_%}mW;b8Q7T-gpx|<*DCK7he1XRTLynOavxZIyFVL7UfYIgQY^MYow~us^8)1aSzRKRB}+V6cwCcx1b_&)dR@zJ30SUzT3oE$3Z$0p9)Y_t7&izfun$J%;T& zw>f%dMkx_2JN;}j%$O%zZEkGR(IZE3`e}QumKvoDJV=PlZut6j_J*H*9adIWXy3lQ zdhfj}ys*5a{caD_(|w$K-uZURE#I)GJmsl${S7yuXl53|M?UdUddqM8E|`;9GTyO$ zyWRSo@7VKS@I2bRa}VA8&71M;=RU_i`RUKo&TaF}U^wo-^(}At%)fr*!~Z4cF%~uk z5GE9+@Z1l!dC=^A(UyEE$i;~|mK_k!PAVcUflDel5wv)nBov=z0}lmx0BB1<1{k>n zMo5S{#h{WsBaU>dj>Je$tx-UUiV-$5#+WPxiDFS_F&`m(*^OYxK06TuR-9!{QFjbZ zjH4jG!55jqR6v*`qf8PBbdr(5T)DPh4VitB!m7bg1t1Bq;?GrMu7_vF374p6jt}@q zWL_t*g%23D_$z@l&b8vCJ`L5CF9|5JB@~I;cdh+~NK6&*7?zz=SwupZoqHmz?D{k%>{LkG;B!1N0_0$kp(~!fDAbslbA!MZ=m8^ zO9ZHdV2U9^MXgPvX2w>j@PS#xfI<$$$2J?Kl^z60WCBxz2)k!(`?&|}liTfVyVN!c zTjyxPALkjY6HvyN2L4|Afy&`^2BrA#SQt!dUE6Bg`&vJfAvm0^5`QVW@D$9qCefk%E|&>^CNG-MHifpQp}E?IARAMJ4ly2 z;Ua7f2Dtd*OX%xgzX`Y8`b}kkg+=%8Kid=~4TpnVawDcjOhnV2+BU`>7wSpiWF-zU z5z^c!p7Y%2(98bI%kigw`locx{{8sChdzjHH?NM%UbyG;ludiSHH$nGt)L2kBIA@Rm6Je z#9__~```!Pr?$CCS3cnYjUIiBzW$#dvGaG#VOaHX^w^`c+BB#{O3s-HLh8o&*wLTI z?wLM6ys%(vgMkr1KX~ALd}(PB%Vt<@M!`CYz)h%@;;?0>Bf5Wfp6*{biA+ERQZ>*h zE05O)dY=d#TwcJ!@uT?2{SVPM7Z$Yv@m#88t;q$9tgyl=-2>Zq{?)ms?|l<#(Q%V& zs?(TRw&XZWQFMb@9gJrSc8Cxr;8##9L$whejuXX;*98}pv{F&>3xi_Ecy2?Z7NI_f?XEFQ)TOSb;fEeflj2~wg_pExG__&Z zQcNc@PCr^g4%G%5S-4yU%N_Ck8XBp{>20O3*ovSfQ03=g@FX1+L-BT4w;0S4jPz!TW z)8i+P)35zMZ$cuXUwY$D89{O0{_|yRZ3D|o%SZ%F_h)hZ#4-QyJ-eF7#3S9f8gSwv zfyM+3h-k>f17Zw_cw~YR6Au!jVMgQKndc)wTv-C4IG=UP+9j4$zJWpv!L5E5;KF|Y zLnr5#w5ksdrj)oJJGE3S2_{Q0r`mDbb5(rE_D0ehK_#77tg-1tB}PtpN0MN2h==xi zR#>~lLO8EPA)wMQnW||LuyDo0T*|KXjlnqpHQi2Mru$R0vUJLbnBVq$Z#6LCBOm?< zJ?Y6$i%@d{k*b23MV%R9iC_joQDY(VoIKA*VB(1*VR#q0X@%E3O-@f1HiQr)&M9K9 z*s5+9_uPB0z4^^=MwJr1{jI-e0AcT*T?At+EiXz|g?LVbE5xnD&`wIiBNp1^B&)gP zAth`uS!R|IIE_KpRLmuD%Bn>=old#$p$GmU=RDP$nrdnxKJUP}JQ@tk^2(C^uiyWD zbUIx-xwyz5`{=*fo8I(mbn4_ujK%}&Reeg7NK0eI5}+A|%%%WR0#r>hQ;|X#32~)R z1-Bh4jFsJwgUr}-CWSeNswtPO1Y%`?GrMIgn?MQk+h$O87*&<@XWsC7ZW>?JUVQPT zwzjxJ4?p~{FNCz9>WC9r*iaHfSP|_uSbPhVQWw2`$2$EkZ=0KwsqT#Xr+2%kIvuL& z8Z$F9TBQzEHIs0{xQx8-A_taioN3%N$fbd4F=BA9(?uU0&c!G<8I6ueM`9^;05WWB z46(7ciX;U`^k zsXct?kp0xp{tUn7wLgwji(T-93+&E2?hxNa8j2O4)pGI4%*+azlt#hDR9Pt(C740c z6wORbDwe&+&j#{hSSTkk=jyK_!hqU zjcaIiWd*PQg`cJCufNIO{>N{n-Sd0-`7e6DJF}U9VU)|rNJXU*Ry7C_Wz)jM;;n&E zQMg&C6_AOkTj4M%p`eMlSwK~Z*~eCx5s{givSu@5f|g=+U6DfE<-~1&PzpfA22!vj zg_$x-GN6z(v9o@x004jhNklb< zPuVrsT|@WYbHAN9al-cR-*1@e)8=5v7&QnZJ2yhof?OKa#sgX-9|4MNrIZjTX3|oq zs40}FppaX$7eOJ{bo(IX->vjaCD9_H#+1mOBzI)rZ@qL#)8FOC(?Pq#4E&Rim}CFWAJ7S0i50C`c;7{BDVGe(V#JOZWgA ztW3-nBNC_mc-tj+NchD`AEHjKkYEoM=YYnL5ZFc#SctV{k-4o~uqD06ZTrp0_X(OL zv4hYaQrCh~aBp*U;8#+RK$-)xgS3Bb%?v~=}PfZRcA&EN=#K_cW^bh7rcP&A(5m$^lrNmjZ z7OFHOb@EHQ%rM6=T+tlcL1$8cRh+dR^PA5Gp#%-aXRDqg(pdO7@gY_yj%B10*mGFz z5lzAyVF@Nb-vn;E~A}I-(3C%IEIg{vT6SdibFeCq6bFk503q9k5{gRNu0~ zcFp#P%5+&A4tZr|jWRPzZqOL(S{`xDOk-b&l7LV#BLlS3WSl$Q$9In$mdcfQbXcu5 zHpN-JKCO>49zJ#u7oT}1J^8%zlshy z=UngvTzB8Sxb5yc`HAOWY+tzHtMro5P$5F96L-4_qnxbUt6)}Jr|!^r zJkn0T$DQFo8qLVLLDd!Hv4SX}u4;_OBUm!(Pfr147;J1XDcSBld*qRaAGR-l?Q7DX znbT)n{xtpdU;B0b>%aYL{m!>9!RuOp{{b8%7i1L}~@cP8_3dw`aY6*Tzkz zVvPcflMAQtt((717hUv3s_QDvOiv*<hHeoZFc0y5#G6d2OfO*A^Nv}{WtobzxE~!H;1_8n>W!jpZT2p&0D`s zmtJy7URqmu(f|JaKmMg(`<>tXJ6%2r6vrX8B?lt#gvZUShG2J_=Rz74NOBO}+9jN} z7A`umOy!bY*;3qPM3~)Cmn?|74kBx$K|5i|$w&G)vK^_qN;}YV;~<>HGK(gj^)y+U zIb5WXuj%zVfzg=PVqv}^qL}M$e_Ribh7xhsF4A6^CW;0 z+#U|Tfh=h4Kpf~0VSnIYi8`CJWqr3>LTs5rPKfWV2uCM_u2O>87K@T7*x*nI2_k7S zwy+VIMeRZ4+Zxsg#BJe9rO6@yZK5@{r20-zQ}}D*|7;r5JI5hJWsAV*t2I3e&ttw`S#()Xs3vjZ{GUNkx1SB z-tD)6B#|ocm9Kpb*I#!dz3wMpiz7#lj6d{GAMB8kF}rA`+wIfF+8Qpo=o0+*|M@F+ za$$j{XXfadYp$hzd-mF>8Dn;47Sr7+{pWxD5HuH-l(6rNeLT~jv17-NV{v&UmB#J7 z>bi%lMB~B08y7Y}b>hsUstf`?_n9x?>Z`A^wbgYZCfs!6jhLO8!QP#FXfzt4XhD-3 z^v?bIFa)*bY_T~u`! zUFlF=)s}=rs$|SuOoUB|m<%Gx$*-jZ>5?W_pO1hHpD&Gy7L2tJDeR^jZ=eV6zXund za~>Xj=wUtQ{0nJi;S`@*U!x1oy%0P1pDxRfoz!!lc%gml*WO$X-gB>9cFAQ}SX;y4 z)%EsT6pC;h_r?d#o}0Jbv(xmShYu6X=&Y$3+;{Yt9vqK(s@K72lzk7N3IuKdC`4cv z&dl=bzwbQz*E%cF)SoM zGznjE7JSRz4)8nfwNwzmefYB@28OobYZr6D*q~t2DoTLmf$T-`TOL-|A~@LEaPn+l?K*$^RE>2`K55R1XW#OZFP-Ct79?s7@8n&(82U=bY1g z^3$KHcI?_kzxz9H0WsNc{rYd&3tsR-?sWRJuy7J(Y|7J#no`i@OjYt+0m_C%2_Ah} zh^!9YOoJQ>22KoX2$Bk!CSxPYP^w_0R)M)7lOZ<^Lj*|`h8mTN4^Ve{n46iw?DU)- zI(QKO^w0kS05sL_*mS?f;iZ!{91qRFR3&z1HPujLkTS8rk5EeCU@MrJnnJ(Z zWA~mN*t>T(F1h3q?B9Pboq6`@Hb1w``$kva7=cjtld)CozVUz}8xx^ovSLKT;U)kv zSVP6!_@QJ-T_wu7vBmXONJ-Q*W0aCH9FMTDa0*8rJAym!yu%)R=s^tEH*Ixog@=P; zqdcI&#*oKli1oD%TUuSF(Wp?j%e1<(q9>P5@slsRM80*~o%#oF`#t`HKlvk^e&!i` z@X<%HaPk!DPKR4XpsHas9uX0d6-73fm{K-J6qML8N8FRB!c-arUl)mtltIDB+hpL@>ca2Ab zp=_Kw-elG89e024UC+7ViXU9t+@vy@Q=-2QJXM&C8LEZGj)Cz|8A}9ZQEN~oOJi9u z%_AZVit0*}Z9lQ>sA|?GHxBE&~QAqW9#d-cW#Pz&rYK= zO4t|-b&$sd11+pB;;-KSK6}pPSK`9``{_qt{=;_DE#IUE4n0cmdEa~VL;v!j^ojrY zG_JVvnf%z1!}^_@Z>8z!KF&JpY&&-1xKy1Q%Zp3c7_6Zb$lUBKdc7_TRzwo@`+eRR z3{0D1>^x^HrZyZk1b|Z|G;XqouX2JJEH@)s+1OAkg_@?J;b3Saj83P96{EUSS(6)# zha(}WTx-lg$qnncXx*tWH9bXD)iDy{PTjFegt!)CB`Owihf+(YQ>hnQ1$i>KHBH8; zg@po;6w3^7Qzc4dLeAedn(9p%5vcBVxyg+SzKk#)H8dKJba`>Xj2+x6#e7yIFX{@# z;^LBx$3rw`%*5zb73xk`a+9H|=yf|d@)5k_`=3U?{Byrt{^T8hnl}a;G(9s@;naz8>eRwT z!<;(=Daxj*1xekyqy=c)&NQa~P>p*7;k{TPAgQy!OA8;8qID!OCO@v)`JJN`;Fc8# z2gIRaW$Ww`YY7<>x@7<`6Bc^QmT|?S`{O$3V%DnS=y8li#Ls)f;FgNg-j$dbX`+p9 z^X0p;Tb__Iigl#Otc)u zFr9U4odCa_IpvSRL3X7eAhw~e6xN**ELgX^b)a6@S*-4H=fB1688yh1DTq1*B=~*H z1}ftA8f++HLdvD$iqARYv~QoWYsZC;96tI(4=xfHiO@F0xTj9llyAWhkD*P(~`(lgJ7qTrg(eSu$g@e}c{|MD-my4qjMVuqQt865Mge z_xMX!U4<9E@I`uR@f2Nj(M9x)Z+sp5KJpQJ$`wzg?|tVU?ArZceaXcaHDA5<27SSE zpQYD-LvsMAzj z$wL8nb1cj}RN6q6ysnrN44G}qVg=szn7K8!#d~6jP)aOKO^~5sl;AUAYjZ z0JI)H8k=^T__RAGqPS5%!t1OB=LtYq6j)dgAht^3;vX#4xac1*bBgt{#J1n84KC%0 zcbvk&#Q-!8NEE-&%}>%TiCfFRaD5ys1GNxSHKqH{I0OIo(T}|2#PO3Cvp_%fnNP_X z`_Am#a`P?dbUWPZ_Hf6yZ=;X@>ql|vlb%SYpSjQ8@cN(WSTQgQnE~6jZ>P2Ob(mH7 zv7h*Htgo%o_dW4aeEo(S=&tYGgIB!rWpwQLF+A=2pJIRap7-%Bx890=w`)_=GuX3z zCypOGN)JE$h>k}?Zr2J;86a*2vSAAbZta@8qpG$RF!PmPE8^06a)>1lg$>)}ICQxX9E zUJckE`R>D6XJ6T?I+Mec~_08(w>Y9$(3<^G# zM~Q$jgioD5H~V)_J^jpgB#{wm1Ep$A9YdpvpbJjGT_}*zZbN-TS{p^KfW>mI1;<+( zBTs&JZ!mJ^s;5Cryw?S7;}(V1T1Kn816YasFqAeLDjoqxiHtxaYkkwVk*Yz^-;{UB0AC}Ydw*=qh_2F?*+gaC}&42($j^h9e8kTN<| zjWUDqJC}CBAK)~%a<4$nwYw*Uh@+lI=0sTk=$|&9fE?Au&GI>>KfJ1Dy5C@+{wDu_(M@%hql*gz_d_op_sO#aVC zY>MnQH4HX2&8|Kzg$-;4jWL9o4aGoWS~yjF>#g6U|M9E8NhuLt`x8Gw0C3&~7xBW% zG9Gy3VSs>scghx5H!QXMO8YmHWt8@}X0|i;rG*q;ygsUmj zQZ z5vFFOmNm0B*;$ZMmr{&LJSw=D0-3T}sg%d4As7}y%EgSCB(WtTLJ^XhF|eU=CT&t; z5u?OVQvwSy7jsW~5H^P+j7DSZJM9eY+`Suz4jtwL=bQ@#Ff%oc3-+HwhaWv+4;^}x zC?!g2kV-IaGK_}CL{u}G6;J%i!vTm0^KREU{IIpb+hd%8Vv|3mospZ_KL;6Hr;pZeSzJNN9W&OG-VT3%hN*7JrfEib?9;e&^++%`XVQJ)sHQ%xuCD=2R#WBcZ@k{t78dL^uXwpl)fK(8dOqL$ z?K}9EJ8#8nUh~5?-Jhm~+IWVhE1#t<40QpDgD16 z>hX`|D_~40SRoNYBqD*$NQq6Tbyy|xPqehYdy^oYNa~82Y$BXfU~6(}dE~^f#6|_= zgtzE6P1-yvN0;3htqqSiB|yMbEZRzIceDtk!dYeBH*z?)Mw&;v&6yAq+dhko2~|q? z=YRY#e(cA7gr0cmrFP3Vzkv^Z;6pS$J4L;IA6YZ9Wio|~M#YL1m=!ZKGEX5TGn7n* z3QRg*|uYjw$IJm;__1c(7}Vhf7af8Z&k{v7-vF(1!>2~dwC#0bP9$r z0U98%5P}pFAW!sp(vmEq=hygp#3cfx!Tb)O+gdh;_Z6(Iy@Q`vqaN<}K9r@6tXX2kSHVgK?X10MVijOmS(OnphCTHS6!E#VyqKM}S#| zh)iY$F~@_F_aTncnKL(?wBsZ=A@kdeyq6=>$vhz?dbJ3OZSjn_7?9dmt`5!t9@i_* zXbK*=XUgKUa71_O+Q(eG8(G!>Bu>TXw=LBr7ygW<>-*OY9k?$g?66&q`tU;=vm zDP3JzN$aZ{IBmyntW-T5KYq+U_zxfCpZn=Iq6p(-ANv@-a^2T3H#d*X%?Z&wF{3u@~EvYuhQ;a zJFtKM*;rj!wMQR$kRCnwn7sIm=L zfE8awg+q{ZdmF ze>a(k6%1_un z_gHSX@o>RfWL_Xp?}=qYYnju^;b88^#KCIk_#UG66}J)(4dJ3Y269WgW#9fV8&REX zYOaslZ@=S`kAC#Sze)gJ_3GD^m%Q{P&0uq#3Y2n_0l+@_A0M~zIO93bdX~Qb@83_G zn`==RicL?=px5nVG#uLZKjmpScmKKAzGDwI2OGHdy6bS!_g#owip|f=;f~vGr;mN~ z!%$V!-5%!W=1nBw)WXTKzPa8u;eNxhgq#Dq<*eKK@Ecz9qd$h%zy9^O>I+}8?c2B8 zr#|^98fS1sG&Y!$3A-%FB~~) zr=51T<>3go9XX6)$<}De2)3`~OsdAyy)G_0?+I8MtYVNyzGN%Kc27^?4_EgrEz4$ZDi~@ZYIe=cUH|m` z2VVV(OD?(a^0UwSqYl%klm?A?p~{~4;Mcym2eFa^+ulP*14+R+j^t~1HV8>1!M#N| zd=I4!?r<<&+i+w6IjmB&rG|sS#3&{ngc+ye z?h^H2lPih@lY~;#xG1;bH{CuT1SsiX6>q(Uw${byDq*d|&GA8r7Nn~+Q zyD|5A$ie(AKKuH@ujM3%dPE{oT*-qW70zvSqU`>g$=&CNBv;TvDaWly;bS&OAa;3N}Q8X^OW5VP~0NQsztF_)_0(f(exT{v%Ex5lrS$ zgbiAIulob|HIJ=9){^%eLT+c5$b*I`{NSlQW7$37gptgMg`gzD!bHTh_t^0x&qwf(8MojeXzkWA_1-rKI0Fz>4bAXaF zD7Dgg@}NqXnpq}dO(~5SGGMi#soqO*6-XDpePgLifyLR&S zZQFR*Z1U#jCf@LdpWAJWMpj!I=0d@q**Z>4KW-JVdD(Tg|!$J8*9nNZjPT()Entx zGsfEL3eMQK7iXS%21Xm3c*%2~=ZYKv=bm#8vKBmY_>j*)B||DflNG9_0wDPSLXdgo!uuP@{Hv6DEtv|!6i zOJ!qYoi|6DSYKVi+Uh#iH`eI*$&+^K)PkKlb;_2P7j0#I6@%d_RyWqLu)JU=7f#Uf z%Broct?T;oGFI1?WPN=VtE+2RSzE#4!lDf}hBg?EY?L#tuC3G8zH*hFcKX>cSbFYr zpAQ3Y<+Cogy?gdrzc+*7aFa*lkxEJ+R?B@pa?XXCQ66QJLTpW{9Q{$Z>Imd8T1Y@2 zIduwmA3RK>;h5G|*U+iDnCtd9IS#Dfx#uqXy}$TNedZINWapfD7T)?Rzk>aHPt)~{ z4LWi1IH1bK%(9kfrMD1pw4$_7HoGsII!lNr3DOMEmTjjowKq8eI0UnMthB)V!{V@L98WK#6%^LIQ7(+W45{bHf zhPs;F*jT8zTM7YCCC@hC$k+%)I`G9xN#L`B&E z$_1v`&{8)Xo6xOn^;Yv`MKU}Dw6s1UL@*N5oNc<-wSz|<#oc$@B~;h+oM%0ko1$3X z7|Hf+I{*NOj-L3%lC9qq%B&i=LG)VDDd=Q&k2Qk^+m9SNDtLTzrI^@v0AbSx2Z-BC zrTxGO?W!Wa9P@5q1{7Z00Kv5KML9dunZO`&lAQ)4Mz$vEmg23VZK1F{-g=1agQ$A53+ml6r zgqL}XZhQZ1MkpM>7qgQRqHpr$0K>$4C1&rN+8N3pH|%L9vxrQ7ug1T5Z@e}CM3hu` z%qP#AXaT_3iD`g+ZoS~M07s5e>y+o@h=?Z!JAf|)N|B>A`P97cZxIj#*iPy*f-Bky z9$*;ic1RGN7$R;RscI;u$Xbx9YWWAAaN&_h z1$!5H>qC#?4d4G1Osx)Wc{o7H1y%~R^=>ndye<_j%fq3rmj;`8Bx}vchT{?b+iQOe z*%Swl9c^7Eto>|DDKM$+=y*(r4j-{yof#Z|_+dJ7_z*2K1PRAMZ^DIm_b@DiFyy=^E;>Zabmu5mP_86#ksp2#p3Z;gVv z!?Euxi;5ssgp?R{U8CFUVs?5KRi|TISJt2ETenkzV9Zicr(0vH+XGU9C8N}-(VLz| zT?=x~5RmlyQ-D%wN~3f0vzVQmvYT$a&ThH+W^CKOjqbbWepn&<^nZR52E%AD2!*%P zPpt*Z;*TV9SAtU9OgIq`JiWjFz(3H*lP6I3`Z)dc(`adFfdHbJ*%_R6+UYpw`~zr) zBd8Ya-MiaNVVzEmDpmOG=RSk`@41hkeZ{lz;De81b90?O_nFU{7PV%SX*e8OhL(T- z>?auvh*+5%+NNmW@AN!}Sftj}0gnu8m_AnHr=r-pn?9Q#tU}!NB#A37!rdB77`XOyG zFNM;dBLmH1@neN(7WJ7#h;p7BpfFFC5~DPi`xF@ZS@%29n2ZjBV?%Y+2+K-dGgRU!A6J z5!*T`v(z54e&|@+C$jstw!t41z!tdOmLq)5`~z&m%q&jy5FBg^;?b&FzE3=Ypi~8 z39}^5}K#-(8IIS25CFMOW9dCP5h?(?qD zgNF|Bm%sF-;G7Typl-K=lP6DDuh*j={Gpel+v{P^-d%S8eGkyu>IPo-+8@BxU%Hyk z-G2Z#ef{e=a`-R+XjRobGd+d%jSX8`T;V1+ZNsgp7R%!zt&d*lScrw8MRCP5F2{S{ z|6cmy=f9v+Gt;>9j@$9|o4&5I(^EV*J7-0UNvg24yg=jO$a>wr&CSmn3(IIR zrK+wBQYGv5`sj7K)a!JtQ&;GAYIN!fbrO?Khf-B@CnZZss7iv=sgbG*#N;ltB$0~F z0xe3+EQ0C{UB*BBnkKwV66%>$BDMBnLTHJ^cps#)Qi+b+%owV=CmpB)J zjHc_JomyX2?M+FOy;>(`adJIlJZivo1;ZFsRpGJY$J;BO1gwKxB%Hme5J?5v*fuxy z*xs34|8V-u^!uyCt7fW6lIEPfFeaBhhS6~_oMXul_oG%62TW^2VkqJLZ(%ous5h~` z2(}AN09B#{Ow=+iIOOQORebAOs&<*^?E;0RQp;}Mn)x0V02E6rVRmUIu^*Iiby^#U z+aOUNPdxJxNykinwyS{F&-@oz4l zg0n|RJW+dV#B&*B3_Xrw@}%Aoy!mc7yk-hZ$!k>)xv{j@Vkn}$|b7YPb` z=U=@GL|lFK>aSpPW8JpT&suIWSQ4qaFjvT+X3U;G3X9Z}B;tP1EW}nQ{3}h7iP$~s ztc3Zf2KsAa!b%ptSgPhdlL+5)=bgCl2^U~)YR=yFwzt5FQoq~7&bfJf^V{Dd7_>h% zjp2C6rD%~3YZ+@{kF6Y_*eX|Pfq^yRG-TpcBN~BtgGfe+WynM$A|5B=hDaM%7qn+A zgV-(Jm>E_$KHRW$F%SM00))jE^D!)QTt5_Nv#UTPvRLB!P(+Qe=u_NEjzcO9@!SM1 z30bX?PTH>N!D(`+V;WIOMH1MY>9-1q5b%gdK8 zudV%ekt%n)-Lzx-E^eA!?)~1~-0gJi{U7*10bBZ;zxsPHRpr$`_$oPe;)ITKBUL4+ zMM^GNq$rS5fvLcN28N0WMYR-w61g*vm{~EPP~j?(Wh!WzF)B4!l`K(3Y(=eME|j4p zmLy`P)iBBlfO0#7%5RJ3i!G|9J06Kc~Fm~_Sso%Ke7JBXr zo`-+`=*P<1+J@}hxt(2d?rb-xsTCvjdKI&aqS0b*Rsl9DrU09>hYV^|G&`U~s#=V* z6=Nl+HKb~)s-&YaiewBI2h{EM@!}V~6mNLLPul(WeUC0UaK0Tl=S+I&;e&kdz4zd} zi!R3e>@J*IIEIb2)h9pn$fJM#qzj+$nv%5uZ9=p_SW%3e6X3>v11NW(DHD|quE8i) z3E7gFSpj7-BQh3K9UAm3mevf|lciv{txcnJ* ze|Of#z%H$W)v`W*Is}^dUU&#V^FK{o1eE^*3D0OQ#lW=Z>8$RXrRG*5?{4 z&*`W7bEDiyA}XH8V*&bN0;Es?Gn2guxfId~e2CyWIBO8G9>Er{&Mg^j@>P2rs2#S5 z)S@$lqHg-f5=FwDpomWP)Akb^>h1dVo}gq8@e)2%xw*vkQj`StrA{O-zVc$SihnqlYkysd7mvXPY8xfwaRxrV>^ z;?=nC&_UYrQQq3536bSs{a7h(R;FqTS*gc{@zN>|oW382PaS8D7+yyFe^d07xJc5g z?!SlL_N1rqhre@=-TB?y>8!n{V|w2n{Lk0@6#eBte+Y{kL*6w#j~j0Pj=k{N&&PRZ zo`n;aE#szZuEowB+i?9g*W<-6d@=9cx6?Xxjba)Zl``?}Z~wTT6~U#K(KQn^smH+; z7Gq-;5=h0`?RR;4&?Ox;Bwbi%sz;lfBO@ZKdp)k3f?jTPNXDdwsp-DW54Yo#o+492 zx7R_h*OkHgrg2wj*Y3Tvys~B=|BsK`|2Xr1(#-6%{q4KoO~3J*zh(dZmwr*-{dezS z7I9QE$1v=67|2ayvs2SlR52b73@K56dd}8YRs@D}+pV|Iwby)AU;V?crah;fZr{7- zE?!?<#g1J&Y1_7W+qG*qP98s{{gnSO3-uGU-|L@;Z&N=4* zA3ppj9y@xR@4EYLTyf&)K#tVE}v{kTyVS;SD1xP&}6n|X!mv2RQ3#<*C~7FeHGc z(yXFAOU(MzXJ5{vvgwd&a8|~Yxugy^I`$N1E2xt|gjv}rYoU@0h%0>W;6Z%n$YWdm z9;pD?dMO!T=-27NAAZVZr@ioki!VHHe*PU?W4W=WD4!P8pTn(&yH;; zPyDXDX)DY?ugEB2bFPly$-yY46!~aS0Z*5+@297ytfNDdTm_BGAwo z9SlzDbwFYnsJula4|^63uotm`w$=yD1P}!$ZVj$LB2nKGCX^7gi_EBvd z_06B3anzGoDp~_uXz#?MxITznav#f%i8?7h zU&Lb9gOda#JYfO&YFQ@sSrn>AjRCCy{50Mq>$ncp^_78Vz5V|@S^@z4LaU%)7j@sWT3I9+_<#q3?GQj*GTEh+dlZb?HP zw&S+xMC92q$p~!9?MS15sTm6!SCznwsSThaHWIc-Pk|7Tkgz1NJMX*$Z+qL@p=5aH zU;h;W&R77Ea;#i4)j9zm0P?syRg% zUm>Hc%*+r`zs})~t*mM#7FKTk0Ubdcue zcHqGI=i8`hbTAyCQwh4g8dem;!N5#GNqkDrd8{64V#dV7B(e_BK#PtDG$IfZ>DV*N zZ3L2r6Xm99($V8b{)trUsa}uf=4Zf(ao>IS5=kl#9Xf0P%V=|m-+kL};SH~UU0PgU z#_Gxn`D{U)mAK?=P07|YBOW&eO*1krMaMZ)88?DlNYR+;h)T(n^O#hN=A3CX8q-L# zjm8beTtgW(1?m)CIafwM6`KV{3O7U(bj>Mvjb&fL2jbF(v8 zTw1}x@{$RArlc`27>}KcLm*0IoY;QZoiMS&fIIqj~~USKK*F| z4AWCn7&Z-zGOoYj23uHMq@xQxEEv_uu zvE#?={`>F4Lk~ZQM-D%thmJf-M~@vTM~)rAp+g7p*r7vs_>o8H(9t7!^w2>%e&Tpq zSYE{H#u`>P*0Hv+YQymun}bbkjz%^Z4|vox)M&vt7mP*?m0U1xiVep@F1c{_j8San zF^$KKz4!0mXJ?+dpRfM>XQ@|ri!dZNW9#<1re zjNGV|M%8Q#8)s5vn5h*MYH}9U?8IWr?ia5hsHzs#oX2cx){KXE_Oq`w!jvhP4D@#j!#+j#!NM!{o$4(r6)v=|;@9WlSVmpR7J3vGNA!AZkaB(K4 zkr59WyvdX{gn1K*)|qupSXL-u8H6!lCrNOaU`MLNr&y{DW*VzuJj%_uX|xn;+)bU- zm`Pd43RR^^&n1$3-Hbw*eg}3~c-FoL8IDPxJ{QZ|akuE&{ zJY0C*dAfJ!KI}j9G@P|(ANK9sZKv zT>+ic!Bnq9{Z0p+x&})EhbIbUqmm7|6zg|-nCf+`-%Fe-MyF!wR5f)gMz_;70aGEi zWJH}rTqQwO0iC*IovN~p^)-w)8*9cx8x0%IgOQF04c0eSb-cMw@H5hqGT`?tn&Ak! zjL{4?0P%U)BCu8&WQ}sxk(wEsniW;jqOej}tw6K}s79BWGIG{9#>fE8#hP)0lE+%| zh+PV-Y^87+H#TlEZEOx`I3A;zNlJvNUX8iw8O%@3VCVMjICI}#yz*uLh301G==c8M z53#v9AS%Yc`#PQ>%#HhK3nwpuxw1}a=UC-1M1zL=UO@lISP_j~1Wz`l4 z@u}UdR$BF*x(dVtW5tYEiQNs~Uk9CW=GlDreGi}+4(Ww2e2J34Hiqk@$hu?ucEF4t zdhC(6NtM9v%mfP7Aw7OR_BFOsZrWLNV&u8ie_1Q5CkyuB8i^piRRZr-=oi&nNa`e;)JgAs0i z-~k-F@pyM$N#34geafhf5mF2F<2z zpPr%zHrK2fZRRJPeSogN_C|;#3{NfTpa1z^kR;IEkKT)YJ9lAqG{UXly&dQ8-Hl83 zpJ(IY&}KS)J8|+DU4PTp>D1yHjmJ$3Z(1ySEQB^hX1=zS3EI|%9I?A$3K6+YVG>5F z67_mr^m^0O?e~dO%~QQuq)s9QNQ_Zc6{>Dx5kAN_ZF^zb26sj^{-=XN^dj58orO}*YUZ`-z0pK$I0 zFqx|xbJ2yRQ});Id5^sEhh9$I{uIql_4PkL{vSAc?3nG?v77F{|3PUQ&98d(tN4MVFlJ= zfGj@O$F)!JS(rp8q@Z>O*^a}m0123i#AR;WhLQTy+^P|+TL;<|n`5A?EnnF&f|ga> z;xF8S`L0BVSZl!^#7e{>EKm*e;ACzIZ=_HQLp6jNDVD2FpmJ7KyOiKq60~oZNn1lL z78xzsxLp7{R?C4Ow4u_DuW0OoqfSRY8ww#2Swu=utN4mHUm=riYyj9TuucTa=7_w{ zaqcq?-%PuDAU*)b){91~$74twHd|IQ?uG6?@zOq64B38R*#rgOk`4gA)gYQc>JtWK z3%2;K*AH!fv;1qmJ7^Q38HLqJO=J_+xV4`^SQAhLiL?o`6Lu)UH{TpSZFt<$fZMHk z6ee|IV+j_XO+Mkk^3@=$fF+lLdHx&}ZRna!Hb&Z7Q^eX?w=B;ljCO=l(`#XltxLN_ zx7hY1?A*B%?|c6Te)D^G-}4MM*gyT_Kcxd_9k7kT23>#6jcMn$U4^oh|M>U+kh|}> z4?p~)KZp~j7I6L7uLX#RIbmjc1{<5}7&i?ryYw==;Q7zP%Hoopv;P3ydFLIpxV(gy zzVt=-+BMhW1 zfE%y5mUiymiFf?T|FHw-9>7<=dL0fw_K0rZwvG4f*{w~Jc{m(kur{F57^dd>IyEx~ z60y;6OexjqbSqSntlQ~Qr>>Fe8r^;ub=|dIU8CFWP%X*2bwzdEL8@v?sUk`2VS0%J z`z2#$HgjQp#I_LF$lN()!X7~T64{K52u-%dQ>W(6hS-Tp5Hcy6F&%p zw)P9=n?(@dJki*U25Y)y#I*7qgM085i%?@LyZ(N%gCy585B(#d~UtD6v%9-9I=L|hTRK7wW8kaQh_Ou*d~wd zhnV?BHbpRP>y|`rbrUHVpcF!A-IAOk4w)P_TP2osAb?E*nl8v7NX1*(55bNB1gs^% z-LUJi2%(N8EVYUo2G|lbGCh2-@@icGB#spH_}XN9ohcTZQyB;=$D&Hl2q z_1}-f(3#-ArlwX_z|K~RB`bM;ELrG1m_U-uQZaNPY@Mo8pIlhDaBZ-0Zeq!McJHK$ z6CFDG2mvV1xcr%941D{RZ}G{6leplV{TORjGYw81OYzM=B{Iu}VO$i%OwN%lq>6Di zci|=gl+050%xuII>WqCe5;irDon;}*4OkMYPK9HKk5QEpUiIo9vDLM8+E^a~U_R%J zv+&rlBU+GAS6xk9k&cUiOx22!utK=8Vk3xT28|Q(W+EOLY{10B#4=*05i>UoX^1iM zsZldWQw1|f*t)b?EWZ3`gTcaPEl%u7z!&+6&h2J(A~_7%UI6FLGVn&#rO0s}#J_iB-qaKwIeL^# z74!2uAe?NJGn(8Gv&Y42F()Aso0^tND1)Sd*%%(=r^cjel$m&yeHYT{R`p{K9(?#W zhU3wJZl_y1ou2L3wg-m~J!;KxfLH(5*YfUdvoy?O+O>DLzU0L(qq*%n>G+`|X2R$o zkusr}p&1f!O`4E6X@(g)8(e~))+m`U>RNydvdUeyo1878YDl?IE)ALyA=TpJb#jYb zDPyQ6EG(>Ger6u$o_{U?re|L9beICYP8W0Y+aa8A?8I@DVw6|_G-mF}%mAU1$|_+N zPLMrP{;TXDbF#q8`HL~6e3s!ss`wr$&q-Me<$kt0X!*MIG|`HCyAWL39t z@@yjmi=gCU#idjQmW7!-m$#^Baq+7pVW^_0C1H-UjxgFBm}(&p?G*@th(w9Zno>AP z4a)@(i9xW5X$i=spc1xh1%%cD!AOZg=5WW)|J)n#-`@B}lrqAR#}3QMg#|DRHKQ?z zKsgs5iN!#Lm{^fZndAczOiN>tJeb7{mW@GLpvASm=1EjsR6~*rgE?WL(L$^+OH8>L z>S#>X>Gtr7m;Vs{{(bMIU;f3P(`Q_91%B&IZ{|P#KmWTt`tXDFjAuN{&OGBRJAC92 zHF-RK=%I%`JNuL;9Y`!X<_4+lRg~R9LJ3NgSxCjLXc^fk6DL)nq)-*nLa36Kb!ROY z6+;GWY+4#-9+K2UMKfn6jcS?F0;-wS+Mp?A0u>?=s1|B76wFN23I=1NP7*+p_Lym; zLS;PW)wMOe^Pm0^GrfMA>rX?8F=$3S+#F(*N3k@QR<#vzWrnPvG*PRwikZauYh;B~ znNr0_EDCJXBl5o=Kbxb3O2sP{MGGl25KiIYzr9T@CQDIKHY zpN_M(+u*#IxXt@n$I^AuV;VgB%zNb$=XO{-29_j7$V9;?_5eQbl??*-U?-*kZrl%7 zEPz|niOSrJgCXvCg0%jwt>PUm+p(3SxjME@tn&+Zi-2Px*JlafCj8N%P9ovfA|`&# z7P%uB)7-M98QQY7DKebQbAFs45_X2c-fm%s30X*DmW;FCVmfY_@PPOJ&H%N^%L^0A zAUXQ)B-fI-nw49kK=B@d3@`_<+tAh&nN1}~g*LIHRj5RN#$;+V!6RDhSr3ABLQ!s) zFKj`8FtlNPZAO)8L91*)R3-_MWjm``5IoH|mJ*J`00QM8-h}_NzrToc!tG?8^C@g* zs!T|10FyRG+^f2W&OYt*w;#E0=|iO`fBS()%S)d2)X{ss{H4xtW5^&wzcYiuXw(9v zFWI3zw?{?^rt?PZ~oRdjKk`{Erb(| zayC)MnhCym%gyqWFMFxodh6{tvb;)EG9S3;LjC<8`BA*>WB<;j)3t0yw>@xQx$OHc z;&XTIrb`Z-uO}9c^VG~7Zn@zmTz>g8v3ti(N)Qz`_MFJ@xTN+&HjSn>LKO{QnWVy| z1eC&5RmqB}b*W3esSZY?UMWR+dU{M#D}B=f%4vvhHzAKZ=&)j>n=mb?>x9l!56#*b zWJ3K;PY3-Gn#~c)D5F{Flm3_b1gXX0<)^|$ziU-{*L zJoIr22Dq`6j*$pFGc|?bXavpX5oN>#Q@!!)U$@)7b1R*{{{U^9pT)-dh7Ct!s;e3Y z_8-7qd+w&=j~&zP^E>#dPk9>dx&M9;fT9g2u5sNp*Wg9Zd%j(M#pQIuVcR?|8?bee+%K{L3e^kV$SK8V=8K z&x#NbOiC>62-yr38A=Iz>sI+g(ynJB%Y`N?12u#N410DWm2mNh`#+TXf($JJ;m9*{ z$~i2@J*$(QXVq2>j^EbTp0AdD|JvdY&C0Am@ZmsPN(FE!2t}B=X8bjF5T|4pJ+rIPM>#n=@ zj{&7uzvjowYk%Uklyk%1{?@Gtrn>L6ef0I4zezXW^evos-r0811sCGye&LOiOC*;D z|B0%5xvp+{qe){**U%&HR*6sJ{@Zlr& z+0T87yLAWWoqIkAjKOeNRE<`L>)h#gG1H&o>0X6Wio%RiN|sV>Rn>uXDw0mZRKG@5 zchT>5PD1`dUFvkY=+<3y>W-y~DOJgm2nkoj6)SPY9tOdYnA^76Flxh#0?JX3 zHFkJ8EbYE^%PoBKP2Z#o_n%|OPc4wt70%yxI=%BB-wT#RFZr3*(jYfFJyp~4&9~S$ z?z)XGx%jEnYz%e0zD7%a@OlZua59xT)N6-NI2;l*o`- zAVpybuT*rRKmGo1w5kH10RGNfX~T;~H#m2m4$7kk^Pr0diXbQ3XbJNu-&3 z5Sv@7a0?1YqpHSE(hfNl2is>-|1FjUAY^s_L4zNNY{3dL|GE-I@S`{jo7o!-Ne*hq zmP&;ub-e_O-)*|Y!%&1;K8FM8!Qw}REW1@#i48HFWfB0WnL#;$VUb#HvDxo+`n^V?yJnfYm+>P^|&`X(Msm(@#g3PZBf2qlgiW7^CjL8_H5U>=537HibWlKyHO9t06v#2tJ z)MB;mYgr=}5Mz3J1~=V!BYy7ZejXhX`}+@mNMS{0W@a%zKW8`Hatj+^Rb5MyhnmBG zfB<7=70^h82Q0E_WJ7=loYJ~#X_#n4ERB$CitqqLSrAUN!Lky>P{=w_fu#UNeW(?1 zYNd=E%n1utx-aM@LaEBc#!O>D6bm;BhF3I!0w0Fk5E7&5j@oDiS8Fipa7y$kZi z(Iku*2~0YX1xgA+K+I5?Dv%cM3;gGbDJ3#gW|*IynLd8x=+T!BH-~5J+P}ASs;cT# zUFxLD0N@8+`eLvEH(d8sJmI2?wHb|2iI8#2HuLG8ThR$KRL$=?a``7il+Cz6m5G?l zNFhXK#O@7iY($n&MA-#_q{w4)Ps~njCr%utSN`BD3T5NB{Pu4#0lIJBULKDJw7#}# zC1;@W7g^l6TFJ=BxDl?$Otw)<86-+WB5sIzz={!z3}HM~SLxvD#^&kE%d2mnotuF+ zrZe+%G}zqW;|s^Nsyg`RfBMH_Z1M|le4|WFP0=%+@pM{QUI16(!~}(DZVXnlT1IY! zb1~G+mZ*vz%ZmzyOtdJ}QlUht&6HPTaA}k{7A_4p#u-o~1)R2}5UdSXAy7Q`d6!#N zcj$lp-rMc|`yVzic;CLg=v0**eC!Bqj>k?zA@^tm7pS7J7=sd+#VRq726m zk}I9Mb(bYoT5>~GE!L^KYBsq&{EW1=0|v;5Hb(<0IU|=Gsv)(}XzXihBge-`kaOez zSBeeSH=$P0>-1@U=Nyr_-3OSI!JJD$uiLe$>1mvK)|s|_=RB{kZP>l{+zT_p^z4j{ zM-4Rms})L=T|i+9Qd8C9_-xLgf?`zsyG@m~6n}TEc&>M3!We};Pf<0Pm=?2Q7-=CC zz={b`!N&S}nVOlBr(Jd#e*gFXm_PT$&)}_p@HYFKzj?Q;uddjU6UX_2C!C)b7Ef4S zALqr@rM-t9dF=PjJ#hB#=iDI2;?AQWVnGN&Q;dX3Ri!~?plnqVt};wSDT50Lsm`io zjxB2<%?-3+!+@x4q?DT6*euvc-3ye3BaqcC$e^wdQ)6aTQ(+@E;w)xa8zW;LX9J}Q zAS%78l2J3p+F%oFgH8N@{$v~M;uSd)t><-YY;2&@ z=~(I{nx321)#Ww*vp;zU-ukw;>g!(rlk%Z|{*XQR;KOvzd1r$lRCJ_)3M7IRRb?XI zrk^OoZ8N%7%W&BG>>35-jt^foAQ(VRmuoluI*O!v{LD|-9yy;a}!u6NNN z{jcA*tFHPitt>2}?p9QZaJG_;oLKnDb5B3>&qq20gHVJX=k4pnI={Ki`$!VBHnI*- zdzV>SrB~RTkh3i?{zSesGSnIl<@%{WJpD>Gl8kPxO|L{JTD~=Mmn$b2sjMC2x&ZoEx-xm`B4|8n>BXv&hR!sCqrfWCB5tz+?mJ(OSI@BWgifrIc*g8}Qns z)kf9YrseHhx6|Rn2XWI)U$f^u|M_%c`54~*w||S*{mQS}$3OK6`rPL~4}h{k#bV%9 z5}%G9JB6wOvYGbliW*fTodQg>vbt!W{N!ix((7JggW*tCR#z~cw3or z2Ohj1jurc-GTgGTV+r*R6p}TFWB$w=JiORIU~2tY($LCF_@}GJaP15% z!Wcriq|rs^?=~%lzywG^Ss-Z9DwmBAEgQs=vww`cfxY9U*@;d=jrF|* zOqVDl_Or$6>ql%~-7wU^pfah46aPx41zCoYKrDCR(#GaqIO@HgW3LK@h1}P~2hVAk0w6!vG44#e<4%Q%$)F^Q(S6c=#RlmaLRI`%y=LINM&X9kcK z-~gRnj&&bjYue`W}4Tl~de{N=j|ZA&TT_rCxA znqm2|#~;&ECzo)}?z8QY2OrKieECZ)RjjZ4!5^d#e&{2#w7d)sRKMbc@%k!YzzbjW zLc8Lst7*?;kKy^>`#hXDb&6Kk*6}^hc@Dnyt=sKc-~AkW-}^p*#idih;%98#ww>13 z*KqjgVRE-)ACodCRm+%68;6{PqHYC7qY?i0Z~hjy-ttY{_MLlZ+m3DdgCF@IwM}E^ zoqwKeZF?h8|SP6?3W*L=uryCPK!}y3HP#scx=mZlq1l;|CRvqcXwN!!ZrijvI{E z*6mAQz5$xEZP~n)?tSC|TyxQruzGq)53jA^AOHFt)}~tZ_z7U zXGnlN$g-v6AUctIamPSS14PauF!6rR&7e~Zii$6?co7>@-$XI>jL;jGC29a&5;+e= zt{Dqq3aJM(BuUsCmSQ<Vm1INB)8;@bs{1Gn<~gzZVp67 zDGp{%fL4qO8E6;V^_?eAoPLf7+uYn{O;ycDk3E5=Rs8Ue{1`SZ%-YezC+ItO--o%m z1x&3`j!Ga&<#QfkBy!fThp-YH8}f&aP1~wUlzJ7ot~x6hD90p&GK_o+6t|~gA=2=Z zt?L@rnw>a)3a@_Et1T1R8-MSA3Pf|(h@P22(rS=>&!eM;mk}bLTbc{B#kF9hSeVtm}*xnh(Djiz8CnT<@a)g zvbxQYdDF*KOy=SlV}r!~N$>zKVZ^;0&0k?q#V{_Y-2VIugHklc>`f=)8DXK2K?cqf zs+tnkTV&Bh;sYllBq&HcLqnJ$s5n)k5SXO2ygr$nedm4m|3QDylgrM(0Ky5Y&6-Un z4FRy9c=c;cVYv7H`>}QFHg1}RCT&9!PA#st6$&Z?OXw@Jnjw>!I_uJBF!00)CBHQU zFfnucBm)7ZiJ{|p@xX2#K@AkWx@nzr;M#(Sk1yGQtCC2?cMXSDpmE&aD;6;cBGm92oFE{ zpplY%=2IWHItg9>=}*yreCbR1r(gRsw7jy2@%luwDrZxoM8qVlmOa;@ZJ^T$#?uK+ zCSz)ILwVYA(<)j+&bfuQEwchPRpgvWvkGO9HaWLwq3QvzO>U`aTbbr5a}umKW2~;O z;i{{y!tCs38m}(n4S(<^0>Hb^ITu@IW^ih838z<9kTsLAvx$@xx%GKYq8fE2Bwp~L zX<9Ve(y-UZ?92>OVr<>K1qTluqyq={8-Zxs)}6evwgxl9KmYT;Xum(CM;?5Xj~qIR zO`Eo0*STlok}EF5#g|-WyDz*5=U;Gv?L2!YZQZt&cI@0i+qZ3(t=qTL%xHw++ze($ z3pN_fVKf?HW;CLi(SSyCBW&Bg6}!$p8|R&Oq3u5ReA<1^1$5~pm-2-dUdR_-e1Yvc z=Pc|zYdg+9`z)NZdp9mP|2$lN#btEqlP;xmFWim(aA<>>A$l`27|qP{U^vR7*%3Gi zudJ`rU3cC=H{Nhl{^r+j!Q$ytv@pMbB#EZ&l-g+qU}o8L+BDQOO4>9~BUUrCIfFQx z0oFj-TH~;ab}-!xXtGVSqE$oAYE4!{4(p2y*LN^fh`~L95o2X-l`Sit{@u^E6Q_>j zPyYB%t*UzZjco*?Nzk?}5m1{>!AMtROa0&+R6d=M#8_pGp=d zVi^OL7_4opIcvu5^DfYTe&;&`0AF+MH7dfkxUyuu;cTkv)LJ$iJ#zdPGFb<-l>D(0 zLTROMCGsFjM)ZB*?iX2V7HqoFwACM${C> z$-fVH!)hT&BL-KSgzHEEK&2OPVoqBuY{E8?qNefZ2+qoPJ)zg1g-plJnzS?I50o!ggK^bj7$;sBC+l#?qkJDbPk_y_v~C5dAI5r9+FC8cMGq5_>| zrg$Cfm%_h`<1Y*rMy6s>83Y9h%Sra%DfxLS_P-+WtWqclQgXI@3}-nN^?V9ODtAOc zi1$+*=S|_tDNTS$c-L0N-8uRI7AQO6)9r8!SptMqMq4`pvn^!Iu=FtrP@XGfp$@2L zif~wBm^Jle(o8Nr>zw}u*G1Xs6U+SaXM9gv7PP}BPGHB5v+)1#SI!MRdhk%*wrN3< zr(<^Oq*@Ci$gL0Ehm}*OaPfH;!H`V|q&d9iV0L_MT`ySJgk@EH?6&XF3%Bj$2X4Qe zs+ke;+8SYI!QS+`pQp)W9h(=nfPwV&?|c&{*A{W@lb@{TZrNd3iA)uDe)~>);*m!& zX&TCw00}|%z8x!qX>>QSz!&pEvC=j9lMD%d5%30iHKnd!1CF0-@FK8H`Qt=LspK80WWlJ9qg7RN9Mz~lQK$0tAaDZKRM zKS2BT?$!DEEx7*EpXU9C4&o_SKUohRK8V$|RoijiuJq1#zf%F^2OhZZzklI#pTF|# zT|4|9PhKmMI3d?Wy#L@b6!h&i2VUS{vBX+SfxQ;NpoUx}bp&1#SNHh3mV=VZ8w~eg z>~<_2Yz!C+1mMcgd7&8L_za^?tH^7h)f;sIY_QVcbB)356I))>+MzTw7wddFck! zO0GjQit|+1{}G6)p=v6i76QP4GBn2`m}7$pwwN%GjeV-w`CdiC3k3VxrAIy$jmbpF z4~oYZk$_8xU`%<96;cKFpWrFA;qTQ=970D$mSACw=YfxY(8ca0swq!@rSLShE+acO z@tCHEM2ez1_5clZY|)M-uRb|9FwAA9ol$>rg)hw4Z0bNwe4Z4>KD-K3GpIxYZupsN zkqi_dv18Q3H}`<+oUMt@Z<^xowFDA&lPljGsDMZsV^dNPCp~A!PW=9x-}srPZO?1L zdivxkOBJW1#}3Q!BS-aui!ajShmX;hzj{-;`>y-tY0r2X_8mNcfB)3K7Kxhx45@mS zv!ap;KlR$z(xVSPh~4L(PrG*Q!nbezHa2aV$L7tOZU5fAv~9~K`af^`TMyX=sH!S# z-n7Y196Qd9C+xTdxr1cVHch82@yg2c7W1kJ-Fnui}B4{Zk5A_4r9xf zt+Z+LCR!Vh$&h(E9`pM8L`VHZgV78Iy~-@YC%LXU)r?-R2dOFy>OT7Y3cW!eqq>h& zRW#`JP*t^6bwyQGqpo^LT!AP-z^LG9(oTtSo`^96u17}k=8YUxpC5Ae$KE}Mpk}!J zwmam;n{K4@&pwxq9X*C|yKdKA{atk1UEgLf=}-U6YnYZ-Aa##$>>%Ct>3_pjXI((r zuG_(*huQ~DFU37(01K%)(gpx8diry)qw3=W|N3FASV*KoW0{GVwhTr%dwwo60sSgr z>%u$~hBi;B8INHKszs0tND=?ns-c#InYkGm)_v}!s=4;;vwmm2X`p15$zV?Z06<{N z;VBi8LUCEBmVpo#uf#JH7Ey9g>F>g$&&)T97-jm>BQflPMiJ;gWAT0x04!OthjFH7 z4i-gMIFp0Q>>kz;+Tq1rNgM!M=VMq@h~Dz~A}yhAQ7uot7qS+K>As11k>+#>2_VnG zeu;G!AZJZO0t9r~D|Lz6e5RvM{BPMH0*H*j42l6oSwkH(_HYxUvT-vk0z)OFW}R9n z>UC$?bNEdXY%#6%sKv13v#N^sHHD{jq^O4FhA=cL@ zxxG+F0ZF<0t`b8K^+nXzc9t{Rdk=ZiV28WCmPIB=$brF@-RF$`^vB9;OhlC1Rt<^~ zk!91C_UzgJ%Wd1tjYdQ6_bOzAEw8Qs1pM+Z{gS1W@b4e{n2x7oUf4WOxoKh9*vM?s zjNK)VQY2{@sdx*;CLkeYNk-zMJ7GdiqTH((5DT(xB%}b$;-?NCJ?7CT3B#F@9Xfi5 zcJA1Ur#$t^w7R-3rClw8BDxiF@u)Of~K2*zK zz@Kd=hbQ7h0!dYFbLM;Rx%>TjIzIdIi?3)_S69=)Lx=Ri`|qc(-Ey;T-ZW2_Tz)wn zK5&3)o&jJsolY#bT0kKXt5MFTrU1kgF2(g3fPYt4@+swzphH+eL;}jB!Bi(95g~B~ zr(2#f!CJz;y?gDuuKq3>^m=HUF#*u+Teo4@@7sDa#`@aWT?RQMwpy(8h)LK8m}Jmu zoSoKSt6_#?W+ubo@brO$hhC+vT{9RB^K`0O^+#A*S>mQ?^}3f_hZlU`buwuie%ssL z&QH4R3fa1St1T_9f;oI;vQcg_X*T3mvqr!(0H}kiXqpMKW>{8jo2l-&Gesp8L>O7y&XSTTAqiRX0559IU^&yE?qU1(tzZ_+%*-L9#Vxmf698yo^9*KZ zMi`IR@C*O#7wD&c;-~nb2Oq$K=MkMRir9ss#N( zuY{a>b*_ZOMkEGFY|M;Q_fREP7V+Ri%EV;dAh)V3^y=Cc=H{@luwZlZBP`6%Vqt!s zHgDd7ZCkct^TIr4h9m0t2N?Exs4Lb~5lMs+w9UF&L>l#aJu(){?G)qnH8f3QZPP$= z!%bFp+l|&T)R0@3_o>=++>*6Qq>5Iv`IT(Fq|Jubl#p9CH7Hs#C>nsEX0Cnm6$QvZ z>n_xmGfl>0 zq`U6B?|MdZ>aP(MUM!K@1o)s23UFo?l|*ABUSrU>Vp<`i(@cCqD4mij9Zt;0Qj(J- zX}JM7((TooW^6zmaeGZslLvz`F{7#~9*?KE@~SHtEp-3BJ#Aw| zuXyPXP|n#_mX|HnJ*s+DyRx!$(eldb#R8l$D+!RizzQg~9S(jdy!JA6Wtvfr&Nv3f z=8LWtzjZK^sLN?mMmIbt4{HK<8A}#ZB@HVX(?Zzu zfw3yZTwjzf;7l%uBa_FS0Oc8f|*2r;&omQc7He?Lyb3vG=($623F~CkJ1zf zJJ#bZVR9l70$2#Agc8bV5h@!Y#bxp0L?pYmZuu5~6&P^iJ>Q|Luf9Ug-my&q!t%=~JhXQV;L^`*#qL;oG;}hEd(8l&T_XGS@qhWEfQ`fn#Xm?Jlba zsxvoD)_1+@1DLjIJ9h5imDLq)r%DDz;)JJPb1mlQ7U=NNBe>!zPsaT0thf!oSXLtv zq4&M-y|%o*h9CLSSMlC`kLzSQrFXvlpJjH_f^FTj)$abzT^O&e_FnUvAFrNv&37>X z`^SHI=PeIC`0&E6-Dd+D;BSnZB^T@w=yILPHf(1QciDfy;Zo}Ip3GA058NrmA-s`g z?nMEVG_Z}bw^|Gpo!GWvyCR+aiv`x<&vwBb{8la^t+E&RXFE7vFbs*|APPB71KTJ$ zXwm<Id z83(Z|)=8o`pA-a6pD6;Z1?UtDVr)>Mu=A+~iu5PDKNvPVNV{6g;(g-u2VWb7zg;@s zE>1KOXN%c;E{mzL3*%fF7w_jLKF-9aE&Y z0DHc{BmT|>Xffxv425jyvTwHapG$WuJN}LlPr#g2v?A^Q9KJ|%z zGZ3(S`!1kSOxIhqFqk4Tg;9g}6u_P6U#DNO;;4vjObH81+2t+Ai zDNtfHqh`_|XSL6M@O?Oa@Co!%!d-hG!KLS3f(v)=vaddHhh4jMCu7jFmWgF{9{d0P z-MHxF8eTjaVg1+%TDP1O4f&?QsC=47rC9pepZ+QQ$Bkdc0|yUtCbEOa4x`D?nhf86 z;dyp^c~LAk*5-^O%gdOkV{@j4X*;zOr%u|Gn>LfdRG^ldbLQstr>}ix)3i-qpH7LT z+Gh+@DS;uNq|WdZfa+wDqQGZDf`i&UCrx(%Y|4ZRirNZ$1>LZUpg>kIxz}-*hygEr zggobf&4*rRCRdxf!iB>&1>^u~f^+zZEEe5hU&LoJx%89EhK0x;h~isfP*?0GJotwp zmXMNzcp~m8A`yrz1c*nNfyGrkRAve#%`?`*meF7+I{RgiF{X zK$P5`CpZrY@jb{{#ohWR8v{`4Kz9dtd{(M4{PgQ1QB-UUUm{3V%YY>qDJXK)Qn+(m z3+fm*24}c<7Kyne6h@hdRIO6ASu^V?sAgtLBI8ua;-uBtef#%4n*h|q9(HWsg=)~_ z#na2^vEX}O@H`@BeCWd;LNlIV+vaT`2v=1K(|^r!!&Q z2vY^XNx(@UDM2FelbEp)QkuNEP2LElU`Mf}j`0KutEJM;6=){Ka7qbk4yIUZfC8Cv zH*5ou=g1J;lhgGrK{YfGZ#0I{&vyH~uMb}5R4houkjhmSk{If0S&(?sXX4WhGRh69 zwd-qZk3atCbC#ADFI||Q>pyX5-|*PU6Hqf5PbN@R+WW)-7_t4@ulyQzoVCNYZr@CE z^9z(x?NyZ;vKlFfLq z1q{P2-@KJx{o}6&0Q~Pa{yqcXvv+LA>~Mg(?js{}FM_DsoY88FnbEA)RZXfbT2oZQ znNvEIt!IoO9E_EE~nM!EC51(O#8QD(bQ%3~HpX zw#mq9rfsIi2#tCoLbleJg_M;f5hbZjhz!C=b%n!64yh{Px|hBLnGEmvySL-|uY3`` z{s0%BcOG;+#*t%3u(G~}ngtBSv~7W$+t&TOiA*ugnb#-lSX^1d`sx}a)!4RuJ4s#P z{92v$LD=(4!9lfWGyw->PPY+itrPpvq31JZT3G9i{cnLq&be*TYNp(%nJT2j zRjH}wOsy)K>6A1Rnn`Qp@x;c{DJGMtO_~NNCTC>O+-6c$wqPy|dIOuAo#(n9aaGqC z4hE>}o>jeprm7}NVk`-DRUt)+v1bgW*aKjkgrG#kVw@70$8#zH$S|V}k7%?8+GNvd zw%j)Ae*YR;exnw?*;kZ|C0WiH#%33te=aV*^b-8cPyH7X7XF8~{R2n@%gd*6?8HfX z_IE#97-_by>T2=y^3xvO``B+t8stGgRlPb{ud1o4Yfd7l>Lfj>sH*BzS4pd?%DsNI zT1mYob+syWT4&~lm|7v5CP|GDEmkb2h0{`ES!W|L(^YG9)tHXeTrF2se`1-eXzaZ(B9upf7K?Jnpv?z5+0?WJ!OSB( z%?z5MMrJuXRF_S2ZlLBqEP*(5Csa+5bE}QI5~FRV_|EO$rmL^K%Jx3K2Y>WOe?pX4 z-~NyPh}pUAn2x91>kpxk)vJ_YO?LC6;Lx&V%H}<-WsURWe)Q%ZrA$QZ920S4b~2?( zv{zLuB*ZKfH1?L5Y|GAV`l6S=41$*5{lWJE0G~X4oaSa`t3lmQRlni~AA9U0QdN{y zs|+Qz9OqM!VQ4Kh+%cgkb(jW_Zp=kE-3{_oU2Vw-<|QFWaNaLV$yNyES~sAGCObxE zUKRkM){gtJWcgA8hX=T;Rg1-{*90ks<{ps8LCcMd2o84^At1RiTq3VMd1Dac^(+EN zDvDg&zyhME4t$~X0{;3A)`&)k5M<>TnsbnZC=r-rKPLrP=&?|26S~lN6lnmkLh-U#qO57IvfDi{)+ zSjkzTXi>3^B{$QZ{j^v!mH_DEi^nGa{@G9KUtISBy85CE3)(g^C67aCR(!*&-C#ZfAl9JMpleuy;eVQy{~!`^`U{TT>XV9Q9Uhb@~o+3egbhW(m`{Q(BO9`y%9 zn@%PqRb>#OI#pzCgD-sXi`aW$KOWz|51;w;XDkh7@bJSAX{*`|QL_0^vzbnDdSwNz zs%p+?Ck-(Pje0{Ze&b*I^5^i`&wP%C{SlT=ow8Js=GIMIpYmN-+vS&DMGro3znypX zPQ37iFUDXnWOEucdLl4n`mNW$-fAIw(&d-%S=)Eup@$yAC;#n}vTNrqK7RZ-_B{4D zxJvTn8^4wq=)*AcyKnqo_dfCXA&f>oz>yTH>L8s-olvo$N~y~~Ft~-Sq1c)bl)~PU z%Ci#KYpe-ch_w(W`*gnO9f#Z*;ZE<5cG@-S%ms&y`@q{zw>!xSHwcQQOiMnX1OFUT z0ne6qJlVAL>JG>f7yGZkGtaocEJiwNZB%*a)X5z9FvWi0jw|rKQZ+DW|IRsx)V_B_ zW!qVtTZbtd5Xu&~?GzQoa$q1u3FU#8j$cGg^sAE?F=k%4R`;rbwLyN;F)Y20*y; zhC>M~u?-qWvA=PEHHHyZu1nlH!@g)ER zb2GCzwY*ZjnqE6`Zd?k zCqDB@+BX1g`pJqAODfwefORAwXc2^ zgI*7}-Fh2kgKgiw6ElMz8qMhS#ir{MYT7aNsveI zx>up<^{ij@(64LMbuy_1DfP*{4tpl4M$JMMGZGS*y%H$kNidl;f^V#76wR^^b-+%V zBC^Ta8UVw+-?@`M`?=54WfxwAG#u)5Z5{vhhknRD@`caSszN{Uu@7Uqx2RARM*E1_MSR{u^09(ll813g#tV07VwOxeiy#>?K?NBSr~xKmu}gH^A{Gd z@6;kDIa6Z>Yg#npF_zYrG+PFlBmat&=eO*{U|6@$-+c~Wv~|I*zw;hjTpvrXKYVni z?mgbNk+?3oo494;SZH}e-UtK4lj8%*_GdbwV|;W&qArNXWrvSuG&leNfB;EEK~ydW zj1q-?(Jm8QE-1X~$sCk6*_g=2h}uYDiK4BOGeF;H|JYgJ#%?!3;$XRh`>w(9nTUTs z(um6{HZ~G*UhILI?mi~YOo@e9& zxloqGtug$@^v|g{Ce{>wYEnKw1w$v;s*I4G#q=7HHNgyoGDD&rb_c}>BO>>{b|AED zcA>&4`CM^LiP16bT^JgS5{r;fE|xje{hYIJgSjJxp}rwwRr2XR!5KmxSnZ9HMA6Tz z-L%~0V^l)e{B|=ReyTWG&K$#Lz>=$l9gi_s)tYkM8#WI-c;A0tTsrmK;mioLgZXx5 zZZ19c-~&)o{PO?!O(Y>Ko?gWL58O-7eD<@NmDMGkPS;&6QPrptf!Rxa=J1R4PT!K0 zkQN3BQ%XrGu_3u%aiXwBvX&S`t&*yv9Z-O+$&}lMMQR8MmQJ3uKmLLhngw(s$$ z9XWC8-J9n(56(Jgw{F|M!ww!j#K(^x%ky)ySYBDSL4Sldzwu3UYVkB(dillFlN!0r zp74Vh?s-^W5C8%lvdCWaAVgROvJwlM7hq;wLe$I?Jsd6yk~=}scQS3?`!E$4@E%a3#))j1;Kc=BmkULnLEinnravOCTi$<($#0s?(-4 zcl7v?xA*EwS0^hpJ3EK1TQ}R+Z~htp#y7tH4I?%jK6cnX^uhPyd!P5cU?y5Qy#xa^ zYsOSF8M3Gunl@8wnR5o(1~zFjt14Rtpc&0HThq3ZO(|=(cG^&5*{sbD_)J^MjTil5 z;x!_SC^2(_Ev_tKd1-}z_Ge#x74ID8oU_aB6aU}4h&_V3#d0C@8s{1J;( zeBj^#oIZUVl9<}2B{H?hj-VuhiW5ixBr+lvN&Y-Z@h0E|g1Vg~vk|qS+yo0Jty9k= ziB(lH5EF?(#ie1|W@skloB=kXBt*!_t`T>O0Zs-sF6(hvs+k#)=OaU%{mDW8%cRJF z8j*WGo2RP6vZwQy9SzkbVGkQH{|zrER-5ZQCQ7?R2l-U#{z_QJ6NQW@-pB7jZOnL2=5_e>$E>u!gko zph{gWXW-~(0_tb9&e4c?lPK7DPYn`uxbb&CXJ88sY7u&On!__+`Twz0j~6>#UuyR&DFnEk;BbHw~J}`0_UAJ{vXU?v|Z;(9HK$ zEsb}8>sEl*sJmh2duyoBeD98}&#W7ucehVhK8pjRK;V50aP9&c;KHsHbe6I4=cSeh1XM*BV5mijT_IW2=nmYt{SA?` z;;q=vu>bD4N`-k1AR&~#a26%VaSBcja`T454+ON)Ymvp2La6Ht+}MsHOqHY7->_rw zzm;HWN@OF&l0eRia`;7p;HRikJgJ=Ant{c8g2IwYL0$?QOD%3O<@|NlJW=xlNToMK z=^fkyTEZ8)w+Oa!emr}tW5`m}|HVE71WmqI3VDym%CJ_^nqg2??dH+K zgXQ2KJ$jrjzxWD!))iL~06e^BpI!abr{YPMUT%VlB&8rQID&L~WjXhIJ)0R0byU^v zVyT2l+khB&WdC05eR!|E>PKG!#CV8R(vGYfP4!S}u&P*Y~{Q0uUGtw{{39F3k%+o=skL#?YG0B|<7U;X7@!s^-z z&cEP1tgWqERSPs{jAmx=f)_p;dmi0G2alYju_Xf$>6yxa>{i=`Cr%&N4 zH{OVApL&h8rZ$`z==GobEEbm+_52IYr~P~O($Oc5U^wdIw%fk#C$Ys@umA1e{MN$! zHq=r%jwf(y)a0Z;rJ{|Gft7c4zIKuL1`-w|(MCD8P>4We0k9(w;evj5ROfik9j9gb z&*Sid5SQ{Gw0K=`ap|j!ixMX`a`KwG==Zu_{tU}b?Gz$``Nr|a1{N02!7gvZ|C<~~ z$l?lQjZNP{@)(S#qVVAkLCh9Lae<$>-IalgM|qLp#BS~TL*UXHZXp(HalxkJq&x8v zr2(Z5L_xqO9f%&VJjbR-g#}5$M1=cFsQ2i;T!(|t7{Ye>PFMJ@nB1TBVA&ENnrWO-T~6LD#2aGh)sJji>vac~_n6_j4`+s;F_AM`B_qiA08+U()FW7!ozUGoA;S;ytqO)L} z{mk#i`kpyLxyjYP2AVFn-u(1XgX%tBmp8*KFI?m6p z7t!2h6u7^-A6xNx1xpmy6dSa}nig_Tl=*KJ>v-x|LP`wf6u~|KQ5FA9;cplgHzk0| z1RRE^&ODC{3w9|&E}!L-i@5H7zj&ak?_J95ygY2I^N{jABhWNaw}Jc0>!7I*NGR&6 zjnG(jlBTc2>;sA98g5mBf`m=10x=met5O}oH&j>kV$b8TOu!@|EtAoy#B@4AR+wd+gikZ4DT5ngF-cy(I*6V& ztc}V5fFuShjKtziTPPX?UR)9bDTNn#0PLv@U@G_f=V*wESH2I$BsLHZOQr(c3naYz zIQCLz59ek{?i-3=Y7ilX)r&LclQVEdJm@Ae0+M*pjxezYtvag~#u)T^?O8i^wf8*q zz~3w`FaO6`JI|{7qX8a!^ih7`f%|A}dCmUIPyH7;ar^{kMlSPPUwqv!@nATE ztvk2t>e8ae@A(u_EvshZY(Y!Zrfn4p)s|e?)|wMT1BO-0?Xiza*gk;nD9&woCKGc&NZ#r$a20AS0^yv@#xaQx&k9A7-?cNY`J zO%vi-r>Dd^ftoAJxkamrUX?IEy9vXYp|#VA1fdTPJ@_yhD7I|bhPBl(%oOMEJ{Q09 z+pkBXQ+(s=H={qC@ubegHb^~^%Co~pQ383%3!yg$N=EqFB%t8j$Vk7 zbBpZP!OYY&D`gnW)N)oeYjdmNm2XPc8mj?q&g7xi#0n3acRvgExR&sq&>U!@DjBtI zZAQv%&N`k>X*B5Lsn>iL{`;^0imgx9>~+8R%UbtpU0qqiw{H8EZr{9B=I0lvPL;N8 zt{#5$k@poKNm!7iu*(vJ64;UwvkH+W=1C$_CK)rynh1@Vcrgi9pcq#y$64rP0xt>k z$yCV_h!$(1lPq$w5;<tsur`;{ zyF)jl(<>Wd*OGNV@4ugk3G*3nW^@8w)l&Lnj<#LTK5w`7&KXb^_Z`Zu> zUAwm_uhZ_&tqcDvuZ^m%!0;4YL?@jWh&u@H1@exsAIzzZbHeE8PC%rTAzE;6S^e>i zGfTxi+`(zD{LY9u)$-e!$K?Lmnz84=ZE-b`oY~L{+|o41I9(BR05$_dT@9!O4RPXNo`Q{yNR7$$AOvCYy8v%gsq3*V zifM|osgaXaYUu2nc!1*^Y>6TytOI;c0OPG#I0RvZeXJ6H7C#fSvrpd zg}+Y_odjNFbN8sqMJV$kSY211v^Mj=6wev-iN^|T|ZLJk@F=A9^@C+uyL&@ zKr|;11p`0oDGqj&w`b*N+&&woByGxI!O53K=Y$IL)?&CT$p*`bdsNYPpgHek}U_{z;U z*#GaxUu&cO007WrMNLeNkv(|)1U+eCfk?H}G&!qfuk3`tle5 z>kZQ8Db`f2CdS7;{vkZ)8BYh*J?!3fHf9F1SXx@td+)gyNB1AbBxl;NOe!mJ#Qpj` zZC!!{#fXR9V92c!C5td6B9bamsu(HNHkz5W;b^E*5oYJ-{r=~Kem%0PHv*F%p9$OS z!VG$YiYuwP>h*|4XxJZ;%b;K^Y^knz)9gI$eSDuDI(iV268`mHKWZQN;D_;}ulW)C zZ~yhban?*igk+2)eRKa80#qTKh(NTsyeR!TX~a0{+IY?WB7K-}~Qc0LJ6V)86pLH~iwlrcKB`{&T$23ehka z)GykF;bE}i$y#tElb@L0oFSiC%;5*V*=OO?2h z*veEDT__)OhFRr+7K%SO07x0-gn+)GW4~pveDbNtT$AHS5+bTj}{PdI8@5zW4KsU-%-r^wNv)AD{mM z&CV=f_j%{jw4K_64?m1g{QD>4eleSwox#qXJMo=6@1^x-9Yjqht}L~V+XT8p5&(ML z>wW=XqCfnjKcv-_W!k)DtKEF_EohpS&pzjD^m?_47*#@Onz7_2qgU0|OFgNFJ#Ng< zOxB55sNe6S-|wOB)zs^aq^fG_4HE`~Aq}cNRdvn1x`(RQ<6bS`x(80|E^Z=7i6N8> zNsY_s-N9UAH)2b!%h`|sG8r<|&}2026h^=uw|<8{{>e|{s*5hNMhz#A9>EK*eu{kT zv!CTA8{hS*Pe~Te!?Vv)V&Jjg_)VM4&EU34w)L!hZ1pr6%TUWP&?2V<#^Ugczw#?~ z{ii;GM;?37{0YdGl3?d(Kr>R&t%si=sBwm&sw@27&;JbmI6w4)2J36`?3c@R-pr;wDPA3A^>WkSl%>hMjWgyjH8 z!OreN2RTF|!ORB0CJ}fP?1uo=tgy)~7IktDuF}mSh6-#13bt{#A(j%^I3{rM{^1qq z-sDl}u|#mr#`M`@;HPESR@S{(KS|;o1W@T46Gc##Z7@AzZ4xF>vano{nB=$ba}GX(6DTJ$O9Uhmt3{9~QG(H6FdXGa z_B{0CW;T<06^#Z%ni=-7Z{GnBfG2;~Q@}#_(tmsrAN}A*><3={N?u!8LI#W}5x^Iw(g6-FaoP81@teN9nIqQZ+;X1 z<-fevn2lfm8?P4tv}M~?8m~?9z(WrK0ErMx*%6phr-6+vDUmgaXUR#+&ZF>;7NezHQfRT{G=@>=9aBU!?@_H@|tSzUy7@2Eh4eUi(^l%ip{e zulV6t@X1pru(Gns7J^_?aMLtk_U5YrjNGFgmGe>A2r7}BqLhJ>Hx|k8u5QevE&x*) zlNm@ggUnbeM!z?MeS7xc#V>jh0N_3E{Aa*GPrCdHou8k>@_32X+jUD2{~R?@z*t1v zwpAvK0}yFMX~jsVW;E$l^;*AQAD&Jp&po+x@Pf0Dt_(-^Xe*A!6Wy z3ooX%^;JA^^cVm`UDwFDfqx+b$YCELu}auX8_Sj<4C?m=SXh_^VBBV4W@Zli_wL1H zGR925huPr}Cr=#*0l4F?doYd=KlBt=p5u~-Y4dV-I+}ep- z=P|P>k#WwU&M}2$kiwuwnUGbj^+dUrkkOhp8lnM3&Mhvw_+reB7Sdn*$)7PLqEG$% zCmBGyvUr*f9Y2mMo^-iZl2R}A+Ec4bS06rh?1x1NDUvpb#oLMG>m3V2SWG;GvZ0zL z!qPCw8naByXiSV15}8Qi6%w2h=F<#5RY|=_l1__ztS?EDQ?2FW<7sj4VZ_LMoJQLEPp!cGH)n|hJ<$DCU?G;!#y7<_R)lM5epk>kC0L#gfJj-#F zA3+Kq@zT#^9 z>nA^jlP6DOW;kQt_u}W%gAY7tXft^xO%flhioqjNEH0jBWK$uqgf1_I2%gPDSecn5 zd3(Z4#Jr)5BO?+KNtF={mt68B+jsZ?ns&;sdd&|50QNlgke#(_2i1cC+P2|`AK&xl zR2tYau8Dfk``#eG6i^)mhxrw1vJoO$K)nDh3ZUZKZLq7EU3i6!WLP_c^iiw^i;Uaf zN5E_yp#??NuId4?#4#wR2tO}%x8oQZ%5@^QO#yq02Xp179~YqFW@;R@HN~YSm2P}x zW!4yBr$BO*eOSL3d#`UuK|XO1*@S(qC3Y(ga#9zf=RpLCO4Kh(8^P&L0uopGN}yBm z2ok5R7AmiYxMy$ytGjbwh);njfEb+PQDGl0YFJ5tE4QZPV2E?^z&F4`{Yzow!W{RC zqw=1qmo{?bB$T@;EF!|%NX0hJYX=TiK;%P_1j-aH0zT!UAa=2{Sq;e18)&h=;ZO>| zS@BLjQcSeP*;}@KWmxqOnt?T|edezFG2idW`CAtN0M~!|di>;1yc#dQ?nPh_X$E%f z+-86L+8-mpbo-{Q^y;TvljlY==m$=fB%!YR01WSa-@9ovGooid=efQbnQ23YK}t9^ zS)*f<_5586+h}>(;GXq0Y?+(Ko^Ra=n<|>s6(|%x`MUpxIcD5?`z@44v-XV#9<&GU zyC3JAyBqWU9$&cY98A|6zUk{X;Feo&)#X!*ZUB~B7>bp0faN|Wb>Zs9vQK7_PfaDK z!1p|h}i>1L~B}AN0t3O-8R*S$|Lil%dVkW@qPY(CeF;T2YgUrHjSoKF;W$K58*&VL?nyGT2<0%l5r5cpfI}tJt$|zkSd1 zo=4lZ@1#`q$cHcPvXQgmAK(7>wrPGIFrrH?ztlebu@B*)2OhB}U3Dd9Ml<-*e|#ZP zW%kD3{{y%DB;fA*?s?l?_uR8>%fdX8do_7rXDaIY==TFAaNB1==euMbEa>-oV1RB_ z;LjR30-H66M`b$>Kkbbvv~|Qp#~1>C35tm0qy`e}q-q7@+L(OD;H4;w%56d#G)sWh zS>qr=j+{*rXVd#_Ws$j|fTlC-T?3Q#oHNiFq1Od};?9;kD8^-HEY{>w2D(9z43eM3 z`amjS5mx#`i2;TJfqw_9DAux=ql03$?(=k%^hXDuD8OC^SxR*xDozNHsBzi=q2h#6 z7~MFYTf_=}QJppKbx{s$k}_HFpDj0sp&0l$dp;ys0g7{sFvtkVZYe;;+egdEcBz?I zq^t**q5$a#897;*2>WDuqpS*W3_hWBv4wRLjE*E>8#fV!{KDsUUL3ebbN9@4C8sCK zS_cMomK0&1-~fSbB*&i7;G1_JQHwd~)&;m2+y{xGvI?jEoLkUXaqm6%UHkqIz4y-* zu%G;i*W%)fF61KzkMh#VCCqGEz=@+L@UC~g8#}gag~4#~r59msZOv}K{WfRGc~qXJ zBs6ZuAQ=DF>wg*knGeHAOq%QnAxLHF<9Pe+a% zqV3zZV190k!|yD}M0ss}0wSiW>Y+E=!ywg|uCIXr40?U*_lF=(sOlQCqXGK8%6ig6 zzp7Ey{(D{Ztlz6GRXs=&WAdPl6bwX((Gb{3i}#dp*f%oFEN(F()v!x8qYO}Y)XOf%yFT$@^hENxFZ@2k;tHp^c^>cEZ})xlgXmvy zi5*;9=fUhI+rP4G%E_8Gz~O9GPT+-SpQo2R=`#H7-@V<1{!z&1oUv(U7MuGctWBDT z7iNs=9xgcd9ITGlamRi4({rBw4D6U0;tQYqJpb13ywRXdzVxCC@#vvrG;y|BniJg#U7+Q5Dvb9 z$n&5C0d|*ALN8p&yij$s-~eHHL#k=PnsIq)u+1n8lLRiA4|%1B9>&6}0UXCL&B%Qj z3rMFH7Bn%O1HnN=^7T|pC~M(HMM|T45^~p3QbC)8)$j7t6TAp#0*j)JC7<&^yAX1AEEn>DRB@(JE5i@b3#7;jW@v(BAHr8e} z%Vx|%B;x-~#3xQ3$I{{o{>N|r2B{i8@Zk>vfSq^lg*d%*k|xuMd*T~Wlc(9Kc+xP$ zqFHJHUP*Oznu(W%_%ySu5YeO}o`_N_ph-d^CRR=ob`$VswaZEnXPmP->&hrtM*@hm z4TJ@rwBRfgp&(j@44RWS&>{hV$3TWdChkGR0(MI-KqT(<0-Vzs8OY?XmBMn^VA4~_ z8Bv}c-l$iMI2ab5li;OIVr8=7ptgR$H~hj^zIfo##~yjEnr1S!`|p3yvJqbJz1Pv= z$^=h;`n7WG#4-HH5B(_ZJ9HSY`?;S-zt^{B+Q70Cu$^uTGj#wlE2AQiiLYgu49N-W zF*0xf!1=l4mSbU;n>%6vv#aIeyb)vA8-fYgci;f7d+`fl2K@P-{t37eY~H-Ubyef= zp<@OGOI5kb)E9k{lsKzSNvH);WMeY;0Ospy{*$8?jnzrmAMjCCkU!7TFYLO4^!D z+6Ly*7@f8)=`^E-TBZy&W3vF_KpnsAa&L1td@^Q&GMfh&sVY1Nk#XqYVFok*@Q?lw zswDW*^`FNZ|Ktxr0G+er91N1-@X_OFH6wx0>J+US#4AfUOPVpLoZ2?Y%1jl8!x84@ z=P?=%p-r~gxskPP<|D_Bx%aCu4jg&{0PySouQ( zjkGmVRri3_tl5;NZPrFJx4AJTqinIUk+DH5sBtEknxRo8&27mWBI68gTFo$nX3g#q zL=lE)<_vT=^V=eCXzF}GGhzqs)YS_x3prI*2KfNU2iC0-Af~NSs|vJ$Ww62wEs=$9 zt|GIw%4i|kOe|**Dm5}U2Q)LwN;x#bYJj@0IuU_#&ZJo>X9HPFjb>|eX$YAK(6-HJ zng&-r`N{fkAOAR3mRIni@4pT&ec3BGXW))IZntVQLl<3q30bAglw{xIkG*AaWn~v} zGA6d%F?C$STO$`(0u0t=*sr!mP{!5;h_Z@^Gj2 z;;zIfTV-dg7gd+bEZuLC%b!VcJv}3O@<075&Y*A*zpx~{g{Ll_(3`EU6*SAyk+v?g zE*c3G@u5Z$)VbP4=NZm>kp@QWXaRLmhyX*0Nx5JT1}T6=0P8{a@&eZD){e_3*l3X% zt^^OEv*ZHW_?IvkEVBWgoC=&##hvlXpP}qQ3t$jE^w2|g#pRcRK=xy={s|DN{OT|L zD)#JonA+TG&aJ15GCO7{1SpeN@f;y_0s=A%l-PjQsr5vxYJi9TI&w({Xza@@Y)q^~ z2@Fz^9yV>;B*%`Q#v}LLi~eAQnb{Fm*4DX}gsq!4Yt^f@N71z9o&YdM&TLZQ;$P&XFB zoCtTM8!I7yo`TtBJ6YI0l6XDbsXT+>2#_n>ie(L3SVX!Vj4*ldX0alOz)aFYLO~h9 zL|&W*hV0}HlJFSrh%|+m1XNM)aMvPf$U?|%8G{+`FALUX0m*_4pv=$|kST9~Qv~;g z&mH#QXHP<2UkH(fR8W-2ovllFTC4i?f|1uI(ff4)@8os8`xgg`!<^ufA~4>CW9;#2 zg}@_q5Gyu>4_%K}NEUEKEs-Id!#ZF66#alP137@pki#0EA(1D6ijy=8Wk$_p^8d-mmr@2Bl& z@5GkgF!$>O24i_?S%>`^EM)r+9i)|GC-7Up_M2sq;5?n0R22b)+YaoNC-2$`0_+oy zK87(>*ni7yws!IublSj(P;FYkpZ&&fWoxtc(vT_=yyK(q!=>k6jP)klIXiaPrcJYU z=xgKscRN#7Q~WOgA~xp{8kmzM5vwE-S4>q^QNQ1( zs#n2mis5jG!C(N0B1wgQ-9uf~nC2F0M#Gs|OLdLJf?n!bN;UO*J!+bU6hK|~48*)+ z*G@D|)~|f|i9ifzy>QCS zXqyIq^SA$)TU89}8ogARwwha0zWPa5V%J&c;HH~yqGx>fciZ!y`#rRI(`M8u0m5k8 zmH_DSlc#a>&EEtO=|$&XVB0or*FX4!-jUYxbGeP z@tfcLjnj*#Xl`~cKw{tQs^si!$2O_6!~zwyeQcV6ReA>?MLM-HG$SwH+`frXat)j? zjTofG@Ugr{49+$nQCGG5&&2oefC(4_nVpP>uBYNrQikF?kfc_y8Zb&4PlTA>i#x|*dRQCbE9-EhL!`GN}s-yBgobVJ<$%6&bTjs2UV z4B+nd6dD&}Q1VS664AYpv_RnX3@_vIFO?|Kux>~iM)n(~?!@RkjEf&C;4IGqmXzj} z0|4^pbECoAa5W1Fk;U{DzS))cv5+umES|-4i#d$`*r!KYh6Cj@5fhv;Er*3f+?`U3 zpKmu|KEo#%#TO`2c)dJ~O)A3mG(6V32|Hr5iDRRvu{v%=`TibJsJ-i* z??em3aCQbvjD`7meBtw-?;tWz#;`x&wrybsT=(Md$4g%FVtoEnpQ4K|y9`fy(iQm7 z2R?=?ue=iHoqrChlmKYH`D|`}&v`r(^@f5YN4TeM8JhwS#WHi$W zL~0t&4ACF;Q8CkKW~6o9(|RyK-RmJ$$$EoiTqV?XvXm;TlQWD`RUuUlpa>CIf*EWC zO4R8{jVL?uk<=8Vs@YhPF@fd`CeJ;(^_#ci3t##&cJDgNR>$jla(NNYx$JU0c>e>o z48z~Q;SULtOxsmjlawF(tG~C)x1UY6X@QQ6$5_;cPOq*LMPtj%$YjNsAHVQle}-&z z33oqoADAqRf1G`>c~E1^+#F6dlZ=2EX6I*d>ez97_;a5_zv^S#{3aW(tRq3}hOhny z2B^{xUwye=yfANLS7YnNJJ0@Tl?Dz}zyT@5RNqP>GTcMfEUZcZu(+39mg3RvUds+* zi+jxnpvzGVmEx0&B7_Y_DR5ISyhvQ_!bQ3yAsq}st4j%~vvbkdm@HTv;M5HhixpPq zS#B1gnb=^skRp)Y4G{l7d4&7DQY46=_zmYz6v^eH*FJCZPuW)`q@ z(`Kx$u2XI^W=A7kn48685AMO2zw#x#><4~O)zq5FT26^I09*nS$M7P!Wa0|o_$p4Y zGo-}gfC!XWEP()a*GR41C9pU?N*e?P9g;xb%(!3Fl<1NTwe zH0alTnx7lu#HmvNV3Lx7$a3~8MGR5W%nF6slz>Ssy=4(Tl|+_>XkD0BImwuWjX7l& zw30-tvNpo45Dfkth)A%!eTO&M*z*$+BssX9l0SDS!M);c{YUl8ycc|*>ST(;M~-0omhE7Iji(dc_r!hzpgj>|%^uu?4M%o1 z6J}9>R{@NPaAGi;Ili*Ee8tg|C*H8KytGxM)=__0&Cd*Z+Dx0}(@QotH;e1O|3%a^ z4SxMse}nqH3TK^tE>_mp44NTK&}@`d9cYbS03gdy&6=TTNyEB4=S)zeY}rWFvSurx z%;JMfw-;731GfQyxhyZEk?JCCwR{jWlQEX@fRTt!+I$ zk<6fNYieYl+y$RWm@9-Hth1n~7Kz?3#zd^dhjKnNDnO(>&&8H`$;3;U7{~ z;G-XUzt#QJYHsb$+ivA^cAtZV(F}=5JJG!TvBwYmF%b_dA&^h1yYN60ftZBtlt5V8 zlv0*dWiU@6a#~Wo%*?A0S(KEPMbe@WpAw?u!Z=LACrS7e3@4MM6TK>(=pmiRljhi@ zogNUWmWRVp?)3*o#FohbC1n$DPneLE*tGQoP60BP{hmNB*lMW=0DU{}Xx;EUR{|oj zQz;xfa)GeUcL1(AdGY(yp`B~{ER zL)NiB*xA;kPWketT?>#NogEBdqwLl*rcWH$Py6>Dz>Zxzal;K?L^GY@iYu?QtFL;B z9yoBw`LhNS2#FPuzo*Pvfx1Yo%Ra1_{V>EI{@JDv7@$mev=8Q0q8%z|M8zpy`Dcy2Cr`dcy(gF4fxty_Z_d^%_NErT;GJ3%)b#>ftYC_rLB}?C)m_P8A+V=gM2%bkY-c0}QZ3%k zYmyFs;9}hpAWyNI^UrkBTPpc2MX8%M6q#pz8Pvl{%o!ZmNkipf3K`rbEN}j<4SSsX| z*5`|{wI6rC>}m~2=^U5 zg6CZMWb{RF`1lcg?Z%tv+0S`Ke$th$Zp(`H-@pDXTzC0JdicZ%didxu+B`o?oCK;Z z#%;^f$rKgWXbgDw``?9UKKofZ8VvyeO`9zVp%1nvR+nM9v5V#w^lL}<+rA@5arB|P zu;=>ETVHdgJVhq9|MowB8}qgBsil(`)_r^E$P<_}E4F**F01N5Ub>7VpT18`n6BR(PKw(?|t{-8P9sAUU<YBanFaH{CtN89`KV9#<`))gW=wLfPH-T?IIYX`PbTIRw5Hr*SWmhGm$erYd&8$N6M+I?jdg0?S!T>*mJdsA5-N-Kq>Sf zV8f*(@Kkofl*Sqm{=R*zX!D(+KuSw#DSY?b%`jlQ^jaWU~zhtQ4QIvJrQ+SDdt{q{>9H z1GCHYBjEG^&L}cxtU@QBAZ$!~d~=Tik~diE5)&JZ+rN7Nx}T3i%W;ITFen>#6b!Mz z2{wFue3jD(Yl{_*Ia8=uvZnyyt zJoqqn@7|3^9(fp-UwWC{_uzxr^Y~*dP&I?4RMDhqp{m%nWvl)Eo8D+2e*cH?;6o4N zmw)MXcE=sxHbskTuDurPlL-cc9{$h&dAr>9om-J}HU`_S?c43};lo&)tb?o#DFgXk zZ($JPm9+w}cf9?dc-J{QapMg)V*kN|cKrBp{^FPZ11%I=HgCabVGaV&G-L$BAPy6RI^RY-NkRh5{f zqMlT!l3xq(25Z2Ht>z)j6e1Tw3apg@HYOye^a(VpF<6ctKY>qu^0UZoi=A7x(80q; z@yxR?u}#Fjs^QPc*Jf$RT$QcF0~1a1Oia`urB1AUfd$Q;!4{XY?;^qG+6B{e9!&& z{T_^Xes;duzI6+lRSD%Q;H_kSNoi}0!gAAyvnMsiCK`CNT||^MJl&@VPyA4u6s4@-?!KP zpa1nc5GMTQul*VT*jeZ7!picRoj!Hi)pIat<0&m+8Q@Xn!dVGcB^irgok=Fdm=N)D zl4_lq$6y{a@svdxW@j6TFi`n`EF}-ga_g2TsyctrGn6D0_B_ns6vKEnT0IYatYRql@#lg(;Ml|G-(P77sJrp33xj^h>14)Dm0kG}df0D(X7{`W!woV8<@4n{*-URuG*>bip>DbY0h zrd_8>EmI4{G)#Hc4AvNIQb}6x)xGKQlP7-k$g!hOHz@ik<{IFBAjWriE>2vSvz*bI;m|>B3BG3Mvy zaQN^+0HBBNyWc1)-SFkF%43f{j+y>YIf>@BB^Gu!Xl)6q);Q>FEi7AhrhWF{KZYvh zrgck`D6}mXHixoJL1+wF71c+({(R(_CQ{1 zGig@NrqGUQ5X)VraILA!SCp!dJ;z53bD zeu`3E%lqH^K2|k8di+#gJaK|Ay6Dox1WKu@mKIOH=D?u?udV8VK|BkRBOsDvAkUOQ zNs6spD_mtsG8U1Ea9SqjRRI=_Xo*=)Q{qJtI&CbAOmdiklPq)!M5h2cX@o_q>7?a+ zdNQ3HB(i39G@ABjXDmrVMkW(&O_&lVxZFAJyyyV*x zb7mIu0Bou}8b{2SiG?W%=VC<~lI8z|q@!c!14hOo6-=3ofFnna;KBMq|K3NiW!om3pWk9EJU(#f=&!790ekb68uh7$UI?1NfyIx*{HX|=|ISbE6iTKl+acZ zhH(aoXML4mR4o=i5&%7dz{HWe6xRXC|6U`%s(95~5UZG-?BfL1`0gB*kWgrlKi0=% zY?+z4Z&dZ}1`(c^jPpGYJ&Il1cHpTOTm%8|A78!!R`uki-}^kIssb3*t&i@-k6v?a zLWbSGcR$bdXK2(Pgti7)n@&uah>h`q4}TO*vreym&5wBx38l%j)l?;G4fxKHqjb^M z?PR&dzaM!57jNEyy|>;)>BI?X!Dy!w$fgr(^YO7v(H}td3?{)p3X-O zAHl`vo`Z$i1=_R!aeV7r-@?O>JP5Fm=|2VlFKNNa~hSLWu=c zRWnryTnqZW8uhRbc+Z02Z~&GbRdo$X45@`DZMJMI!$HsLUP{7!t$N`Y(Cc$+WYcCU zC691+eiqwyZKK=oxDz|KZ_D@Je?K0&{}KADxBfN%$ZLMgc5K_KlgTo+Y~Jo`kO2}Y zpJc*WTUuLRCz$bMG9_5b6K(8YKlX8+G#SEVk}AupG#*cJ(WMvToSo;`J$KzngW-s; zecClR|Dwy7N)Q_WGg7l`AOH7%qvgdVoIH6F&wBQA?316r9&h{mx6{JH0-v{g2R-uO zBht3Yul>oNk?UUma;Rdux;}mBpZ)0{{oVZB9O|kc-r(G2P?!iz+cGDO!I=ajJXqOQ zMz++E)|g^6!X%tOjhYIUuFxe6Rwbn-aguU$8M=u-8zmzRL06- z;S$J!73Mj)hq{%XKZwNcAmqbIWA1{8edtIfb=~&@lOSX}{%abxQK7zd(skg{VjXtm z>iZ(S0KhGf7}++g$$k9@9K`??4)+!66hDZpFZZR0sb|5&JPXMn;Ti8>_w4)6tD8Z0umRt!Mg$WyI?k`I^McAhs54wi*44k8v#Qi7UzMoesI zlykSclz+TLE_F-1&WbEA=oHbUcfY!TMC$-8CUdVOgM<8MTIU5OV<=&)(p8iwK>*BX zl~4jt%+wjU#b4SRoNlt6Rm$YbFEG3CwRoh%q+|aw7t4x}ti|Ul5&FFWN#bh7t1L{lnkuS-Z}*)zd3__~a8zoSGBIj@p;L^kur>g7fjjfhVwKeiL@=+CkTU z>Qf50@h47Vl6q*{2~t(z=l<)@6DjbKfB!I^^W5iP)50cvD^9o~Dxtoj!dUIlCi`X9jh3Hg*2@F#eHO{4o9aYkwNk^#Z0d+~TFGlTt;*lzh$>wi`?WltR|6wg6~^9UEx`5vWmT zt;z&yb&C7%yB9a#^ktm2Z9DpDXnPMI;!C$}v%SX-;mG=`{@k;^k46idsi_2%66%K^ z!R*Qk4lr>4$-|gZ4dj*>Olz83i)XWREjxFdjfHJn=z|~o*Mc%eGX$w1bpF;&bbNJO zltJ37`n+{v9*gU1=nr~0XZu$4`V}UV2``>Lg*<8H@?GcX$wNnUUtTAGdDoV$H_Z*| zqvK}WsYBeOEBFLuAQY3mj=x8xnTka%fa0!T3w8sqOh_6HsX=vcI6l% zP+@L+>UI~3BnG1ZEU9?EM^FzHhKLoUyHr|!4dKU=W2qv~DfPNOM%xMxAyO;*M{G`1 z*3%B$j_G2^!NPwLMg0&`(J&5={0fF;j>gLO*KB2Y!{Mjx10O{Ua||HzK`D&<6=a~S z6}ydvvJq#sp>SGTTw2|+vaGgNgoCvxko&h(XVTahBLdq`n8)seB;+|{=~FxC!?8#bn4`ZwrQsPk$?FJA3ShC zF1++ooLW52FZ=$N+s8j~y*=$|&%*ArcHq$d186m)sw+sU!7Q#jb5l@GR zbd{yJ8@QHEKnyZrgIKIKY)tF{8_aC3AVC>k5)q>}=vl8npks#*;FUl4g8+cHz5Sga z5at(VxtUCHwlYvvm-36tm1$E_UrMy=RJ=Ww#;KPX^c4$`H)ksph2cW zZEJa|$O^U$GN`qT2txKaJA;zuj3fXj$xNUeYk`l8g0UXgF{?^TY~z&`9Zx5C#VcM( zM1nW}?i;DijRBB_-YjP80gjzKYU|U9D_h)|x-c-QRVPaf`h8GRUT+!}ChHG+7!F1{ zJ2%48(jvD;)~{=NV&8rk%m)1#kP@a%i#NUL_b|74liYj%U6|$uE6c0s4{Dl>$IN0- zGs~8d6_zu|G>4Ozh?!D0BeVw69Cf-<)3&fSL$#%>8QI$0G)CDnwU*7yG`B`-N|p_Z z2JJNazfI0rv)e?#+)~TqMxm_-f;R0G({an%W^Sevw9ORlbi$e&2fR&@GuX0G+nT9? zaua6eW~$k!Z5z&Qi?(e|O_41}1Ch8!JN>9(EQ`L}-ScQBcb?Ug_HL)z=tS+%im-SO>Q zRefw;*hHFvwrzWlJ-+An*T>_ny-Lah>7Y<3b0`?Ji5W~{%rp^}oa!{Kl8h5qtDMrf zW?q8Oif~#a=9MJ8l!TU2s!p@WDPt^}@S?CR_NZR2s%n{;k1sBt9_LmuKbX_Dq3 zfj}NdtSwcCp!~MK{&Qs!G?Ouy%%*MQ#b^d2x6Tsb>_Q8et4+)z z&`v?>!hIiDfB-dQj}l>5GrBR0l+v6;HN?&t)M~3Ngl~NPW;=Q8C=v;-y6g%}rb;Z5 zwrtq~R;zMu&tF?z-3DQ(5&0lEtb-^z`LG~$`%AC6HL8wqi|l&dh;DGegr)0^yI{Tu zg#AFmu?=_~N6=-iv8u zMg{4HEcpBCwR09K3t6m`7!WtIzbl##g%UgB6REPDgrDn1$(E(3x> zEQ-%F>axEI&LS~%QBsH`K7YrKzW_lR81LP;7pKLR53Gb&+;PXSongOP58#)!&ut3mE`m(tQ|fMUYnq*YfRPXM}P4bu_N^;x4^d9 z1^VJmHxhb`b2o1Wjg6ji@x{oKG4?$22tIfHmoZr%Q}Q|~;HNTZayF5pc~(raU{E77 z3iB-{6Jik}b~S1erka!X`aR4JXTg#nBpA&M(W@$?B&ax{7NG>=>39sTY77S>t9l~+ zsZ8}|)Ap@9Oq($dKXH_MNpR@!F;o@d4}Sm6eAm7A%FZ2U zV=%02W;ArT+hu)bq$W~38N2m~teJ@z;r;J_FYdVgHe@r@sU{)OwwYou=;M;hFQv(J zj7J}N#IAbMm2}aCyXle(FE*4`A{3N|j~%5ao;XNf`O=qh!S3C7+OwW%pZVlx?PDMM zckJA8ZnLm3hkNe6*QU)BpZvFv;pxw~mSI|b>$cl|{&S!G{EO!1W>EJkw`L7xFKLE_ zO)Cd(s~l8G3YG#Pa?=9aHFB(y37q5VX>uYS5Vo}iKa8Pfkf$|>cNESYTD-|)tVz0I zDUE_*q73)W1mMq5?8h1z?ln-2z)Yd+`OuJ!LD_tH_mvP0a?98@^QaU1yGzm3gRCd ztAC^x?HZh(LfvLc9>4`?$W7FuLALM;%dt6~ae|0o*>5yJgMH(ZodS_lFmlZN{rz6` z-L1$k3Zt^z#9S8Z@M9qjZiV_ea>l+}Bsd#XBkb&qV8e0)QH#z`y$m|A0cv@;r-Ddh zAQKM&m~vLAWoXl+X*;!j`wwn=_q*Tma{%FKPkpNV!q5L4XHz`Bf3Gy-sU)H5h8u36 zg_#+wtSn-2@g!dJnpfdn|ME_(kJlK0^m>(vf%DYC^ru{PHJ<*=r`h{I^Z`)nldvP4oQ10^a?B_u`J*Zo^yu@-5adaN|uk;eq?^gGddQ3YAn?SzbiH*N0R!R@T-b z5Nn$$s?-NF?BwYsu#pZ21FEV7kqU$U06nR#Cw)|PPn~7r8$6S^v<5E2v#b#3Kd}QY ztQ^cJ4Td@x#L7g*Y*|fJjf{{-{*{0)G-~D4hO81_1F&^v>?1^cM`6^*0ujANc)mYVO z2wK#s!0UeUCo$6>+ShNnIhHv!76w%nwvL84aB2nj9ezRqSgLxoYhe@C#_PbO!Id*J zxO{G)qm?D2(S^0t^=R*j<8<$-b(&@nRAp-y3 z5kXY6ZE0v{1ymFj+qSzA#aY{dW>AI(MP?8}m;)pMl0e8DGFGK3sjAd;=iwX9-fR8- zSo?gp?B`cJAy3`h;k)NMXYIA#^$x^rYzA|Kbs{E2@fsy2h#bTR9YCspAQ6EHF+{EV zl?JM8sy{`&USAI#e9&gMY(uD{EiWx=)~wx5*Umq8KTa*Kf(<0h%4C_?5=R~f!$t^U zrK+kG0h(^Nf3j2ej>c|%f7J<(#BO~&cB(T{bxu);^RcRpIf?}Fg(w#fC5e8Y2O$=> zf^sjWLJ08A#RJWXH52(`ZE#kZF+-7&&Cr-3 zXG2Pgacaoa$VEebm#G?(0y!&^CNx=*voaZjOeI4-CuiJXab-0qQnj$Ua^(j<@{!|b z7UzF*_rCq81Jx@lOImkAb>#R_dc`Y$QeudB{cB%`3op2kR@T?(WiNjT&N*-ZgK>lY z+%)Q{BDXjq^9GuYqx;Eo6pBF*nISRyG9icu)Yj3NRpua9h=GJyS;$x>i%JTyq99C& z01>r-8YBiV1zKHR!pY+&@wBI31y$g-J8w24Lk3|q9O1DOj{*SdPKCfiNi#8fheM1` z9YPfXH)?k7U^uuUFi%x=z4y%G>DLo@D#SpsigD-mUFe3M96NT@`n^8>{7?S`W`9 zij5BuAuG_NjHXE#4F}q!209+okw+ipnf?rB=4Nzbea-&#&);kStXEgKZ0~*y*4A-m zWySr9i3&jPWR%9-rl1l*lQUK}Mm9(dLa%32-9Amt&hl_Hwo#K2LPhhd>$b4E1Q5}M z7hj0e3#ZZRbn&}ycq2x`jJiLAJMXy%W6gP#8Z=EpZeS@ZkP>prNNI$WlBKLv!5vTB0n?C^S4Q_GG>Sn-6!o<%;IcNCNz$`bJOnp&6rsT2=11VUwpe|*hma?*D!`fhg z(Ws%PKkb<|SX;;c{`-Hh7-Br~=pz9@H5`oS8S=ydA!DptM7^<5jo!NaR73k%kamwTQ5S|wrC$VLd% zxSbeVV0JYVi`6k&Cq}A5u)5Q=$N^PVS*!(t1yu}6A*uw1P$V|V&f0d8LIqNB)h0`u zc@o6)F1Za8Cm=-jXrZz#6#xPjVl6pU1#MIp(Md^BEd*yGHa|ZE9D})L+Kky*yu#6) zUYRKfnTT87alx&H*vmiL^>i@FRa~TT}F%z+{dJvBZ34BGF zojj&SkpqZ>3WFpBiy=VB&*oTFp)N_*Qi*YlR8fTx*TAyK@weGfZ zZX45rTxRX^pMdBfuaEwP8LefNg0kQ*%FPyEq0;UsI|kDNWN6I*3NxIUTcyca&H*Tv zdYCBq%NG^<1Zs(0AXdbp#BYK8Hq6$+H3vR2GFYhO&=G_@9G%Dz*}b9|1`{ohcR}LB z_nlUV44#&q3wGc7Ef-wJ+N`=Vj}#|@)(*mLY1&!ATu(!OttJc0k{QKPGIWT%=V$+2 z0{{s&`FsI6kpn;oK08GMDh8q$Dgq)55$g8sS&>aWZ>4GSg*$hA5^5tOq%S^jmxiMU z@v?1OQ4{5HO8MFwZpwRh?b84J;+N{KU0ZE_Z5jXf?tAe4S6pG^jiKFf>=Dd%Iv{rN zFE9{<5r{DwCcNz(@6{iE*^gmvYRc4<*a)4e8AOUSNC~%|I+3SXsD|PzH(hTRb}I~Q zY~TFQ2XwTwNMjMqZkxmJ|EE`KMX;syRSfeO-}vhF_WWmjFWvC%Z{pGmF2SC?=OXrM z+awz z5j`_vU4bQ_sypBibGJW*PPcsp)Bx7>q@z+v#$*u2FX?gX$3}on_j;J! zvJKz9*b86y!x}=MWXip%DYCLW7iLqB z?=TWZvWzne^Z2KKdLNy6>@*7#b$dP8xobBf2VC*wC)*WQJ_R@5^esB~!V7WWz&W_& z(#N3_>mulAO_~(L;Ye53)^O{s-?0}w|M_(Od3)%q*IkSEzyJTnsyEHYj~}HYhYz7s zb?~`suN4p?2>kB%z5Cy^8DTsaW4PYbqtU3;y-nh=x&xV$o{OVKVW$G^BDFkst;v`c zl^L-?ZPRmIOAsg*!U@#D^)?{bRAH(ph9=HrXRqHxWjR;WJdO>B<7lAbTdoE8Ze1x$ zB4v4vEh54#U_y?IaB0t^;JNHH84v-n;07`wG8PO)7*Z7LEQJV2Eoa|z7)%SMTyR$_ zE(XK|ica#{s20gvw**PR?+mdqXH}ugcPKnS`BL%hviK!fP8_C9JI04GREQWmXYbwesy+b zD2I2;^vq$hokq(tg&%}gjEJNJFu)j@;QqVC7KSX8U)%3CE#yXjb{J+wgRH>XuBb7t%6$sD|?q=Lp$xbo+S0^M43Oj~>MrK64Gd`jxN7-hKP=nQN}WPyd(yjOEoO z^!t7K$Ok`+fB*N7B1(h-v}I-n!@&^4(YQR=EiV>G?!$^$MH>y*bEpDc|JCa?#tPS7 zdo5O0mg(ki-iZ6|f53=lRTQ!`T-jmBgtq3(6K zsw=DN%IahKUPaw*7u{aX-A)Ic*hk%Q&#rE#My#SqWUvUk>cIWFLs`Q~F~C;? zlNz){{t`J8(9As3%NSWRHI^YE;_ln-z%4i4Xmc}D07o2o_(AOH&&cey9XPtWh-b~s z*$=(`*YoPyz$ip|^zHBB>C?+Jw|yHY!r6TqRZqM$?RF3kY`{I*bg#Q+Dm5 zBd1QK>`T4Dz8yQ>u3EO6;MP{g0c0zzfzsl(5!G#IMQg>R6K^aj3{{?lKN$d~w`|4E zo!e+_ZJo}{p9TPX&%545%#4qJNI)B|V<31{_J$5*Brz~3+C;L3a*weR1%^my^AI!xOu`BfD?^en zcJ1CNCr>T>`lqkH`j)AwY1^`88y`RVsI3o1__<&HMOxn&*`DpY_}~8R{e0m?7vVFX z|AM{x)jwx1_@Nil>dGoDE}rs+(RlzR8>Q%Km?#wfxzCo~c8Za)5USv{G+PEyaxh34 zN(vSx;lM0nf!KI6Ctu-bz`mc)k0N>iB(ip1DUeH20>)l?RI+0E6XohS>4znBIx#}uxrTNXoxWgu%Sb2azY%nCEd8)1Ir$Tdr}LmmPW5EAUE6kW-R~iWfTmF!k4LD3*kg}AN&v8D z=UzN?@4Wy64?pxU>TXBZ)|c`1>uN1DcvEjxHV9%GcPu)7JSnKWf&HH@2v zMtP(uC#39wrA^adoD|6jnk{P{6O2r?fhC5Sa<&WuEUOW+(ijTOie@~fu_-4VqiGUU zGc=8n)tE{uOSX*MWPiq)#K>SQKuVUCkdtw46irS@IccLAqm%(vi)}iHE7W3q27*xJ)Uglws5= zb{Vin8w*kBahF_%cmMOd`PBR=?AX2wzx#&YB>?>3L-%3aWE?nfF2I>W71D4pyx_ry zANhlRw^qc0W|hnkE8wrQSF%`0-{6< zk(fiJLagMATcavyh!sLrtB4S+HSb^(5J_N@P6QLHuw;oK4#9#%jWIw-EXGJ7#2l+Y z62+>>7Gq_hhDr7diCBS6iO$Bw-LfsuW%BX!#q%5Cl#ISC|FYv2-`;J}+9aVQLOE`GOWc@uEv zmdJ;RWg8a&WK(^ai%?yBJ|~~8Crb9xJ34zh6!5$S%pH6+R#&;|rWJ_;EXB$|fYyzu zRgbm(2bIhhiiOM)TC0@8_$af9&mg65q4uAGfwUp%T&yRRiam<6J1sIaczyq;q1+xj>&6$Kp^i^{XEL&?dSSiBH{a`}3rGJ`TaiY=E=lXjr;Ym!L{ z;l@8#i?t+Cn@>|dSK2%(C)Oc5>jZEc-3Er~et)>F+r1SAZbpf}{m2R0JKe*jJ9jex zeC@_>vUPfV!KIJmJyUZGGTd?SU_N*2b`SwaPCW)A!S?An7{H^X07ONqoK)?L*MEsO z)>rM-|Miy`0LI!tbF!JK8BGS9*jSMc3oe|V!_9+reCq4hAvR;oZQY5Zcid)G9)s$x zzV@Hr%ICz20x1$Ked0@BrgQi1!A0j@fTiUX{J_(mj-@ka^t<=pjazT|Hc}d!W^IA4 zGSfTMT0Wv@{g(oQsxb&T!xEE*P-_ek#3mwvm>G2y(C<${g3pYdPUX2t5+Nea4P#am zzsV{_>vcL5xl$HJr~-+I5d~v0jE7?a6L#<3flL{v78Y>-efQdJx7=cvJ>l{Ar?nLf9OT1>I&C=?K->f-h1%$r#}_nz301FT3p1osag5+zx=BVf&RlC9K-`PP-4t98RTgzn4-73tVJ-w^C3dy;Br(Ci zHRKaNr`~ZecAmWyIj7d;xt0*d%NDFcl%USQ>2$qYpNpXNEJ}OR%BAWcZ zraiLg0qxqhsCrVH=@y{HzPPO;%ucc_%*w*p zKTGw)CE2?;>r5OKkjtSl0mIwqsxsXb8f>wdM{5)3Y;<=!qq9fHq5W=!O3k0m<>{71df^i$4xfMH4(Hn33VZP(ZKO!SdRwKUe|C+8X}A%pj2i zx>G$$8TiGY{}o((=|%YV%{S@%!WrCt*IoGLH@*&-qEq+KpPI(>^ppw7cG_L%Wg zq_NFKz3ANYvG>4v_QpT_UjSesl;%ejkpk_R-AY2hvBgCLjOwZ~BOn-IF4mZeHDx7Y z6{K;a51l+gQ&puGOQpBW&%=mw6~cWp{oZnulVkNQY*RvctQew$^^7)QiFj zCoN56kxjL>m?!~AJPC#M;3g~KOpvpJVZjIn_ctv5t}QW#N}4y7p#kb3IZxi602Q~l z@g}=yY+FC-iKRyQx$W>k8A?=`KIP!C;xBK$Wbg(Z6KNTWUwk{cFsXZ4(k95x)LOtu zVO4nus&a%)>`Jkjabag&la^zl#TT=@U&ih7Q%ZUR)CdAtWoo91y3^_NLx&E(4yHm9 z(z*K&=x8vawbeD40y}o?p#A5bi`%|)N51JhH(_>eo3ekzVVfCx-j zjAB3#Hiob;S&YG`0!ffuNx6TRD3JKDtZ>O>70rk^#F%5nWGNE>ik*o0(q=k0T|)m^vWdChg#f94N}{;Z~7+Q_4a?#!6@mU z{Lvrj>t6dC>7olRz<>JbpGFX&Q>VPF)7jAAU#67bCOP{JYALiB34va*WjJ@0u?gMIWvAE9if7o2}S zn9LTJ<}IfNB!rZ*jYo+9LMKEh6*{hO9U_dasymV!?JX=XT}D8hnx4`f+qR>wySU?y zJ9(59pa0ZnEW{d%i;MXC|NVD%+2v2bh38#>QzuVp%Ef}KByhq^dD4IygaVjE0naXh zS`wmGy_k&HER%;|k`^&2yI@(>G`mlXhswd4q_)1gfz{Q4J@qM1)o!Th58n9u`Qb;8 zf&lE?GH3g?Y{Q{br_qcXtwoSFgQzC6rO)A!#svTZfa%#8nwy=mZl`NRz;HNViDD;C zox)(WLA`zl=N#Ct8>1n9?N?ue9s71+FdXyezVJo6`NkVz$ky{dhEhsS_yfo+BWFXC zlck&prbtajlXBK%oSFtXHE5c~-0wV_CJ*t1nk7}s4KUJV<7Na+SxqxRv#J3|N*SuE zRxDcp(+o|jO;)5f^fWa{;|95DFis;H4V&DgWX(9ENs5$5Ii)cgO_ns9rp9tgs#!Iw zQcnK*QdXpsgU;j;{l<+5Sd9#KPRg>Y!BS&m@ z%NE_eV`nzYCNZYRP9A^#;@a9=B-uQAOaIShjtX!lm0P1A69^K*APB3QmykxOnjoF! zs*0mng~htAmTHMHa7aX0$eEWESOL*Uh?lzE?(u%FyAtbql_e}TIX8pRh$W&4!WKiw zAxN&PI@O`pAhD?;TNQ*t6+vJPEJaZe!Au;2Fh?Q@tW^kFRner59P4PYVv-mTIu&sh zEJ~zM1&W~pS2a~3S{0+!RiGf1RUudm9Y_ciV`U*mszS7uEnQX7su-xQBXOu*(G-K# z!U!Rv3V}k16r{2cBUmb95)DBpaFxsV<0!#Gh%~Wmlt8hH7DC`40uf>n)1N|h^#2q7SfARr>fKq0bm6sZDR9cz=oh_NQ&ip14d7D8l} zU?Eh9fl*arF?JB7LaYMnDk4@EY^6eF|@R^B>t$ zuDa4P3^^-Ik+S7d=#hL;U7!mpj1N+aeuil9JdhHGCgd25f?ZB-4ATIR5mPS0fTG)0 z07y;3wyoRomFup@qeqV;))g+i*^BKcK&K+DBq3Au0gJBb`0e~>+?YVs)+liqNA*>L2(AovIixUcf7Ug(* z{mM*71t662p2E$n%FI-9bi|i0Z4fDmZhk!qIjWGp+Mfy0vd0hrP|}Ir4rR@_X#c+7 zDgbl7>Bu9xwb#k#@87Kq;K&2_>7!@nb#{6Ny-wF=rl#!Rv6DO%#pb5^7>!1@G8kgp z)@ei*UlQlck%T3%%`Yz4hyLXQ^t-?F1^|St8Ov+y1S9T*h=FD-jz{Q(Xj1p+{f8g2 zh1+hYOD}&Sop|UFXk!FjTjNl7@Mo`ijjm@!jNS0iV@K>0H{Ot6@*^+OJ8!=YJI^~8 z8OCelA#S|!W}G>FhKA!ICV*N&)XN)KrmBL2ntM$EY`%vf4xm5*B;txe7E(xnfzavn zFgrbCB5W~K=ybXk0wIRl5Ph2VI43d@;kr{iscd0>9v}Mf$ME)ldK)fz+{HL?>;$fS;*)uGZN<9NQxur3WPce5 z7!Jo4gE-J&im!a_%eJ<@Vi{(=P7l*FQ&?SFr@6TqzT&DY>~q(AR`>7SWmTtxXME4o zxLbA0%F2O|l(U^)JWa9g=oi2AWh^Z%;Cavae#~y!LZABNzvKAvqRLz|A-_?X(F^)fNOi3#OZKb? z)>7pNtb_nT%LSQ;$gKn`PcjW0bPR3VT?mO199PZMVh}vRcD!)7#husjVuQ8$aD$bL zs@}g(DMp25UWj;klgRB^8a#m$*Z^tkA8qzju3mR62-Z4>dA$|h%#;hhbMPx<-Yc?{ zj84{;BnxPowBJo&wuVqSXy2J z0BqmA+m1bQ3`u>?y8NPx>53;@j=S!;TfXq+Yw>q){YRT$TtpDYbAI6aXk~c?{ayzj z`{+mLp$87y+}5p>#v_{BJ_j?xa4>LKB&Ug_1Yja^8O!3C)A+vc{XY30|LYIv%;|Z) z_A6iI#ieDt=dQak91g+6)ay-Qy4U4M6@v*J0_QnMBl5sa zc%~KrBC$5!!weayyEPuV=exM^t6u|%F%@gvedr*z_50|~&funp?!yzd&f*#W`DeIM z2?JI-`iW1YUR|<=sT9?4gY% z2CTYZ_nzNRW>C%Wi|$O1_8H{@khTrdBn+oanLY{^E2K&7DZYt?$)Z|V&22#xUvPP& z=pUEX?xQTmxTscW^1LwGWb2kaA{!opIH?eQEo2?3k3KO4L%L!JlUmL;0uoopnRy7TqwE<04seUKx9)c@oCn1X!}oYgpu&rMoEaW4n9cBL8$Y zZ+ogJ5J_5)9?Znin3;fz#6niC$vASLMxav<9zOIF0Cc)DE$5tbuCA`G=;5P>0RZoQ z=R2XM_OXwDST4NiV)Un{h|1XlF2-l1YL3y0h&Tky&>(@tiD71i8coJUa3JRPlT1v= zRjB-4%^5~Su?iNeP7q)C0c3%?I@;-Vn!4^Z z-EKYZ_j;+*snG3ot<&ph6>IeCj&-}0cKbE@y{`3oU7hN6^Hi^=yUX-@?RL@Y^sL*NYGS8{UVlpaQ~f+M-P76WDNOfznCkT~)$iqQw~v0mYu$d&`n_K6 z_WRcB_0a2etk>yUuiMR2Q(c{%n$EK`{WLc>-Aqr<>h#pKO;1fX{qA(r?{;#()6-tJ zgMPQCoo+`vonGoxbq=vs_JBR^Pxmu3?Y`!k&pmkCowxts?9^@)Vn2JR?^<`7*rio&Q8{_}$+RS3TvaSYKPF;cx&FkJbw!AQF<&3l+kFuox*% zNLmCC2aX8tWy*@|5P#wQGek(BF^a}O+U|mqrJ?{O;t&yBY=@kaDj7=<+O~BY*4H;| zINZSZfB$nqYV^l{{1zC%dv@=F0yuSQ-T)vnA+a}?A&ACM+h9GlRJ}2|t50Ca>hkK! z_oi%hr&FWX>&F-bryhF*qh^Gc|LBj}54_}uL6q=QulQ-~+P@Dk{^1wn=&_^7x#3FK zOpT1mt*4bFYlbt=3n9_Bn=a533Q03ymK7?Rjoj*wEGrSImK~`gLrJqCLy3Y|(oEyQ zIxVg&+Eq`zihlG*e#BOmmhtC*{g;6OM2U3Xo?UeC*a^&UtU@UBI4hc>y(*;^etiVl z8r9@AQb5?YWjn^rh+-5=DI?q1MuQP8EG-ZKTz=^jar>ROlQ83L|M-t+nnpkK=}+TZ z-}(ma-Mb6D?v#y@pt&i@qYbB&ET@d|cm!<{6llX%T^pIR0fgk9=ay3@O_{Q0O_q6_ zjGAU_qcnnz6G0oKoOwKMtVzaAZjhR6niQ%TNX}MIIU`$Q%NaQ(G}(|+atXW|nv}H3 zjf}?)ax;SF2AWi|Cd%0W&6X6R#e%{zoFNJY$hkyjO~^S@Gg74FzR;d{TH1HAVA+yt zCe;ke3Ze`@Db%tVBbz$|kRlr_dnTs4A{O3`Ul@fYZ6|n`nJJ80r^zNa7P!Xu|KJbO z)z@5&5B|%)AjA&;{ono-1HhTnr)+6)iMPzoNkBzG0x4+j;6sQ0wb$uDJu;ZAXfY>j zQz>T;w_p!52o*>WI$=;%-3V}H?gOHLRQ;)`Q}tB;aNVs=#8^K}&=XC{C!3t-hk5Km zt*Tn<_4}u~o$iUM?ww-7#z;vUQnNtg7((Je$|9)>frulEM6IGARAlYB%Ida;J~sw1 zBRGLjJ!3PQvPDNpvyaJ90ytJCfe@K2#B$zA)DVI>3s@ndU=j`Dsfn)Cix5u%RWn%h zgOQlXNW@dy!A4}p9;EEiI3ffQl}KDiF$vKEN7NEkDhI$r^blnUUQAg8L?N?8r!E9! z3BtszUWdJB6%nVKNhAU@F%{oO5D6Qb(*W6lB=X-il=g|U$Hfa#2<8g~c6%)m|K33m zM8Hx(IP#XcS;QbTTHnAUM-I_}{Ril`e(Mc5{@8K+(y#m)uDI$d+p%j0)M{awS$n0x|iCtx}%les>%J++x#Uvi%m)*g%ne+YfJnS-`)F#rcFg`A@;D80G1qGEbRbqyP5=2No z*CbX131`hQg;fiK2NfrjbS6Kch0q#?ld;bjKBR$Q2$Nv~WWu1bj3Y2LNpWEN&O5;v z0-$dmKE%gXR&dEwU-}Yhb!CwUr%uwj7hY()cJJiN_Uxxo9_GW#t9HT6Rx%JBKJ^%C zsj+Ql764JUY=tzyqil4|r#^vtrkAJs(*S@`vu+z{-Fn>~R0${7*Dz?tv^Nk=n9)1_ z{nOSFP%xuY_dj5x;Rc{7zv93D585Vzln0Pl;}ie>DcRHOaoy`;Wn~rT?LUBKeFJyh zbr-&UcizJX&OLzZzxow@@PUWy%U}L7n&Ad!woc)K^UkBSrB#~SwhdzsTz5xRO%x;o zq%<6k=;NRKv^{X|eN03uA~@%qb70wQd3gz!KK}7EHQncfhmX+Sz55_U_MGQE7Y1Z4 zN#|y;`S}F{5muJZ;63ktH)0j+SZ!IWKwuX*V7l5fv{-z9Yv3*d26?VCm;0|rUJS|xPg=J4e+#WiG zJ<7Qh^YVN9O{w_aI21M;<+f$3NjR%x&3j|N3EXl!OJ_ z`m=Oq;S6AAvs1Hp@|9Pi?nM3U)z{GW9ozAYr$3E8@cs|bGr#XS05LjKT@1%#{Pkb_ zH7Ep}eC#odnlbk8+=~;ZPW#wYzNdp+Fv^>6Cwg?Zd? z!wq!m)JXuq)-5yW^*X3KU7|{?Th&OpK^is|*u9Oas*~%wucJ|e7$fz%J%re`(23v} zwbSWg%a$$Zb~-GvLa*CFuUlDN)d(UKBvJ?!La0nYuD~@iZ~%qECiRDj)QCKDlv+)( z0BWS%Drw1^8pUvV4cA_KE$%+}5YF4Z2WQUAV=!39<96=G@r|Kc)8KD@{udE zKLdw9@*$p?nc=3>q0{SYytXz{>GW))Nw(fJranp+>9s#s-}{_r@qp5UI; zGZJ?9rm=InZ}*=(O(3&wh&mNI=up7knI5*(J&+kjqcKf~%H~(s397VbW~#YmdEOcY zLuBLfbI$p4(=@)wA$G6$;#Fk~s5oOm(56ItnF&Qg>BFUit+|zBQfdBJyeVUNCk{ce z%-*C_x6d1qdlr%uNoVnQZ2@{I%#uhG=D41feIRY|F3c1YDglRWxM!O?TWW}s=Lkt_ z;Zkf)+IpddbzVStDNKDT?2`;XRM2`wb4f}lpYOp;;!DZU26z;PNnxAV1ibc!-`VxW z)2qaHYq`Es7M-q6EupYx;8;{Z<-lmY#>r$Ntz;$yEl%eJQ50fWXcw%dDRo2CO&J;d zcc5?<^F`bbI;a)D!;*pF7YEuZ-(3_F_yV1_XvsQAf8FSaWQK%68bv|2CCPxhwtkM^2r1#<&^oA`Up`z<%96Hx-T@ zdyH3>S0O}r(T}{uR@c_)!G{jw@sEF!MiycSVjU?+Ffdz;Rq$rW<4+?+@-R|TQ#Md0 z=HTjH77LXp2M8EJL_s1VKya^hxbJ$Ub&TL3My9%DZVO_FcH-n|dgr^|$xMQud)3c_ zNO0wqSMp$EghP)$ECguHzKURCjdeY!s<6`OR4Y}tv)1o)PxX48mAbB$I-TxfZ>mRi zU00zB6r`?Lq!T&xE2+A@PPeXNHA})%L^4fAQ>NN)6#dn~+U&;0Xl8wNuzhuHef!GB z`tFt0jXldN%Li6gHukNrkEVyC(cH#puw!F9*fAKS9izc;`*5(nbubw0TwY$BTU}e- zwz#~uXJK{Wz{={{p0%~rJu3QfC*Pf<4i_`DpZux2*e371~AJCOH3xT z+@#UYjZw2LMoyi64^kpp>*K$^`c-C7KL5f40DvHY9)Hd`m|t4N!wV-6K^U9cD4gBHwQfQ`Wh4Tb|74aXQYV``cPO>Qu58Z>FFS+k`kLz`^PII&sA zC?$-?nZ`{+ni^zFqN>*95r)|?8aFl?jcGX8z;HOkxEavKV1tLF5k{jChJz8tqalW) z27}QEqh^HhXoNKOpF3_E&3WvTwkoNqrDT*-gRy2nvo%S{G{bTh%?&adz!I4fnkG?d zlyWAdCKD_H3Mewn2-%Wp&g|z20*XnmIaL?xtP~)dWy*jOvQn$)Ep2DfqB^sZT8qXq zCYdpNWCcvkfUIUIjj?n4c3kn~r{nGK{3k3f&EuDU<#ifkFamgCX#rC+GuX9zyAlaF z#I(4&{DP&GwY|L9egV89YQI6x>#HLZ?tl3iHaRX!}$|)PNS_YtSgLATstZd2eK^~{9 zNi8%vBWE+!22In*C}m6I2IEnKacX!xN@PiMYDU~>V$JG7w8@Y(hny6e47th3IniJ^ zMl)(?G#K&5c!cq&K^`~Sj7HR?L|GFo88ta+%2^eP)MPVNYO-QDXfPTLF&Yi9J{s|8 zIHKWjtb@UbHUMaP9=qCtQcg(YF=@_}Q$x8?O-+NO*#mP& zM&qVI%88q-oU&RPkEv-gG-=A3Y&=RBjmJDriBeA4nufAAY^I)#Rmhz==aMCpK!Gql zGphjG{RbbiDpvXKd+t&Ic+Ic87NfxkmtS@%=W(JKD=mPak+|I{GjTf~lW=x5oU}VqxJ8G@;XsVJB<~P|I2vatkz@!&RZ$7!vP&P2xBZ`g#$YtUldpU- zK)~Ai8fK@awW>SD67=-^;!jmoO_7nw5TRt!B9ysg?iBA|&YO&JU*;4`L@w66T6$b! zh!j;RnalCZ3@}+#6$>hFgt^?sg~-#gtjRoJj#0?^XW5*zjP}y2>%@262{&AVN15EV z3B38aR6t|2J-Ya%<-*!*J?tmG?Lg5v6O5(cB|OPnLu*z?1PhMEa9K2PQHn#P?QSPn zLTg#s5?B}ph)kAu25rgrn`G2b*rZ%~YAMSB<6_TKRImjB=VF=ZPJu0+1H8WXj>r&YDgkrC`3Ap<*#B;Mu$?db)8Mn^D_fj5O`(Aci2g_uh{ax7=nI?%QvVe&^Pl zds8_#Ss$-FU_oPs4aP#QefMKJ(dYY;AR& zM&pcJlz3)FYT6!{Esoj}iOoEkq#$2xPW3ROAP7~USXZcGM5rRFSQQ|>LKOpb`%{Rq zg2dXjGpy!OD{3rE9EFI2#i~YC*8~nF!c{CMSRRcq*jUHhmaW*jbq7{fR`8k6T!Xdc zb+8b>|9$VLss1$H^grK(2k*TP=bnE)w$07b%Hpyy6giuRei$%r8m&5gG8m3M_Nd)( z!`F3VZIulM34+U>_;^}eTGD`kCtvjx96ERqqjAESQ;Yci=RDhXZQtRPISE8C)7;pZ zg++=XVrgj^Z++|A>GDe-Z&yC`$@cKQ-^Kgi`#u~v_Z$pIN$|JOOa=|GFu!tE~*f(k*yND{YNMH3RJR%h(ocr3I&cNNSXhs zkaZ1kOYed`l5Se>N?ErUWCEabLBm~9?`&>sKQ_sJD@0oI;ASa!twW}*ji1-b5>DuZ zJ*C#guhiDEs4NAQi$9A8Y;&m}>>}G#(9O1;`u!B1k-}Ed$Q=}(!nObMUgZ4Hptp@94!lyHn%3FuQzJFe>T5ATK_j| zH|Gwzxj%I|fUO0W%08PM98zY#E--|WsWM90{`P3euQqk=_cK>Wsc|1oB_k^=~p}j|MG$NQ)(P^+O~Z+4jy_401&H4kH7R%Y~QxU zZut5)XlZ>7fBTlV;49aD4MdDfF1Y~BSkZ|!{^1|rhCA-M8(X$-qt)eA>(m|PK)kUr zFk)%fN7hP*%#4@?Pkzc%@sb~X2|eSf&#;rnPwJr~5A#F!9mJzYA5j3@@6TX%b_*b4 z{i-s6D4FW&(mI34RsF;?J=5nZ2Fj_iZtPlJbx7(+F$$^>q}%OUuh*w;r)zb$Lfz|X z6(g!TQWXQLI#?{eU(C)92;7=hkauU|CKT=o;mwtmXUB}xNCmKLYHS8gP2&5$dpCXa zhOc9~sD2Nn zg4^zgwed*TQ{(CtATyJw8n#T$V(avj{>2CXl>s0GgJ$^Jh9hR`8c_s~EH0RUsqWO; zue;i*D&F4hVY=JFP#Z-u?lReTPMjcO!oJxV`qbU`WEjF+uY28Gw_~T57C}5<4a(49B~dWa&0CxSk0rM3>H3rZMLIiSst#YreAvmux84=UU0mhD~^;>hNQA(#43WKannOhm2_ z0xLoZyfY$XrV<_rs(@rhEk-t^Rr5H(rTR0wfP)8uNnzQHF>oqG1-!orV{@rLQRQnkj6Wo(U* zN!MV#B9%g+M5(XIGy_zZ+pNTI{ReWd0xTpnc2f=xJ_RR+k*c{dgQATMZSR#_I)ios zf;n$Vn8@5Ynb>zWe%B@+<4{cH+zO2wycH4HWtu1p-YLC0*0+^|;uB`HKI5ZJL zRYk0Wot|=)HM%BW9!7KZ>9@EA&+x&QAMD->Tsv-BR9!ToH{{(;hk@PH+tO; zJ$m#A{`!CaMSAMfp2>Ax@xuH9NSG)%@g_I|V&*hv5@uF2a0o_jI8R{9Fff!Mq@>wR zdaSJ73TK-vkx@z~kV^xesBU@crqF?@vH&Cal@k_t>3s_iKF#&Ml-hGrU z%ra85bs}ultjB;H3Bg?70v59YMWN7e*cgl}AVufx7@u|PW+G;08o?ZZ zg;F%q3}v#y24bb8P!GaT%fw_*=ia)7aeHx{I*x3nY)WPmmsS>!fO1$1s%n;rIQXrQ zs6F(P5VM-8u@V}WSzCaS8M6?pS+?YsphirDrfCciGBPHktOOD>R#;{NB@4Orh+tB2 z?u$2c)Bq!7K#hsX11?F)j51ggLpW#8Dpk+7A~p3GdR22nc8`n)h*%+6HG|l)ss#>~ zFg8{ymBKhg@w<<{b&rIV@Z~9;O!WTY|m;c01>c;ATi71=< zqdzyCPiQ~s`&N=7ds;52!x8HJ;oj5%&-MY&Csj1P*(sDeraQd>Tsj2Uda?awc zF%QuT?RnciZ3@=B3C^|tu^t?Z%!~jkA$qNqh!rAvnbwP(oQ!>*FW7yHh_qi9;4=XX zXx-7cScRE+prw{TRFqQ$Y+y5}29#SKDE%YUz`>z`Oa#e37bv_x*7h_gUXTP7Yf8Tk zezf`DRTyLnmlCV@-{P&5i9~r$!VF{ju|LK4LOSYebXkkAZo4*RR9zKN{~Q~ zwMcdxf~aJ$6yOLxzbJebP`KLwT$t@2lY&jC6da^v%&~)FN_-Z{#k^1`!6;8KBc+xU zFP;_Wy<8#n5Pa2x&9wo$$uy{B*m0g%==d1nKU2syfqS$ET_L@hyB=98?@dc*El-Rw zK`0{?A|#uZ>z0dZ+JUr`K}pS?a>0dv{Dtp)=amh>H$MC*e)IdEna}M{(aE%-*Ij>; zz5ZukjXk?|>+<}9?3kId!zWMhv(Gu8ofv485*9Z$aA50pn_6D9m5mKUj1plwB*yw6 z^H)E24SwZUUt@pySAT9mMoz@JNuWTM8_==Q2>Z9p@s55EOUtYJt?RC%AO7{%@baDC zr6xC=hGPtv__@FL+t~Kr_v=bC=3&M7=1n)_M}OdXblr_N;HQ4(DcHMfFIEQ|cK-wS z;;uVx#dCk?hcu-zvs7LsCNLrrwPNn_xQS6NoDjbk99Fi-AgwD{lM!W%BpERV>vn4z z4QkCPaa~my#i%g_X+~m7%7G*+E9WLpvbG`_DvsKOhD{SvhJl%ytT2KG0ng4(>+;Gn zKX&}6UH^^i?K#hVF5P;|x9L6aeUJUpFaIKa`K#CBLm&H?J?ojzpf7yxbMS<6qbR`| zHENnMfm8!Cr)>Ps?|hG4dfCNz;Sc`^7=qoqc46!67Ft+bu-;S`J9q3r3{0I~#AC-# z&})D7b@-ou^1sM(&W<1}25ZZ7-vg`m#LF+C2kyTIANNN?OJ&DQ+T;7q@w8o@rdxmSU|-t=rfZ zETLG3W zD>esmCeoxbG<&d~dco(`tG8IS6e$=}k&d=LYtXVv^Z`_;Eto}iUqCKxB@cy(--fU{ zMph2vNw6W10EG7Q*uWWOBU3_H;X#0kQt*v{HY~3I;sPq$))tT}9A+b5OtgS38Ki_P zLJXFRzY(=5uW1=`<-`V zFdWd%o`YIK(hL?sV7BwlJuk1W zt;$We+=3Us=tpq=f%9r zoSBD`kq~RvLXxn_5k^1ogU`qFp8I{aXU8t|XZrMS|ME$G?8FIu;K6&5Q^O%v*tTUB zAVD2#q9DX9y1uc_nn#dcr3|7_bv5GqJrqu1?{2tk4%c58HE zq^hbZ#2PWy2vQLR1`87fLge6C0|aAnszLisms7^((L3*=QGd!EHv_m70cwf!)8lY!Kut&N=sQ2jfuzu-i-m z6o0~^Br%_~v;aXyI$<4qL+Ze)u@&p3k}BVx(A=sp{PQUnk3pZ?CQX>r*r+r~F3U8d z0`yzE`|{^a{4Z9R@Dn@rlKTK+1h_1yWw1LVUdu+bq*QaO?AhGDI`FkwFVM12s4Txg z;Hs#!001tBgqE7nvQEg_{af)`*Al|x&7v9m01~)ZMYVXLK?C_gQB*oI2`g2g3>yyW zTVaLx7{lg_AD6ruv>+`+I#C{3t70;zn79nLWp%ffFYo}@68;)YT`Fsv+v|4GKt>Sp zTUW~xg#{CaJ(nbHLnxky-u!CG$}zNi%683VrJ2A)t>fEqKQw(gT)wB4p~ufR%I1m# zS96t-REsPEN~%h|es8?6va);r%={HV(Ah0BJhx>F);88`aee_LhClwJH`!=7q=OG0 z#NGq@l@U4Fx*_>`NF`_>CW2a!097!8IM71|Rj6p-5Xf>)?pMJ+@PsatCdt82>4P)E{@*jPf9nOKLM{D zfs}-VBvygQMx-X$piMK_Z;j@qmDN<@1?X@7_HXsqU-ug+6XYNN@gMNU-+!ZCe)(ni z&EI$p$139V>3M6Kk#@TkXEhV2tCbW$fQ*>MhXrq4yrrbl&K0hP0Yt(;GPhlFNn-Mj z%qK)5%SH@RGeENoSprKisC%oj?-oVS4>eVFv}?a|Jza6-75KmhK7ikN&FicRLQjA8 zvjKp%@7je?)9@pY9LWGAaPWZ8Y%0v`&!(7VXwD|6X#}&yM$<0U9AX{A^vtx?q0+;L zA3}oSd!O|@y!utI%%jmL{PHjT3Z`ea$>T0MpVrpaKt&$R*%$4Z+&!I~FIn~)WTci! zSU^TcbU6d4Wic^>nv6_VWTS2vMC2l0V{>~IGgWmS0YD(lY~@f9O;pV# zGucmNBIh6!G+dO>?Z)7ksna$KdLJXxQn+AA%T=FdQkeDnQEBOs=MkEqMvsy5ek1`XPQMTf-nsZVk zQ(_@xgGkFy<1&tCxBMX(vy`=ZaeGxmCNl69jnril}{!C(?eOal>_ z5X4jssTpC*j-8mB-GX<$^BwrZH~$en{-J-t`4?VHkDZ>^y?eI9mfXzlfrAJC%QK(; zJ^yVm7_lmpLb36f znCn_99uAhFl17Ed#T7X}5rEYe~|&B`aG0VaJf#*Cr@-k7ng+ z7u=!*3_7dR%Mh#gy?J74Or`rQ6oA6I)Y9a-9c+NQ{-9)fw(NK9;s2dIT8yc< z1{hClBDe*^&9kx$u7Fi+;vp2&gUHM8#TB55UmodZ{0@UT04p_ef>K6(cgS6rgm?Y<=bw< z#+I$vaq)$~g_q(DFM2Wm_s?B}{QN8rhT475riz1Bfyz}2n(GEYQ`jWO`W<%9cvy| z4MY>FC_Ekoja5fd8XAHLlHVF)1Qw<-k%bs3#$ZiqNJU6AVVn$_#;~fky4S?K_IJF4p7pHn!CT+HarJMsVpW-#-z{tZk4Mosn@hED8+X&7mT3o9t$o)3Q;c4 zzfDMYPHyH2aOxasb+9^l4KQQJD&R6E&zkW2j0&-ELR=<)_BO*sd9xQc@o?v|C{{JJ znHWLXLrS9oSshE&7Hlb)HmKOc7iSTr5}L}sC?MyeI2mKJ-}k!T+EE#TmZnb2wgd1` z5Go*W`=nT5q`2pyOBJ;+ul==c(&ZiKvdNZllgF)-5k%-Lj*t0zcY>oAioQY%(ak|K zl9o&63CpnT2LTs`I2#-@@^H|}wwj%y)UsN6!us~$Qil2kZmlU=!de@MH)#O;AWk3z zC@6CQ(4~z>DxPRs*tF%C)na$yM`JPaH>j13OJVg|kzqJ5s08P=o?-=Hau%jdBphg$ zro@mKVND}|<-6~>`x)1K_Uhj=HT|IqN+NmV+EpsDn@kc8rm2} zI^^+i1m=if!lACvo9d#9jB%3?>zZ7S-WKA@I#o^GZjEm2AXXi!xTY%B8bY8d2E-8E z4ui=!Foh63;khg~6dwMmOh;M()Icl0T3p6=@4gFPyyo)| zGF*7z9J}YX+sLwEc5W75xbYjfd}dC5>COLxnq~}*Y`U<3bmS3?7S3R}zG|awyO6RW zlkrH^R)!5Fr^LAtlR6FhiYHx)V~-rc%6M3mhJutc0)P;soxfwN+;j9e5{P;x=y$r* zse;YMif8H$7S`9XG8iC|VNDZlj5A%bWiM_#ahyi5(ChSSVhJFmKRZjbm*efz}HiEzn;qtxQWjY8j+vg+w}`Q9JWn{CAfWx?7m4^gCN$qa$~@Y4dSqaAWs z;S`6$A8z4})@F+t(Ci9`yqOH{p|w8xSWyN5<=!E3k6kXEKsFC1Ldgy>hC+qONK}fI z0|S=H2mz{r)XjR6qc9g z?Qxe~&N(-jnd!r_VKg2ah>2RmNn{ftp@uD!8e2fgyn^ODnP!9|Ku}*a5Q~X3N!490Ed9EN)zJpAM5v8HnMxB| zB;bI%6O)3O%#7P!&JX%Y?Sfj)OlENCi(#7Fdn^d4nF*Mjbx{U;BNk!z66TMGqM1}!Z>H!P8>ga9BYFCDzFYQVfA9N6D@zb zaE4+sqY#*;`%~Z$t%?DGh1LfHY-|kCjE2;$IvA%$@4EkPnx2~Gt3UlQWF6Rj4;-WG zzIGjmf!XOEvU#SAM=Ash&I2Q17?oh^V!CfehBR(`|DcMT3<$oF;G)X$b4*AmlQKMG zd1MkQ1~Tb5jmv!nu(4&w3;e{+a4l^1fedP{?lFe366I`FrwdXdWdoW9W8W|{b1)*a zl(e{A7+KPyT`6vwq&6Nk zwOvo0K8gNJ7u&aO(T$C@Fdow=4Rd_x;fLS;)F(gr1x=HoMN}iD|MzE_M1mmaOsj+O z-nGT$KaAZ9Ne!Bk*4-{`o!L^)FD{MOR+o5vjk_$2>FF74>CeU(C>xl~G9NuEHGyg+ zkh%*XQcf}Dlq@TH{eD$aeXGvgp|iaEy|NrgC?I^|j=AO@Euuv#RN z;_yVA)rdJ5Y1!XW&SI=a6c|KCW>ngvYyel45R(M*ZG9% zMns9A&@6=Y^>v3)zAgkCo z6`iHAPHX|ZB`u0(Z+-}EM+GJ>d@^#fvpDwDYub1<5N)7N5yyBS~z_Z z3UGi)OMmHqSI$njv65?6a^X^0pwz=3%67r@2NMkm0y`1Q@|p5(cm4+`ExEzPZraP2%|1y-d{l%5`0 z$iM{jZW(4|MVlz@JU|MVGC25ql8hj2wvc+je9Moqc1h88nc~2gD_(PX{|jEyg754q zPbU94nRRklv-s~~io#|uSc;+Ly~5hLtjul+xeXiGoO!G$8YULN&QBu7u&(Qaqv3Gp zsqu&(K6X5R|K%6s@9(@Dr&dnWZTH-drye*@s&EVTY~KzQ*s3cvi47c=W_NeetGm z;#p6A8g97l4!Yo?OK|AOVO|{#aqDfjK7r<0y-=6)}pP6!c z0@qkvT);WceICB&DbK+B|Mk80zW2YEzWCKIV`*s-brmsc3@l6wi_5fa>kh1}uH)k$ z{WQJ)4X?*bU;4v%_q*PMFI@Xo`ITS#1(+@9eRqFXcRXiDICkPpnw#wfnBew1Zh!4( zufFC3Kl<{Qe0yVRZ^~(wFd&1 z*G>q5T&B;IOUOhke{X%$T~h7otA#Js%AJbWRQo6i3b0&|sx}D1r7>rPVxVjfTkc0; zjB0jJ#t$(?>o?vWrqoX5Fh78ck4zaW+=IC=OvAr%s;0+WI<0 z30PTOlI4|^a+AXosl30ox~}Q>-}v7!J2R!{oqIlyMnl|u<4ssvnzyfg?aP!?LT7pg zoqosaUQKh`=AfgD^^Fb7nu(&IlBgoW({o#}Wo8BjR}FW%U5nv@0iAAd|?ppj-&)6-UUI(*6g{g~dh3#T4Dg2km}ykO6M49_fO8I8$o z9rLRzLu2ah?e}h;?e^DKmN&q`46LwR3R(e9+k3o~mpZFE`!=%x+G1r1N^WZcErmZj zq=xJZKPwE~$-!ajURvZKnyyIM3=t*sW|Ir}t|ftki@$pdcvEgIt_omI>LssOTeVEQu_r~~rOW3tI&1Eoa{`PfAdmB;-JR z@sLMZ&RP-Ai@H?TYd1}ntptLoUkfWk5luK(evrHTjNF!o0M)`EEI}-8{W9SgwF0f8 zT(ZJ8bXIz{cDrjXWwTZV0WeWkXY?}^fy9VFiA@qk9b;^9cFWeI3-e3cjy(3ri$WC$ z3YndoiPQa_9(v#)K{LPOoo_dzgb#f1gBWE+e`*S+&zwOB6~O=rqHGpaVKEZ4@zgho z0mzw^Nd?LXY$Aa~&B!+?nwm6Gz=g=DLI*jkBqhWkXtE)O4s{}Q%ww#suh?LHK(F}e zpJwEo-tqQ-A^<#2iSB*y{`PJu=`)-R2oeNbf?re(rXXWNRt>Ae4Ff^UC>kj-Q5F(T z266FVj+7M?0#zX(iYRmBloNlMuX=fR|G426XDp*Sq=szc*56dyd|ED}NEHK$R}@UGJu1n{q-Uf=**J@vQ8+K#KornuMpXol?3O`h zO`=pn*9ojqB8x5`Y*qTCtvj>?sj?@57#H^M1g@Rm_>q^8#%HN)J&00JQG8}4wGgBi7-2s zp#-2o%5L7oq!?xt6(%c3lGFf=Wl$2VuCLm|hmO#vuDKdh-5!4BmtRZwAG}{!STEmy zK2?FR(YOG+N@7*PgxfnX5mAFJF5dECL7i??=vtaWjTg6@n5**5p`KAuz)rHXe_`#3Yd+ zATnWPG@P33%i-vdNC{Llv#h4d&3IUtJ_O`Oh%4wgK|xek5vInW$ntAyK_fLav%z4% z6XpvkEV%@hiI9|#h68HDv`hVFlK{eqOi4%M0c-a4ZKGM82OI%0(v&m?Az`Yhs-6)1B zvw=*Ls+oEOln^Mj+WzbXf(W4sxa>(!z!$H*7C-r|o9TO=`7Hadul{*{_q*Svi}Q=T z^}KD^x@9XKee5x27F!<Fu)Pw^ynq{(SZ>QzW`nWmu z0krfV@elg{xs7QuOP06MTFtkQRmDrs#~9zoa|Wv~LhP*XVv~R^r;t%0z5d6aWoNzS zqOzQ{A0Xw@v9vdx$yr~|lkcmdqYOoa*A+OW1VQv)&u z#|ltb;3&%g1v0yDd}*E0=DW47j%|dH<<`!ny{n4yUjQ-(m6(exiXA4C7F%$-aQR)O zeBVug9W8N%Py$yA&|LZ-UlO{D_IT>hCwibVSH}Us- ztSnI53_TJ8G*3ujzLY0)g21x>4y+7Sg=ecdi|Vqy2mb8NLl0c7K>qZ~y8e%+UllH5 z*uCrPxc&O;@XEKnRrkH`-Q3x^6Z_}3(7{tDY{%>tSG)`3v85Hha9_s0Eps@0`V@`a z0@9k?@FU0O@#&9!2+w@Z4`KVRy*P97IHr3Q#yQ()oM<)(EkgCw;sXENv#;WR_}mxl zeeeB%{MIKws5_@3t458{;iT!yo}e##%2V+E@7&5)Jnkxd=<7G*pT76`SX#IiVRSB@ z^UP=9UqA6tbUQWfxbt@GJ^vhZdVOqMbV28w7nO4Y_F&+(|mLW=( zG}CB2M5jBYJ9q771KZ&vhw<@`e-i)Ym9NBK{P~~J=f3o0``Mp;CH?O2{9b<3AODg3 z*vo&yZoTamI&%0349X2Lrl+TAJQ|bVHcGeMcB_5q3ty%m{DJRB=tLw{`o3pA3m^K( zNAct86fU;nMw(>wqEAMmTc{Hu89yWWl~F259)Kj{g4YHf`d&n#g3&h6pYiPN@c z_Z|}lfAGT}`sS9cTb^>|6R*5;s0jooPq6C5yi3hVy<~f zC#=Pys%i7@v=Di@V3SlbC9Ei`Tf&CV``P`=b4EnT$1{I>-Bgp%sv@b>A@3ob@SM@w zyOaf%v@hQ#I5P@9VZ>0&o63F)zC2AfIf=DcdNHAdEE_DNSlhTgcvfE$iWKzOTFl1V z3AGFk4CK}#hC!4ZS0>Lc49ab1AbvQg7E1vDoc!Xp`|wg6b@P&!EnyKzVv`wY#Z%Xc zw5e2nmlv2HE-;-~wHTF@Y%73VD=Ppdn`$epYvO0WXI8x98okUe!?&;AsvC#xZ) zgfkC6Y@_)_dStLcn3~1n#u_a*4LVi8!eHGRSND^^$mc-C#pj=oe(d10pZTl;(3&Nv z)4q@ZY@hC9b!`<3qXC0dL#%k)>>SB>j0^VdN92Iva9|swfepta?CN%;QM1QZ*G$Ga zfSE7dyYF4iuz_(dEP~Kd82ouE{^M2vbuAz_w-!ZWg&9IcD(NM{qH82ClyBFUhU zioid(q%xJ=8;bE1w?EgVnyu6|Ppq^G56&1A$Y&!e{1h_hN3=eGcRdfFD_QFL$`Fxlr+poU~@`nOl4pr8M^1=46!R1quW?QSY=01P4eapIcZz zEmOT!|Fof0eo5S=JS&JvBY{UC$}o*SUl92{VQZnP@X+B0f4&(v`|56YR7% z|MXAaLT~<~H{(}+?boQ=t8KV4a3&v0TAC180nM3NN>L(id0!q1uSG@)f)JZB75`Ia z2dmYJ2&oM5WWk?3aveROnjxj(Vs?2y02qsDRuUnryB)6T3dfEf$G5)qE&QK<_=o(` zm%dm4;MZUC>v-$i-wFVD?JxZr-trHBi|sRg%pZLWk1U*~UZ={I8yPhQ32d6wsuMc-Pk5divyP4|1(4tgWnCC6WH|t#7A`E;t{b{KO~l;g5Wh z&N*i<&e?Y^pa!V~{c767*CIg>1Eer7HB+ZkP0r1na+~LkSOpgudtjSEiOez?fDi=C z5kd+uNOMp(kSbAgXDvQMU}P%3@C{K2gbr%2=^3t!=m2TlAj1%2AT{rqg$ZfrC<&f$@x$Nzro_U$iH z6_Cd`FheZ|Qd3lB6wUH%PN{2_8dcCJC7WMd(v`JU{@&+2H~-SBe}V3~?`}SD?z#BP zr~h56{uJ%oxm!0zBOVXO00Q>x-NsF7(ChbYG#sMa>1th9WDpY~NDRC&8~|B$u(6KO zaL5#dx}7cnqou4!;{+mD zh(fXQ`!wfFC(bNb5T?-boq~V`#1yQqI%I$~DM5VGsL8UVlzpfr7#m~Mj8!O*2oS5l zNgb)q*_Z{&EMP}aQFS_0RS_Zq%tRY&8#ZnliyZJNN9vV6XSHU>j=akgBOL zlaUe$h*4R}nZ50CIJ^ZKnH>c&V;7wVA}Ex>@~|Xp6B~q_1S-=E8p`j{P)#gmBove)`LOc)~#F1tCz2gTX$^NZM$}UV*T;QUsD8$ z!=VDKUMiV0==naLSvt)PBAel;IkRV>S$&F(#t_puFsVsbVr1w8HL^{sm zr*Tp?<`yy?xi2~8b_fPE87SoRsEzDC{+@9jHdt2Qt-;DP!-l3S$wlE&N|+jlg+WQd zp-BKshImlE!}w5yE&DjhKpbG!ZVzy@ClTEqtBEZPkc_K9K;FY?O#L zG#Cg^6!=}z-LUOWb(lq>rbN3A9_C>$4li82f*;$q3pYOgD2~p|+F8#!!+!S2W9gie zPvsjn+^dmHia;PK(5t(c=?$=Y@nUR0cpwexfk@t{4jns)ZM%2ik^sEo#h2Sx|L1?u z8xE*dcBn@KH82-No9;h+z+QN82A8i{m%e=KkLX3${y;8#=Ua3bBM-VgtJ(r80{zyX zeO$l$>Q{ls+UO0txOdZ|c+HDnh;RMqXL!fkuf%aHR@<)KJ8=Jo2k4^bUy3Cw02^;N z%okh87C&P@sFSWbh_}8OX$NN{bSsE=k4}`AAFBq{?eD*wr$%012on)h>?mi*dQ_^ zsTmo4?u-A9kN?G=W4!8^BHHxgC3M;;r_pS04ljM#%kjvg58Fi-UqHY4{`cGe{n(%D z*6o|=mtOrE{`R-Oji@!MvIT`fhXZ@yq5JWgUwSPaIdl+z_YePozy9PWaOn$Ph|hfX zU-6+2{T_~6e?0ErxIr(x=sCP>=~CKo-v&MB+-EC6<*LtJb?cw}@&8$T(g`P~*||BB z;Ki|InsrrwK3y1Ydgq#?&kbK(lZ*%-$@p zxI*j<+h;hd7bNON4Dt!3WxN2(2wmeM3^jxN1+mHbWX>c;*Kjvmb}bT2ebZwK3v3;@^OKW{dfYf-k-S7s zBu7d8bu9dP^Y-O!FUQvyhNkeOVG1|4Ni!XNf6e3^8BOEohlS)oDT48_7OuVS`hVNA zsZQc5`E?>EvAKv&dZocIf4C@+F1YCUnc~~?(jeq#m zKl-ExBl9Kzv(+nC(sRx`pXTQ0bm#7!^z_r4?G0~w6V|L+9X4)!D8A(#SB7@k!lAnSTGhxTJ?KCrc)W#>qp{i(wkcdq@G(egSF!+VbFU4ige?D(~=pmeV!pXdA z$4=aJ_no$X|6x3_`EjbM3X_wQ3RR3xOmbC~==Xb?1~oI21#p88(M1!BxLp+%lQaCv zB52VnxGGDORjKW1Hl)E?`kvCbHkWreCLtX<}VHw!p0LLmqwR0Q@E0C_`w5Furd znwm>tWKR8NYlt5(BPAdy5iF{a@viOL^v>IF=j{g$<5kan9$M{Sw?4Fy)-PL4MH$em z2lg8;_+@HOPb1b5(IWLXZ&ls7gAVN6X+5r}C?y@9>q%n2FCOmpxmkWJ9|ajqm%re- z*t36c+VJp30l=XsP$ze-F$bJ9xfnBpo^@kQWQ2}Xm>wIm`4nya^5r~t7r?&QyicWW?F`5Yt}VWSzVD=MQ7l(f1qYDs^Hgi>i1Rx~?iLogOET?HLq(rF&)nH88s#gPNK4OA$4$r097{cUdQ~2mfjMvv~u@zNza-|b4BhE#@1Qc5s2FT^xUEKI{*pFv_NYI!PSxf{bYnK&jiyQ|vL5ze7BvVUu1TkZ*)kbZJ z!GJ~OI;Gl*z=4_TIx49Nm?1)pr0ByESlD6&0CYOzRNK(Se5u>DBX-||_u#jF`?sjo zYNOkovjigHV2uL{M$y<

?S}Dw-R;G8z=h3Bd#w*z)C(NP?O=j)?N3rC!iR?jiIK zcLEtSkzZCqBv44I1eh^_l14>RTC{vM4SVzUz=Inp)v90q%9rWvv(6D1^z;)?;K#Ra z#p>nD@#5#d2ovoJ1re4{FT-`W-DV0Zu z9vi1&92x+0dvjR1Yz6-1s((=e_-{V(w|HdJBlN~!eFNs_x=EukAjAbjIOGwcsSvXf zn<1I6r2zsZryluf(m+IN1|c&ug;0Pd5J@CZ;0QzpLJ&(Js~u&>RjY-=NA{qoDtzb< zeis3-=U?_bN~YEdLN9sN**Lgw7j_*vXvvfd5LnHI3#)6g1(Z5*7ABY&t=1UY?T#&) zo}it3_hEW!62rRY{f7=1h)GzCDbNKMKTqHH-uKW~zWQJE!4Lkfu3oba?N-UgKvYJ# zk4=JT8VqF+2gb%U9P|;*_kj=qAt;x^sWuoQf>aM7hqXdss9LQo?m$hzWNfNN zF%FZNiGR3#6^@o`pa>k*AVtuzqGV+kKMDy@Rh#S1Qm56%$`vcMD1^E*^C-&F3#BQ` z_oC3KuoQhR2+gzJocYWRs_c*`D6<6+)#T@P2?_kZt$^!Q^B^Vw&gAEy^BrP=wdg@jVO{oZAV4j#B{ z+2W-)s%U93*3nPz1tEfoFs#$^!Jyw#)jAIA>gcf<%*@Vezt_XfH{V#Cea?A0(H^tF zCH?p(H`1ABoo&6kOXKZv1ZGVN1}7sBMN4KWXK#p1EkO<33c*s2te6>)k}3yc_CrEo z7sOq#G^1pyhG49kna36r*d!H{ymA!gWta(OWgtosKwxDBk|RY4E>xN*D0*dq^br1!l0eJIO9=ej*Ef>+HICL9S_G!YPKQYZ%_C~+jK3#437mqWk+AR{JY zem}U0M0>xgQ{u@xF};nER7pdIOEZx_4hl9GOU#6^YWYffALx7mcOr6o2dr+Twj?E&C!CjNol$$oZ z?B)v0->@Sx@*_2vn*1@b+&?sm zIW(F`zOyGc1?FG?n#5>^;6LNcoy#@VGC3tDG2uyjce`=^v;Hyiu}5}NW}Ja%w=#-_ zM`i;TzZzqsxi|!FN}rqabR)!3)_fecV4B7L=5@mbC>N{JGrF?Oov7rb0^cw*zM-+3 zjs_A7@0b6X?6Pg{Ui!byFxigTtjQ3o0g(k0R33ULXH1SYNmf8bpvm0W$l`g2=85KJ zP~i8S#v|*fPZuklf#yFy$DZZ8DFb8?$1hv)z`dI{?L{vg_r$L4y64CddeLcT+SS{3 z*~42l+4ikl`RwPt2tT;}9zJ#TD!pUV7&9}*%8t(0J=T=4f94oYShfsfWm{(Jo(eqJ zoMObLN1w#LEnDsUv(Bcg<(o*cwp1#yfd{H68C(>aQ<6f z&r%2mv$K#+%Zda#@0VUGm#kWWn;yQ)&OP;Xy5^_X+ZX=yPw6Mq8}Rs!?Rde3&!zwQ z{x#V2@J2lK=tHPl7hp{zcwoqilRkT=n4Rf!-AM=HBu&!l7EQU=@Fz-G8d^ts~P}(L!T9?Ca!yZ zD<;NtYOF22>1EivZzulyf4+wQ`;m{@gAY6)pZ$NINq_Y>f5Bh><~Qv8v(Li!ufIN3 zRTT#PJ^-dcw`*fdmVlXUcJ?T#LVMjI|H(%_ihusse<4j|Ma6o~`RCBhH~gGWJM#?N z@W6xk$@M?RJKyszy6$^Fpc{X7Bi{So-@tLJ*V@i~J8=1BFQgl8x)D{`qCvlp2OoS8 zr<{J8ZF=ZY`tle5)8703_tAla2l1V6U29id@dmWV+w|n)kK*hzpN(gqbGAI^k{6^q z@4A&!ohCm0slVO$`Kvy6rncMYb-N(c8DpIdbkW>&oA1~L5AJ#vu>hGr({5NwnX~S? zs%3p;6tBu_rR80%fxxk3S6?H3r3L{mXmIEwaXP;^%Vt9lFd*Y!eFT>{n*+`FIBGgA zGk&XaT2suo1SkSH?->bA`izYnHI>N-O@Ey)p4rHpVSY$)G*~tEGmB)>T{6wXMFEk5 zjXeu#jnXr~le)^Lip*uHc$E`b#jvPIPHS5;myWja9=DIWf-AjNb7buD{(2Fj= z42O;!#V`)}(Z?T8MkFV!Ur&4X9l*I4o)<2@_#%sS!aaA~MVG$th4}Z+eGYRo$1vBO zM-Zk~YYdAfCJ>6!3%s4A%&IV9!Mon`J{&rF7$=^5Y9fK$bI;v4cJ!FtcH3DpUwK^sKx`omxMVg!wpj?LK7C!gSn zxq0lKn*mQuqc-5sd{^6L;2Mz!sn#^w$b2qWR3)DGoQv(|TW{q-T|?OURw1~dWvVJ| zNoS0nK77y-7yxxTZ4iT|7A>LncnkaX%wuw_Kw>Dfa`i_5mu~QGrva8sqhIs(DF!IXI@yrvj5Md6%m50M-(DRdz)abv7HPrRB0`PR&O9CSv-5KB$RRL*kN?GAL|JWVkC_e3I?077e%r`;Lc1U=|Klhl9Y#5bGMl;lL$D0;iY|*bs>b32;QY8G&udlEva0ZjGeMnxJNp zq9%ipvQcp7m{H>31|=jn{4nP-!aS%3$UOQ$YHGy6n8}bL1<9;?Whf;|DM5%dNI@xC zW)wS*v>6Psh!zg9MPNomc0|BfQ#2w`sS2hTVImZyutHdivdvNZm>OTKWvk%%xh`gA zkI}m0*5O@mf0uQKee6GQ02AXAuF<3fHx*Gfnq|v^G9`l#(Ah|xH>g6w$_6nbH8w-E z#)d{BB#z&qpu8~bA|sDu6PbAwn}vfVv%v0ah%o}mc+J|iICkWS-hJ0y{O2XDOM z3Jy|Y@1ET_=hAY@y{#mZCd1N2W?D zWJ!laq@+~Y; z8^)(5ZFXiBiIfUrh@;TST!5ow0I89L(EOa##LiHNUpyG!!!w45Rr_O zED_`mb@JTu&(WK1TAsisf_7)VUb>S50SB_k%G0&Izr0sVfBWYI4- z218()pC6#zDXiTdqdmKKS&Ta|F+NG-lPw$8iBw5_44!DT5ay|?DCf3FBWj#iAQ(mS zLTu#}Nf}@zg%}}eau+4B%kjy@UhmZ8+|T7_j--i-qM$Wv*W#}~`ANItO>gAi{LNoa z|NQ?xE!(zj!RDto$!VvaVcoeUbl~t|V-B))$L_1gs)ENLQh=ba%Nn|8Nr9#B>-Feh88b~ch5OW|y0@SFk zhb%;h(JZE#j~zJ*t^^`M3m52&govrMI@UOPs zUdja=UZR-{7Gt9EsY!&Qq=E=k1QZZci$o$()o3srSi94rAOeA~gn(!@>N=8ub~yp#|)_u}}mD_fF@ zq3StCV$N~`d{Rj!EUr9~k#HbIa!M|-856UgKbtsW1S=t>2#t|euUUiJZ@UHCcWuYI zwd?WQzx`YIx6gfE7Ee#x+u!n5Y~8jE4?ehI{LxL1e)81)$92&Te=| z6|xTHCdtex=7zH(8Bd!<>SoxGKX}TXCboP(Fw0EGoal9CaZWZ<&eUdXO~V@SK5X-^ zNpJ%qHJo)HDwxGQh{)Nx}h>6tHAs68nxE zq3KSGjt=I{06N<3VWvBW6_XQ~J<#Knu^Ixxf&E9YXWLV>dfghFzWyY8_~}h#nm{5L z#E7cb!-~!rZRpM5RlPY}Ha&%(Tzehf{qaAAty!g354kW_rbukCfBpMU(HU=j8?Bm{ zz@}|m=u6+c1}}fX3-H~WZ^Ij2@d})L+&X*msm*lXJ@??a6Hl^kcPUMD2xj7&CpFyX z91L^9RAYcMjAkz*(5MA4wObVp>H$(3Qdty;p^aAPV^9sOtsUz1dKStSMK~%@f{bQs zegHG5dX$L45Gf#`v?72^BZgLEP=l!3=ZWz#TeM`#j?Et6TYi2MzJAKd^ql8iXd54R zjKA=?FX;z=_qXZh+wb6u&pQW$lmIgf1_KyC$BrGvvgOM$7!J_y_0SGtU-JdFzfX zY8L7E^~dAs%};`f@%WRETWA-wc-bQS>}NO9si&WYSH0?G`2KZ2rkj3t6JGVpuhgP7 zMvp%JD9%0i0{!WYKf!TpSL4{>BRV(VJ@s!s_36L-gAe`QpU(H@A)$mu&CiPZ`UK>D z$OJ@buAjbEWQj$Qd)4xc)myETqm8nmne#mg96-o}Gs#0j)BHSU12O>OgcKWn%%2}O zoH)|Sm-C!{QP*EBv2)j5bA{bQc9z*>FJ-4k(!)m z=+77$LSYg>*+DkK6_RDcayEeHWimDEPhcNdHqPU$HwPliM4BurYu>za_qoG4@@~Z# zMT0y$Wg`*GMfz;#&wS%iwiR>H$RQ_#~)8A0jHmK8g_5rjRzlk zFne6tG{xrHjtkGe0G+afZCjr}ooehmu%9lu;6jK9I-Ry&am5u318%+LXE^7=3-$4h zkMP3}Z^R(gNSbV_GeMoQZR^&rqx&DcpPK0rD41Ea*Sz|dsMBiWu}x3lJ@0+DY~QlO zjvP5gd-m?Ptvj~pSf|ZJ2uZb;$;oLD2=$OT?4k^;~LT!#;37!_L$aaMs@}QB@oN0C!B=k zlT&ox-S^~!DgngW4#ZJ`MP&sk3A<@XRkThe^T6PIr-yVAYDH6M_{8ONbO!R|`uT%aTQ z5NCh}hNz96QKbOl%(YW-U_*XoV7~}6yZ}RC`OztSZf*%m?5`uo|BP&ew`yLOk4u}f z)VzD=%etaroae(^8_g)I8#g&EleqB+LMV8kqBo4BY)B%{N)FKtbSL&ytu zKr%&<5mKDjRy6COHc6iBBv+4K`PcUM$Ge(xsZsv>xf#VYqr`@9o_shtD&9!W)n-lE z`)>=ePGczi{cQ@DMumMj0_2r3zP`KZM4=8*%O~76uuv zy82H~o6iqr?tGrIi#k>;d*OYk>5ez`={uQ`DG3`&>Es%z`dMASRFJA@6$m_L0bxIRvvo(jlpYvd|P2 zlM@r*z*xF`8H@?fI{Vo+h&3?@3<^zAYK<87YeY}9G$>1`g3M|P513ML&h)iW{tOJWc)MP;dV9G>hBn2!b zF$PKrsAKYBpOMs1OLYxlmTtcXVX{uAL(7+~(79fhVP@@i$7+p!vSA;VRW>Ti_0pw0t0(h88=GZBM@pOzw}gV&qI;g*iP!kkSRlp-Bq*mQvF+(C z_|Z?U=imF#hwzpw-v$EXnybH#x4rwV81^F8ty+t}{DY6+$3MN1zx429*na2$I%R2( zJnd7Zq75JCWeg=~h z9o%u}-T1)!e*-Uk(M!;?X;;P-|-u%3k zMMZn}?!)Bx1csXE5C7ozo4>EIL_Wjwh2|tk3tx65g8&QF9-0>d%9!6K-vwG&jvcQ= zu%t?kFrx5Gi)}qj3cwLM9(y2n;~S9?Ng%?NWy_aIcfL!9j~vD7<5uah*<+{&^{|e^MGrsm=+`bj|AJQr5sf-5 zSpZ9n0zyPQuWA)2aU2f0mV&BQNkB^T{jP3#>S@08c^BIoUh{fKW%5$MINFIJ$|zoN1}PIa`*~ z@`u1X3E-v}cXwK&m-u@t!EX`CF=9$eqwp#Px9+ z`BDm~A{*!u48fB?{-Y6RAp4b>$(V`Evp)Ies*bWGD1(%Vi$s8c8B7#YP2vvbk=f78 zj3qeKLcF=t(R${sH)aqDOd+6Zm0C#fs~aN)E+j>-76yU3^K<@?A|RsH5K6A3Krz;) zRV!Cw(ZrNK@A=QCcBf6pjvVn_LddCPVhjWeFrv6M_93QCeo^4vS?^fM$O zBcBOzDnvuHrd^qgOq2;s?5O}^KXo{gO+apkHx{Ba1Y$}sOVk*}#wVuj``^2k-v5CQ z*eCz)Z}qSK=5J~4$YI?1^V`DZmtU41d2FNZ*tPr8XFcnzMMOA~wfxZ{LS}%HayILk z0I10kh}pQGnE#do=$#xrw7mJGv133_lzi!KF!x zFZ4b!E&O*w7NEt&eUhe_G@F7N{UBpah#WtuAdm8eRC2379#!TTVZ2 zwQbwGTgMhH<}%DvJ*c%;4|uLO)I}5H9F87Bs+;B{Lbo@MorjKM#mbfT(qFio9@+8) z;-E%V2<8znTWe|u<6dOkyK6fxT6G+*+Vp68{5#*Jb?GzpCZ8ZoT|0}P< zOR54lJ^X;JTe6I z*{Ga!bO^9UJM_;oHT}b0bKvnXPZ+A8Q?*bJYARVVXcs8!7DBg2byBoj9rVh+)pbdM zYfDs95lWOYL{x#HHf16mCV)wWh(cA7rUa$7FK+b^{lUOW2{bX;p=B#pV*8e@_^+>i z6@T`z|Ep&``%FCk*kj?_SAWx9cg34<^X+%YrI%f5Ge>7hf*{3&7;79kbXcpZq`F^o z9TVDP9en=tU&cROaI}4ZEw30uYTpL^?N_O z*4ovx)1t*oH4Qe;%j^xaz9U;sYP}ExhpZ7vSeN z+>D!Vy^UY_ikDglB|ZMslXSwmwc(rJxF-GbFaMJCy4`gD1NZ*H&wlo^Z@%ENOCOk- zJqCmXPHxb1Tx-gd3>UBi6sZO%xDKJ2rS1qRC!8b$Sb2mv@^NA_Tx{r${y^u9$>`qC zWT>5n1PKgF7$E`;!P6=_vMXkd2qU8<^6$;0!hBZA$&?%$Bh?I-0VrrrD={Re_?ZAC zca?_65~EEz;HS0WG22n)zf%Y#0Ky5QgFv`{2v6l~r=4CKjNa|m}mIAr4vC;*6! zn3Y#9%9s{ou%v}Dj%Ubt)`&!g45!Z$U8aI4X=;%d%xfI2k_*ZrX8-YVW zt18hS4&^WZ`Y$%JMO9+CZ^MHqTOB%f>~OmOz6a#UF>eFjyKgVuf8T>xyl4pq{XQlp zCowfWg|GhCm;9FID)Fe{Z~fZ!c*Te67W{Q5VbJM2SPP=yvvOf14_r=3JkZ{3Q+hmRP9s4QF79}I|u>_5Nq zW&Gg#*JH`llo1J@dg^f;KC~aV-FB;3GCOYF2|65fxhh*|6=HR&DW#@XA)(>`7!eC= z2!V~1*}N^fC`+n>z$`&nw9{&1e5}nAW8-L-15j>UKFu#5K&(2}Tp~HB~X=iG$+odPEJ$F5tDkSvQEMIj)zdxHXNS^D_EM{9CmZ>l}asCWr zAwt+pCD{*uVua|qQqbt>RG7#p;^QWd?2IrU{CTX;S70@DRFA3e6y~LMjXZ1Q!oEPg z8%stP{M^%!7h5Bc<|rkJCsHyB8KMZupjJ2ovWbwA>zJd_hNl-WI&C*|IOIbo@*3F; z<%mW|EzY7io8-eLWlosmO{5VT@&fDumjHJtFa$s%@j)9kcok|WQGQTo&Kp^NUtKNn z$DS7)93~5FL^B^YvStww?1-BTHckvQbw#7}4K*=T@5q4o;kBt3!|3OgIyCEO zGgxe#MA96tWfZM#hO47!C@_iykNzOM5ZIGN3n?VagHCr`H$#cUWPykb>Tz@hG!{i$ zpW5=&TQtRXsLDjFdeVvOsn_k=J@;>b8uWYDev8$VZoBn1OiWH-?YgzLXU}ew1%ufT zlYm*-Op-7`gp(05`)4ze5*u00z~`Y16$s{3N-`p5Mj|pca1f3$niN8)O+ht5k-)Ax zroci&2FH4k0tvWPqACj{QUn7Mkc62Ftq_=16WHmO3XKs8XP6@yh&d%~V0(afW%?(} z)J%cYN+~dlg&?HK+n$KTx#xN7j211X1dWM0MdkfoTC(%njTDL0$jDSfDV~((yrUZ^ zX|zR)reQG=kvIDi{5>@@QABIE+uqS^AP&K+0L&0$f^tGpl!|8g@VvP%AZ|mTejTk~ zLWhHqG)O5;mi(gb--NO$MJ19vJoK2o zAm4a7(`*$Gb{#~mF=}xxO<*(P#C}l}rI50~O2n3Gl=r59XqzI^geKCFNJ>3`;*-+dQq1;+B!a2OLHY`YKagZk6S z#Dzg35tG%?oRG?L!@>_3S9V2I0~{{sB_dw(MyICOxoy6Q8$dethN zeDW!n@6Mnsz49_K8DetHKmx%C!d^Ed#AIqIXO7V5!_3ln8S?otR~t#p{skh{=;5J2 zs>#b|JDmyi`tx}7(FbtfJ@+LL%loc;kJWukW1UWT?P+Jy_Fa2$|DpW=4AT^BXr7N) zSYsCS0Rbav)CACY)xwhL#h4yz;oy;@R1^g!$2z)o_f8UH?as_I0DHwtUP52{&#Ud4 zZ(U6@y*@gvF&*}YJTpIoPG<~7Sz*QU#kOe4BC5EhAftYFV4y@R*RHizSuz&|h{@WW z4hgZwp^|BjTAgu&DuuF5mXd-LRx716#N2$>k{XJlpiqhxAs`ejLQ1BjL?lQW!BUW= zh@>eo2dRex8rBgkehGFL5Toi8)(UM(X{f_`NF>3H2*l`gIw(rAQc6k*iHU>@#>{-z z0xVCS4OLN50VqjDGFH;DgNIR-1&xi38#G#7N4opI`|!SB`!&4lU02d&mtAUae#5WQ zWtU%S)%ZB(dtGG+j0208*%=bdNPYWM|GDePN(5pxGlE6W2ZNi8p^s;r+$&^eOlo8r z^Y9@-K?#;!IY9sxq7zOy!EXHdjkxh=H{wMve2G2h`Iq3%JMOV2b#$chg`v6m=n*lDIL$EGZ0{R4B!vF^MdxpiCk?svX}SHI@f^x*v)?3J&2CA#zTG(SI&qFr%-nC3WHSr*Wk zY&aZH(lla}24_B75CF_794w}oBQgw2mZx0F2J^$lSY;3hK>$_Cd%X6#-DXcSVPP`g z(IjL0*hO21Ltf#88bsI%i@jBrsSl`NSj;Q=$kY z?9Gzkconfm+`Gv!Fz9S9WZa4ohiSj^*z=5F#vY;NuyRC?*M>kbUd z4o}Oeco*}tIWXJx-KZ|3E;$m-q$~xoe_u-C{TuoB6C08l0uhocVD#y7u9Kc9vsIUsKdk-C?m#sUVrda4} z|N0;NvA4brwq#LuV*wCFEK7X$v!Au~?|C1cyzDsaJ$w*9y!lpKdf|Dv@$TE{xz9ci zYnQFW)~#Ey@t%7zy=a;`?G`2%FS4p?Ckdeda%(W)WlNMtoC`fcG20M{iII|jp3Ab- zvMMRXp%xOjDl4k0md3izMPRF1Ev|<{En9*51Gi!otu~4{MBO7}Q!-Yl(+#ZLC209LwB}o|MrE?>nHy16PTW!wmPXUUOX);manv! zhPd$j^Kt)%2kD6?pU^kI?X7gn?YCg-j;*}@xV1R6e;@9??*V+^*WSbb@R`pbkbqe1 zfd?O?lTSJov-8Jr)#pBsKlspx@Zy)f5I_3iPqhqzUi#9PqVD(c#M4{SrO$hQ_?OTA z>+pT=eGhAl#TWkL^EaJ-#_1=oSh4cpT(5`W{2WwVv=(d97M?JP8oayFFf!vIgRUi) z0!!8?8j*yFvI!9*)D*H0uIZbjyiq5xdlK`t%6s5^5GPO|+K9oIXq z^7GDFtH?`^~?fvM)Cx-VS+IjeizG( zD``Y6UtKL1Zc>i;{4chxdmhp3rsO@~nVaqpqK%3Nn`j9}g8+AFibrr7wpxQ3$imA= zye4OQiR1`ZW+gU-9gRTWOisuc2`;9MZd72OdKzQ&3weW5C}bqKW<@J6?wThgg8b`Q zM7O4NF<%rVPXkEuJjYcyumLQLWlNXgcYgPGe>9k#UjoqJA3pU@cE-u4f;7>-z5Ds- z!9&^`bUCJ|H{W^-RaFHEfkLamnP;4Z>#qMH`hyyyf1KiPt#+GU_L3K4W_AuokImr7 z%u!5@Pw?dG)mpQrSG?-gv~u-v-0KhQzPmTlTi*I++WPcny5+9hK+L*q*>WakEM2@5 zhmRh`<}I83GDE+O>11jdwaI zL&3dR>v*SwXhv3RGww3xK*T~E*vhix0D`8d7KGa%D++P9A2C{0n_BHQwK{EWl_fJ5 zkg^J$vW2oLsVWLCssKregazOL;Xvf2Sz^eOtBiv-x5Kh#=zq>yH2p9Z>qH9WE!#I^ z!-o5D?C?Rm^uh~dc4iiLJb0Ikwb~dfr?6xHPF%KfHOdt$kW!LC(j>cfS=hUex;4=q zkKBW*)uz6w9+^AFm6RHd?LcqPgebD^9BB38rE=!!r`e9}J7}ig^^Xk+KxC$%R=dK| zu}RE!hnO488-b*d(%PNMG(|pP^&0dK?6PeK4$+Z=2l1@)CwSlC1302dVMt?Agiw@w zI;HNO=|+?!NXU)S`7p=LkSwEHnn+?J?1}*zn!~G$sLXKk8umLpK3js?F1IWpMX`I0SLO=Qv8 zfPRl^Tx$o&e?EhO+HB} z4_ghw%#_R|83EA1Mn-If0m96QK>FyDPks>0D#SK6HiZ+8Kb{_Y^f57w7$0lN%H=C< zc4jtx>zmienP;7;DMrrDC(kc=6(=>OI)=OLd>9-AL6s6HH=wGFLzH9L!Lg$4?9<pkVo&BnnOb2yiHn zhRIl%dV?-K^~j@q{P8E~r~m1nq|<8C&K=wAqVq4r-a`isf#_wIJYU}b);HT1zH&AH z;MUtP(W+38*dPvQf(0o=4CC+_@H`l)5pys~%8hR&DQwBqq$Q2aWdIbmd(UnPp}_Zl z^aCAQl&}2fS8(mM-@`lJ`yLGDduUfJ8#H_`7>ZB;O=&Z`eiz({4kAC1B{xb?@E%fC zSZFe)?l3k&@)0VaASsxV*H*i2+sI7u-~$`*<~P3u6H|+1*zN1*zw$)_A)NQDbFe~0 zZ{PnI*Q%(%R5zbom~z7n%Xa`|X(Z(n-*Ib>qveYhW7zAZnYo@UUAfqf&CKB7p@SHv z$azEN8*jSFuK(#zpJ8##x0(fB^Z(zGPS5!FmM^f3g;}kQ{yRHfj8)V#4VDWs{PFV! z>%1xxnz-cXYf<4CC;z1kC3NA4yhm_UMC6-uKAtvn{RKwiXoF~Kq#AF(!sqPbh2i>) zJf^`vW<>*5;G~m|xAV?D54YcO3%&ehuSBokC#ME5k{K)|2C*^= zX;gBDYJSbhsKHEdR@GBerePk1%84cOekB80&b#Jtoo_LoFM^z3J!i$D3J zkK*QAF2hfLawC>5Sw{U{SD$?PDLL)bGic@VRl0M}9tev)y<_{oE?&Ci{7Q;Ah_Rhe zLqK&Xiv;GbB`X2eeqCF^1~pZ%a2@M<`|dr(rcIC8ul(|B!`0up1|Rvu59>ew`@ivb zzVj`-_O-u4Maeklq_cJVuAMX(MhXI|hY__UkP-@kNoavcNi9G%A!&59G7&;q5L6*x zPO31C27(P^VpB6n$_EigO{qp7lzYn~hpHfp3IJ$ZDCq$q^*^q*yRbw#HpY6f#YY3b*FWLWWkm;wlu% z5}k{<^FgHfGX+~vn&lG z@?c4>NAUhh5LilryN^v1GKK_>dhrRS8|p+FYr1Q#!A+&!D9#i$qSGFulp^l9`z}7| z#1rw)|NQs1e%&dU>(1f)XJ3e?wmoU>vZ|AkNGOtd_gUDnW7{8|dCE!O&px?qOf&Nm zRnBKy7u6flrdj5E7j&mIEaZNj+`&ZZl1YPe4sO;+L=baRpJvg7p;;_n=p!-$I3p?> z3_>13jC7HOM0oOXSyPuawfJ@G%o{X;@xu3Fjp&{!U>gGUcikmW`z>7Wo zT->zI`S+6ra0(DskQRRTVa`jZ->)cVNt8xWBS*nx-f%+(aP7hGEDhGGp#liydsX6Q zh4lZe1}^~44tOFYa?N8@I-1?{YHrAB-fy=;WE`mwNL}zBnRD_m!Ey>&a>AcIG~w>@ zn15d$5?E$CH*R)Ixr3^?D>kBiaAYMn0~kvAvlM*mlHl7=LX$LEFyLgYWmb0(pd*rj zflvfqdK0USXXn5JPo)!PkkA7CnYoxn2Jd!TC_&omMx2{1* ziI$HoqM_DWam7Tll#-&3O1(iJOUF7mFf$84kpO5M($<~3aQMhkTC;o=9e?sE*n9UO zHXB+cLQxF^Gaf5~?yiUQ@R6f<%eoWzGmk%j_uX(4R=xHY4GM}WDpTMT4QsD_hb{Z{ z573>P9>jSkoQSXAcmw|JvKQ%+sTKV6o_#p|q!X~`-u<}y-urOMS!ZCy%9U1(jdS3V zB}iVTM<*47k;f|iW(^RBTt1PBL$0GSGj}>I#Nkki5K)!|#yc$<)NPFsQWhnsV3tr= z(F!ye28gH?Wy?Z8QKAGELK@cAfHh#jqy$PeXh~2q(xKYi(PNCsNvvDH)*gOr#vXd; zLHgpCzRYjC@@@F(kAEuP{Q5WPoQp2NOJDv{{L?>v79aTa-^5Udj{Mac-CiG37B)38 zMT24A=DR(-^d+y9pWg5zo1B_th~R?r&!a~keZ*F+Swp+`?6dpsy_a78i?7g^zx6&Q9ho_5(ysXK4fokgUh;B!=iA!!^E$XQOlD3wD7> zBo8Hnn*-bnoe#Oqx@$o4qADMsC*+h4Bjf=pV*%^!PNxPz<6n=N!OkgjF+zPznuVmi z$eO>==I^4z-!(7t>Y`Jk=Iq<>&=o^o*j8ycOojPE(9WqnHGN@&`L_DkC=~vS5~@4EYN;ZM2Rs$p1S>v=&W|$~?*y^Yfg^|P@h3K++Z#&Ro=ErHez$DcumMa)t#%6+U34+- zfAC&Bym15m_di5JOfS0Z1z56ZF&^Et3B%zKDJG0{#&E*=6L87J7vbbnPvY8=-Fow_ z^qh+?0-MnV=Ut#06;oqV3?r;wz8pyhcx=;SSp#Hq;nM7~m%fPK`@VPMsVAO5Ux!#U zwHW>09F814#&_I%2f#*a)~==6S-gY@QuUY!fx*lqh4_Xq1rYhz?I&`o%k2#Ia0F{Uc?W)8HOIPTk$!WUf zwmb5nFCeBGrb<)oaV(#lz}o34JbmbZC4dTI8|#cy3F0MHg^F3{X6ESr%}?R9qQdHS zz+-#&0A?IQ5vnqz6ILz1D&~Vq6v}fb@p6ak3T_UimU)1F0P{<)KR{jzYFR&lF=EK4 zSPmJ3y3l6dl-D@&$O}X*V`Y4x)*Qfd3@;gsB}YE}8B=z!uw-0F4uHD5T=Rh`x4$%K zZO+9Ml%GSPg>}-oeSYBc+YEW^bEGRQL`KmxL^tko$f%#8Sr3f;aLb%+^OT+Bu5b8S z#I%69$*vqX=*Yq)WE6&xe2L5$7AA!3)M+AlJaU5Mm5C(xJ@{J8%_P7U6qDxA%J5 zSyIVCr4(ZEEefg`)2TkdQK&EzH-UR54H6*C2t*JP4Z>h1^BFvYC=d)O7%_oTRTaz< zAmYxzA_#&I$|9gBN-N633y+EdLBt9PkPuLapyZ&Ypjg*BtZQhDhNNbG`$AMjs9Ize zScItzg%+W77y}W4h)Qs`ys&sC$7BEbWJpPflcyxa5&b@4C73!okQfNw5UlE)LL-3? zQHdhY*Su%5VH+}7d}c<*$WdE%Y!*d=upkJLgo4x}@85rb?!EV3y!6GtfPeYyXSu8@ z`q)Q5jzxFlw&JTZt|GM^jC>e;gp-wfJ3G>}PVvPB0%+wG9 zjHAJfk|wZ_B{Loy>l9VHCGFM(0tIZ|_B5#~{_{&;MAdFnzt_j#|HI$Wh38*jX)pjZ z*&q%`$jhpPSV(*`F(xAj!0xLgu!=);9ZL@aF?)YAI6;XxF$)thNR5-PKk7r(e4Jzw zu$buX-FwlUnZ=)f{1Y$`&N$^n20+KHT!ktK9^Jc-w|D1_0S%z6P!WX%=Z7^XB@c`H zk~P+@XnJBAMJYDdo0UbA6PT_#wrl?$9`^c;|3gKAc2U{#R>#(kP1@S2MRv;K#dy}z zrF7Pc)#a)hfX%5VcKES>R3x=tv9WQlQ0TZ6<3Iqa_7eELtidC=n}~b1>%?T*^ZZ z6d9b@To=SZ0i*$B0YGV>U?72-uj~+JPywdEM5Q)RBn2~s$%xqrxkO+#8+F-Cjdf_U z-IAz=SH9{O(e2HpfB)j=Y2U70c;d+?Fg-D0AcI3S3>>@(wXse4@Y*s0l2nu+3}X^@ z(*&DkOtcp@`ZY;d$p0IsM6RC)A=0b>8w{GvG$j}mOBPStv6-Xz@BjLu6lI0~_`>G^ zfa+mw2lnqptKH&~1;m`x^yF>Zx4pY4%UXz%M{P6~#D@tu1}F)$lA1-U8N^)XhA2{{ z+wQ&vr=4~J%Cf{&pZjELlRbWULA`wHQ?`B}%bI91Jn2hnDJ^EY?U` ztEHMijDm?MMoa!jeMVC!t@}d^W2AZzsji0@3~SV}kGdYB9@ZH22iEO%x!awmes5j} z{Vv5p1fp@$gyA4UV{K^|(I50try4OCEDdNFqxO0|s)scV1~pA5&>#gBet$^4nK|lpd)A$uM|XDCx^uHO-|ZsSLmCXD6|EM^P*PQtRB~Y~ ztVW=~0YxF|J$`;j3~p2*W|3eZkG+!#yAza&h?$LvAuJ&A6sZXL$%*}R4kBV>;%pWP z&KNi5z{~-G3$TL9(gzWT4(`w^rUN?b%(H3h)+a<1G#u2_ znV3q##6?k1Q55KQ=PvH{x??dV&enHt1W!KYN~{EOq?C)XG@3CQ6IdLt0ZyZoVUrrq z>1wdBBT>K^b=aICUF_kERBTE}v!}%|CPZLyy}-}TTP^rVq}1e-+lBM^Mz*CZaLX+aF=El$So7kyi`zmab0y!8nlpp{?3p~Lu}NMr-Z2Bx zbw9sJ)~r8)*PMJJ;-HUZQ&TiFi+;*3bR=8IQDdqWZuQmAk}fECaf0)71x ze~o^>YsGjAV?~LteBdT*xox64;NQqO{uEWkjF>k4hPDjFXjv!ZO9L3wU&9%EDE5DwfK>+rqz-K8J;?cYhw z)7Tno+i7Q>ZqtjVXw|A!5DxUj<4?+~U;8Rsv+_9FyJs)8r9je1pZb?i_lH=ydwi6_zT_R_`&@0Y<~h!21G z59^apIEfXQsWqNpsK7&sg&ehn#G0^k>eWmCS@0J%?rl zfo9}VesJ?T-5|$(sq|;rt7~;3{W5x(@*-q;yr^y@lZdQGAg819SeKB82sY9p+_ac= zUVncZ?1=iJsniVI{W50;B^`-3l9F!#nxj;?#Q#XliN_W8-5GA{A3ELW=?l zAN3?dw1`mq_}j10{;ANKO@e<~Okq5V666qi<3J!XOE3}Pe(ZzPc=r>VvElCfaA4m- zoO$B$==KM=?(W+#Ruov;8OL>Z-H6}4>~cKsO|M6)Bh(P9*}0%KX!>(cRPq*} z+BjRl8P75@-8G`SWeknE^TdSRM#(&Kwlt|2*NF{M@6D6GFg7)^MqI%E@QK~B9F6Kyp)I7_kfXm-q-q+%Zex$HKkk>B~3|n zE~6DAsA?{v^)=I9W_I*Y%oFlvDQynL1Z4ZCJ97z|6rk)+SIV*9yq?3*pv2wR)(nLe z%&=(w{fc=>kr^N&iD3f;)moX5i!rqVZIBfui9Nk-%Nv-UBns%$W{L>vk= zHISM~0QLJ_0%|1n4pj${2*?}>P*w$L<1|tr#binbAt)syt<}^YP!J{cQVz*(Ij4d% zj3gK|5viK_)Y2>&jcmwfrbeool#?YAE|gTMDg`lG9#W-juq_ZR^Zk<#eCiCh^O=|M z(EP9^#D44cfj6lpD1q4#dd=c*#^?->l z0w#c|CsQE>Y3A9I<>(=VjLpbY^XJ_>i0rN^e|UmhgPUXs7ffRA`hqc{4sC2~oH&#? za`2d5cl}MgZpBJ`j1L2;heAT#Ki7?=cppZ%Q{k6|hrI?PtbA(Dwqow(8?xzR-+O-f8qi8T#l zioLQ3!2pQ_Y5}c8N<}bOWa9#JHe`wk%mqYLELr3ta7jc%DPY}h9<>VK1ywdI#aJUD z5*OkEk5M2{jg%C9CQx#LrN@jS6bSj8-SR43s*#vXLGyjoY#?H*I1m?=p(;#L&3zUv zO(m%JFi>zxPb4!PD$ge%2BG_A4`Ji{EG|6dM6}ne$5r<~Vb|RCGrH~8+i}yke^9*Q zjc>$De(}|~`Hs6#R1?&yf{_sQdP9u2N>kJ37~#u~ZIk@R7GCO=pB6Kq;23Lh6{5QX0~d z#nU?1>r$+1e&C@^vSNA}-uR2J#85u|mr3TromQH4Ms#mR)}&L~JHTlFUL;=AAo1h&a`N z5GiqC$r86a9Uup67QD7Od}2AZN1iEz!@dkG2A|+l5hcWo_He$Nw%nZ#Fnf1# zf>NG%5(#1)fU{XZyzxDYX$6Q$ix5C01_p&7Acd+AOw5S6EJ_Q^WWsP1uTDMfH7VZ$LOG82KpInIWZkn+S)j4YAn2mxR!1X3uV#M0=R#3Jn3fecg= zQfO(Q6u=3>g~#<1jM-5O;}hd_c_lAc*i^5flvsxY~F&i&N>a(<%1XPkkZ+jqpDZ@8;^e9O}xJ#EeU|J&C(P$Ki7M-2d`wU7(P35Fu`xmDd|9!G{YMRZ2g z$o%4FKpUko^RWYz&$6a|u5a=+34mn2qUJk(gL`$yI7V3_H&kW~fErVf-|;!m5}M(F z>jn9hST>YVcADq@HdBv!HZ0;Mk?K(;L;`U>XDtSx(A}_azwo znesHQi%KzLas)uK=4j=)LNH)4Km3|T4*teyz-UZHl-b6VzY0OgjhBRMHq5DBH=w#G zGn!37p}7YFKyadg0?AS~S1LHsNN}^1+;F8i2@Aj9 zSR{yO&crF&?IOi~AJ1C9=9Uc`A2>QQtQXy~>52O7=bc;r!upf2^|6hzWAjsS5D-o{ zel6Yf9Smk?QFhu`Iyp%*y&mR=eU!ygJ91=(mbNP!4EoehHKeXF-Z(oBDk`uxp<^@1#@c8~6SkzqN0-&8}HT<8fdZ z8%I$CQV_l1x88^Nrys%X8}7sFUh^jW*SEfgw_S0CzVlaqm9P5pSMZ9Lz66`EzZUmD z_yC^!yyp;X0N-cL`^>WjMk*fT&yrofist5U6L4cd_0B=kU}e>!R-F*zP|3zDjwRHC zdD1vgEn7S%T{MX#A%Sp7M)Ur;b9SXu$4IFx*>uRnqJHHs%-Yg1jfv_yVc*_;w06}B zJhpirgF4}>U;PsH?c2j|edFt}qjLb)eDmvg+uN?h>)-fR{`R%k*^&K+NzG7jusSL2 z+_4K11P#>b%U}5lUwGjqc>f1~g9wDNu?d`c)>&A$cAf6uw^yEg>>8xSd{h+HdC@3hdyweIJK#BO3OEJ4}b^un^R zh7p5m14x^475@NHE=kXZZ62+wlnc~znuhW^Wv(AL5F;JE76Zk6v}Xa}&t8-HfiH

&t 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

3G8+I4U^qT*G2LVk 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

?V6^#RV1uPL(XMOcl!pkWv@QA13p9AIdDCFw8X< z9ZBJ(YGDYUivD<43Q_oenJHh!YI$0!9bYT|vyLlPO!6hF*p{6tuOAAOb*eaNijdDT z81!;DQt6xu`{NXz8{#jR6@ z7R6Qop=4B5KE=%s@tH*1F$nY5asUzw6pMM7p+X45TyW3DtK|%tb6aI?))GO@F;*6V z9di!^PGPph^4&*Da5wK?2FYhQ%T;s^u%c5ct*7@qaNmEO%%R2DRVqMlkaPc2h}%+6>jCgyNKkc{!o ziLmVOF&7cZ7L=X|xh!|rYySSsS0-1|CB~-yF!5xxIB~x^614(L}GyC8!TKR2qtkdnX~nTlyj)!B0g_-VSsARkx_#|Rm{!v zV9YF;JKY3kZsz$c1yVtno95>lW=wFQGiSu1B1r-zXiS+o8z`C!VWX;uDn#-?K|LqF zQZmy(ssut{8U+kQrS4SFED;n66cVbux1j~qK~+qeF-F5px%+$H<=x-A6aW5&FZzpr z=p~qKp70A#-=+U_^);3Zw#8uYxbji>>&HLV-oN(_JnrUi;hx!)!Qr_aTC6e0@#)xS z-QjY6f-43!fIY&@9p=uI=$_}|2%+}ObPrZlHM5Q-a3)(^T9$LpI>&Cm<2DWk3;5{2 zek4_~=I{N^Z}U61-@(T{_HnW{Tz9Pmb-!noMh`(G8_UH#SCQrgTOAUE6Ui)t8eozq zK{;t7q(D3iRJjkFSy}?ryACj<*0O#i9_z>e<+WeE7Qgl@zlNoSCEoF!@8Bb!`jiV` zk6qf~FJD>oe?PIGUtT@#<=jjHJe%a6L8W(1Cm0vR?grcp2n$gUN5#6MO%BdPq=j%y z!N`Km(8@ZT>qd;ky#XVpCi<1>7KYti+fiV^LYB=q5#nkT8nM zQ4kpkI0QJ+fDI_ef-q8-O;z6%(XoJ2xJ}?`1aPVdLlF)GWu$_2b#8jbczLLlLSYMQ zqbLR-)&U-wZekJyUI%VYTm0f#XR)6J1Ha4}%n{h%*;gl49uS6RH8s zV@kBMnOt_`0O@7##Gu2|JIO3WjP#4Pd!byX!bP(RbsS}6kP`B_y10st{pbzy)K z5;S6QH^R9#ugNsA6EKV#dTMa)K#Rm=jCR5Ex@sVv~}GyFoo_$haHLu>~!I1`)~i zGx?yQo>*$bL_9b=G5h9dFu?MO-JPL08ys9*Ttrn>(7J+zNNR+M7Cc8V(cEO+mDDum zY}({a+n{Z%U~G*95G$1s17j5sqEezJiioI)M6p0Ml|T(5y%;E3F%fF5%fZ8k@%Se^ zR{#4O-pCMwJmnJaL`m=1YR(|61U%=XMNEM-mDAOjVvv;m+wZ+9n zKY0A;#2v$hUT?E)(}9%I2_a4pvPt+zi3wHLsTh(vgRmpbo7Vp zoGfWaW(P=d=O7EEbK_qz%1BPG!Udw)yw)XW844PuAZ;@?H{bWWE+Be2Z)ZDpL7H@z zh$1sF0GbVipp`p+=XlO{dkt0$D%qLBxqC8e4IM_eL$q|bgDyy(&4yZB^ene-WPv!Z zjfk4h*$cw@?^o@eU2*WocQ@%Tu?II;KB2rJil)glwEn_bKi^RvwEj|nUu4; zIZ!%d=6qphkzPVMhkHiL5Sm44Euw01d3q-ebr(o<0(yR(8Q0Kl`q?a0SdaO4WDaOL z)i+q)Tcgam&$*uybG;=OJ>&zCxkEI~hYZZ%RODy2<0luir)9gS6-20uKrG+UQV|gi zgi#7y7a-}5pu_P9kGuTJ-v`0ZJoJ#CyK}p&R6Rore)5{@eB8AD+)FRRxS2?zd8D#+ zaNIQ5x-jT&&j1}WOIYYH7zxxNq9SDq;5Yy9kKyaP43*nx7@8zCz&eG|4iepEQVgLTU^1uTR`gC(lPwsBWiecy5D)7Vd*QDjj zpNlIzUlGhCHJ1DNPCN57Dl7Tf*Z(){x$u1d;?-a9*4?2*+a{^%8h`Zm|IK4ZkNU6t z%CErD+84k0C4A;HpVhnXy_cak;KdhS!mZnuIT}wdTV~id}IJf_1))=xbOs3>G zdF%wLDl!4M8Uv5jMI7Wz#+cqB`?CDSK}ie{RqxF>l~bO_Bs65 zPyCxd_t{V9o^$tf^Btc~TX%}AuC4m*cizd1FTISn-S!c&VO4DXR+LW~> zJEe*MF6B*N!3D6iXL~NcAS@SRIG|<213QF^K#N#}45a|Pv^sb6q=EvVIZAm=dEgb@ zTB)9`!YoA`Bw%Kp6f_s7=FU{lT;=@r3xC(WV|2p``XFy8UVd4HN>qN~0P?J?#L3uk zYx2)p)|UdkM`nHH*P%$XQb>{!Hzc}H6Ru1iS&R3+ z?>(Qk)?{((7Qg!HFKTLA-yEHc2ag`&UEjZpcYXIxUU9{hxZ{rR;`5*T42;gj!4fXH z}Wy=!QPOif(BTe$uD9j(C?BLHc>V$mJ4q72r6`ao0Bq+sW z2yh4bgFa6?Z6}sjwgN(Kj)wTw_1{Q0e(QR3fn z)?V|vSK`^vcrMo0k3)qPg64=_o5#QIO_xfuPVSwLQ!>hkDLXVUoy>60J@?|i2Ohv| zZJm2gKNpk9M2{amVvo4wQrvmx?TCT?|NYb}P;K2Jv4tlJFdS#$o51w&K_6dx4UV)1 z87xDfY%C#az{aG(tZBgHgeN#Wu}v_zFZ7r3+$TRlzW4pRaBOp(Lh)W*r_`ccehinL zc{VRT?`*$m|6Ykw<@~ZJPT#f5kR0A5zvIY34ubFzyUvpD_}K3|emr+dQMK+@*Dd$^ zCsIn8u&iadFq@0qCRVx(y3~pl$0iD2PrBlIQ1g_MsSM^ycR<%PFY4KO02EewS$u_a zVYQ1zmc^v33!M`qFQ%4}6;KE) zMCX&p98N{q=rpU@B|4?W=usRbolx&3>eXR)=6@sIC899yt&75y^;Oxu75NX)L~{3t zXEmN4+$EnC3_^2-yNXIPP0irI!2>U`rX>NKyXSnIv3*zjzyo`A@4ov%Cw}Z@KVnrC zICia}WNALX3O<3Bpo%bF(>Vcw< zM{Qrf^6C0SS@AdCa6RAlz}|%9=o`utBuM7;%>6!f`I<`*d36q;&0ub3FsB<5H3<4u zUo=9RHhHW9>t3BvLGExBx%h$$cYwMN(R^>g4Ag);G z^XPPjhs>oSQv+xMtO8Ch#_B|BeVUB3Ad(_=tj-h=#&FqG)sY5nRt!zm3!A;FT35uO zlEX+{SL$l0B94Rx-naGgQclvr2crbKLra9Goa3fTyhVNl%=vCT?l zGgPt>gquoi1m(IY)>QMyiRh+MHY>_T07enq5OPD6YZ7czg_{{m<7<(!UWu>8U?*en z<3es|25r)@RAb zd0@t-nYo4vkK3{gC~V)xhX3B1e$5wGmiWdu{-S*5GoPktbP>UHHghY`f=px)T1uei z2qMkJXxVnd>?jtARFPyfQiz~=)A8h%+6HOXplN0un8HQ1n0pE?EwjfVFr+qNX>k#$ zam>b3e&VAaWkmGveEl0%i|CQVN3d_-Ls(c`v@OdkUIk5U>tSO!ymWCe=xK;!x0cBr zB5E@?X$e1>5+-noF<_u@(VpFX@PO~$w#1$NnjEfUXTQQNx7~#6zVdm8lRx|V*K)`9 zo%r5&zw2AKEFowGB-gr*sH&a}>b_{G5L6L+5&d4py6T}0Iccn_&=5q#soChCnKS_z zYnGYmR1FYFE*xcWh*Pov&Mbs0Rm4bvBnJsoQHvTSsK8ytj4n|{5%cU*6rzzq6+y&< z1Ox`HVvwlHDn=1iR#k9~N{YKOP=bn*9!0Irg`5!3APFIV9_n5NrMN`62D(xZgCY;4 zDKV&t3If%G29HqzfvEfAnxWn>L&MI!@i}5GiXQ*FMS@KkPTgu zAb@l=x`-&Wbj@_>&dw>#EIeS21t}K`vfBk&5Ev=9QaFnU-Q5|w>bU$l+2Y7K8UO_k z(m8v(Qq=re`GTO`$4C)eAdsYUeWSxp&WlUtPCzLJdO`AR;9+MR%qrI0faskJm6i9L zU@J#-?Gm0SwZ2`iqjVTc0<@w#6Uk2rR2d4HjfYvQkU0{!LoIaD1dI5h-Rmp8OVXu& zneT5I&6vBey!@fDdo#!dYU0BwkgtdDy zaP^Xc)N z*eBD5fm$4{c?d9dm*fTsf~7$X72<2R+=2h|=kLIUSx_&)zoK@P0-l=LFU;fQJ1aD`lyF>{bXj1|-;@5ube_)BgWqZ!!baTva-Sllf;gMJP zLk~O%o6K<5nWyC*4z$wwY!#Sf`&pEQMU=108C^DTEtc!4Pu+ zwfx~*f5*=|`!xK+KfK?qO|o-ht860S=#o;4|(F@8W zhY$1q2lx3|r=N~}dmobh2liw4={xPc?|Q#%+qn%N`rrpZfegnZcyjX=(xw?%_L|qe z>gP;TUVp~Z5h8nj##v|Jc|Z7Kte!ZDcAD@rKlRhFmiYXazKCZ({pr}hcOM_v`w)Kk zhhBgfYe>jE*3I>GhX{`yK8#~WPT=CpF1G*p;^%PLg%`OP+JF6*Pw>JkFUOue=cOBN zxPd3vPRiCT+xWMC^Ny-KIPo`r^R0I;E-j#{BQ)m1Z)GmzH3oF})=n2bMb`28ATYh_E*#upvr8Bcv``Fh0} z>Iof!fSxffMk@|=LfqzscP#e(PU)rz%=6OSp=|P|mS1dVm+DwN9hbdK@?b?L%Nj}% zRmvuj?_MQ}z|1!<-@O#7W;eTcpIc%;S^O#!Sm>$3z3w%Z&4Gm-l!bH0{BH-HKwcWW zyZ5xX*tPujJIDMSY12(zJLhC3*UzywLPb6tDnbw}E-zqt%a*~<|NPJ0Ii8F!))4*J zp@ZlxE!zHl`{m^7D(=7UL4Naw|HSUoPvdE4?80CC`8(|3fkT8F9(m;>vAMb7H{JYg z$-Ws8ck^V%s*3g_FMSzz>^dEH+;%%JyW(=(dh6}D<@Q_gs7E~xYbV$7{1^TpUiGS1 zy3o0{K4h=%WB0Dz*x1~}pw~n4L^x$-d5cvc$aFde-0{|5e+&Nmuly3ebL%bsv5$Y8 z8*A&h_|l89vUMBZ_1AxclWS|(wqrX+!%Z~pZ0?eF2YPixukK|$KvV_~toyZ9F|w*^ z4ElWx2K|&;6H!HPP*bR`6jr?&1U-ge8Y@v1qYLY*$Mw+|Cr+&S^70a1{v$8LFa7cx zd2($7cieFYW|J8n-1i{=`Y->AKl4*Rg~8$y37~1GP7Q8WRLUF-&ME}}OIa(Mj)x2+ zEG6vw-uLmDkA4D&_U*%Y7hQ~g-NT*t-G}A=BKMqrIzIH}fA@YxXoY+&&dU*PAyb{+1B3M?;S*wb`$b1XwQ-h1?rk5YCrx4B7OKr?s9a<`y@ ze03E!?|lg8ZrOp?zV;{m!&hI!Ywo&xVvd;T8$bA@r@SQg;#$+TaF)Vc4H=Ud}latz!&k*LK0El!rf?e5}M)5||y7nXH_L7(jPeL3h|G3o;6ZrmQ1* z7@EIF@>29mX7SIu=g-Tkt(leAp_k%I9})gqeHx{ z7YJ3uOesq@-FC|#yF;|9^r8zc(DTnb7oYs}r*w6=X|<~S%SS)Pg{2jL`yahcHrF?C z<~e8C#@f2T#p^+jZIc*6U>ySbg9`m#&+59z5F$jC)*8%O_r`>(9Q5nNdAN;CW`q-M zYC%F$n=GXkZEBd@!6s2dq{P6gicnRm1kn&t)tMbDrEWPWMFk0<(h@@zO%f36T0&0| zG)M^QfdQ&y&vLA z_t@`ODQb|Yfw8U`Bzg!cs+EVR%!kXYGVPTPVuku($)>ZVX zs@d-i(C_!Xsv>7i1M@^M<`p726Oth1=P1OW8a3CSse0Y-p^mlIRRuFgi^Sl83oBdj z<*!_a^<&5UFaOsc@TXt*bNQLN`2p;H{G(EUA_ekMD*lnnuaboY_z&ImO^n8p~|W;RJ}O74U$)QehI5!30| zw{6+N^Dnpvdk-G)lgE$ooqzK;{-PJZL`EAUJn@N7#Iv9E9A0?gd05{Z$+T&i+*w7X zn=`vjYpRGjMS>E^$zCt!P-AA}bI!ikfaG8mDnh`JSx2rhP#8*aw0lsYXvF4lU8)eU zZQGXg(Efw^@1Ol7zwpIt++&pAdi5*$wVQA82dJsX8~4w}d&( zl3B8pQc4EQQkyK9&no3QoGsZ-0iVHq>Mjl35`d`)8@id04U$jbo(P?pwNArWg(n~w zIxvJ`)5#IRF}zJq3|(vnN9*t@k|#K31RJ+xbhIJJ#NAp78&90TZ3dCXJsGG?5DrOB zD4Y_UD5W7e6>ut|8IzJ5q>TY?!qQCL8&Ia+wiI##(FTsO z10#1IB6%y2DcqvFr7Fgh%%o|PDZpAtOR%<_v!?<%zqg3h#{4VOu{@fB^TI;=t>H#U za9sbN-}c{r%Uk%&=llS_{^e_M>#cWsT}2YYwG$_?ZQB-VHsDZ%P^gQDt7^{cvShhL zC{aB~MU_bRgye3$SV`_T?aT!ZPl;|$GlMk^%@QmnG;N|a2?>sN)}l4zpdWBx-vQkG zotyBApZE#cvTcW(3$MNQ8Xr!E*t%t_^!p2JJxQ`;5J)mVebzR)tJjjLP|sRi!3e7Ij^hNww45kn^oHsMFgFURG5LLV*fns905%_j-Y%k-c7zRje6f zz@R_CpufPX*JH0&GlU3wUK=z+yh`1LLW0muC^1N^qjw#OgV*I(h{35MlEp|` zInx2gtbY*wg&wP_hY*znJVF^NMT}MUBZti5V@evTh>8kEVHGO}Rr;}#7<-IS7_=)< zRm2!Tsss(J>RN(k271&WEcxuz0##Kp)D;6=q>hYIc~FWA&`uj23>0R@3j&u zh=8pbV^GErIq3DVvb+U@evivb%h;Dc=2hw{X2KxGoH2WD2PmjvZ{5pR`sf5mFv2@9RU4!q^wp! z*Mo%BD#q0q;wC%|l$umSs~S@XViIUdO-g~&g}JIO-=u9G9zX`pm1Jml-++PErRuYJ zrn?86VukzMrb_wn(!Da*gjjxl7Fu?fVl65*y4;+i+{e12 z!1;U7-5rV%(lE!Z(9-AtTc z^X{{y4c4^)y5+Bp{5frInMWym2U^c~TX&>s;~Sf!G%{RvVtw^d?M&J$cI@;+8yjh8 ziH9~f@QACPmX6*1J$>-lQEtMZ<~}o#^>*glmlo(QXi|gombdV%-T-TxBQ)0df>zj^ zPT06Zhill;t8x3j2fI4N?uR4b9Ghcz-Q$J*0ryW=&%a;~9`%UF^6%dJ9v_dVG;f*AS=TiLK$BX%{kB{9f)~7yXYM&WYlOj}8vLBI z&*Z3S@SPiP#@Tz$La*xKTQ`0a7hQM}p8E8s;)5UjAYS^CAI6!doq_M)bq8lNV@LEE z4%d17M`=Z4}M5D zh9{Y3&C=${;q{NW^z!>A(4H03l; z(a+_nhpj_dC$WbSQs!>-ZYb+s*0h3I?FN(RzCIwQ&}n1B6b7kZdotU zGxv_|oa;=I1CEpz$>kc=LClhShw#9$zH{XJ_^;K65Xi`Ex z+?x-UmSlZ%9VBr2uHF6{zxP%gK6cE%dBb%WZVqwQ*=PINd-mXyANvIEyZ>J7*s;UC zouN$zGv=aG=7XTds+3SF2{8|OQchLZDtO(iTvS1KuX{BY7nV@>doYU4X05j=`Di-k z=H@0w>m!+^Mp}1EZR^c!f&=^Z62d zIm`DRKZxjVZ-2#q^@Tm>o3)L#0%0*0DQta5*QsOz?*erK&mNlSbRf*0c zkr|(HY7xwgy$*#ZbH~6u8fj7vrU|JC-(9bR84K6Eke##$@XS1~9D6DlluVW{4gh)B zv){dvG#@17!pt&o>xwr7^VAHzTYvH~G64V2;KB1kQW~aN7?S8daW24T{7!L_n3w2l zIe-^Kx^{3>I1**vJ0Zy2cA2-^m+z0l9xDfWrJgdjqnuWm4W|LfeH4}ttl2@6(>NK| zl7|cOFz3EMY`^HzrU1}N`QDvbB*Sm>_b+u~nUh|&AjSM^v9pR4GqZV~&}gEn1UjK+ zh>f=)*7f+tn{WN2*>on!&6gGyaQVfT*uK4c?c~}C(2S40>hV1L+;iO149Q^6{ekDE z>2M+>u(EB1+qZ1RmhCItx@`+$uMckpK`XE7h!`pi`U5O3En?U1U9xT4R&L$0)bx4- zRx$WsX%U0PfiDgQ=nV$wRee@fv??n43w@D^wA+T3fh%s0UF~y*$>j*)} zC?QJ>?&6kx0zuWQx}vp-E(r{TGI}r6KIr$+UmP&T2nKLzVc;SaBu|%-U7CcdLu<8A zQ8Wfr^}y>Yq+YMjx>q?wDN&`@SMLw{SX@}d(qI9-dO`ZVfomP}@2#Rpb~mCIt6Zq2 zK(Fet8q}x<6?=;VEG;eh((;loEG%%au)tpIF;-PtSy{%y$`&px4A8G?uVQU=Zvl&g z9{RmL7WxB75NN0vL-0Ul2mwI_J*hFMd#+W*UI?fb7Od{|P}LQCg8{3ml3rc;@|Gnm zEi70S5~`uX{Cmbxj5*dU-wuCl_~_(Rn0BSi|lEQwb2lN|Ng(n4?O*;_`=m+7>!`Hs*b@p?we?3#v z;&G3E3@*Ot5`XMtAB*+PA>GWXmE)-}b?O4)mjy!~=nHLX}5C z&_hvqxToQW1UV2zj){h2syv|*js)eQpn4<(9tx_5g5t1BI4FU~Rd6^+bwtV481#t5 za5N~6g;?zu;aY?oi7Llc^tcMwLzI&$SPvp60>g%xc_s0L(5Fo<-Zm3RL!%(T4YJlW zzAZ#39RD#MrKjxP8lF(q4uHuLfAv+bBh>sOpZS+`_uY56Lwv`!ZN9iTz~*>}S!(H) zQros@QY)!##VnP(Sb~cpMnwf$u8%SZ1EK^;mff==WFUzc3_{Omw1n0TO)@uc$<$gS zji+gY)Eb&JgPY^*bI-xr>bk$`m9Mp=;&1w`UjP7b>}w|e>KJiuP`|lNJT#oxLb7&e5WIAuhrP#+ z_>ceOPs8EzBgW{lu2J`bSN%SEy~_IiK0)zZ zYi#)psRg190V<-ZYp;7f_WKKMukIsMHG5SJ)gV=f?wZeufnusOr68z6GPs%4UBF*XosY{Iwe!lL zORXY{;o<@&?E-mO^es-qPB^4@_xplrEs6GG6hOz{c4j0>cVA%X2|`J|=FiuhW`%+C z`$JZ{t&nR9O(5HLi+P0wQPT@HIuV_v#514P4VLjV-MyxB(c~7dtQM6whg5`YMVvcd zS3N-1vPDRUJCU@A8=ftBA43RFc3oSUU!*5TRNZkcQ2$#B}r(kCE}>kb`A zi=nc<21XaZ_NJS8?D(PZm~+ns0W?i(;*Po(3~+ifG-*aS{K&>SmV^4~+qT$vI^(#R zQAOMV-2T8r_}ZZ;v#bRQo7H(Zzh z6gpunONb6npalHyn{Va_NQWQVk4rDO*l)k{)^y2*=cf}VPGWg^5pc(NH1v(tb=-gN z{eEQsA(+FO=`3GGJ5j92m!1p;sHFx0?i%v#@#x_rTv-~VKmI@eyX{J%1`B=v-ksmY z?YG^mZ~X6X}5aVAN+?8;m3aThy6)UdTJMeXq(v-b=~ug z(a85ccpnFgOSt}qZ=h`wwr}5-KL4dJV12a7r#|&5_}+KF@89{(%}|ZF{mxt3NNEAY zFMRonAHMOH?`&UMS!jDz4bdDp?h-;7tybcNAn&?yC(D_K+rtzcyG z$8+vk1(ND15f)j9o!{NN!5^&%*D@d4wg1%gsMs|nPXgxuDF(nSu6wEO zJQa%yWv-CGQW6HV^c?YV&yIJW@8jhcl4I0Ta1AUkvcu!&1>e9HVCizpHhq~-Y_p3L zc>$Bq&7?CPpfjecTLns(-U_dX~an-ku5{{!iv zeGll1pZ`KXw0EC>=JTKBWHRM>drrq`J5Eb?-+MPVH#hUc?*`99emwGuE98-ndW20! zQ;a4fUte9*Yp(sO^_Lc<-yZ-Z-tm9`482~D!^sT&x{tf>y`O*b_CI!jj3Ih6n~{L@ z`-^C&GnB=_KJbtK;Gq(J_MiWa-@W5|e9m*8>;1aNuYUO&eEgIDilv1W^m;WXvuXK* zF&7bP5X9`Tgtz-eJ-nsmXcYO+vHsRA=_yTV=z{exT5WH;~PG${4U19Wvui%e*V#q(EgAO`pZ2&Lc= zMQpV$c_F2!r*j|+Ppylk@H3TsUp^of3U(((OCB_3Zz$mb@a9y4B_C9PK*^{n%Y!WI zreXA4OoW_*$;(!^Se_cs=fjcV6n`%d1Wda&=Mw951524{_jFQpgAD<=}yr;?sW8Ae(LiykL#&+ zdV#{ra4_E|S&V00zkOa)gPwAYL(9|^UN+I}n9=fHld_`+Ad>}H04`p19t z4}avN^6i^%4U2;XpUsA8I-P;85_bpbDvHoNS=7{g%`WT=s`mi zmb5I?JvF2TKX&{$lfz?B2@(u|nI}nY@=!*>vIvVzH{#-5F5PCDD?lCN&a_wpm9uZDML#v`q`BO0TXQB*()|ZVZRE zvb-oxinl=P)_9v_<_+876r*-xJGXCFP-rtpvgAVZHYJ^or`C9bt;;K%nZaf)XRYP1 zOAxWPwKg?~u~rJvBGDQbYiG^0X@dX~>WHwpiBz0;nr{gyzaE2mbYD`pwpQ&v(`oEA*j(H62&(59#r$>RAohV3cXDU>Ta$?lNzYGFEjoRf;vqN0VWDLofwFlFYegJUVj1CfBiZz z1b_E?|3=zL>%aD^zsA{YiWk4+hgdV9iM7Y72c(%LrwAiLmF;>$5pO-Sh(RR6dsUAb zG=~aFPv&OUSEaiL?SbPs-U|d6zsIErJ zdZ3KWeJGGI1XBXjpt=f|sX!)FCOAwS=FC3);HHGB6QV9m(Tfi^TV*P6T$+}Wm4070 zdWI7cjd>umFGBMmm%&}#%p{1a$e7f8j7CzYh7pJJdmhCZ#;3)T-GV9#r0%Lrc=jqFG^}=ZRlrwp?`n0fgjqw z({_)Pw@gMlYYZ>jy_;X(`ydo9@A;R1v|s!mzryn#^(egH1uxRi|Hqf`bFY0>y5! z3R`P)P|8RwJDO=Sc#;sbolYkDh(|w)|9Rt$>Ej>$i2Ue}|ET}r@BUBx=5PO=A3J&+ zVq~l1kH%K_`q;X#BpVy+wmzP)t%8lH`m2je_J)(I z^0ju#r&c|!H`mghUQf<#8~^0L{tN!&6R*H?U;1La@^!E0wO{_S-+If9ykO5o><@a_ z*ccXvCUSbmbA5&}@1%XL1XMS1L27L_o6#mSI1H(6QTKYV^eO1gMB7Le!Hp1E(l3H;C2I)ZAS|U?u7dB2CkJ zN=DJ>n(~k^gwVwhT>x*IB!F0M49V<{?08N#Yh6;?mLsAurHBwBL#z>0Vac$ux#^S1 z)OPLOp+Is3Wq+{feOd}3DBUp{&zi%B4pcBfvKgjLas_?gfqlAf-+un~@BWTG?+2ev zCgFSE`A)v+H-FQeFcFtmy!7SXuPghV_r6yTudNA5y3m!-N5ar3IVB~DXiH~9QYELV zNIFs|iBTg=J9A5Rth)%{4yDdT+4p!k(D1H8bxbH8pDKPdaUbsl-nk+wQ`JBWe>Px;os^`RNrln*v%e-%?ByaN|JHb=O0YrIqrC(2Qsu-^u zAe0Di=lFyJEW$l_Dy7)yiuwsRs~>1VKQn zsr;Shc)NACVof-EY2~xulz4ojX}7ZOwS&5+HeAQX#wNy-279({<>qwegQ_P>$$T{> zZeLo$)~bh-qajp+Y^H?cvnkJATIRjSj`?spqlx63QB)oou9u{}1f2S-%6&-yXXZFL zaV*yZ-gV$GpK``o*mrW1U;5XN;}tJ|8I`4~(ovjr1l#1gbvu9P^2>SkZ8zckS-ZD$hRVSSLaaPMBw2z{bG{+b z7=j?9I{e$$f774%w5L!Qm4F5@|H_xImd8KosV*v*HZ$LQ|6Z=Iud`{Uq9NFHV?(CX znMo80q4vpm?CrvW?A*CS@4fH-REMas*Gs)-s^duy)A1O!L@qBZV>TUgGM>01IIp zta@>Om)MK5Xe=cvlh-+ARa(z^5Rn5kXgOY8&)xD=JzX<7t~D-%9}}%61n1By*DTnd4-!toVqEccOIoI zwt)&`n*|xed}EUC4V$;Gb{wz{$&!DOG8bKJ&M5PahrrGS%3}BLPzquGaYCCWtgj8_AO7hBUr^+?^sWc) zcX#)_4?c*EjZJCV#_qV|J973}=Nm-%&mZ|1*Vk9ExUhg-yLQRy>MHJi@cudfKUXG0 zPT#p3Pk+i&kXpy)XcGqx9mBm3+>NGfDI{KUy)1c39;Jx`wdoaf;9iQ~Ba_B(OGg%{YR7hfbdeB%cE z>qkEfw}ipc0JG@~Oc@PAF;{{yDqmDZK8B!9|b)ZDWSHAG?c+dMksK4}v zH{j&z2F}0eBK*&{z0KeJ>u*A=6z-{^S#SspjSC}4$8Y^qmQb&6VDHC2jf0gU?%aWP zZG$7UFmp=+IkvuT2Fppj&Q4q=PEu2Dy6=8WJ-GzM)`dlmCNr!I1}c*Ywhww3i{RYF zC2SciaeXpDY7@@dy$kf2FGi)q(!D2+%LU6T+s@-ts3^9dK_GlAF*E3??H<#NY@ zRq7_4-GD2*&HYpnP~mHpBM~~kI7&%q=X{5_+bak!V2}!9YD2kiWT&fzg`i>Nza8Jo&b*^nv%>Z!@R;iin4wJ>K0=5PJQdnI^WaO6-i7E3Sb38s@3OpD3 zXh|P+y%RY)nxMsMP6tv**)`;;xa$q>f*_8zsO2Kar9}b-yGmpxNpem z9Oi3q8UI64&Vy>_HOvJfP_(Uv(4T(o#&5oRmQsE0+2>(>;{>j}{0bgFdW`qqe?QE? zojZ2Opx5{5v`MF*aW-H73qQ|V6f4`ec{`oycrwLsG{ni(wYKi{!axH?<1zaEMG72k zYitJ%Pz8_yDY=YC>ri2$Xtd;LQ$ke->-85bh^PcXUG+gEZH?&F6(oxiMj9jpsbXz) ztRw-j5zt#2*kEaZ5UQAFvpl4*qySC0mB~P`fqTvbQG&N^{`ZzzZJL=cF7y#&U~38O z%pgJ;Zf-iATwYw}bU4K<&2qZKJfxJ^rex#EM5qO;iqtwBXA-}}&Bvuq-PH!Y`W7TwHdsTDYqx5;QOtOJ5p7;cU@YiEqA z81xpfymir=>4ej^L3DvDGupgqGnt4?szGBZ7@f7P3splPL_>ad%s6fGbK#!ypEX@V zto-QVLpB&JNN+Geuddx4Y`pQ&>LwYYZr!?q*<>af1L}T_jT1wr)cRyL;bd(nkG$$C z{KcRA2~I!vY(KHS%D?%A*N5N!r;p@Q8-QPz3U9vhQP?!#H}~CzkFT!E6!1Pkh42In z%OH9}4!yC_+%uA~%>WtzqAIQ`&H$)ai9~8r3Pv2=n2zJ5X?l~UZ3*!zL?84Qd@`Cu zfkR`(i_bX^2lgFA3$t%s|4mT|{?^}p3$OXw)p+)^o`Yk@4x?!rZ&Hq*HZwzv#LAWx zvyliHKy8tllrPgWcjRpcW-XJMB>-@`2qn#ui#VIsvcb&-s)7&$DFSbu$qn1KuGnZa zk~Ep{)?06}Yrgbp+<)MZ0g$);)^F={ID~?z2>#DYFUB2*9!Q^R+n@kufJT8osp?^z zTE8bXQ~*6Y^H&mq|ZBrN;7qlw5(zXkO1_`0H zwxn8r|H)$)toj)Raay1z;{7U}%f5o*by?AOl4pvtq``jKk#cC_&sD09&XFTg`&L z(2Zn>^yI+>T4}xEVrG(*=!tuRi-Z6McaTmqnwoj-hT!xb-5Lj*OknflAo@{hZSsZG zwtYm^0EH;LZh;L?IO455W^o0FR!{h!KJWnl;nA1-wQDDM!{*FScq5N_;uGxf>Z-oy z10TfprM`ds!yo3E=bZ14c;w~oKE`x5r81*j0K!sh?%-gd2UgLiO~ZaYkY2B!2e~fp z;x^vg6pBJY%*rW2h0@F%)ER=1qiI5$9BMAJa&~E_Gdh6fg@rJkHHaakM?d1x`i~#} zu)XxBoSV_Ii5yIN=T3mhtNcPvZZ3<&Wd**IdU- zuDU9{<2~=w7yrOBaqoQ(;(5=04(_<)c1&k&PLd|$a54t0B}CmVNvvw*Ez}St(%@{H zDU1PPz+kbTeFh>>RU}VnW(jbxu6uAdw9^R^sL5sqSBX7^wSXw43K3145MuCNRR`Bx z3YwahNbshafGP|s1VXj|&?pj|G^u+7M2()TrMqJ`onqEBs8p#{h3RbSq@s=yttA5x zLWmGy5)oY<3?MO5958W~vI(>)v27YGEG_0!jS_+C3}BRs$<2+%>1b+}Ohg0vy~?e? zq*Wu#9mkIx!gxAH-Csa24lr#-0!w*gO3C{DnzLz(x(Wy}ay*%!Z4J}umE;ULO~qbFLjYb{q{b0x%;m>DTpI zRaXy^+>oHhNlt~B1(k6OGK?XNMPwvFr$KcVgsrJg5ZDUERM;wWB&nN@Q{2k}F1i6^ zeyEpX9@0iE$r%#cc7lbIG1 zPZ8s-6Z@s;7DamiQOFs9Sw=4ehb4hXE->lLIUR{0ciU+h2owQ(e)BBo7U^d7Hc#^s znuX@h^{s_cAS|3>z@&m$o6BU2!@Dyu`kb=^oB~E5n|mw^VP2fy`96sG{YN|x-le;9 z`n(YjB8BaqO3A3Vr;L|g43q$1mNBK7Us}?^j&_a^E=U}DVMQpE36|r}S>!i|YJUGr zQXVvD>5eJn1BZboIAhng$!XiS{r$m1hu-*a_uPdoiz_xgeoX5a@U8FO;ZJn8lvZ~`nY(mmy4N#d;f!S`pzBx(EbPH5m!A1hY#)ZLkAB_e`(3@xbwSQ+_DvqecWT&vc+tc ze0i}Cc8DR#`T&XaiI09#f8@u1#I)o3YlDyc!@uB%f9&N@iB3Uk##7#Z?>zz$43-9H zQtO+ep->48QPh%$7&)1axW2K5?YnmRiS;!-dF;3^Ep3s7g$1Oh!Ljie9$>K&^m+>z zPa1ZKrpA+#q*g$1Ve5j;=~z~(8dY7h8P9C*{rAhlLLX`vGtWE?&wS=H@x?EH86W!4Kk|hyelh?4y&u4qZCm_JZ~j&O!q5F2hSQl( zr>*yTQ75yh-SOQ!`HW{g!!0%P&2N6gp82$A;D#IiQ!anhqw$0%JOK~fd%xdw&DZ4_ zFLHqg-%k_ON+h^1SfSW1)gG>voO2~iBla9GICZP$I+ zA-nT*O@Nf6VaiRfM0vb;-)YE;Cpu%doLUTvlx2>>CbxMJo#%H0$XLECR%bgv zo;*k@?6h)C)a-KaCXCteny0kN&TZfQwsg)Qo6``A)+3^GhL@p~6VfuOLTt`zDz=A!0b*WJ+zKsNQnhZAfjCKJ@n=(xZou;rY*do_znV zyYP{Zeaw%YJi*<&cVm`j4!5GyC1%=1^r%&Cv-Ctj5yUKjB2=ox)T?XJ5G^Cp3<$8r zrA4Xg3hw4XqX=Qb;2Ls+h-#EjR~|xzkO{mlBHp%%A;fIca6S)2M zI{*mks>1PON3mmZ2{W5w=b7jE-+b_Ic@d+&>4jey$2ag;!QI#DlTUj9h5%vRD zUMa(4M|{`P5|552-n0#GJaotpZjPLySXo{s99-$u`0mEKfZ&^+_ZDa`diXM!Yy6V1#Qak<0$A90v+{DCJrtA0)uT zDW`{K7GaK~6(&~p>~>30j(IwAaVJuV)0L=>6i;^<+~vt+M$Cv7rgpwKKl(At^o^C6h!fS!jlsSFYf zsl;pZL0i#lSUT!R41<&Kqy~wj0bfi2T6wpKm|#gU@%6EOZ`7LDgs9U3p^B{q5ra|3787 zcL5m7JtCDq=TiRyH}hO_$^YkM%;a!&lbI1p%QF~AN|xw=gb*G zJ9W1K%SppLU;c6m*U8QikpJ`zK$uJ?NV5b9f*?vtC{!hfyD^5~26J-<+MEw}(A-*j zZnhCIy5~Kg$(#gIneMZ$d!U;eg-nhXCgy0B2zlKh28Bcv0_CD|sCbJP%mKUu_Nt;QF zNizk+Fx#BTG|kF+(2$xIZJRt+ks(y2!fIoFuohHgkm4hGe! zAn(OOXEL$;cj)TLL8Uv~ljOBFng|76E(l6ka;ms`M3=~Qf~|{@QYptt0%0jvcn1W} z?s{=hTv8h>h|{|)CTO6AY+~1d4R;2S7{pBx#Q`OghZYpNr4~{P5rMYvDq~OV(S0$w zb>|9K3l`D#oW5v@wTSt+^_*ch=zW_b|B+q0ar=0~Zk~?xuFWxDzUM;p?z|J9Zp=2P z4d3-g|2O^W@4r=k>Gi*ezx=y*V{JU*(beOyw#hiA7>q(8D_0SQntbSiy=dLAIUd8^ zu(YrQck}6FqM?fD*L|3oOC+b`iMIrU2a32sR3?+D3&CEmqEo$@&Dgf)DK&r?7VEz6 z+P)K~owZw!96n)p-*=DxkKg#M^hdw<`}pAB|2?m`>{2}N-~)WZ6P|&|Y zjD~AIna+aQY}6)5FIJjnGo*fvL9G0Ens9kG^J`LzFAY!1PoKGif3|NwzC9h=QzXdC zcb?XMe&e{F4&dO%6u000U0iw9Rq9I%{(%pFlwbYwe{f}S3t#j4*Q04$Pi7>=o7s$$ z*)$IsXEU62#x8GLFf~)ug8`L_S=&OHWy009RrKo`b&LfSD9{)Ta0x2h*x0nSwKZv) z8QQj$S(CRY4f#A+g=o`e?8D8WCUX~xYmj1A0Cw-*?&IN@(>8$uYiA8aqt{Vs5Z7dM z7|bm99_90+F;DJ%VQ~@D@rX?_uPD}9OEXGURbrqwX$Ha>H9$aj3Mn1VK`@BJ|~hN*2qjqSqHqV(zto{So!S5Y8PqpGyYyjKNG zW)u0Vf5~&6?Yp;b#m7GTZ#=fKPGN8*U4%YsX0{OfeDY;iw71@O zuN@k$62u6OwjZmLb&Lm@t2~BEA3|g#@R>^3RFO>)PJ+r*DYKwDC1o1b5mcrsoROYL zPdQ{SrxKXrKvGb%5G=0Ha!zL#LrfVr!jh^4k<+EAU>H3Mt$BURl1w%^=L%t=LzMYU zT1>|#mJ{ejNzQ9_G1qm*nvzUU1R_gUQOY_~c3kJKBo?zrha90j%tcww++80OJ8eKp zca(IUK>$P%N>Wqi+;oMv*^tyZ=^-Uo(*;&@>t;cb6g@U>d~S4uDv;cYecQ^JH=7GPlaaYW@|g!k;3+)xg6NqSg%(0`>1<*;Wuoea z1jbXsTplJ6q5B!j=d;}7vI>%sE+}TOxy&XGPx)^k75=(-my*qQII(iSVliHMF^*ZA z?<1atzce?Irt&(nj)mfuH9eJdFbBpkT)69uzd3m5@Xznt+~{9*;f3vyjWv64?Wlg} z)1R_q_uWTnjXQb+UUl|4GMi1Ye|^Jm-TM$BR3*Ftp<06iQH}0CVOO}=TAPB1D#em_ zwyybqwR3ZY~O)>>+3kOwvjHq^m6{;=RPan`oyR3n4kP{_+;kQppX16nzt#z z47}v=kHw{1w&C6X`p^7@ANwhM>)YS-3op7*hT{=N!=bM%FZ0mBLpXa-W9`_Q-+%x8 zJo}upu=}*rvcf1jcYwgv9@@K~=bU#=w$0_>GynAMe~LH!@*7O4B$6j!*n{c@p$OVD=XTzEjNc7c<`RRSXx^0?c26vI+^n1 z$&S=oZswbcZ*5G9~VEq?r`egf-1^iq#? z#lQ+KiB!e&U;F~>-Tx52e(kk9_nZrG*=759`)#-5jNPZ%o^gJ1d8 zH~Am@(H}VgPNp;T>mJuPH+lCx_xWQV_ZYwTzWey?n{UGQ9ozBo4}Z+gI^#@v*^j;) zpZvrpaqfNh@%#%f@%Oy{z3qoS`eB`nCw|WZ_r2;L{^>*i`r6mL`ZEU(O!DJjkhRGj zU4FjnYH;IR)5t52lr##^f`!cCS?-YlcnfodmXt|mb)>Q;b_xFOxh_kvoLW=eG+$7Q zvD*?#sdRaEt)%tKu+YrsGzF2YDVgMTMud=pVKU~_eA3Q@*_k`DW@V>Tol?Y_k$_g# zp!}$J>JJbe?%I}Ou}9|w_Z-(r9h2N_9{AtNM?u>Mzly>N|xtuLU5S!n; zOB=Ix!w+P>0gI&AiRdh%NGC6N*{r-oi0Fon_o z@t8}QUuPeu=c1nC%4AtMJ6meURi3v^cOrXn@g~a~jViHg`*wW&`u}|DeGfkHd;#0- zJ5LM$>utYp&1~ie_Z`G+I>pJ8C-kP9zipRYe3=|Qcof%M`(>UudDONoZ$p1^LGHir zer$|3%N}Dn&?fL_KJ6Je>x?t8dUDO%Hpz5zga;qE*LsT!G8puI+wuzE`a8dkuD($b zdGyc$yzhhWHUQE#Er+uiVD7PB(E&`X1t9+ZzkR>;`!zoH(SMcezj2*E@u^S3rB__a zx4z|faO>^2aLbmhfD_iF0(&qT@_QYkQt}QaVp=c}A~8l64TZ(qLySRE(|QOMRmtt! zcCa;rNT6sytfHtOnNb3f`gM(de;^`&h**eGRK!$+sD>nPaWRA#u&_8F4DKN%k*Gia z-(K&pd;QPKMd$Ca`}ZB-qaX8Vd-YHLw7mBp-iw^nvjmEyvt({nx<&*22eE#2YVzCbn zwnLg3MsRL4t!q_bb+`$Gxsc+Xt8dKnYEi{X4jn%Mg0g#giDzx!=BvXokFK4N9lgpn z>d2c89K^BFn0FjJh=ZH!T$?oj!3U2Xv-A3W(Lo>A-uD0>fBuC=H@x$!Uu6*ZY`p0J z^wAez{H9YuF`P2U&l!F^CFGWV1%^^mih?=ny!FMk-F+FCP~@{RgrdUOMSoaCbBAeR zpG#LZl+{Y3mgldOP!#kFMIqJ#40*g2h`DIju@}1{8xSc7m@?R{o81A-ZVoG}dC@az zd3u+-E~SX{o?SG?^6YnLsO$h|zBT37KX=WS7?o$PA-v53w#fgBW^pO(Zvm0Ydl%+v zt!Oz2vvY0~#|AP(L{fJ^?gFXZ3XQUn6)*%!n0g-V%D*S2!9#KPyX9$a=jcGlZWt?W ze(lDToQvr!ju9_wc^1;MlO?Bm%4G-+s^`nYsZ}|@&N2iLNKp&B{VA6Mb?bXZNtEAL z%KHXV{`c8fZ)o#`+|>-`9^Kr8QuPP*@mp`d^(Urn!sQoV-fnKJRSS#D?hd={&fBnM z+fMxETiy(Zr@L;uT|WJp&+&>!UdfG(RXAYD3Q>)~(&7R|gvU>ugnA37z+fIwIn)tc zWSSaOy*~R@L~l?fOOV;5!E7?ICM6w>$Ef-}?}Z4hBAaIBmW2b%X05DmY+yVcd4&K* zX(d#lUj>9%A;)W z$#ml5>4dv??q(ox&wclC+tOBNuR_0$w$LB=a5mP#V9~cNFQ=wy;;b>Qo;c2?Z7^6E zc)wSps`_MhF|suW7)8~gF}TKvo>tVTOw$&#wk4~GUKNZ&HcbndBf%tS?CQvTP(@i@ z-hyU4Nui3mxU|sDhU2(79l462SJxh@h*$-$w8wtkgT?@(V`H>wp3C3R>-CehNhZ_A zn&~9Y+6E_AH%wKjK}<;^vwRtx-dK`@M~@N-|g8SVy+feGSYx%5&#c5x?u_x?Nme;+;! zgGmLT2Qh_n2p4s?9#xK~7PIn1M~KhL@lu1fgfI{(hUh^RG_%okGBw8}D%YaK#ingG zl8e?=s0Is*baxw%h83C_9(muPpCJ=Eto~1J`IG;J=0)3?n_+QW5i8tSWI}gJx0%8K5-yisv zWOn;>rVm;20bl``ZD!QjF^KFBWE5Zw$S6dttH==G$iPh@HU!)RWh}yxLdJmRq>=d)h8*%{j*R$CzuMo9`13kK}vLIs5Fj z*BWz-cf6(X9Ku(KC!ubhTasks(KuCjE}KOP2sOY!D_(@E<^?dfQZm5-s;Q~+VlGWf7B7+-D>Q8>s6Y$B8e87I^f4)JMHaG0zW5@XDgAZ|Md$(M8_z>6E&-v|l-6@l<^VQUr2GhL4+n=_0;i9EZkDh zTj*-3Q`#{1Be)0y4kz=jD?*ynAtC}3QWzp+1|W`V(@fNj7GaEV?4gtLfOKm_3}LL! z6TKB@xMP>tWCh=(`a*!I@}AAzNT+*E!ZoKUXZ@@+Z6k0N6DX^QH=8NFxJbg<=0;id zLjhUP3oN=(w;q-=OkiFLdKz}loU!qEj4$2zWqjkeeIrkv+7<{siSnCX^b&3?FZmX1CmZCywuIn?QT8Sd-G(b~HMpihZH(lipEvKc(gz z&5@GqrKXvwrhQeJCXu-&nJF|IO$FMEh^H`^7g32AB>43CT z0Ho^2J75!zI-_7vx>tp)hgqZz%=N`g1u$vtUrS&O97rz?7O6RQgSAZzTJ9-8XB>EU z2O%M54X=v=R%_c>{8w;GtdbF><{t$Rt<|={sx@T*P!1cOMF7Tv@F`>1*|;4z0{C#T zyn^Y&?2;DfS&V~&&959R7*OBKaDA%%4+{?dj9Td;70j-dIHC$?h0sl^b8#hU6{(@D zK+^LpAQ0dohS#h_rh$Y7H&{HB!A`9}W1%lR{d0vLt&*vP7E1>Y+-K4`F1zHS`*ADp zoaNaw&deru@yd!myn7b^>g6xjx4rY7e%;ki;O@?jee}M2WYQO$n@;JL14ar@df%J( z*q+P*WH@16DT54K!@9I_WE*lx1r;i+qe7exZYM4N+b{kizU8NX+P1dO`DIsLttXEk$HwwH9(?REe#Ny< zu~XYSoKNRiJF<=kAAHbny6HxI{nve?Zyq@$0C3B#U&1Fo_96V(kN*DiFJZjYU^mYVG#M|g*leEBb)C#hXAHMerzv_hG)?Q~kiN@4 zo6bC?guctz+21Y?Kl~^+)>f<;jogdr?%pnLz4;co=82ETSHAGY_^F@#N&oHN`5j~% zqe)3}G1o?!i(%FqzV_?>nSb<#8wi9>(8aO5wu)E0@?YTWnbWxOv!BP~FT2|NS@HLO z_(Qzr+NblEf92Q8kG=K>(;vL)jriJ^e2skIV;?fQl=*y)@zRJ7KJ=hpcpffCd!Jefpndb7Q?6x#&`R;O=|<;wz6a&%u9u_dDP6 zq-&n|jHf>NNsmls9Tv7wf>=Ol0qb%zS0=U4La9?NTpWUCh!16u8qG^piNtdu26#$v zE44<}rJz;N8qt`$57xAmTv(4$F$Yts@VAE~w@!y%Yt8{t(~&(g5lSBZyefgr7R~}H zL|!na9-J^-Q$^oZ5%9v6Y8R=If9`DsyeIT*`((Du>*GGRz(^#h=5pz9C*>7^FV6r8Og z7(%4(9vO-NcL~D)m4m|7TG$lXktwQcaSNXA8-gtcXv=5 z#>be5QQLacHX?v^eHK;4=EjCEEswFkw+|t$Nh*XGMWtyJqtRH}b|j=Dsko>{(4L5D zFi1sIognk9gD|0Z5i=E*9)&Pf!MzVYB7ge!zmnIy=3n?*|LRZu&2Rr>zVt<3!{7Pu zzm}fyyyqjOR_?v+X54tw=b%lCzAxC?*~W#3HlaeKW`rAV{3JI?d+9fPo%oZVs+wrx z6lU{w)@i%82D|kZpFZ{&A6Yt#TzYh~4rlw$c4wWWl_i{;%;Mmda5ybiB`9!Ay16%! zxHKAZ))jyBeUh?D@Tt13nz(R7~YBNz?#z~mUhI;v_$LfI0O-}pUrxY03$CVS0! zhkeWe6gAWu84Btu>smFrD8v(L~7lFsm zaI5%NRU0kVpDqU~q#-@kBfQA1R7O!;D?@lrcny1UGgws@*bv?W15{vTD6_*gscw>t z&najg0q%xp`(RBLoQYDRrqo4qT?AuM_rWs6f2g<=3;KFd8jMLqZKo8BZ@csEpD(2} z_dWCgtn|G0@R9QFcYlC8`%`aI&ma7uAF|hc-@oz_@^Fz>&3mh6@Tx?C8OlI$p^CwY z(yQ>iyo7$ONkjmGKz+Yo2+YmEVj;uuY9*&bWUgnpdos|3?$U^Q5ldveq3XzAMRryb7a|}U z5SqEOZnxYs6bTt58Ib`M9gb%c1uF1j-g;05E=0!PUULmLa>f%s{Xskw+y!3-Frv`t zoVc5ND6CIeh688-Ppa%ofdDd+)Q_9wlWZkvBM`6@E4l9{?mlfqx^Wus6ZTjxeoT`t zt*)$ao;%y0cS+6N%#q;s>DzDDm%sd5@jrj}cZp^U)581jyt91qwp;XRPk$!Y*49cZ zA{ipfORL^4kJ(6DbYw|I3m`%JFImD1k4}e4qm0}Q0Z^>V*373fYeubVarBp~b~fh-E{vp?-!PIZfas6Ow3wcme4WArDG=3F|R;K=wf~(xp_%JXwRmnud+0 zE*>>ub#6C7j*~Q0VG@4n6lgIDVFgfQQ`AaWxwM2qNe_3q1g55e88XAZi|!<0 zW=?TZGN?$d%4z4|l zLshn5z5+^T>ZzEYNzRQ1*z85vDtyw>JG$J{P5qx8xm4bF>LmZ}+!_3rs~(RppFF|q zx+6Z>*~Rg_seI3OzLJ0Sw|~*g>WZ(dY!Ia{DUHP}yChMExCR5+tn^%2N)As2fQ;G% z2TWYuu_S%&nN-{eXK{y!7BVh{xhP@g*_AQ4rPMGKupy8vB}>;&jinge(`+&^gP=@y z%h`TUm)8&TNl$;4e8u(G+ZR56lU#P`WxjiM*Y_qf?CkCM1xGgJ!gELY$cdA_*Ux#h zS%Is&3w>j}#I4yB7ZB+rP~LWSo4<1TVf_7MOFv>>K7ztmd6sWmUcosUh9W1IE3Sm+%Navb05Y_E7p!1>AOq^ycxANn@(wTADLriWy6gRU1WxPD*C^dd= z`y8o>OQRNj&aO~cffVoPRygf@xOpD6jb3>40_i(rE^{A`mS7~hzLRb?v)&74dlT+Y zJJPd*B1*@~%Bl-fgt@6FGjXG%Sl0c$eRwgJVm|L?wzt10xi1t2`@ZLF-USEG%uC7T zagV!{t4nL{N?9I{IGxR4X58D|#bh$|bGzqa56R?(kdiyNyJaiPmdhx$I_o+LB%~@Z zSzQ|2?sOsnAj6j1F|K>+Q+-vaAN=^o`S8h8MT8=fylE5Xvw2!dO}YN5*XCRA{W6Yk z??4j0WrBfwqttFuxJ&4+2=-OvRMNCBB0cGykb5G!pHwETYNt(_iLeMID~qVIP^6G_ zRk}zGzJn|*QU_;&h7o2>Mqu@T`bVpG5Dpi%gVD!|gzDU_D$!HL6c$WmEGz;9GB|fc zdpoE=7wvAHVHSU26?`9Zf~qtPF>go;vX2jdMfENZ`@PC|USKpqfElPP@kfLyOUGTLsyD@cGv2A79l+Dxt&=R%L+7s35Nnd2rPdGkd5p$lABo87*eK z^L)&s?12&ln*-8NkS^mYg)KvTT2g1&1ESJ!2&ZUWW3fQ5`BE{r4BpG?hFqhK;_qRKghRr%5_24`H#xe4(Ipp;|y)E`(Ba z@%b7HR2z^P=mGNtA`hq?oJH0)HuJHg7yildQ^%k2nS1V)=UjD#AKqT_Z@lJd{QbZ9 zbAIUdTT#qe${^K^h#8@9tmIlV!l}tQYe$Kl8I_9S#e+XvX`aPom{KcP2T&QNH16i~ zlY6`J_`?_Ck-aV4`N%`~=g)o)-hAU{anF0-?^k`xH%OVykXpK{2*dxG{dA|idFcqy61j; zz@g1e+1fhGy`3pG4z1eK(h8@O8Tvkh6d8}ko|iiB z_j2`_PIb_5gNm5YW+t4?rr6v#OaPcoXFT!fqjKcXAsjn)k++SYn`VqRMttALq`tt?Aa}txV25od7krQpZJ9Q{a?QWFaP%M05#EI@NBr~ zqKoi7uYL_qojHTge&$AAa`DC3+uh^;`9E*KFZ{yK%a8o%PvS>j`)~N}zyHT_(|6pW zXV082pdfd>w4+q+yyLF&tgm>cuC1*5@slU;xMLT~ZFhVT?|ILA@SJBoTQ(0Lv72uD zQhM>mx*xvqLjKL${u1B%UEk#-Hs0{R{@458_{KM0J9fu(HY~*=UtoYh{;!F4K?JM- zyH%BWP}8xC~4<=dz03BFv z@OF^|C}xl*nC+}P$nz!A!QmEg$dRBe&KI}H2lSZh7o={f*zbTZ5rX6u&@!){z~YrI zAN)YCXt&pG93eH>q6+To23An57ivgd06k$aZ$lVJ-7*rs2$DeEIA2M|KBs6Rcmbr~q6;s^PyNi#{-yQZA%f-i-}pv<+~Y1yXU=W$ z!3Q58K;CitZMgM|xASE$`v$-L_S^8$k9@RvZ?e3;g4NA+-gW0)>^z4u*g<#txLv|? zpZgqKdf8?ErQ5#9z1@A>{lLB4+u6g@o^lONo;fQ&_^*EmFM07x;g$g}P>$r2pZqxP zzVj}O$16rJlB?t_CBX8+qTkG08 zf8KF(c@69fcOQJfzu_s@%I3AtL}sKCNXgiG@L{wrSUR@_f9L_;HqAJG_AIcmjQ#l> zy;5dg(CzKuTsJWlNF!quWT*&cr3AsC7^&tZ7w+d7cjgE}jKMx|_ubw))J17laM|W2 zwyogY-X4|WRtiqtw5-D@#dkMW^S3Tghp_SCj(1> zffxcd!xSu74wdN<$@4XgrRJ~=av;=3nFyIpszozE@z{E>`qmA_ZQ+Sm!RF}Ks-+5s z*QqsNP?%H(h>HY!L>f0yv2M_F__#IK3L58BYg4jdGLqeq#4okiI9)^7* z6T`*GtlA~AE&`&SMelD5cFckQm@n$PRaS#9lGa0d2p<^WH5_T!*Lf@u>bt33YBZ%@ zz0j@xJ~Al&Dsx^2d1ghobpX6=Fw_A=D?`52_RLVzyDK|H5dIfJH1*OLN;I7@)`gU| zE+Hx^87%w362xmDY*i!_3r&L;)&;9A{M5X%mQ)=m=dsu;D}=))C6)=5idKN$=!6(V z-8JWeK)a z-w!4{p^pe_Dal^UK`|B=xPgg^LKq>1UW!X3O-6AOicrMWiW?nfrlde%Mv;go7I9`L zM9l<3x>o;xse)*uyBbZFknnsJJf&^$0~cL_E4ae%eCSR*lmPZ9ZPmPVZr(=+qz&N3 zV|6H0EAGtI9%M-qQX;aIzDY?%Jfk3ID^s_!-?VBi(w>SvHZ68B1WV(lP4m*VyVF^- z(k`K~>|43Rt+#(kjvc+oZ~4sU`QjJ82)EsFD@!?0b4LFxQbT`+-g@}|^PPN#J?Md< zAplh>Oik5Nb`&qD=2Z@%7#aa<@|YK|(GE^P3|3%53Ex#00DU8^^re>(1TBz%mMc0h z9iDd212Djs!k`vwi8#GKD`$(R0@xVv9MQ@%)wGqwPbcMBI!6lG6>?XF`=CrHm;o{o z<$go%is-%)SwyBv0*XSSkPX1HlRRRVXyl>S`aPSm$iwU^hlB50kgzMG^!|+PkHQEeWNNNS~WBBBT)6MF=FAG}*i} zn3Vzp%?N24<&q(}(rM)GTx7@H`vS|WBjt3SZHXdXD)R9&r^>fqcuZe*WE1Z=bGH2a zd*82Lv%JFN=T6JvPW&Ou_|&amuuC5Qq!b-IPyi*9Q$>J+q-xe@VFU(xCoUo>K``*0 zESFwc2$4`DA;`?h3Otq_ma-!&2uYxofdX&t!{Hw%dJ!t&MG-WkU{Mei`2N$NvYfeC-dRsoJrb6)y|s zR197f3=HD~v-5FB7Ssrn014gAAtFAoxhlS$)Ig29T*m+t&> z%}ERTI;sZFL8BLU9a4XkbTA9w^7p?WLrtZ@_HgTM22KNzXP+=R~**+IEwg z8HF9)cSXcfO8bq-Bx#c=G80Bx4h5#33P?+!1=T`K2KZFW2&o|W;HMTOo$RRdb0y_4 z(3wFgPZ;QeB*VNO0J@7-yNyyiikR!^HNy?jTQe<|-V5SM9As8wp(;3D2F7Hy0vYBZ zt*q%fe@IpJmqB@1d)xZqR%XG%#1~q;AxbL8LcZ=d1nk&AK9UH9+> zFM0`fCi}9xx93-1eI-A3!^iRVKm8N?`@j7M?oDIx1WKJ0swJ@#Gp_r3Ey{KjwnW`5!GH{(f9cmnr#cDb}PF0c`_1-}Op7`ryO3^|sr1?NgtOkKS-Y`Nh}$ zC;gj0|11CShd;a*2O$t>M`pH3-4U_#r-cqxd?_V4dK_os-TIp&Pyd4TMaR;wzUR8Tn~KM zD={zvl!HoG9l|S4WQZn(A*X^b>NW?50FNUZ5(MjdN-msFf{#*T)!^ZyN?*8kg7ypA=f#k}njDx9GO3x59wW!96qXO|_QhluI zupl8BD(7t^S%LaRAS?o?PhP!xhC)5K(gFt|gF}cQ1~&V!(Hx+s^MX@{rCiFjm9C+N z16XIWV9O6+y;b07@NJIsad2-Bll|((5C^&p7dHYKBfOFIy%9_njc9TMAHZaPf=3^I&|#UYo2&l0&wYWbt1Gzh!Xy04 zzj_BwojR#0DW37vYq7IG!OrfsRdyd;;VAGcufB}0di87Y?)SV`PMz7ZGh177-`#in zrH{LuODh}YDHmL%KmY&y0$d%r2U0UaG2kUH`6>X8l!Sd>;3Ze4y`b-BfIwdR<3EWb zM>g=qTfZp#+k1Gy3$DZd{)~U{hi}5Pn{(220nRyL(Lx7#Hz|ZfqZ+5N0VxSY5>lg7 z(wA43xv{>X(ZB~=%9QQ@c^8o@;9 zUjJLaihuaWzr~H8x`F@vmEVh%v;u5BhUJY7JZW_Uzx(z#<3GRTYw(l~_*m}wy8rwu zc-+^0HFkHleKei9_H#Bq#nu;Y^>Y8ioS!<0FK?fQEVVf2fUd40Pj=7?ab`MkN)o_f zY5*GV`q@IGSOD|RWDY}W6l+a`NjG&e3~LPn!BZC6I0Umh)CT6&t(D3zJo!~@-=U{yF+pF2k*iiJhW z;OmVVNGa78iCP&6R>NCReb#eG`RY=SWmw=v1A`h$LzW029sCKyDyTm7UK#Nr6SN_n z4Fa{W7qQ{{^?V?`Dp_y<%nqJ}J{V;AV(&SOSs@`zsFo~)T?%Sp=EB~^YoUrdQfiT| zp5sGzhZ-6r8M!D_t=fmz1&~`^R#sL;L1m{8ESmtSg+#`HA7T;y>=rdOKB{24(;}2d ztTI_bpO34gNtkmh=E;QUcSTa@_G#bIHu?R3&iF#N#xDyU+m)fva zS!?vS9&gUAEj{)lITbiGTaBrx3s~>tG5{h_8Dbs#qYS|&URzGWE+jy>ee=1dhr!GHOWc|WyU4zhZ4=PV#1bI z%5*04+_|}PKlj}6DRVIt_ge2jsX?v16LXmPc!eEu946)_0;-dlA}cE^)})3iU@~w& z_oX*uDUMn0CHFZLSA*ZZfpyOeG@_@cdv5Be7WZBZ#dFWzB`10s_X&;mj^u77v+pxf zp?98bY^E~@gyL;G@-Y+gXc-SpceuPW!BdVL(-+OAn2yGryP?2+Wo^^w1(V`v4V0T#ilOXyQ01q|ko!&^mlE1`1wAun%rFDi(%6eTMn-uc?_rjJ4E1^LN;a3yX`LIF zsPb%0L=Q+~5Q6)Cv5tErso-SQ1HJa{ig_3>N+&;lF*m?NcK8hR3~0~wHp z?%5$Kz}yH)3Zsw_0)WP08P<4Bi(Ym^uaq?%yI5hdE@u}px^zN#R|eLYMO?gu+9A32 z;kpQn)K?^#l6oX}_C9_yZ)C$h-`xEB{n@PWkT}EcnOkzzE_6RhR&|Ah5z`18%qL5J8MmCF#41s!SGm!x{qE z8JnGu$m9WJBmpdu5EqUb^_5Y>zVCfvMi;u7=&bMEB#{iFQtTW&Tvj#lqVd>MLs2Fq zstCnt1ydFu>4@LCy6!7$EBwgW(|q*Y*#Zd0;#eBBmPBQxX>jEgSK24;xTD*fPCAt| zO^r?+zLQdVOw0-lTSfAgGo4E!yJohRz;kTU&Nww)Qk|qmW(_$@BBoAHKn|9x&jeCX zvpj>{T&Pep)369Y^pL@yDG@S9qR&L58pIh1o`i@m6ygR)F|Wk%n&ZS0fHxeuh6&Sa zbA<5TCI>}(RgzY9YLwXnR=Za+pjDN*yP#MA^-&!KYIQwYvxc;;dz=H=kd>lWNhTO9 z2C99oFXD0n;9=xOu(HUlhHV6UyOL-siDb|s%V2k-ICwuEH>rz+Q^4?V0^TI31@p5a zEkT~CL>H;6tKvZzUVzRy=7_+7!k{Hy-(fabw+uK=sdf&7FLA}w2g1aVl6{_aOHk7* zSiZo8Sq02><>3Wx)nXH*%e)2K6 znVt6;McPnge?gEmq=c!?gieIFKPm|+N!giB;#Q+w4u@>*?%J8{ZMm~#F)mgRtO^P- zn0Gl~$m6}@)VXa4h_ibWEK#wlV!Iw}wsmdLv!IKa%?93m>@5My?g~;>Y&ZAv;JIBq z=Yk6{hWn927x9}fyd3ZR;Jff0(-|Pi_q%;Aw_%w`3N|jg5?$%}RsZJ4@gMHI2mj^& z{2pHZRbP)sw@+hjw2l*xo!~p)@t0UTau^pLy}*xMb|r5A((QcD``(Sgfb<2=y$=8Q zo_FHVp`)nVK}vv-7`0=AxHh18_z6l<^`dn4rb{cU)|4K3-jfl_2Qy=zdoQEHwY3db z?sJkHJ`>NR&t`KrtzvC`o%?$e8;?gEjh1D1Z|dg7EoXYp-ZTv@!#kU^u%Kxa-aA!* z+z7OH&L=ackfZT3N-5YmyRBP0=P;Q~u(Gt|q_~;M?f2YO#vl4HU;0&F#W%d+f8&RL z_=n1c8;7KuPlZa9+yek+^Ner%=9lyRAATRk%S#*V_unW^!(=i8e9pcY?!EhN zUs_rsNj_RS&ibSH#HT*Sr#|gT^310{86W)6hwSpJu9C-HdP(~Dr#^$rFS`;uTjxd} z{pg3@`jVHt_};6Y_{2}1+up&5j=4L=qL_BmDpDU5;RROZ9#$ewdQm?IrM*Qx&b1Us z2{bhx<(T!kAZXY7bYZDo?-~g;3T<#TA1qyhu@gdA!H|1L5qK%#u2L<^OU<^71?Pb4 zR2!%P2d}2#!l7<@D4x8o?FKgmmP+s&W^qMvLmGk{>L$FR{e%2yC^}KZ2c|VD1QiEI zfKcK@slLHM3W$w^$&j>)MN&5wG=YKA?+f5(V3t?NCOmgAfNX*?u+WDf3dh2RMhWEb z2&jiqfPjNsO9v@eWw9N2tYeWX=jw~@MlgVFgUS8@8`Y{QKM@D~u#^}qC5DZH4`TKj zf_voXg?T!k$=mF7~&*_3gan)?56d!-qjP_U=v<(nv48L*oz@NdSY-k(vM& zwfZHc(THoStKPQbx@J}o39HLX<$?<@@HQpiu|m-n)Rv^WPzkD~Rv{u(H-d(wjVEor zX+E%@29yzS|-9Od`9o3H@M|&?l!P-ss_+N zCZwbWD0>4|+k_+QYrs5Vymkm{syK1#1RmPkEiI`}9jo6uE8JLG#o^U8fAIKmZqH}s z(BTWTD`CC5G+LToeetEg*~2Jq7L8`GAEfGi3<`%py{bG|o5z7cU6*HCK~1ZCQ1JK-WoXz&!HVe#1v ziwYZ5LyJp3gbDe=3*T$;WF0=NTKf#St~EF_t{)C0ug(L8&QQ!)Kf{{+yL8i=#mr?*}3S7KxTa~0zI`dA7uZ+iZD{dvCc-<)-!N!QRJo3H1=eS8G9AUyf zq{n>$yScBn^m6e2J^vKH_5OQs(lZ4p z8PHrKz8avc13a>na_)i7vdx1pmlDu7Y{ijP+%Xc)RnwFxB^UQbnwb;c!?Qy>rO#+( zsv@Oy{n7QdRoBM0C+9@++`skMI-aoC_g6jPDa}_s;Zodk-vi#vjq_Z*CnY6f-NaU? z!fpmvaVZ6Tig@XU39X2Y0XdQ9KJR17M8v2!BbgX@nwN6nRvF$t?7Pi zs$7v|Y*eh9`3$tileR=jNw6d;%S>fGHN!)dSXoH8S<-xc7AAQ%O z$MGApeLD{5_dxLE(JJ0H+4XZ>DVI0W?78`lTamD7G=Q@tJO$^rxz8FwFDm;&-D#5S zi=-V9pMbL8i1s2>G%`yK=Wg0lSX5Z(4M>`kA_#x<8gXwVh1JbTlN2%SC?0$mQ>cXY z5$;N1k>oQJ(nu3UsYhrykWnUJ35O9b$g$Oo2q@+zOb(|;8IAm87Ikl2ic>tf)7{-& zNn|rFOoA<;L8L0aSORiy1r#VIHn9Y6UFxByMwOLt}Mxr=W4yVySa4 znnb78da}Y)+$u{w#{wV3@c6JrHCr&*tcTu?Wg|h zd5PQOHM}hszSJ7K`Qpp*$o?*+Nm+BzZOdHJrfi{?&C+l@YJD5>rF&3_jylK19mNQr5*cIwVwZh2-V z;y^DAdJ1$|9Ibk^$*41rVS}yrbbNg0Eczs6b2O5TuDAU>N86d67PpIbPy4@IU&lSC z4S$EZ&jC*6Gha<=XS1<)cmmKE_@wdJ|8cg5?|bN!f7SKR_xGh@FZ!pC%S+z+Hvag< z$M}~QUxB+$oWh4n=9L#5;U#Iwa?{9vZx7+4=JG#XJhmkU75vPtiAm#$b3Bo<&c z@AzPoN=q>JeJOP2;+T4&WVknKN7goFCDuUb=2J{_hPEv`XFlCc)5j-!He$k9G$(N( zVRTAEvVrp9*|tqH=%pCdtQfR+hsQofnzhx+YzUHwkzf%q7C;i7AhZObQjkY+2K{Gd?%Y|L;Tpc*;5Mkq*jE$<%9rHd@9e#Lina@6S)ZcW+?fB4r z_q!7qHS~?8Rmtwyo$TYP%b((({Nioh+~(7^Z99Sm?o*0vja1JD|3dauWLLcCFag&n~#6NH?$KmtOKNqq>stY7OD#H$laWkm*QCi?0@R!=Y^Kv(F3M8n!kqdHWl zik!qOpaG`Wpu9o!5t^4!?ky}3g`rjuqSU}k{QvaLg9mr0ONTV2Qpt;9>4Mt-FUA=g z$U~KZS+8T*FNSVzzd}QuJ7{DOBT@WuZ5DzPZ+bdR50pZ%eH`RN5 zP|q4_6jXrqP$Y(sgaa7wp*rwtGo$sjB1@}MrYgxw24CbF_UZ#$Rl=Ol2GI@T-m;o1 zSOicLSg~rySU)aQBgMK@2;yA@*cFxNBQak(0H$E<*7;_zsXzap%7AxGjwfAp_3_as zK6%T0K701&c*%F?bIrxDJYIGMxi{I1?6ifEa{P!x%S-;z2kvK=vjLEq7bX`pLeFOG zz0Pz4gB}>fSs{UQV*z|xoFY=r%yxJ>XIY+2c;>`|c>0x(FCY2%eR}+hpU2VbUxexQ z8DCmjCQ}R0k(4G>y1W0tPyD$5#+!a0pZmh+^w^=pxcJ%6#nHzd!E)b`**Q%=rE?;#K-MYI6p|LkDC!L^gvdNt0>{F z1_8xKqmgJ)_X1a-NULgYSn9eV(2>O)pj+vSBT;fc106hkXakR(mH^wyP4mJ3Bmc@-!|ub^*?uIW4Q3hiqkK z$vqc*@%CHsglnFd|JA?x{^r+z?KkkiL-*L#S3F+sx$ho~$Ezr1j|A|6kGvnB`KM3e zy63$h?rADi1Us{tKkvEE zfNy=-H}g5q`U>21^G(4|gJZTovEwIC;j&9EMmt_&H=E=5BadQ#Zx`#_M1Imv4UCA78mLTJER)45KKF(6Fqm z()^*emRi#*o7oPCbAjW;vQjJAmbFGkfeXrp*s#bOmVj2teu{_*L3IeJP9iXnhFs%( zLT#U+Xev{?<~wMuUl!vsYY4Lq7)HgCy%?xgb1(zUAC>~bAQ9H$Qx~k2P;Cc6ND3lJ z-4ZSw2CCA82d3r-gJNb&X*AA|MZXlY&05=%Goog{LZ`X zOjlfS1x_44?tlNTf5bJ{Tw}_{|Kv~pOx)mXh!;Qa`MmSayEvImhZh@m*81Jw`Cazd z$rEzh7jO5iy)8epbr$>kQ-9%$u9s7fp5%*O{6c@?ldfSd5p0-bg#G<({NC@sp}r5n zWI6%deZ0Iv04UQv2f^3B{x`6>c>z9l!>94!0}tYB{@K^!jxXQE_rCw#zOlT5c06X+ z%}l~q7THS(FGW2`6o~LBQiu}b0?{~-R+h$CSz4i_#!}M=>1dZnSl`^_q0M!fPiKhi zEFuZ0jj~BiQMN<~{*ju-nG(iJV;Qw0YnqWaBS9nLN+Co%g_q?b8?mx%E15SEqe{-I zO1$MQZ^a+H@qgPle8bCV1U`AgNBQ$V`|s`V-t}&|@BTaSzwf^jFL>s4XqQ?%dHs;D zQ21U2-uAt(hL00$mO&lCg^o^iyg#wcCdo}_PUDg7easJUBG0BUH=dpBVp_~{67jx- zdal+i^D_9r3Mwq^mOvPCc9}CrSVxl}qIUbEkIA@7VP^BWJ@xX(%ja+WguVX{-iUAh zkN=5XpK<47kJ_3hdD5{=ri2~{_4Sxgib901MWRy8xDh(&xn!f;D4x=^zFax-*;)M9eJ18Zlsfb@_(X z8&=cx%RU>t2zRcnR(f9gV0*$h2zIgd!e;W63T_nZ=wCXE7>`#)yBh zLS=&G_Jly`?oe?rlASCpMcf5U#rndL2pVbV$kh_ly=?@-#;0D=w3}PMOM)hQUQ7W0 z(^C)f`O}SZFNz+YPi0jb3UVHqQs|{H!D#u?l?`c?9EqY8!g9?Qc6aTHZJ&A+tvgnX zGFEVGitL8QdoR-P-e%;jIvW*QHW{lFfuyFPY)Vt^oAk0*GFn2`2`g5tz@@hm1e`J_ z6uvxar7x7On3-qk-KA|CyCjEpf1_Aq7EDr78bj3Ch>3wYoxWd=813ri4Q}N*AKu+7=eiyf6uEqPwZCw@+PrP= zoZT>)%c(r`ZI39N2Ji;3Ie=AwOC(p7$aC0ZCCeci z0Wh6ldD5AVM)A0-;Bm|Az}!JE09;z{%!=7OG)B1K=+R(JrX*e8b6&DbF`tQ~WW|p@ z_z2Z0P1_VQ^WuV>OVPPP8i&nR*TkGOG0UDM_inTK)VJK^G>9uMzL>Mglou4Uw7f!$ zm;JUo?!X6SCMmV$lg(Hko9)ZjgLX8H@hh{5|5KUkVW2shn*Oe7=LNtTm`Th4oKe*? zMKB?>SLzli`>p6i5+@1Vhv=S?v!qf)r6**rj)}A|U{vVEC}Jwqut9gwHEVM7B2wk` zP9u|~UKC`EXf?ve3rU4~r-cxSI3T6NJW1FRnbE0MSE5e#5qnIbyP<)Ixp|W6dghtp z%E%3cYgo&extK@BZixDYaGSeGV&pOQajGN>l_wKeW^PaeMaf>=wU85dQTImN&AdUP z8%tsDFfpRAlw{E4ZeAoej?^YiGc!|j5kn7UtL`P46wQ#mLL@_O3NURP+nweHMOGWy zZh@!bSf1zJSEP~RMLs|4ygPDOzPfAhk?AfTo9u|>;!A*A-wP?eI&RJ9$=ayYnW$!@Qg;#hyHBF|{Jo; z8%rb3;D+9GTsdU3vl;i!I+OyAmqth)V8loS8BV4amu#+tag=2%Gn1a`Ryr3Y#sE5P zG3w{+%ba~N_9a7_F0Iita<2T#XHIabxKPxQU62d2IdH#^m=^P!kDu~)-*Yz~JauMh z*nGKd-AUix-IL2MIMm;E?>#opvsr4=RKn0j$7dz|vuiUYOSo-t3S{wu=`@7BGF-OBMiOUzsIH zD`9Y6u?|*CngL<;`eS8im}9C65=y1H49e0W$4vk=qEx~Ps%=8hD0IQHMzwI^!T_ma zHK_BI`j8WPVC}d7D||s5s+{*~u~>m=XXM6}672K^t`asU{qX(ffN3>gsc+U}>EME} z60RhygW$X%Mg|jq$XlvT=AtMbvl1(DCsfUW^{9kWSW2n+UG>@xLx}*e%8HlDIIS~= zn8PF?Ng%T|3S@C3g=#i_4?}?Z^n-;#DBx|us0~o9U|~gSQr#P>KRd#)K#Rku%(?UH zp7yl=_OTm3_vTsOHLj^RX4;pY&3MV%(OB|)wqWx&?FcJvi|1W*jPJka9^@J{>VVCx z$e0O`-V4C&8FUHXE3cm*Nl~$q3lXK#840Jj?f40M%KEz8eed0P(Un*0r$(#z*l+$e zzVmNhgd-PSNG-8W7ip^4f#St@$y2T=*FXO{eBhIxw4_O%^33Ppt~>9rCmy?4cJ}w= zFW>PFutE9emwy|sdD4^d;^)1feB#reNU#0be}h-O;+44i$}8}!=Re;iHI!T-4)P))}z-e3)mqw{h8JSKy(C9ssFD04-kpYhU_x zeC*^SzPh%-;sv92gw@qm?C&I~SJ$KsL=DK|F{U5-! z*FKfkz2G`L^yd%y$8WfSFL>egxainL{NQ^(V%NXug?Z}pOMdG&e)Cs<;>UmD=lb4* z;O6CE&i5u<11csnWF`y&!3%;%2?CtB!88;FUR?l&-Bm)UV^jb)g{4wi;H;oJhg}(< z63a)cm~s6-(BWum21SYUZvgJk%dYS$ISFz9;8b7-q|9MKFp&MsYsj&{yg;mGQH04m z>PCGibx80S$*Y?dlr>xwQIr?|xhQf67t5g`nW{Jx2fua1Au>1;fHkRH}h(z^kh6v1JSi=YZ{LdCk z&w3#06CQsxzV7S3PCj?zO}PJo`)oGb=gHG&0=CZVSTjogAOF)YK}G347$Sq0 zU3L`!;DQS;z|Qtg_!m>?R$%5R4u0J?elx!J`@hfc_~LE6`3pDul~-NG_4QSM!#})} z)9H*yj~vCUn|bMrsH)SQG$SP;Dd|*@65%7&^G@3o;JOgYYirO}J*l#3;>O=xUE#*& zCPt$r-`$(An-?}s0P>BfYocm$Q;Lcv5W-dyM(xPk(U_xA1F|6#T}53)prQoCIr#k4 zl~u^g-BDaeO@n*xyc<9Fb3cPKXU@szKYx>NZXCf4H++o0_WEDfXI%Sa{KLE6g^%BO z6Fz;*XR+KUzV*c~;YZG$#o?nD#mq4Bem9k_d1TVF2^PiFGvQ;)&nn#SY(OE0?kw?xnvkDwSh z!>gK+sB9jep%H+VsuZaWh7P`YL(YOlgG_*uq8L@SNLaqtOooAJ&B5lWhEvpLj#}Tf zRBg|qDK3?H?GR{riA2DY1JzXi$$j?7kLhY(`)#D z4U31MGm3GsXowzD7In!{>NPFZ`;m*KXrxD493J9}1nogeJN)0keu?`a7%CWk2ik&d zKh##KL&ahVnZh-AI9ZZi}W z6z&*pVU2UJUagzl690P!1E#}Y7DTQTwQfZR-hX%p{9peR^anQk=l$$TH|qVo*G={7 z{Jh_zAhOx3o6me0Yr<`_hYO~QSX@VSFsdTC_w1eJd-u-z3MB8r#0R6)FS2Lg(=agsf<(0K6hTaEb5X> zWKI?+ya;3tv%O-#SarUV)MY$^chlwRY+ufp^X@*Q8%=rj1?#+TZ_;m0c6s^AGDq3b zF0YC&&oQUNV1Bk|dGBmna-NZ9n44fC?oKF^VkBBFeC$D4qmZ7_VuVJ`jjr=BLMZRU zTt}^PT_GY45qLjxX$)9u8oO|^izO(PnT-Q0Fpku)ZcYdDC$~b5*;VCE64_7GJ)!Jrl9`gdi1sz?wg-`0W#=Z)=mSMn`dmO&7~C@rlUSjZ7(X0@%t4Cfn#0yisALBWIIJ42K-7BlD zrCAZ1kwVW_Ko)nj3eSN~i5GZwx3ID=oU`iujVKz$d~WU{kYd%O&8;u+magtbb|shO zYzw>;LkfpVgQcW7TPd#I;R!aUcZWQPk}XW zbiem*wU-{^iY+hrcUvd%U$1;Te*A%Lw4$cVBh2O#N-k{K`ymA-iPIW8Zaqa|Zl*Rj zCLvNX(38X6c9*HhUc`IO-K9xx<7&8^m8D%t|$dYn_0rCy^e6d^&rhmV(jOT1F>7Q;d;hyQPzyJ6- zo-^8|Dm>X0jJk=ZMBIDs^gzt@==_2UHN>4%5u0nps76tL)oU%=gVM#k2}*^-;Zs1} z=|Xp7s@B$&Iuw}WRq`6+*S^PP9UcD_G( zL5EpDU}l`mr(9|qY%U#k!Z;d_acpw~7i@0&CvW;Za&@5|YDDh_cY`V_tDkNmV;-W41kH6p;fA^2xguUq=+^ziJ_x-3m{pr`>^Pj&7fAu$i zgS+qf5Y z6;fr+NAP5@!@$a zfCIS>2_#e-f(jT_^nNJt@oWt6^g+NWFmxmer45h%0a{Rj8CZC#1vpZVyurJx{@exA zz4jghmlL$`H4CFiEX?v_@3rVng8mzu#lc6pI@>R1a#o;z5xQ7+K{T&j<^a;+U{a?* zmDt=^$A@mX;mL1*(_20unvhcKU;N_j#l7f#58mILI=zKwJnbpn``-7#^zn~=OkVoc zFZO%xzu({czIPG;S65c>)h~Vt{_w4DaVw=R+2cl0NqF@uz8BkD+qmP7yZzkG4!rc( zSY7j@M~~v3yYAxK-u@OGK6;ed3s8EbcFceG@BTfuwziN`gEObkhW|N+NFSi3C@K~q~AFLP~kqpYs3qLeJN$=pC^e2pMAu}RXDBsIyT zX~-r~l0sB5(uB5Ys3N9l>L;h+uU_JmCh6v}!d8G*=mPV;oAHm{{AQdveHJTAV{9JU zfcIgp zCrfSnfh0Jk+Mx8gHmy~ zQX8v)p~eh(71id-7J;0@G9hYLL@dOtBA{duHa5Isgeff;NpatV3rzSOE~xQzptvbi zg2-ZZ*-&L?J}d;>2=BZ=1?YuXzv|MHc}*Z z!MS+Wz20Tg&lh>AH6%$$>kxT{bB;c6^~8ij?DGa($YrNK41DIgmj(Qjq}j;8mrrjz2yC-d^`>^`9z67$R0IN9$4|K}B>W+Bh1K z=}1;NTXa|pNDsKh@n`}_8S>Qu_Yx5h@QBnA8cL}43jipk$sYRP-smafbwuO6(w({v zFAkN0Xe!kk9l2Sc=_=>?xp#nP!j|h^sI9wr3OK2OI#cno>|k;<4UjFaCC3i$37;>~`7i_mZ6CBU@+jj&o;Co%*P}Jcm#7o5mNJY7(0D1*Dsivo{YLZnwjX|CC*-A`LnG`zU%PuT*j3mjk%A}mw z+vU#bQ`nMX=lY(r0y~G8*;jKxCj5a0a+A%A1M)1D{xQio9Af}BGm+veC+ z!Aw=R8^NAPGfBc-72Q{rdD1i&^_fs}QY2F5Ldi67G(;m}YSw{tY3riL)I{JEBC^rl zi3UmGU^CD~JQ6s7iJs9+63BpQnV$p$IRe64x8kH?cTA9Ld(Ua zp-56K|J3*RuaDlBp0>1Rzi{@1lfYgTYOR{c3TchIj|l#gn+;r_;aE##4uK-{B1q{7 zbney*&74%Scqwp@`OLX!KLnuE+)3IG z?C(RT`O6X7XvY(?T>%p|y4uC!k~uo30>JvPo2qD1xZ>>xj8+`rE`VheOID*$ zfT*t$90_sd#BzY)Wf60QIz9R>p(CI)08$LYF)oXkxzh;A6%29)@iW)+FYr-X%Ou9k zKH>+=-2+>6sEI<6BTH3T;?JGtC>lgCS2q(vjbg041VzM#JB4#A1DIc8yoMN%6-e=Z z(N}swB=7{d-n%0WF4L%7>Vrs0Mun~I3Kl6~i%Hl6f(A=9tMHn$Q3v%*cd3c162m`o z5I~^e^xy<3g!cn+qs!U67!R+m+Mx@NOm4dS{)uXuHY%2qo+Gd&Y<3%wvjq1j=#$Bw zxbC@Nhmbu{*>6N9D!Qkl^G1}aoDq^qDWaN_(3C9HNb{jAQkEc*Tm+#&pfD*2C2Ob| zBiNFQzBz&?2eoua+_O5)NAWz|gBTObs@T28b{x zk{euPKm=;eQ82Ha0#Of(kO6$HNCb!QwF;QS9a71E12z&|?tHL!smyu7@VpP?k^w8K z4MqjA!lJWocg_zy#lX&%I^z%jNbTpbP=^MAaOlEO8Pc-wI3An|ygCjHGv7g==g|At z9$v#|(d*646mv%?eJgQtAUM`6Cm-x8aX@|?C>2_%DFgT&?1jqCs3D_nbul2Ng6RZY ztL;k#&If{4?ZnksS-3IdpfWVPlD-5I8^oc*kD=@!%dgZ~H!l7HAF`^_mP+hG-M4kw z(zKu1*SzoruYTA2Klo)c58H4n$mYJ^XH0A=6v1dR^&@L56j7e-=FxfrAX(jkf+A@} z=<(dAiU1D7YorJimo}+oh-Aw^6 z{_qceU*7yjZvj9d6>TEk_Sb)br#$^yeC^kLHFIfQTo{7&qOlf*LDlFM&Kwa&??EI} z*932yk-`k{xuw)#)HcjrgVvUOKJGYnM^~1-^o3|liuceYNU4p{LsXW=t*@@EVv2n? zFW{(w6+^aS(m=fH5h5UQr3%HkSle2L73HWEKYR8R4;?;)m6bK@&x()swy`o^VQ;{R zM;_zxQ)kQ1{mf6{bwB^_aq7$|jN38h{S+YCrZKvHhMRA@3BUR)zl2|U-G4zrfwE>O`r4ZXX8EZ zdpBxqH34VN84o=00G380Ui*}5v9o&?S3Thgxc}b!@n?VfC;Xw;{-|Gh)m8FmZ~IgG z;UE1`p%wh&JO9D1xcmvWJKb&m(=Yy~Prv1Vk)!urFsU$zTMYH*##9SuT{aGfYdrrl{^%O#?V zt>pmtcx7ZSe1~zs%9PrP#r8LRj0fowjTNXFnBNi%$l5PR-8c`H0|OW&JOJKNEkm&I zOs;Iy3VOTLqE&+gp*XNekhnPEu`BiU0&oz&fq+ zv4!OUK$W^hSEQ6^#qj#qzy6lK>n?OR{gXfWb9?$Tp62t}Bz^S5AHkKEU)A^hT>tXV z|3cyPXFdHH{Ln`~guCv%n*i`{Ui*`H=&^_WeII!L;@7D6kH6{_uf)@z`3!#KqaU-I zZ@on>JbD~bfu5&k{g&v zfj}AssiY`0kx3e-D4EokMlGdLmI7XK$wgRQS*1H{yfkKN5;hL4VPj)c*4HY(^t!)1XbsrBzi;CL)o%uB^nc zIKG7(X)&#!76Y0Mk2Va(-W(SlIf9qJ z@Opm5l~?fLhmQO4`98=*1@hMZt}ZW)OP39Y4{!edyN|d*004jhNklW!Umb*e_MKNn{iRR;a?d7>ny4{`euG20}`+V3{LAWzs;p z)p%`^i+~vnfjg{n(F&G}4D9P@O^4r6YL$QnfjE< zW7Nu`uxKDzEo+nq%Zn&gT-0}Rz-WW*aB)Zyj;C5Q>Ex4gr-4b=D6h${+)r zmx0}1uTwpANWeww;eb-6z@>!wdI!xt^*rEHeEoV}FH{hXzDrzpLz3^!2@Yayqw#9SkE zcy=uIE2ukgvjy*G0UmqZ(VWLT8z@odea-pb3!&Urm!H0`Dr)FtEaVzB8>szV{dWeu1Ed2m1u%hQ-<=Z&_EBWp4d>jjW5rYCoiTZc#2rKr zct?2WC{s{pa4!yx%>%5&@24buRbd6RDc$$uX0j!L9c~&+u5)jiM!>0)H1yfBX|P7}1-n(mFPl=aDMdhyJRra&78-ey%Av2A8&%wz)R%-#0j zz7H=GIQQML57<5+Gr;F@ebL2#a|XBGVRHv&4xc%=57@o~GXwVFe%jp5SmBvsJW~v3 z%noXm!q$L}z({#Oa~ zF1)v7WWW!_An%Vk*a^BNM^2QU z#UeB;K_xsHH7Qg>9Y!crg-IJ108L6xNv^7BRD8&$QB@=tXcLfC(m^FyGiMmYhDJ1g zAEn3N5lUqvYAS>Va|}t<8xa=)Qe@{a;55mymUqV>#BNfZ;MM_!LYRZ0VTN{uNa z?o>J0I1mCMg@Yr42p~dH0tuuPz}&6vq01dgE5)s+HzO5mMRD&e+eha6GAC@}zy#pF zL(ahMQ8*rk;{m!iF>86LI9MU92UrB`95!+H9e4DO@KJJSZzcusKBR&Hb$Kk4ioN%1EDze(8#6BPA z*;7Y*QWmZYj6_>9l5vEvIbns6Qe&pv!&R(@qYo``#=!65aF(%7c(8PEt_93W7ehz} z2V!xBw4{!XAr7xob3ySrYs_OPsmbV^>pblSVa2TjkQxS2GC;MuDWbWH!;vF+xf&nF zwXbl3)U$#J{@wX!_t4F-_5-Lq*#U|eK16yzcr{69(Ga+!O2}*1<8hV`uQAMkRxt`5 zeAm$V1ewp_WL15NY7UZetW3tEgw6Gh?!i;1PS2*(y-{jP(==ODZmY;%qq41FN99fu z-F33l#B;5r{gm`vo0|QkX|8RWh)CDAZD|_qQ%aUn%8jat2vo&Igl=$EfiOWeY!4|C zM3HE4`y9@lHYZ-zT?utFGShlQPv%i{H_ad4f3fMMMdg`fgp)rw`f?m{jILiF&1_qrv8 z#@7tjW?}s+G0C`AOiHZIq+Ad*hu1^&@>FH+dO6H``xaYA)(dV*QF%U`x zT%^w4;xxCx3Z|}Zh**6@`k^){7&aEDSE|p%tm|;~kz?FDdkRl{%F|FDc!;|v9`)ya z|7+M8khizlv?D?jOUV&;EIEJveIH40``f=RXLfc(TcH)^`)sXUSG;hcisM z2vv16XT=OX;1&lp8O%5@9TSQ5jZMtYw+41{ZaXEzxCgO zT$dCAGMD1RA^4Gx-GEno*LUN>qZh#inN)ErWp{U9F1zYVY@OY<)5lM6X>EliXMfMEvvh8M%(BZvIvTW_%^Kk3Qx zycb-D8$WjwX0s`eU4F^DZPw(gzve~xO>g=m=Gh=aJ>xxV0OJDp|HCyli zIE&Y|TF{3#FBSZ$m`7cIQK}4S0Na7Z!R8WEqG)Als-U27N!r)31G+KjRrs^WS~L|CT|nGqjvfe&RLq zgWvys_{``2i68#Rhq8Uwkq9d5>HQN-4n~5F$}LiBLq*Gy+Wtk|JoQX%k272wj)4wzi5(F1f^u_e`o- zSzhMS(vq!=S9oaikdMcWo<4PoeJ)sAU4b@-R0Db=c4}4JWy7MmF{-rO`igDg$Y;B#!k)ub^ zh|07pTwh(`sne%%>fAPe_D6mQ+q?VzrF-vzlpd`JZo2tP{`KGXP2OxC5~BE@|H`lM z;{A#L`6oUuEx;4=IWmc0PL#^V0jC7GBG2rR7krNFay_kfe zltXh=rKVt|77swWA4pMaLn`&_orLOu*AL`@IzUtz(!tl(pGj6rfk6@!*Qjm>7fZ>Z z;UpzgKXo)P2^$rw&8qsKMy@q{c)cMkw$|(_zrn&LtL9t)19)DU>^@x2VPPFtWT=Tl zT^|lCQLkIyAye~Uz^Fv$^B6J*KNpLGJFbO=kw_r5zTkd1>mXt9*oJd4fzm+2a#MsN z1}O&ZOHQKNcq#MkoxSHCUS0Xr(s<0}rP1c7X_3OG%CZ|QLsDwo+?_$R4u_gp5Eaxj zPr%GX5r+KT8SCbl6{`cKL?jo3^^Sk=SLl!hotVJ(S~01dz~z=n_&0hS3_ zB79khvBF0r8zDvlTO)LXzy?vq0M`g#A!H1A3$Rzpo;$l>qRSFc&I!;Hna-l3b90|c zlgbW-QxwdKd8_{zOxvP!tC2jVbBwdqqo>JR4qQ-l~kArZO9~2 zlp+**N?Jq|Nd>B4qv~3NrZgoaRcHbf2^2DE4QQu=B4{K6s)dRqK!Vmjx-PB-NE9eF zazrG6Z9$wBs*04NwyGqMM3M?ffdSknqG3W3#_Lf*mHPc~iq!8(Y-+Gms4Zg|o>=V~ zRM}`Ore&z{jrg$eRw|lA565!4rW9&h0d!a@uy))GG8kDW8Ar{H1>iC=cv~7D=j;jM z;zcCWm{RhUBuu$rB~ivCmr0HRj09XIuq@!%Ve3jRgR(C0F)1qqRz2>cRR@wlR~)iL zpaHxkFs_Tg1fUga3vfxqTaYasqX45t0cjO71~>vR0?-8Onr+>cH&H)|MjOP$1DmJ@ z@a2Zu5;i7ethAOGe!f??Ig`o@Yl))DTwuKs){06(S?Wh?Qy1wGaW&SLBq=BVzZjVj0EakoF8Y)xj< z{iSAfjwwyWe4-*#jbP@93b!=Lq>;2o_)J{4rIkI^wAVB`OCtM8ITdZ@ZA#tq&ll<)FX{xiN(w>=grVE)TatQ1b8UW3aCWuyCA;>ek>tTQ7|5~ zN}8!`n*}MwWtjK9szI%ie}?{=6<7_NVc}y}!Pp?pRA^i(P|cx9sSt8Hk1SkCIR9U& z{xi?#k$pJ%PT-*Zk?-Kv{!=Wew^D`yEMf{Y191bYky8;k=UgU7};7zciT^B;T6 zm@$UI_ShI>Ffa(?0fRtDBAB3rP-j6 zg`YWdGoOFcIlTYlALloG!`Ff5ZeiCL1m+Ne<<#NusjK>mH-8D9zJ3jPGU2fkC;bn9 z`?vYxSG}5_{@A^E!HZs?`+K{#Ihl&&gf3-w6x??6ZP?h{U&xAE4<_-FUDh!oaZM${R!N9>n&L9A2e4@+j^Dw^JTSNZtkk6^JJFqsWe){Z9H_um#Lzs_Mxs7^SV-}<8yxmfx$apMSj+Lun0Y`sN+q!Gx7Z~GF z5kE(p8)a1E)fr1e(PPo zVWN~Lo_tCkeehv_{yq292k!rZe*B}K#3UuT`+3i)?|t8UaX8akJKyzA ze(rOh@!M{`iHp?&<~62c1c?~iv=U4Rby8#OT_B=1n{CAFZH_zdyxoO~eP56yabt6% zPA3zYZcMSWvnBni`0oDPr`?pA6OzaBhbmN6S53&Op{Ua2su@|8qCyd25)BtxP>S^M zY=L1Yb(LuQc7_At;BdwJ?*Ah8_HMX2uqrD&b@6HR%N`dmU7|UBRm>lH=wUo_@iHEL z`T~CcgCD}~{s9F}Gw_NJe9cRr4_);fhT_+rcm~6&V%b+duMDWQ;-FvR^r@35X4ss~ zu#q#IM$14q=^{UzK$nz|1eef)Q{lB8SXAQF@om27dC!xRCr)T5Y8v52qf{k&>xKBl z{a@hco_G>ZE%v>X-bDnro;`z?+;s;_sbaMrY|N&IA}s4Kfs8C)M2?6y7fL%rqusuN zmu)Bofi9M)ri5;}Q_s5OLrHyPgB#CY6KTU%)B9-Tm^U2~EQ;9HN^Oj)lV|^oQKjv* zDc{gar){l{kRX*Y_EQ6KGp?~Ck zk=k%O-k+&mIyNdEWK`Q&d$eOjPCR}|jd*A!qvHaCk;p^D>gZa=^(?gs3Goz<-I`@{ zZ3i9C-B2;cv8zq_(xha9rq~JpbXYpI#Tp*HPoWMfYkdUdD0_WfY-(ubQWEwmjCa7= z_tdUWA2&y!0YZ^?Mred~V3gr_BVZKIX0!!OL=fI{2c1&s7);6pkx=zSv^at zN|sJifM23jU2LLVO_HpGP(_%ST&Xz=OvO!AstS!%SCI-~pb;cgSvAX$mF$?j0bC{` z$SI*y9g?u5z`Z3oJzEoV8ER7?LXaxLNLK0Y1Um&>DK&`?D#8q_bPgawO;JznT4~7VCwXl(kBAxh|&@07zL#h zg=DCuBsGzh=F~_Fwk`>hifnZmvy}ZRvpQw08Mec}c zCo<_0x+yuK+EmpiNjMeZLRVmHPM7QPB-juPGbN@8X;Z{DgfbCfP9iyhQ@CXkL56rUX+tugow%fCrewc`8Ndd|h zfjZ%31(b!mRhk;y5?u&)C#p)M4O#>nX;Mmd)YJg=MAX(XMop1;mjgsZ=U|TgfDK5L zL?D@acIecRvOA=nmkv_a8!2HfNe?0A!+=(oCG-wa>`A0uE;4t+n-S?Qc4gJbO}gFky3^vMN-9#g4_wRC@6~5 zDLNHIfqX)zDgIgMLWM^8Es`iY3Q{6EB{~sj`)~w-ppg-pGqS|*$`GcUI8Diu5?L~) zn$bzJtZ7Iot-3BPXF0EO(v>D%H3jTJPI)(LI>?>gm`?JQj(Tt`C7+OWLu@g1ue5W&sqzxrAU{i=?K&L90 zDm_zbCzPoQJ5Vy!yQG{^Y?cHQif0v>CXp$~i3_Geor&mF$O!}!s!WxhAW$f?icBDu zln{prg*gz^Fg9zD*%U_xJX4SvpW~!NQk71KB&;f4laLwWS>W38J~GWT0Z=s!!Yhag zfdkqJ=#&`WTR8&tS&cLCEsWP#6|Rg}*`|n7X|)<7Mj-^#TKgv{H*rFA0;s2yB&kv) zBeQvh6#y-(D5p8sNz(ah+4rmEs?2n9ahCIw;(nO3?j=n(RMR0K2cl`7kQNZ^B~3TF zE**554<{)PNp#tzt`|{Lz_V&qQ4>lLQ8=|YwDpXJGlh&emvBi6=q>H8k%Q8JZ`Bdt z)E1+GBPV4`_#YjjW0XM5{h{qwA7|1dW@3bX(QGiO0fnPLN7f4UafXa{XH;H~s$>D1 zQ8?a3Z=Q~|Me@R;|&w*QTdOh^0FTGZ3DsP?QABX<3Ug|tJ@ zYZI)cqq#n!d&Zq7p0Tdg^H|eG(VOXOEloYWx;pP8yO6aO1|_ zp8~4%>Le7y(ASeE&+w%$cww`q!_S^L&XYSQ{O&vMz|PKbpL7$B4kG}lC>Y#mWDwK@{vt9~Ue2YUU+RU##BO*iWKM;=383;x4@ z`cIf>#>JF>rOoH?z{1!4}Vw=76h8e1`GDz9*?k!W~B!&+J=$0&*%&&b3z`rph( zRsd*|O||2s;m(y`?3uHzwpyPJ8Yla)~i=8@e?2YICGb5 zF`ws;fAUj)>BqqbX7zp5n&wCLbeCQ#3;S2W%kl7@jnlrxpyZ*X= z-JkuR_~-uYH~Q|u4Y)aW_itG4CStYX2Y=un*Lz;}688N-gJE;JWqZ4O^3s>R7_}B` z&W>Tem;)rvp1TEm`}@+*_W^)E@#8;%G@atZA9)}8<(@zP#rN=IANw?a`R%`Gr%#^^ zKA}cYEb0)ftdpJOHVp-cmr_hfs*aSDDvJ4Hg`01=8K+L1!c$K_?S}^kJbwH*W|Iwd z)NpSga?5Bfv?>3d${_wU{CFP?u&hB5{YL~)a(Oi*xg zV`4sZa<)r2v%Q1MSFUhYiXTfNLorlJ^nb3YE(IuFPzbkBtzi8jd81zgcF?O^LT2qCC z26crs!7*)YQg;Yal+LUpS=xc(Z78)iij9sFAImJFxWQY#AC&Rtx2`DhR_xix#1O1k zI1<*TO94=2t#V!i{Vpw&J0{+ip&A#*sQwtGtE2R_4Z4LE4U~x7Fjy-^ZOp5ULW_0P zl#De!?VQ3o`>T$?et4?kY#HeQypF*?Sm*g!yL4*%;YY#0IL1gA#71L}EgVm*wtk!rz|0zN z>a7elxI3%uJw<~rEb{Tq3^dSvpc|x`iCZTTw zU%mdy-NpQX)oRjwO0wojnrxmqc^oq7mNpa|9`16nSfL;K)DMFKPNk$$Y&i^;JYvZ! z;VST2s8n~e+7DzBN2v-mGY8$51W^P@NuxMh;jDXN&l;KW;$R)B7eK&)V$yT)(yFq|!2=X{ zr4r_XT3hm(*FN+GLe@5u#0PX>w9uf^=st+Mn`;F;f#$_+9W~>UT2T$7A~-($bVm;u zNtIHok}OVlhqH!M++EyhtT804lwt5k*h*u7Fi@L#X(DPZDMDD?NUiX?T+!3SrJk5- zQPIW1Z8=nTs6bqOX?3E|J!b8PVoQPVOZ8q-sxzhq#R^Q8s#u_cCKW?5?UF17lCss5 zr`=pSx#h(eN!z&y&oK7|GUFa@8 zcx}?2(9=!DF?9^nl=@jQ9J*P899a99bV8Hr7c1+fgmhzbk`J?{U4ynv>XTxg`ZiKMpf!Pk){Bgh(abxgt$c@8&=utx{~TIoS2_Y0#Ofz-#U!=CFE1asiIQO0^Ktn~{`Q?!3f^Fbqu><|amZXwn5_ z6p!~+Ox&S1rs_MYxJyAx>j^~B2$Mn^Y8j;oW(4}N#ba=DkVP8Qg$if;bcV9GCMVs> zI3WbSYNXT2f~tTR39oLZB(1gqLKWiG41(&lrHT0gug{l;(9UhNC-B zAwE_W(A`%Cio27vN(kVl6w+M{R;m$Iyuk&nKs7!?7zf^#4GmhTLvQh3vD1|0s z0<#b`05ErtOg)&HIE;lfx`|V5mb*wLQaY>4+3jO}?z(#6(j{9CWtGS!;nSg(jXK!r zO1MJy$xSY!#oSdWSs+O$s-h{WN)k`1?rv%>xy@*U7(q2swT1x11XZkx z1*lmWVQQ^$MnvEx#Cc;d9~&TI28a}R;X2}DbdtiO1I=rj9Z_P=HUp$3&$kFIhl4dX zdU60PMF|T>SN>7-PBY#G_&7S=EgH^agtw-MY^_N(a06?=@)*PD8l|J-2dPSY(MNT4 zv>!F_dCV*K5TisfX+-fx&(i2Vl?V}nwq|*2CWxlW_6GF?ztCK;SVt>HK|+Y1bOfea zM5T*?Hpc!&j6#Vdz=j1y%f~p*Q6g$jnhtUO>23SrQF^g7kSyM(0I#B~a~<$IDi(b# z6lC-!twr_*^>JTndrS@YYHdPDAFGDfLQ028>)#rk4M)Zkj4dbLOeAsZwQ^G@H~^K_ z{)VlEWo9Fs7W;=w%Q^JAej3v5>S~7B#uN$Snsm9dxrJf5*t-3u+Xh=L@$`+W_zQ1- zll;nWz0(i-1yzVzopj*2=g#uv&T)i*f zuw2cdt2tIfcIAZseNYH z9Ufrk*l}?oG8Di3-+l={@cn-m`v-@zxxI5gc%t~$_KxiD?^!<>%gVjh!fx7;07~hp znwV1dQjDZQRZy%lVrDaJFbrh@Sg1`^P`~b3gaygWdCC^4GU{l>RpesJjBq>C&nR{rom|KCt+#j&kzpRbm5R7|Hc)M3DKz6Uz+qI+J9Z~NB2 zfW7@2{`t?}hs|RrIN#mJ@BYqjK_*#_Z6CvOwQ{<9U-}rUtGfubkvPa$=f)W!LMG(N zl%=oO*qq_ysgr*F`c*CumzZtNaPq`SY#rOcapGDnNE8nSP2IyS9jvf8++ryV6eC=e#Rg_mY#!Uhsne%$ z|NRfb3vl}MNx$ak4;VZ z@W(y?u0T=0g5A|V-uTsDZ}PD};b$Lu5L&B0x_^Uz@ini+lUJ_56}avzf9Bu@Uwhk~ zxVBv4>1$VID67W)w7XrJv9(t2?jPco<0tX;Z+??~=>Ge7alQZnKj@u_M{_uxq$KOQ zsZ&gAF$YcRP%+8sr%&$KAAjQBCf1h=v0AO#4E)P z5ZQI(_uJd|!COpAZL%yK?LZp9yHsCGPv{=G31DkfJ_72gEhvR8W0JDY=(c9*(e}L@ z{|whM`Rz zE)Q8Nb7G-yLws`!v1Oo*Djr`Osm7~Dn_}G8Lvaw`!Bo)`QYt|LG-bbxc1ZU%Tim+P z;w5e8t~BMpwu09{96S~VR8$v8jptWgpbR*qhBl7}2(zkH5*gV& z-lAurbRP_mqyi`{3|Nv{Etj}i=>Sw{M(b=vbNNdMCJV)cVM(Z@(&*F(MxJ| z0g4Z1mFDn;6aAFB5|vV^=GFQFU%-t*?N!KGnjCaF?bkA_a$=vH3sRP%vP{CEdLoIH zh*XGqEurI6@l>5#mEKP^txoK0UsTuO+QH#8OWLAp75JtQs|jUEWykC&MU^UUhLsAE zXElb$5oV^SHDdHE=s%^BEs!*jtjK{&WJ#)ewO*;y2o@sjRZ`8G2ceWCEIE27sG>#z#ONa8iooKeh5SYi`k1py zq;@8Q_n+H4IltS>_=2r!itP9mdNB2); zsMJcN94<=aQ4PsfJlZ5JDSE0pP=l0z=9M^90Qm zr6xlZe3~fX-nju%9fJ!*z0Q?VYw3;2jU|aEQ*&h}oS^qhuEU8gOBN@p5y!+Z&Dfk) zJ8@V|i(zv%$pu!cTjrFOI0WbGz_Me_DhbtfC>$t8DQz30>Po!I+@k+Iz+<;cbBQjz zUg0ieZK5A05wBzww}!BKaAR%q1-zw#IvrBmWD-eFE-qvLG9#~HbU`Pih_XsTGY_oT zQ8b8f2e~5PPBFqOC{AV6Xh~frN+~LnVE~M_qDr#rU0+I?YNjykKX79;B@%_^MP0qn zB2SWZcPHahCx90rL%!qym4k)I+C?eRCh6w%5Mx5!#Vfr+AY#rE`~*Eg48fF$g-$~a ztgRua3dPXOd`73cDy3Gyt(q`J0$Rc7)@>*oGlhlKf)ApIc#T7rZmh!gf7~FHAwJgv zb)yMtpt#1k)Ff6uYa=3k5J02fJgR?%CWZ)j2c(AnD`-R}4uOb5pjtIvKdEsYl1`(T zRL~Qn>`&ckm5DS{sCmn+F%f}VAw(j^#9gQspCq;&-FgBnh7Qh}BtpQGNKGkw@#2Ip zwx%0;b^l;k4MQ!p76o=EsXI`SeGq-u<)<~JOG#uesqU%BzKG66@_v^vx508s=}R-279n46F3CuLZ>f(4GKJc1 zj5%zA9?@1lzaEyG8?s>qY+o&R38{=lR3OLQAJ2+~ZH{#x<=|uIkHk=HjLC(o6^}zQb!+2 z1AxZoH{vp5*(W5x-cY7A#=xRPLgJq*7$T>ZQ#WQ|s(bh(;1Q$A5tt4UP-=M0ItPBt z;%hj}NGzweCyiaJ>pKtQ+uTkZdsf6I#|X`F-jCgjaGC_;Z7cX33 z?U#7<^Pi6gzW5OK>d*{^0!_)QSD$JU)r?Y?yzunXIC=aePVJno2lJ(FZEuDyq=H-9 z8?gD@zt}m>9L)JvPW_=jcqgmzhkcB9==dsN#zWAQ!6tj?|Rj?R!EWqqgF#GDZ=#A+QZ|4_>cI zWac4=R%=bvvGj)cljd+%P{U0WL7}!5T^^;`wpqsGy!0lDbWaclDY|w5aYRhQ_v6x5 zQxdgxX^J?~7^4ygZ&atMH`R>uS#8=41!;$rH&MEJQ-jKpva-d_27A}W%Oc|i5EtF} zch&{g4V;TZ*Vin?QC@pHJdI8E-|}h$CBhiADx6Hf9*%_&LB*>Xx zs{tHBQ74QN`V<@B5SSHz{K+Tr^S|(meBj|P;@nN=Aksxqj3^K13tYQ)$v{XcJtQS) z?jUe{@u3IswO{=;eDcCmfIE5ze(~M!M*X$_$G`dE^YU$P{VIIuiAVjRvcl7=B{CJ8 z-Ndi%9dNR-!Ro~GZoL^FedG!59nRwey{1t;I;NNy|8-?@A}v$pE#m~PHC zmdqJq6~)Hl&H;?9GEdEN7m9O2$D^S-B#)-yD5{8XN{hC2j=(sNh%CwxSl-yiadK*@ z&X5$UX>DhYH4xV5tydMjB{>_=W9_h#1Y`%hVxM!A2VQT=VvoT zB@c^Xvw(7aXN@IG4X>odYv$uQdGvh73qxUW>QO;FgE&+l-=DFdlxuK)tvnHfn;vDl zO9H&cN5K`|hIno2m1c2hzZ)%oJucPQX^5sAYf2!6_y8UCkKO=y7kJ3nVktr}y%hvX zjo;@qQbj;dtYvVS(Ca|)o|3whd~dQbRrBE-E6z`+-RCwZv(x*w5HZ^xikX@9eZ4-N zJ@wQ>i`8=4<-9qYO!8p8E*7h)S7aB<^ZDYSxQnW&)uL`}fK&t>Ru@zlvxo?M2s1%7 zH;TDQQ@mLe$yKkB#!rKb8%y!38tc4(?#2rB%M;E0R zgX~RGzA{Z|Pm$&+$vkOZbs|fbT12_Xq6az4GE@4b+KaMgRTF3RMi6Mn=mBbl5}85- zPtjaTcrto!v zf*^@O+&yV(AVYB%)M|<5)|Y_Wkzs~9b~U=Yd#V))T{mGtPD$L%OY~kAmcBneHLXb8 zE30~ZvFxRqcYr&INhl6mLzKHNhDv8mo`fPz3j?sai^7K7N?jtqSWV*(R0^FA6AR!Q z0t{|(?KM%PdB`^CCWXQJ`nt@?U4YufB$5cPP@$PYqTnU9&$E~t<9~Aql@ZMAfN;o~ z77@AT2C_=j7CC?tOQtL}LA9W7eejz}NTaV{G6>igScbz)I7+9)m5S;mL93gwS*+=y zFk`@yte`jk6;wqH5g7?_F-Pgh45w9C>m-!QFcAu!CB<4D`blA_Af47{cdhiAm`kgZ za1(cp0ZrYKz)|COR^;fjiqg4K=}bhiA_-j+f4I9*fl8rT2v%z{sYb?ZA`qHYr~pQF z`if+74-XgNMcB0Xm2_e?W;9E4SOay;izl5m!b8lP291r! zI+_+_%)&A5w)*r2j)#J1WRBKY#JI<}+d7KI#y!Ght!k%BBU8M6i%0yJ2uiRXxqCgZ z3bFRzHQ*sppf-oT!dfnPJX{&K&xW;(&!;h97}YGbxnmU}rC95L*58o^UeKUMR2~7? zaS1iN32onLf*KvA5{&0D0$J4}Xi+7EJTBw>4@gR|I<$MQ9h;&7;kUeav!hr@A759D z?u7QpImX-w6o%5?=hnuxR{xs-TBCFVX!z4Q?I3o*(nP7!;v}qfsXX$;%W_ z?z-t_yy9(d1FF&CNGe|YK^Dt7X0uJ?ZsM!Kc>Q1(XU?3{*`&kae9qIyk7M31kzAZm zE{Byra`h^nf9AA2eEvy%_E&!$Fa7i1gznfetgc?Jf9<>eivHR=e#8IDcYcT0((Bg7 zhJW$?2l>>+XYi3<{;zIUIh)R~T&*aeRRhaV_|#KRdMSqO?M*BeE1Wrf8fDqz-cNo4 zf94y$4hM@l;^v9DH3S5s&k+s@X{!T5Av7qIYEGpm_dIy5St^Q4PMl=QFzG`5V%56Y zL^c5Q{R&>4A`7gROO!g)6FbM{#%rh5w=iSf2xtq@7mwx%}`1^nN@9`ra`mmok zbqf73giqXaaJn_bet-0VKl1xO_c^}!r7y+M4-h)CxV`R;Z;dARW}6d!^rIic3txB-9((k0|IkN2CSUf(H)eOU4}R$VzCGRa0?7aR|Np^1`I-Ox zGq-I^!s75Sy4mzuopBcDw$sB!LaarH0illiDFkXG-duW3u;*+(IbY|UucK?(u4?yC z$+qa)D06PHxO5mQR1~GwM!3eAC{2MG?kH*GWK6kj7(iV0wm!eaqKm^EAvU3-5J(o? zp(A!YCZ6b5eA!oEY-1gbKWr!SsI$QM?^}*|ocGPJ$oAmG)(21=!UBc1;a*~)Xo8HE z@`SMfRK_?5v|^)n0FCKdGJ<7INg0Bj5%@aFJ!d-zxn`Ni0uHRfUW@>IySzrEitUn& z$J+`}8rfjrnyHT0G#bWbZFd@rQ5-&0m=MRej^VK<&fof;_q_W*!cqRsPyUp=`AuJ9 z%hgIAe&}Idy?h1Jtr;GB^fCGPM?Z<@JnwEkec@^T?jQaROJ8v6)Cs=%wQswfR68w$7{@3xGyPwOw zy z`oyRFuDkE%XFu~<{^9Tc5xQCDlS%f)VK`K4?MF8pMWPx*Rj8s!Sx8Bd!KsO}Zi3Ct z4bPK~r%s;2Vlii_19!H!aMLZfVm90K+)Z%vnbWv<=^5-F>|rvUVmg^XC85G7F6<_m z8Ht4ciAAD>Jk2&iC;P|K%6> z!4JF-DP^2Ja~4(xJoU^othJ(>W-OK~_RCd#eyoB3Hn+C$^wZBEC*t5>?$>Ty=OktH zrMOk&qxXLvX?q9X@un~3NACL!?|bGMoHob#g9F}w;|7XVEY0zjdtQhSKk`LCT&~*q z0XCY8T{q>)Q>Q7Y{`}|MEw`LFfrG`|sibzO7F$a{)KOIs-}4sejWHi_1jvO^ z;ybF<1yQO7^%f1&$SEMoPTSB#;W`^p+WB)-2CD0fMUkWIDrt{L+OW;`X8}7>ceL-S zjNnC6yNoLC@vM-hPVn&zvd{^N22dfbd5=xKu+D89!Q}Bw0Wlg#$8$-VPCewb+NSIj z1OG^FwoRB#4Kqexfsq;S`GR7EONCPA9k>d0OqkFXkpi4jhmqF1VtOT2IwVp({{9 z>FHtu4k9wZ!%8nI2Js@!m4KCyB?P4j7mJD*gB~gLS_Lc=9VEK!dK#+GD(S2ExXJ)< zfO8NuLAiS&FwkKtC{7f>iv%WJjMar02=!3MYY790FInkkFrg2O1+IkIfM&v80VB-> z+Jj!{0*VwjD?$uPHHuXlhZe!)Vi-UvlmMDk+(g(DECgMNVn7jhk3=Y%xc3eeKq?iL z=9T19=}3`}I|!sO-k;jWiXJpmz?AHjED-4xr~)wq1|h7%dq=Gfl#bFXSSKol#F9ks zsH-fpN|aSfI%LW7L^*VqL)5xThB?4J5$QFhMW@m$WT41Gg#+COfCV1OG?B#R?die$ zVGtS)g_2mk!t23us0WfbC}^x!V@$@-j+|8))B40$bgy(@!chWxz$&UHY^cuaX4R{e z;$CW$`Yu;q2PId++BRj;e0TBp+OZcOsS#ch9*^x7n)>s`vbN#$xc>GqS#A}3i8 z;yI;dR#|3EeU>z&tfdo$CPgAGD_w=2Br?dO08~R|21QCSC#TlKAuT02%0o2@JX0$P zWs2N%lG^$~qH`hcr=$j|LaM~?5k(SNmtQLs(tfszAh|XXi>!ZtYIm?Oz;e+z`;{RE z$*u4&E14v<^3zZ(N~libXDXr;wH@>cO(C!G^HpViKSxHeLM#9cX~0$|396ws(pI)g zCq(H%fT2~Cn!1y%`+Cw`VVYHYNm!Xcy$4AetRK{TFczET?uLjQ5?F~c;?Nxn3KxK^ za!$}Bg8)@r26YyR#LN{zOQK6j(noX$3zH04#YMDtv8u{KN)^HrWB}Aer3j^pz_LhB zc%`r^r6jUar6!T$Q0tUEB+hGhR62SFPFNwd6pCJJgh17bDhU;e0(Z-zhlCGw^dcB& zRs`%F)`J)vx+f|_87gR2MFW;-Q7w{)UWmcmT%9XMzf~cuIBiHt2a*FxPn04=p{R*) zfIB+T-W5i1W5qJ5A~HFoP*?=0)JRQM${-psWB?0QOWa*7q#Fdi(oM(;!W3GBQXwd2 zF!fQz#7g=A(UQ!olSRBGLputTPWTYU3>v7_+j~IJ%wbF%+-VeFhV)*lP*!L>sVf$3 z>#GnB@LCD<5`$57WfigrF*sQXRtidpuGIuSsCog}dpt)|=RleT>52lAqG}f279Z#w z1Y!v+5FJRAB=PzPt&p??H30@u9Z2t?D8jfQDO}Q}Qc;v#DP`5=3{@{Vp{PhN^pb=t z8V{3j-WOX5aFD?LF6X_8=plr2k_VdQAg8n|)B_dnby@eil=r)w_LHWAENLzTB)T-)3|g4EJV zM^lgy>mDp$??Yq0vW)a?%Lx`4jltgbwI(aI7Gu()Xjq$@KzS4eL2XdYi2bxBrjaG_ zHd_GeqtZ#nM1xkg-ADru@g1Z^6ggVDfjq0=blm@%5Nh42-988*@(Bu9lK@FDnPmL_ z`~KvoR;$I$cinuOpFX~cr*7PU7Z;-_kQxza2w-=qCjezr+CgCx8u#Pe;x0*^$vgR@yA)q5`1n*R8k7=`-hW@xlf9;-imID_-4uKKH_(@g&CLxzcjg?=oIZt{ zZ@CF4Pn__SQd6rEE@X5@3)!;n*midJTAk8TE=5?4ff2^@F2yl;5w{8}6@a1E%D%4{ z>e7=Y8YuIFLrfJkoj z57AAg+}YW-gT+FQZEgGZ&M`ju#07Mz!}ITX0lfn6d;j~WRCskrBFuc<*ZaZu{c-)9 zf9r1|=fr-watJx?CfwSZ;nBw*@d}mQYgaKlwrN+dUFU2%;n|ZX`I#?%9-sg8XZ-j6 z$M4IJ|LDKQYFI%5S4~{5mJlUQZf&EQ3zOs6<}oZ+OFMh+CKASL*DmAsJD*dh(+vW` zm%i+!=~sW{SIymbE?&IoZ+_Do-gmfKHrb4{SlxCWvL%y@|1rn-4GuS}x9>~r>1Gn- zq(AF?9FY_saS&VMujAQ(7AX_t9G-^zX>-)qgV-;sR z8~H53aLmv?!pvwg9}p=3C&4-t3S%BI8a+E^wr~v?8C!O?jP|Bx1!^BOIvP9CG9E>O z`E8L6@FwX;i;OS=W+IaP zbc`Yxm7U`S(-i1U=`Pm5nGiliPP30Tp7sHdR?aBUY3l0c<_>=NU;eG%O(K|VOz~I0 z^EBBi!WTaOMSgv65077X0sxRw z#^a^vKhOsX$e8NQyWTv?IWOK%DW5$iy3|pAIdI+`yq=Xxss%~BhuaHo`sdIVQ!(n*A^PZ1KpSXa-`5e>94DLWFj>8-K z*g3X?z1=-8b>L(&LDK98^EoFQQ(U@q1uwYg`MhxP3T9bg^Ft0oNAn3(hosv*Wfs5jBUdEOJLdfDIC?-mK^8Dj> zX3e)e_0&@@Klk#Ned=(&SQq_Djlj{ho8?&tR%k&-J79}jX-A^Aky*!quBrAy)!ohm zj`t_m(H)WZH#Xci2^hE@j>dSBv82>taO5Tcv}Va`u9JvxSZB|&6;OB^F5}NdMxrz@ zx|wyNon2dIo(VMMb6{=iloonHNMPe4fYh+Fw#y}+&yh+U>l4b_`BouR)DfH>nbD?H z36eoD0Fl>Dwn(dS;0-0>C{edIL;9NV2)m*o25YPF`WlW%35)}AJ5SXt&hN1l$XZ;T za~-oYx&|;_qG(ZFhIJO9w9-|v$XIl3@4dyLJ7xioSIzjEskP6Cwxy0=5)qH&L$4%Cv%Is_Gz9sV0&cg%_d57ek6+*`SU@C{)d? zj$SY&g&c^8_EI-EQ!?`kx=xY;X4T?jV|)fU9@-sVU>{V2p4aZnlUyZ zGmE&N$R40W)eV&x8l!A5Hx(5M&CLa2&mLSTZUrLhUX21)h%1d=ojoWTUn58KsEH-m zTD}P~hpk@-GjS11@Kl|Z#=eQwpn*J-W|cYeFVsM&tlhXQA`}d!p26gV_aL;!5hW>TVUJn}f46{<8+mJT~4tg2|QkRl?7NyIdxSCgf=nW`31 zUkJE#N=+iYDu)EM(ozUboTzR>rmVUmF@wW745$QDw6|I(2EfHOz$}TFIDAg})RGvj zCXc>dP#~Q{SD_!#O7mF!P2G9uXmOoPC0s8?@kU(7X{X9mge-2!Dod=a>PgJtiOGx< z^VCkwHhQZ2RYz6SZZPwu*B-RFI(pIpNkyENrhLkXD@t}r^KvrL z!wfy_I-Pf-`=VSV(F0GIs$i8wR-NV{XAY{_a}W(wHvtFX30f<#S>{B#B3At{Qe$97M6BgE0gJp&V% zD^d>Iy94cBR#Op}SDNdvN*=$+JHl5=ra5|awGQ2&X&>q^lPw{xv2!X|k#s4g9HXTn zC-G!HE8^--t)xb-Zp|)C5UfN}uGQfw))YA1P VSnb^@io`-xp-YIUJ<$cCsf2R{ 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 z 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%0D(8kQb0>!qYLG?)fX2SC ztJL6?GdH4ykY1hr!Y7;d1UO2ukKr=FP?3%IspO;e`=eYVR*NnaFw1O840Vbn!nTLraErNYZk*WC81AT?!# zc!8t}mW4WVw#UnC_21_sEU3zfS-^+W6UZdl4f1_zUlveiS#ZJzz0^lTiB$SobI(Ah zeB~>w&OGtPtf;IdpJqv^fNg3<(dd>RtC%`Hs~dzR_Az%^VZUNxhc<)Wvz8+z*Mlff z$$)PkTC&3Idp~-pzA7AeNUT?gL(#9u;b1~eB1@}=PH83BBF})tBmlevi<3r%E#^Rv zPQt|=89i15cVqfFg6Vql0(~n-mlmcGw-{g=Qj3IxGTMz*BCQ^nEnBD?9P$(kW`26r zQ0GICkGl~qSd|hqM2cmKc%%80G99COhXFD(7Qw&>6EbRA9tdZ87rK$I2!{!+n@OUQ z(J3dEk;xF``pD?rYP(QwN1-xJ$j}@;RL6({#3WVaUQD^cNR{D?YQF{Lt-{|)^axBf zHL@I5eO%3DUmkkX;i5~mZN78C0GAQ*1xT5Lo~|$Mi`rWaLm99h0F!7}Sz{=o;A==i zi^LgJZYOAD+h-+jb0_5Lbz_b|hpf&m#}#@lzPU4^RVNQiHER34IVWb8^Fc|(beQ%% z^V9H=A>UR+?4u|Ku`B~@$-5)SjI}nBssd@R`=*j8#L6EzfCJhYB>dVJr$u#{zx38^FF-^>Tm@EQY+m z>V0lE04;_#KKncX|4xBi%^yHy%u(jd=f7|D+?3+ms_SMD_Snx|IgyV1cUN{I4F@GW zU=anp3}PUk^Hx)cm0v@aK-!)Js0nN|I}Dm(ufSL3hszesW5SEK5UyN7L%>iXDLNQ^ z59p7*fJ!B)hBBcrnf+4ZC`YdW>ic<^0@RYvIHUd0yk)`|myz$^zkG9ITEg zgZ_zs;@9y1{XhMWz=EKe?KWHWiVoWL4G&faIG!ADZZ`}pfHj1O^)$iyg5EnO0=p2- zHd`DY9zqdzd~}3Ij~?Ol>>Stc+_aO^$B0-EeSvv41Lf72d{uo2);IwI?%jO~hlhu_ z*zPbN91$MjfW_39-vva6N_b&Cx{R*A+u3Tp(r$CX^UbANo4QSt=PD$^ExFPZ>_j>@ zoZ%spE4MxxdjPI%-|NQ3n~24y&VX4=&Aqu}(L&piK3mwf8PVh5aK)peBb=X}YHJQR zvn`mq7(kP(+sVbK;<)i#i(Nuj$K%HreEQx~IC*e_*S_)f z_{58!w42v&X!GEGe&s7)!r%3aei6R?JHKsu{+Xxo#yjr?K#L``(}k~RcG7Kgc^QA= zzxxyZFaE}V0UZ%78-&pgT0fW%dHcp~+_-j(vnP*r^TtiS{q8&M(b)-}dFp9?<})wi z8!x|xZ~J+l<=vat@cx4n-&|hm#-$vK zN=wmx2gtKo9oCsdvw*9};B@y5XCIU?T{)8)8iz753}Gl0X)VX-2^f@+OZyDbTB@xN zs(Qcpk0H(WobN!}SxXe5r9QY^R1)ZL?bT;FJ6HBif%w#bKJs(UE3%i84Ofav<_B)Q zE*YUN6`;PUy6;D3b6LQ!w>~m6ek5k}vORn6Zv0Pw=70L}gLS-5lWk58Z2>FE>P|KNSR`NnHFK0XeB_Wt|tayni+>4*$pZUSRjDy3O zH;<0>_1E9f0`OZt^-Y?Z>;3y5*tdNC^Z2IEf3t4hxJ?DQ>z8`|g^y!>IP>57H~%f{ zHakpHgVSP(@N^i?-B-@D$4`uA`aQq<_kc^czxe0=lHa<11IuoU@Bd%^XJBbOIy%C3 zy93~81?Vk;tN>rmnQhftswv!o^|X#=lWjL!xDk_2m37)UPcwGQ4u^-=aO1`e^yoS~ zJmkgcsWz7z-oA4OH*Q^r!Ex>Sjm(0AVLi_Z%I5VtRV0?}vt@sz3EkW*kgk67PK9Jv zF&=4}v@GmP9fjD*j@X`WwA*ZQSYVH3=}=$Lmku`P5`xiew;SbQCiSp3L)M%YQZuKq zDRXa821w*0lg}Te3`^WC!s(O8x;%ek=jZ2`e5LhzmLP8XCWq5yA&C6ySazYyi*w&@yVk223k{;{?DR2L z2Zw`)=RB{q+bsadW!aenFt`?pv%5*q>B)WZh3DW_Nh~ z==gk#OGNR3UTSU|GSMi2x^}jd##>oH3;8W&&&VMh;4Gjl=_wmNWI&IMcqm{tm5Bwc zD^>9F5${p&H!I&xy=;UIpp{A{?WL($i?R)thN9FlLy{pCiDy<|?T5kqnmuDI9C?-u z#e;LG6?&yG4Ha+ZR1d1L_f*Db^Iw$ObtqDV*2gmIxd18uT(7f>UFAKkpDj8%D+@Ds z@%_Y4pThR%1rzu-RlW{LloyrV1w|3=%NU47NvzT^2T*P3z?J$9nH8`HGWOqpDFCvJYb>m>C%Fbm5(GLOKBY3OxmWRc z*}2)Wc#awK&?Xjw0ho96%H&q7oOYm|o&7Gi&qsw_{b#Jw;B=cLjOBy4!-$&_$f?Rm zffl8>w_KJjH!wI|h?FZ2*Oh^!i-gf5S*VN@p)pd-JW&}dHHBqAUFIW`becJt`g)*5fq)75Zh)6G2n^W;5PY?tYCIgmUXV#R@R~v4|QTA2JNE6U) zSg1b~F;JyNHjQlN1ivQBoM=@?VbWTV@0wINGH*F z%McfL5bj-qg&8LWqS2gJc?xDOQEX=B2(_wynFY2?^64SjY=)TvTEc7-%^E~nlRB)S z>pH~-Ml;YPS>@bp0W1r(P}l;zglP*gL~O%VOajl;-2g45n#=KyTEtY8eUODxx><}B z;}z)2M;S0QtFu1{Z~_^KFuCouv62(42OJg&Z%|&(zY7Q?DutFum zG7XqrEH{U0!;=@6|YmE zTPUfVQEDD@RE}syeJzuu zdFtQu5%x5o+9JnC$5#4#O0Jv0zMH|jDn7(Y^_sCIT@3T#{Q8hPMS|Is0De;m?6VlU z(DejCE$tg1q!{7?2=p+9gC^^){MIeQxj@p*jFC~2#@Ndo+Hm6K!LFe`$3T#-?x&o4 z44$c+`#6s}=@R=c3SuaVRl9rs6pmpg8$%*}2X4$dMQ#(d9;^&8o=%5(ce zR?nPIIk1Hk6AWyC1^SN1k#$Gs{8tY_9oi9*L|onVLpEthkpJ?9z1&ZF(G{2*0_1|CJ5NBZ@HRUoIZZc>NQJAMF*zVC^#OToYX;K zn5L$XxVgA6pDZ1#LHKllSPV;7td9@bL;T3I&%y}I2c~}EVQsR0c@_pSf}B?ey1d-* zEVi248i&of+ijEDZBu?fz6KRIKfl2B>(^nMZLGXm-z<1^eu_JrEw*Rp=u1aLAYrvo zq!b}i^uup4luLb5}MaD4h{~u-Ckm{Rm{F{ho!fv+p+~| z0d-3yyp_YJFIcu4YuI*;$2dkAXw-@}azx7|%ul;rZ4Cgj;yWMDB9SVdW-@J~eK5`FF z-MNeV5AO5svrprVx8B0zhmUdn_&T0>`Wd|W+M98Dx!@zuzJU8DkL>*790#j|I5?Q? z^>^O3&n}8?T9ce~B%Pyd-e^*ev}7yeJbxo;hPNjNl1(1CJF?p;bK{MSpe3M5X8+U-q1@0PB9 zD}Xz4$??2=(+OX94vI`0IC6%ozU#^n6eo}D)NDjRArWFiIsJ;T4#c zmp~5JrQJs+os>n6$r7e=k$dpJ@UgngO6|Chf~b5>RR26jt%p=Cmj*EA^(6NR|F8ey zPy7Lr%e-p*=*ORD?>pP=ws`R9F=!SSm*;%+@C5fCK8Uy8eutNr8@}+u$KuK9V=cYc z8lGm^k3aW(y#4+IK6v;LFMj;vy12NsCugU-qj|+oe(VLFJbI*MS@hzkKCN&4{I_tP zXZ5~lxxB>9+c$7}eyZR9U;O6=P(1{1vSnEW0tW}Pou5CUApE_5&p*%)j#vH@Kk-xi z@|S)Nzxp5l)w{p+m;ciA^;cfO;kCnjP_e++(2*8OZ|F|8*0R`!ZZL0|s!or#UJ(&c zESl%p)`u&!$zz&VSREeNX1B$Sn>S!>DiIK>%(CI|=#Wk)3~J4|?FgSdXD7C3(?rE$ zZE9ikVdzaW!R?yY4>p_LU-n)5o zC@Tg4V3FL+ORO6?s}s?TXj2PisA+cJ!O~ttb*5hvo7mvu?1HCf=QumR(4E_NxIS3N zvg-vnGxN4Y%xwnR1YD5T;KFx5c({CXbUu9i(C>fn zKAw8|o`$0S?ELKJb5B2g9tCRKP=FTVA&b4rwC7b?;8#=xNr8*QvbR^+)F4t;%>3gr zk56r+N{*S^K=!@ua)7w90$7;@U>5E8-gY{G#*B#R`-3^PhlB4M%9e^48M)rc)$9vs ztdti~|M}j`UO9>^)p<_MmG$daV6E3698B{+R29hM@Ku588nHK(a}H$m(B7_{Xi~<& zWJD9((3Y}C)#nv^qN3bILt)acauu;(9_-3|WLEn4vXs{FXqBbtdx$ty=XHu_^zuNf z)N+9ilwtgN635ZJhQBeUW)Rkpi(vFXK2%S#1LWR^`u20>^= z1~jkFph)Wo%jbm~B%kpG>X1DVSz1QJNgEb+Q- zYu=bV7wPP#x>{gES^Shw?3Cf)Z2%p$)OkabkkCdEcXj6Ukq@fM=HLL?6S$Si>|3^V zAB!iWR7xmiex1Z{*p&b7R53Qq{6o)a%g8w`^|vutDF}3HPRrGq`F z!rA4N4J9optaA2Zf^v$9#!hlJk&$y~(5wUsV(zgv<=Naos*93YiwsZ35@jISsUf<; zGrxH;31QK*HMB!Mbp$3@EFpTc&=QI)dJ>jCet>lMsX-B?_VVmkAPsB*^^SQW6uv)a z2EBt)hfN&$$mK#RK}5yYqfAkCewD(IQ@IWjNP&4;{D=I|vm2!}FIV#}k=zALRt5u0 ziD?WENFElR-Ud@raKl`Ho6lHW|1OAra5UQ(9Dc!cF<(NoUMyS8YgzHkXT^L z$J?4&4!=~aBXqrDSY~DB^_)UTb|BouQ<9fPyO6YzV~N1h%r3ITmlCm~X@|aSL3*dt zJcck}5}O;bOCM04>{;Yj*N9kwz6%nLNnLd1QoFhZjS*OqZWSY|Gf^Z*K|rnNVv{lQ z5F_Jb>ir$ictB7%tOa6eNdiYkV~t!Lr@;&kv0EXeByBY9u(iy=jAmIgYJfE5FJ(rr z;HYqlq4Z)X+lWPPW{SK|8hollEkzWO5J<3tG&Pfi)AA7Dl7o(E>sXX2?npfsK*zz=F#p8ocF+*dtA~KH@NKD#|O#&FC4UHH!&q5$T`< zt6!?_bL;y(O#AqS;fgBvURd2J<#sE;j@}Z4>VmrKaR4ynVCdN|xhG&q#aJtl@Y%H>UsW-ip zuC$cT5F=V|%6rVlJ(V+5L!LcL>X8A@iIt;`fKBZxL`rlcON`K|a89)3T=P6CrAp>o z*Bb|5m-myz2BN;qq4LhR)tIdgsrX@3PHcG&10d3QW_z+Cc^mH;>j<;jr&FjPaZg^4 zUSL$FcCYz4e`R6EQ9$a2c*kBfPNj;khKy1Jmd7IH%HxMl8dB*{8J%rj4$x`L4uzuS z@8ZR+3#L~0d>|VS4Dy^yw#s5_4XVkCNUHsy*Hg(M<{6R$%LlD@&sbEmJ?IKnj{JZp zP)^TBe` zKb-ypgf^n9ml``~$w34pc~-wWS=!8OWm*Qnk9}U9P-xt&D>A zV4hQZ$Fi8e7w6jCA_+84GCb<q8%Bg{gAWEBa4BxL0L_ z_IqmXWO@7bdWTHu<8TdGN{N9grZZjD21AE9<$PTGP4fw7r)M7nP1kPU(zWY1D2X4u z`(7O1xUGweGgI&Av82L2GQRim**VTG&kE8KeQNBR4c>qFAX=Nj=(a4oI6PkC^mJoO zEH=+8L@0jZ$A6p>u-i(6q7(&YwJqzFYikv%$sL1#Go~?UQ*>o%|E*lafFYLYG4k8K2}4)u(qjV^398$5XQ z2zQ^lE1jP6jW=G?$3F3K+`M_i{Ji0%ufK%Nw#RS$Ex*-%>+kqi(IeR0qiYEdvoIsf zV~HLA=pXr``0fA7?}&@Dvo@~}77O8Ub>IijPBY)%%>7|!m{&j!r$A0qP|M|c0 zJKuS*xew5h08@#ab0y6PIc6l?h;BizNVszILxeS}_b+2mePAUetjq+HB}F@f=!!A% zXH*n>>|18}PIcb~ob9ggcJUO?w-+Wu|fA9fb{l=?YA0O-Z@W8(M^{?es=0@}`x5>Zh zlb?tm{pr6Q>($J=Pu;XHefevW`t+^e@&z201?D4C!&Ks0Q?8f+PmU_g>(*nj~8W($>d+hm0ktH;P0G+fi53NF0%>co zDa#^7P-as@vrRUs7A28gUENicHRKSPkr~rBym#-}+kfnRU!?v>u(_E{nT|NcE0Q-@DTJG%Cx>6@y{LXfCZWR+Gb88=Xw8;dGR_XIY%bySo6K ziVnm=pGVAojN(Y{^c$+y-1l8BlSS>bUEzj^U8p1*j3 zo9i16%zW_Zb-=@xyF*O2VR#lYiHOe>pItYcJ-i>^{?2pyVfL}zxU2K>?7T+DR_{id zZh!1IeM2JfgYW;4BO)xNb2e+dxx0(L81G-)!*;X9_00|L?rtK+U`idpe%pw3dekGD zgq!QZVrMF*E*DyhFBC-i z%&&-=s7|FZUabuf%vO21W@Lm43-yx_x7yV*j8%zqS&6yi>42IRb3bwSv`Pk%9L99+ zC(=OW80j@WnvRUX8uY}GmS5vIvCFYG1(3qBpZqJ;MO|HDBL#4MVO;q%$%9voMswBF zz^mX6Upuu4PrkV*ItMjey zizVGOjNA|{Em+kkNIBDLa|Coc3=;sCwQi166JykMJxw|xrzX6_YSt-qZCaSUx_>Lu zs_rRPUPwzP(aLfz*UTEs%Q_fSmf6TFvM2HYXl8ZjEL2P3PF&e}7uIHYelt1dT%D23 zPCku|uN`_J5lodYhBc5JrP!v!0Fgj$zl>;dC{~hTHo3SKB31{r;&866@2Ka0ts}I~ z*3=1q&8Jvfgix&kUXJl%Zk`-fNoUXJl>#F7tXB1bA*b73jp^5#fT;L}8Uw89hhrV? z6IGY@?y$^=RAJ98EeYj!0GmbffO|HYtX#8XfNnHpOF@=d^Xbf45UIvW1;%1y5i|<( zETg5noJ5n!jVfX;!w5AoDH+Vvc{5K~O?%|ekmm6SRRb{@uJs37gTm2T?i~wPKuZmV zsJ;b56a+ZYa}1HWiYey`Q!&aE@?m)kWY^YBAS`ooGr~Q;cTDLxbW>LC0;4H7NhEU| zq|-5hMrE4fM8G8)iA|dLql*T@dyqQ_XQXcn<1d0!5naQ9Nkjv2L&g+{13)KvOJEAo zJz@r;HPXV`1Yj{6GlG2(iyM1|K(i!2SSW)kBbJQYw1{wzFf-7CF-oS0GTL|`OtI!e zBzAo$>PoClzMQ#8%65XMSk2LrSQ02xgF23lW~UG>9MK$fM##vL)-#iHu-N`-<&*%i%a@T5tO)lnWLPFx9`r%7^0?9f zqP&QCb2X6;AK9(+%q1OcWwBHXk4TiRm!mYjOKB;W1Q;nGFTATI z9OYU+PoaCS9wt_5G zW=$lifG{QMhohPxt)>{pdjGGJ>I85|#Gky@zBB+%+X*kP?|vh~`PDCfDfauV2#jxi z_uF>4zZat>f8B#4CyW?091e$Y9~4D{VObU!&5wrz-Gj0QC)CVvJRZ^1+(=myA3b`F zgs}K+lWo)L)`YPPEI#bJPe3-`MnK6!Z!hohOWECa1K^iJL#XP^wX z^Kp*-cF)7zoh@U=@%D(D!vSZ@0_Pw&`-mnYeG3F_rM8JV)Z1G}=SIoDH@Obw=86aj zj^1KfJZzGvSm444w9au{j#!q(=6Q*uJ1nBP@)_uik?nApCpIJkY!(G%WmTq5m|32{ z#%N1qI+!F3S~P32e)KjAePdWg3!7)$jZmY-_I!`+?LMxrUxw~X#)(Hi00hSI$j#Xf z=Vv=Sd-e>?EZWpHFC(lQ{B}g-(IU?ZMS)p3aJaq2&GYB%(}ZU)p7VqE-;eYCPtZ0U zhb8b!zxa#s-}_y^6aT0G{r`dg)Ial2`y4|8{5S?Dimj3Jf%wP&&;L07fxrLnx3kO3 zSjMq8>uyZW+*|Lw8|UX2JRD|x=}Yg#um9Sw^ZMpx?Du=T`_^0h%a1=9V;OpQ`5F$l zw|seh%LflHe7oJ)_kQrhxVrZM@4fR5zxTrr`1s>b;=QkaML+!T1AO_bU&idipI_gM zt7T~F9{=>u{#_vW`0a71hAF z+DU6YPTc1@o6}HO@rYCIfrn?q&Mh+(PMBPO)qAW4B-h3)^SNbpV-Tmea55Nzsf)yF zoUCT&IwdDxf57z$nQ{tP6GrGHSfQNU?nt{mh2gnT)ZcQEtc5+i*vY|@(~|4f%UDm) z=~_X4O0D`nQ3ym~FuRaMZua_ub2LYn^2ojZd5o10SFSr)btQEY4X_Gbg)Tq|Wegc2 z7z|pUXg1;B{MY`-?*oXpzx1~MkN&pbHI4_jmp3o@@yDO=?s&)jejnE_uj7M{KH{g3 zKh?AA7x?PCUyj?GBkykSa(k}R;MczNr8wW8#V1cb)q8J$NuNA1 z(VsrOu}?nznD2i1E&i6D{7ITM9u5n3(~i4ckMIBR`}kvj{NI4FS)JbK1uQ&2Kab;* zOY^;pd;A~&-G3LJJ$r)hfBZOp0QhU zz)Ao+8o58)69aL$y^Z(3_x;TeKKuaII`{ki00K{*efAUX1I?xqtIJt4l&DF0U?fu7}}OAbYi5B#I*o*tG!HDgvUIoUvviymCAw_|;2* zRpLmvmj5-@xx#TkFj}o&IldYgpucioykbSKuA~gL1iA7r5kB%@QT*5SXJISyhUHkv zHPM+k0xPCF;)?}q4!K875v9Oe>zh@f7*?%9oEnK-56$I-iFI=#k`19TVFj+3i8Z(6UXat)@;5Kyj-nDx-h^(dOcdJ;zK zz_E^Asuj8SLbRCI%P4dTO__{gEoJ9sf=WfOVE(K%G!mVOfywtMbQ#nQ z#`??h_n4)l&ca|uSZ1%I88In+f+j;(gEd1(Pb`t=NIO6@vvR#EWqUIUVmE^zbOt&b zWQrz3Gc{9VZ^@F888);q8hW~Cdjr*sYLc1MC$bYX(YnbujhZIXL`_}XbZTqh#;B>0 zXAL$PuraB3aMuxAqc#?{6?xvMT@x-EebYm`i99pd*1)aA3lld@w(ru`sC}2t%+MQc z+lal$jTtYD+%{V8;>OI(#Ac>#gSv^EMr<2e?=niFLB?p^M3ZPnS*NLopk^*LP*O9Y zXI~)i4^w_`u;ifAATx={#hqm7R?WKyrkn&&2e9e#6*nic0GF zywPlJdKe@{gi%H_vPqPnFd~d(db34I-5_fby@rR-Bz1v}A&?s>Bw1^LE@Y;a$WCFR ze5Af<7)7zK!rb z+^^(*sff2);4KS(-Jk~o_eQ@b;2w#c821gj5V0qH0;0vxKER&Jzjg}kOxVh~$t9c< zgBy?&Wg8}@rdf_nguo`M6Od6Rpm&*iFqoxMgQ=M;E#E=55*8DElR}(OR!P*o0iw0+ zZe%vRQOxz!>UnPEG&8ddDPzvxG{~ALlkznwGbM7TQLTw;k|enz<9f_QleI=}I$Q7g z=OA!urq-L;L{3fYjp~iol^fn<)TW!YX0~l+y&HRzNi>>TBip7)U8E^EnXwxr6M|x6 zx7J8DGZ~`ydalewqnXLNNiwMC+lI9!iu6Wn6iv*`A!D%T`Y#!wW@u_?E%#kDpoy^7 z%J9%&Om9T4qq*)jGgvFnvk^`Cmx*ZBU{-rfGc@Mf+gi(iW~+5s=xUG|CcN77n$`Mi zLSsWS!CHq|&wYf3M$7%wTJ0^lCrZL(L|gYY_Al%)29em9YOh%L1w#|iPJ2i0RmS{1 zR(qnE>c8jD(+tLr4nvb+vfN*~8M+L%uK$!0foXZBQDdiQR2Z9DkS1bkveu~H)HYIz zEoP9ZbyI6HHbZM>>?CC7Mp*;dM0S&UZb#85$_$;2J^xIb#MUI5WSxy&M9X_f2C*r< zb|#|UckZ>weYGL6dTYHx)^}D@rK*`8**e}{xfNVT_Op&wwUKekNy-1yGFh|gBoz|P zux1Qt{cjXnx%CB|>U?E0qWWs92%R&NVHq-=ILcRn(;FMs7dI0MIH;QHk)BUWXM z2uHkp`V?P&=Sy&aA3pmW-Lj4k5ZxMLhehXY=` zc#aXkI1a>+rMIWFsmeNHUNR?U z09wa(v*B*P(|&&uQqa_3HBuWOINY!9-KVTYkhZZYx-7ajAv0>7 z|3ZT_4vypTNH~47op5z=kMDiuE0{JN53cU>;{JWy-5qpubAyMkzrm}^OFq51)`Qm` z#Krk#jCpW5+}YLny+D9J`0zvY?G8=E2S50L(-_O077u%Q{gTIJ_T9eQ z|LTA9zg~QV|M0^f{9W&V|JNV&X;Us(ltUaf1x{r0U#Uk93u)43mh>VSXnu-0ITD{6Js)}gOQ;?10y_VFC)hiEABi0J^=Sj zbailqNTI{YxVgE;%e%un9zOowzwhrind$lU=lI}*kNNnc$C#RMJRa?|v(bh?d>v&1TZ?`0c-S{HK56m)Kj!{RfwL@%&kIS^UH|zK;F* zUVrw_{%Pzsd;HW-{f)SH@5=AyV`ePD;_m49=l|e8AF~s$KYAT+zwvekR|Mni?A#wb zc);h+o&rAjkN%_oD7M?}`1k+){}69JdW}E)!4L5t|LH%2o4acSmc%cB=;g{^mVsr- zVA}8uA#saf69o>aiP1P823nK)wDHz0miZU~k9nC93VZF*Yw%cdx}h6xUfyE%z_e=! zfQQ48^B4>VHk*lkGJ@H|i7~4I3p^HvL4_rB1Q!H3G7800giGjVg@+)Dmmh0`By>0& z=tvZfhhrWyk9T*z97pB}EOh3UJ;hlc6-&1+n32yeeALpka_f-K_!nK={QK}6njzkO`yh}a}9DwW=pJ}s-|)xJnxTkq-b56mUX<<(m`BEjukD1z^SmUmR?nJ z0GU_Hi@Oo!tQey{la^e&=(Toc!*cyhSebw8Gf+k9h>;i=PcC%^pyXOuMNWEhyaI2& z@V zk{4`vhDSzLR6Yi<^7_J0n;>IJQGR4wZT)PF%=5@bM_>$xd%z>F=cv(6jFH!RZAh$} zc>2jxe6P2}y8fre@QUsU*0@-_Iso|>!c|VL^tJ7$a$u+UT(A# z=xsgV)Im!LD9`(?n2^RC)z!&$SB@O3#!?-W0j(Kq-Ma|B{sWnB+ z>oIA?)U2o)&jWXWz$i|A)TG$j$f^6#>QJrf;|nVmi6@pntNE3M*r*11#Z*>PCeZ}x zJTk0PDMBMsh-W$ytq$2!2nj0(dQH?Qi~Br82ZF3-Z0$e@sD+aerU+NKT4381y@w_X zY&yIvaMpqo!?zo1+7Q!ZYF%nOQ$Lfn9j$GsHigc2!D$<|-9&755xX6Dz8%<4BQB<8 zJlGz`o6{1HrrF=xjOC5Zvb@u0f1@48!*kk$3){SL-t2O3cD8T2*sGoItWR6ow1+Ow z)XvXj`>kxVV>{cCn+?%>aI=T;Os(y$ac7Nt%68UlE43{xw$yH-re@mq;J!s{x@@yy zv_@-NP5a5()SI<7^=S(0-PBVBw6>9H(?r??!-PhlnXxgcCL-NLP*Vzh0!%GMofJ2i z2Yst`l{pEtHsOK_%edA=(U*BM80m&d^M9pULeF&;5^1s|94*zKU#Cd8Xt>WvMjM_cI8#@d6z#%M~onraE>}3U*u_q5yA5nN)}{`eb#d3g{UmN$#HIsN1FV6Q5j5J=rPirF zQJW^V31%%rg>qqcPb2zJHqZxvK{UW@AyhO3L(sy}f>b08&JsEX!Du5Jr5WG@C=4sS zM6%=KgK}7+TijHplNHa(h;myGz;jZ($10Mq z?&%aly_ml$2zS8i9GM!yDjlR@VIVo!0S>_2b0UJ}2(Nm?s>Vu8T-D2~8*tz>y~yw~ zt{_E&b&@>QORT4{)p@uI?pA1^w$`~d%Isq`yo@pnW=$M5IT^lAUV4U*hGU#eH&ye- zI{gp;M%Ls@K6_($mC=D^_HM zS8eTZAO9Uk=c>;n877@R6+4t?-KuwLb~FQ@BhMB-$LXREzA8?AZ6ch`;OYEl)xRu} zYpl+7nK7DFZ~IbljC{LWI5Fn#^a~SfD=lznC9@TUwx#33ak029QQR+ zgIGohZaIZ`GFJsoXc+f_4ByT3t2^_|v5XYhFzRd=WfmH+F|c5qaw|f4)=3^cb$xq{ z&p&(Yq^NP^?%pMyJ$)))0?$5uf{%XiL&!R=Z*KX<8;_!I4KH85jQ79)1B>w3OcSmy zFJWf5*iLxx@B#K`XK200_2D+)j{W6*eERqaGhblAZ~3i%oo`xBUEJN>VH{^$afT%M z_4y7zdi5Yg;``4&$8#6nxV*&6>zBB<+u&@wiTflj&9EF79PVDSFT>}T*LeEbCpg~T z@bL10G0*t)$)^Yhj`LF8rYKEZqmJVv07(JshO@IXY&RXp`G_$_#!-zK%3vQj29LM5 zxV=5-a5(tlOSCp&UKSmF;myly3?H1wokr>g;jyeoUviKtntLjMk$;35GRIhl%^Sh2 z28K+eGd#x=SW}D=WxKZXU7L7zcIIQ5vCP43n=oyfQHJ94Y*Pw|)j!e7F2JNV|?kMR8V zxqkUC|0T6X{F6WPGc05yV}yYrA5M{6#=?L0pZTZ#<;}Hgvw=Yx2z%qT*W;~s-oS7A z&A$Z?9=ztSzx5X0e)G++ZO8TPH6}97_vgHRaSacT%X{}YZKjyVVW>5l5!cV3<8XV& z;lQ(J&+z>7r$9t}^ub3w9A~|F^0|B-qS=N{{ehqR=Qk5+hr7G0-}`%i=3jYm^%~|S zaf0i4evE;6j8_P{a?%FlBx-v-nUQ^<$WE82a#XwokJVHOttr>4Q6#4yLF}KAffQSE~hIuxkRQ+SY1OXvKVgVR1cQOhE*Va<#b&;mf2xFNh-%fI}~zjL`eUQKP||JeWWACX7k@rNH_ zEDN4|_5_b!e_vR|(G!07!w+yg9`*K{Z{g!l9{bIUYX_CsDiB}$%8&SWKlrdc z{_L@S;zxhn@9vKASnJ3EW7z4tYK|AUV(mcZ})U4IL{_THDnOc=)*X2jHupFjB& z|KcC|7YGkroS*s4^-CO&OTZ&8&(Hbn*>eZrZR+?vKmF6oi)SzR{`cOGx8Hm#zVp5B z#5ceBS3wee+T_6!$j+D#kc?)^J~@Sr43m1025ZVJIz_MtWr|I2>Go?AH*FhtH#c#9 zevZrYbG*F1M(+*JpTF?Wo_rP$A3Vh6*(Jn=)(r;pP(-sHWFwhS#u3464zv1+IrJ$Y zL}os26g@SZ>-Uzz8~|owGMqji2kveT5yMCd%NSVZB|P$1Wv=o7)ez=f=0)%&d+sZ; zVPq>xXii!+uG3xY0={4 zueXL;sd{z+KjBic!THMdffZk~)F)iWq|4O59zG&gr)DBCw6<4HV~%yuw>fq2*bgc%~$?1@ulI#X6oi!^fQL%=tMumIgG)0ip z?SzJ%TtH%SDH~7?g>pD~)cem4W~!L)lQBWqRji{AYt7Dt-jM$bZsbfO*wU} z9Qx_tj+4WLD|)1r$Xe_@selxnfEvuw@zk1Xj5vQjolROD&uBu9vDNoPGpO0geQxCf zTv?atx^DG5(&eS3YbPqE39@|VI*9&-Zh!rLu0LDw=DOZUM>vyD-&zWkt-^g*mW5h6 zWLhite3TGk`MN9@$a2fq-fr1kZmW~9LVs5Wf2-GO#Uz)NJC6B`_69U- zXexKQ8B8r5>}Kew&r;5Ft81CA_i~Dpn3U+zbnOeKCiRAHa7%aJE2p9w45p^0{CCJi zwRBpBBzBVoshgUGFomp%y(vZWE=?9_UFaQZMzbE=G}*R^6M?Of&4itSU5u?Ewhh{e z+F8V&#LnpZMxA$X-@$!@&L`M|MqU~GqH#Ph^2!3|O}b~~!{)l*#LFIWF7bXdJ+$D% zMxIa9xq)X!oprWNH|`}~2-vCN+@yV@ww;<9BpP={^-lF3Y!rK=^>lW(-pHP}HyhKj zOd2PXn$cuT1G8wHvc5AjqZ!oI*d-W^DSG82VkSsM*=|Zmb-5~Kpqh|I zOk1y6hZ3R?d8@K@0VbJXCe_O0Km#PP9toRd?6Q@K9um<_n7U*QX@709-XdE1e7SAu z(r!jHl3mnfz+|CrHdId=Oi8idPMLZJT8TJD6>m3 zE*hr2puLElW%Fle!41HP#8#_DNp>T;ppA_A7$CE9X<;qWbxU!o@LY-?cXw{s48R9(J6^+GD2qRW-_Cu z*4WH68P%J$)}(EtCQ41fq=1y>>5b94iCdHH8Z;@e@6_4pzK13g_Rad%OdCn(4V+}$ znAFJLnrUjZZ4O#+qS(TBB|9{!tg$MQbK>(agl&O;aOT0|H{*#gfTHHmj7| z{J1%}l+40%pp&hcbxT;Cv9X!atVLr(qjfXNU~GnRd|x;F}W?=(`m-eAhtp;<$-mg`2dP!l?>9Q5hZ?zt-D{v$D8Bd55mAtsYrYv|T8 zSCEvMSvt(A)?|V(HNu*)i|DPXi)yX0)AIE*FroF<)XiGf$StQQ)UAt?#MTlP)|EF0 zn{`tyx+XS*tmi!h8LcU2FIxULDOl|$LG`Rj>t2{EqLuSJgSsgcd)#7u+EG(`R$4%^ z#f`6;5!pm9fx>HoGYBgIeGL|6ofE7ucMa=#yo$J*{#*6jSCfM{Az>3ER79wnTx1kK zEUIo^RSl}(mjJz92dx^bX~eKFa6NrQfWBr2m8iZ7`l|~YEzM|!pIh_Z81<&H8f@0G zFkKK{XAEE6);f{;>JQuMddT1FWt3gQR{dNECeW%0Q=z5llsK7%R%i{Xc3%xdD~CU?Pa&sb^_Z;Zpm>GONeV}vLuz7~ zMKM@IZf(WlAPfC8n*^lw9w;Lc@&?J^VHGM=Xpu%9w0eCvj0#c~qHej$#VX8WDP*S{ z9oF>28tLRTSgVqZ z`EmGhp8c@Qc~TvY*87PzIkLU%l5=W}ZJIDyQs}muDVC%AwBO>Lx887fyh_vY)qE1( zmZRIQv)hE{hXbyUcL)N9!yV2q&d~%c;W*!HfN)$NZV_W4fEW?6%!|)4;&5E>;YS}} z_>9}z+ZbN4#b3zFMYydFTB9&+dRqMJy04}i(c16n0WzF_?Lme zJQf_51utJ*6cZUOJ zU%a*EG>+f4S)An!?D=P5eUsxuQ8da;cr2Lu7BtBsM^00`@*qL87LpZkrFtllQjN^QWC5{6=5V6F(ELrd+GIX?%oZscu&8 z#VKT|Cc|5@8j`I{heJ_*`G~RL?l|K(&ybAsGQ*efc^MePu^bL@cerM=j{E1AxZLmY z>oaiZQDY-9X@*YoXc|5_06$-oa@MlhD@=YHV`Esk2Wwup$k444 znOAXt{aGpRQv$`W)M<};g^A&-!%1a}Bpjs1Pj%`CBzZqtj#}5)dBJ=u&@1s5M#~ZG z8i#F(G)M(%#mBU4Vwa$pbNfvvEJEUG7_9}=I$8~FTfIBhxVzPUXf(hQ1z^?uYDy8S z6txs7YRuaz2cQ+&rJqBj{k+pxUn zxS`luhKx>@J6CT_MzOKcBnfI1u<7j0TI$E*Mzp4g&frc&mo$l*nz%9YOt4A9M&!Au zT?cnYT^PCb#(QF%3$bg6OU8K6frlM-&WJNwyl%w(F1zZ6O9SuA^k~!Uir^lNdr_AX zue#|%(ix3s&1^E$PK{?4Z4zw~H3d1D#b%OCN^Hf}WUW)(jNND^IVE(1l);K*1Jm9E z!i>t+xgs6ILL-OJAh!XEDZ(*~jhz-U!PsFYZ-q|kWl?X5c!)%Ra1_qLl~eC*;*dC2 z_<(g%W*|9(vc@({7>!0_P@-g303;fNVI(bc0h!=CZY(&GP~!C%S_@?8i^NHQLD3Pc z-Ww-?dn&f1ohzbIya2E>#74$5hM$XZPVrKW8?l|kZ7;+Y;JJWvVeApOPt&;}&SK2> z`h0wJe#8R>?rY2smM5P+@_BxJnddjKEDz|*73OiDjyDv`8}#wO5Elww%JG^Z?kR9z z!7~VFGCxyjN5&b!9*l|NMxZQWW0B1fNn0ab0L5mgZbP!)DMgqUE~ zrEpz)2(4LW#P$5|V`}OR*$8ejby}FZ@@tc<(OR?UmST5euV_tF&t`zC8x)q!9~s4L z+_@&HnVB_NSL2lJW?GXq5$uT?qZz|YYE;?M5=+x-Pi>^<-k&vW%lg~RaH;Ic95iWgP_5Og+y<*N)4RN@Y+23L&I89XrsD%5P9D_Cc3 z)|ujqHGZ03G6!h&#{>&A6R(_qF>#)cZR>kVNlz3f7 zZ-zl(c}A=IBh8WqmjOA!j-b`#gJu4aRMC57_)3R(e%E!TaTMmp>+EWQW?p$mT$@NI zUOPv9zH+Xv_aNbUf37SZcxF0OW{|jQPmFOKSp0ZD0KWb1mqP0H_h)AqF=QjR#`T+-tbtCn-hhbmb8I4!6q)@!Z8sPQ9uBu^Y<%~<_e22A=tC%d zBM*TuZw~AdHdBkSIF@CGvEjHl&if9>WpIc%pSG~pvE=knu!%;C;RDO@5EA3|`2mM{ z;BdGbz#<|sy9kex3p_0Etpx+yX&d`#4|uq{YB?eLc8WD{pdNn*z-5_n^Z`-6j1h|u z-5!o~Uq)aAMuLw65py6r9O1UM)_0q9+{M(>OP zHq7$@YRF0?h_l@u=U3;k-)_RkKr?esK?p)%x83XN-o2n4w#`Gn44^kyIM?%&Ee&oh zTmfRh7r;j%Zi2w~zx&T? zQzroXPyXD``!D_CFThBJMKtwrAGmjMVZZ4c-+;*FYJKvbAfTi+iti8(Baj!^=B31?h?z5w{?_AjAdRzq1zagQyo&hPtozW@D4 z&!0Z|3CNaz_^1E35+;B0dxA5pItj+{e?;pW^O# z7bF?s76|;<*MA%zeE4De;PDfG^R?Ic?Bxr7_VPI{_LuzeZ+s)3-M+y0zxTfWp17Hf=Wk;`uZCH~;m26G8C7gV*rl<#R0al09fnxSj7XACCkT z|KXqflej$``2PFf*PCxX!sCxW^pG>srCmMXFY3>Sif^WBW&G9$*& zfMSH_*!MuV2h+Xl7@5}_GZh$7>PzmHOpH2Yj3vNrISZJoK1i1{fZ<#`{N>A+V8(ox z8y+0C^8;I*p@9ENia;&Q+BgHbqoyu5u`8S?95;_e}Q z>D{*>0gEqzHXH~GGREP+X)=uCoT=rR?o!lDMPZHB!%5U`gn#s}dJaL8!!uBFVVzNjG7Lqw3R(n&H5fg{2QA9Ol06??dy}F{}_pI z3vXE_yUQ9Pq7@3s69pKpT5O|ePL?KiKwu5wsJ`dUfHxqTLY)>uX;eUETY+7cnr>IL z6y0eAH;CvU8zX{bqLYc82b&ycA@1qX2{e-47`x!uBVxzUmRPnikF$v7oFgu{EN$G~ zy(z>S?aepZ;hW#ZjCf|v?`a7_^MJUCMO#eKq1eR;3vxp^jpJ#k-9=!l)Td<;ou(EZ zQ&6{&6oEOIizep?!5AZa4SLMb z*F0f{BFa<-^$gqe7zFdY5#ccam?d4L>OHzM#PJ1$!|G%^h1{~GF(OAAfXD-}PR@=n ztLtfA`k{EC&CVTh4Cr;OfjR^HDUxagH1=#VBlMjQ|G{cyyi*B*+E%g2u&>*nSKqBT5!{ycM&jm&12 zBbtRTc{_|WEV;u~>m5aAQA8jjC^g3jEyo2%AAaV09hW(;VrFtg#4F|SR?dw_U|Hyq zHMIoHo?{Hx%K*l}MiY8-+#Y63Q&2G=nHC3*hdEknJdQg&fAI|4X=BUq3U|z@eq?5N zk}5%Z0GsW^{pB7v-#zeh*UIS|KzOvaiRE}epm_w9Yc68(A(QA!B4+2q?Q&d>ZG#O* zo|jz#+JwX@j6fy>h9g6vGsb%?fHCMJ!YMR{W=fvy3lXr+kP8@udLtH3njj}cEZA(f zxIVn((FgWtm$Bbp@Y#!J<|zx_ueEeV6Yces!E+Sk9%*Z!OTrhWSHhj{bNH~Hkr zW4!;}kMOl0d5^EXc0a!PtDoZD%^~hxT;b)-OWj=GIAZX8x8w5{&kz{?`s}};bUC{^4!VNT-NhEsz}3nMjKc|s4)Uz z>z}W+sD?LG`wakONm9>!K zF5Pr?mxzG%14MDhqB^FLL80;-&vAZXv%{-J8pW0IOPEtL-h@Hu!`HE7A?D(#S z=yJfXEE=sxY!$OtgpJh^TAOxtN!?&s%c_!s`KfAD9lZFv8|eOLx9BD`9*yH2R}&hj27+#O*Ve?tMBps?|mPF?o=YH;=!|`}PZyVq3 zH@JTB0!s=sAu{~9008dYdw}!(-hckj{ydsly#1wj{m=hrzknxCp2XSqOwF=JO|Efn z3i90eTP6_>>piR`DNv0;DG&p#aYdKI*fDK-wAQencJbi;C6Ds~&uR>KK1CWN3#Y*OQEJ@%z(KlhA>Q)#5K?8m&8vyyjntqM~#3- zggD?BNio53K42V|SVj^z=izXlG3G&Mz#0)^40nuqW;jfZj1&MslBNnp^2Sbc0Pw+T zy%HP|u@Lj@ak!gx{p>{&2A9Y())4bpVmTaRUKY{<7=g_+VV))|J_7)L!;kzJI1YI7 z^ckk}bFxp61wVWKY}L}E`agnu^xZDg$z8ZQyVP#G4~&SLczQwZ_FMU~N{f?jd9RtLGc=qz;%^6B8%?@Gxb4m^; z$4F|cS@bEDw0gdDN{i2*ucLwqXeD8;oa$Q4Y;_Bl(2a7RASy7k^h%GYwMNyoj8nnC zrZAskYgi4psDED7nCe#Anygd*&&WbSG1o2C>v$nj2!vU!F#)qRJSblEBx_wlWUy*f z!Nh776odnVxp1#*V_p?IH3rvWdF6wzoq`o>5+&SbAkO;#R^$q*d59Fo%W9wh-A}Lg z>X1{L2LM_kT3o6zM?bl1s$!~lSx)*|&-sOeQyFUt>4Pe0{d99DTXQW~tJ{EAu70j3 z+SSdT(J%SBHENmTmVtGBQ-vR`jRvwreFSVcWDRSeVRFm~TEmJvVU42eZgGGmc9Iw}k2x$4fuzoH=EraIL zh0dCMQX*nt=q=8gs+006~T>t#pXw=%QZ(nwALnT5Iq z_XIZrw+eI`_D1Y1umiPi;g<|tTEv-vJ%ERdxC)O;L|o8u2KXfg&ZKdn;SX^*oGoKH z=k48Yb9c9&e)1b8o`^LDUVdq2lV=VUt zKd11hOAlMqC7>&kXJYK-*b%XVw5MXHZ0>9TY!GNCHhhALry}zxbCb{wtsA|iiJ84w zkW}(>Tr??H9!5@bFz3)@;f5BJvE1emEYcm@268!;sbxU45g8sXJ)o*P5UlgnCxOQyO8lp(pi^wo!T{V z-^dFyU6^zs@T?)9pGNF^^CajigC|t)y)eH-aY8 zHW`Dg_P-P&f!sN+g61`EhJU?(E)j%{QqNfGJ#As@y znKl&6np-D?7M+S_2{*9TG%2T7X$;Xq2=AHU!FTTlufWE$tJN+jn*Xf z_3toExiDEXbu(%b%|x51ZYFHN-jXynby>4!EiqTJF47V&){Rm#2F1xJrx*r~nj#D% z*}P8B`R`Ga3s?~#t4mrc&k?fD6!pqsTnM)u&AERVqw+c(;gw8(vFr~?y z-1uplVl^GT&O;}t{A!Z?0v!aA?<>!VJcXUI-fJidd%u2WJ0T81&*P_;rew_aekn#^ zq*Z!gwW`!*Ei6pbc`|*Xc^<(!+-;{b3(HcKUtvx|N6{PnWGJl$PhzXIAoc-|Z~XW- zAW=W~=wpJ6i_I>=2jIqK8KZADft)Z>!~lS3TyKfMJRjj6(OTme1LxZv2w=ZIQ=9tm z#IZ08_>DjI8%mE4H0xxru<;Q$GhYe5*k!~T0^At5xx2;TaN{im zsz-ovJRa#WFy_F`iyPct-?-0n<`j}4C$npuGiXs9YLnq&e;JDp(%Wg$eOa7E9d-g7 zvxm=va+;3;Fw+eNBF6AGj*c;Bz?$eBSh9y2>zKF&T?|5wpyX@It-84Yf)S)AevLu1 zptXPu;evuL*=Pc$ZfNR!{k7M8x8H>YaCLQ#*Is`x_WM2D5rdKOW6MlP{^0U{oKI&i z6;q@R`DBB2k6wmAF|*@T8C~uJp}^thHUh-me2d2)erQ)0_wn-Oi+KP2@7URP8t;Ai zYXGHXjF6Fl!9xnqIq*OAAN_yg$!DJn1ZH0_sR3i~YX@dEdlwI|*-r7~ z(`VzYH{M2X#_QV~lE#a(i|Bo#C~h`e1b~k|_>fd9wM;={)u z`rXYTZm)0o*^|!*r!PMA@Bhg^VG3V3eE+Zi(LeTk9zD2UMO$Vktj}qNRm2ylD77Zl z!0_i^FL0ybTIQLyfWErr5R-ZIDgJ6n5T@IYt!`z-r@?5k*19asB8pc)crAI5SF>V$n*zp#~MEMz5l zzQ2fPFP=}o_N{OIFUDB#|M!M|<@fON`3wG~|LVUS zf8$U64xa5c`0*e61`f9eY%kAYt>HVr_HF+IKlgLm^eN25=eIBYaGcZIU8u=1766F< zCSW(rLW zIXM~-6KtMHk7yD+g0HqgdJg|8f((KN_gu3OY9hyg2NDI(yW@<*GRH{QfWk2_7T0Pk z4ZzsA!~j5eFyKpMce-qDsN@n$J3tO$C}7S}D2XrvOX6hi4tIQha}8_6G7t{uGMtm9lpoE-vN z%SO#S?hqc_o^3NTc$s6`bRLe!bXBCSmqc*(wC2w-+cJjdTy*aK?u)G32w#Le;9?n$ zci;O;WixpH{OQxz-+uG8XUjZJ&I6s?CO}kB6s2 zB(xaC7cA~!R?UzH1}h1E6)l+z^PFNy>jF_i{mJp5DuTSanX4ry&pqQ(%O_Y`yw;1gt@^Ua5+mG$#C3!=d03&rd8FwEj$0xQ(Ody36S=hkV+rw= z10i8V;7FJ`qBA%QK{qaRN(vvLCWHrrgXR{@h=dr8QUrOVFP1(PQnmtMJ*tryKq!m| zgi&;pA>7Rj4CkOi^4!?Nwd8l{UInguBQcVc*wRV}(rdR+c1$f015=}{hFz-VOFC>4 zyvsRA83kntwHhQ_N5rIvOhhFof}MySVrTd^hNhsp()!pU@hUq6c8b_~#8p^ad&E8| z0I{KCLW~`kIOmw}b3S<79WHJ7`SIpj_x`7UU*~4i>>vBRTAqB4!=u(>(nh99R4|+v z;Z*p7=vrbn#q88GxbLVjLv51SV%0)mjp_711l&hlZhj=VFx*|1gIZ1t z^i!v|~w#G=3)2sdLOIMQftT!IUMIek`R610F!GeZPCFc~$gI`||P z5{nSQAO_PLK_H8bW|;$;qqw8HBc#?DjL}1k9DcJ1aEL=AuYyN9e1UxMmK9)^L!@wG zu^bCdPIXhb2SHf#i5~MZ(%hZV&DFmSij1Ukf+G)d(W2*4~Y%-I9aU6YpIE3|SuEL5yj z8=h1PHiJi!;mR>V1U$TnoQakyfG{E`NV7aR5NZ&e5iRw~L^9;8YA3YcPkqPPO+M@EF;c z&HLAtW~VZZoN7@O+xyk?RTz?7bffCyB~a&p^%}o&oN$afS6NQtkJYW8XR0+6R0u?~ zbl1|esjy;p!BhPe%%+Erbh>+ZHAzbEMkOREY4QRvLazjB0@ebfng_2$rV{<>*}$mJ zoCA$H<(Z-3qiV{k*XrB^q?>>|9MT>-j<%j2kSX zNbfcD!@7T%p{rbtOsum^-d`+B)_|qXRoo%w8kP5_1$@+<$U3J~4Lla#aCi$4kKTF1 z%`ApHY0~-SMc5~g2@F{4I-5Fu$;Q%B`n_=i#)8%@z{ca<9j0jmU|_S~`SEbz)x&dM z-M>=n6LEV81^kUS9*HoH@Eqz)ZzKT3%NX%4#JBIgjt{S&aoa6HZzCHxy&)6FMYOho z4@bzPCQQb-i6eY0T*mN?ZFF;Y4S4W47H@D4cs^xmiIh{-fXQ>=`Q;h*+daZYXcp&~ z5m2Og9Bz$G5k6uLR@P|*(VJpK#5`s!%TXS~QvgXYs7C}bd)k=Xh!}ztBx3|*46o7b zv=yd-KF?59XU-8#MDN5rGUh}yLV@Gm0cV#N+MVy?I3F3J-@AXsdzbg|XM&7e;!@Np@9*E_kg)^v4G9O%s{jm?lsU<=#x2)yt%%O?S8}m`mg@C zfWY-FTM9JAAS3gfB(DRi!Z(RuDy8iG~WN-xAjv$^;2>G>H$Ch{PWoE zH-2$;uDjbidU%W%GiePUe)=)L_SLWA;_@(*_-()Kuj6*N=SLrWh%bNnEAZid z{o=W94-c{1Z{r(Z|2lr;>pvd9{_EcwzxYdk;itPzKeyj?+#Tl=CfB2|vPg7GPAjpd zyH{svR_(5AHZH1pTdao58jr5~%yZBxL!hgf;%2~-Wj`UXWi!J)&yT5Xlomd4!o&JH ze_L95rC%pq1p^IG&DG`D^eXY>B9V)o)q$Coix_DqZy`?t(yQ^i90iM4U4Rm-)^YB1 zW#S7WlfM#{m?Pvxrp}RwRI-Zuov$A&bDcUZ)|gQuj-A9F2TsCL6{Dz;#_GKDgcr!8 z731RK0)O}q{R{u|@YqtC|AxQ*w+YJ}bKzT{`Q-1+0)OT4|nkD>XPrg^A^7O>)*yQ&-V4N z|0uuy6W@r7d*|`=*|XSh_UhK-=YRgs>H6j+cAFhHQ->c9WJJ=YTZhzQ_$`g%Z~e`` zDgNqT`xQQU@)`d2zu|vqf9&7-x8k$MpJLkeQ14b%PmCW?l>?_9rL(b2PVJZa|j9Y-n%fs zo0~(-^TML)Nv#5%XBWHm%(q?r?r~ zwv6HJ=Ec)xv%iwWhymPOzx-0$y!&g*@*>MDDrFdH|X04NESsX@< z#0js$f@{d~gn3x`)rc=(G+-s5f5CMT=^j@qswXjhEvgJPSyNoQwTqc9l!h!9YfV~( zXy#UI>j5xUw?Z!5qr!$PQi#pLp6ZU)I1uao8ok^P$wxy^)QT!RDL-?rk9lja?*-*> zUdJJezpmUq=&UFT!g_W!Dm1sm=vL29-cGqEuVcxG zY&_K@dhW7OmtQI#aqhWsasmkMiCtoiI7fxIu-rkckTKM#ammd&<-{VwSWUOpp(pqE z64B`pTDk9QY_E=xD}!I9<29^JCIiP(&i`63B8NH|gg0epFL`@sH=#B8%%D+?4yP#-4n_`ur+$u1Po)rw2w@O{88l_@UV_kNv7{gw zO|*%?-ojhRM8uhdg@MM1t%4JTbBmaeu<1$REf|wx>_oeS#SX(w2Y*eIzhO7mF;9Ju z-pD31YU#w?AlL$I3NDTpiLxh z6CE6#i!6`^+y;b;6N66C2~5uD9N02R7n3FSg#xCap98+-h;tBIho8}7lg=D&1Iw1q z4H;*0oQ-995c8NAem^4anaIP(k7Hiusr?;)H}*gCPsPo*e?7+KnF8w0pjsPPWC(~& zWN;5+262;YTOH^;NNIUt_-x{hkB|pEQkfhb2+!2Y=1b*?8LT8GnCF&XHoBBt`ax(S+wCt`A>!69H&M%5?%Kq{40L?~i4 z=SmTo{lVgbnXK?XTwKL?<$Sqev4tbax7DlM7fJuN77%r}@YPuU*ghs|?Dcqc$k;!U7 z03$-iz!KHFX({IC_Tu4bzO4l~tz}h9q`{%!e#tWsgBDDXECU#s>ESUvX^_6w8CWHd zoS;tYRO1(#{QzC0QN~CYPLQE+f?h}%boR7H5UwDj56@Yc%)zywLi7~-#BMo*2SyWw z8i?}hBG|}xp>o(2jf;a)Ll8{?IuklntV@toga<7$;kQQC@^q^#8l^zcOinVf`JI*( z3y;na9D^2J;4V|Da9m~7tS99*hNYg4RTNFlRuS&>b)UB~5*rg97bih9r_9sPrqli% zQCJKsgv$v_m}Uo$LJU?elCM?_t}enft(d&3w~@%Z3KmuE*Lj?%?;k0=XPJ{i`iLl2 z&?=r51~y6nuHR24!cJ=qCcr&)gKU+1A_-TOBi;P)D3nUouUd7FGXCVkmc#LN#su4pNt~lZnwzZcA3p=4EovlBT9m zQDk2wcuGq2U!2+#>oj_~wqa1!Z&8{`pu$?Y;#9m`<$0zlw{cebt4pW8zXYtL+S!Onn0khZ(VvFuQ}x!etr0+3x8PbO49jgQoL_ z+nWP6o38md2X+-POTY(Pv^3iqfMw3JLZ2p1n+bkgl8OaEW5A`zY?^ekxGSK+35IZw zki|w_$9ee8-2oTNun4a!3O)g@IfZUkQXlKR>y2N0YHn8yt^!+O)>A%ky~r$zygi92ZxQh#ON*0HivvRyrv=C2?S%-k=-YJ|J&d5Cr_U6{OZ1b?bm)yH;2U^ zz44}OV;IK;9*e+2xz@CFc<|r-cm5du;6L~KvDxoqUKX_0G%vu_<$b*Or7!6R@4p}S z?%l`NzWOzO=eys-&GoI`{nESf;YT0w_WF+f{=K-oJmcMA#@*d*?4~JhZWsOFhaceW zH{ar~{MxVJJMX`bciwr+KmF|Uc=7aeyS{sqGUM}S&ouSUW`;ldul}p?yZ+|C*+(pI z{OSMipZdH0w!igv|A`-d|A&cmDl}(AuDwF7YfKnpGL#+TWD?7@szqR&&aXJFZ>cv~ z?wtMw1FR`U@>-XY7QjMUEvKejB?7`&n3-zLdYQ{tljtbJUo|u1Ro9AT;0@L$n8CcR z48O=TI^n*C$fb}`Q3WMXCHr^{xGM>%Ms&WQ?5~#o!Ps@Y|QyczJt=vx_ah^X>2A<4+#r+0&sN3>Y49w%-%J@bO0< z^Wywm`|UP9`TTR8pP%XVH{Jp~@X_PP{Q6galmX(m{dK<`aPaPMtBq|i#=<}RNB*_6 z8o&eA{qC?JGJlBzaW@|b!2iI{{Q=Bl@W1@azZ|=ZJ+AIu;6MBm{{h)L&-UlJEru~i z>8x%@&#`uqW<929^4=B6x=tsqWZYWMJ&&fTX}}{k+f7{EzrxwsIgf`se}4TE@4WpM zZ*Fg30bX2Q`F6W?GXWuNH`}lb50diX2`bRc!qB0_tXN1eqh+{5c+kT=RX^4&8JTG` zp7sI8@bH0%5gbS7yet???!OUE496HAK9bzx?#>8|u^?ghp2J9U2(h4YMH0jyuEDzD z9GMXv*%kBSz%n~-ZeC(J&e<_r7PQu*^$o^x!ONQ)cu~-}Wt*`3S^F zG)_3gCEc1t9Pf_l7|tPU#vm{+QV@rEUT$w*n)_Hj`}`^BBdnzy{POvWA3NLZkbnoT zFh|zW>oi_+(rN>1Hi1shn3N5iCQuI z5hp%)4ix|kDiHG|&ad1)op^p;_^H*MaPlM+VrHFaVL7C&LY$)9!1>JQ_mrpna&EI+ z-Kge+F}aVzNwi&)q^%s)cH)1(DydWgaaxCdt1kid2(~FXqXd_EV5u^tXP1R&z(&P6On4ht5IMni~D-{ zJn#_JAS!J0iRqfGN|uW&0~7NeXqLDXv1JIh382-OazPjw6&T74_$&_PimYiQ6s@o* z6?S?WgH9c3<#^_?ywwy}HLg&fjp?ZBYlEpe{wpdaf@sQ6QPh3AUNc6^pKpneNu*L< zt4@Mur;+IVE1mBd(1sjyq+n{NkXVJ#>Yp=ct^|1~8w$(_)h1-rS~V@2^7U#|Kf}+~ zCYsVB$S%kdFVHN|^(sQ$*kF=d=5!b%sU&bp&D3e2(S>F!uEet0*92jrHA2JE=+aHF zPKwkdansRzgsef$5c>}74D2A9$X!Eh71$BlSm2@o8zXlF&JA&9~KQI^b_%%wN(nzeb;POCbY|op zBAmIs+R~rV*^kq(-&Y?Ua9P!Hg_TMswPP3>ghuGyE{1>QEN5J~NR8T1H|5 z&Ezc7lVmvpiD)95$(oF`pagXpJE*3J4aLd8Nf~j_1a3rbN$d@APH-pSjEELkF1mEt z4O0t$I1PV&8uORiy!-~b|D=uO%dsr4aak@g#+Mj))DW*5aYgV<6K9c1G?K6QeUBrbZ4a8F_K3tT8!%-mZqc%S+P>2^O`Ilh60vQFZKL*T*crHOw~9EM$Za>C zcj3Gn_XgWB*aci@@e6reY}l^4*}bW0->pr?^~$P?R1=%9<}EX)DbnFBBhhlEmzfBt zv{Fb&8Nc#GB5Pe+k$21oI}IkQFv?SadbT^VRyQiNp*!STx0!PEI8 zPckP*M!l6Ltb)l&Q$d}X26DwoU=m9I_`=yHN}vfPhr8SoIwfjFVp>rKMaOAkQZ?C_ zrXkf?VI>0OXYsVlRd!H@bB=nyDN1==muz^f!ZS*Ej}@0w?|(H&#%i8&mEmPA+_MLs zcp6q9X-&Y|YCXwXcD=&ugyD*hSu^>vK3&ZhsaGW@UZ-56Gy%mr1X0G9I@>9#IZ$F_ zR=#;pjN+%49u%2SkrT+3jfM65Plr|JgjM@KZzVgOe{+&M*{|2Pw{Ize&CD97Mu5|1 z5`uW~@;QB8&?xk26Nlp+1Hf38lbKEk91e$^rX|@n8@ARUHS})0yu3o6x`%+NZ!qn) zbOgTf<3AFpMvITdP1EYA!g77!^*rj37dYFTVN}3wj0Jm}u+Y&9y)=&n*M|d^dC}G7 z6+!xOEI8iYVPK9ij<|h!=XW;;hI_aN;G?=lDKmOCx;z}=h%ql|-k~zyq8Yp>)+nphP!7=WO&4~DBS5@HXTNwIg@bAq;Y30v>nU9k$yYkK>L$oYrh4>Z`|Yv%%DRn2A2Z$Kph5a132sp5x)wee~X8 zIpA2$U*^#UDJKy>?&bB+u!|`YS)Su=si=X{{KkMtH zhU(#8MqX^e^!bbH_-B6h_vbS|oFkv*I6vFr?JvKBv&##>i7$WU%XsJQNBH&ce%If7 z?{ncN`^Ow&w zO*U?>uW9s!0sQvg@i%dEc4ll^{^dXPul_63WeCUP^%fYostZ(8LtD`|ffa99g$)CU;lOI)X3PAv0vQH)hjUr{S-#~3Ge z8i*9|Ya}pl?MR04n&4WCF5x*6P%bvCkpDIP8(yf1ym^=5#nF8=20#$QvP+HY8~>GG z`SrhHxtZ@#Jp8_&`6q;C`uKw%9G^USYTthUyO_G+_U?f9fABrLeEvM{?r!)iIe#FJqMf~R9{2RDC z-w>YT^L?7||Nejdd-w}~;m>0;bhh1!jn4Mw@mx+&zai<3IQh{X_Wl<4^F} z=TG?G|6BeR{OLdSAIJMY_%8R`O;F%+7wl7bYhV2u{``Ob3p_u&z}eYeM#UHl zXu#Av`ZS@p4v_496J14!%Q-%Z8QK=ek(xd+!rIXF)+Ie2Kt<+v5Qb`Xk)k9c=%`TTYTsU%b$lzrK%g z%;)BIjPE{s`J$|_)$zm12`ooJ;Y3C`IueXkK$CL4E?P2-ro{8a!U%!oB+%2VY+ZlH zsh8{J3_#^PWT%^J0}y~|0Lxm0*21WAmbgxWaIEf&8a&J}p$tz&6w@3zYBW|y>!^Cl z*Y0M8Ev-2Z{)+h>s~~<#psJ#?#v9jq5Y^elI__Ck$t?EP<^U3Xu@>8-P$vPXkQPAx zJ6E23O$5X#v?pEe9;-NxJPc&aO>R8#g+PvSovfV(4+ocZyQ+<=xQZ)ha;&M>BSUSX z)^XO~)0NEXK(A+mICU1hqJ>%eMe-2Way$2t;r_}UUQV1ixyje|LphVZnhUkx3Ra*s#tf9rt^H8Na>lPD*CxqQ+!RR^A${K^8q4w~z6CSnd~fl z*&t$LrY#qAV!-cihcOi5OWZAnaa{V#_*8Apt8 z5Q`Zn(B_CZG8PYy4q@?y8;1wghlVeXWkEC{mWjZe-s&L8g@GBz(fZ;$$Jn;U=FSbn zFWmjyJkG-xUk=CD=exV}h~-SdiN5T{;chcu-^dS#@o+P3#&8`!ea^E_KH=uxrH9n2mb*-f4;<1&eLo*TjN>G%VHbfa%wK&$iWEk2C^5!v6aF4cK?D5CvEU} z{DFWMf}WeS0C5}%`nZeW81N->G}Jv1ia}SIz5f4P{b{gmTXq%(e%}~#uC?3K-Fx4C zefGUlN~I(#Ez`(QD#{MPlnW@LjO}nZj0vcsDZ(~j2PP=WR8Up{vJJuxQ5YLLa1|;j z8i9lw8VR8WDJ7*++2?!tUcUDB=bXLwT62z3KgOK=F;V1(DudBqHn_Mcf~_BLhqzMpnxphvu45LmuHSLUl5us)?$>ZI_Z1yRH)j z3+8Nfn$OJZRuY$K7)|MeyKiBB3d#(!)?!zN>a2DR@X46u!Ye0tuXLLOEks< zH_^CO4Zvy|ICnSkklj=|U>5QK_uAv`gKpidH9Cy8jM^qj34 zhln^8TAl7p;$qQEI)hN3g9hxpNhfPla)~z_*C(|9jX)I{oblO1C7w*o#f2(00%wFY zm?lA)VKfdt)=~@YF-;-t7u|-BKCG zD=m?yDO}?stF^OS(d7kEV^lv{6gHkr)SQjj!iEhTf#a6vMn@_Fi-zi&OQgiF;Ijt6SM9l^HPHC>1g4>4J))Z=pekioyA*`rcP|b2y+9& zuq|qFxw-b<2uFPo;I%7Y?bzIe2e^W6(doIsq_$jO9zz_x|BOdnZmp8Xk>JxwLk{x_ zZ9TwINzexuZA~=FXaj3`WFWPprS&$ob+ElituO?8JqQ;~1>Hb4>pfewj=?vTaM;Nh z*%pqt^FKK@M+ zO%34sYUk5@Kwd5|ml=QWrLXwo4}DB@f53){JF7KbdbC3x2XGj$T@0wjfs|0@8O4Cz zeDKBPC0P&HAj|yZG48$n7B~t|9$aGm>`LbOfZ`S6T1~TP^TjcPX!s1mYegP1B{fS9 zf<6;ab0J-luv n;s%1p`!tFbg1>Oaz$A9KvX&3>d>6wZU3$AuBeqo<(iqF2*KN zLNyVnlVOZkD`^(%-6|Naq^Px8sS}e5)~hA1s{<-ndN8J*dGQXXdGasgOPI^dGy`_?*A`>es~PS%3c@`2GGz|HyxgGVf&=Rw(;xNTiwv$YCzu{b#=$|LGt9W6VR2 zXFdrg0PDpX&%gL?eBpDyVz)1zlTUo|Tk!w=+kcyv*E{?8$3G!I^^-q|l#?4x@-SeS zCJtF$R8Z=KmtJ}ax6aS;wbx(6>#x0`w{KnGl~=!tSHJdNJoof-x=_dUeom)(0ri9b z_&@rG!zaJxlbqZxUis?F<9f9{Jifk$8c?mozSpc)MB-jF5gE*C^zu=%Pq$4}pWLI|d@9&P_=u6E#Uc2F?1_qE{(FU}!Z*`)lS#up=n}N}y z$uxKLAUmT)Mbaia)_3c^fe~$z(7bM2psBU7W^F)14X?Ro71NSjWBUr5m)aPO-uRA< z;b?8j&?j}qn~6b8AKK)SAzA9q!rmF3>^lnJz{&ZEpPrt;99V8Qe*g71 z@PQ9}&>!7@=$BVletP=?M_-KQop=nqZz{x2s8ywyN10ZtHOLa6vr4mZW+Z;Z`Q}pH zT2P<}%?*UJnoG5cQmQ+QwYX1*nFhmtcaYtF$7w$c!Lo0IuoId1)xm4VL^svQq z3l7&i%yYp`2IL`&3;go(aU2LiagH`8CdHCc)bGX2*6X#Mot(N?$NqYc{b8b}jNNjB1laE zK-R`gY1j9L_knkMVm7fVKu2xN{2pE^jh)h&I?|^OhGTKuC%PT{4F)%QG64F-gc6>O zY;2rpRD#uS-tA)=t2KzM4ODHNucED?nErPlx3^1*U_b|6+t5{!ci81b!=sJm-G>W7 z`ibuk5tJN*Hp5t;eg0O}ryy9uwFm3sXfq<(nAYMq)+CC?xoiXB@RSJFQDcDxoBKwo zkQxKXJIlMV_LAJ3qesxc4OFxTdc{?Y&`xPdYkYq|?6sM{P5tmLOObQw3 zk`g=xbC!d+k1AZM$S9PBS6?cz7V1JMqc~PdY=p8VeeJsc!GIZ1lqm%9(x*Iv7uo_Ttqzx}t4e(QYAH(pQr=yEJqmn%GceC`h)oz{DA zpH6SS^^AHsl~PVn=2Oh`3Z6B^cp-8SbbfO9xD zaNm$z6I=<>65s$}5MmU{7+Vxa5hg-K$V4z9;()UdDQQX~Orn{YRHdl8IKd2|1`Cl% z=u|?5OfA?hflLfXCUHDCC7DAp-uohy;#M3P4RAt=I zeGBIz5hH{v)_Rxj8^X3~Jae~&&1IZ-Q?kRXZoUvhRXWGZhk`qI$alS){PfSz?>vq5 zzyG_^0LYr=X@Ah^>Iyc`>eG}l&B?2cbtxEEnyVrBAJc08L$y)-R0lW=z zFT15SJo|;RpAV+B9R!i zVUrxt*~BUi6^REB1XU<1l2nj1zLgLlp#=m}B!o^4ifE>)if|BepvWM~ z1x1zww@O($^aSoFVjNYt6u}0RGlx8rlozSii+Z_REHY09@w?pbKct8G18VkEx!%9u z%KS8{JKp-R~0HCnd|GDGeuBBBsU8jkm(Xz`w5(jP~@ zBn2EIErC`b?f+X?riv<68KJguY)b@Jiw8kI5;9dJ#XDjM8N`E7Pqs}dNZESx-YAr$ zB1yx>CzGNon$#r|%tDTdT#{T083DG`g$hPN>>bIGMYs@^AruC>5^^EnsKOKV7I+I; zE4Wt2N&Fs(aB5;H!cizIAva066_Jw`c6?6o=|p*Y9EOWL3>RZg+eID*m6Rn^3zC%- zfdQh4Owz;zB-_#JpfI#)(gqP8L9abyhXkudxZ@3bIO-Ygs!(q^DXnMME-P$-d%ga2 zYGfoa086$CGwM-+RB6m-wzHf^YdiHG=-vlDN3r`2L%a?9>5c4yR%d&+`wMHxo)-kP z`lgX+x;071tNVaIRC{()AGgnsW7XVUdYWpI+DNWpDPrDj=34#RRI+F)*8s`celPw7 ze|B#liV{5AW~|@vfUeNg?h+Ken6zn$r+Ce3VFA+tk#1`!H}-jGuN7@r>sPvcB;LV@ zKPF-Ida_mV-Ql1SBptm!s(>hx=#3w_@*Nhzkxj&AM2nuc)Y;`kSb8?~Vd{mmN3R#t zwRWGI4NMOcj4@S*JbwK6Su2)6#b&z^uccgHUK&A8`vc4zUT;7VrPhO+0~O+=wD(F)kvI*pd78Y` zirsFU1|xaWV1a>Kf;_ZgI8QVxDKC)2C8UYpsWQmdR#r zw`;DJCm3^%=dPROQR9gcz);}?3XIeQXgp`7790)-%(MCZx8KH>zx=X2b@whS3}5=f zmyn0d-}N8jw>Mt@I^OmC3qCHE03mg*NO^P-#d@>$oQFy%?mc>d^Rp8Wz(4qrAI9xF zckuY(CBFRSFW22+hgxPleE7iUI^$3zz5hM$o>EQ%Apf(U{rOMYD9A%+)y7_H2qyzW z40)~f;Iw|70y~Z&c^f)55@q~A3qxa^6xK=MT@eHaCH7CEWxutl8LjV;{ao^fKinW9 zp#--UKa9_ipy zn?AZV@TE=syvc&3IloDpAVd{@GXdxfR<=z(f!eGI?Dhd2s|MtI)M^~44f$ka8>b?ayuCt z#CA+8u;PKLo1m)noO1){^cvpjZqv;0L{|eURe~uu*Vzu!E(DYUnZ4RvyrR??AJtN; zS=iyE0*9fR*BExv4aL3IFi&t7z+ttbTERTeILwC#l5qmH21!>EYAq~Q#k}~CGj{t4 z=8lNraYItb$q6PeUd9C$i#4vM35UZ0{m~|A!N#pN<_rv~-7GL`6O9B{W7#&d5THc*f zI@)@4AItVYH!i6ii>wY@x5vC?EClQJh9%o&oZ){Z+B~WnV_F*6sPC{a>3e2(m}562 zY(Ca~S{MUDN6(fuT4PoO@~YO$U<0W~V6?Ky|G)^GXrMTx$w-e|SCe2in+iJ?UDE5i zD6*S9jU4T%+BCIe$z49EXdLD46CO;DK0F9u*Z+kkC7OgTL(%~MTV7ZPs!eX#tj#ZudyrtfHw8nguYFfnGqo0p8MVj5OHYP21W*^8P#swE@%3s)YfXYdc>R@kiMD zy6~Hc296Dkj;QALUbQjSi7w6Vzmo)ViXuSTz^L2tNE;9(#<`h7_aC+^eO(0n6+_pU z>%{wOO}92_u!uI$zW@7XiPiVgOxsFon z8dlET%7p=^AXhBqdA&Z|Ssku6@*n)WOKdM-|JwhWqwn+L^6@wpTjhBgvAbUR<40RQ zzQ3*4yRlkXSSg!%p3iJ5xlZ$Gv2qIaHOx<~))lO-A$CUk*4#G+Ukh~w_z9eAah?F! z5Wa@%(#6&)z7R@+U}OMyBZWgiY8WV@LUloSwFHjCtc@t!Q5^}ZVsAqk6&0h3~5;a7$H~!G7>(T_{yD2!j}Ng!b>QxKs!aXkfsLqX-$-* zAmPjr_Dxd)&A~%ONz${Bt_)ya1xb?(qSTaS5Xw>sAvwf*rBE;sGD_lt%8i3-6|4vu zMPx-{E07aS*e1ap5pHwV^OIqCYPp}ETWh+L_lIZY>hft$ z@upl!sX1IAnN(cEvCNuLMiPO?j@vzjJPD;zVp1az7Xh;{K9`7Sv*wR^G@&X<6q-PV z_@JP~!jeI$k`y_K4oYNIF2pekIEZkSgi9gUNw`+gQ3MMm7o;qOzD?vRDNmHLR_HP* zw~4YAkrQ#83S}$AIwjeN$XZp_Np+KiCy9QMh3iCY6*x`s6A^3$ev-)3A<0q&X9ICt zQ##98Q{2%=Zx)e61Re+J_Xm=q5;xUmToU*qlAvk_M+0~QLDzQ-^N+x#wpxM$l?pxf z<$45-wUKYyY@@06g4E$h5SlH|OxpK&t8x8EmI=4f@EH#fLXV^pZ={&8jMJVH9X&<& zA(!|q^hT;_brsx0vflv3BY4mhe%kVh!joN&HjKSR4P|S@ZaMs@s+VqA$mnmh{R}&n zLJ8s#n_s!;QN3!7Oc9>@aXo|B1BBi&h75w9D;51s&xkV#s~B3mC$&zh(AIyn-p3jx zwgdePk8AOpd(xt&8U)%%Q4Opy7*bdLIUuY@5@W}oJ3*sy$syW$s~RK=@AqHhp7!qz zA9!gschry3b;lUTYl4WiYa4yu(F##JNwg1N8U~`?#ue?_Bi67BAgN`Zy<;%I)~g-4 zH#~N0=rpOLOM_Um2W9ot?HSPOZ^wSOf6ibShXqp}U0meydI!n0oQP5^peqMNGeD}k zvD-I76bSo79u5-@^Bh7+x*c}cfP;CF93mLTOid#MP))1UtA zX0d_;SmXhwiek<|bJXrY>n%c8QnkgU7r~fE05j$~`_<)@ms&CJC!6XNVdAAo1SMBM z+&s~!$x|Y{Rt%c4S}gJS`WkMvx@34zQW0AXlhYwJkOPO26tC4W*Fv~KRjR>!Dh6k9 zfroAoWr+#Xwl~)Eo`~w;%j_ zKLq#cwG(8F z9g@PW;_>AU>*d@}r)YSynu>3g3hx0Uw}R3Ar{H`znZ0toZY zwrgN{#7FWNz7g!a3b;0Vgc=*ZL@;6beb%Wjg>%?Tdf zyN}mie;u#C{sxzeCFt~f5APFjp&ClylYIA!FXHvL-sC)2JpIhmeDdTGucrgni;?GN zXE3YS?e_TiCq98seDgQ+?BtAPo-t2*&};n@f8zg|4A4bR*v|){39QUC2o}SLsT=?R zzvkEcT7JVfehmNb|LK3>Fbp_3+2Sw%rT-4s*L$3uUkC~y!Pb?a{sePWJjI+{h@2CK z93TQ_!{ifI!+&+`4t) zr5cUy;zrd08l$#|1$QTd8BrZn2ffl=Y7Fbz1l$8m45E??By}%`HWP>=Ob9nv1*{aB z)%J+BV1t|lC02AoVp8>5W;d$>Gt9Np9hM})ior&MrlAEOxRzqbNnr-mT2Uhi9cmVS zW~i7B1*HUVTdct0sB?9%MyrOhFOl%2>XRLCvRt6Lc>w@7J)um(U-L*huc;KB4{Wk{11cd!zz5VK<-=#A#DNsql1t`1n=S7LA-Yyjhp zw6B5IF^%j$uTdaF0JkRZi~!1(5!u)(4aQ~*PI|`>F%+#WK&fqv5xn7zRqgGNwReOz zwxPt)r>0xAw4tW7i7HyyQR9wiJ3u-^ooozqzX@y(*0(^cWw9TtXS6~;ey_=mv)>;fEzP6!BKws^%wBS+o+T1Sdv8jt@r?I0vMFSAw zUg+XtBK81ntdIy=V%M?8du&4#A>hecBh`aAaichBg9z=)D+Ieb>`NTVdMvEj)LY$Z zB#Lf@waB*bSFudV0y(eRN^HWZQ345J$rqc zk7&(XW78$Rev>^=*+R|Ybe1-6S5b6px}?2P^`lJLD971XXQcN)uP9Wbq>Aw0m`)H* zBsRxSrXV8Fh$>0}64KFnD#{d97rIczkmJ|Ji;GYZUeZD`3nUX|NlL^bh=y;oQ3=mN z%b<^hE#Nu?!0an=S=0T5@HM?I9KNFYLaYq#+zL2iDrYG%v({zV?Jky&A8s|(C4cp= zqrG>#uO$tg@;4;Dpachv|M8oFXHM40kCg$@k-wRq38#oDVS4i>nj4 zCa61w;Arsc=)G+OMG5RcCYon=?f^6sdMV~kk65H?&P1XRG6kSug+f;MN)v~0KpUDF zkYQ5egz*X(Ns0$+#Dq~mL{6Yo!lkKn*i;!VLbvL0k$Y2Hs_b%IPlLUBFpk*{`0L(<`6AND#fMgOHw zd7nZL%jB!Kcf`q7YIROtm6%X_-kqjQE5+1D&I#Z=d(O*T{al4tPPuEW4-xhu*VX)z z5tejlPUoWm2PfAA4s_Ibz+6emP6~y)>IRx7H!n~aRFeZ0F4@Ja!;={2b}U)TAu#Wi z004jhNklMkgT_JBR@4IU;by6ADYr+dL#+3RP!q+eeNpQcq&hsRJ<= zBV7p$a38`09*LC$B06FKDGXoh703nMGohoijtRb2l|5mah!b5eZ><*T^zo-Zdr_ad z^C+zrn>tNKrDdm%;j3#EseSdu=9kKyBwT8)3I~IL^>rD%##yKI3~a+64wR} zbSt76UNISb67i|oW?VZZTexZrM4AmX!8idl1;jL1IYAxrYIM>uCsISe=0O(+#64Am z2`pqC;en-un;gkKN`aYyi3*pNcWx9-(Z(AHR-w@w+t>(~>d9&DN)@AtNW8wf!sx1! z+)>Rvr9el-NoNbEQ@FZ&7@#`MJ>s65Wl$F;ctj8bpo>JWNq2~ukgS!mOh)-C`8p5K?%cQc^VZ5paoqc+ujtH;@4z=n1s(BK? zTs${B4?0=nm82Rgi6~kmVrMPNC5n?K=5W(iinhbH-jG{5F+q;1%jTgT>7~u$C9+pq zdU`Ont?4eize=Fry}AOMjb3E!L=H-A-9O%`sBDqOQEmkbLz#fm`h>e2yu_hBm+D`TiLLhZd2I1mu~gw5K!%y-Q;kH214!Lu0gNo(fTBf;!8R( ze6;RS03}F59?DU71x}i0C`5d*w#{ zo10Zk3AF>01;e}5e36Tn5WZ4Ga)Wh7d-c|DS!1Sl%SLM+?X4mx>DWkxMNlKrNJA)U z2g0I2B*TlI?j+5v60Xjq8JAa&J^}zaXTN>>g4L|f`-3DMSRJUfhNedpS%^fzuFegt zi{3U)7i(+GI30HQ_=i90 z|M2OjIe+O3Sd1gaq%f#)>1|B{i*_sbekzqmPRb zZiXjbquX|JwOsmPH_PsNhxfks{rs7q`f0E8fhmtX9QGI%qZJ4j!4&h=YQrawpTtl= z5@;nXM+{65%miSCjuZ{`2_wH++-)@@IdErA~JD_EU1y zRSV!XMtxR+q_n9*{-?k8*YHRG^FP9Iv5Z)GNlKZ0dvc0ro_QKy`|3-uTKM#x+n7rA z>)oEuKmP*1_R6bR?Pr^ZS@N(z*4Dv6!A*?I9Zb ziF*Z`O>oDp%sRm>(7)b4c8nml>|Sd$+g6WrOVPrV!@;vDLBggLeQ$4J$|O;bR;D;& zHr;AV9Ds(qLfHJ<5xu-_Rzh~v?SBan{9(Cky= zvy)T&v!DLy4}I;`H~&3zlt1u$e;=wi_tyvP_B$SSJD=+eH^=>l_wmMCZ}4ir$9lWM zqlXVM9riK9tzrH)=D}~@y5;vDKEyDLwj4&h@y6Rw7@oR)$CryWpIlwy>F1u|ul=>( zsn5UoZcjPk^7_h8&d&U;2lw>Hf8rlv$Qh*+hzDd>tC&hgnI>3`JNCc)^}mVze!>s_ z=#OH3a&E7`_I3RDkN;CAiBU4(G=WO$1x|x2ss_t2r;H>Cnlc=YA{L@Y&By@Usu>&^ zitGL4x6UqnTrO~R`Ox?K9ZH??9lz#R^YyR40#f|!;(}$KVYMO!o?yX~h)5xeFgb^r zgdd%wBgY;Sny@q`JtRM<1XyWO5oT`H-D%=|!c^VFYQ4KGsOJnQjxj z0{dz2gN9I4T(HmtrPBb>Vi?919^ZQno2TyL^z;<9^wI)=Rf2T086dD47gkEeY!$2J z8Yzu(d3hb4?=CbGj48q9LJkVigp>v=Q)#}H;w6GWq-6=P8az|+v5$R}`>W!$n3ri5 zH^X|n5lZ&!%gg6Wnce}Uhh2(`x4~Edu3-@s#iVzy^v?Kb;g0bf`Y~kY$T$xRtSD{` zM`OISw|6j~+4ChDJGzf*dKis0i;!S( zcR!jCN%uPRW!tb2w=)b!@j+{r8UqJxGOONv zbZHchgMhH|xB-;ocX!LXMrPG zXXX=?j|OajqbB3A1{`0{Z*vV$=ry z>hTgn7|bV%A8olJ3@i@fgw8^5sDQ~0Gu^wzjUH7LH^HrP!xHcIDu~ciYPa->!Bt$d z2on||Jn=ZRVvIVEQe17%7bOBiBe++aMNOB%hBXn{P>UAsqK2C_A4&p`Ymp$WsZH&A z3nUN>4W@o(0PTc?EM0o2Dv?6f?}GqJ4VSa953&fk3@}}YN)gc%aDI5-k^~b)C28|3 zh~(067;+|(S;(y6Tad#(K{7=&0SVNVI+heHM0|q?eq0H$R+lw_Ek(9UY}I|`W(%6F z9lm6#E7W=G6{o0Wi!$F)FDtF(RQHE5RT;JHH+X6*<`rg!d_GA1oxf99574*Xr0%Aa z;8gcC)H1+Is?(gTlmz1_OatL#t+uVDocdHYR?4c>d2L=-nCl6uokM&L`pVr-+_80d zuxcIW6l|4#0^*d!NJt_j>@uJ$RSv3>DO@n@B@)1tMH7jU(X$DF9Mo2)O3Z?lBBW?; zxlL^BzeaNwMv7%b+y?t!9i}3p3Kyi51Tw06vlj6IPE7)(%Lu_jgkx$RNDN^_a(V`s zNLfH+5q2;bA(r77l#<+%YihIyPeU zq#O>(_xm(o@6NsY!p%mnC6{@UGRO8HcI-S65E9x7Nqm}8xN;$K6zDu)n6`YaS zlH58tLa-ub5XXWZmMEl*qB6Fj#OUTDT}A;$%`&LSLc{Y%*onyzSeZa*Q*ImyaX@6* ziX)M(5=qBlHYQHORfB0g2tg*56gdVG1tuv@B|X6UWnIQ;`O$8y(NP4Og~j{?XU~NF9bNF;}&6O zbU9VGQ##KT*a~nWnQZvPsWJ;mv7yy!F zP8uPx1eNqihKsj1r4c}Bn>H%bmUq*80Mi~h-DIISa{vU z&oTuQQWcsA5fvsCrUc13!lko9hC~@uWl7;e$)z~QBwVR*E5dbxoGRp0$z>9(#Ia7o zbplTmTqp7*3r@uSRLn2nc8l;60vjPOlHxQ8Pm^G+#8wO^>VA@lQzg!5exhDZv*Ti@ zzFn-w#d;XtwM^+-SEpyUsKmVAvDtvQkh8SUB@wWSAmvMqAXZdukfo?mn>QbwPKret z7V{Oh+K}4$0gY7A&RT*{YhY^wK|8aMjmdqZglx*h>NhIXW+^BQxRi!3bO5~3RYC3K zzt#^l2|XL&p1QAku;hXRpsgNjb-FhT#$epC@v{PdI2yXJnNqM3f838MS&cd(*us67 z(1-**r>%FaY{u$GHLZ7|WPk5XW8uy2vRUo2_vsd@+O7(SdbIUd4P;_hlLj>k$M*IJ zrMKd^1<67h&fdZy8yon@0QJV?Z0!?c`-qOapeaZj&eH1hpt8MF*{kRb&5q4@ z^!q>~qOjZTkT;=`N00diR2`)X6+k)KGfHY0RKHHGw`B9-4;#)Hi-fa+HI-{jjCv0f zQBm5$Y0*fW(dWmU#%>g>wJR!u3>pp!cC<4NYm&CWgcy?G^02=H0K+&SiK6?r#&u*A zJWQCU*`_ihjTtVnNeiN$4mU0LTNk%+a(*tuB8yjxp%H*5yDOetT$uUfwUm~_1Pnv2 z2-8&pc6@$cfAbA&HXEJ~OE}=`G+-kcbDdER1&eW{S;eSgngmv66t501*jr(OASq#> z&xZr%!;Dg^%+rkdFa-t!3lJx)oN1V076u$i=%?!wEXPII>?aL>b&v|}86DR0O~tFR zmf`|}iEytnPX*KAfax$}nh%`)Aa0GxMu=Bw_90Gd4ztZ=gYGI$7lx;dRhSd}aU@Fzc-0EyzYXokL!+>GA zfN%hWNSdHc!P`gEFL#+i?CJs8H){1}n6aS2h)rj?Ki(mMKpI24EZ~4vt zy2Bl*nJRj9xS3luNs{oDuYMUn`C~s0Qc%n#Jo6G)t0i81@x3@ZJGTc9AKK}~g%5-B z>#w|uyLX<(X0`I`=^&*XJQK)^B^Il-kd9#(ZJKA)Qm|Yt{c~Ub62AWG>;Bve&+~J? z@;O{SzVi97=izWb@dIpftX5}y>X|!*j^R)L-~QC^eg56=f|Xq(Fm_{=hG8^I)*E|; zej}R_2sgG{@iP|BF9_$&Q0%A{mu?Hy24}b-_Qmz*(K5FGTz{SBX?`S%cR)W}UDyZj zof+1rmCa_L6F?=tew?bJu`iEIZ@>B8PI=ePob&d^+Z(VBZfP9I?GWu#2!H3qp^YQF zZ*skzZlHUcCAAN&aTqtisrf7Qv!tb0$061a8J7;E3D(OMzW@8b|G%TpIVad3`on*i ztf)_(JTaS#><@dLr>XAe9bSLq4cx!?Hi%-2W)$^h!_FG znP|ack*!z(+8g8@WPG z>N<{*xNQcjh9u#sP8C#|jA_83PB=N;`kkkq;*gSGUheqT8*k%<7oYcWvBa0Z@MUba z8!pBr=2~1OdpIqc&_eoUu&_F^%IfWIYxpHJwxy`j-9-(dNENR=j@wBWGm%)@W`@X+ zK&f8)cpLCJ#1qh*P|NJ4&KA~OPIILq#;-YNH;+AUDR6IgZ z+QhmY-iI>7i=otN5Q~|BJFLRZ3--ZgjD!ONaSB}d=Am=rcJRl3ul_g8FG z@%H{yZ@|Y^RL1*g*#h2u&3brp>@8;P_r|)8|1EM<@JN5{aP>SYX!^AY0d4b%M*CiN zHhnZCQNguFL@b!-NH=^LvU{+h%Z-Qt_l+7%<6t?pz(>6qDN-6BCCyGl+1@rlk`|ul=eJmS54gbii$c?^Bxb`eYa*wL1hyK!wV6q6#(Hq5uYu9a)FD6 z611)V8_6|79U=J(LqizcOrxC)qJS87fGQ~@O=k<9RH z&SJ;}#sIO>2?^5-Wu*z4{igQ-z%n9O<@kw-v3fS?4w8 z`2=;|NUaw4{)W9P8v`oss9gr>ThVCVDZ&JgH5E zUT2kBGp#7*Iy%Y<^wDcw!|Mjsmvk(JCQ`A4`x=xD$qmUff@h>{4Yr2Mn&5_z4av2L zE(uwPc!00qsPvI!R*^ALGmS%1ifEV?31v`lk&p(FlnD-0O(|fEBqE8#K&C+?1!%95 z0_lUQXco#Ko-e>n zxXpuE9m=7w?k8HE!FiTk-A={+k*DSYxKV`IZhL zmw=Q?wMsiwWrY$pn44LhQn}tQ_g9z0ROT})_0~L1%X+AHtk{JWy9Kv1x^IP8kT|2; zN+qo&k_aTjCAlz% z8xI-(4HrWYduz?{+P1^jTL5?5>cf@-Ele;WPE(l*ZY)R*a zhEtGhfLk-H;y(Hojs<`XVGEz;lVp6xA6?$DU;f-sUwu7q{*(Xcbn_d&>umnarpACoLini^oQnB5-EU#`Q-CLQITiDBKrRHlL*a>nr-FJ0 z$SH{vf@f4YSIS0{u2pnRV(s8sgiD%lD7s8c8z{o#8yFq35aCGIQ3RQkK}54ifaOF- z)P-Tu6xLOgsAdRJB}C@%=n;b`MH%uOB_)O$0#y-JPgF=!r9{pFB~d6&Nu(rUxGIN> zzEDIHsS1Qie#)Yfl7>gu02K<73MnG0Dmf?0kP?{?9x|$;F*r#{B&!H=CX+5^-qsu3Bp9m}%#m7i;Xv)QiC6S1A>9mG8 zWkGQTrTGAL&k&-t%VF*K53Enh~vm>_KXQH`_u4 zX@QM!6S+o2b-A&3?7yE);n#@}-s}WDWI^vh-QzQR3!H}q$W1>IMIgODQuLfCM_2SZ zstbq&vU#9%T%}Pn8afV@Msks6$=irRM+1X)o!D6Y)QXI-lVOT}#Bt0T>iwI#LYnQLy8#XN3Fnvy zR0;ngZCDT6`stq=fN3Lo_^~Hpcbf4IAv8h|!#W}mUq|hV3HKYeYdEMh%#5MHjQ+|+ zLW@#LRRDO`yWb1Vig}*=`uYiKojI;X&zjL@T7qh}8WtV|ungDMKNF}{vAep$*~z(y z(O>%NSMl=8FV(U?`0cX`tXC_c3lnqoYOa#7Jvk>3T(DRt@!_UA+c0E@Bv`Yn)T}6T z#i1HD%O#)!6ACq<7$8nDPeGU+vS(GelVx&T?{=6bvuf4nS}=PJI;5MqxzVCuF76n@ z7s)o84aS_T?z^RGQ(?66jX+Hl&Pqo$)M`LASamP8LL}7sZY6>{i&%97ytM{Ob)=aN+kc8nQHiu{Lqj52mo_cnHvUO z2T6GTg{SeJ_r3>!bFmof-KU?yTW`OC@t6fAG10(|kZ0vM+}Ph9SemMId&8;Q42tx2vlweC_M6;>p!DcKa(AqMA>H(!TF6{g25(e)Z)q|7TVv zB+bX+W`Nv;YR3e^TC0L||_wK*7eEW^JK3PHk_HX-?+&Vw^X_`1s6R&pH^0-yZE zH)FY8LUU5M>$qN^&J+IpfAi+br8ofoXaDIR2ORkP7k&jVJo}7X z+`8@mJ_Al`tewfHYjAA)grF4M?QyeG>&CC>gh5YrM;N3vGm-nLQ9MHBT&k$VLcGFqIfC3%=9siibdr$^XsBxfM(2r6QV8uZIpzhs4>R%cFX zfayXPm=1efO?v>qG7m^Y;w!E=9al(s;X@uG&A0)eXh#g3Que$4A;o4#9+FLmSAY zy|Is*w9vZLv4N-5SE9*aKdGe)4X(W(7wjF8G!kc)H^9FzdWNib`&bG!oz7~>8VJL#6NoLL2JQt5g#&KXtM}$U)Pef!45HRfp zYwYC_b`>|t+pX{hKBL6iY6TH`P!KY}?M%iaJ%>LI^?(6tXM2xO)x*x^SDpbiGJD=Usoiy+a$e25;w zv8}-D-s623(kJP$<`WXy=XwXItoTH5s>S^I=b|@i=A@1Uo79 z0f=^%KbnW?JG?zxfN28TuquWp;c3}CPc`0$^~Q`m2AD>JDs3PZ_B1hcU{jMcI~;9{ zbP*&3uul@ADg0Ri5{lm?NhCZ~IzQhibdmpY7xDZ{H7>WOqsv;+;1QOJ!zmQY!W_(*sX`kEq3k{fZH)3Jp6#)u`XjwrTd zsY|bQ?bEbHtt&bf+3G0!>#Y}C@$2_i+!xrt`#V#r;>a0wTsz=nHuH@G zr-ZD9vK7GzC~MFoq))J-$|{MhMP(_#(!r6!fyzXhFv&>hLdBO#4iYkm6fAbnRLSZ- zFhK1gE;}U->&Vn4Fp6SS=;(AM2~AKHqpD_rgC;D6R44~hLRTx60UaQ+6p^Kng9Mvd zDaa(2AeT-qlvolNNVcFy8K_u+T*0^mZ6ovmFGW@=DFav;d<|eNE?LDL&g8HY8V4)3 zDEq^@9`@&Mehcn7!KLi?@cqHcv={Rl3N{1Jsk+Szj7fcX{K$s)eSq}?AE#bkferaF z2kTSMA${AYN_zWEONTuYz+{CqBfYYgnRT9xrAmvg5qMqO)%95Rhn3P#8Dfxghu`+< zcj+D=a|9%gpeK+kQZ@*d@)FPyf`P(?Bv}}ELg-eYLlRj~bObO^JT?G1XQ4H!?C|S@{AQ8l*K|K~gnFXTiIyCiw5-q<}l0YK#7LZY6-7Unp5{7GZ*!VD$ zSU|WSI65&hVTh1iO+s6l`&!L2+?HN^EyJ*?wOm*&XTDx(k*(Y3DHCxY?;&J(1#DTDgGLTeNy+Zs)9J zW9BC`-_q=a;8uVOfu9mMQDEcbDIF&wI91^`2~Wjws>-c`Ye)nh3$PK1a7#c^QYfLB z>WdgI$pB%3GSVT)q`~PPD3TJGL_|aIBf^1_NJ?Pau8>S`XgR`kT=Yl-Zy}$Ik*iWt zrf8_D7|Exi5daz}p$fINXF_qRh~$8Lvxo=AC>~g!iYjGHf)wjSR23o-#F;c8_93aH z1Rs==MO{@uY6K)F)g_D&$s`rwQ1K z$~J+gDe*#8&P3#lf?JyOB8%S6qPK;9Hw({IxlMv|6?06^OM2qYCIg)YfT?qz3;{Mt)G78S1IK~LTqh!eQ)0H9!b)aa(L5IkVUWnnOhbB z!Y*H1Sw%=Bxe}sO0X0M+9ymc%(u7-t$b#C42mw5IW-mZ7$gzIyWQPDFj!HST8wGkN z;C12+-{F%@L@g|G1US(c!m0gkr-72teGNmc)?XW~mT3X%(iEl%H@Pu_z$_5fioFK$ z#<1?0E*)Tyo=MXI{9~R|MOT3aS*F#=t$yrkeM2iNkL1JJ2yIb2$8{2PDSw++w0^lc zzjPyq4vcGO1=+t)6S7+eYSdRXwd*2wRR7bW&Ta4fsBnb!8oVo68(`#oM-L!J#zx1% zy(uNxevh>u?Zig!wO}A+y#oo0ztrkLX{`RHG7c7LU{7eZuePCw^QM363IHChb!q^y z%?-gVENA*~#?ZX(2cov#qmwElOt!7@HX!Ofn*IxHGd$g1|T=q;cWnVj#R3mHMmzd@3b8DQW?r%&Ht0!l?y| zJiK}Y_wd0tFBo%1)==nXw?=?7xL4HbNTgOoPJ+R3eRYj_+DWnMr5bB(>5nFAFsbc+ z)KV~;15h1@0XZi*ls!tBL72E`LEmy{301^2?oLwSOtZso!dwb!0O}2qP>{u=wG{ze zOPHstcR-;n3vZEX9$|0_x3;oKahRHj&|%cpI5rZXRaCgC0%=GNDoU+F5z(x8`;E77 z`{I^A`}DKiT|a>Xm=80Z#!A#-xqu0g(lRoqQVZdZd?1KNHkPBUCG)T=6G0Wi=Yqq0 zuyI(>%;YEk=}&TzGaZhvzxFCmPFH&O&Mmi6SIV0@d{D+U-*mPi--3fh?kPg zflLvHW4T)6Js)^4HrrDOsqcUP`*6KK;QI1fZr`~b&qSSlt`(VzVKLz3WCJM$DXCxY z4ydI-srH#)`b9o?_)vu6U;FA;xxc!?beL&YtC>}W+qZr4n`%;+&A9j*f8%fbmgir5 z5jSC-2t>%kX10qL-5bHM=O>I)OYg7X!;8a2&3=cg=cZW_CZ>klTdprq=ic=8=`!Pl*@|NSh9{P>Y6Kn>D2m z2|o9wW&d$SH%H&baiRc_XfGdlr5f;#+L5~!p#&p zCe-avbAv;8cDlvS{PfTKJH^TxX6e8B?(cS|$$mP>^kVFb@j1Tv#%sKNagMX|Tkr}zdh(dx z^o`#rAO7%%JdI;41#{bOPVra&>R-dv)fJf8rXUS6lbADJUthu9s3Q0szvH*#^I!fV z@4fXFQd0Z+%U|P9{^Ur9)caf z4FZc?&mm%XV|M6jz@rBbWZLh{trbnIY#wSRi6%Mg^)wS8 zhCz@Qqm(kC><=MQQpMGiYj_o0UWXme<&!7!jhZKffpC2rNYyr zCzrlHy+s1pthU0Ogp!6bl@gmr6k=7v*UPlCBmBrx_7)NeXUkh?ptIaOlS+9<>T+ko z3W$2c7?=2(dpa_O`=Fr_N{*h5eYggOJWnAJMngjl3S*P&wdrIpe2>!6V8D3y)oTMr zk0E7j>OIU;!{`J=h`<{733SP8V}Hb%7_9of8GC??-FMF{lA!u_uBdG$(FT#70j|9$ z@0Xw#?sD_bT_Pzsvi;2fwxG#ll@4#Fx(I2W1?Y*^EOjOdj*SFkm|zjw;SgvGMgnUK zg6#SPdk0t=n|gSUHy?EK09jj_wjBdSTd!qN9IJK7Zu7oxMY?%34ym(d0=5kfe*??e zz+CG0h@SgW>=*_9_6_g_P{*X?NpeXtNcP)bde1&D|si0DxsDO8nkg*rUO14>aCb7Y_f z*WIg#6N3^1saeE_pu}>~R2C}XDw70~A+mOEm%vkLs?t(R2`6e_jFheNZ;}6fN7#oA`#`=KE+~U zcU`NDehJ#p%v09Fi%>iD%C8Z&V$xEpq4GXE~WTLvlZP=Xg(5l5>^t}sN)3i zjgTuU*MM)#a6;IE)m{fIf;a2~^-pfn+B~fg~3!92mtpC@G>MVLq!%p{NieU9!ZaWzfDg5eo_y zpsxuIB(f5tIXAE#zx^NA031CTJLt-fis~?D~JJ&>AS*fF! zd0Y0oZ9VKS%3PLi^CAfc(gvSrDN{`-g}E9N9c!t+kx=l$z;w7)fA0t2YHmJvt1%M* zvbkXX$cOW?>``C-x~rMPCKt2Na9N3_)eFR{YvgcgsU;Z;;9NJ(S&Q0K%JfY*Z zI5x%Y)N5T6WkFzsd4|hC#Yo6Vm911P6EOh3q+$T-!bMg|Wdu2r9FuAyB|{~NGLaa= zDT<@R$K;}oZ7u+k0V9P8ZlOsEIS(jd^9^BEk!0jR)+}VAXqHHkPXw|k6~stjAz&sk zB5a%%Bu6Djx~KwUd|gI5$BMEduo2n<)h;01n%6T=%y{mZVLn{JzU$WrKl5|8_*4JI zuzb%m%j?hng67xWNUL2L?Ed`)4~LZ=4nsXm3+#6%oc9Y((a@^_-Mbf~N$|;kXd`38`BZoQrcsVBLlWOA;HUFA1)a zV9=%>Q3a0j2g+O zxoM^{MMfc$hBy9@h}?KYStTWLSqg0=(j9869Q|J zTXCF`wiU>k!fz+?DTUvm+buD_!&>js>Mb!p71VQqU8vy<)z+BjtsVBu3}0p7sqFQ3 zHh+2)InThr#}8jvFUDVe{vDtC)alcAzs28v>rCd!2ebPq_O^hd;#kTLbSwl&!A#~M z$~-w{oJ;dY4f#hH6*nQAXtVqY8xJ9!PN6aK02?tQYDcve67GuTKlqL;lTP2z&X5Rl zhcrXH2GE+faC`KC`alllSckM4*=q|t7r<-7T;g@DdFHY;$vuyz*L9I|(=7~dh}aRc z0Q*L0@~Lf2@mdIASihjD7ouMG5Wh4o3qe@335tJ~X1ql2b_xc!P(nxjD>%9- zG!?6wwvMXX1&9Aj429ZYCLP<*rkZFZ97yZ+I=RWB{ynbo)@%BW0=Ex-dQar-vwL4B z48kU@9x*A^NDqAT!M*1I*zJp3w5iCGM-RDJ4H$+I({!Lav01NBs(Uqanm3GLZul3l zK3RD!hRtGyANau^;-CD}f6Bl8+dswM{9FD_{JHP>ulx`HM}HLNz#2Bf6G?6B%Cj%1AR)8LdEF%HrP!w)rn%xF(qs^r(ntejAoAAevfgvl>KzTuYB&aI5|7@m%siB z9zTAJYQ^t8e2_#3FJ;p6vs3@B-}GC=y&nF@zx+S^xx06s3e`zNN+Rzf@D1xK77?HX zTBk0k44fJsCk^{P*`8kqP+@ShW&;)u6UV$XYiEUnRo+vaKwVG15@+u*~ry>_aiS^J54oQ8S>9D-fwEpQ{I zy+p`a8j&=Pr#3YVU$_7mTLuKYMxcbdwVO}_JZV#k*eD}mxEfH*;59bJ*_sB(Lo%-v z{*#~jsc$uNES6jQhEIM%S;;zAxq9@3+wDoZxbswb{jE2--|hX&U-~@qFrpj|c=-0) z?p~3Sw5d4l;^M+Ls}x44KQtlHc;lPoTQ_ zkQ8N}sY4bA`B(nRUj_)|km4aX3kA6O)ssi&7N_$E-v1$g?+4$H*I#|vA75VKwb$R^ zkN((?;r^pXzS*piR4gfw+%08sg+jUqFC@I1Qn#yU;FANRjL0e|b48ggl7&%mdU}SF z%@)r-^OWwMT;a~GTlUn&E&JjZKaZ=+$5?N-V)Kk?E*K=ot2o6Y4JZJVl)~7+%}Mt` zl@ggp2BVNtLt_=$Lt>#5s%}6Hc{5R>%&D<3%^FBVhnabapc1FJ&!xCo1yfLty_&m2 zYc(hk0%8?kZWgv&ti9R{(2zw~_6JyvAtqIj)9BOTfW!WP!}Shxosd)jnLuX0QA@$) z{=f&19{YZG)xgTktnMt;t2;KEEqpGXRPgSL3p}`d3;=lknY-9m;>j~l;mRg_u7 zZ^e2s`g>k{7oL0mIpoEFQVSsDm6K95=$SHw2FUhMkSucJcOmZaf)}lFVKgqkDt3DJvsjv%=x+I)?O!|AJq<(@|hC zxo!u8wS72##*V~zYrnrb+WkUUo3wC~qcs=WV3graZ{Fomegv=04F*STv=pzgC%==W zVqRf2G!ItWB)Q#AAi_n=T5;+?Ew~wGlsGe-4x`0qYJ*x@tQYYZV!0W_D=d)rCIPN( z?KPH5JA$M&cG8NH+OBJIL%%!PsjltTiM0euw0ribFWO*&WFp$#GO{#qVwGD|cj%VSu#vo5?mDXx`(s#aT5VT0(Ri zNTEm2tM)tH8S&nI<18fDZ4jYsUh*x_Mf-AY$^}V4W@kQyUxR9}#~ocZ>@70oIDv@g z>Sn>Tx*@)|H^N872qi*Zd(+#V^WMlvXT=M^;>|lX9&Ax**MKc(Dhg?em<4JM6>VfS zX@Ue#N(~WBO$nk%Xn ztAo{|)oV6hORalxmjvc4GO1uE#FXJRxm+o@_p2S}>m8=cz3eWp({yBFchi7e7X^S!-pM@9s-LDse7R8V7G4*f96j^uOC}Y3qNS`dbX*4=Z-yF zt2}%67H@ACem-X2I$7%3GUu_n`gB;SVN{oO9`cxmVL{=Elg~Ki7BpX^#6wcCOeH18 zgi6f-l*Y_j7c6rN+%%QBk`B#q51(Z$)$P<=HeRr0DH{RSV!jabF#$P2mSeMGNGgM9 zO1XI=1!GmSP(~p~O&$&sLRS$E|{lD=Q^i4 zUFuXG4dddOD)zqXY5)Ae?DqA1xR@(ej-+0N^L|2^b_&3j%Vk}GlI9A`lcoEQZTaL% zru`1(u(vc>%=YHef`rUuwIsg#&oOUD+}W-*Uq1FFpaz4@2g+O&m)Gk1nV4gCJr1Lf z%cbVD++I$HizoBp_FSiJK}{U9`M5wOtp=DqYSK}e2a0C#(BraVFW?-AKvkNBy{t9U zfm$g}A5$u+WjG2&)jbiCq_uSr83ZyiysZ=6RYQ~zq8Ld+GAorr&7fxX!6aY`$;nl_ zV=fGp;DqXXbM8r|=KH=DiYmk@xp>I4uB?_btL5CiUKnhP;%lq8m`gdWQ_&c^48rs6 z<=*)EF3AJ?u3zua@9$zhoYdXbS>0XVnXj%-{pxaK`~8{ir>E-va9Vcz6Q9e8 zKyM}LO58VEeVIhYxJHsw^-&!<5*(=f+)RDq62`ZE!QwE7)#Q-oj)7GAAO$qv- zAfn<-&4(nC5`4^wd7vx?gy(x^Sh^_06?Aoqx{10|9i~R8LlT$==aA#?oQXWRq(tV0 z=rD2^2FPLnmxFOR(3cBx$k5ejJ`T>T0F${4Zj#+a3C~8&)u@waF&8zHTzydYg}M!5 zNMo_p!hIa-JdW;pVLl92ml;*G%t;RW({w23Xz49<<(w8k_o4v(K~ z=7;w%-@kvC)Bcm|i?d(9I6Zlx{L;^1_cK5J-gI?+TJJr0X%ByOcBEi_Vqa^W7vy3f z*U2%c`C8_3&e>08wv1w7sYQ+%vPeN5*9;SNcMaVV1s)*&rdPlGrU%GV%B_NLN_V;@pjgXydRoHcI%(BkXX`ZT)r_ObPY z@!I|G($;YwPIUD|c#lUmn72NUHTsv%`mxr7#(N6DZuWwdQY-MQcrDmnUt<_@p7w_& z2zmCIJH9;2Zbe0Np(ceVPxxzrM!1o_>+* z)d~*bGtWMUI~RBP-~ZLW;^Q#da<$^$|AD`aAN~hF41-~JeaTuXYBB5&g#ct6MhR>} z;BYTq{iQE_neTt*SzMJF_s0P{EAV0%hJ@|e2IR<+h~;VnGeODILv^%Pu<4J$tk8X zAr0B#^c3c$rkXkEV3J20(vbGk1VST8$3(QaH^Ah`UrXv2b2SooCF49cHV+*e+z!gxP1H&axa=cKPHI z%jF>NdErI7eDIJ2@%Z`)>u!hbYR&h(=RKej!#LoupWNpfJ#jk}4F<{K*5TePZY&Zh z%_^p8=Ct2q$l2d~<8}PVkNmJ-K6;{Wy?GBqR{rYW@asWIDCOX@)mkj-!-}e@vA2Ha zXMUD$=Cj3alSElle&sAe1v zd*orjR0>=jhr>?p-nj!a$1i{8S8(h6LY_Q&j8FgKFJW9PdGF1K;+S-eZ4r^spa z+2(+@SS6CFo12*k;9mdafAN1|wQ4{6vp=VB!^N#L|G^*n`-BnWFk0E~#mR8xsUB7- zVeEz6Jfx`__Ad-MzPkgNWCe;%xISEC)CE_=0_PVexO?|0JbdubA6-7--SvtOA765| z*$KsvGk1rBS2yY)a5I--(bC-nLKSg_B~+^x%)vwfO^D>ER$Wx#a8XAafzU~(yPz5v zeBU6zlhkJQ!s3SgVUIe`o>HO}bDJ%!L4-&tVNhYcsz^{b80}y_`5ZAztmf5GXF?W& zI?b5NfmRnV2Z|dj0x(3K;ZuQU!8A{p4|~+P;%cr~uh#)5Q+OzIEoG814-NzO`vV?6 ze28j90&sG2f%VBc{EG8{%gZOSJv;H7gkI-kMoTX&Hrq3K_3JNVvpKXHetmi6 zU;6x4`0KyxUj>Tc!Q)HZfAW9}O}PKyZR{?uFdb%SD_DkMh2;W#{OFO-W#%|8L>>0C z|NQ6V)~(xEzxp-2=Y@Cq7k}mRR{h{fDWy8fVfugrpKoPV+aFp{(kER+q{(+*bBUt1 z19;8V4qf&M*W(@l+;}eb4GK+$Xx)2|ofX|Cgx#LR!j3~+8*94-_E4J*j5PLy2H4la zErMm-6f+j=_y~CQn~k|&{G@Xx7*>;cIZA>IR0P6(svKO#!T=wg>Byg4d#Apdw*nBt&Ki0ey6VPe)jF2i>b{myy&ItXC}m>Vy@sh!vh@}|NR1ToSLo3B2$kDitcVG5*|#f9pTs<^TQ9*z%QEAWz+va(PKCm*Ni|nx&Dl9H=fn zU+uNzcin_kOzPx3JvOxuEne)6mCLx%vs}reDF_19z-k6}aVbTd z?#?V`Go&u9(!@$=)=RBPSVzvb(ZLHfLcBm(8|dOT3mjF2bX*3>(FzP_053geje96F z;X6>=fmJj>Qlmu%X|q!b-85#&A**bMN>Y**8*D^ffOIlPN#Tht6olfL zPH|ueS1-*Z27wHK4{bY36s`!YD7tXin#Gm|jAEAD>Y}190bjwm06kUXAchfcBubj! zx;N(a3i<9G;H$6H>wor>W&GA}OZgxCM7sEczo)+WKm66S`PfHfe>kXBm&5&;w%uSj z+bV~F6?Rguu2$4EnfoHJNZo%5 zwZ?aeafl9KKPt{KyApGuXwKP<-W z;^O4a#oc=Q!sj3P$C}os>-Det_QMgsT}$BeB#w!Nur7NNE5qo0?9H4Uk1+4o9V= zPE;k-y4_;4;6NjlFi1Gs>Z8tzW@93D%frqZg!lEvBW4h4%WhNB=8P?Si4Dj_@C6#_ zqcgHbHzrtC}KE5DI9k%Ui;H)Y9Evg`EZ7MTb1r zLV=w`eeNO=QYfKpgh^A{ckrmQ;;pge4J}9!bcag{dz$V)BLFLI$V{z~>in9HmY~&i zZ0g4Tz94qIujI|=lSYn+4kSfwEk|FCo0=6CYIQ_7y|dc~3s`IGI3&O?Zva=vgwPym z;HXFIMG4XkBQ&?=jmCYBj{$EanaKKzL5#ygecT9P)l2ic@7_wM20gST-# z&)A%u;BWuG{XF2=TjhA-MAEbt=oeYqvt+naP|4N3=->YbKk_}l<=^~me>>}7J*Q9z z)D|!tbF;uqDuRe@?5K6`mo>HMjE2U1*^?RJCD z{K{uPbl4rvLE`uPp8rq*vw1%7u;1%yF>;&LsY|mtV36_aES2{m$>y&E^cZZk>Z- zzFjV>nfw3w_x(P2tv(C`%&Ms*3Fdtb??@_OhH?>Psx=UYfE`2dpdO(qih%-XiYlu~{m~feu+RyOIpgf?Hg4a#jjzA? zIz`-b9=M;beUL=Zn1=yZ*E=Q=2NE0}*?tW|$~j6{w_tqqln94AoAjR4)Hwj=jdBSP z=EWmunF?pi>7*N~nZv5o8Y!R@O(E|!aR2sm1;+GQB;df{Ds<>jy8$A0*S{Osb){*B-I zoBgTVcjf=^JAa4Qso*0Y`T+jxKl^8pHRF}nUdNM1kL~$)zle{0{G;{!;sRx!@%YgL z-|hAs^1@RZOyD#+9^QLUzvYwP=0i&O>7V>r{JkIid-|{cYrj!WPtIIG%(Hz9oArbD zVueS)_+W_k{iCrDi0}dTBf#9{ag9pMD30Rmtq5-xP#rW3>yoy?HUPQjHguB_&~EmR z#&~UOt68r!NvNVReWmRiwaG05Y4q@_ir?Kp&%Pgu_R!rHbs;`S`bLHYSB=U^uqoa(B$44te(Y@j*RFo-|YjH*sQF{x%$_8s1}Z) zq_yp)+RnBZC~2_5dm|`O;D@KZbh`WzJZ5|U(on!-2o$Ade1s20e=pL2^P51|$V%v5 zqmj!>IMR(@XjG06nrFQ+ou)EW9BpZ93lHb<^RzYF)}az@?Mw4u2iOKzFC4R*i!oz0;*6F=pzJ!Dpx{T zkxT+#kdg=_H;isJD!CNFk}4yhD>_#KtO%^kZ2|b`wJu3tJN!hdFKD)rYJ=1&QXQmg zf$L4F|39k!JnXvdD(i&rdyKi(+Iv6U+ng@voScM{kU#>2 zu7J>kL=?pfyeze>Dhtc6Y(UBnQL0KyP*EwxDlL2Ls%R7`<D)wZ{u zgWWmL$N%zNQ3G-BF0kFv=GlC%iv13(861weSV;u(`9N|sVnyc~vJl`F(L*9Q56w_wJ_T^4^{I>F@G3rz`!-!j+{C| zZAS(_E@jvNI3jTj@-!LoTm@nxFaTV2iS8KiBO7oG+6M3ygbBcrXamSK%tlfZpcP>w z$dx(A0pgH04@_Mr8Q7B-L5ze=Fb)Q;2#g?CVlfy877hj*%`v!h18S7n zXuyhw38oE+BRSRtr(A+`+<;S=twgQ?D;h8a?U=#SP;A=1O)ao$wT<(=yE<31+n@M| z;b-1#{@xE_{^g%(^WXj+Kl|_hu-*IcM{K>lh~dtyVYAzbH*Wjx6E9$Y<5t03OKWXa zciZE(yF6;Oj;+?CHn*#cdXkq zi`khMTruN`88_xSG4iY!-^ehGf)x zB9s!JG{87IZJ=>vl3oTk8`;q+MvexQLQI5ZGzB?1Slnzh!`huR$HWAByCrhP3pf_~ z4xp8Ckl@aS=c5K8{%r*`+&J!H`4<~JOJavrgnv`T|wPn zL9Hhyt~}xtiW5^@<2;|S)llzpz1D~A?wu#srq`c5bnWH48#n#@Z+y?Gzw*)J z)%X7GxbdsM{>*;2eZh~`r)ruMEgI`&c*e^xnB1n3ou_kV~W3tHRyHoa&&PlVtLm$ttMID&<#`l%*L+icutI> z6Rj6R#Bv@{ujg|h-LV|VQiy7R`C-!6(khxK4Yk8LPu5SB@@(k8GQy7v^irIF5xdAYM z!f6?}uT{VEcl;Oj*Z$_;)Yt#^uhSQQ;TPalul{632-C2_n}6|bx@f^a_DBC1{=_%` z(e}{spzryIe_ypWJo!nVjIa38FT9Jq<7~ zXjNe}v>Ip%SoV|h%$_n&yVzY~x4p2s-!tYpXQ%^-dWkAHF_ba0+?sIb&TZ5dhzxa1 z&wp#w+zf2N5ULbWNHY&QW#(oE#$21wqRw+%?zh=|X@J6roN)+C zc-5sT+P>`YkN^D7|Jn z59JiaL0jqOxW(W~>&;^=Ss(CBC{9N$*!j4$Wx-WPH!KoI-)OwMPJ6fq42XDXP(&W8 z)9IP+DYkt2qzu}K?r`&i^Spm0)*X7$1)9dbbKZC9QOVCr4i3Bb%npla*h0R=A%R-p zfg9|p`QYm5Rs6;O<-7k50DQ`8KXo2T@z%_D7u&ku&c0qB@tIFN7q{=+k_+Xp}N zlx>bTxO;IA`+1kLSH}sQ9Ut2hk36Wm+e_ZObCZuh`ZzxN^v6kqKIxNQ#e3%$eD{0b zgExG}8}J!#__SzsPn%Axh1zDbD(834@dN+lp91D=^A>{-3}x4k1d9!5XlM=i#y|9p zn5Myh@fUvqbvx_y!7F;td){mJF3$150}oO)a^EA&!l07hItY{uN2Cwl%#&l7{mST@ zT0x7zZr&kg!3RT`CS1LG6(`rO;;H}e5gZ?%v9&!~6*UT0TnwSc7H6ktxvE7*h8isO z=tjjr8kkagMnQDHVh(wbEg~{J(k#E*Wd2*R2%%(dw3}E{Q8y?ghNGp!{dlwC`T4yZ zolAs71jVRf+wG<5Zk8FW7L&{1Hin{d-iMVTqY&=iy~AlWp|pZ|o;8kB?%M{SHS8`f zaqrF@MLS}vO*M4rG0pRgI&Woi?qhG$I4Z0_O?d3V>!=VI(l`vZ-_Jl)+`YK4)zJpS zSa9{q8LwZzj+^&x1FbE(q`41q<;t1n{hl{&-oh)NylNl(z=z`>{oU`uzx>xf!mH~O zun@0#&8zX+*S`)=fBa*Zce8!u10TSZYuC-JU|Nr=wers0TOgcuo)xWXD3jg1xX`;l z_+CEp@FV!*FZ+V{yMOEN^LPH9--SQ(XTCiG^7HNXvBgN8s(Np-b+4{jWEo~Xf!%u1 z(W|5kfb5QQq}fS`eEvOsNsH*X%&(L_8tIl5vNApWP{b`f_oeVz!g0tx-LimJ%nl{! z!UXC55?CJyJv89h5mtCf*yR#p+9z*d0m(C?pfk`G@z~gzj!J>|&_L{XnJm!y6i@E} zEY4vuyQ89D;aFy)V{sBg>DK8yKlTw-7`yX?hc$ZPBIePlb=*iF`vgE1C|bWp*>s4` zoaEv#I#|FROVFsn5Ug1|M;to0OKfm-0o}uTC%HRf`b3dIDcZ~W=T@)k9j;}+>Fyb& zdtn*3%<#|LcQPwu$-`*rb9@P-ABSs;w5~+AWp&38<@^7OX_siH{><6pF6$v- z)ZzIp=#4B}_WDFZq4}XX0Rn1SC^(hl!jbib%c0h1(Tr)1We>pZ98@Q{4BVNP4ikH_ z21$v8g))^>8tG=)#8ptq(+)>Ch-MZEZKqgr!GVh$A($IRhB>H}L8HI{;3R1! zniEwNS5zHHP5>sRw`D?QLB!ge$EH|88Y8%|Xe)p#1lMSB1+A{x+REBITEL5Bv~a6= zkR3KBEb}t}XW-BLc>~A3{s@Qk`8un;=1Ka)*U3UeYZ0xYO{>HJMs?&omRl4wDQAZ(ZPj{blHX6}uM34lj;{3wgZV&II-o?lyH`!91L zL@{76_+H@T7EKK+S?m>rd8t4sh$v)9!?;S0mZa6L-&G)0NDD>eZ;HhIKwJ@YlBIh; zXerb(+gB)nCV&}Om}eLdrPJBSLBz^r4W=PC5Su_u1|LMNNn1sWYi3@BD5yA%i0a9h zALe=g$h^N?W4rUV-XWfN3g;vW_`c^WJdnNcJh84WS5L zOj$-5h$hR(IeXJr!oFn(n}h4IAa*m`YJ!3m*21U-Oc?|Uca18|3@m+S8b%%~aM4i1 z2OE;aUq&-dAWv9>lH6o9b4aWb9E)==(*{v;b|=@8Ns21a`dID&dd+mSZ5O2)YfXW(qSE4VGzsL#}XUfTq;9d_tfYZGdU)&+I_>Bw__= z1=qx;qZV}nVr{|*uz+$kuA!JJbj+r(IXsi8!WA&>_XCbM)c^4hIDgjb;h*;f)W82R z*kAbW^1$Uzw|?NC598^vHdoHdy$WHsE73xAwKuJX5KNK=Rc!+{!K_8`iGgZXd{mhv zRdSwM_|~08jKs&AQRI0@gE<2nrW!F>iz%o95tGQRfC|bf+ZixGnql6Mev`ccP2lKY zgkqr3f~tMjXv!oL_WMj~(TrBqwM&vgae%Q=QhKMvTylHdxu?6rl3Ipb-q9qPh0ADz z(%xJQ^saH$OcWEHp>BltbQfdUOf7rD96|LgdzB=5LFOzHi)A|SV6u|t`ZDF#DL2?k zjFC>uwl0b}*9wKe3E~P-ubN?HZUe=M;F;81)Z|j9$#F$sa7KaTF*ggu$iPrgQ=^=# zD;g=40%dzB+LiIf3me<4+W7Ewi)U|m`PrXxeaV}K)nETRt-bq~_Lncdcw_zOV~@~% z%UX-*lY^JdNCk&bKurU(H$Mhgt)SE}C)JD^6uEu|(Q??^7Z^q$ON;~sC#=(87K}=S zi5B$8)iEbSyGfZ!nNVkC&Wd z471t+Z<*G{26)axi-Cp$W5>^Uo{v&2%3C<-2SHn&X0Xrz^9n@bHo7+h7WqA8#p4GT zKKlDvj6@0phjy^nFZp#wq6+#NuO>zTD*e2YZ!l%b z{u;XP_RiCO8acIm@6w^xTqK<(ELA>arPu3aC;Ie2udPYQGbqse?~X3U2V34x7CGhF zrw61!fNlO}+ybrTWN+F?Kol5VlP*d8w`)E9r{ zmt!0^cKhy)_>wn%iT(O}-;L12$V>Em6n z7BMe#G~KRiv|G1tV!ht*k(WQlJD2DB@KYa-dl&auhC!E?JKnl^3)ik*#nHH78*9fo z3#^4?O?P#x{rDRq6L=SS7N!MJYt_Z&C66}8GJ9UX`p&oOl`ntH#%YClANYOW@ZaD& zzWq<77@Vj5u*k!4=C%cX_NRXif8Y<@!Des?jm117WaHp`_~8fe_FviaQ$Fc+_|(^a z8s7ZYpSM>%`Koq&vavgN?r~psSWROTAI!^$X zeLY!nHKI2OxHL{XfdCyI5QpjNE-171^$309slRUYS-$A&nIfBV-Q2mD*Y3Ug*$b)n|<_{>cUoCa}K7|rYRu~PX<#%e9JYcs13YaFx z&08<7-ubp){CoiTm;d6Qljc<2$N9ZWb1xFfn>TLg&iOq&|Lim6&h6WH?6Jr2v5$Wu z*IhG4ZE^xvuU*5nE7$S-3on8&jMETLKXccoX=)EW_<*<8h*s;Tzv0u0f?S_oLGgl+ z+|1(J|LmVNq2j@-58=kGo2hZNK1A=xk(vliW#pgz&hOy!H*e|P?|DDVH1K$HVsCxh z+o7;F41-6j>f&JLs>tB^Fv^N?@KJQSp%)EEw>o-vJzB-SCbM`L225qZ6HmMxcW&O) zotwAt&?mnJx9{GT8#&JvtIZnwT3LocUdYx$<2b2jxaUG;A|lcUUj`Xnnc*Rsi)jyM zB<44&=wy&NsS_>}&?Ix~oMon19Y`f z$pV$)Se214+`5NW1H-sR-Bk=eDOylHzflT_hVA7ZyZxS$!HjHk>m!3knPPjnxAkg; z(Tw51gV(O(si&WXk({O#+zJ$dTeoiE@kbuTdf3Q|bA7Z<{=z~|fYew`ruNpi{*qs8 zxA>W#dvl;w`?;U~Y23PV8y~uO3S)7+=llbB=R1E*SzMC4d5&kFea=?v6;6-OpjN>$ zVY}Uu?kupF+ZO-vXMT!~0$QMk@X$jKu)#2{R>GaT*zUHkh=@$5j+zXk3ye>_ z+m}NKU4TB6Fj)|%8=@EGwv13(4iZ~m;0l0d_eXI$N+LB;-WSPx@w9AhT3jQH12Tll zz<=+Lui< z7pxh4X=HX~{m^9Wo2`MU7Ri)cni#z>h7!e*0ZgroW*-q%L+cYnsaxkLuJ!4r=xyGtOVt|#ivWB- zpfr#Tfxfe5tXUV+4+pm%E|krQ)(=HX@^_yqfaU#{ZSQ1lrq3WJOAq%@|30GM0SB#C z{hHn1*q1TZ(nm}Mhhau6Y_}xKq=3F00?X1lPuEN0O`?yC*#U!suyjWpxG)BKe{OmR zfOqnNv>XDvi@yJz?t|~o*TOgNqq^OB#GdLaCJ%k_C?#I0H<5g4TBAF_`m{kLhxEXk zTN({op2YRRlJW2J2^=! z80e7$z9ZBDHNc=?NhS)7;s9bybgu>o6OB70F2)pE!#GJ;)50KJMd84vHDH4jrwAz+ zSJAXV;A*?L9HPyJCMDh@vLI&_f+Z2JwP~-21{=!=+nj(aCw6z(rUCxM8BXh1Ep>{V+}YoXX#+Ziediv&WId7kKg zCb^LO`L%$}Jl7#nNNIfupmxdXGEfU8gM4dvATN2>UVv&m3#MM^~lRKXHJ{Rf-S;DM3kWqmbWDN&MI)#Qo*@lXJaWu zsfGx!QD6zTU9l1dA85Krl3dWG0$MQys@YJ)p^|&576FrpEoe;rNqG$LdKip<=ElEX$QG8Tfeh#`d*D}Xiuy2Az# z1!k9^Mv6vaq`2;}BBP8W%^xu1Xwm>`Wi5_dpm@Ya5d(mgNs}V1Aq;c1q|L<|&}3m% zQ44F(a^lu$T;uY>J?a|Tw(0EpIKTZJ`}W}v4M)HCzg%y=>#uVD$sdXRANf|TzW6Jy z*f7+&&Ue^7k^!4YZsjP*x_Aq=7NQX>0$EIGSrgQB(4rl@Oo>0rXdULY=p1V$?k&Wy zh(cpy1Q$zp&n!YGfiT7DWePp|)LU>d-e9qRA4cS(=gBPCyIh7V7->ex&^d#tBCO=r zjV^@POM*<7x*y0|Ts`isBU9`Ee~-n|lBbbWRC^uFLut{wfcY`C`~(+XUJomc{`ws+ zx!6S*u+~v`N#n|zw;OZre-Hg25Q~u8jg4+lUFt&5DaYs(0HiLGf?-G6Fi;H1Bwr>p zBlQ_0lQn*r97Y$Wfwo}(dR-m|KBQ$H*+F>DYZSJiPL}D-KofHzv#uj7!18YXP;SD# z=Fc-pETT^?9UaSAyK{VDqTe?NSV!38`LCrJD>~-pAeyCS9BhfyIc$yT?qAMkS+_># z|g$if5A}WFpRD4XO&@Ot$QS&$E>3lr06=Ck*zj9^NFYNtP$pp)*7@GMsvu7 zTAP3T<4@}&AO0x+=Rfg3?=V=l$x%E%puOhSlh(`yHZIYql$XMBoH~m_h?XU6;d9Jq6f<`89D4|%`ZTC1i0v~?p5xw_)@8`46J*!Ic&fU9s*`tr*WiNXa z&piD!Ns}Z?B{9&Y3jOrY{Vad#Cx4n>^`_qdXK3DKuc-#&!3Q4XdcEfE;u2r>&`7dIl6*dH*dq>xZG7cS~)h;glSmg9D5Q%6S&*Y8docR;^}8`e)l3Cy!L?o z`mev6G0!?ZK8a_ad(Iwt^ko(;c=hZGk4}%UyLXA3H*UTDxo4jrHk+gQ-rYM`f<<3C z`5!@eFvFeI8;Y%mU89?~Ix$Keg}OA!7L%Yy7CSx83(JZF@6{)=1r~jIhWhTZymlAy z(OOQetHDvQ1Z>~;2={lwep*)F;WB!3 ze~ky01NRT81e50S7x|0s3+&W=eX9%nW=J87Ovht?kLv8NK&89!^y~`W{FYz* zx&Wqe9NUwxdJ>@Ga<^@l+e-{(#GO00;`ZHh*4^Gd^x+S;lanKDFE6p*Z+oMmKxi!E z)TVI-AE;+vd{Ni0UEw@e*4nUMt;%M-(d~P8>i;lKHY|0<5wr}6K9;@@F=afyc?c@WP(_X0om)CY9D zS-H@?28mcOFdL92HNa?zL4>OuL@|1@Gwj8N2NsRD+p^mm+~ErAVU9^B(S|wA5LgY&LrS;%+ZO zE5e9*H%l^%lSvjq64%eJ+_x$m+WHpf=UacxYhHubz3x-=`~Iun%?BTT5LX|35Rbg< z@pimfwf(%u<>gj%Jlq{`u#1_wJoQt7>YbSp^Z($x#oI zq`l)^zpA^p?&$3JiUY#kTQ@#cFw3E=bj>aWO;+W85Vhfc5GWTHfO9dScJxwjs^#X_ zS;_3s2J0QbUT?Q9o;C9W@&a01w#rbW&TUWSGed$FYz%tV1D6pYE9mX(?jY|Yh{yoR zvLGv%nFU&K6;b-in?Gwv*G*zY?l%OJ&7No(p*yF!jH~A7mvzKPcLS5`jBUTa?xK%9 z7-6z5O7eizSnw#cbo#>Wutw)SmJI_P*eso5?*_B(pk9RVUMQFT&&#OfvL6WDX}-+H z_020$=nIQdeNX6a4(|eTpDbWMxL6;lTAC%vh+H;J>u&25h#R7Zedf3;)ZOCdi8<+` z1Y97P=tWd-z@{dh0`)S6%8q_<G$U{=G;9n-Lai{!)BTJ;ma6NVq&<2+|mp=*|oez7yYB;&k=yUyX6IVg3c`ZA+z8A zR{A+|LAI!mVOzS<3kw!I-Xg#o3|5A0vbyD@MaRe(mIhkBH~0JZqsjVbO*D+N|NH)3 z6$(H}RErnDm+P8N7wfBnG4U>Do&l(b*KZkE+P@zfdk}bjpG?2G6-DZ)o<^x|v$B#~ zO)XBEd2t#&mw`wG5*)Nbnh{O(R1aL>vJ;rgUt9V=C4Z28*`QzMjOqyINYEyv4>9MXl696^0Q<1m?TU#b7%QVzfUUi7;=sY^D+*^4jwzmzz7~8##>R|C4o)PG2%eC( zHuwr*8z)B^MrNqtkvWb5J9d_13Ma*VW5x;2wZYb8|Bu^RW-F(yL9Vh{!Ic?TgsqHa z)qs@)8yF{u8wdl$jltHSPi7n;TOpmME5O%;9g%)a+FIlU!-j50Mmsg*HG;>0ZAhNd zuz_$Y#8C@-B*2GTjib5N>#fd@?dIL%yWReiciY`7>wbQsMw}|DQ7}YU9A@QPL?zHd zVxUEsGZ@PYS(&)?v%+ljlK ztOAB+2q@+dYDKFR^L{TzsJ5NAPyt}A?uVG`CO5tCrgmy(M>MV#Is$nNZ~`%q7>rsQ zxgyJvfoqv2!j2_u)NCTTmf2Z=#{iGa>!IhM(YZ{0A4@Lkd5KbDjYSIuD zQ;S$djnj~dM4E?*Q4l^*7y+Om7&Nxx!6%=H`p_e2zwNhJd*81yKI?N~ANl}Kzww)5 z`u%?>@a!{f{rq!03bM4V)-~w+S(^94b`OgvY+-ESKy`~4qSlo(ZxnG9bzZf(UWsT& zp;)nTE$Ilrnr3HF+cBaY5&6uJJh8wjq*JGk1-~Zp4B(l7V~{5nJaS@V#x;T)kViBg z5!`^B2uy&j&A39?+Kg+6YlBTRtPNO`Ho0*ixH58Ou#sl#Vm`>RqT5Jta&a=ViLezD z;W7p>(rg@rLTW?f+TBO@Vdcg(h+`N>!p6kW*v4$wnA_S43e6|Cd|yVMxcL!FIWpLh z(~ivSm}YAyHx@WbR25HYJSBPT_Samx2I&f0JB_)XwK`vky1U-y{TXVT(B@<8=d*%#QpB@Cam6m~ z9ocSwGF)CBmmBB9#ee)+U%&9Nq=mStf;mQQ7 ztZ%woda3W#x{;u_*ZMwf-O0O{ADqlKi)SrG@2+V?Uk-C7q8kn~#In~OrqXkBIsnT+ zG{4r>x+l124WXM?)N5#yIzFaPt1EE|OW~gwzg{aVdd+N$+@AFxvp`CEvM)Zqtm2~s z={t}g9Xp%#$s*aJPcC*dP(K&3pUhIRT|R4yK5*|fbr**6$e!PLs@OdEGQj^*-aq})-tX6`TMKQYT<2e1K^!$w*R{@~Sd%pieABZ3R zXFmj5;OgnIs;V_cMBAbN5XlfTEYi*T?~6>8df@tl*h~}DnzDX3oL#%#5R7@hSF{GB z^nZT;{}KQ0-~Obqiwr9=AZkOg!XTmjEC6jdInlh^f~haVi#QEy?b{v=$xg3P1qI4D zfaa>Lffd@-C27uIlb?7gtWM@bOnZ;YHrg@7z<} z1-2I#xZGZ%3@eQ5HO6rO1=Q$1cD1!iTwL5y&Sf-Ptyb~) z%b&or&peGU{GvD3Pkz-W60YRx2Hy9(T~T1DaJ^)41AjH(%nH zf9)N7;_*lE{BxhcFaGi`^JR}b=;!BKGy$#Epo@R{Pku*@2qSRv);GWTt4>bNuxQqY zb+YRjIZw5meY>XOIGlxZ;>7c;-Svdb3C^{E;gC738{3u;Y!GNMbZsN)D$Loz)R+2H zdz#d^;1K`{rB78Ask3E_VC&KA=z!{On|E|aDA`AM3L5%&4ZGEzONXF>?p>5aKafZF ze6ov3y?d=?6XapU2zEb6G#zW!8LYjt>4KT1;eQF!vp&WXnP6>woa-P+b^#=UeecS- zlFfR9fAz2b^`9~`eAS!2+RHFTi-_&zrO$IkSr58(4Zxb1c20%Lo|8-q)hn-DtV8Z6d-bkCgd$2OOFDk8+W?$A^LxuWfv zo`>X_CYFt`;wB)5X=N9?9q!#ZPflI{!)nA_8;?&F0VRD~le_Pu{( zv;c0t_yYdQ|MtJ?sSkaa&%XFP>VB{O$eO#sOVQ_l=I8Pqzy7PZcYeXa3K|3J%^HtA z_HrAC5$kc}JKp*B*wtpW)y(EGy2`F!J7Cd%sUdLn{d)Mia-u9W~k#2Mq7| zA&2psj$c76_<=4bE`?kq_NgjRmg$!Mya$#*#&kXV^6d7tq3fny{8fs#i%{Ly7dr%P zX7TC0kXwqqgD}s967DeT-g#y5c&N8Qcpp#gK&kGq=p%|qM2o2hCTcktbjP%1p|%VH zM!!&t=8wqNDSfkO-3hS-cOC@i^ulyTcGvT}vv_edXJOhM$KLTE2!y9-EG*97{$8ZR z`(>9ntyh$~6>Rem{B`5buYyF0ONC(Hs5EcBA}ZtTdY}hC}e_VV&;I zB`(27=x4oNm?N*HbU)}y9cPm!7A-j81@x2ec{x-yyYJeM`$1YmB$qprI zZh8ZuEZ+s$^H#f)XgM_X7=|EVuEQZOI&(gUKkX2#mHU761JH61>`r%In4wD+LLZGY zON>k(F+4P?`s+tz!^M4Z*as{YqDt*elzxBFlilw^WcwG8Wrl@CUlZ8Ju=AN@;%rD+ zq%#Ya6B|qKh9W$3h*BZUh&9?k6PM*WBFx;ZgYJp+2E(KRYCuBx4d4nM69a3Kq__sP zYScwUSRsmN4#jBF1aS?EBPtYaUYUF%IZ*8sb>74rN8o-^o1KmBwGj$4TA`|8x05l< zi^1C#{H?zO`1H@g7_BcPWeK@yi+3L{-eNsIl5X8Izq|~WIB$22<7gnPh0u!NQRoz! z1kF*a!&qkvvj_&vFt#}|T}o|*@Vya3)}cwmhqWNB3Y^Wk4ET`pzHHDb&CMA7`yNRq zV<)Ep_A-WOM@BUTX3}Q_refL&jF4Beq}x)cFgZXkU;{FDmLSa402EVkA})A z2V=KCQna;Ybd{-9x(^7=(NsOuLeba=dhF4XfG=-sA(hG8oGoIzH;!pHECbZO;IrkT z0o8i?pDz{@2-4g{GtHm<8N^%P3A=L}4%k#H_Xc<^k`pXuVvtcicAP)s1_pj@WOvX~qhg8`b|%tKfSnn^SglY*lgTlc#( zy460N)Rmf;Bt#(*WP^*8Ol~#jPr@mdG`|v{axqEfn@N#j!QiS>z$Qtf0|jOfFaa^7 zSd0n42yj$3XG#kl18p>MWkzqpriM_(kpW4OVGN24J)38m8)FLYrWFT`YTxod+1b~8 zJ@83S8lJm>qd)QA180-9zwq7r?MxpZxoR>;8z*R2%gz-lZW3#2HUOoz(u!4amaKp< z^L?0IvRQF7aloJo3UyMo2ICe%h07=oCQLzIDg!|$P*Z>IMl{ zL}*W7%0x3ruxJG^uqu5FeaIjhoCBhhg&mE;5Ya@?imat6AY;CyJQqR%iC%z~c1 zR+JnIqXIM=2B`)(ih_IYnn=NeomdirIf!DSiG&HOEdMxVKV6Q%kaQCe@R88yZkq@V zO0w9>9a}YxAl61CYab-t27`_QaYaofS{xfRP_c@r6Prc@O4MCZlhB$$VcDE)RMUh| z$Xo>)N`y(x8EsgJD7BW|2cOb#_gP;5Z@+03-}22CFMB-nLqAYI@jv|8ZF$A3kEiPo z94XrKf^Ata&@qBKru%s#3xPQdN;F~@evFCELF5Xh=UFNtfrUIb$UT@Z5ozdMz?P!^<8@?b*)Des5?qz|f z8MKLB|M%J~u!!dZSm4nP0jJRgb@a1AQx}SHu*7%axSv;S84I@ieBN%vieA$%#swVm z$-4VldA?mLNZ57i|%NauT@Oa^BKn&&)fbi`06FnSQBkm(rrEIh||Y1#2zSxl0gzmmoSCF!U0G z4wlfgL!Z~2KJIC4SRei>1d^*1POTGlp zJ@+i0`RGUe{qK7Z{^<|>|M2gB<|okv9iMFYmbbo@Z-2)-@WAzJ{_Jzlp`u|lL)}$? zP69Tao}%t9AtQ??rl|~My~t;3aEI8)FpMQW*6;uTfB;EEK~!GQ+~K9<{au>{JtK$^ zh$I_WYfW>V+2);9r`oPs42}jN<^~(nVQ(eF6$cjIa)u3tTAM{1Ld~59$)srN^?VPQ zR6;bA2P=f&5kM1B>m1Rh^b(h#rD=`;DPt?{O(0u>@OWoT<*3gPOL`5 z=6Hk4-41CR?9BcTAI+$US*^d5+a;rK{Jj@?)QP8jrvDy#K;m--gfl ztk2;e|F-{8-|?M)hApCJw+9qh7@h_QKlM{Ttv9{tD}7iEx_j>~LlqV!6k)G=@<}}Z z>~lChKJ_pBk}uKsfA2r!%O86jtJQ?vcFUv98Mga9Tn+2hgkd$J)6Vz=WIu1PVFpfPsfNql-n}*JWA%eMS^%;gEMx23_RnvCrxupe=F%Gc&Y^#3?ALd!1bXbEVAQ z^57leh}vJDJvc-ir_jg6)H%b^xm5jj2IxKLE?>W45!P~{cIF2;Ft8#I+5|dsqKj^k ze;5mgoyqE&rW1VP*-u>k;0HeNsV3pi{h4nMf-!G*cIVFBM35-#g%@w=?w#BIp$~i% zB;)ep-0s{vPmd)HEoM;UqYpiZX*KEQojW``JwuCzyZ7#DZk4Zj@=1K+6QAJi7oX)P z|CZmThaY+v*REf~-Scx_jU)DB(?9+G?^~u+Y+)`(RF2acE#^!Qhji`Qbv*p=Bl_qw zPhl#9&kEcOl8Ep-J6W6^^(;=8`gQ#NIeY(>V0TEOS*^=*TgJQ1C zLZG45%3>vU3cGXfZr=Y8&Q4Boe)|Q~{T7?e8bbIZk31}wQEH2P3MAwv-u2FR`fk71 z!HR39Z~NA7#W#QBH}Yf8d?Fsa_Mlz6dIkUZ2frVyVZzsb-PhqGPkk8AKldD-c*QGq z@A8~4f9%O<+bw?jKm9Cz{^#FpFTD6XZr;2ZAN%;zapT43%8M_&hz9wKx1L35u;bH{ z+*O<$rm@tEi@kL$i#pSgi=e!eA&aXv*rytW(x*lcExCiXpjT2Hb7a8^sdLzuwP~4D zxG&;GUsINOm1Q&!y)d^f7G}0hbYYl@`dA9ro*tbeeD_^9=%>XZqII#(7?3&GBPn6M zQ~DCh9*YC5Z-E^JvtY0Y^{JlDz3x2dP!C>>h40?Gtex3qCM4R;^WM)W-qakrsNb0; zy=}FKn6VrQdSTqx)CIY7aK9`07;BwFf`s`q!i@x1$9!n>9345)1VCoYAP|E^7 z3n9c3I@?FCqK}LAo$0XOEUx-2yc@g?NPqeQO|>P&;4p@ndr0Dx&5-XMOM}o3g|pg% z1?#OB=4Oo6h2kFGWQPOBf=1~Zb!I^v4iHPkQsQTp25-;pP;_@xu2;+GZ0WnW7D@w= z%m5IIcIf{u$G`iwrS5uS-@mXVlE37{qn-qCcs>jzM=-lZA#(d8AUP=A$E-y*L<$SS z=KGkX?*7k%T0fvglJH{*0}bBiCoV{#ew}RzrVS=z9$EC-!m(VYS(JY-8(GQQ?EFY1 z6bvtM130MG-#@!E9iYjU9-j5EVkK;%5i+KT3a48-PFVV^MF>`e7}5Fa5Joo^gbm#l zvAkTk{-q&2}}#5QQF09Hf``%AGI#ry^ zh@qHvChjj;+l*Q!z-E|@f*U;o;euLot1if8n7tKBGKHgfFx1-6PsoFyeFmkl2)1`% z4)QpiVcMC%X1pK(M%@~n_OEyD>t_--Dl?=kbC`Vy~6D@Hs&_H1Y;YblHIGkZ) za^`(Zan4qRHZ5>9pfd!HQ3}X7G1#%W4;swS8Wc^f)%0&Qp@xJMWo0$kYH}ki%%ms| z;douJ@qxU&i?R)a<_J2=H~c{=PYIwW4WoA$yNU+K(J98i^q0Wj^Lt@!tNG{(=a9xW zv!%MsOHxv4QD?_sa9VAH(_2`OP{c6DET4H*FoWBr=GolKR0a%ytVLouM6D=R2xqFe zEQ6Im+tKVoiZPRXY#-(_p~0h2*7BUB)+MOym4LvX_?`krd5!4OwB_! z657|$#temKJ0>DzYspj{Ks9Et>m|V1jRO_CMh-}$aP%pziX1+tLvxr-U1h3pIGgq& z!}6%xXp5aV6^o=eW!I$jWDiJY7ByYyK^aAvh0u&FCYAeGKjvWHGIa+IxyHjt7D}Mm zpwO7J$`}&s6a#vXHc?L;08B<(2{A|-D4R&FC>)cTvTU(|!UVMy=J_-t)|AG86-J#H z8X2_^8rqIKMr0UV^wqOzZ2LWdXoHVFxIuF*oaeG}!?@oM7w>;JrsFGd`p^FTIzIDr zCes}F%YT0N!e9K(OFsEp#;3n_oM&D@ZLnffK%_W71bprq14ijE|`7-gQV zxuKxWyu;5{G z8UP({gZrkAWnvT=NE-dxXgQ-`xisv!#>J!G17JI>?C^h)fJs}(3Ei+&*^NC!o`(*m zoNT(ZMQGPz%1IGDS;#_f&gE~8))9>TUL(4JBmrSBP@x)`e z{o-AG*_VF_jy5ZN<(GXKr_CBqzWUYr*wfGO!%sbhknpNkd@er!^S^*suV2T$?i2xh z)*HVFU;JfXiU0Nwd=tLuoBoi#=X?Gkc9(nIxP6Ns{?G??bbQJdO@n*N=pE}km~ogU zwOxQAtjY)(QG7&;Jt733MliB(@9sz{mqm?c`-?4XBVZ_)V+JC-u#hnCX6&|=gV*F; z*9MDZMJoo>rZg(G8FEL|9Z>T?Qrq6)mK%(q7S$FMF$YtKCJA&;pk4^ARv{YZd1h-t znjvC2`!tXyii`--Ov*4W8Y1!;leLU>C`pjpj6Z&j;xF zU(5p-6_Ow}H_UUz<@VB7n7SFc^i*L?NY;zxh%N0?13Eiujg zVHbY<|M?Mq!|(mC@mZhy25m3*R10vDZRd*9vooxx5zoJPgJ1fEZ^Xa&;UB{8a);|z zuHhq3KaJ}TK8U-w?_d~K7%XtK-r(N(xvUs#2(|8Uv|7cDJGbrGXP?s}4?oPey!CDT z?O*@f@xa56;PT!D$1-pnBZhIn@BUr?1%L2|ez4rSdHXXy_`wfcdGNspZ{50m8*YY( zj(F~-wIx(}7W$-3>Q1@g^=4;S4_wYhMan19jhjiwP-m#Oj$Bm_h33+%Wg=#l0OG`t zN5@Ms&-xuN4ls4qT=04ltnPP90d#kH7dp@v)Ub|J>4$xF2OS7S_hCl9Y4i>8Fh|q( zY(<7tP{|R_O)s$Q@r;&EQwV7Jg*7dV_r7Q%JD-a_fyl+qy118rqop%33kj5PL;zP$ zPVl|o`+c8*2=}4j^{@Xlo98|5onOS!@#OR6rJnleQ`}u#wr5{>&UcsR?a@acwRir? z+Y!;QS+9U5UF<7|alpe5KY%;;?y(V3hGI3O4}bileDLaZyz14j(NF%&PwTOlzmlKz zIiIPQz5G$zw>>uNHCC&&Zr-}Zr#|)(m>K7Jt1=8cK01aM3({?06|L5cK`bMVPmb(k zZ+QmCCr5bgYd;15_@De^yLs!Du3otc1T>?PdzTN<3T0{@wU~RDhSfwTGeI~*eXvl*$?B^y}K|0fA+in7Z?pM-gpkR20!VOp1`NS?$hki z#~#NkAAcfV{hC+fb>r*oeIIzQ{lYK4MPKnHUxqh+@fYGReCMCX<>joiYuEAicf2#q z-Jg8LE8pMdTCFFoF9dSy#YI{p69IA%+%icM#w?z#GYoTialjf}hUg=n5#23bBQX`V zH`}^csBZ7(OStT!p&+ujRC*euWHm3&5?ExC*3!uAVU4+hEQ>L^7?^>htrwR;Lq`1e zOVHQIrAX!?g+}j!t2^>}n9J$^-?A8s04+mqbXd6iXjyl4FZh%e%S2BvdU+s><6r|{ z8gMCsU~&5&!Y;KmHQM0-lmm%*I$C*wOi!`A-2d_kq5DtHg%SBpSrW2T|n>qZw3(utQ16Bf>xuCdTZ&v92z@Ic(A>J~Z2 zY!(ae9*28$x#!7T8@&HL^#fN^^y#zyLgc{@rX;>vcQnm8kP%pjj}E#NIp-lX0F$E^ z?wMI?mN!ijSX&sOTYwrWrtB*PA&&i#9No;IAcYb&ia|w$1K!Z)TF5o#HgMiHR;^;b z+?0w@bsoxGecO0!brxIm;$b72jV?G!pg6F(j^UxJXfHg6(hL{~>~|@uTgHtvI^1T} zcmEpsmbbBe+Gm2B4eW9oUM8WWaC%FpSz|uhGsSFSIrTEIpyNscM^} z_PkJQ0Wyr%6q-Tp8BS3%U=?CBHNiQcsfwU21F>XPLoo|xFRKBvYE+R}Jo9u6l(}qZ z5v7;Xr%Lvcdh?S$lw1K7YQkx>x+XEW+e34W)4HEGQY*zQ#&LQe!(c2N+P8BQd2oAi z$-3P+FL%^_=G5jO;GPgZ*-%;#h5J3m^SfA?FmBc;FFwyTfO>HOe*Ag1M;>N*@`;qG zRM5?(1Y7Uz6~k0PRPmLsrro%uJ9ff41<)$4j0L;x1z8;1t+STd>)=orOH&!kDP)G? zL!}SoP)bEPVvQp=Z&Sn#AL*>pzRr;1!iT{n+)>0(-0u>$B~>ZgL6~7KDt2zXV5?Uk zGz^v|ph&MO^ZBa~#+)F~K5dPNWx`Bg1N|5QH!|lLvt1`s3`$=1C8d!NWj6GI*HIZu z(mY}h$l#WJJ!uYUM1(0~??;=vesaVW;uHnPwu|-t{N50k7o)+OZTI^&Z;Q{B(L&la zhMIg>HI@N)pMT!M28~z87;b#R+xtHj`@jF!tbE&_2iktdDew!tH*itx-dhS_?L#c(j(SSHt%B>S5wKkSvP#JM4;x+x6qoja2nh{gr!dhV zmzxkQS*y2bWZ{g4bcNT{{S3XSu?XNrsrpq>^ynjNoy{!7j$oy<2jwNqa?jO{`DhW(f>L|#x9d(=YDya#rn8IBgM7W?r(rJDLvcZHBRB>sLV`C}?#7M;jrINV-a3CfG zifT2?b=LX$BSwsnCNKu=+ZxeK5bC@y&BpVR0f5Dz0kyfSu>j3l9sJ^!np2}9Mr6X( z{Hwpj)6e}(*?;)y0WUmHDBy=WrPox z0YQq%$RaY*7y*hFNpOJ^EP>c&o-17nM|xc{iYiAcX8_bt!Vr|v72WUPau{m>HXs8@ zrCw3xQ3OkGBhcF@>xD?f;Zh$+=y88K zZxPjLabLJ4(lo=xf1H0mf>@Zs(Hr{d{=`eFy6zV3hLoyBFl|{Qbz{{cZwOhh=S#Fj zZS5Ivowu%DD!Y1!=wcwu8adjM4Y#-h1GDuSJG)D1UMMLTWd=_g7;1NHr(vcYYSeuf zorER$^uB16^;OocI%G<9V?+;$hj-CCmTR0J*p^0#_1_Z>-t*051~&DH6;|k1_&silZ0o=N%dp_af|0Y;xzQ?E1lN?gDEgq6~0%jO!K52C|euFh}-SH z)jC@aNC@V@=I8{ZFq+|Z+rf)ruoV!2X&SJa*1CIsZu|WX<9dn_uu5>Vnso2pJ!%U( zIyuq3i+k`(Q!zK4UC}rc*kCX#5d^)I^pPn5&%xCMeJCQy?A{bDTB9Lt%ZzHGf#zmv z*h4LoJBV5@h$w6(MTVpz6Pk!=T!ZbBP70>jUY_&8>#wvoe&OfGyZ+Jp;@ShJcJJ~M zchB!(GmSY{(t?6x@&PIUIl{d{v!D>936*KaFjCc0iC{~6@_xI;Lk~Q_Vg>v29arlC zKk;vW9KYjt{w{p^mwz#S^v8Y#La_M2+UEPq8xVIdFYT$1Jf*LE(^uLfFT00}-40i# zDW>&kSB_8X>)-GOf7h?Q3n->9{Gu=8y}P$jR%^7UpF*t-WpE6IT(3`X@BAKKym^bo z9P+@Odlz`{`U7^pzlC4^m3Q!KzxKE2*4^8D%Uj=yumA18GhV#&ERIi)H1DfV)2MIy z!+((f*AM^GK|s0j;;jcCf9w^vhG9#!O#g5LYV3eUG|TCs%xTH9x_1r1x@%l5m5s$~ z(w2a1WnNsG$h!%ypRbqZtd@gl|p8#d5B$dK_e4{)jN#@Gd$D|`_3VB z^dMB{F*Hqk5R9JPJ!QgD==GGiE( zaHn7TrC$U9{JS6jclx3)`U1Z9*WZhu``Q19s13)*$GF&D0yUy^3x8O;TosC8pgFB0 z8tmX8a8JR~%7E4y8VyZ3_J4N$439thDCpF4FFeC(HQ8MEYHBPP1UhAEn!}8x52{$e z-Mr=KpF;OL!R+~xkt10RIn99H6|WKtq?YE`27vC}$!wP0B1c4pDQe`9L=de4QL{B5 zC_=24Th)EF*1A7JWc2eV2(>2GDvo2$MuIej5Vc`AHbk8it&wyUbEbG9M3Y(-V?Sfw z?@=RA_xqeQsSOc`k#5QmQ;^=GHKQj8?|gfSX}#9H-39LLE-7VaZN1*${N7#j)fDTa z<6f&K=zF)l;KSD*!oABa>wJz!9(y_dzklLe@nb*sZodDEMKHuFdRpC7}|{QQ5ySA6AH z=<9#$*W>)+9E3bt!^L*@sSzqN-!lT(y{7v^8~X}eQ>36$)vYxebmwlvdvr%ip7>kz^S7)0qxh{J^503Q| z)t5s`9}r#SXmkr(cZPQX-hoUv>8@sYm$vUWlWnQUiG#SieAP=3QBGa;eF?}347C)1 z)tgG{pJA!wv3SGCoTzDtVD<+J4);nR8E%UU*O=q4!TT&qq6g6;8;@bheC%_{If%Nr zzcQw=JG63AR**9Op7glyzCuhXKSLuizAwtd568<(`S36Y>+do*AAXd z0C?xzEg_c%Z#|&6b2_CZw<|?`rzV>L3KoJK!jT~H&Mxr4`4k4!vLP&0DtT6Ksi1^tfoBvj@>cW zkM<4|n!y{ylWQy&=YVINS*bHh6Dk|4q{Z8-)vQ<=un z;8DP#k9o^z8#r2k#m&!UQ6z2yp4)L$ojbBFum3FSESzNwi^&L)FcLeX%P{%j6Kq2d@Js zr<`s)4{TPb<}5X*k(yj3D)-^gysUA7R_BH`Sk-K$Wcs9+R0smm_R(mUdlK|vHPVK% zhGH9Y9b2lDA?FBSW`-|}5GvpbaFAjnk_J0x+6$YA9mOWN(Q1o8B{4v3G_<@sx!@{I zeKq1smtT4@p$Mu;5y3#pAsd1yFpb%lHv>5VoCvLGz5+3Ub);cq?u3=&sJjz}6%|5M)i zg-_M(cfVVwZ+JZ~%1E1=+Ek$s>%JlC>@NS(5v`Q=vqK6QwmvA8WA4SawzR@sDu({PQ~b zGk==%cl=o^^Hz5C5$gZ`L0tZi-`+M)zB<}xe2VJjcCJCI;{df*9K{8nGEkF6w2;CO z808!QRx_6LAHmhBnz@9sh?+qeBPg@nKtYE=E~?3zSypZ>o9EUbFP-HgLhzczsa`*z z^+~&>URW0V-?^A)ynu%>e(hccE@7;fEk)h;W=nd=1a9uQBuz?OB z!VYZPB~K__^=a1!vsTMyLh0rl%X2dAKrgh;9A0Wjw{%Y*5QWQ*Yv{F?p)$ImCTrx@ z5rL83)13cb+}&vtf-kS+wK%EG z4(N!bh+QNZE(V>0yBpnLl23ACS9+JMe{go@eXsQ4ZXL1Xhv`x8jS9N=pKtK|Q>f*& zNKrkR=IQb1Uio0}ljXT%u|K)`-$T~#Y73pOdvlc6&5@`Es%P^l1^L5dZ+Dqm4Kx~t zAB~hVbrMoaBIK$Yko66`IWE4Qy={p{`%kid;H^n{7>MEzvRpCAO6F?Z*TsEH`^C{ z{udGehE?I*fN?!wU$+hJ^kKxaw{KuD;&`>{hNi5;2O8u7ABJ>Olh{*2i02C-OSy7&wXvm8Hzl9*BXgLbw{)YFGZ_yggK2ew7gl+pcZggkc~~0T+8!N zg(gKrFw~M1KsZp*0xBq~Xo%KlXPS_d^X$AyYN5)WE7zWW`lIFLuY4sw>6MT8%{yBR zX1F}xVi*S7HDO=(pa}yUEfQ;)&8*xg(_S9kermARz*4d$EQ`zS%)58);M&#ec;WU< zeEefi4D{p%{zWO(PjgHUGbh)eLXl-aw z^*NvS`DmdqLf`uX-~YG&#{c#?Z^~e}Uig`T+tg_mj8^Lt%2H0kXF<`Y@GYm|4;qLp zCv%!1T=&nrvFOM+kXm>!YWw|+HFa^#bYFW|@Lf!UqKTe?WPJn57wf{&Vt?-=I13_y z(J=-6gLuyEWH-PUF`NgtquEOms?kM>Wh>^P@tK}irYOI#%kuQzyOPUn)}k0vT`K4b zNA|}%d;Pv(VO>m67iLedp5p1}pFX+V?q1gv{40OqI|r!xe!HW4DfjN&;r8;9#YVpH z;tTfdv(M69xOMY(2*Byl8PtT`_7X(E#j8L0RotwP@e6N$i$46J59##uM03niG?GS{g}K4NAi)C9kcEyBFy=RG1M>)4 z64GyGJqS?PtTuT0V~^?j^=rKQ;vJsfyN7WcW1bs}nZ{z=Y=$^mZG0F8I-%l@sEzY> z7ZO3w*Q@=|#~^C0%tnsV6B|v*Pq$!#gUB3VXM@NPBvwh`Mj~X&XmQjK)S7COTB?P; z6WwAv?@%Km-S-XiejgE#v4B~)M@Z2qm>UfqCW^iLHH?KYgOePFB1Zw04_HIREMcB& z?DyL&s!Gv32U?rWV5p%8hRoBoxbUBAZCH(y=p$NdhzP8YHn@B50<{U7D_8BwS3I$R zpj%fM;}8DfZ`6y=KFja?3*Uv0f9#|B=5PMy_D8ItB=H8JV!; zd=7({_gjR7n>U`v`Sxz?cRSuYzY8_!*WU4VeeVzaAYS*WpP|j>1pCV^e*7nX65F=N z$x*!0S;&^|8t7?19r0mUh}xM?+6DCfv+QDNKGku* z8Pdh^W%|gMSF!GxVJ4Ydzkce1z8UiRAB6Kfq^R}Z-(Bv$@HxT6yO_b1tjgu9%dfX% zu&oDm_HP5dDI+w%+240}vskt&XuV~^m+}+)J)@-ok=NG=lm!RV;gU=6k@x5Q5FFc^ zyGBu1vLju zW+XEe0<_GRN@$cBSSYS@LXL&(-;}W^^Rz}9M;0Gp9ANI24gm&gDaOgc0WpuQYNe)? zYTKZyMB5vQ!eKCraBI~~l%ttP3$zxAP^#oS1OM3@fiL*N<-U&OeJ((}1pj~{k4}gO z9~4(B@N%2q?`}qkhA~0|#nLAy6f#C&6yS5CDKZQxT1d^LR?wQMHP^nel2ze~NRqZPU&@C9qL0Am zygqDuj$y7U9+(^`4H%+n1EDmbv<68E?BNO)HhBbEtK!_q+Em~uFlVbPKx+AX9RukQ4fm+d8)!u0HK-;0Vy%~3_GqY(8eg8j~ zec~As5ks93<~aS)A8jY=3Gwl#RV2;(b8@@ov|eF-a_k&O#eSxj5mT!+-@3&*&t$6u z_j`+dOi^2j{XE3J4vP6WLZ;T-q*00uq!XiUXj-Az8QrdeIt#=@EOr&9O+>p6=uG69 z9A^fe8vF`@QzOm{I5Xl5v=bvH7$+FlASW?4fURhDEbxTH5zUV1JOa5f;t1l#jT@&O zIj}O=M&d@~ie^V)*uc0VaZIz78&{N#0tXTs!lvT3cKWfKt(-a{Y$e2Kz}ke3xgCi- za^tGdkKM~i^32F%b33(SXN7*%s8cf@o9WmMr;x5fIwEmu;7K7)NINy@IHWUF9k;eW z)qcLFc|I1jj;a-EU8BZ`XvQ|1YV(rv=g4{Xk&T0ykF8;BdzCtu@nRe6)dsc;)pxwT z4EOGq2S4!<4BzqRe1JHZ6Lp8}@BMwiL)WR#{49^%th$?N=H{f+DP&g%EmWkiP^*`-5Y`iQ(gGr|7ewrtD5=uN5^i)b znk>0T#%^>_ayl1*8vx|XYSrr{=#Ue12xnKf(Oc)W_gdTKOGw8-fVHLG>Gfh{vPRba zy^cHNi?l8ncei=G^xrQN@4~?tl)trOSYkOp&To0?#H2i4glzj3Bp4mtk=VmVJ(j;!;9BzhQUIeb-*^7~Jbw_dmPW0EfwVVGEOn&T!wIb{=MQ8w4HnLS z{~X<5wM<_^-QBAB{`1k}*KJf%rn`4}wo#Ecy zb3SnGAw2xZ%j{EL`+8nIy&6aB4Q}4Pjo2>&eh3B4sK}XXHZiZ6EG~`IA5@uy1XGVZNzy}li_mqRiO%Y8| zk<87AWZH#TTSKk0_PcEcXY|qIs11ysO%)AZ3f+rZHx1{sg3Or1X=b!(HOdEEvJpNM z(7Qm~DAHJxtre_!@LA5OibGHspoSZ_?=TQrPb=KG^&;+`U+{zPdq0O^(5s$&0sv74 z*Fh8k**$OZvp@6i@sSUI1TQ{!6E|OY5j7&b6cLqYq*=PVLdh9)r3i z$3F5=TaPQoylbRle>rnn4fxux`Fchmo_qG$FSvL6CRSzWliA))kKQL!?4a)gJ=|K$ zWQ`KX+s)h7|DAc_ufkeBx}iQP)n6r@UI%omn7HOeXIhMU>IM9QYh~BDa{ZOixDZ?O zjmc6tqAdqn91JklEg{*(^sf91@?}1J5pi<4OG>GwyDYK`oO7Pm59U3zf=j3=`a;z= zJ|rWon{T>NPzdiokIp^oF1Lf^-VIy18F&goDX8%3$q9bw2Y&FI0IgS}<8$Bm1#_(t zEQ1Oax9;5GY8Z9z?zw&V15feU=Uz~i^!$r2a=kjjdNty*UaCRZj2o3waC&lr7oLCK z`kUe1yLb5TLl2h9#=Ey~>$R_YoxSpjm*as4uH*9FUHUYL?)ri6|9-oD>u!#_h3LZo znxWR20C{qH>bu<~0N4|cJ&uU5r=NKmpZdwK!F%5GUVP|dPqEb*N2kZOJKwTp5_0#A z!AQ7;(*}T+l0so73&~CFlW7W}yv#~yv0)40N|^P8x%Ft>(?nqwAb zlFaI^$%YcnWKa-5)Uc{qs*NpO>TD5<=%dyen_8dZBxh6iJ{&+#iExG?tO%s{SULy{ zIvCNc&5eOL zJq3LPZ0PZl2T-Ja(;xoE_Eo?6tMI4()c>GiEZXlbY;Fxg*c^z*U-mM5)tlag-}SqH z7ry2<|0cZYH@pd7{^ei6m%scm937wF==c~fd)cG7a(ZS*#~ZB2jlwcb;n^3S!TH5K zeCd~d5l&Bz@z}!;;un7Y=ee6_{hfdCcVjRjS{+_^@z&MNxB|K|z#hgD-iI~2Q#_LS zpWMRk21V<3Y(o~{=6!9?;>3D!ml50PZdqK>Sf*wcp^r)e#i9DXAB^gb-j?x$D7_R` zhvEudoK~{JZ3*k?MHn4`c@O67%)-7fJJF|TteeccfN40C%j(A$61~V;+_~%myL#c9 zVX0(yXj^9{S{LJyMX7f{k|D_(C_Hc;-Tfe)%Pcn#U*1m~+(POML3#%BWP*5d9;3*Q^X`(jL$RLkU-$PoBvOW!_tfId zG0&03g}F}nq1es_&~mVJIG2NBcXfy7YmuM}K*6H=F5k2DdlJ1V)%~O0wa{OGIqV@* z{&M=%dOwH28ct{Ok=7Q(Hf%FI#|T9 z7p&D_(ZCQ<8x*r*-Zj=rwQ8;Iyv@}@8WgQ4+8EG?h%nL(TA9qveUxz}+L)~(xOq%w zu?fQp#7O5PVP*8OfD>qIK*unf2&`Zn0Xvd35Lg*8fmq9I6yTzDk<>?mLopkGSf^+o z6U_%RKLL3JX$`|D*P6~FfNSRKZ6qDTe00ZThLwSnLdOEvg04mAl=6|*JSR-X6EzdR<-VY-?m=oYPIfdo_E%2V~rMSL5lzsWncKPNgDv`Fk6xJ1Q`mtGHMNALtqWsn&g_mWGEYRuKPVR0$5R6 zA+TnNk+2D#B0FRo5G#TO;70H%#a|8t^5?}>1V@N#z$Plzim1$bXN)=*8BAdwBxltU zO$E_B)XE%7=e2kc)(SNbqt0c1ukJaY903o#obj<2S-<0302{28B1Z*Y@yfFPdw+w2 z8ujb%!lrI{^1=%|{@@32<>`;%dw3WFZ)3`C` z8paKQV}q?k90@j9W-v?uR)U=Z+$>F#5Jr*{=#vr0W_ASGk&H*6PDov)+XikE$s>23 zfV@KLINuMC09^^-gs=w)yF%JkwRSzCor1U~v#W*JP;nJ=J2A8~RXl*uDQY`Iv;yr% zQ*%UsbEW2*n6K7owQ^8+F}G3GrZ$&hyDz-l(xQRSKW9h3@)lm%3|PJ6m(d=6`QWWK zf~dD|w~OEKM#Sb+<&9r#dy4h^+*PKcagzDq97-=9<)q4zRwN@79Kehk?uED$@;quR zE?y2K9mc7m^EbCzi&6x`83hG?BUtI`|=O7W@sPhrH(*!S4gvv0SHvT3h^puFdR39E?hY zz`~ARba+2Uk;ts3Zi!fU=k#d`($g1Pu*rtOx$Du4qWVZG6Px-fX(K*HwLi3cgf<8VOXJfue+@? z_f4{Kz{1d{4Rp`*RBJOLL`6^@v_MC}2AgWvWh&ZSCC|ipwrp6KH^_+AGP|k_6WJQd zP%wCjmdd%t%?7J!lDVht%)nYJj79>{6#oBb>d&KpThppObk65_*ZMZUX77FarcQNK zUxgqL6%Ygzf`Af9P{K`&CQ*k`qb4CHLP#_kqbyUgqXtY;f77annCpxN1R@9pLtTGD zp+;qkFfVMkZr|Vo*B;W*W|PYNVyv+!CJh*g*5?gQ!rAC@w4Pe)1DUSx3_vsMUKUA; z;C^?}&d%;|7za%I33qSZz$c#kBwz)9^?&~B07COTtKUgnp3MMkH(lzz@BIKCeE0#~ zzH=Mrw{PXH%baG!!;d_M&Cw~3H|zHJW3SPjyLa%&qYt1Fap&$ieHgH>dq$W&_Q<1H z4aCLyZ5*9k0TDRcpJTJx;DaA{KTeL1aeTbxM?dl*`sj)#)FyExqEUbQd;Vt5#iAbn zoA2)i%V&o9VQQA{=EPYktdEv+j@SB0lo{ZKQ7#CEfeJ9q9< zXm<59w=H#Q^Z@R=?;1BpTWp3w&)#?$58VF%Z{NNJBKW%3y6608a2wYrV*!E}@Hc+iq0>GdD^M4lZCS$<8=mQ^k zA3pWTkE4{8R2}iQGYvCNqe1mK4`0FD}BA{&$E#t!X6*sb+{KUi0{CFs=rb zQgnX%0&an*jj9TSb2Sc{cYB;&oWr1Q5hr{YhysKtDc~@9F_1m3BLYzqz^sN0F0GAi zZj_|-1|5=V68;RJS)-OPuLz`@OhOZVppZ|0J761BQ`z!pSFZpfwg`fR-{L>%(QT+7J{tO>|?Q8JxBM;&J`yS8}kG~El zr>D4c>t?jM!p(8z^eVRNBl9xoKB|JYr$L0BjuQyw=WQ^@| z&pr3fVLjpy%Co4xl}vFR7p2$ZhVRgWygVKJZsI_5y0I4Ii}pg`7pS^4&1trkZQb358qG6$QcmSELxRq8NE zy-Fox%lUxl8`?#gtpj#L%f_`2c@LB9T)$%ZrA3FlD2awpA9ACkH14spm$%g?$N74s z!w^@84vU8&?*ghhEE?D?mPOt1jXwPETWKw>g2>RzMFqbsT_X#Bpfl3@7CRNsc2Jow z&OKMW>ht13*<_3RLiZH;#z>$678igHJA`}He=ZlwkT73rQQ~w3Rpe8`db7sp2lwJP z?h14-eHl*m;H$o%S(NqOmpjTP$-5mDFnD(W^tDm89sQcgA}tmi7E*N9Rq|b7L|;_w zxyX1n6v`{`<o9I)w$1@JR|c+~85)_6Y_7P3znBd!jBXgyfM>uFpr?hP6NOM~DX=>46&QLrA#NfhwE-l7M+8)?3Zj?!(@ta^)n)7{!4g*=7y^ zN0W~f3IePF%(H2#L~B5;f@Z{A5z`E+xfK`PM|az}+i9!162Q?=*2lx(SE06vsHYJ+ z5#oxG8-ORqb_L+E0Y@QSN%gWeB)5Pak-BE#TXQ=m?bujO%$YZ#tac=$*@U|AV$c>AP2y_PXsq0R|Hq)SV0(48IJ+vC@W(G2KQp5W4@eF z_f^5AC3iI{D!~@!f&3MDvIHj?=go#%jj<0!keIax?mNZ&gFlYx`~QC4x8|Ui@IUnJ z9DeMFHGIR@v)#Ud_08*A-M-GNFFdV>zv9dJ#sBvY@{ND>zvA%b&!ewbX8TKMw`1%s zsA+aglSQ4Z?kCeU7qxk}~kBnO7y~;I(HJw|S^(6~d2Cm$g%NDbZdsz{-A+a@J z3);$^Yd1du>>7v@TDjuneF1EsIDy)!f>+Sunp(S3h${v?V8GTKC(+^>>b%l^ccs;O z4Yd}Vs>L+Z=h?kBmXN%K`F`@XJB~)jYMQXRxU}(NLfOq)l@-Q;zW&%paQxbbS)Tix zrZ>F}e&?>>#qI7ZjDPFx#XkO7>5IN3hl9JRwe?0C$Dn(9o)&FfVYS3tmV-sh=@d&u z4-v{EFW1rRxNjjyh6Uyh!*V&+qemUAWd4Y>GS=&b*y2&$9~kO@W{GYhtZNL-W8a+e~E(&5#&8e*rLw##f6*y zXIc=g`Tp%Ne~Ba!^q;MR#lS$NVqX2jvPJCFmjPODk1k@* zto%&5xIzDpQlQ8FSuL*Lj%@6r9rod{z^ro+J?M4mHTs`NqFU5z{{-^%Yb3I!YQ4|v zpArt+mdMYivGxqEypAt-7bir1FsH}Ic>1Z&;x|A1A#iYe=;22=6z_KcP({4wJ^v;~ zA0P&Xq42)@u3}YI8i#^$bl!ORWqj&0pGHfyS?u>SKKvUW0v-63UwJn^@ySoMW{wZM z_XGTsfAUWz-y7DfnKX-S4$bpEb!@7#VsbOw+3mIN*HKfVIWx-L=`6i(5L%m2%+dPX zF6KZf-lb|lRkfId5hNm@Fiv$QTIBWB@xJ}KP@qPEqYRFg9|eP;nMD}}I4QFcoqZ%l zsMhSu%P=PQvbKm8Kx?Q`F;{c}QBW26#LFdqPA$kzuJRt;A_1u{XJ3Z&2>WTzd7AX%^&73$nxM1*PmZq8oK}3WH@xAs+FkAtVR-bRhwRSTT?|$f zYPfrO3#TV1IK6g1_EW<+4!ClBg7fno#?^q&J@XuHynG{G`%wT)NDtdVeiH;DgzFEL%i+`9Mi*d9S=FpkUb!S|4uo!v{<@*AggdzChb` zU>6^JMm^X~{qRypyeyKjJk0WIRBfr4>wlKk!|}TGetBUFBEtFr4ovI2`q1Ricw@0P z8I^O zANozfT$|O#o_+pV9G{%Fq0p{hKjSbAun?|XJ;iGtegvQV^k-loR@+s)c;h!y?YxU`tZk~kjmguYxQx+iAk*uM@J`i z>&7dPfN{OTANxjN$>Cb1ttf>KThUQQTufiw` z2$rF6QETNq&uFcZQZS5jbi13UETgr#!OfivXNzIjaGq*_*7dBRaU2*^1k6~<7~rKv zWRh@h|0|%HsGOl_*Crvt`ZgdUsxirPG1!R9X$J+dUah!tM-?&Gz{%AsadB~GHJYqY zXBX!=YwCHB5rL2V#s~Pne$U^FKmN!5IPbf9MIZX$uj7%|JZ1pm?!_73_ulvEYrpPy z^Zmc}0sLS8?4RNX|F{2L>(xjf2h8(cQ6s}`C9Jf<$+6+;=_zjBy2Z2e^Hz%EgCF{! zlYz&ccmgjy|Gc8kpn|Pc3E=bBU;bL-__G-S7>8~Cfo0Cl&$DjA>|w`@G}o(#dM@e~ zb33rom;2V2rP+dfQpbldkmmDLB^)v2n2t;&d zV_%-6@>m&Wj6T=~&^lY*x+*3cgPw&DO1r8enTx%9u{dl*@+|5DV6{a#f}Zga`JDIV z3<6Y?10fZFseZ8N%VI8tv$|Ufhd`?QCs~YnIHvj{A?9iK3@rz90O257{*{pn04>WA z3Y7Ois9v(z@|i5(X)^v7!-bpBqF*m2m#i_va}r17_c-Uv0-~_>tO8DRY0jnsWO?>!44(Lk2>Tpl#dVHOz`lizDL;!9~3AOxOdDSR^e#46#lVXfC4Be7R=>gN>M@0WB*iv`RP{ zCu55VZCJxvBMV`wCE$=(kpn}m0&+EuHrSkFg*Gcqw4RNnt<2>?Tp&U;8O-*ihJcDu zE$DN$e;Q!kOfW%n7aq94ndH(o5%ik>)km0$)Gq+dFj~nnng*eOw(bwvLbfJwG+>B) zfFCI|rqqlZIaV$^3B#5#oRV=>O>+y}Huly!$FYk&C-esS;=8Ha& zSR&V2Ue#a&x{7i9#&5y=#9t+*3t>DWV6rlhY8U`)CCp8Ni!}nO4IvQbA|o(2H#TDl zwJMf@1Brn?T$p1EAV{0c*dns~qflUWDXKym5!hAOXod|qB(EIYv1p8j>cph577jta z22ly@Wo$}YO0_`1hzN>?u%@X~qD+t^BPmy6iU)#4Krv&9d`hnfj2)M`g4vK3+gOES zFk%4VidGt9bYkd_^|`iKXLqhbId3eXsux%HKGOSZaY95RqVDat={zJ z*nH?WsPFi1$UpMO80&4b`4TZ4fnWJGIC9qjd3KD zxzR2!Y?vF|32aCDvVT`}yZB0M_9^>}Z#{E8Ua$;2hebtwteeO2!rN2F^u{K2; zH&7{I+0m6IL7|G0)0PIP!>T0;Vh-Lq4l9}a=IPrF{E6S%w2GSuCiY6G0Vj= zK-euTmM+975NcOMCvKtt4DXYpUK^+Xr`H<24pU2kPY#w1MHLkW^H&9P_8?CzxIOd? zny z4kzxpM2&zuqN+P#d$ZGXopNSkIe52arqV+<7k{6Yu0=@>a3&T--UsRn8KCu?oc#Uq zDyo4x$}`=lJ+L0=jQ0YT=*GGQ!=7_24QGo4}`K5YH(?<)F0*22!->yugc$I_n=u+{~pt%H;LXPG!dmcg}~ z>$Pc~0W)nkYy6|{|DkXx^mIvre;MRniCpSTjc)rZMti)EGfVgj%gsQ2TkuaTuc1L1xV*H6_?Tbza#> zAd(i7V*$akS1!nu0fQQvBo7h!L-G-NC?SL50P4`SZ$-5jm%s@FE-{)Zmo>t6E&UU>OsJ^0YWxO3}_mu-jju!bAxR`mEo z5A)@hUexvLukgy%E81PZ!5V>>XMFg>zsWECvMy@BF zUwQlE|H*%>fAD?(u-?3N_6M)Oa{Z6f2cT6f`EH5f8V=&Q)(@|)rtUqqBh-3Y!?L98 z2VGx;Sxb@SLR-n)xW!i8DFo5iUH!QudVf}WmN^5uxG|j>re#aaZrNU}EQ#XC7u|;f zTo|!^%8%vYt!1#WJb3!1kBe$?!6PuaY0Gj2orS|>TP;s}l0BRPkP5sYOX4ooH!M8n z95AFM$AIRY$<>25d)i0()lx-#|9w~RLqGga{#Tf37{~V3x4j*^-5#}0ihbbx>>?20 z2Y>xH+V0{Kk39M?Kl$lT==$~RG%J4R?j^nCp}5^{@z|q}XuaLwV^4m9PdxS-+`M^* z2J($>coQX+XtNDt(c9nkc0TyPL$<$t-t`k#PQg;`ZH+K~;hM ze$qTwN_`EaifBQpibl;!ax*jV#UR>fBfNk$s@9t$Y>tk|;!rVTdLW$Ec$o8-5l%ThaS{}4?KX=D_5XsUdqNBA}%j?xO4L+KKIOXeCo5G zW$91>BXD-}<{Qf(#Ny(EVaXp|xKmnG*y{4j_7LZt`X=;RQ3UAcN>^x z!A%-dqAhl)U)H#K;1E!=;l@CrBBE9j4VWXv* zBYL5lJN$bE^`dHSSeS!$c&;V;8u_38_gKq6e_#q)SCsU^p8$&YA*|R#Kl9-qOJQvH zRK#E+ilSQ)i5>uJJOnPWTY$ku6}=?c;+`e4i#bxalud(mv`I2hqR(*_w*bNDO;X9P zFmtl3HwNm(D-VvNg+osCd9B%DIDLrFP&OWm!pS^UPGQ!=j=Q5_v8!5w!xWk1o!sw! zO?9Rx`XGDRJm-J9P0Z1)yI4L@_`x67^)>zafOl?ZzJtzqTY^LTLE9IWi!$h5sO)md zbgWRyo?F)T_Yg9GBc+wy5wJKyoXFHkOAfQyGS|3g8Kw?1YtKV6RpHhh6K016h!*v^ z_eDi-f|n50KD+1&bo3>Rbp;pUC z;I2RajM{F1D_4m1nt12|_}EZPm@pfz_#a%^D5)V%w8GBvbmt}R*(udT7oRf=8((mf*7nW!c- zqhvB|0b7MIC=uQ+X$-S9zzu*ClMPNDf#z;jNUlj6DXl@SNUkN0bh;N500Rswktlvq?S@(zR>iT}tT7hH#>BA-rV6l%F*nqiXw4F?9;O;ZRJN!#&sBArHg#^B z7O{ysAGJCkg|rc|QQ<~~TUfb9as$&bpsNCpY~;$_M-|%;wsNzLh$E863~bHdbQ@(j zMzZZUlx;{`$!xH}NTbVb1K3)y5#k!q3gU{ig2W7ML~a{+Y{VAERfr=DD*{E*TI2|) z6Bu(Ft|8D?CSyn?T4T_Lp_n9$Ei{DD8Z06L6|@;bZDHrF+CGGEw<#L-(Ihi85mAHF zJX<{S2=AQjIDgMy&j1OTnHt2xI$a{-675^QjrDi@Zmquc--rL>pP;_}_uKBz{5P0B z_#u|Nm$n6X41`6v&0*eZSTuOs7wqQ}m{+U;H5Rp4NpVzLEpy#(>b`D;x{c6E)Jo!D zq2my?K^#+d3~4LqNNQK0cH+PZ+>QvG061ac%3xbKj{zQqa1@GFFt*XOMX`;*EvOSw zCvJ9Rv@OYFl3Q~f74wa`Z3%7-JR*2RY8%9wg=-i#GTRF61k{NI2S`^Wt%BInu`%PC z#v@Xv1{{NS4B&)j8#5eBx*BTN5bbIpPDEWr!zmqCt=JLWuRy%NkoTkVp&IkGsO?Iq z9%-IWrg^$D)#?6Prz?nhB4X{K5t@yy5>aVWprEqU#_b#!b~}w{cgk?<7Hz6123w6q zn~NRrYriH9>#(2t1!8?FJpW8!prK7szv#`{efZPxx4&JA8PP&*Sf}|5aJiL6cx??) zh)_g}=Ac|D&Q|Nyi>!kc8CW#PiC2?%tEK1`$RYg#NJ$DIlRnT%b~?~tQy}N}Skye! z<4ZNO2;0zWx#)s{JkzsHTWV~xe39x8<4z~+|BlRLOL2VGAxzXvFoViTOBbgyB;D8@ za*GPy7a?8NLJRt($0K!0$D%~!q9#PJU@6R&p?NCrvvtk&?V?)N0c`?j$BgvfSC$;F zbUgZkn+$Z+W!8!6ziwuS8q$p!;Mx0ybdPp{L?;3iTSN|7@0&Zs0$W~129ReR*F}l> zIu{g74y6{jA6vCWg^%y;@;dm7MdlVwwZ5f8up~{Ttt?H^1qP z{KjwmCi{;6`oGkV{n(F}r#|;-{Fy)VXYgJB{eQ<_|In}7qmMtrFaDz6#$jCJ{%iMT z$xdJxSJ`|c_~>Jg8bTOWhHL9J_h_iCVqA?d5H*Bi16uD%#xZfk3tGcu)|$`)WGQ{V zr^Ht`L*z_Jt;tY~X64XRM}CnR^x(yYp)5i)E5+p;EGm%d_O9>EG&Pkn#5j&LI$KW2 zF{}p60RSy(jZnxct4-{bas${(m!PLeE1{rdwD?$o&N{s-kHT?oroE-~8zN+%)EGo!2-QTrk= z@}Vm#BFs`rmoSGQIL{5ci*vxFsm^%u`b+r8um2`mg#Z8k@elN&Mra&L@4J_~opCu` zwx9j!pM@94OV@Ac`i)!GTBEsZx1Wq7aQ*rXFsQe_>m7LIm7DNVcyfA#-NhxF8dyf{ z_UE|ozH2(#9^>xaJ8&6St98u#37exWKKtoU!RbLzANtUTZ9R;#AlqCmOq^@PU;ZEe zvIT@_apgU~`kuF+9v}C)N{SG%EGZYq`!dd1nsx%w;;^7yP{Q}JB=RE2VC(FKE&6ju z%K3I5XXEhP4Mcvo*^72uPiMZQm!)Gm@(_pvSN&C6iFac(|n0}no!oG)~mH$o?YO{Pkw?&C&#>g{f1t? z@v^N}D=2Dv<>n1+HYXU0;kB=O0`GjsJNWc7&tjTqJov!* zfz9zo&prJdo_*$X_}p`!OQrl+C)r6lO?wbC{6>d6t>J-u)`8WO^0OLmfR^Q z0_)WZZooJgE_ZuKK%Hl)!D(qUE<+*B)v9c+L6E9#MyKaRQ-e8C+`(|TJ3>-xv$1O@ zT5El)l>8}5Svh%*!*XuQ&W}k{jrw=Xi0*<&)(;_BO5#n?&}yS z3_%M^y-OB^X&e-|UX56zXh zae2wA;9!oG7q}a0o3Yt$v7aZcS8L4kUh8p8J+m)14DkKG`oVbjyWfMSpL!BM_X|JE zXP$l9Uw-~Y{^o~%6VE>X0-pTX$J#&s!T$q4_j5muyJzRvZnmfa)K)oNPKan4%K(Bn zJHO3WuHUfrdX0x3co4&|!u{7y1<@3Ni)n}J*RP{SrbCxu1VJ=uJzdT@Nc7y^N3X%K zC@11ou9!$p{1Ujcq$9J}9J^5`g8N%SaMPETDNQgOMqhX z7SlCj{nv4@dZLH?EN+{e&E0xk zeQ-}YiWvqJusAX&Eer2LhZRS0LotWjqDL>uo+}P_q7=ta3I-$Gh8)aVT0)CC67Pg8 zfOIb$)O$y~DX9@cB0r)Ff|5_!Q7-COnI0IV#ir>wCx}*G#fR_d*q<>?$NJLA1+j3864R`6ATM;q{UT%U+~+lxXyGBd?@onQ%|R z)Jwele0mtSW69Y{>m#G{-fcO%QYD2rP)q@2NJ$Fkmxikc&UV&i2BR)CD<00OKt7A} z)C(-*`^7eVPdT5Jac&vA>MS3iaCS#oKc_AFk^l>TyuV-d_o8KKeb1h&q)8ka+(QSd zWdXxw_z&-_^Q926uEdw!L%vXiS~kt>O-(8?y3$I^awWP%E(=Rn4=C;n0#gqlUzQJ8 z!de%2(9#X17O97^8exqK0gXTc(6SXR*(^266^bG$H$b7%(Kv!}W+q4$fF!L5+!#>| zHYnL-&J4s{K~xh~p;)15lrSW+KwGPARpCet)2T7a!eA&VfQHH!*HG_+Q!)|eZC1?xa$fPSlUL*X- zfps+92Vsm>w^3_pt$Iw2$&V+@Q-Kaf1{x_uZ?YiFB5E|K1=JL^26wHol~gi`D`bHC7RmM{8@ex{VfBqG^kW zCg6U6_dD$xL#Hxcqi`SHj?J(}z)6+@jDW3RbdqaAV;Dv#Lo7iX2&{Xq@ml28fVDy^ z!Z$FCAWLFgRFFuYLBN*Kh7lVAYoZO3MupZ!43w=Qt|@L97&{OX5;hRl5wStkb(`wY z>bz2`np&7kG^GIyh5|sS(P|A;$XfJ9yaJNvJq<&wwqRK!Zl801bQJ?u&Hl%~;dbW+ zrg0@)UWhQ1H@p>o>rBIwpWyJ~)13dwkK_Db{)$b{J}02j2^$}}8Y3NpsEtJw0;tUj zWE2TCsWoeD+JvTpxelsr2(}GcY}wi-=H{*KSAaHvjsk5>Vr|k96xt!x5T%xn!<$GZ52(2*sFeJf*u zaSi#F4EzV zErkE~|IGTEpB3Nvrf@sbZaiWb9nsKQBpor}n!?bU6s>2ycbcXUCODI?iM&i{La+;o z8v)BTXErxE>5Ay}bmaj8n=5~0O&A7qDFG>&;})_mgm7dS`$2`=B^j0_0j%qmQ}q{z zeluw%(X(^ZnP%y>J77fA74W(@{9UltImvAY7I*Fr4AD8aOf_jg)4FS2T{NZz1G!{7 zEpv`V*pWkth-I#x9PTVhvOYWv?O!FhLAtT;%^h;e3-7(hQq3(rh$8VXS&Lh$<&jGS zf{DBBVjzWgmt-Fb;U2qZaUH0u3$+Z5Td(byRUG>u+yRu5y-F#LRT3)u?*6>0Ho!ha$&FMHNitJP=JSFSI(1&U_10hXp2a-tAZDdDf0fK06{EX@X*5#^XT}9 z=XdX5z1qg<$%)aEB5?P7kF$%r*v+BVW;}TRgSfoh;iDh>DF2_I|2Z6AxsPA-bzhIO zvmKv#=2@Jb-^Iz%F}~;Te=q;+fAMGWuYTzlaelGybv)|DevbqrLMtc0&};602oGJm zip$Fj1PpVl*@sOt%zO#A)b zY$!NAy@I#A=`Fapyugi{*ZGFmy&f04OWwJ88>d&UfpA2MA$fLw&dqwo#~*u?QXpJ9 zy?Sc<{SH^IoZ{m0QlES3X?w>z-iDw4sh`E=<%Jo^i;GLe)S}LFoZff8J@N3v4FG=V zhky959&I+Dmj&2^MWag+tvl;OJ=Y5vsGHA4Lz7U|pUuj{G{d8FK?e}(&TT0U)PrS6 zpTVU|&R#x{T1s>eeQcbyXf3zJk%MjX9Dp3yYFIEY z1g+%(XnDA)56p7fvTXkVp>|7_Ku=}k!r)~eFPJfh?jQo$l%y@J^-cJ4IG6krt))Uy z73j*i^=6Hq`sY9OM2jl4(C_^1UraX(=ivM4E=w7C{NTg--@gAJ@B{DrHN5pLZ^oxS z^;Ep}k;na+=bq7X7ia$P)vI{r{1%>g?6LTcKmX_O{PWM_fBV57u)4d{tsAfK`IlbM z>mPrDPd@o6f6JTRf;)FEwb`EF=FMCD<$v{y`W;{Tr8qhPKKS1EYufF2dU8d#&u+`z zxn8e)S1b0r3LjFzUF(c-81NNe`MYp=xyPqI^%-A!5z>z-{w z(2Q4sN(f^Gt+|;|8nEIv=*{0bVS3^5!WMD_u#ffXst1MnlZ1@UChwumxEt ziA|K5SVgmZ2+Iw_YQ(y&bh*n5aBh`-+a4T@RvST2YL?JUa2r>7En9X%!^ukfX~&b3 zQxv2fs6|Dz(6rmL#*BynT5!L+)KI_|@7%%7+jl?`+tbsY5O&V#a>l%!2?B!`OhdtL znt5`x(te&f0=T-~;^o2d&;t)*o`uu(F#^W(%Zp}F{Mtj02!L8^%l*k%5B$n6{nGfG zfBSFQx@_^<*S!JL#UAf|_pkDa#~;^gU-KHjd-t|J{E-jwb+3IRhE>5_FLC>oTi8vP zSg+S?wPIBU>{~^n=^bx-2R{1I4`ZGto?V>tkp~~dQ%{}Y_U${^9&K@YdIG?;+HAC& z_c71Y?fq^-N7=(D6lNGsD4E8&vduyX7CiwY7vqMWu&i=WnL?>rpBL;$u!rTmO5N+r zFkN6%%Y8~Byt}KD0Dea?G znap16jMMFDGX6XUMpb;8;C1$O%xjD`pd5v>|5Sw}F2LQad-YCxT3Pz$5?VR;sW z=+@3GCR5?vFFiCipaFC1j7xTfNCQliB!oW0@3nX>YT_Xr8`IHn_TbjMTb|h?Ccjq z!@{o5a|fNhjst%&U1&OpMJb^ox#CR*t6lNmU0%)5)%1Cfm=aG@A{`svC*MXv;eBC< zoOnj>j?r@j7Ta;(oF{UP_pV#drk2rg(8e#!%KqJBX-*(CE!d^Le9%2Z(ZWsbeP35< zEeopryp>F@v@9>|x{fP~MFrNE6$gjfqGUQWURXNS?k?|1G@Th>6g&cAwv^09H_1rp z17dRLXw`($RQl(a7o9DnRuP~xnvrsX6-~~Nj3K~Us8y33L@0O(G*U*QX89Nqs1+hw zMBIjPBD6+pP;L9#!lkNtZcxOfP5agA*6j!8-5#Y@4L-0C?k_yAi|H=LH@%Ik>IPPD zH3I7~pL2K4hvh{lB60vd=ZZV7lrfEhCpp^l4H_rWjj~Z1i^K{60Qc`X#%EjFhK0@;V%+&^N z(Y*^PgR8SQX(${U+*siIW~|mU1#C9PC~6k{(wm4tp&3ODkW8?B=lMV)R1k`ZHDapM)_8TUGBFf$srLP}+0GIn6=DQbIZ;#-weGv9(T25+rL2sjtq7fvcG)li5p&zu!cwM@c81M3MD11>Yfv*;;Xaeu zX@c#Pxl1$JoF+6!Yry1GlRT&hfis{Y1Upu)OJ;oE6+JT%YlcRW(R5Jdm=I_LirXe4 zREjkLRLvCKF4?Red?2E+L|g<|Sy3d~pv-LaLVl5MY`)_f4_+#3>;q~f-aB;OenQh;RC4 zjbHWU(lD66bX%*F)37HVv37B;d9MP^*o^t~4x@^*7AK)17^)s0)@q$J)Yh#DVY;RG^jQyVU4q82*?1+NO_ny9^{zOnl!Vu?%fh2Bhm{@ z6+&&q-XlDx69_Xjw497(q_h=8mj+S|4xpMv26~BbF9rK(JrbRW#L?81q?OZFt;MO- zj$O8r+17!fDvl!Rz=-X7SR)z==E=-3vNdSlSqY0)>p<8P`%7`&vq)9*G?sa8)*9I4 z>v42aILvjsHxF{nqTEyOr{;J?c z8j2|u>^VPI)JBM<>|vOVXrX+T%1joTMJn+YY63;6b*`Js)Iv-}sj}9uG$hNu8%T@2e2rNA_EH%wWR>AR)h>wn}NBef*8~s z6?LvyuhuAoQ8g@TRnTSTh8oQV+QfiEsXW-)JBGuKrpx_K?|skv z?BRzW#SqO-u6!P@UcDc`_Wt+bzLRS_Kf6F{m2djIx8TXAK8f=?clq1D?B9Z#^qU|0 zkj~G}_~DQKChy$7tt+SZQL1?7=f4Ag;y?Wp_@$rwW&GsN{}jemLETpy+%VS}0QBzn zz86O4mDfH2Tdi?pe}PgA&)>L#-PEvh!?psK^B$+$BV50G7jbqMm2(1u9H=ue&3hP6 zvEHmuL(VeF%fM1BB7!v<=l$Hw%;wrKdP8wyvs&Zq&Ry*H6YiW};NtR<>&>dUxi>Y| z{blnq*x(+t!n)g=TM5)aQ^R__Np1#-p%nSimS=Y_v0B|ms}nYx%%dB*L9__Z=yx$@ zYhvF1lF-ajb54(nW)9C;W6j-SJ_8yeSi%8ROcXVTQW)cy(-BRY#k#Dl4bA3#jd{Pf zRs-AZQC#kJGC8iEoZz8{AHg%br!d4A+cnJ2EB1X#9UNA?itssqZSe7#bAUSZZ}?d8Q=bGe+cjWy5EEE{RiKRx4-@ExOMXmsK8?n zKaS^LcmbQ&Z}D5+@h*Jw)1Siim#*{VsX?qvf~T@=n`2GMff zAwxr;B!(0Sv%aAV2wf#;SjJU|mb_JVt9>@?{egt!peNBIUpV?uXi=o*w9O8p8a7+H z=R^*4g=xy{q4W`H~8IuLN&%Y=dG5UZ|g~%|O!5B1Jk@ty>hb17fnTyefKSd=&AiL_f_y~@UdcMcF zIl|F;jlrn>e&W2}Yus+Izc?qDu_#TAb(*;&>BATifzd|R5THHkx6$|LA5}wnaUUpX>Mw*+LG`N)Z}3s zp(=||K=rUJn(IW(Ygifjftc6OK-UgIN%CREAkZQ-?}KIrPvzc%E6CfTTR;@CpbA7~ z@IZtRR?#GkrJ&Y|X`ZxNZD{7ue!{JrulOrBUy8>cdmMc$m6mP*pLz00{1<=v&sZ_w z-@N6NpLjysqYYnp{&~P0$4AGwcK?0y;yAm!(9!0&Ba)dz+69wAa9kBV z{LsTR4w!Zm_R}7fK;2DPk7JDE%IL6pKP_RekD!O@U@1lW<_`CSF8Az>ozX44$_m&= zTIihhltC}HKkH#Z_lnG%moL=md)7_Z5`vTu5VtJMnVFIB(k+9p8j5yK%0bCn!5-eo zL`q~NOaIBa*lPqWLYgav^(IdrD3?CwFcM{5;2^fAR}d|vdB!|f1cCkT(x;fqe7PH* zd*MZ!=ZL!7Zz`I(m6DrIQLSM{JDR7cPOQA}+e=bh>8<;&9oM6+u->dzZI1mg6qpZ~<|)q4E-=?U=KTaE5g-yr9g19$Wy0Xx zK=&Mks;iX`!BL$ZrgWSn;Gio}f-sg|s7B&gx^7tHz2R%;4layB>)9BK*T9urv$WlH z1c`MHq8zl&@{1e}hviTiJj_ZvCZ}J2z&(Un4-_eplJVRCogg%aw<~fu+A( zKW>Ye!45y0i?gBQj10LH_C-XnT(<{{tk8N2uNDVFaac6K?eMuA@G{7`S-N~v9TtoF zrUxe_@+A@<6!*B08I98Kk6t9)J0cUIrjAZ?SGOrIh_?o~cNRSkHt9u&#XzEBl#Pu0 ztK2CIeu=%AjQ;)5GJMPLEh{AU&@6*!=Aj5Pf+16~l|mu6yiE>P>lEaXl&Dla!RV5S zlrjBI2O~PIF`wK@f>ko53SdJzW||8q-3K}_w|)iSzzjI_5Y15rLhGQmbQ>62!F_bK zO*9%>tkkqoXwA@CA!42fKwjOfC>lQZIn#b`HaK*=;qg~|Jv12VM?MPMt~4HPfbE)i z`9)xTBD`<|c%;GqoqrE__=(PzS^;R*w?iO;FoQJ*+-P6%Wx{Z1U;s5&1~AKflF{LkOQo^h&o`FgRthXLAq7RjW<=17Qhi| zt29%D9n(00c4@R?j;YNyP=H#S`$TRPuxeE8dYo!x0a6E&bGejtl3tK;J1bF?w5GuY zj6oxT!C(X7EBBDm@=@opVQ53ys-muP`)6JePEpMS%|XFqRsWx`*%#Mg0ic?IB50D|BCSkzFqp6 zU!d+@2Jb%+qLMdWBJbYeIwqBiDJH>ct&|PodZcsAw2eBz+&EW(wIRF>hEU92XtvVe z#$AkU@Y#%LHm#kQnz)Nv#|UkWb}r){CU3$Tf!Q6kff0x+E~|tpq`icRfFw0a`!I|Q zh?#*j%LHcZQ2?>cW6T6ZMe7*ToQfJL0lv!#CMiah(*ZJ!BAY>801XNofpC}?F-k@P z#EED}u(B3#1jQgrToC3uhN84k)jSta(A+Hcdo)!mGNLu?_jig-v!TvFojmU~kx&JL znkP5~7gf6S+gnq)a~lkkt{q`~{Tq!hTxb22U#{h3DC1xGpD=&%7aN@#pZW~r^>0L6 z0_Dw*1M`5(H@{x({`=T=6BHr~T9x4qygrqvgu*+(gH9+)Ug7>O6EO{`Mi!E>I zF8Z>+^Rm;u9avm&vIT5{gV=(WwQ4N2W`9lI5rdGymYkd}1XNe=Hvnt_x_9zvstDX2 z5kWKaR&#poOu<;8btfxve0xBY&Pd7d%PQ>d6TC_128A(?1_8gN#$ta}@qQPy#0vCNr7 zIn;>+?9SFMCQ;9|A^wrl;ZKf=@{;XCw(fcqvVLE1oy%wm=3vw=&eQ=T zlW2ynsR^WXKhj-Y0L)@|aX@XISBv0Ai@8A*kJm>nAdi>>Aq!N@bHlLCA@ej%nCCef z!!Gta0K{fJ;{5yqgyG@)9*os`YcIa^A}=n^vAev)-8<*p9-U&K&?aefx@oJe86=BF z1ZDFyVKBqKLGOCky8tIIF7D#W=@#dgdl(#(Dtzb}MT&cv%6zuKN=~9FV=z$btft1y zL+F7;&amRWeI#1UMvkd1ik{JAdEF1=0K1#B13}&$Eis4S$@gV)Pb4WU7iyshlc#wV zwKXfHD9{*#7>nL19Wg{5D#25W?q(jE;~8)`1x z=004jhNkl-KHF^78d4rR1%(_SC4=H@BW=hp{t*J{)M-{ z{q*Dm0R^;VShPO+PIr3rKGTC}N@qL^x_bqXdIP=qsk#d&TX-H+?}wgTxkx3Ke2+fw z%4L5(4{-0?NvaBvfmqC0cf_F^#==2g4n|)F16=_ZuWFbJGi-NBtzH^(N$_s@Uqa=g z2`If8?*s4FPjX+x>j(S!(z^Etmj&4JM$9_e4uiMkmj$Sjhame3oB&PqVmdxL#n1ix z&;R#M#v9-GdA?e0Bias(N)tH@YrN;*yqm4o_}yRoHTEO__(ybhb{^~1;O~F``|R`H z@MitX|L6bVcYW9YfRBFk!xn6O*E@e}`_KRLKZURVy4}B}Y?6-d@|NZ~q z+x_`xpPk?Gwzov_(Leb9_vvfC{%c_{|BwIhf6Vhcw{7&bYTf01-U4%-+G^Ysz;L-c z*WJ5!F%BcX>%aYPB|^_X|GYi(x##&S@A(zgHgmH&M$*L7Tt`5e#+wOy?j?54Wa@DYJCvpkJ-IR~RPthZYk92dJCFXsz5fT`_q=guA6xpT(T z;|%`N84ju?$71LI1VeEo!#YjeSBaY zV<`w_{k}Hr_B)Y|qthd>H0Qel zFeD^{Y(RC=(pj9r@40NvGSM@katu{#4KQF2VuqP0o)!0Jqs3b}_{CEaS+XJSvviP)~!QeR%#R1V{(VM43bZRy{vfiL1Mr;|*rga2|-`Ay9-9y|KsKJ5v zp67&tEjo(D(vhSbSX*CiaS0>tf);g7j4x=ijx3{FS#)?3SfQk5<~>)(ZS`{K9LvGjq5}i zg^zuVh*|h+e@S@P7k1TxEe}>88pY1~1cj1oO}p{{+Wl+jU%Ur6y$^evaCAHXcXo0* zwIYYP$zXJ&p|wNM`#27$tpW(OuVUSK@0{oh71-QWHw3g zaExYXmbnU}8-qfV6)c8uw+I+!66+MJYn6dnRt-^UHV~O|ZNRLou1#s3a}y}D(GY`Z zL~sCTO|j14JKKu5N#_8SRf=TI!?CtZF*=oE9l#L6MiJ|-i7Pc%;$y(AHjs^?g=weO zTD8_9qBRQyT8*CXkT+kCcAP!@!E&M z|LBjP(NX3-SehMziPSQ=d9fWXT=kyhXVLmbxQCbgfp4Py;P+7#YkB&Hc zDtqR6k9BOc0~o5o=5hwqknV#9wmN}iF;i`md?w+o6+t{fFUWrHH%S};a(fN@5Psi_U5O{lRm;H(iXq&e3YaV)o5Y1PCcwvA+fdqazGuwo!2 zhS)Z}9Bl4v3R9@f$|S)V#_+tq!cA6%Vn!omBARrsb#;o8kAl3j%bdan)Y^g`h_$Gb z;xILA<=UuXJI~V^h9MLzUOZ|Y)n-#mbQR`(QXUjUo56V+HCM7tVGU-YAsWzT_tu1A zRJ6vj+q0CD6z6O<=H-ZEt-$3i`o}(o={G-&dS&a!|HltV-|)>GKw5{xJ8Hvimo0sD(i{dTHtaD znz|4KEwbvEZ~)V#bDX5vvSKwxW-ZDjhAoOcWF}3M9cq2+X>Sqe^~Alv`y~`kE%RAg z&tj7z1rdwFFsviqvACfRu2BUKbA{;2V^eal4?}C{FsoSdd7=v;qT^-2M7~rJ&cwv@ zfZS9YM(gjXKlODuXZzoskJc7Im>*Cy77eh1jAVV4V59$&b#cC?VKCI1qZtJwTiSpc z(Auo4M-NmO;X}#HBmkGYGu!R<<^1mXgU@{KnfA)9+mGG4dGoa|y>jzicW&N%{Bn2x zy35`4;BLRaVphg!x;$#);9#-hprNPzjY+O>cV3Z@lKwM{b^+ zp59%rHs?~{!N(p!G~x2{0=wOWI#2E5;u5?44pW`DT5Si#5>7g?Jn~S)YPy_3(rD(@Jtk8-w7tgwFH=A-wX4b61%-{!9P!1ql z1fnWzNX?Ap;*3@@_^ITIF)CzZT5Um73)0hJ(&Szs_OF`_%!}PnN{58>_aQPzNDx~z zLKZo0r)nddkeM?PeVh-+#aD&dzX-iqQ*dakSdt=5QF&G)psc*f1d)Nfj~n0BMX^JlI%l&TAhK zwIL`!yL}g*_~^%Cy&mmyn(*Iz*ME(_`M3TCS__P2Y^{Oa*(JpcT2n%iVw@LPUs`^Injefq)w?ny#1|j=THXJ-389>-a)GqMBvt~+xC%P43;*7`-u2E8%)6bH1f`|GuZv{uu$MIC5H~t)4RLqfdSU z-~a#l2mBph`X&10XFp@V`}cgE{>8ueMgHkO@h9!{>Pfuqo$usN|Kv}$>(^fyKJfkz z;3FUVSiJf3Uhl7e-Rt8!{^EDxCw}6`U?eMAK7vc(YQ14Gl-;z4)Np=zX#nu`U;BIU zmUq5Gm*;nFo`H{k)3&@D|xW>ux6>QdP+`V&-)6)~(eB~BnHxnBZ=@?gQ^Av?~J+4F}T5GV;712l^ zXdpv@LeD`F8yX>_K?=587DmV&)q6H-Hw6)fkOM ztpX9Gr46S=?MabYGAWI|iEC>LryCi?t)Lmy45-trsfF2Ks%mU)Mi~oK9P{NqNrknt zP7UsZ7zmS0Xq`77EQ2SSsEmjvYb`M!tJNBc#yU;7xN`}P1qH;kuX^IOPw-7|d{dXR zmOyJ6oF0hPYBUz(JnaQQpZd%v`)3(+8gJdYiHq|K9BsEaI@$sNt1{8q;H2%5>*0#a z^9zh)!O8YmUIy+jCv(r@^w!N6;c-7+dj8pX-5Xz@5jLen1hzuUjeJ#4YzLq`B+-v8 zst4f&KuZi08<&j0KIcjmLO#qIoH=Z?9>xQu$~S^21yB&xgwicKoqd|N&J45B!IZ!S zN79f1-63xv%Lo+LdK_R@P|UI2Y%s1o9KcIA@02^YZk&ALlP|pCbDw+u?ax2^{Fgud z%yYl>=B*nKPy5~D5$&cJTL}fi0x*7c3AVhoh6Ah{$r(XJaYTaozMTs$3Ob-z(g?&Et>%`eP5=|EY0Y*SS{Jwoi9P6ZX>%b*kxBYOgA2 zJ6c5SNiphbW?FX@^%-Un*b)Vl8^b*0bXbn`L2~eb==Kcv?UvWPE~3SObI-nlS=>>n z#7rAzveQ}*$?RNiE=r=@zgc9^OUaMDYsPaJe_;1}4vPbTFQFo2x1My1neos}=3vmZ+mMO_%eT z{kV?|5HdtAPr_ccIEXBAtuvQGj+}iPO##3nsIDooe*J`tOk_h?CTK*5zy@FSA`2Ec zlgUgNm`o?nm5dj$6@(We+;dyEmb^eQxHtx}A#8-PL2VG?h(Zb28q_LktZ6s~c@f}R zbvpIX7A+hRMODYBQO29sp~qgs^>_VQ;=!w||N9R?Klr1#^PPXmkABM+U^qF3Z;puD zH;DKD25|E_alFy=jlZA%@BRnyaoroez@clWiyc&zono()OvE>QBg!)`0l(+pR{78W zwD9Rq8ve8YO#bOlGv4u5O_=DrngsT>1#8pR-2=dR&Vcj0B*E6y%%GvBmLVdhDd1LF zhS4h|)E4qWQlmoqT!GUmmPKSiRt0 z7%FNS8Yc>sQ#5LBZLZB*o77r0v7t2}SR+?@Vv7LL5|M_q<_82?oYN&V*RtHmZBtXTQ4CDKoDgZ4Y) z)raJN`8$Ezw{h`j{vzV`d2H4j%opce`+#vIZk?Zz&IlfJSZ_##_5qfbUMB6spjqjq z0qZ1J3{Aw^2Un}L(os=40I{iGnyf; z_p^bcI8BaPfpG=jofB8@6Mo;I6WB6h^veo--7B z07D^0g3ZXS;A2D#bE_jWkoKriYXBZi$3~3-8xhsuhB`NQMpdh(xtUrGiDs>#sWk?? zOf}GEqQ-z|Vnm77!drzQ!VUDBcj0vBwc{93eViuvr#}_`(u=gK*XTxW|L7lu|F!=f z@$loREvyw$#%9&Z^d;|rUVNGHmbasBS2O_gZbo>9E~afbs1%oz?oD1S;2unN9tCIe z;&NwgCJIG{nuUfHQr3e<*;-hdx@_oLn1SRB$VD~+ML;8&xR5-?Nm*B+*C1Srd(fBz z=d9V%J?JpB&Mfz?Heb|z<~e}mVfdZg;jEJku$H$}uODQsGjIbg_9$o1!DdR?VN1F> zyPGa77xU?DC)^b|*-u$jURgb1J7=XXcKBYGrFqt*%lsn{NSc(oSRsS&7dE^1VZ78} zaL^hE&s49@b8lU5O>>|IMlbN8#OcW~hT?D=QC8`2ecx|>^x@~8edcY?JpJi+e(LFG ze$UNYue_@^JkT_)YvqWj3?>O&)gV+H;_4ElSu+T@*b~%JWkkh7GG`N6 zLK$YmJ~z&WMxMheG=eJvu!5s$Zdayy{<_=e7kcHTSBwRMXuJKzSH5)P#Xt26zx2y> zfK6dG7y6xXJ$!O%^ZMH9wGY4TZEt(eo8R=Nk3IJ2BcFQW@z>nmuC|xWBBuR}%l!qW z{a&>;Ow%57ON%|3jB12HPvlFqmNj)p4yBMPhwV&STZ%tQLo~}iz!FE41%@LmFeDoZ zDg_B|=pvX{`j+e%@NjI?N0>|8~2^Rn`lo3UaaU8X~JR=E>!-(B} zpC}_Wti~12FVEm5OY)j!FJ=K-a}2{MGvk$$Qyd+w@$$h6-Ac8S)hmmu8}zslD>@dVIlBMUaiN7$*~qkV~C5vVON4nvnFc5_M&6iET4 zZ(kZJ=DuJUhA~;+o;yC$)mrLTmO*9d0uZ`kETaY=$S#1*ywI>%(vbkERQ0l za@G)vv(qo;so6M;DZ*hxL#V29q{K#WjLb)90bf!mQg5kGY7MerP~6e# z+-ZG;njzX8QHo*8nT;_KO;TH!tcs{KV|49$62qohjgF6e{NwiU9n zeg^M)$J_BEKla0V@B4m@U-DajE57gh{t-6YO?=|xAN7YGd=P<#qvI`x)quNq?x1kM zYhV8wy!i6VI6FJzbI&}jFZz<-#_QK_;ImIXg@+$|6!$;$P|S5IbtaCF?!y;-!50qi zdH=8C>CZm(ZBF~HI<+=z#%?g0dtaaKbat_3-+Fc?eJ_=f5BrE7bjS|gwD0)!0kf_gCUZpjWFx_g)A~M1TUWqJiK0Y1!Pa*K7=49wzY9P>QKV8!T;xux!j2CddBoZr38I!V4N+^j|@ z0>A64zf$vDd2wflpZLFi9CvQs#jqL>G2^nf9-f$ns7$&oGLlAX2Aa9||3>*pDx`a$ z1$5DO$^N_s#xiKNT62>;EbMlBT)XcoZ{57vgB%g73{mA&rx?rN>($8OqcU{6FlvUw zhlNywF<3N(wTN&p-KtC_b6f~TpvaSb!wSJdO5p*`BchpE5n8lh4~TIp3^k80xc9p~qlcK7TO5z@FGG+#8kxVXUFW}KX6_(W?xHnb2nc`o=P zaDI8o^W7c=h`|R=He-K2p}2wW*iDzXaqE^TEXLxt+gHGFQs>sUb!n+v0)pBikXuB* zNL4Bqh)OS}(;k^+oLLsPmIv0d(N1~Jf}qGOZ8QRd@vuar_wykYyUcB_MMP6^gO`G_ zY_ZyIv>sO|tF`9cB^1JbnsN91*3sSDcVF|lXP^DNk9_3AU;E56&%Wix%Qt^p!~8(h zu829P?6YVk@SqmCNuO8%lodvZ_Quz}u@0qha1R>?JJ}w`0}no^^|)qO#d=)hXnUk# zHE6TiIL(b}Z5&pR!5)0*;pPaS$-|(_i-~7vcXV-f#+zq%c;A%=RO{@QyYtvjwOqgP zvfsXOGd}y&Q|-l~Ml`vB0X=xqJodnE-kIVff=G`8R1u@TAWV#(Z95uHMBnAY> z#b*K2KnW3WOZEIH_*&FJs2DgbUA4gnp>7eeQEP*sW6-Y}Yz1K*gy(R;SF*CPBB$&K z4?Jqq_3JwS{vXtOKXZEeNvu`_woiTveCjFeAAAh)Yww3$o&on=3H;G-H~h}u$@2TY z4cM%^5qwF?=`+)4ly~E!x{opOLGu6PPqV(|E#U3j^jBUcUiXmn*Z(_ffA~*pc=2Vf zuRR2@Vq`*bCP{U!n9)Ks%RCz(3aNn+sMhKTnu{RZ!n)co7$TfSQcX9DO8SD(@+9l) z&hUn0$E^b4Chq0R@Nj6z)ruT4r!*#^%O)vCn8QMIfN)0*z!aoe7zuA-CpB63t3E8+ zh*$#}f^ti^wz>NV!c1aT2Ei6F7*zIPnG>BBi1iS#!Sv%l4*RQrCx);7Y11$N3N`JpR>66h z!J`N8z|p8p7_Nhc5ayJiMWd0?toD4O63(`dfSO6}v{|H3=L)uP4rOC9&;C6i*hEL2 zYjdBqZzBf-T63QZio?uN>uf+pz-czo4SkbYmf<1T$lMjp%_5bm1uRr+VJ5?1fEzjej&=| zy$$Uz{1=KH#g|?-D;8yKSUIh!Chj*BC?&ri+aos*-onP5Ylb^KL=Utn2%6JF8d_;h zvf>u4xs`$l4J7wDF0q_{v{uEoO)N(n8Jx@vbgmQ;FwPL>6fnyuH3U;Ll&3@iB^Jo& z32;amOk@kfKqJFMF%M{yyyuA*0tkiEII;|DZxNMkq*&Bq-PG2_$Bj&Drw@u|sBsK) zx;3@{+te8I9yBw}Go#gDgQ7E))nulC>P%~m9vRBp=BgD9t1$EZnYp=bi%HKu7whx8 zoS*(A_EU@1XjZ=P%~=2FPc**v4Y^i#mq+CJQwpQ*J^sXhi1PF^xcIH_fY}k|8i=DU znyF`njsU?>@1l)%Fo`*bDyeHtCJP~wb5?RrB`2*446~>$g`Nd~nHd_wNlY0Nj@Czt zLH2YQbs0)-uJQ|#IaE`to?eWk{Iwh~X66}t$*x1~6@7W0bwfvS^jbjOY1(X2atADn z`Cb!7pBMB+{^E}J1^;)?O_)DZSU#kzcybKBh@NAz%~!6x?>Bz^ zOFr?5Cx6GsKk>=0xOwN+8!s=X2TI{aXsc;z`K2eDw{^aNdqxtr))tPgnGvzsuI=dP zRF6LNAXclbj<;K^HY=F9ZI6z%Uay#>&Oz&8lo>c~R%8gPamCeY1l@Gy%CVve=NEUi z-_O3=PmDPUw;|)U;O-`u^NWq*5i-A=EvXmrZ@laV~;=j+!HDW0{K&pRovGeAhhSYqH=ShAg(#h!20>^v3|a)E zk>;*NsjBo5Tg(U%eM^Go=s!E4$Z$zSBu6h#{A+-4e00QNJ;JkQ#l_{0<9Z~|1WHmg zmfmluBIa6??cmve6a%7(YE`FK?_*i5`SSJa9(9qcR_x~rh1$Men%lspz|GsY(0#8E zkU=}G+R6(bd+;Ga;`;blZ+`1r@k{^u-E1{crduB%ceD`3p}-5#T1BlhM8egVMu1py zrBy)HTA>>vxF9yrvpthzkWaLTOa~!QRilfKtO23SE~VI{ zCVB*F1icJcIaudeyE&*v&2?IkrzAZJ$%}3rW8}kf+BXcN;pF%jXLoMne4bFo0sDPL z!w$xh*Xd}++7jml6KgY6!r^QJgwT7PWe5>kx&))m{$2oPS@9(GQ z;Q`dG?tAN2y=R}b*ZQo79>U_{E^KaX!y;sUFo#LMU33|UPbbrO^wHz8FgGVcqVF?K z9REbz^{Kn`rkif`|Ms&#Cr7WoI)3vv-;Ph;br;_KXYauiPd$mxfBqhQ_OoulH+>#Z>y4dvX~^R~Xe zDQm0ebu=7eJnnsN-sNq-`D@eL?z}TirsKm;ojJE_VScb8iNG|&>P9qbj|RQ!N7c|b zqoL|0D%gS8bxP?mpeBaayV$wh@hW#7>(vI7>+RB z9%E`91~Oz&;GTUbtymbQxpPR8#su0HVJw^wmvD7zK#~@gC|J_z_03)EcncT>w|a93o8v18?VxsuEg3^y-0I;ov=tZXU-NoiF% zXj5TU=7u~Fv$>tQj zbsj#He%eK98_X{)!wnb>M&+ZarJ*~_ifyxsUG5qEbP`QFWYbD;Tr}fSfl%UQTbo-D zrL@f`CX*G0t9pcbc(L?UMLmMh+V%_rswJsXn1-y4$}_*V%m^5;9cFhCW1S^3S`XYR z7M5FeQD$Z+kAf8u0Fn|^o0uOq1`6g!BZw$AH@C65wK4bT$rA@2KlS)a9zOQSP4mNr z?t%O7yM1GG>)MEXAb=5`c9;h#jPiuFs--6Y)-(eh3|s4a=b`FE5VL-hKP9 zd+%->x%4vGy=QL#u1iY`vAla(b}cSQ(+)Wpv@vK$D24?#^K-+H)I?$+dqipn7_=$8 zcPnZFrCN}HU^zQ2)4Sf=rCm^WgHXKhWp!;cF07p6*7}4`oO!}_EiB0P)+C-f^CTaC z;uJso*?aNuqsO?uvJ!naaR{^3;4K*v!IZ5#^u(DnU;FskGp`eJD#Eddp1=CCBOiJ3 z3-0`#Yp=fU{>9N~bJBNc_bg-e;yTPq8<{HW!Bv*7F^fS}SG1sTm^m}i_$(+`XavP; zV|A%o#Nu!uRCmfzi;!DjpAk=|rbO$-E8-aiqO%JaXM4M<`c_k~5oG?u%^dJ9I|9DXmI<{~W#{j!m(ddAEp9ETx3zLH2`B?# zgFr6sFlt#!L`|HaEK@`cwcZI}20fK~aQ(0rv_DZ1ipWUyrUJd%VP0SzfoL`Vo{fS+0|BNQoeu0&8ps36iTR~jYi-UQKa;21^rfw+$lzTgoJ+}ohUKpXl4 z56~7CefW)EFY?)Yee07Sm*kGY#is&?_7SgmA@Dul347UVp=;|d!%;!}F`!oYcv9i4 zDo)rex&bhkk6WGw@|3c@9`fIQ0rud-)Ek~h{>Cpr-t;xZyZ#zjSVS`rh&0F~26SwV zGh9Pd8yA3G6x=isVpJE3P>WYVlfszYtpVIA5`;%`k5CE$%Z2fWhUQ?>PQZcJ>?D&g z7*in_BI>{p5mImu7NRPM$dnj>+5{mGX^IKh6Didh2Mx#o;v={=B$^0UIOc=VP-IZg zl@MSk)RLiKq;Qm)Bk?6b=IERw4LMAK+(sbv+0-p3ry%DZFbj`9+1)46{K9$QO|J*$Mu@Ag0aJqZ+0oSP zA6)|;%yp~c^_Cc%NpCe88W93uiV)^N-$y)f0(k5Zkx%?1+$FqtWE;wAXfSDH_Sq|Hq$^X3zrP@K5MW5G^+z?%D-x zuRC__rau40lzoqo=gtE$<}^E%?v3Q=N%fs5dxMy4XXrpEP;bYMz5)6qY;r`~gmry6 zAsdBSTYz)s*&9=YS!YmH6^aZ=v&d}RZ33kW)zEXu0a`@#5zqi#%(F91$#AoNAQWm! zxr~YKi0A{z5$Y1A5ycxwiKzuuNP~Do7lxXY!cq+jBEp6iMic~aOZWW+(jkpUq!3LC zq<|0HVy^TYMhbzLO(R<*n@l3i0n5ywhdU#38Atj|xIjYZZlG%J%ZJ;dtPHc0|M{)JJKl}y zk)!az0NC6H+EFQL?@)e!6zCj9yokotaU~i-<|wrywW;bE%m30VQ-=f8*_dUT-|?NW zl;?o-(nkVexIuhYxK=}g@R+@)ED(ig64kR@5_t*~ki$+|w6LRR7)IIQRI|=sVgXYr zh(OUY=W}+ypY^fLJaW|z5w-NQtPx9^z9Izy6rpi;Ij9SIsfkI}VUjabR5kX^I@=UP zeUgI3S6=jroqI>!=gk5?wFr}B0TDf;GpI`W6xCQ9v>43I#p1#|Ha6DMlV{EzeCXj% zyx}un{NguGbCxGhpS@~pyuCXR^HneP>ZJ5Z=K^3{CLq-`Y}1iTFXQ#kzK&O4etDO3 z=q3C2ac+KIckf=beftk^|G@)k@1DKBw6K6QXt^*qZ)ikmfznf6jS7KSTfb;3NeE^j zRFXoq?KM%u!z~*vM_tj`#4ZKn0DEo^UZq=4e|>C-XUn(~R$ zPhrru+D#^Y?(BJ-KX+PIH#YtBnF~07?o6Ier>L8Nx*?gRdnuk{>D0-`zT?zmr@k`~ z<{tg9X)YYtzx$pSf8|U5?E34U^{M5Bg=5)tx_9>;Y)w0K<1suO{iH_;ubTvui?bA+ z)`Hyn@hCsg1f*OoS_eosK6EDU73RMo~q$VSZr=0+(*myOP2TxEWGv%X?9jqhZ2yyp0PN zFW|@}mx2&qyLgeJisfCqWjbysl<2w+xwrD2mG~%wy1USHJyGRmoD|fr>;S8(fl&B9ZGV<&x1gg+Y1Tl3MT#iFP=4p@K+-YD^;k0*T ztF#UEq6|4b7Z}j2@2LbVs1Y!F^avkeZhjukUIw^`hlF%z?!5)&?GZ^kF-D;f%iNjbD#9e$%(${-6C%xZ=tyVtc&B zm6a9r-PDyzL(lW87vtW$@6n~*OMc?Sqd5E2Il4x^cy2WHH$Mj-`MVF} zh8wQq*>mS(xHunI9=Tjb^K=RLUP z#vA$k=iiRM`}>c@1NYq@x88nx96x!2cWiIr?CG;Sc#+YARf=b!T=Nj8m7Sfb(R!h2poZy z4M4)Xj7Ad%gJBGYLuLoI#$y~gav0l_3D!3^!_6on=sd@$Z8;c@*!LaGTv991uxv#O zuYoi-Nm39nIWiIkLKtA`#wc|{9!QeJtKda)rXFC$U0wYBA* zP0h_j3K3J72xLb<9=!j-NZLkf+oJh-jwDUVGpfqwcq1ArH@C-FTv{YhifdC!Fmv(B zstBq>OswnKF7GaqUx~*c$Xvza)hM$HgW{vGWYb0b{d_9A= z96N)5373}f)1gtfhBZ1?$Qb(c?-xR4*7YG!BcvgQqd6=s?ZO~6=(;hc!;Y7fI6pvPD2w824 z8iTgLz{A5S($LguPAH1~lop7n4|8Ei**tqj7$};oVEC?0(9K3TnR&c>4oBOD`X^0xJG!+`Y5 zA3S#AJMVww(Ki#A?Ay2J~Lu)&_+V$r4m|bLfuq0K-5$zdB|vY}5ooE}yMx&_R{KO8HN9H?d~cJW8V^ zFyo-j?w2(-A%KKc?92`^21!aHqA2CD<4t0H&o$tzjsuiJ@|iiMWLCU2bBssHaA|e8 z*FMg=1c-ueshqcB*-GWvRyOA)N|H)!bY?|MQjuwO5mm2>B}NS(&H4iPjCgYZAtmv} z8kwHCuIejP?wDRb%vuJHS>k+Fp!&4Qr+x+%JB71=VrC#?B$$@uh}Q41WYM42_jb68 zf}L4mXG)&g@S-k5DyOED&9Yv1#90bgLW+$(f<LwWd%kfpTRi|o$i zD3zuNv>|LtVk^`cD8oEk2__0v8EpUqKs-`3bPhe~h=E}PUj#9Pv-Rj(>&7F^d3TtN zJm&!rBE4$_nZ(?NLundCx4A7ic?RumH_7k^{~7FxtC9cU|B~85_v``oUnc53kWz*7 zsAy!ENWtJ$)-C`+)><*|UZX%n4uQ0AC*{z=(DN&ZFWqZ-{hT(JTmo|tiEL*x#)}R~|Zy*2>fk$FsRCaGM=ORNfZxdAl zd1R151eAn2(bjeTpj-np=AROX3)Nr0*Dml!e+1L-`nH(cy@xn_1vr@kqXdXb zoLQMhxiE;+KPq+|gflnuP}E@;IuAkb52fcFuRpzI4+&yB$%#WH%9a)$=t zVp718f@mx-6u3Dh(J>NOa+ijhM-iB3aLBMWTuOtvmX(Wx6zkYqkRFi{$#Zyz5EJw0 zqqP6HGt2@O64}E`;HS?Z z;Yf{OX*aOCLiA(s>{(!G8S>ok}E69<7T6LscR)JA`gYgeig%65-;`(y1^9Fhi(jm{4sl0zJur zQ~P>-H6blK+fps(oqHCyFjB~nRNlK$$}#DpqGFCNNCu508|fKdW4AeM1R_b+;eRY%(zrWq1TFyU=o2&S71qN6!+ucZQk6K)MSf5SAH$Y0eVegpsq0Ia{*KQQO-x zYFpp+f;$n%PEaR(BqH+dH_5{Mze2j{Im|i;Zf{Z&ld}m=tr=8X7^Ituz2{Gme(}FD z=H~!#MqdG4@MVDNO>5Vf$d{`*--2GyBv zbwG+bcNB(O9hxdembJJ%YJAMAU|H%}OB9ao2(A2dcSLAmxRb>!p(V;c+an+ps>RG# zIOtw<1h8VbcC0kTv{z@Ss?HP*p(u65@KXYFC1q5EdNxV1Yknz4^9wk?dNG~bSljjY zfAjvAef-|Le|&3m>oP~|n)wW>C84X6Zs!PUFp`uCuDQkCe*MvF(;Y8*L3;ijxB4x& z+=9cG9q~ciM$Rs5M4MER=pX=%Ul3M#S?IyVJpv_~Ixf5AE+jR5AYi$JXL`Wt5v77hNi(x)H{t5as#))1 zmht$LPwM^mKN#cjlqVj0EKVFh&c{xkh-1edjqUN4TjVHCfD&*4Ad|j3{MeJH4?p(K zcfO85sOVag(o@g7<(7}$^1SE%+Ok2(hpGygN)xF#p=l=B2vu3O+$E-uB&no4)Bz-< zplU65nqi<4K~gOu5~8nSAj86?aRo{erk+6#4~9@{DHR|R?jEEoU7Y5{Z#u({M!85p z0e4c1oyLV;{LU_g<6eL=efeCd)66400BHan*9frE#e+d24AC1z6e?m}pVht8rbabB z^_lMC!ieaD9BRg3)S?+Q(5``ZJ=7bZ0j#*}VIUg;vI!u$+$V`J52BQ^GKbacSx9+J z#KJ^{z$6<^J^qAVJwL!_@BS?Axcyc{0B6sf#lz`{_6dIg|*cSXoYy~>t2UD?zkf!dh}sAeB?6plL;RB@_jsf zh$A#5Z0>IDx{Ljn6{0NsGxdf{l z7X#rkYUePXYy)1vO}%@J<`(4a`E$-jWp!f>Cy$-L&9~nk|K;cY3x44j-iqD3mg3mS zi=10rLT{N80;q_RP?hq5rUXSWOV_Y1Rqw1|U51p@b;TtVXM&>{4$w3M42P{x`>71) z2I%`K&YU>|H^XQ&ibfK{EmCSLLf0`IjxcOT2+yU#i~^4w{j{U#0CYs(Wuj3uDuINu zsq?7KS#>1Ta0!tJFAmQD%}ZfX5xfHMT4Sg{_8iC=o};ju-H_d-QUn-*$d(JD--9`u zYoa(2(R)BCo*nH_(Dj-0phd7%ss_;67}66^!N$fW=SJ&38V!W47HO+h{!9eD`{(cJHGJ6&r4?+0cXxVwze_`qk$<@Ha54=^*wUVKy?v|uqMO{uPs<; zjH_E)IB=-czG#iBH_ZU4QK%9ZH`ZYahztNu(Kc;sWua}7yKWJI5h2TEjuw+Zh{9E9j{}De z=u2MmQeJ-9Wo$;nG(Q^U;c%b;rI7@xgbL7S_cTzYA%vwKQN%SwBTuIifzYNQ5Ogz6 zv(fu5!mK%WVI7l=Nld%3=It&f-B{LF*3g;BwCiI$o|Gkukb^-JVL?zZXos<|IETZR z9^~A@0vDHeaWoprXf!N!GiI>9)2Ty9g|v;h=gPclFuyRz#l@vKc;FI$$ya}k{_wy3 zHx9T@w>RXm6UY1yfA5d*$M1f(k0)bXym$etFTiAHU)H>mKf>Q(xcOLL-8%pQ6-$l&Y7Va%h%#l-F$*cZ#Em4p=ZE z1r0~WGs-a?UW~YPaa%-NcyYRyjI<-+=`%!%IEPtUNoJb0l(Om)fT-_3D5}?P2SZX! z%rkMlx}J6lNOw|$g+DjjFwNWunDvj8gH)bTbRr-u%4v$~3JVBe<%n0#meo-%l2RJU zB@`inR2R!77*H>SL~Ssu>wwyfDlR+m<(c4L3d73MLS5lrYTv|XE}a^OgjY_gBFxLs zQ8oMG2n#TZt7g{rx)ZzR%t|uDj}-1))CD-}%)pTH^Yr3GpT)dOFPeH01?UWdk;~$M zvzep-lu5VZL}IG6w;JoH!3Dy+M1=?qk;jmSPYs5HNE~I#OgbO9*9{l)6(T`pQ z*|p#Gi6@cIUKE~Nfv^Mj?gNfoHM2{Iq~d}qqZ=#VPG&S~sTKpN%0~I0l`|2iSBQ^( zg4w6h({yyxR{{6jhpdEZnU=z>2=%RqOrsbj%dja(O^_-9@rv6jw*+$&WpN3KlwEjg zBtiw|fSP#%>6$_!B-lyBklOT`JVm9VMPL{r42QYIP{3`{MTDvNfG_~17t*3M3q^=! z3AKnIi8g{#u13C4G?SPYM;qk8VS}Kg>S7s2QC|jxBzK>y1i z15cg6XfV(2@~ZOGN0C!FD_>%bo(h08K>w1LqZup- zf8qZD@4W}O>tpUuo)wJ8Xs)~(*xrcliKiIGVAmIksm$TwO#n71{xo&~H1f1}8738R znD+sXFo{+TJ(CEKy~}x|7?`Se0XE`Pr}yd*G*D2)-Ft^g?I!7o$WThmHuGRl(9OId zQ=rUk=pvq-qY@-`w|#Npu~5jm^TUq0q*+(;^=b%D^F3^*U?DXpETxRpJ_!0hn51P1VPBm zR_vjX>5v>@C~a%KlfvLsr4W=&`lKGxXf$jrsYw}Z%|lv|un0IxlGVz2hepcXa}EI~ z*pSkYk+O#i#e(cb;Zgcy8&E|GBdl5{ck;w-u|jJSk8r~1qGrY@(;NX$5kAMDn0JkN zR(B>aCDEYvW^A-U*Nf%Oz0X4Th%iQHKz6z~+)TxzR4&0NPS7%8UC;vJM5_Fh1Y#jI znD08;sdJ$lV@{uXjA?sSxU&?axj2Z15RFg?7f93=O)D6;0_tbwMioX{uD5^VjCwZXsF&`l*^Sv)H;x6A z;3epVswGAVxYg3>+P&z3pp&9eDDwf2(p@FRdmy#jC1S^cS;v5i_AP7g(#u8cbS)(k zIcCU5))}r8r0>Mo0z0w%YS*g*echY7Rij_&Y>BFJxL83Y)R|-^>?4TqQn;-?v+G+$ z1Qt}yY@uKF>$9Zg47WEcNUiBUYH2Cg7R&Psk)5M|y!W0f|N5gJ{ej2MJozns-;W?V zgqK!t6@gHv5$55Av^}@DAh+ClJ6?R}3wZgJSK1}}_w%wVFSF~fxq8&j&0)|EdJv6y zcH~I8&!Mg7K%naknxF~lmZ!44*<+f=u<=yVV1RzoN06LMr`T9qi`CUNjK|yJW}J?< z<@EWL*jQWP%F0DsS=p4;)inXbX`Y^Z>TxVBF529}JeQUieb@3n3`Zl*&5vSfVVT$8 za1{?7xD*SEi!#47Zwqsa$~5q#1>iZJY`HLLI~efLrI$wTdM7A{4j$so&wXyp4d)^? ztz@&vxs!_*&*#tG{W(7Pz{7m#krOy~?ra=8_NbkD;xUZ3w!7>hTCay0vCtr{zUwph z9R1{7pZ@Lu#`D9`>MhT`>2F^0vakHr{d@L3bnMu%JqHgQxUjgmn7ubltw;2IdH+cO zDUjV^(H9elm;RVK(iSX4cwL;7lxoy+Th89c)vQ9-9bcBAaP^6DznH;?q$V% z_GC7N)4Z5-vh{2SEq3qShxM)X7`6ji1eg?N4rv6r>#?!92}lcb&^^oUJxf^LwHulQ z2M-;>^6ougN<96bfBPeHmmSI>ozW45T)dO_B!$3AyiMFcLM3*rO7hod7Z?#g&))7e9BeTz1XXkd$!z_(RCPW3i%^>I{r0 zyb@7}%m)Tcg; z=iKyMA6{`8*)00%`3smkGO};{#(%=Q@BU1G{=&IuPqw!NVP5XCMN7{0^(oR*L5`Nz z(z-OAVS590M66~m7DTN1Oq(dlcq!d>Ro^b;6pM;_slTrvTCu}B^(;FbpGhi-B&ws& zy*8N6^lZ-d$5n8TB0P9;V^;nY;WW?%nN>=eZ4j#MEQ+eRb7?O-sbbG(-TIbhfcp28 zw|Uuqi`AP#73kFJH!t;)UJl$SS8SL7O%Tx#3&UYtdda2u?%({)-vNMqyAR;N!Ao`0 zPkHhDd2DPAv`fPkchoudLd`Cr&0+ z#dNwUlSvQvz;JE>oBb5O|IRgNb2) zCfebMNm2=zilFkiT$7Z_IZ>3YUbSdRQ<^F$=&eW678Jp7G=f=(1kf}ME?!v0#_B3W z8_vxyLXw07>bXasrw)fSO#+j|=K5Hy&qyh;X$R=@6gt(2RwcH_@PS7bfhJ|!26WVf zN}~pZYDAKTP1AU}P6#6+l1cOa5P(9J1hWjcT=G1L z(f3A7=@iPOpHfXQ91dVzwy92Z*vtoWhqaY;TyfduxVW~C{d@L7RB++qN~~?Hvq^i< zbsgvDMo3AqxU`Jvc!KP}*48%63uD^*PR84t7`@**co54= z3wZHYz639Q#mlj|wT8ca{|E5=JMYB8Xe1k}>u8!0yJ;VNOsmwE)9UJKq^9L?ID|?< z*BiRN_whK(qbDEJM;?3tmtJ}qmKGMUa^YeX(wkC>(kjy=W1OehyR^)67cXGr;+hYx zr3{B7^x3eyxP-p%kW!1e(R@7l)ESmdnHRXdq%8@u&pmo8kw@W7%P9*k*MQUlm|1On zNGTswZEDm_E8CqAW>6I#32iBAWTPnta{~wjTbrAB;>pK%pFDo@`T+Ml{NN+6f9$DK zU*C1zB7h-57Zr*qEcYHEgk^QW0M)s<1-b0eEwdy zt_u{@H~}tf_qK5Sgcp|xrDzthlWZuMm+&e`*Yrn;`#Q3rM1HGKU4Gq5p=KR;%S7-D=TjA) z4S-sC$%&|fQ>`>CA?kY40kGH+(hK{YJFa>@?Q7a8X;rDt@S@FCj7?=CM#02H02zT9 zqe55)cGU1%$t>23X^k1PUNmQCaro>|uj*Opb*|Q@dY;Pcf*UjJS)qUhc7`;t^p^x3 ziBcW(Gof5&!PcGlb)=`%Xl~P$#Eu3vT>Gk#0YR)el z%2~n;2A_Sc1v6IXiL!(!>&u8)C7D@-G@^nC`c7M0eYt=f#q>X_wxJS8DCkEZIHhAA z7Tc8UWypviJUK;a96OBgn2Yda#io-O(Xed{kp%9|h-ukHJMV4Ugtyb_)--Qyj*u;b z)U9266Rd}L_QeDHfVnv~-VyKkW8&NjGF$MfE28`Im)Q)(h^bIVL?eO7geOpDN~&O| zOn?N%lb{~X(=bM2yy$SlkzYc!-lf=8;f&SzF5VC8YwtpXOV+)xA&kl8n z%*`W-VB0LFLS!>oIDr;})Iyq;+O!aDH8m-;X_%Vi&=!Cw6D=U&*`c9LG*E>0E^H`V z7j#|rrekpIT2|!*y0Wxk2$2HK6z)MSDS`mS-6I0?#eON~F!OLYbcC`h9*Cyh(L~#D zu5tHd%#9o7EayRF(}AYVg8B_{%MrjJqLq-W9xii(At9oaV4mavw#?uvW`U?!eo8zI&6(FWF*&dw)^*UI_!*3T z`1{d*^{dM>aoE)On*#_BO~RSV1QOFJkUL^9EQxomOf-{##14!NVu86~G}qlAn0CNd zz6#r4_pR`)jy{^lz#P-nag5JiV4n0?B*Hegslx%DSYJmTCbon5XqpC8Afa&tL<6EU zuuyzrK?zfO(iDWKcxWRnki7{u8lEFhCYBm$t!cg3Uv)^jgUFJaEs%*384&{}Z^BbR zqoKzXU7rHsOr(GVCJ}*Tmd0XBO?w2^LoCDqSl37PV0ka84_j@_eBgzHsy(u+&{Y*M zQ_o$eVYnDPRHWAGW>5qS$H)^l z8_@d>YttzYJo`GugZE)F-GpweMw?nOk6Gvz2rt&E@Be=Hl?&YZlRxKhZV5}1jDC9p z99ri5#uoYvY~-nrl^l%bRaFAZOPD6**2

pQE#}n}p8kkgj6Xi0D=c=)QYF4#^ItT(_JoNL*&L-ZoZP2)KU`r3p5i{jrm zK*S}G4JM5@twGrnaFaqq5iid=7<=B=sYt(1B6mlzEXH*g|b-! zK>)!9?hzhAr9?z;2x+|B*j;w0vqe;hTGEDDMO9InSnmYY^j=+qMZv6%YDLZ3=~LSY z+SP$r0OTs(6Rut`b74T#qDd{som&y+N@l4T1&WQh%wT3#)y?t}6l<0hS8)|wdn%|> zztlje%;t^q_j->@_V2~My$3K}Ti^4ifAhgN{M|qN{g0j7SUoZUMomgmM1K!aNtf<9 z;Lp0|2D$3$OVdrydoJGcmVb`X!on=3SHrk$>O|R$Cu0Z%o7>xIy0wXowGBCS@)#0? zk3adOo_OL(oI7`hTdV6hzj9Gl&YZ)Ul@)l-va-5jXIC$%g%@a+z=h>*T&L9{rGV~?FkPn>=NFa&`4t;u-t<9FTlJ)gMiuJ0A0dBmh0 z4p*)@dgb5TddqEpe*HDq-?y~9c&1IwbTmK2v6GL3Do93jW@y?LfTMG(Zq$-EZ3-Y4 zm7iENrkT|w9LRMO6*K)T!&%Z2*#d5Xwbd2u*|TR22$>%=?50FtFhqWE*DmSC+W-)W zEfSpPSI%O*HR0*UPvPRl^Vqk0FP4^;VP@Fe-opALYiJr`s3K;LhwghIUhy?oa(g`W z3o94o)KgEz&DY<+qgNcp-rc)n?btD1JpUx0k;71-VltVaX@}VC#yJ1T!+ifc{}lh` z`~NwP9Y2Zn^G`w6H}U+-ug0!!jK@!{WB$@ZNOLVNKeQL^{36!2HZVUwkEU(PXIK=2 z;T)!2#`@X@8*Q+v+lj{jqC#k!u_4P-)OK3R+;$4zRSmg!Q!zbln*3 zU{nZsIa5m*zOd@u|W6*^KmL$tyFtyat}49=OEQ&j|-v3PntSBnjb;Fko?M8DIYLeV6uKcYpxC_xrw2C_+HI z_l%1x=P);#$LZ5&adG85=I7`9!pbVX^yLRI?#5=lOPe%4`Y0v^Ic<7o%+PZ^~KlsDn zkN@;DKgRWqb?o1>8+-Tdibsz+#|XW zuZ@KPi-?Gn28_t?98@X5zNQ&qYrGxZv?nPs7!K9C3?>&9ffWiOaz71i6Wie^a(@<+ z?QLM!E;OQ;bQ82pXxavo$pn4Z6&Ji2f)TmTB#F`dAl6ncU^?DnH=STOTELZ;U5V%1 zbUnWAP2UjLUUxOmJ#`9GC%*PIuLe~3z?bjG?YBSQ$Y7s)G@58+M1Z5wkZ<|UH{(y< z^+#y5!Ei9}jg56$?y$AG7Adt{U0cN!mmkJ(u5}MYH=SsJa4VbJloA?g03gVarGgAd?~_k0eIpE`|m=g&x&JFKs4;LOEyHl9qhXjt(ym=W;| z>o8_duB!4%agWY)@_KK6`qwG5vP#l1BUS;d&YTc;i^=wupWNP>J^f}oO(GC&BNR3f z?(_gWG9?(&BzkYyw{Kqz+9Bo^7UPziZt|OMyCvQDtm}e}a(RA9uDtRp-@A9OyzN%DL5x`yTwA-~QsL z865wL+wb^^J8rr8AC`A7pC^Vf-X2S%;%+mccSnOQF56mMB`Bj!ap);Tyc~q}S7*O( zCeWe|!J!pXVigrsxB4NoAIWTGQ6ieM^UBplZ8^Nk-{II{j|XePXmyR3v#0u&SP$hL zA5(e01^_K?0?gd=#S-Q_;)>U=rADkk70@eh-J^cpUU}zb`;8rE_bfJDl3Y>$EJY~` zMlSBJs4n(G!>G8K&{73Iduvi*5v7BpE;7o4p|aPTl2j9$sriKgUx}gBd0qr^MZqg` zNB!sj$0b&4b&A7>QF|Kd_dheWmDf8WC{%Z5spuP`B)MgWU0=SM9SDszr3NYyh1r5& zHN{1VUBa56h!hLGc)`ImBGQl?Mr5rCE-g?-G^C_rc#lCuB=b;OZi;O*1_~Lvp&`*Q zY^Z725qSah0aXS%jsyy))`w~cvV)!Frtg)}BcHoKX+}_=FxEE<#HhO*dg3Jf&;Od~ zYu`ldS_HxwOhKKoiRg8_kexwDLS~`zS~dWr1nGMC^6rqAf33*ZyaD+?{y6Nz|48mR z5VB{9I-X!^5mQkP>9B0*MbU$_&dMth>LI4Ypcom*2$3LFSe`Hpc)_gYB6yapfr*BM zXu%O{M2eu%13?)oEk_9u5av!110y5Q7Hvo1jIy^)^azgVVa8IIT8dG;E#0CqaBwK0 zG{#&GQw9`nDa?t6iGc+ViSSTo5XKakhU94KXIc<~=%*T%6#&Hzote0KiS4uc;-!YY zt%Ep_d#6T4A4Gs|P!CE37m#9J7}Je)ERaCcVu6lU6tcdGG~Et7`UpqYT?u^Sx7Nf- zC4j)A4sSA>tIH=8kntulnF52kYQdRd*J@>Rc}F=Ul{iRh5w749Cqr+&jiWnmo>BzSv<(||=1@vMjlAXTFRaGJ&2`4&qPGY3 zfZ>cBVUadu*xnwJAxcgVFXGBB4ng77=hVsR$72;ux5F zc(@1@CA9AfQDF|a^#cg|vS*DfB+Wy$fl5%^ED@Th@WQCxL76np@KSUx3WP^z+UK6( zMvn~ZvxI}aB)6R1EGL?~g~9tACHrsmu8+t)VF3@L_a=qnRiZ-~0U9IGs9`a1un9w} z!bFpHeoyenzANJOuMI^+bbSQ}NC5_-W8_rc6w#SxQ~vb_Adf!I$=o7zI)PInQbTtJ zJ;?Hw(jYC&#HFdNEgt2vv~xNZ_-YQPB1Hg+GuPG*s6!a_%%jxjY`O83Qa!MM73-h+ z40m=NSsO3kNolz#i9hjTd0|c4mp`bMsmH9~k@a!4lTx2yS7up1AVQ&T_0Cz16m>S! z;=O~31EG*`_$*sr;;<$82E$CvpqA%tP|Ey)K&~KoMRm&?Fe~js)X)h_;?6*-6i}Z4 zfEE*

*El?4Sw`?ca~lsKJ@@YlAO6bo|cu{_X#I+x;gVzQKew#s<6m;FbKIfAQvc z!7aDrz@YZY^HTH+t^x{FF*JIzWm^WC08Cn{P7>)U;q1m2c>$H z9w^Q&EaHyaZo{p&JWr2aeI;(X@g`h$3k5drQuoJ&W_F&*9ON$Krv9kH@JK$Ku!{$GJ7$0uh>22f6Dnz3=`9 z-g4i44}1^6aT2T_IC%JzH$Ln7zr5n;6<@mS@Zq~Jx$JN*9b02ex5l7qdGX494xrS+ z!WwgoiWsWzXY71zW@(dDO`xd#0YIg_JP9!7=NGxQau%u@<}Md5TMk|Xp@R%Ee+Vz1zUu}BE!rIhEW?P5tvz(@k$?* zNa;t72)2V3?Xbag+F>{vq-;6DvUAXsQeHPw1aLrS~=Anb~z61ve z**&DQNP|W!_eczemNTwAL&80zY@XbU^Sd&vGzWUIpo>S1WhOwZ@dz^_fQ-x%o+2f& zFt$r8UnTcjT@{wfa#5BZin?T!1~Kh>7>vWYVM*&GWtc%ips9q8s#IIqT~3$cYRe3d zM5+N@iQclD$e>#h(~W(2mnFh*@X#K-=C!ZE*MGw|?D#V-uB}j_CUUCoyScf+&8JnI z&=AQ89i%p7Ziwxz@y?Fz@++^6*T3#HJbKyHeB+zmfWP{y_u-G<^)5^&8IL^rC=Tx5 z?eBZ<`|yju{6FOF|LZs77k>Wd832+nuDs%C+{+Y@o0#w%X& zDlYEbg{)=Z9X12owrTqNkA38KU-#PAzF22z6VxzBy>A-4T!Es{ELipn5D&1fcXyo5 z)qyUxz<73LosHVX{I%0gQxK+gX-um?%xZvp+Cg2(Lq*S;p&IG|H!C`+OmkGXd5OFH zf49i9NA~QZJ6mWvSTUcmQ&6(g^o^YZ93Bd(ANv_MdG_^4jox_01+aqD1+nu&?l}0w zAkhM}os0b-wRqRN{`9+Nde#sA;J;+Jqe+dNed;_G=ayn=X&$+o@U~lTkGntj`E>HJ zhe2jHf*yAz`q^#YLTLjo}E)EzaZck;??;ga?+E7kuyDy|OUBhyw=>VDEu_ zF=&VJyqjPM$a=_kRAKW@TkHJA?IS6Mf&SRQH}CgsQ&1z3m4N zU!kvl%~um-+{DUblWXV=7vKcG+Yd-Eg|rrlx`Z!64{`G21&F&nh2$cGmyiP za*mubQ%bBq?1D-g6fRGJI7M(qRX}kqK#R#xqSh|Miya2xWQiiWdGg%Xe!O6Kcz{u6 zw%MgLha1pnDL)itq)=GS(M=|7hlA*H=U`}RQgJ{)*)&ZwNy$cC1kC1u3Oet>hG>-G zZnVhZ5@eJjtEqR_=yv^@~We7INtE4H{#pg@@-gHSf;~parI(cch%Kc z-m}~9`iD>IfBMh=DW3bhJ9KqrH3$?WXB`tyJ@KU6e#)}Ol4+M2;TE83HfT!d`zdcY z`mAv8(T^vQQj&gZIvI~;ZehN#AE`)nNj5XhmBCeZN?wQzh*klPPfK7V5(Q1uV36AA z@)RHY$B#ez%U}NT_dovRsn_J3FOTq)nud~+(-qcFqabpDc5a?mU3yu*;aS(ov#x)Z z-+04KyyA+>WN~o`!?_gu_aBP+g?Ydkee`JCfiz4KM0DLW#v5Zfcm9kYf8-Ip|H}`^ z7r*o+|GiM}xAVnc`Bn0D-|&XG{E8#E{i|NU zJ74}4Rxk;Hb7#-v{eSiTbkAo$g9nbC@Vh?#u~;8(`Jn>`(o<(nU;n{R{^Os0?6Y^B zyYZT5z4z;0^{StG*3rvOKl<1yjOIp|PJ0p_6~0-Rmn?i?K}|13xe(1RL1l)ua%rj+ ziDZ;Rt@h+0Sd&;@cN4LL2%90wX19x|s4&$i&Ri7)v<}cUx*5JxAc|Q*IHkJFG1F{O z1ch>eWRxF&x$G8QqKN2*ihPI9MEZIr741B#!+sVmtHSgwex@ZN&RmHAQi!UdUQ54b z4)pT*nmN;17v@RIf3F!4T8zvy{%O*kcXDz4*BrkffI|E)!ad5_?lYd;OboBDhgUeY zmq$(Q#;$*KjZn`n+I;$lP#k3}Y(|-7ZviihmcqOj@mXXu%4rdvN^@B*l9?$=(V96z zvr z__Vjan?$>~JQyZv(RGGCa~Li;ypO(DuHX{?NKtUz?#@F z=ptbS2p%Xf`?5LlV5&@fmd7h|Ir%B1j6fK|Ej)xuBbk^2?lKI-oVyDm62nstG~qEq zBNR#^X~>>Ry__gSJm5{#?rwyec}~$8!}^Gv(OHQU2V8o@j23V3(6Hi4x7#wIR(7LFG>4 zFH5`nxeI~Kbz=8!N7Fv-b|DI$R|;7ek*%t9U^@Wj7dd$8E71M>ANRqd=fpqxX{1AY z5#uh{O{EbJilTKxW8q0m!VJ+nJf;v8H&R3lU58KvG};;%5{hYuCR70kQ$(11gysm> zm_Zke4Kypf1vRHe%!o)N!Wa1Ino^n1lo^r;7g5@KJLm&Gx^@^Jrqj`sQ1e+pAD%~NX!#T%K z{5bOIW6<|}hzf=5-Q|P*2RVK6T(mher-I3|jkVZw)i=xNjM-Y6$^dM9aO`5SVr%fB5^bzjzm-3&`GG5nB$iOooSx(%|9J2t-Sd zno1yXXU|`b#o6LrTo8uB5CKI}2{090Pf(M71x06^P3BP)loE+9{Wo=T zr#jkZfFt{N!yCm%KmPIS{@}fT@s5qH$@4Ny6BXLFxaP|1`sZAKZTh;`ynz?CH}hM* z>sy+0PdtJ5eDH(#rMJCZdMEbmUc&ss0vu5i`d?tvg0uG&@<_p4VEP(e2qi$`JQc@fy1BOti7 zwP72pE1H;S=>3u7Cv-a5f~sQgt|gpb3y<8%p8W?f$$d4cP{-q`ixwf=LCg&X7`8*S z(rS|(-FVv$U2;$@3{O4v$uK%Q>+sf}{cn8lM?X?!!>W`yoZ3iAihumXy}=&1?dofB zcsP%E;69w(8pjIr**gJG?>OW}yfBwHhmJtBk}@Mr?L z156AIG8dtv601e79KXyKp| zY7!QVFw$$;a+4XsphFSSm!wr{L=X{{#jS2Ds{@KqN|UH2u;_qLC_0X}x6w8Y5)*_1 zO%0~D4bc>2N4GNfg?N|(!^)>v-pZaP1 z_S=6eKJ%H+$-zr5!P?3iCexx5RmHd@oJFW)w1bfzJa{1HhI3AJjyF4h^7In~C`Ye8 ziXZ!tAHh|ZUm;gqdriFWJ@4U9{M1k4)Z-`N8F=L3hmg(i;KL8g_kPd!;E&$@XZWSJ zzLk3q?nBob0P^^;M|k1<+4z=k{^nSopU2}*K8c%ezS;loV;|FJKl`uz>)!Y#-B??< z#iepR2Dk)ke+a_T$8Am_qOZ$T~(&vuC z#+#uMq)-s;a1Q-sLN>{pwh`Gb?JdEehxtGTQoWl(j|dNx=(d;TBSOOoaCZL=k8+Mh z?fk3Vd7)*d5|oM?K@i$yhh+<=i%{W#$Zn;^kBB~cCN>dNhWGHcIQH|@L>h^vNg_g< z^iu($iXsGWj;8@QQk6P)pgf#dDk-j&G-MH{KoJ6UUbtjFFSD9 zqgY;MRzw95n_KIC`DKSh0NdKwmTRs$ibo!LfalI%fH*MiC)nQF!trCrV!Ayh9WtGa z(F_Je0Omam4ZQCGAWok@r|n=6&W!1_*J4CB4B7?=@bW7!hcY2VsKV%b*XejNSX^G% z?7DzTJcBV+x!JQu1}TwCQVTCl9NAn3!-3Du&7&Q(K;PlismJF&`}wWj2vLJsKko9$<0teBU%HnkPn^ORzVt^WA4i_tyG~#NtcFTeqjy^3yYX*=45es8OwW?aPZI}+qZ8&PCar=EjvaF z102|Ukb}7)yXh3E9bjQ`PHfsCwGD=YA)0o;LEE4+W4Ap9TgAb>`=rlZjHgp}eU5H2 z(eY%Awe=OOonQ6M@l>|9H*x<1Uj{&ohVy#v^l5B%Q(0TPh~NFAKf?0z2+zCjMqY9F zh`r$DFXQbu-xBwqdP3Uyk)M3>0?$13Fh1~!5960V{c*hgH-42{z;pzWl{E zf9`=Ve#>pw-S|7-`07{v$KhyhZFw=-w3}jUV+&p{ml35)L%HLf#_ZK6pDqEd7E#O^ zyi;YMlv0ryHl?WDMH{Z6fHWH%3ahLXi2$6j!)F4qmP?y63JRtEXQaVR(PG9Imz~nj z!U$(!iqp{6BBTf+MTv-tRDqvmc`!R~tADh(zITeT>gE};gLh$gE$xzeB6vOLwLZej z=d8S0YXMj6ob*-6uX-C(0OUX$zk#H1hRAt(`31}hSt^aFGT6P;?AFk5U2F(<8r6Lk z4`Y-EWr5??v{_lC6_>msU^@(YiJEXL-xf_~uG)&W6s-UgqQ=o@yVA<0FVhJjb^1Zl z0&^|ZYh~{urAO5S6iP9{r%<*970(1hqZB+ewTPubppAe=gaptcqzSl!&;SNPXr;fW zLKTo9B)Y-kQaiVIciUgQn8xdy>U~c-B|<#)ozTrRLZISlaS6??Wx?S?fk6}OJ4!aF z_rmAj0c>p&^UJf1MU*O(0K7u;NfJ6s-`8zS-O!N4-b28NCqh2`amOoO$L5Roisa0E z^Rt1wA4IHgp`T`0SNb+w5f)m?Hd&0)5e{P_S=1E~=ZwN@&hVTysE`sd&!u8Ggpe#! zfXfVIIKYHNWC|6%b3*E{SVyB#m26OBtb@Plm?bin2ouzI~AY5{Q{*n6w=P!!fe!FA$p7LS#dXbye6GFl8C}M2};F!Mc zSHWXn7DETj&m(2PC}<_z$J@lxJQ|@VP?!T@hHRaaiR`A*03Kmv+X7vPw+f*|sGCQh zq$?@HXdHkvWEdmh3Q=Yv8Z$%_Zk|}R)Qq8NZz|eniw5qkoAsr6FDKRH6zjr#-g5{f z4c(@sC#5>zZI*^jL<)wJD%2bvAzg?-m>M)us!mBIB}_<$DS{AjdLX-dai)ifBO^iy z>4HHKQG{f14_Iks)`-f>j9^BF2Q-(hs=yV|n>YbBEjG5dqIY1pH4(0^1+F?G_^ZDL zu0M|Wx^E)e2FzBR>V@}K-tB0Se(*=R{U?7GP3KH6zLUKCGPV!B4{3W7gSiPtyLZLP zbQ-a}E&IRy8?boOQJnnCkKx>Qhh}cT-UBg>fEZ2H9TbNF$w4yQdZI%>9Uci`2~1uW z#hwh}=0UcKztxm$heJ?G`AEX zh1Z><4K4NocbBkYG|QG5)1I(i0n#nIS&-rM47yF-dt+h#I&(N-8Rm}g%(7bw6ct?( zEMUl%N;6PM>4#uy9E}L)-O=pdPawk|`V#ovZzA>_geMI;33G&${^o#yW&j)Fu?OK_ zxEnljCGv$8V5<*Gh=s#d7@|QQcA+86Ku81(v+YC~Bvgv~sgE!T*KjE%=s9+5 za-bB1UcG`NT%LCCd5OqJP2zc-eFQ|L625^8RBU#|L75P&%ve#3RgUWX6^GVsL)kXg z#eaQFdXyOj0k}#v1aN1*3XlmFJ}X=gt%^NBX^!$hm!}mAGAAJDt{;R)~unzz6zy3#G&?KYzxp?slU&zH>d+^Cm z--T1hAH}7Y9f{{%do3qj;NJT_AFJEj+Gt`cgOWHj1KmQ~1dZUn-HW(n{~=je*o9rY z2GBHT>*FnLng*#EaQD(8%rgk#uDyG(w6u$_dDSaoX=#bmoMG9~Tc;@vVLpkrX??Oa z=Hl)J5ws!{G=m`y?Au#%P}WCk22>?hR@cx?CRpFxz+^nZ`EwUAo@`T_2J06u09356 zuJFw1i+t?V30zoPElF({R0VCDFzNeH4;oPDd5kQO#8l#y(@E!Fxc>|Ch5NsNUwYgB zgs50*hkC`~BYe%PUKuZYuVvB@XJ5@ z^Z1$n`k#tdNlCMyQefc%^XS8P&*$&Lu7i8ymDfC*qe%Fl|LXg2$D@z(!N;G%4}H&@ z<8mGF(5?kM9K_>Kp60|S81B2oN27*KlhC9D4Wb7`&7&DM?7Ix4(kInV`lxFe)uu(G zsiN|vzES~KMb{NDW;1Nrh(c7{EyMesokuV!;GoeM4p`2N(lLgJ-m-}nMJN~1Gcw_X zM@F{9mOBQ%U^v_}#S=u$APo1J;#i8j$}*{HWE!*(hR{PP=pqutT`5xrL3K*U2vk&C zsb;3NHmSkN%1T^$^eVpS`7h#6|IAO~-GBBM00bJqWU^fjfs_!I zLnQHz=iiB&ZoCnXojk$EA3KHlg#~VR9WR_+i9P%G=nF5u)315Mf>gF`Yn0w>s~K6Jo|dw|G)!y?sJ~)?|tuI%2#~lS76uDZXI`B{+a*q zGxpARyi@z!4c`B^@BhZPeD`<#(U}Y9As$boz*#IZMYqw??Kwl0h9HN1UOQig{h>CrhT~eZg+{>|3+)rikXyp=&+F~5f80Mos zMN)OuRZ;$FK23>-M-(Sr)EKG=tNt!oP>Z zVLJ>@7J?MSM1J>oe-F3aep{?vynqjV!(+U3mA3n;ZrKNb$3txa|U3Z;7``OoXdvnb1{Ad3x?!4pq@jc)B z-I!lkq_g8&|NAfDKm7F1;5Xm)Hav9fA^hI&{606gw#p4TC4`j>cQ@VUm+rYYUis=* zaCEATbLUoNetsT|#VEo6*IXPt0rXu@3R8eNn@hvxu`5-s9%1l6pVfT=|QQVEFAMN;kZ zON^Xh(ZN)rk%p7;nAvOfxe0Qgz3T@u8BaoG1Z|2HJ6xbD=*`hbMmNdqyNu~%j0+c5 zgA`u4Z~=Rl7r6J}L7ZDz!vha~0Dtnw@8Vaz{44NnZ+;6JDt_eO{b>BkZ@i5|O?b_V zUWyYZkIPPI&FP|L4bl0v0a6{;R(huYbeW%BfSQ5$eg>4NsmsgG;Wy z3IW66OD^S!lP7I!ygfKj*q7C9Til7}C^WJfuaP`MNjaKEF+aDAxw)YufG>afzFnXE zo10U0d~)1{XjmaC3l+<4Xv&z4(nz17=63RTsv z>s(SJ`}Xd^XkpHiHqCUZF`0~c{Mdc|=}+A)AOFNBxMI>R2Cljh=gj1Y>LEGSx1BZC}!Wu3)xF44vIf6?rJ!p)(W39qI3Ga|6HwH>J~SwYnVZ4$I8 z#qil3-K2w%MH|V^uAgFiYdbDpIFB<=ossqRRg9-otX^Ej6OTQPwe?lxzQ>7EkKvIA zAHe2#6KiXm{-L`*A?_~9AOn#!`LJo_`lHw2=%oknf@j|x-}Cxwc-fw1y!(BB5yviE zjQ{g{zoWnL+rNbdKrXax%r!%a$k?^CY;$|}r}^kHoo2k?**9QweXCvD+P1SRr_wopC>#mMtCr`$BIt6km_wg!-2g>JeC;e3D;}9)9 z8{sSkFLhl9FIDadv*RbAUKX^V?YOZ;a}i-Pss$$juo=dn#9`?bGgi(-)Z$zfDT`q* z2o=Rlh_5)7h+42yN^qoZ{Yz>m7qpGkY*wK+fHRzac&Rq7u=TJgm&|I3tOZ91RyKPr z7M(e|rQWJls#CZSKjGD}IuoGFhVE%+P1I(xBo(zIwbUCG5mW!$r+J#?f?HPG)iqx! zNBT_CQ7tzGWrwTIV0q0!$W8&Nlf~{0&JgOwU{PL~YDcf3@uKQGy+G8WoD$&>x;rE( zXSt2=LJMFDcwy;?C=rc=gYxl=B!J|=Kx$E92sOw? z8A+JbJxf?#bfjkE%u^QUR}{U8c|=$aM{tnCBV0W^^0cQ-C%}cXA;%wu&^SGH7AXm& zX+mzhogB>tG?4$GKh>S$|dqBY?sIl3AOMAd*KZloY8g!VX4LIMO1FK1daX zn|BQ&F@}l;G0dgYv7=H#m>6LQl>k&gxGh7Bp1Xkk`}RU6W9Y>d@QNeAQj2E&9Qe|gF;1QWU-Ihm z_H))y4R@X!vlU)ZsuT!;jW?*DzbE>oMKsTUK6VO=O8H>ru2~uQv?;7D2zV+EnqnZq(w+1Mr5<;0MTX)Qd0sp?uayvFo9@vU6&BHD3nYxi9Y;z}H|T%=otWHr zoC`nm(}2Rcvr7t;jI#@l9>v^8J`DThC&6=T#L^t}@O}*P0dyyiBhHbtR$?F}HB@6mTlr&=iGrPnIAHT|6Vgs>#oz zBnNWPyQ%eE50ViU>fSRfGs4Nt@NNpXT%STX++!9pOJ}sNe06s!aDdTKP_?3y@;hf@M(|e zd$Fzu+W|zykrF}^%V}r=Hl@A06mNS9AV)Z(falp#QQ&ad8798-fGdv;@-=Wx^YH-xHiesK|(9y%0f&!6XTG>rX+4l*p{ zv!A}(@BPx}v478QEG#d{sZ&p2bA2P$HaGdi^Z75h^Mk{|aC>d_BDSVePmRL6di+YU zy3upR8I}1Q9<@`+qYo?qK+~u$EHB}b!~40idLHBHm|$>ec>xD@?e)!#4LN@7IBvfA zxu6C1?B0VuXIjn`F(J@K#Bv|miyk`|4P<5I0**cOFb-XI1e+V1eB*215TCjGQxp;G zTHeh(-Ntrwp2MVib1)J`+qB#mPx<~Y-U9&fv44IyZhzkMc;{0WaM?>2@xy=oPJ|-j z!V1?XTll>{_#HfP?4)dNZ&*X>^70})37bAeY8p0@Agw?*w~F3Gk`A$OB+KRV$5PxX z!g}Raz>G+Wl-gpUF{8T!^e{N1M?{!4NUExcY#t8r20@3aDlF*eo$keGLnep^+#K#s z4ULEpL!hlV&j<=kida-w9EDjV1?46lk+U$YBr*{+5s~nYr6;&7&m#)>Gt+4ZW7)O<-8K!ze<}J!|+U2w`s-i)=BR8=>o`rFTGDm`q?I5G^5jk6>cJ3jiK;_h2Jr z4~m3p&^2LkG{E}m7^lyi!yUKYiWh&ySK+O{^xtvv@l!~tWrX3W(@)jAAYnNJ1pnu+ z{0gqP{4%`z-S3Wr2QTp}F27P<`tq0ZInQ}+Y)`gIFQA+J-#_?6yzFH!12th~*oN=Xd;3Lq%UvI5X|ITHQdY<+&hS%7Mc``L)VNpAiyfQ0|ze;u+P@=Y`U-(*qV& z!!ETpHQ-)*!k%{dr{d0IwYW#EtkueqsWbwsGx!d%plp3+r`L>4Q`~&T`po(tR9&LR z_@$PH2&CfrWp+QT?mVBp4Ow|LPhaUvg2GGu8_tr%uP=&IXJ1)~@Kd-jnvc6b^SRq< z4|v>o)6Mh<33tD6{(}6_5C1EC;DaB6hhc7h6nmET@P#jU0sj0i{~}MjsUF;aDE|15 z-Vy)%cYj;H^uT>Fo{VjKx-Abr`Va|Xel$-D1Dz73T@L&9?ukAJC)-=N^0KRZ|NetA z9Z$so9N2%rzvWxM*+2TBkEGXr&DTUk;QH&YkAL=U--Z{x^rik|Kk?&YK>YmA{Q~~= z5BzJs_{cub}p zy|Ce6Zt(w?tM?AG?5fVZ-?jEW=iF4et8-8XwX#q^fCv&2$s~i#kb{i_*w`4`<8Q`s zY>$oc*x1-+3OYX2HeqGk{|!{0e)H+W*MI$9 zf(oW4J5n^(aZwc7Ze)D)@Hl2pox;qSS!Cp>)Dl&UaNeoQh_ft*nqj0pj*)i5q^hvm zUC|ID_d}nGb`vghShr@{F4}z|c?FtT19_f9VZN$Di`fAdL6X&dfBgWfg8&VHb7Xm* zqt$5vW;l5G$Q66{Ja+Db4?X;6WmWD1()<%o5}>Nq=va2ax#ziackR%tu6hPtb>&q$ zHaU(~BS)iA=s<+luAL_5Sv}_#BQWSM>*J5^l^@@CumAS9zNvTIaR;3~bEfVakQRl> zRH4icoOvRRE{243QB4y@=NvM2_2DWb7ibl~iGhvuRt5IOxmW?_!y^hC6 zM=Z;8Y~HpFQ)|}Jrfn_TzH65?Tb?p*q!F}6t6|gzQrvYs}`$)-FMG@@`W#a z(S7H}@7ijwXMKrs=VK4j-FpCUL|?w`MqT3z{>7hpiT(V`cJLQ&x=GyHjqbJ|--X5H zRe%fw?SqtbVSbK!tIIe+9GXRe{u4clLC|Tmaq;FIM(#vB-CK1i!{iShc<^uTeRR)n zz3A$z|LQf@U;A$pW8*k8dj=8|DgoX(Kpo&DJ>R9yIMbney6)c6$PL3xOj4<>!|A84 z3^)j+K1GbJf&gvaHCCbs8}(O4Bu0Y zvap)%rfESaDIz%y=@}Tp!&x1`#AK$hnlVTz^mk}QWGF;^8eG?CWmgBe8Ua}?_)5zB zq{Mf_cV4q=b3Wa>Zl=&MbquWH6$(-$qCAt^5%w?xAb@#p4Vx!#^CzM zsl(BdZ)I3h)a-Szz|_@`>$I6Cqk4YJM3f?hlA?vrF6)!XpVLQ7!bT)!XKW!!C}py%I%uK9O(x`)z{oBz zykjXe#N3(+9IY(j5>qbbZBh(bN(t`|&NV_!(2(G@@Q3PI?xDKXBw2-)@>MB6vP zMKL81dxI?*su1CGXQm*>1T{$miG;#PTPmNtNMZ_BP5*~QHFcKqPl%w7Q=da1$EHAZ zV1St{nsbhg%t(}!T;j1o1xm;al*2(-7-C9}$SEPz(KKGoQj!6Y6Ek6utMLX7%mq0r z2;@{Pj}!@Txfujv&WOnz`IK%)3WBjIsiYYZR6x0N#(+jLAl-~gs!@@Yu2GWsLW0E@ zpdk`ORYHVG0BD`-XNF@(2)(}A%q;syA0<5VnJ^}!biHfJ#Z;}iYzFcK zL}2X(G{5~_l@EN7tNVWp*N-Syx@d&H`C@`wK~)Pem}eg=Fqq&A6V>D}RUx)$YLp~! z3aCVabA(8w5EUxT%AA~e#36&yz^0a&q=;#zjFlv^fShw|(VTK{h8O`4Q#N?XO~}GNjaM2DiIm81tag+yuzZHI98}RM{H_JT3cw$E0m#>T#_urAl6vM5XEVT5O!<{ z>5fVzg;R?0Z{EBu#)>ou8osd6 zc5aQqfM*XLwY8hKg2EiRPkajcM}KI}c}k!sI94bmK-qzPZgSx>$W>za(d~*&TOF>v z82L&c*~}@poC{)z z^;CNpFqs=6lBDOZDQ9F}Oe-~Z-YEK2ADc%lI}oZCMAU+P9a25MWdJwlgd>nR3U*2MPV_hnmL%V zh#H#$q6V0QsVa<}SPHySRd0YsC3ZlIK+S&Fim49VH_ zKS`&qh^fnz=H?v#=uQehy3-5=p{gL>fsnz%f^n7;2plY(S^pqqfpmuHf8z_WhxUjp$8QLw6mEMZ9!ESPFylPLb@fkS?#QIWEZ&1e3k#Xix(wxb! zE-#_f${sm+ithWT_rsIJGoStpY+S$57FL$&;Ql8}rK0i9n19w4m*}Ro>v8dAm)SMf zUISz~KQVJ0r%#^7+`=;Y{l11!aVY}MJWY;G%BJnx-1@a^&AE(P?KY;?u0yj?zo2iuM<+w8?Jcp*1EqYBYZ&CJlC9O%i@GraGKeK@%P z2tBs<5s>o?&xo;N7))X`i52$ldlY;3J&KQf^j|RA8NoBJdX8Op-8J_77hcD^cJ0=4 zc5Wv!M^Q^V7etF^&R}MCK3=%{0$yBRj&t*~v}4CEzqGVKPrLkbIdc3cJ^t{+{@Cf$ zAXP;pi!ulxCbpm(mRDCce&riq|Cz6Ry8LDtc zgXzUrJOh9E{=c^0{)0b8Z*HF6_m_Xe4?XxGrlzKCYGOh{9Jmmogi>75&f$G->^Sw+ zP7^*bMwJjrYQ&gJ=P$^K)Y1(hBMPBp@?*wP2x=-sX(tYlL>M8GrH)V~D!@XH$ue@u z{~{5T=P*%=D#og{WY-jMOh)zplEqgboH-^<^bpcywFMg}3LCsAB2s=2+i--=sz7EQ zN)>_#L?NWaER+Hti5P)QN#L2Sl1NmyEh#?20VG5&LL#AxYTkP)iUP~4D{y%OULqVk{(d3@C_720TAoT@)DmsJqN(>q8GnVckVcc{_Y?CmgeUdg_xO{ zsH#%dKX)N$zT~+pQ{OC~)L3!hbb=Y_C zAeH3+>@w`yb*{CWO`4lu&=@OL5u90AK#U~-MwaDpOyEX?R17KsCr_WG7rpoe_~l=I z2Yz(N-E!Rvu6Ik_RXcs^lzs6lU!bpjGsphDd+nO*uEVpQb2U|EC0XI^*WdY0djI?1 zPnA~N78e)utl6w$uMfv{W`+(4C&LV(B>Hl7jZ^=CYv`*1DTE%0S)I-h(In4iBfv4# z1g<8w48_Nmw%5r3nh-g4f1FwhKQvAaH8OKlyX~?*I25o1U7cPkruF_~1YP zBhKBm8*_{El)h!h#IVyRPtv1VVV7QbAss$()Y#|NY-QA68MvSUo|C}Nvm;gmdsR)P z7XzlGV5xP1&QUr8G6!aY1I&3s7*t%AF_AFX!DS3qrYs{hVlfj(nKyPBie^FWW)q8Z z3lIo0%8VRS=9m&Gmf2+lGjHBAOw~vT@JZhp#TXpSqd`eyV(g^0EVF}2g6lF7sampk zD4S7IOi;$j4k`-cB)Bn2fdU?6fi)3;L)sk$_NOWhB*EH zfSR2Syw3pdU87kb#E5QhNzF!hVr(1$qYMEAM$v3y&>L6?O6_(FU;f;e=)b)36?k<2K9oT?W1!O>;S;A$>uX>82HJOczd6S> z3fsX6~F+-K$Jwr+0*w@WPvJOv(bdmnjq}Lp z7`AQMfXgnq2&ZP}@zyuK5z`wsa_A56@WT)CsnaLzJDY-qa|!_P%{&KS*tBIc z#+#!!Grvd^lVjMn^&A=>9kuCo)3jm32DC;yG(EKztKB6u8y#%fyb06OQ`8z6MdmZg z8wH9^2Mq^njf_I0&@0Z_?w|X@Yix0Dg>L!5&3xDQZqjS6xRjTcd${4A`)sV);#(hm z2w%GIC;W`%C0faw?y-CB#&zdkf)D)B@7V3%zn%X13tzyVlV^CMQ(!p=dRo!aa*5Ry zCIxA~QStS=c4rrE+N3S-@q;5rXz#&;<=o2R`mcWfmVdtW-h2M=H{S53SMA=i@!^$j z4{9+j<>~-s)uBTQFlIQ5DF7P=R)f=|Y)WEGs!=7V*E^DwJeHcOAro?l9|0wmxu>DJ z#3fd_KG`#JeeNkN4Xx`XF%NyyJnSUvb5d(hm$S2Bro%y}p5?-)*>2iq4k4igLhZG7 z42ab3p(le`6_gTbECrjIqq9w@v$~;lcoL&spBh7Kj11p5DJ*r905KdX%-439WTH>* zvZt`l)uq8YyBd^jLv{La#d(&d^OXCcMnSn@a4F6<;ZnN+7)0h0I%&wUuwkRlL+9L3 z)4`T-Z;6zjU_M;`IEK126`)SAPDKybbUmtxvh^pF0=fWlMkqj(rMwyQq(*>cFv|_* z*vx~FCp!asW@A-ks#-uKC#6E54HFeEvYd%X+PU^umtE}k37it%EEQtHrVK~O;K`g* zE!d%zE1DUFO&chi7&jXT#S^EAAAXehob!e@2_OwzP_wjMy=={%V*OGjB32`#B+n*i z-q12qh3nzxuBX-A1Fl z#v(?{3{w*YIihG}=3ov)!k%N&N0^bNtiot&PKd}+20)m(!9Wm$C)2`+Ljt~#7o(hw zs!0h!X}U^!}|oB*hksC-@VGDu*S{Kx_m5uq4L z4icdf4JxcACSs6KnFgUCfh=-3qb=Wa=bZmeKFBa)g-pFqNZ2#|#T6ajMg-EVU86x;s& zko^bY-u??9IHS}gFw*cSU4cXdt7=ycfQv3;_rZTg^TgO9 z7PZbou~jBqKaum z?lRJ$pf^)uks!{PB&rGpWZorFu}JM+GBR>%5ONXfP03pnlniqoP$4500Bp*ZRLG(X zgC|d>!N5-I(*zzh4H{yZidv#h$9jz?Y$~cyCNnir7lXi<$;c&pSyBqBC39pl8+#|B z;u1GH9TEzIkWr{gf@4&svOFkxFp`sR=4cHT$(kA5Wlz_|Z+wkAU;4C-yz%W!7C52B zh{+gCYJejL0nWRGFgfjTXg@GE3J1dIMY}=mhSOeO+Plwn+5Q7K@x5EHVb^v{PLJE_ zV^5Hdjl!8K*VZ49LLHG&P>ICCWGqgZ#cSP=Dl<3|n|CmdVvzxMj!2`JI#rPKOezjp z;b2bK>h&>`6HSVLkSc;zB#|}q>j#iY%InDUk#wC8&x41{EPPH8zMU5vNfYi71?@6)%p5xvgBqFh#wrx^hUY{34d3{d#fKgy%+0`>O=xQp zaDv=Dj=gbJ|h&?%EW*QAlaF!9M zZ$wd3${vzn#WG{^1oM`rI#rUDlM<5Lf}OeapB#sEgBk>ya^Xp+E_K)xqEw%}bp?dP zP)iEGG>orngc<{RHWjN*$V#t21h%B%#4v1y7^z-3i*->r;#u$Yf%+iz60P`15 zt-~`ezCqvG+Is9D@!z*O^Ts{5hL{axaUWA;wKM0g!}Hl4^vYUHaELSy?z&qD@!yt zw}9ExGc>#8g8+PA%xe(CMMgb)AgN8QrWEbjW@UHJV!_(M8;_z?R259}TkeLQn!HkM)F$cR<7 zu`oaTtWSRWQ#S*&1X#H6g7ZIj{dL#BcY0#-R0sk6!2neVP?a=$vigZ{&WgOT006z- zO7{I*e}G=UOYK%i*n6y0i?(aO%q zRwZ|NVDpO$v{Lr)!#nS!GFIrcN9?w{?xcl8t&!6~L{MPUN9zC{i zuP)4@pJLEF(mNCA%@4gGDogkRwl4iBRD^jDRwTwK5erM==^RM-p>J#104$ zE07-kk_b=UX%u6Sa&21~2GAsppdj^S&Oj+88%7>Xr5Vhk5vR;&^_G^Gbugt$9O}1B zl2eh1n4KzH{Wu#&h$*D1$T^R^*#eAEWQ1zq;J}tvn4Z*$rAbTrLki}?dm9-YA%V%t z@(NZ~SFvIJdV2lqUuXOF?c?{p?{A?J!Ne|a-vttNfyGoQsvUhqO*+Hnq!9yvi~gkS%LH`?F*{ofhE=*F9GdhHwE_?A!iyQ_d@sTU@z7e=Yq zO<30C5^zJ(N*$a_DFY%AP3_4@R%T1u6|IAxKrnS+#IvGNgC*CLB8kFk5gwVr0r08@ z=W4V@YBoTEnt3)nIETRc8saW?R)L1$u)7W*!H|(os2grc66HGS3xX6HR}aNa>O&bR zbb(?Ww3ZNYXWQ~2bd{q5erP2dO8tjIyJXR41G3C%x9S%UK5+k4W`^H*=eyH`-xs#L zIEN4Y>pycE9ypK)LRsOb4?KWYyW#)hPydH>IwS7*iPQGzSeh0+UMcu(WCg#M?R#7jvnB*zwK>UyJ0Q1Y&{pJXJ_%Um%S1<-0&?jh=DxV2#1dx z!qUnLu6yRywCB)%>U5?xA0MStr)P{Bjta*L18drvrukG2eHE9s{RFMK#R+HN^8)M~ zWzN%}s-UQcTaH1T)Du)I#}jRV$a`m^Mj;Bg@R|o>qI4){jRLA_DoSP!MaCv|z`Kyb zsX#cuxdQ3cOj*?#GnCEPC=K6<$;1-!07|NW_d*)Y()J1Dlo4V8)!F2fyn~2ZkHW+t zrf}YI<}z!yo2Wt{)rj`k7!_rO5Y(y=$UBEBRB(d}%lP{@eGh=3Xyi0DHi{4Y<3G|TKlKS+ zT3DoCd)K?jV!-z8+j04oPsii?_oLPBP}%FFSN0I0SPmsvjXQ~xjw6ST&|tL$gLF_; z+#mFy3xd;UPUG6=UqiFAGuX0u8#b-mfQKG_m{wN0#2#?$Qh=cmL=`bcj5Ipj86CAf zkMG%j+wFJ$`^@Rn&#SB2K;-%`X|VIS@PZ5c?%n6w?p?cd+m4;?{PTC~`VAW~Ha3dY z)fGRzX4;yaHhZR6R)Oc|m-MdNZ>K;1pMOOUKKvj;RhpO(Y0}lErI`c6eC{%WPfm!j zPRngryMZ=tIVWyfH%&!RxUtDeTEA`suDIj^OsrpraUwL+ZmeR24iEcI-NrmX;Q=+Filq_!O92azr455U^q6I*Mwxw7N`X zC~1CW5&I7xMypYv-E3GHBQ=W_ibjUKDA3Guv|DYQd%=0wx@i+ijXXLwfpzQGp{h#j z4N7b~_Z<4=^WTYId&jSlN-zq7-&$It$8WsF?)mTc(&?oY+I`8-;(}h^W{(`A+aI_W zm%RG5Bp_Ixp+|=K)h-+nrpBiL3BJi*Rzu0lW#9hg_V4p#k;PYDa%ukT3(k{9Fu(uA zQJm_nV!6Az>97CoUw?f5#*O#B<2A2&O@%m(&EgH-cZiI{=q;=?L zI!1|-`hi(fmR}v}Ns&^{2RuX*`I=;?L{ADQ!jrfZf~y0x=0!FXgN&q{MwdBHNI!)Fwztw1|pD(BQj;MNs@UaS{K#!N2ZLC;(sV5 zvZkEvMCb8|?ut6$%^VSVs(C+TtZM2&#AM{mtO-J%1aibM&J>cdCB=Y>-`|u7g3Js1#R~fx{qJRN+h+5t+jvTKgcDEG8Kl zv1tHt7NCxe5!ItfpcoAen0W_taIB^fm}O8%@>ax_2t`WjbE+2}$+TuDRJCDB#4s?W zs2CDW412PuCZ3Emy%#1&5CJ(en5Y_u9!r45SgBSOYm5}dU}8j3%z}``Xsjvl5E_Y9 zVI=IV&Si)~q7fVuv(v?B6V9PF2d(4VWUd@QLn1zP5QG z73Vd^5N`MrPrv8(JVE6TZ$UOX0j*ZRQ4HR>6wDY6&w`-(MTL;jR>vGLI$H) zIbu@=YmjKp;8V{*B&dj;C({6l7LCj&AGPC{_$sCZ&*=h>gTWwUW~TH&N$y97%*Y8D zvxr7Y*)yiho+xepR1HR!QWg+hN^LY!sMPLW5_2XZ#s()^dvVlawCDjCdk52C(I|Pr zjaZq9%~NEBV>1vOQLPbXvJgQgf|!CJ%*SZ!I-_i~M5m7(H}!0r0kUH!&35mEW7h10 zA0vA0n-Q7FYl@-;0K^DO;$}lLC*8UOym6CZWR&ROKCr(Zc4(ja!$)2B2e(`Ex@&24 zVoc*tf5JR5O`{VdSnRE6^tmJQ$Y4MnbO;a!HK@WY2B%Q4chF==A*Hl5D1(@H40fhw z@C4QrWtpOr3`}N5S|hYc4D6Ux)Wi%zoKLQ3Qu88nIpr1Le0qUqRL z@E{4?&GHjPa(hh*^vA0 zF+FyYq?$toRu@*uoMZ9@vdmeTWyFZa%EMs^B_t}$86-u+C;==)5USz2#%83%1~4;u zQ)3WiCgK#-B~l`FP@Me`0>-0yYQlP&u#@5p>$) z^w#HI6PvlWn;(D74*lf5JX(z1eo3Ac7L5z?a9Ktm#i0{Nb*$OoEu$U0;)O4#x4!YU zh}~6u^VU1@;E(S|clHdP_s)0o#*wyt`wO4On_u(uX!N@H@JIiZ{_z9I6Zn)5~z8V6*?mSWZ%vPKS$g4KRE#gt?jM~$ee z3TJg6QlioJG(I|k?rKIE6fsm_&UjGv?Y6t`#ce;jmwxxReotTb#y8S+&waMN@P*go zu6ypGGiT1=zrN>pF+MheFMZ`}cFP^NQdL!TQcfz=yw7a=wsWZ0>+8iAUC7US&U5U| zZ+RoNivoG(v3Ktw`p$R0jbq17*qMbH8osxM)m7YZ%Xe|ZE#Ea)NAyfhPt$eRT#FaH z;Cej!>Sxl9^Ug!FXz@ySF<$=ktMIhTE<=C0Z^w@x=6mnI&&qBe`wtxQpZd&aoy%Oz z%+sI>$oRt6%xrEt@wVBnQMuNYP{fh%88i z2>R{u&@AK zR)_|4dwuH-PC!k`aT46A81k&(ei}$QM-CDO3Aad+YVSe<9NN3YkzBS#Lv zG~(RxaXRID*hr2_CRAGC#A+X3|N58ho(sNjAOHC0c=xVzar?>Rym!wY^_k=IF1!fy zi}QGV&*O~Mo_5xbID^4?XN_hH77Z~}kg~EMfwH`SL7-8SLpTUx3}`gl&=gJTI7^Wv z5YgJD1u(RcH!!fu1x+exfGwJkv!vxS%RMWw+U=SvNhiielY|B?@wG(>l)*?145mnC z#>^Q5qRI7VM9Kh^Qi)5R36Y4Lnv@jb2wcLVf=E>Wr*%MOTF@o{WTor^i<&of#wu=z z9j>2+HNCP5$qCvl3M-lo8k8l-0n7yjSHhC2pF|k!$w3*N!lTvf7@5(+!YnT>Ez_=D zyYPFz_q+Cg{_PX=m9KpnFd)wxXcPt5F;-Vs0RudHoH%&`Q&W?;^ZU2qRj>JZG)6|S zbL%;n9n8~6XUvYz&d`ygM=>%wf~--va!{h#Y+?8AU3A+Ww}YI+U}Xi}s)r_ZU>56H zaLRFH?;#rwu#839*R=2BS1o~fp z@m?qoyIz+D#KQsha7a+UnATeHR7BT}_7F%>KM;lud}_X}ZUk(oG^-O<6Mssywtgo= zDTI*1<%S3vqyc^nr5Q>;>sLx@+oAoPDJj<|ro(e|bQCw-eCr!O|G7_p#>mQkS>_Ho zkyg0snOEYc4?GOVlpKKdugp38)%*T7zT{_K;@0b5sT)Vwg&VL?cbGKLFl>L{m+(w#zQL0?W%wxbE6(aN(twVqsxk3-3YB)BNH* z7UmY{^vTn(O_wK=ljpv|}Xp0MTv~9~)6A{bv zf~#7|+9(S6ykXn6Zlf2!@H*_>yAS&g?#IOFIPxshBt|iD-a95gOzeYm1fS<=knS^p zf$8ZrSUb5+eV(yeM4sp9cl#I}AAv~XhBcanH1onWn@u#^O?c;wTn2V2MY+fe%8MKz zwk&f*L>5)4k%Cmrdk5z;YBn3@eZurO@8Nw0$By#c3E-K?AXdvu>eL$(L8I9K*pYXP zm4#(HGdGJ;BCReiS-;oUyvXYSIx>|CP*a1sK^3g*4bbhcAkT7QcIXc(G>Z)D)~-vd zg9tNIo|qiR$&;rb5S+L3Tx59z5&{~Hrj~;quUS8hgZmC(Zhjss-7c0_R?+MAas2o( zJh5*d{`1RU!n3b_Hoo$oU%~j~w3g+7eFnVi7vG7Gf9{h{!FU4&XBZh7#p22$j0ujN z#i#^}P&0MJEM{6eooJH1?z`nCe$mhU7u>%vn{Kjt9tBRXH@#*J27?l#BO@4}9K}x` zdDv8pn4LDAXC?+aXDhv~Zkk%dmu=r>2WJT)6w9*SzEDac^et;(D=wWcAUS{a?5FaY!utJZqu=`Q5qW^)!v}b z`=2;y3rq8y=Q$QvmQYoK6UR^B(9xq#b6j6*@mVo3y)@nEevW(oz(ZIS(^KKSYRBh*f}u;s?qB3*OI`S{M4zlLVj#~;4!^|q>& zeBnp;(Y}MnczwG?%l$4wC2+Yzzh6RKW=s7p&8~L!+_h`@^zw=>4+gv%O06UgC!_#i zQ_Ys!v1To;A0M%8>(|qrd-vJ>hYx`OoVRI5c-CbX|LTjcfBq-Rl_ku~ErE=j_lZp+ zYG_(ahocRLw2nL_i%}W?TRogjLw5I62@VmQC4Hi+r{hDE3k{EBPK_LBh^4MA%Jtdo z>hFfR9&FbG=ejSbL%(Z6MsjYanQT2o#_(%lX(1&k8-%D{C}YTGPjXzU3x;8jIt&X> z@1+jvuC1I*oUrqCnlo5ZQ!7K(d|gzedcQ8T)1O1_q^Ko{3I8HPf^Quf?uJS-tKiU663UoC$JGIOu=01>y=2Az)lsGw04Qg zqm;s6l}SNl)Bp&~!U|$m^F*9U0(yD&JOHQ(m}gK1)0{vJgLwnmPP8CKgTaLvM#-c} z;5N)U1RDY1K|0Dtg{n-%LDeQ$g8+zxw(Aczn}}LfA@)m195@7pI0<*XzS+MCP1v zdeg3>jEn@3fV|O!AMF@79O&Gg=^}mED}igSPqFk_eijpir%Lkbu|nD-oc*07p%_%8 zp#m2Tv0wjHPY>?_){dL5mQ<-?b*YP0X6qYKAB49pU0x?$!B z#Lib{kd$d=u%uH844O~~8&I*4Q!_E3NH;SRI~vmzN*>hIo2r8`87m}MXf=GUk-(W# zQ%Q`>s2oI1qy&pOsY;8g8bhF1RTe^|P*n(n5{<&K27!bDVh|t%XjuVeKi#oaMTi0i zL16@zh^Cm0hXGt~fGsb-mRw|r4bXhk8{nUF9cWNN@4gLm-i4s^FUC+xmZU^T;6@0+ zC=Hy`+R7vd(OZ56)z`lae$flS>({{l!#^Xm+Q?)8bwxd#Crd+lO@SVU6hMg-Qp0M% zT|Y$kZEpkS7Enw~rhw-VfQEuvWW4oO!VG zYMhZVL7gXJGM6=ivCo|Mnl}n@g;$pq$npZnnAFHtR#!7)MwVwW`6>YhOF~{li*{4k zh&AQ4l0|c-5JSw=0H5XHTJ=GhOJZ0vqX>;GW`i;Vr2qz1F*c!?_z$Ep5R+#jFp-*w zzyd)`S*0?OC|XsS##n#;(P9}Hh>$X>s2RGeF2(^6#ZU=Z)D+sFfe@pOG}^Rvd;}v^ zg%giFWF!4Pw*UTrC3<3?xo>ZZ{#D)}eUc`wc!HwqTN0vo0M2WPqmYLmYvl zsQ%yv?*0BBp!Lv0h@+F1z51oZ?|3W1S8uf5H*cmeDAA1p<(f6<~lsFjY!o@g(Pp7`?rs1^@T4{v2!CMYa0fuRL;yBx7w6F^I~A< z#lV66R(|;_bo5MwuI->QSQJ7vG6E$da$ewbg3lD0H_o%@vZD0fEx>cd&JBzxlA#Nw zo-tOHs8?jZYp_)U%>!66!(#oP+&2>=R#^I!DREUp zVtiUe%^e>q$Zg1?tzF`%L)r|Mq8k#XJ>{D@q+mBBmzt|R9IDAVCw8{t0G-tn>M;Hk zp%&iN4>8oruCtFy@{TmEoJ_Q?X8;ma;ykxTJGasHB!U_K@2$Yev*o}F^4QoYc*FD>ZGyPdZtH7abiJ$@AI*-QK5j=2 z&*0g+chS_&ZQw0iaPPOihd=w~Ex7BkhY*}0nAp~J>uKinNt7{y0h{Wyu=ns0G)6j9 zxB>%>^+Ld#n$XI^g8k=bKa0EW`7w3-eOZ~CaZemPfTiUX3n7vyVSJ>6DhBkr1KYB7 z1Bn^>y#cCNS~)1mh!LZpDoe|<96=*xJ_i))J#o9$0kK&O28{!X8sUA0@zF_Cu|ydn z22~GQ34$uBsu~Wd39acR9#=NT_t?)EVCM*rVw81~`7=C~mv`4!!+{x6|=s$I?#AfpgzcrII8liApW` z;MHed@r-}E{)N~43#pxMwA=B_%$aO{ZZ;NqqjB`)>2){U^xb_f%l)&Sb#?gZ{XgdM zkue%b;KjKGs73*5&;vl7&NwpXFxu&0Y;+97gqhhhAQ1A**^!ecNP?UlBH}3;7l6>r zb5kQ4@3fW3sMjm07fZ9K1ZZ@P+)Jr2C`K9$Gh*uZ`e@}DF4?pJ>#_`!&LLOevgbS- z-#>5&pZ)%=P(0ZSzw$-b<4^wlFLBk?&&1(F2XMo8ZpA|nJ&4flWAnM&v3|oktl6** zPM{k%ZlbBFDQY&G$cw^?MnMFFn1F@Qj}>AFXcPq=eBfa$F3!uK3ND5KN2X>(LB&#_ z2Z6myiX~NM=b$iiQP8$!cWK zXi^D>5Yq{vV!g8GLf`&zqkZeMHM2d{s4n2AgV$o1+SJ> zLo$7Yr5EAh`|rmmzw||rW2_mQ!0f`DnR4B=DqsEV=i%1x-vsA8 zKJrf=vcLPM575%$qFr$Q1yr=!fT}iI1x-#(kaL+n{pnXy;d4|f`jQvF$lZVMz4oRz zzm>>4OpcA9Uj?Wrm>AAERD%*C0-^MKoN7&NHX584O=GV#7z8})8PCL)&6{=4V~^3M zO`GZZ7hZ=o6XW(bANT;>amQVtoW&|7IHvAuNhT$J^IgA#kALD{rP=PR{>#67WPI+_ zETRrl8Dt7#m(Z(7eX_+GXU8=$Q3#xN|7VxC!;Fu!xol+hdBqr--RZ0f9bjgt)Y%=% zFs_L!b%3^yL%UWzfWT8+KuIE7U%yYadpmma1~Y;tR7k?w#Ex1!(g8xvc~R!j1X$u;A)Z|@=c+JAnTKKhZ5=$?azuzAa7@#Hzn3W37PFyJUk zMhc5Wnkbtpnxcf+lpHZB0vg4L1sPbs>|*=w-Q4Z2B1&Xtht;J8%$z=>z1|AV&d%VD zyYHlb|M-7kbaWKI{7b)tqS3;4zx_>|bIvaO>qkF=*S_xcv|;^vtaMjsv@?pTs^Fco zDA5LGiOiHAd+af6T)!5VU3QrTi8y)uq_x+sMUkp-&Y$VnN8HYMWFVhs5G8|Y!oCogJu5MDzu(t9FSs?D8xz5?L$B9|!mKEo6oV)`M}Q%U zne$3&&N5HKgk1wOBRR$)q$Y`xtO`p8XN4JwIS^F}(@KdmhM1r%D~PB;gklI}X3hjg z4hjg7c?}3Igpe%Vo&aMrBQrDejyb4mFI3#ha#C+Fc3}4D;RUv4vjq^~d_lg*InO-i zXBMsB>rpwVwBH+WC`&9a&g1=m`@f(fc+b0k8~^Z+A4pqJBf9ZxH|Xo%{95i-!P33X zP&Kq0Ifx4_RoMFiW#~g=thomacFbxf&YV+IGeGBI{Lz2?7+$pP9Q^Wguf^UoC#Y1h zy=NA1rn`cT7hQmUzXYjZad|-py#cnY-N5GdGX#FD%>W z#F$O2nc`tE;g${S@Uzdq-u~sYpTg5Fz67f)1I*0Mks7MU_CN8$=Pp0<>y2gukL`VY z_d^dp@apB|)n6aP-Z~RBhf_c%GWHIg_6W9Z*@oTcpGVhRcMW!)vmK+OBRKz}3v7I3 zg2*uz7v}NMo_%!ZJ$K-?Tkph8x85NAZqG!-8Hh$l$Kdh;-R=?`7|lkG$+5LGIXQ|= zn>W&Er-M)iRMmi%yQ?^U>= zN6h7(CZ^WFs(^*XGc?lbpw%8h(Qa8QE3mw}ip7-$kOEy*Typ+p%A&TsvPdhdU9Cj8 zR|Q&JnIQ&n_{gE5l(?21KJ{06_;KdV6Q!`Y8b?)&)F}6iW}|71W`~@2ViMW;oZ5{7 zzGwg{$Quo`n{9O3EsV4Z=ZM=P}#qpqY7$v|7lGFw$0E?cTW-@9nY0X+A z(prLEFNo`a2?fZLOK?6UUK=uiWVkw}p+T!&KF8$xsx65_hA7mK)sp++VmswircDD4 zdFb`v+#!XwnAD1iI;i?=@jy?xG;KIoPeXN1p#!j*BV}5bZ3K2oDzyT>o(q!IDUwb( z6*5eTNRj5HXO|Dk&arChwNtD#0I-?~QkK21VG2nJt&Y+gNPn8hhPO(}LL z3}PN`DijW2PfX4X%=NOSmda=8%gF(jC+0f&DB@Yj8*4+=nhY+KEoXLc67s5wLKaD) zKvbF2;QRKEEFSYAme>9Pa{U9v{Ys6HK@9I8`Y zA=Y-mv)}n}GC_o*L7e4gd-gcJ?Jl@A)4=E`Xz`?>91w{B%AOqwn)&~Sm5tRc0nMe2u(X~H(B0A&Rp ztb$w#8|grfo`%l~;EvnC&%G`o5ggS$gVlGmPg5wWR}`jTH3KQ((#z4>aX!lR3x*#* zWZ1Mmc^#TLBrk}Uy5KCQ0%T>VC^iv@d2!vc~Y(mL7>#eSEtRh^VgA$a7EeJDF2Ja(8h&dzmQYQvE)=F4S z)hu-kRH-r(tB?sPShTiTCniOTZ1BXaBmy&H^3HLLss?gqEU8o!0-TW<8>P*diSaN@ z4>3LCpj8Sr5C;_{RTFq)1S7D6bB128kC~Mf%cmz{5;6U{S1bPD&z+k)K`UoYo8R|1 z_=VSks>-Y!fQVJSqZ*oD=SL)GiYTemk{xFN8M`a4Lg(K<2D=Fhg8BLsxlLy41kXmN|>P!%2Y{>HOn9-2r3ZM1mRXC zb;f4u7%GTFv9>I!S}Jpum>nh5u)raMYOvJ*LRHu?Gb3eD1|YyF0+EO%R8p0FW@VO8 zLA63vCLy6jAyXxbkqBZY#-c_Pf|;0^Sn|t5jmVKXLO1jX!3-+MBUvUD=M0;4Y@;IZ zy{`514%v7IE$7un8svRO;mAR_o#zW){)!}Blhl$ENX^WhRj&EM6fiz{+UfoGSeV~o zvb;*!i?0WsehF~ry}+A(%gnljnHga7F0E#M!sW6vD{_c;7Bn*X+{igICL>4WoQE+J zGjr-R% z@S56tCF8Umsg2=Ub7?TF4Qk33YWKJ~tqo^&jZ(9cj10M@ua&y?N`i-{DE}~2FQ>Z1 zEP;gT@kfn{9b)Iw(%y+0$TJaxeK5eW32BixT;@5p8XX)sezNgtcYW~__>I5$XZiX!{*&ga ziZ`rXhc~_HEqKkZydBTG^68j6b{r4ibBF!ud;eM=IdG6ggo3I9aLp`(Fo6`LYA_Sb z%m-xNq1|ZE6Ne64k!3`A4i-}}IEeuvlu#HUR`ASFi3(LJqgrp!H`3(av?oPGHov%3 z*AxkR(JDIFwPQOrZ`p#)>o!PhwB^V-Y~Hw8pY_~laVRTnKW95lPp`-ElPC4`%n91H z{aoCA=k0d%#BuI4@3%`Yy#%e%j$Lr^h4jkyD-#{T6nEWm7w)*@Zrpv(k8Izgd+6wi zBO29ERwb9SCFW;m@$e%L8-I^zyfcOk8`oj$#x2;qWiy_4_0_oQiYwrl`N+wW*t_=t z4jn&YCr_U+jS(RPe)N$?@#rIu0s!9gp7&U*XwfTQ^(y;?UwR8YxVc8g3R?mv1AgBUQ~>R^4IWA@hD@IU|QAMh)`^o#i5hdzw2{`f9vH2ubn zxA3=be70^mXBU0*8(*Pc{`FrqGNI3Z>NEK8M?b0;oOeDy``YKpwyo#b*!Z|3$1qB9 zK_qqFdfJz$Ct@W6XAVBkk@*a(Zn$b@Lp@tQ?lXJHGS<7hI6FM z&XSA8j2zfSHl@VW@@k^wtR8=Yh@3hYiSm%nXyjlPiOh&IPa1=%C1*Z!Ovycrl+x@y zSSrMzlu}32VhA2;8W<7ma&J@;95aN~$g!y?b4CbdgqR`E3pBj1vmyvprEtE2iPkg^ zhDbosER4;tY5hjqy>mAeh1U=L?|J3yX_nN@szlZ+Y`u@$Vo17^*?U zul~y0?USGT3}xQi+I8!2>eMM@&Z9Fm&dxjZ`=y4kYR8Tor41W4+KH3LXy(*uV_#5b zq=l80u4H)|Dm_<9SwGtq@aZ7&;%hhtGZC|>SO^0ud=q9Re)7Nr+GsXu?ZyoR&$#Ue zx7p5JyXa&8`$PEefAYup`ZvF2#Li5_pR;WfPMto5ox9F~0T}dqjb4AXL9BzQU@}up zrcAJ*R-V@?^0c8#XA}=TPxTpc7HOJpYBwyqrS6-DQoK5lG)eVpEILrds1Zyo zM9x7XplYU?z&MnEZ)Ono%p^>mkr5m}a@@9T-9}?09X)>RF!ENLwF({RX6sA$|{`dX`{>NYaB}<6b z^d9{f;o^Tr!dhR6#GvxuPr0Q2N(x`ctm3A2#0BvmJp4eHN6{aL*Jil^hH z=bdX;p0n9DuU*S=q-Ec__kR2Gf&IL&uz;1`DylMYr`^(>n>S(O+G#s6a|TBb9fQS) zy@!usO{sVS$3Du0QEN{^{+qT-3Pk%bLpR)~Hw`|3hty{2l%O-3) zX9rr%mYqC#Qt!O&TXfewKju$=_ER`|_%ISGeu$|~C4ScM==HnM)m7WHb{)2!vyG-E zCK9s3)Q%oGPLDtSIJ#i~2S$jM0i?u9Jk0EqcE+)5G@BTd6*LH%%?|H4cZXg3oNMW# z3(rTpGfMMIi`cwz9Y7A#Qxi5dHKh~d&4(!{DW2a7FWMl;E)~>Uq zxkc*sy66vjv{LrWq&6xMQ{Pku{Q>#q70P_>+M{jtB2-p=bbCEaj832#BKoU+tgJSX z=T2Mg5pEV<*KgUzk3PPiuD#%C*tKn|ZCO9fpZ)H4wA3J%Y~PLf{wi;o-auFE*n$?A zK629y)D5Cztrpg|J4{d+bxr58bY=u7I@|!MT8AB`Cr9n{!ZIzbtXjio+1f0#jgxEi z;_)dQ@2}dP6Ep7Apo`TgXi>$7PaU`UnbWpu%Qm~>oSj@9*>AH;t5HLF*lOt4uuDIT`1Rsyj=l*Bn@s@W9+IG-pM7@`jeO5_=c7R@YYO4hu@l6J;q-V*tY6vSR@ zNdX%KrjAg6*+XjSJt)08CyqgaTUiD`mDH0^K_Iq_2vKqgkz-Z)XvSKFq`#C1Gc!{m zS8FPbkf}#P0b3+z1hHTSZ^p!=3hQEzgUA^f} z`8i}pn&_0Np-DagPPJKSK?PNq&YV=A}WFR3z zrKUx6BBZPXGA1^c)5z313xkr%)2m>Bj18rk^UNU6Br%E_ImdNd+~hFot>@s&?;XUhhPt9>nRyOZ3` z9Yp{3F~Pgv4NkM?I{CRy;8rom25>`BBd(COh^99HFMp{a8zuKgujBaG!>G=?4Ct5Q z)=fCKeUlx0_%T%LHesaG!c^vL-g`of9AgPVVZ)|U&5?nR@ z)Akx7u@<1EuC?i9PQw%k3Pl^&YZEMOUw4~ z>}fKvIS(Vwor_9WZa)Xt?c7D}c7co6Ph;Qw0#?RG^kD4rn%x)J7e4Xtbo19=VSo3r zPvfQ^+-U#y$&cgTKKXHSO!kZ`uckM=^hJEprB~SfPwa=OBKJ98dhvyN`qUXdcIvog zoKw(HuN;(P70|CLYcvW98X$c^#_Y1(*+{!%BO~j1;9 zacVYmOpZ@z7z}uHVhTmGLF?B|>(umGo0yp7$>}K@Eea#Y7#&~3%_1jwsDuDX!4ejv zwEjwu4jwp2{Xv&Wpr=orL^S0so3^M@N&;V5?$g}tBFrMp$kt9x(T;O>+xh2TM8EMH zzfOzGOLpMELE7`!WAc-qKFD|f@DA)hcu>Rw)Qsm>7BT<$A|84CaRm`Fa&G;`O<2Ef z4PJcBbvSSLx#%wU=-8Da2b;icrww>qcYu@lW{Qcj*ACKJsfc?j3K93u3zL^gm*ymjC zC?h8#%vDv5f9Iwf-*ej!@A&1XKl93aFWRyD*Vb)VcWA@p^eN|k22xvGTJ|uqL64~B zAwdMDVr0=7*#N!n>XWncbnm4KoHG9>T#xMbHa@0JGeAQYKXfpYE+CL$In&;c+zw%|f z=k9ym>0_sC{i}agC)cfW+V7)`gP3Jm5(N+$sSk<~0^A~Qti zjG_>mbF8A|4Gb?ZB^3dgAeba9W6*kH#l}ihdIupH^%*+`~uU|`pL4_aRe?Mj3V`6d|OG_(`O;fYzQi=s7;vJF>NtuZ1qiU!I zOOEh7FRa%a@WT&3V(T}o)ooig6UfuSgZu5%U;PSw>WiPZkN(sD_P_Vve?L-2HamNU zPMkVp^NaH|KE5U_F3#qM4;|ULVS4Q&WR{{vb(pP{Ft7{T#Ec3|_+L2Y1lNYP96 z-G+MkoBSfMp|8F!!>L9aI}CxO2^h$f(zq}z+u!%z_tiVdnmeP4r$mg_yGn-DE;p+G zeOQ{;Vh<$pT57b1(|gw8D=-`hWH=xgzOj01ZS|BrrSDqZ)~7+bS#1lW`tM89*Rw%u zehBztK$Rd-x!q~$nKQFn|M*Y-@L;RRdEfrS`0xMU@8UC`|AK;vH7Y;~Pu_m`{Tt}A ztDcQV9)1Mx`-{K8(UV7G2E=tVDjvCYiQQp4xy_bWYh{5T&tbWmsK=ggu~6vb+Hg=lm=Cw)~#8u>())%nb`$bh5;Hy1BVVB#?-{5J^w}56GZ`M z860~=3D6kv;SYWYU;E}a@zV$HLw_*PZJV~z{(}d_dG^r^haY`Z-u|{2R%&CUpxmKW0eIKc#K<|)9M5~-sZF^M^s8O&JB&|+AT zJ1h@EY{F$7a#)a{r30Dh*;_MZ5dbc8<`b>Ssw$Ae&}ntlYihF{6MAKZQp;NOSeq{E zf3kD9VE6ghv-fd`#Hu|qB7^>_HzQUR266Q4{rK1@z4T>2i>F(On9 z?b|WhZu8>uDvlmKgvXxPhwkzUhT6;_>^I9?%zchVqvM`_)#b8bdOdT-wrS&L9v$gW zquIpd#3VLs*k}`LCTMzk8m-YbJY{f>VHy!aL^&w2va)Q83#-)aE+dL)XQa)}6P$C% zT*I2JHd@Ul$PuZi4$1*%K1Z|Buq?~SWe!A8CQea-W^Ndkp{mK67$a8uJv4m=(RBU{ zstQLB9mervhcP#|j05}kC=@;xDzVJC{uS?4- z%Q&{QWNb{ErzWiI_o!VoY^u}7=Axj&c?&8qCF)ic=EDF+j3|nYBOS9uIU&|G4f0Gj z)+~tgOdr^LfFE66KwUOk!#irb%*>3ouG=W57v|hbe^n|oSD9I>+1m4)ulo6C@7%O$ zQG=l482zeD!|Iq^Qx2|fy!1(g$Z#;8R@0ywf0EgdkYr~$;6uV$I(vO>@k$iWdMF2? zh*XBwyiOh-w!<*3gmPi6t;j=MTKX)WVl(qkssV?abgS_*I1jnEUJ}T zX9Ko0Z4Z=eh|jK-_>@$8^#p&&e^X1!a@4ey;cOd@QlM};kk4Y?QU@FXb0BA_CP|~= zCuia`9O$R_o7G%5trPi7Yk_={@YW(^JIh{ob-*kLAR(wTA|bYPw+MN77*gj2W-^OO z2%to8>2ES-PGoX2vx3aBG~y)!AqULYCJ!d|0{~4X6bT5628;E>!TU~SwizL*d zLsI}wZFPz0M|YXN?U$IltBS3gSfW9gv7&^M300o!JbNxLK5r5+C@RD}!_=Ip38nbHv{E9kfh{=WC@>)-c+ccA zkD3lFN?g|AJwj%zWJZQjfiYCXoR>7Hx5CUkz>aEGZ&dXrmPSVkSQQB#Xtz7&Ot^{> zv5J72z?4OWViieaDWR-f=#?6)l7mD|Ccn~&C^7&R29T;s_PH{`S!FH~aeABDU2YT(oY@G~y~Uhy(RYrGzsT0$?;5UQAD ziOH@hKpBDG{7r-(-2=-D*y1v{ky&=>#iVBzAn$q?+^b#zCTF#LD76ks1QsNax+DoZ z>MdWn3iE(`;@^z^;_nd_RtTeGaAt@Z5I3&3)y-RIWnmc)oSs4G_R;K&)aDf;pL?`( zhe)gjVwW{Q-hsU{cu(XrP$hjz5@QtRxvr{qSECV~@p1~|cGmXqyVN9T^3h;%u z%w?808^$?9$(cnHBXtaRF$l2-5KWT5JA#x|96Kh1ce%k-V^yZ{f|=DaCI?Hl;8>L? zxCZwd(!#}*RE#x>#TbkbI1VZ@N%=e)70{q@P_alr7Q|vT0AgiYMmCKIqHsY`u-TfJ zpgZl}DyHWaDZl3FT0G-2?tb{+P>qjZ-FX+N_6AIgbE>To&VP72Xkiu@88#f}Kx z8>OaAvqnx;HLzqoHS<1mj#CN-OwAR!S!EVAP#U5~GEvoN6eX$`;TR*4Xv(57g_#;6 zjGc0;3Mrq=EM;kkVK5lLRi%wJTjafi^!qlVhAE3W=E+f`0h~M$+fw|;$Hr9eEhy2)5LS04coE-XZAjU`BD+H+?;3A&IpiYU}m5wlwC&bv&cm*K5qT`|K7K!d!|Scd76nJt5`XoO`3FPmb;%m%`m5v*^-J(%{=h?`45 z#S9TlnWzO2)J)Zw2yjs)7@9hKX^!@I^1f$VdyN0jsNvXmA#H@7(Th{Qj-@ z=>rd9WOM>McI?F1Xa}uk0kFfSty|G*7HBm)7#SNur`@*9=fn**QnrQJ88llhDvAb; zj*g(w>}adeps|TDYqeYKeF2|2CN@83t?`}VE+*)M*YmKPSu5>6Lu)~%)P>MHuZE;dZ9?>9S**&|1fZz;e%y0yNN8zP!394?sbWfgsMjTguPq8Q@&)N(Ce1w6CBVPWBSJ;=n_(duj1@=C&N56N&O>|=BBwq1~SI|WlUuY(TW~)ie0*Pv>Mk=CZ zRbp~-4L$tmBh>Hqs-KhI-Ymy>6G)*gO%JRUaanFicg2C;>qt z8m@uWvWwNlWt3G9{eFassKR)DZU((x!1|5r00~%LTETVKU2h82zx<28WChGQCZddD zEa5yuRpFWO)vtaH&ws%SF>~UCUU$v&`S9_hn4X?QBX66}GcXHTGnRhAf(Vc3rtlt{HQO$qVlQ;0iA z4L)OxPK?2VAxZ@zuZ=vT?K^kjyxlu7F}2nnf9w(djo+DG61%Wwa+{-A_~8YO0oY&hU105Q#ljR;%|(daA_ zrtY7#c4nK@B5^?-Q2XTlQ_rkxA9|Vzu)%DY5oR@T3844A_q}Huby&JDQFCZh)9lZR zwVq_FTa7E_N2bB4Y@0wR1S4UMy%CpL85Y2iK>R1=}9iq~XT&a>$)Z+;6+OpT*aG%+?hg7(B1s$LJhUe9j7 z`3Lm9?|u)T`_kuarPn3rJ)HCP-xFbCsA2>$Vbj|6cn^xCdVgjYHBTf26E1`%Q9nj z#B4SgRMzcwIR*hSAhq(ZH|PN|g1j>`Q0B9AU2D=Nn;A(+X?Yq$O~GJ8RLYu}SyVGq zmRMtI8EmSmD%5PWsVFjd?~pqOV?w(qzOlV~pWv!MKSw`%ABp8c<`n@iC zy&mm(_!0Z@y+5HthYsM-!9#j_W`;!s$BrLE3<1k4%UD0P9-YxPmS*OlEV$(23-Pyq z_~-Jv-*}hXdw4%G=dI;H>qjQ+vI{Q6o+C%;(W3`b21S;{1n+Q&D7V(lo zaqHCO+J-zVeo->Mf2&{`RuHrlm#zb4-j%-1e5)1k({t^;aYHK(&Z87XTE2vWF^ny-b4 z!+_E!h4(}Tfe{f|+V%|t$7~9D!&fRN7`TmJo^<%MSIcRwxIERb>J61~dqr5e&S;3VT#ckSxPI2o(c8BamaLCM*!;4oa+I%9+o=joh5im5K%x zje@vYAS)WkM<>V^nTQ&qnX1AYb4+n*3=ml11Z+w~3U*>*(G^^~CVfycaSUO&Qq3gg z$P&!d3)u*(SxmR3kg69@rVd0Zo=|Y2)ryf4i6(XjoI(_66-6SFn;=$_a4$hjElR8^ zFI8pLAVOkEp{y)QBn@gB2Pz_*D=1VYG*pOX1e+okLpxI-Dyp)d+$Axh0MN-B$j_X? z)(w-k_BB68{ZD)jTzI(A5%9_)bmlbN%U=!pr@uFhbO^`+r0XEH*foHd1!t>#6+;Y! zzk5Hb&wT+jvjAB$4VpOxK#*d|;P9?@!Po9(t7DfjL~#$T$|)Tg2r(_zTm~ET ztbfJR(OBsde&)I0C-zynT9QsrSpRg7Z1-k->pQn#)fL#hX){cLKnm|X+LT}_(X(Y) zgIvZipMx_pWCi)WX(%!+il$|a22;kQDJ!2N}EdyR2UQ zE3%Yl=v;mwmX93Ap<~Ap+FeSK$}NYT@#wM);ylD<(A-DOis=b4h`?G@hl_?$3&iCu`E&e+^nv3 z!}u5`#-^DUnGDK49-m*d$jG{`-T3%8-~C5_A}fn?kaoe(eEl18%MWhGji0>{XP$Wm ztgNtM>lTcSk0DsV+G-!GE2~iN*v{LcSvrqZ7FpLdPzO19=s*hU(E!buc}1(0N(v@x{-51$W}p_2>0Ii03LkkVMMFe#b&H8uuk$qap?t@;@Qu6Ca$>Ra=Y}(D`exQ&EizJG`}El z8Jv^&l`noxKlZVY$ydMfWkeX-?H2ljK4ORfQ2WehF@!WLYUoS=YA7<;=wP&t>}xWr zqx*U~$x8DMf5O+9TGNQ1`r4&wD#E%}*9dq_u@620HQL+|T(;h=XCXixFy5U+9crvq zB@lz<5P8XSpDiEy>}SpAh3?z;X#79_@=^DZkNpde962n*vVuh-((IP+eP1uR=4vp| zP8>a`H{JXL?AUP%&b{CQbUQ6DMubR25HZv&t0)^b%;5gJ?}3qa-vjr3o`OK>^*^j+=ahVw5 z(1a;T1uRB{U}9D$eLX~!!=Zz~YBO6|Ue^BVDu$ufayWoh!Rjh%6r!pthH4-XA7UM} zsw)w32xSnH5JDBDwx9}=vOffAsH34AmH;A#F(7jp`hz}JmKT$$$`p&si`etXUYHs# zIPU_~{UILRyBF78e;sG1H{jRb_(mE`z4uUxRk23q3yq;hyPfmk(PJF%j?1S$@p1Y0 zzwmk}iLINr!sQMY2+$Ck^*eVSV^fn>6a}ZJre$(sLLthj=_zcSnZ>pp+c-Nrs~`A3 z|B5es?u*#CX(Mv)F&vg=3?iwY+XAD880nL%A{oh$1~wB@OUw_5PscAg-8PCG^zkid&Mq}Q$_wl7O&)zjb;*tOU-~alY zs_G-u2`@?jnI@h_k^vNSjb3djsHsh-=M&*CT%YjD2(jDTaZ@adnz}v7L~?;y%8#&d zzOUKb6bD@ z9aNe%;R&s&qs`N4!?T->#aMZjP&3zk1t6<(P&+>6bYKB6D49DYq4kmsm92>Xsgo+p4?gJj9X<>|Fgrbsg~f%R7$mFH2vOIRsj4$!miffaRF}Gn ziBw{d=aP}=#}b1~#>Xe^wB$g&004jhNklmh~!T1Zg1#KC3^mS%ur5b>bU zEY<=-oO70}TFR=f)tRA&jatPa(CC$#Wo^kiS(3$KgobII=h*}!B8f;9UfXN}OZNmnfSe&!kqPDXZtGbj-9ol(LRTT@hoijbFHGzj$ zdRQ5*;`HtquG+LEBKK~w>Lc?lp1y6XRD&VsSNoEW74fu*X>M&7dU$C?K6mGxGBwub zIqf#+Jvx)q{KS3t$YU$3@PIsN^UnBCe~rgimslz@F;)aJ0P>78&;Q-MD+}ZQ@}}Q> z`?2Fo7=%F@-X{77JUz--!y~P$5))J{Il$B5(ODxAH}Cp}s|~No0TtD)7jC-~amlQf?5MMbFPe@A%55!g!I!9>}(m|*Tg>)gBDNw-4 zG-zE!YZ)=6X45pAu}BASGE`MNhPn=+>eOXD?uNa#^`q5R3hSsbMhIyl$@k#P+GPe9 z0{HLL=svBx~m=&N4%P(n~U4?-;nl};@>6;ec; zLNgD|a+54Wp0`9gIkQ$5zTMKSGY)ai!l)os9UGe>;FO{+h5RK(F;Fs3IP_J$qiPXD z9Uv|WBnmMUrv@O9F(aId7P?fZsMZLCkr|bQz*}uzolh<%qY5G=QVBI$kYGW^+J!Qv zS}Y4>h=v$zq9)5&s#LXyb;KXW_tPk&AQ^epHFQYhq+J&$YXkTc%MYYqg?9Q;W5XZJbTE>_}rKPE9E)U;?m73{?dEX#OV(lV~ubQDbz@XQRtc zx}F$?2n3v%M1ZPwtW6?OM~cEoMiGidHMqKVgMLYi5fW;#U<`Ey#)udV8Y8;mKDc`_}M4%FZBa^5I^}vu(!fNRfTUPMF;W=_&h(M+I4 z;E1jRdvU5#-{DAfceVYNq*--Ke&$87Uzbeuac8|`(7fL*^R|n62rnK+6 z3)rzEpf=A;A^kp3bU;a8Kj{RBCS|EuSvK_h+W&|5!rgd7knXt4pZ6@mg%_AT|M{w8 z8Hd;ZoZy>Z#W6q2FgYo@aTfhLaHuLV%RuKTUS-f73(n`_vJ8^vRPUq9@>=sExGW3m zg(A8}YRMRTbXZeJ4W}NKJw< zJvh;nB8f(CjajaSp(&hbph^aqrrpL;h8f0mc7Y`PPs0*Ut4<1Kt^c=?5O0>w&2eNa zYG^^E!89f3*o*^f#wIt&rigT;8784#^Bjmo=5v4QmaSpm!6Um~^|ya<(^?s}wINa4 zUAH#u3skV7J1&=P+`!Yf?Xb!zYgGDO=?>HiA*!>*tR{KecpM#(;cgqS5Ejl?|4A&y5mmVa?1~K#~pX$;GsjThHDLf z!6E>cw>{1|?HpWt_0>G@?6YlYb;<4B`#5gC?KVEV=Rqmjo!Du2U2kpo2t5e5)d-h7Z+tIO!G2}%7R)Mi` zJ=KF@oSK-HJMOtlC%WU|zWeXhVOe6www*G!aDv0(5Nb{|gM^qwU;|^GWvc2VgkVkt zMW?OpcAFN1c<*dte4LY0)4F-{7E5g{rX)~gEdmzBQJ`LvJ1>z#%TOv}A_yllym_d^ zLBFr_3-cHZ22u`c#8|Pe1A;}?b;)`dvTyzm$ z{POGB8}!1CEt|9^)XG{u^SLkdU-r_Mc0#C*{^h&>a;q;K27^I^T}@R(Ns~D#cBAPM zvnUYf5*0-NT5Nj4nsL>r*m@MbPF*3Xvb)j2RYt~gG_Qa1(IW`Y5udg3kB{QymSW0@ zQ7e`zd`9u&k*lm}*ak=5H~EPdrx={N(T=x1fD_6|Y>cko954#Erhr%zmxrbzl2M`B zh$^Mh2m=`1)gZ_rMZg_*-F?ci9$es>I`{Ac4@j1`xw^W7zx>O; z(6!YbPC4xqtSl~TuiuNI4laa9hA5*vn}HgFDMNxps|Zb?5hkQrqVKCjF&KsAU`@_H z?_8alp2Xva4jDwH)ox2~wWrGqOQXhEMvEF_q>6YNK?nGl6a=Bm%bFA{^X~0VQJ1L#wSpRkk(-s`>Q=3K7170b{x~KTetG`Gfp)vGMzhe zOkECkvI&W-HO~qZtpd@aM8sv%ynoX#&k}4&G1?bYVp{c0n#t|S>ItgUAs8h{ zRn{;wjW9Y$>XU;(G&i#-!(lCCl+61C(FJLy;sA4SN*dPIdQuNds8Uy#dgy7-cAT;k zbzNg-!zMZP)ZIc7x8HWF-hA^9@X);v;*PuSMmZev%1bWMFMZ=1XcuENP>&rvgePD7 zR5@^Xe+1yXX6&?bRqrs{ZtL{KB<^_VA-C_yVHE8S7;DTgF8mw8+9)cqX`hhfqYOe? zFq0THs+l0&R0e|qm`=D%Af&WN{PYK5Bd5eqi|Hp-G>lHTKQXEQiI-95#VoMMa=!ef zFPGQ8=9TW6Yp=ybcOnJ?z1}iz`1ogV(@i(yi(mR8j?JAwp(0M48&(61O-_rb!&-lh zW+r1}W4d$e4qSNgh1k7oms*HeURjLaz3KaU_dWOO((*DC1``({&~DzAXFum>dG(X7 z#&e(hENt1fQzs@nRLx~LSi^8wV_{)IhIIt1lEb=o)v&7Ts*(r;jCp&k1sYKeD=aOP zsLL9|vXp449I-W)0l^{0z^bk#)V0KDj!4twVL5=43@RdY0tbb631=yyC<;%C2%e-I*}0Y!2J)%nP;DkdQi#PyHDZD(u(-8mft-yYr{}$r_;u< zm1Wj-1)nPx78mJ}Y6z-wh}wvX5ldCY&0`(8c=I-W!Re==8kG3fo(IA96oel0{l2{5 zl(Vt1-NKjm@5Rv*^Y-LZPL+dL#19W0bgL`FIKF8{cTY{>UDsd78RvQT{=M?;`yY~g zaZdjE-1GU}!w2NU2M*&0Cl1KQc86EYOv#b8H9J<-uA+q+ux~wb-@8?{zV1)odFHqO zyw;tt+5SNfH?j-*R&LQE1kv2r3B5Q`lSVyTO(U^^UT_H_b zE!PLnnw0$1VvbR@cC+s_7f6^wH6*vTCFYtJ!>DdMHHkOp+k~fyB5C7pSmF>0yo@~N zTxY4Hp&}_99Bdu;!UhDQ!lbb<(atFZUE`P+o*Z_wdEA@tOPbmxA~t(-a&e4K?b?Xo zGE&|f7mU*!BeTAy?V!0}Q(QxJQ#ayo(3oKJXl5UyAA1UUOLL_Vv8YjXz2HR}ek-GZ z8AgMH^qr_EBV(kBbCBqmq#Fmg=5V13XOgI|Cb0=BC?un(7o_2fQKP^LgXR+HB{i^l z1-v0>s?blv8-db=4V7VY)HQwQ$R)2*$vtHHHu(LX;2_3)+++fs)DEo&pIQ@ zblc(8*8zX@UsNWhfmn)E5r~N$=S8KKs8lFbjD#{+H0M-P&_-Mi)#UvioeaqsFs#bx zoFfHJy=#8N=`EzqSe%w(2C3ZwkNDpH)(o?B4g9$TID1i=+iez0; zSqBBg^iCHdj;Omd2ht*;F~DdwNNS9R5Th^{g4MKG3t}CJ+J_imwTZ+?i#2EwA;ttf z4Iw?pMiDa@Yw4RpV*nAL5Vl05Fu~A_7@O3k2ludb=k2;N?}AlnQj7YrDbyETjO-VF zK@nXd^)m&KCDp7dB2)WvgFKe`Ie~8xd+w9?SAP!_MM}XPn}?P|aO*6r&scx&2M+)G zUhQ1}DrnwHRT0^U(bO=Zo(#9UM2K%tpv^KV8` zmpZ6SYETrBfg%)#3IWX27EQF9x2)xW_RJL3IjKS#*5q@w1@oG{>s`Rst%}?M&O?Kx zXi|ERRK#rkb{LW3Slz;*hQXpD?>dZ6g75i9_|`b;vPAp5-CVopAr{{2?97bVY7gbG zFUtzdM?mWe=DhjbYe0mVn5CPXNDa^htIG)WX~ax6rUGYlP>lr)$%EtqYB=vmQ%R|# z&{ST#2CJ5e6)iy3F(H(!0^?{@9ith<>Oixgj4_#hBgl~Q$SM#GH2`Byfd|;lGILP3 zG~bhbtBb7q1MKon$ILLD1G>6IVO#K}?+XiOt=sQ(Vd1gbe*4Wn+;kf{yLTdP+6i}J z&ckZR)Hu*;8-@dwRtu4hAHS*<{S{z*LaQI%j80jhdi8Z)k1VnN;Ky06{gdYBz7PJP z`(&86k!?A{>bxb6%0XR91r_F=(5%@pD2Vnr!AQTyuKoe0wXOxhZYeGpgj{4RlO>Cr@oi~^jb8LD} ztTD^!x(P1f>(DsT*%(LGnG-1_(>VQf6vAnWvqS|EY2czzj7nG8Y$PMAP%ab(;hVa23-u&W zmtFI8`K?oT(mE}DaAg_a+_N7&IC_D{K7$Vu*6*Bm43AfunfEi(Z0{fA%xjefHTne&~>V?vV@3e<}$)HXCyO3GfR|ODuPKFD%2q=V@Nh#4?6Lp0u4qm1f=0~N_6^8VXUK= zL>EJVm>^hmQ2-Z#C{fayFA`&o!LS4jVlc!yr2ZmRIL(sTB}RyPvq~We)Krz=jU10HEzE37T$8#?egxw`m6BDm%dD2``XvZ zl~-LZN{8O+vdqqI#6SGwd-K=-`+txB^|ybEFMZ{Uh(`u^w^9p>C!wQ0(BHi-je2V86CI5C;UGn-}@7w5CWoR zjk=^b0oE3VG7n&?Glr#J4?pwtXW=OqUnGC}&Udx0dDgS|)_43V4j(>%uYT!kc;9>e zF1z!=`{GAG^$Gpx4WHESe(T%%%2!;EtDgK6bjQaKV?eBGSn9hMr^;HqlT6Ucaulsh zeBLrGYZZZc?-T$l)@Vxspr+BH1#>YCaRHdt0167kxd?-}Of?u}I4EI(F7r);XsYgE zI?_9VL6r2WlmNo3V;xg-6r9smmRV%f)s+f)R#;V4&TDNUh!~^PF-i${E<@;i|JlVix5?{09YMRiy+TEnw}+$cUr8fN)8-6guQzoi`}t~ z+yB@BJn+E1a>4l*xSMbOkz9H86#|8Q_Qo5ttFOE!e*fn0<-PuDF_TS~>AorJY;!bc zLB$9dmC{n;M>;^d!>SvNnVJWJn&w=Brg*y%>1nX0V~oxAr}hLPeUva4z&ENkWE9a7 zrj}DpmsK;ujbfng z8pmD3pB1DydrH1HQT`?-w$6Ia42}*r|KO(IVPbB^XFUBmZnd|JJS(u)@8eS+{RDQM zdK#B|EAojCe+2j4`5?CK+`+-hil}o|$EX&AF-Dbyd7w$9Rud_tVi@%aTRPx_0`+O~ zVHQEdc!_VnEFfWus*G~G;WlUX9l&wj1UPTff$s1 zY@FGQrN!g;;+MXJr~J&*@q-`Sq;t!woShnHr~|xah)P-Mt?>5SevHf&a_MCkxhpQc z43ACkwS$izl+Jhu?Ys?x!Dks(mR8_1FU~8h@`x5x2)L{T3N4yx?!Bn<%##h1X39F$ zB9)}l1S9J(jP)?M*;WTd=4l8LnHfoqHN@p&Df#JC)Fp9{f zaX5PHFyk|M-SkxJ8#2-k35JflziTEpMx7d`z7RsLsbR& z*oQuXU;m9?vtGX^PT;aUL+%QAFPQAKk>?p!`#l^waRMMv4*K}NepnohpAt2qHUx>y z_9G_n>J+Fg0tk&A@w(h{a`V;y%U7WP_WuU}iWA}&|Kl&a-}q0z63;yE zd?|{;>S}<`f8h)6OW*iv_|U(6z^$yTpwsPO{hIlYv`>kadmk`s%SW6 z$0>64l~-Zg*6pav68*A|FMahJc<{mdF&Orf@b3iT0q;G|I_o_5rZ@c-U;N_dv+%j7 z&oLbKarp2dJo?C@R8>F~N~wlJ4r|kx-b;{RFfmU+5S7ESAH~vwLki65w67LP&%ig>Ju|ERtDN^hS|}dNDgOq07A$?Avz$ zZ}_!eMZMO;w#{1*>Y;2N>tLxi9GPF%U7I&y7y_IVcoA)98JrieR?yP*zoaqG6jyAV z)$=!QW$hKEsEE(eYEPgFhOHZ>?S{MW7GxRTaN$MRUX0;^<45GtqKj8vbUt1)GsgQ4 z9(F%IcEYNa1-)q7RT%3|%4@EFmAvN43-QQ}U&Hc=6Y>YI`ZNA^dkR1Nr+>Atee+wC zvc&iq7jWO|5+w}%XAU0VVp)X>tX2ktS3Kp9|9ImUfB&t|>B8HIvP1|aGD%6s2Bn_p z1`QKjjEz{_m_j5Kl!)27kHa-vQWU^5y(h$>DLDa@+L-N<5U`|tE5p8a?9MzeRtlvx*<5X?eg!3pTMfzr*DPn-R)UTjSeJbf&fmv)OfQ>p1f~JX} zLxIB5B2P{Dn&u?X;1@`yph!}P42WhTP?vs?21`AzP5C#FdNwmrCNo{iw>i*B(~s## z%sGXriHOh?$Q@}}3QUO-hz1q0+5ws+0AJ$Cz{C?Ym{~M4News@(urA`vM3^)z|&I+ zs|KX0bE*`LWN;#mY6P8_8KbE|5RJ^5Bw{dvh~k9F#xdSiK_m_zgRcHSaQYe0SG`2j zG0c#fKu@|a8ZD(62&ExjgKST~Y(~hiPi7h9*rMPY-v%~s1bhy+a0HckSgQqO88RzX zV3I{apdmsNyWFLIp~ex5rX94|eUf38M$ilq>cmM({lJn>C3P?%nkk6{GEy-Ug_z{Q zS!@7E3Q12Bf@TI25h^29l+lbzAga)-sWer!Fwy~*RxT4uVhlAB4ie8R1MpMoE20hMa^) zWNlH#T`Qsdy^8eukPW-xp7s>T6;}dx{aA3-H9*mZjNrjSz$svLW4Ct1_yn-DEY+XA z6TIhM$jrEesTpX9fXl%$!e!2(H-NwYVbpWSknh@^4(nAd<~`uNq~r-9BUmw#t0&IS ziEcVYWLRSOU*3)UMK44-w}hTh2|it<`E%TnhqLzO(_UU0x=RQX0UX1aw<*|c2za)|B~LZ1_sh-h%rPG zF0Dm06)-Y-b>5r+5(Lb1gO3tRlNjS@rbN=9q%#4cL>inhR1Bu+L@((Sr79{CINmN~ z0(oSFbA{R(E1hz!*jrju_v71{ef3MKzxtbos@C;rRI05UU4$eRGc#Ql(?l~-Z@h!e zZh*e*ddkrg5^lT!g(+lMV`6$jaqcciuZAowKwXA{#F!ZthXVwcsf!t$b4Ubw5h5@! zN(hds4jKs;Q+XDhiZUXqCnFeB(TP!zre_^zx>$bXA;hc$*BNI&h=>M;ESG3N z6ooP6w5iV2xdeGo74@Fpy9loaFBH-!G#~|7N!CJ%CXNm)NGnw&!kTuMbch)3;*L<4 zehYMsavDEef2by+&Z`dWRRLby*sb!`8`qPnhF3J}d#80o}HTMsug^J}ds$&wb`~ z@B8v+-v>gs!|PSE8*u8TX@330L9gn$IdALcb_;KK>d(j(XY7)&Hozl;Qh)RFpW{tO zj`5PS&zI}ZI~_Z-3_pByuX{8`jup8)_k~ZxOaJmca^La8$l+yYr;Cl_6DZob?m2pt zN|iD1Fo-oH8oHec`krtU9GqL=WAh6*bz)Lq^~`5sd2yLvzVmib5?L!pK@*Cgssj4M z5>6eQ0ChAh4g2B7&wa+jDV7(O@TJe(h}oGL+eL^OtS=vIdVl!Fr0ph8&>P?r^A9Z{1U_J>l}!F;CDDsqTq z$XXd%S&s3Eah$gMG|bFy#-@$am>iqHh7HpQwV{kd96K_HVZA1UULRxAlYHhgpD8bR z;qy>eHSWLf0etz(U&G-e2l3cr2XOSrG1Q^P-hGea;XQkB!{p@{0cN_rG8M`CtDf{<~*C&%f{`FV<&0 z`4!JrE z>I#d!9(K=ekXn8G!CiN|XT0$Fc)>HCCBO2<-^68CUcq1b<=4yWf8iJ6*T3;~ecjLf z99DZP`o8!76aM!H{u#4V)A+St`8EFjTYpbF-Eq_*A@eMlxXc44Ha0$?RaGNX@x$Se zD{DRR-W$yvA}P&MDUw>QqZ!ncB3>j0IzYst%e=zDOIel7y{9>f%bZCSrD-z~z|tBP z)u7;-m_wemKvV6l^?)o>mIKxy(n5_G4Ng>?%Ph|_sjJ|;MpN-R zbR}qJ8U#+9h#H)FAyYUIByyK}sX}RKxJbdmu{m6O^;P)Yx4uRG=nvnH8*aP-@A%`l zl(+rq+tq?W)oY9aMc&c~S`0zdd3p4qM=`x=gZ$brzX4zQ(${gu>1Ru)@F>@Y zFp}Q+hPtWgO{5BiiHO1?DXLr<3^2a7#+eP%5`<353d1~ORaaW%1tuoOu)4a0$_zd$ z67I(bFbGmzl{H1tLUB$U1Xd)!PY5Q?)$rcK0AxN_KoF`LgVj~nZMO_cz4y+0Z0n}Y zddbC?;;-NR*Z8g9eY1YzQy-5ne9=qr{hPnnnwvYmE%(_0Q5QyiXbMR~yA-o-Dw1R! zRVpg$i73#m7hbP3me{1rC51sD2|XqaY*Uc>I?}yHn{-yv2m}gw*E|2bk+;()L~Hif zkram}6w(-5&^YQ6%REKk%?VBhjjeIDH^PM};6`6?nkGxr=#3EqN>Y`nS#rZube;C( zR1lMxnC=%N297p=zW{9TF`e-)TuprTt6#k96QBI#MPuV*@mbG&rhe;tH_7tcJWo6I zGAn*>pPg3oW$b70=913 z#ux*7YeU(*Wg|0nDFm3g=I9G6e6A)m8YS}%zEw!!b7n;*izgN^K0b~On>HrVNP&ro zsf0ODMV{wyE`#@u>KX;bIXa(UetDLMMvsz6qK;K0#m86^5z-wW*Wcs#{5&>n-i$qaALh)=M!EC$A7kr|?SK>9_oG|!lxIARy}?kN zI-EB<1qNW>u)^$Eo6~vDu2URaUD2bxzV$<;d0s%prD$ChP}MP^)S8`?4T$0i8u@y} z!#Pc@;6Ev!KY@$(|NJ=VK0m3zH?N(ZSML-`h4UE(^^hQO&6Q7<%dWW$&ws%S?Ps6; zY^_2>3>EIa<1T#k!ym^DH+&q2jvfI3Y~H*D+qP}N>RKO%4;{jw-v>ctF2k0s+wiQX zKb1Ro?v!d!;)5UiI1U{?@Wii=KFe^yndi#&uYDC>@WL11oU_kCo)ughuFA2a$FS#- zJy==kA;bVxL7wHvi&U^XtScTrdKAO{P+}^bF{dJ$WuVeD3SH)$LXc&dsCRJU%&SxJ zLJ@~pmtst-R1C>TKxH!k6qbWEM2a-Mkz&amOsa^7+T`@KkU^~RHIpi|*aV7T0w#e+ z6pm{2)ZDk>GY_X?b%-JgX}Z#k#*+wZ5wlRiiMlMyk9n05yEhQKl{Lk@P&Kt!E9EbTa~zC%T{iaO2#%! zhfTf8cUG5eetHugojtpK>ktj!(L0ZQss%aaB%x@>8&X|KmKiI4|8+j+;OK zHC+Fve`uYRf&A!0ACfnG{6lu!oSri|!M#hzAbFct&Q8fqN9O_r*wPw*{C%(grSs1@ zZF_m|(PLOzUQ3+Q=BKZt-K&WPizIeTGUBA^bHnLr(pU|M8f-SpbQz*BY3`zlk=_iP z0ZpZ+x*nWN4g!yy z^QXbZhy#~iBE`2wQwZl{lI2}n$6AP;` z!876661m<~j2XpcWK@uus524dOx4vHEqcHe1T%nbHB1SZL9`=8hqSJUjz^0fA;%%I zO$3t!6v4)0Rdpyb#=7$TwVtBC*0NBNRWy{9Mhij$(IOcG3ZY1C$ULlTz*vmZl1wxV z5|&5|s%lxw!*#m?55dF~aOD-oSG_`c>N%-aMn+hd$Yvshq+X#3;Wy{67!Awwg5D6A zoF<$pZu$;*!)GY_k4oIX2gnKppQAi>6mv7P7`hz6JJgXFIKW(n;DrKbrsm)?xV%7~ z70{xfYZv0P7U&ewDc~GjUPM(*Zz$&>PNR4gq0=CYR8MDS1`F!4jAB9P9AG92sB={+ z8HQ<|rPGF?u9dSiYe)l58q}|XMvEfG+7kpLf~cxE#V9lp18dKaS%~SmB^hI#l7O{Y zUG)Vtv8qC-N~;DHLRAW*NeF?ls>yPwF$83c&`4MvQqK$`98!rkEWm|;E`Tf&o)Mcw zFfBsAHk54BG~!x`_E;DC-LC;Pfypt8twP;8JN*e^vUJB12_Z)3Tr4YuE6!yn3hGPG z6+U{@>Y}3_6*;#k`OY2ChxY-eo(lW?XN{dPb+IPOp`g=gUR2W*#t5ocLDOts4_s_d z!kswC`lZhk`OfX|cmEji`7goBl~-f>$xi~NIv9NG8$A4#?_p(j8y>4G86q<4j7#1r zlJ`!XWj4ir)?rs8CBE*t$SR>Rm z#7w{lp|Xq>xA~S#J0t2Kt+hVdg_GTYs<6 ze}P%6kdS#TC?IOUWexrd0E~FhUJjea3Gb>Y?v2vj0P8znrfM2pTX)tDO@HIu-a2ymZ`$QyUf(5ON@9K*;(i$ z0XoeA77angJcQ2q=0uguv!V_mgtUBx01DvP;H)CViGd-FKgv3l18Xy|5`r0`v`nlZ zFgAZoGXZ)_i@f~$S77SrUn48O{|D%=EL(5uc8$Xtt@#zp<3QWpF=8-4XKh8?L_6}m z?{W3v1-3VCgk64_=+^CxRSk)w7=t3#K)Xfumw@kl74g}xgx~)l?2rG8gl~TX!}HIz z@iWeha`_dm-v5}!$Bvpke4qA~mt*Z)Zob=L&k{hb_Fkj+l%hc9vdGMdwc2n+3ogr{ zdB)5q)C-(ORTsc$1cqLm_5qXx zE0{zk6`^X>ssJ!V5ejH#64X&ihDgAt345fb)9ff_MwNBM%P37_lyxDTu;dVJ9DQu? zFxt2WVI#|}HR#s{PGyoz5oU-&)K0|&BwaH*N-$dQ9X8EQ0h2BK&3pg#nIF0H&aaUX z4wN>)4S8k*!p}$A*?F#$s+gVJfNW-?-Lm%qT^#n%%?m6TFy$PlW0a*(p~!QdJ3Ebu zRu{`FD=gPm^~ZyuUA%F#PEBpVp=uC&C+6h&XYNKvbKr~}Iy=1q-}})IvFE@699&+3 zhhQxRbg~>9ED)`>EULqNZw0^dq$k;i?xei$rte5SEcq{Qe4`v*oWob{y`MKd@PPEo z(oWy7N$NUCX))GXx%rhLy!W{5;>+-7zxnI9=;3{^RVs79x% zF+!k<%saN)Eg@Vo{{#aW;qqKsc^30l8$xpem+I|IAl}jC`N+Vk7NSv1RGmnK)gW9l zv`3Pz)oRhXM#&c<)@G5C3Z|$c5Q!R*C!7@OI?zb5XfTU57?e_016b1k8Dm6Ql``lL zv9`8mA(R>k6bh)zF)=yLZQHlWsk=|XhRF?F9rPu49`bcMp3>l%8Qk=At|F4STl`nk-e)$c*h^IgQxrk=?$Ok`+-~WR@ z;PK-}B+@WFIg8bmWkdwr@bS;#B`}VySZa0Fgr6H zTCI+Qdh`Y>l8Z-{=LUhq+612FMMcC*1g*$C+O3wE=#Rb+i~#bXXXLVzo&O0ns8ujMDE9VqKPQxwp(%2XRhu^w=DZ9XW!D$#HZ$ z9S#Q-T;{E+N*64WF`7kF2v7%ORaMceWMxRm7prTAx)yaFgFzq5%d70I_2mA0@5R%e z{&c+M58sM~MW5G{AX<7%ar7&Lt1FMI!f^L80mtn>TEZTeol5 zcB?S;PVzk0^UpmGYl8tk@UI`>gAd#<-R?MwqCgA*fdP(4x=Ew`Ap+tYMNL8kyaz3+ zxIAO73g-l>PJC8iYHAw0Pv3o^qk9YXqV z`~BaWJ#E*n;n9V;EOS|%`y2rwnU2Jzgp;rd5lUlBi_KW+8wHNuxHOFWR_|wTbL25CL_KU;qbk233b{XABX{ zfB$#hym(^ncf%3n3C)P>n6I)GtV+@(B1B{Jtt zRbZevij|?37=xy%3Yce^L^E25a`eP;4hMY(f@7N#q zCDQ`E)g=x?Nf@!?lwJCiCqD&6kpm!(9Xf(H{->ZQFOZS z3al-!VDsjUSSxFY0+*b3F~+I^9(?Q&hm3Oi=2+qVFz8p_|(eur#s(Q~5qE*9z`-gw{M||<~U*vag`c8_$12Qu;g~_Q6AS31$<}v84 z!Uz(hC5o)Y6e|QZEg~jRahk9e zp{_N{TWA*^qCTki-fN2USO_Sq3gQ(oQs9J+^eUp3+%Rjyev&`MD0B@~p&9V0Aahwd z$OwcnTC@m?SJEWuo+crXupnj$-{w+9HADm<1d8|K1W*+d=M%L{R7Aj5J7eJsp^yk> zb&Sr5qKY-hueb`UODov0X~wEL>e-zxwr$)5-|phf*$K?gFY@b;AHZ^d z4cljD?W|4PTxOB|`2{Sal5&C3GGbX3xyN3_5uUs$jXsd>C&7@ydu?Obj-26ZP z)|=1!ch_Ed{N8)^$kNhr)Ky@#s0paTlYJfl@@8_Ka3-=&c}XUXMs1gMvA0Ptqyeyu zP%5L6?SvFdTs4kl%#%!Yv6D%!b!>_oeNHMIZMucTX+sXfsE4~LHkA=RrYS3JEWs)x z8-6ovZkTRAanf$uMwOz`%v6&kFC>#7dr~G(J8V-BhV|-Gz$HVnB$$FU{>bKY8aCZ} z$BV(4I)KrXqEx1zyCjud8c9*7!_z7#Vq{RYOvPuT>Qd4% z&Dxnl1E5pDHNSE-qX>~fB~QTu%T1L|%u&?AkO9m^H3yNwLJP#00Ovp$zd$=swqfWB zq(jIUEp!3vTGWj`(+Q(>t*Y}ngegZ%#29pKWkGxubJjz~%3x)wL;#J9bq#@uj|L^J zuqfjYnP?I!F4pj|hKbOrgU`KWV_l%_fJ-h0!~<7eO}_LM(p0~vU-kO^s!0W;aYcGF zMi_=`ierZjYXjwuos^Cjlr`|`*8z_{Zg|UYX#DDT5pTH*)nFM*Gg~lJL8TeiV!+Tl znD;3RqoNc-@(eD^saY<*l|x%y_$)IxFSSszqD44w;uNmPoum#40*yH0H9BaBmU>0g zTe>+>nwco5E^7?E3>MW+8kUS^DfV8L2z8*;17%Hk3&<&mu>vfhtvNy+;l&^{ zI3v4el99+nu}K1_4AMGf2g*kuhg&>>u~)v9c>U`Hv$Mp77mZHT&BLq-b0j0+BY@s= zI*8X5;$;_5H*J%8=LXdG?*%8P;kzxkg%!xAjll8>q}_pg`n3oze+B$SS0wg&tCJol zn20$^6ERDhV>BQRNG-%}`!?iz-(da5x3akA=~_Kv z9GjU$c<^Bs{Z%Vfz5d5HSo=4AQ(`Ld#innqC~LR@OzpwL93reanJ zKlmKy?~Ksq!gJ$Q4|7;79u5*l8V5LLKq?wo-0BW zF_NO0K!`{&vRBp`$>uvVs2Eys%xM;*>C}OJ*m=RZ(r!<|9h-~eQ!R&$8-cAGt@pj} z=~Ag^$C6!maj^oz5dOjonf>gukU#f1z^*eO(FC~~CuSirq`5p(VZF6-VrdcbnUBGq z@l2vSMtRlioZkLp*zU6tUi%WuZn*{VrklmIMVsBAgW-_<7`djoE_OSN1S)kx=g6Xf z%X7HQ)0`vQU2%DfE-&aZXD)9?=Y3Qs!FwO8x-ud9&igeIeNpt3+9S9iA}azTO;%O0 z49J2AmO-qUuqTGn9E8R-fE80+Ml@;wtxlj#F(c|`lQDxt5o$DvBGDWq6@WBT_O$CL zq7h!1y2T7&gG1uTgSU=yYr<3`mO9gr9VRqKNHmNr27E#hyCruC$}DRN=VGIOMIb6p z+p!Iy<=emX7k~BkTMq2~eE`_eX~74>f*}k;Eebk1v1hk(*|K2^zqHnu!}BL(gd^)H zBsg!O4mu6B3pdPg_qJ`$#fZE;#_5?U{GYFXRetBX>$$XLt6lq&SL=8duyedCQaCKl zFW~MQKaEu?_UwNgv8?T$2kzDF8#m+8wG})#cO2V8;NwdxSOg+ewG`8>t#O>UbqfZe z#KhzT?muvpW8IEC^Rg@Ay?Y+fM~@znJS(hlq7NQA2m{a(kH~=Cn>XUNJ^Sg$+VaWw zz843N9ktQYGxB~?uih64$8z*@i0)!r(4D=S!DT$Nxo#=0GxbIv)Oo|=}KEgNzA zX=m6er|!a7yU<>*kK;#=VrFI*RaImAuAMAe1&ju@BoQnw9K(D5_U~}#kMF@(zVTHK zhJz^TTw+_BWKMC(1()FL^DhL$kp2FEH{JYwU0hlO6$n+pMQ5Lfr#3fTkrZY zzWC*@B8I?Sr=2d(e%dqe&mVk$LJ0$P60ao1r4tAXkw0OS`w9H&|2>7iexLv8`~B$C zQ`O))++zK6M+K;Yh5!*QS#Pqeg;uM8b3nUjBN(x~vWU8>;nlH>p*gEKAngP=_l$G! z5AXeZT>0cDqn&5Aw6KU@`L$ouPkr)Zh>@7+cFN+UaL#=3tCM&Am(NT8Ie-A!24uQaYC+B9Q&iZnVOnF9U|(ogqcaJox=!tbq0zWA|sKCyn?_Lj;g7? zeQIh7J5SlEW8HCSw_A}$*?Gzi-L`cbzWL4X-~%82*ErRgba^L(3J~fDv((=wW=z5? zolE|An2~9zh!meAb2*bRW61LilM~a}zI`Wl?>-e5TzCOHtpcs_E>7Kfid=r#6?pKW z2XX#6=chp(9Ik!RwZHtPH~q%@_U+pT?+Z9hy&cU>8LkQKC4M%WTW*6SYpzICff^gK zB2Er=Wwd3DFs_X`&Yd)haa1DOl$!zuKjOfSqTgu#qEXyi8bm>J8E*uH6jzf*Drf}I z#tGQC#@9AXqgd^&X_kBG_j_1eSYmB7P<>NV z4g^)Q0waYqrGVc126`+A)_e&B6_jYSXq2(;xSW3asfZDbtToRIRKuYyEiUQNW5=RG zop+99*|*gF7U?LYkPvaoRNB?PH@;h?H9nYH=d?|+ZwAHT!>@ArQIH+=eIxc#9z z!Z*M94M5ZP;=N<2Yhf#bf$Cg@IfuFoq=)83W=>V0W)e(m1cXp>Vsb)?cFP8XQXhNl z05@&fpc4~Qh%{zCYxFA_Q8$uLu!;E5IZ9&s84`a=XeNyq79vcdiH1mo7}9voi77S3 zAY5d_0E*5lL<M*G3nzM+5j zkMG6a#~#ICP>QHvSXXT29&>X`%yKWw3yb)|7jDEaz2QHhj&3uJ9Dw7o|c zv>z)uZPP|59F8t8NhOe0t0Od0X{hRmsvaii(@!E+2-OmRVtsQwSt7c=@zNn( zh22kYz|BAF6JC2=#BM~hCb((ozLNVGs?-zv&ma0QN)tSM_y|7tnH%w{SHFt4-+sG1 z@W>$K~*mLnKX96Ci$DK!uaRdw=Q&#B8G)o@2Qv$G6z?7 za309BB0(6SlIM=CqAhFE7e=FaW#%*Z%uAjXVwtmCGneHVymNr0t~Q36;werYvQ~@j z@d@z?c$Yy`)AOz-3Z+3LmIH|MC&fy2rV#N?Q|YkN7$RsU5fL;si0QCD1T6}n z3`Q{oSRD~!03&Uz+Yut!?;4_lNVA}N@1)c1nuQ=`RY@I!hPtMTic`-m+qcQZS6qeV zxf9sBc{3`bK6B@3W>uwU?%0V#^9y|B&@s8|*fCigta01Kl$^PJyEtE<-&?_%XPk=t zM~>k5f&FkZQ<(57JDu>!mt2bTp7BhnPCtt-)VTR;U&D`ncsowr@F?7_ojCV}FXWDE zuBC6~`X8S8B&;1hg!wz~(a`SLZF?S;^Uv6gi!Qr3+;!{SesfXdx9+?b?GRlK#1&EQ zy6Tzo?T`KwJFzEzeyE2I9zoo(O*?nr9)I}FFN>er#^?TrUy9Fq{xjvSg}FFDsYRCO zyQa3=(G&Y--|*l6;?XzU`--c7>*X)HZ*6S_E5k);yUZ9uDz~;qXVAn+qo##hM}^r9 zw`8=(utA%RYO+TfvNp~PB5~Oh7@E)^pi5<>GBOF8He&k833gJhrP)Ih@~W9PQ&QL0 zy35?jX!o^7@MlvUJW6M|^tEZCIV4IFk%Et-v=~Q+aPux*d`CqII(p4Uh*1@!xY?-A zqVf0#rom47W++W$+nppq0f_X@H7Rn&gjLl>_(yX2CD?%(gm6@)BzT)pj7)tm>3k3& zbWnptCzAdg>X>Vi;Av3jW!-J#(o$%mDmf!6fLS2Vo2?F?x zCK?2^fLJJ<07c6g`q9P2qJmU3EUzm1j_mh=9Xr5#?-qU0b%4tohL4US80+Ylkpr;l z9Z_W7SPqoVsEcy~Ov0vTsBild!GC>+;=`Y%>(yehZc+^jm%{2G9K0DzOZ}l@iP|8+ z5EB?hqJfA}f={=x=yD(={7)vyI4;5j*HKztj0r7@8B^1_^F~lCO>M+EZF=U_07x)X z)U}FJlgxvNLQ-L=^Ayey&C*|Bjl(!b()j>FEv7RB)F^Zo1+b8q>S-2122xNP5lj>1 z%OuujWE2LPRi(xlXfzc|t`$b3Q3O%h)|SlXj*E4W0KysIEsCl`L7+f{MiU{yb`IGz zjjFc*?%pCYcZ4|WtkFbFej;d=iZz;(e~j4su;biu$ow4K#3teVT!IkB#Ja`&B19eH zo_&ysapqTCB>d7hD4I*W=u)^=)*J!63N$1ai)zzNY~rBM7G!CWZqqK{O@EAd&biv( z_c&wTmN<79K5t`KR*-JNj(Cx(5;Pdb7%QMma(#3eR1Bf6)7r_PxvOb3p%NMs|GU>) z3-!_C&R3=Q5aq~^@37^%!d3tI*Ns`hg}n!3Y_%2Q#Cw$*G+0bxy(rUbIcLV`K$kjP znHqOgp+2KX!>kNZDHPSjR&q*B{oy&NF^%XfwK0jR!8GZ-qJ)cdQB_q;Vgie&x0Y#4 z8w@Baj1Z$qV6-%CZy-_dhzZvbh8Fxo^Q&Qex$maiIXE%J1FMU&aO{M{EaS0*M-UfR zr0d$|FFwP$#YNWt{LeD@{1@S}7Vw_Gg*$F#T7(k^DkX%Nx<7^k(tE8`5JLc>CiWH#-YZ>9NOMeLO!WIS^=?WzOse&cHfeN+XpOHfS%&=J(!wZ`mL0&J=h`cMKPePvZlJ z4`ApZxxfX&?z-S2t)^$t8XK2WzW<|m@$^Rb(2iZWd-14jJoOZAIk;bMT^(}!>`v`$ zowZGqV>Y{Gr^?I}d^_WZUi*vq#Q%A(eC*RV=sVx@w+!CfFJ5|$|Goe9-z<}YzM{*^ zKF%5+=gy0E>-8^tF($Wc#fGih(0gnjHa+8K`JE5^z5b8C`+NV*eFvhbux|mkK7I(V zd(Ja(#U+=?k)=iX?hkIpwyoRT=E*MoEj8}g|G3VMw{6GFtV&&BsW-$j6b~Ld!7Z~> za_q!0yz-ZR3HSc!HhpyOBXF$(xi17X(>!zDJ5Yq>V1Oz_QD|U{E+WE0M6G7(ARDGP zP`#*#LNhN;KjKYcoj3JqMA;8PP|I<=gv9$%$rlE>cz~M#CcUn zA`KAmO+R_CvZ4;lzE;Bl2W5rfphQ^?P}L>ss*F_~B+oO1KnZnVT~<=XAcM6vtgftL zad{Dk4;_^U9(JrQaqAuOiBI3a&))D^>^rnCRw1}s?z~NIx$`!2&da6^Gji&# zQ+ehYXUoF!JQ)I(*81|EzyDjj`W3IjV6}%r9NRM!@;krvCcgI7ujcKy->T z%g6v!p#%qlqT|tugm;SRu_?~4Eg@7U>kl&{9Rv}?1A88{XFT&+de`l@VB2ZCwA-HG zM?d^we(L&{%Nt(*i?-VD^OB1$bLt&_?=5e^AHMZ1ce}I|k88Aj#Bo`Lv zWoCLtw`|*i7;3DotO_aYR|B>)2bXzh=29Js#Yi=0>XA7~G(H%_oaCT*=g3Hyb5Ma( zG~7ryRY8O%;3EWN9O0}?OuUHI(X0}vveRvGIIIAG%d0(Em|Miu!~~}|&LUQU!?F)c zwH#sa<}RUd0iaI}homcq0~_`SEQ(w@Xu;)PdV?X#81d}qJ_k46_$k*L ztYEe^i`uMle@0PJuxXi7amneFd_DqkFgnT1K|J7^T_A)gW!1Okr3LM+&04R&rjy-q z#wysc!$)L(_kx^r_BnFhbuY6|fBsW~803~)e)z7z+Uq~iZFMV3gatwyQQe747}E8Y zz$A{xk$%jCtpn2id1U@hj`bwEM``v(XrdI1svH}bS~}g0G9OKw*MI% zpHVAn^Tcr^F6ao{f~Jf#x!h7@ySapqv_3~@1AG@MC;`gk3Sq;2O`B*E7819%LBNop zHj(?0*x{rR4J3(KdeSKm2%J|;P0!-vpZNHPZv6D8Uwg{Vo$;{)2VIN-S3UV!eE-|u z#jvh;=&=K`vb=x?9^S+Kk3Pyg_xio>-;CAeC58~Nyu1{vDtKCCG&0mR%DUEQ(HO}m z2KNm$Vo++cXwf42^?(;&aH+iL#V@o-qN++AYj7@inUc`mEt{V zGUh-)GNo@8C`|;&(XSRF3Zo&DRC3TQ#^H+$RaxSphaR>KGc!1NcXz@v}vm3RHcyX9AZ`9I;UZ+#0kZr*}7{>E=2@3ip!Z+)9Ty8XxW&TEK9 zvl`vbxD-VOfhW`$qG5cjtC`CZ@~{rhsiS5}XQ~l_o$iF>xkGDD2(?8kU-trc= zw6=y!6;(9E7%?&4#AKgBrv$=&j&g!U&0;y*EEUawcMpL~sf z^WicNtHWp+Xu{=5MC!Juuz7Y;4jwszGE_hDI^A}g{i*~b#HnJ}sk<;UHHksL!oh=& zC3aut0VrmtW-v87gGU~D5Op2azpo7&x5&T$xmV#&-ti8&Rts5{!BJ6%fGX6;oZ7E}=u&}rQsRMnhEo0+jm>3(!_~azo?KZM3M^QMmS{2Ut5qNL%<>5ZVzarwFDp|%Q-96W&i zb0=_UZ4KLJW_a$-Q)RrBbN=WF*)}zX*Ia%DKmW*s=#~*rnjFIgyH1gw_n6wb3lkSy zg6^f4v3KIA_?Ab6VC9j0*niJG$h}8vW(xiBaX#t7Go)N8F}7hU&K=x~rMn+;3pd?@ z$L_udM;7Mk|HFTjpL^TyA?uFAV90_Y)-@DB)mx6^j~#T&`ww7sEW^x2m!ma1gFRpR zGEP5j3uJ1eec`X)&0qfee`YU+*aI92udT{Bq{(Hw&i(bjd;M$wb#ZCA-w!3KXmDhr ziYHAMxoR^EX}sAZ)Jt>RTz8pE;&LW3jKVc5va@ud(*y@krCCYvZ5-$8w&5n|mG;OH z*)YNP)7wW>AhFRxg-Q`qYYc~JS8k5P2{mI4rX_V3rpfyH6FlO>37WnVDwrI&(hLL4 z9GpaD(laC}+3Q`_7ZbDDny2q z(D6uAKNFypShC1K$qbSy&51}(V$zFrC@c`sCOAQ|V`gJ2Qq+M{UTr)^PR3AAvW{aE z8?RQ@TsiEaRpj3K1Bt_dur@@Cj26I90|slypaqFBQe0iLMU!z=WSs&+<8U~XCh3AK zbC9tPuzf3V?Ny8mJ#oMCYrw{hK#1w^vtHPWlbD=Qn8_drHSP9WshhS45QL|l4jHVa zJH_%U@YnB#efo>22PI6&m5B`)h{~Gx7(g&|!XPRp4Rn&K%oOk$eNhluOI(qO_>AI2 zqR*pdUR>ryi*C#^?OTT}db_sjLF3 zDuzMj>bf)=)>_AktfSPi21A4|OE6Y&k<0=mz|awgt`GyOVHVM%pr|7=g-nQIqAD>) zLq3+Xm|vAFFQ8|f1^(F|K`y@>n3!sg0@iFSqiGt~*Cz~W!`E-r@Pk|6kL)KNcof54 zDZ}0}BmmOsz$4HPRz;XmuDVkEMd!e7{5<%)=fVBPZvZ=YG*=t2SrZ!*kCVh(Y)%FJ z9&qG1tiOorY0pM>_C=@=FkJ01i?z%z_gThD0EY#a<3yIDXLa*3M627SsRJbw5rNM$ zXr3V}azsXRc_9=P=Y4DyEhl-7Y<$9Gysf=Q9ye4K&b{tuW$ybw7040&}q7n z6&dN$6%d9X3NNYNHm!52H5nWYRB`m)YlEewP>9T>$U2#pR80+;N@27hG5xq14I+)1 zg93?xj8;)&t)UDF_lRIsh$5k8S=Jgu$yObu8V(rCN~|{2afnz)XiRZqOVc2eU}%w& zCsU_%tALyp2E&r$22QDR1I0~Dbdb%?fX9y7kU_FT$3!=8Kz8Syh%-}g6@bMP#P|eJ zv_P+EXCPJBh$*5#tZ0wiC*hT^2OoHV{*uc@mKT8WE_l|d=s&m*C`-17eF zbVP-$>S%)yT&T;$7J*VifQV8pG$MR*4yHtwv$C$8f@m384NE~ZOm{Q5U^Y_}x@qnh zW}fr(IR20Cchx`r6YOu^h1mBvGVEc?SQ{(L%gnZHMdyO^kR5y+a%fIgjvq&tRq$u; z^7^kIhdc8OVscVwOyzaSehR3@Ds!rzyMgYJheg^s%D2B$Vy}j~>@r$iA)Yu&H#V-J z+h)BsU|Ck$s|8C6thvmpwxdYykYx~`5ncsF4rmT7ocW0<=B+leJZIK!)A@{`*6@f5 zH?UX*f%G9#8f`%!eSkecR+Z8dWkqrTVi}4Bq4Y&%m62-@4pIirDgb>0t46vWHc8mX zBuW_tQNaj`m`bo1OvKR%z$V*IGS!tP2D&Q6Osyfdr85wlVZX6)tdDxh1?#TAwCb4v zo`#U%bfcS2lVM|1@?Pc1ObME1K9ez@N87S_`e*+0Z$2D}*>((aMXSK=Wre;FSI=(4 zvs*d1dmDDjls)H{U#F+M=m`#$NoKXImI+`MlLZduEC|&OA%d z9m98S`ab3!+mEYH-;Ku}*n_h#xCFbexhxKkpOBCJ&41Ike&zU=k6c0;nxUV*bQDV~i?ognBA}ir=GHl zKF<(SB1!JP<2L^G8{e!q{qW{d^DY7CSi6gMw*?1}6AN>QX7J6Cx|QW9Iyufg`#j!$ z=WUppndO1U4ybyKU-`;c_^Rt)t*iZ29a%%yg>Vsgq@PzE!vCM7{{Oh=|3AI#KW)1E ze}0H6##>!<$HvfYx3PW06c*Q3@W{Rc7?f259-)W;d3OwDuV>z=-goESnBKgR4?eU< zp7NAyv9!3rbIv*+$LEgXytB`eg}DV3oiRLiV1F#~%>B2&csE}BqL*Of_O1N#m%fO* zZ@+_QoqaCyw(9b7pW_qbVpYvL^)raeGC06gRa70sspLM7S)RF6+$wChI^4K>5 z!Q8drJY}7g=wOmC=_x!b;t-=TO@1VrA=Z_JXc`$U)~1U~%RF}YkW`_9DCm3!t7?>0 zjcPcQnh{0TvKS1(BFJblRNm+!tagL4CM>3Qf*4W9h)g_|dMkMFo(FLH*=OJ-FS`yG zoOd4n_$_b6*u(^iqGfM?$Diox>M{VJ$XhJyp@;~Sv=fXLP+n?x~_#JGw;*INmFmIHnwSNqC_;nIS=Oqk&#X_*|}o}W;V=na$-tat(-n{ zGCetiYo2l~{`#-}7eD{m8)SBR1DqF>bxhqz1kFJ-xvT+o;?x7I*X1iGfch+Ymx+jq zNt7Zh;_QZ5cj~TPIPd)Pv2FV{Y?|H3-k>jAHf_XHp8CwV)?4Pxh8drP@(i#4`PX0a z?_Th{yAB=PkJ^QaMz=yedFEDF_`4C;u?wRqOqXUSN%D<|gWt!TACA`XTFnV&x)A=HQ#SeJFe)(gcV zL?qR&2^DcP^GNMo;$re<2$C@^IzpYtpd2tmkWI6jIC15K+;Qh!xaho#!kzcsql>FO zPESm*3N_k!%awJ-#}6G;Ck}u32Y-OmcAkpg``tI=ZEt@E{_$`B4%fZ%Ww`3fE9KVP z@1%&ZRTPM|N~j~8g6biTf^Oc5MbUzV#*b(Q6J_Qc#DP`cP%SNDyxT@+Y>agsr5vo; z^0HI!RmHnR>r*wCJ8^K$gpg{XF)52VidhT>1V~gwm^q3G1&9_{RztBENflEOjic&7 zq4~mzhlsjXaL&6>N5oKLur`pQRq#pIUMr`bda6P-IDy~)=pH`#Nl%v5m7c6sLkc0C z@d@Nr#qL-~9(-^wX_Vc&&q9aB*-f(oDq4At-r4~FA7lR=w%Jvd{p06(t+n^Q+tZ)v zJ(J!ONwUEDxC% znN3d4AeKYSFV1nP->+NNf6h7n$i=bli9bgGZwz~GTWJqdv~ zwZNDJ?uVz?BIvZntlL{gK*iU*;+6Qy*ZvcY_9XAR=XUhUApo;(zmL4gxqaIfOpH&U z-|J)l-n}@vykemok^qLo5}nobmQ@|Qo4bsILIQRIlKsHzIx z?g|FoAr9`_g98T+;>MrcEOSRsVt#2+4j(#<#g%2|S%&fP3CzyUVrp`NS&^Y=6jo#n z=8XbHmZQjW2;UJ2}crz`Gg!Km{gkaXl?TqbbSZ`&CZ#w6(=&0iS zRcqjeB{r>DgI2qRTOT@tJ5L@*x7W9AYu57dXP(9JW?Oe3-Y%w;x0-Hj{-wWprc z07z!6{dZ|rkuhZ+>wSae9$MBT{)DdwoubCV7;+I*$u1|t6c{Q5ku`g~AtF>$L8OrC zY9k!$GoN^84)7UJIZ?z?wa#BgfXomBL?@~ipHvE0$x(I$V^5T5l!p1WN2!G zMXSGNh*5+B$)GT2YAWL3MbrDF2+SxV#)#;=%T%M*c}IALsOCjt%8f%Dl^#*MO7Fdb zj)|bGtlug{s<9BIi6wSC1d$p6GgUPck)VKgP*oL0jFtGxfqry>Igo+S^p0tSNKi2t z5TZa08jXks2355vF^0s2RM5jC8DnQ}`Zm6bnu3v(=NgULPnj!J4(8Dau_3Q?_K=M%d5h5KIutfHsv{0ohoS zuGcj@xEEEo&uqs7s^9;X@Fg!Ln^Tr{_3Dzz7-|3DYTzXV)*1shdEm3(f^1j?=gky3 zB?c}YK8h%g5Mtnnh65(NAXLPFgtLfPm5e@1!^F&?R7D;uE7jAPF@zG9+oEh!AK9qf%u8^mN{!$UvHDT7eA;Cpit7x)f2Vp9~Vc zP~gZ4W*U?NOZB?+>R?i705l5VEir7B3R6-Xg;5v;bciq$0n`oEqDY=4@z1+pW)2!s zEs!}e8qF~iF=rwXRdQS#0>ya;#MF$N0&K<^r=^% zxb;R5xUE(gxJ2>IWC0K=EOoWrt<;^GTo z_uL6TGmGYh4GeF;o7NnMIL}VEGK(Hqniq_XW5dca=jZ2vbsMcr&eZ6QE`*3GDjXH& zCEDjP-!f5fM?LPU&FC z)GSoPsO6AnPfyCW)vI)QY0+gx203sD2R`=&Zd$Vz`5*nc=HL64EPeM!w&*-_5@Vf7 zHm1hG+iwp%KF7*Cms<&(cecZy{jtf#7ZRCgjo_>ALk0R>n9rH3FdRDu`{uQVs$|s| zhpeB`DwLuN3n*r1Eev~F9X^h(nv~|ybGgiA6Y6;h`lo9IAPn97P%p0$R+CY3K)>^y|7u5qzobVw}hQJ-{OVQ!8Jh{~zVG$Mtr(&LILPVJED5_#%qQ5Qdq`i{Z0Ei%GH;UW;k>O+koMNLw= z$86+Q2ZE$M4LQQcMu?L1)X8=e%Nm+j{r21Tgb>CXaMc=->^dvMOsnm_@ak7{>$=rA z5s0lXeKlq`trclBFkh9FefL{-@F;%vub<;h|Mj0Z8^O9$Yuw?D8|}@X{)FYTYkBSq zUT9~&G~;qrn(f|a58Qrxw)eCDWLutcCDvYizQJYg#lQS|d&x^*K~_B;fAD@ke{vrE z7_d}DE-frufBzxodmh4h!+_;I`?2E(-?7=fyRiT3pO>kr)p+^SufS`5^{sYd;W*EJ z&FkEMeEk~x!FAX3IhQ<|r_ZiJTwca_v!SoP>MHrpPi}SH<$27VIF1&9r#hIXq7aSkB4 zw76)bP@F(WOSmkT=9wZ8?@W->d7_c!P-e_Xqa#ToR3R$OxwLm?O;=a*6e2Oi%?w@~ zYH;BwQK?a*G@A`I%ftX{sj;dm#2BMS3L49lTbWhJdv zVdJe1rY0vx9A=}E_uPM<-hAUta_GPz+I!8=`C59Gly3xV%(gGWK6Gx65<?f;+tGgYkgRxA-! zfCu+3;dxJa63$$`!M^&V8(76?&N)IO%9S1(S%E=S;_M60x4-%859zC4{c8U7CqLn~ zt*3L}p?!Gc>tBa|{oLn}7X{8+w*eQP{~Y)I>wbve_}{-}pZ@G;_?dtHCw;*SUc?QX zHt`4F`i_l_joZx3EXUd%bZrS#ufxGWwCcn1jLzjLaTZ|aC{Zf|9Ag!rMWjfETyl!9 ztw1hCdTYuZX^~1Q6hXT&o^q`M~T8N@_sccbV2{S{^%$8S{IDcZ^F23|)KKe0_!G-6ZkI(;~&!ICu zi7e0YgX@2IN=%0UAq+t zb(we!05b!PDUK9bcU&M9P=N*$h8WQ84lp)ep{#~h6b?XU^Gi$YE-vGVPq>WV{^mEZ zys~7oYt~R>j}fK`wVCias!T3)QA87xsxF<9O<^!o5iik#NmUIcM#a+7GFFzm*6sFe zI1!}XXxNSi9>BUyo8+`DTkU_n_09HoAOECjRmnA9|KeAk{hX_|iEA*k(zIR*PcdBT zu8p*GrSrPE1RJGD+JafEjccQhvbrNcSewgJ*M~wtQD{VM=uY}4L8vHH9r*q~|MS{W zj+6}xRdR=q01-8Pi7vU}G)1ZFBC|UA@rdX=Q#DwP@`%aR9+CWEYIPAwa;K-u*An~M zC3Qk$jdQ6#XZp4{a-V>3kecfbR}1YXShZ>v|MiV;zU;G~`^+aNCa0T=b8}LLN^iLS zC+;zix!6t|KVkRoxCbuFu)MHfxBm2JvfNwY{X6f+^5POgj96Y;z_2P+L)1#6#1az1 zP^&UXO&U@{69w0ZD%53?i8>Mc-GN)Xezm>f4X;O*XYBQcI^G#)Z`kM2!$0du%Vzg$nX^6(GD402C-9eAJIOYwHFMZ)Fc+};WK0~Y3)Mle8 zWhh}v8yjz7W_A{y9uWb}q643KG_stMxrk^IG+F{BXzHm}qs3sAK^)Z@#h5HDEn#tG z!K_lHbFLf?tqPTS?^xtb%X5b^1mr#k30YiPu%)FHC5+E_#xtbRY}N^>X#e>4|G>BX z_WxtUpvXLR+ve?}5e%V+*)?nJdq232-~8&=@T%9n7MGuQZpd@*?tI{W_InjJZCHl` zM~`Dr_O01!GxM4HSm`jT8yg>Ev(Z4aD0J_E{ajk^Qem-Pr~YpRqE;(s@;^R4YA6xZ zymTglwvBG)2%2sMMb-74^e z$34-$@TD(eyfYD_1%a6bm|I@%;z!qAhdb`P6T2RG5O>{k4~`!_Zq0T>r^YAP>a=8L zY6|01(>6IV!6MHsD;mt5pwe{qZ{!WMT21v?Aw`~9v(Z4_$N-2IMaH60u+tjTPNyS{ zR?G6DV3D~<&@&@)$w4}kOeo@`cL{bh(oI?G8zW>zI-Y|e)~sx?s0OM1y)l@%G?X+W z)1o3~scjfBLg{F#AsxrlAS&5cox))eR(jT%nZl-X&tYt~^!^Y<=E-BV+ic^<8&H~|Y z`ua8Yx4--=xZ~s;icrNBm^&ThRA&t5b;iK%a{O?2Ng6Ep6 z?K6*wn_e%Uh!A+GrSDNF^V9^Lo{%8**NL#v{trG)+Mr;Xf=f;G ziFi|&u%ux?jgPO@snH`t6H3&W=5lnT#RPt%2N0Rqr%dgiBd(26lL{YG4V_vtuGf40 zIwoh9zPPuP`=hwDi4!A7cso$s!>4`c(!VvP6G9@$i?Wdb4kS`LsnpbWpNjudq7n&7 znbFjlNhUz1w8F?hV+JxK;9-_)@+&k9Xamv^L(_kO|=EnHVxxd3=^9+Fm@wC_*g;3&`kQ zy@}8AMrd~0x-vfxGxg$Jh#?X%s&{!kO)=A`W^}5iuwZI*rYa#Alo6t;pkvxfR0uIj zLma6IkQP;AELF6MT2(^}p%e~=tcF8|DnP4&hGE561*@t+#EKXOm_=l4~u@m>w%MYq!W4>E8aofMEb$@^VXYOAq8lQjk&(s$TUi9iEj$ zzpE(wrvLZ}$1i;uT(=SBgZChoKyPjl0knRziLqwRmIiakSV57Ub(-<`aq5l-EdS-# zfbVz*FuR#Ggjmy=Ogxo|qdppO#nhdkzy0ePA3PvV0|xg!fY@l6EiEx*O$-JDbVF&u z=NuLd91JCTGIAPbFb7kiK{A2&>avWk*-Th87+fYQE>G~Lyg-&^=G#q)WlX&bG*HA` zqanhYaw|g3GXqKQC5m&xgk6D%2t@(s)rmJp10_S6kGn{im<20UK#hcRCaJKN8lo9u znqsM;v=jqRv1O1!p-!Wg0SJL1s;EZO7>ueCLey9VRKp=;IFM>EKrDv{F_;Sms{$;s zpLAFSnnrkyngLeOoCKrOs2xkiV16| zu|fo+QHRo7)X1vlW;6L?RH$ThRH!*k^D~gq6!4}lSD@?}-^ai$Y zY);By$r&4B^=X@e9GmyOK>)^DaO30VnjLE`E=btF$IOd1JtV&U_h5hU`vk;9awe`* zUF`u)ZDU6c5$!R68mr&_J@PC6M|kGBS`8z0ex5OJq(Bg3sQQ(wLf}Beh9DOySQ0_- zg=L+>C|;r$&=P6KD{+Y@hEUXmL$+6ynZKpy}6=V9vUSH`s$Uo2?k z7LG5-@tybCj{EM?>9w2S#>Sna(`LJ2LyNBL4&ciYyMJ~YP8>XlxV#KM7~t}&uEhA3 zEjYIOAv<{Yop48wnl=l#RcqzUty|)TEgL1wE$}5D{seBk`&OH1w%E@LJ1ukEx_UjH z{nRI8ZvTF~_lMucruGEZb=p`vGmA@3I}O*|u@j9$d+_yz6ZZI-X@39U0a%`6u)M4U zC3UtZE8>ZhCoB^oooL}3^hJZTSb_9#!sVqEqZvgk3Y~~gU>&mroz1dLok7HliO=8& zs2~X3h}n56uP-2zhE^X6jTG-8j8Hfbsv=HC4zs%3#1gz+&0;cVXjC(`S}di6nB3^Y z;V_mVx^ghoUfGjDcL0MS#(=?~L~ms&45Iq6c1I`2$I)!H%7T- zGtZ5H&!_&(9+m`7QJ)`~c>kX%`Tz0X!$#SL&k;c@%y`9RkHz-Q8{#MaCE&Rcjh@~ z& z6)Y|-+sPAioSYnEj1f!AOD1%N7||aLIH-nds;<#&KnGcY|ffq(qur_joCTzBJ*_QfxJ{=bXR~GtR^ZKJb_L?)Sd0vomW1F(lKo1;kpgh7lra zbUxLRSrVtkdlP!(p5}Z;vxsUKI5|6wjq5kq`t=)l!G#y-%*-sNr>D^C_2@}n@$6>@ z#^`5fX0)mT0joaw&z~HNA(Y*vA7iba?wX^t>e(-3I&cQ&jd z5hEV^xXbL7uXu$WKXQ~svjK|m__5=*YtL@(y!$>3tI`mo=_rs-imD~7gw?NYJtTmP zz@@2$H*s@=iE}UoGM6zg@+31j%H~ZQuw&-~IDY&nKKHr*gDbCmh7J0Co0*wnrIFJU zvshR-VQR*9vw@k(Y23T>KHPoRJ-FtpU&GnwoP%v=o*8ew^%i!!eQ7ou5bxk6O$FP{ z7P`G|5a(=sypxg6Qa~UTka%;{dV8hb(ThW;(Mnv;I0S?k9~;M-HET3PgY$w$(GVv@ zUKHk?*suzQ7#O1(Nd{Gks!BDg7+QG~$4?$-cew}gUPT}=Mk}j|Mb<#0mB(^W!nyQ{ zo|rq%-f|aPwr;g^&p%I^&D?~ZD~n6^i?4buuld$D5MzXRkINr(nGO0qv>R*_WSO#qw@=#nw=*|9J}RvZoAr(T-`BnWCaOP7T6%bqi+I?f{>Z;O`UHuu^)N>5)YqzqSC$ny zFFgA~jLl5ov<;i|_}od{yK|>ZPfXd_=bvY>?8)u7--#2)PUzg+F{#v$WjU^V@>Ae^ zhG5Zl?AXa>k>SC;doe6a0D$*7oJ;O>0O(9~Z0FtgaP8XlKms=-hJc^_>=rzeQJ}~hXyrMaciQN5&}uf=Xtr2nxq9b8CrlJ6Gfxl6JeWAFi91@y>+30{ zC5vbhLQxke)rBz%RniI6YO;EIctI_R0158PS|tReZkLW`R(D#YmhaS@hZxn&0z)uV zv4U!1YDcRXq4o1P#z>zz6~IDFUC2{wW`q%T+L|>yv2Zdx|ALFO+~pWlQIDQDA-5gekM)yND1zG9#2EkN<*z_Eb_C+(+s-)`rT17_Sw!#faSXO@#@Y=Vk+lmfEi54q0dZJjAcX4=aN#RnWb;GSqqp4V z#Cu%&^e17s>mhy9Q=TX{pEz!>SvSGQZP}t5pY(J#SIsi7D$HH~V=UZ%AKdIT{`7&J z@PlYSQ^(~hB4~;AfIc1~5KGRTBT@!}ilp{A>R5yY379 zOjaTtrn3C*AHV0lPdc>kpj$47Qo<@xO_8uug>~tPT3fyAAxaHfp@Nje7coPu%eU*W zLhY&|oJU=#UAw@OgaM!y;gKTHi87PEc73_jQg+?8>IiB|YmHjP>%{yiFL$ztCmlOQ z=@R2!IfU<(# z@I6Rp!Z15SJ?$KmAAO&g9*6z=7ZGo{4L$>K_dTdKZb$a=m+8s(yhpm74o+lk^s36N z@Km}O1+MEHAWp?QvAlrKvQ(<)y;<%V@@Di|Va-PFBrnwY#9wvZ8zl+xgg0i06eqC? z)HpQH+?aV84tvOaZbhpTEkO|ofgWRWOd&r2z;rB2sdT$YB)I2&ij?XgNrR5W=wXEts_!*m1c{`wTgS zorROIsnzOl`k{akwr@8q%OK4bu=#YL$N@7oHK8itC9OG-dd;cQ%uAmPMg|pL$rd>!<{^4)1b!p zy+_xHX7u_xcNLc z?=q9TP?x!qMm1OoWlzOO)t-3Qb(F5bmM!Rt36^Q-npp+2Wg(W0(sN|rU<)GXMn&IJ zB!39l0ESA1k*Q=fL`7wuL#mmk!j?)%uPN_TnZg`ku&5C*NgWwdAN|v6PpiAoBn`~# zeaom*O=-!vz*?|yH8cW5j0RX7Io~nDNK@15j!aN#iS?^D;_%7ir#ii#_*$|At-s(wDn@tgQ=&4)V}X zZ-a%B`Rr^qEweS5I9u!zm)oP)`Y>yh~k{iS8(TQ=C--8)zuJA|>Z zX{_JA(GK2s55M=duiN8);aS-9vRC7xCqACX`(20vXC zWoMs*5Gq`@ehUWki`cVg4|ea{gX_w!z4{4P;xpHOo5NvgsudF~SpX{f-Cl6Hmz-W= zqD!ZC5dvl=A%r?<2qZp)ORW0ZI4LeuS}MCq-OY}mBE zhe{%v#Ssh8w02-4T>~nnG^obp>42gNQ8VWm0LH4sa9AS50F5PLFbsx6RI$WxP+Cys zpgX|I@`^1kEpTaN85#nX78ejSp&b?$77(fmY5u6_c305rb#d^(5j%10ID3OW%BsW} zXP$)(n>V0SG;PbKwYp>118(i~3|{)uSKyMzJQi7zh3kL#9skaE{wc2i(GQZDG%Cb< zXb4GY_qhR)n>KEYl>tkOi&$7#km<>3zTo*U!AC#x*Fct|8usyrfB47v$A9<-TkbCZ zH<4RFY*@b@gL0@VD_toELqrjXMXQTCkmm)e5NZmbj%2iY$T70n{hVrk3Ip@VNc_)9 z>r6dSWNzKvV&xfg_B?D zJv{r|b1<`dHEzD)dc5+ruYsxJoHNeF>a}aFSN3?@tv|64Ew+kGKJ%$h;{`8$i5%R2 z$bNjwEu0z~M|aTE-tsbvMuUxJ+d_yUE?J=f!PMkL3>suO97t5NGtWF58`rN-+Z~P= z4^s0;8~{ps+(d>t?pamQ!my$Vtv~4V#PMS|dGaJe3_8{xb1U5y?XL8wG$0u3xFX6B z;k`%HpsKU*z_`{EQCr*t*A|SG3#}01awhf>7$B$z7gZu5!(IZ@(o5P`_hp;fWXx@8<7~m7O z$!Z}%s;Wxnsydy`I?7C~^@Sn>P1Fe)VqlgPShsGCu3o(s6BA=1Mk|_47L5XrdeozE z?>+b8-GBCOc9(22<@S)5<6E3SIFjg3vnJAUt-_E#VHiwZ#g%&V{d;Ok%cn%_FH zIFArQEzu+y%s(QbtpqgaXwILm<$Azd{|@O4fg12y8|9ElDyfXQ4y~EO)q`WJlUFc> zd-@eurpS2hS{tQG5({1GN%6z%bk=8mshdU8Q8vvxM3QT7WSupW`d}`nd~kIYR2@KJ zEiEP~u(sPJ!TePBaGF*NBpG@V)HXThC1uc?jV2c7=cfPt3txQSs8xFK6a`)A* ze1)+J(O@{Rcb}AHFpG*^yLNG@w~Uh~<~YAFZ&etw><mGgXABtU@$16)2Rh z&aTlVI+-S>ITX}th@#cjE1&vw&Q48p7zb!J+gMs!#-T%pc<8_(EUzpBmWsW^Of*oosucIi1aN5^og9sjOps?eP0bb;=9%Rl6O$8S zn%;8?DKYW(W2jgKBSaC6h%u)8MXCu#G~-|}#9+`zM4}c%Q#v|i-m7U8pJg1DL)*J| zA7GG+FTI%OoO2F?8ZzH#KP_TZ(Mr_!) z8E2kx8qYlKG;5EIb75ft5ANQJJkK~iG0CFYV&R0}|KW9bX!jn3P%^06`1lwfbHODz z_uO-^w6cVoZ@!s_jvv9vxjDobYYo7|ETF0)W~Nu;8`u0NKK_x9acpuD^UDkP`q#dJ zZ+`t+{Qcj36d(A&2l0i^e*t^;?uBzs&pzu+o_qFL*t%^CW>(E&tlhCzr&C)GjYU>i z(Q2^KD9~uO&}p{V86S_WPRC76PhnzW3X?OFn3|Zt#N;HVrYA5tIju9RW@Kt&g6+;Y zTg}4qJfkbT6h6}|%aA!IF3;(mr*{ISP-wN=m?kNX!;w4P>SLM2qi zvwfu ze}FITxKID=h8yJU|GLJ`x#B8muU>EQ(U<2JTy$Fa^{&c4J@}w?2SceG*L?ZMKY8I> zu6p_>h9Rny!6&gfk@M0@Qa4K1^WqVBK};cZkTgyQQuiU8vvjMCia}E~Jme8>k;Hnf zGuBAuqmOiuOHF9vDO5{B!AN~1m1Oa(zYo?nf_gVlU#A8jtIsSWEuASR3Vp=nJ*E9? zgIJBoICZ*(rD67{+a4oL+CYVnW}Z@)o+p2p!5~H&lHx5QuvqikX(B2{&>Kf=263a% z3{8Cvtg8Fb>RMl`8`5;Nyi;JYes|2JAB9RaM~KkiO;hK{DTBWyj&e#0SOy>?nT_}- zObqob0e|QK^8|~O2!I+SGt{~H)k7CGG8*imJ&bqV0XbtE`MTGk`pBo@_8o%k*$rI! zc!0oQZUO$PtJqlVffM7FJ0U`eVHHr;al}4Qe`BdcFC`HPI580i6-RN7-g^oi;Hhcq zLWuLo8Vy%8nh~hHr3F02cpAbiD@;Rxnixb$tIZuTh{n_;Krf=o(fP=Nfo59IWmFAJ zO?EJW#bn7+BP`Y%g(RjkXexCgBoK+Z^j}< zG|W&~5`m&th!M6PWIH2gr^etHmaSY`qGb{O;`5AGUcvI#dy&2IO=iso;T%!}c6Q1j z^6=8ndTsziP-5-?dT;wpgo!D{qbFHXZD@foSmlKIFaVC0HJWJ>+%8b{2K4g_$j&<- z?v1Z7OwLj#r;(_&^^J?V4^||ZreZy$XcVx^pMrdO8FJ^ns16*3wp+-DJ?L-aPk5S1yU6Cz9vPSOOhj#d*2aWxx?sW-!= zi`7ujTQGBja%d93f~jmm$_f^SY`6?w4dL_uOgA-c{Dl{g!!D3_46PQ`38;1DlB+F8 z6xMW+#P13vK_I#YWc@mD-4@{5Z$QST;m^I$I6E$S|9u=BI{;bk8lL+cSN-~1wYc(X zYg~1OuKJ}nU~K;`dEn-oA)(Sd&&8RV(QHf{D=1@71~r6K`Abz*LrN3Gpj1X$1T-eF zW?E}$S%iv4@qo3A;-RWEu^82Xks8TZ$))RNuz7sUyb{R0ER>}+NSh8O(;L^*kF{;k zFX@_Xm<1G7M5Eb2F)YoUb-I&Z`DG5yzetO9>&WQnRbh-oqZuGV)>&^V5O?l`WG%z? z?Xc^wwZX?fC0txKHkv@UYnAs5&Y>(T8wzx2COvVsY~Zq~R+5U|G!vuqR3YiS5TfRs zbK;Tt3|S*nN|FiKU6q29dW9hbWxmL%jtYSf1y>?y?^1 zcX6=W^XQC((U0KF|OXa&HT(N?pip>?;Sa)-}}zBxar&9;S-*E1@rL^ z*PU}Vq}67ofW>Gliz^(gEJK`N^J6c;`U}qos}hsV7ElgR9ynyjhkZWrMK8j}jhn67 z_aOG~*hv=@tEOl8-LHNje)YC{+)E#GIri<{m-?q9LoZf1((7R*Mmuxk2Htz%2%>jb z-)z~T#RWdbpI5^7+?}T|eb_*eJ6cIWR zI-k*d$INGNnPZlF%f!LCjG52je3lF;$>mFkGv^W(opk9b!_+vGnsI0@X*zTQK%7x( zbuA4$AxW!Zat_ldN`qIa3y2IP>xM96TIlO;Lu5XKH-XgLXGe#;mBaa*P5^NpzJ|5u z&Vv*S8tI%@5ofJtliqu1j8;_x#$Z^#Zap?`-iWQ+w{pYA4VH=H;bTW|=k2%S@Zlo{ zP)^%=hS59TbLU<7$&EMSft?S?)1Gw|-twk5<7F>=DK5O^Qhe`w-$6MXp1Sy>MMgDS zUR*)9*O%FuDVd&`#gQXNao1h9^G7$_h+R8&;f!<7)#p9`d3?o7Ucl9>*Pz$0aQN_{ zWU>UT*Xy(2>oI7k&k#s`Fjlue5tbJX<~~Ce;?HXgKkq|-q)Q#%I|8RV+yDFDrXdpt zHJ}P54jnm)qeqV6O|N}5R)z!Y*}os%-q123x1YY9Cr-{m=y~Yy5q$I7Z}6E{Uu}iBHD!e&IRxf4=ZJE-WwG{NhR4u#bjsAyk#?4@-RhOJBl~1BdK+FMgq% zclOz~`=JNf?e}bAVw_o?8wr+!A>fReWN3GqYCa=1i;%Y7Rzx6p0u~qNlaZ%(Xp3{BjX(-CD@>Ap z@o)`**0EtD=+Z9}l_j~zvbsO*f7nWHmDlj&8ffCx4l4V#>rL}zMRLo|8H z6P^_Q;;-Ic0mu*S-+%VApZV`O6}7mhH8UncSR-GghP;o6Osv0=y0o;eWJ`vQ z(Z}m6l}OjEt6g;?Hbs*D>VIEH)>*sxYOHPA64Yml5qc&q&Z!txwXSb~fEF<|K7nh$ z^PQ{iyz`FN^algR5ao-X|2)q<|9o`2Jub{I@ZgbyFaU=S9maBR31z?Jfdl)kx3t14 zR#t^b(7~H%2$evMQDfbXk}Rgqk$F+j3t`M4qChkZ!w_b`^yCCDyyzliMNXkG#)^w` z3*5hdFZLfiU_qmq#dJdOo&wNOOhn+EBsZW)?Gz#iF;CV!GY2{`FG6t{T_*I-oAaPJ zZ_Yao`UCZZoN?wEC{1zmO+V7Bu6~AGc+n;CM>pIgd-pt~KFcJ8G=&+K5kL9qPcYSK z^G$Dk3&z@Q{MR?HmGx`a^X&7^hWD8*EiKa#@Odf^SXo>$=e#(Q!&pMgQYsCJrmA#a z>eZ8uLaFh7!e%pvDbX7YDG+wX#?WrJsWDotDkf5Ns%wB6ohuk)U{wyyK&LQ^p_CA! zWloqCIpVM)U^EdFxr3_OvE#>OVR4BI3(H)!YL-uW!V_)vy0s*LJoos@e|!lqc=3yI zVtxUphI7w68*l!lH{y$5`HG!5F^6A$)0;T#1^oR-K8E}6zn51$;i+g84V#|mV9aOs z(6NIOOJ$?kz`FGttk)lKZehWU#JT64#{&oV;mENQTv%DbaM(}Ru+{sT5o-DW<-ZX< z=@DZ3BL(#OZg_a1b0Tau+S+Qj#Ze^7JxGtd$e~rh;_@O6>_1?~jvV3fxsy10>3n9_e(Rf@n>%6RB!TWI+_-)d&OYOG+~qeu zr#$V+Jol_KIXyFrcB2W&9CFD}v;m^Ox)&)}U`FP`EBpfe#&GMB3L5(9%`30thG z3O7NYA9jUX{d}X19)7948lWW3blNzkJY}tBarE#rD3Jv7RM?Z|;WPsrQXiTl;2cE+ zA~5k@935Pq(TP`aBI2CoSw@%p)GS>E!i>$y351i&c+GG8Dt>$WSv-4kHI^{Io6bH5 zJNN9vd~XGfyui`9lX$^npNMUMb^DjWR3^u)en{jG}Y&Q{Oe;*g z;p1}izx<B2??3*DbfMX>KbV;*W)3~>tg~*P^UxmEd|3eo zO5$?YBDW#6(WOJ+Xd+BJ?B*Vggw5&&SCdO!qCx99YYHf!Z?bSh{lFap~3kK$#nWw2st5*H_P19j3*4u)* z@|P(}=VbIzoTAA&$CP?yniHh4hN=^$N=(*gM5^VI&SlP0#har-#I!IXlW0v4xtSG& zW*~>7Q~)f|$~f{=n9)L*CSs;$P7ES2ZyFV9fv`x#&D2(a(JbE6d9m_6M|nA1eyEF4bZt1 zwo{UYr^_-j%aCOmDFShs%bGc)k+bM@n03Z5jL|aR6w`>^zFX`claQ($q8g$fZhCGxCn!9eg*Nt`>pEsP_$Z%zQ7=w4Wn@>R9LAh0*b1P=+Ypn$?IYc8Y+Ys z5&A>eaHvg-j#Y)GcPzxiIiNE!4PP`9GONfac@Ebo&>Ziukr!}TZds#2X%=<5piZ<> zQlpf(sE978Ld<9(y|1Z$%aJ|<#37oB3W=x;YLd40%Aje;S;d%^X_54FbQFZ-V~Qcd z>hy~;y;ad-a(R2H>x2};6!AucAUH6>A$T%E7)Z24=t#>&=q0DOAm$vR8P!o-P!>XD z&Y>e_Q<;}3?;ur(RliRTdvqEpFT5J|*vC*m`>&9Xd^nX9KjCr)=5REc^QiTM5ufv6 z-GCVwW75~7A*`GPFS-!cYJsnRJ?x=}zz6O^{)RVG{`KF@U;PX#R!^b)@pT-$;dN3q zrflZDe~O8F?vb58yPeCvg;Gcbm}d=k2PKamJ8A;3B~A7ReP}R*7)5C|43IKb7=~bF zDrKiu!4QpRkx(Rbk{3i1sbZC|4^ingx)vS!%RO7;9NWu7i{5cooaQFd^NzAIz|{F? z+IYKQ2N4q&o`XiCK-O-V9X<&6+^dbR`b9YJK*2|Ete7J>$13v*?_B0Gn)9ht zE^~A~r}r6|`?QQ?In5LnBS8}j>Qn;(gQ*f`C4{9IR*W_PQPHdf(KT{FQzx(>!U&+E zVF)0?Y-kphiiXsaWvQXROv*+~R5ggCD4Z}^bd)p^Sn8!P!b8PCm)Zj80CSGCn7Y`6 z3YYc{I`YIxEf^#stg;5X)q5HXJQcfVgsP-Qgi|JUK^0?Ocpp1wY{q;4{-bZXe}3r| z6QRO?U9{a@aP2oa7%%8raCw;z z-g7tZ`_w<-%wPINoLF4O|M~NGgUelvubF1+tPA8j*I$c|-Fh<~H$AI67U!)OE0E;r zQ?r;1F~0Hn&y%0taXVH{oHcIRz1i#f5phXXkx#-3{0AM>qZmKe^?ncFRwH%5J}h z$3FT|m|eXJYu2sBqaJk$e*J&F1^@K1PinW{KV>l%AtTjd2(sAiVeRZJdi^e)_jqXc zgV?iY58m^hck^ps`3lCzrtqe>{3?FsO>f4_Uho1lBX9lLPgN~-yjYzkMZzDOqcHOs zAjaG~WLXC11i5#JQAc@rdxVzoKX4GBfQ+gs3|iY=3!j5bWsYeuU^U87Knf1epTrHf z-H9`{ZpEW6x&(LcxQD&6dJ}m?>1FNcvBF;r9NM)8c;k>|8q>75DK~p*)(yBo5If!Uk5+6|M&@3v7PRltb z*njXK3YYOW{?~8lS?8X^uYUO}*t2IBo_^)i@V-C!GweICpN%|2GjE|RtMsgtjDP>P zAGSCC%9}ZN@&rEh$xq?X;X^!h^sp^1E+d4BMnfuTB{JvLIT#$Nwf-QUqfAITEh<0{ zqYB{+j@hURT!c=E)Kb$JYiXm=aCzq0Y&KEk4HyM8Gt>5?>u%!Q+)1b^i=si)wJk{f za!lNW`g|(MKB0-O!%n*iZ^FEhvB;Y!+6BE6N}e$cD{S4m4OyOHvAe=8Teos*yb~ME zrW>Ce=QaQN&Ft{ugBoINEv+m!U-_bEe`o)(lgY>+1Vb{cp+>k^>bgsVJdso7*`wj! zsU#JWIXs!gM;V)1uXa|;!AR%(Bnd%CL^HT6uDIe6N}j-?)p7AUy3YC^!V*-158sQz z5#MYi**`+bucPW#m#jsVRDYxoPY-I39vlp@{-#f{SH<8Ym7OMWp;qH-w|Xs3AV{0q)yquDf< zd3Jj}J8djLsVm){?A&pmUG@BGKvK*(&lnU&)n=nXfnaHIh4XXsSeReH;~#%HF1_?(Ycv|kn`wsM`>o%>+kW?V z5JRv$YuNLi^IUGk%cMqR&#nbuYn{L7_x7>;gFS-a%eB9-zVrBR4xED9w zb}R4My_@|(iB;3nx^?qrKD6gS&MlrqyV>COZQFSG=uylqEWp+2)U<1*)@#uJzZvoW z+sA%RKtJ_s65cyxc}Jb2gi+jWSOR7!t04x%ftF=yh~&i76sIO9FgL$|Gq-KSwk;cZ zB2P!(kbtDpjL?=NsST zKmW_8v1QvfSPcBV-}?jn;v3$8uYBdp*s)^=I_)t$`caR@6QA$|Ty){Z*s^VFB1lo- zAP^^LG@9s)PhfIt0uxiyY&YBNbUHTHYFei`W}WeIPEJj8YGNFn&KRd>rqF4%&}_HS zY83EAlUZJ%$P0S!#S`#(ZX$qp-rxjc0tbo-=#(@kRH_n)p!oExOAk|y@=3|)R$G$O zRwTjAEjemN&qa0>56F#1rbSKQXIsC zfG906Z?(~EHsOXtJ8SJU&d-|MxM?#E-+w1w_p~dq+*kbI*h#FO8pn4Yd;k}$T92o0 z*@O>W_g(DmF4<$Mpszb)3ny34;Iv0S)*k;`zhei#evR18KgRO*ZCroxCFmVLiTS;I zZG81Aw$^Xt;?fEnjph6zRt_G)gsF9=CpdoEHfXDfpM3S3=uULlDOcF&8pB;X)%WMQ z?a}9=w`q%vKjtwg#&U!^cCvTtPjKz`zKM@r_kDhJ*A8Agcg*fwS*EKZ9(UU5m~k0q zU2a<&O>Qmr`BV3?%|O zYjaOJvpO>**|3JVC5i<7Xh|2+Q%7A4LP^9mNtZfcCXzg(kYqa}VQ{ADn@dkDQ70Vj zMFcdTno!IW%$N>e^#my`+^Q-NI5GHI({vpDpfI0IZ$=})UJrafFO#3WCo&uT0vnBFe5ZK*f@*@1r38W49pF1 zP%FUL0A%1pb# zW~Ys8*yot{Z0A1l^2ghdETfBoq6VC`9Vmy?`yT+$I2&jez`6|peZ31*AV!?pd9ijX z#D}>-)kF6Kd-hUx-VeUudB7!)C13Fpa{DIad4ZxTQ8hB;?GEM-9DrmEgrbr9T43mv zK?i0sP9kfzG3XDBc}B@SE9XvakYnayLO43oIa7NF=_~`f z+F(FBI`7qxc>AU%&I_G)Mh9_p;zm&ASV?brSq2LW63YPfLWxGvk@RV#c~aGaDa_0< z23U+pjPw9#v=~DY;>!rtim{Bws0^`W2oVU;vZ%}~f@ahZ&{o50=P~YyaS~$$oEc*1 z!!0f%>kVvtdY0Lx=Rvk@0KfS?V0sqC2mT7yXoFP3B-Z5&^&Iznv+fW66RmcK5VcVyA-`!Ab*yk-hp^RMio=7$Zs} zI_(w)qUiN|5b>%MapFMltl2EsY_>q(Kvx4p972r@s;RKMsxavFP*w`x$Y26$u!K*k zcSCAG?ZT$g3=s@fNe!uyO1vlxOsMk;8lstVLQv__QzY5rwJwIxWS<>*hN9LDRpAt4 zi$XEAk^aL}5~+*$wh{beUN^725!q{(^iwI<}uYWpPCS-eTpOp zfPluNfKE&)CubPFGdppZ;vDrgzXbQRrx=tn;WyMG6V*L)BCTYl^&U;oRo zvHt;X9vT<(oX3`y4e;E!b_P#+(F-BRPjKIn!(i@^H*%!6Ts8tLURSJL%#_^yWcV0VDrPJ-}Fa&1JjFNfw=ND*28|~?F6cvdR$1N_* z5hqt*b0@(=`xs}ZmH+V1j*~O>bfHcfT6+1-JBro59+Gl+59~vK1^ny2xW~3g*b>KC>b3cKo2@c=N()w=9r6kz!eRM z_~hFrEhQBtinu63jb;@MCBXncKuC|l@-^2 z$2+XrcD}f|E#;fpOpUjB z;kIouJGBbd8H00z`ITh~42!YS6a4`>9CB*wRy^U1)0tHj?wmiSU;4X`>qV`$Y`*Mq z3<9{ZF)kgQ!|ILev3z14t?60#RcmnfPj1G2-~Kixu6PbEf9o$}_wT>cCgx9Y{Uw)T z{idyW#_Qj}byq)|vDL!rsTNND=q9XP?jdUxeB(=AWVhaT50^sZwy9}5u{7^Uhch>B z#$87aftkmkyNt(QdKtcZ|4vM|T6orzo@~oIcXIcjZ(FK>3$MPKAyg#N^dp7{fuve_ z)|)`9JL^&Z1{iUIV=8Z~B_`Ggfk?2fuBq)rDP?H&p~xhSOQ@2qBQp_6lT+s`K{^o$kp9$}6Vf|}I;k&S2ys3YA{ve2tjL5uZ!+_qNlx*J zs!*q8!~mZ;zvT z6DLnXNK8yjFwYzahn4;^jvhN^-~84$?SmisfE_-5n6G%nEBU+^Jr8et+i%LX|8=b$ zJ$j^8@|dDkDWzvHWr%8_tXP?%)oAL(#JH&`%d#4|ejaJi`|mFFpLee#T12POLA%+2 z)#XcON$b%X5;GX|u(-HvTi37W<(EGWKfB|0SlWB0d5Lf&(%X-J@)J%pT6p{Ky~F

B2s%1Xk-k``6t*x0xgdCQw@*dN*rKm4H`JaQQGbMsv8_N?Dukyu5PRY;t05o0QJ z7PXW)pw(&m+Bgc8l92M8h3gmCU*H2upVOku_XLfg#rH*!m76 zY77i(7yH8nYa>)q{a{QkyPDNA+R}}5Vpo60QI-2C3$Kj$=xKf?b!3<{IJi`NUjHDg zr)RKt|DH3x{N=CyX;x%35I?@uCa$l$Ry%p^6vCNR<=P zWe(nXdhd}p3Y(go#7ehkhYlT*%PzYdulc3d;xFF!KK6P&v4&uo1iE+dbQ!BOzgd!FVRVdS;MJN=o><=_pfOkNM%3*&P zNz&z+F3iu#v12D~|GvFkyM7I>de$>+!^X`f>9nQQFv!ba{1W@*r$41s$mVsMv3c`m zAR2#k(~orTL%ZavE3ZaXReIBHxA52A@@rT%GmRhJd?R-6+G8u-o~-nGsI;;TYu2&V zZ1M21Lm2di*tBW0ZrQYnd-fm1+{u&XeFmsWy+1^ZI+_Ci`~vpyGRFVQ$Myg6chkvC z1fH2qb|xsE9QOMdh6=35XNkM)aQ2z!@Nt)2j&^&DW8)n-Cw9>V7qi>z;kMgvw-fVo z_17_>2*)~YYqvU_o}R{FP~yIwJF(pBj>4BvGZc9P|M0Po$$xzLE3$s`hH6+2{kz`z zPCVzi&)4g(zm6IrH*DC1Cp_Uvxb)IXv1!9bYfp@^C<-*29%c^BMgxsz)5a$zxN3IB zre~)yJu$_xi4MGT=!}nXVtj&QlVdV5HOZ;TNwhm1blNS9HOEo3n#i*Pjl98TQD~zm z=rX67&+3qefI_Qdgm6L!f!4nwK!`~#kk|E)^|2QtBYG_a)^>F;Q6+0s6;jb++MXl_ zLcQs$wX9ScTPIi3Owf#{2o#T$<72KECr_r~tPeI*g5-aXfMRHau|PfZcTB7&k=auW#QjSO3bd z*p`>Rl3T92(!TZX_X}HvZG6?sWF-JaBg5G*elCVbm$3H>U&iXK8<3B+**$R*EoNxu z9uu=OblbPXPfgl4zx;JB^-A45EM*G_H|*NRbIz2FPkj>fvd3WZyo+mlyskmpXV!K$2i@YrE2EiRzf>$6)9?CAVFSGo&$+RQXw zb^3OD_j8_Qzj4k*wBbOcXmWjP%EGY17r*i)DQ~?)FJH6CwVwJYdv!79Kl-!Vx#%sw z=8jum@>@@S>fbcR+ctOfcv?T|!ESPSkM1<73rnp&($)Kcdi@iZjGSpfNWd6j?HMQF z)3RJUg-7M4qi{;CKG$7EBY1eaS5tWU6phVB-&+k-qnMd8*|x35^EF$USbCQA|OhbU$C&EOLu30>!Q3y?LH=3uwGm04L)Ben|w1iS< zmWi{5nX71)k>W`>m}W^@ML|ez=1LQKfq0tbBz^sI7vdxXWs9|4#{7mtFEeL}jhRBO>L#Q;s*NGg3e zX`w><+^2yLe;n>-w*mps(1qN2Gw{Fzuug%}HGrTP|Emu|@4FYQhA4djgJBpWx*Dhu zv=-;EvfRhY(PNzJE@5KJ7Pw9ap&Y^)5wg@0;j>JIL{=1VS&^=wkcJ6W2#8f_I;@nL zgVjxD2AIo)F3Tj8AtDArQqdDjNh4`MC`(#MO=ta+3y2miZ#NU8Qbf!G0ah@T1Re>j z4GBs!#$g~d!K<~5Vj8I$tg0F5(JCTFwWy3$jEsSRnK!a5D|S?IX4cSE8R$y276H-7 zh8XhZ7@FQtuy)d&T!8%WX2jkK_}R}wPCLtLJ0?!4QKL}QD9SS0E|@~U`eoQx{}Xn{ z?Qm<>gRw&I_&kORTY+*I41G034~{W|X$2itaNQx?gNMOe??CzBgTSq~LN2-hC^ASS zI6hW$q-2zb1tbFSs5xcn|BrqQZvO$wp1okJgG_WR+hS0SXq>;nL}L?5(fqy&`fiOWF#Wt3`q+&fDVRWr)JiYQJ^S8 zWe|bTn{&xrCUi_89z`rGSRx*osv%mSLTOs1N3qoD1VxQjS5irJN-?UY2pL6O1gT~< zbJ3^bCQp~Dt5fT#BA7%qr37O%s48JmG!;E2V-uBtGa$kX%}l9f48{~vpg>_!lAFsQ zmWlwQMwps40k*tDv(-RlWInqJy0~QVmOH?A|EXa-r+(ophN(%~-FI0$c7Sf}deRHv zJnL+7oorSh1X3JK16d8toKG^t!aUu!(}CI5CJT$eZ@iiMNAEG-z01j2r@_DI6&CKl zmlRL`j7LlPlb>?OHDANjx{Ztw4yz&hM-E~B&O5Pf^(?Ydv3F$=tuXit|g$re#IO%JM-E*|5v7 zvSL0Ov$IaKs7l+j7jpG8;6C$ty6G9R$jyYLMFj<@f&-#SmW}j5N*u!8{AS4EdBiV% zh3>z;ZFcxLVrL9&6cAsCH5|)f#eS)fc7p>t_SM*<=^)|vA>tCo&v`%`#Q`o8c$dR_ zXYd)}sUn^(&&@e+;+=^X6LC?T54E`>5L^b?r??@^A`K;|CCQ3T`jRpU6~I1W1Ehp| zMW6y10c7=-v@%1Kq&0*z;iDuLR1&^TO^H#3ovBD&nywH4RXt(;Hto1S?ko`3Gec6_MY?fDm?y?T{(T*gMDi3s4(L;G~l8?b%; zg?RESUw|L}#@n%~Gs(yN$sc3Q<&S4(fil%W@CNn!?R)Bp56xca?+h!?#0`MCHg z&*HPrIL*Fw^N)GY(WB@Zc=v&QxOl^6Y@VLAg%EkiL%Vc#Y@E-(@Iw6a558{~opCld zty&A;U*_L^>)U+olb)bcr=MXlnq+yd^%zn{FdrdD601oH>(;oPv>{HLw0cXJ1fiq~ z@s!0pV$@wDQ63KGf-p%sdJ@&rE+r8N5~Q?Ni+GB-ZhTlqN>t5}&{ID|lRBHuZxk^b zZDt9m2&qm?(izaiiTV0lAO$YV38-a0r}qV%NYYHQ40-0Q*=WIg2gy90IOKWGcBf6B zWz6zi>EQY+eQULvoSB-!#x0v<%hs(nJuxH8OUvl@`#3o_XCM5)U-RQ1|3|#xmtQAq z*KM#r{KI$2?p+Vz&b#ikP*o@zO^%OEvK;goVX+!i((RR2R(%GoW2|(v5P8RKx5h7g z=HKM5JMO^qU+_Zw%3FVxzx`XkgOB|EM>#A91fb1kOC-;j+Jn;@r%^E+4B74VX;BlB z;^*V>kI)xt7w*q%>Ik7kv(>=*RcmZ&vI8~8YEagX$!JC1u*H?G?0j&yU2yS*{NP{y z1#YCfl2cC3hvr*4;JT_@SLlk!yP;B$NbU~wrtso*;TXHwsA9VzvDI@ zIB<|>Z$A^QR+IhSKvw#F+j0L6yXBT!rB$@_!b>i4lM@s2;LZoa?CRAliUzVqu4Ap1 zL^Ugi6{{++(`upJXwo}pMx&#^#L?H#YS1WYnrdJ~1SM!dZ@I_ii`YUL++qO1!m@!5}=DiGtrMZ+MkPsqGBaGmkcihXxx#ReiH~%VTR?XPa zLx=32Km93g-?kkJ+WY_V{iG0+lM|TeOyI=aQK%|j_Trb}FF*K~=nV$E;kxU1`yF?n z9F~}0p0_Xnx3#9eD{Z_G^G2|IRK8y@SB3b>2PKK~zIkrT&{#$gEUy?ge2`Qk@C z>S!5Cc%-y}tDheV*1t~DPI{UoOpDePVWTQNg(l6~M$(R)^17s+F(kx!t&{Uq2Or^{ zamAI1yE+nZM);N*zFuoOsOJjx7ZsQrX+ZU3QEJJ6>9Lr`iK8DNwWm=f!8_6!7+OyY z(`#F^Xh(a$I=KGG&kqH>&tOa<=*< z_ITpN0#BYe0q1irtt`hQM-Iy{47uz6UFh`(>cqLKiiifNDXUP%7$QwmeVSDPRV{~j zdK7skRS2j;MbT6uSXC9)tzFM2J?RPTjCCj!EG#bA-26O_9yun9ftp0EYp@AR zZv@1NtA%?Nllmo0%XBahoCT(D8z_;`}X1mzwirTcI_HjJv$Axz^Y$Kx4S~`y_HqP zve(19^&73xYRI79XIYlekmL?#G|vpGilACM`CVdTMn&d4vb<1nWT(|(tST;bdpbVe zp(_eh{b3?1AeuNrLy)R=-3_aV7=skz4RjK#5>ZW>tp=+>Df5dCL~2 zy$25B^I!aToH%~c#yTAtR3*CoK8n2HhV>iJ?{#tFty)2||EsY6KmYC{Cdnf&XCg7QnmK1?SJ63#`Gt8^jZ_$BCMMV$_Ho%` zABSgO{Va^N+W;f4yZ(CgLy0rCpT;}xx(g57zY}Fu){7_6X|*^rIf2R6BsOf`z+Jm` z;qb9TsA^Wa0a(9&ja~QM@8a)1`VqP0(o50p_w}9c_yhmK7rp>D-0&l+Mof&i@%Se^ znP;DM7A7ahku@?DS;ls|jdrJvPOFVpyN${5ag0q)a$;%{6P&jwgDG6RQ~#kXMNoTGdV9?{J>dK>u2x2dLqVKnO+4L*~7t)6Kb8Aq+lbqHzn zm@}Bw^xWE_$QmonG?A&7Hj{MPQNTos0uO%ii+Iy}-)*ly`$9Rne=jfFvRxnl!WY`# z{P-r`yR-;v6qxNy;aMBk;am6Kg&!R~NzZ@}JmZ;o&Od$DTB}#{#O}R3a^Fs74?f6N ztHE`bU53hNtqacQe7B3K)3&hEir@OHzu@Hhjad7n#{=^VaAO_An$@(z;ij)&%gI&; zli$CV!<~0y?In-G)@MGG?X|0s%}!xqzAu0KidW#hpZ;flbN55oT`DeXkE7LW%JxRb z&g)D{79)0?Jc7HI7tx9VOM{4`p@(6J+*=Lo=1}tbV@I%m&u)JI{#`uVN64GhnpQTAY!L$)cRW$%y4SI3OA`WP3yF`65NL`+3EPRSfQvbV=PBwD6TYaJw z^GW-(G&?+X%~>7zvU-Cz@};M1(aGpMQy)?US}*f3gE*fojzp>ia7+$xOV-B(Co&@i zbdn%$uEwx=ii1JDXhL^`bOQ59gE!Qpg!Ca1QXxW>v@b0^VHgDF7Xi15Hg3rgHo8doQ^r@nx;CDK9}VN6iO5V5jC`g($K0}H|(vnKxt-q zmZ@15LU3kAC3)r(pX3UwaCpaElDQn2^RTKygS5%^7@A(Cjc73jHaZ>T?FOXPrYBJ=U zb9o~PjeydUOF1$FG-^fFNX9531Za$kDoP9$qE@ECD8n#9{xOF!SEbX)NdYz$Ic77^ z%F1$6j(MTbVcZ#ftAREmJW0+iKrn>d_#NY0e~og+IVpB2^*%f0b4NMTI$-dKx|H3! zQ0=@O-iY}98{nqKAY+rTxj8JCCAv{Dgrn3iB(TjCkvvux<~fbBU9= z+{eHG%`(6VBvc5)L3G1`bIU8p`vc6ZS;fUc9}$Y^JOa$h5M*G0Z#L+ht4j+Lb~AZO z(&Gm7^pZj?qoP9RX_8zvCL%;EQ|gEjQB8qJ4N8jBQ2WcPB=B*VLr7= zGeFR3LXRJ3v420}Y3q$&xdyUsEulkW)~aJ?URVyOy`?Da@zj7>MIb2jGoOHHfW7u5 z;5UB=&aPtF%n+TktZ34P6^7j|yZs0h9vJJ`LrW`I3CaOT6*Gs7lnn45U}oMqia1a* zI4@w9(Rl$~&fGhbqJVb}DX{F+c}Jm(^rEDXhS(<=C3OW1MI?e48d)YkxCJwmgoR{~ z7l>zRhQx{>i&0n|Qa6B76o@qAh`pMY?@?qZi3>s#6Pg2QMmVDGTM>#ex?~tpH<}QN zz(G?>5U6!6-e^%u8?Cgjk$QfgPQ3!cnYx5e7uhtkN^d#1ck^5S?cZ+9!A1*a-+lW# zx$#%tU~|9ocKpkOhw!?e-Yj4L>1_z6oCI)Tr-Kha?umHqxo1LpLwx?8Tk-DOZ|9!l zM{y^k-q-K)p>EF(Eidrkv7ng9l;W6$x*IK)tu5L@RC0C5W1siMw1{qUL z3lK;F5=wxC5CTcy$pfhnN`Md&2))>l)jm;~CJAWtj>iSDGKq2I0x>nN3q=*cI~u0f zH6y64JA%k{|7W!(sgC5G$}w4~U5viG$UBVo4W%3L87c$R$e0}?Zo(M2Q6U{PM*amf zC*lPzk_=7D60j)ni6au9z@>?$X~x8Pw#VAY>h*}LQ>Cdf$ueuTnljcLV{5!k(9r7- z35BIeDiagq*mB%fY~8jEN9PwKAuh!YlN4uZ(iR0W`FFjL6Ul~t6X#Em!J5SEr!<@`sVhd00ZO*m=S zF1!5l%iUl&Kq$&+O07WEqw)eZMbNN*$#|$@{{Ipn`2Vd-7=Zp@fbL+x<&{-SGta~c zKo2VwMJU824v81ueDh7%x9*r4BMmU>%VTbBOH znw|FWhwGMYTm3K}GK63bp0%t_@5v-dv9h{CB~WYEk$8{9IaKj;fEBodaU2sOblgH= zR^&OCmX|Rc_6-hF6s4AB$q>|pglb@(7hE{HVD)-kHgDO+#iK_#cX$p4L$BLq8A5#E zHHgm=g+cDS_kJua%<+$3{tBFO%E{<<*X;A3`+_7%iYHxqiT&Xpz6AYzz%x!c6$cL; zM5o)qFwbpbY6@3ge+^Ax`}aSgST@HE!D>RP*uTVk4#Q>!mAi;#b z^6&{9#EsnAF&$zE7+q4uF~*ghMU#V6?Q%k--l5iLvtF+uO&!Xh>WtjHc{6Xkq{0E~*4zMBr2gjAa$e9mIt2I*kM9}XIsIlux z`@NwZU0lH72M=P`$-CvUXFVN`DWFjCj{EMsOLy%)nae9HsMYEm4ExX!H<+hf`ZRm& z6P|#RcI{##&2aqj$Md<*eU`oBUH{6)3nyZP>YEhi%)mnfnhuhzB2h z&`d~+sC%|rZA#@2TI#NF_Q*U|I;+s2sOTryd*cmw$GhIcnT;EG|J`@vq?1p@Ti@~) zUVY8gW(Ky$#_jC0&XvcWe-T?_Ei{@nG}0d#tA~1{CXKYtTCI+Ht-)5afp&Wg%~l;*8ri(5^Po>7k6J39 zDk?5x6sui~B~}KlYFZe-B_&J{^KxXY73Q&}E(XF(Mwk{*tKPH`jE)+Io9iO@=rm#@ zqq|l8O;Ht(Z!EFCA|BH*M%|{-p{^BfGBy^|L>wLB$yGfVf?8S{|KQ0_0YZtV@7zgU zoVORg@I}1x*1P2!x7~=D=?$0|o5oaG;D-C|z}0JOcD4ZDz3{Po^v6GL;ye$2<6E4c zJ*xSJDcN|+saDYIkzZXUM+beTUeH@vMR$1x+aLc}jJL+^&L8~9#=U3Js3F-nMPJYC zK&OX|bUg67m)SIiyyznzw(-a9;p*%nYV)&p^Jl-x*S+>t`0>I#w$*F6pgn;JpFk)$ zJm@171#j=H;^ywE-5W|f0`T4tZ~%%$5X%;@46p=sj<7>!ylU9B4<3BbK5^sCa@vsv zzVeKR;pJHpme#sBRG2%U0Y5&npxYm~-%fk{Q^Kov9q-?F!wuzuwY43^TJM@C?mF?l zPOlGYWrP&Q2%L?=VaGnGQtfA>o)A{iF<0$z6)L7;@mZA8W5vz?I=l)9UoqMw0mMfA z;b0u792*^rRE~9x(I~{iO^qFum3shY(8@^^8R*r{66+Hq=B_3a8BwHjnWgi*O+Rk@i^EOxfq z2vb96mBon`8~8wrC;(ERl7LleluX2|7BLy{pe3YafKuW=OQR~l1b{anB_)kR131uX z6bUeTB^=2*z#3r*1T{eFW}!u63ZWAqr7giy^p?T0{qE=55X(crl2M%lTzya2vlv+#6ZkL0>fJ{BuZpAZH zUKkgasfP||s5iks_+u8=UkPqG4(^PH!+ZjSN`oC8#9&qALQu_6h+ljUy!J*3Z}=<9 z)HHbSov^!R!7bast| zWqkvP4;wU>;b895M{>R?-K9m>QwnDu$*A7)rQdVAC1u zE<-wAM@nLC_6V}I9!v!8p&y7FaEGaaXcxOBx}Al9X(=h)eevAGZhn?|y@wBS&C)Kx5ZV z5QfzwbLg8QO%kLAY?+#p)6RZ4PCe(5xc}xG`M}aDl4b*)BA^5i9BDp5E%A^fVX1&> zh&7<`yp0j}O2kKA28T z)d<9lw2op6!3=5y5Jbd*45nr5Zv+ixkPyWV1P!pFG>cH7h=YMLUgY97FQir%Fec)v zT51DI!X%I;aKVf;I<;6TW&uuxVum#0v{1s6wHl;9L>LZ`I&ZT70cNE^-}O%TohO1f z-VAxfBbi@&ZH)G$32bb9{UoUv&2y~6C^*1*iubfEjW12s06JY@Y7(;N5|$@!h1_u~ z?eg!lyz(kY9+-6dLGOOhrDvXjx~eU%t#L6ZC!y%)1?6T+R-M_hk-NiM{nhjbg zBe$C-ITZ}iB9s_S)F3oE6SGn+Q{x1kdZ-i{LPN-L5lknZS`_StQbPrusHdsbpzvwR zv9xBPmeLL#VdL;YbE^vsZ+nZn|M-;1WIJZkB!zjXn3U9l`QZmeD70ol zC=JDsyy+&`;tFulqY&=C&tM|#50G~{@KcjWHq2PBP+29p0@I^|AqOT9=LF8h>9Yu# z2%LZ-3E*H(#NZM-=QT|nq?S_Xg2d>Biu3BcQ#vW=7`#YOwZ0gGkwa0IMyI3CLTBnq2W5)9S#vp{sFkK_ccyd(-lw->-Nj-w$A8f}`!Xa_b^ zSMiV52ZPmNxPlpi233MSW-uY~GK_Vva#e+nGMI?L0u8FtYPYqXB)H)H@4CzA$7+!9 zxtG0O9{%iSV(>5Tl7IZ+clZwnAJC8&_KNK%azd4t9lsTSxA8=5EpmMIu6ywOo36#> zYir0AxHcc+rojNW4ElCszaziub@8L_8h)_0hVS?L{N~c4eP(eUU%BTlo4f96oINpt zlg~QC_MCqvJX-RRtFF-fbBFkhhn;4R+` zJ+J1Dm6h~Z-)tIO_!#eWqPqH2_`NHEc7 z5l^4ypu{L896O&;@c=RUBSxIT2;CfIeUEA=F9wA~r)mt$RYfyMMCcN4;v5>y7PBN_ zyU{?S)kdvew=7L0%~I4`EsnKYnBK4v(^FGO(}YC`$cIA=`+X3C}{= zIY05qPx6ER@ozY8`|7GG&!Y>r z2xYK-Z@|EH6rDW?JM! z_67rbakg>uRt^STd+@;nOtQp85;drK?+7#cv~Et-?%($SYmFNI_+>BSsi&NRK|aK{ zzWN<5tt{i>J&(nk-t-piz2zqE-m%k;%+9hHDuxmD!nxT6ZDd}KF3$72-@Y7!ZV!Xu zz?PO)q~GgXUJe-m31z4#7gd5p0|UrJVmSuPnZ#f+B#DhsadjUJ83-2@W;3IS7t#c3 zrXq1aYcv~ZwVH5Ag2V|!Fl^nnO=oA1^3FSMX9x->K0aL)on)l$Qyd^rH!3r7)dFEw z!U?^Lwn6a;R1MyH4TZARYS`v&TcH-{yu-v;n`2YsOjNX813~Y$C|#Sash_wOp0SE<^L_b zulqG)+k%Jz_K+B}cmO4wbC{W$!FRuZ`OAKL9ZrPNGH4P{ zxjGufG8S=gJvA_zf(TG{6SnVUSqA*_msbGQ3QGdLeivF6eDc$tf<~(eaUz{=7Z2Wdzlo6Eiw%ZD>#g;e zrOwhclf29spzzLf#0N?efry7{eA7i7HK>UQ^D>a4sI?jl8o0E$fDi(yv;YGXR4pNl z`NTXQ(zIkz1g@^FR-3nB&>Ql|>=8Y3k*<>*z4Z#20e86u(XmY314*D*dep{r}Fm^(Tzc~O9LSY2BNXf`=L#d=l;%3y(N{Xw4(-H0BtIUOqn z;rc%xeW*;FAGxq7)$>1E=}+B#id=m0<1MKt9G__0+S)4i@7u?A$?=ov6M)wAyWZ^rOz>o;{af$ByIKY`3gE zF~*6BNwnH6G+Qk+n@wxAnrJi{tTpPEq&2phO}3hKG-?g4)oaXZ4QtfvTB|kaQZMaB zgZ0YQ-fXqeY&Wfz)|tejJ9wYK3E=5Mlo_EF-!J;jqa)p_bc%+ly_g-c58fl|(>?;;8BUQ&nHTsJzvSOv-ehg z57mwsFF6&ZBT{)xePTcQ$9LN&e(){+&Pk_QeQ}YG+qNCe<9G5|pZ*B8Pfz0Pvo64q z{rhqB;C;BVKR_b{eD0BF@nQe;c3^Ts@A~fLXr6Ye_FH4tHE_fEkFv6s%AGguWy3oh zJu(mN<(3zPc4m*r*zS`ty>+9^-*giuj^B>WXFUvqu_@GM=k-^=cbS~@h;za@U-*jT zzQJxe)bQQ!@wY$z319x%kKh5Ao-j6nC)OIA==N=YKE#n>9~;GS0JR`slMWdmnVIbp zPj7@nbjMn?R}o+z&>0acjcyedzC2jtH}AX$7tL(67oLA6k6T#dQP}Xxe$KgG9~%er za?WMXu$QK_^8L5p;ji0&|C1km!j3PV*q-RD^#^o5+QLJnYl#S8@p-9)X^2E^rDBB)P(#EGc{tPRY!M&cN>39K35kku8NZ4b8!6px-7}^J ziA`Y=^Q^H+R2ao;sWuogdV%9;y0RJ=9d*5#G?Dd*kO>uzR<#YqA`FrE%nL@cTh%J# zBKF-qgwG;I3Kg|#svcM3n0pjNFKH6u_vuIximg+3BK}33#v>3x=Seyz>Z(zKrt8wIn5>nTMGe;Dz)8Nnq+hdKzk=Gz=UPOryLZsYLUV(4Y*wKT5C?UH*Gj+cSDNO57)YcFc}U9W(eZbR5qS+s+IE#oV)W*QcH>{6T&=9 zi$N}ll}Pe}wTUrK2(_4d>;4Y5wgj6T2a6JN z{5H6;aflP7?*_i)Y`>4eddY4K9a>Sk>O5ey156^akhTpuJ91=CssNt(tgqav^@N-c}P;o2&D zM-Fq??NN&%eZ9rb{1NFdEi1e?_>@^H>sISBFA=Hyl|Ecr6p+hUDymkhm4R9oD2sp) z0<0Xuia?eD2n7&INC=Cue3gd%|<;!S>eQqH;Rh|GmeS?2ACD5tU8OLtR5GwsAZc{gGM<=gNZYS z5GUxW5hz>cIRdo05IN9AolhjDYt`Zb$P6J^5DP}r*d%SSi;SVdt1Fz4pcX;mh#lq` zBveedvMj`gd7R-v%v4Rw5WgObrb-ugFOm*Ul=Vhk#VS;jC>=+Kk?7bq29$-877fJS zfVzm7ccBoX4rMkmW^T~4bZP>!X$vTx;s5@%l_-cm{Y&ssXMrlzUta-v@};8-q(x6w zRS%{CpaiQ%q@%|W6f+-@c^Gt{*IWbn(8n3Bz5(I3+kpp;AaPD@a$FYnJ&2|K2bgW% zOaNG3>)A{#LFs@)2M_b`&3kDOtQ395i!EX|lrfI_;xyQN98fb221he*$}v+Om!{n2 z9Ft&@0yga&ay908VHAisr9)yFg^89Jt7XJsK+GLveXt65{#oWO|2}xx^T|}m5R68^ z3nk)~MDs#e2Ds^Iuo$vzw19hV0pIs7TIi9V`#f;(eqek8<-P}@8VtQ2Y|umV#2vu# z8)5w(m%9bZB!REhY^@Bj4%hqWj7o%b5iLQwh=NKz=~E`Dj|GBRX5u^~Ng~i9aq1Ii zPP~e^0+2w;P&ML)Napd<%`*D)Ss1KvK!|7;$r+V|z=(+ph|&HmHo=V4Nej`g7}a#E zx>w@CS;S0bbR8G7s*n^4k$CO~M58jPl^W_L7Q?s-+5xMQW3lqUR4k^fWnIyz2L5WJ zZNVo_%sY=0HgCj}KKhaO96q{m2~_RUGark$y!I8c_FwN0ule>j@adHv8lv{Hu`%Z@ zv1d$<@g>_IhPjn_Jb&L^_~g;UAb?h!wj(j3HJU*KYyfBgRtGo%pd__`$Wbx-RbKET zciv&QUwJLgPiuU_$)|+fGn?G6=MLb&UH9VAyH2pjJZX=dcG|;i?2fzapT6>WNe|wG z$GrHZ=oW_g`|d_4O`qjjS8Fbohv?p4&_>FJbzJLFK?S04F<=5Z(1~zq8 zar~K&LSy$14(_~_^=1u4$g%5!3(z>}1pChW-Y-vm@{@7#g%{)JzxpNS^8#ySX=6#k zQ#WtLRSz7%ma$1Z`kb@yUqAnmoz!ab=@&iDuDR|S+Zcn8eqH~MV3&76Cp=UkY-g%VqMC^ z2yIZQd(n_|Y&WmEBt@hW?_(MR;%M;*e=PcM(aM2XgCHi+5b33IFDJ;dgtascNmdi* zy?O6IF{Wvv0>C+EwR!`Mb`#$FSg8>T1{L*=Ol!3;-X7=F%p}{bwzXPqj*pL_Jvola zi7AYax3JdfAa$vkDc3qZeD}MT^Ih+LuYKb4pTb+;`u7-gR^{sJt`Brp&3}`TPT+#7 zQbaQEt=Vp4ygA0s>I#fB4S}Ed#3${Y?|28F_T(qy>~qf!Z~oi=%aeES;?>t)%ie02 z2Gx;SXY>kISC#cchxd--<1HMwbqDhzx1uOUu8d>4#Q*-^IFkjW3?+ueP#r;EtA(*v zThb&$UY6#)a(;dR_uY3tr>7=y%1OI;=+Lb723^J!(y=ew?RW9tU;T<*bm0^Eh=-q! zD}MFMaNk{bORb)2vpFWsMqO{a;}(11z(HL0w5Q|N+waij&I<3ne;+!_E7-kj7pAAD z(P-ANIDgc-!@i`cXOgC&-|L|m7VHmu<{%a{mWcZ_iJi!mA1H>?APk0HXAPZhhxwpX z2o1p`9|WovG8ptx409>9M4Hsl8Xt$Zz@rO`$dVc-$EOH`_)O>}6*z`0P28P#-68p~ z)E7MOdEB*Y7kk4#uDaq^*tdV5opt6T_=V4X0blykmjIHJ8>cxpH;XdT0mA#=^Y8Mw zi!Zd*Ziip`>=(GYx?&``*6pIRwu(F-KtPmbKwb>1$$&Cc)V?^hMyVjgMV5B7+psbd zRCcgRsHKR~;6xak3!xV8x(;dT(QLKZZZ?tn%<9bs9Ki9(2@HE(UU$uP2q8plQq`U4 z94ib_g-ES#v0AMuY0N&yaZ+W&O2r##tkoLyp6K=lIPH{^nPzn)-fNcBIWseZwY3#% z*PHgT*SyyL_1*6hKzwi5bB{j%ydMsS!)iIP3Jy@sd8>?!u9HwI&3WX3)2chIDpiva z>I$wJN6Imy`N%{bf%;HWxILF#f@(HddFDpNq9aQhs+BDM!f4eWr6%H)+dZUY4VBms zD*kMA09H)(iZv?|1&A2&8YO**h|aI(s8#f`Qe-Q^-XUJ|9Yl!9_89)*pa1DgWm!y- zz=uEd(ek+Cw#cv;pu4(;wazLR7ne|$CCa>zxuZwfSzELD`J-G}S&gfMff`Db<&b3_ z;)hGksVE}C(Zn1>>`@6)XrP9G5DaQTLa97)_imhW^2y9<8GGFxd%Zr&GGKLOm9w*R z&@$$pLaCM4)ME5MR&a>XnTw7%mK>F?S1v}WYCjwp(X&R0G+YXuIWH6!109L?6d&8U z>-7ec#53`Ui8J^lVYAVan{K|DXFmK)?73tQzW?3t;n0!8qnHQOfNQS3T3`F8e{PLt zUA#}QVdF-ut*&sjyNW@7$TUqfm@qJ~EXt|?AXbGr5`pmpnE5om!D_J?H+B!9CuSxVs5e_kvl@HdE`k=!(iBOWYS6%Pki#_4R0Z%D3_9%h2T0SD{lUQI=I6P(x+>>C z`q4P=yhpJtbNVEOS7$-|%;y^>jIWJ1(;isz`Fuwu$_U0NpqCy64$oF0+|kCWnwiAlcZ zHGj%Yn>OL9Uth`j*?DAX4Y%BS3%Y|o0l@_qTmTQ^^I!TBKL4dJQW22(2F`obS?sO# zaP_rUhkn0T8DWV=t%iD5v$bBAgW&)Kkfxca8Z87QiNg)o{1$I}=i5+}zzbjSBE0fX z{urIrH5$lm+m6GNF5QER9(@5fZ`%UrJhMg(n>K7@k|jueg2X4N*P3XzT5OGtvEHbm zmSxO*inN{}Ni!r_#&%;2&9Nri?WVMvE!Jxu&BmBEn=RJsHOm?qQ=-J{7z^hs1`mTFO|-aD(_v{+jj!_r(| zB1d0jWXUm9Wpks$%!t@jjY%T^g%#Lp9mf?J-c>F1Xq+iVsKmU$+z)?bfB5Gw=QFk* z&xa)q`h{6M{*V3y|Ms2l@F#Nz@w?|;gk*9fuD<41xVzg!9s>UM%yam{?|vWUuHBfw z=2~XkwwblZ9h-I8vU5B7gFX#`(aJjJ zSaQ`Vr;@}LH1JR;*bQp4rnU^jpc)sOMfzd}LsD%O4zMO5D`qq^Ye8hvpo=j1;M|-Z zo?CE#aNb#X#)d8Y;h_iZ#+ES5r)&W~l?e(k%#yTn_jb_qno*W+}%6hTsv4@IqGTIg6f82WMA4iQnvTnwV z#a*PZiX+C9o|8(jwy0{4F06=d^|%?3E#FcUzMcr39j5|%B}bU38`tV-!)fZ!{oFK%hJ>WoI)G|kPjuP)nNG&ns0nL{i|L{-Fqv`!$&aa z_nCwoXtcn6`yq`caq=!$y9HaASNWeGh<1kH;~x+I%%?|;fCxYpl+g&n5t%<)jfJYf z)*Yh#KK$oC0es;zTI@dv?}b{FC`*GBLxiPOgnS5f35uX7v|v%>9Fpj$v9Au^2^*U> zvO|x1_w8c|;l%VzOyFpMPg7dr)j2Wo5f+P192Kq)lK4NqT77&V9KXuS_TW{kRb$UVbEXr|sIgAlNJd^{4DOkv{a zTs#{k-ii0A5nxdUGngvO(OldZgI0GI8J&z`$~K76j3bj|C`;x=0o54iu_{R;A_7sy zGrL*z*Q$>$Mn!bAn?fUn(TkW>-9&073DXeDILY-1z4yrK4JM7)58%^`5R;+^)H073 zQ?2efRn(bQP}EsHOGPCZa|oST0>?504WSTKB5{5l`A8Fkm4qXUcW0O*_b?V~S(U(om0)*h zNK>&RhgrP&O|<>{VVkx?(ga?Ip%e$U+mfUiN(h&`IUE8+!O3QwX|0AHjGd)L3rUTu z8Vg&U0p1xCrDY@%2r`1cAX5)`Gpo^<07w)9Ep4lF+zM)95GzZ|wPebGL=rj>nFOR} ztcMaU?-+(d!|Iy)e}9ko4}6fA*+S+yX+-WbI+lz>9omRM5pVICQoIOD>UY1-Ff8Ct zI050Ozd*&CljBS~M135qJbEpX3Iq}ZL zR&XE1bVpC0B=Bj-KN!fOG^!v&Dq?h@p1jp-M63g!Jq#0 z3jpxc))?OV%9oqF^G18iXFugWU83sa}{Q+fenS*=p=4Yf|Nft`?-L)BJ8#)5+fF<7c6PB;+lkY?h0%$KkAJWvaiDlO=K)D1@kExUOwxpjPePV>VUmK5Vn%oo)*1~qT20on zx;1MVT;k!K6Q4RZYE9G|4K&7DOnic}D6H0Ka&mkeTelpC_V_qe4H|90$it9t`^UG- ze|_jbt4G|AEJC-N_&R_y-&e2GEMrk)<`!5UkXaLb6^@F+DknrIlqm5s0eh zWho#1*hlg1cfLcOe904d>7`G{U;O3k_`1LN3#=@!u-h48Vd-d9u!wcma~v2X3?X2c z=NR;RcJULQ$UPT74tLyk2lBFb$d&m2_2Z#NK^CFJa4>`#*lsn^A9fjH_aJ7E&ZE21 z!DAnNo}rfT(7{6}ilW-QSsCaBAp~Cjz3(DTGMsS2c3WOrll$+#hpNi6&VD2>e*DF_ z!WHBg^ha6?8NS(7dTZ(EUVH|47<>eI)i^3A;Se7N$)>b(j_E}ocpfNw2rinR8 z#5rAXWx3}IGQmwm@H^LTLIgFLYRfW6=aFL2vW+!=zFc<_M-aPPhMae8`^ zciw&n-tq2tK~=eZ=MD_I19Unazzk=cc7}ZVbDx3*<5gGwns?rPHyX9NcKQRX_Bt}? z4xnbDA)v^IDAhny83F95R&|fFl86}*CUh8`Hz|Mx1EH*(`$CBWw)oj}RD;n88}%B- z+AU_a8sg9*W16O*IM!+zes%TL81#D(Czgn3B5CxW2gS%^C={sCMB_GW(PR=mV+5S{ zY83{%mSxClHT2gys5e{OvTZYHhDM_WW_5Gs*c@-8*{ty&-}W{KDvlgEyz{A-KIOdu z1`Q=7Mw8<*B?1cyx=~jrt8&b^E-5RFNSwr>%EwgT*Q#-dgjOTQhzG2~9~QG+?uk#l zq_V@ug)Q(H8-@fzl_xcOh$4@Ns0OjpaJ|5Ey?||Gm)E!h%Lqy{`fyjgG?;^kRM`0V zIc9Z}N2LHn*n)$2MP+$ImZex&TH5)|Z+!bL1f||+;6Fe30px{p*za4v*W=RiDmtqj z1XJ|;eLS%50rdKP9654`y+I#|IhF`k7CA$y2&S-LGz8P2pd-};5-GG)Q&o^f8KSAQ zil*+^z8xo=c%rE)hy6iBWE-)#u!#BD*%%}hvB-3c;zK;lIf<>K5knVocJb^Y&Z>k| zMX9Y`b2XSF0PpA|VqnC3q~1Xi2hW5)OOa-oIT3m|X3YjeUSND`(vHl|F@%6qcAtzt ze97Lu z>t>1b^v*+s>culCN7}6+S`x?t2vBG+%d&(N(u+sEklyB zU`j2`LMSEAb1W~fGED{NoOKpXKlK!pCa7g878V!n1<(6k`Pe5uf<{_{h;V*k9%{ta z4IA;-Z~QBJ;fr6)7ysVx;jX*xl*^v-B;0fNefabjKF6A*sMRtA1Bd-6?Tt5E$cr2c zi%S@k`A8)jwVPwhrVU7ahNYEdmV;QfX3+o7O{hv5SoLYZI<8Dy#lh7|f{k~{0CaWlQ}(HC;>-kY#->t>ws@H6mN zfBi<>cKfXW1Y=|4cwYh!$39PRcv z>diXRBt@3hkfa{XRtuA@F-%TRVsc^v<6~oJkBy_K8#Cas%M~9b} zsz-EP#vbKcDs^H6+o+Vs_}z{y=eAC7f$*5tU8UUDk9AfpzoWk$8F;x~R$VFNHfolu zJah5NaE$*FKiJ18$LkYETfcEsL-J#XO4F+HUUYO~RhWRzV5-Kye9rSZ71aQ`nSJ~)$SS=$`UU)`3!vEmp{ka#tFOUqaSA& zYco%4q889-HY{m1jHJ|CZL4kEgy#0++1$9n>fwxpvyeKE&ChE120hhPyxg87^FZBft6G&*OW80nci*abc~6dwZ+6-wgMR z*RiQ|dd09W_gTQIK?i`;0d4{~2H1*4dz6S-X2;qzl98)O9BW3jpqv4$5hG>pxBY&& zeReUNj5T}dnHLeOtM=iQ1;=~uv&Wsjv%Kiy$J&Q3|B()$Ghh1cjbm@xv*(9-Hy4eG zu!LeJ6hdRehZ8aCu`7l|fn@YKj!wJvO;8{j);oWyx+VaG(~(tRq?%U=thgo!V@Dmu zwA$C>$l8H8Mq4IfCT>*S8H-TqOofn#^xES?Lz7_0hQIH{lsFhrIf=pm5v>j?kwmV0g@>nkF*q2~k*+TqQYF2Bbs7?yr2-}tc!PNYSu{YJ0!SEH>lsOB zf&_+yw3KiK%u*N{ARP>;k(pVjDVSI=s9LScLDGb&n0O;TQ`8S1vi{GmGxLTLFT``=!J;)5Jv= zDg^KzgCG77#lO8vlYK|U?c70|8Ut5Xz^sn4J489m!I^0|C9t~2K*ONdLs!kZrLxcx zB?%^;t?5bD>U9V-xYUEJA$n{(KbCGfqzO$>92cc??q zb{?4*)qa;rt%2rA+i3?5;NWM!im_&mddFRmlTQGj`V2#}38d*rq{YZG5x1RceSiYp zPV`y7>wU<3i*S=O(2suvMWX?Af?}-?%Yd~K?1U19#_ebTv%)|RLDLaVjkWPQtmd$I z>pk>G7hs2GfxWkbd5Ls#0ygNvZoAdw{KpXE6Bw1h#S?BNO@uOzfL#KEp}gx(^gs9k z==Hawd-bnin>MnZ)ZuzLWMUkv-8Ga@OxNou0W5TS=qJX> ztcY_=nmLLC)f9Ost4`2rj}<_wX9+@>YKZYoqgqkf*Fi%`RYM+G+&mTtR8tKMMNlnD znu}ib5v^p0=v{$IYywM=9Bt;?OQi(06;*h<^QBZpX)Hr&WxtRRD^*d0jqBegdDe{>ituLtKw0rfFlSoYBh{473g(n z?J?SKuY-Q;Ye+V30c#0@5$N|dq+UE7G3c@;)J%;b1mvMW%ZU}kAqNH+91|hBAw=Lu zJZe?DNG!?-7SsW(k;sH>scD^bBy~KP9N(yEE1@K1(B7~IQ{`BavEhlV7}!LTa-!Zu z*6C3D17N934;A-MZ-q{6hC8qi#KY{N004jhNkl%p7{FZcYzBPn;+d1!W zbQo+^4MU5q5kbKqqNz*hy+hi_w2{@2W{D+P$|Ox8KDD%-!g(j+QiEf3%!)Gz11UL4 zrAY~~GHB^w2nOV0l9MtNCk54VfH_Syh8$G^DZ$wJ3s^K_k|`qMFo=l3qN|IewFr`u zT0~PFlj<_BRHe}(C_x2;Le!jcRFPr6Dr0x+$hO#g7LU1R-T-sr%v9ktPU+2{9!_8? z3`VnH&IwtTIyp9#?D^pPZz@V{PPoLr@`l%!Q+Hf1KmDI?;cd%>p130A$sHELg-I465T1ZvL&j=gVKlIkgF#|4(n`sqJxWou9+|KKMcII{O?v z;i3!iz}}m%y0C`jl?B+`62b>RXoqj#OLz8Tu={z>!}g~?1)XhMk#63EuFo)(1UsJa zSPShISMI+L^G9aUXta^;J_!>O)Ao~_e#=YFy#RMye?9J4Swdfc6UR4T`{rrfu*JVoW24JV6;BWwN$*_OVn^FcbpzJ*Utdji;u=wbWt5|fS`7ZK zCw%P~e!Y_KM;9!tD_RDrsG2lmblN7MI8?0L)?CWLaEM;7 zhkt(i+wGdGuH#?5=`ZE&Z~GUV`S6G1t6%%7sVd5{V9-D_SmF~VX&t2obUPg+l3CVB zq%>e=at14FYxwBLKY>qv^dok|Z-2{YT=on+`#HaZm%aSOxcH)ruw~;W`|WRj!y?2g z?$P^@ibH9NyeN40-S^nWnazC7t6qU;Jnb^<-FqunR#*OCTDqfyb4m5auj64@mId-s zQRD-(TMd}Sv&2$o6-Vcnx#yw_LG^a%$U%lsrKEs$u^#}gzy3NLe(*3(J?&JhHybh- z4(!OGS+vK;B zeCUV;Q*AZd><{}~U0E~d9L->zZkN4&7eRy3fHH*mktl%W#*1BLl~pD zWf9;UsKJpEtUnl{+v{4ICM*Xzx`P3ltrjSxa}v61J-Ox9y?Dm6pDCxGcA5#X3Vifvnau#8`Lh)p! zu`{Mv#hmjL2+auu0_PlBttQmKP!>4hgcE>ZVRCZZ)#`Qi9yBea*&O4Yx8I|;?7i8n zv}}6ghW|Nv_wGZz{vb-!7AomFp70*ZV2=H=Rh`i&-Lmd>jT1tx)-*Xbc?6;BNF_73 ze!q8@Ua}{yXw@>MK`RS;RE1o{eysw?^^ZtXS=UxG0Gw-ouH<_T!GjEw|iq-micCtCy(h@C~p3Yd&Gm2 zlC7<+a(QJ1vqxvq?e(nF?Q&sp!H&+(qqnwdM~@z5nHN+93&VoLys)4pGz8NM3*y#e z0A@jhsA@=(go$^|^C3f7LaCUZn8B85_X*M@LoH1$%`zn7nWibz zdS+RcBFj>%H*2ib>RPMUQO|1HXw<~i&>nALgNmeuR*bvx{Kx=39j-aAGzPJmLWrsfkTV~r-0D$?kDLhk^9BShhy zpxthw)flHZTCf1`9FruoTC0Z2muX4j*~scF%A709%c0xtyEJuNSzf~G+M0Ri=v;!y z$ti5uyalA-$}4_>$3FIPy!E!dFeM6$iN>-lt=??%V;}jbZQ8btZ+iV-!Y2v$JoU-A z<<>iK#jmcw@te1qrJh=mru-#r>Viwp;m8VVqzTidL8vz1Bs7ofcHt9Hl~SWXU6w7NUAk_94(rug7OgMJp4t(!Lzl+=Mxf{>?_E(7GPJrKWJQm;i@A%2P z-(^2qn&WrpmhpmQoMl3Madk;&i_(Tv42GrsrWi;L*g16iNWg6bumQk?5aZ%`vLkjF zu{H4+Cnfb6G7419RwI;5QW%?nwJ02;NDCp<09h-BELVH}{6>wBJNefQM{Wq#_*AM==ZH&c(5p(f&!!s0W7P!^&(`b-8u4Ha*o!czw@ zSk+o$aH;|eRcUBEv^xV_^vFaZ9)OraOkqYRW)7y_GeVFBNF-L#I%g^p!-h^&g)oW+ z4>O9IgIW+(5vYfW6Sah9o~8l?&CFK@dJ;-1MKt)Btx(WH1~n(j#6syTn9$V0pip(y zjU~>HVbL%{)A;RMQQ_nPn6sc3&1A+n+&2}o5{4jP3D^)oPC-GkFx7#Xnv1ARrJ0$= zVFeAUss@FpsgF445PRKdLZhdeh#4X`gk~0mL4_gKSH*<8YXXvrFo_vuWJ1Xhnd**Z zn1tB`#l}521JfB%-9oi7YN%B#UllOW%sUIU5JH{9Jh7sv*>Kn>Ix8*db@ghx@;~ULGsE!q<{FsZ2s^5 z852*xjDC8Ya5c!E{4tVC_dwdI>IG+;jE~X%>8nhS-wpl2x9HD58`y9Hc;0z1ILK(` z6mtZK3+1uF4+N?dCOdYT+qMO=dX%_i4{X~8ll@1?xg)SVhbj@u5{AVRLU~2)Ic>FQVQ~d z`RWprq|RhmhyWPdxkHk~u`F}3qC{G&q26wr8IZ57GV}}P!@jQ0&%+QM&MFC9t&YWe z?&Q*a`=rQ+mKS{@6cklRB7q=XA`p5S0?OeqI7+PI6ClzB;sIGhfLRIG9g?Ah&@2px zW`i!bj*p=+9Kv<`=r>ZbUt%irXwgynJ=BmuCdZ-q0J2)ZJ?ROMrbp--+;g5wZM9?A zFobxJCVUfAh0&{GWwnd8G?|Pw&CSg+@8_^uiu%r7z=MZicids_g0qQT#{<3r)N7+W z>}Wu(a8;$U1#s9k{Oo6%Uie5!?zs=y$tR$;*aeQx!oTVdk^bBJF#Vzzqy6)rKyJGi z)3usyJ8?HQs?Z;u#}mK!dHQ<~=){qOvX&-TM&Pgv%=0q3$od21gPcVL<@Ep%aXgf2 z;{>TiujfLMBNQdI4A8t}$P0Ba3I#!`&I?DlB&ESw03v_OIinM&8lW0jsuDq=Y7$hT z8cc(Vg#u>LT*QJ@Git=41m~S7OBTZd{eB0^EbO1#HV(5hf0(o2vHHTS`uz`=OojFJ@&|C~bOiP&MH0x6}b803qqsC$YK>#h3 zViwGhI#maQ6AMJCCZ?WdY8oU#EaQ!NW`o3nIgf~2QwjsjOu)!R)vEu6EMn9{qoGfX zsuaK^FvL9r#;j3in$)us&p)sH)DM3AvhUt{%kKfe4bOY2ZQt```N9`I>Hhn{qw>;C zTlmDR&Ks8&O>>d`i;MWx@`_xm0SSR=Bbp+pIY9!VG_xeC5HtWaBb+!C5`pr41BKpB zca9s(P{J56`UMIb_OX#>N1c=6{(J4w3w@r|s;48dKaWWc(e3tdhz{AK9?j;|1ctp1R#rQfZkndwya~zVgf))a z!P1mrt#3(ljN=niKqxVsU$A^;Q@QlxU%69eCUD*Ve9L}2%vppIhYsw=zy9T0kUwxJ z{N(U{>8-BdHNW@!_|A8~W`A($rF_hpXX67u`T^>@=Z(S|kTn{!OE;r+E>{h++|%HDa2Eh#;z_wWDCLR%za2VtnkDi>7u!r2=hQ zRrS1{-Hn&3N+hffR#=&Y@x z*Xe>H)@nAnapMMzH^xwg9Qj}fHN#4`!@Ya=;$t8CD8BOLuVC@WEPn4LFTqou_B8I< zb20LMz|DJatnQkoMlelMc=0Gh$-D2p8`s}(J)UyuCHRN8{w*$i^kdMdwQ%dLw?a*; zORGUOR9S@o?O+el*$xA7+G(fajFV0ZhmOq2;n`Wsd}gPeb_$>O>}T+{+wZ~3+De5n zu557CkJ+QMxasD-a=`_U#_^lCh5HX2a*0c{mNj|uX{X_qTW^>B2M;g|2grv*9Tr2b zt#*0+Z*G!v&p8J>cAh{wL3?6?S(agLc9uW+@sBY!F-by^rirFrFc=nGSz5;0>WU5q z17|@)f7m1G)u6Jpyo^EKr+{qK8&p~-1_fQ3QlKz`MP8y+&xG_SHDIFM)_SduP!#MB z2F$#}bD#S=+`MVC&CSnaX2Y~~R+i-FSNsCce$KOT<8{Bak9_ju@nsM}tJcE7!v_HX zKmElou;YXs=&tqf{qO$(2M--Vy;;NB>M9nN7ue}^*zfhN(^-`~FKAi;z61zL1XGG4 zxFj;bV_>hEf@yUr4Y4RoM(0o(yh~ytpGHRpn9&N=LJKq+O=ek*QmvxxRtvQ(iv@{dnA_CU6vcZi zFE3;F?p<(cBCS>%jYdsEsaRTE;?#y2dDdl@@f~k_8s$rm2t~Oa823qy#bKTuu1>6C+J$v?4K07y>V^{Lt zu_+=(4A}KAJQBRIPUWKsf&gyhScgRcf8_48%5o2^|3OBz-%>4sBWn2Q_l!$i{HCK< zQ{WQ^NjxU%ZT#6AU;pE>C?^23AAIjSj?Qy!t;6nGAHzWp%PVUDjJ-}5%S+3co15cG ze+|paYgUHB07Fp*Xc?fdHBScc#p)V%#zfyG-Hxx$g-5qd!%WCTIOj=G@DJ#Y}kmi&piw8 zdgr_2>kv6UW~%(~fBl!e;q|Yx_SgiMR#%WF4s)|dxw5>763R677E{I|-e(F6423eQ z*UTqAI&Gm9bIqzr4&l<2&M_j?f`Uxwy-?^7Oqu6HbBRY<%aHenI?M}c*6Wy?o8|o6 zQEb_=nbVUqc+7>5!L}`%3>4gc<4rv8g2!OcAHvL#W+~D%MLrnff(ssR-}u%yc-NhG z@$;YhEH-c3W-ol@`no@Z6I*bqu#zth$JYM0Gc6ZNSHn5(h2d9(F?`b&Q8KmHYO zeD{0dPC6N3>o(Yf`*GbHUWLU$fh!i4cu{klheLsH^wvyF(IRD06%U%)ZgKMLMw2J| zlw!&nh)HpnBvFT=bRNu7G$iFrl3~l#3^rzUOp0*ERF2Oa8lWCl<1EbvG>(ZAN3a`D zW_H!WQ9Cs#o`2fI>_RE!RrlV{iGv+`=|BFtYkG^W{Spl*HuKA2nHu&(u)-Z9O4kC>m=wD>x8<|b-+3JQS}H(iFaQ* zi9(R4l8&+WGzKEY5$57W#ayJ&nPa8D5J*Y**g2w!fR2^cU&Uh`z|_o)G%v(Peq#bPZy0bf1yj-VfXE-Emt1H>DYBJctxj8C(9VIl@c(81`WB$4N3#SHUH25r0+5Qa zZe#*76SJnmYE-QQYzGZ(DB9v&YD8kHX|N!sp@uRfs+J-;`|E%;)e2u58=ur}&s(P> z3h}+AC0}%U9G{#(Efra~;Z|Av>KAbM2j6FRP)L?#F-DkpIuUBCjzM>*?(Y4RL$hoh znWf*o1K7R|nl^yU8|xW)&f`qZJqOq{Nj&X2bQeCB?)lFHU-UxoyvG1ZQY|T?L{u0d zgx14PMg*!jYJrf|O|H9v{Q8%P;Q*YSB_2Ft3?L;%0Y(4N5#WnogkL%eIq5{)^MMbs z*t8YBB!g#ac?is%z(pZ0vb9`giKu>Cq*azAqJzwdqe~Ldd5HH+T1}LlejFaA35UHE zPMz{Fnw2cpdI&`hFNqcTkb_PKt<77w>GacC76S~|IuxH&&N)K7m%Jz#w1kyG%nU3+ zh*$B>(a16wHIz13>7dLDmn4LiickcU8o&^=EDIJzLCphQF@&i?iXe3mQ)(#YX3=c4 zFf}nouCAexr9j$1ecKF@XFeV7%+ukfThOa+K)!n?THpRQ-1C12a_KXS8)hmlSv545 zhwS{Qj9L;uP8{SYzVT(GH(ZJ0yWaxueE>x;l#6TdjV4Qii~ZbCuaRk;OQB#Wb96Nz zH|Rv_rIDma$H!2*#E|!xbyisaqnDue7jLkYFMomAmaUM7?FO&360xsLI2P^ z)+F%sn{Q@q+XQa?;#Y05Ut-r=-z0NC_#qAt2G$AdCL6|ck|8K)(L1hY$|BEElwm!k zY9uw3u()7qRW=?iS1!iCU+HoD%>vjDGO70DicqnOUq;e<)=Oi zdCY~>q*nPB6f8&4Y^_o&2B-kb3!;m2@`^u#nP<5BF65JA zOrG&nWN&+qGI6F~`Ksyc92cghZLZhj(LoQTOIdgzm?ynZC_xetpC(ANlxdoQ;^CdB zVtW|4)*rDyuHXn*AyAR2@v8u#+;xDVoQ?Zk?nDw+HN2Tu!AUU z#lQ~DrhLj4h*FJ9rt}stCc+u#u?Dr$z!tzBfVH5Ky9752am54o>+eo(=2N$Caz}^Y zr*FMQkK21UAMq!Dj7Oby9)J4fFWTJAx8MnX{QK0?&cNY2@57euTM$-{a?@Flv<;6s z&t}ek6t-OW7&fn<=wio_n2u4o z9#uKY^*+QF6*HkmQcWL%eTfz8>-Rn)8p*-YP7?ctqRpu~v1&ECUIz;qBo_HbAcIdt z*3-;{sWJpLg;kwvP=x`(gfxUArgaH11XYDeo)4i~jxaW;XDK#p*l4GpdKwz_I_|#r z9+pMPEt@uS$BrE~wP8j!%}kd`)|6haYyDnVKK1EO;NSo4eZ1^B&&0<+{t=XeVR`Kh z*F#mM3?Y8EKDveb{T@15z%PaI9Z+{y< z^O?`_VW*yE|L5=inhSFacKe-ovdD9qSs8*#;uEMSL=C-OAK$(Fa(wOU-@qdu@d!NW zl0CTi;>Y8RQ%=Kmzqt-&87lABLqZ1sJCkoA1kTSMHAx(I9Cuu3)f?`X+i$aOugBSi zMLzy97h-vN6-O73u8Wfo{V^O4c*U=-)Ts^AJaNZP6lKW=_V0rYO1|(#FTfSQ{5g&; zECf@7nzASZmlo#mgCG11uYT>T)q6)zDU&p_O`A5lnduF@>X*MnuiHbZK|o=>o|>7U z+v~F1>2PIrRm!3S6H0fji{WqxC*CrjGB0xshq*W(H_alLRmuQJqR8`@P^cvw42!5? ziL>+1JKq{(Ej;+Ze%ZKbqdD*J>tA0fGgFf|^AV5K3md$njUN ze*q2!zta$EVm+LY!JTBUFmAfQXP@TFYV7w1XttWD z)#|wK-g~gHuz=JjrWWYMn}|?c>{WEBgNsy}nEV1oNqPq}dZ8JTMBpT`vKXM&XmMh4 z46{dPF*QAfcB5^rR*SVpEw;=%C(U{d&1RDy{@6#@S?!ibkIwIW>ZMQm5JaGAP^}); zI0J@Qr94Zh@R$#IpevnnwEc~+L5t@@3kv%T`+R^rim_flMCD_mn_BE%ZbW50&g+8y2Q81abWsoBLB zWo&E=^YgP4-~9Hs{uxHgn%>^}mVa_;IXayly4^Lb_IntXrIm$pb#)m>4j(U zrKy!^magT=_Ii7jR4fDC6}x~x%A!= zarBO4oT|c!h$POO_ejzNi6l&GHDqZLvRWNUmYO(Wns`gInu&tS zC6{n!W+RW=ejFypCp9lheEln5<0Vgh5=m!ZANb})cN_NB9+TLtgrU*=}$y- z#X76kt6Gyi$GX!Hg&u`E`x3-HUMFilv5e~yy{vOn@7CEAHDPyc;`Fc z##g`QReJWhkK)(9{&lh;a&gzQ>idgg+`FpWia%5Im_n-5j zVtNbIs4(&rIGUj!3+h*S#&|+|$Z{!Uwb@$bH>(Wl)z^54p?)N%j1I5Slv@F# z4a0!vdn zfu5iI;+NPw?IfK)GABMu&8I0<1g@4bbE(mL=e#$cB%lC3Ns!euky;8J3~70Q_la%T zy^}SUQpQ^LgJ)jGhmEyx{EJ_P?3_m;%pSqFp7u0Ay?yEEQC>7LfieVqanL~q*f#I+ zpaz>0$R)M9{K>W*mX&>WFbbq73`$2JNfR3nC8a2FAkUG9T)mZ?F9vpx1}->ax0Wga z(lBKS*inK_0yS|Mnud;=OsL|<)fHJ>S(8VLv+Y{qb+_M$i>J5n`OkUU@YCP<9`9UT zI%mh!=FdKQ=k}F;zmK4K#Ac{U)f8tO-5{!LtP{pM!OEutQY6-TD2=XSmV}X0M@HxO zxaW!!c!SW)5(jZHh6)j5DS)dkCDD~`RXZrnSCB|YfmBbq1Ly_x5cSms!V4HJZLxa8 z#iIaHRs>z4q+;-ZCSuVmK+=_GbgwVu5Pq9>-OKJ2L#dZ%c z5l06_-G~|;>jt6GQktX$5`(2?RtKz3qOQt@0ZlX15j2G(gIP+0h=-U0X4*E0CrSw+ z)HIZ16iv$z;F4q``h!}UrXG2TZl~iiE$OK;KnTNn+vjCrgTau^@hP_2ZF7S@T$-9e zi^9YWl7!`2AMO4CHZuX-al5&n{)(JG0G_auxc*Au>T7{rCkdu!6uAN#h>e>JX_N47 zWZ8`#ilBrr0-&vm`bF_iz@X^&DO!SG{xY#|AJAw3iz`5q5Rr96sKKWmiXrlwZot~! z+c^8+K^*FKtncE`+XNVhtJ)+S#Z@xCl17ayTD?B%wT*Mcgka*BBpD@^rDOHTK{PjR z##yg{@H@u9S1w|uCD zQiwp93qcDOgMu20h}I}dg#xO9n&+Sf3q?T4^C-$|0P_MCN@fPDi7^XiM+ZHk+q10K zF;5{9LAKfjRu(aT^^F+2;bzDU*F%?9kk)J9pZ`U4wKi*n7ob!?s;HrFko&lBQlAVt#>P_ioD4A`wkEgg931GcloT8sGAf)apHKa+;{u&3)yoVvU+{_X(7zJQeCurhTZL;39v33LAy1)}ILUQLp!j%Yf%Vgp$9rP>>0yn=v-L@Hg-#aMJ zdlBJ1;{CUbL@-*!+i--gFjAB(g6i6mal>YjO&iUc3Eg?;BL6>sOP+M1xc~bW>pVEi z@n2p6{N78=ed}usfBi-jhiBabzJdLD!NoEse8waZ%f(ZiFh+BoxWq9{Q%kdyE=kqV zAx%6a^Xk%+E@6mdS-=UaBdCKoffEJ_RKS8jUWw6;|M@eLvZhoB`!=T}t zW?)|MjW{?(q{ zy8muF{-&Gdk#GJ>v`^fQeP8`%dE-Yv?Do9%Z_(Pi0e9}b8O_Zn*p{=-f^FPLj89ov zCAD3x#iZGSPhzc7P*!e@N~R8gb6~4Ai6aSY=hOGt&aeEpTRLzUccg+ljvV5K_PD+O z?eB0O`s}BWCVl zS}MZjF$g9=iOm&CgTxbPGzSsuzE~(=7ONgc*{jO=6gN86(FMvXX+2^Vs>g$)M$ve+ ziW3${qAKCoeEJwOXr4Ck~ko9sn8Vrj|%UD`kW_xUm9>V=c9t;N_I3T@YAIELo zimB--96o&Lf0^P~q358+Tle0=*}21f#F=OE(7^+^@4kDiFy%9z_6*#9*PXJkupp$M zo~87O$I{XqzWBM%^A#_9nfWwxf)b=)dS;s2wr<4@zqtX!VU9d65b}~facVS{d2Yq9 zppK#s6r|!93PliQC<{YSmZhRBO2WX*Cr|_{gV7jFOS4|TN9UZTiI-DOJq_a%6PTMl zjK)~Q+O4+D&o9U?ulN;T{>qo**T4QXKk|`}R=5sW>O4FB4klXT`1TLJhfwA=d+@N{ zy!RFYh9q&;AN0ArxPl@tsA^O#tEIQHHhZcC1LKi69>7I32K7gzua!lvpayzD>O3fpfY8)Tyu|t%IPpSdv~_9X6Oynp1ddOQ0|s>0`q+BhRyG<9G-`FG zSq&km75UI6C#Ud)Cp?iK``AbGVUbUsfA0DJ)fyk`=jAZol7hlH!c?I&I6GDjVWSX? z0~ib@;UPVu5$|FnVhK3%z{Gz)BB>zaV%#N9+=F=1*LC-~jSROHloeHmT&m_1Mp3JR z1dsY!M^ubx*o?7&s>IX;l-Ro%@om+=qXBdnsZ*z4Pw79!E3xna_L?4?p8H8T5y`w7kN8zk{`v4uHVU>KYanmoPVb1k0p=rso4EnK8d=hVd)Bllr*04c7wCR~?+q`)Tj?5pShhsqGPnl9&BIYS5 zLO@v-v|!AOf+3U!N^~5*=bX*V zCmIl>mLzDjTDb9s-^x>-@sw&YHcpIqHk1n_hTaTb&^cZOTK<>9BD4$$z*KY2C2`j!92v!C}I zZrr#5pZm-gc-hmQf^U86o7}o>2XDOLT07&+Gq`zXBYVBRJ?8xL?4^J7NAB|PT@Ewj z@y8#JC+&F>iV$$awb!ty;#Re0%~n@dS%k7$Xh)k>9Mw1>27>{zB*FZVBl_Iu|1NiK z-@)%*{v9(=#>dBa>dB|!)KgBvtAkH}^-Xlw$g#b7wa1q~J zl{2y$&;Tk@iQ;M_x41lHOdeN@IGqJRW5q~~k2}_nsMQ)*86o ztuxX`E{Uqu$||x8R7dRPDic>BX3PwuS=vKrG7tHK7&xM1SAjgxgaNS_^M9WALY%NN zXU%iZlbh!kdBUU5#V>#OKlsMJ`(>j6|Mi{^=wH6=AMLjX_mcqs_3Sfo(Let)atIOx z`mDy(Ily4GT1I9GU77^%9eu6FBx}&84&pq^yhNT40R{hHt4K7s?5II&j4`b&ZCj!28!-e>r(?ayvAdD7t-$@=uFaN|0cjmkGzn$^R{(fZ zG>wvwC=E6=#X?ycO2~7w8kUAVyy=%$mA`k!dG^{%_tf9@gCFq+_uX~ztIs+6!-W&* zFk~ zdpsL!Pe`qi1cLRV;Mn%#q`7GWRt_AL&V2{bgNk@BmL;5=p2GCRxVfbjf`m7quPQDS zMsajy0jzc~oSS8KYUYT<%A-V01;$z27>{E zZHxoPCKwyz$2K;P1135UY;wj18)Jh^MnpvvP);qiTAjNqSKV~Z-fR6o>~mXs#(2lu zV=yGtUEN((_wKXTTyy>=;;pwrzIPpP{0Q;OzYI*TC#n)?wrUhE5-Nh0TqOch>;ACO z@$smKHoc^LM)-p4&MLll4N(mZWuT6afn`Nh5f&oc%tUP7bPxTuEj;?Zf5ODs7oyA^ z%VCAC_g2MVC^94nk0B~8BzHPRe2PsMxrs}QewWot{-T{0sp7Q1u#85lfXh8YZwcjU z-DV!>9y`vmKSUS~%qV6t-PtT^J&=f53^YwhCa6M( zrG&DgX;6)7p^Op+L#QdJimEE9m7=N!j4={1LPG^srMeiwpjIv{amQH4p7ho~z=W!- z?%4xrwdukBVg5#AW#iT^kaqDDxj+o3sq^EK_~J;5ETOr2!oy-2;lB5 z8};z~f=p*EaL}jy;vV?BZ)3UlfVHxWe&a@9x@~;s^N2iG{^Bm!rB5U!BI#|$^i74- zvHr9wR0Hn4jhL7Q@Aw6V>(`^&yB~h-4CFKag6ht@QQmVO=I?({m-_?vocW`)hwsAu z|N2qe{G=L)DrK4yF&{!wh)aoYF6RjtRF(Q#d)7p|+$7LCzv4$(BG%1WmOMGF? z+bwaKM>G?Q5mxWoEhu9Qj0^MDJ$e+w#YKiepCS%^tZnV~1pEDgQBCQ^2E!pUCbOf& z=xVbYOPIw_SqzoHQ3{_Erd+j%Xs~{-D~r9pt#o^mZ``1Hk;&}U*P{2s8&Eh0IdY7W z7lxfX$wmW|3izL^z{i~ruG;`~dqktCLr5bXtL7G?)>ZR{F;-wO>efwQ*`w^;Z#;O= zuxTTC!;L1Vo*TbZWxSCI8o$i<{qoPA$q~EEY!A)tbLjQ zcaCg`aBCyynD^Fl!d8}RcX0_ttlY#zONx^>ke~gW+N)k`_TU5JhYCErmomS=5F)Z( z536gY&HwjT&0X%dXctgaWa8oekqs97kTOid>k$-({3tyu?b-lo|9kl@Hs z$S++=e(a-=EXUDPPceMu%h25M!I<%Z{s28+zlwaC+e&dN-cyiKGSa&YSzgq<^vt{y zBKLL2ghy%!AhIGe(!-!k_X8oEx8$$jfI_X6^Q_)iKB^WsH2Un zyV4X|6X=MdF7a{olfu`z==3@k$&%A8{d$sl{oW@aCQQp`qnd$^X0>DeL_bT)wXrTs zujxe;lVqi|Acoo!mZ0rsLeSjg*m#`YyiMQyiGTf@8y?#GYykY#3ohpio#Dp^4`P25 zoaBg29(dP*hcTCMGME9}Bw$k{J&fZ%!{$bVTiPuY$gpG%i?PHnR{PdjTI9|c^a;~5 ze94w=*a^jhy*~FNq9F7%@2F;W)QoK!W+X-bV|{ybPDqQ~B;*aTia$U22%ooY2d+H* zbou$dJ+}A$dvWpfW}NZLSMvTFu5&j%um{bfb2#-CzXG(zbj_}vvN{+b8ykbmh|Fh_ zH5zQR8}QAB4pw_G(0q!p6Pl>QnNK=6Fd+)iI(#SEj zZY%Eo#Z7qIpZ*{F*DwDU)*L;8r#$6pSlRoa4(`9(cAR&qv`;-HiQLK3T0f_(j*i<1 zyL>`Y8llfYs%ey(g=4ivs7@!0LUQSOk-U?&1Je>zDoxD#7)SaE?#sv&Z^BxOM^rP2 z5-}ws6V#B&y_7_!5x`hRrZEVCSR;>Nv1V`85Z&5nRR^2u&r$@LFa;)@XP)_V7&}12 z$ZW5U3WTUq#UVhU^P*WARzWokhn024$ECZng4LB3j*m}s-Ntp?wd-UPkPq*D$PAFq zSlc?SjxH=MGtWI<^um|$iYGjQ*WGZvMpHTP$Rm8`JO3}XY(I&g|I8=tymQXw4}bV0 z^m^R@LQGFc(AFOgcx-kKRlkpoYiDf3rj4AOoMF%k<*-5sl?|(kIgj8$Yb<$Vv_j~`t9W887q?dWvI z@V@uGhtGM|Gcc@%xaZz`VJVRX)X^0idBbX{v5LXw7Z&K80OF)QF^<8Yhoi@iqTQar zmQ9;6zqr6q>ldI|=A9@Mre<@q^LGFJdwAL7A8*^XZ{d+c2RYUm$ID;#%lN@}uh!n6 z#}FesopEefzs~mVeVAYU&;Q`-e(QA*=MdFQ0Gphg)^pB12S*O>=fe-}MHx%;xrfh+ zQJpO*K&LZi&N~hVLv)8-#-IpMt=sFfEGrVQ7%Nn}?%q`s3}D-K?&Ps!$KaUZ+8b`b=1m*1w6uT+ z9(X{?VF?q#a9GL!4?*z0a8TOH(vk+P(zenpnv!Y?5voP2-7ZR_f^b?JuvvdVN~1+f z6H!`vCiT?-dIiOucs^TQq+n422eGK|dB#qsgI2qVR;y*EV1Kn|Q`3_?^^{ZXl+(_X zvfsn;xueLl0)w&-1L3@f(2OpFnK6BbX$c$ZNUsoaVEtflNR-dPu#ci>VPUI(kDT7}scHDs@Bw1jV7*XrbL~ zW$%8^dp;SeFfJ7P>}NhJYRaRBk8&7FbXQlS#*_ItA?Nslb z96WSTHm_fgO(!_BrR^ga7dd3;}@sEF~zxzAC$(wGu)gE`=`4(doA$jvH zH`^~gR031 z8*jolulhR9J^y@JU0sIrnT(B3@a)sh!mg9IW2`+!pJi56fq9l;)5eY1x@8j@t)`84 zI&8Mu$Xx+nIAmD^&7y$IG5~^RD??{;4C7-HXf~Ru>nbQhjPTwga{}iC;&XcM;hi7x zJQ+fjaxbYCXw>GQgh=wrXk7?hX9)GgIcJ7PZ4R}oVkEcM)&$gUj6@u;dhDu&b>ZlC zSC{LMq6Fmx=DfCyW8~v7GSzvU(5?uhrp~#vA{^}*M`acxVEPDbRo^3%X~WW$)+{FB z-xM+PaQpVzyWalCT$439y>^`~sq*5}&&02P=965sfFFMPE9BA<{Q5`!nHkKQfPCT~ zKLR=POvI`W4PaIjniZaOG%p!^mQh^BJon-=q0hY0i>$2nv3%?}SScEl6XQ0|9%Z|?F?qi0am==XUnUYivdHVD1QUQ3px|_ z`!iGAH|X=WW5?`J2n?i6L}EMxGXtEd?edvCY260A>fCeij7^)c4a6B<>9pyVXIz%l}b&^piUqj&LtZVO&kE4b8snRMhKm# zgTdFxBoC!a(^d3N>5`DIK8+)E0CRzP&}b%2iiv@R02zfDfE;8-nkQH!&%PDO0?mw3 z3cx&x43s9!3IYYdT+AAvG{lgZSPn|t45nbgR7~17uw@W&w5Af1fVN@Mfs@<}4H$Ea zDv7&h6Xx6+gRC*Jj=>rUALAPIGM;;xiDmE$2M)@^ciqj&(@*Eb*{Au%+wVZ{=$uKr zA^pKntUthDamBRPjqA25^OT#Kc6B zGkU`$LOTLQL+ts_q297%;TZ;jKc%BrPhvfW~1(?*RJ#DY?*K#gW$*k{!rn)3yV=}D+Y z7Of_-W|Pna_qP}|RzoK)SNe=v4n)*ghJdmviLz3QCLu<~P+4FlnUNs`S``q=k`|Sg z>^@YD=KCcz1PZ~Kyn)uiM=-OrC|uvP;gRDUEG=X68Kv5pp2TWL| z*AD@KGI7d5LdCHbxKZ_oSe!eCs;ugaUwVQXK#gjo&`Vxxqjf!EmH`wCp%T>n0%{5h znP;9=RROVv6eUMb+HrVE?6s5+HZzl&Ad|4;P*Q|5C+|jgcGk*a4}@d1ki3~1sWj%y zti5(dv_CL4HQ#KIYNp*D%HxM6Xaoom5jK2-jl#p!)XFO1FkFVH>eTALiUU@yvR-AD z!<;#fm}j&`Zmql}t1GK$jCat;o51oStTh1_BQ2D0bBn-v=b`$}Rc7D+0qyY@fofpU zsVBfR_>Gc#qf1OZ@Db&}Wd1ngp##9q?T8yT(m(MDiQkqh$ zXiTXC9pTul763;+TvAnn8o?B??G40^9yQsui#TwAxaOyDTQ?b&d(=OCtL^*UKOk01 zHrH>&A~W1Ezl4~j^0h!wvnVExF3TgG6H4uX%{-jXG!voZ8J#$KpPBQXnJ<(+r!R8L z8--+rXAD6dy`4yYlWK+vu;7Hy7>n9iICRDmkO-mzMJb|^f|f~KOt0s3y`ZX+PK;Sn z4peFkGHZlKoknv$Rkb1ILREbIqA)o4#BNcCSi=E8XG)ODRP~z59#bIGBnhFG>?aT* zO(lI!>0^wJrn!i-cBc~$Ke%_tZ(a4}Pa!aGHN-x7`i0E;%l4@~dwFjb@znN&eed9Y z`DqoHkx~F019UBkK#^%jy+_(jc zbI0ZA_*(3__G-J}m9OUXmXox1-B0=7KfF3T=a2q`Q|s2qav8PLYD#Bn0xt6=WD;=2 z(Fqw9=8Fs>PBJg>KBw~n=3cWrb8Hk~mgCrggJ`Uo(Whnw|Mq*|wtg;LsVeM0Z~#wz z@)dgBt+(>jwVQeBh3DfF-~ONYtLHt=ZEF^C|Gf{&`h$ zQrYRASZhj;Iydd?0aaOHPz@0JC0BZVRKuZxWYH*?7aoX)xrKS`eeeM&fK3}VaAw0gY}~Mksu2^D zlProHWe76AFt7U_dIZ1ns+aLsU;ZlIe%mi>b#*m{5b%?q{#ZZuu}{bqPq+e~|J-Ne z@uP>_O*h}l+M9L7*p)@(H0pg*(& z2lwNDzHt>l{E?5?;@mt>KjRep&DZ_5zVel?kW0=xS6};@U&rGvzL0zOK7_@EWmMI` z?tfqpzx}`8!NYs^;IfM!k6-_--^S@DpTuup^=(wC2>h`ofyZ#|(syK7mZ+){y_HoI zSpnxWtgNge&mGS><1Cm(%r7ni#+dRlBRDO%y0T=q-F~Zd#@h@*F*`etnGG}chi`rh zzxE$r#h@(FAM{8kY`5EX=)fV|c-^)5)nENJjaG>;6F3zLaOxSSp(qO8bNAi0ytIN& zt0j5SN*4z-hGmh##&0K-(@icEp#+6)c$HC z)av40T52tz8lqz+qDE@{#*h$|0)aSzn$nc)v|DJm+UT@f@Zxdu?vw43$6v~I>(@Yo z+8uY^&aZ#{8*m^7gAziqcB4^8x?vguDbA8)Zz2K(9KASZnX4ZwVwp?zS*p>dCMOv! zFh<4JEn8URnKYXnW?q;%k49dw(JHXKuvA@l{dMy2{)f+c;j^Fj!EQN7J!t8CgQZpy zq#}tCmSyBruXl&FNqpodH>N>f>qvFoT9sVuY9}%oFu+~;v@0JKw{>(%0ThQ(+TGyl z(2tzBYjLC}i9Na?tTk~+`gp77htV>zW;K8q{bfgMPpkKb0!u*{NKOvF5}Bz{wsLNOJBs*?g~~{RxGMxi?j1Ow>Zb{ zppX8rZ=tHFp+psos=-Jn255|tv}iHL7-Ho#)MG2?3V%edjj>ltFGElQ3*`RR}F<~P69TCIZ1E6bKO8km`$mX+ltJ$T@t zD2m)BCMMBtw`nwHd1m8d<8V%hl+b17GgBDN0&BZEilPvR z8sTJoaspG+Q)uLcWIn@r=bd9yGi!P9z(H)^wwaZ}2w|S*7!HS6KeG-$_|cC^!an}7 ze`Sa!W9>HA&&*(PY0+-_`OmFecICeN?*~avPL5&UzWu1mVLjO00YI9~7TWCzbbHI}^|~x$01Y}e)v4aj@FeJ0Ez!-EsRZxb2QRFc=O_xZN~mwoc$(PFzzS<5J(c zWt;u?*S^YEyz*D|>@&{bCqDBTBMeg$Q#^UsZawe3^SE=@cC+~zOSNK;xvtjv6sCno zy1goms_9-Ljxi5GKKq>K^W=m3@k>vAfqm=XgLd)-7ufvqS^39b+^W;Qz(0KI^Y+SL z`DNR)xWEFCf4T5%T=eeuQ8NS%gJV{xcOoVN@5Cg_%w%t7y5;?f07SaJCfG6MuXeM|XJQ16Y^vS6X zPh%k?k;OT&C_68x_5VxL0(}+nC*S4VTDpV6ysPfPs6blbO)a)OhWv-R% zJnvlD@QPQ!4m~2v-~EwBhz-TbVAy9h2qsQA=nvQ|2Z+O=l~q)T*g`aE!J*kGV5Vs1 zM6qM5!9WKGY~5l!bq7%zv1`4$@oAzA#@-5$<%IKfp1KZCr?`)%E10F`tx>jyX-k9Q zAlUIkV7CM|tRwnepw|QD78EfM%_h)lf`cLC-dn&OCn5XGzv9ZLKY{xX9|61|Yc_4z z?;{l6%n5CT-cM!fbwEcT%?8CgbK+CT4rD~ItkE!`BpR0@C7L>82q7@`2LTo-PFR)0 z+BM=~v4nF@L}(TQT%!Jga~E5`1?N-P`Y? z8yiC`GPV8?Ap{PpVBIn>Y7LMB2sKpV%!QH@8#eKxkAFm$zx6fl`JZpu#$S82v~Rf? zw?4d&8&BTB91ijLoOM=Ks4sXvi3<4luV~o0gV?n#+LymV?tg@Q(o<4XUA=ykLc0&{B>OZ;^(|>3JX)d#l=CSru{FNIoz% zBZTTeZrr>Oa>;E*v<>s^5om8RGI1CZ^WdrVAe@J_O5LAw?kyRk{d6kT$5!Mtge$2upv+rV9*;ehXyd zTIgH;l8gY^dFunTE*;8s_GCp{flJ44*^bKuA! zYV3pK9b(NI_%&13dE*;Rul|Xw?%QYDY%>fbXlfeglR6z;hd+-gyx)imq9$} zvf4Y+Jp}xo@Z!|P3ayp-lfU#-%I7|X zAI>eAG+G>%LrgUa4o$&UOP~Alm-79e_&8e++{Y(9{kaIY-W-oTc$b{~>R(q(jMbx% zC<&(|#9#>o#gI0=X&Gaw(lgma(i2(%6CuTDVe~eW5h~DZB&Cyej3GgT9vx3dpa~mE z@1wCbsSiS{$GSBCIT*Blts!aj7L!DWc*59}WT+^$<-S&!;>ezPf{>6t^HD!qY7VsY znKhame;uXB$ z;tP4!S!W@r;g;KPv2T6jTfFCvTXFKKr|Wy(^KR>|c5%<$_p*u=gc9n?+s6v*^_ZPN z&)t3x!>WXZ5(;R4FrbM?v&ga1UsZ{UI!xq7c7#x=-gn=9Tw3Yd?vqdA_rLc8(mVYA z>wgzF-+C+N7v|9$4A?1})~`x=VDE#t_D4UmSH0>rK$d7OE-mY^ZQC}^tXrph?%%`t z#RZPFTP9wlD$A5nD+5ARVOW+J4hAfHJ&K6sc}BCyFpMk*6;y+Wz$j$Z8(Nlo*|2^+ z^CD*>FPwLoc2`$r&jWk#z3+V&&ws&-Wvt!gWly*qAw;&@EuOObbR0T#2+w)ObL<`O z{0o*Eu)Mg82Wj~Egn5|kXyHJvsP=&+MTwwTP>!^)M2bM#!D~1qa=&i0;ISd?@eJ(Ao7yvG> zEaBMEqnKNm=hEU52ZI5s;ZTNEM2LzIs!`#zMN`o#z-O7#M1~=NL18JjqE%H&sDhNk z5>;7gvH_$dMYL$MbFjC((SHreqjL$gQK%i9EW9zOD}mmUjK&Q!Ta9-4|eVKKXng3{18@FR!=;xlE^HhRrM$%^8c)d z+l>~^KId#+bnzu5i5I^31(=n89bKc|Ztg}wzh7B9oY&0Pvn3|lxmW^Av zY4c``w>!);4<}B{fGo@4G6(M*^4!6DkD}4U_*e%Mlam-5A49X*K%NyygG0_nUNFlX zGjVXMb~wtq))M*&XU_?7UlI<+r7K&yud!}Xs(n3aj>Y9g9E{Nx5pYa_ zT@+q0Hi?Tn4c@i9WZzg`l&(fjJ3%YU&`@GNmh39Tf-BC^HIKW%OhT}ke#_twp7!i(<`x$V(V%J+ zC-h7n8S!wVWlEy|C+Mk@#O-tmwkRnP>_lkz84XS#u6Cc- zwR&(hPbPzzcg8GvD9sVfST_q(EJwn;6wcsD<_35=aioYOoJ%go!hs%SLC_1dAuva? z!VC>lD;$x5$YGYb%!gFG&KiD2??9NCPj6KE+FRt9hMbI`Pf$)|FljgkNiK591=<3o zIKeefj0F!MOCmZ7A#wvUq(FlMP=IVQ{klTP!VEcp9Dp}rMxdc!gN6cd4TCiRHc~3c z3K&{6YXH_l`q~sQv=XD4EsddRK!Z-28Z|SrqaG~F~#TXT;^(zTeK>#o@QCq-9#L+tQM@y|l zHIOvboYx_q1RxbEpojO7(=&=qYl(aB0T#PJSrHmjF;NDXK*O;^bf@mb)RUjZ*3rXy znZp(?E`hbb21GMIpQvjyiUWv`n=+h`2KA!>G5 zLcXXnmP4yz5C_vx4q5j52tfr_BkEL{K{?)T==xTZ8=4Jl?u>EMbDm_`rgb>B?-0sL z**awxjvbrDaB&`stIN#4e>D#M-@lb6jg60f1XXh!B2Fca%3>|igEgYgme$`pO^@tK z(`C5Z1-|oLKm%~_IHcVGvy8E<*dGir2$8`A6<|X%>yI4SFpC;kIJ4zzZ*@uNA zNA=nd{fpeU?*L||)^RX*6xQuyw%_BXLkGd9Jq7sr%_t8ZX7;y#1>Sj}>Q+`R*Q z#WR`=ju-<8vJIwCKblMW8fSOE4+|8d1>^&LHBF#G9HXU}iJ}yqJmiDDsS< zjIc_nrZh4YP?4r)W@b#SDVk`OjMR{N0@8g=jiz;0G$q|oMMPJ-aW!G&L8GTrMU<+l zSPjeMamljUN2#eP0w$`4-ogEH@E3QWTwOMox#Y@>ffJ{kjI~dCGKPB|K-uf5Rnh4n zSQRQW3yh=Gv6obf0AmQH1`Q*SDc5)}tA-ks>e*BSMbHfu4a&9aW{5$LFmE<9O}Zr4uZ^cup~xj8D0epDfu_HjwdBAqj=+sJt22)VjSZr(^7 zJ7!o}ArQfpRmj`|?4}zaD&!yjiTRZk#OtnOrlO*OZWv$&WEyeQ83$!)Lx7nOO$sYD zQ~-j(CdQg>tl2^qAnwRL99(y;*xuvHTW@20aF4}b+{*lt3rx41Ou6Q#EdTj^kf%SJ zu`>oq&E81W^mV4Nt_-icbYP57X6jZ~(&wJ#U|I4+cfd72Adb(2FM0~9TkhuSkFG~{ z`f1RawLpJ>mHu(L>84*;<_mH32#5%DMCMY&s>nrBIE&0ZozNu9kYzcY6VQn{I?Hnp zmlc2`oH)P)PAx_Y4ippAm*12F3KRw!EQIJ`tb_;<(>mHwr3i_pBROR#Ycnv5+Dr_9 zz7D%HZ9^&bZ974v&AfW=N2U`4T*9-}*T&JurKS-vh!8V_*n?JNsT*6Sxd1M zGg4s%Xj9(H9*y>Jx35obcHHgv-N;ja`BnJw)j#0*XP$vw&v^#j_kPSz?YUoH_$#ks zXY;yrL8Z{K-hMku?fN$79Vm`;8Jtk)1(_Fm@$?>s5NVz$iYAs9SJ)bx(92)>8u|45 z-pkogp^TO7J#c_7M##hjf8!M|k6-wYuem)B@5S5x>`yUw>jT)gZ%hw58{Le-@vF+<9h)iBK@_SmTYDWwr8Cqy8QupjCAIFg$%!ol!_Tj_+2Y2=?x z{-QcTf;2GcXg*_V2YRd`&qRq!^x%5>8)cjEsGDqL&rB3nj!d1&`f0V2mCnBO5|)Hl zau7+5i#(U2(V+LaWgZ}C-sRG0G^O2WBFhUJg@dxh>e8Z_q_>lram~yOnvEv={Q)g1 z<`!l#>{m4>UeIhbc-iGozzx@4i+BC~yLtY3=i1Ys`7F##OmYAI16*2OK?Hc{z(M@e zKmRk%JYzS`I_oUJ42O;!g#gH#4QLh2kQQ>ovc%%j68ilfH?CceW~<38FW4EMz|r~R zD4I=7PfTLn+O-HVVmKVwv17Ax(@i(y_B(GwccqI*_8;U=e)dzD80+xDi_S+g&#`{p z44lvS;Qoj0)?eI(R zstwA(qG-U%QmSA`y_!jdG{DT6(1^jXha*Rhacped?!NtYtPTf!_OqUW0|yWB*pXux z40@Uu4P;K_{s$kzzkT8J{Jl5)0W;^(9}WZ>sYY8nvlhE{@4~))`(*a`F>yjVm%%$n zm>@=DtRkwaVRGz%7415g1tteKjYb?et+{o1wow}1Z+zUMvfvS0x>{`^Mkb_ejz z(`DXvY}-L7xV*9mjS;P)Wl0CM+E*xaW}rA>M)S#tC`M23Gk8aaY6$0Yu3ftxM-Csv z*!UziZrn&G!kMXQXbco{Y`2@p@&X_J;D=*x(9a6bo1gH6C*8ZWxO5^6nqn#S!$U?j zc*$*^6rlL1qmnpLlc%-l&XF5^6b-4Zl%t<@Pkrjs9*ZNuC{*b%a-^q7jn(*;Q3GnK zq2OaYu~HLS(y}BWXXVi~d7VVIIJJy`S#?b5|fBVEx*)h(Vz+ ztX;Pbokj=W`QCSHFdEp*GR!S5%jFkeWT%{VnjJfQ4DC*fjiM!!lM^^}sS9gf4SYLnUQdNfn3I z?sT|i$2Jy469$J{Z~8eNf7zupH8>|MnhkWjJrqTgH(qlcZn*wNeDvcVWxLg}M!RW) zZV$KLaR+a`{Z>+eZm*{aJ?P9d5CmGy4yv+*gG1hIAXJes#l*y-9Dt`i^-6yJ3!k@Oz;FKc>-leA`XbIc^IV*L_SyRU z=RQxSCZ7XX$uN2r$u6+!Fwt%dq>TlX2-29*-T{wqob@?f5_M z_zRT7l3p_IK6w|;I{O@K*}NIfJLKM5(QI;Jyn}TcHeh0644Kd1a|cIHg&`m!Rsk_8 z42DdcwZ_IdH92Jy6B8)%oLP~9BA_@p0^TKlI|)eY!%A;#C-9~TZVmxOYG-Bb>K0>N zLYnw?k}Pvb^;vb>XU!$I5n5eq{|Jp{CSr($6P0>;9$5uhuLSE;ucq17)lD415-?hq z2v1;I(#;^PbrS^UG1olQof1$psc&xprEcIpK_aYIm+797e%mz3D#RI~QN_StyzV!V z?YSGLKkZ7COIA?a63<%<&Wo9`x3WrKw9K`0KK!3w!{IM|9y?Co$!%}>6AX?V z<)OcOC-!QNjKIOwW$Yae&=ugpDzE|YnVm75ofq~<99RkG4uv5)W>}x)<|EJ(#bO!o zj`cG<*>~`-E3@$n{gUSk_-pGn@hQ7^*wz=kfZ^oR@YDbLAAIk>zk%f+{FHY;^pFka z7G>$!5mdddtbfYW^fD>j?fVYsT^g_sqJbj8EH+8@0Y;5DdGlJse4o>ertBSrYOw!M zcG2#wgHPOfzrSx`_JUWQ_qflj%l&c;(ZyJ0O!9z`@HOE#cLc;NtJ&P3r7f_SbAV=b zEr`I>)oP|oEuJB$G>0Jr%uy(SWunZ5 zR-|8#9I!$_Z-N|V1XN0$qbsalh&4WUb*WD|;M!oY*+ z^NGv_>S6Rr#xW0bzGk$0s%7%v0F`m?Z=aT7>zucd&$HA)8DzzXl9V0y#u7 z!V*db$Uw;eda4!1go&YQj{4*3p5j7)mJuyY@7A0^6F>vva#9*JYbva%W)ef_z^o-A z1&Kn{#zR>aX4X)mWo69OA_+9JqM?%;H)7_L-7<65SrUu3JaX3^Zt1{5JAThy=pHzZ z$(_649k{r>f}tielm|hdp#rF0Y!H*^kayn$q?ye(#2I|rR^>D1HY@ZJYeM#$Qeb|O}#4OOMCdraUVNm&jj z&ZNk z=6%Mj(*%^JF`ychQm!s)x!SWZ95D6=qGgE~REHWE%fJvSGYzO>lu!+6F{aZ!s;EYk zWeJPXVvH0uKm#&0VsV)}HgB>9A{LJx=h55l=G@)`be$%fS;LMUJjy~NR7*5{hPB&v zVruI)^p}^=`o(Qwsvs3hVZJT;m+pPL4x+ z72FTL5B%qU!5^MQwP}sIKl{IoA%ahRD(uoHn0ZG+lvXFOM#NcFSi21lDxkjre)HSV z_k9T6Z+sh4jKNJ$V;*Lmc87UcVqS=BVuF=3u9SvBde~S+laS^+h=ZsIqD7FjIQpuL z^0sQVF_Caypk)P(idYR9EE-*MrIM+8B_uUns7UCvm_`bS)SL4HXZQ^lH*+!8X_no91TYoeu#qQ>>Q3=^HcPeRsae$ z4y}qx2oj7VrBb2JL#seoDjSYLp{nA9%)L_u7!1@Zz%-CCq6ec_!*r3GR)O@6*6kv! zEPzK2!v6Q0(9=#r{+quEyZ*+g2lr97Z>LR+fmHwuMonM&BwHlkK;kq3ED8#o5=uMy zl*ne2*tV0_JqC_<3>QD1a%k2tK2G#X@Y1uH6@c7vH#7uuMUk3pVueMTmBA!fM1^$s z^DwpvYl=fA&dPpI!tA{IgGU8(^Omo6x$y8lbUyY^!1G=}tX(I5xQz1tyNnOq3wg#5rmKCOI2S;(+OZsA zR^RqVxEBc0-^+=xZw4<3VIwffnt5J|_{K{=_lbY+4XbtMHVe6OW{X_DZjHX--up3k zY+l~|v?t?tzV|IFRk>CGXTT1Z)12_yvd8T(dE>^-IBUxccb@$?D+unNKaRzIiGA}+ z{KSDr@SiKoW-ANwz~Liy&AtO%U0A_sYu4Ij>()}71P4i5a`5Y(rRx<9%T$Yt4}Nx;UP-dB&?>g*)EPxcq4{)@b6}*Zc^7^c%0W?xFqCID81zp+ng8yywH3O))bu z3vkZUET&21grt+8_#D+3j_l+$pd~RbYnqEDe>f==C{l$5B1hs-eR&y?6_7rih!c7g z!3d}@))`}(oB%VVuIc|b5j@KF!cM?6Px#4dmpp6D{888@M>?2-j~U5E!ag-&K5NEJ z8qmZGnvDjUtu`qsYiERs0~(D6v&@->NS8VGyM3&5S9$2bAb&f^?Ec_^m=_>e#Pb7_u#{Lu5)27kTW+ zQJYym!zWyPF_u^Qm|t8#t20iRT8xnZR5i-#Y7esua~NwkIW;|PgksR`v)}90Cf0f< z4@cj~p}{n0aI$;HnBb$MIGhvij$&-hTigL{SZ(Ih$Wvu>bz=|B%v z0hwQz#p+TQdC|bk%ru*=M%=n>o1Agl>BxM6yYIORV-u6IaoyT#|AB*kSXP*uKaLl? z;6+-NmA>rdFLV8V-#VQpR|mn&l%M>>r*Qs-=L4!(>Grs?vWR}ak1&jgsGu>R*Y9CC z9Kg(|ssM~tj7juOIBFm&;eZ%1YRLppD8m%`R zu-PgAI7Ur#fSS=cPl2=CdrKmOhX{~)2TcKR_J>1k+OW~eSYps0^2{?%x3VlbJ~e5X z&uLI=G#V5qs&Kga>hJ5pLq~SM@Wn6q#PUkFHq08#>f&{aNwKrX_NvtSG;kt4Gh$JV zew_HSqVE43l?K%NM)&k9pO%iMR56mAJzDP!Jd2X=l@>)-9NWz{*nvM*Vn)P zjWVqIJaY61=8n(F(&91z#q!Du_8&ONvK-j4<44);^$^t9?{#%$wZ~8ess^owsl1^~ z<(Z&}m1WQ>Bn3|B#yp?m?=529#abB)?>J=0PPd(){KJJ3Y z@x1dN$I0<&w#UXGAWu5wB<$XOGPiEu&P^LPVRCw!-Q^{OP}Q#*!|L*~G>gKja)@)z zJ(m{2<%LCEyMDb~^P?a0Nl&@r#D=poHiogH4Vc;=yy*`(xn>G~^^QNo#6$Yp3rov5eBcmD z4KNc9L&c@VMJ}(b)N7-Zu%M`AKI2C|^e_Co_q_*S`t)b{x9|LGu9;qo-~H|1vO@L_M!Sh-qY0lExZ%bd z(eL-MW#cBCb zl>rpN_}BzCZrH$$8#iHMax9s~lYI@t>67!1@FNtUfg(aCSVp=Tj!qbR^x@7&gTeKMwpO`M zZ~$xn!ze~ot63>VTRYcNN<5V+Gj);H)mSHJ@1s+*{yggPR80pk&7dZr#0ZL`byw}H zzxR4ReR`8^dEyoP>s$ArKYtKgcb?8qfAhcHYhL@icHXWX{K&t4kfO@f5csx#_%Nn- zp9GpfG6$omb24gf)w=dlk|jD#VCqg3<(U^j!#OmX88|)`kNogDIsCd;qPwyhUwGh% zz&RZHi+5o0`#;3By+zzvRyfk@slhO;Di{Q>ZFcOEsWrGe^lhfM%CV@}-|OosK0_%^ zj#Wc86!xa|8|CzEXWD1?-p%h12J#H=_}VL;iA^uK68*t|U;Ebg@po7MgmZH%Sjfj^ zVtofYHg2M=Db=a(VWwmiJ5az3#fUgno%uRW9|T7w}m+uEh8Yw7l2HnMJiRy zlx9%?bwCtYq@^o>H^Pb188lN=jP_%*sbBvXTMiEu-73$0~XUI@R zsG4)+P#^=Es)!qs3?#~^nuvxlP_@3=iosH@%V5bG2@9ZCntdiRxXdx}m5l%$%6A{(LEhAO?C`gg``xD7}$EHP{HpEFYoj~RqW@sVAHiZq41=L)q2EM=AFIJDw zO7GaLZ&d?MuUm`d`yaH$2On@K9Q%WwTV7q(Arz&SE?TOqjX@E;(xS1VXi38qjT4!` zi?>|F^31W>XrLHxz~?z)6=~ybL&F1ei-^k$kkd{jC)_sD$Cyip);G_29-u$Y`=yVFE#Y7GF&^5Mf`Fq)cG zAyTxYb3!#(OczScvWC!9LlvX~NHI}O6q{&~d81$~mBZmcb=VigieWH>4N8WpLJTFV zsx(BE4JVz-{=#uo^NT6w87gY2P>ryl8nt8`R%EO!3)}S%g!s-ux41Mxb3_Etv)!~8k2=OW6sS#>-}>EV##=4&Hqm zbb39j-KWA^Oj3lCM1l|)1V&L}=Wf`uUI4rCcHp@H-#{S0&xBi9LI2n>V0;WSJGZgD zeIr^{>iDqY($W%!WyG2cC{4q%qf4y-gd*BFggL1(26zCSW}6zzB%Fr;go?4MU?GC0 zP$(q==17WX3io);>u7$g0;qu!(-4zG%u|z{MODgSMXgGh^YCfLH%W_sW?7EB$Wi1u z8qK!3Mh0)0h<9+_(dC75Fc6oyR3B9topbQsQJga`Vl=>|<_u$ziyF0rN%R8EGPq{J zfhsG2QHXv}^a++UD*@)P#6Y*oY%oBq62v-2)8$x_RRlD!ij@siO;y=2umg?F7-h+T zsw}a*FsB`#)4%jtW+02N{71mQe_6OP6!-L}Kqp(2yZ{;?{<7btVvcJshbjJ5mj0q0yuiO_Z4jyrZXwcVy3OUnQz$g%X+2{Ria>EujKidm=s1lcWX9yt^L6yy zB^FbtTnuWefw58v8U#@Z9m1^iF_scyC8|MUtVFeRQA+|tQL8L!MKysbpg|>?(KN!W zGL4EDb1_iV@}QOhnt>{7*01Tm_j})ez6*L%QJH)H8KjMXfsD=Ii2Tr`l+Y$H(vE({q>i< zP_Ep*&34`U2u|yjxM{dzpMT^4H?8!zamx&Ta(o$6)sP$2Y=;N~sXy%xacI!RbBn@O zD&>NiMZlW1Rb|Pd&QRoJN4<4*mA|@vt$q9M+xes|JF)!WJ$SG&gDYP5TiAK~b-3Y< zd-&w1{F2I!t@KqzvqV~gS%S)%Q4?DpG>IleO0AEaHwetKgcbCXL|!HP%d0r^RWHX^ zzxW?qypGexL!6i{Bk;jwid{oz`pe1x`ns^`pVr_sjgN}A}9F1OS zfRht6wDhf2p$aU?7KuazT5aE~6>>_F#T1fwoHdW8Hk4UCv@wpv^x7YPLME&KG@Ll* zknn5KR1qW93>pJM1fmAUDwt`6h@(I>3fN!iVKAr|5kY!7FFG|j#YUr`84v~~4$U61 z{SWWs?CiX)c304BwJlUbd+4EurQh#atKG8xppRWA@3PVHsZP|j^xno#dSVlPnf{?Q*H1gvydF*UswXPt3o?DbY%H5{PG^3-z!M1tb#HO6pQa##*= z{Ma$O@4kDu_u)tIhi`l%e(z0h!8iWr>pVU?3$t2NG{doD^Y+be{;$08O>aifXo@J} zoJ3XRzOW7JX50h!KZqDh@p-{=I53!rsiF#%tSqgv*>2#HOD^WCUik_<<>^o5C6`>r zlXmUm$-7UL?K^j%$US;Xi@focn=w5#!PP<6-FxRf_|err<`XZ!jN7(vmtTI-OWiMS z{{_aUrnz=zJ?7_*;j~kC^It#uF$&4vpil1-gMVpx5kB+kDeRR2{aznY6@z{c3rkB> zji5oHDp3H7W~z}Qf|$f(3K(Ir_76Ikst`bcLDL0XLx?m}ixD(cI68}=l&FC*#;C!d z!4NgTBBUxy^jEvsvS~BVKKo4k>xVyv)zwu_O-|w1>?|IC$)(t^emxEyJ5p;9o(CRz z1pWSydENxYIP90GLPV%aXjNHMWs!O0twK$ra13>Frb zI6gkfjT<&vr`-`Ib1^5!Cm{~jXf^DUpZjc9^#@Z|T=C@h#Ij68{*c%=Bj|3TB*zog zcxrWKD+zm#A+?|un35M<>w7&-YE@inJ^|payz*(aIG)yjQ8kI+wRm28Cs3Pl>)%{b z-AH}3jZnZwNe!tZcewzuUM$*Zr}&r}K&h?n!i4`xGh*%9K?21ZPb@dl>a=mgtv8=@ z+pV{}*@=X|_=~@h^DjKl&CVa=>hh{|SGpL+3f^Tne*8F&&mF~ZP;zc|0fRvW4MQw0 zFR`qYFd&3rl?Db)oJHrwMGaOC1A|6}ScaG+JyA7t2LApV-h{vS^FPPwXP${|+qPnH zdC8WSmU+(EXJO6c6pkG~&eiS;78jS$?XIdpOdO%6)Rr@}1rj?Gq!?ba9? zMPc4~W?6=;@M!u5#>dCRXP#%Ce!Bhpm%mIHqFR)q(L^XKeDq&G$UlDjADgMsI|mIx zueZl%r=~D5 zHH9@ZQ<$2Zu!9EN_d z8v!w_tgPa#Z+f$>nOVb+eBgsPc<3;K89HNQc;LSKvD94#K*l;f9GrLlnfT_nzGdIP`f6A#(e0Kft09L~nNTQ2hVOs>2lns(_C?-( z*Ii}+$EVidrl0*pJDmvkB=r1YbkhyGf!6rJ@JQe6e}F%%G8poK?MLBrEd96 z>Uo;HLgF`{xMA@`q-NC2Ji?_v>UpZ!FIH2_c%p6&sZj#;rIGc`7-AHqu@>~}KjXx@ zzHUuTT7FbjF~D4g2R{8p;82~J`l5NqJ2)ol$>PiUo5xlHMu``^F# z3w-|i>-pQi@w*&<@pDl;bcl!F`F8AC>ER9o`mr)kfp;Q@Re5RF;PWW#r(F0rTeovNJDYZ}*=cd>hRx_abigfF zirK2P2t(i0#_|l2CWk`B?E!ME8p_5sQ?_f}cKq+1x8k?XIhX&q?;-s7k$so^`Ac8= zPu1~Rmcz0TSOT&NoTLneFp0Q1>(w?%$CQipOyC@!232|{zFA_68@v%-%yK%Hi&+NJ zC3KwSM&~6(uJc+n_Xf+EWTTv*qtTI;30*4r1f3ZKM8@=IW`yQYYf+KItjQD1bmTDP zB50)-D8~Ra6;=q4i+IqpDW(cIPtX}_KB}-la?X>qLWQorSBQvskQpe2CKqY$6m6L1 zBy+PwHzAnC#EZ{CX(#6zGZ-5}G+=BgkP&Dq#fie1V*{`pW(5tIn&l!^04x9$5O^~* zjBGM}Ei#x*&}TWxCdk}0HehU$meEj{B8$)&4=YUAFte7?I!0ksD`GVifVl=RB0^(@ zav0ojFkq}Ihb+^{^=lCr*;`!3(&9Xa3JEcyjEZ2$#xhCzSGtdUb= zgoX-LRcVZsLx_xJuyR;3lod4wS_t%3DGkWWk}d{R8X25p^d6w9MWD;TDkw4ovfPh4 zY>-b*0-M$$-**7{Ti;AKK91Vi@aRb|Nce`4aVtcFbF^~6_>OlVTyqV=_%zyMEjZ^8 z`xREI3VkXnAr@lPlHg*k5oY4)95F=d+?br4QWi~is{utk3ZEe+7A$7Q$FQ;4WF9N{ zcm5INwB5kkbwFbbn4JZVEkd_#Lwxr?!0&s=usq~ z!9Dv*$U_G}-+-=}Mp5=Lyz72QWh~7wXg0CxMdu8*7|peugMx^lWs-_>%AjmJK@?#` zL|G|72bXyyV`5s&(}>b)tgm=Y5#%%m)i`Vp2ZIz^aTzj69Yx|ik!6Ibg|ZSf3gmPa zEkFQ)DpGMCMZ}poXBH}_Rb@a_C(eoUKm=o1(!pt?(-wNMvMkj?MTn>5ndzVcXc9Fr zNu|aR11X8A4H`5kG_la3W|lq&FJ^|U#wf)qrt+&46qcbyhM-6qrqd`+A|i$)Dhi#5 zSJJSg z4he{(Rw+!}>zkNCF1P>~pBA*nEM9Us?SZ?1?_Y&*{^gL3Q{WGN%&_ku+{7d-4lwAg zpy4u74O#`56E<_tmd~K7lq?4uo^EC>+(gT)nbU3Cj%=b$965sO!2|S9zMOvhPRfqm zw4zB@K?O3O@2)gs*&!y$`$}veIMmmOo(c zfrl}uBHE{(j6R4#e*o1;N`_^lMuApvjFRf(={=kiItoMXNE3*2^cg{)%un74Tzv-T zjfOU|hIr?b7tPEpYR%6wORsf-sm7GrRueUiG5Syq3xoiuiCI*$G?yx@A|wFPGOcrL z>0&C9?z=9b1!Y`o!hCWLTLu$ns*W^I!kJQp=9yxp83CtBpJI)f15(MkATiXu0-mWD zypC2|mae>TFuK(FN3RB@sjHt$%tX1aGq(Em`|iK;OSj+h_KuP-U9*8NJ^x(%*NxX> zS&f%%+iHJz-`yAhTo3XPj7`us3Gw1}>-o$x&%}lozsgq8qkZdYv^T9m`=Ybidhv5H z_6KhupZ_d0&N~)s^nd>I-}y^_ z^2b>JjHg4t_$gffna}W|Kl~$@b1KQZFQ~aMNtm(P`b;6LcGe`NN5mXs(q0ggrVwJl zLwDbYsjZuF`j(yY$^ZJYPQb}UyU)adM;^AT_ueOe{`Nn^hraOHxbTx3<=HQOo;401 zq3yW`_x|{5p8ET5p$S#QTugi`BA|w#P#qzu(~nM)9jQhvgQNK;Db|*XFeE0PfYBnU z-T>27=zJno_o%Kq^1F{lB1`j?jpkad0W`_!EGmhd_-K{s3FL9oZWCihMQiIiV&dx7 z`a4F_eYDyYUk_I z6b+~ZEz6Sg3-jpqyJ!>zR=O)#m|wv1(lX|k7OdTD^T3gV_|Z>(f(Q59kBcw302iEd zF8aNm%`GjA=I9e1T>Ss}v9z>^yivI6sWq?=b-CBGiHS*Q07I-sFN#qXJS|TME-uXD zOIQ!glvAVLvsMKaNw-}TsoqRGby7*#l-@X}DP~7y>>+#k%y&1pxJHKJ?`ulhB zKmYA3c+IPS6<_=6|KPqod(i8z(xOH0oUPli4!`uwXYhuf-+;e-=l?+nit+I=9Nhm1 z9EoeMyMb$F)?iQ#FzEFFHCtKkv)fw+=@Cel{l4{wLxy1=E2~}8GEHacEoIOMD1yW) zCLtkJV#ElgnM$fk35>xI8KDMTm@NWVDEb zhYq0E9iZ3kVPSC&u^eJhR@Ptb(KI5O!lJUO0tkwCPK2T%s4L4leq5=M=A1ah82O?X zz5t*8?5COg9RK<6U&6;e@hRQ4W0yVkX;;V-FMEPjq0;?_4odEGEG{isuRkz9;!-3x ziFyj)oH*f$?`qn75)@}nNAP7tkpwTJcP1im&Y5?PnG?Fqn{y53J_DUtk>!#Xxe=OP zoVnL5^UPeX&O31wWLbvs@i8`9P2`P?S)L)wGBmOV+GAtr_xk8`#(3r#r`dbo`+f+;P%Ye&OSv;HzKr>s;=w#=raPzmwZIK`=h8mYn-4n2s0E#0cQ@!=Z^8(8?U$TeD4R0s+eC|#?NoQ*$y2&Y$76Rh7h9x z#zxTsV5o)xkG>_rMqb$SpZ7ePDSqv>zh!1>%|;U|y%o}od7i5oIEtfMUR ztKC9>(5J-+wFHSSiiSCQY7E+HkIB|88#yzz24iDwG_r=78T!4hRb_=?S#lJH_Cj+` z=)8xBW9G!9$myJeGgpICyp2)=0;H679qmgj^i;H08^CEyk)1lGqa&5P?o87<*n$*n zN*6Ot;7lQ-5|p}JJ{_tfdwL!GL%mY3t%K?5UHji@(Bz9B+(|0Vu}2A8$@QBG)zTPJmFDQAQp5ke@>lT0qRH0z=kmkfy$U~B?c&eh^!E6U zkG==}R?EHVkKU&5{G&fa8A>q)zWtKdVC^rz2qRX>qtQAY*+N+V3&o%|DqBliy?R&R zOwFXoa`fjHaNFPft?ArxyzGnrBH83REdRrYdCS+ofjf!CMH zv8Ug~AeKBW%k;k9(Cq_lYomiojim%!=5t)&9KUgFj{i9r*q^r=c+S=hJg|2k_xHPq z048^wgXjOj>ulzUm*A0aeGfPM)5q*#g&%IHjuWH!ge} zK5*~7ldXxV8_&GO=2+y7x|GFL)jb zmjwP!tBE7m{>)Yv7r8JtPGosPA3A}fqf2E#2Jv*6gUe`WHYt({rbl=h7|5tFF%((b znw>G0OI^llnBX|+Mlba%pCplG88V-nYAVpPlt)HRFf1(rRRlw@Y8X%r(;xx>v-jP@ z-uxn5D_4N1s)#aHw5U*1jWJ5BBCE307^_rjostrOnKWWVGlk4;Pz6?lpizUAF_jH; ze8H*;$V^ncXWN&Owskg*?z-PcY z7nxl9Q{vvcP~CA4{28YqUz|mC;0WSU7t2+Mr3FFOz@qagNh{5yxM6Bd69S@g+26fr2?lGneHo@*L^_R?49o@+^nAdecC{Wf@&2 z(3q5=si|qG3ZNB=MiU;6$OWDbB58lBAx5hzQbZa>PJk9d2`@rXs8ta<95N0|GV>;? z8U_P~P|;$bs#R)mnjB!HTGaaK>fi(#V@v@gGQ!jXRfxhn3uOdC1yiMlfS3eTR3NBk z1`{#0oMPS!y_p3ORwR1EfTd8e6v2jxafCyMCGOo%myw~{gAF3xop(XwDqXK6&Usw= zB9#@H$tb&=$gI&u>`hlk^nkKY%?t40A<-}Vm-YYQpJ;D?E5jE)NA*KkZvp&^cLKNE zKsj=Za_@uCrDbq+6|5>m5}}I7#UW2AY&Zf9B(sqfxi;2LlRhI>`j*YkTYPvQxpf=- z?%mA(?X$2epKjc?lc-94^y=%K+Mnn=R6kjR7>^r-#uC;gXsNpne6Uju>W4#$I3R3J@}L=@OnN zPL(+!bA#4j0vR>+7Bwc%36RwUS0`y1UZ%vERV1yQW!1#yt^H?y{GX`T(j4g(kid0DH??OBeC$EIz~6;I@m1N&s^_M5C2 zALnWu;GXMm!EgWNyYP(M;uW(&RNOv$*(0 zFR_)Yf5PcTj`q`@hJ4RHeB`>p5M3XdGgeGPR==dpS{;ybB=e6&k*LRH@X=F zI$p+BHnv0KG7q#hC@Tr{$yCmJ+-3OFKl^h%F&X=rb*-bikDHD^lwR?&m+Kkxi~1)Y z_&596XFebG`X-J(^Z-^4KFCYn`iqPqh&2sEp;Oe=Q>QI#aeyVbkfF<8Z>d4tf}ek9Qf8-O zHC;ieBg6lF(!Dl}4DY@w4i?L_NE)}R8JN~fU`|W!)#f16! z5w82{SLN}KzY>Qhk`Jsf=C0Y&HRu?&aB$)zO>LM6ZY>%S`F%_+X{#V@jLS~-05 zs5hyVeqH0NGtc1Oox8Qy>tpHUNjM2}M^TnsT3ME3$B$uoWl7f7R>7{|5=DVK?!1$O zK~K)vf0pdsxl5XqWPN@8yKR5}e?|4BlPffu%+1fq!f>RMrbQuzCU0Tx{I2h@^*+ll zrUUQ(hj-(5e)G3b_xm__-~F<=v5siOus#q5No_E2;yzrv)wHY`5^k+UDb93|lD{py={>aOI)PDbe{eiyg-G7VmWE11f zhI2DRtgNkY-&ygUPgkyUY688rm3167+LzfBgl9AiT}0@)Hki=FjOz|kfO)>8fMs5!xCkib>hCf~u%-+L@>G8{fQDJQ>Qe#8aPkl{C`{*4H<(F@T=C&Wj2J)KUb4qEwM0 zR458KLdd-llv9pvtrV&SR#%pJ#+hfTmIc<9*KppsXJck=MyjgxQWRCMC)4RPj^<~I zuYUP!#l834i^;~u$`c-c#TT0ddMZ02B&)J@>N{THoLw6Rb>I!vP$>09{-~Bz^7iNYt{N-PHn<-EoK6;p& z(@mXhOyT0vOd1?Hd=x20tZuAgeSHH>Oqfi@m^2MM8O%*$GzVNWr$rAEg8%*By-RMn^>(@P%E#fB+ioL3E-#;uKlzhC$605cCD&YgjTA*8=7vKL z9r9=~1j(*d7YfbPMOdhUO5eI6K#*^&WR~0%9#mB{>wiI1wNNQSDF`B^23BREAy0Os zR~Ax~g=(ACCaJ{g%&JJl^~@IXJ=$M9I`G;Das-joT_4eegrdzileRv za`E}+;l1yBpM;)~3x=Kk?y@;5AoYEii`$(V&6Pe8w{v&F#roK1uI6@NG1k z>+*DTw<;z~FH{bGg`N&5bpPD;-1XyC<698GFx=7e4bjxc19m#=%1mc9%vDVOMp}XGe2IQ3seA zjKIeF8d6H#3a+TjQp_`yvsc$BLqKxFv}rJ&Y+^K+k$%62$#ja1^)-*NRRAhZSmxwN zT~#85qG_fbelUx>!{H1ry6}AY>=!@BkAC!HB0?@MZr9E6hEO0yRiOwW7rFi)fAWVK zg1_nYSIgPwpM%?O{U&zp+=27YJy$+|?U&@1n{MRAmpl^t&)P3Db3@DyXVJEesERCZ zTf}L5_jp;C(l&<4coP~*_WLz@y$UKp5*@>tp`5m759a3DA^ z2O&q`pb}721wtsK(jxPyG{;@Cc4((G>n4JVO*&Q?sY8~&csMI5IHT3u)XJT+^~ zt1xr&7UDuGT=OI7z8`Z-PVTLzh!|i2B1M7egAd9z|KnHXsz+UhBV~bi-FO?;#PG`J zf1keP-~YG#^!NS%o_^&M<@f*gZ)6%Lt7Pa{sUYCa06BeD-JGDAVaCzCNAeAPwheaE72q zEaCFu5VQRmKCrPQr;Gc^l=RzxEEct>1es|kd<-Cu(E>NM(eI$)2TGMk&MitSHAd%N zfUs)^cAR%EPJ8xKQM8Tx(l5RPulo1*;XMcM(NC|Rz&B5>>g|@~+IGs1FD?1|j~xzw z^^M#7!H<3>TvA2u-MvSiv$)8I?teg5V~bTl5+Fkm5#ZUPnk>q>+vjC{$LYNO=Ii;K z3ohc{+P@FuXB%A0D?HEf?D7`KuQP-IBF5EXj&;ysYn** zGo`r#aye;seftQ&P{E!+DhPU@mI4gvQYmbhzX$qsuWWO&1CUuMLK2_|?zL8xi=v>h zAlP?GAw&U6DWU8s&{OqFRC@sWB0;I>!%>U-NPrT89&*`eUqlKK>1Ri{j6~1}Fe11cm~Z$Umc^NafC2MJfS?%r5-_$Ua?007rCG7D6SWBXzF{t4J9d ztS8Vw)t=D?PR^06`;Duoy!!gVPz4i@DLw0;-Bsa&u)PtgJ4J#R#L* zMa3QBbT2}l|Cz;(N+qmfI_w}B8*1)dR>?kKXFn* zY#~4Y3xdH2&|=GO&it5FkwFa#Rc10(NBPV6QIhVOd0dWOPuPq_F5C~?djQybn&3I# z1HJw_NZGgYPu>ZB{6A%U``suP7ckth9Vgbua%5w|UVq?)y1F_XfVz>9K*{rNd=+|VTHq)sjOK>+@boJzFW@K!U(p1@7Hu2bI!A7WxHBBp|s+Oeo!@1IWZFnfk9kK2H93CVTQGF!_{QahmK03p{PojiG*qf`s`-|qj|{t{tfa2KPuS0 z1K74bgVr)S#i1c|80tJE2tn|yrvZ<81aROWLT>w*ThWfz=ZDYIqKEh@?22*6HYSCT~Aya`-bUAS|7gf=+ECEq*cTj*{=cQKN#&|pr9OlaKDLfJNrZ0prhl@(;%z$Y!Sv97Yd0YCZ> zigPZ4{P?SY>AIk*U@I%xk6u*}Iz@8`iFpsURVXL01aSw3eWY)HQ{+GYO{D4}p0Z)FcsE91c6n6Q~*j91PX%?1(iJzr2wTU0>DB=3kVAmwbL4b6hQ*Z zAUfY0HLG=f(XV~#!*8ivaphoMUo|tp{f8gqgH0=^Rde$GqxZ{kcT53!jF$4$?R&5o zrw~FeJ^eK7yYexZ-hHrFoo3z|9K9okkv-(p*5o!DKrDmU}7#o)Pb91sa~z#t(6IdbSIw(s4Iu)Kj!U-u=H z?%2QcbiL!@!y$w|U-KhB#NT=MJN@Yk3pnGMPYdbG*UI{dCG30NGa2^oV_aL&P?cGN z2J`R{go+Z9y%yS)^W`ShE;HO&EwM$4+RDb|<65VJtB89h@n=CtzROr7+KrpHtmAnl z&TS)tyt|?1^OLA-$xK^zOzm0$wX;LBlb19jUp!#zA)TVnQ>ivYbIu%&%{+N!~PI-r=?alH#c;1b8Kc5 z^C-i94JWa5az#>VB&8`Pn^X3B16f;N$A5nCLpXf+h`;m)Uo7|Da}Nfifxqz$Z{W3G zzBa6`tkTWIRXw&zZ@cwYoOSkoy#8liD{s8|H8^np5j_5i$I6B0UF3J({Vf5&BgYQO zn||)+aQ+47;+ku}BGd60O-eGEG+13-!|{_RWHK3JemFqe5}T6=NJonC|Ii=01F&u( zjg8I+4jq#9%_%gLm>Z3-Z{JyR^ytI6bpHSI53xDkkd4hv%+1bX&uQD)#w3%bVTw^t zozwGw9U_{~g%xc&A!WMg9;F*Q<^wVEgY-QW9tdDSakA+w8f z9wY=$ka06c5ehU-%O+0s>tDT5hQlHDo_V_b-tYXre(#H3fE#YQ5tiJ~JNq0xxpI=5 z;|;0no@|ac*f0BX^EYmmGfvxsv(G*YA(Q}w{a#P2x|Yd!VsCuY8)aj4!)NCgbUdAc z?pR(~Mo|<#Z6@ND&`hRi+lc9Oj5a3eR6}XnhE0sB*#SqmDK%?Hj&5zwUF!lVAZ}tb z0Cab#IY1=9C~jMg0}eOP2|AOikWPmdL4-~h6ZbrZ^-jqE$!U|MR~Dcrh!&hqCt^+< zd-ynh^2dLIfA9x?D9?NT^Ksqv*WejfJqrg89>ns=RqWieO{UWZlg$ZYY7v6M2$r2* zTvXa^m%&gL0#^}=xPWD-rLGDtFRgH4aX|*d9yT}Dv2FV zdOAPT_ka8Mf9Hvl$1nVz=f2<%RU9cinNz zu0z^-D}I-Hq!~`1zbOApw;(ZjCG$Mn+bRns1T-RK$1k?JgYuHo2~zYtAEbBEx`W<1 z+oemwYo3~U_g6c!COhlAuya>+-r&)2h_BxG)x92VHwC=v+24a+RhDZTD~OG$x0$*x zE?C=Ghgplngl5u$?np7BX{X}R-Q2~^-I*j?V)L?UZqiImEJY%ZIT=C$y7Q?|zDh56 z#KrQbfB46o84OYP`x44RH#Wxl>eswZ?zrPluBS?P*EbMjD{#2OX`~|=On{JU zU`U6!LsOe=8_28wiNV*%6yp(?riSE(Y@qRbu*RS7+T9iNtNR6W`0%FQm-{-#Id(j{E;L#aWxv{ZPY~Qwnx88QU-*@Mo z9*TmSODAo1G=q(%!Tih3jDegn-}vjsKzV__hC` zH{W_QpYil(unYy?`ObIp_`}Ch)pgjn?<`r{9EU>(AM&GzkNA7u^G|&74}33MGld98 zqoK^s&&jCn@kf8?rC40pA)ou)HFEF41Du_o!;z!M@r~PV!P3cabk#f<;~FTeP5 zdD@enh-<%gJr5o^+}#MWZ=$Sw+_7!D7NufsWtFR|8(3RgK}rS@!R*W&M|H`V3?vv7 z7|sl#A+RWV5GX7fR@Yatyu1o=bV;~Oq|6B#s51|h+DXh^$ssfJ>#{_t0e9SfC)5K4 zip9l6SzljZ1lnZq=V9>8HJ2x+j+qYrIu0@%jn@4{z!d4F_3qda1QP2Q0qOl0K7M@6& zf#S-ptkXdxAz^?K;_fOgV9dysZs1R)=b?rWFctOe25>ja9WqV|G+WTV%T`Xn0n<}) z!fwFL4q4TCvvOrXr#a`9O>xSbfzDIKZZ4diH^7$EKp4b2fL!i zQBBX!Kf(Yl2ncWf^*_UfrP3esMBH}QU4C%7j@P~Lhj7;?KjKr1c>I-D;_lB}%e7`K z(*XS0!gifJ@}giu5Y|1nZl$Mm$4Wvx8dt|7>GmPAift(i< z`-A!}s16~eh%$-d?^c%lia&fO|M^{iXOpAH-d(Y{RJcK!7W)D1g zKd#ub8`H&kJ#zQG^0DVWJ*D-{)Bf|O8=pPbtDA}pD(nT(IsmQW13R)~>`4ufzYkfEygl;{b)ufUwRjRZCj`cNseK`|8dJ{(mL z?<+9_K~JDPDKJz;k6@ofU%?TaGXVMm_5loo$|wLs5Cf$T)i6u=kmNw%vqIKzABdnV zi(-h?wVg%K?X1fE+O~5xne3L7b_g&N6a#e`6pEoLW>hhoUE!>{aIrIS7!E z00V%tLLZ287Vfj4&ywD!bD&@k&JoBVh#_GkcZ>u+5MV?JBNP|`7*J%+P38%i0c2KG z=K$YDa9)5p5zGj58|ZUn8ajNo2s%&q*+lDm!br%zLVKbz3vdC^M;4RD+%%lUbdPic z%uP~Cl9G9}Br$q0OA=$k)RU)nDkl#glhw5~Cp*3#f);t7l5-}p+oeKGMJ+?8j6;R= zOV!pKQ%h_MK`a7%+CYsgM?=VH03T0*rUhaIAxO(hK-D99eX_3dwW*zF0h%X}=qM3&QLIW@}NByyv0YCI|;D>$)c;uzP@#B~reHi-NzZvl5PpRJYO>o+9 za$*TEm4$_QES8Xo#{dynQkXlbfF~EwbCeX67!zZRXx$N=OidDcB0@e?ZhPb-r9Yg7 zOfty@fpP1KYkoGqB5wC3UtAW~@-Y?`3r`J~*MOxp;vgq{Y}Wra`# z)PP&2lY5R$_~d$r{p6z6$u6pN4Nn$eu;Wj-6T8$(AL7 z8ylE3W3knun5-@NbagGvox7h!U9y^)AvDmFsd)DIhEQ5I>;ToE&rp5Gf)q4B z8K|1)70H}hid4NmSX3}A#d5yHp(P@~O+q$7uDa`rC$z4d2?4{LLzT_css=^nAf1?2 z6=O6RPa>?U5$jpR|NZZoab-VDMZ{@9vh-OtE6a>w91ZGisFwD}| z+&uaEUx5GB-=Tc>Uvc>1&xri>yHH&5DDZhNKvW_vFG1Q3l~_NgyuG!YvN(I%Jjd!CKK z+un>lmtKld({OElisk84rUp&uF6sOWq6DH41vKOrm2PCN$0h|Zc*n}lUXI+zOSpTW z=hk~m8iJ`7g@>wetx6WEk{csk70}?UB(ghOF23kSUi%0L3=#5e=m42c;bhag9E zjD#EjG9#2h00s&liem_u5$FR@1|l3NWE99irb^sd&kX#JKmO5IGg`Sf^wN_S<}jy* zFK;$-;b0r?voTJjh(!Rq3dM`I?Y8mqF??>k!Qp5YXYM-#>49T@)}BTFk0Zt&H2E7kRPk_Fl%q~V^f4{=nMIk3O@MdZ8)Ve3v-*7E= zoOc$MH`mEKZbR?FON)KIq5rQ3PLQ|Wl39;NNR}>gkiaS3DMPe7ZHUve<4`(?t^<9jbNA2~D8 z;rUWzUKo>w?iZWH%$UhbCe}uUB@hlvgqw*ww-VG8_dE=fA|z7UXl@o^?r_VZT~MHs z0vdvp+R@{?L9j|d5OpI%+l*y%W0T2U%Bqy!u;(HHt^pwgX`2?q!2mGBe}3SD`d=UZ zFm~?R1xryLI(it_e(5^=!SDUPpcG6d;}C+nsNy~U_#V9W>NoiLk9;)$?St>f<(FTM zx+-+o>#+_&F1h#;3yyffsu~+;!kQ}dn?Q3!2x#zJi0#a%aLJ0K4v(G*k z|M@TP%co&+smnf91P>g1Q2y-C{+hq==3n69BZvI8uX#Ow>wo?xKwx$_%c`!z6QA%n zzvSY}Bt?fR{n86B)+b*1cv+ZP;C_NCwNOTRzBpjWdl z`zVW2%A(SsrBro|D!_}XL9Ar2+^H9iS;lW^qwd(2(mhz+&rKrC0~3^$b6u z)7j0wG!&RL3FcAS81d4VycE4&jTgM|g$g>BmX`1%Kk^EH#Kq_HlOOv84jj0X+qPxY z@Z9VSQ*=x=rznDGRhAMoc#H!VyDmx5dX2k3A>I$n+Q?!tW9(qVyYax>L zr8u3!%+2BU)Mq|JMRnY^w(HPC59}z*8r~h3yeqrUzluDk>>Nr!Z~zMR&iewubA-Gz zgLcxpeCMryN;v8)=Xo6poig4z)rES>#tvbghoeKlbTSO`S*mleZ(%4pnN|OMu44B@yR4pqyHa}6OMpp+F;sDk&zd%60%lP?guEihy$sfr4%s@p&-JIjKsV8^N&duVBU-%N<`!D~D+wQs@N^ixbS@J+P(|N zjvdCgzICS*A;|sr-_Lsw-i>A&fm0Vpe%IASg%>^dh1|FQO#jFyKh8Vv`Br|jbvTi^ z!7R_&w-3!^Dw`Xd9#bM|1VIe}r|sU2-MeN~S3Z$ny!IMicKM^w9}e)gx4cDf_}cY++Ebsx^UpsIW)X91@jJ zQ<5}2e~zbc3naG;8HUVY6#;_*LK^ehM|ID4BQXUjxex?OLX+lVS%c@+$1Ynb(`!GD z?K6vph3!0a@+b}p@T%9pk$-o?4btnC{@j=RAl~)lkR#A%gscTJr{t`tmb$SP`#ZMnEM{jfw58R(I*r?q ze5ZzDUP74FLPiP<;g}a<29{<3%nHJcfWr_lP?3=c=K<~{xd_J$GN*kgf&q!4kh3Bj zIx#DdIRFC@A7oLTGXzGUE($Owl!2%Y0O^aQ5!`3szCgEmip&bQNRjOX=LnxOrV$Nu zbRVQPZnw7GZcW+^a)IQciY$;aZ?I8fDx?Sl30mbnL&kkcp@HaV#2lsqkm7*3zJi$R0k{sAH=VoKrY>f#5 zw+ODU(T^{K;|bVqdhxhRA&-45Q5F!0tEez1F!L}q7yzcuk(dKATfrLm7Q5TTJx4Ab zg7FjxC9v-_HV5wm{`#*_TyQ@4%&UOUeG=o74hzb#XUv z%=MzQ-@S2JQs^9g+W>ZjTH3F2Jw5I z%l4%&MH>K}Y{Cyd1T-zh=#&BgsqR$kiis_5i7HHQ`8nX*-$J$jEEG3fkMt`)jd1^i zDEobwPrQjP$&)+4;KbP7r_m&)e9Li4Zo^`U0xD%uifRFKpmFOCK~6Jf>BE)o22ar> z$Iuzu38s?<=8lL+^8|;{ElG+EtZm^bBAL-TU_lXrYf%CYT1;X^#u3n5pssXxYZ|FX zeHqO!7G=LrfS%gc^!7jLSk}?I3#4NJTmY! z_a%BZcJ?aAcq|nh^$Wir^5kcV96tno_%LMuxsC@9AiVYG!7CpNiwUeN6ulBw_gKcn zJ`}^c7S(_X#7tSEoHim)dJ?KQW`JwCK84(Kz^jwTpwIrEp#St9;GaGW^!i&Al-f! zieACl3(p7cxf{IxYZ%l8=K3|JmN1zZ5|LZTp`-xb8AuSmvm`USI5dc6WzbEcMYtJU zlF%*lIgo&X zIBHQ0MRX*<5adXRk-$fwi~tSq61a*L@*FwCJ06f4Ai|>xb>7AR?wdI2J?S( z`M9a|NLDP^RxJcAO3zFgZSF3e+~-Ude3CjG`k7h*7-F9)dB5b zyo9(a&<5lTsUQ*v6t9OfICl6XFgwHx&NvNY7^cIT0fM{kyA4e<;TvD_L-N_f2ke16 zzRl6Tv%MS)+;0CSv~69hnr_I&bq+}mPiACB4$+<5s{C|!z@1JLp=nZD9vzDaMJ3nJ z!bvk`g8{Pt^b|I@BQJDXXouKj5(G%+F9IFn>gL)x)f2%iY<0*?#tu>JSsuw&BEUS6 zP9)1+6=Lpg?2KH=jcyLf?P&A}cRHAoGPjd@YsuS|Zge*TV;hm$l>MWsfOMC>6P`?x z8JgIN3*c^u(J-~Cw=p6nGp1xsY!PGk@Ks@mVjWE*P8)jbsES&HC=lsV1PP^Lb24Us zIKXM!x8WOi+=kn4za86m?8d?S4(Pkz{nvQ))vx1ZJmKzL+mK=_BE+ya^!pDS(7D+W zKKr4M;OBnfzwt#s_+q^M9ls*~_)qV_+kW-e`TqC67gs#)i9CGtFxSRwzP7%Ka!{aO z_b@k_LkN_n8N=+9gzRTUw2kFB9?3t!-&Lq~Ad>8E4c{KEfBK>v;y zufSGGT0Yl@m8B)W_N!m^O#bQb{(+$=8B{4j_~^$yns0dhYf)4I-~ZwlA4?mz2XaW`$-*8lZ=@6+WI$MK$j_$Pnp$Z_6q>#csq+2{IAx7;kCu~Y=rLSFd% z@53dJzSI{N7x_zX{v`sy`DdTU>9_?*eDlt40)<#Jod8;(oi^~8a+N}%D2jqbRWP7L z)$3_lRV>RIWnFu}*Jm{xvZ$1GQA%AEUKRyZ6wjL* zg9L!^;BZyLmK5t-&5oUP(y^&MltJl^LKTxH0svn2V?RtS1YiI9P0&!_8#mvG&wlEY zN(=I)pZ__xRPr0Qe*^d2b2pyj)vpXgK1@l_ichHYKG5dfsKW)&K;{deHRxRaI1hx7>Q`Pt1;Hp(z`>1%!9n8Wac} zfe|2R8FlU&;F1v7@e91`6h%M*0ln)66+nV?2?^htvv*BL?I@M$N)=gLQc2m3Atw16FPA%A|$GTtfu&^(1H3miRiD_2P|bxTJ>~-zqctK< z^-LlSogF{3vPAsFKk_ns=)XP|0O->4NvyB05vmF^DT^Tg_|N~q>#o0E7ItitqA0m^ z;v{pys|L#>(Qfdh3I>`h+#}%>7X>n7FKiu!^NSdAZc$aF(A?~ixoIF>s@(ZPN&q@w zjs{T;3JG1?i7GWH%DO}dg@yozqF`AS0u~5bLA0~CJ2TrJ!k`s@_Dw&J-k>LDKnUU| zPo4xM>B@MTjvqS_3|_qM>Nog5yyu_g6QBK*-+9*^SXx`N$)rusc=|K&(1VAHVZSdY zmX>8a-tc?w{g%A^B`-yPG(!?zSB0E^;rX0Q$GG#3Z^|@Iq_gy7{P^os#>%>)%vWo_F>+G8hg8?yzKtO$05$ zWh*9>_2Lv*^Z@sIiS` zEQ&{i$EY-8aw3{(YFsTvqnWy!wq|7V>_2j9HUnfe-7VK6(>%9qIGLl=YM>~L!mKxU zGsDblC$qAgUqnO48unbWocX2#C|tz5o^mI%e=FZ)07vKqc_=cfD>3^oJ9B+@e7Q@m zw=iZWg_ll}?uB(d3K7nD${M!NdHJ45ZVe4G6_)~a7DBgdMP%+qixH+J4}9$=Y(8{I zp7_EaWWD<|o!)V`lxq_y=jZgx%^2sX;Ox4G;&}myhYQ8 zQ}or8m_S_wtOtbcfSo7eJDfg>tuDZ2RuMiv8Oxh*xJib4_VDV{w{tIvgQc=2Wwni* z8w{KPjy-t44$D$R3vUiB$qVKe;z^6=A72~q84Y_Hz`ly0g7g&Z30W$nhM=!1vnnzZ z1TzX9sYqXh0}=KBsiB-v$3TIRIOhcz3NZ}AJ}I>TBP9kxnGpy3eZmfRGx(0fYlk2jUngF(c+Z0fqvp1sp0l06DAVP{0`hhN@UlL0_B$ zYh&M5R<@Tr7xz`?ojq5sES(Vw>{9m`pG;;|bWt_T1YjU4*?C^-Y)~C3FsBmcgqRih zTws`oU6c8<{ z1Pe|V7Y(p{clKn65I=+J1MU0N0y+o@U8h_$VFG8!Fj6i-pU^^yPN1Gn8m zEeoIs8qLH~QY6ntk?3F-S(R>AGd+GBMT)Y0e%4v_!s^Ktzw^_d!N=ZsbvSwO0jajl zA+?ESDGSm}AQL@`q&Bh$F3JEg7xUzF&v?5$)s_Gc0z-7FxcOF+Tu@37NQoq+k#t7^ z!ITkE1ZCrjxdq?}j}_d02l@Fg07ZGq-iJ;K$@d9C29i4v;h1a!>zhbR8!$&^JC-%n z3{+uM!9;-86)pmIifRERxY@Q?jSV)Mh^d>mo;b7XOg`yP{*Ze|b65j?6_lw^L<;mm zKv9UOl(>I$Lyo2v>qUVhZIo#pP(lRNEXtR^4C(k1(#>CWY7mEMe!x!SN7xvG=trco&BIckF37AXO_53lve z@nkH?5{jY#%D|)&9EroK#9}>Qzp6xoVoJj?IBsso^2L)YSoWw!`h>(WBTg7}4T2^R ztr5+5lamum;BXe$a|Yz(8m7mO06TXgopm12Ohuv*?pyBCu5-p!D1=W*6Qb7>tgOJU z`7Hdzad_GU_n!&5?|yC0ILr9D*P^`THu&-ic-n4AQKO6|suVATL5U(pS0}>BRY|>o z@_+uO^Cw;=nw%^J;lgvI{hPlb{{B7G=e|h7<|bsa0eH&OyNt_|E$l;X*^yJ1ox5v$ z%U2Qax-%2b4<2B7!G6(wXS;pqBSip+h(^Gn7!5R3TicM)Bm7xMgaC(kV>tP+eS+uc`mo}qvPrOygD13_QNA&EX50~PjFPyy@%GJt#K!pb~WrARuuv2n?CGTqS+ zA-!^@_R+2(?;me)cNK8YbW_&F{p`^k9y7ndZGrfPxB9RIdEU-#*x;Cl?!1}5@u|=9 zSEmhkQ#d4K#GDKMHh_b0E|owK%1$Uo;;Xy^kD&SkIqq5%AH^P zGR}Y2lW^1LJ^^p0c*M(p1XuTJzvZT{Q8zZF3_`*+k7XPoAMdt8v>{h{O4#y9Dg`W! zdElH+E~Lra_U%|cehenGm;B^w1ON{nxL0QD8s;9}{nzit8?OEtM5sS-;6Wdqc9!bQ z9G2F`IR5cZlv);06L^Y3fy1&8!bIk=e9Cro%lRpHQ8x-ziL9wOK)N`oTYSr0T7>{5 zw$LcdbGpuGoDF-PaVi$b>_8CumPe3Emt6l#7hxvec)op?P6Od8^!$CD==2bEgVG4P z1tUX(NlXzjCTUxf)-1%F))8buo?m`)pSr&BP($%N#V6|X{};)w1Zf~vbS zwh^kiucq~c^Y)#`@p#HxzJ8N^{ia)R@7)LR#-DkE+;ivca`50`>^bdBY1+umW`g!n{7vaS(eThE$QI~I}=us4<0FZA#cmUr%ct0+` z>@qy@agWDfI6^4Hme)7G-RUS%6sp0u_~;%aI3ai4eV2Xm^IyQOZQF4E1s9@M_x>*> zztare04mD5@_+f)f7R>0dOc?6=lJ9&J_&VEVbV+qS5XP}>esz4y#L?+9ia%p%~cBx zPrvGEc;g%XI|2CW>MD}C95{Hl?Av<=`@NoAaP~Ra++4=xk9s5&43}K;D7^D;{!-^= z2YlQWkJHn3?UCarPVg14{BbPKE$Zuk<_&1t$Q|1jSoUf;^6+6i=Ca55?j5^fW?^k* z6_yf-fY!S}AOq`uU&^8_aW`|S7#c^?GZVs37cTed(LLS#-<$8SSNDDuv2E>xIh zK>MjhFetcXmv;b0m~_pknoCHX4(*J&ZiI1*&Fq;A9vxrt^5#j^r0vU z9((xV(6;S`Ahaq<*|}pUT^g*euSsf~j7~7)`q~ECJpE_ew6NBYVgilGosawryNlUZF^yu6iIz1caJ@5WLD1QZg=KxA1yi^1XyrJ^hf6jccdF`i7gw!W(C(+#ca z5?8Q}!abV^ZGoST^osv5p_!&miP@A?~m#Ko6l zVRlZ=KId$G)-#^XednAbx88b-0?@a;^=;CtO5FIh8|CPc6TJNL%lzUCE(q6M_f_0< z%gtI;l??hrR%H=(?bszqi4WZWpxk-a-MX~2q|>IwiIdB4%}Ik~Ew*Y)c5dH>r#<0H zx#7lJ@%b-bCv8gkvQdGGVmLFx1?TR^gNF`bY2}2dCrl<|(GYOS#g9N0dN_RaVXPiM zi4!N5aseB_x!F0q`7Lk8&0qfpU-z0<rk^8k189q*FPJ z|BD~?om)Xwm-6UGT`FZ+V{>C&7_$GX%Qgvd#NbHc8N*_9gVP}{xzX8OgqGpMP?CT_yG97< ziY)SmFH;UZ1NB9STvRQVNw9DcX0@LxG%-R`N-$4(NaBtJCn@52VRU)|&B#-^5roy7 zZ`MI@?E8V2%F3O$;cj=i;+#t)t*=;w%lAI@G5qF#{0CNTDg_`f+OdG@+`U#N2R(Z< z*a>fP3KyT{{>(a%U;=UNY$cvF4*g*(S1(AQK1|vWT?bYMfz|lvV+@a;OvQW2K14d4?zqC zIYLcvPJmgZ41}BoIYas!=zWlLurzc_LnVjeoKg2d0Q(fwqz~cj-0tYXZ79h`>OLd% zQppkB`#E-vKInbIhf2%>-SqDbl;~9ZILvRP-Gf38h*{nNjCkr79Ax1>lmKaAV**xhB9xzhDK*)gu zeTWQHWQd?Wahs=jUo7_At%kD))e2xiPv{EloyO3%lVUoZur*4WLX(?hech0fsgt15 zsOl~VD#~6_QdP|8Fi#Y56aq5=Tc=tg#Ra8{Ob`W7Y$j(TB6U@AK?}^40sUc(s#2&1 zu&kYRC9DHweG~TJQE)VayaUc>%~MBib}jM@KsPkYJds?HO0#THknhwJV=x5j9+3=o z#$JS{T!HWhe+sSoXn*%laPqzX6lxJj6QL=At}>3vX;IA*)N|;?K)?)bZrg@iQg01z z3CUc|65J!BMJPQF0+Mm{u5Y0l&a)T{#LcqB*cqIJo6|!^;>BqLm?5ar*4O0XSG)oj z{q)srnuacN_j59%lP^?X!tfd>lFQ=sCWtGP4t0Z? zDGX>Wh6xC#xkv(2gtZ3oC}M^_h@qC~2Sw=jpkgS-Td2$0EY%a ziuu$81@8G4urQx-hjj^-Sv*HkNCYsUBhnO1A_c`MSWi)>W*IqAD0)=ct*VcC=4IG@ z#p797^bK=ew_L!~7jmY^+}nv$#vx!c8blL9uf#^8x04A{(_(t)Vc?s0p}zJ8mG#ZM zhi^CX)M{=&QfoytM>0d(CeREPb1A8tJL$pPVW}lxc>vSpIxR&+ zi;`j_X*4HOitywx5mHJID&l5hsRc<_xTNV6^p+_ldP=$64&Y>S!&cXp#hMo45vfT? zbfj^U3B1(+(OO+QdW6=td3F+1A#9YAx%6c zXfk7yOp=?EB5-2}6{@n9VHvnMsL`t`(!svu>g=P|V8flNqCFa>9x-O(DkEAqtRrF) ziB=r#c#83K3T|IOdGA5sUGGLQ9RqdWk)md3g9#7~v@KY!cr+I=r6|$wOL_TYs0-Vm zyH2N+Bf%4%hQS~HUXXeOB!?8Bt*^th02b#^_ItVeVRId{s9|md%vKN*#jdlYxZ^(8 zlMk!^x7RVg@BPXjdIdERa`YGwD*9lQ2Z!Bk5jlens45tcUpC9-@8b=zd%lhGk&gf* zA?!UvWM&H}9Bwx#=gH7ZMT;?o?V5(%mf*=HiVpH4SNzIk63;o4_Ip zAQX87AblFDX0z-Kin{hmKP)Xt)og}ZiGEcUp$Jk6tHQk0$i5qExb*-V0j%8_0QTYD zgG&MN9>G3neS$rAR2exZm4FqE1ECKx*#xuh=!v2h!;rK-$-WakAuCX3+`T4bNZ}lv zGvav0;HB)Qa%JZ08?Mc!kZX+{k~jx@WFF|Ac1b*v#>4Hy@4E>Mme~;i6hfZ zoH4&$&z~8ISi%kK8<++7gEIp>`?S-2?`(}fKJb8iOd-2nv=YjmLU~#c>=a-J=mQm* zaY#&&6OW=$RB#R;y4y|a(zPj}ulQg8K-7Zx>L10cp7K<_8DMna)2cY`#!Yt{!zCH@ zqN>jVKnP$-NRPlaLe=vic7Z`|SzDLEsK)h&9z+onc1RyL{m!3a?y{%&;M{Zd<4j!p z&16aRmpYPl>o_wWh30f-oyE6?O!S=abyGS;++m)b z>rRtQPD(HsU|o;zR(X{Z7EMW~A&Fb-$xN6cJQ`yY(KHR(reQN}q-n=!rc*R+D{T{l zrKGVa6VP>Oc@q=gi4zZV z*dOTPwnYvHLn-SLv;86OId~rqK5z)_xIus;d4f<-g-VLD##RAy=RDl%e3r*v{%HL2 zFaH9c{KTiCO;Lh|EIZnkw?Hs$$Nb`T*TPJ2_3K`Z-~8pb;BWr&&+w;z^hfffE3bqW z1)@h`2KGxX!Prt8MW>sa`1&ok(%OW}E_sxU`h%@q?N&A@KP(z!lXP}w$c^)Fp_$M%QAOS9y!c;(A^%E)k8FV!%>yoO)nIOAD;-Esg^;ck1O!l2gD_~2q70d8 zlDjDJzW?|j?!4n0Ku|Q(so#C?L3IjfhOb`#HLh>2N>K(M4tqHNymNpuH-N-8No@1| z(abZCNrXnBcvs2HAf#watyE=&jq!vlD{I;x4kR`ctgNgO0wl`%f zxuulC>e||llgmrJy6EQsj(a}AxOVJ;&J>?<2YF5Pt_sgPM9h|GPQjKsE1LaGgyc0X zm!c7FzU4uOTj#>m4*V?00#v4=LsJAbWMpTK7k4VZK`kIjf>OYcC1Ul=k0b@Oj62Zo z0wXd?#z_<|h)xuRg?ypGk?C2Vev(Y8}GZHq#JL#Ra%i4*hKHoEupGn|&>!NZ4SW_HE| z2-E49z5WmZnoh2qC=T3vxBtW|Umo7_wqHV7R!A0c>o;yeuPzbF3QnLX3cc*oi}{y- z`4{-a$3CvB8!OmZ?}3Q2O%rhu6zXP9(IRBFC;^M4Cl^6Lr~?2MwM^MDBD<4l70M!5RTrTyO7{DeR7K5tFhpHef?PTxFbArw64?S( zuNRmS+zd@@@U~xh2ma*G{~VUG?X|7~&)joHc<{&}XEb;y<%-8YPI^TNvn0!_V@L?X zl<>(feqP`Fvv0(wJ~zajci)3|y#3eYJ^%RkII+BhvMBI|pL-+9s={fzPxH^OeNOwm zzWmp#C2|M74CDd(MgE(F4j*fonPVm$xT!{k*@5g=j-@ny2BU^fVw@qO8p#+5+3cdTzJFxro z)9{sRu3_D)<;!2b9-sTt7jW*r{dnfHo`L1nbsju;K*r-SVw=z(^ih@-rcH|-voq)o z2RMH0xE(w8a4>7xtNT8j8HON%o}#R+C%}{vfKr0=1~s)P8AMdIfJpCOgsvDj98gg=1FST)CI_?FX&wT8EXOo- z04D)l;|u_-D$o3XPlQ} z`iZKaAMG`axk>qAMC>H=XjVb1haML1YMy93K%c@jQg^T3blvD^TE7g>unFmed z4PkP$o}5M%7j-kS=m5o&vM@SHXO-Jrg%sJ8;9gX+D>M?C1~VXbxU<)*r78nb8Nx`b|frAo~;gA`Fk$b1Y43T%#n zL7k(aPyHUmst0@ZPs6|YO^hzM1e1+5siSd1k(Jb7tg2RZQ#vg~EzyJ$NmQ|wC>1~= z5eP<6=4O~s_XPx_8G=j!DYf3S6ZLpgSe0zXtg^!976|Saj<@6<|sr ziIhMCyadD4080~0MI?%NPl60X5Fc;)>2otuL=$UTRD%kE0eK}Ls(qFzC zVc$OKY=d3AoeoIo1`3Ws)%zppu?Og{ezg>XdEgNjAl~*ZI@W|!LyL$Fb4=QZ2q1d! zi6k^6EI%Ro4$3nNwGQc6B0yL9e^7@kU;Bv2k+^CW)+j40NnF5uPkC z8MIK@J~Kom#Oip0$_*P7Q88?rTkwl_%*ow{kKx;!(JLCaspwpARNC`sCSiS5Lca%j z{1uKtA^ely7yR;X1U&pOv26x2ngu4N=m)?P#avkr06~JevML2yQiO_LkC=m?%s2{# z)1Ub)DK^HU%a{L%r53E5|JaEqgvUg^H^Zw;;9TffM%YM=q=XPK)?8$Q5qF0up z37isSS!gXPWm#fa^=v)HAdw6~P?)=F5RHUr%-%^)S`Y{#3>IC=LIsMVaMD_5f^bv^ zXQYZ1nCod#1^B^3lxII#dV`{DKJ-y(W)?J-b<#Qz{ULNPD5|O!sl5w)aJnc5E)w0v04xCLL9$WC zER#h9GAFJTHH#_|urnHNf#BrlV`<$Usq2XW!u2jr;Hd&7}FD>cQ} zTkxZ6%Tf{C1IQ`}Qf&{O6uLXqI7?4u&cfEiH}P(3$MBEXr%tpj&EnVag6du&K&g1R~+ zQ(O^>l1dY$NHT{@0cU~{KyqkRx+AHX!!2qw)07gJ2xH5QwI~op-7irFU^AC_q6h&^ z+lrZ?jV+q#1SuNY*!uFys;sZCiO@N>u%M#CO>1RkW0@Pvs}hmmtClMzL(mwFTBy{6 zK2%DHOj(^XWl@#7wz`6u(E{pPF_})me&uT?R`iuW{uA=kulZ^G`+NU4zW*gJVNj8^ zl{En3|NJlir0@OL_lkzRAA8nSPeax3+3mO86<8;1Y>d%Pqa0s8@qby+6(|U&!&1r~ zSE$sL!jd3)#M7Q~6|TPe)%gDJdx<>z*-yjy=bz6V+jrpeU-~?qxz-WgxKRbT{jP7| z=5OAB*cbrd$6ofM_~d6lhp$|B9p3fszp;ON@B0GWQG^0UDqsdda4OuQ-tn!wu{me7cxQ(IL@8kPl^n5AH3T_c^{`p_jsxI+M|Lu*~+?Wa|IP&l@D1u(~tmn#b zG=S3paV%`#MzdBFBTOa}=&(j%S!}j;1JPWjlLpgqi`XVlZGgY9R5`hHLht?70gQbE4##tz`AoU}w%dGlZ9|J{2A}=>=P^?c zvAVWN1-(#}X3~HV?bSdC3b-M)}I(aMoF8vXBxFA2}>dlW<~r z36%!fzPQb_C^VE(zW4`TEN_3u+gljt?!M>VNAElHtS?KUoq=0mPJ{p$q&rG&F6x*`lvFLS}O1bWO^RcG(J{x_70d-I|3{(p}z&vcqr^T_Y+ox&`npR}Q+A4S*bP z&M`)Tb=9ygfLYdUyIVxYNp@UzAt9c*)Y=ggx}Z>=CI}%K;_}kcd`xK@1bp7}zc*+I zwsdmIC)0@(bwG?$Nhu+EL~ISyX@kjliZ-^0sl~KSPzl-fO_k}S!K9gBG#qg>7|8O* z1`7#7cTC%clmODKsDg;7zy9?ekE@F0MMLNeQ^>)Ghav7ycoa+;yKl~l*y7B|}+#?_Oz<+Afw*0HV_$z+#E7zfk z4eCJ;dv@+jM~)np)%7)|rp4xDg5xJwFqup_oi@m~STS~K2n`kLswY)hvuRsjTVKaG zP6-i&P>R!h+qUiU)T^$-ZQr;Jci(p}LJ=G)vSY^%oPYj#_{#Oyc4B(bjXd3pP;lqY z9oQV_q0IgF-;ZzKcQ2NfPRNB9ox`2GcgdZ1+{Pn^4&xDzcm&Qr?>vIm;pph@-QE5F zm6!sGvf}5ycn$Bn|NbqWi-?0Ng@>x6B{F~N^xb=*67+%l?#9{Yp2O9XCvf1vLHXim zzsP&2KNnAX+EdW9jyvzTQ%)Q|hH2B7$2{SlHVu;-*4EZ=|9#)a-S^(D4?Xk% zjvYNJ4;?xjjvYCSrR8NgzPyT!l@*LP*0{00CL7}oEHAIf@`)4J+}uQyn#_BhY;roD zqM1$*r-sev#PvB+(cQG0h6Ox%* zGFoynCAvA1n>e9tExYh6!H8g%H!H9t6xA>p^TgqYu>Vn)Af0iBefE~GK}B))>1W}+ zH+%+9+<%VLE1Uem-}!ZiBApGS)316KIT(hvO&vW;G9ALj)u1rxiZgN&E9BIrlbIN8 zp6h*l(lUese&m?UPEO*y@BJQzvPS&cSEawS99H@xZ$UI7INEJm_X3P5$$+H6^{7MK zAWsj1HahRKWHns2Ymn`s(Ca4&A5De}AbQCwUWviJOSHM>)A*Tdt^oj?T?j6(0 zhIAXcTjqd^4Fx_Ukh!kVYX*)H+-FD|34H+LysFNK_$+`S-DgN2y2vOS?qw(vhT@nJ z#}M=Z-~*xbRb(E(oDh9vF6xlrK*$+_Ga@Jz9I5#n61Ta>IT(AveW1{xz-Qn#XR+-e zra5f33)N_3_0rOue(mO+{;cN=`hWG;GnF@I`+Wy$xGd09h16`fWbJ@ zfuQnTaLUe^uHV_Sxo4Spi=KC?5Jz)lFz4I~NC1|WfiHX!tb1;~KJ>#MfPen8kVjpD zurQBM258O|p+n~;PuDdnGT-=i3t`HEk$uU3IN(M+}xbzNtjZ$xgfi7D^s{Z*C&lMlL@!Y&&y0%Nm-Yu zLuZ%kk3bEm{^bKmzxEp_Ui5rO5PYYnT5|4lD~=h0xQ09{-*y_f|6JhkQQ+PK2pAnievS7S`#g`#mg-hF*#4pe`^|S4dKz5y4c!WiuRa z6IuW^p5mVA6lcuNYy5*h7dv}5mS6gERO=Ijr#=bkv!A0p`6@8Wex1XnOKYJU6!_K- zUI3qHc=#A_$zu?%{#k^}E`WClOInm#^C4wa_c$2VMNgEKEBaEf2!*s_pi*irSfD^~ zL$Q@yHAl+n2NrqIE-4zKCq#FTp3o+PrB;njn#0Y-yXci6vGpjPo1{oju#_aFC^4D0 z=9tE)7Lz)YB(uzHl7N&;uDor=W^sz?WE0KiSYw;8e&QsjlSbTA_B@EpGS5=zLi4GTLF?-rxEH9nJWV&fZRRMtHum+$|b2=twXx-qN6SZy3@IQmN z3o(tx_1JKd3`J2&5<v0pCes${q3~Qf23bbpLygJWwACiLjMq2m8=LT5i;9(X zm)q|HKKdUy7d4oJYef$GIV$czrj5D+$Y6acJ8&ye6xzia^LY|M@Yc6d-}KYKIlG}J z4#OuC`179&JNI-HmtThRagPSh-v_M})rIE(=ba6oj(zkue}RoFpDO;!A5L-qesI(e zUKZVp7%0@lt)R9bfX1#&RY=bjNaj*La4%$70)P28kT<;<#oc#-FmnItg6+GA-8&J^ z+QmfUcxhRDZNrZNcwpS{uK)fPS^xJBVWT(H+s4a!Y&`WSkmxQA=*a=0GZJiKOHWC1 z0ew_)R|rH?B0OoXgM)!&mCCWCTMEF%}v<)rut^9*c^L^n;c$pf%G4J ziPYcsd>KyH&|h6cIgW*|uPY{-rA?+GPA36PQ`1<3C_$}ZUV=U#&~vher5V=%!9YI0 zq9)l($$HVOqWOS{eUGWaF;Zc>K7=>`CjW`N$R{=cvjD33fGoPlny#GV;i{JPr1_GQVDmBSA zLuye0m_m%$5J@0*1oc^{6oJ7MSR-|s9HkJux;p?}Fyqc^zJ4PfvF8jtH2?o_ z^``-sW@U9ZzSgz(eV_BpHFott&jU?2G(*$SfXpBY8YG~o8U9gJOiY}jQE-R}QS-)V zqKQM05Q8X_s0fNE3P>|Fa}V@9cUM){_|!9=bMC#bYyCg$Q?2jYUz&#M;;E|h-1pws zwbt*qf^upTaqysDeEBtT*XGRq=1*HOfWx#!LydE+f=HpZ@_JhW1D0_XrlD3K5^0#f zZC3WK*`!o}zz@9WdFDWT@vd9x03LeeUU&yCF092FAdcVtAopDJ)YLC8NGFejIngCV z6c!IOG-qIL>J$s8Xl;M@Dld*2gWTuM;Zm&*jv51Mh3eocMIm=qFU?I6LPel@z}?#- zI~-nWLxRNK0KE#o-e*BmYKlT`g-6^6vrqd~A!xXj7P)kdx&!!WbPA8z)ia9$|9X z>_6~?#__&~?!%kD?+3B9yM?_6_Hkixk(Xa~2^=U#Pdtuer%&RNOD^H^VkflYCFI5L zz5RA8Z2^V{AAAJweE096ROc`L(%bNd@A|#?gZI5x)x$%=+S(qbj(pF%f3J;NtKcM3 zYPeNV$fFJk>4~GetZ~s{mdY_)7#h}FGbe&r=HYbM}3@4n~8 zh2_O27MO^ zSDV_24Ww~(bp@aQ!k1q7wXc5VdvcfJH-76kvAndPlgE#xt@VvSmpR#<#`e~x4MV~1 z_AVYjaRSGV9>dP|E=n2TwIH>`E4O!dHQn9e($X@{JNJ+_&TQJL)2Fz!x~y8Nd8uuc zDgzMq)a#zk&wTn*c<29pS3LEpPqou0PQg;bWHQAK&v=$U>B0-`ZNK<7NN|r}X2%<@ zf2RKIBOlh{!ZPJxnN5O5dbr?WI?Jo4HAPVZ$t2R6IKU8Q31%JJnKjFd>{4RtGE&M& ziRhVNIV<-)bDwO~_3XP|dECdS8`-Gul}0@hz=hF*R`;&i%JLdU<1xlv=4jNztV7pj zWG0TrBXmY=@9tuAV^gbpR&@1~ui}6EwO>2iG^eWL(#tN^`#<aFY- zJ8Yjh!{2_#+k>zKKssT#@*>umO2YmANS*!lo`F2CrCI=3jkXC{3v&s6fu;6 zyVEHEg{8!hgCuTv<}>+)FMJ87&YY52VuY}^yv!@Fyb^cZac9hifo2Kc@Z9HPb!9J) zpFAc(cENe)>G0u4&rY{-=+GfN=b1O)+0S`4R+g9f*B|?9o;ZCn&OdZMo_5{Sn9OkG z*yGrGSq+Fc^iDGnXulUKI!05uu`PSd~ue|oc z%ki9RpN8N6>p$mvf9W^$l`no)zjxD3X=&8qC%X>M{n?-AY-KfO+Y>IXj47nXi8qnP zRzD`f5G}P!BLfjoCa4wwpvva9F=$8s;Pc8WS z=JXk$qZ48=Q<0#YYUKevWiU50&J;|PlJqWt{h~kLEXg+Mo zCa~6a`HQG2TA9yg?qWsusEp=phzN%m2+~4Mg`&ErT7?=FQHyG=7DHtX2R!7(QB>ts zQWa%QHtn@iA+b7Z(*d)$6ru3JYjTHz&dvji2qXYGLD46u%S5Tjt9xY2E9A~3bk$X+ zXWgJiI$(>EoUQq>1xZ>|0?jhsVij}VIvcxho(ID)#pFXDB1NPpUq*ZPyR`dDzf2UM zTOPxPikMDOK{$!ssIgt0)Akf2k>Lu6Y;vw-a3-~ficl>#JeE;Ll9uKdGax(=rC_=< zW%I(M5EI-B%VY{D+BwD&9F$cz%7O6$>+w^e6GyOl`V7%^gc%ePB2=Ro5D_Ib)Izwk z)~KN{j{u6`@>a+X!QB}pq;Q#pPSCiG4>59symB!@3ry&%YpE2j^;w$kaAD70gfd`b zjTU-#dzLiFXutN$uy1_>z>L5DeFq@19fEay^nlu!;&*s=OU>3rT zfSm|T2zZb+0Tr$J+32~H!|9+#BF3Wi3~a|-_$Jhp$)(i6kT_GtE~PRXn7Re59^B^} zpZkEKfY9zUx7hNsh>_ab(eT>&0ESKQqa7RH>{aIh zI)J4GO=mNDDIE2kBC17=#ta6-BN!eL?LMSXSPjZ+pfFTjaJUpS!K6f-8fG{(%(RfY zG%Ze<5C*b{OGb^xy-Iak?0V&uRr1bz40qlJuJ3>^c^Q2FIY@Wk21X4mtQcx(&y(D& z12CA0VA5GAtAZqRYA4(203R*EuX!5NL-)fzeKT<0IT*h1W!TAWV9z2j3`j>$z_)i` z`}ZN8vj;f;kh&MX(E2xjA9dN4$UXzv8I4fR)*gUOCPZnjjA=sIXxs^+8V`oT6|tz|4-DXEu52@KNQ(Rh}sY z6QdQmX4YZW{9z=MQl_;|fanoq&gz($69F0%gUPH_uq?&G+*p%a&DgBe0NW#?jYFKA z4(hsI-7sVN%9ninb3dKzIXBAAyGZ`IPa|%-HPWGTQO9HCT2)hf$|7n(y9mu~Qmyq2 zdIn*Tvi1F*s9{lSqARDS5=(FhUXgO@NEi&ALSU#9kO7&6n~7sVNuk6x2udN5asf=1 zlMv`(G6a$lSwKc85m*vXYG|~Q^Pp~Y&RakJu{ZA4l78*Vr`y5R5kGg!9r$pW;9Ex{ zJi8y`(S_xB&*^m@1^Clz%XrDNuh(5){Tlw&y?1d!;;NKbBspPAi7`gv!hEQnA#?yT zp%KNdJ#W}EkO;^F3(b(nD)8%&E_vtyKK&nktHy_qA>IFgePL&d#|2!C;Q0n*Bs?Zr zY6m)=CcK7h#?%b0mbn&z!+`c8!Il^KmD8v2Jy$;kkM2K&E3SXK77w1Q6Q8`v9=q)} zJ$ZGc^iAJlw!5p;8DU*}ZCER^lF%IZ`NYs>K3Qx5b|T_z7uB-rbjE&ZAugQF_^TiO zFo&qvV+o!|{L!EMN#WEs{`yNdag=gA_uTXO*w=0mw@&GzAN(Q9nVjtGo*m3I+Gyj? zTA)fUx`zkC6k;?SNO**W5P^ZLMh|BwAg_%$DK+_X)CNF{*4_%$20DnK7!i(^mIYd< z$pwcPs!$**1EkRvaBt&z!5F1d?q1>6QbNIS2UHaycy>QM`R!!%!6^ILrz|6=gP{ z41-Ekjz>L8DHw(VDKMK(u(P|%fFf$)^3n=w1UAlWVtxIjg%m4$);N?YHa6BVn@+Vo zn-LY7O()#k*oxiBuFXo-beM8ueFJB2av~h4F%znI*WGvG+0VRzBzfEIUq=WWjXGK~bmNgIG2CN&XWMqB zGpJNGMm-doC%u{HGQYM)O?^h1&;I&ugr{D8Er0CCei%Rf*0-S6K|lGEZ^e=0$MI7? z@#EUJXD{FVhwn2VX58MMXf~U0ad8FT|ARl^U;N_dO#rTc=Jj~_%U_{OFS?A^J?ojc z|K7Xs{tx~UuD{_~{3rkHpW$PF`IneYXQoz0w`8edIi48xgC5TNAG$xbx3>7==ikVM zrNuaW^w<+DFawOt(OX9W+}JvU$B&=D=FS8+T=z^q{OF@9UM+$C^}Fxn&h|E5`N~(& zjQWNbzL=l>o4@13k3OvJ*#s9HI#-umaxoWI_VEXQ;7wqGec(_2*uVCbudtS>-~Y(N z{HAaD7JlVRUzC&lrdPg-LdK|19K50qg)e!@%i;%q@XZDQB^(x_88x_*PNkga?rjbc zL>;CY2G?vhLm37XFO(yq7PyNHr`V#JQJeKLJldS51fkmQ2^M6vwz99z>e0IU4P)y; zFdEkdvcx`j%A?+TGt#m|CtakOikb@{u>%8!)L}NvaN@)}+o#6n^CJ z5rD*7-})9-1@61&UV^6SWI!o1ST_&DQyx2U3SG)LuQV-i*>p0&Lk~WLg_Si7(+NL)(`WF!=iGol z{_uzOuK)8+e$NkluO(-!F0a`?`Dfpq9)0u(-u3Qx;f2qA4lX_aV(S*iT;Di@;!e$G z=tm>^Tx)Gmz=E#K9E4?A-}h<^cNt_zBvQ^uMkY&eBU1bW_Iz$T?ItKOz~)g+nL%Pm zX0Yh`jBYgILO;fMJVLmLZ0*m(+Dj*809-(+6YTCzQ9by;gAehk*IpYhc;O5AsZae~ z0JM$CHYdX%5Ajd`^dmfY@LXJS)n$I)y?5IC{_uVHcR&48HXWu<)UUquwJ!sJ-tdOk z>3hES2ka#;d9fLxS_XwrdGz5&^|oL9<<n(Q^=IFzgNF|A zkKXq|eCW?Vg1viI@yb`cQeEnK)6Jhj-z0d#*{JY87@+@u|8q(y1T!xc)+P3%1wHvG zSMz~;@6(OXy%CpQaW!gjeE7qE%D?#7-(b(al{o)`^K4;h8C}Y}^X@w}n@wPSYEujo z%%xHTk|XM%$UXa!L^BMf!V)kHB)4WNJ_7tdtF@%a~0EE(`^;(Ud(i ztjl0d9Ce-gu0vH|+zF-3fJAm(K{xb(fw^m^zhnvCCD0RDXgMcjCZu+cWY;l-NHlt9 zFt-F+!<1K=Wh*F7(L_e31;r#JT3Ag6qnnc@0Hy+u97>RZbOq!(f z8r!k|`)-UEdMv#BMLP25e?RpNvsWX4dF1hZquV8lrv2pV7 z*4iSILJn9buM6`N%(x|>D}t8OXrWVhA5tPx5e>B#$elnmn^Cks69of6ayV=8wutGo z=#itj6uj0-R~Xz`B}JP1RccK|itwPKC~B})m)D{B5IoGHF`5-&jDP~ls6aT}ogIJ- z(rB8LY8}Ytq=8KWSXaf;qyY>~ndYr{m^Zf}n#C0t!*9Pm+0(BRYavqK(g#oAA_I^a zn4(Dp&F5!6v|}6zxPTOAf$`Wl&4q8c9(eN85r6tY)ZhM1j*&62AlA17r7-s+W(X#S z0BiOLP_)Q&i*Qu6CU@J!%G!c4N#V%ZC=b>UECTR=X5M(pwNP|emjhk0>8UfGa>jUN zrJWs1D3T~2SQM($`5=B_(H^<`0n8}axCcm!sjGT0n$(lkt56)#==Z7CvzyTn9Ld8G zq^eiB7j+(10+Ar}G%he;s#u|655Ys7k=>XJLjj9(vkurdnY#?e1Wf6C)<@FbrjeaH51_r_O8|z?4)q zu{3JpyuXMjh}M1wfn=UQC|0LOyBnH%nfee4kt|(W>{EkBOR~6`4+oER$T(ZP)23ahmQ zXf#?XstB*h><9vGQWTL=>J~;Y8tPDxa+h-MFq=$N-9b}oEVntXp@o!@Q^(y?r{mPl z7VOLxkKKJ2R@yCOS21dlaUrxKHpJ>fzhV1%!(*bCRAxtczcFWsEHh*_nl$a zDzc5b4wbto-jphP&9EbgkS&fEW7cP@4?l=S&*0WX!)>>)fBWw!{m732XU-5e-<0sw z>w%|SCzJ`;tpKVBn@4A1ZSvv-#r7OB0x2QSc8S~pFL?#@<=cT8(!&q3)ER8&jB-C_ zY@R_n|6Ih*4q_;>BIDw6RO@J7Q{)VLqP`3VnMBzWwdls4j%X>~sOuSkW>Gal;>;t0;7Dwa1Q$qe->y~38S~<`!(8;5Wz`j=B}mLY;LZ#qYY~S5 z9A@aZHaolSX+d{jr(pbs?>7J3%}9qIv3kXmYpErhnO6n7H0sb(q*H>mHL9|KMKv-Y z5BDBWB!j%|ku!uMx!_6+?*WKaLm-+G4V*GuRH89*`)O4|8kuZrROf+g$qOUqA|eHd zp=pLt!6*nMSQ?rvUsybS$00I#{=KunH2rdv_$IinF?WP)9K1-^36-F5`P zivcW@tb6YMy5951QOks`61)S8v5LA3uV3G2`Z1bv`VXXz3svTM`pd_Q<*&08=@g z2~z~F1aup~i7F0(xG#h+-+4POzW%v5_OXv);fklE?!_;`lm6lZw((bg*%ATWh&G!# z^4JIyYa5?HLE-GHmOc-o+Y^_@CaG$f86#6Rc+k%I)_;UO_<~eGjSwMv%SlcF4RM0RFIH^E1(C5h|ljLAh3dobl zDA|M29KY@oyubyRMT!!LHo1~YC5_3wAQX_?!rKwNwA90V@!YuXgcudtvI*QPXJvpq zIGar2UUhaY+m9BpJKM$P)&{1N9p%x;VyKF!oa|1pwKZYNMCvkU!+>EnGbrF?hGCdu zXJ;ZQ%tY?&PUtU!hlbAZ> zE@OGTjHh0E4bC}u055v+H{cC#{4R`g$N%(;Z{y<$DeLwEM{{jB)@BJU_ZtvjK z`Uxy7E*aE(><>TmfW7MFuf~;6z8w1x9Khqpj&WgOgcHY4<0;oX6)$_)EAc&V`WG^E z{F6WVAl~u2@4|cE_ij@NZfHMA%#l7%#D~F$9(@GIPM*eVU;T~P+}Ogs_umJPnA_$m z3xt$%EOaCDT5?b76S}AN}~B z+rRzspTKYZ_HXMi|K{WK%X8pgeBbBLrk|~bn2GeVm%M}@`rscymiXrH{g*g-=8TW} zQ5s6Y+VYCFwzvFu-}w$}p6|Ki41pT$ET4O01d&sRloD#}fCe`A0GnDd3<{ZyOr1%d z0|JbdObAvpuhJafLeK&xsuH5ZJ=ipu0(*i(r;;M|C~bOZhH<|rLfo3{Krku_X43)l zgdS2dcmztFz#-RA)9Ugb^!p9hUV9xrebc95H0){s9L*)9z+2w>a|l(f?b*w<#ppW}O#Zb}7nqs#=^r zswhD$jQad--}Z+3&UgOra`NPf8+SIhm&fNE+-7)Vz~ih4bUyVyd&~vV$miC^>+?&{ zTyHrS&jHS}iT1X)XcO46`;bw7G|= z;baJ7qYzs=ceQT^)4aws|AKPE%1{C-WY(0N*%Bs`ZJs!J;zkkik6-&8kyGN)(vmzIz|kCqD5h{+#To4{|oG zvYhq)55AAT@RpyC5B~9c?AL$e?HIfWGf-Y*&*}FsUoPG)?^|M@?>?#b73GVE3a(k);6su`hozx!SB z!WVpl-S^Og>D90KX1wU7FU2jl-HHPT4&c}R>#yn4pZXME`qG!ikN((?+QW}N!fT#( zEfTY;D(}DJR{Z|E-i<%_!21CjM}1F&)#+rKOD#U?daSLka$&p}r_Y?Wot-Uate>KiKbPg9+7C9O%u+JTio_HLS?FlVqq(Bt8b(Yb{2ePoU zzT$$}F6Q5?Q*3SnIa8K9EaVX^gWZrhOFgJp?SuxOz3}m&U2Q3Avgd{MUFS%tW1&SgGr?-k7jVS?ELT1spVb-#1 zKvl@lTKDb>Gce#tMh2Y>wbL1+t#hden{z(p%|^_kK&S+&tO*6%LNQ8Pu(<-K|MrvE zcl|Sv_8jE9-v1sXGd$y(Yw@AK{WzA#i|N4r1M$wUeZiKK(JP~0StOU%Fhq!Tu)spQ zcFv3X2%;rB5R^=6i++PyxXdg;9;&qnv#_Io^KqR%ax|{^H$R>`B;bMjxW2WHGR~NK zF`rd!2{-`YNhx7F3{yFl64Wtq71XjN+!{sefSs2OT}lDMZY#p8M+!eN>Xw&mB`?%h96V4zb>jHq z@%59}99&tweOAjd6;mS15UYfesxnPfXau!S86rU}E$(Q73ArWb5VQycP1&nl1}MQu zx-zW+z!=DeD50j5`V?7XLCJO_qFCRL zh}6z@a6`pHfCYesF&UZQNTC?JAh@zeSc3tPB9@|B0AWeyk}NzD6r*VLOeh#&MC-2j zC@Ok0F?ETlOG%|Lq~suA(NU~$r+du^C6utH3l>_GQmhdngtlk>BQ_rELbx-4WG8fVl_cG&WRS(8AmURUY$FpBSXq0wLIuNFGoUNW;K{ zT{sp?)k0>&8g6YNpLY(@H@;kW*$XjKz&`#_jehE<;mEBU$g_tro1^#U)jLM}`y3~6D5N-$-F^MUG3`5a;Avv4H?#W~6>X&|_=TV;?x#Kn> zC9o#RMT!yf6pE;$&NK}0Qi2|glr+qyDy5pd&XxC-;T7#qKtvrFlu%m}$pA$Ox>uN- z?f~T$FeOT3IlC@l1qs7+#$&?_=RxW$(JbQN-hJ#2KgOX9z#tSRx6QQTn5%p#_ZLvw$Y2954-vbjBdFrwjOxM>h1(H1$JOokyPZY z0H>lXiJ)N+P+HI)J;^KzG!;1!jvgI~k{J<9Bx}Xk5{AaWWHn%`xE8WfN8yoMZ^Oms zorip25xaMM9r-Ok1*5Bn|v;o6!`xo__>50Sd-)CP83N+5Fk6Vm*e(k?U-j6xC69-qwy z9^QTo0W*eznGFSyG0vvml7>>O&IR2d)l#XMUM+-TW`<QXWoVP~VTK=@5Bsh0lB2 zFNy#8Z94h2+lX_{Ln{hq8U~mMhnb~7sHLcyFvetnS!zzI`Dj5da9}&iRFt%kI_v~+ z$Ho>Sgbv0ogdruIti{f33^*_zTSvi$6+a7?;4bBEczqU^~(J=FvgHj~X=0kN5@?e~u7@NY4wJ35I2{de+6h8c6 zA_4i-8R(HC7#{ip$KwU@hHK!D9wr(sVwl9JhUd)nF{DWNIG zf=slY!~zpm`cb$M8@m%0RgH6RnT8~U$q}BIvXmkdj9{2qION`#&l+f5mKlK|Q9h+0 zB}e$y7Grx`!)~=G0+fY~lZMl~X4gL-cEj^6zVP`NA3UENcPyn+oPvGiNV%eoZODR= zkwCU)aZGQPrhFplgyM^__9CH($Nw(IZ#RAiQE_MT>Rt!@HAo@qvB7$rCu37vY2O zx4WB|0eH^h0(NG*{J;Y{dQgE2WL#>~0$WTe_Lx`zW_LKC;$Yvde(2k?9}Z#*&{X6& z85TjzybV_tbH;ASJ}1PlzyIC(l{bGc_WsECrq_J`9s1*)E&MIO=ZmRV#B!nqp^nIV z13F4!3?j@pX@(*@7>+4`<>>?$)y2mjGG1T0oAvSfN1h_loj_?v#TC__>oxU zDANL1Moj}4u4+liTX#)~U?hh;SwlOwG&S7ZfLf}h^uz$DZ2{2ELU2WZCY9jX1b~|{ z1W(=;_Y`f$v(@x@O43^kxUGa(eF~3uAZyapkQ7h^YKRtKq(Ck8tmGP;-;tnT-7JVw z=SZ50QrncRR#)-B`l&m(zOjy+J1i|MaXOpn{}wyWL7#u*G=QHFx) zY=CH}Wy;b-_dYE{8m3jPDejDBwF@ce0caR3BHCH5R=5{04!`6Dz-Jjc)a1vedxOho)-W0$$2CuRGA_ROVm$ot!%;M|mDN=rW)u5|DmR_&A=H@Pro@~(>HjFmtT4*M+=MG-q_SH{kLD|iIc~1{j;BqzxnG=;v*mX3wczg zE=$!h9d_7{dn9K3(FgvRb#Q#;i=W5GKl!&#Dj^OsM-+>43e*nuX z%lPKkyhgwN8~+{W9@x)c{U87REXVC1&VBx25K)uKHsAZFe`;4;cyT=Ax@Yp9`|iQk z_SSsoD%CnOA)`x%Q66D?Ya3s??N*$B-nl$_>{#_WOT~jf@z%F!|LPjAf9{QO^|PLV zU;Wizv!_4hYW(tl`LCMQYDXSF(k>R3jNy9n6<6{d?|cVteBKK&tpon@Pd|bWedztM zZ{J?*?Chc&jbdwiOV7Ff`F7ET7q(kTcoVSA?H>lAM*EI#$PO^21X_>OO=-rUndRP4 zijW7BSyGI8rkw((k(SBqVxN#p;?S;T2zQ#K(#SbXhSsoTfPHRAzex02Q6sRsv#ssz zZB1Hh!-lEDRUib+63v=8S!BR#>QavjFS;OB*7k67;|wpo_#%aXQ>RaJ z5yINuLwx2_o>K3;|ADMlnnM%gS(K2blO3LW&H=8U*~CsAu)Mg0loC57NVzEqGo^`R zb7RvEoO4jcXE=52B+6{YS_agR*GaKt2@w1>ul{Df^Br%efYE&q-FwaX7oPuxVVFDt zUv73#%|BMwFyDTdu03j~&y zmQm^uLn&5ERo{*5;5i4hy|IPIPaciQWQq_BF2WGoJKO1jhwjJ9>Y9(1dQNwz{P+Lq zKLLPSN{LSN<31+SUH(wth1bf^TnB5WL|V>Sw1jM@)Q@{DjM~rJCYeKb-@VcQRZY)B6TUPuI<%m)W_-dQ{33zCK*1jK%8w{D3Pd9 zx!f=5g7ePj-S^+ywn2OXi-eRC+-nd7v)Q4&2l2-5_;&u@@BbclCe!$~Z}}E{(>Hw+ zj~sp+0cdM7u`92*0;f05;MlQaAe+L5GNw#=b>x&$z2Yzb>SOwwr(eg{y!tgbdHRgM z?QK7A|Mn+;6o2%G@5RH9Jr+lf9O3SChWqckSO1@v!9RSTodr8ZQ8A+-Z0+tdE?jX*p99aI(b_=BLn1w1hk8mF&8V zI!~6Ns+p$SlacabkR>$$rn?GZiS1`7hz9jB337Ru5vZ`BkVzT=A1cp&0^~JdIhDyy zjQ6f_m=G%PaWGeRt~(uY4`nj~s=k3DJMRA-GDwxT6{FN0x)z+sCJoQp`PCX5IjEd#cyY#|$Zv!I|&Gn^6dgO^;T zy12-FjHuIH{>RUJ5-Sk?@o0oK65|M*sgCXWHe%Gs791PY1<;WZYEgwo4r?(@2IUAW z(vT^b2~@B%!@5JapIOJb7o8th^}XFO%uoPq4l|rP9%HwJA3c6jTwKDiev035{)PO@ z6UY7TM<2cF(9^Da5K>RaIH6boE2*jv3$)#hdMOGjdzo?#D`v$3bcCu>$g{$;Xenr2Wtv!c7i5})jk~B$ zP<@0Ep+ORZNb+heW}i$9QA&ZF#M%J~K?W>F?GhP84FlUeM|SqaVePF52o@Heomr+D z=3ZSYsfN5(St*01aSm@UP)JS#IJgH&VR$7yqIjjC1_3mo)Chwh7y5wU?K3-QAj1f$ zW&kZkEcUgXpLzpQ?wT#x+A}IIEC?shP?H_%g|Dm&FL-J4*MF<@)i2R*d|{)v1m`tG zpL6t7*-o5)e^9d~Nd*G}3fu4tG@!iq57~JI?!Fs1ei+!dhIHA*(4>HJMDE$Gt$?RD z)%i@cHn5v3p=D^MDK{`N+VvoiLJp(`rU)lE2xSzoIy8s#a8|cX4zoh7pW%6zT@lax z_BZ%v{?~6(bug(_n;DL1^VD`V_KFgYInsu+GEtcp5YeDv;eiq+6sXLXIN|dq8-#}Y zXhT|WITUG#EMNq&%}f)|*}H68kDtQgP_Tbt!8O~pw2+lRq{ELfmR7Lv$Roi1{eT81 zM+t~P@wt$3-Xrw@(tPvLB66ffOGXl2dnbYRV0$lbPQC47C8lWvTjh7}XGt70c24JMAxT0o-V zAEP}WQDe?GFd`(FH+ZR985kY}QLsIms%LOalaT0MWRyG^s{@XT4kqM`LfBX)k4grR z!Z1t&$kn{DN!jHzW7RTcVcCAMV+cpYl_sAgNV8Oy*()bdV@(|j+QEw zuq6M}4>2t)LFYp}cAD})cm5&7zP+sKYTe#SmV0i@3beTsHG`AXX=u-P^%SB@DAn0n zGk(u#WCT)5bzk45l`fNJ==z9_p#VNt zM`AbsGm3zh7-sW#U#U3T4EIRkwZg+{i-2~4kckGBU`2<{It*5jJ0LV*&WJ#SLAJ__ z9k{Af9gS|J3trR~-XjnLWsDRTjV$jNxb}$$?z;{UzvJA4upv^^YUie0kw)28_u|&W z5959Zo|1{n(-?i-#Yof&9AQ8o;K6KKN@=bVspyQ55?dD_klPqUZ0ABApQjFI3>m>r zRBF{gT$;fL2iFH?u(y5cCN93_rGD*GFXR7n^KJOyOn$yryeM^AZYg&f3`>MBk*sKF zOCW6B3=0A50N9b^{L!-Adg_dHdPDi}qmhNQwzfBhD=yL3zI;0`dhfe+1>zBjvZH>PI=j7mkLHqrZb*eUq_eP^KLd7G@0zuS+TRd9bRR_WaiW9 z)LemD6<%uEnGJMrfz46_iqb@?FcSoi>h6(Rfo|QFw^*6m54?glBCex{{uC3w3@e}xiKX{kUY^`(O{sZ{$|NVdBvBw{SfidoT z^A;n}o|P3X@7br_Q>XZWKmGuZJoG4zK7JfsXV|-UuMVDb6?e9Fb$WfBJCiAH{>sft zG#)*CI6nKCzvJs(`?}bgZl|~Z?mIN6aLfaZ|8SNv&rW*a{zo6h#53R zvx;Q2kN(A}yFkz67=qi5)X`E{ zSan)suer@pQL=_74#15x$*A1H=xsv;X8`6x4An86?%3(|GpeOnaVfkC9!y zAx3@4OJ0nW81Cvm``Mdc`>Jnx%@?*dw&1C`Zl9Q}TY@4G^Wv@A#l2NG=D|n8pb!#; zU~_Ia5=}##143>gzxLVW++{ikY2fVns2MQMB3}Y$@iT1rt2y2UXa5_R8LHYuztL~> z#Am)0^#e%O&g9nqAA{ENDRN}XX!CU0-hKPxw}0z@{V)J@<6N$P=F_Z7*xubv41|ZH zPG(3Z)Z*BgO)(t`QZ@{Af}ze}mJro#IvX$^jZ(NvG%Ll`<(_-@@72juC;7m=_iB)o zQ%W6)>ON1lAtuwQO@|@XVL)m%cSS_XDWSqOneG}0l%b^g$PV+%6rF+(v$JzkOS?PT z$~zp7`&eFGw!O=1=*PX$OxxSr9EKrwcXt^zw0Cd9o;?T9_dUumGFjWkQjeb&O_0=w~ot*$P|>fSZ>DVvwpB495XD3dW6H7x_mFynMq zv9LVGspBWHy0(h%{Lb&@@4x$9a0R-)2fUIn{K<#^EWZ1@--tVJz1yDgjAv_cX^cO5 z|N9V7+Pkubzq{!s9z6db{`0T@7yQwC{*Zt1;lIWo{pkl(YN0iJ22=+kk##y_%Eklx z_D6!*u@lGBbUJI+M`pJFFZt)rGQzb&_qs3mKR@D{zWE_ZtV z^Kaw_Kk{eDeUCT)lYeT@c;++occ1<&-v5F3aws!2YMAi)*Zd>C_!Te5x4r(g>Hog- z|L8ydhhM~Fk3AOWoPUmm+CwoXl1!MCLDyb=Rr=kx|L-{W+(Y>H|KS(fDNaQ{^e=w| zuX@GH_06yP#`N0Py?(CF`G299&I&Xv#3s;GRo`V6_mol}Z~eKSwj+lR{)Kpa%MEs41ALp$-E=j&2yxjXLDqv+o8BspDi^(9g268B3p) zb4P=jdIJdaR8cKZYn9hNN_I1=?7GxQrVT9&4{wrLgOOb@OAu3TefW7=A}O)S2{J9{ zmW+WiU;52U3k1OwCWS0nhUD<*8xpIH;#<@qS!&fqfM^u`Dod^R6G}m=Nk(^At3)XR zhUD-tBnL|hBv49~ayD)tnxu5PJISjD4`F+K9WrS3DNp4v4E*AWcePMeG z3q}?MhS{!`7M8d^Oww95PNo}i?b1jim_73N<5$hDx%RW!k*n$o9018cHov{4lpX3B z8qHs`iJ}pr!h2XP;m8bTif!iMG!Ye4Vh>5ycuZs_)v3xNDO2oNl|#y`p50XGq9Bud zFITpa`Va>LMhYMK6XQ@MyGs0z8dFe+Yh%u_A(9-98nVH14$SLMeQTZM7S%ghG)83ex}9W zddf^DBvYnMN7WHTWMe`^p?fumDFTF*HLBdT(!LhvZHF((+F5W?V32#^^eRclmd6LDcC=E=EhqYE0Vs)(%C>2Xo1#hTK5fDCzVWykgzh3FyyjmZGaj9)WRAbUO`36 zl|dkCLAX$hP@}f!rP1b0m?oGl&IWjQLkKy<5fk_1q&1NA!Scqg_K(Oz%S%{DqZCUS z)_3Snp5k^*=zik?D4VBc9k>J@6}%2Ef#bOOsg&4XbObB8+F&UycV*g1a8{_2gdXI@@~TVQEr z**KfEw=yG$NTA8#h(raD-CHuk+m}Q|Q*p|Os$e)EdP0~3N{y5PbDDP5ybrr_?a(wK zZAA$QhH(;XHVbvh4y~@3on8;DE*cgx@#rJqCqGH-I|tai59p#%q~=$}C!9b@)@moM z7l%ZH7|1lN?gy@WI(XCPXfJyq<4yk>{y%;j_RoIM?7|CxzxgEMCEp01*+Sk}XH1H6 zH?t_awDA~*1kp^0Fg8sM7?$^t+v~KuzYcW^NKbkabnyj9 zuXq(VZokV%X1QNnh{-Tv333o(Mp{8taf(Pxsky&8%8EkeEG4il$kNtis!>X|k`lIk z0!A09bAu>@p;7-$hERmDx`Pxgv8Am%EFjPg;t*Dd8iV;{ro6adBLcqfT*Ok(1hOtJ zE1!Qpbp7*`N4-%q`M zogQ7JDB*&P5-qVwfGT=0l^CP8kroQY4pc;xDXS$JiluI+4LBtV28%JNLDE75oH=0x z?V`{2wFeJhL`ctEIZ$_Ilaxz|6T?nAcWHzf1An}=jw#@;LZ8lsV}igwGoDhyNP*QZ z#on$}+o$0g1MDRvnwC4VV~6FrPhmI01`;PDw$)yyedOF!Z!x{iK!`585T){4Kca);sjoU-_kU#Sgp*cfI$WxcZ9ob=h~kf$-YI zU=7B=Hs}diNTSSLa2c~1)ov-28FJTQXL}pmw@)v9^AB11^ABNjwk?7D=tn<-AOEo* zh!r#=NaG-4)~oA=2Fm7lMr`J(O8ABuco~A?;3Pn(Xev z6)9zdifhl>3SxO7wr4Xte&Q4mRWk=I5m75j88Dj;f`YTD+iW&L8A>X{6vZosp(b~Q zycnWAK;;omr`Lwn@Od69yuw2&r7~EX3c6IdDOl0kk^pGVk{Wv1BCt6tO~gJFtgmn4 zTVDHWz5N}(gP;7jZ{eMH-oY*>rEY}qp*h=JsDOnWnkDo(pk!EHTIAN|7GLvEUX4Th z&ck%r#oFo`zWAjtg-Q11uinC(Gj93X*Kzpq$B;`#ja*zE z$B+EWAK}*4Y5b$tz8?Dz?8D;nGOxVqD%||}&-3DoFT%?55{?}^##?W>Exz>SucS|X z<|b@xZR4$P`I&OxgAaFq`|-a9=EHQeL@MBObjsOzioEK+hab{HKf-~72l1?@KLhvN z_n{Nr}x3toVq`S(9V z!$fcT z7vGCL2M+47M-OZNxqFj>nnM6v)7p$VWz6aTV}e-b7D}_Zp|XwNyM$abE4|KYt(yo6nsfqNdd6YIy}+XXQT1Xnm3jld#yqb^{u>CV(F8P1$Kg)+>n??;%G z!Sbkci%^-Cw7j&ewUrf}KC=~v4?p%sh(E(jAfh#D+7TT|K&7=aya)%7=HwNfB|At@ zbSOC|u>|MS^LdUYpT)Z9Z1SAZg5}mwEb~3sd=S;@IW4XP%pZI6TE$s$sX=owFNHSs zpJzPVcf)+eG*@W|f+@EfnGDI=*J385+(o!>&pmfN7XS|KJE*nQHBNRW8fuB6idsEH zS~#`4yG2C+;TVRBA-rw<asgKz(HM5L}XuqW}YF^`*E0Q5*h6*RU&e?RTjnkXl zzjv<|mseuc_bKPjws&{2xw&a4PoC6)GaI)5z(K67E@NS7fqmD(m?HJb5|VP?(O`|f z*uFtQP{|VeagWh>!Il=5xVpCNi%Sc(FdowbKn$=VNsTQn1IDACwYr#%q%ckyJ0Wau zZs8fvx(@r#IcO)3pNLwTyi*Due(V^(_?55W`@ZM<{q6tzchh8h7kl^Z!8K2LGVZzW zemvv)XW-IHF2TR}?thN=eeeS?MIgZzM!hDpf%7&oB}Ph#`}Xcdgm~iA2@MT@k|@)h z4t3V{1pwN+x|dJB>T*tIRkz=D*V(!SnnepKyxDqJmRI?bZ}^6I__0UrPd@TzlE53T zzaF>U_H}&x6F2dmyKe_bz4a|W$G`aVkKn-G19?ioI{>_iz z%;`<8uCC$CnGK|5r~!<}9d7;V*VxOnxxH!c|G@kGyT9u@apjYrtZ)0)*YnRl{!uLE zKK<-l-wHEB3z35TsK@1(U5@+jyVr*KR&tb+jTct5v9Upq01deQS ztS(F8tW6*UNjP!*BqzHQj29NPySqa~bEC~yS#Va9a_c@p2syJ7#3ueq^Y2Mlb-Ggf z;08JcX6%p=X#GDTyb={qm%x+&h!ws0Z@Yr7kmaMuvz88S@;R z(!ssL%))CSQn6HXt9zHuvL&FTvpYD#nz|R7T2}!vH5r)!sX7JFa#BLFYO-ciOY=sI z1IqJ7j!@12Tc47<{jO46sEyJuiBbXSdXznIwQA1xh5|c1bh)IR`l7B7Z%YkEn>8^2#T0kLK>yCu(;sP zgeLLI=n&D}b-NwE=N_H&s#jUsdyaVc5p6$wABs=u;}zs6FbMkqo&9UP;0{4WU{LFsTcQ~d$*3`4Q&}5ohB&IgXf@f+v}*hKF+J(vK|FhXgAdLo zkUJ-{S?ph4vy?&!@NQuR=cd%3(=XHqPn|qqv*AGQbTVdfu^^h*wH&UG5bTpNEHrA6 z^tl=XOjIPQ@v|idj6qOLHkG_<99VYkgBYD^SP;G3JAk9Jtc(y+8>WX*@(4pzi-@{N zugM9AkO(cp5@0!pV#J6@Aw;OJUXmEfeV59tN{`-`ckX*A?af*F1pcnhhqVFmuUmQSJ;@dTpa`dFiWKjVPduHktqs$zkG9 z4UXghpea#dP)$;+Rw<`Ws)*`hC}*{Nl0xmiFd9)nuojAzTCc|q^JIb7rm{k%1c#DI zNY>WQEzYQj`J0)BkO#n8Drzm1SI*h^@LJ{J2=`RIKoQ~Iz829VY8#?AJ%bCds8J9e z%@U;+-xm;-6*<~7pp9ArHHcjb9Smc4rD5Rk&?C^&GHrYSy8BM%FMb|4?>ykqBe30F zXkigVY6riVo9M#;w)oP#Uf3q*2vXEMNy_FNnjzNq0uSAXynY5ca4s-ZXlnz0Y8~ve zWeD2XKvF2=tcCy^YuKClIhmRVbeQ`AK|&D<3eioHEZV)j zN@h_Ja?mNX85!V#Bw)ej=#&I(453svanYW0d^DS~KJXCZqI1aCy&jW)^m_EqdKSRS z_}~X&=N$wtxk4B(Jt4tr2j00|v+b-2uR>0(%IQIz*Z|)86U6ow@V-C5>_dO4&CMO! z${q|5rdC0Ym_$?*M1ow6>Er-raG0kQCJ2p;0{~7_?lP9Ukv;W-^Kfe8blmp%X>OH< zK!A)-v>H>koQWtUP7W1&H+RieSFv#Mxf*Wz8W%tMG3HCJ1YZ0?L+9PrdOu^|GW!&(|5ps{4GeGqfg7=);30F7{R&PcifV2 zd^*8kq*BJ1NsA8jmRJ#%=gA;voK=TPVGt|KQp0MS18RaVrcN!23bPPqK8UF@C6gi3 z3V~cjWlK@vmI)sS>qC%b1>LCXE+Q=D2uCs)syuRM895o`g90QI)mf)@n@yHFz&+%{ zlt4l>$ts-VmhHj9_sFO)1Hdj2H!x2rS6Cv%7;BEr6Ni zsU6^RUx4ZicJwgt{O3v+UdTE5&ftPD7}5LL8qhqZH4i&_^E>2D2&0zQpyxgZI(-Uu z;1Gs$_oDl&zX1M!KM4QKO-Q3<;Az*Q{?acYO^d}_-YQ&mskx;{sr3!pW~l|*V1!hH z?j$l%3**jPz-z8Yz5Gh}SH2vWow4z=Za_TpD9Y`3!yh>Ulx@y7H*GRr5D3(iu-HZqYw!NhBjBtra=DjiPLl>7`b_wo3c}nhXq9_kI6^xu1 zRgn-)s}mLu$}8kTM+3s?0d*ckySN~&pNO)Mto94+#7MP@2I9!WDQp(zuHL#fIGGL+ zxiifMz=9(HfaE2MH+~J)eN(Ri9 z5@UjBZA=mtUdE734OW6EMpVJNW;={gyLqS@tv6zMsJ`#cGpEO^UFM;SF6F&<-fA0L zTZmDP17f$OB6x z$2pTjfRN4ux!oEMSe2qC<0z5a;Rqk_+?~X~1MI&&_#mEh&trPhi(hH`_x>E7y#e0Z z6K7mpNSRZW7EKIbnZN?)tCM-de*~d7p*XNNXISp=x!Z2hm3#K096y5Dlh47WH@+0- zul){2kDtQOcX;ali*WDz{)AV)?sY&;h;YgqvD4-rQYDZ`2v(JyZQ6JNCLt^#yFq5= zTQg|6;{2Drpy>?4EJL{czB{~t>2=@wZFAHn5M{&J7WB;~IfFD;PZH=O>~CDF{_Z z@nVB!s1Yc$LBmiu%%&=;%$8szl4T|9Yuj!dn(@aeQ(BRKJ`g_`Aer!Yv6DH_LKIH-|&xd@kJNu&;R1j`S^*G076dV&SWO9 zm6;i8Ls^_TwT{P+%XN`x<-*yx_*? z@|$1vDn54X2yXt|=k>04{a=3mv!Cz&pa1eJ;4t8GU;H9=C%df|NzUm%PoQ9cIWuE2 z%=Fli$54mL8=w75-gDmrdi3z4a0$D+Gn7=Yyt<5(dUUmDV{?m(i;KWyf-d(qneOVQ zo4=?NXEt#B^alR(Fa84F{yT5SbDnzx9zT8>hYlRT_Rbdm-CKV;#{I~)HaB(ueGlXQ zhaWb}S$*y>nNDSi_N%|~YcbiKaF|2_(vDAVt<<^&Rm%MVeJ4HXrjjl(7d7G|s zo;1%X1F2xvS(qR}h%%J3V3Vl17>KKBFDTOC!uwGF>mcSD^^BJ z=tdnbebQ5qyOEAOehjDAPjNDtq1_9zX0s{&@B{DRp>xjB(s+qiTz)Bz9Xo~H-5u-8 zNOMOFy1ZZnvAMO4)wPv4e&Up!KDDm%&p#K#WP;VDm6Twb>fY}8-|$lZ$VWbe zI@I$v)=$BhQ8mDHR&+}^8@Vp%EnWXa%+==itQHP`BG>^TkQ${$LRe$5=jKk*6L*5} z3L-&aU{k@)x#x2zXgKD620;A#F>X^+Hx~)fs>x4G?&k@3YF^~$TzzV-7m@<)g+6~r zMIf7{*>viR0CPSc0G3w|H6?cQ=?}cXOLNlR%l(C)NPx9yoxZx=wAKK^}*XSm=Ipu z@iFGW;;2TL!t4AND+)eepy6!bMj^LMV$_f5)mci3Guvl48jsV$!UC521uTvia57Hg z*yBfe>hwwMIeHj}&O1NOJ#-FZw8Ye9Virny#AP!n89U3|+1?TS%~Zci7vrPb=lOZ`YAx4?e^Pmiva9d&$=E78TUVU zKkBUbXw=zsI`BPz_-_2@kNhyc@6A7ejg1YQ*xJI*{SRm|8~F66Kh6K+zyF!^?f>}o z_`~;n06UY$=-RWoN6`_V`rK#v(wDsyLn-Nv-}&9R`HNrR*YCW`N9@wEKl#vy@RTbr!S}uSU*f_0AH@4NHgM#~5u|K<;~T$Ar;eZE$3F2_s6+AVpY?3} z##g+Y8=KoadEz)upE@2_UGSweXgV7@EG47_4mFSlL*zhbDG=3yLduQ`Am?74NST8m zTn1Jkx@H8G&o6fK#6mI=$z*hxl0+r2&e4PI{3mN{dlHBmAZHX496_7U87&E{%_OX- zq$N09LIT@E&)`y3SS#ZQRiWlksmM&I?rwcf)_~ZkHRSGGT3x}=6A%B%pKCvj{ZlW; z*KhqQdLX{(o4?Ec?$aN0Lr&fLG4&@-08w!PMtI#hYs@ct8MX*N@re(oi(mNim??9# zy^D$fW`VN1qnIqRZ1qS;iepDnS~4Q>^g8lrgnsWn9lPaL`{<`{(jy3b&$oROH#-CG zxg|9nj++Zu}5O)238?&z6uTvO~VvJ*^LQo;U`fIiy-8%^9i@S>UG&y9A> zBVN!^3(nM?toZsT-h&-?T$ITBW>efC;)+p^yJu6Z%*DTp5*7fgfLL;g3>BD-Jupdt z8W4`1JW>ONV}LQyks_%LGHK(j9UMwIPHb=Ry47WS^`2Gy>XBV6qTryxHcpQx11WjM2bDHS7m^bq<=j7WGg=IVj*Xtdx;$x=X} z+Rhl}6uj1`!|v`Xm~tBBM1w_X2^@Jvam8X{*M9XhrsRT5r4~@r5R2B=&!;1yW1_5> z#G%&Sx?X8vEN;(cDJtl0M$%o`q)4MaY&=eymF1zDuWg*P@~meHoyo2_g!uBk)vW8{ zqRVNs2^OEUFHz(KKtC(pz%J*WWp^@Lq7dwp1lEX_R1Tun>ItP9Ay}7{WbPK3ZP*(g zz?3OLNTLe@yg2$y=6)0**?2aL5}g=kHHJ#JWCNk-ItHj70<6m(RZ)ktO7;j!5dk)5 zlLAd5m(J>U+x!JjIb~5r%4NKM&_qcF-#kf`!7PGTg0kLE&vhGJhJ9 z(TP@N7G@AEa*K;w^{|XS1_ZMLH4LXAO>&Rb)Z|r5?765OeRg)wdls~@1uHJxc^7%` zJYY5f?zsava2{~z5YV#))769!jTaCtsNZZmV6Z_`Jm$;PkT6R2|NCCx9se^>X{=2+ zr0buKe0m-0e|M9u96bdcTvj)kpquQ%kee;X6{B%76EF+G6^5BZeMTfhgt3&Gssv+e z!B};4ec!Na5o8f2XU-VUx+0N4$kk5)!L=q5eZl3~w;VXc*{5){S*TIV~ zQh)j7oNk<^bqiRiGpsBu_-HgrI~CZNO<*oA1>r6n^;xP)IBsrTO(+={1VmEPga;X* z!qh-I2n>i8H zph{?33Zm|Bn4NDw$PatnK^ZzBU@8siMYmGU^Z=mi5wAoOJAdi92FFEN#Cvr#$YGM0M$je^= zRF$Ux`Hs-N;dbE3BgJBM&vS{(4*+vJoNs$8I5q1*CUuKOPG+GHgCel<3DJ=dg26%3 zP98%0z7L@K(l0|EKM3je=>P3)?$=z2@k_p&I%<8`SK{-J;9}jgB?oPzWuzek7DWsW z5eZ~gG_K}Sj?f~(t16)DE(s1dw{zn$-G!maA(GyY5ob@H_%_X8OcvgfT6IZ9AQHw+NT(7X%>e2VQISN8jW2 zsr#c#&+4i}3kj_VtEz$_QQbUMA&@mGaAR}@Vi0-&O}#X&c?>RqhO)hO88uzF8ba_1 zRm6p%GNEYB9gNllEH%$sDBp<@lHDC1=)y3L{uasXN)0m+7B z-|ivHPtI)1;rtRiE0^qG81oL!$(e!T)L<1i#tJtXu#sCd<}{C39Jd@9xIL6K$mTF% zn!s$Jc1=Q04E;!i3~#eBiD8rrv$%$H0mPgEm)tNmmw6AED&0K3fxyQU+*en)&}Oav z(|?rk@=x*N5C0^t_}%~L|72zV*<{sSK*$7^Ty>5na}{lrbJ%p^0u386cy{Nh82#Fo zd~S@WTjjI&T#nI)K8cxMxx;(++{4eUk8w>_y!_3-<-^$-Uh%;F@Z(1@zVcec;Re{W z+#HV3U6_Yfm1_`T&gh7-h9cIX%&#`r0g6j+id-L{T9`uP@M#AwTH;)13RPxUgXrbY zx;@Nf;=&W(knPWSE^l63z{9c2doHbD{+g?OV{MJONtnzsOSfK5CHv+kZl!)NnA2hA zZXzO3%Rq)nXsIk+r5QzBmx45B3>75iiL+s%3Aw-qu?mGld^#+{tI=J zV5Lnhdn#0=oPok6bhRv&=$;iYhXVARJgXW4L))ZsHfHdYvXtagh9>u_TSMF!Dq&PO z>dGxS#b~2;HMp1)g>#mR^$niA5EZg9mzLKud~g=HM=(HPtx|-Js;Wo<`ZH6EF=BCk0j(zd z>aYD0?*IH3`S=rG_iL}cffp`ZV9YhHzWOSjJ9P@J7qe^~EA+ZuWK-Q|v{hupJ!9}JFW+~D!AKZ<)l_gPSY{d+IRH=cOXZVo|ix&C_WUfk{* zqX7>dJfa`^=!e3~U-mNGdi(A6p$~mH96fm)@S-M8)X6Pb{psYtJN)d$b2$6Ci@tB~ zF1hCF>u~7EK`&je&fUBAcr!{CB7$kQ!Dv%DRnG>aO@V`h;Tpg3$Rjv*^q7DBfiLm* z-~Ri4(=E54>UBl4;yEvPo(GEj;oIMeFMj^>{MbMIZ`5^d3v;tF7z~lx)_>{eei7Yn zUpy;z?%mB!uU`gB&H|0iiqUAmCbiJ)&`v~3P2u-jg2Pc)9bgKm+TcTgoecD*qHO3! zG33+{ZQEe&(lSC6PEGZZEzwf);W%MsW1XApn{1jfrlQ}>apM4JoO&u2J7R^lUSAY2zJ0Jb%hm=BD zUR_z-wQI-n>gu=vcY;kY5e{|5#1dYHZ0-ePJ{i}TYr&Pfz@WuY0)wCoQx%426K6TM zzRF9NUWpd_(+((yK@b2bhZ{^#FL_JJ--5olOc3o88kA37o?H3RJ`tefO z5*gmuScm3JfLPqN&9A)TfKAu6oL^q$#j|J8jG7WHb+?JxNGBg!2ZM*wwoMYrynnsPWAp%W`51eP-? z;QYe8_ow;{k&sEhR7OTS8bATmbqyAfv}_JHFdB}X6m&6GN=*iKiaNGw;4#e(Np2ft#+q38$AYVPSp&H(q_cA3lDFDXGs+FS5xa z4mQ`JR_1VJ=s=Ru;l#?uT0y{uqDYy0**QBfIbNdQsr~A!uS5(LKKYr?pv@TsJV+JH z9hDGSThFP%^wf;qeEkjb*yG>80}nj_QlzQ_BA~nW?+IUin2;~VhOm%kjZ_@3`oZ4=+| zj(3oSCW5)?8Gh))AN1U`{@iCjI}A4l*t>ThI^D_-9XZThi#tNoHg1}^Faq+`JwR}-q0p^*dt=Ewn{X(@imnOQ4nl~Gk4VE|f2XK2aNu7#=+1c?v`qzZJ1 zQ|YacAx#2LWjZLalS?!w$Yh{L1Q9?BV9G7IhaY*I~RC9B9^1d(VE&#g^?DUU6^;qaL0POOSC!cUoxnYeiZodMO zGGh!}KXM4;mwgw<>npHk3{MH;;ks*f#$F$+fWV6V@d)Eqt;rc2Y+9I^j7Y|^1$<7fKFCD|I{%_qaoVfEX^V|tI9)b+zDW;8C8hrMDwOKR8B;i%s?>3C@0!h zcLM-{j`84gT!aiLX2FUiJiF3Bz(*Yj$0P0b`@DX32C}(2t!ck7FYJE&9>&0)%z zDVb)j6})^P=x$VpPsK6Kq9#KKk?z)Yg}IrFDcnoG&S^BG0)a>=l!{&Nc*@f>7uN!j zC=XmA#dEAG`e-eRx#a9sb~U&~8b#>pTAL5o8Jj`Sidy~Xs~PLc^NBTti>E6+Fl!2t zI*mOotp!`()TzrW4%bE^sZo=^YQgreZgDZlQ z5{#CCO5B-T%8sY(^vyB_&SXFkda+|EEd%2!q6q=oHn47ho<9$S=v><%kDmZCfRyP~ z2UuMO8Gy_7P0XOVI1xgg93w*6e-y31fUwGJpS-l}+_9sSN4f~=u6sww#}2{i@SAVM z+`oP!*53RU^rmlQHPc5Jwdj`Yj+vW?2UOxnR*KRlg*?u(-XXUJM1eU;rMr;9a^WfF z0^ng~&Q`5KD~>Ak`?H`xENkJ?Bz4PW=s|VQ<`g$K&B0tD5I2PfxFC8kQ@A=^jWj|; z;Nw=3CsYi~$ViP_38~wJOkTp6aO0E&^h9{m{=L3%>*d6EycE3U2KqN12VeRM=Yeay z{&SfM2nG!-j~bDm{WasSo$%@<-zCWn zao7;E2BuUd%b_MgXRk{jg16j;`owVzf9zkObJ-4ZVHR?H$su5;(}gAtjT<^{SRH4Z z>2#zY1smBsdho_5aKixRP@$Fl5h^!t9aJ*{0*e{$6K*oxyeKlDfoho+fe4b4%nBcg z;?Zj-D1j1!iPJr28bEQ1TS;N4XAg{2b1>61W@kXiZ2%(~LPYSA20$f}vY9v}^!o1R z;s(rKb2V1ZUzE{>3tmrmApI^ni;D@Sqv!1g?kOZ@GNGws`G7FfXIc?osnkK`0eGhP4%9)|=NH5aI zp0SjbVPyr2F`yS~$l^}xq)Qkac@ov3Lta1QF5>Xn0Pi}weMf4EP7sK|rSF7ui_MLR ztCetge-0i3Hq!fXy5lY?4CFVJpaW&AZ2RSY?5v!3MLJO6yXjN zu}K|QAf1sa1&ouv_7KA1Q^3wWu7ff8gWu22E5F~HKlyXNbYY28yLTc^O=CD5v1Nj)1!B>Q1Qw zGJwv%dSlR!e<63E0t&{>NF-E_Gb;tXkMH zAHMI0evJ3M=YQdW&)&=FE3bm|D?j<+zvsR;z7cC@&Zw{oD^DJQojZf|<447J@5Rom z_alynIQVxT1r~PUnZNprsJ72x>4`(!an+UHUtEC3E+q!5Apr&~_PTa-?UFqH-~)W- zt#?8?m94c&*y(ucM4mZ!8W)!?VeYzXNTa8=frMZ&1kr4OnYbF-HcduZYUR!os=F~j zV1$~A7*V1mMnPb9hs0Q%@6i#p7~fsRDNZ+nK_GCpFk_yi%Mpy~)XDn>cM;7HxF>fQ z9iE+57C2-#rcpyPc$N$wt7%D3z!7LU1(493P@W}@tOhfKCWV{Qk&zqs?3rz9k&_~) zduZ_>V<8EGd z*=6{Pzx)f_{j6v5kKg{^@uNTSqgr=*(y3~;bRYyQ%+BMP&%6r9c43 zdCz|?MFdYi`2-&N(wDKgxQH8Wyaw&K#g`s>V8YTB#t<;Suz>05X3pq*V>K-F7>&yPZ6Jl9QAszZnoLkG@i^I>Bz3`k8a* zan1f|?AX0q&YwLCcef`FKFPapy+cM#1BpRQ6)ndyKQo8b^-b@0yJ*HEE-hc==aw(} z^I!5pzU)OW$N&7Fe}bv`1+;m<&wS*Q{_lVF*O^U`atoG-~Klxc{nU`{->c#dSCk#9}E&VD<>6L=pJRbQc?gfsL9m z;FQs5g!T1x5(0@82AgYGTUx>L>WYuXLvat7n(kp?eh!usE-qcd`sTVDj5AZynA$ZH z>L^HUf~7W`zjP66>jP`Y!!0}TmXPicY&CLD+UUIOm89H^wgoTtZ*BT~8Y#hJCr)oE z@w(ZJKp@bI-(}FWyz#p05S_lfzQIQiKJJxN*t_pC?%KTrd-mhoxHiM7`4~GvOzH|T1J^xs62BlL8TYaG=?mVeI znbcEFwo$$nyqipF$^fUB(QP8a(;boY2@eJn9?_N@T-uMFrP#0pSSc){}|=WO?W;eM{JEcvDN z4O})D<5jQzPVCse3+FGK$Ej1N2M%y!ebbMfI6fgmGgP5s>&ZKzraQbDH6Xy8%#WTp ziNSDy7=oHXw8{ADqmPBn!5EyRFrWR*=lI|K-QVi$+;n))JKxD?JnNab@#Y&r!gSoo zRKMrL^-b1w?Z;1?z<>L*Kjp8z=@)U|7r%(Zhn^~dG^J++g`~OTcmB(N@z?#U*W;mw z9+V&WfgiMg`pjqT?D@0uuD||k)S*VBtyFcy&;QcD=gw}`(gh@n(Vw4(0Bf><# z8Mp2s6r``3xhLhgZk?H|Iu&CS#1IieboYt^g@iy)ZW5%hNf{Ypn3OmbqCwvsSz;;S zK}o-7p+wLv2$4&K4_09pr$9Ln7mS%Q*M#mTl$U{b`X0#|1#yCRI4rQ0|MSOhc_-c48BOp&OO`V5VPeKdUp|ATx8f>#b9m4 zJJU0)=H?kk*%g`XI5~7ou5S8hJfyl=73(T;~*agZku z`B=@*j|bFj98+yhNuV$%L*0euF}r|wLBvp@amTzW<|v^@*w>mtSX1@q)DiWLT{8XC zKaQ2JJmK#@e}Z=sxJd;IRX{~42Swoo2~N5=rpkfS%nd;xeZrt*q_Ye6$ii|D61@@Q z0>zu`L=Yr0)T9fY!f1`8u$EfW&4IjRb{>DRvce5>?CW&Uc;>Ll>@HnEnw#QGe;Svs zu5fK_ecSxb?dLovcXH0NcAQ>|dF2j?;(^(Xi5*BAtYOFLmfXc$jG#%#1y^9ngGDn( z#ip$!LPDgaW-QSi3>0s@lIUeBli^h**5=HRGCc%k)=)~BtP&tVf|(^mcEjAhJ$Y?u zInd1|rvOC-7)0P5bs)8&>US)RBARX6C4S!z65d)&Ibd}&+tm^y2uw{mo^hvC@BBa@ zqlwVNa1*ALNL6e0Kr3s$x&Vf3^hkqxWKb2Ck`xIDfu3#Rxu?<9J)1>j1w%xvf)R;K z2_Y+kss>Gn0KMB2Yd1BFh9Y&41OZgt5(&?AGdRRD+(kjFN)wM-(Q(vF3QQZqs4#P{ zngFGN>cMk@n0Xc`QyYT2CkLrUQ!`T)aFXULPA8w>!o^M9L2=W`aUIgSSODl&ECmzt z4B**=(~GO!W95qAfaCxb!I&9?s$+9A9nq$RoW1BWHSLxgGMRZAi{#dL=CojX7AY&L zy}OIfq&~5`1OPe_wlS$tfdFN@OI63rY-xqRvY>Y7am7fC_ zcR((!K=v# zD_V9V6Pdi#5UNme;^tZSzMAd-`q5gLH#bf|d|iC}73s2LKXi5g8ab1Kvo zFP;XtIkP3N39k!qP%6v5y#tQ-?9l#8UM$$TO~bXf1^@I%oWK0bGW^iT(Czj>D$;vD zi1>Z4h5wItKxXG1H{C=~0nI?DF|m*p%M=N0ZoohJQSh-RQ2or0z_o*V`ct^HHiS(H zQjD-xMcWpuM2WmGx+GjZy#e?;yPB+nulZkqNWkQBG0D zNi7gyTFwPiv*`THPr*O&agQ&!o0T?bmexEk%sAH9WwQ5+{Nq5=;;c2({AP3?^(^7uCk= z5E-k2aZ`%Gva6PywHVD=A!TLo01pZ}S<|fe|FfiDEGK%?sy!^TNf@nVUzm zx#3^<(@ThT4e9qFb>+Uf&Q7c~%+H45+NP%5s8NCw?rIcQk5vs|6Tz9>*a1-LG0oK#*=aTCS%3)Pw*E8*o9n)w8`LTsR*p3f z7;lV$s=|($fGQe0vt4%jSGs=nOTeB**AKp%+Mj0q)BnaX)mLN-paHRzwH7xO2rKka zM*uzf@Q?nCQ;fj;Jgmu*4<9x;e%$fuR}q~KO1x;obd&%yij;C?r#VUv9>uU$;?y2T zL-->PvOahSE^sU_qwdYYKKmI@mrio<&X1z)bP;D3xVf>4^P_~#QjJrHMWvrz6$}Y# zvpI&LD;zn*dLGGIk_j<*=!9s_faxIExnqv)KzVX)88zu$Q!!K+*Od=f*AVI&tU4lA z(up)ct#xf33{TU!2+8gwJ8tN~T^J~J@L(ke;FBol+U37Iu_BH3t@YU%hOwZp}QOkC5Q z$~g_;l(0bY&FpMO8(63U=2dY?fN3kA&~6Oa#>&T`xRh7Sus0A>v{Izx^eekl6aa?@ zBTV=Dpk|Cb12l+7pEYB$#7+>52?jNEp_3DP!fp}lbmA#MK0F-Sw|(|=us6QmufONn zxbBmmu|6wVL5@8kXU!nReZHT&BJ=>GjWMQP9Xn<9`#val{a-(Ujipt@<}vmccREUTOx-s#?o(U1tC+hf@Ue{VrCOBtaVXmW+)_3Q_n)cQrXA3LX2*75L)VH zRov(#3fcu~p6JYGo^z&|qt%8?bd?OxiAIHGb5$>UM>@^2=T@0CgXVBkZ*ykSY}#ff z%g}60DXHdGG;7xEF?nLnO113XIx^f{i*tS4CZ;w6mXTGFat7Ryy=({##$+b0EzAXO zbYpx>YI%l7Q$-~R0fkyV8v z9;8ALAgkf%(W9m*%j z$ll#M@YRPOu_h(sWnz9xfVV;}y9kH~>5KY@LF_Tk6?x#8T{PO{}Q|1 zK19Sjb!33Uga`ppINI?TnlfF85QBGJy_M4DnLMMGDBVui*G4PaGz|mc#>}&)FXGJE zGt4Pts@s*>*?Ch-G8hc8bm@XEFRhD7LS%>CN}!tU%$c(s3^rhvO69ltmJt4}#^Ei_ z$yT{s3Bn3NFBK*NBKy<2=hI5?xBUKFe=FtuR?=shD5uYy&Zo|vi3@Y{ylnSnn4g`a zyYkezGdOkXB(A^lMqgQ7rK)0XeqP2KBWw-_5D{EFw}iFzO-%QDSXsN|i`y4Lmq0Lg zy4^54J*Dd#n>cvzsaL=7+g|jKanj;m9O5=R^=yKB30uN2U=Arb zmck;AD5a!6A)ZcZ3@0i)zlnu(pLAY@$)*;CDGVt<%8BOb&IyyFB#_GqrXa1i#CI1j z0+S0+g2V_YyZ;D5`9g&=*uvZbKKYr?eovVOi1oYEG9EYF+!!!rrMoGeA!YTo^)<{+ z&HHdP=H~h)(rApj3OIfG0#?`7P**j+?FBEuHJ9(lqmMm-`yYG|>l+(Jw?GOAfznWQ zf?7f;i}5X#jyVe}h)>^I-_**#<;HRG|Kp~abb)QfQE25|ED?YSxqN=&YlPml-h zz}X9D z&z{}9?%M18^r@3EgaY61b$ecQx|&*Jr(2cbhZ@S!xYSdgKYJdhPaLyH9(_XI@KZm5 z3un&a+=UBt1LqdzFdU6-eQgyp)0gojFMSE$@y>Vn2xCqEhhEGrqRAzIE|K zl*rbShY+c%$d=2YNCMhsBo~$jD8_^;xF?SdBvJz`zEyM~+Bms_$)Xq2rdTn`;EJ%}mcAHI0nN z36>Kq)MeevTfqJ@t)&$9o{N{D9SsV1&{(ME1|`L`WX&T>HI{@7MQ}u8(0W3scTh5t zlFo=q9bhUftj1+R@7?`QXx9oW=9ZlAxXAc*HwUv zF;EJUMLooTI#8Mrj18oU5jhA&sVS)h&>)7yU_k&uqzgT`OK~|XRLa~#vN1(^#fT6E zxsb&n0&x)#!s3uG_itj&fCS4RA?9Kz`frKMWy?}{fKGQWoC}r`D^quivGD!eU~tcx z2?=Ni4cGD*Z8ZaolOH~LoR`n<#-j(15CDGo+h6Rf>uXjEhyb}ZC!f3RE?S7P@})1q z=ceJSORg)c6be%|AOuuZU`&d3bAYC8;DaHPsb{m0#Vl?Puy*E5_{P^B^>c36aosHp z)fCpx9dSK>nw11(b5OI3kTnc_z_%U)8!4lfz#st~F;wmz-8m!XnUqte*hb*aZrAJW zJG{R08ZLeOSurOQPuXY`#@U2!vvQ}U6zh!7Nd)CoUM z0y>x&VCo=K?mlw&dLpcrO%&N^<-2+vS+)`OPfg*D;lP)3=H97UOd+tN38@*-#*w{H z@upCPbLTHEEG}+ajOMvDpAy$Dvh|@>In^VA(C8Ek<|a9$s!WcZK~r){6cu_Qa0|!5 z1XdM(X+mVEJT(xCM?|)%L1d=`HEM`f!Cc3U29YiSig|#WxNERN7LPQDkH?mlmxH7+ zJR5@*XtJ3xzz|}ru)bkfIw$$WQS_(!K(}&N1R`qw>Q`gD^-lA;7BEQXRj-D$%J=H1*QQ!%n(^D}FJ3%$Nr6fVUEJ@ayq!?)C zq==Xy=4>G)N~pk|(_G_RRe6g=hV(v+H@T0UVVD-2Nvcc*8vd>##sAZ{YTEd!%c zchz`O7DTR_XGBPySyrnXjN2A5 z+8lTu4oNrEPH1qHV0}O%nN3o(ATkZE^h{$VlXrEpSBe5CNG&FpBEmyF7e_ZF&{a^l zDik4z8t#l0vw#u>bMvHHbtJSyJl6ubPXC2xNBzp}f3r}0Iv z5R{^9(yX*bBTjC=!sH9D_#R8^7X_!zBIU$-JO-ubD+e1RTyf%*cXw^40apLtzs3C4Ka^+*;~#!4Y6*m9LDK-8nXMa6CWY@4M&6{k zU7~b;_?3>`dx^mqVhNr9{)fb#E9g~K)~lqBP>HkD2L&RS69QKkPPSDV-~fgVSXZx%Q8fMXKyH{*f4`GGHB z_6@JMxmSIk-16zq+8uyDY0jF!6rmtxEJQ`HkKldJygx9)8+h*aJ*YN< zZ?3L_DPeu-68hV>G4I=nfxN^?XTbRQ9wb$6W zBgZ6fjIh}nd%Jg|Ki!iPUws%ijv935XK?b#C$MYJ7-_hU{Rgh%w#7x_+(mS&+5&)! zmsY?in46m6#-(MT*RlED48MBm6xU83hq*D<5lKstOmNU?W=YF|EvrCsDdSUu0-A~m zRKz_r>R?Ivx(N}RBrd^`loH*MN{FRsNDNjAN-3Ne9n8ucT}ua@J5W;UE}plda7HyP zrOa6;^kHS&mU2_ma;~zJXe2G!q|I57HA7Q|dIp@xS!t$Fx57QwfTV_;ljNL{lf%p` zYa3Ed&}=c~*34WqwU$z5%DE_FY98yzoD)c|umwUEPbPG^=UI3K%ln zii^`U!(f(8VOb?-Eu3lq7Q~SgP26D-a1&)f+l*0nI}8%hj>i~R4W^`nKw|0QG9G&5 z5xn`=|2_WKJO2Xj{PX{Xx4!-NQN_SF|A*gzFo5D1wv9_OStBW?R?^?Cvo5XpD$}$Y3)X*H;v`hO8`W=-5#c=rg`rC1+1*CiUjdk zb$HL+_k`ibI@b5CVR`>DR##SV;^a|ur)vD{FaClv3g7aZzlkRg9mK}^nh%>XBtRU3 zs;X3T3Y&u=nv=&+)mP%C>u&P%=g#uP$%);T(;g$PYF^5SXQ{h z4<0=t+ZVUvWiNdZ@3{ST|HP+1&E-oM%Xer5HZ>(P+ZHiCcTqxBVc3pv@aPc`0XJNK zjo*CZ4f4M~{z=R(%;MOwqa3#xp!?hY;P*n4T7T;C$83FVO_o;I{MpZYmb~w;-ix>V z##`{+-}MUIeABJmwtF{HJH}vRgmG$7F<@;l#&|rUOOXbLDM`v1GjlUIf9@=rrtxMx z#`4-4*H>3~`pg+$U)f-9dK&xp?MJuY@k>jW{MhlMJa+sPHa6Gb>eBDepx3Fesp~#k z8X_0>(U$Q0v=R9KN9O!L{;0^9D5PdMX^zZjK>k)N%$6Ac|L40nx4iCUMD9fjb+?t( z6bkGD-Ek}L``j1h8;?Hv(mWVKLM%F+lpnvfZ{NBYHbI&fdo&RyWu(FE zX`jqizw(y3+)HopM9Q5Mk{02;u+GK5#b~X7i9;qojZbH0S;TfN1*N`4InjyLfD_uC zu~_7#oF_%fjNT`GSt8{t3$M#jRmk0b2VZ;SE3a_?`!By-0*TFyO&^a&u1UQLm9(*i zXUFcHyZq!><;g=&*~V~F#!chLPaNlHIL39?T#siz^O<<+(35=UyZ_3XcD&^-52X-V z%jGhZVX7+~u5gMME4NOPTXg?FZnJNRGi<5A{w)(7PNo!vF;RFgYDJU8Ld>sim@Pru=#z5ji9{&Qb| zm%aRDe!~sdW8303Z<^M|<3@ID+dkQn3ZWUpQO3EmXD}EH_$&YR7x1-jJb@QJ??qTy zz91*gowgUf=!G&rKZk{d1zWzfEaTw_XU?3H)#Xd>Nxkj}ZoByoKJeiEPT0hSTwGt{ zal-0glVLot8?L(vscGcciDR~N+YUK!#a=$}(8Et32I1o6St?o8qaqPtCJ@{`i@2DP z0CJ#2gK~9aee3cdhQKTLUFOT{8(3alrfQnNn@TD}bwc-dx|7Upf(UK<_8qdew(R3J zg9Lu_Ex#51`hy>U3;d2-@5HNL{e4(oxrou`u!!{TUdPJTR##--Wd}?|4bKkxu@lejrtmz!_78PmN!#_a(8sVTql_M7pCZ~O23 zy+8PU?{#Vpha3EpKl@{!o14YeH(bM0pFN42Z@vi^mzLP+)M%TQ)~b%ijWmNXI-Nda z4BS|2VQunUbZ)p9O1Qmj*h6rm1$Yoj8Q_$mjft=#RNaEXJ%j+IyErweGln9InL#X+ z38sgFcA)Tj{Z>gniG5%m?Bf{+y+iBb~?m9zkvGdRo>Tu{GR6r;qS7HTE8Kdtf4d%@4AA+|4W zfHXpLoXN%p2R0U@ETs+35hXH7@h}@QJOpvVT>y1) zs1OklR&K#zYK&ym*4&Ez7+e*T7B+}TOjcT6Y3@P9#lh5OmjFZof;xJguGgk)+Qd=P z(p2XF0%5IE-Mxi*xBQ`$iM-J$G&gT(%vOq&yRD&HRji>H569^AyFjM{OidwlqU(th z#H+s#cN-{3K#9m!={5(`CD$6NCxfFhLAF9ba@QX2Of-nLqq@h(Glcz^DaI zTmb&+uhCv}J!I)3_&fgr-Gwow-sbtK!)#*oloBLoMgmTO`R96RD>I7>X zS$3l3WtfwoAVO6w2N4mo0%g^Z5OPE-ImkGv^${#*PD<{*bZ|gu#sBV}sOl27{4-_S z3C*n_yXFXBoFt{>8A@plH3bY2fI*9R#L7}I6GU;bRCHRz4yUvG(eo7m&R!Jeku15ps!`mW?W4S*jPm9C+7zP(A;-z~Mt4 zHxoljsJa!*y4=^5N@brKxoyolQvXQ26SHkFS+*r{GQZDk3!z{ zC+NNAbwElJw^Rf)0a*q8X@^>2eL{+f)Eo$oxbI3JD|}|QtXm7)=zxp514^$dpa8WX z#nGkW6a-E@Rv}=%k05|jnXg}3^!bTmCH)Y&E-oj^V6&lnUhIxYKp3@tqmIK!m&L> zn=(ooY+&DO{$Dz?yv*6JJnoySq7s0ts6#+qQ8o(>1LE|G#*PtF4oqvqKtsbR=Y{k1 z5YYLKm%wM{;LX_CpDtPPx&wq-(6(CL^E~RyUqOBEdrK-M7(#9lJ&K7b3?dRlooy6_ zYYY;DhOBHgJ5n+Mr2-k+5o4rut>danYX?YK*`1!E1<@v(qn5}vxtj_~@IjoY39%?< zLPn<07eL{zmeFHz))*@`>e`j@s57o(Ue|0lR28O7r5SG8xXm5_nIDg^zpl^;f|c;9uXlab~@eteR=itKzZPOqC&PbXB_A0>? zy0Y13s2N~DLxLih19<)XG;Zh%&MXi8cXITPe*6>su_oK}x4qc*Ro!@V9qstQ=)t|0 z5ayje0AWGcQOD&Z&ciV9fIC8#19Lm^PnS-69U~X2nx_XF-kdw*c`!hy)5F{i*8v1H zWmwf?n480NZrRoythEWA4cW~{D;Y8zNj)_^DLyrfazbEl)fQ0dP^!Losr(%=Xo?DSVQEc4h=bFK6Pc&Zq)dRT4iCkb)>Qg9`$Xl1>bl zgu9cOFq(l*HJG~sCZV~)Qbx*FI*_wcz4eq5H5*dfiowy2vt&)BINJ=a#b)X`!LlKzjBEyTg=+S! zN@4t(NcpTO_^=l_Zj1K#+CH~63ak3X}Azw{OP{kOl3 zM-CnGx%oNXa@*bb%xCYzH@@*G7Ut&g#Rt9&IE+aOM2%hQVk6H%E-{ z7ryY@c>C?Q0S4PYw;uxG{=NI4t_YQ2=k^`gzGDZfs)OT4kK?JwoW-tToWH@5&+=cU!9U{)$Q#%;?($4_E39<$%=LxP}FcQI-jxT%{xEj^MH z(C8|;SXfztkD?_K3|9f5OUq00!H;~5FL>Uw{U?6xwf^aQ@5RGkc^Kx7!C=!<8gY7h z3I`7C_cN!@aD8(F2M%1p`MG(1?z5lApc!KO>;mq+|A7p+{LWi`o6md6i}bOte?44U zTIR)zOMc58x5~p0J%pFM?4@}8@h9;9_x>#o-hL22@I$Y`+`WWxD8V&s3FMK|9yFI_-mRoqub=S%3e(3vr z++@7tFaDB84j%!veBp_s$I&!nE^OOogS9oTudnmKfh%=$u)$7keC-eaOS$j9`?)z7 z>|PrTrl+QQn{A$mvJ>Bnd)Y^+`vf^BaG$h&`Xq50CNPpM>D|0+^C!QLTh4xGaRll_ zaAVC>lJDs!c+K~(mKd8TbAI{(>UcoXlt?{j+J7w?rH{h=S>FaGi``JUZ-{K>~2XK#AiDFCzC z=5Q=kr^b#Q3%+;X9=_x|{ssQ=bNBiCKl}my*lT_mSKoM}{N4NC@6WvF*|_qG19EX` z2`5gT#DV<>ux)X{pLpVs?^>Lf?|;?z*n>mUBuM={#mv|YRQ%Afz`yWPy0$Jtzf zwoS~r#b#=R5~@-f;&X{_0op^jL(GJama!P_sH6RL^+vi(Z1; z@48DPJsf)KN!)VFZFF<{r_bF-O5n@B{a@H$z4u+bu(ZVIJ@@(8wR0P)y275_dvWIU zS&YXGrsk%7+@>&YMo>3*GdANfQW|^X>SA!WL<_<&S*#=))I}f;5i_TYdayt#W~FQe z#vpEzGqM{4B3wW*d%9s-)g~zvAP6BTmpq0SjI+8Rn1kZTW~f7$yt@i@7_x{7k(!R4Kw@su)9>6eJf1vt%oe zR0$>m7dkZ52oZo%M4=v%o13ePzyx$75fD&hadAgLRC5h6qNEl`L{W7IHAvb2m0Ddf zH98@j1c}R&rU+YGj&)LCZpdoZrYy#S_QS34(TW9nEmaoB;?urv{poZt885AX2QO0nQ-7jKq0u zVH*R_%?Q`*zZM5x@e+?2Vi%UkwbioT#fXc!Ww)-quP9}%ffzy2i2-IX<{+KQ(1Tb+ zmMJfouWjzOBXn$DO{T8C+HvYQ9((FZyp*u{%0*M)W;4cgh%!?N>JX3`MdgrgOc+P; zPN&0;st3?}bJKKH4AzGZI)xPgXX|u?fUeUN2oS*O9!PRBCmNc=L$NZZVT&C*rtPxL zt~6?lL5%Kc_Atb^GL@{@o$4GMtksJ+x3m3KXU9TYi>H|cl>wrPdT>$2%J)BxX9*q!t zT?Zn3b{qNQKZ5w)_d7Nl&g|JkPmO!Z&>-HJBS2(wgmA(cjUGh-5n9TwaF1ju=59gK zEu>sXaBY$Z_kd7br{>nRmYpCjn+;<#X1M2OPmeyu>dZ-E+jjIfL<Fom4mO+1)7#+JRW;Dym9rzzMyJ>>#oY_0}l)>3sBpy-HTI#%8h zdR_Hs0z$L>gr}%I)OsLslfrYF+7`FHd@LiN^vz>c9d-q zL)0MFbHh>2KAfIoT~`R>f#%ePdam!dd=D{Rhh2U-@<;v=eBtv^ZJYOi2@BDRjd-g{ zXc7%8+kw#-X}HE}b`~@1(pOwpozoX+$Nbw3I)aH>onWaH{4tai$RIMl&+s*6m_$gVB`f(QDfY>F;~0xAm0;;0pxK@WnMwV2xwJm*9~3|flH3tu-Y zU4jQSQ&Yk#n$Q@W*|H&k`|h~I7O%RI>~#6mz4u}B!dV`;<{H=30(Iq0JLU_1^mVrS z`7hwp|KpD(xm$nRB1S7~%q8JwWMquufJ};y-6aWBWzs!dX8Pg*mei^$O2~p_8EuXh z0ti(N5`v<6nmXiLNo^t8HUNQWL2Sa%D3Iug9x-(FsAg4&!6YN}YPZY?M{ISN&K>+?`-rr;#Nt1UT7K)-8jlAw+S zL8)2_Oeg09pB&2F$};Z;^W}?z?c2bnA^!Z&z#8C-Uj}~g1ITBWpb~6T0%dc+#>E3l zO@{<`Sjz}nzpA*VnOY7PFgV8mBLWct-x#Cc?fFap{vQk{j`GkC{4ma{Gl^p`9$7s% zgZ|VE+O+Cu9XcN2)M$X+^Yd(nLysE+^cH3jNu)Mm%?!yLfe}*zbBjWlOl3!(hB{}6 zDPj<$r4>WB6T+)sVe+b13Jx9w&zvT@HM}=lj5{Hi_5$O~4E*`eG5O#J0#BcIUU`{! z-I;RhRoTH8Oqo((!JyefuFBG+EhMW5;FSbKGj>(z)>ugHaoc>XpFHAuI6$7A4Gyz5 z1+D2-PUfIbU|=q8kRa3$13a}I$kqec2y+^s;xXo=QjJIb1fpv?byX0_ZNoOVpqf+^ zR05x=J6s*Na1y&EA|l(mxpZBzv#z~o@L}6XBk*2)+9$@?W-vOKf${nfZiZM39D+E( zUDAo*f_}%nX_SzFo;nZ&orw>rXDTnii(>$~d-je)_EP*&cbv7vJ=0x#&d#gkZG?%o zwy-}qAdVn!hsAm@8bY8r;3{$vEkY>~v z`cfnrOI8Nq?xlPd!3>jJnu)oYc}Gj;RLZ)z=8$^O=4mCXK3hj zIw0J8vCF!yu(WhZ)D=gM9>r)l^jmJd1^@Kv&*0L^3cvRCNANfA{cF7cLm%?b-}gnH zI&+l2d*$!IHT#)UC$V?WKCG;)@chy_?A*Qw_kR8hQW9aM*McY}Q_XoIq=|p;E594B zdgZIJwzh$)0{b&_UQu}L&V@Le(;e!+MTEzK_m*8fhjuAio(?7$NwPpYE{SVl=r3=W7%DHprePwN# zDJ4uz^>N^a%dxt;hIhaFU3ktt&&GiR2QafZ$14|iU{Y3U%MMB zj~tPM2cPh%nHd+FTz17}cFh%6^ZqY?iT8c}i`FzFLSV2GSuM(L;hm?X_~t|TpBaLE z3ld(mMz_hYwyslAO??XmGkM-mG|!1Hx2552IoMGwl;5Jrm3S++m?=_fOa*|O`M0{@ zWlJ6$k4L=!!7uxl9(suP?cc{A|B2V*SAY4}?9nH_A@_dfA93o;2~@H2BL|Q2%B!#P z;ULJ;rAy8LH*KMs@Y>h?kpIlj{ImmM>h!5oSKoB&Esw}x^vyIW3P~=zOm1v1uf3FN z7W6p^L|#Z3y-WorTc4*(Nw+S}mI^82@GS!|w#0M?5nu$ug#M;rX;&zDYlxI%^_GsA z&CBRRIDwcyU}BDW1THwR(& z&Yi9)VR>~~zWVT2xUsh3O>X(r;e(i;pYb1he|iE$`Id>$w@iU1H)fIGr9do;jq8hFzMrr9fmh>uzWbH5oW$?`_HXgdXWWUps_?PD|Cqn+58sAf_s{tAKmQB3`i5)$nyarx)|SVQ9;2q# zzV?l8_+Vp|*Ij)r9zXn)=VYv+xJbpOZOgz)0(CTGtc#Fw=*WsUTgV(^0g*^C4_TR} zxRg1!Zv`MiAn0T^xE1dHmJQ6e&28sX$Byvq`SWOV_E^>I_xo61TYWmU0Z^(aaL`Ph zGziSlVvG42*zNY%jz)RU?%lGov5cG??Wnb>`B{#ZmY6N0(Zr<6@x==m3`aP8_%J%% z8rNKZJs$qrR}Eg~Tkx%)`*e(fCr%%OIIwbQSs(cP=R>#d;&rcmtu^gPc5d4)H(Y-$ zVvK&p)mM}`SIYi_Kkx&1+aLTsuD2_5_-@LIS`JlKy-5l-5KZt5p@e>P)sJ5o@rLfp>0BRHVXhU%?zMHS;EUs5zQ^8 zr>8@+JV5OUbG>=bqfKTw7$u%Kf6hUX)#HbeM?(y>1+wXmnLhis+!j~X&-3h|$FXbw z

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≈;_iJhQd2n`LNi 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

cW9F8 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 z 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 z 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

m8T*Ob1v&&uu)H-5mugDdU zP!u07gyKlwH-79bzIX~s`iRp3ckamAxDVvRca<*gdKu^c<8TGtA z-HYF^HQ`=pBm05(wLo{nb0?2{v*dE>=yX%?9RJ+S4HcVHAz=e`^rgA)yq6tQE(jDTv?N{)Y8qK4vp8VDh&K2PwJ z>gNKs7@-X*KYhNNZRgS-k0yyG7l25g;_%qs!@;Gp)rToH&-t~%vW@I4m+iPBu1%HpH+`B7Wc45@jmtwd)Q+|m`*J=z=j#LtMoDp2)$C_-#v_&n*~SxP>HJCQ z*F;48sl~z-()ota0(VW#&RwP`$W|(%A`VXmohP@5kKsmM#pb+GFH35RF0IW`l)mI< zXw-t!&<*LPt==kn3IGf|QEyeM*kL?D(K*_c@Y$G=M>Bm97nSebhL;+P-}oMU>sU4z z)@Z_tRK%+kuMOkMu`CH2ZW!nIrbH))vn3ZL7(- z$MJOM(?rOf`byhCiM!ZG^E&PGm~#(Dq>=JI75^+ONWl74V~KTQ&wqNtCVXdlD!}j6 zzVmaMA_7a-Fm@U2m~zum6W=mpFl#v#X-GM3u8C_G9VSjX4xi{|K2ssvY&*|+M%W}z z53fXmPhNU(MoFcg>zx?P{CXgx_S|6S|J^~Ulsc!nK_bVAr1t6WmozBzU5w7p_FsEA z5O#>Q@;En7`WKf+-&>{s>yb%Y5I6(6p2YglmNI*==FUN)kHTEpHJDQ2$-6j+yV4U% z*sfUp?V6=)e(GW81s(5-09Tr5#-}v*EM%RviBL?lg6Zvv&Y{U|kce+S%U{3e(oW|{ z9kao+$P7g82^x^*c3f-K7f-&l?GP52*9FuwwZ5yOy`YwhYb}8TUc@oh%J6> z|L2P;wswJMq$=89?`IBy1`8^7#y5%Z9I)``3`zP*Q9lP4gTwLe>_bSmk7zPvr-{eB z?VWp2+k1hF?E5*-=Ii5`5GC^xq?>05h4yL#a6Ux9JQL!8586i%UErJ$yN;Jw>kyrG zB(KBJ7j(tu8vI2r;3wP%Zs_Uhq;Uau^rU|u7CHnw0%4x^iJ;_*Y}hR7(U;p{612slH5;XsYUt?si z1(h5hH))Gl>P69G%7C)ZVB|!4aZWmpbS^nA;(UrkIb(be|3q|TAY#p@`4UeQA%;G#NPzrW#|o(A3k2sW$ScnZE%#Ldr=)p-E+ z$=`!WhQy0Gx3&3*)9a=l#J=2k21w3OP(hBGcrXFH&NHl9TL2r_PD~RerlEWbrRB7c zsL)$M`s9znGjy<~V4&>rjkv_}oLJQ42qa_&`qGjUG?zNIO?%y7-Xy$#K22C36(0}J zR}t3_wRz}gyN(b=2aSWh|06Ci$y4@DpXSBnL|>MLVAJeL3Z_h*VsW9#1*}f+^{FM# zqPIrPUDp6)$Jw|u>T6?<{+Zs<(t|~Qf7#EXP#xwSi@$WydqZ0w4L1O7=7!Aa0{mL- z*FtKZZ-1YU(^*XT^`H3|!ymG+U#}5+*5i0g7gzVLsI#pKG zc`|}&zOWUXpZ`W(ux!l#rdTqny=YH+{U-K-JE^Jn;}u+s2^yiGBo~^vx=88#`@wg4 ztVrrfkgsCTgp2JH*9vi~Rd16_pQOANmN@oZp}ur+=7qWYew*N!?^N1}Q% z^oKfPL?F&j5%ykl4OWl66#3iv)giF&9yuU#7IX$%i~Vyc7=L$tTW18^?C`~&6T2!s zjW9PB3B@g>$ldv2Vi)|A#yT^WFP0dig089CA`l7KQc4u&=8UwY9%MyS=km6RSSUTk zuW?J(S3;jbQWw& zZL7*K`v04eA$&Rn{>=(gz;Osj*?KtAF2MheDc{oEOB>zZ4&YKk&kPdkZ=vm zzx7a$v+ztII3}o7yKM!@v!H>&qe|F5vUL&m~0Z2 zi>LkM`an;UzIV*{U7!Ow1JlJcLAYLkIB08^=X(gkA$*Rao8(@c{0f~!!R@LE%UkLtKs*T~6Mys0~4D6F>yWID!^b#$VI zHJqRO>-&Ek=SHw&p@;7EG@7PCkq8H(MMuYX@hWw)p60z95U9;dEgUnE9Fe-G|5@03 zJCpNHlX=X1`z}6YdQY%$znvGdJaxbL^ccHEv;g5cM}bL#=4!}lU$~zZ(g+pxOtn-m z?~Jge95vfw#KzZB&o>B_xPwMU#=wx=E zh6yky0MVdLV?un)@7$B@Z92|B#MP!`5Fa(Rs_G_te8h9(t9NoWO26uXlfgxf`(47P z^rxR!eTY$FtZV;jrPtLe$#W(q`b1c?VU>AJ9O3vb!JIc0XKs1t>l0Fa=3>E6rJl0f zbAwIYzvG1}c4)PlBL``#drb^8h6@AjB?%g z>~LQFG~;uE9ImXKOYSr>19uN|LCw|4=d&6c4-L{&2kfethL-OP{O9?ffB$hZzA#Dt z0j68iC3>J#tMwHQv~e}S#Q1^=Y}6SL8(3`3;pgBExwadI`>=TlpC8-;f*m(uoaDrv zWWZ>QKScW&`9ZK~^%!tnl!Qr#qd#nr0q@K+G>{d)1X86FQd(x#2{(t3D@MSP47d=1 z5YwM#lqrgb>@DD!1FstdbiWu5qZp(BQfa_9`5WTkPgy1Ain9Rrv#llEfXFT6_`GUW z-?>ii4x`v&P!RF@FU(fX5!l5!ff9BBjKz8lTJsoWhJEBHtEZ1QWKCHb#E7qgpNCmY ze?P`O`i~e09n_rW4(R*?nt3O~DAfcs)C!QIsvN>&mupD)SfgHPkJcs~k}Efr7{%HW z5lsgAK6w)0CIJWj&K`q_7ZiyOcVXo&Np}P|m!AJ%3J4{x;>mPxrqc=&XgBzjJSms_n={ZEgX2 z85?%O6opzoD$3`*QW#fs(bJP0dn0*&yLd*uFw^m2{Vh97Uu`13R_~Bh(?vfM_|v2X ztjvhPlD0GTi%@eg7OFf2;2I3b?Z z02YdJEMgkiqR3dhiMM6h?j*g)mM!j(dNE0-*4~Qe#%G%5#adc~Tqt{?FQhO8Y#2B2 zfifZ6eJ7mXZv7_yQYdxf^Um{wpv?3f&Jf%oJmh1rgVrkRvwDbvMl^QA#nIx8G$xXy zx>j|mJQ3)^(WG66o^3LRiD7g@MiJWCv~9l3^Yxi-k{*a0+BZ(2b4;W!p$87s5Iar- zgpLOf$mM4sx;k-NwIPyeCp^X>_-S;roU(`zVe}$zgJ`pVyaG3*UXO zWpX33{r^V=@5ck7f_>gBg@oPIvCY}qPED*fLA$=Wv5LX5K>79aS8fr1emmwJI~%}L zOLD-hGq%c~?wvyMr=Rux>+biv;oPkSUPvcQ&S)kXXi7{2W{O-0&ua40Vc?R~%S%2G zdJuDbzo&UDH7PmC(3Um+s2L%hEuKZa2l@+5vp2PBb*8slh!R5rQ8z_+r5{At2_*_` z*90g9DIrOz#2#=4v6IG1C1Rt#? zq^CtRSkR2Mgr}(>@xBoZ{6{n|>udf7E45V2B2oS36tsmOm>UK$h;uM=IXG#^vnO8_ z=ht!ngljjR6{4UgzubD?&y(L>i(Kl9W)B}xnR;@VTDwaTlk)u>6Z=78h5GKYXQS(v zGtG>(sB)v_qyK8!$Utfrr`LR+zyEU|Ep)o@w_&Uw+IDVY=yYGo878>W|zW)6H5x9p^>OUR-%qi5wbhsfe z@Jy@hOY`mZYP59&^8A-sOlpT_5gy)9f&trKe*xB=cE3KWZErgG{a%|8pi) z52mAOWpW!3>hli=6jiNG#{z3eN~ro6P9!|lBXZA7$(Wze?g)aH*|@g&FTm;G!`S*I zs-$0wf$3{=Pl+?K*sc8j+m+-he=%{l6gvO?@4o|FIdHqsM-F;-$J%SjJ?tU|P~@Zm zZ$T|DzuK`0ieCtn9ucfz`~j;FnC%(lKAscTSapnnynGos7u)meg>N-L>Gvdi)Y5Y2 zhtcaCA3q}Ld_#TZrG!&x#*E4H(1YSZC6+P4+|?(YlLl6190DRcC*X_i>c*0n&W?Zo zr|wMB_%Pk?k?REnEaDo!V?m&MQ510!Wi|F6Ng0iDs}pTj6Nns^JSIl&nUTV|7O|fN zze&g>)MjhsLgnmSZ?X%usJLV%TL}UgZI|OrG1E=>f`|WkT_5_-%9+q}K@F(fY-tjD z6SOr|I%(RI-G`3S4-wB#4h^bEOg&K`Bv znYz#)Jxa~*9mSY-g!0-RsLzKLH0lK{Ig*d{&zr5{&-p2nSki(40X_}t zQ3Hdyq)>b@fKqW*t*abjImKDX$q(45q=_Duj!A!-v_frxitQQq2K|Q`Z~#OgBQ*EF z>`iDPhP+~scHPtbv$L}^Jk00&Zk%UR>4?LQQfvC z#Hhv$y&T)54Fw42_xOIBbkBsqd`4U!9v6Z}F2GTBPwbk62|4xH%4teY-q^n1>2@$O z+=az2?kqE81iqi&HJ&Tgj2qYdjPNDQl)cMW$#3%^s{xxFC-$KngLp)ga3B|kxahcc zwP!IHJx&uH5i{`u=nJdn2VVqD^KAle{bO}@(HJ%}13}{^K$)C_${)dxAPsATKh!hq z{+P`zesp7nrkG~Xop%ih$PwSWTGzOqh1N4_(lNfijw@+=q6g28W@zG@^P_h&To>qVb5TL$6?3y&~y z3~`O^RiE?g`h|FBfskVAqp2`@b^{aw6HC2oM!+yLG;pKe^FFQgJ zY(%l3kQcS0mjXnB3Bo6~?J&Wco=m|U-6R~AU42Hn)-K=EZJc-l-wl3pD77gJ!*Lv% zUS)Lsp=uRn+Z&$2omc|N!mJ83^3miZKJh+(0~*G{%5gx5DPcd>-g7YmqK@-mVg8Qq zSn}+ALw!lZxQLuEIn-FUwI!!5$vgoexTN4LxS3d1z*o#3vYHyzPjVQ&;hQb0s3Aoq z^}d@7=`)FGlC$fdve<*GkUPCzji2&t{YX5j>xQHLX!i_QG#QQq&W}(Tvgm_FmHq5` zYvazVbjy?@96}-uNWfEq5D}(w@URi4!vZ^rVrR>&hrwkpNsgVV^Ab z)jT(N0kCYJ5#!KW!PXcx-RSrI)znZY?k)!vHizKr>&aB(SIKd^YX{vHT-E7(h$J*_ ztMZwgzSD5EWwUZV7eKGo_v3A%74VS{d=I(%Aupk~Xs&kuB^bX2WHk+qP^hq(%ZE(& z@1%)L$v3~#H)Qx2aIU&8yXFm+DYK}EpG9-R-0j7RLh5N7$u?HGqNZqGnn~)Yr+IAA z!iBd+@geyKLIZ+rmhpTS=UE3EUl4#Loj*Vs<3@*YEGyCc{U2ZUf-Lv<+92%! ze73+I;vb?%yKte4^s-Qc--*AQlO`U`1V#t7PHF^WNQfUX~K!=G6o;Lyb}f5yz8a1O`^U<*g)q27oW+vGtayxuwKB1 z!EzTCJ_leGIq@3gjenSlQ{YOA`WoP7VI+aKTmL=O(iJACN3@a~Ge4RU!yGmEOVHAe zNisInb$HDfB^}Bu%@|wIyt#me29wuBFTt{PIwr^N@j}p7eYm8y-%2Y^J5M2 z#qYHmPL2U2?+LxppnQO$$Gp3c_8;}+!$I9H?YJW^%=eIH#x@#jV%>4UIyRBv5k)L+ zPMT=w-`8A}$w-;_%O15JWwi+=-lw8{zjagR$alzNXEToDT#`!&?k4TG5!nfU$BSK* z@&njsQMavHg!*uceYwy=3ELq1K0HpgKdQHgqQK4}I%K;r03yY72`iDR^rm>fSr& zyIolfPMz0gJW@x(pE@8|`9IGnsZaFv^BNl;`$9GVzjH1>7qzVn`Gm?T{4O1Yn$WnV zY2pm&rpbAz0cbEU`PNM&R6y-t>iqF4r8o771!y~s1R?g|fMMC4BfM;M#RjeP8|7ec zoU>A9t0OFvpbOdmL@T8idozFGCsZ_gYH-G7X`=NlQK)76T-T);u^3?L&J#oAQAD>2 zGKYp<$@EWCcI(yeD3*uT|FFGfni5&{wx@A#=S*qdtFD7k0T=|9yTE1SktO z;WO^oex=k{-M81-y32 z@0UGF(^vu*^01xJ@X;^Fq%6oC@ORGhtE91U2B(t~TR`?75uj(9obNm%ea7VO{;=x> z0=})UtTeCNWcs$78E@iut@W&BKd*v5p0hwhX?786s@mXkgn*O{76NctwDs2Tu9CEDn z_r2i;5y&B_g*_3#M7*s{i$@%S)G8eE*yi7#pYM4qx0W?{_&y0^y-e1i9n3nV*h&#=o4PYjP;d99T?JXlMdWR zty1#FV;VSFZq#ngfU%)%$n_T)%VO}*wMljA!m+2Bj_~S8wu89&xG{Pi} z0}@Lpxmtk5IXq6OC^lt)TKK~)@S)on+K$s`3S!dX_=I(C02CUOnS@SXHvIn5`9@W? zN??Sd$K<0vk>BG1%@rkmzb^cp+l%6XdsrIZQ@$fjUw&_XORoG?(5ZUEcC{iCKT;YV zWsf&L`VbVTko``Qq;4-U4jP`NEf>luoXbIY>w12;6@b;lH#e{9{>(=(=A*G}knn@s zacK&XR_UQW=9wB8xv&ROrqRn~D&zKu;f(b7y><|;2{c&7%v4206VHkvXHYe7;Mu1? zqX=~k`nX}M@|#6wRr=#fA?<~BbLcKTr&W2?iU5EDAVd@_-8{jTOIA+rw&|~%ZD|lg z{P6P%7T#p(*0q=<_A3R&k3G6_$IxZsf<;wTIm=8Nn8rNwDMtP2Y37VKW?;QBA&1ki zjO(-E_+{m>{!rvKLGZ`tdv-|Fe#Ug7%7C=w-9fzjd&xnQ3Sp_D2G4DY*XPAxEe(u6 zH=?*dQFPB^NGm`mswFm~6L*OJyMg#2wsj1E`}bELJTt(LZ|*3<3Xk*gsqc<_+?~SuKK*TR@&bdny#&bbdhClvu|#3$ zH*+D)ZUgJ;yFva6s}nlzAA=nL`NliQ=(@ek=0@q@=OAe$ws#(}^G~ZacJk?yeoL|v zADiTLUV;SoIi-OG6_vhx1@Y|P)5M1FumMW<&DRR6u55+!5L;#w+Ifn6{oZfl#YUca z&zCQ}#J^CjIMGi`q8S8Hu5P{!@#X>qAxr+1`<583&?p@WbZ@4q3)icgsrbqbJ*J)< zaUolMwvH7c_r&vE>0Ff0c;}y<{JWY7xp~*#mk>1tP#2L`d7H2wiw!2B0A;>!?V$~s z>^g6nntdLQ2{^_rrMo186`N%hM+Y4m@m&$}X8uGd?r|~FIC4NN5vJ-YT+MFI)4xE>*j5MmQ&dge8H(L!;~aLQ z8?Ps&Z$@%mJWUg&iHx8r#d{(GQDZtk&|HEvypdiqW^$>X*a&HNs{c%;bglBt#)U0B z_-rxJao|@w3(~LVPOflSZE*}0LCvw<@8u?$bMaTff+pJwAt-5KPg(W&Z7HY{jXad% z+Gf7*?H};bQ%4MrC5#9ETWsFZ>(&yFm0Rqt6q5i=B3cbt(M__S@76(G87^4+hjwG; zQ&}W%-7fwqW^xkK&>=qpAmqu=a4!5b7IT_HHr1E@H})zwo8u58;Lfw`6_B61U#FYR z{A=@Vhvxq8_lqIn1RMRwrR(N;43q=%)!%sOe?P-eR_|Sycg^)7-%Ik@g zj9yS>kpYTl8roBTKi{7V7H_jNR?ML+o!dAkMGdcM0JF$Gz7D=wyW^{C&rcaYPht3l zlG|#(^F`4N@i`&1gw@4LQ#5s7hmahil*c=}8~j<5hOyLQ(|g;l1fdXh_HZ3=V9O=^ zWpfl)_aasx=RP|?NJi!Y$Zy3RaopvcUzJY$r23{YUXpILC~B66_DEO&0Du5VL_t(* zM)Qm8TDUxaaDB;pSUNV2U0|*FvH3gy-rzpDUcheFVgMd$+-~{FcUs03<@f@DJ>seK z^MQM+Y&$OUC=IC@S^TCBzQ+6H&p?>5$`MaPI)9Y+S%&Xw_MJyKHB0OFYVD4eQE>Y; zG4STNO#YJV$(@qDBhDs%BXA`b^uG9Tnu1^OK1qGH(Cg1}>a|ge`B{-a#peallixai zf1zz2z;9t~7GW-j=E{Em%QV_`{a)EIFW`-(^Upv3<6v|KSr*_pcH^-#tqD9AdA`JV zo?U+cxjRDhb_nu3t>jZYeuo51t1?}T&o&Nw-0?#w zjFVrx3XwZNz?Kt6Y!t5`xbYg7Gw-MsbBa)u?45|+yt{WuK-~$sWhJRN z$m$Mn6B7Llg7>eQM>cMu_~ZHS_A{AbRbc`-3s2Q#Aj?#{k-!#>K8+AK__(DLm8{I< zvyQ6R|2xqGFPZG z-}fMmLaI>M2C*{7lBDX`zuD?3+0Qm2}uNkimNts7j1E{`M@fbW&#CPgF zK1Ys|8}_I17DIe^(P4n~Y6*dl`*Y?@NfZgsnNZ{)q-_X$xRw22}+|>4gdS(se9XcnV9JBdp$7{RrB|{IPjmzjhi2@@?I;+P@G8m zI#2#4w58vln-4y-ct_J~fFO`UI>Q&5n6jvaMy~%}FXq-Xvj!;AB$jO!qL(#yBfj5# zTVK`O=?Ifi-OU`QsAJ@u{@y3r-YZU@V+qAGH=kmq8%!tXhIrD^A_t2MGIN^f1`b0$ zwPhXq1Y&R}=c`qk{m<%53Q%Ou#8@})W2Po%f+=j>g+e~vtoAOO*&7umq|1tbKfgI& z1Ngg{lp)o3+E4Y1!NPEsH90wFnO3|+AD-!NK9rkN@d+p2E_&U-q`0;`>f+=}{~BP;UzAzatI#Uw7O_fcT;-l-R37Wy{Hb96HFzqjUj^+ad?XY7c&R?q!x zJh@stk1VE1#+(8*@MaeJFXz8fV8PixryZd4VOknD{Z+X3&!>9yJGi>Nz%Ez(!^BGe zeAg4T`2dm8*yupMIJe-@9FE;`(*xVmt>Lxr9(xEOsxe>b4wFlRewG!3pZ-i5-R8ZH zV}nlL)9m}0b;pjb(j+7$!h_|&C;~^B$l%+Sw*|v9X2#S45!f*m#!($F9Q)cT%6Hw* zDvX0N!!>mux}7e}X*%=HWowMRKG{UOJYkDcHM%LfLc3_|lyme8)6LE^?PVU`@z4tG z>$A@(Z7#?)MM{4p{Y)6MaJGeMZ8?)nj5)3}2JB|zA&#jJ_>Irc4`JusNf49Gh+)Vd z^*N3p=n0k>=f>seXAKRyG`ZhZ&;)Z1RCn43w+)GCaint!|KvP1^6so_BJ#69A?7%F zuU4e;=h&^TL#VH+Xg1k|%ab)UuBJ^8cST=T)L(rJwQ1D!S7zJF6Wg5SuAh%{NKZVa zaFc*@LFl?Z|E_;7qDJ!wOiA7HjtAEhVZP411N$*ht7G?3tP#0RZW)7jTA+Y$zGmv; z<4gyWmgU@L{8bz4$mK|Y(oMlM`QNyAo88=T%S!gvpHex9s5nLmD z_uKyT#i-Kx=l}iRG1FIRM}+2L?3U>PDpnyuG#>Kkc!QZ3fpqrm&Ig#)$~^rLmaqVL zcf108LZ&;JF+MtDD6cI^%tHlwhPyjq;8Fz5xC3Qpi~@xee?M}TpK;K_BgslSda=vE zAP1_6{nQrEIdlg_oL@4dztxv&tVAHvLn?a*uE%@MJK=>6xi=|42XH3H$^b-Orj$={ z)|WOW8Ip*@7i$8!-1fG)5{uN6an`Ll3q@GKc1T5h7IO9BbD@SM8pHc4g?@xZ`nOoY5gd8f5H5AbwBZAylFi%=j~&GBFvPNiU!t z8EcGU>s60-Y|dFY+XX0%S)NbFnBUP%)X1ZbU5lHbK>3*_%4af%3cLT_QVIa1{y8U3 zKey_lvayI4E78zOl-iD=U5{)5UT!|xAGUM4#u_0UJIl6g(*P!qq9}cux(azpz!*dx zBaSopMz+YADW378^0-HXp3Mz%oW8<4A}g)7t(Y^_ z{blE1pHBo1vulM0@iRKs%Ks_NRN*~kM!@j`^4#;)_n2v~{ri~@=^<&n9>>~fZ~GJo zcBezZYPCkI@M^ZVckzOk=@XAi`6;ksQUX@c{%;duRGj9b-ZoR-6-R<3qC-QfsjTT*v0VB}|GqabOy2-c6pG z@$GP9>fke4YPFL`+a*u+d|)+-A&XcnAW5?{lV2=dp8F@%I9AAswtfzNA6D99;8mjo zb)8XERANz7*CjLnJAQ!~*|8)y2c}AhYZ*@Jo{lr}v>c$?uRQ2p>jByRv!L4&hpB#SyKHTwZM(=sA;d-JGCV1U7}T z8Fq5An;t^pfQ!Yw=RccNd21r=f=QMsmY06&UY$r2`v!2nYp>Vz{BVIy?~vZ|BwP8} zac_${z~t$5^KM*qA%UvTjS@TwM)JM%tFu95-=Dd6HTSX-h2r0&*Zbf5d8Wl9DJX-n z_w?QELYv$V9`>^wJ|g~#y*(9SJQEt?ZVLwZB>T)`CBo+~jXeS5{fS2N|J<`(s_n*y zu>@8+JA3MU6Nq)N;e1Y+t>TE^y&uZ)As@VavoZfX9~w0MtnkT&92ufjJRe)jy2*_a zP=W0OTt$DT7A~B5kG-45@7c8@bukU?sy^RMl(nigZWFwP3X~~4sa4JD+IW`#*|MVw zwdj72&qAPS?vEO_&*hCp`iS%Hkcs^6#_ZU9sGd7pyEr#XGmV=H`+ggfB(a=4XR?bs zFpVxiN8h@(H#tqN)9`k)Bfi_y9zR=xGW|siyS_6PjD4p3%NS;DQPzGiw1OxHr+Gf* z^VU5n=aOG8?#b9XM&^s+H-%E?n4XHOd&cUcdAHP|xyN&}i^*YkPTkFUffm|%d&HD9 z6^5DM9P)x33l1R>5eMjK{_vaF}mF(d# zDvGU#85>#Qhw%ZiMKRM?Grdg?8728o>;{-rG4%>993K1fi!B0m+%##Qz7M4*4+b-a zXO_RRSB-ev>G@2ZwF0Y+9V5Ur9?lbfKSA^ybao6d>0Qn4p%SOXMHXa%?@ckGP?AL) zIWf_bcr&@(yEJBMwPLKhnAX-$p04}EO41QKHEHcd#GF6vK11J~^Y1_ZE-6>JU2H~i zZKa^VGC?yEvmW4G^;~I}4&_^tG!P*v|oZd7^YEtR7jdW zp|`*McnG_D>Shfo)nuZyt%~x(Kv#lsIw(!(^r&Hl>O}LQ-;y<56Lh-0bI?5Jdut!O zF9DsnNVIdqOHIcF2+-=2AFt9Ji#yOUh;0(~1e3DW%g>`|9i4R2q#<0`sAi^ZGKYpv zn;>xL=nOfG($M8=Xu#`$H6A`c!xwnQlpL@}J?P6As5(qseT>2Zz}oy#^LXaWi< zq7C{i-8jW_Sr0IpDZqRZLRwmi`38Wp|56(k#FgsY1~U)~iL$x_aD|%;B53xBynrTc zfNl)+B*K<-Yt3DMo@QPlX}bsQqBZsR6z zSO~w4TqrJY5|=tKpX}t#JI*NStU@CT*wzh&4ru* zoTNUFe0`!2?h5th)lcj(aG_!^z{wCNeXQLLzs`qN1~QRR_Y-?Ky5=(>l&QSlI54&< zT0$oc{{7y*I!Z4EMURCH)|71I0*NR+$j1pt;!Ow`i1n(D2HYsF{U`6=}i50&tz`8%~Nw{)zDcqq(@mDCxtps=euX(nz z4=&_P-&Lm`i!*4h<}^|n!~ILV@Q`=C$k9s$)0oMBhI^bRglvn+zW$(TLd7K2X}qlu z5+~){hO)jpc8SkSuMHn~?0#}-NoCm>&ZJLZ5%Ie?*r(4JqYLeg{8idD_ zB{Am=8Ovu&u)24YpwmQ4U#`Hi$MH!rHtA91_>P8HS4<8qMv`O0d` zHm&H~m?_&iEvepj$i$Y(@$36I50Y`+SV>LuE)cf}G4RahzB}@alDkQV3YzJrImva^ z6B<1Mrp<$n<6VyU!a%wP6C5@7KdC2kWh9kgDsCuE`)AtdsWVln8%_0R{js8%{I|=& zuX1(~g{K;htb$AbVxCi0j6eF^)z~=f_g2Ic$MBBbj#H2DY|axfGJuXDwxV0x+VAji zkW6%ECkx2VQseUa15O>2HPQ6xb7EVGV=@eJNnCs6LzcKca{`Do5&88!Qra-C?ug!W z(qR$-Mhr36JxR`x%qE<_;y=&lPCe-O;W7V9{ce1I^h~rxsiJoa+`&kQ<|O^De{X-E z5d#Vc<$BCkv%lG&1%A-jaR|cD%eXUGrtNC&ixK0r^0pUs(*UBWDP!Vog0L&E9_6-Q z!Qnpo<$sN*W*XLN)uvM#pQQN{YS3xWu$4Cr#irz5VGs4wwUARZ_&&#%U)X2gxDP() zyG^N?zeSHhOAipgKy#PJ<^{%K;>>@$|Iwy$QTdD&y0=N9=p(l@dVY=6fd{d`8e zGYhAuz4FIR=a>d!nOmE$-*=0AeiG-*-e+@=i#L9rb&qo z_a>90>=D%J%fm7hl38Q-G-#x=sv%fVuk`uo;9qm|G?o}mI^8Cfz9k~cqw}fMuRdM< z`h0L6EDes^KdS>rJxL&`g_cm;lk%Kj->V^3-^N`EwfmiW06>W8aJSEVP11|oMDEQe ziClwD3dA8~36g&UMaJd{biJp{%Llz^!gcZ!8=B1My^0N-(n~hkxPCc*v9W_q-SXHQ z51`c_CPXWGO!dABim-~<)Z!sI_(}epJ!+eOaisXH4mQA|v&%Or*K%vHvW*+1Cc)+? zA;K=HzHQG=2SLO|NMC#5GR@Q2vm0n#aJO;=;M=~104RfO;$Qx4J5kvlySMf;kD|nP zERT<-y(E=o%ME*jqnP+=O9($B3YIB6q_IQE+neHNT<=i`rZ>l4rQ?J|Go+iM@x+I( zW7ehfZt??fbr!RJCT%7+^?l4~1ge{VytXPyzg4w6k5#2DYTO{imjoduf8T+ahSaq+ zKtXmmXEI$te-c0@tFY5W5fcj2(74bcF8LUhhTJ!4R6c|Kr}_T7P&gk^C4*2Hnxo&m4NMFzGXiX}|;Y{lk}pA_Ftsr2i& zLR{N;YMwp*B4a3uP@Z@E1cbYQt~(P7nKrT;6=W|wYvI9}#%Sl)e7=jZKu%;7+!;Wi5+hAmgy!cE>!lVhM3i^3 zY@v#BIFO-4DDA=WBM+rXZ(D7kDD9uz)DIQ}$KmJJ#?K+|jLG`vVyn0$cv*!Ges5n~L>y%m z-RZpQ;>{0ED4aUxj`6=6eLj<(GDvox=o|mcu(;#@N7f&$OOoWc))+{O(v7;hf4%>s zD&43HVv&}k`Oci_uFBjy!rhDnK@beLKCxx{)MRj&To(DjduhhzCp7OlAj80SUon(2 z_v#Z9n(BKtcQ*XFbJXqyzIjN_S@~1M^)&GnI(Lb!S$btsl#mH2&LqRu7>keE;-QS! zIUAva?`YI0hzYk!H!VKay+Y7v6n9539u&^oL}5ou8FRaIG_Ei~Lji4KG~JM7i6G?K zp)=3oPt?)itqdU?zQpi{!0zMe?}(_WGt3ml_=txs6WG(z1c64xbB4ssQM^svR-K=3 z`&r1(K6!X0Wx@pNt1U``-vYDF5yGl+sniTpzS7{>NMp6cHZx*06svsxMbPKLlE z|5AgY!j;cd*fSl%DkfRpuZjC6xQvZFjrpmc$yiGSM05;CQ-Asq9Z33# zGy!Me!xY-j-=ynw_L7)Cu_Cx?@yDX{n)_3g-o;YuO%c?eSNGQo!%wt0Av5$vxl!zS z7;^x}U1Qo%d9dbr6t_`E$uadyzc3mPPyJh^`Ye329Tg%##D&-Reex&u%VUdlyt@Pe zUDv=9NTq1vcCBN#i8r6f`3G{Fn3UBWk@z;f;2WM!HWA-U?_~8-%Z#uX?TpPI(*T4E zgeoZ$*~v6$Kg(12fnUv3dre4QA(|UGD3FJH3RCt;eP!XV^LVoRK^CJy2H7&qx0_G; z2!Yc?ZSFLu_XXwPn{x9s+yJ(17}kNYb@Jvf6Y}*n4zjQ|JXOn7>xCyMxGGQK^#+&5 zi0~%&=m#h0Cdn@BZv3C*R2J91m6P#B>va2jVO5>pkwU}kQjY+QiM`I3BkUakA{Q}c zuU-FWrprC~0+zG)d3k9DpDAO%FFbWTc#hbYbN~ADA2s2h?=BPU0KsdL&cFZtw=dlf zWun1Y{+v`eks;CxqZyQc6CdQlN1@DFw>*F#;kKV8I79MBa$7qP`&P{t53m~ZP&$a+~t zv+uv`uO^gh+1i6ll!APzGlg^b-E|GI&n2wD=##i!%%jR?L^2lG?Lls!)6d7`{XMI! zwQ8`FvIBp_EEdQ*)BOWCP0@;iQh3~&sGc$8e*O)F@A!-93niWM!&qSrRtno7bcc=N zJ*@h&&zFgZGwPwU|2@`SVfwrVyUsr%;aqZBC^c z+!5{5`C{h#LM#_!5oyI|Ahrs{8x$AWOZ!fDapm_UlYRrL9Fr-Xwi&FDz)Te^}@9Cm$KLQzSJsO8$@x}P&D%wcyF`durwa=OpNs1$C`w* zZz9#erm!H9m#G-!-&oK)$_*FJhXifX;F>V5i~*6O)HLaa1xIOr9z!oIQ7SsMcLNm( ztVcOfrWs_=U`U^58ZD3)<>?>4*YUMpx>v2zv$|;(?Q#F(A^iQ!P_*ZnrL`15U}J1Z zddX`vM;I|n2xkb5X67|1dP_RT(=ahaLEj@RL^Qwmgh8Kk!58s((xoyzHm}mp_tT1) zC|hE+bxr7`SM!aXNzMp)6UEW9Hd#7F^KX^5!8A}3Ur|R!ldFnpz5?>-wl`@yeh>Zp zKS*p;c`;2?8hY*j8i>>Xx*IpRBam=?URtOfQ*r=CK)JtRr*?K8Xqwi!k;w&S6V#<$ z^x7WJ5C#3S_v}jc&xLC0-q+EPKP&CtFOC2vR zOXCosw4@kKa-Wy+RNn>0tfx6XynjQqqj(D-no;S0;J!A z)&sP5s-|Dm9sG-@u{+jEn`&XB(&CYHF68_*Nv$izFLb}QEY#I3GWPJ6Xv*Z|lJ`Gv zeoZUlr(i=2QekVZDG?oqMYI8pJ9;xIntyq(x;mQA^ayfisxnkF=$R(##x^3h*|$V9 zWJ5RUSV+t?A^*O@>hKG(*7y02a=2Bq5OZB=|I{PE+R^U6z_`(D$aftA*Ny)1$UnWe z;&jg7xiwBEZtP@f82cacpnqopwEgP!^>Uq;pgUME{9^HZTq@v$F=LsSkB7kW~3ttf9@cR?rvJ3@wZD0X6yl+YQ1Kx2M zj!y3F?v(E4(bVqHOX1HJbB2;!2kAxgAT_Gy!r~%js|*uVW33UwVoQO#oa5d2g!)0A zbh{=;%JnyU)pA4~#+Fn6+$DAeri}UQSVSD^XU>q)?~ex6PGHo$|FTdj_xy?bPcx3g zZ6S%WEdtXvmc%;~PuNMu`E~p~#wsSLrm=23s&q}k#6ghjWgD}-U*NZ&n}MOmxG~tUMo83+OOLun+=u` zI69*{2OoBRKIYYq&wtgojg2|uK6^={MB8~mL|RACM?a>M@>AaR^3F`}v$7fO)Y6_3 znpj*M={ft?HTDeXVfL#%8MEo(XNce(?v-vL&mbmRX&O*ZsH&|gGI7q1?j zQ!7ToU9~yVxrJ7oT^&c{iQm&f477&fQFZ)n4Ys|Ui_TfuiiWWkA^kV7OCzfuC9tX$ zo>3H%$4Zv%C^Y{GxxM6Z5V)@uZICDafkk0V=iG&HKd;-wq!sQ>4jFL!G7Q07G5?)W zElmI*;BSm7;kNO&t zWrAuwp{>W#cVn+6xr|EZEo2}C9QEosAF_(FoUritr)d)qmG&ICT7Thq2niH%Hz1;1 zjFa^J-sky8kMlsZ;&*vnOq~q-!#1kDv7X>EX#vm5=3y==z?%{AAz9>iV|ACzNkhm6 z9d3UY&Oh8MDy!LDkYS&6kBIs2KGcNR6}!Z*ec>E5N7~M6nbiIq;ztRPbWfjKJ3#yxn6mRPnkAPTS*8#h_bXoj>4R0!WuX00ys z;@=o)+~;?J>PPiF|ECVlrEt7!T~d$WiO)Gof+f#D$8O<2SQ)$mUp^ zzhiB8t%ir}MgdD>q|(b*u@o{My0<^|4sc;z;LrY1WH@d(X?Ohrv0Pnn&*w2d&5doS zubOOb-P$?s*=l3N&DsLdsvS){c0{fwqH!7mA4Xh#(fREv#3K6&Zbx8IbIk_?S!Pw_TkZRuo3Yoa@hvqLh4gZO7N1kP}<0$9?7ez~avM48BbqTob$4 za!_WVoV!s%z;w(2MoE84I%ie9#IGS5Bri(u2ii7K-zbzIVj%p9LEDT0-@IPyF-=#N z^$t!Pl`N`pnJiyx!k^@cI(aX;&z!5vY3_N|+5OS*JgQEekLtOR@g!c8K| z>c*M4%A6(-RZ!Xvikd^&9Qdd!VXl}|vDm16bR7$-v38pA#s;S-umk1yopS`ElT_QQ zQ0O>F+)xdfNzN5_ochKM<}&jF#*e3By%owI3eu3`&rFZRMOZ;Y_W^RMSrQ*lT`*IN zL--lDay~re&~J<8^7@p^xhapV?v1f~Ag3V6SF&XEi8G<-272EE-Mf|*(}aq_ek(fK zjN2q&^u*uuUbrX3UNA8ENwYY*YcV{^IWL^A((kDU$P2aKAqRes;0|!t(~oECC&&-2 zB}pp?srif_X*}4PAj}QOHTkWBUh1hY)1NUc)=^Js(!2AYx~|KzA6duH_U99eK>J*H z&99q-oc~Io_lP85QH-Io2MFQ&NOMv`f~@L%TKkqSF|bE+h$B- zs0Z=1xnIM@gzH<*ep_79WcIlkHMrl5oyiauR#sa^xiRI#-0zlUpeCeZ@;njKIKa)o z6Vya-3=Z2v3a-gs6ZSFKYWNgD!Dovr8aGvnV^Nq-Uz}KboZI#{A9)@XDjbVzuKRVf zOZJSvX?w$C+*Z`8WzI_T{S`TrEKGUixgNrbQPDR$v+)PZ7les%TiA+dZT!fwh7q+9 z4&7%ketzWK##A*DTtti5xM}MTpYe>V`{y?kd(YTxoB&MZnewMA+CVmV(T69b38@O5ilIU|j zxvic6$S0=|hs;^j?fgL4jL4_S+qiICq$GXu?K|@iqTVH+_j2BTrsr$n0nI-v{Z7`kZ0z;bG1A${*37ok-cw22}%NyL>c*tG-+& z67C%Wn{6h&=nwM8OBQc!^-LjBt;pe0#vo^d?W9TaB++u=2a%EjY_+;&tPkewb=OwGvf*BS86m~b z0U8y0bfUjx6FRnEk0gglfO2$Ct4YF35|07dH%7rGQ1W}c?3_$FvkGtbt~smMjR}f} z>%vg>qn#o|j@8!_E>}}1_kDPXYybbj`JK*#nI4a!^|D6Dw=S~!ylT%cpq|dAli7Nn zeZ8#k9(^>+!sort5DFQRr8a%$FL$&_?YspsM<8oW(ey&_y8sgItb@v8Xi5L{U1n$!8&N z+VW1znI)T2;#5=@?l@w?6GsQq*;^4a84_Z_D?!#Vvk6CY^eUqN(>Zp)^XS z!jevNU)PkOiNu|@(EhJlNQLKp8dIh*4kOm#|GkcPqargd?FDH|Ze_-t|DfnEPc%hL ztR$32Y#ig{fU}d7hazyEd(F9~j)7yLX!gBROy!wpYJw6~`nws#5t3Oe}t4hN+^-rxH|2 z|KGgb%-HI#pGooGP+%3n(H%W4<$ z#2uaiK?61*6J`>svD$_koR-g7uN9)PfOMv=Av#0S=cXnWm7yVlvCpiT*vxsC+xRnK zO3hVo)2DyO>py>dZ+>cWOLqy%Ovuu=F${!koc^)u28j;dH6YafaLCV8T|*lQIlR?&-vIqw-GP@D{edN*YvKTL}Idr{Mdm94h; zJ++?hR++3Y@4;qKCfT#^PM)^y+bN^)-LoK$+CG|(C}Xyp8U;CxSw)P3J?taRW1ERJ zX>if{miIZr5^|<@%`wmtyjF`(yi~T@zvP`yerY=B8gD?DM{_sWz71=(FDOiNUwFRE(*!((hyJ-I!YS-npC@?AiO+EZh?l zsX8^{o)KR{_TCojebnS&T;E+B2c}s!Pt5oxPFrO=uJ#1PPVLHfb|=962qurxjBl&L z;9dr6O}lPsD@5nn;~GkZ6j5Z1Gw~37zJFG{fsEOY67uv0jSMFBQf<+r<8#m#;E?d0 z&v~C^c7E_qRa=btMPC|TlJAet$MMvJ_ajAw&j0@XukhAs_QS#A;0?|HknC;vZ*u2+ zbf)eo59vB6+P^nc_9N{je0P#KV*n)<--MILb{qZ`! zl~_tCo$N0jaPtoL2K76(vfx6f$YWBb?Mx2lkyV&@lJ)aq z6b$8dLVoMah;PaTsL9l_CpJNHnmo`$ELU{mX_DC%6Sn>Vd_al}=&;(gU#As-e49Me z^q`|zww-^AB+xm{e7U;tI&#K(TO+6=i9FSC3zHs)LstqGR; z9xrU%%_u@R5al8v{5~IbakMH31^xJq3YA=#FzOF*d{!C1&c_!TK30rGu}NWL^Nu}1(}^s%?v>G*82G|(YY4Uv2hqS&;BRVtjHrT&dZYIrA*+*H}`&ByT=ic@u@eHV2 z{KIrqj}-Sblk>Sp(>os>=U19Aejk}$$S3CutCdH|n`2os)=xpS>&KDB;!YaAhM$f# zv$H^&=T*n&*Wwn?QkjHioH^|`8z-c%<8B=kYN4M6E#bJ@T!EWr6#YDB^|TWCGG<9m zPTXxW7$Ob%z+IH+hIX(ING4(ACJ}Ed>~;OvDn{53_xc>3wjkqfj&R7a!M%oQZc8p) ztEYBv^yJM!4kq6daDTdu@DMf=@1O6}+7@;+<~{`6!tXH%-W+dKk~ zw)a$q~b{(D&{t*|+$dJ2d6^6RUcn13rFZ6WxE9xiZ zH-zWJcTZFGtF5ul2;+F(Uzy~=hG#y_(bzpMFYg*sp)X6n83)#iD{><#i$Jkaz2RnC zXuQRlbU|AsPi#%aR_WbS(x6Zi>@@s_z;O-SVU#9KwC!i){QUf4maEU18LQgzP%GSm zRr~&~0Wsv})uj%u#-g)J=7!EwCyQz`s&`8jOB-JT);vOdGoAklk8|kRKGl_{g_OSU z)b4bjsX?1ZL7`oafw4^Myt_1~;CIU4$%qU${`|F!+&?e1!l)PoHvU1KlX~-jDmcgp~I@VqrFJe{6y?T6Ss3LTyCqt zha0TYkOiKaoJpM7VTqMA3yJ%=pMZbum^}jsZf=EhB8^0_fn3MTf5qX$5A}j;%ervsGo>0_v8@55|>HQO(dqza5Y$9Fo z!j8u%WF+M|6JNQ*=uDYVMrt0}d|=%e9?EaRW#klzdfiU2?PW(sRq6cazyGn)xs^@? z^r4+0W@g0NBMjblTE`v6^!WLwF19(Cr{*xvTXj&!6OP!j0I`2RUOfcmRMQq1>D zY_Wwecs&507vmst)e4s#TZ&=D*_zwx7s;kTLUon08r6R$MGUsmK>CYh{Y5WIDy$CZ z`1>}bWgKD9?xQjz#{8anAEi;MHNot`X%pW&8edNr&16omc%E8UC!Bvh+U}7YMysay z#PXyh7Tfe8MAZ>`y{G=@Z;!gYVQcAdVh<=|X6AKV5TpYt^?I4a$zAM0kqz(wxOfvV z9c4y^TRhlm31%X~2k%-XdKmBX`5dbkZv;nKi&`GVizCPc2_grJN*H;WW?Q1xsp-H` zH2>e`%6LAh0b-BaJm0?nW-dNaK0w6z-dvMr_fix9R zUP^MrvbUPMjNj*WsbeB4MWfHY+$Q<#1xu_MGK-F}K}l?r2Nl!U#Xw%0oJL_gjSUw# z9S(Yd=LIySRDY_U&sBq*)5Jwv=j4nU^%w18x(d>3?|zJAwQJh=oK!h?zRSJC&RU>M zf4+`KyWh)EpmIC_uRE$2a=?uiJ`3WRbdy4OvWg~HqkYUN=6@V7YtAa40Rk&b;utuY z$hi7>IUj$?|oUIV`t58&vD8bQn)nqrKO*Ccw>Nr{C83Vz=ueh1OA1!1?X zBA7G^=PiJ=C#e!(a?8c<<`RCDo;ZHPBZmPHVX=-pEkNP6Yip+CFZDFV4^Vh*36)mH z`1u4wznVty-^H(yitVv3BW}{#j!BPN!TCnX;2eBgF%$~b*Cg((dDF@Wec!dc4NYk|9&cQXY0A{( z_ZhR4I7gjrYZtx(up-n1qPod^eIVP)E4EO-Qk-L(Hv>+!5P{*m%3hQh`t>vTOdLip zfxh`PZK|CW8JfZuK3!bMv$`P<~|i9hxc^;D4Xq%7j4&G}}+^4i6mWF4)ztsIwyRhQ8Oh}kuAedd?$=3_Y4 zF$U|2(eydG)kS+97lotPbk+RjPvfyLd`QItoOZ`hEbH-EZ=Hfd%zwObu>eI z0qXU?rx<nIArnB;X7t;Ws7WyjN^W|8Ch(;S2B zXZi{ZP8omvJr=u=AS_r?=*A~~r^#EZ4zI$*HROG(t7?|`^k+VhN)RHjCT0RMdzzLi zbwm%uP2wWocVY_rOkyz+q_UVW>82r*nCsn1g&r4Vx%np=o+!YI%t;*#bUEiNiG@y;i zDKeb1SS*~V*;Adc_vLR z`y8FEMD=yUEi!dK&2xr(`P38LzkF-$Z7hsP3A}n@?{4%|QYuhFu9YifFZsdGaB@ky zK7#D5m?MYl!qoi4j97eH5skHP-;KlHJAa=}nT^dmaUi8+1O=OXmk250+w_B2Ece?wE!<;!z+W4J>KiG%xsQ|M@5<{NZ!JvVTlbQuPMw7Ae*yFhEl0 zn6@qnS#?%oNrpLOt>E-*N4-p9b3vscM%u~{C6-3@fDd|j1WyLV{oo)g<&jTc#Hju6 zQPQK%4XZifu87rX(k74^Izr4dyS5l{Vx};!_~y^?YNjbk{vnAcT_!#Q3PXdR+Rrwa(!sD*(&z?d}6mK3#WaOyZ7&W@~TC1Z|pVi%r9l2va z7Db#J2eRB}10B9uL&7Eqb%@8+fcA{uwQ^oCNho_Vu>PZSb$L@(i z@z@CUbGovE2e6aQZ`Ejo@uNsWzwd`2$->k`vt#yP0Q_2IOBz(+F8qoGwt&a}NH>>+2!nxhLt`5t&0TRu)w;Uw ze>w*Ae>^IzQ#*lUv0P^AGe+`?D%*wGd~U2mp2i-ZgMu05dMy1S3T+y7jv-%3N58hd znMSn9l&1l$DQdX?ypx_>y#KFMc!?Q{4O1-$Q9K3OkgG0!tVUpob}wMWic9l8Oh=6+ zRkFbEf;Xo8-_NM#lH}NWE(Cm<)a~bVT<9W}nD=R1_Y3lGpTQmBbpb~4?w?7Kn#MAz zjtL#-A!{iv{mTvoYHYeX8rv4~EChGlojOYOb+t2GkjGIzEb&>k4tTSoo^Lao$JL;0V zjUqWZwn)Vl9|3@OJ*1Eu**-_3`h^anKB~RbL&Q>;^IY$qLuX`V9n)p2uNJ!%*>9ts zxR`~o(dXtE?<&d@H3$jiXP?ty9HNSQZA^kflfM^t09C)6Q8#l}Ei~}GXkvaBr($u) zx8~!i?tE6Jhbs_9Ue)dV&*Vqw?9`DbSW+?x+O{OW`ns%fGDr1E5fwLv)Cp>e#>7Vf(qARQ+JHbs2|404-tiJk)Ob4N_y@Hh(AJ6X$SCJS#y<+%i}+m`c1c0l+5Hkr5}DUNYO+@5L}v5%*cs)f%RFqZRa zj^Oj8n2gz*Q##-6dkcQb>k0CdDyKn%J-5u+UDxct{)jquOh6ogXbwv?{c4&@#XBPg zBOJ^pPggrFe77;T5ReM-KtF%F^Vdso;nrKc!ZY;WOvhYVoC;=lT*ap6{O>>i?MwKO z$Tt}#o7*uYLHY~T;Skn(_!2k@pn*q~7xS6u9-rt$RmS1)fZ=q;cT68ZyCZ1FbsQ+h zmyH+rk~|dis6=AmT^C_Fk5A{2++uxO zXYDjAErM|D> zQEie@$B`O9Qv2h<&K+N88gfb0$R(*O+9s-1%`wd$xyjg{ZAWgMTRO=`OoHq&ZIeMM z<=4&05pnw8V+Yb<{PVM2Vp7!~Wk#uwthDyCLb?0L0EOynX5UQyOi#(NR8~!8`_ryv z*HPR%4tb^F5(ZE)-bH*UZ7%6E9J7!V(y8vJ_<7XdK5RA5AA-dkOeUgoF*Sh{oaWt- zlc6Qb{JxnWdxs8D*kx$G7b?N19@U?vTaYRyle)P;amHw$|A%-;Gu>gcpJ$T|m%1kG z5qPAy9+f@hvA&b{S!6a#nojSc5S9p2RGQplI?3-Hd#-63@d$*a5d{YXYt8eIfS{s) z=I6*w`_IdFx48Ygq3i}Pb^&+E7Mfviqm!SLZluSri#ZV=vd{VfaU?NHT!4Ky)x;vd zW1gQ!n@)N<1i47XoZCA;A2KU6iwG~O4hRzG+p;x`tw~a)d%m%dn=IiSCfnT5UlUy& zXKIwqG|j>tl&;T!zMfEV;Z{x(iJ7iGiwB+iJ%uArczo49#+QcEJ(^RJrLW2&zO^D@ zjK6(1rI%#Y{H|&eC%-43dt$?lh(H|%cQ!U>XeHgn^7Gicf2TRzHWjBmH{I;Rnk3`~ zNAbC@;^AA{Hp8v-(EKi$(DWRxfDLg{@u!ivh)FQsY$g(u^@u z!zj!94MM1I5G`O+&{LzPiTrE|ypxY=&m>5xmlcYf4XKqB`Wo^PA6YV97XhhzSdfkQ zV5ji{&oE(cP`jIG2nEja=H6A8?NmCrwHLSyhzAHa)aMjsD*~`I@z)lmJ^4HJ73yi#oExlO z+)DA(t>0(dZj$UF>;L_}Jy%Zqb&ulLL>SFQDOl$>YHjG;{``+M)G?V>_laQ^nIOL) z_7jT}($V>MuoP!M#?^E1dGvFtDxH6h?Hgg)%IAexWIm%1Rl2FolIi|{=6C#=-C++& z_ZX+#nkY2SoeQ2){Hb=CuwW$M*P?yld&kh3Qmb*~*AtAcf2iN<`MDabkCd&+TXsB* z72eb*O|XhOz|9?aPYCxo%4 zIJ*D7;1i~OiP*t)>@2)?_`YGWPCtXpvlcTZE7K}oi2fpuxgpSd1lDGxU*b2PzeQws z#7|)sNBaJ1kgRB!rZ~J@?_y!8J?Hw5n_-mu8Mq&q&Wuv&H{#igI|NO9?v#MP-b-|C zVVqZWe=7ay80|&cjD!Tm-Q;sO74G7qv3aIRGs}+Mj51yi+&mornF=9C4Gnc=hYqaU zIM=;s`?~(DF9$cB|Ni@LgEF*fTyn-`!hlwqG2(y-q6nDH3Xr?@9#4unhb6im>LhgR z*^5^w#_qHDLk5X1QZEDU`bwk9r<+WjK!*`OpPIrO zLZC0eQM$|OLb5t>$rmE8$963_#4~D?))(3fQp|!!C$t7~K~A<;p^4_?vb*Cmo^Smn zat>#It}>DGs)7JqGt%}x`+!`MySa>q-2Q+M!3~&GJ)apxtP_ojOJ$Bm>M>zA9L6HR z-DW`!CB+5_h|!(cg7pdhTx7suE2?Um3wH>pyJQ6q*v%PKjj7wqT(sRbFkBQ%_-cp& z&3QCfiJI-~_v_Sf9Td87_;l}?ajsFJPE)9h)N>y_W1@!ibN73xP!l&NdPLdnwVPdH zT)D8U>TxZmirpbDpLZGyDSkf(6d2${<}rE37AHBW39Vzb9n%AKAx!#g;6+T(ooj7S zDtztzUeJqgqp4hgoW;Zw8N0GO)rG*>@daIXUYB&%v((4;s~{$78hcGJd?wR;K2iIi z_~uci=BLllLCD16n1l2^!(%!1mw#IL`EKNUv^@p`yCCgzqT-xd^;!@Ft3I9(8W4GD z?wI6ls}*pRK4AIx_hkse|{S zdi=2OdhA#Vk-1|omOv5E8DWa{7f8zOK>h~OkbmV0BpBQUDa zU-WZ7xeX>mUl)dc{yzWZv+&`=EIQ)Oz>hZ~_wh#Bt5L0%z9z*qt?99ML#T93z6+4W zk@|8tHwr4HMm^QjZ1V?{Rr+aP&QaGq8}lL59rIA2xKOZw#m!L9o^`c4pm`c@1K5cf z{am#o<|=!k_f_Zy z;$Jz|%Qa_miDu$p3#)nkc^WS?D*n|jL>6GNi0>MK!=yB;&_pAjbAhMgja{JZ7dhnm z;R%@itOm99hXT8LVI)l~bPoK&*-!<&-=^jYVC5uBQR%#&+lCGekD| z2=XNIn}*f3GHFB*P$849kN#Q=8o7j!?^5};UH7IG)w3a}h@jCf% z#4LQvcw(O8vwr=)zG@-R^#o*HckCI4WPN=HO)fuTFhhf z>dqU|FO+|zzf=e6=NYFZI4pi^m44^#Ge6k^0W$afR8Ma0{QGA)he&-v4eNSPOe$Ge z5*j5aDpd$SqB?`F%bCsph>oyu^})W1c)t;}t6jTIW~m70(p&5T~J8 zj!2O+IGTA6FC@O^FNk&3we*?N(?37@pZ_D859AK&Ib&Yq?p~VgAChj;y2)53s<0_t z@lyZ1ufiVrKEDY*D#cH#vJ(FhyUCozsNM6?DH|v5lo)7jLCxzI-SO?ZsbE26F1`$< z;t;?M;SbaJ7HDxt0TJ*Yu{$>6c_Wp>2#Lb}8n5Yj9rXF+SOfD{t>^$M`ff{o2P@pvY+wnZL}h?MGn1# z2O2x({K0=!i;&a=bue-Ev0p{fM{CNB2mfC9yq*lpv8X&1b0=3QT{9uGhFGaQ0V#kd%!MSB)DuQV!J%xR3E7tL_! z`0#Q>4Po2`Vcd-|q4n03Rgnz3pBYycfJ`nDvUUN`GY)vNiJCiV_Vml~2p0rFdW0lV zaOMO>&Ur7+J2R3IRzR=}b;iQlaHO`NitBgFXe z78U<+dn$Dq6`>-&8l}R-CI@vq%UG~B7o3A%bY@FBXTaWqW-aNR=_Uf@==6^LJkywg z=d}b|D~g+>+hwe|UdNLJ9Juba7bAhPiTfE^Oae-yySmX62Gxn^PWx-gTl&Uh8ABm) z8bpw6x=RXao%ZvV1BE77+(b=BL3B2#SZ#O;>m$wC9D@%x)ym$ul}B~24nE-&dMp&m z$r}xv*Z6%vKI)G9s?pt;+6jPGqcYyhvfXm9i)M&~rN!ssPP}=NSF}T;OhCGfAAol` zUxm6p?8jx2;NTx=(w-`I$cigA#Fv#_nwa3xanmw128O@@z&!a{hAyqN|GDd*ey^b~ z&LoKPXr)kznkZm1_bTQ*NnuYpNDapJ`?GjTAg%E-&`@}kDY~eU<9|3GOvRyX@R3wI(}@U{&&|CL_EnhGf*M*csH-nXi% z8?ZF7iE_z^oVib$vM)I6i2!T(91lZfzkUf-F7aa&ZWN-Z(g2<)6ofU-SsU|-$4MUkT8o<3I=51OZnP0&vLagtG({_D0dVh+#F<`|q&1t78v8-GA zJwB1Srs^Iy@v|;lmIL+aTdo zt))c_>6KCQ{JSnWL*%_S6tgJx_JPSd{`OE| z5Ls)D*9(5qR zOO9KPs6xKKVCKmykH|_U<@%kv#cD!Ukuw3YwkeQT-Ly=0yzu9oC z!z>v`)SEHHRYS&|poTz#WE=J4?Kq#`4pqr`Ve6;GMKlIzm`zp=tsrmk6FL1#C4ITS zAaqT@)ME|db5nf=ekQWQ{6tM!J@fZNvG=DCICb@V;?G#X&f>|*_kJHV`J`?TN2yNN zkLl+W_6r;pZutF0??e)Pqwi zAMPqKS98~*8B8nXS6C+FIz4%9@c-EKE+Cmy4mSW@_p$3lrKzd2_KYf;qs#fUp*7O|u}KZ#|?dbqb*H-IKxOKW@E97cz_+!%Pf z_O-&P#SidzzW?|7d)Ke=?P2z!&uLo{Zq1M5!s+zoX@LF)8RYr<*K|;+X}T7)^y2fw zc@9n9IFb5ezT=lye|&6IJo`|$DEj+hrlh_b!f#f6P~1pTi9m05;--*Z1`q;@-{MzOIj4#G2$vi%N2w0GNh4y;xU2MVWaB z?Dr4@OrOU1f|Gw*v=%${LH=V(@cjGV|2S60ZgEWxpsch)A@;lsMl?-elvY_a3$aX0 zWUyc^^+!E!^r@VH`(-H3Ut`m*j6@d!%v&zh>UgBthoDsret2|@+-|F5#at289JGVq zw2FQvt*#X{C=Hqzp)~SaFo3rH0CJ1mlqjq3Uja0ARPoto_zrP33*LOl zf3<3Dh$_^q?UU7BicQ$Y5X@ynR>496m+UNmo6%!;@_aB?5!lb|gWZT#ezIumGj9=t z`g58w?N`=njxy2tND8~_3>k2Dyi~L7D0ZoqmLo}9{xrd_vGzD>b< z&%0~fb-?1V+wiw-eyk0UuAdUbN}Phkpb9pZWN=j#?xs z;yJqpsx${K&6U)SnDaGWGJ2Pj74I#Y{27(qOH&wVGFl3mUc$c&4{j4?^$k%MLwEwM z9q)XGAl4bJ?!Z6m%A}%uT1$!sRGXa4y9~Pud+NFSIa>hqSW58k`iEqZ2n;I>YDWpm zb4X7w#5O?Z*>&Y7sLnngr~f|W49St^OvEfx6LHBu@zMk|!HmKRdzS_~Th#Wrl#A+! zZcGM#sv1>a*6kw6iM0zRr(PH{Q4F!XDB8y0!cnHj|I&cjn*ZvA&n^$1Z^xZby1A)% z)TVwWCm(O^?9J}&n@7ico0W3RzmT4#RC4WYc<}z?ptKU)zz%=LD4JTG414RpY*9Cfv;EKbzM|V1KT!P{oWJ zrkgYkV)K&IzyN2?c{gFY=(wu6_Z=7JSPoI!G2||>;QtMXtOg8TZ_o{hFu~N#=5FZJ z4Z0D=VHQ(lDgMM1#Szg9scwqp+^Em4r2IvX%=*Fo%3l1Uk-Ow0@rZ)8<}PrXV$K8P zaKHaO*T)bR1#?#F&O*w3PGNQPk>?^Q&!c7{I-MA7p@_CoEY2oYfS;eYhQR5cf9IKW zZtV_RnT(NhEJ7Ap!HgGw`mQP7&p?Gl)^nrBMKG}|uB}R@Bz&H^F+`ni)U}8itW{%Y zLGu{E23cZV!1T{L9ZOo#1(R$*`}8x$m9okpNnxyZkEFuM8{`a;YLpQ9#{m^7jix` zM9!aTt37rOM5Xj|Y@=?iRQ^6Oay#oPg6GFM({LXB3_O|Y`lw0$SH367@$+p=oS3ZR zi5hSw_-wKGacq9E{jBtXt4Q{+R8MaT9ylk4fD;suJ{>DRYLYP4gap6RPOS6JZM#8@ z%pLZ5-O0gzJ|}DqVSGva&67O^WZWU;T5s`;A>@I8lc#g){8A`x?`N83yK9OPDqIu^MuVElGpW+83o@bH>=zrlxn=U?dCL>1l+7? zKybghF~zFd{s>3q<rrA~Vg3Bj+TYr!gNt!5XmY7OnnwSjBJHQWOaD znIi2iCU+mZfP2p76b6!}nSt7x@y)}>DK2@qKz5)3AVw(TQ*ZXI4Qy7rp)#Qm9@i~aEkRY$ z?3L7s$Hjd*qpw0|x31s%bk6#BQ#|7@3pmSD+sP+MJ*~WnMm#6S)+pC z=cCB-BcBFnduhce^17>uqJZR7P897UX!lIV$7|r!N&rT{XIWiTPYaj`=p}L%<|*8Tb{IeqRwLx#UtsXUrls;pI>q$oDT{D( zmclTe_-z)%AmhxA42?Qq3aM(vJgU34?pft);Aa==<&TBWsELebJAD@o<3@#mvhxaS z&GB_~_`Z|3{tw_1jm}cdvE&XMt+MA1d6g_n6-}CM1eZt7%1doR6jfd{2eIX1k1^Ce zaWx9DODuN*)b<5#(oj*$-n-7VPA@$nP;}f|sWZ(L)V>!&MZJWI=T`=9oEH<3&Gpy( zOcjL5ndc>|AtFyJ2TB9pLNOLdDxhu6JGk@Qy>G#YB>wVerAdWv;q^$Li>4~)*)#El z99v^$Fzo;0IrXP(Upl44);Mcb(4yX2pKC zu|$>$qARnejPsI{ljWGLp!`{ZtAseo6>u0w%pIX<_kTBMqu}XBwXKFECg1|=DiT4G zFMK~Injg&qbHmrj(D77`T8P$5DdXx!`%XukjZsDMv>5foVx}9_IaV(I{=ZG4;QQVd zDTBx-FEj?*e0`@;;OCA4{Sl2;eZn`I-}ikX{S&iOguO%f7vJfc5X&5kP{LdN=sE7e zHwbKISHY=K`?sygPl#-koXZ0hUT+fLGs8$h;v~Gkf zv;-qQxTnY?vR7~Fey=&J$>x&93t-?oWFEg73slHg_9!UA3nusTV;|zg?02z^2%1X> zu*SpD7>GXn2nO_c*WPI{0A)mUuYy5UWpw^VFj=_PxGNqZS>$OQFPb&B(@M(C4t#^pfIkrE< zKwf2O6!L1p=ZCi5GH>{=@EL*k=s2{35t=PyD>Hbg>uNdXG36Atb-XOYG_lQeBbK3Z z9O)Vb^*cG6Yh6OUSGs%2}$bIJ5=IL=C+%yiCJwG+K)u5PDh(sFC(rNq`+Sg0eMS3x+Cv8J;GF>qvxUU28RG%tR#juO^5AdMpw1nANZ$=lz=|X!v_`*pg`oNr9^ZosSeXwJGKL8TY@OED0$D2QU9Ij!P zf8HI1>J%ff0BVy@sLqb?_nCB|h%BDvn76xQO&IoA3PnVNlvc_swBy?j#JMM~gZvOu zU0nYR-caWqpPD9{@m6dF*IZr{E)(cBsjYU$=Z*S~g;|6-7bD~0bz^xPZ?W358 z{yfnm%e*sazcN|VNzTdy?TG7q(kjKTJ?7e5ZDfWE&RjeUxsXd*-Wk(crQ|zCpF=9U z=rUPLVL7oa%Og%P_r>_MgWU=J>NWvoWqtS$g~42(oA!vkjb5gsj@qV`B1=T|KYKjX z{q8M#wAjQdvycfso?-3ZBdHtcB%t2}Q<*gLw$^_BGa^h9cCrHe`}fe2Q1a)%>0z+q zVop}Bj4$7MgqaCuxIi=ZqXRcFBo3x*!DEeX;!P-}v4cv>mna}LeF`C?`8(JqY#xhE ze5L8ecBlDga&9MFcA~b11n0K(h}u9CF_LQN(C?{Gx2~IeI$qz{-$U)e@9$&pIBc=9*kMt0#JmhT;DM6dF|EB3DKI>)4#=-m{jTZ{ zXX~zA4Jnd|gre9F(e7w9V#Od$h#egUcrqDF;O5><>HGJ4}M$3v`;^@Rq zpRsET2JzK{qN4Ws89|npK>LUIpP6K$3EDsOult{lr!4&~H$wFkW25-6l>o7a9Ter4 za6MfDciKB4{JDKs!`Iq500#!uL#0UC^hfHSrbl8XshmBsSYK}SLC-MRqV!aQdPZkiD!{#OJ6 z7RBa^JxZ>Ig_mlXJZ=)!_sR`f#1=!BKH`~r5T-ZEn_zEXaJy@u_&j3m=h$B4lKzQl ztc36C%`L1h_nKuDP9H4}N$)f8xjIZ-(9D3OeB;-0!`Rv(YMPX-7TkCQq{-hKJxLhp z8pwZN>*OCpviht!pwTq#MiIgqzfY`0K5CL{fxC%{FcGV=0El&WUSltLt4D zR@O2BG!JklIcu;X^~D9}Pi^P@2g9DfjdTsU#xzhbpC`xd^JSD0!dP`oollSh>83u5hjI_%Z_oSK~I$;&t27WYE);zQSjevD9Mh_<5fWjh|F=Z;;WUUVyhJGK_!x_iCFMw>)t? zb%wo+$6ibGdFPy#G-~XVdX=Ygd~EXNt{v%L^+*4GS_?G5!q~l^X()b7Dw@FmKli`m z=&x(?yEaHn;%3%UF4o+|;A0Xe({Y}u?}(Y28Bb|X0Zz-u_p&XdEV{{1eSR-vAYF5= zR?yP-@Lm&2k44Pveo5)4XA03ap?$0^lJGy<`dRE1?f-n+<}jT9H96Y#(Pe_HMR#F~ z+!`X@@y3FwN{49U@1CY6r}z11QsVggWztl0O<~a-aiHX%AH>n1vc zESPSFL}jr6lMG0*ZL5=TO+If8!SCO3);t3iojK&J3yh2C&O#eq?-l7Ua9xWBF)LE_ z-Tphq*oWN0-*GdzOR}pxww?{mb4!at>X4rwUd_z`{L-`4Ppw$CSOXEsHJ>DZzdp;x zsWcu`eeVty&xjyQ3ez+{Frn8G-VMRjSWxF@ga|H#aJV_vnN#1YJ@1+HP)K=Otalvu zZ+AqxN^*QtbW=hjBB;TyiC6?M8;C9tjrxxGpFyP8SNvP&E>U(;}t# zOtw^8Mz$ql%#>tCjAd(*{$oETeS=vSm2$mkv0=4cWZjhNk31qUJX23veOsT8*sXN_ z{qMgGAbq*oWAzSj@AK>r=OPrJaLAJa^v%K6JS2$09^G&CAe_>fYMq1J-xdX2V|Ig7 z7vkk4I)I|?sDpHmZhp!K*pD#;#D-5h#Y>H^;|OVo5RO@N*5qSG==)>^cg`h4MR3wd z7D73x75a^yw7(?Jo5Dy2AMX4bdAUWz6 z_I(wkiq_wI{QEAOe0>>dsXaBI)MBRp6wSVD9-9pJrN{x#-a`27>maXjkV~{vy$IuqHukKq@RoJuIAjc zpp!ozENJ2!J%F{tlgXTGP)Z=bUf5xKtM$J}!P4jJ3+y~7?HKir1rQg%{%!E+ zJ`*H?$UT1svK4HsE(5(7RmoaKp@3Yg72@X!iYC<8{ibK(23U-J13oO>?YCE^&sDl6 zp_r!2-b=YO-ft1D>}5$0m%#32G9xH1+7S4UEmkiI zb9%j~iL8>eJ%~;Nv?Hw0Xi|h$&jX3j-go^gu8Yr{{3!B;7?JKtfhqF7npiT#j1g|_)LHa>$Pt;sHOsT-ISDW4anda{Un zn{*5>&7f#~_@%Xi@B=?Rd*!higpPT$q(Sj$A;ie)IGX39n8)hq}& z+9t+84(_5G?bja^Z~Nx0TqoteJD&GP9-|<)M`#zRxk8e<8haj}?(;Nh$0_$I27|*z z)OZPsM-kiK)8`0t`R8XgDe5K)1fqXQv`S*~N)xlYujq@mDx%*D@p6fOkP1(JVp*~g z>%1Q(0Ey!Gt!K^;d_$(%J@w1PnZ7TQqe5wHdUQczG8+s{QR#>pW z@0sR!)Zn!K-PDh4-KbeYoqE4hMfu*;m77(q>KuaacCFJM(|2r!O2_dtc3QFUHYW!7 z&UHcFNUw6A`AZazdZ<5N`K(SO!GfEp-d@-E<>&h-=Qjy^1B$w$zLJ|cu4}r^T01)W zV>JIzyvKd5R^5sn z{asI#_xiaJ>}$}|%-^V@uj^3kUGi7bx07*0oP&XEl@YeNq{qc|)-{g5sj-rsy4<;B zcI$1dh093ta4biJkYa7sVrpY@Q=wq4U9Af7FKGpxa-H@}2DB2~V$Jg|l#hA0h$+t5 zePHluV7v-9rfc4kzjRuz-}TS^yjRRT1NM?wP=e2^3|Qtpm1Y_&8l#L)`aDmI+3KAL zM8E)((tqbb&SQNEL<2Vk&Cf}Olk?@q$M}XW~%^>V01JTWgf{e0)i=UspIKRf^a@83>f zK^LZf=%sLsJGBSiKp0!xyb&Lnqk+{bn9kK z9SIEp`w2E^&S}Q!(T2Q=pio-^1z_$I-=BR(K$h&uC@-c_FI8Z?>rzeR)2xuko?mi_ zo+e2)=KadwW4y%Q@dG|XsmIg?SZI90L;@YpPATqs?kyd?#7_S{{5vHDoz?A%Ek*cr zk$JBq0$=R@Gu$}72e6cy06Cq+!9z%a;)o=W;vD{?w?TUE)%aNppFwT?i!-o&!)sK)v#=Ui8J6Lc=B z7c0f8uYBWkh#{*olnO77882x!GSf|xo0_H~0BU-j00-yZvLPGxA_;=#GX_Ok-_4^)a`ZEUlnQ7{s9O~G{h$jBYe3nr! zA~R^9oi0pyK-XvXt49=JzHQVoUet)i)7wDrrAx896_7PlE1?|B2Aq%j**UVD#1iF} zD1iJoJXu7uIG9+uA(n_wp{kPN=e)4EtNe$iX(r7=%NSyHG?f;n_Bm$c)(3bnlG!c^ zg)WvgwGD_q!*{R*_vHD=^Z8qt;i1xi_zUT0g*%1I_+@Jf`Yx1am|O9)s%V-|qBF3T zUllqxbbpNl2Gcptv{HzvhzFO4eMCJPi(fQ-^Qu(+Q=ZCmV9z_)uI+NXa2aBi?)3q4 z(kNOrE7P$Z`dx4EBrkC(hJbARV?}P1u?xQGjS7B#exgwek&@x_Wjrhfffuuv-@PV( zxnUWMW!Dh(#A=9rpv&?3y zCgDA{7x2^yj^%Y(ZkWP9yT1rluA29w!9w+%(B5|w5yQdR4xFspQ!8;K{b_Zr^Ixa&c&0RKruL!^ zKYj#NeWv>CW~D_Du@hU|d5TKsCoK6Q8W#;`qdglm9qV$Byu7*ELaZCvclZ)w)it?( zjmwDfT}x`4f~Cd?UcA_imYUDiY2-HVQv9?2j7NxKJiR08QxnzP{D6C;M(J3V?q>G2 z&#}K5!k6=y+UYT6#~T0qti@1N)`=yVmo{U?I1P!1`{^&p{yX2_D_alUN%nEQSEE?& z3S$4M;`>XWHC7_JJrTxqwz-uv*rXd*Oi}ej?OMDZ^IVh2z^|Tq`z5)<@8p9^=wo)| z??KLROih8CVi0>{eACKP7mGu0QH#$xHF{{85Utuak7MD_FJ64p&FpCw`k>ZuOtIF^ ze(#8HQA5vSbH9@#7AR9sI42`)l?G$P^f+%?I zpd;?(`#<=JF8FaXvi~3ZNt&(?3yYcTFI)l4*&Ops`NRP#s2l9A^7(|HEzYB-7p$lc z+b#YE&wrbHMBGa+R_&M$|2y|HCTjd;GldN?4Yc#W|NM8<(m}8``So@P@)E^epv-^Kvhy!)qAvNm#d&O zvr3Wwt`2Ja`BE$(JXU2_|NiYX`9dKn5@Y^oUmoAY=K>IfG{vJo8%kUk4w@0Ic*tIg z%Z~18!eP3v4y5_0Fb)c9zrTK3M{#a1K7hQK=fpTk%mIBEnt8rMATx;o;bhn|RvS(- zeIO~S4N%ulXEYIdd`G8>pH7$Q>F~meB8U27#;-T6`*~7?^>|Pxfn-B3MTYL+68YS= znt?k~+_fQwA+ttp;O}k*!+EN^vMt8DOK=009wor|JYIKQ)1);-6~%s{a-zWL0%E;B z&%6t~sJYDoX&;0<_3f+y;4wdY)GyM&2a~7N6m1z-$vS6umgvMfp)H zBTcjQ`F8j69Fqfe7TAuU#@Znhsr@}P1qaSz6#EwakZLi>F!{$o~EkhS9TDz3b=XU&R=Y|<@*N{!UsC&nMA@5iu z7e$+yW)fs#4v^Tcu(ONjY53=d-qyhm^->IcZj* zHtWCBaCq@lD-n$kqkkWU9mMLQc@QQzdn<1LjOpa$J{yxTzv%dI-E<vkh-Cu{im z;9P!=39PY1iavL|`};JwtK;@PO#-Lme>t#p(H(+i>mqr5j^+2+#Ut0a?Sv{y@%47D zGZsipC1h*%I+;z3o4Okrbl)4lcy$Pp0$3q!LmB99^2}i_(85VE|nKaKSku! zFx;;U*F3yqavw>J07$(d@4fi>U(e={Miw;cXfVP!1~zQfq(l9BB7pQu(>gIi>@S%S zV+Y)JR$gxA`bGllQxDYKXC?(9$_{mr?CR5ehP-UD@Qg(VHZWO#MGC)P zmZc7D>ZT|6&A5_$%$KWez~i}1-?X3Wuk$w6fC@cBOZ`8nou6+p0ve z9pjb{2qBCa+(5mjJ#%@Ebia-x03he5tbH$m(9P%i9M>0Ej?FpH3TeWs)>D$Y2^uW? z<-UfjW1^wxxT~CHe;WS5ajNSYi#dNCFK_7l96u-)tV$015-%Cu@gB~C1_(qywoIo| z*H*ddsj$X3{xkQ^=M6U^g0^l4~KR(-ZZx z|H(LRtT?faxzYGES||h?)gJ6fQq$`4n)14$tt{?WieKZa@b~ZOK9huBN|J|+e4w2XTqobE*vix2eVPB z8$W%nJE!+~xj}Q@aoO>w$#VoF-A*FM3>RVkh<#FZWA3fkUszK7v_xn`3rmN)qWKxN zXky`Sx>AzsHrL2$t1DxPkAQ|q_P7aJ8?WHbS`hi!a*6x2-+LIZU)R_7QX6x2Iu~6p zEq?`{Gi~MiAPY<2#Yb=e`0kIDc1rj2n{q+hE)L-d1*7w6qB)-2QvKtG`^0qD4i-HE zL73)U%bpdo!Us*#imR-jW6ho1)v@5(GI#U!;|(jOtYksUG-4#N>!fmdk3b|bb5x~Z zIV|EME2E>nIcpt1`*4MoZK+=5TAuiltWr|Q{%1Z!BfQt`LY3l$X<;m$p0D?BbM=qx_=a&qvjeDf`m$~ z^~HDN`7eS7VYIePgEl*6AKWKLbWx;m;(a;7r|A%kCCQmK~VczjCV1QXDw&ir`r<;{HzJs3$9S0u@GSb^!&_t z{sCtCFgo-xC0)c6e`1(yWS>Jc=Q!F{)w|Ecn z)!+B?LxPz`(LML+&i4*Ckra=gt-}_k?y0$tvvHsfK=v$T7y`dk=l}!kLvxh5o9Ey!jsJCgwnq6FwJVG$>pgs_zK4QE&uN*+LY1xwoxR zPKq6T;nR|J+h$~fdY^-|k9F!ileAcA^ygq4_fuL`j-29A{plH_%`UuuR$(KA8H+3m zp{tqPnCIQ#!i9&X8C3c+xlNMd5dWNi{5f|yPygT1;1=q&81iFEx!c~|L5`hzpmz(D z)z4*R?BvD^wa$+at}d9d-mU<`ntxuODsS5dTS#{(E5v{o`#iK zl6>!k^ADJOl23+Jn`?v9>i?Yc2T9sEHzZ=X_JSn%DpwtP%O<7l#Ho2PLVQJ?87|zX zhN$&c=X;I~)W|BIWGl_{4KpHT;#(}1r#Wt{ab1TEz5;K3{4wW}E1gUo@7Q4mm@&4s z`0RkXc5fzt3lb!OD?VQ|9Q_lkOx!(_y5OfFmo>!cperVRDq9Hm-T9l>I8knh)|``W zI)EqW7mcrW0-F$Ha5qzxpYa^{$+#`9zT#{U!5%91dBEP-65YaQ8 zdiRXZH2PhF@hjc2S#Z1|-^L^EtFl;x+62MgBSLg8W!j`}+vyxE5KWZ!`K93{$Imc% zco!NwHmRiJT{m6UuZ7O!BKfX@AL?7;i298f_MGigSb~`|`MQ4M>^5F@3?eSaPqVY2 z)i%?N>L#`^2KKQ&wx>Fuf98?O;zw{pyD>OVozHevsh(E7jlZ1bIxh3yR|KjmePz3` zm-Nn!Z8dQtR9|B(a4z^dY2p+Vw7-j5U=?4v*>@&4_n)~Vfa=E+dk(!9r+GqS(Q9k9 z6W*alIKSpP`uty$>rk2*TPI?<+4v0uLx^6VXCbC@y-?pHAmp>B1uky*Rm|Cfwn^29 zYocI*nok+M)$uL>#~OG*MGG~0Af{C%Owz;Y)D7h?RQ1j0qM<(^!1*~51jLd4QBQTj z<#8TED?sv5Fl)c}&P~iSbxi8S=h))-nSJP*cS-XDo@N@(_pN~n;&SqeM2zVK(i~#y z=ZT{9BwP!J92`H2e@U&o@aJ5iQXR04c?a`bU&&|QXP>v}?>zfujG-x`BTu_Q{KCR1 zxju{s)W-Zr?qL$&LNn=I53Z2$t>WnX@BjHTDV%!030K0Cp=qsPzME%h$;O)N^?9h_Z%W%K_TL9z-qI>21I zpjB4V7@1(7qHVyigrzdkCQv9o+`Zt?grX1V^mTrqJF_f z+tRI{3qHX813Gc2js5#Q+Lmj?@A1t0EZ31q^<(u{dycyEL&wXYw&J$WTHaaQ2^fKR zD98>6`yuX1y&$ICjdfHTYAU0>iiQ<(ur}QF%3b=IT}Fqy=QKIo#m_U`n?gNql()}! z*46PSB_j=Nc@BI4K8Z)co*l&{Ksn9)A-Pyg}cdg3z zs#OB>Yopa1J?50crx4|6$L3=%&U7%Nv1c$h#nCpGP!$9=9>IcT313qtK!^{=ZO{{~ z@Fo2Yfi~(_U&~mc?Q+IcI{rO1&9ZDwe8#i5oN+||{F36A&!}vO1_iN6fw}_%+houQ zg+9OUyYa(C={?~w?T$IeBkq?$#-|glYCD?yEuqzF4<}h}SLMVw4G{79@%<_nCwSnY za>_Kh2x*F?j)^kV?qT3wuuMLEvx2~dRo}UKRC!h&0^|Z$xC5T`{Q|_Gj5ElJCK$OE zMFYd5b(y6?pUj1TgxAjfjw7`2Lc)i&bupt zWk@F}49X*{nml*o^mzUk8UxCih;m~%SvW;wR!z6ZKL)3Mmw|VRIl@FxhcoNE72r|tR=J$97P_OrCO(zP4X608&(8;0 zqgJDxYWyo|EHLGDAia*m_tQ`9`W`$ymQ?K6m4xKHdEMdynM&sY=Js zt#fEbMf{o=vIw$0aw*fH(aW|^Cb#Pu_m9o*G(e_lO>Xti`!iNPn8WaAcA8Wwov@c@ zZG6kZKUrHOYq7dBi@uU~7#u~qsE5>?xM-rp_=g4ed$k%Ym7fV#pTxtSIJ(-(j{D5? z4TSieraT1xTdHh?Pf2f&=@dzngdrxD3RE_){(P;2OcE2q0 z!CQZ^VCcyeZfb5J{L^83om z{Cr(&T*vt?_1&;ZFK&0uHpDlvK>ItvkG;dl4LNdRY@D5%yh03@WilQIXs7hBb#nY3A~B|JiifCTf+i!HOb4W#%bySpdFqZ`l6W^B$1CE={W&ad zb*?$CG2%+U-`4NxICiS}fxM-(Rbwv+cW}-yKJED5q70@=%KJXR_oszPP^jDyYJzxj z^(XT#&Xdtt=QD2o2`raZ(5svJ)07JHYD2>G`SX-TcJ;e%Ek;*_evYRUt3!{70?LFI$iJ z9iP4*_t(=YG;I+leer9-Q7o5-<3>9FHC%FxPb5y zR>#D6`T{J73w<8h#(P{Q5C~3PkN9F46lW~RC>Ibr7D{EZ-AK1=r1%`{W5~5pNII*r zMLeDGH?{L;x~mwOTF>HAWJEn{fmg}z@8xm+@KT&nzKQOYJ=I89vyIjTY8VsRgXFuc#RM8q0lq%K0ctG$)^}qwt>K)CrCX@=f(pr8wjRV zvODSL?$`B*M;m9?mVkJtUF>H}Brxhz!%p?Z?#6MBdLcPGMy7NaDQu*DKJ|13 zYrv$RNv&#n ze+F_5TEp0SGKA67=UTAkQUTHlQd#r^y;X_2m?4jYl8DWCQ(%`(Z|=a@D^iyAm1 zj$PSPFg19|_mBHI-zA#dvDCJLNf52-DxycvGX_S)RsWbc)!T)`io2hz6tzW6ns$heGx1X^aC~o@^to<+^*DZ6VOcaT^fZe6-aln4 z2!AQXAF=%I=IzCB-Z8L350@6U_~5)A=ji!8$$4~GM$@V%Ll6Z()7sMB0h(Wt(ZFW3U5#{)OsRxups@*_s=>z z>j8eBZ0y=+?^ol!dSb3Wixp_INGsgnvR75uYj-S#Hmy4T=M^%CBA@%La;CH)_FZdbO+8gskXP;m9QcmiW&DaD*0i*J zf46IRb|VY{*1@~qiTeFsuA=WRXMwrNMnWdR$2RXwu18=s;t8zQ0Z>B^Oz9iP0JcP|1@$G5K;Z^SMoasiO>(L8oZ~LF+ zP}~fD>hd18GsYQZrQdVDWLfB(@39Z*#^V>VYr%0|bY0*jb3~xD#Qiz;iXVNs{#_lP z$TNS``~FyOsj0E9Y;BRxGZA)f<;J1+=*2Z{(zvQaG~Cs5>}%E8GQN~!KzX`w+&pq1 zudq!^_%8T|x{80=in5P9xrW>cCNzTLdz-LV+@7|(lDrR$_G{NgPkolgzi>iWxY7jD zW5raP;~`P;-d1IcD7kl?ct)5s&G;af$NbLWqafp%Wb)5xKX-EeapNub{Ue}2#AGYV z&w_x%xpW-w&VsFc%M&clzul0~*!9g&mNX(obC%Ostwea_n^&KoOASP#Njg>(w80hP&k67=xxUB%qi*24k1y z^D?$jd1rmp)Iy$)?%JcK@k!l6w-_!1D^zZ-t_5!Y{^#Eb5M6NkaybFKBgd*5Whu|A zrm%7_6c+?~B^?ND%Yg^#2}xgHg3G0^#c8vsNaJG^DklxP7+z8klm#9iCHSbv4ANa5 z#zN=>_wV8GdINNX)tn9zLyGz5)m44a7%sRfgk5J+G+U)r2FZAlE$d;WWZmwjNV9Wd zC}BT`i)TeH$F0JF{N#i&DfkW%Uodc1D2zoyvHlF=qwE3npB@P0_fK718SALy?lX#RiVt;gZ3)?>D} z*4wMD_T)~}z&`~d_Ne_SNfeNzgIagv%#@6w9^p+oX7{noG274gD?i`Stk&K!7Kg@N z5-wPl$f!Bs#!F@ncRKH!8w!h%6%F1lJzjSH+4pFdPWmez7hQn!&!^=R6AcE|PI?g5 zmk@{_8DwtGO`O8F6HgZs6`la$1-LN$!V6jO{Pr_qjHj*?KPF9Rl5|4pb5k@RO^SVf z{*?M*1x|^j!>HKE2l5k@6=;y99qX=GRCrOmdECFf?&G<)ek)df&e&4TFKQ5j^$L?0 zkRM(Ii1#x>4XV@@xQi^Ps4opi%i z2kLm51_W*@WvxmD!UrO*74x!14z*IZbTdPisr0#bvZn)`qwLK|ip0~jTBK@8bO2MD zSpUVdQ=;?~Z%*t^tihdiY#&7J*NQ6Hy`9OI?IY|Gx7ORR$bSQdmK3f+CB-=UopZoc z0S&Y3_r*R5yqSp^EZ*ev-@4L0#!~+9wf?w`d+bkd)yu7Laqjy!-X6WQuUKxSZ1s!J z(IJ;h7&hTkUF zsYzlo}>zNpb-o-q;eDHTJ477NuHdX zX(*E?uCvBkQ4di=k^!x87UdHjArU9_cIEalf>7;@Lkv&G8>&Q1ZMrQ*^WuTy!&foP82Zc_f z$ITWOumg9k5^HQh&WzdpB2TL*Vrr;?AT8aUGgFsok|jl_wsWyN3T)*piS2?nEtCj9 z^DThEJ3VRB=Z9S_BXSx7ylcmrfQ8+jQ&jrdfL9Cx^T2EgdGO?DWm!RjF)-9p0GC-ms{HpK^x#FAUj8PD8lFS7%kbG6fY2)0=H$@DJo z0BbeA;aH-E7IPWDT_$p{Hh3!+2)X2r@BIkxT>uZ+hg0EwA-yo0=jx2{;Q3RNMciy& zn@NN;GMP&9>4t^{3<_a;sfmi_Ac$XX0%wK3d%a&_6|D7=>Q6(CMXbR=quM72N7{q? zbO3h!C9axr5T$bZorIf!t;~&S8kX(b5XH&w27-2)1-_5On{%^wg^(gEq#--`E))Iw zJ5+0PevYTtQ)nX?S?<{!Lufe=*T^-mWU%F(NJ`F$$*bXs<^CYH24s@e_cycanSA0g z+(2l_czNPBPtDoY6Js*={8ohU`=rTsDrfQ`6`uBs#Vy!R$X{dZ1YMgA2^(848GDZ1 z9eiq$~J^)xir@!7W(0A!Guf+1!>zC7M_Gv8m z?t^D?IFntn$sM}IGy=6d4VC^GttJl<_-Fc(g!1I18%SHXVNtig=Li55BgUaWcE<|U z+otGMRy`a6srTOzXQczi5!?D{jej&s~#9&;x0uj`)?Gd(q zgni(z^2AItbiH9a)R~ZmTeCXCwbM7vw5hV^{j@!iS+$`4=RU{+Mi5S#2w!WxlhG4F zh?xvl!td`$`a@&Dy|0dR4?$kWFTn%|^^dtv_zdTtR;>HNo3kM3ZC|eQAc9CK^qD_B z|NHm9n#dhaMjQ~;Sjx>N^kTFrgsLLup=gp6OE=?&(uVs*U5SL4+!fWr_K&?B^A|U~1 zM4A}oD?4w)mLT}|(JY`NsOR~6zAv0CYu>M)_@$Y_X%G0Az7+Q7Evc8n-s}!HVENTB z%oyT!2=xg4Q4!#ciN{%APOAzcX50g1S&E~zO0RjN27Wzq)8A@5wSAUW4O878zpF+DQ#|QV=4+=MoFEG}uOpOxUri8*;(Jk?yCLI_ z8+Xn;(-4HiJS!vv)h5R^b}cj~79#jC=uhAK^0Rx2(Prx{3$XWdXJJjM_@z;oZ7JZ`_Cnxd#^p zn0E7Ey(zKmFdCXEp=-tE6$zrxQhKCMlD*q}MBET*;&DUbSO5U7rqDEjV{}sm5N{Ar zw@DUqeNX6^!2YfqEU-MbA{sKPRmsPs8WS8<=|ZK33?x2r?*czREC0#`A!FCaD(P8z z2k3yhZVl?qA3< zAL8CBwdI(*=N}87tX!}#iV`<9e1EX*pxA>WXadI0nG~VPvxr$7K7@l8-RQV^J&Qkx z4>8{vuXqPs69wUC3Blx|*q)v}uD#PDB?R3ycdV>Jazbjq>6fkvcD-!AP_0sG73~Y) zyZ1-I=y#g>`}{}ja~o*`f{YR>|Doz2iKJHJ6kwEu2=Lt*0)YLH^5MpSG0lutV=-dI zU@s%<*!5k`e4mGYmTiA@t;im9GYWs4W!H9N;+<+$hZZTY+_dZ=P+n4*j)%VlkarG_ zTd-ek4P)`}cT)MahbX@32qP4$cHD`b{(0$U|4qDIwL~XN?cJR-5_=TCG4COMoC!SH zJNBOua%_YBxDx!-OSkpMXQ58}wdZfnXFfKCXL+=JUw#&)#NNdwES)O_7Sh;K$@_`2LiOjmiDiW*gE6RjL~L^bc3Yu@hh=hp zJ-)26+CM-2;>^IK{un3EV!9r^pE;x`C|kI-k0zuZ@rO6rU`|R)W*}U5!`%@m(?bUi=KJnwvNf5A>H`N2A6%Or)bmM<7pxlwbYa8;>i=T zcuP!$fIa%`HP-7|1EM`-t54T_-H74m_q!j0^m4aNgm|_QOM&tvRrBhPjm|XxA7Kjk zL^P^>Z?kt&bxwB8k~ugM{L}cJdYV-HEH?)@@Cb+>j)&KA>diA#;5sdH!ofCuefu-r z;YU#1_C^wADt_J(Oc~|oLpz#IJ!}gCmFwfm8 z-Tm)a7HmydW;3yQJ5{>*YthMb*4vJ0+K&1sjZ;n9UB}go(sv7ao`yZW8&76wV%CuU zOd0HSUZ1fWF-r~mjJMSo7BaH~YZ_+c!4AF`wKVXII7&@oXhfa2gHy)X89JB7m~p<3 zC0}paR@~2YeWX3>AI&j>l$Uj0Ra-XMHn`7UjgXNjKA~^Bul7oj#cSY4_W8(yMRN3t zgF02d>=$p@&qv|?Gc}lsz!!i=xsidZKrzWijHS`&LZ}d@StzOAJs7EOicbu4y?$t3 z)nCF7{QlX0I2PFV6ZS66D9+&>d>ZH1pWBV<-VbI@&*DvNrH7Ok_iwR$$gLd8vI#D#pBqgq8t{8x-bvL}?~l0h6+jFI(>BzE!6pBR`{kT$Ja{db%xlrw zIgPuxBh~2(3r%>|@=|2WZyd`nE@pe@MU5a&Fr`C*bIIM(kd`QUE6gd$)22L{dhQv+ zyXDWYb(4|umExDuALouBAvh1YUhO6^js%aIne$oZDB)(3nluLkBVzU(fX;vZ`|o@i zv;jeh7k4}-n{3GO8|uHZ0JsAJglb83S{>o>?u+VyB39ALKsA`tb=S**C7;W$(2Q;r zqYzVg`US=@fpoP?aGw8hqQj3h=Fp)g^g|iNFp1m%$%=(PrA|5n1h-Od=*faG-%fW& zI~+EFe+b+jolW5*Hz&s+jli}j0p-1}70M*o;*ME?{cPjw$pA2i1J-zR+=omYI68&< zY*Q{Ny%of_fqQh$o2`auNSfN#PwvyCS=se zGnN-7jiNtyn0&GukoObBc6U)a__Hy*Y$mkjx$XZk>qVvlQ~69RE$hd&#@>7Ap>{`C_H6A;@CVz#45O!h~5IOr-=ITAAhEPb&gG$ zPn_DT8ELx%ca(XS`(9UVu&OFyum_gacrYqtF6NFx4sbxtnQg)G(RH!9!KIK@E7HApK+H)u-y~Ih9d7|QkF{BO z)Hos$bUO$+w?7ic8z|rM0j!~~u$lnkuD>rYAtjUY#FU(d_ky;?`g7nM15&q}0a0rY z$8#bUR7|eBIX7fUrPAz@L5Yb%k+kEtC2D#aeW9VATogN++y@60O7Anpj;eJi>_IqI z9CHScd=H^)LaXZ|d)5`AQ8!mnu%hC7o->vpj7`%zPoaog5YG5ziThyT$F)Ms%eOVr z$ITd==com*6-^PlSQLE4NOeemF1WP+JdMlxAVzrL&MyNcy0QKTHIhm1AyX${)hw~> zT&)(BK%^URr?FeyCa-3&j|SqyD0VK68F7`Bi`{gy=;NcQvUxhPu|z{n+Z@!T?wzwO zTU?wV|A&`nt^%2u6=(BHkN6V!uM@`1$3pG4_25$b778iod7F&n&Ezt;NSOiK4ERz~J4q*vZ@> zo1&(9+6_wbcg)=`hlyXdm1h%&;fV`A8xxh-ifwUCu<3K_2F?9ebu77NTW@vZ9oCFR zWsLyC-(xH-t82u;dd0*9s>7US<}7Js^c}Usoaq+SyweCQa-Fm9{87b>Wcm*MnfMY+ zB*r%B#C}Ze^cwp#R5UMQRL?^I`16l?a*CM#+#h#16w6m;3vk!9rqu)sTiF*+M1`yW=K6iE)AHr3i29JaE9$5$_+upZoR*a zMuSbe+%RQAM7~GXi}q*!vZpXS6%S#=-Vp`XjQk!Awl9YcFjf4R+G)OKf0MCnnpE}A z1}(=eMf_CpO&oefC2#ybZU&5^)dUnGhOSk;usYbyK}?xaqA^qTpFN84?&nNqV!xo- z#lytZ{jTD;k}v5TH-#;n2&|Tp*zSpLp6k>|npk95uW8JLbHvnzG-ICkP&M&UoJFwm zNip?LBV)`AmXKOp8t-!^{@=Cf(l#pUmXt?%!Zse9yA@!TMX;*1c#OXq%V`lGwe0Fnt<(E0F1X@wKsyd7}c+Ox_-jU}`Mh{wn2V`;b}JHSt$_XuuNlnKS|oxWM+a zZ=$`wkF8M4O`~z2h4&d<^U}bGP6t~XR2qv%Saf2+#{E;XUr78VD6awD#%B4m@<*Q z3cSm^1Bet>13VK?HAI7bNH5M!kJ=Gom#l{XdpnWgB-B;o4#g8Ehc3|X4>Et3)ut8MO)XK?CIp7}; zGxDnR0@^-AQ*=0;jOS|6yz%=sI64Fr-}kDTk#X509x@}RXz(k_UIJG}Iq{sUa3Mrt z!Bx8L(L_e`7cvqY=v85J}*T~(eF!rWi}Tp#LIhog|Mc^{KNA>#ZE zuymP4egK+h0tFIVR%#ydEK694ACpb@U5MvQ@}C7t-2W{?!=ER0AOFYo|L2*9@5Tth zSTw_*E=J*rSq(^t$1<3dr=~vt;A5pjLb&8@V#R9t$%hIluFJ~Q|2INEEpQCQb4H%e z%{dC<&$OHk^gFYs<6l88o_)u$$F#q1*@DNa41nlyG1vv!ox-adLC4MQ^)%k`$Ubu? zkB^(xe|PU#=M`dtpXo5PAkt%u;i581aXSKkRyKD`l8FZs1Vau8NzF{XWHnwWH>dkd zp~p^pm|A)Lsq-Uv!KB;81D7IWR8~9B)st!lfua#`CO?F(eqahU=-r004~a+pS@fs) zH3*#gpz~*|h{6SGKgSPCrRo#%2YLW9Q9LiH?(UCiD-pcOCj&~5ebofj)fOjAzU9UC z2q?MuNOLY|@EVXhcikb?ny6w5Z+@>IO2nfPO3nGc!QkmOZV5~5Z{fUSzr$j+zbp?R z>uQTannj|>!xUb&Bl=#UvE$cGkBov9uiu4LKgA+9hk0p8P)NR@xMl>kvhN`t+qp$^ z|G}BXoW+OnkZPbZ7D69b_!(EfnuWjI^K)&*pa=8p^B;b6Baolxr)LOx7Befa;-07B zsP(V4b=^#FWM~F%Zh3^dhOj0+-(n=#FAF8-Iqj>TG4Cb9KF@0Mo{1+cmAXKzv2zLS zJG>@o`dz2-GPkL}>lYApddL;jc-(bty<#3x^913TM;lW2|>Wj{= z64MAfZQ=Y+u`Y7Qv;Gal ze8%UeCYH(lzJV5MO$g}E4Gv-gj^??5Z4F}UZcGV14dfRQ=3gq^CsnR`DfnW7njB=9 zJmSEc)pd?`x&>S)U@*NR=-;r@8=7TI8nrVyP zn5nVoE%wkbmA1HgnoD4rAUCaAozoOaWB)wO37`7Q_3{+;WOj|>zKpY5y!Xu7hxGkH z6yP{91$o-)#*0!ZvQEtX8d28unN2v)oXJe6*|NZ;#bnj7+zso?jAnU@266YSM zC|}<2$eFvXQ|RA4EP{*#Th1-W9)F==n}j%~B7YIN{UthZCmzBAG<*YKJV|4a#zl7q z&pRDV3c~i$e8?6$DPFQrTJ=z!+Z%ovn^IZL8%rnxdyrISlS)z1Ui1dYnP)B;%L}&K z!{@ll`i&u-9dgPF(osr2iMnyxPSmvj zzttFjO6T}&Gf7|ombv3~Lq-&5#*y?3d*8>NXg;U^SzpX9m{XrJexp2VpqbuzU@)1J z4PA&exEtjKG`tt0gbU!luOl`zUTpVF$QQ^Q1U09$O}Xe?vnxA;O|lpBH9*CofeiDlf{F;R@d>Ja+frd z+au@F43V4m&_i)|Ykj)^Z@wE6P1=P!KBw$dxg1{Z;~`&#l;40@l&hRgV&Y~*$H?pA z#p6(xNy8@Kh+w#(Ae>PAUpq~7xpRXq|O$IIlyn5JW7u-l_tggCEt zai+Fyk>6Oo33Sb?BapNa9#D40F1hGr>H7S0pebvFSssEF!V(Ws)ryzFT z`=dL#iG2~DLcip$vRv_5imI(!YCrN28Dl?qVu-|dDZQ+WA6#TL@L=D;>l)EZIv!n< zl01VFLWpON%1nv!&ZsB%`DxB*%y;P!xpe{}7;1}2BN=uid}=qy0sfAgoU5QAnSK`I z^yl1}!j8|SNQE~wJ>o3!%w1nPtT{fgD}wsMO7Q6JuX3yUg6oYfeY5sZ!^E|NGZL;B1FP zO?Yk@xA-y)fMXih&&zgkm8c+O-^}Se=-DuCi;n!7_;shE=1}wJ<(Il6v^uNK;RR%Q z*;g5OT|Z!VqZoagkh(^~TYpwVURP&bWX0jx_4AmPB32-+BFU;&TX_^Ab-l>Y>ilbB z!)hYbZG*|i5`?JNqxCnR5h3Hh<`%DJ^RX2rGeDC~7F`ozM@x*#%t4tkiJb{unro1E@i9U!*d(JaXP6axnl&4%= zEkR={Ll%zmawkwibW)_3KSSRm7a_@rVAz+_1@!}_YA$jAd=xozPXaQR`(ru5EdFYB zDBjB9InYt8q#Ou8FOH-c;2;%aRy1Ro9fZ7P0Due@bTL-$kVm2->U)zEMjjKZ>;*7# z?|~(}u!?nPob3Xs{^Sr8OPcx=&s~y}-!y+Yq7-XxM5VixH5YIjLzMZ%Dt-p%XA2*X zYi7=#2(yL;KNL@XJ-51Xp`*;}ZtdA-RK@do{k*N-VRWvEnV6sZ89M`@xMRI*mG@L8 zKLL)%wTeATQRa*?E2p#D=lE`HGUz)>>3rQahuCzZps$R{S?)zj-aO;v)&R6lFHwHu z*6c6Ha&xR{5_zFro`B2Oq@Z%bG>FS*V&tmYM-NZCbc+A(G~?3#bknVNfgMUKDf;~Y zZE?~G*#r0`n*9C_`GNDoWC?!c)%Pm1-*FTDG5DoFz>(^EPNRu|NS*3&v~&EPoNHo@ zH2dD3VK6)`1X!aJZWZ0vBg3@2!&4G#!GXdkAHsw0{Z8K01NxV^!uJ*5=PY|0dkTqY zbJeQAULbqsdGGy5#D_v{h-xz(wGtwb-Xg`T)l-WDL7dUZ?N##S51uK~Hbf%11YTa@%~@0q^S0qP8v^0e7{^ zN<6X{*VTw}SDoziIF`QE%Y{2cTP-$f3*xzR=ez^FQ5_?0>HOpOrrmARzNuja@YPoy z$K-sUf|1v60B;!^P(=FcBz~61)2*vy4Cf`rStEKe*EA+>=h{3{eKqR9G~NWev;d>T zt_2iQ5&qm&I-@ky2p(AE+)eOLl#19Os-%;i=E>6MLNmN%G_M;jkvcRMX(qbB{Y9zj zCtNUTr1c-jRZUwR*Hf4#WM4I#m$IhwkIjMnZe3_iOA&j%zHfb}_FqA6fpN`G_cRkR zC0TL|DJYdbv0Ec;iEtnU$d{z$45^Ot+-amy7~b?*MYUH)6>cPzRnA$qdnw&NnsMr= zuko!(`BebV+Z}=*k9=a2)CFdF&qe=ydkaS^&;IxsbbcbikUvBDr}?bLvN0rK;5UV> z#A)LDFpXlOus;z^@bqLBQ@Bh)PW3p-whrBH#-|#)~Wx;emH{((WI1%tQwppW86ZpnzQP*D3;1I##Mdzd5^#4s4xr*M{G6N(-^70FJ zvW{lT{EWe&{jZt$2W5}gGpg8rq zX^Yhw!iKtUYXb@GbUs+J&o8yA&+CXl_&FM7JUdyY$DgK$g5L{)BwhVfx2@aSy3$Rj zr_M;84;FI4&+KWYsh9p-k@)!?sZ@L>jUA6GQKmy2UUf&a>x;5#Gvuj3tT|NPBPIPH zWxGZ1CrRWbG1_yLJb26b`AlB(OpKlPG{*cJOZ zQoiwCXBxSR-V4|%GlvtvQY1KoOhM%Jc}`>2JB<^F?cVnhqspGJ@4OtBEb7UpqlbtF zkH9IY3CQv9^Sy8^yV3aM3|YzFpG&AL8t>*TY}GPCgv`JAt<4)usC6FXEcH3yS(?qd zixD-}WB&cwr0LvwKL>a@U-7k@gwG?6sf&Ml{jR{FK@~S<3GNCL8t-^KV6a=)&n=|8 z8Ixx%)$#LN;n*K_>?f8-+8rU+s+XKw@B@BvLD2H^K~$&Q{HD9lfp|F0blfX8+iQyyKs;o+%wjy_w%LTwr<&v;X~&`P*bKH4YruSq5lx`D z8ys<-={5rwI`kD{J2^u#+_{LKlk>Yy_)oK|>cXJ4m?s77wMpMp757l_T$9~84XB#Ul zQLUnzd#nOFqr|ypr~3T<4C;8l6g__SzB3VL8b>s#mMZb{fdrThC)maG@0m)-=ekKb zh&dZoSUFe_7bKUn>c!z6fU%qp-(#YG-8+q=9WAn&A9Zv*&$2VD?kyerjekC`SWlc_ z1kxe?hsR+2mGp<);s4OucLcxqQR_HcM$jMASUKcj=R+DW zqiSyc`8`uPcaHoNj!@nYbSXBsJVx=Vt^2VW`T>!Ejpdk6wl52*I% zeE7m;pIErlpX-`&ND;_FR|Fq1~h0dMAwN=0Q7tWFWHUoZl zR1AGT59c)J$WQ*XN^X?#G||%p|5Z(%kSH?OmTCM=eJ{o?;E%~)mu}>5BcJ_mYF>jO8to9PT4=| z=n?O1^Q%ddK9`>ZQR|%8-D0BOO_0%cqNqGSjXllW<(+&|q$iXd`wi5L$VauC&lK2T zC7S2pM`HfmD1-(O`s`>)?f$R+488a~9)dpJB(n`JTS6fWAV2+OMPuSIeHkjmo?u5D z0KcDKHNmZFvi$h@t_pDLnLIHz5jjF5a(v^8A9yBf@b}MzOy$}Ob`xgp>)78#L!CxI z-;+Q3P^??xxz+)>jk#V-Hg%g0B&1KgpKmwlW17d);QvYarzX!_PsG0aoH~S_j)SgM zdzvan$Y98zwIEaz-H!EO%(f8mclICr8Ph@DQukjPer50Ppgv$q!S$<2u((qE{&D`$ z)K6JGr2=O$;wHL4VYS|M%sZCIIUc9fzQ{bofSy*dF;=3LW=8r8{Gs>=C@4-ei{nKQyR7I1JT^lKx=7senh!e z2Okewln~WnEfhZ|Di#6jnT8QqDy8@oH`{Z*zQG}gDyca#&nWfp{b}~)xfX+TKGd_$ z2`WjSg;t!w*vZ}NX*bSf*9jVY@Db=yF-BZ5IvW+&972VhxB#&X#85322Yr`n@M+~H~5Unudi|J{gy+pKvReM z`)#61H>~>4uBVRLmbc$^>3+mQnmWFflOt)myFu&;<>r9B!wWI18Xw<4U}SNL8xld$ z3cpBvh))&&be=qWH|F_BlV4BJz~XG%YRz22FS;R)i0mHcuk)MS)Xz1CL=X6kSuEM$ zs%{Q$QT}xG=`?tq9iGkErbg_OZls#eI{*Fu{6F16iM42$q;4XDQ2>Y3xLF-Rj4hi2)ENl;}Pm^jd|XbxqILg~UA72qdErtugI zk4)4iQwjonK}X&G5?k0(SuKrnNbZ~gZvC@o#O$X9OI1@CVh3;wdJhqp(~v8ca8fK6 z_(%mqF$-iRPhN0d9qsVRUO$85qMYV{N6f?>>9aeHFDI(< z&%fc0KO2bs=j*PPyNNItQ=dC`7xI25B{*-1BH|dx4Qt2wy6%YMcjXb{NLv`yWcqu( zOoNg2>D|i-Qo>2RZUX|G+b+{Hu+zR*j7qkOkDw`^H<~TniEk1zMd(;F^hUvrCj?Iv z5d&uREMw~34yq-X`!mA6`Td8%ctCAErLD<|=_oxT;1e79tWP4;U3CZB>(yW1BU%u= z*idDwtGAc4rP!#5)>>(L-HE1;7y&rke?BUA6w;^`B9x!zJGEt#?_jj$PWU_SsGzLk zRX^9bZe%uz+XelO!Ol5{}PZwg9pL4b(7L5=cCxR;y@eRn4wIc}LGC}Opn$l-vS zZsJ}<5W3@y{oOm>iT%#4wzK?{`@nM^0(;I>&NAADMAdskgjk{NS>hh)cc&p$`OOb` ztrIJ^$$n-2S(`Jn7lmL!}l{CY*D-qCOdAn`gwC7%2+i-;}{W(8dpt> z@nL6DJ)by0GP$YSfl${PGHH%8M_Jk3YsJo|zGRYT*+NoZXNYfzk zJxNcAjJ}a`=(1p}`z9yI4Qsc=^Gse`-(niLauXpYZ}6{Yx}e;Q8w)A5<=Zd)#g;e` zlTS%G*5~(&JNYIG{JLb^h=lBJL*pdy6s8#xvYkqhP(Y%62IU2H)p=`LzJskEg*^35 zdU_OkAWJINYNqq~XYx$l91U$O30{fgyaV;2>(*T@4Y_WWC(8CR-N3y9|DV+4$x>TE z{V^tCuh!LK@0sSd!uZHd(^(?9b;Z&8;Y%zZ&*5Q^g^eIXT`x8!x{74Qr2l>*NVEVc zx{*gcHvCd-^^q1|eHI#FtAglcgbcRcVrmMBQqH~arfXzRxn0kM5CeKL;Y{G?sHpRBod| zQv3r+-|zk{tu}wx9)3fq*uNCZFpYwz@R`P^CKH{QmxVynNQrTqE-B z|E!n4^m&(Sp2|D%`C6#JyAJ0ajg1?UKF$I$3PFtHy%y(y$)&AP4UUXuY)iHs-jU8? zySo1J-Wzggs8GxqLHhZg+9@seowUDtH`ZwC)amAaPg(c#A2G6<@^XG!1Cy-@W}gp{ zcq}TJz73uK{O8|!!6C+#C?GWlckDKXp!6>o(C?R=+WEcwQ;Y4$~X+}Da zCr^_`^{6e{$8W(RN_AEHx^r#&XM2oBq4BkIkj{d10#t7oy%h=sFij9;1Ooaut`DdW zJ7X^JyWxWALOeMrd?Zj=-gz8SU;iyDw|Z$;Y&R-2BR(jw?=xx=;RFeIEEDw=t=6Oq z`zWP&4XP!8;<&5Ms1yK>4(B@jtAtlLfpHblC|m|?94lX#*A{{53NOdv0ahoA>kb>; zScOO5tct%zl{0y;`MOV4gw|)2=jKI*_HIlk=pDxC^PZIhZj)|X^k;?$>8fOj2%tg* zp6woU@wny`!qlkB2I&Erc}ID)$!&9}3cvEJhb?g8DCH=gQgv)6fIW^uP7_h#@o0}b zy0J!KBkgAT;OA9Mp$B2|l1%Y_?2@n&*}@4jbphH~TL8XqH>afLQ#HgPWcNJeA+`T1 zt_&vW8I{NE#)_gA4ng)qmZ-|xpizg%5HJ1fx2qDiCAl{`Iohk2aj;e0b=rui^^%XJ z{qTw_8GP0^V6>l;yQfKG@I9d}cC#NG(-26yLO%PW!o6eDL;*8O$Uw2#zTqjre)SX$ zg@&6_{QDVyL$wri6~hfATQZEz1`4i66*ek}>qLL20XihJ3sEc$wxX0iE2joj4B~Qe zbBPBpLCSfFCcAxaQKAI*mJXdXO)>o4`cD6JO&Jd*voy*}`VX zbMF>EY;Pw%bajC~#&n*yo4=yrg=OpHFFN5h$>W9TYA06qov*XJx-4IvZ_kd-8#TU{)etX@B#5U+>JXlY2Lfyz2hXteQ47}p|EY2Y9A&ABh(or~n znz#x2=hs3?$aY$mv#)@b1qZM-9*|XyKnP8%jnSuqCn|)O8^+dvP(UEHJ=WN2T z)w!QVqOt#XCNunuiI+ixPm?R}j4;&L-eiSzSc2X~XEGKYJ>9BHH5 z^jYZ<{61?p_xnX0#n;oMJQ}8lm*}m@MN6bUWY*wSPqTpooL9lKjjf0&5^aT0i?TW% znM^Vfldg}j%jy4zTG+Ul?_YZ_>$=GYdF*Co75>ICH6lp9VUZs!Q(zBapOa_uFaKAO zrLFQ!*X8(`Pj1*tJ@f+2?*}$%yhKh!69S>sTAy3*}VP zfEoIIuwg&*GfW}?=ggsJQD*ZAeK(Jm{J*z}lH>T2w$`gX+^$=ww@6~4nKqsp*G*IE zxWG>6>W)C{blgwia_p2o6TifAaMd)wa`=O~@GY*TO>TyX&-c>An(>_XCx<^8&C75ci+6-b z&bU$$Pm`t;_v+r%IgpiRz7R(FE=FNTr}@0iL9OEZIgpd<`W>HPGRSfj4>?-V@r}?j zcWUcO_e5Gf4_Q4alvvUC_4+Qy^ZWXaK#4Y{I@Pvm_Y&*6$$0fng;8te)SH#yZQGly z-*gK#-0yGf1n1WuHnS(Vb*xa79UTJu&rNESv|Eyo*{^D;T90{ z{@b3bBi;A)IZK3EBRaH5OtOto3u(vAMxlQ^QGGIZ;?g_nc)#^^d>bY!wzj=hgPD4_ zgX_5yGXXTH-r^O^zY&}elV(K)=g@fb?pJ?^?*4aceYEuzc$}u{M;V+QJC<{bY0xSR z+5Jm~f23X+HF|kJm?wuEe`M^$>l=D7YMbTNmV&o}aA+LO91a%OXX4-a-+%w>2Y#(| zHPL9L#>=XAld1tZBMjT|=F1THQO@LaNEDF74%QbXWFPqZ0Nm^Ol7Ps!!sAq{Y#7xO z;~43#&6N|gv?l){)i-L!ko1)|8pGWdO9LE&pWxEqWWn5re^9fzKD>7?r}FQ>Qsp|` zgyrROm0IsaP}Fowb|HzC&R*OzTe8E1UTHjtYdp6Mh_BSkCF?N+G&!d$oE7K2IYL&-s0Cb)qQ}}*p`yzU@=A_zht0TEDc`ayn zLCcey=NRhGcA^_KCT2<=Yja_k54qY)+YC;`s1WDu%=1YI^Fb+wESF^9aaaida*(e3 z5SM6fX*qmS9V;%aoRr6Dt;9(u+i>?4(jW%RH!(q{|2mO$Qw>{=Xm9SM7=!PYHXWRMO@o!Gnhk5~ea7@@#gc8}x*1lKe2@vTp8DVXD7mpo-Uhj6Sn_fV9hgCJfSsgcN zo-}EfL%|;lRBOYL&`3`i!dvr{rjGYll>|02BU!SwevO3H__3*6y zj7B+DSOuHk_rfk+7js&B11I^<=ZIL=HdcLyj!DeRSe%=ML!@%8iIac2IMhOgy*&5O#hDlrI4H2HrJIu_=uRTA~yE#npO8 zZV_|lV4AJb<66TdrOtSIf7UgUXK8Wi@6(jh#Zh2y9CPY z-r$#Kh#=jZS}ru^m=+6Ikj5mbm}i^kw##4!=g-^KooK0!@!+>af* zGV)LtM*S1MZ91`hwz?2pn{RRc|8C`?#3{iq99wzFFGt0t+!m#Ur#gFtQ1?{nkfFgZ2;$2H*ta`TedGIhNaS)c2` znK&eBq5=iSyEzlB9Q#Z}hnEjeG{3#9_}Y3iZ=cQ1zdLPOliLi%X?{U)H51c23;eu9 z-OrfA;86B4m~g+n6!}Q{W3O)-iw6a^<8y+Qg815T^%_@!A6_q5uj}@GCB9rO_zo#P zPk$k1vh|9d=>rqd>HPkMwox>qEk0W<{;HUzdHplZ#*fGVYasGxV<>e--jteL931L|j#vg=X%y2lTVQGfme-ce1R-1?~{ zyD#LP3I3hvlbca#f{katyHdK2)8v}ox8gk<3baLjZ)KEn{i`0n$c_aw75vpGV73WBt# zc~Vzv{{K^Vx^W(Gp`}LWY;~(DbFBz>GZF+r@ZQ7t1lvNM#H}hf2pApc4PM#FQMgf) zbDtI6OW=1w!iXY3nBOw~M9zw1HYeVBf0LudX#gUZyM#%WqqL22{ZSLP_UI9d-NesU z4HfTuW6+2Qb$TXkDmM17=;C3cEj7voRsNsxROh=aHKH2fQ+&OePLSi$K>S`?+(j&H z4#Y-Do^`30>%0^n_tj_6RMMw9oE)9n0JD_9y#;RV-dfF06qB>o*=fW(Qo#@7cqbD7 z$Q8qX-tJZ9{3XF6t>i4!#$Oh44jEo%Yes#J+!wI#miV1HvreJ@JTb|5Kx&_R$iL3m z%>fxOx_772QJob#id)`cvvP zDel3xJMEtT*_ebEIAaR=<_VuEQ ztMXjN9)t6MG-oMXsh}S+@9uf@@}){x)6Y0oK#>gL_G>51P6xK7cq$R+$KB4|inNNp zkV<}HSLff|HEEE>ps`o|EV7$q59DuXC6pDeh`Mj&0qwxY2uVfrH3-&oZ7C#8c6l?j z*yHS`{-l3YZP#9al#^rh`d3aqE2-6qNO9OP3F1xm3o=t9Z9!D$*` zLMoz6rgyBAeAh>#gWio`V1Rz|faB2z{MzH|KI6Qds}hVd z)wFbFgwu_ogTa>($Vw5Ul7#O^N3uhEo9t^Tk|pO-(<4trPf>N;9N{k&1|%@J1{tH{ zRJKaEQarf;L+ss#G7>6&A;5#l^oZ|8*~;g6->ag~l^^@xD@T{eHxa0}Dicks4kW;% zcylf0-jQr8hwSV47y4GA-e~;kgy)bdY>qX0K90x&YTokP-}3n!Sfy=?k?b*;#_w9m zzj4u+ zl_ldAL6`vftDt0_{*-@axQb<`@VG*Ikq0tPJ8DroU4z}^PMG8_)E6+lOTNGp01ibH-$Fvn6)!n7-14R(x5>cQ(YC7x|sYr2U z@^xi6AL{;6`&4gyw|yIlMf^2Ak!E8;y)3I5e_236apj;yh!1mpxHyl9?|ttpqR10C zQeN6hZWU-ccM5c`RYjY4D%-tSQ~*@b-oWAlRmiZ|BnYZG4}XIN9>TZ=u|V_Q0V~6Y zvF!HX-m~Rrl;g z2^V6Ce1bHuOmN1^#z7ecK>H#}L`Oys)?zbpp`LnFR!bK9SaB%h#%&U)E;vzJ-?e&F zytKeB3+{}!71vCxewB4iyaA7>qAF`T6wVd*Jmsex5Cov-d;Q!bD(TdqyO?$Eq-on0 z1NvO*!6c?${rh9+%O?7fe&YC?w(hHAt*2$wObK}n)O1TN%LUd2HfKDc%doRnseXo% zs>unXaI(?oN;>z4r*l%6CyBvT_Y%zfI9nS6r;s00wWrZ%d7sjF$ z^4d66_^ySd1uO2Nezk}*VfAJ|4J0J<=Z%ZPJ(-@+tT;-|QrFp;c!gt41!X_10bVzP zhIu60WaxVi#EB?ZLDR)`D2C9VEqD*kr2gamWB!Ou@8P9<$z0bTGyz}sp>!w9Xhw~f z)WW)4{k*$O|J_NMbKJ~sF&U*?B+IK4ds>9kh~l|MOHy4oyM_=ah9`F=rcQ*IoR+$I z{t=WOH;p&nB?pMxV;Ef%+flu^oDy(lQM7w&4!&ZOp;d@h?cS#Qk57Zn$0NpUHQDbp zPHQ?{`NuhgDW6u77BZu?#JP(0yPjAzi3sgP#MaENXK%B9FLM&c;Z-4?p<0mnK#gUc z8RJIYE8!gHbK~#_hm@8|kDNTd8PH_P){cmnQ9wW#pNVE&QuuB-wP%_v{{n!v8(07| z{$7fYE+N{#Y z<1RsK;sF<3RuH-qvoFs|x_Ie$Bm+|M%dEzv zgU4cEK-7C^$^%~XMZnaX1QkWEW)F`}*6f$-;A_~=6{>#_Wm#GX+Mb5cIiI*KO`WENv z?4!N=MZeReWxX#_LafpF=8{xPcCSJx{(=Ti`T!;^>Pi00%-am1V%!Cb8XULRE8c@n z*J|&I01i4I88OxZhpWF!5V*upNw4Y8J@6EPqFvtEjlZ+-2KxryLOuq)p5DNAibnyo zyat9v={Ku18ho_FiKlMkyMIHODb-t3^yAXmSLhkCZ%A^d<0pFRKSlTOR3p0RXm@kcWTP2GLZv`l{LvFD$SRa*V%Kf zSZ_>?i5n<_K*)gK5jRKCI0+q6!s;OZGxP~rlIabsomM?$=TAoE0j#f8cpKq8NXKh%k&BvcPB5pQD1Vms$`=6#n?6j+S^ zxto0|ENnvnPngL@YUH!c5&1*0snnQ|$D#9fnp^V_HrIGXBc!sds@A`!OiAR&j&5hc zu-|WSF`u)4;~{j7ckkd+!?4syDfL2~x-hcNXgAv*)udRO(v%`YQs?|Y@67+hAIEp( zQD(;AV;%5=GZlyS`cicytWd&T7{@Z;_MyFwmXQ5CW8f(yr(VUO1c4+)ohuQT_F%r# z=p$>Vs|8z$YCD_a=|?wMcyx+hL8S%{@-N`!X&w z$_>sBQD%D++aYczaRmZvXOSYs=r>}XrUKW^Rvij9RF)tasoGM60*F7p>dPMAEWi7D z6y_wB4p!9Tf7T{3Jsn}&pQkXcvOqTl6kHjm7M1GFQ&YCPY8@k3rNlH zImrq8&){)>PpYIDvp(FC({`IT9 ztIKEDP5Q!o{5fRs9jDaHn3A#|E{fFvsr@dq{KM`sz_Z^%O6~bX)_D3@_X8dNf!M{X zh~)#(cpRrSm9+-PEn+Eyf}&Jr7Op zf?~|X#lj~Hue+}JTi^4}M^gb*sZe2hp@pxmPl3`D^Lw`A!|XrPu052KC7fdOTursY zPLF50QZ**r*w!S|7z^Dfs8NMeH_fZk^w1f`^D|E{i10;q5*iKJ%@wD=T5)1>$KZ%B z5&lCY%J$ax-XgDr23z6Wy+@hS!9^YB@stHnV?#nG-(4Lo^wmP-D*SW?QCoA&*CF}) zc(PWxsPNR1x+}5uJ*o4x2c6GX4Y(SK;!KL$W#L%mytTV+Fe8L@n32e$+S7a{kFWlo zxk*)=o3gf~ZRkE7E3C^xwo=^>x(@>+R@_ZLhsRmMWKFi6%eNj+lvc1bED?jRb>@RnlLc#RG-25@BjSEi`fQl7q@@9cqS@EZ=1A) zYk4LmCPfhyYGYT36o5U2&m~HfW9}?_6!l$9I`BA6;do+E$>DQX%tfBMi5#o&Xa<3H z7K1t|^=`^`3C4s#B7kb4BZ8^YEj3iqv|mQ$d7&&t&#)r{DA&ld0C19rllst>K(kI! z1gmk7WhE~5;4VI&QTL8eR)Mw^L!!x}Y^CbDWNTqS?B~JP=>+cO9f;B(z}j~(QNj7H z1e|N_B&~Wk$i;vv!Y43F9q-~Li#bb0dBBm$zAeQ#**qD)?`+WiqTYf%t;j1!E4 zl*jN@7~oO`Z3X$B(*;vIlBf}HOaMa0m%6r@P&tz6uI4+ty{h}1$(E=ZH-$g}#duw3 z6%aZ|Hy11EH7)#jbb?$;Ig>#`=zWq}`i=-*X z_2DbQlD|;_4aco-+s$;e>%il1Dy}`MWgvn_g>F!O9BWI2m8KYu?QsYyjv8A5*806s zxo2;L{(FJn=MZ!ciX)D*&8cvXL(=d##^F3Mn*{lH`Mh|})y!6`w;H8kfyT1&z9H*4)G`zNDL+G$JJH4(fa%v8#^ABj5c=OrH-p zziqO)V3EJV3u!O_jp(PwRWrV}AiZo)38L&TRd_L6J+`SbQyB%K)?*4#O z$y5*HTTgSost;a(?ccc~g<;dKv`N6tidq66!-Yew`(V%7pKxq&fQ$9~ci8=e|4S2t zqZ}N5{eb%r?EU%OU>W8oDd8IUU8~&ICqJI^!p@#PaAOBg)3#LzTD%bTe7OeKgx>L_ zlmC5M%ul05s>3GPK|H}b-Fp6gWHExhSAeYNtgud;P~6ZELdJ7z(Dx_B?@i%#QjOb( zT5;lNGNQCYp>#(Fi6v18|0b!OKThBAY-1IU#U^xT@diZ)GTylb+T$^v9DVkwL4C#~ zNaLHjiphDy?46xjmFtX`ZK)w5;^qi=UrlmRNYE0FwDOB4E4zU2qJI`l@Oxk7b8-|S zqnz`i>L2u+#h=(a;`~03fFdM-!K}TS6Vo(Rd%?*h_ZmDYpmP&-W!pAE@kD=i5(L;h zv)?~M{RzqM2_}-O+oa&t@C!xM952y-eSUE4q=P<}3dd86%}wkTbe?5_2~EoC9leeH zc>7o5IR1;=a?>nLE@Mk$`b=jk97=%J?cEJ6^|l3E$2TvET*up_e2F-&{=3OIl+RcF z)dbFxxCa9R=E(i?JDg@4Y~o`cn7epfKHaCNJV%KD_V2WC!pe6wK-r+5r*YV*riG+M z9#(D>OK4f^bfyHIYin$)A|ZnbPYlz;SDaifewX8*SyWT+aT+WCV4GTthK)0!dye|F zLqNN1VwLNA%KYLQBKEN1n&-|-h9;vCH?HbUW zwcAT7-Eh&wtMSWa^M^JwrF}Ss`VHnA?Xfa1;ypSCo;2oz{UO$H^8V;^(;rU#Zcp#B zILT84myNG+zNq9XcsjE3vPJSK4nlSs{~ub;j!4ncvgO3w!*dZYZsnaUNc425>y$B` zVa;`angF{W$$IBg?<;}M`)9DsXJJuT9m@9YsPMpaSb53#s?Yy39@IVbS-B)5>;4h1 zC?MXN1@-qE`_t>b)LN_%KN{Pw&75mB8|K)8tLl?z%Z;9=KE)tQstJf)eFsZw&43=e zaL$n{g8tmKWtJzZh1sZnw&f&T*5mZWpOK0iBU>KvtmP?5ijF84_~dgh`x1<-Z(VaK z-&x?-CYXiKj{=*g8`WeoZwm2117oX6edJvQfxolxOC<7n}Zz z)*oZR33wsCriUI$K#gL~63Hfoqg;C~cnDjQ{(1WX8n$dHt27nos`wC|u4sE)EDAx5 zg3hWt-SwCP+SwSkS25tTaza2}pSz?SId75%q;!@qY*lQ-E`}q}jSx#zg$Mwpa215r zC>X}wKs}5j5PAz!KfdF#l5v^B}`(Q`tT;P4mCqiEb$Z|UH zuBC&u>TP%am2msWuWY@Nyb_?ts*HUOe%JN9X9HoF$S`_TAe-`{8b6DNw980a=4UtY&COqwyBz>+OPCWKp0R!(BBm zP2jU|m%gL0<*2zJlfEizQWaQQCP?D7qw+bp+vt&Of&X^BNHHp?rWf3nN3U%YKvH(5 zS+rpAr|h-1p4PlyB0|eH7)!RzD5#ekf^Mo<*0P;v{#->mkG5GkAz)}Spj1>E#I_0z zd$7*E0d_fF4k@ik2FD!5G1}AUgFpFKcsy5Nx8X;K6qa!@}N5LlM;2uR80uE zsAu>6L{;G5TuQ)FTb!dtm}Ae$^EkD!wXKj!Q@E%m($CIPnQMC~7k)lFjA5{df|`!~=HUFs*qAz{OEBH@#O~T@6rLd|uFD>G6Yob?*cQ&U6{2?+ z#paNVCTV1CmT3Y%W4)Kbz&oEy4H$+Ugp>ic~*c%sNHxsfx6!V4|&{mHMTxM%k*o!zC2rqnorkxILaMmTexwo zcm{n?ByN3<1WX5Ns_R`DU|v}-c`r%n6D)pV>>PW%CqImeIW7(Tf7hgq3vqb>UMb8` zI8umZtP^@y4Xo84?{4lb1hPM(w{tu(^ij16 zwsx1iW;0d9q)UNq!ei9OtP6t6`1j zM#SN-gpudN^!W?%@lLy#*y_cWU{>LcZU3f#`zQFJ=A@vDXYw7{sqp)?vCi=GjN$_S zZf)ISD;wNrN=|pZwqfYT_h^!&G$F%tG7oW0B7|au;x3R&B8lWeTdR|T(S+LoAtpJf z^;psAHu8@BRExv4rU?B|v-k~G> z!+hrPc(Ns;?%6Q57~u-{Ns0X%NIsW#LC@NJOU(}A_7X(JW)E2H|Je80>Z5an$k;9F- zf5f**O|0p_2Jt2B8lNiN&Akg$9g#-1u+o{DPi36q<1yZD-Ch1!E0b;Y%4jW&qNeNG z-~qO>0fsg;;zs!SO{@!t$+Cd&wIdD~u#p^lwLcg2Ys??VYQ+y(T^&6?Pppgz>eI|G z!3cN%o#Q;JV&hRFAg^Ya7)vC)FrS8^MM)!KDK4|t6sv`b!|xyp6i*VtJc7u3Z&`>} zR*V++;=NwvgVFchvs}tZMb8=iKt6X17YAH+EYzGP+)+Nujvh+Nab-k*ELyvstS=Fz z`uzS%nG|6oqiab;<~P@x4?Z-%1>mcRmpkiG)el}|dS9Dk#i%keten5pwBiEvWT>JQ zA<#N+I+px=_n>~m>Ev=88xD0j#*E>AFJ#2WD1&klz^arn)=v5P?}YzJ5>g|~Rv#g} z`Lokd_?*Q29~MXIjMZp&NtnItMlyEsV$+@qpFvDNT75Z4D2 zjLdrL3y0=~qUNml6Xi57&hD1&GPQN>jrr}Lqr7-K0>|{Sqia;nj=^_8fyO~59V|?1 z2~CjC%s4O-kIb}|(KC;x0r2oMMVKgj@ZorIgeh02RbBT>UBt@hIgy2Y*AoP z$Dr=<_!@UptLEu!Q>dtI(k=h3S2Zsn7ec{Z`r4pq4{`+Xh;%e~4&Bt(SApUV3P;9~D!9>1jf&lHmbZ7kM94x-8%jZUIDw=XsRp6Ra|m zYCsC*Oc9z~>>rDD18)?(dAs#PM;G|E>EqyScu|HsTXUWfsu`5Jg9lG^P_Q+SCvmx* zDM!;*a#7yPFD;$JyuTqS@j-}X#dtG^g*%gvOiI{FFNNCCm3oLzS-eMdhR*Zz;R zUtrUPiQEK4#61d{)mKC*@AYKt^gQE#&S=s}TIKGf<8zeDAtDkU>769TIS!%%RkaHq zxiE13tDwOD1(=Dn6$$C_VvqaK)6qe$HKwCv&?MtL)d4V={v=_#?a+(Fjd38wlI2&@ z^ekmgp@<|gk4y7Ww7ebVVHyIFpv+*;P1R|82%hYKAd>ayp~rN2&<@m_P%`;2@Ks(t zscx3RY{tv1zO$-u0nA9Xov|-XIoJ}TN9&RG_pOR6iEQL>hF?P}7@ZFlVpgNo19<)2 zc<&ioxPL)$Qa@+D4_;vGNG9$8Q7ilYW1jaRQtbn(e*you(tqH0tC9kT#n`7J-}|0g z3Y91}oJ%l&kC1s8v%m(&O|>XZ78LJ1V>k7^6iXkHnyyWTc_SX(kUGmYDpvXyw9Mr^ z?;OdSCV<@(SYKF!95;o|g29pZDT*oyEA2uaZk zLel?bJnJ;$J-wyhtLX@!(C11W$YSe04V`vUQS+z(^v~p4rC)07fHWyi2+wZ&hKsDK zy*t2caqNAhVvtR)SMq$k>qoLceRI~!$gy(ziPH2fNI=tGLBoXLdW=^uLv&{GANu_ph>l2 z9OOp58bw`J-|*dK((E+m8+cr&bpALkQ^7C1(=8wSNz|P#D(&K_iZs;RlCV{V!bp5d ziEmUyD}GT)+$4!E?`2DkZLtbt>0{SXCI?;g_z{VK@@IEn1^a#onHWD!gfPB}2r!x~ zHu)9WpXRXfy}MenRT4gDokjBD)>W+Okkp)%(bQg=lY-*5a1s&e!qTzFi^*M-&K%`) z=QS5+EmA`SLMh+4nGc|J=emlGaOLjJG^VVmatiSb#rIhEb@1tVrat>T7~SHY5YvOk zFDk1U+pz)nEBu6o-4L$3`Rh8a!D?S9?<%%=A>wsBQd?Rc^=%wfCvoyJsq!wk(Kmb6 zJZXR_*=0c%55%Cis;8vqp27O@?{~&&k$#%A_?4z#1mT4dN95PE#XXY=kZSH)3fY>< z$KdagA*C)_F$AaJE8>(gfdfdbtBI!?w8Tv%JHo5_(PYh1h>P_?RQ3S<1J&1$E35_p z0Du5VL_t&md;7ZppngcB9f24j(pHRyH0SB}tj4w)uv{)YvCQ^mvWM`Eh=RoIH34}% zl^}d^Bs>rsQ+4=G;96J@&3L<-lNs0R1lQ!MSIxomAM2?JrpTa=K@DgtH$zg|&0Q+Z z`Rv*vjoIchL?E-ob4)%wn||+7aP>4j;AipEE)H~F^U*mXMQ4R(DBQlNKNsEq@QG-` z5zUEaPiuU}Ilu}x5<`JHKP@0Prm<+xQ+0awht^t6|F7qB__0lPf1s8$cf3x6xXrhS zSW^?n6MT+rxw4>b7sQ{02?NEAHq>r|G}Xlv2>3qgKV=QrHon)0**Alqap-A{76jH70I)O3!_C!Rv-*51fwbP$2O`1^LQ~g8VHxG~q{pv^r zB!O+SkwAf@nhHJHG-|6XH@9#RaftJ}Ekc_eTumjE8n=x312u!%R(!mVM={M7sq6Mo z+RI38=2M)$Rrm+CDwP_1A>d*G;?Sg4VpCU$cy0KI-6(C9IF-=%lMw5QYtb%9ou|$@PQ?@3ZGi_^ z=!72CuZ%h{+K68hOrX^bS4%u}b@Fp;X2%FPWWc678Js*ygnC zZs_`I_(n?kvMwC>q4vvPp!G;*c&?|=Unv5SBzH^Q%+9m>Nf@-tp?f!lpfw^9jM5Okl#yq zvlojf_)wMqz62weiKnk`R`Ohkd9?Yr?^};fG2795NRY(Dx zO4Njatx`r2u~FO#-5lwdagv(92)6ErRCJx~OeCc|5+(pmHo%ygU=OGog*h3j? z@#lXg1dKR59&WN$&;P18n5z-#izvDeq&}!65Vrv4hq@XmVgSF77qZ@eOWiKT<8hGx zRxzH@**j5}L*qzMwie_SuP0Mjg-&>GHLp@lA zFQJ%GJHIOd4@j|nA@z>wVI|Nn=S9V)i5<8ze=+A|840E|H376$R3>oHEY@6e76jsZ z_e7XfmKtGB1znZo9X-Q=vFQ+H@y2X*x#8x|)3Ch)1kS4}kkI`oSS$Z&;!wCyuVCVf zYTrCG8_OHIwvgfXl!C6T8kcH%)=M|mRBo>7(yoW4yILheRcGj!aKNKfu|lR~KR16h z3LIYu7i5vryYpb9#5UizFcvAQyYF4H1fObNv;e%HYt!5)*# z#J#;r4&MRgkbK@pnaKima(1k^8x*9AE3ovCKMRWD;35G$Z93TP^yaMT2oqO4H( z;{3F`!>V}^c_w-w@~(=$)LE=80N35P-dW(L_Vwh0?q8b7 zCm)AT&F@sX)MTx&*u8^$5K_@oJrDtMMFP6?ww@&rQ@GUJ8dbIiU&NQ^uo>vdv27qg zv54-W#^;WeI(6HyDx(46XNzwX9Bl_UivL^Cs^EN7ix&VsHwku6#@aeOsw_{kHK)*y zf4@9+GZl*uZnRizKwK?CYOsQWn%!ISgYesPUTbaa*=>QKXkoN&LWV zQzJRz=zeINd+e)uH>#K{!0 zjPjNDo>c5!>dIKQusbbepL21vb3{KM8&6$}l$N`?nK^1Qlqa#9Rt^BT&{_GJPu~Pv zao>QmdOO9qL0oAxn7|836wG=k@X_ydFb1hxh*CnL#%3Fa?6@o4Mge12kWPp=M&ynwDZic092 zg-2!X3 zzBXy`dn);r$21YyaTj1S?+Z=C$5mveU;XEgEy>7t9KFLfSEZVeIA5x6PmY$X49DVH zM`A1D=u9y>b8WGQxxWGGu<>jBQ{H)W{OuHMDY|+(|C zCctbLHSQ@$`s*e+tC7;E2xfM@y58StOm0&2itLr&y|2==1AT3hQka+%^*)+qEqTzweBTF@edtQM|>T zKxe{<*!K{gC}}E%+dw9`ng82F(&!nxupWaob&xYXvQQ?8Z@sH^MmG8ojJQ5F$)WGy zsRk|}Q}U2%5&@3~UcOS^8?Z7cRESBWQ;1o$Gs@+T66I$lN2Qa$#Xc5!w9n&Uq<~mI ziwYPVK#B*cd|d1({)zs`+aH^Hj@5Z3`ycmwX{B`hkfPcuc=rJBpWo3#J=LVqf}G=n zECxd3gIS&3;{6EN|I4k}fe^u~%&s#aJdZD1s_!ZC| zlY}nH10;T^`osIFxHmR}Ym#lWbkG&`czZv~xn@UDOU*TWoz;4Rs*;8m)&U|R6omcWs<+Ux zRfHS&o;LJ?-;juo8^h<~kzBctB+j?-+vrQrKD&&R_l@ez*~kjJI}homoXSO3VkfRV zlKneo$J=iW>T9^ybBj$}PXzW%BnCB|LvZD>>V~WDZr#1d`VGP>qlVJuo{Ha~?ujDS zjaKL8QW2R<;2ilY+6NXg^#oy)OfKRQ<2Fz)8>aX3Hf8zOJ7cuywd3(9eO))4MZSK* zt8r+b^m9Jzie2WidAP z-WSZPR@+H3NTGgwO<&d7U-qlYoH4(wyn!s-vUZ>V$KO*T4wEeT8O)_U+k|9j zI8mF{ACAd04pl@(jFFlw^4-h5^>f;nkg2dI#xl;Zc;_8*!=1`A+MwN3A`zTizNbku zU3JK*ki53(i=xXo#L9b3mUsy_pO15<-vmr63(qA8lWbH0>vIS#_lBlneC{i?h3}cM zjGmlvrkgo%3@doir%3}B!=p(_`u}%`TBzoj)_cQKvri9)ojk~2U1hIo=UB18OT#<4+>NugMU>xP z*|xyq5lOYWv^VDg)9$P2ocX!iZs=adV>WOHz8L&|TykwCA=S#P{#(=PsTWb8|8AuY zi*uh8r1MdnaNAz^t`{n~u$SRVonY1K^vK+jwXZR2-NqFi8#}49jX(=?Y^iV^ud1Rt z1(16+-#kQHE2fryCYuAVr6g;~tNm21d+hwcv-J6y7g%qxYRyF2J*6qPKieD@iVnXy zK2#>0OL<=TOE0_BxO7{Fcpr6(lM0+taZ_s8#MAfH+eJK~-E{L5kg(0@S<=VPadslc zixumG4NJM~4rqgSRPQL4HCB``nN0Ttl8jB+4T6^>$M)xpb}CfPe+zSdnr1h_Xp2d6 zUu+asRM8eUl<>pFK6gHQV#U_a7)>A8g6F%yucX3;?TGOZoP4wQB8A&{5`mI$-lt1W z%#8|9{wZN(D)Re~{OJjYjcBZ&jT?8#xbPfhr`liU*kj!K2m>BDPit35ye5(XHMp*3G_UNN33E2I$-Xtwn?ja zWSgU4c6LSZ%1n{f4Q&j_fW^>=dY zj%rB>=(r$hFM?Fyx~qS-ErxM)x4Vz(M1=$usiu20?v9AWfPu5sJOP0QRcrS^5>(4B zbh>WFtG9^515!|!i<;0YMG(vIIC&^g4huFQh=gL@^f(q`n>HT8=F8grZx`; z=kDVG_(amqP=#VLSMT3`as?0^jJw<-o<7Lyg3XK4=gyu1U;hb*oUStNm7lzas6QMx z6rz`f2>C!!Ch=>vff7Z#mmWhWjg6@Y0`jg#gd(m>+tCCBTSO@P{Uc-fBT!iY<^W^$ zr-7OiSIE$D?App#q=rvLhZwPC&h?F_AAOU^gejWKKy77AlkLNocO><)2ssj3SISGN zVqN&_9=U)n1-8~fO2hbCktK3rJh39eQVebLRmMtXJSCfld18B2L%YwGECx_l>udCU{5wbQd1RrJ?~~l+#Oy#KQshx+ zR|EHh2sk~CqH5nw*L&StufG7IgXegelu4uV?gD;yFZHR<>N|Ha98+A}ZF9S1XS8(S zq-cgl{`WcfSu6gWSk|RUIWK^XV5Bix{CDs7oG$?{oxM?k(OBa6d95m4v^&BInj^J` zzaZS$R{>DlfE^K^CT!YY1lH6}&Y$ti3&7jWELhROEB?8eDV0_{w9Awp(pVA3h1I|T zj=rY>2(;ShW8!C)Fwl88-ZkNdwfAg@uxTyN8{OA}h&hvArEBAYOyKo6Pv6JZ$e$lt zf`)-TiLaH6U&SxiR#@V#NtpPqOkPzQ;73HVix1pSdGZ-Ezigb~{($+?M7D=I)43y} z>z`8n`G_t&Pize3@Zl+j+o*G+DnZWS@Vxn&j|;&3_7H+wG$oVCP zb&qysTw$?u_}?85v+Kj((gdb)kYryoE^I9X*sDpquZt`b6hQJWH@+*8ta?6PT2-aqwlTUUP^Hd`wW3Nm+g|uPP9Mzo;gmnc1SqCvB=Z8Y?Bfq&`-xl zo_^cguqph(F1h8T#Hj-QhL5dp)7%28lnH|N9(G(a1}gan<-vS{)V11WP0)7< zkBuXp2jT`3dYc?P0$cx<)$9^U-7;p?tJB1dk*mcQHJ-S#$jEi6^Bnfwry_?09+g_o zD)Ub`*cKWyvQ2{((@Aem$L~*7{r!jcP|RWHAh$4IWeVAZ#mpYasXb$kFSLPk9Ctcu;g1z(jO=hu+mhir4C>sutGAfjO8ffQ#4xP$U)gsYRcS&0*ryMPv zEQ93x2Xk%L=`*Tbbg=kvFnt;O6yG=jApXnZ&OhV^8PyE&?Ftm(pcTt5|wW!$`S zTy>M?-r!-Xs7oxkUPU8J_^LETaQ zMLkQvqaFsr?yg0YqiTXc#UCE1A3=62t){5;uY^fRV+4`G{=Uso2N=ACe9$!zfs}=m zvT-pu8VD%11AnOli+t~NlrGXKT^`Sua>;?YKE2PM zlT3?nx1{VzFkyk$o7rb6-s=GQYvXfMGhOMLydFUh#jjpxEM91$)jo{wVwk0t|jFirW znkU>dA`i+M*?25LRf=EEbywi4T*NE;c>$5109;hpV5Zb#88roG$yZEJOr62CjoOTe zCBrE`&+n?po&tUyJ1gMJ=jUg(OaUr}pdw!dV-Xl$gL2s-T%G+f`3L3YxruQlvSGZp z!6{qc*#u2l2CC10plJ#Jc>^}7LJi|)z_{#hD5t7&w*x8ocmqp=`C-p8N!!tP>I>$RBbB+7MI#YMB|bQ2sK^ZcNGiibDF0)kPI9m|0e8?E z9vfNQNli99KSWzYJIXuBqxPInv5jYuD0)*(722xOy6E|_Vdu#Mn0%kS_o+|H)Xfb! zgNe?(A5^TGAO^M%u=i_ief0CSe}ZMnmow*mNB~sSs$uKKlPry9Xn8Ph()57Sy$2q3 zH+9F}cs)%6<#rPosE`D&&;Dr@oK7ynJ*Lx%`xnYj<^Yks@CFx024RjO!k%4wVB>5S^;?nmw&HfrOpJe zyag2?Su)SPEav-@DNj!TxJl|-AF+ul5i^`R)8EUKAn~A^as%l8GVYM1QeCM0{dq#D zk-t;=eXSeseIL#tGbUBB3)g)c%ff*{Ym)V#a9avb-HkXYqEo#LWWO@T7S%1E~a#T;yAF)j%qdQU56w> zW2YC;kEV80}{qK+QyY}Wqq6hd+5*8N!| z%A86;oiOQ7HGoBsMIea=TmWuK{WFD>rfN5}z;J#T<_ zFzmFP?Sy$=kJQV7y;K-aqCan&8-6Bb(7TK=_wGFJZArxv8TUisPdmj(&N*yw-3NE` z>}j!i?Xzf45f*U=8!(ebZLCZS5g{6!j}^HNQF?#Dzs9mPz#k+IZq4Q$Zi?kB$;}siyMP7`<9eR$zqJ{I{fB(A+xmK&HLIm)#1A>nZ&>3}zNvwF$moNZj zt^_AiUCpf5U5OaFPA1odq5|4$8M*1?7;B6fccCks^`vD;#h@m1qh{*Gl;AA#Vh zLK;N<0PBaCEj*S5dM2N|(^{wM+}^z|fdIZkvjHuI(hW$gb7kFt;^ucegzigVJBT@O z8KB>&$)!1Y68k1_v*vGtY5`WYF#yn0-KyMTg}>d@1ORpKo zFc1zg;Ljcc$4SfJ{-gS`YKaI`RFDShH1b70^Yu8rNAT)-OA5#bB~Y(h8L*S&yq=q+LZ2%9abvw?zm;*Z7y$UU z0r27-S1Oh9$G`H+Y<{9Gg1igcu?JDaFgI-+4+UvUkd}p%&K$@1PC(I;FbY}k08>D$ zzxZ@LQTx8nLVk+y*^}J`z7&(Kr8j&OYm-o=Nv*LWjQ9Cyq?Z1Nl?7WUPO|ZLurb(O zR0Rm!HEt9cAqX7Y;UjaCpB*uHW~5e~+gY*lLB(3SaN`A?NqbH0Y zAweDeJxFmjxho;HFu`pZjI?M#xv8a&v)3?5M-~S)mv$uzEzU-+vK%Wy#w*sTT#xeH zao^RX`dev$yRpo>B~_DOW+rsz!Jr!xkD5IO<`@<&G$OyabCz5fDs;TZA*x}Ke6i;M zn|OciRXHx2j0AaquNynUS%hFa^A)Pxjag&e@p*i38XSTSvJ8H_Z-J7)t`mz6H~XO6 zgYr8e;oxS}y;t7ll_@ckgTcUKlPRnxGmPEPfl|BRbwXb;ru9CSdnxA4|@ zA&Br#9jc{F?ayc_s)#V#Zzv>WO6iuDz)R?o0<9uc;H0UiR%+vPIUajQ!6)3xhK;8g zV>j4;crR-21fo*jIL#Pjvek#pjm5fGqgt@Bixu?5e4e9_4_}uhmqJ&#uUh zIV<=o5%HgMu`%L=P;+fJa4gJ=z#Qj>r~cR7w7o|;HjeMUrd->x&P!hTOd0W@MhKgG z{`)**-qs{Y`g|sa+beO=^ZVdQ0e+ru+&IdGPM&ex?M%-DUPsr{ItrznV->lGazAh1 zUDu)JTl9NQZLV8y?DFam2tDlNmvg~5P8uT)&J|eD1&KOd_x9G{eBOyPA%a~SOnt&f z;*3O!wk&e|T>PoL+`d3@4cySF=08`t+^U5*L9+H1p0e_utgj>#(EU2uJ9GE>LHOAG zMs=(ydnS9Dwh;;QAE^5WUO3-rQb3Ahp!;J!uamQQTbSXvZi4c~O%p|1=h;{>E_~`< zc6W)wNd9jH5?dpa-~~+)_cq30{AD{zHN{*H_zt$0ly>ZtTzBTPraA7~L(QiueBPTh zUM7lgc;+9R`zRoA{oa4soeC7J=t+$b{{KF^70hnV%?(8ixq;J=-H^y#<95}l=Kp}9 z+Xhx0P5~U>O^Dy(nd_Jm%QZoe72^&G|g{IJ~I_vJm;LwI*HX~t4iTaPm>TUuHAR_;#Jyq8B5v1 zjJYHA0HBE%=k9&qURX*i&x_w2{bXUG`G`@Xm#*ZK?7A4gPh`p;?K{GI4%9x2_IYld zsYU9x*Pb&t|NiG+1{#d~-)seJ|?|HLb#xZ$@C*Yp>f$!mrlvDy%kEg@}$6JGP0z!$EqfTl*!>z*Jt$rROebL zXDb~HJ2!ccTFge!D}Y-DmHtLj?wfrn5h@0@ytN$p8L4uTj7{EdVl&QjQz<`7*~eW- z;AEjSS}STzqs-EOf8TCsZzY6M=D--7yW$@qH)fSR2y+{@sk3DRcx;^syFcY z0|dN-Ao!H%-x?JDz+F2h#wji`(`~1g?vYb^2@cQu%_PHUc_Ixmz_7fZ@K|JU0dd%o2L_uh+c?gj&&V03^Ac3h{CB=xIq3uV@ zceausO|G1(kmof=WKBPx-wW|b^c=+}`vdZuiZJ%sGpG@%6qP0R49jFA>Ry~}EodqnsamMo74;A|l< zAZclTb6(8}NToNngPNYD^PL6CZqCDTb)*v24ZJ?=95nEHe79yPx5u3PjNyn2!xvi z^m(X@gM+U`K=+q@6Zh~e@vl;8LwA>opCmDmrl!<@jb~d44{A3r)M%(CI!AhmSfu1KS?7jPmDEfX^c8VGe zpMG}SSd2w7jf!I~v+g^pMIf(E{W*b7mI+ewSw(2v+wMnC7O!6n`fNeBdvtUceM*%l zje*ld#>DEN%9+{|Z4zkMuYC6ILh8SQn(-zK%0=Jc++EUrYY9u=$yS3VLlW)MrbGN+ zIREqB*#5D)fKN4+yK?>vVFLX8-SAIgBoFkp7QF;6Y|I4Xv`}P4U=y4Ugvg7k4yEa8 zeZSef?xx$?E9g0;FKwt8S_a<3$-(T+;ERejvT}2;gTLE-plN%0% zKC)6PlflpTF7-HTfDF zua8MfPpR!!=ifUNJ~)013jO1EsD(8-_nvO&Uu9##H3IhrjqKB~pG*6!FcuLBL$IqT zoOo#Yz;jk1|DSX3$?&rH$#=o^^xW7Ft`~Pjkce*^;J5U%3fZrrGKz}Zam*9`>IVKG z@fWIR^Kx4JsuZrqA_og}i5@rJIepwEl`is+BW-hJGx{3+)Ee1*-pKUkYDise!G$ ziJ_&}Frx*7>h~1Z{$wyzf=@-IO#F6bDKl#3I$x^>)B7Emi_j#Er)$peJp0-op96K& z@Z|p!01aDAF4ouckYBm?T9om1Ek1sDV?g-H3!pKIX~-Ij)H_q=tX$rz8LiiP4ZTOs z1?3%=&m?+y3fCN8nss+*&G-#xCdxI%f$V$L_P;;Yoo;A>-`5sPO#2%<%_);Va=m1J z!tNTz3Q$uikTddfo;97XaeWAQdA$|kg~IvozyGtGo6_*bq#$KIuFg`qyEjo#nOv9$ zobmwMj$qUYEh)y9AZU-HIXF&Hi6&spX~9SB`V{*7S6>ufChpvQ?~jMf$(0~=<^DW5 zzM$-e^1*4e)1+g2T+zxl-GSNfPoFAx@Rr1k7w@pBm}X+M8X%uH1P-6A3*F7*{5e$3 zIiS0+Q8U8-K0k&5)JjhSQ_-OCBB2846IE9FSc&6;L_tRXZ0v0+uv){P_)`#{=is#g z6M7Feti0V(lDa0_Re(6@n|Q%aEl|a(E@DPo`xyfj$nu3$QVn*Ts}7sg{|4o5k|>e3 zZ$bfHD9f|J0^1`#@Fhs za`(DuIw8`|l{(G^QpPEckBn(*p-z+!HBhb?anG7O86=*sm$eTA zv)6qJSK53?-5|2Qnncgc;42nlopU8$A;sa2|4THoR~!x zBaR=?Xq}ayv!45Hq(bBK07%C74gk3ti>v4Pd9us7Fho5JZdL4yMYekUevraKXHH{y zR0B~N$TbtmoH_*D=sthtJm&Z%TsD41$*Z`S-|zRU39KF}wOD^2#rKiLlhvj4#`Qt< zdhtdvmz#L@vNo&y%%Ae+@JxOpp`pB`bN^Q}DUI(*)6xWS6mT^-9`{!Pc=Z}-8OCRj zRe_2j_k&KY1tVL4@==*sb&eAGl=tAJt?uGn)IG{|Ck3y8n(qsN&0|q>A+pX3SHGxe znDaUcAmWcwKfj-btM5j!5pcb-$2jLM0a8PcbrZvnVvv!Eo$|F9$^p~)xtR`V`*_dL zW=G&<0IAI$n~mf_C^LH^cye7hny)2XCR|j|*zT{qK|3T5&%|jfKNUZ?3@6iWr$);B z8xou76=_1W&IV*T3;S8A>~hyH4EkRMyC0gp zhnc_mvj&%5)R(0B{P-hCN+0YVC6oMaDmrhA$kc9^>I-~oyrS{-#e8b^Lpi*>#Lajf zDJr4n!mp6;AB+o&MQGn})yU%5acw>D`+3c5NW9}FrKd5YT%HvEU4uU^ipou5s&7j< zi1~_M*q;`sRZo0EO^RnyR$wzC+7xk$nJz-hixt_h*nKdvrE1?t$6=jW6V)D@>36xL zQ`6!PkG~%|9e5dJNLrLsinKzqaQVKw37~q;N-a0q58~0Xg{^Y#b#?kojP;J}i&+VN zvprOr)*_rEv>JCaSS8w35W z>qh=jjyHbN=N>Vp->0cC;)r-4>!GG`VIr=aT{@$aZn`sPk8;~juSScE|1d{+4|N-( zwZ6ZJ4R%i@Ub4#fX7YhkOv3m5sKHT+kDdC2lS3<}q6H&@Ur~)CFZ@wV9V}Mn(oudV zTin?K#o`Wo?1wlXtnyuoowc;#lHgyO_{vG zY}?HxAUUtW2`tx4U!^4^p@4C(u$~1C<(Ox&&4+viHEHOSCVL+o#&3(&8hK7vnAG-B z{h7>N9to#Z7qfxO&7(IWjuUoF^BHA3I)o&2p4a^z~RP|cY^_`2lJYwMCK*OW+nxo1U{#jNiK7-2>rRTltk^jX7*_#NW}JvZFsqCw;Q`~Ury zU+Om)Z-1T^X{q2K?{XGSetCBJ)dd#&>jK6FrVpiURM-VjQhUJJ*jL+1u3BpZ0ss>Y z>HENnp2QA>Q4*Nq+qdVF4_3FWEZqBWcS@a%koNjJGoA#2=Xa`GW9_1Jen7c8(a5!v zaz+aE6UmLJ#Bx%TZs=LHy23c7=2 za?&a_eYVl^*mQ}X;Fp6w$^QZL-2ASk8>P{p;l#x^1Y+|hztZ#d9qW$`t>#HJcfL7PwUXf(3r&%WQ8>ZwLB)Hk{6DO##= zpapmzG9tKuNi>Yr4OSf)bhMAKN9nX9g0oI}7oSgz$(JJqW3k*a2)H^&>Euo;@jUUM zF2#jX0F;VTjz6;iwC`ry5=C*72~uDFUa43rZj{hFGd;2s3;Jg!0@l!Wi!In2N0R{? zh*qI;U0f?M3fvngavV#I%qIq==;}Z@*aCz~UaOl0y4dy66_e^AU~{DWo`9EWt5iD# zf9d`D{5j6!a;oO5?LwPS9wv<>Qd^f<_P40PQbJP?bXxdBM_Z{bm8-*MFH8uPl8Mwfk0#!&a5U3fHPWw#wd`#kx zr+G{!)fJ#TT1cj21A$Hqi%P3zPYC|WXPb7;F`j#xYQ`t_#`6DEqc02m7CFY}A+<9E zG@Ez^WebL#C~%xMil{qkusVKX7kz8-;b~8sh=8=}w|8usG4V6Ur6enmx zLIre`ro9W*%CdcoR>d0Q~c!UfVXdD+iM@5Z-k>b^=qhyYENy5+J$vHEq zIm8!kBr4~P$P?VboL`gKp&~+Tgu9Idj0`zl^_*bm|ya2 z#lyEBQB7~rIGMju{HnhiqQnr6gV<)R3*iS>dneE?Ij^%bkqJPJR;=tqriDt8N?g*1gUH)AQFT?^!Y zEQG0t^dup4gwH%{xr^UT-XS;(CbLY4rM@kBw;Sj6TB7AiqM`qdCtU`V7|(q$xV`S!; z8s~Ug7btvs){$q!+~wR+8n5InFV;o>@_ZbNcIrd;$OAg{^x4hmql@ z+&?Vr;Dy6i%avVAdV(#Or#vl-aM4|Z^Pm6xFRy02XMwuAjFCV^YZI&%Q*m30V66?t z-XP!AxavTk<|yV|rzjPXN@lEkSqO3iJOBRI;CN6QkV3m=vxSKu8$P=d@!AFb6rl90CS)?D1_xC-7qSMx^#g zO3MxNH;M10ai9~U?>f0if~vNgz|B@?tNu@`88xMvS;gZD?_MG{T^;$93PQpC$`%0-!vWergO))yB|4cp@sg-`nfjffsU%f#N#z#-996^0o&sS8 zc&GHe=AfIl1s7JcB;P&2y&P6VU{C(M3uxa!$GX9IqYRU4i4TkgloVl4UWmV&M{wT} zc_?}1`&*fyXM6X*@>uYTTosdpzoIcf#yJLkFC*KSa&C}}sm?QM8=d2AgLmp0#Y6Q&5{SR}C_dr=P% zEkvapHM3Hmh@-3TsBJ8;$8QRWBme^B21wYEnYaVGdP{_gga1Q(5CY{7mWGq7P#TXE#C^ zxba1lp?{?8KHPTdw;dqQnx7~11GZSWDpn+rpd7%;A0BYW&pyC>NG>s4F!70lT}GJ* zI#I>?0*#tOef%B#+~&cVfEP5UtaD&ea4g#d-Rp_rD6FC!6Y1D+Q*qU(5umEswd&+r za!dC+#IT6BtM}{Tn_j}6B;dJkefr1UdiR!$$t~$lEg*?gSmXW!)cs-w78@;}w{mNe zzcbBPothHCLLR^|biW%XUo=SxX`<@ z5L~ISrdOzc#>T5UjL#lh2Pz8$GpSQlSAKW#`|fX2BjM+zk7*y_+Jx5U6T+M=I|+T) z@;!hjIQ@5u%G$%m7W?C)m}Vql_Ebr(tkhkyO|VFqtyH^|h=nhW0XHhFu?^c8&bG>w&Qz8^&@VVR>S>w2Qsyd-vMKQ((bOBnTsG7y+<{?nZIr6P@ z4bWZ^yhtjWxN$uOrhjKJ0FCe7)T4fPBp^8*Yb^NM1wuc+N>k#xD5+oSY0j7zm(rg8 zyKBwG{UH9{SQ`x0X`h-bUA8m;S(AJII(we3euZh{`c3z??c3r60`_xqM<1spFf4+KHG4eLF%R4y9MXX7gfm~UYEXh0> zTc`119#JA2{iPUmlu&QJ6VDArZ%47)PuQv1C#+#HqU*zo|2P+H`}+y-xzO5%pK-d0 zaW_GVc{RUpyl=)+aj*{OIak|^{)-rQ%~}>B8DjA~vkqbW>vM%&?($m7CA@c3HLuWs z_u>;4$W9cCp^DSOPI!(Ve6K4?vW-Xs_$&yj5A}P(4?)B>5!(L?A*(Ie(hRIv#J&HI zU4VpxCR51`^pxJW@QU(ICqRAq&bIiAO&AktNPX9lBhJI;6=RM_=RWa@JJJUHnIG=* zPlZR6)oD7%qhB$$yE9$yn0o>8gKf^H#cSw(+5saCFDk7^O%6P@`d~$D&Ry{YQKQn| z$B)EKG2S1Y^3EW5NxiV}aB2=|0?pR0I@hP&uIBmaG5(YwIp5zqi=YWt zo+aDelIOZ=LMm4YPa0fKYe!p;_K^sc>U{Qnp1pBm`5XY}-+%uLdz-miOJ$#56hX%= zjSjVwoG-k;=<@FLCWAe1LICDLC3iCN>+}-32n_ZNEtb_j+Ic|9J@cT=-<78Ex zAXOnY0)>ZQ20}6%fva%I>ZV_lE7yrbWP=I@TiCR~ct4;fL_mTDRz+Iwk}MeDWm4z) zR~aqlREGl&J1660ro-(~1(TWqO@N&U3ccOt9jD>X_=?}ZQ|zolD?@#@v~lDslXGSQ zTqv6ay12)r7dvOwt1Kz-->FX1SlkvtS1LOfLXB-$FjyT;MVJ5yPKFo$#a{{Q2cBh6 z=PEH&E-7>|*AH2D|5wi#@0YO;pYPK7-f)i;cJz<_ZBcihu`q*)_V-%M3t&|@`n%pn z467$fgI_bTLdeow!r0* zRF4jd3gaUst#2ZroK#3&_`lyrffkgbQU7TtY2M#^69%!WE-4YhW{W7+efvbL<=H_0 zKAm@`#0jxsWr&*_t=Q+KRgV^53sqF~tEfgb&JcKe`o%#0jz$N|cOFsA@%PDVP>P?c z*wo2+ukuRqt8Fmhg4YDKnj^XooQznqDr2WQmx((m1S(`(2_VFl@=C?{#9cQ4=dZI? z&-qIbBS2OB9ND@V9Q>u?O%dQ%zZWv5aX~;bp zS{_v_#=dQ}M14{^vlVjMM4Eo4?tVEF*Pe%0ZPtDl7B#qA4NgKa@3hEJ#dhCsTibPM z-CnH!wrWzjJjzDg+hX32Hx+V+?i@C?D5(aIEfBzB)w$T;HkxDoAF3j@Ww_>Q<*F z$KNA@P8jAqzu%$jX_|LIA`S{mf@!?W-Dl)@t7(OZH?ih>=~@y~QpWO`e6%l)Jsd|| z`;8XCuQODDa_8=a7v_;rV4+QWbxlwdI6iJ+fk>Z>HXBZ+f;A~3@>a??v8*k z*P{|2@51?UwS0VrTNgwx!TW1$do;RywuQP!4T;as(v5K8S>3U^jyLs?t-S=o?Aaly zd|?tl*xGfH@KW+&70Q#%iU%v+(eKqOImWZ)x&l{5{VpzhyupP9WN~6a zmQ=z>Z~k%<#R|c2It6*RD=yAxsqE%cRl-|8s0r+}$}`=uN^(tN(y1hD@Xz$}ZVc_# zlDFJc1Z1P=^U&t5(j=-nFz6V{A&MaJea!q9Z-G2C_`_ zYS%z|kuY9+mT20($W5Ez&Y(TTlPpV8I9%D*ibryKFJm^Zk{Q`}HU8rnTtl!siB)agv2!xX-(InhjUyFL&I{=jCIn1?W-e z+iZ}$4U30R{K|LssX=sR=Lhsx;%E4h4j&J8X)ZsXZIf*$WA!dM3lq(?7JQS(CM!Zj zcvWcJ{QKp@wgCv)Y)tA4VDR0_fh$jPoH zyA+i0ithGc`1y24uNuo^j_qkQyP0w|B65U10oHF{nnA*`KwJyjglji#8x;>CSjg@U zeIE&FFPMKEhdy6`j;)CMsP*2{} zBff6!ooQhqHjS?jx~C)^Td+ca8lR^tOF!nSQxwr;FU?zbc$yt*?6_EgcpaSyPtZgd zCAKJEEK)qzuy7Z$seOoi;_j`+g4p z4s5q-{I;O?t75e$-jOD?VWLh~#=dR&Kp1&HdMTO2lgbF&aP1V7^uTn|sNfQ++v+dS zO84}v+QO>aYtSLJ=2f$%TcfsEg)WN(0rGPR#?(DEh-KrK z9f1Rr!(0l|u>UiUing3z>|IZhR5+T9AQml6?YxZ;HPEgsKKvZ5%!b3Imzvm|M8pI9 z`3K)Xz@^jJG+5fAb?pV1#9U;_gYox}Q*Ppw65}gJv;xf=#~*^&MS3X*;CW9bXdqC5 z#1txvrUz$^fWZ8%w6Oy8$qVh|f3JVK#z-|LTl?opFf)g+Z=`tdr|h_D366^9+fRY# ze-B%0b-w4FADa|b?i8|Y&w&2ch=jHR#Q2==cgNYWF;m5y0b>b_c+0y%7=R^+?dw}= zT-7RktynVYPt^92NY~c$G(s%1t;;;3k;*Y}40*#iCf}SiWmsq!h$8u=43^6|gaCN{ zT0&i0L<-1xF=IyLg#=pTwpU~`w3G=x|BjvhxS;Cgb5W(B^cDHHU_ck4wqnw|ZL0@a zF<`gF^ZWPR4KcP%8J*=Tm4!uMT$jxAeWk2K0lz8SgU+-fnD&R*=j)L6sdtHXchy*A1Ls_gvPzT~dvv`)zff z?uIOg9<)nAL7KZFw)*BAlWaQz_QV+pYQ~r4d~i00yFqWP!f8v{9cg;vqmqd`556?} z7+)sM5#yQ^E3m>)@1^Ci*Tmy1j&NDgn2$f-`yHmVmmmbp`iVNRa7w10X{g>J%!)N( z_JW&u$dbq|D%#p%HaT4Rrb@X(6Ee`0sIaG(h}!ZBDw@Z3EFzHV=ZT7woSkwxy| zotHF6qeRN|)x?RcyeM8_fIEtPb4ehxad)+(`erIM%lq1*q78s^w~4^Z^{og(&uB?l z>m}4&EEV7|hEqLY+b0PZc*m>;AF0a~Axw@cm47CQ!FW^>6U?>3Py(N;LlV-2wv;15 z(%&MK#>}U8IVpsZxFUi>1vN%CK9y4;vQ5{u9w9|6dn6mz_dI$QXchV&&%2id_SK)& zneAJfPm6USsxz@!ZVp;$srOU$k@(j0w4j9;N!Dq;hcl?3iQGpCnn|t|?1WYle%RWy zSH&yaF0T#9e@v-IpeZ2z+$cm{-})W(0H10(Ee-IrPmgno>opR;Z9)pXqobH&|NfB7 z`cMOtqoe!0B#%ALFF!hQhza7EEOK=6_ih%4*Q?ucO{loh4AsvEIG9`u&>1UW?WpGOIwW{yh_=`IwlKdzkH|kc)uKJktX!PD z>d%ajr5uKl9oa!J4ByAqSvC2#b?p0d?{jzHoU8axJ8=EIU@P7iFVE!r)>|pXPft?$ zA&x)4fRrsIRSQ`-hT$~0n-w=#%x6G6R&4{u=O5h~@@HJmK6qOw+6s}%5;pjMOv9OK zcKnr^n)@_LOKG3Dsv5KCifkfZHisJpF6U4GzTV`q;f<%c#IXosv~A7LirBQ zxM{Hd5(k|MTY{}vAYRvYw#k(6>hjFKQ_4Pfote+gjl{6smX*zS)3oyE)uAfOsNcg$jvgA*(rsuBME|J@fE~kbpsT%ZQWZ zQde1Z={jE3k^RZK#W~*ix%lR8_%+2-m`~+%1T;nSxtQVib>6(fw+IsyQ_gZ8oAMl zd1{Y=7eUxdi<_{=@@VWrCNE#DsGb>UyK5H@*kenINjxenl#70UjtcxTm2CymY*^O)&#G4`GbdwY4~^xgXhw8x|& z6|G1L_)JvP4Rasz-{e8N83B6ZY4i+9v6HUaxEY~y0n{!S!Nq*~nO64cGhE3i7!aI* ze4b3Qt^(+OCVL$~ONC+W_>*CvldV+Do)S)1a}d>fR9Y@XJbTu94xjHoRWJYKBntrR z%traig8_G3`DbWn(Hb+SP3Fnj&Htz3HvJ#7j%k32_<+qR7R<*3Tj#@GWg+Kv)-{1? zEQgF+OQq~(nclcQLqIXIp@P+$pu)SJv6qoDtmXeZ1?|Z3yVtop@&z7|X+e$1pVMF` z$)oY;8R&UAB$!7?q19Y}7q^(zP(vNmwfF#DSxMBsFOM>-C=#3{IW+PTHTZE-HaP%$ z<{@Y2CX>qsV%8FBdAB8x48qvpN#@TalT||yXz}=&7otG-$i#@1!O3S=1l%duQ}GN! z0?jqKu!^KCdrq>2V4m)Ni1RHXZ71V+>sPS~G{wynaJ+G!??QW|4Y0@D2ml?aEbY_y zSN?{2CC`-^{S4lV3F+#Nz3b29uXz?IXVQtp@{QVC<91R_17Ey&Q;bTL=_aThbtp_W zsbo>gXnISFiQ(c-p9eSA5v3;GplDH|80mctEMAN+{4SJUL0?jzHxs7z)()vLo@7(} zmGJa_&t8&}?S$WvVjY!A$}_?M*TkK{p#5l%3xx`}bWG}|cXt*8B_0;qy8?9IMt-CB zs!8pJ*OkAnmvBo2M8!yHxzGA7o5Y{4@`B&0!Td3?B42h*Ia#q-YEVy-uNrB2hlpbT zul(RpCGhHdnkk#}6yFM4T!3AV%6H?9)lH@R%_h_Ey=hO1$ulo}W+TD*S;hRA3{kAP zK>Z3eUs;jFvnVp-C;aj*-cvAhldga$=t_z^xB#nP;*iyQX((drraUvLs21ZX9&I-m zuXnm9Chl0AP{1((W<``AB;(~7Hi4r8D>cML3bhChh*ZM?r@4fAGm;z=V%^PtuwuO7 zh&ao>qbBuqp8VZMDkXkKwORZdJ_1Cz3L>7M8{z(|ixv%rw{XGZgj)>&l&EWTW zr%-3I%PH<2A)R5RgjRw`Kbe7{fn*CK&jkbiW zOi`8NPcZe`g_JRBt8hMy-QOVO^Ve=*J;jx6Ui^Pz^9ogzhf@K{$5hr?y(V(1yb!M= zuySLXgFX7Jw?dFD$+k_(tWC6FLK6Ym*=0e)RO%)??_;hS;aNt=^J#o$ywQ3W6Q!Tj ze)ETMIE3BWa(Y6f^^mQEGx?JmppfY^3xP0&Ulsmnl8D&F^@$rkUQ?)MVmSsG`5DV7 zK1X_qs47G3_ud1{c<4a{+!ykasaK1bJyqdmg7W96+1=BzyYA--db+Bh35(-8z~YdS z_{f+;56mK)r#3Lb&78kh4!hgNxJ3WAZGD1J1wwE0{9|+ODdIDKcHcqU64J5xV;nL+ zVGI(g&qU^0wYHSR^p&oNT$EbH-W{9+e0QYcb}ThPjh!BjFY*2yb1HQmToqesC=bh9 zW=t~IawzI(wu%o=n|AB2-n@lOs~wBH9GiNZm1)xZ8B(bhQq?#t~qWGx35i2i@UW(7GuQ(|dp5tRvzka;v6gRY{^Z83ZDTqg+ zm@I2VEvX`W(G7g}EYD^_^kU=iJPVff9VP_$1ji899(!GFpZm+Kp zU%Sx23)>jqJr?ZCq66alF)r{8bQffm714gt9-}V+-SVp5!YbrcIgwK`wti!qP^h>( z+kFz~>9G&vP4X}xb6#t3#A{R$mxv7qEZZ2AfGJEAxG+|dtcJ!(sboM|eKt>VwIlm! zPAH@sE*;kb)A=3=9{$Q|Zbb2AqV)w9LuJFUr&f8?6110acgUoqiQ5-unAAPCO;JM8 z3v$ikyX?gXBt%Wd8N?-oE67PLQy%c20MCZckWNywf#z12ac1HigV_L~lOWe$5Q1@6d?Dgb3f2i;j7&1YYiymc^i>dnS%o!Tp z07T!9*(r-Ucs;u{0;iz zTU%TBdPE%84Gq7GdND^5WW2rF1mfBE;0Xh%yA_2(R2w)XD%@z7_;!6P#zcgkn-aRm zfV^xju?mRNu5j^9Coyys>-GfO0s(leihyn08KO%?mqhp}rOuuSIK~Dbj0%h`CNiSt z+vj$^M(hiJGzL}h$kvSF;S9cW(Q}@Wtlkc{CMzg**fC@%5q7z`CKZO5PZ!`;M7QrU zsQikD+PDA^bgG;0@zj%yznb8wuk|x4|ITGz^>Y|f0XufdLEQJRu|$CK6a5lLcih?1 z*ps7*?FI{IwX#bgJ^7^Er^b*Qlu(Rt=ls@ipU~0a$~fCe%;)o6Qj1FvYwJ;;F&X$# zD0Lo!cgahFB9bJf^NZmqylqUZqOro~nq(7xu)3XNnIf+;Rdw>b^9OW4xN1pf8w_`4yg4uBRXBfFLSE@o0b!enwy052^68wqx%i_MR7 zL*}#a-a5hMfiaNxJ)98iEwVv*zWLtfIDR*xP`0qeq`K}=COF)zkWEq4`i>cX#Svy4 z9LXKNxjW*2eH5CUtiD49fT-SrW6FdC88^bl6M^<9dUSzqAZG){xf zYq7&vzSp!*a6{D=NG3jyitzIIwGTL)zn2_sEm9=Z@RX2`QCm99J4X05gqE+R zu&*afRB|bUbjTS`0Z;!>_|jxB2_HnEywdPRe(+(*grmOvy@4=}F_pe!y=Nxx{qBAT zPg{x6r=Y|wE@NZm&G|&=%3AH6$QYy{SI_x$iBJ10lh=-^H;@9j5}3%lUc^^Q4COJ) z2s|+n+Y>;`A1m=}1vbiIC@qVX-+FhZlan(&p%RkRV;TqEr@`aSe?|{(*^4-r0+{;3 z@3am>{KDJ$=@0RM`GtCRK*@rOHj=V=x)VDwa#lNO!o5y9H+N8nV$8YOaHMm`Twbj_ zT&%rDJALM?m1pU_Q>oZlSYNOO=H2Pxs^suaZj%j{NJ~z^sT21V@UxIc&qYf!S!c9t z{bc5RJLmA$)y{#@viZmBeTD+8pYlntz~0rh3g&eB?(0f`M{zeDec#R9 z)aDldbBl9J^}>56 z8)zjw7~&g<(t+aD&Lq=%&#Q$V{_V+`pWeCZ*H-}8!$z+~q=i}wtD_H=X>{kR=JT6v zvl(Q1YT*3)KmT%+DvK3VsPwAce0n=1485^!FjKRITSi6DXeq`=YK|;mNcW4E)E6Q& zkprp*>H;Bs3I9)kC^%Ry@#M|(?LeR}-Cj1LCl+C_R_pnd`F+x)nD@UF?AeTGoC3-%U!#{WCS zr%A2O;x8UG7e5=9((O7@ORCep|Km=Ml6Dfg)len|9K=#X1{9f|g%=N+BnrVUia-iymNRDjx%RRb1QZ@54FJN)v=KY${lGWE|P9)ZP z_qv$dbLx(4i~Q$^6r?;|Yanl#wiN~=s7Lso=86AomxwW+e}hxNqx`m`f*M>&AbLLz zsu*qzPXe}oOS>3*)U*alYV6p0q@{kM;8wx(OcIH0eMl&zyRyXos6e-}Pst;eGSIzs zVc=pG2HXRz<6TJko95F5Fsk1ab+>)dO3&pc5%ByMnw!F9k>rJ39?5O*jZiY3G!9=S zhyWN9L_T90B34_AT*Y?$mdwA6KY5Xob~k>@g5rgJSKx;eXv&qja>R!r3*_82ri41D=U6PaKG;iU#-@-wlB^YD!v> z@8^5I9ZNMaqox3?{&3t;AIPO&TiH_=RXpX?hPza6i2rfg5-yTi$AE!ig2N{;E$?~xyN z@|SUrtU_+4E_Al6vc7{l7x%pPnZ+-C*a_6ShwIO9X+dMeP=@ zj*28HAe#9(_(_u*A#eSBjOR=^&O!Y?7Co8@+=5-%Ah zJT}fndgR6hdIdNENshNf(f3N>Q@${(*1 zWX3gy?wVN*H90-S%0?N9Lw?*z{BXJG)OM=jDU+TP1u~n>S1H3w13Sc135WSkJEl5W zut_EEU|RQiMG{_=S0T1W-qVv>v|wT%K!3O)Q(I+#nS+y90;SQCQnmD*lY84F>^|zm zHk~Crjdf3})%~d0ei{wN|5KI4?y2t^iKl2crks$GU*2)?n#u|){+gz%@yC{N<~ zP*!R0hZ~0eLT)@Ne=6M45v4MTR^_^;IK3iHqzm{?IV5czgZ3m%x#id*#&%8XJZbu)G(*9p7ZHLRsIy`5nJh#c6+i# z*iIqTjc_mL#p_<<%om2 zmF4iFx~wIUr2xJ5Ztc&^k4N$m#W7{t%+!)59bMFZ50Ou@uF^PxRTlCUtqy>=Z7jkQ9Z}HJF?}*h!t6FK(J{dBd1W&l{oh_KK##$-PUt?X1x4n zHvvE3Z_eYY8-rB?726b?`6{wsvWnHe1Vtq;V0nx- z@YDGnG=7@pOp#qq#K8240&~5RU949?d!g{vCq=LTa=efg{3ks^`3y2Sc~pr?%MpQZ zB431CA!By*6caK`x3jqLNnLzfC!{a=bSMG1w-7=IieR(j=sq^L=Ub=EfI zqIW#X8@OFiyV;_G_4XErUv1acHZfysJa7cjk)T3A7pz|Y^f@5~cis<5DjSjmw9QyA zQjEr-imHUs=eMdp2@+mpR;%Q0H!Lf$+r^vxqEGPy-D#`SZB~l`9!NO#?-F!bF##E_AM75;+N#EQnWX z`NNuOgYuzOZwwEVef5+8bJMRMTW~oRXeM`y&(VTQ5k;+77C`*DD6IS(rU;Kdnt*cA zF0kzPBXY>3tVbkgKV1|xQS1kNiO2#+8r>K)#&B6diwVW#OEv7Ny<+P}S@N7!kUO&8 z`AJQmX%)uyvFBy+KDRHlih)ePbtozoA#Qf?pB@zMClF4C1tCmPe}l55Jt=@P&80Ir zMK$qdA#nxzjC3rl?-T$}#oiv5^*EvkQ3V$DV_{|6P1DkLZTmelc5s0{7c(d4cZzi* z$M2QjLWU9055nq4rCH!}+eWo8%`njR$PUl(Non0vR#wnLqmd(pI%2?coE7l4P%JLU{?Is5*?%~E4q__W?^(D!pW89(tm4$?I^Rq8 ze@yZWgc%Uqrj}r;waewA@XHsm&_;^~+zeGl_K&JuRujpY9HD01P2$Uc$SN=Q4L~pNh*MCLzg5Ln~ z=QhDcq?Jiws!LbR+94$i?$_P|W8298ScFx}sv-DK1%Q?DT>$>5A(}g-hQjY5D*lKJ z`EGC%367Kaw?TR`+3CjkU&|#?E22=%abe=5qzLs7Xf{D_0YBmI2!w>+tlWKSh1c@2 z)GR1rn8c6S=a=|9vwpzAwEX+WB)lge{QXSExVCH)%$`Epae0dbHdnbYZwW+{|4($H zB7rrQUI6aLMWZDxlt0PU#9i*>iYNxOGOH>z!WZ9`10IxjaCahE_7ZGK>Y%&U)kCN4 zCnuQpxtic`!gSq?#MkRN*ZT-vu2sYJ#CJ{j#+KCQD9{1kiE#_cla5Jll%A-18;nbH z9@V6Yl{!?vs;P_5rMj@aVzdfi)-xvh&m)w|#8~HiACEjhWv0n%z1K|3`c6aN#gjy~ z84W?dQ;_hT!ecE^5LsO$+Vu5kvBu9yF1(VLJoWb1#ZWEd1->T6owLc8s8iHlxSQL2p$;ii=TW*$c!y!C1-9ZO&wFrS66E#p0Lvs|!b$a#xCiqN;u# z|6}^sOU(_r7$|;wD0BIl5^mfn&FaY%8=t?_(bw^VHB&yHg^O?)AWlCc!3U&d7e=|K z)}rIkb9#iAAYATuc5NFH(Iqx^4nO}7;vr&Z#iol9M&gNhTL>?-E&3jDf+xkk8pRDw zwv48$QoIFSF(6vK^%x^)FU+{<|pr z!-+}N^v)R;u-+n{sE5f)#OI;`+>>LBG7&v2BR}*d z9Zu}Y%2T}-50p8<7D=n@4vXi zAO0@DtQ2$tRqDw2BvQ$}2PmM!pr_rnk+0y{mxFQP7mYMxUExHdOodAQ z_F@Pheo!glv3UoY&)~ffaB)pa0Sn;!Ea(N+_|~10Bj4##@M$C|v(PvxgxEB9a!}{0 zM9PXC$_8Eiigs~--?5HL0--naQv#HEW{(0Ll|&!hrSY@q>rT{Tz0v+H8o~-00gZGi zK=cVA-ryL|zPmjGwvN#~Mn)wI`Ti*kT!_Fywf-suUBQr`H^KLArSSwnKY_ke%tUon z^i6GfS^*p*RE$m2!k-nGzm{NO_H${|B)IOvptv>}A6@YF5*7aQ>7#vhl0^t;rU2^R zglm-vO5blVKPQ7|jd@NKv|9H7NBaay1fxM<-s&&i?ms&B9q_~;GPAyPZaQ6~N-tc4 zLEhf^@;iQjY^*GN#})M2YH)W$9rW5{#zc{QL>fnF;lfVp%+_KWlMcR7E`~}A5L^fh zkOcD1Mfhj)eTYDIQ$$_rwhC^`u#D*0S^^@%W;`NX0X|g+Ex%2;K{twTih1^ZT+;DT z?4A~7sU;h2s~>?`1$m!KcZY3cO&c6YjqgSTp9?vrUMnJ4WnfiBvYD{oY~i8!d>!N9 zrh$qi_#XZAG^L%iLT|LZS9EQvy94ysA@~i3q2dH*3%tgTYV&`s?{2Ki6#q=Xam|Lg5b)3CRfl{$8@YEumj&hPn&#u3Tu&VAUm3u|s*&}#GeoV(z z3LGSdjl7jb%(<&=sFwW9i5=%C=ZSKI!)mp&9*S0*w~EKE(f$a>Jr;OB6h>t2ac}JD z=$NGO*r7>tD``7KgP!jP`f*Cd%H|)fH2OIAZ{b!3hsG0SuzJ+&c#4D?%$)G~7lrf5 z(5nW=F-^ML->N;P zGkW}~Xzo+=%WW%F=E>tyg83;|Z7$L8^!FsjI?ow5QDN1SzqTwVa*vM|_^F%_C{IH` z9=xoH>@hE*vyVQ@x97q@KC*j1F=4u|Rz=jK(RAk*TV%+O^8)CD`An+u5ge$XGQ%y> z{!^f49yE-8$$aPfBRXp2h+q^e9^g7$-Vk@cDQ`ax7+v^?(Oi zubNK0-?!Q!3|_)pfEKoYn4ML?P z7UG$}YTd12 z0jx;-9;JOqDNt-c>~a4h#k~r?WGhs2rGf)~)%c_7B70POn#c9Fr_jVkvZ-!`?mR-S z{visD5E1?ylYf@|M4s++n#9J>3&^swV*L?ulcr~Ib`pjih(jW8T)Qv+B7EuKe89Na zq&|eBWN}a;D*SnYOgXq2zy+k3EDmA`V=;d=3e`r+hwc~n; zZEd2vSu0Vj;_0g8JJ|4kBmT*mdu_f zElqLxOl2bFXB@U?7FdOURI#!>q>aYGtuJ;Fe2%}=yZib0%W3b|X(G6pj9#bv+^N3! z15f%^8dOjd)OUVr)Iig;XrByXUDpf3oykdh7=~^1-TtxuNP}0?MNNwC>w|MYe2Uj3 znt8wuJSi^0pvYQ^IW1aJeJbL()o``-Chp*;{9~&^!@%5+Dg5deOQ&@&Q{7gjdhkOs z;sAp~+#_}JH=OFAm5o2wfu}cL0niA0`14!c?DJ>diDbIOiG#!(Gn7m%YE#a|5l`Zd zd-p^vSzU?Ku7eQ~v2if#3)|hsQK$~AH~egk0}BYj_^oLuUef_Lk-BNGpI_Rmg;LI! zb&xO;&T<#rXLV%Z%+G%;rqQ{-MR5ts_PaX-(0TsneWt>=d|o2mORgEpwO8b)Et-BX zsjl4~M|kODhpUVE1G4ks-4qs`;S}{b*#{7;X^|KTrTAyJp}rD9`Oi1oSiy%~xL0;P zz6Tif(1b0;-@ucSid*EB#Z>p9D6zzY`tz&yJ^%ja-*{DKl;5M(PRvm_S;41+Em=R+ z%&qALEfw(Sb=%{S;P2u}6{L#;L^;c`N(U(wX?_6%ff$X6Kei@LL{>G_;qnuAW~#R^ ze}OOLebk=;oeK7o=nXuC0IrCsE>O}e;Pw0D1xcV6Z^l`I&p(bNh?a_Al_ZR>qU_2* zv6d)%ly$k|cLK8WS?W_U$-{7pV}>v3Fb!_Oy$0!4{V?R;*wLu-?%<|p=J!A+nYCkK z9_91@tEfESVj9@n*7ShhMQy;?4(pE9SuxV!&*_l=1WclC88#0Dz(`gfeHN=h=S0Bf{~jJnnwl&kE||R+d<>^Cy5ve-SBO z_^f!ZX8jLUKz+3%O2JkJ)0hO^#enj3M8!*u3!m(r&jU*vo7U2hLTAyBfqUodZ9%32 zWZd+~4T5LbGw5)XtS-CH2HDtJ;jg00q|M(vT){J5lTq(k60(ueE7XF>(etZkI0rJAg`%qiD{remARM(kt$J@dS z-PV0RAzcKVOuGB2Ifg**CRSlmsE{2IKu}T62H9kCRGinOLfY-v zxT=S&s2vhS$1M5W_rsGD&S#})$q61S-=VQV-4!9p8l>PTP14XmTV#Lvfp2_&3)9KR zFWo6V)#`0-jDVCB$_^i%R4#6150l@v{2FW{)Qv*< znC#CGNUl^@Qg5yuoF~#p_7Rv*7DqQt4%^-M@1iv0cqg@}8|ey75v51~ozFGTzc)!t z-O8k)0x9un3C24^wKH=$)Eubi>}QJL$M1TBaVel!^V5lvl_K4W-He~RBO0-q_!NKb0q%n>@tHBtqCE;`PJx7bX2q z1e@Iz9!z7qD>p>PSX4J^v0`EFp@rtrnbrhBAxT@!Q`d;(Lt0+WA2bcx5+1qfrgLzw z&xAa+74u8yXv(VN&55wgs;F>Jj)t2>#?I^;)j(d}H@33gUuMuvHTmIPIE7Oemp(0+ zpM+%_ic_y~iSsAexgw`FE2*=ZJ$tSPWC>NlQ1en04>(XWqwI^W#vIhxEVoOPXG;y! zyG=~O4!!fbq7`pyx$E2~{5YpFweJ{ByxFNmVt1ssjBsAoa;wqO+J*3NUURi4(S-l~ zgdIvTzf1b!ZJxAXD~sv4q2A0DR+JjYU)O7?8xIf zRzI(6-5#QNZn-leFikw7L^tlb?6E5!XfJsxstp>I!_*?y`&*lU=tEk{qm1}L50{D% zD`*Y6-mv5)PzE0v6`}#6z@7iSlbcdwYYYXQkr0o5TXkEqg?W%of=0%F&3Kl>{^Wm+X39^kS&ZcmM5r*CUqD^L0eeExGZ_MV<7`S zE8W2nftRFe@IM1{Ua>0Itau<;W=7gmv81tQ4b)E5Z`xk;40ur6Fj$R{Kw^26U4(%|EmJ5e~_T4j@QjH8-~LwbO2 zUfzVO66h<9H5YJc?P29Vm$Mb_PtSZBxL)=K=E)KUai7n>2PUDMa+eq?sA!aQa_adE zE}|ETG4>57?dWYPv5G<|3RIg7N#=vW+>w_$gp1wmW$|Z4ZtMojdi74j;$qNOzOu0G zoa6=f1DYfQjxoeeJMn$@s-aXA&0Qii5JB;M=3`-_bKPyyPo3mOyS1=AQ)rAA<5l!ad9hs8&oCC!lusrAEHZmz{I45BNu@Di>GMobCslzrn>lj zr3fDTWsBM=*`_#lFLA5po%bX)@71V2FxjrgMk~LMa!Rffq|z5In8b+Aw1kz9CVNL7 zb>iCd&Z?{>>@u;T#0M|cMRmM~c^}xU=}ZVUypXc9IF!lPHTE{k z|DJK7aOz<2=^Y;6erX2rwM)5Jg_STHG|twk>>fSYV9)uT$D_#< zzVGhEVxMc8U{YdwPnxrDDW8>6>-3%*bJBjkj&Yn6!IGSFvR7u$IE1^18}0?_$8%c8 zDo@_O&k6+Ri*|gy`n`?$xD(I339ux8>;tuf&2ioqPUMUD^KBy&kr1|a17+dbv4Dps zVf^glwWu;nMNzhn9OkY8aA9KrkA=@yfm*;cRgKYqI=~-E@C`XhvcIp?qKuxF*v;w z@q?^_mgFsHauUgfSJ=Ty{8IfEp&Kr$kDiHYSTDQ0&OiQHofx{cp3Y`b+_EAS=P|dA zIN8bN=tyoOkoxKVQ2=p-u|&$iyCkZCdu_DUh+lnaqhxz2t?GN(!-by`zHkFHRgP`H z1+YfJz#5!s#m3_XapyjGpCIwHCt)FeRJiQQnyjDLJf7}{aziEXroK|)FR{HiXko}M zP4F$TP48t+PThL&$d5td z+4H~u^B*|6-{u$>FRm`}Z5q_Wo#ONoVG{&5MHrQ~FeRytC|eAov;ADL%z!stc0&v@ zM+^RBg>kW6UM3xm_Fb%<3q($D3438pWVW=c;?OYi0(YyQwgsk_P^c?qy1S$pz+?CR zeW{uSVoXgWOWMb7LN2zF?<%HsP<#pQ^Y2IM=kI-{WkxFAS@e5Xlft)cz8$kFDX3hT zX-p#Om*egoU+vYi!+t$_7S>fUJyn+Ox*&D%wZhq--{(Wmz-r>gs>x|z5IRW7@mmFr zCk9HTT{UVxszFTFm(Sv2$3@3HuT&OjtiFe8-~a$Gzez+vR7i>ek9b>fM_^!uL3A}b zgKPxQL*Lqx@+{3JRi7zjB2H(<7o@iFkm6qFQ$@~5I%@koH>PR^ckb?<)mb#@RLb9w zS1-D`u;uDSDp?*_F{=)AR5fGN1dso?IiriDAhm&($M-{f)AcQ>#tf$XqzZGG3>!l) z)aM;}D!>F`U7ro?{pdYYqx&_Vllq2}c#F3|@8r(gPG}oGOLWwQK%{`B#|7^aYqkmU z?f@Pd`ZuE;kFbjMs5#bWhRxx?)ADBNzIkH1*! zJ=&}AS|RoP&l~Se*57oDp{WKEp2U0yS4|i9pO1^QkZhChl6Va(OSZrq#S;6t@*i@t zV<&o$MhOf*AGXO21OqV0rpt}MmI|fo%XaTvz5T6;Uj%e5f}@|fCh}|U#@4!4q25t3!^XK zZ9GAtsjPxxz%*`01_o3uD1CsY0lFaQD&K2QmzTowOf=>SV7~xNg(ipCH2w8>W)?{N z-n;kUz>PN%C49-8HutI21X1m>3oZ|?#`@7~48N@kxA&#~O4I;;&MZLK7*r$nwhGe$ z%FQwY@IGvue64*XxUuc3dUq%wfYy0$P&mi25U4*SU8}j<#dwWzsx#c=#^eO2@TIi9 z6aXo{iEmuAl~g~WH}lw@>5*+TNh$_^*69B6g)z zFO7y~pVs_ceEA;d_vNl~^xsnqzGrJ=U~3;)s;IHU_)cpC=`4VICBitgkLr%iRVn{N zs^#nnYBnBvEsYOsCyJ}q@@OiuWDuT5T^}3ssA#n8njH^iu16Fn(I41CyT$%Qa8_9Zqe3YK1 z((O^GC_k6-l&y(ah6~0pHR}~mtX_rRr>0^~ot=`>MP@kq^nM^BTFqd8C#!sCYc;Et z+mdhP=1JWb0}7r=_`9aUU=3xD>aq{7^Oyu+kBXkQB|K-*&FS8_MsZARLq#>4V%PF* zio&p|(kAcl2!LP`Uw?lXr)=*y`aE;4$UdHvj##WBm`NNomY0o&r@6`mq*Sx1E3k)* zH9CLJy*#J>IddH^9)q|Mt@YFo)zn$Ipc?Z64m#JVgmscV*{5pH->ewToWNS%Tk5S5y4(0I*AJ#>M-#cT&s6-*;M4NtZ!H?G>^^l4zO-?~5kMa2 zR(>1*ICfg_5R5qcpNbc;Dbx463VIQWi3bZ$(m-phxb^Pu$U0T{8J8EVWC=pMC3&yg z7D}QrK?E3G$wHp*Z`dIDAUj()zlxYG*1gPQ+hjoEr{YLaLI&5!^V)ZK8v4TwEq3;2 zTR0`Iq=+Bq^7$85C^R#`SK6(oIBWi^UF(&&qc0P8e3uh^b-fT-wo^5OPsFLn8^xQA z8#mZsw*J18hSl_oU3uP}M_~R=w9c3(xX-=PZa6^vsdBFIA8SVm5gM^`cF`-83k*dr z_OWmXD@>*zZ#m^mtnqmMR0lafiC;L0$(~Gw78V0(){b+REo}H0%)9Ux`}tJ5y4Wc3gd(4?UGTUeo_f7g$H<6GI9zyP9rf>bM?m1E1c86iYn-SQNJ zfm#W?=)!~qIZJ$6!TN=q=BF4dimo?_1MV!EAPO;PxLPKR{gsNJzc^~+rIrScWiU0s zdYg?!__7-K=m$pn!TGgTV!`2uUzOR3ki(@-Xvz=uBW+fZ|6-9~vy#47# zJ{;t^ETD9-m1kl6&Hc3Y-O~rj1vdY4l?LuURcd5gb9fxpmMLB^Q*CflByoEOEsZRm zw5p(Dl|wHHQb;FvpPqtwX*$%JGpJkEUY9?BxNyO@5M?Z~jw%w0Dr%BUO z8)s+EdSGgj=TzhV`II{Od5%Whdt6v!8^y|bS;#uFCGmuiVxBQgfz4D)Fx%Kdam~nZ zG`{UAKLT;a`|-HtRSao2Ek$(v`3QJ#c^fILcD?xFmssI=s!4%zk>pq>-QuXIz+_ar zZ)w=Z2zijEl41?Y-+gdf_JLwqTKLFH690Y7X!-1;jxp=5i3KG73LM9R!Oa!DlkX-+ z!OflJL6O}Jc*r2*M^6ulKusf8|IF4R4P!ss8}fV|CAr4v51P0KAkXG|ckfEPqVld( ztTyDcDR3Jbx=m(Q(G576^J)5Iz99iwo~lR!fE7tuJU2ic6*U_PL+XtFax8HQbG&0?^vXGi&sT#GWs$B>w9;u{ndH=>*2e0fXkT08KcKnsv$X=zf1ODxTQre#+1&(5%YNJ zD*_LR|0I$C3gcy;ei+K(+hLW^Amcs^>fI*eOLkIjjwAXIGfqKbV@np2b=MPhc(7dY zdvS&Cb3VH`)gvzBSs+<(vt%x+e`(T>u;<83ID2Ed_ey8dK%B>bc-rb$0EHj94eSI# z20wy39?Ly6@Ov6%X&xz;nbZP5b9bvgM?BU&k!6Xu#aO!x*bjPw3+c#Xk$~`#absCP zw2gUBWcd7hVdX6m;pGWq@j}LK@0pb-p+#=6`MJ9-*d#k4UY*a}^tfsmWCB$AfsG$w zpwkgYv5~C*UPj}c?`ePMvURFz*qt7gNXlpV1Lpj;Mr_$`=u2Kb&pw0sqshK;jQ6wD zLU1KC=ZqVSy?=iBBTYdVTMAzv;k`LJE9JR2o}Y&Areiwt-Ho$j7a0ppHRgvuw=SRQ z-Rq-kUC+HJgEoDR-a5(eO7ZM!cNYJgVtYF#=*#zqnV&=)Cs^ywgg{Qbf<;dy%UQ)Z z*PX+<!+5|cCdCF^JA%;Fn zreiCINBxG%PO-VWI2f`pG=|~3{;(P2BrazvJkwh%0`mWd9=TWWIk!m=#h_808W#)Q z8)}C%VHn}Ga*yM9t(Y*=ZF+uo?&tx|fB*NtTY#xhwTi%^_*MbqCPjdUND#v}cR^QA zI3aIBGkl>Fkp&Zg9{3jfL6q>r76E2E(IhfeGg?e_Zdi|e*isTlwxRF$gc=F1^b5Zb zJXV4g4!f6t8I2?lDsyIi{7!qr7DU;{sMzlwbRT<7%!blZ~F-6C%ua3Xbz zy{=k^)5M}32r7p|Z>HRdgo+?3jZjgV5eW7YY))jezr&7y2@LktogGEZ1h0b|fSMCR zIENHoJv%8x9(|o&Eq}iQw2Qb~3&uE7^eON;fQ6~j=4?-5EJ>QGJ&l9~r421|6)9}! zYoGM7H?}^5t$j>tw9aZh?+6NzP}1q2z?%sKuzPCdjR92Y9=YM=)8@$%4h$%Ow`?m4 zDa`!)OjJ~H#G740M72cNxA)PDP3F5Hu3R-%map)Ec~oeUAnv0KLl)KLk#|K9QU5r)7J2nVe-HWN9+;HV$M;MPM_EicEyWWriY{a^ z3}&QmK}coCYpXWq&8hAD)5&QJMVdA$7n7S?{hl2E8(Na(g|~WM{S?3aEEc z^5XBx#KO$wT`?%D-NVucT&~y~w`ar2gDDQOkj#YDQ_PpihX)8-9m@S2jV!dw`Pu0N z$FudgC|F)a>odNWQSKwa5`cV*?@=@~v7wJ-TZGbCha2o=Wm2y<;vg}0^ygawhQ7Ux zk8&Y_j3=ikQ24!4G)`IDUICx2qSfk|qe9`f!#3l|?b%|{q@9)u?oNsu9COv2@Nz9T z0Z7KJmEQW^cACc*Ez(BnxaYkCpM(j*BATR1#L@Zfa^uWO^L_5{jN}5)lq}rI*X4A zB1Bm@c5&_3&-fgV_`tY&}4hY?p=`bNO<=8J@z9I zsKI%A+<`+FSr9CE#?-dul(6S>qf@EjyinF=r_+nUf1urN4)j9 zXJt}5T7@ha0z7&B_^(^t_*tc-vGie6<*4{{liLkklZaNodFrwB%Z`(eF@=`9+Ahw^ z4jU5ps1bZd%eh3DIKGYwb9f!ANz|@Y!zVA!U-btY7gzafV*BBR<2({1plLN>L5}l| z6|7EXB%4}GmR(Ez`uPk1>;a!?QpnE7#H448&&17q#6>_Unx5NaJNg-&60~MVc$N zhJ8>K|68VVMfS|dW=(aHn%%}DRo>r3nUjZZ=hJ6DYPz|pt~_W#n4ekIHvKc%Xbi15 zWScw_El8TMEuF~9X~i5h%4A{VI8Z}@$yc&2a_%*5fxf3i2~%3oXVTiLeUU$tI=q7) z_gouKTEWg7H1PN2-95&#)vJ0ha2e`Plb2y{#O2g^ewi%y+^|xu)CE})BHV?~bm|G+ zfh_kkfl!@4H{Ko5hvc&q-I$%=9bqbB9`C5oeE@K}>2vxt3Nl)=SJ8 zzBT>ehJO{R{vX&S)%g%Pk6Y4}A(R`loslunm*p=<3 z4WT}9O(UY7p8SWldU|J!pT>#i4MruLn(=7>v!1Xj>gU=@jiE8lZerP!_jq$(jw{zP z*3~=GyK`tP{FD4%C0m*6+=JkvMyUby*vL4in)FaU{?r_Y>PgmfgVTrk8>8?$58r|a z30&uwle=D82_$&BdsH{KgJ45qOXpYegMUqt>s7aK$4%3=#m#t!2k~p-kK#VXr$_N! z4T|@kYf=FAweME*@&9mh5uUmE&J1VK^bc#r1h{!2M-4Z;Bv|`&e=SDv?mA`Abw zM7ih}^*uk=6mb6gpZ{>7fRh-c+B9fNfw94_QB((7)pyt5*Ik%8?#vcOi%U(|+D?O= z94mRY3~^_`1%$`WEC)6)%y}X6g9>X4+ro*6>kaykg1rTD+{qjiyC)ul=|?S?)44<@ z{f9POdjx-Uky_s1=v9f@-PI~?E0afH%H7^_v%r$?`cQL_@z=J`lGHvTdQI4i0pmRz zt3g`Arp{&L*wGTRpOs0)pKHJ65V=keu%hN9QAXhe;2yzG{e5?Q>aXu=%v4FLJt{(d zfdK|VkvQqPw$z;ar=H7R$W~=30jdW0ysXj6SO%pL0$HE-jc;S}tBrp5 zWTGX>ghzpEAVa)$vu)Y;!rgQS06&z`W*OVDw3KxlN|&w6Ht}?~eL|3(1i)~lXLN2y zz5lW!bz%B@g7Sh}E4lD9VDOfzNkfc;hn=sKh|446ewHrYM(<3@ClMGPF+Uz*^Y<+m z>Ju>4#+L>%P9hJuyGlYCA5)ScfwHluq`qUa+4y3R3KgskZnx$c(cE)YMvw`FI>dIo zn0?1}E(*Ec*e5u;E3`0j+?}?HLnMRZ*S?>T+DS<@N?C+xIR=PL06_Jf0KDRIVz9wq z?ei_%oL}1q)wK4E5_IzCUtkX3p?$p-Q&9)(WLh`$t`^F_^esQ1a`@qA@PCo*M+wht;mvW#RCOp$ zu{F|AzSGQ)Y2sL+{8;rV?4f>vf;w!8IgPTRj$oxE=OoHx6`80kx_=d~b zM}-cr@lnk(w6oJF=i)mT(1U$YPtHP1V!uQe22^&HpZnwsJ3mwOAx!1mcHV=t`5Kwn z`y<6FGKF`0wz*v-!w+_XVmxu6JJxQlxq*VB;G{0*9O1K@DYE*D0D`Pyw4^gjnAUgR zQ>?3ieD0DEOP0ifm+*`VOR)v}KKHD+D93EmB#WsA949}MT^P7pO6R3&QN#rusR>`G z`LaxLzEyS=NR+0zT%)NX#DDV^q>|KoHM_33)2v}Ct|5neiU$C%*X3vsnDjK8}~<9!7MRqY{6u=t42j)4;P9 zA+9~(y2%zHL1nrdZg7^Arg%jR{`qReYvgr8qU_nYKvdjSjxxfFUL4Er7rfK#L=|my zC+lAl9(+gl%|99IC!V8XakiNW*Z-YKKjW`btg+8N_nR58OF4Ojfn@=@9@L8EZA_-W zc1)NF$0(-ui@{QB73v>PgV2Y(PlpE>sW3fZSDq{p8Q#tP6-N!Y@&t2Yh62i`rf18F z&16j55=*Sn{~^($vYe8I+eP*fc88>Oz23A3(BHihHa)rb!`{vMKMmBetssA%OA_N< zbuKf3yQ$B3gn9NWtU6uaf$xS>Qv5E1bHRN~RoWH};5V_Pa*X)R!6)+ElkTH9qo}Q> z0DpeGm8&)R1d?Zp39))T;Do*=LQ42O)~(LYJ%Io$p?q`MxWuD**edA>DUYcXD1ZQnHUF_ z6#xEbj+39VXMb`<;JNB@GjyF1=poJ;VxEjr_PceQwYU?|B>lub*3Io);^*4g zTo&(@Vfi0S1SoTM;*J7gO&X){hpS}SP|I?*3U0koeRCI&o3G?86u;P|&6sXwO5KwJ zm8pW`0)HfS+#^pNIuc?sHod z+1SS0+cX(tKbL^~o!8A4iD@~l9QIH3TI2lpfB!W;mr6s)@ZLvx`H($99JB1dyRJa*&Gw7Mpb-{2V@E~`#6YF~(laY^Cg#Y--d z!oL}Gn;7>P2|R|W?t-6tMpgI&vTVr(tvVX2KlStcBInu0ylO%hh9RAMmA3N|hDPvy zKMLM1EFhJ9_XeAhDmGo6+C$|rB5#a0sRE6|3o3|A0Wgg^A14)5L>oO*q$tIp0!S6u z#nOAX_gq?-%ZjEaVq&w}Y620n*uaz`6%HI*B#kXo3~~jgeKFD`sAqXdQvDKVR?B&u zWEBlJ|IUO0{$NSTdcM1H+I{R@3}T0^78e023PjklG4)B!W&p3|2`0;Av=)NN*MVHB z!o&iA%`T7kJqk@I0M?nuN8ZW}6*=`z18Yp$3XwTdWhuB7edQZ?JOXuR&AIB58Q-rKc;151ih|c>%I&+O_%wrE)-#G- zPJW7iiG@!3ShC!HbEy_Xa?NgA$KdvlDso)CKL#^zrFQ%^@S=lYrMv6KoISWx%-jkw z@6Qzlg1YRZF|LBWH<7XWxuZq89O3ekE9ZoaKI$Fz=yQquv%=4rrEO)Shh4HH@HujG zpp9-n=PJdcuTuUh*rnOPhF*zi{$nfZ0Ko!qz7L#oQZc36g)WV-Z>}2ww=~(k(2cW( z0U|EG8uX5yTj-A3PrquteMlZy0dQ&;mqi7wJZK+O#_kxb zZUc4|2|V$YXvXtBEj6w&iRq!8h%%r@k%->*oEBk0#iW7sHAvkF!q|~mG2_5fEoH15 zL?Stb`5F}*;i)6c+N~8vLWDdn9W%4&Sja~Xx1IQ+qKgB@a*+_3U zYQI0=_ZC36zqx%q%l!cP%3cdNZsGn&iu|hVqQVkMjiM61Y!zwtpzIpdr)JIv^lzw$ zv_fANOn&B(e^{~ql|Vfk5~qPLwjoPo(0-+Zd!EfxBI1yLUurN>X=CzZa?*_A0L3&Z z#-l;0j>{Ze*hh`#rqb2>^d15gQYMzceL6F|YtA3d7Nu+?_!)i$S^OARnJV?YRE&0B z^gGSD<=^W*_*K!4;sCqbgwHP)9g4fY4{b}Cs^H<^?91~~)xG;%+ z@owhGQ~6?v1q-WmB$TT}R$~>lUCwU|0ITfgv$aS3Xjx(DXBi8(CTFW$6WW%A=fh-6 zUH$yNsns+n7T;5zA5Ua<6lQ#+J85g0hPb>%zR;%Uj>#dNm9PG~AFueyHRi3#yXL!m z;%%%1oOicJ>0FdqT-RbXiSHKMRNJ!8xS!|fh>$oU3f$q!|L6P*T87lfXktyUJ6JNw-rtYCX4 zc!{-&7d96xF34ZmR4gsf5rK5wCsMPRzgNw$V`0{HV2V}Vt6nc~*F}GBOp2scG0;9N z3Uap4Q?SC|5Bdln>W!J$E1%yVVURHnVd}(pd7j3v1yJE7uH-XHsw)cfyVrDS>HI4e zaY?92bYt|p6OwKI!}sj}kd&$9HM7G@r`(|Y^w{GBL&0!f%_01W2$H3tI2U0O+ew%l zv=*QT_!J+w*JOa!RHb6bxGo%jCpN)20Y)ywc94!?u8HgV{%Gnc(~lNVE*Cae(~8u)8sp|hUysvlE;r{_#rQj$XfR*Pngy!y zl~+wH=|XwhhZcp#*ZKn%#+ttpK3+J-!0+E8>@d|Yv&bFd$s@#kj{V%R-pbdjL6n5e@j^I%v7nqOQ zqUtHgOB~F$4t<+#ArvyW;6zpWemVe8lfYo%7X8^Apa?oOVk?<|$0O6N_W~(}5r0I? zl6LWGY$~v;WdUH)#_vv`&PBhZA_Ap%3kr9W9<*Z*ymZ#aXX^h~)fp{Ga;z{E$o8}E z|9|ULav#tUX-7C>9p0VouF3=F*!9Kw*MB*#Z`L3NXOcjAi5O9y8V|{_^XQ+V=>jFbf0*6QE zP^rv!D=H6362iWkw*WOdQVKdoq5&y(3}mLe$vC-`C2BGC8Blj*$29jncP73>1J#qk zA|m?4=~2+#M;($P{XJQrLTmCCmI+c1eGx6S35}p38Da~mJZq;CT23U;HsKCcBSAlX z4qN2p5P3K1oQU|8T({Y_J13MpRODLu?Y5afZ|5Z054=8#*!goBQ52BMf>cpxK55YC zcdhT-xx|}QXi^oH5byw)a&bDz@d5iP$XGy^J(#`D)j}tIE)kqpg-D%pQX+*+JU`@M z#b*JaWY@s_TW7lXos1&~0aNEyGZiUv=Nzk6rw~A?+g{E&?_e8#?dFq89_&SQen!NR zlOIE#e^zJmIdvYr@Og{bCBOv&?%dBIdPM|hN5wy9tFwHXfa!+k7l1ISr%`^HB%OCt z3{)O9%$$$ZjQSl-{17u#JYOm9rS9Fur`Qn$Fm2xHk&-0Wz9%3f)gWlni(>ptDKOX! zt+6WPqvCi9iErZ##Ygjg%FT=+d3%N2B9hm(joUVAr1{mcFJy^{XRJI>QX~!Q@B*WW zAtHNqw+uclF8EF1RyS_W(#^W5T^o-gP&ekQzxc%o_sL{4*J@}$p!8E@pmgk$OhyJD zwrlV2r67wAZPQY5lHNC9yH{%?z z93VVY1nk1s`C5+&VW;+d%ul^iI2lCWDTFyE^Y=ki%9jz+KuzQo7nGZJDCx<~XgG#& zpXOMKkXw!yG|xPu8YNPu#?`c@CoJ#6zK*!HpGVMZZb<38cnRW?#y3;y?B3^lYOMmj zJRC|V0e>&GRvAw|h$py1FfO`osJl}B07$zY% zrY*Cyu)bPK%Mf-H!23KUp_twxV?_|+XtaP3;;K9aXPc&=Av0SIQZ-}*%{H1dA~Z^b zOqA^_d3Ig~+%#O%HU!PC27IRTNNmwTPcN`CS~s)bI9A+V#UAXW?Mk&b7oZBakcQ zTalN_Yb+3+2|T?=)v_mMI(XvMl3x&F2#65H%yi@=R_>XrjqYiJXRkm-ry7NNs*cOT zT2psc@BcGlccVKqf5Mrz0IO~EOFVUyD=*WJCRk}cgbC9utT9j%PF%tM%XN^j$DEIC z3}SuYUH}c>dsj%I`x?S3Q!kvEyig-?Cst`<2-{FIgx26fzG!OZVpl0ld{vlx#Bc!Ag1th!)ew_;m^vMvrt0j}F?o;WDMb^MoN?ZmrUz*9b3pvt#_Aiy&0KO-)jqS%9^Ih z(}(~ z@CzK&KkZBH0$F6?aMFOo1^>~ZFDa_%0 zsNN|EtZHi-1QS4RUR{#)s`S(VAWjz~BDOd+J0_(r%2T?_HDhlxA~w}S>wuNV9ZBXB z=ofH6v@1xT6D&k1DSY`Xm+?_O!NdF310g84o=qN8e=4Z-zWPqHq9D(y4thZ#g+Gl0 z3Kz~{#B3;k!2O3BP9JL2BJLwQ)u4R+kH=s81S?S~7(fIuY7dP^hJNAQwH5w@5 zuqD;$);tcxl8}7WD(NG8{JkNw2_jO$OhQ>@6ve^xYQF!R%NZeym96Wnj6YP!lBBlF zt!14amJ_NN!c(A;%FoG1?6RKfRY%^u_#g!n)+bhrO)I= zF|nQ2Id^x-$Xs<*X=(zm(dK?D*yhFGogxJgTk6$ury<}pK>QE^nycLBs6{1k=G~M=4fAMO>D%PXZP=-T4QG>N zszPLP@=T_K-73iE^T}dNBo^ls62cZ6D5HkT*Rtz*XP*kXiXmEu$fH>zl}Jrb-2hAX zn#E>>OxtUiEj;@ORe0T~;Ua6BVKlw2Kvz`k_IaJi!Xih@tj0NpyP{{3B0yYChRLcB z@iNNb0h@_$ebT(e(kZNjp~hU-IOP$VcD=7vQB#Cq2Qt5c^hr}yLWO#`OQiaYlUD&z z^EqcBpQh|8^{&W& zpX0;lM2&Z0qK?T~4qb;rQRz43fB#I^c8=1yMHZm`LTMLq)z8)UP=kK3n#y7|d6}}C zum9u^Z1Zj!2>UT@!?9{J({TdSR2xGVJ}&8FE~b z0*hwv0uu>fbgoK;jV&z{T<#enZ_dV=fXwlER|&7kXF~3^M>fc00u%%T_cDAphExJ8 z5u-$?APNa`mn?T0G8Iukcn3yiP4ik<{PedCmRb@ZvCRYf@^LHdUCN{m7-$s#N0_nc zJzI4)){(zahdy`!(Z#&KRoUfJNN23DrtB|V{|SPrI3V`Kf|pX>bC)LvYla%DRwy!c zJhD$!Rk*J!5O`9QC1c_LrlZ=j4B6d`!kto3g4K>ICINYq!gP03c5Ut4GD4AzI9soT9t*z36-QWx_)ZYP?qnO@`7}w#ANv!IyD9;TZ93dj`_y!B45zZ0;L-WWI7R_89NC3-aYbA5ndCFD3@JJ`O_ zM+EX0!ax1^s|UoELP-U?&bm+JY4d#4o+m=ntrhis+IOe(ltZR|_gF`?Q((PVT_PwB z`&Ion&zxtQ!(o;I+r+5kJad+L1|;$}uAiKB9$YnC82MrWq8fF*Sj|GtWVXZximKP< zOwr66A{;0AGCxF3c=^t*>8P!0mb=rWX>6Y|u0$w&e^1Z{wp-Utk8!Msi1_9n7tZQu z@Oi+0EH5#Sg!$Gq{;30}cmrFPND`D8#MFdwT`?|>ZKdGqK`SHK+TL1t6 M07*qoM6N<$f*QS>2mk;8 literal 0 HcmV?d00001 diff --git a/docs/static/favicon.ico b/docs/static/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..5b119e80889c0db8a652680f55f008378a7be3ba GIT binary patch literal 4151 zcmaJ^WmMGNxBd+v(k0R@0xBgAF?5Uq1Ja!W(wzt000Ew15~8Ijd1|vcmN>wztP=)^DhJdpmb9c z=J+?~BL)D<+W-)&rJ+nt!bEaYC0A8}>fG#9H;a^r@W%VCkV60fG^q+z(1U+KCCNDG zYBNMFduzC<@43b$gK0z<6DK$nQ)q6J4yX#lwmlq%8%RjP-pcuYw~_zM<)#B2GoV$A zCu)^gA86Duy&Ej-6GKcyc#D`u___L?429?nr{4i1=Je{v1w4fOCEA!L!s92q$5$!H zX8J2ux1QxrsxZ8+@RpYFjE`ngDZ^`KKwd;1jA-t&5b9f58=8`L*mli$SueulYi8<% ztTf`db@3OzC z?drJr==%nQC%Nv{Bsx+t3f^u=n@CD}oh!3s`P7 zJS>9;8FF{ot3;>W@Va(8Zm*!uHD!*h{6QgMrgHU9>aoXu7)*&yne_Jd+l9@oXg}(5 z3H$7pmmj>Lh1#|#fh^^v>%t6Ll3QFTAApadrj&{V;2$nHyF}nHf5<5`$_zt~S;TL~ z45&WUfL1HM2>TCU;J9hu{Ra%ZBRg9FK#=k;7U-JIyjXXknhZw@eV))*W0f!<31$-hw z7xdyqsdcNLYlNU-IDOnQ(4n-{5Ih1xv&x2cLY5#PjDw)4sNmC>qbS|e zB>a%)%n@0y+teJa>ytXsPNIvQ-t?kEV(dH-UDmZ8-@@-GP#Gx_r3;R98W|X9*egTH zw?WQzlB>_QSg>)TWoqw01pxJdM2*B#RnQ9%M{jCtxni(*h*&^3ZZHaapS`$M?%^nTDJY5hiXb$0 zaIlu&+S*!C{Nw!o>1LJ*L@s#u)7I2B&6U$*C>23taq)nmQL`w0qL3ThkO6JpQ7su% zS6AbmSK?G`GX7OVf4d~QAeHh06Q-E7Bz?&zwT#%K;QPI;N+ofTj(KbDG)ZqTEt>s{J+06gZ(W(9FnjmvMr6kUG zN$&5j?%o(ZZzd+Gxeg_z_@YEA-;+@M+k#X;X=$mJo_>y#CkiqTXE6GG#S^o+?&>Jva z`P9W4FQ}?50&V}5gGVe~GDkx-U#mu=#0E3vbQOjl(%LF{f7lCQobI{d*8!FQ_hqTa z9tYW%;J)u7oMe7iZMnwH)e3@lCfM&)N1TLSOLTuIXm@h987TeIPIosFF&Lw{$=D_u z{Gn0!Vf?Dg zQgeEyGf3_|D4dh@cvP2tULr_${bwJgpx_6}H{q&onnl3qHdzz2F_( zXSuoMa)y1Iy$WfJX$?pR3xS;L!$7OQ&0Z6Rs_OV!Gwbj;F~K z#OCyFxaz-gnea`U;~y^5o4jBF03zJ~ahajBPs$qWUl|;#CEaW;^*A}X-qBHaj*vt| zo>_qe!7}eDrG1+udvK&G8{Nu!ETR1AcFy$kjS#P{2YX%5S__-CR}0ee)(i$vi7=rt zu_{;Bl=|mcsS8W?>?+MFpv<6I$kl7asQ=%L<-doQxqtE1t!YyJU7jxBSNH<|K`XRb^9h2=h-SsR$|w z7K#%)S+{2)pu{g;>xBvWLO}lqtuD*4@wt=3ajY`syo=a+wjNg*#^+!H)k4@i$`J3{ zUwAMulI={1M`YIR-Q#2?9#ZtP4QF9spks|djITUBU0wa97pK8{ettVot4uNi4*$M2 zRWV32)w1TL3nS(v5b8Ly<6(}?IVSf9M}8}@iE3f#aCwd<`MWgG`1K9k;+B4`;0x{>L z9lEv&#s++^HXp{z<2_-A^G7PCq@_H$?(rUt%>7sv%l3EFGiTQ9I(ua$nI}gh!?9`p zR`!S(=W>Ooc8oD5sH42VTEpJBER*Swq{k~{>#22Cm5#2OBg7mrFKv=P`d1b(3MIzR z1Mk~^DB(T0qoh-hL>)3dfjsJ&L+(oGAi#XK_S!~ybK)yui5z%ikM z7NC-yHQOD6WR;j-5zu%pQ>|4dYY#1ug^b3Q2mc<9fj+$WiciTOOf0`(U2BG!qk9{P zA9BHNrtN(Z20LFrpWE*=Z@Xn

mbEFj(c*J#n(LI)`@i`tuT>${i=VtS$xU6Bmm! zGwh@n6x0`u$)u&B2KdeYbOqU8M$%ix@|!fjuQoeNxd?qLfYfV+_Bb`vX_P#%tL5*^ z(K2Dr*MBuh7MTL2TY=5WzOZ(M+!HQjChd=fdGdnL2Hel&?ZyZj;q zgiKVl^@C~*u+slWzvH9wXiyiSu=AaB zXV8pL!j@WIYVyQpF{S;ghUxi{DCVswI53QQS$KnyNxFF#XNpsaA!Y%L`02iH`V6EF z)vslmxCWU91RVcNdjxrn3^g!%INniVq5QzsxJExSbJq6OK%jOO%>QKdHtuRWC@P{` zIImXX+wlwEMhjIWD&!DEQw>aHEOtiqtm zq|SCYeUTzMd=2Q@^w9zK&jMd1yn8qHf-k0e&uw*m>pf{61L>{j333+Rm3etxW)dA# zSS z@InDc+%I`|P0Cxh(uQsI0l$x?P4S7)iyJYeYav_F(%xQ4Am2W}ILvTFF5!E~ZDmaH zN?$+U;rtjLgtTDTr?}UaANumt*V8kJNMu=<+j#cZAv}>QsV`eI=h>_)T0sH{={UU? zc-o26HpFt`X_KUtO{tIJqH8(WrF-Ma!;{BKHT|mLc3_D%ye&P*`T2$MG$XyPr6pyH z8DYnge70t;LO;Lv0`|bOFmya8SMpS-Ftsj&VlrPT8cGuj9~w)%otGLR^e*N69MQMp zsbVWaGS;llV;k7pyU;k|?in1o!CE}K9s8z08$PJ$Ank`&g|9Tz?kryMd5o$>{xe4I z{5|r11VV;QN3Vs0ZEDk_8BJPg^se!{H-ks8f(jqBjWD_(`?@avVsN?fu=_=#4P!dN zK$s^|lUkZhNOs{jXA#X~qx5@NEN5TgWAa|%j8On^S!hlYVHt$k))`s;4f%0EcHq@Q zwlSJJ2=0(KF*VJU=Lk`eP<(x@ZN;ZNSS90|ex@+?TcuMrp&8<3`bo-!36_*4fim%* zSbXcSn?LPKb zf^@*`CsYI>RAamIYZr~d!r}|q z#sm-~iEP9&8guD2Zo~&p$oQ;Ts;k>1b3RAvPK}1Z9T#R?R)#vrvwQM?D6!>Ieo&86 z-<>q#rU_Nyk5YdauJ`b%?lhmtNXaag=4?s>Vg;@5IN{p;o2kg$QTs=eZ;6 z?x_ol-MRZCcJ}M#*2%gcm8E^Y1Ok$x1x#`88MJ4vq`BV?c zR5KsBLtpePMlY-e7Z7C#iKnTH-V=C!^iHR2X~6SR&fns=70Pv%Z%{F{kmxaCWu4Q! z)p)sO%2V5J{_4pkiT0srx}*{4yI=0.3.8", "ruff>=0.14.5", ] +docs = [ + "zensical", +] + +[project.scripts] +dasjax-benchmark = "dasjax.benchmark_cli:main" [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/scripts/build_api_docs.py b/scripts/build_api_docs.py new file mode 100644 index 0000000..936ed6b --- /dev/null +++ b/scripts/build_api_docs.py @@ -0,0 +1,484 @@ +"""Generate Markdown API reference pages for the Zensical docs build.""" + +from __future__ import annotations + +import inspect +import os +import re +import shutil +import sys +from dataclasses import dataclass +from inspect import Signature +from pathlib import Path +from textwrap import dedent +from types import ModuleType +from typing import Any + + +ROOT = Path(__file__).resolve().parents[1] +SRC = ROOT / "src" +OUT_DIR = ROOT / "docs" / "api" + +if str(SRC) not in sys.path: + sys.path.insert(0, str(SRC)) + +import dasjax # noqa: E402 + + +@dataclass(frozen=True) +class ApiEntry: + """One generated API documentation page.""" + + name: str + display_name: str + obj: Any + kind: str + path: Path + owner: "ApiEntry | None" = None + + +def _doc(obj: Any) -> str: + """Return a cleaned docstring or fallback text.""" + return inspect.getdoc(obj) or "No public docstring is available." + + +def _summary(obj: Any) -> str: + """Return a compact one-line summary from a docstring.""" + lines = [line.strip() for line in _doc(obj).splitlines() if line.strip()] + return lines[0] if lines else "" + + +def _signature(obj: Any) -> str: + """Return a readable signature for functions, methods, and classes.""" + target = obj.__init__ if inspect.isclass(obj) else obj + try: + signature = inspect.signature(target) + except (TypeError, ValueError): + return "()" + params = [ + parameter + for name, parameter in signature.parameters.items() + if name not in {"self", "cls"} + ] + return str(signature.replace(parameters=params, return_annotation=Signature.empty)) + + +def _slug(value: str) -> str: + """Return a filesystem-safe, deterministic slug.""" + value = value.replace("__", "-") + value = re.sub(r"[^A-Za-z0-9_.-]+", "-", value) + return value.strip("-").replace(".", "-").lower() + + +def _table_cell(value: str) -> str: + """Escape Markdown table cell separators.""" + return value.replace("|", "\\|").replace("\n", " ") + + +def _page_link(from_page: Path, entry: ApiEntry) -> str: + """Return a relative Markdown link from one generated page to another.""" + return Path(os.path.relpath(entry.path, from_page.parent)).as_posix() + + +def _xref_map(entries: tuple[ApiEntry, ...]) -> dict[str, ApiEntry]: + """Return local reference aliases mapped to generated API pages.""" + refs: dict[str, ApiEntry] = {} + for entry in entries: + aliases = { + entry.name, + entry.display_name, + entry.name.removeprefix("dasjax."), + entry.display_name.rsplit(".", 1)[-1], + } + module_name = getattr(entry.obj, "__module__", None) + object_name = getattr(entry.obj, "__name__", None) + if module_name and object_name: + aliases.add(f"{module_name}.{object_name}") + aliases.add(object_name) + if entry.kind == "method" and entry.owner is not None: + method_name = entry.display_name.rsplit(".", 1)[-1] + aliases.add(f"{entry.owner.display_name}.{method_name}") + aliases.add(f"{entry.owner.name}.{method_name}") + for alias in aliases: + if alias and alias not in refs: + refs[alias] = entry + return refs + + +def _link_ref(token: str, *, page: Path, refs: dict[str, ApiEntry]) -> str | None: + """Return a Markdown link for a reference token if it can be resolved.""" + clean = token.strip() + suffix = "" + while clean.endswith("()"): + clean = clean[:-2] + suffix += "()" + entry = refs.get(clean) + if entry is None: + return None + return f"[`{token}`]({_page_link(page, entry)})" + + +def _link_docstring(text: str, *, page: Path, refs: dict[str, ApiEntry]) -> str: + """Convert common Python docstring references into Markdown links.""" + + def _replace_role(match: re.Match[str]) -> str: + label = match.group("label") or match.group("target") + target = match.group("target") + link = _link_ref(target, page=page, refs=refs) + if link is None: + return match.group(0) + href = link.rsplit("](", 1)[1][:-1] + return f"[`{label}`]({href})" + + def _replace_double_backtick(match: re.Match[str]) -> str: + token = match.group("token") + return _link_ref(token, page=page, refs=refs) or f"`{token}`" + + def _replace_backtick(match: re.Match[str]) -> str: + token = match.group("token") + return _link_ref(token, page=page, refs=refs) or match.group(0) + + text = re.sub( + r":(?:class|func|meth|mod|obj|py:class|py:func|py:meth|py:mod):" + r"`(?:(?P

', + "", + f"- __Kind__ \n `{entry.kind}`", + f"- __Owner__ \n {owner_link}", + "", + "
", + "", + ] + if callable(entry.obj) and not inspect.ismodule(entry.obj): + lines.extend( + [ + "## Signature", + "", + f"```python\n{entry.display_name}{_signature(entry.obj)}\n```", + "", + ] + ) + doc = _link_docstring(dedent(_doc(entry.obj)), page=entry.path, refs=refs) + lines.extend(['!!! abstract "Description"', ""]) + lines.extend(f" {line}" if line else "" for line in doc.splitlines()) + lines.append("") + + if inspect.ismodule(entry.obj): + lines.extend( + _owned_table( + title="Owned Public API", + entries=_module_members(entry.obj, entries_by_obj, entries), + page=entry.path, + empty_text="This module has no documented owned public API entries.", + ) + ) + elif inspect.isclass(entry.obj): + owned_methods = _owned_methods(entry, method_entries) + if owned_methods: + lines.extend( + _owned_table( + title="Owned Methods", + entries=owned_methods, + page=entry.path, + empty_text="", + ) + ) + + return "\n".join(lines) + + +def _collect_entries() -> tuple[ + tuple[ApiEntry, ...], + dict[int, ApiEntry], + dict[tuple[type, str], ApiEntry], +]: + """Collect root, public symbol, operation, and method API pages.""" + root_module = ApiEntry( + name="dasjax", + display_name="dasjax", + obj=dasjax, + kind="module", + path=OUT_DIR / "dasjax.md", + ) + module_objects: dict[str, ModuleType] = {"dasjax": dasjax} + entries: list[ApiEntry] = [root_module] + + for name in dasjax.__all__: + obj = getattr(dasjax, name) + module_name = getattr(obj, "__module__", None) + if module_name: + module = sys.modules.get(module_name) + if isinstance(module, ModuleType): + module_objects[module_name] = module + entries.append( + ApiEntry( + name=f"dasjax.{name}", + display_name=name, + obj=obj, + kind=_kind(obj), + path=OUT_DIR / f"{_slug(name)}.md", + ) + ) + + seen_operation_classes: set[type] = set() + for operation_name in dasjax.list_patch_operations(): + cls = dasjax.get_patch_operation(operation_name) + module = sys.modules.get(cls.__module__) + if isinstance(module, ModuleType): + module_objects[cls.__module__] = module + if cls in seen_operation_classes: + continue + seen_operation_classes.add(cls) + entries.append( + ApiEntry( + name=f"{cls.__module__}.{cls.__name__}", + display_name=operation_name, + obj=cls, + kind="class", + path=OUT_DIR / "operations" / f"{_slug(operation_name)}.md", + ) + ) + + module_entries = [ + ApiEntry( + name=module_name, + display_name=module_name, + obj=module, + kind="module", + path=OUT_DIR / "modules" / f"{_slug(module_name)}.md", + ) + for module_name, module in sorted(module_objects.items()) + if module_name != "dasjax" + ] + entries[1:1] = module_entries + + method_entries: dict[tuple[type, str], ApiEntry] = {} + for owner in tuple(entries): + if not inspect.isclass(owner.obj): + continue + for method_name, method_obj in sorted(owner.obj.__dict__.items()): + if not _is_owned_method(owner.obj, method_name, method_obj): + continue + entry = ApiEntry( + name=f"{owner.name}.{method_name}", + display_name=f"{owner.display_name}.{method_name}", + obj=method_obj, + kind="method", + path=OUT_DIR + / "methods" + / f"{_slug(owner.name)}-{_slug(method_name)}.md", + owner=owner, + ) + method_entries[(owner.obj, method_name)] = entry + entries.append(entry) + + entries_by_obj = {id(entry.obj): entry for entry in entries} + return tuple(entries), entries_by_obj, method_entries + + +def _render_index(entries: tuple[ApiEntry, ...]) -> str: + """Render the compact linked API index.""" + index_page = OUT_DIR / "index.md" + counts = _entry_counts(entries) + lines = [ + "# API Reference", + "", + "", + "", + "This page is generated from the public `dasjax` Python API and the " + "registered pipeline operation surface at build time.", + "", + '
', + "", + f"- __Modules__ \n {counts['module']} generated module pages", + f"- __Classes__ \n {counts['class']} generated class pages", + f"- __Functions__ \n {counts['function']} public helper functions", + f"- __Methods__ \n {counts['method']} method pages linked from owners", + "", + "
", + "", + '!!! tip "How to use this reference"', + "", + " Use the table below for public entry points, modules, and pipeline " + "operations. Method pages are linked from each owning class page so the " + "top-level index stays scannable.", + "", + *_index_rows(entries, index_page), + "", + ] + return "\n".join(lines) + + +def _clean_output() -> None: + """Remove old generated API pages before writing a fresh set.""" + if OUT_DIR.exists(): + shutil.rmtree(OUT_DIR) + OUT_DIR.mkdir(parents=True, exist_ok=True) + + +def main() -> None: + """Write generated API docs to the docs tree.""" + entries, entries_by_obj, method_entries = _collect_entries() + refs = _xref_map(entries) + _clean_output() + (OUT_DIR / "index.md").write_text(_render_index(entries), encoding="utf-8") + for entry in entries: + entry.path.parent.mkdir(parents=True, exist_ok=True) + entry.path.write_text( + _render_page( + entry, + entries=entries, + entries_by_obj=entries_by_obj, + method_entries=method_entries, + refs=refs, + ), + encoding="utf-8", + ) + print(f"Wrote {len(entries) + 1} API documentation pages") + + +if __name__ == "__main__": + main() diff --git a/scripts/build_benchmark_docs.py b/scripts/build_benchmark_docs.py new file mode 100644 index 0000000..8ef590f --- /dev/null +++ b/scripts/build_benchmark_docs.py @@ -0,0 +1,29 @@ +"""Generate benchmark documentation from the tracked benchmark snapshot.""" + +from __future__ import annotations + +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +SRC = ROOT / "src" + +if str(SRC) not in sys.path: + sys.path.insert(0, str(SRC)) + +from dasjax.benchmark_cli import DEFAULT_DOCS_OUTPUT, DEFAULT_SNAPSHOT, docs_command # noqa: E402 + + +def main() -> int: + """Render the benchmark docs page.""" + args = type( + "Args", + (), + {"snapshot": DEFAULT_SNAPSHOT, "output": DEFAULT_DOCS_OUTPUT}, + )() + return docs_command(args) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/dasjax/__init__.py b/src/dasjax/__init__.py index b9f6eac..e853ed3 100644 --- a/src/dasjax/__init__.py +++ b/src/dasjax/__init__.py @@ -18,6 +18,7 @@ iter_patch_operations, list_patch_operations, ) +from . import operations as operations from . import core_ops as core_ops from .pipeline import JaxPatchPipeline diff --git a/src/dasjax/benchmark_cli.py b/src/dasjax/benchmark_cli.py new file mode 100644 index 0000000..34091f2 --- /dev/null +++ b/src/dasjax/benchmark_cli.py @@ -0,0 +1,519 @@ +"""Command line helpers for running and publishing dasjax benchmarks.""" + +from __future__ import annotations + +import argparse +import html +import json +import math +import platform +import re +import subprocess +import sys +from collections import defaultdict +from collections.abc import Sequence +from datetime import UTC, datetime +from importlib import metadata +from pathlib import Path +from typing import Any + +DEFAULT_BENCHMARK_FILE = Path("benchmarks/test_pipeline_benchmarks.py") +DEFAULT_RAW_OUTPUT = Path(".benchmarks/current.json") +DEFAULT_SNAPSHOT = Path("benchmarks/results/current.json") +DEFAULT_DOCS_OUTPUT = Path("docs/benchmarks/index.md") +DEFAULT_DOCS_DIR = Path("docs/benchmarks") + + +def _version(package: str) -> str: + """Return an installed package version or a fallback label.""" + try: + return metadata.version(package) + except metadata.PackageNotFoundError: + return "unknown" + + +def _now_iso() -> str: + """Return the current UTC timestamp as an ISO string.""" + return datetime.now(tz=UTC).replace(microsecond=0).isoformat() + + +def build_pytest_command(args: argparse.Namespace) -> list[str]: + """Build the pytest-benchmark command from parsed CLI args.""" + command = [ + sys.executable, + "-m", + "pytest", + str(args.benchmark_file), + f"--benchmark-json={args.output}", + ] + filters = [] + if args.benchmark: + filters.append("(" + " or ".join(args.benchmark) + ")") + if args.case: + filters.append("(" + " or ".join(args.case) + ")") + if filters: + command.extend(["-k", " and ".join(filters)]) + command.extend(args.pytest_arg or ()) + return command + + +def run_benchmarks(args: argparse.Namespace) -> int: + """Run pytest-benchmark and write raw benchmark JSON.""" + args.output.parent.mkdir(parents=True, exist_ok=True) + command = build_pytest_command(args) + print("Running:", " ".join(command)) + return subprocess.run(command, check=False).returncode + + +def _benchmark_group(benchmark: dict[str, Any]) -> str: + """Return a benchmark group name from pytest-benchmark data.""" + if group := benchmark.get("group"): + return str(group) + name = str(benchmark.get("name") or benchmark.get("fullname") or "") + name = re.sub(r"\[.*\]$", "", name) + for prefix in ("test_dasjax_compiled_", "test_dascore_"): + if prefix in name: + return name.rsplit(prefix, 1)[1] + return name.removeprefix("test_") + + +def _benchmark_engine(benchmark: dict[str, Any]) -> str | None: + """Return dasjax/dascore for known benchmark functions.""" + text = " ".join( + str(benchmark.get(key, "")) for key in ("name", "fullname", "fullname") + ) + if "dasjax" in text: + return "dasjax" + if "dascore" in text: + return "dascore" + return None + + +def _case_label(value: Any) -> str: + """Return a readable label for a pytest benchmark parameter.""" + if isinstance(value, str): + return value + if isinstance(value, (list, tuple)) and len(value) == 2: + shape, dtype = value + if isinstance(shape, (list, tuple)) and len(shape) == 2: + shape_label = { + (600, 4000): "medium", + (1200, 8000): "large", + }.get(tuple(int(axis) for axis in shape), "x".join(str(axis) for axis in shape)) + dtype_label = str(dtype).removeprefix("float") + return f"{shape_label}-f{dtype_label}" + return str(value) + + +def _benchmark_case(benchmark: dict[str, Any]) -> str: + """Return the parametrized patch case label.""" + params = benchmark.get("params") or {} + if isinstance(params, dict): + for key in ("example_patch", "patch", "case"): + if key in params: + return _case_label(params[key]) + text = str(benchmark.get("name") or benchmark.get("fullname") or "") + match = re.search(r"\[([^\]]+)\]", text) + return match.group(1) if match else "default" + + +def _mean_seconds(benchmark: dict[str, Any]) -> float | None: + """Return benchmark mean in seconds.""" + stats = benchmark.get("stats") or {} + mean = stats.get("mean") if isinstance(stats, dict) else None + return float(mean) if mean is not None else None + + +def _environment(raw: dict[str, Any]) -> dict[str, Any]: + """Build environment metadata for a normalized snapshot.""" + machine = raw.get("machine_info") or {} + return { + "python": platform.python_version(), + "platform": platform.platform(), + "processor": platform.processor() or machine.get("processor") or "unknown", + "machine": platform.machine(), + "jax": _version("jax"), + "dascore": _version("dascore"), + "dasjax": _version("dasjax"), + } + + +def normalize_benchmark_json( + raw: dict[str, Any], + *, + command: str, + source: str = "local", +) -> dict[str, Any]: + """Normalize pytest-benchmark JSON into a docs-friendly snapshot.""" + grouped: dict[tuple[str, str], dict[str, float]] = defaultdict(dict) + for benchmark in raw.get("benchmarks", ()): + engine = _benchmark_engine(benchmark) + mean = _mean_seconds(benchmark) + if engine is None or mean is None: + continue + key = (_benchmark_group(benchmark), _benchmark_case(benchmark)) + grouped[key][engine] = mean + + rows = [] + for (group, case), values in sorted(grouped.items()): + dascore = values.get("dascore") + dasjax = values.get("dasjax") + speedup = dascore / dasjax if dascore and dasjax else None + rows.append( + { + "group": group, + "case": case, + "dascore_mean_s": dascore, + "dasjax_mean_s": dasjax, + "speedup": speedup, + } + ) + + return { + "schema_version": 1, + "generated_at": _now_iso(), + "source": source, + "command": command, + "environment": _environment(raw), + "rows": rows, + } + + +def load_json(path: Path) -> dict[str, Any]: + """Load JSON from a path.""" + return json.loads(path.read_text(encoding="utf-8")) + + +def write_json(path: Path, payload: dict[str, Any]) -> None: + """Write stable, pretty JSON to a path.""" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8") + + +def _format_ms(value: float | None) -> str: + """Format seconds as milliseconds.""" + if value is None or not math.isfinite(value): + return "n/a" + return f"{value * 1000:.3f}" + + +def _format_speedup(value: float | None) -> str: + """Format a speedup ratio.""" + if value is None or not math.isfinite(value): + return "n/a" + return f"{value:.2f}x" + + +def _benchmark_category(group: str) -> str: + """Return a human category for a benchmark group.""" + return "Method" if group.startswith("operation_") else "Pipeline" + + +def _split_rows(snapshot: dict[str, Any]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + """Return pipeline rows and method rows from a benchmark snapshot.""" + rows = snapshot.get("rows") or [] + pipelines = [row for row in rows if not str(row.get("group", "")).startswith("operation_")] + methods = [row for row in rows if str(row.get("group", "")).startswith("operation_")] + return pipelines, methods + + +def render_benchmark_index(snapshot: dict[str, Any]) -> str: + """Render the benchmark section overview page.""" + env = snapshot.get("environment") or {} + pipelines, methods = _split_rows(snapshot) + lines = [ + "# Benchmarks", + "", + "", + "", + "Published benchmark results compare warmed compiled `dasjax` pipelines and " + "methods against equivalent DASCore operation chains.", + "", + '
', + "", + f"- __Source__ \n {snapshot.get('source', 'unknown')}", + f"- __Generated__ \n {snapshot.get('generated_at', 'unknown')}", + f"- __Python__ \n {env.get('python', 'unknown')}", + f"- __Platform__ \n {env.get('platform', 'unknown')}", + f"- __Pipeline results__ \n [{len(pipelines)} rows](pipelines.md)", + f"- __Method results__ \n [{len(methods)} rows](methods.md)", + "", + "
", + "", + '!!! warning "Benchmark numbers are environment-specific"', + "", + " Treat these numbers as a snapshot for this machine and dependency " + "set, not as universal performance guarantees.", + "", + "## Result Tables", + "", + "- [Pipelines](pipelines.md)", + "- [Methods](methods.md)", + "", + "## Environment", + "", + "| Key | Value |", + "|---|---|", + ] + for key, value in env.items(): + lines.append(f"| `{key}` | `{value}` |") + lines.extend( + [ + "", + "## Refreshing Results", + "", + "```bash", + "dasjax-benchmark refresh", + "```", + "", + "To run the steps separately:", + "", + "```bash", + "dasjax-benchmark run --output .benchmarks/current.json", + "dasjax-benchmark normalize --input .benchmarks/current.json --output benchmarks/results/current.json", + "dasjax-benchmark docs --snapshot benchmarks/results/current.json --output docs/benchmarks/index.md", + "```", + "", + "Raw pytest-benchmark command:", + "", + "```bash", + f"{snapshot.get('command', 'pytest benchmarks/test_pipeline_benchmarks.py')}", + "```", + "", + ] + ) + return "\n".join(lines) + + +def _benchmark_display_name(group: str) -> str: + """Return a display name for a benchmark group.""" + return group.removeprefix("operation_") + + +def _render_filter_script() -> str: + """Return client-side table filtering script.""" + return """ + +""".strip() + + +def _render_table_style() -> str: + """Return page-local styles for benchmark tables.""" + return """ + +""".strip() + + +def render_benchmark_table_page( + snapshot: dict[str, Any], + *, + title: str, + rows: Sequence[dict[str, Any]], +) -> str: + """Render a filterable benchmark table page.""" + generated = html.escape(str(snapshot.get("generated_at", "unknown"))) + placeholder = html.escape(f"Filter {title.lower()}...") + lines = [ + f"# {title}", + "", + "", + "", + f"Generated from the benchmark snapshot at `{generated}`.", + "", + _render_table_style(), + "", + '
', + f'', + '

', + "", + "", + "", + "", + "", + '', + '', + '', + "", + "", + "", + ] + for row in rows: + group = html.escape(_benchmark_display_name(str(row.get("group", "unknown")))) + case = html.escape(str(row.get("case", "default"))) + lines.extend( + [ + "", + f"", + f"", + f'', + f'', + f'', + "", + ] + ) + lines.extend( + [ + "", + "
BenchmarkCaseDASCore mean (ms)dasjax mean (ms)Speedup
{group}{case}{html.escape(_format_ms(row.get("dascore_mean_s")))}{html.escape(_format_ms(row.get("dasjax_mean_s")))}{html.escape(_format_speedup(row.get("speedup")))}
", + "
", + "", + _render_filter_script(), + "", + ] + ) + return "\n".join(lines) + + +def render_benchmark_docs(snapshot: dict[str, Any]) -> str: + """Render benchmark docs Markdown from a normalized snapshot.""" + return render_benchmark_index(snapshot) + + +def normalize_command(args: argparse.Namespace) -> int: + """Normalize a raw pytest-benchmark JSON file.""" + raw = load_json(args.input) + command = args.command or f"pytest {DEFAULT_BENCHMARK_FILE} --benchmark-json={args.input}" + snapshot = normalize_benchmark_json(raw, command=command, source=args.source) + write_json(args.output, snapshot) + print(f"Wrote {args.output}") + return 0 + + +def docs_command(args: argparse.Namespace) -> int: + """Render benchmark docs from a normalized snapshot.""" + snapshot = load_json(args.snapshot) + docs_dir = args.output.parent + docs_dir.mkdir(parents=True, exist_ok=True) + pipelines, methods = _split_rows(snapshot) + pages = { + args.output: render_benchmark_index(snapshot), + docs_dir / "pipelines.md": render_benchmark_table_page( + snapshot, title="Pipelines", rows=pipelines + ), + docs_dir / "methods.md": render_benchmark_table_page( + snapshot, title="Methods", rows=methods + ), + } + for path, text in pages.items(): + path.write_text(text, encoding="utf-8") + print(f"Wrote {path}") + return 0 + + +def refresh_command(args: argparse.Namespace) -> int: + """Run benchmarks, normalize results, and render docs.""" + run_args = argparse.Namespace( + benchmark_file=args.benchmark_file, + output=args.raw_output, + benchmark=args.benchmark, + case=args.case, + pytest_arg=args.pytest_arg, + ) + code = run_benchmarks(run_args) + if code: + return code + command = " ".join(build_pytest_command(run_args)) + normalize_args = argparse.Namespace( + input=args.raw_output, + output=args.snapshot, + source=args.source, + command=command, + ) + normalize_command(normalize_args) + docs_args = argparse.Namespace(snapshot=args.snapshot, output=args.docs_output) + return docs_command(docs_args) + + +def build_parser() -> argparse.ArgumentParser: + """Build the benchmark CLI parser.""" + parser = argparse.ArgumentParser(prog="dasjax-benchmark") + subparsers = parser.add_subparsers(dest="command", required=True) + + run = subparsers.add_parser("run", help="run pytest-benchmark suite") + run.add_argument("--benchmark-file", type=Path, default=DEFAULT_BENCHMARK_FILE) + run.add_argument("--output", type=Path, default=DEFAULT_RAW_OUTPUT) + run.add_argument("--benchmark", action="append", help="filter benchmark group/name") + run.add_argument("--case", action="append", help="filter fixture case label") + run.add_argument("--pytest-arg", action="append", default=[], help="extra pytest arg") + run.set_defaults(func=run_benchmarks) + + normalize = subparsers.add_parser("normalize", help="normalize raw JSON") + normalize.add_argument("--input", type=Path, required=True) + normalize.add_argument("--output", type=Path, default=DEFAULT_SNAPSHOT) + normalize.add_argument("--source", default="local") + normalize.add_argument("--command") + normalize.set_defaults(func=normalize_command) + + docs = subparsers.add_parser("docs", help="render benchmark docs") + docs.add_argument("--snapshot", type=Path, default=DEFAULT_SNAPSHOT) + docs.add_argument("--output", type=Path, default=DEFAULT_DOCS_OUTPUT) + docs.set_defaults(func=docs_command) + + refresh = subparsers.add_parser("refresh", help="run, normalize, and render docs") + refresh.add_argument("--benchmark-file", type=Path, default=DEFAULT_BENCHMARK_FILE) + refresh.add_argument("--raw-output", type=Path, default=DEFAULT_RAW_OUTPUT) + refresh.add_argument("--snapshot", type=Path, default=DEFAULT_SNAPSHOT) + refresh.add_argument("--docs-output", type=Path, default=DEFAULT_DOCS_OUTPUT) + refresh.add_argument("--source", default="local") + refresh.add_argument("--benchmark", action="append", help="filter benchmark group/name") + refresh.add_argument("--case", action="append", help="filter fixture case label") + refresh.add_argument("--pytest-arg", action="append", default=[], help="extra pytest arg") + refresh.set_defaults(func=refresh_command) + + return parser + + +def main(argv: Sequence[str] | None = None) -> int: + """Run the benchmark CLI.""" + parser = build_parser() + args = parser.parse_args(argv) + return int(args.func(args)) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/dasjax/core.py b/src/dasjax/core.py index 18f67e7..b2bd2a3 100644 --- a/src/dasjax/core.py +++ b/src/dasjax/core.py @@ -11,10 +11,6 @@ import jax import numpy as np -from . import kernels - -SUPPORTED_DTYPES = (np.bool_, np.integer, np.floating, np.complexfloating) -TIME_DTYPES = (np.datetime64, np.timedelta64) _DTYPE_TO_CODE = { np.dtype("bool").str: 1, np.dtype("int32").str: 2, @@ -27,6 +23,10 @@ np.dtype("timedelta64[ns]").str: 9, } _CODE_TO_DTYPE = {value: np.dtype(key) for key, value in _DTYPE_TO_CODE.items()} +TIME_DTYPES = (np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")) +SUPPORTED_DTYPES = tuple( + np.dtype(key) for key in _DTYPE_TO_CODE if np.dtype(key) not in TIME_DTYPES +) _PatchTreeChildren = tuple[Any, tuple[Any, ...], tuple[Any, ...], tuple[Any, ...]] @@ -36,12 +36,16 @@ def _camel_to_snake(name: str) -> str: return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower() -def _matches_dtype(dtype: np.dtype, candidates: tuple[type[Any], ...]) -> bool: - return any(np.issubdtype(dtype, candidate) for candidate in candidates) +def _matches_dtype(dtype: np.dtype, candidates: tuple[np.dtype, ...]) -> bool: + return any(np.dtype(dtype) == candidate for candidate in candidates) def _encode_leaf(array: Any) -> tuple[Any, np.ndarray]: arr = np.asarray(array) + if np.issubdtype(arr.dtype, np.datetime64): + arr = arr.astype("datetime64[ns]") + elif np.issubdtype(arr.dtype, np.timedelta64): + arr = arr.astype("timedelta64[ns]") dtype_code = _DTYPE_TO_CODE.get(arr.dtype.str) if dtype_code is None: msg = f"Unsupported coordinate dtype for JAX patch conversion: {arr.dtype}" @@ -50,8 +54,6 @@ def _encode_leaf(array: Any) -> tuple[Any, np.ndarray]: return arr, np.asarray(dtype_code, dtype=np.int32) if _matches_dtype(arr.dtype, TIME_DTYPES): return arr.view(np.int64), np.asarray(dtype_code, dtype=np.int32) - msg = f"Unsupported coordinate dtype for JAX patch conversion: {arr.dtype}" - raise TypeError(msg) def _decode_leaf(array: Any, dtype_code: Any) -> np.ndarray: @@ -62,6 +64,23 @@ def _decode_leaf(array: Any, dtype_code: Any) -> np.ndarray: return out.astype(dtype, copy=False) +def _coord_values_match(left: Any, right: Any) -> bool: + """Return True when decoded coord values match existing coord values.""" + left_arr = np.asarray(left) + right_arr = np.asarray(right) + if left_arr.shape != right_arr.shape: + return False + if np.issubdtype(left_arr.dtype, np.datetime64): + left_i = left_arr.astype("datetime64[ns]", copy=False).view(np.int64) + right_i = right_arr.astype("datetime64[ns]", copy=False).view(np.int64) + return bool(np.array_equal(left_i, right_i)) + if np.issubdtype(left_arr.dtype, np.timedelta64): + left_i = left_arr.astype("timedelta64[ns]", copy=False).view(np.int64) + right_i = right_arr.astype("timedelta64[ns]", copy=False).view(np.int64) + return bool(np.array_equal(left_i, right_i)) + return bool(np.array_equal(left_arr, right_arr)) + + @dataclass(frozen=True) class PatchBoundary: """DASCore-native metadata owned by pipeline boundaries.""" @@ -111,8 +130,11 @@ def to_patch( for name, coord in self.coords.coord_map.items(): out_coord = coord if name in coord_values: - out_coord = coord.update_data(data=coord_values[name]) - if coord.units is not None: + if _coord_values_match(coord_values[name], coord.values): + out_coord = coord + else: + out_coord = coord.update_data(data=coord_values[name]) + if out_coord is not coord and coord.units is not None: out_coord = out_coord.set_units(coord.units) dims = tuple(self.coords.dim_map[name]) coords[name] = ( @@ -327,86 +349,3 @@ def iter_patch_operations() -> Iterator[type[PatchOperation]]: def list_patch_operations() -> tuple[str, ...]: """List class-authored operation names in registration order.""" return tuple(PatchOperation._registry) - - -@dataclass(frozen=True) -class Identity(PatchOperation): - """Return a patch unchanged.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.identity_kernel(patch_tree.data)) - - -@dataclass(frozen=True) -class Scale(PatchOperation): - """Scale patch data by a constant factor.""" - - factor: float - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.scale_kernel(patch_tree.data, self.factor)) - - -@dataclass(frozen=True) -class Add(PatchOperation): - """Add a constant value to patch data.""" - - value: float - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.add_kernel(patch_tree.data, self.value)) - - -@dataclass(frozen=True) -class Abs(PatchOperation): - """Take absolute value of patch data.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.abs_kernel(patch_tree.data)) - - -@dataclass(frozen=True) -class Clip(PatchOperation): - """Clip patch data to a fixed range.""" - - min_value: float - max_value: float - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new( - data=kernels.clip_kernel( - patch_tree.data, self.min_value, self.max_value - ) - ) - - -@dataclass(frozen=True) -class Real(PatchOperation): - """Return the real component of patch data.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.real_kernel(patch_tree.data)) - - -@dataclass(frozen=True) -class Imag(PatchOperation): - """Return the imaginary component of patch data.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.imag_kernel(patch_tree.data)) - - -@dataclass(frozen=True) -class Angle(PatchOperation): - """Return the phase angle of patch data.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.angle_kernel(patch_tree.data)) - - -@dataclass(frozen=True) -class Conj(PatchOperation): - """Return the complex conjugate of patch data.""" - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new(data=kernels.conj_kernel(patch_tree.data)) diff --git a/src/dasjax/core_ops.py b/src/dasjax/core_ops.py index 1188e9a..b55a29e 100644 --- a/src/dasjax/core_ops.py +++ b/src/dasjax/core_ops.py @@ -1,852 +1,9 @@ -"""Core PatchOperation ports for the public pipeline operation surface.""" +"""Compatibility exports for operation classes. -from __future__ import annotations - -from dataclasses import dataclass, fields -from functools import reduce -from operator import add, mul, truediv -from typing import Any, ClassVar - -import dascore as dc -import jax -import jax.numpy as jnp -import numpy as np -from dascore.exceptions import ParameterError -from dascore.proc.basic import pad as dc_pad -from dascore.transform.fourier import ( - _get_idft_dims_steps_axis, - dft as dc_dft, - idft as dc_idft, -) -from dascore.units import get_filter_units, get_quantity -from dascore.utils.misc import iterate -from dascore.utils.patch import get_dim_axis_value, get_dim_sampling_rate, get_patch_window_size -from dascore.utils.transformatter import FourierTransformatter -from scipy.fft import next_fast_len -from scipy.signal import ShortTimeFFT, get_window - -from . import kernels -from .core import PatchBoundary, PatchOperation, PatchPyTree - - -def replace(obj, **changes): - """Copy frozen operation instances without calling custom constructors.""" - out = object.__new__(type(obj)) - for field in fields(obj): - object.__setattr__(out, field.name, changes.get(field.name, getattr(obj, field.name))) - return out - - -def _dummy_patch(boundary: PatchBoundary, dtype=np.float64) -> dc.Patch: - return dc.Patch( - data=np.zeros(boundary.coords.shape, dtype=dtype), - coords=boundary.coords, - dims=boundary.dims, - attrs=boundary.attrs, - ) - - -def _tree_boundary_from_patch(patch: dc.Patch) -> tuple[PatchPyTree, PatchBoundary]: - return PatchPyTree.from_patch(patch) - - -def _get_data_units_from_dims( - boundary: PatchBoundary, - dims: tuple[str, ...], - operator, -): - if (data_units := get_quantity(boundary.attrs.data_units)) is None: - return None - dim_units = None - for dim_name in dims: - dim_unit = get_quantity(boundary.coord(dim_name).units) - if dim_unit is None: - continue - dim_units = dim_unit if dim_units is None else dim_unit * dim_units - return operator(data_units, dim_units) if dim_units is not None else data_units - - -@dataclass(frozen=True) -class Flip(PatchOperation): - """Flip data and, optionally, associated coordinate values.""" - - dims: tuple[str, ...] = () - flip_coords: bool = True - axes: tuple[int, ...] = () - coord_axes: tuple[tuple[int, tuple[int, ...]], ...] = () - - def __init__(self, *dims: str, flip_coords: bool = True): - object.__setattr__(self, "dims", tuple(dims)) - object.__setattr__(self, "flip_coords", flip_coords) - object.__setattr__(self, "axes", ()) - object.__setattr__(self, "coord_axes", ()) - - def bind(self, boundary: PatchBoundary): - dims = self.dims or boundary.dims - axes = tuple(boundary.axis(dim) for dim in dims) - coord_axes = [] - if self.flip_coords: - for name in boundary.coord_names: - axes_for_coord = tuple( - idx - for idx, coord_dim in enumerate(boundary.coord_dims(name)) - if coord_dim in dims - ) - if axes_for_coord: - coord_axes.append((boundary.coord_index(name), axes_for_coord)) - return replace(self, dims=dims, axes=axes, coord_axes=tuple(coord_axes)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - data = kernels.flip_kernel(patch_tree.data, self.axes) - coords = patch_tree.coord_values - if self.flip_coords: - for index, axes in self.coord_axes: - coords = tuple( - jnp.flip(value, axis=axes) if idx == index else value - for idx, value in enumerate(coords) - ) - return patch_tree.new(data=data, coords=coords) - - -@dataclass(frozen=True) -class Roll(PatchOperation): - """Roll data along one dimension.""" - - samples: bool = False - update_coord: bool = False - kwargs: dict[str, Any] | None = None - axis: int | None = None - shift: int | None = None - - def __init__( - self, - samples: bool = False, - update_coord: bool = False, - **kwargs, - ): - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "update_coord", update_coord) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "axis", None) - object.__setattr__(self, "shift", None) - - def bind(self, boundary: PatchBoundary): - if self.update_coord: - raise NotImplementedError("Compiled roll currently requires update_coord=False.") - kwargs = self.kwargs or {} - dim = next(key for key in kwargs if key in boundary.dims) - coord = boundary.coord(dim) - return replace( - self, - axis=boundary.axis(dim), - shift=int(coord.get_sample_count(kwargs[dim], samples=self.samples)), - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None and self.shift is not None - return patch_tree.new(data=kernels.roll_kernel(patch_tree.data, self.shift, self.axis)) - - -@dataclass(frozen=True) -class Standardize(PatchOperation): - dim: str - axis: int | None = None - - def bind(self, boundary: PatchBoundary): - return replace(self, axis=boundary.axis(self.dim)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new(data=kernels.standardize_kernel(patch_tree.data, self.axis)) - - -@dataclass(frozen=True) -class Detrend(PatchOperation): - dim: str - type: str = "linear" - axis: int | None = None - - def bind(self, boundary: PatchBoundary): - kernels.validate_detrend_type(self.type) - return replace(self, axis=boundary.axis(self.dim)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new( - data=kernels.detrend_kernel(patch_tree.data, axis=self.axis, type=self.type) - ) - - -@dataclass(frozen=True) -class Normalize(PatchOperation): - dim: str - norm: str = "l2" - axis: int | None = None - - def bind(self, boundary: PatchBoundary): - return replace(self, axis=boundary.axis(self.dim)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new( - data=kernels.normalize_kernel(patch_tree.data, axis=self.axis, norm=self.norm) - ) - - -@dataclass(frozen=True) -class Differentiate(PatchOperation): - dim: str | tuple[str, ...] | None - order: int = 2 - step: int = 1 - axes: tuple[int, ...] = () - dxs_or_spacing: tuple[Any, ...] = () - attrs: Any = None - - def bind(self, boundary: PatchBoundary): - dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) - if self.step > 1 and len(dims) > 1: - raise ParameterError("Step in patch.differentiate can only be used along one axis.") - axes = [] - dxs = [] - for dim in dims: - coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) - val = coord.step if coord.evenly_sampled else coord.data - dxs.append(dc.to_float(val)) - axes.append(boundary.axis(dim)) - attrs = boundary.attrs.update( - data_units=_get_data_units_from_dims(boundary, dims, truediv) - ) - return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - data = patch_tree.data - for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): - data = kernels.differentiate_kernel( - data, axis=axis, dx_or_spacing=spacing, order=self.order, step=self.step - ) - return patch_tree.new(data=data) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - return boundary.new(attrs=self.attrs) - - -@dataclass(frozen=True) -class Integrate(PatchOperation): - dim: str | tuple[str, ...] | None - definite: bool = False - axes: tuple[int, ...] = () - dxs_or_spacing: tuple[Any, ...] = () - attrs: Any = None - out_boundary: PatchBoundary | None = None - out_coords: tuple[Any, ...] | None = None - out_dtype_codes: tuple[Any, ...] | None = None - out_dims: tuple[str, ...] | None = None - - def bind(self, boundary: PatchBoundary): - dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) - axes = [] - dxs = [] - for dim in dims: - coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) - val = coord.step if coord.evenly_sampled else coord.data - dxs.append(dc.to_float(val)) - axes.append(boundary.axis(dim)) - attrs = boundary.attrs.update( - data_units=_get_data_units_from_dims(boundary, dims, mul), - coords={} if self.definite else boundary.attrs.coords, - ) - if self.definite: - out_patch = _dummy_patch(boundary).integrate(dim=dims, definite=True) - out_tree, out_boundary = _tree_boundary_from_patch(out_patch) - return replace( - self, - axes=tuple(axes), - dxs_or_spacing=tuple(dxs), - attrs=attrs, - out_boundary=out_boundary, - out_coords=out_tree.coord_values, - out_dtype_codes=out_tree.coord_dtype_codes, - out_dims=out_tree.dims, - ) - return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - data = patch_tree.data - for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): - data = kernels.integrate_kernel( - data, axis=axis, dx_or_spacing=spacing, definite=self.definite - ) - if self.definite: - return patch_tree.new( - data=data, - coords=self.out_coords, - dims=self.out_dims, - coord_dtype_codes=self.out_dtype_codes, - ) - return patch_tree.new(data=data) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - return self.out_boundary if self.definite and self.out_boundary else boundary.new(attrs=self.attrs) - - -def _taper_window(window_type: str, size: int) -> np.ndarray: - return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64) - - -def _taper_slices(boundary: PatchBoundary, kwargs: dict[str, Any]): - dim = next(key for key in kwargs if key in boundary.dims) - axis = boundary.axis(dim) - value = kwargs[dim] - coord = boundary.coord(dim) - if isinstance(value, (tuple, list, np.ndarray)): - start, stop = value - else: - start, stop = value, value - dur = coord.coord_range(extend=False) - clses = (dc.units.Quantity, np.timedelta64) - start = start if isinstance(start, clses) or start is None else start * dur - stop = stop if isinstance(stop, clses) or stop is None else stop * dur - stop = -stop if stop is not None else stop - _, inds_1 = coord.select((None, start), relative=True) - _, inds_2 = coord.select((stop, None), relative=True) - return axis, inds_1, inds_2 - - -@dataclass(frozen=True) -class Taper(PatchOperation): - window_type: str = "hann" - kwargs: dict[str, Any] | None = None - axis: int | None = None - weight: Any = None - - def __init__(self, window_type: str = "hann", **kwargs): - object.__setattr__(self, "window_type", window_type) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "axis", None) - object.__setattr__(self, "weight", None) - - def bind(self, boundary: PatchBoundary): - axis, start_slice, end_slice = _taper_slices(boundary, self.kwargs or {}) - length = boundary.coords.shape[axis] - start_len = start_slice.stop - end_len = length - end_slice.start - if start_len is not None and end_len is not None and start_len > end_slice.start: - raise ParameterError("Taper windows cannot overlap") - weight = np.ones(length, dtype=np.float64) - if start_len is not None and start_len > 0: - weight[:start_len] = _taper_window(self.window_type, 2 * start_len)[:start_len] - if end_slice.start is not None and end_slice.start < length: - weight[end_slice.start:] = _taper_window(self.window_type, 2 * end_len)[end_len:] - return replace(self, axis=axis, weight=weight) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new(data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)) - - -def _taper_coord_inds(coord, values, relative, samples): - error_msg = "A len 2 or 4 sequence is required for taper values" - if not isinstance(values, (tuple, list, np.ndarray)) or not len(values): - raise ParameterError(error_msg) - if isinstance(values[0], (tuple, list, np.ndarray)): - return reduce(add, (_taper_coord_inds(coord, item, relative, samples) for item in values)) - if len(values) not in {2, 4}: - raise ParameterError(error_msg) - out = [None] * len(values) - for idx, value in enumerate(values): - if value is None or value == ...: - if len(values) == 2: - raise ParameterError("Cannot use ... or None when only two values provided") - out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1 - else: - out[idx] = coord.get_next_index(value, samples=samples, relative=relative) - return [[0, *out, len(coord)]] if len(out) == 2 else [out] +New operation implementations live under :mod:`dasjax.operations`, grouped by +the corresponding DASCore operation domain. +""" +from __future__ import annotations -def _taper_curve(coord, ind_1, ind_2, window_type, reverse=False): - taper = _taper_window(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1] - return taper[::-1] if reverse else taper - - -@dataclass(frozen=True) -class TaperRange(PatchOperation): - window_type: str = "hann" - invert: bool = False - relative: bool = False - samples: bool = False - kwargs: dict[str, Any] | None = None - axis: int | None = None - weight: Any = None - - def __init__(self, window_type: str = "hann", invert=False, relative=False, samples=False, **kwargs): - object.__setattr__(self, "window_type", window_type) - object.__setattr__(self, "invert", invert) - object.__setattr__(self, "relative", relative) - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "axis", None) - object.__setattr__(self, "weight", None) - - def bind(self, boundary: PatchBoundary): - kwargs = self.kwargs or {} - dim = next(key for key in kwargs if key in boundary.dims) - axis = boundary.axis(dim) - coord = _dummy_patch(boundary).get_coord(dim, require_sorted=True) - inds = _taper_coord_inds(coord, kwargs[dim], self.relative, self.samples) - weight = np.zeros(len(coord)) - for i1, i2, i3, i4 in inds: - weight[i1:i2] += _taper_curve(coord, i1, i2, self.window_type) - weight[i3:i4] += _taper_curve(coord, i3, i4, self.window_type, reverse=True) - weight[i2:i3] += 1 - if self.invert: - weight = np.abs(weight - np.max(weight)) - return replace(self, axis=axis, weight=np.asarray(weight)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new(data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight)) - - -@dataclass(frozen=True) -class GaussianFilter(PatchOperation): - samples: bool = False - mode: str = "reflect" - cval: float = 0.0 - truncate: float = 4.0 - kwargs: dict[str, Any] | None = None - sigma: tuple[float, ...] = () - axes: tuple[int, ...] = () - - def __init__(self, samples=False, mode="reflect", cval=0.0, truncate=4.0, **kwargs): - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "mode", mode) - object.__setattr__(self, "cval", float(cval)) - object.__setattr__(self, "truncate", float(truncate)) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "sigma", ()) - object.__setattr__(self, "axes", ()) - - def bind(self, boundary: PatchBoundary): - dimfo = get_dim_axis_value(_dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True) - axes = [] - sigma = [] - for dim, axis, value in dimfo: - sigma.append(float(boundary.coord(dim).get_sample_count(value, samples=self.samples))) - axes.append(axis) - return replace(self, axes=tuple(axes), sigma=tuple(sigma)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new( - data=kernels.gaussian_filter_kernel( - patch_tree.data, sigma=self.sigma, axes=self.axes, mode=self.mode, cval=self.cval, truncate=self.truncate - ) - ) - - -@dataclass(frozen=True) -class HampelFilter(PatchOperation): - threshold: float = 10.0 - samples: bool = False - approximate: bool = True - kwargs: dict[str, Any] | None = None - size: tuple[int, ...] = () - - def __init__(self, *, threshold=10.0, samples=False, approximate=True, **kwargs): - object.__setattr__(self, "threshold", float(threshold)) - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "approximate", approximate) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "size", ()) - - def bind(self, boundary: PatchBoundary): - if self.threshold <= 0 or not np.isfinite(self.threshold): - raise ParameterError("hampel_filter threshold must be finite and greater than zero") - size = get_patch_window_size(_dummy_patch(boundary), self.kwargs or {}, self.samples, require_odd=True, warn_above=10, min_samples=3) - return replace(self, size=tuple(int(x) for x in size)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new( - data=kernels.hampel_filter_kernel( - patch_tree.data, size=self.size, threshold=self.threshold, approximate=self.approximate - ) - ) - - -@dataclass(frozen=True) -class PassFilter(PatchOperation): - corners: int = 4 - zerophase: bool = True - kwargs: dict[str, Any] | None = None - sos: Any = None - zi: Any = None - padlen: int | None = None - axis: int | None = None - - def __init__(self, corners=4, zerophase=True, **kwargs): - object.__setattr__(self, "corners", int(corners)) - object.__setattr__(self, "zerophase", bool(zerophase)) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "sos", None) - object.__setattr__(self, "zi", None) - object.__setattr__(self, "padlen", None) - object.__setattr__(self, "axis", None) - - def bind(self, boundary: PatchBoundary): - from dascore.utils.misc import check_filter_kwargs - - dim, (arg1, arg2) = check_filter_kwargs(self.kwargs or {}) - filt_min, filt_max = get_filter_units(arg1, arg2, to_unit=boundary.coord(dim).units, dim=dim) - sr = get_dim_sampling_rate(_dummy_patch(boundary), dim) - sos = np.asarray(kernels.design_pass_filter_sos(sr, filt_min, filt_max, self.corners)) - return replace( - self, - sos=sos, - zi=kernels.pass_filter_initial_state(sos), - padlen=kernels.pass_filter_default_padlen(sos), - axis=boundary.axis(dim), - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None and self.padlen is not None - return patch_tree.new( - data=kernels.pass_filter_kernel( - patch_tree.data, sos=self.sos, zi=self.zi, padlen=self.padlen, axis=self.axis, zerophase=self.zerophase - ) - ) - - -@dataclass(frozen=True) -class Pad(PatchOperation): - mode: str = "constant" - constant_values: Any = 0 - expand_coords: bool = True - samples: bool = False - kwargs: dict[str, Any] | None = None - data_pad_width: tuple[tuple[int, int], ...] = () - out_boundary: PatchBoundary | None = None - out_coords: tuple[Any, ...] | None = None - out_dtype_codes: tuple[Any, ...] | None = None - out_dims: tuple[str, ...] | None = None - - def __init__(self, mode="constant", constant_values=0, expand_coords=True, samples=False, **kwargs): - object.__setattr__(self, "mode", mode) - object.__setattr__(self, "constant_values", constant_values) - object.__setattr__(self, "expand_coords", expand_coords) - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "data_pad_width", ()) - object.__setattr__(self, "out_boundary", None) - object.__setattr__(self, "out_coords", None) - object.__setattr__(self, "out_dtype_codes", None) - object.__setattr__(self, "out_dims", None) - - def bind(self, boundary: PatchBoundary): - patch = _dummy_patch(boundary) - pad_width = [(0, 0)] * len(patch.shape) - dimfo = get_dim_axis_value(patch, kwargs=self.kwargs or {}, allow_multiple=True) - for dim, axis, value in dimfo: - coord = patch.get_coord(dim, require_evenly_sampled=False) - if value in {"fft", "correlate"}: - target_length = len(coord) if value == "fft" else 2 * len(coord) - 1 - pad_tuple = (0, next_fast_len(target_length) - len(coord)) - else: - if not isinstance(value, (tuple, list)): - value = (value, value) - pad_tuple = ( - tuple(int(coord.get_sample_count(x)) for x in value) - if not self.samples - else tuple(int(x) for x in value) - ) - pad_width[axis] = tuple(pad_tuple) - out = dc_pad.func( - patch, mode=self.mode, constant_values=self.constant_values, expand_coords=self.expand_coords, samples=self.samples, **(self.kwargs or {}) - ) - out_tree, out_boundary = _tree_boundary_from_patch(out) - return replace( - self, - data_pad_width=tuple(pad_width), - out_boundary=out_boundary, - out_coords=out_tree.coord_values, - out_dtype_codes=out_tree.coord_dtype_codes, - out_dims=out_tree.dims, - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - return patch_tree.new( - data=jnp.pad(patch_tree.data, self.data_pad_width, mode=self.mode, constant_values=self.constant_values), - coords=self.out_coords, - coord_dtype_codes=self.out_dtype_codes, - dims=self.out_dims, - ) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - _ = boundary - assert self.out_boundary is not None - return self.out_boundary - - -@dataclass(frozen=True) -class Hilbert(PatchOperation): - dim: str - axis: int | None = None - - def bind(self, boundary: PatchBoundary): - if boundary.coord(self.dim).step is None: - raise dc.exceptions.CoordError(f"Coordinate {self.dim} is not evenly sampled as required by hilbert") - return replace(self, axis=boundary.axis(self.dim)) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new(data=kernels.hilbert_kernel(patch_tree.data, axis=self.axis)) - - -@dataclass(frozen=True) -class Envelope(Hilbert): - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - return patch_tree.new(data=kernels.envelope_kernel(patch_tree.data, axis=self.axis)) - - -@dataclass(frozen=True) -class Dft(PatchOperation): - method_name: ClassVar[str | None] = "dft" - dim: str | None | tuple[str, ...] - real: str | bool | None = None - pad: bool = True - axes: tuple[int, ...] = () - dxs: tuple[float, ...] = () - real_axis: int | None = None - pad_width: tuple[tuple[int, int], ...] = () - out_boundary: PatchBoundary | None = None - out_coords: tuple[Any, ...] | None = None - out_dtype_codes: tuple[Any, ...] | None = None - out_dims: tuple[str, ...] | None = None - - def bind(self, boundary: PatchBoundary): - patch = _dummy_patch(boundary) - dims = list(iterate(self.dim if self.dim is not None else boundary.dims)) - real = dims[-1] if self.real is True else self.real - if isinstance(real, str) and real in dims: - dims.append(dims.pop(dims.index(real))) - pad_width = [(0, 0)] * len(boundary.dims) - work_patch = patch - if self.pad: - for dim in dims: - axis = work_patch.get_axis(dim) - target = next_fast_len(len(work_patch.get_coord(dim))) - pad_width[axis] = (0, target - len(work_patch.get_coord(dim))) - work_patch = dc_pad.func(work_patch, **{dim: "fft" for dim in dims}) - axes = tuple(work_patch.get_axis(dim) for dim in dims) - dxs = tuple(float(dc.to_float(work_patch.get_coord(dim).step)) for dim in dims) - out = dc_dft.func(patch, dim=self.dim, real=self.real, pad=self.pad) - out_tree, out_boundary = _tree_boundary_from_patch(out) - return replace( - self, - axes=axes, - dxs=dxs, - real_axis=work_patch.get_axis(real) if isinstance(real, str) and real in dims else None, - pad_width=tuple(pad_width), - out_boundary=out_boundary, - out_coords=out_tree.coord_values, - out_dtype_codes=out_tree.coord_dtype_codes, - out_dims=out_tree.dims, - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - data = patch_tree.data - if any(before or after for before, after in self.pad_width): - data = jnp.pad(data, self.pad_width) - data = kernels.dft_kernel(data, axes=self.axes, dxs=self.dxs, real_axis=self.real_axis) - return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - _ = boundary - assert self.out_boundary is not None - return self.out_boundary - - -@dataclass(frozen=True) -class Idft(PatchOperation): - method_name: ClassVar[str | None] = "idft" - dim: str | None | tuple[str, ...] = None - axes: tuple[int, ...] = () - steps: tuple[float, ...] = () - sizes: tuple[int, ...] | None = None - real: bool = False - out_boundary: PatchBoundary | None = None - out_coords: tuple[Any, ...] | None = None - out_dtype_codes: tuple[Any, ...] | None = None - out_dims: tuple[str, ...] | None = None - - def bind(self, boundary: PatchBoundary): - patch = _dummy_patch(boundary, dtype=np.complex128) - dims, _steps, axes, real = _get_idft_dims_steps_axis(patch, self.dim) - out = dc_idft.func(patch, dim=self.dim) - out_tree, out_boundary = _tree_boundary_from_patch(out) - sizes = tuple(out.shape[axis] for axis in axes) - new_dims = FourierTransformatter().rename_dims(dims, forward=False) - out_steps = tuple( - float(dc.to_float(out.get_coord(dim).step)) for dim in new_dims - ) - return replace( - self, - axes=tuple(axes), - steps=out_steps, - sizes=sizes, - real=real, - out_boundary=out_boundary, - out_coords=out_tree.coord_values, - out_dtype_codes=out_tree.coord_dtype_codes, - out_dims=out_tree.dims, - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - data = kernels.idft_kernel(patch_tree.data, axes=self.axes, new_steps=self.steps, sizes=self.sizes, real=self.real) - return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - _ = boundary - assert self.out_boundary is not None - return self.out_boundary - - -@dataclass(frozen=True) -class Whiten(PatchOperation): - smooth_size: float | None = None - water_level: float | None = None - kwargs: dict[str, Any] | None = None - axis: int | None = None - window_len: int | None = None - sample_step: float = 1.0 - patch_template: Any = None - - def __init__(self, smooth_size=None, water_level=None, **kwargs): - object.__setattr__(self, "smooth_size", smooth_size) - object.__setattr__(self, "water_level", water_level) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "axis", None) - object.__setattr__(self, "window_len", None) - object.__setattr__(self, "sample_step", 1.0) - object.__setattr__(self, "patch_template", None) - - def bind(self, boundary: PatchBoundary): - kwargs = self.kwargs or {} - dim = next(iter(kwargs), "time" if "time" in boundary.dims else boundary.dims[-1]) - axis = boundary.axis(dim) - sample_step = abs(float(dc.to_float(boundary.coord(dim).step))) - window_len = None - if self.smooth_size is not None: - fft_dim = FourierTransformatter().rename_dims(dim)[0] - fft_patch = dc_dft.func(_dummy_patch(boundary), dim=dim, real=True) - coord = fft_patch.get_coord(fft_dim) - window_len = coord.get_sample_count(self.smooth_size, enforce_lt_coord=True) - return replace( - self, - axis=axis, - window_len=window_len, - sample_step=sample_step, - patch_template=_dummy_patch(boundary), - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.axis is not None - source = jnp.asarray(patch_tree.data) - shape_dtype = jax.ShapeDtypeStruct(source.shape, source.dtype) - - def _callback(data): - patch = self.patch_template.new(data=np.asarray(data)) - kwargs = self.kwargs or {} - return np.asarray( - patch.whiten.func( - patch, - smooth_size=self.smooth_size, - water_level=self.water_level, - **kwargs, - ).data - ) - - return patch_tree.new(data=jax.pure_callback(_callback, shape_dtype, source)) - - -@dataclass(frozen=True) -class Fbe(PatchOperation): - overlap: Any = 0 - samples: bool = False - detrend: bool = False - taper_window: str | np.ndarray | tuple = "hann" - fmin: float | None = None - fmax: float | None = None - kwargs: dict[str, Any] | None = None - prepared: dict[str, Any] | None = None - out_boundary: PatchBoundary | None = None - out_coords: tuple[Any, ...] | None = None - out_dtype_codes: tuple[Any, ...] | None = None - out_dims: tuple[str, ...] | None = None - - def __init__(self, overlap=0, samples=False, detrend=False, taper_window="hann", fmin=None, fmax=None, **kwargs): - object.__setattr__(self, "overlap", overlap) - object.__setattr__(self, "samples", samples) - object.__setattr__(self, "detrend", detrend) - object.__setattr__(self, "taper_window", taper_window) - object.__setattr__(self, "fmin", fmin) - object.__setattr__(self, "fmax", fmax) - object.__setattr__(self, "kwargs", dict(kwargs)) - object.__setattr__(self, "prepared", None) - object.__setattr__(self, "out_boundary", None) - object.__setattr__(self, "out_coords", None) - object.__setattr__(self, "out_dtype_codes", None) - object.__setattr__(self, "out_dims", None) - - def bind(self, boundary: PatchBoundary): - patch = _dummy_patch(boundary) - call_kwargs = dict(self.kwargs or {}) - dim, axis, val = get_dim_axis_value(patch, kwargs=call_kwargs)[0] - coord = patch.get_coord(dim, require_evenly_sampled=True) - window_samples = coord.get_sample_count(val, samples=self.samples, enforce_lt_coord=True) - step = dc.to_float(coord.step) - sampling_rate = 1 / abs(step) - window = self.taper_window if isinstance(self.taper_window, np.ndarray) else get_window(self.taper_window, window_samples, fftbins=False) - overlap = coord[:window_samples].get_sample_count(self.overlap, samples=self.samples, enforce_lt_coord=True) if self.overlap is not None else 0 - hop = window_samples - overlap - stft = ShortTimeFFT(win=window, hop=hop, fs=sampling_rate, fft_mode="onesided", mfft=window_samples) - frame_times = np.asarray(stft.t(len(coord))) - frame_starts = np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid - frequencies = np.asarray(stft.f, dtype=np.float64) - mask = np.ones(len(frequencies), dtype=bool) - if self.fmin is not None: - mask &= frequencies >= self.fmin - if self.fmax is not None: - mask &= frequencies <= self.fmax - prepared = { - "axis": axis, - "window": np.asarray(window), - "frame_starts": frame_starts, - "selected_bins": np.flatnonzero(mask).astype(np.int64), - "sample_step": step, - "detrend": self.detrend, - } - # Reuse the existing DASCore STFT metadata construction by running on zeros. - out = patch.stft(**{dim: val}, overlap=self.overlap, samples=self.samples, detrend=self.detrend, taper_window=self.taper_window).abs() - ft_dim = next(dim_name for dim_name in out.dims if dim_name.startswith("ft_")) - if self.fmin is not None or self.fmax is not None: - out = out.select(**{ft_dim: (self.fmin, self.fmax)}) - out = out.sum(dim=ft_dim, dim_reduce="squeeze") - out_tree, out_boundary = _tree_boundary_from_patch(out) - return replace( - self, - prepared=prepared, - out_boundary=out_boundary, - out_coords=out_tree.coord_values, - out_dtype_codes=out_tree.coord_dtype_codes, - out_dims=out_tree.dims, - ) - - def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: - assert self.prepared is not None - data = kernels.banded_stft_kernel(patch_tree.data, **self.prepared) - return patch_tree.new(data=data, coords=self.out_coords, coord_dtype_codes=self.out_dtype_codes, dims=self.out_dims) - - def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: - _ = boundary - assert self.out_boundary is not None - return self.out_boundary +from .operations import * # noqa: F403 diff --git a/src/dasjax/kernels/__init__.py b/src/dasjax/kernels/__init__.py index c7423de..216c57a 100644 --- a/src/dasjax/kernels/__init__.py +++ b/src/dasjax/kernels/__init__.py @@ -15,15 +15,30 @@ scale_kernel, standardize_kernel, ) +from .domain import ( + apply_mask_kernel, + dispersion_phase_shift_kernel, + phase_weighted_stack_kernel, + radians_to_strain_kernel, + slope_filter_kernel, + tau_p_kernel, + velocity_to_strain_rate_edgeless_kernel, +) from .filters import ( + design_notch_filter, design_pass_filter_sos, gaussian_filter_kernel, - hampel_filter_callback_kernel, hampel_filter_kernel, is_finite_array, + median_filter_kernel, + notch_filter_kernel, pass_filter_default_padlen, pass_filter_initial_state, pass_filter_kernel, + savgol_coefficients, + savgol_filter_kernel, + sobel_filter_kernel, + wiener_filter_kernel, ) from .signal import ( detrend_kernel, @@ -34,10 +49,12 @@ ) from .spectral import ( banded_stft_kernel, + correlate_shift_kernel, dft_kernel, envelope_kernel, hilbert_kernel, idft_kernel, + whiten_spectrum_kernel, whiten_kernel, ) @@ -46,17 +63,20 @@ "add_kernel", "angle_kernel", "apply_1d_weight_kernel", + "apply_mask_kernel", "banded_stft_kernel", "clip_kernel", "conj_kernel", + "correlate_shift_kernel", + "design_notch_filter", "design_pass_filter_sos", "detrend_kernel", "differentiate_kernel", "dft_kernel", + "dispersion_phase_shift_kernel", "envelope_kernel", "flip_kernel", "gaussian_filter_kernel", - "hampel_filter_callback_kernel", "hampel_filter_kernel", "hilbert_kernel", "identity_kernel", @@ -64,14 +84,26 @@ "imag_kernel", "integrate_kernel", "is_finite_array", + "median_filter_kernel", + "notch_filter_kernel", "normalize_kernel", "pass_filter_default_padlen", "pass_filter_initial_state", "pass_filter_kernel", + "phase_weighted_stack_kernel", + "radians_to_strain_kernel", "real_kernel", "roll_kernel", "scale_kernel", + "savgol_coefficients", + "savgol_filter_kernel", + "slope_filter_kernel", + "sobel_filter_kernel", "standardize_kernel", + "tau_p_kernel", "validate_detrend_type", + "velocity_to_strain_rate_edgeless_kernel", "whiten_kernel", + "whiten_spectrum_kernel", + "wiener_filter_kernel", ] diff --git a/src/dasjax/kernels/domain.py b/src/dasjax/kernels/domain.py new file mode 100644 index 0000000..125cd66 --- /dev/null +++ b/src/dasjax/kernels/domain.py @@ -0,0 +1,150 @@ +"""Domain-specific transform kernels.""" + +from __future__ import annotations + +from typing import Any + +import jax +import jax.numpy as jnp + +from .spectral import dft_kernel, hilbert_kernel, idft_kernel + + +def apply_mask_kernel(data: Any, mask: Any) -> Any: + """Apply a static broadcastable mask to data.""" + return jnp.asarray(data) * jnp.asarray(mask, dtype=jnp.asarray(data).dtype) + + +def slope_filter_kernel( + data: Any, + *, + axes: tuple[int, int], + dxs: tuple[float, float], + mask: Any, + steps: tuple[float, float], + sizes: tuple[int, int], + pad_width: tuple[tuple[int, int], ...] = (), +) -> Any: + """Apply a 2-D slope/FK filter and return to the input domain.""" + arr = jnp.asarray(data) + orig_shape = arr.shape + if pad_width: + arr = jnp.pad(arr, pad_width) + spectrum = dft_kernel(arr, axes=axes, dxs=dxs, real_axis=None) + filtered = spectrum * jnp.asarray(mask, dtype=spectrum.dtype) + out = idft_kernel(filtered, axes=axes, new_steps=steps, sizes=sizes, real=False) + if pad_width: + slices = tuple(slice(0, size) for size in orig_shape) + out = out[slices] + return jnp.real(out) + + +def phase_weighted_stack_kernel( + data: Any, + *, + stack_axis: int, + transform_axis: int, + power: float, + squeeze: bool, +) -> Any: + """Apply phase-weighted stacking over one axis.""" + arr = jnp.asarray(data) + analytic = hilbert_kernel(arr, axis=transform_axis) + eps = jnp.finfo(analytic.real.dtype).eps + amp = jnp.maximum(jnp.abs(analytic), eps) + unit_phasors = analytic / amp + mean_phasor = jnp.mean(unit_phasors, axis=stack_axis, keepdims=True) + weights = jnp.abs(mean_phasor) ** power + out = jnp.mean(arr, axis=stack_axis, keepdims=True) * weights + return jnp.squeeze(out, axis=stack_axis) if squeeze else out + + +def velocity_to_strain_rate_edgeless_kernel( + data: Any, + *, + axis: int, + step_multiple: int, + gauge_length: float, +) -> Any: + """Estimate edgeless strain rate with central differences.""" + arr = jnp.asarray(data) + moved = jnp.moveaxis(arr, axis, 0) + out = (moved[step_multiple:] - moved[:-step_multiple]) / gauge_length + return jnp.moveaxis(out, 0, axis) + + +def radians_to_strain_kernel(data: Any, factor: float) -> Any: + """Scale radians data into strain units.""" + return jnp.asarray(data) * factor + + +def _interp_along_time(row: jnp.ndarray, sample: jnp.ndarray) -> jnp.ndarray: + """Linearly interpolate one trace at fractional sample positions.""" + nt = row.shape[0] + idx = jnp.floor(sample).astype(jnp.int32) + valid = (idx >= 0) & (idx + 1 < nt) + idx_clip = jnp.clip(idx, 0, max(nt - 2, 0)) + frac = sample - idx + vals = (1.0 - frac) * row[idx_clip] + frac * row[idx_clip + 1] + return jnp.where(valid, vals, 0) + + +def tau_p_kernel( + data: Any, + *, + distances: Any, + dt: float, + p_values: Any, +) -> Any: + """Compute a linear tau-p transform using JAX interpolation.""" + arr = jnp.asarray(data) + distances = jnp.asarray(distances, dtype=arr.real.dtype) + distances = distances - distances[0] + p_vals = jnp.asarray(p_values, dtype=arr.real.dtype) + nt = arr.shape[1] + taus = jnp.arange(nt, dtype=arr.real.dtype) + + def _positive(p): + samples = taus[None, :] + (p * distances[:, None] / dt) + vals = jax.vmap(_interp_along_time)(arr, samples) + return jnp.sum(vals, axis=0) + + def _negative(p): + rev_arr = arr[::-1] + rev_dist = distances[-1] - distances[::-1] + samples = taus[None, :] + (p * rev_dist[:, None] / dt) + vals = jax.vmap(_interp_along_time)(rev_arr, samples) + return jnp.sum(vals, axis=0) + + pos = jax.vmap(_positive)(p_vals) + neg = jax.vmap(_negative)(p_vals)[::-1] + return jnp.concatenate([neg, pos], axis=0) + + +def dispersion_phase_shift_kernel( + data: Any, + *, + distances: Any, + velocities: Any, + nf: int, + first_live_f: int, + last_live_f: int, + fs: float, +) -> Any: + """Compute a phase-shift dispersion image.""" + arr = jnp.asarray(data) + dist = jnp.asarray(distances, dtype=arr.real.dtype) + velocities = jnp.asarray(velocities, dtype=arr.real.dtype) + freqs = jnp.arange(nf, dtype=arr.real.dtype) * fs / (nf - 1) + omega = 2 * jnp.pi * freqs + fft_d = jnp.fft.fft(arr, n=nf, axis=1) + amp = jnp.abs(fft_d) + fft_d = jnp.where(amp != 0, fft_d / amp, 0) + omega_live = omega[first_live_f:last_live_f] + fft_live = fft_d[:, first_live_f:last_live_f] + preamb = 1j * dist[:, None] * omega_live[None, :] + + def _velocity_row(velocity): + return jnp.abs(jnp.sum(jnp.exp(preamb / velocity) * fft_live, axis=0)) + + return jax.vmap(_velocity_row)(velocities) / arr.shape[0] diff --git a/src/dasjax/kernels/filters.py b/src/dasjax/kernels/filters.py index 58fe0a6..b671a46 100644 --- a/src/dasjax/kernels/filters.py +++ b/src/dasjax/kernels/filters.py @@ -1,4 +1,4 @@ -"""Filter kernels and callback-backed helpers.""" +"""Filter kernels.""" from __future__ import annotations @@ -10,9 +10,14 @@ import numpy as np import pandas as pd from dascore.exceptions import FilterValueError -from scipy import ndimage -from scipy.ndimage import median_filter as scipy_median_filter -from scipy.signal import iirfilter, sosfilt_zi, zpk2sos +from scipy.signal import ( + iirfilter, + iirnotch, + lfilter_zi, + savgol_coeffs, + sosfilt_zi, + zpk2sos, +) def is_finite_array(data: Any) -> bool: @@ -29,25 +34,110 @@ def gaussian_filter_kernel( cval: float = 0.0, truncate: float = 4.0, ) -> Any: - """Apply a Gaussian filter with SciPy-compatible semantics.""" - # Gaussian filtering still relies on SciPy's exact implementation semantics. + """Apply a separable Gaussian filter with JAX-native operations.""" arr = jnp.asarray(data) - # The callback result shape/dtype is identical to the source array. - shape_dtype = jax.ShapeDtypeStruct(arr.shape, arr.dtype) - return jax.pure_callback( - lambda x: ndimage.gaussian_filter( - # Force a private NumPy copy so SciPy can mutate internally if needed. - np.array(x, copy=True), - sigma=sigma, + if not sigma or not axes: + return arr + out = arr + for axis, sigma_value in zip(axes, sigma, strict=True): + out = _gaussian_filter_axis( + out, + sigma=float(sigma_value), + axis=int(axis), mode=mode, cval=cval, truncate=truncate, - axes=axes, - ), - shape_dtype, - arr, - vmap_method="sequential", - ) + ) + return out + + +def _gaussian_filter_axis( + data: jnp.ndarray, + *, + sigma: float, + axis: int, + mode: str, + cval: float, + truncate: float, +) -> jnp.ndarray: + """Apply one static 1D Gaussian pass along an axis.""" + if sigma <= 0: + return data + radius = int(truncate * sigma + 0.5) + if radius == 0: + return data + x = jnp.arange(-radius, radius + 1, dtype=data.real.dtype) + weights = jnp.exp(-0.5 / (sigma * sigma) * x * x) + weights = weights / jnp.sum(weights) + moved = jnp.moveaxis(data, axis, -1) + flat = moved.reshape(-1, moved.shape[-1]) + padded = _pad_gaussian_axis(flat, radius=radius, mode=mode, cval=cval) + + def _convolve(row: jnp.ndarray) -> jnp.ndarray: + return jnp.convolve(row, weights, mode="valid") + + filtered = jax.vmap(_convolve)(padded) + return jnp.moveaxis(filtered.reshape(moved.shape), -1, axis) + + +def _pad_gaussian_axis( + data: jnp.ndarray, + *, + radius: int, + mode: str, + cval: float, +) -> jnp.ndarray: + """Pad flattened rows with SciPy ndimage-compatible mode names.""" + pad_width = ((0, 0), (radius, radius)) + if mode == "reflect": + return jnp.pad(data, pad_width, mode="symmetric") + if mode == "nearest": + return jnp.pad(data, pad_width, mode="edge") + if mode == "constant": + return jnp.pad(data, pad_width, mode="constant", constant_values=cval) + if mode == "wrap": + return jnp.pad(data, pad_width, mode="wrap") + if mode == "mirror": + return jnp.pad(data, pad_width, mode="reflect") + msg = f"Unsupported gaussian_filter mode {mode!r}." + raise ValueError(msg) + + +def _normalize_filter_mode(mode: str) -> str: + """Normalize SciPy ndimage-style mode aliases.""" + aliases = { + "grid-constant": "constant", + "grid-mirror": "reflect", + "grid-wrap": "wrap", + } + return aliases.get(mode, mode) + + +def _pad_axis( + data: jnp.ndarray, + *, + axis: int, + before: int, + after: int, + mode: str, + cval: float = 0.0, +) -> jnp.ndarray: + """Pad one axis with SciPy ndimage-compatible mode names.""" + pad_width = [(0, 0)] * data.ndim + pad_width[axis] = (before, after) + mode = _normalize_filter_mode(mode) + if mode == "reflect": + return jnp.pad(data, tuple(pad_width), mode="symmetric") + if mode == "nearest": + return jnp.pad(data, tuple(pad_width), mode="edge") + if mode == "constant": + return jnp.pad(data, tuple(pad_width), mode="constant", constant_values=cval) + if mode == "wrap": + return jnp.pad(data, tuple(pad_width), mode="wrap") + if mode == "mirror": + return jnp.pad(data, tuple(pad_width), mode="reflect") + msg = f"Unsupported filter mode {mode!r}." + raise ValueError(msg) def _sliding_windows_last_axis(data: jnp.ndarray, window: int) -> jnp.ndarray: @@ -69,88 +159,90 @@ def _slice_at(idx: jnp.ndarray) -> jnp.ndarray: return jnp.swapaxes(windows, 0, 1) -def _median_filter_axis(data: jnp.ndarray, axis: int, window: int) -> jnp.ndarray: - # Reduce the target axis to the last position so the window helper can be reused. - moved = jnp.moveaxis(data, axis, -1) - flat = moved.reshape(-1, moved.shape[-1]) - windows = _sliding_windows_last_axis(flat, window) - # Sorting the small window and taking the center reproduces a median. - med = jnp.sort(windows, axis=-1)[..., window // 2] - restored = med.reshape(moved.shape) - return jnp.moveaxis(restored, -1, axis) +def _sliding_windows_nd( + data: jnp.ndarray, + size: tuple[int, ...], + out_shape: tuple[int, ...], +) -> jnp.ndarray: + """Return flattened N-D windows for every unpadded output element.""" + out_size = int(np.prod(out_shape)) + starts = jnp.stack(jnp.unravel_index(jnp.arange(out_size), out_shape), axis=1) + def _slice_at(start: jnp.ndarray) -> jnp.ndarray: + return lax.dynamic_slice(data, tuple(start), size).reshape(-1) -def _median_filter_exact_callback( - data: np.ndarray, size: tuple[int, ...] -) -> np.ndarray: - return scipy_median_filter(data, size=size, mode="reflect") + return jax.vmap(_slice_at)(starts).reshape(*out_shape, int(np.prod(size))) -def _median_filter_exact(data: jnp.ndarray, size: tuple[int, ...]) -> jnp.ndarray: - # The exact multidimensional SciPy median is still callback-backed. - shape_dtype = jax.ShapeDtypeStruct(data.shape, data.dtype) - return jax.pure_callback( - lambda x: _median_filter_exact_callback(x, size), - shape_dtype, +def _window_sum_kernel(data: jnp.ndarray, size: tuple[int, ...]) -> jnp.ndarray: + """Sum zero-padded local windows in SciPy signal-correlate style.""" + before = tuple(window // 2 for window in size) + after = tuple(window - 1 - pad for window, pad in zip(size, before, strict=True)) + return lax.reduce_window( data, - vmap_method="sequential", + jnp.asarray(0, dtype=data.dtype), + lax.add, + window_dimensions=tuple(int(x) for x in size), + window_strides=(1,) * data.ndim, + padding=tuple(zip(before, after, strict=True)), ) -def hampel_filter_callback_kernel( +def median_filter_kernel( data: Any, size: tuple[int, ...], - threshold: float, - approximate: bool = True, + mode: str = "reflect", + cval: float = 0.0, ) -> Any: - """Apply Hampel filtering via SciPy-compatible host callback.""" - source = jnp.asarray(data) - # The callback preserves both shape and dtype of the incoming array. - shape_dtype = jax.ShapeDtypeStruct(source.shape, source.dtype) - - def _callback(x: np.ndarray) -> np.ndarray: - original = np.asarray(x) - is_int = original.dtype.kind in {"i", "u"} - # Integer inputs are promoted for robust MAD math, then cast back on exit. - work = original.copy() if not is_int else original.astype(np.float32) - if approximate: - # Approximate mode applies separable 1D median filters per axis. - med = np.empty_like(work) - np.copyto(med, work) - for axis, window in enumerate(size): - if window > 1: - filtered = scipy_median_filter( - med, - size=tuple(1 if i != axis else window for i in range(med.ndim)), - mode="reflect", - ) - np.copyto(med, filtered) - abs_diff = np.abs(work - med) - # Reuse the same separable strategy for the MAD estimate. - mad = np.empty_like(abs_diff) - np.copyto(mad, abs_diff) - for axis, window in enumerate(size): - if window > 1: - filtered = scipy_median_filter( - mad, - size=tuple(1 if i != axis else window for i in range(mad.ndim)), - mode="reflect", - ) - np.copyto(mad, filtered) - else: - # Exact mode delegates the full multidimensional median to SciPy. - med = scipy_median_filter(work, size=size, mode="reflect") - abs_diff = np.abs(work - med) - mad = scipy_median_filter(abs_diff, size=size, mode="reflect") - # Replace zeros to avoid divide-by-zero when a local window is constant. - mad_safe = np.where(mad == 0.0, np.finfo(work.dtype).eps, mad) - out = np.where(abs_diff / mad_safe > threshold, med, work) - if is_int: - # Integer inputs round back to the nearest representable sample value. - out = np.rint(out) - return out.astype(original.dtype, copy=False) - - return jax.pure_callback(_callback, shape_dtype, source, vmap_method="sequential") + """Apply an exact N-D median filter with JAX-native windows.""" + arr = jnp.asarray(data) + if all(window == 1 for window in size): + return arr + before = tuple(window // 2 for window in size) + after = tuple(window - 1 - pad for window, pad in zip(size, before, strict=True)) + padded = arr + for axis, (left, right) in enumerate(zip(before, after, strict=True)): + if left or right: + padded = _pad_axis( + padded, + axis=axis, + before=left, + after=right, + mode=mode, + cval=cval, + ) + windows = _sliding_windows_nd(padded, tuple(int(x) for x in size), tuple(arr.shape)) + return jnp.sort(windows, axis=-1)[..., windows.shape[-1] // 2] + + +def wiener_filter_kernel( + data: Any, + size: tuple[int, ...], + noise: float | None = None, +) -> Any: + """Apply an N-D Wiener filter matching SciPy's local-statistic formula.""" + arr = jnp.asarray(data) + window_size = float(np.prod(size)) + local_mean = _window_sum_kernel(arr, size) / window_size + local_var = ( + _window_sum_kernel(arr * arr, size) / window_size - local_mean * local_mean + ) + noise_value = ( + jnp.mean(local_var) if noise is None else jnp.asarray(noise, dtype=arr.dtype) + ) + res = (arr - local_mean) * (1 - noise_value / local_var) + local_mean + return jnp.where(local_var < noise_value, local_mean, res) + + +def _median_filter_axis(data: jnp.ndarray, axis: int, window: int) -> jnp.ndarray: + # Reduce the target axis to the last position so the window helper can be reused. + moved = jnp.moveaxis(data, axis, -1) + flat = moved.reshape(-1, moved.shape[-1]) + windows = _sliding_windows_last_axis(flat, window) + # Sorting the small window and taking the center reproduces a median. + med = jnp.sort(windows, axis=-1)[..., window // 2] + restored = med.reshape(moved.shape) + return jnp.moveaxis(restored, -1, axis) def hampel_filter_kernel( @@ -160,28 +252,25 @@ def hampel_filter_kernel( approximate: bool = True, ) -> Any: """Apply a Hampel filter with a native JAX approximate path.""" + if not approximate: + msg = "Exact Hampel median filtering is not implemented in pure JAX." + raise NotImplementedError(msg) source = jnp.asarray(data) is_int = jnp.issubdtype(source.dtype, jnp.integer) - # Mirror the callback path by promoting integers before the MAD computation. + # Promote integers before robust MAD math, then cast back on exit. compute_dtype = jnp.float32 if is_int else source.dtype work = source.astype(compute_dtype) - if approximate: - # Separable medians keep the kernel JAX-native and reasonably cheap. - med = work - for axis, window in enumerate(size): - if window > 1: - med = _median_filter_axis(med, axis, window) - abs_diff = jnp.abs(work - med) - mad = abs_diff - # Apply the same separable median strategy to absolute deviations. - for axis, window in enumerate(size): - if window > 1: - mad = _median_filter_axis(mad, axis, window) - else: - # The exact path falls back to the SciPy callback helper above. - med = _median_filter_exact(work, size) - abs_diff = jnp.abs(work - med) - mad = _median_filter_exact(abs_diff, size) + # Separable medians keep the kernel JAX-native and reasonably cheap. + med = work + for axis, window in enumerate(size): + if window > 1: + med = _median_filter_axis(med, axis, window) + abs_diff = jnp.abs(work - med) + mad = abs_diff + # Apply the same separable median strategy to absolute deviations. + for axis, window in enumerate(size): + if window > 1: + mad = _median_filter_axis(mad, axis, window) # Protect constant windows from generating infinities. mad_safe = jnp.where(mad == 0.0, jnp.finfo(work.dtype).eps, mad) out = jnp.where(abs_diff / mad_safe > threshold, med, work) @@ -191,6 +280,235 @@ def hampel_filter_kernel( return out +def sobel_filter_kernel( + data: Any, + axis: int, + mode: str = "reflect", + cval: float = 0.0, +) -> Any: + """Apply a SciPy-compatible Sobel filter along one axis.""" + arr = jnp.asarray(data) + out = arr + for dim_axis in range(arr.ndim): + weights = ( + jnp.asarray([-1.0, 0.0, 1.0], dtype=arr.dtype) + if dim_axis == axis + else jnp.asarray([1.0, 2.0, 1.0], dtype=arr.dtype) + ) + out = _correlate1d_kernel(out, weights, axis=dim_axis, mode=mode, cval=cval) + return out + + +def _correlate1d_kernel( + data: jnp.ndarray, + weights: jnp.ndarray, + *, + axis: int, + mode: str, + cval: float, +) -> jnp.ndarray: + """Apply 1-D correlation over one axis.""" + radius = weights.shape[0] // 2 + padded = _pad_axis( + data, + axis=axis, + before=radius, + after=radius, + mode=mode, + cval=cval, + ) + moved = jnp.moveaxis(padded, axis, -1) + flat = moved.reshape(-1, moved.shape[-1]) + + def _correlate(row: jnp.ndarray) -> jnp.ndarray: + return jnp.convolve(row, weights[::-1], mode="valid") + + filtered = jax.vmap(_correlate)(flat) + out_shape = (*moved.shape[:-1], data.shape[axis]) + return jnp.moveaxis(filtered.reshape(out_shape), -1, axis) + + +def _savgol_filter_axis( + data: jnp.ndarray, + *, + axis: int, + coeffs: Any, + left_coeffs: Any, + right_coeffs: Any, + mode: str, + cval: float, +) -> jnp.ndarray: + """Apply one Savitzky-Golay filter pass along an axis.""" + coeff_arr = jnp.asarray(coeffs, dtype=data.dtype) + window = int(coeff_arr.shape[0]) + half = window // 2 + moved = jnp.moveaxis(data, axis, -1) + flat = moved.reshape(-1, moved.shape[-1]) + if flat.shape[1] < window: + msg = "savgol_filter window_length must be less than or equal to axis length." + raise ValueError(msg) + + def _valid_convolve(row: jnp.ndarray) -> jnp.ndarray: + return jnp.convolve(row, coeff_arr, mode="valid") + + middle = jax.vmap(_valid_convolve)(flat) + if mode == "interp": + left = jnp.einsum( + "hw,rw->rh", jnp.asarray(left_coeffs, dtype=data.dtype), flat[:, :window] + ) + right = jnp.einsum( + "hw,rw->rh", jnp.asarray(right_coeffs, dtype=data.dtype), flat[:, -window:] + ) + out_flat = jnp.concatenate([left, middle, right], axis=1) + else: + padded = _pad_axis( + flat, + axis=1, + before=half, + after=half, + mode=mode, + cval=cval, + ) + out_flat = jax.vmap(_valid_convolve)(padded) + return jnp.moveaxis(out_flat.reshape(moved.shape), -1, axis) + + +def savgol_filter_kernel( + data: Any, + size: tuple[int, ...], + axes: tuple[int, ...], + coeffs: tuple[Any, ...], + left_coeffs: tuple[Any, ...], + right_coeffs: tuple[Any, ...], + mode: str = "interp", + cval: float = 0.0, +) -> Any: + """Apply Savitzky-Golay filters sequentially along requested axes.""" + out = jnp.asarray(data) + for axis, coeff, left, right in zip( + axes, coeffs, left_coeffs, right_coeffs, strict=True + ): + _ = size + out = _savgol_filter_axis( + out, + axis=axis, + coeffs=coeff, + left_coeffs=left, + right_coeffs=right, + mode=mode, + cval=cval, + ) + return out + + +def savgol_coefficients( + window_length: int, polyorder: int +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Return center and interp-edge Savitzky-Golay coefficients.""" + coeff = np.asarray( + savgol_coeffs(window_length, polyorder, use="conv"), dtype=np.float64 + ) + half = window_length // 2 + left = np.asarray( + [ + savgol_coeffs(window_length, polyorder, pos=idx, use="dot") + for idx in range(half) + ], + dtype=np.float64, + ) + right = np.asarray( + [ + savgol_coeffs(window_length, polyorder, pos=idx, use="dot") + for idx in range(window_length - half, window_length) + ], + dtype=np.float64, + ) + return coeff, left, right + + +def design_notch_filter( + sr: float, + w0: float, + q: float, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, int]: + """Design a second-order notch filter and return filtfilt parameters.""" + nyquist = 0.5 * sr + if w0 > nyquist: + msg = f"possible filter values are in [0, {nyquist}] you passed {w0}" + raise FilterValueError(msg) + b, a = iirnotch(w0, Q=q, fs=sr) + zi = lfilter_zi(b, a) + padlen = 3 * max(len(a), len(b)) + return ( + np.asarray(b, dtype=np.float64), + np.asarray(a, dtype=np.float64), + np.asarray(zi, dtype=np.float64), + padlen, + ) + + +def _iirfilt_rows( + flat: jnp.ndarray, + b: jnp.ndarray, + a: jnp.ndarray, + zi_rows: jnp.ndarray | None = None, +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Apply one direct-form II IIR filter to flattened rows.""" + b = b / a[0] + a = a / a[0] + if zi_rows is None: + states = jnp.zeros((flat.shape[0], b.shape[0] - 1), dtype=flat.dtype) + else: + states = zi_rows + + def _sample_step(carry: jnp.ndarray, x_t: jnp.ndarray): + y = b[0] * x_t + carry[:, 0] + new_states = [] + for idx in range(1, b.shape[0] - 1): + new_states.append(b[idx] * x_t - a[idx] * y + carry[:, idx]) + new_states.append(b[-1] * x_t - a[-1] * y) + return jnp.stack(new_states, axis=1), y + + final_states, ys = lax.scan(_sample_step, states, flat.T) + return ys.T, final_states + + +def notch_filter_kernel( + data: Any, + b: Any, + a: Any, + zi: Any, + padlen: int, + axis: int, +) -> Any: + """Apply a zero-phase second-order notch filter.""" + arr = jnp.asarray(data) + moved = jnp.moveaxis(arr, axis, -1) + flat = moved.reshape(-1, moved.shape[-1]) + edge = int(padlen) + if edge > 0 and flat.shape[1] <= edge: + msg = ( + f"The length of the input vector x must be greater than padlen, " + f"which is {edge}." + ) + raise ValueError(msg) + ext = _odd_ext_last_axis(flat, edge) + b_arr = jnp.asarray(b, dtype=arr.dtype) + a_arr = jnp.asarray(a, dtype=arr.dtype) + zi_arr = jnp.asarray(zi, dtype=arr.dtype) + zi_rows = jnp.broadcast_to(zi_arr[None, :], (ext.shape[0], zi_arr.shape[0])) + x0 = ext[:, :1] + y_flat, _ = _iirfilt_rows(ext, b_arr, a_arr, zi_rows=zi_rows * x0) + y0 = y_flat[:, -1:] + y_rev = jnp.flip(y_flat, axis=1) + y2_flat, _ = _iirfilt_rows(y_rev, b_arr, a_arr, zi_rows=zi_rows * y0) + out_flat = jnp.flip(y2_flat, axis=1) + if edge > 0: + out_flat = out_flat[:, edge:-edge] + out = out_flat.reshape(moved.shape) + return jnp.moveaxis(out, -1, axis) + + def design_pass_filter_sos( sr: float, filt_min: float | None, diff --git a/src/dasjax/kernels/spectral.py b/src/dasjax/kernels/spectral.py index e15bb0d..47e06cd 100644 --- a/src/dasjax/kernels/spectral.py +++ b/src/dasjax/kernels/spectral.py @@ -56,7 +56,7 @@ def dft_kernel( """Apply a scaled DFT over one or more axes.""" arr = jnp.asarray(data) # Multiply by sample spacing so forward and inverse transforms stay consistent. - scale_factor = np.prod(dxs) + scale_factor = jnp.asarray(np.prod(dxs), dtype=arr.real.dtype) if real_axis is None: fft_data = jnp.fft.fftn(arr, axes=axes) * scale_factor # Shift zero frequency to the center on fully complex transforms. @@ -78,7 +78,7 @@ def idft_kernel( """Apply a scaled inverse DFT over one or more axes.""" arr = jnp.asarray(data) # Undo the forward scaling using the frequency-domain step sizes. - scale_factor = np.prod(new_steps) + scale_factor = jnp.asarray(np.prod(new_steps), dtype=arr.real.dtype) if real: real_axis = axes[-1] # Only the non-rfft axes were shifted in the forward real transform. @@ -127,6 +127,29 @@ def whiten_kernel( fft_data = jnp.fft.rfft(moved, axis=-1) else: fft_data = jnp.fft.fft(moved, axis=-1) + phase_only = whiten_spectrum_kernel( + fft_data, + axis=-1, + window_len=window_len, + water_level=water_level, + freq_weight=freq_weight, + ) + if is_real: + out = jnp.fft.irfft(phase_only, n=moved.shape[-1], axis=-1) + else: + out = jnp.fft.ifft(phase_only, axis=-1) + return jnp.moveaxis(out, -1, axis) + + +def whiten_spectrum_kernel( + data: Any, + axis: int, + window_len: int | None = None, + water_level: float | None = None, + freq_weight: Any | None = None, +) -> Any: + """Whiten already transformed frequency-domain data.""" + fft_data = jnp.moveaxis(jnp.asarray(data), axis, -1) amp = jnp.abs(fft_data) if window_len is None: # The unsmoothed case is straight phase-only whitening. @@ -136,7 +159,7 @@ def whiten_kernel( env = _uniform_wrap_kernel(amp, window_len) if water_level is not None: # Water-level clipping prevents deep spectral notches from exploding. - min_level = water_level * jnp.max(env, axis=-1, keepdims=True) + min_level = water_level * jnp.max(env) env = jnp.maximum(env, min_level) norm_amp = jnp.where(env != 0, env, 1) phase_only = fft_data / norm_amp @@ -145,11 +168,18 @@ def whiten_kernel( phase_only = apply_1d_weight_kernel( phase_only, axis=phase_only.ndim - 1, weight=freq_weight ) - if is_real: - out = jnp.fft.irfft(phase_only, n=moved.shape[-1], axis=-1) - else: - out = jnp.fft.ifft(phase_only, axis=-1) - return jnp.moveaxis(out, -1, axis) + return jnp.moveaxis(phase_only, -1, axis) + + +def correlate_shift_kernel( + data: Any, + axis: int, + step: float, + undo_weighting: bool = True, +) -> Any: + """Shift correlation lags back to centered order.""" + out = jnp.fft.fftshift(jnp.asarray(data), axes=axis) + return out / step if undo_weighting else out def _extract_zero_padded_frames( diff --git a/src/dasjax/operations/__init__.py b/src/dasjax/operations/__init__.py new file mode 100644 index 0000000..ff537a5 --- /dev/null +++ b/src/dasjax/operations/__init__.py @@ -0,0 +1,160 @@ +"""Registered patch operations grouped by DASCore operation domain.""" + +from __future__ import annotations + +from .basic import ( + Abs, + Add, + Aggregate, + Angle, + All, + AnyOp, + Clip, + Conj, + Divide, + Exp, + FillNa, + Flip, + Identity, + Imag, + IsFinite, + IsInf, + IsNan, + Log, + Log10, + Log2, + Max, + Maximum, + Mean, + Median, + Min, + Minimum, + Multiply, + Real, + Roll, + Scale, + Standardize, + Std, + Subtract, + Sum, + Where, +) +from .detrend import Detrend +from .correlate import CorrelateShift +from .dispersion import DispersionPhaseShift +from .normalize import Normalize +from .differentiate import Differentiate +from .integrate import Integrate +from .taper import Taper, TaperRange +from .filter import ( + GaussianFilter, + HampelFilter, + MedianFilter, + NotchFilter, + PassFilter, + SavgolFilter, + SobelFilter, + SlopeFilter, + WienerFilter, +) +from .mute import LineMute, SlopeMute +from .pad import Pad +from .hilbert import Envelope, Hilbert, PhaseWeightedStack +from .fourier import Dft, Idft +from .whiten import Whiten +from .spectro import Fbe +from .strain import ( + RadiansToStrain, + VelocityToStrainRate, + VelocityToStrainRateEdgeless, +) +from .taup import TauP +from .numeric import ( + Correlate, + Decimate, + Interpolate, + Iresample, + Istft, + Resample, + Rfft, + Spectrogram, + Stft, +) + +__all__ = [ + "Abs", + "Add", + "Aggregate", + "All", + "Angle", + "AnyOp", + "Clip", + "Conj", + "Correlate", + "CorrelateShift", + "Decimate", + "Detrend", + "DispersionPhaseShift", + "Divide", + "Dft", + "Differentiate", + "Envelope", + "Exp", + "Fbe", + "FillNa", + "Flip", + "GaussianFilter", + "HampelFilter", + "Hilbert", + "Identity", + "Idft", + "Imag", + "Integrate", + "Interpolate", + "Iresample", + "IsFinite", + "IsInf", + "IsNan", + "Istft", + "LineMute", + "Log", + "Log10", + "Log2", + "Max", + "Maximum", + "Mean", + "Median", + "MedianFilter", + "Min", + "Minimum", + "Multiply", + "NotchFilter", + "Normalize", + "Pad", + "PassFilter", + "PhaseWeightedStack", + "RadiansToStrain", + "Real", + "Resample", + "Rfft", + "Roll", + "Scale", + "SavgolFilter", + "SobelFilter", + "Spectrogram", + "SlopeFilter", + "SlopeMute", + "Standardize", + "Std", + "Stft", + "Subtract", + "Sum", + "Taper", + "TaperRange", + "TauP", + "VelocityToStrainRate", + "Where", + "VelocityToStrainRateEdgeless", + "Whiten", + "WienerFilter", +] diff --git a/src/dasjax/operations/basic.py b/src/dasjax/operations/basic.py new file mode 100644 index 0000000..d964aee --- /dev/null +++ b/src/dasjax/operations/basic.py @@ -0,0 +1,501 @@ +"""Basic DASCore-style patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, ClassVar, Self + +import jax.numpy as jnp +from dascore.utils.misc import iterate + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class Identity(PatchOperation): + """Return a patch unchanged.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.identity_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Scale(PatchOperation): + """Scale patch data by a constant factor.""" + + factor: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.scale_kernel(patch_tree.data, self.factor)) + + +@dataclass(frozen=True) +class Add(PatchOperation): + """Add a constant value to patch data.""" + + value: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.add_kernel(patch_tree.data, self.value)) + + +@dataclass(frozen=True) +class Subtract(PatchOperation): + """Subtract a value from patch data.""" + + other: Any + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.asarray(patch_tree.data) - self.other) + + +@dataclass(frozen=True) +class Multiply(PatchOperation): + """Multiply patch data by a value.""" + + other: Any + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.asarray(patch_tree.data) * self.other) + + +@dataclass(frozen=True) +class Divide(PatchOperation): + """Divide patch data by a value.""" + + other: Any + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.asarray(patch_tree.data) / self.other) + + +@dataclass(frozen=True) +class Maximum(PatchOperation): + """Return elementwise maximum of patch data and a value.""" + + other: Any + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.maximum(jnp.asarray(patch_tree.data), self.other)) + + +@dataclass(frozen=True) +class Minimum(PatchOperation): + """Return elementwise minimum of patch data and a value.""" + + other: Any + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.minimum(jnp.asarray(patch_tree.data), self.other)) + + +@dataclass(frozen=True) +class Abs(PatchOperation): + """Take absolute value of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.abs_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Clip(PatchOperation): + """Clip patch data to a fixed range.""" + + min_value: float + max_value: float + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.clip_kernel(patch_tree.data, self.min_value, self.max_value) + ) + + +@dataclass(frozen=True) +class Real(PatchOperation): + """Return the real component of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.real_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Imag(PatchOperation): + """Return the imaginary component of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.imag_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Angle(PatchOperation): + """Return the phase angle of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.angle_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Conj(PatchOperation): + """Return the complex conjugate of patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.conj_kernel(patch_tree.data)) + + +@dataclass(frozen=True) +class Exp(PatchOperation): + """Apply exponential to patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.exp(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class Log(PatchOperation): + """Apply natural logarithm to patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.log(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class Log10(PatchOperation): + """Apply base-10 logarithm to patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.log10(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class Log2(PatchOperation): + """Apply base-2 logarithm to patch data.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.log2(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class IsFinite(PatchOperation): + """Return a finite-value mask for patch data.""" + + method_name: ClassVar[str | None] = "is_finite" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.isfinite(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class IsInf(PatchOperation): + """Return an infinite-value mask for patch data.""" + + method_name: ClassVar[str | None] = "isinf" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.isinf(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class IsNan(PatchOperation): + """Return a NaN-value mask for patch data.""" + + method_name: ClassVar[str | None] = "isnan" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=jnp.isnan(jnp.asarray(patch_tree.data))) + + +@dataclass(frozen=True) +class FillNa(PatchOperation): + """Fill NaN, and optionally infinite, values in patch data.""" + + method_name: ClassVar[str | None] = "fillna" + value: Any + include_inf: bool = True + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = jnp.asarray(patch_tree.data) + mask = jnp.isnan(data) + if self.include_inf: + mask = mask | jnp.isinf(data) + return patch_tree.new(data=jnp.where(mask, self.value, data)) + + +@dataclass(frozen=True) +class Where(PatchOperation): + """Select patch data where a condition is true, otherwise use another value.""" + + cond: Any + other: Any = jnp.nan + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + cond = self.cond.data if hasattr(self.cond, "coords") else self.cond + other = self.other.data if hasattr(self.other, "coords") else self.other + return patch_tree.new(data=jnp.where(cond, patch_tree.data, other)) + + +@dataclass(frozen=True) +class Flip(PatchOperation): + """Flip data and, optionally, associated coordinate values.""" + + dims: tuple[str, ...] = () + flip_coords: bool = True + axes: tuple[int, ...] = () + coord_axes: tuple[tuple[int, tuple[int, ...]], ...] = () + + def __init__(self, *dims: str, flip_coords: bool = True): + object.__setattr__(self, "dims", tuple(dims)) + object.__setattr__(self, "flip_coords", flip_coords) + object.__setattr__(self, "axes", ()) + object.__setattr__(self, "coord_axes", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + dims = self.dims or boundary.dims + axes = tuple(boundary.axis(dim) for dim in dims) + coord_axes = [] + if self.flip_coords: + for name in boundary.coord_names: + axes_for_coord = tuple( + idx + for idx, coord_dim in enumerate(boundary.coord_dims(name)) + if coord_dim in dims + ) + if axes_for_coord: + coord_axes.append((boundary.coord_index(name), axes_for_coord)) + return replace(self, dims=dims, axes=axes, coord_axes=tuple(coord_axes)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.flip_kernel(patch_tree.data, self.axes) + coords = patch_tree.coord_values + if self.flip_coords: + for index, axes in self.coord_axes: + coords = tuple( + jnp.flip(value, axis=axes) if idx == index else value + for idx, value in enumerate(coords) + ) + return patch_tree.new(data=data, coords=coords) + + +@dataclass(frozen=True) +class Roll(PatchOperation): + """Roll data along one dimension.""" + + samples: bool = False + update_coord: bool = False + kwargs: dict[str, Any] | None = None + axis: int | None = None + shift: int | None = None + + def __init__( + self, + samples: bool = False, + update_coord: bool = False, + **kwargs, + ): + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "update_coord", update_coord) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "shift", None) + + def bind(self, boundary: PatchBoundary) -> Self: + if self.update_coord: + raise NotImplementedError( + "Compiled roll currently requires update_coord=False." + ) + kwargs = self.kwargs or {} + dim = next(key for key in kwargs if key in boundary.dims) + coord = boundary.coord(dim) + return replace( + self, + axis=boundary.axis(dim), + shift=int(coord.get_sample_count(kwargs[dim], samples=self.samples)), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None and self.shift is not None + return patch_tree.new( + data=kernels.roll_kernel(patch_tree.data, self.shift, self.axis) + ) + + +@dataclass(frozen=True) +class Standardize(PatchOperation): + """Standardize patch data along one dimension.""" + + dim: str + axis: int | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.standardize_kernel(patch_tree.data, self.axis) + ) + + +_REDUCTIONS = { + "all": jnp.all, + "any": jnp.any, + "max": jnp.max, + "mean": jnp.mean, + "median": jnp.median, + "min": jnp.min, + "std": jnp.std, + "sum": jnp.sum, +} + + +@dataclass(frozen=True) +class Aggregate(PatchOperation): + """Aggregate values along one or more dimensions.""" + + dim: str | tuple[str, ...] | None = None + method: str | Any = "mean" + dim_reduce: str | Any = "empty" + axes: tuple[int, ...] = () + keepdims: bool = True + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + if not isinstance(self.method, str) or self.method not in _REDUCTIONS: + msg = f"Unsupported aggregate method {self.method!r}." + raise NotImplementedError(msg) + if self.dim_reduce not in {"empty", "squeeze"}: + msg = "Compiled aggregate supports dim_reduce='empty' or 'squeeze'." + raise NotImplementedError(msg) + dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) + axes = tuple(boundary.axis(dim) for dim in dims) + patch = dummy_patch(boundary) + if self.method in {"all", "any"}: + out = getattr(patch, self.method)(dim=dims, dim_reduce=self.dim_reduce) + else: + out = patch.aggregate( + dim=dims, + method=self.method, + dim_reduce=self.dim_reduce, + ) + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + axes=axes, + keepdims=self.dim_reduce == "empty", + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = _REDUCTIONS[self.method]( + jnp.asarray(patch_tree.data), + axis=self.axes, + keepdims=self.keepdims, + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class _Reduction(Aggregate): + """Base class for named reduction methods.""" + + register: ClassVar[bool] = False + method_name: ClassVar[str | None] = None + + def __init__( + self, + dim: str | tuple[str, ...] | None = None, + dim_reduce: str | Any = "empty", + ): + object.__setattr__(self, "dim", dim) + object.__setattr__(self, "method", type(self).operation_name()) + object.__setattr__(self, "dim_reduce", dim_reduce) + object.__setattr__(self, "axes", ()) + object.__setattr__(self, "keepdims", True) + object.__setattr__(self, "out_boundary", None) + object.__setattr__(self, "out_coords", None) + object.__setattr__(self, "out_dtype_codes", None) + object.__setattr__(self, "out_dims", None) + + +@dataclass(frozen=True) +class All(_Reduction): + """Perform boolean all reduction.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class AnyOp(_Reduction): + """Perform boolean any reduction.""" + + method_name: ClassVar[str | None] = "any" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Max(_Reduction): + """Calculate maximum along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Mean(_Reduction): + """Calculate mean along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Median(_Reduction): + """Calculate median along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Min(_Reduction): + """Calculate minimum along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Std(_Reduction): + """Calculate standard deviation along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) + + +@dataclass(frozen=True) +class Sum(_Reduction): + """Calculate sum along one or more dimensions.""" + + def __init__(self, dim=None, dim_reduce="empty"): + _Reduction.__init__(self, dim=dim, dim_reduce=dim_reduce) diff --git a/src/dasjax/operations/common.py b/src/dasjax/operations/common.py new file mode 100644 index 0000000..0f86d8a --- /dev/null +++ b/src/dasjax/operations/common.py @@ -0,0 +1,54 @@ +"""Shared helpers for patch operation implementations.""" + +from __future__ import annotations + +from dataclasses import fields +from typing import Any + +import dascore as dc +import numpy as np +from dascore.units import get_quantity + +from dasjax.core import PatchBoundary, PatchPyTree + + +def replace(obj: Any, **changes: Any) -> Any: + """Copy frozen operation instances without calling custom constructors.""" + out = object.__new__(type(obj)) + for field in fields(obj): + object.__setattr__( + out, field.name, changes.get(field.name, getattr(obj, field.name)) + ) + return out + + +def dummy_patch(boundary: PatchBoundary, dtype=np.float64) -> dc.Patch: + """Create a zero-data patch with metadata from a pipeline boundary.""" + return dc.Patch( + data=np.zeros(boundary.coords.shape, dtype=dtype), + coords=boundary.coords, + dims=boundary.dims, + attrs=boundary.attrs, + ) + + +def tree_boundary_from_patch(patch: dc.Patch) -> tuple[PatchPyTree, PatchBoundary]: + """Convert a DASCore patch into pipeline tree and boundary objects.""" + return PatchPyTree.from_patch(patch) + + +def get_data_units_from_dims( + boundary: PatchBoundary, + dims: tuple[str, ...], + operator, +) -> Any: + """Apply a unit operator between data units and dimension units.""" + if (data_units := get_quantity(boundary.attrs.data_units)) is None: + return None + dim_units = None + for dim_name in dims: + dim_unit = get_quantity(boundary.coord(dim_name).units) + if dim_unit is None: + continue + dim_units = dim_unit if dim_units is None else dim_unit * dim_units + return operator(data_units, dim_units) if dim_units is not None else data_units diff --git a/src/dasjax/operations/correlate.py b/src/dasjax/operations/correlate.py new file mode 100644 index 0000000..ef5eba8 --- /dev/null +++ b/src/dasjax/operations/correlate.py @@ -0,0 +1,64 @@ +"""Correlation patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import dascore as dc +from dascore.proc.correlate import correlate_shift as dc_correlate_shift + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class CorrelateShift(PatchOperation): + """Apply the lag shift after frequency-domain correlation.""" + + dim: str + undo_weighting: bool = True + axis: int | None = None + step: float = 1.0 + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + patch = dummy_patch(boundary) + coord = boundary.coord(self.dim) + out = dc_correlate_shift.func( + patch, dim=self.dim, undo_weighting=self.undo_weighting + ) + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + axis=boundary.axis(self.dim), + step=float(dc.to_float(coord.step)), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.correlate_shift_kernel( + patch_tree.data, + axis=self.axis, + step=self.step, + undo_weighting=self.undo_weighting, + ), + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/detrend.py b/src/dasjax/operations/detrend.py new file mode 100644 index 0000000..1a05a34 --- /dev/null +++ b/src/dasjax/operations/detrend.py @@ -0,0 +1,30 @@ +"""Detrend patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Self + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import replace + + +@dataclass(frozen=True) +class Detrend(PatchOperation): + """Remove a linear or constant trend along one dimension.""" + + dim: str + type: str = "linear" + axis: int | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + kernels.validate_detrend_type(self.type) + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.detrend_kernel(patch_tree.data, axis=self.axis, type=self.type) + ) diff --git a/src/dasjax/operations/differentiate.py b/src/dasjax/operations/differentiate.py new file mode 100644 index 0000000..e872103 --- /dev/null +++ b/src/dasjax/operations/differentiate.py @@ -0,0 +1,57 @@ +"""Differentiate patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from operator import truediv +from typing import Any, Self + +import dascore as dc +from dascore.exceptions import ParameterError +from dascore.utils.misc import iterate + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, get_data_units_from_dims, replace + + +@dataclass(frozen=True) +class Differentiate(PatchOperation): + """Differentiate patch data along one or more dimensions.""" + + dim: str | tuple[str, ...] | None + order: int = 2 + step: int = 1 + axes: tuple[int, ...] = () + dxs_or_spacing: tuple[Any, ...] = () + attrs: Any = None + + def bind(self, boundary: PatchBoundary) -> Self: + dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) + if self.step > 1 and len(dims) > 1: + raise ParameterError( + "Step in patch.differentiate can only be used along one axis." + ) + axes = [] + dxs = [] + for dim in dims: + coord = dummy_patch(boundary).get_coord(dim, require_sorted=True) + val = coord.step if coord.evenly_sampled else coord.data + dxs.append(dc.to_float(val)) + axes.append(boundary.axis(dim)) + attrs = boundary.attrs.update( + data_units=get_data_units_from_dims(boundary, dims, truediv) + ) + return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): + data = kernels.differentiate_kernel( + data, axis=axis, dx_or_spacing=spacing, order=self.order, step=self.step + ) + return patch_tree.new(data=data) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return boundary.new(attrs=self.attrs) diff --git a/src/dasjax/operations/dispersion.py b/src/dasjax/operations/dispersion.py new file mode 100644 index 0000000..6acb6bf --- /dev/null +++ b/src/dasjax/operations/dispersion.py @@ -0,0 +1,111 @@ +"""Dispersion transform operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import numpy as np +from dascore.exceptions import ParameterError + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class DispersionPhaseShift(PatchOperation): + """Compute a phase-shift dispersion image.""" + + phase_velocities: Any + approx_resolution: float | None = None + approx_freq: tuple[float, float] | None = None + distances: Any = None + velocities: Any = None + nf: int = 0 + first_live_f: int = 0 + last_live_f: int = 0 + fs: float = 1.0 + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + velocities = np.asarray(self.phase_velocities, dtype=np.float64) + if not np.all(np.diff(velocities) > 0): + raise ParameterError("Velocities for dispersion must be monotonically increasing") + if np.amin(velocities) <= 0: + raise ParameterError("Velocities must be positive.") + if self.approx_resolution is not None and self.approx_resolution <= 0: + raise ParameterError("Frequency resolution has to be positive") + patch = dummy_patch(boundary).convert_units(distance="m").transpose( + "distance", "time" + ) + time = patch.coords.get_array("time") + dt = (time[1] - time[0]) / np.timedelta64(1, "s") + fs = 1 / dt + if not self.approx_freq: + approx_min_freq = 0 + approx_max_freq = 0.5 / dt + else: + approx_min_freq, approx_max_freq = self.approx_freq + if approx_min_freq <= 0 or approx_max_freq <= 0: + raise ParameterError("Minimal and maximal frequencies have to be positive") + if approx_min_freq >= approx_max_freq: + raise ParameterError("Maximal frequency needs to be larger than minimal frequency") + if approx_min_freq >= 0.5 / dt or approx_max_freq >= 0.5 / dt: + raise ParameterError("Frequency range cannot exceed Nyquist") + nt = len(time) + if self.approx_resolution is not None: + nf = int(nt * (fs / nt) / self.approx_resolution) + else: + nf = nt + freq = np.arange(nf) * fs / (nf - 1) + omega = 2 * np.pi * freq + first_live_f = int(np.argmax(omega >= 2 * np.pi * approx_min_freq)) + last_live_f = int(np.argmax(omega >= 2 * np.pi * approx_max_freq)) + if last_live_f - first_live_f < 1: + raise ParameterError("Combination of frequency resolution and range is not an array") + out_patch = patch.dispersion_phase_shift( + velocities, + approx_resolution=self.approx_resolution, + approx_freq=self.approx_freq, + ) + out_tree, out_boundary = tree_boundary_from_patch(out_patch) + return replace( + self, + velocities=velocities, + distances=np.asarray(patch.coords.get_array("distance"), dtype=np.float64), + nf=nf, + first_live_f=first_live_f, + last_live_f=last_live_f, + fs=float(fs), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.dispersion_phase_shift_kernel( + patch_tree.data, + distances=self.distances, + velocities=self.velocities, + nf=self.nf, + first_live_f=self.first_live_f, + last_live_f=self.last_live_f, + fs=self.fs, + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/filter.py b/src/dasjax/operations/filter.py new file mode 100644 index 0000000..ed6b021 --- /dev/null +++ b/src/dasjax/operations/filter.py @@ -0,0 +1,495 @@ +"""Filter patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import numpy as np +import dascore as dc +from dascore.exceptions import FilterValueError, ParameterError +from dascore.proc.filter import get_inverted_quant +from dascore.units import get_filter_units +from dascore.utils.patch import ( + get_dim_axis_value, + get_dim_sampling_rate, + get_patch_window_size, +) +from scipy.fft import next_fast_len + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace + + +def _size_and_axes( + boundary: PatchBoundary, + kwargs: dict[str, Any], + samples: bool, +) -> tuple[tuple[int, ...], tuple[int, ...]]: + """Resolve DASCore dimension window kwargs into static size and axes.""" + dimfo = get_dim_axis_value( + dummy_patch(boundary), kwargs=kwargs, allow_multiple=True + ) + axes = [axis for _dim, axis, _value in dimfo] + size = [1] * len(boundary.dims) + for dim, axis, value in dimfo: + size[axis] = boundary.coord(dim).get_sample_count(value, samples=samples) + return tuple(int(x) for x in size), tuple(int(x) for x in axes) + + +@dataclass(frozen=True) +class GaussianFilter(PatchOperation): + """Apply a Gaussian smoothing filter to patch data.""" + + samples: bool = False + mode: str = "reflect" + cval: float = 0.0 + truncate: float = 4.0 + kwargs: dict[str, Any] | None = None + sigma: tuple[float, ...] = () + axes: tuple[int, ...] = () + + def __init__(self, samples=False, mode="reflect", cval=0.0, truncate=4.0, **kwargs): + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "cval", float(cval)) + object.__setattr__(self, "truncate", float(truncate)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "sigma", ()) + object.__setattr__(self, "axes", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + dimfo = get_dim_axis_value( + dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True + ) + axes = [] + sigma = [] + for dim, axis, value in dimfo: + sigma.append( + float(boundary.coord(dim).get_sample_count(value, samples=self.samples)) + ) + axes.append(axis) + return replace(self, axes=tuple(axes), sigma=tuple(sigma)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.gaussian_filter_kernel( + patch_tree.data, + sigma=self.sigma, + axes=self.axes, + mode=self.mode, + cval=self.cval, + truncate=self.truncate, + ) + ) + + +@dataclass(frozen=True) +class HampelFilter(PatchOperation): + """Replace outliers with a Hampel filter.""" + + threshold: float = 10.0 + samples: bool = False + approximate: bool = True + kwargs: dict[str, Any] | None = None + size: tuple[int, ...] = () + + def __init__(self, *, threshold=10.0, samples=False, approximate=True, **kwargs): + if not approximate: + msg = "Exact Hampel median filtering is not implemented in pure JAX." + raise NotImplementedError(msg) + object.__setattr__(self, "threshold", float(threshold)) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "approximate", approximate) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "size", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + if self.threshold <= 0 or not np.isfinite(self.threshold): + raise ParameterError( + "hampel_filter threshold must be finite and greater than zero" + ) + size = get_patch_window_size( + dummy_patch(boundary), + self.kwargs or {}, + self.samples, + require_odd=True, + warn_above=10, + min_samples=3, + ) + return replace(self, size=tuple(int(x) for x in size)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.hampel_filter_kernel( + patch_tree.data, + size=self.size, + threshold=self.threshold, + approximate=self.approximate, + ) + ) + + +@dataclass(frozen=True) +class MedianFilter(PatchOperation): + """Apply an exact median filter to patch data.""" + + samples: bool = False + mode: str = "reflect" + cval: float = 0.0 + kwargs: dict[str, Any] | None = None + size: tuple[int, ...] = () + + def __init__(self, samples=False, mode="reflect", cval=0.0, **kwargs): + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "cval", float(cval)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "size", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + size, _axes = _size_and_axes(boundary, self.kwargs or {}, self.samples) + return replace(self, size=size) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.median_filter_kernel( + patch_tree.data, + size=self.size, + mode=self.mode, + cval=self.cval, + ) + ) + + +@dataclass(frozen=True) +class SobelFilter(PatchOperation): + """Apply a Sobel filter along one dimension.""" + + dim: str + mode: str = "reflect" + cval: float = 0.0 + axis: int | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + if not isinstance(self.dim, str): + msg = "dim parameter should be a string." + raise FilterValueError(msg) + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.sobel_filter_kernel( + patch_tree.data, + axis=self.axis, + mode=self.mode, + cval=self.cval, + ) + ) + + +@dataclass(frozen=True) +class SavgolFilter(PatchOperation): + """Apply Savitzky-Golay filtering along one or more dimensions.""" + + polyorder: int + samples: bool = False + mode: str = "interp" + cval: float = 0.0 + kwargs: dict[str, Any] | None = None + size: tuple[int, ...] = () + axes: tuple[int, ...] = () + coeffs: tuple[Any, ...] = () + left_coeffs: tuple[Any, ...] = () + right_coeffs: tuple[Any, ...] = () + + def __init__(self, polyorder, samples=False, mode="interp", cval=0.0, **kwargs): + object.__setattr__(self, "polyorder", int(polyorder)) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "cval", float(cval)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "size", ()) + object.__setattr__(self, "axes", ()) + object.__setattr__(self, "coeffs", ()) + object.__setattr__(self, "left_coeffs", ()) + object.__setattr__(self, "right_coeffs", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + size, axes = _size_and_axes(boundary, self.kwargs or {}, self.samples) + coeffs = [] + left_coeffs = [] + right_coeffs = [] + for axis in axes: + window = size[axis] + coeff, left, right = kernels.savgol_coefficients(window, self.polyorder) + coeffs.append(coeff) + left_coeffs.append(left) + right_coeffs.append(right) + return replace( + self, + size=size, + axes=axes, + coeffs=tuple(coeffs), + left_coeffs=tuple(left_coeffs), + right_coeffs=tuple(right_coeffs), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.savgol_filter_kernel( + patch_tree.data, + size=self.size, + axes=self.axes, + coeffs=self.coeffs, + left_coeffs=self.left_coeffs, + right_coeffs=self.right_coeffs, + mode=self.mode, + cval=self.cval, + ) + ) + + +@dataclass(frozen=True) +class NotchFilter(PatchOperation): + """Apply one or more narrow notch filters.""" + + q: float + kwargs: dict[str, Any] | None = None + axes: tuple[int, ...] = () + b: tuple[Any, ...] = () + a: tuple[Any, ...] = () + zi: tuple[Any, ...] = () + padlen: tuple[int, ...] = () + + def __init__(self, q, **kwargs): + object.__setattr__(self, "q", float(q)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axes", ()) + object.__setattr__(self, "b", ()) + object.__setattr__(self, "a", ()) + object.__setattr__(self, "zi", ()) + object.__setattr__(self, "padlen", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + dimfo = get_dim_axis_value( + dummy_patch(boundary), kwargs=self.kwargs or {}, allow_multiple=True + ) + axes = [] + b_values = [] + a_values = [] + zi_values = [] + padlens = [] + for dim, axis, value in dimfo: + coord = boundary.coord(dim) + if isinstance(value, dc.units.Quantity) and coord.units is not None: + value, _ = get_inverted_quant(value, coord.units) + w0 = float(dc.to_float(value)) + sr = get_dim_sampling_rate(dummy_patch(boundary), dim) + b, a, zi, padlen = kernels.design_notch_filter(sr, w0, self.q) + axes.append(axis) + b_values.append(b) + a_values.append(a) + zi_values.append(zi) + padlens.append(padlen) + return replace( + self, + axes=tuple(int(x) for x in axes), + b=tuple(b_values), + a=tuple(a_values), + zi=tuple(zi_values), + padlen=tuple(int(x) for x in padlens), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + for axis, b, a, zi, padlen in zip( + self.axes, self.b, self.a, self.zi, self.padlen, strict=True + ): + data = kernels.notch_filter_kernel( + data, + b=b, + a=a, + zi=zi, + padlen=padlen, + axis=axis, + ) + return patch_tree.new(data=data) + + +@dataclass(frozen=True) +class WienerFilter(PatchOperation): + """Apply a local-statistics Wiener filter.""" + + noise: float | None = None + samples: bool = False + kwargs: dict[str, Any] | None = None + size: tuple[int, ...] = () + + def __init__(self, *, noise=None, samples=False, **kwargs): + object.__setattr__(self, "noise", noise) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "size", ()) + + def bind(self, boundary: PatchBoundary) -> Self: + if not self.kwargs: + msg = ( + "To use wiener_filter you must specify dimension-specific window " + "sizes via kwargs (e.g., time=5, distance=3)" + ) + raise ParameterError(msg) + size = get_patch_window_size( + dummy_patch(boundary), self.kwargs or {}, self.samples, min_samples=1 + ) + return replace(self, size=tuple(int(x) for x in size)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.wiener_filter_kernel( + patch_tree.data, size=self.size, noise=self.noise + ) + ) + + +@dataclass(frozen=True) +class SlopeFilter(PatchOperation): + """Filter over slopes in the 2-D Fourier domain.""" + + filt: Any + dims: tuple[str, str] = ("distance", "time") + directional: bool = False + notch: bool | None = None + invert: bool = False + axes: tuple[int, int] = () + dxs: tuple[float, float] = () + mask: Any = None + steps: tuple[float, float] = () + sizes: tuple[int, int] = () + pad_width: tuple[tuple[int, int], ...] = () + attrs: Any = None + + def bind(self, boundary: PatchBoundary) -> Self: + filt = np.asarray(self.filt, dtype=np.float64) + if not (len(filt) == 4 and np.all(filt[:-1] <= filt[1:])): + msg = f"filt must be a sorted length 4 sequence. You passed {self.filt}" + raise ParameterError(msg) + patch = dummy_patch(boundary) + pad_width = [(0, 0)] * len(boundary.dims) + for dim in self.dims: + axis = patch.get_axis(dim) + target = next_fast_len(len(patch.get_coord(dim))) + pad_width[axis] = (0, target - len(patch.get_coord(dim))) + work_patch = patch.pad.func(patch, **{dim: "fft" for dim in self.dims}) + dft_patch = work_patch.dft.func(work_patch, self.dims, pad=False) + freq_dims = tuple(f"ft_{x}" for x in self.dims) + dim1, dim2 = freq_dims[-1], freq_dims[-2] + coord1 = dft_patch.get_array(dim1) + coord2 = dft_patch.get_array(dim2) + np.finfo(float).eps + ax1 = dft_patch.dims.index(dim1) + ax2 = dft_patch.dims.index(dim2) + shape_1 = [None] * dft_patch.ndim + shape_2 = [None] * dft_patch.ndim + shape_1[ax1] = slice(None) + shape_2[ax2] = slice(None) + slope = coord1[tuple(shape_1)] / coord2[tuple(shape_2)] + if not self.directional: + slope = np.abs(slope) + invert = self.invert if self.notch is None else self.notch + fac = np.where( + (slope >= filt[0]) & (slope <= filt[1]), + 1.0 - np.sin(0.5 * np.pi * (slope - filt[0]) / (filt[1] - filt[0])), + 1.0, + ) + fac = np.where((slope >= filt[1]) & (slope <= filt[2]), 0.0, fac) + fac = np.where( + (slope >= filt[2]) & (slope <= filt[3]), + np.sin(0.5 * np.pi * (slope - filt[2]) / (filt[3] - filt[2])), + fac, + ) + mask = fac if invert else 1.0 - fac + axes = tuple(work_patch.get_axis(dim) for dim in self.dims) + dxs = tuple(float(dc.to_float(work_patch.get_coord(dim).step)) for dim in self.dims) + return replace( + self, + axes=axes, + dxs=dxs, + mask=np.asarray(mask), + steps=dxs, + sizes=tuple(len(work_patch.get_coord(dim)) for dim in self.dims), + pad_width=tuple(pad_width), + attrs=boundary.attrs, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.slope_filter_kernel( + patch_tree.data, + axes=self.axes, + dxs=self.dxs, + mask=self.mask, + steps=self.steps, + sizes=self.sizes, + pad_width=self.pad_width, + ) + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return boundary.new(attrs=self.attrs) + + +@dataclass(frozen=True) +class PassFilter(PatchOperation): + """Apply a band, low, or high pass filter along one dimension.""" + + corners: int = 4 + zerophase: bool = True + kwargs: dict[str, Any] | None = None + sos: Any = None + zi: Any = None + padlen: int | None = None + axis: int | None = None + + def __init__(self, corners=4, zerophase=True, **kwargs): + object.__setattr__(self, "corners", int(corners)) + object.__setattr__(self, "zerophase", bool(zerophase)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "sos", None) + object.__setattr__(self, "zi", None) + object.__setattr__(self, "padlen", None) + object.__setattr__(self, "axis", None) + + def bind(self, boundary: PatchBoundary) -> Self: + from dascore.utils.misc import check_filter_kwargs + + dim, (arg1, arg2) = check_filter_kwargs(self.kwargs or {}) + filt_min, filt_max = get_filter_units( + arg1, arg2, to_unit=boundary.coord(dim).units, dim=dim + ) + sr = get_dim_sampling_rate(dummy_patch(boundary), dim) + sos = np.asarray( + kernels.design_pass_filter_sos(sr, filt_min, filt_max, self.corners) + ) + return replace( + self, + sos=sos, + zi=kernels.pass_filter_initial_state(sos), + padlen=kernels.pass_filter_default_padlen(sos), + axis=boundary.axis(dim), + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None and self.padlen is not None + return patch_tree.new( + data=kernels.pass_filter_kernel( + patch_tree.data, + sos=self.sos, + zi=self.zi, + padlen=self.padlen, + axis=self.axis, + zerophase=self.zerophase, + ) + ) diff --git a/src/dasjax/operations/fourier.py b/src/dasjax/operations/fourier.py new file mode 100644 index 0000000..a05693a --- /dev/null +++ b/src/dasjax/operations/fourier.py @@ -0,0 +1,151 @@ +"""Fourier transform patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, ClassVar, Self + +import dascore as dc +import jax.numpy as jnp +import numpy as np +from dascore.proc.basic import pad as dc_pad +from dascore.transform.fourier import ( + _get_idft_dims_steps_axis, + dft as dc_dft, + idft as dc_idft, +) +from dascore.utils.misc import iterate +from dascore.utils.transformatter import FourierTransformatter +from scipy.fft import next_fast_len + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class Dft(PatchOperation): + """Transform patch data into the frequency domain.""" + + method_name: ClassVar[str | None] = "dft" + dim: str | None | tuple[str, ...] + real: str | bool | None = None + pad: bool = True + axes: tuple[int, ...] = () + dxs: tuple[float, ...] = () + real_axis: int | None = None + pad_width: tuple[tuple[int, int], ...] = () + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + patch = dummy_patch(boundary) + dims = list(iterate(self.dim if self.dim is not None else boundary.dims)) + real = dims[-1] if self.real is True else self.real + if isinstance(real, str) and real in dims: + dims.append(dims.pop(dims.index(real))) + pad_width = [(0, 0)] * len(boundary.dims) + work_patch = patch + if self.pad: + for dim in dims: + axis = work_patch.get_axis(dim) + target = next_fast_len(len(work_patch.get_coord(dim))) + pad_width[axis] = (0, target - len(work_patch.get_coord(dim))) + work_patch = dc_pad.func(work_patch, **{dim: "fft" for dim in dims}) + axes = tuple(work_patch.get_axis(dim) for dim in dims) + dxs = tuple(float(dc.to_float(work_patch.get_coord(dim).step)) for dim in dims) + out = dc_dft.func(patch, dim=self.dim, real=self.real, pad=self.pad) + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + axes=axes, + dxs=dxs, + real_axis=work_patch.get_axis(real) + if isinstance(real, str) and real in dims + else None, + pad_width=tuple(pad_width), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + if any(before or after for before, after in self.pad_width): + data = jnp.pad(data, self.pad_width) + data = kernels.dft_kernel( + data, axes=self.axes, dxs=self.dxs, real_axis=self.real_axis + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class Idft(PatchOperation): + """Transform patch data from the frequency domain.""" + + method_name: ClassVar[str | None] = "idft" + dim: str | None | tuple[str, ...] = None + axes: tuple[int, ...] = () + steps: tuple[float, ...] = () + sizes: tuple[int, ...] | None = None + real: bool = False + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + patch = dummy_patch(boundary, dtype=np.complex128) + dims, _steps, axes, real = _get_idft_dims_steps_axis(patch, self.dim) + out = dc_idft.func(patch, dim=self.dim) + out_tree, out_boundary = tree_boundary_from_patch(out) + sizes = tuple(out.shape[axis] for axis in axes) + new_dims = FourierTransformatter().rename_dims(dims, forward=False) + out_steps = tuple( + float(dc.to_float(out.get_coord(dim).step)) for dim in new_dims + ) + return replace( + self, + axes=tuple(axes), + steps=out_steps, + sizes=sizes, + real=real, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.idft_kernel( + patch_tree.data, + axes=self.axes, + new_steps=self.steps, + sizes=self.sizes, + real=self.real, + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/hilbert.py b/src/dasjax/operations/hilbert.py new file mode 100644 index 0000000..e77ba4f --- /dev/null +++ b/src/dasjax/operations/hilbert.py @@ -0,0 +1,130 @@ +"""Hilbert transform patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import dascore as dc +from dascore.exceptions import ParameterError + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class Hilbert(PatchOperation): + """Compute the analytic signal along one dimension.""" + + dim: str + axis: int | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + if boundary.coord(self.dim).step is None: + raise dc.exceptions.CoordError( + f"Coordinate {self.dim} is not evenly sampled as required by hilbert" + ) + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.hilbert_kernel(patch_tree.data, axis=self.axis) + ) + + +@dataclass(frozen=True) +class Envelope(Hilbert): + """Compute the signal envelope along one dimension.""" + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.envelope_kernel(patch_tree.data, axis=self.axis) + ) + + +@dataclass(frozen=True) +class PhaseWeightedStack(PatchOperation): + """Apply phase-weighted stacking over one dimension.""" + + stack_dim: str + transform_dim: str | None = None + power: float = 2.0 + dim_reduce: str = "empty" + stack_axis: int | None = None + transform_axis: int | None = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + transform_dim = self.transform_dim + if transform_dim is None: + other_dims = tuple(dim for dim in boundary.dims if dim != self.stack_dim) + if len(other_dims) != 1: + msg = "transform_dim must be provided for patches that are not 2D." + raise ParameterError(msg) + transform_dim = other_dims[0] + if boundary.coord(transform_dim).step is None: + raise dc.exceptions.CoordError( + f"Coordinate {transform_dim} is not evenly sampled as required by hilbert" + ) + out_patch = dummy_patch(boundary).phase_weighted_stack( + self.stack_dim, + transform_dim=transform_dim, + power=self.power, + dim_reduce=self.dim_reduce, + ) + out_tree, out_boundary = tree_boundary_from_patch(out_patch) + out_coords = out_tree.coord_values + out_dtype_codes = out_tree.coord_dtype_codes + if self.dim_reduce != "squeeze" and self.stack_dim in out_boundary.coord_names: + coord_index = out_boundary.coord_index(self.stack_dim) + out_boundary = out_boundary.new( + coord_names=tuple( + name for name in out_boundary.coord_names if name != self.stack_dim + ) + ) + out_coords = tuple( + value for idx, value in enumerate(out_coords) if idx != coord_index + ) + out_dtype_codes = tuple( + value + for idx, value in enumerate(out_dtype_codes) + if idx != coord_index + ) + return replace( + self, + transform_dim=transform_dim, + stack_axis=boundary.axis(self.stack_dim), + transform_axis=boundary.axis(transform_dim), + out_boundary=out_boundary, + out_coords=out_coords, + out_dtype_codes=out_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.stack_axis is not None and self.transform_axis is not None + data = kernels.phase_weighted_stack_kernel( + patch_tree.data, + stack_axis=self.stack_axis, + transform_axis=self.transform_axis, + power=self.power, + squeeze=self.dim_reduce == "squeeze", + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/integrate.py b/src/dasjax/operations/integrate.py new file mode 100644 index 0000000..45bcbb8 --- /dev/null +++ b/src/dasjax/operations/integrate.py @@ -0,0 +1,85 @@ +"""Integrate patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from operator import mul +from typing import Any, Self + +import dascore as dc +from dascore.utils.misc import iterate + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import ( + dummy_patch, + get_data_units_from_dims, + replace, + tree_boundary_from_patch, +) + + +@dataclass(frozen=True) +class Integrate(PatchOperation): + """Integrate patch data along one or more dimensions.""" + + dim: str | tuple[str, ...] | None + definite: bool = False + axes: tuple[int, ...] = () + dxs_or_spacing: tuple[Any, ...] = () + attrs: Any = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + dims = tuple(iterate(self.dim if self.dim is not None else boundary.dims)) + axes = [] + dxs = [] + for dim in dims: + coord = dummy_patch(boundary).get_coord(dim, require_sorted=True) + val = coord.step if coord.evenly_sampled else coord.data + dxs.append(dc.to_float(val)) + axes.append(boundary.axis(dim)) + attrs = boundary.attrs.update( + data_units=get_data_units_from_dims(boundary, dims, mul), + coords={} if self.definite else boundary.attrs.coords, + ) + if self.definite: + out_patch = dummy_patch(boundary).integrate(dim=dims, definite=True) + out_tree, out_boundary = tree_boundary_from_patch(out_patch) + return replace( + self, + axes=tuple(axes), + dxs_or_spacing=tuple(dxs), + attrs=attrs, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + return replace(self, axes=tuple(axes), dxs_or_spacing=tuple(dxs), attrs=attrs) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = patch_tree.data + for axis, spacing in zip(self.axes, self.dxs_or_spacing, strict=True): + data = kernels.integrate_kernel( + data, axis=axis, dx_or_spacing=spacing, definite=self.definite + ) + if self.definite: + return patch_tree.new( + data=data, + coords=self.out_coords, + dims=self.out_dims, + coord_dtype_codes=self.out_dtype_codes, + ) + return patch_tree.new(data=data) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return ( + self.out_boundary + if self.definite and self.out_boundary + else boundary.new(attrs=self.attrs) + ) diff --git a/src/dasjax/operations/mute.py b/src/dasjax/operations/mute.py new file mode 100644 index 0000000..c59217d --- /dev/null +++ b/src/dasjax/operations/mute.py @@ -0,0 +1,102 @@ +"""Mute patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import numpy as np +import dascore as dc +from dascore.exceptions import ParameterError +from dascore.proc.mute import line_mute as dc_line_mute + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace + + +def _ones_patch(boundary: PatchBoundary): + """Create a metadata-only patch with ones for mask construction.""" + patch = dummy_patch(boundary) + return patch.update(data=np.ones(patch.shape, dtype=np.float64)) + + +@dataclass(frozen=True) +class LineMute(PatchOperation): + """Mute data in a region bounded by one or two lines.""" + + smooth: Any = None + invert: bool = False + relative: bool = True + kwargs: dict[str, Any] | None = None + mask: Any = None + + def __init__(self, *, smooth=None, invert=False, relative=True, **kwargs): + object.__setattr__(self, "smooth", smooth) + object.__setattr__(self, "invert", bool(invert)) + object.__setattr__(self, "relative", bool(relative)) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "mask", None) + + def bind(self, boundary: PatchBoundary) -> Self: + mask_patch = dc_line_mute.func( + _ones_patch(boundary), + smooth=self.smooth, + invert=self.invert, + relative=self.relative, + **(self.kwargs or {}), + ) + return replace(self, mask=np.asarray(mask_patch.data)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.apply_mask_kernel(patch_tree.data, self.mask)) + + +@dataclass(frozen=True) +class SlopeMute(PatchOperation): + """Mute data between two slope boundaries.""" + + slopes: Any + dims: tuple[str, str] = ("distance", "time") + smooth: Any = None + invert: bool = False + mask: Any = None + + def bind(self, boundary: PatchBoundary) -> Self: + slopes = np.asarray(self.slopes) + if slopes.shape != (2,): + msg = "slopes must be a sequence of length 2" + raise ParameterError(msg) + if np.any(slopes < 0): + msg = "slopes must be positive." + raise ParameterError(msg) + patch = _ones_patch(boundary) + coord_x, coord_y = (patch.get_coord(x, require_sorted=True) for x in self.dims) + origin = (float(dc.to_float(coord_x[0])), float(dc.to_float(coord_y[0]))) + range_x = float(dc.to_float(coord_x[-1] - coord_x[0])) + dim0_vals = [[origin[0], origin[0] + range_x], [origin[0], origin[0] + range_x]] + dim1_vals = [[origin[1], None], [origin[1], None]] + for num, slope in enumerate(slopes): + if np.isclose(slope, 0): + dim0_vals[num][1] = origin[0] + dim1_vals[num][1] = origin[1] + 1 + elif np.isinf(slope): + dim0_vals[num][1] = origin[0] + 1 + dim1_vals[num][1] = origin[1] + else: + dim1_vals[num][1] = origin[1] + range_x / slope + mask_patch = dc_line_mute.func( + patch, + **{ + self.dims[0]: dim0_vals, + self.dims[1]: dim1_vals, + "smooth": self.smooth, + "invert": self.invert, + "relative": False, + }, + ) + return replace(self, mask=np.asarray(mask_patch.data)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new(data=kernels.apply_mask_kernel(patch_tree.data, self.mask)) diff --git a/src/dasjax/operations/normalize.py b/src/dasjax/operations/normalize.py new file mode 100644 index 0000000..848e04e --- /dev/null +++ b/src/dasjax/operations/normalize.py @@ -0,0 +1,31 @@ +"""Normalize patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Self + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import replace + + +@dataclass(frozen=True) +class Normalize(PatchOperation): + """Normalize patch data along one dimension.""" + + dim: str + norm: str = "l2" + axis: int | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + return replace(self, axis=boundary.axis(self.dim)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.normalize_kernel( + patch_tree.data, axis=self.axis, norm=self.norm + ) + ) diff --git a/src/dasjax/operations/numeric.py b/src/dasjax/operations/numeric.py new file mode 100644 index 0000000..24cdf01 --- /dev/null +++ b/src/dasjax/operations/numeric.py @@ -0,0 +1,205 @@ +"""Numeric DASCore patch operations backed by host callbacks.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, ClassVar, Self + +import jax +import numpy as np + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .common import dummy_patch, replace, tree_boundary_from_patch + + +def _init_callback(obj: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> None: + object.__setattr__(obj, "args", args) + object.__setattr__(obj, "kwargs", kwargs) + object.__setattr__(obj, "boundary", None) + object.__setattr__(obj, "out_shape", None) + object.__setattr__(obj, "out_dtype", None) + object.__setattr__(obj, "out_boundary", None) + object.__setattr__(obj, "out_coords", None) + object.__setattr__(obj, "out_dtype_codes", None) + object.__setattr__(obj, "out_dims", None) + + +@dataclass(frozen=True) +class _DascoreCallbackOperation(PatchOperation): + """Run DASCore numeric transforms whose full kernels are not yet ported.""" + + register: ClassVar[bool] = False + args: tuple[Any, ...] = () + kwargs: dict[str, Any] | None = None + boundary: PatchBoundary | None = None + out_shape: tuple[int, ...] | None = None + out_dtype: Any = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def _call(self, patch): + return getattr(patch, type(self).operation_name())( + *self.args, + **(self.kwargs or {}), + ) + + def bind(self, boundary: PatchBoundary) -> Self: + out = self._call(dummy_patch(boundary)) + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + boundary=boundary, + out_shape=out.shape, + out_dtype=np.asarray(out.data).dtype, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.boundary is not None + assert self.out_shape is not None and self.out_dtype is not None + + def _callback(data, *coord_leaves): + coord_count = len(coord_leaves) // 2 + coords = tuple(coord_leaves[:coord_count]) + dtype_codes = tuple(coord_leaves[coord_count:]) + tree = PatchPyTree( + data=data, + coord_values=coords, + coord_dtype_codes=dtype_codes, + dims=self.boundary.dims, + ) + patch = self.boundary.to_patch(tree) + return np.asarray(self._call(patch).data) + + result = jax.pure_callback( + _callback, + jax.ShapeDtypeStruct(self.out_shape, self.out_dtype), + patch_tree.data, + *patch_tree.coord_values, + *patch_tree.coord_dtype_codes, + vmap_method="sequential", + ) + return patch_tree.new( + data=result, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class Correlate(_DascoreCallbackOperation): + """Correlate source rows or columns with all other rows or columns.""" + + def __init__(self, samples: bool = False, lag=None, **kwargs): + _init_callback(self, (), {"samples": samples, "lag": lag, **kwargs}) + + +@dataclass(frozen=True) +class Decimate(_DascoreCallbackOperation): + """Decimate a patch along a dimension.""" + + def __init__(self, filter_type: str | None = "iir", copy: bool = True, **kwargs): + _init_callback(self, (), {"filter_type": filter_type, "copy": copy, **kwargs}) + + +@dataclass(frozen=True) +class Interpolate(_DascoreCallbackOperation): + """Interpolate along one dimension.""" + + def __init__(self, kind: str | int = "linear", **kwargs): + _init_callback(self, (), {"kind": kind, **kwargs}) + + +@dataclass(frozen=True) +class Iresample(_DascoreCallbackOperation): + """Deprecated DASCore interpolation-resample operation.""" + + def __init__(self, *args, **kwargs): + _init_callback(self, tuple(args), dict(kwargs)) + + +@dataclass(frozen=True) +class Istft(_DascoreCallbackOperation): + """Invert a short-time Fourier transform.""" + + method_name: ClassVar[str | None] = "istft" + + +@dataclass(frozen=True) +class Resample(_DascoreCallbackOperation): + """Resample along one dimension.""" + + def __init__( + self, + window=None, + interp_kind: str = "linear", + samples: bool = False, + **kwargs, + ): + _init_callback( + self, + (), + { + "window": window, + "interp_kind": interp_kind, + "samples": samples, + **kwargs, + }, + ) + + +@dataclass(frozen=True) +class Rfft(_DascoreCallbackOperation): + """Perform DASCore's real FFT transform.""" + + method_name: ClassVar[str | None] = "rfft" + + def __init__(self, dim: str = "time"): + _init_callback(self, (), {"dim": dim}) + + +@dataclass(frozen=True) +class Spectrogram(_DascoreCallbackOperation): + """Calculate a spectrogram from patch data.""" + + def __init__(self, dim: str = "time", **kwargs): + _init_callback(self, (), {"dim": dim, **kwargs}) + + +@dataclass(frozen=True) +class Stft(_DascoreCallbackOperation): + """Perform a short-time Fourier transform.""" + + method_name: ClassVar[str | None] = "stft" + + def __init__( + self, + taper_window: str | np.ndarray | tuple[str, Any, ...] = "hann", + overlap=None, + samples: bool = False, + detrend: bool = False, + **kwargs, + ): + _init_callback( + self, + (), + { + "taper_window": taper_window, + "overlap": overlap, + "samples": samples, + "detrend": detrend, + **kwargs, + }, + ) diff --git a/src/dasjax/operations/pad.py b/src/dasjax/operations/pad.py new file mode 100644 index 0000000..cf92752 --- /dev/null +++ b/src/dasjax/operations/pad.py @@ -0,0 +1,104 @@ +"""Pad patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import jax.numpy as jnp +from dascore.proc.basic import pad as dc_pad +from dascore.utils.patch import get_dim_axis_value +from scipy.fft import next_fast_len + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class Pad(PatchOperation): + """Pad patch data and optionally expand coordinates.""" + + mode: str = "constant" + constant_values: Any = 0 + expand_coords: bool = True + samples: bool = False + kwargs: dict[str, Any] | None = None + data_pad_width: tuple[tuple[int, int], ...] = () + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def __init__( + self, + mode="constant", + constant_values=0, + expand_coords=True, + samples=False, + **kwargs, + ): + object.__setattr__(self, "mode", mode) + object.__setattr__(self, "constant_values", constant_values) + object.__setattr__(self, "expand_coords", expand_coords) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "data_pad_width", ()) + object.__setattr__(self, "out_boundary", None) + object.__setattr__(self, "out_coords", None) + object.__setattr__(self, "out_dtype_codes", None) + object.__setattr__(self, "out_dims", None) + + def bind(self, boundary: PatchBoundary) -> Self: + patch = dummy_patch(boundary) + pad_width = [(0, 0)] * len(patch.shape) + dimfo = get_dim_axis_value(patch, kwargs=self.kwargs or {}, allow_multiple=True) + for dim, axis, value in dimfo: + coord = patch.get_coord(dim, require_evenly_sampled=False) + if value in {"fft", "correlate"}: + target_length = len(coord) if value == "fft" else 2 * len(coord) - 1 + pad_tuple = (0, next_fast_len(target_length) - len(coord)) + else: + if not isinstance(value, (tuple, list)): + value = (value, value) + pad_tuple = ( + tuple(int(coord.get_sample_count(x)) for x in value) + if not self.samples + else tuple(int(x) for x in value) + ) + pad_width[axis] = tuple(pad_tuple) + out = dc_pad.func( + patch, + mode=self.mode, + constant_values=self.constant_values, + expand_coords=self.expand_coords, + samples=self.samples, + **(self.kwargs or {}), + ) + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + data_pad_width=tuple(pad_width), + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=jnp.pad( + patch_tree.data, + self.data_pad_width, + mode=self.mode, + constant_values=self.constant_values, + ), + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/spectro.py b/src/dasjax/operations/spectro.py new file mode 100644 index 0000000..cfeb479 --- /dev/null +++ b/src/dasjax/operations/spectro.py @@ -0,0 +1,142 @@ +"""Spectral patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import dascore as dc +import numpy as np +from dascore.utils.patch import get_dim_axis_value +from scipy.signal import ShortTimeFFT, get_window + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class Fbe(PatchOperation): + """Compute frequency-band energy with a short-time Fourier transform.""" + + overlap: Any = 0 + samples: bool = False + detrend: bool = False + taper_window: str | np.ndarray | tuple = "hann" + fmin: float | None = None + fmax: float | None = None + kwargs: dict[str, Any] | None = None + prepared: dict[str, Any] | None = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def __init__( + self, + overlap=0, + samples=False, + detrend=False, + taper_window="hann", + fmin=None, + fmax=None, + **kwargs, + ): + object.__setattr__(self, "overlap", overlap) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "detrend", detrend) + object.__setattr__(self, "taper_window", taper_window) + object.__setattr__(self, "fmin", fmin) + object.__setattr__(self, "fmax", fmax) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "prepared", None) + object.__setattr__(self, "out_boundary", None) + object.__setattr__(self, "out_coords", None) + object.__setattr__(self, "out_dtype_codes", None) + object.__setattr__(self, "out_dims", None) + + def bind(self, boundary: PatchBoundary) -> Self: + patch = dummy_patch(boundary) + call_kwargs = dict(self.kwargs or {}) + dim, axis, val = get_dim_axis_value(patch, kwargs=call_kwargs)[0] + coord = patch.get_coord(dim, require_evenly_sampled=True) + window_samples = coord.get_sample_count( + val, samples=self.samples, enforce_lt_coord=True + ) + step = dc.to_float(coord.step) + sampling_rate = 1 / abs(step) + window = ( + self.taper_window + if isinstance(self.taper_window, np.ndarray) + else get_window(self.taper_window, window_samples, fftbins=False) + ) + overlap = ( + coord[:window_samples].get_sample_count( + self.overlap, samples=self.samples, enforce_lt_coord=True + ) + if self.overlap is not None + else 0 + ) + hop = window_samples - overlap + stft = ShortTimeFFT( + win=window, + hop=hop, + fs=sampling_rate, + fft_mode="onesided", + mfft=window_samples, + ) + frame_times = np.asarray(stft.t(len(coord))) + frame_starts = ( + np.rint(frame_times * sampling_rate).astype(np.int64) - stft.m_num_mid + ) + frequencies = np.asarray(stft.f, dtype=np.float64) + mask = np.ones(len(frequencies), dtype=bool) + if self.fmin is not None: + mask &= frequencies >= self.fmin + if self.fmax is not None: + mask &= frequencies <= self.fmax + prepared = { + "axis": axis, + "window": np.asarray(window), + "frame_starts": frame_starts, + "selected_bins": np.flatnonzero(mask).astype(np.int64), + "sample_step": step, + "detrend": self.detrend, + } + # Reuse the existing DASCore STFT metadata construction by running on zeros. + out = patch.stft( + **{dim: val}, + overlap=self.overlap, + samples=self.samples, + detrend=self.detrend, + taper_window=self.taper_window, + ).abs() + ft_dim = next(dim_name for dim_name in out.dims if dim_name.startswith("ft_")) + if self.fmin is not None or self.fmax is not None: + out = out.select(**{ft_dim: (self.fmin, self.fmax)}) + out = out.sum(dim=ft_dim, dim_reduce="squeeze") + out_tree, out_boundary = tree_boundary_from_patch(out) + return replace( + self, + prepared=prepared, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.prepared is not None + data = kernels.banded_stft_kernel(patch_tree.data, **self.prepared) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/strain.py b/src/dasjax/operations/strain.py new file mode 100644 index 0000000..f224005 --- /dev/null +++ b/src/dasjax/operations/strain.py @@ -0,0 +1,167 @@ +"""Strain transform operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from operator import truediv +from typing import Any, Self + +import dascore as dc +import numpy as np +from dascore.exceptions import ParameterError +from dascore.units import convert_units, get_factor_and_unit, get_unit + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, get_data_units_from_dims, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class VelocityToStrainRate(PatchOperation): + """Convert velocity DAS data to strain rate using central differences.""" + + step_multiple: int = 2 + gauge_multiple: int | None = None + order: int = 2 + axis: int | None = None + spacing: float = 1.0 + attrs: Any = None + + def bind(self, boundary: PatchBoundary) -> Self: + step_multiple = ( + self.gauge_multiple * 2 + if self.gauge_multiple is not None + else self.step_multiple + ) + if step_multiple <= 0: + raise ParameterError("step_multiple must be positive.") + if step_multiple % 2 != 0: + msg = ( + "Step_multiple must be even. Use velocity_to_strain_rate_edgeless " + "if odd step multiples are required." + ) + raise ParameterError(msg) + coord = dummy_patch(boundary).get_coord("distance", require_evenly_sampled=True) + attrs = boundary.attrs.update( + data_type="strain_rate", + gauge_length=coord.step * step_multiple, + data_units=get_data_units_from_dims(boundary, ("distance",), truediv), + ) + return replace( + self, + step_multiple=step_multiple, + axis=boundary.axis("distance"), + spacing=float(dc.to_float(coord.step)), + attrs=attrs, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + data = kernels.differentiate_kernel( + patch_tree.data, + axis=self.axis, + dx_or_spacing=self.spacing, + order=self.order, + step=self.step_multiple // 2, + ) + return patch_tree.new(data=data) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return boundary.new(attrs=self.attrs) + + +@dataclass(frozen=True) +class VelocityToStrainRateEdgeless(PatchOperation): + """Estimate strain rate with central differences and dropped edges.""" + + step_multiple: int = 1 + axis: int | None = None + gauge_length: float = 1.0 + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + if self.step_multiple <= 0: + raise ParameterError("step_multiple must be positive.") + out_patch = dummy_patch(boundary).velocity_to_strain_rate_edgeless( + step_multiple=self.step_multiple + ) + out_tree, out_boundary = tree_boundary_from_patch(out_patch) + gauge_length = float(dc.to_float(boundary.coord("distance").step)) * self.step_multiple + return replace( + self, + axis=boundary.axis("distance"), + gauge_length=gauge_length, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + data = kernels.velocity_to_strain_rate_edgeless_kernel( + patch_tree.data, + axis=self.axis, + step_multiple=self.step_multiple, + gauge_length=self.gauge_length, + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary + + +@dataclass(frozen=True) +class RadiansToStrain(PatchOperation): + """Convert radians data units to strain.""" + + gauge_length: Any = None + wave_length: float = 1550.0 * 10 ** (-9) + stress_constant: float = 0.79 + refractive_index: float = 1.445 + factor: float = 1.0 + attrs: Any = None + + def bind(self, boundary: PatchBoundary) -> Self: + gauge_source = ( + self.gauge_length + if self.gauge_length is not None + else getattr(boundary.attrs, "gauge_length", None) + ) + gauge = convert_units(gauge_source, "m") + if gauge is None or gauge <= 0: + msg = ( + "Gauge length must be non-zero positive and provided " + "or defined in patch attrs." + ) + raise ParameterError(msg) + quant = dc.get_quantity(boundary.attrs.data_units) + if str(dc.get_unit("radians")) not in str(quant): + return replace(self, factor=1.0, attrs=boundary.attrs) + const = self.wave_length / ( + 4 * np.pi * self.refractive_index * gauge * self.stress_constant + ) + data_units = boundary.attrs.get("data_units", None) + data_factor, data_unit = get_factor_and_unit(data_units, simplify=True) + new_units = get_unit(data_unit) * get_unit("strain/radians") + attrs = boundary.attrs.update(data_units=new_units) + return replace(self, factor=float(const * data_factor), attrs=attrs) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree.new( + data=kernels.radians_to_strain_kernel(patch_tree.data, self.factor) + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + return boundary.new(attrs=self.attrs) diff --git a/src/dasjax/operations/taper.py b/src/dasjax/operations/taper.py new file mode 100644 index 0000000..c87d308 --- /dev/null +++ b/src/dasjax/operations/taper.py @@ -0,0 +1,163 @@ +"""Taper patch operations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import reduce +from operator import add +from typing import Any, Self + +import dascore as dc +import numpy as np +from dascore.exceptions import ParameterError +from scipy.signal import get_window + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace + + +def _taper_window(window_type: str, size: int) -> np.ndarray: + return np.asarray(get_window(window_type, size, fftbins=False), dtype=np.float64) + + +def _taper_slices(boundary: PatchBoundary, kwargs: dict[str, Any]): + dim = next(key for key in kwargs if key in boundary.dims) + axis = boundary.axis(dim) + value = kwargs[dim] + coord = boundary.coord(dim) + if isinstance(value, (tuple, list, np.ndarray)): + start, stop = value + else: + start, stop = value, value + dur = coord.coord_range(extend=False) + clses = (dc.units.Quantity, np.timedelta64) + start = start if isinstance(start, clses) or start is None else start * dur + stop = stop if isinstance(stop, clses) or stop is None else stop * dur + stop = -stop if stop is not None else stop + _, inds_1 = coord.select((None, start), relative=True) + _, inds_2 = coord.select((stop, None), relative=True) + return axis, inds_1, inds_2 + + +@dataclass(frozen=True) +class Taper(PatchOperation): + """Apply edge tapers to patch data along one dimension.""" + + window_type: str = "hann" + kwargs: dict[str, Any] | None = None + axis: int | None = None + weight: Any = None + + def __init__(self, window_type: str = "hann", **kwargs): + object.__setattr__(self, "window_type", window_type) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "weight", None) + + def bind(self, boundary: PatchBoundary) -> Self: + axis, start_slice, end_slice = _taper_slices(boundary, self.kwargs or {}) + length = boundary.coords.shape[axis] + start_len = start_slice.stop + end_len = length - end_slice.start + if ( + start_len is not None + and end_len is not None + and start_len > end_slice.start + ): + raise ParameterError("Taper windows cannot overlap") + weight = np.ones(length, dtype=np.float64) + if start_len is not None and start_len > 0: + weight[:start_len] = _taper_window(self.window_type, 2 * start_len)[ + :start_len + ] + if end_slice.start is not None and end_slice.start < length: + weight[end_slice.start :] = _taper_window(self.window_type, 2 * end_len)[ + end_len: + ] + return replace(self, axis=axis, weight=weight) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight) + ) + + +def _taper_coord_inds(coord, values, relative, samples): + error_msg = "A len 2 or 4 sequence is required for taper values" + if not isinstance(values, (tuple, list, np.ndarray)) or not len(values): + raise ParameterError(error_msg) + if isinstance(values[0], (tuple, list, np.ndarray)): + return reduce( + add, (_taper_coord_inds(coord, item, relative, samples) for item in values) + ) + if len(values) not in {2, 4}: + raise ParameterError(error_msg) + out = [None] * len(values) + for idx, value in enumerate(values): + if value is None or value == ...: + if len(values) == 2: + raise ParameterError( + "Cannot use ... or None when only two values provided" + ) + out[idx] = 0 if (idx / len(out)) < 0.5 else len(coord) - 1 + else: + out[idx] = coord.get_next_index(value, samples=samples, relative=relative) + return [[0, *out, len(coord)]] if len(out) == 2 else [out] + + +def _taper_curve(coord, ind_1, ind_2, window_type, reverse=False): + taper = _taper_window(window_type, (ind_2 - ind_1) * 2 + 1)[: ind_2 - ind_1] + return taper[::-1] if reverse else taper + + +@dataclass(frozen=True) +class TaperRange(PatchOperation): + """Apply tapers around selected coordinate ranges.""" + + window_type: str = "hann" + invert: bool = False + relative: bool = False + samples: bool = False + kwargs: dict[str, Any] | None = None + axis: int | None = None + weight: Any = None + + def __init__( + self, + window_type: str = "hann", + invert=False, + relative=False, + samples=False, + **kwargs, + ): + object.__setattr__(self, "window_type", window_type) + object.__setattr__(self, "invert", invert) + object.__setattr__(self, "relative", relative) + object.__setattr__(self, "samples", samples) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "weight", None) + + def bind(self, boundary: PatchBoundary) -> Self: + kwargs = self.kwargs or {} + dim = next(key for key in kwargs if key in boundary.dims) + axis = boundary.axis(dim) + coord = dummy_patch(boundary).get_coord(dim, require_sorted=True) + inds = _taper_coord_inds(coord, kwargs[dim], self.relative, self.samples) + weight = np.zeros(len(coord)) + for i1, i2, i3, i4 in inds: + weight[i1:i2] += _taper_curve(coord, i1, i2, self.window_type) + weight[i3:i4] += _taper_curve(coord, i3, i4, self.window_type, reverse=True) + weight[i2:i3] += 1 + if self.invert: + weight = np.abs(weight - np.max(weight)) + return replace(self, axis=axis, weight=np.asarray(weight)) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + return patch_tree.new( + data=kernels.apply_1d_weight_kernel(patch_tree.data, self.axis, self.weight) + ) diff --git a/src/dasjax/operations/taup.py b/src/dasjax/operations/taup.py new file mode 100644 index 0000000..1cb7e9e --- /dev/null +++ b/src/dasjax/operations/taup.py @@ -0,0 +1,80 @@ +"""Tau-p transform operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import dascore as dc +import numpy as np +from dascore.exceptions import ParameterError +from dascore.units import convert_units + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace, tree_boundary_from_patch + + +@dataclass(frozen=True) +class TauP(PatchOperation): + """Compute a linear tau-p transform.""" + + method_name = "tau_p" + + velocities: Any + distances: Any = None + dt: float = 1.0 + p_values: Any = None + out_boundary: PatchBoundary | None = None + out_coords: tuple[Any, ...] | None = None + out_dtype_codes: tuple[Any, ...] | None = None + out_dims: tuple[str, ...] | None = None + + def bind(self, boundary: PatchBoundary) -> Self: + velocities = np.asarray(convert_units(self.velocities, to_units="m/s")) + if np.any(velocities <= 0): + raise ParameterError("Input velocities must be positive.") + if not np.all(np.diff(velocities) > 0): + raise ParameterError("Input velocities must be monotonically increasing.") + patch = dummy_patch(boundary).convert_units(distance="m", time="s").transpose( + "distance", "time" + ) + out_patch = patch.tau_p(velocities) + out_tree, out_boundary = tree_boundary_from_patch(out_patch) + dist = patch.get_coord("distance") + distances = ( + np.arange(len(dist), dtype=np.float64) * float(dc.to_float(dist.step)) + if dist.evenly_sampled + else np.asarray(dc.to_float(dist.values), dtype=np.float64) + ) + return replace( + self, + velocities=velocities, + distances=distances, + dt=float(dc.to_float(patch.get_coord("time").step)), + p_values=1.0 / velocities, + out_boundary=out_boundary, + out_coords=out_tree.coord_values, + out_dtype_codes=out_tree.coord_dtype_codes, + out_dims=out_tree.dims, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + data = kernels.tau_p_kernel( + patch_tree.data, + distances=self.distances, + dt=self.dt, + p_values=self.p_values, + ) + return patch_tree.new( + data=data, + coords=self.out_coords, + coord_dtype_codes=self.out_dtype_codes, + dims=self.out_dims, + ) + + def update_boundary(self, boundary: PatchBoundary) -> PatchBoundary: + _ = boundary + assert self.out_boundary is not None + return self.out_boundary diff --git a/src/dasjax/operations/whiten.py b/src/dasjax/operations/whiten.py new file mode 100644 index 0000000..d8c87e3 --- /dev/null +++ b/src/dasjax/operations/whiten.py @@ -0,0 +1,100 @@ +"""Whiten patch operation.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Self + +import dascore as dc +from dascore.transform.fourier import dft as dc_dft +from dascore.utils.transformatter import FourierTransformatter +import jax.numpy as jnp +from scipy.fft import next_fast_len + +from dasjax.core import PatchBoundary, PatchOperation, PatchPyTree + +from .. import kernels +from .common import dummy_patch, replace + + +@dataclass(frozen=True) +class Whiten(PatchOperation): + """Whiten patch data along a frequency-domain dimension.""" + + smooth_size: float | None = None + water_level: float | None = None + kwargs: dict[str, Any] | None = None + axis: int | None = None + window_len: int | None = None + pad_after: int = 0 + sample_step: float = 1.0 + input_is_fft: bool = False + + def __init__(self, smooth_size=None, water_level=None, **kwargs): + object.__setattr__(self, "smooth_size", smooth_size) + object.__setattr__(self, "water_level", water_level) + object.__setattr__(self, "kwargs", dict(kwargs)) + object.__setattr__(self, "axis", None) + object.__setattr__(self, "window_len", None) + object.__setattr__(self, "pad_after", 0) + object.__setattr__(self, "sample_step", 1.0) + object.__setattr__(self, "input_is_fft", False) + + def bind(self, boundary: PatchBoundary) -> Self: + kwargs = self.kwargs or {} + dim = next(iter(kwargs), "time" if "time" in boundary.dims else "time") + fft_dim = FourierTransformatter().rename_dims(dim)[0] + input_is_fft = dim not in boundary.dims and fft_dim in boundary.dims + axis_dim = fft_dim if input_is_fft else dim + axis = boundary.axis(axis_dim) + sample_step = ( + 1.0 + if input_is_fft + else abs(float(dc.to_float(boundary.coord(dim).step))) + ) + axis_len = len(boundary.coord(axis_dim)) + pad_after = 0 if input_is_fft else next_fast_len(axis_len) - axis_len + window_len = None + if self.smooth_size is not None: + coord = boundary.coord(fft_dim) if input_is_fft else None + if coord is None: + fft_patch = dc_dft.func(dummy_patch(boundary), dim=dim, real=True) + coord = fft_patch.get_coord(fft_dim) + window_len = coord.get_sample_count(self.smooth_size, enforce_lt_coord=True) + return replace( + self, + axis=axis, + window_len=window_len, + pad_after=pad_after, + sample_step=sample_step, + input_is_fft=input_is_fft, + ) + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + assert self.axis is not None + data = patch_tree.data + if self.input_is_fft: + data = kernels.whiten_spectrum_kernel( + data, + axis=self.axis, + window_len=self.window_len, + water_level=self.water_level, + ) + return patch_tree.new(data=data) + if self.pad_after: + pad_width = [(0, 0)] * len(patch_tree.dims) + pad_width[self.axis] = (0, self.pad_after) + data = jnp.pad(data, tuple(pad_width)) + data = kernels.whiten_kernel( + data, + axis=self.axis, + window_len=self.window_len, + water_level=self.water_level, + ) / self.sample_step + if self.pad_after: + slices = [slice(None)] * data.ndim + slices[self.axis] = slice(0, data.shape[self.axis] - self.pad_after) + data = data[tuple(slices)] + return patch_tree.new( + data=data, + ) diff --git a/src/dasjax/pipeline.py b/src/dasjax/pipeline.py index d31ea9e..0140556 100644 --- a/src/dasjax/pipeline.py +++ b/src/dasjax/pipeline.py @@ -2,10 +2,13 @@ from __future__ import annotations +import hashlib +from collections.abc import Callable from collections import OrderedDict from dataclasses import dataclass, fields, is_dataclass from typing import Any, ClassVar +import dascore as dc import jax import numpy as np from jax import tree_util @@ -85,11 +88,12 @@ def _freeze_device(device: jax.Device | None) -> Any: ) -def _resolve_target_device( +def _resolve_compile_target( *, device: jax.Device | None = None, backend: str | None = None, ) -> jax.Device | None: + """Return the device on which compiled inputs should be placed.""" if device is not None and backend is not None: msg = "Pass either device or backend to compile(), not both." raise ValueError(msg) @@ -106,12 +110,13 @@ def _resolve_target_device( def _freeze_value(value: Any) -> Any: """Convert nested values into hashable cache-key components.""" - if isinstance(value, np.ndarray): + if isinstance(value, np.ndarray | jax.Array): + contiguous = np.ascontiguousarray(np.asarray(value)) return ( "ndarray", - str(value.dtype), - value.shape, - tuple(np.asarray(value).reshape(-1).tolist()), + contiguous.dtype.str, + contiguous.shape, + hashlib.blake2b(contiguous.tobytes(), digest_size=16).hexdigest(), ) if isinstance(value, dict): return tuple((key, _freeze_value(val)) for key, val in sorted(value.items())) @@ -134,10 +139,37 @@ def _operation_key(operation: Any) -> tuple[Any, ...]: for field in fields(operation) ) else: - entries = tuple((key, _freeze_value(value)) for key, value in vars(operation).items()) + entries = tuple( + (key, _freeze_value(value)) for key, value in vars(operation).items() + ) return type(operation).operation_name(), entries +def _boundary_cache_key( + patch_tree: PatchPyTree, + boundary: Any, +) -> tuple[Any, ...]: + """Return a cache key for static metadata used during operation binding.""" + return ( + patch_tree.dims, + tuple( + ( + name, + _freeze_value(value), + int(np.asarray(dtype_code).item()), + repr(boundary.coord(name).units), + ) + for name, value, dtype_code in zip( + boundary.coord_names, + patch_tree.coord_values, + patch_tree.coord_dtype_codes, + strict=True, + ) + ), + repr(boundary.attrs), + ) + + class JaxPatchPipeline: """A reusable recipe composed of registered dasjax operations.""" @@ -168,9 +200,9 @@ def _compile_cache_key( *, device: jax.Device | None = None, backend: str | None = None, - assert_no_fallback: bool = False, ) -> tuple[Any, ...]: """Return a stable cache key for equivalent pipeline definitions.""" + _ = backend return ( tuple( ( @@ -181,29 +213,6 @@ def _compile_cache_key( for step in self._steps ), _freeze_device(device), - backend, - assert_no_fallback, - ) - - @staticmethod - def _validation_signature(patch) -> tuple[Any, ...]: - data = np.asarray(patch.data) - coord_sig = tuple( - ( - name, - tuple(patch.coords.dim_map[name]), - np.asarray(coord.values).dtype.str, - len(coord), - getattr(coord, "step", None), - ) - for name, coord in patch.coords.coord_map.items() - ) - return ( - tuple(patch.dims), - tuple(patch.shape), - data.dtype.str, - bool(np.isfinite(data).all()), - coord_sig, ) def _resolve_operations(self) -> tuple[Any, ...]: @@ -276,11 +285,7 @@ def _plan_core_segment( ) return tuple(segment_ops), current_boundary, False, op_index - def assert_no_fallback(self, patch) -> None: - """No-op compatibility method; core pipelines have no legacy fallback.""" - _ = patch - - def plan(self, patch) -> PipelinePlan: + def plan(self, patch: dc.Patch) -> PipelinePlan: """Return a diagnostic execution plan for this pipeline and patch.""" return self._plan_core_execution(patch, self._resolve_operations()) @@ -339,49 +344,82 @@ def compile( *, device: jax.Device | None = None, backend: str | None = None, - assert_no_fallback: bool = False, - ): - """Compile the recorded steps into a callable `Patch -> Patch`. + ) -> Callable[[dc.Patch], dc.Patch]: + """Build a reusable callable `Patch -> Patch` from recorded steps. Class-authored operations are bound against a patch boundary, grouped - into JIT segments, and reconstructed through the final boundary. + into JIT segments, and reconstructed through the final boundary. Binding + and segment JIT creation are lazy: they happen on the first compatible + patch call, then reuse cached segment runners. + + Parameters + ---------- + device + Exact JAX device on which patch-tree inputs are placed before + running JIT segments. Mutually exclusive with ``backend``. + backend + JAX backend name, such as ``"cpu"`` or ``"gpu"``. The first local + device for the backend is selected as the input placement target. """ - target_device = _resolve_target_device(device=device, backend=backend) + target_device = _resolve_compile_target( + device=device, + backend=backend, + ) + operations = self._resolve_operations() cache_key = self._compile_cache_key( device=target_device, - backend=backend, - assert_no_fallback=assert_no_fallback, ) cached = self._compiled_cache.get(cache_key) if cached is not None: return cached - operations = self._resolve_operations() core_segment_cache = _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE) + plan_cache = _BoundedCache(maxsize=_SEGMENT_CACHE_MAXSIZE) def _compiled_patch_fn(patch): patch_tree, boundary = PatchPyTree.from_patch(patch) current_tree = patch_tree + if target_device is not None: + current_tree = tree_util.tree_map( + lambda x: jax.device_put(x, device=target_device), + current_tree, + ) current_boundary = boundary op_index = 0 while op_index < len(operations): - bound_ops, planned_boundary, needs_result_boundary, op_index = ( - self._plan_core_segment( - operations, - current_boundary, - op_index, + boundary_key = _boundary_cache_key(current_tree, current_boundary) + plan_key = (op_index, boundary_key) + planned = plan_cache.get(plan_key) + if planned is None: + bound_ops, planned_boundary, needs_result_boundary, next_index = ( + self._plan_core_segment( + operations, + current_boundary, + op_index, + ) ) - ) - segment_key = tuple(_operation_key(bound_operation) for bound_operation in bound_ops) + segment_key = tuple( + _operation_key(bound_operation) for bound_operation in bound_ops + ) + planned = ( + bound_ops, + planned_boundary, + needs_result_boundary, + next_index, + segment_key, + ) + plan_cache.add(plan_key, planned) + ( + bound_ops, + planned_boundary, + needs_result_boundary, + op_index, + segment_key, + ) = planned compiled = core_segment_cache.get(segment_key) if compiled is None: compiled = self._build_core_runner(bound_ops) core_segment_cache.add(segment_key, compiled) - if target_device is not None: - current_tree = tree_util.tree_map( - lambda x: jax.device_put(x, device=target_device), - current_tree, - ) current_tree = compiled(current_tree) current_boundary = planned_boundary if needs_result_boundary: diff --git a/tests/operations/__init__.py b/tests/operations/__init__.py new file mode 100644 index 0000000..6f3fe64 --- /dev/null +++ b/tests/operations/__init__.py @@ -0,0 +1 @@ +"""Operation parity tests.""" diff --git a/tests/operations/helpers.py b/tests/operations/helpers.py new file mode 100644 index 0000000..465cfba --- /dev/null +++ b/tests/operations/helpers.py @@ -0,0 +1,50 @@ +"""Shared helpers for operation parity tests.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np + +from dasjax import JaxPatchPipeline + + +def assert_patch_close(left, right) -> None: + """Assert data closeness and exact coordinate preservation.""" + assert np.allclose(left.data, right.data, equal_nan=True, rtol=1e-5, atol=1e-6) + assert left.coords == right.coords + + +def complex_patch(patch): + """Return a patch with complex-valued data.""" + return patch.update(data=patch.data + 1j * patch.data) + + +def even_patch(patch): + """Return a patch with an even number of time samples.""" + return patch.select(time=(..., patch.get_coord("time").values[-2])) + + +def fourier_patch(patch): + """Return a patch transformed along time.""" + return patch.dft("time", real=True) + + +def fbe_baseline(patch): + """Return the DASCore baseline for frequency-band energy.""" + out = patch.stft(time=64, samples=True, overlap=32).abs() + ft_dim = next(dim for dim in out.dims if dim.startswith("ft_")) + out = out.select(**{ft_dim: (2.0, 10.0)}) + return out.sum(dim=ft_dim, dim_reduce="squeeze") + + +def assert_compiled_matches_dascore(case) -> None: + """Compile one pipeline case and compare it to the DASCore baseline.""" + name, args, kwargs, baseline, *rest = case + example_patch = dc.get_example_patch() + patch = rest[0](example_patch) if rest else example_patch + pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs) + + out = pipeline.compile()(patch) + expected = baseline(patch) + + assert_patch_close(out, expected) diff --git a/tests/operations/test_basic.py b/tests/operations/test_basic.py new file mode 100644 index 0000000..4b275eb --- /dev/null +++ b/tests/operations/test_basic.py @@ -0,0 +1,104 @@ +"""Parity tests for basic patch operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels import normalize_kernel + +from .helpers import assert_compiled_matches_dascore, assert_patch_close, complex_patch + + +CASES = ( + ("identity", (), {}, lambda p: p), + ("scale", (2.0,), {}, lambda p: p * 2.0), + ("add", (2.0,), {}, lambda p: p + 2.0), + ("abs", (), {}, lambda p: p.abs(), complex_patch), + ("clip", (-0.25, 0.25), {}, lambda p: p.update(data=np.clip(p.data, -0.25, 0.25))), + ("real", (), {}, lambda p: p.real(), complex_patch), + ("imag", (), {}, lambda p: p.imag(), complex_patch), + ("angle", (), {}, lambda p: p.angle(), complex_patch), + ("conj", (), {}, lambda p: p.conj(), complex_patch), + ("flip", ("time",), {}, lambda p: p.flip("time")), + ("roll", (), {"time": 5, "samples": True}, lambda p: p.roll(time=5, samples=True)), + ("standardize", (), {"dim": "time"}, lambda p: p.standardize(dim="time")), + ( + "normalize", + (), + {"dim": "time", "norm": "l2"}, + lambda p: p.normalize(dim="time", norm="l2"), + ), + ( + "pad", + (), + {"time": (2, 3), "samples": True}, + lambda p: p.pad(time=(2, 3), samples=True), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_basic_operation_matches_dascore(case) -> None: + """Match compiled basic operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +@pytest.mark.parametrize("norm", ["l1", "max", "bit"]) +def test_normalize_modes_match_dascore(norm: str) -> None: + """Cover non-default normalization modes.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().normalize(dim="time", norm=norm) + + assert_patch_close( + pipeline.compile()(patch), + patch.normalize(dim="time", norm=norm), + ) + + +def test_normalize_zero_and_invalid_mode() -> None: + """Cover zero-norm handling and invalid normalization mode.""" + data = np.zeros((2, 3)) + + assert np.array_equal(np.asarray(normalize_kernel(data, axis=1)), data) + with pytest.raises(ValueError, match="Unsupported normalization"): + normalize_kernel(data, axis=1, norm="bad") + + +def test_pad_fft_correlate_and_coordinate_padding() -> None: + """Cover special and non-sample pad width branches.""" + patch = dc.get_example_patch() + cases = ( + ({"time": "fft"}, lambda p: p.pad(time="fft")), + ({"time": "correlate"}, lambda p: p.pad(time="correlate")), + ( + {"time": np.timedelta64(1, "ms")}, + lambda p: p.pad(time=np.timedelta64(1, "ms")), + ), + ) + for kwargs, baseline in cases: + out = JaxPatchPipeline().pad(**kwargs).compile()(patch) + assert_patch_close(out, baseline(patch)) + + +def test_roll_update_coord_is_rejected() -> None: + """Cover unsupported roll coordinate updates.""" + patch = dc.get_example_patch() + with pytest.raises(NotImplementedError, match="update_coord=False"): + JaxPatchPipeline().roll(time=1, samples=True, update_coord=True).compile()(patch) + + +def test_aggregate_unsupported_options_are_rejected() -> None: + """Cover aggregate validation for unsupported methods and reductions.""" + patch = dc.get_example_patch() + + with pytest.raises(NotImplementedError, match="Unsupported aggregate method"): + JaxPatchPipeline().aggregate(dim="time", method=np.ptp).compile()(patch) + with pytest.raises(NotImplementedError, match="dim_reduce"): + JaxPatchPipeline().aggregate( + dim="time", + method="mean", + dim_reduce="bad", + ).compile()(patch) diff --git a/tests/operations/test_detrend.py b/tests/operations/test_detrend.py new file mode 100644 index 0000000..4713d6f --- /dev/null +++ b/tests/operations/test_detrend.py @@ -0,0 +1,48 @@ +"""Parity tests for detrend operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels import detrend_kernel, validate_detrend_type + +from .helpers import assert_compiled_matches_dascore, assert_patch_close + + +CASES = ( + ( + "detrend", + (), + {"dim": "time", "type": "constant"}, + lambda p: p.detrend(dim="time", type="constant"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_detrend_operation_matches_dascore(case) -> None: + """Match compiled detrend operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +@pytest.mark.parametrize("detrend_type", ["linear", "l", "c"]) +def test_detrend_aliases_match_dascore(detrend_type: str) -> None: + """Cover detrend aliases and the linear kernel path.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().detrend(dim="time", type=detrend_type) + + assert_patch_close( + pipeline.compile()(patch), + patch.detrend(dim="time", type=detrend_type), + ) + + +def test_detrend_rejects_invalid_type() -> None: + """Cover invalid detrend validation.""" + with pytest.raises(ValueError, match="Trend type"): + validate_detrend_type("curve") + with pytest.raises(ValueError, match="Trend type"): + detrend_kernel(np.arange(5.0), axis=0, type="curve") diff --git a/tests/operations/test_differentiate.py b/tests/operations/test_differentiate.py new file mode 100644 index 0000000..0334bad --- /dev/null +++ b/tests/operations/test_differentiate.py @@ -0,0 +1,45 @@ +"""Parity tests for differentiate operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest +from dascore.exceptions import ParameterError + +from dasjax import JaxPatchPipeline +from dasjax.kernels import differentiate_kernel + +from .helpers import assert_compiled_matches_dascore, assert_patch_close + + +CASES = ( + ("differentiate", (), {"dim": "time"}, lambda p: p.differentiate(dim="time")), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_differentiate_operation_matches_dascore(case) -> None: + """Match compiled differentiate operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_differentiate_step_and_uneven_spacing_paths() -> None: + """Cover stepped differentiation and uneven coordinate spacing.""" + patch = dc.get_example_patch() + stepped = JaxPatchPipeline().differentiate(dim="time", step=2).compile()(patch) + assert_patch_close(stepped, patch.differentiate(dim="time", step=2)) + + data = np.arange(5.0) ** 2 + spacing = np.asarray([0.0, 0.5, 1.5, 3.0, 5.0]) + out = np.asarray(differentiate_kernel(data, axis=0, dx_or_spacing=spacing)) + assert out.shape == data.shape + + with pytest.raises(NotImplementedError, match="order=2"): + differentiate_kernel(data, axis=0, dx_or_spacing=1.0, order=1) + with pytest.raises(ValueError, match="too small"): + differentiate_kernel(np.arange(2.0), axis=0, dx_or_spacing=1.0) + with pytest.raises(ParameterError, match="only be used along one axis"): + JaxPatchPipeline().differentiate(dim=("time", "distance"), step=2).compile()( + patch + ) diff --git a/tests/operations/test_domain.py b/tests/operations/test_domain.py new file mode 100644 index 0000000..e9fb956 --- /dev/null +++ b/tests/operations/test_domain.py @@ -0,0 +1,195 @@ +"""Parity tests for domain transform operations.""" + +from __future__ import annotations + +import numpy as np +import pytest +import dascore as dc +from dascore.exceptions import ParameterError + +from dasjax import JaxPatchPipeline + +from .helpers import assert_patch_close + + +def small_patch(): + """Return a compact patch for domain transform parity tests.""" + patch = dc.get_example_patch() + time = patch.get_coord("time").values + return patch.select(distance=(0, 20), time=(time[0], time[200])) + + +CASES = ( + ( + "line_mute", + (), + {"time": (0, 0.1)}, + lambda p: p.line_mute(time=(0, 0.1)), + small_patch, + ), + ( + "slope_mute", + ((1000.0, 3000.0),), + {}, + lambda p: p.slope_mute((1000.0, 3000.0)), + small_patch, + ), + ( + "wiener_filter", + (), + {"time": 5, "samples": True}, + lambda p: p.wiener_filter(time=5, samples=True), + small_patch, + ), + ( + "phase_weighted_stack", + ("distance",), + {"transform_dim": "time"}, + lambda p: p.phase_weighted_stack("distance", transform_dim="time"), + small_patch, + ), + ( + "slope_filter", + ([100.0, 200.0, 500.0, 1000.0],), + {}, + lambda p: p.slope_filter([100.0, 200.0, 500.0, 1000.0]), + small_patch, + ), + ( + "tau_p", + (np.asarray([1000.0, 2000.0]),), + {}, + lambda p: p.tau_p(np.asarray([1000.0, 2000.0])), + lambda: small_patch().set_units(distance="m", time="s"), + ), + ( + "dispersion_phase_shift", + (np.asarray([100.0, 200.0]),), + {"approx_freq": (1.0, 10.0)}, + lambda p: p.dispersion_phase_shift( + np.asarray([100.0, 200.0]), approx_freq=(1.0, 10.0) + ), + lambda: small_patch().set_units(distance="m", time="s"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_domain_operation_matches_dascore(case) -> None: + """Match compiled domain operations against DASCore baselines.""" + name, args, kwargs, baseline, patch_factory = case + patch = patch_factory() + pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs) + + assert_patch_close(pipeline.compile()(patch), baseline(patch)) + + +def test_compiled_strain_operations_match_dascore() -> None: + """Match compiled strain transforms against DASCore baselines.""" + patch = dc.get_example_patch("deformation_rate_event_1") + + cases = ( + ( + JaxPatchPipeline().velocity_to_strain_rate(), + patch.velocity_to_strain_rate(), + patch, + ), + ( + JaxPatchPipeline().velocity_to_strain_rate_edgeless(step_multiple=2), + patch.velocity_to_strain_rate_edgeless(step_multiple=2), + patch, + ), + ) + for pipeline, expected, source in cases: + assert_patch_close(pipeline.compile()(source), expected) + + radians_patch = patch.update( + data=patch.data, + attrs=patch.attrs.update(data_units="rad", gauge_length=10.0), + ) + assert_patch_close( + JaxPatchPipeline().radians_to_strain().compile()(radians_patch), + radians_patch.radians_to_strain(), + ) + + non_radian_patch = patch.update( + data=patch.data, + attrs=patch.attrs.update(data_units="m/s", gauge_length=10.0), + ) + assert_patch_close( + JaxPatchPipeline().radians_to_strain().compile()(non_radian_patch), + non_radian_patch, + ) + + +def test_domain_operation_validation_edges() -> None: + """Cover validation paths for domain transforms.""" + patch = small_patch().set_units(distance="m", time="s") + + no_freq_out = JaxPatchPipeline().dispersion_phase_shift( + np.asarray([100.0, 200.0]) + ).compile()(patch) + assert no_freq_out.shape == patch.dispersion_phase_shift( + np.asarray([100.0, 200.0]) + ).shape + + for velocities, message in ( + (np.asarray([200.0, 100.0]), "monotonically increasing"), + (np.asarray([-100.0, 200.0]), "positive"), + ): + with pytest.raises(ParameterError, match=message): + JaxPatchPipeline().dispersion_phase_shift(velocities).compile()(patch) + + for kwargs, message in ( + ({"approx_resolution": 0.0}, "Frequency resolution"), + ({"approx_freq": (0.0, 10.0)}, "Minimal and maximal"), + ({"approx_freq": (10.0, 1.0)}, "Maximal frequency"), + ({"approx_freq": (1.0, 1000.0)}, "Nyquist"), + ( + {"approx_resolution": 100.0, "approx_freq": (1.0, 2.0)}, + "not an array", + ), + ): + with pytest.raises(ParameterError, match=message): + JaxPatchPipeline().dispersion_phase_shift( + np.asarray([100.0, 200.0]), **kwargs + ).compile()(patch) + + for velocities, message in ( + (np.asarray([0.0, 1000.0]), "positive"), + (np.asarray([2000.0, 1000.0]), "monotonically increasing"), + ): + with pytest.raises(ParameterError, match=message): + JaxPatchPipeline().tau_p(velocities).compile()(patch) + + +def test_mute_and_strain_validation_edges() -> None: + """Cover mute and strain transform edge paths.""" + patch = small_patch().set_units(distance="m", time="s") + strain_patch = dc.get_example_patch("deformation_rate_event_1") + + assert_patch_close( + JaxPatchPipeline().slope_mute((0.0, np.inf)).compile()(patch), + patch.slope_mute((0.0, np.inf)), + ) + for slopes, message in ( + ((1.0,), "length 2"), + ((-1.0, 1.0), "positive"), + ): + with pytest.raises(ParameterError, match=message): + JaxPatchPipeline().slope_mute(slopes).compile()(patch) + + with pytest.raises(ParameterError, match="positive"): + JaxPatchPipeline().velocity_to_strain_rate(step_multiple=0).compile()( + strain_patch + ) + with pytest.raises(ParameterError, match="even"): + JaxPatchPipeline().velocity_to_strain_rate(step_multiple=3).compile()( + strain_patch + ) + with pytest.raises(ParameterError, match="positive"): + JaxPatchPipeline().velocity_to_strain_rate_edgeless(step_multiple=0).compile()( + strain_patch + ) + with pytest.raises(ParameterError, match="Gauge length"): + JaxPatchPipeline().radians_to_strain().compile()(strain_patch) diff --git a/tests/operations/test_filter.py b/tests/operations/test_filter.py new file mode 100644 index 0000000..0d5db66 --- /dev/null +++ b/tests/operations/test_filter.py @@ -0,0 +1,246 @@ +"""Parity tests for filter operations.""" + +from __future__ import annotations + +import dascore as dc +import jax.numpy as jnp +import numpy as np +import pytest +from dascore.exceptions import FilterValueError, ParameterError +from scipy.signal import wiener + +from dasjax import JaxPatchPipeline +from dasjax.kernels import ( + design_notch_filter, + design_pass_filter_sos, + gaussian_filter_kernel, + hampel_filter_kernel, + is_finite_array, + median_filter_kernel, + notch_filter_kernel, + pass_filter_default_padlen, + pass_filter_initial_state, + pass_filter_kernel, + savgol_coefficients, + savgol_filter_kernel, + sobel_filter_kernel, + wiener_filter_kernel, +) +from dasjax.kernels.filters import _iirfilt_rows + +from .helpers import assert_compiled_matches_dascore, even_patch + + +CASES = ( + ( + "gaussian_filter", + (), + {"time": 3, "samples": True}, + lambda p: p.gaussian_filter(time=3, samples=True), + ), + ( + "hampel_filter", + (), + {"time": 3, "samples": True, "threshold": 3.5, "approximate": True}, + lambda p: p.hampel_filter( + time=3, samples=True, threshold=3.5, approximate=True + ), + ), + ( + "median_filter", + (), + {"time": 3, "samples": True}, + lambda p: p.median_filter(time=3, samples=True), + ), + ( + "notch_filter", + (), + {"time": 10.0, "q": 30.0}, + lambda p: p.notch_filter(time=10.0, q=30.0), + even_patch, + ), + ( + "pass_filter", + (), + {"time": (1.0, 10.0), "corners": 4, "zerophase": True}, + lambda p: p.pass_filter(time=(1.0, 10.0), corners=4, zerophase=True), + even_patch, + ), + ( + "savgol_filter", + (2,), + {"time": 5, "samples": True}, + lambda p: p.savgol_filter(2, time=5, samples=True), + ), + ( + "sobel_filter", + ("time",), + {}, + lambda p: p.sobel_filter("time"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_filter_operation_matches_dascore(case) -> None: + """Match compiled filter operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_filter_kernel_and_design_edges() -> None: + """Cover pass-filter validation and lower-level kernel branches.""" + data = np.sin(np.linspace(0, 1, 20))[None, :] + sos = design_pass_filter_sos(100.0, None, 10.0, 2) + + assert is_finite_array(data) + assert not is_finite_array([1.0, np.nan]) + assert design_pass_filter_sos(100.0, 10.0, None, 2).shape[1] == 6 + assert design_pass_filter_sos(100.0, 5.0, 20.0, 2).shape[1] == 6 + for args in ( + (100.0, -1.0, None, 2), + (100.0, None, 60.0, 2), + (100.0, 20.0, 10.0, 2), + (100.0, None, None, 2), + ): + with pytest.raises(FilterValueError): + design_pass_filter_sos(*args) + + zi = pass_filter_initial_state(sos) + assert pass_filter_default_padlen(sos) > 0 + assert np.asarray( + pass_filter_kernel(data, sos, axis=1, zi=zi, zerophase=False) + ).shape == data.shape + assert np.asarray( + pass_filter_kernel(data, sos, axis=1, zi=zi, padlen=0) + ).shape == data.shape + assert np.asarray( + pass_filter_kernel(data, sos, axis=1, zerophase=False) + ).shape == data.shape + with pytest.raises(ValueError, match="requires zi"): + pass_filter_kernel(data, jnp.asarray(sos), axis=1, zi=None) + with pytest.raises(ValueError, match="greater than padlen"): + pass_filter_kernel(data[:, :2], sos, axis=1, zi=zi, padlen=3) + + patch = even_patch(dc.get_example_patch()) + with pytest.raises(ParameterError, match="greater than zero"): + JaxPatchPipeline().hampel_filter(time=3, samples=True, threshold=0).compile()( + patch + ) + + +def test_jax_filter_kernel_edge_modes_and_validation() -> None: + """Cover JAX-native filter modes and validation paths.""" + data = np.arange(12.0).reshape(3, 4) + + assert np.asarray(gaussian_filter_kernel(data, sigma=(), axes=())).shape == data.shape + assert np.asarray( + gaussian_filter_kernel(data, sigma=(-1.0,), axes=(1,), truncate=4.0) + ).shape == data.shape + assert np.asarray( + gaussian_filter_kernel(data, sigma=(0.1,), axes=(1,), truncate=0.1) + ).shape == data.shape + for mode in ("nearest", "constant", "wrap", "mirror"): + assert np.asarray( + gaussian_filter_kernel(data, sigma=(1.0,), axes=(1,), mode=mode) + ).shape == data.shape + with pytest.raises(ValueError, match="Unsupported gaussian_filter mode"): + gaussian_filter_kernel(data, sigma=(1.0,), axes=(1,), mode="bad") + + assert np.asarray(median_filter_kernel(data, size=(1, 1))).shape == data.shape + for mode in ("grid-constant", "grid-wrap", "mirror"): + assert np.asarray(median_filter_kernel(data, size=(1, 3), mode=mode)).shape == ( + data.shape + ) + with pytest.raises(ValueError, match="Unsupported filter mode"): + median_filter_kernel(data, size=(1, 3), mode="bad") + + assert np.allclose( + np.asarray(wiener_filter_kernel(data, size=(1, 3), noise=0.1)), + wiener(data, mysize=(1, 3), noise=0.1), + equal_nan=True, + ) + assert np.asarray(sobel_filter_kernel(data, axis=1, mode="nearest")).shape == ( + data.shape + ) + + +def test_savgol_and_notch_kernel_edges() -> None: + """Cover Savitzky-Golay and notch kernel edge branches.""" + data = np.arange(12.0).reshape(3, 4) + coeff, left, right = savgol_coefficients(3, 1) + + assert np.asarray( + savgol_filter_kernel( + data, + size=(1, 3), + axes=(1,), + coeffs=(coeff,), + left_coeffs=(left,), + right_coeffs=(right,), + mode="nearest", + ) + ).shape == data.shape + with pytest.raises(ValueError, match="window_length"): + savgol_filter_kernel( + data[:, :2], + size=(1, 3), + axes=(1,), + coeffs=(coeff,), + left_coeffs=(left,), + right_coeffs=(right,), + ) + + with pytest.raises(FilterValueError): + design_notch_filter(100.0, 60.0, 30.0) + b, a, zi, padlen = design_notch_filter(100.0, 10.0, 30.0) + assert np.asarray(notch_filter_kernel(data, b, a, zi, padlen=0, axis=1)).shape == ( + data.shape + ) + with pytest.raises(ValueError, match="greater than padlen"): + notch_filter_kernel(data[:, :2], b, a, zi, padlen=padlen, axis=1) + + filtered, states = _iirfilt_rows( + jnp.asarray(data[:1]), + jnp.asarray(b), + jnp.asarray(a), + ) + assert filtered.shape == data[:1].shape + assert states.shape == (1, len(b) - 1) + + +def test_hampel_integer_and_exact_rejection_paths() -> None: + """Cover Hampel integer round-trip and exact-mode rejection.""" + data = np.asarray([[1, 100, 1, 1, 1]], dtype=np.int32) + + native = np.asarray(hampel_filter_kernel(data, size=(1, 3), threshold=1.0)) + approx = np.asarray( + hampel_filter_kernel( + data.astype(float), size=(1, 3), threshold=1.0, approximate=True + ) + ) + + assert native.dtype == data.dtype + assert approx.shape == data.shape + with pytest.raises(NotImplementedError, match="pure JAX"): + hampel_filter_kernel( + data.astype(float), size=(1, 3), threshold=1.0, approximate=False + ) + with pytest.raises(NotImplementedError, match="pure JAX"): + JaxPatchPipeline().hampel_filter( + time=3, samples=True, approximate=False + ).compile() + + +def test_filter_operation_validation_edges() -> None: + """Cover operation-level validation branches.""" + patch = even_patch(dc.get_example_patch()) + + with pytest.raises(FilterValueError, match="dim parameter"): + JaxPatchPipeline().sobel_filter(1).compile()(patch) + with pytest.raises(ParameterError, match="wiener_filter"): + JaxPatchPipeline().wiener_filter().compile()(patch) + with pytest.raises(ParameterError, match="sorted length 4"): + JaxPatchPipeline().slope_filter([1.0, 3.0, 2.0, 4.0]).compile()(patch) + + out = JaxPatchPipeline().notch_filter(time=10.0 * dc.get_unit("Hz"), q=30.0) + assert out.compile()(patch).shape == patch.shape diff --git a/tests/operations/test_fourier.py b/tests/operations/test_fourier.py new file mode 100644 index 0000000..407c09a --- /dev/null +++ b/tests/operations/test_fourier.py @@ -0,0 +1,57 @@ +"""Parity tests for Fourier operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline + +from .helpers import assert_compiled_matches_dascore, assert_patch_close, fourier_patch + + +CASES = ( + ("dft", (), {"dim": "time", "real": True}, lambda p: p.dft(dim="time", real=True)), + ("idft", (), {}, lambda p: p.idft(), fourier_patch), + ( + "correlate_shift", + ("time",), + {}, + lambda p: p.correlate_shift("time"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_fourier_operation_matches_dascore(case) -> None: + """Match compiled Fourier operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_fourier_complex_paths() -> None: + """Cover complex DFT and IDFT kernel branches.""" + patch = dc.get_example_patch() + complex_patch = patch.update(data=patch.data + 1j * patch.data) + transformed = JaxPatchPipeline().dft(dim="time", real=False).compile()(complex_patch) + expected = complex_patch.dft(dim="time", real=False) + assert_patch_close(transformed, expected) + + restored = JaxPatchPipeline().idft().compile()(transformed) + assert_patch_close(restored, expected.idft()) + + odd = patch.select(time=(..., patch.get_coord("time").values[-2])) + padded = JaxPatchPipeline().dft(dim="time", real=True).compile()(odd) + assert_patch_close(padded, odd.dft(dim="time", real=True)) + + +def test_fourier_preserves_float32_precision() -> None: + """Do not promote float32 Fourier data through float64 scale factors.""" + patch = dc.get_example_patch() + patch = patch.update(data=np.asarray(patch.data, dtype=np.float32)) + + transformed = JaxPatchPipeline().dft(dim="time", real=True).compile()(patch) + restored = JaxPatchPipeline().idft().compile()(transformed) + + assert transformed.data.dtype == np.dtype("complex64") + assert restored.data.dtype == np.dtype("float32") diff --git a/tests/operations/test_hilbert.py b/tests/operations/test_hilbert.py new file mode 100644 index 0000000..38ad5fe --- /dev/null +++ b/tests/operations/test_hilbert.py @@ -0,0 +1,72 @@ +"""Parity tests for Hilbert operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels.spectral import _analytic_multiplier + +from .helpers import assert_compiled_matches_dascore, even_patch + + +CASES = ( + ("hilbert", (), {"dim": "time"}, lambda p: p.hilbert(dim="time"), even_patch), + ("envelope", (), {"dim": "time"}, lambda p: p.envelope(dim="time"), even_patch), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_hilbert_operation_matches_dascore(case) -> None: + """Match compiled Hilbert operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_hilbert_even_multiplier_and_error() -> None: + """Cover even analytic multiplier and uneven-coordinate Hilbert errors.""" + assert _analytic_multiplier(4, "complex128").tolist() == [1, 2, 1, 0] + + patch = dc.get_example_patch() + coord = patch.get_coord("time").values.astype("datetime64[ns]") + coord[1000:] += np.timedelta64(1, "ms") + uneven = patch.update( + coords={ + "distance": patch.get_coord("distance").values, + "time": coord, + } + ) + with pytest.raises(dc.exceptions.CoordError): + JaxPatchPipeline().hilbert(dim="time").compile()(uneven) + + +def test_phase_weighted_stack_infers_transform_dim_and_errors() -> None: + """Cover transform-dimension inference and uneven-coordinate validation.""" + patch = even_patch(dc.get_example_patch()) + + assert np.allclose( + JaxPatchPipeline().phase_weighted_stack("distance").compile()(patch).data, + patch.phase_weighted_stack("distance").data, + rtol=1e-5, + atol=1e-6, + ) + + coord = patch.get_coord("time").values.astype("datetime64[ns]") + coord[1000:] += np.timedelta64(1, "ms") + uneven = patch.update( + coords={ + "distance": patch.get_coord("distance").values, + "time": coord, + } + ) + with pytest.raises(dc.exceptions.CoordError): + JaxPatchPipeline().phase_weighted_stack("distance").compile()(uneven) + + patch_3d = dc.Patch( + data=np.ones((2, 3, 4)), + coords={"x": np.arange(2), "y": np.arange(3), "z": np.arange(4)}, + dims=("x", "y", "z"), + ) + with pytest.raises(dc.exceptions.ParameterError, match="transform_dim"): + JaxPatchPipeline().phase_weighted_stack("x").compile()(patch_3d) diff --git a/tests/operations/test_integrate.py b/tests/operations/test_integrate.py new file mode 100644 index 0000000..a7799e2 --- /dev/null +++ b/tests/operations/test_integrate.py @@ -0,0 +1,42 @@ +"""Parity tests for integrate operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels import integrate_kernel + +from .helpers import assert_compiled_matches_dascore, assert_patch_close + + +CASES = ( + ("integrate", (), {"dim": "time"}, lambda p: p.integrate(dim="time")), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_integrate_operation_matches_dascore(case) -> None: + """Match compiled integrate operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_integrate_definite_path() -> None: + """Cover definite integration.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().integrate(dim="time", definite=True) + + assert_patch_close( + pipeline.compile()(patch), + patch.integrate(dim="time", definite=True), + ) + + +def test_integrate_vector_spacing_kernel_path() -> None: + """Cover vector-spacing integration kernel branches.""" + out = np.asarray( + integrate_kernel(np.arange(5.0), axis=0, dx_or_spacing=np.arange(5.0) ** 2) + ) + assert out.shape == (5,) diff --git a/tests/operations/test_numeric.py b/tests/operations/test_numeric.py new file mode 100644 index 0000000..f03fb64 --- /dev/null +++ b/tests/operations/test_numeric.py @@ -0,0 +1,142 @@ +"""Parity tests for additional numeric patch operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.operations.numeric import Iresample + +from .helpers import assert_patch_close + + +ELEMENTWISE_CASES = ( + ("subtract", (1.5,), {}, lambda p: p.subtract(1.5)), + ("multiply", (2.0,), {}, lambda p: p.multiply(2.0)), + ("divide", (2.0,), {}, lambda p: p.divide(2.0)), + ("maximum", (0.0,), {}, lambda p: p.maximum(0.0)), + ("minimum", (0.0,), {}, lambda p: p.minimum(0.0)), + ("exp", (), {}, lambda p: p.exp()), + ("log", (), {}, lambda p: p.log()), + ("log10", (), {}, lambda p: p.log10()), + ("log2", (), {}, lambda p: p.log2()), +) + + +@pytest.mark.parametrize("name,args,kwargs,baseline", ELEMENTWISE_CASES) +def test_compiled_elementwise_numeric_operations_match_dascore( + name, + args, + kwargs, + baseline, +) -> None: + """Match compiled elementwise numeric operations against DASCore.""" + patch = dc.get_example_patch() + positive = patch.update(data=np.asarray(patch.data) + 1.0) + pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs) + + assert_patch_close(pipeline.compile()(positive), baseline(positive)) + + +def test_compiled_null_and_boolean_numeric_operations_match_dascore() -> None: + """Cover fill/mask numeric methods with NaN and infinite values.""" + base = dc.get_example_patch() + data = np.asarray(base.data).copy() + data[0, :3] = [0.0, np.nan, np.inf] + patch = base.update(data=data) + cond = np.ones(patch.shape, dtype=bool) + cond[0, 1] = False + + cases = ( + (JaxPatchPipeline().fillna(-1.0), patch.fillna(-1.0)), + (JaxPatchPipeline().is_finite(), patch.is_finite()), + (JaxPatchPipeline().isinf(), patch.isinf()), + (JaxPatchPipeline().isnan(), patch.isnan()), + ( + JaxPatchPipeline().where(cond, other=-2.0), + patch.where(cond, other=-2.0), + ), + ) + for pipeline, expected in cases: + assert_patch_close(pipeline.compile()(patch), expected) + + +@pytest.mark.parametrize( + "name", + ["all", "any", "max", "mean", "median", "min", "std", "sum"], +) +def test_compiled_reductions_match_dascore(name: str) -> None: + """Match named reductions along a dimension.""" + patch = dc.get_example_patch() + if name in {"all", "any"}: + patch = patch > 0.5 + pipeline = getattr(JaxPatchPipeline(), name)(dim="time") + expected = getattr(patch, name)(dim="time") + + assert_patch_close(pipeline.compile()(patch), expected) + + +def test_compiled_aggregate_and_squeeze_reduction_match_dascore() -> None: + """Cover aggregate and squeezed dimension metadata.""" + patch = dc.get_example_patch() + + assert_patch_close( + JaxPatchPipeline().aggregate(dim="time", method="mean").compile()(patch), + patch.aggregate(dim="time", method="mean"), + ) + assert_patch_close( + JaxPatchPipeline().sum(dim="time", dim_reduce="squeeze").compile()(patch), + patch.sum(dim="time", dim_reduce="squeeze"), + ) + + +def test_compiled_callback_numeric_transforms_match_dascore() -> None: + """Cover heavier numeric transforms which delegate to DASCore callbacks.""" + patch = dc.get_example_patch() + interp_coord = patch.get_coord("time").values[::4] + cases = ( + ( + JaxPatchPipeline().correlate(distance=10, samples=True), + patch.correlate(distance=10, samples=True), + ), + ( + JaxPatchPipeline().decimate(time=2, filter_type=None), + patch.decimate(time=2, filter_type=None), + ), + ( + JaxPatchPipeline().interpolate(time=interp_coord), + patch.interpolate(time=interp_coord), + ), + ( + JaxPatchPipeline().resample(time=100, samples=True), + patch.resample(time=100, samples=True), + ), + (JaxPatchPipeline().rfft(dim="time"), patch.rfft(dim="time")), + ( + JaxPatchPipeline().spectrogram(dim="time"), + patch.spectrogram(dim="time"), + ), + ( + JaxPatchPipeline().stft(time=64, samples=True, overlap=32), + patch.stft(time=64, samples=True, overlap=32), + ), + ) + for pipeline, expected in cases: + assert_patch_close(pipeline.compile()(patch), expected) + + +def test_compiled_istft_matches_dascore() -> None: + """Cover inverse short-time Fourier transform callback.""" + patch = dc.get_example_patch().stft(time=64, samples=True, overlap=32) + + assert_patch_close(JaxPatchPipeline().istft().compile()(patch), patch.istft()) + + +def test_iresample_constructor_preserves_varargs() -> None: + """Cover deprecated iresample varargs constructor.""" + operation = Iresample("time", samples=True) + + assert operation.args == ("time",) + assert operation.kwargs == {"samples": True} diff --git a/tests/operations/test_spectro.py b/tests/operations/test_spectro.py new file mode 100644 index 0000000..552d19d --- /dev/null +++ b/tests/operations/test_spectro.py @@ -0,0 +1,89 @@ +"""Parity tests for spectral operations.""" + +from __future__ import annotations + +import dascore as dc +import jax.numpy as jnp +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels.spectral import ( + _extract_zero_padded_frames, + _linear_detrend_frames, + banded_stft_kernel, +) + +from .helpers import assert_compiled_matches_dascore, assert_patch_close, fbe_baseline + + +CASES = ( + ( + "fbe", + (), + {"time": 64, "samples": True, "overlap": 32, "fmin": 2.0, "fmax": 10.0}, + fbe_baseline, + lambda p: dc.get_example_patch("chirp"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_spectral_operation_matches_dascore(case) -> None: + """Match compiled spectral operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_banded_stft_edges() -> None: + """Cover STFT detrending, NaN frame handling, and one-sample frame helper.""" + data = np.arange(8.0)[None, :] + data[0, 0] = np.nan + window = np.hanning(4) + frame_starts = np.asarray([-1, 1, 6]) + out = np.asarray( + banded_stft_kernel( + data, + axis=1, + window=window, + frame_starts=frame_starts, + selected_bins=np.asarray([0, 1]), + sample_step=0.1, + detrend=True, + ) + ) + + assert out.shape == (1, 3) + assert out[0, 0] == 0.0 + assert np.array_equal( + np.asarray(_linear_detrend_frames(jnp.ones((1, 1)))), + np.ones((1, 1)), + ) + frames = np.asarray( + _extract_zero_padded_frames(jnp.asarray([[1.0, 2.0]]), jnp.asarray([-1, 1]), 2) + ) + assert frames.tolist() == [[[0.0, 1.0], [2.0, 0.0]]] + + +def test_fbe_detrend_and_nan_paths_match_dascore() -> None: + """Cover FBE detrending and non-finite frame handling from the operation layer.""" + patch = dc.get_example_patch("chirp") + pipeline = JaxPatchPipeline().fbe( + time=64, + samples=True, + overlap=32, + fmin=2.0, + fmax=10.0, + detrend=True, + ) + + expected = patch.stft( + time=64, + samples=True, + overlap=32, + detrend=True, + ).abs() + ft_dim = next(dim for dim in expected.dims if dim.startswith("ft_")) + expected = expected.select(**{ft_dim: (2.0, 10.0)}) + expected = expected.sum(dim=ft_dim, dim_reduce="squeeze") + + assert_patch_close(pipeline.compile()(patch), expected) diff --git a/tests/operations/test_taper.py b/tests/operations/test_taper.py new file mode 100644 index 0000000..1cc4665 --- /dev/null +++ b/tests/operations/test_taper.py @@ -0,0 +1,65 @@ +"""Parity tests for taper operations.""" + +from __future__ import annotations + +import dascore as dc +import pytest +from dascore.exceptions import ParameterError + +from dasjax import JaxPatchPipeline +from dasjax.operations.taper import _taper_coord_inds + +from .helpers import assert_compiled_matches_dascore, assert_patch_close + + +CASES = ( + ( + "taper", + (), + {"time": 0.05, "window_type": "hann"}, + lambda p: p.taper(time=0.05, window_type="hann"), + ), + ( + "taper_range", + (), + {"time": (10, 20), "samples": True, "window_type": "hann"}, + lambda p: p.taper_range(time=(10, 20), samples=True, window_type="hann"), + ), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_taper_operation_matches_dascore(case) -> None: + """Match compiled taper operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_taper_range_edges_and_errors() -> None: + """Cover nested ranges, invert mode, and invalid taper values.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().taper_range( + time=((10, 20), (30, 40)), + samples=True, + invert=True, + window_type="hann", + ) + expected = patch.taper_range( + time=((10, 20), (30, 40)), + samples=True, + invert=True, + window_type="hann", + ) + + assert_patch_close(pipeline.compile()(patch), expected) + + with pytest.raises(ParameterError, match="Cannot use"): + JaxPatchPipeline().taper_range(time=(None, 10), samples=True).compile()(patch) + with pytest.raises(ParameterError, match="len 2 or 4"): + JaxPatchPipeline().taper_range(time=(1, 2, 3), samples=True).compile()(patch) + with pytest.raises(ParameterError, match="len 2 or 4"): + _taper_coord_inds(patch.get_coord("time"), 1, False, True) + with pytest.raises(ParameterError, match="overlap"): + JaxPatchPipeline().taper(time=(0.6, 0.6)).compile()(patch) + + coord = patch.get_coord("time") + assert _taper_coord_inds(coord, (None, 2, 4, ...), False, True)[0][0] == 0 diff --git a/tests/operations/test_whiten.py b/tests/operations/test_whiten.py new file mode 100644 index 0000000..2e965d1 --- /dev/null +++ b/tests/operations/test_whiten.py @@ -0,0 +1,43 @@ +"""Parity tests for whiten operations.""" + +from __future__ import annotations + +import dascore as dc +import numpy as np +import pytest + +from dasjax import JaxPatchPipeline +from dasjax.kernels import whiten_kernel + +from .helpers import assert_compiled_matches_dascore, assert_patch_close, even_patch + + +CASES = ( + ("whiten", (), {"time": None}, lambda p: p.whiten(time=None), even_patch), +) + + +@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) +def test_compiled_whiten_operation_matches_dascore(case) -> None: + """Match compiled whiten operations against DASCore baselines.""" + assert_compiled_matches_dascore(case) + + +def test_whiten_kernel_and_operation_smooth_paths() -> None: + """Cover direct whitening branches and operation smooth-size binding.""" + data = np.sin(np.linspace(0, 2 * np.pi, 16))[None, :] + complex_data = data.astype(np.complex128) + 1j * data.astype(np.complex128) + weight = np.linspace(1.0, 2.0, 9) + + assert np.asarray(whiten_kernel(data, axis=1)).shape == data.shape + assert np.asarray( + whiten_kernel(data, axis=1, window_len=3, water_level=0.1, freq_weight=weight) + ).shape == data.shape + assert np.asarray(whiten_kernel(complex_data, axis=1, window_len=1)).shape == data.shape + + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().whiten(time=None, smooth_size=1.0, water_level=0.1) + assert_patch_close( + pipeline.compile()(patch), + patch.whiten(time=None, smooth_size=1.0, water_level=0.1), + ) diff --git a/tests/test_benchmark_cli.py b/tests/test_benchmark_cli.py new file mode 100644 index 0000000..8180402 --- /dev/null +++ b/tests/test_benchmark_cli.py @@ -0,0 +1,114 @@ +"""Tests for the dasjax benchmark CLI helpers.""" + +from __future__ import annotations + +import argparse +import sys +from pathlib import Path + +from dasjax.benchmark_cli import ( + build_pytest_command, + normalize_benchmark_json, + render_benchmark_docs, + render_benchmark_table_page, +) + + +def test_build_pytest_command_with_filters() -> None: + """Build a filtered pytest-benchmark command.""" + args = argparse.Namespace( + benchmark_file=Path("benchmarks/test_pipeline_benchmarks.py"), + output=Path(".benchmarks/current.json"), + benchmark=["scale_fbe"], + case=["medium-f64"], + pytest_arg=["--benchmark-min-rounds=1"], + ) + + command = build_pytest_command(args) + + assert command[:3] == [sys.executable, "-m", "pytest"] + assert "--benchmark-json=.benchmarks/current.json" in command + assert command[command.index("-k") + 1] == "(scale_fbe) and (medium-f64)" + assert command[-1] == "--benchmark-min-rounds=1" + + +def test_normalize_benchmark_json_pairs_dasjax_and_dascore() -> None: + """Normalize raw pytest-benchmark JSON into speedup rows.""" + raw = { + "benchmarks": [ + { + "name": "test_dasjax_compiled_scale_fbe[medium-f64]", + "group": "scale_fbe", + "params": {"example_patch": [[600, 4000], "float64"]}, + "stats": {"mean": 0.25}, + }, + { + "name": "test_dascore_scale_fbe[medium-f64]", + "group": "scale_fbe", + "params": {"example_patch": [[600, 4000], "float64"]}, + "stats": {"mean": 1.0}, + }, + ] + } + + snapshot = normalize_benchmark_json(raw, command="pytest benchmarks", source="test") + + assert snapshot["source"] == "test" + assert snapshot["rows"] == [ + { + "group": "scale_fbe", + "case": "medium-f64", + "dascore_mean_s": 1.0, + "dasjax_mean_s": 0.25, + "speedup": 4.0, + } + ] + + +def test_render_benchmark_docs_includes_results_table() -> None: + """Render benchmark docs overview from a normalized snapshot.""" + snapshot = { + "generated_at": "2026-04-24T00:00:00+00:00", + "source": "test", + "command": "pytest benchmarks/test_pipeline_benchmarks.py", + "environment": {"python": "3.12", "platform": "linux"}, + "rows": [ + { + "group": "scale_fbe", + "case": "medium-f64", + "dascore_mean_s": 1.0, + "dasjax_mean_s": 0.25, + "speedup": 4.0, + } + ], + } + + text = render_benchmark_docs(snapshot) + + assert "# Benchmarks" in text + assert "[1 rows](pipelines.md)" in text + assert "[0 rows](methods.md)" in text + + +def test_render_benchmark_table_page_includes_filterable_rows() -> None: + """Render a filterable rich table for benchmark rows.""" + snapshot = { + "generated_at": "2026-04-24T00:00:00+00:00", + "rows": [], + } + rows = [ + { + "group": "operation_fbe", + "case": "large-f32", + "dascore_mean_s": 1.0, + "dasjax_mean_s": 0.25, + "speedup": 4.0, + } + ] + + text = render_benchmark_table_page(snapshot, title="Methods", rows=rows) + + assert 'data-benchmark-filter type="search"' in text + assert "fbe" in text + assert "large-f32" in text + assert "4.00x" in text diff --git a/tests/test_core_api.py b/tests/test_core_api.py index b74cea4..498278c 100644 --- a/tests/test_core_api.py +++ b/tests/test_core_api.py @@ -3,14 +3,23 @@ from __future__ import annotations from dataclasses import dataclass, replace +from operator import mul +from types import SimpleNamespace from typing import ClassVar import dascore as dc import jax import numpy as np +import pytest from dasjax import JaxPatchPipeline, PatchBoundary, PatchOperation, PatchPyTree -from dasjax.core import get_patch_operation, list_patch_operations +from dasjax.core import ( + _coord_values_match, + _encode_leaf, + get_patch_operation, + list_patch_operations, +) +from dasjax.operations.common import get_data_units_from_dims @dataclass(frozen=True) @@ -108,6 +117,19 @@ def test_patch_pytree_restores_datetime_coords() -> None: assert np.array_equal(out.get_coord("time").values, patch.get_coord("time").values) +def test_coord_values_match_rejects_shape_mismatch() -> None: + """Cover coordinate equality shape-mismatch rejection.""" + assert not _coord_values_match(np.arange(2), np.arange(3)) + + +def test_encode_leaf_rejects_unsupported_dtype() -> None: + """Reject coordinate dtypes that cannot be represented in JAX patches.""" + with pytest.raises(TypeError, match="Unsupported coordinate dtype"): + _encode_leaf(np.asarray(["x"], dtype=object)) + with pytest.raises(TypeError, match="Unsupported coordinate dtype"): + _encode_leaf(np.asarray([1], dtype=np.uint32)) + + def test_patch_boundary_swaps_dynamic_coord_values() -> None: """Rebuild coords by replacing values while preserving coord metadata.""" patch = dc.get_example_patch() @@ -137,6 +159,26 @@ def test_patch_boundary_exposes_author_metadata_helpers() -> None: assert boundary.coord_index("time") == boundary.coord_names.index("time") +def test_patch_pytree_helpers_and_base_hooks() -> None: + """Cover direct tree helpers and default operation hook behavior.""" + patch = dc.get_example_patch() + patch_tree, boundary = PatchPyTree.from_patch(patch) + + with pytest.raises(RuntimeError, match="requires PatchBoundary"): + patch_tree.to_patch(coerce_numpy=False) + + assert np.array_equal(patch_tree.coord(0), patch_tree.coord_values[0]) + replaced = patch_tree.replace_coord(0, np.asarray(patch_tree.coord_values[0]) + 1) + assert np.array_equal(replaced[0], np.asarray(patch_tree.coord_values[0]) + 1) + assert boundary.with_metadata(attrs=patch.attrs).attrs == patch.attrs + + op = PatchOperation() + assert op.bind(boundary) is op + assert op.kernel(patch_tree) is patch_tree + assert op.update_boundary(boundary) is boundary + assert op.update_boundary_from_result(patch_tree, boundary) is boundary + + def test_patch_pytree_new_updates_data_and_ordered_coord_values() -> None: """Mirror Patch.new-style immutable updates for JAX patch trees.""" patch = dc.get_example_patch() @@ -161,6 +203,44 @@ def test_operation_subclasses_register_pipeline_names() -> None: assert get_patch_operation("scale").operation_name() == "scale" +def test_operation_registration_validation() -> None: + """Cover duplicate registration, suffix naming, and unknown lookups.""" + + @dataclass(frozen=True) + class ExampleOperation(PatchOperation): + register = False + + assert ExampleOperation.operation_name() == "example" + + with pytest.raises(ValueError, match="Duplicate"): + + class Scale(PatchOperation): + pass + + with pytest.raises(AttributeError, match="Unknown"): + get_patch_operation("does_not_exist") + + +def test_unit_helper_handles_missing_and_multiple_units() -> None: + """Cover unit helper paths for no units, skipped dims, and multiplication.""" + patch = dc.get_example_patch() + _, boundary = PatchPyTree.from_patch(patch) + attrs = boundary.attrs.update(data_units="m") + coords = boundary.coords.set_units(time="s") + unit_boundary = boundary.new(attrs=attrs, coords=coords) + + assert get_data_units_from_dims(boundary, ("time",), mul) is None + assert ( + get_data_units_from_dims(unit_boundary, ("time", "distance"), mul) is not None + ) + + fake_boundary = SimpleNamespace( + attrs=SimpleNamespace(data_units="m"), + coord=lambda name: SimpleNamespace(units=None if name == "x" else "s"), + ) + assert get_data_units_from_dims(fake_boundary, ("x", "time"), mul) is not None + + def test_compiled_pipeline_uses_class_authored_basic_operations() -> None: """Run a fully ported class-authored chain through JaxPatchPipeline.""" patch = dc.get_example_patch() @@ -230,9 +310,7 @@ def test_core_planner_restarts_after_result_boundary_updates() -> None: JaxPatchPipeline._plan_core_segment((op,), boundary, 0) ) out_tree = bound_ops[0].kernel(patch_tree) - out_boundary = bound_ops[0].update_boundary_from_result( - out_tree, planned_boundary - ) + out_boundary = bound_ops[0].update_boundary_from_result(out_tree, planned_boundary) out = out_boundary.to_patch(out_tree) assert out.dims == ("distance", "ft_time") diff --git a/tests/test_method_equivalence.py b/tests/test_method_equivalence.py deleted file mode 100644 index e504119..0000000 --- a/tests/test_method_equivalence.py +++ /dev/null @@ -1,104 +0,0 @@ -"""Compare core pipeline operations against DASCore baselines.""" - -from __future__ import annotations - -import dascore as dc -import numpy as np -import pytest - -from dasjax import JaxPatchPipeline, list_patch_operations - - -def _assert_patch_close(left, right) -> None: - assert np.allclose(left.data, right.data, equal_nan=True, rtol=1e-5, atol=1e-6) - assert left.coords == right.coords - - -def _complex_patch(patch): - return patch.update(data=patch.data + 1j * patch.data) - - -def _even_patch(patch): - return patch.select(time=(..., patch.get_coord("time").values[-2])) - - -def _fourier_patch(patch): - return patch.dft("time", real=True) - - -def _fbe_baseline(patch): - out = patch.stft(time=64, samples=True, overlap=32).abs() - ft_dim = next(dim for dim in out.dims if dim.startswith("ft_")) - out = out.select(**{ft_dim: (2.0, 10.0)}) - return out.sum(dim=ft_dim, dim_reduce="squeeze") - - -CASES = ( - ("identity", (), {}, lambda p: p), - ("scale", (2.0,), {}, lambda p: p * 2.0), - ("add", (2.0,), {}, lambda p: p + 2.0), - ("abs", (), {}, lambda p: p.abs(), _complex_patch), - ("clip", (-0.25, 0.25), {}, lambda p: p.update(data=np.clip(p.data, -0.25, 0.25))), - ("real", (), {}, lambda p: p.real(), _complex_patch), - ("imag", (), {}, lambda p: p.imag(), _complex_patch), - ("angle", (), {}, lambda p: p.angle(), _complex_patch), - ("conj", (), {}, lambda p: p.conj(), _complex_patch), - ("flip", ("time",), {}, lambda p: p.flip("time")), - ("roll", (), {"time": 5, "samples": True}, lambda p: p.roll(time=5, samples=True)), - ("standardize", (), {"dim": "time"}, lambda p: p.standardize(dim="time")), - ("detrend", (), {"dim": "time", "type": "constant"}, lambda p: p.detrend(dim="time", type="constant")), - ("normalize", (), {"dim": "time", "norm": "l2"}, lambda p: p.normalize(dim="time", norm="l2")), - ("differentiate", (), {"dim": "time"}, lambda p: p.differentiate(dim="time")), - ("integrate", (), {"dim": "time"}, lambda p: p.integrate(dim="time")), - ("taper", (), {"time": 0.05, "window_type": "hann"}, lambda p: p.taper(time=0.05, window_type="hann")), - ( - "taper_range", - (), - {"time": (10, 20), "samples": True, "window_type": "hann"}, - lambda p: p.taper_range(time=(10, 20), samples=True, window_type="hann"), - ), - ("gaussian_filter", (), {"time": 3, "samples": True}, lambda p: p.gaussian_filter(time=3, samples=True)), - ( - "hampel_filter", - (), - {"time": 3, "samples": True, "threshold": 3.5, "approximate": True}, - lambda p: p.hampel_filter(time=3, samples=True, threshold=3.5, approximate=True), - ), - ( - "pass_filter", - (), - {"time": (1.0, 10.0), "corners": 4, "zerophase": True}, - lambda p: p.pass_filter(time=(1.0, 10.0), corners=4, zerophase=True), - _even_patch, - ), - ("pad", (), {"time": (2, 3), "samples": True}, lambda p: p.pad(time=(2, 3), samples=True)), - ("dft", (), {"dim": "time", "real": True}, lambda p: p.dft(dim="time", real=True)), - ("idft", (), {}, lambda p: p.idft(), _fourier_patch), - ("hilbert", (), {"dim": "time"}, lambda p: p.hilbert(dim="time"), _even_patch), - ("envelope", (), {"dim": "time"}, lambda p: p.envelope(dim="time"), _even_patch), - ("whiten", (), {"time": None}, lambda p: p.whiten(time=None), _even_patch), - ( - "fbe", - (), - {"time": 64, "samples": True, "overlap": 32, "fmin": 2.0, "fmax": 10.0}, - _fbe_baseline, - lambda p: dc.get_example_patch("chirp"), - ), -) - - -def test_case_table_covers_registered_operations() -> None: - assert {case[0] for case in CASES} == set(list_patch_operations()) - - -@pytest.mark.parametrize("case", CASES, ids=lambda item: item[0]) -def test_compiled_pipeline_matches_dascore(case) -> None: - name, args, kwargs, baseline, *rest = case - example_patch = dc.get_example_patch() - patch = rest[0](example_patch) if rest else example_patch - pipeline = getattr(JaxPatchPipeline(), name)(*args, **kwargs) - - out = pipeline.compile()(patch) - expected = baseline(patch) - - _assert_patch_close(out, expected) diff --git a/tests/test_package.py b/tests/test_package.py new file mode 100644 index 0000000..3354548 --- /dev/null +++ b/tests/test_package.py @@ -0,0 +1,20 @@ +"""Tests for package-level behavior.""" + +from __future__ import annotations + +import importlib +import importlib.metadata + +import dasjax + + +def test_package_version_falls_back_when_metadata_missing(monkeypatch) -> None: + """Use the unknown version fallback when package metadata is absent.""" + + def _missing_version(name: str) -> str: + raise importlib.metadata.PackageNotFoundError(name) + + monkeypatch.setattr(importlib.metadata, "version", _missing_version) + module = importlib.reload(dasjax) + + assert module.__version__ == "0+unknown" diff --git a/tests/test_pipeline_cache.py b/tests/test_pipeline_cache.py index 2c1cb54..83bd9ff 100644 --- a/tests/test_pipeline_cache.py +++ b/tests/test_pipeline_cache.py @@ -2,12 +2,14 @@ from __future__ import annotations +from dataclasses import dataclass + import dascore as dc import jax import numpy as np import pytest -from dasjax import JaxPatchPipeline +from dasjax import JaxPatchPipeline, PatchBoundary, PatchOperation, PatchPyTree def _fbe_baseline(patch): @@ -46,16 +48,6 @@ def test_compile_separates_distinct_pipeline_definitions() -> None: assert pipeline_1.compile() is not pipeline_2.compile() -def test_compile_separates_assert_no_fallback_flag() -> None: - """Separate cache entries when assert_no_fallback changes.""" - pipeline = JaxPatchPipeline().scale(2.0) - - compiled_default = pipeline.compile() - compiled_checked = pipeline.compile(assert_no_fallback=True) - - assert compiled_default is not compiled_checked - - def test_compile_rejects_device_and_backend_together() -> None: """Reject compile calls that pass both device and backend.""" pipeline = JaxPatchPipeline().scale(2.0) @@ -64,8 +56,125 @@ def test_compile_rejects_device_and_backend_together() -> None: pipeline.compile(device=jax.devices()[0], backend="cpu") -def test_assert_no_fallback_passes_for_native_pipeline() -> None: - """Allow fallback assertions for fully native compiled pipelines.""" +def test_pipeline_private_freezing_and_plan_edges() -> None: + """Cover cache-key freezing for unhashable values and plan tail reporting.""" + patch = dc.get_example_patch() + pipeline = JaxPatchPipeline().scale(np.asarray([2.0])).add({"value": 1.0}) + key = pipeline._compile_cache_key() + set_key = JaxPatchPipeline().add({"a", "b"})._compile_cache_key() + + assert "ndarray" in repr(key) + assert "(2.0,)" not in repr(key) + assert "value" in repr(key) + assert "a" in repr(set_key) + assert JaxPatchPipeline().steps == () + + class PlainOperation: + value = [] + + @classmethod + def operation_name(cls): + return "plain" + + from dasjax.pipeline import _operation_key + + assert _operation_key(PlainOperation())[0] == "plain" + with pytest.raises(AttributeError, match="Unknown"): + JaxPatchPipeline().not_registered + + plan = ( + JaxPatchPipeline().dft(dim="time", real=True).normalize("ft_time").plan(patch) + ) + assert plan.fused_kernel_count == 1 + + +@dataclass(frozen=True) +class _TailResultBoundary(PatchOperation): + register = False + + def update_boundary_from_result( + self, + patch_tree: PatchPyTree, + boundary: PatchBoundary, + ) -> PatchBoundary: + _ = patch_tree + return boundary + + +def test_pipeline_plan_reports_unplanned_tail_from_execution_planner() -> None: + """Cover the unplanned tail path in the public execution planner.""" + patch = dc.get_example_patch() + tail_plan = JaxPatchPipeline()._plan_core_execution( + patch, + (_TailResultBoundary(), _TailResultBoundary()), + ) + assert tail_plan.segments[-1].kind == "unplanned" + + +def test_pipeline_backend_and_result_boundary_compile_paths(monkeypatch) -> None: + """Cover backend resolution and result-dependent execution hooks.""" + patch = dc.get_example_patch() + + with pytest.raises(RuntimeError): + JaxPatchPipeline().scale(1.0).compile(backend="not-a-backend") + out = JaxPatchPipeline().scale(1.0).compile(backend="cpu")(patch) + assert out.equals(patch) + monkeypatch.setattr("dasjax.pipeline.jax.local_devices", lambda backend: []) + with pytest.raises(ValueError, match="No local JAX devices"): + JaxPatchPipeline().scale(1.0).compile(backend="cpu") + + @dataclass(frozen=True) + class _ResultBoundaryForCoverage(PatchOperation): + register = False + + def update_boundary_from_result( + self, + patch_tree: PatchPyTree, + boundary: PatchBoundary, + ) -> PatchBoundary: + _ = patch_tree + return boundary + + PatchOperation._registry["result_boundary_for_coverage"] = ( + _ResultBoundaryForCoverage + ) + try: + out = JaxPatchPipeline().result_boundary_for_coverage().compile()(patch) + finally: + PatchOperation._registry.pop("result_boundary_for_coverage") + assert out.equals(patch) + + +def test_compiled_pipeline_reuses_bound_plan_for_same_boundary() -> None: + """Avoid rebinding operations on repeated calls with the same metadata.""" + patch = dc.get_example_patch() + bind_count = {"value": 0} + + @dataclass(frozen=True) + class _CountingBind(PatchOperation): + register = False + + def bind(self, boundary: PatchBoundary): + bind_count["value"] += 1 + _ = boundary + return self + + def kernel(self, patch_tree: PatchPyTree) -> PatchPyTree: + return patch_tree + + PatchOperation._registry["counting_bind_for_cache"] = _CountingBind + try: + compiled = JaxPatchPipeline().counting_bind_for_cache().compile() + compiled(patch) + compiled(patch) + finally: + PatchOperation._registry.pop("counting_bind_for_cache") + + assert bind_count["value"] == 1 + + +def test_native_hampel_pipeline_compiles() -> None: + """Compile native approximate Hampel filtering.""" patch = dc.get_example_patch("chirp") pipeline = ( JaxPatchPipeline() @@ -78,25 +187,54 @@ def test_assert_no_fallback_passes_for_native_pipeline() -> None: ) ) - pipeline.assert_no_fallback(patch) + out = pipeline.compile()(patch) + + assert out.shape == patch.shape -def test_assert_no_fallback_accepts_core_pipeline() -> None: - """Core pipelines no longer have legacy fallback branches.""" +def test_gaussian_filter_pipeline_compiles() -> None: + """Compile native Gaussian filtering.""" patch = dc.get_example_patch("chirp") - pipeline = JaxPatchPipeline().gaussian_filter(**{patch.dims[-1]: 3}, samples=True) + dim = patch.dims[-1] + pipeline = JaxPatchPipeline().gaussian_filter(**{dim: 3}, samples=True) + + out = pipeline.compile()(patch) - pipeline.assert_no_fallback(patch) + assert np.allclose(out.data, patch.gaussian_filter(**{dim: 3}, samples=True).data) -def test_assert_no_fallback_passes_for_fbe_pipeline() -> None: - """Allow fallback assertions for pure-JAX FBE pipelines.""" +def test_exact_hampel_filter_is_not_implemented() -> None: + """Reject exact Hampel filtering because it is not implemented in pure JAX.""" + patch = dc.get_example_patch("chirp") + + with pytest.raises(NotImplementedError, match="pure JAX"): + JaxPatchPipeline().hampel_filter( + **{patch.dims[-1]: 3}, + samples=True, + approximate=False, + ).compile() + + +def test_whiten_pipeline_compiles() -> None: + """Compile native whitening.""" + patch = dc.get_example_patch("chirp") + pipeline = JaxPatchPipeline().dft(dim=patch.dims[-1], real=True).whiten() + + out = pipeline.compile()(patch) + expected = patch.dft(dim=patch.dims[-1], real=True).whiten() + + assert np.allclose(out.data, expected.data) + + +def test_fbe_pipeline_compiles() -> None: + """Compile native FBE pipelines.""" patch = dc.get_example_patch("chirp") pipeline = JaxPatchPipeline().fbe( time=64, samples=True, overlap=32, fmin=2.0, fmax=10.0 ) - # fbe uses pure JAX (no host callbacks) — assert_no_fallback should not raise. - pipeline.assert_no_fallback(patch) + out = pipeline.compile()(patch) + + assert np.allclose(out.data, _fbe_baseline(patch).data) def test_cached_pipeline_callable_still_matches_expected_output() -> None: diff --git a/tests/test_registry_architecture.py b/tests/test_registry_architecture.py index 31eeb36..c43e416 100644 --- a/tests/test_registry_architecture.py +++ b/tests/test_registry_architecture.py @@ -10,16 +10,41 @@ "identity", "scale", "add", + "subtract", + "multiply", + "divide", + "maximum", + "minimum", "abs", "clip", "real", "imag", "angle", "conj", + "exp", + "log", + "log10", + "log2", + "is_finite", + "isinf", + "isnan", + "fillna", + "where", "flip", "roll", "standardize", + "aggregate", + "all", + "any", + "max", + "mean", + "median", + "min", + "std", + "sum", "detrend", + "correlate_shift", + "dispersion_phase_shift", "normalize", "differentiate", "integrate", @@ -27,37 +52,148 @@ "taper_range", "gaussian_filter", "hampel_filter", + "median_filter", + "sobel_filter", + "savgol_filter", + "notch_filter", + "wiener_filter", + "slope_filter", "pass_filter", + "line_mute", + "slope_mute", "pad", "hilbert", "envelope", + "phase_weighted_stack", "dft", "idft", "whiten", "fbe", + "velocity_to_strain_rate", + "velocity_to_strain_rate_edgeless", + "radians_to_strain", + "tau_p", + "correlate", + "decimate", + "interpolate", + "iresample", + "istft", + "resample", + "rfft", + "spectrogram", + "stft", ) +EXPECTED_OPERATION_MODULES = { + "identity": "dasjax.operations.basic", + "scale": "dasjax.operations.basic", + "add": "dasjax.operations.basic", + "subtract": "dasjax.operations.basic", + "multiply": "dasjax.operations.basic", + "divide": "dasjax.operations.basic", + "maximum": "dasjax.operations.basic", + "minimum": "dasjax.operations.basic", + "abs": "dasjax.operations.basic", + "clip": "dasjax.operations.basic", + "real": "dasjax.operations.basic", + "imag": "dasjax.operations.basic", + "angle": "dasjax.operations.basic", + "conj": "dasjax.operations.basic", + "exp": "dasjax.operations.basic", + "log": "dasjax.operations.basic", + "log10": "dasjax.operations.basic", + "log2": "dasjax.operations.basic", + "is_finite": "dasjax.operations.basic", + "isinf": "dasjax.operations.basic", + "isnan": "dasjax.operations.basic", + "fillna": "dasjax.operations.basic", + "where": "dasjax.operations.basic", + "flip": "dasjax.operations.basic", + "roll": "dasjax.operations.basic", + "standardize": "dasjax.operations.basic", + "aggregate": "dasjax.operations.basic", + "all": "dasjax.operations.basic", + "any": "dasjax.operations.basic", + "max": "dasjax.operations.basic", + "mean": "dasjax.operations.basic", + "median": "dasjax.operations.basic", + "min": "dasjax.operations.basic", + "std": "dasjax.operations.basic", + "sum": "dasjax.operations.basic", + "detrend": "dasjax.operations.detrend", + "correlate_shift": "dasjax.operations.correlate", + "dispersion_phase_shift": "dasjax.operations.dispersion", + "normalize": "dasjax.operations.normalize", + "differentiate": "dasjax.operations.differentiate", + "integrate": "dasjax.operations.integrate", + "taper": "dasjax.operations.taper", + "taper_range": "dasjax.operations.taper", + "gaussian_filter": "dasjax.operations.filter", + "hampel_filter": "dasjax.operations.filter", + "median_filter": "dasjax.operations.filter", + "notch_filter": "dasjax.operations.filter", + "pass_filter": "dasjax.operations.filter", + "savgol_filter": "dasjax.operations.filter", + "sobel_filter": "dasjax.operations.filter", + "slope_filter": "dasjax.operations.filter", + "wiener_filter": "dasjax.operations.filter", + "line_mute": "dasjax.operations.mute", + "slope_mute": "dasjax.operations.mute", + "pad": "dasjax.operations.pad", + "hilbert": "dasjax.operations.hilbert", + "envelope": "dasjax.operations.hilbert", + "phase_weighted_stack": "dasjax.operations.hilbert", + "dft": "dasjax.operations.fourier", + "idft": "dasjax.operations.fourier", + "whiten": "dasjax.operations.whiten", + "fbe": "dasjax.operations.spectro", + "velocity_to_strain_rate": "dasjax.operations.strain", + "velocity_to_strain_rate_edgeless": "dasjax.operations.strain", + "radians_to_strain": "dasjax.operations.strain", + "tau_p": "dasjax.operations.taup", + "correlate": "dasjax.operations.numeric", + "decimate": "dasjax.operations.numeric", + "interpolate": "dasjax.operations.numeric", + "iresample": "dasjax.operations.numeric", + "istft": "dasjax.operations.numeric", + "resample": "dasjax.operations.numeric", + "rfft": "dasjax.operations.numeric", + "spectrogram": "dasjax.operations.numeric", + "stft": "dasjax.operations.numeric", +} + def test_core_operation_names_are_unique() -> None: + """Ensure each registered operation has a distinct public name.""" names = [operation.operation_name() for operation in iter_patch_operations()] assert len(names) == len(set(names)) def test_all_operations_are_patch_operation_subclasses() -> None: + """Keep the registry limited to PatchOperation subclasses.""" for operation in iter_patch_operations(): assert issubclass(operation, PatchOperation) def test_list_patch_operations_preserves_registry_order() -> None: + """Expose operation names in deterministic registration order.""" assert dasjax.list_patch_operations() == EXPECTED_OPERATIONS def test_get_patch_operation_resolves_all_registered_names() -> None: + """Resolve every expected operation through the public lookup helper.""" for name in EXPECTED_OPERATIONS: assert get_patch_operation(name).operation_name() == name +def test_operations_live_in_domain_modules() -> None: + """Keep operation implementations grouped by DASCore-style domains.""" + for name, module_name in EXPECTED_OPERATION_MODULES.items(): + assert get_patch_operation(name).__module__ == module_name + + def test_package_root_exports_only_runtime_surface() -> None: + """Avoid exporting implementation modules from the package root.""" assert sorted(dasjax.__all__) == [ "JaxPatchPipeline", "PatchBoundary", diff --git a/zensical.toml b/zensical.toml new file mode 100644 index 0000000..1ea3d98 --- /dev/null +++ b/zensical.toml @@ -0,0 +1,85 @@ +[project] +site_name = "dasjax" +site_url = "https://dasdae.github.io/dasjax/" +repo_url = "https://github.com/dasdae/dasjax" +docs_dir = "docs" +site_dir = "site" +nav = [ + {"Home" = "index.md"}, + {"Tutorial" = [ + {"Overview" = "tutorial/index.md"}, + {"Compiled Pipelines" = "tutorial/compiled-pipelines.md"}, + {"Performance" = "tutorial/performance.md"}, + ]}, + {"Benchmarks" = [ + {"Overview" = "benchmarks/index.md"}, + {"Pipelines" = "benchmarks/pipelines.md"}, + {"Methods" = "benchmarks/methods.md"}, + ]}, + {"Development" = [ + {"Overview" = "development/index.md"}, + {"Architecture" = "development/architecture.md"}, + {"Operation Coverage" = "development/operation-coverage.md"}, + {"Documentation" = "development/documentation.md"}, + ]}, + {"API Reference" = [ + {"Overview" = "api/index.md"}, + ]}, +] + +[project.theme] +variant = "classic" +logo = "static/dasjax_logo.png" +favicon = "static/favicon.ico" +features = [ + "navigation.tabs", + "navigation.tabs.sticky", + "navigation.instant", + "navigation.tracking", + "navigation.sections", + "navigation.top", + "toc.follow", +] + +[[project.theme.palette]] +media = "(prefers-color-scheme: light)" +scheme = "default" +primary = "indigo" +accent = "blue" +toggle.icon = "lucide/sun" +toggle.name = "Switch to dark mode" + +[[project.theme.palette]] +media = "(prefers-color-scheme: dark)" +scheme = "slate" +primary = "indigo" +accent = "blue" +toggle.icon = "lucide/moon" +toggle.name = "Switch to light mode" + +[project.markdown_extensions.admonition] + +[project.markdown_extensions.attr_list] + +[project.markdown_extensions.md_in_html] + +[project.markdown_extensions.tables] + +[project.markdown_extensions.pymdownx.details] + +[project.markdown_extensions.pymdownx.emoji] +emoji_index = "zensical.extensions.emoji.twemoji" +emoji_generator = "zensical.extensions.emoji.to_svg" + +[project.markdown_extensions.pymdownx.highlight] + +[project.markdown_extensions.pymdownx.inlinehilite] + +[project.markdown_extensions.pymdownx.snippets] +base_path = ["."] +check_paths = true + +[project.markdown_extensions.pymdownx.superfences] + +[project.markdown_extensions.pymdownx.tabbed] +alternate_style = true From 7cc3e9f591f973f5097e37fa9d3ad2946dcb0110 Mon Sep 17 00:00:00 2001 From: Derrick Chambers Date: Sat, 25 Apr 2026 16:33:44 +0200 Subject: [PATCH 4/7] add docs --- README.md | 15 +- benchmarks/results/current.json | 480 +++++++++++++++++++------ benchmarks/test_pipeline_benchmarks.py | 251 +++++++++++++ docs/development/documentation.md | 24 +- docs/development/operation-coverage.md | 2 +- pyproject.toml | 1 - src/dasjax/benchmark_cli.py | 159 +++++++- src/dasjax/kernels/signal.py | 3 +- src/dasjax/operations/__init__.py | 6 - src/dasjax/operations/basic.py | 8 +- src/dasjax/operations/dispersion.py | 22 +- src/dasjax/operations/filter.py | 4 +- src/dasjax/operations/hilbert.py | 4 +- src/dasjax/operations/mute.py | 8 +- src/dasjax/operations/numeric.py | 26 -- src/dasjax/operations/strain.py | 11 +- src/dasjax/operations/taup.py | 6 +- src/dasjax/operations/whiten.py | 19 +- tests/operations/test_basic.py | 4 +- tests/operations/test_differentiate.py | 4 +- tests/operations/test_domain.py | 15 +- tests/operations/test_filter.py | 77 ++-- tests/operations/test_fourier.py | 4 +- tests/operations/test_integrate.py | 4 +- tests/operations/test_numeric.py | 14 - tests/operations/test_whiten.py | 20 +- tests/test_benchmark_cli.py | 232 ++++++++++++ tests/test_registry_architecture.py | 6 - 28 files changed, 1156 insertions(+), 273 deletions(-) diff --git a/README.md b/README.md index f83b164..8f76153 100644 --- a/README.md +++ b/README.md @@ -53,13 +53,13 @@ Operation authors use `bind(boundary)` for Python-side metadata planning, `kerne ### Operation Coverage -`dasjax` currently registers 75 pipeline operations. Most operations use native JAX kernels; a smaller set of DASCore-compatible numeric transforms still use host callbacks where a fully static JAX kernel is not practical yet. The current operation set includes: +`dasjax` currently registers 72 pipeline operations. Most operations use native JAX kernels; a smaller set of DASCore-compatible numeric transforms still use host callbacks where a fully static JAX kernel is not practical yet. The current operation set includes: - Elementwise math and masks: `abs`, `clip`, `real`, `imag`, `angle`, `conj`, `exp`, `log`, `log10`, `log2`, `is_finite`, `isinf`, `isnan`, `fillna`, `where`, and scalar arithmetic operations. - Reductions and aggregation: `aggregate`, `all`, `any`, `max`, `mean`, `median`, `min`, `std`, and `sum`. - Coordinate-aware array transforms: `flip`, `roll`, `pad`, `taper`, `taper_range`, `detrend`, `standardize`, `differentiate`, and `integrate`. -- Spectral and signal operations: `dft`, `idft`, `rfft`, `stft`, `istft`, `spectrogram`, `hilbert`, `envelope`, `phase_weighted_stack`, `whiten`, `fbe`, and `correlate_shift`. -- Filters, mutes, and DAS-domain operations: `pass_filter`, `gaussian_filter`, `hampel_filter`, `median_filter`, `notch_filter`, `savgol_filter`, `sobel_filter`, `slope_filter`, `wiener_filter`, `line_mute`, `slope_mute`, `correlate`, `decimate`, `interpolate`, `iresample`, `resample`, `dispersion_phase_shift`, `tau_p`, `velocity_to_strain_rate`, `velocity_to_strain_rate_edgeless`, and `radians_to_strain`. +- Spectral and signal operations: `dft`, `idft`, `stft`, `istft`, `hilbert`, `envelope`, `phase_weighted_stack`, `whiten`, `fbe`, and `correlate_shift`. +- Filters, mutes, and DAS-domain operations: `pass_filter`, `gaussian_filter`, `hampel_filter`, `median_filter`, `notch_filter`, `savgol_filter`, `sobel_filter`, `slope_filter`, `wiener_filter`, `line_mute`, `slope_mute`, `correlate`, `decimate`, `interpolate`, `resample`, `dispersion_phase_shift`, `tau_p`, `velocity_to_strain_rate`, `velocity_to_strain_rate_edgeless`, and `radians_to_strain`. Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. `rolling` returns a roller object rather than a patch, and `dropna` has data-dependent output shape, so neither fits the current static compiled-pipeline model directly. @@ -75,16 +75,15 @@ Remaining DASCore patch methods are mostly metadata, selection, convenience, or Documentation is built with Zensical. The public API reference is generated at build time from the installed `dasjax` package, so run the API generation script before building or serving the site. ```bash -python -m pip install -e ".[docs]" -python scripts/build_api_docs.py -zensical build --clean +uv run python scripts/build_api_docs.py +uv run --extra docs zensical build --clean ``` For local preview, run: ```bash -python scripts/build_api_docs.py -zensical serve +uv run python scripts/build_api_docs.py +uv run --extra docs zensical serve ``` Generated files under `docs/api/` and `site/` are ignored by version control. GitHub Pages builds the same generated API docs and static site on pushes to `main`, then deploys the `site/` artifact through the `github-pages` environment. diff --git a/benchmarks/results/current.json b/benchmarks/results/current.json index 1daf2a0..043f592 100644 --- a/benchmarks/results/current.json +++ b/benchmarks/results/current.json @@ -1,239 +1,519 @@ { - "command": "/home/derrick/Gits/dasjax/.venv/bin/python3 -m pytest benchmarks/test_pipeline_benchmarks.py --benchmark-json=.benchmarks/current.json --benchmark-min-rounds=3", + "command": "/home/derrick/Gits/dasjax/.venv/bin/python3 -m pytest benchmarks/test_pipeline_benchmarks.py --benchmark-json=.benchmarks/current.json", "environment": { - "dascore": "0.1.15", - "dasjax": "0.0.2.post5+git.b91ea38d.dirty", + "dascore": "0.1.16", + "dasjax": "0.0.2.post6+git.fdb52b38.dirty", "jax": "0.9.2", "machine": "x86_64", "platform": "Linux-6.8.0-110-generic-x86_64-with-glibc2.39", "processor": "x86_64", "python": "3.14.0" }, - "generated_at": "2026-04-24T21:02:20+00:00", + "generated_at": "2026-04-25T14:27:13+00:00", "rows": [ { "case": "large-f32", - "dascore_mean_s": 0.01680247585863981, - "dasjax_mean_s": 0.027737313893080033, + "dascore_mean_s": 0.007935926129023082, + "dasjax_mean_s": 0.017582151127201292, + "group": "operation_abs", + "speedup": 0.45136263882668115 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.015053255730610825, + "dasjax_mean_s": 0.034838203482900884, + "group": "operation_abs", + "speedup": 0.43209047039406584 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.0016216116442719372, + "dasjax_mean_s": 0.002737910963199475, + "group": "operation_abs", + "speedup": 0.5922806351514623 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.0029411434471127837, + "dasjax_mean_s": 0.0039036083065406677, + "group": "operation_abs", + "speedup": 0.753442255511335 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.007861990409571157, + "dasjax_mean_s": 0.017857173290923872, + "group": "operation_add", + "speedup": 0.4402707125862474 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.014968957292976797, + "dasjax_mean_s": 0.03530251717828443, + "group": "operation_add", + "speedup": 0.42401954561428906 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.0013730891043464352, + "dasjax_mean_s": 0.00273294466455809, + "group": "operation_add", + "speedup": 0.5024211145411025 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.002872821541935874, + "dasjax_mean_s": 0.003951023883951072, + "group": "operation_add", + "speedup": 0.7271081183804482 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.007773525349543112, + "dasjax_mean_s": 0.017493574536813498, + "group": "operation_clip", + "speedup": 0.4443646055975865 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.014837235603408772, + "dasjax_mean_s": 0.03473483007420092, + "group": "operation_clip", + "speedup": 0.42715728194763897 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.0015795147206869437, + "dasjax_mean_s": 0.002797094222745197, + "group": "operation_clip", + "speedup": 0.5646984316233492 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.002816467924502995, + "dasjax_mean_s": 0.003984043106562846, + "group": "operation_clip", + "speedup": 0.7069371111631487 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.010819450778073565, + "dasjax_mean_s": 0.02165447399992055, "group": "operation_detrend", - "speedup": 0.6057715582485342 + "speedup": 0.49964043357106075 }, { "case": "large-f64", - "dascore_mean_s": 0.02056590126647077, - "dasjax_mean_s": 0.039724797681794204, + "dascore_mean_s": 0.019358336065045518, + "dasjax_mean_s": 0.03907591064346759, "group": "operation_detrend", - "speedup": 0.5177094023538874 + "speedup": 0.4954033251245981 }, { "case": "medium-f32", - "dascore_mean_s": 0.00280651622404241, - "dasjax_mean_s": 0.00464291289685484, + "dascore_mean_s": 0.002359406132353501, + "dasjax_mean_s": 0.004217029320276005, "group": "operation_detrend", - "speedup": 0.6044731586378832 + "speedup": 0.5594948370430295 }, { "case": "medium-f64", - "dascore_mean_s": 0.006594007113993652, - "dasjax_mean_s": 0.005276114980069589, + "dascore_mean_s": 0.004759153708495725, + "dasjax_mean_s": 0.005132301489444065, "group": "operation_detrend", - "speedup": 1.2497845742373646 + "speedup": 0.9272942593657413 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.0329788664482827, + "dasjax_mean_s": 0.02926682580786851, + "group": "operation_differentiate", + "speedup": 1.1268344119305274 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.04246424634984578, + "dasjax_mean_s": 0.05601835818742984, + "group": "operation_differentiate", + "speedup": 0.7580416085699292 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.006672640640317695, + "dasjax_mean_s": 0.004160485464541186, + "group": "operation_differentiate", + "speedup": 1.6038129918219886 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.012786168552802919, + "dasjax_mean_s": 0.007639906760496704, + "group": "operation_differentiate", + "speedup": 1.673602696163223 }, { "case": "large-f32", - "dascore_mean_s": 0.2184312981997209, - "dasjax_mean_s": 0.07017438086671367, + "dascore_mean_s": 0.20849201119999633, + "dasjax_mean_s": 0.067468552866679, "group": "operation_fbe", - "speedup": 3.1126929158748164 + "speedup": 3.0902102141124366 }, { "case": "large-f64", - "dascore_mean_s": 0.22405660559925308, - "dasjax_mean_s": 0.12280043924988604, + "dascore_mean_s": 0.21955316859966842, + "dasjax_mean_s": 0.11780996044439639, "group": "operation_fbe", - "speedup": 1.8245586658148782 + "speedup": 1.8636214439889613 }, { "case": "medium-f32", - "dascore_mean_s": 0.060894481812397316, - "dasjax_mean_s": 0.016618491196748467, + "dascore_mean_s": 0.05749154618706598, + "dasjax_mean_s": 0.011731497455548379, "group": "operation_fbe", - "speedup": 3.6642605571985847 + "speedup": 4.9006144701395735 }, { "case": "medium-f64", - "dascore_mean_s": 0.06038897700011603, - "dasjax_mean_s": 0.02635550172517469, + "dascore_mean_s": 0.05919101474978561, + "dasjax_mean_s": 0.025517563621228014, "group": "operation_fbe", - "speedup": 2.291323368829388 + "speedup": 2.3196185822593467 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.06394093606650131, + "dasjax_mean_s": 0.033948521290092744, + "group": "operation_integrate", + "speedup": 1.8834674865547474 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.07652714800077284, + "dasjax_mean_s": 0.06064815950069007, + "group": "operation_integrate", + "speedup": 1.2618214407628 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.01654486007932324, + "dasjax_mean_s": 0.005963402924941606, + "group": "operation_integrate", + "speedup": 2.7743991622845523 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.01953043829625703, + "dasjax_mean_s": 0.009111122707663354, + "group": "operation_integrate", + "speedup": 2.143581962717943 }, { "case": "large-f32", - "dascore_mean_s": 0.02410416859510449, - "dasjax_mean_s": 0.029323925272613204, + "dascore_mean_s": 0.016861063919932348, + "dasjax_mean_s": 0.017541805865361172, + "group": "operation_mean", + "speedup": 0.961193166162382 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.02815186759403332, + "dasjax_mean_s": 0.029849777181935322, + "group": "operation_mean", + "speedup": 0.9431181821709023 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.0045291220615997, + "dasjax_mean_s": 0.0031456233550736638, + "group": "operation_mean", + "speedup": 1.4398170252311209 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.006446509749821416, + "dasjax_mean_s": 0.002789384320467339, + "group": "operation_mean", + "speedup": 2.31108696729942 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.022142910000597607, + "dasjax_mean_s": 0.02258763956830411, "group": "operation_normalize", - "speedup": 0.821996658735737 + "speedup": 0.9803109321643965 }, { "case": "large-f64", - "dascore_mean_s": 0.0442047530001067, - "dasjax_mean_s": 0.04763245468166133, + "dascore_mean_s": 0.03985147412489217, + "dasjax_mean_s": 0.04604641334757933, "group": "operation_normalize", - "speedup": 0.928038525319286 + "speedup": 0.8654631539719515 }, { "case": "medium-f32", - "dascore_mean_s": 0.005262831870463686, - "dasjax_mean_s": 0.0038589278446091823, + "dascore_mean_s": 0.003866081424726048, + "dasjax_mean_s": 0.003445870612513223, "group": "operation_normalize", - "speedup": 1.36380675731362 + "speedup": 1.1219461957413273 }, { "case": "medium-f64", - "dascore_mean_s": 0.007819257648463918, - "dasjax_mean_s": 0.006448505770629922, + "dascore_mean_s": 0.0076487489297601555, + "dasjax_mean_s": 0.006458191331293379, "group": "operation_normalize", - "speedup": 1.212568915434202 + "speedup": 1.184348455688807 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.0076031236100588704, + "dasjax_mean_s": 0.017752565218424107, + "group": "operation_pad", + "speedup": 0.4282830969221359 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.01408750785177054, + "dasjax_mean_s": 0.035332438148880436, + "group": "operation_pad", + "speedup": 0.39871315396944734 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.002024273651784072, + "dasjax_mean_s": 0.002737090742528947, + "group": "operation_pad", + "speedup": 0.739571260949038 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.0029554693321760857, + "dasjax_mean_s": 0.0038526478810573758, + "group": "operation_pad", + "speedup": 0.7671267718774611 }, { "case": "large-f32", - "dascore_mean_s": 0.14351405271424614, - "dasjax_mean_s": 0.23610140819982917, + "dascore_mean_s": 0.13081185362625547, + "dasjax_mean_s": 0.2346832335999352, "group": "operation_pass_filter", - "speedup": 0.607849202630677 + "speedup": 0.5573975252499316 }, { "case": "large-f64", - "dascore_mean_s": 0.1569610861667267, - "dasjax_mean_s": 0.3055325966664289, + "dascore_mean_s": 0.1514530785001019, + "dasjax_mean_s": 0.2844445848008036, "group": "operation_pass_filter", - "speedup": 0.5137294281503193 + "speedup": 0.5324519663686493 }, { "case": "medium-f32", - "dascore_mean_s": 0.04044847061532682, - "dasjax_mean_s": 0.0535740397895815, + "dascore_mean_s": 0.032527580249864387, + "dasjax_mean_s": 0.052176482400136594, "group": "operation_pass_filter", - "speedup": 0.7550013173207222 + "speedup": 0.6234145874459952 }, { "case": "medium-f64", - "dascore_mean_s": 0.04170220657137439, - "dasjax_mean_s": 0.07101005280043561, + "dascore_mean_s": 0.04164246772081242, + "dasjax_mean_s": 0.07034695579956557, "group": "operation_pass_filter", - "speedup": 0.5872718710486379 + "speedup": 0.5919583476996682 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.007709398385319686, + "dasjax_mean_s": 0.01771389471709109, + "group": "operation_scale", + "speedup": 0.435217579671022 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.014517987178805924, + "dasjax_mean_s": 0.036403064703470725, + "group": "operation_scale", + "speedup": 0.3988122235604454 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.0014040707887125262, + "dasjax_mean_s": 0.0026716843637301637, + "group": "operation_scale", + "speedup": 0.5255376749490664 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.0027331539843771678, + "dasjax_mean_s": 0.004020802098549036, + "group": "operation_scale", + "speedup": 0.6797534216775966 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.03271859779325213, + "dasjax_mean_s": 0.02677430021631645, + "group": "operation_standardize", + "speedup": 1.2220150490922332 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.06161480506658942, + "dasjax_mean_s": 0.047110426545424904, + "group": "operation_standardize", + "speedup": 1.3078804329478757 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.006401470681010033, + "dasjax_mean_s": 0.005071113542843734, + "group": "operation_standardize", + "speedup": 1.2623402388699572 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.013299871999966949, + "dasjax_mean_s": 0.007162377103119821, + "group": "operation_standardize", + "speedup": 1.8569075334184415 + }, + { + "case": "large-f32", + "dascore_mean_s": 0.009185174989084693, + "dasjax_mean_s": 0.01774878547171884, + "group": "operation_taper", + "speedup": 0.5175100574470561 + }, + { + "case": "large-f64", + "dascore_mean_s": 0.015738343254567803, + "dasjax_mean_s": 0.0372611652959744, + "group": "operation_taper", + "speedup": 0.4223792554407345 + }, + { + "case": "medium-f32", + "dascore_mean_s": 0.002441625380864328, + "dasjax_mean_s": 0.0025713899945996347, + "group": "operation_taper", + "speedup": 0.9495352264697946 + }, + { + "case": "medium-f64", + "dascore_mean_s": 0.0031923615308187435, + "dasjax_mean_s": 0.004030060436244411, + "group": "operation_taper", + "speedup": 0.7921373838735 }, { "case": "large-f32", - "dascore_mean_s": 0.08525154969258718, - "dasjax_mean_s": 0.04037866288265778, + "dascore_mean_s": 0.0497878854001101, + "dasjax_mean_s": 0.03216135399959187, "group": "scale_add_detrend_normalize", - "speedup": 2.1113019502486257 + "speedup": 1.5480655883064474 }, { "case": "large-f64", - "dascore_mean_s": 0.09698225289994297, - "dasjax_mean_s": 0.06014784300008186, + "dascore_mean_s": 0.089915300092054, + "dasjax_mean_s": 0.05392152589430273, "group": "scale_add_detrend_normalize", - "speedup": 1.612397852734486 + "speedup": 1.6675214323182632 }, { "case": "medium-f32", - "dascore_mean_s": 0.011251645377685943, - "dasjax_mean_s": 0.0058049622475484265, + "dascore_mean_s": 0.010027643979318176, + "dasjax_mean_s": 0.005617196311436172, "group": "scale_add_detrend_normalize", - "speedup": 1.938280543071194 + "speedup": 1.7851688677681923 }, { "case": "medium-f64", - "dascore_mean_s": 0.02263596206534124, - "dasjax_mean_s": 0.010735889017007016, + "dascore_mean_s": 0.02164517268201135, + "dasjax_mean_s": 0.00887979291158391, "group": "scale_add_detrend_normalize", - "speedup": 2.1084385307525992 + "speedup": 2.4375762923226154 }, { "case": "large-f32", - "dascore_mean_s": 0.2694122765991779, - "dasjax_mean_s": 0.08099217654555767, + "dascore_mean_s": 0.217333702200267, + "dasjax_mean_s": 0.06826758373354096, "group": "scale_fbe", - "speedup": 3.3263987719558927 + "speedup": 3.183556386711362 }, { "case": "large-f64", - "dascore_mean_s": 0.2593546889997924, - "dasjax_mean_s": 0.12906283150005038, + "dascore_mean_s": 0.23468941240134883, + "dasjax_mean_s": 0.12220381800014163, "group": "scale_fbe", - "speedup": 2.0095226951509364 + "speedup": 1.920475286632017 }, { "case": "medium-f32", - "dascore_mean_s": 0.06117705750011737, - "dasjax_mean_s": 0.016964814050000616, + "dascore_mean_s": 0.059396552500629696, + "dasjax_mean_s": 0.016094810917775995, "group": "scale_fbe", - "speedup": 3.606114238553363 + "speedup": 3.6904162965362253 }, { "case": "medium-f64", - "dascore_mean_s": 0.07161363979964032, - "dasjax_mean_s": 0.026488216809411824, + "dascore_mean_s": 0.062460162599988205, + "dasjax_mean_s": 0.025890661076958237, "group": "scale_fbe", - "speedup": 2.703603655727949 + "speedup": 2.4124591648830287 }, { "case": "large-f32", - "dascore_mean_s": 0.2429028071997891, - "dasjax_mean_s": 0.09134150290010438, + "dascore_mean_s": 0.22368254179964425, + "dasjax_mean_s": 0.06857853256269664, "group": "scale_fbe_normalize", - "speedup": 2.6592819199114746 + "speedup": 3.2616991562942337 }, { "case": "large-f64", - "dascore_mean_s": 0.24544560220019776, - "dasjax_mean_s": 0.13214524928558344, + "dascore_mean_s": 0.23593561480010977, + "dasjax_mean_s": 0.11862296349954704, "group": "scale_fbe_normalize", - "speedup": 1.8573925549889214 + "speedup": 1.9889539751804521 }, { "case": "medium-f32", - "dascore_mean_s": 0.06755474915399436, - "dasjax_mean_s": 0.01810524253948917, + "dascore_mean_s": 0.062028346937268, + "dasjax_mean_s": 0.015839042776019257, "group": "scale_fbe_normalize", - "speedup": 3.731225859396876 + "speedup": 3.9161676506853436 }, { "case": "medium-f64", - "dascore_mean_s": 0.07054645092817477, - "dasjax_mean_s": 0.028195836228561737, + "dascore_mean_s": 0.06444275512512831, + "dasjax_mean_s": 0.025173454000185124, "group": "scale_fbe_normalize", - "speedup": 2.5020166224654417 + "speedup": 2.559948870133372 }, { "case": "large-f32", - "dascore_mean_s": 0.19576208779981244, - "dasjax_mean_s": 0.29107356519998573, + "dascore_mean_s": 0.14785859057051962, + "dasjax_mean_s": 0.23864778060087702, "group": "scale_pass_filter_abs", - "speedup": 0.6725519291499785 + "speedup": 0.6195682616374445 }, { "case": "large-f64", - "dascore_mean_s": 0.1968337761663861, - "dasjax_mean_s": 0.303922596749544, + "dascore_mean_s": 0.182844042000094, + "dasjax_mean_s": 0.28871820400017895, "group": "scale_pass_filter_abs", - "speedup": 0.6476444274678019 + "speedup": 0.6332958554978427 }, { "case": "medium-f32", - "dascore_mean_s": 0.04842030686383871, - "dasjax_mean_s": 0.055725851882444284, + "dascore_mean_s": 0.03665519632020733, + "dasjax_mean_s": 0.05447101847312297, "group": "scale_pass_filter_abs", - "speedup": 0.8689020486574726 + "speedup": 0.6729302544305041 }, { "case": "medium-f64", - "dascore_mean_s": 0.05123172271426787, - "dasjax_mean_s": 0.07264519385755973, + "dascore_mean_s": 0.04954743119978957, + "dasjax_mean_s": 0.07087507012533933, "group": "scale_pass_filter_abs", - "speedup": 0.7052321013103953 + "speedup": 0.6990812300032606 } ], "schema_version": 1, diff --git a/benchmarks/test_pipeline_benchmarks.py b/benchmarks/test_pipeline_benchmarks.py index c736bf9..50764d5 100644 --- a/benchmarks/test_pipeline_benchmarks.py +++ b/benchmarks/test_pipeline_benchmarks.py @@ -5,6 +5,7 @@ from collections.abc import Callable import dascore as dc +import numpy as np import pytest from dasjax import JaxPatchPipeline @@ -81,6 +82,62 @@ def dascore_scale_add_detrend_normalize(example_patch) -> Callable[[], object]: ) +@pytest.fixture(scope="module") +def dasjax_scale(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax scale operation.""" + compiled = JaxPatchPipeline().scale(2.0).compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_scale(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore scale operation.""" + return lambda: _scale_patch(example_patch, 2.0) + + +@pytest.fixture(scope="module") +def dasjax_add(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax add operation.""" + compiled = JaxPatchPipeline().add(1.0).compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_add(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore add operation.""" + return lambda: _add_patch(example_patch, 1.0) + + +@pytest.fixture(scope="module") +def dasjax_abs(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax abs operation.""" + compiled = JaxPatchPipeline().abs().compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_abs(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore abs operation.""" + return lambda: example_patch.abs() + + +@pytest.fixture(scope="module") +def dasjax_clip(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax clip operation.""" + compiled = JaxPatchPipeline().clip(-0.25, 0.25).compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_clip(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore clip operation.""" + return lambda: example_patch.update(data=np.clip(example_patch.data, -0.25, 0.25)) + + @pytest.fixture(scope="module") def dasjax_detrend(example_patch) -> Callable[[], object]: """Return a warmed compiled dasjax detrend operation.""" @@ -109,6 +166,90 @@ def dascore_normalize(example_patch) -> Callable[[], object]: return lambda: example_patch.normalize(dim="time") +@pytest.fixture(scope="module") +def dasjax_standardize(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax standardize operation.""" + compiled = JaxPatchPipeline().standardize(dim="time").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_standardize(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore standardize operation.""" + return lambda: example_patch.standardize(dim="time") + + +@pytest.fixture(scope="module") +def dasjax_differentiate(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax differentiate operation.""" + compiled = JaxPatchPipeline().differentiate(dim="time").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_differentiate(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore differentiate operation.""" + return lambda: example_patch.differentiate(dim="time") + + +@pytest.fixture(scope="module") +def dasjax_integrate(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax integrate operation.""" + compiled = JaxPatchPipeline().integrate(dim="time").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_integrate(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore integrate operation.""" + return lambda: example_patch.integrate(dim="time") + + +@pytest.fixture(scope="module") +def dasjax_taper(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax taper operation.""" + compiled = JaxPatchPipeline().taper(time=0.05, window_type="hann").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_taper(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore taper operation.""" + return lambda: example_patch.taper(time=0.05, window_type="hann") + + +@pytest.fixture(scope="module") +def dasjax_pad(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax pad operation.""" + compiled = JaxPatchPipeline().pad(time=(16, 16), samples=True).compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_pad(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore pad operation.""" + return lambda: example_patch.pad(time=(16, 16), samples=True) + + +@pytest.fixture(scope="module") +def dasjax_mean(example_patch) -> Callable[[], object]: + """Return a warmed compiled dasjax mean reduction.""" + compiled = JaxPatchPipeline().mean(dim="time").compile() + compiled(example_patch) + return lambda: compiled(example_patch) + + +@pytest.fixture(scope="module") +def dascore_mean(example_patch) -> Callable[[], object]: + """Return the equivalent DASCore mean reduction.""" + return lambda: example_patch.mean(dim="time") + + @pytest.fixture(scope="module") def dasjax_pass_filter(example_patch) -> Callable[[], object]: """Return a warmed compiled dasjax pass_filter operation.""" @@ -275,6 +416,46 @@ def test_dascore_scale_fbe_normalize( class TestIndividualOperationBenchmarks: """Benchmarks for individual dasjax operations and DASCore baselines.""" + @pytest.mark.benchmark(group="operation_scale") + def test_dasjax_compiled_operation_scale(self, benchmark, dasjax_scale) -> None: + """Benchmark warmed compiled dasjax scale execution.""" + benchmark(dasjax_scale) + + @pytest.mark.benchmark(group="operation_scale") + def test_dascore_operation_scale(self, benchmark, dascore_scale) -> None: + """Benchmark DASCore scale execution.""" + benchmark(dascore_scale) + + @pytest.mark.benchmark(group="operation_add") + def test_dasjax_compiled_operation_add(self, benchmark, dasjax_add) -> None: + """Benchmark warmed compiled dasjax add execution.""" + benchmark(dasjax_add) + + @pytest.mark.benchmark(group="operation_add") + def test_dascore_operation_add(self, benchmark, dascore_add) -> None: + """Benchmark DASCore add execution.""" + benchmark(dascore_add) + + @pytest.mark.benchmark(group="operation_abs") + def test_dasjax_compiled_operation_abs(self, benchmark, dasjax_abs) -> None: + """Benchmark warmed compiled dasjax abs execution.""" + benchmark(dasjax_abs) + + @pytest.mark.benchmark(group="operation_abs") + def test_dascore_operation_abs(self, benchmark, dascore_abs) -> None: + """Benchmark DASCore abs execution.""" + benchmark(dascore_abs) + + @pytest.mark.benchmark(group="operation_clip") + def test_dasjax_compiled_operation_clip(self, benchmark, dasjax_clip) -> None: + """Benchmark warmed compiled dasjax clip execution.""" + benchmark(dasjax_clip) + + @pytest.mark.benchmark(group="operation_clip") + def test_dascore_operation_clip(self, benchmark, dascore_clip) -> None: + """Benchmark DASCore-equivalent clip execution.""" + benchmark(dascore_clip) + @pytest.mark.benchmark(group="operation_detrend") def test_dasjax_compiled_operation_detrend(self, benchmark, dasjax_detrend) -> None: """Benchmark warmed compiled dasjax detrend execution.""" @@ -297,6 +478,76 @@ def test_dascore_operation_normalize(self, benchmark, dascore_normalize) -> None """Benchmark DASCore normalize execution.""" benchmark(dascore_normalize) + @pytest.mark.benchmark(group="operation_standardize") + def test_dasjax_compiled_operation_standardize( + self, benchmark, dasjax_standardize + ) -> None: + """Benchmark warmed compiled dasjax standardize execution.""" + benchmark(dasjax_standardize) + + @pytest.mark.benchmark(group="operation_standardize") + def test_dascore_operation_standardize( + self, benchmark, dascore_standardize + ) -> None: + """Benchmark DASCore standardize execution.""" + benchmark(dascore_standardize) + + @pytest.mark.benchmark(group="operation_differentiate") + def test_dasjax_compiled_operation_differentiate( + self, benchmark, dasjax_differentiate + ) -> None: + """Benchmark warmed compiled dasjax differentiate execution.""" + benchmark(dasjax_differentiate) + + @pytest.mark.benchmark(group="operation_differentiate") + def test_dascore_operation_differentiate( + self, benchmark, dascore_differentiate + ) -> None: + """Benchmark DASCore differentiate execution.""" + benchmark(dascore_differentiate) + + @pytest.mark.benchmark(group="operation_integrate") + def test_dasjax_compiled_operation_integrate( + self, benchmark, dasjax_integrate + ) -> None: + """Benchmark warmed compiled dasjax integrate execution.""" + benchmark(dasjax_integrate) + + @pytest.mark.benchmark(group="operation_integrate") + def test_dascore_operation_integrate(self, benchmark, dascore_integrate) -> None: + """Benchmark DASCore integrate execution.""" + benchmark(dascore_integrate) + + @pytest.mark.benchmark(group="operation_taper") + def test_dasjax_compiled_operation_taper(self, benchmark, dasjax_taper) -> None: + """Benchmark warmed compiled dasjax taper execution.""" + benchmark(dasjax_taper) + + @pytest.mark.benchmark(group="operation_taper") + def test_dascore_operation_taper(self, benchmark, dascore_taper) -> None: + """Benchmark DASCore taper execution.""" + benchmark(dascore_taper) + + @pytest.mark.benchmark(group="operation_pad") + def test_dasjax_compiled_operation_pad(self, benchmark, dasjax_pad) -> None: + """Benchmark warmed compiled dasjax pad execution.""" + benchmark(dasjax_pad) + + @pytest.mark.benchmark(group="operation_pad") + def test_dascore_operation_pad(self, benchmark, dascore_pad) -> None: + """Benchmark DASCore pad execution.""" + benchmark(dascore_pad) + + @pytest.mark.benchmark(group="operation_mean") + def test_dasjax_compiled_operation_mean(self, benchmark, dasjax_mean) -> None: + """Benchmark warmed compiled dasjax mean reduction execution.""" + benchmark(dasjax_mean) + + @pytest.mark.benchmark(group="operation_mean") + def test_dascore_operation_mean(self, benchmark, dascore_mean) -> None: + """Benchmark DASCore mean reduction execution.""" + benchmark(dascore_mean) + @pytest.mark.benchmark(group="operation_pass_filter") def test_dasjax_compiled_operation_pass_filter( self, benchmark, dasjax_pass_filter diff --git a/docs/development/documentation.md b/docs/development/documentation.md index 56bcae1..46751ef 100644 --- a/docs/development/documentation.md +++ b/docs/development/documentation.md @@ -3,18 +3,17 @@ Documentation is built with Zensical. The API reference page is generated from the public `dasjax` package API immediately before the site build. Benchmark documentation is generated from the checked-in benchmark snapshot. ```bash -python -m pip install -e ".[docs]" -python scripts/build_api_docs.py -python scripts/build_benchmark_docs.py -zensical build --clean +uv run python scripts/build_api_docs.py +uv run python scripts/build_benchmark_docs.py +uv run --extra docs zensical build --clean ``` Preview the site locally with: ```bash -python scripts/build_api_docs.py -python scripts/build_benchmark_docs.py -zensical serve +uv run python scripts/build_api_docs.py +uv run python scripts/build_benchmark_docs.py +uv run --extra docs zensical serve ``` Generated API reference pages are written under `docs/api/`, generated benchmark docs are written under `docs/benchmarks/`, and the static site is written to `site/`. These outputs are ignored by version control. @@ -22,15 +21,14 @@ Generated API reference pages are written under `docs/api/`, generated benchmark Refresh the benchmark snapshot before building benchmark docs with: ```bash -dasjax-benchmark refresh +uv run dasjax-benchmark refresh ``` ## Local Checks ```bash -python -m pip install -e ".[test,docs]" -python scripts/build_api_docs.py -python scripts/build_benchmark_docs.py -zensical build --clean -python -m pytest +uv run python scripts/build_api_docs.py +uv run python scripts/build_benchmark_docs.py +uv run --extra docs zensical build --clean +uv run pytest ``` diff --git a/docs/development/operation-coverage.md b/docs/development/operation-coverage.md index cc298b8..3a41fa0 100644 --- a/docs/development/operation-coverage.md +++ b/docs/development/operation-coverage.md @@ -1,6 +1,6 @@ # Operation Coverage -The package currently registers 75 pipeline operations. Most are implemented as JAX-backed kernels with static metadata planning; heavier DASCore-compatible numeric transforms can use host callbacks when a full static JAX kernel is not yet practical. Callback-backed operations are compatibility paths and generally offer less fusion benefit than native kernels. +The package currently registers 72 pipeline operations. Most are implemented as JAX-backed kernels with static metadata planning; heavier DASCore-compatible numeric transforms can use host callbacks when a full static JAX kernel is not yet practical. Callback-backed operations are compatibility paths and generally offer less fusion benefit than native kernels. Remaining DASCore patch methods are mostly metadata, selection, convenience, or data-dependent shape operations. In particular, `rolling` returns a roller object and `dropna` has data-dependent output shape, so they do not map directly to the current compiled `Patch -> Patch` pipeline model. diff --git a/pyproject.toml b/pyproject.toml index 16f01cd..c50077b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,7 +30,6 @@ test = [ "pytest", "pytest-benchmark", "pytest-codspeed", - "bottleneck", ] dev = [ "prek>=0.3.8", diff --git a/src/dasjax/benchmark_cli.py b/src/dasjax/benchmark_cli.py index 34091f2..ca521f9 100644 --- a/src/dasjax/benchmark_cli.py +++ b/src/dasjax/benchmark_cli.py @@ -99,7 +99,10 @@ def _case_label(value: Any) -> str: shape_label = { (600, 4000): "medium", (1200, 8000): "large", - }.get(tuple(int(axis) for axis in shape), "x".join(str(axis) for axis in shape)) + }.get( + tuple(int(axis) for axis in shape), + "x".join(str(axis) for axis in shape), + ) dtype_label = str(dtype).removeprefix("float") return f"{shape_label}-f{dtype_label}" return str(value) @@ -187,7 +190,9 @@ def load_json(path: Path) -> dict[str, Any]: def write_json(path: Path, payload: dict[str, Any]) -> None: """Write stable, pretty JSON to a path.""" path.parent.mkdir(parents=True, exist_ok=True) - path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8") + path.write_text( + json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8" + ) def _format_ms(value: float | None) -> str: @@ -204,16 +209,29 @@ def _format_speedup(value: float | None) -> str: return f"{value:.2f}x" +def _sort_value(value: float | None) -> str: + """Return a stable table sort value for optional numeric cells.""" + if value is None or not math.isfinite(value): + return "" + return f"{value:.12g}" + + def _benchmark_category(group: str) -> str: """Return a human category for a benchmark group.""" return "Method" if group.startswith("operation_") else "Pipeline" -def _split_rows(snapshot: dict[str, Any]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: +def _split_rows( + snapshot: dict[str, Any], +) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: """Return pipeline rows and method rows from a benchmark snapshot.""" rows = snapshot.get("rows") or [] - pipelines = [row for row in rows if not str(row.get("group", "")).startswith("operation_")] - methods = [row for row in rows if str(row.get("group", "")).startswith("operation_")] + pipelines = [ + row for row in rows if not str(row.get("group", "")).startswith("operation_") + ] + methods = [ + row for row in rows if str(row.get("group", "")).startswith("operation_") + ] return pipelines, methods @@ -291,14 +309,38 @@ def _benchmark_display_name(group: str) -> str: def _render_filter_script() -> str: - """Return client-side table filtering script.""" + """Return client-side table filtering and sorting script.""" return """