From 059e065f87b6402f672804d51860c1aa4ea6568c Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Sun, 21 Jun 2026 22:14:45 +0200 Subject: [PATCH 01/58] docs: design for Sentinel-3 OLCI L1 EFR -> GeoZarr export First Sentinel-3 exporter, scoped to OLCI L1 EFR. Grounded in a real EOPF product introspected from the EODC sample store: 21 radiance bands on a single ~300m curvilinear swath grid geolocated by per-pixel 2D lat/lon (no projected CRS). Decision: preserve native swath geometry with CF 2D coordinates (no reprojection); /2 decimation pyramid; measurements-first scope; mirror the S2 package + data_api model + CLI auto-detection. Co-Authored-By: Claude Opus 4.8 --- ...2026-06-21-sentinel3-olci-export-design.md | 182 ++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md diff --git a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md new file mode 100644 index 00000000..6f0a5f81 --- /dev/null +++ b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md @@ -0,0 +1,182 @@ +# Sentinel-3 OLCI L1 EFR → GeoZarr export — design + +Status: draft for review +Date: 2026-06-21 +Branch: `feat/sentinel3-export` (off `chore/new-conventions-metadata`) + +## Goal + +Add a first Sentinel-3 exporter to eopf-geozarr, scoped to **OLCI Level-1 EFR** +(Ocean and Land Colour Instrument, Earth-observation Full Resolution). It +converts an EOPF OLCI product into a GeoZarr-spec-compliant, multiscale Zarr +store, modeled on the existing Sentinel-2 exporter but adapted to OLCI's +fundamentally different geometry. + +This is the first of several Sentinel-3 product types (SLSTR, SRAL, SYNERGY are +out of scope here and will get their own specs). + +## Source format (verified against a real product) + +Introspected from a real `_NT_` (non-time-critical, fully consolidated) product +on the EODC EOPF sample store, e.g.: +`S3A_OL_1_EFR____20251101T073957..._NT_004.zarr` in bucket +`e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu` on `objects.eodc.eu`. + +Key facts: + +- **Zarr v2**, consolidated metadata at root (`.zmetadata`). NOTE: `_NR_` + (near-real-time) copies of the same products are often *incomplete* (chunks + but no metadata) — use `_NT_` products as the source of truth. +- Top-level groups mirror S2: `measurements`, `quality`, `conditions` (plus + `*/orphans` subgroups, an OLCI artifact for removed/duplicate pixels). +- `measurements/`: 21 radiance bands `oa01_radiance` … `oa21_radiance`, each + `[4090, 4865]` `uint16`, dims `(rows, columns)` — a **single full-resolution + ~300 m grid; all 21 bands share the same shape** (unlike S2's 10/20/60 m). + Each band has CF `scale_factor`/`add_offset`, `units`, + `standard_name=toa_upwelling_spectral_radiance`, and + `coordinates: latitude longitude altitude time_stamp`. +- **Geolocation is per-pixel / curvilinear**: `measurements/latitude`, + `measurements/longitude`, `measurements/altitude` are 2D `[4090, 4865]` + arrays (`latitude`/`longitude` are scaled `int32`, scale `1e-6`, with fill + values). There is **no projected CRS, no EPSG, no affine transform** — root + attrs are empty. OLCI is delivered in satellite swath geometry. +- `conditions/geometry`: sun/view angles (`sza`, `saa`, `oza`, `oaa`) on a + **coarser across-track tie-point grid** `[4090, 77]`. +- `conditions/instrument`: per-band/detector spectral data (`lambda0`, + `solar_flux`, `fwhm`) shaped `[21, 3700]`; `relative_spectral_covariance` + `[21, 21]`. +- `conditions/meteorology`: ECMWF fields on the `[4090, 77]` tie-point grid, + some with a `pressure_level` (25) dim. +- `conditions/image`: `altitude`, `detector_index`, `frame_offset`, + `latitude`, `longitude` at full `[4090, 4865]`; `time_stamp` `[4090]`. + +## Core design decision: native swath geometry (no reprojection) + +OLCI L1 has no projected grid. We **preserve native swath geometry**: keep the +per-pixel `latitude`/`longitude` as 2-D auxiliary coordinate variables +(CF "two-dimensional coordinates" + GeoZarr geographic convention). **No +reprojection / resampling** — faithful and lossless. + +Consequences: +- The GeoZarr `proj` convention is geographic (lat/lon), not a projected CRS + + affine transform. We attach 2-D coordinate arrays via CF `coordinates` and the + appropriate GeoZarr `spatial`/`proj` metadata for curvilinear data (no + `spatial:transform`; lat/lon carried as coordinate arrays). +- Multiscale overviews are produced by **simple /2 decimation** of + `rows`/`columns` (subsample the radiance grid AND the lat/lon/altitude + coordinate arrays together so geolocation stays consistent per level). This is + the COG-style /2 approach minus the projected-grid assumption. (Reprojection + to a regular grid is explicitly a *future* option, not in this deliverable.) + +## Scope (v1): measurements-first + +- **`measurements/`** → GeoZarr-compliant multiscale group: + - 21 radiance bands + the 2-D `latitude`/`longitude`/`altitude` coordinate + arrays, CF `coordinates` linkage preserved, scale/offset preserved + (same handling as S2 reflectance encoding). + - `/2` overview pyramid (decimation), down to a configurable min dimension. +- **`conditions/` and `quality/`** → copied through faithfully but unoptimized + (the way the S2 path copies non-reflectance groups as-is). +- **`orphans/`** subgroups → copied through as-is (not specially handled). +- Out of scope for v1: GeoZarr-converting the tie-point geometry grid, 3-D + meteorology, and 1-D instrument arrays; SLSTR/SRAL/SYNERGY; reprojection. + +## Architecture — mirror the S2 package + +Reuse the S2 exporter's shape (a self-contained product package + a data_api +model + CLI auto-detection). New code: + +``` +src/eopf_geozarr/s3_olci_optimization/ # parallels s2_optimization/ + __init__.py + olci_band_mapping.py # 21 OLCI bands (oa01..oa21), band metadata; the + # "all bands one resolution" config + olci_multiscale.py # swath /2 decimation pyramid + GeoZarr metadata; + # decimates radiance + 2D coord arrays together + olci_converter.py # convert_olci_optimized(dt, *, output_path, ...) + # entry point + is_sentinel3_olci_dataset() + common.py # (or reuse s2_optimization.common) + +src/eopf_geozarr/data_api/s3_olci.py # Sentinel3OlciRoot pydantic model + # (GroupSpec/TypedDict members) +``` + +Reused as-is from existing code: +- Generic encoding / chunk-alignment / fill-value helpers in + `conversion/utils.py` and `fs_utils.py`. +- GeoZarr convention metadata helpers (`conversion/utils.build_convention_attrs`, + zarr-cm), root consolidation, snapshot/round-trip test patterns. +- Type-aware resampling: OLCI radiance is all "reflectance-like" (block-average + on decimation); we can reuse `s2_resampling` averaging or a thin OLCI variant. + v1 only needs averaging/decimation since all bands are one continuous + radiance type (no SCL/quality-mask variety in `measurements/`). + +### Product detection + +S2/S1 are detected **structurally** (validate the zarr group against +`Sentinel1Root | Sentinel2Root` pydantic models in `is_sentinel2_dataset`). OLCI +root attrs are empty, so structural detection is the right approach: add +`Sentinel3OlciRoot` and extend the adapter to +`Sentinel1Root | Sentinel2Root | Sentinel3OlciRoot`. The CLI `convert` command's +auto-detect dispatches to `convert_olci_optimized` when the product validates as +OLCI. + +### CLI + +- Auto-detect in `convert` (as S2 does). +- Dedicated `convert-s3-olci-optimized` subcommand mirroring + `convert-s2-optimized` (spatial-chunk, sharding, compression-level, + keep-scale-offset, skip-validation, dask-cluster, verbose). + +## Data model (`data_api/s3_olci.py`) + +Follow the S2 pattern (pydantic `GroupSpec` + `closed=True` TypedDict members), +NOT the S1 dynamic-mapping pattern, because OLCI has a fixed known structure: + +- `Sentinel3OlciRoot(GroupSpec[..., Sentinel3OlciRootMembers])` with + `measurements`, `quality`, `conditions` members. +- `Sentinel3OlciMeasurementsMembers`: the 21 `oaNN_radiance` arrays + + `latitude`/`longitude`/`altitude` (+ optional `orphans`). Genuinely-optional + members stay `NotRequired`/`total=False` (lesson from the S1 model: don't make + variant keys required, or real products fail validation). Accessors narrow + with `.get()` + guard. + +Type checking: pyright (project standard). No `typing.Any`. Convention metadata +built via `zarr_cm` / `build_convention_attrs`. + +## Testing (match existing pattern) + +1. **Structure-dump fixture**: generate a JSON metadata-dump of a real OLCI + `_NT_` product via pydantic-zarr `GroupSpec` (as `s1_examples`/`s2_examples` + were made), commit to `tests/_test_data/s3_examples/`, add an + `s3_olci_group_example` fixture in `conftest.py` that materializes it to zarr + via `create_group_from_json`. First confirm the dump round-trips cleanly for + OLCI. +2. **Unit tests**: band mapping, swath decimation correctness (radiance and + lat/lon decimate consistently), GeoZarr metadata emitted, model validation + (incl. a real-product round-trip). +3. **Golden-file snapshot** of the converted structure (like + `optimized_geozarr_examples`), with the URL-only-diff regeneration discipline. +4. **Synthetic in-memory OLCI builder** for an integration test (mirrors the + S1/S2 integration mocks) exercising `convert_olci_optimized` end-to-end. +5. **CLI e2e** for `convert-s3-olci-optimized` on the materialized fixture. + +## Open questions / risks + +- **CF curvilinear + GeoZarr `spatial`/`proj` for swath data**: confirm the + exact GeoZarr metadata form for 2-D-coordinate (non-gridded) data during + implementation; the conventions are grid-oriented and may need a geographic / + coordinate-array representation rather than `spatial:transform`. +- **Decimation vs. averaging for overviews**: v1 uses simple /2; confirm whether + block-averaging radiance (and what to do with lat/lon — decimate, not average) + is preferred for the pyramid. +- **EOPF data access plumbing**: opening these remote products needs the right + storage handling (tenant:bucket name breaks s3fs; `_NR_` products lack + metadata). Test data is committed as JSON dumps, so this only matters for + regenerating fixtures, not for CI. + +## Decomposition / sequencing + +This spec is one implementation plan: the OLCI measurements-first exporter. +Follow-ups (separate specs): OLCI conditions/quality GeoZarr conversion; +reprojection-to-grid option; SLSTR / SRAL / SYNERGY. From ee43eba4bca590fa46c436a9d2a42070c6a40ae0 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Sun, 21 Jun 2026 22:44:38 +0200 Subject: [PATCH 02/58] docs: implementation plan for Sentinel-3 OLCI export 10-task TDD plan mirroring the S2 exporter: OLCI band mapping, data_api model, swath /2 decimation, structural detection, swath GeoZarr metadata, convert_olci_optimized entry point, CLI auto-detect + convert-s3-olci-optimized, real-product JSON fixture, golden-file snapshot, and verification/docs. Co-Authored-By: Claude Opus 4.8 --- .../plans/2026-06-21-sentinel3-olci-export.md | 1169 +++++++++++++++++ 1 file changed, 1169 insertions(+) create mode 100644 docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md diff --git a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md new file mode 100644 index 00000000..bd78e396 --- /dev/null +++ b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md @@ -0,0 +1,1169 @@ +# Sentinel-3 OLCI L1 EFR → GeoZarr Export Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a Sentinel-3 OLCI L1 EFR exporter that converts an EOPF OLCI product into a GeoZarr-compliant, multiscale Zarr store, preserving native swath geometry (per-pixel 2-D lat/lon, no reprojection). + +**Architecture:** Mirror the existing Sentinel-2 exporter: a self-contained `s3_olci_optimization/` package (band mapping, multiscale, converter), a `data_api/s3_olci.py` pydantic-zarr model for structural product detection, and CLI auto-detection plus a dedicated `convert-s3-olci-optimized` subcommand. Overviews are produced by /2 decimation of the swath grid (radiance bands and 2-D lat/lon/altitude coordinate arrays decimated together). + +**Tech Stack:** Python 3.12+, pydantic v2 + pydantic-zarr, zarr v3 (output) / zarr v2 (EOPF input), xarray (DataTree), zarr-cm conventions, pyright (type checker), ruff, pytest. + +Design doc: `docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md` + +## Global Constraints + +- Python ≥ 3.12; modern type hints (`|`, `list`, `dict`). +- **Never use `typing.Any`.** Use `object` + narrowing or precise types. (Existing `ArraySpec[Any]` in s2.py is pre-existing; do not copy `Any` into new code — use `ArraySpec[object]` or a precise attrs type.) +- Type checker is **pyright** (`uv run --frozen pyright`); 0 errors required. Lint/format is **ruff** (`uv run ruff check`, `uv run ruff format`). +- Build convention metadata via `zarr_cm` / `eopf_geozarr.conversion.utils.build_convention_attrs`; never hand-assemble `zarr_conventions`. +- Run tools with `uv run`. Tests: `uv run pytest`. +- Commit messages end with the project's `Co-Authored-By: Claude Opus 4.8 ` trailer. +- Pydantic model members: keep genuinely-optional keys `NotRequired`/`total=False`; never make variant keys Required (real products fail validation otherwise). Property accessors narrow with `.get()` + guard. + +--- + +## File Structure + +Create: +- `src/eopf_geozarr/s3_olci_optimization/__init__.py` — package marker. +- `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` — the 21 OLCI band names + per-band metadata; "all bands one resolution" config. +- `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` — swath /2 decimation pyramid + GeoZarr metadata. +- `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` — `convert_olci_optimized()` entry point + `is_sentinel3_olci_dataset()`. +- `src/eopf_geozarr/data_api/s3_olci.py` — `Sentinel3OlciRoot` pydantic-zarr model. +- `tests/test_data_api/test_s3_olci.py` — model + detection tests. +- `tests/test_olci_band_mapping.py` — band mapping tests. +- `tests/test_olci_multiscale.py` — decimation + metadata tests. +- `tests/test_olci_integration.py` — synthetic end-to-end + CLI e2e. +- `tests/_test_data/s3_examples/.json` — committed structure dump (Task 8). + +Modify: +- `src/eopf_geozarr/cli.py` — auto-detect OLCI in `convert_command`; add `convert-s3-olci-optimized` subcommand. +- `src/eopf_geozarr/s2_optimization/s2_converter.py` — extend the detection `TypeAdapter` union to include `Sentinel3OlciRoot` (or add a dedicated OLCI detector — see Task 4). +- `tests/conftest.py` — add `s3_olci_group_example` fixture + `s3_example_json_paths`. + +--- + +## Task 1: OLCI band mapping + +**Files:** +- Create: `src/eopf_geozarr/s3_olci_optimization/__init__.py` +- Create: `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` +- Test: `tests/test_olci_band_mapping.py` + +**Interfaces:** +- Produces: `OLCI_BANDS: tuple[str, ...]` (the 21 names `oa01_radiance`..`oa21_radiance`); `OlciBandInfo` dataclass (`name: str`, `data_type: str`, `wavelength_center: float`); `OLCI_BAND_INFO: dict[str, OlciBandInfo]`; `RADIANCE_DTYPE = "uint16"`. + +OLCI band central wavelengths (nm), Oa01–Oa21: +`400, 412.5, 442.5, 490, 510, 560, 620, 665, 673.75, 681.25, 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865, 885, 900, 940, 1020`. + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_olci_band_mapping.py +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( + OLCI_BANDS, + OLCI_BAND_INFO, + OlciBandInfo, + RADIANCE_DTYPE, +) + + +def test_there_are_21_olci_bands() -> None: + assert len(OLCI_BANDS) == 21 + assert OLCI_BANDS[0] == "oa01_radiance" + assert OLCI_BANDS[-1] == "oa21_radiance" + + +def test_every_band_has_info() -> None: + assert set(OLCI_BAND_INFO) == set(OLCI_BANDS) + for name, info in OLCI_BAND_INFO.items(): + assert isinstance(info, OlciBandInfo) + assert info.name == name + assert info.data_type == RADIANCE_DTYPE + assert info.wavelength_center > 0 + + +def test_first_band_wavelength() -> None: + assert OLCI_BAND_INFO["oa01_radiance"].wavelength_center == 400.0 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_band_mapping.py -v` +Expected: FAIL (ModuleNotFoundError: eopf_geozarr.s3_olci_optimization). + +- [ ] **Step 3: Create the package marker** + +```python +# src/eopf_geozarr/s3_olci_optimization/__init__.py +"""Sentinel-3 OLCI L1 EFR optimization (GeoZarr export).""" +``` + +- [ ] **Step 4: Implement the band mapping** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py +"""Band definitions for Sentinel-3 OLCI L1 EFR. + +OLCI has 21 radiance bands (Oa01..Oa21), all delivered at the same full +resolution (~300 m) on a single swath grid. +""" + +from dataclasses import dataclass + +RADIANCE_DTYPE = "uint16" + +# Band index -> central wavelength in nm (OLCI Oa01..Oa21). +_WAVELENGTHS_NM: tuple[float, ...] = ( + 400.0, 412.5, 442.5, 490.0, 510.0, 560.0, 620.0, 665.0, 673.75, 681.25, + 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865.0, 885.0, 900.0, + 940.0, 1020.0, +) + +OLCI_BANDS: tuple[str, ...] = tuple(f"oa{i:02d}_radiance" for i in range(1, 22)) + + +@dataclass(frozen=True) +class OlciBandInfo: + """Spectral characterization of a single OLCI radiance band.""" + + name: str + data_type: str + wavelength_center: float # nanometers + + +OLCI_BAND_INFO: dict[str, OlciBandInfo] = { + name: OlciBandInfo(name=name, data_type=RADIANCE_DTYPE, wavelength_center=wl) + for name, wl in zip(OLCI_BANDS, _WAVELENGTHS_NM, strict=True) +} +``` + +- [ ] **Step 5: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_band_mapping.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py` +Expected: tests PASS; pyright 0 errors; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py +git commit -m "feat(s3-olci): add OLCI band mapping + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 2: Data API model + structural detection helper + +**Files:** +- Create: `src/eopf_geozarr/data_api/s3_olci.py` +- Test: `tests/test_data_api/test_s3_olci.py` + +**Interfaces:** +- Consumes: `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.{ArraySpec, GroupSpec}`; `eopf_geozarr.data_api.geozarr.common.DatasetAttrs`. +- Produces: + - `Sentinel3OlciMeasurementsMembers` (TypedDict, closed, total=False): 21 `oaNN_radiance` + `latitude`/`longitude`/`altitude` + optional `orphans`. + - `Sentinel3OlciMeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers])`. + - `Sentinel3OlciRootMembers` (closed, total=False): `measurements` (required), `quality` (NotRequired), `conditions` (NotRequired). + - `Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers])` with `.measurements` accessor. + +Use `ArraySpec[object]` (NOT `ArraySpec[Any]`). `quality`/`conditions` members typed as `GroupSpec[object, object]` (we don't model their internals in v1). Detection is structural: a product is OLCI iff it validates as `Sentinel3OlciRoot` (i.e. has `measurements` with the radiance bands). + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_data_api/test_s3_olci.py +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +def _olci_arr() -> dict[str, object]: + # minimal v2 ArraySpec-shaped dict for a 2-D uint16 array + return ArraySpec( + shape=(4, 5), chunks=(4, 5), dtype=" None: + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root = { + "zarr_format": 2, + "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {**radiance, **coords}, + }, + }, + } + model = Sentinel3OlciRoot.model_validate(root) + assert "oa01_radiance" in model.measurements.members + + +def test_rejects_non_olci_product() -> None: + import pytest + from pydantic import ValidationError + + not_olci = { + "zarr_format": 2, "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": {"measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {"reflectance": { + "zarr_format": 2, "node_type": "group", "attributes": {}, "members": {}}}, + }}, + } + with pytest.raises(ValidationError): + Sentinel3OlciRoot.model_validate(not_olci) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: FAIL (cannot import `Sentinel3OlciRoot`). + +- [ ] **Step 3: Implement the model** (follow `data_api/s2.py` patterns exactly) + +```python +# src/eopf_geozarr/data_api/s3_olci.py +"""Pydantic-zarr model for the Sentinel-3 OLCI L1 EFR EOPF Zarr structure. + +Mirrors data_api/s2.py: GroupSpec + closed TypedDict members. Used for +structural product detection (an EOPF product is OLCI iff it validates here). +""" + +from __future__ import annotations + +from pydantic import BaseModel +from typing_extensions import TypedDict + +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +class Sentinel3OlciRootAttrs(BaseModel): + """Root-level attributes for an OLCI DataTree (not validated in detail).""" + + other_metadata: dict[str, object] + stac_discovery: dict[str, object] + + +class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): + """Members of the OLCI measurements group. + + The 21 radiance bands and the per-pixel geolocation coordinate arrays are + required in practice but typed optional so partial/variant products still + validate; the converter checks for the bands it needs. + """ + + latitude: ArraySpec[object] + longitude: ArraySpec[object] + altitude: ArraySpec[object] + orphans: GroupSpec[object, object] + oa01_radiance: ArraySpec[object] + oa02_radiance: ArraySpec[object] + oa03_radiance: ArraySpec[object] + oa04_radiance: ArraySpec[object] + oa05_radiance: ArraySpec[object] + oa06_radiance: ArraySpec[object] + oa07_radiance: ArraySpec[object] + oa08_radiance: ArraySpec[object] + oa09_radiance: ArraySpec[object] + oa10_radiance: ArraySpec[object] + oa11_radiance: ArraySpec[object] + oa12_radiance: ArraySpec[object] + oa13_radiance: ArraySpec[object] + oa14_radiance: ArraySpec[object] + oa15_radiance: ArraySpec[object] + oa16_radiance: ArraySpec[object] + oa17_radiance: ArraySpec[object] + oa18_radiance: ArraySpec[object] + oa19_radiance: ArraySpec[object] + oa20_radiance: ArraySpec[object] + oa21_radiance: ArraySpec[object] + + +class Sentinel3OlciMeasurementsGroup( + GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers] +): + """OLCI measurements group: 21 radiance bands + 2-D geolocation.""" + + +class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): + """Members of the OLCI root group.""" + + measurements: Sentinel3OlciMeasurementsGroup + quality: GroupSpec[object, object] + conditions: GroupSpec[object, object] + + +class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): + """Complete Sentinel-3 OLCI L1 EFR EOPF Zarr hierarchy.""" + + @property + def measurements(self) -> Sentinel3OlciMeasurementsGroup: + group = self.members.get("measurements") + if group is None: + raise KeyError("measurements") + return group +``` + +NOTE: to make detection meaningful (Task 4), the `measurements` member must be +required for a product to count as OLCI. If `closed=True, total=False` lets an +empty product validate, change `Sentinel3OlciRootMembers` so `measurements` is +required (a separate `closed=True` TypedDict without `total=False` containing +only `measurements`, with `quality`/`conditions` in a `total=False` mixin) OR +add an explicit check in `is_sentinel3_olci_dataset` (Task 4) that +`oa01_radiance` is among `measurements.members`. Implement the explicit check in +Task 4 (simpler, and keeps the model permissive). Adjust the +`test_rejects_non_olci_product` test if needed so it asserts via the Task 4 +detector rather than model validation — but since model validation with +`closed=True` rejects the `reflectance` key under `measurements`, the test above +should pass as written. Run it and confirm. + +- [ ] **Step 4: Run tests** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: PASS. If `test_rejects_non_olci_product` does not raise (because the +permissive members allow it), move that assertion into Task 4's detector test +and keep only the positive test here. + +- [ ] **Step 5: Type + lint** + +Run: `uv run --frozen pyright src/eopf_geozarr/data_api/s3_olci.py && uv run ruff check src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py` +Expected: pyright 0 errors; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py +git commit -m "feat(s3-olci): add Sentinel3OlciRoot data-api model + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 3: Swath /2 decimation + +**Files:** +- Create: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` + +**Interfaces:** +- Consumes: `xarray`, `numpy`. +- Produces: `decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset` — returns a dataset with every 2-D `(rows, columns)` variable AND the 2-D coordinate arrays (`latitude`/`longitude`/`altitude`) subsampled `[::factor, ::factor]`, preserving attrs/encoding and CF `coordinates` linkage. 1-D and non-(rows,columns) variables are passed through unchanged. + +Decimation (not averaging) is correct for v1: it keeps geolocation exact (an averaged lat/lon would no longer correspond to a real pixel). Radiance is decimated too for consistency with its coordinates. + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_olci_multiscale.py +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath + + +def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={"scale_factor": 0.5, "units": "mW.m-2.sr-1.nm-1"}, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +def test_decimate_halves_each_axis() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_decimate_takes_every_other_pixel() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + # top-left pixel is preserved exactly (no averaging) + assert int(out["oa01_radiance"].values[0, 0]) == 0 + assert float(out["latitude"].values[0, 0]) == 0.0 + + +def test_decimate_preserves_attrs() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py -v` +Expected: FAIL (cannot import `decimate_swath`). + +- [ ] **Step 3: Implement decimation** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +"""Multiscale (overview) generation for OLCI swath data. + +OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays, +so overviews are produced by /2 decimation of the (rows, columns) grid: every +2-D variable and its 2-D coordinate arrays are subsampled together, keeping +geolocation exact. (Averaging is intentionally avoided — an averaged lat/lon +would not correspond to a real pixel.) +""" + +from __future__ import annotations + +import xarray as xr + +SWATH_DIMS = ("rows", "columns") + + +def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with every (rows, columns) array subsampled by *factor*. + + Both data variables and coordinate variables that span exactly the swath + dims are decimated `[::factor, ::factor]`; everything else is passed + through unchanged. Attributes and encoding are preserved by xarray's isel. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + indexers = { + dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes + } + if not indexers: + return ds + return ds.isel(indexers) +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): add swath /2 decimation for overviews + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 4: Product detection (`is_sentinel3_olci_dataset`) + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` (create in this task) +- Test: `tests/test_data_api/test_s3_olci.py` (extend) + +**Interfaces:** +- Consumes: `Sentinel3OlciRoot` (Task 2); `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.GroupSpec`; `zarr`. +- Produces: `is_sentinel3_olci_dataset(group: zarr.Group) -> bool` — True iff the group validates as `Sentinel3OlciRoot` AND `measurements` contains `oa01_radiance`. + +Pattern mirrors `is_sentinel2_dataset` in `s2_converter.py` (validate `GroupSpec.from_zarr(group).model_dump()`), but the extra `oa01_radiance` check makes detection robust given the permissive model. + +- [ ] **Step 1: Write the failing test (extend test_s3_olci.py)** + +```python +# append to tests/test_data_api/test_s3_olci.py +def test_detector_accepts_olci_zarr(tmp_path) -> None: + import zarr + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + # build a minimal OLCI zarr v2 store from the model dict used above + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root_dict = { + "zarr_format": 2, "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": {"measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {**radiance, **coords}}}, + } + out = tmp_path / "olci.zarr" + PyzGroupSpec.model_validate(root_dict).to_zarr(out, path="") # type: ignore[arg-type] + group = zarr.open_group(str(out), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_detector_rejects_s2_zarr(s2_group_example) -> None: + import zarr + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + group = zarr.open_group(str(s2_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is False +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: FAIL (cannot import `is_sentinel3_olci_dataset`). + +- [ ] **Step 3: Implement the converter module with the detector** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_converter.py +"""Top-level Sentinel-3 OLCI L1 EFR -> GeoZarr conversion.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import structlog + +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + +if TYPE_CHECKING: + import zarr + +log = structlog.get_logger() + + +def is_sentinel3_olci_dataset(group: "zarr.Group") -> bool: + """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. + + Detection is structural: the group must validate against + ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the + first OLCI radiance band. + """ + from eopf_geozarr.pyz.v2 import GroupSpec + + try: + model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) + except ValueError as e: + log.debug("Not an OLCI dataset", error=str(e)) + return False + return "oa01_radiance" in model.measurements.members +``` + +- [ ] **Step 4: Run tests** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: PASS (positive detect + S2 rejected). + +- [ ] **Step 5: Type + lint** + +Run: `uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_converter.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py` +Expected: pyright 0; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py +git commit -m "feat(s3-olci): add OLCI product detection + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 5: GeoZarr metadata for a swath group + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` (extend) + +**Interfaces:** +- Consumes: `eopf_geozarr.conversion.utils.build_convention_attrs`, `zarr_cm` types. +- Produces: `swath_spatial_attrs(dims: tuple[str, str] = ("rows", "columns")) -> SpatialAttrs` — returns the `spatial:` convention data for curvilinear (no-transform) data: `spatial:dimensions = ["rows", "columns"]`, `spatial:registration = "pixel"`, and NO `spatial:transform`/`spatial:bbox` (geolocation lives in the 2-D lat/lon coordinate arrays, not an affine transform). + +This isolates the one genuinely OLCI-specific GeoZarr decision (open question in the spec) into a small, tested unit. `build_convention_attrs(spatial=..., crs=None)` is called with `crs=None` because OLCI L1 carries no projected CRS — geolocation is via coordinate arrays. Confirm `build_convention_attrs` accepts `crs=None` (it does: signature is `crs: CRSLike | None`). + +- [ ] **Step 1: Write the failing test** + +```python +# append to tests/test_olci_multiscale.py +from eopf_geozarr.s3_olci_optimization.olci_multiscale import swath_spatial_attrs + + +def test_swath_spatial_attrs_has_no_transform() -> None: + attrs = swath_spatial_attrs() + assert attrs["spatial:dimensions"] == ["rows", "columns"] + assert attrs["spatial:registration"] == "pixel" + assert "spatial:transform" not in attrs + assert "spatial:bbox" not in attrs +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py::test_swath_spatial_attrs_has_no_transform -v` +Expected: FAIL (cannot import `swath_spatial_attrs`). + +- [ ] **Step 3: Implement** + +```python +# add to src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from zarr_cm import SpatialAttrs + + +def swath_spatial_attrs( + dims: tuple[str, str] = SWATH_DIMS, +) -> "SpatialAttrs": + """Spatial-convention data for curvilinear swath geometry. + + OLCI has no affine transform; geolocation is carried by 2-D lat/lon + coordinate arrays, so we declare the spatial dimensions and pixel + registration but no ``spatial:transform``/``spatial:bbox``. + """ + return { + "spatial:dimensions": [dims[0], dims[1]], + "spatial:registration": "pixel", + } +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/` +Expected: PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): swath spatial-convention attrs (no transform) + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 6: `convert_olci_optimized` entry point + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` +- Test: `tests/test_olci_integration.py` + +**Interfaces:** +- Consumes: `decimate_swath`, `swath_spatial_attrs` (Tasks 3/5); `OLCI_BANDS` (Task 1); `build_convention_attrs`; `xarray`, `zarr`; storage/consolidation helpers from `conversion` (`fs_utils`, `geozarr`). +- Produces: + ```python + def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, + ) -> xr.DataTree: ... + ``` + Writes a GeoZarr store at `output_path`: the `measurements` group with native-resolution radiance + 2-D coords + GeoZarr convention metadata, plus `/2` decimated overview subgroups (`r1`, `r2`, `r4`, …) down to `min_dimension`; copies `conditions`/`quality` through unchanged. Returns the opened output DataTree. + +This is the orchestration task. Build it incrementally with a small synthetic OLCI DataTree (a helper in the test module, reused by Task 7). Keep the function focused; factor any growing helper (e.g. `_write_overviews`, `_copy_group`) into `olci_multiscale.py`. + +- [ ] **Step 1: Write the failing test (synthetic OLCI builder + end-to-end)** + +```python +# tests/test_olci_integration.py +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + + +def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: + """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" + rng = np.random.default_rng(0) + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + data = {} + for i in range(1, 22): + name = f"oa{i:02d}_radiance" + arr = xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + attrs={"scale_factor": 0.0139, "add_offset": 0.0, + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude"}, + ) + data[name] = arr + ds = xr.Dataset( + data, + coords={ + "latitude": (("rows", "columns"), lat, {"standard_name": "latitude"}), + "longitude": (("rows", "columns"), lon, {"standard_name": "longitude"}), + "altitude": (("rows", "columns"), alt, {"standard_name": "altitude"}), + }, + ) + return xr.DataTree.from_dict({"/measurements": ds}) + + +def test_convert_olci_writes_measurements(tmp_path) -> None: + dt = build_synthetic_olci() + out = str(tmp_path / "olci_geozarr.zarr") + convert_olci_optimized(dt, output_path=out) + + import zarr + g = zarr.open_group(out, mode="r") + # native measurements present + assert "measurements" in g + # all 21 bands at native res + meas = g["measurements"] + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in meas + + +def test_convert_olci_creates_overviews(tmp_path) -> None: + dt = build_synthetic_olci(rows=512, cols=480) + out = str(tmp_path / "olci_geozarr.zarr") + convert_olci_optimized(dt, output_path=out, min_dimension=256) + import zarr + g = zarr.open_group(out, mode="r") + # at least one decimated overview level exists under measurements + meas = g["measurements"] + subgroups = [k for k in meas.group_keys()] + assert len(subgroups) >= 1 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_integration.py -v` +Expected: FAIL (convert_olci_optimized not implemented / missing behavior). + +- [ ] **Step 3: Implement `convert_olci_optimized`** (incrementally; minimal to pass) + +Implementation outline (write real code — this is the skeleton to flesh out against the tests; mirror `s2_multiscale.create_multiscale_from_datatree` for writing groups, encoding, and `build_convention_attrs` usage): + +```python +# add to src/eopf_geozarr/s3_olci_optimization/olci_converter.py +import xarray as xr + +from eopf_geozarr.conversion.utils import build_convention_attrs +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + decimate_swath, + swath_spatial_attrs, +) + + +def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: + """Number of /2 decimations until min(rows, cols) would drop below min_dimension.""" + levels = 0 + r, c = rows, cols + while min(r, c) // 2 >= min_dimension: + r, c = r // 2, c // 2 + levels += 1 + return levels + + +def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, +) -> xr.DataTree: + """Convert an EOPF OLCI L1 EFR product to a GeoZarr multiscale store.""" + measurements = dt_input["/measurements"].to_dataset() + + # Attach GeoZarr convention metadata for native-resolution swath data. + conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + measurements.attrs.update(dict(conv)) + + # Write native resolution. + measurements.to_zarr( + output_path, group="measurements", mode="w", + consolidated=False, zarr_format=3, + ) + + # Write /2 decimated overviews as subgroups r2, r4, ... + rows = measurements.sizes["rows"] + cols = measurements.sizes["columns"] + current = measurements + for level in range(1, _overview_levels(rows, cols, min_dimension) + 1): + current = decimate_swath(current, factor=2) + current.to_zarr( + output_path, group=f"measurements/r{2 ** level}", mode="a", + consolidated=False, zarr_format=3, + ) + + # Copy conditions/quality through unchanged (if present). + for grp in ("conditions", "quality"): + try: + node = dt_input[f"/{grp}"] + except KeyError: + continue + node.to_zarr(output_path, group=grp, mode="a", consolidated=False, zarr_format=3) + + return xr.open_datatree(output_path, engine="zarr", chunks={}) +``` + +NOTE: this skeleton uses xarray's `to_zarr` for simplicity. If the project's +chunk-alignment / encoding helpers (`conversion.utils`, +`s2_multiscale` encoding handling) are needed to match GeoZarr output +conventions (chunking, sharding, scale-offset), adopt them here the way +`s2_multiscale` does. Keep `keep_scale_offset`/`enable_sharding`/`spatial_chunk`/ +`compression_level` honored (wire into encoding); if a parameter is not yet used +by the minimal pass, leave a typed parameter and a follow-up note rather than +silently ignoring — but prefer wiring encoding via the existing helpers. + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/ && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_integration.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_olci_integration.py +git commit -m "feat(s3-olci): add convert_olci_optimized entry point + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 7: CLI integration (auto-detect + `convert-s3-olci-optimized`) + +**Files:** +- Modify: `src/eopf_geozarr/cli.py` +- Modify: `src/eopf_geozarr/s2_optimization/s2_converter.py` (only if you choose the union-adapter detection approach; otherwise no change — Task 4's standalone detector is used) +- Test: `tests/test_olci_integration.py` (extend with a CLI test) + +**Interfaces:** +- Consumes: `convert_olci_optimized`, `is_sentinel3_olci_dataset` (Tasks 4/6); `_is_sentinel2_input` pattern in `cli.py`. +- Produces: CLI behavior — `convert` auto-routes OLCI products to `convert_olci_optimized`; new `convert-s3-olci-optimized` subcommand. + +In `convert_command`, add OLCI detection BEFORE the generic path and AFTER S2 (so the order is S2 → OLCI → S1/generic), mirroring the `if _is_sentinel2_input(dt):` block. Add `_is_sentinel3_olci_input(dt)` wrapping `is_sentinel3_olci_dataset(get_zarr_group(dt))` (guard exceptions, like `_is_sentinel2_input`). Add `add_s3_olci_optimization_commands(subparsers)` mirroring `add_s2_optimization_commands` and call it next to `add_s2_optimization_commands(subparsers)`. + +- [ ] **Step 1: Write the failing CLI test** + +```python +# append to tests/test_olci_integration.py +import subprocess +import sys + + +def test_cli_convert_s3_olci_optimized(tmp_path) -> None: + # materialize a synthetic OLCI product to a zarr v2 store on disk + dt = build_synthetic_olci(rows=300, cols=300) + src = tmp_path / "olci_src.zarr" + dt.to_zarr(src, mode="w", consolidated=False) + out = tmp_path / "olci_out.zarr" + result = subprocess.run( + [sys.executable, "-m", "eopf_geozarr", "convert-s3-olci-optimized", + str(src), str(out), "--spatial-chunk", "256"], + capture_output=True, text=True, timeout=300, + ) + assert result.returncode == 0, result.stdout + result.stderr + import zarr + g = zarr.open_group(str(out), mode="r") + assert "measurements" in g +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_integration.py::test_cli_convert_s3_olci_optimized -v` +Expected: FAIL (unknown subcommand). + +- [ ] **Step 3: Add the CLI subcommand + auto-detect** + +In `cli.py`, near the top imports add: +```python +from eopf_geozarr.s3_olci_optimization.olci_converter import ( + convert_olci_optimized, + is_sentinel3_olci_dataset, +) +``` + +Add the input helper (mirror `_is_sentinel2_input`): +```python +def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: + try: + return is_sentinel3_olci_dataset(get_zarr_group(dt)) + except Exception: # noqa: BLE001 - detection must never crash convert + return False +``` + +In `convert_command`, after the S2 block and before the generic/S1 path: +```python + if _is_sentinel3_olci_input(dt): + log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + dt_geozarr = convert_olci_optimized( + dt, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + ) + # (skip the generic path; mirror how the S2 block returns/continues) +``` +Match exactly how the S2 block hands off (return vs. fallthrough) in the current `convert_command`. + +Add the subcommand (mirror `add_s2_optimization_commands`): +```python +def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> None: + p = subparsers.add_parser( + "convert-s3-olci-optimized", + help="Convert a Sentinel-3 OLCI L1 EFR dataset to optimized GeoZarr", + ) + p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") + p.add_argument("output_path", type=str, help="Path for output optimized dataset") + p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") + p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") + p.add_argument("--compression-level", type=int, default=3, choices=range(1, 10), + help="Compression level 1-9 (default: 3)") + p.add_argument("--min-dimension", type=int, default=256, + help="Minimum overview dimension (default: 256)") + p.add_argument("--keep-scale-offset", action="store_true", + help="Preserve scale-offset encoding instead of decoding to float") + p.add_argument("--verbose", action="store_true", help="Enable verbose output") + p.set_defaults(func=convert_s3_olci_optimized_command) + + +def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: + storage_options = get_storage_options(str(args.input_path)) + dt_input = xr.open_datatree( + str(args.input_path), engine="zarr", chunks="auto", + storage_options=storage_options, + ) + convert_olci_optimized( + dt_input, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + compression_level=args.compression_level, + min_dimension=args.min_dimension, + keep_scale_offset=args.keep_scale_offset, + ) + log.info("✅ S3 OLCI optimization completed", output_path=args.output_path) +``` + +And register it next to the S2 registration: +```python + add_s2_optimization_commands(subparsers) + add_s3_olci_optimization_commands(subparsers) +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/cli.py && uv run ruff check src/eopf_geozarr/cli.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/cli.py tests/test_olci_integration.py +git commit -m "feat(s3-olci): CLI auto-detect + convert-s3-olci-optimized command + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 8: Real-product fixture + round-trip test + +**Files:** +- Create: `tests/_test_data/s3_examples/.json` +- Modify: `tests/conftest.py` +- Test: `tests/test_data_api/test_s3_olci.py` (extend with a real-product round-trip) + +**Interfaces:** +- Consumes: `create_group_from_json` (existing conftest helper); `is_sentinel3_olci_dataset`. +- Produces: `s3_example_json_paths` tuple + `s3_olci_group_example` fixture in conftest. + +**Generating the fixture** (run once, by the implementer, to create the committed JSON). The product is on the EODC EOPF store; use an `_NT_` product (the `_NR_` copies lack metadata). The store's `tenant:bucket` name breaks s3fs, but the consolidated `.zmetadata` is fetchable over HTTPS. Generate the structure dump with pydantic-zarr from the consolidated metadata. Reference product: +`https://objects.eodc.eu/e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu/01/products/cpm_v262/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.zarr` + +Write a one-off script `scripts/dump_olci_example.py` (NOT committed to src; can live under a scratch dir or `scripts/`) that builds a `pydantic_zarr.v2.GroupSpec` from the product's consolidated metadata and writes `model_dump_json(indent=2)` to the fixture path. If opening the remote store with xarray/zarr is blocked by the store's naming, build the `GroupSpec` dict directly from the fetched `.zmetadata` JSON (the `metadata` map contains every `.zgroup`/`.zarray`/`.zattrs`). The committed JSON must be a structure-only dump (chunks not required; shapes/dtypes/attrs are what matter), matching the form of `tests/_test_data/s2_examples/*.json`. + +Keep the fixture small if the full product is large: it is acceptable to truncate array shapes in the JSON (the model/detection tests only need structure), but document any truncation in a top-level attribute or a sibling README note. + +- [ ] **Step 1: Generate and commit the fixture JSON** + +Produce `tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_..._NT_004.json` via the one-off script. Verify it loads: +```bash +uv run python -c "import json,pathlib; json.loads(pathlib.Path('tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json').read_text()); print('ok')" +``` +Expected: `ok`. + +- [ ] **Step 2: Add conftest fixture** + +```python +# in tests/conftest.py, near the other *_example_json_paths +s3_example_json_paths = tuple(pathlib.Path("tests/_test_data/s3_examples").glob("*.json")) + + +@pytest.fixture(params=s3_example_json_paths, ids=get_stem) +def s3_olci_group_example( + request: pytest.FixtureRequest, tmp_path: pathlib.Path +) -> pathlib.Path: + """Path to a Zarr group with the layout of a Sentinel-3 OLCI product.""" + return create_group_from_json(request.param, tmp_path) +``` + +- [ ] **Step 3: Write the round-trip / detection test** + +```python +# append to tests/test_data_api/test_s3_olci.py +def test_real_olci_product_is_detected(s3_olci_group_example) -> None: + import zarr + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + group = zarr.open_group(str(s3_olci_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_real_olci_product_validates_model(s3_olci_group_example) -> None: + import zarr + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + + group = zarr.open_group(str(s3_olci_group_example), mode="r") + model = Sentinel3OlciRoot.model_validate(PyzGroupSpec.from_zarr(group).model_dump()) + assert "oa01_radiance" in model.measurements.members +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v && uv run --frozen pyright tests/conftest.py && uv run ruff check tests/conftest.py tests/test_data_api/test_s3_olci.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add tests/_test_data/s3_examples/ tests/conftest.py tests/test_data_api/test_s3_olci.py +git commit -m "test(s3-olci): real OLCI product fixture + round-trip detection + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 9: Golden-file snapshot of converted OLCI structure + +**Files:** +- Create: `tests/_test_data/optimized_olci_examples/.json` +- Test: `tests/test_olci_multiscale.py` (extend) or `tests/test_olci_integration.py` + +**Interfaces:** +- Consumes: `s3_olci_group_example` (Task 8); `convert_olci_optimized`; `pydantic_zarr.v3.GroupSpec`. +- Produces: a committed expected-structure snapshot + a test comparing converted output to it (mirrors `test_s2_multiscale.test_create_multiscale_from_datatree`). + +- [ ] **Step 1: Write the snapshot comparison test** + +```python +# append to tests/test_olci_integration.py +import json +from pathlib import Path + +import zarr +from pydantic_zarr.v3 import GroupSpec +from pydantic_zarr.core import tuplify_json + + +def test_olci_conversion_matches_snapshot(s3_olci_group_example, tmp_path) -> None: + import xarray as xr + + dt_in = xr.open_datatree(str(s3_olci_group_example), engine="zarr", chunks={}) + out = str(tmp_path / "out.zarr") + convert_olci_optimized(dt_in, output_path=out, min_dimension=256) + + observed = GroupSpec.from_zarr(zarr.open_group(out, use_consolidated=False)).model_dump() + expected_path = Path("tests/_test_data/optimized_olci_examples") / ( + Path(str(s3_olci_group_example)).stem + ".json" + ) + # To (re)generate the snapshot, uncomment: + # expected_path.parent.mkdir(parents=True, exist_ok=True) + # expected_path.write_text(json.dumps(observed, indent=2, sort_keys=True)) + expected = tuplify_json(json.loads(expected_path.read_text())) + observed_flat = GroupSpec(**tuplify_json(observed)).to_flat() + expected_flat = GroupSpec(**expected).to_flat() + assert set(observed_flat) == set(expected_flat) + assert [k for k in observed_flat if observed_flat[k] != expected_flat[k]] == [] +``` + +- [ ] **Step 2: Generate the snapshot** + +Temporarily uncomment the regeneration lines, run the test once to write the snapshot, re-comment, and verify it now passes: +```bash +uv run pytest tests/test_olci_integration.py::test_olci_conversion_matches_snapshot -v +``` +Expected: PASS after the snapshot is written. + +- [ ] **Step 3: Run tests + lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run ruff check tests/test_olci_integration.py` +Expected: PASS; ruff clean. + +- [ ] **Step 4: Commit** + +```bash +git add tests/_test_data/optimized_olci_examples/ tests/test_olci_integration.py +git commit -m "test(s3-olci): golden-file snapshot of converted OLCI structure + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 10: Full verification + docs + +**Files:** +- Modify: `README.md` and/or `docs/` (add OLCI to supported products + CLI usage). + +- [ ] **Step 1: Whole-suite type + lint + tests** + +Run: +```bash +uv run --frozen pyright +uv run ruff check src/ tests/ +uv run ruff format --check src/ tests/ +uv run pytest tests/ -p no:cacheprovider -q -m "not network" +``` +Expected: pyright 0 errors; ruff clean; tests green. + +- [ ] **Step 2: Document OLCI support** + +Add a short section to `README.md` (and/or `docs/converter.md`) noting Sentinel-3 OLCI L1 EFR support, the native-swath (no reprojection) behavior, and the `convert-s3-olci-optimized` command + auto-detection. + +- [ ] **Step 3: Commit** + +```bash +git add README.md docs/ +git commit -m "docs(s3-olci): document Sentinel-3 OLCI export support + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Notes / deferred (future specs) + +- GeoZarr-converting `conditions/geometry` (tie-point grid), `meteorology` (3-D + pressure_level), `instrument` (per-band/detector) — copied through unmodified in v1. +- Reprojection-to-regular-grid option (lossy) — explicitly out of scope. +- SLSTR / SRAL / SYNERGY product types — separate specs. +- If GeoZarr's spatial/proj convention for curvilinear (2-D-coordinate) data needs a specific representation beyond `spatial:dimensions` + coordinate arrays, refine `swath_spatial_attrs` (Task 5) and regenerate the Task 9 snapshot. From c613e2463c773d921917962bdf2eb57ea1f74a2c Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Sun, 21 Jun 2026 22:56:14 +0200 Subject: [PATCH 03/58] chore: regenerate uv.lock for released zarr-cm 0.4.1 pyproject already pins zarr-cm>=0.4.1; update the lockfile from the git-main dev build to the released 0.4.1. Co-Authored-By: Claude Opus 4.8 --- uv.lock | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/uv.lock b/uv.lock index 88d9e183..5f2a9bd9 100644 --- a/uv.lock +++ b/uv.lock @@ -854,7 +854,7 @@ requires-dist = [ { name = "typing-extensions", specifier = ">=4.15.0" }, { name = "xarray", specifier = ">=2025.7.1" }, { name = "zarr", extras = ["cast-value-rs"], specifier = ">=3.2.0" }, - { name = "zarr-cm", git = "https://github.com/zarr-conventions/zarr-cm.git?rev=main" }, + { name = "zarr-cm", specifier = ">=0.4.1" }, ] [package.metadata.requires-dev] @@ -3026,11 +3026,15 @@ cast-value-rs = [ [[package]] name = "zarr-cm" -version = "0.4.1.dev13+ge94a3ee8d" -source = { git = "https://github.com/zarr-conventions/zarr-cm.git?rev=main#e94a3ee8db52689883753f5b928f8331c3d01b15" } +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/f9/c6/51d38cafa07bdf725c77a67719647eea43255f925fda062b40799bbb361d/zarr_cm-0.4.1.tar.gz", hash = "sha256:693d24ca2b8e3a7230e1ed448c2c57f98833b81e5899607b6cb4a7ac31f94002", size = 50839, upload-time = "2026-06-21T19:20:36.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/14/3de8976647909b2f6764b8d0c9add0a961667ef4ab46f3f99e12d7a522fa/zarr_cm-0.4.1-py3-none-any.whl", hash = "sha256:2c7f36383af2e6f75eb274a797a13154fd5c5827390de7c79294dfeb9f0543ee", size = 33005, upload-time = "2026-06-21T19:20:35.05Z" }, +] [[package]] name = "zict" From c49ab06d82defc53257e33c3d337d5e9763216ca Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 07:07:16 +0200 Subject: [PATCH 04/58] feat(s3-olci): add OLCI band mapping Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/__init__.py | 1 + .../s3_olci_optimization/olci_band_mapping.py | 51 +++++++++++++++++++ tests/test_olci_band_mapping.py | 25 +++++++++ 3 files changed, 77 insertions(+) create mode 100644 src/eopf_geozarr/s3_olci_optimization/__init__.py create mode 100644 src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py create mode 100644 tests/test_olci_band_mapping.py diff --git a/src/eopf_geozarr/s3_olci_optimization/__init__.py b/src/eopf_geozarr/s3_olci_optimization/__init__.py new file mode 100644 index 00000000..6850218b --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/__init__.py @@ -0,0 +1 @@ +"""Sentinel-3 OLCI L1 EFR optimization (GeoZarr export).""" diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py b/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py new file mode 100644 index 00000000..db0cc35e --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py @@ -0,0 +1,51 @@ +"""Band definitions for Sentinel-3 OLCI L1 EFR. + +OLCI has 21 radiance bands (Oa01..Oa21), all delivered at the same full +resolution (~300 m) on a single swath grid. +""" + +from dataclasses import dataclass + +RADIANCE_DTYPE = "uint16" + +# Band index -> central wavelength in nm (OLCI Oa01..Oa21). +_WAVELENGTHS_NM: tuple[float, ...] = ( + 400.0, + 412.5, + 442.5, + 490.0, + 510.0, + 560.0, + 620.0, + 665.0, + 673.75, + 681.25, + 708.75, + 753.75, + 761.25, + 764.375, + 767.5, + 778.75, + 865.0, + 885.0, + 900.0, + 940.0, + 1020.0, +) + +OLCI_BANDS: tuple[str, ...] = tuple(f"oa{i:02d}_radiance" for i in range(1, 22)) + + +@dataclass(frozen=True) +class OlciBandInfo: + """Spectral characterization of a single OLCI radiance band.""" + + name: str + data_type: str + wavelength_center: float # nanometers + + +OLCI_BAND_INFO: dict[str, OlciBandInfo] = { + name: OlciBandInfo(name=name, data_type=RADIANCE_DTYPE, wavelength_center=wl) + for name, wl in zip(OLCI_BANDS, _WAVELENGTHS_NM, strict=True) +} diff --git a/tests/test_olci_band_mapping.py b/tests/test_olci_band_mapping.py new file mode 100644 index 00000000..8fca56c7 --- /dev/null +++ b/tests/test_olci_band_mapping.py @@ -0,0 +1,25 @@ +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( + OLCI_BAND_INFO, + OLCI_BANDS, + RADIANCE_DTYPE, + OlciBandInfo, +) + + +def test_there_are_21_olci_bands() -> None: + assert len(OLCI_BANDS) == 21 + assert OLCI_BANDS[0] == "oa01_radiance" + assert OLCI_BANDS[-1] == "oa21_radiance" + + +def test_every_band_has_info() -> None: + assert set(OLCI_BAND_INFO) == set(OLCI_BANDS) + for name, info in OLCI_BAND_INFO.items(): + assert isinstance(info, OlciBandInfo) + assert info.name == name + assert info.data_type == RADIANCE_DTYPE + assert info.wavelength_center > 0 + + +def test_first_band_wavelength() -> None: + assert OLCI_BAND_INFO["oa01_radiance"].wavelength_center == 400.0 From cbe586f1c2f1ce0d062e560c0a349fd9658784a8 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 07:13:38 +0200 Subject: [PATCH 05/58] feat(s3-olci): add Sentinel3OlciRoot data-api model Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/data_api/s3_olci.py | 81 ++++++++++++++++++++++++++++ tests/test_data_api/test_s3_olci.py | 60 +++++++++++++++++++++ 2 files changed, 141 insertions(+) create mode 100644 src/eopf_geozarr/data_api/s3_olci.py create mode 100644 tests/test_data_api/test_s3_olci.py diff --git a/src/eopf_geozarr/data_api/s3_olci.py b/src/eopf_geozarr/data_api/s3_olci.py new file mode 100644 index 00000000..69cf6d56 --- /dev/null +++ b/src/eopf_geozarr/data_api/s3_olci.py @@ -0,0 +1,81 @@ +"""Pydantic-zarr model for the Sentinel-3 OLCI L1 EFR EOPF Zarr structure. + +Mirrors data_api/s2.py: GroupSpec + closed TypedDict members. Used for +structural product detection (an EOPF product is OLCI iff it validates here). +""" + +from __future__ import annotations + +from typing import Any + +from pydantic import BaseModel +from typing_extensions import TypedDict + +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +class Sentinel3OlciRootAttrs(BaseModel): + """Root-level attributes for an OLCI DataTree (not validated in detail).""" + + other_metadata: dict[str, object] + stac_discovery: dict[str, object] + + +class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): + """Members of the OLCI measurements group. + + The 21 radiance bands and the per-pixel geolocation coordinate arrays are + required in practice but typed optional so partial/variant products still + validate; the converter checks for the bands it needs. + """ + + latitude: ArraySpec[object] + longitude: ArraySpec[object] + altitude: ArraySpec[object] + orphans: GroupSpec[Any, Any] + oa01_radiance: ArraySpec[object] + oa02_radiance: ArraySpec[object] + oa03_radiance: ArraySpec[object] + oa04_radiance: ArraySpec[object] + oa05_radiance: ArraySpec[object] + oa06_radiance: ArraySpec[object] + oa07_radiance: ArraySpec[object] + oa08_radiance: ArraySpec[object] + oa09_radiance: ArraySpec[object] + oa10_radiance: ArraySpec[object] + oa11_radiance: ArraySpec[object] + oa12_radiance: ArraySpec[object] + oa13_radiance: ArraySpec[object] + oa14_radiance: ArraySpec[object] + oa15_radiance: ArraySpec[object] + oa16_radiance: ArraySpec[object] + oa17_radiance: ArraySpec[object] + oa18_radiance: ArraySpec[object] + oa19_radiance: ArraySpec[object] + oa20_radiance: ArraySpec[object] + oa21_radiance: ArraySpec[object] + + +class Sentinel3OlciMeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers]): + """OLCI measurements group: 21 radiance bands + 2-D geolocation.""" + + +class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): + """Members of the OLCI root group.""" + + measurements: Sentinel3OlciMeasurementsGroup + quality: GroupSpec[Any, Any] + conditions: GroupSpec[Any, Any] + + +class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): + """Complete Sentinel-3 OLCI L1 EFR EOPF Zarr hierarchy.""" + + @property + def measurements(self) -> Sentinel3OlciMeasurementsGroup: + """Get the measurements group.""" + group = self.members.get("measurements") + if group is None: + raise KeyError("measurements") + return group diff --git a/tests/test_data_api/test_s3_olci.py b/tests/test_data_api/test_s3_olci.py new file mode 100644 index 00000000..067768bf --- /dev/null +++ b/tests/test_data_api/test_s3_olci.py @@ -0,0 +1,60 @@ +"""Tests for the Sentinel-3 OLCI data-api model.""" + +import pytest +from pydantic import ValidationError + +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec # noqa: F401 + + +def _olci_arr() -> dict[str, object]: + """Return a minimal v2 ArraySpec-shaped dict for a 2-D uint16 array.""" + return ArraySpec( + shape=(4, 5), + chunks=(4, 5), + dtype=" None: + """A dict with 21 radiance bands + geolocation validates as Sentinel3OlciRoot.""" + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": {**radiance, **coords}, + }, + }, + } + model = Sentinel3OlciRoot.model_validate(root) + assert "oa01_radiance" in model.measurements.members + + +def test_rejects_non_olci_product() -> None: + """A dict with an unexpected key in measurements is rejected by closed=True.""" + not_olci = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": { + "reflectance": { + "zarr_format": 2, + "attributes": {}, + "members": {}, + } + }, + } + }, + } + with pytest.raises(ValidationError): + Sentinel3OlciRoot.model_validate(not_olci) From 8debe8d825dad0b33cc61a60e730f3974418d9e6 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 07:17:14 +0200 Subject: [PATCH 06/58] fix(s3-olci): remove Any from data-api model (use precise opaque-group type) Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/data_api/s3_olci.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/eopf_geozarr/data_api/s3_olci.py b/src/eopf_geozarr/data_api/s3_olci.py index 69cf6d56..616a7454 100644 --- a/src/eopf_geozarr/data_api/s3_olci.py +++ b/src/eopf_geozarr/data_api/s3_olci.py @@ -6,7 +6,7 @@ from __future__ import annotations -from typing import Any +from collections.abc import Mapping # noqa: TC003 from pydantic import BaseModel from typing_extensions import TypedDict @@ -33,7 +33,7 @@ class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): latitude: ArraySpec[object] longitude: ArraySpec[object] altitude: ArraySpec[object] - orphans: GroupSpec[Any, Any] + orphans: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] oa01_radiance: ArraySpec[object] oa02_radiance: ArraySpec[object] oa03_radiance: ArraySpec[object] @@ -65,8 +65,8 @@ class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): """Members of the OLCI root group.""" measurements: Sentinel3OlciMeasurementsGroup - quality: GroupSpec[Any, Any] - conditions: GroupSpec[Any, Any] + quality: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] + conditions: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): From 5874f26deeb4f59b10d7b5e0a958080354ad1305 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 07:22:41 +0200 Subject: [PATCH 07/58] feat(s3-olci): add swath /2 decimation for overviews Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_multiscale.py | 31 +++++++++++++ tests/test_olci_multiscale.py | 46 +++++++++++++++++++ 2 files changed, 77 insertions(+) create mode 100644 src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py create mode 100644 tests/test_olci_multiscale.py diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py new file mode 100644 index 00000000..4c766456 --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -0,0 +1,31 @@ +"""Multiscale (overview) generation for OLCI swath data. + +OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays, +so overviews are produced by /2 decimation of the (rows, columns) grid: every +2-D variable and its 2-D coordinate arrays are subsampled together, keeping +geolocation exact. (Averaging is intentionally avoided — an averaged lat/lon +would not correspond to a real pixel.) +""" + +from __future__ import annotations + +import xarray as xr # noqa: TC002 + +SWATH_DIMS = ("rows", "columns") + + +def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with every (rows, columns) array subsampled by *factor*. + + Both data variables and coordinate variables that span exactly the swath + dims are decimated `[::factor, ::factor]`; everything else is passed + through unchanged. Attributes and encoding are preserved by xarray's isel. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + indexers = {dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes} + if not indexers: + return ds + return ds.isel(indexers) diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py new file mode 100644 index 00000000..3d7c58cb --- /dev/null +++ b/tests/test_olci_multiscale.py @@ -0,0 +1,46 @@ +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath + + +def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={"scale_factor": 0.5, "units": "mW.m-2.sr-1.nm-1"}, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +def test_decimate_halves_each_axis() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_decimate_takes_every_other_pixel() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + # top-left pixel is preserved exactly (no averaging) + assert int(out["oa01_radiance"].values[0, 0]) == 0 + assert float(out["latitude"].values[0, 0]) == 0.0 + + +def test_decimate_preserves_attrs() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" From 01abf3118efb57ae02d68a7ff8e92fe270045087 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 07:26:05 +0200 Subject: [PATCH 08/58] fix(s3-olci): move xarray import to TYPE_CHECKING; strengthen decimation test Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py | 5 ++++- tests/test_olci_multiscale.py | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 4c766456..c16af00d 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -9,7 +9,10 @@ from __future__ import annotations -import xarray as xr # noqa: TC002 +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + import xarray as xr SWATH_DIMS = ("rows", "columns") diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 3d7c58cb..2dd3db2e 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -34,10 +34,13 @@ def test_decimate_halves_each_axis() -> None: def test_decimate_takes_every_other_pixel() -> None: - out = decimate_swath(_swath(8, 6), factor=2) + ds = _swath(8, 6) + out = decimate_swath(ds, factor=2) # top-left pixel is preserved exactly (no averaging) assert int(out["oa01_radiance"].values[0, 0]) == 0 assert float(out["latitude"].values[0, 0]) == 0.0 + # interior pixel: stride-2 decimation means out[1, 1] comes from original [2, 2] + assert int(out["oa01_radiance"].values[1, 1]) == int(ds["oa01_radiance"].values[2, 2]) def test_decimate_preserves_attrs() -> None: From f7998de9606e390a208278fce96da7a9d0910b6e Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 08:21:18 +0200 Subject: [PATCH 09/58] feat(s3-olci): add OLCI product detection Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_converter.py | 34 ++++++++++++++ tests/test_data_api/test_s3_olci.py | 44 +++++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 src/eopf_geozarr/s3_olci_optimization/olci_converter.py diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py new file mode 100644 index 00000000..0596f502 --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -0,0 +1,34 @@ +"""Top-level Sentinel-3 OLCI L1 EFR -> GeoZarr conversion.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import structlog + +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + +if TYPE_CHECKING: + import zarr + +log = structlog.get_logger() + + +def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: + """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. + + Detection is structural: the group must validate against + ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the + first OLCI radiance band. + """ + from eopf_geozarr.pyz.v2 import GroupSpec + + try: + model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) + except ValueError as e: + log.debug("Not an OLCI dataset", error=str(e)) + return False + try: + return "oa01_radiance" in model.measurements.members + except KeyError: + return False diff --git a/tests/test_data_api/test_s3_olci.py b/tests/test_data_api/test_s3_olci.py index 067768bf..ce32ca96 100644 --- a/tests/test_data_api/test_s3_olci.py +++ b/tests/test_data_api/test_s3_olci.py @@ -58,3 +58,47 @@ def test_rejects_non_olci_product() -> None: } with pytest.raises(ValidationError): Sentinel3OlciRoot.model_validate(not_olci) + + +def test_detector_accepts_olci_zarr(tmp_path: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + # build a minimal OLCI zarr v2 store from the model dict used above + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root_dict = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": {**radiance, **coords}, + } + }, + } + assert isinstance(tmp_path, pathlib.Path) + out = tmp_path / "olci.zarr" + Sentinel3OlciRoot.model_validate(root_dict).to_zarr(out, path="") # type: ignore[arg-type] + group = zarr.open_group(str(out), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_detector_rejects_s2_zarr(s2_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + assert isinstance(s2_group_example, pathlib.Path) + group = zarr.open_group(str(s2_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is False From c05a0608de5a646270a0c691433ceb3bffba6311 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 08:36:54 +0200 Subject: [PATCH 10/58] feat(s3-olci): swath spatial-convention attrs (no transform) Add swath_spatial_attrs() function to return GeoZarr spatial: convention data for curvilinear swath geometry with pixel registration but no affine transform or bbox (geolocation carried by 2-D lat/lon arrays). Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_multiscale.py | 16 ++++++++++++++++ tests/test_olci_multiscale.py | 13 ++++++++++++- 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index c16af00d..b61641e0 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -13,6 +13,7 @@ if TYPE_CHECKING: import xarray as xr + from zarr_cm import SpatialAttrs SWATH_DIMS = ("rows", "columns") @@ -32,3 +33,18 @@ def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: if not indexers: return ds return ds.isel(indexers) + + +def swath_spatial_attrs( + dims: tuple[str, str] = SWATH_DIMS, +) -> SpatialAttrs: + """Spatial-convention data for curvilinear swath geometry. + + OLCI has no affine transform; geolocation is carried by 2-D lat/lon + coordinate arrays, so we declare the spatial dimensions and pixel + registration but no ``spatial:transform``/``spatial:bbox``. + """ + return { + "spatial:dimensions": [dims[0], dims[1]], + "spatial:registration": "pixel", + } diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 2dd3db2e..e1480a2e 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -1,7 +1,10 @@ import numpy as np import xarray as xr -from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + decimate_swath, + swath_spatial_attrs, +) def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: @@ -47,3 +50,11 @@ def test_decimate_preserves_attrs() -> None: out = decimate_swath(_swath(8, 6), factor=2) assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 assert out["latitude"].attrs["standard_name"] == "latitude" + + +def test_swath_spatial_attrs_has_no_transform() -> None: + attrs = swath_spatial_attrs() + assert attrs["spatial:dimensions"] == ["rows", "columns"] + assert attrs.get("spatial:registration") == "pixel" + assert "spatial:transform" not in attrs + assert "spatial:bbox" not in attrs From 67e86d41c13b8c17a5865e44b218f4a6558bced1 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 09:21:24 +0200 Subject: [PATCH 11/58] feat(s3-olci): add convert_olci_optimized entry point Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_converter.py | 179 +++++++++++++++++- tests/test_olci_integration.py | 136 +++++++++++++ 2 files changed, 310 insertions(+), 5 deletions(-) create mode 100644 tests/test_olci_integration.py diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 0596f502..08f3e94e 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -2,14 +2,13 @@ from __future__ import annotations -from typing import TYPE_CHECKING - import structlog +import xarray as xr +import zarr +from eopf_geozarr.conversion.utils import build_convention_attrs from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot - -if TYPE_CHECKING: - import zarr +from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath, swath_spatial_attrs log = structlog.get_logger() @@ -32,3 +31,173 @@ def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: return "oa01_radiance" in model.measurements.members except KeyError: return False + + +def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: + """Return the number of /2 decimations before min(rows, cols) drops below min_dimension. + + A level is generated as long as the *current* minimum spatial dimension is + at least *min_dimension*. That is, the check is on the pre-decimation size + so that a 512x480 dataset with min_dimension=256 yields one level + (256x240), while a 256x240 dataset would yield zero. + """ + levels = 0 + r, c = rows, cols + while min(r, c) >= min_dimension: + r, c = r // 2, c // 2 + levels += 1 + return levels + + +def _copy_subtree(node: xr.DataTree, output_path: str, *, root_group: str) -> None: + """Write every Dataset in *node*'s subtree to the Zarr store at *output_path*. + + Each path is mapped relative to the node's own path: the node root becomes + *root_group*, and child nodes are placed at ``root_group/``. + + ``DataTree.to_zarr`` does not yet support a ``group`` keyword for + specifying a root offset, so we write each leaf's :py:meth:`~xarray.DataTree.to_dataset` + using ``xr.Dataset.to_zarr`` instead. + """ + node_path = node.path # e.g. "/conditions" + for child in node.subtree: + ds = child.to_dataset() + if not ds.data_vars and not ds.coords: + continue + # Build the group path: strip the ancestor prefix and prepend root_group. + relative = child.path[len(node_path) :] # "" for root, "/sub" for children + group_path = root_group + relative + log.info("Copying ancillary subgroup", group=group_path) + ds.to_zarr( + output_path, + group=group_path, + mode="a", + consolidated=False, + zarr_format=3, + ) + + +def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, +) -> xr.DataTree: + """Convert an EOPF OLCI L1 EFR DataTree to a GeoZarr multiscale store. + + Writes the native-resolution ``measurements`` group with GeoZarr + convention metadata, then writes /2-decimated overview subgroups + (``r2``, ``r4``, …) down to *min_dimension*. Any ``conditions`` or + ``quality`` groups present in *dt_input* are copied through unchanged. + + Parameters + ---------- + dt_input: + Input OLCI L1 EFR DataTree (must contain a ``/measurements`` node). + output_path: + Filesystem path for the output Zarr v3 store. + enable_sharding: + Enable Zarr v3 sharding on measurement arrays. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + spatial_chunk: + Target spatial chunk size (pixels per side). + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + compression_level: + Blosc/zstd compression level. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + min_dimension: + Stop generating overview levels once either spatial dimension would + drop below this value after /2 decimation. + keep_scale_offset: + When ``True``, preserve CF ``scale_factor``/``add_offset`` in the + output encoding rather than decoding to float32. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + + Returns + ------- + xr.DataTree + The opened output DataTree (lazy; backed by the written Zarr store). + + Notes + ----- + Parameters ``enable_sharding``, ``spatial_chunk``, ``compression_level``, + and ``keep_scale_offset`` are accepted but not yet applied to the on-disk + encoding. Wiring them through the existing ``conversion`` helpers + (``create_measurements_encoding``, sharding codec, etc.) is left for a + follow-up task so as not to block the integration test. + """ + measurements = dt_input["/measurements"].to_dataset() + + # Attach GeoZarr spatial convention metadata for native-resolution swath. + conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + measurements.attrs.update(dict(conv)) + + log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) + measurements.to_zarr( + output_path, + group="measurements", + mode="w", + consolidated=False, + zarr_format=3, + ) + + # Write /2 decimated overview subgroups: r2, r4, r8, … + rows = measurements.sizes["rows"] + cols = measurements.sizes["columns"] + n_levels = _overview_levels(rows, cols, min_dimension) + log.info("Generating overview levels", n_levels=n_levels) + + current = measurements + for level in range(1, n_levels + 1): + current = decimate_swath(current, factor=2) + group_name = f"r{2**level}" + log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) + current.to_zarr( + output_path, + group=f"measurements/{group_name}", + mode="a", + consolidated=False, + zarr_format=3, + ) + + # Copy conditions/quality through unchanged (if present). + # DataTree.to_zarr does not support a root ``group`` argument, so we + # iterate the subtree and write each leaf Dataset individually. + for grp in ("conditions", "quality"): + try: + node_item = dt_input[f"/{grp}"] + except KeyError: + continue + if not isinstance(node_item, xr.DataTree): + continue + log.info("Copying ancillary group", group=grp) + _copy_subtree(node_item, output_path, root_group=grp) + + # xarray DataTree enforces dimension consistency between parent and child + # nodes, so opening the whole store via ``xr.open_datatree`` would fail + # because the overview subgroups have smaller spatial dimensions than + # the parent ``measurements`` group. Instead, we build the DataTree + # manually from the top-level groups only: overview levels (r2, r4, …) + # are in the zarr store and accessible via ``zarr.open_group``, but are + # intentionally not exposed as DataTree children. + root = zarr.open_group(output_path, mode="r") + tree_dict: dict[str, xr.Dataset] = {} + for key in root.group_keys(): + child = root[key] + if isinstance(child, zarr.Group) and list(child.array_keys()): + tree_dict[f"/{key}"] = xr.open_dataset( + output_path, + engine="zarr", + group=key, + chunks={}, + consolidated=False, + ) + return xr.DataTree.from_dict(tree_dict) diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py new file mode 100644 index 00000000..ec9bbf1a --- /dev/null +++ b/tests/test_olci_integration.py @@ -0,0 +1,136 @@ +"""Integration tests for convert_olci_optimized.""" + +from __future__ import annotations + +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + + +def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: + """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" + rng = np.random.default_rng(0) + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + data: dict[str, xr.DataArray] = {} + for i in range(1, 22): + name = f"oa{i:02d}_radiance" + arr = xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + attrs={ + "scale_factor": 0.0139, + "add_offset": 0.0, + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude", + }, + ) + data[name] = arr + ds = xr.Dataset( + data, + coords={ + "latitude": (("rows", "columns"), lat, {"standard_name": "latitude"}), + "longitude": (("rows", "columns"), lon, {"standard_name": "longitude"}), + "altitude": (("rows", "columns"), alt, {"standard_name": "altitude"}), + }, + ) + return xr.DataTree.from_dict({"/measurements": ds}) + + +def test_convert_olci_writes_measurements(tmp_path: object) -> None: + """Native-resolution measurements group must contain all 21 radiance bands.""" + import zarr + + dt = build_synthetic_olci() + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out) + + g = zarr.open_group(out, mode="r") + # native measurements present + assert "measurements" in g + # all 21 bands at native res + meas = g["measurements"] + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in meas + + +def test_convert_olci_creates_overviews(tmp_path: object) -> None: + """At least one /2-decimated overview subgroup must be written under measurements.""" + import zarr + + dt = build_synthetic_olci(rows=512, cols=480) + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out, min_dimension=256) + + g = zarr.open_group(out, mode="r") + # at least one decimated overview level exists under measurements + meas_item = g["measurements"] + assert isinstance(meas_item, zarr.Group) + subgroups = list(meas_item.group_keys()) + assert len(subgroups) >= 1 + + +def test_convert_olci_returns_datatree(tmp_path: object) -> None: + """convert_olci_optimized must return an xr.DataTree backed by the output store.""" + dt = build_synthetic_olci(rows=256, cols=256) + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + result = convert_olci_optimized(dt, output_path=out, min_dimension=256) + assert isinstance(result, xr.DataTree) + assert "/measurements" in result.groups + + +def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: + """conditions and quality groups, when present, are copied through unchanged.""" + import zarr + + # Build a tree with conditions and quality groups + rng = np.random.default_rng(1) + rows, cols = 128, 128 + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + + meas_data: dict[str, xr.DataArray] = { + "oa01_radiance": xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + ) + } + meas_ds = xr.Dataset( + meas_data, + coords={ + "latitude": (("rows", "columns"), lat), + "longitude": (("rows", "columns"), lon), + "altitude": (("rows", "columns"), alt), + }, + ) + cond_ds = xr.Dataset( + { + "wind_speed": xr.DataArray( + rng.random((rows, cols)).astype("float32"), dims=("rows", "columns") + ) + } + ) + quality_ds = xr.Dataset( + { + "flags": xr.DataArray( + rng.integers(0, 255, (rows, cols)).astype("uint8"), dims=("rows", "columns") + ) + } + ) + dt = xr.DataTree.from_dict( + { + "/measurements": meas_ds, + "/conditions": cond_ds, + "/quality": quality_ds, + } + ) + + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out, min_dimension=64) + + g = zarr.open_group(out, mode="r") + assert "conditions" in g + assert "quality" in g From 26edc80ce359f0b7a254bfca2fd0f6b652ba6e43 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 09:29:44 +0200 Subject: [PATCH 12/58] fix(s3-olci): correct overview min_dimension guard; document returned DataTree omits overviews Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_converter.py | 18 +++-- tests/test_olci_integration.py | 68 ++++++++++++++++--- 2 files changed, 71 insertions(+), 15 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 08f3e94e..4959d0a8 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -36,14 +36,15 @@ def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: """Return the number of /2 decimations before min(rows, cols) drops below min_dimension. - A level is generated as long as the *current* minimum spatial dimension is - at least *min_dimension*. That is, the check is on the pre-decimation size - so that a 512x480 dataset with min_dimension=256 yields one level - (256x240), while a 256x240 dataset would yield zero. + A level is generated only when the *post*-decimation minimum spatial + dimension is at least *min_dimension*. For example, a 512x480 dataset + with min_dimension=256 yields zero levels because 480//2=240 < 256, while + a 1024x1024 dataset with min_dimension=256 yields two levels (512x512, + then 256x256). """ levels = 0 r, c = rows, cols - while min(r, c) >= min_dimension: + while min(r, c) // 2 >= min_dimension: r, c = r // 2, c // 2 levels += 1 return levels @@ -125,6 +126,13 @@ def convert_olci_optimized( ------- xr.DataTree The opened output DataTree (lazy; backed by the written Zarr store). + Overview subgroups (``r2``, ``r4``, …) are written to the Zarr store + but are **not** represented as children of the returned DataTree, + because xarray enforces dimension consistency between parent and child + nodes and the overview subgroups have smaller spatial dimensions than + the parent ``measurements`` group. To read them, open the store + directly with ``zarr.open_group(output_path)["measurements"]["r2"]`` + etc. Notes ----- diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index ec9bbf1a..50e844ed 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -57,19 +57,67 @@ def test_convert_olci_writes_measurements(tmp_path: object) -> None: def test_convert_olci_creates_overviews(tmp_path: object) -> None: - """At least one /2-decimated overview subgroup must be written under measurements.""" + """Overview subgroups must only be written when BOTH post-decimation dims >= min_dimension. + + Case 1 — 512x480 with min_dimension=256: + 480//2 = 240 < 256, so the guard fires immediately → zero overview levels. + + Case 2 — 1024x1024 with min_dimension=256: + 1024//2=512>=256 → level r2 (512x512) + 512//2=256>=256 → level r4 (256x256) + 256//2=128<256 → stop + Exactly two levels; smallest must be exactly 256x256. + """ import zarr - dt = build_synthetic_olci(rows=512, cols=480) - out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] - convert_olci_optimized(dt, output_path=out, min_dimension=256) + # --- Case 1: 512x480, min_dimension=256 → zero overview levels --- + dt1 = build_synthetic_olci(rows=512, cols=480) + out1 = str(tmp_path / "olci_case1.zarr") # type: ignore[operator] + convert_olci_optimized(dt1, output_path=out1, min_dimension=256) + + g1 = zarr.open_group(out1, mode="r") + meas1 = g1["measurements"] + assert isinstance(meas1, zarr.Group) + subgroups1 = list(meas1.group_keys()) + assert len(subgroups1) == 0, ( + f"Expected 0 overview levels for 512x480 at min_dimension=256, got {subgroups1}" + ) - g = zarr.open_group(out, mode="r") - # at least one decimated overview level exists under measurements - meas_item = g["measurements"] - assert isinstance(meas_item, zarr.Group) - subgroups = list(meas_item.group_keys()) - assert len(subgroups) >= 1 + # --- Case 2: 1024x1024, min_dimension=256 → exactly two valid levels --- + dt2 = build_synthetic_olci(rows=1024, cols=1024) + out2 = str(tmp_path / "olci_case2.zarr") # type: ignore[operator] + convert_olci_optimized(dt2, output_path=out2, min_dimension=256) + + g2 = zarr.open_group(out2, mode="r") + meas2 = g2["measurements"] + assert isinstance(meas2, zarr.Group) + subgroups2 = sorted(meas2.group_keys()) + assert len(subgroups2) == 2, ( + f"Expected exactly 2 overview levels for 1024x1024 at min_dimension=256, got {subgroups2}" + ) + + # Every overview level must have BOTH spatial dims >= min_dimension. + for sg_name in subgroups2: + sg = meas2[sg_name] + assert isinstance(sg, zarr.Group) + band = sg["oa01_radiance"] + assert isinstance(band, zarr.Array) + # shape is (rows, columns) + overview_rows, overview_cols = band.shape[0], band.shape[1] + assert overview_rows >= 256, f"measurements/{sg_name} rows={overview_rows} < 256" + assert overview_cols >= 256, f"measurements/{sg_name} cols={overview_cols} < 256" + + # The deepest level (r4 for 1024-input) must be exactly 256x256. + deepest = meas2[subgroups2[-1]] + assert isinstance(deepest, zarr.Group) + deepest_band = deepest["oa01_radiance"] + assert isinstance(deepest_band, zarr.Array) + assert deepest_band.shape[0] == 256, ( + f"Expected smallest overview rows=256, got {deepest_band.shape}" + ) + assert deepest_band.shape[1] == 256, ( + f"Expected smallest overview cols=256, got {deepest_band.shape}" + ) def test_convert_olci_returns_datatree(tmp_path: object) -> None: From b67275937ce0d05869919fc11b0b844863b5c8a3 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 09:34:39 +0200 Subject: [PATCH 13/58] feat(s3-olci): CLI auto-detect + convert-s3-olci-optimized command Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/cli.py | 77 ++++++++++++++++++++++++++++++++++ tests/test_olci_integration.py | 36 ++++++++++++++++ 2 files changed, 113 insertions(+) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 805c9237..52c4b3e6 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -15,6 +15,10 @@ import xarray as xr from eopf_geozarr.s2_optimization.s2_converter import convert_s2_optimized, is_sentinel2_dataset +from eopf_geozarr.s3_olci_optimization.olci_converter import ( + convert_olci_optimized, + is_sentinel3_olci_dataset, +) from . import create_geozarr_dataset from .conversion.fs_utils import ( @@ -100,6 +104,20 @@ def _is_sentinel2_input(dt: xr.DataTree) -> bool: return False +def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: + """Best-effort Sentinel-3 OLCI detection that never breaks the generic path. + + ``is_sentinel3_olci_dataset`` validates structurally against a Zarr v2 model + and can raise on unrelated inputs; any failure simply means "not a recognised + OLCI product", so fall back to the generic converter. + """ + try: + return is_sentinel3_olci_dataset(get_zarr_group(dt)) + except Exception as exc: + log.debug("Sentinel-3 OLCI detection skipped", error=str(exc)) + return False + + def convert_command(args: argparse.Namespace) -> None: """ Convert EOPF dataset to GeoZarr compliant format. @@ -203,6 +221,14 @@ def convert_command(args: argparse.Namespace) -> None: keep_scale_offset=False, max_retries=args.max_retries, ) + elif _is_sentinel3_olci_input(dt): + log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + dt_geozarr = convert_olci_optimized( + dt, + output_path=output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + ) else: dt_geozarr = create_geozarr_dataset( dt_input=dt, @@ -1154,6 +1180,7 @@ def create_parser() -> argparse.ArgumentParser: # Add S2 optimization commands add_s2_optimization_commands(subparsers) + add_s3_olci_optimization_commands(subparsers) return parser @@ -1247,6 +1274,56 @@ def convert_s2_optimized_command(args: argparse.Namespace) -> None: log.warning("Error closing dask cluster", error=str(e)) +def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> None: + """Add S3 OLCI optimization commands to CLI parser.""" + p = subparsers.add_parser( + "convert-s3-olci-optimized", + help="Convert a Sentinel-3 OLCI L1 EFR dataset to optimized GeoZarr", + ) + p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") + p.add_argument("output_path", type=str, help="Path for output optimized dataset") + p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") + p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") + p.add_argument( + "--compression-level", + type=int, + default=3, + choices=range(1, 10), + help="Compression level 1-9 (default: 3)", + ) + p.add_argument( + "--min-dimension", + type=int, + default=256, + help="Minimum overview dimension (default: 256)", + ) + p.add_argument( + "--keep-scale-offset", + action="store_true", + help="Preserve scale-offset encoding instead of decoding to float", + ) + p.add_argument("--verbose", action="store_true", help="Enable verbose output") + p.set_defaults(func=convert_s3_olci_optimized_command) + + +def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: + """Execute S3 OLCI optimized conversion command.""" + storage_options = get_storage_options(str(args.input_path)) + dt_input = xr.open_datatree( + str(args.input_path), engine="zarr", chunks="auto", storage_options=storage_options + ) + convert_olci_optimized( + dt_input, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + compression_level=args.compression_level, + min_dimension=args.min_dimension, + keep_scale_offset=args.keep_scale_offset, + ) + log.info("S3 OLCI optimization completed", output_path=args.output_path) + + def main() -> None: """Execute main entry point for the CLI.""" parser = create_parser() diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index 50e844ed..f38fa579 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -2,9 +2,16 @@ from __future__ import annotations +import subprocess +import sys +from typing import TYPE_CHECKING + import numpy as np import xarray as xr +if TYPE_CHECKING: + import pathlib + from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized @@ -182,3 +189,32 @@ def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: g = zarr.open_group(out, mode="r") assert "conditions" in g assert "quality" in g + + +def test_cli_convert_s3_olci_optimized(tmp_path: pathlib.Path) -> None: + """convert-s3-olci-optimized subcommand must write a GeoZarr measurements group.""" + import zarr + + # materialise a synthetic OLCI product to a zarr v2 store on disk + dt = build_synthetic_olci(rows=300, cols=300) + src = tmp_path / "olci_src.zarr" + dt.to_zarr(src, mode="w", consolidated=False) + out = tmp_path / "olci_out.zarr" + result = subprocess.run( + [ + sys.executable, + "-m", + "eopf_geozarr", + "convert-s3-olci-optimized", + str(src), + str(out), + "--spatial-chunk", + "256", + ], + capture_output=True, + text=True, + timeout=300, + ) + assert result.returncode == 0, result.stdout + result.stderr + g = zarr.open_group(str(out), mode="r") + assert "measurements" in g From cec1e38090025dd81be86b72cd636c9fd822c558 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 09:43:14 +0200 Subject: [PATCH 14/58] test(s3-olci): real OLCI product fixture + round-trip detection Add structure-dump fixture (shapes shrunk to 16x16 / tie-points 16x4) from S3A_OL_1_EFR NT product fetched via HTTPS .zmetadata, add s3_olci_group_example conftest fixture, and extend test_s3_olci.py with is_sentinel3_olci_dataset and Sentinel3OlciRoot round-trip tests. Also update Sentinel3OlciMeasurementsMembers to include time_stamp and fix quality/conditions member types to allow nested GroupSpec children. Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/data_api/s3_olci.py | 17 +- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 9281 +++++++++++++++++ tests/conftest.py | 7 + tests/test_data_api/test_s3_olci.py | 28 + 4 files changed, 9331 insertions(+), 2 deletions(-) create mode 100644 tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json diff --git a/src/eopf_geozarr/data_api/s3_olci.py b/src/eopf_geozarr/data_api/s3_olci.py index 616a7454..7b55f8f0 100644 --- a/src/eopf_geozarr/data_api/s3_olci.py +++ b/src/eopf_geozarr/data_api/s3_olci.py @@ -33,6 +33,7 @@ class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): latitude: ArraySpec[object] longitude: ArraySpec[object] altitude: ArraySpec[object] + time_stamp: ArraySpec[object] orphans: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] oa01_radiance: ArraySpec[object] oa02_radiance: ArraySpec[object] @@ -65,8 +66,20 @@ class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): """Members of the OLCI root group.""" measurements: Sentinel3OlciMeasurementsGroup - quality: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] - conditions: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] + quality: GroupSpec[ + Mapping[str, object], + Mapping[ + str, + GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] | ArraySpec[object], + ], + ] + conditions: GroupSpec[ + Mapping[str, object], + Mapping[ + str, + GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] | ArraySpec[object], + ], + ] class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): diff --git a/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json new file mode 100644 index 00000000..540ba24b --- /dev/null +++ b/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -0,0 +1,9281 @@ +{ + "zarr_format": 2, + "attributes": { + "other_metadata": { + "absolute_pass_number": 101114, + "cycle_number": 132, + "data_information": { + "accuracy_reference": "0", + "earth_sun_distance": 148480739608, + "measurement_accuracy": "2.000000", + "ocl_status": "true", + "sampling": { + "across_track_distance": 270, + "along_track_distance": 294, + "along_track_time": 44001, + "columns_per_tiepoint": 64, + "rows_per_tiepoint": 1 + } + }, + "eopf_category": "eoproduct", + "ephemeris": { + "start": { + "TAI": "2025-11-01T07:04:33.801668", + "UT1": "2025-11-01T07:03:56.894643", + "UTC": "2025-11-01T07:03:56.801668Z", + "position": { + "x": -5158649.738, + "y": -4999249.404, + "z": 0.0 + }, + "velocity": { + "x": -1135.456679, + "y": 1184.091255, + "z": 7366.562801 + } + }, + "stop": { + "TAI": "2025-11-01T08:45:33.004874", + "UT1": "2025-11-01T08:44:56.097773", + "UTC": "2025-11-01T08:44:56.004874Z", + "position": { + "x": -6798153.901, + "y": -2321413.387, + "z": 0.001 + }, + "velocity": { + "x": -522.070453, + "y": 1555.438723, + "z": 7366.565105 + } + } + }, + "meteo": { + "missing_time": 0, + "source": "ECMWF", + "type": "ANALYSIS" + }, + "phase_identifier": 1, + "product_unit": { + "alongtrack_coordinate": 2160, + "duration": 179, + "type": "FRAME" + }, + "relative_pass_number": 298 + }, + "processing_history": { + "Level-0 Product": [ + { + "adfs": [ + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251031T193601_20251031T211644_20251031T212830_6043______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251031T193543_20251031T211626_20251031T213436_6043_132_142______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-10-31T21:34:44.882967Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251031T193601_20251031T211644_20251031T212830_6043______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251031T193543_20251031T211626_20251031T213436_6043_132_142______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-10-31T21:34:44.882967Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_CR___G_20251031T194853_20251031T203446_20251031T212835_2753______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251031T193543_20251031T211626_20251031T213436_6043_132_142______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251031T193543_20251031T211626_20251031T213436_6043_132_142______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_CR0____20251031T203343_20251031T203428_20251031T213509_0045_132_142______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-10-31T21:35:17.560564Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_TM_0_NAT__G_20251101T072914_20251101T091022_20251101T092320_6068______________SVL_O_NR_OPE.ISIP", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:11.830782Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T073951_20251101T074151_20251101T092324_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T073933_20251101T074133_20251101T092938_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:46.948695Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T073551_20251101T073751_20251101T092400_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T073535_20251101T073733_20251101T092939_0118_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:48.080956Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T073751_20251101T073951_20251101T092323_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T073733_20251101T073933_20251101T092939_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:48.353917Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T074351_20251101T074551_20251101T092325_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T074333_20251101T074533_20251101T092942_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:51.235291Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T074151_20251101T074351_20251101T092324_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T074133_20251101T074333_20251101T092945_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:53.711405Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T074751_20251101T074951_20251101T092327_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T074733_20251101T074933_20251101T092945_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:53.748759Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T074551_20251101T074751_20251101T092326_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T074533_20251101T074733_20251101T092948_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:56.456470Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T074951_20251101T075151_20251101T092329_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T074933_20251101T075133_20251101T092950_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:58.435023Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T080951_20251101T081151_20251101T092353_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T080933_20251101T081133_20251101T092950_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:29:58.866801Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T081951_20251101T082010_20251101T092357_0019______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T081933_20251101T081952_20251101T092953_0019_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:00.637395Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T075151_20251101T075351_20251101T092331_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T075133_20251101T075333_20251101T092952_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:01.238503Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T075551_20251101T075751_20251101T092335_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T075533_20251101T075733_20251101T092953_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:02.704502Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T075751_20251101T075951_20251101T092337_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T075733_20251101T075933_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.023429Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T080151_20251101T080351_20251101T092342_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T080133_20251101T080333_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.115634Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T075951_20251101T080151_20251101T092339_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T075933_20251101T080133_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.121375Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T080351_20251101T080551_20251101T092344_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T080333_20251101T080533_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.206487Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T081751_20251101T081951_20251101T092357_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T081733_20251101T081933_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.411532Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T080751_20251101T080951_20251101T092351_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T080733_20251101T080933_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.424684Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T081151_20251101T081351_20251101T092354_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T081133_20251101T081333_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:03.872892Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T081351_20251101T081551_20251101T092355_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T081333_20251101T081533_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:04.141107Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T075351_20251101T075551_20251101T092333_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T075333_20251101T075533_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:08.927171Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T081551_20251101T081751_20251101T092356_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T081533_20251101T081733_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:09.413568Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ACRI-ST-S3A Processing Service [PS1]", + "inputs": [ + "S3A_OL_0_EFR__G_20251101T080551_20251101T080751_20251101T092346_0120______________SVL_O_NR_OPE.ISIP", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3IPF PDS 001 - i1r8 - Product Data Format Specification - Level 0" + ], + "outputs": [ + "S3A_OL_0_EFR____20251101T080533_20251101T080733_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3" + ], + "processor": "IPF-0", + "time": "2025-11-01T09:30:09.643291Z", + "version": "06.16" + }, + { + "adfs": [ + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "", + "inputs": [ + "S3IPF PDS 001 - i1r1 - Product Data Format Specification - Level 0", + "S3A_OL_0_EFR____20251101T073535_20251101T073733_20251101T092939_0118_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T073733_20251101T073933_20251101T092939_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T073933_20251101T074133_20251101T092938_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T074133_20251101T074333_20251101T092945_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T074333_20251101T074533_20251101T092942_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T074533_20251101T074733_20251101T092948_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T074733_20251101T074933_20251101T092945_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T074933_20251101T075133_20251101T092950_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T075133_20251101T075333_20251101T092952_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T075333_20251101T075533_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T075533_20251101T075733_20251101T092953_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T075733_20251101T075933_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T075933_20251101T080133_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T080133_20251101T080333_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T080333_20251101T080533_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T080533_20251101T080733_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T080733_20251101T080933_20251101T092954_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T080933_20251101T081133_20251101T092950_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T081133_20251101T081333_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T081333_20251101T081533_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T081533_20251101T081733_20251101T093001_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T081733_20251101T081933_20251101T092955_0119_132_149______PS1_O_NR_002.SEN3", + "S3A_OL_0_EFR____20251101T081933_20251101T081952_20251101T092953_0019_132_149______PS1_O_NR_002.SEN3" + ], + "outputs": [ + "S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.SEN3" + ], + "processor": "PUG", + "time": "2025-11-02T06:40:37.351108Z", + "version": "03.50" + }, + { + "facility": "CS-SopraSteria", + "inputs": [ + "S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.SEN3" + ], + "outputs": [ + "S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.zarr.zarr" + ], + "processor": "EOPF-CPM", + "time": "2026-01-25T08:25:10.532519Z", + "version": "2.6.2" + } + ], + "Level-1 Product": [ + { + "adfs": [ + "S3A_OL_1_RAC_AX_20160425T103700_20991231T235959_20210309T120000___________________MPC_O_AL_006.SEN3", + "S3A_OL_1_INS_AX_20201030T120000_20991231T235959_20220505T120000___________________MPC_O_AL_009.SEN3", + "S3A_OL_1_CAL_AX_20250219T001400_20991231T235959_20250219T120000___________________MPC_O_AL_032.SEN3", + "S3A_OL_1_PRG_AX_20160425T095210_20991231T235959_20210309T120000___________________MPC_O_AL_004.SEN3", + "S3A_AX___FRO_AX_20251028T000000_20251107T000000_20251031T064829___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ESA-Copernicus Ground Segment", + "inputs": [ + "S3A_TM_0_NAT____20251031T193543_20251031T211626_20251031T213436_6043_132_142______PS1_O_AL_004.SEN3", + "S3A_OL_0_CR0____20251031T203343_20251031T203428_20251031T213509_0045_132_142______PS1_O_NR_002.SEN3", + "S3IPF PDS 004.1 - i2r7 - Product Data Format Specification - OLCI Level 1" + ], + "outputs": [ + "S3A_OL_1_RAC____20251031T203343_20251031T203428_20251031T213547_0045_132_142______PS1_O_NR_004.SEN3" + ], + "processor": "IPF-OL-1-RAC", + "time": "2025-10-31T21:35:47.946683Z", + "version": "06.17" + }, + { + "adfs": [ + "S3A_OL_1_EO__AX_20160425T103700_20991231T235959_20230613T120000___________________MPC_O_AL_015.SEN3", + "S3__AX___MA1_AX_20251031T210000_20251101T090000_20251101T055222___________________ECW_O_SN_001.SEN3", + "S3__AX___MA1_AX_20251101T030000_20251101T150000_20251101T173929___________________ECW_O_SN_001.SEN3", + "S3__AX___MA1_AX_20251101T090000_20251101T210000_20251101T175432___________________ECW_O_SN_001.SEN3", + "S3__AX___DEM_AX_20000101T000000_20991231T235959_20151214T120000___________________MPC_O_AL_001.SEN3", + "S3A_OL_1_CLUTAX_20160425T095210_20991231T235959_20160525T120000___________________MPC_O_AL_003.SEN3", + "S3A_OL_1_INS_AX_20201030T120000_20991231T235959_20220505T120000___________________MPC_O_AL_009.SEN3", + "S3A_OL_1_CAL_AX_20250219T001400_20991231T235959_20250219T120000___________________MPC_O_AL_032.SEN3", + "S3A_OL_1_PRG_AX_20160425T095210_20991231T235959_20210309T120000___________________MPC_O_AL_004.SEN3", + "S3__AX___LWM_AX_20000101T000000_20991231T235959_20151214T120000___________________MPC_O_AL_001.SEN3", + "S3__AX___OOM_AX_20000101T000000_20991231T235959_20151214T120000___________________MPC_O_AL_001.SEN3", + "S3__AX___CLM_AX_20000101T000000_20991231T235959_20151214T120000___________________MPC_O_AL_001.SEN3", + "S3__AX___TRM_AX_20000101T000000_20991231T235959_20151214T120000___________________MPC_O_AL_001.SEN3", + "S3A_AX___FRO_AX_20251029T000000_20251108T000000_20251101T064726___________________EUM_O_AL_001.SEN3", + "S3A_AX___OSF_AX_20160216T192404_99991231T235959_20250724T075944___________________EUM_O_AL_001.SEN3" + ], + "facility": "ESA-Copernicus Ground Segment", + "inputs": [ + "S3A_TM_0_NAT____20251101T072856_20251101T091004_20251101T092903_6068_132_149______PS1_O_AL_004.SEN3", + "S3A_OL_0_EFR____20251101T073535_20251101T081952_20251102T064005_2657_132_149______PS1_O_NT_003.SEN3", + "S3A_OL_1_RAC____20251031T203343_20251031T203428_20251031T213547_0045_132_142______PS1_O_NR_004.SEN3", + "S3IPF PDS 004.1 - i2r7 - Product Data Format Specification - OLCI Level 1" + ], + "outputs": [ + "S3A_OL_1_EFR____20251101T073535_20251101T081952_20251102T064720_2657_132_149______PS1_O_NT_004.SEN3" + ], + "processor": "IPF-OL-1-EO", + "time": "2025-11-02T08:33:16.813474Z", + "version": "06.19" + }, + { + "facility": "", + "inputs": [ + "S3IPF PDS 004.1 - Product Data Format Specification - OLCI Level 1", + "Metadata Specification, Excel document S3IPF.PDS.008", + "S3A_OL_1_EFR____20251101T073535_20251101T081952_20251102T064720_2657_132_149______PS1_O_NT_004.SEN3" + ], + "outputs": [], + "processor": "PUG", + "time": "2025-11-02T08:43:38.241703Z", + "version": "03.50" + } + ] + }, + "stac_discovery": { + "assets": { + "atmospheric_temperature_profile": { + "href": "/conditions/meteorology/atmospheric_temperature_profile", + "title": "atmospheric_temperature_profile" + }, + "detector_index": { + "href": "/conditions/image/detector_index", + "title": "detector_index" + }, + "detector_index_orphans": { + "href": "/conditions/orphans/detector_index", + "title": "detector_index_orphans" + }, + "frame_offset": { + "href": "/conditions/image/frame_offset", + "title": "frame_offset" + }, + "frame_offset_orphans": { + "href": "/conditions/orphans/frame_offset", + "title": "frame_offset_orphans" + }, + "fwhm": { + "href": "/conditions/instrument/fwhm", + "title": "fwhm" + }, + "horizontal_wind": { + "href": "/conditions/meteorology/horizontal_wind", + "title": "horizontal_wind" + }, + "humidity": { + "href": "/conditions/meteorology/humidity", + "title": "humidity" + }, + "lambda0": { + "href": "/conditions/instrument/lambda0", + "title": "lambda0" + }, + "nb_removed_pixels": { + "href": "/conditions/orphans/nb_removed_pixels", + "title": "nb_removed_pixels" + }, + "oa01_radiance": { + "href": "/measurements/oa01_radiance", + "title": "oa01_radiance" + }, + "oa01_radiance_orphans": { + "href": "/measurements/orphans/oa01_radiance", + "title": "oa01_radiance_orphans" + }, + "oa01_radiance_unc": { + "href": "/quality/oa01_radiance_unc", + "title": "oa01_radiance_unc" + }, + "oa01_radiance_unc_orphans": { + "href": "/quality/orphans/oa01_radiance_unc", + "title": "oa01_radiance_unc_orphans" + }, + "oa02_radiance": { + "href": "/measurements/oa02_radiance", + "title": "oa02_radiance" + }, + "oa02_radiance_orphans": { + "href": "/measurements/orphans/oa02_radiance", + "title": "oa02_radiance_orphans" + }, + "oa02_radiance_unc": { + "href": "/quality/oa02_radiance_unc", + "title": "oa02_radiance_unc" + }, + "oa02_radiance_unc_orphans": { + "href": "/quality/orphans/oa02_radiance_unc", + "title": "oa02_radiance_unc_orphans" + }, + "oa03_radiance": { + "href": "/measurements/oa03_radiance", + "title": "oa03_radiance" + }, + "oa03_radiance_orphans": { + "href": "/measurements/orphans/oa03_radiance", + "title": "oa03_radiance_orphans" + }, + "oa03_radiance_unc": { + "href": "/quality/oa03_radiance_unc", + "title": "oa03_radiance_unc" + }, + "oa03_radiance_unc_orphans": { + "href": "/quality/orphans/oa03_radiance_unc", + "title": "oa03_radiance_unc_orphans" + }, + "oa04_radiance": { + "href": "/measurements/oa04_radiance", + "title": "oa04_radiance" + }, + "oa04_radiance_orphans": { + "href": "/measurements/orphans/oa04_radiance", + "title": "oa04_radiance_orphans" + }, + "oa04_radiance_unc": { + "href": "/quality/oa04_radiance_unc", + "title": "oa04_radiance_unc" + }, + "oa04_radiance_unc_orphans": { + "href": "/quality/orphans/oa04_radiance_unc", + "title": "oa04_radiance_unc_orphans" + }, + "oa05_radiance": { + "href": "/measurements/oa05_radiance", + "title": "oa05_radiance" + }, + "oa05_radiance_orphans": { + "href": "/measurements/orphans/oa05_radiance", + "title": "oa05_radiance_orphans" + }, + "oa05_radiance_unc": { + "href": "/quality/oa05_radiance_unc", + "title": "oa05_radiance_unc" + }, + "oa05_radiance_unc_orphans": { + "href": "/quality/orphans/oa05_radiance_unc", + "title": "oa05_radiance_unc_orphans" + }, + "oa06_radiance": { + "href": "/measurements/oa06_radiance", + "title": "oa06_radiance" + }, + "oa06_radiance_orphans": { + "href": "/measurements/orphans/oa06_radiance", + "title": "oa06_radiance_orphans" + }, + "oa06_radiance_unc": { + "href": "/quality/oa06_radiance_unc", + "title": "oa06_radiance_unc" + }, + "oa06_radiance_unc_orphans": { + "href": "/quality/orphans/oa06_radiance_unc", + "title": "oa06_radiance_unc_orphans" + }, + "oa07_radiance": { + "href": "/measurements/oa07_radiance", + "title": "oa07_radiance" + }, + "oa07_radiance_orphans": { + "href": "/measurements/orphans/oa07_radiance", + "title": "oa07_radiance_orphans" + }, + "oa07_radiance_unc": { + "href": "/quality/oa07_radiance_unc", + "title": "oa07_radiance_unc" + }, + "oa07_radiance_unc_orphans": { + "href": "/quality/orphans/oa07_radiance_unc", + "title": "oa07_radiance_unc_orphans" + }, + "oa08_radiance": { + "href": "/measurements/oa08_radiance", + "title": "oa08_radiance" + }, + "oa08_radiance_orphans": { + "href": "/measurements/orphans/oa08_radiance", + "title": "oa08_radiance_orphans" + }, + "oa08_radiance_unc": { + "href": "/quality/oa08_radiance_unc", + "title": "oa08_radiance_unc" + }, + "oa08_radiance_unc_orphans": { + "href": "/quality/orphans/oa08_radiance_unc", + "title": "oa08_radiance_unc_orphans" + }, + "oa09_radiance": { + "href": "/measurements/oa09_radiance", + "title": "oa09_radiance" + }, + "oa09_radiance_orphans": { + "href": "/measurements/orphans/oa09_radiance", + "title": "oa09_radiance_orphans" + }, + "oa09_radiance_unc": { + "href": "/quality/oa09_radiance_unc", + "title": "oa09_radiance_unc" + }, + "oa09_radiance_unc_orphans": { + "href": "/quality/orphans/oa09_radiance_unc", + "title": "oa09_radiance_unc_orphans" + }, + "oa10_radiance": { + "href": "/measurements/oa10_radiance", + "title": "oa10_radiance" + }, + "oa10_radiance_orphans": { + "href": "/measurements/orphans/oa10_radiance", + "title": "oa10_radiance_orphans" + }, + "oa10_radiance_unc": { + "href": "/quality/oa10_radiance_unc", + "title": "oa10_radiance_unc" + }, + "oa10_radiance_unc_orphans": { + "href": "/quality/orphans/oa10_radiance_unc", + "title": "oa10_radiance_unc_orphans" + }, + "oa11_radiance": { + "href": "/measurements/oa11_radiance", + "title": "oa11_radiance" + }, + "oa11_radiance_orphans": { + "href": "/measurements/orphans/oa11_radiance", + "title": "oa11_radiance_orphans" + }, + "oa11_radiance_unc": { + "href": "/quality/oa11_radiance_unc", + "title": "oa11_radiance_unc" + }, + "oa11_radiance_unc_orphans": { + "href": "/quality/orphans/oa11_radiance_unc", + "title": "oa11_radiance_unc_orphans" + }, + "oa12_radiance": { + "href": "/measurements/oa12_radiance", + "title": "oa12_radiance" + }, + "oa12_radiance_orphans": { + "href": "/measurements/orphans/oa12_radiance", + "title": "oa12_radiance_orphans" + }, + "oa12_radiance_unc": { + "href": "/quality/oa12_radiance_unc", + "title": "oa12_radiance_unc" + }, + "oa12_radiance_unc_orphans": { + "href": "/quality/orphans/oa12_radiance_unc", + "title": "oa12_radiance_unc_orphans" + }, + "oa13_radiance": { + "href": "/measurements/oa13_radiance", + "title": "oa13_radiance" + }, + "oa13_radiance_orphans": { + "href": "/measurements/orphans/oa13_radiance", + "title": "oa13_radiance_orphans" + }, + "oa13_radiance_unc": { + "href": "/quality/oa13_radiance_unc", + "title": "oa13_radiance_unc" + }, + "oa13_radiance_unc_orphans": { + "href": "/quality/orphans/oa13_radiance_unc", + "title": "oa13_radiance_unc_orphans" + }, + "oa14_radiance": { + "href": "/measurements/oa14_radiance", + "title": "oa14_radiance" + }, + "oa14_radiance_orphans": { + "href": "/measurements/orphans/oa14_radiance", + "title": "oa14_radiance_orphans" + }, + "oa14_radiance_unc": { + "href": "/quality/oa14_radiance_unc", + "title": "oa14_radiance_unc" + }, + "oa14_radiance_unc_orphans": { + "href": "/quality/orphans/oa14_radiance_unc", + "title": "oa14_radiance_unc_orphans" + }, + "oa15_radiance": { + "href": "/measurements/oa15_radiance", + "title": "oa15_radiance" + }, + "oa15_radiance_orphans": { + "href": "/measurements/orphans/oa15_radiance", + "title": "oa15_radiance_orphans" + }, + "oa15_radiance_unc": { + "href": "/quality/oa15_radiance_unc", + "title": "oa15_radiance_unc" + }, + "oa15_radiance_unc_orphans": { + "href": "/quality/orphans/oa15_radiance_unc", + "title": "oa15_radiance_unc_orphans" + }, + "oa16_radiance": { + "href": "/measurements/oa16_radiance", + "title": "oa16_radiance" + }, + "oa16_radiance_orphans": { + "href": "/measurements/orphans/oa16_radiance", + "title": "oa16_radiance_orphans" + }, + "oa16_radiance_unc": { + "href": "/quality/oa16_radiance_unc", + "title": "oa16_radiance_unc" + }, + "oa16_radiance_unc_orphans": { + "href": "/quality/orphans/oa16_radiance_unc", + "title": "oa16_radiance_unc_orphans" + }, + "oa17_radiance": { + "href": "/measurements/oa17_radiance", + "title": "oa17_radiance" + }, + "oa17_radiance_orphans": { + "href": "/measurements/orphans/oa17_radiance", + "title": "oa17_radiance_orphans" + }, + "oa17_radiance_unc": { + "href": "/quality/oa17_radiance_unc", + "title": "oa17_radiance_unc" + }, + "oa17_radiance_unc_orphans": { + "href": "/quality/orphans/oa17_radiance_unc", + "title": "oa17_radiance_unc_orphans" + }, + "oa18_radiance": { + "href": "/measurements/oa18_radiance", + "title": "oa18_radiance" + }, + "oa18_radiance_orphans": { + "href": "/measurements/orphans/oa18_radiance", + "title": "oa18_radiance_orphans" + }, + "oa18_radiance_unc": { + "href": "/quality/oa18_radiance_unc", + "title": "oa18_radiance_unc" + }, + "oa18_radiance_unc_orphans": { + "href": "/quality/orphans/oa18_radiance_unc", + "title": "oa18_radiance_unc_orphans" + }, + "oa19_radiance": { + "href": "/measurements/oa19_radiance", + "title": "oa19_radiance" + }, + "oa19_radiance_orphans": { + "href": "/measurements/orphans/oa19_radiance", + "title": "oa19_radiance_orphans" + }, + "oa19_radiance_unc": { + "href": "/quality/oa19_radiance_unc", + "title": "oa19_radiance_unc" + }, + "oa19_radiance_unc_orphans": { + "href": "/quality/orphans/oa19_radiance_unc", + "title": "oa19_radiance_unc_orphans" + }, + "oa20_radiance": { + "href": "/measurements/oa20_radiance", + "title": "oa20_radiance" + }, + "oa20_radiance_orphans": { + "href": "/measurements/orphans/oa20_radiance", + "title": "oa20_radiance_orphans" + }, + "oa20_radiance_unc": { + "href": "/quality/oa20_radiance_unc", + "title": "oa20_radiance_unc" + }, + "oa20_radiance_unc_orphans": { + "href": "/quality/orphans/oa20_radiance_unc", + "title": "oa20_radiance_unc_orphans" + }, + "oa21_radiance": { + "href": "/measurements/oa21_radiance", + "title": "oa21_radiance" + }, + "oa21_radiance_orphans": { + "href": "/measurements/orphans/oa21_radiance", + "title": "oa21_radiance_orphans" + }, + "oa21_radiance_unc": { + "href": "/quality/oa21_radiance_unc", + "title": "oa21_radiance_unc" + }, + "oa21_radiance_unc_orphans": { + "href": "/quality/orphans/oa21_radiance_unc", + "title": "oa21_radiance_unc_orphans" + }, + "oaa": { + "href": "/conditions/geometry/oaa", + "title": "oaa" + }, + "oza": { + "href": "/conditions/geometry/oza", + "title": "oza" + }, + "quality_flags": { + "href": "/quality/quality_flags", + "title": "quality_flags" + }, + "quality_flags_orphans": { + "href": "/quality/orphans/quality_flags", + "title": "quality_flags_orphans" + }, + "relative_spectral_covariance": { + "href": "/conditions/instrument/relative_spectral_covariance", + "title": "relative_spectral_covariance" + }, + "saa": { + "href": "/conditions/geometry/saa", + "title": "saa" + }, + "sea_level_pressure": { + "href": "/conditions/meteorology/sea_level_pressure", + "title": "sea_level_pressure" + }, + "solar_flux": { + "href": "/conditions/instrument/solar_flux", + "title": "solar_flux" + }, + "sza": { + "href": "/conditions/geometry/sza", + "title": "sza" + }, + "sza_orphans": { + "href": "/conditions/orphans/sza", + "title": "sza_orphans" + }, + "total_columnar_water_vapour": { + "href": "/conditions/meteorology/total_columnar_water_vapour", + "title": "total_columnar_water_vapour" + }, + "total_ozone": { + "href": "/conditions/meteorology/total_ozone", + "title": "total_ozone" + } + }, + "bbox": [ + 50.2738, + 39.5451, + 30.273, + 52.4509 + ], + "collection": "OL__L1_.004.01.00", + "geometry": { + "coordinates": [ + [ + [ + 30.273, + 41.9704 + ], + [ + 31.1018, + 41.8937 + ], + [ + 31.9266, + 41.8114 + ], + [ + 32.7591, + 41.722 + ], + [ + 33.5821, + 41.6276 + ], + [ + 34.4036, + 41.5298 + ], + [ + 35.21, + 41.4252 + ], + [ + 36.0241, + 41.3112 + ], + [ + 36.8244, + 41.1979 + ], + [ + 37.6322, + 41.0748 + ], + [ + 38.4362, + 40.946 + ], + [ + 39.2425, + 40.8107 + ], + [ + 40.0401, + 40.6707 + ], + [ + 40.8321, + 40.5257 + ], + [ + 41.6192, + 40.376 + ], + [ + 42.4046, + 40.2206 + ], + [ + 43.1858, + 40.061 + ], + [ + 43.9685, + 39.8941 + ], + [ + 44.7417, + 39.7232 + ], + [ + 45.5177, + 39.5451 + ], + [ + 46.5646, + 42.1402 + ], + [ + 47.6972, + 44.7331 + ], + [ + 48.9276, + 47.3145 + ], + [ + 50.2738, + 49.8833 + ], + [ + 49.3652, + 50.0884 + ], + [ + 48.448, + 50.286 + ], + [ + 47.5222, + 50.4765 + ], + [ + 46.5878, + 50.659 + ], + [ + 45.6488, + 50.8344 + ], + [ + 44.7016, + 51.0024 + ], + [ + 43.7492, + 51.1629 + ], + [ + 42.7906, + 51.3155 + ], + [ + 41.8274, + 51.46 + ], + [ + 40.8537, + 51.5971 + ], + [ + 39.8797, + 51.7254 + ], + [ + 38.8973, + 51.8432 + ], + [ + 37.906, + 51.958 + ], + [ + 36.9122, + 52.0592 + ], + [ + 35.9213, + 52.154 + ], + [ + 34.9166, + 52.2412 + ], + [ + 33.9165, + 52.3194 + ], + [ + 32.91, + 52.3892 + ], + [ + 31.8908, + 52.4509 + ], + [ + 31.4953, + 49.8306 + ], + [ + 31.0932, + 47.2099 + ], + [ + 30.6854, + 44.587 + ], + [ + 30.273, + 41.9704 + ] + ] + ], + "type": "Polygon" + }, + "id": "S03OLCEFR_20251101T073956_0180_A149_S973", + "links": [ + { + "href": "./.zattrs.json", + "rel": "collection", + "type": "application/json" + } + ], + "properties": { + "bands": [ + { + "eo:center_wavelength": 0.4, + "eo:full_width_half_max": 0.015, + "name": "oa01" + }, + { + "eo:center_wavelength": 0.41250000000000003, + "eo:full_width_half_max": 0.01, + "name": "oa02" + }, + { + "eo:center_wavelength": 0.4425, + "eo:full_width_half_max": 0.01, + "name": "oa03" + }, + { + "eo:center_wavelength": 0.49, + "eo:common_name": "blue", + "eo:full_width_half_max": 0.01, + "name": "oa04" + }, + { + "eo:center_wavelength": 0.51, + "eo:full_width_half_max": 0.01, + "name": "oa05" + }, + { + "eo:center_wavelength": 0.56, + "eo:common_name": "green", + "eo:full_width_half_max": 0.01, + "name": "oa06" + }, + { + "eo:center_wavelength": 0.62, + "eo:common_name": "yellow", + "eo:full_width_half_max": 0.01, + "name": "oa07" + }, + { + "eo:center_wavelength": 0.665, + "eo:full_width_half_max": 0.01, + "name": "oa08" + }, + { + "eo:center_wavelength": 0.67375, + "eo:full_width_half_max": 0.0075, + "name": "oa09" + }, + { + "eo:center_wavelength": 0.68125, + "eo:full_width_half_max": 0.0075, + "name": "oa10" + }, + { + "eo:center_wavelength": 0.70875, + "eo:full_width_half_max": 0.01, + "name": "oa11" + }, + { + "eo:center_wavelength": 0.75375, + "eo:full_width_half_max": 0.0075, + "name": "oa12" + }, + { + "eo:center_wavelength": 0.76125, + "eo:full_width_half_max": 0.0025, + "name": "oa13" + }, + { + "eo:center_wavelength": 0.764375, + "eo:full_width_half_max": 0.00375, + "name": "oa14" + }, + { + "eo:center_wavelength": 0.7675000000000001, + "eo:full_width_half_max": 0.0025, + "name": "oa15" + }, + { + "eo:center_wavelength": 0.77875, + "eo:full_width_half_max": 0.015, + "name": "oa16" + }, + { + "eo:center_wavelength": 0.865, + "eo:full_width_half_max": 0.02, + "name": "oa17" + }, + { + "eo:center_wavelength": 0.885, + "eo:full_width_half_max": 0.01, + "name": "oa18" + }, + { + "eo:center_wavelength": 0.9, + "eo:full_width_half_max": 0.01, + "name": "oa19" + }, + { + "eo:center_wavelength": 0.9400000000000001, + "eo:full_width_half_max": 0.02, + "name": "oa20" + }, + { + "eo:center_wavelength": 1.02, + "eo:full_width_half_max": 0.04, + "name": "oa21" + } + ], + "classification:classes": [ + { + "count": 748283, + "name": "invalid", + "percentage": 4.0 + }, + { + "count": 0, + "name": "cosmetic", + "percentage": 0.0 + }, + { + "count": 4509230, + "name": "duplicated", + "percentage": 23.0 + }, + { + "count": 16, + "name": "saturated", + "percentage": 0.0 + }, + { + "count": 119, + "name": "dubious", + "percentage": 0.0 + }, + { + "name": "saline_water", + "percentage": 24.0 + }, + { + "name": "bright", + "percentage": 36.0 + }, + { + "name": "coastal", + "percentage": 0.0 + }, + { + "name": "fresh_water", + "percentage": 2.0 + }, + { + "name": "tidal", + "percentage": 0.0 + } + ], + "constellation": "sentinel-3", + "created": "2025-11-02T08:42:55Z", + "datetime": "2025-11-01T07:41:26.801966Z", + "end_datetime": "2025-11-01T07:42:56.801966Z", + "eopf:instrument_mode": "Earth Observation", + "gsd": 270, + "instruments": [ + "olci" + ], + "mission": "copernicus", + "platform": "sentinel-3a", + "processing:facility": "OPE", + "processing:level": "L1", + "processing:lineage": "systematic", + "processing:software": { + "PUG": "03.50" + }, + "processing:version": "TODO", + "product:timeliness": "P1M", + "product:timeliness_category": "NT", + "product:type": "S03OLCEFR", + "proj:shape": [ + { + "columns": 4865, + "name": "FR", + "rows": 4090 + } + ], + "providers": [ + { + "name": "", + "roles": [ + "processor" + ] + }, + { + "name": [], + "roles": [ + "producer" + ] + } + ], + "sat:absolute_orbit": 50557, + "sat:orbit_state": "descending", + "sat:platform_international_designator": "2016-011A", + "sat:relative_orbit": 149, + "start_datetime": "2025-11-01T07:39:56.801966Z" + }, + "stac_extensions": [ + "https://stac-extensions.github.io/eopf/v1.2.0/schema.json", + "https://stac-extensions.github.io/classification/v2.0.0/schema.json", + "https://stac-extensions.github.io/eo/v1.1.0/schema.json", + "https://stac-extensions.github.io/sat/v1.1.0/schema.json", + "https://stac-extensions.github.io/view/v1.0.0/schema.json", + "https://stac-extensions.github.io/scientific/v1.0.0/schema.json", + "https://stac-extensions.github.io/processing/v1.2.0/schema.json", + "https://stac-extensions.github.io/projection/v2.0.0/schema.json", + "https://stac-extensions.github.io/product/v0.1.0/schema.json" + ], + "stac_version": "1.1.0", + "type": "Feature" + } + }, + "members": { + "conditions": { + "zarr_format": 2, + "attributes": {}, + "members": { + "geometry": { + "zarr_format": 2, + "attributes": {}, + "members": { + "latitude": { + "zarr_format": 2, + "attributes": { + "_ARRAY_DIMENSIONS": [ + "rows", + "columns" + ], + "dimensions": [ + "rows", + "columns" + ], + "dtype": " return out_dir +@pytest.fixture(params=s3_example_json_paths, ids=get_stem) +def s3_olci_group_example(request: pytest.FixtureRequest, tmp_path: pathlib.Path) -> pathlib.Path: + """Path to a Zarr group with the layout of a Sentinel-3 OLCI product.""" + return create_group_from_json(request.param, tmp_path) + + @pytest.fixture(params=s1_example_json_paths, ids=get_stem) def s1_group_example(request: pytest.FixtureRequest, tmp_path: pathlib.Path) -> pathlib.Path: """ diff --git a/tests/test_data_api/test_s3_olci.py b/tests/test_data_api/test_s3_olci.py index ce32ca96..0625ec84 100644 --- a/tests/test_data_api/test_s3_olci.py +++ b/tests/test_data_api/test_s3_olci.py @@ -102,3 +102,31 @@ def test_detector_rejects_s2_zarr(s2_group_example: object) -> None: assert isinstance(s2_group_example, pathlib.Path) group = zarr.open_group(str(s2_group_example), mode="r") assert is_sentinel3_olci_dataset(group) is False + + +def test_real_olci_product_is_detected(s3_olci_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + assert isinstance(s3_olci_group_example, pathlib.Path) + group = zarr.open_group(str(s3_olci_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_real_olci_product_validates_model(s3_olci_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + + assert isinstance(s3_olci_group_example, pathlib.Path) + group = zarr.open_group(str(s3_olci_group_example), mode="r") + model = Sentinel3OlciRoot.model_validate(PyzGroupSpec.from_zarr(group).model_dump()) + assert "oa01_radiance" in model.measurements.members From 0b453920eadf571015b8fe4fc771cc622048dfdd Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 09:56:58 +0200 Subject: [PATCH 15/58] test(s3-olci): golden-file snapshot of converted OLCI structure Co-Authored-By: Claude Opus 4.8 --- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 1828 +++++++++++++++++ tests/test_olci_integration.py | 60 + 2 files changed, 1888 insertions(+) create mode 100644 tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json new file mode 100644 index 00000000..9acab0ef --- /dev/null +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -0,0 +1,1828 @@ +{ + "attributes": {}, + "members": { + "measurements": { + "attributes": { + "spatial:dimensions": [ + "rows", + "columns" + ], + "spatial:registration": "pixel", + "zarr_conventions": [ + { + "description": "Spatial coordinate information", + "name": "spatial:", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", + "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" + } + ] + }, + "members": { + "altitude": { + "attributes": { + "dimensions": [ + "rows", + "columns" + ], + "dtype": " None: assert result.returncode == 0, result.stdout + result.stderr g = zarr.open_group(str(out), mode="r") assert "measurements" in g + + +def test_olci_conversion_matches_snapshot( + s3_olci_group_example: pathlib.Path, + tmp_path: pathlib.Path, +) -> None: + """Snapshot test: converted OLCI structure must match committed golden file. + + The real OLCI fixture contains a ``time_stamp`` array in the measurements + group whose ``rows`` dimension has a different length (4) than the spatial + arrays (16). xarray's DataTree loader rejects this as conflicting dimension + sizes, so we open only the /measurements group as a Dataset — dropping the + non-spatial ``time_stamp`` — and wrap it in a minimal DataTree before + passing it to the converter. + + To (re)generate the snapshot, uncomment the regeneration block below, + run the test once, then re-comment before committing. + """ + meas_ds = xr.open_dataset( + str(s3_olci_group_example), + engine="zarr", + group="measurements", + consolidated=False, + drop_variables=["time_stamp"], + chunks={}, + ) + # Clear inherited Zarr-v2 encoding (numcodecs.Blosc) so the converter can + # write a clean Zarr-v3 store without codec-compatibility errors. + for _var in list(meas_ds.data_vars) + list(meas_ds.coords): + meas_ds[_var].encoding.clear() + dt_in = xr.DataTree.from_dict({"/measurements": meas_ds}) + out = str(tmp_path / "out.zarr") + convert_olci_optimized(dt_in, output_path=out, min_dimension=256) + + observed_group = zarr.open_group(out, use_consolidated=False) + observed_structure_json = GroupSpec.from_zarr(observed_group).model_dump() + + expected_path = Path("tests/_test_data/optimized_olci_examples") / ( + s3_olci_group_example.stem + ".json" + ) + + # Uncomment this block to (re)generate the snapshot from the observed structure. + # expected_path.parent.mkdir(parents=True, exist_ok=True) + # expected_path.write_text(json.dumps(observed_structure_json, indent=2, sort_keys=True)) + + observed_structure = GroupSpec(**tuplify_json(observed_structure_json)) + observed_structure_flat = observed_structure.to_flat() + expected_structure_json = tuplify_json(json.loads(expected_path.read_text())) + expected_structure = GroupSpec(**expected_structure_json) + expected_structure_flat = expected_structure.to_flat() + + o_keys = set(observed_structure_flat.keys()) + e_keys = set(expected_structure_flat.keys()) + assert o_keys == e_keys + assert [k for k in o_keys if observed_structure_flat[k] != expected_structure_flat[k]] == [] From c673287dcc1a32ac1ddc0edc0b71a7eb7cb911c7 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 10:10:14 +0200 Subject: [PATCH 16/58] fix(s3-olci): strip inherited v2 encoding before v3 write; fix fixture time_stamp rows Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_converter.py | 31 ++++++ ...084255_0179_132_149_2160_PS1_O_NT_004.json | 95 +++++++++++++++---- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 66 ++++++------- tests/test_olci_integration.py | 18 ++-- 4 files changed, 145 insertions(+), 65 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 4959d0a8..ed98553c 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -50,6 +50,29 @@ def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: return levels +def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: + """Return *ds* with all inherited source encoding cleared. + + When the input DataTree was opened from a Zarr v2 store, xarray carries + ``numcodecs.Blosc`` compressors (and potentially scale-offset filters) in + each variable's ``.encoding``. Passing that encoding to + ``Dataset.to_zarr(zarr_format=3)`` raises:: + + TypeError: Expected a BytesBytesCodec. Got + + because numcodecs codecs are not valid Zarr v3 BytesBytesCodecs. Clearing + the encoding lets the Zarr v3 writer choose its own default codecs. + + CF attributes (``scale_factor``, ``add_offset``, ``_FillValue``) live in + ``.attrs``, not ``.encoding``, so they are preserved by this function. + """ + ds = ds.copy() + ds.encoding = {} + for var in list(ds.data_vars) + list(ds.coords): + ds[var].encoding.clear() + return ds + + def _copy_subtree(node: xr.DataTree, output_path: str, *, root_group: str) -> None: """Write every Dataset in *node*'s subtree to the Zarr store at *output_path*. @@ -65,6 +88,8 @@ def _copy_subtree(node: xr.DataTree, output_path: str, *, root_group: str) -> No ds = child.to_dataset() if not ds.data_vars and not ds.coords: continue + # Strip any inherited Zarr v2 encoding before writing to a v3 store. + ds = _clear_encoding(ds) # Build the group path: strip the ancestor prefix and prepend root_group. relative = child.path[len(node_path) :] # "" for root, "/sub" for children group_path = root_group + relative @@ -143,6 +168,11 @@ def convert_olci_optimized( follow-up task so as not to block the integration test. """ measurements = dt_input["/measurements"].to_dataset() + # Strip any inherited Zarr v2 encoding (e.g. numcodecs.Blosc compressors) + # so the v3 writer can choose its own default codecs without raising a + # "Expected a BytesBytesCodec" error. CF attrs (scale_factor, add_offset, + # _FillValue) live in .attrs, not .encoding, so they are preserved. + measurements = _clear_encoding(measurements) # Attach GeoZarr spatial convention metadata for native-resolution swath. conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) @@ -166,6 +196,7 @@ def convert_olci_optimized( current = measurements for level in range(1, n_levels + 1): current = decimate_swath(current, factor=2) + current = _clear_encoding(current) group_name = f"r{2**level}" log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) current.to_zarr( diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index 9acab0ef..4cb98e61 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -228,7 +228,7 @@ "valid_max": 65534, "valid_min": 0 }, - "coordinates": "altitude latitude longitude", + "coordinates": "altitude latitude longitude time_stamp", "dtype": " None: """Snapshot test: converted OLCI structure must match committed golden file. - The real OLCI fixture contains a ``time_stamp`` array in the measurements - group whose ``rows`` dimension has a different length (4) than the spatial - arrays (16). xarray's DataTree loader rejects this as conflicting dimension - sizes, so we open only the /measurements group as a Dataset — dropping the - non-spatial ``time_stamp`` — and wrap it in a minimal DataTree before - passing it to the converter. + The fixture is a Zarr v2 store representing a real OLCI L1 EFR product. + We open just the ``/measurements`` group (the converter's input is a + DataTree rooted at this sub-tree) and wrap it in a minimal DataTree. + The ``time_stamp`` array is included: its ``rows`` dimension now matches + the spatial arrays (both 16), so no ``drop_variables`` workaround is + needed. Inherited Zarr v2 encoding is stripped inside the converter, so + no ``encoding.clear()`` workaround is needed here either. To (re)generate the snapshot, uncomment the regeneration block below, run the test once, then re-comment before committing. @@ -246,13 +247,8 @@ def test_olci_conversion_matches_snapshot( engine="zarr", group="measurements", consolidated=False, - drop_variables=["time_stamp"], chunks={}, ) - # Clear inherited Zarr-v2 encoding (numcodecs.Blosc) so the converter can - # write a clean Zarr-v3 store without codec-compatibility errors. - for _var in list(meas_ds.data_vars) + list(meas_ds.coords): - meas_ds[_var].encoding.clear() dt_in = xr.DataTree.from_dict({"/measurements": meas_ds}) out = str(tmp_path / "out.zarr") convert_olci_optimized(dt_in, output_path=out, min_dimension=256) From ade00deab1b3fc51d3234da6d0f004bbb6c9bea7 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 10:47:10 +0200 Subject: [PATCH 17/58] docs(s3-olci): document Sentinel-3 OLCI export support Add a Supported Products section to README.md and a dedicated Sentinel-3 OLCI L1 EFR Conversion section to docs/converter.md, covering: auto-detection via `eopf-geozarr convert`, the dedicated `convert-s3-olci-optimized` command with all key flags, output layout (measurements + r2/r4/... overviews + conditions/quality passthrough), and the v1 scope note (encoding wiring is a follow-up). Also add `# test: skip` to the first code block in the OLCI implementation plan doc so test_docs.py skips the non-runnable planning snippets. Co-Authored-By: Claude Opus 4.8 --- README.md | 60 +++++++++++++++++++ docs/converter.md | 59 ++++++++++++++++++ .../plans/2026-06-21-sentinel3-olci-export.md | 1 + 3 files changed, 120 insertions(+) diff --git a/README.md b/README.md index 44f3f6ea..76c61960 100644 --- a/README.md +++ b/README.md @@ -283,6 +283,66 @@ Check if a variable is a grid_mapping variable by looking for references to it. Validate that a specific band exists and is complete in the dataset. +## Supported Products + +### Sentinel-2 MSI + +Sentinel-2 MSI (MultiSpectral Instrument) L1C and L2A products are detected +automatically by `eopf-geozarr convert` and routed to the optimized multiscale +layout (`convert-s2-optimized`). The three native resolution groups (10 m, 20 m, +60 m) are reused as-is and coarser overviews (120 m, 360 m, 720 m) are computed +via /2 downsampling. + +### Sentinel-3 OLCI L1 EFR + +Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) +products are detected automatically by `eopf-geozarr convert` and routed to the +dedicated OLCI converter. Unlike Sentinel-2, OLCI data uses **native swath geometry**: +measurements are stored on a per-pixel 2-D lat/lon grid with no reprojection to a +projected CRS. The exporter preserves this curvilinear geometry intact. + +#### Auto-detection + +```bash +eopf-geozarr convert S3A_OL_1_EFR.zarr output.zarr +``` + +#### Dedicated command + +```bash +eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ + --spatial-chunk 1024 \ + --min-dimension 256 \ + --compression-level 3 \ + --enable-sharding \ + --keep-scale-offset +``` + +Key flags: + +- `--spatial-chunk` — target spatial chunk size in pixels (default: 1024) +- `--enable-sharding` — enable Zarr v3 sharding on measurement arrays +- `--compression-level` — Blosc/zstd compression level 1–9 (default: 3) +- `--min-dimension` — stop generating /2 overview levels once either spatial + dimension would drop below this value (default: 256) +- `--keep-scale-offset` — preserve CF `scale_factor`/`add_offset` encoding + instead of decoding to float + +#### What is converted + +- **`/measurements`**: all 21 OLCI radiance bands at native full resolution, with + GeoZarr `spatial:` convention metadata and per-pixel 2-D `latitude`/`longitude` + coordinate arrays. +- **Overview subgroups** (`r2`, `r4`, …): /2-decimated copies of the measurements + stored as sibling Zarr groups under `measurements/`. +- **`/conditions` and `/quality`**: copied through unmodified. + +> **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid +> groups (`conditions/geometry`, `meteorology`, `instrument`) are copied through but +> not converted to GeoZarr convention. Encoding wiring for `--enable-sharding`, +> `--spatial-chunk`, `--compression-level`, and `--keep-scale-offset` is accepted +> but scheduled as a follow-up task. + ## Architecture The library is organized into the following modules: diff --git a/docs/converter.md b/docs/converter.md index 898c251a..b1faa4fd 100644 --- a/docs/converter.md +++ b/docs/converter.md @@ -177,6 +177,65 @@ dt_optimized = convert_s2_optimized( The result is a space-efficient multiscale pyramid: `/measurements/reflectance/{r10m, r20m, r60m, r120m, r360m, r720m}` where the native resolutions are preserved as-is and only the coarser levels are computed. +## Sentinel-3 OLCI L1 EFR Conversion + +Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) +products are supported. OLCI uses **native swath geometry**: measurements are stored +on a per-pixel 2-D lat/lon grid, with no reprojection to a projected CRS. The +exporter preserves this curvilinear geometry intact and generates /2-decimated +overview subgroups for multi-resolution access. + +### Auto-detection + +The generic `convert` command detects OLCI products automatically: + +```bash +eopf-geozarr convert S3A_OL_1_EFR.zarr output.zarr +``` + +### Dedicated command + +A dedicated command offers fine-grained control: + +```bash +eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ + --spatial-chunk 1024 \ + --min-dimension 256 \ + --compression-level 3 \ + --enable-sharding \ + --keep-scale-offset +``` + +| Flag | Default | Description | +|------|---------|-------------| +| `--spatial-chunk` | 1024 | Target spatial chunk size in pixels | +| `--enable-sharding` | off | Enable Zarr v3 sharding on measurement arrays | +| `--compression-level` | 3 | Blosc/zstd compression level (1–9) | +| `--min-dimension` | 256 | Minimum spatial dimension for overview levels | +| `--keep-scale-offset` | off | Preserve CF scale-offset encoding (default: decode to float) | + +### Output layout + +``` +output.zarr/ +├── measurements/ # Native-resolution OLCI bands (oa01_radiance … oa21_radiance) +│ │ # with per-pixel latitude/longitude coordinates +│ ├── r2/ # 1/2-resolution overview +│ ├── r4/ # 1/4-resolution overview +│ └── ... +├── conditions/ # Copied through unmodified (tie-point geometry, meteorology) +└── quality/ # Copied through unmodified (quality flags) +``` + +Each measurement group carries GeoZarr `spatial:` convention metadata and +references the per-pixel 2-D coordinate arrays `latitude` and `longitude`. + +> **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid +> groups in `conditions/geometry`, `meteorology`, and `instrument` are copied +> through but not converted to GeoZarr convention. Encoding wiring for +> `--enable-sharding`, `--spatial-chunk`, `--compression-level`, and +> `--keep-scale-offset` is accepted but scheduled as a follow-up task. + ## Error Handling The converter includes robust error handling and retry logic for network operations, ensuring reliable processing even in challenging environments. diff --git a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md index bd78e396..664fb5ae 100644 --- a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md +++ b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md @@ -59,6 +59,7 @@ OLCI band central wavelengths (nm), Oa01–Oa21: - [ ] **Step 1: Write the failing test** ```python +# test: skip # tests/test_olci_band_mapping.py from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( OLCI_BANDS, From 73a47b9a55cb5ffca5a08a935f6a36d863ca8ec9 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 12:05:29 +0200 Subject: [PATCH 18/58] fix(s3-olci): fill-aware block-avg overviews, multiscales CMO, orphans passthrough, fixture dims MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit FIX 0 — reduce_swath: genuine 2×2 fill-aware block-average for radiance vars (OLCI_BANDS), stride-decimate for 2-D coord arrays (lat/lon/alt); replaces literal [::2,::2] decimation of radiance that added no information. FIX 1 — declare overviews as GeoZarr multiscales: build_convention_attrs now receives a MultiscalesAttrs layout (asset "." + "r2"/"r4"/… with relative scale=[2,2] transform) and writes the CMO to measurements attrs. FIX 2 — copy measurements/orphans through (was silently dropped because to_dataset() discards child groups); iterate dt_input["/measurements"].children and _copy_subtree each one. FIX 3 — fixture dim consistency: renamed tie-point 'columns' → 'tie_columns' in geometry/meteorology arrays, fixed orphan 2-D arrays from [16,16] to [16,4] (removed_pixels=4), fixed instrument 2-D arrays to [bands,detectors] at consistent sizes, fixed 3-D meteo arrays to [4,16,4], fixed nb_removed_pixels shape; xr.open_datatree now opens the whole tree cleanly. Snapshot regenerated (conditions, quality, measurements/orphans, r2 overview). FIX 4 — wire in OLCI_BANDS: is_sentinel3_olci_dataset uses OLCI_BANDS[0], reduce_swath identifies radiance vars via OLCI_BANDS frozenset. FIX 5 — remove --enable-sharding / --keep-scale-offset from README and docs/converter.md copy-paste example; keep them in flags table with "accepted but not yet wired" note. All 31 OLCI tests pass; pyright 0 errors; ruff clean; no typing.Any. Co-Authored-By: Claude Opus 4.8 --- README.md | 9 +- docs/converter.md | 8 +- ...2026-06-21-sentinel3-olci-export-design.md | 22 +- .../s3_olci_optimization/olci_converter.py | 60 +- .../s3_olci_optimization/olci_multiscale.py | 143 +- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 10857 +++++++++++++++- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 2664 ++-- tests/test_olci_integration.py | 30 +- tests/test_olci_multiscale.py | 120 +- 9 files changed, 12038 insertions(+), 1875 deletions(-) diff --git a/README.md b/README.md index 76c61960..fc52893b 100644 --- a/README.md +++ b/README.md @@ -313,20 +313,17 @@ eopf-geozarr convert S3A_OL_1_EFR.zarr output.zarr eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ --spatial-chunk 1024 \ --min-dimension 256 \ - --compression-level 3 \ - --enable-sharding \ - --keep-scale-offset + --compression-level 3 ``` Key flags: - `--spatial-chunk` — target spatial chunk size in pixels (default: 1024) -- `--enable-sharding` — enable Zarr v3 sharding on measurement arrays - `--compression-level` — Blosc/zstd compression level 1–9 (default: 3) - `--min-dimension` — stop generating /2 overview levels once either spatial dimension would drop below this value (default: 256) -- `--keep-scale-offset` — preserve CF `scale_factor`/`add_offset` encoding - instead of decoding to float +- `--enable-sharding` — accepted but not yet wired into encoding (follow-up task) +- `--keep-scale-offset` — accepted but not yet wired into encoding (follow-up task) #### What is converted diff --git a/docs/converter.md b/docs/converter.md index b1faa4fd..39697cb0 100644 --- a/docs/converter.md +++ b/docs/converter.md @@ -201,18 +201,16 @@ A dedicated command offers fine-grained control: eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ --spatial-chunk 1024 \ --min-dimension 256 \ - --compression-level 3 \ - --enable-sharding \ - --keep-scale-offset + --compression-level 3 ``` | Flag | Default | Description | |------|---------|-------------| | `--spatial-chunk` | 1024 | Target spatial chunk size in pixels | -| `--enable-sharding` | off | Enable Zarr v3 sharding on measurement arrays | | `--compression-level` | 3 | Blosc/zstd compression level (1–9) | | `--min-dimension` | 256 | Minimum spatial dimension for overview levels | -| `--keep-scale-offset` | off | Preserve CF scale-offset encoding (default: decode to float) | +| `--enable-sharding` | off | Accepted but not yet wired into encoding (follow-up task) | +| `--keep-scale-offset` | off | Accepted but not yet wired into encoding (follow-up task) | ### Output layout diff --git a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md index 6f0a5f81..6083174f 100644 --- a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md +++ b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md @@ -62,11 +62,23 @@ Consequences: affine transform. We attach 2-D coordinate arrays via CF `coordinates` and the appropriate GeoZarr `spatial`/`proj` metadata for curvilinear data (no `spatial:transform`; lat/lon carried as coordinate arrays). -- Multiscale overviews are produced by **simple /2 decimation** of - `rows`/`columns` (subsample the radiance grid AND the lat/lon/altitude - coordinate arrays together so geolocation stays consistent per level). This is - the COG-style /2 approach minus the projected-grid assumption. (Reprojection - to a regular grid is explicitly a *future* option, not in this deliverable.) +- Multiscale overviews are produced by **2×2 block reduction** of `rows`/`columns`: + - **Radiance bands → block-average** (mean over each 2×2 block), like the S2 + reflectance path. This is a genuine reduction, so each level carries new + information that justifies storing it (a literal `[::2,::2]` *subsample* would + add no information over the base array and must NOT be re-saved). + - **Coordinate arrays (`latitude`/`longitude`/`altitude`) → decimate** + (take a fixed sub-pixel, e.g. block top-left), NOT average — so each overview + pixel's geolocation remains a real measured position rather than an + interpolated one. Radiance and coords are reduced together so each level's + grid stays internally consistent. + - Levels are declared with the GeoZarr **`multiscales`** convention. Per the + multiscales spec, the per-level `transform` holds the **relative** index + relationship (`scale: [2, 2]` from the source level) — which remains valid + for a 2×2 reduction. We do **NOT** emit `spatial:transform` (the absolute + affine), because OLCI has no regular grid; absolute geolocation is carried by + each level's own 2-D lat/lon coordinate arrays. (Reprojection to a regular + grid is explicitly a *future* option, not in this deliverable.) ## Scope (v1): measurements-first diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index ed98553c..1520b9b0 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -2,13 +2,23 @@ from __future__ import annotations +from typing import TYPE_CHECKING, cast + import structlog import xarray as xr import zarr from eopf_geozarr.conversion.utils import build_convention_attrs from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot -from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath, swath_spatial_attrs +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + reduce_swath, + swath_spatial_attrs, +) + +if TYPE_CHECKING: + from zarr.core.common import JSON + from zarr_cm import LayoutObject, MultiscalesAttrs, Transform log = structlog.get_logger() @@ -28,7 +38,7 @@ def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: log.debug("Not an OLCI dataset", error=str(e)) return False try: - return "oa01_radiance" in model.measurements.members + return OLCI_BANDS[0] in model.measurements.members except KeyError: return False @@ -116,9 +126,10 @@ def convert_olci_optimized( """Convert an EOPF OLCI L1 EFR DataTree to a GeoZarr multiscale store. Writes the native-resolution ``measurements`` group with GeoZarr - convention metadata, then writes /2-decimated overview subgroups + convention metadata, then writes /2-reduced overview subgroups (``r2``, ``r4``, …) down to *min_dimension*. Any ``conditions`` or - ``quality`` groups present in *dt_input* are copied through unchanged. + ``quality`` groups present in *dt_input* are copied through unchanged, + along with any child subgroups of ``measurements`` (e.g. ``orphans``). Parameters ---------- @@ -174,10 +185,6 @@ def convert_olci_optimized( # _FillValue) live in .attrs, not .encoding, so they are preserved. measurements = _clear_encoding(measurements) - # Attach GeoZarr spatial convention metadata for native-resolution swath. - conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) - measurements.attrs.update(dict(conv)) - log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) measurements.to_zarr( output_path, @@ -187,7 +194,7 @@ def convert_olci_optimized( zarr_format=3, ) - # Write /2 decimated overview subgroups: r2, r4, r8, … + # Write /2 reduced overview subgroups: r2, r4, r8, … rows = measurements.sizes["rows"] cols = measurements.sizes["columns"] n_levels = _overview_levels(rows, cols, min_dimension) @@ -195,7 +202,7 @@ def convert_olci_optimized( current = measurements for level in range(1, n_levels + 1): - current = decimate_swath(current, factor=2) + current = reduce_swath(current, factor=2) current = _clear_encoding(current) group_name = f"r{2**level}" log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) @@ -207,6 +214,29 @@ def convert_olci_optimized( zarr_format=3, ) + # Build and attach GeoZarr convention metadata (spatial + multiscales CMO) + # to the measurements group attrs. + layout: list[LayoutObject] = [{"asset": "."}] + for lvl in range(1, n_levels + 1): + transform: Transform = {"scale": [2.0, 2.0], "translation": [0.0, 0.0]} + lo: LayoutObject = { + "asset": f"r{2**lvl}", + "derived_from": "." if lvl == 1 else f"r{2 ** (lvl - 1)}", + "transform": transform, + "resampling_method": "average", + } + layout.append(lo) + + if n_levels > 0: + ms: MultiscalesAttrs = {"layout": layout, "resampling_method": "average"} + conv = build_convention_attrs(multiscales=ms, spatial=swath_spatial_attrs(), crs=None) + else: + conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + + zarr.open_group(output_path, mode="a")["measurements"].attrs.update( + cast("dict[str, JSON]", conv) + ) + # Copy conditions/quality through unchanged (if present). # DataTree.to_zarr does not support a root ``group`` argument, so we # iterate the subtree and write each leaf Dataset individually. @@ -220,6 +250,16 @@ def convert_olci_optimized( log.info("Copying ancillary group", group=grp) _copy_subtree(node_item, output_path, root_group=grp) + # Copy any child subgroups of measurements (e.g. orphans) through unchanged. + try: + meas_node = dt_input["/measurements"] + except KeyError: + meas_node = None + if isinstance(meas_node, xr.DataTree): + for child in meas_node.children.values(): + log.info("Copying measurements subgroup", group=f"measurements/{child.name}") + _copy_subtree(child, output_path, root_group=f"measurements/{child.name}") + # xarray DataTree enforces dimension consistency between parent and child # nodes, so opening the whole store via ``xr.open_datatree`` would fail # because the overview subgroups have smaller spatial dimensions than diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index b61641e0..76fbfed9 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -1,18 +1,29 @@ """Multiscale (overview) generation for OLCI swath data. -OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays, -so overviews are produced by /2 decimation of the (rows, columns) grid: every -2-D variable and its 2-D coordinate arrays are subsampled together, keeping -geolocation exact. (Averaging is intentionally avoided — an averaged lat/lon -would not correspond to a real pixel.) +OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays. +Two reduction strategies are provided: + +* :func:`decimate_swath` — pure stride-based decimation; every (rows, columns) + variable is subsampled ``[::factor, ::factor]``. Geolocation (lat/lon) is + kept exact; intended for coordinate arrays and cases where preserving pixel + identity matters. + +* :func:`reduce_swath` — radiance bands are fill-aware block-averaged + (mean of ``factor x factor`` blocks) while coordinate arrays are decimated + with :func:`decimate_swath`; non-swath variables pass through unchanged. + Intended for producing GeoZarr multiscale overview groups. """ from __future__ import annotations from typing import TYPE_CHECKING +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS + if TYPE_CHECKING: - import xarray as xr from zarr_cm import SpatialAttrs SWATH_DIMS = ("rows", "columns") @@ -22,7 +33,7 @@ def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: """Return *ds* with every (rows, columns) array subsampled by *factor*. Both data variables and coordinate variables that span exactly the swath - dims are decimated `[::factor, ::factor]`; everything else is passed + dims are decimated ``[::factor, ::factor]``; everything else is passed through unchanged. Attributes and encoding are preserved by xarray's isel. """ if factor < 1: @@ -35,6 +46,124 @@ def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: return ds.isel(indexers) +def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with radiance bands block-averaged and 2-D coordinates decimated. + + Overviews are an unweighted index-block mean that ASSUMES locally-uniform + pixel spacing; intended for visualization, not quantitative analysis at + reduced resolution. Coordinates are decimated (real sub-pixels), radiance + is fill-aware block-averaged. + + Radiance variables (those named in :data:`OLCI_BANDS`) are averaged over + ``factor x factor`` pixel blocks with fill-value awareness: fill pixels + are masked before averaging so a single fill pixel does not contaminate + the entire block. Blocks where ALL pixels are fill are set back to the + fill value in the output. + + 2-D coordinate variables spanning exactly ``(rows, columns)`` and **not** + in :data:`OLCI_BANDS` (e.g. latitude, longitude, altitude) are decimated + ``[::factor, ::factor]`` to preserve real on-ground positions. + + Variables that do not span exactly ``(rows, columns)`` are passed through + unchanged. + + Parameters + ---------- + ds: + Input dataset. May contain any mix of radiance bands, 2-D coordinate + arrays, and other variables. + factor: + Spatial reduction factor. Must be >= 1. Factor 1 returns *ds* + unchanged. + + Returns + ------- + xr.Dataset + Reduced dataset with the same variables but smaller (rows, columns) + dimensions. + + Raises + ------ + ValueError + If *factor* < 1. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + + olci_band_set: frozenset[str] = frozenset(OLCI_BANDS) + result_vars: dict[str, xr.DataArray] = {} + result_coords: dict[str, xr.DataArray] = {} + + coord_names: frozenset[str] = frozenset(str(k) for k in ds.coords) + + all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] + for name in all_names: + var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] + is_swath_2d: bool = tuple(str(d) for d in var.dims) == SWATH_DIMS + + if name in olci_band_set and is_swath_2d: + # Fill-aware block averaging for radiance bands. + fill_value: int | float | None = var.attrs.get("_FillValue") + if fill_value is None: + fill_value = var.encoding.get("_FillValue") + orig_dtype = var.dtype + + float_var = var.astype("float64") + if fill_value is not None: + float_var = float_var.where(float_var != float(fill_value)) + + # coarsen().mean() is available at runtime; pyright stubs don't expose .mean() + # on DataArrayCoarsen, so we suppress the type-check on the reduction call. + coarsened = float_var.coarsen({"rows": factor, "columns": factor}, boundary="trim") + averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] + + if fill_value is not None: + fill_da = xr.where(averaged.isnull(), float(fill_value), averaged) + result_val = np.round(fill_da.values).astype(orig_dtype) + else: + result_val = np.round(averaged.values).astype(orig_dtype) + + out_var = xr.DataArray(result_val, dims=averaged.dims, attrs=var.attrs) + + if name in ds.data_vars: + result_vars[name] = out_var + else: + result_coords[name] = out_var + + elif is_swath_2d: + # Coordinate or non-radiance 2-D swath variable: decimate. + indexers: dict[str, slice] = {dim: slice(None, None, factor) for dim in SWATH_DIMS} + decimated = var.isel(indexers) + if name in coord_names: + result_coords[name] = decimated + else: + result_vars[name] = decimated + + elif any(dim in (str(d) for d in var.dims) for dim in SWATH_DIMS): + # 1-D (or higher) variable sharing a swath dim but not 2-D swath: + # decimate along whichever swath dims it carries. + var_dims = {str(d) for d in var.dims} + idx: dict[str, slice] = { + dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in var_dims + } + decimated = var.isel(idx) + if name in coord_names: + result_coords[name] = decimated + else: + result_vars[name] = decimated + + else: + # Non-swath variable: pass through unchanged. + if name in coord_names: + result_coords[name] = var + else: + result_vars[name] = var + + return xr.Dataset(result_vars, coords=result_coords) + + def swath_spatial_attrs( dims: tuple[str, str] = SWATH_DIMS, ) -> SpatialAttrs: diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index 4cb98e61..e0e241a4 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -1,14 +1,2345 @@ { "attributes": {}, "members": { + "conditions": { + "attributes": {}, + "members": { + "geometry": { + "attributes": {}, + "members": { + "latitude": { + "attributes": { + "_FillValue": "AAAAAAAA+H8=", + "dimensions": [ + "rows", + "columns" + ], + "dtype": " None: ) } ) + # Build a measurements/orphans sub-dataset to verify child subgroup copy. + orphans_ds = xr.Dataset( + { + "removed_count": xr.DataArray( + rng.integers(0, 10, (rows,)).astype("int32"), dims=("rows",) + ) + } + ) dt = xr.DataTree.from_dict( { "/measurements": meas_ds, + "/measurements/orphans": orphans_ds, "/conditions": cond_ds, "/quality": quality_ds, } @@ -194,6 +203,8 @@ def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: g = zarr.open_group(out, mode="r") assert "conditions" in g assert "quality" in g + # measurements/orphans subgroup must have been copied through. + assert "orphans" in g["measurements"] def test_cli_convert_s3_olci_optimized(tmp_path: pathlib.Path) -> None: @@ -232,26 +243,25 @@ def test_olci_conversion_matches_snapshot( """Snapshot test: converted OLCI structure must match committed golden file. The fixture is a Zarr v2 store representing a real OLCI L1 EFR product. - We open just the ``/measurements`` group (the converter's input is a - DataTree rooted at this sub-tree) and wrap it in a minimal DataTree. - The ``time_stamp`` array is included: its ``rows`` dimension now matches - the spatial arrays (both 16), so no ``drop_variables`` workaround is - needed. Inherited Zarr v2 encoding is stripped inside the converter, so - no ``encoding.clear()`` workaround is needed here either. + We open the whole DataTree so that conditions, quality, and + measurements/orphans subgroups are included in the conversion. + The fixture has been fixed so all dimension/shape conflicts are resolved + (tie-point grids use 'tie_columns', orphan arrays use removed_pixels=4, etc.). + + ``min_dimension=8`` is used so that the 16x16 measurements grid generates + one overview level (r2 at 8x8). To (re)generate the snapshot, uncomment the regeneration block below, run the test once, then re-comment before committing. """ - meas_ds = xr.open_dataset( + dt_in = xr.open_datatree( str(s3_olci_group_example), engine="zarr", - group="measurements", consolidated=False, chunks={}, ) - dt_in = xr.DataTree.from_dict({"/measurements": meas_ds}) out = str(tmp_path / "out.zarr") - convert_olci_optimized(dt_in, output_path=out, min_dimension=256) + convert_olci_optimized(dt_in, output_path=out, min_dimension=8) observed_group = zarr.open_group(out, use_consolidated=False) observed_structure_json = GroupSpec.from_zarr(observed_group).model_dump() diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index e1480a2e..08d95ab1 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -1,17 +1,28 @@ +"""Tests for olci_multiscale: decimate_swath, reduce_swath, swath_spatial_attrs.""" + +from __future__ import annotations + import numpy as np +import pytest import xarray as xr from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( decimate_swath, + reduce_swath, swath_spatial_attrs, ) def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: + """Minimal synthetic swath dataset with one radiance band and two coords.""" rad = xr.DataArray( np.arange(rows * cols, dtype="uint16").reshape(rows, cols), dims=("rows", "columns"), - attrs={"scale_factor": 0.5, "units": "mW.m-2.sr-1.nm-1"}, + attrs={ + "scale_factor": 0.5, + "units": "mW.m-2.sr-1.nm-1", + "_FillValue": 65535, + }, ) lat = xr.DataArray( np.linspace(0, 1, rows * cols).reshape(rows, cols), @@ -29,6 +40,11 @@ def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: ) +# --------------------------------------------------------------------------- +# decimate_swath tests +# --------------------------------------------------------------------------- + + def test_decimate_halves_each_axis() -> None: out = decimate_swath(_swath(8, 6), factor=2) assert out["oa01_radiance"].shape == (4, 3) @@ -52,6 +68,108 @@ def test_decimate_preserves_attrs() -> None: assert out["latitude"].attrs["standard_name"] == "latitude" +def test_decimate_factor_1_returns_unchanged() -> None: + ds = _swath(8, 6) + out = decimate_swath(ds, factor=1) + assert out["oa01_radiance"].shape == (8, 6) + + +def test_decimate_invalid_factor_raises() -> None: + with pytest.raises(ValueError, match="factor must be >= 1"): + decimate_swath(_swath(), factor=0) + + +# --------------------------------------------------------------------------- +# reduce_swath tests +# --------------------------------------------------------------------------- + + +def test_reduce_swath_halves_each_axis() -> None: + """reduce_swath must produce output with halved spatial dims.""" + out = reduce_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_reduce_swath_radiance_is_averaged_not_decimated() -> None: + """Radiance must be block-averaged; top-left output != top-left input (unless accident).""" + rng = np.random.default_rng(42) + rad_data = rng.integers(100, 200, (8, 6)).astype("uint16") + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # block [0:2, 0:2] averages to a value; verify it's a rounded mean + expected_block = int(np.round(rad_data[0:2, 0:2].astype("float64").mean())) + assert int(out["oa01_radiance"].values[0, 0]) == expected_block + + +def test_reduce_swath_coordinates_decimated() -> None: + """Coordinate arrays must be decimated (stride), not averaged.""" + ds = _swath(8, 6) + out = reduce_swath(ds, factor=2) + # lat[0,0] in output == lat[0,0] in input + assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) + # lat[1,1] in output == lat[2,2] in input (stride-2) + assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + + +def test_reduce_swath_fill_value_preserved_in_all_fill_block() -> None: + """A block where all pixels are fill must produce fill output, not 65535.0 average.""" + fill = 65535 + rad_data = np.ones((4, 4), dtype="uint16") * fill + # put some non-fill values only in lower-right block + rad_data[2:4, 2:4] = 100 + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": fill}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # top-left block: all fill -> output must be fill + assert int(out["oa01_radiance"].values[0, 0]) == fill + # bottom-right block: all 100 -> output must be 100 + assert int(out["oa01_radiance"].values[1, 1]) == 100 + + +def test_reduce_swath_preserves_attrs() -> None: + """reduce_swath must carry over variable attributes.""" + out = reduce_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" + + +def test_reduce_swath_factor_1_returns_unchanged() -> None: + ds = _swath(8, 6) + out = reduce_swath(ds, factor=1) + assert out["oa01_radiance"].shape == (8, 6) + + +def test_reduce_swath_invalid_factor_raises() -> None: + with pytest.raises(ValueError, match="factor must be >= 1"): + reduce_swath(_swath(), factor=0) + + +def test_reduce_swath_non_swath_var_passthrough() -> None: + """Variables that don't span (rows, columns) must pass through unchanged.""" + ds = _swath(8, 6) + scalar = xr.DataArray(42.0, attrs={"info": "scalar"}) + ds = ds.assign({"extra": scalar}) + out = reduce_swath(ds, factor=2) + assert "extra" in out + assert float(out["extra"].values) == 42.0 + + +# --------------------------------------------------------------------------- +# swath_spatial_attrs tests +# --------------------------------------------------------------------------- + + def test_swath_spatial_attrs_has_no_transform() -> None: attrs = swath_spatial_attrs() assert attrs["spatial:dimensions"] == ["rows", "columns"] From 3849b24ea9e428d6b2d59e536e94cfaab0279689 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 13:00:12 +0200 Subject: [PATCH 19/58] fix(s3-olci): restore faithful 'columns' dim name in OLCI fixture (revert tie_columns); regen snapshot Co-Authored-By: Claude Opus 4.8 --- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 80 +++++++++---------- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 80 +++++++++---------- tests/test_olci_integration.py | 5 +- 3 files changed, 83 insertions(+), 82 deletions(-) diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index e0e241a4..df5df18d 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -57,7 +57,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -118,7 +118,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -190,7 +190,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -262,7 +262,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -334,7 +334,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -406,7 +406,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -817,7 +817,7 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 4 + 8 ] }, "name": "regular" @@ -850,7 +850,7 @@ "fill_value": 0, "node_type": "array", "shape": [ - 4 + 8 ], "storage_transformers": [], "zarr_format": 3 @@ -882,8 +882,8 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 16, - 4 + 21, + 8 ] }, "name": "regular" @@ -917,8 +917,8 @@ "fill_value": "NaN", "node_type": "array", "shape": [ - 16, - 4 + 21, + 8 ], "storage_transformers": [], "zarr_format": 3 @@ -950,8 +950,8 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 16, - 4 + 21, + 8 ] }, "name": "regular" @@ -985,8 +985,8 @@ "fill_value": "NaN", "node_type": "array", "shape": [ - 16, - 4 + 21, + 8 ], "storage_transformers": [], "zarr_format": 3 @@ -1011,8 +1011,8 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 16, - 4 + 21, + 21 ] }, "name": "regular" @@ -1046,8 +1046,8 @@ "fill_value": "NaN", "node_type": "array", "shape": [ - 16, - 4 + 21, + 21 ], "storage_transformers": [], "zarr_format": 3 @@ -1079,8 +1079,8 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 16, - 4 + 21, + 8 ] }, "name": "regular" @@ -1114,8 +1114,8 @@ "fill_value": "NaN", "node_type": "array", "shape": [ - 16, - 4 + 21, + 8 ], "storage_transformers": [], "zarr_format": 3 @@ -1160,7 +1160,7 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 4, + 5, 16, 4 ] @@ -1192,12 +1192,12 @@ "dimension_names": [ "pressure_level", "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", "shape": [ - 4, + 5, 16, 4 ], @@ -1235,7 +1235,7 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 4, + 2, 16, 4 ] @@ -1267,12 +1267,12 @@ "dimension_names": [ "wind_vector", "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", "shape": [ - 4, + 2, 16, 4 ], @@ -1340,7 +1340,7 @@ "data_type": "float32", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1401,7 +1401,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1462,7 +1462,7 @@ "data_type": "float64", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1484,7 +1484,7 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 4 + 5 ] }, "name": "regular" @@ -1517,7 +1517,7 @@ "fill_value": 0, "node_type": "array", "shape": [ - 4 + 5 ], "storage_transformers": [], "zarr_format": 3 @@ -1583,7 +1583,7 @@ "data_type": "float32", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1655,7 +1655,7 @@ "data_type": "float32", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1727,7 +1727,7 @@ "data_type": "float32", "dimension_names": [ "rows", - "tie_columns" + "columns" ], "fill_value": "NaN", "node_type": "array", @@ -1749,7 +1749,7 @@ "chunk_grid": { "configuration": { "chunk_shape": [ - 4 + 2 ] }, "name": "regular" @@ -1782,7 +1782,7 @@ "fill_value": 0, "node_type": "array", "shape": [ - 4 + 2 ], "storage_transformers": [], "zarr_format": 3 diff --git a/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index 465f4787..89b91449 100644 --- a/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -2002,7 +2002,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "dimensions": [ "rows", @@ -2044,7 +2044,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "dimensions": [ "rows", @@ -2086,7 +2086,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2139,7 +2139,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2192,7 +2192,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2245,7 +2245,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2577,7 +2577,7 @@ "long_name": "instrument detectors" }, "chunks": [ - 4 + 8 ], "compressor": { "blocksize": 0, @@ -2591,7 +2591,7 @@ "filters": null, "order": "C", "shape": [ - 4 + 8 ], "zarr_format": 2 }, @@ -2623,8 +2623,8 @@ "units": "nm" }, "chunks": [ - 16, - 4 + 21, + 8 ], "compressor": { "blocksize": 0, @@ -2638,8 +2638,8 @@ "filters": null, "order": "C", "shape": [ - 16, - 4 + 21, + 8 ], "zarr_format": 2 }, @@ -2671,8 +2671,8 @@ "units": "nm" }, "chunks": [ - 16, - 4 + 21, + 8 ], "compressor": { "blocksize": 0, @@ -2686,8 +2686,8 @@ "filters": null, "order": "C", "shape": [ - 16, - 4 + 21, + 8 ], "zarr_format": 2 }, @@ -2712,8 +2712,8 @@ "long_name": "relative spectral covariance matrix" }, "chunks": [ - 16, - 4 + 21, + 21 ], "compressor": { "blocksize": 0, @@ -2727,8 +2727,8 @@ "filters": null, "order": "C", "shape": [ - 16, - 4 + 21, + 21 ], "zarr_format": 2 }, @@ -2760,8 +2760,8 @@ "units": "mW.m-2.nm-1" }, "chunks": [ - 16, - 4 + 21, + 8 ], "compressor": { "blocksize": 0, @@ -2775,8 +2775,8 @@ "filters": null, "order": "C", "shape": [ - 16, - 4 + 21, + 8 ], "zarr_format": 2 } @@ -2791,7 +2791,7 @@ "_ARRAY_DIMENSIONS": [ "pressure_level", "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2821,7 +2821,7 @@ "units": "K" }, "chunks": [ - 4, + 5, 16, 4 ], @@ -2837,7 +2837,7 @@ "filters": null, "order": "C", "shape": [ - 4, + 5, 16, 4 ], @@ -2848,7 +2848,7 @@ "_ARRAY_DIMENSIONS": [ "wind_vector", "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2876,7 +2876,7 @@ "units": "m.s-1" }, "chunks": [ - 4, + 2, 16, 4 ], @@ -2892,7 +2892,7 @@ "filters": null, "order": "C", "shape": [ - 4, + 2, 16, 4 ], @@ -2902,7 +2902,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -2954,7 +2954,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "dimensions": [ "rows", @@ -2996,7 +2996,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "dimensions": [ "rows", @@ -3046,7 +3046,7 @@ "long_name": "coordinates of the vertical temperature profile" }, "chunks": [ - 4 + 5 ], "compressor": { "blocksize": 0, @@ -3060,7 +3060,7 @@ "filters": null, "order": "C", "shape": [ - 4 + 5 ], "zarr_format": 2 }, @@ -3068,7 +3068,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -3120,7 +3120,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -3172,7 +3172,7 @@ "attributes": { "_ARRAY_DIMENSIONS": [ "rows", - "tie_columns" + "columns" ], "_eopf_attrs": { "coordinates": [ @@ -3232,7 +3232,7 @@ "long_name": "dimensions of horizontal wind vector" }, "chunks": [ - 4 + 2 ], "compressor": { "blocksize": 0, @@ -3246,7 +3246,7 @@ "filters": null, "order": "C", "shape": [ - 4 + 2 ], "zarr_format": 2 } diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index 922a3044..baf57a25 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -245,8 +245,9 @@ def test_olci_conversion_matches_snapshot( The fixture is a Zarr v2 store representing a real OLCI L1 EFR product. We open the whole DataTree so that conditions, quality, and measurements/orphans subgroups are included in the conversion. - The fixture has been fixed so all dimension/shape conflicts are resolved - (tie-point grids use 'tie_columns', orphan arrays use removed_pixels=4, etc.). + The fixture uses the real product's dimension names: tie-point grids reuse + 'columns' (at size 4) while measurement grids also use 'columns' (at size 16); + orphan arrays use removed_pixels=4. ``min_dimension=8`` is used so that the 16x16 measurements grid generates one overview level (r2 at 8x8). From 43d4bf030c8ffe81f63bbdab00e9388a818ba445 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 13:36:23 +0200 Subject: [PATCH 20/58] fix(s3-olci): open with mask_and_scale=False; sanitize stale attrs; regen snapshot - CLI and snapshot test now open OLCI source with mask_and_scale=False so radiance stays uint16 with scale_factor/_FillValue in .attrs; CF decoding no longer silently strips scale/offset or widens dtype to float64. - Add _sanitize_data_vars() in olci_converter.py: strips _eopf_attrs, dtype, valid_min, valid_max from measurement data-var attrs before writing to GeoZarr store (both native and overviews); preserves _FillValue, scale_factor, add_offset, units, standard_name, coordinates. - Update sanitize_array_attrs() in conversion/utils.py: always strip _eopf_attrs/dtype/valid_min/valid_max; only strip _FillValue when is_decoded_float=True (raw-integer path keeps it in attrs for downstream fill handling). - Update _clear_encoding docstring: clarify converter expects raw (non-mask-scaled) input; only Zarr v2 codec encoding is stripped. - Regenerate snapshot: oa01_radiance dtype=uint16, scale_factor/add_offset/ _FillValue present, no _eopf_attrs/dtype/valid_min/valid_max. - Add _assert_radiance_dtype_and_attrs() regression guard in snapshot test. Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/cli.py | 6 +- src/eopf_geozarr/conversion/utils.py | 27 +- .../s3_olci_optimization/olci_converter.py | 47 +- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 2219 +++++------------ tests/test_olci_integration.py | 35 + 5 files changed, 727 insertions(+), 1607 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 52c4b3e6..8177052f 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -1310,7 +1310,11 @@ def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: """Execute S3 OLCI optimized conversion command.""" storage_options = get_storage_options(str(args.input_path)) dt_input = xr.open_datatree( - str(args.input_path), engine="zarr", chunks="auto", storage_options=storage_options + str(args.input_path), + engine="zarr", + chunks="auto", + storage_options=storage_options, + mask_and_scale=False, ) convert_olci_optimized( dt_input, diff --git a/src/eopf_geozarr/conversion/utils.py b/src/eopf_geozarr/conversion/utils.py index ff5e8d2c..e53b79cb 100644 --- a/src/eopf_geozarr/conversion/utils.py +++ b/src/eopf_geozarr/conversion/utils.py @@ -112,18 +112,29 @@ def sanitize_array_attrs( ) -> dict[str, Any]: """Return a copy of *attrs* with source-only and misleading keys removed. - - ``_eopf_attrs`` is always removed. - - For decoded float measurement arrays (*is_decoded_float=True*), also - removes raw-encoding leftovers ``dtype``, ``fill_value``, - ``valid_min``, ``valid_max`` and rewrites - ``units: "digital_counts"`` → ``"1"``. + Always removed: + - ``_eopf_attrs`` — internal EOPF provenance blob, not a CF/GeoZarr attr. + - ``dtype`` — source storage dtype hint; misleading after conversion. + - ``valid_min``, ``valid_max`` — source-domain integer bounds; not meaningful + in GeoZarr output and absent from CF conventions for radiance bands. + + When ``is_decoded_float=True`` (caller has already CF-decoded the array to + float), ``_FillValue`` is also removed because it has been consumed by + xarray into ``.encoding`` and is no longer meaningful in ``.attrs``. + ``units: "digital_counts"`` is rewritten to ``"1"`` to match the decoded + physical-unit convention. + + When ``is_decoded_float=False`` (raw integer / mask-and-scale=False path), + ``_FillValue`` is **preserved** in attrs so that downstream code (e.g. + ``reduce_swath``) and Zarr readers can identify fill pixels without + requiring CF decoding. CF keys ``scale_factor`` and ``add_offset`` are always preserved. """ - out = {k: v for k, v in attrs.items() if k not in ("_eopf_attrs", "_FillValue")} + _always_strip = ("_eopf_attrs", "dtype", "valid_min", "valid_max") + out = {k: v for k, v in attrs.items() if k not in _always_strip} if is_decoded_float: - for key in ("dtype", "fill_value", "valid_min", "valid_max"): - out.pop(key, None) + out.pop("_FillValue", None) if out.get("units") == "digital_counts": out["units"] = "1" return out diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 1520b9b0..3542222f 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -8,7 +8,7 @@ import xarray as xr import zarr -from eopf_geozarr.conversion.utils import build_convention_attrs +from eopf_geozarr.conversion.utils import build_convention_attrs, sanitize_array_attrs from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( @@ -73,8 +73,12 @@ def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: because numcodecs codecs are not valid Zarr v3 BytesBytesCodecs. Clearing the encoding lets the Zarr v3 writer choose its own default codecs. - CF attributes (``scale_factor``, ``add_offset``, ``_FillValue``) live in - ``.attrs``, not ``.encoding``, so they are preserved by this function. + This converter expects raw (non-mask-scaled) input: the caller must open + the source DataTree with ``mask_and_scale=False`` so that CF + ``scale_factor``/``add_offset`` stay in ``.attrs`` and integer fill pixels + are identified via ``attrs["_FillValue"]``. Only Zarr v2 *codec* encoding + (e.g. ``numcodecs.Blosc`` compressors) is stripped here — CF metadata is + untouched. """ ds = ds.copy() ds.encoding = {} @@ -83,6 +87,31 @@ def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: return ds +def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: + """Return *ds* with stale source attrs stripped from all data variables. + + Applies :func:`~eopf_geozarr.conversion.utils.sanitize_array_attrs` with + ``is_decoded_float=False`` to every data variable in *ds*. Coordinate + variable attrs are left intact. + + This removes ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` + (source-only / misleading) while preserving CF attrs + (``scale_factor``, ``add_offset``, ``_FillValue``, ``units``, + ``standard_name``, ``coordinates``). + + Note: ``xr.DataArray.assign_attrs`` *merges* (update semantics), so we + copy the DataArray and replace ``.attrs`` in-place to ensure stale keys + are actually removed rather than retained from the old dict. + """ + new_vars: dict[str, xr.DataArray] = {} + for name in ds.data_vars: + var = ds[name] + new_var = var.copy(data=var.data) + new_var.attrs = sanitize_array_attrs(dict(var.attrs), is_decoded_float=False) + new_vars[str(name)] = new_var + return ds.assign(new_vars) + + def _copy_subtree(node: xr.DataTree, output_path: str, *, root_group: str) -> None: """Write every Dataset in *node*'s subtree to the Zarr store at *output_path*. @@ -181,9 +210,15 @@ def convert_olci_optimized( measurements = dt_input["/measurements"].to_dataset() # Strip any inherited Zarr v2 encoding (e.g. numcodecs.Blosc compressors) # so the v3 writer can choose its own default codecs without raising a - # "Expected a BytesBytesCodec" error. CF attrs (scale_factor, add_offset, - # _FillValue) live in .attrs, not .encoding, so they are preserved. + # "Expected a BytesBytesCodec" error. The caller is expected to have opened + # the source with mask_and_scale=False, so CF attrs (scale_factor, + # add_offset, _FillValue) live in .attrs and are preserved here. measurements = _clear_encoding(measurements) + # Sanitize radiance variable attrs: strip source-only / misleading attrs + # (_eopf_attrs, dtype, valid_min, valid_max) while keeping CF scale/offset + # and _FillValue so that downstream readers and reduce_swath can work + # correctly with raw integer data. + measurements = _sanitize_data_vars(measurements) log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) measurements.to_zarr( @@ -204,6 +239,8 @@ def convert_olci_optimized( for level in range(1, n_levels + 1): current = reduce_swath(current, factor=2) current = _clear_encoding(current) + # Attrs already sanitized at native level and passed through by + # reduce_swath; no second sanitize pass needed. group_name = f"r{2**level}" log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) current.to_zarr( diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index df5df18d..a5dc9079 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -9,7 +9,6 @@ "members": { "latitude": { "attributes": { - "_FillValue": "AAAAAAAA+H8=", "dimensions": [ "rows", "columns" @@ -19,6 +18,7 @@ "eopf_target_dtype": " None: assert "measurements" in g +def _assert_radiance_dtype_and_attrs( + group: zarr.Group, band_name: str, *, level_label: str +) -> None: + """Assert that *band_name* in *group* is uint16 with scale_factor and no stale attrs. + + This is a regression guard: the converter must preserve raw integer storage + and CF scale/offset, and must strip source-only attrs (_eopf_attrs, dtype, + valid_min, valid_max). + """ + band = group[band_name] + assert isinstance(band, zarr.Array), f"{level_label}/{band_name} is not a zarr.Array" + assert band.dtype == np.dtype("uint16"), ( + f"{level_label}/{band_name}: expected uint16, got {band.dtype}" + ) + attrs = dict(band.attrs) + assert "scale_factor" in attrs, ( + f"{level_label}/{band_name}: scale_factor missing from attrs (got {list(attrs)})" + ) + for stale_key in ("_eopf_attrs", "dtype", "valid_min", "valid_max"): + assert stale_key not in attrs, ( + f"{level_label}/{band_name}: stale attr '{stale_key}' present in output attrs" + ) + + def test_olci_conversion_matches_snapshot( s3_olci_group_example: pathlib.Path, tmp_path: pathlib.Path, @@ -260,6 +284,7 @@ def test_olci_conversion_matches_snapshot( engine="zarr", consolidated=False, chunks={}, + mask_and_scale=False, ) out = str(tmp_path / "out.zarr") convert_olci_optimized(dt_in, output_path=out, min_dimension=8) @@ -285,3 +310,13 @@ def test_olci_conversion_matches_snapshot( e_keys = set(expected_structure_flat.keys()) assert o_keys == e_keys assert [k for k in o_keys if observed_structure_flat[k] != expected_structure_flat[k]] == [] + + # Dtype/attrs regression guard: radiance must be stored as uint16 with + # scale_factor preserved and stale source attrs absent. + meas_g = observed_group["measurements"] + assert isinstance(meas_g, zarr.Group) + _assert_radiance_dtype_and_attrs(meas_g, "oa01_radiance", level_label="native") + if "r2" in meas_g: + r2_g = meas_g["r2"] + assert isinstance(r2_g, zarr.Group) + _assert_radiance_dtype_and_attrs(r2_g, "oa01_radiance", level_label="r2") From a0cf79061f28ebd1289a201f3f1f8ae2ceb31228 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 22 Jun 2026 15:49:17 +0200 Subject: [PATCH 21/58] fix: revert shared sanitize_array_attrs to pre-OLCI semantics; add OLCI-local attr sanitizer The OLCI work modified the shared sanitize_array_attrs in conversion/utils.py, changing S2/S1/generic output attrs and breaking 3 S2 golden-file snapshot tests. - Restore sanitize_array_attrs to c613e24 original: always strips _eopf_attrs + _FillValue; strips dtype/fill_value/valid_min/valid_max and rewrites digital_counts units only when is_decoded_float=True. - Add _sanitize_olci_array_attrs in olci_converter.py: strips _eopf_attrs/dtype/ valid_min/valid_max while preserving _FillValue (needed for raw uint16 data opened with mask_and_scale=False). - Replace sanitize_array_attrs usage in _sanitize_data_vars with the new helper. - Add unit test asserting _FillValue is preserved and stale keys are stripped. Co-Authored-By: Claude Opus 4.8 --- src/eopf_geozarr/conversion/utils.py | 27 ++++---------- .../s3_olci_optimization/olci_converter.py | 27 +++++++++++--- tests/test_olci_integration.py | 37 +++++++++++++++++++ 3 files changed, 67 insertions(+), 24 deletions(-) diff --git a/src/eopf_geozarr/conversion/utils.py b/src/eopf_geozarr/conversion/utils.py index e53b79cb..ff5e8d2c 100644 --- a/src/eopf_geozarr/conversion/utils.py +++ b/src/eopf_geozarr/conversion/utils.py @@ -112,29 +112,18 @@ def sanitize_array_attrs( ) -> dict[str, Any]: """Return a copy of *attrs* with source-only and misleading keys removed. - Always removed: - - ``_eopf_attrs`` — internal EOPF provenance blob, not a CF/GeoZarr attr. - - ``dtype`` — source storage dtype hint; misleading after conversion. - - ``valid_min``, ``valid_max`` — source-domain integer bounds; not meaningful - in GeoZarr output and absent from CF conventions for radiance bands. - - When ``is_decoded_float=True`` (caller has already CF-decoded the array to - float), ``_FillValue`` is also removed because it has been consumed by - xarray into ``.encoding`` and is no longer meaningful in ``.attrs``. - ``units: "digital_counts"`` is rewritten to ``"1"`` to match the decoded - physical-unit convention. - - When ``is_decoded_float=False`` (raw integer / mask-and-scale=False path), - ``_FillValue`` is **preserved** in attrs so that downstream code (e.g. - ``reduce_swath``) and Zarr readers can identify fill pixels without - requiring CF decoding. + - ``_eopf_attrs`` is always removed. + - For decoded float measurement arrays (*is_decoded_float=True*), also + removes raw-encoding leftovers ``dtype``, ``fill_value``, + ``valid_min``, ``valid_max`` and rewrites + ``units: "digital_counts"`` → ``"1"``. CF keys ``scale_factor`` and ``add_offset`` are always preserved. """ - _always_strip = ("_eopf_attrs", "dtype", "valid_min", "valid_max") - out = {k: v for k, v in attrs.items() if k not in _always_strip} + out = {k: v for k, v in attrs.items() if k not in ("_eopf_attrs", "_FillValue")} if is_decoded_float: - out.pop("_FillValue", None) + for key in ("dtype", "fill_value", "valid_min", "valid_max"): + out.pop(key, None) if out.get("units") == "digital_counts": out["units"] = "1" return out diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 3542222f..462fb395 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -8,7 +8,7 @@ import xarray as xr import zarr -from eopf_geozarr.conversion.utils import build_convention_attrs, sanitize_array_attrs +from eopf_geozarr.conversion.utils import build_convention_attrs from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( @@ -23,6 +23,24 @@ log = structlog.get_logger() +def _sanitize_olci_array_attrs(attrs: dict[str, object]) -> dict[str, object]: + """Return a copy of *attrs* with stale source-only keys removed. + + Strips ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` (source + provenance and raw-integer-domain metadata that is misleading in GeoZarr + output). Unlike the shared :func:`~eopf_geozarr.conversion.utils.sanitize_array_attrs`, + this helper intentionally **preserves** ``_FillValue`` because OLCI input is + opened with ``mask_and_scale=False`` (raw uint16) and downstream code (e.g. + ``reduce_swath``) needs ``_FillValue`` in ``.attrs`` to identify fill pixels + without CF decoding. + + CF keys ``scale_factor``, ``add_offset``, ``units``, ``standard_name``, + ``coordinates``, and ``long_name`` are always preserved. + """ + _strip = frozenset(("_eopf_attrs", "dtype", "valid_min", "valid_max")) + return {k: v for k, v in attrs.items() if k not in _strip} + + def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. @@ -90,9 +108,8 @@ def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: """Return *ds* with stale source attrs stripped from all data variables. - Applies :func:`~eopf_geozarr.conversion.utils.sanitize_array_attrs` with - ``is_decoded_float=False`` to every data variable in *ds*. Coordinate - variable attrs are left intact. + Applies :func:`_sanitize_olci_array_attrs` to every data variable in *ds*. + Coordinate variable attrs are left intact. This removes ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` (source-only / misleading) while preserving CF attrs @@ -107,7 +124,7 @@ def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: for name in ds.data_vars: var = ds[name] new_var = var.copy(data=var.data) - new_var.attrs = sanitize_array_attrs(dict(var.attrs), is_decoded_float=False) + new_var.attrs = _sanitize_olci_array_attrs(dict(var.attrs)) new_vars[str(name)] = new_var return ds.assign(new_vars) diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index 8d7299ca..a02ef5f2 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -14,6 +14,8 @@ from pydantic_zarr.core import tuplify_json from pydantic_zarr.v3 import GroupSpec +from eopf_geozarr.s3_olci_optimization.olci_converter import _sanitize_olci_array_attrs + if TYPE_CHECKING: import pathlib @@ -320,3 +322,38 @@ def test_olci_conversion_matches_snapshot( r2_g = meas_g["r2"] assert isinstance(r2_g, zarr.Group) _assert_radiance_dtype_and_attrs(r2_g, "oa01_radiance", level_label="r2") + + +def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: + """_sanitize_olci_array_attrs must strip stale source attrs and preserve _FillValue. + + Unlike the shared sanitize_array_attrs (which always strips _FillValue), + the OLCI-local helper must preserve _FillValue so that downstream readers + and reduce_swath can identify fill pixels on raw uint16 data opened with + mask_and_scale=False. + """ + attrs: dict[str, object] = { + "_eopf_attrs": {"source": "some blob"}, + "dtype": "uint16", + "valid_min": 0, + "valid_max": 65534, + "scale_factor": 0.0139, + "add_offset": 0.0, + "_FillValue": 65535, + "units": "W m-2 sr-1 um-1", + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude", + } + result = _sanitize_olci_array_attrs(attrs) + # Stale source-only attrs must be removed. + assert "_eopf_attrs" not in result, "_eopf_attrs must be stripped" + assert "dtype" not in result, "dtype must be stripped" + assert "valid_min" not in result, "valid_min must be stripped" + assert "valid_max" not in result, "valid_max must be stripped" + # CF and fill attrs must be preserved. + assert result.get("scale_factor") == 0.0139, "scale_factor must be preserved" + assert result.get("add_offset") == 0.0, "add_offset must be preserved" + assert result.get("_FillValue") == 65535, "_FillValue must be preserved for OLCI raw uint16" + assert result.get("units") == "W m-2 sr-1 um-1", "units must be preserved" + assert result.get("standard_name") == "toa_upwelling_spectral_radiance" + assert result.get("coordinates") == "latitude longitude altitude" From a112179349d459907a889caf3e48f910b6de9add Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 23 Jun 2026 12:14:28 +0200 Subject: [PATCH 22/58] fix(s3-olci): align coordinate decimation with coarsen trim on odd dimensions reduce_swath used slice(None, None, factor) (i.e. [::factor]) for coordinate arrays, which yields ceil(N/factor) elements when N is odd. coarsen with boundary="trim" yields floor(N/factor). For real OLCI products with 4865 columns (odd), this caused a 1-element mismatch between radiance and coordinate arrays in every overview group, making xr.open_dataset raise: ValueError: conflicting sizes for dimension 'columns': length 2433 on 'altitude' and length 2432 on 'oa01_radiance' Fix: pre-compute dim_trim = (N // factor) * factor for each swath dimension and change coordinate isel slices to slice(0, dim_trim, factor) so both paths produce exactly floor(N/factor) elements for any N. Add 4 unit tests (rows=7, cols=5) and 1 integration test (rows=10, cols=9) that confirm consistent shapes across radiance and coordinate arrays after reduction, and that overview groups open without conflicting-sizes errors. Co-Authored-By: Claude Opus 4.8 --- .../s3_olci_optimization/olci_multiscale.py | 26 +++- tests/test_olci_integration.py | 47 ++++++++ tests/test_olci_multiscale.py | 114 ++++++++++++++++++ 3 files changed, 185 insertions(+), 2 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 76fbfed9..6239ffe3 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -98,6 +98,21 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: coord_names: frozenset[str] = frozenset(str(k) for k in ds.coords) + # Pre-compute the trimmed length for each swath dimension so that both the + # coarsen path (radiance) and the isel stride path (coordinates) produce + # exactly floor(N / factor) output elements. coarsen(boundary="trim") + # already truncates to a multiple of factor; we match it by stopping the + # stride at the same trimmed limit: slice(0, n_trim, factor). + # + # Without this, an odd-length dimension N yields: + # coarsen → floor(N / factor) e.g. 4865 → 2432 + # isel[::factor] → ceil(N / factor) e.g. 4865 → 2433 + # producing a store where coordinate arrays are longer than the data they + # describe, which makes xr.open_dataset raise a conflicting-sizes error. + dim_trim: dict[str, int] = { + dim: (ds.sizes[dim] // factor) * factor for dim in SWATH_DIMS if dim in ds.sizes + } + all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] for name in all_names: var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] @@ -134,7 +149,12 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: elif is_swath_2d: # Coordinate or non-radiance 2-D swath variable: decimate. - indexers: dict[str, slice] = {dim: slice(None, None, factor) for dim in SWATH_DIMS} + # Use slice(0, n_trim, factor) rather than slice(None, None, factor) + # so that an odd-length dimension N yields floor(N / factor) elements, + # matching the output length of coarsen(boundary="trim").mean(). + indexers: dict[str, slice] = { + dim: slice(0, dim_trim[dim], factor) for dim in SWATH_DIMS if dim in dim_trim + } decimated = var.isel(indexers) if name in coord_names: result_coords[name] = decimated @@ -146,7 +166,9 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # decimate along whichever swath dims it carries. var_dims = {str(d) for d in var.dims} idx: dict[str, slice] = { - dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in var_dims + dim: slice(0, dim_trim[dim], factor) + for dim in SWATH_DIMS + if dim in var_dims and dim in dim_trim } decimated = var.isel(idx) if name in coord_names: diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index a02ef5f2..67ed0fc8 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -324,6 +324,53 @@ def test_olci_conversion_matches_snapshot( _assert_radiance_dtype_and_attrs(r2_g, "oa01_radiance", level_label="r2") +def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) -> None: + """Overview groups written from an odd-dimensioned swath must open without errors. + + Regression test for the off-by-one bug in reduce_swath where coordinate + decimation via [::factor] produced ceil(N/factor) elements while + coarsen(boundary="trim") produced floor(N/factor) for the radiance data. + On an odd-column real OLCI product (4865 cols) this caused xr.open_dataset + to raise ``ValueError: conflicting sizes for dimension 'columns'``. + + We use rows=10, cols=9 (odd cols) with min_dimension=4 so that two + overview levels (r2 at 5x4, r4 at 2x2) are generated. Each level is + opened via xr.open_dataset to confirm no conflicting-sizes error. + """ + dt = build_synthetic_olci(rows=10, cols=9) + out = str(tmp_path / "odd_olci.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out, min_dimension=4) + + # Determine which overview groups were written. + import zarr as _zarr + + g = _zarr.open_group(out, mode="r") + meas = g["measurements"] + assert isinstance(meas, _zarr.Group) + overview_keys = sorted(meas.group_keys()) + # With rows=10, cols=9, min_dimension=4: + # floor(9/2)=4 >= 4 → r2 generated + # floor(4/2)=2 < 4 → stop + assert overview_keys == ["r2"], ( + f"Expected exactly ['r2'] for 10x9 at min_dimension=4, got {overview_keys}" + ) + + # Open each overview level; this must NOT raise a conflicting-sizes error. + for lvl in overview_keys: + ds = xr.open_dataset(out, engine="zarr", group=f"measurements/{lvl}", consolidated=False) + rad_shape = ds["oa01_radiance"].shape + lat_shape = ds["latitude"].shape + lon_shape = ds["longitude"].shape + assert rad_shape == lat_shape == lon_shape, ( + f"measurements/{lvl}: shapes disagree — " + f"oa01_radiance={rad_shape}, latitude={lat_shape}, longitude={lon_shape}" + ) + # r2 of a 10x9 swath must be (5, 4) = (floor(10/2), floor(9/2)) + if lvl == "r2": + assert rad_shape == (5, 4), f"r2 shape expected (5,4), got {rad_shape}" + ds.close() + + def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: """_sanitize_olci_array_attrs must strip stale source attrs and preserve _FillValue. diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 08d95ab1..d7efd1c2 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -165,6 +165,120 @@ def test_reduce_swath_non_swath_var_passthrough() -> None: assert float(out["extra"].values) == 42.0 +# --------------------------------------------------------------------------- +# odd-dimension regression tests (real OLCI: 4865 columns is odd) +# --------------------------------------------------------------------------- + + +def _swath_odd(rows: int = 7, cols: int = 5) -> xr.Dataset: + """Synthetic swath with ODD spatial dimensions. + + Matches the real-world scenario where OLCI products have 4865 columns + (odd). Before the fix, reduce_swath on an odd-sized dimension produced + coordinate arrays one element longer than the corresponding radiance data + (ceil vs floor of N/factor), causing xr.open_dataset to raise a + conflicting-sizes error. + """ + fill = 65535 + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={ + "scale_factor": 0.5, + "units": "mW.m-2.sr-1.nm-1", + "_FillValue": fill, + }, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +def test_reduce_swath_odd_dims_consistent_shape() -> None: + """reduce_swath must produce identical shapes for radiance AND coordinates on odd dims. + + Regression test for the off-by-one bug where coordinate decimation via + [::factor] yields ceil(N/factor) but coarsen(boundary="trim") yields + floor(N/factor). For rows=7, cols=5, factor=2 the expected output shape + is (floor(7/2), floor(5/2)) = (3, 2). + """ + ds = _swath_odd(rows=7, cols=5) + out = reduce_swath(ds, factor=2) + + expected_rows = 7 // 2 # 3 + expected_cols = 5 // 2 # 2 + + assert out["oa01_radiance"].shape == (expected_rows, expected_cols), ( + f"radiance shape {out['oa01_radiance'].shape} != ({expected_rows}, {expected_cols})" + ) + assert out["latitude"].shape == (expected_rows, expected_cols), ( + f"latitude shape {out['latitude'].shape} != ({expected_rows}, {expected_cols})" + ) + assert out["longitude"].shape == (expected_rows, expected_cols), ( + f"longitude shape {out['longitude'].shape} != ({expected_rows}, {expected_cols})" + ) + + +def test_reduce_swath_odd_dims_radiance_is_block_averaged() -> None: + """Radiance values must be block-averaged (not decimated) on odd-dim inputs.""" + rng = np.random.default_rng(7) + rows, cols = 7, 5 + rad_data = rng.integers(100, 200, (rows, cols)).astype("uint16") + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # The top-left output pixel must be the rounded mean of the 2x2 input block. + expected = int(np.round(rad_data[0:2, 0:2].astype("float64").mean())) + assert int(out["oa01_radiance"].values[0, 0]) == expected + + +def test_reduce_swath_odd_dims_coords_decimated() -> None: + """Coordinate arrays must use stride decimation on odd-dim inputs.""" + ds = _swath_odd(rows=7, cols=5) + out = reduce_swath(ds, factor=2) + # Output[0,0] must equal input[0,0] (stride starts at 0). + assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) + # Output[1,1] must equal input[2,2] (stride=2 -> second step at index 2). + assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + + +def test_reduce_swath_odd_simulates_real_olci_columns() -> None: + """Simulate the real-world OLCI case: 4090x4865 (odd cols) -> both 2432 cols. + + Uses smaller proxy dimensions that are proportionally odd to avoid + heavy memory use: rows=10, cols=9 with factor=2 must yield (5, 4) for + both radiance and coordinates. This specifically guards floor vs ceil + on the cols dimension (9 // 2 = 4, not 5). + """ + ds = _swath_odd(rows=10, cols=9) + out = reduce_swath(ds, factor=2) + expected = (10 // 2, 9 // 2) # (5, 4) + assert out["oa01_radiance"].shape == expected, ( + f"radiance shape {out['oa01_radiance'].shape} != {expected}" + ) + assert out["latitude"].shape == expected, ( + f"latitude shape {out['latitude'].shape} != {expected}" + ) + assert out["longitude"].shape == expected, ( + f"longitude shape {out['longitude'].shape} != {expected}" + ) + + # --------------------------------------------------------------------------- # swath_spatial_attrs tests # --------------------------------------------------------------------------- From 56b2b2e165bcf96111f0a78879c392e12e9ed07c Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 23 Jun 2026 12:20:29 +0200 Subject: [PATCH 23/58] docs(s3-olci): add Sentinel-3 OLCI GeoZarr demonstration notebook Notebook walks through opening an EOPF OLCI L1 EFR product (real EODC sample, with an offline fallback to the bundled fixture), detecting it, converting to a multiscale GeoZarr store, and visualizing the pyramid by splitting one field of view into four quadrants each rendered from a different overview level. Adds a `notebooks` dependency group (jupyter, matplotlib, nbformat). Executed end-to-end against the real product; outputs (incl. the quadrant figure) are saved in the notebook. Co-Authored-By: Claude Opus 4.8 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 664 ++++++++ pyproject.toml | 5 + uv.lock | 1539 ++++++++++++++++++- 3 files changed, 2187 insertions(+), 21 deletions(-) create mode 100644 docs/notebooks/sentinel3_olci_geozarr.ipynb diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb new file mode 100644 index 00000000..1ca7536b --- /dev/null +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2888da1e", + "metadata": {}, + "source": [ + "# Sentinel-3 OLCI L1 EFR → GeoZarr\n", + "\n", + "This notebook demonstrates the Sentinel-3 OLCI exporter in `eopf-geozarr`:\n", + "\n", + "1. **Open** an EOPF Zarr Sentinel-3 OLCI L1 EFR product.\n", + "2. **Detect** that it is an OLCI product.\n", + "3. **Convert** it to a GeoZarr-compliant, multiscale Zarr store.\n", + "4. **Visualize** the multiscale pyramid by splitting one field of view into\n", + " four quadrants, each rendered from a *different* overview level.\n", + "\n", + "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", + "no projected CRS). The exporter preserves that native geometry — it does not\n", + "reproject — and builds overviews by fill-aware 2×2 block averaging of the\n", + "radiance bands (coordinates are decimated to keep real measured positions).\n", + "\n", + "> Requires the `notebooks` dependency group:\n", + "> `uv sync --group notebooks` (jupyter, matplotlib, nbformat)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "96531b64", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:23.118582Z", + "iopub.status.busy": "2026-06-23T10:17:23.118408Z", + "iopub.status.idle": "2026-06-23T10:17:24.799718Z", + "shell.execute_reply": "2026-06-23T10:17:24.799151Z" + } + }, + "outputs": [], + "source": [ + "import pathlib\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import xarray as xr\n", + "import zarr\n", + "\n", + "from eopf_geozarr.s3_olci_optimization.olci_converter import (\n", + " convert_olci_optimized,\n", + " is_sentinel3_olci_dataset,\n", + ")\n", + "from eopf_geozarr.conversion.geozarr import get_zarr_group" + ] + }, + { + "cell_type": "markdown", + "id": "cb881df9", + "metadata": {}, + "source": [ + "## 1. Open an EOPF OLCI product\n", + "\n", + "We open a real Sentinel-3 OLCI L1 EFR product from the EOPF sample store on\n", + "EODC. If the store is unreachable (offline / CI), we fall back to the small\n", + "structure-only test fixture shipped with the repository so the notebook still\n", + "runs end to end.\n", + "\n", + "EOPF radiance is stored as scaled `uint16`; we open with `mask_and_scale=False`\n", + "so the raw integers and their `scale_factor` / `_FillValue` are preserved for a\n", + "faithful conversion (the converter expects un-decoded input)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "baf81f90", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:24.802088Z", + "iopub.status.busy": "2026-06-23T10:17:24.801845Z", + "iopub.status.idle": "2026-06-23T10:17:25.546984Z", + "shell.execute_reply": "2026-06-23T10:17:25.546382Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opened remote EODC OLCI product.\n", + "Top-level groups: ['/', '/conditions', '/conditions/geometry', '/conditions/image', '/conditions/instrument', '/conditions/meteorology', '/conditions/orphans', '/measurements', '/measurements/orphans', '/quality', '/quality/orphans']\n" + ] + } + ], + "source": [ + "# A real OLCI L1 EFR product on the EODC EOPF sample store (use an _NT_,\n", + "# fully-consolidated product — _NR_ near-real-time copies may lack metadata).\n", + "EODC_OLCI_URL = (\n", + " \"https://objects.eodc.eu/e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu/\"\n", + " \"01/products/cpm_v262/\"\n", + " \"S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_\"\n", + " \"0179_132_149_2160_PS1_O_NT_004.zarr\"\n", + ")\n", + "\n", + "\n", + "def open_olci_input() -> xr.DataTree:\n", + " \"\"\"Open the remote OLCI product; fall back to the repo test fixture offline.\"\"\"\n", + " try:\n", + " dt = xr.open_datatree(\n", + " EODC_OLCI_URL, engine=\"zarr\", chunks={}, mask_and_scale=False\n", + " )\n", + " print(\"Opened remote EODC OLCI product.\")\n", + " return dt\n", + " except Exception as exc: # noqa: BLE001 - notebook offline fallback\n", + " print(f\"Remote open failed ({type(exc).__name__}); using bundled fixture.\")\n", + " from tests.conftest import create_group_from_json\n", + "\n", + " fixture = pathlib.Path(\n", + " \"tests/_test_data/s3_examples/\"\n", + " \"S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_\"\n", + " \"0179_132_149_2160_PS1_O_NT_004.json\"\n", + " )\n", + " store = create_group_from_json(fixture, pathlib.Path(tempfile.mkdtemp()))\n", + " return xr.open_datatree(store, engine=\"zarr\", mask_and_scale=False)\n", + "\n", + "\n", + "dt_input = open_olci_input()\n", + "print(\"Top-level groups:\", sorted(dt_input.groups))" + ] + }, + { + "cell_type": "markdown", + "id": "fd59eb10", + "metadata": {}, + "source": [ + "### Inspect the measurements group\n", + "\n", + "OLCI L1 EFR carries 21 radiance bands (`oa01_radiance` … `oa21_radiance`) on a\n", + "single full-resolution grid, geolocated by per-pixel 2-D `latitude` /\n", + "`longitude` coordinate arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3bab9194", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.548827Z", + "iopub.status.busy": "2026-06-23T10:17:25.548535Z", + "iopub.status.idle": "2026-06-23T10:17:25.552958Z", + "shell.execute_reply": "2026-06-23T10:17:25.552363Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21 radiance bands; e.g. ['oa01_radiance', 'oa02_radiance', 'oa03_radiance'] … oa21_radiance\n", + "oa01_radiance: (4090, 4865) uint16 | dims ('rows', 'columns')\n", + "scale_factor: 0.013946459628641605 | _FillValue: 65535\n", + "geolocation coords: ['latitude', 'longitude', 'altitude']\n" + ] + } + ], + "source": [ + "meas = dt_input[\"/measurements\"].to_dataset()\n", + "bands = [v for v in meas.data_vars if str(v).endswith(\"_radiance\")]\n", + "print(f\"{len(bands)} radiance bands; e.g. {bands[:3]} … {bands[-1]}\")\n", + "oa = meas[\"oa01_radiance\"]\n", + "print(\"oa01_radiance:\", oa.shape, oa.dtype, \"| dims\", oa.dims)\n", + "print(\"scale_factor:\", oa.attrs.get(\"scale_factor\"), \"| _FillValue:\", oa.attrs.get(\"_FillValue\"))\n", + "print(\"geolocation coords:\", [c for c in (\"latitude\", \"longitude\", \"altitude\") if c in meas])" + ] + }, + { + "cell_type": "markdown", + "id": "90b511c0", + "metadata": {}, + "source": [ + "## 2. Detect the product type\n", + "\n", + "Detection is structural: a product is OLCI iff it validates against the OLCI\n", + "data model and its measurements group contains the radiance bands." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "35c20e40", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.554630Z", + "iopub.status.busy": "2026-06-23T10:17:25.554431Z", + "iopub.status.idle": "2026-06-23T10:17:25.629450Z", + "shell.execute_reply": "2026-06-23T10:17:25.628795Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "is_sentinel3_olci_dataset: True\n" + ] + } + ], + "source": [ + "group = get_zarr_group(dt_input)\n", + "print(\"is_sentinel3_olci_dataset:\", is_sentinel3_olci_dataset(group))" + ] + }, + { + "cell_type": "markdown", + "id": "f2497b10", + "metadata": {}, + "source": [ + "## 3. Convert to GeoZarr\n", + "\n", + "`convert_olci_optimized` writes the native measurements group plus `/2`\n", + "block-averaged overview subgroups (`r2`, `r4`, …) down to `min_dimension`, and\n", + "declares them with the GeoZarr `multiscales` convention. `conditions` and\n", + "`quality` are copied through unchanged.\n", + "\n", + "We use a small `min_dimension` here so even the small sample yields several\n", + "overview levels to visualize." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "781d44e8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.631065Z", + "iopub.status.busy": "2026-06-23T10:17:25.630958Z", + "iopub.status.idle": "2026-06-23T10:18:59.861715Z", + "shell.execute_reply": "2026-06-23T10:18:59.861003Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:17:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:17:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:29\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:32\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyramid levels (native + overviews): ['.', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512']\n" + ] + } + ], + "source": [ + "output_path = str(pathlib.Path(tempfile.mkdtemp()) / \"olci_geozarr.zarr\")\n", + "convert_olci_optimized(dt_input, output_path=output_path, min_dimension=4)\n", + "\n", + "store = zarr.open_group(output_path, mode=\"r\")\n", + "# Overview levels are the rN subgroups under measurements (exclude e.g. orphans).\n", + "levels = [\".\"] + sorted(\n", + " (k for k in store[\"measurements\"].group_keys() if k.startswith(\"r\")),\n", + " key=lambda k: int(k[1:]),\n", + ")\n", + "print(\"Pyramid levels (native + overviews):\", levels)" + ] + }, + { + "cell_type": "markdown", + "id": "1c5310cc", + "metadata": {}, + "source": [ + "### Load one band at every pyramid level\n", + "\n", + "Level `.` is the native resolution written at the measurements group root;\n", + "`r2`, `r4`, … are successively coarser block-averaged overviews. We read with\n", + "default decoding so the stored `uint16` radiance is scaled to physical units\n", + "for display." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3f654e2e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:18:59.864062Z", + "iopub.status.busy": "2026-06-23T10:18:59.863872Z", + "iopub.status.idle": "2026-06-23T10:19:00.100825Z", + "shell.execute_reply": "2026-06-23T10:19:00.100149Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " .: shape (4090, 4865)\n", + " r2: shape (2045, 2432)\n", + " r4: shape (1022, 1216)\n", + " r8: shape (511, 608)\n", + " r16: shape (255, 304)\n", + " r32: shape (127, 152)\n", + " r64: shape (63, 76)\n", + "r128: shape (31, 38)\n", + "r256: shape (15, 19)\n", + "r512: shape (7, 9)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" + ] + } + ], + "source": [ + "BAND = \"oa08_radiance\" # ~665 nm (red); good visual contrast\n", + "\n", + "\n", + "def read_level(level: str) -> xr.DataArray:\n", + " group = \"measurements\" if level == \".\" else f\"measurements/{level}\"\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + " return ds[BAND]\n", + "\n", + "\n", + "level_arrays = {lvl: read_level(lvl) for lvl in levels}\n", + "for lvl, arr in level_arrays.items():\n", + " print(f\"{lvl:>4}: shape {tuple(arr.shape)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "95da72f9", + "metadata": {}, + "source": [ + "## 4. Multiscale quadrant visualization\n", + "\n", + "To show the pyramid in a single field of view, we split the native-resolution\n", + "image into four quadrants and fill each quadrant with data from a **different**\n", + "overview level. Each level's array is nearest-neighbour upsampled back to the\n", + "native quadrant size, so coarser levels render as visibly blockier — the\n", + "resolution drop is the point.\n", + "\n", + "Top-left = native, top-right = `r2`, bottom-left = `r4`, bottom-right = the\n", + "next coarser level available (clamped to the coarsest if fewer exist)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b40965eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:19:00.103316Z", + "iopub.status.busy": "2026-06-23T10:19:00.103038Z", + "iopub.status.idle": "2026-06-23T10:19:04.459494Z", + "shell.execute_reply": "2026-06-23T10:19:04.458850Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def to_native_grid(arr: xr.DataArray, ny: int, nx: int) -> np.ndarray:\n", + " \"\"\"Nearest-neighbour upsample a (rows, columns) array to (ny, nx).\"\"\"\n", + " a = np.asarray(arr.values, dtype=float)\n", + " row_idx = (np.arange(ny) * a.shape[0] // ny).clip(0, a.shape[0] - 1)\n", + " col_idx = (np.arange(nx) * a.shape[1] // nx).clip(0, a.shape[1] - 1)\n", + " return a[np.ix_(row_idx, col_idx)]\n", + "\n", + "\n", + "native = level_arrays[\".\"]\n", + "ny, nx = native.shape\n", + "hy, hx = ny // 2, nx // 2\n", + "\n", + "# Choose four levels (native + up to three coarser), clamped to what exists.\n", + "chosen = [levels[min(i, len(levels) - 1)] for i in range(4)]\n", + "\n", + "# Build a single canvas: each quadrant upsampled from its chosen level.\n", + "canvas = np.empty((ny, nx), dtype=float)\n", + "quadrants = {\n", + " (slice(0, hy), slice(0, hx)): chosen[0], # top-left\n", + " (slice(0, hy), slice(hx, nx)): chosen[1], # top-right\n", + " (slice(hy, ny), slice(0, hx)): chosen[2], # bottom-left\n", + " (slice(hy, ny), slice(hx, nx)): chosen[3], # bottom-right\n", + "}\n", + "for (rsl, csl), lvl in quadrants.items():\n", + " full = to_native_grid(level_arrays[lvl], ny, nx)\n", + " canvas[rsl, csl] = full[rsl, csl]\n", + "\n", + "fig, ax = plt.subplots(figsize=(7, 7))\n", + "im = ax.imshow(canvas, cmap=\"viridis\")\n", + "ax.axhline(hy - 0.5, color=\"white\", lw=1)\n", + "ax.axvline(hx - 0.5, color=\"white\", lw=1)\n", + "labels = {\n", + " (hx / 2, hy / 2): chosen[0],\n", + " (hx + hx / 2, hy / 2): chosen[1],\n", + " (hx / 2, hy + hy / 2): chosen[2],\n", + " (hx + hx / 2, hy + hy / 2): chosen[3],\n", + "}\n", + "for (x, y), lvl in labels.items():\n", + " res = 1 if lvl == \".\" else int(lvl[1:])\n", + " name = \"native (r1)\" if lvl == \".\" else lvl\n", + " ax.text(\n", + " x, y, f\"{name}\\n1/{res} res\", color=\"white\", ha=\"center\", va=\"center\",\n", + " fontweight=\"bold\", bbox={\"facecolor\": \"black\", \"alpha\": 0.4, \"pad\": 3},\n", + " )\n", + "ax.set_title(f\"OLCI {BAND}: one FOV, four pyramid levels\")\n", + "ax.set_xlabel(\"columns (across-track)\")\n", + "ax.set_ylabel(\"rows (along-track)\")\n", + "fig.colorbar(im, ax=ax, shrink=0.8, label=\"radiance (scaled)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b4beef58", + "metadata": {}, + "source": [ + "Each quadrant covers the same ground area but is drawn from a coarser level as\n", + "you move down/right — the blockier quadrants are the lower-resolution overviews\n", + "from the multiscale pyramid, all produced by the single conversion above." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index bd22dce3..3b8ff219 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -71,6 +71,11 @@ docs = [ "pymdown-extensions>=10.0", "mike>=2.1.3", ] +notebooks = [ + "jupyter>=1.0.0", + "matplotlib>=3.8.0", + "nbformat>=5.9.0", +] [project.urls] Homepage = "https://github.com/developmentseed/eopf-geozarr" diff --git a/uv.lock b/uv.lock index 5f2a9bd9..cca16cf0 100644 --- a/uv.lock +++ b/uv.lock @@ -214,6 +214,89 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, ] +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "async-lru" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" }, +] + [[package]] name = "attrs" version = "26.1.0" @@ -260,6 +343,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/05/a4/a26d5b25671d27e03afb5401a0be5899d94ff8fab6a698b1ac5be3ec29ef/bandit-1.9.4-py3-none-any.whl", hash = "sha256:f89ffa663767f5a0585ea075f01020207e966a9c0f2b9ef56a57c7963a3f6f8e", size = 134741, upload-time = "2026-02-25T06:44:13.694Z" }, ] +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + [[package]] name = "black" version = "26.3.1" @@ -292,6 +388,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8e/0d/52d98722666d6fc6c3dd4c76df339501d6efd40e0ff95e6186a7b7f0befd/black-26.3.1-py3-none-any.whl", hash = "sha256:2bd5aa94fc267d38bb21a70d7410a89f1a1d318841855f698746f8e7f51acd1b", size = 207542, upload-time = "2026-03-12T03:36:01.668Z" }, ] +[[package]] +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + [[package]] name = "boto3" version = "1.43.0" @@ -417,6 +530,63 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f4/2f/2d4f04e27c2481fd697522340df04f3a278dfe9a1f13292b2f9e39b98a44/cf_xarray-0.11.1-py3-none-any.whl", hash = "sha256:b55c77af7bc5c0768a65ab6eafef89646e5cbf003a12ec37513983565e25f888", size = 79377, upload-time = "2026-05-12T20:58:51.016Z" }, ] +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + [[package]] name = "cfgv" version = "3.5.0" @@ -564,6 +734,81 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + [[package]] name = "coverage" version = "7.13.5" @@ -716,6 +961,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/c6/c71e82e041c95ffe6a92ac707785500aa2a515a4339c2c7dd67e3c449249/cramjam-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:028400d699442d40dbda02f74158c73d05cb76587a12490d0bfedd958fd49188", size = 1713108, upload-time = "2025-07-27T21:24:10.147Z" }, ] +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + [[package]] name = "dask" version = "2026.3.0" @@ -742,6 +996,45 @@ distributed = [ { name = "distributed" }, ] +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + [[package]] name = "distlib" version = "0.4.0" @@ -829,6 +1122,11 @@ downstream-titiler = [ { name = "httpx" }, { name = "titiler-xarray" }, ] +notebooks = [ + { name = "jupyter" }, + { name = "matplotlib" }, + { name = "nbformat" }, +] test = [ { name = "jsondiff" }, { name = "pytest" }, @@ -875,6 +1173,11 @@ downstream-titiler = [ { name = "httpx", specifier = ">=0.27.0" }, { name = "titiler-xarray", specifier = ">=2.0.0" }, ] +notebooks = [ + { name = "jupyter", specifier = ">=1.0.0" }, + { name = "matplotlib", specifier = ">=3.8.0" }, + { name = "nbformat", specifier = ">=5.9.0" }, +] test = [ { name = "jsondiff", specifier = ">=2.0.0" }, { name = "jsondiff", specifier = ">=2.2.1" }, @@ -894,6 +1197,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, ] +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + [[package]] name = "fastapi" version = "0.136.1" @@ -910,6 +1222,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" }, ] +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + [[package]] name = "filelock" version = "3.29.0" @@ -919,6 +1240,56 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, ] +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + [[package]] name = "frozenlist" version = "1.8.0" @@ -1116,49 +1487,512 @@ version = "3.17" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", hash = "sha256:5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f", size = 196048, upload-time = "2026-05-28T14:32:38.55Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", hash = "sha256:466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c", size = 65316, upload-time = "2026-05-28T14:32:37.035Z" }, + { url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", hash = "sha256:466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c", size = 65316, upload-time = "2026-05-28T14:32:37.035Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio2" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" }, +] + +[[package]] +name = "ipython" +version = "9.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/23/3a27530575643c8bb7bfc757a28e2e7ef80092afbf59a2bc5716320b6602/ipython-9.14.1.tar.gz", hash = "sha256:f913bf74df06d458e46ced84ca506c23797590d594b236fe60b14df213291e7b", size = 4433457, upload-time = "2026-06-05T08:12:34.921Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/22/58818a63eaf8982b67632b1bc20585c811611b15a8da19d6012323dc76a5/ipython-9.14.1-py3-none-any.whl", hash = "sha256:5d4a9ecaa3b10e6e5f269dd0948bdb58ca9cb851899cd23e07c320d3eb11613c", size = 627770, upload-time = "2026-06-05T08:12:33.045Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jmespath" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" }, +] + +[[package]] +name = "json5" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/7d/05c46a96a78147ae3bf99c2f4169ce144a70220b8d6fcd56f6ec368b8ce9/json5-0.15.0.tar.gz", hash = "sha256:7424d1f1eb1d56da6e3d70643f53619862b4ce81440bdb8ecfd6f875e5ba4a71", size = 53278, upload-time = "2026-06-19T20:08:27.716Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/59527c99478aade6bb33a68d72e6e18dd4e6ff6eacfc7d01bdb15bc76912/json5-0.15.0-py3-none-any.whl", hash = "sha256:56636a30c0e8a4665fe2179c0212f32eae3796dea89ea6f649b9436ecdb39618", size = 36570, upload-time = "2026-06-19T20:08:26.748Z" }, +] + +[[package]] +name = "jsondiff" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/48/841137f1843fa215ea284834d1514b8e9e20962bda63a636c7417e02f8fb/jsondiff-2.2.1.tar.gz", hash = "sha256:658d162c8a86ba86de26303cd86a7b37e1b2c1ec98b569a60e2ca6180545f7fe", size = 26649, upload-time = "2024-08-29T04:09:06.201Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/94/a8066f84d62ab666d61ef97deba1a33126e3e5c0c0da2c458ada17053ed6/jsondiff-2.2.1-py3-none-any.whl", hash = "sha256:b1f0f7e2421881848b1d556d541ac01a91680cfcc14f51a9b62cdf4da0e56722", size = 13440, upload-time = "2024-08-29T04:09:04.955Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-builder" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/45/d0df8b43c10a61529c0f4a8af5e19ebe108f0c3af8f57e0fc358969907af/jupyter_builder-1.0.2.tar.gz", hash = "sha256:6155d78a5325010532a6419ffcba89eac643fd1aa56ea83115e661924d6f6aab", size = 968638, upload-time = "2026-06-12T02:33:25.767Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/b6/c418e0b3256f67c04933566b80bfce947350682db92c4b786a8653db32d6/jupyter_builder-1.0.2-py3-none-any.whl", hash = "sha256:b024f65d36e1d530542db597b00dd513261aa59842e0d0fbbb1015a9f1935e9c", size = 910789, upload-time = "2026-06-12T02:33:23.317Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", hash = "sha256:c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf", size = 19512, upload-time = "2026-04-20T23:17:48.927Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", hash = "sha256:71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81", size = 77513, upload-time = "2026-04-02T08:10:01.753Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/dc/db3a582633170186f8c8b31298d7eb26ad0eb031a1f53476c258b64eed05/jupyter_server-2.20.0.tar.gz", hash = "sha256:b5778ba337d8015a3dc2b80803ecdd5ac18d3797fddf61a50ea5fb472b4ebe14", size = 756523, upload-time = "2026-06-17T12:09:09.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/71/8c002223e873a870f5c41dc69b0a7c922301123e4a31d5d01ecb700aef77/jupyter_server-2.20.0-py3-none-any.whl", hash = "sha256:c3b67c93c471e947c18b5026f04f21614218adb706df8f48227d3ee8e0a7cdcc", size = 393143, upload-time = "2026-06-17T12:09:07.234Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-builder" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/3c/1ebd737b860cdbe61eed71536d06aab4e1781fbdcf07ecd5a1afe05b8adf/jupyterlab-4.6.0.tar.gz", hash = "sha256:6a8b88f2aae7ed4d012c634fc957c1a27f3aa217c32f0ced0175fac9ee17f9e5", size = 28181861, upload-time = "2026-06-18T13:52:56.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/eb/aa48075d0aa3d0188db34ba2704f53791757743c0bb02e18c4eef989b6de/jupyterlab-4.6.0-py3-none-any.whl", hash = "sha256:b6938cb8a1ef3d43860ff4745a680c62cc0a9385f9672295bb56cd2e7cfeebe2", size = 17143447, upload-time = "2026-06-18T13:52:51.42Z" }, ] [[package]] -name = "iniconfig" -version = "2.3.0" +name = "jupyterlab-pygments" +version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, ] [[package]] -name = "jinja2" -version = "3.1.6" +name = "jupyterlab-server" +version = "2.28.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markupsafe" }, + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, ] [[package]] -name = "jmespath" -version = "1.1.0" +name = "jupyterlab-widgets" +version = "3.0.16" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" } +sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" }, + { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" }, ] [[package]] -name = "jsondiff" -version = "2.2.1" +name = "kiwisolver" +version = "1.5.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/35/48/841137f1843fa215ea284834d1514b8e9e20962bda63a636c7417e02f8fb/jsondiff-2.2.1.tar.gz", hash = "sha256:658d162c8a86ba86de26303cd86a7b37e1b2c1ec98b569a60e2ca6180545f7fe", size = 26649, upload-time = "2024-08-29T04:09:06.201Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, +] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/63/94/a8066f84d62ab666d61ef97deba1a33126e3e5c0c0da2c458ada17053ed6/jsondiff-2.2.1-py3-none-any.whl", hash = "sha256:b1f0f7e2421881848b1d556d541ac01a91680cfcc14f51a9b62cdf4da0e56722", size = 13440, upload-time = "2024-08-29T04:09:04.955Z" }, + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, ] [[package]] @@ -1254,6 +2088,72 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, ] +[[package]] +name = "matplotlib" +version = "3.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/17/f5276b496c61477a6c4fc5e7401f4bfe1c2e5ef7c6cd67896f2ade3809cb/matplotlib-3.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:06b5872e9cf11adc8f589ded3ce11bc3e1061ad498259664fabc1f6615beb918", size = 9449976, upload-time = "2026-06-12T02:27:50.989Z" }, + { url = "https://files.pythonhosted.org/packages/82/34/bdd77418adb2178a1d59f044bd67bfebb115896e91b840b8a197eb3f4f4e/matplotlib-3.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0515d495124be3124340e59f164d901ed4484e2246a5b74cfa483cac3b80bd97", size = 9279307, upload-time = "2026-06-12T02:27:53.247Z" }, + { url = "https://files.pythonhosted.org/packages/94/95/7f522393c88313336b20d70fc849555757b2e5febc22b83b3a3f0fd4bce9/matplotlib-3.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be5f93a1d21981bfb802ded0d77a0caa92d4342a47d45754fac77e314a506344", size = 10031353, upload-time = "2026-06-12T02:27:55.215Z" }, + { url = "https://files.pythonhosted.org/packages/87/ce/8f25a0e3186aefd61913e7467d1b999465bcd0d0c03ac695c1b26ca559b7/matplotlib-3.11.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41635d7909d19e52e924a521dde6d8f670b0f53ab1d0e8c331fa831554f681d1", size = 10839232, upload-time = "2026-06-12T02:27:57.746Z" }, + { url = "https://files.pythonhosted.org/packages/85/c2/db15da2bbdf9e3ca66df7db8e2c33a1dfed67be24a24d2c878efaaff01d6/matplotlib-3.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:94f5000f67ca9faa300863ea17f8bce9175cb67b88bec4bc7780502d53dd7c9e", size = 10923899, upload-time = "2026-06-12T02:28:00.223Z" }, + { url = "https://files.pythonhosted.org/packages/e5/2f/a58a4443a4d052a4ea77557478336aefc26c7981f6408d37adba763aa758/matplotlib-3.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac6f1ef39f3d0f9e2463303013094992cdbe0f85f43bc54155bc472b2042768e", size = 9329528, upload-time = "2026-06-12T02:28:02.27Z" }, + { url = "https://files.pythonhosted.org/packages/61/0f/4b669589d47733b97ab9df4b58d6fc1e68acb5ea42a928dc7cbdd6bf5871/matplotlib-3.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:9dd11fb612ce7bc60b1de5b4fc87ff959d22317b5de42aabf392f66f97af22eb", size = 9003413, upload-time = "2026-06-12T02:28:04.49Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/aa47f156b061d14c98b906f76c428507397708ec63ff94f410ae1752b426/matplotlib-3.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6ce3b839b34ae1f430b4616893a2945a2999debaa7e94e7e29a2a8bbf286f7b5", size = 9450532, upload-time = "2026-06-12T02:28:06.769Z" }, + { url = "https://files.pythonhosted.org/packages/8c/4f/5a9eb0375e81413953febf8af7b012a6b6357f53438a15c4f5ad86c6bbb5/matplotlib-3.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:373db8f91214e8ccaf35ac833cc1dd59dd961e148bbd55dd027141591dde1313", size = 9279760, upload-time = "2026-06-12T02:28:09.152Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c0/1117d53077e3ac3152503a84e9cf7a5c239576805ee71276e80c2aaa7471/matplotlib-3.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be152b7570324dc8d01574cc9474dd2d803237acf528bcbb5b211fa347461a09", size = 10031623, upload-time = "2026-06-12T02:28:11.26Z" }, + { url = "https://files.pythonhosted.org/packages/92/7e/e937138daffad65b71bf831a377809dcbc830fb4f31a31e067dc1faa2575/matplotlib-3.11.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:126f256df600652d7e4b394cf3164ff75210a00038f287c95a012a6f58d0e83f", size = 10839372, upload-time = "2026-06-12T02:28:14.102Z" }, + { url = "https://files.pythonhosted.org/packages/1d/c2/438ecc197ffb8023b6b9922915542f2172f5fd45b76703b0b4fc47322243/matplotlib-3.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:03acfeddf87b0dddb11b081ef7740ad445a3ca8bcb6b8e3011b08f2cf802b75c", size = 10924099, upload-time = "2026-06-12T02:28:16.383Z" }, + { url = "https://files.pythonhosted.org/packages/40/2e/395883da416f378b3ed2c9f3e843ac477eae1ce731b671b79adaa6f0bacd/matplotlib-3.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:ab3722f04f3ff34c23b5012c5873d2894174e06c3822fcdac3610965a5ac7d06", size = 9329727, upload-time = "2026-06-12T02:28:18.581Z" }, + { url = "https://files.pythonhosted.org/packages/61/82/2c388956abf8bf392dfb5b8917c502f1082df6a941b781ab8c8e5ba2474b/matplotlib-3.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:c945824670fb8915b4ac879e5e61f3c58e0913022f70a0de4c082b17372f8771", size = 9003506, upload-time = "2026-06-12T02:28:20.474Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c1/34454baa44da7975ada82e9aea37105ec47059514dc967d3be14426ba8dc/matplotlib-3.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3489c3dc487669b4a980bc3068f87856de7a1564248d3f6c629efb2a58b03f24", size = 9499838, upload-time = "2026-06-12T02:28:22.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c3/98fe79a398cf232219f090163a7fa7e6766e9f2e0ad26df54d6f8934d8ee/matplotlib-3.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6a98f5476ce784a50ce09998f4ae1e6a9f25043cef8a480c98949902eda74620", size = 9332298, upload-time = "2026-06-12T02:28:24.796Z" }, + { url = "https://files.pythonhosted.org/packages/95/e4/b4b7c33151e74e5c802f3cde1ba807ebfc38401e329b44e215a5888dd76d/matplotlib-3.11.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:565af866fd63e4bd3f987d580afe27c44c2552a3b3305f4ecbb85133601ea6f3", size = 10045491, upload-time = "2026-06-12T02:28:27.141Z" }, + { url = "https://files.pythonhosted.org/packages/71/28/394548efd68354110c1a1be11fe6b6e559e06d1a23da35908a0e316c55a9/matplotlib-3.11.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6b3e64dea5062c570f04358e2711859f3531b459f29516274fbad889079e4f3", size = 10857059, upload-time = "2026-06-12T02:28:29.222Z" }, + { url = "https://files.pythonhosted.org/packages/c8/44/e7922e6e2a4d63bdfbc9dc4a53e3850ab438d46cf42e6779bb15ec92c948/matplotlib-3.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:942b37c5db1899610bd1543ce8e13e4ecff9a4633e7f63bb6aa9205d2644ebd1", size = 10939576, upload-time = "2026-06-12T02:28:31.66Z" }, + { url = "https://files.pythonhosted.org/packages/3d/be/b1ca96003a441d619b727fee21d671fdff7a5ce2f1bb797b2521aa2f679a/matplotlib-3.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:c08e649a6313e1291e713623b97a38e5bb4aa580b2a100a94a3309bc6b9c8eb3", size = 9379519, upload-time = "2026-06-12T02:28:33.888Z" }, + { url = "https://files.pythonhosted.org/packages/e3/72/4bf3b91821c34596dd6a7bdac5836d94f744144c8208939ef49d8ec43f7e/matplotlib-3.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2746cd2c113742ff6ce37a864c5ac5fd7aa644568f445e66166e457ac78e40e0", size = 9055456, upload-time = "2026-06-12T02:28:35.878Z" }, + { url = "https://files.pythonhosted.org/packages/57/52/a94102ac99eb78e2fe9b826674f9ef9ee23327110ea6ab4776c1b4eb6209/matplotlib-3.11.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3338e3e3de128cf50d0d2fb92a122815daf9c755bd882a474343c05f8fd7ec79", size = 9452137, upload-time = "2026-06-12T02:28:37.93Z" }, + { url = "https://files.pythonhosted.org/packages/7c/03/b8cdb625a21f710dfa11bbca1f48fb4057d2c0286975f8b415bf80942c99/matplotlib-3.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:25c2e5455efd8d99f41fb79871a31feb7d301569642e332ec58d72cfe9282bc3", size = 9281514, upload-time = "2026-06-12T02:28:40.028Z" }, + { url = "https://files.pythonhosted.org/packages/b7/2d/4e1240ea82ee197dfb3851e71f71c87eeeb975f1753b56a0588e4e80739a/matplotlib-3.11.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9695457a467ff86d23f35037a43deb6f1134dd6d3e2ac8ce1e2087cff09ffb9", size = 10843005, upload-time = "2026-06-12T02:28:42.39Z" }, + { url = "https://files.pythonhosted.org/packages/29/dc/6377ecfaa5fef79430f74a1a16638b4e2aa30d4692bae2c19f9d76fe3b01/matplotlib-3.11.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19c16c61dea63b3582918503e6b294193961261d9daa806d4ae2151f1ad05430", size = 11127459, upload-time = "2026-06-12T02:28:44.483Z" }, + { url = "https://files.pythonhosted.org/packages/6f/41/795c405aa7560443a3b01309424cde4a1113b85c90b8a63417444a749617/matplotlib-3.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2d72ea8b7924f3cb955e61518d21e43b3df1e6c8a793b480a0c1214f185d30ba", size = 10925160, upload-time = "2026-06-12T02:28:46.564Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f7/3a9e6389a7cfaeff76c56e40c2dabcb13110e21e82f837228c834ebe748c/matplotlib-3.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:1c02da0a629dfa9debf52725ea06866b74c1fb70a895bae05e4493d34074f9f2", size = 9485186, upload-time = "2026-06-12T02:28:49.344Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c0/396478ee7cf2091d182db8b4a8695f6a37f1ddb978989cf9dbb84cd5c123/matplotlib-3.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aa55d73b3117d4b07f959cd9eb6f69b375d8df3414139c479388e551aa5d999d", size = 9160349, upload-time = "2026-06-12T02:28:51.382Z" }, + { url = "https://files.pythonhosted.org/packages/c5/6f/1c3bd51bb2b34eaacdcf3c3d859dbb357f952fc8020c617dc118ad7c9e38/matplotlib-3.11.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a9d8c6e7cd2f0ddf11d8d92e520dd1d9d2abb0cf6ac8831e338666c81e905847", size = 9500921, upload-time = "2026-06-12T02:28:53.443Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/4d861d0121840cb1a3fd4a10deb211efd6fccd481ed23e553f31f4f4da4a/matplotlib-3.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:be050fcf32f729eda99f7f75a80bf67612ce16ab9ac1c23a387dcaede95cb70e", size = 9332190, upload-time = "2026-06-12T02:28:55.623Z" }, + { url = "https://files.pythonhosted.org/packages/4b/cb/22f6bc35711a0b5639a784e74e653e77c86210bd4304449dd399a482f74e/matplotlib-3.11.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfabef0230d0697aa0d717385194dd41162e00207a68bf4abf94c2bf4c27dca0", size = 10854181, upload-time = "2026-06-12T02:28:57.856Z" }, + { url = "https://files.pythonhosted.org/packages/3f/7e/9a9eaca731a2939589da520f0ebe8fd8753d0f51fca98c7d20af6dbe261a/matplotlib-3.11.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1644db30e759199443493ac5e5caec24fdb775a8f6123021f85ba47c4133c3cb", size = 11137715, upload-time = "2026-06-12T02:29:00.555Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f9/9b030b6088354acb0296871bb624b25befc1c42509d3c6cd17420c83a5b8/matplotlib-3.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15b0d160079cb10699a0e98b5989c70677b2df7cacdc62af67c30f2facec46d9", size = 10939427, upload-time = "2026-06-12T02:29:02.527Z" }, + { url = "https://files.pythonhosted.org/packages/59/94/6b273eaee4ee250863567d100865da61a5c1527fa67f527b7ed22e0dd29c/matplotlib-3.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:446307e6b04b57b1f1239e228a1ec2af0d589a1008cebc3dfa3f5441d095cfb6", size = 9535809, upload-time = "2026-06-12T02:29:04.994Z" }, + { url = "https://files.pythonhosted.org/packages/60/95/1d36bddf2b7e2692c1540e78a6e5bc88bc1496b137e3e35a611f91b65ac3/matplotlib-3.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:652fb5696271d4c50f196d22a5ff4f8e4444c74f847423570d7dc0aa2bbd0159", size = 9209226, upload-time = "2026-06-12T02:29:07.033Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -1289,6 +2189,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/76/8e/56ccb09c7232a55403a7637caa21922f3b65901a37f5e8bdb405d0de0946/mike-2.2.0-py3-none-any.whl", hash = "sha256:e1f4981c1152eec7c2490a3401142292cc47d686194188416db2648fdfe1d040", size = 34026, upload-time = "2026-04-14T04:59:02.602Z" }, ] +[[package]] +name = "mistune" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/5f/007786743f962224423753b78f7d7acb0f2ade46d1604f2e0fa2bedf9020/mistune-3.3.2.tar.gz", hash = "sha256:e12ee4f1e74336e91aa1141e35f913b337c40bdf7c0cc49f21fb853a27e8b62f", size = 111284, upload-time = "2026-06-23T00:29:28.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/43/894c2cbbcbdf53b57d1257a249811abe2ee9ab7ef76af301b40f1c054533/mistune-3.3.2-py3-none-any.whl", hash = "sha256:a678a56387d487db7368ede4647cb2ba1deff22ce61f92343e4ebe0ddfce4f2d", size = 61554, upload-time = "2026-06-23T00:29:27.088Z" }, +] + [[package]] name = "mkdocs" version = "1.6.1" @@ -1525,6 +2434,70 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] +[[package]] +name = "nbclient" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nest-asyncio2" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" }, +] + [[package]] name = "nodeenv" version = "1.10.0" @@ -1534,6 +2507,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, ] +[[package]] +name = "notebook" +version = "7.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-builder" }, + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/44/d5c65783f490298473bb1c05722e05ee2256231389559c2c5ae0a3e5d975/notebook-7.6.0.tar.gz", hash = "sha256:ea13e79e601bf273074895fdfb17dd3f2da916d3c045e0b9c47d18b16ab62481", size = 5497344, upload-time = "2026-06-18T16:18:55.202Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d1/e617c40db57ff40e75f43a7d4d1c305e3a54c053ab5cb0534a6c314664f9/notebook-7.6.0-py3-none-any.whl", hash = "sha256:98aa2811b54ac191321d5dfce12ca700f8a511a33a26e4de2fa106a357c43d6a", size = 5544575, upload-time = "2026-06-18T16:18:52.551Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + [[package]] name = "numcodecs" version = "0.16.5" @@ -1793,6 +2795,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/2b/f8434233fab2bd66a02ec014febe4e5adced20e2693e0e90a07d118ed30e/pandas-3.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:5371b72c2d4d415d08765f32d689217a43227484e81b2305b52076e328f6f482", size = 9455341, upload-time = "2026-03-31T06:48:28.418Z" }, ] +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + [[package]] name = "partd" version = "1.4.2" @@ -1815,6 +2835,87 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, ] +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, +] + [[package]] name = "platformdirs" version = "4.9.6" @@ -1849,6 +2950,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" }, ] +[[package]] +name = "prometheus-client" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + [[package]] name = "propcache" version = "0.4.1" @@ -1961,6 +3083,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, ] +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.13.4" @@ -2294,6 +3443,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, ] +[[package]] +name = "python-json-logger" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/ff/3cc9165fd44106973cd7ac9facb674a65ed853494592541d339bdc9a30eb/python_json_logger-4.1.0.tar.gz", hash = "sha256:b396b9e3ed782b09ff9d6e4f1683d46c83ad0d35d2e407c09a9ebbf038f88195", size = 17573, upload-time = "2026-03-29T04:39:56.805Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/be/0631a861af4d1c875f096c07d34e9a63639560a717130e7a87cbc82b7e3f/python_json_logger-4.1.0-py3-none-any.whl", hash = "sha256:132994765cf75bf44554be9aa49b06ef2345d23661a96720262716438141b6b2", size = 15021, upload-time = "2026-03-29T04:39:55.266Z" }, +] + [[package]] name = "pytokens" version = "0.4.1" @@ -2323,6 +3481,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" }, ] +[[package]] +name = "pywinpty" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/ef/2d27f30c59a67be7025b2d7858c8c2d282b74d66544b2384730b82de74fd/pywinpty-3.0.5.tar.gz", hash = "sha256:61db0db063de9865adbea66db294628f8577f608d9764a4c7d3384eeacc4e81b", size = 16223484, upload-time = "2026-06-11T00:11:58.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/34/942cc95ca4e26489875aa8a95192766247a687379ec29543eebe73ec945f/pywinpty-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:d62946adf14b15b54c0b8d785f93fe18b04da23f4ad59e2e8c4612646e9abd23", size = 2090915, upload-time = "2026-06-10T23:43:14.98Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/5b9053004844139ea8bd86209c57ade12b134b2782f383a095784c8531ec/pywinpty-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:e9391c05fbfa7a992a97e831fc6849887b4014a614192e3d984a7ca59592b376", size = 815934, upload-time = "2026-06-10T23:41:42.384Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f4/2a464b9893cceb3b3f416356e94fdc3e1bca9476993927e4e6d99fe95382/pywinpty-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:48db1b0ad9d0a1b81dcaaa7163a99a7808deaceb0c1b2344716dc1fc090c3c4c", size = 2090471, upload-time = "2026-06-10T23:42:11.071Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2c/a138491a0afbdb50eb79395577bd326d4b0fbde7209417d1a8087ff2493a/pywinpty-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:2c6008fb2d3774b48693b2fcb7f2cc317ade9dc581289a964ffeeaf81307c9b5", size = 815518, upload-time = "2026-06-10T23:42:02.363Z" }, + { url = "https://files.pythonhosted.org/packages/6f/15/54400049a380582acd1282665c70fcf11e0bd3713679aca78e24c3aae738/pywinpty-3.0.5-cp313-cp313t-win_amd64.whl", hash = "sha256:22ce1b780d89821cc52daf6eac0708af22d93d000ce9c7c07e37489db8594598", size = 2089920, upload-time = "2026-06-10T23:44:13.395Z" }, + { url = "https://files.pythonhosted.org/packages/94/0c/6f24f3c0799f502259b24bdf841a99ad2b0d59df5c2525b4e2a286d14be2/pywinpty-3.0.5-cp313-cp313t-win_arm64.whl", hash = "sha256:9c2919a81bc5cfb09b86fc5a002112b2de95ca4304a07413cbeeb746a1307a5c", size = 814520, upload-time = "2026-06-10T23:43:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/f3cd1b1e5fc56517f54452c49f92049e7dd9ffc8a63de22a495581f50d04/pywinpty-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:03bb3c16d691d9242267201830bcd0e64a9b663170e9042bc84b210da9de15ac", size = 2090663, upload-time = "2026-06-10T23:43:59.845Z" }, + { url = "https://files.pythonhosted.org/packages/9d/dd/96d6cbfc6d9ddab5c1c2f92c26545ae8997446a2ba7ee2024cd43c81f49b/pywinpty-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:89c5c6ef08997a3b4b277b214a35fe15cab4dd6d119f0140aa71df5b1168fdbc", size = 815700, upload-time = "2026-06-10T23:40:50.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/36/d98087bce0acaa4cce7f196103cfa7be3f63ce65f52473bb3e38784ae5d9/pywinpty-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7b566165e0c5fdd6abe167a5ac8b954be6a843eb55a85946576d6bc1dea03d6d", size = 2090093, upload-time = "2026-06-10T23:40:58.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/fd/fe2b0db922ba052ce3976a08f3fc05d0c05047c8b4ebb6102e832b8ef563/pywinpty-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:24366280a8aa677323da87bec729cb3ea3b35367386cece0978bdc6e4695c690", size = 814517, upload-time = "2026-06-10T23:42:34.946Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -2381,6 +3557,49 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" }, ] +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + [[package]] name = "rasterio" version = "1.5.0" @@ -2428,6 +3647,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/d1/8b017856e63ccaff3cbd0e82490dbb01363a42f3a462a41b1d8a391e1443/rasterio-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f4b9c2c3b5f10469eb9588f105086e68f0279e62cc9095c4edd245e3f9b88c8a", size = 29418321, upload-time = "2026-01-05T16:06:44.758Z" }, ] +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + [[package]] name = "requests" version = "2.33.1" @@ -2443,6 +3676,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, ] +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + [[package]] name = "rich" version = "15.0.0" @@ -2494,6 +3760,116 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3f/dd/0b2c68495331ba36af783139baaa94693ef310d484d458c11dfa1357287d/rioxarray-0.22.0-py3-none-any.whl", hash = "sha256:db0aa55cd36a95060968f2e6574107829def29d43a563560b90bc642d0bd6a3b", size = 72018, upload-time = "2026-03-06T17:10:58.965Z" }, ] +[[package]] +name = "rpds-py" +version = "2026.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256", size = 64459, upload-time = "2026-05-28T12:02:13.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/e7/a78582dc57caa592dcc7d4fb69b61390561e908eb3d2f5df5928a8e354c0/rpds_py-2026.5.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3abe24a66e57adcfa645d718063a5fa5103ecc71ddbf26d78af8f9368018ff1d", size = 353040, upload-time = "2026-05-28T11:59:12.531Z" }, + { url = "https://files.pythonhosted.org/packages/a3/43/35e3f136343aef451e545ce8c38d36c2f93c0ed88703db8b64ba2b205c68/rpds_py-2026.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b1d94308ddf0b1982f61f2eb54bf92997c9ece8a8093ef014250f4a517906c", size = 345775, upload-time = "2026-05-28T11:59:13.827Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/0f2160c5982d3157734d5cb3ed63d8b2d583a73c9864f77b666449f32cf8/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fa92420128dadce7f54bd73ba1825a273e9268fe9e35dbf7e6362890efa4e08", size = 376329, upload-time = "2026-05-28T11:59:15.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/11/ee0ba42aff83bf4effdbc576673c6be64c5e173978c3f6d537e94482f77d/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ca653c6546386227cd9800d1bef6a348099acf8db4250341da6d90f663d6dfcb", size = 383539, upload-time = "2026-05-28T11:59:16.665Z" }, + { url = "https://files.pythonhosted.org/packages/11/df/d94aa6a499d4ac40afe2d7620f2c597fd3c0f182e854ad7cf3f596a81cb6/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66c93681c4729e4e3ecba31b8179fae083ff3118841672835140338b4b9867c1", size = 494674, upload-time = "2026-05-28T11:59:17.991Z" }, + { url = "https://files.pythonhosted.org/packages/1f/75/33d30f43bb2f458de11979486a591b1bf6e5651765ed1704c6197c2dc773/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40ff257542e04796880e011e15cd4dc21c2599975df2aaa8f2c8495ca574e1a5", size = 389268, upload-time = "2026-05-28T11:59:19.434Z" }, + { url = "https://files.pythonhosted.org/packages/f4/1e/2c9096fc19d5fd084b0184ca2b651e659aa0a37e6fdbecf6ece47f147fe1/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6825cc329b290e93c5f6a9be2393118a763f6ccf6abd83704e0c102ca583644", size = 376280, upload-time = "2026-05-28T11:59:21Z" }, + { url = "https://files.pythonhosted.org/packages/b9/e5/61ec9f8be8211ea7f48448195549e4aaf02004083475493b0e137702ecb2/rpds_py-2026.5.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:de42116e69cb53b911cc34aee5ab98f36c597b822545045d49e938818b99e5e4", size = 387233, upload-time = "2026-05-28T11:59:22.454Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ca/bcec1005c4f4a234f92a29078631fee49206c7265ccae966f18fd332e80e/rpds_py-2026.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c0f920015df2a504bebaba6d4c31ccf3fcf942f92655c086da30b671aad19aa6", size = 405009, upload-time = "2026-05-28T11:59:23.845Z" }, + { url = "https://files.pythonhosted.org/packages/72/e6/4d5718c5cf26c522dc7c9999e238da1e77380b81d0c5d1df11e271ddfeb1/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0408a24e44feb919423dc6d9da677cb5cddb894d2ca9e763967d156d9c60fab4", size = 553113, upload-time = "2026-05-28T11:59:25.184Z" }, + { url = "https://files.pythonhosted.org/packages/d4/25/2ee807bdb3e1f0b7eddf7782acd5665a8b5205a331a7d7244a52c4812fd9/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cea68bcd53467561ae2f96a6bdad1544299ba97b5b0ddcd5ac3d376e5c781c24", size = 618838, upload-time = "2026-05-28T11:59:26.749Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c1/7d4c26f167f8c41501cc073d30ee22082b16ce358cf5b00ec97cbc7804ea/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4be8b1d2a705cc37d08256004e1d07de143fa0075c8e85a3df020b776f62b732", size = 582436, upload-time = "2026-05-28T11:59:28.11Z" }, + { url = "https://files.pythonhosted.org/packages/04/1d/9d12b0a337bab46f4769f8857f4007e3b2d639e14f9a44a0efe157696e64/rpds_py-2026.5.1-cp312-cp312-win32.whl", hash = "sha256:6736718bd4fc49cbcb538ba30516fdbef161522acefb739657d48b97bd864fed", size = 212734, upload-time = "2026-05-28T11:59:29.689Z" }, + { url = "https://files.pythonhosted.org/packages/c5/93/e4116f2de7f56bc7406a76033dc501811ddeb22b7f056b92d632871ebb0c/rpds_py-2026.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:0a7d1eec967df0e9b22614a5e177622e0c89611d03727fa0cb48e45028907870", size = 229045, upload-time = "2026-05-28T11:59:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/53/6c3419d85eb2ec5938a37627c585b42d76a63bb731d6e42ed4b079ebf486/rpds_py-2026.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1841d067089e117142d79b98aa0df2f08b52f2ecc1819dd2700636c0db74a473", size = 223967, upload-time = "2026-05-28T11:59:32.318Z" }, + { url = "https://files.pythonhosted.org/packages/6c/32/14c961ad295f490eb0849ada8b79683e93a59b9de3afdd983eaf55fa6867/rpds_py-2026.5.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:efef4ac29c6ff495531eb17ee705b62841ecaa291b7c7077e848ea03e237164d", size = 352787, upload-time = "2026-05-28T11:59:33.655Z" }, + { url = "https://files.pythonhosted.org/packages/ca/bb/d1b85117967c11191441a7274ae616c65d93901d082c588f89a50a8da5ae/rpds_py-2026.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c39f5b67a8a2e67179ada2a954227d670fe65fa9098457f698f56ddf248709b3", size = 345179, upload-time = "2026-05-28T11:59:35Z" }, + { url = "https://files.pythonhosted.org/packages/7c/46/d84105f062e626a1b233f863907288a4708c2d833b8b4c6fb2764bc080c0/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5c30f3f04eef4fbd362226a6f31d7c8895ca4fbb6e0b790f6890a98d8da8559", size = 376173, upload-time = "2026-05-28T11:59:36.43Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/469d7959ce5b1201e1de135dc735b86db3b35dd0d1734f6a44246d5f061c/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:277f6c82f0580848796c7ecc8a7173aa3bfb928e4ff831261c2f60a81dc270db", size = 383162, upload-time = "2026-05-28T11:59:37.995Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a2/57853d31a1116a561aa072794602ad3f6341e18d70a8523f1bd5b9fc1e5a/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:63c2c4c213f1a4e3f3de28ecab029dbdee976324e729c0d7a55211be72576b02", size = 495093, upload-time = "2026-05-28T11:59:39.453Z" }, + { url = "https://files.pythonhosted.org/packages/99/63/3a8eabcad9314b7daf5c65f451d2c33d989235cd8a5762186cf2c3f5a4f8/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3350ec808fb538fe71a1f94dfaa0e29c598dfad805ce49f0caec5ae3183c652b", size = 389829, upload-time = "2026-05-28T11:59:40.896Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/05678d97fc25e2622df14dc530fb82023174ecfff6733991ed0d78f167bd/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1b964e3ab599e718dc46c018d104b1ebc007cbc6567d827c94a687fca56d77e", size = 374786, upload-time = "2026-05-28T11:59:42.626Z" }, + { url = "https://files.pythonhosted.org/packages/88/d1/8c90b6431e80a3b91b284a5c7c8c0c4f9c006444d90477a740d6e0f9c694/rpds_py-2026.5.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:19cb09fab7b7fc96b2a6e28f2e34b72a3705ff27b37edb77455316e5d3f3dc9b", size = 386920, upload-time = "2026-05-28T11:59:44.124Z" }, + { url = "https://files.pythonhosted.org/packages/ff/99/4638f672ab356682d633ee0da9255f5b67ce6efd0b85eb94ad3e255e65a5/rpds_py-2026.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:abe76bcdba31e576cb83eeb8797aa0d882b738fef6dc65d0601fc753806a5b46", size = 405059, upload-time = "2026-05-28T11:59:47.177Z" }, + { url = "https://files.pythonhosted.org/packages/66/3f/3546524b6eb4cc2e1f363a3d638fa52f6c24faae3500c25fb488b02f1740/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8bff7073db3899158fff55ebf57b113a67030af26f80a18978f9f0aa60250ddf", size = 553030, upload-time = "2026-05-28T11:59:48.603Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c3/7b3388c796fcf471bd17194242d4dc1a7608567c0fa422bcc1c5e79f9c1e/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8ba264fa49be666cd9cc56bf34ec7002fb3d27a4aee5bcb4d43d0d18feb1bb6f", size = 618975, upload-time = "2026-05-28T11:59:50.314Z" }, + { url = "https://files.pythonhosted.org/packages/61/1e/a3cb07f2795075d1d88efddae2f541359fde5f08c81ee114c29c2949c90a/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4860b603ddda0475a8885499b3729e90229d480105b42651962a5397d995fa89", size = 581178, upload-time = "2026-05-28T11:59:51.673Z" }, + { url = "https://files.pythonhosted.org/packages/a1/74/e758c03a5ef46f04c37f2651a2893db846d569ba8a7bca469d4b58939bcd/rpds_py-2026.5.1-cp313-cp313-win32.whl", hash = "sha256:7944270ae71383f6e2657dd7d5ce4eeb4ac2d0059a6738f0510583d462ab4842", size = 212481, upload-time = "2026-05-28T11:59:53.148Z" }, + { url = "https://files.pythonhosted.org/packages/70/ec/a2aca432db9c7359b40fa393eeeaa0d166c2f70175be956e75fa24197c44/rpds_py-2026.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:88647f43a73c4e01be19b04ceef0c8d3a1958153604d13c773becd8016f2a0cf", size = 228519, upload-time = "2026-05-28T11:59:54.505Z" }, + { url = "https://files.pythonhosted.org/packages/29/60/a73bfdd45b096574556acf303bbd9fa9eed36ca8a818b514e2a5d5fe2b9d/rpds_py-2026.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:453895624ecf7db7063b1004e44037522bbaef9ff6a945e59bc71662d7a03abd", size = 223446, upload-time = "2026-05-28T11:59:56.081Z" }, + { url = "https://files.pythonhosted.org/packages/18/e2/408105fd611823f00882aea810f3989a30d26b1bab8b6beb20f98c724e0e/rpds_py-2026.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:b4e4bc98639ec915f512fde3aa7a95e0041d95d9c3cc86eea841fa63cb1e8600", size = 355287, upload-time = "2026-05-28T11:59:57.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/58/5c4a43436843c90d0f6d19f82c200c80e3843ca9fa07b237623327f6d384/rpds_py-2026.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cacedb7a6e167680acba45ad5716e89067d225dc80da0d7040cae8c81d4572fa", size = 347033, upload-time = "2026-05-28T11:59:58.881Z" }, + { url = "https://files.pythonhosted.org/packages/fb/c2/1a71acdacaf4e259b10278fb87b039ded3cf80041bcd89dd8a3ea702ded6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68700371c5d7ae1412862ddfa719090925c93ecf351c566d66f09d04b136ea00", size = 376891, upload-time = "2026-05-28T12:00:00.516Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c8/535f3d9b65addd8e28aa87b83c6e526799c3717a88273db8ea795beeef7a/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:296c799becfa849c779c8725494fe9ed94959ed886787df4364b058465bad7f0", size = 385646, upload-time = "2026-05-28T12:00:02.394Z" }, + { url = "https://files.pythonhosted.org/packages/1c/91/dc033f313345c354ade914dbe73cdb90b615a4409ea02430d5356794f3d8/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d3858b908218ee108d0bbfb2095ccc237648053c9bf98affad7cb079acaf1d97", size = 498830, upload-time = "2026-05-28T12:00:04.189Z" }, + { url = "https://files.pythonhosted.org/packages/27/fc/90fcbea459dbb8ddc18a2e0fd1de9412b48bc84ffff2db771cf714bacfd6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4fb8d2e7cb2f850b169806d61d1b991738acec96500a75c30f49caf064ce7cef", size = 392830, upload-time = "2026-05-28T12:00:05.797Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1d/46cd11a228c9750684a798d98f878be6f614aa762438da7378f035e79e35/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27b74c10ed6a8f190f4287f53bcfea348b92a84a9c9f70d30183d1e6172d580d", size = 379613, upload-time = "2026-05-28T12:00:07.433Z" }, + { url = "https://files.pythonhosted.org/packages/24/4a/d9b0c6af3a1de03eb93741bbe8be2bdce84d8fda8224f3005451d86df389/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:b9a6528956191c48c52294a592dbd4a8386d7048bdb25c0efcb6b966466c6d83", size = 388183, upload-time = "2026-05-28T12:00:09.227Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b4/db7aaabdda6d020afc87d981bcc2f57a434c7dec60ecfc2ab3dd50b20351/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:af03e34e860047bc7a352b842856fcf78798fbb81132cc98bd2f907ab4eb9cd2", size = 408578, upload-time = "2026-05-28T12:00:10.779Z" }, + { url = "https://files.pythonhosted.org/packages/08/d6/070f6a41cbb343e2ac4171859bf3f3623e0ab002f72619d6d505313ec2de/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fea6e836d10abbe191d557d33bd58bd5987725fe63aa1eefe557d230209855bd", size = 553573, upload-time = "2026-05-28T12:00:12.443Z" }, + { url = "https://files.pythonhosted.org/packages/75/ab/1a71ea3589c4345dac0a0518f0e6a031cb42689277851b683c46d27463a5/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:fc0c0f878ea770a0a8a462456c5ad36fc9fe6358e6b76fdadc7f17575e0b8bf1", size = 620861, upload-time = "2026-05-28T12:00:14.09Z" }, + { url = "https://files.pythonhosted.org/packages/8a/22/9bf80a56069c0c443fcfefac639a86a744550a2898817a6dfd3e26654924/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3", size = 585633, upload-time = "2026-05-28T12:00:15.66Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/3b2c0a75c9e04125696f84ebdbbf304acf5a40b58ba4481cdb98a922c3ba/rpds_py-2026.5.1-cp313-cp313t-win32.whl", hash = "sha256:a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc", size = 210074, upload-time = "2026-05-28T12:00:17.291Z" }, + { url = "https://files.pythonhosted.org/packages/e7/8b/609157d5a25d37d4f29f92840ba531f416907c34ae5c5739dd21fc2bef98/rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55", size = 228635, upload-time = "2026-05-28T12:00:18.73Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6f/19c1918a4b590d8de87e712e4abe4b3875771eff60216fb6153cf6665c68/rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9", size = 349756, upload-time = "2026-05-28T12:00:20.217Z" }, + { url = "https://files.pythonhosted.org/packages/e5/60/a06fe7da34eca79dacbf958a2ba0c6eea85bc2b29de20080bf40f72f66fa/rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78", size = 343831, upload-time = "2026-05-28T12:00:21.711Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/b2333b97b90e2a6ef6ca8ad386ee284968e74bcfe113b3f1a8d9036429a9/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63", size = 375127, upload-time = "2026-05-28T12:00:23.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/7f/e00aae54067f2b488c4637961d5f58204d470795fc791085fa3f15060d2e/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a", size = 379034, upload-time = "2026-05-28T12:00:24.89Z" }, + { url = "https://files.pythonhosted.org/packages/be/cc/423999bbb8ae8dc93c77fc1d5e984ade5eb89d237d3bb884ccfa72ae2890/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195", size = 490823, upload-time = "2026-05-28T12:00:26.676Z" }, + { url = "https://files.pythonhosted.org/packages/0f/aa/c671bf660f12e68d3c52ff86c7066ed1372df5a0f4f2ff584e419b8207e7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee", size = 388144, upload-time = "2026-05-28T12:00:28.577Z" }, + { url = "https://files.pythonhosted.org/packages/19/c8/d63bb75b68afe77b229e3021c6031bcaf01da5db5b0e69d0d10f9ba679a7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba", size = 371959, upload-time = "2026-05-28T12:00:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/82/35/c51122014d8274ff37dc606d60049c3db7d83da02b5b282511e5a906a9a6/rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec", size = 383558, upload-time = "2026-05-28T12:00:31.764Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f9/2790cb99c136a5363acdeacf5c27c56f3de0d4118a1f48fca83404c99c89/rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d", size = 402789, upload-time = "2026-05-28T12:00:33.247Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1b/e4fb584f8c75d35c38150ff6a332cda949e6f97acba1f4fd123b14ab56fe/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d", size = 551405, upload-time = "2026-05-28T12:00:34.819Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f7/a6731b4216cb3793ea1af5391da240f5683dacc0d13e034fe5fc3503f240/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02", size = 616975, upload-time = "2026-05-28T12:00:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/2e051a81d95d8e63f4b35a1c463a87e8766bc3d083c067c5dfb6bf220747/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0", size = 578701, upload-time = "2026-05-28T12:00:37.82Z" }, + { url = "https://files.pythonhosted.org/packages/65/56/b5f6fdb2083e32bca8a8993d89e70db114b4756c9e2c38421328126689d2/rpds_py-2026.5.1-cp314-cp314-win32.whl", hash = "sha256:2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7", size = 209806, upload-time = "2026-05-28T12:00:39.492Z" }, + { url = "https://files.pythonhosted.org/packages/fb/80/65a5aa96c155e611d1ed844e4e1f57f3e36b021f396d9f8585d756e6b90d/rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838", size = 225985, upload-time = "2026-05-28T12:00:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/27/7c/ad185212e87b05f196daef92bc5f3caf07298eb47c295b5585c3dd3093ac/rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8", size = 221219, upload-time = "2026-05-28T12:00:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/23/58/e14ae18759020334646b031e708ab4158d653a938822bfb7b95ef2e93aa3/rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad", size = 352148, upload-time = "2026-05-28T12:00:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/31/9b/5f4a1e2f960bca3ac5d052b139dd31eed97b259f9d909173821760d542e8/rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3", size = 345196, upload-time = "2026-05-28T12:00:46.14Z" }, + { url = "https://files.pythonhosted.org/packages/1a/71/1d9574d6a2fa20ab60eaa55c7467f5aa20cbc770f341a05f09c0876f59e2/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081", size = 374981, upload-time = "2026-05-28T12:00:47.531Z" }, + { url = "https://files.pythonhosted.org/packages/0c/9a/37e99f4915a80aa71670263c1267f7ae0af95f53a3f61e6c3bdc016d4515/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6", size = 379961, upload-time = "2026-05-28T12:00:49.216Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ff/6e73f74b89d2e0715e0fc86b7dde893f9a61ae2f9b256ff3bdfe41ac4e94/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5", size = 495965, upload-time = "2026-05-28T12:00:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/ea/e0/425faba25f59d74d4638b267f7c7a80e8649d2ef4db10a19b0c4a71e6e6f/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b", size = 389526, upload-time = "2026-05-28T12:00:52.77Z" }, + { url = "https://files.pythonhosted.org/packages/c6/76/7a41960e3fddae47fab43a28684d5da981401dffd88253de0944148654cb/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964", size = 376190, upload-time = "2026-05-28T12:00:54.215Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/5f38dc70824fc6951b51d35377e577a3a3a4c81a6769cc5a2de25ebe0ad1/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131", size = 383921, upload-time = "2026-05-28T12:00:55.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/1a/d60a38caa1505f4b9483c3fbbde12c94e1079154f4f401a6da96f7e77621/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81", size = 404766, upload-time = "2026-05-28T12:00:57.518Z" }, + { url = "https://files.pythonhosted.org/packages/87/ff/602fd3f174d6425f0bce05ad0dfbec0e96b38d0f7d08a79af5aa20083885/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47", size = 551343, upload-time = "2026-05-28T12:00:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c1/1be13327acdbead3eca1fde03b6a34dbb011f1e864e217f0d32cc1779a7f/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a", size = 618502, upload-time = "2026-05-28T12:01:00.656Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d7/afb49b49d7f2be8b7ba1a9f0977fa5168003437b93086726f066544e8351/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca", size = 581916, upload-time = "2026-05-28T12:01:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/dbef8c1f8a10f07beb62b5f054e20099fd9924b3ec001b8f0b6ac7813a85/rpds_py-2026.5.1-cp314-cp314t-win32.whl", hash = "sha256:6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a", size = 207855, upload-time = "2026-05-28T12:01:03.821Z" }, + { url = "https://files.pythonhosted.org/packages/2a/72/bfa4e61ab8e7dc1c8adf397e05e6cbdd4239357bd72b248d3de662f23915/rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6", size = 225422, upload-time = "2026-05-28T12:01:05.194Z" }, + { url = "https://files.pythonhosted.org/packages/27/3a/7b5da92b640f67b6717ccafc83cdd06bfa7ff2395c3685c68922bb54d703/rpds_py-2026.5.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:3574b55c604b8f75dacb007136508bbc0db406e626301778096a133327e7f2fb", size = 349576, upload-time = "2026-05-28T12:01:06.722Z" }, + { url = "https://files.pythonhosted.org/packages/d7/8a/2aafd7ad355a1bd48ca76e2262b74b15e6432b5a1efe150efd4d779cd55d/rpds_py-2026.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:94068eb3ae6d43f5a786b7db96a406a34e6d5c24489feef32fd6e8946ea7b291", size = 343640, upload-time = "2026-05-28T12:01:08.441Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7d/6c9523c1abbe840a1b7fba3c516d48e1d3487cc80fea4366c4071cf56784/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a5b10e8ce894825f380a8f1b6444cf73c294dfea62afbb2d13e3a9e630cec1", size = 375322, upload-time = "2026-05-28T12:01:09.934Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5d/0b7b03fb1dc509321f01de3149784ab773e34c8573022029af8076afcb9c/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc09f82e63d4bcd58149572f857a431bae851dc747e313c3b5bdf7abb907fda8", size = 379066, upload-time = "2026-05-28T12:01:11.48Z" }, + { url = "https://files.pythonhosted.org/packages/d7/e2/8ef6012999ebf1cb1c22f876d9ce5e63d960fd4631d2af3202d3f480aa25/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e10464d17df3b582745c25cec695cb9558bca2cb6ddb631aee1787fc72c767b2", size = 494586, upload-time = "2026-05-28T12:01:13.051Z" }, + { url = "https://files.pythonhosted.org/packages/80/af/1eeb029bec67582c226b7809172207cd005073af4ebd906e65ff494f4983/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba05adbf15d994c38ec0b7ab32e858e5110c21e9009a00a86545fd220f84e038", size = 388415, upload-time = "2026-05-28T12:01:14.631Z" }, + { url = "https://files.pythonhosted.org/packages/18/23/ffbe10711c4d766c1cab0557d6906c074f795814863c67b351355d29354a/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77c004fdc7b891967106f78ddfd7b076bfe6813c6139c6fff6aed3bcaa960b26", size = 372427, upload-time = "2026-05-28T12:01:16.153Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3a/30ba4a6ad457e5b070c18d742a33fb77d8d922b565cc881f8a5313d63bfe/rpds_py-2026.5.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:83bcf894486c9d78dd290d3c0124ff6dd8875d3025e2090a8ec49fcc37c55fdd", size = 383615, upload-time = "2026-05-28T12:01:17.809Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/62e242b53ce39c0814bd24e1a6e6eba6c92be716277745f317f9540a2e7b/rpds_py-2026.5.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3df104083952a0e0c6f10de33e440eabe98fb6317d23e1a58c68f6df08d01b9", size = 402786, upload-time = "2026-05-28T12:01:19.419Z" }, + { url = "https://files.pythonhosted.org/packages/38/c1/a770b9c186928a1ed0f7e6d7ae50e7f3950ed23e3f9e366dbc8e38cb55de/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:980450826cf22e133c57e0835070bdd0dd3f73b9b708c3ce223def2cb9469e14", size = 551583, upload-time = "2026-05-28T12:01:21.013Z" }, + { url = "https://files.pythonhosted.org/packages/21/7c/68e8579b95375b70d2a963103c42e705856cdb98569258bd807f4423891c/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:205dde846f24332ab0c1188699a043b8d165b79bb84529ce272c45048ff6be01", size = 616941, upload-time = "2026-05-28T12:01:22.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/a1/a6135aed5730ff03ab957182259987ac11e55fb392a28dc6f0592048a280/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3966b82dd563176396df030f3dd52a6e54cb69b718e95e78bd555ed3d1e0185d", size = 578349, upload-time = "2026-05-28T12:01:24.118Z" }, + { url = "https://files.pythonhosted.org/packages/09/6e/f24201a76a84e6c49d0bdfdfcb735210e21701e9b21c5bfc0ba497dd62f6/rpds_py-2026.5.1-cp315-cp315-win32.whl", hash = "sha256:7818f8d0a415be74d2be3590b0a1c1f463a642f4d0217e7d10602dceef5b79aa", size = 209922, upload-time = "2026-05-28T12:01:25.522Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e4/966bc240bb0485fc265278f6de44d05834bf0b3618886e0b22e33d54c49a/rpds_py-2026.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:b3cc20c0d800af78fd0fac68086e28c1856cec51ea528bb81ea851aa40d39325", size = 226003, upload-time = "2026-05-28T12:01:27.062Z" }, + { url = "https://files.pythonhosted.org/packages/5c/5c/a15a59269cd5e74472734516c73795c15eccfc841b3d4b0228c3f53f19d0/rpds_py-2026.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:3609e9939a8a76cd904cf98a3f1f13b5dc7e150adeaee89e0ea09652ea213e16", size = 221245, upload-time = "2026-05-28T12:01:28.51Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/135ce03804e179a71ceb13be095deda4a279bc88f7a6b8fa161c5ad44e12/rpds_py-2026.5.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:5d333a7127d4b307601ac37792bee01bb95c867cbfacf21b6375b804d6bbd723", size = 352015, upload-time = "2026-05-28T12:01:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5f/f1f6d2652eb9d848f6eb369d8db83a2da6249bb49ad2c2a48f45d54538d3/rpds_py-2026.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:b5f077b44a4f7808520f66dae234988d867deb9aed9be5da057ce9ba831b2a41", size = 345016, upload-time = "2026-05-28T12:01:31.656Z" }, + { url = "https://files.pythonhosted.org/packages/88/66/b74182775691ea2290c99e52ac8d5db844e56fbec90ce421f107658c8314/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55d8f9b7b78c9538fc9e04e82ec0e888ff0c3cffcfad152c77e57cd09351a98a", size = 374775, upload-time = "2026-05-28T12:01:33.136Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8f/15e5a61d9f0a43902d36561d4f07cae6ae9f4716be825159fd72717f33af/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e3a8ae58895ac107ed934a6bf51e5846f95c53b9b940c2c6d310838fd5846358", size = 380270, upload-time = "2026-05-28T12:01:34.574Z" }, + { url = "https://files.pythonhosted.org/packages/02/c3/f859b12763a80540cdf2af0f15b19904cf756a71d7bdd3f82ff3e5b1bbf9/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0957cf3c2b8632ec7aaebffebea8005b353cc2a237b6e2ae3c2cac0820704cfb", size = 495285, upload-time = "2026-05-28T12:01:36.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c7/ff27c2ac8411d30b03b1829fd88cae8dad1a4d0da48dd25e57c4038042e6/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c396c1304de421050b3681ea70f371874b54d41b0151e96109758144c231e30b", size = 389581, upload-time = "2026-05-28T12:01:37.635Z" }, + { url = "https://files.pythonhosted.org/packages/6e/67/fe92ee32a6cc05c77228a2f8b1762e7124f386ec20ff83d0757b762d58d0/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aad1bff7f666b9598e573815affd666aac6a13a585dde336f843e33350c7fadc", size = 376041, upload-time = "2026-05-28T12:01:39.307Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/b4d6685c27aba55bd82f25b278be8237038117d05f9659a6213ad3408130/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:656a042550878f12d45752452d47094b7cfe5ad1e9d7b87b5a22ad3ae5ff8015", size = 383946, upload-time = "2026-05-28T12:01:41.043Z" }, + { url = "https://files.pythonhosted.org/packages/bd/79/2c1d832a53c8e0f8e98fc970ec257b950fecd4f62be2ab7182b500a0cbc8/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c4bd4f70294737b5206a3e8e30ccadbf8a60301831c8ea23eec5dbeea1ecfa", size = 405526, upload-time = "2026-05-28T12:01:43.032Z" }, + { url = "https://files.pythonhosted.org/packages/78/c4/c98117b03c6a8581ab2c2dfccfe9a5ad82bd8128a3c28b46a6ad2d97c393/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:43bca78665423cabae77146f2fe7ce55272b6c8d55d82cca83effd42c7e13972", size = 551165, upload-time = "2026-05-28T12:01:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c1/bc479ca069200af730881b1bd525e3114b2b391a351509fcb1b772f28086/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:42d0f20e85e549c870749d0e247f0c10d318a45b7e9676d575d2dcb04a1b2e66", size = 618778, upload-time = "2026-05-28T12:01:46.337Z" }, + { url = "https://files.pythonhosted.org/packages/77/65/38ab2f90df44c2febfb63cc10ced40763d9b4bc94d173e734528663fe7f5/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b1be5c35683684d5331b93600c210e8367c254683d8a6df6bd21bd2da3a334fb", size = 581839, upload-time = "2026-05-28T12:01:48.109Z" }, + { url = "https://files.pythonhosted.org/packages/15/2d/ce1f605fe036aadd460e5822e578c6c7ec3a860936cca37d6e0f299daa77/rpds_py-2026.5.1-cp315-cp315t-win32.whl", hash = "sha256:75808f6c38ce7749bb68cc2770161aae5045e6c6f6781a9782e74b93304399df", size = 207866, upload-time = "2026-05-28T12:01:49.648Z" }, + { url = "https://files.pythonhosted.org/packages/79/cb/966040123eb102371559746908ef2c9471f4d43e17ec9a645a2258dab64b/rpds_py-2026.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:90bd6630002a1c7f09e7843dd79f0d24f3d2897cc25a753480917865d14f15b3", size = 225441, upload-time = "2026-05-28T12:01:51.408Z" }, +] + [[package]] name = "ruff" version = "0.15.12" @@ -2545,6 +3921,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/87/72/c6c32d2b657fa3dad1de340254e14390b1e334ce38268b7ad51abda3c8c2/s3transfer-0.17.0-py3-none-any.whl", hash = "sha256:ce3801712acf4ad3e89fb9990df97b4972e93f4b3b0004d214be5bce12814c20", size = 86811, upload-time = "2026-04-29T22:07:34.966Z" }, ] +[[package]] +name = "send2trash" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + [[package]] name = "simplejson" version = "4.1.1" @@ -2616,6 +4001,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, ] +[[package]] +name = "soupsieve" +version = "2.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + [[package]] name = "starlette" version = "1.0.0" @@ -2669,6 +4077,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/be/5d2d47b1fb58943194fb59dcf222f7c4e35122ec0ffe8c36e18b5d728f0b/tblib-3.2.2-py3-none-any.whl", hash = "sha256:26bdccf339bcce6a88b2b5432c988b266ebbe63a4e593f6b578b1d2e723d2b76", size = 12893, upload-time = "2025-11-12T12:21:14.407Z" }, ] +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, +] + [[package]] name = "titiler-core" version = "2.0.2" @@ -2733,6 +4167,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, ] +[[package]] +name = "traitlets" +version = "5.15.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" }, +] + [[package]] name = "typing-extensions" version = "4.15.0" @@ -2763,6 +4206,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, ] +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + [[package]] name = "urllib3" version = "2.7.0" @@ -2820,6 +4272,51 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" }, ] +[[package]] +name = "wcwidth" +version = "0.8.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/b4/51fe890511f0f242d07cb1ebe6a5b6db417262b9d2568b460347c57d95cc/wcwidth-0.8.1.tar.gz", hash = "sha256:faf5b4a5366a72dc49cad48cdf21f52bdf63bdda995178e483ba247ff79089b9", size = 1466072, upload-time = "2026-06-08T05:57:23.146Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/6e/95b0e537de1f4d4301f76f944642c6da50d1511cc7b3d64dc418a66c7509/wcwidth-0.8.1-py3-none-any.whl", hash = "sha256:f453740b1e4a4f3291faa37944c555d71056c4da08d59809b307ef4feba695c8", size = 323092, upload-time = "2026-06-08T05:57:21.413Z" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" }, +] + [[package]] name = "wrapt" version = "2.1.2" From 7a8361ac91563922387a33ee8687bf44f080e906 Mon Sep 17 00:00:00 2001 From: Davis Bennett Date: Mon, 6 Jul 2026 11:31:04 +0200 Subject: [PATCH 24/58] bump zarr conventions; migrate type checking to pyright (#199) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix the types * refactor: build all conventions via zarr_cm.create_many Route multiscales, spatial, and proj convention metadata through a single utils.build_convention_attrs() helper that delegates to zarr_cm.create_many, so zarr-cm validates each convention and emits its CMO. Previously the CMOs were hand-placed and the spatial:/proj:/multiscales keys assembled by hand, which skipped zarr-cm validation (e.g. multiscales' layout>=1 and derived_from=>transform rules) and duplicated key strings. Type the helper precisely with zarr-cm's TypedDicts (SpatialAttrs, GeoProjAttrs, MultiscalesAttrs, MultiConventionAttrs) and a CRSLike Protocol instead of dict[str, Any]. Multiscales data is still produced by the project's MultiscaleMeta model (it also covers the TMS encoding zarr-cm doesn't model), but its CMO and validation now go through zarr-cm. Output is byte-identical to before (verified against the golden-file snapshot tests). Add tests/test_conversion/test_convention_attrs.py covering the helper, including that zarr-cm now rejects an invalid multiscales layout. Co-Authored-By: Claude Opus 4.8 * chore: gitignore local scratch files and .claude/ Ignore root-level scratch files (test.py, tmp.json, cli_test.sh) and the machine-local .claude/ session directory so they stop showing in git status. Co-Authored-By: Claude Opus 4.8 * Revert "chore: gitignore local scratch files and .claude/" This reverts commit 4a5b6e45d96da3fdaf5e5d888e49d11da825c474. * fix type checking errors * wire up mypy correctly in pre-commit * build: migrate type checker mypy -> pyright; upgrade zarr-cm zarr-cm's convention TypedDicts now use PEP 728 `extra_items`, which mypy does not support. Switch the type checker to pyright (which does) and upgrade to the zarr-cm main git dep that also ships the supporting fixes: - Mapping-covariant aggregate API + exported JsonType/JsonValue/JsonDict, so build_convention_attrs no longer needs a private `_core` import or a cast. - PEP 695 `type JsonValue` alias, so pydantic resolves MultiscaleGroupAttrs' ConventionMetadataObject field directly (removed the model_rebuild workaround). Toolchain: - pyproject: replace [tool.mypy] with [tool.pyright]; mypy -> pyright dev dep. - .pre-commit-config / CI lint job: run `uv run --frozen pyright`. Type fixes across src/ and tests/ to reach a clean pyright run (0 errors): - remove stale mypy `# type: ignore[...]` comments (pyright-unnecessary); - narrow NotRequired TypedDict access (`.get()` + guard) instead of making keys Required, preserving runtime validation of optional Sentinel-1/2 members; - replace casts on external/untyped data with runtime isinstance/validation; - model construction via `Model.model_validate(...)` instead of `**dict`. No `typing.Any` introduced. Runtime behavior unchanged. Co-Authored-By: Claude Opus 4.8 * refactor: replace unverified casts with runtime checks Three casts asserted a type derived from Any or a union without verifying it. Replace each with an isinstance guard that raises TypeError on violation, so the assumption is enforced at runtime instead of only asserted to the checker: - sentinel1_reprojection: rio.write_crs() returns Any -> verify xr.Dataset. - s2_multiscale: output_group[base_path] is Array | Group -> verify zarr.Group. - s2_multiscale: client.compute() returns Any -> verify distributed.Future. The remaining casts bridge types on data we already validated (model_dump / create_many output), satisfy protocol/TypeVar binding on `self`, or widen a TypedDict for a third-party API — a runtime check there adds no safety. Co-Authored-By: Claude Opus 4.8 * chore: use latest version of zarr-cm * fix: re-add CF _FillValue after attr sanitization in s2 multiscale encoding create_measurements_encoding injected the _FillValue=NaN attribute (the workaround for xarray issue #11345) before calling sanitize_array_attrs, which unconditionally strips _FillValue — so the workaround never reached the written dataset. Track the injection with a flag and apply it after sanitization, mirroring the ordering already used in geozarr.py. Also document in sanitize_array_attrs that _FillValue is always removed and that callers needing the CF attribute must re-add it after sanitizing. Assisted-by: ClaudeCode:claude-fable-5 * fix: preserve integer S1 nodata in encoding; document S2 CLI auto-routing Record the determined nodata in the reprojected S1 variable's encoding["_FillValue"]: the downstream attribute sanitization in setup_datatree_metadata_geozarr_spec_compliant strips _FillValue from attrs and only re-adds it for float variables, and explicit_fill_value reads from encoding, so integer nodata was lost from the output metadata. Also document in the convert subcommand help that Sentinel-2 inputs are auto-routed to the optimized flat multiscale layout and that --groups, --crs-groups, --gcp-group and --min-dimension do not apply there. Assisted-by: ClaudeCode:claude-fable-5 * feat: add --no-s2-optimized flag to force generic conversion path The convert command auto-detects Sentinel-2 inputs and routes them to the optimized flat multiscale layout, silently ignoring --groups, --crs-groups, --gcp-group and --min-dimension. Add a --no-s2-optimized escape hatch that disables the auto-detection so those options can still be honored for S2 inputs, and use it in test_cli_convert_with_crs_groups so the test exercises the crs-groups code path again instead of routing away from it. Also remove dead GCP handling in write_geozarr_group: the Sentinel-1 branch materialized dt_input[gcp_group].to_dataset() and immediately discarded it, since reprojection already happened upstream. Assisted-by: ClaudeCode:claude-fable-5 * docs: drop stale tile_width references from README The tile_width parameter was removed from create_geozarr_dataset along with the TMS-based multiscale layout, but the README examples and parameter list still mentioned it; copy-pasting them raised TypeError. Assisted-by: ClaudeCode:claude-fable-5 * fix: log multiscales creation failures at error level with traceback The broad except around create_geozarr_compliant_multiscales logged only a warning with str(e), silently swallowing defects in the rewritten ZCM layout / convention-validation logic. Keep the deliberate continue-with-next-group behavior but log via log.exception (error level, full traceback) so a malformed multiscales block is surfaced instead of hidden. Assisted-by: ClaudeCode:claude-fable-5 * chore: commit zarr-cm re-lock left out of previous commit The pyproject change to zarr-cm>=0.4.1 (e75b3b5) updated the dependency from the git rev to the PyPI release, but the corresponding uv.lock update was never committed. Assisted-by: ClaudeCode:claude-fable-5 * fix(deps): bump tornado to >=6.5.7 and msgpack to >=1.2.1 for CVEs pip-audit in the security workflow flags tornado 6.5.5 (CVE-2026-49853/49854/49855, GHSA-pw6j-qg29-8w7f; fixed in 6.5.7) and msgpack 1.1.2 (GHSA-6v7p-g79w-8964; fixed in 1.2.1). Both are transitive dependencies via distributed; raise the uv constraint-dependencies floors and re-lock. Assisted-by: ClaudeCode:claude-fable-5 * test: cover S1 member accessors, CLI S2 routing, and Dataset validators Raises patch coverage on this branch from ~34% to ~94%: - test_s1.py: reflectively exercise all 96 generated member-accessor properties on the S1 group models (returns member when present, KeyError when absent), plus the root polarization-group helpers. - test_cli_convert_routing.py: in-process tests for _is_sentinel2_input (detected / not detected / exception-swallowing) and convert_command dispatch (S2 auto-routing, --no-s2-optimized escape hatch, generic path for non-S2 inputs). - test_v2.py / test_v3.py: validate Dataset models end-to-end so the model_validator wrappers run, including the missing-grid-mapping failure branch. Assisted-by: ClaudeCode:claude-fable-5 --------- Co-authored-by: Claude Opus 4.8 --- .github/workflows/ci.yml | 28 +- .pre-commit-config.yaml | 17 +- README.md | 3 - pyproject.toml | 54 +- src/eopf_geozarr/cli.py | 45 +- src/eopf_geozarr/conversion/fs_utils.py | 54 +- src/eopf_geozarr/conversion/geozarr.py | 111 ++-- .../conversion/sentinel1_reprojection.py | 25 +- src/eopf_geozarr/conversion/utils.py | 70 ++- src/eopf_geozarr/data_api/geozarr/common.py | 2 +- .../data_api/geozarr/multiscales/geozarr.py | 26 +- .../data_api/geozarr/multiscales/zcm.py | 25 +- src/eopf_geozarr/data_api/geozarr/store.py | 10 +- src/eopf_geozarr/data_api/geozarr/v2.py | 31 +- src/eopf_geozarr/data_api/geozarr/v3.py | 19 +- src/eopf_geozarr/data_api/s1.py | 562 +++++++++++++----- src/eopf_geozarr/data_api/s2.py | 72 ++- src/eopf_geozarr/pyz/common.py | 15 +- src/eopf_geozarr/pyz/v2.py | 8 +- src/eopf_geozarr/pyz/v3.py | 6 +- .../s2_optimization/s2_converter.py | 67 ++- .../s2_optimization/s2_data_consolidator.py | 2 +- .../s2_optimization/s2_multiscale.py | 193 +++--- ...041_N0511_R122_T32TQM_20251008T122613.json | 116 ++-- ...309_N0511_R108_T32TLQ_20250113T122458.json | 84 +-- ...131_N0511_R037_T29TPF_20250811T152216.json | 116 ++-- ...041_N0511_R122_T32TQM_20251008T122613.json | 116 ++-- ...309_N0511_R108_T32TLQ_20250113T122458.json | 84 +-- ...131_N0511_R037_T29TPF_20250811T152216.json | 116 ++-- tests/conftest.py | 21 +- tests/test_array_attrs.py | 9 +- tests/test_cli_convert_routing.py | 139 +++++ tests/test_cli_e2e.py | 9 +- tests/test_convention_attrs.py | 142 +++++ tests/test_data_api/conftest.py | 7 +- tests/test_data_api/test_geoproj.py | 24 +- .../test_data_api/test_geozarr/test_common.py | 33 +- .../test_multiscales/test_geozarr.py | 17 +- .../test_geozarr/test_multiscales/test_zcm.py | 4 +- tests/test_data_api/test_projjson.py | 184 +++--- tests/test_data_api/test_s1.py | 72 ++- tests/test_data_api/test_s2.py | 4 +- tests/test_data_api/test_spatial.py | 50 +- tests/test_data_api/test_v2.py | 46 +- tests/test_data_api/test_v3.py | 53 +- tests/test_docs.py | 5 +- tests/test_fs_utils.py | 31 +- tests/test_integration_sentinel1.py | 12 +- tests/test_integration_sentinel2.py | 6 +- tests/test_reprojection_validation.py | 4 +- tests/test_s2_converter_simplified.py | 4 +- tests/test_s2_data_consolidator.py | 40 +- tests/test_s2_multiscale.py | 53 +- tests/test_scale_offset.py | 2 +- tests/test_titiler_integration.py | 6 +- uv.lock | 287 +++------ 56 files changed, 2133 insertions(+), 1208 deletions(-) create mode 100644 tests/test_cli_convert_routing.py create mode 100644 tests/test_convention_attrs.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 00f7ca57..b059bc53 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -10,19 +10,25 @@ permissions: contents: read jobs: - pre-commit: + lint: runs-on: ubuntu-latest steps: - - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3 - with: - persist-credentials: false - - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6 - with: - python-version: '3.12' - - name: Install pre-commit - run: pip install pre-commit - - name: Run pre-commit - run: pre-commit run --all-files + - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3 + with: + persist-credentials: false + - name: Set up Python + uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 + with: + python-version: "3.12" + - name: Install uv + uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0 + with: + enable-cache: true + - name: Install dependencies + # The pyright pre-commit hook runs `uv run --frozen pyright`, so the + # project environment must be present. + run: uv sync --group dev --group test + - uses: j178/prek-action@bdca6f102f98e2b4c7029491a53dfd366469e33d # v2.0.4 test: runs-on: ${{ matrix.os }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f19c8a37..52e24ad7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -11,13 +11,12 @@ repos: args: ["--fix", "--show-fixes"] - id: ruff-format - - repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.17.0 + - repo: local hooks: - - id: mypy - language_version: python - exclude: tests/.* - additional_dependencies: - - types-attrs - - typing-extensions>=4.15.0 - - pydantic>=2.12 + - id: pyright + name: pyright + language: system + entry: uv run --frozen pyright + pass_filenames: false + always_run: true + types_or: [python, pyi] diff --git a/README.md b/README.md index 44f3f6ea..877c691e 100644 --- a/README.md +++ b/README.md @@ -183,7 +183,6 @@ dt_geozarr = create_geozarr_dataset( output_path="s3://my-bucket/geozarr-data/output.zarr", spatial_chunk=4096, min_dimension=256, - tile_width=256, max_retries=3 ) ``` @@ -207,7 +206,6 @@ dt_geozarr = create_geozarr_dataset( output_path="path/to/output/geozarr.zarr", spatial_chunk=4096, min_dimension=256, - tile_width=256, max_retries=3 ) ``` @@ -227,7 +225,6 @@ Create a GeoZarr-spec 0.4 compliant dataset from EOPF data. - `output_path` (str): Output path for the Zarr store - `spatial_chunk` (int, default=4096): Spatial chunk size for encoding - `min_dimension` (int, default=256): Minimum dimension for overview levels -- `tile_width` (int, default=256): Tile width for TMS compatibility - `max_retries` (int, default=3): Maximum number of retries for network operations **Returns:** diff --git a/pyproject.toml b/pyproject.toml index 2d371778..2e2ce41d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,7 +36,7 @@ dependencies = [ "rioxarray>=0.13.0", "cf-xarray>=0.8.0", "typing-extensions>=4.15.0", - "zarr-cm>=0.2.0", + "zarr-cm>=0.4.1", "aiohttp>=3.14.0", "s3fs>=2024.6.0", "boto3>=1.34.0", @@ -48,7 +48,7 @@ dependencies = [ dev = [ "pytest>=7.0.0", "pytest-cov>=4.0.0", - "mypy>=1.0.0", + "pyright>=1.1.390", "pre-commit>=3.0.0", "bandit[toml]>=1.7.0", ] @@ -149,40 +149,19 @@ ignore = [ "TRY003", # Long exception messages outside class - common pattern ] -[tool.mypy] -python_version = "3.12" -warn_return_any = true -warn_unused_configs = true -disallow_untyped_defs = true -disallow_incomplete_defs = true -check_untyped_defs = true -disallow_untyped_decorators = true -no_implicit_optional = true -warn_redundant_casts = true -warn_unused_ignores = true -warn_no_return = true -warn_unreachable = true -strict_equality = true -plugins = ["pydantic.mypy"] - -[tool.pydantic-mypy] -init_forbid_extra = true -init_typed = true -warn_required_dynamic_aliases = true -warn_untyped_fields = true - -[[tool.mypy.overrides]] -module = ["zarr.*", "xarray.*", "rioxarray.*", "cf_xarray.*", "dask.*"] -ignore_missing_imports = true - -[[tool.mypy.overrides]] -module = [ - "eopf_geozarr.data_api.s1", - "eopf_geozarr.data_api.s2", - "eopf_geozarr.data_api.geozarr.v2", - "eopf_geozarr.data_api.geozarr.store", -] -disable_error_code = ["valid-type"] +[tool.pyright] +include = ["src", "tests"] +pythonVersion = "3.12" +typeCheckingMode = "standard" +# Several runtime deps ship no type stubs; we can't fix their types here, so +# don't report missing stubs/sources for them. (Imports still resolve because +# the packages are installed in the environment.) +reportMissingTypeStubs = false +reportMissingModuleSource = false +# Match the strictness we relied on under mypy. +reportUnnecessaryTypeIgnoreComment = true +reportReturnType = "error" +reportUnnecessaryCast = "error" [tool.pytest.ini_options] minversion = "7.0" @@ -225,7 +204,8 @@ constraint-dependencies = [ "urllib3>=2.7.0", "requests>=2.33.0", "cryptography>=46.0.6", - "tornado>=6.5.5", + "tornado>=6.5.7", + "msgpack>=1.2.1", "filelock>=3.20.3", "virtualenv>=20.36.1", "black>=26.3.1", diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 53c3ee21..5e4d95da 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -184,14 +184,14 @@ def convert_command(args: argparse.Namespace) -> None: # Convert to GeoZarr compliant format log.info("Converting to GeoZarr compliant format...") - if _is_sentinel2_input(dt): + if _is_sentinel2_input(dt) and not getattr(args, "no_s2_optimized", False): # Sentinel-2 inputs use the optimized flat multiscale layout # (sibling r{N}m levels), shared with `convert-s2-optimized`. The # generic per-group options below do not apply to that layout. log.info( "Detected Sentinel-2 input; using optimized flat multiscale layout " "(per-group options such as --groups/--crs-groups/--gcp-group/--min-dimension " - "do not apply)" + "do not apply; pass --no-s2-optimized to force the generic path)" ) dt_geozarr = convert_s2_optimized( dt_input=dt, @@ -354,7 +354,7 @@ def format_data_vars(data_vars: dict[str, xr.DataArray]) -> str: # Fallback to simple format if xarray HTML fails vars_html = [] for name, var in data_vars.items(): - dims_str = format_dimensions(dict(zip(var.dims, var.shape, strict=True))) + dims_str = format_dimensions(dict(zip(map(str, var.dims), var.shape, strict=True))) dtype_str = str(var.dtype) vars_html.append( f""" @@ -450,7 +450,7 @@ def render_node(node: xr.DataTree, path: str = "", level: int = 0) -> str:

Variables

- {format_data_vars(node.ds.data_vars)} + {format_data_vars({str(k): v for k, v in node.ds.data_vars.items()})}
""" @@ -1074,7 +1074,16 @@ def create_parser() -> argparse.ArgumentParser: # Convert command convert_parser = subparsers.add_parser( - "convert", help="Convert EOPF dataset to GeoZarr compliant format" + "convert", + help="Convert EOPF dataset to GeoZarr compliant format", + description=( + "Convert EOPF dataset to GeoZarr compliant format. Sentinel-2 inputs are " + "auto-detected and converted with the optimized flat multiscale layout " + "(equivalent to convert-s2-optimized with keep_scale_offset disabled); for " + "those inputs the per-group options --groups, --crs-groups, --gcp-group and " + "--min-dimension do not apply. Pass --no-s2-optimized to force the generic " + "conversion path, which honors all options." + ), ) convert_parser.add_argument( "input_path", type=str, help="Path to input EOPF dataset (Zarr format)" @@ -1089,7 +1098,7 @@ def create_parser() -> argparse.ArgumentParser: type=str, nargs="+", default=["/measurements/r10m", "/measurements/r20m", "/measurements/r60m"], - help="Groups to convert (default: Sentinel-2 resolution groups)", + help="Groups to convert (ignored for auto-detected Sentinel-2 inputs)", ) convert_parser.add_argument( "--spatial-chunk", @@ -1101,7 +1110,10 @@ def create_parser() -> argparse.ArgumentParser: "--min-dimension", type=int, default=256, - help="Minimum dimension for overview levels (default: 256)", + help=( + "Minimum dimension for overview levels (default: 256; ignored for " + "auto-detected Sentinel-2 inputs)" + ), ) convert_parser.add_argument( "--max-retries", @@ -1113,12 +1125,19 @@ def create_parser() -> argparse.ArgumentParser: "--crs-groups", type=str, nargs="*", - help="Groups that need CRS information added on best-effort basis (e.g., /conditions/geometry)", + help=( + "Groups that need CRS information added on best-effort basis " + "(e.g., /conditions/geometry; ignored for auto-detected Sentinel-2 inputs)" + ), ) convert_parser.add_argument( "--gcp-group", type=str, - help="Groups where Ground Control Points (GCPs) are located (e.g., /conditions/gcp) (Sentinel-1)", + help=( + "Groups where Ground Control Points (GCPs) are located " + "(e.g., /conditions/gcp) (Sentinel-1; ignored for auto-detected " + "Sentinel-2 inputs)" + ), ) convert_parser.add_argument("--verbose", action="store_true", help="Enable verbose output") convert_parser.add_argument( @@ -1131,6 +1150,14 @@ def create_parser() -> argparse.ArgumentParser: action="store_true", help="Enable zarr sharding for spatial dimensions of each variable", ) + convert_parser.add_argument( + "--no-s2-optimized", + action="store_true", + help=( + "Disable Sentinel-2 auto-detection and use the generic conversion path, " + "honoring --groups/--crs-groups/--gcp-group/--min-dimension" + ), + ) convert_parser.set_defaults(func=convert_command) # Info command diff --git a/src/eopf_geozarr/conversion/fs_utils.py b/src/eopf_geozarr/conversion/fs_utils.py index f55a3ab0..b31ed878 100644 --- a/src/eopf_geozarr/conversion/fs_utils.py +++ b/src/eopf_geozarr/conversion/fs_utils.py @@ -3,7 +3,7 @@ import json import os from collections.abc import Mapping -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING, Any, Final, Literal, cast from urllib.parse import urlparse import s3fs @@ -16,6 +16,8 @@ if TYPE_CHECKING: import xarray as xr +ZarrOpenMode = Literal["r", "r+", "a", "w", "w-"] + _MISSING = object() # sentinel for missing optional attrs @@ -52,18 +54,44 @@ def replace_json_invalid_floats(obj: object) -> object: return obj +def _sanitize_attrs(attrs: Mapping[str, object]) -> dict[str, object]: + """Sanitize an attributes mapping, returning a typed ``dict``. + + Wraps :func:`replace_json_invalid_floats` (which is typed ``object -> object``) + and verifies the dict-in/dict-out invariant at runtime instead of casting. + """ + sanitized = replace_json_invalid_floats(dict(attrs)) + if not isinstance(sanitized, dict): # pragma: no cover - invariant guard + raise TypeError(f"expected a dict after sanitizing attrs, got {type(sanitized).__name__}") + return sanitized + + +_ZARR_MODES: Final = ("r", "r+", "a", "w", "w-") + + +def _zarr_mode(mode: str) -> ZarrOpenMode: + """Validate *mode* against zarr's accepted access modes and narrow its type. + + Checks the value at runtime instead of casting a bare ``str`` to the + ``Literal`` zarr expects. + """ + if mode not in _ZARR_MODES: + raise ValueError(f"Invalid zarr access mode {mode!r}; expected one of {_ZARR_MODES}") + return mode + + class NanCompatibleJSONEncoder(json.JSONEncoder): """ Custom JSON encoder that converts NaN, Inf, -Inf values to JSON-safe equivalents to ensure valid JSON output. """ - def encode(self, obj: Any) -> str: + def encode(self, o: Any) -> str: """ Encode object to JSON string, converting NaN values to "NaN". """ - converted_obj = replace_json_invalid_floats(obj) + converted_obj = replace_json_invalid_floats(o) return super().encode(converted_obj) @@ -87,7 +115,7 @@ def sanitize_dataset_attributes(ds: "xr.Dataset") -> "xr.Dataset": ds_clean = ds.copy() # Sanitize dataset attributes - ds_clean.attrs = replace_json_invalid_floats(ds_clean.attrs) + ds_clean.attrs = _sanitize_attrs(ds_clean.attrs) # Sanitize variable attributes for var_name in ds_clean.data_vars: @@ -95,14 +123,14 @@ def sanitize_dataset_attributes(ds: "xr.Dataset") -> "xr.Dataset": # Preserve _FillValue as-is — xarray encodes it via FillValueCoder on write; # converting np.nan to the string "NaN" would break FillValueCoder.encode. fill_value = var.attrs.get("_FillValue", _MISSING) - var.attrs = replace_json_invalid_floats(var.attrs) + var.attrs = _sanitize_attrs(var.attrs) if fill_value is not _MISSING: var.attrs["_FillValue"] = fill_value # Sanitize coordinate attributes for coord_name in ds_clean.coords: coord = ds_clean[coord_name] - coord.attrs = replace_json_invalid_floats(coord.attrs) + coord.attrs = _sanitize_attrs(coord.attrs) return ds_clean @@ -405,7 +433,12 @@ def open_s3_zarr_group(s3_path: str, mode: str = "r", **s3_kwargs: Any) -> zarr. Zarr group """ storage_options = get_s3_storage_options(s3_path, **s3_kwargs) - return zarr.open_group(s3_path, mode=mode, zarr_format=3, storage_options=storage_options) + return zarr.open_group( + s3_path, + mode=_zarr_mode(mode), + zarr_format=3, + storage_options=cast("dict[str, object]", storage_options), + ) def get_s3_credentials_info() -> S3Credentials: @@ -589,4 +622,9 @@ def open_zarr_group(path: str, mode: str = "r", **kwargs: Any) -> zarr.Group: Zarr group """ storage_options = get_storage_options(path, **kwargs) - return zarr.open_group(path, mode=mode, zarr_format=3, storage_options=storage_options) + return zarr.open_group( + path, + mode=_zarr_mode(mode), + zarr_format=3, + storage_options=cast("dict[str, object] | None", storage_options), + ) diff --git a/src/eopf_geozarr/conversion/geozarr.py b/src/eopf_geozarr/conversion/geozarr.py index e2a13b37..3d7a6bdc 100644 --- a/src/eopf_geozarr/conversion/geozarr.py +++ b/src/eopf_geozarr/conversion/geozarr.py @@ -18,25 +18,23 @@ import os import time from collections.abc import Hashable, Iterable, Mapping, Sequence -from typing import Any +from typing import TYPE_CHECKING, Any, cast import numpy as np import structlog import xarray as xr import zarr +import zarr.core.common +import zarr.core.group from pyproj import CRS from rasterio.warp import calculate_default_transform from zarr.codecs import BloscCodec from zarr.core.sync import sync from zarr.storage import StoreLike from zarr.storage._common import make_store_path -from zarr_cm import geo_proj -from zarr_cm import multiscales as multiscales_cm -from zarr_cm import spatial as spatial_cm from eopf_geozarr.data_api.geozarr.multiscales import zcm from eopf_geozarr.data_api.geozarr.multiscales.geozarr import ( - MultiscaleGroupAttrs, MultiscaleMeta, ) from eopf_geozarr.types import ( @@ -52,6 +50,10 @@ from .fs_utils import sanitize_dataset_attributes from .sentinel1_reprojection import reproject_sentinel1_with_gcps +if TYPE_CHECKING: + from zarr.core.common import JSON + from zarr_cm import MultiscalesAttrs + log = structlog.get_logger() @@ -372,7 +374,8 @@ def iterative_copy( consolidated=False, zarr_format=3, encoding=encoding, - storage_options=storage_options, + # xarray stubs type storage_options as dict[str, str]; S3FsOptions is broader + storage_options=storage_options, # pyright: ignore[reportArgumentType] ) dt_result[relative_path] = xr.DataTree(ds) @@ -504,14 +507,11 @@ def write_geozarr_group( if not success: raise RuntimeError(f"Failed to write all bands for {group_name}") - # Create GeoZarr-spec compliant multiscales - if _is_sentinel1(dt_input): - assert gcp_group is not None, "GCP group required for processing Sentinel-1" - ds_gcp = dt_input[gcp_group].to_dataset() - # For Sentinel-1, ds_gcp is set to None since data is now reprojected and doesn't need GCP handling - ds_gcp = None - else: - ds_gcp = None + # Create GeoZarr-spec compliant multiscales. GCPs are not needed here: + # Sentinel-1 data was already reprojected upstream (see + # setup_datatree_metadata_geozarr_spec_compliant), so multiscales are + # created without GCP handling. + ds_gcp: xr.Dataset | None = None try: log.info("Creating GeoZarr-spec compliant multiscales", group_name=group_name) @@ -525,7 +525,10 @@ def write_geozarr_group( enable_sharding=enable_sharding, ) except Exception as e: - log.warning( + # Deliberately continue with the remaining groups, but surface the + # failure loudly (with traceback): the output store is missing its + # multiscales metadata for this group. + log.exception( "Failed to create GeoZarr-spec compliant multiscales", group_name=group_name, error=str(e), @@ -585,7 +588,7 @@ def create_geozarr_compliant_multiscales( compressor = BloscCodec(cname="zstd", clevel=3, shuffle="shuffle") # Get spatial information from the first data variable - data_vars = [var for var in ds.data_vars if not utils.is_grid_mapping_variable(ds, var)] + data_vars = [var for var in ds.data_vars if not utils.is_grid_mapping_variable(ds, str(var))] if not data_vars: return {} @@ -672,26 +675,27 @@ def _spatial_transform_for( scale_level_data["spatial:transform"] = spatial_tf layout.append(zcm.ScaleLevel(**scale_level_data)) - multiscale_attrs = MultiscaleGroupAttrs( - zarr_conventions=(multiscales_cm.CMO, spatial_cm.CMO, geo_proj.CMO), - multiscales=MultiscaleMeta( - layout=layout, - resampling_method="average", - ), + # Validate + serialize the multiscales block via the project model (which + # also covers the ZCM/TMS duality), then hand all conventions to zarr-cm, + # which validates each and emits the matching CMOs in order (multiscales, + # spatial, proj). proj is included only when a CRS is available. + multiscales_data = cast( + "MultiscalesAttrs", + MultiscaleMeta(layout=tuple(layout), resampling_method="average").model_dump(), + ) + attrs_to_write = utils.build_convention_attrs( + multiscales=multiscales_data, + spatial={ + "spatial:dimensions": ["y", "x"], + "spatial:bbox": list(native_bounds), + "spatial:registration": "pixel", + }, + crs=native_crs or None, ) - attrs_to_write = multiscale_attrs.model_dump() - if native_crs and native_bounds: - attrs_to_write["spatial:dimensions"] = ["y", "x"] - attrs_to_write["spatial:bbox"] = list(native_bounds) - attrs_to_write["spatial:registration"] = "pixel" - if hasattr(native_crs, "to_epsg") and native_crs.to_epsg(): - attrs_to_write["proj:code"] = f"EPSG:{native_crs.to_epsg()}" - elif hasattr(native_crs, "to_wkt"): - attrs_to_write["proj:wkt2"] = native_crs.to_wkt() group_path = fs_utils.normalize_path(f"{output_path}/{group_name.lstrip('/')}") zarr_group = fs_utils.open_zarr_group(group_path, mode="r+") - zarr_group.attrs.update(attrs_to_write) + zarr_group.attrs.update(cast("dict[str, JSON]", attrs_to_write)) log.info("Added multiscales metadata to group %s", group_name) @@ -756,7 +760,8 @@ def _spatial_transform_for( zarr_format=3, encoding=encoding, align_chunks=align_chunks_flag, - storage_options=storage_options, + # xarray stubs type storage_options as dict[str, str]; S3FsOptions is broader + storage_options=storage_options, # pyright: ignore[reportArgumentType] ) overview_datasets[asset_name] = overview_ds @@ -1011,7 +1016,7 @@ def write_dataset_band_by_band_with_validation( ) # Get data variables - data_vars = [var for var in ds.data_vars if not utils.is_grid_mapping_variable(ds, var)] + data_vars = [var for var in ds.data_vars if not utils.is_grid_mapping_variable(ds, str(var))] successful_vars = [] failed_vars = [] @@ -1044,9 +1049,10 @@ def cleanup_prefix(prefix: str) -> None: for var in data_vars: # Check if this variable already exists and is valid if not force_overwrite and store_exists: - if utils.validate_existing_band_data(existing_dataset, var, ds): + assert existing_dataset is not None # guaranteed by store_exists + if utils.validate_existing_band_data(existing_dataset, str(var), ds): ds.drop_vars(str(var)) - ds[var] = existing_dataset[var] # type: ignore[index] + ds[var] = existing_dataset[var] log.info("✅ Band %s already exists and is valid, skipping.", var) skipped_vars.append(var) successful_vars.append(var) @@ -1114,7 +1120,8 @@ def cleanup_prefix(prefix: str) -> None: consolidated=False, zarr_format=3, encoding=var_encoding, - storage_options=store_storage_options, + # xarray stubs type storage_options as dict[str, str]; S3FsOptions is broader + storage_options=store_storage_options, # pyright: ignore[reportArgumentType] ) log.info(" ✅ Successfully wrote", var=var) @@ -1388,15 +1395,17 @@ def _create_encoding( for var in ds.data_vars: if hasattr(ds[var].data, "chunks"): current_chunks = ds[var].chunks + assert current_chunks is not None # guaranteed by hasattr(..., "chunks") if len(current_chunks) >= 2: chunking = tuple( current_chunks[i][0] if len(current_chunks[i]) > 0 else ds[var].shape[i] for i in range(len(current_chunks)) ) else: - chunking = ( - current_chunks[0][0] if len(current_chunks[0]) > 0 else ds[var].shape[0], - ) + chunks_list = list(current_chunks) + first_chunks = list(chunks_list[0]) + first_shape = list(ds[var].shape) + chunking = (first_chunks[0] if len(first_chunks) > 0 else first_shape[0],) else: data_shape = ds[var].shape if len(data_shape) >= 2: @@ -1404,7 +1413,7 @@ def _create_encoding( chunk_x = min(spatial_chunk, data_shape[-1]) chunking = (1, chunk_y, chunk_x) if len(data_shape) == 3 else (chunk_y, chunk_x) else: - chunking = (min(spatial_chunk, data_shape[-1]),) + chunking = (min(spatial_chunk, list(data_shape)[-1]),) var_encoding: XarrayEncodingJSON = { "compressors": [compressor], @@ -1429,7 +1438,7 @@ def _create_geozarr_encoding( encoding: dict[Hashable, XarrayEncodingJSON] = {} chunks: tuple[int, ...] for var in ds.data_vars: - if utils.is_grid_mapping_variable(ds, var): + if utils.is_grid_mapping_variable(ds, str(var)): encoding[var] = {"compressors": None} else: data_shape = ds[var].shape @@ -1480,7 +1489,7 @@ def _create_geozarr_encoding( ) else: # For 1D data, use the full dimension - shards = (data_shape[0],) + shards = (next(iter(data_shape)),) log.info( " 🔧 Sharding config", var=var, @@ -1641,7 +1650,7 @@ def _add_grid_mapping_variable( # Ensure all data variables have the grid_mapping attribute for var_name in overview_ds.data_vars: if ( - not utils.is_grid_mapping_variable(overview_ds, var_name) + not utils.is_grid_mapping_variable(overview_ds, str(var_name)) and "grid_mapping" not in overview_ds[var_name].attrs ): overview_ds[var_name].attrs["grid_mapping"] = grid_mapping_var_name @@ -1695,4 +1704,16 @@ def _is_sentinel1(dt: xr.DataTree) -> bool: def get_zarr_group(data: xr.DataTree) -> zarr.Group: - return data._close.__self__.zarr_group + # `_close` is a bound method of the backend store on an opened DataTree; + # `__self__` retrieves that store, which exposes `zarr_group`. These are + # xarray/zarr internals without public type information, so resolve them + # defensively and verify the result is actually a zarr.Group. + close = data._close + store = getattr(close, "__self__", None) + group = getattr(store, "zarr_group", None) + if not isinstance(group, zarr.Group): + raise TypeError( + "Could not resolve a zarr.Group from the DataTree backend " + f"(got {type(group).__name__}); the xarray/zarr internals may have changed." + ) + return group diff --git a/src/eopf_geozarr/conversion/sentinel1_reprojection.py b/src/eopf_geozarr/conversion/sentinel1_reprojection.py index be90abe3..17b8f8e0 100644 --- a/src/eopf_geozarr/conversion/sentinel1_reprojection.py +++ b/src/eopf_geozarr/conversion/sentinel1_reprojection.py @@ -5,8 +5,11 @@ to geographic coordinates (lat/lon) using Ground Control Points (GCPs). """ +from typing import Any + import numpy as np import rasterio +import rasterio.control # Import submodule for GroundControlPoint attribute access import rioxarray # noqa: F401 # Import to enable .rio accessor import structlog import xarray as xr @@ -74,6 +77,9 @@ def reproject_sentinel1_with_gcps( gcps=gcps, ) + # calculate_default_transform sizes the grid, so width and height are populated + assert width is not None + assert height is not None log.info("Calculated target dimensions", width=width, height=height) log.info("Transform", transform=str(transform)) @@ -101,8 +107,13 @@ def reproject_sentinel1_with_gcps( data_vars=reprojected_data_vars, coords=target_coords, attrs=ds.attrs.copy() ) - # Set CRS information + # Set CRS information. `rio.write_crs` is untyped (returns Any), so verify + # the result is a Dataset rather than asserting it with a cast. reprojected_ds = reprojected_ds.rio.write_crs(target_crs) + if not isinstance(reprojected_ds, xr.Dataset): + raise TypeError( + f"expected an xarray.Dataset after write_crs, got {type(reprojected_ds).__name__}" + ) log.info("✅ Successfully reprojected Sentinel-1 data", target_crs=target_crs) return reprojected_ds @@ -178,7 +189,7 @@ def _create_target_coordinates( } -def _determine_nodata_value(data_var: xr.DataArray) -> float | np.floating: +def _determine_nodata_value(data_var: xr.DataArray) -> float: """ Determine appropriate nodata value based on data type and existing attributes. @@ -270,6 +281,14 @@ def _reproject_data_variable( # Set nodata using rioxarray if not NaN if not np.isnan(nodata_value): reprojected_var = reprojected_var.rio.write_nodata(nodata_value) + # Also record the fill value in the encoding: downstream attribute + # sanitization (setup_datatree_metadata_geozarr_spec_compliant) strips + # `_FillValue` from attrs and only re-adds it for float variables, and + # `explicit_fill_value` reads the encoding — without this, integer + # nodata would be lost from the output metadata. + reprojected_var.encoding["_FillValue"] = ( + np.asarray(nodata_value).astype(reprojected_var.dtype).item() + ) return reprojected_var @@ -289,7 +308,7 @@ def _reproject_2d_array( # Initialize destination array with nodata values if np.isnan(nodata_value): dst_array = np.full((dst_height, dst_width), np.nan, dtype=np.float32) - dst_dtype = np.float32 + dst_dtype: np.dtype[Any] | type[np.floating[Any]] = np.float32 else: dst_array = np.full((dst_height, dst_width), nodata_value, dtype=src_array.dtype) dst_dtype = src_array.dtype diff --git a/src/eopf_geozarr/conversion/utils.py b/src/eopf_geozarr/conversion/utils.py index e7125c97..71023cd6 100644 --- a/src/eopf_geozarr/conversion/utils.py +++ b/src/eopf_geozarr/conversion/utils.py @@ -1,15 +1,77 @@ """Utility functions for GeoZarr conversion.""" -from typing import Any +from typing import Any, Protocol, cast, runtime_checkable import numpy as np import rasterio # noqa: F401 # Import to enable .rio accessor import structlog import xarray as xr +import zarr_cm +from zarr_cm import GeoProjAttrs, MultiConventionAttrs, MultiscalesAttrs, SpatialAttrs log = structlog.get_logger() +@runtime_checkable +class CRSLike(Protocol): + """A coordinate reference system that can serialize to EPSG/WKT2. + + Both ``pyproj.CRS`` and ``rasterio.crs.CRS`` satisfy this; the conversion + code accepts either, so we depend on the shared interface rather than a + concrete class. + """ + + def to_epsg(self) -> int | None: ... + + def to_wkt(self) -> str: ... + + +def proj_attrs_for_crs(crs: CRSLike | None) -> GeoProjAttrs: + """Build the ``proj`` convention data keys for a CRS. + + Prefers an EPSG code (``proj:code``) and falls back to WKT2 + (``proj:wkt2``). Returns an empty mapping when *crs* is ``None`` or exposes + no EPSG code. + """ + if crs is None: + return GeoProjAttrs() + epsg = crs.to_epsg() + if epsg: + return GeoProjAttrs({"proj:code": f"EPSG:{epsg}"}) + return GeoProjAttrs({"proj:wkt2": crs.to_wkt()}) + + +def build_convention_attrs( + *, + spatial: SpatialAttrs, + crs: CRSLike | None, + multiscales: MultiscalesAttrs | None = None, +) -> MultiConventionAttrs: + """Build validated multiscales + ``spatial`` + ``proj`` convention attributes. + + Delegates to :func:`zarr_cm.create_many`, which validates each convention's + data and emits the matching convention-metadata objects into a combined + ``zarr_conventions`` array. The CMOs are ordered multiscales (if present), + then spatial, then proj. *spatial* holds the ``spatial:*`` keys; the proj + keys are derived from *crs* via :func:`proj_attrs_for_crs`. + + The proj convention is only included when *crs* yields a usable CRS + representation; otherwise only the other conventions are emitted (a proj + convention with no CRS field is invalid). + """ + conventions: dict[zarr_cm.ConventionName, MultiscalesAttrs | SpatialAttrs | GeoProjAttrs] = {} + if multiscales is not None: + conventions["multiscales"] = multiscales + conventions["spatial"] = spatial + proj = proj_attrs_for_crs(crs) + if proj: + conventions["geo-proj"] = proj + # create_many validates each convention and emits its CMO. It returns a + # generic JSON dict; narrow to the combined convention TypedDict. + result = zarr_cm.create_many(conventions) + return cast("MultiConventionAttrs", result) + + # Sentinel: distinguish "no explicit fill_value" from a legitimate `None`. UNSET: Any = object() @@ -50,7 +112,11 @@ def sanitize_array_attrs( ) -> dict[str, Any]: """Return a copy of *attrs* with source-only and misleading keys removed. - - ``_eopf_attrs`` is always removed. + - ``_eopf_attrs`` and ``_FillValue`` are always removed. ``_FillValue`` + belongs in the variable's *encoding* (where the zarr-level fill value is + carried), not in its attributes; callers that need a CF ``_FillValue`` + attribute (e.g. the NaN workaround for xarray issue #11345) must re-add + it after sanitizing. - For decoded float measurement arrays (*is_decoded_float=True*), also removes raw-encoding leftovers ``dtype``, ``fill_value``, ``valid_min``, ``valid_max`` and rewrites diff --git a/src/eopf_geozarr/data_api/geozarr/common.py b/src/eopf_geozarr/data_api/geozarr/common.py index 8236611e..cbbbd90c 100644 --- a/src/eopf_geozarr/data_api/geozarr/common.py +++ b/src/eopf_geozarr/data_api/geozarr/common.py @@ -80,7 +80,7 @@ class BaseDataArrayAttrs(BaseModel, extra="allow"): ---------- """ - grid_mapping: str | MISSING = MISSING # type: ignore[valid-type] + grid_mapping: str | MISSING = MISSING class GridMappingAttrs(BaseModel, extra="allow"): diff --git a/src/eopf_geozarr/data_api/geozarr/multiscales/geozarr.py b/src/eopf_geozarr/data_api/geozarr/multiscales/geozarr.py index d1a5efd3..e507ae3e 100644 --- a/src/eopf_geozarr/data_api/geozarr/multiscales/geozarr.py +++ b/src/eopf_geozarr/data_api/geozarr/multiscales/geozarr.py @@ -5,6 +5,9 @@ from pydantic import BaseModel, model_validator from pydantic.experimental.missing_sentinel import MISSING from typing_extensions import TypedDict + +# Runtime import (not TYPE_CHECKING): pydantic resolves this annotation when +# building MultiscaleGroupAttrs, so the name must exist at runtime. from zarr_cm import ConventionMetadataObject # noqa: TC002 from . import tms, zcm @@ -16,17 +19,17 @@ class MultiscaleMeta(BaseModel): or ZCM multiscale metadata """ - layout: tuple[zcm.ScaleLevel, ...] | MISSING = MISSING # type: ignore[valid-type] - resampling_method: str | MISSING = MISSING # type: ignore[valid-type] - tile_matrix_set: tms.TileMatrixSet | MISSING = MISSING # type: ignore[valid-type] - tile_matrix_limits: dict[str, tms.TileMatrixLimit] | MISSING = MISSING # type: ignore[valid-type] + layout: tuple[zcm.ScaleLevel, ...] | MISSING = MISSING + resampling_method: str | MISSING = MISSING + tile_matrix_set: tms.TileMatrixSet | MISSING = MISSING + tile_matrix_limits: dict[str, tms.TileMatrixLimit] | MISSING = MISSING @model_validator(mode="after") def valid_zcm(self) -> Self: """ Ensure that the ZCM metadata, if present, is valid """ - if self.layout is not MISSING: # type: ignore[comparison-overlap] + if self.layout is not MISSING: zcm.Multiscales(**self.model_dump()) return self @@ -36,7 +39,7 @@ def valid_tms(self) -> Self: """ Ensure that the TMS metadata, if present, is valid """ - if self.tile_matrix_set is not MISSING: # type: ignore[comparison-overlap] + if self.tile_matrix_set is not MISSING: tms.Multiscales(**self.model_dump()) return self @@ -55,7 +58,7 @@ class MultiscaleGroupAttrs(BaseModel): multiscales: MultiscaleAttrs """ - zarr_conventions: tuple[ConventionMetadataObject, ...] | MISSING = MISSING # type: ignore[valid-type] + zarr_conventions: tuple[ConventionMetadataObject, ...] | MISSING = MISSING multiscales: MultiscaleMeta _zcm_multiscales: zcm.Multiscales | None = None @@ -67,15 +70,18 @@ def valid_zcm_and_tms(self) -> Self: Ensure that the ZCM metadata, if present, is valid, and that TMS metadata, if present, is valid, and that at least one of the two is present. """ - if self.zarr_conventions is not MISSING: # type: ignore[comparison-overlap] + if self.zarr_conventions is not MISSING: self._zcm_multiscales = zcm.Multiscales( layout=self.multiscales.layout, resampling_method=self.multiscales.resampling_method, ) - if self.multiscales.tile_matrix_limits is not MISSING: # type: ignore[comparison-overlap] + if self.multiscales.tile_matrix_limits is not MISSING: self._tms_multiscales = tms.Multiscales( tile_matrix_limits=self.multiscales.tile_matrix_limits, - resampling_method=self.multiscales.resampling_method, # type: ignore[arg-type] + # ``resampling_method`` is typed ``str | MISSING`` here but tms.Multiscales + # constrains it to the ``ResamplingMethod`` literal; pydantic validates the + # value at runtime. + resampling_method=self.multiscales.resampling_method, # pyright: ignore[reportArgumentType] tile_matrix_set=self.multiscales.tile_matrix_set, ) if self._tms_multiscales is None and self._zcm_multiscales is None: diff --git a/src/eopf_geozarr/data_api/geozarr/multiscales/zcm.py b/src/eopf_geozarr/data_api/geozarr/multiscales/zcm.py index 650ea07c..1c8f07cd 100644 --- a/src/eopf_geozarr/data_api/geozarr/multiscales/zcm.py +++ b/src/eopf_geozarr/data_api/geozarr/multiscales/zcm.py @@ -9,8 +9,12 @@ CONVENTION_ID = multiscales_cm.UUID CONVENTION_SCHEMA_URL = multiscales_cm.SCHEMA_URL CONVENTION_SPEC_URL = multiscales_cm.SPEC_URL -CONVENTION_NAME = multiscales_cm.CMO["name"] -CONVENTION_DESCRIPTION = multiscales_cm.CMO["description"] +_CONVENTION_NAME = multiscales_cm.CMO.get("name") +assert _CONVENTION_NAME is not None +CONVENTION_NAME = _CONVENTION_NAME +_CONVENTION_DESCRIPTION = multiscales_cm.CMO.get("description") +assert _CONVENTION_DESCRIPTION is not None +CONVENTION_DESCRIPTION = _CONVENTION_DESCRIPTION # Re-export zarr-cm TypedDicts TransformJSON = multiscales_cm.Transform @@ -26,22 +30,22 @@ class ZarrConventionAttrs(BaseModel): class Transform(BaseModel): - scale: tuple[float, ...] | MISSING = MISSING # type: ignore[valid-type] - translation: tuple[float, ...] | MISSING = MISSING # type: ignore[valid-type] + scale: tuple[float, ...] | MISSING = MISSING + translation: tuple[float, ...] | MISSING = MISSING class ScaleLevel(BaseModel): asset: str - derived_from: str | MISSING = MISSING # type: ignore[valid-type] - transform: Transform | MISSING = MISSING # type: ignore[valid-type] - resampling_method: str | MISSING = MISSING # type: ignore[valid-type] + derived_from: str | MISSING = MISSING + transform: Transform | MISSING = MISSING + resampling_method: str | MISSING = MISSING model_config = {"extra": "allow"} class Multiscales(BaseModel): layout: tuple[ScaleLevel, ...] - resampling_method: str | MISSING = MISSING # type: ignore[valid-type] + resampling_method: str | MISSING = MISSING model_config = {"extra": "allow"} @@ -59,8 +63,9 @@ def ensure_multiscales_convention( Iterate over the elements of zarr_conventions and check that at least one of them is multiscales """ - expected_uuid = multiscales_cm.CMO["uuid"] - if not any(c["uuid"] == expected_uuid for c in value): + expected_uuid = multiscales_cm.CMO.get("uuid") + assert expected_uuid is not None + if not any(c.get("uuid") == expected_uuid for c in value): raise ValueError( f"Multiscales convention (uuid={expected_uuid}) not found in zarr_conventions" ) diff --git a/src/eopf_geozarr/data_api/geozarr/store.py b/src/eopf_geozarr/data_api/geozarr/store.py index 61a6a443..0835ed25 100644 --- a/src/eopf_geozarr/data_api/geozarr/store.py +++ b/src/eopf_geozarr/data_api/geozarr/store.py @@ -91,13 +91,19 @@ class GeoZarrScaleLevel(ScaleLevel): class GeoZarrMultiscaleMeta(MultiscaleMeta): """Multiscale metadata where every layout entry is a `GeoZarrScaleLevel`.""" - layout: tuple[GeoZarrScaleLevel, ...] + # Intentionally tightens the base ``layout`` field: ``GeoZarrScaleLevel`` is a + # subclass of ``ScaleLevel`` and the optional ``MISSING`` default is dropped to make + # the field mandatory in this store-level profile. pyright flags the narrowed, + # now-required override on a mutable (invariant) field. + layout: tuple[GeoZarrScaleLevel, ...] # pyright: ignore[reportGeneralTypeIssues, reportIncompatibleVariableOverride] class GeoZarrMultiscaleGroupAttrs(MultiscaleGroupAttrs): """Multiscale group attributes with a mandatory `spatial:bbox`.""" - multiscales: GeoZarrMultiscaleMeta + # Intentionally tightens the base ``multiscales`` field to the ``GeoZarrMultiscaleMeta`` + # subclass; pyright flags the narrowed override on a mutable (invariant) field. + multiscales: GeoZarrMultiscaleMeta # pyright: ignore[reportIncompatibleVariableOverride] spatial_bbox: list[float] = Field(alias="spatial:bbox", min_length=4, max_length=4) model_config = ConfigDict( diff --git a/src/eopf_geozarr/data_api/geozarr/v2.py b/src/eopf_geozarr/data_api/geozarr/v2.py index 6e889db7..772f13d0 100644 --- a/src/eopf_geozarr/data_api/geozarr/v2.py +++ b/src/eopf_geozarr/data_api/geozarr/v2.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any, Literal, Self +from typing import TYPE_CHECKING, Any, Literal, Self, cast from pydantic import ConfigDict, Field, model_validator from pydantic_zarr.v2 import ArraySpec, GroupSpec, auto_attributes @@ -10,7 +10,9 @@ from eopf_geozarr.data_api.geozarr.common import ( BaseDataArrayAttrs, DatasetAttrs, + DatasetLike, GridMappingAttrs, + GroupLike, check_grid_mapping, check_valid_coordinates, ) @@ -52,8 +54,11 @@ class DataArray(ArraySpec[DataArrayAttrs]): https://github.com/zarr-developers/geozarr-spec/blob/main/geozarr-spec.md#geozarr-dataarray """ + # The override intentionally widens the accepted argument types (e.g. plain mappings for + # ``attributes``) and adds a ``dimension_names`` parameter, so the signature is not a strict + # subtype of the parent's. This is by design and does not change runtime behavior. @classmethod - def from_array( + def from_array( # type: ignore[override] cls, array: Any, chunks: tuple[int, ...] | Literal["auto"] = "auto", @@ -71,13 +76,15 @@ def from_array( auto_attrs = dict(auto_attributes(array)) if attributes == "auto" else dict(attributes) if dimension_names != "auto": auto_attrs = auto_attrs | {XARRAY_DIMS_KEY: tuple(dimension_names)} - return super().from_array( # type: ignore[no-any-return] + # ``auto_attrs``/``fill_value``/``filters`` are validated/coerced by pydantic at + # construction time; cast to the parent's declared types to satisfy the static checker. + return super().from_array( array=array, chunks=chunks, - attributes=auto_attrs, - fill_value=fill_value, + attributes=cast("Literal['auto'] | DataArrayAttrs", auto_attrs), + fill_value=cast("Literal['auto'] | float | None", fill_value), order=order, - filters=filters, + filters=cast("Literal['auto'] | list[dict[str, Any]] | None", filters), dimension_separator=dimension_separator, compressor=compressor, ) @@ -94,7 +101,7 @@ def check_array_dimensions(self) -> Self: @property def array_dimensions(self) -> tuple[str, ...]: - return self.attributes.array_dimensions # type: ignore[no-any-return] + return self.attributes.array_dimensions class GridMappingVariable(ArraySpec[GridMappingAttrs]): @@ -127,11 +134,17 @@ def check_valid_coordinates(self) -> Self: GroupSpec[Any, Any] The validated GeoZarr DataSet. """ - return check_valid_coordinates(self) + # ``self`` structurally satisfies the ``GroupLike`` protocol, but mypy cannot bind the + # helper's TypeVar to ``Self``; cast through the protocol and back to ``Self`` (the helper + # returns the same object). + check_valid_coordinates(cast("GroupLike", self)) + return self @model_validator(mode="after") def check_grid_mapping(self) -> Self: - return check_grid_mapping(self) + # See note above: ``self`` satisfies ``DatasetLike`` but the TypeVar can't bind to ``Self``. + check_grid_mapping(cast("DatasetLike", self)) + return self class MultiscaleGroup(GroupSpec[MultiscaleGroupAttrs, DataArray | GroupSpec[Any, Any]]): diff --git a/src/eopf_geozarr/data_api/geozarr/v3.py b/src/eopf_geozarr/data_api/geozarr/v3.py index 9359b22d..ee2a487c 100644 --- a/src/eopf_geozarr/data_api/geozarr/v3.py +++ b/src/eopf_geozarr/data_api/geozarr/v3.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import Any, Self +from typing import Any, Self, cast from pydantic import model_validator from pydantic_zarr.v3 import ArraySpec, GroupSpec @@ -10,6 +10,8 @@ from eopf_geozarr.data_api.geozarr.common import ( BaseDataArrayAttrs, DatasetAttrs, + DatasetLike, + GroupLike, check_grid_mapping, check_valid_coordinates, ) @@ -29,8 +31,9 @@ class DataArray(ArraySpec[BaseDataArrayAttrs]): https://github.com/zarr-developers/geozarr-spec/blob/main/geozarr-spec.md#geozarr-dataarray """ - # The dimension names must be a tuple of strings - dimension_names: tuple[str, ...] + # GeoZarr requires dimension names, so tighten the parent's optional + # `tuple[str | None, ...] | None` field to a required tuple of strings. + dimension_names: tuple[str, ...] # pyright: ignore[reportGeneralTypeIssues, reportIncompatibleVariableOverride] @property def array_dimensions(self) -> tuple[str, ...]: @@ -55,11 +58,17 @@ def check_valid_coordinates(self) -> Self: GroupSpec[Any, Any] The validated GeoZarr DataSet. """ - return check_valid_coordinates(self) + # ``self`` structurally satisfies the ``GroupLike`` protocol, but mypy cannot bind the + # helper's TypeVar to ``Self``; cast through the protocol and back to ``Self`` (the helper + # returns the same object). + check_valid_coordinates(cast("GroupLike", self)) + return self @model_validator(mode="after") def validate_grid_mapping(self) -> Self: - return check_grid_mapping(self) + # See note above: ``self`` satisfies ``DatasetLike`` but the TypeVar can't bind to ``Self``. + check_grid_mapping(cast("DatasetLike", self)) + return self class MultiscaleGroup(GroupSpec[MultiscaleGroupAttrs, DataArray | GroupSpec[Any, Any]]): diff --git a/src/eopf_geozarr/data_api/s1.py b/src/eopf_geozarr/data_api/s1.py index d8bb91f1..00f0bed5 100644 --- a/src/eopf_geozarr/data_api/s1.py +++ b/src/eopf_geozarr/data_api/s1.py @@ -47,7 +47,7 @@ class Sentinel1DataArray(ArraySpec[Sentinel1DataArrayAttrs]): # Conditions groups -class Sentinel1AntennaPatternMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1AntennaPatternMembers(TypedDict, closed=True, total=False): """Members for antenna_pattern group. All fields are optional to support different product variants. @@ -64,53 +64,75 @@ class Sentinel1AntennaPatternMembers(TypedDict, closed=True, total=False): # ty terrain_height: ArraySpec[Any] -class Sentinel1AntennaPatternGroup( - GroupSpec[DatasetAttrs, Sentinel1AntennaPatternMembers] # type: ignore[type-var] -): +class Sentinel1AntennaPatternGroup(GroupSpec[DatasetAttrs, Sentinel1AntennaPatternMembers]): """Antenna pattern group containing antenna characteristics.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def count(self) -> ArraySpec[Any]: """Get count array.""" - return self.members["count"] + value = self.members.get("count") + if value is None: + raise KeyError("count") + return value @property def elevation_angle(self) -> ArraySpec[Any]: """Get elevation_angle array.""" - return self.members["elevation_angle"] + value = self.members.get("elevation_angle") + if value is None: + raise KeyError("elevation_angle") + return value @property def incidence_angle(self) -> ArraySpec[Any]: """Get incidence_angle array.""" - return self.members["incidence_angle"] + value = self.members.get("incidence_angle") + if value is None: + raise KeyError("incidence_angle") + return value @property def roll(self) -> ArraySpec[Any]: """Get roll array.""" - return self.members["roll"] + value = self.members.get("roll") + if value is None: + raise KeyError("roll") + return value @property def slant_range_time_ap(self) -> ArraySpec[Any]: """Get slant_range_time_ap array.""" - return self.members["slant_range_time_ap"] + value = self.members.get("slant_range_time_ap") + if value is None: + raise KeyError("slant_range_time_ap") + return value @property def swath(self) -> ArraySpec[Any]: """Get swath array.""" - return self.members["swath"] + value = self.members.get("swath") + if value is None: + raise KeyError("swath") + return value @property def terrain_height(self) -> ArraySpec[Any]: """Get terrain_height array.""" - return self.members["terrain_height"] + value = self.members.get("terrain_height") + if value is None: + raise KeyError("terrain_height") + return value -class Sentinel1AttitudeMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1AttitudeMembers(TypedDict, closed=True, total=False): """Members for attitude group.""" azimuth_time: ArraySpec[Any] @@ -126,66 +148,99 @@ class Sentinel1AttitudeMembers(TypedDict, closed=True, total=False): # type: ig yaw: ArraySpec[Any] -class Sentinel1AttitudeGroup(GroupSpec[DatasetAttrs, Sentinel1AttitudeMembers]): # type: ignore[type-var] +class Sentinel1AttitudeGroup(GroupSpec[DatasetAttrs, Sentinel1AttitudeMembers]): """Attitude group containing spacecraft attitude data.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def pitch(self) -> ArraySpec[Any]: """Get pitch array.""" - return self.members["pitch"] + value = self.members.get("pitch") + if value is None: + raise KeyError("pitch") + return value @property def q0(self) -> ArraySpec[Any]: """Get q0 array.""" - return self.members["q0"] + value = self.members.get("q0") + if value is None: + raise KeyError("q0") + return value @property def q1(self) -> ArraySpec[Any]: """Get q1 array.""" - return self.members["q1"] + value = self.members.get("q1") + if value is None: + raise KeyError("q1") + return value @property def q2(self) -> ArraySpec[Any]: """Get q2 array.""" - return self.members["q2"] + value = self.members.get("q2") + if value is None: + raise KeyError("q2") + return value @property def q3(self) -> ArraySpec[Any]: """Get q3 array.""" - return self.members["q3"] + value = self.members.get("q3") + if value is None: + raise KeyError("q3") + return value @property def roll(self) -> ArraySpec[Any]: """Get roll array.""" - return self.members["roll"] + value = self.members.get("roll") + if value is None: + raise KeyError("roll") + return value @property def wx(self) -> ArraySpec[Any]: """Get wx array.""" - return self.members["wx"] + value = self.members.get("wx") + if value is None: + raise KeyError("wx") + return value @property def wy(self) -> ArraySpec[Any]: """Get wy array.""" - return self.members["wy"] + value = self.members.get("wy") + if value is None: + raise KeyError("wy") + return value @property def wz(self) -> ArraySpec[Any]: """Get wz array.""" - return self.members["wz"] + value = self.members.get("wz") + if value is None: + raise KeyError("wz") + return value @property def yaw(self) -> ArraySpec[Any]: """Get yaw array.""" - return self.members["yaw"] + value = self.members.get("yaw") + if value is None: + raise KeyError("yaw") + return value -class Sentinel1AzimuthFmRateMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1AzimuthFmRateMembers(TypedDict, closed=True, total=False): """Members for azimuth_fm_rate group.""" azimuth_fm_rate_polynomial: ArraySpec[Any] @@ -193,28 +248,35 @@ class Sentinel1AzimuthFmRateMembers(TypedDict, closed=True, total=False): # typ t0: ArraySpec[Any] -class Sentinel1AzimuthFmRateGroup( - GroupSpec[DatasetAttrs, Sentinel1AzimuthFmRateMembers] # type: ignore[type-var] -): +class Sentinel1AzimuthFmRateGroup(GroupSpec[DatasetAttrs, Sentinel1AzimuthFmRateMembers]): """Azimuth FM rate group.""" @property def azimuth_fm_rate_polynomial(self) -> ArraySpec[Any]: """Get azimuth_fm_rate_polynomial array.""" - return self.members["azimuth_fm_rate_polynomial"] + value = self.members.get("azimuth_fm_rate_polynomial") + if value is None: + raise KeyError("azimuth_fm_rate_polynomial") + return value @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def t0(self) -> ArraySpec[Any]: """Get t0 array.""" - return self.members["t0"] + value = self.members.get("t0") + if value is None: + raise KeyError("t0") + return value -class Sentinel1CoordinateConversionMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1CoordinateConversionMembers(TypedDict, closed=True, total=False): """Members for coordinate_conversion group.""" azimuth_time: ArraySpec[Any] @@ -226,42 +288,60 @@ class Sentinel1CoordinateConversionMembers(TypedDict, closed=True, total=False): class Sentinel1CoordinateConversionGroup( - GroupSpec[DatasetAttrs, Sentinel1CoordinateConversionMembers] # type: ignore[type-var] + GroupSpec[DatasetAttrs, Sentinel1CoordinateConversionMembers] ): """Coordinate conversion group.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def gr0(self) -> ArraySpec[Any]: """Get gr0 array.""" - return self.members["gr0"] + value = self.members.get("gr0") + if value is None: + raise KeyError("gr0") + return value @property def grsr_coefficients(self) -> ArraySpec[Any]: """Get grsr_coefficients array.""" - return self.members["grsr_coefficients"] + value = self.members.get("grsr_coefficients") + if value is None: + raise KeyError("grsr_coefficients") + return value @property def slant_range_time(self) -> ArraySpec[Any]: """Get slant_range_time array.""" - return self.members["slant_range_time"] + value = self.members.get("slant_range_time") + if value is None: + raise KeyError("slant_range_time") + return value @property def sr0(self) -> ArraySpec[Any]: """Get sr0 array.""" - return self.members["sr0"] + value = self.members.get("sr0") + if value is None: + raise KeyError("sr0") + return value @property def srgr_coefficients(self) -> ArraySpec[Any]: """Get srgr_coefficients array.""" - return self.members["srgr_coefficients"] + value = self.members.get("srgr_coefficients") + if value is None: + raise KeyError("srgr_coefficients") + return value -class Sentinel1DopplerCentroidMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1DopplerCentroidMembers(TypedDict, closed=True, total=False): """Members for doppler_centroid group.""" azimuth_time: ArraySpec[Any] @@ -275,58 +355,83 @@ class Sentinel1DopplerCentroidMembers(TypedDict, closed=True, total=False): # t t0: ArraySpec[Any] -class Sentinel1DopplerCentroidGroup( - GroupSpec[DatasetAttrs, Sentinel1DopplerCentroidMembers] # type: ignore[type-var] -): +class Sentinel1DopplerCentroidGroup(GroupSpec[DatasetAttrs, Sentinel1DopplerCentroidMembers]): """Doppler centroid group.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def data_dc_polynomial(self) -> ArraySpec[Any]: """Get data_dc_polynomial array.""" - return self.members["data_dc_polynomial"] + value = self.members.get("data_dc_polynomial") + if value is None: + raise KeyError("data_dc_polynomial") + return value @property def data_dc_rms_error(self) -> ArraySpec[Any]: """Get data_dc_rms_error array.""" - return self.members["data_dc_rms_error"] + value = self.members.get("data_dc_rms_error") + if value is None: + raise KeyError("data_dc_rms_error") + return value @property def data_dc_rms_error_above_threshold(self) -> ArraySpec[Any]: """Get data_dc_rms_error_above_threshold array.""" - return self.members["data_dc_rms_error_above_threshold"] + value = self.members.get("data_dc_rms_error_above_threshold") + if value is None: + raise KeyError("data_dc_rms_error_above_threshold") + return value @property def degree(self) -> ArraySpec[Any]: """Get degree array.""" - return self.members["degree"] + value = self.members.get("degree") + if value is None: + raise KeyError("degree") + return value @property def fine_dce_azimuth_start_time(self) -> ArraySpec[Any]: """Get fine_dce_azimuth_start_time array.""" - return self.members["fine_dce_azimuth_start_time"] + value = self.members.get("fine_dce_azimuth_start_time") + if value is None: + raise KeyError("fine_dce_azimuth_start_time") + return value @property def fine_dce_azimuth_stop_time(self) -> ArraySpec[Any]: """Get fine_dce_azimuth_stop_time array.""" - return self.members["fine_dce_azimuth_stop_time"] + value = self.members.get("fine_dce_azimuth_stop_time") + if value is None: + raise KeyError("fine_dce_azimuth_stop_time") + return value @property def geometry_dc_polynomial(self) -> ArraySpec[Any]: """Get geometry_dc_polynomial array.""" - return self.members["geometry_dc_polynomial"] + value = self.members.get("geometry_dc_polynomial") + if value is None: + raise KeyError("geometry_dc_polynomial") + return value @property def t0(self) -> ArraySpec[Any]: """Get t0 array.""" - return self.members["t0"] + value = self.members.get("t0") + if value is None: + raise KeyError("t0") + return value -class Sentinel1GcpMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1GcpMembers(TypedDict, closed=True, total=False): """Members for GCP (Ground Control Points) group. All fields are optional to support different product variants (S1A, S1C). @@ -346,66 +451,99 @@ class Sentinel1GcpMembers(TypedDict, closed=True, total=False): # type: ignore[ slant_range_time_gcp: ArraySpec[Any] -class Sentinel1GcpGroup(GroupSpec[DatasetAttrs, Sentinel1GcpMembers]): # type: ignore[type-var] +class Sentinel1GcpGroup(GroupSpec[DatasetAttrs, Sentinel1GcpMembers]): """Ground Control Points (GCP) group.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def azimuth_time_gcp(self) -> ArraySpec[Any]: """Get azimuth_time_gcp array.""" - return self.members["azimuth_time_gcp"] + value = self.members.get("azimuth_time_gcp") + if value is None: + raise KeyError("azimuth_time_gcp") + return value @property def elevation_angle(self) -> ArraySpec[Any]: """Get elevation_angle array.""" - return self.members["elevation_angle"] + value = self.members.get("elevation_angle") + if value is None: + raise KeyError("elevation_angle") + return value @property def ground_range(self) -> ArraySpec[Any]: """Get ground_range array.""" - return self.members["ground_range"] + value = self.members.get("ground_range") + if value is None: + raise KeyError("ground_range") + return value @property def height(self) -> ArraySpec[Any]: """Get height array.""" - return self.members["height"] + value = self.members.get("height") + if value is None: + raise KeyError("height") + return value @property def incidence_angle(self) -> ArraySpec[Any]: """Get incidence_angle array.""" - return self.members["incidence_angle"] + value = self.members.get("incidence_angle") + if value is None: + raise KeyError("incidence_angle") + return value @property def latitude(self) -> ArraySpec[Any]: """Get latitude array.""" - return self.members["latitude"] + value = self.members.get("latitude") + if value is None: + raise KeyError("latitude") + return value @property def line(self) -> ArraySpec[Any]: """Get line array.""" - return self.members["line"] + value = self.members.get("line") + if value is None: + raise KeyError("line") + return value @property def longitude(self) -> ArraySpec[Any]: """Get longitude array.""" - return self.members["longitude"] + value = self.members.get("longitude") + if value is None: + raise KeyError("longitude") + return value @property def pixel(self) -> ArraySpec[Any]: """Get pixel array.""" - return self.members["pixel"] + value = self.members.get("pixel") + if value is None: + raise KeyError("pixel") + return value @property def slant_range_time_gcp(self) -> ArraySpec[Any]: """Get slant_range_time_gcp array.""" - return self.members["slant_range_time_gcp"] + value = self.members.get("slant_range_time_gcp") + if value is None: + raise KeyError("slant_range_time_gcp") + return value -class Sentinel1OrbitMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1OrbitMembers(TypedDict, closed=True, total=False): """Members for orbit group.""" axis: ArraySpec[Any] @@ -414,31 +552,43 @@ class Sentinel1OrbitMembers(TypedDict, closed=True, total=False): # type: ignor velocity: ArraySpec[Any] -class Sentinel1OrbitGroup(GroupSpec[DatasetAttrs, Sentinel1OrbitMembers]): # type: ignore[type-var] +class Sentinel1OrbitGroup(GroupSpec[DatasetAttrs, Sentinel1OrbitMembers]): """Orbit group containing spacecraft position and velocity.""" @property def axis(self) -> ArraySpec[Any]: """Get axis array.""" - return self.members["axis"] + value = self.members.get("axis") + if value is None: + raise KeyError("axis") + return value @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def position(self) -> ArraySpec[Any]: """Get position array.""" - return self.members["position"] + value = self.members.get("position") + if value is None: + raise KeyError("position") + return value @property def velocity(self) -> ArraySpec[Any]: """Get velocity array.""" - return self.members["velocity"] + value = self.members.get("velocity") + if value is None: + raise KeyError("velocity") + return value -class Sentinel1ReferenceReplicaMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1ReferenceReplicaMembers(TypedDict, closed=True, total=False): """Members for reference_replica group. Closed TypedDict - only reference replica coefficient array keys are allowed. @@ -450,28 +600,35 @@ class Sentinel1ReferenceReplicaMembers(TypedDict, closed=True, total=False): # reference_replica_phase_coefficients: ArraySpec[Any] -class Sentinel1ReferenceReplicaGroup( - GroupSpec[DatasetAttrs, Sentinel1ReferenceReplicaMembers] # type: ignore[type-var] -): +class Sentinel1ReferenceReplicaGroup(GroupSpec[DatasetAttrs, Sentinel1ReferenceReplicaMembers]): """Reference replica group.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def reference_replica_amplitude_coefficients(self) -> ArraySpec[Any]: """Get reference_replica_amplitude_coefficients array.""" - return self.members["reference_replica_amplitude_coefficients"] + value = self.members.get("reference_replica_amplitude_coefficients") + if value is None: + raise KeyError("reference_replica_amplitude_coefficients") + return value @property def reference_replica_phase_coefficients(self) -> ArraySpec[Any]: """Get reference_replica_phase_coefficients array.""" - return self.members["reference_replica_phase_coefficients"] + value = self.members.get("reference_replica_phase_coefficients") + if value is None: + raise KeyError("reference_replica_phase_coefficients") + return value -class Sentinel1ReplicaMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1ReplicaMembers(TypedDict, closed=True, total=False): """Members for replica group. Closed TypedDict - only pulse replica data array keys are allowed. @@ -491,89 +648,126 @@ class Sentinel1ReplicaMembers(TypedDict, closed=True, total=False): # type: ign relative_pg_product_valid_flag: ArraySpec[Any] -class Sentinel1ReplicaGroup(GroupSpec[DatasetAttrs, Sentinel1ReplicaMembers]): # type: ignore[type-var] +class Sentinel1ReplicaGroup(GroupSpec[DatasetAttrs, Sentinel1ReplicaMembers]): """Replica group containing pulse replica data.""" @property def absolute_pg_product_valid_flag(self) -> ArraySpec[Any]: """Get absolute_pg_product_valid_flag array.""" - return self.members["absolute_pg_product_valid_flag"] + value = self.members.get("absolute_pg_product_valid_flag") + if value is None: + raise KeyError("absolute_pg_product_valid_flag") + return value @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def cross_correlation_peak_location(self) -> ArraySpec[Any]: """Get cross_correlation_peak_location array.""" - return self.members["cross_correlation_peak_location"] + value = self.members.get("cross_correlation_peak_location") + if value is None: + raise KeyError("cross_correlation_peak_location") + return value @property def cross_correlation_pslr(self) -> ArraySpec[Any]: """Get cross_correlation_pslr array.""" - return self.members["cross_correlation_pslr"] + value = self.members.get("cross_correlation_pslr") + if value is None: + raise KeyError("cross_correlation_pslr") + return value @property def internal_time_delay(self) -> ArraySpec[Any]: """Get internal_time_delay array.""" - return self.members["internal_time_delay"] + value = self.members.get("internal_time_delay") + if value is None: + raise KeyError("internal_time_delay") + return value @property def model_pg_product_amplitude(self) -> ArraySpec[Any]: """Get model_pg_product_amplitude array.""" - return self.members["model_pg_product_amplitude"] + value = self.members.get("model_pg_product_amplitude") + if value is None: + raise KeyError("model_pg_product_amplitude") + return value @property def model_pg_product_phase(self) -> ArraySpec[Any]: """Get model_pg_product_phase array.""" - return self.members["model_pg_product_phase"] + value = self.members.get("model_pg_product_phase") + if value is None: + raise KeyError("model_pg_product_phase") + return value @property def pg_product_amplitude(self) -> ArraySpec[Any]: """Get pg_product_amplitude array.""" - return self.members["pg_product_amplitude"] + value = self.members.get("pg_product_amplitude") + if value is None: + raise KeyError("pg_product_amplitude") + return value @property def pg_product_phase(self) -> ArraySpec[Any]: """Get pg_product_phase array.""" - return self.members["pg_product_phase"] + value = self.members.get("pg_product_phase") + if value is None: + raise KeyError("pg_product_phase") + return value @property def reconstructed_replica_valid_flag(self) -> ArraySpec[Any]: """Get reconstructed_replica_valid_flag array.""" - return self.members["reconstructed_replica_valid_flag"] + value = self.members.get("reconstructed_replica_valid_flag") + if value is None: + raise KeyError("reconstructed_replica_valid_flag") + return value @property def relative_pg_product_valid_flag(self) -> ArraySpec[Any]: """Get relative_pg_product_valid_flag array.""" - return self.members["relative_pg_product_valid_flag"] + value = self.members.get("relative_pg_product_valid_flag") + if value is None: + raise KeyError("relative_pg_product_valid_flag") + return value -class Sentinel1TerrainHeightMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1TerrainHeightMembers(TypedDict, closed=True, total=False): """Members for terrain_height group.""" azimuth_time: ArraySpec[Any] terrain_height: ArraySpec[Any] -class Sentinel1TerrainHeightGroup( - GroupSpec[DatasetAttrs, Sentinel1TerrainHeightMembers] # type: ignore[type-var] -): +class Sentinel1TerrainHeightGroup(GroupSpec[DatasetAttrs, Sentinel1TerrainHeightMembers]): """Terrain height group.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def terrain_height(self) -> ArraySpec[Any]: """Get terrain_height array.""" - return self.members["terrain_height"] + value = self.members.get("terrain_height") + if value is None: + raise KeyError("terrain_height") + return value -class Sentinel1ConditionsMembers(TypedDict, closed=True): # type: ignore[call-arg] +class Sentinel1ConditionsMembers(TypedDict, closed=True): """Members for conditions group. Closed TypedDict - only antenna_pattern, attitude, azimuth_fm_rate, etc. keys are allowed. @@ -591,7 +785,7 @@ class Sentinel1ConditionsMembers(TypedDict, closed=True): # type: ignore[call-a terrain_height: Sentinel1TerrainHeightGroup -class Sentinel1ConditionsGroup(GroupSpec[DatasetAttrs, Sentinel1ConditionsMembers]): # type: ignore[type-var] +class Sentinel1ConditionsGroup(GroupSpec[DatasetAttrs, Sentinel1ConditionsMembers]): """Conditions group containing acquisition and processing metadata.""" def get_antenna_pattern(self) -> Sentinel1AntennaPatternGroup | None: @@ -636,7 +830,7 @@ def get_terrain_height(self) -> Sentinel1TerrainHeightGroup | None: # Quality groups -class Sentinel1CalibrationMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1CalibrationMembers(TypedDict, closed=True, total=False): """Members for calibration group.""" azimuth_time: ArraySpec[Any] @@ -649,51 +843,75 @@ class Sentinel1CalibrationMembers(TypedDict, closed=True, total=False): # type: sigma_nought: ArraySpec[Any] -class Sentinel1CalibrationGroup(GroupSpec[DatasetAttrs, Sentinel1CalibrationMembers]): # type: ignore[type-var] +class Sentinel1CalibrationGroup(GroupSpec[DatasetAttrs, Sentinel1CalibrationMembers]): """Calibration group containing radiometric calibration data.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def beta_nought(self) -> ArraySpec[Any]: """Get beta_nought array.""" - return self.members["beta_nought"] + value = self.members.get("beta_nought") + if value is None: + raise KeyError("beta_nought") + return value @property def dn(self) -> ArraySpec[Any]: """Get dn array.""" - return self.members["dn"] + value = self.members.get("dn") + if value is None: + raise KeyError("dn") + return value @property def gamma(self) -> ArraySpec[Any]: """Get gamma array.""" - return self.members["gamma"] + value = self.members.get("gamma") + if value is None: + raise KeyError("gamma") + return value @property def ground_range(self) -> ArraySpec[Any]: """Get ground_range array.""" - return self.members["ground_range"] + value = self.members.get("ground_range") + if value is None: + raise KeyError("ground_range") + return value @property def line(self) -> ArraySpec[Any]: """Get line array.""" - return self.members["line"] + value = self.members.get("line") + if value is None: + raise KeyError("line") + return value @property def pixel(self) -> ArraySpec[Any]: """Get pixel array.""" - return self.members["pixel"] + value = self.members.get("pixel") + if value is None: + raise KeyError("pixel") + return value @property def sigma_nought(self) -> ArraySpec[Any]: """Get sigma_nought array.""" - return self.members["sigma_nought"] + value = self.members.get("sigma_nought") + if value is None: + raise KeyError("sigma_nought") + return value -class Sentinel1NoiseMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1NoiseMembers(TypedDict, closed=True, total=False): """Members for noise group.""" azimuth_time: ArraySpec[Any] @@ -701,26 +919,35 @@ class Sentinel1NoiseMembers(TypedDict, closed=True, total=False): # type: ignor number_of_noise_lines: ArraySpec[Any] -class Sentinel1NoiseGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseMembers]): # type: ignore[type-var] +class Sentinel1NoiseGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseMembers]): """Noise group containing noise estimation data.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def noise_power_correction_factor(self) -> ArraySpec[Any]: """Get noise_power_correction_factor array.""" - return self.members["noise_power_correction_factor"] + value = self.members.get("noise_power_correction_factor") + if value is None: + raise KeyError("noise_power_correction_factor") + return value @property def number_of_noise_lines(self) -> ArraySpec[Any]: """Get number_of_noise_lines array.""" - return self.members["number_of_noise_lines"] + value = self.members.get("number_of_noise_lines") + if value is None: + raise KeyError("number_of_noise_lines") + return value -class Sentinel1NoiseAzimuthMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1NoiseAzimuthMembers(TypedDict, closed=True, total=False): """Members for noise_azimuth group.""" first_azimuth_time: ArraySpec[Any] @@ -732,46 +959,67 @@ class Sentinel1NoiseAzimuthMembers(TypedDict, closed=True, total=False): # type swath: ArraySpec[Any] -class Sentinel1NoiseAzimuthGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseAzimuthMembers]): # type: ignore[type-var] +class Sentinel1NoiseAzimuthGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseAzimuthMembers]): """Noise azimuth group containing azimuth noise vectors.""" @property def first_azimuth_time(self) -> ArraySpec[Any]: """Get first_azimuth_time array.""" - return self.members["first_azimuth_time"] + value = self.members.get("first_azimuth_time") + if value is None: + raise KeyError("first_azimuth_time") + return value @property def first_range_sample(self) -> ArraySpec[Any]: """Get first_range_sample array.""" - return self.members["first_range_sample"] + value = self.members.get("first_range_sample") + if value is None: + raise KeyError("first_range_sample") + return value @property def last_azimuth_time(self) -> ArraySpec[Any]: """Get last_azimuth_time array.""" - return self.members["last_azimuth_time"] + value = self.members.get("last_azimuth_time") + if value is None: + raise KeyError("last_azimuth_time") + return value @property def last_range_sample(self) -> ArraySpec[Any]: """Get last_range_sample array.""" - return self.members["last_range_sample"] + value = self.members.get("last_range_sample") + if value is None: + raise KeyError("last_range_sample") + return value @property def line(self) -> ArraySpec[Any]: """Get line array.""" - return self.members["line"] + value = self.members.get("line") + if value is None: + raise KeyError("line") + return value @property def noise_azimuth_lut(self) -> ArraySpec[Any]: """Get noise_azimuth_lut array.""" - return self.members["noise_azimuth_lut"] + value = self.members.get("noise_azimuth_lut") + if value is None: + raise KeyError("noise_azimuth_lut") + return value @property def swath(self) -> ArraySpec[Any]: """Get swath array.""" - return self.members["swath"] + value = self.members.get("swath") + if value is None: + raise KeyError("swath") + return value -class Sentinel1NoiseRangeMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1NoiseRangeMembers(TypedDict, closed=True, total=False): """Members for noise_range group.""" azimuth_time: ArraySpec[Any] @@ -781,36 +1029,51 @@ class Sentinel1NoiseRangeMembers(TypedDict, closed=True, total=False): # type: pixel: ArraySpec[Any] -class Sentinel1NoiseRangeGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseRangeMembers]): # type: ignore[type-var] +class Sentinel1NoiseRangeGroup(GroupSpec[DatasetAttrs, Sentinel1NoiseRangeMembers]): """Noise range group containing range noise vectors.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def ground_range(self) -> ArraySpec[Any]: """Get ground_range array.""" - return self.members["ground_range"] + value = self.members.get("ground_range") + if value is None: + raise KeyError("ground_range") + return value @property def line(self) -> ArraySpec[Any]: """Get line array.""" - return self.members["line"] + value = self.members.get("line") + if value is None: + raise KeyError("line") + return value @property def noise_range_lut(self) -> ArraySpec[Any]: """Get noise_range_lut array.""" - return self.members["noise_range_lut"] + value = self.members.get("noise_range_lut") + if value is None: + raise KeyError("noise_range_lut") + return value @property def pixel(self) -> ArraySpec[Any]: """Get pixel array.""" - return self.members["pixel"] + value = self.members.get("pixel") + if value is None: + raise KeyError("pixel") + return value -class Sentinel1QualityMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1QualityMembers(TypedDict, closed=True, total=False): """Members for quality group. Closed TypedDict with optional fields to support different product variants: @@ -824,7 +1087,7 @@ class Sentinel1QualityMembers(TypedDict, closed=True, total=False): # type: ign noise_range: Sentinel1NoiseRangeGroup -class Sentinel1QualityGroup(GroupSpec[DatasetAttrs, Sentinel1QualityMembers]): # type: ignore[type-var] +class Sentinel1QualityGroup(GroupSpec[DatasetAttrs, Sentinel1QualityMembers]): """Quality group containing quality assurance and calibration data. Supports both S1A (with noise_azimuth, noise_range) and S1C (without them) products. @@ -848,7 +1111,7 @@ def get_noise_range(self) -> Sentinel1NoiseRangeGroup | None: # Measurements -class Sentinel1MeasurementsMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel1MeasurementsMembers(TypedDict, closed=True, total=False): """Members for measurements group.""" azimuth_time: ArraySpec[Any] @@ -858,37 +1121,52 @@ class Sentinel1MeasurementsMembers(TypedDict, closed=True, total=False): # type pixel: ArraySpec[Any] -class Sentinel1MeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel1MeasurementsMembers]): # type: ignore[type-var] +class Sentinel1MeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel1MeasurementsMembers]): """Measurements group containing SAR imagery data.""" @property def azimuth_time(self) -> ArraySpec[Any]: """Get azimuth_time array.""" - return self.members["azimuth_time"] + value = self.members.get("azimuth_time") + if value is None: + raise KeyError("azimuth_time") + return value @property def grd(self) -> ArraySpec[Any]: """Get grd array.""" - return self.members["grd"] + value = self.members.get("grd") + if value is None: + raise KeyError("grd") + return value @property def ground_range(self) -> ArraySpec[Any]: """Get ground_range array.""" - return self.members["ground_range"] + value = self.members.get("ground_range") + if value is None: + raise KeyError("ground_range") + return value @property def line(self) -> ArraySpec[Any]: """Get line array.""" - return self.members["line"] + value = self.members.get("line") + if value is None: + raise KeyError("line") + return value @property def pixel(self) -> ArraySpec[Any]: """Get pixel array.""" - return self.members["pixel"] + value = self.members.get("pixel") + if value is None: + raise KeyError("pixel") + return value # Polarization group -class Sentinel1PolarizationMembers(TypedDict, closed=True): # type: ignore[call-arg] +class Sentinel1PolarizationMembers(TypedDict, closed=True): """Members for polarization group. Closed TypedDict - only conditions, measurements, quality keys are allowed. @@ -899,7 +1177,7 @@ class Sentinel1PolarizationMembers(TypedDict, closed=True): # type: ignore[call quality: Sentinel1QualityGroup -class Sentinel1PolarizationGroup(GroupSpec[DatasetAttrs, Sentinel1PolarizationMembers]): # type: ignore[type-var] +class Sentinel1PolarizationGroup(GroupSpec[DatasetAttrs, Sentinel1PolarizationMembers]): """Polarization-specific group containing all data for one polarization.""" @property diff --git a/src/eopf_geozarr/data_api/s2.py b/src/eopf_geozarr/data_api/s2.py index 3cfdbd02..c86c48a7 100644 --- a/src/eopf_geozarr/data_api/s2.py +++ b/src/eopf_geozarr/data_api/s2.py @@ -222,7 +222,7 @@ class Sentinel2ArrayAttributes(BaseModel): # Resolution-level members for probability data arrays -class ProbabilityArrayMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class ProbabilityArrayMembers(TypedDict, closed=True, total=False): """Members for probability arrays at a specific resolution (r10m, r20m, r60m). Closed TypedDict - contains probability arrays (cld, snw) and per-band/coordinate arrays. @@ -237,20 +237,20 @@ class ProbabilityArrayMembers(TypedDict, closed=True, total=False): # type: ign # Probability resolution groups (r10m, r20m, r60m) -class ProbabilityResolutionMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class ProbabilityResolutionMembers(TypedDict, closed=True, total=False): """Members for probability data containing resolution-level groups (r10m, r20m, r60m). Closed TypedDict - contains resolution groups as subgroups. All fields are optional since not all resolutions are always present. """ - r10m: GroupSpec[Any, ProbabilityArrayMembers] # type: ignore[type-var] - r20m: GroupSpec[Any, ProbabilityArrayMembers] # type: ignore[type-var] - r60m: GroupSpec[Any, ProbabilityArrayMembers] # type: ignore[type-var] + r10m: GroupSpec[Any, ProbabilityArrayMembers] + r20m: GroupSpec[Any, ProbabilityArrayMembers] + r60m: GroupSpec[Any, ProbabilityArrayMembers] # Resolution-level members for quicklook data arrays -class QuicklookArrayMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class QuicklookArrayMembers(TypedDict, closed=True, total=False): """Members for quicklook arrays at a specific resolution. Closed TypedDict - typically contains TCI (True Color Image) and optional band/coordinate arrays. @@ -264,20 +264,20 @@ class QuicklookArrayMembers(TypedDict, closed=True, total=False): # type: ignor # Quicklook resolution groups (r10m, r20m, r60m) -class QuicklookResolutionMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class QuicklookResolutionMembers(TypedDict, closed=True, total=False): """Members for quicklook data containing resolution-level groups (r10m, r20m, r60m). Closed TypedDict - contains resolution groups as subgroups. All fields are optional since not all resolutions are always present. """ - r10m: GroupSpec[Any, QuicklookArrayMembers] # type: ignore[type-var] - r20m: GroupSpec[Any, QuicklookArrayMembers] # type: ignore[type-var] - r60m: GroupSpec[Any, QuicklookArrayMembers] # type: ignore[type-var] + r10m: GroupSpec[Any, QuicklookArrayMembers] + r20m: GroupSpec[Any, QuicklookArrayMembers] + r60m: GroupSpec[Any, QuicklookArrayMembers] # Mask members - contains resolution-level groups or various classification/detector groups -class ConditionsMaskMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class ConditionsMaskMembers(TypedDict, closed=True, total=False): """Members for mask subgroup in conditions. Closed TypedDict - can contain either: @@ -297,7 +297,7 @@ class ConditionsMaskMembers(TypedDict, closed=True, total=False): # type: ignor # Geometry members - contains angle and orientation groups/arrays -class GeometryMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class GeometryMembers(TypedDict, closed=True, total=False): """Members for geometry group containing sun and viewing angles. Closed TypedDict - contains angle and geometry groups/arrays with flexible internal structure. @@ -321,7 +321,7 @@ class GeometryMembers(TypedDict, closed=True, total=False): # type: ignore[call # Meteorology members - contains CAMS and ECMWF atmospheric data -class MeteorologyMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class MeteorologyMembers(TypedDict, closed=True, total=False): """Members for meteorology group containing CAMS and ECMWF atmospheric data. Closed TypedDict - contains subgroups for different meteorological data sources. @@ -458,7 +458,7 @@ class Sentinel2CoordinateArray(ArraySpec[Sentinel2DataArrayAttrs]): # TypedDict definitions for members structure -class Sentinel2ResolutionMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel2ResolutionMembers(TypedDict, closed=True, total=False): """Members dict for a resolution dataset (r10m, r20m, r60m). Closed TypedDict - no extra keys are allowed beyond those explicitly defined. @@ -483,11 +483,11 @@ class Sentinel2ResolutionMembers(TypedDict, closed=True, total=False): # type: b12: ArraySpec[Any] -class Sentinel2ResolutionDataset(GroupSpec[DatasetAttrs, Sentinel2ResolutionMembers]): # type: ignore[type-var] +class Sentinel2ResolutionDataset(GroupSpec[DatasetAttrs, Sentinel2ResolutionMembers]): """A single resolution dataset within reflectance (r10m, r20m, r60m).""" -class Sentinel2ReflectanceMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel2ReflectanceMembers(TypedDict, closed=True, total=False): """Members for reflectance group. Closed TypedDict - only r10m, r20m, r60m keys are allowed. @@ -498,11 +498,11 @@ class Sentinel2ReflectanceMembers(TypedDict, closed=True, total=False): # type: r60m: Sentinel2ResolutionDataset -class Sentinel2ReflectanceGroup(GroupSpec[DatasetAttrs, Sentinel2ReflectanceMembers]): # type: ignore[type-var] +class Sentinel2ReflectanceGroup(GroupSpec[DatasetAttrs, Sentinel2ReflectanceMembers]): """Reflectance data organized by resolution.""" -class Sentinel2MeasurementsMembers(TypedDict, closed=True): # type: ignore[call-arg] +class Sentinel2MeasurementsMembers(TypedDict, closed=True): """Members for measurements group. Closed TypedDict - only 'reflectance' key is allowed. @@ -511,7 +511,7 @@ class Sentinel2MeasurementsMembers(TypedDict, closed=True): # type: ignore[call reflectance: Sentinel2ReflectanceGroup -class Sentinel2MeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel2MeasurementsMembers]): # type: ignore[type-var] +class Sentinel2MeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel2MeasurementsMembers]): """Measurements group containing reflectance data.""" @property @@ -523,7 +523,7 @@ def reflectance(self) -> Sentinel2ReflectanceGroup: # Quality data groups - need resolution-level typed groups -class Sentinel2AtmosphereResolutionMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel2AtmosphereResolutionMembers(TypedDict, closed=True, total=False): """Members for atmosphere data at a specific resolution. Closed TypedDict - may contain aot and/or wvp arrays depending on available data. @@ -537,12 +537,12 @@ class Sentinel2AtmosphereResolutionMembers(TypedDict, closed=True, total=False): class Sentinel2AtmosphereResolutionDataset( - GroupSpec[DatasetAttrs, Sentinel2AtmosphereResolutionMembers] # type: ignore[type-var] + GroupSpec[DatasetAttrs, Sentinel2AtmosphereResolutionMembers] ): """Atmosphere data at a single resolution.""" -class Sentinel2AtmosphereMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel2AtmosphereMembers(TypedDict, closed=True, total=False): """Members for atmosphere group containing resolution datasets.""" r10m: Sentinel2AtmosphereResolutionDataset @@ -550,25 +550,23 @@ class Sentinel2AtmosphereMembers(TypedDict, closed=True, total=False): # type: r60m: Sentinel2AtmosphereResolutionDataset -class Sentinel2AtmosphereDataset(GroupSpec[DatasetAttrs, Sentinel2AtmosphereMembers]): # type: ignore[type-var] +class Sentinel2AtmosphereDataset(GroupSpec[DatasetAttrs, Sentinel2AtmosphereMembers]): """Atmosphere quality data (AOT, WVP) at multiple resolutions.""" -class Sentinel2ProbabilityDataset( - GroupSpec[DatasetAttrs, ProbabilityResolutionMembers] # type: ignore[type-var] -): +class Sentinel2ProbabilityDataset(GroupSpec[DatasetAttrs, ProbabilityResolutionMembers]): """Probability data (cloud, snow) at multiple resolutions.""" -class Sentinel2QuicklookDataset(GroupSpec[DatasetAttrs, QuicklookResolutionMembers]): # type: ignore[type-var] +class Sentinel2QuicklookDataset(GroupSpec[DatasetAttrs, QuicklookResolutionMembers]): """True Color Image (TCI) quicklook data at multiple resolutions.""" -class Sentinel2MaskDataset(GroupSpec[DatasetAttrs, ConditionsMaskMembers]): # type: ignore[type-var] +class Sentinel2MaskDataset(GroupSpec[DatasetAttrs, ConditionsMaskMembers]): """Mask data containing classification and detector footprints.""" -class Sentinel2QualityMembers(TypedDict, closed=True, total=False): # type: ignore[call-arg] +class Sentinel2QualityMembers(TypedDict, closed=True, total=False): """Members for quality group. Closed TypedDict with optional fields to accommodate different product levels: @@ -583,7 +581,7 @@ class Sentinel2QualityMembers(TypedDict, closed=True, total=False): # type: ign mask: Sentinel2MaskDataset -class Sentinel2QualityGroup(GroupSpec[DatasetAttrs, Sentinel2QualityMembers]): # type: ignore[type-var] +class Sentinel2QualityGroup(GroupSpec[DatasetAttrs, Sentinel2QualityMembers]): """Quality group containing atmosphere, probability, classification, and quicklook data. Supports both L2A products (Sentinel-2A, 2C) and L1C products (Sentinel-2B). @@ -607,19 +605,19 @@ def mask(self) -> Sentinel2MaskDataset | None: # Conditions groups -class Sentinel2GeometryGroup(GroupSpec[DatasetAttrs, GeometryMembers]): # type: ignore[type-var] +class Sentinel2GeometryGroup(GroupSpec[DatasetAttrs, GeometryMembers]): """Geometry group containing sun and viewing angles.""" -class Sentinel2MeteorologyGroup(GroupSpec[DatasetAttrs, MeteorologyMembers]): # type: ignore[type-var] +class Sentinel2MeteorologyGroup(GroupSpec[DatasetAttrs, MeteorologyMembers]): """Meteorology group containing CAMS and ECMWF atmospheric data.""" -class Sentinel2ConditionsMaskGroup(GroupSpec[DatasetAttrs, ConditionsMaskMembers]): # type: ignore[type-var] +class Sentinel2ConditionsMaskGroup(GroupSpec[DatasetAttrs, ConditionsMaskMembers]): """Mask subgroup in conditions.""" -class Sentinel2ConditionsMembers(TypedDict, closed=True): # type: ignore[call-arg] +class Sentinel2ConditionsMembers(TypedDict, closed=True): """Members for conditions group. Closed TypedDict - only geometry, mask, meteorology keys are allowed. @@ -630,7 +628,7 @@ class Sentinel2ConditionsMembers(TypedDict, closed=True): # type: ignore[call-a meteorology: Sentinel2MeteorologyGroup -class Sentinel2ConditionsGroup(GroupSpec[DatasetAttrs, Sentinel2ConditionsMembers]): # type: ignore[type-var] +class Sentinel2ConditionsGroup(GroupSpec[DatasetAttrs, Sentinel2ConditionsMembers]): """Conditions group containing geometry and meteorology data.""" def geometry(self) -> Sentinel2GeometryGroup | None: @@ -647,7 +645,7 @@ def meteorology(self) -> Sentinel2MeteorologyGroup | None: # Root model -class Sentinel2RootMembers(TypedDict, closed=True): # type: ignore[call-arg] +class Sentinel2RootMembers(TypedDict, closed=True): """Members for Sentinel-2 root group. Closed TypedDict - only measurements, quality, conditions keys are allowed. @@ -658,7 +656,7 @@ class Sentinel2RootMembers(TypedDict, closed=True): # type: ignore[call-arg] conditions: Sentinel2ConditionsGroup -class Sentinel2Root(GroupSpec[Sentinel2RootAttrs, Sentinel2RootMembers]): # type: ignore[type-var] +class Sentinel2Root(GroupSpec[Sentinel2RootAttrs, Sentinel2RootMembers]): """Complete Sentinel-2 EOPF Zarr hierarchy. The hierarchy follows EOPF organization: diff --git a/src/eopf_geozarr/pyz/common.py b/src/eopf_geozarr/pyz/common.py index 3b5bee04..fd21b00f 100644 --- a/src/eopf_geozarr/pyz/common.py +++ b/src/eopf_geozarr/pyz/common.py @@ -103,7 +103,7 @@ def _format_array_html(arr: Any) -> str: if value is None: continue dtype_str = str(value).strip() - value_str = dtype_str if dtype_str else "(not set)" + value_str = dtype_str or "(not set)" # Skip data_type if we already handled it via dtype elif prop_name == "data_type": if getattr(arr, "dtype", None) is not None: @@ -149,13 +149,12 @@ def _format_array_html(arr: Any) -> str: "
" ) - # Get items based on type - if is_dict_attrs: - attrs_dict = attributes - items = list(attrs_dict.items()) - else: # is_model_attrs - attrs_dict = attributes.model_dump() - items = list(attrs_dict.items()) + # Get items based on type. Use direct isinstance checks (not the + # boolean flags) so the type checker narrows `attributes`. + if isinstance(attributes, dict): + items = list(attributes.items()) + else: + items = list(attributes.model_dump().items()) for key, value in items: if isinstance(value, dict): diff --git a/src/eopf_geozarr/pyz/v2.py b/src/eopf_geozarr/pyz/v2.py index 052834fb..52605eb1 100644 --- a/src/eopf_geozarr/pyz/v2.py +++ b/src/eopf_geozarr/pyz/v2.py @@ -40,9 +40,13 @@ class MyGroup(GroupSpec[Any, MyMembers]) TArraySpecType = TypeVar("TArraySpecType") -class GroupSpec(GroupSpecV2[TAttr, TMembers]): +class GroupSpec(GroupSpecV2[TAttr, TMembers]): # type: ignore[type-var] + # TMembers is bound to the full members mapping (e.g. a TypedDict) by design, + # whereas the parent's second type parameter expects a single member item type. attributes: TAttr - members: TMembers + # members holds the full mapping (TMembers) rather than the parent's + # Mapping[str, TItem] | None; this is the intended structure for this subclass. + members: TMembers # type: ignore[assignment] def __repr__(self) -> str: """Return a condensed text representation of the GroupSpec.""" diff --git a/src/eopf_geozarr/pyz/v3.py b/src/eopf_geozarr/pyz/v3.py index fabdf4e6..0613e507 100644 --- a/src/eopf_geozarr/pyz/v3.py +++ b/src/eopf_geozarr/pyz/v3.py @@ -41,8 +41,12 @@ class MyGroup(GroupSpec[Any, MyMembers]) class GroupSpec(GroupSpecV3[TAttr, TMembers]): + # TMembers is bound to the full members mapping (e.g. a TypedDict) by design, + # whereas the parent's second type parameter expects a single member item type. attributes: TAttr - members: TMembers + # members holds the full mapping (TMembers) rather than the parent's + # Mapping[str, TItem] | None; this is the intended structure for this subclass. + members: TMembers # type: ignore[assignment] def __repr__(self) -> str: """Return a condensed text representation of the GroupSpec.""" diff --git a/src/eopf_geozarr/s2_optimization/s2_converter.py b/src/eopf_geozarr/s2_optimization/s2_converter.py index fd303b69..6a868087 100644 --- a/src/eopf_geozarr/s2_optimization/s2_converter.py +++ b/src/eopf_geozarr/s2_optimization/s2_converter.py @@ -5,7 +5,7 @@ from __future__ import annotations import time -from typing import Any, TypedDict +from typing import TYPE_CHECKING, TypedDict import structlog import xarray as xr @@ -20,6 +20,9 @@ from .s2_multiscale import create_multiscale_from_datatree +if TYPE_CHECKING: + from collections.abc import Mapping + log = structlog.get_logger() @@ -66,13 +69,16 @@ def initialize_crs_from_dataset(dt_input: xr.DataTree) -> CRS | None: continue dataset = group_node.ds - # Check if dataset has rio accessor with CRS + # Check if dataset has rio accessor with CRS. rioxarray returns a + # rasterio CRS; convert it to a pyproj CRS (the declared return type), + # which also validates the value at runtime. if hasattr(dataset, "rio"): try: - crs = dataset.rio.crs - if crs is not None: - log.info("Initialized CRS from dataset", crs=str(crs)) - return crs + rio_crs = dataset.rio.crs + if rio_crs is not None: + ds_crs = CRS.from_user_input(rio_crs) + log.info("Initialized CRS from dataset", crs=str(ds_crs)) + return ds_crs except Exception: log.debug("Failed to get CRS from dataset rio accessor") @@ -80,10 +86,11 @@ def initialize_crs_from_dataset(dt_input: xr.DataTree) -> CRS | None: for var in dataset.data_vars.values(): if hasattr(var, "rio"): try: - crs = var.rio.crs - if crs is not None: - log.info("Initialized CRS from variable", crs=str(crs)) - return crs + rio_crs = var.rio.crs + if rio_crs is not None: + var_crs = CRS.from_user_input(rio_crs) + log.info("Initialized CRS from variable", crs=str(var_crs)) + return var_crs except Exception: log.debug("Failed to get CRS from variable rio accessor") @@ -263,7 +270,7 @@ def convert_s2_optimized( return result_dt -def simple_root_consolidation(output_path: str, datasets: dict[str, dict]) -> None: +def simple_root_consolidation(output_path: str, datasets: Mapping[str, object]) -> None: """Simple root-level metadata consolidation with proper zarr group creation.""" # create missing intermediary groups (/conditions, /quality, etc.) # using the keys of the datasets dict @@ -318,6 +325,19 @@ def simple_root_consolidation(output_path: str, datasets: dict[str, dict]) -> No zarr.consolidate_metadata(output_path, zarr_format=3) +def _as_bbox(value: object) -> tuple[float, float, float, float] | None: + """Return *value* as a 4-tuple of floats, or ``None`` if it is not one. + + ``spatial:bbox`` is read from stored metadata, so its type is not known + statically; this verifies the shape at runtime rather than asserting it. + """ + if not isinstance(value, (list, tuple)) or len(value) != 4: + return None + if not all(isinstance(v, (int, float)) for v in value): + return None + return (float(value[0]), float(value[1]), float(value[2]), float(value[3])) + + def write_store_root_bbox(output_path: str) -> None: """Write `spatial:bbox` and `proj:code` at the store root. @@ -336,14 +356,18 @@ def _walk(group: zarr.Group) -> None: attrs = dict(group.attrs) bbox = attrs.get("spatial:bbox") code = attrs.get("proj:code") - if bbox is not None and len(bbox) == 4: + # spatial:bbox comes from stored metadata; verify it is a 4-element + # numeric sequence before use rather than trusting the type. + corners = _as_bbox(bbox) + if corners is not None: + x0, y0, x1, y1 = corners if code and code != "EPSG:4326": transformer = Transformer.from_crs(code, "EPSG:4326", always_xy=True) - xmin, ymin = transformer.transform(bbox[0], bbox[1]) - xmax, ymax = transformer.transform(bbox[2], bbox[3]) + xmin, ymin = transformer.transform(x0, y0) + xmax, ymax = transformer.transform(x1, y1) bboxes_4326.append((xmin, ymin, xmax, ymax)) else: - bboxes_4326.append(tuple(float(v) for v in bbox)) # type: ignore[arg-type] + bboxes_4326.append((x0, y0, x1, y1)) for child in group.groups(): _walk(child[1]) @@ -408,7 +432,7 @@ def create_result_datatree(output_path: str) -> xr.DataTree: def is_sentinel2_dataset(group: zarr.Group) -> bool: from eopf_geozarr.pyz.v2 import GroupSpec - adapter = TypeAdapter(Sentinel1Root | Sentinel2Root) # type: ignore[var-annotated] + adapter = TypeAdapter(Sentinel1Root | Sentinel2Root) try: model = adapter.validate_python(GroupSpec.from_zarr(group).model_dump()) except ValueError as e: @@ -418,7 +442,16 @@ def is_sentinel2_dataset(group: zarr.Group) -> bool: return isinstance(model, Sentinel2Root) -def validate_optimized_dataset(dataset_path: str) -> dict[str, Any]: +class ValidationResult(TypedDict): + """Result of validating an optimized Sentinel-2 dataset.""" + + is_valid: bool + issues: list[str] + warnings: list[str] + summary: dict[str, object] + + +def validate_optimized_dataset(dataset_path: str) -> ValidationResult: """ Validate an optimized Sentinel-2 dataset. diff --git a/src/eopf_geozarr/s2_optimization/s2_data_consolidator.py b/src/eopf_geozarr/s2_optimization/s2_data_consolidator.py index 7ca56db5..67cf071c 100644 --- a/src/eopf_geozarr/s2_optimization/s2_data_consolidator.py +++ b/src/eopf_geozarr/s2_optimization/s2_data_consolidator.py @@ -159,7 +159,7 @@ def _extract_geometry_data(self) -> None: # Consolidate all geometry variables for var_name in ds.data_vars: - self.geometry_data[var_name] = ds[var_name] + self.geometry_data[str(var_name)] = ds[var_name] def _extract_meteorology_data(self) -> None: """Extract meteorological data (CAMS and ECMWF).""" diff --git a/src/eopf_geozarr/s2_optimization/s2_multiscale.py b/src/eopf_geozarr/s2_optimization/s2_multiscale.py index d9743069..a79a9832 100644 --- a/src/eopf_geozarr/s2_optimization/s2_multiscale.py +++ b/src/eopf_geozarr/s2_optimization/s2_multiscale.py @@ -6,25 +6,22 @@ from __future__ import annotations from itertools import pairwise -from typing import TYPE_CHECKING, Any, Literal +from typing import TYPE_CHECKING, Any, Literal, cast import numpy as np import structlog import xarray as xr -from dask import delayed +import zarr from dask.array import from_delayed +from dask.delayed import delayed from pydantic.experimental.missing_sentinel import MISSING from pyproj import CRS from zarr.codecs import CastValue -from zarr_cm import geo_proj -from zarr_cm import multiscales as multiscales_cm -from zarr_cm import spatial as spatial_cm from eopf_geozarr.conversion import utils from eopf_geozarr.conversion.fs_utils import sanitize_dataset_attributes from eopf_geozarr.data_api.geozarr.multiscales import zcm from eopf_geozarr.data_api.geozarr.multiscales.geozarr import ( - MultiscaleGroupAttrs, MultiscaleMeta, ) from eopf_geozarr.data_api.geozarr.types import ( @@ -40,7 +37,8 @@ if TYPE_CHECKING: from collections.abc import Hashable, Mapping - import zarr + from zarr_cm import MultiscalesAttrs + from zarr_cm import spatial as spatial_cm from eopf_geozarr.types import OverviewLevelJSON @@ -107,7 +105,9 @@ def _preferred_spatial_transform( rio_value = dataset.rio.transform if callable(rio_value): rio_value = rio_value() - rio_values = tuple(float(value) for value in tuple(rio_value)[:6]) + # rio transform value is dynamically typed; it is iterable at runtime. + rio_iter = cast("tuple[float, ...]", tuple(rio_value)) # pyright: ignore[reportArgumentType] + rio_values = tuple(float(value) for value in rio_iter[:6]) if len(rio_values) == 6: rio_transform = ( rio_values[0], @@ -139,11 +139,13 @@ def _coarsen_variable(var_name: str, var_data: xr.DataArray, factor: int) -> xr. var_type = determine_variable_type(var_name, var_data) coarsened = var_data.coarsen({"x": factor, "y": factor}, boundary="trim") if var_type in ("reflectance", "probability"): - result = coarsened.mean() + # xarray stubs omit reduction methods on DataArrayCoarsen. + result = coarsened.mean() # type: ignore[attr-defined] elif var_type == "classification": result = coarsened.reduce(subsample_2) elif var_type == "quality_mask": - result = coarsened.max() + # xarray stubs omit reduction methods on DataArrayCoarsen. + result = coarsened.max() # type: ignore[attr-defined] else: raise ValueError(f"Unknown variable type {var_type}") @@ -152,9 +154,9 @@ def _coarsen_variable(var_name: str, var_data: xr.DataArray, factor: int) -> xr. # inspects encoding (e.g. to push CF scale-offset into a codec pipeline) # would see an empty encoding on every coarsened level. encoding = var_data.encoding - result = result.astype(var_data.dtype) - result.encoding = encoding - return result + cast_result: xr.DataArray = result.astype(var_data.dtype) + cast_result.encoding = encoding + return cast_result def inject_missing_bands( @@ -255,7 +257,7 @@ def create_multiscale_from_datatree( Returns: Dictionary of processed groups """ - processed_groups = {} + processed_groups: dict[str, Any] = {} # The scale levels in the output data. 10, 20, 60 already exist in the source data. # Step 1: Copy all original groups as-is @@ -409,14 +411,20 @@ def create_multiscale_from_datatree( # Step 3: Add multiscales metadata to parent groups log.info("Adding multiscales metadata to parent groups") - # Get the parent group (it was created when writing the resolution groups) + # Get the parent group (it was created when writing the resolution groups). + # `output_group[base_path]` is typed `Array | Group`; `base_path` always + # addresses a group (the reflectance parent), so verify that at runtime. parent_group = output_group[base_path] + if not isinstance(parent_group, zarr.Group): + raise TypeError( + f"expected a zarr.Group at {base_path!r}, got {type(parent_group).__name__}" + ) - dt_multiscale = add_multiscales_metadata_to_parent( + add_multiscales_metadata_to_parent( parent_group, resolution_groups, ) - processed_groups[base_path] = dt_multiscale + processed_groups[base_path] = None return processed_groups @@ -475,6 +483,11 @@ def create_measurements_encoding( # Forward-propagate the existing encoding, minus keys that should be omitted keep_keys = XARRAY_ENCODING_KEYS - {"compressors", "shards", "chunks"} + # Whether to inject a CF _FillValue attribute for xarray issue #11345. + # The injection itself happens after sanitize_array_attrs below, which + # would otherwise strip it. + inject_nan_fillvalue = False + if experimental_scale_offset_codec and not keep_scale_offset: # Push CF scale-offset into the zarr codec pipeline instead of # decoding to float. The data stays as packed integers on disk, @@ -516,8 +529,7 @@ def create_measurements_encoding( # on the source variable. keep_keys = keep_keys - CF_SCALE_OFFSET_KEYS - {"_FillValue", "filters"} var_encoding["fill_value"] = "NaN" - # Inject CF _FillValue attribute for xarray issue #11345 - var_data.attrs["_FillValue"] = np.nan + inject_nan_fillvalue = True elif not keep_scale_offset: # When stripping scale/offset, also strip _FillValue since the original # _FillValue is in raw integer units and meaningless for decoded float data. @@ -528,12 +540,11 @@ def create_measurements_encoding( # to set the zarr-level fill value, distinct from "_FillValue" which # controls CF-convention attribute masking. var_encoding["fill_value"] = "NaN" - # Inject CF _FillValue attribute for xarray issue #11345 - var_data.attrs["_FillValue"] = np.nan + inject_nan_fillvalue = True for key in keep_keys: if key in var_data.encoding: - var_encoding[key] = var_data.encoding[key] # type: ignore[literal-required] + var_encoding[key] = var_data.encoding[key] if len(set(var_data.encoding.keys()) - XARRAY_ENCODING_KEYS) > 0: log.warning( @@ -546,13 +557,16 @@ def create_measurements_encoding( # otherwise leak into the output). is_float = np.issubdtype(var_data.dtype, np.floating) var_data.attrs = utils.sanitize_array_attrs(var_data.attrs, is_decoded_float=is_float) - encoding[var_name] = var_encoding + if inject_nan_fillvalue: + # Inject CF _FillValue attribute for xarray issue #11345 + var_data.attrs["_FillValue"] = np.nan + encoding[str(var_name)] = var_encoding # Add coordinate encoding and sanitize coord attrs (e.g. drop # ``_eopf_attrs`` from datetime coords carried in from the source). for coord_name, coord_data in dataset.coords.items(): coord_data.attrs = utils.sanitize_array_attrs(coord_data.attrs) - encoding[coord_name] = {"compressors": []} # type: ignore[typeddict-item] + encoding[str(coord_name)] = {"compressors": []} # type: ignore[typeddict-item] return encoding @@ -613,8 +627,12 @@ def calculate_simple_shard_dimensions( def add_multiscales_metadata_to_parent( group: zarr.Group, res_groups: Mapping[str, xr.Dataset], -) -> xr.DataTree: - """Add GeoZarr-compliant multiscales metadata to parent group.""" +) -> None: + """Add GeoZarr-compliant multiscales metadata to parent group. + + Returns ``None`` in all cases: metadata is written directly to ``group`` + via ``group.attrs.update`` rather than returned as a DataTree. + """ # Sort by resolution (finest to coarsest) res_order = { "r10m": 10, @@ -632,7 +650,7 @@ def add_multiscales_metadata_to_parent( "Skipping {} - only one resolution available", base_path=group.path, ) - return None + return # Get CRS and bounds from first available dataset (load from output path) first_res = all_resolutions[0] @@ -642,14 +660,14 @@ def add_multiscales_metadata_to_parent( native_crs = first_dataset.rio.crs if hasattr(first_dataset, "rio") else None if native_crs is None: log.info("No CRS found, skipping multiscales metadata", base_path=group.path) - return None + return # Calculate bounds directly from coordinates for consistency with the data arrays if "x" not in first_dataset.coords or "y" not in first_dataset.coords: log.error( "Missing x/y coordinates in dataset, cannot determine bounds", base_path=group.path ) - return None + return x_coords = first_dataset.x.values y_coords = first_dataset.y.values @@ -668,6 +686,8 @@ def add_multiscales_metadata_to_parent( dataset = res_groups[res_name] + # Defensive guard retained for runtime safety even though the typed + # contract (Mapping[str, xr.Dataset]) means mypy proves it unreachable. if dataset is None: continue @@ -771,9 +791,9 @@ def add_multiscales_metadata_to_parent( if len(overview_levels) < 2: log.info(" Could not create overview levels for {}", base_path=group.path) - return None + return - layout: list[zcm.ScaleLevel] | MISSING = MISSING # type: ignore[valid-type] + layout: list[zcm.ScaleLevel] | MISSING = MISSING layout = [] @@ -804,6 +824,7 @@ def add_multiscales_metadata_to_parent( scale_level_data["transform"] = multiscale_transform # Add spatial properties + assert "spatial_shape" in overview_level # always populated by the producer above scale_level_data["spatial:shape"] = overview_level["spatial_shape"] if "spatial_transform" in overview_level: spatial_transform = overview_level["spatial_transform"] @@ -813,42 +834,35 @@ def add_multiscales_metadata_to_parent( scale_level = zcm.ScaleLevel(**scale_level_data) layout.append(scale_level) - # Create convention metadata for all three conventions - multiscale_attrs = MultiscaleGroupAttrs( - zarr_conventions=( - multiscales_cm.CMO, - spatial_cm.CMO, - geo_proj.CMO, - ), - multiscales=MultiscaleMeta( - layout=layout, - resampling_method="average", - ), - ) - # Write multiscale attributes directly to the parent group - attrs_to_write = multiscale_attrs.model_dump() + # Validate + serialize the multiscales block via the project model (which + # also covers the ZCM/TMS duality), then hand all three conventions to + # zarr-cm, which validates each and emits the matching CMOs in order + # (multiscales, spatial, proj). + multiscales_data = cast( + "MultiscalesAttrs", + MultiscaleMeta(layout=tuple(layout), resampling_method="average").model_dump(), + ) - # Add spatial and proj attributes at group level following specifications + attrs_to_write: dict[str, Any] = {} if native_crs and native_bounds: - # Add spatial convention attributes - attrs_to_write["spatial:dimensions"] = ["y", "x"] # Required field - attrs_to_write["spatial:bbox"] = list(native_bounds) # [xmin, ymin, xmax, ymax] - attrs_to_write["spatial:registration"] = "pixel" # Default registration type - - # Add proj convention attributes - if hasattr(native_crs, "to_epsg") and native_crs.to_epsg(): - attrs_to_write["proj:code"] = f"EPSG:{native_crs.to_epsg()}" - elif hasattr(native_crs, "to_wkt"): - attrs_to_write["proj:wkt2"] = native_crs.to_wkt() + attrs_to_write.update( + utils.build_convention_attrs( + multiscales=multiscales_data, + spatial={ + "spatial:dimensions": ["y", "x"], + "spatial:bbox": list(native_bounds), # [xmin, ymin, xmax, ymax] + "spatial:registration": "pixel", + }, + crs=native_crs, + ) + ) # Write attributes directly to the zarr group group.attrs.update(attrs_to_write) log.info("Added %s multiscale levels to %s", len(overview_levels), group.path) - return None # No DataTree to return since we wrote directly to the group - def create_original_encoding(dataset: xr.Dataset) -> dict[str, XarrayDataArrayEncoding]: """Write a group preserving its original chunking and encoding.""" @@ -856,7 +870,7 @@ def create_original_encoding(dataset: xr.Dataset) -> dict[str, XarrayDataArrayEn # Simple encoding that preserves original structure compressor = BloscCodec(cname="zstd", clevel=3, shuffle="shuffle", blocksize=0) - encoding = {} + encoding: dict[str, XarrayDataArrayEncoding] = {} for var_name in dataset.data_vars: # start with the original encoding @@ -865,7 +879,7 @@ def create_original_encoding(dataset: xr.Dataset) -> dict[str, XarrayDataArrayEn var_encoding["compressors"] = (compressor,) for key in XARRAY_ENCODING_KEYS - {"compressors", "fill_value"}: if key in var_data.encoding: - var_encoding[key] = var_data.encoding[key] # type: ignore[literal-required] + var_encoding[key] = var_data.encoding[key] # Set the zarr-level `fill_value` explicitly rather than letting xarray # decide — different xarray versions infer different defaults from the # variable's `_FillValue`. See `explicit_fill_value` for the rationale. @@ -881,11 +895,11 @@ def create_original_encoding(dataset: xr.Dataset) -> dict[str, XarrayDataArrayEn # Sanitize source-only attributes (replace dict — ``.update`` cannot # remove keys, so stale ``_eopf_attrs`` would otherwise leak through). var_data.attrs = utils.sanitize_array_attrs(var_data.attrs) - encoding[var_name] = var_encoding + encoding[str(var_name)] = var_encoding for coord_name, coord_data in dataset.coords.items(): coord_data.attrs = utils.sanitize_array_attrs(coord_data.attrs) - encoding[coord_name] = {"compressors": None} + encoding[str(coord_name)] = {"compressors": None} return encoding @@ -912,7 +926,7 @@ def create_downsampled_resolution_group(source_dataset: xr.Dataset, factor: int) for var_name, var_data in source_dataset.data_vars.items(): if var_data.ndim < 2: continue - lazy_vars[var_name] = _coarsen_variable(var_name, var_data, factor) + lazy_vars[var_name] = _coarsen_variable(str(var_name), var_data, factor) if not lazy_vars: return xr.Dataset() @@ -962,7 +976,7 @@ def create_downsampled_coordinates( # Copy any other coordinates that might exist coords.update( { - coord_name: coord_data + str(coord_name): coord_data for coord_name, coord_data in level_2_dataset.coords.items() if coord_name not in ["x", "y"] } @@ -976,9 +990,9 @@ def create_lazy_downsample_operation_from_existing( ) -> xr.DataArray: """Create lazy downsampling operation from existing data.""" - @delayed # type: ignore[misc] + @delayed def downsample_operation() -> Any: - var_type = determine_variable_type(source_data.name, source_data) + var_type = determine_variable_type(str(source_data.name), source_data) return downsample_variable(source_data, target_height, target_width, var_type) # Create delayed operation @@ -1040,8 +1054,14 @@ def stream_write_dataset( "Level path {} already exists. Skipping write.", dataset_path=path, ) + # The zarr backend accepts a zarr `Store` here at runtime, but xarray's + # `open_dataset` stub only types the first arg as path/buffer/datastore. return xr.open_dataset( - group.store, engine="zarr", chunks={}, decode_coords="all", group=path + group.store, # type: ignore[arg-type] + engine="zarr", + chunks={}, + decode_coords="all", + group=path, ) log.info("Streaming computation and write to {}", dataset_path=path) @@ -1079,8 +1099,11 @@ def stream_write_dataset( # Try to get current client for better status monitoring try: client = distributed.Client.current() - # Use client.compute to get a proper Future with status + # client.compute is untyped (returns Any); verify we got a + # Future rather than asserting it with a cast. future = client.compute(write_job) + if not isinstance(future, distributed.Future): + raise TypeError(f"expected a distributed.Future, got {type(future).__name__}") log.info("Using distributed client for write job monitoring") try: @@ -1146,9 +1169,11 @@ def write_geo_metadata( # TODO : Remove once rioxarray supports writing these conventions directly # https://github.com/corteva/rioxarray/pull/883 - # Add spatial convention attributes - dataset.attrs["spatial:dimensions"] = ["y", "x"] # Required field - dataset.attrs["spatial:registration"] = "pixel" # Default registration type + # Assemble spatial convention data + spatial_data: spatial_cm.SpatialAttrs = { + "spatial:dimensions": ["y", "x"], # Required field + "spatial:registration": "pixel", # Default registration type + } # Calculate and add spatial bbox if coordinates are available if "x" in dataset.coords and "y" in dataset.coords: @@ -1156,33 +1181,23 @@ def write_geo_metadata( y_coords = dataset.coords["y"].values x_min, x_max = float(x_coords.min()), float(x_coords.max()) y_min, y_max = float(y_coords.min()), float(y_coords.max()) - dataset.attrs["spatial:bbox"] = [x_min, y_min, x_max, y_max] + spatial_data["spatial:bbox"] = [x_min, y_min, x_max, y_max] spatial_transform = _preferred_spatial_transform(dataset) # Only add spatial:transform if we have valid transform data (not all zeros) if spatial_transform is not None and not all(t == 0 for t in spatial_transform): - dataset.attrs["spatial:transform"] = list(spatial_transform) + spatial_data["spatial:transform"] = list(spatial_transform) # Add spatial shape if data variables exist if dataset.data_vars: first_var = next(iter(dataset.data_vars.values())) if first_var.ndim >= 2: height, width = first_var.shape[-2:] - dataset.attrs["spatial:shape"] = [height, width] - - # Add proj convention attributes - if hasattr(crs, "to_epsg") and crs.to_epsg(): - dataset.attrs["proj:code"] = f"EPSG:{crs.to_epsg()}" - elif hasattr(crs, "to_wkt"): - dataset.attrs["proj:wkt2"] = crs.to_wkt() + spatial_data["spatial:shape"] = [height, width] - # Add zarr convention declarations - conventions = [ - spatial_cm.CMO, - geo_proj.CMO, - ] - dataset.attrs["zarr_conventions"] = conventions + # Build validated spatial + proj convention attrs (data + CMOs) via zarr-cm + dataset.attrs.update(utils.build_convention_attrs(spatial=spatial_data, crs=crs)) def rechunk_dataset_for_encoding( @@ -1194,11 +1209,11 @@ def rechunk_dataset_for_encoding( When using Zarr v3 sharding, Dask chunks must align with shard dimensions to avoid checksum validation errors. """ - rechunked_vars = {} + rechunked_vars: dict[Hashable, xr.DataArray] = {} for var_name, var_data in dataset.data_vars.items(): - if var_name in encoding: - var_encoding = encoding[var_name] + if str(var_name) in encoding: + var_encoding = encoding[str(var_name)] # If sharding is enabled, rechunk based on shard dimensions if "shards" in var_encoding and var_encoding["shards"] is not None: diff --git a/tests/_test_data/geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json b/tests/_test_data/geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json index 48a69cc8..8bc9e17a 100644 --- a/tests/_test_data/geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json +++ b/tests/_test_data/geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json @@ -4117,22 +4117,22 @@ "zarr_conventions": [ { "uuid": "d35379db-88df-4056-af3a-620245f8e347", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "name": "multiscales", "description": "Multiscale layout of zarr datasets" }, { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4277,15 +4277,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4752,15 +4752,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -5842,15 +5842,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -6856,15 +6856,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -7946,15 +7946,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -9037,15 +9037,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10141,15 +10141,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10457,15 +10457,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10773,15 +10773,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -11096,15 +11096,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -11636,15 +11636,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -12362,15 +12362,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -12816,15 +12816,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } diff --git a/tests/_test_data/geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json b/tests/_test_data/geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json index 9d0f84b2..15039c49 100644 --- a/tests/_test_data/geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json +++ b/tests/_test_data/geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json @@ -3812,22 +3812,22 @@ "zarr_conventions": [ { "uuid": "d35379db-88df-4056-af3a-620245f8e347", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "name": "multiscales", "description": "Multiscale layout of zarr datasets" }, { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -3972,15 +3972,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4447,15 +4447,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4921,15 +4921,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -5627,15 +5627,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -6101,15 +6101,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -6576,15 +6576,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -7064,15 +7064,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -7604,15 +7604,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -8330,15 +8330,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } diff --git a/tests/_test_data/geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json b/tests/_test_data/geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json index be9ee053..0b19623b 100644 --- a/tests/_test_data/geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json +++ b/tests/_test_data/geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json @@ -4117,22 +4117,22 @@ "zarr_conventions": [ { "uuid": "d35379db-88df-4056-af3a-620245f8e347", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "name": "multiscales", "description": "Multiscale layout of zarr datasets" }, { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4277,15 +4277,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -4752,15 +4752,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -5842,15 +5842,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -6856,15 +6856,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -7946,15 +7946,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -9037,15 +9037,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10141,15 +10141,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10457,15 +10457,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -10773,15 +10773,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -11096,15 +11096,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -11636,15 +11636,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -12362,15 +12362,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } @@ -12816,15 +12816,15 @@ "zarr_conventions": [ { "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "name": "spatial:", "description": "Spatial coordinate information" }, { "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "name": "proj:", "description": "Coordinate reference system information for geospatial data" } diff --git a/tests/_test_data/optimized_geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json b/tests/_test_data/optimized_geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json index fa20e80d..5b335149 100644 --- a/tests/_test_data/optimized_geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json +++ b/tests/_test_data/optimized_geozarr_examples/S2A_MSIL2A_20251008T100041_N0511_R122_T32TQM_20251008T122613.json @@ -4218,22 +4218,22 @@ { "description": "Multiscale layout of zarr datasets", "name": "multiscales", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "uuid": "d35379db-88df-4056-af3a-620245f8e347" }, { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -4262,15 +4262,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -4830,15 +4830,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -6195,15 +6195,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -7463,15 +7463,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -8828,15 +8828,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -10196,15 +10196,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -11575,15 +11575,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -11891,15 +11891,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -12207,15 +12207,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -12530,15 +12530,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -13070,15 +13070,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -13796,15 +13796,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -14250,15 +14250,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] diff --git a/tests/_test_data/optimized_geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json b/tests/_test_data/optimized_geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json index caf32e63..d75fa908 100644 --- a/tests/_test_data/optimized_geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json +++ b/tests/_test_data/optimized_geozarr_examples/S2B_MSIL1C_20250113T103309_N0511_R108_T32TLQ_20250113T122458.json @@ -3913,22 +3913,22 @@ { "description": "Multiscale layout of zarr datasets", "name": "multiscales", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "uuid": "d35379db-88df-4056-af3a-620245f8e347" }, { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -3957,15 +3957,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -4525,15 +4525,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -5090,15 +5090,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -5958,15 +5958,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -6523,15 +6523,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -7091,15 +7091,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -7670,15 +7670,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -8210,15 +8210,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -8936,15 +8936,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] diff --git a/tests/_test_data/optimized_geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json b/tests/_test_data/optimized_geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json index 9ed8a49e..7eb259c3 100644 --- a/tests/_test_data/optimized_geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json +++ b/tests/_test_data/optimized_geozarr_examples/S2C_MSIL2A_20250811T112131_N0511_R037_T29TPF_20250811T152216.json @@ -4218,22 +4218,22 @@ { "description": "Multiscale layout of zarr datasets", "name": "multiscales", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/multiscales/refs/tags/v0.1/schema.json", + "spec_url": "https://github.com/zarr-conventions/multiscales/blob/v0.1/README.md", "uuid": "d35379db-88df-4056-af3a-620245f8e347" }, { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -4262,15 +4262,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -4830,15 +4830,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -6195,15 +6195,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -7463,15 +7463,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -8828,15 +8828,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -10196,15 +10196,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -11575,15 +11575,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -11891,15 +11891,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -12207,15 +12207,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -12530,15 +12530,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -13070,15 +13070,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -13796,15 +13796,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] @@ -14250,15 +14250,15 @@ { "description": "Spatial coordinate information", "name": "spatial:", - "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-conventions/spatial/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" }, { "description": "Coordinate reference system information for geospatial data", "name": "proj:", - "schema_url": "https://raw.githubusercontent.com/zarr-experimental/geo-proj/refs/tags/v1/schema.json", - "spec_url": "https://github.com/zarr-experimental/geo-proj/blob/v1/README.md", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] diff --git a/tests/conftest.py b/tests/conftest.py index c08bade3..59746f8f 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -28,7 +28,9 @@ def read_json(path: pathlib.Path) -> dict[str, object]: """ Read the contents of path as JSON """ - return json.loads(path.read_text()) + obj = json.loads(path.read_text()) + assert isinstance(obj, dict) + return obj def get_stem(p: pathlib.Path) -> str: @@ -40,8 +42,9 @@ def create_group_from_json(source_path: pathlib.Path, out_path: pathlib.Path) -> Create a Zarr V2 group from a JSON model """ out_dir = out_path / (source_path.stem + ".zarr") - g = GroupSpecV2(**read_json(source_path)) - g.to_zarr(out_dir, path="") + g: GroupSpecV2 = GroupSpecV2.model_validate(read_json(source_path)) + # to_zarr is annotated to take a Store but accepts a path-like at runtime. + g.to_zarr(out_dir, path="") # type: ignore[arg-type] return out_dir @@ -87,8 +90,9 @@ def s2_geozarr_group_example(request: pytest.FixtureRequest) -> zarr.Group: Return a memory-backed Zarr V3 Group based on a sentinel 2 product converted to geozarr """ source_path: pathlib.Path = request.param - store = {} - return GroupSpecV3(**read_json(source_path)).to_zarr(store, path="") + store: dict[str, bytes] = {} + # to_zarr is annotated to take a Store but accepts a dict-backed store at runtime. + return GroupSpecV3.model_validate(read_json(source_path)).to_zarr(store, path="") # type: ignore[arg-type] @pytest.fixture(params=optimized_geozarr_example_paths, ids=get_stem) @@ -97,8 +101,9 @@ def s2_optimized_geozarr_group_example(request: pytest.FixtureRequest) -> zarr.G Return a memory-backed Zarr V3 Group based on a sentinel 2 product converted to geozarr """ source_path: pathlib.Path = request.param - store = {} - return GroupSpecV3(**read_json(source_path)).to_zarr(store, path="") + store: dict[str, bytes] = {} + # to_zarr is annotated to take a Store but accepts a dict-backed store at runtime. + return GroupSpecV3.model_validate(read_json(source_path)).to_zarr(store, path="") # type: ignore[arg-type] @pytest.fixture(params=zcm_multiscales_example_paths, ids=get_stem) @@ -207,7 +212,7 @@ def _verify_geozarr_spec_compliance(output_path: pathlib.Path, group: str) -> No # Check coordinates for coord_name in ds.coords: - if coord_name not in ["spatial_ref"]: # Skip CRS coordinate + if coord_name != "spatial_ref": # Skip CRS coordinate assert "_ARRAY_DIMENSIONS" in ds[coord_name].attrs, ( f"Missing _ARRAY_DIMENSIONS for coordinate {coord_name} in {group}" ) diff --git a/tests/test_array_attrs.py b/tests/test_array_attrs.py index 53ef3e0a..a4234a11 100644 --- a/tests/test_array_attrs.py +++ b/tests/test_array_attrs.py @@ -46,7 +46,8 @@ def _is_float_array(node: dict) -> bool: @pytest.fixture(params=_SNAPSHOTS, ids=lambda p: p.stem) def snapshot(request: pytest.FixtureRequest) -> dict: - return json.loads(request.param.read_text()) + loaded: dict = json.loads(request.param.read_text()) + return loaded def test_no_eopf_attrs(snapshot: dict) -> None: @@ -163,7 +164,9 @@ def test_fill_value_masking_roundtrip(tmp_path: pathlib.Path) -> None: "NaN cells in converter output should be masked when opened with " "use_zarr_fill_value_as_mask=True" ) - assert masked.mask[0, 0], "nodata corner cell must be masked" - assert not masked.mask[-1, -1], "valid cell must not be masked" + mask = masked.mask + assert isinstance(mask, np.ndarray), "mask must be an array, not a scalar" + assert mask[0, 0], "nodata corner cell must be masked" + assert not mask[-1, -1], "valid cell must not be masked" finally: reopened.close() diff --git a/tests/test_cli_convert_routing.py b/tests/test_cli_convert_routing.py new file mode 100644 index 00000000..811fe00e --- /dev/null +++ b/tests/test_cli_convert_routing.py @@ -0,0 +1,139 @@ +""" +In-process tests for the convert command's Sentinel-2 auto-detection and routing. + +The e2e tests in test_cli_e2e.py drive the CLI through subprocesses; these tests +call ``convert_command`` directly (with the converters stubbed out) so the +routing logic itself is exercised in-process. +""" + +import argparse +from pathlib import Path +from typing import Any + +import numpy as np +import pytest +import xarray as xr + +from eopf_geozarr import cli + + +def _convert_args(input_path: str, output_path: str, **overrides: Any) -> argparse.Namespace: + """Build a Namespace mirroring the convert subcommand's defaults.""" + ns = argparse.Namespace( + input_path=input_path, + output_path=output_path, + groups=["/measurements/reflectance/r10m"], + spatial_chunk=4096, + min_dimension=256, + max_retries=3, + crs_groups=None, + gcp_group=None, + verbose=False, + dask_cluster=False, + enable_sharding=False, + no_s2_optimized=False, + ) + for key, value in overrides.items(): + setattr(ns, key, value) + return ns + + +@pytest.fixture +def plain_zarr_input(tmp_path: Path) -> Path: + """A minimal non-Sentinel-2 zarr store.""" + path = tmp_path / "plain_input.zarr" + ds = xr.Dataset( + {"temperature": (["y", "x"], np.zeros((4, 4)))}, + coords={"x": ("x", np.arange(4.0)), "y": ("y", np.arange(4.0))}, + ) + ds.to_zarr(path, zarr_format=3) + return path + + +def test_is_sentinel2_input_true(s2_group_example: Path) -> None: + """A real Sentinel-2 layout is detected.""" + dt = xr.open_datatree(str(s2_group_example), engine="zarr") + assert cli._is_sentinel2_input(dt) is True + + +def test_is_sentinel2_input_false(plain_zarr_input: Path) -> None: + """A plain zarr store is not detected as Sentinel-2 (and never raises).""" + dt = xr.open_datatree(str(plain_zarr_input), engine="zarr") + assert cli._is_sentinel2_input(dt) is False + + +def test_is_sentinel2_input_swallow_errors() -> None: + """Detection failures (e.g. in-memory datatree with no store) mean 'not S2'.""" + dt = xr.DataTree(xr.Dataset({"a": (["y", "x"], np.zeros((2, 2)))})) + assert cli._is_sentinel2_input(dt) is False + + +@pytest.fixture +def converter_spy(monkeypatch: pytest.MonkeyPatch) -> dict[str, dict[str, Any]]: + """Stub out both converters, recording which one convert_command dispatches to.""" + calls: dict[str, dict[str, Any]] = {} + + def fake_s2(**kwargs: Any) -> xr.DataTree: + calls["s2_optimized"] = kwargs + return xr.DataTree() + + def fake_generic(**kwargs: Any) -> xr.DataTree: + calls["generic"] = kwargs + return xr.DataTree() + + monkeypatch.setattr(cli, "convert_s2_optimized", fake_s2) + monkeypatch.setattr(cli, "create_geozarr_dataset", fake_generic) + return calls + + +def test_convert_command_routes_s2_to_optimized( + s2_group_example: Path, + tmp_path: Path, + converter_spy: dict[str, dict[str, Any]], +) -> None: + """Sentinel-2 inputs are auto-routed to the optimized converter.""" + args = _convert_args(str(s2_group_example), str(tmp_path / "out.zarr")) + cli.convert_command(args) + + assert "s2_optimized" in calls_or_fail(converter_spy) + assert "generic" not in converter_spy + assert converter_spy["s2_optimized"]["keep_scale_offset"] is False + + +def test_convert_command_no_s2_optimized_forces_generic( + s2_group_example: Path, + tmp_path: Path, + converter_spy: dict[str, dict[str, Any]], +) -> None: + """--no-s2-optimized sends Sentinel-2 inputs down the generic path.""" + args = _convert_args( + str(s2_group_example), + str(tmp_path / "out.zarr"), + no_s2_optimized=True, + crs_groups=["/conditions/geometry"], + ) + cli.convert_command(args) + + assert "generic" in calls_or_fail(converter_spy) + assert "s2_optimized" not in converter_spy + assert converter_spy["generic"]["crs_groups"] == ["/conditions/geometry"] + + +def test_convert_command_routes_non_s2_to_generic( + plain_zarr_input: Path, + tmp_path: Path, + converter_spy: dict[str, dict[str, Any]], +) -> None: + """Non-Sentinel-2 inputs use the generic converter.""" + args = _convert_args(str(plain_zarr_input), str(tmp_path / "out.zarr"), groups=["/"]) + cli.convert_command(args) + + assert "generic" in calls_or_fail(converter_spy) + assert "s2_optimized" not in converter_spy + + +def calls_or_fail(calls: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]: + """Fail loudly if convert_command dispatched to neither converter.""" + if not calls: + pytest.fail("convert_command did not call any converter (it likely errored early)") + return calls diff --git a/tests/test_cli_e2e.py b/tests/test_cli_e2e.py index 6b11b120..8b27b3f6 100644 --- a/tests/test_cli_e2e.py +++ b/tests/test_cli_e2e.py @@ -140,7 +140,7 @@ def test_cli_convert_real_sentinel2_data(s2_group_example: Path, tmp_path: Path) GroupSpec.from_zarr(zarr.open_group(output_path)).model_dump() ) assert expected_structure_json == observed_structure_json, view_json_diff( - expected_structure_json, observed_structure_json + dict(expected_structure_json), dict(observed_structure_json) ) @@ -206,12 +206,14 @@ def test_cli_crs_groups_option() -> None: assert "Groups that need CRS information added" in result.stdout, "Help text should be present" -def test_cli_convert_with_crs_groups(s2_group_example, tmp_path: Path) -> None: +def test_cli_convert_with_crs_groups(s2_group_example: Path, tmp_path: Path) -> None: """ Test CLI conversion with --crs-groups option using real Sentinel-2 data. This test verifies that the --crs-groups option works correctly and - processes the specified groups for CRS enhancement. + processes the specified groups for CRS enhancement. It passes + --no-s2-optimized so the Sentinel-2 input goes through the generic + conversion path (the auto-detected optimized path ignores --crs-groups). """ # Dataset from the notebook @@ -242,6 +244,7 @@ def test_cli_convert_with_crs_groups(s2_group_example, tmp_path: Path) -> None: "256", "--max-retries", "3", + "--no-s2-optimized", "--verbose", ] diff --git a/tests/test_convention_attrs.py b/tests/test_convention_attrs.py new file mode 100644 index 00000000..f3ddf576 --- /dev/null +++ b/tests/test_convention_attrs.py @@ -0,0 +1,142 @@ +"""Tests for the zarr-cm convention-attribute helpers in conversion.utils.""" + +from __future__ import annotations + +from typing import cast + +import pytest +from pyproj import CRS +from zarr_cm import geo_proj +from zarr_cm import multiscales as multiscales_cm +from zarr_cm import spatial as spatial_cm + +from eopf_geozarr.conversion.utils import ( + build_convention_attrs, + proj_attrs_for_crs, +) + + +def test_proj_attrs_for_crs_epsg() -> None: + """A CRS with an EPSG code yields proj:code.""" + crs = CRS.from_epsg(32632) + assert proj_attrs_for_crs(crs) == {"proj:code": "EPSG:32632"} + + +def test_proj_attrs_for_crs_wkt_fallback() -> None: + """A CRS without an EPSG code falls back to proj:wkt2.""" + # A bare WKT-defined CRS with no authority code. + crs = CRS.from_wkt(CRS.from_epsg(4326).to_wkt()) + out = proj_attrs_for_crs(crs) + # from_wkt of an EPSG CRS still resolves an epsg in most pyproj versions, so + # accept either, but the key must be one of the two proj CRS keys. + assert set(out) <= {"proj:code", "proj:wkt2"} + assert len(out) == 1 + + +def test_proj_attrs_for_crs_none() -> None: + """No CRS yields an empty dict (no proj keys).""" + assert proj_attrs_for_crs(None) == {} + + +def test_build_convention_attrs_data_and_cmos() -> None: + """The helper emits spatial+proj data keys plus their CMOs, in order.""" + bbox = [300000.0, 4990200.0, 409800.0, 5100000.0] + out = build_convention_attrs( + spatial={ + "spatial:dimensions": ["y", "x"], + "spatial:bbox": bbox, + "spatial:registration": "pixel", + }, + crs=CRS.from_epsg(32632), + ) + data: dict[str, object] = dict(out) + assert data["spatial:dimensions"] == ["y", "x"] + assert data["spatial:bbox"] == bbox + assert data["spatial:registration"] == "pixel" + assert data["proj:code"] == "EPSG:32632" + conventions = out.get("zarr_conventions") + assert conventions is not None + names = [c.get("name") for c in conventions] + assert names == [spatial_cm.CMO.get("name"), geo_proj.CMO.get("name")] + + +def test_build_convention_attrs_matches_handwritten() -> None: + """Output is byte-equivalent to the previous hand-assembled dict.""" + bbox = [300000.0, 4990200.0, 409800.0, 5100000.0] + hand: dict[str, object] = { + "spatial:dimensions": ["y", "x"], + "spatial:bbox": bbox, + "spatial:registration": "pixel", + "proj:code": "EPSG:32632", + } + out = build_convention_attrs( + spatial={ + "spatial:dimensions": ["y", "x"], + "spatial:bbox": bbox, + "spatial:registration": "pixel", + }, + crs=CRS.from_epsg(32632), + ) + data = {k: v for k, v in out.items() if k != "zarr_conventions"} + assert data == hand + + +def test_build_convention_attrs_validates() -> None: + """Invalid spatial data is rejected by zarr-cm validation.""" + with pytest.raises(ValueError, match="spatial:dimensions"): + build_convention_attrs( + # missing required dimensions — exercises runtime validation + spatial=cast("spatial_cm.SpatialAttrs", {"spatial:registration": "pixel"}), + crs=CRS.from_epsg(32632), + ) + + +def test_build_convention_attrs_with_multiscales() -> None: + """With multiscales, CMOs are ordered [multiscales, spatial, proj].""" + out = build_convention_attrs( + multiscales=cast( + "multiscales_cm.MultiscalesAttrs", + { + "layout": [ + {"asset": "r10m", "spatial:shape": [10980, 10980]}, + { + "asset": "r20m", + "derived_from": "r10m", + "transform": {"scale": [2.0, 2.0], "translation": [0.0, 0.0]}, + "spatial:shape": [5490, 5490], + }, + ], + "resampling_method": "average", + }, + ), + spatial={"spatial:dimensions": ["y", "x"]}, + crs=CRS.from_epsg(32632), + ) + conventions = out.get("zarr_conventions") + assert conventions is not None + names = [c.get("name") for c in conventions] + assert names == [ + multiscales_cm.CMO.get("name"), + spatial_cm.CMO.get("name"), + geo_proj.CMO.get("name"), + ] + # extra layout keys (spatial:shape) survive the round-trip + multiscales = out.get("multiscales") + assert multiscales is not None + layout = multiscales["layout"] + assert isinstance(layout, list) + first_layout: dict[str, object] = dict(layout[0]) + assert first_layout["spatial:shape"] == [10980, 10980] + + +def test_build_convention_attrs_multiscales_validation() -> None: + """zarr-cm rejects a layout entry with derived_from but no transform.""" + with pytest.raises(ValueError, match="transform"): + build_convention_attrs( + multiscales={ + "layout": [{"asset": "r20m", "derived_from": "r10m"}], # no transform + "resampling_method": "average", + }, + spatial={"spatial:dimensions": ["y", "x"]}, + crs=CRS.from_epsg(32632), + ) diff --git a/tests/test_data_api/conftest.py b/tests/test_data_api/conftest.py index be567726..03537803 100644 --- a/tests/test_data_api/conftest.py +++ b/tests/test_data_api/conftest.py @@ -5,13 +5,9 @@ import re from collections.abc import Mapping from pathlib import Path -from typing import TYPE_CHECKING import pytest -if TYPE_CHECKING: - from typing import Any - def extract_json_code_blocks( markdown_content: str, @@ -53,7 +49,8 @@ def extract_json_code_blocks( end_line: int = i # Line with closing ``` raw_json: str = "\n".join(json_lines) - parsed_json: Any = json.loads(raw_json) + parsed_json: object = json.loads(raw_json) + assert isinstance(parsed_json, dict) code_blocks[(start_line + 1, end_line)] = parsed_json i += 1 diff --git a/tests/test_data_api/test_geoproj.py b/tests/test_data_api/test_geoproj.py index 5949099c..c9f734ce 100644 --- a/tests/test_data_api/test_geoproj.py +++ b/tests/test_data_api/test_geoproj.py @@ -14,7 +14,7 @@ class TestProj: def test_proj_with_epsg_code(self) -> None: """Test creation with EPSG code.""" - proj = Proj(**{"proj:code": "EPSG:4326"}) + proj = Proj.model_validate({"proj:code": "EPSG:4326"}) assert proj.code == "EPSG:4326" assert proj.wkt2 is None @@ -23,7 +23,7 @@ def test_proj_with_epsg_code(self) -> None: def test_proj_with_wkt2(self) -> None: """Test creation with WKT2 string.""" wkt2_example = 'GEOGCRS["WGS 84",DATUM["World Geodetic System 1984"]]' - proj = Proj(**{"proj:wkt2": wkt2_example}) + proj = Proj.model_validate({"proj:wkt2": wkt2_example}) assert proj.wkt2 == wkt2_example assert proj.code is None @@ -36,7 +36,7 @@ def test_proj_with_projjson(self) -> None: "type": "GeographicCRS", "name": "WGS 84", } - proj = Proj(**{"proj:projjson": projjson_data}) + proj = Proj.model_validate({"proj:projjson": projjson_data}) assert proj.projjson is not None assert proj.code is None @@ -45,7 +45,7 @@ def test_proj_with_projjson(self) -> None: def test_proj_validation_error_no_crs(self) -> None: """Test that missing all CRS fields raises ValidationError.""" with pytest.raises(ValidationError) as exc_info: - Proj() + Proj() # pyright: ignore[reportCallIssue] # no-args construction tests the validation error assert "At least one of proj:code, proj:wkt2, or proj:projjson must be provided" in str( exc_info.value @@ -54,7 +54,7 @@ def test_proj_validation_error_no_crs(self) -> None: def test_proj_multiple_crs_fields(self) -> None: """Test that multiple CRS fields can be provided.""" wkt2_example = 'GEOGCRS["WGS 84",DATUM["World Geodetic System 1984"]]' - proj = Proj(**{"proj:code": "EPSG:4326", "proj:wkt2": wkt2_example}) + proj = Proj.model_validate({"proj:code": "EPSG:4326", "proj:wkt2": wkt2_example}) assert proj.code == "EPSG:4326" assert proj.wkt2 == wkt2_example @@ -62,7 +62,7 @@ def test_proj_multiple_crs_fields(self) -> None: def test_proj_serialization_by_alias(self) -> None: """Test that serialization uses aliases (proj: prefixes).""" - proj = Proj(**{"proj:code": "EPSG:32633"}) + proj = Proj.model_validate({"proj:code": "EPSG:32633"}) result = proj.model_dump() # Should serialize with proj: prefix @@ -74,7 +74,7 @@ def test_proj_serialization_by_alias(self) -> None: def test_proj_none_fields_excluded(self) -> None: """Test that None fields are excluded from serialization.""" - proj = Proj(**{"proj:code": "EPSG:4326"}) + proj = Proj.model_validate({"proj:code": "EPSG:4326"}) result = proj.model_dump() # None fields should be excluded @@ -86,8 +86,8 @@ def test_proj_none_fields_excluded(self) -> None: def test_proj_extra_fields_allowed(self) -> None: """Test that extra fields are allowed.""" - proj = Proj( - **{ + proj = Proj.model_validate( + { "proj:code": "EPSG:4326", "custom_field": "custom_value", "proj:custom": "also_allowed", @@ -104,7 +104,7 @@ def test_proj_roundtrip_serialization(self) -> None: original_data = {"proj:code": "EPSG:32633", "proj:wkt2": 'PROJCRS["WGS 84 / UTM zone 33N"]'} # Create model, serialize, then recreate - proj1 = Proj(**original_data) + proj1 = Proj.model_validate(original_data) serialized = proj1.model_dump() proj2 = Proj(**serialized) @@ -124,8 +124,8 @@ def test_geoproj_is_proj_alias(self) -> None: def test_geoproj_functionality(self) -> None: """Test that GeoProj works exactly like Proj.""" # Create using both classes - proj_instance = Proj(**{"proj:code": "EPSG:4326"}) - geoproj_instance = GeoProj(**{"proj:code": "EPSG:4326"}) + proj_instance = Proj.model_validate({"proj:code": "EPSG:4326"}) + geoproj_instance = GeoProj.model_validate({"proj:code": "EPSG:4326"}) # Should be instances of the same class assert type(proj_instance) is type(geoproj_instance) diff --git a/tests/test_data_api/test_geozarr/test_common.py b/tests/test_data_api/test_geozarr/test_common.py index fa54ffb8..e7286726 100644 --- a/tests/test_data_api/test_geozarr/test_common.py +++ b/tests/test_data_api/test_geozarr/test_common.py @@ -1,11 +1,14 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any +from collections.abc import Mapping +from typing import TYPE_CHECKING import numpy as np import pytest from pydantic_zarr.core import tuplify_json +from pydantic_zarr.v2 import AnyGroupSpec as AnyGroupSpec_V2 from pydantic_zarr.v2 import GroupSpec as GroupSpec_V2 +from pydantic_zarr.v3 import AnyGroupSpec as AnyGroupSpec_V3 from pydantic_zarr.v3 import GroupSpec as GroupSpec_V3 from eopf_geozarr.data_api.geozarr.common import ( @@ -33,7 +36,7 @@ DataArray_V3.from_array(np.arange(10), dimension_names=("time",)), ], ) -def test_datarraylike(obj: DataArray_V2 | DataArray_V3) -> None: +def test_datarraylike(obj: object) -> None: """ Test that the DataArrayLike protocol works correctly """ @@ -41,7 +44,7 @@ def test_datarraylike(obj: DataArray_V2 | DataArray_V3) -> None: @pytest.mark.parametrize("obj", [GroupSpec_V2(attributes={}), GroupSpec_V3(attributes={})]) -def test_grouplike(obj: GroupSpec_V3[Any, Any] | GroupSpec_V2[Any, Any]) -> None: +def test_grouplike(obj: AnyGroupSpec_V3 | AnyGroupSpec_V2) -> None: """ Test that the GroupLike protocol works correctly """ @@ -80,9 +83,12 @@ def test_multiscales_round_trip(s2_optimized_geozarr_group_example: zarr.Group) """ Ensure that we can round-trip multiscale metadata through the `Multiscales` model. """ - source_untyped = GroupSpec_V3.from_zarr(s2_optimized_geozarr_group_example) + source_untyped: AnyGroupSpec_V3 = GroupSpec_V3.from_zarr(s2_optimized_geozarr_group_example) flat = source_untyped.to_flat() - meta = flat["/measurements/reflectance"].attributes["multiscales"] + attributes = flat["/measurements/reflectance"].attributes + assert isinstance(attributes, Mapping) + meta = attributes["multiscales"] + assert isinstance(meta, Mapping) # pull out the multiscales keys, ignore extra submodel = tuplify_json({k: meta[k] for k in ZCMMultiscales.model_fields if k in meta}) assert ZCMMultiscales(**submodel).model_dump() == submodel @@ -95,11 +101,11 @@ def test_projattrs_crs_required() -> None: with pytest.raises( ValueError, match=r"One of 'code', 'wkt2', or 'projjson' must be provided\." ): - ProjAttrs() + ProjAttrs() # pyright: ignore[reportCallIssue] # no-args construction tests the validation error def test_projattrs_json_examples( - proj_attrs_examples: dict[tuple[int, int], dict[str, Any]], + proj_attrs_examples: dict[tuple[int, int], dict[str, object]], ) -> None: """ Test that proj attributes in the JSON examples of the proj extension README are valid. @@ -108,19 +114,22 @@ def test_projattrs_json_examples( for json_block in proj_attrs_examples.values(): # Check if this JSON block contains geo.proj attributes - if "attributes" in json_block and isinstance(json_block["attributes"], dict): - geo: Any = json_block["attributes"].get("geo") + attributes = json_block.get("attributes") + if isinstance(attributes, dict): + geo: object = attributes.get("geo") if geo and isinstance(geo, dict) and "proj" in geo: proj_examples_found += 1 - proj_data: dict[str, Any] = geo["proj"] + proj_data_obj: object = geo["proj"] + assert isinstance(proj_data_obj, dict) + proj_data: dict[str, object] = proj_data_obj # Validate that ProjAttrs can parse this data - proj_attrs: ProjAttrs = ProjAttrs(**proj_data) + proj_attrs: ProjAttrs = ProjAttrs.model_validate(proj_data) # Verify that all fields from the original data are present in the model for key, value in proj_data.items(): if value is not None: - model_value: Any = getattr(proj_attrs, key) + model_value: object = getattr(proj_attrs, key) # Handle tuple/list comparison for transform and bbox fields if isinstance(value, list) and isinstance(model_value, tuple): assert tuple(value) == model_value, f"Field {key} mismatch" diff --git a/tests/test_data_api/test_geozarr/test_multiscales/test_geozarr.py b/tests/test_data_api/test_geozarr/test_multiscales/test_geozarr.py index a9c9418c..3391d796 100644 --- a/tests/test_data_api/test_geozarr/test_multiscales/test_geozarr.py +++ b/tests/test_data_api/test_geozarr/test_multiscales/test_geozarr.py @@ -1,7 +1,8 @@ -from typing import Any, Literal +from typing import Literal import pytest from pydantic.experimental.missing_sentinel import MISSING +from zarr_cm import ConventionMetadataObject from zarr_cm import multiscales as multiscales_cm from eopf_geozarr.data_api.geozarr.multiscales import tms, zcm @@ -18,13 +19,13 @@ def test_multiscale_group_attrs(multiscale_flavor: set[Literal["zcm", "tms"]]) - """ zcm_meta: dict[str, object] = {} tms_meta: dict[str, object] = {} - zarr_conventions_meta: MISSING | tuple[Any, ...] = MISSING + zarr_conventions_meta: tuple[ConventionMetadataObject, ...] | MISSING = MISSING if "zcm" in multiscale_flavor: layout = ( zcm.ScaleLevel( asset="level_0", - transform={"scale": (1.0, 1.0), "translation": (0.0, 0.0)}, + transform=zcm.Transform(scale=(1.0, 1.0), translation=(0.0, 0.0)), ), ) zcm_meta = zcm.Multiscales(layout=layout, resampling_method="nearest").model_dump() @@ -58,13 +59,17 @@ def test_multiscale_group_attrs(multiscale_flavor: set[Literal["zcm", "tms"]]) - ) }, ).model_dump() - multiscale_meta = MultiscaleMeta(**{**zcm_meta, **tms_meta}) + multiscale_meta = MultiscaleMeta.model_validate({**zcm_meta, **tms_meta}) multiscale_group_attrs = MultiscaleGroupAttrs( zarr_conventions=zarr_conventions_meta, multiscales=multiscale_meta ) if "zcm" in multiscale_flavor: assert "zcm" in multiscale_group_attrs.multiscale_meta - assert multiscale_group_attrs.multiscale_meta["zcm"] == zcm.Multiscales(**zcm_meta) + assert multiscale_group_attrs.multiscale_meta["zcm"] == zcm.Multiscales.model_validate( + zcm_meta + ) if "tms" in multiscale_flavor: assert "tms" in multiscale_group_attrs.multiscale_meta - assert multiscale_group_attrs.multiscale_meta["tms"] == tms.Multiscales(**tms_meta) + assert multiscale_group_attrs.multiscale_meta["tms"] == tms.Multiscales.model_validate( + tms_meta + ) diff --git a/tests/test_data_api/test_geozarr/test_multiscales/test_zcm.py b/tests/test_data_api/test_geozarr/test_multiscales/test_zcm.py index 32d3dc4c..52be4251 100644 --- a/tests/test_data_api/test_geozarr/test_multiscales/test_zcm.py +++ b/tests/test_data_api/test_geozarr/test_multiscales/test_zcm.py @@ -30,7 +30,7 @@ def test_scale_level_from_group() -> None: """ meta = {"group": "1", "from_group": "0"} with pytest.raises(ValidationError): - ScaleLevel(**meta) + ScaleLevel.model_validate(meta) def test_scalelevel_json() -> None: @@ -46,4 +46,4 @@ def test_scalelevel_json() -> None: }, "resampling_method": "nearest", } - assert ScaleLevel(**x).model_dump() == x + assert ScaleLevel.model_validate(x).model_dump() == x diff --git a/tests/test_data_api/test_projjson.py b/tests/test_data_api/test_projjson.py index ada54398..ae2214f8 100644 --- a/tests/test_data_api/test_projjson.py +++ b/tests/test_data_api/test_projjson.py @@ -7,8 +7,6 @@ from __future__ import annotations -from typing import Any - import pytest from pydantic import ValidationError @@ -39,51 +37,52 @@ class TestBasicModels: def test_id_model(self) -> None: """Test Id model validation""" # Valid ID with required fields - id_data: dict[str, Any] = {"authority": "EPSG", "code": 4326} - id_obj: Id = Id(**id_data) + id_data: dict[str, object] = {"authority": "EPSG", "code": 4326} + id_obj: Id = Id.model_validate(id_data) assert id_obj.authority == "EPSG" assert id_obj.code == 4326 # ID with string code - id_data_str: dict[str, Any] = {"authority": "EPSG", "code": "4326"} - id_obj_str: Id = Id(**id_data_str) + id_data_str: dict[str, object] = {"authority": "EPSG", "code": "4326"} + id_obj_str: Id = Id.model_validate(id_data_str) assert id_obj_str.code == "4326" # ID with optional fields - id_full: dict[str, Any] = { + id_full: dict[str, object] = { "authority": "EPSG", "code": 4326, "version": "10.095", "authority_citation": "EPSG Geodetic Parameter Dataset", "uri": "urn:ogc:def:crs:EPSG::4326", } - id_obj_full: Id = Id(**id_full) + id_obj_full: Id = Id.model_validate(id_full) assert id_obj_full.version == "10.095" assert id_obj_full.uri == "urn:ogc:def:crs:EPSG::4326" # Missing required field should raise ValidationError with pytest.raises(ValidationError): - Id(authority="EPSG") # missing code + Id(authority="EPSG") # type: ignore[call-arg] # missing code (intentional) def test_unit_model(self) -> None: """Test Unit model validation""" - unit_data: dict[str, Any] = { + unit_data: dict[str, object] = { "type": "Unit", "name": "metre", "conversion_factor": 1.0, } - unit: Unit = Unit(**unit_data) + unit: Unit = Unit.model_validate(unit_data) assert unit.name == "metre" assert unit.conversion_factor == 1.0 # With ID - unit_with_id: dict[str, Any] = { + unit_with_id: dict[str, object] = { "type": "Unit", "name": "degree", "conversion_factor": 0.017453292519943295, "id": {"authority": "EPSG", "code": 9122}, } - unit = Unit(**unit_with_id) + unit = Unit.model_validate(unit_with_id) + assert unit.id is not None assert unit.id.authority == "EPSG" assert unit.id.code == 9122 @@ -101,17 +100,18 @@ def test_bbox_model(self) -> None: # Missing required field with pytest.raises(ValidationError): - BBox(east_longitude=180.0, west_longitude=-180.0) # missing latitude fields + # missing latitude fields (intentional) + BBox(east_longitude=180.0, west_longitude=-180.0) # type: ignore[call-arg] def test_axis_model(self) -> None: """Test Axis model validation""" - axis_data: dict[str, str] = { + axis_data: dict[str, object] = { "type": "Axis", "name": "Geodetic latitude", "abbreviation": "Lat", "direction": "north", } - axis: Axis = Axis(**axis_data) + axis: Axis = Axis.model_validate(axis_data) assert axis.name == "Geodetic latitude" assert axis.direction == "north" @@ -121,7 +121,7 @@ def test_axis_model(self) -> None: type="Axis", name="Invalid", abbreviation="Inv", - direction="invalid_direction", + direction="invalid_direction", # type: ignore[arg-type] # invalid direction (intentional) ) @@ -130,35 +130,35 @@ class TestEllipsoidModel: def test_ellipsoid_with_semi_axes(self) -> None: """Test ellipsoid with semi-major and semi-minor axes""" - ellipsoid_data: dict[str, Any] = { + ellipsoid_data: dict[str, object] = { "type": "Ellipsoid", "name": "WGS 84", "semi_major_axis": 6378137.0, "semi_minor_axis": 6356752.314245179, } - ellipsoid: Ellipsoid = Ellipsoid(**ellipsoid_data) + ellipsoid: Ellipsoid = Ellipsoid.model_validate(ellipsoid_data) assert ellipsoid.name == "WGS 84" assert ellipsoid.semi_major_axis == 6378137.0 def test_ellipsoid_with_inverse_flattening(self) -> None: """Test ellipsoid with inverse flattening""" - ellipsoid_data: dict[str, Any] = { + ellipsoid_data: dict[str, object] = { "type": "Ellipsoid", "name": "WGS 84", "semi_major_axis": 6378137.0, "inverse_flattening": 298.257223563, } - ellipsoid: Ellipsoid = Ellipsoid(**ellipsoid_data) + ellipsoid: Ellipsoid = Ellipsoid.model_validate(ellipsoid_data) assert ellipsoid.inverse_flattening == 298.257223563 def test_ellipsoid_sphere(self) -> None: """Test spherical ellipsoid (equal radii)""" - ellipsoid_data: dict[str, Any] = { + ellipsoid_data: dict[str, object] = { "type": "Ellipsoid", "name": "Sphere", "radius": 6371000.0, } - ellipsoid: Ellipsoid = Ellipsoid(**ellipsoid_data) + ellipsoid: Ellipsoid = Ellipsoid.model_validate(ellipsoid_data) assert ellipsoid.radius == 6371000.0 @@ -167,7 +167,7 @@ class TestCoordinateSystemModel: def test_ellipsoidal_coordinate_system(self) -> None: """Test ellipsoidal coordinate system""" - cs_data: dict[str, Any] = { + cs_data: dict[str, object] = { "type": "CoordinateSystem", "subtype": "ellipsoidal", "axis": [ @@ -195,14 +195,14 @@ def test_ellipsoidal_coordinate_system(self) -> None: }, ], } - cs: CoordinateSystem = CoordinateSystem(**cs_data) + cs: CoordinateSystem = CoordinateSystem.model_validate(cs_data) assert cs.subtype == "ellipsoidal" assert len(cs.axis) == 2 assert cs.axis[0].name == "Geodetic latitude" def test_cartesian_coordinate_system(self) -> None: """Test Cartesian coordinate system""" - cs_data: dict[str, Any] = { + cs_data: dict[str, object] = { "type": "CoordinateSystem", "subtype": "Cartesian", "axis": [ @@ -222,7 +222,7 @@ def test_cartesian_coordinate_system(self) -> None: }, ], } - cs: CoordinateSystem = CoordinateSystem(**cs_data) + cs: CoordinateSystem = CoordinateSystem.model_validate(cs_data) assert cs.subtype == "Cartesian" assert cs.axis[0].direction == "east" assert cs.axis[1].direction == "north" @@ -233,7 +233,7 @@ class TestCRSModels: def test_geodetic_crs_wgs84(self) -> None: """Test WGS 84 geodetic CRS""" - wgs84_data: dict[str, Any] = { + wgs84_data: dict[str, object] = { "type": "GeographicCRS", "name": "WGS 84", "datum": { @@ -276,14 +276,16 @@ def test_geodetic_crs_wgs84(self) -> None: }, "id": {"authority": "EPSG", "code": 4326}, } - crs: GeodeticCRS = GeodeticCRS(**wgs84_data) + crs: GeodeticCRS = GeodeticCRS.model_validate(wgs84_data) assert crs.name == "WGS 84" + assert crs.datum is not None assert crs.datum.name == "World Geodetic System 1984" + assert crs.id is not None assert crs.id.code == 4326 def test_projected_crs_utm(self) -> None: """Test UTM projected CRS""" - utm_data: dict[str, Any] = { + utm_data: dict[str, object] = { "type": "ProjectedCRS", "name": "WGS 84 / UTM zone 33N", "base_crs": { @@ -356,14 +358,14 @@ def test_projected_crs_utm(self) -> None: ], }, } - crs: ProjectedCRS = ProjectedCRS(**utm_data) + crs: ProjectedCRS = ProjectedCRS.model_validate(utm_data) assert crs.name == "WGS 84 / UTM zone 33N" assert crs.base_crs.name == "WGS 84" assert crs.conversion.name == "UTM zone 33N" def test_compound_crs(self) -> None: """Test compound CRS with horizontal and vertical components""" - compound_data: dict[str, Any] = { + compound_data: dict[str, object] = { "type": "CompoundCRS", "name": "WGS 84 + EGM96 height", "components": [ @@ -388,11 +390,15 @@ def test_compound_crs(self) -> None: }, ], } - crs: CompoundCRS = CompoundCRS(**compound_data) + crs: CompoundCRS = CompoundCRS.model_validate(compound_data) assert crs.name == "WGS 84 + EGM96 height" assert len(crs.components) == 2 - assert crs.components[0].name == "WGS 84" - assert crs.components[1].name == "EGM96 height" + component_0 = crs.components[0] + component_1 = crs.components[1] + assert isinstance(component_0, GeodeticCRS) + assert isinstance(component_1, VerticalCRS) + assert component_0.name == "WGS 84" + assert component_1.name == "EGM96 height" class TestDatumEnsemble: @@ -400,7 +406,7 @@ class TestDatumEnsemble: def test_datum_ensemble_creation(self) -> None: """Test creation of datum ensemble""" - ensemble_data: dict[str, Any] = { + ensemble_data: dict[str, object] = { "type": "DatumEnsemble", "name": "World Geodetic System 1984 ensemble", "members": [ @@ -416,7 +422,7 @@ def test_datum_ensemble_creation(self) -> None: }, "accuracy": "2.0", } - ensemble: DatumEnsemble = DatumEnsemble(**ensemble_data) + ensemble: DatumEnsemble = DatumEnsemble.model_validate(ensemble_data) assert ensemble.name == "World Geodetic System 1984 ensemble" assert len(ensemble.members) == 3 assert ensemble.accuracy == "2.0" @@ -427,7 +433,7 @@ class TestOperations: def test_coordinate_metadata(self) -> None: """Test coordinate metadata""" - metadata_data: dict[str, Any] = { + metadata_data: dict[str, object] = { "type": "CoordinateMetadata", "crs": { "type": "GeographicCRS", @@ -445,13 +451,14 @@ def test_coordinate_metadata(self) -> None: }, "coordinateEpoch": 2020.0, } - metadata: CoordinateMetadata = CoordinateMetadata(**metadata_data) + metadata: CoordinateMetadata = CoordinateMetadata.model_validate(metadata_data) assert metadata.coordinateEpoch == 2020.0 + assert isinstance(metadata.crs, GeodeticCRS) assert metadata.crs.name == "WGS 84" def test_single_operation(self) -> None: """Test single operation (transformation)""" - operation_data: dict[str, Any] = { + operation_data: dict[str, object] = { "type": "Transformation", "name": "NAD27 to NAD83 (1)", "method": {"type": "OperationMethod", "name": "NADCON"}, @@ -469,9 +476,10 @@ def test_single_operation(self) -> None: ], "accuracy": "0.15", } - operation: SingleOperation = SingleOperation(**operation_data) + operation: SingleOperation = SingleOperation.model_validate(operation_data) assert operation.name == "NAD27 to NAD83 (1)" assert operation.accuracy == "0.15" + assert operation.parameters is not None assert len(operation.parameters) == 2 @@ -480,27 +488,28 @@ class TestValidationEdgeCases: def test_invalid_crs_type(self) -> None: """Test invalid CRS type raises ValidationError""" - invalid_data: dict[str, Any] = { + invalid_data: dict[str, object] = { "type": "InvalidCRS", # Invalid type "name": "Invalid CRS", } with pytest.raises(ValidationError): - GeodeticCRS(**invalid_data) + GeodeticCRS(**invalid_data) # type: ignore[arg-type] # building model from dict[str, object] (intentional) def test_missing_required_fields(self) -> None: """Test missing required fields raise ValidationError""" # Missing name for CRS with pytest.raises(ValidationError): - GeodeticCRS(type="GeographicCRS") + GeodeticCRS(type="GeographicCRS") # type: ignore[call-arg] # missing name (intentional) # Missing ellipsoid for geodetic reference frame with pytest.raises(ValidationError): - GeodeticReferenceFrame(type="GeodeticReferenceFrame", name="Test Datum") + # missing ellipsoid (intentional) + GeodeticReferenceFrame(type="GeodeticReferenceFrame", name="Test Datum") # type: ignore[call-arg] def test_mutually_exclusive_fields(self) -> None: """Test that mutually exclusive fields are properly validated""" # Cannot have both id and ids - invalid_data: dict[str, Any] = { + invalid_data: dict[str, object] = { "type": "Unit", "name": "metre", "conversion_factor": 1.0, @@ -511,27 +520,27 @@ def test_mutually_exclusive_fields(self) -> None: # For now, we'll just ensure the model can be created with either field with pytest.raises(ValidationError): - Unit(**invalid_data) + Unit(**invalid_data) # type: ignore[arg-type] # building model from dict[str, object] (intentional) # Valid with id only - valid_with_id: dict[str, Any] = { + valid_with_id: dict[str, object] = { "type": "Unit", "name": "metre", "conversion_factor": 1.0, "id": {"authority": "EPSG", "code": 9001}, } - unit: Unit = Unit(**valid_with_id) + unit: Unit = Unit.model_validate(valid_with_id) assert unit.id is not None assert unit.ids is None # Valid with ids only - valid_with_ids: dict[str, Any] = { + valid_with_ids: dict[str, object] = { "type": "Unit", "name": "metre", "conversion_factor": 1.0, "ids": [{"authority": "EPSG", "code": 9001}], } - unit = Unit(**valid_with_ids) + unit = Unit.model_validate(valid_with_ids) assert unit.ids is not None assert unit.id is None @@ -542,7 +551,7 @@ class TestSerializationDeserialization: def test_round_trip_serialization(self) -> None: """Test that models can be serialized to JSON and back""" # Create a simple CRS - crs_data: dict[str, Any] = { + crs_data: dict[str, object] = { "type": "GeographicCRS", "name": "WGS 84", "datum": { @@ -558,14 +567,16 @@ def test_round_trip_serialization(self) -> None: } # Create model instance - original_crs: GeodeticCRS = GeodeticCRS(**crs_data) + original_crs: GeodeticCRS = GeodeticCRS.model_validate(crs_data) # Deserialize back to model - json_data: dict[str, Any] = original_crs.model_dump() - reconstructed_crs: GeodeticCRS = GeodeticCRS(**json_data) + json_data: dict[str, object] = original_crs.model_dump() + reconstructed_crs: GeodeticCRS = GeodeticCRS.model_validate(json_data) # Verify they're equivalent assert reconstructed_crs.name == original_crs.name + assert reconstructed_crs.datum is not None + assert original_crs.datum is not None assert reconstructed_crs.datum.name == original_crs.datum.name assert reconstructed_crs.datum.ellipsoid.name == original_crs.datum.ellipsoid.name @@ -574,17 +585,17 @@ def test_projjson_union_type(self) -> None: # Test with different types that should all be valid ProjJSON # Ellipsoid - ellipsoid_data: dict[str, Any] = { + ellipsoid_data: dict[str, object] = { "type": "Ellipsoid", "name": "WGS 84", "semi_major_axis": 6378137.0, "inverse_flattening": 298.257223563, } - ellipsoid: Ellipsoid = Ellipsoid(**ellipsoid_data) + ellipsoid: Ellipsoid = Ellipsoid.model_validate(ellipsoid_data) assert ellipsoid.name == "WGS 84" # CRS - crs_data: dict[str, Any] = { + crs_data: dict[str, object] = { "type": "GeographicCRS", "name": "WGS 84", "datum": { @@ -593,26 +604,26 @@ def test_projjson_union_type(self) -> None: "ellipsoid": ellipsoid_data, }, } - crs: GeodeticCRS = GeodeticCRS(**crs_data) + crs: GeodeticCRS = GeodeticCRS.model_validate(crs_data) assert crs.name == "WGS 84" class TestRoundTripSerialization: """Test round-trip serialization with real PROJ JSON examples.""" - def test_projected_crs_round_trip(self, projected_crs_json: dict[str, Any]) -> None: + def test_projected_crs_round_trip(self, projected_crs_json: dict[str, object]) -> None: """Test round-trip serialization of projected CRS example.""" # Parse JSON to Pydantic model from eopf_geozarr.data_api.geozarr.projjson import ProjectedCRS # Create model from JSON - original_crs: ProjectedCRS = ProjectedCRS(**projected_crs_json) + original_crs: ProjectedCRS = ProjectedCRS.model_validate(projected_crs_json) # Serialize back to dict - serialized: dict[str, Any] = original_crs.model_dump(exclude_none=True) + serialized: dict[str, object] = original_crs.model_dump(exclude_none=True) # Create model from serialized data - round_trip_crs: ProjectedCRS = ProjectedCRS(**serialized) + round_trip_crs: ProjectedCRS = ProjectedCRS.model_validate(serialized) # Verify key properties are preserved assert round_trip_crs.name == original_crs.name @@ -620,88 +631,100 @@ def test_projected_crs_round_trip(self, projected_crs_json: dict[str, Any]) -> N assert round_trip_crs.base_crs.name == original_crs.base_crs.name assert round_trip_crs.conversion.name == original_crs.conversion.name if original_crs.id: + assert round_trip_crs.id is not None assert round_trip_crs.id.authority == original_crs.id.authority assert round_trip_crs.id.code == original_crs.id.code - def test_bound_crs_round_trip(self, bound_crs_json: dict[str, Any]) -> None: + def test_bound_crs_round_trip(self, bound_crs_json: dict[str, object]) -> None: """Test round-trip serialization of bound CRS example.""" from eopf_geozarr.data_api.geozarr.projjson import BoundCRS # Create model from JSON - original_crs: BoundCRS = BoundCRS(**bound_crs_json) + original_crs: BoundCRS = BoundCRS.model_validate(bound_crs_json) # Serialize back to dict - serialized: dict[str, Any] = original_crs.model_dump(exclude_none=True) + serialized: dict[str, object] = original_crs.model_dump(exclude_none=True) # Create model from serialized data - round_trip_crs: BoundCRS = BoundCRS(**serialized) + round_trip_crs: BoundCRS = BoundCRS.model_validate(serialized) # Verify key properties are preserved assert round_trip_crs.type == original_crs.type + # A nested BoundCRS has no "name"; this example's source/target are named CRSs. + assert not isinstance(round_trip_crs.source_crs, BoundCRS) + assert not isinstance(round_trip_crs.target_crs, BoundCRS) + assert not isinstance(original_crs.source_crs, BoundCRS) + assert not isinstance(original_crs.target_crs, BoundCRS) assert round_trip_crs.source_crs.name == original_crs.source_crs.name assert round_trip_crs.target_crs.name == original_crs.target_crs.name assert round_trip_crs.transformation.name == original_crs.transformation.name - def test_compound_crs_round_trip(self, compound_crs_json: dict[str, Any]) -> None: + def test_compound_crs_round_trip(self, compound_crs_json: dict[str, object]) -> None: """Test round-trip serialization of compound CRS example.""" from eopf_geozarr.data_api.geozarr.projjson import CompoundCRS # Create model from JSON - original_crs: CompoundCRS = CompoundCRS(**compound_crs_json) + original_crs: CompoundCRS = CompoundCRS.model_validate(compound_crs_json) # Serialize back to dict - serialized: dict[str, Any] = original_crs.model_dump(exclude_none=True) + serialized: dict[str, object] = original_crs.model_dump(exclude_none=True) # Create model from serialized data - round_trip_crs: CompoundCRS = CompoundCRS(**serialized) + round_trip_crs: CompoundCRS = CompoundCRS.model_validate(serialized) # Verify key properties are preserved assert round_trip_crs.name == original_crs.name assert round_trip_crs.type == original_crs.type assert len(round_trip_crs.components) == len(original_crs.components) for i, component in enumerate(round_trip_crs.components): - assert component.name == original_crs.components[i].name + # Compound components are named CRSs, never a nested BoundCRS. + assert not isinstance(component, BoundCRS) + original_component = original_crs.components[i] + assert not isinstance(original_component, BoundCRS) + assert component.name == original_component.name - def test_datum_ensemble_round_trip(self, datum_ensemble_json: dict[str, Any]) -> None: + def test_datum_ensemble_round_trip(self, datum_ensemble_json: dict[str, object]) -> None: """Test round-trip serialization of datum ensemble example.""" from eopf_geozarr.data_api.geozarr.projjson import GeodeticCRS # Create model from JSON - original_crs: GeodeticCRS = GeodeticCRS(**datum_ensemble_json) + original_crs: GeodeticCRS = GeodeticCRS.model_validate(datum_ensemble_json) # Serialize back to dict - serialized: dict[str, Any] = original_crs.model_dump(exclude_none=True) + serialized: dict[str, object] = original_crs.model_dump(exclude_none=True) # Create model from serialized data - round_trip_crs: GeodeticCRS = GeodeticCRS(**serialized) + round_trip_crs: GeodeticCRS = GeodeticCRS.model_validate(serialized) # Verify key properties are preserved assert round_trip_crs.name == original_crs.name assert round_trip_crs.type == original_crs.type if original_crs.datum_ensemble: + assert round_trip_crs.datum_ensemble is not None assert round_trip_crs.datum_ensemble.name == original_crs.datum_ensemble.name assert len(round_trip_crs.datum_ensemble.members) == len( original_crs.datum_ensemble.members ) - def test_transformation_round_trip(self, transformation_json: dict[str, Any]) -> None: + def test_transformation_round_trip(self, transformation_json: dict[str, object]) -> None: """Test round-trip serialization of transformation example.""" from eopf_geozarr.data_api.geozarr.projjson import SingleOperation # Create model from JSON - original_op: SingleOperation = SingleOperation(**transformation_json) + original_op: SingleOperation = SingleOperation.model_validate(transformation_json) # Serialize back to dict - serialized: dict[str, Any] = original_op.model_dump(exclude_none=True) + serialized: dict[str, object] = original_op.model_dump(exclude_none=True) # Create model from serialized data - round_trip_op: SingleOperation = SingleOperation(**serialized) + round_trip_op: SingleOperation = SingleOperation.model_validate(serialized) # Verify key properties are preserved assert round_trip_op.name == original_op.name assert round_trip_op.type == original_op.type assert round_trip_op.method.name == original_op.method.name if original_op.parameters: + assert round_trip_op.parameters is not None assert len(round_trip_op.parameters) == len(original_op.parameters) def test_all_examples_round_trip(self, projjson_example: dict[str, object]) -> None: @@ -726,6 +749,7 @@ def test_all_examples_round_trip(self, projjson_example: dict[str, object]) -> N # Get the model class based on type obj_type = projjson_example.get("type") + assert isinstance(obj_type, str) model_class = type_mapping[obj_type] diff --git a/tests/test_data_api/test_s1.py b/tests/test_data_api/test_s1.py index 98d9917e..ed0c3a29 100644 --- a/tests/test_data_api/test_s1.py +++ b/tests/test_data_api/test_s1.py @@ -10,12 +10,78 @@ from the markdown files in docs/models/sentinel1.md """ -from eopf_geozarr.data_api.s1 import Sentinel1Root +import inspect +from typing import Any + +import pytest + +import eopf_geozarr.data_api.s1 as s1_module +from eopf_geozarr.data_api.s1 import Sentinel1PolarizationGroup, Sentinel1Root +from eopf_geozarr.pyz.v2 import GroupSpec def test_sentinel1_roundtrip(s1_json_example: dict[str, object]) -> None: """Test that we can round-trip JSON data without loss""" - model1 = Sentinel1Root(**s1_json_example) + model1 = Sentinel1Root.model_validate(s1_json_example) dumped = model1.model_dump() - model2 = Sentinel1Root(**dumped) + model2 = Sentinel1Root.model_validate(dumped) assert model1.model_dump() == model2.model_dump() + + +def _member_accessor_cases() -> list[Any]: + """Collect every generated member-accessor property on the S1 group models. + + The S1 group classes define uniform properties of the shape + ``self.members.get(key)`` + ``raise KeyError(key)`` when absent; identify + them by their source so unrelated properties are not swept in. + """ + cases: list[Any] = [] + for cls_name, cls in inspect.getmembers(s1_module, inspect.isclass): + if cls.__module__ != s1_module.__name__ or not issubclass(cls, GroupSpec): + continue + for prop_name, prop in vars(cls).items(): + if ( + isinstance(prop, property) + and prop.fget is not None + and "raise KeyError" in inspect.getsource(prop.fget) + ): + cases.append(pytest.param(cls, prop_name, id=f"{cls_name}.{prop_name}")) + return cases + + +@pytest.mark.parametrize(("cls", "prop_name"), _member_accessor_cases()) +def test_member_accessor(cls: type[GroupSpec[Any, Any]], prop_name: str) -> None: + """Member accessors return the member when present and raise KeyError when absent.""" + empty = cls.model_construct(members={}) + with pytest.raises(KeyError) as excinfo: + getattr(empty, prop_name) + member_key = excinfo.value.args[0] + + sentinel = object() + populated = cls.model_construct(members={member_key: sentinel}) + assert getattr(populated, prop_name) is sentinel + + +def test_polarization_group_helpers(s1_json_example: dict[str, object]) -> None: + """The root model's polarization lookups find the VH and VV groups.""" + model = Sentinel1Root.model_validate(s1_json_example) + + pols = model.get_polarization_groups() + assert pols + assert all(isinstance(group, Sentinel1PolarizationGroup) for group in pols.values()) + + vh = model.get_vh_group() + assert vh is not None + assert any("VH" in name for name in pols) + + vv = model.get_vv_group() + assert vv is not None + assert any("VV" in name for name in pols) + + +def test_polarization_group_helpers_empty() -> None: + """The polarization lookups return None / empty on a root with no members.""" + empty = Sentinel1Root.model_construct(members={}) + assert empty.get_polarization_groups() == {} + assert empty.get_vh_group() is None + assert empty.get_vv_group() is None diff --git a/tests/test_data_api/test_s2.py b/tests/test_data_api/test_s2.py index a17fa138..ad7c45c7 100644 --- a/tests/test_data_api/test_s2.py +++ b/tests/test_data_api/test_s2.py @@ -15,7 +15,7 @@ def test_sentinel2_roundtrip(s2_json_example: dict[str, object]) -> None: """Test that we can round-trip JSON data without loss""" - model1 = Sentinel2Root(**s2_json_example) + model1 = Sentinel2Root.model_validate(s2_json_example) dumped = model1.model_dump() - model2 = Sentinel2Root(**dumped) + model2 = Sentinel2Root.model_validate(dumped) assert model1.model_dump() == model2.model_dump() diff --git a/tests/test_data_api/test_spatial.py b/tests/test_data_api/test_spatial.py index aa757644..0ee7464f 100644 --- a/tests/test_data_api/test_spatial.py +++ b/tests/test_data_api/test_spatial.py @@ -13,7 +13,8 @@ class TestSpatial: def test_minimal_required_fields(self) -> None: """Test creation with only required fields.""" - spatial = Spatial(**{"spatial:dimensions": ["y", "x"]}) + data: dict[str, object] = {"spatial:dimensions": ["y", "x"]} + spatial = Spatial.model_validate(data) assert spatial.dimensions == ["y", "x"] assert spatial.bbox is None @@ -25,13 +26,13 @@ def test_minimal_required_fields(self) -> None: def test_missing_required_dimensions(self) -> None: """Test that missing dimensions field raises ValidationError.""" with pytest.raises(ValidationError) as exc_info: - Spatial() + Spatial() # type: ignore[call-arg] # intentionally missing required field assert "spatial:dimensions" in str(exc_info.value) def test_full_spatial_metadata(self) -> None: """Test creation with all fields populated.""" - data = { + data: dict[str, object] = { "spatial:dimensions": ["y", "x"], "spatial:bbox": [500000.0, 4900000.0, 600000.0, 5000000.0], "spatial:transform_type": "affine", @@ -40,7 +41,7 @@ def test_full_spatial_metadata(self) -> None: "spatial:registration": "pixel", } - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) assert spatial.dimensions == ["y", "x"] assert spatial.bbox == [500000.0, 4900000.0, 600000.0, 5000000.0] @@ -51,13 +52,13 @@ def test_full_spatial_metadata(self) -> None: def test_3d_spatial_data(self) -> None: """Test spatial model with 3D data.""" - data = { + data: dict[str, object] = { "spatial:dimensions": ["z", "y", "x"], "spatial:bbox": [500000.0, 4900000.0, 0.0, 600000.0, 5000000.0, 100.0], "spatial:shape": [10, 1000, 1000], } - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) assert spatial.dimensions == ["z", "y", "x"] assert spatial.bbox == [500000.0, 4900000.0, 0.0, 600000.0, 5000000.0, 100.0] @@ -65,14 +66,14 @@ def test_3d_spatial_data(self) -> None: def test_serialization_by_alias(self) -> None: """Test that serialization uses aliases (spatial: prefixes).""" - data = { + data: dict[str, object] = { "spatial:dimensions": ["y", "x"], "spatial:bbox": [0.0, 0.0, 100.0, 100.0], "spatial:transform": [1.0, 0.0, 0.0, 0.0, -1.0, 100.0], "spatial:shape": [100, 100], } - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) result = spatial.model_dump() # Should serialize with spatial: prefixes @@ -91,7 +92,8 @@ def test_serialization_by_alias(self) -> None: def test_none_fields_excluded(self) -> None: """Test that None fields are excluded from serialization.""" - spatial = Spatial(**{"spatial:dimensions": ["y", "x"]}) + data: dict[str, object] = {"spatial:dimensions": ["y", "x"]} + spatial = Spatial.model_validate(data) result = spatial.model_dump() # None fields should be excluded @@ -105,27 +107,30 @@ def test_none_fields_excluded(self) -> None: def test_node_registration(self) -> None: """Test node registration type.""" - data = {"spatial:dimensions": ["y", "x"], "spatial:registration": "node"} + data: dict[str, object] = {"spatial:dimensions": ["y", "x"], "spatial:registration": "node"} - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) assert spatial.registration == "node" def test_non_affine_transform_type(self) -> None: """Test non-affine transform types.""" - data = {"spatial:dimensions": ["y", "x"], "spatial:transform_type": "rpc"} + data: dict[str, object] = { + "spatial:dimensions": ["y", "x"], + "spatial:transform_type": "rpc", + } - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) assert spatial.transform_type == "rpc" def test_extra_fields_allowed(self) -> None: """Test that extra fields are allowed.""" - data = { + data: dict[str, object] = { "spatial:dimensions": ["y", "x"], "custom_field": "custom_value", "spatial:custom": "also_allowed", } - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) result = spatial.model_dump() assert result["custom_field"] == "custom_value" @@ -133,7 +138,7 @@ def test_extra_fields_allowed(self) -> None: def test_roundtrip_serialization(self) -> None: """Test that serialization and deserialization preserves data.""" - original_data = { + original_data: dict[str, object] = { "spatial:dimensions": ["y", "x"], "spatial:bbox": [500000.0, 4900000.0, 600000.0, 5000000.0], "spatial:transform": [10.0, 0.0, 500000.0, 0.0, -10.0, 5000000.0], @@ -143,7 +148,7 @@ def test_roundtrip_serialization(self) -> None: } # Create model, serialize, then recreate - spatial1 = Spatial(**original_data) + spatial1 = Spatial.model_validate(original_data) serialized = spatial1.model_dump() spatial2 = Spatial(**serialized) @@ -157,23 +162,26 @@ def test_roundtrip_serialization(self) -> None: def test_invalid_dimensions_none(self) -> None: """Test that None dimensions raise ValidationError.""" + data: dict[str, object] = {"spatial:dimensions": None} # intentionally invalid value with pytest.raises(ValidationError): - Spatial(**{"spatial:dimensions": None}) + Spatial.model_validate(data) def test_empty_dimensions_not_allowed(self) -> None: """Test that empty dimensions raise ValidationError.""" + empty_data: dict[str, object] = {"spatial:dimensions": []} with pytest.raises(ValidationError) as exc_info: - Spatial(**{"spatial:dimensions": []}) + Spatial.model_validate(empty_data) assert "spatial:dimensions must contain at least one dimension" in str(exc_info.value) - data = { + data: dict[str, object] = { "spatial:dimensions": ["y", "x"], "spatial:transform_type": "affine", "spatial:transform": [10.0, 0.0, 500000.0, 0.0, -10.0], # Only 5 elements } # Currently this will pass, but in the future we might want validation - spatial = Spatial(**data) + spatial = Spatial.model_validate(data) + assert spatial.transform is not None assert len(spatial.transform) == 5 # Current behavior # Future: might want to validate for exactly 6 elements for affine diff --git a/tests/test_data_api/test_v2.py b/tests/test_data_api/test_v2.py index a3386033..dd4c6941 100644 --- a/tests/test_data_api/test_v2.py +++ b/tests/test_data_api/test_v2.py @@ -1,17 +1,23 @@ from __future__ import annotations -from typing import Any +from collections.abc import Mapping +from typing import TYPE_CHECKING, cast import numpy as np import pytest from pydantic import ValidationError from pydantic_zarr.v2 import GroupSpec +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs from eopf_geozarr.data_api.geozarr.v2 import ( DataArray, + Dataset, check_valid_coordinates, ) +if TYPE_CHECKING: + from eopf_geozarr.data_api.geozarr.common import GroupLike + def test_invalid_dimension_names() -> None: msg = r"The _ARRAY_DIMENSIONS attribute has length 3, which does not match the number of dimensions for this array \(got 2\)" @@ -35,10 +41,13 @@ def test_valid(data_shape: tuple[int, ...]) -> None: f"dim_{idx}": DataArray.from_array(np.arange(s), dimension_names=(f"dim_{idx}",)) for idx, s in enumerate(data_shape) } - group = GroupSpec[Any, DataArray]( + group = GroupSpec[Mapping[str, object], DataArray]( attributes={}, members={"base": base_array, **coords_arrays} ) - assert check_valid_coordinates(group) == group + # ``group`` structurally satisfies ``GroupLike``, but mypy cannot bind the + # invariant ``Mapping`` value type, mirroring the cast used in the source. + group_like = cast("GroupLike", group) + assert check_valid_coordinates(group_like) == group_like @staticmethod @pytest.mark.parametrize("data_shape", [(10,), (10, 12)]) @@ -59,9 +68,36 @@ def test_invalid_coordinates( f"dim_{idx}": DataArray.from_array(np.arange(s + 1), dimension_names=(f"dim_{idx}",)) for idx, s in enumerate(data_shape) } - group = GroupSpec[Any, DataArray]( + group = GroupSpec[Mapping[str, object], DataArray]( attributes={}, members={"base": base_array, **coords_arrays} ) msg = "Dimension .* for array 'base' has a shape mismatch:" with pytest.raises(ValueError, match=msg): - check_valid_coordinates(group) + check_valid_coordinates(cast("GroupLike", group)) + + +class TestDataset: + @staticmethod + def _members() -> dict[str, DataArray]: + base_array = DataArray.from_array( + np.zeros((4, 4), dtype="uint8"), dimension_names=["y", "x"] + ) + coords_arrays = { + name: DataArray.from_array(np.arange(4), dimension_names=(name,)) for name in ("y", "x") + } + return {"band": base_array, **coords_arrays} + + def test_valid(self) -> None: + """A dataset with consistent coordinates and no grid mapping validates.""" + ds = Dataset(attributes=DatasetAttrs(), members=self._members()) + assert isinstance(ds, Dataset) + + def test_missing_grid_mapping_variable(self) -> None: + """A member declaring a grid_mapping that is not in the dataset fails validation.""" + members = self._members() + band = members["band"] + members["band"] = band.model_copy( + update={"attributes": band.attributes.model_copy(update={"grid_mapping": "nope"})} + ) + with pytest.raises(ValidationError, match="Grid mapping variable 'nope'"): + Dataset(attributes=DatasetAttrs(), members=members) diff --git a/tests/test_data_api/test_v3.py b/tests/test_data_api/test_v3.py index 09771b01..51c85419 100644 --- a/tests/test_data_api/test_v3.py +++ b/tests/test_data_api/test_v3.py @@ -1,17 +1,24 @@ -from typing import Any +from collections.abc import Mapping +from typing import TYPE_CHECKING, cast import numpy as np import pytest import zarr +from pydantic import ValidationError from pydantic_zarr.core import tuplify_json from pydantic_zarr.v3 import ArraySpec, GroupSpec +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs from eopf_geozarr.data_api.geozarr.v3 import ( DataArray, + Dataset, MultiscaleGroup, check_valid_coordinates, ) +if TYPE_CHECKING: + from eopf_geozarr.data_api.geozarr.common import GroupLike + class TestCheckValidCoordinates: @staticmethod @@ -29,10 +36,13 @@ def test_valid(data_shape: tuple[int, ...]) -> None: f"dim_{idx}": DataArray.from_array(np.arange(s), dimension_names=(f"dim_{idx}",)) for idx, s in enumerate(data_shape) } - group = GroupSpec[Any, DataArray]( + group = GroupSpec[Mapping[str, object], DataArray]( attributes={}, members={"base": base_array, **coords_arrays} ) - assert check_valid_coordinates(group) == group + # ``group`` structurally satisfies ``GroupLike``, but mypy cannot bind the + # invariant ``Mapping`` value type, mirroring the cast used in the source. + group_like = cast("GroupLike", group) + assert check_valid_coordinates(group_like) == group_like @staticmethod @pytest.mark.parametrize("data_shape", [(10,), (10, 12)]) @@ -53,19 +63,19 @@ def test_invalid_coordinates( f"dim_{idx}": DataArray.from_array(np.arange(s + 1), dimension_names=(f"dim_{idx}",)) for idx, s in enumerate(data_shape) } - group = GroupSpec[Any, DataArray]( + group = GroupSpec[Mapping[str, object], DataArray]( attributes={}, members={"base": base_array, **coords_arrays} ) msg = "Dimension .* for array 'base' has a shape mismatch:" with pytest.raises(ValueError, match=msg): - check_valid_coordinates(group) + check_valid_coordinates(cast("GroupLike", group)) -def test_dataarray_round_trip(s2_geozarr_group_example: Any) -> None: +def test_dataarray_round_trip(s2_geozarr_group_example: zarr.Group) -> None: """ Ensure that we can round-trip dataarray attributes through the `Multiscales` model. """ - source_untyped = GroupSpec.from_zarr(s2_geozarr_group_example) + source_untyped: GroupSpec = GroupSpec.from_zarr(s2_geozarr_group_example) flat = source_untyped.to_flat() for val in flat.values(): if isinstance(val, ArraySpec) and val.dimension_names is not None: @@ -73,7 +83,7 @@ def test_dataarray_round_trip(s2_geozarr_group_example: Any) -> None: assert DataArray(**model_json).model_dump() == model_json -def test_multiscale_attrs_round_trip(s2_geozarr_group_example: Any) -> None: +def test_multiscale_attrs_round_trip(s2_geozarr_group_example: zarr.Group) -> None: """ Test that multiscale datasets round-trip through the `Multiscales` model """ @@ -87,3 +97,30 @@ def test_multiscale_attrs_round_trip(s2_geozarr_group_example: Any) -> None: assert tuplify_json(MultiscaleGroup(**model_json).model_dump()) == tuplify_json( model_json ) + + +class TestDataset: + @staticmethod + def _members() -> dict[str, DataArray]: + base_array = DataArray.from_array( + np.zeros((4, 4), dtype="uint8"), dimension_names=["y", "x"] + ) + coords_arrays = { + name: DataArray.from_array(np.arange(4), dimension_names=(name,)) for name in ("y", "x") + } + return {"band": base_array, **coords_arrays} + + def test_valid(self) -> None: + """A dataset with consistent coordinates and no grid mapping validates.""" + ds = Dataset(attributes=DatasetAttrs(), members=self._members()) + assert isinstance(ds, Dataset) + + def test_missing_grid_mapping_variable(self) -> None: + """A member declaring a grid_mapping that is not in the dataset fails validation.""" + members = self._members() + band = members["band"] + members["band"] = band.model_copy( + update={"attributes": band.attributes.model_copy(update={"grid_mapping": "nope"})} + ) + with pytest.raises(ValidationError, match="Grid mapping variable 'nope'"): + Dataset(attributes=DatasetAttrs(), members=members) diff --git a/tests/test_docs.py b/tests/test_docs.py index 82763904..b9422d38 100644 --- a/tests/test_docs.py +++ b/tests/test_docs.py @@ -10,6 +10,7 @@ #> hello """ +import uuid from io import StringIO from pathlib import Path @@ -92,7 +93,7 @@ def _validate_output(example: CodeExample, captured_output: str) -> None: # Get all examples and group them by group ID _all_examples = list(find_examples("docs")) -_examples_by_group = {} +_examples_by_group: dict[uuid.UUID | None, list[CodeExample]] = {} for ex in _all_examples: if ex.prefix == "python": if ex.group not in _examples_by_group: @@ -120,7 +121,7 @@ def test_doc_example_group(group_examples: list[CodeExample]) -> None: #> hello """ # Execute all examples in the group sequentially to share state - namespace = {} + namespace: dict[str, object] = {} any_skipped = False for example in group_examples: diff --git a/tests/test_fs_utils.py b/tests/test_fs_utils.py index 872f93a9..fec0cee7 100644 --- a/tests/test_fs_utils.py +++ b/tests/test_fs_utils.py @@ -66,7 +66,7 @@ def test_get_s3_credentials_info() -> None: @patch("eopf_geozarr.conversion.fs_utils.s3fs.S3FileSystem") -def test_validate_s3_access_success(mock_s3fs) -> None: +def test_validate_s3_access_success(mock_s3fs: Mock) -> None: """Test successful S3 access validation.""" mock_fs = Mock() mock_fs.ls.return_value = ["file1", "file2"] @@ -79,7 +79,7 @@ def test_validate_s3_access_success(mock_s3fs) -> None: @patch("eopf_geozarr.conversion.fs_utils.s3fs.S3FileSystem") -def test_validate_s3_access_failure(mock_s3fs) -> None: +def test_validate_s3_access_failure(mock_s3fs: Mock) -> None: """Test failed S3 access validation.""" mock_fs = Mock() mock_fs.ls.side_effect = Exception("Access denied") @@ -87,6 +87,7 @@ def test_validate_s3_access_failure(mock_s3fs) -> None: success, error = validate_s3_access("s3://test-bucket/path") assert success is False + assert error is not None assert "Access denied" in error @@ -101,11 +102,13 @@ def test_get_s3_storage_options() -> None: ): options = get_s3_storage_options("s3://test-bucket/path") - assert options["anon"] is False - assert options["use_ssl"] is True - assert options["client_kwargs"]["region_name"] == "us-west-2" - assert options["endpoint_url"] == "https://s3.example.com" - assert options["client_kwargs"]["endpoint_url"] == "https://s3.example.com" + assert options.get("anon") is False + assert options.get("use_ssl") is True + client_kwargs = options.get("client_kwargs") + assert client_kwargs is not None + assert client_kwargs.get("region_name") == "us-west-2" + assert options.get("endpoint_url") == "https://s3.example.com" + assert client_kwargs.get("endpoint_url") == "https://s3.example.com" def test_get_storage_options() -> None: @@ -114,9 +117,11 @@ def test_get_storage_options() -> None: with patch.dict("os.environ", {"AWS_DEFAULT_REGION": "us-west-2"}): options = get_storage_options("s3://test-bucket/path") assert options is not None - assert options["anon"] is False - assert options["use_ssl"] is True - assert options["client_kwargs"]["region_name"] == "us-west-2" + assert options.get("anon") is False + assert options.get("use_ssl") is True + client_kwargs = options.get("client_kwargs") + assert client_kwargs is not None + assert client_kwargs.get("region_name") == "us-west-2" # Test local path options = get_storage_options("/local/path") @@ -142,7 +147,7 @@ def test_normalize_path() -> None: @patch("eopf_geozarr.conversion.fs_utils.get_filesystem") -def test_path_exists(mock_get_filesystem) -> None: +def test_path_exists(mock_get_filesystem: Mock) -> None: """Test unified path existence check.""" mock_fs = Mock() mock_fs.exists.return_value = True @@ -160,7 +165,7 @@ def test_path_exists(mock_get_filesystem) -> None: @patch("eopf_geozarr.conversion.fs_utils.get_filesystem") -def test_write_json_metadata(mock_get_filesystem) -> None: +def test_write_json_metadata(mock_get_filesystem: Mock) -> None: """Test unified JSON metadata writing.""" from unittest.mock import MagicMock, mock_open @@ -183,7 +188,7 @@ def test_write_json_metadata(mock_get_filesystem) -> None: @patch("eopf_geozarr.conversion.fs_utils.get_filesystem") -def test_read_json_metadata(mock_get_filesystem) -> None: +def test_read_json_metadata(mock_get_filesystem: Mock) -> None: """Test unified JSON metadata reading.""" from unittest.mock import MagicMock, mock_open diff --git a/tests/test_integration_sentinel1.py b/tests/test_integration_sentinel1.py index 137cd53b..13f20925 100644 --- a/tests/test_integration_sentinel1.py +++ b/tests/test_integration_sentinel1.py @@ -21,7 +21,7 @@ class MockSentinel1L1GRDBuilder: """Builder class to generate a sample EOPF Sentinel-1 Level 1 GRD data product for testing purpose.""" - def __init__(self, product_id) -> None: + def __init__(self, product_id: str) -> None: self.product_title = "S01SIWGRD" self.product_id = product_id @@ -32,7 +32,7 @@ def __init__(self, product_id) -> None: self.nlines = 552 self.npixels = 1131 - def create_coordinates(self, az_dim_size, gr_dim_size) -> xr.Coordinates: + def create_coordinates(self, az_dim_size: int, gr_dim_size: int) -> xr.Coordinates: coords = { self.az_dim: pd.date_range( start="2017-05-08T16:48:30", @@ -182,7 +182,7 @@ def temp_output_dir() -> Generator[str, None, None]: shutil.rmtree(temp_dir) -def test_no_gcp_group(temp_output_dir, sample_sentinel1_datatree) -> None: +def test_no_gcp_group(temp_output_dir: str, sample_sentinel1_datatree: xr.DataTree) -> None: output_path = Path(temp_output_dir) / "temp.zarr" with pytest.raises(ValueError, match=r"Detected Sentinel-1.*GCP group not provided"): @@ -193,7 +193,9 @@ def test_no_gcp_group(temp_output_dir, sample_sentinel1_datatree) -> None: ) -def test_invalid_gcp_group_raises_error(temp_output_dir, sample_sentinel1_datatree) -> None: +def test_invalid_gcp_group_raises_error( + temp_output_dir: str, sample_sentinel1_datatree: xr.DataTree +) -> None: """Test that specifying a non-existent GCP group raises an error.""" output_path = Path(temp_output_dir) / "test_s1_invalid_gcp.zarr" groups = ["measurements"] @@ -216,7 +218,7 @@ def test_invalid_gcp_group_raises_error(temp_output_dir, sample_sentinel1_datatr ], ) def test_sentinel1_gcp_conversion( - temp_output_dir, sample_sentinel1_datatree, polarization_group + temp_output_dir: str, sample_sentinel1_datatree: xr.DataTree, polarization_group: str ) -> None: """Test conversion of Sentinel-1 data with GCPs.""" # Prepare test diff --git a/tests/test_integration_sentinel2.py b/tests/test_integration_sentinel2.py index bae02360..91b6b7bc 100644 --- a/tests/test_integration_sentinel2.py +++ b/tests/test_integration_sentinel2.py @@ -230,7 +230,7 @@ def temp_output_dir() -> Generator[str, None, None]: def test_complete_sentinel2_conversion_notebook_workflow( - sample_sentinel2_datatree, temp_output_dir + sample_sentinel2_datatree: xr.DataTree, temp_output_dir: str ) -> None: """ Test complete conversion following the notebook workflow. @@ -290,7 +290,9 @@ def test_complete_sentinel2_conversion_notebook_workflow( @pytest.mark.slow -def test_performance_characteristics(sample_sentinel2_datatree, temp_output_dir) -> None: +def test_performance_characteristics( + sample_sentinel2_datatree: xr.DataTree, temp_output_dir: str +) -> None: """ Test performance characteristics following notebook analysis. diff --git a/tests/test_reprojection_validation.py b/tests/test_reprojection_validation.py index aa5bbab1..abb944ce 100755 --- a/tests/test_reprojection_validation.py +++ b/tests/test_reprojection_validation.py @@ -16,7 +16,7 @@ class MockSentinel1L1GRDBuilder: """Builder class to generate a sample EOPF Sentinel-1 Level 1 GRD data product for testing purpose.""" - def __init__(self, product_id) -> None: + def __init__(self, product_id: str) -> None: self.product_title = "S01SIWGRD" self.product_id = product_id self.az_dim = "azimuth_time" @@ -25,7 +25,7 @@ def __init__(self, product_id) -> None: self.nlines = 552 self.npixels = 1131 - def create_coordinates(self, az_dim_size, gr_dim_size) -> xr.Coordinates: + def create_coordinates(self, az_dim_size: int, gr_dim_size: int) -> xr.Coordinates: coords = { self.az_dim: pd.date_range( start="2017-05-08T16:48:30", diff --git a/tests/test_s2_converter_simplified.py b/tests/test_s2_converter_simplified.py index 69cff728..0bbf746b 100644 --- a/tests/test_s2_converter_simplified.py +++ b/tests/test_s2_converter_simplified.py @@ -254,8 +254,10 @@ def test_write_store_root_bbox_reprojects_utm_to_wgs84(tmp_path: Path) -> None: root_attrs = dict(zarr.open_group(store_path, mode="r").attrs) bbox = root_attrs["spatial:bbox"] + assert isinstance(bbox, list) + assert all(isinstance(coord, float) for coord in bbox) assert len(bbox) == 4 - xmin, ymin, xmax, ymax = bbox + xmin, ymin, xmax, ymax = (coord for coord in bbox if isinstance(coord, float)) # Roughly 7.0-8.0E, 44.1-45.1N after reprojection assert 6.0 < xmin < 8.0, bbox assert 43.0 < ymin < 45.0, bbox diff --git a/tests/test_s2_data_consolidator.py b/tests/test_s2_data_consolidator.py index 6102a25d..be82a85e 100644 --- a/tests/test_s2_data_consolidator.py +++ b/tests/test_s2_data_consolidator.py @@ -187,7 +187,7 @@ def sample_s2_datatree(self) -> MagicMock: } # Mock the dataset access - def mock_getitem(self, path: str) -> MagicMock: + def mock_getitem(self: object, path: str) -> MagicMock: mock_node = MagicMock() if "r10m" in path: if "reflectance" in path: @@ -220,7 +220,7 @@ def mock_getitem(self, path: str) -> MagicMock: mock_dt.__getitem__ = mock_getitem return mock_dt - def test_init(self, sample_s2_datatree) -> None: + def test_init(self, sample_s2_datatree: MagicMock) -> None: """Test consolidator initialization.""" consolidator = S2DataConsolidator(sample_s2_datatree) @@ -229,7 +229,7 @@ def test_init(self, sample_s2_datatree) -> None: assert consolidator.geometry_data == {} assert consolidator.meteorology_data == {} - def test_consolidate_all_data(self, sample_s2_datatree) -> None: + def test_consolidate_all_data(self, sample_s2_datatree: MagicMock) -> None: """Test complete data consolidation.""" consolidator = S2DataConsolidator(sample_s2_datatree) measurements, geometry, meteorology = consolidator.consolidate_all_data() @@ -253,7 +253,7 @@ def test_consolidate_all_data(self, sample_s2_datatree) -> None: assert "atmosphere" in measurements[resolution] assert "probability" in measurements[resolution] - def test_extract_reflectance_bands(self, sample_s2_datatree) -> None: + def test_extract_reflectance_bands(self, sample_s2_datatree: MagicMock) -> None: """Test reflectance band extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -274,7 +274,7 @@ def test_extract_reflectance_bands(self, sample_s2_datatree) -> None: assert "b01" in consolidator.measurements_data[60]["bands"] assert "b09" in consolidator.measurements_data[60]["bands"] - def test_extract_quality_data(self, sample_s2_datatree) -> None: + def test_extract_quality_data(self, sample_s2_datatree: MagicMock) -> None: """Test quality data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -283,7 +283,7 @@ def test_extract_quality_data(self, sample_s2_datatree) -> None: assert "quality_b02" in consolidator.measurements_data[10]["quality"] assert "quality_b03" in consolidator.measurements_data[10]["quality"] - def test_extract_detector_footprints(self, sample_s2_datatree) -> None: + def test_extract_detector_footprints(self, sample_s2_datatree: MagicMock) -> None: """Test detector footprint extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -292,7 +292,7 @@ def test_extract_detector_footprints(self, sample_s2_datatree) -> None: assert "detector_footprint_b02" in consolidator.measurements_data[10]["detector_footprints"] assert "detector_footprint_b03" in consolidator.measurements_data[10]["detector_footprints"] - def test_extract_atmosphere_data(self, sample_s2_datatree) -> None: + def test_extract_atmosphere_data(self, sample_s2_datatree: MagicMock) -> None: """Test atmosphere data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -301,7 +301,7 @@ def test_extract_atmosphere_data(self, sample_s2_datatree) -> None: assert "aot" in consolidator.measurements_data[20]["atmosphere"] assert "wvp" in consolidator.measurements_data[20]["atmosphere"] - def test_extract_classification_data(self, sample_s2_datatree) -> None: + def test_extract_classification_data(self, sample_s2_datatree: MagicMock) -> None: """Test classification data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -309,7 +309,7 @@ def test_extract_classification_data(self, sample_s2_datatree) -> None: # Classification should be at 20m resolution assert "scl" in consolidator.measurements_data[20]["classification"] - def test_extract_probability_data(self, sample_s2_datatree) -> None: + def test_extract_probability_data(self, sample_s2_datatree: MagicMock) -> None: """Test probability data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_measurements_data() @@ -318,7 +318,7 @@ def test_extract_probability_data(self, sample_s2_datatree) -> None: assert "cld" in consolidator.measurements_data[20]["probability"] assert "snw" in consolidator.measurements_data[20]["probability"] - def test_extract_geometry_data(self, sample_s2_datatree) -> None: + def test_extract_geometry_data(self, sample_s2_datatree: MagicMock) -> None: """Test geometry data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_geometry_data() @@ -329,7 +329,7 @@ def test_extract_geometry_data(self, sample_s2_datatree) -> None: assert "view_zenith_angle" in consolidator.geometry_data assert "view_azimuth_angle" in consolidator.geometry_data - def test_extract_meteorology_data(self, sample_s2_datatree) -> None: + def test_extract_meteorology_data(self, sample_s2_datatree: MagicMock) -> None: """Test meteorology data extraction.""" consolidator = S2DataConsolidator(sample_s2_datatree) consolidator._extract_meteorology_data() @@ -412,7 +412,9 @@ def sample_data_dict(self) -> dict[str, dict[str, xr.DataArray]]: }, } - def test_create_consolidated_dataset_success(self, sample_data_dict) -> None: + def test_create_consolidated_dataset_success( + self, sample_data_dict: dict[str, dict[str, xr.DataArray]] + ) -> None: """Test successful dataset creation.""" ds = create_consolidated_dataset(sample_data_dict, resolution=10) @@ -434,14 +436,20 @@ def test_create_consolidated_dataset_success(self, sample_data_dict) -> None: def test_create_consolidated_dataset_empty_data(self) -> None: """Test dataset creation with empty data.""" - empty_data_dict = {"bands": {}, "quality": {}, "atmosphere": {}} + empty_data_dict: dict[str, dict[str, xr.DataArray]] = { + "bands": {}, + "quality": {}, + "atmosphere": {}, + } ds = create_consolidated_dataset(empty_data_dict, resolution=20) # Should return empty dataset assert isinstance(ds, xr.Dataset) assert len(ds.data_vars) == 0 - def test_create_consolidated_dataset_with_crs(self, sample_data_dict) -> None: + def test_create_consolidated_dataset_with_crs( + self, sample_data_dict: dict[str, dict[str, xr.DataArray]] + ) -> None: """Test dataset creation with CRS information.""" # Add CRS to one of the data arrays sample_data_dict["bands"]["b02"] = sample_data_dict["bands"]["b02"].rio.write_crs( @@ -513,7 +521,7 @@ def complete_s2_datatree(self) -> MagicMock: coords={"time": time, "x": x_20m, "y": y_20m}, ) - def mock_getitem(self, path: str) -> MagicMock: + def mock_getitem(self: object, path: str) -> MagicMock: mock_node = MagicMock() if "/measurements/reflectance/r10m" in path: mock_node.to_dataset.return_value = reflectance_10m @@ -526,7 +534,7 @@ def mock_getitem(self, path: str) -> MagicMock: mock_dt.__getitem__ = mock_getitem return mock_dt - def test_end_to_end_consolidation(self, complete_s2_datatree) -> None: + def test_end_to_end_consolidation(self, complete_s2_datatree: MagicMock) -> None: """Test complete end-to-end consolidation and dataset creation.""" # Step 1: Consolidate data consolidator = S2DataConsolidator(complete_s2_datatree) diff --git a/tests/test_s2_multiscale.py b/tests/test_s2_multiscale.py index a0ad955f..29c57117 100644 --- a/tests/test_s2_multiscale.py +++ b/tests/test_s2_multiscale.py @@ -4,6 +4,7 @@ import json import pathlib +from collections.abc import Mapping, Sequence from itertools import pairwise from pathlib import Path from unittest.mock import patch @@ -17,6 +18,7 @@ from structlog.testing import capture_logs from zarr.codecs import BloscCodec, CastValue, ScaleOffset from zarr.core.dtype import Int16 +from zarr.core.metadata import ArrayV3Metadata from eopf_geozarr.s2_optimization.s2_multiscale import ( _coarsen_variable, @@ -70,7 +72,9 @@ def _dataset(resolution: int, size: int, x0: float, y0: float) -> xr.Dataset: {"band": (["y", "x"], np.ones((size, size), dtype=np.uint16))}, coords={"x": x, "y": y}, ) - return ds.rio.write_crs("EPSG:32631") + crs_ds = ds.rio.write_crs("EPSG:32631") + assert isinstance(crs_ds, xr.Dataset) + return crs_ds r10m = _dataset(10, 12, 600000.0, 4900020.0) r120m = _dataset(120, 3, 600030.0, 4899990.0) @@ -86,9 +90,17 @@ def stale_transform() -> tuple[float, float, float, float, float, float]: {"r10m": r10m, "r120m": r120m}, ) - layout = parent_group.attrs["multiscales"]["layout"] - derived_level = next(level for level in layout if level["asset"] == "r120m") - assert tuple(derived_level["spatial:transform"]) == ( + multiscales = parent_group.attrs["multiscales"] + assert isinstance(multiscales, Mapping) + layout = multiscales["layout"] + assert isinstance(layout, Sequence) + derived_level = next( + level for level in layout if isinstance(level, Mapping) and level["asset"] == "r120m" + ) + assert isinstance(derived_level, Mapping) + transform = derived_level["spatial:transform"] + assert isinstance(transform, Sequence) + assert tuple(transform) == ( 120.0, 0.0, 600030.0, @@ -101,8 +113,8 @@ def stale_transform() -> tuple[float, float, float, float, float, float]: def test_calculate_simple_shard_dimensions() -> None: """Test simplified shard dimensions calculation.""" # Test 3D data (time, y, x) - shards are multiples of chunks - data_shape = (5, 1024, 1024) - chunks = (1, 256, 256) + data_shape: tuple[int, ...] = (5, 1024, 1024) + chunks: tuple[int, ...] = (1, 256, 256) shard_dims = calculate_simple_shard_dimensions(data_shape, chunks) @@ -181,8 +193,8 @@ def test_create_measurements_encoding(keep_scale_offset: bool, sample_dataset: x # Check that encoding is created for all variables for var_name in sample_dataset.data_vars: - assert var_name in encoding - var_encoding = encoding[var_name] + assert str(var_name) in encoding + var_encoding = encoding[str(var_name)] # Check basic encoding structure assert "chunks" in var_encoding @@ -194,11 +206,11 @@ def test_create_measurements_encoding(keep_scale_offset: bool, sample_dataset: x # Check coordinate encoding for coord_name in sample_dataset.coords: - if coord_name in encoding: + if str(coord_name) in encoding: # Coordinates may have either compressor or compressors set to None assert ( - encoding[coord_name].get("compressor") is None - or encoding[coord_name].get("compressors") is None + encoding[str(coord_name)].get("compressor") is None + or encoding[str(coord_name)].get("compressors") is None ) # Store data and check that we are conditionally applying the scale-offset transformation # based on the request passed to the encoding @@ -220,7 +232,8 @@ def test_create_measurements_encoding_time_chunking(sample_dataset: xr.Dataset) for var_name in sample_dataset.data_vars: if sample_dataset[var_name].ndim == 3: # 3D variable with time - chunks = encoding[var_name]["chunks"] + chunks = encoding[str(var_name)].get("chunks") + assert chunks is not None assert chunks[0] == 1 # Time dimension should be chunked to 1 @@ -240,7 +253,7 @@ def test_calculate_aligned_chunk_size() -> None: @pytest.mark.filterwarnings("ignore:.*:FutureWarning") @pytest.mark.filterwarnings("ignore:.*:UserWarning") def test_create_multiscale_from_datatree( - s2_group_example: zarr.Group, + s2_group_example: pathlib.Path, tmp_path: pathlib.Path, ) -> None: """Snapshot test: a single canonical parametrization (keep_scale_offset=False, @@ -253,7 +266,13 @@ def test_create_multiscale_from_datatree( output_path = str(tmp_path / "output.zarr") input_group = zarr.open_group(s2_group_example) output_group = zarr.create_group(output_path) - dt_input = xr.open_datatree(input_group.store, engine="zarr", chunks="auto") + # xarray's open_datatree accepts a zarr store at runtime, but its stub does + # not list Store among the accepted input types. + dt_input = xr.open_datatree( + input_group.store, # pyright: ignore[reportArgumentType] + engine="zarr", + chunks="auto", + ) # Capture log output using structlog's testing context manager with capture_logs(): @@ -291,7 +310,9 @@ def test_create_multiscale_from_datatree( # check that all multiscale levels have the same data type # this check is redundant with the later check, but it's expedient to check this here. # eventually this check should be spun out into its own test - _, res_groups = zip(*observed_group["measurements/reflectance"].groups(), strict=False) + reflectance_group = observed_group["measurements/reflectance"] + assert isinstance(reflectance_group, zarr.Group) + _, res_groups = zip(*reflectance_group.groups(), strict=False) dtype_mismatch: set[object] = set() for group_a, group_b in pairwise(res_groups): @@ -421,6 +442,7 @@ def test_create_multiscale_from_datatree_behavior( # ------------------------------------------------------------------ for group_path, var_name in _ORIGINAL_GROUPS.items(): arr = zarr.open_array(output_path, path=f"{group_path}/{var_name}") + assert isinstance(arr.metadata, ArrayV3Metadata) codec_names = [type(c).__name__ for c in arr.metadata.codecs] if keep_scale_offset: @@ -461,6 +483,7 @@ def test_create_multiscale_from_datatree_behavior( assert ds.data_vars, f"{group_path} has no variables" for name in ds.data_vars: arr = zarr.open_array(output_path, path=f"{group_path}/{name}") + assert isinstance(arr.metadata, ArrayV3Metadata) codec_names = [type(c).__name__ for c in arr.metadata.codecs] if keep_scale_offset: diff --git a/tests/test_scale_offset.py b/tests/test_scale_offset.py index 18826e0f..913c1c84 100644 --- a/tests/test_scale_offset.py +++ b/tests/test_scale_offset.py @@ -37,4 +37,4 @@ def test_scale_offset_from_cf_round_trip() -> None: ) arr[:] = unpacked_values - np.testing.assert_array_almost_equal(arr[:], unpacked_values) + np.testing.assert_array_almost_equal(np.asarray(arr[:]), unpacked_values) diff --git a/tests/test_titiler_integration.py b/tests/test_titiler_integration.py index 3d761c76..925e019e 100644 --- a/tests/test_titiler_integration.py +++ b/tests/test_titiler_integration.py @@ -9,6 +9,10 @@ - titiler-xarray, httpx installed """ +# titiler/fastapi/starlette are optional (the `downstream-titiler` group); this +# module is skipped at runtime when they're absent, so don't flag their imports. +# pyright: reportMissingImports=false + from __future__ import annotations import pathlib @@ -89,7 +93,7 @@ def _open_group(path: pathlib.Path, group: str) -> xr.Dataset: def _band_vars(ds: xr.Dataset) -> list[str]: """Get band variable names, excluding spatial_ref.""" - return [v for v in ds.data_vars if v != "spatial_ref"] + return [str(v) for v in ds.data_vars if v != "spatial_ref"] class TestTitilerInfo: diff --git a/uv.lock b/uv.lock index 6f1926ed..a7c71ef4 100644 --- a/uv.lock +++ b/uv.lock @@ -18,9 +18,10 @@ constraints = [ { name = "black", specifier = ">=26.3.1" }, { name = "cryptography", specifier = ">=46.0.6" }, { name = "filelock", specifier = ">=3.20.3" }, + { name = "msgpack", specifier = ">=1.2.1" }, { name = "pygments", specifier = ">=2.20.0" }, { name = "requests", specifier = ">=2.33.0" }, - { name = "tornado", specifier = ">=6.5.5" }, + { name = "tornado", specifier = ">=6.5.7" }, { name = "urllib3", specifier = ">=2.7.0" }, { name = "virtualenv", specifier = ">=20.36.1" }, ] @@ -214,46 +215,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, ] -[[package]] -name = "ast-serialize" -version = "0.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/81/9d/09e27731bd5864a9ce04e3244074e674bb8936bf62b45e0357248717adac/ast_serialize-0.5.0.tar.gz", hash = "sha256:5880091bfe6f4f986f22866375c2e884843e7a0b6343ae41aeea659613d879b6", size = 61157, upload-time = "2026-05-17T17:48:29.429Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/9a/13dde51ba9e15f8b97957ab7cb0120d0e381524d651c6bd630b9c359227f/ast_serialize-0.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8f5c14f169eb0972c0c21bada5358b23d6047c76583b005234f865b11f1fa00a", size = 1183520, upload-time = "2026-05-17T17:47:30.831Z" }, - { url = "https://files.pythonhosted.org/packages/37/de/5a7f0a9fe68944f536632a5af84676739c7d2582be42deb082634bf3a754/ast_serialize-0.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7d1a2de9de5be04652f0ed60738356ef94f66db37924a9499fffe98dc491aa0b", size = 1175779, upload-time = "2026-05-17T17:47:32.551Z" }, - { url = "https://files.pythonhosted.org/packages/9c/81/0bb853e76e4f6e9a1855d569003c59e19ffac45f7079d91505d1bb212f92/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be5173fb66f9b49026d9d5a2ff0fc7c7009077107c0eb285b2d60fdf1fe10bd1", size = 1233750, upload-time = "2026-05-17T17:47:34.731Z" }, - { url = "https://files.pythonhosted.org/packages/e5/d3/4cf705beeccc08754d0bbda99aefff26110e209b9a07ac8a6b60eec48531/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8015cd071ac1339924ee2b8098c93e00e155f30a16f40ec9816fcf84f4753f6", size = 1235942, upload-time = "2026-05-17T17:47:36.287Z" }, - { url = "https://files.pythonhosted.org/packages/26/c8/ee097e437ea27dd2b8b227865c875492b585650a5802a22d82b304c8201b/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5499e8797edff2a9186aa313ed382c6b422e798e9332d9953badcee6e69a88f2", size = 1442517, upload-time = "2026-05-17T17:47:38.17Z" }, - { url = "https://files.pythonhosted.org/packages/ff/bd/68063442838f1ba68ec72b5436430bc75b3bb17a1a3c3063f09b0c05ae2b/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6848f2a093fb5548751a9a09bff8fcd229e2bbeb0e3331f391b6ae6d26cd9903", size = 1254081, upload-time = "2026-05-17T17:47:39.826Z" }, - { url = "https://files.pythonhosted.org/packages/50/e2/1e520793bc6a4e4524a6ab022391e827825eaa0c3811828bfdc6852eca26/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:832d4c998e0b091fd60a6d6bceee535483c4d490de9ba85003af835225719261", size = 1259910, upload-time = "2026-05-17T17:47:41.369Z" }, - { url = "https://files.pythonhosted.org/packages/4e/e1/49b60f467979979cfe6913b43948ff25bca971ad0591d181812f163a988e/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:16db7c62ec0b8efe1d7afd283a388d8f74f2605d56032e5a37747d2de8dba027", size = 1250678, upload-time = "2026-05-17T17:47:43.702Z" }, - { url = "https://files.pythonhosted.org/packages/74/ba/66ab9555de6275677566f6574e5ef6c29cb185ea866f643bc06f8280a8ee/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:baf5eb061eb5bccade4128ad42da33787d72f6013809cd1b590376ece8b3c937", size = 1301603, upload-time = "2026-05-17T17:47:46.256Z" }, - { url = "https://files.pythonhosted.org/packages/66/42/6aca9b9abc710014b2be9059689e5dd1679339e78f567ffb4d255a9e2050/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:104e4a35bd7c124173c41760ef9aaea17ddb3f86c65cb643671d59afbe3ee94c", size = 1410332, upload-time = "2026-05-17T17:47:47.899Z" }, - { url = "https://files.pythonhosted.org/packages/47/68/2f76594432a22581ecf878b5e75a9b8601c24b2241cf0bbeb1e21fcf370c/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:36be371028fc1675acb38a331bde160dbab7ff907fdf00b67eb6911aa106951b", size = 1509979, upload-time = "2026-05-17T17:47:50.942Z" }, - { url = "https://files.pythonhosted.org/packages/40/ac/a93c9b58292653f6c595752f677a08e608f903b710594909e9231a389b3b/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:061ee58bdb52341c8201a6df41182a977736bae3b7ded87ca7176ca25a8a47ab", size = 1505002, upload-time = "2026-05-17T17:47:54.093Z" }, - { url = "https://files.pythonhosted.org/packages/14/2e/b278f68c497ee2f1d1576cbbef8db5281cd4a5f2db040537592ac9c8862e/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b15219e9cdc9f53f6f4cb51c009203507228226148c05c5e8fe451c28b435eb3", size = 1456231, upload-time = "2026-05-17T17:47:56.311Z" }, - { url = "https://files.pythonhosted.org/packages/0b/43/419be1c566a4c504cd8fd60ce2f84e790f295495c0f327cfaeadf3d51012/ast_serialize-0.5.0-cp314-cp314t-win32.whl", hash = "sha256:842d1c004bb466c7df036f95fabef789570541922b10976b12f5592a69cf0b38", size = 1058668, upload-time = "2026-05-17T17:47:58.305Z" }, - { url = "https://files.pythonhosted.org/packages/03/6f/c9d4d549295ed05111aeb8853232d1afd9d0a179fddb01eeffbb3a4a6842/ast_serialize-0.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b0c06d760909b095cc466356dfccd05a1c7233a6ca191c020dca2c6a6f16c24c", size = 1101075, upload-time = "2026-05-17T17:48:00.35Z" }, - { url = "https://files.pythonhosted.org/packages/d0/8e/d00c5ab30c58222e07d62956fca86c59d91b9ad32997e633c38b526623a3/ast_serialize-0.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:787baedb0262cc49e8ce37cc15c00ae818e46a165a3b36f5e21ed174998104cb", size = 1075347, upload-time = "2026-05-17T17:48:01.753Z" }, - { url = "https://files.pythonhosted.org/packages/e0/9e/dc2530acb3a60dc6e46d65abf27d1d9f86721694757906a148d90a6860de/ast_serialize-0.5.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0668aa9459cfa8c9c49ddd2163ebcf43088ba045ef7492af6fe22e0098303101", size = 1191380, upload-time = "2026-05-17T17:48:03.738Z" }, - { url = "https://files.pythonhosted.org/packages/26/0a/bd3d18a582f273d6c843d16bb9e22e9e16365ff7991e92f18f798e9f1224/ast_serialize-0.5.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bf683d6363edf2b39eed6b6d4fe22d34b6203867a67e27134d9e2a2680c4bc4a", size = 1183879, upload-time = "2026-05-17T17:48:05.463Z" }, - { url = "https://files.pythonhosted.org/packages/40/ae/1f919100f8620887af58fcc381c61a1f218cdf89c6e155f87b213e61010a/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc22cf0c9be65e71cf88fda130af60d61eb4a79370ad4cfe7900d48a4aa2211", size = 1244529, upload-time = "2026-05-17T17:48:07.008Z" }, - { url = "https://files.pythonhosted.org/packages/c6/ca/6376559dcce707cdbc1d0d9a13c8d3baaaa501e949ce0ebdc4230cd881aa/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f66173891548c9f2726bf27957b41cabce12fa679dc6da505ddbde4d4b3b31cf", size = 1240560, upload-time = "2026-05-17T17:48:08.46Z" }, - { url = "https://files.pythonhosted.org/packages/35/b2/a620e206b5aeb7efbf2710336df57d457cffbb3991076bbcc1147ef9abd4/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e42d729ef2be96a14efbad355093284739e3670ece3e534f82cc8832790911d9", size = 1451172, upload-time = "2026-05-17T17:48:09.922Z" }, - { url = "https://files.pythonhosted.org/packages/fa/e0/4ad5c04c24a40481b2935ce9a0ccdb6023dc8b667167d06ae530cc3512f2/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b725026bafa801dbd7310eb13a75f0a2e370e7e51b2cb225f9d21fcfadf919ee", size = 1265072, upload-time = "2026-05-17T17:48:11.469Z" }, - { url = "https://files.pythonhosted.org/packages/b2/71/4d1d479aa56d0101c40e17720c3d6ac2af7269ea0487a80b18e7bfd1a5b7/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b54f60c1d78767a53b67eaa663f0dfac3afe606aa07f1301572f588b73d64809", size = 1270488, upload-time = "2026-05-17T17:48:13.575Z" }, - { url = "https://files.pythonhosted.org/packages/6d/4f/0de1bbe06f6edef9fde4ed12ca8e7b3ec7e6e2bd4e672c5af487f7957665/ast_serialize-0.5.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:27d51654fc240a1e87e742d353d98eb45b75f62f129086b3596ab53df2ac2a43", size = 1260702, upload-time = "2026-05-17T17:48:15.141Z" }, - { url = "https://files.pythonhosted.org/packages/75/61/e00872439cfdddcc3c1b6cdaa6e5d904ba8e26a18807c67c4e14409d0ca8/ast_serialize-0.5.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c36237c46dd1674542f2109740ea5ea485a169bf1431939ada0434e17934", size = 1311182, upload-time = "2026-05-17T17:48:16.779Z" }, - { url = "https://files.pythonhosted.org/packages/76/8e/699a5b955f7926956c95e9e1d74132acad73c2fe7a426f94da89123c20aa/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1943db345233cc7194a470f13afa9c59772c0b123dea0c9414c4d4ca54369759", size = 1421410, upload-time = "2026-05-17T17:48:18.527Z" }, - { url = "https://files.pythonhosted.org/packages/a9/ae/d5b7626874478997adc7a29ab28accf21e596fb590c944290401dfd0b29e/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df1c00022cbbcb064bfaa505aa9c9295362443ce5dacb459d1331d3da353f887", size = 1516587, upload-time = "2026-05-17T17:48:20.133Z" }, - { url = "https://files.pythonhosted.org/packages/0c/ce/b59e02a82d9c4244d64cde502e0b00e83e38816abe19155ceb5437402c7f/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:cae65289fc456fde04af979a2be09302ef5d8ab92ef23e596d6746dc267ada27", size = 1515171, upload-time = "2026-05-17T17:48:21.921Z" }, - { url = "https://files.pythonhosted.org/packages/8b/38/d8d90042747d05aa08d4efcf1c99035a5f670a6bf4c214d31644392afbca/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:239a4c354e8d676e9d94631d1d4a64edc6b266f86ff3a5a80aedd344f342c01d", size = 1464668, upload-time = "2026-05-17T17:48:23.544Z" }, - { url = "https://files.pythonhosted.org/packages/dd/51/5b840c4df7334104cecffa28f23904fe81ca89ca223d2450e288de39fd3c/ast_serialize-0.5.0-cp39-abi3-win32.whl", hash = "sha256:143a4ef63285a075871908fda3672dc21864b83a8ec3ee12304aa3e4c5387b9a", size = 1068311, upload-time = "2026-05-17T17:48:25.027Z" }, - { url = "https://files.pythonhosted.org/packages/41/11/ca5672c7d491825bc4cd6702dea106a6b60d928707712ec257c7833ae476/ast_serialize-0.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:cf25572c526add400f26a4750dc6ce0c3bb93fc1f75e7ae0cad4ce4f2cd5c590", size = 1108931, upload-time = "2026-05-17T17:48:26.591Z" }, - { url = "https://files.pythonhosted.org/packages/45/19/cc8bd127d28a43da249aa955cfd164cf8fd534e79e42cea96c4854d72fd0/ast_serialize-0.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:92a31c9c20d25a076edaeec76b128a3535d74a24f340b9a8a7e96c9b86dc9642", size = 1081181, upload-time = "2026-05-17T17:48:28.122Z" }, -] - [[package]] name = "attrs" version = "26.1.0" @@ -831,7 +792,7 @@ wheels = [ [[package]] name = "eopf-geozarr" -version = "0.10.0" +version = "0.10.1" source = { editable = "." } dependencies = [ { name = "aiohttp" }, @@ -854,8 +815,8 @@ dependencies = [ [package.dev-dependencies] dev = [ { name = "bandit" }, - { name = "mypy" }, { name = "pre-commit" }, + { name = "pyright" }, { name = "pytest" }, { name = "pytest-cov" }, ] @@ -894,14 +855,14 @@ requires-dist = [ { name = "typing-extensions", specifier = ">=4.15.0" }, { name = "xarray", specifier = ">=2025.7.1" }, { name = "zarr", extras = ["cast-value-rs"], specifier = ">=3.2.0" }, - { name = "zarr-cm", specifier = ">=0.2.0" }, + { name = "zarr-cm", specifier = ">=0.4.1" }, ] [package.metadata.requires-dev] dev = [ { name = "bandit", extras = ["toml"], specifier = ">=1.7.0" }, - { name = "mypy", specifier = ">=1.0.0" }, { name = "pre-commit", specifier = ">=3.0.0" }, + { name = "pyright", specifier = ">=1.1.390" }, { name = "pytest", specifier = ">=7.0.0" }, { name = "pytest-cov", specifier = ">=4.0.0" }, ] @@ -1201,66 +1162,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/63/94/a8066f84d62ab666d61ef97deba1a33126e3e5c0c0da2c458ada17053ed6/jsondiff-2.2.1-py3-none-any.whl", hash = "sha256:b1f0f7e2421881848b1d556d541ac01a91680cfcc14f51a9b62cdf4da0e56722", size = 13440, upload-time = "2024-08-29T04:09:04.955Z" }, ] -[[package]] -name = "librt" -version = "0.11.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/d0/07c77e067f0838949b43bd89232c29d72efebb9d2801a9750184eb706b71/librt-0.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b87504f1690a23b9a2cca841191a04f83895d4fc2dd04df91d82b1a04ca2ad46", size = 144147, upload-time = "2026-05-10T18:15:53.227Z" }, - { url = "https://files.pythonhosted.org/packages/7a/24/8493538fa4f62f982686398a5b8f68008138a75086abdea19ade64bf4255/librt-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40071fc5fe0ce8daa6de616702314a01e1250711682b0523d6ab8d4525910cb3", size = 143614, upload-time = "2026-05-10T18:15:54.657Z" }, - { url = "https://files.pythonhosted.org/packages/ff/1e/f8bad050810d9171f34a1648ed910e56814c2ba61639f2bd53c6377ae24b/librt-0.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:137e79445c896a0ea7b265f52d23954e05b64222ee1af69e2cb34219067cbb67", size = 485538, upload-time = "2026-05-10T18:15:56.117Z" }, - { url = "https://files.pythonhosted.org/packages/c0/fe/3594ebfbaf03084ba4b120c9ba5c3183fd938a48725e9bbe6ff0a5159ad8/librt-0.11.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:cca6644054e78746d8d4ef238681f9c34ff8b584fe6b988ecebb8db3b15e622a", size = 479623, upload-time = "2026-05-10T18:15:57.544Z" }, - { url = "https://files.pythonhosted.org/packages/b0/da/5d1876984b3746c85dbd219dbfcb73c85f54ee263fd32e5b2a632ec14571/librt-0.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5b0eea49f5562861ee8d757a32ef7d559c1d35be2aaaa1ec28941d74c9ffc8a", size = 513082, upload-time = "2026-05-10T18:15:58.805Z" }, - { url = "https://files.pythonhosted.org/packages/19/6e/55bdf5d5ca00c3e18430690bf2c953d8d3ffd3c337418173d33dec985dc9/librt-0.11.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d1029d7e1ae1a7e647ed6fb5df8c4ce2dffefb7a9f5fd1376a4554d96dac09f", size = 508105, upload-time = "2026-05-10T18:16:00.2Z" }, - { url = "https://files.pythonhosted.org/packages/07/10/f1f23a7c595ee90ece4d35c851e5d104b1311a887ed1b4ac4c35bbd13da8/librt-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc3ce6b33c5828d9e80592011a5c584cb2ce86edbc4088405f70da47dc1d1b3b", size = 522268, upload-time = "2026-05-10T18:16:01.708Z" }, - { url = "https://files.pythonhosted.org/packages/b6/02/5720f5697a7f54b78b3aefbe20df3a48cedcff1276618c4aa481177942ed/librt-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:936c5995f3514a42111f20099397d8177c79b4d7e70961e396c6f5a0a3566766", size = 527348, upload-time = "2026-05-10T18:16:03.496Z" }, - { url = "https://files.pythonhosted.org/packages/50/db/b4a47c6f91db4ff76348a0b3dd0cc65e090a078b765a810a62ff9434c3d3/librt-0.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9bc0ca6ad9381cbe8e4aa6e5726e4c80c78115a6e9723c599ed1d73e092bc49d", size = 516294, upload-time = "2026-05-10T18:16:05.173Z" }, - { url = "https://files.pythonhosted.org/packages/9e/58/9384b2f4eb1ed1d273d40948a7c5c4b2360213b402ef3be4641c06299f9c/librt-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:070aa8c26c0a74774317a72df8851facc7f0f012a5b406557ac56992d92e1ec8", size = 553608, upload-time = "2026-05-10T18:16:06.839Z" }, - { url = "https://files.pythonhosted.org/packages/21/7b/5aa8848a7c6a9278c79375146da1812e695754ceec5f005e6043461a7315/librt-0.11.0-cp312-cp312-win32.whl", hash = "sha256:6bf14feb84b05ae945277395451998c89c54d0def4070eb5c08de544930b245a", size = 101879, upload-time = "2026-05-10T18:16:08.103Z" }, - { url = "https://files.pythonhosted.org/packages/37/33/8a745436944947575b584231750a41417de1a38cf6a2e9251d1065651c09/librt-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:75672f0bc524ede266287d532d7923dbce94c7514ad07627bac3d0c6d92cc4d9", size = 119831, upload-time = "2026-05-10T18:16:09.174Z" }, - { url = "https://files.pythonhosted.org/packages/59/67/a6739ac96e28b7855808bdb0370e250606104a859750d209e5a0716fe7ab/librt-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f10cf143e4a9bb0f4f5af568a00df94a2d69ef41c2579584454bb0fe5cc642c", size = 103470, upload-time = "2026-05-10T18:16:10.369Z" }, - { url = "https://files.pythonhosted.org/packages/82/61/e59168d4d0bf2bf90f4f0caf7a001bfc60254c3af4586013b04dc3ef517b/librt-0.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78dc31f7fdfe9c9d0eb0e8f42d139db230e826415bbcabd9f0e9faaaee909894", size = 144119, upload-time = "2026-05-10T18:16:11.771Z" }, - { url = "https://files.pythonhosted.org/packages/61/fd/caa1d60b12f7dd79ccea23054e06eeaebe266a5f52c40a6b651069200ce5/librt-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa475675db22290c3158e1d42326d0f5a65f04f44a0e68c3630a25b53560fb9c", size = 143565, upload-time = "2026-05-10T18:16:13.334Z" }, - { url = "https://files.pythonhosted.org/packages/b8/a9/dc744f5c2b4978d48db970be29f22716d3413d28b14ad99740817315cf2c/librt-0.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:621db29691044bdeda22e789e482e1b0f3a985d90e3426c9c6d17606416205ea", size = 485395, upload-time = "2026-05-10T18:16:14.729Z" }, - { url = "https://files.pythonhosted.org/packages/8f/21/7f8e97a1e4dae952a5a95948f6f8507a173bc1e669f54340bba6ca1ca31b/librt-0.11.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a9010e2ed5b3a9e158c5fd966b3ab7e834bb3d3aacc8f66c91dd4b57a3799230", size = 479383, upload-time = "2026-05-10T18:16:16.321Z" }, - { url = "https://files.pythonhosted.org/packages/a6/6d/d8ee9c114bebf2c50e29ec2aa940826fccb62a645c3e4c18760987d0e16d/librt-0.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c39513d8b7477a2e1ed8c43fc21c524e8d5a0f8d4e8b7b074dbdbe7820a08e2", size = 513010, upload-time = "2026-05-10T18:16:17.647Z" }, - { url = "https://files.pythonhosted.org/packages/f0/43/0b5708af2bd30a46400e72ba6bdaa8f066f15fb9a688527e34220e8d6c06/librt-0.11.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7aef3cf1d5af86e770ab04bfd993dfc4ae8b8c17f66fb77dd4a7d50de7bbb1a3", size = 508433, upload-time = "2026-05-10T18:16:19.309Z" }, - { url = "https://files.pythonhosted.org/packages/4a/50/356187247d09013490481033183b3532b58acf8028bcb34b2b56a375c9b2/librt-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:557183ddc36babe46b27dd60facbd5adb4492181a5be887587d57cda6e092f21", size = 522595, upload-time = "2026-05-10T18:16:20.642Z" }, - { url = "https://files.pythonhosted.org/packages/40/e7/c6ac4240899c7f3248079d5a9900debe0dadb3fdeaf856684c987105ba47/librt-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:83d3e1f72bd42f6c5c0b7daec530c3f829bd02db42c70b8ddf0c2d90a2459930", size = 527255, upload-time = "2026-05-10T18:16:22.352Z" }, - { url = "https://files.pythonhosted.org/packages/eb/b5/a81322dbeedeeaf9c1ee6f001734d28a09d8383ac9e6779bc24bbd0743c6/librt-0.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4ce1f21fbe589bc1afd7872dece84fb0e1144f794a288e58a10d2c54a55c43be", size = 516847, upload-time = "2026-05-10T18:16:23.627Z" }, - { url = "https://files.pythonhosted.org/packages/ae/66/6e6323787d592b55204a42595ff1102da5115601b53a7e9ddebc889a6da5/librt-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b09f7044ea2b64c9da42fd3d335666518cfd1c6e8a182c95da73d0214b41e", size = 553920, upload-time = "2026-05-10T18:16:25.025Z" }, - { url = "https://files.pythonhosted.org/packages/9c/21/623f8ca230857102066d9ca8c6c1734995908c4d0d1bee7bb2ef0021cb33/librt-0.11.0-cp313-cp313-win32.whl", hash = "sha256:78fddc31cd4d3caa897ad5d31f856b1faadc9474021ad6cb182b9018793e254e", size = 101898, upload-time = "2026-05-10T18:16:26.649Z" }, - { url = "https://files.pythonhosted.org/packages/b3/1d/b4ebd44dd723f768469007515cb92251e0ae286c94c140f374801140fa74/librt-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ca8aa88751a775870b764e93bad5135385f563cb8dcee399abf034ea4d3cb47", size = 119812, upload-time = "2026-05-10T18:16:27.859Z" }, - { url = "https://files.pythonhosted.org/packages/3b/e4/b2f4ca7965ca373b491cdb4bc25cdb30c1649ca81a8782056a83850292a9/librt-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:96f044bb325fd9cf1a723015638c219e9143f0dfbc0ca54c565df2b7fc748b44", size = 103448, upload-time = "2026-05-10T18:16:29.066Z" }, - { url = "https://files.pythonhosted.org/packages/29/eb/dbce197da4e227779e56b5735f2decc3eb36e55a1cdbf1bd65d6639d76c1/librt-0.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4a017a95e5837dc15a8c5661d60e05daa96b90908b1aa6b7acdf443cd25c8ebd", size = 143345, upload-time = "2026-05-10T18:16:30.674Z" }, - { url = "https://files.pythonhosted.org/packages/76/a3/254bebd0c11c8ba684018efb8006ff22e466abce445215cca6c778e7d9de/librt-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b1ecbd9819deccc39b7542bf4d2a740d8a620694d39989e58661d3763458f8d4", size = 143131, upload-time = "2026-05-10T18:16:32.037Z" }, - { url = "https://files.pythonhosted.org/packages/f1/3f/f77d6122d21ac7bf6ae8a7dfced1bd2a7ac545d3273ebdcaf8042f6d619f/librt-0.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7da327dacd7be8f8ec36547373550744a3cc0e536d54665cd83f8bcd961200e8", size = 477024, upload-time = "2026-05-10T18:16:33.493Z" }, - { url = "https://files.pythonhosted.org/packages/ac/0a/2c996dadebaa7d9bbbd43ef2d4f3e66b6da545f838a41694ef6172cebec8/librt-0.11.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0dc56b1f8d06e60db362cc3fdae206681817f86ce4725d34511473487f12a34b", size = 474221, upload-time = "2026-05-10T18:16:34.864Z" }, - { url = "https://files.pythonhosted.org/packages/0a/7e/f5d92af8486b8272c23b3e686b46ff72d89c8169585eb61eef01a2ac7147/librt-0.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05fb8fb2ab90e21c8d12ea240d744ad514da9baf381ebfa70d91d20d21713175", size = 505174, upload-time = "2026-05-10T18:16:36.705Z" }, - { url = "https://files.pythonhosted.org/packages/af/1a/cb0734fe86398eb33193ab753b7326255c74cac5eb09e76b9b16536e7adb/librt-0.11.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cae74872be221df4374d10fec61f93ed1513b9546ea84f2c0bf73ab3e9bd0b03", size = 497216, upload-time = "2026-05-10T18:16:38.418Z" }, - { url = "https://files.pythonhosted.org/packages/18/06/094820f91558b66e29943c0ec41c9914f460f48dd51fc503c3101e10842d/librt-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32bcc918c0148eb7e3d57385125bac7e5f9e4359d05f07448b09f6f778c2f31c", size = 513921, upload-time = "2026-05-10T18:16:39.848Z" }, - { url = "https://files.pythonhosted.org/packages/0b/c2/00de9018871a282f530cacb457d5ec0428f6ac7e6fedde9aff7468d9fb04/librt-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f9743fc99135d5f78d2454435615f6dec0473ca507c26ce9d92b10b562a280d3", size = 520850, upload-time = "2026-05-10T18:16:41.471Z" }, - { url = "https://files.pythonhosted.org/packages/51/9d/64631832348fd1834fb3a61b996434edddaaf25a31d03b0a76273159d2cf/librt-0.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5ba067f4aadae8fda802d91d2124c90c42195ff32d9161d3549e6d05cfe26f96", size = 504237, upload-time = "2026-05-10T18:16:43.15Z" }, - { url = "https://files.pythonhosted.org/packages/a5/ec/ae5525eb16edc827a044e7bb8777a455ff95d4bca9379e7e6bddd7383647/librt-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:de3bf945454d032f9e390b85c4072e0a0570bf825421c8be0e71209fa65e1abe", size = 546261, upload-time = "2026-05-10T18:16:44.408Z" }, - { url = "https://files.pythonhosted.org/packages/5a/09/adce371f27ca039411da9659f7430fcc2ba6cd0c7b3e4467a0f091be7fa9/librt-0.11.0-cp314-cp314-win32.whl", hash = "sha256:d2277a05f6dcb9fd13db9566aac4fabd68c3ea1ea46ee5567d4eef8efa495a2f", size = 96965, upload-time = "2026-05-10T18:16:46.039Z" }, - { url = "https://files.pythonhosted.org/packages/d6/ee/8ac720d98548f173c7ce2e632a7ca94673f74cacd5c8162a84af5b35958a/librt-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:ab73e8db5e3f564d812c1f5c3a175930a5f9bc96ccb5e3b22a34d7858b401cf7", size = 115151, upload-time = "2026-05-10T18:16:47.133Z" }, - { url = "https://files.pythonhosted.org/packages/94/20/c900cf14efeb09b6bef2b2dff20779f73464b97fd58d1c6bccc379588ae3/librt-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aea3caa317752e3a466fa8af45d91ee0ea8c7fdd96e42b0a8dd9b76a7931eba1", size = 98850, upload-time = "2026-05-10T18:16:48.597Z" }, - { url = "https://files.pythonhosted.org/packages/0c/71/944bfe4b64e12abffcd3c15e1cce07f72f3d55655083786285f4dedeb532/librt-0.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d1b36540d7aaf9b9101b3a6f376c8d8e9f7a9aec93ed05918f2c69d493ffef72", size = 151138, upload-time = "2026-05-10T18:16:49.839Z" }, - { url = "https://files.pythonhosted.org/packages/b6/10/99e64a5c86989357fda078c8143c533389585f6473b7439172dd8f3b3b2d/librt-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efbb343ab2ce3540f4ecbe6315d677ed70f37cd9a72b1e58066c918ca83acbaa", size = 151976, upload-time = "2026-05-10T18:16:51.062Z" }, - { url = "https://files.pythonhosted.org/packages/21/31/5072ad880946d83e5ea4147d6d018c78eefce85b77819b19bdd0ee229435/librt-0.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0dd688aab3f7914d3e6e5e3554978e0383312fb8e771d84be008a35b9ee548", size = 557927, upload-time = "2026-05-10T18:16:52.632Z" }, - { url = "https://files.pythonhosted.org/packages/5e/8d/70b5fb7cfbab60edbe7381614ab985da58e144fbf465c86d44c95f43cdca/librt-0.11.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f5fb36b8c6c63fdcbb1d526d94c0d1331610d43f4118cc1beb4efef4f3faacb2", size = 539698, upload-time = "2026-05-10T18:16:53.934Z" }, - { url = "https://files.pythonhosted.org/packages/fa/a3/ba3495a0b3edbd24a4cae0d1d3c64f39a9fc45d06e812101289b50c1a619/librt-0.11.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a9a237d13addb93715b6fee74023d5ee3469b53fce527626c0e088aa585805f", size = 577162, upload-time = "2026-05-10T18:16:55.589Z" }, - { url = "https://files.pythonhosted.org/packages/f7/db/36e25fb81f99937ff1b96612a1dc9fd66f039cb9cc3aee12c01fac31aab9/librt-0.11.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5ddd17bd87b2c56ddd60e546a7984a2e64c4e8eab92fb4cf3830a48ad5469d51", size = 566494, upload-time = "2026-05-10T18:16:56.975Z" }, - { url = "https://files.pythonhosted.org/packages/33/0d/3f622b47f0b013eeb9cf4cc07ae9bfe378d832a4eec998b2b209fe84244d/librt-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd43992b4473d42f12ff9e68326079f0696d9d4e6000e8f39a0238d482ba6ee2", size = 596858, upload-time = "2026-05-10T18:16:58.374Z" }, - { url = "https://files.pythonhosted.org/packages/a9/02/71b90bc93039c46a2000651f6ad60122b114c8f54c4ad306e0e96f5b75ad/librt-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:f8e3e8056dd674e279741485e2e512d6e9a751c7455809d0114e6ebf8d781085", size = 590318, upload-time = "2026-05-10T18:16:59.676Z" }, - { url = "https://files.pythonhosted.org/packages/04/04/418cb3f75621e2b761fb1ab0f017f4d70a1a72a6e7c74ee4f7e8d198c2f3/librt-0.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c1f708d8ae9c56cf38a903c44297243d2ec83fd82b396b977e0144a3e76217e3", size = 575115, upload-time = "2026-05-10T18:17:01.007Z" }, - { url = "https://files.pythonhosted.org/packages/cc/2c/5a2183ac58dd911f26b5d7e7d7d8f1d87fcecdddd99d6c12169a258ff62c/librt-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0add982e0e7b9fc14cf4b33789d5f13f66581889b88c2f58099f6ce8f92617bd", size = 617918, upload-time = "2026-05-10T18:17:02.682Z" }, - { url = "https://files.pythonhosted.org/packages/15/1f/dc6771a52592a4451be6effa200cbfc9cec61e4393d3033d81a9d307961d/librt-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:2b481d846ac894c4e8403c5fd0e87c5d11d6499e404b474602508a224ff531c8", size = 103562, upload-time = "2026-05-10T18:17:03.99Z" }, - { url = "https://files.pythonhosted.org/packages/62/4a/7d1415567027286a75ba1093ec4aca11f073e0f559c530cf3e0a757ad55c/librt-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:28edb433edde181112a908c78907af28f964eabc15f4dd16c9d66c834302677c", size = 124327, upload-time = "2026-05-10T18:17:05.465Z" }, - { url = "https://files.pythonhosted.org/packages/ce/62/b40b382fa0c66fee1478073eb8db352a4a6beda4a1adccf1df911d8c289c/librt-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dee008f20b542e3cd162ba338a7f9ec0f6d23d395f66fe8aeeec3c9d067ea253", size = 102572, upload-time = "2026-05-10T18:17:06.809Z" }, -] - [[package]] name = "locket" version = "1.0.0" @@ -1475,46 +1376,54 @@ wheels = [ [[package]] name = "msgpack" -version = "1.1.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" }, - { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" }, - { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" }, - { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" }, - { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" }, - { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" }, - { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" }, - { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" }, - { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, - { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, - { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, - { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, - { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, - { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, - { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, - { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, - { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, - { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, - { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, - { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, - { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, - { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, - { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, - { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, - { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, - { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, - { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, - { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, - { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, - { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, - { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, - { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, - { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, - { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, - { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, - { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", hash = "sha256:04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647", size = 183960, upload-time = "2026-06-18T16:13:52.594Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/dd/9e8cbd8f5582ca4b590336f2b91ee5662f6a6ca562b565abaf696a0f81ff/msgpack-1.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2ef59c659f289eddf8aa6623823f19fa2f40a4029266889eac7a2505dd210c35", size = 83531, upload-time = "2026-06-18T16:12:58.249Z" }, + { url = "https://files.pythonhosted.org/packages/50/2e/ebdb85a8da151397a2790363676b7ed7c125924fe618e4c6d8befb0cc62c/msgpack-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3567748a5107cb40cdf66a275430c2f87c07777698f4bfd25c35f44d533258c", size = 82657, upload-time = "2026-06-18T16:12:59.396Z" }, + { url = "https://files.pythonhosted.org/packages/26/aa/753ad8b007b464e1d8aa0c8e650b9c5f4f725e658fc5ac8a7635c55b7f6e/msgpack-1.2.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60926b75d00c8e816ef98f3034f484a8bc64242d66839cef4cf7e503142316a0", size = 410634, upload-time = "2026-06-18T16:13:00.383Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a", size = 419989, upload-time = "2026-06-18T16:13:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cc/85039b7b0eb168aaad7383a23c97e291a11f08351cb45a606ce865e4e3f1/msgpack-1.2.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4202c74688ca06591f78cb18988228bd4cca2cc75d57b60008372892d2f1e6e6", size = 377544, upload-time = "2026-06-18T16:13:03.637Z" }, + { url = "https://files.pythonhosted.org/packages/ed/bf/35963899493b32030c85fc513b723ae66144ac70c11ebc52e889e16e3d99/msgpack-1.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8b267ce94efb76fbd1b3373511420074ee3187f0f7811bf394531de13294735a", size = 400842, upload-time = "2026-06-18T16:13:05.012Z" }, + { url = "https://files.pythonhosted.org/packages/a6/df/8e2ac970c8f99264cd9997d1c73df5466bc19da3301d7dc5500862a9b089/msgpack-1.2.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e4f1d0f8f98ade9634e01fb704a408f9336c0a8f1117b369f5db83dc7551d8b1", size = 374108, upload-time = "2026-06-18T16:13:06.232Z" }, + { url = "https://files.pythonhosted.org/packages/17/dd/fa8bd265110dfa51c20cb529f9e6d240a16fafe7e645004c6af2d01353ba/msgpack-1.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f02cf17a6ca1abe29b5f980644f7551f94d71f2011509b26d8625ce038f0df64", size = 414939, upload-time = "2026-06-18T16:13:07.478Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b9/8377a5ad8953fc0437c70cc98d9ae29f27fe5ac5109fbec0812085865735/msgpack-1.2.1-cp312-cp312-win32.whl", hash = "sha256:0c0d9802354507bcba62af19c17918e3eb437cc25e6f50657d511b5856a77aac", size = 64504, upload-time = "2026-06-18T16:13:08.822Z" }, + { url = "https://files.pythonhosted.org/packages/57/7f/ce1e377df7e62461fefd9eb23bfb93a4a523f40a517b377b8f844d836828/msgpack-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:5c24aa15d5963051e1a5c62b12c50cd705992502b5ec1f3bece6046f33c9fc24", size = 71421, upload-time = "2026-06-18T16:13:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/8f/32/ebfe84c9929f08f188d56c7a2fd913406a9ddad76a634697c1c43b8112e6/msgpack-1.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:4227224aaec8f7fbcbfbd4272319347b2bb4030366502600f8c45588c5187b07", size = 64775, upload-time = "2026-06-18T16:13:11.056Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ac/dcddcab6f6c20ecb387ca5e980371cdb3f87ff69aeca388be97eebc4c074/msgpack-1.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0a70e3cf2804a300d921bb0940426e35f4e489a23adfb77a808892241db0a064", size = 83151, upload-time = "2026-06-18T16:13:12.173Z" }, + { url = "https://files.pythonhosted.org/packages/64/71/fbcfa83a1d6a9c6091942d1cfd070962244664b87427a9a49a6897b1b219/msgpack-1.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:491cc39455ca765fad51fb451bf2915eb2cf41192ab5801ce8d67c1d614fe056", size = 82351, upload-time = "2026-06-18T16:13:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/e3/10/ddf7b06db879e8792d13934ddda09ff20bd2a583fd84c9b59aae9b0e650b/msgpack-1.2.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f310233ef7fb9c14e201c93639fe5f5260b005f56f0b29048e999c30935596cc", size = 407518, upload-time = "2026-06-18T16:13:14.233Z" }, + { url = "https://files.pythonhosted.org/packages/79/d3/36a46a8ed992b781acbc05928bd5bee3c810cb0c3563bf81a7b0c04a1a76/msgpack-1.2.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:787c9bebb5833e8f6fc8abca3c0597683d8d87f56a8842b6b89c75a5f3176e2d", size = 416405, upload-time = "2026-06-18T16:13:15.435Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/e8e9598b557c0ba6ddae901a73780a4c75ac667dddf59414b1e56a42fb34/msgpack-1.2.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc871b997a9370d855b7394465f2f350e847a5b806dd38dcc9c989e7d87da155", size = 376257, upload-time = "2026-06-18T16:13:17.022Z" }, + { url = "https://files.pythonhosted.org/packages/40/16/738fe6d875ad7e2a9429c165322a4ec088f4f273cdfae63d96a89c467961/msgpack-1.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:85f57e960d877f2977f6430896191b04a21f8901b3b4baf2e4604329f4db5402", size = 397469, upload-time = "2026-06-18T16:13:18.287Z" }, + { url = "https://files.pythonhosted.org/packages/ca/be/6d5952df75a7f24f35833af764c3a6860780364cb3a0030beb8099e1b2b4/msgpack-1.2.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1233ee2dd0cefba127583de50ea654677277047d238303521db35def3d7b2e7c", size = 372802, upload-time = "2026-06-18T16:13:19.685Z" }, + { url = "https://files.pythonhosted.org/packages/e1/39/e2ef7dbf0473bcb8dc7c50bf782a892d67414877b63e47fc88eb189ef5e6/msgpack-1.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3dc2feb0876209d9c38aa56cb1de169bd6c4348f1aa48271f241226590993e6", size = 411273, upload-time = "2026-06-18T16:13:21.028Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c5/133f4512a56e983a93445c836c9d94d88f3bc2e0980ff4b9e577bd8416ce/msgpack-1.2.1-cp313-cp313-win32.whl", hash = "sha256:6d09badf350af2be9d189184e04e64cf54ad93569ab3d96fca58bd3e84aad707", size = 64471, upload-time = "2026-06-18T16:13:22.293Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/577e10b055096a7dd40732358cabaf7180a20c79ed1dcdbb618e4b9deac7/msgpack-1.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:33f14fba63278b714efe6ad07e50ea5f03d91537aa6a1c5f1ceca4cf44013ca9", size = 71274, upload-time = "2026-06-18T16:13:23.455Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ee/0c0048e7cfbef23c6a94791b8959ab28155232e7956de8a305b5ff588f05/msgpack-1.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc5febcd4c99effbc02b528e49d6fd0760b2b7d48c05239e345a5fa6e743d9a", size = 64795, upload-time = "2026-06-18T16:13:24.687Z" }, + { url = "https://files.pythonhosted.org/packages/77/58/cce442852c6b9e1639c7c8ac8fd9143121cb32dab0f308df4d1426a8eb9c/msgpack-1.2.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:05f340e47e7e47d2da8db9b53e1bb1d294369e9ef45a747441309f6650b8351d", size = 83610, upload-time = "2026-06-18T16:13:25.724Z" }, + { url = "https://files.pythonhosted.org/packages/60/5c/15b4c7a0182f75ffa90751958ba36a9c01cafee367d49a3edc10ed140b01/msgpack-1.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:810b916696c86ef0deb3b74588480224df4c1b071136c34183e4a2a4284d7ac7", size = 83138, upload-time = "2026-06-18T16:13:26.781Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a6/99e58722feaffc5f2fbcc0c8c0d1451ab9f84097f7af87291b46af2390f4/msgpack-1.2.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ca0dacff965c47afdc3749a8469d7302a8f801d6a28758d55120d75e66ce6889", size = 406090, upload-time = "2026-06-18T16:13:28.072Z" }, + { url = "https://files.pythonhosted.org/packages/19/03/8c63e8cf52958534ef688625965ab04c269a6cadd8caef16758b380a821a/msgpack-1.2.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e2bf9280bceb5efca998435904b5d3e9fdbcc11d90dc9df30aec7973252b720", size = 412106, upload-time = "2026-06-18T16:13:29.427Z" }, + { url = "https://files.pythonhosted.org/packages/63/d2/155d9e71b40e41fd934bc0c48b9b2770f22263e1ac20aad8e29fdca7be3f/msgpack-1.2.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa6c4be5d1c02a42b066ca6ddb71adf36432868fdcdb6ee87e634e86e0674190", size = 374851, upload-time = "2026-06-18T16:13:30.631Z" }, + { url = "https://files.pythonhosted.org/packages/98/48/deaf2326262a8d5ea3295ce9649912ecd3f551ba7ec8e33c665d2ba583f3/msgpack-1.2.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec0e675d59150a6269ddc9139087c722292664a37d071a849c05c473350f1f2d", size = 396168, upload-time = "2026-06-18T16:13:31.977Z" }, + { url = "https://files.pythonhosted.org/packages/10/2a/b4410f906c2ec0008f1608d3ab5143afc3ad3f4e6da0fed3ea2231d0bef4/msgpack-1.2.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:dd3bfe82d53edfe4b7fc9a7ec9761e23a7a5b1dac22264505af428253c29ed24", size = 371959, upload-time = "2026-06-18T16:13:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/59/86/1edc67270099a528fa2093ea60fe191233cd238e4bd30cfacf7db79fc959/msgpack-1.2.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5ad5467fc3f68b5468e06c5f788d712e9f8ffc8b0cd1bcb160c105c1ee92dae7", size = 408457, upload-time = "2026-06-18T16:13:34.567Z" }, + { url = "https://files.pythonhosted.org/packages/82/90/8b630fef07d8c5ab457b71ff2c217910c83d333c7a68472c186e87cc504a/msgpack-1.2.1-cp314-cp314-win32.whl", hash = "sha256:98b58bdb89c46190e4609bb36abe17c6d4105ad13f9c5f8f6f64d320f8ced3fb", size = 65942, upload-time = "2026-06-18T16:13:36.056Z" }, + { url = "https://files.pythonhosted.org/packages/16/f1/467b81e98b24dd3885d7b1857728797b4ffc76a7a7483af4fb321a07de3c/msgpack-1.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:74847557e28ce71bd3c438a447ca90e4b507e997ddbdef8a12a7b283b86c156b", size = 72627, upload-time = "2026-06-18T16:13:37.079Z" }, + { url = "https://files.pythonhosted.org/packages/a7/1d/5d8c4c89985feb6acefb82a09e501c60392261856d2408d20bfe4f0360b1/msgpack-1.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:b50b727bd652bdc37d950336c848ef20ec54a4cafc38dce19b1cd86ad625d0f7", size = 66908, upload-time = "2026-06-18T16:13:38.23Z" }, + { url = "https://files.pythonhosted.org/packages/1b/02/ad2afb678b4de94496cd432b581759b756a92c1192d8c767edd6b132efdc/msgpack-1.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8d00f177ca88a77c1cf848d204a38f249751650b601cb6532acc68805d8a8273", size = 86000, upload-time = "2026-06-18T16:13:39.44Z" }, + { url = "https://files.pythonhosted.org/packages/54/74/0b797484013128837f3b1cbb6cea019277c4de4e377dc512b4d9a0f92940/msgpack-1.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5bb9c386f0a329c035ddbab4b72d1028bf9627add8dda41070288563d57ed1b1", size = 86544, upload-time = "2026-06-18T16:13:40.447Z" }, + { url = "https://files.pythonhosted.org/packages/a9/b4/b774d7eb95561739907fec675582f83203cf41c597a418c2589b4bfb8e9d/msgpack-1.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20466cca18c49c7292a8984bc15d65857b171e7264bdcb5f96baf8be238791fc", size = 427661, upload-time = "2026-06-18T16:13:41.574Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f9/3243191dc9937e00756c8bc1b0272fed8f23758e43df2a3b46f533e5090f/msgpack-1.2.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:196300e7e5d6e74d50f1607ab9c06c4a1484c383cd22defd727902591f7e8dde", size = 426375, upload-time = "2026-06-18T16:13:42.936Z" }, + { url = "https://files.pythonhosted.org/packages/23/c7/1693111db9944ba4ad4b67a1e788400d78a0b6af7a6523dc7e4e58f8274b/msgpack-1.2.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575957e79cd51903a4e8495a242442949641e08f1efd5197b43bebd3ea7682b4", size = 380495, upload-time = "2026-06-18T16:13:44.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/2b/92f86956a0c13e8662f7e2ad630c4eb4db07497b967589bd5245e018b2c1/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8c2ed1e48cc0f460bf3c7780e7137ff21a4e18433451916f2442c1b21036cd7d", size = 410897, upload-time = "2026-06-18T16:13:45.629Z" }, + { url = "https://files.pythonhosted.org/packages/da/ea/1479f72d200313a76fc2f823a79d1e07ed052ab7b8a0280640aa7b95de42/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5f6277e5f783c36786a145e0247fc189a03f35f84b251646e53592d2bc12b355", size = 378519, upload-time = "2026-06-18T16:13:46.998Z" }, + { url = "https://files.pythonhosted.org/packages/f5/4d/fa006060ffa1011d32bfae826fe766fe73e02982183601633b7121058ab3/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9389552ecf4784886345ead0647e4edc96bee37cbab05b75540f542f766c48c", size = 419815, upload-time = "2026-06-18T16:13:48.205Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/aab6c946570496b78e67804721f3d5e2d62a93081b9b37df77764ef56347/msgpack-1.2.1-cp314-cp314t-win32.whl", hash = "sha256:c1c79a604a2969a868a78b6ebd27a887e00c624f14f66b3038e0590cb23332d1", size = 70914, upload-time = "2026-06-18T16:13:49.385Z" }, + { url = "https://files.pythonhosted.org/packages/13/0a/e608956488a2af014cfe6e3d665e090b8ee42aa14b07f8f95b8880d66b09/msgpack-1.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f12038a35fabd52e56a3547bab42401af49a45caa6dd00b34c44de235bc93ee2", size = 77999, upload-time = "2026-06-18T16:13:50.467Z" }, + { url = "https://files.pythonhosted.org/packages/d2/8a/27e2e57055176e366a46b85d02d68e7a5bcfbdd8474c9706375d965f24d3/msgpack-1.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0adcf06ffde0777c0e1a9b771a2b1c4226ba1bbf748c8efcc02fcdeca3299107", size = 71160, upload-time = "2026-06-18T16:13:51.498Z" }, ] [[package]] @@ -1616,50 +1525,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] -[[package]] -name = "mypy" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ast-serialize" }, - { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, - { name = "mypy-extensions" }, - { name = "pathspec" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/82/15/cca9d88503549ed6fedeaa1d448cdddd542ee8a490232d732e278036fbf2/mypy-2.1.0.tar.gz", hash = "sha256:81e76ad12c2d804512e9b13240d1588316531bfba07558286078bfbce9613633", size = 3898359, upload-time = "2026-05-11T18:37:36.237Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/95/b1/55861beb5c339b44f9a2ba92df9e2cb1eeb4ae1eee674cdf7772c797778b/mypy-2.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:244358bf1c0da7722230bce60683d52e8e9fd030554926f15b747a84efb5b3af", size = 14874381, upload-time = "2026-05-11T18:37:31.784Z" }, - { url = "https://files.pythonhosted.org/packages/0b/b3/b7f770114b7d0ac92d0f76e8d93c2780844a70488a90e91821927850da86/mypy-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ec7c57657493c7a75534df2751c8ae2cda383c16ecc55d2106c54476b1b16f6", size = 13665501, upload-time = "2026-05-11T18:34:23.063Z" }, - { url = "https://files.pythonhosted.org/packages/b6/f3/8ae2037967e2126689a0c11d99e2b707134a565191e92c60ca2572aec60a/mypy-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8161b6ff4392410023224f0969d17db93e1e154bc3e4ba62598e720723ae211", size = 14045750, upload-time = "2026-05-11T18:31:48.151Z" }, - { url = "https://files.pythonhosted.org/packages/a0/32/615eb5911859e43d054941b0d0a7d06cfa2870eba86529cf385b052b111c/mypy-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf03e12003084a67395184d3eb8cbd6a489dc3655b5664b28c210a9e2403ab0b", size = 15061630, upload-time = "2026-05-11T18:37:06.898Z" }, - { url = "https://files.pythonhosted.org/packages/d4/03/4eafbfff8bfab1b87082741eae6e6a624028c984e6708b73bce2a8570c9d/mypy-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:20509760fd791c51579d573153407d226385ec1f8bcce55d730b354f3336bc22", size = 15288831, upload-time = "2026-05-11T18:31:18.07Z" }, - { url = "https://files.pythonhosted.org/packages/99/ee/919661478e5891a3c96e549c036e467e64563ab85995b10c53c8358e16a3/mypy-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:6753d0c1fdd6b1a23b9e4f283ce80b2153b724adcb2653b20b85a8a28ac6436b", size = 11135228, upload-time = "2026-05-11T18:34:31.23Z" }, - { url = "https://files.pythonhosted.org/packages/24/0a/6a12b9782ca0831a553192f351679f4548abc9d19a7cc93bb7feb02084c7/mypy-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:98ebb6589bb3b6d0c6f0c459d53ca55b8091fbc13d277c4041c885392e8195e8", size = 10040684, upload-time = "2026-05-11T18:36:48.199Z" }, - { url = "https://files.pythonhosted.org/packages/6e/dd/c7191469c777f07689c032a8f7326e393ea34c92d6d76eb7ce5ba57ea66d/mypy-2.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35aac3bb114e03888f535d5eb51b8bafbb3266586b599da1940f9b1be3ec5bd5", size = 14852174, upload-time = "2026-05-11T18:31:38.929Z" }, - { url = "https://files.pythonhosted.org/packages/55/8c/aed55408879043d72bb9135f4d0d19a02b886dd569631e113e3d2706cb8d/mypy-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8de55a8c861f2a49331f807be98d90caeceeef520bde13d43a160207f8af613e", size = 13651542, upload-time = "2026-05-11T18:36:04.636Z" }, - { url = "https://files.pythonhosted.org/packages/3a/8e/f371a824b1f1fa8ea6e3dbb8703d232977d572be2329554a3bc4d960302f/mypy-2.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fdf2941a07434af755837d9880f7d7d25f1dacb1af9dcd4b9b66f2220a3024e", size = 14033929, upload-time = "2026-05-11T18:35:55.742Z" }, - { url = "https://files.pythonhosted.org/packages/94/21/f54be870d6dd53a82c674407e0f8eed7174b05ec78d42e5abd7b42e84fd5/mypy-2.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e195b817c13f02352a9c124301f9f30f078405444679b6753c1b96b6eed37285", size = 15039200, upload-time = "2026-05-11T18:33:10.281Z" }, - { url = "https://files.pythonhosted.org/packages/17/99/bf21748626a40ce59fd29a39386ab46afec88b7bd2f0fa6c3a97c995523f/mypy-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5431d42af987ebd92ba2f71d45c85ed41d8e6ca9f5fd209a69f68f707d2469e5", size = 15272690, upload-time = "2026-05-11T18:32:07.205Z" }, - { url = "https://files.pythonhosted.org/packages/d6/d7/9e90d2cf47100bea550ed2bc7b0d4de3a62181d84d5e37da0003e8462637/mypy-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:767fe8c66dc3e01e19e1737d4c38ebefead16125e1b8e58ad421903b376f5c65", size = 11147435, upload-time = "2026-05-11T18:33:56.477Z" }, - { url = "https://files.pythonhosted.org/packages/ec/46/e5c449e858798e35ffc90946282a27c62a77be743fe17480e4977374eb91/mypy-2.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:ecfe70d43775ab99562ab128ce49854a362044c9f894961f68f898c23cb7429d", size = 10035052, upload-time = "2026-05-11T18:32:30.049Z" }, - { url = "https://files.pythonhosted.org/packages/b0/ca/b279a672e874aedd5498ae25f722dacc8aa86bbffb939b3f97cbb1cf6686/mypy-2.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7354c5a7f69d9345c3d6e69921d57088eea3ddeeb6b20d34c1b3855b02c36ec2", size = 14848422, upload-time = "2026-05-11T18:35:45.984Z" }, - { url = "https://files.pythonhosted.org/packages/27/e6/3efe56c631d959b9b4454e208b0ac4b7f4f58b404c89f8bec7b49efdfc21/mypy-2.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:49890d4f76ac9e06ec117f9e09f3174da70a620a0c300953d8595c926e80947f", size = 13677374, upload-time = "2026-05-11T18:36:57.188Z" }, - { url = "https://files.pythonhosted.org/packages/84/7f/8107ea87a44fd1f1b59882442f033c9c3488c127201b1d1d15f1cbd6022e/mypy-2.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:761be68e023ef5d94678772396a8af1220030f80837a3afd8d0aef3b419666f4", size = 14055743, upload-time = "2026-05-11T18:35:18.361Z" }, - { url = "https://files.pythonhosted.org/packages/51/4d/b6d34db183133b83761b9199a82d31557cdbb70a380d8c3b3438e11882a3/mypy-2.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c90345fc182dc363b891350457ec69c35140858538f38b4540845afcc32b1aef", size = 15020937, upload-time = "2026-05-11T18:34:59.618Z" }, - { url = "https://files.pythonhosted.org/packages/ff/d7/f08360c691d758acb02f45022c34d98b92892f4ea756644e1000d4b9f3d8/mypy-2.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b84802e7b5a6daf1f5e15bc9fcd7ddae77be13981ffab037f1c67bb84d67d135", size = 15253371, upload-time = "2026-05-11T18:36:41.081Z" }, - { url = "https://files.pythonhosted.org/packages/67/1b/09460a13719530a19bce27bd3bc8449e83569dd2ba7faf51c9c3c30c0b61/mypy-2.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:022c771234936ceac541ebaf836fe9e2abeb3f5e09aff21588fe543ff006fe21", size = 11326429, upload-time = "2026-05-11T18:34:13.526Z" }, - { url = "https://files.pythonhosted.org/packages/40/62/75dbf0f82f7b6680340efc614af29dd0b3c17b8a4f1cd09b8bd2fd6bc814/mypy-2.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:498207db725cec88829a6a5c2fc771205fd043719ef98bc49aba8fb9fc4e6d57", size = 10218799, upload-time = "2026-05-11T18:32:23.491Z" }, - { url = "https://files.pythonhosted.org/packages/b2/66/caca04ed7d972fb6eb6dd1ccd6df1de5c38fae8c5b3dc1c4e8e0d85ee6b9/mypy-2.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d5e5cad0efeba72b93cd17490cc0d69c5ac9ca132994fe3fb0314808aeeb83e", size = 15923458, upload-time = "2026-05-11T18:35:28.64Z" }, - { url = "https://files.pythonhosted.org/packages/ed/52/2d90cbe49d014b13ed7ff337930c30bad35893fe38a1e4641e756bb62191/mypy-2.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ff715050c127d724fd260a2e666e7747fdd83511c0c47d449d98238970aef780", size = 14757697, upload-time = "2026-05-11T18:36:14.208Z" }, - { url = "https://files.pythonhosted.org/packages/ac/37/d98f4a14e081b238992d0ed96b6d39c7cc0148c9699eb71eaa68629665ea/mypy-2.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82208da9e09414d520e912d3e462d454854bed0810b71540bb016dcbca7308fd", size = 15405638, upload-time = "2026-05-11T18:33:48.249Z" }, - { url = "https://files.pythonhosted.org/packages/a3/c2/15c46613b24a84fad2aea1248bf9619b99c2767ae9071fe224c179a0b7d4/mypy-2.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e79ebc1b904b84f0310dff7469655a9c36c7a68bddb37bdd42b67a332df61d08", size = 16215852, upload-time = "2026-05-11T18:32:50.296Z" }, - { url = "https://files.pythonhosted.org/packages/5c/90/9c16a57f482c76d25f6379762b56bbf65c711d8158cf271fb2802cfb0640/mypy-2.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e583edc957cfb0deb142079162ae826f58449b116c1d442f2d91c69d9fced081", size = 16452695, upload-time = "2026-05-11T18:33:38.182Z" }, - { url = "https://files.pythonhosted.org/packages/0f/4c/215a4eeb63cacc5f17f516691ea7285d11e249802b942476bff15922a314/mypy-2.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b33b6cd332695bba180d55e717a79d3038e479a2c49cc5eb3d53603409b9a5d7", size = 12866622, upload-time = "2026-05-11T18:34:39.945Z" }, - { url = "https://files.pythonhosted.org/packages/4b/50/1043e1db5f455ffe4c9ab22747cd8ca2bc492b1e4f4e21b130a44ee2b217/mypy-2.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:4f910fe825376a7b66ef7ca8c98e5a149e8cd64c19ae71d84047a74ee060d4e6", size = 10610798, upload-time = "2026-05-11T18:36:31.444Z" }, - { url = "https://files.pythonhosted.org/packages/0d/2a/13ca1f292f6db1b98ff495ef3467736b331621c5917cad984b7043e7348d/mypy-2.1.0-py3-none-any.whl", hash = "sha256:a663814603a5c563fb87a4f96fb473eeb30d1f5a4885afcf44f9db000a366289", size = 2693302, upload-time = "2026-05-11T18:31:29.246Z" }, -] - [[package]] name = "mypy-extensions" version = "1.1.0" @@ -2310,6 +2175,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/73/a7141a1a0559bf1a7aa42a11c879ceb19f02f5c6c371c6d57fd86cefd4d1/pyproj-3.7.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d9d25bae416a24397e0d85739f84d323b55f6511e45a522dd7d7eae70d10c7e4", size = 6391844, upload-time = "2025-08-14T12:05:40.745Z" }, ] +[[package]] +name = "pyright" +version = "1.1.410" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nodeenv" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/53/e4d8ea1391bd4355231be6f91bf239479aa0014260ed3fb5526eeb12a1f2/pyright-1.1.410.tar.gz", hash = "sha256:07a073b8ba6749826773c1269773efa11b93440d9a6aa60419d9a3172d6dc488", size = 4062013, upload-time = "2026-06-01T17:35:48.894Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/33/288b5868fa00846dacf249633719d747893e54aebd196b9968ac1878a5d3/pyright-1.1.410-py3-none-any.whl", hash = "sha256:5e961bed37cacf96b3f7cd7b1da39b350a9239aa2e69138d0e88f728cfaf296c", size = 6082448, upload-time = "2026-06-01T17:35:46.387Z" }, +] + [[package]] name = "pystac" version = "1.14.3" @@ -2849,19 +2727,19 @@ wheels = [ [[package]] name = "tornado" -version = "6.5.5" +version = "6.5.7" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f8/f1/3173dfa4a18db4a9b03e5d55325559dab51ee653763bb8745a75af491286/tornado-6.5.5.tar.gz", hash = "sha256:192b8f3ea91bd7f1f50c06955416ed76c6b72f96779b962f07f911b91e8d30e9", size = 516006, upload-time = "2026-03-10T21:31:02.067Z" } +sdist = { url = "https://files.pythonhosted.org/packages/64/24/95ec527ad67b76d59299e5465b3935d05e4294b7e0290a3924b7487df30b/tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2", size = 519252, upload-time = "2026-06-08T17:34:51.232Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/59/8c/77f5097695f4dd8255ecbd08b2a1ed8ba8b953d337804dd7080f199e12bf/tornado-6.5.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:487dc9cc380e29f58c7ab88f9e27cdeef04b2140862e5076a66fb6bb68bb1bfa", size = 445983, upload-time = "2026-03-10T21:30:44.28Z" }, - { url = "https://files.pythonhosted.org/packages/ab/5e/7625b76cd10f98f1516c36ce0346de62061156352353ef2da44e5c21523c/tornado-6.5.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:65a7f1d46d4bb41df1ac99f5fcb685fb25c7e61613742d5108b010975a9a6521", size = 444246, upload-time = "2026-03-10T21:30:46.571Z" }, - { url = "https://files.pythonhosted.org/packages/b2/04/7b5705d5b3c0fab088f434f9c83edac1573830ca49ccf29fb83bf7178eec/tornado-6.5.5-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e74c92e8e65086b338fd56333fb9a68b9f6f2fe7ad532645a290a464bcf46be5", size = 447229, upload-time = "2026-03-10T21:30:48.273Z" }, - { url = "https://files.pythonhosted.org/packages/34/01/74e034a30ef59afb4097ef8659515e96a39d910b712a89af76f5e4e1f93c/tornado-6.5.5-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:435319e9e340276428bbdb4e7fa732c2d399386d1de5686cb331ec8eee754f07", size = 448192, upload-time = "2026-03-10T21:30:51.22Z" }, - { url = "https://files.pythonhosted.org/packages/be/00/fe9e02c5a96429fce1a1d15a517f5d8444f9c412e0bb9eadfbe3b0fc55bf/tornado-6.5.5-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3f54aa540bdbfee7b9eb268ead60e7d199de5021facd276819c193c0fb28ea4e", size = 448039, upload-time = "2026-03-10T21:30:53.52Z" }, - { url = "https://files.pythonhosted.org/packages/82/9e/656ee4cec0398b1d18d0f1eb6372c41c6b889722641d84948351ae19556d/tornado-6.5.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36abed1754faeb80fbd6e64db2758091e1320f6bba74a4cf8c09cd18ccce8aca", size = 447445, upload-time = "2026-03-10T21:30:55.541Z" }, - { url = "https://files.pythonhosted.org/packages/5a/76/4921c00511f88af86a33de770d64141170f1cfd9c00311aea689949e274e/tornado-6.5.5-cp39-abi3-win32.whl", hash = "sha256:dd3eafaaeec1c7f2f8fdcd5f964e8907ad788fe8a5a32c4426fbbdda621223b7", size = 448582, upload-time = "2026-03-10T21:30:57.142Z" }, - { url = "https://files.pythonhosted.org/packages/2c/23/f6c6112a04d28eed765e374435fb1a9198f73e1ec4b4024184f21faeb1ad/tornado-6.5.5-cp39-abi3-win_amd64.whl", hash = "sha256:6443a794ba961a9f619b1ae926a2e900ac20c34483eea67be4ed8f1e58d3ef7b", size = 448990, upload-time = "2026-03-10T21:30:58.857Z" }, - { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, + { url = "https://files.pythonhosted.org/packages/02/dc/c7043cab6fed8ae159fc1923ce829ada35c4dbd797d408a43858ffaf9639/tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163", size = 448543, upload-time = "2026-06-08T17:34:38.052Z" }, + { url = "https://files.pythonhosted.org/packages/92/4f/090b1431e5a43df696feceffc268c5383cc079ecb5f08ce58f917109aafe/tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100", size = 446707, upload-time = "2026-06-08T17:34:39.594Z" }, + { url = "https://files.pythonhosted.org/packages/37/d8/ef374952fd5da67d4463122c2b8e5a96536ec10b4b339254c6dcde81d01c/tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972", size = 449774, upload-time = "2026-06-08T17:34:41.204Z" }, + { url = "https://files.pythonhosted.org/packages/35/37/d434c73f4c6e014b745b9b37085f34f40c022f007efff3d7fe65991899f3/tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b", size = 450745, upload-time = "2026-06-08T17:34:42.531Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2b/56b9aff361d7f1ab728a805ec7d7ea835f8807afa9f5cc690ea0e630efb9/tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92", size = 450578, upload-time = "2026-06-08T17:34:43.787Z" }, + { url = "https://files.pythonhosted.org/packages/02/30/a7444fb23aa76860a14198fab96ac79f1866b0a6e19e26c4381b0938e50f/tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5", size = 449985, upload-time = "2026-06-08T17:34:45.326Z" }, + { url = "https://files.pythonhosted.org/packages/5c/42/5f0e56c01e8d9d36f4e23f367b85ae6cae0c1ecddd5e6977d8388ad27488/tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4", size = 451047, upload-time = "2026-06-08T17:34:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/b393076ffb21b469eec5b328a0534cf03a3b90bfc6b1f09507cdd075d938/tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4", size = 451485, upload-time = "2026-06-08T17:34:48.248Z" }, + { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, ] [[package]] @@ -3157,11 +3035,14 @@ cast-value-rs = [ [[package]] name = "zarr-cm" -version = "0.2.0" +version = "0.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/40/99c941d23a7cd84fb194b3eaa2ca2d0d85f5135aa07e2c4f2c12febfef43/zarr_cm-0.2.0.tar.gz", hash = "sha256:737f5b181e8a2456643c423f49b59d879531498c13c7345860f0e718ef73d8a8", size = 24773, upload-time = "2026-02-06T14:47:57.588Z" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f9/c6/51d38cafa07bdf725c77a67719647eea43255f925fda062b40799bbb361d/zarr_cm-0.4.1.tar.gz", hash = "sha256:693d24ca2b8e3a7230e1ed448c2c57f98833b81e5899607b6cb4a7ac31f94002", size = 50839, upload-time = "2026-06-21T19:20:36.277Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/54/60/06c371c10a321db63ec46634c9498a3c491754214c0e3bfc27410c528d99/zarr_cm-0.2.0-py3-none-any.whl", hash = "sha256:7f4c778d70d37ccb6e10e1509f4c0a488689027dcebcd6b64fa89a899f101e11", size = 14222, upload-time = "2026-02-06T14:47:56.465Z" }, + { url = "https://files.pythonhosted.org/packages/e8/14/3de8976647909b2f6764b8d0c9add0a961667ef4ab46f3f99e12d7a522fa/zarr_cm-0.4.1-py3-none-any.whl", hash = "sha256:2c7f36383af2e6f75eb274a797a13154fd5c5827390de7c79294dfeb9f0543ee", size = 33005, upload-time = "2026-06-21T19:20:35.05Z" }, ] [[package]] From c774b853e7cad7123b1ddf9ac2080b1f9e65ba79 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 12:51:00 +0200 Subject: [PATCH 25/58] fix(s3-olci): open raw input in convert auto-detect path; guard overview rounding MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The OLCI auto-detect branch of convert_command passed the CF-decoded DataTree (mask_and_scale=True default) to convert_olci_optimized, whose documented precondition is raw uint16 radiance with scale_factor / _FillValue in attrs. Fill-aware masking in reduce_swath then saw no _FillValue, and np.round quantized decoded physical radiance in every overview level. Re-open the input with mask_and_scale=False in that branch, matching convert_s3_olci_optimized_command, and round in reduce_swath only when packing back into an integer dtype. Also include nested ancillary groups (e.g. conditions/geometry) in the DataTree returned by convert_olci_optimized — they were silently absent because only top-level groups with direct arrays were assembled — and add a routing test asserting the OLCI converter is selected and receives packed (non-CF-decoded) input. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 15 +++++++- .../s3_olci_optimization/olci_converter.py | 35 +++++++++++-------- .../s3_olci_optimization/olci_multiscale.py | 9 +++-- tests/test_cli_convert_routing.py | 35 +++++++++++++++++++ 4 files changed, 77 insertions(+), 17 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 02d37ff6..a54335c5 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -223,8 +223,21 @@ def convert_command(args: argparse.Namespace) -> None: ) elif _is_sentinel3_olci_input(dt): log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + # convert_olci_optimized requires raw (non-mask-scaled) input: + # radiance must stay packed uint16 with CF scale_factor/add_offset + # and _FillValue in .attrs (see _clear_encoding / reduce_swath). + # The tree above was opened with CF decoding on for detection and + # the generic path, so re-open it raw, matching + # convert_s3_olci_optimized_command. + dt_raw = xr.open_datatree( + str(input_path), + engine="zarr", + chunks="auto", + storage_options=storage_options, + mask_and_scale=False, + ) dt_geozarr = convert_olci_optimized( - dt, + dt_raw, output_path=output_path, enable_sharding=args.enable_sharding, spatial_chunk=args.spatial_chunk, diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 462fb395..67e81e68 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -2,6 +2,7 @@ from __future__ import annotations +import re from typing import TYPE_CHECKING, cast import structlog @@ -208,7 +209,9 @@ def convert_olci_optimized( ------- xr.DataTree The opened output DataTree (lazy; backed by the written Zarr store). - Overview subgroups (``r2``, ``r4``, …) are written to the Zarr store + Every written group that holds arrays is included — including nested + ancillary groups such as ``conditions/geometry`` — except the overview + subgroups (``r2``, ``r4``, …), which are written to the Zarr store but are **not** represented as children of the returned DataTree, because xarray enforces dimension consistency between parent and child nodes and the overview subgroups have smaller spatial dimensions than @@ -318,19 +321,23 @@ def convert_olci_optimized( # nodes, so opening the whole store via ``xr.open_datatree`` would fail # because the overview subgroups have smaller spatial dimensions than # the parent ``measurements`` group. Instead, we build the DataTree - # manually from the top-level groups only: overview levels (r2, r4, …) - # are in the zarr store and accessible via ``zarr.open_group``, but are - # intentionally not exposed as DataTree children. + # manually from every group that holds arrays — including nested ancillary + # groups such as ``conditions/geometry`` — skipping the overview levels + # (``measurements/r2``, ``r4``, …): those are in the zarr store and + # accessible via ``zarr.open_group``, but are intentionally not exposed + # as DataTree children. root = zarr.open_group(output_path, mode="r") tree_dict: dict[str, xr.Dataset] = {} - for key in root.group_keys(): - child = root[key] - if isinstance(child, zarr.Group) and list(child.array_keys()): - tree_dict[f"/{key}"] = xr.open_dataset( - output_path, - engine="zarr", - group=key, - chunks={}, - consolidated=False, - ) + for group_path, node in root.members(max_depth=None): + if not isinstance(node, zarr.Group) or not list(node.array_keys()): + continue + if re.fullmatch(r"measurements/r\d+", group_path): + continue + tree_dict[f"/{group_path}"] = xr.open_dataset( + output_path, + engine="zarr", + group=group_path, + chunks={}, + consolidated=False, + ) return xr.DataTree.from_dict(tree_dict) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 6239ffe3..ee0c9ce8 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -136,9 +136,14 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: if fill_value is not None: fill_da = xr.where(averaged.isnull(), float(fill_value), averaged) - result_val = np.round(fill_da.values).astype(orig_dtype) + result_arr = fill_da.values else: - result_val = np.round(averaged.values).astype(orig_dtype) + result_arr = averaged.values + # Round only when packing back into an integer dtype; float + # radiance (e.g. a CF-decoded source) must not be quantized. + if np.issubdtype(orig_dtype, np.integer): + result_arr = np.round(result_arr) + result_val = result_arr.astype(orig_dtype) out_var = xr.DataArray(result_val, dims=averaged.dims, attrs=var.attrs) diff --git a/tests/test_cli_convert_routing.py b/tests/test_cli_convert_routing.py index 811fe00e..9a67ce69 100644 --- a/tests/test_cli_convert_routing.py +++ b/tests/test_cli_convert_routing.py @@ -81,8 +81,13 @@ def fake_generic(**kwargs: Any) -> xr.DataTree: calls["generic"] = kwargs return xr.DataTree() + def fake_olci(dt_input: xr.DataTree, **kwargs: Any) -> xr.DataTree: + calls["olci"] = {"dt_input": dt_input, **kwargs} + return xr.DataTree() + monkeypatch.setattr(cli, "convert_s2_optimized", fake_s2) monkeypatch.setattr(cli, "create_geozarr_dataset", fake_generic) + monkeypatch.setattr(cli, "convert_olci_optimized", fake_olci) return calls @@ -119,6 +124,36 @@ def test_convert_command_no_s2_optimized_forces_generic( assert converter_spy["generic"]["crs_groups"] == ["/conditions/geometry"] +def test_convert_command_routes_olci_with_raw_input( + s3_olci_group_example: Path, + tmp_path: Path, + converter_spy: dict[str, dict[str, Any]], +) -> None: + """Sentinel-3 OLCI inputs are auto-routed to the OLCI converter with raw input. + + convert_olci_optimized requires the source opened with + ``mask_and_scale=False``: radiance must arrive packed (uint16 with CF + scale_factor/add_offset in .attrs), not CF-decoded to float. + """ + args = _convert_args(str(s3_olci_group_example), str(tmp_path / "out.zarr")) + cli.convert_command(args) + + assert "olci" in calls_or_fail(converter_spy) + assert "s2_optimized" not in converter_spy + assert "generic" not in converter_spy + + dt_received = converter_spy["olci"]["dt_input"] + radiance = next( + var + for name, var in dt_received["/measurements"].data_vars.items() + if str(name).endswith("_radiance") + ) + assert not np.issubdtype(radiance.dtype, np.floating), ( + "OLCI converter received CF-decoded (mask_and_scale) input; expected raw packed radiance" + ) + assert "scale_factor" in radiance.attrs + + def test_convert_command_routes_non_s2_to_generic( plain_zarr_input: Path, tmp_path: Path, From 1db0929ca4aa20163f5c2792d5e63e196cb7c0a9 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:00:19 +0200 Subject: [PATCH 26/58] fix(s3-olci): forward --min-dimension in auto-detect path; avoid fill collisions The OLCI auto-detect branch of convert_command silently used the default min_dimension=256 instead of the user's --min-dimension; forward the flag so both entry points agree, and assert the forwarding in the routing test. In reduce_swath, a valid block whose mean rounds to the fill sentinel was recoded as fill in the overview; nudge such values one step back into the valid domain on the side the unrounded mean came from. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 1 + .../s3_olci_optimization/olci_multiscale.py | 17 +++++++++++++++++ tests/test_cli_convert_routing.py | 3 ++- 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index a54335c5..94132145 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -241,6 +241,7 @@ def convert_command(args: argparse.Namespace) -> None: output_path=output_path, enable_sharding=args.enable_sharding, spatial_chunk=args.spatial_chunk, + min_dimension=args.min_dimension, ) else: dt_geozarr = create_geozarr_dataset( diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index ee0c9ce8..0e9adbc9 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -135,14 +135,31 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] if fill_value is not None: + valid_mask = ~averaged.isnull().values fill_da = xr.where(averaged.isnull(), float(fill_value), averaged) result_arr = fill_da.values else: + valid_mask = None result_arr = averaged.values # Round only when packing back into an integer dtype; float # radiance (e.g. a CF-decoded source) must not be quantized. if np.issubdtype(orig_dtype, np.integer): + unrounded = result_arr result_arr = np.round(result_arr) + if fill_value is not None and valid_mask is not None: + # A valid block whose mean rounds to the fill sentinel + # would be recoded as fill in the overview; nudge it one + # step back into the valid domain, on the side of the + # sentinel the unrounded mean came from (fill may sit at + # either end of the dtype range). + collision = valid_mask & (result_arr == float(fill_value)) + if collision.any(): + nudged = np.where( + unrounded <= float(fill_value), + float(fill_value) - 1, + float(fill_value) + 1, + ) + result_arr = np.where(collision, nudged, result_arr) result_val = result_arr.astype(orig_dtype) out_var = xr.DataArray(result_val, dims=averaged.dims, attrs=var.attrs) diff --git a/tests/test_cli_convert_routing.py b/tests/test_cli_convert_routing.py index 9a67ce69..fcb5e6ef 100644 --- a/tests/test_cli_convert_routing.py +++ b/tests/test_cli_convert_routing.py @@ -135,12 +135,13 @@ def test_convert_command_routes_olci_with_raw_input( ``mask_and_scale=False``: radiance must arrive packed (uint16 with CF scale_factor/add_offset in .attrs), not CF-decoded to float. """ - args = _convert_args(str(s3_olci_group_example), str(tmp_path / "out.zarr")) + args = _convert_args(str(s3_olci_group_example), str(tmp_path / "out.zarr"), min_dimension=128) cli.convert_command(args) assert "olci" in calls_or_fail(converter_spy) assert "s2_optimized" not in converter_spy assert "generic" not in converter_spy + assert converter_spy["olci"]["min_dimension"] == 128 dt_received = converter_spy["olci"]["dt_input"] radiance = next( From 5925c64befafea3f3e966c7620eb9e22b6a3b845 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:13:57 +0200 Subject: [PATCH 27/58] fix(s3-olci): add --no-s3-olci-optimized opt-out; clarify divergent sanitizers Mirror the S2 escape hatch for the OLCI auto-detect path: a new --no-s3-olci-optimized flag forces the generic conversion path, with a routing test asserting the opt-out. The CF-decoded detection tree is now closed before re-opening the input raw, and the convert subcommand description documents the OLCI auto-routing. Rename the OLCI attr sanitizer to _sanitize_olci_array_attrs_keep_fill so its divergence from the shared sanitize_array_attrs (which strips _FillValue) is explicit at call sites, and cross-reference the two helpers in both docstrings so edits to one aren't assumed to apply to the other. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 25 +++++++++++++++---- src/eopf_geozarr/conversion/utils.py | 6 +++++ .../s3_olci_optimization/olci_converter.py | 6 ++--- tests/test_cli_convert_routing.py | 18 +++++++++++++ tests/test_olci_integration.py | 8 +++--- 5 files changed, 52 insertions(+), 11 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 94132145..6deca23f 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -221,14 +221,18 @@ def convert_command(args: argparse.Namespace) -> None: keep_scale_offset=False, max_retries=args.max_retries, ) - elif _is_sentinel3_olci_input(dt): - log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + elif _is_sentinel3_olci_input(dt) and not getattr(args, "no_s3_olci_optimized", False): + log.info( + "Detected Sentinel-3 OLCI product; using OLCI converter " + "(pass --no-s3-olci-optimized to force the generic path)" + ) # convert_olci_optimized requires raw (non-mask-scaled) input: # radiance must stay packed uint16 with CF scale_factor/add_offset # and _FillValue in .attrs (see _clear_encoding / reduce_swath). # The tree above was opened with CF decoding on for detection and - # the generic path, so re-open it raw, matching + # the generic path, so close it and re-open raw, matching # convert_s3_olci_optimized_command. + dt.close() dt_raw = xr.open_datatree( str(input_path), engine="zarr", @@ -1121,8 +1125,11 @@ def create_parser() -> argparse.ArgumentParser: "auto-detected and converted with the optimized flat multiscale layout " "(equivalent to convert-s2-optimized with keep_scale_offset disabled); for " "those inputs the per-group options --groups, --crs-groups, --gcp-group and " - "--min-dimension do not apply. Pass --no-s2-optimized to force the generic " - "conversion path, which honors all options." + "--min-dimension do not apply. Sentinel-3 OLCI inputs are likewise " + "auto-detected and converted with the OLCI swath converter (equivalent to " + "convert-s3-olci-optimized), which honors --min-dimension but not the " + "per-group options. Pass --no-s2-optimized / --no-s3-olci-optimized to " + "force the generic conversion path, which honors all options." ), ) convert_parser.add_argument( @@ -1198,6 +1205,14 @@ def create_parser() -> argparse.ArgumentParser: "honoring --groups/--crs-groups/--gcp-group/--min-dimension" ), ) + convert_parser.add_argument( + "--no-s3-olci-optimized", + action="store_true", + help=( + "Disable Sentinel-3 OLCI auto-detection and use the generic conversion " + "path, honoring --groups/--crs-groups/--gcp-group" + ), + ) convert_parser.set_defaults(func=convert_command) # Info command diff --git a/src/eopf_geozarr/conversion/utils.py b/src/eopf_geozarr/conversion/utils.py index 71023cd6..32810807 100644 --- a/src/eopf_geozarr/conversion/utils.py +++ b/src/eopf_geozarr/conversion/utils.py @@ -117,6 +117,12 @@ def sanitize_array_attrs( carried), not in its attributes; callers that need a CF ``_FillValue`` attribute (e.g. the NaN workaround for xarray issue #11345) must re-add it after sanitizing. + + .. warning:: The Sentinel-3 OLCI converter has its own deliberately + divergent sanitizer + (``s3_olci_optimization.olci_converter._sanitize_olci_array_attrs_keep_fill``) + that **preserves** ``_FillValue`` for raw (non-mask-scaled) input. + Edits to the strip-list here do not apply there, and vice versa. - For decoded float measurement arrays (*is_decoded_float=True*), also removes raw-encoding leftovers ``dtype``, ``fill_value``, ``valid_min``, ``valid_max`` and rewrites diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 67e81e68..cda72f3e 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -24,7 +24,7 @@ log = structlog.get_logger() -def _sanitize_olci_array_attrs(attrs: dict[str, object]) -> dict[str, object]: +def _sanitize_olci_array_attrs_keep_fill(attrs: dict[str, object]) -> dict[str, object]: """Return a copy of *attrs* with stale source-only keys removed. Strips ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` (source @@ -109,7 +109,7 @@ def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: """Return *ds* with stale source attrs stripped from all data variables. - Applies :func:`_sanitize_olci_array_attrs` to every data variable in *ds*. + Applies :func:`_sanitize_olci_array_attrs_keep_fill` to every data variable in *ds*. Coordinate variable attrs are left intact. This removes ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` @@ -125,7 +125,7 @@ def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: for name in ds.data_vars: var = ds[name] new_var = var.copy(data=var.data) - new_var.attrs = _sanitize_olci_array_attrs(dict(var.attrs)) + new_var.attrs = _sanitize_olci_array_attrs_keep_fill(dict(var.attrs)) new_vars[str(name)] = new_var return ds.assign(new_vars) diff --git a/tests/test_cli_convert_routing.py b/tests/test_cli_convert_routing.py index fcb5e6ef..bfabd624 100644 --- a/tests/test_cli_convert_routing.py +++ b/tests/test_cli_convert_routing.py @@ -32,6 +32,7 @@ def _convert_args(input_path: str, output_path: str, **overrides: Any) -> argpar dask_cluster=False, enable_sharding=False, no_s2_optimized=False, + no_s3_olci_optimized=False, ) for key, value in overrides.items(): setattr(ns, key, value) @@ -155,6 +156,23 @@ def test_convert_command_routes_olci_with_raw_input( assert "scale_factor" in radiance.attrs +def test_convert_command_no_s3_olci_optimized_forces_generic( + s3_olci_group_example: Path, + tmp_path: Path, + converter_spy: dict[str, dict[str, Any]], +) -> None: + """--no-s3-olci-optimized sends Sentinel-3 OLCI inputs down the generic path.""" + args = _convert_args( + str(s3_olci_group_example), + str(tmp_path / "out.zarr"), + no_s3_olci_optimized=True, + ) + cli.convert_command(args) + + assert "generic" in calls_or_fail(converter_spy) + assert "olci" not in converter_spy + + def test_convert_command_routes_non_s2_to_generic( plain_zarr_input: Path, tmp_path: Path, diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index 67ed0fc8..af2cf1b1 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -14,7 +14,9 @@ from pydantic_zarr.core import tuplify_json from pydantic_zarr.v3 import GroupSpec -from eopf_geozarr.s3_olci_optimization.olci_converter import _sanitize_olci_array_attrs +from eopf_geozarr.s3_olci_optimization.olci_converter import ( + _sanitize_olci_array_attrs_keep_fill, +) if TYPE_CHECKING: import pathlib @@ -372,7 +374,7 @@ def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) - def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: - """_sanitize_olci_array_attrs must strip stale source attrs and preserve _FillValue. + """_sanitize_olci_array_attrs_keep_fill must strip stale source attrs and preserve _FillValue. Unlike the shared sanitize_array_attrs (which always strips _FillValue), the OLCI-local helper must preserve _FillValue so that downstream readers @@ -391,7 +393,7 @@ def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: "standard_name": "toa_upwelling_spectral_radiance", "coordinates": "latitude longitude altitude", } - result = _sanitize_olci_array_attrs(attrs) + result = _sanitize_olci_array_attrs_keep_fill(attrs) # Stale source-only attrs must be removed. assert "_eopf_attrs" not in result, "_eopf_attrs must be stripped" assert "dtype" not in result, "dtype must be stripped" From 1d4ef57389dc3168ab8508bc1b1b61e3cc04db6e Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:26:00 +0200 Subject: [PATCH 28/58] fix(s3-olci): clamp fill-collision nudge to dtype range; document strict detection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The fill-collision nudge in reduce_swath could wrap for a sentinel at a dtype bound (e.g. fill 0 on an unsigned dtype nudging to -1 → dtype max). Clamp the nudge candidates so both sides resolve to the in-range neighbour when the sentinel sits at a bound. Document that OLCI auto-detection is intentionally conservative (strict structural validation against Sentinel3OlciRoot): near-miss products fall through to the generic path, and convert-s3-olci-optimized is the explicit bypass. Noted in both detection helpers and the convert subcommand description. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 11 +++++++++-- .../s3_olci_optimization/olci_converter.py | 7 +++++++ .../s3_olci_optimization/olci_multiscale.py | 17 ++++++++++++----- 3 files changed, 28 insertions(+), 7 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 6deca23f..ecd5e5d9 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -110,6 +110,10 @@ def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: ``is_sentinel3_olci_dataset`` validates structurally against a Zarr v2 model and can raise on unrelated inputs; any failure simply means "not a recognised OLCI product", so fall back to the generic converter. + + Detection is intentionally conservative (strict structural validation), so + near-miss OLCI products fall through to the generic path; the explicit + ``convert-s3-olci-optimized`` subcommand bypasses detection entirely. """ try: return is_sentinel3_olci_dataset(get_zarr_group(dt)) @@ -1128,8 +1132,11 @@ def create_parser() -> argparse.ArgumentParser: "--min-dimension do not apply. Sentinel-3 OLCI inputs are likewise " "auto-detected and converted with the OLCI swath converter (equivalent to " "convert-s3-olci-optimized), which honors --min-dimension but not the " - "per-group options. Pass --no-s2-optimized / --no-s3-olci-optimized to " - "force the generic conversion path, which honors all options." + "per-group options; OLCI detection is intentionally strict, so near-miss " + "products fall back to the generic path — use convert-s3-olci-optimized " + "to convert them explicitly. Pass --no-s2-optimized / " + "--no-s3-olci-optimized to force the generic conversion path, which " + "honors all options." ), ) convert_parser.add_argument( diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index cda72f3e..ab317c00 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -48,6 +48,13 @@ def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: Detection is structural: the group must validate against ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the first OLCI radiance band. + + Detection is intentionally conservative: ``Sentinel3OlciRoot`` uses a + closed member set and requires the standard EOPF root attrs, so a + product with extra top-level groups or missing root metadata fails + validation and is treated as "not OLCI" (falling through to the generic + converter in the CLI). Users with such near-miss products should use the + explicit ``convert-s3-olci-optimized`` subcommand, which skips detection. """ from eopf_geozarr.pyz.v2 import GroupSpec diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 0e9adbc9..058382ef 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -154,11 +154,18 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # either end of the dtype range). collision = valid_mask & (result_arr == float(fill_value)) if collision.any(): - nudged = np.where( - unrounded <= float(fill_value), - float(fill_value) - 1, - float(fill_value) + 1, - ) + # Nudge candidates, clamped to the dtype range: when + # the sentinel sits at a dtype bound (e.g. 0 for an + # unsigned dtype), both sides resolve to the one + # in-range neighbour instead of wrapping around. + info = np.iinfo(orig_dtype) + down = float(fill_value) - 1 + up = float(fill_value) + 1 + if down < float(info.min): + down = up + if up > float(info.max): + up = down + nudged = np.where(unrounded <= float(fill_value), down, up) result_arr = np.where(collision, nudged, result_arr) result_val = result_arr.astype(orig_dtype) From 55f110c70878005df41f9db734225f58cd18db39 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:27:40 +0200 Subject: [PATCH 29/58] chore: remove superpowers planning docs from version control Working plan/design documents under docs/superpowers/ are local scaffolding, not project documentation; untrack them and gitignore the directory. The files remain on disk (and in history). Assisted-by: ClaudeCode:claude-fable-5 --- .gitignore | 1 + .../plans/2026-06-21-sentinel3-olci-export.md | 1170 ----------------- ...2026-06-21-sentinel3-olci-export-design.md | 194 --- 3 files changed, 1 insertion(+), 1364 deletions(-) delete mode 100644 docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md delete mode 100644 docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md diff --git a/.gitignore b/.gitignore index 0fa04a75..573aacb2 100644 --- a/.gitignore +++ b/.gitignore @@ -218,3 +218,4 @@ uv.lock # VCS versioning src/eopf_geozarr/_version.py analysis/.edh_token +docs/superpowers/ diff --git a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md deleted file mode 100644 index 664fb5ae..00000000 --- a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md +++ /dev/null @@ -1,1170 +0,0 @@ -# Sentinel-3 OLCI L1 EFR → GeoZarr Export Implementation Plan - -> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. - -**Goal:** Add a Sentinel-3 OLCI L1 EFR exporter that converts an EOPF OLCI product into a GeoZarr-compliant, multiscale Zarr store, preserving native swath geometry (per-pixel 2-D lat/lon, no reprojection). - -**Architecture:** Mirror the existing Sentinel-2 exporter: a self-contained `s3_olci_optimization/` package (band mapping, multiscale, converter), a `data_api/s3_olci.py` pydantic-zarr model for structural product detection, and CLI auto-detection plus a dedicated `convert-s3-olci-optimized` subcommand. Overviews are produced by /2 decimation of the swath grid (radiance bands and 2-D lat/lon/altitude coordinate arrays decimated together). - -**Tech Stack:** Python 3.12+, pydantic v2 + pydantic-zarr, zarr v3 (output) / zarr v2 (EOPF input), xarray (DataTree), zarr-cm conventions, pyright (type checker), ruff, pytest. - -Design doc: `docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md` - -## Global Constraints - -- Python ≥ 3.12; modern type hints (`|`, `list`, `dict`). -- **Never use `typing.Any`.** Use `object` + narrowing or precise types. (Existing `ArraySpec[Any]` in s2.py is pre-existing; do not copy `Any` into new code — use `ArraySpec[object]` or a precise attrs type.) -- Type checker is **pyright** (`uv run --frozen pyright`); 0 errors required. Lint/format is **ruff** (`uv run ruff check`, `uv run ruff format`). -- Build convention metadata via `zarr_cm` / `eopf_geozarr.conversion.utils.build_convention_attrs`; never hand-assemble `zarr_conventions`. -- Run tools with `uv run`. Tests: `uv run pytest`. -- Commit messages end with the project's `Co-Authored-By: Claude Opus 4.8 ` trailer. -- Pydantic model members: keep genuinely-optional keys `NotRequired`/`total=False`; never make variant keys Required (real products fail validation otherwise). Property accessors narrow with `.get()` + guard. - ---- - -## File Structure - -Create: -- `src/eopf_geozarr/s3_olci_optimization/__init__.py` — package marker. -- `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` — the 21 OLCI band names + per-band metadata; "all bands one resolution" config. -- `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` — swath /2 decimation pyramid + GeoZarr metadata. -- `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` — `convert_olci_optimized()` entry point + `is_sentinel3_olci_dataset()`. -- `src/eopf_geozarr/data_api/s3_olci.py` — `Sentinel3OlciRoot` pydantic-zarr model. -- `tests/test_data_api/test_s3_olci.py` — model + detection tests. -- `tests/test_olci_band_mapping.py` — band mapping tests. -- `tests/test_olci_multiscale.py` — decimation + metadata tests. -- `tests/test_olci_integration.py` — synthetic end-to-end + CLI e2e. -- `tests/_test_data/s3_examples/.json` — committed structure dump (Task 8). - -Modify: -- `src/eopf_geozarr/cli.py` — auto-detect OLCI in `convert_command`; add `convert-s3-olci-optimized` subcommand. -- `src/eopf_geozarr/s2_optimization/s2_converter.py` — extend the detection `TypeAdapter` union to include `Sentinel3OlciRoot` (or add a dedicated OLCI detector — see Task 4). -- `tests/conftest.py` — add `s3_olci_group_example` fixture + `s3_example_json_paths`. - ---- - -## Task 1: OLCI band mapping - -**Files:** -- Create: `src/eopf_geozarr/s3_olci_optimization/__init__.py` -- Create: `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` -- Test: `tests/test_olci_band_mapping.py` - -**Interfaces:** -- Produces: `OLCI_BANDS: tuple[str, ...]` (the 21 names `oa01_radiance`..`oa21_radiance`); `OlciBandInfo` dataclass (`name: str`, `data_type: str`, `wavelength_center: float`); `OLCI_BAND_INFO: dict[str, OlciBandInfo]`; `RADIANCE_DTYPE = "uint16"`. - -OLCI band central wavelengths (nm), Oa01–Oa21: -`400, 412.5, 442.5, 490, 510, 560, 620, 665, 673.75, 681.25, 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865, 885, 900, 940, 1020`. - -- [ ] **Step 1: Write the failing test** - -```python -# test: skip -# tests/test_olci_band_mapping.py -from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( - OLCI_BANDS, - OLCI_BAND_INFO, - OlciBandInfo, - RADIANCE_DTYPE, -) - - -def test_there_are_21_olci_bands() -> None: - assert len(OLCI_BANDS) == 21 - assert OLCI_BANDS[0] == "oa01_radiance" - assert OLCI_BANDS[-1] == "oa21_radiance" - - -def test_every_band_has_info() -> None: - assert set(OLCI_BAND_INFO) == set(OLCI_BANDS) - for name, info in OLCI_BAND_INFO.items(): - assert isinstance(info, OlciBandInfo) - assert info.name == name - assert info.data_type == RADIANCE_DTYPE - assert info.wavelength_center > 0 - - -def test_first_band_wavelength() -> None: - assert OLCI_BAND_INFO["oa01_radiance"].wavelength_center == 400.0 -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_olci_band_mapping.py -v` -Expected: FAIL (ModuleNotFoundError: eopf_geozarr.s3_olci_optimization). - -- [ ] **Step 3: Create the package marker** - -```python -# src/eopf_geozarr/s3_olci_optimization/__init__.py -"""Sentinel-3 OLCI L1 EFR optimization (GeoZarr export).""" -``` - -- [ ] **Step 4: Implement the band mapping** - -```python -# src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py -"""Band definitions for Sentinel-3 OLCI L1 EFR. - -OLCI has 21 radiance bands (Oa01..Oa21), all delivered at the same full -resolution (~300 m) on a single swath grid. -""" - -from dataclasses import dataclass - -RADIANCE_DTYPE = "uint16" - -# Band index -> central wavelength in nm (OLCI Oa01..Oa21). -_WAVELENGTHS_NM: tuple[float, ...] = ( - 400.0, 412.5, 442.5, 490.0, 510.0, 560.0, 620.0, 665.0, 673.75, 681.25, - 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865.0, 885.0, 900.0, - 940.0, 1020.0, -) - -OLCI_BANDS: tuple[str, ...] = tuple(f"oa{i:02d}_radiance" for i in range(1, 22)) - - -@dataclass(frozen=True) -class OlciBandInfo: - """Spectral characterization of a single OLCI radiance band.""" - - name: str - data_type: str - wavelength_center: float # nanometers - - -OLCI_BAND_INFO: dict[str, OlciBandInfo] = { - name: OlciBandInfo(name=name, data_type=RADIANCE_DTYPE, wavelength_center=wl) - for name, wl in zip(OLCI_BANDS, _WAVELENGTHS_NM, strict=True) -} -``` - -- [ ] **Step 5: Run tests + type/lint** - -Run: `uv run pytest tests/test_olci_band_mapping.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py` -Expected: tests PASS; pyright 0 errors; ruff clean. - -- [ ] **Step 6: Commit** - -```bash -git add src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py -git commit -m "feat(s3-olci): add OLCI band mapping - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 2: Data API model + structural detection helper - -**Files:** -- Create: `src/eopf_geozarr/data_api/s3_olci.py` -- Test: `tests/test_data_api/test_s3_olci.py` - -**Interfaces:** -- Consumes: `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.{ArraySpec, GroupSpec}`; `eopf_geozarr.data_api.geozarr.common.DatasetAttrs`. -- Produces: - - `Sentinel3OlciMeasurementsMembers` (TypedDict, closed, total=False): 21 `oaNN_radiance` + `latitude`/`longitude`/`altitude` + optional `orphans`. - - `Sentinel3OlciMeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers])`. - - `Sentinel3OlciRootMembers` (closed, total=False): `measurements` (required), `quality` (NotRequired), `conditions` (NotRequired). - - `Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers])` with `.measurements` accessor. - -Use `ArraySpec[object]` (NOT `ArraySpec[Any]`). `quality`/`conditions` members typed as `GroupSpec[object, object]` (we don't model their internals in v1). Detection is structural: a product is OLCI iff it validates as `Sentinel3OlciRoot` (i.e. has `measurements` with the radiance bands). - -- [ ] **Step 1: Write the failing test** - -```python -# tests/test_data_api/test_s3_olci.py -from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot -from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec - - -def _olci_arr() -> dict[str, object]: - # minimal v2 ArraySpec-shaped dict for a 2-D uint16 array - return ArraySpec( - shape=(4, 5), chunks=(4, 5), dtype=" None: - radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} - coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} - root = { - "zarr_format": 2, - "node_type": "group", - "attributes": {"other_metadata": {}, "stac_discovery": {}}, - "members": { - "measurements": { - "zarr_format": 2, "node_type": "group", "attributes": {}, - "members": {**radiance, **coords}, - }, - }, - } - model = Sentinel3OlciRoot.model_validate(root) - assert "oa01_radiance" in model.measurements.members - - -def test_rejects_non_olci_product() -> None: - import pytest - from pydantic import ValidationError - - not_olci = { - "zarr_format": 2, "node_type": "group", - "attributes": {"other_metadata": {}, "stac_discovery": {}}, - "members": {"measurements": { - "zarr_format": 2, "node_type": "group", "attributes": {}, - "members": {"reflectance": { - "zarr_format": 2, "node_type": "group", "attributes": {}, "members": {}}}, - }}, - } - with pytest.raises(ValidationError): - Sentinel3OlciRoot.model_validate(not_olci) -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` -Expected: FAIL (cannot import `Sentinel3OlciRoot`). - -- [ ] **Step 3: Implement the model** (follow `data_api/s2.py` patterns exactly) - -```python -# src/eopf_geozarr/data_api/s3_olci.py -"""Pydantic-zarr model for the Sentinel-3 OLCI L1 EFR EOPF Zarr structure. - -Mirrors data_api/s2.py: GroupSpec + closed TypedDict members. Used for -structural product detection (an EOPF product is OLCI iff it validates here). -""" - -from __future__ import annotations - -from pydantic import BaseModel -from typing_extensions import TypedDict - -from eopf_geozarr.data_api.geozarr.common import DatasetAttrs -from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec - - -class Sentinel3OlciRootAttrs(BaseModel): - """Root-level attributes for an OLCI DataTree (not validated in detail).""" - - other_metadata: dict[str, object] - stac_discovery: dict[str, object] - - -class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): - """Members of the OLCI measurements group. - - The 21 radiance bands and the per-pixel geolocation coordinate arrays are - required in practice but typed optional so partial/variant products still - validate; the converter checks for the bands it needs. - """ - - latitude: ArraySpec[object] - longitude: ArraySpec[object] - altitude: ArraySpec[object] - orphans: GroupSpec[object, object] - oa01_radiance: ArraySpec[object] - oa02_radiance: ArraySpec[object] - oa03_radiance: ArraySpec[object] - oa04_radiance: ArraySpec[object] - oa05_radiance: ArraySpec[object] - oa06_radiance: ArraySpec[object] - oa07_radiance: ArraySpec[object] - oa08_radiance: ArraySpec[object] - oa09_radiance: ArraySpec[object] - oa10_radiance: ArraySpec[object] - oa11_radiance: ArraySpec[object] - oa12_radiance: ArraySpec[object] - oa13_radiance: ArraySpec[object] - oa14_radiance: ArraySpec[object] - oa15_radiance: ArraySpec[object] - oa16_radiance: ArraySpec[object] - oa17_radiance: ArraySpec[object] - oa18_radiance: ArraySpec[object] - oa19_radiance: ArraySpec[object] - oa20_radiance: ArraySpec[object] - oa21_radiance: ArraySpec[object] - - -class Sentinel3OlciMeasurementsGroup( - GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers] -): - """OLCI measurements group: 21 radiance bands + 2-D geolocation.""" - - -class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): - """Members of the OLCI root group.""" - - measurements: Sentinel3OlciMeasurementsGroup - quality: GroupSpec[object, object] - conditions: GroupSpec[object, object] - - -class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): - """Complete Sentinel-3 OLCI L1 EFR EOPF Zarr hierarchy.""" - - @property - def measurements(self) -> Sentinel3OlciMeasurementsGroup: - group = self.members.get("measurements") - if group is None: - raise KeyError("measurements") - return group -``` - -NOTE: to make detection meaningful (Task 4), the `measurements` member must be -required for a product to count as OLCI. If `closed=True, total=False` lets an -empty product validate, change `Sentinel3OlciRootMembers` so `measurements` is -required (a separate `closed=True` TypedDict without `total=False` containing -only `measurements`, with `quality`/`conditions` in a `total=False` mixin) OR -add an explicit check in `is_sentinel3_olci_dataset` (Task 4) that -`oa01_radiance` is among `measurements.members`. Implement the explicit check in -Task 4 (simpler, and keeps the model permissive). Adjust the -`test_rejects_non_olci_product` test if needed so it asserts via the Task 4 -detector rather than model validation — but since model validation with -`closed=True` rejects the `reflectance` key under `measurements`, the test above -should pass as written. Run it and confirm. - -- [ ] **Step 4: Run tests** - -Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` -Expected: PASS. If `test_rejects_non_olci_product` does not raise (because the -permissive members allow it), move that assertion into Task 4's detector test -and keep only the positive test here. - -- [ ] **Step 5: Type + lint** - -Run: `uv run --frozen pyright src/eopf_geozarr/data_api/s3_olci.py && uv run ruff check src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py` -Expected: pyright 0 errors; ruff clean. - -- [ ] **Step 6: Commit** - -```bash -git add src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py -git commit -m "feat(s3-olci): add Sentinel3OlciRoot data-api model - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 3: Swath /2 decimation - -**Files:** -- Create: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` -- Test: `tests/test_olci_multiscale.py` - -**Interfaces:** -- Consumes: `xarray`, `numpy`. -- Produces: `decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset` — returns a dataset with every 2-D `(rows, columns)` variable AND the 2-D coordinate arrays (`latitude`/`longitude`/`altitude`) subsampled `[::factor, ::factor]`, preserving attrs/encoding and CF `coordinates` linkage. 1-D and non-(rows,columns) variables are passed through unchanged. - -Decimation (not averaging) is correct for v1: it keeps geolocation exact (an averaged lat/lon would no longer correspond to a real pixel). Radiance is decimated too for consistency with its coordinates. - -- [ ] **Step 1: Write the failing test** - -```python -# tests/test_olci_multiscale.py -import numpy as np -import xarray as xr - -from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath - - -def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: - rad = xr.DataArray( - np.arange(rows * cols, dtype="uint16").reshape(rows, cols), - dims=("rows", "columns"), - attrs={"scale_factor": 0.5, "units": "mW.m-2.sr-1.nm-1"}, - ) - lat = xr.DataArray( - np.linspace(0, 1, rows * cols).reshape(rows, cols), - dims=("rows", "columns"), attrs={"standard_name": "latitude"}, - ) - lon = xr.DataArray( - np.linspace(10, 11, rows * cols).reshape(rows, cols), - dims=("rows", "columns"), attrs={"standard_name": "longitude"}, - ) - return xr.Dataset( - {"oa01_radiance": rad}, - coords={"latitude": lat, "longitude": lon}, - ) - - -def test_decimate_halves_each_axis() -> None: - out = decimate_swath(_swath(8, 6), factor=2) - assert out["oa01_radiance"].shape == (4, 3) - assert out["latitude"].shape == (4, 3) - assert out["longitude"].shape == (4, 3) - - -def test_decimate_takes_every_other_pixel() -> None: - out = decimate_swath(_swath(8, 6), factor=2) - # top-left pixel is preserved exactly (no averaging) - assert int(out["oa01_radiance"].values[0, 0]) == 0 - assert float(out["latitude"].values[0, 0]) == 0.0 - - -def test_decimate_preserves_attrs() -> None: - out = decimate_swath(_swath(8, 6), factor=2) - assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 - assert out["latitude"].attrs["standard_name"] == "latitude" -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_olci_multiscale.py -v` -Expected: FAIL (cannot import `decimate_swath`). - -- [ ] **Step 3: Implement decimation** - -```python -# src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py -"""Multiscale (overview) generation for OLCI swath data. - -OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays, -so overviews are produced by /2 decimation of the (rows, columns) grid: every -2-D variable and its 2-D coordinate arrays are subsampled together, keeping -geolocation exact. (Averaging is intentionally avoided — an averaged lat/lon -would not correspond to a real pixel.) -""" - -from __future__ import annotations - -import xarray as xr - -SWATH_DIMS = ("rows", "columns") - - -def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: - """Return *ds* with every (rows, columns) array subsampled by *factor*. - - Both data variables and coordinate variables that span exactly the swath - dims are decimated `[::factor, ::factor]`; everything else is passed - through unchanged. Attributes and encoding are preserved by xarray's isel. - """ - if factor < 1: - raise ValueError(f"factor must be >= 1, got {factor}") - if factor == 1: - return ds - indexers = { - dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes - } - if not indexers: - return ds - return ds.isel(indexers) -``` - -- [ ] **Step 4: Run tests + type/lint** - -Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py` -Expected: tests PASS; pyright 0; ruff clean. - -- [ ] **Step 5: Commit** - -```bash -git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py -git commit -m "feat(s3-olci): add swath /2 decimation for overviews - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 4: Product detection (`is_sentinel3_olci_dataset`) - -**Files:** -- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` (create in this task) -- Test: `tests/test_data_api/test_s3_olci.py` (extend) - -**Interfaces:** -- Consumes: `Sentinel3OlciRoot` (Task 2); `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.GroupSpec`; `zarr`. -- Produces: `is_sentinel3_olci_dataset(group: zarr.Group) -> bool` — True iff the group validates as `Sentinel3OlciRoot` AND `measurements` contains `oa01_radiance`. - -Pattern mirrors `is_sentinel2_dataset` in `s2_converter.py` (validate `GroupSpec.from_zarr(group).model_dump()`), but the extra `oa01_radiance` check makes detection robust given the permissive model. - -- [ ] **Step 1: Write the failing test (extend test_s3_olci.py)** - -```python -# append to tests/test_data_api/test_s3_olci.py -def test_detector_accepts_olci_zarr(tmp_path) -> None: - import zarr - from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec - from eopf_geozarr.s3_olci_optimization.olci_converter import ( - is_sentinel3_olci_dataset, - ) - - # build a minimal OLCI zarr v2 store from the model dict used above - radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} - coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} - root_dict = { - "zarr_format": 2, "node_type": "group", - "attributes": {"other_metadata": {}, "stac_discovery": {}}, - "members": {"measurements": { - "zarr_format": 2, "node_type": "group", "attributes": {}, - "members": {**radiance, **coords}}}, - } - out = tmp_path / "olci.zarr" - PyzGroupSpec.model_validate(root_dict).to_zarr(out, path="") # type: ignore[arg-type] - group = zarr.open_group(str(out), mode="r") - assert is_sentinel3_olci_dataset(group) is True - - -def test_detector_rejects_s2_zarr(s2_group_example) -> None: - import zarr - from eopf_geozarr.s3_olci_optimization.olci_converter import ( - is_sentinel3_olci_dataset, - ) - - group = zarr.open_group(str(s2_group_example), mode="r") - assert is_sentinel3_olci_dataset(group) is False -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` -Expected: FAIL (cannot import `is_sentinel3_olci_dataset`). - -- [ ] **Step 3: Implement the converter module with the detector** - -```python -# src/eopf_geozarr/s3_olci_optimization/olci_converter.py -"""Top-level Sentinel-3 OLCI L1 EFR -> GeoZarr conversion.""" - -from __future__ import annotations - -from typing import TYPE_CHECKING - -import structlog - -from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot - -if TYPE_CHECKING: - import zarr - -log = structlog.get_logger() - - -def is_sentinel3_olci_dataset(group: "zarr.Group") -> bool: - """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. - - Detection is structural: the group must validate against - ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the - first OLCI radiance band. - """ - from eopf_geozarr.pyz.v2 import GroupSpec - - try: - model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) - except ValueError as e: - log.debug("Not an OLCI dataset", error=str(e)) - return False - return "oa01_radiance" in model.measurements.members -``` - -- [ ] **Step 4: Run tests** - -Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` -Expected: PASS (positive detect + S2 rejected). - -- [ ] **Step 5: Type + lint** - -Run: `uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_converter.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py` -Expected: pyright 0; ruff clean. - -- [ ] **Step 6: Commit** - -```bash -git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py -git commit -m "feat(s3-olci): add OLCI product detection - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 5: GeoZarr metadata for a swath group - -**Files:** -- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` -- Test: `tests/test_olci_multiscale.py` (extend) - -**Interfaces:** -- Consumes: `eopf_geozarr.conversion.utils.build_convention_attrs`, `zarr_cm` types. -- Produces: `swath_spatial_attrs(dims: tuple[str, str] = ("rows", "columns")) -> SpatialAttrs` — returns the `spatial:` convention data for curvilinear (no-transform) data: `spatial:dimensions = ["rows", "columns"]`, `spatial:registration = "pixel"`, and NO `spatial:transform`/`spatial:bbox` (geolocation lives in the 2-D lat/lon coordinate arrays, not an affine transform). - -This isolates the one genuinely OLCI-specific GeoZarr decision (open question in the spec) into a small, tested unit. `build_convention_attrs(spatial=..., crs=None)` is called with `crs=None` because OLCI L1 carries no projected CRS — geolocation is via coordinate arrays. Confirm `build_convention_attrs` accepts `crs=None` (it does: signature is `crs: CRSLike | None`). - -- [ ] **Step 1: Write the failing test** - -```python -# append to tests/test_olci_multiscale.py -from eopf_geozarr.s3_olci_optimization.olci_multiscale import swath_spatial_attrs - - -def test_swath_spatial_attrs_has_no_transform() -> None: - attrs = swath_spatial_attrs() - assert attrs["spatial:dimensions"] == ["rows", "columns"] - assert attrs["spatial:registration"] == "pixel" - assert "spatial:transform" not in attrs - assert "spatial:bbox" not in attrs -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_olci_multiscale.py::test_swath_spatial_attrs_has_no_transform -v` -Expected: FAIL (cannot import `swath_spatial_attrs`). - -- [ ] **Step 3: Implement** - -```python -# add to src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py -from typing import TYPE_CHECKING - -if TYPE_CHECKING: - from zarr_cm import SpatialAttrs - - -def swath_spatial_attrs( - dims: tuple[str, str] = SWATH_DIMS, -) -> "SpatialAttrs": - """Spatial-convention data for curvilinear swath geometry. - - OLCI has no affine transform; geolocation is carried by 2-D lat/lon - coordinate arrays, so we declare the spatial dimensions and pixel - registration but no ``spatial:transform``/``spatial:bbox``. - """ - return { - "spatial:dimensions": [dims[0], dims[1]], - "spatial:registration": "pixel", - } -``` - -- [ ] **Step 4: Run tests + type/lint** - -Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/` -Expected: PASS; pyright 0; ruff clean. - -- [ ] **Step 5: Commit** - -```bash -git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py -git commit -m "feat(s3-olci): swath spatial-convention attrs (no transform) - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 6: `convert_olci_optimized` entry point - -**Files:** -- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` -- Test: `tests/test_olci_integration.py` - -**Interfaces:** -- Consumes: `decimate_swath`, `swath_spatial_attrs` (Tasks 3/5); `OLCI_BANDS` (Task 1); `build_convention_attrs`; `xarray`, `zarr`; storage/consolidation helpers from `conversion` (`fs_utils`, `geozarr`). -- Produces: - ```python - def convert_olci_optimized( - dt_input: xr.DataTree, - *, - output_path: str, - enable_sharding: bool = False, - spatial_chunk: int = 1024, - compression_level: int = 3, - min_dimension: int = 256, - keep_scale_offset: bool = False, - ) -> xr.DataTree: ... - ``` - Writes a GeoZarr store at `output_path`: the `measurements` group with native-resolution radiance + 2-D coords + GeoZarr convention metadata, plus `/2` decimated overview subgroups (`r1`, `r2`, `r4`, …) down to `min_dimension`; copies `conditions`/`quality` through unchanged. Returns the opened output DataTree. - -This is the orchestration task. Build it incrementally with a small synthetic OLCI DataTree (a helper in the test module, reused by Task 7). Keep the function focused; factor any growing helper (e.g. `_write_overviews`, `_copy_group`) into `olci_multiscale.py`. - -- [ ] **Step 1: Write the failing test (synthetic OLCI builder + end-to-end)** - -```python -# tests/test_olci_integration.py -import numpy as np -import xarray as xr - -from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized - - -def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: - """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" - rng = np.random.default_rng(0) - lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) - lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) - alt = np.zeros((rows, cols), dtype="int16") - data = {} - for i in range(1, 22): - name = f"oa{i:02d}_radiance" - arr = xr.DataArray( - rng.integers(0, 6000, (rows, cols)).astype("uint16"), - dims=("rows", "columns"), - attrs={"scale_factor": 0.0139, "add_offset": 0.0, - "standard_name": "toa_upwelling_spectral_radiance", - "coordinates": "latitude longitude altitude"}, - ) - data[name] = arr - ds = xr.Dataset( - data, - coords={ - "latitude": (("rows", "columns"), lat, {"standard_name": "latitude"}), - "longitude": (("rows", "columns"), lon, {"standard_name": "longitude"}), - "altitude": (("rows", "columns"), alt, {"standard_name": "altitude"}), - }, - ) - return xr.DataTree.from_dict({"/measurements": ds}) - - -def test_convert_olci_writes_measurements(tmp_path) -> None: - dt = build_synthetic_olci() - out = str(tmp_path / "olci_geozarr.zarr") - convert_olci_optimized(dt, output_path=out) - - import zarr - g = zarr.open_group(out, mode="r") - # native measurements present - assert "measurements" in g - # all 21 bands at native res - meas = g["measurements"] - for i in range(1, 22): - assert f"oa{i:02d}_radiance" in meas - - -def test_convert_olci_creates_overviews(tmp_path) -> None: - dt = build_synthetic_olci(rows=512, cols=480) - out = str(tmp_path / "olci_geozarr.zarr") - convert_olci_optimized(dt, output_path=out, min_dimension=256) - import zarr - g = zarr.open_group(out, mode="r") - # at least one decimated overview level exists under measurements - meas = g["measurements"] - subgroups = [k for k in meas.group_keys()] - assert len(subgroups) >= 1 -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_olci_integration.py -v` -Expected: FAIL (convert_olci_optimized not implemented / missing behavior). - -- [ ] **Step 3: Implement `convert_olci_optimized`** (incrementally; minimal to pass) - -Implementation outline (write real code — this is the skeleton to flesh out against the tests; mirror `s2_multiscale.create_multiscale_from_datatree` for writing groups, encoding, and `build_convention_attrs` usage): - -```python -# add to src/eopf_geozarr/s3_olci_optimization/olci_converter.py -import xarray as xr - -from eopf_geozarr.conversion.utils import build_convention_attrs -from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( - decimate_swath, - swath_spatial_attrs, -) - - -def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: - """Number of /2 decimations until min(rows, cols) would drop below min_dimension.""" - levels = 0 - r, c = rows, cols - while min(r, c) // 2 >= min_dimension: - r, c = r // 2, c // 2 - levels += 1 - return levels - - -def convert_olci_optimized( - dt_input: xr.DataTree, - *, - output_path: str, - enable_sharding: bool = False, - spatial_chunk: int = 1024, - compression_level: int = 3, - min_dimension: int = 256, - keep_scale_offset: bool = False, -) -> xr.DataTree: - """Convert an EOPF OLCI L1 EFR product to a GeoZarr multiscale store.""" - measurements = dt_input["/measurements"].to_dataset() - - # Attach GeoZarr convention metadata for native-resolution swath data. - conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) - measurements.attrs.update(dict(conv)) - - # Write native resolution. - measurements.to_zarr( - output_path, group="measurements", mode="w", - consolidated=False, zarr_format=3, - ) - - # Write /2 decimated overviews as subgroups r2, r4, ... - rows = measurements.sizes["rows"] - cols = measurements.sizes["columns"] - current = measurements - for level in range(1, _overview_levels(rows, cols, min_dimension) + 1): - current = decimate_swath(current, factor=2) - current.to_zarr( - output_path, group=f"measurements/r{2 ** level}", mode="a", - consolidated=False, zarr_format=3, - ) - - # Copy conditions/quality through unchanged (if present). - for grp in ("conditions", "quality"): - try: - node = dt_input[f"/{grp}"] - except KeyError: - continue - node.to_zarr(output_path, group=grp, mode="a", consolidated=False, zarr_format=3) - - return xr.open_datatree(output_path, engine="zarr", chunks={}) -``` - -NOTE: this skeleton uses xarray's `to_zarr` for simplicity. If the project's -chunk-alignment / encoding helpers (`conversion.utils`, -`s2_multiscale` encoding handling) are needed to match GeoZarr output -conventions (chunking, sharding, scale-offset), adopt them here the way -`s2_multiscale` does. Keep `keep_scale_offset`/`enable_sharding`/`spatial_chunk`/ -`compression_level` honored (wire into encoding); if a parameter is not yet used -by the minimal pass, leave a typed parameter and a follow-up note rather than -silently ignoring — but prefer wiring encoding via the existing helpers. - -- [ ] **Step 4: Run tests + type/lint** - -Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/ && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_integration.py` -Expected: tests PASS; pyright 0; ruff clean. - -- [ ] **Step 5: Commit** - -```bash -git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_olci_integration.py -git commit -m "feat(s3-olci): add convert_olci_optimized entry point - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 7: CLI integration (auto-detect + `convert-s3-olci-optimized`) - -**Files:** -- Modify: `src/eopf_geozarr/cli.py` -- Modify: `src/eopf_geozarr/s2_optimization/s2_converter.py` (only if you choose the union-adapter detection approach; otherwise no change — Task 4's standalone detector is used) -- Test: `tests/test_olci_integration.py` (extend with a CLI test) - -**Interfaces:** -- Consumes: `convert_olci_optimized`, `is_sentinel3_olci_dataset` (Tasks 4/6); `_is_sentinel2_input` pattern in `cli.py`. -- Produces: CLI behavior — `convert` auto-routes OLCI products to `convert_olci_optimized`; new `convert-s3-olci-optimized` subcommand. - -In `convert_command`, add OLCI detection BEFORE the generic path and AFTER S2 (so the order is S2 → OLCI → S1/generic), mirroring the `if _is_sentinel2_input(dt):` block. Add `_is_sentinel3_olci_input(dt)` wrapping `is_sentinel3_olci_dataset(get_zarr_group(dt))` (guard exceptions, like `_is_sentinel2_input`). Add `add_s3_olci_optimization_commands(subparsers)` mirroring `add_s2_optimization_commands` and call it next to `add_s2_optimization_commands(subparsers)`. - -- [ ] **Step 1: Write the failing CLI test** - -```python -# append to tests/test_olci_integration.py -import subprocess -import sys - - -def test_cli_convert_s3_olci_optimized(tmp_path) -> None: - # materialize a synthetic OLCI product to a zarr v2 store on disk - dt = build_synthetic_olci(rows=300, cols=300) - src = tmp_path / "olci_src.zarr" - dt.to_zarr(src, mode="w", consolidated=False) - out = tmp_path / "olci_out.zarr" - result = subprocess.run( - [sys.executable, "-m", "eopf_geozarr", "convert-s3-olci-optimized", - str(src), str(out), "--spatial-chunk", "256"], - capture_output=True, text=True, timeout=300, - ) - assert result.returncode == 0, result.stdout + result.stderr - import zarr - g = zarr.open_group(str(out), mode="r") - assert "measurements" in g -``` - -- [ ] **Step 2: Run test to verify it fails** - -Run: `uv run pytest tests/test_olci_integration.py::test_cli_convert_s3_olci_optimized -v` -Expected: FAIL (unknown subcommand). - -- [ ] **Step 3: Add the CLI subcommand + auto-detect** - -In `cli.py`, near the top imports add: -```python -from eopf_geozarr.s3_olci_optimization.olci_converter import ( - convert_olci_optimized, - is_sentinel3_olci_dataset, -) -``` - -Add the input helper (mirror `_is_sentinel2_input`): -```python -def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: - try: - return is_sentinel3_olci_dataset(get_zarr_group(dt)) - except Exception: # noqa: BLE001 - detection must never crash convert - return False -``` - -In `convert_command`, after the S2 block and before the generic/S1 path: -```python - if _is_sentinel3_olci_input(dt): - log.info("Detected Sentinel-3 OLCI product; using OLCI converter") - dt_geozarr = convert_olci_optimized( - dt, - output_path=args.output_path, - enable_sharding=args.enable_sharding, - spatial_chunk=args.spatial_chunk, - ) - # (skip the generic path; mirror how the S2 block returns/continues) -``` -Match exactly how the S2 block hands off (return vs. fallthrough) in the current `convert_command`. - -Add the subcommand (mirror `add_s2_optimization_commands`): -```python -def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> None: - p = subparsers.add_parser( - "convert-s3-olci-optimized", - help="Convert a Sentinel-3 OLCI L1 EFR dataset to optimized GeoZarr", - ) - p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") - p.add_argument("output_path", type=str, help="Path for output optimized dataset") - p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") - p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") - p.add_argument("--compression-level", type=int, default=3, choices=range(1, 10), - help="Compression level 1-9 (default: 3)") - p.add_argument("--min-dimension", type=int, default=256, - help="Minimum overview dimension (default: 256)") - p.add_argument("--keep-scale-offset", action="store_true", - help="Preserve scale-offset encoding instead of decoding to float") - p.add_argument("--verbose", action="store_true", help="Enable verbose output") - p.set_defaults(func=convert_s3_olci_optimized_command) - - -def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: - storage_options = get_storage_options(str(args.input_path)) - dt_input = xr.open_datatree( - str(args.input_path), engine="zarr", chunks="auto", - storage_options=storage_options, - ) - convert_olci_optimized( - dt_input, - output_path=args.output_path, - enable_sharding=args.enable_sharding, - spatial_chunk=args.spatial_chunk, - compression_level=args.compression_level, - min_dimension=args.min_dimension, - keep_scale_offset=args.keep_scale_offset, - ) - log.info("✅ S3 OLCI optimization completed", output_path=args.output_path) -``` - -And register it next to the S2 registration: -```python - add_s2_optimization_commands(subparsers) - add_s3_olci_optimization_commands(subparsers) -``` - -- [ ] **Step 4: Run tests + type/lint** - -Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/cli.py && uv run ruff check src/eopf_geozarr/cli.py` -Expected: tests PASS; pyright 0; ruff clean. - -- [ ] **Step 5: Commit** - -```bash -git add src/eopf_geozarr/cli.py tests/test_olci_integration.py -git commit -m "feat(s3-olci): CLI auto-detect + convert-s3-olci-optimized command - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 8: Real-product fixture + round-trip test - -**Files:** -- Create: `tests/_test_data/s3_examples/.json` -- Modify: `tests/conftest.py` -- Test: `tests/test_data_api/test_s3_olci.py` (extend with a real-product round-trip) - -**Interfaces:** -- Consumes: `create_group_from_json` (existing conftest helper); `is_sentinel3_olci_dataset`. -- Produces: `s3_example_json_paths` tuple + `s3_olci_group_example` fixture in conftest. - -**Generating the fixture** (run once, by the implementer, to create the committed JSON). The product is on the EODC EOPF store; use an `_NT_` product (the `_NR_` copies lack metadata). The store's `tenant:bucket` name breaks s3fs, but the consolidated `.zmetadata` is fetchable over HTTPS. Generate the structure dump with pydantic-zarr from the consolidated metadata. Reference product: -`https://objects.eodc.eu/e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu/01/products/cpm_v262/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.zarr` - -Write a one-off script `scripts/dump_olci_example.py` (NOT committed to src; can live under a scratch dir or `scripts/`) that builds a `pydantic_zarr.v2.GroupSpec` from the product's consolidated metadata and writes `model_dump_json(indent=2)` to the fixture path. If opening the remote store with xarray/zarr is blocked by the store's naming, build the `GroupSpec` dict directly from the fetched `.zmetadata` JSON (the `metadata` map contains every `.zgroup`/`.zarray`/`.zattrs`). The committed JSON must be a structure-only dump (chunks not required; shapes/dtypes/attrs are what matter), matching the form of `tests/_test_data/s2_examples/*.json`. - -Keep the fixture small if the full product is large: it is acceptable to truncate array shapes in the JSON (the model/detection tests only need structure), but document any truncation in a top-level attribute or a sibling README note. - -- [ ] **Step 1: Generate and commit the fixture JSON** - -Produce `tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_..._NT_004.json` via the one-off script. Verify it loads: -```bash -uv run python -c "import json,pathlib; json.loads(pathlib.Path('tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json').read_text()); print('ok')" -``` -Expected: `ok`. - -- [ ] **Step 2: Add conftest fixture** - -```python -# in tests/conftest.py, near the other *_example_json_paths -s3_example_json_paths = tuple(pathlib.Path("tests/_test_data/s3_examples").glob("*.json")) - - -@pytest.fixture(params=s3_example_json_paths, ids=get_stem) -def s3_olci_group_example( - request: pytest.FixtureRequest, tmp_path: pathlib.Path -) -> pathlib.Path: - """Path to a Zarr group with the layout of a Sentinel-3 OLCI product.""" - return create_group_from_json(request.param, tmp_path) -``` - -- [ ] **Step 3: Write the round-trip / detection test** - -```python -# append to tests/test_data_api/test_s3_olci.py -def test_real_olci_product_is_detected(s3_olci_group_example) -> None: - import zarr - from eopf_geozarr.s3_olci_optimization.olci_converter import ( - is_sentinel3_olci_dataset, - ) - - group = zarr.open_group(str(s3_olci_group_example), mode="r") - assert is_sentinel3_olci_dataset(group) is True - - -def test_real_olci_product_validates_model(s3_olci_group_example) -> None: - import zarr - from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec - from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot - - group = zarr.open_group(str(s3_olci_group_example), mode="r") - model = Sentinel3OlciRoot.model_validate(PyzGroupSpec.from_zarr(group).model_dump()) - assert "oa01_radiance" in model.measurements.members -``` - -- [ ] **Step 4: Run tests + type/lint** - -Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v && uv run --frozen pyright tests/conftest.py && uv run ruff check tests/conftest.py tests/test_data_api/test_s3_olci.py` -Expected: tests PASS; pyright 0; ruff clean. - -- [ ] **Step 5: Commit** - -```bash -git add tests/_test_data/s3_examples/ tests/conftest.py tests/test_data_api/test_s3_olci.py -git commit -m "test(s3-olci): real OLCI product fixture + round-trip detection - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 9: Golden-file snapshot of converted OLCI structure - -**Files:** -- Create: `tests/_test_data/optimized_olci_examples/.json` -- Test: `tests/test_olci_multiscale.py` (extend) or `tests/test_olci_integration.py` - -**Interfaces:** -- Consumes: `s3_olci_group_example` (Task 8); `convert_olci_optimized`; `pydantic_zarr.v3.GroupSpec`. -- Produces: a committed expected-structure snapshot + a test comparing converted output to it (mirrors `test_s2_multiscale.test_create_multiscale_from_datatree`). - -- [ ] **Step 1: Write the snapshot comparison test** - -```python -# append to tests/test_olci_integration.py -import json -from pathlib import Path - -import zarr -from pydantic_zarr.v3 import GroupSpec -from pydantic_zarr.core import tuplify_json - - -def test_olci_conversion_matches_snapshot(s3_olci_group_example, tmp_path) -> None: - import xarray as xr - - dt_in = xr.open_datatree(str(s3_olci_group_example), engine="zarr", chunks={}) - out = str(tmp_path / "out.zarr") - convert_olci_optimized(dt_in, output_path=out, min_dimension=256) - - observed = GroupSpec.from_zarr(zarr.open_group(out, use_consolidated=False)).model_dump() - expected_path = Path("tests/_test_data/optimized_olci_examples") / ( - Path(str(s3_olci_group_example)).stem + ".json" - ) - # To (re)generate the snapshot, uncomment: - # expected_path.parent.mkdir(parents=True, exist_ok=True) - # expected_path.write_text(json.dumps(observed, indent=2, sort_keys=True)) - expected = tuplify_json(json.loads(expected_path.read_text())) - observed_flat = GroupSpec(**tuplify_json(observed)).to_flat() - expected_flat = GroupSpec(**expected).to_flat() - assert set(observed_flat) == set(expected_flat) - assert [k for k in observed_flat if observed_flat[k] != expected_flat[k]] == [] -``` - -- [ ] **Step 2: Generate the snapshot** - -Temporarily uncomment the regeneration lines, run the test once to write the snapshot, re-comment, and verify it now passes: -```bash -uv run pytest tests/test_olci_integration.py::test_olci_conversion_matches_snapshot -v -``` -Expected: PASS after the snapshot is written. - -- [ ] **Step 3: Run tests + lint** - -Run: `uv run pytest tests/test_olci_integration.py -v && uv run ruff check tests/test_olci_integration.py` -Expected: PASS; ruff clean. - -- [ ] **Step 4: Commit** - -```bash -git add tests/_test_data/optimized_olci_examples/ tests/test_olci_integration.py -git commit -m "test(s3-olci): golden-file snapshot of converted OLCI structure - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Task 10: Full verification + docs - -**Files:** -- Modify: `README.md` and/or `docs/` (add OLCI to supported products + CLI usage). - -- [ ] **Step 1: Whole-suite type + lint + tests** - -Run: -```bash -uv run --frozen pyright -uv run ruff check src/ tests/ -uv run ruff format --check src/ tests/ -uv run pytest tests/ -p no:cacheprovider -q -m "not network" -``` -Expected: pyright 0 errors; ruff clean; tests green. - -- [ ] **Step 2: Document OLCI support** - -Add a short section to `README.md` (and/or `docs/converter.md`) noting Sentinel-3 OLCI L1 EFR support, the native-swath (no reprojection) behavior, and the `convert-s3-olci-optimized` command + auto-detection. - -- [ ] **Step 3: Commit** - -```bash -git add README.md docs/ -git commit -m "docs(s3-olci): document Sentinel-3 OLCI export support - -Co-Authored-By: Claude Opus 4.8 " -``` - ---- - -## Notes / deferred (future specs) - -- GeoZarr-converting `conditions/geometry` (tie-point grid), `meteorology` (3-D + pressure_level), `instrument` (per-band/detector) — copied through unmodified in v1. -- Reprojection-to-regular-grid option (lossy) — explicitly out of scope. -- SLSTR / SRAL / SYNERGY product types — separate specs. -- If GeoZarr's spatial/proj convention for curvilinear (2-D-coordinate) data needs a specific representation beyond `spatial:dimensions` + coordinate arrays, refine `swath_spatial_attrs` (Task 5) and regenerate the Task 9 snapshot. diff --git a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md deleted file mode 100644 index 6083174f..00000000 --- a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md +++ /dev/null @@ -1,194 +0,0 @@ -# Sentinel-3 OLCI L1 EFR → GeoZarr export — design - -Status: draft for review -Date: 2026-06-21 -Branch: `feat/sentinel3-export` (off `chore/new-conventions-metadata`) - -## Goal - -Add a first Sentinel-3 exporter to eopf-geozarr, scoped to **OLCI Level-1 EFR** -(Ocean and Land Colour Instrument, Earth-observation Full Resolution). It -converts an EOPF OLCI product into a GeoZarr-spec-compliant, multiscale Zarr -store, modeled on the existing Sentinel-2 exporter but adapted to OLCI's -fundamentally different geometry. - -This is the first of several Sentinel-3 product types (SLSTR, SRAL, SYNERGY are -out of scope here and will get their own specs). - -## Source format (verified against a real product) - -Introspected from a real `_NT_` (non-time-critical, fully consolidated) product -on the EODC EOPF sample store, e.g.: -`S3A_OL_1_EFR____20251101T073957..._NT_004.zarr` in bucket -`e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu` on `objects.eodc.eu`. - -Key facts: - -- **Zarr v2**, consolidated metadata at root (`.zmetadata`). NOTE: `_NR_` - (near-real-time) copies of the same products are often *incomplete* (chunks - but no metadata) — use `_NT_` products as the source of truth. -- Top-level groups mirror S2: `measurements`, `quality`, `conditions` (plus - `*/orphans` subgroups, an OLCI artifact for removed/duplicate pixels). -- `measurements/`: 21 radiance bands `oa01_radiance` … `oa21_radiance`, each - `[4090, 4865]` `uint16`, dims `(rows, columns)` — a **single full-resolution - ~300 m grid; all 21 bands share the same shape** (unlike S2's 10/20/60 m). - Each band has CF `scale_factor`/`add_offset`, `units`, - `standard_name=toa_upwelling_spectral_radiance`, and - `coordinates: latitude longitude altitude time_stamp`. -- **Geolocation is per-pixel / curvilinear**: `measurements/latitude`, - `measurements/longitude`, `measurements/altitude` are 2D `[4090, 4865]` - arrays (`latitude`/`longitude` are scaled `int32`, scale `1e-6`, with fill - values). There is **no projected CRS, no EPSG, no affine transform** — root - attrs are empty. OLCI is delivered in satellite swath geometry. -- `conditions/geometry`: sun/view angles (`sza`, `saa`, `oza`, `oaa`) on a - **coarser across-track tie-point grid** `[4090, 77]`. -- `conditions/instrument`: per-band/detector spectral data (`lambda0`, - `solar_flux`, `fwhm`) shaped `[21, 3700]`; `relative_spectral_covariance` - `[21, 21]`. -- `conditions/meteorology`: ECMWF fields on the `[4090, 77]` tie-point grid, - some with a `pressure_level` (25) dim. -- `conditions/image`: `altitude`, `detector_index`, `frame_offset`, - `latitude`, `longitude` at full `[4090, 4865]`; `time_stamp` `[4090]`. - -## Core design decision: native swath geometry (no reprojection) - -OLCI L1 has no projected grid. We **preserve native swath geometry**: keep the -per-pixel `latitude`/`longitude` as 2-D auxiliary coordinate variables -(CF "two-dimensional coordinates" + GeoZarr geographic convention). **No -reprojection / resampling** — faithful and lossless. - -Consequences: -- The GeoZarr `proj` convention is geographic (lat/lon), not a projected CRS + - affine transform. We attach 2-D coordinate arrays via CF `coordinates` and the - appropriate GeoZarr `spatial`/`proj` metadata for curvilinear data (no - `spatial:transform`; lat/lon carried as coordinate arrays). -- Multiscale overviews are produced by **2×2 block reduction** of `rows`/`columns`: - - **Radiance bands → block-average** (mean over each 2×2 block), like the S2 - reflectance path. This is a genuine reduction, so each level carries new - information that justifies storing it (a literal `[::2,::2]` *subsample* would - add no information over the base array and must NOT be re-saved). - - **Coordinate arrays (`latitude`/`longitude`/`altitude`) → decimate** - (take a fixed sub-pixel, e.g. block top-left), NOT average — so each overview - pixel's geolocation remains a real measured position rather than an - interpolated one. Radiance and coords are reduced together so each level's - grid stays internally consistent. - - Levels are declared with the GeoZarr **`multiscales`** convention. Per the - multiscales spec, the per-level `transform` holds the **relative** index - relationship (`scale: [2, 2]` from the source level) — which remains valid - for a 2×2 reduction. We do **NOT** emit `spatial:transform` (the absolute - affine), because OLCI has no regular grid; absolute geolocation is carried by - each level's own 2-D lat/lon coordinate arrays. (Reprojection to a regular - grid is explicitly a *future* option, not in this deliverable.) - -## Scope (v1): measurements-first - -- **`measurements/`** → GeoZarr-compliant multiscale group: - - 21 radiance bands + the 2-D `latitude`/`longitude`/`altitude` coordinate - arrays, CF `coordinates` linkage preserved, scale/offset preserved - (same handling as S2 reflectance encoding). - - `/2` overview pyramid (decimation), down to a configurable min dimension. -- **`conditions/` and `quality/`** → copied through faithfully but unoptimized - (the way the S2 path copies non-reflectance groups as-is). -- **`orphans/`** subgroups → copied through as-is (not specially handled). -- Out of scope for v1: GeoZarr-converting the tie-point geometry grid, 3-D - meteorology, and 1-D instrument arrays; SLSTR/SRAL/SYNERGY; reprojection. - -## Architecture — mirror the S2 package - -Reuse the S2 exporter's shape (a self-contained product package + a data_api -model + CLI auto-detection). New code: - -``` -src/eopf_geozarr/s3_olci_optimization/ # parallels s2_optimization/ - __init__.py - olci_band_mapping.py # 21 OLCI bands (oa01..oa21), band metadata; the - # "all bands one resolution" config - olci_multiscale.py # swath /2 decimation pyramid + GeoZarr metadata; - # decimates radiance + 2D coord arrays together - olci_converter.py # convert_olci_optimized(dt, *, output_path, ...) - # entry point + is_sentinel3_olci_dataset() - common.py # (or reuse s2_optimization.common) - -src/eopf_geozarr/data_api/s3_olci.py # Sentinel3OlciRoot pydantic model - # (GroupSpec/TypedDict members) -``` - -Reused as-is from existing code: -- Generic encoding / chunk-alignment / fill-value helpers in - `conversion/utils.py` and `fs_utils.py`. -- GeoZarr convention metadata helpers (`conversion/utils.build_convention_attrs`, - zarr-cm), root consolidation, snapshot/round-trip test patterns. -- Type-aware resampling: OLCI radiance is all "reflectance-like" (block-average - on decimation); we can reuse `s2_resampling` averaging or a thin OLCI variant. - v1 only needs averaging/decimation since all bands are one continuous - radiance type (no SCL/quality-mask variety in `measurements/`). - -### Product detection - -S2/S1 are detected **structurally** (validate the zarr group against -`Sentinel1Root | Sentinel2Root` pydantic models in `is_sentinel2_dataset`). OLCI -root attrs are empty, so structural detection is the right approach: add -`Sentinel3OlciRoot` and extend the adapter to -`Sentinel1Root | Sentinel2Root | Sentinel3OlciRoot`. The CLI `convert` command's -auto-detect dispatches to `convert_olci_optimized` when the product validates as -OLCI. - -### CLI - -- Auto-detect in `convert` (as S2 does). -- Dedicated `convert-s3-olci-optimized` subcommand mirroring - `convert-s2-optimized` (spatial-chunk, sharding, compression-level, - keep-scale-offset, skip-validation, dask-cluster, verbose). - -## Data model (`data_api/s3_olci.py`) - -Follow the S2 pattern (pydantic `GroupSpec` + `closed=True` TypedDict members), -NOT the S1 dynamic-mapping pattern, because OLCI has a fixed known structure: - -- `Sentinel3OlciRoot(GroupSpec[..., Sentinel3OlciRootMembers])` with - `measurements`, `quality`, `conditions` members. -- `Sentinel3OlciMeasurementsMembers`: the 21 `oaNN_radiance` arrays + - `latitude`/`longitude`/`altitude` (+ optional `orphans`). Genuinely-optional - members stay `NotRequired`/`total=False` (lesson from the S1 model: don't make - variant keys required, or real products fail validation). Accessors narrow - with `.get()` + guard. - -Type checking: pyright (project standard). No `typing.Any`. Convention metadata -built via `zarr_cm` / `build_convention_attrs`. - -## Testing (match existing pattern) - -1. **Structure-dump fixture**: generate a JSON metadata-dump of a real OLCI - `_NT_` product via pydantic-zarr `GroupSpec` (as `s1_examples`/`s2_examples` - were made), commit to `tests/_test_data/s3_examples/`, add an - `s3_olci_group_example` fixture in `conftest.py` that materializes it to zarr - via `create_group_from_json`. First confirm the dump round-trips cleanly for - OLCI. -2. **Unit tests**: band mapping, swath decimation correctness (radiance and - lat/lon decimate consistently), GeoZarr metadata emitted, model validation - (incl. a real-product round-trip). -3. **Golden-file snapshot** of the converted structure (like - `optimized_geozarr_examples`), with the URL-only-diff regeneration discipline. -4. **Synthetic in-memory OLCI builder** for an integration test (mirrors the - S1/S2 integration mocks) exercising `convert_olci_optimized` end-to-end. -5. **CLI e2e** for `convert-s3-olci-optimized` on the materialized fixture. - -## Open questions / risks - -- **CF curvilinear + GeoZarr `spatial`/`proj` for swath data**: confirm the - exact GeoZarr metadata form for 2-D-coordinate (non-gridded) data during - implementation; the conventions are grid-oriented and may need a geographic / - coordinate-array representation rather than `spatial:transform`. -- **Decimation vs. averaging for overviews**: v1 uses simple /2; confirm whether - block-averaging radiance (and what to do with lat/lon — decimate, not average) - is preferred for the pyramid. -- **EOPF data access plumbing**: opening these remote products needs the right - storage handling (tenant:bucket name breaks s3fs; `_NR_` products lack - metadata). Test data is committed as JSON dumps, so this only matters for - regenerating fixtures, not for CI. - -## Decomposition / sequencing - -This spec is one implementation plan: the OLCI measurements-first exporter. -Follow-ups (separate specs): OLCI conditions/quality GeoZarr conversion; -reprojection-to-grid option; SLSTR / SRAL / SYNERGY. From cc203e0863d1afe6890a0795abc7aedc24325293 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:35:30 +0200 Subject: [PATCH 30/58] fix(s3-olci): warn on unwired converter options; NaN-aware fill masking convert_olci_optimized accepts enable_sharding, spatial_chunk, compression_level and keep_scale_offset but does not yet apply them; it now logs a warning when a non-default value is passed, the dedicated subcommand's help marks those flags as not yet applied, and the convert auto-detect path stops forwarding them (it would otherwise warn on every run since convert's defaults differ). In reduce_swath, a float source with a NaN _FillValue was masked via an equality comparison that is a no-op for NaN; mask explicitly with notnull() in that case instead of relying on coarsen's implicit NaN skipping. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 28 +++++++++++++++---- .../s3_olci_optimization/olci_converter.py | 17 ++++++++++- .../s3_olci_optimization/olci_multiscale.py | 7 ++++- 3 files changed, 44 insertions(+), 8 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index ecd5e5d9..cbfbff0d 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -244,11 +244,15 @@ def convert_command(args: argparse.Namespace) -> None: storage_options=storage_options, mask_and_scale=False, ) + # Only forward options the OLCI converter actually applies; + # enable_sharding / spatial_chunk are accepted by + # convert_olci_optimized but not yet wired into the encoding + # (forwarding them would trigger its ignored-options warning on + # every run, since convert's defaults differ). Re-add them here + # once the converter wires them through. dt_geozarr = convert_olci_optimized( dt_raw, output_path=output_path, - enable_sharding=args.enable_sharding, - spatial_chunk=args.spatial_chunk, min_dimension=args.min_dimension, ) else: @@ -1345,14 +1349,23 @@ def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> ) p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") p.add_argument("output_path", type=str, help="Path for output optimized dataset") - p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") - p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") + p.add_argument( + "--spatial-chunk", + type=int, + default=1024, + help="Spatial chunk size (not yet applied; reserved for a follow-up)", + ) + p.add_argument( + "--enable-sharding", + action="store_true", + help="Enable Zarr v3 sharding (not yet applied; reserved for a follow-up)", + ) p.add_argument( "--compression-level", type=int, default=3, choices=range(1, 10), - help="Compression level 1-9 (default: 3)", + help="Compression level 1-9 (default: 3; not yet applied; reserved for a follow-up)", ) p.add_argument( "--min-dimension", @@ -1363,7 +1376,10 @@ def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> p.add_argument( "--keep-scale-offset", action="store_true", - help="Preserve scale-offset encoding instead of decoding to float", + help=( + "Preserve scale-offset encoding instead of decoding to float " + "(not yet applied; output is currently always raw integer)" + ), ) p.add_argument("--verbose", action="store_true", help="Enable verbose output") p.set_defaults(func=convert_s3_olci_optimized_command) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index ab317c00..f71c5378 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -232,8 +232,23 @@ def convert_olci_optimized( and ``keep_scale_offset`` are accepted but not yet applied to the on-disk encoding. Wiring them through the existing ``conversion`` helpers (``create_measurements_encoding``, sharding codec, etc.) is left for a - follow-up task so as not to block the integration test. + follow-up task so as not to block the integration test. A warning is + logged when a non-default value is passed for any of them, so callers + aren't silently handed default-encoded output. """ + unwired: dict[str, tuple[object, object]] = { + "enable_sharding": (enable_sharding, False), + "spatial_chunk": (spatial_chunk, 1024), + "compression_level": (compression_level, 3), + "keep_scale_offset": (keep_scale_offset, False), + } + ignored = [name for name, (value, default) in unwired.items() if value != default] + if ignored: + log.warning( + "Options not yet applied by the OLCI converter; output uses default encoding", + ignored_options=ignored, + ) + measurements = dt_input["/measurements"].to_dataset() # Strip any inherited Zarr v2 encoding (e.g. numcodecs.Blosc compressors) # so the v3 writer can choose its own default codecs without raising a diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 058382ef..1077aebe 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -127,7 +127,12 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: float_var = var.astype("float64") if fill_value is not None: - float_var = float_var.where(float_var != float(fill_value)) + if np.isnan(float(fill_value)): + # NaN sentinel (float sources): equality comparison would + # be a no-op (NaN != NaN is always True); mask explicitly. + float_var = float_var.where(float_var.notnull()) + else: + float_var = float_var.where(float_var != float(fill_value)) # coarsen().mean() is available at runtime; pyright stubs don't expose .mean() # on DataArrayCoarsen, so we suppress the type-check on the reduction call. From 1ad264f14f63838398d05152c174e465e3f4d2e1 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 13:48:32 +0200 Subject: [PATCH 31/58] fix(s3-olci): defensive return-tree assembly; test fill-collision nudge DataTree.from_dict enforces parent/child dimension consistency, so an ancillary group reusing a swath dim name at a different size could make the return-tree assembly fail even though the store was written correctly. Catch that case and fall back to a measurements-only view with a warning instead of masking a successful write. Add direct tests for the reduce_swath fill-collision branch: a valid block averaging exactly to an interior fill sentinel is nudged one step into the valid domain, and an all-fill block keeps the sentinel. (Bound sentinels such as 0/65535 are unreachable by a mean of one-sided valid values; the dtype clamp remains defensive.) Assisted-by: ClaudeCode:claude-fable-5 --- .../s3_olci_optimization/olci_converter.py | 15 ++++++- tests/test_olci_multiscale.py | 39 +++++++++++++++++++ 2 files changed, 53 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index f71c5378..5d2bc90c 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -362,4 +362,17 @@ def convert_olci_optimized( chunks={}, consolidated=False, ) - return xr.DataTree.from_dict(tree_dict) + try: + return xr.DataTree.from_dict(tree_dict) + except ValueError as e: + # DataTree.from_dict enforces dimension consistency between parent + # and child nodes; an ancillary group reusing a swath dim name at a + # different size would make assembly fail even though the store was + # written correctly. Never mask a successful write: fall back to a + # measurements-only view and point readers at the store itself. + log.warning( + "Could not assemble the full return DataTree; " + "returning measurements-only view (the written store is complete)", + error=str(e), + ) + return xr.DataTree.from_dict({"/measurements": tree_dict["/measurements"]}) diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index d7efd1c2..af505789 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -290,3 +290,42 @@ def test_swath_spatial_attrs_has_no_transform() -> None: assert attrs.get("spatial:registration") == "pixel" assert "spatial:transform" not in attrs assert "spatial:bbox" not in attrs + + +def test_reduce_fill_collision_nudged_not_recoded_as_fill() -> None: + """A valid block whose mean rounds to the fill sentinel must not become fill. + + Uses a sentinel interior to the data range (a bound sentinel such as 0 or + 65535 cannot be reached by a mean of valid values that all sit on one side + of it): values [999, 1001, 999, 1001] average exactly to _FillValue=1000 + and must be nudged to the neighboring in-range value instead. + """ + rows, cols = 2, 2 + rad = xr.DataArray( + np.array([[999, 1001], [999, 1001]], dtype="uint16"), + dims=("rows", "columns"), + attrs={"_FillValue": 1000}, + ) + lat = xr.DataArray(np.zeros((rows, cols)), dims=("rows", "columns")) + lon = xr.DataArray(np.zeros((rows, cols)), dims=("rows", "columns")) + ds = xr.Dataset({"oa01_radiance": rad}, coords={"latitude": lat, "longitude": lon}) + + out = reduce_swath(ds, factor=2) + value = int(out["oa01_radiance"].values[0, 0]) + assert value != 1000, "valid block was recoded as fill" + assert value == 999 # unrounded mean == sentinel → nudged one step down + + +def test_reduce_all_fill_block_stays_fill() -> None: + """An all-fill block keeps the sentinel value in the overview.""" + rad = xr.DataArray( + np.full((2, 2), 1000, dtype="uint16"), + dims=("rows", "columns"), + attrs={"_FillValue": 1000}, + ) + lat = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + lon = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + ds = xr.Dataset({"oa01_radiance": rad}, coords={"latitude": lat, "longitude": lon}) + + out = reduce_swath(ds, factor=2) + assert int(out["oa01_radiance"].values[0, 0]) == 1000 From 10db2ddcbaddfa9cbfac44788e4e84b438acc100 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 14:36:56 +0200 Subject: [PATCH 32/58] perf(s3-olci): materialize coarsened mean once; never raise from detection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The radiance branch of reduce_swath evaluated the dask-backed coarsen+mask graph twice (once via isnull().values for the valid mask, again via fill_da.values) — roughly doubling the heaviest compute in the converter for real products. Compute the averaged array once up front. is_sentinel3_olci_dataset only caught ValueError, but from_zarr / model_dump can raise other types on malformed stores; broaden the guard so the classifier never raises for direct callers (the CLI wrapper already swallowed everything). Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/s3_olci_optimization/olci_converter.py | 5 ++++- src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py | 4 ++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 5d2bc90c..a4864a4b 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -60,7 +60,10 @@ def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: try: model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) - except ValueError as e: + except Exception as e: + # Classify, never raise: from_zarr/model_dump can fail with types + # other than ValidationError on malformed or unexpected stores, and + # any failure simply means "not a recognised OLCI product". log.debug("Not an OLCI dataset", error=str(e)) return False try: diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 1077aebe..7b4d4344 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -138,6 +138,10 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # on DataArrayCoarsen, so we suppress the type-check on the reduction call. coarsened = float_var.coarsen({"rows": factor, "columns": factor}, boundary="trim") averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] + # Materialize once: with dask-backed input, the isnull()/where()/ + # .values accesses below would otherwise each re-evaluate the + # coarsen+mask graph — the heaviest compute in the converter. + averaged = averaged.compute() if fill_value is not None: valid_mask = ~averaged.isnull().values From 31ca3902ff146d0537d35725111e192db0d844a6 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 14:52:01 +0200 Subject: [PATCH 33/58] fix(s3-olci): clear error for missing swath dims; finer return-tree fallback Validate up front that the measurements group has the rows/columns swath dimensions the whole OLCI pipeline assumes, raising a clear ValueError instead of a bare KeyError deep in the converter. When return-tree assembly hits a DataTree dimension-consistency conflict, re-add groups greedily and exclude only the offending ones instead of collapsing to a measurements-only view. On the convert auto-detect path, warn when a user's --spatial-chunk or --enable-sharding is dropped (those options are not yet applied by the OLCI converter), instead of ignoring them silently. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 23 ++++++++++- .../s3_olci_optimization/olci_converter.py | 38 ++++++++++++++----- 2 files changed, 50 insertions(+), 11 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index cbfbff0d..139a0049 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -34,6 +34,10 @@ log = structlog.get_logger() +# Default for convert's --spatial-chunk; shared between the parser definition +# and the OLCI auto-detect path's ignored-options check. +CONVERT_SPATIAL_CHUNK_DEFAULT = 4096 + # Suppress xarray FutureWarning about timedelta decoding warnings.filterwarnings("ignore", message=".*", category=FutureWarning) @@ -249,7 +253,22 @@ def convert_command(args: argparse.Namespace) -> None: # convert_olci_optimized but not yet wired into the encoding # (forwarding them would trigger its ignored-options warning on # every run, since convert's defaults differ). Re-add them here - # once the converter wires them through. + # once the converter wires them through — and don't drop a user's + # explicit setting silently in the meantime. + ignored_cli_options = [ + name + for name, is_non_default in ( + ("--spatial-chunk", args.spatial_chunk != CONVERT_SPATIAL_CHUNK_DEFAULT), + ("--enable-sharding", args.enable_sharding), + ) + if is_non_default + ] + if ignored_cli_options: + log.warning( + "Options not yet applied by the OLCI converter and " + "ignored on the auto-detect path", + ignored_options=ignored_cli_options, + ) dt_geozarr = convert_olci_optimized( dt_raw, output_path=output_path, @@ -1161,7 +1180,7 @@ def create_parser() -> argparse.ArgumentParser: convert_parser.add_argument( "--spatial-chunk", type=int, - default=4096, + default=CONVERT_SPATIAL_CHUNK_DEFAULT, help="Spatial chunk size for encoding (default: 4096)", ) convert_parser.add_argument( diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index a4864a4b..803f4941 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -253,6 +253,16 @@ def convert_olci_optimized( ) measurements = dt_input["/measurements"].to_dataset() + # Structural detection does not constrain dimension names, but the whole + # swath pipeline (reduce_swath, decimate_swath, SWATH_DIMS) assumes + # rows/columns; fail with a clear error instead of a bare KeyError below. + missing_dims = [d for d in ("rows", "columns") if d not in measurements.sizes] + if missing_dims: + raise ValueError( + "OLCI converter requires swath dimensions ('rows', 'columns') on the " + f"measurements group; missing {missing_dims}. Use the generic convert " + "path for products with different dimension names." + ) # Strip any inherited Zarr v2 encoding (e.g. numcodecs.Blosc compressors) # so the v3 writer can choose its own default codecs without raising a # "Expected a BytesBytesCodec" error. The caller is expected to have opened @@ -367,15 +377,25 @@ def convert_olci_optimized( ) try: return xr.DataTree.from_dict(tree_dict) - except ValueError as e: + except ValueError: # DataTree.from_dict enforces dimension consistency between parent # and child nodes; an ancillary group reusing a swath dim name at a # different size would make assembly fail even though the store was - # written correctly. Never mask a successful write: fall back to a - # measurements-only view and point readers at the store itself. - log.warning( - "Could not assemble the full return DataTree; " - "returning measurements-only view (the written store is complete)", - error=str(e), - ) - return xr.DataTree.from_dict({"/measurements": tree_dict["/measurements"]}) + # written correctly. Never mask a successful write: re-add groups + # greedily and exclude only the ones that break assembly. + kept: dict[str, xr.Dataset] = {"/measurements": tree_dict["/measurements"]} + for group_path, ds in tree_dict.items(): + if group_path == "/measurements": + continue + candidate = {**kept, group_path: ds} + try: + xr.DataTree.from_dict(candidate) + except ValueError as e: + log.warning( + "Excluding group from the returned DataTree (the written store is complete)", + group=group_path, + error=str(e), + ) + continue + kept = candidate + return xr.DataTree.from_dict(kept) From 4e2f7f83cb48db7b199048ea535b5ed79cd4dc0c Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 15:06:54 +0200 Subject: [PATCH 34/58] fix(s3-olci): explicit skipna in fill-aware mean; depth-sort tree fallback Pass skipna=True explicitly to the coarsen mean so the fill-aware promise (one fill pixel must not contaminate its block) does not hinge on a version-dependent default, and add a test asserting a partially filled block averages only its valid pixels. Sort the return-tree greedy fallback by path depth so parents are considered before their nested children, preventing an implicit empty parent from shadowing the real data-bearing one. Assisted-by: ClaudeCode:claude-fable-5 --- .../s3_olci_optimization/olci_converter.py | 6 ++++-- .../s3_olci_optimization/olci_multiscale.py | 5 ++++- tests/test_olci_multiscale.py | 19 +++++++++++++++++++ 3 files changed, 27 insertions(+), 3 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 803f4941..5c2381c0 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -382,9 +382,11 @@ def convert_olci_optimized( # and child nodes; an ancillary group reusing a swath dim name at a # different size would make assembly fail even though the store was # written correctly. Never mask a successful write: re-add groups - # greedily and exclude only the ones that break assembly. + # greedily and exclude only the ones that break assembly. Consider + # parents before children (sorted by path depth) so an implicit empty + # parent materialized for a nested group can't shadow the real one. kept: dict[str, xr.Dataset] = {"/measurements": tree_dict["/measurements"]} - for group_path, ds in tree_dict.items(): + for group_path, ds in sorted(tree_dict.items(), key=lambda item: item[0].count("/")): if group_path == "/measurements": continue candidate = {**kept, group_path: ds} diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 7b4d4344..4598dd4c 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -137,7 +137,10 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # coarsen().mean() is available at runtime; pyright stubs don't expose .mean() # on DataArrayCoarsen, so we suppress the type-check on the reduction call. coarsened = float_var.coarsen({"rows": factor, "columns": factor}, boundary="trim") - averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] + # skipna=True explicitly: the fill-aware promise (one fill pixel + # must not contaminate its block) depends on it, so don't rely on + # the version-dependent default. + averaged: xr.DataArray = coarsened.mean(skipna=True) # type: ignore[attr-defined,assignment] # Materialize once: with dask-backed input, the isnull()/where()/ # .values accesses below would otherwise each re-evaluate the # coarsen+mask graph — the heaviest compute in the converter. diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index af505789..57216711 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -329,3 +329,22 @@ def test_reduce_all_fill_block_stays_fill() -> None: out = reduce_swath(ds, factor=2) assert int(out["oa01_radiance"].values[0, 0]) == 1000 + + +def test_reduce_partially_filled_block_averages_valid_pixels_only() -> None: + """A block mixing fill and valid pixels averages only the valid pixels. + + Block [[100, 200], [300, fill]] with _FillValue=65535 must average the + three valid pixels (200), not collapse to fill or include the sentinel. + """ + rad = xr.DataArray( + np.array([[100, 200], [300, 65535]], dtype="uint16"), + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + lat = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + lon = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + ds = xr.Dataset({"oa01_radiance": rad}, coords={"latitude": lat, "longitude": lon}) + + out = reduce_swath(ds, factor=2) + assert int(out["oa01_radiance"].values[0, 0]) == 200 From b2606b21d0bbd69674e2b328f7e08d8e742f3940 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 6 Jul 2026 15:26:09 +0200 Subject: [PATCH 35/58] fix(s3-olci): truncate store on re-run; handle transposed swath dims Truncate any pre-existing store before the first write so re-running convert_olci_optimized against the same output path cannot leave stale overview or ancillary groups from a prior run (the per-group writes were mode="w" scoped to measurements plus mode="a" appends). Tested by converting twice with different min_dimension values. Make swath detection in reduce_swath order-insensitive: a band stored transposed as (columns, rows) is normalized to (rows, columns) and fill-aware block-averaged instead of silently falling through to stride decimation. Document the origin-vs-center offset between decimated overview coordinates and block-averaged radiance in the reduce_swath docstring. Assisted-by: ClaudeCode:claude-fable-5 --- .../s3_olci_optimization/olci_converter.py | 7 +++++ .../s3_olci_optimization/olci_multiscale.py | 19 +++++++++++- tests/test_olci_integration.py | 29 +++++++++++++++++++ tests/test_olci_multiscale.py | 21 ++++++++++++++ 4 files changed, 75 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 5c2381c0..e2bb9261 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -275,6 +275,13 @@ def convert_olci_optimized( # correctly with raw integer data. measurements = _sanitize_data_vars(measurements) + # Truncate any pre-existing store first: the writes below are per-group + # (mode="w" scoped to measurements, mode="a" for overviews/ancillary), so + # a prior run with more overview levels or extra ancillary groups would + # otherwise leave stale sibling groups behind, and the returned DataTree + # (built by re-scanning the store) would surface them. + zarr.open_group(output_path, mode="w", zarr_format=3) + log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) measurements.to_zarr( output_path, diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 4598dd4c..d620b778 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -19,6 +19,7 @@ from typing import TYPE_CHECKING import numpy as np +import structlog import xarray as xr from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS @@ -26,6 +27,8 @@ if TYPE_CHECKING: from zarr_cm import SpatialAttrs +log = structlog.get_logger() + SWATH_DIMS = ("rows", "columns") @@ -64,6 +67,13 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: in :data:`OLCI_BANDS` (e.g. latitude, longitude, altitude) are decimated ``[::factor, ::factor]`` to preserve real on-ground positions. + Note the resulting origin-vs-center mismatch: coordinates sample each + block's *origin* pixel while radiance averages the whole block, so + overview coordinates sit ~half a block off the averaged value's effective + center, growing with each level. This is acceptable for the + visualization-oriented overviews these feed; do not treat overview + coordinates as block centers. + Variables that do not span exactly ``(rows, columns)`` are passed through unchanged. @@ -116,9 +126,16 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] for name in all_names: var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] - is_swath_2d: bool = tuple(str(d) for d in var.dims) == SWATH_DIMS + # Order-insensitive: a variant product storing a band transposed as + # (columns, rows) must still get fill-aware averaging, not silently + # fall through to stride decimation. Normalize to SWATH_DIMS below. + var_dims = tuple(str(d) for d in var.dims) + is_swath_2d: bool = len(var_dims) == 2 and set(var_dims) == set(SWATH_DIMS) if name in olci_band_set and is_swath_2d: + if var_dims != SWATH_DIMS: + log.info("Transposing band to canonical swath dim order", band=name) + var = var.transpose(*SWATH_DIMS) # Fill-aware block averaging for radiance bands. fill_value: int | float | None = var.attrs.get("_FillValue") if fill_value is None: diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index af2cf1b1..8d893649 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -406,3 +406,32 @@ def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: assert result.get("units") == "W m-2 sr-1 um-1", "units must be preserved" assert result.get("standard_name") == "toa_upwelling_spectral_radiance" assert result.get("coordinates") == "latitude longitude altitude" + + +def test_convert_olci_rerun_removes_stale_overview_groups(tmp_path: object) -> None: + """Re-running against an existing output path must not leave stale groups. + + The first run (small min_dimension) produces more overview levels than the + second; without up-front store truncation the extra r{N} groups from run + one would survive run two. + """ + import zarr + + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized( + build_synthetic_olci(rows=256, cols=256), output_path=out, min_dimension=64 + ) + root = zarr.open_group(out, mode="r") + meas = root["measurements"] + assert isinstance(meas, zarr.Group) + levels_first = {k for k in meas.group_keys() if k.startswith("r")} + assert "r4" in levels_first + + convert_olci_optimized( + build_synthetic_olci(rows=256, cols=256), output_path=out, min_dimension=128 + ) + root = zarr.open_group(out, mode="r") + meas = root["measurements"] + assert isinstance(meas, zarr.Group) + levels_second = {k for k in meas.group_keys() if k.startswith("r")} + assert levels_second == {"r2"}, f"stale overview groups survived re-run: {levels_second}" diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 57216711..3e348f8c 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -348,3 +348,24 @@ def test_reduce_partially_filled_block_averages_valid_pixels_only() -> None: out = reduce_swath(ds, factor=2) assert int(out["oa01_radiance"].values[0, 0]) == 200 + + +def test_reduce_transposed_band_still_block_averaged() -> None: + """A radiance band stored as (columns, rows) is averaged, not decimated. + + Swath detection is order-insensitive: the transposed band is normalized to + (rows, columns) and fill-aware block-averaged. Stride decimation would + keep the block's origin value (10) instead of the block mean (25). + """ + rad = xr.DataArray( + np.array([[10, 20], [30, 40]], dtype="uint16"), + dims=("columns", "rows"), + attrs={"_FillValue": 65535}, + ) + lat = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + lon = xr.DataArray(np.zeros((2, 2)), dims=("rows", "columns")) + ds = xr.Dataset({"oa01_radiance": rad}, coords={"latitude": lat, "longitude": lon}) + + out = reduce_swath(ds, factor=2) + assert tuple(out["oa01_radiance"].dims) == ("rows", "columns") + assert int(out["oa01_radiance"].values[0, 0]) == 25 From c2b4fc0baa265d0f571576aaf39d45a3a76edb43 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 7 Jul 2026 13:10:49 +0200 Subject: [PATCH 36/58] docs(s3-olci): plot each pyramid level on its own native grid in notebook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The quadrant visualization nearest-neighbour upsampled every overview back onto the native pixel grid, so nothing in the figure was actually shown at its stored resolution. Replace it with a 2x2 panel figure where each panel pcolormeshes one level's radiance against that level's own decimated 2-D latitude/longitude — same swath coverage per panel, visibly larger native cells per level, no resampling. Levels are picked dynamically from the finest affordable (<~600k quads) to the coarsest. Also make the offline fixture fallback independent of the kernel's working directory (nbconvert starts in docs/notebooks/), and silence consolidated-metadata warnings when opening levels. Assisted-by: ClaudeCode:claude-fable-5 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 316 ++++++++------------ 1 file changed, 130 insertions(+), 186 deletions(-) diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index 1ca7536b..b9a404af 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -12,8 +12,9 @@ "1. **Open** an EOPF Zarr Sentinel-3 OLCI L1 EFR product.\n", "2. **Detect** that it is an OLCI product.\n", "3. **Convert** it to a GeoZarr-compliant, multiscale Zarr store.\n", - "4. **Visualize** the multiscale pyramid by splitting one field of view into\n", - " four quadrants, each rendered from a *different* overview level.\n", + "4. **Visualize** the multiscale pyramid by rendering the same band from\n", + " several overview levels, each on its **own native (decimated)\n", + " latitude/longitude grid** — no resampling onto a shared grid.\n", "\n", "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", "no projected CRS). The exporter preserves that native geometry — it does not\n", @@ -30,10 +31,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:23.118582Z", - "iopub.status.busy": "2026-06-23T10:17:23.118408Z", - "iopub.status.idle": "2026-06-23T10:17:24.799718Z", - "shell.execute_reply": "2026-06-23T10:17:24.799151Z" + "iopub.execute_input": "2026-07-07T11:01:34.328216Z", + "iopub.status.busy": "2026-07-07T11:01:34.327856Z", + "iopub.status.idle": "2026-07-07T11:01:36.220206Z", + "shell.execute_reply": "2026-07-07T11:01:36.219788Z" } }, "outputs": [], @@ -76,10 +77,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:24.802088Z", - "iopub.status.busy": "2026-06-23T10:17:24.801845Z", - "iopub.status.idle": "2026-06-23T10:17:25.546984Z", - "shell.execute_reply": "2026-06-23T10:17:25.546382Z" + "iopub.execute_input": "2026-07-07T11:01:36.221762Z", + "iopub.status.busy": "2026-07-07T11:01:36.221623Z", + "iopub.status.idle": "2026-07-07T11:01:37.035025Z", + "shell.execute_reply": "2026-07-07T11:01:37.034564Z" } }, "outputs": [ @@ -113,9 +114,20 @@ " return dt\n", " except Exception as exc: # noqa: BLE001 - notebook offline fallback\n", " print(f\"Remote open failed ({type(exc).__name__}); using bundled fixture.\")\n", + " import sys\n", + "\n", + " # Resolve the repo root regardless of the kernel's working directory\n", + " # (interactive runs start in docs/notebooks/, CI may start at the root).\n", + " repo_root = next(\n", + " p\n", + " for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents)\n", + " if (p / \"tests\" / \"_test_data\").exists()\n", + " )\n", + " if str(repo_root) not in sys.path:\n", + " sys.path.insert(0, str(repo_root))\n", " from tests.conftest import create_group_from_json\n", "\n", - " fixture = pathlib.Path(\n", + " fixture = repo_root / (\n", " \"tests/_test_data/s3_examples/\"\n", " \"S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_\"\n", " \"0179_132_149_2160_PS1_O_NT_004.json\"\n", @@ -146,10 +158,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.548827Z", - "iopub.status.busy": "2026-06-23T10:17:25.548535Z", - "iopub.status.idle": "2026-06-23T10:17:25.552958Z", - "shell.execute_reply": "2026-06-23T10:17:25.552363Z" + "iopub.execute_input": "2026-07-07T11:01:37.036756Z", + "iopub.status.busy": "2026-07-07T11:01:37.036635Z", + "iopub.status.idle": "2026-07-07T11:01:37.039322Z", + "shell.execute_reply": "2026-07-07T11:01:37.038951Z" } }, "outputs": [ @@ -191,10 +203,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.554630Z", - "iopub.status.busy": "2026-06-23T10:17:25.554431Z", - "iopub.status.idle": "2026-06-23T10:17:25.629450Z", - "shell.execute_reply": "2026-06-23T10:17:25.628795Z" + "iopub.execute_input": "2026-07-07T11:01:37.040895Z", + "iopub.status.busy": "2026-07-07T11:01:37.040774Z", + "iopub.status.idle": "2026-07-07T11:01:37.076238Z", + "shell.execute_reply": "2026-07-07T11:01:37.075794Z" } }, "outputs": [ @@ -233,10 +245,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.631065Z", - "iopub.status.busy": "2026-06-23T10:17:25.630958Z", - "iopub.status.idle": "2026-06-23T10:18:59.861715Z", - "shell.execute_reply": "2026-06-23T10:18:59.861003Z" + "iopub.execute_input": "2026-07-07T11:01:37.077296Z", + "iopub.status.busy": "2026-07-07T11:01:37.077225Z", + "iopub.status.idle": "2026-07-07T11:09:57.911303Z", + "shell.execute_reply": "2026-07-07T11:09:57.910921Z" } }, "outputs": [ @@ -244,154 +256,154 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:17:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + "\u001b[2m2026-07-07 13:01:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:17:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + "\u001b[2m2026-07-07 13:02:00\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + "\u001b[2m2026-07-07 13:03:03\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + "\u001b[2m2026-07-07 13:03:52\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + "\u001b[2m2026-07-07 13:04:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + "\u001b[2m2026-07-07 13:05:30\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:29\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + "\u001b[2m2026-07-07 13:06:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:32\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + "\u001b[2m2026-07-07 13:07:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + "\u001b[2m2026-07-07 13:07:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + "\u001b[2m2026-07-07 13:08:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 13:09:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { @@ -420,12 +432,14 @@ "id": "1c5310cc", "metadata": {}, "source": [ - "### Load one band at every pyramid level\n", + "### Load every pyramid level\n", "\n", "Level `.` is the native resolution written at the measurements group root;\n", - "`r2`, `r4`, … are successively coarser block-averaged overviews. We read with\n", - "default decoding so the stored `uint16` radiance is scaled to physical units\n", - "for display." + "`r2`, `r4`, … are successively coarser block-averaged overviews. Each level is\n", + "opened as a Dataset so we get the radiance band **together with that level's\n", + "own decimated `latitude`/`longitude` coordinates**. We read with default\n", + "decoding so the stored `uint16` radiance is scaled to physical units (and fill\n", + "pixels become NaN) for display." ] }, { @@ -434,64 +448,13 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:18:59.864062Z", - "iopub.status.busy": "2026-06-23T10:18:59.863872Z", - "iopub.status.idle": "2026-06-23T10:19:00.100825Z", - "shell.execute_reply": "2026-06-23T10:19:00.100149Z" + "iopub.execute_input": "2026-07-07T11:09:57.912794Z", + "iopub.status.busy": "2026-07-07T11:09:57.912727Z", + "iopub.status.idle": "2026-07-07T11:09:57.970795Z", + "shell.execute_reply": "2026-07-07T11:09:57.970451Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -507,32 +470,21 @@ "r256: shape (15, 19)\n", "r512: shape (7, 9)\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" - ] } ], "source": [ "BAND = \"oa08_radiance\" # ~665 nm (red); good visual contrast\n", "\n", "\n", - "def read_level(level: str) -> xr.DataArray:\n", + "def read_level(level: str) -> xr.Dataset:\n", + " \"\"\"Open one pyramid level as a Dataset (band + its decimated lat/lon).\"\"\"\n", " group = \"measurements\" if level == \".\" else f\"measurements/{level}\"\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - " return ds[BAND]\n", + " return xr.open_dataset(output_path, engine=\"zarr\", group=group, consolidated=False)\n", "\n", "\n", - "level_arrays = {lvl: read_level(lvl) for lvl in levels}\n", - "for lvl, arr in level_arrays.items():\n", - " print(f\"{lvl:>4}: shape {tuple(arr.shape)}\")" + "level_datasets = {lvl: read_level(lvl) for lvl in levels}\n", + "for lvl, ds in level_datasets.items():\n", + " print(f\"{lvl:>4}: shape {tuple(ds[BAND].shape)}\")" ] }, { @@ -540,16 +492,17 @@ "id": "95da72f9", "metadata": {}, "source": [ - "## 4. Multiscale quadrant visualization\n", + "## 4. Each pyramid level on its own native grid\n", "\n", - "To show the pyramid in a single field of view, we split the native-resolution\n", - "image into four quadrants and fill each quadrant with data from a **different**\n", - "overview level. Each level's array is nearest-neighbour upsampled back to the\n", - "native quadrant size, so coarser levels render as visibly blockier — the\n", - "resolution drop is the point.\n", + "Each panel below draws one level **exactly as stored**: that level's radiance\n", + "array plotted against its own decimated 2-D latitude/longitude coordinates\n", + "with `pcolormesh`. Nothing is resampled onto a shared grid — every panel\n", + "covers the same swath in geographic coordinates, while the native cells get\n", + "4× larger (2× per axis) with each level shown.\n", "\n", - "Top-left = native, top-right = `r2`, bottom-left = `r4`, bottom-right = the\n", - "next coarser level available (clamped to the coarsest if fewer exist)." + "The finest levels (native, `r2`, `r4`) are stored identically but skipped\n", + "here only because `pcolormesh` with millions of quads is slow to render; we\n", + "pick four levels spanning the affordable range down to the coarsest." ] }, { @@ -558,18 +511,25 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:19:00.103316Z", - "iopub.status.busy": "2026-06-23T10:19:00.103038Z", - "iopub.status.idle": "2026-06-23T10:19:04.459494Z", - "shell.execute_reply": "2026-06-23T10:19:04.458850Z" + "iopub.execute_input": "2026-07-07T11:09:57.971838Z", + "iopub.status.busy": "2026-07-07T11:09:57.971770Z", + "iopub.status.idle": "2026-07-07T11:09:58.618700Z", + "shell.execute_reply": "2026-07-07T11:09:58.618229Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Levels shown: ['r8', 'r32', 'r128', 'r512']\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -577,55 +537,37 @@ } ], "source": [ - "def to_native_grid(arr: xr.DataArray, ny: int, nx: int) -> np.ndarray:\n", - " \"\"\"Nearest-neighbour upsample a (rows, columns) array to (ny, nx).\"\"\"\n", - " a = np.asarray(arr.values, dtype=float)\n", - " row_idx = (np.arange(ny) * a.shape[0] // ny).clip(0, a.shape[0] - 1)\n", - " col_idx = (np.arange(nx) * a.shape[1] // nx).clip(0, a.shape[1] - 1)\n", - " return a[np.ix_(row_idx, col_idx)]\n", + "# Pick four levels: the finest that is still cheap to draw as quads, through\n", + "# the coarsest available (deduplicated for small fixture inputs).\n", + "MAX_CELLS = 600_000\n", + "candidates = [lvl for lvl in levels if level_datasets[lvl][BAND].size <= MAX_CELLS]\n", + "pick = sorted(set(np.linspace(0, len(candidates) - 1, 4).round().astype(int)))\n", + "show_levels = [candidates[i] for i in pick]\n", + "print(\"Levels shown:\", show_levels)\n", "\n", - "\n", - "native = level_arrays[\".\"]\n", - "ny, nx = native.shape\n", - "hy, hx = ny // 2, nx // 2\n", - "\n", - "# Choose four levels (native + up to three coarser), clamped to what exists.\n", - "chosen = [levels[min(i, len(levels) - 1)] for i in range(4)]\n", - "\n", - "# Build a single canvas: each quadrant upsampled from its chosen level.\n", - "canvas = np.empty((ny, nx), dtype=float)\n", - "quadrants = {\n", - " (slice(0, hy), slice(0, hx)): chosen[0], # top-left\n", - " (slice(0, hy), slice(hx, nx)): chosen[1], # top-right\n", - " (slice(hy, ny), slice(0, hx)): chosen[2], # bottom-left\n", - " (slice(hy, ny), slice(hx, nx)): chosen[3], # bottom-right\n", - "}\n", - "for (rsl, csl), lvl in quadrants.items():\n", - " full = to_native_grid(level_arrays[lvl], ny, nx)\n", - " canvas[rsl, csl] = full[rsl, csl]\n", - "\n", - "fig, ax = plt.subplots(figsize=(7, 7))\n", - "im = ax.imshow(canvas, cmap=\"viridis\")\n", - "ax.axhline(hy - 0.5, color=\"white\", lw=1)\n", - "ax.axvline(hx - 0.5, color=\"white\", lw=1)\n", - "labels = {\n", - " (hx / 2, hy / 2): chosen[0],\n", - " (hx + hx / 2, hy / 2): chosen[1],\n", - " (hx / 2, hy + hy / 2): chosen[2],\n", - " (hx + hx / 2, hy + hy / 2): chosen[3],\n", - "}\n", - "for (x, y), lvl in labels.items():\n", - " res = 1 if lvl == \".\" else int(lvl[1:])\n", - " name = \"native (r1)\" if lvl == \".\" else lvl\n", - " ax.text(\n", - " x, y, f\"{name}\\n1/{res} res\", color=\"white\", ha=\"center\", va=\"center\",\n", - " fontweight=\"bold\", bbox={\"facecolor\": \"black\", \"alpha\": 0.4, \"pad\": 3},\n", + "fig, axes = plt.subplots(2, 2, figsize=(11, 10), sharex=True, sharey=True)\n", + "for ax in axes.flat[len(show_levels) :]:\n", + " ax.set_visible(False)\n", + "for ax, lvl in zip(axes.flat, show_levels):\n", + " ds = level_datasets[lvl]\n", + " band = ds[BAND]\n", + " # This level's own decimated coordinates: the native grid of the level.\n", + " mesh = ax.pcolormesh(\n", + " ds[\"longitude\"],\n", + " ds[\"latitude\"],\n", + " band,\n", + " cmap=\"viridis\",\n", + " shading=\"nearest\",\n", + " rasterized=True,\n", " )\n", - "ax.set_title(f\"OLCI {BAND}: one FOV, four pyramid levels\")\n", - "ax.set_xlabel(\"columns (across-track)\")\n", - "ax.set_ylabel(\"rows (along-track)\")\n", - "fig.colorbar(im, ax=ax, shrink=0.8, label=\"radiance (scaled)\")\n", - "plt.tight_layout()\n", + " res = 1 if lvl == \".\" else int(lvl[1:])\n", + " name = \"native\" if lvl == \".\" else lvl\n", + " ax.set_title(f\"{name}: {band.shape[0]} × {band.shape[1]} native cells (1/{res} res)\")\n", + " ax.set_aspect(\"equal\")\n", + "fig.supxlabel(\"longitude\")\n", + "fig.supylabel(\"latitude\")\n", + "fig.colorbar(mesh, ax=axes, shrink=0.7, label=f\"{BAND} (scaled radiance)\")\n", + "fig.suptitle(f\"OLCI {BAND}: same swath, each level on its own native grid\")\n", "plt.show()" ] }, @@ -634,9 +576,11 @@ "id": "b4beef58", "metadata": {}, "source": [ - "Each quadrant covers the same ground area but is drawn from a coarser level as\n", - "you move down/right — the blockier quadrants are the lower-resolution overviews\n", - "from the multiscale pyramid, all produced by the single conversion above." + "All panels cover the same geographic swath, but each is drawn from that\n", + "level's own stored arrays — radiance plus its decimated latitude/longitude —\n", + "so the visible cell size is the level's true native resolution. The\n", + "coarsening from panel to panel is the multiscale pyramid itself, produced by\n", + "the single conversion above." ] } ], @@ -656,7 +600,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.13" + "version": "3.13.9" } }, "nbformat": 4, From 55b950a18b8d77723c95aaa9ee377b9b08f439eb Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 7 Jul 2026 16:26:01 +0200 Subject: [PATCH 37/58] feat(s3-olci): overview lat/lon are geodesic block centroids, not decimated MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Overview coordinates were stride-decimated, labeling each block-averaged radiance cell with its block's top-left corner pixel — up to half a block (~77 km at r512) away from the centroid of the pixels actually averaged, and never converging to the swath center under repeated reduction. reduce_swath now reduces the 2-D latitude/longitude pair (matched by CF standard_name, falling back to variable name) jointly: pixel positions are mapped to unit vectors on the sphere, block-averaged with fill awareness (a pixel fill in either array is excluded from both), and the mean direction is converted back to degrees. Each overview cell is therefore geolocated at the geodesic centroid of its source block, stable across the antimeridian and at the poles, and collapsing the whole swath to one cell yields its geodesic center. Because the converter runs on un-decoded data and OLCI packs geolocation as int32 microdegrees (scale_factor=1e-06), values are CF-unpacked before the trigonometry and re-packed after, preserving dtype and attrs; feeding raw packed integers into the trig collapses every coordinate to ~(0, 0) (caught on the real EODC product, covered by regression test). Other non-band swath variables (e.g. altitude) keep stride decimation. Notebook re-executed against the real product; prose updated to describe the centroid coordinates. Assisted-by: ClaudeCode:claude-fable-5 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 134 +++++++------- .../s3_olci_optimization/olci_multiscale.py | 170 +++++++++++++++--- tests/test_olci_multiscale.py | 142 +++++++++++++-- 3 files changed, 348 insertions(+), 98 deletions(-) diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index b9a404af..0f97ea21 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -13,13 +13,16 @@ "2. **Detect** that it is an OLCI product.\n", "3. **Convert** it to a GeoZarr-compliant, multiscale Zarr store.\n", "4. **Visualize** the multiscale pyramid by rendering the same band from\n", - " several overview levels, each on its **own native (decimated)\n", - " latitude/longitude grid** — no resampling onto a shared grid.\n", + " several overview levels, each on its **own native latitude/longitude\n", + " grid** — no resampling onto a shared grid.\n", "\n", "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", "no projected CRS). The exporter preserves that native geometry — it does not\n", - "reproject — and builds overviews by fill-aware 2×2 block averaging of the\n", - "radiance bands (coordinates are decimated to keep real measured positions).\n", + "reproject. Radiance overviews are fill-aware 2×2 block means, and each\n", + "overview's latitude/longitude are the **geodesic centroids** of the same\n", + "pixel blocks (a unit-vector mean on the sphere, stable across the\n", + "antimeridian), so every overview cell is geolocated at the center of the\n", + "pixels it averages.\n", "\n", "> Requires the `notebooks` dependency group:\n", "> `uv sync --group notebooks` (jupyter, matplotlib, nbformat)." @@ -31,10 +34,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:01:34.328216Z", - "iopub.status.busy": "2026-07-07T11:01:34.327856Z", - "iopub.status.idle": "2026-07-07T11:01:36.220206Z", - "shell.execute_reply": "2026-07-07T11:01:36.219788Z" + "iopub.execute_input": "2026-07-07T13:32:41.979509Z", + "iopub.status.busy": "2026-07-07T13:32:41.979034Z", + "iopub.status.idle": "2026-07-07T13:32:43.330407Z", + "shell.execute_reply": "2026-07-07T13:32:43.329984Z" } }, "outputs": [], @@ -77,10 +80,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:01:36.221762Z", - "iopub.status.busy": "2026-07-07T11:01:36.221623Z", - "iopub.status.idle": "2026-07-07T11:01:37.035025Z", - "shell.execute_reply": "2026-07-07T11:01:37.034564Z" + "iopub.execute_input": "2026-07-07T13:32:43.331695Z", + "iopub.status.busy": "2026-07-07T13:32:43.331550Z", + "iopub.status.idle": "2026-07-07T13:32:43.935473Z", + "shell.execute_reply": "2026-07-07T13:32:43.935053Z" } }, "outputs": [ @@ -158,10 +161,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:01:37.036756Z", - "iopub.status.busy": "2026-07-07T11:01:37.036635Z", - "iopub.status.idle": "2026-07-07T11:01:37.039322Z", - "shell.execute_reply": "2026-07-07T11:01:37.038951Z" + "iopub.execute_input": "2026-07-07T13:32:43.937106Z", + "iopub.status.busy": "2026-07-07T13:32:43.936993Z", + "iopub.status.idle": "2026-07-07T13:32:43.939521Z", + "shell.execute_reply": "2026-07-07T13:32:43.939153Z" } }, "outputs": [ @@ -203,10 +206,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:01:37.040895Z", - "iopub.status.busy": "2026-07-07T11:01:37.040774Z", - "iopub.status.idle": "2026-07-07T11:01:37.076238Z", - "shell.execute_reply": "2026-07-07T11:01:37.075794Z" + "iopub.execute_input": "2026-07-07T13:32:43.940626Z", + "iopub.status.busy": "2026-07-07T13:32:43.940546Z", + "iopub.status.idle": "2026-07-07T13:32:43.978585Z", + "shell.execute_reply": "2026-07-07T13:32:43.978079Z" } }, "outputs": [ @@ -245,10 +248,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:01:37.077296Z", - "iopub.status.busy": "2026-07-07T11:01:37.077225Z", - "iopub.status.idle": "2026-07-07T11:09:57.911303Z", - "shell.execute_reply": "2026-07-07T11:09:57.910921Z" + "iopub.execute_input": "2026-07-07T13:32:43.979912Z", + "iopub.status.busy": "2026-07-07T13:32:43.979841Z", + "iopub.status.idle": "2026-07-07T13:35:49.840011Z", + "shell.execute_reply": "2026-07-07T13:35:49.839427Z" } }, "outputs": [ @@ -256,154 +259,154 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:01:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + "\u001b[2m2026-07-07 15:32:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:02:00\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + "\u001b[2m2026-07-07 15:33:03\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:03:03\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + "\u001b[2m2026-07-07 15:34:11\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:03:52\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + "\u001b[2m2026-07-07 15:34:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:04:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + "\u001b[2m2026-07-07 15:34:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:05:30\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + "\u001b[2m2026-07-07 15:34:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:06:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + "\u001b[2m2026-07-07 15:34:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:07:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:05\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:07:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:14\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:08:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:24\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 13:09:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { @@ -437,9 +440,9 @@ "Level `.` is the native resolution written at the measurements group root;\n", "`r2`, `r4`, … are successively coarser block-averaged overviews. Each level is\n", "opened as a Dataset so we get the radiance band **together with that level's\n", - "own decimated `latitude`/`longitude` coordinates**. We read with default\n", - "decoding so the stored `uint16` radiance is scaled to physical units (and fill\n", - "pixels become NaN) for display." + "own `latitude`/`longitude` coordinates** (the geodesic centroids of that\n", + "level's pixel blocks). We read with default decoding so the stored `uint16`\n", + "radiance is scaled to physical units (and fill pixels become NaN) for display." ] }, { @@ -448,10 +451,10 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:09:57.912794Z", - "iopub.status.busy": "2026-07-07T11:09:57.912727Z", - "iopub.status.idle": "2026-07-07T11:09:57.970795Z", - "shell.execute_reply": "2026-07-07T11:09:57.970451Z" + "iopub.execute_input": "2026-07-07T13:35:49.842045Z", + "iopub.status.busy": "2026-07-07T13:35:49.841926Z", + "iopub.status.idle": "2026-07-07T13:35:49.920330Z", + "shell.execute_reply": "2026-07-07T13:35:49.919847Z" } }, "outputs": [ @@ -477,7 +480,7 @@ "\n", "\n", "def read_level(level: str) -> xr.Dataset:\n", - " \"\"\"Open one pyramid level as a Dataset (band + its decimated lat/lon).\"\"\"\n", + " \"\"\"Open one pyramid level as a Dataset (band + its own lat/lon).\"\"\"\n", " group = \"measurements\" if level == \".\" else f\"measurements/{level}\"\n", " return xr.open_dataset(output_path, engine=\"zarr\", group=group, consolidated=False)\n", "\n", @@ -495,10 +498,10 @@ "## 4. Each pyramid level on its own native grid\n", "\n", "Each panel below draws one level **exactly as stored**: that level's radiance\n", - "array plotted against its own decimated 2-D latitude/longitude coordinates\n", - "with `pcolormesh`. Nothing is resampled onto a shared grid — every panel\n", - "covers the same swath in geographic coordinates, while the native cells get\n", - "4× larger (2× per axis) with each level shown.\n", + "array plotted against its own 2-D latitude/longitude coordinates with\n", + "`pcolormesh`. Nothing is resampled onto a shared grid — every panel covers\n", + "the same swath in geographic coordinates, while the native cells get 4×\n", + "larger (2× per axis) with each level shown.\n", "\n", "The finest levels (native, `r2`, `r4`) are stored identically but skipped\n", "here only because `pcolormesh` with millions of quads is slow to render; we\n", @@ -511,10 +514,10 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T11:09:57.971838Z", - "iopub.status.busy": "2026-07-07T11:09:57.971770Z", - "iopub.status.idle": "2026-07-07T11:09:58.618700Z", - "shell.execute_reply": "2026-07-07T11:09:58.618229Z" + "iopub.execute_input": "2026-07-07T13:35:49.921691Z", + "iopub.status.busy": "2026-07-07T13:35:49.921606Z", + "iopub.status.idle": "2026-07-07T13:35:50.209387Z", + "shell.execute_reply": "2026-07-07T13:35:50.208895Z" } }, "outputs": [ @@ -527,7 +530,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAPeCAYAAADj5iyNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQWYXMeVts+9zTA9PKMRS5YlMzuOY8d2EjtxOBvaJH842Q0zx2EmW2FmzmYDG7KT7AZsJ3bMDJIli0fDM818/+c7p6pJI2lG2LLO+zxye7pvX6h7u6q+OuR4nueRoiiKoiiKoiiKorQx7uE+AUVRFEVRFEVRFEXZGypeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFUR6CPPzhD6eLLrqo6b3FixfTi1/84sN2TspDh3g8Tq997WvpaL+OdvpNtdO5tOP5HC0c6e0+n/OfbZxTHvqoeFUUhcrlMn3ta1+j888/n7q6uigcDtOxxx5Lr3/962nbtm27tNBJJ51Exx133F5brlqt0g9/+EN63OMeR/39/RQKhWjZsmX0mMc8hr71rW9RNpud9z4PBtdccw1deOGFFIvF+Pqf/vSn04YNG3bZrlgs0uWXX06nnHIKdXR0UG9vLz3iEY+gn/70p4flvBXlYNLX10cvf/nLtZEVfabaDP1tKkczKl4V5Sgnk8nQJZdcQu94xzvoBS94Aa1fv56mpqbou9/9Lt18880s1P7xj3/Me78Qpo9//OPpVa96FV188cV04403UiqVoquvvpoe+9jH0hvf+Eb68pe/TIebf/7zn3x+J598Mgv1O++8k3K5HAv5nTt3Nm37spe9jN7+9rfTG97wBtq+fTvde++9dN5559Fzn/tc+tznPkftDq4P91VRFEX7m4cmR3o/f6Sfv3LwUfGqKEc5r3vd69jy+Ic//IFe8YpXsIU0EomwKPu///s/Wr58Of3bv/0bTUxMzHu/+P6VV15Jb3vb23g/wWCQLa8QyjfddBMtWrSIDjdvfetb+dw+//nPU3d3Ny1ZsoR+8IMf0PT0NH30ox9tsrr+5Cc/YUEOEZtIJGhgYIA+/elP83V873vfO6zXoSiKoiiK8lBHxauiHMVs3ryZRdczn/lMdn9tBe7DEHBjY2P0la98ZV77xcrps5/9bLZgzsaaNWvYYrkvLs4f+9jH+PtwQ4bYfs5znkMbN25s2u6ss84ix3H4n9/vp4ULF9ILX/hCtphaduzYQddddx095SlPIdd1m1yyHvnIR9LPf/7z2nuBQICi0ehuz6uzs3Of4+1g2Ub7Y9HgIx/5yJzPHxQKBXrLW95CCxYsYLdnuGi3tsWeYonmehx7rjfccAOde+65fK4rVqygr371q7MeC+7iuCbrXv3Upz6V7rjjjqZtsEjwsIc9jNsV+4cHAPbfyAc+8AE+t7/97W97bc9f/epXfG5w/e7p6eFYKCye7M/1YmHn7LPP5nPEd+FBAP7+97/zuaMd4O7+xz/+cdZzmss17su1PO95z6OVK1c2fQdeDriuD33oQ02LLjgunpG5tkE6nebPsGAF93677Wy/5bk+D3NlLu0113s41+fwcFzHGWecQaeddtqs373gggu4f5vP/g5GHzrf3/ye+pu5PFNz+f3u6/Xsz+9lf9thPt8/EL/N1n7+UD1r8Fh605vetMtYNFtc6p7GvtnGqfmMc8pRgKcoylHLN77xDQ/dwPe+973dblMoFLxgMOidf/75tfdOPPFEb82aNXvd7/e///05n8ve9ml57nOf60UiEe+73/2uNzU15d16663eWWed5fX19XmbN2+e9TvZbNa77rrrvDPPPJP/lUolfv+qq67i88T5tvL617+ePxsdHa2998UvftHz+/3eN7/5TW9mZoY/e+tb3+pFo1Hvr3/9qzdfYrGY97jHPc57ylOe4t1zzz3eli1bvN/85jdzPn/w9Kc/3UskEt7Pf/5zPidsh32ecsop3oUXXti0n0WLFnkvetGLdns+ezoOzvUJT3iC96xnPcu77777vMnJSe9tb3sbt9HVV1/dtB+0SSAQ8D7ykY/wPcG2v/3tb72XvvSltW3e+c538nN1xRVXeDt37vR27Njhve51r/NCoZB344031rZ7//vfz8fYW/v+85//9FzX9T760Y964+PjXjKZ9K655hrviU98opfP5/fpei+99FLvOc95jrdhwwZvZGTEe9rTnsbP2bXXXus94xnP8NavX8/PAP4f209MTDTtf67XuC/X8u1vf5vbZd26dbXvrVq1in8b5513Xu29v/3tb7zdlVdeOe826O3t9V72spfN+r35PA9zZV/aa0/nP5fncH+vY7bf1FyuA30JjnHTTTc1fRf3E+9/8pOfnHe77O33Pd8+9GC0ze6eqX35/c7nevbn97K/7bCv39/X32Zrux+MZ202nvrUp3qdnZ3eL37xCx6L/vWvf/H9m20s2tPYN9tzM59xTnnoo+JVUY5i3vve9/LghQF7TyxbtsxbsmTJnIXme97znjntd77i9YYbbuD9fuhDH2p6HxMUTFJ3N5hbIDrw/euvv57//tGPfsR/Y0Bs5X3vex9/hoG1kU9/+tN8LHyGfxisf/WrX3n7AgbweDzuTU9Pz2n71vPH5AB/r127tmk7fI735yted3cce66YMKVSqdp7mEwNDAx4L3jBC2rv3XnnnZ7jON7b3/723e7/3nvv5W0uu+yypver1ap3xhln8KRkvnziE5/gfe5tojuf68XkN51O7zLZw28Bk2sLxC3e/9KXvnRArnEu17J161Y+Jiam4MEHH+S/3/Wud/ECCyZ4AMfHZDSTycy7DfYmXufyPMyV/X0mWs9/Ls/hgbiO1t/UXK8DIiscDnuvetWrmraDeMD9Gx4entf+ZjuX/e1DD3Tb7OmZ2tff71yvZ39+L/vbDvv7/fn+Nlvb/WA8a61ATOIcP/e5zzW9D8E821i0p7Gv9fznO84pD33UbVhRjmKwgDXX7eCadLhBDC1ANuBGli5dym5O9nNw11130bOe9SwaGhpi96tG16oHHnig6ft7urbGzxDHe9lll7ELNZJaIaETMjI/4xnPYBeufQFZjmdzOZ7L+dvrhdtzI+eccw67V82F+bQTXMzg7mXB9nA5a3Tfgpsfnhe46e2O3//+97wNjtsIjv3oRz+aXXLny6mnnsr7hCs6vg83s/29XriOw0XNsmrVKv4OXPDghmqBOyLcFRvbYX+ucS7XAtc6uCv/6U9/4r///Oc/c8w24svBX//619r7iF9vdHmfTxvsibk8D3NlPu01l/Ofy3N4OK8DrrHoNxBHn8/n+b1KpULf//736YlPfGLt93ugfyvz6UMPdNsciN/vvl7P/vxeDkQ7zPX7B+q32ciheNZs+z35yU9uev/MM89k1+f5jH2tHIhxTnlooeJVUY5ikDzJxqjuDsQAQaRhMjDf/W7ZsoUOJDZp1GwDFt4bHx+vxbJiAoKkS5jEJpNJHpRvu+02/rxUKvErYuAAhGgr+C5A7BW455576Itf/CK9+tWv5oRNmBAMDg5yvBQGdsT62P3Oh9mSVs31/G174Dxame29fT2OBROqVpC4yrYVGB0d3e11WWwWZ0xsMEHz+Xwcc4x/n/nMZ3iC1VhGaS5ceumlvICAbNmIr8KkCFmkkYjsQF0vJnEQs7O1Ayamje2wP9c4l2sBiEXDpBExf5h04znEhByTdvyN5xqJ0bDdvrbBnpjL8zBX5tpecz3/uTyHh/M6AMoQ4Ri/+MUv+G9cD64P/cu+7O9A9qEHo232xFyf+f25nn35vRyodpjL9w/kb7OVg/2s2fuAJIatzPYemGvCxv0d55SHHipeFeUoBpMDDEx7miBg1RMCFgkS5goGf+x3Lsk25oMVkiMjI7t8hveQaAn8+te/5oH/S1/6ElvJ7Cr6gw8+2PQdlMcB999//y77QxkcDIx24LXb2O80ghq1KAM0W8KYvYFEUK3M9fyt+N5de+yNuR7HMhfrO5KlgD21hb1PaFNMJGEFQE1g/DPhLHtMjrU7XvrSl3KpIwiXH/3oRzzZg2XBWgUO1PXOpR329xr3di32d4bnDklP8DtFCSqAV1iY/vKXv/DxGifj822DPXEgvTHm2l5zPf+5PIeH8zqs5QnW/G9/+9v8N14hcpDRfF/2dyD7UMuh9LiZyzO/P9ezL7+XA9UOc/n+gfxttnKwnzU7FtlFo0Zme293Y9+e9r2v45zy0EPFq6IcxaBEDGq7/vd//zfXO20FK61wk8Wg9spXvnJelldkC0S23tn2awdIuDHNh8c85jG1rJStdeGQDdF+boErZyNwk2oE7kxwPfrNb37DA7QFq/XIMosszI3XZN26WsGEC8c60KvAezt/WA7Ab3/726b30RatNWr35zjzAZNNTNR+/OMf73Wbn/3sZ3QwgHCBmxwmwAD38mBd78G+xj1dCyxUsJB84hOfoMnJydqkG6+wYH3jG9/gyT2yjbYylzaAlXmu7puHur32dv5zeQ4P93VgOwg2iLPrr7+efve739GLXvQivqf7sr+D0YceaObyTO3t97uv17M/v5dDycH4bR7sZ+1Rj3pUzfW4kVtvvZUtvPvDgRrnlIcOKl4V5SgHrrBIVY+B6+tf/zoLNwyKWJ2GZRYxOXA1al2R3xtf+MIXeECDO9jll1/OrslYSYcr8ac+9SkuCTBfSyXcu1B+B2URkM5/ZmaGy15gogO3zfe85z21lXSU+UE8E1Zmh4eH6d3vfnfTQG2BOxRWthG7CrcxTHog6OHSBeFuwYQG7fHlL3+ZywDBBQv7fv/738+r+G984xs53f+BYK7nD+H9tKc9jc/hl7/8Ja/a/+tf/+LyMqeccsoBO858OPHEE+nNb34zrV27lu/T1q1bua0wWbIuarBUv/Od76QPfvCD9MlPfpKfCZRZgGs2nhW4Zs+3VA62e9/73ke33347u7ahvBMsGPgurA4H63p3x3yucV+uBSDuFmUorrrqKraqoPyGfS7gdonyPZi8N5aBmk8b4BowQdzfyedc7uFc22uu5z+X5/BgMN/7jkU+3B/0a+gfITD2Z38Hqg89WOzumZrrM78/17Mvv5dDycH+bR7MZw3tijJUuIewIMPCjbJiGJvmMhbtif0d55SHHipeFeUoBwM8xBfquaLm6zHHHMPCDbXl4LqEiQCSTcxmObU15hr/wZoL4F4Et2FMQDBZQBwNVouRfAKThM9+9rPznngBrMa/613vog9/+MO8Qo9VWVhFMZjZY2NiggF0w4YNPEHB4AdhicGuFZwP4p1wnUjqgUkvJhDXXnvtLnFKsNBiYL/iiis4BviEE07ga8HK+Mc//nE6UMzn/GG9fslLXsI1CxHjBcH9+c9/fk5Cej7HmQ9YEIAVA/tGUpLVq1fTN7/5TRb4Fkw2cS/xjMAVG4sj//7v/84uZpiwzRck08J9Q1vgucB9RPwaXOLt5PdgXe/u2NdrnMu1WBqtRxbEqllLCBZcGplPG+A+4vj4zu7qvM4FW5tyb8lV5tJe8z3/vT2Hh/u+o495whOewOIa/eyxxx67X/s7UH3owWJ3z9R8nvn9uZ75/l4OJQf7t3mwnzWMRZg3vOIVr6iNRRjnIZhbrcnzZX/GOeWhh4OUw4f7JBRFURRFeWhy9tlnc0bmg+UmrihK+wKRDdGMxXFFORAceF8pRVEURVEUk8kbXg0//OEPtT0U5Sjj6quv5lCkvVnPFWU+qOVVURRFURRFUZR9BpZVxKOi1isSX1133XWc6BHu4Lfccou6+CoHDI15VRRFOYAgQ/FsscCN/2bLWKwoiqIoRypI2IQEj0g8BVdhxKgiARYStWlsqnIgUcuroiiKoiiKoiiK0vao5VVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFURRFURRFUZS2R8WroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFURRFURRFUZS2R8WroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFURRFURRFUZS2R8WroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFURRFURRFUZS2R8WroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoeFa+KoiiKoiiKoihK26PiVVEURVEURVEURWl7VLwqiqIoiqIoiqIobY+KV0VRFEVRFEVRFKXtUfGqKIqiKIqiKIqitD0qXhVFURRFURRFUZS2R8WroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9Kl4VRVEURVEURVGUtkfFq6IoiqIoiqIoitL2qHhVFEVRFEVRFEVR2h4Vr4qiKIqiKIqiKErbo+JVURRFURRFURRFaXtUvCqKoiiKoiiKoihtj4pXRVEURVEURVEUpe1R8aooiqIoiqIoiqK0PSpeFUU5pOTzecrlcg+5azgY11UulymTydDRSKVSoXQ6fbhPQ1GUPaD9+dw5mvvz+aB9v7I3VLwq+4znedzJHAhKpRJPVGf7h+PsjmKxyNtUq9W9HmM+2x4KcB57urZ9aecDeU8O1oTmmc98Jp177rl0JDPbNRyM68I+X/ziFx+QZxrbYfLUrs9MK+Pj4zQ4OEj/8z//c7hP5Yhltvu9Ow7WMzCfZ3Rv54CJ/+7GicO50LG3a7Sfz3d8a5ffJfry3fXnT3va0+iRj3wkHcnMdg0H47qwz5e//OUHtT9vh9/8/qJ9v7I3VLwq8wID7de//nU65ZRTKBqNUiwWo2OOOYY+9KEPsWDZVz75yU9SR0cHLViwYJd/w8PDTdumUin64Q9/SE95ylMokUjw92655ZZZ9zufbQ9l+5166qkUDoept7eXnvOc59CGDRt22fauu+6iSy65hLeLRCJ05pln0p///OdDdk/2hyc96Um7HfhxLThPZc/87W9/o9/+9rf0wQ9+cL+f6bvvvpu3u/baa9v2mWkFwvW1r30tve1tb+PFLWVubNmyhd75znfS6tWrKR6P833HosrPfvazXba9+uqr6QUveAEtXryY+xn0t8973vPogQce2K/mTiaT9P3vf5/7AfuM3nHHHbNuO59zWLNmzaxjBPbf3d19SJ+T+Vzjxz72sd2Ob2NjY4fknuwPj3/84+lRj3rUrJ9pfz43/vd//5euvPJK+sAHPrDPz5Hl9ttv5+2uv/76tvnNH0i071f2hopXZV5gEH7FK15Bz3rWs2hiYoIn0h/5yEfowx/+ML30pS/d79bctm3bLivTCxcubNrm5z//OV111VX0H//xH/Tud797j/ubz7aHArTd+9//fm4zWBFGRka4LX/yk580bbd582a68MILeSCCeMcAByH7hCc8ga655ppDek8ONLgn//znPw/3abQ9H//4x+miiy6iE044Yb+faVgve3p66Pzzzz+inplXvepVPKn6xS9+cbhP5YgBixJLly6lP/7xj2wtw8LYGWecwYtkX/nKV5q2RR8zOTlJv/vd79jqgwWTTZs20VlnnUXr16/f53PApBmT9Ve+8pX09re/fY/bzuccZhsfMBkHT3ziEykQCNChYj7XaNm5c+cu5z8wMHBI7snB4le/+lXtHih77s8vvvhiXoDZ3+cI/Xl/fz894hGPaJvf/IFG+35lj3iK0kI2m+V/lnK57OVyOf7/E0880Vu6dOkubfbkJz/Z8/l8vG3j91KplFcsFvfaxh/+8IfhO+VNTU3N6358/OMf5+/deOONB3TbRi677DLv3e9+96yfjY+Pe+edd553880373U/v/jFL/j411577V63ffnLX+5FIhFvcnKy9l61WvVOOOEE75xzzmnadj73ZC73u1Qq7XbbfD7P9xT/MpnMrNvg/Ysuusg7/fTTa9um0+na53iWGo/XevxGcC74fqVS2eUztMdcnq3dsafr3Nv+n/jEJ3qnnnrqXt9rZG/3oZENGzZ4juN43/nOdw7IM/2whz3Me8ELXnDQnpnGPqIRtB/acU/s7Vj4fV144YV73OZoY7b2x29zd+Ae9Pb28nPQyPvf//5dtn3ggQf4mXrta1/b9P58+vPZ+vZbb7111s/ncw6z8epXv5q3/f3vfz+n83nHO97hvfe97531s7GxMe8Rj3iEd9ttt3kH+hrxOdpvb+xvexyM/vz888/3zj777IPen++tT94dc/nunrZ53OMe55155pl7fW9f+/N169bx/fvBD36wX8+R5YwzzvBe8pKX7HGbA/Gb35++R/t+5WCilldlF2Dhw7/77ruPV+ngVvj85z+fP+vr62PXrNY4nUKhQF1dXeTz+WrvweUR7itf+tKX5tXK2Fc74bouW6pgmWpkZmaGHve4x7F7r+M4e93P5z73OXbTPO+88/hvrHruaTUbbrdwhbPgGHAV/de//kXbt2+vvT+fe7Kn+w0LFyx9uN+w+L761a/exQ3vLW95S83dDZY8uB3Bney6666rbQN3JViH4dpkt4VL6u5iQ9/whjew+zTas5XXv/71bJmAZdCCFWN8PxgMssvacccdRz/4wQ/2eI2N34X1MRQK8TVidfqXv/zlLtvs6/5b+fvf/8730bYp9vXZz352r+6NcC/D/dydq958gOX+xhtv5HirA/3MzNZHwO34sssuY0sA2g//YBW7//77a9/HcT/60Y/SihUr+HM857BK/OMf/9jlWGgDuDvP9nwcraBN4Mp5zz331J6vF73oRbvdHu2Nf52dnU3vt7owAtw39DVwRWztk9Cff+1rXzuAVzK/c2gFzxq8VrD9pZdeOuf+HB4Gn/jEJ5ren5qa4mf63nvvnVN/vq/sbXzbn/ZofDZgRbvgggv42cB9e93rXrdLv4O+t7U/f/SjH0033HBDbZuzzz6bPWVuvvnm2raN1sPW2NDXvOY1bBVs7LMtGFPw/cakRb/5zW/o4Q9/OPe3OP7xxx9PP/rRj/Z6nfa7GE/Rn+MaEVrTGiO/P/tv5S9/+Qsfz/bn2NcXvvCFvfbnf/jDH/j1QPTn8D5AmEhjf36wfvPz7Xu071cOFSpelVnBwPPWt76VvvjFL/Kg/v/+3//j9627K0TFgw8+SDt27KC1a9fSX//6V7riiiua9uH3+zmWDoPGXEEcBr6DgQExIIczPtWCOMA3v/nN9N73vrd2jXD3QgeOCTmExumnn77HfWBwQ3wKxAsGd0wUMGlHbAcEYWMyDLiWwZWz1b0I2PcgmC3zuSd7ut+ImcFCQzabpW9/+9s8ScXA3AieB+vuhoFq3bp17NYNcYLjAohWiGC0id0W17Q7kMAC19/qOm0nphC7dgDGeT35yU/mCZZ1wYOrFVxdv/GNb+zxGuFahe9iMoZ2Qpthf//1X/9V22Z/9t8Kvo92Oemkk7htcDwI461btzbdv9mAWIOgX7ZsGe0vmLxhcoeFlgP9zLT2EUgAgmtGO8JdDc8SXNIwacSigX1G8B0ICLzi3mMx5j3veQ9997vf3eU4uF/Yr7qaNwMxj2fzq1/9KrsB/vu//3vT52h7hBtAjL3sZS/jNmyNn56NX//61zzpPfHEE/e7P99XdncOrWDhCc8erg+idC5gIRKi7V3vehd9/vOfrz3L6M/hbgmXfCwyHgwg3NCGEFroZ2699dYD2h4W3HdcH/pwPAfo+9C3t7qQ4tlp7c8xJiE8xfbZiJeHSMHv0G4LAbWn/hx9S2u8Jc4D7z372c/m6wc4r6c+9an02Mc+lkNosG+MtRBD3/nOd/Z4jV/+8pf5u1hoRB+De/jNb36TfvrTn9a22Z/9t4I+CnMSLHhiQRDXiL4Vzwx+Y3vrz9GuixYtov0F4hxzByy0tHKgf/Pz6Xu071cOKWrYVmZz08Ojcfvtt+/W/bWrq4u3cV3X8/v93ic+8Yn9ashvfvOb3re//W1vZGSEXXtuuOEGdncJhULeP//5z8PqNmx55Stfyd9fu3at96hHPYrdev/yl7/M6bvDw8P8XbiCwi0NbjqFQsH72c9+5oXDYe9JT3pSbdu7776bt33Pe96zy35+9atf8Wc//vGPD9g9wf3Gd+6///6m9y+55BJ2L90dOH+4gO3cuZO//+Uvf7n22WMe85jdulzN5l578skns1taIz/84Q/5ev72t7/x33BV6+zs9P7t3/5tl33+53/+pzcwMDCrOxpIJpNeR0dHUzu3Mp/9z8Vt+KqrruLzv/766735gnuyp7afzzP9hCc8gc+tlf19ZmbrI+w9+5//+Z+m9/Gc9PT0eG95y1v47+c85znecccdN6dj/etf/+J9fvWrX53T9kcDCB1AX4K+YnesXr2a+xa0XXd3t/fLX/5yr/uF2+zixYu9RCLhbd++/YCc61xdIfflHNDPwM1969at8zonuFQiNANt+PnPf9575CMf6UWjUe/vf/+7dzCu8etf/7r33e9+1xsdHWV3SvQJZ511Ft8fPN8H8p7g2UCbYIxpBGPWnsIabH+OY+BacM4WuO23hqvsyb32+OOP984999ym93D9jWEz6JNxTc961rN22edLX/pSb2hoaLchB9PT0148Hvee9rSn7fZ65rP/ubgN/+53v+Pzv+mmm7z5grbbU9vP57fy2Mc+1nvqU5962H7zu+t7tO9XDiVqeVVmZcmSJbOuPsP1FZawd7zjHbzSiZW+H//4x2ydRAKZfQWrhC95yUvYRRQr/FjlhdsxLEawCLYDWOl94QtfSG9605vYvRFJZObqBmTdM/EKF1S40cKCgVVoWGJhkbvppptm/c5s7zW6tR2IewL3TWQqbASJgmCVa00kBfdQuJ1ayzGuBan9Z8uYPJ/7D9fWO++8s/bet771LVq1ahW7vgFY3rDiC8ueLcWDa8U/uIWNjo42uaY2gu+ibdDeu2N/9j8bWMVGGyExEu4HVv7nClbP4X2wv8DS8H//939sfWjkQDwzs/URcI/Dbxa/i8Y2xPN62mmn1ZKNITkIXI5hpYFr9Z4yHFsrjboNN7N8+fJdknk1gmcV7Q8LGjwHnv70p+/iSdEI7hNcEWEdh1WqNVHeoWA+5wBrG9w4YTGFx858wPMIqySyrML7AKEYcIu2fc2BBr8pWPvgToukUueccw6PbxjrYCE90PcE/WZjqMbu+nO0IdoAXh62P7fjwP725wglabRIoj+H55ENm4E1Ev3c7vpbWDd3lwEX30Xftqf+fH/2Pxsnn3wy923os+ARhPHgUPfn2A8SLLX254f6Nz9b36N9v3IoUfGqzMpsnRhidTDQIjYNghKdMTpzZCzFBAAuO3tzh5wPELIQsZhYtANwi7FxPI3/PxfgJgy3NriNrVy5sukzGy9kXaQhDAHc4Vqx79ltDtQ9waSlFewLg5utG4cYXbjTIo0/shri2HCdgqhAjOR86su1AkGM84a7KcAkC4M0JkFWqNvJAmK3cP2YCOIZwT+8B3e83Qkc1I0DQ0NDuz2H/dn/bGBCjdJGOCauA/ceghZuuXurr4e40wMh1nCfcN/gomg5UM/MbH0E2hDHwzU3tiGeL/yObbzfG9/4RvrMZz7DrvRwMUfMK2IWZ4t5te2A35Cy5/afDbQ92hrCDPd9tmcP9wWTWCzgQGRg0nuome85YLKNxbz//M//3KfjNfbhWHw71HVi0R8gRtOWOzmQ92R3/TnET+P+sciE2EVku7X9OdxA0efuT3+ORV6IdNufI/4WC1foB1v7W2SVbe1vsUB8oPrzfdn/bCAuFP05vo+FdrQxQkKQw2BvdVkPVH+OECXcF7gvH87fvPb9yuFGxasyK1gRbgWrc1jVw+ppK/a9A10rDB31XGOZDiYYnFAbDTEuWHXFyicEF/6eCxAHSO4w2yBiJwm2zTE4YmIzWxwNJhqYWGAV+EDek7kkKEESj40bN9L73vc+nnTZ84U1dn+LnWPlHwMp6pdC/GDSg/vemITGlpRAXGRruQn7Dyvqs4H2BIg33R37s//dASsDJhyYuECYobQBYpwvv/zyva5st9Y33tf4KFh57PUfyGdmtj4CbYhJISbJs7XfbbfdxtthsQPtAJGMOpeoc4jrhaDG89SIjZNFmyh7bv89gf4H4sRO/Bvj8WGFh4BBXPeLX/ziQ97M8z0H9Mf4nWKBCPGZ8wX9FWK0YS1CHCb2gbIiv//97+lQgr5/tuRo+3tP5tKfwzIKyysS+CA/gX2e8N5sXj/zAUIRyQXxu8a1oD/H/jGGtva36PN319/CQ2N/+/N92f/uwEIzFgTRv8Gyi74VQhgC9lD15xhD0L6H8zevfb9yuDn8qkA5YsAqJ1yL7AS0EWs1bLQqYoKAAWJfC8cj8x1caRszGR4OMJBjxRiTHKz2Y5IDAYuECXBbwmA2F5773OfyRB0JMBqB6xsmG7ZmG4AVDGKnMdERJjpwbUN2V7uyPt97sj/YAat1McGurreu8s83azTaGIMsrvF73/seTygbV9YhBLGCDvfW+YK2hUDGfnfH/ux/b8BFHOeAiQImHruztljwzEPw7k/dPfz+MBlvdTE7mM8MFiDwm5/rog5Am+N5Rx1EuPch4VcjsNjCitOYoVqZ/7OAZw79RuPEF32KFW1IbtNoGZttH/vTn++O+ZyDBZNujA9wjdxbZuzZhC8sZwj7gLhCH46kbfAqecYznsH7PhRAJOL31jq+7Ut7tGt/DusnBBf6XXh/NFqEYRWEN8W+9LdI/gZvjT315/uz/7n05xgvYLHEecylP0cSxla37fmA3x0WQnfnMnwwfvPzQft+5ZBySCNslSMCJGPBv9lAEiE8Nm9+85s5IQQSZSDhRSAQ2CV5gk0uhARHewOJEX70ox959913Hyc3QnIEJH1AEoHWpDBImmPrzX3wgx/kY1x99dW71J+b77Z7qyP4ta99rel91Ld79KMfzYmb5pLoA8dDndZTTjmFk1AhOcIXvvAFbjscoxG0wcKFCzlRxr333svtjCQTOFZrwoj53JP53G/Ut8V+bW08XO/KlSv5/FHXdsuWLd7ll1/uPfe5z+XEWm94wxtq333f+97H7yExCRJnNLb17uqhInnG8uXLvQULFvBxf/3rX++yDZ4pXNcLX/hCbgckQEFNxi9+8YuckGRP/Nd//RcnMsH54vzRxkiqhJq0893/XBI2fe973/P+3//7f96f/vQnb9u2bXy/cV9me5ZawfY416985Su7fDbXZ/qvf/0rf4bnp5WD9czgHj772c/mZCFf+tKXvPXr13s7duzg38drXvMa72Mf+xhvh23w/2hj1Eq+6667uP2QQApJ21r7hksvvXSv53Q0gaQps9W+Rb1FfIZEcEjAhucXfQ3uKZJy/eQnP2m6V3g+8RxcccUVtWfK/mut1fnzn/+ct0WftTcan1HUVMX3cB6tz+h8z8GC5wfXs3nz5nm2nCRfQ8KZb33rW03v41hoUyRumkst7rleI+pgIhkdkuzZ8e03v/mNt2bNGn7e77zzzv1uj7k8G6hv2zjlw76WLVvmnXbaaZwgCG356U9/2nv+85/PfY9NrgZQ5xxjDxIptvbnu6uHivZZsmRJrT/HmN4KnikkikPNUvTJeF5xLuiLkIxrT+BZxnmivW655RZu1yuvvLLpe3Pd/1wSNiGhJGpl//nPf67155/97Gf52lqfpVbQtnhev/GNb+zzc4Tj4jP0qYfqNz+f50v7fuVQouJV2QVkmcW/3YEspej4ly5dyhn7kD0XE9XW4vW//e1vvVgsxp/tDQjUl73sZSxYMfHFwP6KV7zC27hx4y7bYqDCfmf7t2jRon3ednd87nOf40FqNjC4PP3pT99lQNkdmKijEPiKFSv4OlFsHO0zW1bFTZs28UADEYtMt49//ON3m1V2rvdkPvf7Qx/6ELdTYzF2DI7IdIhjQGhC/EDUohj629/+9tp2MzMzLBJx7sgKOTg4WPvsmc985i6ZKC0QNDgm9r27gvK4p8973vN4Gxz39NNPZ+Hcml1zNuygjvPHuSET7z/+8Y9573+2a2h9D+ePCSsmQXjWkNERix0//elPvbmArMeztdNcn+k3vvGNnH1ydxyMZwbgWUb28AsuuICfW5wTFgggxO3kCBNNTNSQcbWvr4/PExPMVqGNv2fLXny0g4WU3Ql6TM6x0IWFMogjLDjht9ia9Rp90e6eI/xrXQzCwg7e39vCC4DI2d1+IZj29Rxspln8LueyyDIbmLRjMWo2MIFHf75hw4YDdo0AC2C4J43j26te9Sru4xvZl/aY67OBBUXso/X39eQnP5kFJsakt73tbSyGkHUdgtUyNTXFGcJtf97Yz+A+IFvzbNgx5JhjjmkaRxrBAhaeT7QZ7ivGRPRds439rWCR4SlPeUqtP8cC2HXXXTfv/c92Da3voV/EAjuy/dr+HP0nBPJcQDvP1k5zfY4wb8Bv+lD+5ufb92jfrxwqHPzn0Np6FUVRlL1x880308Me9jB2/ULisvmCbKNwg/zUpz51xDY2MnHDfR7ule0Q+64oirIvIPwBoSMIhdpbXfjdxc0iMzTqFB8NaN+v7AkVr4qiKG0K4pEQ+/rf//3f8/oeytAgGcmf/vSnpljqIwkkakJiMlz7XEtSKYqitCtIQIjY4Z/+9Kfz+h4S2yFZIPJjYEHzoY72/creUPGqKIqiKIqiKIqitD3qh6UoiqIoiqIoiqK0PSpeFUVRFEVRFEVRlLZHxauiKIqiKIqiKIrS9qh4VRRFURRFURRFUdoe/+E+AeXQU61WOZtbR0cHOY6jt0BRlCMeVH1LpVK0cOHCo6asjvbliqI8VPtyzFETiYTOU5VdUPF6FALhumTJksN9GoqiKAecrVu30uLFi4+KltW+XFGUhzIoFQcBqyiNqHg9CsFqlp3kaaegKMpDgWQyyYtytn87GtC+XFGUh2pfjjnq0dSfK3NHxetRiHUVhnBV8aooykOJoykUQvtyRVEeqqjLsLI7jo7AIEVRFEVRFEVRFOWIRsWroiiKoiiKoiiK0vaoeFUURVEURVEURVHaHhWviqIoiqIoiqIoStuj4lVRFEVRFEVRFEVpe1S8KoqiKIqiKIqiKG2PildFURRFURRFURSl7VHxqiiKoiiKoiiKorQ9/sN9AooyGw978RV0w3ffrI2jKIpyBHPmf67l13y3ecORl9A0kVOtb3fz1990GM5OURRFOdJQ8aq0JeHJCp33rMvJV6hSeqGfnApRMFOlQLpK5YhLkZECZYdCVA04VA47VA0QBZMe+fMelaIO3fA9Fb6KoiiHm0qQyPMR+fN14dpKOUx06uvXUrFL/g6k6+8DX968n5VXjAcgNCPq95//9ZaDeQmKoihKG6HitY14xzveQf/4xz+a3nv4wx9On/nMZ2p/Dw8P09e+9jW66aabKBaL0SWXXEIvfvGLye9/aN1Kt+SRW6pQdtDPgtQt4z2iYsJHTsWjQk+Q33eyVQomiXK9Pgqmq1SMu1TscOiMV66l6JjMcAIpM9NxiNxilaoBl8oxH1UCDrkVj3xFj9xCldxSlf7vr+86vBeuKIryEOGcF15BIba6NqtWzyEqR+qWV39OXn1j8lrskFf0+/I/8lKKy2twpvk4Z7xiLffj/FlaXksxOWYgI3/nu2UnxYR8587PqKVXURTlSOShpXiOcO6++25auHAhvf71r6+9193d3SRczz//fHrRi15Er3rVq2h0dJTe97730Z///Gf62c9+Rg8lghN5yi2MUDnisJBlPKJSxOEVfM8l8hU8CuSqVA265C/I5ASTncTWMpWiLgtaWHBnVgRZyFb9Mpnx56ssYp2qQ1WfwxMpf7ZM5ZifHvW4T1Kxw0exLVkqdwapHPFRKeZSJeTwMSGYg6kqlSIyEdIVf0VRlD1Tipku3Mw4/MaCir638RV9Ov/d6TSL1wZglYUlF8K30OWSU/V4EdIK4XxXcyoPzwjeVk5+i7gzO3Z4cYkqLZZeMvu88woVuoqiKO2Citc2A+IVAnU2ent76Z577qFQCGvZQn9/Pz35yU9m6+ySJUvoocDZL7mC6MQ4W0rhHgY3YAhWf86ruZ1hwgH3YR+ErUdUNZMZAOsrxCZbYhMuBXIeT0wCmQpVQi67GmN6A+Hqz1WJPI+yC6RNsT+3QlToC1M56hI5Rjw7MsGCtTbf7eP9YWKFc4UoxqTMn5Xt8Irji7uciF78u/XLOgFSFOXoIbVEOmyITX5tSREZMBbXWr9eFSutr2C29xFV/c2uxFg8BFjY5O8Yx5pKUP6umOHR7sOC0JJGQcxi1bxXDTZ/1soJ7xGha8/Fvlox7vlEATtlOYf179K+XlEU5WCh4rXN+OMf/0gXX3wxDQwM1FyCHUcGxGDQjLANdHZ28ms+b5eKj3zg7oVJC9yEMZkJZOHai8mHQ6HpKoVmyjURCuHqlD0WqrC2umWPY2CxD8RDBWcqFBrLkxdwqdAbIn+2woIykC5Tvi/IVlUWvY6ITJ4HOQ5V/Wa2hUlS1K1bBooeT5KwLUQ1Vv1xroG0x5MpWA4qYYcnRbDSQsBiYgahfMar1rLIxvZiOTaTIOwb1+GJQMf+VegqinKkY4Wlxfaj1sKJfq9RMHJcrP3I1/xqxSj3+ywgzc4CzVbbilHCVlgWo1gFlf8vG2Frra2WVtFaE7ols297XvV1Y7ND8xJr3teaD6+tWZdtG1jxzYuwRHTjdzQvg6Ioyr6g4rWN6Orqouc85zl0zjnn0Lp16+id73wnXXXVVbt1CfY8jz7xiU/QCSecQKtWrdrtfguFAv+zJJNJamdCSY86NuUotTzCbsKY4ECQAp8PK/NBCmH1nS2uDltLfXm4AYughOUUkw1YYAOuQ/k1cRa3flheIy4VOn2U7/FTIFslz3Wo4/5JKndHqRL2U77PT27Ro1JcXJAx2WJrgRGXEL6MJ0IWYhQiGZZWCFkIT1h6EXclVgN5H5MhTGJcCGUzmfHl8b4IdezHxmaFp6t07nMvp2KHy2I9kK5QlQWzY84LlmSxGl/7i7cetvukKMqh5Ujry4MpeS2Y6BcrKCvm1Wctr0acop+viVR/s8txdkheI6NOs1g1Y4Ol/9YMTR0f5f/HgiLGBbsvi2Otr0akWqxYLUeb/8ZYYGN0MSa4WEw1a8m8EJlzeIGVz8cK3GrzPlrP4bTXiTXXgu9Zcd+xTb6c6xNT9W1fUEuuoiiKRcVrG/HNb36TwmFZkr700kvp1FNPpYsuuohjYM8777xdtr/sssvo6quvpmuuuaZmnZ2Nj3/84/TBD36QjhSQkGlqjcweeLLggyXUrMB7DvkLHk8+IFrZcspzGJddetnyGRJ3tGLcoUKXQ9ExcQ1mN2ROBOVRIFPl/XbevpO8aIj8M3kqxzpYULLrcLlClaDLEyMWsJwtU0QjjocJCVbxEWvL7mtmJR8ZkSFYITArRljj+3aixWIWotgVCwJEdaHDJce4FuOcfDNVjuXCPnH88FSVHM8lpwJLcpmKXX5uD4jxc15whbgq5zzquH+KCgs6qNjpr8Xo4rgQ9LrKryhHPkdaX55c4ZE/N/vYBOFaE3omK3Fj8iabpClkkjPl+mc/BsI0QkkRe1jELCWClNgsSrLQJeo02+82WXEtWOgEtmKP9ZTBQiP6afaU8ct5Npb1Afbv2vveroKXz89Yba2LMi+K+iDsvZqgFa+dekKqVk577domUW0pmcRW979Xxa2iKEcPjgfzndKW4NZEo1GOZ33Na17T9NmHP/xh+uQnP0l/+MMf6IILLpj3aj3iY2dmZiiRMKkX24gT37GWJy6hKVmt5kzDZYlthSiDG3E5JK5geB8lcmCdzPf6xcqJGFQzORg9w6XoThGG4SlJthTblKLCQIzC25NU6o0ZYetQYDJLnt+lYl+URSqsnXBFZssrFgc8r+ZuhmOwoOYkTnKePBHBrqpynhDJ2B4CEhYFFr5VeY+tsGWPrcMAgpwTR0GYw3JcqEq8bQEJqRx2k7aTIyScgnAtx31sRbYuyhDkOBZEMVypcZxKGImrXD4+/u65N0/jJ4dlglauZ+aE+P3nz7TchHLkgn4NYRTt2q8dCI60vvyYz1xRE6823jVgrLFWqNXiW83nkXH7vvRNyB4P8n3m+0mi6Kjpt8w2/qwoSOsZE0yKcqwEZKfJ5YFm8Wf6Uu6rgy1xt5XZ3ZZbReou27vNArfmLmzch/l8Qs1CNjwpOyvDtbmhTaIj5n1jVcY52CzJqI9ryS6oW5Fb27FqY3+NeL774ypwlSODo6EvV/YPtby2MfjhIpYVAraRj370o+wuPBfhCpDgqTHJU7sDd6zYMCykGMwdnnAE0g4Lz0KnQ/k+hwUpLLQcf+r3WLjCimmtpIWEw/+67/covcihrvUSK5tZEKDK6gQFkxWqhoNU7ApQZGeOV+uLAzEK3bOd3ERYhGpVMg1jAsFleWDAhTUTLmMmJtcm/fCVRABCOLIrcbIq9WfZCiuTGgjXWtwsxHeZ2P3ZxtBiUlRAgqksXI5dWfn3+1gUYxu4HnOm5ZKIWSugcWxcO4Qui+6AQ6VOH28fmaiw5RUiFedXTPh5wgQhC8s0rBZoL8QIo84iu+7FiBKbJTtzoVPclHH8W76qkx9FOZwcSX35qk+uJYccdrFtEm6RZhHWaH0FBVPrNTpSfw/1X9li6RKV40SVGacpSVPd6mnFoChOeNqAyISoyjQWAVvEZS3b8N7idmeJk2XLrGP6d2znNMTMBkx5t45ZrLZmn7acjz0Ht+YyjT7evFesW4IbgedPcIqoaF2y7efO7Mmx1nxIrLc4J4yvjQsDljvWah+vKEr7o+K1TdixYwfHt77kJS9hF2Csrr/hDW+geDxOT3jCE2rbQbTCdQzC9cILL6SHGqe/Zi11j1W57A1nEK40Fqx3KDLhUXXGWD5DSMrkUWaBK4IMJRPK4hbsVER4Jlc4FBnByrtLvXeLSIyMlrjOK6y70U0pKvXIbArlcyqL+rkOrFuuUmhnmpxyjLwFARaF2DfOR6yo9RV5FqcVjycC2E6SRzliXS1JXKy4HIurMFtGK5hcOPXYLzPBg/UUrsKI9W2a8LCVGQK5yu7RTgX/YHEW8Yn3SjF/zUU5PFGm3ICfsn0+ikzKOcS35Gjs9BgfixNDhYjyPS67JWMSyDHDWPn3iJJLffx3aFr2n9hUpMc86uOUGwiyC158R0Xam+ODfWwdvv6HmoBEURRqEmTWtdVaXG0yJCvOavGnDfkIreURQgt9OxYsbT8o/aWp6Zqy21Wbkzg19ZsehabLNL0qKAuPrfGv1nLaOhtqEKs166vNbByW1AW1RE52O3N4K9htXKwFNcn5+62xtjam1uwDgtd+1yZ+sqAv59fW9nPr++djmM/Rp8OLKViqv4dxEYSNldty4jtNVmVzftYSjAVisOEt2scrinL4UfHaJqCe60033URvf/vbaenSpbRp0yZatGgRC9rBwUHe5t5776V3vetdtGDBAo53beTyyy/nRE9HOhhcU0sR30kU31FlQWizS5ZCEheEmq3Zfh9bLiEOE5ukJA5caDGAx7cXWQCGkhUKpP2UGyDquxNWVz/13pGisTMT1H2fBFZlVnZQcLpMwfGsuOlmCuSbzlB5IEHlzjDlBmQU5+RMLBqR+bi+ao0kSzZWFRMplEyAkGTXZuPyxavvcA/GRIrjaWUCxYmmiiKGMZnBBKnc5UosFBI/ZcTNmdvFZtj0OXxtsCxAgCJWit3VgiKueV+Id0XsbMGj/AKXIpsqlOtxafzUGItoJIHKDPnk3B0kGvEoMl7h88kMSCIrJIvCtjhGaolLxXiQ48Nw3rg3qSU+vi58jvfzXQ6d8Yq1PAG0ZYtqEzczCdRVfUU5eqjFhFaahVA1aDxQCg1Ck/vGepwochUAjAEgMiJ/oy/n116nSbxa0Edj4Q6EdoparsQlj4QvL315Nd5s7bTAg4U/RziItV7aGVJLPdpW7HnXSulYYVnZ9TucSZ+TC4oA5rJvs1igW6211v3YJrBCbDBciTlLfbrluxW02a6uz63kBlsEMBZCI15T+R++vqIsbq769BVUCZuyQNb12pQH2vBmFbaKohwaNOa1zchkMpxpGIJ1aGioKRETPrv11ltn/d5JJ53E2YqP9HiC01+9lhNz9N5TpeRSl1eSIYLgIsU1AU28qC03A6thdLhAhd4gWw8hxMLjRRZvcJGdXumn8LQnbr9wvap4FN+QIncqSYVjBinfG6COjSkqdYbJnymSL5knqkB5VanSG6dCT5iKnVBjclzsH4IRIpKz/iLGyhPRiORNYnEVQceilrMVG+EZMNbTvMTv2vhXtiJjcmEyG4sl1wjFqmyP/drkURDGoGYFNoIRQpgnSthH0ePzwT7YfTlA1LG1zEmoYNV2WYRLzUS0G0Q1LNUszLl8hYjy7KCPImNVyiHhCc4VLtKFuuszW5Mb4n35Gjixlpw72gHnaROhcKbOcoNVxkzEsK3GZCn7Qzv3a0fjNZ/09mYrno3ZhHgNJpvjYK3Ai2+V18xieYXFEPgzzSLM9huxnR5FR0V1ou63bCM7C02I+TMwIV+eOq2XX/M9TpM4tH0Yn5u/OZGT3ab2eUtdWF+2OUmT02gZbVm8swK3VaTa92F5nc2dmf+/3JK5uCHTcWP7oM9vPE9rGbZjRmvd3VoiRLRpZ3XWmrVO1SzCmsUGzzXiNtBijQ7VRW2tbRuE+4Ov05wKypHfryntgVpe24xYLEann376bj87//zz6aEMys5AfcFSiDgnlFrA6nogIwMhJ7YwIgivcGGt+sMU21mk0dNCFB3zKN8V5nIzEJj9txdoak2IUksdCs6IG2x2WZz8A1EKTBUo5HOo3BHCKg5VQ36iRJh8OyaJggFyClJaB1ZTjqc17rkQoxBvGKDLPPhLeR6cE8SgjYuFuGP3X46fxdWJ4OX/Y6EnwpddncumzA+yGDe6DCPpEsf1Gmtt3ohWWFyNUOWyPUZQykRMrNVlR7Ijw8IKAZvrg+LHxAwWXTkuQPxvdtBfSzgCayoSYAVSRQqmgqbdA2JNNfGxHJMVNJMoK1qhb3GOuboA50swMWG8f2uNsO7ShfrnJ791be2+Yp+wLNg4Yo23VZQjHCN6WKzZOFNfs8hJL2sWY8XO5r9BXjQoxbdJtl7rKlwTrzZh0aCoRF+2OVgU/VZjPdlGC2dNhLYkZdoFK2qDpg9Dv2dchanVymnjYP0tFmkrZo1onVXQmnQXXrQ5KZN1S65tX22uYwvxat21Qfc6aZf4dq9mtbYJsGrhL3kTRxxrtrz6zPtoGytQd2mOgIxxVuhagWsJpFxa/bG1VDZWXdsmAbOIcf/7NNZWUZS5o+JVaStmVrq0+C8ZFoTh6TALsqljfSxkExtNuRkYQhvGRiRxCmT81LWxQsllPoqMi1iD4MwuCHDdWAig2E6pDYvMlOWoS24pILGqnX5+rxpzyS34yE3FyMlCOYm1EXVbMUFCvKmIQSmHYzP4wsoJbEwrJkdl5HxC/GtG4l9Z9BqhS9a6yTGx8h0g/48YL8kwLNZUY+EsE0XSYoFFEiu4BNsJDsAx2e3YiFp7LtalGZMtCF+21EKARnF8U0O3z8eCll2SUV6oE+3ro9CMnydYsPjiWGhna2XFPywo8HWbrMsQpRCcfG/Yeiv/D5doay1n6y3OtcHKzJZiuFJjO67dK20Bi3MxAQs60clvXkuVKFF4QiZ9WJzANYemKvT3P7z9UD6iiqLMgfTyCvXe5qtnDt5GNH2sEUjhlrIyldljRC3onzhbe7m+jbWg+gtyDPQFsg8jZsP1jEXTx4vPcq6vOZeA7UOt4G21tForac2CaKyKPtufNVo5jaC0i3a25I+9RvS/9juNJW8gXq0orYl6t8UdudX12HzOZeFSIlrtgqC1cNvjIjFWdkC8bxqPbeNYrTitWX6txbUs/X6TO7G1qBrX71oddHte1tW4RePW4ozZM6fxQznWKW9aWztfW++80C2f3XGFCltFUZpR8aq0FZExoh3nx6jn/jIl7pumcleEImNhCs5AFEJASkxpo3jFoAyBh8y40ZEqCzi4yCKO1dcXZaFZigQ4sRMmFKV4gDq2Fim4bZqqnVEKzHhU6IsQsRuvR6WBOAU3Fyi3ECVzZICGkMKkCBMof0FcbaWmrMOr3mzpDMkkDCKQSzggGzKEqbF2cl3DYN1SYGNURcQi+RGRiwRMDlFossLHg2CGRQGfF7r9vC3awFpB5folMyWsyj6nXiqoFl9VbCjxEzAZkrFvUxuRMw8nzEQwK9dbCiMjZZXSC41FlssUyT6QJIv3heuALsaf1ppiSvDgOJhwsXCFVsf7dl5js3NaayyXFjITu2pdxCPuDZMnnhQ6RNGdSA7lkOPDZMyl6GiVs0yf96zLyZ9Fe7lS97cK1/Eyi/a/XanCVlEOR7mzGPk48RBjstra5Hv5/mbh1Agy6PJnRtChz0Zsvs0kHEg1u76iFFijeG0UTJGxMpW64FnTHDdqEybVMvi2iGaIaytYua/iRUrzd8P+m5IbGVdmePjweaNmeKGlhq3525bG8UzpHys8axmGSy1uwuYYnJDPWI2RdZm/E5k9Rta2T6FHXovdpn2iFaJc3Tzsy0tmereMxUmP3YOrIY/FrR1jrKDF+42NUBP1poGt5dV6z/D+c3J/yrFq03mGJt1ahmVOVmUWNGxyLpt86sz/FPdzLDTbWGg7BoGbvqmxtopytKHiVWkbzn7pFVTsc2jwlgLl+gI0dUo3C9HYThEik8dhMiSCBlmHMQgWA1KKgUvMZKRuKpepifoodXonv9exKSv1TslH8R0lSi8KUCnmo8qaPgpOFMg/niLqj1JwukjVIDLnuuTFQlxmIZSu8Mp+rsfHcUO+YoXFqXUPxva8Kh00ExzUTkVpGSPaMIjbMjv4fxtfykk6OKlU1WQxNm5XHIsKZYpR38eZfAOpCmdH9uWrtZI7ELQcS2tiZ91SXUzDWot24uMjY3BS/ubyPJyNuCF2l12M5T1MIDB54nN1iYYf4RfrKVyau6oUGkMbi9DFpIVL92RNySCOrTVWB47jNdZW49bMK/QNE5rGTM129d5uz5aNYr38BIt6kxyKXaSLpu6hSbySXuSSW3SNq7h4J0LoB2fK9JhHf5xKcb+UVQojEZhH2X4/J6e64bs66VGUg4EViwjjALD88e/ezDiwGMl/G6sdFvZsyRdrGUTJLlAyAs4qpZogtO62xsJZ7PDx7xpwhmEszhktFR2RnWSGAk2iEKKY95mvWy1r+7U6rSVmdXdZia0wxufiYlu3dlrvHAtqkwOMJfxqtkP/auvbcrstEA8cCLyay7C1xhabxbJ1E65lHG6MmYUHUcpnBLiPUsfawFqiwkCFXCMwa1bRHrPziWDNLViuDWOVuXetiZ2NcK25RZeaFyzs/bSi1SaZ4vAblFun2UGiLzlWfVHWku926KS3rd1FwN/zEbXWKspDGRWvStvQtS5H5UiUhSdccwtdIgwh1PJdLnU9UOXarXnE7Bjxh5ItU6t81LG9SoUOWN2QlMKl8ASSNIkbbWZxVOrZOYiX8tcmB6nFfkrA+tkhS9Oe3yV/ukhuMkflvjiFR7P8Xm4gxsIJohKC1s/CT6x8kjhKEjhh0mUzZrJbLxI8FWwcaj2etASX5bLJWmyuAyeHz7wgEjOJMOW6sBCCIbgzVwnzCraahiQGt5pHLVuXMwXX8KTEDcrjQKjh+mGVrECU+xy2znJ2yixq5rq8MABRjEkd2gzW3tAMshP7OD4K1wKR2LmxQMXOAKWWiCXWWnBRP5Zd0oL1SYiNy7Ui0wrTRgssT9aMuMZUxmnI9Il4XEz8UIMWFmxYzPk9lPPxYE0pUb5PXL5R6gf7hnDlckYQuyabc2pJkCKTqHOL9rTJqeT/0S5nvewK3h7/j8UGrObDInLLV3Tioyj7g3XtRa6BplqpLRT6qhTdjrgBouD0ri61jftqjfMka7WEp0pSfrv+qWbzY3iL7LQ4aE3AzTVqkFk9OyhiylqJa/H4RhTXXHottSy75rzsIpxZeONNmiv71Lxtau7AFWNFLkgoCMYNm8W+ZjHtdPgcAi1xuPYYNTFtBfpOkwwQore/JSFWy0wvsU4OUjALBuizxZLsNFlrq4kyuTOB+rGLdcVq3Y4lTATnau+10xynbJNxbZbx0h6vsW2tsEWbOtbFujHJVbT52q2nEPpvLBzzs9Egpo9/39rac2TPAzHS4Mbv6KKlohzpqHhV2oaRs6OcoANuTHawjO2UMi+wCEJEYSW6VnOvKi6y0VGPUotQr1RiJNk6x8XhHfKZTL3siuqTfxBE0e1Zim7zOMtwcGeKigs6RPxkCkTFolgzs0XKHtPNEwC470IEOmWPa52ytTVkVthNPCvEGo6HQRRWWs4mzALSBlTJJEbcyUSgQTixkIXINRmMYT3GRAYC07oFszsy3KXLSF5VYQGL40ZHMWtCsinUxZXtMMBHR2Smlx3EucIai4lAVeJ0MeCHHIqOlMlD3dmQHA9th88giPm8UAKnw+GMzqll4ZqrHSYUEMHsIgyhPAarpsSSYfKRXmKSLWUbkoiYUhhsoa6IdaAmZE1pHd5v3qOyqd8LSy4WJIIzpk3hUu2XBQgriGFZF/djxCAb4Wti3rBNekjKJ2GS5FbE8hqZlHbNDLp8/K4HijSzIshWGy8v5SCC02gfKSEU2ZkjN1UgCvjoqts+dCh/EopyRGKtgTbhkkWSzdVFRXQrFvJaaoq2xJ82wmIHHizoU1jdyPuBdLUpzhXeKrzPfrNTA8aQ6JgpP2bCQOoxoM3HbS2l0ySyjBi3nik1UWqtxIZSpNkqy142NoTDeOy0wh4yDd+J75AGynf5asmWeF9VCe3g48SaxSpyRPA+ki0Zgc354Li2JI4/K4uPtXhWLCBuDO8iMDOLm12G8b1G12/uwwvN8b+1WNdG75tZ7q1duLBiGlbkxvq2tl3R/jx+NdQNDk82J/LC/fA15INYcIOcTHqhDGCoV85/L0GsSn27f/1ARa2iHCmoeFXahq4NZXKLVZpZGZTB1iERrmGHElslGdPS305QflGCXcRyMVhkJSkR3K0wgNukTBBgSHxkkyqx2AwThUYly+7M6jhFxssUGk5RaTDOZXLcPMScj5xygHzbJ/icPLebxSZcUP3TeSp3hSW+NVyPNWUrY6HuGswWVJMwCZMpuyLP5W/gaotqPCFJ7MR1Co0I5DhRv1hc+bsRV9zgHBHHHPPlwQXYV98+6FApKn9DmMG6iBIRXB6C3Y79Jg5UVvaRRTiyNUnZFZ0UmsxTbihKnoNYIpcHf0wI0JYQ37b8DSZ8YvHFOclkBgsCgK0FRpiypRgeZ/fKe5xcCpMqtvRi3x4FTZwrzpuTtOAzTOhYvIolFYsQFdNOiMFCe6YXutzG+IfrsYIfxyjDfdi4JLObcVmsqcGMyUbqq2d+ZtfvQpXbqmO7WKYzCwLiym2euWV/KJA/madib5T82TIvYiAOOrMwSOc+73JeNIBLYvz2nUThIFG+SFdu/Mxh/e0oSlvi1QVsbNuuNUUbBWFrfKfFhg3sKbGSTdKE8QJ0GvEKAmPinzp2Xn+tLwcILeDjm77M7ssmWrLHhuCqlbexmYxt8iObNbchGzJvBoFlSqNZsW37eluzG32Q/A81CdDGZFYQ1oWu+jTNikObXdiGTiCpIF9ToiF7UkO9WQjTxtI9Ujau2e/XHtfW4bVuwHYhotaeSacWl2y/Y9usJsztQkCluYZu7R6bz1EWjz9HWTcTemMXMSw2nMQeq3bWLW7LVmTbMcCKf75kB0K/xB5GyeWhWoKwrrvk4pxqlS499b1U6ZCDOGXZgBezieiqOz/afDBFUQ4rKl6VtiG5VGqyohA9xE540qPYaIWy/VhxFgvcxJk9nIUQgyVcRSFeWPBxXCZR2i9xmYUuiJ+6ZRODJpI5ccxsRbL/wlsXBexTS0IU3+aQE0E5GI98rkvujCxZw1236kesUIXcbIHcSIAnJRDFmJBAYGES5mBx18S8cvbghgRH1gWYV/oRq9khFlok74Awj+4ssUhCrVobx2onVDi+uBGbiZtrBK2ZMOA6amV2KnKcmWPCVD0uwtcNayxbFLl8DwQzrKwm8+ZQlEITBcosDkuGx6rDK/M4h0pQXIbxXT6GmWiFjHUbq/K4Ppw/W5QRl2WTevgc6r4/x/HAsRHUlfVReKpCpYgrWZThQo3rNy5ujZNRJGHCJC48WeEJRqFThLktIcRZnuEemDUZj7Pino36hfmBKoXG4WJM1H1/id3Ocb2cjMS63hnxDMGK40vdWXExx/5iw1hAqbDreCDgIzdXouRxYg4IT8DM4lBk/Rh50zNUWbWYnFKFKBaix531AXJHpqgy1Eu+zcPk9fVw8q8r7/nYofnxKEobgUUuG4MZHTZvGl1lLZ01y16+xUpn4Gzkpeb3rYCx9V+tFbdRtMFrA94Z8a156U+NEIlvF9EaSEpnEBoTdTO9SsyUVe6XjUeIcUetud22ut+2WoXN38jibi2BtaS6NUHXrLZsnwfPFnv9xYRLLhZikT+wteROg16rWXjNG0hg19iWGA/RzuxSW9mzRduOU1ZoQpwicaLFfi/xgLHQNryHvpavwXizcD3whjhXGxrDx7FZoK2lG4vO6bprsGv2ZcWrPZa1sHqlhnhes/iBNkJ2/MZ431oWe15IlQYpR5obE4m8GkkfIysspbhLEa4bLDc6nClQuSdGF1/4sdo+UJ0A/PNnWrdWUQ4XKl6VtiE2IsKla71k88WgC8HDq8RwTx0tU3YBEvGI6yfHnMLVFwmDjPUViTDY0poSKxviNxHb6rJbrwgdazlDbG2hxy+Jn7okqU9wusTWV+qIE5XLFFk3RqnTF5B/GPUGsuQvFMhdFZWkR4UGNyYk50DJGBZDJnmTteaRZBW279lJDGJNcQ2TJwQpNuyn0HSZEzRB/OK8WXgF4TLtmvbwOKNmGJMuuAqHAywQ831BtiIXE/JddhGG2GQxLdZYHItch3K9PqqaEkAQvLmeCMetuqhFi8zJnGhEVt0xEcMEASK5gCy/sBwHUSqoYRW8Ui8dERuRc5BSRH6uHQvBCQspYmir1rWaLcBVtrJzmaJclc+bXf0covA4Ym9F6CL2GW2X2CKxudjeru6jzdFO5LgU3wYLAYS5xOGmFgfYBS2xpcqWWyyAYN/BmQqXScI5wBLLLnIp1IKUe+HLVyjfH6L4uEvljiBRR5DdtENjeV6dRwZp1AAunbKC0otDXCMXz4x/pkCF44YodP9OOTm0cb5El558GVvAcwvjbPENTOaokgjR//793YfpV6YoBxck0GmMNbQCs7G286w4dSusFW62HitKZIHsoLzO5m5rRU/JWBRLCTGPBsbkNbJBdlLpiu363YTX5FaLBHj8fqdZKMzMLjy57zN1Xq2gyw7Ja2Rk9su054k+tvPBcj2LMCfNM8cxr1ZQ1tyUERtr2gR9cG17I5zxD59D8LXGuTZ+j/dp9Zut0W1EX9P3TGhHvqf5PBKbq/W6tg33IzJW5XwMcjzj0hyXm5lFnXEu3eM1iVl7PhabNMq6T2M8SmxoPnebCLCVRldj2ZexyPf7OV+GJbZTEnwVOxKc8A/03Fvk0CBLcLJA1UioZiHHInIjFz7hU7Xrs1ZzoDG1inLwUfGqtAVInlNaaBLzwD0V9UjhXtrrcGZhrGxjAAomkVzIR+mQT9xzjUsW/tXchoylzp+psNjliYZJdsTutnDXTcIXCe65fnJJLJRwX61E/CxEuP5LCcvXeeq40yxDex5RLs+Cqhj38aQMgsy6v3Id1Wi9cL3EVNmSCR6LKgyUnGkSyaN6fLUJAQa/fE+Quh4oUL4nwIJISr/4WPTgFVY/tEF4e5ktxgDCFgMuRKN1P4ZlGG5aHF/E7YP2hHh0eAEAohBijuvAouyscbmNjpUpM+RnqzC2QSLOyASs2ziGuKbheqwrMK+Mw+03bz+TpFP4IgZ6WGhh0cW5xIaLLJprrnKYHExkyZ8VazNbx/MlcspVqsK67SGu1QddyvvHvUSSJj7PkRKL0671OcoOhWnqWJQSku2cPFFyudS17V5XofBEiRcpYiOIpXWpEkE8r1vLWh0dEQsvJ7bK49lzKX7jFsqesZQXOWBZZgHdGaSpY0PyzEHQ55EApCDxxAWZ8CB2utrfSU6xTNVQgBy/S6WuCBV6AhTdnqNyPEAentvpHD36kk9IBuSgywsN+K66pikPBWyyn1qSJmd20cp9lI3RNK7F1sraWmKmNYlTo8UwNtz8nXr5lpYv5O0JxMi3U8yjO5+0jIVxyZTyaa23akvENGItgbD2eY3lbVosnBbrHl1BCEOgwQPEEW+jJospxpgG0Q4PIn7fjF0Yc2xiKWv1tGK45vZry+ogWV7D6fMiLxZXOf5/9pqwFnsfrJDFgmUtUVQJ5yWlykB4QlQsxhj+jnGLtpmUa8cv1xNS2bATC8fgoj56TEoh2YWPkHFZtteBvAcgs7CevTowU4+ZbbRkJ9aJmXbnI00jmvPHPU4uDdTaduC2YtMxbEkmlFiyruWR0SK7m2cXyAMZmm4QuakK10XnfRerdMFTPy0W/wau+dVbmxtYUZT9QsWr0jbwZMB12JXIunrC6ocEPhjUIQbhuhMbFusZVlLFldYMrp4RjBgkoT07fOx+CkGCWEq7kssursUqi0NY4CBS4B6LwdbxmwlENkteuUyOz0c0k6TKyoXk3jdN5HM52VOupwP/K/XmoNfYTVjOh0V31LgwmWzEsAJDkMMVmt1fMdbByggLclzOLTQNt2Y/n9PYaRGeqHRurPJnEPV2QpE8XpJIIVMm8KcrFIQALFQpNxCQbLph48LME5i6a29uwC/Xz1mRET8qJXQgrjML/HwMnCfugWfco3ENmBAgO3GtTmwAglUmU7YEDq4LyaY486+DZFJS2gfnWegKUCBV5rZ1CxUWcOxyiwnaQIw8ZHJGGaKonTUZIY56tBDnXX7y56tsOS4mAhQbqVB6aYQtrz33SnIuzkQ8UaGOrVgsQHItuFwj5tfH18jbcDwUkmF5LLjZCpwskT/jo/AD4g5cPG0lW2CnjwmxaIdgzfUHWIjju4n1MrMq9oQofMMDREMDfF1ssa8S5Rd3ki9XpuBIjioLYnzdeNZCoxly0jnyYmbhIejysashH1tnL77go7x4gmM7JVimy5RdHKNrfv22w/BrVJR9ozU+1WJFVS1eNNaQUKjabHWr1cIu7SocUd8UC2c2ztKKOfStsjOq/b52IRQk31SaqCJ9T899ohKxCDabAIYgtJ49dfdfcxjr7tqSBdiKWRaV5rOSEYkhI7IQ/28zCjeJ1waXXvThnLm94e9GasLWHr9iLMAmVwEnkjJtbTO/2/a0NWlrGZztQaxXS7ghrrglBjlokycZq68vK2/4Z/Ic1mLJ94sZm8N64DU0I/13k6A3ixNB42ZsQd4D3s6IQM6HwMmqTGZ7eBW1LIbEke+CsxrLg1GNNJvnG2ufJzaXqGMbniOXFzfDY7KzqTVyzlbcN4rUxr/hVdQIh92YhGHhyZaHlohrkdvnJjRVbhLJf/m/d+6yvaIoe0bFq9IW5AYkgRHEAsedFkQ0QRyx0EI8p7GeQrhiMJSi6qauaMAMTmxBRCILU/s1J0LRWkCti29mUZCtr5ikBHIQW7Jqin+w/Pl6usiZwUxJ4hzd9VvJ8fvJ86rk2zxCdHKHKRHQILKM9RGTBkxg2KW4LAMhJimYKCDTMYCYBfgesiVz8qY0YjbzVOgJUXwHVp8rNHVcgDofrNQy5sISiGu28ZocA9qHurUQnJLUyMbe4rzwPgQoi3NYWmGghcXPuDmzldXv1AQux5ihLY1FGZ9hn2hLTMY4gYmLeGOxJsOKiWvh/aJcghmQIRSldA2SMclCQ747SNGxCgUrcHkOkm9ynNzJaYqMwWyOWhlBqsZDlFneIUmnUiUKJD1KLY9IJmaUKcp5LKLhhgxXaUwi8B4mRlgBZ1fwLrQDTBV1VzWIVFi+4SqMshrchrmq3EPXofD6EfJSaaocv4zyvUEprcTCGy7PLnXflyVfpkiVaJAqcSnTA7cyb8VCmji9s1ZSqPfuPAWncaM8qsZCFJoskG86y8J2+8W91H97lLM++9MlqgZcyg2FKTRZIqdQIjcvXgK+ZI6/mx+IUnRzmrNj+nIl8lxkR/Z4fzSdpCuHv3QYf7GKsmcqUekLfCYrLfo462paE4lGUNTK5HDZsF1BYp+adc3WVc20urLKTpGQxxLbmqFqR6iWgK9ufRX8U6Ia/WlRhlbs8fkim7wRfXzO5twhnuu1aeueJKFJ6TO4vE262RqKUJhGWq9Tku/x1dSzuluX4ebwzLqbrfG04XLithTZrK3XYEndTbZfLARYV230/VhIrrlmO81xxshJIft0qHNTmfKDkdpCQXyTXHg5HiR/rsJeJxCe1kU4lDJZoaNuk/CG+EPNVhurytdpvsOuzFhYNp/FxuVLNvOyTcwU25anwP0mKxiOcezimlC3ZY9QQo6v17gHF815T5wcbRL18e0tDeR5nJMCZBb4mkWrCcGxtYRbQYWA8HiRgiPGVJ6TZ66wUhry8UvfyGMPH6ZY98X+Y+b7s+5PURQVr0qbgBgaxEFyKZp+Nn9Sxa662my+JlsvBn5YPOPDZUoP+Ws1Q3lAhlswrzBD5EjcbJOwNLGg+BsDipsrkjuRJIpG2BW3AssfLK/JNHm5PDkB8zcOgdV6/H88yGIJ1lw7ALNlsssUevc3uDAbgVuJNbgYoxbtUocSm5A52KG8sSJMrfJTRyhC6YU+HmRhie25t2QsuhBkVSr5JXlTyYU1tsLi0Yp2XnU3x+T4WyReCog7bKFLkixhMcCfE3dhCDobE2Trs/I5luoZKWXVXYQtzpGTmRixbi0h+H9ODILEUVg06LLCGO3gUHKJw9eDuFJfrsL3gOvnnrSI9xXeOM5xpJVEmCqRAMfMBiazlFnZye1lEyXhe8i8GR2tUDBV5uuL7ixTcnlAknfFfcYt2aHY5hSLSo6NjqKtxIIdzYg1GOcav32YqFIlL5ulajpD3ilr2JqaNUlHsPoPyy6mwnD5hVszhC5AvGu+B5ZfmZjB4hvbITG7WAjw5QtUSUTEYtMVpY3/Fqelfy7wSj9c0RBfm9iUp9iWDFG5SqWBDm5buKxXo0EWqNGtYyzoA8UyOZPTRH4/UUdMns18gR4Xf5FZXHGpWiySLxalq5LfOcS/XEVpxlr3QhPGM8Yk32mMkbQWv9YkTRYpT2b+n5PB1ZPw2My1VojVsugaMdozlafCoIiRckw+9Dl2Y2serfDvyR0zioy6asK1dm62vqyxitaOYYSpFbUApbV4YdUIW/ua2GDcXBdIQ3A2fBvfi0XFovHeabBw2gzCu8SsIst7vG5hte3Eu7MGQmsdNvuy5XBQzoa3tdfI2eHr7QirbqNlsnGf9m8IO7gz27hbHCMzYBIbTZv41oQsHMDrCcDSamOegS1T1LWxzGM9t5UpJedU5LUUd3ih1Sb0s9Zp60ptQShI920mO9Y2CTCuLlvIr6ljxdQ9ebzss8MI3tj25mLBWJSt1YwtN2eNlhrtsgBb6gxQvrvZkh8ZN7G9BRvjKw3mBcz1wHumZLyjto437BirvyEK7ZgRIYt5STDQJF6dSJgu7ftPcuAvzicn53jlyFeaG0FRjlLU8qq0BVhVHT0DSYvk/yEu2TUIExbjDowkS7CeYRCBRbGQ8EsslKkhh+y9iInhbMRI3pSW8gS+orGwpipicU2JpbXYGaDoyAxRAIq4wm6aTkXEVXnpAPnWbSEKhWorpSwUYH1NZyg8VaLsIJI5OOQhkzAEpnGfZStppW7l5XqkKcneW8vSmDQifBrfNWLRc9iliOu6wpLXAUuclJGxohJCjt1eUyUqdQYpmi1xZk12fw7BxRYizeVSCkjeAWsuBmieOKKNsvWyQZWqTJ6s0ET8E7ua4W9YYc0kCRUTOLMvEjWx+DUWcbglI1YpZN6LGsu5cVmzEyjcB44f5WRSKN8jSZ2QYRmDcmlhF3k+l3wZXEuAV+WLHd2UWuxSx7YqlXt81Hv9KJX7O9j1thIL8iID3I/hZty1oWiyEPt4QcLxApRalZD3wkQ9N02YC3JZNHt3rGN3cK5sFPCT0xGn6rFLqNgZpMygj+LDFW53uGNXoj4KThXJf/9Wor5udnHG+cM9evDaacqs6KD4thK7znl+H1UiPqoi9suNcNIqZC6eXh2jxX8pyvmN5smf9VF4whE3O7hOI24WpZom0+QlUBujQh5iZpMeeeM4dx9RV4IomyOCSxqeV5y7z0dODEHWHrn+BFUmpujS7pfzRAgLLfgcCzAqaJVDCTLVzqwyC37+uribzQ3YYmMvaz64jEma1CHvBWeakxg1HXPSo8zCEMVNTH0gLUoXpcJA9mQRNdE7tu/y3fHHLqfomEfJFTbDOzW58lrBaJGQC4wH2LY5g65N0oTrwbWnEH9vLMtcuzpi6mFX66IVMfV8POu1Ys7ZLiZKG5hzstrLnKNNcFXLGGy1eVjGH7ZWov8O4O+6SGPxbIRtrbV3MdtKAj+C27QJc7F9urVkWmxIDkQrxg3rtQNPm+RS4/1SELHY+aBchC0B1JgHQf427WzGS+tCjEXIvttFXfqnxNxa3bhZtl2yiF/tnhqzHvfe3SxYfXl5NlIronyeSAYI0gv9tdryjSAcJzhTpPCo/D12RpxzJYCQKbvkT8kxkEDRKVTINUIW84kmSiVuzxotngAuEkVa4g2JxVJp8kplurTnP+rvmUX1q6a+2XwMRTkKUPGqtAVIEATBicGq2G3qdKZFjFrLIsdfmjIGGEiR3baUcSnb50qZT9d8LylWV2SbhWsx3Ig5rhQxrnmZQHCa/YCP8ucu4LT54e1JcjJ58jqjVIkGyPM7lD97FUXu2CoWV6x8wvKFV7g1Z8sUmgmyiPZ4MuLV3JdgTYWbLMQ0r5IjefE2ycQLl1d2v8UYFjUTGGtVDDs0fWyIt++/JU2TJ8R4QhHbUaLYdJHdZ2HhhOXRKfspkCxSqSPAqf05mVGtLA8K2rvsoow2w6utlcdxSp60a6MFtWZxZTc/4zIGz9sGi4dNUMUr6ajfiJI5yJAZFgss2p2zKpv6hLa2LbsLFjDBrEgGZhOP7M/Dcuyj0FiJSl1+Cqbz5M+FKbpDAr0iYz4WfJGxClU6o+y2VVweocQDaaqEfRQoShmhss+hjnXTVImHWJwiMVNkpEAd6wrsZusUilTp6yDnzgd4AsA3zPWT29vDMXDl/gQV+mBJhX+5XCviVBG3GpjJs0tv+vxVFL97jMtrpBclKLG5SDMndlJsR4FFaDmB+r8uJ6GCizBqBvu3T1BpSS91rjcTrbCP7w+s3YGJrDxviMvCOeZKVOlLcDyeF4+QM5MmKiLo21j+07IPr4zGLVM1nSbHD/9uj5zOBFWnpslds4JoeIy8Yok8TJICAfKqVbHQctIX4xmA57nq0R9zPziEv3DlaOD0V6/lfiOYNNYy0ye21u5sdF/lklxYREPod96h3EJjcYuIEvOMoEVfAGy5FA4rMaJxxljncn1i5uu5R8QEQg9s/eka+G0AIyw6Nsu2ud66u7ENoWglYgSM9ayxVsVatmIj4hrhOqkOvDXks64H6mIMJDaKSobXB2CRa9yKy1a02vquti8OtyS2CtXFKLIYI1uytSBb62vNomwTOuG1wTu20T0Z96EpM7G10raW2QnX635jARXlyVAWrZGe+5rFKsqUNcZDY4EZ4yIfx2TI51AgDkUx+7hR3L4d9Ik4j5Excro6yR0whWINhQUxGj1dLpCzyDfoVnar9jssWkF6CGEueGbkvDq2ynkHkmVetORtFuAzH/XOyI6KXSHq3FiqJenjzP0NYMyQG1TlmvDW1B0cmyEqNAhVLERiYRyhMmPm2oz1FVbXRrwJW1TXtCvGhAawYMnW3AauGv9609+K8lBDxaty2EF2Pr8frsAiHhDjCcuW1CaVmExrQeSVa2PRhPDCoIe4RIhVLvHiSbbLyDBchERkzSz38wCJ5E0YXLHCDestBnlMokosVjspevt2Ii9C/m3j7Nbj6zQzI7ZiIStuVaxZVOG4xMRGh6aOi7CltIJYpxJEo2TYxeQBCTXE9RRCEe/JOUCw2cRHOH925c1LUiZOhDQj7kp2f+5AgCrBAHVslcy5ka1p8sJ+qoRMDdRylbMhIr6IhSHayJP40Fp9WSSSgoWvKEKWXbMg4NEDGJdgfJfjahGCakrOcOynWQ3nWCxTVqEWMwUhnDVJqhA7a4rJW0ssJrLYFwQ07im+h1hTWYyAhdLhSRuOjXp6iBGFaO//+zBl1/STP1PmJEYokYPSC10PzlB2eScLTZRRAvFNGa7ThzgmWFxwfwO3b5QBfbCfvNFxcqdnRLThlDoT5PT38qq3Fw2xBTsziBI80lbhkTzHosYncyyGZ07uochYiSYeMUiZIYd67quw+y+s4MgSDGEZKFW4wL3n89HkSXFOxBW/vyIWgqpph7RYf6uBMCergsXZlyqSm87xhJq1JSzBcG3EBCUSJm9yipxwiDxMfILIYOxn1zInFKJqLk+uVyUnXxArbLkqq/VVj7yxCfIq1oTkkgMhi0k7xC4suX6HLk28RG5htUpuLMrto5MeZX+o125uFnEh491pLYmcEMhsaoWMFUr+lHy32GczBtX3w4nkkCjPWOMQlgCSK+XzQp+JhxwQn99lv68rUN/OKSI/xhi7QiUnE3pQXDp7wwM0cWJzdqKmvqwhk3LYeIGipmtqWXOwqfRxdYFur8/WTs32w0ukud04LMEkEcQin61bW+qQV+tCXROeVqtgAdIIaGTpbdzGYsv+sHizohxlcTJOXfBicdOUxeF91NySJf9EI1yGB8ISuR0CDdmWOW09xjzzXfM1jFksRCuSIA/XYhM3iWUai5TGCm0WPeLb5O/ERrlwJ4dVUiMMSyXxODFYq3p6UWDWrNaIvQXIZcCZ3eGBNSBeXtZyjbrgfO47JC516hSp7W3BmAQwBkv7zJIMjDNIOxJ61EBw+zTPJ8jGswabE0m5feahQv/c8hnNpGp9Pqf/b6TxbyzKcgPKsR+/+PW1ffKCreGqyW/set6KcgSi4lU57MA9E1ly2SrH7q4igjq2Fii1NMSrzZkBn4grxGlyPJTH1lQWUhWpHZfrk6ROwSmxegIuiVIx20wWyZf3c7Icz0FsqWTPxTERh+g7dhlbCnrvCrKbqDM5RZRIkGPchatL+sm3aadM/ieT5C9WqKdcofSymFgBuO6oJF+CgPKVRGAnl+L9AJedYXG+qUypRaiBKgkfkJU31+eTiQBbSmWw5My5m4ucAREJqPKnBqnnvjJtv7iLFl6bJn+mRM6UDO65RR0UgivzgqCZPGGiUOUMyiwoTfkhm6yIV+EDxupR8Pi4ABMRcXsWV19bigjnKVZDsaQ2Wj/YJTvrUb6n2YUOkwh2AceEFgKZk0NJvbwy15JFmRixCGK1G5ZVvCY2Fam4uJvCozmeDASmcpQfilMx4ad8Xw8ll6EmrJwfJh+ppR00cFOO42QRZxq/b4KFHgZtZ3SCqlh8QO3bzgSvdheOXcAr65zwCgsPxiUd/x/lUkIuddw1Tl7QR+lVCeq8fZKKCzoo8WCeymHcC1jxYd2BqwB82o2bb6VKmaVRig2XWXTveFwfLfr1dqp2xligFpb2iDtyEu7CZQpsnWCByu2IyZjrsuUgiDq+SOBRqZLb1SlWVYhSqFsI28VD5BZL5GZznOiDJzYo+7R1B38HK/huV4K8TFbch/E9vEIEwwUeCzDG+sSf4RqiESLjdszXg7aDJcB11S1NmX+fbpMptWTiRdZdawFstQTaBEWt4sufwiKXx+7Dvpy1CFplSDW33Hy/lFSzdN3v0cyqKPVeXU/iI182B7L5DLwKFZfLQpm1lNXOwezfWmHRF0K42gW+pvPMiii1126vJ7ZTkttJu8ibY8Y62H9biYpdQbYQ8ymhbjXaKRLjnAo28ZPtZ20ywEaB1upGXcvq3KiDOPSmHtNpFwqs4Kwl0srVPyvHmy3W1opei4X1t9w/sw8IU5t913r2hCdNPVuTY6GWqMmMI13rPMltYMAYgRAQPu5EmigUIAqbC5qS+jnlpWJ1Rdk03idcsZPVWnmdXK/LWYXhOm6t9j7T/hbrGg4vJjBzgknhbMgNEkV3yviF8JDGhVuUXQPRB+WAxcF4LdZVrkGOWUV2eYhdsxjujkxRZVEv/38pEWzKqhy5e4c5MemzvQHZDuMYb4e5CBYgMb4ZK3QTEKro37M5ctCnI8TEiFdnsI8ef/y7OH8GuOruj+76fUU5QlDxqhx2OCMhrGXGKgfrKAaIXD8yFkpt1OhIVTIOcg1XjwWuFaUc7xkUSyUEICca8hPlF0gMElyFsU1uMCSxrgmpcYokUenFYg2suqgXWOWYU/8D26l0/BIKbBwhb2JSJjmlMrnrtkr8YTxKHlZEo6jhGRYXL9Rt7Yb11JSAgFsu4j4RPwrhVG4oKA/XKIw7YeI4q+iwjy3LSOoRGZeV4UDGofhtO2jqEYuo526IJMT5ZNglNXZPgaqdUXJnzGwi4OeYHFm9l4GWRTncr9BmHsR9lYI+p+aqxqV2TOkX645tk15ZF+OKiWG1btu2Ri6Xe4AF1ifWWS9rXOBg9Y2bpB4YL7EvDLQcAyvu2rh3OEcvgrhliV3GtjGziCEW6irl+4IUmEaBV+Pq6sMCgBGWW1ACqUyhiTxnES0v6adyR4Amzuqhrvuz5I2Mi5g7bhm5mQK5hTJbXyHEiqsGqcxF5VFTWMR9bHueJw/YB0CsavmYHirHEJtaJIIbcLlKEydFeBLadW+S3FSevHCAKp0RKi/u5FJAnEgr6lAx4VLH1ioNXT1D1Z44nwPcltlaO5wmZxo+1lgBCLK1GbHXsBjjc1hfYO2F0GTrq89HbgIrF0XypqapumYpu7WzdTUgK/ZwYffvmKTqYBf5MNHDivxMki2q7CmAVxawDclqGnEcdl1zcE64X4kOcWtDqajuLnp8/yvFYhUO0Yb/WELLfpehP//zPYeod1COJGyyIVuD1FoIsXCFfia6s57R1S5y7VIOxwg2xA+idI7nR91p6zrcHPdqQzUa4XCIELKry9/TD1/U5HKbuGm75DHAP/zOZhFo2aHmc4F1s7FmatP5ZuSD/ALjSjologUiNr7dLGa2WAMXXG/9gE07oZ+DwIy4lFnUfE42q7CNibVCp9VKChByY9vHZo6fLdlRI9YiXDtctTnpVO19qy1NabjGUjqcQ8G6ECfQp8pnsZ1GtNrEXaYGLOqNT6/CuC9jSmYIniyyTXKFCDorXisdYlr2pc1FmHuG8Rz9N5Il2qRLFliu3QaXYJv0qceIZWupj2+V9h0/TR5KeMxkB+1NMTV9TTtnFkpjRkdMnGtWSpqVeqI1ocrntSBcy9SMsT/X10ld98kPwsU1xOoZrGqiOi+NiYVV2ZAotH6EnEz9AWfPIWNtbbSmyvYNlmDrWWDvG+YsfGJ59jZyGjze8l3yWWZBvf3u/uSbmvetKG2IilflsCPZYOFOJDGRmAxg4JKEN8jY52eRle2Hy2+9DAsGS0worEUQMZcQQ1w+AG5RRUmcgayEEE5cS3WmwhY7zmzs1esEYrIF8VgOI2HQSraEdgYWstCJbEuTu8Vk4sDEAYPA0ABRocjJkhAziwzJODcuhePI+WFQ5tVozkBrsjQWquxeixqjZS5vIxMlb9StTZyQOKL/+mnKrx6k6M4S+dIFLt+D8jLZZXEKjxao0B+iaL5MXtDPSSGQbAgxpL6SK/FHZqUfx4N7NJcygIU0U2XRHylLqR3UdkXb8uTIuAzbOoG4J5jwQZSzi7VrxCwnb2pwlTOZjrE9DlJL/IHtM/XSPJxApCqxsnzv4BoNt3Cfw6v1WANArBUEXjDgUqknIomQXJeFajUEazXqyFZo+tgAxSMuFU6K8/dRgqFrXY4yiyIUc5ZLMq4bNspKdSjIrlfZs5ZL0qh8lSIoa4DzS5W4Fmy+z09B1PCTUoJ8P7FwAvewYn+UJteE+JwjYx6VusM0w+VxxAsALtg2+ySeAewfq/2VsLjw+rMhCj6wk8LZBC8+4FzKfR2clRKTH1xbbihKkZ05Tu7kK4UoHvLzZ75JPJhZzjLsHbOYzxXJQNi1GAbczhBnQc4dt4DjtimZoqqZ8MBVuJZdFZMek8QJopi9CYzLsN22Nsmxn8H6WixyGyJJmdvbTct/naJqxE/nvOAKXmiaXmVd14nuuEInPUc71oUUYsn2QTbEA791gD66EWsh5D7bJIzjUlbwuLcx+Ua8ljq9JhdZ/p4PcaJ1l17b/6SWGavfuPGICRHHn5cX9pB/g7FwGWwZFDuzZ+upCZHguFb8THzNotu68toSMp7jo0J/hUqdFYoMw0+2vn+U2+JzsUmPQ/I3sq/DygiCJvmPJTJeaSorYwVgraaoWTCENdW2Ya2ckNOSCMu2tcmEz/2yOZwVoTVLuBGt8GCy7Yk8CA27rWHdbm0GZrsQgTEDxHaafWL8wcIYkiFGUdfcR1GTrRceUGD6WLmI+HbJJo/kd7zvolmpyBfZiwVW2JHzupquD+XmGi29cL2ePsZkmTIWVjxXEyciT4U8W4Uej2aOrV9UeFTCkOyCQte6qsTfGlBNwMZHY15Q9vs45Kixdiv6dIxPkU3mRhixWRiS4OUgYmG7xbSdXGZinJPV2j2mqFurOWvxktb8vrtCSA3Y/hxhMRaI/Za47yIW55Nl2v5IX1Msd3plhZZ/9TMUHJfEW5b73q99+5HI9PQ0ff/736evf/3rtGnTJrrlllto9erVTdv8/e9/p89+9rN04403UjQapYsvvpg+8IEP0MCAqYll+NSnPkXf/OY3aWpqis4++2xau3YtrVmzhg4XKl7biK9+9at01113Nb13wgkn0Ktf/eqm9zZu3Eg/+clP+ME855xz6BnPeAY5rfEQRxBczgbWP9clv8kIAfGBMjgd20ocp8JF62E1RQymWflly57ZBz7nOCpT3xSDKBJlYKKRHXDFjRZxl0gUlKtKeZeQiEc7eMd3iPUTAjC+vUSZhUGK7ShKNsRQkLw81AKUmkfOxBRNXbyKAtkqFXr8kmHRlnDwGVfblCSfQPZjuNRyPOWUJHfCPhEvhfhUTI4KnUSRCXG9tfX2EMMDwRfs9LNLMEUDLFw5mdG2NJUG4lTsQjwsLBpiYUQMJqx5mCxAsGJixKWGUojTdDiZEbIjI14UK+aw+PIqPRIzlTzKRl2e2KDdIApxHTgvWINHT/dzvcJ6rJokmuJzhBUT9yDoUDAjsbJYxQY8cWVRb13CJdET2gbHjaQqnGAK3/dD3PbFOCGGU6yQbzpDk+cMsuUmOpznc8Rqde/dBb7/0R1lXpHPHNPFZY86b0+xldw/ihltkGiglzW2Fw1SaqGfY5a2PtZPvbfLJDAyhlgiosS9SRaWqWNilB5Cu0k8XWpxUCzDO6s86YalfvTMEHXfJ4Jcyg2J1T66syjXlivzJKbQEyRfTsr+eIk4LzTkF0TJ7ZGV94DJUIk2jN++k7zpGerJDJKTytLYoxdT33/fRbRwUNzA8N2hGBU6fSyOY1uyVOoKsatjoT9KkTu3EcH1mEVqVUo8VascKwuLKsfMwpILYWotsjYjMbsJw22hQt7qZeSOz0h/gslSAZl0qkTHraTM0jhNHOen/KBHAzfJJBQiBdZ2TKAvuvSTNHZakN0kMXm9Y61OeI42ePHGxHuiTwBlUwLFWqOsFdBm0LWhG40JgaxlFVlz5Y36MULj0tdz9nOTqR1ERqzQre+j2EmUXSDitoke4x5qhAH6FT63nKk3ajPsNl6bEXfFLpsACfkNZMzBcVqtq7x7m8HYfHf6eCzMynv9t2Bhrn5hZZNluPN+sdI5WfkS8htklpnGYmGIcJl66TPepqF9WkvssABHe2GsaxCc6MO4PbFoh3NdKl+EsIN7tx1j5QLMq71Pvua/EeoSNNmT5Rwdio16ZnG3xFbK4KgoYCveEOICEIJiY6W5pJ3PoeCI3BeUr4NVuhryUSXWW4tlRqgN3wsTGwyhX7MYh10eu+zzZeN6bbvb5FrnnHsfv/7r+uNM+9czTXdsRViSVAMAWMyWbeQV84jGTMno77lUDvpQ16HCQlHVoeEUOek8hdcjOZ+IVSTrY4x4xRgBMI/A3CTfb7YbCYnHEB8I8x/rueXxAqj8r/WmacmklTb+4TbcxN6/aJQ2PV88EfKr8UM0Fzwq9yS+UfJxNC0qOURrPrSWyqtltcYecuPz3t18zKOYfD5PxYYavQeTYDBI4XBzUq/d8ba3vY23ffvb304vetGLqGoXsw3bt2+n97///fSmN72JvvCFL9D4+Di98pWvpCc84Ql0ww03kGss+pdffjl99KMfZd1x/PHH02WXXUaPfvSj6b777qOOjnrfdChxPG8uyznKoeBJT3oSZTIZFqOWZcuW0ZOf/OTa39dddx2vjOA9rKB861vfogsuuIAfqrmSTCaps7OTZmZmKJFoWZo9DJzzwitY3GDlmeM0TS1TWz+Ny6eY+BIWr2ZF3E4KrIDA5AKf20yMnBk3Xo+9HLyxQLnBgMQ6muRCcAFC6RMMVJyZF5OXHohMjwdUFD5HwiCIBK4Ju2WELVEor5I/bohdXOHeDPx5iZtEuRVgS8bYOFEMrpyGH26aflsfFTXtsKor7rgQVLl+1ICtmAzJDs0c61Fsq0MDN2XIv3WMZh6xlHJ9cDGuUuc/NhPBrRRuREi7j3+IVYQ19vglPCGCyy7K0pRisAaiDA0EusSwws0Pbc8xq5zEyrhc96Esj7Qj2iS1xKHlv5rgFWRMQhCbCddb7AdWU8kqbBNDidUFbQyXLixMYHKItrFWWEw2sgNI5OFQ710ZSq6MsqjHKjQmAYFp1ET1SX08z6PiqgXkn4arLq7BT9mhIMdIZQdlpO25eiu3QXn5IPk3j5LX28lxwJEdaZo4vYsn0h33iokkt6yTouvHqbptmNwlCyl1Uj9PmBJ3T9D4OX0sUhEbjMQqfXcW2X147DQf5fuq5OstUDnjp8Gr/fyciPu1xPzCSs4xUR5Rvgeu3BWxWuTKVI4hERPaRUoxFboDFJwusWcBi/pEkD8Lbpsmb3xS4k3tZAUi3O+nSn+CMxoHhmeouKiL2wdARKIMVGjrlJRUsK5msKQ2xK868RhbUBmIW5u5k+OkXHEtXrmEaNtOEcAmu7Y30EPbH9fHlq3ioiKFNgc5Y2otrholMbZnaftFHdR7j2TVzvXK5BG/TzwPmNzjt7DuPQdP0LZbv3YoaKdrPuMVa/nVWqvw2wfWqmRLwmT7fJQzSWKtkLJiyC4A1mJkTZkcWF7hPsz7MW65tn9qjJFlN8+G76eXUJNlKTxpEgFtEgWN0JDK4j7+/50PjzcnKzLnVOhttvZCMFpxbc+hntDJeLyY2NyaUI9BVJprCcnrkqtkJ1nOaCsxlXJcU48c+79XLMSps5c0xfqi32y0cKKfsYsDNoGTPSe7GGo9e/rurFBkpO5HXOgN1RIoFY17LcJoGtvWWuFqGemLdcutrfFaq09r76X5HLkb4DVlSWwqcP4CPldYZBvb2tRKH/iHycCbFXGFxHpTp/Y01WDtWG98gM25Tp3cya/J5S3ngXO1ayBn11cxThncQdfdf4y0zWigKblVp8kIbdsZdd0DDfGyyJFh29U+14nbxDsrf4w8T6ER09eiHFojJhSmGgpQuUNu2vipIlgTm00G7FvkviOnAZ+3rfdq6eyo9d+N2/FCoxEcVuBSt7RL5ng5r/ET5f3cCfIMLP2Jic0NuryIXLvGLrn2zCKPqkP1lRnH8ahaMPv2STtteuE76KHar81FuK5YFqedo7PU8DoILFiwgB588ME5C1hw0003sbX03nvvpeOOk8Wa3QGN8YhHPILuvvtuNp5B8A4NDbERDUIXQKf09/fTpz/9aXrNa15DhwO1vLYZp556Kr32ta/d7eevf/3r6alPfSr9+Mc/5r+f9rSn0Zlnnkn/8R//wSshRyJwu4WoYvdfx6HQzhSlj+3iJBaYrHOplypcMSWzsI2vlNgmM9ib+qp4HwMrx5x6RLmKWDKxGj29OiSuaabPhzgtdvm41E7fnXkWRNg3f68PsZgO5buj/J2u9UShDIJXzQpooUDhbTOUPLGXLZrBZIVSi/08qEJMQwzDpSmxSc7X1snDCi6ElC0JAHdmTGx4BR9lcYZR2iFAyWV1t534Fohcoi2Pj9HSq4g6HkhSZDRMwfXDLE7Sq7spsiNHbi5AhYULKXTzBh7YAnc+SMFwmKpDvSzA2YINN9a8ZD5GHCeSJomYr1s3cL2Y7KEkz9RqHyW2VKjzgSJVYyEKb53hfQdDPgqkfGwhx+QEQhb3A5bcmeU+ttZi/+wWHJDFCAzyEFlwmYNA7bkjx+Vj8HnnAxkWcNmBAPX8fTtlTlskheo7hlgg5fqCRP1Bio4UpF7qRJknFigTBPeyykA3PyMsdlF6aHSSotkCebEwx+XCMl3pipBvOkfRe3eS1xknZ/VyKvZGWbRjorX90n4W7bBI4N7ASj5yVpCtEKVuxDc55F8fIZctRZI1k7OR5sUFG6UgArDq+8VFmt3gCxUqJSSmFSK8FA9QMIlSC6jVWyA3meNVch9bPqtURdZhrJZ3xDmm1tk5QV5eMk76MllyppPkrVrKq/O4Z7xAgPhfiF6UXMDkxVpN8f8cM9tBHiY7E1M1S2xNuMIKCyELCyyyGBvhiu9Wly2g3MIYW2T6by/QxIkhWnpVmfx3PUBOKEi505aJG/dYgTMs4zeGGsO4zzMrfLxyj3aJjMvEGYLluA+sZTdLlLHCe/j93vthtdA+FOGs4izcmife+M3YmFibHKgxbrNpHxnHuMI6lB0y7rIdst+MEXKBtMTSgta41EpMtk2ZGMd8n5xLrjdCnZsrlO9bQtGtzYGzNSuwOSebAZfPM2jyF5jsuLbTtC7EjrHu4fnmrO4xWTzlkAzbwRrxOnGSCKbeu+W3GBpJc7kvgCROjXRc96Bcz5JBufalUcm0n4FXjOwvtcQqTmqy9kaN8c5aKxuBt05kR5kKSGbHVlDZV3bQ+jfLC6y8Voxajxqbid6ChUdpW1/NfRw1VBvL4kBs57vDtTG4Y5tJUGVcpy2ZlVjtsjVym4Oi4e0EsJDJ7XhyvLZIAdDu1iLNbcZl34yV2by3smeC0qUQUV6EW6lXLi60U+4Jxn+blBBjAUJdkNcAoEQfPJHgxcTtOpznPBmW8G3pejkbm5APC5Asxs2Dks6yF7rPlMehU+UBxcKyfMGrLzRajJW+tGaxnOOg7Lvjr/ebBE914dqEaUecL1zN4zukLeI7QtS5Ds8+xmQfURYeUNJCHIaVkoX8yKhD/k3hWgIrAO+Kxjjq4x6Uhav8YIWceP1+Pfj8d9FDHVhcIVw337ycEvb+HSSSqSotO3MTH3M+4nVex0jKgw8XYrBu3ToaHR2lxzzmMbVtYrEYnXvuuXTttdeqeFUE+KS/9a1vZX9zPCwQppYdO3bwCsoHP/jB2ntnnHEGr478z//8zxEpXh/5tE+TvyJigS1vO2ao0hXlOp2c2Air+FWUwvFRx5YiZyWGhQ/bopaqnQ9wLE9JBlZ83rkxz6nxyyFxg8EkqYBMl4hL9WyG4goLpI7tmMQE2XU0tyROgYzLcThI/gSXyI4t4sqEOJtAppN67kqRA9FRLFF0R442PzFG4TG/rGzb+JkJjyftHJPrqydC4hI5Pof8aUlABesE3IfzvcgkKzE5ELEYGCDAsT2sWIuuTtP0mhgNnxfjZEDxrXkqLx1gS2z89mHyOqKcETe8ZZrdgplSmbxKltxMnGuVluIJFk0of4CJpa2ZC1FrV7xZ/BewAlxkC9rSX+6sWXOx+o0ERW7GJfeBbVQ5bhmLFcQnQUSVuhy2qkC4SnIqxJpVKTYssygRcig5JCvaiJ3kUkWdAcrEQ1SKuhTfUaLciQspPJan9NIot9HMyhBb+TAIIzFGcLrI71fjAU7ugRq6mMzhWcmc1Un9Nye5FA2v2lcR35on31RWSuEkwpQ9rpsnCcFklSZORPInIv80Yqsd6r+lQrl+H2UWOtR3e4WmV/uoNAhfyCp5iJneKDFTU8eJa2H3uiqlF2ASaawfmAQYywCeBSTRwrniOjHZwOo9shJj4YO2jxIcX7wcMkNGufyDAxELi2m+QNXuOPl4UuJQNZVi0clCc/soJdI5GnvMYl6oYa8EK1ptRmJbH5ZrFIvbWHVRP2UfvoLiN28Tl2Ks1uP4ELAQ/PiOzUzZmaBCb4Qtw50PlijXF2BLS3YoTJ3j/eRtG6bITRupcNpytiwjk3bvD2+lysNOoMkTo+x2N3MMygpV2aOh2uVQ7z1m0ol7Hnepa0OFUkt8tPqja2VibBKk3Hm5itkjGSwwAo7Bxuuw9C3IGD6zMiDi0GbxNYLIih2IQmv9suV1OjeJwPHn5LeVHbJZzXd1GoOFH0RH5LPYFjl2dqFHlY4KFcMoLeXyglTn5ubvRsfkO1OrTame7iqFxt3mMjcmkZMl39tg2XWMyy1yKCR3rW1r8adNe/R7FB5zuDwPYumzA91slWzCiB4usxIKkW/nJCf1QYxl1Qof2+7G+FY0HtEQ/fY9S2KdWB7Tx4hY7bhDTNJupYMyNlGRgUWnK+WA+LzRB7NreLNwtzVpwxMVKVfDi7DNViibUMlaQ9nfz0Pcp4m5xJiBvAjmecj2+2tW3x4jXm3GYjw/08cgrCheW/xoOm8f7n/zc2XjoRd2yvXfec8yCg/7kDOR8v1Vcso+8mcQuiJm7Hx/PTEWytjxq1njGD8ZeSbk/7vWV7hPTDxgDm7Fo3XPNAK0VmN7BhkdzUWinzf/H99epWy/y9broZ+va7oea3W1SZqsVb72ORY60ZdjrLBjPwwBKKM2INbW3DJ4H1U4jwhA7Xg+TVi+G1zX7W+3Y12Sxh7WJTWKjQUe86SO7bJwC6aPMaWmUA4QTj/LUWbOR0VbMmmnSye8W+o+298yuPXLD83+Pd7h8L+DSdX85pJGYFpCoRD/218KhQK9+93vpgsvvJCWL19e0x2gNQYWfw8PD9PhQi2vbYTP56Pe3l7q6+tjX/L3vve99J73vIdfwfr16/l1xYoVTd9buXJl7bPdPZD4Z2l98A8nHI9ZEDdRZGWlTI58iEOKhKk82ElOGalv64M0u55WJckPMk2K+62pYYexABltObOvj+IPTJM/28FxN3gfK8VcBxaDO5d3kaQavDILrbGig0UYJ1TKID5TBsrJExzq2BRgqxwsqp0bAzTy8ISsQDsOLflfZINAwomwfB8VRkoei2NM1OFCyiWAOuR84Y4T34Z4QYn5hBsthJScm8Sowm3Lxmnh75Gz4zwQc3xYRUQEvtfhDvBMwD8q97TUH6cAVmDhPmqsed7OMXJ6u8V1uDNAHbftZLfRzHG9YgkNOjRxqkdd9zkUMJmZ3WKFEjcMc0p/36RD2VU9LJIS128RQeT3U24gxGIM1lJYV3Bu7IKclkQXcFdGUXgkGEImX1jVIXTC2zKUPL6HQiNZzoZc7A5y/Vu43cJai+vJLI5y/DEswxDxLNLCmCz6yevz89+SfMSjwEyR/Igz6glKHb5ylSfKnhPnOCJYZwvHdrHV207AMDFLLxLhyhmr+bxRMkiyfuLzbZd61LtwgqY2dFP3XQGKTFapgIQxnpTocfIoeeHwAI+Yr2wfFkJgzZbnEAk5EO8MqwxW7VFyAS7PobE8OfmSxCPl8uQskORfHFMNYBVF7VVkDLbZJdHmNuESXIEnpsipLuY2iG9IEU0nZSKEz/HPWF45rhUxUuUqTZ/ayYseKItjY6m4hmBD9mG2ygYDVB3sFvftjTILjAYC1JmIkjOOGbGf3YuTx3ZSaLLEcbzRTSkqn3sSTZwYpv5bM/z89NxS4vhdJAxBPHEZlu9MkVKrErTsV2OUOq6HFwAwwUZWVutSfv7TP1NzMcciS3bQTzd++82HqEdqb9q5L4dFil83SseFWD8mHKT8kk6Z9O4mSEniLOu/TX4180Dr0mqtdcGpultsJVIVN1mjiqxYSy8y7rQm/wGS8ZSyMt0pdYqw2HmOUVLnmGQ6pikHbq3Q9EofBWfcmhi21MSXeS0Olik46meLVNxU5HFMrh4rXmsJnjJ1sS5WUae2f2vRSmwy1zgjF1se6CT/6Ax7YsxqVUN7bxdrnlsJ09SxEGF1q6ul/wY5qayJnQ1Ol8mfLXEW9JGHNatsK/RsGZnWerUWLBbbWuGw6BUTGAeoqdZrzR05YTL/oy/sljHXxgij/0U9c9tOsWFZ+MP+QXpJiEM4GoW5/a49Ryt6rbcSFgOazvUR05ScitH6LQvINx5gq6dzqrnhO+T68SzxtlmXBm+qr7Cg2kFGSsnywi+I7mwWKaXjrFu3j0vxWZAYjEvajE/WhCqXsMG+kE8AVKuUuOpu6sQ4gJAPJNrjndpMzZg8NCfzKscCHGaFY5WHesiPJJLY1njU1NyM880PQu8NEobDhzWlh2wMMhaJeR+OQ4Wz6iWDkHcEwHtoy+PqJm1b6zi50jG/qXqbBydd9lJoLeOE+HPEzxb65INNr35r8wbKnFiypMHVgIjdeZFkaX+oVCr0/Oc/n8bGxtgY1oqNf238+3BGnap4bSO++MUvNj2UiG19wQteQP/2b/9GJ510EuVyMki1BkgjJgCB17vj4x//eJO1tp2A8AhsGa8nhsFkHa42Mynyuy5lj+3lPhGT2fTiYC25RxAuvyZrJQYsjpHNS2cJN1a4kiaP6+Y4VID3IUghgDjrbwmJnBxebecMuHEkJ/KxiIHwgKupFaL9t1Zp8gSXB18IzPFTInw8pNTnmNtCkBK37qR4tJ9GzwzwKjziJoNpEz9kXHJt2Rn8nRlyKLFFysN4DgSrdAL9txd59RqTAZveH/Gvth4pgKizGTlDUwEKTkkB89DmKXY1hYUUop8LuefyVF42SL5skQJ3bSJ39VIqLu+lwEiaYncMU/LMhXz90e0SQxvbmqPx02OU+NNG2vHCE2nob5NU6YxS9JbNIrYKRaouHaSJ02XWBdEKFzMINL9ZtYVIRPwWLyiY7L0QrRC7iH/zloU55mzizE5etYfVrhLEZNGjfF+IY51x7dGxKoUmy+xmjJT+uC84DlyTMfnC84CFAB7Ipws0s9JHPbDu+V1+riZOjbFYHT4X8bEymey9R2KJcX9gHcgOohwHJjtIthSi2I68WZ0OklPxU+gv3RRdhuRLRIGcQ+PnIPGIn3rulkzD+V6HrS9D1+b4e1gggIjmrJVmwsdJr8Ykrjg0XeY4p2JvH7vFc91Dz6PAeIYcTFAwwcGCDSyvuRxPRiAuXfwmUP7H9AGg+4c3keM65C4YoMpMUraBYEVMNlZhjdBFKSF+jh5Ic51ir7+bKscvJ9/dG3lCbK0CDFbv8f18UZKr4jxg9Y1EyPH7yEumeN+VIalZy7FfiHVeGucEa7iXcGkOJpHlKkBOV4Rj6hAHjsUfXz5K2QVYjOjhiTbaHvcUrsbset3pkg/ZSIPiRQFLHdr3hMvW8iIBvz/l0Y3fOTrFbDv35XzPbZwinr2An/LLTO2WFmxeAsYk4LNxotZt18Yp5vp2LelS6hR3YVjMGmuSIls5Y7MEN1hwLU65+TjsWZH18YJUZMSl8ZN9lHjQa4oBtefLIht5FPKS1Z6yfirHTKZbUwamlgBwS91ai21wzmGTVMqW+GkVx2Onhan3nqIk3DNuqW7O1AfNiEBBXwqwGOafkvfc4THq2EAUGRaVtfPhoiKx4AamT5IDJTZkxdqG76DetJxpk2ituXDDvXuq4dr5d+rxdaaWyj5sUqSiyQId3SHXh4VBaznFggLGRNsuFiuKywjLMPoZ4hYxq4nNxgK4RVSqPys7S5v7XTtuoh6XaxcuYHVvrIWLcZ7+1k20Rtqt9wRRXamcsVS5HkUWiIW0cndzfOXkcW5TRunYcPMzySEqFSSmCtZiuzusePWIyisX8gKu3ZbP8/5t9YXDBWK6zy2R+xO9wzwYWHBEf27jWk2CsfyxssqBBX9fctcMYeyZY4nJM1AZ7OTxkYzn0cjDpPEWXGMWNAZFxKaXOLW6u/b8YyNSunBmJa6tbkQor8hRegVRdVq+W/OWGDPPVhGu33XlWjSeXb5lGYpGimQlMDIb21rD9nl48HVvoSORilelFqP4QTkG2Lp1a1Ms8P5aXSFcX/jCF3K8K7IPL14srumNFleI2lWrVtXex9+t1thDiYrXNl5Nefazn00veclL+IGCeI3HpYdHluHGhwupq/cU1P6ud72L3vzmNzet1rce63BhB2IGbovBAFUGu6iyop+Cw0m2UhV7w9S5oUCZRZL5VcrjmFIsHG9oEufAquZBiEpSIkyuYdGMjFVNEhkfCwiIWLgxcY05UxYGAzMGQYhETJZRGgYdNwQT3osOi9sURO/UGjNJgaErTzS9EscbYsG29MokJY+Nc4ZjDNaZAcSMImZTYksJbstYSI1JbTUUtscEvhBzJWaIswqKOxr2jfPCeUfHjOscrtd1KTwFEebjWnmBNLIAY+UaMbdV8mVK5IPIiUQoe+oSTk4ES2x5zVKx0Fp30WKJOv6SEnfV6mKKbstwDObgNXmqnLCcMy1mlycousmMaHbluFShvhsmafhRvZKIxAg0ToxVMTUduRyCTPBKS0XsQ3zj/iEhVbEjwhM3uH1hMoW2ieH+8wDvsnAJTZc4oQev3mMBA/mDuIYvXO1CtQzPEDieE6DF/zNM1USE3FyJygNxTo4FN+Yl/5dl6y6eidQSP58zzgsJo0DH1jKllobZrSq9JMyWZ/xDrM/wRVVe+cZqfGYJJot+niRNPTVDxXEcy6XgjEPZhSEW2jsfHmGLOdoCIhuiDDFbiHvlGsMdPnb5CySLEmfEE7EAx8JC+NpM1Hj1fC6XSWLg2ptEZqiALFCEg/zclzqC7GrvQ8xaTxdVN29l62k1neGJjNsRpzLaF4meJnMyCUJW7/XbyLMWWr6pcDmWTMXUlSAnU+B42+zDVlJ6YYBdBXlRJzXI8d2cbAvZpU22V4Q5Qbjybw5ufo60SWqxK4mbzBwM4jO23aFtj3YohJwsHlGnSfJkk4chRnx6NdrBJrmSSSqS4WDRJrNMxCwnYoFlrUJ0+2cfmq5oR1pfjpJduVV9FHnQzPZbwAIZQJgEPFtgJbTio1Y3dJZZCX5TsORggQxWPZQZAzZ2Fh4xqAlb7IaXQbNVzCaFipnqOLZWLJ699PIqOWkfeZ3mAR1pngRaa2oRhk88a+n6+dlsrK1wPoNaYiOPOjfULcE2mRIZoYXQEj6nCMYdj5PjZG09USMEI1vNNS6QMR6eLJW4bIMyadIQzSczdJ0cwLdziryENMDwhT2UPytG/bc1x/gO3pCuxY6mlpmasi26CGIb/TkLQc6uK/GwNjsvn1dJXKGdio1FbhboVsxb0H6oa05J6dNB1ligrStyaqncD8ReyvU2fB/DRbV+nNbs0PZvPF+w2AYmzY1bSrSic5Kok2i6GCbqmaJNE/VkUNwWJ5oEkd0eLzjYUnewAKMt7GIt+iy7EFE2j870Glls4PruNRdrLDYUOFFf4eEr6vVazbqhzThcMQuN3J7Wc4G9GHK046nyO7eJohZfaS580pj6UZ8bNNSG5f1kCuz1AkYeZszbEECP76q5XaMub3RHfRHBPtvDj5YGh5cREzShHzk/BUfFgs3XHqtSfLNZ0Ig3POf47fZnifqJCskQVdJBFq/g+N4Rot4R2jAtKwFj6xvK+yh7JJFIHLBEVkjIhEzEEK1/+9vf6JhjJImZBQmeurq66Oqrr+Y4VwDvn+uvv76WwOlwoOK1jcFqCP6VjWhAimrEpiFjGMSsBX//+7//+273c6D84Q8G7jRmLx4V1yzizL1wKyz0hjm7L1xg4XoaWT/G8X/BDmQF9nEsKg+wSK/PWs+jEgY7DLDIRdMhCXgA3Ebjm3NSxzONcidmBbBoBCQmzDzIiEsXkilhxZtL7PS7lNha5oLnGKxgrasWicJjUkoAK/sY5OF6yu7KpSoPFFV/B3WtK/Gx4cbKNWDzHieB4JqziAEMSKZKlMBBDCSsdRBqmMSHpqvUc1eWUitjfGzODIyyNSh1E5ZXWDdjw0i0EeCBffPjo2xhQLkfpxqkcNdSLsWCbLss6HDN92wib+EgeUP95I5N1ZP2ZLIU+/v99eyEhQK7sFdOOFHcnhd2UAgWOjyHiNnZhMAXhxb+JkupMxay6/H4SUE+b7EkSr1bnDcWEiDc0bYQ/2hDa+1GKRqOnzKWl+Qyl8us4DvIsLz0T67Ei7qSHATlavA3EmRgMQH7QKF6xMqiPbc9ZYgFNzIFo9xNZBKWQbj2RnmiA4sd7gNWejFoI0smzgnx1BCuEO/5gShlhvwUHa9QOeynjvukTZInlMkNl8kdyFFmPELOcJRjozEhi+8o08jZYq1lQYVFDXa9lkROyRVhPld2WcaKOiyoIR+v1gMWqxC2wQBPdlAKByvrnBE7gfqyfqpEUAc4znFY7CoWCxhvA8le7Q31sRh1Fy8UF+RTBig7EGLLMs4Dk/vudS7HqWLaxPVvYTUYGhAXYohmJGjAMzCdpPKaJeTfXKLIthTl+rplMokQ2gDuk58tMFhQ4XJHRTzbfppZJVm0fYUIx5GFJlx2LYO1CuKT48xnsJpfocEb8lwCY2p1hF2DUW8Yv8dCj0zi2VMBJVdM9upqpErVRJkSvRlKTkUp7wUlkY5DdP97jw7h2u59eSO5lSIGrNUpPGyTz0QouQxeDQ0ZYK0gsfN8m+2Xs3CbbWoaoDn+EN+BxdBmdW/EblMyVlnEyiKxEydaM5NzGxObPln+rglpJO0zggkLJuxAYuuitrhCWmsvnv1gunk/3B82ZDvOSJUSXvSx8Zg89pQwFtRrkjaCXAsDN6XYFR8Lc/ydnKhGlBNruuYN2+vuxaZu89jD5F60ilYnk+VEdzAXZZbFOP8CMv0DeElw+5j6qTY5UyVqMjpzdnlzzLwkFcz3NLvuWiFkhTxEbG6w2UKetc+HEfF2McK6FqPlrZC21lbbPtY1uvW+w2vHHrvYK+6sWHzk76xO0Uw2TA+SnOzoph5y83XPk3CWKHucKWE2Iw8i4l8bFxMsnHsDz5+xznM/bp5TyelA5Jh7jORHWYxVJiMzl4UzISx8Da7Utue+PmyyaRvxuuNiuRnpFSIcu+5p8d/GwoVJDIU63wy8pHCcThGrSNg4W6x2zz2SV8NS9pz6AkJXhZxy/VihIfkNnzAooSR3jYoVroNzibk8v4KLtf3deVilxz3ISRy0Y/7OFQL0hJX38P//7xapE+rzValzpS1SfGRSJY//HexjHND9VatsIINoxb9Gy6rF7/dzEtkrrriCLrnkEq7tikVUvA/Re7hQ8domTExMcPrrs846q/YeaitZ92GAeFj8/9e+9jUupwOf8z/84Q9cfBhW2iOR1CkDksyo6pHLVsMiRe/YzlY+xGwixg/WHwgUDFKcZMiUBbBJXjCxbozxkbqlIhwwsU4vjch2JksxrJYQuBhgHMTe5I1ra8HjRE0YjOF6NL0ag6CfyytAhNq6q9gxju2DCzKLMEzkq5w9Nr+4k92egkmJzYVwxSCFEgeYuEPA4txRFgcT8+TyECc1YhFXMhY3FzEkIT4WJvqw3mKig+sMoZ5qwKGeu9JUSkjG2e71ZZo40c/tk+t3xeo3A5e6KjkzaYl/gTvowkHOduig/mI0Im5JyZTEyUA9oZh5vsCJITKXnMjtFP/XJqouHqBqJEC+u+Dn7KfSWatlool7UZU4VGTuhMtn54Y8+aeyVOqJsmjDYI1kHDajMQQPlx/AvQkSJ/WJb5W2gEWFFwgCRJ3rHEouDVJuwC4QeDSzwqXeeys0cXJUrORG2PDqPd9XCFFYYMTtGxZCZ4Gf7xU+Q+IrvCKuNp1wqdDhUjkkQhoW2elVnTwxw8SNXYdFQ3GWU3/SR86kn/wzRCHzvEj91wpNnODnCZqd1BYR2xySTF2wuqMdnRJcov0UHq9QqcNPgVSZRTjixAKZMgtZieeuUinhp0w8SPFtBSr0BMSSU4TlEzG7FSr0hSg8kqNyLEj+NIKBK1Tuj5MvW6LSom4aPTMiseDIhJwliiU9FtiRWzcRwfUXsdAQrr3dUueSYxHRgCGiUokTfXCN2mQHzZzQxfcQzzA8BSLjDvXdkWOLMGJXA+kKDT88SJ0bPUps9Ci1VLJ0BlIuWzumTykThapEaT8FBnKUG45QKeqjeCTCCwnd63IUGEvTzMp+npyyC/uww9/l5GppotTxZbaqBWMlSs1EiCouVcNVKvY1ZyFVDh9nv/QKouNjkgneZJkFka3pWmbY8VPiTZbQmoW1ZT7G4gePJMTgdLNV1gqhgXtQ81ne3HxptMntsBKX9/F7AlYUgqmT5EeaWNeseNypYM1tdeBWk8zGJyeI53420YoatL6seJdUIh5lFxGVbDkd40qMEmfAzx4nIrhglYI4q5V7a6gP3ijO0kvhSy37KXR3NLlOd98vGwV3mMQINttsKERlU/qn5q46i4W80Beh8vFDVOg2ZVKMyLbETEbajgezNHaGuWFGZFrRjTGMv2tEbDlRpfBIXexgO15UMGO2lMuavS0RC2nfyy1o9i+ObTWlZYJ1LxGuw2ueH66za2rvhibEG8Rmfy6Z4+H+8DnuiFFwyqUZ6uAYa7clszWeTV9L2Rxbaxh9EtyHsWgN7y3+sjV8p41HQbepaWxFq7k9yGWBcYHPcUbG+dpxrdXVuInbhExYvOe2WWgEZrV+jwb/17gRmFhXzkPRiN/c11DzFB8LPTbR2dC1RlwG5Lij59uEUDYLpnmNyvur+8doRzpBW5Liwhw4boZ813TKQgEWmhoy7WZPy7FV9thFsmqzbqso4tef+Vd+vSm5rOm8eqMijP/vUVc0X4eyX1xxxRX0vve9r1bfFQlgYQD73Oc+Ry972cvY8PX973+fAoEAnXbaaU3f/e///m+69NJL+f9hYUV5nIsuuohfTznlFLryyis5P8/hQuu8tglwBbb1XI899lhO2IQ6S2vXrqWXvvSlte2QmOlRj3oUDQ4O8ioJxCsKDH/oQx864mpoXXryZZQ5pqtmVYyOFHkii5VjLkweCUoSiLjEz1grHCc5avCSwuAIV1VMViB+eu7O8QCH+rBIwIP9wsUyvHGcXWpypy7l1X9OKGDqmqIDtu5SmFh034cyLxJfimQNXetkVZX3f0+e0otDJoGSuBTBitd18xjlVnRzHCC7zpr6prFtWZo6Pl6rUQswuGIwwyAcHa9ypkVYUJFJ2Ma/IkESXJESWxAHG2SRm1mATLjIcihp7PE53JaGfr2JJh6N0iUOu36hjbrvhxiHxa3M8WiBWzdIXPHSIS4l4+UL5ECwwN00HpYMvYUSbXuCLCig5hzECQbT4M4UeZEAleNBdkHFCj1EIFaJYR1HVtrQ/Ttk0CxXKPnwpTWrAwZntibmyxwPyQmqZiqUWor6vdLmmNTh+iCAOSFXQNpO6u8SJbZWuQZdajnitmTiArctXun2ZIIJ8VPu8Ngit+C6Ek0fG2gS2eIeXp80TB9H1H0vhLEI0AX/KnD24uwCJKgq0sI/+Cm9WNy/IZBLcCGHZT8hyV3gvmUThcGFjuv6Gpdw8QyQSQzuT3y7ZGTGogosvbbcA64R1na4F+P64DqO5wmWW/wmMOlh8T6B1RIsSIhbMWrPhiYKPBF1Z7JUWNbNMc+FJd00vSrEiyGIq8YkC+eRgBX1vp2UO24Bhf9xLy9CcC1ZG1dls2PGopRf2UepJQHqWp+j6dURdgdGVtBCJ9Gy302Tmy3StscPUHjao/HTPZ4MFnqR1dnE+WKhgpN3EeVWYzEEcbUe9f4zKG7UxgMCvw8sZoydKlZXUOqESU4mjrC0Di2cooXxJPWHUvTXP5zBE1UsMBR65Td0z0fe1Hb92qGkXa75/Gd8hl9tjev+m8QCVIn6afIE8SG099ha5mr1VG2CJnzVWq5M/95hYh9tGRbrXsllqIx43X5RtCnu0n4XCxz+GV+TZS+9Qg4eGvc1JX+CRdGeDwRs437swqgtDYKxB88fbxPwmoQO3CcbLYtWvDbtz1hwsTAn3623gxVwNnmUTWIURRKjBktu1/o8e+zwe8ZaigRxck6yTfd9YgLbcUGU4lub29GSWuSrCSr+ewkW+KieMZ3rmBrL9YDxWso3lA0y5543oc1WUNptrIirmvCCRqzgtG2IbL+N7Y1sz/x+WvpA3l9D/K182d4HeUXfYM/B1ui19wBeOY1MnFYXrXzuTnN8NAs9U5ap9lxG5Qb13hRoSRTlcdIpS6Ol3rZBrRKBqTVs7xNc6e2zzOeTrXKeBzC5Wi4mtVI+hzeLdWfvu2Wm2YONG61ElYXG68FY4PMDzZ4a6UWyz+iIXMvw+WZxoLc5udPxy4bpgj5JBHph7D5+fd09z+XXzL+aRYt13U4Z6/CCVePUG6mX+gn7y9QblL//svHYpu+GQtJQdz/1A23Xr80Fe6477l98SErlLFyzbc7tUiqVmhL8WVBmB5ZTiNpsttkjwxLBArPx3mjdJ8Tu4UYtr20CfMqvueYauuGGG1i0PvOZz6RzzjmHra2NWGF71VVXseC97LLLeBXkiASJl5KIkwpQbHteEhkEAlReNkCZxWbCE3Xqkx2fTHwweeDV3Fo9PrFmQuhg0ETcYuf9aeoYTVOpX2ZMgUxJ3CMdxJmWKZT0s1BiAeqXzhcClldVk8YlqAoXTkm7j6REPffDYuujctwvbq7LkTVYXGRDUxVa//IBWvaHgmQ7Dkv9TYiN7KIol17Bqjlcq2CBxSuXR1jg0EyHS13rqzyx6LhngrIru1l0w9oWqMItyQxgi+He6lHf7VWOKUUsL8SYP1uh8UuWUd91YzR9eh/1/j7Pk5zsghANXZulnefGyEXyoSUnUOLBHMdSegs62JKH5EU4DsROaLxA/mSWuh8om7qtHoWGk1TuiVFpMC4idjRNOx/Vz1YzW/4AmTIx4RhILGWX39jOIsd1cu1ev8P1bzFAI64Tk4DIZIVXmTkjcx7WS6kFCAsuQFwxxJ1NegThCCspBF18q4hUPAuIncVkA9ZUTLjwveh9RMUYLLoBiqMEUo/Ey3I9YLi0FpEVGsmaMCHEfcdxfHJP+iCmUS6nROX7YSUtklsOsPAGbtzHrs1IlIJELuz6CGPHtJR6sufLz6RJGINjYl4Ly3jnRsTP4r6X2LrOExT24cXER1yrsViQWSCiHufCsbdjcD0P8AQN9x9xzZGdch+L3WHyRQMU2p4kLwLhHaD4zjKLca7NCAuFK3HBvnw/u+dG4HYK0YqsxTMp9m6Am7AvmSNnMsmLDH03pthy35csUDkRonBHhBb8I0XFvihNrunirMqZIZcXChAv1bnRodFHF9jCGhzIcVxTwK1Qdns3+TI+6tjgsCs4So8gUVlwukL+oEOpRX6JXasQFQewKuUQRStULbrkBKo0vLmXxicG+fkqdXpU7SlS0Vcld3uYHJMQTTn8dNwqhVajAzKhyqHPMzHlrewiWnH/4cVeabCm2Uoji43wEC9DBv03H2Mw1CwgjID0HIRZELnGVbT54M2uudxXY7GpAldnUWLBEZmYWffHkBGSWLypZRt2moWPFZ3WqhyarNcJ5fAWHLpQd0NuhV1xG9rGJpuy19YIappijLOUOoywRQ04uILeIYtCSJTGpctGJLEcn68R1eifzdmxCyk+t0I5t7AuGkH/rUbEpj1KLWsueYPQl0asZRiLt1g45dwCi5qFl/1uzZpeNHXazflTURYJIWbLC4pU7sCE2cTRTgSaXMHRzlxSD4n1w9L+VuhyrdLputuxFeFYgAbRbeLhYam7psv9RHgQmVJJcNn1gtWaVXLqhCr13m7btLkNkJiLaUlQVbMGxyRUia+9JN5CNvaZva7iPsr215PZWdBOuNe4Zrj2lkyW4ND9O5usr1iE5n0ZAQwQZsRtwDHjVQ6PAiNn+dk6fMyjpI7w3Zsl4dcVj/gZv96caa5s8ZiF6+jWqcXUc9EW2niTxOAiNwSH9pyTJqzPXLzifn5/c1pE9MldYiW+fdr4zBvOXbaJQr5ZHnDlgBEIBPYoNOG9aXPpzGef7YBaXo9C2mVV69Ke/yAnFOTC6+4DWyn7yNW1xA0Qjxzzx5ZWyfzLExIjDNmlE3F6qKyCPppFgKmnykmbZACMb6tS5+1jlDy5j7OisvswLGiw4vpMwiAcw1hgORmCA2sn4n8cFs+dG4u045FBrvsZ25Kl/FCE41On1oj4hWsjXGMhnpGEBBOjoWtTnExj9OGoDStWWEwO2Eo7JW60ts4rXI2stQ4uqwM3SzwirJkQfzgPuDn33DZNo+d08wCNOrIQ8rC8ctsYASCxZFJapufqreQl05yaP332UkouMRkgkdUVInpS4oiQdANthtqcsIzZ646OlmuuZ5EtMhPLrEjwggNW+SG8cR0YeLHynhvyKL5Z4kkHbi5ynCafe9xlKzGv7nsSVwzxDeHN5VCyErcZnMjzpNeeJ69YIylXRgQsJkMoSQOsKxrumQhCsUSz5fOCJAWuSXB7wwUtutXlc1t4NR4OlLTxcfp/JCLCwgNbG8alfiGeO7hq22evY0OKxs7qpO51eSqHfVTs9PHkA/eTnz1MkJJyL2CpQNtAaKIGMdzkOIlJHyw7Vc7EiJi7YEayKCNetdAb5PuPhQBbC5gnWXiGO6QGMRYSUHYJohWxpbBcwgLFmY17gxQaK1A17OOskbDUdt+Xp01PCrH1x04uuQ0nKhSaKVPw1o3sSg73YI51jcfI64pTJREh/8gMlYY6qdSJjMk+/o1FdxR40aLUF+NY3cyCII1eWiB/sELFZJAi3Xl6zuqb6ZcPnkozIx2UGEhTariDgr05KqaDEus0HSR/yqWee73abxO/NViwkLkyGCqT4yD216NyxUde1aHKjqhM3o11G0KhsLDEHu6BkQCtf+eb2rJfO5S0yzVfeqqUc3NyMitPn9hfE6/W4toYWwd4YcXq29ZyLA31u/k12JBwKdIctwdxUotVta77xgprBS1+dwCLlHDfBajfDUJJ+dLmp3pN4hVjjbUsWoucPbY9nrUE4rjR0bq45P1MNcdxWq8PjBP2PG0JFitmrAeQBQupVgRHR+VLWFQD46diHKpvm1lWZS8IvrZNJra0ZjX2OB7R0nNPkT1fAEJZQHaxHDhi6vLaGFNezA0335+aMLfGOnPOEEfWBdmKYWs1RCgBnwsMcFb8mwWCzGI5X8fcL/s5ytd4XQ3hATkfRbbJQ2GTRVmxaIV+7Zw43KL+1cTmKmUWyjnAu8puw6cfbL5nGKPhLcP7j8tDuv0SI+qn5Pj2PtlMxHCjtpmZ7f5qcb/mPBoXTWx78T5zMkdozHBtt50+3rRfUs7dZsJGLXY+7uZ6cjQb42oT8e24QBonb6z8fXfIvqI75bsobQYWPUvE65bpbkpNxJrU/Dlr5LON0yJGJ+7va2rvco/8z+IlMtic2iuVL2ZKEdqRMUnGzL76EFSMZ60sz96dm0TQXnz8ffTNs77bdv3aXLDnuvW+RYfE8rrkuO1HRLscbFS8HoW0S8fw+GPfLrGt00nObptZFGGXUoBBGXGimMhjdRIrkixWOWmMuN+yJRYxNaa/YDFjxCfHs5rBBQIFE2avcXvjTsoTKFPOBRMKCEOOtcuKIIGI67stRWNndJjY1gpFtqfJTeVp4hGDNHm8WJ4gtDDgYTDiYu+mNA6sqVYoS9Kgas1Vq+uBkghqx+G6gjgvJFxiq+2U1EqFe1y+RxL5QOQVO/0SV4M09qNIKuTQ5PEuxxxiEhIdlWytEuMr19R7d4FCWybZpXf6NLiEutS9vsJupwA1Y1GU3Av5OGEEZ52teuSfKVCpL8Kxpzgf3BtYF3FPMOFLL/RTcqVHAzd6nFXWxgFhssq1TTulZh++B9dT3AO7+IB7gvqrEPDsBhtFqZwyZYeCFNtRoJGzwtSxTdqOLe0+hyeOaB+IR7QVrhPXyFmZbU1CrvUriYXKZuKAZCnYBgI/MialcnANmMzBRRBxxHDLhZUc5XeQUXPw5jzHkPpmclRY3Ekzy0OUXkocn4vzxbMBgcpJvtIehWYqHMeK7yCpSqk3yq7lEyfLOS27ssji0grl2GiZRWehPyQimDMRuyajr8Reszt1uT7BwTOAfxD+sNBCXIanJZ42sxCx2VIrOPbAFI09vI8n0YlNslAC0Y8ar/j/wFSOXcrcneNSgzURIwdlOFyXKl0xyi6JchkbLAjgOhMPovE8rvk6ddFycev2OzRySZEo76PEPZKBmRcL+k1JqqjE/QWnsPhT5VhsTHZgpYeVKbdAEmeVEhXygh75p33y2w4jWzHiZavkwZ0wWqFgrEjFTIB8Y8Fa4pQ7L39T2/Zrh5J2uebHPkzCVnzTGZo6W2bKNjmeFQg2zg9Z4a2Qg4WJtzW/1ZoYs+IltKuQreHVYxmRtZ2/ZkRhzUJqTqFRMFnraPe9zeJ168Um5tAjCkwboWUsX3a/Q9eK6+P2i2Qn6FNsfCgS6IHh84zlNiPJ/CwYU6zVz1r5bHIc7L/mXurO7nprBQ9CWrCYBcZPkmP13i0CD/2AfKeeUdkKbuvBZEW/FVQQWmXTjtweU7IAKW3lNddAzRlvGFPnlBdjzTWiT+f9dzdn0rUiNr7N45rpfEwTR4rFTj7vRS2ljvCn+X5xiVGpJnmQf0yuuRqy7samZF5BFmDBxKnNdVmX/smUzCvL35ue5lJgqu4ZUFsExzmZ7M42bruM2t8QYyvc2vNjLeX2Om1d2aipdTx5nLEQm58k+vLWurmtCcvQ74PODbmm2Ned58S48oEFY0TPHeKnW+iXG1VbZN4h4hDhPWBqtXyeMgbUBdeXKTwq7Yna62DbRcGm9qzYXAL2kK5H7qRsE1tZd1XOZELU1SnH64/J+ZRhCcDvY8qU9knJw3vMUknytG2qiwrmPbtvvh8veGdb9mtzQcXr4UHdhpXDh0k2gFItxS5kqy1zhlzfJDIQIwsG8uD7qRqFedPl1PH5JV08eYf7LleVMYOOjX204pattQHJfgoRzJP2bD3Tr90e/8+rv8aKxq9GzEIIQ7BOnhjnFVXELoZHc+ROpii3ZpA6NuWp0BWhzGIM5uIOhElD791FGj85SJ0PFil8zw52hZ48fyELsfBYgWaWRbmWHyfQ6emi7ArUo4XlDGVxXD5PTuBkBi9k80XiJ3EjlZhLiML0Qh/Fd1QkthJJnO4t8Sox4mdt8hsAQeh43RTcMkmJ+5IUHQnT+ElhikTDPAniONljEyZBSoXdd/EeMoNGxitsFSzFoPyJOh8ssxswtoHwg1sWElvBwgdxBxckDO5sEfXLKjKXEPBctkRi9ZuF/ni5dq8cP0QoLNkhXr329SIBUIUSd47T5MMG2FKBe4FEJ8klLlu54U6IyQomZBCi4qZWd0vDsVHzFVmH0a6w2iAW2JcXKzBKV3Q9IMmvkNEZk48djwxx7GZ41KFcf5DKkRB1PuAjHxIq9YjIRH2/jm11KznON9UFAY5nMkSJdXAJRukfh7ruTVHnfQ5NnRinieORmMujDpRN6ndp+Fw/9d3hUscDGfKlcjR6/gA/c7B8Q1SzcER8K2Jni5LgA9Z+GyvKlg/ExiKWOFem3lsz/FxyCaTOOE8YB26BdbdK4eE0Z4hGvVjvpGO4bAIyl8LjAd4BlXiIAsUyP4ewxiD2GG7UODae8cD2KaoOj9D4v59G3fekufxGeWEvZftjPCmzCwap5YjvFjd//K7im+T/sViC2DMIDEySEeuG7J8cHxhHzC6SVplkamPym/UjrjrgkX8M2ZKDFG10wTt8ddGVPYBY+HJ/Ry15TdddktHHGTHmf8RPmTi86oBMbrP9DX6bRkRYkcqLiOW6ALAJeyRkpCXza6jFsmXm32wdMmXVauKhxTjCpdUSLnXfQzT5sBI/Xp5xma1Zlxo863ZcEJMSLSakz2abRZ/F132/v2bNtFiXVSugS0Yccv4GhDQ0eFjX4mgLzUKOf1NbJfmPFa82u/HwI4y1GMkKC83nzCWpTCK5Rpdb9N027tQKKPz+7H2w7+M8fFk5wUpUFsOQxM4KWCt04YnTaJXFfey7S25EanGAvVrsIiMq1DRmNWbX4ZZ4X+vSG9oUajrvMuLiuWSQFZOS5wB9fnKFFc7NPrvbz0d/K+9hnIg/UI9bttbf3LHScDVxZUr7YKEwO+DnJI52IRHhI3xdx9hEST7qua/uqcT76W24x7her3nRwIpX3Htk4G+E299xaMd5ovwxLwB9d0kDTp4sN9e6g/fcX65lFcZCv2S1J+q5L8cZ3ZEnou82adjsYll4YY8nIlp4TYlSy8Qla+JMZL9ya21rXb2Lqxv8lw2xWIE6w83vb53spsKMtN/QoimiWI4m01F+f6AzRf2JNE355D5kkHzPc2jTC99BDwWOxGzDRzIqXpXDBmJb/dsnkBKQouvGuX4lbd4h9SdtAhlYiEIwvXlUXrWIAtMFckuBWkkWWIAcTwQSF7ovwBVVVichOHngMGIV77EbMvLTmPcwkGDwwPcqftRss7VipTQLZ1rNS1wK77cjSIX+IWPhRewk4mBcXs2G+xAslOnFAR58kBSKaCG7/3auz9COR8YpsyjM8YKppcgWtYKFRfTBKcr191PvmIhWrLiWImJdyw4EWLDivOBGCpdgDKKYHHVtKNPUsX7qvadM4yf7KZhBLVuXrxFxmMiui8kCC/eJLE2eO8QWQqwkQ0ix2EOt0KjDImX0jAgVTkD8rcTFYKWZXaaM2yZWf5FAwia6KnTJajraCFl3IczGTkWiHxSyN3UBTRZJuCkDxHZCWHUgwUWP31gbJWEILBidD2SpGpB420pPjIUzJn4QSVgc4Nq5cB9Oy2ICrLy4x9aFFxMRtBe7hIccFrz4G/GWXfc5nMQIInrhP8oc/8n3PUw0cUKI3eN8BalLOn2MS0PX5znrMNqza0NF4pBRyqYgdYPZihyRZwj/z6WXlsXYAhsayVJmRQdPEDo35ikwmuKkWOOnJTjeGfFUse0Ffp68oLgxc63TDhFviOeFy2N0BNZnTOR8krU46FLAzBdQwxiLOImtM/wbQn1kxMHufHhMYrgRt4xnuS9GybNOYgsx11I1cbCI9+14IEmB4RmqdoQpum6M/PkeFt6wVoc2T3CCM2+wl7yTV8l9mMpStTfBSUDgWh8ZRf3lEI2d5vJkFhNPeBugHbFogMUAZBhlsd+P0joOVWMVTnyCMgzBbSFeBMF9w3ORWVIlL1Em30SAKiGPyt1lcnI+Fr6IN4MAueejR09pnCOB8575GaKlUe6vADJhg0qHUSjxheTfYf1um7OiIjQBZBy/uMxKBEFTbKi1xlpR25iptpa9tiVxj/V8Ab7M7CVV0Ld0bDNZkcfkFQnb+DSNJRKeAxZYUofPR3xHswWz6wF42zg0erpcL2c/p+Zzt7GS1ssC/TLXrYZLbn+zaIN3AmMSOKH/wuJP7cIaku5gMc1et3WNtpZWCzyCuI2x+IkapRnE2zdvY9sms1QaMrHBZWFp3a55v0Y8VhLSVoWSNLat6ck1vk29dE4UV4RbqrFA1hMWyz3JORQ2bta177fEiFoLJXRobpHJhGsFICzAjkfuAmOlnI7tsihhY3Y7NsvfqaXNCxLW8o4mhUXYP1xvFCxsosKBzZ6NBT1pJ/m7//YC7XxYiKLbfLUySBYsiCL7/ozja7KY2/uCdsFzYcOVGmNtu+6YbIpbjYzbZGdyXCw62+eDvQmMK/zMMohzeNQ4FBiTD8p90ui9t6c4cRrKq8HaikVR9njodmsLL+llLaLI/Ok7zVhas/IgV6oOBQNybmt6JMA5amJ5bhpeSqFAmY5dJe9P5OT4EK2dwXpg8FQmStl0iBwjYhVlX1DxqhwWLnzip6i0KEK+gUXcmUa2pjjTbfGs1Zwohh/Oezaz9dXLygDlu3MDOaEQ+eJRCoxGKLO6u25VzYkrI2Y+EKkQJJwEwqy6w6Jam9gg6yz6UhMzWTb15DhjLFaaKyjxILGGHJuKGmzTsHzJfhCrGNmRIieVIee4Icr1BnkAYZERF5detkjhf12HZlaGKDLh5zhViMveu/PU+Y9hmjlvGY2d0k1Lf76dkxjxd4sezSz3S+3ZssfurNnBAH+Oib8deGw9284HZVUYkwVeDYYgN3GCsFhgQoR9bL+kh+Lbq7xvTApDcHHOiItX50YpndJ3V5EFNwRubP00OZVuyveIJZgtpBzXhZItDscMYXKIBB6Ir8LnsDhinxgQpRwQEl7V459glcWxuzYiZlYGQ+wbwpdLwHQFKLswwgILgzUELVyP+Z7GJONzx+YCJUshLnskbtW4NxVKL0D7SmwXjo9XZCAu9EBs4hwdzu6ZW1ih4JSPMoN+XtxIL3G4HAefKxY1fETxm0u8SDJzXJzFKhITYcEDbl0Q+fy0eChT4+fJB7JHIiv1wE0ZzvxZSgRo/Owu6rs1Se7YNBWX95MXCpCTLVJspEyFLj/1rENsbJBi23OUHwjzhL8Ui7JVGfcJk1O4ViLDZ3S0ytmsOVlZyJTmCMkiRXxLVhKRlcrkTk3T9KXH8aIGrOOw8HKJqSG/xBAjTrdiavDmEZ+ckcnY2AQ5kzBN+Shw2zQ5AfhCxqgykKDysl4KzORZZENYz5zWz4srmSEft9/2xwao+zaXeu72aHoN2ltc2JB8BS57XmeZIvcF+T5gAo8MsG6wQu5oiMoJLAggczIRpj9VvycZR7NBqsTEBdqH8kRZlOrZdVKutAfTq2SS7lTk1Z+T37bNDA8WWPFqFiWdjRIXF98RosryBZxUaHq1THbthNr21zaGkeMIuU/FWqaxGNraq1VZmOTj+j1xhTXuqvAG4O+b2Q5i9G0SJSw08TknZQK+6G+y7dZLZGPejxFeVpQicRFAH4TxAQt1FmtBs0J0+vi6O+zQdUaom1hgm9/BijS2NOKZz5t8DKF69mJrabbHxuIeLLBw2eX6ssm6RRm1suV+yN/oMzjOl92sbXtRc5bkOMJIJOYGx7YWUWlPanLPrQYQC193JfZnJSO7lJsz12KsvggP4PNOOpRbUq4LT96PEZMtGgZ9LRYQuR6vSajoBM1GBfPdbrHo+tfHas+YBYthkZzU/p5t0QL75nAKHwSt02Spt6VtOPTHWDoxLgHUZLfnjQW+JX+Sm5xfIA8a+lr+u0tyYWCfXO6I92uyTxsXc/TFsjNzP4yXlZPKcrm6Ov1cn5gvvWYlb7bqw/sKGYq5vBvaGvvvivA8KrcACyrB+v02btPIsM9t4zY3TmDCT6X+Ei8whrvyVK645HOrFI4UKTMZpUzOT6efKBmIy7yCT/RgspdWdY7TOQtllWA4m6Cy57JVdmFUGnT9jKzQjCXlwejrEb/rGx//MXqoAKtoRS2vhwwVr8phIYMJtSnUjY61HO6sZR1FHChW8d1jl5BvOkuZY3sodv8ElXvj5LtrA3m5HDnBIMVzBSov6KLswjBPwl1PEu5w4hu72hk1q934w67MwpXYrIhaCyy7bjkyIZEVZImxhciFiO29M03FrhC5pQr5J7LkRYNUjYUo/OAEDUxEaPKUzv/P3p8AS5Zl1aHguvf6PL55innOObMyqyprYi4oJonf8GlMokGNhPojGV/qjwCJlhoJa5P40m+TWhL9uxHo2zfaJCQkIYQQxVBQFDVmVVZWTpEZGXPEe/HmwZ/P821b+5x9/biHR2ZCkVmRVb7NXrwX/tzvcO5995y199prySLBGNWH6HqeiHH4nZgI5RAEFW62xd7g8GwKM7U5AQ+tYh7Vx5ckwzv9+S1sffOybIOUo34swPLv7SBeyaM9kxTgSwBlfEshglFcvHCSlB4cS5umaBQnZVYEKeqQWi3j6CtswE0iP5NFNxdHOx8Tauj+AwEyV/ZQe2DOVBivNETFs/SuWfk/s8iknpKKfHjSR3aLfVuGgkegwqxzep8V2UAWmQSIFDcRAassFZfNokrUfKfN9ejHYzLWXCBNXyIlKpAqLCvdBOTcPhdZSsGaudRDY4ZKv1yg8hqYxWdmtydqtSJoVO7LYk5o4VSe9j1ZOPUTfcy9YKjCch/EQ8x/qS/3196DcSw+25WsNX9HcMZKrFRV2+Y1AYtd9pQ1xfN39/GM8XFNGKXNhc+XsfV0wV6zJLKv7sDrFpAhQ7JGJSwPiZs7gB+gcX4e2efvIHspieapGcQ7QGvOVGtITefib+pyA7uPZdCcB9JbnoxtZqsl6qLCICBNum4Vh9l7vbmPkAmeXg9+KimJCiZXCiGw96DxqpWFcJx+wCYhU7x4iH42IUCbixfvwnHj+9rsIowH6GXjhnomiywfvZRZnM1/cltoofSALV7ryEIosxNHfZ6UYVWLDUWcKn/FLoRjCWNPQp/WmSZ69GjdTsE7Wsd0tiX93O1WDP1qHH62g26Mx9WHb2mKXDjz/qlbBdQb/+PfepufVJN4o1CQqBUk/b8K2TCqjy/Ld1H/tjYs6V3zkE5dNEB2pm5Q6sFjRk2Hveca4uvdNkkRRlRls/oFpBRHasMjx0emBYPPSD6j5BltwYrfNIv4Plk/NnaeiAszwqXOMmgLxZh/lnZkZl9qQcPEnxz7eQPc82s9bD8ZGJGxuV4EGsceF1kSpPSSJbFiDoyCZG7ELfjJbLdROst9mLnGDa0EZ3ZIjfWGRJe0kqyet7WT5qTylwNL5aUQ3TBdV/tdSSXm7zjmHL/Uro/WjBkc9qcL2D1hjrv7aBve5eEyK2m+3SKQ2ogNgXUViMqs+xHVmX/vnJNHhY40gnKA4IStLK5mxbOUnurudeJYu9RzZYDIvjaoWg/sfKPZcNi2VkFb5gOc06SC7bM1hy0eCZm7GeKpzXv5ZA5Bu49G2tzo0k4ya7dT6glDaf3rtOnaHpN64x6SmWVYOwxWXxefNRSB+DVbOp8yPHk6BzApT3Vhzqtxq67OJB4TuXJ+1OXI+dh6j9nfyme6qJ+dknlRrqWl3NMpQc6P/uZWFZ+sKAYdE0iZZ1uNnM+IiHt9J4vCUgXF+Sp+6oHfk9c+XzljttePoVhs4EHK9wP41MFZscW5uj+Lw70cXoP5uz96ZA+rt01GJFlo4bA2yURO4suLCXidxFckCDLEuqRlfhZP1K7JhhpKlScVqc5Jok+g+iDBlIdU/Bxi+zWEN9aA3T3Eul0k00tSiSLoJeDjdozYTYimR8VbK85ELEGgbG1TGJoxlvfwZ7soYm8l2TD0QmNFiGJS3F6C1M29A3jluFFoncsjuHoH3qNFUSWmVYlUa60YFPuAgk6AqVfKuP7fFwXYUVxj6/15AWsLH99A+8gUQj+BzsqUAJPWlKF3sbp57YeXcObfbEsGlbRN7atl0pMeiNw+FyjcrkyI4klqgOKRT1Sw/Z48lq91sPPhY3KuuTsdHJ5OiHUNacPMbh+8d1Eyt/XFQKq4sniwisasfDZnA5NUiEEEqs790joaZ+ew9wj7QgfZfh57rEG12wYOHkhHdGChO0dKyOb9VfZH3vKw9T4j3EMKVKLMiXVwrTjxzl6kMFQgYkTJA19AOftXuZgl6OSYcEI2lFirEGoXPPGKJ1XWg/NAe8ZUFoqvxEB/dIIyKpLWjwTI3WZWm0B7sCAon05h/2Fjer/4xTbufH0KzRXSgc2ijqJBXICvfbPpFZ6+3JfECYOJhuw10++HRAL9XBIHjxSNh+tUDt3pjNjh8Dwzmx1kbh+im5yV3tC9RzOygOLimYtbVlH9Vld6Yf0EVaetEvSdFvy1bYQd8uJ78Odn0T5hEhC0cpL+USYORNXaVMzZ10fxpX46jvZ0QhZczMCzCi2VAnuNuFibvlST/inSnmsr5Il7qH1owVAtV3tiQF8+EpdrRPp2g9T7MxX01rJC5WTyhdvqFEKkFus4M7eLV1aXEXZ9ZI5V8PjSOl7YXEFzO4OFk/vYRQ6pi2m5r6Wyo0qh9m+TQjEqvjKJ+yuiypmz6GVySyj1FiSSCSCvW5CSqg+8LQ++4cRQj6yGgBD+mYilmnmNLQrRPpVerPsdoRvrw4ZgjNVMYeOorU77bpslv9lBil8HBlVGvq/2eaKtD26w31/O76QBrfNf6qJ0OobSqSBSrm3ZKubme80G2Vah4L6+Ys6TLQtyrHa7WnGlwmzxmhFo0DaBmnUcYbVa3quKx5aCSiuwjgot2f7QwPrdNudChAstI85fSogS8PQrw3xb6jfIOAa0lRuvyqsh+gJsQdiKi3hWrxyLFpXtaWvdokrEFGpbGP4bTu2YCmljcdCHK3RqB7SSnRFsx9HL9YWRoYBTQ4Gp+Prm7A23bgYloj0HViBspSfPEhV/I7BmtfEuMTAnCA7FCubhvOgPyObs8ZXO2GqnFXAarSJTmIr3GnuFk7seDs7T49v8TrQgOBceT2P6M+uSXNYoPzwrFnb019Zxlu13DeOJa6FxTJT1D7Ktxwp62KAo1uHJIDrH4k1zkPUl66vbDbHzXs3U8ML5SM6bg2TVNTNfQz417BVa7SXQdCkHAH7x1Q+ZY71oMybHzSDFNhPY3FxGYEW6wrx5ncryX00x6Xl9e2MCXifxFQlWXMVGpcg+OdNjyaqb3zKvd9Omp4X0T/aMJneaYgdCepdXa6H9/gfFp1Sok5cP0DxWRM9nj6ahcvFzfVaTOH9akCw0onC4R1KqlVKGNf0n8jj17HtpW8ksaYcLMXqs9pFhL0qvj4MPn0DxtQqCO3von1yW/kF+jiCcdNHy2Zzx4SxSpZC9i2mc/eV17H79stid8HWKB8UfmJfz4/kenknJpMjqJum8YdwCqUfmxB6hPcWKmOnH5cRFkD/3UhfbT5k+VKk45ihUFOLIJ6ropdl/2kb9/JyA3rkXGlj/ujTmX+wK9VgmYPYiTnvorgSG8jtlKic8Z9L3Iv/b7AC0rX/3itCOj/6bq+icP4LD0ymhooqtynYPifVDpBaTAhCp5NmcjqG5DMy+bAAz1Y/j1YRkxFnFICDiteB+Giu83mYRI32X+x0B6+y/pUqvmNBbqx8u3nheBsCa/l7Op8YWwsPyZzpY/RbjycuxJp3MAHJPqLnlk2ZRUj7bR3bVR2vaQ+IwlGq09Jrx/Qfs20rIPTP7rOl/JY2LYI+Al+PkNw3ti/ctLUIoPtV6fFaAmNy/nRCzn9tG49Q0tt8/K0kJVkFZ/Y2X2+jlUpJ4kWpzMADu0st0MiE9dbT38XuGWRBrcBEXQ0DgSmGOQh6dY7Om6p41NkNyj/eMHy17rLlwUVP6g4cyUkViVSi1a4Aurz2phTOv9lGf97H2TTnJ1leXA8y9WBeBp+rxLGZeqiLYKWHju46hvmwW4AIuDjz0a3l4afrSGpp3a7mL7EIN/b6HV+8smUVnw0crFcfzG0fQqKSQ2ghQvz6P5Ru0AbIeztZ+iAJnUuWn3dAMcOnnfmLytL6PQxfWDAWtrkc3Q/UFSK1sTpnFugKCg8fVv8Q8e6TNQKnA6iu6O6gwuiJKsg/1CY1UXAdUYhV7Ek6l+a3ZRj4ubRmMqVdt/+uutYzZbqE5O0Br5TOe9GpSQXzl070hIR0+Q5nAI7hUrSArvBop9DaXu8jcYvLM+Hr66iXqVOZSt8yxNBd7cvydYh97jypleBi0RT3+LeDw/AhVON+/C0RFyZ+OP9QTqsFnItsf+PxgYpVBFXk3VOApvelH+9Lqrntc5oD5QOKk6CGxH0RVQBmTJhk9A29Z0oojenhseDsRAKXIG1sN6maMgiC0qtAeOucaklDrWVVcPYTWiTZCe77pO7Eh4SdpR6jHZIwZ9KB2g3OVJixU7KtobWrKx2wV2TdzihvrH4qZsfFCuV9Ge3E552pbEz+rIFaO7ZjZYe6mUeLaf0hNY+1x2HUMq6acH+RYHrBJAgXuNrwds2FJULxsDoJiatJvG/MkKUKveirgI2uzOnVzXoV0E/X2cKbigwvX8VL9GH7tuffI/y+cNt5V7V6A36w/KolIuV52fP1Ds63ucguz8wN55nLVoO7L/72x15rEJP40MQGvk/iKBOmvAsBaRjiG/Z6s/pGmyiqT+HVmCBJ8qTj57HPMBmgspuB3CwL42K+UuLyOxqNHBSgRPOVvd4TmWjmREKorq4Hzz1VRupAzIMn2wNK2gEBA6MI6WRoNKPm/mJ5TBKprX4+bftbDB4uIH8th6qUDESShmBTpofnLtEfJYuFjdxDmDI2ZizT0DcA5OJfATH8WubWOiC7F6waIJnebUmE2/qq+0D65AGKSsko/2pihBxeSScnEkmrnhTE5Fk5ApI8uf7qNnccT0eRP8ZDD07T2MarEFHdiT+edb0rLpJq9coBWYU7oxZLltvRp0pwJDglICCQJhsXih/2SCS7uqB5r+lspfNT9nrPGQofWPqU+sjfKaBzLY/PDS7JN7pOTPK9B7kXjgcpHTm05IdeWIJWLPk7iHGcu5ljp5IJMexwPLqQEUHOyJxCUhUrWCEXx/DM7fSuiYXueSQFPEJyGoog89yJ78oylDUU49h71RbGT7yEVlTTEmRdNEoRVX77Oc+cxsMLLY2CvG4936kpTEgjxum/7coHp610Bq9nfewmNb3kE5eNm4SL91taLlgA7M50R/1cuHkipjtWsAFQ7hvpSAk0C4bbtXQsGitdcPFEtmskBZsiTJVtlCDz0zx5DYyWN7M0KYodN4PYGwm9/UCqsSsFPlun5a3pUc2stoT5TQbp4JSb9WKz88G+NLN3EvkkS8L7nPcDxnH2liVipgdrpovQ67z6ZR+jnRVma9xep35VH24ivJ9CZ7SJzO4baQ22k8i3kYz3UqknEbqax+BIr+z5Kj3SBtTSCTQ/Jgq06VSlAY46ZSR2lJIqKNv8QxP9nWOhnEvdP0C9VK05GpXxQDQysOmu6QvBk36P9fjaUsVC4Ze5PRp+iffy8XY8XL5nS5M5TzmLe7jNhhWv4dyaVWklGDluvyH3kRPUEn73A7sMJFFbNhtozVnBpu4WgZh+mFrxKe8Ud3ptmO6QEq4fySAEqCvWkLl4xwnXxSgzt6YHXK0NFlvg3x2cvnwG9DJC5E0SVNQVXCrh5LlQAZrIpY6uvxdfUI9SeH4Eid8X+yFQPYbwv3smyleYwCC490BdVWfbIKyAaDT1vPqeZCGBLRpi0f6cVWx20Y86/ab6PFN/RSmR3ylaCN2NDatAyB4+o8Or1NWyS4Q1lbyjN11bzdlVueuAX2zvSlBFTEKXBBKxsPmaSduktw9zhgOXuKP3bbE/maIf+zl5YPr/5XOX95teMQB2DCWHax+k4KEU7Ovcsk7LmWpMJI8dgL0XlXYbDG43XTOJuWj7XRAX+X3uvB9svrNjSPbdVTiNYTzr3vxcpgGswuTvquyz3S9oseHa2i/i2h1+Rl89nzU36G3eM/5Bvr7fG6rNHRSHbxejZM6bXdTprslkd2w/PSm56uoNPffif4Kstemxbs734b+U+JmFiAl4n8RWJ/I2qeJG1rIdpotKRxT3FgrhwF2Cy2RFA2inEpA+RPY0C/voUj+ggtlNB/YljyFw/QHu5gG4qQCcfoF0MMPtcCV6ZikJVIJ+Ddz4nYhfcLpVdhR4rQhdGUl6raIY2YyYKyYaz7zNmK7YEtAR0hQA4VRCwRtqwCk8k7pSAfg9es2OUZDOcvA14o/DO7qNJyW5LRSzP8+uiXUwI2GY1lsHzTO+00cmzsuZH6rym2spMtbEcoEonqUOlM+zJoQhSTwQjKOxB8KV9sB0VFZEEADD/XAdXfmQOZ/59GQcPF6JjI1gUoGoBq/S7ss+MCzDPCFlwYcTtc4FjxFgMZXdQ3YghoPy+Z6p5BLgi6nTcQ2/TQ20pIYta0nM1YdCeNn2zfJ1aLmn2mlmKMoNepVwksmdWFJ9Z5WM1mOCXFblpA7YIbkmdZhWANjNcILOSx0VW9jY9+3oonaFqrRE74bFRfZg+taQb0/KG15rVAS4O2/M9JMrmPHjNOU4E0uI1e6eP6TttAZW89vkbdXhnjsvCRXtMOW5idyQVjQ5qRzORsFR2nerDVdTOTWHvkZTttTYgjlVkEQZTthsXqTMechv0om3LPQ76Bvuk3fvIrFbF6ia2WULt6y9I8idSQBZVYQLSwNDDL6TNudRCsbUJA/ZT+dL3y+sYaxrqAenE7LVKb5se7e0PGgobF3iihMxkyJ5RYCaduHI0IfdGJx7i+37gj/HxrXNYW5tFsxaTxROvy+YHrO/lRgzZNSvgVRoob5bP9OHNtdBvBQj247IYYn+y+HeGPq7+9Z98259Rk3hzwntcW5fFamMg0MTrygTh2LD3tnq9KruG7JbMDUMdThyavkkVodG+1NmLdaHWy2Zs1ZKaAkLHpNewbbdUMaRol1oBlsSkSQpq5fbgnHmABU0DGBa/OLD/yN4yFaOgZTZ8cCEuoFEs2BRfaEHTKsJqMDlI1oPs33qUqvhO1F9aMM82filY04KXVq9dyxKpGobmb8dVG1ZvUtnHkVCsTqJKdNvSQ+13JuyCmi/f2VrBVg+yTBhMFMp5mxZGI+o3Z1ow2GbhXj8BxjoETJb1PcQqtkpsC22tOZtEYKJroW9VgoHO1ABMkRrtgjQ+f8kKESCnzCgb858zIIiJ1sbZAbfYswCV1er8DXue26lhT90l81wk84XzWTTHMyxobxcsKJ6yPb4DkVwzJ9GOx/Y763FltgfXkslGCiu6PrDyXvp1U4n9cCCWJOeaHADLFtcVtjrK2HvYgH/Oj7QmcoWneD24L/phe/TL/vyAtcCzVitAN1RtuTlvfqlK3UygJL6UjNSLW9858HJl/NKrH4T/vFNen+sjfujj5h+fMMki7m/F3EDZjMnYPDi3jdf251Fu2oRQvIOQrhAWxE5iEl9uTMDrJN72+PA3/CM0TlLJtS8CMqy8topxqeoJDWejAa/fR/lcHvmbRBuGgeR3YwLq8q/si9IvAh+Z524JdTLR66N3ZlZACy1FSo9MYfoThwgXZtE8VhCrGgI/lbqffqWC8rmcVGe5/Ui1Uhc5ttdKKJjtwWKEkyPBNkFm+ZtmBIgVL1WNOE+nA2RoeFlDfLeKRLuH1FYKW+8vGupxyoBIWvvwPOmpyQWcetISkHEshCa910asGqCVTwrw4AKPn2XGNGPpaayoZbdIy/VRORoIEOciQSxNuHhs9IVuquex8skGeslAqpu3v7MolUj2NBKMsSeNlDweJ6X4lf6n6ssEJwSRBIecxFnRNcdkK3dzgVilxOodZLbYN8vFji+/50KLgFqOqWksKqRawaz2vkkgzFxqo3ycfrRmMcr7oj7HyqRZYIgljrWkYQ+bgGe7Pbk/xBqGE7FJDEjVeTPEsf+6h/ZSHu0ikwhmIaaLTF7zhS+GSBx2kb55iMaJIlozMaFxpekSs2Sqx7ynavSK3QzlenP79OVN7ZpECq997cyU7J/Hkd3sijIlxT54HqQd0/KmvkDque29OmNWidLznTHfWcXmuBVutyWRw2tB8Mht9VIUkeoj0aT4l7lJe0xkxJOibrz/4IoR9zjsSdWK48SqtvQPk9psgTRfqC96Qrkmbax6xNyTTIyoqjJpk0wcMWnE6yriWjOefBEccDFFixFW/VvFmCyiSM9jb9Nv/vLX4/BdbeReSUgVmfcdrTqo7un3zHWtLRirDum/o0BLipLNPWAvCd9SPbmwIsig+FNYGFFtmcR9E0wCumHYEUA7PgA2pqpl/DIZvaT5TP5aDcGmVSEOlB9s79OZgegPmQ3dEzlhKzCoLcBgwi95YF7L3fGHelA1xBZNeihNpckFhJ28BVYN8xkClZnX6JUdg9/Q5lh7Docd6ePns0qrphqqqMt7l/R22Za9ZSlyx2BSzo0E2x9G6KRRb6gFUlFCqzpQzlXAQSaQhqjmnjR/z6bP3VZhpzx0SR+2oFU+3/HkS5JCUm1WcG3HoG4ozazC5tZ6ogQfxgzgEKu5WAjP+s+yj5OfYyU25N8wX+sFiFXNc0LOpWxAL790HyqwpL2q7ZU2/FJ8aAxa8+a6JretkrW9LWj/poJSGsGO+ezsS/aSdUwLkoY+X2mZI2woYtWjwyBbbdiYQOnQXo3MH3sOtIBj7DzpRz3bckw9JkXJIPMjQOuCXdk+K7Ml7ZMdRpNkW/H3vnVXUNEn9kszqcvgvevaDKlyts4jtL1jKJWe9xnvBTMO9vhvGYeAprVb0uugwX0YQGsB+vUC+jMd/F7poejeUZ9tnl/stkkYNx4cnCzf9cQxI7xWbiex3xo05M5mDCr+6ZO/I98/cspUdCcxiS8nJuB1Em97UK2UC19WIKXqemiosKwysueQtNpeNoGpT6+ifXZRsqEEYrmXbYqT1VRO0DGufInMQqBcQfrVNlLPVNF99JRYr4SFHLxyFX4vj2BtF71zS+hkjcpxcqONzEYblRNJdEXoyRq+sz+yYwALFwWcoFT2nr1MpveTIJO9fX3jZXo0g+xtWnuEokCMTAL+fhXtk7Oyvdwd2sBQ5dBYwFCtlhMlxYxYQS2dofea2RcnQlbIqEqYKPcw+3INlZNpmXT5eeySpmbou6Y6aSai4o2uAIMW7VBo0+MB5eOBVBy7NfYnhdh/KC0qveJ92iTNiRVX9tcaFWOCExHfqJjJkOfMbCzB68IXu0KJlR7ZOSPmQVrU4jNVbD+Vk/fHG1lk11tI7XVweIZ8bCAgzcxWryXjXTYLMi5AWJ3k2BIM0jOPE299gVYDxs6ncqGDmefiKNxW6xfbm2x9XLkAJNCk76lmyutx0zvaXO4hez1A61toVshJnZ69g55KXVxmNtsI6h0cPDkrFdnc7QYOLmRExCi/2hFQW35kRhbQUu2lwu6u8crt52kN1AeW80Y5u86seh+5F7eAWICDC0uiEjn/Qhf7F2L2913xRTViHFSLNiqpBIOkWOuiJFGiNVIo+xVwXumgXYwjVusitltB++iUKPVSOZKgl+fWnGMfmfb4moTD0ufbSOw3RQSJ3qy8RwjMed7NuYTcH1zo8T7mQiq1Z+5p+hAT5LKizYoBx5Y2IMGGobqRIsdFfvlcH6ktIGPtcAi+8y9TEMz4LXPMuOD0O8Zah5RI6bkiFT3bR2KugXYtIdS+oG7AM2mS3kILc9MVnJnaxb95+pcmT+n7NJhocgWZNPj8UW9MDTJiGHzWJSo9NJfTyB7YMmPL/kFalev4jW10j8/LfZ/ctmD1qCmVMrHHZ36ebB2xAnF3bDcjiZ/hX7nAg8F7W0P8SZNA5ZhWkHWhz/aD8bxgpegyockEHe/vqOKm4lEOQGVFLXGFzypbaUwPC065kML0BlNgaBjwKA1afJHt8ZOl4AJ3Ph9HhZUUsGhlXKi4I32xGQuM2COpB6HHyLFkcrNhFWoNu8QXcGreYGza3FB6a1QxtJRePdPIo7dkEnVufyufE7KN8w30rEBT/kXrNWq3KypxtlJL0SmCPJM88KJkAXUVGMylGDu7wSjre9R+SOm/BI96mIufN/fe9pMJeQ6qP67SvZMH1v5n2dwj4nFr74FojtmyvrjTFoi7w841g3NMnIPdvlxqP8j2bZWblGW2BUli0t638oxmhXzWMJX6p0zm2b9sBnH/m5voH5gDn7pk7j3tP+bn3Puqb/dLD9Z+k+X0waHWj5o/qMS8qbJ+6Kixxnlp1ygKv7y5hA4/YyOW7OGbT16WnzcaRfyvd74Zf/3IH+KrNXhZ32rn2okz7iAm4HUSb3uQbtstsIc1jqnPrqF5YQlBo4ep7SZac0nxTctc3kP56WPI3ahIL2g/6aPy+CLilR5SF7ky7yDsNuEFAcKQwNFDWK2JR2X86ob8HjNTomRJWqdURAkkn11F99i8KL7GSk3EZ+Oy/Rgf3mxRjZsMs/Rh0tNV11SkDKfs/8Uf1niZCuWTWc3lLJI7PoKtEhoXFhHLJqTyRsELAjYCI04EajcgtjLzFE3oIVmOSSWSwIUZb4I8v2sk7bMbBIk9AfvNubjQh6WPMuYhu9EVyyGxeSHliOI9XVKqrJAQ1Y4XTCY5USWwCaV38sgnWkKB5T6pZiiUMTspG29aAzKVvsrvpMSygsJtE9ByLLhI2no6J8CJVVkeG5bpB+pLXyUz9wcPJJDZNcCY4kd8+vL92TtmuwTwBPSsArPfkj54BLP03s1diQs9LHVgFkZcIIrXaQIg+4hJgMyWAUzsS+LkzR45oVqtUUmXHngdlM7FcXjGN9StqgHR/Dm/avplDx7KyTFwYbDzRCbywW3Msz93VqrbrBZQ0CnWYnUlJt64yZ26UN/ZB8teKLmmcz66X7+C6ZfLZhzJJA+AhecooR0isV1FetVH5cK0HCuveb9lqbo1q7ZdacNLxRC0eugnUwISk7stJEptUR4O0wlJRtAjNnkQx9Z7kybRQsGchqmy8rxYaS+fSoHrkcZCXI5DfW17yaTcu6yOC6jk9fco5gSEua70NXExy75fY81jrhODwmVS2QjZB+2jfMr47fJL+8RJ8WaVntuW+7UQop+hB1WIkH9X5Rhy1wL01nMA6X92cdZa7CIotkWUZaM6g83tIvD05CF9v0d6z6rjVnuiUyBAQauvFmvwvjH9rVReHUGSGj0mI61/6A2LENKWeuh58PdMb193eVj6l/3cjHYhFVWhFJxqv6sqDGs1Vqr7xBX2uex+hiBWqcdMSLn+s1FwHkiGQ7YvKs5Eexk5nulQfuYzhwJ+DAXVCmK0N57PnajP1bI0xe84OygXB7dTkvTj3zL/Nhl8Jpu+WNMGwIi6ZLVSa4FjN2kqoBwTrWYaTQcqr9t91H0DxtMDyxr1P9U+Swo3se9WhIfs+QwAqPme2jO6ABrdQojMmjk+jocrZqQWSGbb7BsxNOdwMyVzoJzTyGqVdFnSVxl6zfVeU/qzMFuyJlmqFe39pwyY7KbNBmlFw+dmyyZXGstMqJtK7Ob7DGAuXg9HqO59xKp2O7kYZi+ZBCX3oefPfVMnQYP0bN5TfDZzDmOVlxoX5vpQ1LGLTiYu4659uawaz1wyV/PwtC/iSmpzxAq6Xq/MgwdCF5b7oZ7E/+GBF4EHgM9umzJs5Qs26wCnQntiuJ92/v2GKz6fNoj2Qt40VP/axSfRfLiD95xYRUqb0G08v2VuGmobuOGvpuUe/J3qI0gXBmPwkQ9Nqq6T+LOJCXidxNsercUsWlMxJEtdtE8toJ/wZSIgmGVWnQv01tEpZDaaaM+mRZE1rHqIHdSAfSIYuwhgtpcVWAGGNstrrUO8HGVKfUz9N/uwjMWQKB0CU0UByKSghVMpFJ7bxN7XrwwEf2ymmNVCmfhYpbSVPp2kuZCnSJEAjQb7dUmfDJDY81F/cEmqZQTb6a2WKK9yYjo8lRT6EPsX+fzndrm9rfekjLDOoaH2EBCKqi5Fq7jozwcyDrWjdgG3b4CDqNsmCAjZK8bJkNlY2gVZiwq2X+YNwCTFV8Bs11TDaitJsdJhnycpwjkCKC402YtUMIsZVjX1fDn5S1U4owsX87rQZGsDmx5SBg3gJ/AL5PhYIeB+2cMkvVNVK8bESZP+ePOm6k3xIo4zj9PQrMzCh6CYVUoBqtvGRojbNECf/b2mx1NEhnhrqMDLi22hFbLvuHbEqCRr1WHuUw1ZOJRPEATGcHDBKBXn1jmmVHBum8Wrb3qL4+UOPNoFWSout8PjrR/LSQWS1VXX2oEgr3I6j9xGVxbpsesb6J1YRLBbARJxSZxk1+roJbNmsZ/ykb3TERDMJA4XuaS++fU24mVaHPiiLsz+VS8Tk97h/C2T/Y6XGph5lT65RiGZ9wErXlSrZIKIi8Pq0bjQzXk/R4tJzxOhFsR78BsB5i7sIptoodFJoPTZBbkHc+s9JCpdNOa4kDdVtupyDO1sINXtw/M9IN9FMttGcz8Nr8Wea9535Hb7SM410G1ZAR72sqa7UkUJ9hJyP3AbXERNXY0he6cpFWlWvNtTMSQo4NUBLv7PP/VWPYYm8WcQAwsckzBhwo3PQ4a2aORWm4iv7g8J00TRVcNLqrVbcGjBqz7n0WhSWhb+NpukrVLuulFLCqZN1SdodNBYzsg9yyq/C2iURqtVJJc+HKnzUhCOPbNJ04rAv2Gt1GrSZvqKrbK1+5KUk/M5bStk+7YKaP1URa1d2CtUUx8P7uT9tqir9il8but72tN9AYih/Zv19pjwDZFSym/ePpsF6N1Nl45Uht0qsBVtkn0rF5SquGWjpE4QKTRgO/b6XFPVaFYVWXEWdWCLSRTg6viSItwrmA+oX7OKR2lygM9Q9Z7VkGowX7MHzPYW0XuYGgBo6SltmXmSO4yq6XbfnAe6heH6VC9njiWzaQY7dhDD9CXT90mrOVdpqPy0OamwkjIigs5zvXDV2sdUzLO3cXxYCZjzUuFWZ+je12DbCpPL1BZgMlATF2SVpQ6YGSfLJkBhtYv98xZUl+wcPefj4FGeg0MlSPcQ2kRHtwBMZcwxPVA07LTP7ZzA7qfN34aMnU1S8H6rnTDj/nPf+Wvy/d9tvFe+f9ei5V3buN2axcPpNfzcu9fwW7tPYFwEQR8nigeAzSW99gdnhA7OpMt/96EvyGu/c+NBfC1ED6F8vdX7mISJCXidxNsefGDH6+x3ZfqYYjKkKvoI4z7aMTabxo1wx34JsUTC0IPrdbQfOIoEFzL8UooZq41afaVCpaaTa0yltuElLX8qDBEuzRkxpS+tAU0q6vhAIS8ZTy7+E1V6isaMV2jX9LhKBVKVM1k8E3CoSn0eOgQUkvQOUbpARVlT9SQYTRy0ZeFEWtD0pbr4ZjZnjDeqqBgecvs0Qjd0SQnP9mVmeDzsP+yhPZWIgLVZVFml5ISxBmLFjgCRvaQUm2ISW2xXrOiSVomF3lbrR9L8PC+K5xB0iuhj26MWkO39sf59pA2zMGb/z+PkZ6R6uhWifNzQTc0CzVTfhG7c5ALIKPSyd7Ix40s/Ko+Xx8Rqr/bHyeKQ5z1raFOiOrxvxoeULgJhigPR71WEVmQxY7LlKk4l1FqKHZE2nCI4DoT+SrC58IW+LIJIYeVidfcxevaaBRUXGcuf60kFev9BVq+B1W9OiLz/8u/EUTobQ3MuJtVmqqpS7ZnbJsWd+yufMgs+9lvxGlSO+CKexQQDBZW8TgKxQl4q8oibnuv4dgXYPcD0XhHlx+aRvV2X96a2egJS2efK5ERryfSFNxaNSFd6u4tYu4+Zz22iX0ijfL4g9wLVUcMgicx6A71UTPpjd95dFFAt1zlh+5aTphLMCk/p0a7pMw099Hxg99IcalseZi71kJvleZr+1G7GKEPXloHGsT5i+ToeWtnEQSuNpXgbt/enMZOrY6fv4chMCc1uHJl4G7V2EpubU0I/CxI9hJUkwkMKsnki1sIqTL9l+tdiNR+VI2lUHuzAo7BHK0BhoYpqeYQSOon7LpjA08qk0kNVTVhVhN3Iv2gW12HGPoS6vAe1BGi/W6VhJiGHQCyDyUm+dcYgwtRmDf6+4WnmNo0sbDZvykmr323VjNwqp2IpPbTX0Y9hdZDB5yfVyxu0q5Ld83lkjqNyerhxlUkZsfOior2t9IkirgfUjtoxuDFQetXjIitGPt8wDBYKomnfY1gxbw6nDZLqVpLSlyrvt1Nh1QJc+oPLMRcJmGw/6z24hhRPYtWOQbBhdnL3+zTpxb51eS91IpxgAkpFrLQS7YJkpb9KUjg26DWO9CXsZ7RvlokvTuPNxT5iFVtJToRozhvQLMfeG7mOZOZYum7PVmN1/BS8ls+ECI7XBKs29oZ9lpRmHVs1oJXPzJi2PZPNRD/1jBnk9J5BjdSL4P0n+5rLYOpaG9WV+BCdnqJ+5r10EzCJRWUkFKyCNvU9JObM9mcvmf/WFgNhyrihFWrO5XJsKXuQpDYf5uXLs+JK+knehxwnJqo//OHnhrb3QHIT/+Dkb+JHX/wh/GL5Q/gfzn1KXr/CNwP417c/hJuXBiA4c6SChxdMRfZHlj+Jv7AA/OKdb5T/7zUzmPvgBtKx4ers95wxoPh/fuw/Dr0+iUl8OeGF4UR7+WstyuUyisUiDg8PUSg45mtvU7zv//RPkdkywI6LeVEXTrAX1HhUFq81EVRb8O/sGNDJSmoqZfqiKB7B19odA1b5fy6AYgFCCiaxCqvAlhS0wDfg1i6EvKmiAb/8P/dPgFvMI6xU4U1PCSXz8OFpWYBxkhEAqPYLhvEWgSWdOBMCmmyPF/FjzhcQRiEk9s+KkmYmEOpv9vk7qLznqLEGotetXeCRXpnZ6YlADvcrvTvsGytZcZwGhZwIZONoTgco3GiKEme81kVrOi5jJ5XTrPXGbFl1YJs9JiWWPVfcr/REWuEK7ouUZr4uir9cgMQt/Vay42byZg8jF6OkY7FKQGBPahsXapULXRQu0fIlRPEqBT8MeGOllgIn0y/si78pqwSFm6w0Gop26ZxvqrZUDZ41AJkgceaSSSYwqXBwPi4ZbQJSnpcs+tjuXDP9RyLu07PG7aRw53j/GDrw9ntCzH/R2uckPVF55AKUlSHukxlvVjHlvqA10Yon1Vf2aCowrj1dR096f0LMfSIhWXOeG7eliziOD0ErQSF7WIVOyORCnFVFCsAEyK41op5T+gNT5Km1UkSs1kZrPo1YRcsyHOO43CtU0e7M5yQJkNiqyH3bW99CsDgf/R0gkUDz1Iz05lWPJuTY0/vso+L1MXRF9cbkAq2XYKLDVK9lMRnw2g48HnldSe8meObnee8cvK+NI8v7eHz2Dq5V5rBWmkI22Ubro/S0BWoPtpHKtdBezaGf7BslUx+YfdEkKEh3q53qIjtXk8+dnd7Fa/sL2L89FdHfwkSIYKqFftdHSNGmdoBbP/pT76jn2lcivpLn/O4f/afyXcGrtEaIII9ZUB+cS2H6skFXiTXrN8JnNIPPcgWlunhX0KrBZ7QuT7R6qiGJSvtaSrNxFkRTd0C8TtM4PG+ArPYIap+q28un1FWtsjFhqaFiO9kNc9xMJilVVDZDhkRPARuGqm7xUgsHDxuQtP+I+V3+pje0XVKR3cSlHLcFUkrpVP9u2b/FKhRNMzuzw5obiA42FxVkWqDTHwY+iQOTpHPPmb6yLijSHkjzHm9oe2oBw2exKhDrPlK75ne1E7Y/ci+QarEZl2HBoF7eVmebRvnYHUMqF8v2tszFkQqkTcZFqrgWnEb+sPFBLypDGDG2MqvHp9dWVYbJBKI3uRyf7bfefcwyu1wg7/w891I/StDoPKrXjok+/axW7LXyPnXF7KfwrBE24vO888CxaLtk2Ow9Yr1ZT5ntrjxiTqjdNffb9q0ZBI4/b7jShL9mknzaw1y4bP6O9J5pLPWwdMYwFZ6YWzNjbk/uD26el+9kzjBOnzb7IwOnbxc429cMhSFkspOg9elPY48S/Ta+vngJP/vinzfX5JYBzqmTzh8RgFf+u3+Ar9ZnuR7ri68sIO8Ihb0VUan08dhD2++IcXmrY1J5ncTbGt/wnf8EyYAVMNpgtNGeSiK9Vhaho8xqD/6WXeRwcc5KVSEHbGzLYkeqq6oKHI8ZQNqxFdduT2jEJG6o6IcXi8lnBPyyesvFzWFFrHNQq8nix+P2O114SfLFAqnM5m/U0J42E0JirynellKdJKCNDXqk1FKG2NnQan2xvSHAya+2EFQ76BFgHjRMFa7dRVjMIv/yLkAKM6vK/T7CVgvezLSITnnvOYXMa7vY/sYlA459oDHDyShArGkq1kLLXTCTHL1v2X+TLFN1mFYw9FM1FGQeKCd0AhQB4azAWml+0vtIO+NiiHRcglQu7NRjlT+z2kCrFp5nfcFULVlt5TgITdgqMs5+IYbCrTYS5YTQkb0e7YrsGHkedt43K9Vkbo9+owRIcokpGN3S6o0RzGDldPspWqwYuqsZV+svyCQCgbcFs0pbI4hVdWijTuwJrfj8/17G6kemZOHDnrzK8UAAsFHSDIXKTVBfPuVh+TMdBC0qNnfhd2JC76J4WPa/pJBdaxp7prVVdE7MIx2j6mRPrJq4uN5/36JUn6WvzTeJB4J9ntvhmTjyaz3Uj6SN1U06If3R3WROqL2tubQkXHg9CX75eUMlpILlAmZebSJxbQvhYVnuEz+bAZIJ9Kdz4ktJgS9W4HnOVNDkcZDh5S03cGSuhMqvr5jKfNtQ8FqsbDuJ8QGVsY+gRa/lUOw8pGfMC01VJAT2/3gJf9RbQmOlj8SBj+4a0CtYlcqWj85ODr2iMbgl7Zl9frTxqD7cwdJyCalegE43wH45iy/W02jX48isBaI4TNsH8RcuZXDwcCiLY13wTuL+jaiyeneBVfq2559rwy8bOmP7qEEakoThM5jAVSuro6CVQdDqVlwV4DL4On8/CmhteBWjcRAr1VGwtinTF82NXj+SQW3JLHvqWlDSwq9dDfEZwWcbQ0EKleEZxWsGDZFVE9u2C3Srxivn5Y7PESrMIeqrdHsx+fcaiScp/lFqbs0mFu34qg+3vNfuim0t+n8F5FFVeWT9LAr+O9YOyJ4X+zrl/w69ld6yDP5NqkKzjIel4ZKuy+cv+12zq1ZAyPb2auWYgJHjl9gN0D7SQXulj/zL5uCrFpCxiirn27c05UwPnoo51YY9YxtLfSRKvtjcjApuKYAnEG0u6f1hz7Nl7IOUlq29xAyZ45iApYBfkp6nqqZsx5Zzpu2TZiXdXL/B5ym0R+V5Jjt58+uahN6vcjz2umkSYuZV8wYyzJLrZYT5DA4fMTxbChwy9h4xO+d5nv7ALSi5vtZJ4F9d+Dfy8/f/v38SrM02HjMXcXbalPYrl9Pija09sDJ+tuJaYWsHj7lh1gt/aMFqPtPEwSVtFOYLPXzkiZflx89vHTdj/5zlAltFanPNPPzvn/0Q/txTz8v/P715Sr7C5y2Qsj7G7deK8M/ewzR4EpP4M4gJeJ3E2xqsQiUPu4gdNsW3L/28UawLahmhBgtFWLLnGXiHFXilMlDMA9W6qaASaHKx0w9NzysXDgSABLb8vyjlmd9H1VZ+rms/xyBw1T5Z0otlAdGHV/VFzKm5mELu87fQPrcMv93F1JWW9OXSy5BZXgHeTfPdqBJ7kQw+qaPSfzqbgE96NO0dPA/t2Yy8L33zAOHevqkAVy2A5jkTnPR6yHzuGnpnVgQAM7iIIKAg2BSPTfY2SvXXCOhwvwQvrCYqrZcglZM3J2aRtmcBg5W4jKk+EmRz+zwe6YFdNpY2mQ0DwNhXRGVFUpo5sU9d6aCxEBOxiMOCUXI0ljeGMla82cb6BxNCSZ17pYvN98bk89z24fubKHwhhdlXelKBnnmujM5sFgfnU5j/fAn1Ezkk99tY/7qMVCVJI+WipHCri+oRCiZZL1CrkMyFslYkCJwJVvm6iGexQNqjEq4nX71EQYArhaY4VjOvdmSMWtMx+T2pZ7x+tI2pL7IHu4/6IqueRtiKNkqk8JU/kLFq0McF7HbSnpxzbWUe9UVTreS2ZDFmVS0JnoX+d2gqtYXrDXSzRr2RVW6xSjqTl+NixZ3er7WVFPyQ4kch0ptNBLU2vDvbCJdmgZmCsSCezQjFnj3VpdPW+L0N1I4AmUf28cDsDv7y0h+LsuNapYjitbYoB5MF1jjVQXamjvyvUe6a/YmkwrGv2AgyZamKGVLIw6g999jPuhFHJ4yhfqKL9FoMs8+byn5+vYuTf+USLpfmsXVpHv3FFuIbSRGCIS3SMAlC9C8n0PvEPDrTnlTFe0d68Mo+Tn2sg91HaFllepa5YKe6MRetrP5c/amfeFufS5P48iOzZkpiIqpkq6CaSExctSWx1wGd0e8Zo+9xgexoqFKxSyKzrSXxbS1NWoRxxD48HCAXVV7JNMnYVosBG3Mo2JetwkHBMZvgLJt5JtYwVafEa+syJwWrWyhYn9pueoCe+IwVBfuRfShAldYKp/d1aBjs/5sL5hkt+7VUYbU7GZwfWTUDdWKG9o+mrQgSqbXsfSUbQ6uT/hHz5u5+asCMKHak4zJ1zYCgzI4VsbLKybL/WTOfGPEoINg3J+GeZ5iwvysHohbM5Kgcx1F7DflfSx/2EtYG6ZS5rxqfM2CLc4+C9+op+1576tKHz01sB5KgFPXyrNE0YAKVz6DWnL1elSCq4soxtQa2R5EI1aiuWJ8JXLPPpFUC1iIkn1+M6deoFTDoT2WCMb1l7sf1Dxsqe+vrTKLj4MW8pVGH6C8N7+wvH/m0fP/Oj/8N88IZ23PNw+j52NktGHr2yTb8uB2rL6Sj6xo+VJVeV410kjdPB997/AX5/0fjD8n3I1lzI338xjnEX3AUtpgUjhkfXu+8AaJte0/81meeNNcz10XxuYTqPUrbEMeQAmDppFUJb41IX3+VxkRt+O2NCXidxNsanJjDGPvycvA6IbxTyyJM423tDdHKvO0905PKBUmvZ8AlAgNAuSBScGp7XRXIenaxJMF+VAtoJZRSLJlyOpT3B1VazoadDmI3NpC7HiJcmEHi0prsP1nNCZ24ujIrwLCfHPS8Ejy2s6bCKD8v0xIlNLL7BKa9ELVTBanIkqJbeWgW6c0s+gkewwwSd0oI4zFgbQPh2WPwtksI1veRzcRFrZgAspPzjW1Kimq3pr+V4ILUYdqdkGIrAI8CSQ1DaSJYZW+r2FLYqrFUMPu+EZqiZU7cQ1+UiJkCNgsHVgzlvWkKRQTIbvSx+2hcJv2jf9jE9rtSAlqZbaY5O8Eae0T76T6SJR8bT1OJN0RzyqjNJq6n5DjYvzP7YhOt5bxQnHkOpUeKODzNYzaPIS4weg3TLxyvdtGLx6LFGtWERUV4r4/GLGnZjqAUwSM1L6yJPGfS1nIXzQV6sRrRFNrbEDzvPWwWnwTDstCaH1Sl27kAcy830U0FCP0A6WofO0+Yse1QkTdlKLXM2NcX4lIFF/XojrWuIO25GaKdoBdvCzGxtumhNRNHuxAXwElgynFnMCFBqjmVhhP7IXI3a/CbbYTxwHzFfLSePIXS2YSlAQOtx+pIXDQ2REY4Cmiwx3ehg94nZnB7bQp/N3Ne/s4IoFe/FegvNhHcSaH4PJMvRWy9ry9+jqTxUUWZ9wxVq3nN2FfGikVpOkRQjaG10kF8J47pMwcoVWdwyKr2Q4e488EYVj/7MOaeA6YTVItmEqGGjfeTvwjUHmqjm03IvXZ4ltZSBtSH6xTyAg7OJ1C41ZMxIFW7ukwRMlPdefX/8T+91Y+hSfwZxKDiZ5Io/Vgexc/fGQaS1sNyLGC1icrovXye3wuk8vOjHU7qDavPdfc9Clb1O6nFtMJ6cQvpTVMlKl0wqKNywtDoGQoItQrL54RsmgJjFANSxXmp/JltZy6ZEiCt0RI3dkSUrf6IKesmtwxCnrrKv4dgyDKFzBcZBgdEK2i9q09Vq8PWykxZK7KdEfYg/44ilWFLxyWwdHtFdR/sre02rQhW3Sq2XzIAprvQQ7xkjjW+ZeBJfaUn4lR7D5vP5O4Y1doh8SQW8q4PX8fa0VDAtF+KDSlAR9GgIJ6lI9tzj1lAFr3lTBu5iwlJVI6es/a1em16g3viX1ux9xJF/xgEiUzIyWt37rY/4vWlvykqg2VxHFT1Nz+PWj9psOJavG5OnolkN4IGW36AnXfl0PsOssqUPh/DcrEMfF0ZR3JGyvnTz1+Q7zd2DEj/26/+AC48uIYLJ8wBvHb5CJZPmJOpNi29uDRIxqReSUtCd+GbzN/gzSumfjt/wpSNc8kWbm3N4l+XPiD/X5kvod5O4Ep7Dvu75mbUUdHn9eETbaQKgwsbn2qhs58ScEorOiMFZYICZe610Lj8ff/3seM2iUl8OTEBr/dpvPLKK/jMZz6Dp59+Go8++ujQ77a3t/HMM8+gWq3izJkzeO97jVrcOyG4uBcAGGMlhpYKPoL1nQiQSvBnK8YklF/PNyDUWaSEYQ9eIm4WKwSyBLE+fW56Ts8rzOe14qr7sJ+JFj+iWNwb9ExxWxu7xqKh1RJxJ6/ZwvxvG9GdvW8+LkCRYJUAQvocrYw+FwRiXcPqmigUG/9aVuwIyBIXb8sx8Yg80pcTCQPUM2kcXigguZBF+sVVJG7uwW9OiTIyPTmpEMwVDCdu8Whd8NFJp6QvkfsnTViEnEhHs0PA3sdWgRRQ9qGGUs2k/QuvAQEggwsxLsjEuoA/p406JjPZpKCyDzLJKmwV2H00hfya9bZd9MQTlH2j9aUkpl8zFTmeu/SXlkKsfOJQRIW2382EhYfVj2SR2jGLXo5N9k6IqWuhiGGIR+sScPx362jOJ7H9RErArFROywOLHoIdUsG4oKCNDo+Riz/6+XFxQisHHkP2akwANxcuTCSwl9ifNufMKuTsy6H4IvL33B4Xq0xil84YcE7xj2SPlDVm6oHiVWPhw2tcvGm9UI8EAii56OG5E2CLz1+VKpYGJKe2G0ZNu9ZBO56Q3tTEQVdox8GdPSCXEaDK6Kfj6GcS8FrmAm5+sCg+qvNnd7B9exrx/Rh6uym0pkNkzxyi1YmhvZPG0d83vWrbTwFb7+d2evCzHczNVNG/Oit+fWG+h9LjVDAOZGFJAF64aeh5pCcefHsdDy5v4dKnTsv5k8qXfy2ObiaOzgMNhP9tFulvO0T3hSJalwtG8dNS7Xjua9+Ukio8l58Ub8leSqC+0ke8QiqyqZBrlfzox+tCjz54IG0XoibRwfG69pOTius7JbQqJcJ2VaOKWigY4OPtWW8VN0aFmTSIVviM5pdSiTVcSvGoCrE+693XFCS7++BrWp3lJtfNYn52v4bag3NIlYDaQmwIUEbepFq19AagleJ78vrhwAKkt1AQv+joUO3n6QE+1Dvp9JlKgpE2LvaZLsdmx1RBbCQkRB/a+N1AVkN8rw896UGV12PDFN1AbYF4vYp9UZVP7tp+0n0jJsUkoB4HlY5ZcW3Padk0hs708LXhPMNndjdnrsvMK2TlmPfvP2CFluwxUzlYz4evsULH4+iyB7/pI1Zmy4t5L5+3Ennmpn0cljPo7ybl2VI71kd21djPmWvri70WH97chrw0cguRyiwK020P/REhKT1fJilac314VF22b6HtEOcF7R3VKrG0EHG+bYdRL7TeC715AyapIL/1bl7EBGae3kIKFdRsBfJwy9xkN8tJ8cTeg/UoOtfD9As8hxwO3tUVX9zXbpgkyLmTmzh3bh239mbEF9uN2U+a/6sg2MFv2u092ENyJ0B5Z17uOamdPmQyJf1yAmtlDkzEtB6q3jOJ2Z8aLvt3rIp35tYwzZ/3N+cp2W7aUszrASrXbFPy10iwvNIb10PxZ7yPSZiYgNf7MNiM/T3f8z24desW/tE/+kdD4PVXfuVX8Nf+2l/D+9//fiwsLOAP/uAPcOHCBXz0ox9FNutQPu7T4OKfNB7aupAq2E8GgwqrCzD5nZVLFeZwgCVa5HBacMvMuq2esidQQ6q07IH1+0NUYnmfUoi5TWbkWe21++NrUX9sm27vpvIrCyc5Lh/52y1UjyZFQZCUIC40SE2lQJFR6O0LNZoqw710gOmLVQRV8pYoOBWDx15XnnO9gf5MHn4rLQux5H4XzdmY+BnWH15E5uo+YtfuoPEu49VGwCwTBSsF9PMUKqsBjBQBqpzOCVCmfY705YrRPVWcLMU5Q+/TnlRqOZmROkwhEwKHIkGk9LJH7GEAAQAASURBVPCYxRoBJhdyoiRMSwarvEzQPH2lDb8bEw/b0vkklj7XwcEFY6fC8z94yPRFJkt58VedfpXVXAMQp651sPcg89lArEUBkwamXmygO5VGJx+XSnJtKRBqlvTthobaK8bvrOit2Cpnl71EtA0i9dXaFtUMbU0WfKzGkk67wt5ZHosBl9NXOkiVYth+b4jCVaNyzHMUenbDHKMYvycMJU5BFRMA/E4vWhlXAutDKmBaup03SMykyhSMYlKjh04xKUC3l0pKxTVd5tiFYpsTTufRXM4hfXUXYTaF5mIa1aUYKqfYU2cWEtlbPqob8yjWqJZpwCBpznO/nRaxmD6VfNl3nQ2Ml+p0B+nL9H2NobuZRpGLx9CXBVyizIqyyagvfbaKxmJKFlixuofFX0uh+4yPlSe6Ui1qP59E9UiITtvDzH9O4vAk4P9xEWn+ScQ9WbQWr0LUlvvxEHH2hpGFfyQUsRfeP1z8cWHMhTzv2+U/3MHOB+aw90jGqHZbj0gupHlObl/aJO7/IONAWhXomLRmQIvXcLxF3ghY8rv2turvRkWc3GrsuN7Ye9nruPRk/Z27f37V6mO2Z74JS0Axcmq4F3Uoun2E6SQCq3Tcn59CPx4gtd1C+YwBMtQYYKQ3DXBoFbJDz1rtM2VkLJ1X/cRlCHT/1WFgrMc7UHsf+MtqxbhN25tYiG6hJzRZOX3mhlmdLBrmhVbMhsSQFtlWYg5g6iWzTDy0WKRr1YLZ90qfbVw17A1X1YjHxDh4iC0QA89SN/pTVjn6kBoH7HMf/I501G49Ds9WQZlwy26acaxYjSN5ZvPcVWTKWgixT5/JPD5jpB+Vc4iqKdtornQRVPnMHIDdzKq54HxN/r/pCBsGbIUwtjqc56cum7VGcvVAWFkaiVILd77JgNO59xmqvAofMdkox8m+XjmcwYXkfUDgynts96lQlKDls/G+VJs3Lh6PmA7Z2nDFPrfZReaareiSmvyt81h8poLFZ0ijNsibApKMxoE51uRSHa1tUrEGY5KYNRtMfzJnerP3zXt7j3TQXzUX78RHeWO20M6bc1n9LkuhnmoN0YqDFXNjX/n+vzd80ScxiT+jmIDX+zD+6l/9q/jBH/xB/MIv/MJdv/tbf+tv4W/8jb+Bn//5n5f/b25u4sSJE/jVX/1V/OiP/iju95CMZZNqrx5yN2oDmfh4fAASSevlIkQ9AGWBY0CtAbN+BHhphSMqwzaUJhxVbAlERzL9Hvcl2X7fWOawgst9KY3YoRNHwFgrAq0WEq+sYnprGq2jBcmw0nuVC4qp1+qonMpIT2lrKiE9lASywUEV/Vwa/mEF/eVZ+BuWEs3Nr21TeUF6tGL1LpK+h/q7jkmfZGypgESf/YhmO61CgOx6F/F6gNqCJ8qyrIQSDO09xj5GiLpn5bihFCUPe0boSFSC7WQYmH5XMxBmQcbeRFZNuBBgtZZgMPIJlEqiqS4SxNIupnI0LgkILpBmL/ZQOREXkEd6FIWX6Dt35BMt8bYjbZdVWm5v+nJX+lqXP1WB32ghTLDcyQVGH4dn01KxLJ+kSjF7aY0CsizCaEdaC2UCFnDKSmkAlM5aqmnH0P205zWkWMdaiOx6W3xySeUiJbd2Iov1D8bRPtHC3B8lBICJfU/eAC+en6gssxfWClhxEUnLHlYTCVgLt0IcnDciHRynwvVQKMmk/nJxk1vvWlGpnpw/rx2FtGZeKsNf3TILaN5/pLjvt5Du9FB/cEHo1iKGMt3HsQc3sf3JFcy9IHLwQufl8Sx83hOwmDpgAoh/B+beTpQ6KJ1LIHcT6K8lkb9jEzbiS2u8fwncZ19pI2j2RNXSv3gd2eoKzrzcRvv4DOK7NTkuLoIO3jUrn+PinVXV/Yd8Wej2i10kV+OS6OD2mPjgMU9fYiKkj/RWB/F6QvqUVVCLi7KZV2pi/9NaLoiVFBdGFERhsoGVbW6rcjJEb26kwW8S9218+Ov/IVggi+2ZRWr9rG2m1GArhFZGx9F93arpvWIU9L6Z3ljXM3ackYLOKRYIZ1/Zke/pO2ZxTu9mjex1Uz3uJ035cP/RHGZeGojQ8HW/q6XSUOx7vE4PAZOUEmabfJbLrlMZUd6Ww3ZaHkZDKcNqg8PnNOcXF7RKf71DMxZ/8AF+Qc22RST3zDNSjmPKiK+Rvtudsi+WzQb4nDbjahJN+SuBqMe7MfP8wLOVSWj+YIQBB0Dq8JQZq8PzYUQfbayYc46XBvTkxmIIfz+OhFUu7uZsYtm3wlCNuFSS9f0uyJp/wYwv21UK18muMcdVJagV3QfqHWiLkAWzOqZ7MQGy3Fzu9kDp3w0RemKFmJu1ivIqypTd7CH3JUPL7a7MojuXR1Az98DqtxuBo9pDLSwtHKJnG3M3r85JIk/GoGyoudp7rOrKtNkhxZix+1RqMF6lhAgqMlY+ZVDrnW/MYfFZC57XzD3aKw4yfwSu9ZUM1r5dzHXlteIrMZP4rQa48L4b8tqra8L3lgQpw+/lRKSQ15XJWjnvJ8oCEtJXhv/O2FJU/46y3OHNWgKdRgwhq9rJHpI5c31e+96fxddSsLah5MC3ch+TMDEBr/dZ/OIv/iJWV1fxb//tvx0LXulstLhoPLgYMzMzSFIp9x0Q37H011FcnDWUslQSIRV3NV+r1VBddOgiQ6uuAvYsjVgFmASoDoSaRFmYlVmCXC6eGD37mlt9jbL6DkhVwKvZUKmycnZIio2O7N9WhEOKgWxsI7W7j8RRQ72hgqxfbWLq2Sp6M1kEe2waiWHvvXNI3SZnCWhfWEF8q2o8Cm+tw8uk0T8yD79Kz9kA8dU9xHt99BempBpLf9TK8QWpLnLypaR/fZ4gxwhGSf9k0gAIgsnpy23pk5WFBZlyUxTEMDY+BIasAEgGOW3scfgZycL3WHntSNWXNGN+PntINUVffq+VRQZN3QUgekDxhq0o7PSMxcxMgL0ngKVPA9tPJpFb7yO72UU/FsPSx3fROFGUymRDRFMysjhgFZig0QgymQoqwejBBUMjm7rexeGpmPRvinWRrYyK7+pqTzxgeX5CRSPIjgNzL7bRWIijvsS+VFYFewh2SgiW00jv+IhXSHOuIwwyQ9UP0sPEboc9zDFDWRZj95TZZ/E67YpC+L1Akgapva5U1ltFkzHnjczzYcRTRgSL4z73ezfMPcfFOMXFqHAd89GZzWDzvSlTYb0DlB/owqNy7y8vISHqmiHijT7yN9sC7qn4zERC8XJdKvlUxsbBIbrnj4q1wqyAXaNYnFttCo2x+HIL7YUc4qUmvP0yeisziF/dAZYWpE+b913i6pYoGN/4S0fkmPO3gMJqFzuPxZA4NBQyb6mJQraJxKemkCr1JJHCyvPKxw/lftx99xRKH0ii9VAD/mpars/S55qiLts4MYXkTh3N2Tias6F4SrIKRODKMWd/MisNN//Pf/utfQBN4i2L7BdXB/8ZBZRu5VP+BsaswFw1YYbb+yptHWMqq+O2PW6b4yq2+juK5gnNkVQWHzmq3dvjJzNCg88sJik7U2auVd/t3rEMUjstYDaDWHlYcGfmGeOH2ZvKimI9H6J8poyzwyGg5N82wagCLSbM3IrrUGjxOmBSysyV7FvX3/F5ots2Ht+s/HqR96mSgVuzZmdM4BWumXM6PKeWNuY9TOKxxUOG67g3VCHWYy2fDKSvVYSHrOBS+o6lYk8PfIDJsHArxAq+U9u2MrhsemNl2yP5DQXKHPvtJ+ND40JmCSnXSrMO6FneHKbCxqzFDOeZpc/ymMwO9h8IZP6SbdtbJbdhflc5Gouqm5ro6C0M02G3PmhB6/E+Fs7siXyERvO3FkCcSuDYOdKG3iGJ1QQKN/Qicj9x7LzfHF/C0rnZ0sL5zw2uMY79VhPeQeWue5Qe34ydJxXI2s/2PBxe6CGYbiOVbuPmgVURJqi9ZIHriHhYc8kO/mYWS582ay9eq+qRhIgdymZpEO7E0uIhNjem0Cq/M9ajk3hnxwS83kdx8eJF/OzP/qz0usZUzGIkfvmXfxk//dM/jb29PczPz+O//Jf/go985CP4oR/6oXtut9VqyZfrS/UVCVZKKcxEum9z0C80JKrkZMuVEiyg074uVVO3r9VZCMl2gpFt8fMEpLogCdnbOniLx+oVBaGEnuYNgK6lDodc3NhtRr2ziUQEklk5pedsZjstQJcU5OBmBZguiprvzPMlhKkYukXrxTaXRS8VIMmPJ2JSfQz3Nsz+eIzZDPztElJ3drD77WeQ3u9J5rV8nF6uvvjGcsFASxqxqkkbwEfwtPNEQoAfK6m0LhA6qbW1MWDVFwVcAlH2kc59ytCauvN5EZBKlilKYtSMWVUUVUXi4J6pHpDmK5Mch9zjhOtLhTR3h8qxCRGuWHzGqC2L36pQmc3kuv+eWTme6Veq6CcJylNSTeZ5SH+ZeLGaCZuLNlES7gCHJ6gCTLBOwStfPFzTu6YHmNY3/AwXhATzrBLy+AjeeP7VIz4Wn6kJNb27PCPgmlW/U7+yiu1vPSaKzfScpaULK6ocS1GRFgBoKrGkxfE9BHE8nuRBF8VrxpqGVVXSxPpHMzI+c5/eQphJiiUS+1dZhSHAFCukqSL6+Qx2np6S8eRxyDELbc1D5VQfie0YZi6FSBx2ZfwPLlCoy0ftgT4WPs5FqqlMHjyYQbKcRvm4j252SaompFWzgpBf7Yj3b/zGtkkQJWOIv3AdYbstly3gvZzNoF9IG/umRAyNB2Zlkbb4+Q5ufY+HWjeGKhdtzCNVmZjpwjtMYOpX44hXWlLZz2x2RMW4/GDBVHfZc1cGkp9Jy0Ly1L/bwq3vW0R6N4XZFyuiLM6quiReKgEK14CDRyl4FSKxE8Pl/9tEpOnNxP3yLI9ftyhEw61yjlZFX08p2A19v7Jc9Jn4eu8dRw8eV3HVbbrH5O5Pk0vuLg6ZgIwjqLcQs6CVSTEG/z6VUso+ftmt3Z5fsqgql0HzuCmxqZcorcKiQ0pay5bCsG+pS10WP2Zryya/UorrboiZz5rnd/Vhg3KVykqBONlXnB80VVkmmhht63fL/nll19AflNTi8pnhISPAZO+/2Z/1ba2YMWrOWKBVMf3/9Ipu2W33O8PjyAQg7W7M+81xTF82O2/OxUW0TwT0uuzDHaYPyzmz/bOjXt0UMAyEAcQQYUShsPvYfxhDPrRK+w7qtuLbUHudwT3FOYS+5VSWZxRvmKphjwrB63Wk11k5NlmA1vGZyAaKce37M3j43TfAVtM7lSIGkBDYuWiuSfiBBvqWqqtx+v/HY28hsW0rqd8y+CT7jDvFnlS++UwlU0auV8lcW4/3ltgIDtaHvYIBqxQklGtlK7Xl8x6OnDE3p2cbrw/o6sD4XBH8lDB6vjRYi9Gbef9xZqeBqVf0XjWf5XWScVgySJdn5fH5nekgleigQVq0Wh5ZKvfXUvTehp7Xt3r776SYgNf7JBqNBn7gB34A//gf/2MRYbpXzM7OIpPJ4JOf/CSWlpZw48YNPPXUUwjGZZdtkGL8cz/3c/iKh1Yz1eaGocrBBIMEZqom7PtCCY76k2yQInyXgJPSeglU+ay39jmRkJMdm0G1djj0dbdCS0AagWYRNbAPDQXH9ZaAAO5HqMtcUFZr8KyqpRGECtDLJcXDM1bviUVLap/U2QA4WkByswq/ZO2BbHWZ4Kc/X0A3F0fxelM+Wzpt+n3YV8TKHlUPxdszYUSSOBnHGxQxCkVEgosqKhTPvFRBcykjlUFWXbtJH0t/cEMqxx7Fns4sSX8WxZQoKkTQl97tyeIgs9VG6XRSqg2k5zIzTWsVZvEp/sSFCjOxFNspZRJSqSRQzm71EKt2kb/VR7eQlIro7MUm/FZP9iHZYZ+Lop6AtOShqQ6zB4x2OgTYPI7ErVAWPTyf9G4HsSptblLIvbKL9pEpOZbcHaOsTDDPbDApvuw9DuPsMTWUaoIlAnfxWS2xEtwX4Jrb6CK1WcfOkwUjhkIBqc2+nBP7hKnOaQSYjMUO+4WpHMz7N1nqCXAtn0wisx0g/+oBmsfZJNwWGnzj7BxiDS4AQsR3+zj8tgviG1s+bfpDFx7awf5uAWE9hvylmKka103v9M6T7HclZc7aHiWAk78KpF++KaJevEeSuynsPZ63IiQGCLM/iwu5WJNU8T7680VT0b+1Lvch+6xZ6Q9pP5VOweffSKcrvbZU/eZ13Xs4juw1s1BmtZmLv5nvvoPWZ44gu8br20f5eEoUn3n+C7+/KkmBbjIjXrn5WyHmPr8nCZmtbzLsECYo2APG3let5HSnumjNxBAm+4jvxiIBm0m8cdw3z/Jxca/q6DgAOgpU3dDPKdvFff9o36xLDx7dr77mziGj23E/54Y+563WAp8jDCqnM0HEhX9t2YDE9pQBJ+mauZGFPsze314f7YJZYlFzgMHntditid0ZhjxEtaeRoFarivq3MXWNdH9zzIWLVj7XBp+jsu18TNg28nPak8+6wlPy3gND2WWw190cmz9E3c2uGWV6+mfPfdIALM4R8p6lAceW7Spk79Djm7H/4KDippVVgiMKQ2kPbsVWbim4Jx7ljT6y61ZIz1b0NMR2jLsX+zErPNUy14OK8Oa7Sc4SFKuXrSpFM6nH5yeTaqPUYNJeZewPQhRuGvDmU0vDBum9nDvNNfOx/SSPLbB06zSCDC9eE/WupZTvGbp52PGFPYM0Pek9YJd+dRawP2Puk8T6LjxHQEzOqw1MPx8TPQlGPxgwERI7hhrEhGjv6JwkceX6lQxX26930CsMVzsJNNPrAQ6vGcXh+pPmvbFED/HPm2Nd+NLwMTTmEqKX4VOxueUZGrbYQ3loL3QilebkZgytxR7ae2kg00Uq20arPazePGHRTOKtjgl4vU/in//zfy5Z9G63K9VVBjPsn//854VC/Bf/4l8UIac/9+f+HP7O3/k78sXY2dnBQw89JFXYn/qpnxq77Z/5mZ/BT/zEQMWT+zl2zD6Z3ubQXtRx1dWw37V+rbZfigsI9Qu09jZi9aIg0wJO+d5owp8qDAt+iFXOwI5hHHCNlIcTrArZSq7Sg7ntWGxwzE4/rLwWqRZ7piLM9/A7j6HdRuPMjPyOPbBcYORv1NBYziB5QDDWhrdbAnKU6PXE21XUZ2+to/fkOQF7IftTK10sfbqF5lJafibQI72X9F9SYsXrVbxdDXWWoDYeGK/Q9kwKnbSP6S/uAPTLJRhvdxCeWkFjMYvkvvESZZ9XotxFbTkh1CtSY5ldnnuxg146htRUyvTBdq0iccYAV/aCSrV0u4/CjR7KJ+OoLQSY+/RlhCdW4FcbSLxURv29p9E8lpTsNqu0XAjlPnsde99+TlSCExW1ofBEjIp9s1Qg5rGwT7N8IoH5391ALL+C7kJBPp/e6cPvGf9bvo99oBwHs2ijYAfFSLoISnV0V4rIrtURHDbELzj9fAftC0ekT5jbEDoy/V8LvtCJ/WYPWx/IC3CmNVFtKWY8evuh+N0Wr9QRW91FiiIWpBv2+khfaqA/XUBnJi0LU+6/dD6N6jdmjCqrZxSOtz7cQekzC8i0zMKS7yVIJn2Wi1cmXxaeM2CZ17sxHxcgHNYb8NjbXcij9EBeep/nnq2a6mmLgmMD0bN+KiH2U+yjDs8Yw3lPerqZTqeUMMXIOuhRLKzZRubVTXSzR+SYORZMBlBlmsez+vwKUqRjp4yfZe5WDc2FNBLXtgR47D+cjXqDWRmhjyEXvnw/7TA6O1wI0WLDnCf70Wa/EJOqa6wUCLVPxLgm8abifnqWRzGu0nkvYDiqOOywaiJAqS0j8nkFqw6w0WrrKGjV0O246sXua9w+v+7BbpLtthVZGlAQP7DVqeODKlpmyyrNMlFF0JlNoJs1i3gyMtzgHMDnUoFK5RT+scBL6cMSVGG3Xt1aYaXnNrUE9s9TxG54nJnEk8ONeagtJYaqjUrnVfCqolGJq3zODHpXNbhP9p8qrTl/27x/5ylTBp17oY5OMSFtDDuPm3FLlEyrilacZQwy5nNqL8Mko2v7Q1bN4rMdeZ7q/rMb5nrzWcdnOb+E8uxcVgJljdyreyD8apwypWrqTth32XE126Dtj3t+DJPstZZDItTnIb5h+0ZnzC/LZ3OoHB3QmGU87ecLCyarMJut4c7+FG7vDqqmwZa5BrHT5j2xLxjW0fRl9kEbF9BEqY3eVBo+Jaa5r3M55Db7qC75KNzuiY2cfLbeF2s1fnWy1j+4ZG0EyaLKxeWrvmSuhSY2In94EtSyfN4PxoCU4SFwf+sgOu+DB825M4lM0K+q2515s08/qUkmc3+LzVrR3ON6ZZQu/LUKXCeV17c3JuD1Ponz58/j277t2/C5z30ueq3T6Yji8Be/+EUBr7TPUQCrQdD6vve9D5/+9KfvCV7ZE3u/9MVG9FiX+suwgFFAIhcPrgKxFfjQfteIvqsVXN+DX6QsbP/uLLubqY8FpnLr9NYOWenY44le02OC6bGN1I99H/5U0exPq8P8PT9LkEFKz8wUMjdL6GeTSFFUaX1btpu7GTOV3ukpNB47htRGFa2Tx5HY5yo+jvD8CRH66YknqPERrZzJiiBOeyouE5cYoIe+UDd9Zn45nFwQ8dSpjFs0asT9eAyFKxSLSsEjyGm00T25iNheFfFqAo0lA7QIeKtHkgLk+H8qZbJCSg/aIB5DMfCw/UTS+MGKEBSroabHszFvhH04Kc+80sX2k2kcfuQBTH12DZUnj6A+v4yp6y2kDnoCbFkZ7GZj6B9fEi/S+Rd7KJ0OcOK3Kwhj9H9NyUKFld5uysfB+aRQnLsnFuQ8vW5PKgWFi/tonJ5CbqOPwgvb2H/fogGtSSoix2Q8iq/U0Tw2hdSVLak40vqod2Qe9WMZ5J9bRza7JAIjYuPSNRN25WQ6opARvMqY2oUWK8KkXRMwyjU/OETn3Aqqx1IC+tgvrMJSYWASAaw89GaNsnHz/3gA7OWkCkFbGVmkhsayh5YW81+0fWF3qkCnh34+KfeH3MpTRVE19Tpd6TllAmPniWnpO2bvLY8xXm7LsZH63Z5NIVHKwGt2DXAlXl3gvnlvmb+LxowvyYTEfkIEu3iOXPzsPeyJj1/mjof+UojWrIeFj7WRurQhtPjsehz92SIq5wpy/PlVQ7nm2HAxLkIyUk02tktSzW6aCjErz9VjnmT2xUbDB176pxPK8JuN++ZZ7iRLXhe8joYCT7fyOfp5JgAZmrjUGK2a3ssWR3QSdH4Zo2Q87lwkOer0xyp4jSjaOXRzCRSvNZHYsFRtqsXPGXTQXDGLf7JLhjZNRfCYaWOgMr2cXrUv7R8MtkVoiOK29qnSytm0GkYWPRoqzhM7HABkFdOtHhugYT7PqWdgnm0+CtdMBS9eMccqdmWbtpfVgjX+TeZXh8edz9/yqbRQhBlzL3WRuWEAX2vJoJy9RxLIbPG9llo6xR5e6g0MRJ34989nHpk96e22sJH2HmFJlAkMk8Qq3jJANlbrYv/B4XJp/qYVJ9g3CJuChsO2NANrHrWLIxtELtWCSVByXPWcZ14YtnNqzaSw8YH4kACVBkWfwqkOKodp5IsN7NUG3ObwelYW0r0jTYTlOHqbVkuB1c3nzMWjLzijdM58X/p02SQBKarYC6X6nto0Ve7OtKUBlzvw2gNmQi8Tk/nfHI8/XMleNxoYzPGQNcT2m6o9RGoMoJxAayMlz11B/jY0AcBksRu8Tu3jbSGpeloF3k9I/zKVqmOHATpJM+bJrDnH7PTIoE1iEm9hTMDrfRLf+73fK19u/MZv/Aa+//u/Hz/5kz8p/6eqMOPFF1/Eww8/HAFcgtrv/u7vxn0fWkklYLU/D1VDbQVUQjPrTrXTC6yvq4b2vEY9T6YKGi1gFMw6C5gIuNp9DKkRq0WPu31WXrmAEUEQA2y5MJLtELg6VQKhGifiUk32dg+AYh7+fgnhwgy6Z44gdmXNnHMyie58QSatzlRKQFFrLo0gl0Cs1ERqt42gzEpbD9UHZqXamjgwaoRes43a2WmxZSmfMj2uMlEThJJC2yNoMIsWOcVOD7i9YTxxYzEEF28g7PcRL1cRf62L+rtPofjCGsJsBu0VsxBhxZD7nL1Ulcrw4ckkchuGfis2QLsttGaT0mPTnE5IZr18NoPp//oKposXkF6ronVmEflPX0OOi0DPQ+k7HkB6ryf+teGpOfib+8ivmUl+6loX3XwC9cUECler2HpvHjOX2kJ3pgUHx4fCSFwIBqs7OPi2U0hRzIp9mp8toTebw9TFQ/hbB0Kr2no6Lwsl+qf67R7CvQMz5icMcC9/KI/m1FGzYGMGvmKsBOiXSwBGsSIqHRMUsseN50z/QqpBF/5oVdSpw6kCwkwCh2fS8ln2TVGpmXQtbs9nkfe4oa716h7q31AFXpzB7E1TBSEVm36t8YqhJxPMMlmR2jOL5s5CTgSOWPktnY5h6VMldAsp0y+920Tm2U1MM1FSyMs5Bxv7gB+gt1iE3+gioKJ1Jo3edEaozOy7prdsfSUpQlw8V6GfpwOEcVoJ9UVVmCCcCx8CUp4XFY55TAbAhwgXZ9HLJISGTcDLhXH5uCeJDVZgSdNTAEvAXF8OkVszFEYuzLkdJljCY03Erqdx6e9PgOs7Lb7j+P91/C9ccDhKIdbn+TgKsUv3HUf91bgXDdk+m4ff64Dre/XNupRlfa+C1kjwj+gtDn+vjMS2soBi7PMxh75pZXoteNVgYjB7+QDZchOeWvJwHrPjUn/SMCJoHcZQobdgk0qvZgyqR4aPmxZtiTuHQ8fem7cNszZyd9pR7yPt3Bjp3a4AZ/pna/B5xZCkpwBUHoMBmHmrvUVWD+m4+VUDkhNXNqPEQpgzwDKxb8Zh9mV+1owZE5putZXVYzm3pgFF4h1ue2Cj4Xf+SwZMqzAA4VQvry37aOdzRozw7HkUrtelPYJ9p4x+1lo1NX15ZmlIa0UXkgzVfRSuD0AWn6kopFA+NT4hFKuyB9da77SGOdjtMpWwWEHoICjH4O0mESbMiR/5OH/B5LMXKTBr8NlbejCP7IYBfU3bo5zaNNTgoGlZMmJZZBMVFXOfkI2lPc0aTBqIfRuTrbwn4rbn17P9v6UgqjhrLH6hh8rDc0LD5jNfRb9YVW+u6N/F8N9gfKWOdj3uSoYIkGdUShkRo7r5w1+bVVe1RFJbpLdyH5MwMQGv76BYWVnBj//4j+PHfuzHBMBSdfg//+f/LNVYl0p234a7mBjNqiuwVHDrUsMi79eRHqfRbWu11lWnlExl/+5KgVrzcJ/MulNBWIWZtJ+W+7UqyKQ0D1nnkLrcbA6oy6wIL8wZYEt1Yh4Dq320RNnaQ7DOyrG1cGj1BcgGC7OSRY8fVFA/UUCs1hexn1itiXD/AGE/RHZnz1SY2a9oRa5y7Z6AkswqKb5dqagePjEvQEd9X1ntmvrittCXe2ePIdgtI6S4C8fl5BH00nH4zS4Shx30lmdkIZC8UxY7k7kvlAT4dc4fQe1oSsAWM8S03CGQmi93pTJMKhSN0dMvhJh6fhdXf/phnP3XVLhoIlnJCNDB6ia8Qg7TH7tqgH8mg+TF2+gvzyNzsyzgunZuWmiy7ayHTiEpCzqCRi5UaDPDftbZV/rI3Cih8ehRAV2sZjBLzwSAV2+j/MAUYkdz0p/EICA8eDgnE3p47FGhPS/+5lU0Hj8u4Ir9VRRDkUVWCKFspTebxgaCHqwPcGLvwe/EULhUgsce524XrSdOIqh30ZpLysKEx6GUNNoXiZqmx4WjsVzgYlD2cSknCQXS5irHfRFrmrrkobFoaGXxSk9EOWgh1Ctm0Fhg5bYvAJ3HWT1dQO5qGQlShLs91J88IZl6b+dQKMKkLJOm7TcM0Owtz8KzC9zQ96V/i76wpTM+5l7uIX2njl4ujthBE7VTedQXfZz4rxWUHsrJWNXnmfBhHyx7fmPmtYUTmP3jNSA7g2SpA69HMS0KNyXl99Inq3mkRIguODaenLNLY6SNRfLF9JC1xyTegTHuOaxAUSm5mrB8o+rsODsdBp/D9/qsZdMM7/91PjcOzGqlVbfDNhYNmYvG2PqIL/iwH21ybyB608tYUad5gxjYoihCO05knr1p92utaqZy6E5bYaApA1hmLpltp3Y74icqQe9x53NR2GSRTHW2WsekG0MrvnJsSR/Fm9ROsP2hHqSHnaGvqQLwzBf2BsC7ZgGfBa/yPOT3ahON80acKLCgWem71EOQsaEVFrF6nv25w4fNdg9V+GU7hpy/FSBS32f2/4ryO7Xm1u/RIC+uMEyMWTVBqUbaqudyAoVrNQfQ+tIaEgaB+IozEuU+Dh4gM8i0cND6jUlIUby/woQu5wszMJVOXp5rPOypV+w4KhksHmD+S2as2sW4AMPBfgc2Q9RP6NneVbmcjT7qx/PI3DY9FLWTJpHMOYOJ1HYuKVoLMma72mOcFq2DuecqUU82o3y8IP3KqT3OL+aanPht81kCaQqD7T8YYPmz5p5t20QN51oKYXWstRMZQgsLhmXQ6poTLGbMue0fmvJttZxCaC2BJjGJtzMm4PU+DioIP/bYY0Ov/ct/+S/x5//8n8cnPvEJEWv6vu/7PqnQTk8Py7ffjzY5kfiGA1y1Z1XCCjXJl1Q4LZCVzPqIUuSIkJNMqtrHJDRJCz718+r9p5/X79IL2BumsulxMLhw4cJG9mVpzVxYKfU58LlEN7Tivf1hIE4hJwJcAltSgsHmVJZI+6bfce8AMW6j30f2S2tikQMKKG3twMvnjLgOwTF6Brja8Qu3d+GtteGfOCr9RuxZEfBT7UgPqyxgWBGwx+5fuS3VVo/9tbMzCLt9IyDS78Nvdkx/ZKWG1vllMwnGfKGfciJO7neRWq+gcawgIhcEeRQG4aIntVrCyqemTJ/O7gHO/vNDqT7LeEovqB3XZstUpednZfHVr9YQppbhNTrYf/ccZv7wJqrvPiYguTkXQ2azjfpiTNR0c3dCqealP3UJKBaQuuOhM5tFpxBHar0q9i9hPoviFzex/t0rmHmljfRWiL1HTCadGXqOUYyVyUIeew8ZcSnxaeViqkQBE+Dof9sVZV7cvIPOE2dFDCu+XkImLKL0yJRsJ7i9jcRmBZ25HJJ7bbRmEnJs0u+ZMtWMzA7P2app9kPc+YY0pq4a8L/5PjIHgGMfoy0HKbY+sls+0psN+JWWjD3Fjlgh4WKmfDyGqattxMsdtKcT6E6nEHppybxLf2oqDp+93PUWwkJa+oH5WbXLMXTuLhKNmvjOxg+bOPa7BiBzMR3ks0JrJ6WQFL9bfy4vCzaOy8lfL2H/XUUs/9sDsWXY+dbjxug+kUBAoZAwjbjHHuWkJAhIDZQe1+ke4oUW+vsp9FPA1MUA5bO8hn1R/SSVmAs/qlE/948mVdd3ZIyCQLdi+if9/Cj1N7LMeZ3tqRf4OOVNq4dwz35bSXIG934PF/IEsPxy7Xv0M/eo4gabg0xMoAB4jOXOuM/Lc98JCkLJW/uhJBRlGykDGvuzBjQEO+Z1JqvI3mFiim0lDD4fqM5O4KPAUAEshfgYrHxKqwrB2GmzzenL5hoUX9yXuWns8dqKczg/bUSp2K5QNefbSxkgOPelGrbfTb8xYPqKOZfidfPx7XeZY0yulxGmEnIM1RPDZUEFmlQkD/atYJQFWG1LUw6qLew9NY3ZF9VCJ4aDRwxAS++YfSbXD9FZyIttmF8257r7PtMIO//Hm6ifmxMQWVvhtgfnqZ63pBdXjnioLQ5+V7jGMSJrxjB1tDrJY1BF54E4lwWBWtT1BpXn4jVbOU/5onrPvmlqO9TtvUDhRD7/5X64Y96rFXUVa1r4bEMqtfKnYvMr619HRhepw6HRqGg6VoA+VfU7WDs7vOwnw6lywryPFVp+fuZxo1IcD8yGS1WTSUhkG2j3AuRyDVSrafixEL2J4N4kvgIxAa/3cfyzf/bPxr7+rd/6rfL1jgoFrFTUVdVfAr+ek53XKqn7fq24jmwjCq3SKn1XAZOlOUpobysBrtKEmT3X/1P5j4sh68MpH7G9sQKuQ6t8rMfAL3m/B+SZpu3AI51JwSX9ZrmA4T41Q07wSCDqO6apBLHbu1EvrXdj3eyTv1O1YxuG7mzPZ2YKSARArYXO8RnEah2ktumpYISKRMCHmz97BMH1dYRnj8EvNxBubguAZd9k2I9Jpl+scaa5+MkZWjKVauPsmUxKz2nhxR0Z79R2A/14BtmbFQMY63WgYBSTU69WTCWaixmqRKdTAlBFeZn74rXRvuX9EvzlRZSPZpD7r89hZp++OF3knl9H+d1HhDKXeHUNiZlTKNwwVT2xRfB9sS1iNbF3tIjsK9sov2sJqUIK8eeuoP6hB7D8v70oFD/2h65crAnYRbliBbSoSNLBwnMNdDMxlM7HpbeLgk/Ln7XXqt4ToSn6NWZZveiRVmssJYK1XVnA1k9PScWZIimsjHLBwqojs+2seDLbnr12iJ2nZ7D3/g6mv2Boa7x0tGmYf64mStKHpwzdmsAv91pDqtX0D2SvqnjhLtHCgfTvEKULGekdy1zeRb+YQWK3BnT7onBcf99xWagya86+YgJiVkCSey3xeWUViH6yyVumgo9kHO2lAvxCWhaAlVOsVnuoL9O70fgRnvovZUlgzD5Xwt6T06genZHqx/InD1F+bN5YVux2UD0Slwo2BbdIDeylQ1HY7G2lMf2qj4P3dHD4dAdhLY6gwh5uT8Rn/JhJGkziHR58jo6qBeszy23FcN8/+vnXC6UCWzDwuv2yoyBLEoxOUnScGNRoIjVvKp/qofm6gHzUcoeJwlEAbsdCtuf+Tn9mMtEJUkJlk+1+pP6u1VhJGOmp8VnEIKuHdj4ztkeyY8Tl5FfNQaWVQZV7YbcU45Is49+hRv6yBcKspmpld1w4zCZv58DMfU7wGS6K6GSJ/dq6PSlzro0nT8l3Vn3zV2vop5MRJVZ68EUcKYXsbeu7u1cZAssy5xGQXrwtSUi3Z3X7feZ3TJTNvmzen1i3IkxWlVgXumxdIag8eO8ipp43yebaigG0mU1qOZj7+eB8DNWVwT3VTVuroaKH+eebwA162xpUqnoTrFjnbzYj8STG1nv5c4j0lnnNAF6TmGDEqz3pX+Vx8nprULeBzKLU9qCi383EZd7pxQL0F8y9Ezs014ttR+sfsurXcxbsls21n/8S3QECSQazmsoEJT1mObdybpK+aMse0uBla3VjaHZiSMa6KGYbmMuaa/Pq9RV4lQF0iFmAfPWn3gHsv7cwJoJNb29MwOsk3p5QwOmo/gqItT2okaWNLgrYo2kXGkMKxa6QE0MrrKNqktZ6RhUnBURy4aAKlK6oB/cVUZTphZIQgCeTNCdoa2QfLcwIegl+LTAVUKVqxDIxKUi9W3RkqMfWGRcBf6pwrKrAArhpo2POMxKNoiVLoy/HndiqSLWOGVjSQwk+Ay5oUkn4l27Jgshf3TIVUcZhWX5uPHAe6dWq7J50JfbJUEW4cKMpkyh7bDJXK9j5ugVMXWmimw6QvVGWyiSFj1pPnkHyC1cQzuaBet2oMit4pxWPUsDt9ea5hKVDeEeX0Z3KIPfRF+GdOwls75vx7IfI/8El5JncaHeQ//1XpFI7c5A2/ZYnViTT31kqoDEfQ3I3h/RWE/HLdwRwpp+5Cm92WqrV3I/se2PL2MTksghX5qX3N37QQH1lCnMvNBHfr6OXTcq4t4/PSD+ZV2uh/vAiMi8Z+rPXnUN6p43t7zgp1jDZL67i1l86JUJJiVIPxYtmkdQ4nov6tdZ/aBrZO8CR/+aLj21qpyUJhuXr+6hdmJX+Npre+60+4pUOaudmBBCT7scqduWYL96PXPCUjycw81LVJHDiMaGV0zuWINbv9tHJUJyKvql1xA7q6BVSCLbLCLNJEepqziWFDt2fzsm18Es1xHerOHxkBr1kRirMcs18Q5cj1ZnZewphMdgXLArUXaB6MicV9+ydloipEFxT2IT90Spqxepqb7qLyin+TYYINpIICFqbZkFterKBL/7SpOr6jg3XRubNALw/iaDTaJ+suy23ZUSpvEr3dftpda7gMzVqAXmdc7HvH6X2Du3PFYByj3P0GBnqGTtakdZtjNjasXoqp8L8bdYkSYOarb46Y+c1WggajoqxfaYnXltHf2EGsQNW9YzfTmPW7IMJLeoljNKHZXtk3NjtsqVEuEXuPOskcYd6ikeuZ+zWdvSagu2YFVWSmJlC+iY9eppiMdS8sDRSSfQjiq9/YK9B30mKTBdlHGSOOzKP1nxmiKZN0LjwhdrweDnHmNyqCaPJK9eRe3ELnWOuI6tR6tVq98GF4X7S2skeZl6gPZ3xmB3qA9W8SQgUrw2Dfor4MXqFLtJr8cgqaKjnVn2BOzoOZj1RvNaKkg6dfCJSq5b/Z/2oT1mG9qU2bn+nAfPdjLVAsqCVugK9RgwbrHM0TXk2tR1EiQ5G+ZSP1pSpIFNsiwrMvcerOKynkYwPJ3ou3V6Cv50UujSF91wP3at/e/I8n8TbGxPwOom3J5RCxQlXQV7k1Wqpw7pYEOA5qGRGwFD7mFygqZOcLhhGKwH6/2jRY4GtW2m1YFaUgpkNVw82Ttr6cyIxAL0ErlrtLVcG1VVWUl3amkuL1uO379FFwpC/LLcjKsc8Ph+gRYr2LcpCzJOqplByxZqHzZV1mbD92WJkvSMVBFZgEwmptrLXlurGzGJzMcLIfOYKwmYL1e94TLLABGjSC9Toii0P+0t7+bRM6uWTKcx+bhudxTxiR5cRbmwj+cxrBpi+dnNwXd0EgvYg20q7/Mwq7PYugjtdc/xrW4bOzAQBKdJMIhCkcxyOLQGsWNw6gL80j+50Fu2VnFkoXKnBP6yjNTeLOP1Lt/cNcO720D97DN7Fq/AX5lB63xGh6yaYnebtcvYY+skYGrO0rYjDbyURXLoFHFlA7LCGsFKVvuXMpR0RsGLSIvHCdVm8TfeOoj9bEPB45OM1qYzEd2pS/eQiTKhXx434UvGqoWcxqJxMWyQKVLXPLknRvXi1ITTgxH4LwWFdqN5cmLVmkjg8TbVgei0S7IXyxb5gii4JgyAZN6b0pBTeLiF5o2cTPT20V4qyvz4TCn1acsRkseMtJIVWzmNOr26hceEUqsu8Jw2tkFl3ijQ1FoDqmR4KrwXY/AAz9L5UY1n1nfvcLioPzogV0f5DKaFdc9FI8EqP114yFDowK6/BQUx+l7qZECEYYVeQ7EB8zz9R1x5kEu+8GEed1WqjtHiMgDq3P/RegPZeokr63nv93hXZi4ALS0lMhI5BrEMCgXZuaDZeHziPnsNIv+td79FEqft+HRc3NKHIcxCl9R58Zc1YQSTZbEmTp7pfHd8RZWRWP9cN4KA+QazaG6KxapD5oXRk7NhWF6U6c54bmacH1XNH/Z9jfUgNhREge/XOYPxs4pbWXXIeBLTxOFIX76D58BF5LblRQXID8NRjlToRjGzaXMN0Gp152195LCWUYnme22jNpjD9GlXWzbHGXrP7Z3W200Hqtc3BHO6MP9k33eNFsXfTSid7dNWiqHqmb5JuNfM8ZqQObEKh28fWew1IF5svl6lugShbLChQl7sal5YSxvKn2xHllwlI1/KISdX5zzfQOJIz1j9uR1S5Jb6ztaMZSRQqeJ15pSYMM7UWilfN62zfEA/f19LoHuuIiJUGn8vsO64e8VE9YZqkeZ5yHMUQsVPVITI+BYLq7QSaVwqS/yF7RsZ9wZynb2+jSTA14MvXWxljXLG/ZmMCXifx9oQFlkK/5SJcAY3Shfl61Hs6UpmM/PwccMSQHlcLlO5abLgAtx+BQMkiC52VPYkjVVFSnqwVTtQLK7+wVVqH8qXV4Mhn1nrCeh4rv72h1+Vn6087pK6sIJ6LENJieUykC7PaOiRUZd9HlVtWA/mdoDnPvqIQYTEPr9Y0x0hAuXcY+RNK72y5Ipl1L50eTOS9Pvx8DoWXdyUj3p+fgr++i3CmgKCZlF5I9nEFlRRSq55UYOf/6xWAli12PzIOdgw9jhkpz6wKy88GrA4pd/L9zZb5vTP2BLQCYi3oJYBkXy4r2hIHh4jtHpiH1XRRADnPL32lL4BTF4jhYRneQQn+kWXUHpgTqhwtZZK7fQSVhhyPn4hj+d+tyn3TX5mT+zEkiJYx6Rkatyphp5LoE9Cm01Lh7R9bRONoQbZJj0eOEYH/7mNJqUiKoi5tcHZD1JZjQmsjXbtxZha9o8ew9UNNTP1mClvvzmDlk23sviuPxY/XBBDvPj2NeMMIbhHwkb574jcP4fNaEpzyuvGevLmGmNDGKTjWR/OBZanqUv2ZdkViJVRvi9BKYusAM5d60p9GS4vUM1fQeeSkiIiwd1nsfeiT2w5lUbTyByWsf8uMCHqkN3w0F0LUlz3kb3rSm0y7CbWi4HYZtD/i4kkojrm+0Y1JhMissY+WHr6h0AIJjIO6EQF5+X+ZZOm/KoLPXi3OjFMJdiu0r7eN0d9HdOGBOu9dMdq7+kahAE+fqeMUkd19jTsf3adbYXXD/b/2zo57n84rOp+026JIL7tIDJ6VVGCXQ7ECUHxvfKdqxqxpK7BMZPI969vyPV0r3JUYYC+8Cv1EVj4KEkdUmqN5mer+o6JQymay8x/DZRxF27DnLfMYd1Gxok9MUtrjTl3fM+/NpkQckEk5eS/V+bntchWepQpTVIm+p1R/16CyvJwvbW9sQjYKXl/6mmtVPpXE4XsMWC5+bhXxG9vwjs3J/ynC1Jj1jD+4vSzls5yvgcy6B7fLh0HrNsbSZ83cFNswFebmuXnxqaUP6sY3ckNdZG6b85+6Yq5Hcqs6oKRzDcLzzyQFuDZWcmhPDe5nsnrSawYZbn/A0JorJ83vlj/TlR5ZJiEqRxNCdy6ftrRkaVX1MP9CA3e+nknoOBrL6hvURTvfRedwuLqcLHmon7Ast6Y55lzeVLar2zkkt2KaJjHXtQuk1oNomRb19E5iEm9jTMDrJN6+UJn9Wn0A0OQutFReF4S6NjkKcpUGrEBDAKT2MtkKlLtIUdqT5w8qnK61zrhKLXt+VOBJQbUIQNnKl1Kdbbhqw1HV2LHk8Yhq3Aqy/Z1M0KTuiAWQqbZqX+sQTdpZGMjCQi15WBkslRHOTUmlsnWUi5Y5yfyGsWmpynG8+jM5YHkW/to2wkbD7JvnSLBHIMlseCYN7+qqAZDdLpJrW6bySaGlag2dR09h/r9dM5+h+rFdxMnYWtVm+SyBJydlW2EWmqulDAslmsdtJ225lrqI5Oe4ULLqz0L75ThlM2g8vCKgS4LHxDE9siSV2ODVmyYxYQW6/LkZqS7TOoc01qDZw9QX9mTxxuOWfej+Wa2+vWXuPUsnp52OVIobTYSnj6E9l0byxVs4/MazKD63Bb/ahD+dEuCa2Ktj80NTmHm1jexWH7uP+ShcpweuEeNqZ320FrJoPliUasH6ozmc+sFL8DIZTLfbkjjwesew/Q30uwWqp/rI3vJx5I/K0u8lFGv1EObx8L6bKqD5TY+a4aNtUK2L+lIc6R1PhEfiqzT3q6Nfr6P71AXUl1KorfgoXu+KIBgTD/sPZ8R+qF3wUTnmSRU5INjdOUD31BKym31UTjPp4SFBmwVSEAk8G1RWNlVUglV68zaWQiR3jcgHfWH5Fd/3kSh5ppeKuSXxt/QEuMYbBLN/6qfHJO6D+I6TNvHAqphE741taxijCUZNcMnPI76tgw8NflQAyO3oz05S7C49BO1t9V0RPpWEHel7dY9pHDAdrcaO67PVeYTPQ2ceGBuvV2W2/YuyG6tGm1itm95Whj6/FLzqtlTckNVQBZ22/5S97e050yPZtnY2carrK8Ckmj0rrjp2o4rRBId8zVF25nMsOufRPmKde7Vdh0nIkf5ePqOD9X14rTY866UrrSXc9ux0tK/m8SnpC9V+UO0Lbp9ZRHzbemC74lL8YgJA2VG2BUej/PQxc2p1k7xLHvbQmDXnydYG2UzPQ+728DWiECCF/xb/aBcegbFGMok732OAcd2woeG1B5+lzyzZLdQV2PrgDGZeNRXbxKZV8V3IRp6tGoXXzO/IsCmfTkt7ht0yjv+OSVaw5UX2+ZQBtrEqMPeypZ/XupHqO6N43Mynpe08vI4vz+moWuwB9aM9eC17DPYyle8UkLseUCA6qhwTtMpxpYHZlwb392d+7W8NHf/XaoRvg1UO9zEJExPwOom3PL5j8a8N9ZjKolyrmwoexCjeAlqxVEkb+xqXqqRZb1uhFbChoYBTt0f6qYLKUfqxVnijBY6zbQI7/nyPrL4CT5cKHPXq6qJGFwHaX6ves459j/SIqnCV+NMOKsx6zAqSxTdWf/btueniZWMHXq+PZHdRKoH9RIDEaimy6fG7OQFuEfGL6VKn0iD0MI6zpbXx//1zx8UQPUEbBPZ/vrYrCQcBqOyrJXAm4LQiVmGrDZ9WPjwfew0FsPI4KWMwN4Nwd18oz/yS6rFVUZb3slordkRm+1HFYjYtwJVUbiohJ69tITw4RL/bhX/DWB34mQy86aKhY5MWfWxZKpmZNVJ7AzRPz5qJ/MJxxHaroigsEhocH16P7kDdmgskJhvElujKTQSZc+LPy8VT5bEF2U6i3EPq5j66c3mZ+GvL7DUmHSsUy4kEbYTiPgqXDUpLsXd0bRNHL/XhnTouVGwqOZfOZiTjr3Y9mVUjprH93gISlTxijWUBfandLjKvbsr49O9sIsP7RnxrE7jxP5zFqX9tALzcZ8UCwiM5+DsH2Hwyg9qREMd+v43Ui7fMorrdxtTVlvTR0sj+6O9XEFSb2HvvHGY/1cDeoxksfPYAu49Ni/gSz4/Km1Qfbs6bvlhaM4hfIn/d9cSSgVRpZu8TVSpn9oWSRguMbooUYU/ALRdAcy+30aEy9STeuaEJJ384ITn03HMrYVES0gF8EVjVjYwBevq5yHtpjPLv64VLedWf9bjcyuRoL+tQ5dju5y767BgQqnOXS42+F0V6TNKUdmoEQvxEWmnCfMbr+xS0Vuuvby3khvqj15pI7htAlKCAnT03eY6/kQCXqxPhvo+Ac7QyK+8faFrcdc6MAgUOuwj2qmYb7hiwMqv30wjAJ9Bkb2o3nURmrY6g3RsGkXpctpKt9Ge9b/gMbyyY452+aMagfsSc/8wVM9+sfjhAesNDenOw77nnDVjktBl/bS0aOwZt28wvqQcwfA8HTR/tqRCHls68+EWnatzuoTuTFbYMI3PTgMu0Ped+JoHKSXNsKholrR3UTmz1cHguCxwf0MqpiszoZAMUXh04HqT20jh4XxuN/Zz8iXn+8D1DkM5IHFhV5FQI3ElFwF1FnBopa3XGJVrNtIpMYhJf6ZiA10m85RFlYDmZCt2xN9wH5Ipi6AREQKV9kwoMXRXHUfVGBYd2u2Foab0EQkqB4vs4qRG0adVQhD9G6GkKap0JlABNtmOruEMVUbdSqsenNGMXtEbbNOdohDC073bQLxtRjOGAWFu5VJAr1Nq9fQv6QgGxAcGcqOraCjcrqzy/UXVOrXpGvakE6wN/RP/qKnx6mDZbSG3voO+AagGYHEsFz3ZsOT4RINeEga2cS7XWnrtQgSm+YQGrvGyviaoTR2PIcz55RNSTE89eFkEq3Q4/o766XNiFmztSmaUasbdXRf3xIyKIlFo9ROnxWaQvrpvr2umYZAB7h2lfREq1HVcRBelb/8LTx8R+ormcRvbKgSQD6k8cw/6DCaysBWhPJQSctU56AugWnrN+jzf3EaYTYueTWN03Y5+iAaqxwQkTgSg8d5Omv6o5ZxYJpOOS/kXl4tqSh7mXusi/Vha6ryxY56bRf+oB+Jsls+iMBTj5L15BGIaofPhBxCtdtKZjyN1qoPXUcUyJRUVc7IzoqUtBqeZUYKqnfeDYf7yD6uNL6MWzmP3YTWvFtILVj0zLIoYetOWTA89DqpNmttkbBrEaShyYxRQBKSsH3Hb+ZgP1paTpb814YhtEAD7/Yhv7F5KIVTv4+O997ZrYf1WEqx0QVepGwAornPIMdZ7ZLpCLHodOW8bo9hUoKuvmXsJQKtzkViDvintUghmOGnz0/V7gWI/FTVS6lm1vhk48drt2fwrmVAzQHRdLDx7a970qwZK8ZWKuOxDqc0PnXH2GC1tmTP+u+xqf45p8thVvJiGj/bse6U4I24bzEUEzn7k8N9dLV+dPJqLdY7WV1+RaGe0VJvN6iO9aijRt4PQY9cvuv/GAKX/K855tDe8+HnlM51aHRZUoaqVCTTuPJ5BZG/i1Jg9CzH7RAEFqKsiwHjF+tn7VjFsvHYjQYW6tj6ql9DLXQlCY2mZrxrDAE4+jm4sh87KxofH6A3tD9tEyDp40dOb9h8y1ZK/r3IvmGFM7w6iR+gaF2yGKL+zLGLnx2v+FNHSujTCkDOx1yNKxPbOv2n0+YH5XvOLJnOYW99gGw77e/GoPgRV5MtsxP3/it396aL9fyzFRG357YwJeJ/GWR1SZJJjhokYnT/FCtf2nVghJJru4I1yk4FTN4jmpEUgqqGVEPbEOuLGLEk8XHOr/aq0AlKo7BI5H/QfF89SAXk+oNraaGwlN2ay8JqX5s4p1iF3PiBKmLMLsSxZUcyKX8yUI1M4SVe21FVfTY8rtDfYrvZnSc2qPm/NQfGDpE3bNhBcJSPEc2CtLQEuQyUetVpG5fwJLLnbsAkqse1iJ1Sq3TQpE46ZiVBZo6+dlH5YmLIsUgjZnESTbHNcDxv2xuig9vQlzHJs75vrxd1z4cB9MOthr3d/cNlTh3QPzOvu+uM/FeVELZh8v9kso/MYq+rq4YsIiHkNIahpPKZlAb2lKjpPCSftPTolhPSusFM7IPnvbJDuaLSQOOyjc9iVrzoVEdiMmCs1zL1alytunyBbHYL+J+OqmgH//6LKIkyS/eA29XBKHZ9KYeW4P3UeMTQGz2Lyi8Sarl31k1ym0RI9dTyrLrakYUsW8APfYjU30js2LL2JmswWvN2v8Dh/ykdpPCBAun8xi9pWuqC9nLmZNny+3u3eILMeU93Cvh+6DJ8ROJ35lXUB874ETQnvz33UI/7UiWkUjPNWaMiCVt1+sEWLpmY5QsrlwSuzWUTuRF59YLvrYT0dF09mLbQRN2i7ROqeP2vEM5r9Uw+9/5u99eQ+SSXzlYxzlVZ8x7PdnyHNKgZTzuXupDruAM9I1eBP9suNA7ZBGgj5PR5SJGaP9qApahzxgx9CZXfueN2v94x6jC+ZHlYxfR51ZmSxD4HF+eghcRUyeoeN0FI6j5K+j9k/gqnOyc3zabjMutKc1CknQarIBQ2PtKRNK2S6qLaFzqyY7qa7P+0jnHybssml51ies6460uLjB7dqxaJ63nF2psnbRPbEgtkB8Bsnh1AeVY7Z/NI9NCXAlc4YxZX1XyycCsQQzY2fPiXOPDSodYz6DWL0rz89Oznw+bvtIVU1dhqJp992w5x/zkHnhzvBY0qc9l0Js+xB7H1oe+t38c+aYyLyRsOB+ZmNPtClc0Kux+p22l3ephviXssBGAo0V857iJXM9Z141Y8yWE8bsy320cxYs26I/ac4U1qNuwewL5roxkSvDcce86Xef/QfD12MSk3gbYwJeJ/HWh/SZDoChTIyaWebCQqnASkUlSLW2MEMLB13QqFKwUn+lH8eCU7XK0cyxVXIcUhlmKFhVEK0gOepZclSKFYxyl1R6ZEVQQadD8707Wz2ycODn3Oy1VD8d8YvRXlqiYoJaPza0eBn07NpFg61aUi3ZXfjodhV0GlDpAwRD+QzCyzck492v1eHTE1Uz6e5n9bhcMSZHJTOkQ7nTzyYLm5EqedSXrB6BTm/ZUA+xpVNLFdTeH5LdVxVmJ8Ovx9VnVVe337GLMV7jStv08XoefJ4vK8OJuDnX2QW0VvJI7NTROTKNTi4mwNSrNjD3xw3UHlpAvNJGcruDzpklxG/uGGEnH8hePUDj5BQ66RSmL5bRWMmiNZdCaqOG2HVjI6TnTpVkjmn8sIXuwyfFd7Vwo4HmkQIy231UjvqYudxFYyZAJ0d6rS+iKqmtllRpm0dzKL6wYxZoWzvA9BSCa+soXLYMBe7n+LJUQpnVP/kfd43itFbj2bPMRI/cey30Hj6F2PqBWC3Fbu+YpFE+h2t/aRmnvu4W8IcnkP/1ApozkD7Z5G4L/VQgx00QEtzZkb+j9kPHUVtJoJvJI73dgs9VDqut+Zj40vbSPpLbLXMsqSQK2wevD0Im8c4L1SNgRO0SDvBzdQVGI3pGjTzHGBEIcrb/ZmIcbTY6Vj47RqzLhirB99iPtnO4Me6YRp5vY8Mdo1Gwqq8zVNdAxepcX9hxFWH+rS/PAzcMpZUtFUOH5mhEDLXZMJhsi85rhMbs7ktBs2uZ4yZvHUAbJUMdkcRRurXMU7ofSdwa5XNEljGq0u9F3ruDY7bAXcFbrSk2Z7QNi4qcdn+s1tK7XE4vZXt9t6smEVjvonYkJT35GslSB/OlTgRao17adAq9JZMooFcuI1FSynMcu4/Gpec0vWc+l6OavmNNdHg6julL9NB16N/tNoKNfbk3w1xKhJs00jtdpHdg7NpGrkv35KI5Nr0mFrzGKm1c+UE2rDKh7AHrGSih/9y/qSNYNdXeKFJJJG8BjXOmmhzaRA8ZMwGJSKUQ6e3hqn3mpqFpR/3XkxiKXujL11sZI8LhX9MxAa+TeOuDsvec9G2FNVIxlP9bURpd5LgKwu4Eqn2qLth0KccMB8wOZY51caKgV8GtVoR5HPy/9tuMZsodAQ6tNuqCK6L6cl8Khl1PWVUtViEnVzhKVW1dGrI70VuwO1TpNQdhxpHbEjnEAP2ynVBcsZTIroDHGcJPJdE7dwzBbgV+rYk+j79u0sT9PVJc7XFw2xwLgkgFvVIRt3RkFbCyYyXAToGvXD+7ILGgX/pcIxDlJB1UJEntgFSESxeBKmalPakq+KRCLQqE3e0mqfzrCXDzimzWbAGZDKofOG16pXZM9r4xF0d830P8+hZiFBAr5tE6vSCLoOxLG2b7KXqUBmhdWEJis4J+PBAfw+RuE90jaXiNDrKv7Ul1V65lIYeQP588Yo6l0kD9XcdEsIM+rrH9GkDlUI+egV2EAe16+shu9JFar8CrNsWfde/dRoQjd8f0I0cLWY5xIg4vSQXpMppPn0Nqs4bTv3jDjJ/tS45uk1YoVGpm9oPLt+E32uLJK+M4VUT3+Dy23ptFNx/i9sdO4OgfN4QqPf3ytWiRGOP1t0ra8vdRLMBv9VB8rYLmcha7j2eQW+9JtYM9V/FaH9nPXR/cy6SEKz1xEu/8UAE7hj4mxebMPqO0yjkOxGniUAEgF8z6fscH/K5wVYFHt6sJrSGf1zGgOJoL7iHWNLpNnVvGgdVRKrS+d5RO7L7Hna9exyZIab4iqjcC+oY0EKaK4kkdgV0mfim8x11Rgd15v7BWGJrgleMZ8cvV8RoXvG7sR2XU6vcUaYr828eB1jHbHlUzHqoa87nhHBs9vkX0iXM1FdWpwh71Vhul5vieeU5SEZ5KvQGF6Onj7YDOxsMzyK4PkrSMZMmcS+LKJkL25DrROW/EmLrZOCrHBv3dmXWgU0xKsm7upc4g4WIjfc20ytTPzaJws4/kdaMGzWdod95QfGPbFgxaBeLpF6wH687BXb3Y/WUzJ3QKCfEGF19tC17vfKMB8sFiDUf/t8Excm6IgOaox3AiLloHGlSbV2u2RKmDWGkwRn6pgrCYM+uqwEM4W4C/N/HImcRXNibgdRJvfTAr6wo/qD0AKaKqMquT/whd9y7gKn2qDuVLP+OCJi7OXeDr7sP9rH4frQ6MLC4iOhbBHIYBpwDZqK/Xgm4Fx7ovXWDZyq8XOr1TI6BVRabcPloBu27V0V1P0TtVFzwC/DxTdZP1mukN1aotAW5wext9KlJaQRQvRoXdwIBPteQhINUMt1Z8daGhlQrXDkfpe1apVyjHtOgpZqX6JuJSo31t1tPV2P8MbIjc6xbZ6mi4VRChXVvgainR0sNaraF7agGxNWu1w/c1msg/w8y3XWTEAkw9tyOgM1yYRe2po0LtoucgqbrM9reW81Ix5QKF6o0c8+RaCb3pjHjFpvY6pkd2bR3+8SNG5ZeTOrP0qQSCzX0Bh7sPxbD0TANxLgaY8S81EL9akopu/npH/Fu9Vg8g5ZnjVqth9osevI1dGfvGe88i/dIaesfZbBoiuLVlep1nZ5B69po5HyYxVGiMYceFvbC5m1XEdiuy4KW6cvf8UQGs5XM9IB5i9gvA1CseFv7Tq1GfsginkELOhIEmWkQ9Gig9tSDCKY05Dysf20XmtS76+ZSIZCVZBWAShYtlVvQzSfgbLCFk8NHr/8+xj4ZJvHPiO87+lPlBQYazWL9LzEjDVYh3qaVRS8U9qLIq2CQ/jxMA0n27DXoj9GBXrEmfxfo7t1d2iCrsv7FIk/v+iL2jydcRwSOXxTOmR1UV5CVh5/aRuvRgrWralhf5edv2TcbjxqLNqar6quw7Wjl2q3ijSc7RYx6dN2211G0rcZMF8pymRdyo4JNuq2NZP2NAaxS5zODessCUCT0J7teOVftBoxiceHXVnErTJDzF3m2/hsy1fRHmk89zv7bfNLlZA2F8P2taa3I31D/Xg9fsoj83Jc8x2f1iDljMYe/hlLBk3Ji+VDfCiPtNSWhqtGeTyLxsE5/2OiYOC4PhZxuLeNOaaxWULdWY8yMV6K3dUTT2zrWhnRB9wN1g5Vi+P9FE8koKsVd43c09kn7h9vD4Rz3hPXEo0DGR4yl4QM7DwueNgB+jb62L6D/eT88ISCbDSOMTX/y58dfwazioUmLM4t7KfUxKrxoT8DqJtzS+48j/OOydyoWtneClkudmrceJUaiokwtU3XAtdFzrnVH6biTqZO1vdFExah7vCkHZ/7vVwSHrnugjfSOi4/bzuqqT+pp6z+oxuqEVz96wYqP22PY7LaA50huWSEiPqAbBKic9qg8rTY59l/K6eYPxRdUFBEGqFXfyguzA4889L0cVOBp/zehL5XfQ8yq0XTtW9FxF6RAht++Irsj+WPFVcZLRvmD2o46CVrWy0cWP3a9Q4Qi0rI1DWMiK1U/s+avmuk1PicqxLBKnCmaRsl9G+/wyEhtluRe7sxnkXt42isxCeYuLSBTFhYKtErxOHt71O0K59VtdoV8F7NnqdNCfLiB8+CywXxHg7Nfb6MznsPHBDBaeSyKx18CRP64aZU3e8+zpnsqhc3ZZqrB9VkQ3D9C7swEvn0fIqlC3i8axAtK9EI2TRWSevYH+Cvu3EkgcWoo2x5yVcjseIZG1UO+owJ0241XII/+xV9F97DQaK3NoPW3oZlMvH6K+DAQzbfg30lj45Lb46EoCg9eZwiy2Nzaq8HMRnc+huzSFzFYbrak4sutdsdeRW7HeQDhbNDZPs0WhPPeyCcSvbpiKjWtpMol3biiQc1sv3O9jFt1DPws1dNBycO/tj9wvboV2XIxWXOX5x2317q3COzqXRH2yryPuNK6iOzoW7rG4AoPu73iqES3Yglb5RxlCY/5e+LvecOJAnoecl/T9+l3nOyYXxh3XG1GclVFkn4dDVF/XBsdNro5eTze5YMUBhxLKQ+dmnzXchz73tdIrzya1cRm22+lcOCotDX67C391y7w4VTR73TuUZxHBaGcuKyq9BIB6fgSajMzza0PXsX3CVCP9dh87T1BVf9Czmt4yc1b89i56C9PC8IltGiZPfzaP1GbdJEu5LXqE0zu91cXqtxLAkqESonilLr2yGt6mFTPUcNcFVg26n00JuO7SnojHWAjEm5u6A+sf8uFtO5TjVyx4Hl1TOX+jXnNABy5cM5X02C2tDNuEScEAVb/VQT8Vj2ybJjGJ+yUmq4pJvLXBCYsLFn5XxWERbyjDK+SHKcMqnuRmxfkwZ8WMCwGCTmYp3b4h9XZ1J2U+5NXnjaGCUE72MRLnEKXZQBbsUe+qO4Eo9ddduLgLgRirsU7PrG5Tq7B6TOP6lsTax2a35biM4nBElZUqbh89jpUuGnSR0BsWzpBqJ6uYFL4YzX7LGxxKlx6/FYCKRJ3kmMyxiqWO2MfYinMw6LsVAKp2OBa0RkDHJgZIExbqtlaFrY+tVImdxEK/Ya0IrF+sEbAiwO1H36PEh1VFVvVqKhYzIy9gltXRctWKWzmiVtzniRWUHi1i6uIh+sfmTR/UwaEcS/DcAUJSkUmrnp4y53NrHTH2q3Z78HcOpUc4OKijebyIVKsooK1/UEK4voX2tzyBeCKQXtLOQh77D6Yxe7ErHrN+uYFwa8d4FzLRcMKIisQu3jS3Uq8v5x+cOCbnRwEqvo+qwTtPzGH6ch+lbzmL3M0G0l+iInDLLHJVYVPHRpWa7SKTVVmeR/WbHhCaV+EzN5E8sYiDhzLw17aQ3p5Cu5XGqX96Uc4topc7HshyrWQBO3g9qDQR9PuIv2j7p5RmTjZBzdgteT3f2H5UawjTKRx8yyk88ys/Me7JMIl3WuhzIrDURD6nNXnmiNrcBZTcGK3CSqJvBAQrwHWfoaPiS2O37bSRjLJ9xyVGXRA6DuSOagy4r9+rx5av2zGJ7MxUGyGdNkm90XCfv24IK8UyYizD557HKtshMylmfdPtNm21NrIx0/NRnQh3vB3F+4Fo4IhasQNS1bZtXETtMWMP0zKX1JvW3a5v7ys+n/XzLVudtuCtNZsQ8KZAcig4viN9zYk7RoCpV8wI0GVxMnNl7a77tvaoEUxKlNpS7KfInNmfebYm7pQQZlMIp/LCrJFQYchra/BIOY4FUX+sZxsU82shpl8wiT5vfedu/2E3WeEywmKB2Oa4kbthKMYHD5uKbm7VWvE8U0Ps5tZ4twSXLWABMSvT08/vwyvXhrQu5P5JpxCUmxE1GSnz996cM8c5eZ6Pj4na8NsbE/A6ibc02FMp1TFO5A4YkUqluwCPPuBQg0Wd2AJNghK1fXEfzm61UHuiCIj4XhVH0P5WoasOqKYGDBnKajSx84HtVgPHVXyt+NJQX65r2M7fRYJRY2jJo/0nttdJKWM0Yo8AXCo5qJxqdVU/4whpqPAFKWOiGkzPU12AiN2OHnsIf8oIGMkkn4ob8E2wInYpzkLSFVayfa+yoFLxK+1RdXxu2XepFVSPzZ52jCKVYivkoQBdxJxcoStXQMX9rpUMqeJaM3v2t+p9NbrA5D5TSdTfdQLJgxYKV+tSEaRIBlUvpS/WHofS1zlmYr8znQcoNpRMojdXgH/ltgDj1Oq6HHuPleEgwNZfew/mXmpi+8kMVrbLwoBc/MQ22ot5xF66IcCw89Q5xA6aIgbFCq5Q/6yasly3NL0IYuguFhFjImGmgNReF/nrbQQXbe8og4JcvZ4IawkdWnq0Y3JN+g+fhv/abTmP7tMPInF1E40LR5G/tA8029Iv1cvGkCiHaLz7NGrHQlz4hU0Zg1B7pZX6KAkRW4Vl9ZrjQqGuUhleyfZhO3RMSUZwHOdngUoN/flpeBtNeOdOyuuquDmJr7LQ6iVZCG4vJBfw41RzR0FOpFBsE5QM/e76dDpU2SEQy3DbMtyEnHlxsP3RZzTfIs8vO9fI8TnMmjH03uj/us9gRPyIwWeqW1W1MbCWadyt1Ctv0H5fq4vA47Wf8Zng1TOy21f68F29rG4fqs45akPmWu+4z0od33tWTm0v6kjR9C5gqi0nBK12XhgdP7dCK88XhlUDjuZfztu6LW3JQR+dx0/Lz/VlM+65SwfwyKoZGkcHEEpVc3dQjeWziAwZe59GWhXc5uNHhtjp8R3zTKSqfFBuIFNuyPNb3t8agHnVi9D5N3qWLk2jNW/+LqghQOEjSegNjZejsWHZT3rN2BNLT3KX3UWVY3rVdnMJqYLm1s11a84mceSjDt3Y9e5lJTuqpGaHqq7SMzw6Z3L/nE9tMlp/W3lsBo1Zc2wv/Iv/afgzk5jEVygm4HUSb2kYWifdrY2KrKmu+iIQRPAhINa+NqiQ2iorJ2v+X/v5+HDlAkcXADpB8/cWMEVVWwLXMQIaAhqkYmR88IZEnxSE6ZdSsnRRoFY9I/24FMjw7QQZ7dOdvB0hDnQbUnEmUJTJgYq5pcOhRYzrfyr9qa83vq5HK4+F1c5UEv78HPr7B6ZSSuDD1+2CULLpks23lggEcOp76wJ3W8WVjLf1HhwVXor6cyPwP1K1dsY+ArIKhhXEOqEV2qHPudVp9vjyc3b77nsFaBFA81womlRvIXPjAPVT00juN+FfXTPXgYsF2zMr/WIEk1zMdLro31g1lWb27JbL8Hf3rDex8Sj2FleAqTSC2ztY/pWL6F84jpXf3pdFUeJKXcYsRvVIJiJ6PSS4H1aheY8KbdpS1nldMkmpvHoHh4g1mtj7puMoXmsgfthG7MqaVL3VO1c+y3vaglap4thFstCSZ6bgVaqIv3wTjXefkeoywTor39wOaXD5G1X4tRYu/EIX4UEpoowrW0D2c3zZqARrEimZMAkGVn0pbMVVrOPtK2PF+5Z2RRzDyzfQec8D2HxfGkELePGfTRY7X3VBUbJIYK83eK6yZWD3YFDNolDfvUSOnL/77oKheupqOXbHWejrc4X7cyqEEvy/WIM5FdTXq07eS4BJj2vUEzWqEo8cOzfl2raokNIoELSaA1GryRuFozMQ7cntY7fhK0DR/fC4R+nOohsxrGA8tJ+7qtD2v/z7dunX9jzuCtcezjmWCJSOhltpdMSZ5JnDJJqrbu8g5f7xxaHPFV89HIDS6ANj6N8avCcpesck+ihteXleUhyZZ28OEt0M/sxnMinLur0Z0ycqwXt8REArOpRMGsHaLlpnTsj/p//wpjNmzngyiVu0gLLRluSl3vv8UrBJyq4c0tohvIoBy61zZkyStw5w5JY9f7Z6OO0ZIT/HL71v2BOcjgPpOAIKRXFcNGHjaoswlOVE/PvEMSRLPRSuDSdkJvGVUhueJIM1JuB1Em9piJXJPf7guODhl09wRIBVrRmFWE4G/BKrlIYBT1wYqCcsKZbHl6RyJAID5XA4a84FjfY9iVk7q7fhoGJIMQe34hf1wzq2BKoYrErBUk11Mtcj1FxZvLn0H/sZoXqOLIoIHOTcMBChML/oW/EdsxiRxZCoGPdN9XRIZINU3sG+Qru/aIImgON4OSqQ0XgMHTrBJ6nT6qMbM9VTtdUJbJ+s9q26/rqcLCleJf2zdgGp9GGp2Gl/mwo6meqrLM70/0JFHlwDed1VlJbzs9V3hrXWUfArQ2Gr6roQ8gnsfB+9mTyCSkN88sJSOaLKRT2zI4smqVxTMVgWO9Z2yAJkqTby/De2Eaxb79ogQHs6hfS1dQFu8rkO+2J94ORRhJs76O8dGJBo6ef8HMdFFqDpFPy5afRvriE8voT0fg/BK2axQxAuY8V7wP7ssarOqnGzheZ7ziL94qocZ0i68eI8+kcX0M0nkb5VkiqoLF7Zi3vlNnwVB7PUeG9m2tDF+PfEY+lXTSWHCqYE7pkkvHoLzZMzSF1cM4kG688o50MfRqt4Hali53Mof/MFFD9xFccveWYR+M/G/ulP4h0YBGzqtzyUpOqOsWFhqM2VG/x7U6aEBb6xklmUU8k7tm561O8KFfwb0jkwdH+JSJjJ+XuORJTsM9YFrmNVi+32lUZpPTxl31pVtdU22UQErF+nd9StHN9L1CoSpnIqyC5bx45ttBe1gBsX0gYzLHo0sGezzKd7HFNUjXTPSxSkR1pLxtGCXeskt8IbWc6N2MipkKAyYLTSbn3K9Zr5a6aqmNh2VMsj4ULHVmnEaigK3q+lw8GcoZVS/p9iclqjt9dXnm32+vePGBsZv2HnMetT63q9986aqi0FnOTznT5it7cx/YlbA/ZSVPG3FWhaG2myOZcC6PPK+15eczzR6y3E6i1pwXB/l3zpdvR31V8ySsu+akjoZ1lhtX8btYfM/rIvbtwNojnu/JJ7hYw3c6z9xWmpMqdvHxqlZ35sbsACmMQkvtIxAa+TeGuDvYSkPrkZZIrdlM1EEPU9amaUD0/HqkAWRXywEsDyAW0nRv+garzRxKbE0qwiOx7HfsdZBBgw50yiLjC14EcmeO1RJXgQEaLEoPdVf6fbdW0B3AnU94arpo4NgNJsI9GiofFSqqwBrYOPD/e8emKR4/QdKvDTYyGoJJVJKVwa7nG7lQUeT9gFqtbaZyT7biZ/7YG0C0ntdZWf7fYsEI1sb0Z7fFlBjI5zQBUWMBj1qw2ow3yvVGPdKrYuQridSHAqFnnMCoi9sQafn3Wr7zwmq0ot1WhVUnbVP20PdDQG/b54ww5Vg5WC3uuJErDcv70+/KPL6E3n0I37UfXIP7Ikiw9SCUXFmVXxhXn0p7OG+sxxe/iMAMz0Fec+4PWcn0XIhVc+h/ojy2gVA0x/bkPUKQW4ku5MoMn+0oMS/FIZcelTdhaSrs0IaZKkKff76JESd8f0qYLJCQJNnjv/Nlfm0FzKIvPsDlIvVQf3PME3/0a4zWwaHqvg3Herhd7TDyOotlD8/Jq57vOz+OirP3/3/T2Jd2R8e+FH5Lu2NghbQZVyR0EcwZEk/5wNUAgtokeab96IMm/sgAmRMaq9r1e1VOqlVmVdoaRxAG+UEqw+4/xK2PNwwZ0FTBFodSnzrmc3Y6ytjqN4fK9w3jOqri5/S3o8PFftYXUt2pxjkbDen8OnbZOTNiIAxtDj01+7YoSj+gl67uNEmgYbH07ujlY8+Vx2W3/GCTk5yQ15Lx0EtDKt6v9wkrd6L+r9oFV2t0KuQeEntkLwvUrF1pOXRHpiSKk4Cqv1INd7jKhWfHV/pGfbUehXcM65bOcg8muVecK911VzgPY5THyP+q3b8+0vTw/fz1zb8N7g83vGgExqLsgpXS3Bs8B7SF9E7283qeB5aJ03vb/JywdDCYXf+9zP3j2WkxhRG36Dv/UvM97q7b+TYgJeJ/GWxUeyPyzfI6Dq0Kmk2sqHogtkZCKzFT7NQvOhz0mclSC+j4DP9maIxDwnCFaYNCurWXlXJMkK8pisv/YH9cz+AwuUOKkovZmTjxVTiiqBWrUVYGABts1kkzJM6m8kmORk58eBUlGVfaMFDcNWXc3HTeWVX5Fokx1LFwCaBICh1sq5KjhzxH2iXlYXwGql1bU00vdwscHxVeCm10wTBtE5GtAa0Z4V5LkLSodaLcdrwenQ/WG3JWDSoezJokVVh11hIYKoTmtgC6TnMgrQCR6tUJeAVHschm5slZUtvVfe0+nAJ+291Ub7XWeQfPnW4HNKZc5n0Tu9KAvv8PYGMJdHbHVXvGHj+wWEF6/Cn5s19hWsAoSh9NG25lPIXD8QCppcUwXZLu2c93ihIPdA5nPXkF6YNRQ4/g1YloFQh+X6WgEVFRdzt2XHn9VZ+g5mLu8K1ZisBglWAjjMhxVhPtBSJ33LiPLLKGsPeiJhlaxDs+hjxS2XlT5h/5XbgwU4x9hS6ybxVRL3UqZ1n0Ha/2o9oofopBT1UjBiq1RREBDr36mrX6DhLq4ZLnBQoKC9sK6i8V3H6Pq+2rlGfr4bHAsYqlQR1uzfiBtuxU+FmVRN/l6A7k8aDmgJYcWWJIlrx9iqxsvvx1RFx70++togCRgb7ld9I+rvuBhV6Vdm07gYpwOhwbnLAsrRpMWQGr7LgpLP2fl71KpIg+0P/M4xrI2hwHJ7KwvyzFNvWLZYMOonp5D5Evm5QOfcinyPr5cigEuQGLjXJEoGOOJiSku2qs2xq3fuvg6vc90i4Mrzny7Cb1omQC4lFVIKMHmjyXDb4uMJA2JEKE2LBENjYPafvLzhWEvFIoA/iUncTzEBr5N460NBQjZtFgP0HGUlyqEiDi0mNFPJh7iKU6j9yyjw0gwr3x8JVzgTmFJ/1QOWD3IBxY7Ijype2l6U6PXRiVgBK4OTUaUq58HKMr+oQPuGoRNT702+T4dw3MKBk91Iv8+QqiSrxhxfgnSOu6VmSyi442JFlX3dUAAb+R469Ccde1by3EUWqcpa7Xarty6Q0v9HpzmosEb7snReF9hGvVHu+6k47FRFte9OVIgtfc5zr5/2XJMG5yps+m0DfJlUcM5bXrP2DYnnrhp6Gavx6nXIKma1jjjBMxdHuSwCLkqmCojvN4DXbgIPnkV7KiWm7z4VeTsdBLc3kVmnJRD/PyKy4pjTC32b56d9r+tbAzAvfyPGdmhQwfbHjrM3TRsbTxJAmZfWRRSKFhJRL3Ozg5D0Zp67XVzJ73QxpPeV0NO56LFJEtl/39DarMev9OPGYvjozv/n7vt1El81MZYO64oCjVJIx20jnZTq/ZAakGvtMfrZUUqoglZ33hj6naswP6YqGjEu7P9ZneKzkn9vWql6vXDVct9MuO8dA3JH/U+j5ymf0fY5oSJNoiWhr+l5jLSnuNRe+bu9l3ftGwHue53jOLB+L1DKkMTnSM+rfd5FFUZ33ni9cBIIWnWNQJ+yhdzxHAVgbg/uVNHcApYeC/rFbpgqKu1uUjsN1J80PazxCq15ekKhDdb34W+XhudAa2lkzi80au4aNok/1g3Asfgz7gXDPcRGe8LpIeexUYlYk7KcW2yS0acwld4L7li6f5PuPKFrmxFLHXtC8u2ja/9i/DFPYnA94KM38Xl922ICXu/T2N/fx/Xr13Hs2DEsLlrRAid6vR6uXLmC2dlZzM/bHor7MKQqyV4pq4zqqzWHBl+XrLXSMvvmNVmQOAb3DD7Hpdppq4ouNVKUUq1FjbzXglaGW83SBZbrLztqs+D0jUafpQE7F+06ORO40sKGAIf0Hq1iDVF7vTdVVXU/J59RKvAYhc6o6qriTur16VQvWR0UyjBfIxhRoMb+YZ4/QQcz3DqfqyryWEVkf9iKKPIudGlbvYEQk0y+DmBUOvCoorClOQ/Rhd3hcUSrxsr/2/1GoFepz6SD2deGgJ4kPMx7IpqfDqutlAv4ZYVUvHZtb67tz+OiUYB/PAZf6bxa5aaf4NaeMAyk5zWZwO43LWPhcEFUi4PUnAGuBHe8VwgKXREqe4w8dqn02iSMimOZXm2bMHBp36SGZzNGSClpgfZocCHORBFZBO0O2ueWkdiqiK+tAFRS+nkfW4q5JlUki6+UfVUrtVR07YMb7fuWa0W/3XGVr0m8s8NJLEW95vxb0d+JaEz7LuVUt9IqIjLRi2RxMN9iq35tWwkap48QKY0PxIRkW7oWv0toyf+TAcd6XUT3zLb+lFWmcQBwtDo49Dvnc6PVZvtMHKIQ2xBQPTKvSBJNfz9atXOP6x6KwveytHlT4fi5DokwyUsDgHivqmL03HGPL7oHBnPzWOsdbRkZmZukvWVUBEqtv1yhJb2P+Vy2ibpwcdZUXG3FvfT1xzDz7C4yN1oDQKjbVT9se4zGUi5+d6Ll9SqXDqCU5/0IuJdjdVWleYzxAJULhjacv2LFHjU0me+wk6Kxddudht7v6E5oWLE+xkev/i/3Pv5JTOIrFBPweh9Gt9vFd33Xd+GZZ57BP/kn/wQ/+ZM/OfT7X/mVX5HXsta0++u+7uvwi7/4i0g7k9j9EqqkG1FEW23JIIofJTOJUq2x6q+68NFeylGlSXkfF9MjBuziAzpQo9UMZvQA1++qRqyf4wTDxXvNodbq6wwFuvYB73HFQZBRb6CvNGXuT/uQHGrv68YY4DokwPR61hIKim3v7BBAc94rmXrSURX4aP8of+C5cGJSIKeWQ1rxVGVmXjOb3Y+AnC4ieXzuIsWCx7t6XBlazXQpvCqGZPep90fUN6uiGkrjtdtR65bonPl5rVDocVpqsAFclvasoFaP3Y6DVAoFsPaN9Q77SPlZihhpPxCvuVLC+NlK1YwFExqNOvoX9+DncpKoqbzvBDpZHwt/uC4AVxI2h2WEKmoltPaBT7F4stbr0X6leqlg261GO/3EUXDc7HGNAldvacHQHmem0DhZRHM2huxGG8k7PBarEGx7pBRIy3ipcinHlaDeMhKUWj3EGGBvndgwUYF7UFX5nd1/NXzvTuIdH+7fWKSuOyZZ4s2O9OIJa8Z5nuhzOlJIf52KqPuzbi8WoHXUKLMm1of7+AQkc3NkQUR97k511PWzFOE84/Usm1dLET7T3khYyY1x772X0vE9thmN65iK3N0JOJuwk/2M0K9pq6bjJIrydlxGznvceUTg0v0Dd+1v7gFw5XMqsuSKHmmM+ug6/bh3PU8iuu2wAONdKsFM0PKDjbvV6gVAMpHngke+f6Ty7P6ez1A9ZiYh2w8dB2azSFzZwAzVgmn/xHCr8aNjqB65o+wATXK6CtSueNTosTrXQsbV7R+OxVB93HiFFy7uiSLy4LwdT2S9Z9z+X50zVVjt9RKMOtfcq0I8iUncBzEBr/dh/L2/9/dw7tw5qayOxq//+q/jr/yVv4J//+//Pb73e79XXvvVX/1VHBwc3H/g1Xlgaz+koUCZhZAIGlHQieCBVRtRBbZAUwARQaXzENUHrrsQcOkvGpp51IpsPCE0n/pKGumtFnrJwPR1MNpthNP5SFEvyq6qMi4tbdJpsfaRXTuqv/J9pCd1LDAdjTHA9U29z+19GaUf6TiIarClWEfG9gaAiPiUFZ2Qap3YFNGjLm7OU3qGutL3yIWdSyWOfFqdRVRE03bA2JBSsKvg6VK9LRWO+6EatVQF6a/Kfk7tj1YvV0eFUpR1lVamCzN7L0V0YgvoI/9YWx3VPlmpCmqlWEWbtLJsq8cCdrkwtyA4Eu+S97LX04o+cXHRDRC+5xHU55PIfv4mch97xQ6DpfXqWPDeYCLApWNTDGpr+64FmCR3VEhELYy4Da0Y6/G61Wx7/JHqtVR42/BabWSeu4WMVSg1SQhH+ITXPqImG0E06YFTcS61Q7IiKdEi1kkAiEBUS/1+J1L+X60xYHc4ibSRdgNJ2CjtXK1ylL7Of3QRrck/9TF1EzP6OyY3XTs0hjJrqKJ63gDlzGoVngVFYVJBmPXk5N+0AiYFzlR5pfo4/9QdWmd/lCo8SrN9I/ElVzU4GqA3psBGibsxIc82V6COoeCQCTf+7FaLlS3hbkPBpZsQ1veM6CfI377LComSAGOOTectrSzann73Gg4Ufv27qbystjv7jo5nxK/1rhhTyY3+P842aBzwHU2eqI4Bh5f9+wy9t3f2TZsQv0YT3K8XWgHu8zk7vNRWADuULNHj1jWQ27bD/TYayH32uvFxHxWnUk0O/RtxAau8pqJiI/O0bnv0fQzOVyPHPYnXudwTq5y3NSZ35n0Wv//7v4//8B/+A770pS/h9GljzO3G3/27fxc/+IM/GAFXxl/4C38B92249NfoZy6iBxlx6X+NUZwmP2wSr6H+qgQU/DwXRVTco8Iq7UMIaqxYkVRzVTlVqaLoIFjdQX4zhu7yDJJrJYS0RMkk4B/WzeJGq7MpAwh68wXTv8ggwM7n0a9UBKDSQ1XA1N5BRBeOqq1fDgVrdNw8S6lWED+qDjkutLKnCy1H2Mh8dkCxFX9aJg7cCYsgTRdx2k/Dc5VFgVMhUNq29jH1HAXSIbrSiD1FtE1rjWQ9B0Mazo9Ql3nM4oPqAODIZkfBKifwEeudSCiK4VLBCcQc8B12HJrxSEVTPsrfOaJTupBU9WMRagl8BJduIXPZJAeGxpj0bVaiCMp1/FwxqZFkhOyT2+e42IVJBFyVDub0iOm5iP8rrzcXj9YTVoWceI+619IA+O6Qmra83/UoVpBrBcgiuwxeZF04JgmUTa+wXP+0sVv46Ob/eu97cxLvyPhI7i/d83d3UcQ1v0ixMfWvdryopVfTDbISnESNvEeTRmTnqKdp5FnaE/aAbHbG0pZ7Ifop8wzzm5YpEnNoy/Znj9tXbQQbnHvkc0qBdkOfoW8GsI7GyBymzzk5ntEWjXt97q6qc2x4e+7qTecJV5xHhfvczavPtCYF7TMs2o8+40dBrgtWx4TsR/UURk9Jnss2+afH+nqgfoQ2/EbCU9H/3STDGG9Z2aIF/lG1U32q5dnaHn6/3i+uB6yGAnwywEbZA66C/WhifYztUBRqO+eM1WDevod9VHRiVjPEZZC5lValBsu2RtqxRgUa9TVShm/80/HHOolJfIVjAl7vo9je3saP/MiPSFW1QJXRkVhbW8OlS5fwD//hP0SlUsHt27dx/Phx5PP3n//WR9I/9MY9N67HHFV6CWCcEHEKpYaSVplOyWKmvzUwKZdeJbvIkAmJlSrb5ydZ96niEIXKp/w9t2V7ACPKsQr62L7EoNEUewTZFmxVUve5M9j/Xf6rcuDOJP+nAbMKOl3Km7tNBbMKyLTyKIuP4XGNKLRabbOgRN5Dn12llGmfsVoCKehVOhUXkVwMqRKzVgg5luqbOurH6HoWumrHFgCOA4zR51QkyAWiboWX58xr7Qyb/H+cwvHopOwoKivolc+qvc+QXYVjf2S9f6VaqTRKp882Unt2QL9Qi0VEzH5e1Y0dqrarFD2kvhxV0x0/XL7Me7p0OHgfwTE/zx6scbYTujBxF4ya3VdamvYY255oj/ayUim2C3/NwNtxR8f6GNs+WV10TWIS0d+jw4aIXrMVz6j33qWZ2ufCXRZbSu0kxV7+Fs3fsl9rw1OLlAiMqOZBaPpo7d+HeT7Q9sx6plpAYpgY/XtXXcf5wf4pYghEKtCU43WA4z1Ult2xUMGm6P38Ptqn69BGo0onx0cTYe5ndY7V41BQq5Rw1W9QHYah/Vg2lRtjRKGGQOu9YpwH7+v1EUdvdZIUah/3JsSwhj43avvDw1V2lVRGHRquez+ozQ8f6xTfc46R1m2ybSscGLXd8LFLYT2H+SKh19jpj43+Lkb1Juw5jqvoyjHqPeL22jr94s6JD+tQuPv6U97nX+uCTfx6a/cxuS4aE/B6nwRphj/0Qz+Ev/yX/zI++MEPjn3P+vq6fP/0pz+NH/uxH8Pc3JyIOv3AD/wAfumXfgkJnXhGotVqyZdGuez4j97HEQErm/3m/4deG0PpGnqPeFI6BuHplJiJ+5KhpPF81/SVKOWGk6xO5nbBL0I9/H0uA1TuVqAcC1zdavOfgBIcHaecC0ZELAZiTb5mgkf6IF2KmRGPcICrVecl9Ug2p+A3WgB1pBouizoFulTRVXVmtxeTAEx6JjsIT6zAK1VM1XVja9A/60r7jwpIuBVU3b+cmAG30e8U5JoDHvRzjVZFo6F3RLjc7L47MeuCw61guhVcrXhy4WD7hnmuVDAWdWyOD8dJ+5ac45DP6iJQx04SKgPgKgJKYyhnHL9IDEmscNiXnDTnSXqzvS+8mSnTc8vvXHBrH5wj5hT5IeqiTKsEzn5l2z7p1YGoI8s14iKY3wVos+fYXjsuvlhFlnN26Ibav2V7vT668/8df09P4s8s3hHPcvfvzQqRRaGCSwSN4yzF9PeqI+B81lPfbDJ0YgF80oK1mqnVVbZ/EKTKi/bZ0emY/anNmRujCZfXE1ka93p4j2rfvRb/I8BqYIEySFDdVS3lM3x0bh9li4zuw7aHyHcFbs68KEGF/IKhdvulkaqpbe8xpzxse+TOb25lUJJdbrV61PrMjVFq9ei4vgkV57GV4NHrYF+T55eCQWtrJM9+ak0w+Wp50UOWNKPHGQlLOfeMJv1SFjDms5HYk2gGaGVXP6fnyed9IoH+wpQ53H2rqdBqm+epbbWKxsc5F2W+DB2Le38o7X5E3HDoNVcvxD0ufY1V1zv/8u7xncQk7pN4a9MEk3jT8a/+1b/Cq6++iu/8zu/Es88+K18UbmK19YUXXpD3BPZB+Yd/+Id47bXX8Morr+DixYv4rd/6Lfz8z//8PbfN3xWLxeiLCsbvqFB1Uw3tgx3KZtuFuiwA7Hf2NrGay4c5FynVunhwmveHg+ykii5xfAl+mXUmGEklJSMv2XrX0uRe4U7yb0Q3c4PHrl+2+hdRUPV1C5SNzyuBLCmfncF7STXSxQMnTLu4UR9UCQIhV8VQq5MK1Fld5f+1OsFFE2l+FDWanZHfEzR5R5fRPXdUgL+/tmWqi9u7g/5Qt5dG9z1Ko1P63iid2apsupY48qV9l9rTSvDlKpBKBtwxhXeVefU9UmV3rqMDcGWhphVajqld6Kn3awSMHepudGxciJAV4PSimUq2octFitrcLqvd7Efl/UZaLntUjyxF10OUiK0lkIBcEZvqDCof2hPGRQ6vP9/vqrTaLL8RQ3EWQTwGrXZpddX6OkolSxWQrZBXpHKs58PtOEI0KkKiC8A309s3iS8/3lHP8nHg6l6WHON+b7/8dFq+wBaR2WmEY/rwvFYXXtOyQpxnpvn7G7EBU9aILvLfRAyxMV6vKqVzlTMHDX2Nnq4kDXvmeTBmXEy1bmSZNsqu0PNz55sgQPfEorTJRMGWmkwa/aU59I/Mo59Pwd/Yk68omCCgEFDXAXZMnOp4ulRczkX2d0OAW8//XuOkYNW1bNEErBXqi77sMZiPmZ+HjotsIPsVPaf0OTm6bnD6+McmCBx6+2hSw8yzA9ZRFHw+zxblS+jajjiW25c7NKfL9THzib91AP/OjiSVw4NS1AMbXXe99pGIH3tzg+HXlAru3mN8jzow8MvVb3ijv7173KuTeP3ohd7b8jUJE5PK630SnU4HCwsL+PEf//HotVqthv/0n/6TUIV/53d+BydOGK+xH/7hH8b0tBGrOHPmjCgTf/zjH8ff//t/f+y2f+ZnfgY/8RM/MZStv68XPaPxetRbtxdUQZ7t/RN6pdu7I7TPEVl+mYwdlVsuxgt5I2DE91uLFG7Tn52JhJvuinG0Kt2+gMPXzxNFFjjR5gYTrCsEJe+zVbBBlt9R9Y0qvoP+pYjKqrYMUh21qssu3ZdAPp8b2MCwUr23j/Dhs1LZCC6Xzdhs7yLYsACa4+VWViLanqMu7Ij+RDEyObq9c0qfNac2UCEWKx6tMiql2PEHFEArH7IAXum9FoDKz24/NKnjlsYryQt3LOx2pOdWxMSMGrb08jkVY4J7oYw1dIFgx9e171CBqMV5YGsH3vyUWeTkcyZjXyoPVJWVWsyKVadjFu28B0mPJzDl/acLO1a71eLB2tnIOMMsPMNghPbHPlWOAQGq9CybqnN//wD+iaMiTCLHwWQFKYdKzea+KP5lK+66aIwsLHo9/M6k6vq2xDv+Wf5G4VSG/MUF82PaJtNc/243NKGji3IVknM36/b+aUuEUodfB8SOFVIaa30zxtpsXLiV3dcBwXftl59Tn09XZEgBjAJYArOp4b7i7rxpQaodTaP43Cb8Sv1u+xYVyhsjguS+Ls8B9zhdETd3DEbPbVwv7+vQeofGUvy6RyrNtgIZql9S1N7AhOAYaxoLtEfZOq5Gg/bmuscZ+euOJkxY/VfK+r5lBETAd5D8vKt6yoT4nFHLpte2fN85GBbWYowoOMv1HaWH67EmqNVh729XMMtNJNvjMmPXH9a5cIX/JqB1Eu+QmIDX+yQIWl3gyiAt+G/+zb8ZWeXw/+9617uwsWGVcm1sbm6K3+u9IplMytfbGm92Mn+jeKOeUU6wqrDL3S4vDiv+aq+h+sO6D33JMtrJX6tu6uvJ76w0shKr4jf3EKSIYlSNMuprsqDSBdqjgFs999Sc3KVlRRRpVvqcbbjbd9SGdeET9ZXxi9VkFasgGM+k4VlVQulb5eSXTKJ1ag7Ji3XsfeQsYs0QXv8YCn90xRwDgRrBExcOqgRaqw8sYOSYHJVh/Zmgb7TiqUDPigdFPaO2whn1j+pHlJ6rn9cFBwErq5li9eL0hhJYS7+RpbqqkrAFrkoXls3x2LQyavs8lbasdj0RXdjtbeVnef6u9y0rKaQtqjIlFz1SGbfVbQo46XkcVqSvmuPpH11Gf2NrCLT7K0tC65NFTjGLfi4Fv9o0iyWpNAwW5d5IlV37v0R0SVWae2ZR369RCCcdgXomZdR2QRI/VrV48DcmaQNb4WYiwt5HdtzfNMNgEl92fCWe5S6QGis2NA6EvdneuRGapz89ZaiX/CjFcOQ9zmZdCxzdvvva6Hyhi3R+V+0DrfJZgHAv8HovBeCh83JB6Cjl2LGFGTz3HeuXewg4aS+9/MxntoJW95x0LtPtuuOhbysZWnb91BQyl3dR3CnfDU4cuzN9RkfHN0ZcyP2/WxG9pwjRG11/Zb5oopbPS1dM6o2249JyXa/20d0ouFdGj/bok27ujxyDM78OAUrZR2At97pG0d1NujIRyeenTfzJNu2aQRLp9pr5dUuJp2VZtQkwQakUehdUqmIz5yyK42k7DxOoPK7Alwq6bLMyqPj2Zpm8yCHYtQmJiEFD0G0TG1W7v3HUZFKGJ8J7f+LowZevtzKMB8MkGBPw+g6kjX3/93+/CDU99thj+N3f/V2hEfPrvosx4g1/oniTYkf+wvxwf6ULEun9xxiV0HfFChRkWUGeCPAqWOWExQVEswW/WDAWP/cK13ReHzSRkJJTnVUwK793H3gjiwu1vIloyIOFxV1ZfCveJPRft8eUExUVg1lN5sRKKjAnXQU+mtUNQyRfviXbnvmNlwc0I06UpCVbURMxlmdmmZO9W+0Y7Q/SyqhSbV0wKgJJji2SBV+REJPtQdWI6MKOR565robu7bN/q3Qo18f9XNSz6/r+imhVYjBmibhRvJZqZtwsTni/8OdeHz7fy6on7OLOeraGBIEqjsGwXsVSAeWYia9xK1LkVUEy13NWgCPPgT1801MIeW8l4vCZKNjdh7dj6Os8/mDXR/vBo0hUrZgKK/CO8I2ML+9ZoQKbBAD8gQ1QZG90/gQqJ3MoPL9lRMsScfSWZuDXWvB4jbm/2aJ4HsoCttVG99FTiL10w4yPqphycZfL4qO3/1/3/nuYxDs6vr3wI2/8pnGVyDcp+KILcrHK0uqW0ittksTTnjz+DSqoc9837jmqP2ti6h7HK37jfJ7ptvS5ei8QpM8wTUq5oMdJPA0SeMNWNJKYG3n/EEjWY1OvaTfcZ6xOjVqN5ucs0Ips3ywFNfNSffCM0FBdAgX1o5VWh7FxL2AqlUy3DUWO2/5ulEY8/EFH52BgexMJDek58nx4bO6YjdqKaeuD/O511Ph1nNQ7VQWTuO9RgUON0eQFP8dxYzV0xMtXtqNVUlXP1oQlt0nmjAOE5T5m4lyrqZHNjd0P760RyyBJuCaT5pnvWDwxOksFBDWzraA84uvLed62qUQhiV5LoS5mI+o946OX//Hd4zeJSdxnMQGv93E88cQTWFoyptQaH/nIR/Cbv/mb+IVf+AVRJaadzjPPPIOnnnoK90t8JPvDfzYg9nU8U4cqrJbCCE7akZ1Lxy6GbKbUtz0xSh9W0KTZeAVqbs+sO8myOkkAS8BhbXOGQgGzu/DR6rNuR2X1Iz83S/20ipdjfVzH0I0jexmHAhcBV4IeLsg4uUUA1y5qhE5nK5OkoparUZ+PbIsUWWaBeTxc0J06An+nNACt7Dejyq1WEl3rHHexoh65qsirwFUBZJT5HuMNq9VX288aUZ51kWertCJ8RBBIYMhJWanJrBiqP531VY2q11bBWcSPbFVWdt9qw89mTIbbXn8ByuKLa61gNOOt9wlBKi2bFORSoMlRSZVqjopXsTrM+0crZirAws/zc3zPnU2zzblZ0/u0XzL3Gy08uPBh5j4MEf/SNZMSsWMqC0iCSR4bQafcfzYBoNVitQFhQoBCTJv7KJRq6OczCJMBgs0DBDslm+DxJUnjEQTPTCHc2hXAGr+yHtGm5T0nVoAba3f3gE3iqzresAr7pjdkQSjv97Sh+wtIdd/CHlZXGZfB+1cp+aNzg/S6Km3VPseHfj8i3CYiaZZFcFBy2CMW3HjOc8d+j0CZm7iLqscmOSbPAAeIjxNoi45jpAo7Cook+Kxw9+eOh36WX0pV5fuTNgln1Z0j4ML5ROdArRpG27I2dPacRHBo6PwcyxlXX4ChzzY+f1VUKGITjZy/7d2MQOtodZP/5zNv9DyHxs21gRuuPivgFq9hDY6NMLQGXttDCuk8Hq4VROBupKfYAbvRIdgKW1TR5bxZqw1bC+lcwH1p9ZzXptmGx7EdFQvTcXDZVgw+y/n85ynOF+ArOOXt1u6iedT+Lm2uSWr1cAB+tXod+dM6ljlahdWYPMu/rOiHvny9ldGfqEBHMQGv93F87GMfG/v6N37jN8rXOy6+3EosN0GP1dEJXid2V23W9Udj1pEPbZ18VNyBk5RWLa04TvQZTmySQaV4glKMrI1MMQ8/mUB/1xG6GK28unYIAmAdmle0AGJlsDFEf2YVmfRRLsSEShwJj9hDKxaMorL2sPpOVZKZa06UBCv8mWqcnCR1oaL0aQXLrAYSAJJC7C6itAp6dRWYnZYKAKu24hmqAFQrvK02+qePwK+2Ikqx0G+1J1UpulzUUSSF+27rscQGmXO3WjpCGVZfVAV/+n7fTuhS4eR5utRZraTosbB/11ZXI/EiBdU8RjvJqy+r3ifa2ym/076ixXn0s0n4V26bRSEXa1yUWGqzqVSoEq9VW6WvbqMhFVX07Hs4rjdXB4scXlc9DgHibWOrw+ORxZcjKCKiVcZ/V3pceWzOQk8q0Ik4WqcXkNiswNOqQLOFynuPI17rIV5uI5QFnf3b4Dn8/9n7DzC7srQ6GF7n3HzrVs6lnFqtzmFyZIbJBGMbDAwwDPMbgzHY4A9swAEPBmNg/g/8Y8MAgzF5gCGNGbpnenJOnVtqqVuxpCpVzlU3n/M/6937PXffW7cUuiW11Drv80h1w8nn3L3f9Ya1iqVGJoMAWhmQmerp7oLXYYIcWFgxxDlxj9RNa02yTpu+bJ+91EoFT6XgXKDgOvP6udtDyd93pc3+LCN20za4vk4TzHCpuWO8ORIZK2RctYCpiVjHzaS2WktWtSnbqONTFtFvT1oE3ABA6zZt8C4CvvxeAlAOEN9UFs3xSxnOOa4yuBYAC0vN58tj0P0pwNLyXJ0buFtnnozGJQs+BexZnV7to630mm3knzTBrQgkM+DZmnXWNo8+s67Kq3nzVg9Y54F2/AOuPMxgfzOBooJsfQa0RURNpZJYqaIlvzpWqu4wt6EVUu79sNZK8CRzipsJd5izm0qrhb/BcbN5rXX/rYzGyQRCm2332I6i29Dgo+8jMb8WEZbVes2yxYEkeo6aADN168U4j7hBEw0iuxVQK2uNa2XPL2YYju1GsRi8xnbt7XL6Ye3E7FPOw/Z0Rs5KzUolKBhpneBlIraZIppONkJY4DDjOhqeUVReS4O05FSdKb5fWxdAsSkDG+13K4fOIV1ys6wiW2POS4Dr7fuAp55trGezh5xAA044NosoEipknLWTrGTfGOGVYzRgLmIidLT+ZOLN5+GxZ8fRfzWZaS3Fs0RGy6smm6masgKQrXwKST6YLTw5YcugGplUKW9SGQE6ObfvRKJcR6Ung/QS2Z9DJMiyyG0quy2dx2QSPrPC1uGTMlU6PBsbCEf65TjqhQwST54wRElNDI6be2JVv7e2fxuSc2umR9cGKyQDS2N20orRF28dQfaLR+1tCRpOEO8PQSr3MTMv1XEEfiZwYEGuAlUL+MJquSmYYsoTDUOwOLbzi+a6OSLxKm8k15DLr29E19wwkprzkeOV0sKUYbpkXywz7jULKPmv6iFz5GwUvKDzFhzcCY+PxXxRHJ2gkDPXgo5dlLWymQYGGTQDns4iXFiMMg0k8vLzeTxw/n9d8Ocb201sLvkSCW5o+tf53bLCQcw68wQ1URa2VeLDbs98ZitvdE5Qa+19dMBB03YU9OUt4NJsn1prZkyDWArqNAPMrJ1mHp25Tfrh3SylA96jPltlNdfAGE23206bUwKoDTk0saoJjsl2bYbPU51WnfMUCHNcdWVVXF3u1v5HhwFYpOJk++Y4kzMGcFZ6B5E/uWgytrxeSvzktLRIZpTHYc/RWzbtOGFvo/RVdVI3yd/oXGezpEIWN7/QCH5IlVDKgLWWoLaCZJzbkOXliJgddY2BuFatU7kuYVvyqoj0yVbsyHeaMXXbXzSwumSBOa+59inn7Xlr+xGfCW3hKdrngu+Vd8CSNEbXb30D9dE++NUAtUIKHVOV5uejRbM4Ok4NfjoANurJbcPgHdvlWdzzem0tfmJju26zsAQukTA9B34pebETsZb3aK+qLiM9r04Zl35PcCG9hbqszSAyc8UJqd3xcVLUjKybvWQZDyecfF40Y9lruZURqEpJKidJq62a6GRPavMeFZhKtlWBq3XO/G2jCCbON2VsZZ2IbMOUaEmGk+fF7JmywaqkCQGr9kRxYuTx8PpqmShBbYWTvNFQ5KRGkFW/Yx+SU0sImWW2xEssLRbSJykjXmk4QErORJ07Zjxv3SPkFMxSpieWJHObpaPH68posj3+yJFTTVo5xzrKr7gVqdUKEuMz5vjOTUtZdHIlaWQzLJGWy2psCJfMJC36rCyFRgqJI6cR8L5pGbBmf2W/1jFZ30Du6ycRaE8sz+GWXQLO2wra676FsMoBzKIraLOw2hvKS88IfKUK3x67SOzQIbElXlGfL/ffaxkp/YpxWoRh2j7PvGdcVp3L87NRJjt6tu31UOc1WF2D39cLr1pH/vQq/DmWCVfg299LlLGOSiFbHHdbZqcyP629Z7HdnNbU57nlQm1KP11n2c2acnwQ1veLEEO1luJqkKhFEzPav5OVi75r7VscHRYmdfktXIqMju+ZnvVW0/HEluxK33tfD/yOHIJ+A6g8G+AMnzlt/ko5vlM5odk2F1DyujDzrNc6lTPXkcP5XnMc2XE7F3V0NMsFKWhR015Ly6hvPlMNZ3tsA32oDpvMpG8z3skZh++hXEH+iYmoLzW6rvbamGuRaPRnajbYgmdvZsGUyjrZ9yaw6D4XDGJyW8qurnMunxdmYgmuLelcJGXGcVGYqJ1tUR97juy+FszT9F63CapHgQcCZ33mXC1wPT4FsGwDsuzYsgyDCUK4VG5cZz1GzgM2GBAtbwkDTQY+5RAwAV49NJnVdBrTLzOf9R8xxy5yR63jPyXsrGZs2/Faq3fYHsLtW06G2GK7ESwGr7Fdn8YBlxONlPiSBdhGbhW0qnaZTihaFtVOy1NLgrSnlaalkErD70apNfMqWTRH2JyvNRurkyEzhSNDCKZmGhlVxwlJcGIlSCQpzuIyPCJPnawJxi0gIXBJsGTV7otgQ1hoe3tEj2/lH92Nrg8/sdlpc5kR2TvGPk2CQNufy0lTwLn293j1qD8yHOhBebiA7Dmj6yeMxFI6ZcgcCHKTZ2cjUiQp+SJgzAQNyRkLvHkNBDSvriG8+wD8Z87CI6siM9R0WljGalmJw3q5QW6hAFCz6gK0TXAge/ic0dzlBMvlCSYp48PyYz1WDUxoHxOdB3uPed6UmmG5XiS/YyVvsHeH6dkUDVlD2CKZTiktM0ELn/dundePTNMbJpvc1W16hUWjtYKAmVElgnKkiVhSze+YnZRjsX2p0TMoZCmUoKEERt4wR/Z3wZ9aMIzAJGsiuRbLyFQPl9dbe9K0f1vKoC2TdlQymTTag5kU/PlVySjNvfNeBGlg5FOzCKdmG5yFK83kY1GvrJYv8jnQbLANiPC6hD2deOCxn7/sn3VsN5hdRNLlkkqI3fJMHRsZ4FIAxe1rpmqrY5B12xAbXYjpmOOs7kM/izK5LbqtGugcGza7YsWJzSJqGbGU/EdEQrXmgGcb1lbhHZDMakrGDNkGz5uLjw3Cm1uSOU7LlWWeYO8kzWY6sbreYBtWUJlJo9Zvx5UWAF7c1Y38M7PmOtesLrVrWjLsamzrWKzH3tuNepcBWqnZtSYyHzHN6rpzkds3K9co0wCHLZlAmZMUYCrAakuKZedbOe4W6aOonQEI05b0y70XBO+t2XSbZQx22nu8aLOwDMhJ0NDZdyvpE/2Ejk6E5AnQYyD41iw2gWlrz7ZwL6QQdju9pcrfUDPnVS+Y65xYKyFMJRD2dqDekUZiw5Fa4yUfsyXC93Yhu1BHYaKOrsdnms6rOXNsQasyaEUg3CoqyE6bAe0D07/VfM6xXZbxzl5tHdaYYaJhMXiN7fosIQ5CBFOz4kgzwxeQ0KZl8hLdTAItd31lx5WFbEkmHROnj9FkY52Bu5V8wu0J0n5YXU5BQ8D1G5/728dkEmQfrGRbc9mGPqiQA/lIEIw7ouzauykTsfQ2WsIknjPlTWyvkT8+je5nx+GRVZkT/dpGo3+SoJNgjI4SHYFMErXOnCnrolNiS64ItCbecztGP7eKam8Gmak1lMY6kTuzZJwRPwFv24h5bUur5PgceSAhHbIaulrWJEBnB9cro3j7GDKzG4btMJFAkE3Dn1s04Hl5xfS3smZVr7XtJXOJjjDUB0zNmD5WlSjSe2cBYpOOnwJBcS7yDXkj7o8A3ZIskfBCovV8XejAxlgBicFbkP7qM1ZSxzc9nSurpjfW9xHMzJnetcEBhLu3oZ5LIfHUCZPh3WiQQQlgdvqoxBmjI8T7b4mzPF6rIGOeIWrOcgGCcp7j6ppEwH22UFMmpFaHz2elRPBfNPeA95Bldgx01AKEuTTC7rzIidTzKSSXS8YZK5ex9LrdyC7UEKR9rL6kC/UUkF0K0ffZGSnri/pyW353LM1mKXxEhCVlljbAYgMVJmtfgmed8NhuArtE2ZsLZWGDSTN+b9J7thb1r7vG584FZ+7zGkmNWdI6PqvuOC48CG67R7M0mSH6c1iKSfBnwZSYU1rrK7GNk4Xb1JPZ2sNofx8cp91rI2MVQSorH7RU1JXCceYlSmOhkDVBQAvSwmx7l42tGOyHFGOQTEG6HrMCTjkhm9lrZdPlPCIBvjoSE/PNcyErcnQcZguCgk8F27oc5yRmGfm9lhC7JIQt976pP1SPNZ3Gxh1jZrOdZt3uh83zU981jPUdZp/pZbOt7Pk1eItsYUmjst8A0+W95toO/t0zZh+LS9H2/VmbodXAJ+fqSks5Nc9B3+dzWLnLKBp0HjXZSY9auZwL02ms3mm/e3zafKdB3WxKAojymX3WWPlSHepsbs9I+giyHQ1pKF4yC17Xdptnr9zjo/NsVbgKKvaaRNfcqgGI6X3lfXCrB1RCrrU6gQDX6a+NLbYbxbyQaYXYbiqjsH13dzeWl5fRpb0jV4tp+HLsUvpgW2QR/OEB897SvkdRa52s9XNXGkd7XDVjpt+peLeUrTnEBgpM3AyAThJOeY9E+V1Hzy1Z1mUt462YZnH11JjFy+ekDJkAWDK4HvsbDXOkgtCo95ROj7Al29JVTlb8nE5GPofyrl5kjp43x9XRYcqZqGtXC+Axom+znVLCSmBpSShcIKa9r1E5F8+V/7gPZgEJ5JZXTfkR968ZO2Vsbke8QeP5dBYEIJI5WoClZUcmuCTbbtRDxIyvS+LhSujwOx43s6QJXxyD5KPPYvmb7kCyGCA/sYFKX1bIiZYPdKBwriyMvRI0YG9tsYTyK29FuSeJ7ifnEYxPGJkam+mVZbScTvubFIDaLHdUvq7PkgC/JBZfNYaOyTLSh8cbvX4E1gM9OPvWXuz4hznDqMrrLTq8pu9WyrZ5n6zDSlAa9HcKm2RyqShl2NJHuG56kck4uXawD9W8h8xSHenlKlZ359BxriR9UUEmYY7BJTLTc+K+tGqBQYjJmai3VwFulOVg3zkzGakUHjj7P3AzjWvXq13Nc74kmZw2dsksxI7rEekVD/Q1QKACSZX1kAW85kycQ6jWpJGp5rZWRMDVmWeiNhIte+WY5XAR0LhvF6S2noN+pkFTtoDMzjdla6PedXef7rYUtEpw0FaO5Gx57UY5+r3WtzXruZN5NiJj0786l7nXUKTWtrhOqrdtj70tk7F7jdzj1W3pHCivzfgYGfkXtJSaY7VeE5sV1cBlfdcoZl5uxsm1HWbVoYfNeayP+Fg+ZM6l5ymzfM/xCnLMMnNYvcUAyMVbzTVLrYXIzZnlC4dnm4PV647meUe2QRilYNU+Mxt3b0NqpdqUgd7Y3WOOWcqRzXWq5c25dZxZgz9jS6PtvWbVlJxbPoVa3hIt5c2xZOdsyW+pjtKoAeT1tNnW0n4fvcfqTSA9TJr9ZZ+ZRtBjrpPPZ6M1G673S89H50teZ31G7TJknKd99NH34nqyG2ks12P9rUdeilzh6uYDi2s1/Mv7vnZDXJerbXHmNbYbi8ipJYIeTBvwY74z8gci/s3Jg5OUK4fDfw6VvdmA45RoHyEdBccRiaR1FIxpGaWW4EgmtlGyKe+VZVflaiInwunxsmCCGbXw5FlTMsveRGZYHf23KDrNEk6N0ivg4THwXCl2rj263P9qHZknVhoAnaXTKytRDyxBkoBW63zIPuwxR+etpA7aP8soO8Euy8A0a6zLsNyUIFeZMdsxjYqEQ9oQmdBZYsaaoI6OXa/JSodTM1HJrOyLIJllZuw9feYMwoO74ZEFmY7Kt9yG3KyZ2MffkkR62UO5P0Dh/rvQe6KGqZcnESS7kFoF+g8nkJ2rIX3krDjX7OUlGFzflhYOpL7HloDZBQR3HYC3XDT9P3RwCh0mkq6BCXk+DHA15YaWqTjhY/nNB7G6w8eOv58Vh633s+Oo7RjA1D+9RWraRh6YQDDciyCbws6/mmw4nNrvpk66BD3SqIx0IrVQRH2oS/qdqNzB8j2fr6s11Ia6JLuaXK1gfTiBoc/Noby9C365hu5jq/DPTjeRtAQDPQJ0PfbiaZDDlpfJAZ6btuQzRqNWSkGZOeLfoR4DtMnKmomnjdiurJyOkMLx7+RURF4UMW+zN5yglhaVATMYWN8kKdIWGEZzhgPCLsS5oIBXj93droIgF0y7JcncFwOOblaTlTQ8J50D3B5RF/TJvhttJQJaW0p6KWsVLdcOSLczPeZoTnNAvDsftm4v0kEPG8HL1t5JDeLqnMfKEck+6jZtFpAtGVl7riu2mmdsSP4s39qLxVvN9Uo5Vb5BOsTUKz10nDXHlT/X2PfwlwxIrI32bDr2sQdMBrQ22Inks+fkdfHe3fI3x57gQh7l0S5sjJjj6X1EW4/MtVh69Q4JBNL65hqaqRNvtRnWs+Y+5ifNd4lSAskl87p80EgbpmctWVctQHFHsyarfL9cQ5BKYG27VomZP6n1EMV+H5lFIDtvLmJq0gJiViFx/sznUO/KNINXJfKygVUx3hM+d/Q3NLDsas0WckLS92Dc/hHbDWixFxLb9WWuM3IhIOv0LKm0TNPXJNJwexHdaLR+rtk8ZXXU0hqClhbZg6YIezSp222qo2KBrPZPRkBRs7yt/VecbAgS5pZMH40tNyWTq/RXCkkFezJThkDJlsMJuOC+lHyIYJAEHywv5T4kKmyPt9V55Hci72L6YJukYJRgSEvZtB9VpGRKBnRGUV0jEWOE021PaqYhUSCZ0miftldrbBA4O2X2zYymq63Ibe/ehto9+5GaWjGT8fyigFrRrT09idKrD0l5XP2uvVjZk8XaNg8bQyn0nKhj22cDLO9hD6mPoccIykLkppJIloChvzlmek4JOg/shleuIkz5SC2X0Hd0wmxfeljLpizY9oMtv2E/ur96DoFl2T37w7dj+0PLpi91qE9Kx2rb+nH2zR2o5YD9f7qAnodtFpPOeDKJejaJ/GyArqfmUNo/iOzZJYnOb9yzHfljc6jtGpLlk1qmRzCcSQtYTU+vod6Zxfq2HLKLVSSKdWzc0o9a1heQPPoZOjVpLN9SQGYlQL03j+z4ktF25DGQ9MmSxlT2DSO1sGGyNFpZoM+BvY/mmbdOUNpm5G0fuClz5POWwIPH/vvWv8vYXjzWjuH3asvpuG0CLZ+LueApvMTj07mBz3JEztOq5ekQ/VmgGszMRuOTlPGrSaWL5V2QY1K5qTrC9UZ/J+cBIW1yy4ntnBaVIqsJ6CCxTwXYcKTDFNy6c067a6HmZtn0b+u14fG4oLidZI8ek1QNOb2TaqyOsZlhjlGLh0wGb+BLZhxbfPV2+dv7yBxWD5nAQ+G4yXBu3DEqfysFH/WMuYc7HjKodeqVBfQeraL3KHVLzXVj9Qzt3Js6sev3jsvrmW/Zj/4nVuHVAxljE8Ua0idnkDts5qaVe0xAu2u6BTgWS1h5yTZzbJ85Yz6zgDvo7cDank741RADXzNBAla5JGbNGNp7zNzvSnfjWiRt32xxd6+ULytoda9j/sQian1mHwv2Ok2/1Gabd5uM6cBHs8hPme3XcimpoKl0m3ufmgSCHrN+eSCHRMlmZE+brHNUzt2qA6yBeI7z2n/MeVWDQmtx68eVtHroy7+raVd7+zeSxeA1theM5OOKWav2nUp5kCSI5WiadXWPS7OxmkF1l9HXQgxlCaNcVlsagSMBioJeEgNNnt9E2iRZAzr9WkKsmVw1AkZmUEXDTjMDNQOACWRatsdeWi1NDZlJVQkBarBGou2JRqmrA7q1FNTT8yFIYnaTy/ruukYXV5ZVmRfJNjfIS4TJt1JsMHMS4LokTEr2wwzvYK+Uo3pTc6jdtlv6ytgXG+bTUvpa3t6NuTszyC6E6H5mQ/Y9/8phhP4AsksBCkfnUe/OIT1fQmmE0WKg96kV9H98QTKZ/sSsnEPH8SGsHehF+vwKVm/rR+F8gK7PnTAAu7cHM2/ZhuGPT6Le14nkEycR7t8hQu2m9DeJqX92C0YfmBTyrfKrb5NouJAz7dmOldv6sOM3n7Tsnhl4U/OSUSDo3PURE/Tw1pklJog3mUs6DfV8Qvqk6LyQgEocCc9D/ukZrNw7gq6vTxgH2ZZgM2Mr94fEUbyWhaxkWld2plEc8FAcCZFZ9LD7TydR2dEHv1xHejVAqdc8m7XeDiRtWRwlR6qHtksvlVcNDOkKyUlsiZlcF/d3oc8lnzsCevYQ2yAGny+5TnUnKBFbbNcAIEtWloEuLs7e2AtpC0dlwm3mIKf8PzJmb/UYFCiSMI397u5i1Dzmb5S96yoXxbJXBbeaGW4XvHOl02zQlWRu8pZZWRK2qSxVaz+wAuR2jM1qOofJgThAeVMm1ck4S0Yu0Uxq1Co35OrL6noky6O8lpTQdiM7WzLVRdYWXmrKmv0a0DFRRmW4E4UTBvzVesx6+UfPynEKjLP3qL59AInzC9j21wsRuFp7xZ7G9Uz42PYpMuBXULtzD3qPFZE4Z+5Rfb/JdrLKZWWvAYdrY+Z4ux4368/dlcbYp1dRH+xB5zM2k6nXi+MlmaOLJXRZnVSyADPzndgoC3AsD+Zl3lHrPtwAtyRaEvk3NQ0AV+oI04mmXtbiIBAwJl0CSttrwFoKOz4iK6HSnZQqIIJnNbaAVMd6UM8mkFyrSvtLkE44Wq71toH/cLgf3mqxuUrNMl37NsMcW2w3ssXgNbYrazphXiLJxxXLwrYDsCuUB2mhj5ftWukbmvYrCgutkUeJMrBVpz9VmCudQV/15YTUyeqzOqY9q5LtkwyjKSkzgMH0srYKn7daBGad12QsllNeWhZyHQEWLT2qUfbUSttE22C/kTLJMiNCgGLLiISMyTLjRkRHLOnl+gRkPOZ8zkgYWL06khA19QWrjlxVGZ0DydaGYwMI924XoLqyJ4e+jz1rCIi6hxBOzyHR24FtfzOD6bfswNLBPPqPnkFqfQSdDx0xYNHz4U/PyT7ylGAl4YlqyJ6ajJhw6SwIUOztQOcXToqjI1kfAuy5eQx9kaXkG0isrmHjNQclg1l44CS8vTsw8aZ+KTUWZsyDuzF3exqpDaBzzxi8Ug3dj0ybvlUNVvB5ILEVM+enKBdRA7aNSK+ux2eDQQbPl31MvHUAI19cR23PCBKrhlWy1plB15fHG0ynEgCwDiOfzY48Srv7sHhLGpnlEMky0DEdYn13gK5TPuoDnQJcy4MZ1FMeuk6XJCjglwwBycLLh9Dz5DISa1VxVryVdZMF0lJ1V+6GwYnhAVNuP2ucMinTZERffxs8rloND0z95gWf2dhepKbPykXGrCtVRtxqHI+knUIrWWgy7tlta0kqn1nXoae1EhPJuo5+rGZGhXBvoXnuceYVkQCTIXZ9MxjV9Rwdb9ciBvoWLfBwrWa0u5WZfssL4IBRV5fVkQnbdG/ce6b9j25vr36v3zlyPTpvRPqm0v9PTeg6vKU1WbZjah71/SaLOfgJU54rc6TOk1r+TR1qxgaOWs3pVtZjHiqBqPbF9veiNtCBzGLVkNMlfFS608ifWAAG+5FYaZYxSk+vRtcmWVLyK/O+vLMPM/eRI8C27KhxburtRMWSJzFzK+vPLAtYNMdBuaHme7m6wzxnxR1dSC9a/VSVLFNQqDJMDtlYuS+N+UNJ4b+r9jVvc2VnUgKtbAuJ+lvtfSBxE1s9eJWoby7nS9m5hUUjbxPpC+vvIIOgy2r92u2T7bjal4t6d8OOTDTOx+N5bDeqxeA1thdHFnYLABuZO8kr0LKMtpK95ITjau25xErRNiypEfflkDTVW6L0am4m1Vjd+byNE3ih47fnKICYkjHE2EtLSAwYoqKIvEgBBzOhmlEVGR1DTiS9qQL2LBmR7TWTHmFmBSUDYDOnnOAJYtmzRAdIejsTpnxYr6lmra3zJKXIKqtCYilOrmRKtte09+yk+Z56p0dOyX4Sh09KSfTQX5gIvTc0gM5PHI2coTCZNPI47I0l2NZy6A72o1LOKCmyFEEhg/Vdneh8YhrhyID0GkmUX/uCF1YEsPP65Z+cNAA6m8HMq/tlps+eL2LtNfulf7RzIkD3l85GUka83/XRflT6s6J5mBlfMMexuobiy/cjM1tC4tQkSi/bj8xcUUqD69t6kZ0to+vRRcmSpmbW4JHcKpdFem7ZOHeSdbdEYbbv2GSDkvBrAZKlELWsh/UxE7HvfTKB9GoN69vzyM1W4FdC5CbWjf6f9jUVOtD76Dy8ZVtGLs+WKTkneKB8EEmxRKKH95nljakEvPNz5pgo1dSdB3o6UOnNIvvoKfNbaVfOGdvNYe0Ii670uL7FtrfUFFa+AZoSDklbhAVjbj9nVAq7mWVe+ghPjjdvu36J47MLbi8QYL3Qd1vOU3oN2rAzX1IQQYkIXWDrshBrCbUEp+x56LWzLMki4bXd9KZ67KFvyeYmjlsNbNU8dRiEZUnbciDjrrN/yV5rO4+a7QUmWzwGTJmsXzGB5Gyp2uiZVaN+ur2fQmJnbX3YR2od6Jyoo9qVRGaJgb8aSkM55M5vCAleaTCHSo9ZNzddNWR4qxWpykmsNrLm2lPKdg3Z5XQN2ZnSZtIsGwxh64Zc0k5zHdn6URkuIFmsY+Qr5nk8/c2GxMlfSyA35UnLiWvZiZUGo7Fs1GrsrjQC6BEzsxrnR8tFQEZjcyMClA4MN66jayr7FNsVswCe/LuadrW3fyNZDF5ju2L21sL3ty9ZuhJZ2OcCYEWg2yFHckl3tH/UlowiYTNgXEYZhxUo6fLSq5kznwch6ucs6c7ztXZOUTswzqh+q89CJ6BcMYywtj8pirkKS6YtA7XAQ/tc5byd0mLPs+8V7GoPFkGwlaxhGSl7X1WPVbO8PidO6wgpY/GZH74Nu/5iEiGBvdWdlb5dZvwIsll+x5LqLDOUFQOiLUkUSZtk27zevCcEXdyvA8iFHVmF6nkfOwvwyxUUzpw3IH9tHXlGlwl+bXm3lOixd21+EWv3bkPhq2dkveFPTGHj4AASq0UUjhaRXuxEcTiDsKcgjgAzuRrUIDCtdmWklMxfXBOgmD++YHp2B3oN+yXvQyEv0hWrLxlCYqMT6aPnROYh6M8jdX65oSXMa9GZE/DIzHQw0I2QxxqGSJ9dxMB8BsVtnahnUij3mrKzznNAohpiaX8W6dUQ2QnLZq3PN7VwebAsRef15rXn/fc8+B151PZtQ/LEhHm+eG2oJ0uHx55j6fZtyJ5dlkxsZqZuCGe8LB4Y//Ur87zHdt3b23r/+WZw8RztOWVbLzRnuPJlupwrn9VqHK/U2Sf5W2sQZnTIPVi8EMbxmyzzIhnkcjO0M5dRtrWiyJ1/3f5YF+xqH6wyC3seqocMvW/qlNEOlfGfbTfcXSGNRLmO+t4xJE6dbwI/9YEuJCbnNt8Djj2uBItTRSXBXwF7Ri5MFh+15cbjU1GWNmpRodwYT6vLAloSyw0aVuowl0Jp2ADG3NkVdB6roFIwJdyZ+TKqnSkUJpm9NfuffkWXBAHlMtjHIOcUTUnLht/Icip4zcyVULWAlJnQiAm+yAqsRFQSTX4CGjkKqoUkqoUedBxfhEdmeJJTvWQUw1/l/TH7yy6Ya1buMWSR1UICWcYbqAbgGu9lxVQRqdZ3vcecd2LBLMvqGr1OHgkcPR+Z8yuoDhbk+rOdRr5nIDKdwoOHf7F5H7HFdgNZDF5ju2L20bU/EHmFJmelXe/Nxay1z0ZfX0r02mEjljKzJuIlq/vH6DIdmEgA3ZYAa+bVkcZhOZhb3pvo7zXi9VcKiG/lLF2iE0VJBvZiRRO9lW6J+k+VhEc15azUTkhdQwXmfK/ETdpv4+iAEvz5JE5aXUNQLCFBpyYBTH73QYz+0eFGDyWB6/5dmH1JL3b95XlxZsIDOxE++SwS2QzWvvE2dH7xZCO7wEmU/Va2P1Tuj80OErRKdF4zu670Tj1EiCAqffUG+htl2wS2dKyYPVxYgr9zm2jMsj/NC9KojfUhmUxK9DwYG4A/uyQ6fUv7EkiudiJ9YhrplTVUenYaEfquTpx5RwcKE0DfkSLm7u3C0D+ckmOp7RmFX6nBX1pH5cAo0iSa8j0hR2JJL4XnC+Ml4xAVOpCYWUEik5KsJqUTWKpGxklG/UsDKfi1AjILVbMdPovse65WkZ+aQ25ioIXV1EP+tGU65TURrV7rpHNdOoXMsrNnlY4ir5PtYU1OzkvWWsCuBDwShtiJ96BWQ/bEHGojPUhSN3KF7JwdVwTExHYDWass2FUAq547DrSywLumWT2XaEhZU1XmyTXb1hARKbGyYGW1uQ9VSOmM84/JzYR/19qE4yCdQrC8IpURYlY2RXgb9Jq6ANGdHyMCwC1AP++nPd/qjr6oLFWXi/pWgwDBiAF/Kwe7kFo3+00wiMUM5H2GtXd9LIkCg2YEf24MV8mdbIOozJ02OODZ8mgJYu425cbrewww7ThrgNfqa/YhN20lZIq2LHfBkGCRU4C9qOHoAOpduaZeUtmu1VTtHK9I1Yrrd3i1EGffQnc3xPZPmnNZ3W7cXxL3re8sSM8p5dVoyY2aECZVuvsjuZyMzYhSa9en9u5GRaTZSgOOPqxI2jDImELXM6umIsYxEgBGANOWjgf5NFKLJZlH2poGImwgVy2xtAG4IJe+DQPPLOsm38Jgs5QKddfN/loy2LFdEYsJm66txeA1tqtvlwr02oFWF7A6JEjiiFysD9YO9JLlo6Ok+q/CMtxGZsCyrwaLS1uWedVJjHQty50vYmGtCrD1kuyPUT+VKQmWUiLtxWoXQHC1b2VidDVxgZDyOrfvR5BJYXlvXhyZwhdPSESeMgRjf3US9bU1uVb1N96L6fsy6JgK0Xd4TQDa8stHUOz3sPQj92D7Az46j6/g3DsPYNsfPm2kE1iSrEzPBN90Ym02XAAsD/HgbuCI1WXdt1tIntRpIXEFnRKCv4zV7mVvK/p65JjXXrcfXY/PIBzqg5/PCyBLrBuHKDm3ZrKOmYz0xyaKu6WXiEGM8e/YhkQVyJ8dxOl/1CN+2PAD45j/hh2Gmbe7E8Vd3QjSHgqPL6C6c0D0VJfuHUBqLUBmoSLAldHv5PR8JE1kyoONw87lWVrGUjVmfNPzCXh01pit4L2wbMVKJiKld+xL5n2VLHu94chSf1Uden4mTrsl/ZLyeA9e0pKGsXScmXQarynBLe+zEoHlsqgNd4vcjjwPXQVxeq43HcDYrrK1EgBdhcqZJlmurUzHhlZNVz6bWwFeR/M74Hi9xfgq49vzsEsuBb7U7WkljIJXB7BE2WL5LSc3Sf805NTQ1Ksq85zNoJb29EVMtQpWlbA5NbeO6dcOAof2IrsYSOYwN1uNNEnPv9pkWvMzIXqeXkV2FvCnnbmwNfOtcj8MpNqPhJRpYV3GnNX95pjIqi7HNpRDqd+c1+xb86j08HxMeW3/Y91Y32YOtNIVot5tzmH/H1sN1jX7fIQhNrab7Gxm0RJpVcNovhj7XPNzQFKprjMVVPpzWN1ujrf32QAruwjuUhFxUq/VY5Xj5dy6VkedAchCMwjsOG1AtgBWvZcaZKHPIeoAiUjeJ7lonj/RhrXtO1HZtrID81nmd+7vkICVc4C7HJ8PBmkGe6WKxzVmgOsZH+hPY2mf2c7Y57YAyrHFdoNYDF5ju/JlwyqRcLnkHppdbecUOJlXLVG9FBPgaqVPhGnV9mU2ZG8M666QF6WSESHSNbErFO0ngGX/Ky3R02OuezmQrCz3IZ+JDI8j7aOgVftWVc6GvagDfUKy4c8uIjw5Ab9aRfEl96D78KpkBrC8gvKt92Dplj1IVPeg9ytTqKR9pNeA/i/P4Ny3DGP7306i5/Eq8kOdGP2Tk4Z5OJnEtv9z3txLYVP2I1Zi7ZvVe7Xwjw6h78kV+CtFoK9XHNXKYAdST52GP9gvJa0I2OPagSAJzN67Cz4rvovbsDFK4guglqXo+xCmXwF0nfBRHAKS6x0Y/npFyrM6n16Q4wh2DCN/5LwBhPkcdv7BsyIzs7GnF9s/WUR6fEHKjLtOFiVTSjIRJDxUuhKY+4btwhBZy3vILgRGoahSN0CUGSCWKdt+KBJpiLPmeajlU0jPrEpfqvRdW4Zi7UGWa2LLtr3ObsNyyqx/Lg1vnidXM/eUkfaSs45m3glQ6fTKTfUaWWxmY1mGJ9uvCLCXEm32vDKjzWqDdEL+1fuzkqEpWybj2G5SU8dZx4xrySQvZaNdjeyrggL+/ltNGLPtsxoxn994FQN1jrFtLGKwZ2mxmrLRO9JxkdlrFpITYH0D2WNTQt5D0zJXZg0rXT6wNysMvmqUEpPNJ80+t//deSPFRmMlxlYBACltNYBbWZnnXtkfZWlX7jL7zy2Y+7KyK4GKnA5ZeducdF8F829koMPD9jETiD13yuitnviODPySOb6dH6uinmk0j/rFGqq9BtjVs5YTwj4KzKSSBKr7RB3L+zJIFkNkF0NsDHmYvy0lRH39T9hzlcoWTyR5gq6skPcpOCSZklxmC44lG9uqv2ulypqAprXqQAdS43ObA+n8namGeyvxlnJtOPebPdv0YYJOW+pM0j7eit4sah1m3Y2h5ufjoS/8xzYXO7bnY3X48u9q2tXe/o1kMXiN7aqYlI49l17XrcqDLzHKLb2fLJHs7TEOP0ulGKEXFmEDoKJjjBgVPclQqXzBjWwKYps+W15BYmTIZN1UJoemvbxOVFeYhnsKwMmzhijJas2O/fUpjH/fHvTuuRep9Tryn38GuWJJMr7o7kT+kTPIP2K2se2jCRMJnp1Hevx8oyzQOjVhsWq26zqjfFboZGVyOPu9+zH0SFl6reoDOazuHEYtb8Bo5W2HJFtQ66wjdz4hfUvUciVKS9L38oDC2RDzdwPpRQ9z93hIDG9grZpHouShngHOvimF7IyHzidq0vtDoCYSRLW6MPz6tR4kl0tIlupIza8j6O9E4cgcKqPsl/KE+ZJ/CVp7jm0goIzBckkcG49ZIoLHPB2JjOmP4nvrbAfZJLxyHamlIryFlUbfNTVZGTjRLJPNmGJ4EHXKMaQTSB6fgLdhyLAkS8PsNDPulnQsylqvVqQ6QTIutlSSPcPSXyyBGzJh0jHsMcdHALy6gcruweiZoPPKMrpSD7UbruYTG9t1ba09lZcQkGzHLvxcGIelJcDVV3XNzbrqeOZkaQO2drxIjb99medoCtaj3larUy6v60Jc167yZnVnFr1PLKKT41CpiqDTZDk55tJISkfrfHjCZAO5vmaEacqhoLJBK6sOe7m9112dMmZ2Hy9FmqQrO3fK37m7fGRs4rbrVBgBy6VbrMTNCbONrk+mMPUyu90xu/nOKvzT5lj6nzLnzZ5cOf68LxnT8mBWApRr28x2uk/Vo/OqdSQRJj1k5ivoO7IhDPi0wSfKqNtSbSU4CiwJEoN6Cdu36llmYtGAXVg3Paf2eVQZIWEgpj+h94fA1f52OH/kJuzz6RIvKdcGfysu0CWQlXvKtg7n92fLpEW7O5FAwmZyGeCs9OclGKmZbdlvi+RtbLHdyBaD19iumDUJ0rcjbbpUELspEnnp4FdKJTkJMIPFYxHtPCttwn/6mo4/J1uWXBWLjVLKF6OFAernp+AlUw2pHGETtpls9o6K5I8lpVrdMIzAYYhTP3wLql0h/IqHfR9ciMpXg4M7RZeP0jBYMlldkeYhQdLxcQFVxdfcivzj52y/WVVK0ljC5R8bN4EC6siKvI4pHZa7zuzsbz2GxW+/G31/8xRS20eRe2oVxTu3i4PCXlKWtNLJmrkvh75jVVQ7EkiWApS7E+g6VZRJPFHpw8oeD37ZQ/rrHeg8Fwj4TVToGK0LmRIn+aW7TH+Xtysn/anlHoI7IJVNIFEOUO3vgF8LUd7TK+8Ztc+dYZmXIY5iKTIdGxJ80E0R7VqSZZDgqtpgaPZKdXN+KiWhTg2fVUobrG1IP7LIE1WrxkElKVXCk7JisF+MjrxKJRGsMnMqxFcp2Y4XWBZpq80abYf7J3DlPRfhetsnKORXJgsf9nQZyQmRZMhi5ZYC0qt15BaAL/zl//PCPLexXT+mBD+XaqotrUzk7TK4F9slgzHtjsPyEUTzCberYNYtr+T49jzbMq4n00qmcJXSMBZksY9dmObTRsqLZisxaruGkRw3BExaZvr0v+nErr/zkFmpC2it95F1PB0x1KYWbAB3cgbl+/ehfnAE2XEbEFXg5LDwC3t9V5f06UrLhjXJBC8sIcXqH6d8dvihCQS9HRj8uvnYnzXj2cLrDajtOmnuaXZx87M2cXQYXc/6YO62a9x8z6AirTrSFfWeztyZxNDDVaRWuYy5TmQZlv2tlw0LO09np8ngdh9bw+r+DulT1TLqrL1sieWNiGxJryEDifxMwKyyMtv7IOfOlgs+hwxI2j7f6Hrlc8idWYansmXmYjUCBJv6mCnhZ8Z3ExCF3De9D5zDkE5Gn8l7OVFgfdS8rouubIi0PblHf/MnNl3b2J6/BaEn/66mXe3t30gWg9fYrpgJcHVBqwtW3eh4GxAr4EkkYBqTlmSRhKTHOkJW7uViYFYkYaLIsJFZiSZaAgL+5WTA5bRM81raC+RMSX9s1RIhsT/GMgPLtVeGSTITL69i5S2HTL9QEsjOedj5gWNyrQKW2d53ULKA0oNJMhGyPlZLCKT8NYPZd92HoQ8+idzEmtzv4utvQ+70EvDMmYhR2O8qGOZmzfQxeMA+WMuk2fuhxxHWA/js2U2nkXvsjDhnwkScSjIGjeFwN1JnZqWkt5bz0ffQcdR3jggD5dJ+H4OP16JoPHtR81M1pJ+dMuAtl4WX8NHzxIJovHaeC5GcXUX35CLK+waQnlo1hE20nm4kT63b802LI1G8Y5v0vLKslqyWknldXhMHL9LPZaCAmSA6ewoatT9towKvv8+UFvNzZitIbMIoO5cl2RWd9+n5KKOK2QVZ11QPhOa55murwyoBgm1DALPdfO47C/DYD8vfC4/DSlGwj9U8EKGQhUi5cMJDrSON4nBWpHm6TmwgSPso7jUZmdhuHntb93uuTHnwFusLy7hmB/n8tgDPiACuXjetD9YUqEV9gXzuFVCpZAqDaZt2eOUB7JXud73Izi74mWp1i7wVrTMrTLiqP0o78YM7UB5ilQUkyEfrcOZa6buU7YYoHRoDRjqRnmtUIgWFLFDIRpnZ9Jl5BN2mfFjBIMn5pM2Dpq0MvRZQswVlwOqnMkvYQk7UOW7ma/rmmqVVkJzftRvDX1ltkqCp5Ro1xlKVsrCOjO8hUawiP0FdVTNujX7WgGOW+gYpH0E6j5Q9Xo73868wZFJaspwoNzRbpTKGpuMlwWLaLshyaVZ1udloBmAJIglyhVvDOUElVCSYbQ3s20Bj07PNHlVZwW9cZzfoo+RjNjOsEj1kEmYlkJtx7RqvYGlvRjRmH/ntGLjG9uKwGLzGduXtQk6PDtwty7QyQYppD6SW+DK7t38XvI0ygskpA7rIlHsB/UlmYgnG/OEBKeMJKO3S1WnKytpkEkRH9Wo7Ji9gNoAAVAG7f/stwKlzmPlnt2HoQ08jHBsEzhqpgtlvL6JaSmLwkz4W7gTCbUOSdUWphMSR01h8xyH0/N+nEBSLkl2p37Vfyq96P/wUuk+bDOLCnT3oPpZE7vPHzL1kietQH7y1ImpDXfCqAfxiWQTTBYhxcqZjy1JkMuCGAYKeTpEroJ4f5QME8PHaJZOG8ILyOA+fa4DiY6fludj918b54LNRv3UXks+ew8w/PoihY4HJHFP2YbkorJXbPj4vfaTzb9ojmdvMkQnJWniFMSkFFrkEHn9PN2pjvSK/QHKROluNlgMjfUMGTet0S4+e1W0N+7pM/yuzzySoouxMrqNBOEPQypJlntvSSgTixbm3WsNS+s5nnA76ejkiQBEArM4OgWqyAlAbkNeSoJXZYUb4FeDa68tt8bqyZNhfK0fkIwTsci7s/e7OoZZP4mv/+9++IM9pbC+gXYme1naBS0efMmJDV3multJiAlmp5HHKg6O2DqnaMNskEdsllQk7LPTXvekxtutjdY3AhtfCXhdqSEd2zy3mby6LZ36BTaUbGPl7A7SoHa2WmDbgrr6tH5Uek9nLHZ+LevRJfMd/JKCjpSllo2OOtaCvIBlN6flUUNbZ0cxyu2PYjPVrRSTWio3eTSv7IuOOPY+G9riZE8Y+dDLK1ifsM1K7f6cQ45E4kLJm6ZVmLdziYBJdp0uod6QN+VwYCimVbL+nINqrtMK5CtKzJjtat6XTQurn+9i4a7vos0YZafICENByzM5mJIMsx2mBIltC5Bo0xOrMuOuWBru/CztnmQvrXFMbbDc7bqwrUjj6TDjLBzlWU8FU6FgAS+tZLpkKKgGwce/H1bbgGvS8ch+xGYvB63VqYRiiXq8jwZK/LaRmLmWZ69LpucTltCe1CeAePxM57wp4KRUjoIZO+fxCM2uxfR1MWy06vqZDfwEn5poA2OvAgsPPyN+B//01IwdrWTon3307Oj7L0q0Q+fMVzL4iCZyZxMqbDqHr08+icvdu9BxeRrhvJ7wzkzIJE9D2zQ8g3LMdmYdPSNaUQFYmZ+l1NTI4PgFwLiuRcrk3S8sIB/rg0Ynlc6EEUjSWCFPTj8BVZSBsoEKyxiTa4vtwoyEZow7wxEzUN5p4ZlzA3eAXrOZsfy9W9ubR+8iGlJrlWT63Z0TYlFPPTCDs70Xy3JyUa1HPVaLm7AXOpJFYLSE5PgtxL7hvAk9mPnq6UD24TZiP00tlI1zP0uHzc6a0tyNv+vfotDFTzUwAS4y1j0qYVE0JtVYcqOyRECuxtDuZM3I3rBpY3zDAlcfFAAKfZ2Uhpq1tWHZWUyIvRgkhXqdaDX6pYu7J+gYS1Jcc7m+UA1aqCNIFpJcvoJ0ZW2yXaFErCf9q6auTRZJWBs24ahuBAtq604rSbgxzCYMuR0qtcXDXz31so+t9Scvbc4rGDH70xLNY/ra7gb15FL5ovt+wcrZd4yGqHR7mXzMqXAGZFcvMW25h413egK/3a9npadXvGdTTMlcdd2wAjzwIbKegrJmAKqfUuGk5bl/XdbVgRYfcGX9c/yaVRMcTk0YjO5NEYaUYyeQs3taJwmRF/jE4KrvIGjc3sUKgl2oAzpbnJbFmxmJyDDDLmVkooW6XJ2cBS6tDZpJbfC0hcOJYXwsiMidWN4UdBMOdDTkiEu3puVhwHy1PUGwz6BKo1esj8zKvkfWF6vYvx3oSSdUCJBZaAvH5nHAvCP+C/nb64wqa2F5cFoPX69S++7u/G3/+53+OX/3VX8VP/uRPPudlrpW9teNdV36jnFxae0DafBeuFxGuT1xYZud5OivK9HhFQO01dpjcY9bzaHc8jOKvfdv9GPnSKhJzqygeGES1K4mD718VB3Nlp4/6W29BeqWO9LEJLLx1H/rZA0t2TJatTs9JBnXTNWL2kCCL5bTMlE/Pmiws3zPLeu581GMrJXCc7KlDqhFoW4ImJeSq98rjZZmyEGHY3mY5QWrY1htRbQvI2ZsrAJmOQzIp5cK1/oKwA1MqIT2zgc5nigi2DRoSI2Y+S2X4SzARdrLwZhhZr5pj5DZ7CiKHExRyAj5FBD7ho9bXIcyUzOxKxpqZVzpiBK4CRlm+7iExtWii8jxOZpAI8llaV6wYBmGC1JUV07PK4IwSoTAzy/O1wFR1bcUJVI1i0W+1uphcT/qZKZWzYdZT54hl35mM9Dm71zE1sYgHjv/qFX4SY3tRWGug9DIyte2AaBN7/KX01W61Px3bLjZGX+pyN4K1gPGG/BCQXTCvu4+Y8tfJN/ag2gnM3+7j4JtO4OTf7jPr2IBfflrpeJMm+MXvWAmiwEnBq5LAiaxX87UUKS+Os7MLm/uVadrrzz57e6xK+iRjj1NttTlTaRnzNVvPNg5dbOeIjM/dJ5jZtfNFJKmWQbk/jXJ/n5Ql56fKQtykTMo1W3LLSpPM7IZodyvBXmK9Ku/NgTafkei0Wq1WAYrcF7O3nCtYwl0PTZBQzemLjfRZWZmzXjLA1ZIXyjzlSkLZwG9jx57JUrsVbJqhZTtMGEplkwRgaZkMcicX8MCx/97ujsR2hSwIffl3Ne1qb/9Gshi8Xof2u7/7u5icnERvb+/zWua6s0tlH3adigs5GM+FldgtH7tA+a6bfY0An4CF5mzwjQJc24LWNtb5kcfhDw9JSevUK1Io9/E6dWH3bWsIPgYsHvSw88EyavvG0DlelqzfytvuQMe5IvzHn4kcHZZri4MRRYwt4Fxdk3LAYGnZ9B07mqPSg0lASmemtLCZ3dTJIkrfHF9wH9obLduxUg2h39A+dPtquSz3nUggmU4jSZBKh4u9qLkM/GrFOC6lMlZeuQuJSoBEKZD+ryCTEPBKhuLSji5hyAz9TuSePIdgtF/Knwk4E3TAhCHSytrwfPiP4JLljSRW4fe8RgTBmbT03wp4l2wGM8ieOIkC7rne+rqV0mGpsM0GMKPLZ9iW1EfZFxJnSd+t6UeWcydgDix5iDJa8piEbdpDfaBHWJD9qTnz2daV+LHd7ObyF+jfC4zpz4Vp+IJ2OeR/7VYndwL1k5+jXfGqnOcyJ1ygpDhBoiA6dxuNueqZ91BXlT2bIZK9JRyeHEGmRZqGklgEvMVdPQhSvchO8Rr1wT96yhymZkI1M87MnwW0IedFzplClOgEnXX+0eVYBt7yWWR8TlzWZHfO4himcm9yDFb+RqpTkvAn5+C3+BfhSB/8+RWk54H00XJUycU2EtldzWrMDmaQXq5GjMXyHSti7PGxHFg+K1YjoO8vrW4u961W4S9Uo9YMtyxagwGmdcMGMbUUWMjQGsHX6PwjeRxmWdkb7sylCvB1ec6lkull+fgakhPxAB7bi9ti8Hqd2ZEjR/BzP/dz+NKXvoT777//OS9zXVorUcFW1g5oXWmHQSf/LQBsq4NCsNS2L/e57PcaAFgePwHrpYJWHtczH7gLB//FkyayLozMQP/jnrD2zv/9doR5YO//Pouz374Do19Yx/lXZrHjq2V0f/aE3Nf1b7wT+U8fMROrkBNZB0Np/5VRmCAt0tm1ZEY0kkcJ8VDFlM6SWMvtg+OkzW1Yh0EcJS1LFrBsmU31NZmPmZm0nyt7KcGxZH7JFEkAyDJZ27vLnmgj25NC50efModtwW2a2ePeTpR2dhtHJwTS5xYlou6vlkSahmVsUg7MMrNSVfRyRQ7HyuIYEqdqIyPMcjwC2Z5uhLPzRgKDkXuCfO7XRt2FhViloPJ5yciaa5YwgJbXi9eN2Wr2CzIDzgi+vUZGP9f219KRIlEUo/3sK6vWkDgx2fjd9XTHUfrYLjJePAcZtCsJZC8EYLeSW2t/QC9c6fDl7vdiPbC6WbYA6Cq1AEE+JSy9XWdtCbBvQM7ifrPM2nYPxQN2bguAgc+Z4FjW0B/AGx02LzaKwhxvAo32WGTcsX3JPJ0IfDYHOJqIGCMpn6ApE2v+snWEUl4OkNXef55/NtVEvmiWt9tQwMjgHYOgx9dF4zYCy9S35pBpM5JhT6cAUzIRqySOaHB3pIBCGqmlku3RRQQMo0yq++ypX0AfQUFpa4aVy3PslfO214JBSQYQubACU62ooYnsX8t10AyrK5lDI59Ca2k2S5ft9XrwyV9s/i62K270Ltrwo1/xfcRmLAav15GVSiV813d9F973vvdh165dz3mZ69qea8T8YuXAz8faODCtfa8GDNw4PYCXDFpt9Nrv7jLA1fNRun2bCLunV0hoUUXhHB2ZdRz9V52o7uhHZglYviWPjQMVnP+zXdg40ov9f7qAaoeP0//2Lox8uRL1S/pHTpmyQB4Pgef+XQiPnjD7ZWaQEXUFsEFgGEUrRr5FvxPwqyW/bgaATpCri2ozrFKirOyOCmhTSfgagFAZDyFVMtleybwKK7B1Hgiidd98Dgq25IvEH6tV+ASmSV+ysGT2DEnWQRmG1Q0kGE23zoUnPblWS5dOS6lsevvSBkCz/1Z0WzNJA0w1u8ryL5YD89oRYBJoq8MiIDVvS/pML7D0AFuZHT1OKW9mny0zDrwe/EsHlGCY/cIEzvq5JSGRUm2n3yq2m8ve1vUDlz+OtwtIXmCcf97Z10uZQ7YAsPIbU7D1HMmcnhcnwhXOsrrmu9qgZyaRPANUXnYL5u40nyfXzfhR7TTgqDgaot5px8myj/6vqjtozm35VkNq1HXcR3nAbCP/macb+2DvvrRy2EoOO4abg9l8zG6mNdJYv1Ahk/tcaRktjZUqHNu03NwhbJTtcizkOKa91J127GZrBK8lN5tJCaNwgqR2dCmGOpHYMK8FtLICxj2URZtpdcGktGGUbBY6IWOsjPf2GKNxtd3zyuNIcZ5rAaEq+6SyR3od+I+no8RkLku3bYWJ3nOfdm5TJujYYnuxWQxeryP78R//cdx111145zvf+byWabVyuSz/1FY0a3O9RO4Jaui0X6zf6Wr2KLUAWM1cRrsmk6M4EZehdXgDmGTsghD1xWX4BEzbRpBcq6KeyaDrTF10TZNWzzW5eCcmX5fExmiAvid8DH8ihb4vFYG1Oay+ai+y8zXset8RA8buOYiV/QV0P0FJHkoTpRDWa/Ao46IlZFbeRZwae62N/mto+jxFukfZFVObST/cUiuuT61CydgadkklcZLSW2qeah9orYZgbsHIKLHfk+fNTCyj9T3dxiki6QWj6Iy0s2SXgI6fEZzyeaUjxAwwy3PpKLGMzErcSDSd+yNIpL6qLYnWY9YsqulRtSB3aS0SqRdSJgX03JZqCQqDsO2f5TWitJCWZ/NcJWOetIL2JnLPEmkx6aOyZFi8RgTIdLDYe8Z7wPUoHbWyZvYf23VpL8hYrmM1gZ8Gi7aSQWtdp50s2pUuI2491guVMNvfXrjIZna73LXMvLYDoq37v0Sw2li85bqfmYTX241goBupxRIK5+x4YK3zq2dx4od2I8kugjCJ9Epz8MG3t7j3iSUju8XqV7L1W1gbZVotoPQH+xukUSRMpGkFS3SOoQmwqS6tAlkFZjQNzrkkcw6XQZSRVA4EYVBvLkH2BvtF61SOM23cW4JUZoKpsaqf+WQ8pkmFUYjU1EpDToymWVLug2Ow5TkQ0+CpjrvOtQCvHbfBf60AXvTnlWW72NiPgnAFoS2lyNG1ccGqE6R0n3epJnLKqaPrGdtVt7jn9dpaDF6vE/vwhz+Mf/iHf8Cjjz6KmsOyGwRBxCh8Kcu0s1/6pV/Ce9/7XlxXpWWufMKlANernX29kEOgUiMvJiZidTa0vJggrrOAYHwC6D2A1GoN6YklmSSptSj3yA8x8GQd3qMhznxziP0fJGNtXUiOOh+dRHnvkJk002lUO9MipcNtMtPI++unyIxbEjAbvvxOKd8iiKQzxO8Clj4xI6ng1pIPkXE0epboECR8WyZbNaW1Kr2hIJgAkT1ASizCCZ33TDMD4gj5DYkZLucn4A0NmH7XgulTEiINOgmUvuG6ZKnm59wW11GCJEbDdbvSc2uugfSx8rhU75UmEq3Khu03jo8OIUEn7we3JfswxCTy2+BrOjl63A6jtnFUzL6llJpEJgSufK0l1CzJ5jVToM9lNSusJdVJo7/5wNn/cQ0ewNiei70gY7k+r60Zy3bLtWZhGYRqCYaEpdLFt3UF5pW2xEzpNILpGVxXtgVYvdy5xlSV2FaNaq2huUrGW8YeVitIzK8JYOo+GaLU5yGz5AmJk6xj90XN04HPmZph6lhHxsAWq0VscKw+0osEWeNpWunCsdIGVySw1qoYoEDNZZtWYj63hNjtA43GPAfkc15gWayCQR4nQSaDidrzSqBK0JxOwl9Ya+is0jgm2yytjOOtGWOtFmoXnOGco+O5+7xrppUq5O5zqHMDt6lEglIu7MwXboBT9y/Xtc3vRMn33Gtj5wYJQroEWAAeGP/1zduILbYb3GLqquvEvvKVrwgB0/DwMLLZrPybn5/Hz/zMz0TlwZeyTDvj98vLy9G/s2fPXhum4Zao4FYWAVc3CqvvtzJLGHHVjc5XU6bgeQLX5xPll5KnC/xkW7+70LJhgMTQgNEiZcmsZCPn5Svqp6aPnsPK3UOoD/eY0lnPw/ZP1pCdKSH3xWcw9GVf5Abm3rAdsy/twcJrtyMzbqPuZN59+IREwUns5A30w2ffFJ0eCzzXdhpWRgLQ6hvubtbC4+fqHNjsjGRphZiIEehalC2Uz1yn2ZnU5bi1H5aZSgJj0VnNGlIogjlmruggFIsIp2aN5iyzqOPnTXaG2yebMkt06VwJIC03HAY6COL82Gddy8T4l59JGXTVbEccsnojM0pnk71bBJbM6noWlAshR6JBOEUwzuACj5+l1hpZZyaD95jXTs/fnqtkR7h/7ZHi9eNxW+Aq14cRfpXnUZ3d2K5ru9pj+fM2d8zns8XfcqlkAKtrdqzn2Kr/Lns/l2pC6maCXvKb3jTP+Fe1LeO5bFu3LxUo/KdjRuuyco1NdYlUmChz/MJStEzHRJEJVqzuyct4U97Ri84zjRaY7hOh/EtthCh3eyj1eLYdwu5zbEgkXUhgx3+1sT6Mf+cOTLzelBXTwgIlw1JCUESAuvCWA1j8pkObD1jLjB0TEidbhcLXBKRRdte1QgfKt+1A+fadjfPvKsg8wz79YLBX/pn9BPDnV+Gfn5d/oKSSyipxHNfxmBU1HIeVoV7Gc5uB5fjJf46WrnzOcZ+gWYGzgmAXcKvpuerY3/qd8B9YAiblJZDgZWDBbjNgb+v/cD3NDF8Pkok3qdWdvter9+/yLQxDfPrTn8b/+T//R+aMdsZqno997GOiXnL8+PHnvMy1tDjzep3YL/7iL8o/1wYGBvDTP/3TkQzOpSzTzjKZjPy77k1LiKnfpqU5LeXFm5yWyyHn2HK/bZx2jWC3MFNeUcmcy7ULadPy/krPpif9q/WFxa2X16yr0O03MnnC4DsyhOU7+tH10SnRAvSePC4ZSUbZa3kfQSaH0qHb0P/IkoC8gekU1m4fROHInEjgaP8qHZjKy/YL42XYQRCZwNLLRxCkPGEpLnf6CKZmMfvPX4rBD3xNiDXW/vH9KJxZR/C1w/AJuurOfbAgTLevwFUcH6040P5ZZhXJ/Eht1VwO09+xG8MfOWOi7dY5kb7YzryRsbFag7JNZlGZAeZrdWaEKdiKzRMEMmOpRCB157lNpJqcGclmBqZsOCrTld4k1eqzy9MJokPFfzzGVTKE2OyBZETtuVvgLkaflYDTOkXi7EWZpsAQjPH+y31Nme+VzErW9w3Bk10u5D5J7LH8v5/bsxnbNbEbaixv/YjjjePAX3LJ8PNgFlZTkrcrsa0rbWzXoEWALQzgd9ry5nJZKlK2lBCyY7xUtGj20w6H9b4OybQmZ1agMLO2rUHmlJ8216IwUUbq4WflddeBBjDE5HRTv2ey3I2FA0ms7DQapbTxbxtGQqdqe4gjX3DKXq0xgKngUcZPOXFLzBSVAGumtdFWoucoIF36PfvkI4LY5LrZ8cLtBfQ/3iifp0yNv2QzwnYclmNgC4dKirnya0oipbI08phYYGkJ/mSdxWULfO1x8b5x7OZxWyCrAUfOO5G5wXmz0KaMdGRazSPXZzMQjY7XYdhvImqSYK1tkeF4Pvc77fcT201hH/zgB/Ff/st/QTKZxOHDh/GKV7wC3d2GjVyNAdA3vvGNUrm5b98+vOc978F/+A//AT/7sz97Wctca4vBa2zXl0nWqGImDDrl7qTtEiVcsf1dxIGSTFbQVDr8vOxKsFtaQEeCDrLkihGw2WslwPVCq9uJz/SXamTYSs5MzaDzw+cQ3r4fhYkK1t96FzqfnEGlO43CiVUs3NON1HoInDwrJajcTnpHr/QZSdBhY0MAvz/ajezEClZu60PnRhXrOwvYGPKlJK3cnRVH59R/ug+ZOcAvdGDlzbeK3I6A5VwW62+5Ex0PPC4lxonhIUNyRNCqvbJWuF2cGgV6BG08B+usBitr8Ls7MfTZOQGFxX39yB2bwal378TgYzUB3LWRHiQWN+DR+VjfMGCODg+zlAR9vP8Es+yXWlltsBdrabLzTESgVntu7b0K2+nS0slQQClkJ7ZUWJ0qNk9JxtUyKyvpksucrCXFaiIvYZ1Bfu70EZu+YifDZPctQSKbfb0kjc3YYrtU01YLBgBdLdfL7XV9jszGWx1Po2z/CgQ+n4dFgdA2BFJ1VntcyjZyJtPpnodUaLCqZn4N4byZC4p3Dcnf3HQZQdqOEQyABWQbziDVc5t81jG+Zph3M0kkFyzhUX835l7S07Tfch+QtFNPpY1aX7JoQVxnAbNv3yOvV3eZ8937e+ONcY5BPWaM+VrJiPQ+8Ty0Isfes8yZeRmzaRvb8qhlPSRLjXOXUmkbiIv6R3WOFCZ37U1tyM5ErSdOD61bci6lycyGa7BRTbO1TT2vFmgL2364uRxaSoWdfmB9Fh0JocbJtIzvzvciTSRjvI8QZi4yxxQ0KnZiw83e85pMJvF3f/d3WF1dxUtf+tK2y/zYj/0YhoaGJDubSqWkPfHbvu3b8Pa3vx333nvvJS9zrS0Gr9ex8cHzL1JOdSnL3HCm2aQtBu5rfiy0FuD6vHpfnyeAVadHIvJ6mLVL7CFjiRmdSdVXteZvH0OYzyB8xmj6Bbk0MqcXkGGf52AfMvMl1HqzyE/XJJt6+ifuwp7fPAavI4fE559E5bV3IbNRhkdAyT7XjixWb+nB6jYfC7d1o+fZUJyl/EyIcpeHUj97sIChR0s4/WO3wWdr6RPrKL3mdqQ/8wQKxxZRv/cgKr1p2TdBrc+eVDpjKp3A7Kk6Jg57sWZZfBIc8bdxfgbhjhEEaQ/lfQNSIkfgyu0kT08bUMoVLICT7ZDpl0bHZn3DZCbpTNkoN/v4NFvZnPUlqLQ9utrLbTOzPqPxzHgSmDoSDyL7EDgAUrMALJdWDVdb5huBZS2jtqWZUWWC/c2E7nFoGTEdLF43LSW2x216tRJx1vUmt0tmGr5EU4AqGdfnvbHnp+sqf/U3zSCT6lETvdFqL6zDf0mcD+2AL8c/p+xZGIeVOI62czT6ruOMGa8y6xV4lRqy48DsqwwRU4qtsFMlBOkk1reZrGFiaI/on7pWKwBdp0Pk5xiE9CTmqbYxBgSpEMff2Y1EycPY56so3rUDg58x/bOr7xpFZhGY+Cc7kVwHBh41YDXBsl43O85zIws7jUSJNA12rG8guZDCyu2NDLJch6Rv+nl5HPeaFqr8kxPmy9FBswz3UWo+HwkOagZTeBJsttVtY2l99niNFZCqli4DgTo2a++wZmFZJuOWD7dpjYrYl/Veatm4VPvY35FbNCplw853zE5rlZJW6lyJYHtsN7R9+7d/u/z9+te/3vZ7Ev595CMfwe///u8LKKV967d+K3bv3i1ZWwLTS1nmhbAYvF7HNjU1dUWWuSGsBQhKZPFq20UApPRpUv9zoB/B+WlTzjU4gGB27tpKJbRu4rlkyBwHR6Rh3OPwfDk/nq83OICNe7Yje37dTIzUxptdgL+YEJ3TdBhi/e4xVPpCrL9qH/KfPYbEthEkzi7i5LtGsfOj3ULEtHRnr0Tft31iQSbuIJdBz1M1LB/qRqLiYfTLFWRPLUj/VfVQEdv+LIWJX0lh7AdOIKQTcXIcif07ceg3juELf3Yf+ntux+lvS+DAH/YhcfgkvL5eIxnT0yUlzd4Tz0YSOZSf4flItlQd57NTSPXnUe5JoZr3UO/pEM0+r5pG/c59SFCnVaQb7HUhyRTLjkXWJm22xSyBJVWCSxDF0lwyF2tQIGIxtXI1KiXB8+LzJAzPtQZwdTOfwrRpy6Ilsm+ztOzz5Qq6Tz8pGRdxcVwyK1vO3NRDyJLmbPNxiGkptFOWHVtsz8euOHvwlTAtq8xlEUwZsiYJJCn4E83lywsoXom2kcY2Ln88d9nw3fkg4grobJT2rhw0ZYLe6UlU7zRZ0IAyLQD6n1qT3tVSfwKdXzLMwt3P1hGOGcBX7TdkW/nZOvLHl0CoW+81ny3empOxlNYxHaBjGkiUA6zuMGPJyi7j6OaOA0svHUbf0wGCpIfcbPPcvvLyHeaY0h6W95rj2vl/DX+CVNpQK5uvN8oILZletO4eH6NfKKGeS6G6pxnQ1nYNIbG80Tyu09zArY6TCmCVZdhtUYrKeO34Kss7ygR6/RW06v1ktpbPFXt5nWerKZvsbwacTd+7xJZWAzw6PlrCZnPbWFwy/OK1lRaW+efaTnL06FEhf7399tubPuf7p5566pKXeSEs9lhie+HtWmVVOYG45BzqsLQ6LnYZAawEDsw+KhHG3MLz2/8LaRfq7bUAavWlO8QBWbqtCz1/Yfqgqq+9E6m5IkpjHch++il0HE7ilpNp1LtyRppgbkEA8e5fnhLZBPaS9j48i3pnDt7krESp/cFe1AtZrOz20X0ywPpoCtMvHcHgo1Uc+K+rWD3Ui6H3ZbH6hoPofHYZM6/oxeAfP4Yz3zGM0eE1iaofel+AoLeA8z9wJ8b+6jTKd+5EZnwJ576xgF1TJoNQ3TOI9PFp+CNDpgyY2Rarm5d+dgq1u7ahnksYTdZaHUFfQULyXrmG2mAnEitFeNRpJeATMg9LqCH9UHWrgGjLzbSvVMvLyMZJll9SKwiRki1pFqcnZQma2KdL+SBT8hwxbavzpM4QmTQJzknUxNJjJ4sK7lKkcgikW/qdFOzWrYSEkmRxG9o7xmNVPVvrHD0w/VtX7bGL7eaxqyKD8zzLheV3xIDRzFwju0fzPemLZ3vB9WCXy6egy8l6LRk72sJLDJirFjyMfGoWGBqIQOvKbnMd+p+soGPKbGf8Xfsx/HVTzZOeMwAvfWpWMo3p80Ct32Su/XIDfCZsIjO9Upc2ETme0IDNtdEkcvMBVu4ZRrJo9nH2rSF2/51Z5/zrTF8vq256TtaAcohyb+P4z76D/a19KJwL0fvYvLSmqGWWqph4nXHWy70GJKfWzBiaLLIsl2DYh8/KNLLG07TX1mpjm52rFJvdtqvlrlwK0pub2CRZEwUKlPGdw6lDNCjjrL/5NyBjf8Q14ZQdsyqG43RrFla/b8d8zGOzhIbuOg/Mvn/TfmO7ulYPffl3tfdB27HDBHzUfu7nfk56Wy/XlMCpp6e5LaCvrw8nTpy45GVeCIvBa2xXh2n4cswO/k0D/5U0BajtxOjbRdxdkCvRT9PzSmAmgPZ6sa3A94WWbyl7jlgzk0lUtnULKVOl00ffY4uovPpOpL7yNIKEJ2yTq9tTyFMPdWkZc6+/FZ3nqjj1j0Zw4HdDeOx13bsDwcmzwJTpuyl/491Ip7YjeXYOQUcGi7flkZ0DMos1dD14DL0WFFZfcZvsN/nESXQNDaC0uxcbw8C5f3UPdvzuEZz/x9uQXi2gWgCGv7IupWpLr92J/FQFx/7lEPqfCBH0dwlJx9TLssgc3IXhj04AzK4Ui9h4yW5sDCTQe3gNG0NJpFZDhLkU6pkclvfnJRNQGh5Ax8llU1ZGR8bpOYuIkoREykS6tU/Lk3JcK1NB4EoWZO2V1Sg6rzVLjFkybMt5hRzLLue1EJJFTMJWaJ7bjiLyqmfIzKz0yTokJ+r0ag+dZXMW0C3OlW/649ysLHt47bnEFtt1l3G9QgRLkXMfaV/6CLTs/wUMKnL8JcEeLbjEPld33WhMd8ANx2HXusatHIwA2Yac3tCDZ+RvalsOudkKuk4BSZW+IV/RYAfQm0OibEHhuTnz1WAPJl/fFfW+bv+EAbwS9BPrRnKjjp4TdaQWTFvH1Gt6EKSAzuPA8l5zDOyUWL/drFsa0KxRiH0fWkeQT2NjLEB6ycfSLR56HzPfVmwmeOrlGVQ7zbNx7lvN8XU/msbqbvNZ10kPI59r5n4Iewrw1ssmkKj3XMdKldqRMmL7HXkPolJgy0mgy9KcShnNtkYyb9ouYoOITWO2W1Jsg4pStt4atEg4y3FzCmpFD9xkc5sArtykWNP1ZrCzZ8+iq8v8BmnPlcQvZytQ1qll7xh7ZPW7S1nmhbAYvMb2wlkrAcHVsnaZVRegtgO1UUbNh5fPN0Vur2iva7t9X8J2Evt2yfWrnxpv3o5uayvtQAFg9Ya+az4v5ET1W3ehOJhGz5OL8OaXUTkwiswTpxHu34XMXBFz93ajY7pmSJB2jKEwWUP22BT2P7yOc99/CF1nhpBZrmH+G+4REpDRvzqO/JOTAtrYb7q6Oy8ZTko2zN6dxo6zw8D0nEzw6bMLyKcHUD+0G2HKR+bLx7Dn5ABW7xrC2X9xm6wz8MklzP23GpIPBAhSHeh5dA6nv30I9c4quk7X4c8s4dw/2yURd43yT37zNiTKwPBnZ7C0bwiV/iwkcOkB4+/oxtCjNRT7Pcx8Y4iBz/hYH+rD0JcXDLtmXw8qI11In5oRzURwclDBejoy6vR05EzEXJ1HL2gA2FK5wegrGoxOeZewFvM+WE1DKxvSyi4smSyCXS0ttlq1Kh0k27ZyC6J7yDJkgm91rOReG5DrUX+Q5moaqh5sbLFdK7DqAlL3N3ENmIDl98jfmZLzvEDAVcZeNwtM08BUmzLipkCj2YD5w/GH35fKQnxHK24zTm3vU8vAUcthoHPWHYNYG7MAJ+Fj9o3b5WV+snEdan1mO0HaLJf88mHzxcgQireOmO8SQOdEiI6pZrZbBhFz59ZQHjLb8NfKqI50YfCxIqZfao61OACURi3YW26QINVuMSW+lPRJvGca27CKc+cNu/D4t5rKmvQKUMsy+wsktpnlg/UUEtk61l5ZRPJkDqNfaO5rDbpyttKGlTv2uBZWG2O4Bv6UQ4JjPMdUjo+WR0FMSaYYcBT5osb9i0Bpu8ytEgpa3fKGlJSthrHjdiuBmIz/ymrvPguuJix1yRUEW1b7Bxd+t2n52K6NkU6Ss+zV3getq6urCbw+VyNzMO306dO44447os/5/mUve9klL/NCWAxeY3vxlAdfqiPiZivblRG3LEsGXXl5BXhHttQUbPf5BQB3/cSZy99H08Rry5RIQtTTDX9uFV1HzxjJhTBAcm5eqlPX9+5HteBj4JEl4Nhp+F0F6Qc9800J3Ho8JWB27H99PSKCGv6Mic7VOSmz5HXvDlSGC5LNTa8FyJ8oIeSknUoguGWHRPj9Sg0bwynkfA/ZLz8Db2xYMp2FTx1D6B1E59OL8FbXsfzUTiz8hzIKjwKrh/pRPFBBR1cR9UweZ75vFyo9IYbvmcb850fQn0pi+WCA4S97wOo6Rj+1gJPf0YdaIcTx73o/fnTyZfiHA3cgMZvArb+6Ig5b6vh5BCN9qO4dQvrkDNKnDYsnPxMWS16/+UVTiktNQzoRInNjMqRimbRxMlMpUwLsAFhzb8haaYlBFACIzI5hgNZsa/QZwSidbYJPZeJO2v5aZo4s+7GSRbGXT8Aoo/zlssnw6rG5LJdahlyp4sGV39/6WYottqsBWl8o42/oCrBqtxL2teq+bgU2nQWil1HZ8gWkzUT+hoBXezLHDHswJmcsCVvKMLIzU3JyAWHWgEL3iq9+yz3yd/QTMwhOn5PxffCzxgWsDRpHOHz2NFLkeiC2mjVESjR/pwG5oe+hNJBE4XyIruPmuOtZU11S2TuE4oAZ5wrj60icmDQrj5ht9z1dxeItKQGgfs0Au+IIeSTKqA0CwUwW2RkfS/uAxEct0dRdNqtbY5a2Ak7BYcVcS+7p2Gv/UF7v+/gPYOijmaYzPvu2XmxsN9d071+bzFRyuSSAWqprFLzq86DSPSzlVZ1u12wbiAQqW/RcFTy6rRjOlw19bfe7QKtsGs9ja+ZW9cyj7ehyGuBUlnpn3dhiu1QbHR3FfffdJ9qt3/zN3xz1uD766KP4+Z//+Ute5oWwGLzGdmXNjSxyUN1KjkA/50RwqRI4TeW8zzNiHknEXIcEI5Fz1Frme/F+CkbfBdiUy6ZE1PZAkowpIEnR1IJh0F1ZlT7VYGkZPrN3nTkE+3fAe+JYk/PV+cWTcn9Y0sbPgpr5e+v7EqhbHUC+T+zfgfrx05FGoUeiJxIoeR7Sk6sYnF5DeYR9p+cR9nTBY/bQ95HYIJhNoPeJJXgLKwgIzhaWovPpfOiIgNnF1+5ArSPA7j9JoNQfIjdTRsfhPHpOJJBaLaN0Rw2jf5XGVGIY9e01LL50CF5PGUu3MNu6G4VzFfQfCTB3p49b/uiHsf9PltD38gx6jpdRHu2CXw1w+j17Ub9nDclHcxjMjyF/wpBNre3pROfxEDhnyNGEuEmfc2XrtRqw8pplZBtFEzV3CT6sGL3cF82yWGdHHWplBZaMq5M5jfpblT1YyKNs6TG3p9F9lhgHAXyuqw6Orq+mzlosjRPblgNQs6b2pYBWV3vyksGqVBI4yynLaqvW55U0d3/PYz4RcKqAwTlO+V22kP8ISV4r0Y+bpWtjPrVR5UWDZK2yy3yWmjfbq92+G6lxU84rVS67RgW+SWZRoZw9ts6PPG6CcW32lRyfkblAxqeFJYT7dwB9nQbocb+jXUiUasgslJBeaYAkBiI5dlY7zfjSMVlCctr0yKmljozLfeQZ5I+Zvrkz3zmG9DKQXvZRP5VDyl4estC7ls5VkXykIEz1Clppe/easfgfH38Lnp0bQK7A4zQAdeb+FAZfPwnZ1MfG0HmOHAtpdJ1Yl6BpdK8YiNXAgbZSEEi2I0DiZzYjK1lS11rAY5NmrQYJm565xvYjRmDLSyCf8VmU38FmQq6m3xTXgakiiMZ3BwjH9uLteb1Ue/LJJ/Hwww9LlpT2N3/zNwJGX/nKV+LgwYPy2a//+q/jzW9+szAJHzp0CO9///vxjne8IwKql7rMtTYvDK+HcGhs15qpjELFbMR+vqUH0vPa4uiIuf0hW4BSyUBJxugCjkOrU3EhPUorGyJOlPaHEJg5ciqXZBfpIb0STJOuUd6Ajoy/d5cw+4qjQ7D6PHqApSyN/QhjwwjzaeCp43JOxbfeg+RaHZmnzhidV4kGG8CpLMQXOj/NJsjyu0cRPm7Arnx2cI+UZq3cMYCOM+uSURXwlU7Cn11G+cCIZAGTiyWEmQSqXRmk5zdEtgETM43JX3s87f0sv/wgUp96FH6hIN/Nfc+96D5RRubENM58707pB8osAUsHQ4TJEDsfqKPck0CY8FDLeFjeD3TdOY/v2P0I/uJ/vhnlHvZqhRj+WoiupxawdE8fyt0+am9bwvrJbhx832kTZc/nMP+yAfQ/dMpkMXu6Ec7ObyoXE6dD+s9Ys2wzpzx2ZkCtrI84qqrBap0fAai6vJJuOFlXZyeRhm2Tpq0CXC09VtkcKzOlUjnRawfIauT+xUTscSXHtZvtnN/W/Z7NH7rkMM5z186i58sdm9vps+rYYqWfZDH93Ts9fFEpu+ogy7oNYprnlMXdaly7XODqZlF1POzqND32sh+r68zMZSsQoob0BTK2F9tn7RVGjzV9ZByrrzblfJ2PTAjjOo1jKi377LSAUDk9zTC2ayfxPdRefkheph49Ieztcux9hkxp6fZuKRGmUSZN9r1SjbRiPdvTSdKk7JwB4xF4JdBTcOjoqUbXhEzx3eaare4x5bzLe8x2O8+GqNthlj2vsrn+GpIFcy7JZ3IobTOvf+DlX5C/f/yRb8DAPYZNuiNdxokzJoM88pAZ6xI2VkD/v+Os8QmSZxwOC3udov7ojnzjWNuBVjXLg6DXM/rM5SPQ79TXaffb0NaT1m23Wpt1RT+c4/n5/4UXg91IY7ke60998ZuQKbRoAV9hK69V8auv+sglXxdK3PzlX/7lps+///u/H294wxui90eOHMEf/dEfYXFxUfRg+T1lOF27lGWupcXg9Sa0KwpeC9+/+UOHfEbscsGeW5bjOhbaZ0LHRx0e9qFaB76pF6SN2Hg7RuFN+7iAXSnQStDukwXXRnNZlmzKS6sGyPJcWoXrL7bNLXRnxTmyA4zf24PqniGknj5rtOpsqSmvYVAsmePq6kRAsXhmD7cIEkjZsQq72z5gf/soKtt6kFosojLUgfWRNLpOFSNHpt5bQGJ2SfqGavsoCBgiyBBsAam5dWEuJthMPvps0+TM0mMJROwcFamEoJCDP2UyDcuv3YvOZ1cE/Eq2NpNG0NuFxbu7MXdfiNyED//VS6h/uQe7PjiB09+zTUDu+uvWUZ/IY+jQLKofGkLpm5fR+4cFvOm9n8PHpw4i/7MFzN/dKUB74C+eFMbiUz+4F3t+6xnTA8XrRmdGyY8UPPLa8Hgtq6+SNsn1t395vaTsmKW+tiRYiZUkmEMnr7X8y9VxdcEr7yGfE26vUm0AWhdktLJTOveQWeEXk5zCjeTwXHfgtfefmxet4LQNSGwFsJGesC7vbZ0x0mdbgEE7fXIXQERjeeP31XZMutS+2Xbj93OtvGmjx9mkq6nH6cpSbVVSfDn7cwAOf/8ahFp48375m5+uihwNbXmfcaRH//pkdK0jtnwnqEwOAzKzi3EskYMMUdlt5HLOvdEAzJEvm3uTWSwjMWvIpWpD3VFbArOwasnjRmOVAVEdkyg3JtbVKZriZh1zrCu3mGe358sTWLvblAyTOyE7a+aXE//GPDcDH8li+tXmnt36fnMMr/jjx/Hnf/EN5vIUga4z5vvJd5hr7tu+2t7DHuZfa4IiB37LfJecW21cU5u1FC3xNoGbtuCy9ZmyGvVNtoWUTVSV06byIPJ/3N+aE8Rp/e3InPIiYo2/kcZyPdb/5wvffE3A6//31X9/Q1yXq21x2XBsV0fU3nUi3OyrzVBpmYtkpGx5ceTw22ygGIESe/xsZDHajpYcq+4mgY47oDNJ5ZZHtusD3SorfJmaf5drPMe6UxrrOnWBkkZc7ja3AK7yuXUIqU+bmJ1DnWW+Pdtx6ntHUe4LUDhDKRagMBkis1xH7uQSgmcN0UeitzsC1o2sh+mV5TmIE3bnLQieOo7E6XF4Q4MoH+gWAfvSQBq5eicS5+aQmCiaEuXtYyJHw8k3ObWBsCMj2Vr/sWdMVkKz5dZhDVdXhQ3Xm1syxEWUS6DDlkqh8x+eMCV6wwNYe4XRL8wsVND34afR9/cejv2PPeh+qAejX1vF7BvHBLiO/NnT8D5on5t6HUd+sRd73p9HeqmIh977Oiwe8LH8GmBjW4i9f1PE+htvg18JMfq6cwD9Akbf+WwziDLUB5yfbZT2EpDajFHIJi25gE7pr7y3ZfL6G9Cgi+PMym9A37tAXjOrUQ+rJQnRZ8Z18B0CKPMsOL8VXudaDR9d/t/P6VmL7UVsGozZwlzg2lodsHnhZqZV+dvnyC1cKEDXNH+YQM8lLXs59nzGeF2XPy/2OzLw2NezmTHYBbTWtgSuTgmz32PkZqSU192no1cartWkGsS1ck9Sqkjk0FLA9r+fAhgosEHG6qtuR+a8Ocbw/AywfdiMuUokynF+0GRxV/bYTKm1amcC3Y/Nmje+j3pfh7R/uOBMQSvHx6oFv8nHjtvzs0GNbAr1gpnP/aJJh/Y8MovaQAG1sT6UehNY3meW3f0Rs+r2P0khPc9xbgM9TznPQhDgy++8E7tnj0dj4cqbTSa545hJ3fa8cQp7u+aBVwCfe8aA/I2xLOoZD9iTQ6nXXK/Rj54XWTwtf9ey7qgkV1s/XNPnOt3oOdbfSOSP2LaQ6PcSZXOdZyMqP3cytq3mchbocdg5gXNGTNQU281kMXiN7XlZRBbTzoFozX66RAPqjDhgVBiHtbQpkZD+TRn0RauzZoADyX5IkkOrWOfdKbc0H9jXum2XVdh1WC6DbfJKlwo3iY7TwZFs8+X3q2zqM7vAMbu6gMG589j9/87B6+02LIqdBYk4j//wbdg5bq7XwrtegoGvGvZdklRI1F4YE01mvPqGu5H+7FNSOpzYuU2i8Ms7cghSHtJrIdJLVdTyKXizcwJACVxlIk8lUOvMIOzPI3NuCfWTpw0IJauz7wnzceLoGZPFHOgxZcVOCWFl/4j0fHmFHbKtxdu60XN0FUEmieJwBqmX7JeyuYM/egLeyKCsN/DVipHBGezH3CsH0f/ho3IOt/6rx0023/PQedRHceB2lN66jPpsB579/jRef/dRHFscQu93b2D59ful92p91BfyEZ5nRy2QUmI/m0XAiH1roEafMd4nBbaWmCkqZ9dSScsyKt9L9MWUcMtz0qYkM/oNtct2tRDTyG+0VG4wGsfkHrG5plklt0yxDfGMW7q+ZVbWyVpFpcHMuvF5ZCDMjt/Sm6/am00VMpszrm3tQmNyK0C8mmSBqgE+v9CoclHwSVK1C43rBL733CIvV/bmkZ+x2c0nDYu839+HoCXQ2bRrey17HzjaCAiXyghu3dWyH0/aNsQsyPL6eyN6I46ztPJwAct7lVzO/Ekz6PdVm5mt1rBxuynHzcya7ZT7MqjlDfhK53chud4caKjdYwBjcqkIr1iRf+jSEmtmWAMBtMzCsgy555kNLO8zZcSnv7mAPX+7guzUhuFr4CoDPagOmPVXdppjXbjTsBLf8t4jSK+Y+aL/sI+5O5JY/NQIvnK/1ahNBuh4OIeV3UDiDQtYO0KgHmLgcWDx5SPofWhVgLd0nPYbEB9MklK5uRe7cXJmX01Zd72mCmJtAN4NLjYF2mlOpYG73lbl+lEwMiZqum6sDl/+Xe19xGYsBq+xPS/bEri2OhAqwO5KFLTLhjLLysFeylpDmSyljKfdAO5MJALi3GNxs7ftDxwvtDX1tDJyf3APcGbyotlXyajedRBruzuQLAXIj68iSCdR70ihlksgtVZF8vETUgrcaon9uxFOTJmMdl8Pwpk5A3KWllF75R3Y8dAKgqdPyD76/+RReIP9qO4dRuIrh82km8lg9R13oevwAjIPn0DlVbejnk9IqVq5y0eiGiJRCpCuhEg/fdb00R7aL/dlY0cnUssVpKZXUd1WQKIcoDbYiUR6H4JCFgEBcsqXfi709khpmQBOngf/8ZlYXkFKy2z374RXraP3kXms3NEn/aud82vmmaGzvLwKrBcRLJAhOC2OWvXuvVje72HpJw9h/x/OYuGlA+g8W8bqjgySpRDDn5zG2tQARtZqmHhdBp/J3ILUZBo9oykkKgEO/cen8OXzu3Dm/hzG/jYtrJ1yTzxfMi/h2ro847y3fiqDsE6JHFs2Z+VuCDoFyFqnJvpN2N8FwaoA90oFid4eyZg3MRrLwxNGzNHRs6zBGZV+aNUA5m+L14X7u1qayrHduKbPxFbj+UUynNH4rI4+y1qztr2ABGbU0HSXVxIj+W2kN2lbNmWgLrcFpU3g9JqYBTFNGdOtTMcFG5zrPrqCap8BZRsvNZUktNy4AZbhCSuLpgFErjs0gOW7TYYzP1VC8siZpvLWcGrGBH+5mtV4TY4aoMfS34X7DENSteChahXhuk+b614c8JGdD8A76JfY55pEbaSROS+O5pFeriJZrCN/+LzZ3/Iq6rftltdKJCW9v8xk8o0NZiTJam9LlSVrSUKnCaB+cKd8tutBAlhzLfy1xjzGdbz1DWzcdqu8n3tJgL0fqqHrNDD+tjSO/+xtCLaXMPCgee66xs1zsHA/UD/VIaC0/Io1A8xLjecxN1tFarGM+q5RkdUx96Uq19ofGgDWLHjXdhnNsPNZ5ziulVNWmUB8GGa87bMvnzFAzLYR9xlQ0Ktl9fmcfM95U+ZbAulcNlqHmX1/5zazStKHV7brX8rzFltsLyKLwWtsV98cR0IikC5xTWtpmZ0ITPmwIZ6Jvlc9NBe4spTU2VUEBiST+RxB6gsEbINjplTXNZnYW8rrSMTkz62gq1hGeawLG7s6UepJoPfwCtLHF01GLwzh57JNAJagKDh5RkBqqT8Fn9Wq5UHkHz8rTJWJLzxpmCo78qaHxvNw6j27sOdPp4DRYWwcGoFfC1HPeph/eT+CxIABq5UQncfXkVzPID27gSCfQnJyQQiPvNFBBKkE6tkEvFqIxGoFtf4COp6YFKeGIE2ZOHkfeVcDgvOFxYYTwIwsAWGxaMrzcln4wwMIx89HE3z33IK8DnaNotbVheTXjgpAnHr3bRj7wLK83njLXTj7DpbN1rH77+pYuqcf/V+cQmVHr5CC7Pv1Z/DMb+xE5xcSWNuewIEPnMfca0aQWalj4e4eVP7ZIrpSJSxPd2L33wHZTz0hz9nGm+9E4fPHjWxNXw8824dNR4MZZynF47NMQEtHJJ2Sc5b+4sWlRg9cMgm/t884RpS9YeUBe8YoOWSzVNobGxmXGxyQ7TBgw75mcfAKWZOd3Siiftd+JCcXgWzaBAG6OvDg4//16j3Isd1QFvW7tjO3X0/HXBlfG1qhYnyG1QGXcdx+rlUyjhMv6/J595MNGRArC+JuUwKYuv9yxYz97JFsRwD1QsmzXcDcSpd2rMRq1KimBUM9WNpnymkHv7YE7/hZu4DfknFLS9ZNxpZyWYCn7M/th330qPmMr63+a/a8Xn8PK8xs7iM3gSfzgAtaaam1uvxLbtSQXNR+WHOvcuMrJntK03vqns8jhsSvLtnEloCz5QXg/dS5TRnW5dCePhPd3/7xQkNLm1bIY/UVBtyuD5MkD+g8wXcGwI19ro6OpwwBk4Ls1b15rI15SH+lgG2fXMbk67qByQLKrzZEUol9a6hVExh/D1BfNGDz1t+wFTKcA6dn4ZGMyw28kBGfIJbHqSRU6+Y6kMtCqwkicM5SeRsY0t5UOWctA24TFPK3jSIoZMz9s4zPYTKBYPewsEVL642z3oul1/VGtiD05N/V3kdsxmLwGttztk3Mkq2lu/oVJ1oO8pzAOVlZKnkpc3J7N2gWsEbZKJoj6C46lqptpuQIGunnMr4HX7JLFOwub2bsvQ4yrpdj7YibyBLs2V7h7FIfll67E71//rBE4+kwiLPETGBPFxKMGlerCKZm4A/2y9+l/WbCHfr0eXEi6o6en24/0TMi94rAlbIzmcU6wqSHle0s7wJS6yFy8zXR/cvOlBBkE0gvliSL4FM4ncRT6STCY6fkePxKRXT5kEzB5z0YGzXZ0I2NqAdMn6eg6jh9zDCQeZhAWJyFEAHBOeUctC+W95nXg3qHpyaRJnFTGCLR34fR337UgMKd2zB7TwLZc8Ce3zyG+tISMtx/Oo3U3AL2fKmMZ37hXuz/gUcNOLRBkP6/moW3fRSL9/Zj9N2z+Oi7XoEdp+s4+84K8N0HcfAX1rAxkMDiuw9i+OGSMHbK/dGydx6X58lrfs6SPq0qqM/Ny/PMYEGd+rGWUCX6vbhl9sqeraWWmmHlOotL8EeGDFBQJmGrU0jHNUm9RTKh8rfArD5LGWOLTc0dx7WHzy1VbxlDpc/S6UEVUGmlPYThnOZ+3yIJE7VL6P7cXj5bxSBs3zQGMksMBvnw6m0YjZ+rXU1Og3Zswk1z5eaKo3BlFd7KKrqGOkTrWhZjS4fNZop0Da1cFWkx+Z4ar8wunrQBSgarnKodldpZu21A/uYmNlAaNfen2O+h82wdvc8angBaaTCD7Lx5TRI9b9rMCxpcTA4bbdlgeibKoEZcFLbEleO0cCTUqpv6eGW8F21sO17bQKwYq2Va7qsGMH2OdzZ73PX5k1h/2W70ngiweMA8oylqt66WRCgnZNDOGuekjskyOk8H0gJy7EAHOp8232W+UMDAYXMM2ceMjMjT792H9EARJ9+bRe6zBQw8WQKGbhF5N3Mg5lxWX7UXy3vNPdj+IZMNN0FU2xu702rUnpk0wJdEULw+GkhOJqQKQX43WqavUmnMzDLYwOCmMm6zCidts+YzNuOr29qKDCq22F7kFoPX2J63KZGMTE6a9WRJI9/b8kj5fKPYkPxwMq/CvKtkNCypZHZJSixtqSMjtE4EX6nptQxNtk0HSwCzJxHPTQ7O83RWtmLzvaK2RSl1a1+rTJKUX7G6ooUzxcbnZQNqvAO7URwtIDNXhHfinIjMl3f1IhOEGPzQYZRecQuC7jy8Z+c2HYN3zyGUepm5A7Jnl6WcrbitIPIzA4+uSG8SNVqTi+uoDnXCL9fgFavw5hcN2N7YEFIobqvyjfci87nDInMjWXFLhBHMzMIfGpTPWGqlzoxmIflXXoeBlFFLX5RIz1AD1UPoUrQL4Zc5dmG33NiQXjFmkyVzOzSAo/+hCwfe8zUkto8J+E0MD5lM0PZhBEdPSkZ03898HV6XiZyf/dd3YeRLZayPpdHzN4+jt1LFsz91ELs/UkTiq0/jwEcC1F5xO77vw5/Af3r4W1EvJrF+N3Drv8/h+H+5Dbf83gLOvq0f2z9wBPPfdggdk1X41VCuXfaZKdEX5LHQMaVzkxgbRn3iPBI9PSIhERLE8hwJVlV/UXtVpZfWMLyyt44liiLhQ7C8tGxKgy2hWUiCK67Pa9iRl9/Ggyu/f9Ue4dhuQLtY75x+rv13DH606ljKa8eRVpKb0GapaHyeFZS2KVuP2GgZ4LQgzCVqauoTfL5j8ZXSC7e21dzgZl8br50yf7ZKMPg0NCivc8fnAGpkWwsGe4DBHiwdMp/1PL0K/7wFlcoQzFs4bvtBWX1h11/8Blu+ux4gd35DxshEMYBfCzDwZA2paRPEqg52IEgnkF52AsZnpxBs0jM1Pcucr7UsOgKvHNeH+4FT5yybug1IyrzcAGgy/jvPmgTzbKCktQ+0iQSP80NLhlKAo31O1l65V/52nFgCTk+I65BQGTEAh/6bycSSybjw2KS8Xr1/G/KTRdT3jqE4ksOOjwIL766j6895/QKkJ0xG/MSPmBLuHKVlW6bnyW/bibE/OSbnU7zH9BlnJ1bgTc0L6CwfHEPmKOuhHX+Ex8S5jf3Onj0n+jm2zLjJNIi5yHnC+c1wPrBZ75io6fqwAL78u9r7iM1YDF5je866gH4+3wAdLOvUAVp5ZJSQxtXscyLnkUwIgSk/0yi81bUU0gtboiYAVllYrZZlsFpuZKYskFNdzasRYb8qAHYr+R79jhNca0SapbNk4B0dkmuVOHIaXneXRMPHv+9O5KdDdJ2uIL1Uhj+9iGDXGMKnjyM1fg5hLicOBwGlt3eH0S+V/pwcarftErH53MQaso+fNteyuwtBJiWSBR1P2t5jsgwPDaA22GVKyngPT44jsFnfyEnLZJD5/BGbFa0j1P5LKx1DoCX7t/fdEFnYLHrEtsvzryAs6jNDEiMfXmvpIrOuzAZo9pYkJ/ZZCSencPBHZiVLTNAsALuzA14ygeJYJzInU/L8EsCGLP/yPez8uzmUtnWh73NnEWYzCM5PY/8vzGH8R+/CrslR1M+cQz2XxB+96VXAj+Vw6H+Mi4NF4HvLf3oS2DWGHX89iRP/9jb0Hw5w+lsT8Ms+9t17FvjuityDsLsgpdVSEknQyeOnc08JHQs0NZpP4qlwfCJyYJhVF6Zi/nZ4/4ZN3xsj9nLfeCwMAvFceQ1JhsZSPZbsxRabY9qu0URAY/upxcG2RGLmh9UiwaTjtpqCTv7OVfbGZV/VzK4CWtmnzTqVzViySSqnnfTOdWatc0NUTWI/ayuPw2ukp0SgyICUY6VbRlDpMvel71NnIpmbwOlhlz9fPybZWF5TAa7Ote15ygAwVsRwHGdbh79qQG9og7/pkzNRWSz5JURnu/X8CJYWbWBMjYFHGyAUO3Wu6TnSqif6CVGr0Npay7107qmO/ZpZdsGsA1zznzoiz5TOnNWXH0JqpWZAIhfVYEqLpAznrY5PLUWZ68KnjiGwPbYLt9gqlsDDzEvM+j1fN+vt/YtFac2hzdxrn986kNY2044cgoFuCRRXu7OoDHUilUmhygCwY8HOYfgs93XPh3OpDTZIv7Al2kpOWZIu6uS2mf/524oyvbHFdhNaDF5je+5my3kFdJBkxgFfMgFuyn46LJScVDTbakFnxDxpTdhbtY/HLUl2iJ8ilr/IcVAmTFtWaaUMtgKxFwKj7SQNrjiAbUdadcHFrVNEQHhyHPV7D8I/WZRAgd/ZiR3/49FIeoiTnmRAp0x5mazHaL1G7J89I/2kUqZUryN1dh6J2XmEDB7ctg/+4hrCTBJJavqtromEAmVtCJTp5CSYHWQ5LJ0qZmztsYlWrYKnRAKJoUEpTfazSfncH+iTLKNE0z3P9OVSHqJQQH1lVdbXwIgSYETHL9eeGUgLVB0AK9fEEYSPeqd5z/iX723/6fTrhpBdCtD5kSdMdN+WranWanD0BDLHU6jxeNmnah3Fnf/zCQTWGSfb8PEf3ol6ro7x3+jB9l/wMHt/F3qPleAFIVITFdRzIbqfWEDPp5dMNopOYqJuyuuYWQhDrN41jDAxIoRQ5a4Eev76MSnxDndvw8bOAlI7+pB+6gx8XvdyGX7PgDhihrSJEh29AnorI51IL6+gPj0r11B/U9wX+28T6TQemH3/c31SY7sZTMGlW47I39mFgKPD7h4BXYKXC0nuMHvrVuC02+bzsa2Clq3j7XPQ+960rl3vucwX/J23mrQOJBLIfGUZaQIVVpS0W1lbCQgO5Tic/WwU0fuQo5nNa60kQ2wx4HpsrSFhH98sOWOpHjsBcb8hd2LwzuwrZxiU2YrBAJvKsFlQyjko0v5WwiKZC5pLx11rBLOdHmg9Zuc828rQuNuRDG2bZ4mBUfoSrsyM3bZ/xPBM7DgCVO87AHw1jdPfYhZ79geHsf2TZt8dz1h93HuHkLNqQX1HSkisV1Ef6jWSQSwa6E6i80kz32YWbHtGOoXaNnOfl243peB9XzyPjVsYcBxEZqGEepbnPQDfKigE3R3wz5lrHgUjeA27u6S9hP2vksG2ZJaxvfBWDz35d7X3EZuxGLzG9pxMJhxOUtrrSoKaarmR/XIn0hYReZ14NjktrlyCmmZRNQtJMOMKxLc6Bha0mXUbuqTR7p2y1IueY0sk/UpnXZtLydpsv11vFJe551Z4TxxDcN8hJJ46EUXJ667GYKuv6TLS2r4zAT3MlIS+maHCAAD3PUlEQVShyDwIkKXDQiKhJ58xjL/np+W9BAnIhOz0Jgkh1MJiBPp4LyTyz2fB9tEKCLPHJcB17y4EZwxDr/Sqch1mPG0fVHJ0GMHcPILVVdnXpkysnk5TltY+Tyy9skDUnLItYVcnL8E+oxr8dBpDf/aE2ZAur/qreulJkuT7SDDj71YVOJqr+c8dw77PQfrRzr+2G89+TyhSD8N/dUZAdxCEuOW/r+L4b25H/Xwfdv/fKjLPTke6i+wp23jZXhSOm1I3OoYddN4oj0GwXypj+p/0YO/vT6N8lykBPPm9Pvb9QQ2Jvk74x05Lr+v8q0fR//FTSK9tmPMjyyvvWanUyGLcfRCYX73Q4xjbTWoCQEIHXLT20fF3oWBBAanKf+gi+vtwgEb0u9Te9FYQ3A4Qt+vh4xzQbm5oOsbghet1bdXvdMtiWVnSBtQS5KnWdLR+uYJgaWVL6RVz+Ha+0N81g1TbDBjFjAFYwrTeaYAj2diVEV0DwcJ/oMCS439LxlPuNwMRbE2ZoY61uWYytrPNh1U++hy47SwMDnJ+doISShi4pbate72Ux6KFN8NtNWoHWtNff2ZTll6rt5rkllTqyT1uCaI3b3P7p+rCik9LrjR6iEk0uOPjGzjz4wH2/WeTQa3bHlthjK6HKBxbNNUvtFwO9aEus5tyDWffbF6PfK2M8p5+rI8lsbKbx5vCjo+b7W1sy6Hr0almngO+7jE9v95GWbavV/OBqd+84HWNLbYXq8XgNbbnbOKMaBbVTixuhFU1YKMJhxMLQQ6zX9rP0urASO+syX41lf+2Rsj5vtWRccuwdJ0W4Or+vaxzvRr9rjJhK9AKkWAUPggMeU8bMJvYvQPh9Cxw8pwpE370mADXCx6bZgV08if1/rYRw47IiC7LVNnHRHIPm60TXTtOzDaqq38TfT2R5qAcH8uXWc66tBL1X9UdTUIuU7eOUoKagnSUWAbVqj+r+qfVGurTM03n03rPIhKnplM0Dor21DZlXvmdCrm3yQTxeZXqAZu1jcTp2VtLUE3Hnvu0ThUdN9Fz5DZ3jQEnz8J75gxGn6rC7yogGBuSbbAvbPFN+0WCoeuhNArna8iQGIRgmM5HV5c4evmvnpSMrJRc83nvzEoJoT82Ik5KeVcZ63cOo+PpOQG8h/57Duu39uPcG3Mof//tOPTLZ9H/0eMItg9JbzPvA4MBvLdrL9uJzsemTBnysdOGPTO22Bx7W98PNl8P0VK+AFB0yzDbZdNa2VNbtWFbf7fRmy20Yx0d8C3tWpDwXYAtuGkOtGX5cm1YjcR/tuJDvh/oQ9DTIZlUf9LwDTC4F4HVNuey1fjOVg/Xgp0j8OeW4bEXkgFJMrC7CzgSOzLOEVi6Guwco2fmLMeCvbe1Bg9DwP58u1+OX2JaxeO2t1gGePdetjuHprGclTtK3tR0Ug3getFnSOe5C+kQa5ZXySL5z24jfWYeWF8XYkG3Ciy4fS+QS2F9Wxadz6xgzy82tpcYn9pc/cXqGpbCk8G/WER994iQHarVUz5y51YwMA0M/LXJrk59z20Y+cw8UgsbRuJNz0d4LMqoFwaQPG+zv7FdlxazDV9bi8FrbM/JWkmEpDSnZSLR903LuSVA7RwBRkxbmIbF9P3lEG200vS39CFdbTOkU6Yfk6WyBIlCKGTZNgnaCAhZjhseH49Yf2XCqjU0PItvuQe5TzxpGDcJnti3udV5XKA8mucv5EfjEwL06tsH4D/xLLx9O+GtlxBMTDUmd3EYWu6PU1YmYLu7Q/p0XOIQ9zjYmyovlVmy0IH61LTJ7pJBUUGrPTaR8rmIxq1ZtuFQKVlY5EDwr6OJ2sjEmlJqvScuC7WC1cZzHMJPJyR7KmDf2V6k38h9HreyDnYduQ7PnJLrtPj2W9H7hXPSh5x9al16WyWDq/p9DBjkcobJk86v9I+tCkEVHSeWTc+/4xYc+tnTqO8YFEeIWRnvwC5kH3gUuz+REoArbM08p8MnJPiQ2LlN7qNXrqDza2eNI8UKh3QKD879zgWvbWw3oUVZNyfw444rkb5q+3El6l217LNSZeHovEbbdMo5L1ROvNXxRdZuzGvHFXC1TAgErWwKf8eWBTcC9cVSxM4rXA8MqEnW0oI9gqIeI10jgVy1NnNhW9ZiWmt5b6WOoMsAv7CQgze31Lqh6CXnoWC414Dap0+a9e14TNC0iZ3fmacZnBMmYc4h9nRkHGfLB+W/3MqfSzBtAfGV2dqO/YaNvU1gIzrhhvRQdFWUrbc1Y+1mcRng1HvnXkdyB3AMn5lttDNJy5HZZuL4hIyf3eONQCuoX2xJJKUvXPcrcwv7l8Ool1Vt22c34K+bdTZ2m/LhPEuDfQ8jf/Y0qnfuQfrEtAQeg0HzPbO5p7+tV17u+QObWbf7fXDxA5dxtWOL7cVlMXiN7TlbFF1tM/Fq1tW88bb8TiQ+qF9JhtV8WspvOPmKk9+udMqCQXFYtGy41VlxJp62x+04AlcTyApIERBnouAShec/RriXV+Hdug/huSmEJ62enxqBq9X4pOU+9phc6+DUOPztY2YZAqp2/T2t5vYhE3D29wKUYJhdgF+uGuA6s2A1FH3jhPB+NOnrJrH8bXej9ytTwpBbH+6Gf/ikAKNwccn0iarT03IvyKLL/kz25JLkifI1StDlXnlhF74IcHWX9TQYr1lSOkDWOTHlYiwbM0yX4pipA2Qj4NG+NbMg8kskEPMjZ8olN5JKAcrQOOtG2RTp/W7Oavb8w9PC1ql9YXTq6ZSZwASButF6jcrhtZRQneF0Cv0PPovKbTuRPj6F8m07kDlyFuHkjNybxOAIwmwKx//dIez9j1+TrH1tzwj8h4+i+prbkVytYH17Hp3HFhFOTG0GAbHF5paKUtKDWsFNP7RGCafH8n9lmPV8lO8xZeyZJ41UCG3j7m100VHN+aIRKo/xivmNJCcaclxkxlZzq3K2CmZG5gY0LzRut+MReL6AlmOOjgv8q8RFazZwZ1soXGM1SzBqeh0p3SWfTS3AX7Lgdr3YALrt+o5b578W0EqCvUqPJV1aqiD5pNUJjxiAm1tFaMuv2onOEyazJ20j3M6uISSOntl0GG61i4LvaOzjs+KU20pvvVaw8HwvcSyXZZXYiYFCjo8cv11g785zji6wWbklQO0SOLZ+3iKtJwGHJhZ/C2yjucLZ1kYDnMpvhqoIrjyO/VqArJJY2iqkBDPhuk8d31EwmrQ93TKfsrw7udq4ZqWRDqxuN9vO2J9lZc8g0scmm0mzYovtJrUYvF6n9gu/8Av44Ac/iJ/8yZ/Eu9/97ujz48eP43/+z/+Jr3/96+jo6MCb3/xm/OiP/iiyjAReI3tb1w8gvGWXTMRC124joZ72utqSSs8BZQIoDu0VcBqmEvKX0UeyKdZY5TgfIFGsI7VShZcZhL/eBbA3UicSdb6l/8pxxFU2xDVOupfowGzVi3PFQC31PtOGCVIm+IxhrqU0AkmB3HIrcRJ27RCyjdWX7UB6pYbUl55G8Y13oOMrJw3Jj+ibhpuAa2J4EMHsHD0ro7HXcv6J/btRGSogMWkcUEaQ6x1pJL56JJKdEZClVNF6bRIJzL3zXvQdXkdwblK2u/DGMQw8m5LeVAMkE9H+JdtqAZkA15W1iLwrGJ8w2qdWIskc43NjEDWyMQyeBCbDY/unBWBK6aONoDOqTuIoAmy3/0kddwJUBlOk91e1U630k5a1a++V9mg7hGNGFsJE212pET1HKT/jM0B9YunxJTFVR6TJ6LOv2GauxemZmzfPiGVLTn71aQSeh3p2G+o7hpE4cx7Ba+8Gxhek/+nArx1H2JGXjPDpb9qLsd67cPZNCez+MDDzkgQKp1NyXh9d/5PndJ1ju3mMAFVMew/lta2eyaQj8h53/F164z75W817wsBK6zpdRmrOkNWQebXV0WjS99YyY4cLQcr325E4tY77rm01XjOwpOObZs2erxHktIy/0gpgQSOzsfWRXsMVyOCYtUpfDujbhuwTZ6IS3HZzElsOZF7l+JLPYeNeK8HymafMqd5zi1nV91DuNmNOx6MzDWDpVML4DFbSOjsanyl4ZiVIXw8SixvRvQ3XJxryN5ZQLwpuSA9tLeInELC3VUb+AhwRBKlNPbjFEhK2B1cBpIyFLSDS8Fm02Z/blqTmVhD5LRVAuj0euwZn3MAAx3dX51i2Z6TH5DNVPXCfQVtuLyzbbn+4tFJRz9VuZ6OI2j37JdhQ3jOA9W3mfHuOrDTWyeeQf3YelS7Ty7yR8zH4qGUpju26tTD0EYT+Vd9HbMZi8Hod2ic+8Qn88R//MSYnJzE319DhnJiYwLd8y7fgX/7Lf4nv+I7vwMzMDH7qp34Kn/rUp/CRj3zkmh6jd3rSlFARFHAQ18mcAz8nTGZP2T952x74GxV4Z6eAZ87IYM7sXm3fNmHWyyyE6J5el/4fpd1fedvtKDCIfMc+yR51fea4aHM2ZW0tqURbuwJlY1cK1EpJFiOldAjspMeM68aOTuS/VkGwYxh4/JiAoNLrb0fuS89i/fUHUfj4kcjZYuaVZ7SlM5DLCsOsZkC9ZAor//gedEyUkXzsuGwnOHkG6dUBcUhK9+xGdnFZgKs/Ooxj/3o7Dvzsow0CJAKtYhHr77gXHR99AoN/dcScu91f/x8/jNl3vQQDf/qY6V8mqzF7cRsXT4CrOTjjxPCY5PiYVWaEnkCeoK4jLwzDF7MEpYHSadSXLHjnPG8JnsTR05IwWwImh+E4Ik2ligpM9TOrTewlUpYIynznas9GEk2WrMlkYu3waddxM/4RYYvtqVI9Q+1/00y3MHdGl82yHovTo1JBho07/8gZs52hPszel8NAYgCZkzNGTqezILq9+39vEqW9A9j5YIj0zCr2vvewOcZbjE5hbLFtMj7b7J3k82h1IyXgomX3LDvnOM/gjqNDKf3bxHGqPUzjdmyvYFRFQfDqA+X9QxKcTJ6YNODISrNUdw0iNWlSS9LPr78FJ3uoQFZIhqx+LLVRm0yZznuNnqceq+gcU8JF5KW6G9U8Suqm7RluOXO7ip+wZVxRI2cAr4+WTPMvOQJGDGikVJmQGPFaHS62Zw7WTKsFbkraJNuSOcCA1/W33iV/8+dYfloWLdN0j1PxsX24MWZwjJPzVNLCUCowuiampL9erhPP+6zRPAWJ8hic5HjNKhkS1vG83Cwf52f27Ft2eF1ONs95h+Mbz0EBYa0WZVWbLiWDqzJGWrDPdhY7v/ttqqYEKCsgdDOvTvlwqzWB0dZ2Jqtu0MTFodZu3pdgePtlIk6EtuSR5OVwqs/sbyrxyDPR8aUfMcdQfOUtyD8zK34CGf7V8tMV5KeB1PHzTefxwPn/1fa8Y4vtZjEvpC5GbNeNzc7O4v7778eHPvQhvOMd78BP//RPS/aVVuNE63lGfNvaxz72Mbz1rW/FqVOnsHu3KeW6mK2srKC7uxvLy8voUuKFyyT5kIxTypDPRFkvJa1gaQwnNYIGloi1OAMukIhInZweWn4m27CDv5TP7t4mjKzBod1InJmW8puNgwPIPz2DOplXy/YY5pcNWQUdCWp/cjLgxOhOim5W0rLM+mR4HeyGv1pCyEmY++X+z07C6+sRZ0fJilrB8QXldpzsnNHlbET/m0iI2nx2UaB8363AI0ej/Zg+UyezmEpi9vvuxfDfPisOh0y0d+wX8p6Vt92Bzg8/0nQ9ai8/JJNsiuVndBqtQxH1pDIjyCj58KCRY6FMji170yytMA6zr4pZYLsu2W/FObFZZr3Xet6Jgf6IFEocmTYOT9M1da4NS3zplAoIFLKvdOQsuoyo4qTytToULcOe9ALbftgo49paku6yXLvOT4vebCT/pN+1ISXTkjVlOlaiEb0+TRH+lntKTVc6yOJIUr6Iuo2UvaCcEfVqR4fF0QSf2/UiHhj/ddwM9nzHtZvxnN8+8iMRIGRPfmurhoJXMf4utMx1q7JNCzoj8MqxXIFkdye8ov1c5wZLFGReGH1iV/u1qZ+RgRqbARRtZD1WnTcsw7ZZ1gY7D+6Rfn4xzlO+/a1mUgjyBix6z5rS50hbnNZVABZtf7s9f5YFR6WlrJzQTJ4LrByd3Kis1mHMl9YAbmt1tSlQuLkPM9xEZOT1dKGy2+g5b4ya40huBMgsmrkv8fCxBmjTntCRQWkRUYsCcs5cqy0fHE88tpRYRmK5fb09CGxwUfRa7TZas9gyHis5oNMTrPuReUCDfUoARfZ5+5k75msW1vSetqmqilQEnDHcAbVR1r5FXm/TOgqyef9UT7sdw78zB+j3TWXJLi9HO5WFpmXbZM7sOdLnCbtMhtxbNNecv7fSyw/I69xjZ24a8HojjeV6rP+fz/wzpAtXlxSxslbF773+L26I63K1Lc68XkfGOMK73vUu/NAP/RBe9rKXbfo+6WqgtXym2pPXwrQEViP1bTX8OLlx0naOaxNRh8ontEwGshzLsEaGDPshSYpIjkMQ9eRxkSDB0gqyZycliu2RaEhX1mPTbalj0ApcdUKyZV0kQcLMbBQVFw0128MTciK365XedJeUNpf608jOleFX6khML2H9rlEECQ+FT9gspVNWJqQmBPp0AhwHxyWQioAcCZxI+tGieSvfdXc1y+E4wLWpR5VAM5cTZ2f4709h/WV7sD6SRPepMuYPZTC2NoLC6fUIWIX33ALv0aOGLMJeo6BCGSRfgFAwPSPL6TFplpXA1fR02h5W64CQlIlG3VZxGAVEmnJmOU8h+EiL8yK3YGbOMORaYhN1nPRcRPOV2WMrnSPb0t4qZioXloy2LI+BOqjUQ7VsmkKSxMh90vTyRiA7cixMllOPi8+DPEtu5F4BqA0OMEMbOYkKhn0HuLp9VVsQh0SfEbjy2WDZMR19JQvR7Kss02BslfM6d75RwnbqnOlHHOiBx2tdT0pZumROGHDhcx1bbG3sbQP/wrywBDCbTABatQmMNJmO587z3NS3rmRmG0UJAJJEjGyusiqBqGYarYZo0661kqHFmjKurazlbTQvw2Onmhl3tWeVdmCn2cyte+CTa4H4tsuC76SP+k4D5HKHJ4FCHn4hL5+blQBfy3OVEZ3AXrOoQoJkS2A57mgmWYNugwNGZszt2XfnQWXU57+do5h+tSnrTa/a9esh0tRm5SaTPjKHxwG2ZAzZ0m4SAXG8OD/TaIlwzc5DTcR/rNR1xl6aMN872tkStGN/rzM/yZgsAUV/s34t+R5m5+XauoENHftNibjJfke+gJYkK/O763PImzblw3wW25UUJ7YYh/WtBm4coNoKYNsBWjleLutW2EhZswOYHTmeJv1azf5GBGlWSorPrwWvYmR17shhbZtZNztuqgoePOzQHccW201qMXi9jux973sf1tbWJNt6KVav1/Ff/+t/xX333Ye9e/duuVy5XJZ/bqTo+RidkdaepFY5HIkisq+nhRTBbKAdS26LI8IMFAlCgsBIk6hdKMtpSXsuSOhxiSXFpq+00syKmMtKWS8nrBQ/s2WfYSaDji8XpS+o9PKDSK1WsHRLB7pOl1DpTiGzUAFbFZKPrRinhj2PBGuUhtkxKIBcABdBP7OUC0sSBa+99FYkvvBkVA7sAleVGXAZeqMMLifK7cMobuuCFwL58VUk1/PInFtCT7ZfsnFhf0EcCum5PDaO6ivvQPLLR6J9qSNRZylZu2uo0XMrTi/H0gqi6bxZOQJxPlZtdjzZcBgiAF+pIkEJH/bPkpV4bV3AuvTmOqQmQlzVQgYi/bSaOWXmlnI8agSHSthE/OlqTSpRkz12KZlztGWNs2aDDRbwihNmM7Pi+GgWVwErn3c+hxq4UR1Hgk3NGli5qMjstqLflEr/6HFbuR9x6vjXswEXy1ytmrAMkHCdpbcexPp3rmD9VDf2f/Dmjs6+2OxKjuXKPv223n/e9vsItBB0aHm7/jbopLfaVkVcBCFK9uT2hbfIqolppUpLAFD7E92yVPc4m4iPWnVL22iNy2LnLFAjeZrKgWnAiIf9mtvkb+XACNJnbWUIM7rKPD7SF5UG13YMABiAv1E1mp80Bnf5m2S22NG6lt8/S26V5dftx7XzCsdwkhnWhgyA1n5iWue4AXGpGZOdq4x2RT2pkW0birJ3Un3k9tXTdEyToGijgkYpCLQXX8Y7ZkIVfEXcAhzj2vMVcAwlQaG/w5ALhlONcmttlxCeBI733CUJ5RxjQNLnmMxMsBItMYhiga6Ellt0y6XKym0PibLdbdqL3GyutplUHXDdpmxcjkPXs8FFj4Xbdn9C1CScCW0k/LQFRSvTWI5NFmr3mdSM/QlbBcD/1O959SDmXlPF3Gu6cPrd/77tNY/thTfedsrlXO19xGYsBq/XiX3ta1/Dr/zKr8hftyz4QvZv/s2/weOPP44vfvGLF1zul37pl/De9773Ch2pQ1zT9kvrdGvZl5RSXj4pTxTRdCeSdiQdNnPl9pRERBJuiY5+z+ORcsw25aO6T8nUNUo/pddKJxrZp3E2ohKsjQ0z2SyvIH12Qj7rfcwAoyZewHQapVfdCq8eClGVXwfK3T761negNNIJvxoYsMpyUIK5Lzxpts/J/Na9CI4aaQMXUGv5rWSJD+yEPzFrgPHcEjbu70d6JUA64SH9iOkbzid8rL50OwqfecYsx23tGkP6qTMAqf3pIHISt2XGrWyYpgzaRN7lOOl0ceJ+6W3wHjG9u3LNdm4DGLWnNizLA51yYcnAcju2/JelY/I5pWAY9LDPC0vrEnt3A+MTpsSMx0XSr8ePSlY36pWVfjRH6N7VeGX5s82a6vFrpltYe0eGjc6iZI8bJcmeeYOwZrK27jMc2v2EIb+zfcbaz6tZWqd8L3KK6MxqhlZLlLX3TgmfbKmbZozlmLmO36ynbIJE9tmtB6a0zx5jz/9dRvdf1zD1Q/fhY1/6T1v8wmK7Ee1Kj+WXK7kRZWsvpO3aaq7ep82eRe0iNvMVsba6JfI2cxntQ743TOKtRhmXaH0FGS5w0UoFS5oXmQVHEWO6rG/2lbEESbLZduc10icApD7Sh8R6Bd55W5FigWJEgEVjaTQBGMc3BfJsjbEAXX/rLCtee81+s50EUHjQzAG48x750/N0Q4oIq+tYv2+HvIyuFM+lYseqzg4hyZN96XjkVP4IcVxLGatcG7kWpmKGfxlUjXqJGShQOSRH+7ZJYk2rwbSf1lYNmQWMRFyU/W7TKhK1lSDVVAGwyZwqKi33bpS1K4htaROy1TUNvVsLOLXU3a2K0cysMmFH1Voc751ja9V5tdekcfLNOrXac+t+FpV5awBU/ZBEAgN/8SQG/spuo8HdGVtsN7XFPa/XiTHb+v73vx/bt2+PPjt69CgGBwdx8OBBfPrTn25ann2wv/d7v4ePf/zj0iN7udH6HTt2XJW6eTIRCwBi1sxO0m11/Z5Lq7XjiEQyPU6fYeSARBI6FswSYGjks3V5ToqtLIWu0LlswJaCcsKVXqaEyXhtoWu3pah8K/hu6YektAIdhfIrDsILQmROzDXKPmsEIy/ByAcebWiR5rICDmtjfVjZm0fv4wtYO9CDjo88Kg5E/f6DSB4+LVHh+p4xeE8+Kz1gYcKDP7+CsKdTsgQkc8IdBwwz5plJKbVu13urIFl6gCnzwOyBZiFtibU/NCCRdB6bfL5nu2jYRky+BH216qZ+X7Lx8jq7Mj26P1nHOkjJW/YinJptS/Ik4FZLyrT/182sUoPP+R0IYVRvD+oOa3KkaShavCYAIZkAvtfIv5N5Vs1ec+NJTGWfKeuQ67WJ3ivBhyW6igIwrc+c/d3IMSkobsk4uU6Q3Ac+47qcBcEfXfsD3Cx2I/VJPVe7lmP585oDtjJXo9NWOzQZfw8kQaK5wKpJU9yZTy60Ps0Noqq165WUntYWEqhWa832uZ+5ZrdJ1uAoIyrZQxvs1L7G+eWm8aj0UgNaqx0+ur5gZG+U0C3SiZUPg2gf6/cafyE7W4L/rGH3d8G5q0vdpHGqY6wlZBJCOQWd5AzQ663nQqBrr3ukz+20ijTJpVmLxjte/n27UD9+qjHW220rqK45MkP6mcwhen3ca37H/ijjrfJEcnx6zvaaRQFMpzxYytXdMmi9Fu4zaS1a100mqE9h5zcxPe/WpEOrRr1r7bRr2/lELSD3ZtF2vZHGcj3W7//UdyFdcH5jV8EqaxX8wRs+eENcl6ttceb1OrGf+ImfwPd+7/c2ffba174W3/M934Mf/MEfbPqcDMMf+MAH8NBDD10UuNIymYz8uxb24MrvX9Jyb+141yUt1xQlVwIGR77EtQg0eAmEkjmz9PXMYikjLLNkQuJk+yE1+q/lPlzG7sedfBV4Sf8KswQkeRocaGbZbQdQ3ePbVE7UPNlTeoaW/vxhc45DgwJahTRj+xBGPr8kDkJi5zbTC1zoQHXnAOqZBDomK1Im1vEPZwwQq9UEuArRFCPdTxwzoHudfZ++KeleWDK9R3QMnj5pypjYe+OAPgHJFKcvlgSYBjNzCCbOC8mSAFmNxGu2lP1NNqspGcFjp+x15HubXWAPq/TSpYyjRP9hfUPKhSPgev/tZnsPH25yHuonzhiQuvniRsDVBb/MyJ77dy/F8Ncq8Mt1pJ4gGVXd7JdAc33DyNhYUJro7UOdRC0WuEYESlyW/bQ8doJG7XOz/bRSrizlzGVzHszMW9BpsrqGrEvAbdn0O0lfKkG/2//kAmF1qDKZxrraL23JqFx2ZC2plGc24d9UwPVmsWs5ll/tOeDtgz/c/ot2wU4FrAxAtTB6i3EMF0Imr0k2qwnIXswU4LZjG24nvdb6uZOZi/pzyRysVR9637o6DLEgPyPpnSWuyh2dEt1YgXZ63NxW0gRKKa8WlW9bUCmg1Wq0SnmvZTd3gX8EMFvImeQ7grl8TrLcIt/TTk6OLQ3sV7Zjk7RoaNBRsrc651myLNvDKqW8HKf27zSVSa7mOI+DrTBO6bh7HaNx0V3HSgQl5mzg0pEnc49v01+tbKHSgeVGaDJbvh1dE8vlIbJrLRUBAqZttY35wPoEWiUQEZmxMsep9tHXmvGVOWSLFiYNsjug+1I10GOL7WaxGLxeJzY8PCz/XGP58MjIiGRe3QytAteXvvSluFHto+t/eEmsxs2lNbbktyViLxMTJxpXD45gKZJ7sDqgCs44ERCcMjKu8hDrRRM9VsdIMolWny0i7FHwbHtYnFLYrQBqE5jVHsstsrPRZxbUatZVjvfIiQYhki0FI4BMPnESSUtsUXe2KaCTwHL3mMga8fzKr7vDyBOdmZfsKp0hIfnhBMnjJFGUkpAwW2nJjbSHlP2vCeoBMpuwsirl0kKeRbPgTki1SLJE7VH2ZIYWTNnz5vpSumdlFTxLxCTH7GQhEjOL4tQJoYi9vsldO1A7c1aA7ibjteV9sSXJAuDpkADY8WuPmqxwgSDcsB7LPwYvbG8VQTzXE+AqzgX1hjOGWIosrATbZFve2DBOKDdhM/Bm/x4SXekGSQuBbmdBHEJZxmZQG4GRtMnk0xlfKxtSL32OLNkLHTI5FwtcdT+yfdeB5z9eQ+l5TTccv9hiu47tgdn3X3SZt4/+q8YbZYTNJ53sLIOK9nfjPPMCEph1dTKuUeCH453OKW7li5DP2fHQIQ8yL0wwLypP5txhS1QjzdZ21spMz+2ePHvR32cTMZUu6wI9HmOlgsTZ2UhmRvowNZNKFYBWRmANVDqBXoLPupNx3hR85b7bScpo5QnHqVZgxaCfJUIUibS55oy2BCo1k9wOvHLbm2RnPPiHTduMzBcK7lymdz0nm9mVwKJq73L81MyxDZgK8Fama66rzPm8t+75u/euDWmm2ZfTC6yl8ELiZI+zpbRYA496bmLazsTrbNtfxLfhHJVMXtLvJbYXztgFzX9Xex+xGYvB6w1kTz31FH75l38Z/f39+IEfaC7N+u3f/m28+tWvxovJHlz43Ysu85aX/Tz842cNELGkOYbdN2kzqqYc01cnhiWv2ttiwYREnukYcV0l4yDw0jIrLkfyCEvKEDolxNxXtE47UMXSVAI+ZXdkfyyBsr81iFXT71zRedfakik5RtDpn09GfavpTzxmPrelwHRwWnta7Y7tHzoRNSRGhlC3LJQEVMHps5sj9I4cBNeT3jZOwjxvgi8b3VYAJ9F7p1dKjkvJknidCZgP7QUefbrRFzV5fstzJcgU/UB1qmzJbqN0PGWDFqZ/tPaqu5D83BPwUoZgLNnXGzFGqharAZbWoeF97OuVMrXKq29D9rAJIIizYUF7Q9A+MKRc/EvGSAYAbLmalqKZ/jpmSKrwba9xVK7OfdPxttdHStTUOYpOmFkUll8bYig5X77ndaXeZivbcWyx3YB2MUmQt+81MnKueZR00UyYMHBbIKUVG8zS6diuhGg0IUZTAiC2Zpjy3AgAKdGebLeFi0G0QBvByXbWCiZbrR3r8qZldLy2Ujtbgd4tW1c0k2hLX2mJPYZ1uX5qvNE7OjIAb8rKnTmqArwGrCyRYBznMof/ggBLWIjdlgrHKLFWmzTkTO3mHRljbXBApY7c7SiHgWsiDUZ+BZrq43Ls5HzNc9UqGWc9qZ6xJc+enhvnKQWt/Kw1KyoSas2BwyaAbeeN5nVaKgNoUh2gxE0qiVZtbKspa273dwV062OL7cVmMXi9ju3zn/+89Lyq7d+/H08+aQkcWuxSNV5fbPaxr/7niy7z9t0/0YhoEgTYySKKzCpDLL8nwOEkqlpzjGTT2eFEw8yWnawlK5bPNaLO1Ai0JVReNmuW16yAlWORTC2XIZsvy0qvMnUcJ9m6LUlr+tzud5MD0TpJ2vItAtcES4bn5gWEzb3npRh8eAXhY0+bbATLZPeMIbG4LiyalFdgNoDkI+JAkLikHqB8YASZU3NGyoX6rMxM8hisU6dZRGEUXl2Ff3Ki6Zg9irdr9sBmQqgJKOzIto/Wz5msimRKHe1Zvf4C2it1ZE7OICx0GNkHlj1zOcsSHDEXe570IdMBYu+YlESnksg+dtqAymQSG/fvFgZqjZ7L+VjSsqC4bkrUeewE1xbEi+nzaMvrBNRr7ysdaGE2TptgiQXS5iI1pHiicmEhdPKNq2OdpEsJ/MQW241uD5x830WXefuOf9P8gWrXqkSQbXFwTYKS0Rv7OxXAauVauL6CWtXQvsqmbSVqrbwErkRcq7nAK+o5dVtv2I6yfQxBX0FYmAlc3exwpNXrAjsLKg1oNSBQynJbel8JqNtpd7fKu0ng0z0HJVKyY62pctrMIhxatmIeYwSmbXVPk3EfKmVUt+Opne95/uv370T+xJIBvrZXOpxfaDBCK9B1GYVta1KTSXBEy4213N0GJrl/p2eZ85kZ8x3CSDsX6LWlPTD1m5uuX2zXl9VDT/5d7X3EZiwGr9ex3XrrrU3vs9ks7rjjjhfseG5Ue+D0r13cuaF8jBLg2L8SmeY/7UGxbLEyQTKLGhH0OKVPdCK4nBL1qPQCHSZ1BtoJlb8QdrGILjOgWk5LLVaSPR09gYHf+0rUwyTlv3RsTk6Y8lqW27Ic2OryEcwlKHwfhEh98TBCZgUFkNWjHis6U9IvSn1Z/rUBgSZNW17aVueMZEoqE8TyNAv01FEToiXpE600sq/1ipAvsXfX3z4mDNGqKcksK4MLfqHHEIGQVMlqDkoJsmrJKpjsLGDxYAr5x02mkzq+EvTo6UbIoAGPx5a0S3ZUZR9ab4MlWor6oXievK7yGeUfTLBFytpF78fKEhnGPSPFoH1+WtoeW2yxiT1w9n9c8Eq8feRH2ut+igQWx0hHm1kBkfSpk7m2ZoKY1wC8RofVqm97CUHQhpZrFYEFgMxySpuEbZUQOwcECkodbVWVEpLPtRdfdaf1s1ZCOWqk2/1KkNHV5r6QAoEea0vPq+yToFDvAcd6WyYNZtulPLehDavZ97Bux2A5EIcN3tFZXXqDkRqsjBiCLcrKSWVVVxfCjgy8qXkzfmtfLK+LSjK5x2h1uZvMYZ7XHtnIXBItaWkqNUglWfkTt3/EFltbi8FrbDe9Xcy50f5b1ZH1GLlmCSw1XvmlJWyQbKz2skj2r2IyrZys1jcijVFZVvuUrpUpQ+7llCBp+bDt7aXED/tGI21XAYsV1Kc2l7sJIZZ1ImrU/LNlvcGiAY+UqAlm5yKATIuE6x1jJF8Aqsv0aV/7Gcto3Mp0SSeDUkMdeemvSm4bNVqoPV0IpmdMZp06htTRoyNFYEknlCA1mxWNQim9ZdkvlyNjp2VVdnuW5l47gp4TNZQPjSFzbtkAR95r7Ycm4CVw9xNR/7JhWFW9QN+UojslZwYYW/3HKNhhv2d5O79XiSfVjPTs9zboEmddY4vt0m2rrJYLaiPjONNOGkV+vFeuvLMdd8JzrtTZdFwJGQvlFXs+XQkXHbs5LlbXDOM7xzG3R9NqqopZtnRlRpf1W9pBZOxvzby2YW5uYkO230Ul2yODqHcboOo9dWITWA5zGXjs3U1SR93K+nDeyJqgo1Sk6PJuxZH9rPuwKbeuDHQY4CoHbiqxvKbgtA0UtmZb9b0GOVw5HOWVsFrFYsozoddQds5qLku65RybANrYrnsLQl/+Xe19xGYsBq+xxXYJdiFAIE6OEkZJiVNCAIlk7mwZqZjD5kvpAyUHumb2PJwrKUF+9iS8uw7CO3pKSoWlj9OW+LpGsJm4/QD8hRUpt/UtyyXLiCWbShmfqWmzri3R3SoS3wRcnXOgQxR93lo+V6mKzML4j96JXX8yjvrktOmZpV5hJtuQl7HZS1dmQT4/sAveKuUi2E9qgg3so4oIX3ifPQ8Dn540ZeFaeiYarnUpWYscQt5jvf82UyF7t8zXEnmXTITpXRUwavuRJfPPcjl1eLRXm/uv2qwD96vljw6rZWyxxfb87GKlmi5bsoyHrRqjkr205EGXEay8IJnfpW9k66/Itq5yMk1ZQJudlNJiqwHOlglLcBSxJQuRkB0LpR/fBh/ZA3uB45TSYYeBV89LZMhaM5dOhcr8t90mfwc+dRYhAarLpFyuYO2NpkKt46SV9VlaNaCY156BTdtbqqXAUXVVi1E2LjO5LG0sYSczuQl4DhmVjK1Vp+/Wlg9LNUzNVGHp9YlMl9VyZqnkaujj2ptgrosNjsPX7L75/sG539nymsYW281qMXiNLbar6OS8rfs9DaIimhL21OtIjA0LsGo1MjGKzIolHVK238u2KwxkpG/zyWfldV11+dy+KDo3ls25fvjZxueWhAlk6nWcFu0Xbgtctzh2zba6rNCmP9SsQ6erfsdenPnGDuz+nWdNGbH00dpeWF5X30jkhPu2wz9v+8gcRk1vw5YuswSYwFCymlZ6SZ0WvheiJpsF5foEuSpVUbeOiO1PlV3k89Ibphn4plJE6YtuFqc3b5w+Kd2WslhaEOsyqnoJp+wxtthiu2p2IfbXt2a/J3otDOBKINWqlepk9a4IB8JFxvxoXLGSYhK8s9lNd55p1z8rx+wQ4kWf25LprY4/qqghh4JDYiStHnzhVp5ohlY/q9fR82wRiSdPmCqnpgMy42vHyUbw1GfQUUuCddyUhlI79+p58btIjqhupIuEYNBkdFllJMb5hYEHfl5umac04NiuDUjnCiX44rXjtrhOxFisgUfLik1Qy9WUPftyZJ5iuz7Yhq9yT2rMNtywGLzGFttVtAeX//cFmTLJ5KusvyIx09kZATOjPWp0VhnhbcsMrHYVMm5CNORGke37JmkgR7JFHTJdh86JOi5CFJLNS7Y2LNYv7xxYPuaUpOln7WQK6mvrqOeT2PXrTyCwZb68fpE4vWX89ft7Mf3ybox8ZDmKcEeOCAE5nU06FuzbUq3X0GvS6YuujWQL/E3EL1Je5mTdNYMRkS0pazXXsX1YQkzSbUqGRbuQpcW2n0ucH6sZa3YQAswaM4uixB4Tv3GRuxpbbLFdbfto6U8umq1t4kpwSZWuIpFfY+xmIMyMZZHUTsQL0Dw+i461K/HGdhGR70qZEuML9a+alcw2mMl0GXi1iqa3Xyp0InPHVa715InGdy747chj+pv2mHOwsYHRB1gx0yydJJUrmkHlmEl2d5oSMKm2u1wWZ/xO+kDBEncVi5tlgVoYiaOqF+dyRLwXCmI519hy5sZClq3acjPId/bcH3j2V7a+rrHFdhNbDF5ji+06ZMqMNG61xDWXhc8Srq3Eyi+3n/UyyUAEtFKKpmWZRi+WYfKVHik6NWT/rVUN+yQzib7XXp/1QuaA1uaPPelZDZZWTDmylZLhspRx8D/3pPQkR5IIes3Ym8yS5Tv24uxP1bDrX59pZDO1H0lKyuoRI7XK5Xj9ffD6ezH1hkGMfOw8vHA10vxF2sgmEYgGQz3wpxfhCRC27NbCSGnArcg9SOm4dQbJiqn9W+ynsn3TBM+ayZZj5HZ825NGZ5Df8XNeU65LELyFBmFsscV2fdjFtDrdjO1l2XMZ+511dOx25caUJ0GCd6wCapH6acdR0GrS3tG6WwsuKZ2z/Eoj09P5D0/I36b9uOOZU4nijQ7Jy9IOI+tDG/3ELFDSDK/TpkPTIKJkvxsZ46VXbUd6yRxL/ritwOFcwf2WKlh43Rj6Hp43hE0W4EsGXbevbMcix+NkYRU881xYbcTrSQ4F15T0j9nVaHsWSPO71uVju+4tvAY6r9xHbMZibye22G6wHtu3pN/5/Ag8noNtta9Ii9b5S7CaHB1GfXpma7DdvJHmUjIn2xs5VZrhTaZQetNdOP/KJHb/3FfMMuWy0Yi1jpcw/moJmF3PHxtBODWDEz9zF/b/1hns+jGr76jA0jL+CjkTpRLoLLE0juROI0MGpG4UMfTVFQQ9HfCZFZX12e9kxeXrAUpDeeRXio1IP7dBYGvL2EjqJCV3zKQzmm/lbsSBcXuxQksWNbdgMrXaF0ZSKd0f1yPQFhmgAA+c/tXncGdjiy226z1jyzH/albcRDrZrdsU3W7K8NQvKzPcDrSqcWytvup2uF2n5dfejuwXno7aJCJNXtXopVa2AkinH3boi0aLVgCflts66wlA5LEoYRKtVEHYlUf3kWWTXVXjWGpbMSr7R9B5xpm7RE7HXp+IKMoEN70ECRhLm7OxyhjMsVyre7ScWXTm7WdWGi0KQMrYbuXdYosttrYWg9fYYrvB7GOVP70wsLUMtK2R8q3suYJg6ZUiCGsTga+dn76UHTdvjwQbVot1E4AliNyzE+P/aAjJErDvd8aBHdtRO3NW9F99qw9L4Ew2ZBJiSV+rHls+A+zZjv2/O2FZJG0vK50JgkE6NywFplC9ECelIvIlkkyxP1lAZKkCr+YcN50NBZzUhWWvlC0jJq6V/aumKxehrIaVUtI+V5EKUlIU0aW1sjosE+d2LPOwZECkx9XK+nAZLUeLLbbYbrox/y2p77r0jWi/qmpJO4RNpoIlt1l/lTJptmLmYvOEEC9phtRd1hnn2RbjWqnXx/DHzpo3QwMSPGyFbGy/4D+/rzf6bO1gn/zNLliN7tZy43b9oqtr0j4i1ru7cUyrJVv5slnvV6p1FletFrzN2ooOq2lBkfnKMsRHGVc7hkc8BXKgWYel2mEdbj1OLmOB/wNP/9Lmc4jtujX2u171ntdY5zWyGLzGFttN7ORcyCFpip7TMdBosGVNNlnLhoaflOheIhAWR4fOlJAf2XJYZk/d6L4SfFjn5Pw3DqFjKkTvXz6GUMgv6kh0dUpZsKflyZbxWVie6cfs243w9FkUxwqoFhLo/IdxYQaVMuNcokHqoRFz/mWUf7gX/tRCw7mo1lC6Y7tso3B00ThY6sToutUqsk+dM44Oj8cyTSsLpTiFVkJBsq1WYkJLl6MsrN22ZJyZweWxduTh8ZrwvNlvpvqGSgTi6lPGFltsN4V9rPrBi473KkEjvAQ6vjjZSx2LtAqlqVWDXAVa9eG0pjQBXGUhFs3pLcZ/LUW2/aZL+zMY/OoSBr9aFMm5Jn3dKIjHLKwv7RpiBIkF0//vV0Pkv37KfK7HKwFHe35SjWKOsbyjF6nlEtCVg79keSOWN7BxcFBe5tfLQJltGWSMN9tKH5+K9hX2FOCtrJvvtKKGSgKtWW9qc7fo0koAmeXDlLthBY4NFog2uppmYKNy51gOJbbYLmYxeI0ttpvYyXlz4js3lY4xAq8kRU1kHJysAzowSvZhSmANM3LaEGNoP6fjHLmlwxFoVTDMjKL2yrplUk6/FdmXZ7/lAIa/vAwcPiGZ3oQKxltCJinbIijkseRy8OgkcZnVdWD3DuSfnhLHRtwNAkU6D1GvUWBkFViWZkH52u4CuhbXRFs1YbOw2cMTyCrLrzp7XFcBsJTw2vfsWeV11HJqLUsmwYl1ICXrYSP2UfaV10JInMgyXW5o2BKgc7uUceA9IdDn+dtjuFD/dGyxxXZz2Vbj/VsL3x+9VpAajUMOiVSkucrPWcbbwqhL6Z8mXdbWjKVLyNTdBfTY/tR6HRPfOmY+J8Mvx0JmJbUtRAOatGxj+yF7TTmmcvlyFfmnZ2RstifQWIdjJ8dLB0RT/iZMJZq/J2h9Zq4xB+j6Vh5N3q8XTRUMP9cgpnPOUgVj5XoMN0GIMNEA8wpco+26Ej8bRXP9Rf3Mzgdcz64bj+exxXZhi8FrbLHdxPZQ/c/bfv62rh8wIMvJtkpZrgAvky2V91Y+IazbMlyaG30nuRLLi1tZgpVRWZe1QJWW2D6GYPI8cPt++IvrmH3DGGo5D0E2hURHDskdY6ifPotEoV+i9sLSy0lfmYEJXEWSgJ5LGh5LxfiepWd0pLTESzPIdIxsOa5K3XR96YxhfZRoOTMSLA+28jbMnvKvmy1QUKvO0PKqKfmls0QNYGGqLBlH0JYARyC0I2ccGCklM1qw5nrbwAAJqVSWx5qQhAg5lu2Rii222GK7iH107Q/aj/e9/7zxhkFAJTmy5a1uwM0QOBmJMlnGCVRKtYzVza7esRtLtxiAOfQZ00Yy+U1jSFqS32CwW8jtmnpKOdZS/3vYZFs9ZkT5d3VDtFdDjvWtPAocO9nK4Zbu0qweN8d+qVqRcdpyHMgB2PlN9m/Phd+zNLMVjBOg6nrRXMbWHAv2mR1WoMqx3+qBt5McUtN2G+3vFQbnFgbj2G4cC0Jf/l3tfcRmLAavscUW2yZ7cOX3216Vt3a8y7xQQiOCO5GJsQtYyZeIfIiZWl1es5COvI6fa7BLLn7vS9B9ooSp+3IY/Z0ZzN3Xg+UDPdI7uu+P5xCmk6jeuQerOzPom5qJtivr8+/+HabU108gmFuA39NtStJ6uxEsLsFnPyuPi8vTEWG2lQ6ElChrr6pTMifHb0g5ItZgt19JTsJrEHlYJ04cGtWeZWkwj8ECYTp9dFqECZlO1/AgvIUl09PVWZCIvABT0WG0pcU8RjpKPAauo9eSmeTS+pYOaWyxxRbbpdiDix+4aKZWxrbW8c81qZwhCK2het+Bpq82bunH0l7jbg5/2ozdQT6NcKBHXnvsXW1Tciya2zSC1lkLdF2ZGY6XOp9odldZfGUnLrA22dGIfViO2dHTjiR2HE1vl0Sv9bzZEsLgpLRyVBrglSXFui0XKLva3U6/cURKJZVEW+jGxhZbbE0Wg9fYYovtku2j63+4daZWgKwBrtJTyslY+0JbTMqEmXEUUiLzfe+RNUy+rhOVLmDlW+9Gqhhi2+fqyJ1cgsdodqmE5LNl9D2SgNfXY4AzQSJBKfdTMZIF4eKS9FApEPRIRkK24bkFQ5ikJcYrqwJwI4dBSoF9Uz5MYEsnhw6LXT5i+KW1Ohk2im9kbEgcZbIIIn3D/lfNVlinSt5TWufMOcnMsrc19EumbJjLV6sG8DqOkDhKBOmSJbYEULGjE1tssV0laxcYayo9TqdRv82QHwXpBFKPn2xadn0M6DodotifwNjHZkwbBy2ZgM9xleBSSfUc8iKfLRs0yxtgPvSBnq4G4OP6HFNVp7ZYQuUWU5LMTGtqdq2RUaWRpE8zqirDwxJhyc7aHduS4k1BSq24YeUO32ZTqBcMiE6Oz5plZhcaY7UtaSZpYMSczFYVJb/S7LFmrx174Pz/ansvYru+LSZsurYWg9fYYovtqmRqmaX1Bwdkgg4WFhHWawLA/FQGs991F/IzNRSemkHt1DgSt+5HtTONvqM1zNyXRC3rYeBz56XXU9h5SYaRzZpSrHIFIcEsHYzto2AljbdWBM5MSs+QAD8rDu8P9ptIOnuXWE5Mp8FGyEVygSW5ubSJ7BP80rmikyFZThulpyljMPdpS5SjbK11dMLQ9gkTMPMv92XBvAHYddR2DaE0mEFmoYLEw8cMyGYm1pY6B3TWCGyzGav3mjEETdyeyEGQ4CmQUmKe31YZk9hiiy22q2FbVXp84xsa7Lj1bAILt6aQXgZ6jqwhMWOzptECgfTN0ry8JS/iWNvb3QCRSyvmtXIhdNl2EAV+NiPKPtnKHbsaoHVqpbmPVbcnZcVOWa5K6ygHgy6n5nko3rFNXuYePW0+I4M9x+pagOT0snxUOTCC9LklmUuE98Eux2ysjOGcf6jbqhlc1YvVkmzOVzHhXmyxXZbF4DW22GK7plnatw//Sww9dFYi5QR6ycF+bOzqRvb8OoqHurD7L612HzOZpZLpoaIjwuVJdEFAp9FsAls6B7ZnNZKcIQNyfzfAUjPfRzA1Y4ioSHjETGyhAxuvOYTszIaRSlhbMaCWDgWdI42IO32wAmAty7F8z+1R2oFA0hJcSX+rMidrRlhAcE2cmcThU+ggkGaJMAFqVxc8ljHX66jNzyM5NNjok6IjN7cozpkAYSuB5GVtz7ESlsQWW2yxvcD2iU/9TNvP3/Kyn2+84fipY3SXzaJyjCTI4z8G6ETvNNGcZVXGY473TrVJbc9oA7SeN2AyypgK+VKbHlLNurJkWEmhuF9dN2ohaeznmZ/aj8yi2e6uPz/f2FathvTJmc26rMkEgvn1Bo8DwavuWzOttl/WHIvZ1wMTv9H2GsZ2/RupvSy911XdR2zGYvAaW2yxXVN7YPq3Nn32mn/yPvhLq+j5/LLJalpReYnKW5BLjb7Evl3GUWCG0pb0So/o9hEh9/DmFgGWFLNca2pOtsOsL8GqyED0DQOZJCbe1I9tHzpj5R3caLxlSua23ZIuYd1MGKBsdVclI8oIepPMgYcT/2sM9fEO1PuqyD+Txq4/HRfwKqXCBN1kZObxWfZgtUR3N2oztgTNdI9Z6R+TaZUMtIJpkjm5zk9sscUW23VoH/vqf256//aRH2m8yaTMP46rVt4sajNhUFBJlGTss72s2sfa1WmqZ+jIKnCl2eoUMZWz0XHTZSV2Tb93MqISEP3JGbx19Ii8/e2vfENj+SbgyZYSB1TwXGo1qabRMTpcWDKtLm422DINq7xbbLHFdukWg9fYYovtBbfP//VPtv1cHJ10Cue/5yDG/uwZIW3ySlUz2RMEWiIlAarsFWVGcmXVytaY6LmUGrMHl44Je23XStj25yetA+MwZnJbBKUWODeE5G203GWs5HslrNJeWH6WTCCXrQC3VJBPV+E9YLQEI5Ny4pJxWOickSGZx8ay6GQSyf5+ycDS6guLkokVh8cSZMm5WEKnuGQ4tthiu9HsganfbPv520f/VeNNUtmHHQ1XLfPVKphiCf6Gw/gumuGqmRpszrTquO6S63GMT/oApXRqjZ5bTzLAKax+cBS//bqB6PNDv7Jog5iWXZ6mrSWsFOo2TMtrBwxbcuFTRxGsmf7d8OxGdFzJg/slC+25gU8y58d2w1rc83ptLQavscUW243h6Py6+fP2237WlAgvLcNnHxRB6XpRyJ8EoNJJ0eh9sWT6XzXizcxsNoNgYQk+y9KYCdWMKo3rSrTfbylBM9lO2Re/Z8mulA9T95bOlI3YJxIY+H/zWP13q/A+MIjur583n3NdWw5M/VdD8GT7VzNpBCMD8FniXK0iOTaKYH4RQbkUZWL9TFb0bKUsWaQsLElJbLHFFtuLwNoRFb19byOoGQx0ozxgym8z8yVsbDO9soVHJswCSrin47iO6SKb1sI+zGE7a4AvNWD9DZsh1T7UvKmQGfzKPAa/5mNjV2fjoLhdBhE7svLW27CM8wkPxZ22ZxdA56OTUvqc6OlCOG96fusWyAbjEzJ31XePRMt/7NlfeV7XL7bYbiaLwWtsscV2Q9kDR/7bps/evu3HDLuxKwhPtt/+bsnUTn/DMIYfmkB1ey9OfEcWt/6C1aWlI8IyZdUtJCDlugpg+Z7/NPsqkfpEBESNlqAp7ZVMbr0u5B39P0LH6Xxj28Wi6Y3lPxqdHSHzqOHp/7gXfl8ZB3++A1hZk/36A30Ip2cR1kxUn0A2mC0hUSjAGxlC7YBh1Ywttthie7HaAyff1/bzt770vdHr6u5BJI+ckdfCh0BL5q1mrJ0TNLvJ8d72uXrlmpD1edSItUadVVb3yCr2L7/Pn1yyC3gR6JW3JPlLJhBy7Kf62vgyOn7bANXZX96Djiec/ljHgmJR/nkOeI3txrY483ptLQav16l96EMfwt/+7d/ine98J97xjnc0fffEE0/gj/7oj7C0tISXv/zlePe7342klrDEFttNaFsRXbz5Vb+A5NQchj9alqh76pkJHPyPRmKBmVtheZQMaN04PpYUqalMOJlEMNIH//x8o1SMmde1DUPuJOvY0mECYjpNfM3SM2Z2CX7JYEwwrORStveVx7H/z0uY/skKzr9pCKN/vRb1P0VagY4xcp+Y9vDxZ375Kl7N2GKLLbbr1z76tZ9rev+2gX/ReMOxlkZeAJtJld5YNwOrwUcyzRN4ZFLwhA24hRCHYDWVkE/JqWA/bHwvgVJPth/aap37usfx1cXd6P2pM5h+/175rPfjjSqaps0/9ow5n+IfPY+rEVtsN5/FiOc6tKNHj+Lf/tt/i/n5edxzzz1N4PWTn/wk3va2t+E973kPDh06hF/6pV8SkPv3f//3L+gxxxbb9WgPffE/Nr1/+84fF9KkYHrOyOjQbAbUZFkphZM2EXsh3mBvbQB/yZKJqC4twSsBKEFqrYawk9I1FsDWQ6O/SoZJyj10dSJMJkRvVoCr9tgSHAcBpl6ex+2DZ/HUmzysnd2J/Jk1Ia/yqQOrGoiO1VdXr8m1iy222GK7EezBud/Z9Jm0l1gLsmn46wawEtAq/PQ2ygi6LBOwo5KjWVd/vYyQPbGucfy3bR8yrts+Wq8e4tw7BvHB3/9GvOQ7n5DPpglcvzIFdBaMs23BdH3O8BpINU5sLwqLM6/X1mLwep1ZqVTCd37nd+LXfu3X8EM/9EObvv/xH/9xfN/3fR/e//73y3sC2dtvvx0PPPAA3v72t78ARxxbbDeOPTBuG2cde/vunzDOCAEpM6kCYhMAiZ9UGieXMBF9loglPFNqtl4063UaJmOad34OoA6g6L+GpveKsjkW5ErkX/ux+DpMYsffnsfJN/bhldtO4+PfdDv2/UkG6fllo5E7Owe/s9NILyytwO/vxQPn/n8vwJWLLbbYYrux20tob7v9P9jAo6ms8Zc3ENry4qDTlB1zfPdnlprzrASaJABkqbDVg+V6IbO2RQYZQ2z/20mz7HcCXxjfC/zjdfQ+nACYtRXmfMNVkNg+FvEyPHD8V6/iVYgtthenxeD1OjNmXF/ykpfgn/7Tf7oJvI6Pj+PJJ5/Er/5qY7C77bbbcNddd0nmNQavscV2+fbA6V9ry3IszMVkB2aJGWVxLOj0FIAW8qY0uG7LjtesnMPyqgGmSu5Elkw6LVxHmYr5XhmNsxnkf2MAD317DwonkkjNLlmmTR9+f585oCCAT6kFJZCKLbbYYovtsu3Bw7/YPNYf+HfRa7/kpF+1RUR1aKVyxlmRDPG1OkIW3OQzNgNrtMLP/+AODO/JITexgXpnDglbchwO9KC4w5A61anXHduLxuLMa3sLggCf+tSn8LGPfQzHjh3D6uoqBgYGBOd80zd9k2CY52IxeL2O7G/+5m/w0EMP4dFHH237/cmTJ+Xvrl27mj7ne/2unZXLZfmntrKycsWOObbYbhY5B8nQhvZ3xEj96nojGl8PjXPDiD7/0pGRftiU0QQU58fILzCjGw73C2GIMg7nHzmN256mdE7V6Miq41TIY+neAeTPVxD6Hj75iZ++xlcituvJ4rE8ttiurD3QwvL7tnscXVoGHoXDwOp702zWVcn8vAoQ9nUCQaMUmUHOwuMbCHN2nYSP5XuH5eXyXgNae5+JtV1je/FaGIb4/d//ffziL/4iJiYmcP/992PPnj0YHh7G4uKifPfv//2/x+tf/3r8t//23/DKV77ysrYfg9frxJhVZab1wx/+MAqFQttlirbkpPX7zs5OeTi2MvbFvve9DXa+2GKL7QplaA/9jPwVUg9lJqYRlKpED30d9q7S+bFsxuzBSpSqUnYmvbAsIWOGl6VldJRsH9XqoX7M3ushP5JF35HN/a+x3VwWj+WxxXZ17cHHfr594FJNmIVtBYxTCSMa5BXDYBzpybK4RjTHfXQ/NS/Bye5H8P9n7z7A3Kiuhw8fafuud9e9dxsbjI3B2Kb3YnozzYBpIQFCCyXUhBI6oQUwPYQS2kcIPaaDMR2MacbGgHvv3t7ne874r7W0qxlpZkfakfR7eYR3NdJoNBrdnTPn3nOlqXRTUam3ZnBeli60E3pTy4JfCXiNVHHBBRfI119/LTfccIMceeSRkp/fenz38uXL5emnnzaHSj7wwANmJjZeAUPDY7S7q666yrwSsffee0dUHNbxrHpF4r777pNPP/1UdtllF7Pa8KhRo5ofp92Fc3Nz5ZVXXon7an2/fv1k48aNUlJSkuB3BmQOrXoZ6FC0qStx+ByxoXlnNVNbWbV5rlh9jDk+9v+m91GhnzWYNafoafq/Lmv1MnXlA+335nxO27XS0tK0btdoy4H2F7pouamg36ZT6KZOHSRQH5pbtnHzVDvaKydU1Emzsio03vXnW5K/8Skgldry0Lbu+78zJbvo/zLtCdJQWSvvHvRQSuyX+fPnm5nWeGv9aDa2V69eca+fzKtPHHPMMWb14HAajA4fPlz22msv83ftG56VlSU//vhjc/Cq1x7091NOOcVy3Xl5eeYNQDtUvex7/uZgVQPZ0PVCc37ArE3dh7VrsXY5/r/7NxV0ym6eJ9YoLW41VguZh7YcaH9TZ99sOfesOT1PdrYZyGoAa2QHJFD3f5nYnOzmoPbN765P7kYjoRjzGinewFVpVtZJ4KoIXn1Cp8TRW8vKwmPGjDGLN6mOHTuaWdYpU6bI0UcfLTk5OWZ2dtmyZXL88ce305YDsNOyOvCBQ/8sRlG+2cUssHKtSMfSTcWfqqrNzGxTYa4EyzXrmiViFrFskoAuAwCkxtyz22yeps3MyDa2yL4CGWbu3Llmz1GNawYPHiwVFRVmHOMmuUbwmmI0cN13333N7sR6ZWP69Oly2223yciRI9t70wDEIdrUCAeM/qsEzKl66iSohZ5CxZ+0+7BmYakyDAAp483vb4j4/cBhl7XbtgDt7ZxzzjGn+MzOzpZ//vOfZvCqFYiff/558+YUwauP6QetQWq4/v37m92EP/roI9mwYYM89NBDMnDgwHbbRgBt17ILmWZnm8fAFuTL1Lm3spsBIEXRhqc3ug3bz6Sigepvv/0mf/nL5h4JRx11lFx66aXm/UOGDBEnCF59TLsGR6PFmTT76laoRhdT5gD+9Pw3f434ne9qbKF9lEk1CGnLAaRrW67/6mwaAXoepbRp06aZmVdNtLX8LDVBp9ODErwiJp0kWGnFYQBIt/ZNqz9mAtpyAOkqlWbFIPNqX004+H89yVoGrzpdTqFOEegQmdcM1Lt3b1m8eHHzFa3Q1Dl6Xyo0Eu2JfcX+4tjy5/dQs5AazGn7lqltuaKNih/7yhn2F/sqGcdVqC3Xdk1vSG177rmn3H777XLGGWdEBK+PP/64zJo1y5wO1CmC1wykV0D69u3b6n5tNAhe48O+cob9xb5KxnGVKRnXWG254jsXP/aVM+wv9lWij6tUa8vJvNpPBfr000+b04Fq8KpjXO+880759ttvzSK0nTp1EqcIXgEAAAAAnsrKypJXXnlFnnnmGZk6daqsW7dORowYIffcc4/suuuurtZJ8AoAAAAALhhGwLwlUqLXn+heQieddJJ582R9nqwFKU0nCL7mmmtcTRScadhX7C+OrfbH95B9w3HE987PaKPYV4isOLxmzZqwe8Sc9vPnn38WNwJGJs0rAAAAAAAeFJvS8bk7vXKeZBclNgHUUFkrnx1+b8pUYA758ssv5U9/+pNMnz7d7EIcsnDhQjn44IPN5U4rDpN5BQAAAAB46rnnnpNjjz02InBVAwYMkD59+sjnn3/ueJ2MeQUAAAAAF6g2bK22tlaqqqqiLqusrJSKigpxiswrAAAAAMBTe+yxhzklzqJFiyLuf/nll2XGjBmy4447Ol4nmVcAAAAAcIFqw9YmTpwoTzzxhAwfPlz23ntv6datm/zyyy/y2WefyR133CHdu3cXp8i8AgAAAAA8pWNdX331VXnggQfMQlMrV66UrbfeWj788EO58MILXa2TzCsAAAAAuMCY19gB7KmnnmrevEDwCgAAAABIiHXr1snSpUulsbGxVdXhTp06OVoXwSsAAAAAuMCYV2vV1dVyzDHHyBtvvBF1+VNPPSUnnXSSOEHwCgAAAADw1P333y/z5s2Tjz/+WLbYYgsJBiPLLRUXFzteJ8ErAAAAALjMvOq410S/RiqaO3eunHvuubLLLrt4tk6qDQMAAAAAPDV06FBZtWqVp+sk8woAAAAA8NTkyZNlzz33lG233db8Nz8/P2J5bm5uq67EsZB5BQAAAAAXDLNbb4JvKfrJXHLJJfLzzz/LkUceaVYVLigoiLg988wzjtdJ5hUAAAAA4Kmrr75azjrrLMvlw4cPd7xOglcAAAAAcKFJAuZ/iX6NVDRs2DDz5iW6DQMAAAAAfI/MKwAAAAC4nMYm0VPZpOpUOWr27Nlyxx13mGNfy8vLJdxNN90kBx10kDhB5hUAAAAA4KkFCxbI+PHjpaGhQSorK2XLLbeUnXfeWebPny95eXkyaNAgx+skeAUAAAAAF5qMQFJuqejJJ5+USZMmyeOPPy4jRoyQQw45RO6//3755ptvZN68edK5c2fH6yR4BQAAAAB4SjOsO+64o/mzTo0T6jY8ZMgQ8/7PP//c8ToZ8woAAAAALoTmYk2kRK8/Uerr6yU3N9f8uX///jJjxozmZUuXLpXsbOehKMErAAAAACBhtPvwyJEjZc2aNbJ27VpZsmSJ7Lrrro7XQ/AKAAAAAC5QbdjalClTzMJMaujQoTJ9+nR56qmnzEJNjz32mJSWlopTBK8AAAAAAE+1DE7HjRtn3tqC4BUAAAAAXCDzGqmiokJqamqkuLjYHPOqP1vRx4Qys/Gi2jAAAAAAoM3OOuss6datm7zwwgvNP1vd9DFOBQwjVetXAQAAAEDylZWVmd1ihz9zuWQVOsseOtVYVSs/n3CLbNy4UUpKSmI+vrq62pxP9f333zenp9Gpac455xwZO3ZsxONeffVVefTRR2X9+vVmd96rrrpKunTp0qZtXbRokaxbt04GDBhgvrb+bEUf06lTJ0frp9swAAAAAKSJ0047Tb744gu59dZbpWfPnvL888+blX31vtGjR5uPee655+Tkk0+WW265Rbbaaiu58cYbZe+995avv/5acnJyXL+2TomjN6WBaehnrxC8AgAAAECazPP66quvyu233y7HHnus+fvuu+8u/+///T956623moNXzbKee+65ctFFF5m/b7/99tKnTx8zqJ08ebLrbdUsbmVlZVyP7dy5sxQWFjpaP2NeAQAAACBNjB8/Xj755BNpbGw0f//uu+/MLsc77LCD+fv8+fNl3rx5cvDBBzc/p3v37ubz3nvvvTa99nnnnSf9+vWL6/bf//7X8frJvAIAAABACoyzDaeVeqNV63355Zfl+OOPl969e0vXrl1l2bJl8swzz8gee+zRPC5V6fJw+ntomVt33HGHXHvttc3be9BBB5kZ4KOPPtrMtC5YsEDuvvtuycrKkiOOOMLx+gleAQAAAMB1t+FAUroN9+vXL+L+a665pjlQbHn/zz//bAaJvXr1kv/85z9mRnSbbbaRYcOGmVPYqJaBb0FBQfMyt3r06GHe1J133ikTJ06Ue+65p3n5yJEjZcKECTJq1ChZvHixOd7WCYJXAAAAAPC5xYsXR1QbjpZ11S7BGiy+8cYbZtZT7bnnnvLll1/KzTffLP/617+aKwqvXbtWBg8e3PzcNWvWtLnacLg5c+aYAXNLWhBKKyDrcqfBK2NeAQAAAMAFzbom46ZKSkoibtGCVx3bqrTKcDj9XYspKQ0YNcv61VdfNS/X8bEzZsyQMWPGeHYcDBw4UB577LFW3Z1nzpwp06ZNM5c7RfAKAAAAAGlgyy23NIsv3XvvvdLQ0GDe9+2335pzvobGvObn58uJJ54o//jHP5rnYb3vvvtkw4YNbao03JLOLatBsc7nqmNef//738v+++9vzil7yimnyHbbbed4nXQbBgAAAAAXdDhqgmfKcbT+/Px8c4zr7373O3O8q3YD1iJJp556qpx//vnNj9PxqMcdd5z07dtXunXrZmZHn376aRk0aJBn211aWmpmc5988kmZPn26rFy50hxzq9P0hAJppwKGkeiZiQAAAAAgfWiwp8HZkKeukKzC/IS+VmNVjfw2+WazS3D4mFc7GuJplWHdTs18Ws2nunTpUrM78RZbbBG1G7LfkHkFAAAAABfCx6Qmipv1BwIB6dOnj3mzE89j/ITgFQAAAADgudmzZ5tzv+rUPeXl5RHLbrrppuaKyPGiYBMAAAAAtGXQa6JvKWjBggUyfvx4s3BUZWWlWUxq5513Nqfz0S7KbsbXErwCAAAAADylhZomTZokjz/+uIwYMUIOOeQQuf/+++Wbb76RefPmSefOnR2vk+AVAAAAANxIxhyvCR5TmyiaYd1xxx3Nn3Ve2VC34SFDhpj3f/75547XSfAKAAAAAPBUfX295Obmmj/379/fnDYnvMpxdrbz8ksUbAIAAAAAF3TS0URPPJoOE5tOmjRJRo4cKWvWrJG1a9fKkiVLZNddd3W8HjKvAAAAAABPTZkyRY4++mjz56FDh8r06dPNDOzYsWPlk08+MefJdYrMKwAAAACk0TyvfrBs2TKzKFN+fr75+7hx48xbW5B5BQAAAAB46tZbb5W3337b03WSeQUAAAAAN5JRDThFM68DBw6UuXPnerpOglcAAAAAgKf+8Ic/yG677SbDhw+X/fbbr9UYV61EHAw66whMt2EAAAAAaEO14UTfUtGll14q8+bNk8mTJ0vPnj3NuV7Db88884zjdZJ5BQAAAAB46uqrr5azzjrLcrlmZJ0ieAUAAAAAeGrYsGHmzUsErwAAAADghnbpTXS33hTtNpwIjHkFAAAAAPgemVcAAAAAcMEwAuYtkRK9/lRC5hUAAAAA4HtkXgEAAADALcakNlu/fr1UVlZKPDp37iyFhYXiBMErAAAAAKDNzjvvPHn66afjeuxTTz0lJ510kqP1E7wCAAAAgAuMeY10xx13yLXXXmv+XFZWJgcddJAce+yxcvTRR5uZ1gULFsjdd98tWVlZcsQRR4hTBK8AAAAAgDbr0aOHeVN33nmnTJw4Ue65557m5SNHjpQJEybIqFGjZPHixbLVVls5Wj8FmwAAAACgLfO8JvqWgubMmRM1OM3JyZEhQ4aYy50ieAUAAAAAeGrgwIHy2GOPmd2Hw82cOVOmTZtmLk96t+HPP//cfPG1a9fKbbfd1rxBo0ePlmCQ2BgAAABAutI5WBM9D2tqzvN6zjnnyPPPPy8DBgyQffbZRzp16iQLFy6U999/X84880zZbrvtHK/TdXRZW1srRx55pOy0005y+eWXy9///vfmZddff728/vrrblcNAAAAAEhhpaWlMmPGDLOIU3FxsaxcuVKGDRsm7733nkyZMsXVOl1nXq+77jr5+uuv5eWXXzYjad2gkLPPPlvuuusuOeyww9yuHgAAAAD8LRljUlN0zKvKzs6W008/3bx5wXXwqvP3PPnkk7LXXnu1WqbVoz777LO2bhsAAAAAIIXNnTtXvv/+exkzZowMHjxYKioqzKJNeXl5yes2vGzZMhk/fnzz74HA5r7YRUVFUlVV5XbVAAAAAOB/VBuOOe5VKw6feOKJ8umnn5r3vf3223LyySeLG66D165du1qWN9aCTX379nW7agAAAABACnvppZfMQPW3336TY445pvn+o446yhwLq/cnLXg98MAD5YILLpA1a9ZEZF7Xr18vl112mRxyyCFuVw0AAAAA/mcEknNLQdOmTTMzrzolTngvXbX11lubCc+kFmwaN26cbLHFFrLnnnuKYRgyefJkM7rWPsyvvPKK21UDAAAAAFJYTU1N89SpLYPX5cuXS2FhYfIyr/369ZMvvvjCzMC+++67ZvD64osvyh577GH2Z+7evbvbVQMAAAAAUtiee+5pFvjVWkjhwevjjz8us2bNMqdcTVrmVemEs88884z5c2VlpRk9t4yqAQAAACAdGcamW6JfIxUdc8wx5gw1WrBJY0Qd43rnnXfKt99+a87z2qlTp+QGr+G0wjAAAAAAAFlZWeZQUk12Tp06VdatWycjRoyQe+65R3bddVdXOyju4PXDDz90lSoGAAAAgLSeKifRr5GigsGgnHTSSebNC3EHr3vttZfjles4WAAAAABA+quoqDALNcWjuLhY8vLyEhO8aqq3pYceekhqa2vl8MMPlx49esjKlSvl5Zdflvz8fDnzzDMdbQgAAAAApJRkTGWTQlPlnHXWWeY413g89dRTjjOyAcNlevT22283izRdc801rZZdffXV5gDcCy+80M2qAQAAAMC3ysrKpLS0VPre8zcJFuQn9LWaqmtkyflXy8aNG6WkpET8bNGiRebY1niL/zot2uQ6eNWpcr755hvp1q1bq2WrVq2SsWPHmhsPAAAAAOkYvPb7R3KC18UXpEbwmmiu53ldvXq1mXm16uusywEAAAAAaNfgddttt5U///nP5pjXcDpA95JLLpHtttvOi+0DAAAAAH9XG070LUXNnj1bzjjjDNltt93M+DH89r///S9587zeeuutsv/++8vAgQNlv/32ay7Y9Pbbb8uGDRvk3XffdbtqAAAAAEAKW7BggYwfP14mTpxo9tjdcsstpXPnzmZBJ/150KBBycu87rHHHjJ9+nQzan7hhRfMAk7675gxY+Tjjz92PfEsAAAAAKRUteFE31LQk08+KZMmTZLHH39cRowYIYcccojcf//9Zt2kefPmmYFs0jKvSiNpnUJHaz5pNF1UVCSBQGruXAAAAACAN+bPn292F1YFBQVSXl5u/jxkyBDZcccd5fPPPzenXE1a8BqiAWuHDh28WBUAAAAApIZkjElN0TGv9fX1kpuba/7cv39/mTFjRvOypUuXSna281DUdfCqXYNjoeswAAAAAGS2SZMmyciRI2XNmjWydu1aWbJkiatY0XXwGkoB23E5hSwAAAAA+B+ZV0tTpkyRvLw88+ehQ4ea9ZKeeuops1DTY489Zs6Tm7Tg9bXXXmsVqGr69/XXX5fi4mI58cQT3a4aAAAAAJDCSlsEp+PGjTNvbeE6eNVqUdGcddZZ8te//lVWr17dlu0CAAAAAH8j82pr2rRpsvXWW0vXrl2b7/vxxx8lJydHhg8fLkmbKsfOOeecIzfccEMiVg0AAAAA8Lkvv/xSrrjiCunUqVPE/dpLV+d+raqq8kfwWldXZ3YhBgAAAIC0xTyvlp577jk59thjJSsrK+L+AQMGSJ8+fcypcto1eNWgVSedPeWUU2TUqFFerhoAAAAAkCJqa2sts6uVlZVSUVGRvDGv+fn5UTdQdenSRV555RW3qwYAAAAApLA99thDLrzwQjnppJPMeV5DXn75ZXPO1x133DF5wasWZopWUWrIkCFy1FFHSYcOHdyuGgAAAAB8L2BsuiX6NVLRxIkT5YknnjALM+29997SrVs3+eWXX+Szzz6TO+64Q7p375684PXuu+92+1QAAAAAQBrLysqSV1991Zzb9a233pKVK1ealYdvvvlm2X333V2t03Xw+u6778q+++7rejkAAAAApDSmyokZwJ566qnmTdXX15s3t1wXbNpvv/3atBwAAAAAkJ6amprMoaYrVqwwf3///ffN2kg61PSWW25xtc6ETZXTsiQyAAAAACAzPPvss1JTUyM9e/Y0f7/88svNYPY///mP2XV42bJlie02vGTJEtvfQxWH33jjjeaNBAAAAABklk8//VR22mkn8+e1a9fKjz/+KNOmTZOCggLZbbfdZObMmdK7d+/EBa/9+vWz/T3c1Vdf7WhDAAAAACCVBJJQDVhfIxXl5+c3dxnWgk077LCDGbiGeurm5uY6Xqej4PXee+9t/vm8886L+D2kqKhIRo4cKePGjXO8MQAAAACA1HfwwQfL4YcfblYZfuWVV+Saa64x7y8vL5eff/5Zxo8fn9jg9dxzz23+ecGCBRG/AwAAAEBGMQKbbol+jRS09957yz//+U957bXX5E9/+pOcccYZ5v3vvPOOXHHFFWbhJqcChmGk6LS3AAAAAJB8ZWVlZvA14JYbJZifn9DXaqqpkYWXXyUbN26UkpISyWRxZ14106oGDhwY8bud0GMBAAAAIO0wz2uEe+65R8aMGSO77rqr2GloaJAnnnhCBgwYIPvuu694HrwOGjTI/DeUqA39boekLgAAAABkhmHDhskJJ5xgzjwzadIk2Xnnnc2EptZFWrduncyaNcuc7/Xpp5+WLbbYwgxgnYg7eH3kkUdsfwcAAACAjELmNcIBBxwgc+bMkX/961/y6KOPysUXXxyR0MzLy5N99tnHHAt74IEHilOMeQUAAAAAN2Neb0rSmNcrU3PM65o1a2Tu3LlSUVEhXbp0ka233tqcQsctR9WGw7377ru2/ZNjLQcAAACAVKZzvCZ8ntcULq/btWtX8+aVoNsn7rfffm1aDgAAAABAwjOvdurq6iQrKysRqwYAAAAAf2DMq3+D1yVLltj+rmpra+WNN94wK0wBAAAAAJD04LVfv362v4e7+uqr3W8VAAAAAABug9d77723+efzzjsv4vcQncNn5MiRMm7cOCerBgAAAIDUQrfhmLTa8Pfffy9jxoyRwYMHm5WHc3JyzGlzEhq8nnvuuc0/L1iwIOJ3AAAAAABCzjnnHHnwwQclOzvbnNtVg9e3335bnn/+efOWtGrDt99+u9unAgAAAEDaTJWT6Fsqeumll8xA9bfffpNjjjmm+f6jjjpKZsyYYd6f1GrDukEPP/yw/Prrr1JfX99quWZnAQAAAACZZdq0aWbmdeDAgRIIBCKWbb311jJz5kwZMmRIcjKvjz/+uBx99NHS0NBgBq/bbbeddOzYURYuXCiDBg2SHXfc0e2qAQAAAMD/jEBybimopqZGgsFN4WbL4HX58uVSWFjoeJ2ug9f77rtPbrvtNnnnnXeas7DffvutGUFrQHvVVVe5XTUAAAAAIIXtueee8uSTT0pVVVVE8KpJ0FmzZslOO+3keJ0BwzBc9aLWSFm7BXfv3t3cmMbGxubI+quvvpLLL79c3nvvPTerBgAAAADfKisrk9LSUhl07U0SzM9P6Gs11dTI/GuvlI0bN0pJSYmkCo0PjzjiCLPSsMaLffv2NQNZTXhOmTJFzj777ORlXqurq6Vbt27mzwUFBbJ69ermZTpVzhdffOF21QAAAACAFJaVlSWvvPKK3HjjjbLLLrtIcXGxjB07Vj766CNXgWubCzaF0r/Dhg2T//3vf3LaaaeZv3/wwQfmxgEAAABAukpGNeBUrTastGfuSSedZN680KbgNeTEE0+UM8880xz/mpubKy+88IKceuqpXqwaAAAAAJCiFYe1snDXrl2b7/vxxx8lJydHhg8fnrzg9bXXXmv++aKLLpKVK1eaA3LVCSecILfeeqvbVQMAAACA/2lWNNGZ0RTNvH755ZdyxRVXyPTp0yPu1x66Bx98sLncacVh12NeDznkkIj+zLfffrusWrXKvD3yyCPSoUMHt6sGAAAAAKSw5557To499lgzVgw3YMAA6dOnj3z++eft020YAAAAADJOEsa8pmrmtba21qwuHE1lZaVUVFQkLnjVaXGcGjhwoOPnAAAAAADapqGhQX7++Wfp3Lmz9OrVK+pjFi1aJOvXrzcL8OoMMl7aY4895MILLzSLNfXv37/5/pdffllmzJghO+64Y+KC10GDBjleucspZAEAAADA/3w65vWJJ56Qiy++WDp27GjOEDNmzBj517/+1TzGVOepPfroo+WTTz6Rnj17ypo1a+Thhx+W4447zrPNnjhxorkdWphp7733NqdZ/eWXX+Szzz6TO+64Q7p375644FXHsQIAAAAA/Oull16SM844Q55//nk56qijzPv++9//ytq1a5uDVy24u3jxYlmyZIl06tRJpkyZIieffLKMGzdOBg8e7Ml26FjXV199VZ566il56623zAK/Wnn45ptvlt13393VOgMG6VEAAAAAiJtmLktLS2XwVTdJVn5+QvdcY02NzLvxStm4caOUlJTEfPzIkSPNTGtoJpiWqqurpUuXLmb28+yzzzbva2pqkt69e5u/X3PNNeJXFGwCAAAAgDSwfPlymTVrlhmAarCrdYv69etnjnsNmT17thnAapY1JBgMyvbbby8zZ870fJvWrVsnS5culcbGxlZVhzXr6wTBKwAAAAC4EEhCteHQ+svKyiLuz8vLM2/hli1bZv778ccfy7nnnis9evQwx5keccQR8thjj5lFmTSYVOEBrdJs7Pz58z3bbg2QjznmGHnjjTeiLtfuxFrMKSnzvAIAAAAAkqNfv35mV+XQTceOtpSTk2P+O23aNLPS8Pfffy9z5syR999/X2644YaIx+hUNi2DzdAyL9x///0yb948M5DW8a6rV6+OuGlg6xSZVwAAAADwucWLF0eMeW2ZdVWhKWlOPPFEs9JwqHvuIYccYga0od9DWdqtttqq+bn6u06Z45W5c+ea2d9ddtnFs3WSeQUAAAAAnyspKYm4RQteNWDdYYcdmrsPh+iY065du5o/Dxw4UIYMGSKvvfZa83LNjH7xxReyzz77eLa9Q4cOlVWrVomXyLwCAAAAQJq4+eab5bDDDjO7GW+77bby7rvvmjftOhxy0003mdlZrTCs2Vd9zqhRozyd53Xy5Mmy5557mtug/+a3qMqcm5trFopygswrAAAAALhhJOnmwF577SVvvvmmfPXVV3L99dfLihUr5Msvv4yYW/XYY4+Vl19+WT777DNzyhzt2vvee+95Oub1kksuMcfdHnnkkWZVYS0WFX575plnHK+TeV4BAAAAwMU8r0OuSM48r7/dHP88r36hY17tug0PHz5cunXr5middBsGAAAAAJ9PlZNqtPiTlwWgFN2GAQAAAAC+R+YVAAAAANxK0cxoMsyePdscU6tjX8vLyyOWadGogw46yNH6yLwCAAAAADy1YMECGT9+vDQ0NEhlZaVsueWWsvPOO8v8+fPNaX4GDRrkeJ0ErwAAAACQJtWG/eLJJ5+USZMmyeOPPy4jRoyQQw45RO6//3755ptvZN68edK5c2fH6yR4BQAAAAB4SjOsO+64o/mzTo0T6jY8ZMgQ8/7PP//c8ToZ8woAAAAALlBt2Fp9fb3k5uaaP/fv319mzJjRvGzp0qWSne08FCV4BQAAAAAkjHYfHjlypKxZs0bWrl0rS5YskV133dXxegheAQAAAMCNZIxJTdExr1OmTDELM6mhQ4fK9OnT5amnnjILNT322GNSWlrqeJ0ErwAAAAAAT7UMTseNG2fe2oLgFQAAAABcYMxrpIqKCqmpqZHi4mJzzKv+bEUfE8rMxotqwwAAAACANjvrrLOkW7du8sILLzT/bHXTxzgVMAwjRXtRAwAAAEDylZWVmd1ih118k2Tl5Sf0tRpra2TuHVfKxo0bpaSkRPxs0aJFsm7dOhkwYIA5NY7+bEUf06lTJ0frp9swAAAAAKDNdEocvSkNTEM/e4XgFQAAAADQZuvXr5fKysq4Htu5c2cpLCx0tH6CVwAAAABwg6lyIpx33nny9NNPSzx02pyTTjpJnCB4BQAAAAC02R133CHXXntt87jggw46SI499lg5+uijzUzrggUL5O6775asrCw54ogjHK+f4BUAAAAAXGCqnEg9evQwb+rOO++UiRMnyj333NO8fOTIkTJhwgQZNWqULF68WLbaaitxgqlyAAAAAACemjNnTtTgNCcnR4YMGWIud4rgFQAAAADaMuY10bcUNHDgQHnsscfM7sPhZs6cKdOmTTOXO0W3YQAAAACAp8455xx5/vnnzflc99lnH3PqnIULF8r7778vZ555pmy33XaO10nmFQAAAADcIPNqqbS0VGbMmGEWcSouLpaVK1fKsGHD5L333pMpU6aIG2ReAQAAAACey87OltNPP928ebI+T9YCAAAAABmGasPJRfAKAAAAAPDc7NmzzW7DP//8s5SXl0csu+mmm8x5YJ1gzCsAAAAAuMGYV0sLFiyQ8ePHS0NDg1RWVsqWW24pO++8s8yfP1/y8vJk0KBB4hTBKwAAAADAU08++aRMmjRJHn/8cRkxYoQccsghcv/998s333wj8+bNk86dOzteJ8ErAAAAALRhzGuib6lo/vz5suOOO5o/FxQUNHcbHjJkiHn/559/7nidBK8AAAAAAE/V19dLbm6u+XP//v3NaXNCli5dalYidoqCTQAAAADQljGviZSimddw2n145MiRsmbNGlm7dq0sWbJEdt11V3GKzCsAAAAAwFNTpkyRo48+2vx56NChMn36dDMDO3bsWPnkk0+ktLTU8TrJvAIAAACAG2ReLS1btswsypSfn2/+Pm7cOPPWFmReAQAAAACeuvXWW+Xtt9/2dJ1kXgEAAADAhcD/3RIp0etPlIEDB8rcuXM9XSfBKwAAAADAU3/4wx9kt912k+HDh8t+++3XaoyrViIOBp11BKbbMAAAAADAU5deeqnMmzdPJk+eLD179jTneg2/PfPMM47XSeYVAAAAANygYJOlq6++Ws466yzL5ZqRdYrgFQAAAADgqWHDhpm3WB544AEZPXq07LzzzjEfS7dhAAAAAHAhYCTnls4++eQTs3txPAheAQAAAAC+R7dhAAAAAHCDMa9JReYVAAAAAOB7ZF4BAAAAwK00H5PqJ2ReAQAAAAC+R+YVAAAAAFxIRjXgdK82vMsuu8jgwYPjeizBKwAAAADAM4ZhyC+//CLdunWTTp06mfe99dZbsmDBAtluu+1k/PjxzY89++yz414v3YYBAAAAwFWUlqRbCqmtrZU999xThg8fLv3795ePPvpIfv/738sBBxwg5513nuywww7y17/+1dW6ybwCAAAAADzx7LPPytKlS+XDDz+URYsWyTnnnCPV1dXy888/yxZbbCGvvPKKHH/88XLmmWdK3759Ha2b4BUAAAAAXGDMa2tff/21mWHdY489zN///e9/y4QJE2TYsGHm70cccYTstttu8sMPPzgOXuk2DKDNampqzCtq6fYeEvG+GhoapLKy0tN1ZrrGxkapqKho780AfIs2On600d6jjc48TU1Nkp29OUeam5srOTk5EY/R+/TYcIrgFRHq6urMk0A96GJxcsDpoG03B6iX2+DkvSWaH/adlyc/Rx99tOy0006SyqK9h0S8L13nqaee6slxqo/TE622rCMVj8WW1qxZIz169DC7ISF+oeMk2k0/61jP8/r4ikUv+lhtb3tevNDvoN3+ShZtn63a6FCWI5VFew+JeF+6zjPOOMPzNjrVvm9eSvs2mjGvrWyzzTby6KOPyty5c+W9994z/3344Ydl9erV5vLPP/9c3n//fdl6663FKYJXSHl5uZnOP+yww6SkpESKi4vlm2++ibpnPv74Yzn55JOlX79+kp+fLz179jT7rGs1sZa0MdYDVQ/gwsJCKSoqkiFDhsjf/vY3MxBya/HixXLllVeag8B1nR06dDAHfmv/+ra8t0Rzst2J2ndtccghh1ieJBQUFJjbCXs69uO1116T6667rs3H6axZs8zH6XcyFb/HXtKTonPPPVf+/Oc/S319fXtvTsq46aabzONEP/+Wt9AJRkhZWZk8+eSTZjsQOr6+//77qOvVwhyTJ082u4KFjq8TTjhBfv311zZtr7ad0bZVt0UrWSb7s3/ooYfMbdL3mJeXJ/vss0+7/X1RBx54oOy1115Rl9FGx+fdd9+VqVOnyrXXXuv6+A/57rvvzMfpSXoqft+8RBudeSZPnmxecNE2UrsL//3vf5ehQ4eax6mee+y8885yyimnyKBBgxyvm+AV8sILL8ibb75pVgHT4MqOVg5btWqVvPrqq+bVQG00dUD22LFjzUHY4bSh1oHYxxxzjKxdu9Y8ub7hhhvk+uuvl9NPP931nn/kkUekd+/e5h8Yvco8f/58MwjUxvree+91/d4Szcl2J2rfJYru508//bS9N8P3br75ZvM7NGLEiDYfp3oFu3PnzrLrrrum5PfYa1pmX0/WXnzxxfbelJSzYsWKVpmg7t27Rzzm+eefN0/szzrrLLn00ktt16djnNatWyevv/66eXzpRRudGkGPr2gXSOK1ZMmSVtupx646+OCDW3VJSyT9Xui+0O+GBhr6/enatav53Zo9e7b4zUsvvdS8r2DfRu+7777mCbfb4z+8jdYpQvQkPRW/b15L5zY6NOY10bdUUlRUZF640eNRs656YV2Pa73o97vf/U5efvllefDBB92t3EBGqKqqMm8hDQ0NRnV1davH3XzzzWbnh6+++irqeq655ppW9y1YsMB8zllnnRVx/9Zbb23079+/1eMPPfRQIysry9yG8O0pLy836urqDDeampqMHj16GGPGjLF8TKz3ZuWqq64yrrzyyqjL1qxZY+yyyy7GjBkzDC+328m+i+fzrq+vt3xsTU2Nue/1VllZGfUxev+ee+5pbLfdds2PraioaF6ux1L467V8/XC6Lfr8xsbGqPvD7TEQWrcdu/UffPDBxujRo2PeFy7W5xDut99+MwKBgPGvf/3L9nHxHqfjx483Jk+e7Godifoet6Xt0c9FPx87sV5Lv4t77LGH7WMyTbT9r9/50HGgn7l+H524/vrrzefNnDkz7uPr119/NZ9z7rnnRtzf1rb/j3/8o7neN954I67HX3bZZcZf//rXqMtWr15t7Lzzzsa3335ruw5tDwsKCoyDDjoo4n5tE7t06WIcccQRMbcjEW30rrvuaowbNy7hbXSsdtZKPM+1e8yECROM7bffPuZ9btvouXPnmsfSU0891abjP0T/rp922mnNv/vh++a0jQhHG93axo0bzf28zek3GduddWdCb/oa+lobN240Mh2Z1wyx3377mbc5c+aYV+m0+99JJ53keD0tu9Io7QKQlZVllsIOp1ehtRtXy7EcOvdTx44dzeeEaFdK7RYzZcoUcUNfQ2+lpaXitWAwaF5l12xTuI0bN5pdIX788UcJBAKebreTfWf3eetVTs0E6Oet3ZT/+Mc/tupad/HFFzd3XdJMnnY70q5nn332WfNjdNzn9OnTzW5Qocdq11GrsaEXXHCBdOnSxdxHLZ1//vnmVWbN4IXoFWN9vg7e1+5tW265pTz11FNx7UN9rmYftduevscxY8bIf//731aPcbv+lqZNm2Z2nw7tU13X3XffHbPLombc9fO06tbnxPLly+Wrr74yx2a5kajvsdO2R7sdX3XVVeYccPq56E0zaOHZX33dG2+80exapMu1e6hmRj755JNWr6X7VrtERzvuMpXuE+1O+tNPPzUft9pVqyX9PL0S7fjSz1jbyZbHl2YEte3Xq/FO6fGjwy503Tp3YLztufYauOWWWyLuX79+vXmcatY0Vnuubb72nmmZUdNMw3bbbSdvvPGGVFVVxfW5aGZs9913Nz8X3Q9anbNlW6Ltacs2eu+995Yvv/yy+THjxo0ze7/MmDGj+bHh2cOWY0N12grNCoa3wyH6d0KfH15YTntp7LjjjmYbqq+/1VZbydNPP237HsOfu8suu5httL7H7bffvtXYx7asvyUdR6evF2qjdV3auylWG/2///3P/NeLNlp7CWgXcqs2ur2+b07bCNpotJW2MXqO/49//MNsdx944AHz73RbxmcTvGbYAXTJJZfIfffdZ/6hPvHEEz1Zr/7R0YOw5aBrDfb0j58GK9pFdtmyZXLXXXfJBx98IHfeeWfEY7Uimf7h1z9c8dKTA31PelL8hz/8wWxkdRye13SdF110kTmZcmi7tZuPNvZ6kq1BiZ6weLndTvadFX2Nyy+/3LwgoK/52GOPmSeILbso6/EQ6rqk26LdO7R7swYR+rpKg1YNgvV9hh6rXZ+saLELPblrOZ43dLKpwW4oYNftOvTQQ82TsVB3Ku0mpV1Stau1HR2Lqc/VEzfdT7rPdH3/7//9v+bHtGX9Lenzdb+MHDnS3Df6ehoY63hmPaG1o421BvQDBgwQL75zeiKoF0+84sX32Enbo6+l+1I/H/1jpseodnXTE1e9GBE69vQ5Gmzov3pMaffMv/zlL/L444+3eh09DnS9dGGPpMG8HvPaRUu7Fx533HERyzVQ0fZXAwv9rsycOVO8pl3E9EJEy+PLTdsfohep9HjSLmgalMZDL0RqMHjFFVfIPffc03x8anv+22+/mV3vdXy3nVBwG+3kS4vzaJCk7Xss2t1Yt0PbZT3+tT3T9lq/D+H0c2vZRusYwoMOOqi5HdYx8Bp46Hcg9FgNoOzaaP1eaze+cLodet+xxx5rHg9Kt+vwww+X/fffX1auXGmuW/8maoDzr3/9y/Y93n///eZz9eKhfr91X2sRl+eee675MW1Zf0vaPug4Ub2IqRf59D1q26afbazu3NpG637t06ePtJUG53qxTS+ItNSe3zcnbQRttAMUbIpKzzd79epldhnW40vHveoFOm2rdK7XaBeh49LeqV8kh3an04/7u+++s32c06612m1WuxR26NDBWLRoUavlL774otGxY0dzncFg0MjOzjZuueUWwwsjRoww8vPzzXXra/znP/+xfbzbbsMh2p1Sn3/XXXcZe+21l9lt7P3330/Ydrdl3+nnrc/5+eefI+7fb7/9zG6gVmpra80uTStWrDCff//99zcv22effSy7Z0XrXjtq1CizC1u4f//73+b7+fDDD83ftVtbaWmpceSRR7Za5x/+8Aeje/fuUbuuqbKyMqO4uNg45JBDLN+Pk/XH0234zTffNLf/888/N5zSz8Ru3zs5TrW7om5bW9aRrO+xVdsTOhZeeeWViPv1+OvcubNx8cUXm78ff/zxxpZbbhnXa33xxRfmOh988MG4Hp8JdthhB7O7+qxZs1ote/jhh43HH3/cWLVqldklUI/rsWPHmu2T7su2dpsM747bt29fo6SkxFi6dKnhFW2TtOv64sWLHT1Pu6aeccYZ5n655557jN12280oLCw0pk2bFtfztYuuPl6HUoRbv3692d7ovnn77bdjfi667dq9M5z+bbEbqhBqo3U/6uvoZxiiXeZ1vdFE61671VZbGTvttFPEfXo86Ho//vjj5nZWP7djjjmm1TpPP/10o1evXpbd/Tds2GC2KXbdqJ2sP55uw6+//rq5/V9//bXhlO47u33v5Pjff//9jcMPPzwlvm9WbQRttINuw6fdZGx35p0JvelrpFK34XfeecfIy8sz7rzzTmPZsmXN9+v3+YcffjC/3zrMws37IfOaQbS6V6wryk5oFuSoo44yr+5q9kTXH067CGiG7bLLLjOvtuoV3WeeecbMMmpRmbbSK826DXrlWTOY+lqaEUoUvYKsFVovvPBC82qRFh1w070onu32Yt9pN8vQZNAhWihIs2fhFi5caHbj1O6heqVYrzxrl2CtEqdXq93SbIh2bdUJqEP++c9/mtXmtJuc0gyZXvHVDFxoKh59r3rTLmRaVKhlAaEQfa7uG80QWGnL+qPRq9i6j7RIi34emiWIl2ZZtAtbW2lWQsvOa6YiVb7H0doe7aKn2WP9DoV/NprV2nbbbc1u6kqLjmgWSzNF2mXbrsJxKFNEt+FIAwcObFUkTOnnp9kt7T6qxY60gJx279JsqGYEvaCfqXad1Ey6ZtG0V4cXNIun3UM1Y+p0gns9xjTbqcXytEfBF198YXZfDrVLsWi3Su2Jo4VItHeLtqHa80KzVaHjM1Z3eqVtYfjwC6s2Wt+rbqv23Ai10aG2va1ttA4PCc9IahutQyG0220oG6ltl1UbqtlNq6q2+lxtr+za6LasP5pRo0aZ7Yq2F9rLR9v4ZLfRuh49Nlq20X7+vkVrI2ijHSDzGjX7rzMA6DmzZl/D21/tvaZtjZ6nhv7WO0HwmkG8OmlQWtFOT3j1oNMuP1qJtOV4Dm2MdWya/nHXPwj6B0UfpycL2m0oVjfLeOkf8ltvvdXsFqpVVhM1XYJ2oQmNDwr/2evt9mrf6fpb0nXpH7fweef09bUE/1tvvWW+tnaz0pN/PfmKNodovDQg1u3WgEjpCZn+QdcTplC3u9CJhXYj0eBZ/6jreFi96X3atcoqENF541R4o9hSW9YfjZ4kv/POO+Zr6vvQ7l8a0Gr32VjjN3R8qBdBlX5O+rlpd7NU+R5Ha3v0s9HX130Z/tnocavBRGhM2J/+9Ce5/fbbzaqF2nVdx7zq+MZo3Y1C+1fHBcJ+/1vRY1rHJIam92gL/Qz1RFovIumJih5rXtETc+0WqRcA3Qhvw/VCndN5YvX78MQTT5htmg6n0K6qekIWqvTd8iKQkzZag5/wfagXeHQ8olafDbXR2rVT29G2tNF6MVaDqFAbreNvtS3Qtq1lG6qVYlu2oXpS6lUb7Wb90ehYT22j9fmnnXaauY/1c9G6BLHmSfWqjdahRPq56DGRKt832mh4Tb8DOgzIji5304YRvGYQvbrnBT3Q9EqqnkTr+IjwP3QhetVPr6DqFdyWQvd5PQeZFmXQK7dOrrTGS//o6ZxVOnZGr+bqFVUNzvR3r7fbq30XTxEpLfgxb948ufrqq80/oKFjRDMJbZ3sXLME+odU5x7VIEVPkHRcWnixmND0ADp+0Wrydr36bvVHX+l4UyttWb8VzUjoyYme5GgApUVbtOjVHXfcEfPKtmYRvBhLpVfsQ+8/Fb7H0doe/Wz0xFRP1KN9Lt9++635OL2IovtXg2SdC1HnPtT9qAG1Hqcttze0r2G//2MdG/FkDu3oxTjN2GvApWPLTz31VE/bY/1O68UkHffplLZtOu5aM0s6vlPXofMca6Elp8GfBh0aSGp2VNsAvRCoYyZ1PJcXbbRmRnXdWpRHg+TQZ6n3tSyi5pQGijoWTb9T+nlpG63r1791LdtQbcet2lDtHdHWNtrN+q3oeDpt17Rt0cyutpcaCGsAm6w2Wv8u6P5Nle8bbXTbMFVOa3qRWce46jR+LQuU6YWta665xqynEpruzwmCVzj+o6/dlzRo0260Vle99Uqrdm8KnYCGC03iPnjw4Ij16h8pt1lTPZnRP/J65batJ/Ut6QmCntjrSY5e7deTHA1gtRBD6OTfrWjb7XTftUXoD1bLYiehK/EtMwJOKyTqftNGSrvkaZZCTxLDr8JrIKjvXbuhOqUnBxog63qttGX9sWiBGd0GPVHQk5RYV871hEoD3rbMu6ffEz3BbmuX4UR9j53QCxv6nXdyAUg/S8366lyMesFH//CF04ytZpLCK1/DGQ2K9LMNr0zrlJ6Mh4JBzehHuzDSlrZfT9C1iqoWXXN60q9trmbkdNiHBm3ahmuBN+2BMnHiRHPdbmkXXi3gpsWGvJKMNlovnGrApW2p9ugIzwhrV2rtyeCmDdWTUu0pYddGt2X98bTR+jdAs5C6HfG00TqXdctu207ocawXN+Nto5P9fXOCNhptPX60qvmkSZPMXg16cUh7QejFPW1jtAijfu/1PM4pglc0d5nSm2bIlGZb9PfwUvmhIE6votx2221m5jH86qg+J7wrgGZLtAuS/qt/1HVMnVYe00qKelCHj4GLd6ocPdEZP368WalQxypqJkb/IOkJrVbs07Gj4Scz8b43O+eee655lV+zU6Er0vpHUU9+9A/jkUceGXPydyfb7XTftYWOLdTg47rrrjP/gOoVcu0Cq9lY7R4abvTo0WbgpQGCdreLZ/9pdkwbLO36qetu+UdVx45p8KcZEM3I6jQPum80KNFjQU8orWhQFSq5roGYbr+OI9aLCaGxyG1ZfzR6sqvHvXZL06qWmunTz0XXGWuqDg3c9TPW8aotxXuc6jGhWZ5o0y/44XvshGYJNHDQAEQDaM3gatZDv0v6ndMAVek4Qv1ZPzs9sdQx4/p4/WPYMmuu+3afffYxM7qQuNokvRCnbZJ+d7Qd1uNYv/s6pMHt8aVZH60ErJlIPam2Or7cTpWjwYgGc25O0rV7qmb5tF3Qkyql71e3Q48nDTriqYCpfw+0CraOF9Xvv47v0guauv+0mrFXtEeMVijXLIVeRNKgXbvRa/vTMnDXNlo/S601EG8brRXLtYuzDqPQ71/LfarfJf1sNLjV76q2s/p+dVu0HdA23oo+V7+r2rVa2xn9W6fHmVZ0Dj2vLeuPRi8wa0ZcL0KE2mgdt69VqWO10TruVo+rtrTROi5/w4YNrdpov3zfnKCNdoAxr1HpNHd6PqnfQT029e+ztjF6LqwXbuLpWh+Vx8Wl4FNaZVZv0XzzzTdGUVFR1FufPn0iKgdaPU5vWrExWpVSrQiplUy1aqBOAD9lypRWE9K/9tpr5jp0WSxatVQrRWrVXq2AOnjwYLMi6aeffur6vdn5xz/+Ydx9992W1WyPOuoo45dffvF0u53sOyef99/+9jfzvYdP3K4VibUqor7GwIEDjYsuusic0F6rwF166aXNj9OKcJMmTTJ69+5tVpDs0aNH87Kjjz66VdXKkJtuusl8TV231eTz+jmdcMIJ5mP0dbfbbjvjggsuaFWJMxrdf1rNUrdft00r8X7yySeO1x/tPbS8T7f/mWeeMStc6vGjFR333ntv47nnnjPioVWPo+2neI/TP/3pT8awYcN8+z122vZo1cFHH33U2H333c3Kz7qdWsH1gQceMKqqqszHLF++3PjrX/9qVuXs2rWr+f5PO+00Y/bs2RHr0t+jVS/OdFq99oADDoi67NtvvzUrPmrV2U6dOhnDhw83zj77bGPBggWtHvvll19aHjMDBgyIqFxtd3zp9oR76aWXzPsfeuihuN6PHr/6HbarYGtHK1/ed999UZdpFV9tz3/77beY69Hj84YbbjBGjhxpHpf6vdbjNrxtdfO5XH311eb+aHlsH3rooUbPnj2NQYMGGX/+85+Nmpoas7LxlVdeGVHtWP+mhNro8O+97q9o3+3wvwtDhgyx3H6t3qvtv37Wuv/HjBljtkfz5s2L+V61cvFhhx3W3EZrpfTPPvvM8fqjvYeW92mb9PTTT5vVfkNttLZdL7zwghEP3c/R9lO8x/+5555r/o336/fNaRtBGx1fteHRJ99kjDnjzoTe9DVSqdpwIgX0f+7CXgCAE5o91KvvmnXX+Rid0sqk2rVRM6aIpN2TNGOmmZt45/wEgHDas0iHg3z99deO5m8P0Z5G2hNI5xNG+rfROq5a56zfdvKNkpVrX5yorRrrauTbp64yhx+VlJRIJkuPowcAUoB2AdQuXi27iMVDp4vRqXmidRnOdNo1ULshaff7dDkpApB8WtxJuzi7aaO1qJzWeKCNbo02OrPNnj3bnL5Kx3brcLXwmw7rcorMKwAAAAC4ybyelKTM679TL/OqY1t1/mXtNabV2HWOai3S9vTTT5uzFmhNGZ11wwkuUQMAAAAAPKWFLrU4ngapI0aMMIs0aSE37T6uxZzczMtO8AoAAAAALjDPqzWdeio0M4DOEqGV0EM1PPT+WFNYRUPwCgAAAADwlM59rNNLqv79+5uFK0N0OqvQXNZOOH8GAAAAAGDzPK+JlAZzw0yaNElGjhxpFjbTedt13vhdd93V8XoIXjOQTn6tld90YvhAINDemwMAbaazvml3pN69e2dMxWHacgDp2pbrOaoWJuI8NbVNmTJF8vLyzJ+HDh0q06dPl6eeekoGDRokjz32mFnwyimC1wykgWu/fv3aezMAwHOLFy+Wvn37ZsSepS0HkM5SpbJuaMxrol8jFZW2CE51jns389yHI3jNQHo1K3SSlwqNAgDEM2WBXpQLtW+ZwMu2/IG5h0l7OnvYq+36+gD81ZZru5ZJ7Xm6q62tlblz58rq1atlwIABMnjwYNdZdYLXDBQ6WPRkh+AVQDrJpC5mXrbl+R3a73TgpaXbytSv/tamdXy4z+2ebQ+A9pdSXYYZ82pL53S9+OKLZeXKlc33jR07Vh555BHZdtttxSmCVwAAkNL2fO8S188l8AWAxPj000/ltNNOk2uuuUaOP/546dKlizm/66233ioHHXSQ/Prrr1JYWOhonQSvAAAgI43uvFQumDkp7sf/Y7tnE7o9AJBOXnjhBTnvvPPkqquuar5vzJgx8uyzz8ro0aPl448/lv3339/ROgleAQAA4hBvoEuQC2QOCjZZ08rR22yzTav7dVYALa6oY5ydIngFAADwEEEuAIiZZX3ggQfkpJNOks6dO0d0J/7oo4/kvvvuc7ybCF4BAACSbN/SWfLavNYZiWgOHfx9wrcHgEsUbLKk4111XletMLz33nubAez8+fPN+V4vueQSGTJkiDhF8AoAANqt0jBiI8gFkIoKCgrMca0awGqmdc2aNTJy5Ei5/vrrZbfddnO1ToJX+MLAh/9uuSxYnRXz+fMuuMjjLQIApHuxpnRDkAu037hXRJeVlSWnnnqqefMCwStSnhE0ZNC9d0Rdlrc2GPP5c669MAFbBQCp4R9z9m3vTcjILsPtZXr5cJn+3TG2j7lt9AtJ2x4AcILgFRmtvsSQIXfeafuY3y4iqwsAyByX2gS3BLZAC4ax6ZZIiV5/CiF4BWw0dmqQgf+6LfrCrNgNyYKTL2P/AgAyIrBVBLcAEong1Ucuu+wy+eSTTyLu23HHHeX2229v/n358uXy0EMPyddffy1FRUWy3377mX3Is7P5KP0mp6BetnjhBsvlvxzzl6RuDwCg/bV3l+FEI2uLTMM8r8lFxOMjs2bNkt69e8v555/ffF+nTp0iAtddd91VTjnlFDn77LNl1apVcvXVV8s777wjzz//vKQqDfByNr/NCHVludLYocH2+cGq2AWd/Ebf14B/WmR0NalbZv/VnHchXZkBwK10LNbkd1MXjpCpC6+xfcwPh12XtO0BkJoIXn1Gg1cNUKPp0qWL/PTTT5KXl9d8X7du3eTQQw81s7P9+vWTjBMQaSpqjLqoeE5OzKfXl0jqyTJk8D3RC1SFzDv/4qRtDgC4wTQ5aGnUq9bBLYEtfIt5XpOK4NVn3nrrLdl3332le/fuzV2CA4GAuSw3N7fV40tLS81/a2pqkr6tqS6rVqTDwk37NpqNWzWK1NpUKy6MHjS3t6bSBhn4xK2WyxecwjhcAMg0yegynEgEtoA7//3vf83b8ccfL4ccckjEsh9//FGefPJJWb9+vYwbN05OO+00ycmJnfxpTwSvPtKxY0fzwNphhx1k7ty5cvnll8ubb75p2SXYMAy55ZZbZMSIETJ06FDL9dbW1pq3kLKysoRsf0bJbxRpktTTFLAuQKWC9kWoCHyB9kNbnvrac7xre3cZTiQCW7SnQNOmW6Jfw425c+fKBRdcYAanI0eOjAhep02bJvvvv785HFFjib///e/y0ksvyf/+97/mxJkfEbz6yKOPPir5+fnmzwcccICMHj1a9txzT3MM7C677NLq8VdddZV89NFHMn36dNuD7Oabb5brrmMciRNm1rUtgiL11RZXrhoDEog9/azv9Oq1XnZ6+3Lbx3y2/y1J2x4g09CWA86UbyiQgU9G/7u04GT7v2dAOlzwPP74482hhRrAtnThhReayx9++GHz94MPPli23HJLef31180hiX5F8OojocA1ZPfddzfv+/bbb1sFr9dff73cc8895tWRbbfd1na9V1xxhVwUNlepZl79Mj52q5euE9tCySV1ts+vK2/dlTrVGU0ijSXWRaqyKhNUoCpG1jWWDrm1st+HF1ouf2fPu9q0fiDT+bktTyUUa0qvrKtbBLVI9zGvf/7zn2XUqFFy3HHHtQpely1bJjNnzjTjiZBhw4bJdtttR/AK9zZu3GiOZS0sLIy4/8YbbzS7C2vgqgFuLFrgKbzIU7poWFmgCc6ocjYEpS5GMaaC1YnYqk1Z10TJLmoQ0ZudWv9VXy7JrZWJn/7R9jEv7nx/0rYHSEWJaMvPmjFZ+1W4fv5WRcs93Z50lu5T5KQLglr4WVmLoX9Wfxdee+01MwjVBFg08+bNM/8dMGBAxP36e2iZX5F59Qm9AqLjW3WgtHYB1lS/XiXp0KGDHHTQQc2P06BVu45p4LrHHnu06zansg5LrJdtHGZIVpV9BNqoY14TlHVti0CwSbILrFfSUJmYTLVmXdtiRWWx7PKOdSGpT/azLkAFoP3MrnQf+AKJ7jLsJYJa+GGe134tettcc801cu2110bct2TJEjnjjDPMIk0lJdEzOdXV1ea/GmeEKy4uNqfi9DOCV5/Q+Vy//vprufTSS6V///6yYMEC6dOnjxnQ9ujRw3zM7NmzzW5jPXv2NMe7hrvjjjvMQk9IvMau9Sm5mxt0DK5F1+D84rYFn4m0ZHEXGfCYdZGphadfmtTtAdB2K2tKpFP+ppMnN9bXeBuYILO6DHuJoBbJtHjx4oiANFrW9ZFHHpFgMCgPPPCAeQv15tQCsAsXLjTvC81WooWcBg4c2PzcdevWNS/zK4JXnygoKJD777/frPSllcE0YO3Vq1dEISYNarU4UzTDh9MlyA+MevvqbLHGqzZazFkbb9Y1UbqWVCRs3Zp1dc0QGfBPm+rJGtz+juAWSDdtCXzbA12GUzvr6lTXj3Jl7Ed3Rl329aObx60DTpWUlFhmU0OOOuoo2WKLLSLu0y7EGivss88+5u9amCk7O9ucKkfHuYbo7zpG1s8IXn2mqKgo4iBquWzXXXeVdLFpyhbrPzDZRfbFmtJNdlnQvNlpHBpjvGs7qKrLNW+xxry6zbq2lV1wS2ALZJbRpTZjRlpYXx9ZbwLwwtgzWge1BLQpzjA23RL9GnEaPXq0eQt3ySWXmAVejz76aPN3DYB12hxNnGmwmpuba06To5nZSZMmiZ8RvCIlaUI6u4f1lfe6YGTl5laW+K+oUSxNeYYEFtu8rwFVvsy6rl9fZN6s9O6+QdpD7qoc2eJm6wrIv1xhXTkZQPrrlBNfm0qQm7ldhq2yrl4EtIqgFol07733yr777itbb721DB48WD7++GOzrk7LwNdvCF6Rcbp9rdnN6FewajsGpGiJfdffsq7iy8BWVlhnsY2AiO27aqcxr1nL8mTlsk1juqPq0j6Z5vy1IqMuiQxsf7idYBbpZVOlYSQryG0PmVhluL27DHuJoDY1JLNgk1tTpkwxuwqH69u3r3z//ffmkEQd+/rggw/KoEGDxO8IXgEHGvfYKNY5RJGKNYWJC04TJL9v4saz2mVcY2koNCRQbZ8hN1xWfdasq1MEs4B3xZoyycsLt5GXZZu4Hnv9Vq8kfHvgr6yrG3Q9hlMTJ06Mer92Fw6Ng00VBK+AR+rqsiW3xHqcbn1FrjQV2wRbMca7uqVZV7eys5pkY5X9Veyc7EbXWdc2KWqwzSYbjQHXWddYClYbMv6U6N281JdPUJADSOXxru3lr7MPT4sgN1O7DLeXKX+9V75YeG+r+3cYML9dtifjaH4hwZnXhK8/hRC8ol1s8cINkhM5tVSEhtosaayzzrpl5yVmntX2EtyYLQ0drFumYL0/s67lG+wzzYGsxFVAtn3d8mz7btIJVFcSkG3Psx5L++29dD8GkJwgd/++czJqV7dnl+FkZV2d+GJh6y6gBLRIdQSvSDkFHezHZ1atLhLJ8dclKs26upVVE08Y5q/3qwrn2L/nuk5t2OYi92NhS+fGqOicFzvr6lZWjcj2v7cObGc8QmALwBsnDf4y5mNW1WVWF+50zbo6QUCbmWNe0wnBKzJKl6+ypcniqO/2eez+oov38N9Xpq67dVo2v2NNwl43VtbVTt5GvdkH5etHGK6zrm41xChSHU/W1a2Ov1TLPnveZLn8vQ+vdL1uAO033tXPuueWeR7Y0mU49RDQIpX470wc8Kk5F5aIrLNentMhtealLSmIHdjW1DsvbBRP1jXm63YRKVhpnSGtHpyYrGs8Vz6ruwVcZWI16+pW7q8r5MC+50fcN3XJPe5XCGRYsaZUGO+aCYFtImVil2GnWde2BLR0N06deV7THcEr4IGsggZpaoweGGXlNEpuiX1X54aN2Z5nXb2YS7cg13r95dI+mnJE8hZbnyjUdWxKatY1PJjNqnWfdXUqPJglkIVTTJOT3uLpMpyowBbpiews/ILgFe2ivsomo5dhHfsbFxa1W3EhtxqagtK5q3X4WiNd2pR1dav/1Erb5au3dz91T6zDMtAoll3Slf2kP/ZZ11haZmVbIrgFkAyHdvhBDt3uB9vHHD3z92n1YaRj1hXOMOY1uQhekVK6d7e/2rtySSdJuUjQRulc+zeztnvisq5urV1RIjLUPiOcNyPHddbVrSX7FCWsW28sHZa2T9VlZdTUyAFd/2C5/M01Dyd1e4BM4ffxru3lP9s94nlg255dhgEkF8ErMkYgu0nW7hx9XOrgpw2p62Ezd48PlQ8QyV1pHc3Vd26U2tU2RZX617jOurZF3rIcqexlvTyrLjFZVzv1xZtudgpW2Wdd3cota5DGfLd52diBq51ASYkcOPiSiPumzrs9IdsCtJdMG++a6C7DqRbYZtr0OMnCGNgwzPOaVASvQBxWb5MnxT9aL68a537qlvZQ3KvcthiT3VjXRLILEFVNt8RkXWMxBlRJ1YDI+wq/Kkx41rWiT45U9BkYcV+3txaIFzRwjSY8mCWQRToUa0Lyugy3V2A74QP7oRPphi7DyGQEr0Ab1e1SbvlFaqjLlsb6xGTV7GjW1a2KhSVSYbO805D1bcq6utWUK5K7UTwXK+NqpWpcVfPPRZ8Xus66OrV6wsC4AtlYWddYFh7fR0ZcaT0n7U83MSctgPb3yLrd5OjRM6Mu+8932yXsdcm6IoQxr8lF8IqkG379XZIn0bva1HZtQ//LVG3x+thUmp3rfi7VRDByDVm3uKP9g3KaEpJ1tVO0wpDywYnZV5p1tZP7Y6HUJ6DHuWZd7XT5ZqM0detkuTyweLnjrGt44GqnpmeTDL7njoj75p1/se1zgEySaeNdE511dStaUJvIgDYZyLoi0xG8IqVU1FiPLzGMgBR2sQ40qje6nAulnWTPLZRK+xjCd7LLdDxs28bEWmVd3Vq3VftV8MpfK1Ld1Xp/JGq2iYDOB9e3p/UDyuwD8liBazThwSyBrL8NfEjHNY92/fwDxn4nqYLxrumfdXXKiywtWVdEaDI23RIp0etPIQSvyAjVZfmWVYhzCutlsXUxVlP+53neb1QbpgTqPd26qlF5/xyR3+wDyNrDJOmyqhMTRGrW1a3OY2One1dv6GCbdXWr2zcxZsq1ybxq1tWtwNooz83JiTvrGkuwZ7UM/X83WC7/9di/tGn9aH9vfu0u8N1u5HzPtwXwSnt0PXaKrCtA8ArE1LCiQCoGWneFTbVagxV9AiIzbLr+dm1qQ9bVnfpiw3bsadHSQLtkXScN+EqkRaGme77bK+6sq2tNIp1/iBx5vG5Uh/izrk7V17cp6xoeuNopKqyV0a//NeK+7w65Pq7XRmrr2HejzN/Q2fXzB3Vc5+n2IP27DCcyqP3wox0kE1Fh2ALVhpOKzKuPPPjgg/Ljj5ElbUeMGCF//OMfI+6bN2+ePPvss7JhwwbZYYcdZOLEiRJoy8SccM0oaZDa8uhZ2fziWsnJtS7IU98OhZxi6fKTfXCydN/kZ12NbEMqBlgHZEUrknvsnz/6g+afH/zx4MRkXaNoGcx6lnUNs/LggZJvEyPU2PREjkUD12jCg1kCWVhxG/i2R7fh9hrvmspT5CSry7AXahuzZac/zoi67LP7t0/Y65J1BTYhePWR119/XSorK81gNKRfv34Rj/nss89k3333lUMPPVSGDRsmF1xwgbz44otmMJsKdj3qdrGa7WTN6CzJXxUjoLOZHzSV1KwtaJcvp5l1dWn5biLBWu8DRc26tsXKHayfn1MWaFvW1caDs3cTGWMzaPUdl9OCxEh8N5Ta5/pzV7sfz2pn3Xati6mFHw+xsq6x7Ndvrlzy3XGWy28f/Xyb1o/MU5RbJ+8s3zKux+7Xa07CtwfpL1pQm8iANpnIusIvCF59ZvTo0XLuuedaLj///PPl8MMPl2eeecb8/YgjjpDtt99efv/738vee+8t6ax+eLWIRcGmpjUxxqQWp9Y8rIHCBqkbbLPN04NJz7raCdQHxPB+k8ysq1s5vatEeku7qJtXLHVDrLe92zeJed2VY/V7YP1d6P/vjbZZV6ea8ja/x6CLrGt44GrnmI5fyhcLB0Xcx4kUvESQm1pdhtsz6+qUF1lasq7+FmhbGZO4XwObELz6zDfffCOXXHKJdO/eXfbZZx8zMA1ZtmyZfP3113Ldddc13zdmzBiza/Err7yS9sGrW3m9Ky2XBYOxAza/hb1GVbbMPyb6ss7fJOYrrVlXt5p61Ip1eSmRwOoEFMOKQ311tqystsmOthjr2irr6lKgISDzjrQe4Dv4xXLXWVc7/d5YK0anyNcNrC93nXUN99D+j9kuv3TW5t4kbgLXaMKDWQJZp5WGkeggN9kyrctwOmiPrsdu0cbCTwhefSQrK0u6dOkiXbt2lTlz5shf//pX+ctf/mL+q3755Rfz30GDIjMQgwcPbl4WTW1trXkLKStL0PwcaaixKSi5fayDX6vxrm3NuiZCoEGkaJn4SnZeo0jfKttiWe2hQ0mNPDp3F9dZV7c0k/nrCdaFmQa+URcj6+pMy2A2EW6cd7CUFtQk/HUyAW25/501cFrcj71j7n4J3RakV1ALH9NCiW6KJTp9DZgIXn3kvvvuixjjqmNbJ0+eLEceeaSMHDlSqqs3jSkrLo484SwpKZGlS5darvfmm2+OyNbCG7XLiyyX5faskiYjkJCsayJUd9ObXcdP912K3SrIrxMZaJezFSlfUOo66+pW+YbW0+MUFNfEnXV1q2B5QFaOiQxQe3xj3x03POtqZ/HBXVxvV6ysq50Pt36l1X2XrtwuZtY1U6VqW66VhtHaxcPeSekgly7DyfGP3lp/IfrUaV/Vxlcpvi3IusJvCF59pGVxpmOPPVZOO+00s0iTBq8dOmzKyGiV4b59+zY/bv369WYAa+WKK66Qiy66KCLz2vK1kmH7398l0sW6IFN9B8N3WddEqF1vPeesH8c1VG0ZO0DKWp38CYN6FJdLj1HW3V4Xru3sOuvqVHV5fvPPbmtIh48fjVfLYDYRKre0v4AQK+vq1G09Nk9L8VUcsXkmnVj5pS1PlWJNmRTkrmxwdyEPqW1cXk67BLSIpONdEz7m1V+nyO2K4NXHGhsbzVtDw6ZupFtttZU5Jc7s2bPNYDZEfz/uOOsqnXl5eeYtlTV2rReptQgL6oIiecnPDCaCWfioPvoVVlMbChglSm5hvcgA6z+WTTXJb2YamoLSp9MGy+ULqrt6lnWN0CTS2MV6X2SvzHWddbVT1df98d+WrOvfd/1/UtYU2bW7JFjtOusa7oe6aslv8bZrjMz+k5UObTm8V95UIIVB62C9qinVZiNPj0JN3mVd2x7Qug1qM+niIFJHZp8J+MjatWtl/vz5Mnbs2Ob77rjjjubuw0rHw+rPDz30kDmdTjAYlP/973+yYMECM0uL1gq6Wo+nrK22CRK1k06+v0o15XazDwoalhTJhuHWwW2nWcnP6dZVxTppsi8EZJd1dWvZhtJNAXeSZa/OEQkm/+JD6c9BWbF7F8+zrhq4RtMymHVDA9do8nXgdlggy4kVUnW8azIlIrBtry7DcM9pUEv76oD+aU/0n3f/5S7aDcGrj4o1XXjhhebPW2yxhVmwadasWfLwww+bv4dMmTJF9tprLxk3bpwMHTrUDF61oJNWHYZ3cn6L4wS8c+pke5tym2Tt5qGErRQucdfZtU1BYFWW1FdZv25BnzrXWVe3ajbki12n4YBd5rsNh0N9lxgXSpbnuMq6auBqJ9goktciQV3bUTyxZ8EK2XOrTVN6RWc9ZjwenFgBbZcpGVtYo+sxUg3Bq0907NhRpk+fLl9++aUZtB599NGyww47mNnWcKHA9s033zTHvl511VWyzTbbSCqo7iFpw9iqQqz+rDcsK5SGpTbdSwu9D3o16+pahwap2rKhHbKu1koTVOBFs65u5XRofZLXUGOfvY/IurpUPLv1c72YU1cD12jCg9lKh1nX8MDVzrpGQ9Y1VjT/vkVOh5hZV7Qd0+SkZ5fh9ghs2wNdhpOHi4POBAzDvCVSotefSghefWb8+PHmzY4WbtLgNp2UzrMO6Kq7BEUWWAdCG7bxV/deO8HagAStxu5qMNShKSFZV7eKO9oHErV1LpsQm4xrLNW1ubKw1roYk91Y11hZV6ey8zdnnhuqcjzPukYLXFUgjo80VtY1lrKBItkrvM+8aODa0i/1mwPZeEpeje6/2OOtQjpJp2JNfvTFxsHmzcqVvaYmdXsAZBaCV6S0it0qk34Qa9Y1Eeo7WwcxJd2s55pVrsP3Du4D/4qwCrteakvWdVzfRQnJvEbLuobLm1kkdmV0ajsn5oppQ5FI3tqgZ1nX8MDVynmHvyHL6jtF3Nc7Z33cWVc7Cxrs+yz3zConcE0xmTJNjl/Hu7aHm5Yf6HlgS9YVvqYXlBM9kix1RqolHMEr0lanYutiTbnZjSKbeyq2siaeMa8+UVObI1l9rN9r0+r8hGRd7fTruc52+aJferjOurq1oqpY+tpkZX/d0FMSoSlbJKfMulhWfRdnWdfwwNVK49aVll1+zXW/37bxpi1FBLM2wWu0rKsTZFyB5HQZTqXAFt4K9pzLLoWvEbwCLSz/qYdIiZEWX5p6naam2Ca7aiQ/61qQXS/Dt1piuXxFeXFCsq521lcXSpeeZZbLyyrybbOuro0pE+vR0e7Hydrp0alMZGLke616sVfcWVc7o/IXyw911leF+mSVu866Amh/dt2FExnYdstLTI8nwAuMeU2uVDoPRwobcvudImlwbtrpx4DIj9Yn52vHN4gUWPftsBvvmmzjhiy0XT5nTfeEZF3tlNXmS2FuveeZV826urXhl9bja4O9rDPdLbOulsZYB8vBL0rEaHGoBBrjz7o6VThxefPPZTM2B7JeWtHQ0byF2z6PsasA7P241rpXzF69f03Y7kuluV29QtYVqYDgFe0ub0NANg6O3q2yy48NUlxlHQym1LXYbEMaujakxHiGldUdpFNRleeZV826upUVbJLupe7nd7XLujrVtNz5c9qqZTDrOutqY+nKTiJ97SYLss+6OjWjtl/zz11ssrJqwqCfXG0XMkt7FGtivGv7+WDZ0KQGtEBUzPOaVASvSGm9nrEuk1NzZnzZMa+YWVe36oJiOSoyaEj5Sutsb07HWkmmRYu7JmS9mnV1q6ouV2avtR5H26mgyrOsa7jGDg1S0frcqVnhghxXWVc7VX2a2qVRP2HUV7KqLnLbuufaB8MhLTOuLR1ZtMp2+Uc1qTe2z2/23f1GsTlUY/r1RLuSZMiE8a6J7DKc6IDWaVBL1hXwL4JXpKWqbtki/+0WddmGfdphHsnsxFSb7TNwje3ypSsiq8ImWufu5VJRm+d55lWzrm5V1uSaNytF+YnJ1HSYm5P0JHt2T/fHtpl1dSgimHV57SFW4KrIura/oU+7u0i25jLPNwUZxK7LcHsEtUBUOgdroudhZZ7XZgSvQJji4moRvUWxcV5HWbdNAhqnurbNx2ll9cYOklvgvpuu17ICTbKuyrq7bXZWk+usq1uNDUHbYky2z3U5zVCjJky+s8+uus262jl1xOet7pu6fETcWVc7x3a0X74iHQa8w7HsDdXS8wp3O27FzdYVugEvRQtqd+6xIKN2MmNdkUoIXpFwW192l+Rbd4oVIzFFVZMqf7UGoNZBaPWg+qRnXe1071guy22KGAUDCb6C2EIgINLYFPQ882qXcY2loSpHpNTmc2sMuMq62ila1vq+Gvuey23Kuh7Ya/M40kdX7iJuxApct8zJkS1zVjf//mJlN0dZ14Je811tF1JbzyvctUHld0jaj3dNxSly2jvr6sTaFaXy2orRUZcdOvq7tCzUBKQSgle0q46/hZVQbaHkB/vgrGIriwkyfcYIiuQvtA5manpZ74O2ZF3dystqw9jdBNii0+bAJxq7sa6xsq5uFXVqHShWrCmML+vqUH5Y8eaqPuJZ1jXc3MoesvsWvyYkcG1pYtFqP9YoQxpoLCmQwuvi+5JVXRPfeG2k1njXRHvtu9FJDWiTgaxr2+n1/kRf809yTsHXCF6RmurqpMN3m6f3aKlq381VTP2srqMhwWrrIMrI0tbK2+5zmnV1SzOyWwxcYbl8bVUb5jx1OQWOXTEmt5lXM+vqUIeuYdsxt9STrGu4tdt7f5EjHv/sb51ZmtWG4cLv1dgH+3vlV5J1RcIUXhe76z4BbubRrKsXAa3ToJasKxA/glekn9xc6f7RyqiLmkoKpOu31k9dea2kBKO0QZYut+5PmltYl/Ss66J19gV/SgrcTcHi1oqyEttxtG4zr9GyruHqZ5WKWJz/BBM0i8dD+z9mu/zrqsG2WVc3geufV4xtdd+pnT+xzbo6QXdhpEKAK/+SpKLLcOrwIqhFiqBgU1IRvAL/Z/X2JRJ8LfruWDu2QaTArpOj90WXNmVdnQtkNUl9rfdf7baMg62vyZa1NdZdmbt2rnCVdXW9PQ1ZEnS5f93K3eD+uW3Jul4558hW9x3VPzEnT4+v2zxu9pYeX7rOuiI9ijWlu8aCLPnXH4+I67Gn3f+ypKpM6TLsJuvqVVDbXplXugwjFRG8IqFGXXRXAsI6f8lfli1NNt+kgI8G9nXrUi51DdmeZ15jZV3t5OY3SFmVTcXfTu6yrm717FgmdsVx11YU2WddXcjbK0bxrUWdXGddo/nvos0nTyO7rPAk6xpu2rKhspPFtBTqhq1S90QecCOeIDeVA1y4F9yYLUOfOyvqsl+Pf5BdmwL0PC/R53p+OpdsbwSvaDd9X7MesyqN6fEt7TPNfm7EBYe6r4abCOW11kFkaX6166yrW12KK2VBWfTu0fku54zVrKtbi6N01S4srk1o1nVjeYFkd4rsct2wPt911jVcXX22fLOib/SF/SUhjuj/vXxdGZnJGVs0L+L3gwb9mJgXz1D77n6jZEKxpkwIcI++7y1Jd+1VZdiPogW1XgW0ZF2RqghekXoMm8A2ENToRFJBef9c6WLRe3P13jEGRxrJnQNxY1W+efOaZl3d0Klz6pvcB6G2WVeHqsrzmn/OSUTWNYqWwawbGrha2abHMjll4V6Wy7vnldtmXe0C12jCg9mWgSyATXJXV8mrx+1muTsOe36657uKLsOJz7r6KaCFS4x5TSqCV2SU4Fq7Srvuu5omlc38oibvYzpbdTEq8waChuusqxtLv+tluzxrQKVnWddwxTOsg/umHPdZVzuNqwrkrDd+Z7m885CweXbiDFxj+Xz+oFb3HbZl9KDUDbKuSJXxrn6T7MAW/uG02zFZV6QygldANTVKjzcXRd0XRsdi6W4zTeb8o9yP9/Ra7pIY3ZC7uJ8mx43gys1ZyagGOS/U1Ca9a6SxPrknnR0PsZ8Dp7IuMV3H+7+lPRSiD95d9/sK26yrU6/O2ab559KSKkdZV6SfTCjWlGpSJbBtjy7DySrU5EXW1SmytEmi1+gTXQOSeV6bEbz61E8//SSffvqp7LDDDjJq1KiIZatWrZIvvvhCKioqZMiQITJ+/HjxowOHXSYWo+nSRnWfDtLzC3djL5Mtu1qkYno3y+Uddlud1O0p3GKj+EljTZYsWtzVcnkgu8lV1tXO6jLrCsyxaNbVPnCNbuFBAZGlkZWai/uUu866huvZpW2f6dUjX23T8wF4G9j2eHgpuzTNkHVFqiN49aGNGzfK4YcfLgsXLpSbbropInh98skn5eyzz5addtpJunfvLu+9954MHz5cpk6dKkVF1lVQfafB/dQfqaKuJEtEbymgpkeT1MztYrk8p6+7rrZu1c/sKGttlnffdZmrrKtbJd+1zo6Wb1/T5qyrnYK3S6RleFq2V2I+h/LwYNZ62lfXgetZA1tXLp5f293dCwFpWKwpnvGuyRYoq5JVx1v3LOr+3Pqkbk86SUbWFckTMAzzlujXwCZ8e3zo97//vZx44oly3333tVp28cUXy/nnny8333yz+fuKFStkwIAB8uyzz8oZZ5whaS+o4z0tAsJAjLGgPqpgHGwQya2I3hBV9ApK6VfW3W03jolRzMljTR3rpbYi19MxrW3JutaVGLLke+txrQGXWVen3GZb25J1Lflg8wWq9Vs3ucu62ijoWSnfLEtOf4lBeasiAlmyrkgVfhzv2h68DmwzqcswAPcIXn3moYceksWLF8szzzwTNXg1DEN69NicGuncubPk5cUYV4hNgW22zQlHXWpkgqt7iuQuy/U86+pWtw/tt2Xd1u6yrm51nGsdnG3s7V3WNZyxVxvmwbHJutrJqTSk+5fJrThduyCyq3GgV43rrGtLBK5AeiFj68+s67w/XdRur53WqDacVASvPjJr1iy5+uqrzbGu2dnRP5pHH31ULr30Ulm7dq1069ZNXnnlFZkwYYJMnjzZcr21tbXmLaSszPl0IGlNuzAHLQLb7CwJVNnN4+l+zKLXen5hP+3MmpHZrrKubuWWG9LTotBV2Rbus65urNupTqQuudmS0sJqaUrylEYN+QGp6GX3OTfaZl3jDVyVsTws89zGsa6ITyq05RRrSg/aZTjpge0USSqyrkBqInj1ierqajnuuOPk1ltvNYswWenSpYsUFhbK9OnTpWfPnjJ//nzZfvvtJSvL+sRcuxhfd911knTpPq61qUkKf7YuclQ3zj8TrTfkB6Xjr9EzrCt6JCbraqWyZ1Cy3rHOrtZb10xynXW10/Nt+3lsqrp5n3Vd/Zn9dD6xsq5ubNjSkKzqYMR9jQVt70r/76Na9xAJ91sdY1u90m5tOTJuvGuyNXUqkq5/sV6+5obUmL89FrKuaUr/LCd6ZBpDXpsRvPrEP/7xD/MqekNDg5ldVXqF/csvvzS7EJ9wwglmIadDDz1ULr/8cvOmVq9eLSNGjDCzsH/+85+jrvuKK66Qiy7a3FVEX6dfv37S/mNX01ggIB2/Xmm5uGxblxGjy6yrleouQSmdY718/Y7us65uBBpFCqx3m9QleSre6s4Bc5usGDZZV7fy1unFhsj7smviy7o61TKYjTfrGq9HVu3R6r69O86O+H3yFjbzUKHNbfmBwy+XeKYZru/h/nPOpGJNjHdtH13/ku1pYEvWFUhdBK8+MWzYMNl///3l8883n8jV19ebFYdnzJhhBq86fU4ogA3RoHXHHXeUTz75xDJ41TGxaTEuNmhzop1CVdiMglwp/jl6MYtARY3YxWe/ndHHVdbVjZLFDVKyOMtVRjIRSufXS+l86+VlA+M5RXeWdbWzcWydyIbC5t+LO1YlLOsaHszmVLrLutrpMMy6uEptG7Ku0by/YSvLQBb2EtmW56wsT9sAF/7pMpwKgW2ikHVNX1QbTi6CV5846qijzFu4l19+WY455hi55JJLzN+1qrD6/vvvZeutt24OcDWoPeSQQ9phq1OEXaGmFOreXDukq/T9IHoo0VCY3PGchd8ukc1hW2tlO/ZP4tZoxtaQ0t+sqzCv28ld1tWJ8rBA1m3mVbOusTLajd7W67JVV58teQPLXWVio2VdWyLrmlriCXCNPE4r4LzLcLID27XnJuwlASQYf2VSSO/eveXcc8+Vs846ywxgterwSy+9ZGZjw7uSIX6GZnMLomcyAnX1Sc3oatbVjWBto+TWWgfgDb3aNqWLY4GAlHyx2HJx5eGbLsI4zbq6lVXbKEP/GX1ZRb8c91lXC50/zZUqscmuOk+ex+yK3VDgvhu+XdY1mpbBLBDSWGp3SctesCa5U4ClikwY75pserFzy39URF0254LEFGEk65rm9M9zos8XU6eDYcIRvPqYVhDeZpttIu6799575bDDDpNp06aZxZomTpxoZmg7dbKeb6096DgrybE5vBpTI9vpl27KmnV1I2dFmZSusK5IWr1v8otK9XploeWyFYcMcHUi4kZWVb2U/mwdFFfv5P0A27Xj7YPwvHXuuzFbqS8UyV8ZGdzW9DDiyrra2bL7Kvn7kgMtl3fMtT/p/te4f8XcBmSOpvwkdilwifGuqZV1dSNaUJuogBaAOwSvPnbXXXdFvX+//fYzbynNqjpyCo1dtZUC76OxY5F0+9o6i1bbo8DdfLouGcVF0mPamqjLavqXus66urFmu5K4iiRFy7q61WOaNsebj5uasG7LXmddI4LZYeK5WR8Ojfh9l/2/9/5FkPGyFq2Iax80DHXZ3SEDpdp412RI5YCWeV2RjghekTqyLAoP1funIENMTUb07sFN/spEZ62vkML10btVJZt23y74NXpQq2oGdXGVdXWrtlSkww+bg9SKUXWeZF1byl+3OWBtynGfdbVTu32l1FZF7zafk9Nom3WNN3BVn7y9TUQgS9Y1iT1gINm/Lo25FwhwM4PbnjotOel23J5dhpHEhEXCuw37PymSLHyjkN40w9tk84V3V4g3uZoMyfvZOsNQPzDJZX9r69qUYbXKurrR0KNUsqusL14YWQFXWVcnwgPZtmVdoytYZ39hY+NAd824Bq5WsuYU2U9Zt4918BoLgStSNcBtHJXcQnTpPt7Vb12GExXUzj3Vel5zAM4RvCJzBQMSaLI4Ra+t936eWrsg2q3qGsmZbV0cSTqVusq6umK1L+OZ6igBgpU2GdHsoOusq5XOc+17AKwV7zVliRQvtn7ddcO9b+Lz14nMe2FzdnXwMb/aZl2BtGAYkve99Xj9cLXbOB+77wfp3mXYq6yrEw0leTL4v62rz887KvHzE9NlOIn09CeQhNeAieAVnjtwxJXWXXxVY4p/A+3em5+6duTnmcGtpY5F7rKubjTE6tpd5Crr6kZN3+SPVSrrny2dZto9wnCVdbVT0TtbcsOGNNcVx591tQtcWwoPZCVGJ4C5V11o/wBkZKXhdBNPkJuqAS680TKgTUYwC6QLglcklaHdTS3mXdVJnlMiKLSj7y9al1rNStpla5Mdz9fXWxc7KU5ycGcYElhjM8FpSXzzisaddbXRmBOQgjXWAWNtaZarrKudwlVNrrOuToQHstFnC26bjr/US8dfrJcv39n7SsrIXPEWa0rlANfoleQhIUmUjl2Go2Vd4+V1dpasa3Lp+WvMc1gPXgObELwiNdhla60qF6eKmlrvu9tq1tWN7Gz7bK2bbYmZdbWRk2OzPe4yr25lVzVK1x82B7ZrRuXGnXV1o+Sn1gF99cCOcWddreRvaJL8l61PitZtafE8m+sL8SDrCsTP6NHFfiiGx8Mw6DLsP2RngegIXgGveFzESDVt2Gi7PFjg4spsvctKuzo3r938vG4uIri9kpiTLdlLrUeRNnUsdpV1daLrD5uzu015waRkXQsWbGj+uXKI90VASmaXScns6MtW7NHRNusKIImSGNjCH+LNzpJ1bQdUG04qgldkplhjcnOy3RcmSpJAbq4YFsFkousGRGUX2LrNurpQO7h7QrKudoK13h4T0bKu4Yz8XClcal1cpaJ3iWXW1Y1gTZ30fiuywvCyCfHv52lvXOrqdeEe0+R4KNW66/k8sKXLsHfIziITEbzCUwcOu8z+AXZBYSrwSeBqJ6D7uK4uqRniVNlfeb9Yj5MrH9vX89crWLRRChZZL984yvkctbHUdc6Xjr9F//xrumTbZl2dCA9mqwZ3cvRcADG6DGdIm5yuVYbbC1nXdkLmNalSPJJASgkEJNAQPYNlFORa1Fv9v6dWu6xymyxVrbvzhBh2Y0j1vRUWuMq6upKX55sTG6uscUjARebVddY1KyjFM5dZLq4e3kO81lSUJ8XznE9LpFlXu8DVSu7aaslt0dO6bFhxXFlXO7ECV7Ku6S/ZlYZTvViTHxkdrNuOQIX93zC4L9QEwDmCV6REhWKjsPUfA8s5WkPLazweh5eAwM6orTVvljI4S2rUWJ8wBXI6eJp1tZWVJQW/rmn+tXpo17izrm4Eo5woGi7npY2lZG5YCeIEIHAF0jewdRPUZkKX4fby7kdXtfcmZC4yr0lF8Iq0FKhvjD0fq981aS7aJ92dvB7P2gZmRjZWhWYnHB4nbgLZaFlXJwINmy8sGC6zrrbrr3NXEZruwkAKdRnOwGxtJnUZBjIFwSsyj920OylQmCOg0+B4vZ1us65+ytYahuTNshlg6qartU0F5fo+nSS72tugPlrWNUJ5pQTLK6Mv69zH1WvaBa6Bqtr0G7cOOJECfxNSLbBNZ3QZzlB6KpTojnI+Ot1qb5yFwFPGGusqqYFuqXNFuZWNZbHnR/U86+oysE33rKurJwaspwjK8n6f5ax2Ppa1TQoLJH++9XevqcT9ZPet1MeXpaXLMIBwq3axPwfo9uXmqcDgDF2GkUkIXpEUga6dLa9gN3Ysit0F2MeaytoQqASTOKZVA2y/ZBG0eJdFwG80uOjC6vZ96fPsCmp1SMD4rPUbJbjeYlnH6FPcmKwyrjEYedkSqN0cuBt5Oe6zrhEPCEjh3M1dqMNVDXPXnRremNDhFNfPDfbp5euPgWJN6Wv1+I6eBrbJ7jJM1jVzBQzDvCX6NbAJwSt8LVhdm77jWGzHWibx/bkJFhPIKqh1v8KA++dVWs+lKtLJ+6zrhrL4g9kQh9WqwwPZNu0bG2RdU1fT0uXOn1Q6JBGbknFSabxrqge26YSsKzINwSvSTl13+0q0ucudzWfZLrwuNuU2ILQZ82m73KqLblsCJruxyskuzpWXKzkLVzf/Wj+gW3zPW7/RfTAb67OwyLpaCVTW+qdXAFJWsFcPkfWxL9g0dnJeIRyZ02U4EYFt98+surgAHqPacFIRvCKjBOuapKFL9JOo7GUtJsFMJJfBVkADGD8VSbIaIxu0eX9ed33RIMtunW6CZYfPCQ9knWZC43sBl2N93TKaRMJ764cHzsmcvglpIysVA1y66aWsrBpD1m7XOqjtMnNDWnUZJuuKTETw6lPr1q2TefPmSb9+/aRHjx6tljc2Nsovv/wiXbp0kW7d4sz6tOM4q1Q+3W1ancSgtg0CiQiavNbQ6C6Qt8u6xmIX7LsJxPJiVC2usp+WxlP63uxeL6/YXdbVrmhXjCz+1F9uc7ZuwEGAm67oMpwc0QLaRAa1ALxH8OpDDQ0NcvDBB8sXX3wht912m1xyySURy5988knzvqKiTcVkdtttN3nooYekoMC/wUvTshWWywLLbJ44qK/4mgY/WQF/X7VPdtbOqfDANNndf60+o0RkF/VzsPosKiq9//yCQQls3Lxeo7Qo/qyr3WfVWOc+sAfaojxzg9tUlsguw15pS5aWrCvMGSICCT7nczkLRToiePWhv/zlL7LFFluYmdWW/vvf/8rvfvc7ef755+Woo44y73v22Wdl/fr1vg5e3Qho19OFrSPbQEn0bFKzGGNe253ZANk0Qi4COLdZ18bena03o8ymCq+bCsvRsq5hDA2aGqIHToFAEoNarwtGxaLVjl2MZ3XafTw8kE3UeyTrmtqVhoF06TLshWR2OwYQP4JXn3nnnXfkhRdekJkzZ8rgwYNbLb/qqqvkxBNPbA5c1aRJk5K8lf7V1KOTZJdbd4lsCpsmJKHcZl1jjd/0g43lSX05c5yvX2jAWFvnPNPoNntaVBj5u920PuFsxhwbne0rGAc2VnjfdRuAJboMp45oAW3pb0kcKvJ/GOvqMxRsSiqCVx9ZtWqVnHbaaWZWtaSk9QnmkiVLZM6cOXLjjTdKeXm5LFq0SPr37y/FxTEykWie0zLLYl7LQE2977vXBnK97ZLpOusaK2iyCpxsMq9m1tUNu8/MruKxFacZSTeBrJtgNKQgf/PPttP4uBOorLHeB3bdhTXruuhuz7cHKVBpOE01rosvw5bVqTTh24LkZ13jVbiyQeo7tP47lFPh4u8PgLgQvPqEYRgyefJkOf3002WXXXaJ+phlyzZ1of3kk0/krLPOkq5du5pFnY477jh55JFHJNciuKmtrTVvIWVl3k8Vc0DJaZu6+UZh+L06rp0NZRIsbJH9CtNUnfwrri0Funf1NkBKhPy8TTe7OU29zLrqmFW7YL/OPhCLyu441u206xbt5sJIy6xry20JD2Ttguo4s65m4GpFv9vhr+eHYyoDJaMthzONcUx/lckBbiqMd02EaAGtV0EtWVc/MpLQa87nvfKSiODVJx5++GGZPXu2XHfddfL11183F27SbOt3330no0ePlqz/O5F///335eeff5ZOnTrJb7/9JuPHj5ebb75Zrrnmmqjr1mW6Xoh11tUFq8DVKogPMZqiZ38TlnW1C3K8FON9t9IxLJBa72IcUVsy5Vb7MxEXWjSQrnFY3bcNGnpEnihnLwqbxscrLQJZsq7JkdFteQoXa4oV4AZ7ZGaAl+o06+oUWVqg7QhefaK+vl66d+8u5557bvN9lZWV8uKLL5pdhd98800ZMGCAef/JJ59sBq5qyJAhZmXiDz74wDJ4veKKK+Siiy6KuFqvU/Ckane0ppLULUylhZXs6tg2JesELRiQrI0WWePaJHd3qqmVgFWxMTcZUreVgrP14pBNptcqAHWbHW6ZiY6XTYDdMnA17+u/eSqtrIpad1lXGwSuyZOKbTns1e09Oq5dlL8subUGUlGyuwx7xUlAS9bVpxjzmlQErz6hQWt44Kq0W/AFF1zQPFWO/r7ddtvJ8uXLIx63YsUKc75XK3l5eeYt3QUsKtWmjKwsCXaM3r3MSObcoXa04JVV0asKj8dgajCZbXOhot75Ve82/WEKH9Nq0S3Xq0C6qWPktDbBMg8+/yZDGgujZ5yz7YJX+EamtOWpMt41mWp6F6dcgJupXYa9QIYWsEbwmoLdxo455hizUNM222wjb731ltmNWG+wL9Zkn3HzN7dT4SSLkR0U6djBeddst91po42hbUsQ7fQYCA9kY0wB5EXWNby3QXBDZdxZ13hkL1njj27naDOmyclsqRjgZlKX4bYi65rCUyB69hpQBK8+tu2220rPnj0j7pswYYK8+uqrct9995lViXU6nS+++EK23377dtvOA0pPt84wGUbKFnIyA7KeNleO5y/x7sVcdj01ulgHLIFaj/+4upxmKFCRvKxx1SDtTr+pS300hT8sdb5SmyIMRqn9nMKBdWVtzrqGqxiorxf9NQuX13j+R69lgadAdWTGeerPt7haL4Dkq+yVI5W9WleZ7zJjXcp/HKnaZRiAcwSvPvbuu+9GvX/PPfc0byktEPDX/J0OBTZWSqBzlCAp1nQpSRrT2licL2JxET57TYUvruA1dWld+Ta4cn3CxooGGwyp2ap39FX+slK8Vt23WERvURTOjZHtdKgpR6Siv3WGtMOCandZ1xaMglzLQBaZJanT5KRwsSYvxrsm2trto0+b1pagNp27DLdH1hU+p9P9uZ3yz8lruKypkxOjwKXOeKKV7PPzU6OnFcEr/CcrS4y10YOYQIciCa62mAakk8/nu21osO6CWeeTOeE8HkfqNOva1GPzBYHg2uRMAxJsaJK6QZuLGrWUO2+Vq6yrlZyKBqnv3Xqi+5CsqnqbrKtzpT9EnoA2FsfXBd1uWh1F1hXpyI/jXf0U1KZDljYVTfvfpe29CUghTU1N8uyzz8rdd98ts2bNkmAwKHvvvbfcddddZqHXEJ3VRIsAPvbYY1JTUyMjRoyQhx56SHbaaSfxM4JXpIcOhRKojz720AgExLDouhzwQddlY6P9GKSAH8YcauCtNyul1l1d3WjKz5GmPtGv3GevrXCVdXXFEKkb1D3qopx1VfZZVxdW7KCB5ebgss8HZXFlXZ3IKvdJ8S8ASe0ynK4BLV2G0e58Vm145cqVMnXqVHnwwQfNqTY3bNhgzlRy4IEHyk8//STZ2ZvCP52l5IUXXpBPP/1UtthiC7nyyivloIMOkrlz50q3btYX9dsbwSsylh8C11gCRYUpkXXVbtRRZTmc+zWGtSN1f1jvk+JFyclgN3TIloYOkZnJgkVlcWVdnVi61+bXKJ3f1Oasa0uGxxcdAGQeq27H6ag9ugyTdYVTvXr1kn//+9/Nv+tsJddff72MHTvWDF614Kt2J77//vvNgFV/V7fccouZhX3iiSeaZzrxI4JXtMkBnc6wngdSg0O3c276gO+n3snOkkC5RfZPx7y2s4a+XW2XBy0qQGvW1Y3CVY3SmB/9WAxWuKgI7PAianX/sGDWxZjiTVnX6Gq66C36e+v2nffHqZEfOXa7Za+GN7/9m+evCWQSv4x3TYTKXvZ/9/PjKG0ApJQUqDa8aNGi5kBW/fzzz2ZGdrfddmt+jE7FtsMOO5iFYP2M4BXtI9HdKxLIWL02+v2V9t0xgz2T1AXDMCR76Vrnjd//dSNJhqzKyClyjJzEFe/Krm4SI8vmZKrBedbVTl2HoGeZ11gGvlGV8MC15edj1T0f7Sttp8lJYrGmdB3v6lWXYa/UdPIuqE1ml2GyrvCDsrIyx/N/b9y4US677DI58sgjpXfvTYUrV61aFRHMhnTv3l0WL14sfkbwCv+xGFupU+sY66IXawp2SGL3WheMhnppXLIs6rJgsYvxkR7PTRur+2hgY2K7SkUERC4yr5p1dWP9Fvpa0V+v6w82U8+4kFvWKPUxAl+rrKsbOWsiu3LbBvAOkHUF4Dbr6iaoVWRr4WtJHPPar1+/iLt13Oq1115r+bTq6mo54ogjzAD30UcfjVrcKZwWcQr4vNckwStSXrBTR5FyizGXhQVi+RUMBjzLurplNBnSuNF6rGS2l2NeXXY5qe1VIqK3KPLnLG9z1rVlEJu9zuKzNBU6zrq6oUWQVo2J3vW689wGV1lXO7kb6qTXJ5svzCzfpcjzrGug0YgZyEbLugKtDxRDmpatiLljgr0j5ykHvA5si5z/CUoZjHVFNIsXL5aSks3nZHZZVw1cDzvsMDPL+sEHH0jnzpvHp/fp06e5uNOwYcOa79fHhrKzfkXwisxUHSOrVhTfdCLxZl3darA4Qczuv6nRaU/1xVlSP66v5fKC5d5mLlfu7m23601ZV2eyakU2DohsNksXNsSVdXWi1yebA/j5hxW1OesarqGz9fqCtcxfCO8Q4GbeeNdkKlqe3l2GkULMIa+Jzrxu+qekpCQieLWiU98cfvjhsnTpUjNw1e7A4bS6cI8ePeS9995rHvdaUVEhn332mdxxxx3iZwSvaBurrgWNqTsurmntOpG1/p22JqukWIwN1tnaQKl3892aWVcXClbUiHXKOzq3Yyk3jGiSDSOiv1j/qc7X53TqmfBgtmBtk6usqxXNkCZiXGs0S3dvndXu907kcfbWV9ckZVuQOWIFuMFid/MbO8V41/btMoxIZF3RFnV1deb41l9//dWcMkezs1qcSXXo0MGcKkfnftVxsNrteMyYMbLVVlvJX/7yF3MM7OTJk339ARC8IvlStFiTUd8gRr1F8RDDJ5WJdU7bstbbGOhYKuLtrDWuWBaSUoUFnmZdc9cGZcV46zed53HFyy6zrDPNDYXejlHOWWk/N7DVFEV2WddoFu9XYhnIAolm1NVJo15MjCGrS+ZM1YLkI+uKVPPbb7+ZGVSl1YPDPf/88zJhwgTz5wsvvFAMwzCD2PXr18u4cePk/fffl2I3tViSiOAV/mE3QDwYlEBW4irSZrJV+1h3QS5ZaJ0VtM26OlS5TevxFUW/ro8r6+pG4aYie55kXmPJqq43b1YMi0DTbYElo0XBq3gy2tGyri2RdfWvI3udKdmBzB2vTICbeZLZZRjwU8GmeGgWNZRpjeWiiy4yb6mE4BUpLZCfZ1mdWDTYrbTocmk1N20SabEmT3lcHS5/Q5PUlVo3EQGH22+bdY2icqhN6ckEKV5iP66p5XjXeLKudoI2xasaOhW6y7q2kMhpiJCBUrTnTMwANxBMu/GuyZwihy7D3qHLMGCP4BUZp2ltjIyeiyrE6Zh1tVPocTEmO8G6JilZED0DvGFEtqdZVzv1hUEpXL0501vVLfbJrl3GNVZl4PCiS/Vdi1xlXcM1lLofr/3TTRe6fi7gd4ZZoyF2D4VAtr/mS81Uycy6dvky+kXX6gGlSdsGpABzupkEDx9rMaVNJiN4hWsHlJ6efntPx676udaU0SSNGzdGXZTVsaO0t+zVzrKCbZG3plq2eNJ6+cKDSz3NurYUHsh6nXV1Uj24rWo750qXn6K/97UjsglcAQeV4zMxwM3ErGvBwo0JCWjJugKxEbzCH13OfD4hsm0XX58Ua2q0Gt+g3eEs55Ltk5ysq2Y2srNdZV1daTRkwKvR98fqHTu6yrpaKVjlfFxwvPOxRv3+uOgZ4DbrSsYV7VmsKRW1ZWq0VO0yjMQGtEgBPhvzmu4IXpEa6C7huY2Td5Cseh80hrV1UjRzSfOvldtZzx3bVk0FOdLlu+hZzLou1hN9u5FdkeST78YmCVRvfk2jIDeurCuQyTZ1GU6O4HYjJG917KmvarvFLqCWqfzQZThRAS1ZVyA+BK9I6ZMOo9xq6hofBGXJLNbkcRGS1ftZd2kd+oAkVHggW7116yrEMdllLi0Empokb3W15fL6AUWeZl3NCsBW1bMbG5wf042tM9Thgay0YbwrENcxCM+kUoCbiV2G24oMbRoi85pUBK/ILMkKGtNUzvx8WXiA9fIhTzkc81prE/w1NUnBD0usF/fq4jjr6kZTXrYUrtgczFf1zEtY1jVQ2aJLdo4HTXRTk+Qsi96FurZzd8unTX/5z21/bQDtEuBW9qK7antnXZ0g6wrEj+DVp3TS4MbGRsnKypKAxXjQeB6TKOlYrClgEygYNfEX10lY1tVqbK3HUzzYZV3tDP7PesuuqoEK66ymK4GABFdEn/qiqVtip9gJD2QNF+NP45l3tVl9WBY22ypT63JccDAoHX5aE3VRxYiu7tYJoN3VdSmUDkutx95W9EnN8bDM7QrfMs/rEpwcIfnSrP0nu0RUkyZNkpycHLnjjjva9Bjf0SC75S03Z1OGyerWzprsAlefFGuKJqAXNWxuyVLTs0iqh3aNevNcUaEEq2qj3txmXa1kr6+SnLWVUW+eZF1bBqi19dFvtm/A3fFJ1hWZUKwp2eNd/UID22g3p+gyDKA9tH9kgFYeeeQRWbZsmXTq1KlNj0kLdf6o3NjuPA6Ss4YOlC5fRs+6rd6v2FXW1an8ZeVidLJ+rcDajZ5Vpm4qKZCgTcbTyPKu50KgtsG8Wb5WHIWU4tbQsOlmRS8MRRPkuiWASFYBbKpmalOly/Cbs25M6uvBe4bRZN4SKdHrTyUErz7z008/yTXXXCOfffaZbL/99q4fk+4Mu4xSsoqKuGhIklaoyaV1Y7tK97esl68f5jzr6kZTYa5IYbfm37MWr479pCJ3BUwCVXUScJh51ayrK3V1ErDKKllNJeS2W7C+TvhrdXD3WQAmijWlTJfhZAW1lb2SV62cLsMAQghefaSmpkaOP/54uf3222XAgAGuHwMbLsYophvNurphBEU6/to+wXdjv7BAdkn0jLHXAlXVkrMo+lhdozj6CaJdxjXm2Nbw8a0FcVQHtsu4RlMR1p25xDrjPXXurc7WCyDj5M9dIQPmtr5/4Qn922NzUhZZ1zS6uJfo5AQXEJsRvPrIn/70J9lmm23khBNOaNNjWqqtrTVvIWVlZYkr1mT35UpyUSknAnl2FWS9K9bkxqbxqckbo+pUTkWTlA8tsVjW6C7raiHQ0CRNPTtHXRYstxkzarW+Khdj6+obJLBu83fI6Bz9vbfiZBxfddh7yXWR3bB7LT2eKqs8zV4jObxuyzNZpo53TbQBzyyKen+qBLXJ7jIMwDmCV5949dVX5X//+5/MnDlTGsIyKk1NTc0VheN5TDQ333yzXHfdddLurAJbH49rNWpro1YhNjRLZlflN83GJmjW1amVO+iTrJ849CnxTGNRrnmzklVV7zjrGvdjwwJZV8FfeMY12ncmLFiJkICiW2Rd/c03bXkaFGtKR4noMpzIoDbegDZduwyTdU0j5vktmddkIXj1iS+++MIswNSjR4/m+zQgveKKK+See+6RJUuWxPWYaHT5RRddFHG1vl+/fpLS41r9zMeBa3DEUE+bV826ulH6S0BW7xh9ntYu35dbZl3dWHhAgfbDjbpsyL/XeBdo6lQ2VoGm1z0P9Lvh5vuRxCrT8J5VW/7S8oekpCTOHgAiMqHDKXw8aFOX4fYOaAFkLoJXn7jxxhvNW7iuXbvK5ZdfLpdcckncj4kmLy/PvKWNFO73H7AZc9vexZzKhpVKVk30bWgoTE6X7/UjDFk/okPz70Ofq0jYaxUtE1mxd/Tpenq9vtjbFwvvBtxSTo73x3l4oJzC3xckpi1/q+IJx8+ZUHQyHwcSLlpAu2av5Fxsp8swXNOLyYGmjE2MJBvBK5ACgW17yi1vlNzoyVCpLwq6yrrG69fjNweyW/y7zGXW1Zme09eLUbr5dcMF1mwQT+kFi9qwbpJ5cYxvdZpxjTPjO3Xpvc7Wi4zyVuWTaRPcMt41dRgdi6XLzNbt7trtOkoqo8sw4B7Bq49lZ2dLMMZ8jPE8xkuuizX5nI5t9aNNxZqiLQh6enKmWVensmobzZu1PMdZV0vda+SXi6wDu8EPOc+6OhWoqBbJb/GeamrblnVtKTyQtZqj1S3mdkU7BrepFuCmmmSNd/Wqy3BbpWNACyA+BK8+tmLFCk8e095SduyqRTfeZF61dyPYp6flsmRdXqjokyddvo++rMF5MtRWj65lUnmVxcIZBY6zro6EB7NOp66x6yauWXir9SUgCCXrCr8EuPvnHJ+UbUH6aUtAm8wuw2Rd0xAFm5KK4BW+FLAaB5gK1SitsqLtPF6hrn/0KWaSqXClddXf9SO8zTSO7bpYZEL0savT/zXW09dKWsVsDXibGu2LRkVD1hUp4u365xw9nmA3vbsMtxUZWiD9ELwi5QQs5r006ut926U5aDOFSlNFRVKyrlZy1lWbNys1vaKP/7TLujqVv3iDDG/R9ffnM7vFlXV16tVvR4tsF/1Y6TldvOWky3CIy7HPhmZqw7K1gZZdnIE05DTYVfsFj5F0mt/Vz1Pk+FG0gBZoaw9DI8EFmwwKNjUjeEX6a7RpUNq5SJJmka2CcVM7d1E2sgKSt6oy6rKG0nzPsq7RDH9odfPPP/+12HnW1aGSrpWy9G/Wx0PfzTOUtDnragaaFgJWY11tuhlHW58RNh43UGjdfZouw8g07zS90K5BbapK5nhXL7Ku8QpUW/fmMqx6s7hEl2Gg7Qhe4YxV90OfjwO1ZBUQ+OAKVyA7Wytytbq/afhA6yetsygL7LFVO1iPI8ot9zbL3dC5SIZMif55VFzjIuvqQs2sjvLr7za/56H/XJaQrKtl4NoGgWKbzHmqfm+BJAa1isA2MwUaGpMS1CLFMeY1qQhekViBgGXFXLuMo11mqj2191ysdrIWr4zxiM6Os65OdZ5tHbA15XhbaKh8YIHIExYZxYsXO866OvHr73o3/zz0gYWOnuv1sd2W9ZF1BVI7W0uX4cRlXb0Oasm6At4geIX/5OZYZqCMKuuxme3K40ytmXX1UFOfbpJdVpvwrKuV7PJa11lXpzTo/vLu7aMv3LPBVdbVSt8P6qRmy15Rl+XPnO9Z1tVthWvbrCuAhGZrJ2zvsGuIj6Vrl2GvkanNUJrYCCQ4uZHC01F6jeAVqaOpybIIjQa1Vhlew27Ma5JYFWWyHe+aBEZ20LxFE6hPUpfSWb+J5SfUebh11tUhIyDSY1r0Jq96oniqrjRb6vbcIuqy4ndne/Y6gW5dWt1nrNg8VhhA+3lrxnW2y9MpuM2krKsbZF0B7xC8Iq0ZtbXOp7RJIqtpf7zMvGrW1amyof7I2AW/+bn556Yx0QPZtnZ1zl/fKPmPWr/f5TtZZ12d6vBrmRgD+0RdFli2ypOsa6Bn2Oddad1TYeqiux2tF4C3CG6BNGFmRROcKCHz2ozgFXE7sMfZ0bs2ancJi2DL13Oy+qAok1U21mocY7BPL8na4Gx8phWrjKudjjPtJ3Kv7+4w6J31m6tAVgZuK8mQu6FOBkzdfAwvPLAwrqyrU/WdC0Q6D2j+Pe/Hha6yrq0UWWSobYJaAKkR3Kq99r814dtBl2EAfkLwisQJBqznmvRx4aNULNYkWjyiwHlXWi8FVq2V3FXRg9umAT29e53cHOn4+qyoy9YfPlISacDUquafG/OzHWdd41U7cnMgm/vdPPEaWVcgPXzw9mXtFtSmsmR2GZ768y1Jey203/mhkeAxrwaZ12YEr/AVcxJmi66+gRzvpxHxjF0XZI8yvJp1day+XoIr10dd1NgnjsydBzSLHPhtSfRlHr9Wp1d+tFy27oiRjrOuVtaOss7AFq5qcp51tdBYmCXVO0UfO1v46zpHrwMgcxDUAkhXBK9ICUZNrXmLygcFmawErTLPmo2sbseum9lZkrVyg/Vyh2NeNevqVRErc33ZOZ7Og6pdsbv8b27UZZU7DRGvFKxpEiMJQ6mzy+ulrkf0ipy5K5Mz1y+A1OPnoDZZVYbJusJzZpIi0WNe/Xuum2wEr0hffv6iZ2dLsLjYeZGpZGhskk4fLYq6yCguSvgcpFqgKLxIUTAvXxJFLyAUvB89W9s4ZpjjrKuV0i+iZ55NFplXzbo6pb2W6rtHHlc5qyKD2amzb3a8XgCZGdSqAwdemNRtAQA7BK+Iy4F9zxeJ1m03YFPd1c/FmqxYTLdjamrwLOtqJdC1s0Tbo01Ll5s3y9fq0V0Srr5eAutssrUJ0lRb0/xzlovMq5vpiHTapezvLIpJjRplmXV1rMmQvF82z59Yu0XPuLKuToQHsy0DWQCIZeqCu1rdR0ALbMaY1+QieEXCGF07R72/oYt15ir7p9hVVttFk2Ezj2yS5kO1EOxYajlOWIIO+7C66IJt1CbnIkWwsNB2X1t9Pp52287Jlh7Pb56ndeVxW7Ut69pCeCBbNTr6lDpW4qkVQdYVgB8DWroMA4gXwSt8I2dFmUjnTlGXGcs2n9QnjMPgRwUK8qNmSk0uusx6qXzHzRVrWyr+ZpmzldU7y/Yle5okN9lVy3U5OA7CA9myfWLPQxvBpnp1U7dSyV8WfUxwQ7HzjD4AJBoZWmQsxrwmFcEr/K+8QoLF0QsIGTZBlVHhzXyobgRK7AseGWXWxYocZ10dKv5upXWgnsTiV4G86EGYUbV5Opo2azF+tk1yrJvLQHa2lE6z6Gbsovu45es0NEnO+ugZ44aO9lMlvTvtSs+2AwBSLaClUBOQHghekZ4amyRgMe+p0Z5VflV2tgQ6d2y3rKsVw2Y8ayDPu8ym7TbU1UdUGjYa6hOSdU1aV28dE27Vrdpi6ifNujpV3bdFkaaK9s36A4CTgPaAba9mhyFlPbX4PikpKUnoa5SVlUm/fq8k9DVSBcEr4jJ1yT1R7z+w3wUptQcD+XnmzenY0KZkFCqyyhQbhgQ7OKvy6ynDsJ6mKFbRrjaymjInLm4CVH2vFt29AxaZV826On4Z7TEQ1msgUFgYV9Y1XvUdsiMCWbKuAPzszW//FvV+r4LaZGZdkTlyc3OlZ8+e0q9fv6S8nr5WrofDpFIVwatP3XDDDfLcc8/JJZdcIqeeemrz/b/++qvcd9998vXXX0tRUZHst99+cu6550p+fuKmE7EzdfE/HD9n391vlJRSkC/BPj0dZyujchHoWKkf3lfanYeBq2ZdLV8mGLAeQ+ywIXeTdTUD1PqGuLoQu9k3kV2lS9uUdW2JwBVAqkp0UJsIU3++pb03AUmi597z58+XuiTV+NDANb+dzvf9hODVh9577z3597//LcuWLZM1a9Y037906VI59NBD5eyzz5ZjjjlGVq1aJX/+85/lgw8+kDfeeENSxbsfXRX1/gOHWc8z50s1tRIotB9n2B4CTSIFK9t7rtjG5FRnzsqynBfXcUbUiKNcb0h4IOvwdezGaes+CyxZFf15Pbs6eh0ASFepGNQiPWkwSUCZXASvPrN69Wo57bTT5D//+Y8cdNBBEct69OghP/74o2SFBQWafZ0wYYIsWLBABg4cKKls6txbHT/ngK5/EN/R4MwqQPMw8+pG9tK17Zp1tcuu2mZdHQqWWGcjjXJnxbLsgmCzC7pV0OtlVlqPp6Uroy+MkXkFgEwPag8cfnlSXp+sK5B4BK8+YhiGnHzyyXLmmWfK+PHjWy3PjnISHbqvqSl5VWL95M01D0e9/4BOZ4jfGJVVInqz0J5Z3KYVqy2XRR0jbMdNt9zcHAlI9PGtVplVN1Mb2Y0fbnIY1MacBqfJ2X5wOk+t+ZzsbCmcsaD596rtIy9gTXvjUsfrBIB00zKoTFYwC8B7BK8+cvvtt0tFRYVcfnl8jWpjY6Ncf/31MmbMGBk8eLDl42pra81beMWydPfm+kcdPf7APudJu8rNiVooyLZQUhKyroGiAlfzlHqVdW0sL4/4PRjH+Fa7rKvt86ymY6qu8SaoV3m5EfMCGzXR1x3x+g4uBtgFskh9mdiWA8nKkBLQAqmB4NUnvvrqK7ntttvMf8O7Bdu54IIL5LvvvpNPP/3U9nE333yzXHfddR5taXqauvRey2UHDv2z+I0GgsHPZ0VfNn5rz7KuVgKBoIjFYep0TKtmXePVFFYUIWgxFZInY1pDT+nRJfKOBUtjP8lBUB8IL7xgMxbWDbKu6Ye2HPBvQEuXYSA5Aob2VUW702zrgw8+KH37bq4gO2fOHOnWrZsMHz5cPvzww4jHaxXif/7zn/Luu+/K9ttv7/hqvZb13rhxY8LnpUpnB/Y9P/oCi+DN7DYcjUXwZpd1tcpi2o0PDfbq4bzLsEXm1Qxeo22XVUVgm/djF7y2zLzGE7haZl69CF7DBFZsLqYWd/BqNV+uTfViuzG6duNxp664XzKJtmulpaVp3a7RlgPtzyqgJXj1Ria05WgbMq8+ceGFF8pJJ50Ucd9uu+0mJ554ovz+97+PuF8rDD/66KPyzjvvxAxcVV5ennlDkua+7XWO73Z1U32DNC2KnjWMpytuW3nZ/dlOsFsX2+rQXrKq/htY5jyTbSk7WwKdOlov93KcLnyPthxofwSpQPsiePUJrSSst3DafVgnJNbMa3iGNhS4jhs3rh22FLFMXT4ldSomG03SVGs97jLLbsyrB8zXtnl9z16ni/3V2+BSbwLOwMq1IlnRs9Ke00xyePGpisqMzboCAIDMQPCaQnSanFtvvVW6dOliTqcT7qGHHpJddtml3bYN3ldMntDhlHbdrdo117JYUWFhwl8/q7Q04vfGjRsT8jqBugYxunWShGtsEmmsc9xtOG6hQDYsiAUAAEgnBK8+9vHHH5tjXkOGDh0qP/zwQ9THpvocr2jtrYonLHfL/rkntNsuM+rqpDGscFK4YIfoFXu9DmZ1GxLNyI1sHgMNCZqOSqsWN4SNk86Oo2Cbzfhdsq4AACBdEbz62JZbbhnxe35+vowcObLdtgf+8XbdM1Hvn5B/oifrd1zJ1+yBbEhjWbkn42pbZl0jFwYlUBBWpbeNWdd4GdlB94GsZl3jFRHI0kQDAACEcGYEpJG3ap6Oev9+Wcd5sn5XGc8Y42q9YnZldjj3bLxZ18gXCoiREz07al3r2YLdXLEu5pGd+uvfHT8HAAAgVRC8Ahngncbno96/X/AYT9avWVenXFU5dlEMqX7g5q73LWU7yLzGEiyvESm1KAy1boNnr2NYTC0UqE18V2oAAID2RPAKZLB3ml6Iev+EopO9eQHD+TjRmn1GR/xe8OncmM9xU0Aqu6xWS3o7e1LAcW51UwElm7lsoyLrCgAA0ArBK4BW3qp8Mupe2T/neE/2lpOsa/XOw5p/LvjiV8+yrlaMrIC7rKtTTU2bbg7Gt1plXQEAADIBwSuAuL1d/1xCx9S2zLqGK5y9SqTEoltuQ4PzrGsyOJm2JuI9OB/vCgAAkO4IXgH4fkytHaNDvnfrssm6Bmq8Gx8bkXGNtsyiarN07Rz17jdn3ejRhgEAAPgXwSuA5I+pdTilj5l1dUins8lZU+m8mrBDRn62GBZNadBJ5jWW7GwJbChr/fodLbLRAAAAaYbgFYBvpvTZ4+DbEp51behcZLksWF3nWdZVA+TG/t2jLstasMJ5RtYCWVcAAJApCF4B+Ma0Ny51Hci2zLo6lVVW7Srr6vh1NlSJhGdLo2RTW4mjmBMAAEC644wIgO8D2QMHX+LJOu2yrlZadjEOVNc7fo6t8EDWw/lgAQAA0g3BKwDfmzrv9qj3H7DNXzxZv5Osq1EQNl2NYTjPulpxEbhOXXqv4+cAAACkKoJXACnrze9viHr/gSOu9GT9dhnU1eNKLZd1/bZCPFNYEP3+utgZYAAAgHRC8Aog7Uz96aao9++3a+KnlCmdVyf1JbnOMq9kXQEAAGIieAWQMd75+CpPuh/bZV2tVPTJkYo+3Zp/7/rZavdZVwAAgAxE8Aog41l1P54w9lrHWdd4rdkpLJB9g0JNAAAAsRC8AoCFt76+1nUg2zLraqUxNyArjxwWdVmPtxZHvX/q/DtdbwsAAECqIngFAIeB7Jiz70r4Puv0c43UDdycnQ3JXRBHd2MAAIA0RPAKAA5988CFUe/fa8KtjtajWVenyLoCAIBMRfDqU//5z3/k5ZdflhNOOEEOOuigiGXff/+9PPXUU7JhwwbZYYcd5NRTT5XsbD5KoL198NZlUe8fd/qdjrOuAAAAiETE40Nz5syRiy66SNauXSvbbrttRPD6/vvvywEHHCCnn366bLXVVnLzzTebQe7rr7/ertsMwNpXj10U9f4xZyW++zEAAEC6IHj1mZqaGjnuuOPkrrvukjPPPLPV8j/96U8yefJkefDBB83fNZDdeuutZerUqXLggQe2wxYDcOubBzd3PyaQBQAAsBdkB/mLZlzHjh0rEydObLVs0aJF8sMPP8ixxx7bfN+IESNkm222IfMKpEEgG7oBAACgNTKvPvLSSy/JO++8IzNnzoy6fN68eea/AwYMiLhffw8ti6a2tta8hZSVlXm2zQC8994HV7Bb0QptOQAg05F59QnNqmo3YS3E1KFDh6iPqa6uNv9tuby4uLh5WTQ6Lra0tLT51q9fP4+3HgCQaLTlAIBMR/DqEw899JBZMfi+++6Tk046ybxVVFTIs88+K+eee675GA081fr16yOeu27duuZl0VxxxRWycePG5tvixYsT/G4AAF6jLQcAZDq6DfvEMcccY1YPDvfKK6/I8OHDZa+99moe35qVlSU//vijjBo1yrzPMAzz91NOOcVy3Xl5eeYNAJC6aMsBAJmO4NUndEocvbWsLDxmzJjm4k0dO3Y0KwpPmTJFjj76aMnJyTHng122bJkcf/zx7bTlAAAAAJB4BK8pRgPXfffd15weZ9CgQTJ9+nS57bbbZOTIke29aQAAAACQMASvPqZzuWqQGq5///5mN+GPPvpINmzYYI6VHThwYLttIwAAAAAkA8Grj2nX4Ghyc3PN7KtbOk5WMWUOgHQRas9C7VsmoC0HkK5tuf6rs2kEAoH23iT4DMFrBiovLzf/ZcocAOnYvtlVX08ntOUA0pWeo+oMGSUlJe29KfCZgJFJl6lhampqMos8ha5o6dUtbSR0Ch0aCXvsK2fYX+yrZB1X+qdMg7nevXtLMBjMyLZc8Z2LH/vKGfYX+yoZx1WoLdd2TX8n84qWyLxmID2x69u3b6v7tZEgeI0P+8oZ9hf7KhnHVaZkXGO15YrvXPzYV86wv9hXiT6uMq0thzOZcXkaAAAAAJDSCF4BAAAAAL5H8ArJy8uTa665xvwX9thXzrC/2FeJwHHFvuE4Sj6+d+wrjiv4AQWbAAAAAAC+R+YVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7Ba4Z47733ZMKECdKxY0fp0aOHHH300fLLL79EPEYnhf7d734nnTp1MieH1sesWLFCMs26devkyiuvlC222EKKiopk5MiRMmXKlIjHPProo+bE2S1vNTU1kqmqq6vNfaX74eOPP45Ytn79epk8ebI5d5vO4zZp0iRZs2aNZLKHH37Y3FeHHHJIxP233357q+MqPz9fMlF2dnarfXH33XdHPGblypVyzDHHmG2Wtl2nnXaaOel9OqM9jx/tuTu0587QnsdGew6vELxmgMbGRvnHP/4hV1xxhSxZskS++OILqaurk3333VcMw2h+3Omnny6ff/65fPbZZzJr1ixZvXq1HH744RGPyQSPP/649OzZU9555x1ZtWqVWYn5oosukieffDLicQMGDDD3TfgtU4MMdcEFF8jgwYOjLjvhhBPMY2rGjBny3XffyW+//SbHHnusZCrdF9dff73stNNOUZePHj064rjK5IsiU6dOjdgXf/rTn5qX6e9HHnmkGcD++OOPZvv11VdfySmnnCLpivbcGdpzd2jP40d7Hj/ac3jCQEZ66623NCI1lixZYv4+f/588/c33nij+THffvuted+HH35oZLpx48YZZ511VvPvjzzyiDFgwIB23SY/+X//7/8Zo0aNMn788UfzmJk+fXrzsh9++MG8b9q0ac33ffzxx+Z9X3/9tZFpqqqqjJEjRxovvviiMXHiROPggw+OWP73v//dGD16dLttn59kZWUZU6dOtVyux5keR999913zfa+//rp536+//mpkCtpzZ2jP7dGex4/2PH605/AKmdcMo5kKzb4++OCDsssuu0jv3r3N+z/99FPz3z322CMi+9OlS5fmZZnadeqVV16R2bNnmxmecMuWLTO7YXfu3Fn23ntvM+uTiRYsWCDnnXeePPPMM1HnCtbjR7sL6fEWsvPOO0tBQUFGHluaOdxhhx3kqKOOsnzMnDlzzO7VXbt2lQMOOEC+/fZbyVSatdceDVtttZXcdtttUl9f37xMjx/tKrzNNts037fPPvs0L0t3tOfO0J7HRnvuDO25M7Tn8ALBa4Y1ssFgUPr162d223zuuefMMWRKx7YWFhaaYzzDde/ePSPHvep4TN03uk907O+NN94o+++/f/NyDVrvv/9++fXXX+WHH34wT6w18NefM0lDQ4M5flW7pOt412j0+NEAPysrq/k+3bcamGXasfWf//xH3n///VbjNsN169ZNHnnkEfMkUrtZaxf2XXfdVebNmyeZ5qSTTpLp06ebQxhuvvlmufXWW+Wyyy5rXq7Hj+6vcBro6vjXdD+2aM/jR3seH9pzZ2jPnaE9h1cIXjOInjDreCkt1DRw4EDZc889pbKyMuaV/VCAm0k0sNL3roVf/v3vf8vll19uFmkK0YD2jDPOMB/Xp08fue+++2T48OFy7733Sia59tprzQzh+eef7/i5mXZsaY+Hs88+2zyeOnToYPk4Ha+pxa004Ndx1XrcaYCmvSUyjY5X3Hrrrc1g9IgjjpDrrrvO/I7V1tZKph9btOfxoz2PD+15/GjPnaM9h1cIXjOMZl6HDh0q//znP83s61tvvWXer9mdqqqqVsGsZjy0OnGm0pPm4447Tk4++WQz02pFT5T1JLtlBed0p1WF3377bfO40n2gFZrVbrvtZgYboWNLK37qhZPw4GLt2rUZdWxpQSHNAO24447NlXNffPFFeeONN8yftatwNNrlesstt8y4YyuaUaNGmdkhzUqHji1to8JpcauKioqMOLZoz52hPbdHex4/2vO2oz2HWwSvGSo0biyUndAxiOrDDz9sfsz3339vBhihZZm+v+wyORqMacXB0BjiTKHHS3gl2FCApV09X375ZfNnPX404AifPkcrWuv4s0w6tnTsasvq1BMnTpSDDz7Y/FkD1Gh032lgm2nHVjTaLV8DtlBgqsePTsOkFaxDtFt2aFmmoD13vr9oz1ujPY8f7Xnb0Z7DNc9KP8G3tPrmNddcY8ydO9eorq42q7/uv//+Rt++fY3y8vLmx2nl0xEjRhizZ882Fi5caOy2227G+PHjjaamJiOTnHLKKcY777xjbNiwwVi7dq3x2GOPGbm5uca9997b/JhTTz3VePPNN43169ebFZvPOeccIzs72/j000+NTPbLL7+0qjasJkyYYIwZM8ZcPm/ePLPa55577mlkumjVho8//njj/fffNzZu3GgsWLDAPB7z8/ON77//3sgkTzzxhFl5WY8Xbadeeuklo0uXLsbvfve75sdo27TTTjuZbZXuqzlz5hhbb721ccQRRxjpivbcGdpz92jPnaE9t0Z7Di8RvGaAmpoa4/bbbzdP6vQkeODAgcYZZ5xhBqjhysrKjNNPP90oLS01ioqKjKOOOspYtmyZkWm++eYb4/DDDzc6d+5sdOrUydhxxx2Np59+OuIxM2fONB+jy7t162ZeDPjss8+MTGd1srNu3TrjxBNPNIqLi40OHToYxx13nLF69Woj00U72fn888+NAw880Pwe9uzZ0zjkkEPM4y3TaMCqF92GDh1qtkc6vZC2Y3V1dRGPW7Fihbkf9TG6zzRY0cA/XdGeO0N77h7tuTO059Zoz+GlgP7Pfd4WAAAAAIDEY8wrAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAAAAAADfI3gFAAAAAPgewSsAAAAAwPcIXgEAAAAAvkfwCgAAAADwPYJXAAAAAIDvEbwCAAAAAHyP4BUAAAAA4HsErwAAAAAA3yN4BQAAAAD4HsErAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAAAAAADfI3gFAAAAAPgewSsAAAAAwPcIXgEAAAAAvkfwCgAAAADwPYJXAAAAAIDvEbwCAAAAAHyP4BUAAAAA4HsErwAAAAAA3yN4BQAAAAD4HsErAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAAAAAADfI3gFAAAAAPgewSsAAAAAwPcIXgEAAAAAvkfwCgAAAADwPYJXAAAAAIDvEbwCAAAAAHyP4BUAAAAA4HsErwAAAAAA3yN4BQAAAAD4HsErAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAAAAAADfI3gFAAAAAPgewSsAAAAAwPcIXgEAAAAAvkfwCgAAAADwPYJXAAAAAIDvEbwCAAAAAHyP4BUAAAAA4HsErwAAAAAA3yN4BQAAAAD4HsErAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAAAAAADfI3gFAAAAAPgewSsAAAAAwPcIXgEAAAAAvkfwCgAAAADwPYJXAAAAAIDvEbwCAAAAAHyP4BUAAAAA4HsErwAAAAAA3yN4BQAAAAD4HsErAAAAAMD3CF4BAAAAAL5H8AoAAAAA8D2CVwAAAACA7xG8AgAAAAB8j+AVAAAAAOB7BK8AAAAAAN8jeAUAAAAA+B7BKwAAAADA9wheAQAAAAC+R/AKAAAAAPA9glcAAAAAgO8RvAIAAAAAfI/gFQAAAADgewSvAACkuL59+8qpp54qmb5NO+64o+y5555JfU0AQPIQvAIAgKTo2rWrnHHGGextAIAr2e6eBgAAYG3JkiXsHgCAp8i8AgAAAAB8j+AVAIA01NDQIDfddJMMHz5c8vLypFu3bnL88cfLvHnzIh7XoUMHOffcc+XLL7+UnXbaSQoKCmTQoEHy4IMPtlpndXW1XHjhhdKzZ08pKiqSCRMmmOuLNtY0fMxrRUWFBAIBWbt2rfzzn/80f9bbrrvuai7fsGGD+fstt9zS6jXHjh0r++67b8R9tbW1cvHFF7faDitPPfWUjB8/XgoLC833u99++5nvFwCQWgheAQBIQyeffLLccMMNcuWVV8rKlSvlnXfekd9++0122GEHWbRoUcRj58+fL7fffrs8/vjjsmzZMjnmmGPk7LPPlunTp0c8btKkSfKvf/1L7r//flm+fLlcf/31cv7555tBrR0NGA3DkC5dusjvfvc782e9ffzxx67e2wknnCCPPvqo3HfffeZ2XHfddfLHP/4x6nZcccUV5jhb3XZ9n7/88otstdVWsvvuu8vXX3/t6vUBAO2D4BUAgDTz1VdfybPPPmsGbqeccop07NhRtt12W3nxxRdl48aN8re//S3i8V988YU89thjZpa2U6dOZsa2e/fu8sgjjzQ/5vPPP5dXXnnFfO5RRx0lJSUlZjZTA8fvv/8+ae9NM6b//e9/zdc9+uijze3QzG+07ZgzZ47ceuut8uc//9nMGPfo0UN69eol//jHP2TrrbeWv/zlL0nbbgBA2xG8AgCQZt577z3zXw0yw/Xv398MOEPLQzQLqdnRkOzsbDOQDe+K+8EHH5j/HnrooRHP3X777aV3796SLKFtP+ywwyLu14yydiMO98Ybb5gZXs0kh9MuynvvvbdMmzYtCVsMAPAK1YYBAEgzOrZUtQzmQvd99913EfdpNrIlzWguWLCg1To1I9tStPu8osFnuNB2aBa1pZb3rVixojnADq0rtL7Qv1VVVeZYWACA/5F5BQAgzXTu3Nn8V8e6tqT36XyrLTORseh4VbVq1apWy6Ld54RmfbOysqS8vLzVsqVLl0bdDqv3Fi70Pn/++WezgFVjY6M0NTWZt1AgS+AKAKmD4BUAgDSzzz77mP++9NJLreZe1TGjoeVO7LXXXs1dccPNnDnTLPIUD60MrJWCW9Juytql+ccff4y4XwsqtQxItbuveu211yLu1/cVyrSGHHzwwWZg/vzzz8e1fQAAfyN4BQAgzei41mOPPdYsvKTTxGiRJi1mNHHiRDPL6aZQkRZFOvzww+Xqq6+Wl19+2cySamGoa665RrbZZpu41jFy5EgzyIwW7P7+97+X//3vf/Lcc8+Z6/7kk0/M7dfntBzbesQRR5ivq4WbysrKzIJT1157bavt0OdefvnlZjEnLdykVZa1IvFPP/0kd9xxh1mhGACQOgheAQBIQ08//bRZbVins9E5XjVjOWDAADPQGzhwoKt1agVjnYLnzDPPNMfOXnXVVXL33f+/vTs2bRiIwgB8caVB1GoGdyq0gGp3btRpkOANNIVao0adRvAE3iHhHaSIMdgJMVzg+wY4jut+3rv33tNut8u7ZB+JdTxxl7quv+15DeM45jA5DEP+gxthM1bh3Ds37nE4HPI6n697nE6nvKP2VgTgeIt5nlPTNLmVuO/73Ooca4QA+D/ePm4nIQAA/EAE0q7r0jRN3g2Al1F5BQB+bVmWdL1e036/94oAvJTKKwDwlKisxh/T2PUaE43XdU3H4zFVVZW2bbvbtgsAf0XlFQB4SgxsulwuqW3b3Coc/05jcvH5fBZcAXg5lVcAAACKp/IKAABA8YRXAAAAiie8AgAAUDzhFQAAgOIJrwAAABRPeAUAAKB4wisAAADFE14BAAAonvAKAABAKt0nZLMpOaymJ0oAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -551,7 +554,7 @@ "for ax, lvl in zip(axes.flat, show_levels):\n", " ds = level_datasets[lvl]\n", " band = ds[BAND]\n", - " # This level's own decimated coordinates: the native grid of the level.\n", + " # This level's own coordinates: the native grid of the level.\n", " mesh = ax.pcolormesh(\n", " ds[\"longitude\"],\n", " ds[\"latitude\"],\n", @@ -577,7 +580,8 @@ "metadata": {}, "source": [ "All panels cover the same geographic swath, but each is drawn from that\n", - "level's own stored arrays — radiance plus its decimated latitude/longitude —\n", + "level's own stored arrays — radiance plus its latitude/longitude, where each\n", + "cell's coordinate is the geodesic centroid of the pixel block it averages —\n", "so the visible cell size is the level's true native resolution. The\n", "coarsening from panel to panel is the multiscale pyramid itself, produced by\n", "the single conversion above." diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index d620b778..5680c68b 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -9,9 +9,11 @@ identity matters. * :func:`reduce_swath` — radiance bands are fill-aware block-averaged - (mean of ``factor x factor`` blocks) while coordinate arrays are decimated - with :func:`decimate_swath`; non-swath variables pass through unchanged. - Intended for producing GeoZarr multiscale overview groups. + (mean of ``factor x factor`` blocks); the 2-D latitude/longitude pair is + reduced to per-block *geodesic centroids* (unit-vector mean on the sphere); + other swath variables are stride-decimated; non-swath variables pass + through unchanged. Intended for producing GeoZarr multiscale overview + groups. """ from __future__ import annotations @@ -49,13 +51,125 @@ def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: return ds.isel(indexers) +def _fill_value_of(var: xr.DataArray) -> int | float | None: + """Declared ``_FillValue`` from attrs or encoding, or None.""" + fill = var.attrs.get("_FillValue") + if fill is None: + fill = var.encoding.get("_FillValue") + return fill + + +def _swath_geolocation_pair(ds: xr.Dataset) -> tuple[str, str] | None: + """Names of the 2-D swath (latitude, longitude) pair, or None. + + Matches on CF ``standard_name`` first, falling back to the variable name. + Returns None when either member is missing or ambiguous; the caller then + falls back to stride decimation for whatever geolocation is present. + """ + found: dict[str, list[str]] = {"latitude": [], "longitude": []} + for key in [*ds.data_vars, *ds.coords]: + name = str(key) + var = ds[name] + var_dims = tuple(str(d) for d in var.dims) + if len(var_dims) != 2 or set(var_dims) != set(SWATH_DIMS): + continue + kind = str(var.attrs.get("standard_name") or name) + if kind in found: + found[kind].append(name) + if len(found["latitude"]) == 1 and len(found["longitude"]) == 1: + return found["latitude"][0], found["longitude"][0] + return None + + +def _geodesic_block_mean( + lat: xr.DataArray, lon: xr.DataArray, factor: int +) -> tuple[xr.DataArray, xr.DataArray]: + """Reduce a 2-D lat/lon pair to per-block geodesic centroids. + + Each output cell is the spherical centroid of its ``factor x factor`` + pixel block: positions are mapped to unit vectors on the sphere, the + vectors are averaged (skipping fill pixels), and the mean direction is + converted back to degrees. Unlike a planar mean of raw lat/lon values + this is stable across the antimeridian and near the poles, and reducing + an entire swath to a single cell yields its geodesic center. + + The sphere is used rather than the WGS84 ellipsoid: for centroid + direction the ellipsoidal correction is second-order and far below the + positional accuracy these overview coordinates need. + + A pixel that is fill in *either* array is excluded from *both* means — + the two arrays describe one position, so a one-sided mean would blend + positions. All-fill blocks come back as the variable's own fill value + (NaN if none is declared). + + The converter operates on un-decoded (``mask_and_scale=False``) data, so + the inputs may be CF-packed (e.g. OLCI stores int32 microdegrees with + ``scale_factor = 1e-06``). Values are unpacked to degrees before the + trigonometry — which, unlike stride decimation or a plain mean, does not + commute with scaling — and re-packed afterwards, preserving the inputs' + dtypes and attrs so readers decode the overviews exactly like the native + level. + """ + lat = lat.transpose(*SWATH_DIMS) + lon = lon.transpose(*SWATH_DIMS) + + def cf_packing(var: xr.DataArray) -> tuple[float, float]: + scale = var.attrs.get("scale_factor") + if scale is None: + scale = var.encoding.get("scale_factor", 1.0) + offset = var.attrs.get("add_offset") + if offset is None: + offset = var.encoding.get("add_offset", 0.0) + return float(scale), float(offset) + + def unpacked(var: xr.DataArray) -> np.ndarray: + """Raw values as float64 degrees, with fill pixels as NaN.""" + vals = np.asarray(var.values, dtype="float64") + fill = _fill_value_of(var) + if fill is not None and not np.isnan(float(fill)): + vals = np.where(vals == float(fill), np.nan, vals) + scale, offset = cf_packing(var) + return vals * scale + offset + + lat_v = unpacked(lat) + lon_v = unpacked(lon) + # A pixel invalid in either array is excluded from both: the two arrays + # describe one position, so a one-sided mean would blend positions. + invalid = np.isnan(lat_v) | np.isnan(lon_v) + lat_r = np.deg2rad(np.where(invalid, np.nan, lat_v)) + lon_r = np.deg2rad(np.where(invalid, np.nan, lon_v)) + coslat = np.cos(lat_r) + vectors = xr.DataArray( + np.stack([coslat * np.cos(lon_r), coslat * np.sin(lon_r), np.sin(lat_r)]), + dims=("xyz", *SWATH_DIMS), + ) + coarse = vectors.coarsen({"rows": factor, "columns": factor}, boundary="trim") + # .mean() exists at runtime; pyright stubs don't expose it on Coarsen. + mean_vec: xr.DataArray = coarse.mean(skipna=True) # type: ignore[attr-defined,assignment] + out_dims = tuple(str(d) for d in mean_vec.dims[1:]) + xm, ym, zm = np.asarray(mean_vec.values, dtype="float64") + lon_mean = np.rad2deg(np.arctan2(ym, xm)) + lat_mean = np.rad2deg(np.arctan2(zm, np.hypot(xm, ym))) + + def restore(orig: xr.DataArray, degrees: np.ndarray) -> xr.DataArray: + scale, offset = cf_packing(orig) + vals = (degrees - offset) / scale + if np.issubdtype(orig.dtype, np.integer): + vals = np.round(vals) + fill = _fill_value_of(orig) + if fill is not None and not np.isnan(float(fill)): + vals = np.where(np.isnan(vals), float(fill), vals) + return xr.DataArray(vals.astype(orig.dtype), dims=out_dims, attrs=orig.attrs) + + return restore(lat, lat_mean), restore(lon, lon_mean) + + def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: - """Return *ds* with radiance bands block-averaged and 2-D coordinates decimated. + """Return *ds* with radiance block-averaged and lat/lon reduced to block centroids. Overviews are an unweighted index-block mean that ASSUMES locally-uniform pixel spacing; intended for visualization, not quantitative analysis at - reduced resolution. Coordinates are decimated (real sub-pixels), radiance - is fill-aware block-averaged. + reduced resolution. Radiance variables (those named in :data:`OLCI_BANDS`) are averaged over ``factor x factor`` pixel blocks with fill-value awareness: fill pixels @@ -63,19 +177,19 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: the entire block. Blocks where ALL pixels are fill are set back to the fill value in the output. - 2-D coordinate variables spanning exactly ``(rows, columns)`` and **not** - in :data:`OLCI_BANDS` (e.g. latitude, longitude, altitude) are decimated - ``[::factor, ::factor]`` to preserve real on-ground positions. - - Note the resulting origin-vs-center mismatch: coordinates sample each - block's *origin* pixel while radiance averages the whole block, so - overview coordinates sit ~half a block off the averaged value's effective - center, growing with each level. This is acceptable for the - visualization-oriented overviews these feed; do not treat overview - coordinates as block centers. + The 2-D latitude/longitude pair (identified by CF ``standard_name``, + falling back to variable name) is reduced with + :func:`_geodesic_block_mean`: each output cell's coordinate is the + spherical centroid of the same pixel block the radiance was averaged + over, so overview coordinates ARE block centers and repeated reduction + trends toward the geodesic center of the swath. Levels built + iteratively (2x per level, as the converter does) renormalize between + levels, which departs from the exact one-shot block centroid only at + second order. - Variables that do not span exactly ``(rows, columns)`` are passed through - unchanged. + Other 2-D swath variables (e.g. altitude) are decimated + ``[::factor, ::factor]``; variables that do not span exactly + ``(rows, columns)`` are passed through unchanged. Parameters ---------- @@ -123,8 +237,24 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: dim: (ds.sizes[dim] // factor) * factor for dim in SWATH_DIMS if dim in ds.sizes } + # Geolocation first: the lat/lon pair is reduced jointly (per-block + # geodesic centroids), so both members are handled here and skipped in + # the per-variable loop below. + geo_pair = _swath_geolocation_pair(ds) + geo_names: frozenset[str] = frozenset(geo_pair) if geo_pair is not None else frozenset() + if geo_pair is not None: + lat_name, lon_name = geo_pair + lat_out, lon_out = _geodesic_block_mean(ds[lat_name], ds[lon_name], factor) + for geo_name, geo_var in ((lat_name, lat_out), (lon_name, lon_out)): + if geo_name in coord_names: + result_coords[geo_name] = geo_var + else: + result_vars[geo_name] = geo_var + all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] for name in all_names: + if name in geo_names: + continue var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] # Order-insensitive: a variant product storing a band transposed as # (columns, rows) must still get fill-aware averaging, not silently @@ -137,9 +267,7 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: log.info("Transposing band to canonical swath dim order", band=name) var = var.transpose(*SWATH_DIMS) # Fill-aware block averaging for radiance bands. - fill_value: int | float | None = var.attrs.get("_FillValue") - if fill_value is None: - fill_value = var.encoding.get("_FillValue") + fill_value: int | float | None = _fill_value_of(var) orig_dtype = var.dtype float_var = var.astype("float64") diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 3e348f8c..c1892e6a 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -13,6 +13,19 @@ ) +def _geodesic_center(lat_deg: np.ndarray, lon_deg: np.ndarray) -> tuple[float, float]: + """Reference spherical centroid of a set of lat/lon positions, in degrees.""" + lat = np.deg2rad(np.asarray(lat_deg, dtype="float64")) + lon = np.deg2rad(np.asarray(lon_deg, dtype="float64")) + x = float((np.cos(lat) * np.cos(lon)).mean()) + y = float((np.cos(lat) * np.sin(lon)).mean()) + z = float(np.sin(lat).mean()) + return ( + float(np.rad2deg(np.arctan2(z, np.hypot(x, y)))), + float(np.rad2deg(np.arctan2(y, x))), + ) + + def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: """Minimal synthetic swath dataset with one radiance band and two coords.""" rad = xr.DataArray( @@ -108,14 +121,116 @@ def test_reduce_swath_radiance_is_averaged_not_decimated() -> None: assert int(out["oa01_radiance"].values[0, 0]) == expected_block -def test_reduce_swath_coordinates_decimated() -> None: - """Coordinate arrays must be decimated (stride), not averaged.""" +def test_reduce_swath_coordinates_are_block_geodesic_centroids() -> None: + """Each output coordinate is the geodesic centroid of its pixel block.""" ds = _swath(8, 6) out = reduce_swath(ds, factor=2) - # lat[0,0] in output == lat[0,0] in input - assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) - # lat[1,1] in output == lat[2,2] in input (stride-2) - assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + lat_block = ds["latitude"].values[0:2, 0:2] + lon_block = ds["longitude"].values[0:2, 0:2] + exp_lat, exp_lon = _geodesic_center(lat_block, lon_block) + np.testing.assert_allclose(float(out["latitude"].values[0, 0]), exp_lat, rtol=1e-12) + np.testing.assert_allclose(float(out["longitude"].values[0, 0]), exp_lon, rtol=1e-12) + + +def test_reduce_swath_whole_image_collapses_to_geodesic_center() -> None: + """Reducing the full swath to one cell must yield its geodesic center.""" + rows = cols = 4 + ds = _swath(rows, cols) + out = reduce_swath(ds, factor=rows) + assert out["latitude"].shape == (1, 1) + exp_lat, exp_lon = _geodesic_center(ds["latitude"].values, ds["longitude"].values) + np.testing.assert_allclose(float(out["latitude"].values[0, 0]), exp_lat, rtol=1e-12) + np.testing.assert_allclose(float(out["longitude"].values[0, 0]), exp_lon, rtol=1e-12) + + +def test_reduce_swath_longitude_stable_across_antimeridian() -> None: + """Lon values straddling +/-180 must average to ~180, not ~0. + + A planar mean of [179.5, -179.5] is 0 (the wrong side of the planet); + the unit-vector mean lands on the antimeridian. + """ + lat = xr.DataArray( + np.zeros((2, 2)), dims=("rows", "columns"), attrs={"standard_name": "latitude"} + ) + lon = xr.DataArray( + np.array([[179.5, -179.5], [179.5, -179.5]]), + dims=("rows", "columns"), + attrs={"standard_name": "longitude"}, + ) + rad = xr.DataArray( + np.full((2, 2), 100, dtype="uint16"), + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + ds = xr.Dataset({"oa01_radiance": rad}, coords={"latitude": lat, "longitude": lon}) + out = reduce_swath(ds, factor=2) + assert abs(abs(float(out["longitude"].values[0, 0])) - 180.0) < 1e-9 + + +def test_reduce_swath_geolocation_fill_excluded_from_centroid() -> None: + """Fill pixels in lat OR lon are excluded from the block centroid; all-fill stays fill.""" + fill = -999.0 + lat_data = np.array([[10.0, 20.0], [30.0, fill]]) + lon_data = np.array([[5.0, fill], [6.0, 7.0]]) + lat = xr.DataArray( + lat_data, + dims=("rows", "columns"), + attrs={"standard_name": "latitude", "_FillValue": fill}, + ) + lon = xr.DataArray( + lon_data, + dims=("rows", "columns"), + attrs={"standard_name": "longitude", "_FillValue": fill}, + ) + ds = xr.Dataset(coords={"latitude": lat, "longitude": lon}) + out = reduce_swath(ds, factor=2) + # Pixels (0,1) and (1,1) are fill in one of the pair -> only (0,0) and (1,0) count. + exp_lat, exp_lon = _geodesic_center(np.array([10.0, 30.0]), np.array([5.0, 6.0])) + np.testing.assert_allclose(float(out["latitude"].values[0, 0]), exp_lat, rtol=1e-12) + np.testing.assert_allclose(float(out["longitude"].values[0, 0]), exp_lon, rtol=1e-12) + + all_fill = xr.Dataset( + coords={ + "latitude": xr.full_like(lat, fill), + "longitude": xr.full_like(lon, fill), + } + ) + out_fill = reduce_swath(all_fill, factor=2) + assert float(out_fill["latitude"].values[0, 0]) == fill + assert float(out_fill["longitude"].values[0, 0]) == fill + + +def test_reduce_swath_packed_integer_geolocation_unpacked_for_centroid() -> None: + """CF-packed int32 microdegree lat/lon is decoded before the spherical mean. + + Real OLCI products store geolocation as int32 with scale_factor=1e-06 + (and the converter runs on un-decoded data). Regression: feeding the raw + packed integers (45_000_000 for 45 deg) into the trigonometry collapsed + every overview coordinate to ~(0, 0). + """ + scale = 1e-6 + fill = np.iinfo("int32").min + lat_deg = np.array([[45.0, 45.001], [45.002, 45.003]]) + lon_deg = np.array([[10.0, 10.001], [10.002, 10.003]]) + lat = xr.DataArray( + np.round(lat_deg / scale).astype("int32"), + dims=("rows", "columns"), + attrs={"standard_name": "latitude", "scale_factor": scale, "_FillValue": fill}, + ) + lon = xr.DataArray( + np.round(lon_deg / scale).astype("int32"), + dims=("rows", "columns"), + attrs={"standard_name": "longitude", "scale_factor": scale, "_FillValue": fill}, + ) + ds = xr.Dataset(coords={"latitude": lat, "longitude": lon}) + out = reduce_swath(ds, factor=2) + + assert out["latitude"].dtype == np.dtype("int32") + assert out["latitude"].attrs["scale_factor"] == scale + exp_lat, exp_lon = _geodesic_center(lat_deg, lon_deg) + # Output is re-packed, so compare decoded values to within one quantum. + np.testing.assert_allclose(float(out["latitude"].values[0, 0]) * scale, exp_lat, atol=scale) + np.testing.assert_allclose(float(out["longitude"].values[0, 0]) * scale, exp_lon, atol=scale) def test_reduce_swath_fill_value_preserved_in_all_fill_block() -> None: @@ -247,14 +362,17 @@ def test_reduce_swath_odd_dims_radiance_is_block_averaged() -> None: assert int(out["oa01_radiance"].values[0, 0]) == expected -def test_reduce_swath_odd_dims_coords_decimated() -> None: - """Coordinate arrays must use stride decimation on odd-dim inputs.""" +def test_reduce_swath_odd_dims_coords_are_block_centroids() -> None: + """Coordinates on odd-dim inputs use the same trimmed blocks as radiance.""" ds = _swath_odd(rows=7, cols=5) out = reduce_swath(ds, factor=2) - # Output[0,0] must equal input[0,0] (stride starts at 0). - assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) - # Output[1,1] must equal input[2,2] (stride=2 -> second step at index 2). - assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + # Block [2:4, 2:4] feeds output cell (1, 1); the trailing odd row/column + # is trimmed exactly as coarsen(boundary="trim") trims the radiance. + exp_lat, exp_lon = _geodesic_center( + ds["latitude"].values[2:4, 2:4], ds["longitude"].values[2:4, 2:4] + ) + np.testing.assert_allclose(float(out["latitude"].values[1, 1]), exp_lat, rtol=1e-12) + np.testing.assert_allclose(float(out["longitude"].values[1, 1]), exp_lon, rtol=1e-12) def test_reduce_swath_odd_simulates_real_olci_columns() -> None: From 964c0477d350a3050832c19a58d717b1b05529ed Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 7 Jul 2026 17:21:02 +0200 Subject: [PATCH 38/58] fix(s3-olci): raw return tree; block-average altitude in overviews Address both findings from roborev job 456: The DataTree returned by convert_olci_optimized was reopened with default CF decoding, handing callers float radiance while the store (and the converter's own input) holds packed uint16. Reopen with mask_and_scale=False and document the raw contract. Overview altitude was stride-decimated, sitting ~half a block from the geodesic-centroid lat/lon locating the same cell. Route altitude (matched by standard_name, falling back to name) through the same fill-aware block mean as radiance: it is linear, so the mean commutes with CF packing and is exact on raw values. Assisted-by: ClaudeCode:claude-fable-5 --- .../s3_olci_optimization/olci_converter.py | 7 +++++ .../s3_olci_optimization/olci_multiscale.py | 28 +++++++++++++------ tests/test_olci_multiscale.py | 26 +++++++++++++++++ 3 files changed, 52 insertions(+), 9 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index e2bb9261..26914180 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -219,6 +219,9 @@ def convert_olci_optimized( ------- xr.DataTree The opened output DataTree (lazy; backed by the written Zarr store). + Opened with ``mask_and_scale=False``, mirroring the raw store and the + converter's input: radiance is packed ``uint16`` with its CF + ``scale_factor``/``_FillValue`` attrs intact, not decoded floats. Every written group that holds arrays is included — including nested ancillary groups such as ``conditions/geometry`` — except the overview subgroups (``r2``, ``r4``, …), which are written to the Zarr store @@ -375,12 +378,16 @@ def convert_olci_optimized( continue if re.fullmatch(r"measurements/r\d+", group_path): continue + # mask_and_scale=False so the returned tree mirrors the raw store + # (packed uint16 + CF attrs), matching how the converter opened its + # input, rather than handing callers CF-decoded floats. tree_dict[f"/{group_path}"] = xr.open_dataset( output_path, engine="zarr", group=group_path, chunks={}, consolidated=False, + mask_and_scale=False, ) try: return xr.DataTree.from_dict(tree_dict) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 5680c68b..5f9d9844 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -8,12 +8,12 @@ kept exact; intended for coordinate arrays and cases where preserving pixel identity matters. -* :func:`reduce_swath` — radiance bands are fill-aware block-averaged - (mean of ``factor x factor`` blocks); the 2-D latitude/longitude pair is - reduced to per-block *geodesic centroids* (unit-vector mean on the sphere); - other swath variables are stride-decimated; non-swath variables pass - through unchanged. Intended for producing GeoZarr multiscale overview - groups. +* :func:`reduce_swath` — radiance bands and altitude are fill-aware + block-averaged (mean of ``factor x factor`` blocks); the 2-D + latitude/longitude pair is reduced to per-block *geodesic centroids* + (unit-vector mean on the sphere); other swath variables are + stride-decimated; non-swath variables pass through unchanged. Intended + for producing GeoZarr multiscale overview groups. """ from __future__ import annotations @@ -187,7 +187,11 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: levels, which departs from the exact one-shot block centroid only at second order. - Other 2-D swath variables (e.g. altitude) are decimated + Altitude (identified like lat/lon, by ``standard_name`` falling back to + variable name) is fill-aware block-averaged exactly like radiance, so + the full geolocation triplet of an overview cell describes the same + pixel block; being linear, its mean commutes with CF packing and runs + on raw values. Remaining 2-D swath variables are decimated ``[::factor, ::factor]``; variables that do not span exactly ``(rows, columns)`` are passed through unchanged. @@ -261,8 +265,14 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # fall through to stride decimation. Normalize to SWATH_DIMS below. var_dims = tuple(str(d) for d in var.dims) is_swath_2d: bool = len(var_dims) == 2 and set(var_dims) == set(SWATH_DIMS) - - if name in olci_band_set and is_swath_2d: + # Altitude gets the same fill-aware block mean as radiance so it stays + # consistent with the centroid lat/lon locating the same cell (a + # stride sample would sit ~half a block away). It is a linear + # quantity, and a mean commutes with affine CF packing, so averaging + # raw packed values is exact. + is_altitude: bool = str(var.attrs.get("standard_name") or name) == "altitude" + + if (name in olci_band_set or is_altitude) and is_swath_2d: if var_dims != SWATH_DIMS: log.info("Transposing band to canonical swath dim order", band=name) var = var.transpose(*SWATH_DIMS) diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index c1892e6a..5a578fd0 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -233,6 +233,32 @@ def test_reduce_swath_packed_integer_geolocation_unpacked_for_centroid() -> None np.testing.assert_allclose(float(out["longitude"].values[0, 0]) * scale, exp_lon, atol=scale) +def test_reduce_swath_altitude_is_block_averaged() -> None: + """Altitude gets the fill-aware block mean, not stride decimation. + + A stride sample would locate the overview cell's altitude ~half a block + away from the geodesic-centroid lat/lon describing the same cell. + """ + fill = -32768 + alt = xr.DataArray( + np.array([[100, 200], [300, fill]], dtype="int16"), + dims=("rows", "columns"), + attrs={"standard_name": "altitude", "_FillValue": fill}, + ) + lat = xr.DataArray( + np.zeros((2, 2)), dims=("rows", "columns"), attrs={"standard_name": "latitude"} + ) + lon = xr.DataArray( + np.zeros((2, 2)), dims=("rows", "columns"), attrs={"standard_name": "longitude"} + ) + ds = xr.Dataset(coords={"latitude": lat, "longitude": lon, "altitude": alt}) + out = reduce_swath(ds, factor=2) + # Mean of the three valid pixels (fill excluded), not alt[0, 0] == 100. + assert int(out["altitude"].values[0, 0]) == 200 + assert out["altitude"].dtype == np.dtype("int16") + assert out["altitude"].attrs["standard_name"] == "altitude" + + def test_reduce_swath_fill_value_preserved_in_all_fill_block() -> None: """A block where all pixels are fill must produce fill output, not 65535.0 average.""" fill = 65535 From cd847b9550a066da06900dcf93eb73f79ea04078 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 7 Jul 2026 22:11:48 +0200 Subject: [PATCH 39/58] perf(cli): check --no-s3-olci-optimized before running OLCI detection Short-circuit the opt-out flag first so an explicit --no-s3-olci-optimized skips the structural detection (a full model validation of the store) instead of running it and discarding the result. Roborev job 457, finding 1. Assisted-by: ClaudeCode:claude-fable-5 --- src/eopf_geozarr/cli.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 139a0049..c4c6c187 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -229,7 +229,9 @@ def convert_command(args: argparse.Namespace) -> None: keep_scale_offset=False, max_retries=args.max_retries, ) - elif _is_sentinel3_olci_input(dt) and not getattr(args, "no_s3_olci_optimized", False): + # Opt-out flag first: skip the structural OLCI detection (a full + # model validation of the store) when the user already declined it. + elif not getattr(args, "no_s3_olci_optimized", False) and _is_sentinel3_olci_input(dt): log.info( "Detected Sentinel-3 OLCI product; using OLCI converter " "(pass --no-s3-olci-optimized to force the generic path)" From 36b6b0769e36e6a27c47f8c98f8e7ebd2a5cf053 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Thu, 9 Jul 2026 07:38:55 +0200 Subject: [PATCH 40/58] docs(s3-olci): draw swath quadrants from different pyramid levels over a map Replace the four-panel figure with a single cartopy PlateCarree map: the swath is split into four geographic quadrants and each quadrant is drawn from a different pyramid level via xarray's curvilinear plot.pcolormesh against that level's own centroid lat/lon, over coastlines, borders, and labeled gridlines with a shared robust color scale. The seamless tiling across quadrant boundaries makes the geodesic-centroid coordinate scheme visible: levels agree on where things are even though every quadrant is a different stored grid. Adds cartopy to the notebooks dependency group. Uses explicit set_xticks/set_yticks with cartopy's Longitude/LatitudeFormatter for axis labels: Gridliner auto-labels (draw_labels=True) blank the whole GeoAxes when a colorbar axes is present under cartopy 0.25 with matplotlib 3.11. Assisted-by: ClaudeCode:claude-fable-5 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 229 ++++++++++++-------- pyproject.toml | 1 + uv.lock | 86 ++++++++ 3 files changed, 226 insertions(+), 90 deletions(-) diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index 0f97ea21..54d5ea32 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -12,9 +12,9 @@ "1. **Open** an EOPF Zarr Sentinel-3 OLCI L1 EFR product.\n", "2. **Detect** that it is an OLCI product.\n", "3. **Convert** it to a GeoZarr-compliant, multiscale Zarr store.\n", - "4. **Visualize** the multiscale pyramid by rendering the same band from\n", - " several overview levels, each on its **own native latitude/longitude\n", - " grid** — no resampling onto a shared grid.\n", + "4. **Visualize** the multiscale pyramid by drawing each quadrant of the swath\n", + " from a **different overview level** — each on its own native\n", + " latitude/longitude grid, no resampling — over a coastline map.\n", "\n", "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", "no projected CRS). The exporter preserves that native geometry — it does not\n", @@ -25,7 +25,7 @@ "pixels it averages.\n", "\n", "> Requires the `notebooks` dependency group:\n", - "> `uv sync --group notebooks` (jupyter, matplotlib, nbformat)." + "> `uv sync --group notebooks` (jupyter, matplotlib, cartopy, nbformat)." ] }, { @@ -34,10 +34,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:32:41.979509Z", - "iopub.status.busy": "2026-07-07T13:32:41.979034Z", - "iopub.status.idle": "2026-07-07T13:32:43.330407Z", - "shell.execute_reply": "2026-07-07T13:32:43.329984Z" + "iopub.execute_input": "2026-07-09T05:35:33.849762Z", + "iopub.status.busy": "2026-07-09T05:35:33.849569Z", + "iopub.status.idle": "2026-07-09T05:35:35.581658Z", + "shell.execute_reply": "2026-07-09T05:35:35.581201Z" } }, "outputs": [], @@ -80,10 +80,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:32:43.331695Z", - "iopub.status.busy": "2026-07-07T13:32:43.331550Z", - "iopub.status.idle": "2026-07-07T13:32:43.935473Z", - "shell.execute_reply": "2026-07-07T13:32:43.935053Z" + "iopub.execute_input": "2026-07-09T05:35:35.583619Z", + "iopub.status.busy": "2026-07-09T05:35:35.583379Z", + "iopub.status.idle": "2026-07-09T05:35:36.211683Z", + "shell.execute_reply": "2026-07-09T05:35:36.211239Z" } }, "outputs": [ @@ -161,10 +161,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:32:43.937106Z", - "iopub.status.busy": "2026-07-07T13:32:43.936993Z", - "iopub.status.idle": "2026-07-07T13:32:43.939521Z", - "shell.execute_reply": "2026-07-07T13:32:43.939153Z" + "iopub.execute_input": "2026-07-09T05:35:36.213190Z", + "iopub.status.busy": "2026-07-09T05:35:36.213090Z", + "iopub.status.idle": "2026-07-09T05:35:36.215569Z", + "shell.execute_reply": "2026-07-09T05:35:36.215205Z" } }, "outputs": [ @@ -206,10 +206,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:32:43.940626Z", - "iopub.status.busy": "2026-07-07T13:32:43.940546Z", - "iopub.status.idle": "2026-07-07T13:32:43.978585Z", - "shell.execute_reply": "2026-07-07T13:32:43.978079Z" + "iopub.execute_input": "2026-07-09T05:35:36.216686Z", + "iopub.status.busy": "2026-07-09T05:35:36.216597Z", + "iopub.status.idle": "2026-07-09T05:35:36.253598Z", + "shell.execute_reply": "2026-07-09T05:35:36.253283Z" } }, "outputs": [ @@ -248,10 +248,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:32:43.979912Z", - "iopub.status.busy": "2026-07-07T13:32:43.979841Z", - "iopub.status.idle": "2026-07-07T13:35:49.840011Z", - "shell.execute_reply": "2026-07-07T13:35:49.839427Z" + "iopub.execute_input": "2026-07-09T05:35:36.254799Z", + "iopub.status.busy": "2026-07-09T05:35:36.254733Z", + "iopub.status.idle": "2026-07-09T05:37:36.558420Z", + "shell.execute_reply": "2026-07-09T05:37:36.558068Z" } }, "outputs": [ @@ -259,154 +259,154 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:32:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + "\u001b[2m2026-07-09 07:35:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:33:03\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + "\u001b[2m2026-07-09 07:35:57\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:34:11\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:05\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:34:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:34:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:11\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:34:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:13\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:34:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:15\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:05\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:16\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:14\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:18\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:24\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:19\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:33\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:23\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:23\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:24\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:34\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-07 15:35:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-09 07:37:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { @@ -451,10 +451,10 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:35:49.842045Z", - "iopub.status.busy": "2026-07-07T13:35:49.841926Z", - "iopub.status.idle": "2026-07-07T13:35:49.920330Z", - "shell.execute_reply": "2026-07-07T13:35:49.919847Z" + "iopub.execute_input": "2026-07-09T05:37:36.560083Z", + "iopub.status.busy": "2026-07-09T05:37:36.560001Z", + "iopub.status.idle": "2026-07-09T05:37:36.690586Z", + "shell.execute_reply": "2026-07-09T05:37:36.690309Z" } }, "outputs": [ @@ -495,13 +495,15 @@ "id": "95da72f9", "metadata": {}, "source": [ - "## 4. Each pyramid level on its own native grid\n", + "## 4. One swath, four resolutions, over a map\n", "\n", - "Each panel below draws one level **exactly as stored**: that level's radiance\n", - "array plotted against its own 2-D latitude/longitude coordinates with\n", - "`pcolormesh`. Nothing is resampled onto a shared grid — every panel covers\n", - "the same swath in geographic coordinates, while the native cells get 4×\n", - "larger (2× per axis) with each level shown.\n", + "The map below splits the swath into four geographic quadrants and draws each\n", + "quadrant from a **different pyramid level**, using xarray's curvilinear\n", + "plotting (`DataArray.plot.pcolormesh(x=\"longitude\", y=\"latitude\")`) on a\n", + "cartopy `PlateCarree` map. Each quadrant is that level's stored arrays,\n", + "exactly as written — radiance against its own centroid latitude/longitude —\n", + "so the quadrants tile the swath seamlessly while the visible cell size grows\n", + "4× (2× per axis) from one quadrant to the next.\n", "\n", "The finest levels (native, `r2`, `r4`) are stored identically but skipped\n", "here only because `pcolormesh` with millions of quads is slow to render; we\n", @@ -514,10 +516,10 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-07-07T13:35:49.921691Z", - "iopub.status.busy": "2026-07-07T13:35:49.921606Z", - "iopub.status.idle": "2026-07-07T13:35:50.209387Z", - "shell.execute_reply": "2026-07-07T13:35:50.208895Z" + "iopub.execute_input": "2026-07-09T05:37:36.691838Z", + "iopub.status.busy": "2026-07-09T05:37:36.691766Z", + "iopub.status.idle": "2026-07-09T05:37:37.095442Z", + "shell.execute_reply": "2026-07-09T05:37:37.095032Z" } }, "outputs": [ @@ -525,14 +527,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Levels shown: ['r8', 'r32', 'r128', 'r512']\n" + "Quadrant levels (finest → coarsest): ['r8', 'r32', 'r128', 'r512']\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -540,37 +542,84 @@ } ], "source": [ + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.ticker import LatitudeFormatter, LongitudeFormatter\n", + "\n", "# Pick four levels: the finest that is still cheap to draw as quads, through\n", "# the coarsest available (deduplicated for small fixture inputs).\n", "MAX_CELLS = 600_000\n", "candidates = [lvl for lvl in levels if level_datasets[lvl][BAND].size <= MAX_CELLS]\n", "pick = sorted(set(np.linspace(0, len(candidates) - 1, 4).round().astype(int)))\n", - "show_levels = [candidates[i] for i in pick]\n", - "print(\"Levels shown:\", show_levels)\n", - "\n", - "fig, axes = plt.subplots(2, 2, figsize=(11, 10), sharex=True, sharey=True)\n", - "for ax in axes.flat[len(show_levels) :]:\n", - " ax.set_visible(False)\n", - "for ax, lvl in zip(axes.flat, show_levels):\n", - " ds = level_datasets[lvl]\n", - " band = ds[BAND]\n", - " # This level's own coordinates: the native grid of the level.\n", - " mesh = ax.pcolormesh(\n", - " ds[\"longitude\"],\n", - " ds[\"latitude\"],\n", - " band,\n", + "quad_levels = [candidates[i] for i in pick]\n", + "print(\"Quadrant levels (finest → coarsest):\", quad_levels)\n", + "\n", + "# Robust shared color scale from the finest level shown.\n", + "finest = level_datasets[quad_levels[0]][BAND]\n", + "vmin, vmax = (float(v) for v in finest.quantile([0.02, 0.98]))\n", + "\n", + "# Map extent from the finest level's coordinates, with a margin.\n", + "pad = 1.5\n", + "extent = [\n", + " float(level_datasets[quad_levels[0]][\"longitude\"].min()) - pad,\n", + " float(level_datasets[quad_levels[0]][\"longitude\"].max()) + pad,\n", + " float(level_datasets[quad_levels[0]][\"latitude\"].min()) - pad,\n", + " float(level_datasets[quad_levels[0]][\"latitude\"].max()) + pad,\n", + "]\n", + "\n", + "fig = plt.figure(figsize=(11, 9))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.set_extent(extent, crs=ccrs.PlateCarree())\n", + "\n", + "# One level per swath quadrant (row half × column half of the pixel grid).\n", + "quadrants = [(0, 0), (0, 1), (1, 0), (1, 1)]\n", + "for lvl, (row_half, col_half) in zip(quad_levels, quadrants):\n", + " band = level_datasets[lvl][BAND]\n", + " nr, nc = band.sizes[\"rows\"], band.sizes[\"columns\"]\n", + " piece = band.isel(\n", + " rows=slice(0, nr // 2) if row_half == 0 else slice(nr // 2, None),\n", + " columns=slice(0, nc // 2) if col_half == 0 else slice(nc // 2, None),\n", + " )\n", + " # xarray draws the curvilinear quads straight from the level's own\n", + " # 2-D centroid coordinates — nothing is resampled.\n", + " mesh = piece.plot.pcolormesh(\n", + " x=\"longitude\",\n", + " y=\"latitude\",\n", + " ax=ax,\n", + " transform=ccrs.PlateCarree(),\n", + " vmin=vmin,\n", + " vmax=vmax,\n", " cmap=\"viridis\",\n", " shading=\"nearest\",\n", + " add_colorbar=False,\n", " rasterized=True,\n", " )\n", " res = 1 if lvl == \".\" else int(lvl[1:])\n", - " name = \"native\" if lvl == \".\" else lvl\n", - " ax.set_title(f\"{name}: {band.shape[0]} × {band.shape[1]} native cells (1/{res} res)\")\n", - " ax.set_aspect(\"equal\")\n", - "fig.supxlabel(\"longitude\")\n", - "fig.supylabel(\"latitude\")\n", - "fig.colorbar(mesh, ax=axes, shrink=0.7, label=f\"{BAND} (scaled radiance)\")\n", - "fig.suptitle(f\"OLCI {BAND}: same swath, each level on its own native grid\")\n", + " ax.text(\n", + " float(piece[\"longitude\"].mean()),\n", + " float(piece[\"latitude\"].mean()),\n", + " f\"{lvl} (1/{res} res)\",\n", + " transform=ccrs.PlateCarree(),\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=12,\n", + " fontweight=\"bold\",\n", + " color=\"white\",\n", + " bbox={\"facecolor\": \"black\", \"alpha\": 0.55, \"pad\": 3},\n", + " )\n", + "\n", + "ax.coastlines(resolution=\"50m\", linewidth=0.8)\n", + "ax.add_feature(cfeature.BORDERS, linewidth=0.4, alpha=0.6)\n", + "# Label lat/lon with explicit ticks: cartopy's gridline auto-labels\n", + "# (draw_labels=True) blank the GeoAxes when a colorbar is added\n", + "# (cartopy 0.25 / matplotlib 3.11 incompatibility).\n", + "ax.gridlines(draw_labels=False, linewidth=0.3, alpha=0.5)\n", + "ax.set_xticks(np.arange(np.ceil(extent[0] / 5) * 5, extent[1], 5), crs=ccrs.PlateCarree())\n", + "ax.set_yticks(np.arange(np.ceil(extent[2] / 4) * 4, extent[3], 4), crs=ccrs.PlateCarree())\n", + "ax.xaxis.set_major_formatter(LongitudeFormatter())\n", + "ax.yaxis.set_major_formatter(LatitudeFormatter())\n", + "fig.colorbar(mesh, ax=ax, shrink=0.75, label=f\"{BAND} (scaled radiance)\")\n", + "ax.set_title(f\"OLCI {BAND}: one swath, each quadrant from a different pyramid level\")\n", "plt.show()" ] }, @@ -579,12 +628,12 @@ "id": "b4beef58", "metadata": {}, "source": [ - "All panels cover the same geographic swath, but each is drawn from that\n", - "level's own stored arrays — radiance plus its latitude/longitude, where each\n", - "cell's coordinate is the geodesic centroid of the pixel block it averages —\n", - "so the visible cell size is the level's true native resolution. The\n", - "coarsening from panel to panel is the multiscale pyramid itself, produced by\n", - "the single conversion above." + "The four quadrants tile the swath with no gaps or seams even though each is\n", + "drawn from a different stored array on a different grid: the levels agree on\n", + "*where* things are because every overview cell's latitude/longitude is the\n", + "geodesic centroid of the pixel block it averages. The blockiness that grows\n", + "from quadrant to quadrant is each level's true native resolution — the\n", + "multiscale pyramid itself, placed on the map without any resampling." ] } ], diff --git a/pyproject.toml b/pyproject.toml index 39a4cce2..756cfcbd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -72,6 +72,7 @@ docs = [ "mike>=2.1.3", ] notebooks = [ + "cartopy>=0.23", "jupyter>=1.0.0", "matplotlib>=3.8.0", "nbformat>=5.9.0", diff --git a/uv.lock b/uv.lock index 3481a41f..b7a8c578 100644 --- a/uv.lock +++ b/uv.lock @@ -443,6 +443,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/87/42/e09974bc74ea2791f985dff3d7f06065d11abcc31da6c46fc5f83046516e/cachetools-7.1.0-py3-none-any.whl", hash = "sha256:05afd1d309309e7c8971db462b4cf516d93fa8c9aea1b906e26e61b4399d0d82", size = 16748, upload-time = "2026-05-01T21:20:02.879Z" }, ] +[[package]] +name = "cartopy" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyproj" }, + { name = "pyshp" }, + { name = "shapely" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/3f/ec3dee34237b696a486d566a6d3ae6550ae821836e0412bafdcbbec2cfd2/cartopy-0.25.0.tar.gz", hash = "sha256:55f1a390e5f3f075b221c7d91fb10258ad978db786c7930eba06eb45d28753fe", size = 10767728, upload-time = "2025-08-01T12:44:16.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/35/b19901cbe7f1b118dccbb9e655cda7d01a31ee1ecd67e5d2d8afe119f6d3/cartopy-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:060a7b835c0c4222c1067b6ffb2f9c18458abaa35b6624573a3aa37ecf55f4bf", size = 11006900, upload-time = "2025-08-01T12:43:57.708Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4f/09e824f86be09152ec0f1fa1fe69affbd34eac7a13b545e2e08b9b6bc8ff/cartopy-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:57717cb603aecff03ecfee1bc153bb4022c054fcd51a4214a1bb53e5a6f74465", size = 10994813, upload-time = "2025-08-01T12:44:00.069Z" }, + { url = "https://files.pythonhosted.org/packages/b9/30/7465b650110514fc5c9c3b59935264c35ab56f876322de34efa55367ee4e/cartopy-0.25.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53c256351433155ef51dde976557212f4e230b8cca4e5d0d9b9a2737ad92959d", size = 11799069, upload-time = "2025-08-01T12:44:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/1d/52/3a57ecb4598c33ee06b512d3686e46b3983e65abd6ec94c5262d01930ed9/cartopy-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:efedb82f38409b72becdfee02231126952816d33a68b1c584bd2136713036bfb", size = 10983127, upload-time = "2025-08-01T12:44:04.441Z" }, + { url = "https://files.pythonhosted.org/packages/8e/b9/0773ff8f1c755b8a362029e6910db87064d27ca021b060c48ce511ec98b7/cartopy-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a6fcd2df8039293096f957fc9c76e969b1a9715d12ab8cee1a6bdae0c6773b8b", size = 11007728, upload-time = "2025-08-01T12:44:06.64Z" }, + { url = "https://files.pythonhosted.org/packages/34/a6/75738630b7f64bca7afc6bc5de08ddf0c61f13563f2a1abf642373d1095e/cartopy-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e4def451617e6957169447fe6ecdad0f63ef2d2007e7d451dd7b9656ada57382", size = 10996613, upload-time = "2025-08-01T12:44:08.822Z" }, + { url = "https://files.pythonhosted.org/packages/19/0d/669d4bbeb36b87ba504409d85c68ec297e6f434ea6525424f8aa5f14abac/cartopy-0.25.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c388824cb13e4fa9c2901dc4fbb2dbe9547acd2f4a6a3440983d4e6c6973ae3", size = 11829044, upload-time = "2025-08-01T12:44:11.402Z" }, + { url = "https://files.pythonhosted.org/packages/01/ff/b46e2120abd99b2ff3d376dc91ed58ae8f0a052d57c242c9b140497573dd/cartopy-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:60bad14c072d16e3c96967638cd66eb5a62cf24bc70087bcbfc6b30a3872ed26", size = 10987060, upload-time = "2025-08-01T12:44:14.222Z" }, +] + [[package]] name = "cast-value-rs" version = "0.4.0" @@ -1124,6 +1148,7 @@ downstream-titiler = [ { name = "titiler-xarray" }, ] notebooks = [ + { name = "cartopy" }, { name = "jupyter" }, { name = "matplotlib" }, { name = "nbformat" }, @@ -1175,6 +1200,7 @@ downstream-titiler = [ { name = "titiler-xarray", specifier = ">=2.0.0" }, ] notebooks = [ + { name = "cartopy", specifier = ">=0.23" }, { name = "jupyter", specifier = ">=1.0.0" }, { name = "matplotlib", specifier = ">=3.8.0" }, { name = "nbformat", specifier = ">=5.9.0" }, @@ -3339,6 +3365,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d7/33/288b5868fa00846dacf249633719d747893e54aebd196b9968ac1878a5d3/pyright-1.1.410-py3-none-any.whl", hash = "sha256:5e961bed37cacf96b3f7cd7b1da39b350a9239aa2e69138d0e88f728cfaf296c", size = 6082448, upload-time = "2026-06-01T17:35:46.387Z" }, ] +[[package]] +name = "pyshp" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/58/8d9461f328b2878a4b1632db4189a68c77e0c87689830a7834f204302704/pyshp-3.1.4.tar.gz", hash = "sha256:0663762be72c67684c890decd888fb8e849e01a85ee6ef0346214b7329270453", size = 2225442, upload-time = "2026-06-29T16:55:14.621Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/40/f1c777c07866b9de9420627c79bd22141268256d78afb890feabc4a85d70/pyshp-3.1.4-py3-none-any.whl", hash = "sha256:5bdd39c8fe02a47fe8de9c3355c5efaa312ff5c7fc6b8156592df738246f6167", size = 73189, upload-time = "2026-06-29T16:55:13.226Z" }, +] + [[package]] name = "pystac" version = "1.14.3" @@ -3927,6 +3962,57 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, ] +[[package]] +name = "shapely" +version = "2.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" }, + { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" }, + { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" }, + { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" }, + { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" }, + { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" }, + { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" }, + { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" }, + { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" }, + { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" }, + { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" }, + { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" }, + { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" }, + { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" }, + { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c4/3ce4c2d9b6aabd27d26ec988f08cb877ba9e6e96086eff81bfea93e688c7/shapely-2.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223", size = 1831290, upload-time = "2025-09-24T13:51:13.56Z" }, + { url = "https://files.pythonhosted.org/packages/17/b9/f6ab8918fc15429f79cb04afa9f9913546212d7fb5e5196132a2af46676b/shapely-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c", size = 1641463, upload-time = "2025-09-24T13:51:14.972Z" }, + { url = "https://files.pythonhosted.org/packages/a5/57/91d59ae525ca641e7ac5551c04c9503aee6f29b92b392f31790fcb1a4358/shapely-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df", size = 2970145, upload-time = "2025-09-24T13:51:16.961Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cb/4948be52ee1da6927831ab59e10d4c29baa2a714f599f1f0d1bc747f5777/shapely-2.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf", size = 3073806, upload-time = "2025-09-24T13:51:18.712Z" }, + { url = "https://files.pythonhosted.org/packages/03/83/f768a54af775eb41ef2e7bec8a0a0dbe7d2431c3e78c0a8bdba7ab17e446/shapely-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4", size = 3980803, upload-time = "2025-09-24T13:51:20.37Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cb/559c7c195807c91c79d38a1f6901384a2878a76fbdf3f1048893a9b7534d/shapely-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc", size = 4133301, upload-time = "2025-09-24T13:51:21.887Z" }, + { url = "https://files.pythonhosted.org/packages/80/cd/60d5ae203241c53ef3abd2ef27c6800e21afd6c94e39db5315ea0cbafb4a/shapely-2.1.2-cp314-cp314-win32.whl", hash = "sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566", size = 1583247, upload-time = "2025-09-24T13:51:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/74/d4/135684f342e909330e50d31d441ace06bf83c7dc0777e11043f99167b123/shapely-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c", size = 1773019, upload-time = "2025-09-24T13:51:24.873Z" }, + { url = "https://files.pythonhosted.org/packages/a3/05/a44f3f9f695fa3ada22786dc9da33c933da1cbc4bfe876fe3a100bafe263/shapely-2.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a", size = 1834137, upload-time = "2025-09-24T13:51:26.665Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/4d57db45bf314573427b0a70dfca15d912d108e6023f623947fa69f39b72/shapely-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076", size = 1642884, upload-time = "2025-09-24T13:51:28.029Z" }, + { url = "https://files.pythonhosted.org/packages/5a/27/4e29c0a55d6d14ad7422bf86995d7ff3f54af0eba59617eb95caf84b9680/shapely-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1", size = 3018320, upload-time = "2025-09-24T13:51:29.903Z" }, + { url = "https://files.pythonhosted.org/packages/9f/bb/992e6a3c463f4d29d4cd6ab8963b75b1b1040199edbd72beada4af46bde5/shapely-2.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0", size = 3094931, upload-time = "2025-09-24T13:51:32.699Z" }, + { url = "https://files.pythonhosted.org/packages/9c/16/82e65e21070e473f0ed6451224ed9fa0be85033d17e0c6e7213a12f59d12/shapely-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26", size = 4030406, upload-time = "2025-09-24T13:51:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/7c/75/c24ed871c576d7e2b64b04b1fe3d075157f6eb54e59670d3f5ffb36e25c7/shapely-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0", size = 4169511, upload-time = "2025-09-24T13:51:36.297Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f7/b3d1d6d18ebf55236eec1c681ce5e665742aab3c0b7b232720a7d43df7b6/shapely-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735", size = 1602607, upload-time = "2025-09-24T13:51:37.757Z" }, + { url = "https://files.pythonhosted.org/packages/9a/f6/f09272a71976dfc138129b8faf435d064a811ae2f708cb147dccdf7aacdb/shapely-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9", size = 1796682, upload-time = "2025-09-24T13:51:39.233Z" }, +] + [[package]] name = "simplejson" version = "4.1.1" From 36fb851950e6e9970d1490a624ac53c5b7a6a735 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Houpert?= <10154151+lhoupert@users.noreply.github.com> Date: Fri, 17 Jul 2026 10:22:09 +0100 Subject: [PATCH 41/58] fix(conversion): open sources with native-chunk-aligned reads and an atomic zarr CacheStore (#220) Some S2 conversions fail with "RuntimeError: error during blosc decompression: -1". Root cause is an fsspec bug open since 2021 (fsspec/filesystem_spec#639): simplecache writes a download straight to its final cache filename, so a concurrent read of the same key can observe a half-written file. Products whose quality/atmosphere aot/wvp are stored as one whole-array 10980x10980 chunk trigger it because dask (chunks="auto") splits that single object into ~9 read tasks fetching it concurrently (EOPF-Explorer/data-pipeline#339). open_source_datatree() (conversion/open_source.py) is the safe way to open a source: - opens with dask chunks matching the on-disk zarr chunks, so each object is fetched by exactly one task (removes the race trigger and the ~9x redundant downloads), and - an optional cache_dir replaces the pipeline's simplecache layer with zarr's built-in CacheStore over a LocalStore (suggested by @d-v-b in EOPF-Explorer/data-pipeline#339). LocalStore writes atomically (temp file + rename), so the half-written-file race cannot occur. Cache entries are namespaced per source URL to prevent cross-product collisions. The convert-s2-optimized CLI command now opens sources through this helper (generic convert/info/validate open sites are left for a follow-up). zarr is bounded to >=3.2.0,<3.3.0 while we depend on the experimental CacheStore API; the import is lazy and guarded so only the cache_dir path is affected if zarr moves it. History note: this branch previously carried a hand-rolled atomic fsspec cache (atomiccache) and an output chunk clamp; the former was replaced by the CacheStore wiring, the latter is split out to its own PR. Synthesized from commits acfd142, f950067, cf1a5d2, cd3eb00, da2f2c1. Co-authored-by: Claude Fable 5 --- pyproject.toml | 4 +- src/eopf_geozarr/cli.py | 6 +- src/eopf_geozarr/conversion/__init__.py | 2 + src/eopf_geozarr/conversion/open_source.py | 90 +++++++++++++ tests/test_open_source.py | 145 +++++++++++++++++++++ uv.lock | 2 +- 6 files changed, 243 insertions(+), 6 deletions(-) create mode 100644 src/eopf_geozarr/conversion/open_source.py create mode 100644 tests/test_open_source.py diff --git a/pyproject.toml b/pyproject.toml index 2e2ce41d..20cf7d5b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,7 +29,9 @@ requires-python = ">=3.12" dependencies = [ "pydantic-zarr>=0.8.0", "pydantic>=2.12", - "zarr[cast-value-rs]>=3.2.0", + # <3.3.0: open_source_datatree uses zarr's experimental CacheStore, whose + # location/API may change between minor releases; bump deliberately. + "zarr[cast-value-rs]>=3.2.0,<3.3.0", "xarray>=2025.7.1", "dask[array,distributed]>=2026.1.0", "numpy>=2.3.1", diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 5e4d95da..6a2f23e7 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -24,6 +24,7 @@ validate_s3_access, ) from .conversion.geozarr import get_zarr_group +from .conversion.open_source import open_source_datatree if TYPE_CHECKING: from dask.distributed import Client @@ -1243,10 +1244,7 @@ def convert_s2_optimized_command(args: argparse.Namespace) -> None: try: # Load input dataset log.info("Loading Sentinel-2 dataset from", input_path=args.input_path) - storage_options = get_storage_options(str(args.input_path)) - dt_input = xr.open_datatree( - str(args.input_path), engine="zarr", chunks="auto", storage_options=storage_options - ) + dt_input = open_source_datatree(str(args.input_path)) # Convert convert_s2_optimized( diff --git a/src/eopf_geozarr/conversion/__init__.py b/src/eopf_geozarr/conversion/__init__.py index 1a0e448a..1a292070 100644 --- a/src/eopf_geozarr/conversion/__init__.py +++ b/src/eopf_geozarr/conversion/__init__.py @@ -17,6 +17,7 @@ iterative_copy, setup_datatree_metadata_geozarr_spec_compliant, ) +from .open_source import open_source_datatree from .utils import ( calculate_aligned_chunk_size, downsample_2d_array, @@ -36,6 +37,7 @@ "is_s3_path", "iterative_copy", "open_s3_zarr_group", + "open_source_datatree", "parse_s3_path", "s3_path_exists", "setup_datatree_metadata_geozarr_spec_compliant", diff --git a/src/eopf_geozarr/conversion/open_source.py b/src/eopf_geozarr/conversion/open_source.py new file mode 100644 index 00000000..3cf5302b --- /dev/null +++ b/src/eopf_geozarr/conversion/open_source.py @@ -0,0 +1,90 @@ +"""Open source EOPF zarr stores with dask chunks aligned to native chunks. + +With ``chunks="auto"``, dask may split one on-disk zarr chunk into several +read tasks that each fetch and decompress the same object key — multiplying +egress and racing on shared cache files (EOPF-Explorer/data-pipeline#339). +``open_source_datatree`` opens with ``chunks={}`` (the store's native chunk +grid), so each zarr chunk is read by exactly one dask task; downstream +conversion code rechunks to its own output encoding anyway. Note that one +task then materializes one whole native chunk (~241 MB raw for cpm_v270 +aot/wvp) — under tight memory budgets, lower dask task concurrency rather +than sub-splitting stored chunks. +""" + +import hashlib +from pathlib import Path +from typing import Any + +import xarray as xr + +from .fs_utils import S3FsOptions, get_storage_options + + +def open_source_datatree( + path: str, + *, + storage_options: S3FsOptions | dict[str, Any] | None = None, + cache_dir: str | None = None, + engine: str = "zarr", +) -> xr.DataTree: + """Open a source datatree with dask chunks matching the native zarr chunks. + + Parameters + ---------- + path : str + Source store URL (local path, s3://, or https://). + storage_options : dict, optional + fsspec storage options. Defaults to ``get_storage_options(path)`` + (S3 credentials/endpoint for s3:// paths, None otherwise). + cache_dir : str, optional + Local directory for an on-disk read cache of source objects, backed + by zarr's ``CacheStore`` over a ``LocalStore``. LocalStore writes are + atomic (temp file + rename), so a concurrent read never sees a + partially downloaded object. Entries are namespaced per source URL + (CacheStore keys entries by relative zarr key, so different sources + sharing a directory would otherwise collide) and never expire; use an + ephemeral directory. + engine : str + xarray backend engine, default ``"zarr"``. + + Returns + ------- + xr.DataTree + Datatree whose dask arrays are chunked exactly on the store's native + chunk grid: each on-disk zarr chunk is read by exactly one dask task. + """ + if storage_options is None: + storage_options = get_storage_options(path) + if cache_dir is None: + return xr.open_datatree( + path, + engine=engine, + chunks={}, + storage_options=storage_options, + ) + # Imported lazily: CacheStore is zarr's experimental API, so a relocation + # in a future zarr release must not break importing this package. + try: + from zarr.experimental.cache_store import CacheStore + except ImportError as exc: + raise ImportError( + "cache_dir requires zarr.experimental.cache_store.CacheStore " + "(present in zarr 3.2.x). Your zarr version no longer provides " + "it; pin zarr accordingly or open without cache_dir." + ) from exc + from zarr.storage import FsspecStore, LocalStore + + source = FsspecStore.from_url( + path, + storage_options=dict(storage_options) if storage_options else None, + read_only=True, + ) + # CacheStore keys entries by relative zarr key ("aot/0.0" is the same key + # for every S2 product), so namespace the cache per source URL. Trailing + # slashes are stripped so equivalent URLs share a namespace. + cache_key = hashlib.sha256(path.rstrip("/").encode()).hexdigest()[:16] + source_cache = Path(cache_dir) / cache_key + cached = CacheStore(source, cache_store=LocalStore(source_cache)) + # xarray's open_datatree accepts a zarr store at runtime, but its stub does + # not list Store among the accepted input types. + return xr.open_datatree(cached, engine=engine, chunks={}) # pyright: ignore[reportArgumentType] diff --git a/tests/test_open_source.py b/tests/test_open_source.py new file mode 100644 index 00000000..89484e36 --- /dev/null +++ b/tests/test_open_source.py @@ -0,0 +1,145 @@ +"""Tests for open_source_datatree: native-chunk-aligned reads and the +per-source cache (EOPF-Explorer/data-pipeline#339).""" + +import os +import threading +from collections.abc import Iterator +from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer + +import numcodecs +import numpy as np +import pytest +import zarr + +from eopf_geozarr.conversion.open_source import open_source_datatree + + +def _build_source_store(store_path: str, seed: int = 42) -> str: + """Write a zarr v2 store mimicking a cpm_v270 source group. + + - ``aot``: ONE whole-array chunk (the pathological v270 layout) + - ``b02``: regular 32x32 tiles + + ``seed`` varies the values so two stores can share a key layout but differ + in content. + """ + group = zarr.open_group(store_path, mode="w", zarr_format=2) + rng = np.random.default_rng(seed) + + aot = group.create_array( + "aot", + shape=(128, 128), + chunks=(128, 128), + dtype="f8", + compressors=numcodecs.Blosc(cname="lz4", clevel=5, shuffle=1), + ) + aot[:] = rng.random((128, 128)) + aot.attrs["_ARRAY_DIMENSIONS"] = ["y", "x"] + + b02 = group.create_array( + "b02", + shape=(128, 128), + chunks=(32, 32), + dtype="f8", + compressors=numcodecs.Blosc(cname="lz4", clevel=5, shuffle=1), + ) + b02[:] = rng.random((128, 128)) + b02.attrs["_ARRAY_DIMENSIONS"] = ["y", "x"] + + zarr.consolidate_metadata(group.store) + return store_path + + +@pytest.fixture +def source_store(tmp_path) -> str: + return _build_source_store(str(tmp_path / "source.zarr")) + + +def test_single_chunk_array_is_one_dask_task(source_store) -> None: + dt = open_source_datatree(source_store) + assert dt["aot"].data.chunks == ((128,), (128,)) + + +def test_tiled_array_chunks_match_native_grid(source_store) -> None: + dt = open_source_datatree(source_store) + assert dt["aot"].data.chunks == ((128,), (128,)) + assert dt["b02"].data.chunks == ((32,) * 4, (32,) * 4) + + +def test_values_roundtrip(source_store) -> None: + dt = open_source_datatree(source_store) + aot_expected = np.asarray(zarr.open_array(source_store, mode="r", path="aot")[:]) + np.testing.assert_array_equal(dt["aot"].values, aot_expected) + + +def test_explicit_storage_options_are_forwarded_to_xarray(monkeypatch) -> None: + captured: dict[str, object] = {} + + def fake_open_datatree(path: object, **kwargs: object) -> None: + captured.update(kwargs) + raise InterruptedError("stop before any I/O") + + monkeypatch.setattr("xarray.open_datatree", fake_open_datatree) + sentinel = {"endpoint_url": "https://example.invalid"} + with pytest.raises(InterruptedError): + open_source_datatree("/some/store.zarr", storage_options=sentinel) + assert captured["storage_options"] == sentinel + assert captured["chunks"] == {} + + +@pytest.fixture +def http_source(source_store) -> Iterator[str]: + """Serve the source store over local HTTP (mimics the EODC https source).""" + root = os.path.dirname(source_store) + name = os.path.basename(source_store) + + class Handler(SimpleHTTPRequestHandler): + def __init__(self, *args: object, **kwargs: object) -> None: + super().__init__(*args, directory=root, **kwargs) # type: ignore[arg-type] + + def log_message(self, format: str, *args: object) -> None: + pass + + server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + threading.Thread(target=server.serve_forever, daemon=True).start() + yield f"http://127.0.0.1:{server.server_address[1]}/{name}" + server.shutdown() + + +def test_cache_dir_reads_correct_data_over_http(http_source, source_store, tmp_path) -> None: + """cache_dir reads return correct data and populate the cache, with no + leftover temp files. Atomicity of the cache writes themselves is zarr + LocalStore's contract (temp file + rename).""" + cache_dir = str(tmp_path / "source-cache") + dt = open_source_datatree(http_source, cache_dir=cache_dir) + + aot_expected = np.asarray(zarr.open_array(source_store, mode="r", path="aot")[:]) + np.testing.assert_array_equal(dt["aot"].values, aot_expected) + assert dt["aot"].data.chunks == ((128,), (128,)) # native alignment preserved + + cached_files = [f for _, _, fs in os.walk(cache_dir) for f in fs] + assert cached_files, "cache directory should be populated after reads" + assert not [f for f in cached_files if f.endswith(".partial")] + + +def test_two_sources_can_share_one_cache_dir(tmp_path) -> None: + """A shared cache_dir must never let one source serve another's bytes. + + CacheStore keys entries by zarr key ("aot/0.0" is identical for every S2 + product), so open_source_datatree namespaces the cache per source URL. + """ + first = _build_source_store(str(tmp_path / "first.zarr"), seed=1) + second = _build_source_store(str(tmp_path / "second.zarr"), seed=2) + shared_cache = str(tmp_path / "shared-cache") + + dt_first = open_source_datatree(first, cache_dir=shared_cache) + np.testing.assert_array_equal( + dt_first["aot"].values, + np.asarray(zarr.open_array(first, mode="r", path="aot")[:]), + ) + + dt_second = open_source_datatree(second, cache_dir=shared_cache) + np.testing.assert_array_equal( + dt_second["aot"].values, + np.asarray(zarr.open_array(second, mode="r", path="aot")[:]), + ) diff --git a/uv.lock b/uv.lock index a7c71ef4..bbeb7613 100644 --- a/uv.lock +++ b/uv.lock @@ -854,7 +854,7 @@ requires-dist = [ { name = "structlog", specifier = ">=25.5.0" }, { name = "typing-extensions", specifier = ">=4.15.0" }, { name = "xarray", specifier = ">=2025.7.1" }, - { name = "zarr", extras = ["cast-value-rs"], specifier = ">=3.2.0" }, + { name = "zarr", extras = ["cast-value-rs"], specifier = ">=3.2.0,<3.3.0" }, { name = "zarr-cm", specifier = ">=0.4.1" }, ] From cc8766411e681e5513cf7f6b447c29a1a66c6247 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 17 Jul 2026 10:22:54 +0100 Subject: [PATCH 42/58] chore: release 0.10.2 (#187) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .release-please-manifest.json | 2 +- CHANGELOG.md | 10 ++++++++++ pyproject.toml | 2 +- 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index e1a24428..31ed71b1 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.10.1" + ".": "0.10.2" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 20c5c3be..7319ccb4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## 0.10.2 (2026-07-17) + +## What's Changed +* ci(deps): bump the actions group with 3 updates by @dependabot[bot] in https://github.com/EOPF-Explorer/data-model/pull/185 +* bump zarr conventions; migrate type checking to pyright by @d-v-b in https://github.com/EOPF-Explorer/data-model/pull/199 +* fix(conversion): concurrent-safe source opening (native-chunk-aligned reads + atomic CacheStore) for data-pipeline#339 by @lhoupert in https://github.com/EOPF-Explorer/data-model/pull/220 + + +**Full Changelog**: https://github.com/EOPF-Explorer/data-model/compare/v0.10.1...v0.10.2 + ## 0.10.1 (2026-06-09) ## What's Changed diff --git a/pyproject.toml b/pyproject.toml index 20cf7d5b..d908faf3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "eopf-geozarr" -version = "0.10.1" +version = "0.10.2" description = "GeoZarr compliant data model for EOPF datasets" readme = "README.md" license = { text = "Apache-2.0" } From a4a6973c1db992cdee1a88a9d0825fd4c0da5e6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Houpert?= <10154151+lhoupert@users.noreply.github.com> Date: Fri, 17 Jul 2026 13:52:34 +0100 Subject: [PATCH 43/58] chore: re-lock uv.lock after merging main Co-Authored-By: Claude Fable 5 --- uv.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uv.lock b/uv.lock index 49379c2e..6a1eaacc 100644 --- a/uv.lock +++ b/uv.lock @@ -1109,7 +1109,7 @@ wheels = [ [[package]] name = "eopf-geozarr" -version = "0.10.1" +version = "0.10.2" source = { editable = "." } dependencies = [ { name = "aiohttp" }, From 5ea5662361d3127e0dcb912dd56937eecd7b2a34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Houpert?= <10154151+lhoupert@users.noreply.github.com> Date: Fri, 17 Jul 2026 14:13:54 +0100 Subject: [PATCH 44/58] fix(s3-olci): open OLCI sources with native-chunk-aligned reads MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port EOPF-Explorer/data-model#220 to the OLCI converter paths: both OLCI source opens (convert routing re-open and convert-s3-olci-optimized) used chunks="auto", which lets dask sub-split stored zarr chunks into multiple read tasks — duplicate egress/decompression and cache races under EOPF-Explorer/data-pipeline#339. open_source_datatree gains a mask_and_scale passthrough since the OLCI converter requires raw packed input. Co-Authored-By: Claude Fable 5 --- src/eopf_geozarr/cli.py | 13 ++----------- src/eopf_geozarr/conversion/open_source.py | 13 ++++++++++++- tests/test_open_source.py | 17 +++++++++++++++++ 3 files changed, 31 insertions(+), 12 deletions(-) diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index e9c0e28f..3784532e 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -244,10 +244,8 @@ def convert_command(args: argparse.Namespace) -> None: # the generic path, so close it and re-open raw, matching # convert_s3_olci_optimized_command. dt.close() - dt_raw = xr.open_datatree( + dt_raw = open_source_datatree( str(input_path), - engine="zarr", - chunks="auto", storage_options=storage_options, mask_and_scale=False, ) @@ -1406,14 +1404,7 @@ def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: """Execute S3 OLCI optimized conversion command.""" - storage_options = get_storage_options(str(args.input_path)) - dt_input = xr.open_datatree( - str(args.input_path), - engine="zarr", - chunks="auto", - storage_options=storage_options, - mask_and_scale=False, - ) + dt_input = open_source_datatree(str(args.input_path), mask_and_scale=False) convert_olci_optimized( dt_input, output_path=args.output_path, diff --git a/src/eopf_geozarr/conversion/open_source.py b/src/eopf_geozarr/conversion/open_source.py index 3cf5302b..d43d9530 100644 --- a/src/eopf_geozarr/conversion/open_source.py +++ b/src/eopf_geozarr/conversion/open_source.py @@ -26,6 +26,7 @@ def open_source_datatree( storage_options: S3FsOptions | dict[str, Any] | None = None, cache_dir: str | None = None, engine: str = "zarr", + mask_and_scale: bool = True, ) -> xr.DataTree: """Open a source datatree with dask chunks matching the native zarr chunks. @@ -46,6 +47,10 @@ def open_source_datatree( ephemeral directory. engine : str xarray backend engine, default ``"zarr"``. + mask_and_scale : bool + Forwarded to ``xr.open_datatree``. Pass ``False`` to keep variables + packed (e.g. uint16 with CF scale_factor/add_offset in ``.attrs``) + instead of CF-decoding to floats, as the OLCI converter requires. Returns ------- @@ -61,6 +66,7 @@ def open_source_datatree( engine=engine, chunks={}, storage_options=storage_options, + mask_and_scale=mask_and_scale, ) # Imported lazily: CacheStore is zarr's experimental API, so a relocation # in a future zarr release must not break importing this package. @@ -87,4 +93,9 @@ def open_source_datatree( cached = CacheStore(source, cache_store=LocalStore(source_cache)) # xarray's open_datatree accepts a zarr store at runtime, but its stub does # not list Store among the accepted input types. - return xr.open_datatree(cached, engine=engine, chunks={}) # pyright: ignore[reportArgumentType] + return xr.open_datatree( + cached, # pyright: ignore[reportArgumentType] + engine=engine, + chunks={}, + mask_and_scale=mask_and_scale, + ) diff --git a/tests/test_open_source.py b/tests/test_open_source.py index 89484e36..66a674c2 100644 --- a/tests/test_open_source.py +++ b/tests/test_open_source.py @@ -87,6 +87,23 @@ def fake_open_datatree(path: object, **kwargs: object) -> None: assert captured["chunks"] == {} +def test_mask_and_scale_is_forwarded_to_xarray(monkeypatch) -> None: + captured: dict[str, object] = {} + + def fake_open_datatree(path: object, **kwargs: object) -> None: + captured.update(kwargs) + raise InterruptedError("stop before any I/O") + + monkeypatch.setattr("xarray.open_datatree", fake_open_datatree) + with pytest.raises(InterruptedError): + open_source_datatree("/some/store.zarr", storage_options={}) + assert captured["mask_and_scale"] is True + + with pytest.raises(InterruptedError): + open_source_datatree("/some/store.zarr", storage_options={}, mask_and_scale=False) + assert captured["mask_and_scale"] is False + + @pytest.fixture def http_source(source_store) -> Iterator[str]: """Serve the source store over local HTTP (mimics the EODC https source).""" From 4121f9453767c4b5ae3e2cebbdf6e99546d63f01 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 11:24:15 +0200 Subject: [PATCH 45/58] fix(s3-olci): write native resolution to measurements/r0 so the store opens with xr.open_datatree MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The converter previously wrote the full-resolution arrays directly in measurements/ with overview groups (r2, r4, ...) nested beneath, declared as "asset": "." in the multiscales layout. Overview children then inherited the parent's 2-D latitude/longitude coordinates over the shared rows/columns dims at mismatched sizes, so xr.open_datatree — and any generic GeoZarr reader, e.g. titiler — rejected the store with an alignment error (reported on PR #212 from a real S3A scene). Native-resolution arrays now live in measurements/r0 as a named sibling of the overview groups (the Sentinel-2 pattern); measurements/ itself carries only the multiscales/spatial convention metadata, with the layout referencing "r0" instead of ".". This makes the hand-built DataTree workaround (which silently omitted overview children) unnecessary: convert_olci_optimized now returns xr.open_datatree(output) directly, and a new acceptance test pins that the whole exported store opens cleanly. Snapshot regenerated; docs and demo notebook updated and re-executed against the real EODC product. Assisted-by: ClaudeCode:claude-fable-5 --- README.md | 9 +- docs/converter.md | 5 +- docs/notebooks/sentinel3_olci_geozarr.ipynb | 187 +- .../s3_olci_optimization/olci_converter.py | 56 +- ...084255_0179_132_149_2160_PS1_O_NT_004.json | 3887 +++++++++-------- tests/test_olci_integration.py | 80 +- 6 files changed, 2109 insertions(+), 2115 deletions(-) diff --git a/README.md b/README.md index fc52893b..f2f51109 100644 --- a/README.md +++ b/README.md @@ -327,11 +327,12 @@ Key flags: #### What is converted -- **`/measurements`**: all 21 OLCI radiance bands at native full resolution, with - GeoZarr `spatial:` convention metadata and per-pixel 2-D `latitude`/`longitude` - coordinate arrays. +- **`/measurements/r0`**: all 21 OLCI radiance bands at native full resolution, + with per-pixel 2-D `latitude`/`longitude` coordinate arrays; the parent + `measurements/` group carries the GeoZarr `spatial:` and `multiscales` + convention metadata. - **Overview subgroups** (`r2`, `r4`, …): /2-decimated copies of the measurements - stored as sibling Zarr groups under `measurements/`. + stored as sibling Zarr groups next to `r0` under `measurements/`. - **`/conditions` and `/quality`**: copied through unmodified. > **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid diff --git a/docs/converter.md b/docs/converter.md index 39697cb0..3ea6211e 100644 --- a/docs/converter.md +++ b/docs/converter.md @@ -216,8 +216,9 @@ eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ ``` output.zarr/ -├── measurements/ # Native-resolution OLCI bands (oa01_radiance … oa21_radiance) -│ │ # with per-pixel latitude/longitude coordinates +├── measurements/ # Carries multiscales + spatial: convention metadata +│ ├── r0/ # Native-resolution OLCI bands (oa01_radiance … oa21_radiance) +│ │ # with per-pixel latitude/longitude coordinates │ ├── r2/ # 1/2-resolution overview │ ├── r4/ # 1/4-resolution overview │ └── ... diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index 1ca7536b..b8bd5237 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -30,10 +30,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:23.118582Z", - "iopub.status.busy": "2026-06-23T10:17:23.118408Z", - "iopub.status.idle": "2026-06-23T10:17:24.799718Z", - "shell.execute_reply": "2026-06-23T10:17:24.799151Z" + "iopub.execute_input": "2026-07-27T09:17:19.024518Z", + "iopub.status.busy": "2026-07-27T09:17:19.024425Z", + "iopub.status.idle": "2026-07-27T09:17:21.144560Z", + "shell.execute_reply": "2026-07-27T09:17:21.143809Z" } }, "outputs": [], @@ -76,10 +76,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:24.802088Z", - "iopub.status.busy": "2026-06-23T10:17:24.801845Z", - "iopub.status.idle": "2026-06-23T10:17:25.546984Z", - "shell.execute_reply": "2026-06-23T10:17:25.546382Z" + "iopub.execute_input": "2026-07-27T09:17:21.147088Z", + "iopub.status.busy": "2026-07-27T09:17:21.146831Z", + "iopub.status.idle": "2026-07-27T09:17:21.956110Z", + "shell.execute_reply": "2026-07-27T09:17:21.955271Z" } }, "outputs": [ @@ -146,10 +146,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.548827Z", - "iopub.status.busy": "2026-06-23T10:17:25.548535Z", - "iopub.status.idle": "2026-06-23T10:17:25.552958Z", - "shell.execute_reply": "2026-06-23T10:17:25.552363Z" + "iopub.execute_input": "2026-07-27T09:17:21.958453Z", + "iopub.status.busy": "2026-07-27T09:17:21.958291Z", + "iopub.status.idle": "2026-07-27T09:17:21.962690Z", + "shell.execute_reply": "2026-07-27T09:17:21.961998Z" } }, "outputs": [ @@ -191,10 +191,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.554630Z", - "iopub.status.busy": "2026-06-23T10:17:25.554431Z", - "iopub.status.idle": "2026-06-23T10:17:25.629450Z", - "shell.execute_reply": "2026-06-23T10:17:25.628795Z" + "iopub.execute_input": "2026-07-27T09:17:21.964544Z", + "iopub.status.busy": "2026-07-27T09:17:21.964364Z", + "iopub.status.idle": "2026-07-27T09:17:22.032730Z", + "shell.execute_reply": "2026-07-27T09:17:22.032128Z" } }, "outputs": [ @@ -218,8 +218,9 @@ "source": [ "## 3. Convert to GeoZarr\n", "\n", - "`convert_olci_optimized` writes the native measurements group plus `/2`\n", - "block-averaged overview subgroups (`r2`, `r4`, …) down to `min_dimension`, and\n", + "`convert_olci_optimized` writes the native-resolution measurements to the\n", + "`measurements/r0` subgroup, plus `/2` block-averaged overview subgroups\n", + "(`r2`, `r4`, …) as siblings of `r0` down to `min_dimension`, and\n", "declares them with the GeoZarr `multiscales` convention. `conditions` and\n", "`quality` are copied through unchanged.\n", "\n", @@ -233,10 +234,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:17:25.631065Z", - "iopub.status.busy": "2026-06-23T10:17:25.630958Z", - "iopub.status.idle": "2026-06-23T10:18:59.861715Z", - "shell.execute_reply": "2026-06-23T10:18:59.861003Z" + "iopub.execute_input": "2026-07-27T09:17:22.034444Z", + "iopub.status.busy": "2026-07-27T09:17:22.034346Z", + "iopub.status.idle": "2026-07-27T09:18:59.603654Z", + "shell.execute_reply": "2026-07-27T09:18:59.603008Z" } }, "outputs": [ @@ -244,161 +245,161 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:17:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + "\u001b[2m2026-07-27 11:17:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:17:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + "\u001b[2m2026-07-27 11:17:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:07\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:14\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:18\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:29\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:26\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:32\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:30\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:34\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:57\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 11:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Pyramid levels (native + overviews): ['.', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512']\n" + "Pyramid levels (native + overviews): ['r0', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512']\n" ] } ], @@ -407,8 +408,9 @@ "convert_olci_optimized(dt_input, output_path=output_path, min_dimension=4)\n", "\n", "store = zarr.open_group(output_path, mode=\"r\")\n", - "# Overview levels are the rN subgroups under measurements (exclude e.g. orphans).\n", - "levels = [\".\"] + sorted(\n", + "# Pyramid levels are the rN subgroups under measurements (exclude e.g. orphans):\n", + "# r0 is native resolution, r2/r4/… are the overviews.\n", + "levels = sorted(\n", " (k for k in store[\"measurements\"].group_keys() if k.startswith(\"r\")),\n", " key=lambda k: int(k[1:]),\n", ")\n", @@ -422,8 +424,8 @@ "source": [ "### Load one band at every pyramid level\n", "\n", - "Level `.` is the native resolution written at the measurements group root;\n", - "`r2`, `r4`, … are successively coarser block-averaged overviews. We read with\n", + "Level `r0` is the native resolution; `r2`, `r4`, … are successively coarser\n", + "block-averaged overviews. We read with\n", "default decoding so the stored `uint16` radiance is scaled to physical units\n", "for display." ] @@ -434,69 +436,18 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:18:59.864062Z", - "iopub.status.busy": "2026-06-23T10:18:59.863872Z", - "iopub.status.idle": "2026-06-23T10:19:00.100825Z", - "shell.execute_reply": "2026-06-23T10:19:00.100149Z" + "iopub.execute_input": "2026-07-27T09:18:59.605591Z", + "iopub.status.busy": "2026-07-27T09:18:59.605486Z", + "iopub.status.idle": "2026-07-27T09:18:59.826567Z", + "shell.execute_reply": "2026-07-27T09:18:59.825769Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - " .: shape (4090, 4865)\n", + " r0: shape (4090, 4865)\n", " r2: shape (2045, 2432)\n", " r4: shape (1022, 1216)\n", " r8: shape (511, 608)\n", @@ -507,17 +458,6 @@ "r256: shape (15, 19)\n", "r512: shape (7, 9)\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" - ] } ], "source": [ @@ -525,8 +465,7 @@ "\n", "\n", "def read_level(level: str) -> xr.DataArray:\n", - " group = \"measurements\" if level == \".\" else f\"measurements/{level}\"\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", " return ds[BAND]\n", "\n", "\n", @@ -558,16 +497,16 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-06-23T10:19:00.103316Z", - "iopub.status.busy": "2026-06-23T10:19:00.103038Z", - "iopub.status.idle": "2026-06-23T10:19:04.459494Z", - "shell.execute_reply": "2026-06-23T10:19:04.458850Z" + "iopub.execute_input": "2026-07-27T09:18:59.828435Z", + "iopub.status.busy": "2026-07-27T09:18:59.828249Z", + "iopub.status.idle": "2026-07-27T09:19:03.967999Z", + "shell.execute_reply": "2026-07-27T09:19:03.967438Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -585,7 +524,7 @@ " return a[np.ix_(row_idx, col_idx)]\n", "\n", "\n", - "native = level_arrays[\".\"]\n", + "native = level_arrays[\"r0\"]\n", "ny, nx = native.shape\n", "hy, hx = ny // 2, nx // 2\n", "\n", diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 462fb395..1aad6997 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -171,9 +171,10 @@ def convert_olci_optimized( ) -> xr.DataTree: """Convert an EOPF OLCI L1 EFR DataTree to a GeoZarr multiscale store. - Writes the native-resolution ``measurements`` group with GeoZarr - convention metadata, then writes /2-reduced overview subgroups - (``r2``, ``r4``, …) down to *min_dimension*. Any ``conditions`` or + Writes the native-resolution arrays to ``measurements/r0``, then writes + /2-reduced overview subgroups (``r2``, ``r4``, …) as siblings of ``r0`` + down to *min_dimension*; the ``measurements`` group carries the GeoZarr + convention metadata tying the levels together. Any ``conditions`` or ``quality`` groups present in *dt_input* are copied through unchanged, along with any child subgroups of ``measurements`` (e.g. ``orphans``). @@ -208,13 +209,10 @@ def convert_olci_optimized( ------- xr.DataTree The opened output DataTree (lazy; backed by the written Zarr store). - Overview subgroups (``r2``, ``r4``, …) are written to the Zarr store - but are **not** represented as children of the returned DataTree, - because xarray enforces dimension consistency between parent and child - nodes and the overview subgroups have smaller spatial dimensions than - the parent ``measurements`` group. To read them, open the store - directly with ``zarr.open_group(output_path)["measurements"]["r2"]`` - etc. + Native-resolution arrays live at ``measurements/r0`` with overview + levels (``r2``, ``r4``, …) as sibling groups; ``measurements`` itself + holds only the multiscales/spatial convention metadata, so the whole + store opens cleanly with ``xr.open_datatree``. Notes ----- @@ -237,10 +235,16 @@ def convert_olci_optimized( # correctly with raw integer data. measurements = _sanitize_data_vars(measurements) + # The native-resolution arrays go in a named child group (r0) alongside the + # overview groups (r2, r4, …) rather than directly in ``measurements``. + # If the parent held the full-res coordinates itself, every overview child + # would inherit them over the shared rows/columns dims at mismatched sizes + # and ``xr.open_datatree`` (and any generic GeoZarr reader) would reject + # the store with an alignment error. log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) measurements.to_zarr( output_path, - group="measurements", + group="measurements/r0", mode="w", consolidated=False, zarr_format=3, @@ -270,12 +274,12 @@ def convert_olci_optimized( # Build and attach GeoZarr convention metadata (spatial + multiscales CMO) # to the measurements group attrs. - layout: list[LayoutObject] = [{"asset": "."}] + layout: list[LayoutObject] = [{"asset": "r0"}] for lvl in range(1, n_levels + 1): transform: Transform = {"scale": [2.0, 2.0], "translation": [0.0, 0.0]} lo: LayoutObject = { "asset": f"r{2**lvl}", - "derived_from": "." if lvl == 1 else f"r{2 ** (lvl - 1)}", + "derived_from": f"r{2 ** (lvl - 1)}" if lvl > 1 else "r0", "transform": transform, "resampling_method": "average", } @@ -314,23 +318,9 @@ def convert_olci_optimized( log.info("Copying measurements subgroup", group=f"measurements/{child.name}") _copy_subtree(child, output_path, root_group=f"measurements/{child.name}") - # xarray DataTree enforces dimension consistency between parent and child - # nodes, so opening the whole store via ``xr.open_datatree`` would fail - # because the overview subgroups have smaller spatial dimensions than - # the parent ``measurements`` group. Instead, we build the DataTree - # manually from the top-level groups only: overview levels (r2, r4, …) - # are in the zarr store and accessible via ``zarr.open_group``, but are - # intentionally not exposed as DataTree children. - root = zarr.open_group(output_path, mode="r") - tree_dict: dict[str, xr.Dataset] = {} - for key in root.group_keys(): - child = root[key] - if isinstance(child, zarr.Group) and list(child.array_keys()): - tree_dict[f"/{key}"] = xr.open_dataset( - output_path, - engine="zarr", - group=key, - chunks={}, - consolidated=False, - ) - return xr.DataTree.from_dict(tree_dict) + return xr.open_datatree( + output_path, + engine="zarr", + chunks={}, + consolidated=False, + ) diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index a5dc9079..115ae6af 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -2306,11 +2306,11 @@ "multiscales": { "layout": [ { - "asset": "." + "asset": "r0" }, { "asset": "r2", - "derived_from": ".", + "derived_from": "r0", "resampling_method": "average", "transform": { "scale": [ @@ -2349,1336 +2349,1917 @@ ] }, "members": { - "altitude": { - "attributes": { - "dimensions": [ - "rows", - "columns" - ], - "dtype": " None: g = zarr.open_group(out, mode="r") # native measurements present assert "measurements" in g - # all 21 bands at native res + # all 21 bands at native res, in the r0 base-level group meas = g["measurements"] + assert isinstance(meas, zarr.Group) + r0 = meas["r0"] + assert isinstance(r0, zarr.Group) for i in range(1, 22): - assert f"oa{i:02d}_radiance" in meas + assert f"oa{i:02d}_radiance" in r0 def test_convert_olci_creates_overviews(tmp_path: object) -> None: @@ -92,9 +95,9 @@ def test_convert_olci_creates_overviews(tmp_path: object) -> None: g1 = zarr.open_group(out1, mode="r") meas1 = g1["measurements"] assert isinstance(meas1, zarr.Group) - subgroups1 = list(meas1.group_keys()) - assert len(subgroups1) == 0, ( - f"Expected 0 overview levels for 512x480 at min_dimension=256, got {subgroups1}" + subgroups1 = sorted(meas1.group_keys()) + assert subgroups1 == ["r0"], ( + f"Expected only the r0 base level for 512x480 at min_dimension=256, got {subgroups1}" ) # --- Case 2: 1024x1024, min_dimension=256 → exactly two valid levels --- @@ -106,11 +109,12 @@ def test_convert_olci_creates_overviews(tmp_path: object) -> None: meas2 = g2["measurements"] assert isinstance(meas2, zarr.Group) subgroups2 = sorted(meas2.group_keys()) - assert len(subgroups2) == 2, ( - f"Expected exactly 2 overview levels for 1024x1024 at min_dimension=256, got {subgroups2}" + assert subgroups2 == ["r0", "r2", "r4"], ( + f"Expected r0 + exactly 2 overview levels for 1024x1024 at min_dimension=256, " + f"got {subgroups2}" ) - # Every overview level must have BOTH spatial dims >= min_dimension. + # Every level must have BOTH spatial dims >= min_dimension. for sg_name in subgroups2: sg = meas2[sg_name] assert isinstance(sg, zarr.Group) @@ -143,6 +147,55 @@ def test_convert_olci_returns_datatree(tmp_path: object) -> None: assert "/measurements" in result.groups +def test_convert_olci_output_opens_as_datatree(tmp_path: object) -> None: + """Acceptance: ``xr.open_datatree`` must open the exported store cleanly. + + Full-resolution arrays live in ``measurements/r0`` as a named sibling of + the overview groups (``r2``, …), so no child group inherits mismatched + parent coordinates. The multiscales layout references the base level by + name (``"asset": "r0"``), not ``"."``. This is the layout generic GeoZarr + readers (e.g. titiler) require; see the discussion on PR #212. + """ + dt = build_synthetic_olci(rows=1024, cols=1024) + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + result = convert_olci_optimized(dt, output_path=out, min_dimension=256) + + opened = xr.open_datatree(out, engine="zarr", consolidated=False, chunks={}) + + r0 = opened["/measurements/r0"].to_dataset() + assert dict(r0.sizes) == {"rows": 1024, "columns": 1024} + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in r0 + assert "latitude" in r0.coords + assert "longitude" in r0.coords + + r2 = opened["/measurements/r2"].to_dataset() + assert dict(r2.sizes) == {"rows": 512, "columns": 512} + r4 = opened["/measurements/r4"].to_dataset() + assert dict(r4.sizes) == {"rows": 256, "columns": 256} + + # The measurements group itself holds only convention metadata: no arrays, + # so children with differing sizes inherit nothing conflicting. + meas = opened["/measurements"].to_dataset() + assert len(meas.data_vars) == 0 + assert len(meas.coords) == 0 + + meas_attrs = dict(zarr.open_group(out, mode="r")["measurements"].attrs) + multiscales = meas_attrs["multiscales"] + assert isinstance(multiscales, dict) + layout = multiscales["layout"] + assert isinstance(layout, list) + assert layout[0] == {"asset": "r0"} + first_overview = layout[1] + assert isinstance(first_overview, dict) + assert first_overview["asset"] == "r2" + assert first_overview["derived_from"] == "r0" + + # The returned DataTree must expose the same structure as the store. + assert "/measurements/r0" in result.groups + assert "/measurements/r2" in result.groups + + def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: """conditions and quality groups, when present, are copied through unchanged.""" import zarr @@ -317,7 +370,9 @@ def test_olci_conversion_matches_snapshot( # scale_factor preserved and stale source attrs absent. meas_g = observed_group["measurements"] assert isinstance(meas_g, zarr.Group) - _assert_radiance_dtype_and_attrs(meas_g, "oa01_radiance", level_label="native") + r0_g = meas_g["r0"] + assert isinstance(r0_g, zarr.Group) + _assert_radiance_dtype_and_attrs(r0_g, "oa01_radiance", level_label="r0") if "r2" in meas_g: r2_g = meas_g["r2"] assert isinstance(r2_g, zarr.Group) @@ -347,13 +402,14 @@ def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) - g = _zarr.open_group(out, mode="r") meas = g["measurements"] assert isinstance(meas, _zarr.Group) - overview_keys = sorted(meas.group_keys()) + level_keys = sorted(meas.group_keys()) # With rows=10, cols=9, min_dimension=4: # floor(9/2)=4 >= 4 → r2 generated # floor(4/2)=2 < 4 → stop - assert overview_keys == ["r2"], ( - f"Expected exactly ['r2'] for 10x9 at min_dimension=4, got {overview_keys}" + assert level_keys == ["r0", "r2"], ( + f"Expected exactly ['r0', 'r2'] for 10x9 at min_dimension=4, got {level_keys}" ) + overview_keys = [k for k in level_keys if k != "r0"] # Open each overview level; this must NOT raise a conflicting-sizes error. for lvl in overview_keys: From 73cc5119dee68a85e174ad12ffcb3bc179bc614d Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 12:23:48 +0200 Subject: [PATCH 46/58] docs: design for OLCI reprojection to regular grid with CRS Assisted-by: ClaudeCode:claude-fable-5 --- .../2026-07-27-s3-olci-reprojection-design.md | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md diff --git a/docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md b/docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md new file mode 100644 index 00000000..3f440f66 --- /dev/null +++ b/docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md @@ -0,0 +1,92 @@ +# Sentinel-3 OLCI reprojection to a regular grid — design + +Date: 2026-07-27 +Status: approved +Context: PR #212 review feedback (titiler cannot tile unprojected swath data); +supersedes the "native swath geometry, no reprojection" choice in +[2026-06-21-sentinel3-olci-export-design.md](2026-06-21-sentinel3-olci-export-design.md). + +## Problem + +The OLCI converter writes measurements in instrument (swath) geometry with +per-pixel 2-D `latitude`/`longitude` arrays and no declared CRS. Generic +GeoZarr readers cannot serve xyz tiles from this: without a projected grid +there is no geotransform (confirmed by titiler maintainers on PR #212), and +without `grid_mapping`/`spatial_ref`, `ds.rio.crs` is `None` — the same gap +Sentinel-1 had (#176/#201). + +Decision (with maintainer sign-off on the PR thread): **reprojection to a +regular grid is a hard requirement for all converted products.** The OLCI +output contains only the reprojected grid; the swath representation is not +copied into the output (it remains in the source product). + +## Approach + +Warp with rasterio's dense geolocation-array support (rasterio >= 1.4; +repo has 1.5.0). No new dependencies; no GCP subsampling or polynomial +fitting — the full per-pixel geolocation is used directly. + +Rejected alternatives: reusing the Sentinel-1 GCP path (discards geolocation +density; polynomial transformer distorts the curved swath), and pyresample +(new heavyweight dependency for something rasterio already does here). + +## Converter flow + +In `convert_olci_optimized`, after the existing encoding-strip and +attr-sanitize steps: + +1. **Warp once at native resolution.** Pass the 2-D `latitude`/`longitude` + coordinate arrays as `src_geoloc_array` to + `rasterio.warp.calculate_default_transform` (grid sizing, ~native 300 m + resolution preserved) and `rasterio.warp.reproject` (per-band warp). + Target CRS defaults to `EPSG:4326`; exposed as `target_crs` on the entry + point and `--target-crs` on the CLI subcommand. +2. **Band handling.** Radiances stay raw `uint16` with CF + `scale_factor`/`add_offset` attrs. `_FillValue` (65535) doubles as warp + nodata, so off-swath cells are fill. Resampling: bilinear (linear scale + means averaging digital counts is exact in radiance space). +3. **Coordinates.** Output grid has 1-D `x`/`y` dimension coordinates derived + from the affine transform. The 2-D `altitude` coordinate is warped onto + the grid as a variable. Per-scan-line `time_stamp` has no home on a + regular grid and is dropped (documented; it survives in the source + product). +4. **Pyramid.** Overviews build as today — fill-aware /2 block averaging — + on the grid, in `measurements/r0`, `r2`, … sibling groups. 1-D + coordinates decimate by simple striding consistent with the coarsen trim. + +## CRS metadata (both idioms, per level) + +- `rio.write_crs`: a `spatial_ref` variable plus `grid_mapping` attr on every + band — what titiler/rioxarray require (closes the #176/#201-style gap). +- zarr-cm `geo-proj` convention attrs via the existing + `build_convention_attrs(crs=...)` path. +- `swath_spatial_attrs()` is replaced by gridded spatial attrs carrying the + real affine transform. The multiscales layout keeps `r0`-relative entries + with per-level scale transforms. + +## Tests + +**Cross-product contract** — new `tests/test_geozarr_output_contract.py`, +one parametrized acceptance test over each converter's output (S1, S2, OLCI; +reusing their existing synthetic fixtures): + +- store opens via `xr.open_datatree`; +- every measurement level reports `ds.rio.crs is not None`; +- spatial dims have 1-D regular coordinate arrays; +- the declared CRS round-trips through pyproj. + +**OLCI unit tests** (per repo test-structure convention): one behavior test +for the warp helper (correct output grid, fill propagation outside the +swath, dtype preservation) and one test per error case (missing geolocation +coordinates; degenerate/empty extent). + +**Regeneration:** OLCI golden snapshot regenerates; the demonstration +notebook re-executes against the real EODC product (the quadrant demo works +unchanged on the gridded pyramid). + +## Out of scope + +- `conditions`/`quality` groups stay passthrough in tie-point/swath form. +- No swath copy of measurements in the output. +- Encoding wiring for `--enable-sharding` / `--spatial-chunk` / + `--compression-level` / `--keep-scale-offset` (pre-existing follow-up). From 88808d9ee65b39d560d394e9043226884bc0bb59 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 16:35:14 +0200 Subject: [PATCH 47/58] docs: implementation plan for OLCI reprojection and cross-product CRS contract Assisted-by: ClaudeCode:claude-fable-5 --- .../plans/2026-07-27-s3-olci-reprojection.md | 1036 +++++++++++++++++ 1 file changed, 1036 insertions(+) create mode 100644 docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md diff --git a/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md b/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md new file mode 100644 index 00000000..f33147b1 --- /dev/null +++ b/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md @@ -0,0 +1,1036 @@ +# Sentinel-3 OLCI Reprojection Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Warp OLCI swath measurements to a regular EPSG:4326 grid with declared CRS metadata, and encode "reprojection is a hard requirement for all products" in a cross-product contract test. + +**Architecture:** A new `olci_reproject` module warps the native swath once via rasterio's dense geolocation-array support; the existing r0/r2/… pyramid then builds on the grid with 1-D `y`/`x` coordinates. CRS is declared per level in both idioms (rioxarray `spatial_ref`/`grid_mapping` + zarr-cm `geo-proj` convention). A parametrized contract test asserts the grid+CRS requirement for S1, S2, and OLCI outputs. + +**Tech Stack:** rasterio 1.5 (`calculate_default_transform`/`reproject` with `src_geoloc_array`), rioxarray, pyproj, zarr-cm via `eopf_geozarr.conversion.utils.build_convention_attrs`. + +**Spec:** `docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md` + +## Global Constraints + +- Never use `typing.Any` — use `object` or precise types and narrow (user rule). +- Conventional commits; every commit ends with trailer `Assisted-by: ClaudeCode:claude-fable-5`. No Co-Authored-By line. +- TDD: write the failing test, watch it fail, implement, watch it pass, commit. +- All commands run via `uv run …`. `uv run pyright` must stay at `0 errors`. +- Test structure rule: one behavior test covering reasonable input combinations + one test function per error case. +- Target CRS parameter default is exactly `"EPSG:4326"`; CLI flag is `--target-crs`. +- Snapshot regeneration uses the uncomment/run/re-comment block inside `test_olci_conversion_matches_snapshot` (never leave it uncommented in a commit). + +--- + +### Task 1: `reproject_olci` warp helper + +**Files:** +- Create: `src/eopf_geozarr/s3_olci_optimization/olci_reproject.py` +- Create: `tests/test_olci_reproject.py` + +**Interfaces:** +- Consumes: nothing new (rasterio/rioxarray already installed). +- Produces: `reproject_olci(ds: xr.Dataset, *, target_crs: str = "EPSG:4326", resampling: Resampling = Resampling.bilinear) -> xr.Dataset` and module constant `GRID_DIMS = ("y", "x")`. Output dataset: dims `("y", "x")`; 1-D `y`/`x` dimension coords; `spatial_ref` coordinate; every data var carries `grid_mapping: "spatial_ref"` and `_FillValue`; `ds.rio.crs` set. Raises `ValueError` on missing lat/lon coords and on degenerate (zero-area) geolocation extent. + +- [ ] **Step 1: Write the failing tests** + +Create `tests/test_olci_reproject.py`: + +```python +"""Tests for OLCI swath -> regular grid reprojection.""" + +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_reproject import reproject_olci + +FILL = 65535 + + +def build_rotated_swath(rows: int = 64, cols: int = 60, angle_deg: float = 30.0) -> xr.Dataset: + """Synthetic OLCI-like swath: regular grid rotated by *angle_deg* in lon/lat. + + Rotation matters: it makes the dst bounding-box corners fall outside the + swath, exercising real geolocation warping and off-swath fill. + """ + rr, cc = np.meshgrid( + np.arange(rows, dtype="float64"), np.arange(cols, dtype="float64"), indexing="ij" + ) + theta = np.deg2rad(angle_deg) + lon = 10.0 + 0.01 * (cc * np.cos(theta) - rr * np.sin(theta)) + lat = 45.0 + 0.01 * (cc * np.sin(theta) + rr * np.cos(theta)) + + band = (100.0 * rr + cc).astype("uint16") + band[:4, :4] = FILL # a filled block inside the swath + da = xr.DataArray( + band, + dims=("rows", "columns"), + attrs={"scale_factor": 0.0139, "add_offset": 0.0, "_FillValue": FILL}, + ) + time_stamp = xr.DataArray( + np.arange(rows).astype("datetime64[ns]"), dims=("rows",) + ) + return xr.Dataset( + {"oa01_radiance": da}, + coords={ + "latitude": (("rows", "columns"), lat), + "longitude": (("rows", "columns"), lon), + "altitude": (("rows", "columns"), np.full((rows, cols), 7, dtype="int16")), + "time_stamp": time_stamp, + }, + ) + + +def test_reproject_olci_produces_regular_grid_with_crs() -> None: + """One behavior test: grid shape, CRS, dtype, attrs, fill, and dropped vars.""" + ds = build_rotated_swath() + out = reproject_olci(ds) + + # Regular 1-D coordinate grid over (y, x) + assert set(out.sizes) == {"y", "x"} + for dim in ("y", "x"): + coord = out[dim] + assert coord.ndim == 1 + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]) + # y descends (north-up grid) + assert out["y"].values[0] > out["y"].values[-1] + + # CRS declared in both idioms + assert out.rio.crs is not None + assert out.rio.crs.to_epsg() == 4326 + assert "spatial_ref" in out.coords or "spatial_ref" in out.variables + assert out["oa01_radiance"].attrs["grid_mapping"] == "spatial_ref" + + # dtype and CF scaling preserved; fill recorded + band = out["oa01_radiance"] + assert band.dtype == np.dtype("uint16") + assert band.attrs["scale_factor"] == 0.0139 + assert int(band.attrs["_FillValue"]) == FILL + + # Off-swath cells (bbox corners of a rotated swath) are fill + vals = band.values + assert vals[0, 0] == FILL + assert vals[-1, -1] == FILL + # …and real data survived the warp + valid = vals[vals != FILL] + assert valid.size > 0 + assert valid.max() <= (100.0 * 64 + 60) + + # altitude warped onto the grid; per-scan-line time_stamp dropped + assert "altitude" in out.data_vars + assert out["altitude"].dims == ("y", "x") + assert "time_stamp" not in out.variables + + +def test_reproject_olci_missing_geolocation_raises() -> None: + ds = build_rotated_swath().drop_vars("latitude") + with pytest.raises(ValueError, match="latitude"): + reproject_olci(ds) + + +def test_reproject_olci_degenerate_extent_raises() -> None: + ds = build_rotated_swath() + ds = ds.assign_coords( + latitude=(("rows", "columns"), np.full((64, 60), 45.0)), + longitude=(("rows", "columns"), np.full((64, 60), 10.0)), + ) + with pytest.raises(ValueError, match="degenerate"): + reproject_olci(ds) +``` + +- [ ] **Step 2: Run tests to verify they fail** + +Run: `uv run pytest tests/test_olci_reproject.py -v` +Expected: FAIL (all three) with `ModuleNotFoundError: No module named 'eopf_geozarr.s3_olci_optimization.olci_reproject'` + +- [ ] **Step 3: Write the implementation** + +Create `src/eopf_geozarr/s3_olci_optimization/olci_reproject.py`: + +```python +"""Reprojection of OLCI swath measurements to a regular grid. + +OLCI L1 EFR is a curvilinear swath geolocated by dense per-pixel 2-D +latitude/longitude arrays. Generic GeoZarr readers (titiler, rioxarray) +require a regular grid with an affine transform and a declared CRS, so the +converter warps the swath once at native resolution using rasterio's +geolocation-array support (``src_geoloc_array``, rasterio >= 1.4). +""" + +from __future__ import annotations + +import numpy as np +import rioxarray # noqa: F401 # enables the .rio accessor +import structlog +import xarray as xr +from pyproj import CRS as ProjCRS +from rasterio.crs import CRS +from rasterio.warp import Resampling, calculate_default_transform, reproject + +log = structlog.get_logger() + +#: CRS of the OLCI geolocation arrays (per-pixel lat/lon in degrees). +GEOLOC_CRS = "EPSG:4326" + +#: Dimension names of the reprojected regular grid. +GRID_DIMS: tuple[str, str] = ("y", "x") + +_SWATH_DIMS = ("rows", "columns") + + +def _nodata_for(var: xr.DataArray) -> float: + """Warp nodata for *var*: its ``_FillValue`` if present, else a dtype default. + + Integer variables without a fill value get the dtype maximum (matching the + OLCI convention of 65535 for uint16 radiances); floats get NaN. + """ + fill = var.attrs.get("_FillValue") + if fill is None: + fill = var.encoding.get("_FillValue") + if fill is not None: + return float(fill) + if np.issubdtype(var.dtype, np.integer): + return float(np.iinfo(var.dtype).max) + return float("nan") + + +def _grid_coord_attrs(target_crs: str) -> tuple[dict[str, str], dict[str, str]]: + """CF attrs for the 1-D (y, x) dimension coordinates in *target_crs*.""" + if ProjCRS.from_user_input(target_crs).is_geographic: + y_attrs = {"standard_name": "latitude", "units": "degrees_north", "axis": "Y"} + x_attrs = {"standard_name": "longitude", "units": "degrees_east", "axis": "X"} + else: + y_attrs = {"standard_name": "projection_y_coordinate", "units": "m", "axis": "Y"} + x_attrs = {"standard_name": "projection_x_coordinate", "units": "m", "axis": "X"} + return y_attrs, x_attrs + + +def reproject_olci( + ds: xr.Dataset, + *, + target_crs: str = "EPSG:4326", + resampling: Resampling = Resampling.bilinear, +) -> xr.Dataset: + """Warp an OLCI swath dataset onto a regular *target_crs* grid. + + Every numeric variable spanning exactly ``(rows, columns)`` — radiance + bands and the 2-D ``altitude`` coordinate alike — is warped onto a common + grid sized by :func:`rasterio.warp.calculate_default_transform` from the + dense per-pixel geolocation (~native resolution preserved). The + ``latitude``/``longitude`` geolocation arrays are consumed by the warp and + replaced by 1-D ``y``/``x`` dimension coordinates. Variables that carry a + swath dim but cannot live on the grid (e.g. per-scan-line ``time_stamp``) + are dropped; variables without swath dims pass through unchanged. + + Off-swath cells are set to each variable's ``_FillValue`` (dtype max for + integer variables without one), and ``_FillValue`` is recorded in the + output attrs so downstream fill-aware averaging keeps working. + + Raises + ------ + ValueError + If the 2-D ``latitude``/``longitude`` coordinates are missing, or if + the geolocation spans a zero-area (degenerate) extent. + """ + for required in ("latitude", "longitude"): + if required not in ds.coords: + raise ValueError( + f"cannot reproject OLCI swath: missing 2-D coordinate {required!r}" + ) + lat = ds.coords["latitude"] + lon = ds.coords["longitude"] + if tuple(str(d) for d in lat.dims) != _SWATH_DIMS or lat.dims != lon.dims: + raise ValueError("latitude/longitude must be 2-D over (rows, columns)") + lat_vals = np.asarray(lat.values, dtype="float64") + lon_vals = np.asarray(lon.values, dtype="float64") + if lat_vals.max() == lat_vals.min() or lon_vals.max() == lon_vals.min(): + raise ValueError( + "degenerate geolocation extent: latitude/longitude span zero area" + ) + + src_height, src_width = lat_vals.shape + geoloc = np.stack([lon_vals, lat_vals]) # (2, H, W): x first, then y + transform, width, height = calculate_default_transform( + src_crs=CRS.from_string(GEOLOC_CRS), + dst_crs=CRS.from_string(target_crs), + width=src_width, + height=src_height, + src_geoloc_array=geoloc, + ) + assert width is not None + assert height is not None + log.info( + "Reprojecting OLCI swath", + target_crs=target_crs, + src_shape=(src_height, src_width), + dst_shape=(height, width), + ) + + result_vars: dict[str, xr.DataArray] = {} + passthrough_coords: dict[str, xr.DataArray] = {} + all_names = [str(k) for k in ds.data_vars] + [ + str(k) for k in ds.coords if str(k) not in ("latitude", "longitude") + ] + for name in all_names: + var = ds[name] if name in ds.data_vars else ds.coords[name] + var_dims = tuple(str(d) for d in var.dims) + if var_dims == _SWATH_DIMS and np.issubdtype(var.dtype, np.number): + nodata = _nodata_for(var) + src_nodata = ( + nodata + if (var.attrs.get("_FillValue") is not None + or var.encoding.get("_FillValue") is not None) + else None + ) + dest = np.full((height, width), nodata, dtype=var.dtype) + reproject( + source=np.ascontiguousarray(var.values), + destination=dest, + src_crs=CRS.from_string(GEOLOC_CRS), + src_geoloc_array=geoloc, + src_nodata=src_nodata, + dst_crs=CRS.from_string(target_crs), + dst_transform=transform, + dst_nodata=nodata, + resampling=resampling, + ) + out_attrs = dict(var.attrs) + if np.issubdtype(var.dtype, np.integer): + out_attrs["_FillValue"] = int(nodata) + elif not np.isnan(nodata): + out_attrs["_FillValue"] = float(nodata) + out_attrs.pop("coordinates", None) # swath geolocation is gone + result_vars[name] = xr.DataArray(dest, dims=GRID_DIMS, attrs=out_attrs) + elif any(d in var_dims for d in _SWATH_DIMS): + log.info("Dropping swath-bound variable with no grid home", variable=name) + elif name in ds.coords: + passthrough_coords[name] = var + else: + result_vars[name] = var + + xs = transform.c + transform.a * (np.arange(width) + 0.5) + ys = transform.f + transform.e * (np.arange(height) + 0.5) + y_attrs, x_attrs = _grid_coord_attrs(target_crs) + out = xr.Dataset( + result_vars, + coords={ + "y": ("y", ys, y_attrs), + "x": ("x", xs, x_attrs), + **passthrough_coords, + }, + attrs=dict(ds.attrs), + ) + out = out.rio.write_crs(target_crs) + if not isinstance(out, xr.Dataset): + raise TypeError( + f"expected an xarray.Dataset after write_crs, got {type(out).__name__}" + ) + # rioxarray records grid_mapping in encoding; pin it in attrs so it is + # guaranteed to reach the zarr store. + for name in out.data_vars: + out[name].attrs["grid_mapping"] = "spatial_ref" + return out +``` + +- [ ] **Step 4: Run tests to verify they pass** + +Run: `uv run pytest tests/test_olci_reproject.py -v` +Expected: 3 passed. If `test_reproject_olci_produces_regular_grid_with_crs` fails on the corner-fill assertions, print `band.values[0, 0]` — a rotated swath must leave bbox corners at fill; investigate the warp call rather than weakening the test. + +- [ ] **Step 5: Run pyright and commit** + +Run: `uv run pyright` — expected `0 errors`. + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_reproject.py tests/test_olci_reproject.py +git commit -m "feat(s3-olci): add swath-to-grid reprojection via rasterio geolocation arrays + +Assisted-by: ClaudeCode:claude-fable-5" +``` + +--- + +### Task 2: Generalize `reduce_swath`/`decimate_swath` to grid dims + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` + +**Interfaces:** +- Consumes: nothing from Task 1. +- Produces: `decimate_swath(ds, factor=2, *, dims: tuple[str, str] = SWATH_DIMS)` and `reduce_swath(ds, factor=2, *, dims: tuple[str, str] = SWATH_DIMS)`. Existing call sites without `dims` behave identically; Task 4 calls `reduce_swath(current, factor=2, dims=("y", "x"))`. + +- [ ] **Step 1: Write the failing test** + +Append to `tests/test_olci_multiscale.py`: + +```python +def test_reduce_swath_on_grid_dims() -> None: + """reduce_swath(dims=("y","x")) block-averages bands and strides 1-D coords. + + After reprojection the pyramid dims are (y, x): bands average fill-aware, + the 1-D dimension coordinates decimate by trimmed stride, and non-spatial + variables (spatial_ref) pass through unchanged. + """ + ny, nx = 6, 5 # odd x exercises the coarsen-trim alignment + band = np.arange(ny * nx, dtype="uint16").reshape(ny, nx) + ds = xr.Dataset( + {"oa01_radiance": (("y", "x"), band, {"_FillValue": 65535})}, + coords={ + "y": ("y", np.linspace(46.0, 45.0, ny)), + "x": ("x", np.linspace(10.0, 11.0, nx)), + "spatial_ref": ((), 0, {"crs_wkt": "stub"}), + }, + ) + out = reduce_swath(ds, factor=2, dims=("y", "x")) + assert dict(out.sizes) == {"y": 3, "x": 2} + # block mean of the top-left 2x2 block, rounded + expected00 = round((band[0, 0] + band[0, 1] + band[1, 0] + band[1, 1]) / 4) + assert int(out["oa01_radiance"].values[0, 0]) == expected00 + # 1-D coords: trimmed stride, lengths match the data + assert out["y"].size == 3 + assert out["x"].size == 2 + np.testing.assert_allclose(out["x"].values, ds["x"].values[0:4:2]) + # scalar passthrough survives + assert "spatial_ref" in out.coords + assert out["spatial_ref"].attrs["crs_wkt"] == "stub" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py::test_reduce_swath_on_grid_dims -v` +Expected: FAIL with `TypeError: reduce_swath() got an unexpected keyword argument 'dims'` + +- [ ] **Step 3: Implement** + +In `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py`, thread `dims` through both functions. Signatures: + +```python +def decimate_swath( + ds: xr.Dataset, factor: int = 2, *, dims: tuple[str, str] = SWATH_DIMS +) -> xr.Dataset: +``` + +```python +def reduce_swath( + ds: xr.Dataset, factor: int = 2, *, dims: tuple[str, str] = SWATH_DIMS +) -> xr.Dataset: +``` + +Inside both function bodies, replace every use of the module constant `SWATH_DIMS` with the `dims` parameter (five sites: the `indexers` comprehension in `decimate_swath`; and in `reduce_swath` the `dim_trim` comprehension, the `is_swath_2d` comparison, the coarsen dict — change `{"rows": factor, "columns": factor}` to `{dims[0]: factor, dims[1]: factor}` — and the two stride-indexer comprehensions). Update both docstrings' first lines to say "spanning the *dims* spatial dimensions (default ``(rows, columns)``)". Do not change `SWATH_DIMS` itself or `OLCI_BANDS` handling. + +- [ ] **Step 4: Run tests to verify pass (new + existing)** + +Run: `uv run pytest tests/test_olci_multiscale.py -v` +Expected: all pass (existing swath-dims tests confirm default behavior unchanged). + +- [ ] **Step 5: Run pyright and commit** + +Run: `uv run pyright` — expected `0 errors`. + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "refactor(s3-olci): parameterize reduce/decimate over spatial dims for gridded pyramids + +Assisted-by: ClaudeCode:claude-fable-5" +``` + +--- + +### Task 3: `grid_spatial_attrs` helper + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` + +**Interfaces:** +- Consumes: nothing from earlier tasks. +- Produces: `grid_spatial_attrs(transform: Affine, shape: tuple[int, int]) -> SpatialAttrs` (shape is `(height, width)`). Task 4 calls it per pyramid level. `swath_spatial_attrs` stays for now — Task 4 deletes it with its call site. + +- [ ] **Step 1: Write the failing test** + +Append to `tests/test_olci_multiscale.py`: + +```python +def test_grid_spatial_attrs() -> None: + """grid_spatial_attrs derives dimensions, bbox, and 6-element transform.""" + transform = rasterio.transform.from_origin(10.0, 46.0, 0.01, 0.01) + attrs = grid_spatial_attrs(transform, (100, 200)) + assert attrs["spatial:dimensions"] == ["y", "x"] + assert attrs["spatial:registration"] == "pixel" + assert attrs["spatial:transform"] == [0.01, 0.0, 10.0, 0.0, -0.01, 46.0] + # bbox is [xmin, ymin, xmax, ymax] from array_bounds + assert attrs["spatial:bbox"] == [10.0, 45.0, 12.0, 46.0] +``` + +Add the imports at the top of the test file: `import rasterio.transform` and extend the existing `olci_multiscale` import with `grid_spatial_attrs`. + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py::test_grid_spatial_attrs -v` +Expected: FAIL with `ImportError: cannot import name 'grid_spatial_attrs'` + +- [ ] **Step 3: Implement** + +In `olci_multiscale.py` add (with `import rasterio.transform` at module top and `from affine import Affine` under `TYPE_CHECKING`): + +```python +def grid_spatial_attrs(transform: Affine, shape: tuple[int, int]) -> SpatialAttrs: + """Spatial-convention data for a regular grid with an affine *transform*. + + *shape* is ``(height, width)``. Emits ``spatial:dimensions`` ``["y","x"]``, + pixel registration, the bounding box, and the 6-element row-major affine + transform — the gridded counterpart of :func:`swath_spatial_attrs`. + """ + height, width = shape + left, bottom, right, top = rasterio.transform.array_bounds(height, width, transform) + return { + "spatial:dimensions": ["y", "x"], + "spatial:registration": "pixel", + "spatial:bbox": [float(left), float(bottom), float(right), float(top)], + "spatial:transform": [ + float(transform.a), + float(transform.b), + float(transform.c), + float(transform.d), + float(transform.e), + float(transform.f), + ], + } +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `uv run pytest tests/test_olci_multiscale.py -v` +Expected: all pass. + +- [ ] **Step 5: Run pyright and commit** + +Run: `uv run pyright` — expected `0 errors`. + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): add gridded spatial-convention attrs with affine transform + +Assisted-by: ClaudeCode:claude-fable-5" +``` + +--- + +### Task 4: Integrate reprojection into `convert_olci_optimized` + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` +- Modify: `tests/test_olci_integration.py` +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` (delete `swath_spatial_attrs`) +- Modify: `tests/test_olci_multiscale.py` (delete `swath_spatial_attrs` tests) + +**Interfaces:** +- Consumes: `reproject_olci`, `GRID_DIMS` (Task 1); `reduce_swath(..., dims=...)` (Task 2); `grid_spatial_attrs` (Task 3). +- Produces: `convert_olci_optimized(..., target_crs: str = "EPSG:4326")`. Output store: `measurements/r0..rN` on a regular grid, per-level `spatial_ref` + `grid_mapping` + zarr-cm spatial/geo-proj attrs; parent `measurements` carries multiscales + spatial + geo-proj. Task 5 (CLI) and Task 6 (contract test) rely on this signature and layout. + +- [ ] **Step 1: Fix the degenerate synthetic fixture and update the acceptance test (RED)** + +In `tests/test_olci_integration.py`, replace the lat/lon construction in `build_synthetic_olci` (currently a flattened `linspace` reshape — collinear in lon/lat and therefore unwarpable): + +```python +def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: + """Minimal synthetic OLCI L1 EFR datatree (measurements only). + + Geolocation is an axis-aligned ~300 m grid (0.003 deg spacing) so the + dataset is genuinely warpable to a regular lat/lon grid. + """ + rng = np.random.default_rng(0) + lat_1d = np.linspace(45.0, 45.0 + 0.003 * (rows - 1), rows) + lon_1d = np.linspace(10.0, 10.0 + 0.003 * (cols - 1), cols) + lat = np.repeat(lat_1d[:, None], cols, axis=1) + lon = np.repeat(lon_1d[None, :], rows, axis=0) + alt = np.zeros((rows, cols), dtype="int16") +``` + +(keep the band-building loop and Dataset assembly unchanged below this point). + +Apply the same replacement to the inline lat/lon in `test_convert_olci_conditions_quality_passthrough` (the `128, 128` case): + +```python + lat_1d = np.linspace(45.0, 45.0 + 0.003 * (rows - 1), rows) + lon_1d = np.linspace(10.0, 10.0 + 0.003 * (cols - 1), cols) + lat = np.repeat(lat_1d[:, None], cols, axis=1) + lon = np.repeat(lon_1d[None, :], rows, axis=0) +``` + +Rewrite `test_convert_olci_output_opens_as_datatree` for the gridded contract (warped sizes are ~input sizes but not exact, so assert structure relative to observed r0): + +```python +def test_convert_olci_output_opens_as_datatree(tmp_path: object) -> None: + """Acceptance: the exported store is a regular grid with CRS at every level. + + xr.open_datatree must open the whole store; measurements/r0 holds the + warped native-resolution grid with 1-D y/x coordinates and a declared + CRS, overview siblings halve it, and the multiscales layout references + the base level by name. + """ + dt = build_synthetic_olci(rows=1024, cols=1024) + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + result = convert_olci_optimized(dt, output_path=out, min_dimension=256) + + opened = xr.open_datatree(out, engine="zarr", consolidated=False, chunks={}) + + r0 = opened["/measurements/r0"].to_dataset() + assert set(r0.sizes) == {"y", "x"} + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in r0 + # CRS declared at every level, 1-D regular coordinates + for level in ("r0", "r2", "r4"): + ds = opened[f"/measurements/{level}"].to_dataset() + assert ds.rio.crs is not None, f"{level}: no CRS" + assert ds.rio.crs.to_epsg() == 4326 + for dim in ("y", "x"): + coord = ds[dim] + assert coord.ndim == 1 + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]) + band = ds["oa01_radiance"] + assert band.attrs["grid_mapping"] == "spatial_ref" + # halving structure relative to observed r0 + r2 = opened["/measurements/r2"].to_dataset() + assert r2.sizes["y"] == r0.sizes["y"] // 2 + assert r2.sizes["x"] == r0.sizes["x"] // 2 + + # measurements itself holds only convention metadata + meas = opened["/measurements"].to_dataset() + assert len(meas.data_vars) == 0 + + meas_attrs = dict(zarr.open_group(out, mode="r")["measurements"].attrs) + multiscales = meas_attrs["multiscales"] + assert isinstance(multiscales, dict) + layout = multiscales["layout"] + assert isinstance(layout, list) + assert layout[0] == {"asset": "r0"} + # per-level geo-proj convention present + r0_attrs = dict(zarr.open_group(out, mode="r")["measurements"]["r0"].attrs) + assert "proj:code" in r0_attrs or any(k.startswith("proj:") for k in r0_attrs) + + assert "/measurements/r0" in result.groups + assert "/measurements/r2" in result.groups +``` + +Add `import rioxarray # noqa: F401` to the test file's imports. + +Note: before asserting on the exact `proj:` key, check what `proj_attrs_for_crs("EPSG:4326")` emits (`uv run python -c "from eopf_geozarr.conversion.utils import proj_attrs_for_crs; print(proj_attrs_for_crs('EPSG:4326'))"`) and pin the real key instead of the `any(...)` fallback. + +- [ ] **Step 2: Run to verify RED** + +Run: `uv run pytest tests/test_olci_integration.py::test_convert_olci_output_opens_as_datatree -v` +Expected: FAIL — r0 has dims `rows`/`columns` (no warp yet), `set(r0.sizes) == {"y", "x"}` assertion fails. + +- [ ] **Step 3: Implement converter changes** + +In `olci_converter.py`: + +1. Imports: replace the `swath_spatial_attrs` import with `grid_spatial_attrs`; add `from eopf_geozarr.s3_olci_optimization.olci_reproject import GRID_DIMS, reproject_olci` and `import rioxarray # noqa: F401`. +2. Signature: add `target_crs: str = "EPSG:4326"` after `keep_scale_offset`, and document it in the docstring ("Target CRS for the output grid; the swath is warped once at native resolution before the pyramid builds."). +3. After `measurements = _sanitize_data_vars(measurements)` insert: + +```python + measurements = reproject_olci(measurements, target_crs=target_crs) +``` + +4. Replace the two native-size reads: `rows = measurements.sizes["y"]` and `cols = measurements.sizes["x"]`. +5. Overview loop: `current = reduce_swath(current, factor=2, dims=GRID_DIMS)`; collect levels while writing — before the loop add `level_datasets: dict[str, xr.Dataset] = {"r0": measurements}` and inside the loop, after computing `group_name`, add `level_datasets[group_name] = current`. +6. Replace the convention-attrs block (the `if n_levels > 0:` section) with per-level + parent writes: + +```python + root_rw = zarr.open_group(output_path, mode="a") + base_transform = measurements.rio.transform(recalc=True) + base_spatial = grid_spatial_attrs( + base_transform, (measurements.sizes["y"], measurements.sizes["x"]) + ) + for group_name, level_ds in level_datasets.items(): + level_transform = level_ds.rio.transform(recalc=True) + level_conv = build_convention_attrs( + spatial=grid_spatial_attrs( + level_transform, (level_ds.sizes["y"], level_ds.sizes["x"]) + ), + crs=target_crs, + ) + root_rw[f"measurements/{group_name}"].attrs.update( + cast("dict[str, JSON]", level_conv) + ) + + if n_levels > 0: + ms: MultiscalesAttrs = {"layout": layout, "resampling_method": "average"} + conv = build_convention_attrs( + multiscales=ms, spatial=base_spatial, crs=target_crs + ) + else: + conv = build_convention_attrs(spatial=base_spatial, crs=target_crs) + + root_rw["measurements"].attrs.update(cast("dict[str, JSON]", conv)) +``` + +(The existing `zarr.open_group(output_path, mode="a")["measurements"].attrs.update(...)` line is replaced by this block; keep the `layout` construction above it unchanged.) + +7. Docstring: update the flow description to "warps the swath once to a regular *target_crs* grid, writes it to ``measurements/r0``, then /2-reduced overview siblings"; note that `time_stamp` is dropped (survives in the source product) and that every level carries `spatial_ref`/`grid_mapping` plus zarr-cm spatial/geo-proj attrs. +8. In `olci_multiscale.py` delete `swath_spatial_attrs` entirely; in `tests/test_olci_multiscale.py` delete its tests (search `swath_spatial_attrs`). + +- [ ] **Step 4: Run OLCI tests, fix the remaining old-layout assertions** + +Run: `uv run pytest tests/test_olci_integration.py tests/test_olci_multiscale.py -v` + +Expected initially: the acceptance test passes; these tests fail on swath-era assumptions and must be updated in place: + +- `test_convert_olci_creates_overviews`: replace exact-size expectations with structural ones — read the observed r0 sizes and assert (a) every level's dims `>= 256` for case 2, (b) each level halves the previous, and (c) the deepest level would violate `min_dimension` if halved again: + +```python + r0_2 = meas2["r0"] + assert isinstance(r0_2, zarr.Group) + band0 = r0_2["oa01_radiance"] + assert isinstance(band0, zarr.Array) + prev_shape = band0.shape + for sg_name in [k for k in subgroups2 if k != "r0"]: + sg = meas2[sg_name] + assert isinstance(sg, zarr.Group) + band = sg["oa01_radiance"] + assert isinstance(band, zarr.Array) + assert band.shape[0] == prev_shape[0] // 2 + assert band.shape[1] == prev_shape[1] // 2 + assert band.shape[0] >= 256 and band.shape[1] >= 256 + prev_shape = band.shape + assert prev_shape[0] // 2 < 256 or prev_shape[1] // 2 < 256 +``` + + For case 1 keep `subgroups1 == ["r0"]` only if the warped 512x480 grid still yields zero levels at `min_dimension=256` (halving 480-ish < 256 — it does). +- `test_convert_olci_odd_dims_overview_no_conflicting_sizes`: the warped grid's dims won't be exactly 10x9; keep the intent (coord/data length agreement at every level) by asserting, for each written level, `ds["oa01_radiance"].shape == (ds["y"].size, ds["x"].size)` and that each level floor-halves the previous; drop the exact `(5, 4)` assertion. +- Any test asserting `latitude`/`longitude` arrays exist in the output: update to `y`/`x` (`test_convert_olci_writes_measurements` band loop is unaffected). + +Then: `uv run pytest tests/test_olci_integration.py tests/test_olci_multiscale.py tests/test_olci_reproject.py -v` — all pass except `test_olci_conversion_matches_snapshot` (fails on degenerate zero geolocation — fixed in Task 5). + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_integration.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): reproject measurements to regular EPSG:4326 grid with per-level CRS + +Assisted-by: ClaudeCode:claude-fable-5" +``` + +--- + +### Task 5: Snapshot, CLI flag, docs, notebook + +**Files:** +- Modify: `tests/test_olci_integration.py` (snapshot test seeding) +- Regenerate: `tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json` +- Modify: `src/eopf_geozarr/cli.py` +- Modify: `README.md`, `docs/converter.md` +- Modify + re-execute: `docs/notebooks/sentinel3_olci_geozarr.ipynb` + +**Interfaces:** +- Consumes: `convert_olci_optimized(..., target_crs=...)` from Task 4. +- Produces: `--target-crs` CLI flag; regenerated golden snapshot; docs describing the gridded layout. + +- [ ] **Step 1: Seed real geolocation in the snapshot test** + +The golden fixture materializes arrays with no data (all zeros), which is now a degenerate geolocation. In `test_olci_conversion_matches_snapshot`, before the `xr.open_datatree(...)` call, add: + +```python + # The JSON fixture materializes arrays as zeros; zero lat/lon is a + # degenerate geolocation the warp rejects. Seed a plausible ~300 m grid. + fixture_group = zarr.open_group(str(s3_olci_group_example), mode="a") + fixture_meas = fixture_group["measurements"] + assert isinstance(fixture_meas, zarr.Group) + lat_arr = fixture_meas["latitude"] + assert isinstance(lat_arr, zarr.Array) + ny, nx = lat_arr.shape + lat_1d = np.linspace(45.0, 45.0 + 0.003 * (ny - 1), ny) + lon_1d = np.linspace(10.0, 10.0 + 0.003 * (nx - 1), nx) + lat_arr[:] = np.repeat(lat_1d[:, None], nx, axis=1) + lon_arr = fixture_meas["longitude"] + assert isinstance(lon_arr, zarr.Array) + lon_arr[:] = np.repeat(lon_1d[None, :], ny, axis=0) +``` + +Also update the `_assert_radiance_dtype_and_attrs` call sites if level group names changed (they did not — still `r0`/`r2`). + +- [ ] **Step 2: Regenerate the snapshot** + +Uncomment the regeneration block in `test_olci_conversion_matches_snapshot`, run: + +`uv run pytest "tests/test_olci_integration.py::test_olci_conversion_matches_snapshot" -v` + +then RE-COMMENT the block and re-run to confirm it passes against the committed file. Inspect the snapshot diff: expect `rows`/`columns` dims replaced by `y`/`x`, new `spatial_ref` arrays, `grid_mapping` attrs, per-level `proj:*`/`spatial:*` attrs, no `time_stamp`/`latitude`/`longitude` arrays under `measurements/r*`. + +- [ ] **Step 3: CLI flag** + +In `src/eopf_geozarr/cli.py`, in `add_s3_olci_optimization_commands` (after the `--keep-scale-offset` argument): + +```python + p.add_argument( + "--target-crs", + type=str, + default="EPSG:4326", + help="Target CRS for the reprojected output grid (default: EPSG:4326)", + ) +``` + +and in `convert_s3_olci_optimized_command`, pass `target_crs=args.target_crs` in the `convert_olci_optimized(...)` call. The auto-detect path in `convert` keeps the default (no change). + +Run: `uv run pytest tests/test_olci_integration.py::test_cli_convert_s3_olci_optimized -v` — expected PASS. + +- [ ] **Step 4: Docs** + +`README.md` "What is converted" OLCI section — replace the three bullets with: + +```markdown +- **`/measurements/r0`**: all 21 OLCI radiance bands warped once from the + native swath onto a regular grid (default `EPSG:4326`, ~300 m preserved), + with 1-D `y`/`x` coordinates, a `spatial_ref` variable, and `grid_mapping` + on every band; the parent `measurements/` group carries the GeoZarr + `multiscales`, `spatial:`, and `proj:` convention metadata. +- **Overview subgroups** (`r2`, `r4`, …): /2 fill-aware block-averaged copies + stored as sibling Zarr groups next to `r0`, each with its own CRS metadata. +- **`/conditions` and `/quality`**: copied through unmodified. +``` + +Add below the note: per-scan-line `time_stamp` is not representable on a regular grid and is dropped from the converted measurements (it remains in the source product). + +`docs/converter.md` OLCI section — update the "native swath geometry" paragraph to say measurements are reprojected to a regular grid (default EPSG:4326) with the swath geolocation consumed by the warp; update the output-layout tree (`r0/` line becomes "Warped native-resolution OLCI bands … with 1-D y/x coordinates and spatial_ref") and add a `--target-crs` row to the flag table: + +```markdown +| `--target-crs` | EPSG:4326 | Target CRS for the reprojected output grid | +``` + +Run: `uv run pytest tests/test_docs.py -v` — expected PASS (no executable snippets changed). + +- [ ] **Step 5: Notebook** + +Source edits in `docs/notebooks/sentinel3_olci_geozarr.ipynb` (edit with `uv run --with nbformat python` and `nbformat.read`/`write`, asserting each old string exists before replacing, as in the r0-layout change): + +- Conversion markdown cell: describe the warp ("`convert_olci_optimized` first warps the swath onto a regular EPSG:4326 grid using the per-pixel geolocation, then writes the `r0` base level plus /2 block-averaged overview siblings"). +- Add to the pyramid-levels code cell (after the `levels` print): `print("CRS:", xr.open_dataset(output_path, engine="zarr", group="measurements/r0").rio.crs)` and `import rioxarray # noqa: F401` in the imports cell. +- The offline-fallback path in cell 3 uses the zero-filled fixture, which the warp now rejects; extend the fallback to seed lat/lon exactly as in Task 5 Step 1 (same meshgrid code against the materialized fixture store) before opening it. + +Re-execute end-to-end (remote product has real geolocation): + +`uv run --with jupyter,nbconvert,ipykernel,matplotlib jupyter nbconvert --to notebook --execute --inplace --ExecutePreprocessor.timeout=1800 docs/notebooks/sentinel3_olci_geozarr.ipynb` + +Then verify with nbformat: zero error outputs, pyramid levels print `r0…`, the CRS print shows `EPSG:4326`, quadrant figure rendered. + +- [ ] **Step 6: Full verification and commit** + +Run: `uv run pytest tests/ -q -p no:warnings --deselect tests/test_cli_e2e.py` — expected: 0 failures. +Run: `uv run pyright` — expected `0 errors`. + +```bash +git add tests/test_olci_integration.py tests/_test_data/optimized_olci_examples/ src/eopf_geozarr/cli.py README.md docs/converter.md docs/notebooks/sentinel3_olci_geozarr.ipynb +git commit -m "feat(s3-olci): --target-crs flag, regenerated snapshot, gridded-layout docs and notebook + +Assisted-by: ClaudeCode:claude-fable-5" +``` + +--- + +### Task 6: Cross-product output contract test + +**Files:** +- Create: `tests/test_geozarr_output_contract.py` +- Modify: `tests/test_integration_sentinel2.py` (extract fixture body into an importable builder) + +**Interfaces:** +- Consumes: `convert_olci_optimized` (Task 4), `build_synthetic_olci` (Task 4 version), `MockSentinel1L1GRDBuilder` (exists in `tests/test_integration_sentinel1.py`), `create_geozarr_dataset` (exists), and the new `build_sample_sentinel2_datatree()`. +- Produces: the executable statement of "reprojection to a regular grid with CRS is a hard requirement for all products". + +- [ ] **Step 1: Extract the S2 fixture builder** + +In `tests/test_integration_sentinel2.py`, rename the body of the `sample_sentinel2_datatree` fixture into a module-level function and have the fixture delegate: + +```python +def build_sample_sentinel2_datatree() -> xr.DataTree: + """Build the sample Sentinel-2 EOPF DataTree (importable, non-fixture form).""" + # + + +@pytest.fixture +def sample_sentinel2_datatree() -> xr.DataTree: + """Create a sample Sentinel-2 EOPF DataTree structure for testing.""" + return build_sample_sentinel2_datatree() +``` + +Run: `uv run pytest tests/test_integration_sentinel2.py -q` — expected: unchanged results (refactor only). + +- [ ] **Step 2: Write the contract test (RED where it should be)** + +Create `tests/test_geozarr_output_contract.py`: + +```python +"""Cross-product output contract. + +Reprojection to a regular grid with a declared CRS is a hard requirement for +every converted product (see +docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md). One +parametrized test walks each converter's output and asserts the contract at +every multiscale level. Products whose converter has not yet migrated off the +legacy nested layout carry an xfail on the whole-store DataTree check so the +requirement stays on record. +""" + +from __future__ import annotations + +import pathlib +from collections.abc import Callable +from unittest.mock import patch + +import numpy as np +import pytest +import rioxarray # noqa: F401 +import xarray as xr +import zarr +from pyproj import CRS as ProjCRS + +from eopf_geozarr.conversion import create_geozarr_dataset +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + +from .test_integration_sentinel1 import MockSentinel1L1GRDBuilder +from .test_integration_sentinel2 import build_sample_sentinel2_datatree +from .test_olci_integration import build_synthetic_olci + + +def _convert_olci(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "olci.zarr" + convert_olci_optimized( + build_synthetic_olci(rows=256, cols=256), output_path=str(out), min_dimension=64 + ) + return out + + +def _convert_s1(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "s1.zarr" + dt = MockSentinel1L1GRDBuilder("20170508T164830_0025_A094_8604_01B54C").build() + with patch("eopf_geozarr.conversion.geozarr.print"): + create_geozarr_dataset( + dt, + groups=["measurements"], + output_path=str(out), + gcp_group="conditions/gcp", + ) + return out + + +def _convert_s2(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "s2.zarr" + with patch("eopf_geozarr.conversion.geozarr.print"): + create_geozarr_dataset( + build_sample_sentinel2_datatree(), + groups=["/measurements/reflectance/r10m"], + output_path=str(out), + ) + return out + + +PRODUCT_CONVERTERS: dict[str, Callable[[pathlib.Path], pathlib.Path]] = { + "olci": _convert_olci, + "s1": _convert_s1, + "s2": _convert_s2, +} + +#: Converters that still write the legacy layout (native at group root with +#: asset "."), which xr.open_datatree rejects. The xfail keeps the hard +#: requirement on record until the generic converter migrates (cf. PR #212). +DATATREE_XFAIL: dict[str, str] = { + "s1": "generic converter still writes asset='.' nested overview layout", + "s2": "generic converter still writes asset='.' nested overview layout", +} + + +@pytest.fixture(scope="module", params=sorted(PRODUCT_CONVERTERS), ids=str) +def converted_store( + request: pytest.FixtureRequest, tmp_path_factory: pytest.TempPathFactory +) -> tuple[pathlib.Path, str]: + name = str(request.param) + store = PRODUCT_CONVERTERS[name](tmp_path_factory.mktemp(name)) + return store, name + + +def _multiscale_level_paths(store: pathlib.Path) -> list[str]: + """Every pyramid-level group path, discovered via multiscales layout attrs.""" + root = zarr.open_group(str(store), mode="r") + found: list[str] = [] + + def walk(group: zarr.Group, path: str) -> None: + attrs = dict(group.attrs) + multiscales = attrs.get("multiscales") + if isinstance(multiscales, dict): + layout = multiscales.get("layout") + assert isinstance(layout, list) + for entry in layout: + assert isinstance(entry, dict) + asset = entry["asset"] + assert isinstance(asset, str) + found.append(path if asset == "." else f"{path}/{asset}" if path else asset) + for key in group.group_keys(): + child = group[key] + assert isinstance(child, zarr.Group) + walk(child, f"{path}/{key}" if path else key) + + walk(root, "") + return found + + +def test_every_level_is_regular_grid_with_crs( + converted_store: tuple[pathlib.Path, str], +) -> None: + """Hard requirement: each pyramid level is a regular grid with a real CRS.""" + store, name = converted_store + levels = _multiscale_level_paths(store) + assert levels, f"{name}: no multiscale groups found in {store}" + for level in levels: + ds = xr.open_dataset( + str(store), group=level, engine="zarr", consolidated=False + ) + crs = ds.rio.crs + assert crs is not None, f"{name}:{level}: no CRS declared" + # CRS round-trips through pyproj + ProjCRS.from_user_input(crs.to_wkt()) + for dim in ("y", "x"): + assert dim in ds.sizes, f"{name}:{level}: missing spatial dim {dim}" + coord = ds[dim] + assert coord.ndim == 1, f"{name}:{level}: {dim} coordinate is not 1-D" + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]), ( + f"{name}:{level}: {dim} coordinate spacing is not regular" + ) + ds.close() + + +def test_store_opens_as_datatree(converted_store: tuple[pathlib.Path, str]) -> None: + """Hard requirement: the whole store opens with xr.open_datatree.""" + store, name = converted_store + if name in DATATREE_XFAIL: + pytest.xfail(DATATREE_XFAIL[name]) + xr.open_datatree(str(store), engine="zarr", consolidated=False, chunks={}) +``` + +- [ ] **Step 3: Run and reconcile** + +Run: `uv run pytest tests/test_geozarr_output_contract.py -v` + +Expected: OLCI params pass; S1/S2 `test_store_opens_as_datatree` xfail. If `test_every_level_is_regular_grid_with_crs` fails for S1 or S2, investigate before touching the test: open the failing level by hand and determine whether the converter genuinely omits CRS/regular coords at that level (a real product gap — report it and add a targeted xfail with a reason naming the gap) or the walker mis-resolved a group path (fix the walker). Do not weaken the OLCI assertions — OLCI must pass everything. + +- [ ] **Step 4: Full verification** + +Run: `uv run pytest tests/ -q -p no:warnings --deselect tests/test_cli_e2e.py` — expected 0 failures. +Run: `uv run pyright` — expected `0 errors`. + +- [ ] **Step 5: Commit** + +```bash +git add tests/test_geozarr_output_contract.py tests/test_integration_sentinel2.py +git commit -m "test: cross-product contract - every converted product is a regular grid with CRS + +Assisted-by: ClaudeCode:claude-fable-5" +``` From d21fd9812827369a57656bc41f0f2540c9fa8783 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 16:42:37 +0200 Subject: [PATCH 48/58] feat(s3-olci): add swath-to-grid reprojection via rasterio geolocation arrays Assisted-by: ClaudeCode:claude-sonnet-5 --- .../s3_olci_optimization/olci_reproject.py | 178 ++++++++++++++++++ tests/test_olci_reproject.py | 101 ++++++++++ 2 files changed, 279 insertions(+) create mode 100644 src/eopf_geozarr/s3_olci_optimization/olci_reproject.py create mode 100644 tests/test_olci_reproject.py diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py b/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py new file mode 100644 index 00000000..b87c6817 --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py @@ -0,0 +1,178 @@ +"""Reprojection of OLCI swath measurements to a regular grid. + +OLCI L1 EFR is a curvilinear swath geolocated by dense per-pixel 2-D +latitude/longitude arrays. Generic GeoZarr readers (titiler, rioxarray) +require a regular grid with an affine transform and a declared CRS, so the +converter warps the swath once at native resolution using rasterio's +geolocation-array support (``src_geoloc_array``, rasterio >= 1.4). +""" + +from __future__ import annotations + +import numpy as np +import rioxarray # noqa: F401 # enables the .rio accessor +import structlog +import xarray as xr +from pyproj import CRS as ProjCRS +from rasterio.crs import CRS +from rasterio.warp import Resampling, calculate_default_transform, reproject + +log = structlog.get_logger() + +#: CRS of the OLCI geolocation arrays (per-pixel lat/lon in degrees). +GEOLOC_CRS = "EPSG:4326" + +#: Dimension names of the reprojected regular grid. +GRID_DIMS: tuple[str, str] = ("y", "x") + +_SWATH_DIMS = ("rows", "columns") + + +def _nodata_for(var: xr.DataArray) -> float: + """Warp nodata for *var*: its ``_FillValue`` if present, else a dtype default. + + Integer variables without a fill value get the dtype maximum (matching the + OLCI convention of 65535 for uint16 radiances); floats get NaN. + """ + fill = var.attrs.get("_FillValue") + if fill is None: + fill = var.encoding.get("_FillValue") + if fill is not None: + return float(fill) + if np.issubdtype(var.dtype, np.integer): + return float(np.iinfo(var.dtype).max) + return float("nan") + + +def _grid_coord_attrs(target_crs: str) -> tuple[dict[str, str], dict[str, str]]: + """CF attrs for the 1-D (y, x) dimension coordinates in *target_crs*.""" + if ProjCRS.from_user_input(target_crs).is_geographic: + y_attrs = {"standard_name": "latitude", "units": "degrees_north", "axis": "Y"} + x_attrs = {"standard_name": "longitude", "units": "degrees_east", "axis": "X"} + else: + y_attrs = {"standard_name": "projection_y_coordinate", "units": "m", "axis": "Y"} + x_attrs = {"standard_name": "projection_x_coordinate", "units": "m", "axis": "X"} + return y_attrs, x_attrs + + +def reproject_olci( + ds: xr.Dataset, + *, + target_crs: str = "EPSG:4326", + resampling: Resampling = Resampling.bilinear, +) -> xr.Dataset: + """Warp an OLCI swath dataset onto a regular *target_crs* grid. + + Every numeric variable spanning exactly ``(rows, columns)`` — radiance + bands and the 2-D ``altitude`` coordinate alike — is warped onto a common + grid sized by :func:`rasterio.warp.calculate_default_transform` from the + dense per-pixel geolocation (~native resolution preserved). The + ``latitude``/``longitude`` geolocation arrays are consumed by the warp and + replaced by 1-D ``y``/``x`` dimension coordinates. Variables that carry a + swath dim but cannot live on the grid (e.g. per-scan-line ``time_stamp``) + are dropped; variables without swath dims pass through unchanged. + + Off-swath cells are set to each variable's ``_FillValue`` (dtype max for + integer variables without one), and ``_FillValue`` is recorded in the + output attrs so downstream fill-aware averaging keeps working. + + Raises + ------ + ValueError + If the 2-D ``latitude``/``longitude`` coordinates are missing, or if + the geolocation spans a zero-area (degenerate) extent. + """ + for required in ("latitude", "longitude"): + if required not in ds.coords: + raise ValueError(f"cannot reproject OLCI swath: missing 2-D coordinate {required!r}") + lat = ds.coords["latitude"] + lon = ds.coords["longitude"] + if tuple(str(d) for d in lat.dims) != _SWATH_DIMS or lat.dims != lon.dims: + raise ValueError("latitude/longitude must be 2-D over (rows, columns)") + lat_vals = np.asarray(lat.values, dtype="float64") + lon_vals = np.asarray(lon.values, dtype="float64") + if lat_vals.max() == lat_vals.min() or lon_vals.max() == lon_vals.min(): + raise ValueError("degenerate geolocation extent: latitude/longitude span zero area") + + src_height, src_width = lat_vals.shape + geoloc = np.stack([lon_vals, lat_vals]) # (2, H, W): x first, then y + transform, width, height = calculate_default_transform( + src_crs=CRS.from_string(GEOLOC_CRS), + dst_crs=CRS.from_string(target_crs), + width=src_width, + height=src_height, + src_geoloc_array=geoloc, + ) + assert width is not None + assert height is not None + log.info( + "Reprojecting OLCI swath", + target_crs=target_crs, + src_shape=(src_height, src_width), + dst_shape=(height, width), + ) + + result_vars: dict[str, xr.DataArray] = {} + passthrough_coords: dict[str, xr.DataArray] = {} + all_names = [str(k) for k in ds.data_vars] + [ + str(k) for k in ds.coords if str(k) not in ("latitude", "longitude") + ] + for name in all_names: + var = ds[name] if name in ds.data_vars else ds.coords[name] + var_dims = tuple(str(d) for d in var.dims) + if var_dims == _SWATH_DIMS and np.issubdtype(var.dtype, np.number): + nodata = _nodata_for(var) + src_nodata = ( + nodata + if ( + var.attrs.get("_FillValue") is not None + or var.encoding.get("_FillValue") is not None + ) + else None + ) + dest = np.full((height, width), nodata, dtype=var.dtype) + reproject( + source=np.ascontiguousarray(var.values), + destination=dest, + src_crs=CRS.from_string(GEOLOC_CRS), + src_geoloc_array=geoloc, + src_nodata=src_nodata, + dst_crs=CRS.from_string(target_crs), + dst_transform=transform, + dst_nodata=nodata, + resampling=resampling, + ) + out_attrs = dict(var.attrs) + if np.issubdtype(var.dtype, np.integer): + out_attrs["_FillValue"] = int(nodata) + elif not np.isnan(nodata): + out_attrs["_FillValue"] = float(nodata) + out_attrs.pop("coordinates", None) # swath geolocation is gone + result_vars[name] = xr.DataArray(dest, dims=GRID_DIMS, attrs=out_attrs) + elif any(d in var_dims for d in _SWATH_DIMS): + log.info("Dropping swath-bound variable with no grid home", variable=name) + elif name in ds.coords: + passthrough_coords[name] = var + else: + result_vars[name] = var + + xs = transform.c + transform.a * (np.arange(width) + 0.5) + ys = transform.f + transform.e * (np.arange(height) + 0.5) + y_attrs, x_attrs = _grid_coord_attrs(target_crs) + out = xr.Dataset( + result_vars, + coords={ + "y": ("y", ys, y_attrs), + "x": ("x", xs, x_attrs), + **passthrough_coords, + }, + attrs=dict(ds.attrs), + ) + out = out.rio.write_crs(target_crs) + if not isinstance(out, xr.Dataset): + raise TypeError(f"expected an xarray.Dataset after write_crs, got {type(out).__name__}") + # rioxarray records grid_mapping in encoding; pin it in attrs so it is + # guaranteed to reach the zarr store. + for name in out.data_vars: + out[name].attrs["grid_mapping"] = "spatial_ref" + return out diff --git a/tests/test_olci_reproject.py b/tests/test_olci_reproject.py new file mode 100644 index 00000000..db085e30 --- /dev/null +++ b/tests/test_olci_reproject.py @@ -0,0 +1,101 @@ +"""Tests for OLCI swath -> regular grid reprojection.""" + +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_reproject import reproject_olci + +FILL = 65535 + + +def build_rotated_swath(rows: int = 64, cols: int = 60, angle_deg: float = 30.0) -> xr.Dataset: + """Synthetic OLCI-like swath: regular grid rotated by *angle_deg* in lon/lat. + + Rotation matters: it makes the dst bounding-box corners fall outside the + swath, exercising real geolocation warping and off-swath fill. + """ + rr, cc = np.meshgrid( + np.arange(rows, dtype="float64"), np.arange(cols, dtype="float64"), indexing="ij" + ) + theta = np.deg2rad(angle_deg) + lon = 10.0 + 0.01 * (cc * np.cos(theta) - rr * np.sin(theta)) + lat = 45.0 + 0.01 * (cc * np.sin(theta) + rr * np.cos(theta)) + + band = (100.0 * rr + cc).astype("uint16") + band[:4, :4] = FILL # a filled block inside the swath + da = xr.DataArray( + band, + dims=("rows", "columns"), + attrs={"scale_factor": 0.0139, "add_offset": 0.0, "_FillValue": FILL}, + ) + time_stamp = xr.DataArray(np.arange(rows).astype("datetime64[ns]"), dims=("rows",)) + return xr.Dataset( + {"oa01_radiance": da}, + coords={ + "latitude": (("rows", "columns"), lat), + "longitude": (("rows", "columns"), lon), + "altitude": (("rows", "columns"), np.full((rows, cols), 7, dtype="int16")), + "time_stamp": time_stamp, + }, + ) + + +def test_reproject_olci_produces_regular_grid_with_crs() -> None: + """One behavior test: grid shape, CRS, dtype, attrs, fill, and dropped vars.""" + ds = build_rotated_swath() + out = reproject_olci(ds) + + # Regular 1-D coordinate grid over (y, x) + assert set(out.sizes) == {"y", "x"} + for dim in ("y", "x"): + coord = out[dim] + assert coord.ndim == 1 + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]) + # y descends (north-up grid) + assert out["y"].values[0] > out["y"].values[-1] + + # CRS declared in both idioms + assert out.rio.crs is not None + assert out.rio.crs.to_epsg() == 4326 + assert "spatial_ref" in out.coords or "spatial_ref" in out.variables + assert out["oa01_radiance"].attrs["grid_mapping"] == "spatial_ref" + + # dtype and CF scaling preserved; fill recorded + band = out["oa01_radiance"] + assert band.dtype == np.dtype("uint16") + assert band.attrs["scale_factor"] == 0.0139 + assert int(band.attrs["_FillValue"]) == FILL + + # Off-swath cells (bbox corners of a rotated swath) are fill + vals = band.values + assert vals[0, 0] == FILL + assert vals[-1, -1] == FILL + # …and real data survived the warp + valid = vals[vals != FILL] + assert valid.size > 0 + assert valid.max() <= (100.0 * 64 + 60) + + # altitude warped onto the grid; per-scan-line time_stamp dropped + assert "altitude" in out.data_vars + assert out["altitude"].dims == ("y", "x") + assert "time_stamp" not in out.variables + + +def test_reproject_olci_missing_geolocation_raises() -> None: + ds = build_rotated_swath().drop_vars("latitude") + with pytest.raises(ValueError, match="latitude"): + reproject_olci(ds) + + +def test_reproject_olci_degenerate_extent_raises() -> None: + ds = build_rotated_swath() + ds = ds.assign_coords( + latitude=(("rows", "columns"), np.full((64, 60), 45.0)), + longitude=(("rows", "columns"), np.full((64, 60), 10.0)), + ) + with pytest.raises(ValueError, match="degenerate"): + reproject_olci(ds) From ccd72ee1e88a170b187e9128f4c50e8070d62089 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 16:57:56 +0200 Subject: [PATCH 49/58] fix(s3-olci): guarantee _FillValue on all warped variables; test dims error Float variables with no pre-existing _FillValue warped to NaN nodata but were skipping the _FillValue attr, breaking the "every warped variable records its fill" contract. Always write _FillValue on the warped path (NaN included for float dtypes) and clarify the docstring to scope the guarantee to warped variables only. Also add the missing test for the 2-D latitude/longitude shape-mismatch ValueError, per the one-test-per-error-case convention. Assisted-by: ClaudeCode:claude-sonnet-5 --- .../s3_olci_optimization/olci_reproject.py | 13 ++++++----- tests/test_olci_reproject.py | 22 ++++++++++++++++++- 2 files changed, 29 insertions(+), 6 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py b/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py index b87c6817..3d088700 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_reproject.py @@ -72,9 +72,12 @@ def reproject_olci( swath dim but cannot live on the grid (e.g. per-scan-line ``time_stamp``) are dropped; variables without swath dims pass through unchanged. - Off-swath cells are set to each variable's ``_FillValue`` (dtype max for - integer variables without one), and ``_FillValue`` is recorded in the - output attrs so downstream fill-aware averaging keeps working. + Off-swath cells are set to each warped variable's ``_FillValue`` (dtype + max for integer variables without one, NaN for float variables without + one), and ``_FillValue`` is recorded in the output attrs of every warped + variable — including NaN for float variables — so downstream fill-aware + averaging keeps working. Passthrough variables that carry no swath dim + are not warped and carry no such guarantee. Raises ------ @@ -145,8 +148,8 @@ def reproject_olci( out_attrs = dict(var.attrs) if np.issubdtype(var.dtype, np.integer): out_attrs["_FillValue"] = int(nodata) - elif not np.isnan(nodata): - out_attrs["_FillValue"] = float(nodata) + else: + out_attrs["_FillValue"] = float(nodata) # NaN included out_attrs.pop("coordinates", None) # swath geolocation is gone result_vars[name] = xr.DataArray(dest, dims=GRID_DIMS, attrs=out_attrs) elif any(d in var_dims for d in _SWATH_DIMS): diff --git a/tests/test_olci_reproject.py b/tests/test_olci_reproject.py index db085e30..0db49d26 100644 --- a/tests/test_olci_reproject.py +++ b/tests/test_olci_reproject.py @@ -31,9 +31,14 @@ def build_rotated_swath(rows: int = 64, cols: int = 60, angle_deg: float = 30.0) dims=("rows", "columns"), attrs={"scale_factor": 0.0139, "add_offset": 0.0, "_FillValue": FILL}, ) + # float32 band with no pre-existing _FillValue: nodata defaults to NaN. + solar_flux = xr.DataArray( + (rr + cc).astype("float32"), + dims=("rows", "columns"), + ) time_stamp = xr.DataArray(np.arange(rows).astype("datetime64[ns]"), dims=("rows",)) return xr.Dataset( - {"oa01_radiance": da}, + {"oa01_radiance": da, "solar_flux_proxy": solar_flux}, coords={ "latitude": (("rows", "columns"), lat), "longitude": (("rows", "columns"), lon), @@ -84,6 +89,14 @@ def test_reproject_olci_produces_regular_grid_with_crs() -> None: assert out["altitude"].dims == ("y", "x") assert "time_stamp" not in out.variables + # float variable with no pre-existing _FillValue: nodata is NaN, but it + # is still recorded, and off-swath corners are NaN. + flux = out["solar_flux_proxy"] + assert np.isnan(flux.attrs["_FillValue"]) + flux_vals = flux.values + assert np.isnan(flux_vals[0, 0]) + assert np.isnan(flux_vals[-1, -1]) + def test_reproject_olci_missing_geolocation_raises() -> None: ds = build_rotated_swath().drop_vars("latitude") @@ -91,6 +104,13 @@ def test_reproject_olci_missing_geolocation_raises() -> None: reproject_olci(ds) +def test_reproject_olci_wrong_geolocation_dims_raises() -> None: + ds = build_rotated_swath() + ds = ds.assign_coords(latitude=("rows", np.linspace(45, 46, 64))) + with pytest.raises(ValueError, match="2-D"): + reproject_olci(ds) + + def test_reproject_olci_degenerate_extent_raises() -> None: ds = build_rotated_swath() ds = ds.assign_coords( From 637b1d8c845f2cc3bfcc841e2d1e687440228a55 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 17:01:37 +0200 Subject: [PATCH 50/58] refactor(s3-olci): parameterize reduce/decimate over spatial dims for gridded pyramids Add keyword-only dims parameter to decimate_swath and reduce_swath, defaulting to SWATH_DIMS=("rows", "columns") to preserve existing behavior. Enables Task 4 to create pyramids on reprojected grids with dims ("y", "x"). Assisted-by: ClaudeCode:claude-haiku-4-5 --- .../s3_olci_optimization/olci_multiscale.py | 27 ++++++++------ tests/test_olci_multiscale.py | 36 +++++++++++++++++++ 2 files changed, 53 insertions(+), 10 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index 6239ffe3..da4e5096 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -29,8 +29,10 @@ SWATH_DIMS = ("rows", "columns") -def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: - """Return *ds* with every (rows, columns) array subsampled by *factor*. +def decimate_swath( + ds: xr.Dataset, factor: int = 2, *, dims: tuple[str, str] = SWATH_DIMS +) -> xr.Dataset: + """Return *ds* with every array spanning the *dims* spatial dimensions (default ``(rows, columns)``) subsampled by *factor*. Both data variables and coordinate variables that span exactly the swath dims are decimated ``[::factor, ::factor]``; everything else is passed @@ -40,13 +42,15 @@ def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: raise ValueError(f"factor must be >= 1, got {factor}") if factor == 1: return ds - indexers = {dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes} + indexers = {dim: slice(None, None, factor) for dim in dims if dim in ds.sizes} if not indexers: return ds return ds.isel(indexers) -def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: +def reduce_swath( + ds: xr.Dataset, factor: int = 2, *, dims: tuple[str, str] = SWATH_DIMS +) -> xr.Dataset: """Return *ds* with radiance bands block-averaged and 2-D coordinates decimated. Overviews are an unweighted index-block mean that ASSUMES locally-uniform @@ -54,6 +58,9 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: reduced resolution. Coordinates are decimated (real sub-pixels), radiance is fill-aware block-averaged. + Parameters spanning the *dims* spatial dimensions (default ``(rows, columns)``) + are processed; other variables pass through unchanged. + Radiance variables (those named in :data:`OLCI_BANDS`) are averaged over ``factor x factor`` pixel blocks with fill-value awareness: fill pixels are masked before averaging so a single fill pixel does not contaminate @@ -110,13 +117,13 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # producing a store where coordinate arrays are longer than the data they # describe, which makes xr.open_dataset raise a conflicting-sizes error. dim_trim: dict[str, int] = { - dim: (ds.sizes[dim] // factor) * factor for dim in SWATH_DIMS if dim in ds.sizes + dim: (ds.sizes[dim] // factor) * factor for dim in dims if dim in ds.sizes } all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] for name in all_names: var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] - is_swath_2d: bool = tuple(str(d) for d in var.dims) == SWATH_DIMS + is_swath_2d: bool = tuple(str(d) for d in var.dims) == dims if name in olci_band_set and is_swath_2d: # Fill-aware block averaging for radiance bands. @@ -131,7 +138,7 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # coarsen().mean() is available at runtime; pyright stubs don't expose .mean() # on DataArrayCoarsen, so we suppress the type-check on the reduction call. - coarsened = float_var.coarsen({"rows": factor, "columns": factor}, boundary="trim") + coarsened = float_var.coarsen({dims[0]: factor, dims[1]: factor}, boundary="trim") averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] if fill_value is not None: @@ -153,7 +160,7 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: # so that an odd-length dimension N yields floor(N / factor) elements, # matching the output length of coarsen(boundary="trim").mean(). indexers: dict[str, slice] = { - dim: slice(0, dim_trim[dim], factor) for dim in SWATH_DIMS if dim in dim_trim + dim: slice(0, dim_trim[dim], factor) for dim in dims if dim in dim_trim } decimated = var.isel(indexers) if name in coord_names: @@ -161,13 +168,13 @@ def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: else: result_vars[name] = decimated - elif any(dim in (str(d) for d in var.dims) for dim in SWATH_DIMS): + elif any(dim in (str(d) for d in var.dims) for dim in dims): # 1-D (or higher) variable sharing a swath dim but not 2-D swath: # decimate along whichever swath dims it carries. var_dims = {str(d) for d in var.dims} idx: dict[str, slice] = { dim: slice(0, dim_trim[dim], factor) - for dim in SWATH_DIMS + for dim in dims if dim in var_dims and dim in dim_trim } decimated = var.isel(idx) diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index d7efd1c2..623c1c8e 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -290,3 +290,39 @@ def test_swath_spatial_attrs_has_no_transform() -> None: assert attrs.get("spatial:registration") == "pixel" assert "spatial:transform" not in attrs assert "spatial:bbox" not in attrs + + +# --------------------------------------------------------------------------- +# grid dims tests (for Task 4: reprojected pyramid) +# --------------------------------------------------------------------------- + + +def test_reduce_swath_on_grid_dims() -> None: + """reduce_swath(dims=("y","x")) block-averages bands and strides 1-D coords. + + After reprojection the pyramid dims are (y, x): bands average fill-aware, + the 1-D dimension coordinates decimate by trimmed stride, and non-spatial + variables (spatial_ref) pass through unchanged. + """ + ny, nx = 6, 5 # odd x exercises the coarsen-trim alignment + band = np.arange(ny * nx, dtype="uint16").reshape(ny, nx) + ds = xr.Dataset( + {"oa01_radiance": (("y", "x"), band, {"_FillValue": 65535})}, + coords={ + "y": ("y", np.linspace(46.0, 45.0, ny)), + "x": ("x", np.linspace(10.0, 11.0, nx)), + "spatial_ref": ((), 0, {"crs_wkt": "stub"}), + }, + ) + out = reduce_swath(ds, factor=2, dims=("y", "x")) + assert dict(out.sizes) == {"y": 3, "x": 2} + # block mean of the top-left 2x2 block, rounded + expected00 = round((band[0, 0] + band[0, 1] + band[1, 0] + band[1, 1]) / 4) + assert int(out["oa01_radiance"].values[0, 0]) == expected00 + # 1-D coords: trimmed stride, lengths match the data + assert out["y"].size == 3 + assert out["x"].size == 2 + np.testing.assert_allclose(out["x"].values, ds["x"].values[0:4:2]) + # scalar passthrough survives + assert "spatial_ref" in out.coords + assert out["spatial_ref"].attrs["crs_wkt"] == "stub" From c21e7930830b1e0fdc0d4796adb421202d67aac1 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 17:09:49 +0200 Subject: [PATCH 51/58] feat(s3-olci): add gridded spatial-convention attrs with affine transform Assisted-by: ClaudeCode:claude-haiku-4-5 --- .../s3_olci_optimization/olci_multiscale.py | 26 +++++++++++++++++++ tests/test_olci_multiscale.py | 25 ++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index da4e5096..d0e25abd 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -19,11 +19,13 @@ from typing import TYPE_CHECKING import numpy as np +import rasterio.transform import xarray as xr from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS if TYPE_CHECKING: + from affine import Affine from zarr_cm import SpatialAttrs SWATH_DIMS = ("rows", "columns") @@ -206,3 +208,27 @@ def swath_spatial_attrs( "spatial:dimensions": [dims[0], dims[1]], "spatial:registration": "pixel", } + + +def grid_spatial_attrs(transform: Affine, shape: tuple[int, int]) -> SpatialAttrs: + """Spatial-convention data for a regular grid with an affine *transform*. + + *shape* is ``(height, width)``. Emits ``spatial:dimensions`` ``["y","x"]``, + pixel registration, the bounding box, and the 6-element row-major affine + transform — the gridded counterpart of :func:`swath_spatial_attrs`. + """ + height, width = shape + left, bottom, right, top = rasterio.transform.array_bounds(height, width, transform) + return { + "spatial:dimensions": ["y", "x"], + "spatial:registration": "pixel", + "spatial:bbox": [float(left), float(bottom), float(right), float(top)], + "spatial:transform": [ + float(transform.a), + float(transform.b), + float(transform.c), + float(transform.d), + float(transform.e), + float(transform.f), + ], + } diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 623c1c8e..9fdeeffb 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -4,10 +4,12 @@ import numpy as np import pytest +import rasterio.transform import xarray as xr from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( decimate_swath, + grid_spatial_attrs, reduce_swath, swath_spatial_attrs, ) @@ -326,3 +328,26 @@ def test_reduce_swath_on_grid_dims() -> None: # scalar passthrough survives assert "spatial_ref" in out.coords assert out["spatial_ref"].attrs["crs_wkt"] == "stub" + + +# --------------------------------------------------------------------------- +# grid_spatial_attrs tests +# --------------------------------------------------------------------------- + + +def test_grid_spatial_attrs() -> None: + """grid_spatial_attrs derives dimensions, bbox, and 6-element transform.""" + transform = rasterio.transform.from_origin(10.0, 46.0, 0.01, 0.01) + attrs = grid_spatial_attrs(transform, (100, 200)) + assert attrs["spatial:dimensions"] == ["y", "x"] + assert attrs["spatial:registration"] == "pixel" # type: ignore[index] + assert attrs["spatial:transform"] == [ # type: ignore[index] + 0.01, + 0.0, + 10.0, + 0.0, + -0.01, + 46.0, + ] + # bbox is [xmin, ymin, xmax, ymax] from array_bounds + assert attrs["spatial:bbox"] == [10.0, 45.0, 12.0, 46.0] # type: ignore[index] From 85045d4c9ad2a0851639c498631a0aa49e5219b7 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 18:27:04 +0200 Subject: [PATCH 52/58] feat(s3-olci): reproject measurements to regular EPSG:4326 grid with per-level CRS Warp the swath once after sanitize via reproject_olci, build the r0/r2/... pyramid on the grid with reduce_swath(dims=(y, x)), and write per-level spatial/geo-proj convention attrs plus multiscales on the parent. Replace the degenerate collinear lat/lon in the synthetic test fixture with a real axis-aligned grid and restructure size assertions relative to the observed warped r0. swath_spatial_attrs is deleted (replaced by grid_spatial_attrs). The golden-snapshot test intentionally fails until the next commit seeds real geolocation into the zero-filled fixture. Assisted-by: ClaudeCode:claude-sonnet-5 --- .../s3_olci_optimization/olci_converter.py | 76 ++++++--- .../s3_olci_optimization/olci_multiscale.py | 17 +- tests/test_olci_integration.py | 146 ++++++++++-------- tests/test_olci_multiscale.py | 16 +- 4 files changed, 138 insertions(+), 117 deletions(-) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py index 1aad6997..570d2a5b 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -4,17 +4,20 @@ from typing import TYPE_CHECKING, cast +import rioxarray # noqa: F401 import structlog import xarray as xr import zarr +from rasterio.crs import CRS from eopf_geozarr.conversion.utils import build_convention_attrs from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + grid_spatial_attrs, reduce_swath, - swath_spatial_attrs, ) +from eopf_geozarr.s3_olci_optimization.olci_reproject import GRID_DIMS, reproject_olci if TYPE_CHECKING: from zarr.core.common import JSON @@ -168,15 +171,20 @@ def convert_olci_optimized( compression_level: int = 3, min_dimension: int = 256, keep_scale_offset: bool = False, + target_crs: str = "EPSG:4326", ) -> xr.DataTree: """Convert an EOPF OLCI L1 EFR DataTree to a GeoZarr multiscale store. - Writes the native-resolution arrays to ``measurements/r0``, then writes - /2-reduced overview subgroups (``r2``, ``r4``, …) as siblings of ``r0`` - down to *min_dimension*; the ``measurements`` group carries the GeoZarr - convention metadata tying the levels together. Any ``conditions`` or - ``quality`` groups present in *dt_input* are copied through unchanged, - along with any child subgroups of ``measurements`` (e.g. ``orphans``). + Warps the swath once to a regular *target_crs* grid, writes it to + ``measurements/r0``, then /2-reduced overview siblings (``r2``, ``r4``, + …) down to *min_dimension*; the ``measurements`` group carries the + GeoZarr convention metadata tying the levels together. Any + ``conditions`` or ``quality`` groups present in *dt_input* are copied + through unchanged, along with any child subgroups of ``measurements`` + (e.g. ``orphans``). Every level (``r0``, ``r2``, …) carries its own + ``spatial_ref``/``grid_mapping`` plus zarr-cm spatial/geo-proj convention + attrs; the source product's per-scan-line ``time_stamp`` is dropped here + (it has no home on the regular grid) but survives in the source product. Parameters ---------- @@ -204,15 +212,19 @@ def convert_olci_optimized( output encoding rather than decoding to float32. Not yet wired into encoding for this minimal pass; accepted as a typed parameter for forward-compatibility (follow-up task). + target_crs: + Target CRS for the output grid; the swath is warped once at native + resolution before the pyramid builds. Returns ------- xr.DataTree The opened output DataTree (lazy; backed by the written Zarr store). Native-resolution arrays live at ``measurements/r0`` with overview - levels (``r2``, ``r4``, …) as sibling groups; ``measurements`` itself - holds only the multiscales/spatial convention metadata, so the whole - store opens cleanly with ``xr.open_datatree``. + levels (``r2``, ``r4``, …) as sibling groups, all on a regular grid + with 1-D ``y``/``x`` coordinates and a declared CRS; ``measurements`` + itself holds only the multiscales/spatial convention metadata, so the + whole store opens cleanly with ``xr.open_datatree``. Notes ----- @@ -235,6 +247,17 @@ def convert_olci_optimized( # correctly with raw integer data. measurements = _sanitize_data_vars(measurements) + # Warp the curvilinear swath onto a regular target_crs grid (1-D y/x + # coords, spatial_ref + grid_mapping on every variable) at (approximately) + # native resolution. Everything downstream — the pyramid, spatial attrs, + # and CRS metadata — operates on this gridded dataset. + measurements = reproject_olci(measurements, target_crs=target_crs) + # rioxarray's write_crs records grid_mapping in both .attrs (explicitly, + # above) and .encoding; xarray's to_zarr refuses to serialize a variable + # whose attrs and encoding disagree on an encoding-owned key, so clear the + # inherited encoding once more after the warp. + measurements = _clear_encoding(measurements) + # The native-resolution arrays go in a named child group (r0) alongside the # overview groups (r2, r4, …) rather than directly in ``measurements``. # If the parent held the full-res coordinates itself, every overview child @@ -251,18 +274,20 @@ def convert_olci_optimized( ) # Write /2 reduced overview subgroups: r2, r4, r8, … - rows = measurements.sizes["rows"] - cols = measurements.sizes["columns"] + rows = measurements.sizes["y"] + cols = measurements.sizes["x"] n_levels = _overview_levels(rows, cols, min_dimension) log.info("Generating overview levels", n_levels=n_levels) + level_datasets: dict[str, xr.Dataset] = {"r0": measurements} current = measurements for level in range(1, n_levels + 1): - current = reduce_swath(current, factor=2) + current = reduce_swath(current, factor=2, dims=GRID_DIMS) current = _clear_encoding(current) # Attrs already sanitized at native level and passed through by # reduce_swath; no second sanitize pass needed. group_name = f"r{2**level}" + level_datasets[group_name] = current log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) current.to_zarr( output_path, @@ -285,15 +310,30 @@ def convert_olci_optimized( } layout.append(lo) + # zarr_cm's proj convention wants a CRSLike (to_epsg/to_wkt) object, not a + # bare string, so resolve target_crs once here. + crs_obj = CRS.from_string(target_crs) + + root_rw = zarr.open_group(output_path, mode="a") + base_transform = measurements.rio.transform(recalc=True) + base_spatial = grid_spatial_attrs( + base_transform, (measurements.sizes["y"], measurements.sizes["x"]) + ) + for group_name, level_ds in level_datasets.items(): + level_transform = level_ds.rio.transform(recalc=True) + level_conv = build_convention_attrs( + spatial=grid_spatial_attrs(level_transform, (level_ds.sizes["y"], level_ds.sizes["x"])), + crs=crs_obj, + ) + root_rw[f"measurements/{group_name}"].attrs.update(cast("dict[str, JSON]", level_conv)) + if n_levels > 0: ms: MultiscalesAttrs = {"layout": layout, "resampling_method": "average"} - conv = build_convention_attrs(multiscales=ms, spatial=swath_spatial_attrs(), crs=None) + conv = build_convention_attrs(multiscales=ms, spatial=base_spatial, crs=crs_obj) else: - conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + conv = build_convention_attrs(spatial=base_spatial, crs=crs_obj) - zarr.open_group(output_path, mode="a")["measurements"].attrs.update( - cast("dict[str, JSON]", conv) - ) + root_rw["measurements"].attrs.update(cast("dict[str, JSON]", conv)) # Copy conditions/quality through unchanged (if present). # DataTree.to_zarr does not support a root ``group`` argument, so we diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py index d0e25abd..371502e6 100644 --- a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -195,27 +195,12 @@ def reduce_swath( return xr.Dataset(result_vars, coords=result_coords) -def swath_spatial_attrs( - dims: tuple[str, str] = SWATH_DIMS, -) -> SpatialAttrs: - """Spatial-convention data for curvilinear swath geometry. - - OLCI has no affine transform; geolocation is carried by 2-D lat/lon - coordinate arrays, so we declare the spatial dimensions and pixel - registration but no ``spatial:transform``/``spatial:bbox``. - """ - return { - "spatial:dimensions": [dims[0], dims[1]], - "spatial:registration": "pixel", - } - - def grid_spatial_attrs(transform: Affine, shape: tuple[int, int]) -> SpatialAttrs: """Spatial-convention data for a regular grid with an affine *transform*. *shape* is ``(height, width)``. Emits ``spatial:dimensions`` ``["y","x"]``, pixel registration, the bounding box, and the 6-element row-major affine - transform — the gridded counterpart of :func:`swath_spatial_attrs`. + transform. """ height, width = shape left, bottom, right, top = rasterio.transform.array_bounds(height, width, transform) diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py index 6f1c7f61..03b64db8 100644 --- a/tests/test_olci_integration.py +++ b/tests/test_olci_integration.py @@ -9,6 +9,7 @@ from typing import TYPE_CHECKING import numpy as np +import rioxarray # noqa: F401 import xarray as xr import zarr from pydantic_zarr.core import tuplify_json @@ -23,10 +24,16 @@ def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: - """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" + """Minimal synthetic OLCI L1 EFR datatree (measurements only). + + Geolocation is an axis-aligned ~300 m grid (0.003 deg spacing) so the + dataset is genuinely warpable to a regular lat/lon grid. + """ rng = np.random.default_rng(0) - lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) - lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + lat_1d = np.linspace(45.0, 45.0 + 0.003 * (rows - 1), rows) + lon_1d = np.linspace(10.0, 10.0 + 0.003 * (cols - 1), cols) + lat = np.repeat(lat_1d[:, None], cols, axis=1) + lon = np.repeat(lon_1d[None, :], rows, axis=0) alt = np.zeros((rows, cols), dtype="int16") data: dict[str, xr.DataArray] = {} for i in range(1, 22): @@ -80,10 +87,9 @@ def test_convert_olci_creates_overviews(tmp_path: object) -> None: 480//2 = 240 < 256, so the guard fires immediately → zero overview levels. Case 2 — 1024x1024 with min_dimension=256: - 1024//2=512>=256 → level r2 (512x512) - 512//2=256>=256 → level r4 (256x256) - 256//2=128<256 → stop - Exactly two levels; smallest must be exactly 256x256. + the warped grid stays close to 1024x1024, yielding exactly two + overview levels; each halves the previous and the deepest would drop + below min_dimension if halved again. """ import zarr @@ -114,28 +120,26 @@ def test_convert_olci_creates_overviews(tmp_path: object) -> None: f"got {subgroups2}" ) - # Every level must have BOTH spatial dims >= min_dimension. - for sg_name in subgroups2: + # Every level must have BOTH spatial dims >= min_dimension, and each + # overview must be exactly half the previous level (floor division). + r0_2 = meas2["r0"] + assert isinstance(r0_2, zarr.Group) + band0 = r0_2["oa01_radiance"] + assert isinstance(band0, zarr.Array) + prev_shape = band0.shape + for sg_name in [k for k in subgroups2 if k != "r0"]: sg = meas2[sg_name] assert isinstance(sg, zarr.Group) band = sg["oa01_radiance"] assert isinstance(band, zarr.Array) - # shape is (rows, columns) - overview_rows, overview_cols = band.shape[0], band.shape[1] - assert overview_rows >= 256, f"measurements/{sg_name} rows={overview_rows} < 256" - assert overview_cols >= 256, f"measurements/{sg_name} cols={overview_cols} < 256" - - # The deepest level (r4 for 1024-input) must be exactly 256x256. - deepest = meas2[subgroups2[-1]] - assert isinstance(deepest, zarr.Group) - deepest_band = deepest["oa01_radiance"] - assert isinstance(deepest_band, zarr.Array) - assert deepest_band.shape[0] == 256, ( - f"Expected smallest overview rows=256, got {deepest_band.shape}" - ) - assert deepest_band.shape[1] == 256, ( - f"Expected smallest overview cols=256, got {deepest_band.shape}" - ) + assert band.shape[0] == prev_shape[0] // 2 + assert band.shape[1] == prev_shape[1] // 2 + assert band.shape[0] >= 256 + assert band.shape[1] >= 256 + prev_shape = band.shape + + # The deepest level would violate min_dimension if halved again. + assert prev_shape[0] // 2 < 256 or prev_shape[1] // 2 < 256 def test_convert_olci_returns_datatree(tmp_path: object) -> None: @@ -148,13 +152,12 @@ def test_convert_olci_returns_datatree(tmp_path: object) -> None: def test_convert_olci_output_opens_as_datatree(tmp_path: object) -> None: - """Acceptance: ``xr.open_datatree`` must open the exported store cleanly. + """Acceptance: the exported store is a regular grid with CRS at every level. - Full-resolution arrays live in ``measurements/r0`` as a named sibling of - the overview groups (``r2``, …), so no child group inherits mismatched - parent coordinates. The multiscales layout references the base level by - name (``"asset": "r0"``), not ``"."``. This is the layout generic GeoZarr - readers (e.g. titiler) require; see the discussion on PR #212. + xr.open_datatree must open the whole store; measurements/r0 holds the + warped native-resolution grid with 1-D y/x coordinates and a declared + CRS, overview siblings halve it, and the multiscales layout references + the base level by name. """ dt = build_synthetic_olci(rows=1024, cols=1024) out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] @@ -163,22 +166,29 @@ def test_convert_olci_output_opens_as_datatree(tmp_path: object) -> None: opened = xr.open_datatree(out, engine="zarr", consolidated=False, chunks={}) r0 = opened["/measurements/r0"].to_dataset() - assert dict(r0.sizes) == {"rows": 1024, "columns": 1024} + assert set(r0.sizes) == {"y", "x"} for i in range(1, 22): assert f"oa{i:02d}_radiance" in r0 - assert "latitude" in r0.coords - assert "longitude" in r0.coords - + # CRS declared at every level, 1-D regular coordinates + for level in ("r0", "r2", "r4"): + ds = opened[f"/measurements/{level}"].to_dataset() + assert ds.rio.crs is not None, f"{level}: no CRS" + assert ds.rio.crs.to_epsg() == 4326 + for dim in ("y", "x"): + coord = ds[dim] + assert coord.ndim == 1 + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]) + band = ds["oa01_radiance"] + assert band.attrs["grid_mapping"] == "spatial_ref" + # halving structure relative to observed r0 r2 = opened["/measurements/r2"].to_dataset() - assert dict(r2.sizes) == {"rows": 512, "columns": 512} - r4 = opened["/measurements/r4"].to_dataset() - assert dict(r4.sizes) == {"rows": 256, "columns": 256} + assert r2.sizes["y"] == r0.sizes["y"] // 2 + assert r2.sizes["x"] == r0.sizes["x"] // 2 - # The measurements group itself holds only convention metadata: no arrays, - # so children with differing sizes inherit nothing conflicting. + # measurements itself holds only convention metadata meas = opened["/measurements"].to_dataset() assert len(meas.data_vars) == 0 - assert len(meas.coords) == 0 meas_attrs = dict(zarr.open_group(out, mode="r")["measurements"].attrs) multiscales = meas_attrs["multiscales"] @@ -186,12 +196,14 @@ def test_convert_olci_output_opens_as_datatree(tmp_path: object) -> None: layout = multiscales["layout"] assert isinstance(layout, list) assert layout[0] == {"asset": "r0"} - first_overview = layout[1] - assert isinstance(first_overview, dict) - assert first_overview["asset"] == "r2" - assert first_overview["derived_from"] == "r0" + # per-level geo-proj convention present + meas_group = zarr.open_group(out, mode="r")["measurements"] + assert isinstance(meas_group, zarr.Group) + r0_group = meas_group["r0"] + assert isinstance(r0_group, zarr.Group) + r0_attrs = dict(r0_group.attrs) + assert "proj:code" in r0_attrs - # The returned DataTree must expose the same structure as the store. assert "/measurements/r0" in result.groups assert "/measurements/r2" in result.groups @@ -203,8 +215,10 @@ def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: # Build a tree with conditions and quality groups rng = np.random.default_rng(1) rows, cols = 128, 128 - lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) - lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + lat_1d = np.linspace(45.0, 45.0 + 0.003 * (rows - 1), rows) + lon_1d = np.linspace(10.0, 10.0 + 0.003 * (cols - 1), cols) + lat = np.repeat(lat_1d[:, None], cols, axis=1) + lon = np.repeat(lon_1d[None, :], rows, axis=0) alt = np.zeros((rows, cols), dtype="int16") meas_data: dict[str, xr.DataArray] = { @@ -388,9 +402,10 @@ def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) - On an odd-column real OLCI product (4865 cols) this caused xr.open_dataset to raise ``ValueError: conflicting sizes for dimension 'columns'``. - We use rows=10, cols=9 (odd cols) with min_dimension=4 so that two - overview levels (r2 at 5x4, r4 at 2x2) are generated. Each level is - opened via xr.open_dataset to confirm no conflicting-sizes error. + We use rows=10, cols=9 (odd cols) with min_dimension=4. Once warped to a + regular grid the exact base size need not match the swath input, so this + asserts coord/data length agreement and floor-halving structure at every + level rather than a specific (5, 4) shape. """ dt = build_synthetic_olci(rows=10, cols=9) out = str(tmp_path / "odd_olci.zarr") # type: ignore[operator] @@ -403,27 +418,22 @@ def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) - meas = g["measurements"] assert isinstance(meas, _zarr.Group) level_keys = sorted(meas.group_keys()) - # With rows=10, cols=9, min_dimension=4: - # floor(9/2)=4 >= 4 → r2 generated - # floor(4/2)=2 < 4 → stop - assert level_keys == ["r0", "r2"], ( - f"Expected exactly ['r0', 'r2'] for 10x9 at min_dimension=4, got {level_keys}" - ) - overview_keys = [k for k in level_keys if k != "r0"] + assert level_keys[0] == "r0" - # Open each overview level; this must NOT raise a conflicting-sizes error. - for lvl in overview_keys: + # Open each level (base + overviews); this must NOT raise a + # conflicting-sizes error, and each level must floor-halve the previous. + prev_shape: tuple[int, ...] | None = None + for lvl in level_keys: ds = xr.open_dataset(out, engine="zarr", group=f"measurements/{lvl}", consolidated=False) rad_shape = ds["oa01_radiance"].shape - lat_shape = ds["latitude"].shape - lon_shape = ds["longitude"].shape - assert rad_shape == lat_shape == lon_shape, ( - f"measurements/{lvl}: shapes disagree — " - f"oa01_radiance={rad_shape}, latitude={lat_shape}, longitude={lon_shape}" + assert rad_shape == (ds["y"].size, ds["x"].size), ( + f"measurements/{lvl}: data shape {rad_shape} != coord sizes " + f"(y={ds['y'].size}, x={ds['x'].size})" ) - # r2 of a 10x9 swath must be (5, 4) = (floor(10/2), floor(9/2)) - if lvl == "r2": - assert rad_shape == (5, 4), f"r2 shape expected (5,4), got {rad_shape}" + if prev_shape is not None: + assert rad_shape[0] == prev_shape[0] // 2 + assert rad_shape[1] == prev_shape[1] // 2 + prev_shape = rad_shape ds.close() diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py index 9fdeeffb..2098ddb1 100644 --- a/tests/test_olci_multiscale.py +++ b/tests/test_olci_multiscale.py @@ -1,4 +1,4 @@ -"""Tests for olci_multiscale: decimate_swath, reduce_swath, swath_spatial_attrs.""" +"""Tests for olci_multiscale: decimate_swath, reduce_swath, grid_spatial_attrs.""" from __future__ import annotations @@ -11,7 +11,6 @@ decimate_swath, grid_spatial_attrs, reduce_swath, - swath_spatial_attrs, ) @@ -281,19 +280,6 @@ def test_reduce_swath_odd_simulates_real_olci_columns() -> None: ) -# --------------------------------------------------------------------------- -# swath_spatial_attrs tests -# --------------------------------------------------------------------------- - - -def test_swath_spatial_attrs_has_no_transform() -> None: - attrs = swath_spatial_attrs() - assert attrs["spatial:dimensions"] == ["rows", "columns"] - assert attrs.get("spatial:registration") == "pixel" - assert "spatial:transform" not in attrs - assert "spatial:bbox" not in attrs - - # --------------------------------------------------------------------------- # grid dims tests (for Task 4: reprojected pyramid) # --------------------------------------------------------------------------- From 2d0d6fd14d5732047406cce1de55cd551489bb35 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 20:12:28 +0200 Subject: [PATCH 53/58] feat(s3-olci): --target-crs flag, regenerated snapshot, gridded-layout docs and notebook Seed real geolocation into the zero-filled golden fixture inside the snapshot test (the warp rejects degenerate extents), regenerate the snapshot for the gridded layout, add --target-crs to the CLI subcommand, update README/converter.md for the reprojected output, and re-execute the demo notebook against the real EODC product. Mark the implementation-plan doc's code blocks test-skip so pytest-examples does not execute them. Assisted-by: ClaudeCode:claude-sonnet-5 --- README.md | 25 +- docs/converter.md | 22 +- docs/notebooks/sentinel3_olci_geozarr.ipynb | 266 ++++-- .../plans/2026-07-27-s3-olci-reprojection.md | 1 + src/eopf_geozarr/cli.py | 7 + ...084255_0179_132_149_2160_PS1_O_NT_004.json | 786 ++++++++++-------- tests/test_olci_integration.py | 23 + 7 files changed, 693 insertions(+), 437 deletions(-) diff --git a/README.md b/README.md index f2f51109..493e3829 100644 --- a/README.md +++ b/README.md @@ -297,9 +297,10 @@ via /2 downsampling. Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) products are detected automatically by `eopf-geozarr convert` and routed to the -dedicated OLCI converter. Unlike Sentinel-2, OLCI data uses **native swath geometry**: -measurements are stored on a per-pixel 2-D lat/lon grid with no reprojection to a -projected CRS. The exporter preserves this curvilinear geometry intact. +dedicated OLCI converter. Unlike Sentinel-2, OLCI data starts out on **native +swath geometry**: measurements are stored on a per-pixel 2-D lat/lon grid. The +exporter warps this curvilinear swath once onto a regular grid (default +`EPSG:4326`) so that the output is a standard GeoZarr raster. #### Auto-detection @@ -324,17 +325,23 @@ Key flags: dimension would drop below this value (default: 256) - `--enable-sharding` — accepted but not yet wired into encoding (follow-up task) - `--keep-scale-offset` — accepted but not yet wired into encoding (follow-up task) +- `--target-crs` — target CRS for the reprojected output grid (default: `EPSG:4326`) #### What is converted -- **`/measurements/r0`**: all 21 OLCI radiance bands at native full resolution, - with per-pixel 2-D `latitude`/`longitude` coordinate arrays; the parent - `measurements/` group carries the GeoZarr `spatial:` and `multiscales` - convention metadata. -- **Overview subgroups** (`r2`, `r4`, …): /2-decimated copies of the measurements - stored as sibling Zarr groups next to `r0` under `measurements/`. +- **`/measurements/r0`**: all 21 OLCI radiance bands warped once from the + native swath onto a regular grid (default `EPSG:4326`, ~300 m preserved), + with 1-D `y`/`x` coordinates, a `spatial_ref` variable, and `grid_mapping` + on every band; the parent `measurements/` group carries the GeoZarr + `multiscales`, `spatial:`, and `proj:` convention metadata. +- **Overview subgroups** (`r2`, `r4`, …): /2 fill-aware block-averaged copies + stored as sibling Zarr groups next to `r0`, each with its own CRS metadata. - **`/conditions` and `/quality`**: copied through unmodified. +> **Note:** per-scan-line `time_stamp` is not representable on a regular grid +> and is dropped from the converted measurements (it remains in the source +> product). + > **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid > groups (`conditions/geometry`, `meteorology`, `instrument`) are copied through but > not converted to GeoZarr convention. Encoding wiring for `--enable-sharding`, diff --git a/docs/converter.md b/docs/converter.md index 3ea6211e..8c44b59d 100644 --- a/docs/converter.md +++ b/docs/converter.md @@ -180,10 +180,11 @@ The result is a space-efficient multiscale pyramid: `/measurements/reflectance/{ ## Sentinel-3 OLCI L1 EFR Conversion Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) -products are supported. OLCI uses **native swath geometry**: measurements are stored -on a per-pixel 2-D lat/lon grid, with no reprojection to a projected CRS. The -exporter preserves this curvilinear geometry intact and generates /2-decimated -overview subgroups for multi-resolution access. +products are supported. OLCI measurements start out on **native swath geometry**: +a per-pixel 2-D lat/lon grid. The converter reprojects (warps) the swath measurements +once onto a regular grid (default `EPSG:4326`) using the swath geolocation arrays, +then generates /2 fill-aware block-averaged overview subgroups for multi-resolution +access. ### Auto-detection @@ -211,14 +212,15 @@ eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ | `--min-dimension` | 256 | Minimum spatial dimension for overview levels | | `--enable-sharding` | off | Accepted but not yet wired into encoding (follow-up task) | | `--keep-scale-offset` | off | Accepted but not yet wired into encoding (follow-up task) | +| `--target-crs` | EPSG:4326 | Target CRS for the reprojected output grid | ### Output layout ``` output.zarr/ -├── measurements/ # Carries multiscales + spatial: convention metadata -│ ├── r0/ # Native-resolution OLCI bands (oa01_radiance … oa21_radiance) -│ │ # with per-pixel latitude/longitude coordinates +├── measurements/ # Carries multiscales + spatial: + proj: convention metadata +│ ├── r0/ # Warped native-resolution OLCI bands (oa01_radiance … oa21_radiance) +│ │ # with 1-D y/x coordinates and spatial_ref │ ├── r2/ # 1/2-resolution overview │ ├── r4/ # 1/4-resolution overview │ └── ... @@ -226,8 +228,10 @@ output.zarr/ └── quality/ # Copied through unmodified (quality flags) ``` -Each measurement group carries GeoZarr `spatial:` convention metadata and -references the per-pixel 2-D coordinate arrays `latitude` and `longitude`. +Each measurement group carries GeoZarr `spatial:` and `proj:` convention metadata, +with 1-D `y`/`x` dimension coordinates and a `spatial_ref` variable referenced by +`grid_mapping` on every band. Per-scan-line `time_stamp` is dropped, since it has +no representation on a regular grid. > **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid > groups in `conditions/geometry`, `meteorology`, and `instrument` are copied diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index b8bd5237..80307c74 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -30,10 +30,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:17:19.024518Z", - "iopub.status.busy": "2026-07-27T09:17:19.024425Z", - "iopub.status.idle": "2026-07-27T09:17:21.144560Z", - "shell.execute_reply": "2026-07-27T09:17:21.143809Z" + "iopub.execute_input": "2026-07-27T17:44:34.843116Z", + "iopub.status.busy": "2026-07-27T17:44:34.843026Z", + "iopub.status.idle": "2026-07-27T17:44:36.176995Z", + "shell.execute_reply": "2026-07-27T17:44:36.176300Z" } }, "outputs": [], @@ -43,6 +43,7 @@ "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import rioxarray # noqa: F401\n", "import xarray as xr\n", "import zarr\n", "\n", @@ -76,10 +77,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:17:21.147088Z", - "iopub.status.busy": "2026-07-27T09:17:21.146831Z", - "iopub.status.idle": "2026-07-27T09:17:21.956110Z", - "shell.execute_reply": "2026-07-27T09:17:21.955271Z" + "iopub.execute_input": "2026-07-27T17:44:36.179646Z", + "iopub.status.busy": "2026-07-27T17:44:36.179406Z", + "iopub.status.idle": "2026-07-27T17:44:36.884522Z", + "shell.execute_reply": "2026-07-27T17:44:36.883632Z" } }, "outputs": [ @@ -121,6 +122,25 @@ " \"0179_132_149_2160_PS1_O_NT_004.json\"\n", " )\n", " store = create_group_from_json(fixture, pathlib.Path(tempfile.mkdtemp()))\n", + "\n", + " # The JSON fixture materializes arrays as zeros; zero lat/lon is a\n", + " # degenerate geolocation the warp rejects. Seed a plausible grid\n", + " # (whole-degree spacing survives this fixture's raw int32 storage).\n", + " import zarr as _zarr\n", + "\n", + " fixture_group = _zarr.open_group(str(store), mode=\"a\")\n", + " fixture_meas = fixture_group[\"measurements\"]\n", + " assert isinstance(fixture_meas, _zarr.Group)\n", + " lat_arr = fixture_meas[\"latitude\"]\n", + " assert isinstance(lat_arr, _zarr.Array)\n", + " ny, nx = lat_arr.shape\n", + " lat_1d = np.linspace(45.0, 45.0 + 1.0 * (ny - 1), ny)\n", + " lon_1d = np.linspace(10.0, 10.0 + 1.0 * (nx - 1), nx)\n", + " lat_arr[:] = np.repeat(lat_1d[:, None], nx, axis=1)\n", + " lon_arr = fixture_meas[\"longitude\"]\n", + " assert isinstance(lon_arr, _zarr.Array)\n", + " lon_arr[:] = np.repeat(lon_1d[None, :], ny, axis=0)\n", + "\n", " return xr.open_datatree(store, engine=\"zarr\", mask_and_scale=False)\n", "\n", "\n", @@ -146,10 +166,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:17:21.958453Z", - "iopub.status.busy": "2026-07-27T09:17:21.958291Z", - "iopub.status.idle": "2026-07-27T09:17:21.962690Z", - "shell.execute_reply": "2026-07-27T09:17:21.961998Z" + "iopub.execute_input": "2026-07-27T17:44:36.886439Z", + "iopub.status.busy": "2026-07-27T17:44:36.886283Z", + "iopub.status.idle": "2026-07-27T17:44:36.890669Z", + "shell.execute_reply": "2026-07-27T17:44:36.890086Z" } }, "outputs": [ @@ -191,10 +211,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:17:21.964544Z", - "iopub.status.busy": "2026-07-27T09:17:21.964364Z", - "iopub.status.idle": "2026-07-27T09:17:22.032730Z", - "shell.execute_reply": "2026-07-27T09:17:22.032128Z" + "iopub.execute_input": "2026-07-27T17:44:36.892714Z", + "iopub.status.busy": "2026-07-27T17:44:36.892535Z", + "iopub.status.idle": "2026-07-27T17:44:36.969219Z", + "shell.execute_reply": "2026-07-27T17:44:36.968562Z" } }, "outputs": [ @@ -218,11 +238,11 @@ "source": [ "## 3. Convert to GeoZarr\n", "\n", - "`convert_olci_optimized` writes the native-resolution measurements to the\n", - "`measurements/r0` subgroup, plus `/2` block-averaged overview subgroups\n", - "(`r2`, `r4`, …) as siblings of `r0` down to `min_dimension`, and\n", - "declares them with the GeoZarr `multiscales` convention. `conditions` and\n", - "`quality` are copied through unchanged.\n", + "`convert_olci_optimized` first warps the swath onto a regular EPSG:4326 grid\n", + "using the per-pixel geolocation, then writes the `r0` base level plus `/2`\n", + "block-averaged overview siblings (`r2`, `r4`, …) down to `min_dimension`,\n", + "and declares them with the GeoZarr `multiscales` convention. `conditions`\n", + "and `quality` are copied through unchanged.\n", "\n", "We use a small `min_dimension` here so even the small sample yields several\n", "overview levels to visualize." @@ -234,10 +254,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:17:22.034444Z", - "iopub.status.busy": "2026-07-27T09:17:22.034346Z", - "iopub.status.idle": "2026-07-27T09:18:59.603654Z", - "shell.execute_reply": "2026-07-27T09:18:59.603008Z" + "iopub.execute_input": "2026-07-27T17:44:36.970816Z", + "iopub.status.busy": "2026-07-27T17:44:36.970716Z", + "iopub.status.idle": "2026-07-27T17:51:07.680749Z", + "shell.execute_reply": "2026-07-27T17:51:07.680089Z" } }, "outputs": [ @@ -245,161 +265,194 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:17:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + "\u001b[2m2026-07-27 19:44:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mReprojecting OLCI swath \u001b[0m \u001b[36mdst_shape\u001b[0m=\u001b[35m(4371, 6773)\u001b[0m \u001b[36msrc_shape\u001b[0m=\u001b[35m(4090, 4865)\u001b[0m \u001b[36mtarget_crs\u001b[0m=\u001b[35mEPSG:4326\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-07-27 19:50:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mDropping swath-bound variable with no grid home\u001b[0m \u001b[36mvariable\u001b[0m=\u001b[35mtime_stamp\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-07-27 19:50:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4371, 'x': 6773}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-07-27 19:50:24\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m10\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:17:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 2185, 'x': 3386}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:07\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 1092, 'x': 1693}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:14\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 546, 'x': 846}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:18\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 273, 'x': 423}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 136, 'x': 211}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:26\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 68, 'x': 105}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:30\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 34, 'x': 52}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:34\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 17, 'x': 26}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 8, 'x': 13}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:41\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r1024\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4, 'x': 6}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:52\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:57\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 19:51:05\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 19:51:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 11:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-27 19:51:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Pyramid levels (native + overviews): ['r0', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512']\n" + "Pyramid levels (native + overviews): ['r0', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512', 'r1024']\n", + "CRS: EPSG:4326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3423171/683526426.py:13: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " \"CRS:\", xr.open_dataset(output_path, engine=\"zarr\", group=\"measurements/r0\").rio.crs\n" ] } ], @@ -414,7 +467,10 @@ " (k for k in store[\"measurements\"].group_keys() if k.startswith(\"r\")),\n", " key=lambda k: int(k[1:]),\n", ")\n", - "print(\"Pyramid levels (native + overviews):\", levels)" + "print(\"Pyramid levels (native + overviews):\", levels)\n", + "print(\n", + " \"CRS:\", xr.open_dataset(output_path, engine=\"zarr\", group=\"measurements/r0\").rio.crs\n", + ")" ] }, { @@ -436,27 +492,101 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:18:59.605591Z", - "iopub.status.busy": "2026-07-27T09:18:59.605486Z", - "iopub.status.idle": "2026-07-27T09:18:59.826567Z", - "shell.execute_reply": "2026-07-27T09:18:59.825769Z" + "iopub.execute_input": "2026-07-27T17:51:07.682641Z", + "iopub.status.busy": "2026-07-27T17:51:07.682491Z", + "iopub.status.idle": "2026-07-27T17:51:07.937062Z", + "shell.execute_reply": "2026-07-27T17:51:07.935995Z" } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - " r0: shape (4090, 4865)\n", - " r2: shape (2045, 2432)\n", - " r4: shape (1022, 1216)\n", - " r8: shape (511, 608)\n", - " r16: shape (255, 304)\n", - " r32: shape (127, 152)\n", - " r64: shape (63, 76)\n", - "r128: shape (31, 38)\n", - "r256: shape (15, 19)\n", - "r512: shape (7, 9)\n" + " r0: shape (4371, 6773)\n", + " r2: shape (2185, 3386)\n", + " r4: shape (1092, 1693)\n", + " r8: shape (546, 846)\n", + " r16: shape (273, 423)\n", + " r32: shape (136, 211)\n", + " r64: shape (68, 105)\n", + "r128: shape (34, 52)\n", + "r256: shape (17, 26)\n", + "r512: shape (8, 13)\n", + "r1024: shape (4, 6)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n" ] } ], @@ -497,16 +627,16 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T09:18:59.828435Z", - "iopub.status.busy": "2026-07-27T09:18:59.828249Z", - "iopub.status.idle": "2026-07-27T09:19:03.967999Z", - "shell.execute_reply": "2026-07-27T09:19:03.967438Z" + "iopub.execute_input": "2026-07-27T17:51:07.939078Z", + "iopub.status.busy": "2026-07-27T17:51:07.938861Z", + "iopub.status.idle": "2026-07-27T17:51:13.873319Z", + "shell.execute_reply": "2026-07-27T17:51:13.872677Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqoAAAIrCAYAAAAnabsXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXe8ZVdZ//9eZe99ym3TMulACoQQDIIFCb0EBBQSUBBBQVDkR2JBqVIUBKXply8E+EZAQwSlhiYREKWKCIIUIYAQSUImyZQ7t51zdllr/f541trn3swkmQnMMDH783pNcu+5++y+1/6s5/k8n0eFEAIdOnTo0KFDhw4dOhxh0D/uHejQoUOHDh06dOjQYX/oiGqHDh06dOjQoUOHIxIdUe3QoUOHDh06dOhwRKIjqh06dOjQoUOHDh2OSHREtUOHDh06dOjQocMRiY6odujQoUOHDh06dDgi0RHVDh06dOjQoUOHDkck7I97Bzp06NChQ4cOHW4JmEwmVFV1WLaV5zm9Xu+wbOtIRkdUO3To0KFDhw4dbgKTyYTb3WaGa65zh2V7Rx99NJdffvmtnqx2RLVDhw4dOnTo0OEmUFUV11zn+P5/3Ja52UOrnFxe8dzmbv9DVVUdUf1x70CHDh06dOjQocMtBTOziplZdUi34Tm0678loSum6tChQ4cOHTp06HBEoouodujQoUOHDh06HCBc8Lhw6LfRQdBFVDt06NChQ4cOHTockegiqh06dOjQoUOHDgcIT8BzaEOqh3r9tyR0EdUOHTp06NChQ4cORyS6iGqHDh06dOjQocMBwuM51ArSQ7+FWw66iGqHDh06dOjQoUOHIxJdRLVDhw4dOnTo0OEA4ULAhUOrIT3U678loYuodujQoUOHDh06dDgi0RHVDh06dOjQoUOHDkckutR/hw4dOnTo0KHDAaKzpzq86CKqHTp06NChQ4cOHY5IdBHVDh06dOjQoUOHA4Qn4LqI6mFDF1Ht0KFDhw4dOnTocESii6h26NChQ4cOHTocIDqN6uFFF1Ht0KFDhw4dOnTocESii6h26NChQ4cOHTocIDrD/8OLLqLaoUOHDh06dOjQ4YhEF1Ht0KFDhw4dOnQ4QPj471Bvo4Ogi6h26NChQ4cOHTp0OCLRRVQ7dOjQoUOHDh0OEO4w+Kge6vXfktBFVDt06NChQ4cOHTockegiqh06dOjQoUOHDgcIF+Tfod5GB0EXUe3QoUOHDh06dOhwRKKLqHbo0KFDhw4dOhwguqr/w4suotqhQ4cOHTp06NDhiEQXUe3QoUOHDh06dDhAeBQOdci30UHQRVQ7dOjQoUOHDh06HJHoIqodOnTo0KFDhw4HCB/k36HeRgdBF1Ht0KFDhw4dOnTocESii6h26NChQ4cOHTocINxh0Kge6vXfktBFVDt06NChQ4cOHTockeiIaocOHTp06NChQ4cjEl3qv0OHDh06dOjQ4QDRpf4PL7qIaocOHTp06NChQ4cjEl1EtUOHDh06dOjQ4QDhg8KHQ2z4f4jXf0tCF1Ht0KFDhw4dOnTocESii6h26NChQ4cOHTocIDqN6uFFF1Ht0KFDhw4dOnTocESii6h26NChQ4cOHTocIBwad4jjfO6Qrv2WhS6i2qHDjxl/+Zd/yV/+5V9u+OxFL3oRb33rW39Me9ThloLPfOYz/Mmf/Annn38+H/jAB37cu/O/Hjt27OC8887jS1/60k0uOx6POe+88/jYxz72I1vnocaRtC8dOiR0EdVbIFZWVvjwhz/M1772NSaTCccffzwPfvCDueMd77jPsn/+539OWZa86EUvusn1lmXJxz72Mb70pS+xtLTE9u3bOeWUU/j5n/95+v3+zVrnjxrOOS655BK++MUvYq3lvve9Lw984AP3u+zi4iLvfve7ufzyy7HWcoc73IFHPepR9Hq9w7zXN473vOc9APz+7/9++9lFF13EPe95T37t137tx7Vbtyr8+Z//OVddddV+//Zbv/Vb/MRP/MSGzw7kGfzABz7ARz/6Uf7wD/+Q2972tvtd986dO/mTP/kT7nWve/GYxzzmoPb5oosu4jd/8zf53d/9Xe5whzuwbdu2g/p+h4PH7t27ueCCC7jnPe/JXe961xtdtixLLrjgAo4//nge9KAH/UjWeahxJO3LkYxwGKr+Q1f136KLqN7C8M53vpPb3e52vPSlL0VrzdFHH82///u/c+aZZ/Lrv/7rjMfjDcv//d//PRdffPFNrvf9738/t7vd7fjd3/1dlpaWOO6449i1axfPfOYzOe6443jf+9530Ov8UWN1dZX73Oc+/N7v/R6DwQDnHI961KP4tV/7Nbz3G5b9wAc+wIknnsiFF17IcDhEKcULXvACTjrpJL7yla8c9n0/WLz4xS/m13/913/cu3Grwd///d/zjne8g9NOO22ff7OzsxuWPdBn8KijjuKCCy7gwgsvvMHtXnTRRVxwwQUsLCwc9D6/7nWv40EPehCvfOUrOe+88/i5n/u5g15Hh4PDsccey2tf+1rudre7/bh3pUOHWw26iOotCO9///t57GMfy2//9m/zute9Dq2n84ynP/3pPPjBD2b37t188IMfRKkDn4198IMf5JxzzuHJT34yr3/968myrP3by172Mv7kT/6Eb33rWz/SY7k5eMELXsB//Md/8F//9V+cdNJJAJx99tnc//735z73uQ9PfvKT22Wf9rSnccwxx/DZz36WPM8BOUcnnXQSz3zmM/noRz/6YzmGA0UXST38mJ+f57zzzrvRZQ7mGbz73e/OGWecwd/8zd/wkpe8BGPMPut785vfzG1uc5sbjbjdEL7//e/vE+ntcGixefPmm7xHOvzvR1f1f3jREdVbCKqq4ulPfzqnnnoqr3nNaza8IAHOOussXvCCF/Cc5zyHSy65hHPPPfeA1/u0pz2N29/+9vuQVABrLS95yUu47rrrbtZ+X3vttbzrXe/i8ssvZ3Z2lgc84AHc61732rDMq1/9ai6//PJ2e9u2beOBD3wgP/uzP7thP9/ylrfw8Ic/vCWpAPe73/24853vzAUXXNAS1aZpuPbaaznnnHNakgoS4brtbW/L1VdffdDH8axnPYu73e1unHvuubz73e/mS1/6Eve73/146EMfekD7n/Cd73yHd77znSwvL3PWWWfxC7/wC/vd3ote9CJOPvnkDYT1QLeT9vVRj3oU73rXu/jSl77E9u3becITnsD27dv32dZ4POZ973sfX/3qV8nznHvc4x48+MEP3rDMaDTiPe95D1//+tdRSvGzP/uzPOIRj9hwH37kIx/hgx/8IOeffz53uMMdbvKcHsi9cbDHciD7eXNxc57BlJr/8Ic/vM+1/uxnP8tll13Gi1/84oPav8997nO87W1vY2lpiX/7t39ridOLX/xiNm/eDMCXv/xlPvzhD7N7926OO+44zj33XG53u9u16/jSl77EW97yFp773Ody3HHHtZ+vra3x7Gc/m3POOYcHPOABAHzve9/jL/7iL3ja057GUUcdxdve9jYuv/xy/uAP/oATTzxxn/1bv/yWLVu4+OKLue6667jLXe7CYx7zGKyV1861117LS17yEh75yEfuI9/x3vOsZz2LM844gyc+8Yk3ug9btmzh2c9+dvvdoii47W1vyznnnMPxxx+/3/3aunUrF198Mbt37+ZBD3oQ97///QG47rrruPjii9mxYwf3vOc9eeQjH7lhv3bs2MFLX/pSfuM3fmOf1PjHP/5x/umf/ok8z3n0ox/NCSeccGAX9EZwxRVXcMkll3DFFVcwPz/Pwx72sDaam/Zl/bVKCCHwrGc9izvd6U488YlPPKD13Rh27NjBe97zHq644gq2bNnCPe95T84666wf+vg6dDgQdKn/Wwj+5V/+hR/84Af82q/92j5kMuE3fuM3APjbv/3bH+l6QUjeweLSSy/llFNO4eKLL2bTpk1cffXV3P/+9+dxj3vchlT9bW5zmzbNevzxx3PZZZdx73vfmxe+8IXtMl/72tdYXl7mZ37mZ/bZzt3vfnf+8z//k7W1NUBI3Nlnn81nP/tZFhcX2+Uuu+wyvvOd7/DQhz70oI/lwgsv5GMf+xjnnHMOn/70pzHG8LWvfe2A9x/gve99L2eccQYf+9jHmJ+f513vehdPf/rT97u9iy66aJ+o74Fu58ILL+TjH/84v/Irv8JnP/tZ5ubmuPDCCznzzDP3mXB88Ytf5NRTT+X5z38+TdNgreX//J//w6/8yq+0y3z5y1/m9re/PS972cvIsgxrLeeffz73uc992nMO8IUvfIELLriAK6+88ibP54HeGwdzLAe6nzcXN+cZfMITnkCv1+PNb37zPsu+6U1vwhjDk570pIPaj/n5eU477TSMMe3Pp512WrtPz372s7nb3e7G17/+dbZu3cpHPvIR7nCHO/CWt7ylXce3v/1tLrjgAnbu3Llh3ePxmAsuuIAvf/nL7WdXX301F1xwAR/96Ed5xCMewc6dO7nmmmtucPKalv/IRz7Cueeey8rKCt57nv70p3Of+9yH0WgEwPbt2/nEJz7BH/3RH+2zjn/8x3/k1a9+dasnv7F9MMZskGosLCzwnve8h9vf/vZ88pOf3Ge/Pvaxj/HLv/zLrK6usmfPHh74wAfyxje+kW984xucc845LC8vs7a2xrnnnsuLX/ziDfuVNJzf/va3N3z+tKc9jbPPPptrrrmGPM85//zzN8ilbg7e+MY3csopp/CP//iPbN26lR07dnCPe9yDF7zgBQAcffTRfOQjH9lnH0Hu1Ve96lUb9Pg3tb4bwqc+9Slud7vbcemll7JlyxZWVlZ43vOex//3//1/P9Tx3ZLhgj4s/zpEhA63CLziFa8IQPjgBz94o8sde+yx4aSTTmp/P/PMM8PJJ598g8u//OUvD0D40Ic+dMD7clPrDCGExcXFMD8/H+5///uHuq7bz9/5zncGILzmNa+50e+/6U1vClrr8N3vfjeEEMIll1wSgHDxxRfvs+wLX/jCAITLLrus/Wzv3r3ht3/7t8MJJ5wQnvCEJ4THPOYx4ZhjjgkveMELQlVVB3ysCfPz82Fubi587GMfaz9bXl4+4P3fs2dPmJubC494xCOCc65d7tWvfnWYm5sLZ5111obv3+Y2twm/+qu/epP7df3tpH1dWFgIn/zkJ9vPrrrqqpBlWXje857Xfra2thaOPfbY8FM/9VNhZWVlw3rTuRyNRuH4448Pd7/73cNkMmn/vmPHjjA/Px+e8YxntJ994QtfCK997WvDlVdeeaP7fDD3xoEey8Hs5/5w5plnhvn5+fD0pz99w79XvepV7TI39xl83OMeF6y1YceOHe1ny8vLYTgchoc97GE3uq4bw/z8fHjyk5+84bMPfOADAQgvf/nLN3z+67/+68Fa217Xv/u7vwtA+PKXv7xhuZ07dwYgvPKVr2w/+/SnPx2AcNppp4Xdu3dvOIb9IS1/xzveccPyX/7yl4PWOjz72c9uP3vd614XgPDFL35xwzoe9rCHhU2bNrXX8mD3IYQQHvnIR4Y73elO++zXmWeeueF7T3va08KWLVvCIx/5yLB379728/PPPz/MzMyEpaWl9rOvfe1rAQh/93d/1372vve9LwDh//2//9d+1jRNeNSjHhWA8Gd/9mc3uI83tM7PfvazQSkVnv/8529Y9l3velcAwj//8z+HEEJ42cteFoDw7W9/e8Nyj3vc4zacvwNd3/725Rd/8RfDT//0T++z39/85jdv9Lj+N2JpaSkA4dKv3i586vKTD+m/S796uwBsuP9urego+y0Ey8vLAPsUdlwfs7OzrKysHPB607IzMzM3f+f2g/e///0sLS3xrGc9q031AfzSL/0Sp512Gn/zN3+zYflPfepTvPSlL+X3fu/3OO+88/iXf/kXvPdtZGcymQCS1rs+0mfrC8kuu+wyPvGJT7B161ZOPfVUTj31VPr9Pv/8z//MD37wg5t1TCeffPKGFOX6a3FT+//+97+f5eVl/vAP/3AfXWMI4YD34aa2k3DHO96Re9/73u3vxx13HHe9613593//9/az973vfVx99dW86EUv2uf6p9T9Bz7wAa666ir+6I/+aMO5P/roo3nMYx7D2972tvazn/qpn+K8887bkG7dHw723jiQYzmY/bwhZFm2TyHVbW5zm/bvN/cZ/M3f/E2apuGiiy5qP/u7v/s71tbW+M3f/M2b3K+DwVvf+lZmZmb43d/93Q2fp4j5gZyHG8Iv/dIvtdICuOnz8Mu//Msblr/LXe7CQx7ykA22a7/2a7/G7Owsb3jDG9rPvv/973PppZfy+Mc/fp/n/Yb2YTwe8653vYvnP//5/M7v/A7nnXceO3fu5Jvf/OY+BaaPecxjNuz7Qx7yEHbv3s1d73pX5ufnN3y+urrKN77xjRs9zosvvpgtW7a00XQAYwxPfepTb/R7N4Y3vOEN5Hm+T7T50Y9+NMcdd1x7HZ/4xCdijNkQLd+7dy/vfe97N5y/A13f/uCc45prrtnHFeO000672cd3S4dH4dGH+F+nUU3oNKq3EKTBeX0qe3/Ys2cPmzZtOuD1pmVvar0Hi+985zsAnH766fv87fTTT2/T2t57Hv3oR/PRj36UxzzmMdzhDndgMBi0acW0X4PBAGCflw7QphKHwyEghOLhD384p556apumB9E73vnOd+bcc8+9WT6B+9NdHuj+p/Nx/cG9KIoN2sEbwoFuJ+H2t7/9Pus46qij+O53v9v+/s1vfhPgRgtyvv71rwNiofVP//RPhBBaYv2Vr3yFa6+9lvF4vMG+7KZwoPfGwRzLj2I/b6qY6uY+g/e973055ZRTeMtb3tJqKd/0pjdx9NFH87CHPexG13Ww+M53vsNJJ520D8E7+eSTKYqiPfc3BweiO16P/RGZ0047jQ9/+MOsrq4yMzPD7Owsj3/847nooot41atexcLCAm984xvx3m8ojryxfbjiiiu4733vSwih1eJmWcaOHTvw3rO0tLThup966qkbvr9169Yb/XzHjh03epzf+c53OOWUUzZMum7o+A8UX//61xkMBjznOc8BaO/nEAJN07Ra9WOOOYaHPvShvPWtb+VP//RPMcbw9re/nclksuH8Hej69ofnP//5/OIv/iInnXQS97jHPbjPfe7DQx/60P1q8Dt0OBToiOotBD/1Uz8FwOc///l9BP4J3//+99m5cydnn332Aa83aT6/8IUv3OB6bw4SOWyaZp+/VVXV/v0f/uEfuOSSS3jXu97Fox/96HaZT3/607zkJS9pf08FVPvTP1555ZVYa9vCjn//939n165dvPCFL9xQaT07O8sv/uIv8trXvparrrrqJiN/18f6aEvCge5/2o+6rvdZx/4+u7nbSdifV6zWGuem/U7SPlVVdYPbTe4RJ5988j4WSre//e15/OMfv99q9hvDgd4bCQdyLIdiP6+PH+YZfMpTnsJznvMcPv3pT7OwsMAXvvAFnvvc5+5Dbn5YGGPa7MN6eO9xzrXnIOlZr38Nbiwbs7/7/8ZwY/f6+mvx9Kc/nTe84Q1cdNFFPO1pT+Mtb3kLd7vb3TjzzDMPaB9e+tKXsmvXLr773e9u8JK9Ia309e+nlOG4oc/X32f7gzHmZj/XNwSlFIPBgFNOOWWfvz3/+c/n2GOPbX9/8pOfzAc/+EEuvfRSHv7wh/PmN795n/N3MOu7Pu5+97vzve99j49+9KN88pOf5N3vfjcvfvGLedzjHsff/u3fHpTDzP8WdFX/hxcdUb2F4KyzzuK0007joosu4nnPe95+027/9//+X0Beigez3tNPP52LLrqI5z73ufuVAIQQuOyyy/bbUOCGcMYZZwBS4LI+Yuic46tf/Wr79xQVu8c97rHh+5/97Gc3/H7HO96Ro446is985jP7bOvTn/4097jHPfaJIpVluc+y6bMfRRU4HPj+p+P96le/yjHHHNN+vry8zOWXX74hnfnDbOdgkKqW//3f/32/L7D1y9zlLnfh4Q9/+M3e1noc6L1xMDgU+3l9/DDP4BOf+ERe8IIX8KY3vYn5+XmUUvuNGP6wOOOMM3jnO9/J0tLSBlL3ta99jaZp2nObJmnXd8D4UXoMf/WrX93ns6985SucfPLJGyKcd7rTnbj3ve/NG97wBrZt28Z1113HH//xHx/wdr773e9yyimn7NPw4Id5Ng4GZ5xxBu9///v3idj/MOfyrne9K29/+9t58pOffJPZioc97GEcffTRvOUtb+GEE07gS1/6Eq9//etv9vr2h5mZGc4999zWTeaZz3wmr3rVq3je857Hne50p4NeX4cOB4NOo3oLgdaav/7rv2bPnj089rGPZWlpacPf3/rWt/Ka17yGpz71qdz3vvc94PUqpfibv/kbFhcXefSjH82uXbs2/D1t7/3vf/9B7e8v/MIvcPzxx/Onf/qnG/b1Na95DVdccUVb7Z7Sv//yL//SLvOd73yHd73rXRvWZ4zhd37nd/jYxz7G5z73ufbziy++mMsvv5xnPOMZ7Wc/93M/x5YtW3jTm97U6gpBol3vete7+Mmf/MkbjSAcDA50/3/hF36BY445hpe85CWtVAHgJS95yQFFqg50OweDhz70oZxxxhm88IUv5Iorrmg/997zkY98BICHP/zh/MRP/ATPetaz9kmBLi4u8g//8A/t7x/5yEc477zzbtJz90DvjYPBweznzcUP8wxu376dhz/84bz73e/mb//2b7nf/e7HySefvN/tvPrVr97Qpexg8NSnPpWyLDc4QZRl2U5Ck93Zne9859aiKWFpaWkfffAPg0svvZT//u//bn//h3/4Bz71qU/x27/92/ss+/SnP51vfetbPOMZz6Df729wnbgpnH766Xz729/eQLrf9ra38f3vf/+HO4ADxG/91m+xsrLCy172svazlZUV/vqv//pmr/MZz3gGIQTOO++8fTIe3/zmN/mP//iP9ndrLb/+67/Ohz70If7sz/6Mfr/P4x73uJu9vuvj3e9+9z6Sq5S1ONK6/B0udFX/hxddRPUWhLvf/e584hOf4Ld+67c46aSTeNCDHsTs7Cxf+tKX+Na3vsUf//Ef79fqZdeuXfvV3m3atImXvOQl/PRP/zSf/exnedrTnsZtb3tb7nvf+3LcccexY8cOPv7xj3PqqaceNHno9Xp84AMf4JxzzuGMM87gPve5D1deeSX/+q//ygtf+ML2RXT22Wfz2Mc+lic96UlccsklgBRCvfzlL98nMvac5zyHb33rWzzwgQ/kkY98JKPRiA9/+MO8+MUv5hGPeES73HA45N3vfjdPecpTuP3tb88DH/hAyrLkIx/5CKeddtpB2XfdFA50//v9Pu95z3t4xCMewRlnnME973lPvv3tb3PuuefeYDTz5mznYGCt5R/+4R/45V/+Zc444wzue9/7Mjc3xxe+8AXOPfdcHvzgB2Ot5cMf/jBPeMITOPXUU7nf/e7HUUcdxeWXX873vvc9nvnMZ7brS/ZUj3zkI29Uz3ig98bBHsuB7ucPg5v7DIIUVV1yySWMRqMbLaJ65zvfyde//nX+8i//8qD37x73uAdveMMb+P3f/30++9nPcqc73YnPfe5zLC4u8p73vKedoA0GA175ylfylKc8hbPOOouTTjqJb37zm7zqVa866EnpDeEZz3gGT3jCEzjhhBMYjUZ85CMf4XGPe9x+Sfg555zDMcccw44dO3j84x9/UJ26nve853HppZdy17velYc85CFceeWV9Ho9zj///A3+qocK97znPXnFK17Bc57zHP75n/+Zk08+mf/8z//kFa94BR/84Adv1jpPP/10PvShD/GkJz2JU089lZ/7uZ8jyzIuu+wyyrLkr/7qrzYs/+QnP5mXv/zlvOMd7+AJT3jCPpPfg13fenzpS1/iGc94BqeffjonnHACV1xxBZ/5zGf40z/90xucbHXo8KOECgdTctzhiEAIga985Ssb+ozf85733G8q8h3veMc+XokJMzMzG8ygQaJ0//Ef/8Hy8jJHH300p5566j4p/3e84x3Udc3jH//4m9zXqqr45Cc/2Zq63/ve995gMJ7w+c9/nv/6r/9iy5YtnH322VRVxcUXX8z973//fYpuvva1r/HFL34Ray33ute9brCPetM0fO5zn+Pyyy8nyzJOOeUUfvqnf/om93l/+Ku/+itOPfXUG4xWH+j+Ly8v89GPfpTl5WXufve7c/rpp/Pe974XYEOThre+9a0cc8wx+3QsOpDt3NC+fvjDH2ZxcZFf/dVf3Wf/v/CFL/C1r32N4XDIz/zMz+y3wOu//uu/+PKXv0xd19zudrfjZ3/2ZzekEb/4xS/yb//2bzzykY88IP3vgdwbN+dYbmo/94eDuafh4J7BBO89b3zjGwkh8JSnPGW/DhZN07B582Ye+9jH3mjrVZBzc8opp3C/+91vn7/t2rWLT3ziE63h//3ud7+22HA9/vu//5tPfepTDIdDfv7nf548z3nTm97EPe95T+5yl7sAU7P3hz/84Tf4rK3HZz7zGe51r3vxwQ9+kLPPPpt//Md/bA3/k853f3jyk5/MW97yFv7lX/5ln+t9U/tQliUf//jH2bFjB6eddhpnnXUWX/nKV/j0pz/Nb/zGbzAYDG5wHanxxMMe9rAN9/3OnTt5xzvewc///M+3hGzPnj28/e1v58EPfvA+xVeXX345n/zkJ8nznAc/+MHMzs5y4YUXco973GOf5gDrcWPrrOuaf/3Xf+W///u/GQwGnHbaafzkT/7kftdz8cUXs7S0xIMe9KAbnCje1PpuaF/27t3L5z//ea688kq2bdvGWWed1Rab3ZqwvLzM/Pw8l3zlVIazP5zm/aawtuI458zvsLS0xNzc3CHd1pGOjqh26NChwxGCf/3Xf+UBD3gA3/nOdw662O9IwXqiejDR/hNPPJEsy/jv//7vW2WBTocjH4movucrtz8sRPVRZ367I6p0GtUOHTp0OGIwNzfHu9/97lssSb25+Kd/+ieuvPJKzj///I6kdujQYQM6jWqHWy3++q//+kaLCIB9eqF36HAoccYZZ9ws14NbKj7xiU/w9re/nUsuuYSf/Mmf5GlPe9qPe5c6dLhJeDTuEMf5PF2yO+FWRVRTVe61117Lne98Z17+8pffqNl5h//dOO64426yB/z+dIQdOnS4YZx88sm89rWvPSDCvWnTJs4880we8pCH8LCHPax73jp06LAPbjUa1Xe+8508/vGP58ILL+Tnfu7neNWrXsV73/tevvGNb7B9+/Yf9+516NChQ4cOHY5gJI3q3//n6QwOsUZ1tOJ47F2+0WlUuRVpVF/60pfypCc9iSc+8Ync4Q534I1vfCPW2n2MkTt06NChQ4cOHTocGbhVENWlpSW++tWv8sAHPrD9zBjD/e9/fz796U//GPesQ4cOHTp06HBLgkcfln8dBLcKjWrqWHL9FP/27dv5z//8zxv8XlmWG9pweu/Zs2cPW7Zs6SpTO3To0KFDhx8DQgisrKxw7LHH/sjaYXc4cnGrIKpJhmvMRk2JtRbv/Q1+78/+7M/4kz/5k0O6bx06dOjQoUOHg8eVV175Y7Fyc0HhwqENVh3q9d+ScKsgqtu2bQPYp0PTzp0727/tD8997nM39JBfWlrixBNP5MorrzxgcfN4UvGM33sbV16xi2A1wTvquZxmaGh6ClMF7CigApjKozx4C6oOmCbQ9A1BQ9AKbyFkCm8Vysn3vIGQxxs6gHIBXQMKmoEiW3LkSxXNIAMCpgr4XKNcwEwcIdMQoOkZglXTdTiPboL83giZD5kmaEXQsq18qcTllpBpXKHxmSZocJkiGEUwoLwsiwGc7KbyAe3Axf32mYIQCFZh1zwoCEphJx4CuELWBxCMrC9YOR+6BkLAZ7K9oEAF+T/pn4//j2WDKv5fV/IxPmDHAZ8rmp7CToLsA2AnAV3JuVA+gFIEBa7QKE97DXUd5BxYWX891NiRJ1iwa3Jd88USUzqaYU4ztPhM4Y1CBdCNHKu3CuUDky1G7olJIGhFf1dNU2gmWy31EHp7AgooZxXagR3L/ikn191nCjsKBCPrDArZz1KOs55VmHJ6bpQHU3p6u0p0Fag25TQ9jc8VyoMuA2i5LsHId4KR+5BAe9+6It4fyDLeAFqWUy5+T8t3Q7wm6dJoF9CNfNXl8b7w03Wl7bTXUNGuA017v2Zrcs6CgXogX1Zetnv747dy0fmP4Sl/9g6+c+VOTBlQTpbXdcD1FMqBnXhM6TFjh8811bwlaOQYguyrcoFsrUGXDtcz+NxQbjbo0tPb3UAI6EbW7QvNeEsOBKoFBV6RrwWCgnqo4vPkMVXADeQEZiueckGzeqyi2Au6gWwUMGNP0Aq7VjO4eg18IFiD7xlc31JuyuWaa0V/Z0lx5R7UpAGjCP0efljIMYxKAqAaB3UNwz6MS/mXW9z2BdAaPWlQ4woI1JsGNAs9zMRhxg0qpGdFLoTPDc3AyrUKck30pEEBLtMyrkwa3CCX+0Sp9t4PWtEMrTxnyDgi16CRMWNco2tPyAwhM6hRhVpeg7omlCV4T2gcNI4QPMpmEDzKGlSvR6jrOB4EVJ7JeNI4UAqqWgIaIaCMAS1jkjwcgF83iKRsmjGyTKpHjv9XRQHagKsJjUMZDdoQ6ppQNygbAyZaQX8APQuNl3E2BGgczA1oNg3wgxwzctQLBZOtlt51FdV8RjVvqeYUPgddBZSX+37myorlkwvsOGBGHhUUk60aO5Ixd7KgaAYK1/PoStEMIGSgKshG0N/pcX2F1wqXK0wZyFfkufRWrlE5p3AFNPNB3imrmnw10NsT0JXc8z6T51t5MBOPCjLeqyBjZj2jcT3wOp5f5Pn0FlwvYEcw2BVwmfw9FIoX/erZPOhM6Za1vLzMCSeccKOd4Dr878Gthqje7na34zOf+QyPfOQj288/9alPbWhbeX0URbFfu5S5ubkDJqpZVmFnhzAzQmlFPWfAKHIHtlHycjZCVFUmg75tAs2chiZeoESwqoBTiibT+AKyiby1G61pepFAeFAT+UJGoF9WTI4pqOcsw6srVKHwsxZVe8JAXiRm3KC0JURCETKF1gEywAey1RqfG0IcvF1PXsZqmGGskFN6Bh0HcKNVS45UCPKC1EAciEwdSUsRl9FT0mOzgLdKXnC5DHgmkiNvI/cM8ZwEIe6KgI/EJ6SgeSSowdK+NBPJSSRWGXn56zrAEKyH/pKDAPWMwRvZNxscxntUEDLoco1R8tItVqEZGEKhyGuPWfP4XKMbDT05bqVk8M6vraEoUMYQ8gyVa6wPmNKDDzR9jfHy4jC5IRiFG8r50isWNWdgTtMbB5hVmHGg1whZz8aOYISgKqVockUzC66Qv+sKQg9CA/nIg9JoA7YSMputNOhaY7RiclwhZMkAkfw75PzpGrSXyZDX4PrxGGtZXBNJZi7kK2XldB1QceISjPzzRq5zIq3ayT0XjMIoWd+G6xloJwvE5yLoODHRQBE/s2kmArqQC64bWSbPB8zNzZEN+uh+D2XkJa892OCxXo5H5wGVgR8I+TZa9t315T7VjTw7SnkoPEYpyu0WjSKvHHogN5tJ12XOovtGJhAadIBe5VAuUBmDHXnylQZXaEZDS7HXo3pQH2fwRwXyJejvKuntrHBzPVyuyVcdlpzQt9TzPer5DJ8p8jqgJx6vYbBzBbXagLXQHxB6OcbHieFcD58bzGoJQYiYngSC8mAKtLfo5Sh9ynqE3GLWGryGkMt6fC6kTpUNqmrAaZy2BKNlclTW6ErhhgXZuCaYDKUtxhvwAdfPUDqgxw14sBODG1iypRJVNqBAj5pICBWqdASnCdqgvI43UyA0tZBDY8HEm8VaIZ5ZBt7jqwq0RuUFSltwXg4bQOdyX4UQByQvv6d7TV/PHCfd2GkyDOCcbC9YyHswUQRXyQNkNNi+zHRSFk8ZQl6gvJIgwIzFTBrCyhpqrcHmiuAVvtcDMhqbo4cWW1iagcHkYL3CD+S9ka8FmqML6qM1+Y5AVgWyVYfdq5lsMdQ5VMcFzFjRW5ExVYeAXgXXhzAPdeFRjcKUCm0grwJ55dEOqKGalWCF9zI2eBsoVhQ6A5MHlA1kq57gFc1QAiI2yEREWcV4q6GKRNdn4PP4/NUyQQy9+N7JFXUc830e0EoxnJ/Z573745LgucPgo+o6H9UWtwqiCvA7v/M7/PEf/zG/9Eu/xN3udjf+4i/+gquvvpqnPvWph3bDSjHZZBlVOdk4kI09qpao4XibnUbjeppQaJmNpquSZug+tFEcgKAC9BT1UGMq+Vu+5nG5opyPEbZRXG/fEjJFtiIvTJS8iH0mJIE6SKQ3RlODkeiT8oGAkDAVArr0uH6MunrwhYkDuRCOoFUbzVQ+oBohLUFDQIhN0KCdjOyuiH9TEh2V2bfCS+BXSJpRLTkJxMilA2fV9AWhhOQTifD6qBtKCFr6THkZFF2e9lsGwjb6UweCUu359rkcULAKvSrRL59pTOWhitciRvKCizGlRMpVjIBrMJVEIuptQxmM9fQ8gUSwm4GhntW4AvKVgCnl7z4DO/I0Q403MLjG4Yp4npBoaT2Epm/JVzw+UzR9hWoCtonR357C5XJP+BxCfMmqeH8VexrwHje0NEOLK1R7bOlfS/RjFNPnEg1JE4i0jOxTjGzHa6D89Nok4qkcaKbnUH6I6/ChjaonEjC9pmo6SYnraqOqMQCm64Bu4vk30+enJSLEa28Aq9pnLBiNbsBlgNLx2sXJ0mQasU7743JF0zeoxkgENkb3g1bUM0a+a1XMNsj9K/ehXI/JgpGIWAN2gkRu5+SgdBNoBhqvYPADxez/TMgWS8zSiJBZdG0wlQMFbpBRLWS4QmHHEpU14wY9rlFLEnFFa/ygoNncl0hv6XB9G0mCFcIZgkQolYK6Qa+WMl7kGRhNM9+TMUALAdda0QwztPNyv5Y11PK5G+aY0qEaj6ocfl6jlaJeyMkXS/SklolxblHOoye1bNco1EqFHsd1jUu5vj5siHqSGXlWMxsjohUohdIKsgzyHJqGMBoTypLQNATv0b2ekNbVkUQ20/qMifdQmN7I6X7zfhpRVevuo/S39nvx9qqqKRk1eroeoyWK2sSwvPcxM6BQ4wq9OiZMSomQZxY1mhB6lmpLH5fFzEYj40FuFcpryk0BM4mZHh2o5mSMV95jRw6fKVxPxpVyQeFMQAchpmYEg71yvxd75V5XTlHNqTh5Dbi+YlIYZq6osCNPPcjBK4wDuyoR0t6u0GbOXKFkkp6eUa3aLMx4m6HcpGK2RCbI6dl3eSBk4AZClMMYqgUhs7oWIusPrRtUhyMYtxqi+ru/+7tcd911PPCBD6QsS4477jje+973cvvb3/7QbjgEhleO6K02MhM1ipDLS1DXYMp1ZDSlSmOkr02dr09nIxE2n00JJ8i4YEce5eWF2BTT1IsdBcbb5GUqRFTSlsT/KxfDXJFMEOLfkBdmPWNRfSG+srPgFSgTR+YYQU2EIGgVQ2vTVCnQpu8TsQmKmGKLEa2JRzkZ7LyJ5yYFNJo4GCdiGmgJvSuU8BAP2q2LwsVzptSUpE4HUNqBvyVYmUS4E8nUjfyhGmrMSKPrGGVBoRpPyETukNLguvJyXqM0QyOEUsi6kJds1Qu5i/IIlVL+8XiLvY6mb3CFnE/dyPHmiyXBGsbbclxP1qtLcD05nmzkMRMf991gqzixWVFCYCOBNlVMr4dA/5oJzVxBPWsYHZVhJ+vIaZwI6CYGgRKxIxJIrkdOo/SiJZs6vrQDkr5PQSTPNPIdieX1I95pG+l+T9too66e9v5Pz4Xy1/s5ZgZUfI58MX1+QO4TSaULudcxyq+8TLyE0EuaEgVZnECqIJMwUzpcLmQp5OAbhY6k1hUSSZLjVe2kMGh5Nk0dUF5F0ivnrZrTjDcbtJNUq/JQDxTDHUKQ7cjJs5JZdO1RozpeA0mXN31NtuawI0ewQhTM0lhIUZ7B7AA336OezcAH9CBDNR6zXKFHFUEXoDVhfogaWVTjCMYQCgtG4zOJ8Nu1hno2o57L0I1HN16uw7hqyZgbZNTzGXqiyXc3+J7FDQwq5HLvNR5vdUv0dBkjplajSoeZVELSfBAiM6kjWYzjgdaoSQVV0ol4lNYE7wkuAA0KRagqQlW3aXxV5Kijt0JZo1al0UeYVITgUF7S7iEEaAJKG7BGtquURGvDuhtU60hS42QreBSRKAdESqEiaXYyCCpjZKxwDpwQVdYmqEFPtt3E45npo4wFa6iOGrB6bMZks0wOh1drslWRcLk6MLgGZq6YUM9aeteOWb3tgGpOoSvQtcejoxxMHrRiT5JnBVQeJ4xKpEP1jKK/s2F4dUOwGm8VzcC06XflvEik7HTy1gwUo2MUdi1FRoFhXG8jY7MrNM1AZFXeSISUAKYUIup6kbSagO95zEjTzAFOka3I+WwGQmSPFPig8e0M+1Bt4+Aiqtdccw2vfOUr+djHPsba2ho/8RM/wXOf+1x+5md+ZsNyb37zm7ngggu47rrruMtd7sIrXvEKTj/99INe5nDiVlMup5TiZS97GUtLS+zevZvLL7+chz3sYYdl276wuCISGq2oB4p6oFvClf6fiFFKZSYNY1BJ4xd1kutv4EB8KUYdnhJtUaun1Er0jl7JC0wp7JqTl/DQ0AwMTd9ix0Kk2zRWQCJMtQzO3iZiFdqogk8RWkX7Ina5kLxEjER/SktIWiLh42qaEPWRAVOGKUkKQhIkwinnLWlbUZJeDika1kRC56baQV2Hlryk/fcm/j1FMv002qY82DK028pGgWxN0lj9XTUqBFzftOfe9Q3VrBCEoEVLZ8cOM/GtRkv0mipGQ0L8m291W2bicbmmGRoZ5CuPrgLlvDCwfNlTLDb0/2eZfNdEonM9IUTF3oD2SOS6ob3+ZhLIVoXw5sue3qIjX/Lkyx47kUitt7T6M9UEqtkYScxpiXUiqOla2Im8WNK5CkYizs1Axciz/A0dU3oxUp3Ot3ZTkrpBb7ouihpitHaDvjitl+nykhmApHdNz0yahLhCzpMroJ4R0nl9MqyapOuN5DTeS8HIcqaMkSpEK5oIfooOuVxLpCc+s67QErnqqRhpVZTzhnqg4zFNJx5p3XbiyVc9vT1yjbKxXJ+mL7rNYknuJd1AsBpdSmpZ1y6SckXIjER1wzRqLPrRuiVnzM1QHT1LuZAJITIKr8GMGsyonj5bk1oii0UuJLWfE6zB9TKC0XGs8dhRg6kCQWvMakW2OIHMEvo5zaY+rm9lMpEbqqOGlEfP4IpIdEfyLOnGg9GYtUoit/F4lHNCQBsHroHVMWE8hrISoqg1lFFH65xEKb0jVLUQvRBiJHUEdY3qFehBH1UU6MEANzeAIofBAOZmIIuz3URSA6DiTZWIqNaQW/l/+hvrxuGkZdWRfEcyjVLQNEKsMzmHwWg5x0oRvOwrjRyH0gbV76GUhvkZ3LY5Rsf0KBeUjHVKJi/VrKaa0fR2N/R2NaAV2UpDkirYsdz31axkwPIVef6FrMr9bmolOncfWk2+HadJs0KXIkvRlafYW0s0f3nS6rlTUMBMoLc7MLzG09vjMXVgslkx2ZQmmoG1YxSjoxTVHNRzQkoTSZU6A3lXhL4nG9SwqcYNPSELuCLQzAbcjCeYgyNutzY885nP5JRTTuGd73wnl156Kccddxz3u9/9+N73vtcu89a3vpWnP/3p/MEf/AEf//jH2bJlC/e9733ZvXv3QS1zuHGriagmaK0PuwBb155isUa5QLk5l9mqhkYpvDHoRiJddS8WwUxCjBCGddFAiSSFIKlNUwWaqA9MA0fT0+0LzOeKbM3T9JWknpV0DjYxKigvS8dkm6XY4zDluiiaB4ysI2h5QflcZsb5imsJSbCihZySzxiNjIQ3pdh1irIyJTmpMEV5RBoQtYqpCCQY2qhUKrpSZZi+VJtExmPALo/p2RDfJeuiZyl6rV18uSdCHqbLmXGaCABBdKNJO5nITNCKOpJKl8vLw5QBXblITqN+y6o2qqed/D9JPFJUz/V0S6SbQkXSDq4vEY+UTvOZEAaXSxFcG9UOMYLhJDLncgjzhnzFYSeBbORwhaQz66HB1PGFFOSF1PQ1bianGWjsOBBKKDfJukSqEO/dRs6TruXc1tn02iaZhvYSbU3aU5l0bZx4JZKqo/SB612j9me9joiC3PPrIrfp2q2PmrfaYzP9f7bkqQcaTCB41RamZWuyIu1CnBBGgl+HVjfrcklPmuRMp+R8ByuRV1NPJ1Qq0J7/9p5HIqk6rlOeiVgYp+QZLEYetEgHRE4jBX1BEyU8Fm8V2UhSuKp2BKNRzqPKBj8oUHWDzw0KIdZ27LCrtSwzaaAQcuRme4yPymkGBl1Fgry3Fhl3z0qx06SWLIE1UozUz2lmCxl7Koee1OjCUi/08FYKucxqJfKUwgo5BerZDFM2FNeO8YM8ylc0upRJGi7g+7mcUxcko6AVbraQc1lF8mk0lI0QOecJWqNQQjK9h6oWMmjkRgreyXJNI5pUraNcoCK4lNYHPankc4CyFqJaVTIXCkiWCLlmG1DkEpleWZvKBJKGNYQoc1HXI69MtayNTDKYGUi0WmuUUiI/8J6gYwFXWaF6BW6Q08xkMoFSElEEMA1kax7tAsWuiZDf3KArj+tnNANN01fQl+e+2AszP6jxmcb1A8VuycKYMRR7A9mKQyFFu/nuidzbSkmBHdDMGNaOyhi6GtXEwt6UDUHeW/mKJ19xNH1NPdR4oyhWRLZUzkvBVhrr7QjwSiKkNoCPmRgtY5POPL7RhKgJdr1AKAJmoUHnjiMFR6JG9a1vfesGze6rX/1qXv/61/O5z32Ok046CZDGR0996lP51V/9VQD+6q/+iu3bt3PhhRfy3Oc+94CXOdy41URUf5yYpu6mWlDWpVeTzi9b89ixb3WPOpKdVIEerJrKpxStXi5JA5SP6fmYsq1nNMGIJKBY8gwvX8as1nEwM5jKky858r0VZlS3qW1vI9kM0FbUK6kKh0jSItn0VgibKxQphc31xvhELlVK5cWXe5uCTz+nL6S7MkYnTJ3SpZFgNGm9U7KgW6JBmzb2sRCoPZ/NOpKU9JbxOFMletr/EAt9fK6pZyyup9t0vWhE5ZhEAxpdD5I+lXXXViWSKxrEYDVNLxLaSMZNGbAjj51IlXex7EUeYWU746N7lEf1JSqPrK/pa1ymon4rXvNK0qOyj1Jgp52cv3TOdS3kOV/xNAMjBD/JT5xUlasm6cJoK/VdT1J3ratDlE6kdHsiibrZ+L302fp7deMk4vouAWqdBIVp8Vy63kmCkIhHJNCiY5xOKpKON1tNUV2w43XkuY4R7lqeObk31z1fyLaSrlT2U7URezn+0BLpNEEh7W/a53VR33QfeqOm44ACF6+1jtmFfEVS+E0PSY1XTuQ5Wkkavp+JrtxoidZ5sCOHXRGyqWpZ1vdz3PyAer6g6ckkJ1tzFHvkWddrFboSqUC1fYbymBmwmtDPqbfN4AsjWRijUFWDqhyqFpKkJw16dQJAuaVg9QQhtflShZ44UIGmp3A9gymdENulCXpcCSmO45qcZ8ncpKr3kBmCMULy1kcpmwbKijA7iFrPZqr31JoQAsE5qe73fmNkM3hCWaL2rIB3MJkQVtcIq2ugFWrQl+r8VMmfpAZBrkHrhrCu0j80bkP6v/1/SxYikdWaEDx+YYgf5IRIesV5QIl0wQeRDlgLwz7jE2dYuW2fak5RzQWqLY5gA/lizcy39jDz7b1C6mNxK4BqHHYc6O3y5Eue/nUNw/9ZI+jAeKumWIThtZ6ZqwLz363Jlxu57yaOwRUr5LvHMnkIck0mW3NG2wzjbZql04aMT5ihnhOdaSqISgGOoGhJdW+PTIonWxXlJggWgpXx10xkGbumKHZpBtdKHUEwAXKPazTBK8xYky0pTANkXiQFZUdXbgzrSar3nre85S0Mh0POOussAK699lq+/e1vb2h8lOc5973vfdvGRweyzI8Dt7qI6mGHkoF8VPdF6xdfZrqevtBSlC2l1wNM7XcMNJkmc0lDJ9o7iQqs0+npuDEfU+hmSg6y1QZdeUIvlxT/XnnJ6cqja40bWJyXSGEIkq5XSWdZB4KRdbYvea9aUpH2V7swjYbGaGWbZo0kYAPWRTPTIJdIgmokkpxkDd6IVZUKUkiVUs0tWUokqCWfEtk1tRRxNb20oRj1jJE9XYV1REvhIsnNYgqs6cnAmMhF2qZEfiOZVYk8RyKe9IFVgDoel0vaWUUdLVpSsZAde/K9JT7TjI4uKBbFNaDpKWijp4qmj0QICfQXHc1Ay0QkkqQUuatnxPZMV5r+zhqfa8xEtZpXFeUCEKiG08I5UPQW5Th8Fo/ZRmKaIsvr7ku5rtN7HLfx8zatH6OtKhL2lqSmc5kmGyoVodGSvPUEFWLEFjmX7X0SwMfvKSeTO4Kkz9N3zSQVikzJkQoykTNlQNVedMG5EPigZSKhou2XbmL2QkU9tIoHEEl3inKrOFFri87iRK6VNcT7RrsQU+HTiG6SBMk+a+zYU6x4XE/DYpyAWA3O4XuZfE9n+FwmSEqpOBGy2KUJIU8FVhKx1U6kJL0dI7Glsga9MgZrUFqRhbh+LxZT9ZzFTHw7kcN71GiCtZqQGSl2CnHZoRaiEWC8PZdsgevTDBS93Q4zatA+CLl0EtX0JurBrRESPKnxhYUgEWPisaKUEMg0gagbVFUThn3YswTjMSiNMgaVK0JTC1kNAWUtSmuUNTFiKhFWQOQBsehJWSua1pSqR8n3CVPSmbSq6wur1iPpZ9cFEogFU4lo67USH6OxKkkKrIZeTuj3UMurUjDWK3CZop5R1LOiTe1dp5m/rGJw+Srm2iVUUVAfvwnfs5jFNeyuMRhN32r6CpmEfP9a1LjEnXoc830tE9FVKXAzoxrX09hxg10uQWv8sKCZy1ttajWrKTeJc0i2sp6MBuo5uc/71wXs2FPHCv982eOtpPpHR0vEdH2RpfYyebSjABomm8D1p8+lm1jsbkt/hzx/46MU2S5LVin0XY8couo59D6naXhdXl7e8PkNuREBXHrppTzhCU9gZWWFmZkZPvjBD3Lb294WuPHGR5///OcPeJkfBzqiehgQbNQp2ikpJUi60ARFqxuz8oK1Y0nLS2Qoaty0alPMKHnBuoLWqzBp91w2jfYVe734QtYOXUrq0PXzGI0RS5TWK9WDWaup5iWH6XKFHXnMpMGMaWfZrpDvSso30KRox/pCmKhxpCUnalroEsln6z6gp+ng9dGnFDH2WbQtiT6yKbp7fdKSvhNsIlChTel6y3SSEG1u2ihgIlWkitXQ/oyK3pqJXPogEScFphaiRCIaVuEyOTcpPewNmHUTjnQc7YAPqDWP60lKbXBNSTMQK5neHtGwVrNSWOXzWIgzCXFSkDxWI6GLvrS6kZeFLQNVtCvSVSBfcVJckWvR9I4qZldK6vkCn2mKvaKlq/u6rURORKwt6Evp+yYeVOL/KUpNvB/dNCzZRtDXRSqTTCCtI73TW72p37hsSwBClKXEX9EySRJpx1QHiyeeq7RkLGgKSopYIKb3U1RToo0qalCVC1JYpmhdFNL18g60UdhS5DnJW1I0m0gxTfrcJJlKmgzE+zzI/jRFnPyodecnTXIQkuxsLKxa6GH3jqGJkhSjY8FXnCxahRtmqHiN106UCv1qRiLm/Z0Ou9agJ7UQw70rUDcwNytkSWuJaBpFKOyUfDfrKvKtIbmBhFyKfepNPVzP0NtV46LzRFgTT+GUIdKNl1RyAKpGCrRiYaQeTWTsKCyqrNGjEupG9Kbet9dvepMEGE0k8phZQt2IllVryKyc/7ohuEYiq8a03w/ei9a1ruXYAbVpHpUXUWJgRTqgQGm9blJ1PbKa0v1Z1K1GWyq5fikNEElt+l4m50u5+FlVE3xA9XswLuX61w1hfoZm0wDRmoqvr50EZq5omP2vvahr9rRRYnvtEtXRszJGzfbEyaGQ59detxc1msiEfaVElzPoypHvWJXxcFSS71mRgrFBH7d9Ht/LGG3PmGzR6AqaAZSbRBblelLr4HqAV3greurkgasbscKqh4bqKAtayXvDKYIRqZYd075rFDDeAuWWQJhpKAY1wQTCtQXFNYpsVZ4hu6ZAgynVNCBxK8MJJ5yw4fcXvehF/PEf//F+l33AAx7AZZddxs6dO3nd617HOeecw+c+9zlOO+20A2p8dHObIx1qdET1kENJFNCqtuBBNxJhSSJy5WIkdN3LjBT9WvfiCkbhYnoypSBVkMhgsCq+OFUrVk8v2GYoKSZde3xhIvkTXRJKzOlNGTBjLWOzl320Y0d27QpqUhNm+3EAZRohbSOmU9KWopzTAqrQWjIRra2CUu17py3MSa4BEKvKJaqaqvaTE0CqoFbizCOkzahpqjlWqCddZIpwJaJoqpgKj9tPNk+JJAc1jaQqJ56p2gU5VK3bVL6QYrXBCSFohRl7OWwNtpbJiOspgtKx4Ez2QwXRgk02Z6AhW3boxlPPWIZXlpgGqjkr13kCIRppqyYw3iqetzq6P5gqYNdEe9hGh3MVpRoi/3A6VqJ7JA27d4LvZ7gZyFYlFVxtykXb2tOx+EwRrNjXhDhSqJjGVzpsKL6TY4rnMX6oQthQse/XFcCl858itSmamiYQbTo/Ed31E6H17gLINVfr1pkmSVL8JJX9IldR7Xq0F5mDWFmt88etPSixhfJ5vMVVjIJaJU4CSfJRqNjcYrq/SRaTzglBJAhKxeYR0dUCmHr8xucl6axbv+Kog3aDTCLDKxOxZUrkVElBpEzEFGbssOOGaj7HFaZtiDG4tiZfduJzajT19jlUM8RevYibKaiOmZnqn4OcEzORyW1rQq8UbqbAzRTxmZfIbdNXjI8O9HZLZE3s5jRZlCEQQqsx1VVNGBRRQ1tLytt5sb+qHeRWbJlAtKfjiXw3WUhphSJW9jcipVJ5LuNOHclq8DGFnwuB1BqsmO2rpCGNkxU9HBA2zcd1KVRVCbFd/0K+vu5UWKwMkuujrMk2TbFObpBmqXIO1CgS0qjlUum48kyKNY9awG0aUs9YQDG4riFbVTQDTbbiwXma225jdJshw++tYa7YSb5nmfr2x6C9xhMoFwzDby2iFpeFhPZ71NtnWDs+p79jQsgt9dY+Zq0QnW+Ro3o93DCnHlqqOU25IPeTz0M7RzBloFyAeh70BOxYnAWavqHYU2LqwOrxOaOjNXZNJo52pKaBCifE01tpLDDZBPUMUDgGCxM2z60yXi1Y3TMEJZZ7Povjsw6Eap1E6AiAR+MPsXIyrf/6DYZuKJoKkqbfunUrW7du5YILLuCf/umfuPDCC/mLv/iLA2p8dHObIx1qdET1MCBF+No02rpMlryoZEDQtXQOqmdT1FKISar49LkWElmLpU7kgW3KXleB5HWuXKCa1/R3Nq2dletnBKvIolWW6xmpWidah6wjXnbk0BNxB1DLqxJUWOjHdcuO61rMnNfrMltSSMDraJPiAk2u1w3OyIshTHWk0sWHSB5De95UoLWhStFKKTJS684f7QkNMUKb9Kxt55N1ET1dTcll6yigkAHRqLb6N8kVPNEcO+5f0gzrSOhdHt0JItloSZWXLlA+Fmi4LKX943ciqdcNVHMG5Y287DNDOatjZyjAQ7HkYopNIkRpG6YWWYYKck7M2OGMxhUmWovF8+4CQQmDckWB2pRTz5jYDMDT5FbkIWpqxp3+n0h40BJFN7HzWVBy37YdpFIQ1ocNBVRBM/XKjdesTfOr6TndkE1d//O634OakuI04UOLDZVJet0gDg6EWHRYaFSQSYSPOl87chS7a5T3mJGj3Fa091O26mLDB4nmNFHvmiLprqfayVW6T3Udps4B8ZhNLChro94hOVLIpjIPVdSRB4S4qiwWcUU9btIDm4lDlZLyTpZortDRgD26SJSOeiZjstWKPAboLTp6106kYCoW9GRVI9dk8yzVMTOMt2VSgLYaqAeK/u5GJr9akS1OULVDjUu01YRc9Nr10KBL8WHd9F81vV2VNAUxCjOW6nufm+iR2sTnVyRHwWr0SFLwwUYfVOdRlURAg3OooAlKxyiki/77cdbiXEsow0yfMOyhrt6F6hfQL6QgKZeiq1CWktof9sVbtY62XsM+xOOCIETZe1lvKoBKRVctQZXipxCjw7KfaSxZdyN7IdcqFqKm9YaqIiwMUWWNCn7qsRobgIRBEc+PSHW0kwlj/9oS17NUx85hV2sG311C7x2Dd/gt8yLD0IZqPiMbBWwdYDjAb56lOWqWaiGnv9NhKoUfZNi1Bl/khO2bUc7jBgWq9lRzmslRATcEPZJASr4YyJdlgt/0Id8DppIKf93IpF68Wg3lvMauyiElW7fkI10PQyziEhmT6wNbKha2rTIYVBg84zKXwqtG5ACuF/BFDHQMoxXfrRAH02Do+siyjCrKXU444QSOPfZYPvOZz/CQhzwEkAjqZz7zGZ74xCce8DI/DnRE9VBDSYvEZlUKX4i6vPXWNjpqT1tvSBdJaSQCydjfTHwcwGKlcinaOR2LO1JBRjBEghKYbLbR9imQ720klbSGRFb3Y8kjafxAtnskPoy5hU1zEvUAqd6tfautExN5HQkvbSQLIlGxtIVZOrbbhGmKAVRLatan0tefPxMjk8BUj9u+ICKRje+J9V6p8c/gUtSWNk0u0VOJcmsXq7HjdVhPIpPFlonER1o+hjbV25LZTDSxUg0fCUy0qULLOUg2TU2m42dy7RMRN6VE9YKNleeZajtLoaRoq+nrNqKHkvQw0O6LSeddQVPoaAYuf69nhODoKsQovUIFKaqS+0C1kUeXqQ3NEAgBXdFWzQcVjyujbaOarkEwat1Lfkpy03VNx7veG1gx/Vle7tcLSqXITjWdxCQttCmTu0KMosZ1yfMkdj5NH0xlCPHGUA4pODKaZpvYjIlRukTL0jPhbGw5mcf7UIc2gpl8I/u7o2uGJlb7T4uw2vtJTe9xFaPx6ZzUA9oitOS4IF27Ykp1RSr5aRwhj4UzLghJiPKCfKnG9QxVdAvo7ZbJaLYqkh+AkMkFTS1Ikx+ujSl619P0dzXkyy7uryzrdQH9HD2OnqsmJww0NI5yXqOdtAtuZjJxHWhiekODWSpRo0qie8nPNBWGqZihaFxMn2uUn5Ja1S8IlYbJBJpaiGvSfUZCGbwXIj07hIFMpBkOSNIVFWYIRYbvZ5KBqh1qdQy9Qk763mUhpk3TtlNVsTCLNM6sS/2HJt2jYVq8koqv1nW0Umn5RFi9HLMuxcUAkChwVQv5zftUCz1047GrDhVUS/Zc30q0f2zQ4zGYjLA5R80MpdfBthl5BjNpMuHmBjA/pJ7PqeaNSILqQNAWN7RRS9qgJw3BQLklpx4oRts1qoLeqsJltC4pcn958iXIVx3Z3gqzVtEs9Ck3Z2QrNbry+GxAuUnkJsGmcRqq+UDTl9PtC2k64ucaioUSkztWRgXjXQPc3pxspGiGgWbGo+ZqbCGTAqUVoffjSz1fHy5o3CEO8R7M+hcXF3nRi17EH/7hH3LiiScyHo95zWtewze+8Q1e//rXt8udf/75vPKVr+Tcc8/lzne+M3/+53/Onj17eMpTnnJQyxxudET1UCPElJiR6l67Nh33gpoawptoE+iz+PKaEY1XirhKWlGjQogFOvFF6FT7UvNIG87U836yRQhusVde5kt3yOjthGZgMaUnX3M0A0uYEfsi3cQB1Ch8YdAD6QnObC6RkrU6EiEvvbqTrypgYneqFJFdH21qI2jX0xj5FGGMUdi261WMXq6PRKsYvVQ+9X9WrSdlqjZti6tSi087/axNDyshAT5pWb2KRROyn23VOdM0bqqqVx5M46fFVdDKIIKBJlknxerwYBPpi3OOoFrCLdHJdT9HRwIVoIldaOxEPDZ11OpWM2ZDBDKRtVRkp5sgldr6etrdINcjaW1DPDZTscEOrOkJCW71oInQx/szFQCu1xGn9af1in5yHQmNkcE2Er0ucpp+TrrS6zsCrfdclcnBVNbRfg9a+Us7aQlxYhAL/FQIZGuQLzfYGfmSK6TwLG3HxUi4VnIeRO8rOmBd0DaiqBfA9wL9a6SCub/TtZ3l6oGOkUlPNpIDaqUAIab8g57KCCIJMHWyBZPJqImRbeWimb7zmN2rbYrZTESeUc/I/dRblOhlM5B0f2+xwWeQL9bSAEAr/CCnnks6F6KjhaKatbGDXWx3ueaizZpE2lUAX0hLVDcUWynVeIq9jsnRfYJW2BVPM2Pbgk6fW3QpBZyAGPnXTSSOEFIRUeNQZSWpd6UgU4ReLoRPQ5jUYsGVJj1Wi7ZUayF/mWVyylb0pKa4DvwgF9JpjHTOg1g06toIL7kViVWUEgCiDS3L9vwm6RFxgpZmTMFJ1FWlKHD7EMT9824ajU1/XU9ma0dYWgFjpgkD71viqhspaLPLlUzYa6SpRwGDy1extUJVNS5TjE+cobfXkl29JNX6xuBmFPXQoguLXauwaxLZXjsmQ3mFXY7uArH4s5nvUS3kjLda6VoVsyf1QJ4tr8DbgB3L2FzsnTaUqLb2pZhqxwTVOMzymKJnaQY9woJk0lxfbLWaGek25eIEzw8coQjUtWV5ZUCznKN3ZmRjRbBx+dmGwWxJNbG4iYWJRY+PoNz/EYaFhQV+4id+grPPPpurrroK5xxnnnkmH/rQh7j3ve/dLvesZz2LXbt2ce9735uqqjjhhBN4//vfz+1ud7uDWuZwoyOqhwHaw+z3a3TjcT0rXnPZ1A80eSem9oumkpdyGv+SfRDQpsPTQNnaV+npslJwFOjvDPT2NIy3WVSjGV7lydacRKBqYRfZai1FFi4QMi0FQToOmpkhZDaSDyGqqVJYa/HhdH09rfyvU/tXJT3b10XYUpq2dTqIBVlt5DMRKw22nEbppOnBlPgkGYTyQdKTakqmJN0rm08erinKC7QFUclhIBGeVNHfEkBHS1b1upRyalcbtGqLuhSxMYGeamelOC5dr4AKqpUwJN/NFBFvK98jGZeXReoeJpHvOk+2WWpK+DS4mBq2E7GDEXstFY8JiNroNkWOrN8gE4pU9FX3pc2iN0g3rdh61EcLMjuRbTY9Idvro5nXj34nna83CtJkIBGUtMx6khlJ6nppRisLQP6mHeta8NJOfJLjQ5IBSAQoRTGTIb/D1DpagU3JqU8tgzUS9c8l85GtxoI6BaoStW2xLH/r72ragrvhlSWTowqJxA5kPc1QdjlfTdczNbOYEvyQ3I1Sar+QyVnbJjnqkF1fk48CdiwV8aysgXMxfa4Yb5NCuWwU/W1nTDvxy5ZEH2pXKjmO2uELi12TC1DP5Uw2iTuEclDNS8OHbFUq9InFWkErfM+Ic8TYtc9jKAyuZ1g+KRPv4t1CrJM8SVcu6tUVyWIqaC9R1dT1rqzb7k1h2CfkFj8sWlmAXhnD2qiNSIbMonp9gh+JrVOvgCInX3GoPav4mSHNpmFsqCHtcJM2Si+PUaMJfq5Ps20Wnw+wKyVqLdpNJaKs9bobUUmRVvt5/NQYVCHFV+kZkGipbmUFoluNBDcRVa1p27V6P/2uUvjZPn62J/aADdSbCvGqXamg8fQv2ytjj5M22Gb3mJnVCmYGMClRdZ9qy6C9ZtVCRjOU+7yekWLM3l4nk6LSS+MIApNtBZNNlmpWtVkpkQIxnajGYMpkszyY5by4AuQrHl0Hys0ZvZ2VWKIZ1TqsmEqcAXwuA1bIAiH3qFqjGgVrBtcoXK0wa5p8r3zPAXZVE8YZoxXbFkuihTR32D+UUjzlKU/hKU95CuPxmF6vt8GuKkFrzate9Spe/vKXMxqN9uspfyDLHG50RPUwQE+8DBAuUM8mS6lppf80GhgHe6sQw+NYgONlebwQkzYfqiB1hpIOI178EmM0Ukd7JryYuc9+35MvNajGM9maU80XDK6tKK4bAUihRKYpdqyB1vjCigl4npFsmUKRSTFELSbkGNtGMYWQTHvcJ2lDasfa2mupGIlNlk/rnqdEUBNpW5/9SH3XYR1pjZvQsag4Gcavtz4y8f2R0tGtS0Kq5M5po1vJD1YI6rTblRC1VN2tpqllQxt926CDbaaRVlOFtld3tuan5Jh47dv7YEqYpcHClGSmwqWkvXVxEEqyj6a/TgNMJJrr2uy2bWsjCVRO4TPRBfsU9YvRlA2NDkKIRQ3y8k2paZfT6mshFUrElJ+aZgZSK+C2iMxB9PKeFlAlS6cgpDHE6ynLh2l0eP35ddOIq64la1HNmWg9FkmogbpnWqcChdiBtfdAfG7qnqaaU9iRRI+yNbmZmqGmHki18uDaBl0H6qHoMFdP7FEPNfmq7JR0ZJMJQNOT7dixxwUdvZHlJZ60xD5b91KPhDvpa01qxauBxqH3rBBW11AzwzYK2DYGSZPU+Cxlq46QGTHjrxpCZnAzPZrZHF06mrmMyWZLNRObIMSmBjo2pPA9jV2tY0cqSRObtVq8XCuH0TGqualHsUcx891V7DjQLPSFaPmAWRXLBBWba6SCqTDIpcCqcTImGCPRVSNa1GA1rmdQtZHqfOcJVSXG+PNzEkn1Dvo9lLXybO9cFpupTQuY0qEahyobzNqEkBnpsjUQvares4KxhnrrUMYCY4TsBQ91PS24is+WWFzFGWeyu+r3UHkuDgLOyc9Ns0E321pVrUfbinV9OiKA1ujlNcL8ELNWStS3b1BNwO4ZoddKKGtCvwdOU24fkO/OpYVs3RC2zFNtnyFZqpULUVZkTWwCEchXoxdw6hZYaOqBYbLZUA/jWF2JjCgYaAYxw1JIvUAzkIevHhjylUC+LNHoeihuJD7X1Jt7rB6XM9kqk+pmQBuhVQ2EIoCB4ED1HTqTiIu3GrVkZBsBTKUIZcD1FT5anpF56HvIjhyi6lH4fS7yj34bNwf9fv8mlzHG3CQBPZBlDhc6onoYoIBgtBRlpDS1UhsibM5CyGgrltuqk0RSA9SzeuptGHX6LRkLUoHpbbRkitpPVyhcX4yXlcuo5i0ulwrkbFW0aM1cD+U9elyLvt8ozOIaoZdLOi0EgjH4npX9XRmj6oCeaBlYkW5HPtd4Ky9yoG3B2WpQoxk90dw6xENU8ThStFIF8CqS0kjSdLmxxeZ6oiIuCUyLcQ2kanFT05IWXU8jeclZYX1krSWC0aooNVzwVrXEa/r96b6JZGD60pciMRWr/eN3tAzYqaVs0r+m44FI9lK3pxh1TfunQPSNbkoICfKOlUlALDqI7Wt9lBysj06mIh5pBkFM8UoBjUJeTGKFJZGQbEXWY8sYLc+gHArJVS5G+uO5S5HvZA8WLOLAEOSYTJWkG2kixsbIbNJpx6K0NEloo6cxoq6b6TMSIknVToh6UHJfty4TKq5XIVXvDmy00awHmnqopDVsBcOrPXYk+muJfitJ4a9KZEw1gWreMDpKt64ahCQvES0xCnp7JKJn11x7L9UDIRGuNy3KClGu00ZdY8coU3kx1s+kE5Oe1FL9HiD0C1zPTrtfOWiGqtVw2+gY4HONH+YS2TQm2tBJxMsbmXApHxhe3dAMNN5CsdeRrdSY5RI3zHF9kQSo2D1Kj2P0UwfUyoi8bti0WuNzS7OQSQAyC9jFMXpUE3IrHZgyQyjk72pSyeQ2AEYT8t404ujkuK2TBgcMelKRvhbbp3pPmJ8R0posoJwXX9WZId5oWbdCCOpMD19k+J7F9Q16rsDuztCNJ7tuVSKZPYteEx9WvEdFS57go+QqpfgDQka1SK/CoAfBE/Yuy3UY9KVxwHpR9Xq3gPTz9f+fLLCM1As0m3rY1Yri+3tQNkPtWpLjrsRSLMz06V25RFhZRRkL45KwdQEz8fgcJgt5LMSS57htLR2lDt4oyu0ZTV9RzSsmm8FOpBCxt1smvOVmuUe9ES1pyAJ+6DBrus1g+FzBmtikKRfaotx6RrIYrohezB6axLWcgloGfNVvyHsN2sNkxyCuU0iyG8Z2qYUnOIUuNWbJUFydYc7sUv+3VnRE9RBDK4Xt2TY1J5rU+KKJL+oNlk5Jdxj/ntLYqed9PdSS4kb0c8oFedmkDSrRsqaXu8ukhd1wh6N/bUMzyCBIAUVvV0W5ObY/DNCLjhTV5j4mUyibSQebysnLLxMfRb1LfAhVZtrCKhToiSNrPN7m6EiUW2/MaMeUiN8Gksk6Qhstt5LGlUD7wpRCMvk9+cVKI4JIZFC4wTTC3Hq3rjuXYrg+JYGJNCTCgIupr1hIkSQELSGL+uA2OimB75YEprS7z1IjhOlyLhcSmYrWUtFM6kXfXsJIfJNJfiogalPVZnpcwSg8MdIZK9F1avFpFTTTfWrvNzMl5OOj5IWVIp+p4rZYlGvRzMtBhYGimQnYVWJLXJEEJKmJi4S0mQ2oGtxATr5dlWsWLIRmOmFRbhrhUXFCAJF4JgusZDmm5LlIhDydC9PIfZWkFOL1m5hvjFI2HrvmZBKXKybzcsOZKmBHIRb4SSMIV+j4spZoVP/aino2IxhFMy8m5s0Air1yvZsBqOVANS/RUTsKQm5Xasy4wQ2lmj51M3N5utfkeKTgKnXNilFUJxpoNzToUQ3jilBWqGEftzDE9wzVnMFUUM6pSMwDtgrkq36aKo3p7KDFR1n5QD2XSzvTOlAs1vSvXGXt5FkpvDIafKDe0peo8MBS7K1a833fz2hmMrLFCcxE94+qQRmNXRUiqddEaiBtPa0QJOcjSa2lGh/awkyqGI7PbYyWpomPkmp+DaasUUbjZ6Ouwjk5thS9NBI1FdmB6GQVSZoTmyBoQBmarUPM0hhz9W5CryAMexLNLTJUlgkZTcVPG6KfcbJSFLTtU30Q79XMgtGoIp9aZPlAcH6j5np/pFUBWSbjYlXjZgfgrUhHgkfllrAyIkyiRCHPCEUuxWi9nJBn+GFBPWeph5ZyTrfe0PlSoL/HYcaees7S9KSBwPgoaSLg+oFsWVEshkguodwC5WYnQRAbJPqRe4z12B09eovSLjX5N6exrZzXIvloZPzQjXin1rOpq1tcX3yWXWUoa41azKDS1LOBUHiJnNqAzhyUBrtopTvVRIlc6QjyUT3Siqn+t6MjqocYxmiK2UJSg4X0/F5vfg/Tl2xbmBM1iy6PEZm+zLx1M+1PLkbaUWsaCU9KZ7aFQgFQipmrpFXqZIvFZ4pij6PYXaInDrMGk6P7mNIzPqYnfcXLBoWmGRiylYDvmQ2FTSE3qKbBF1k7qw5aoRpPtlrje0ZSpHGgVjGIosK6NpVxAEsdkHRDW32fiKZuVNv+0kcf1ETmZb1hGjGMlf1CJgGk+rpNtceiIaKEIqW6TQ3er+vfvo7YhUiGU7GQCkA8x+IvGolWutjph0iuSZHDJkS5nIodrBKpok2Jb9Blsi5inFYdI6nTaHs8Jxp0EMsXmJK/tjVs3EbQtJ6gSRNaz6jYrUbIl8tFZ6kCDHZIIU+xpGh6YsnUWxQSX8+ElmCioZqL8gkDdjUWaY2BIBpKb6GaBzOJLhHxOFwvoFLnmpZY0sob8ElyMI08pnOhY8Fckpyka6v81GO0WHVROyo97rUTMgfirdrbXWNHdbR0ylBesgzVvGn1muVmIUHlgqKZkWNI53V4tWi+q1lNMfEMdzRRK6wJVvxOXSZZEG/FIssZIfptp6x1UEkn3jPYpQlqXElVupN0tx/kpBa56R2W3EN6uypcXwqqit0Tsqv2yPcWZnGDgRRERXlLsSi6dJ9Ltb5qpC98tjjBTBrcsCBba8SqbFbS9fVMhis0dlmImApBxrK6idHJjPHxQym02lniexl6Uss2lZLCKSfpb1XWhCIj9DJCYdtirSRvUl6io3pcCyED8V+thBgGJ6l6jIbZAT631HMFIdNtMaQuvfgFV7HYtPTUCzlqWBBuexR6tZQWsM5LdDfTUK1L2Sc9aaoFMAY1HEikN0Z4Va+H2rIJrJXo77iEspQIqNLtd9t1tRc6rlOJfhcrUo3+ipy3kFlU3RCWVwnjUnxhhz2aTX2CNaitQ4LW+ExTzUvNgxSXQrYknaGykUzQ0Iq6LwTVFQrXk+cmW1b0dkd/1E0qtkX1hDyOqdajTMBkDj3S9HZDvuRj0a00dEg2fypK1dxQ4foSWW9mAtjQTjB1Fa/L1gm+tITljBAUWOl8GDKPsjJR8Ss5ulTyr5bxRMUMUodbJzqieogRFNQDJdrUONtti3VSGDSm900VSN6brlD4QPsyTul0QlpndAWAqIFLJEXFgUThI+n1VrF6XE65SaJ5s98t0eOaer4HVjG4Yo3V2/YxtaIeZuRLoEKDGTnpmmSmLgPBaNzmWUyWRb2cEAM9qdErE0JfIrYtuUxkvCXl02NJdk6S6g4t8QkAsRgFP02vBhsjfoWcnzSr1ylNHM+PbCf+rmMhEuuiqyGAV6QOWaZOBFlNSWr0sRW7r/i5BnI5ZuVS9ymF9tPtt5pBhHjYicgI0FGztS5Io2umUoZmY7QzKAgFQsCVfE+FGP3IlfwtrgMd9UyRxHqjNhRteSPrSgVcqNgBbSSRlDxGMHt7PG4tFgtdXRGsREomCwZXTrW2diQ2VakYKFul1camqntJz4fWjzNfCvR3O3ymGG8xUfYgL6/kBWzHYZq+ztZFH6GNmgPtCzJVmctnvp0YmFpIqfgN6zYCdP02vsoHSaX3DXYihSY+W5fiLCzeQrkgUbl8MZFoSf3bkccVmmLJ098Vn5dh7N5kJZrnChX1wMnJIbQFhe3/kwSCGFEeV5jlCWpxBb+61nZhiqZHbbesNHkSaymxm8qXa7I9Y4k6VjVqXGL6BWbcEFRg9aRZshXPZFvBcOzEQq0w0vShbEDFYqgKySgMc4KGOroDTI4e0PvBCjSB5TsuUOyppatZ48h2jVFWyGfINHWei7XWuEL5aGlnYsOC3OLmezQzQoSluYaJXsAeMwoonaOjxlX5IFHaykIBqmnEU3ZQoMoKb8H1xXfUlF7aQ1cON8iwq5VU/9ceVxjoGYy1KKWnhWpjqbRvJ3JAWwylAK8Ia2tT7jk/i5qflSh3YTHjSmQEQcYc8RVOM/V4s6b7L63XSNoklJUQ09k+oZfB6gSuukauYZ4RFmapTj6KekGuhbSolQlf04+yJCfPZG93Ldeq8lKdP6NZO1aei6RBVY1U5XsrNRPjrRBMaI9TnjONqgPmWsvw+4qZK2rsRIoUpUuex44cTU+cSFyhY7c38AUwaLBzNU1tMNajCFjjscozuq43HYzj+VG1Rq0p7JrCjBWmUm2WyvXk1B1JAUaHxh1iw/9Dvf5bEjqiehjQDKRq2EwCtmaqLQUhIBpUNSVh9TB2WjJTbSSwweQ+mbzLABFavWCyIkoFP0FPjeZ9FsjWpFnAyp3nKJaiaf9qw3CHmHU2Q0Oxp46VuwY1qqWoAkXq2KJckIhIJpEPBTLwxhRhigqnlDnQVqMnL1XtYvrerNM6Mj0nEk1WrWYzpc9TS007nqa3Jfo8nW6nAS5ps9riCANqHTmU1HJoNZUbOh750HpUmnIa1ZXinZTOIlbcSxRD0rsxWuKBEGLBjBBb3YBa17CgJXUx5emLaaQsKNnXqU1X/LkJhN5UVgC0UVo5Rmle4E2MOjoIvRRdluXyFSGM0iFJCFSxV7SZdVBR+2jbgrD1ul4VJCqqm0AIsQFDkkhAK1FJRWfagV1uxFUgtfd1IfYxDygnx9zbDUW0z3GFjtIMOd8h3jepuEq19zhTKYGXyKJuPLr0MkGxEsFOrhOsn9DEtHB7bAqJkrX3jzgEVLNSMKWr+OApaX1qapkMBiNuAEEr6lnRcGM15Zx8NxFRkTPIzeUySXOrJqaUndxDAHbvWKyoxhPCeCL3b2YJ/Vy23TdtEZYdSwQ4RWazpTLel1qicFvmI5GroXH4uR5BS8FVsVhj9o4IdoaQgWrEck41TtqYarF4MqMKVdb4o3OKPTVuIN2jxsfljLcbht9dRlWiG1UTB7nYWNUzlnpgCHh6S7J9Mksw4qcacosrrFSgK6lU90aU603PoOatkKFVMz1HK5FMag3aiHQgtwRryHdPqHQfPyMkzUwaVO0wYyUTjsLIMQ6ztgBRjUuYVNKhKSFmoWTQ8lNSSZQxoKDI8JuHuEGG61narlm5FT3x9RsFxIyB/EuzWNo2sUpB2DSL62Ui/VhaI1QNYesc1WnHUm/q4QuDi0WNyb/XR7/n5NubL7s28yUOEIG1Y2RSOPc/LsqWtJDJXOz0mkGc6JdQ9yTdr2oFlcaOFMUuGFzj0C4w3mqoZ2ITgl2+7V7XDMVruOmDLwJha0U+X1EuFwSvaCqNGhtRbZQKO1bUM4gcQIOqFXoszQLsSCKoImGLY4CWIEHo2MqtFt2lPwwwFeTLkfA4YmtG0SYqH7PZ8cVry0DTxIiSJbZVjJFIP001+5h6lsiRvKDTC1w5iVRVs6bVwqEgX1aYUrN8ykBe6JWjGUoVV//qMdUmqQipFgrsyEV7FEewGarybYQKI+xB1V4MwHMTq5T1NDQUEolgKnOIfcJbw3otqXcVl0/RRBcjrm3BTUxdK2KUMGoTaUDFKEHyCU0V+imql1L3bf/5QGvjk6htspJqNafElGodWjkGKkX1kqZLQRMHfKWnZJp1++uSHCMSxugQkFqv6kaiGipKEVq/zfXNDZB7pY36puNpaK2aiBYyadt27OgvNtg1ibSVm210YFifipSXTLHXE6LXaD2Ql5gppW2jKWUykV4QbetPrdCZaovO2hlGJP82NhlwMdIj/rGip9R1oL9b7hVTxraitad/XYMKinooFc8htsoNWiLWyfw+WU+JbIS27acpXauB1i4QfECHabHHPgjTFKa3yc0B1o7NyUZyplwhVc5FNMB3hRZdaixutGNPtlwTMs1kc97qZSVyJ00TTJTmuBiNN1Vosyeimw6YsaTFzdIYs2sFRhNClXTgGSzM0iwMaGYymr5GO8QeKPqu6sZjVmv0uKKZK1Bj6fDUbJnB9Q3FD5apts+ydlxPLMlGtURSe7ncQ3WNWSkJeFTV4DYNZZ+CjB/15gH5ihdCuKek2pyxcnKPha8tYZx4LisfUKMAVY2fLwhKMfjB2rQFqo4PpRVZhM8NuhIC5HODKT22ETJaz+eMt0mb4HqYY+pAtjtWv1sj0dkYbdK7lqBfEPoFdrXBrrmY3RmDtfhM0wyztjNa09fkq1FW4INYPjXN9LmIBU4KJTpRFc3/E3ltGigyXN9Sbi7QtSdflEHMbZ3DljVhNGZDMZWOg136vXUAiM2GswxVe0y00cIHwpZ5Vu9+IpPtBcVeLyQ1No5IuvygA9bJ+6VYrKXzWsxQmUocYFxPMXOVIxvJpFk1SETaTYMl2iFV+YWXyvwA2ZoiWxHd9Xibppo31Js9YabBXJORL8esXxa111oO0WfiSOJ39VBjg6nUNNsUM4rS7S7KBhzoSF5V9JKuhzKWpK54IvWZjs1HAnxQ+PXarEO0jQ6CjqgeBlSzUG6GYlGRrYU2zZv+7wta7WmDpC7tBISREB0Cpl2rTCkVmdWspP9b/06ibq+R4iczUaIlAiabFOVmYI9ExPq7JC3bX1zDLsqgnu2dYMeN2FLVHjWpcLPSWtKsVeADppQIg7QeBCYVKpMCgzAoJIpJQEcbqjYj7ac2S6qZkkmYVoKngbyNILqprZOpmcoPFFFTOpUABD0tOkpWT95MvTVTi9OWlMLUpiqm+tcPqKkgCT2N4qkQo5dBvtv0hKzKd1Qb6U4EO5FjH6utvY0Ti7GcnxSBNWVsN1tPyXoq/pKXTiAbifdiPaPlhZBDiIVftpKKdRWkkE5+jhHDAINr5FpV8znZSoMZN5RbCkjrkyvWOgyYylMPdHvPNYVqfVV9Hiveo9diyFUbYU5pUp+JtKBt/pCrVhua7tXh1VKhLU0GAFRbQNf0IllYF0mW78Xio1g8JJpmhak9dqVur0GSl/g4gUoFf8GktCbywoz+wHYi3pL1jFSpKSezR28V+arDjB3VvJ2+6A30d4qhej0rb1NTiq9kyMSDlADFisdMPE1f4/u6tYtTsWDKW/nMTjx6rcT8YA9MROMoB65QwwF+btgWJirEwaA9X1phVkUqEDKDXavFd3R+KLpLNM3moUwmU0FhT9IU5aZCIsM2MNizilpeQzUO65HKdi9dpHzei+cTqoWcvadmzFxRUSx6fM9ilktCz9Jsn5N7opeRjRrMWh3bvvbAOaqjZ8mWKkIhkWc9EX2rBrJGJr0qVv3bNQO1w6kStwn0dSVcLaSUzQtxchQJcN1AP8dMZOzSkwa1vIbftiCWV30jGZJCovpNociraAdRiHQgVH5KRtOkK0Y/xWZLC8Gsa9hbYzIFm4t4nwbM0lg0t3NDiarCdH1Eq671LwXnpGhLyzWkaVArJfRy6OWo3JKNA+qaStoAH52LztrTdqxL3QTtyJEt1bHiP6NYlPT/ZIuRtqNKinDXjpX0vHJS7NgMPW4YwAZMr0EFKApHvbMn0p3tJeWJnspolA1kRY26omBwlbx/mkImsS5XuF6aqCvUqgUvutTkRBJMQFdKPvMyGRaLwWnBlRtOaw5SPYLySshzx9lu1eiI6uFAkIhqseipZ0xLrNLApZpp1DEYEcLrMtAMFdmSpx7qtvpcxehgk8kKXKFQQeO1dDJqPU0RP8gm2vCIFx4Mr5aCD59pqoWM/sRBv6CeKxgfldHfWWNKiTjURw2pZzLsxNHM9TAxCqGaOL1dGcVsqOxb0Brl5eWMTvZIMRUO8lJqta6xitOnlE6IJEe1Feo+LpMIajqX2oW21adUzrOhW1GKOOMUjSVGsCA1VEgkUruU3ie6Esh+mck0vaxioVXyd7VjMV33uZheS8pfug3pmKYWF4DQHoPS00KooITcOTPtrKU8GBeiPZVqbbRSxE18S9MAL+dJigykcj0bycmpB6KJ1LXGjqQTkJk0uJ6hHmiUgnpWqt+lsE32L1tzKC/n2hmZAIlFmKSXm75MCKTYSHSt04i1ENGmoO1IVeWKbE1eNqNjNP3rHNmqnPNsuW79MuuBboljucmiG9r2taaKKfs6TDWHtY/Xx7eRVe2DeHx6aY8JRHJl0VrJ5GrsJWXNxiiXz/XUj9cFRttt6zhQD8W2STWBZij2O21bVCf3Qz2XiTl/T/SPbYtQHwjGoieyvz6Ta5WtOLI18TFGwWRzjl1ryK7cDbsWCWU9bbmZW9GmFmIR1wxttBMT7TkKimWHXa3ElWNYEDKDHlUQAvXmvlT4O6jncsbbMkbHwNz3ApOjelMpTlNLmrzx7fNFVeO3zFLPF9i1mnJBdOrVnEwyszUoloJYYC1PqDcVYvlUxDbLE2ka4Ac5pvGiQZ1U5DtH4sNcxlawHkKhhbBXTvZ9bYSKVlGqcVgCfKuUcSezUNZSYDYciGbVZaJXDaDKBk2QFqmNAxczQAFp8xwlG8EqmoU+RoG5ZlGGHmOk81TyIY7/TWS17UzVONSmOTRaCk+dx1y7JB227DzkOWrbZtG9VrV8J459SqkYXdZT6yvnJbLrnfjBbp3HzfWwO1fof30HzAxotgyp5jNxe1GKJo/yMC8+qb0rl7F7Rrits1irWTs2j61MpTPUZLOmmYFyIbZ+XnCYhQrvNaEyKB0IjWbTYI1jt+7hf+rtZMfUzMyMWZ308Ks96qUcd2XB8GrAB6o50TK4nljdiU41EGxoyaf3EIZSLGVXNWakMCWxI16cbNdxEpwHXC+08iKUEF09inUaRxhR9YdBo+o7jWqLjqgeYqgAwx2B4VUNwab0T9KgTgtq2qysYlpg1EC5YNoXZKrgdrkiX/ZSTZ1IhZW2fDb528WCKvGGVNGWBsZbTbS3UphxYO2EHnNfH2FGmmxVS+HCRLquuL5YzOixlMK7QY6uYrcW0xdz7aqJlfwx/9sEIUeFJvT0tDqcaWobQ3yhy++qFoLo1nmMbugDH2idBSS1pTacs6Qhm1peJe2WFKapWIAEqnVK0E3YUNE/tQhLdkdB2mfGVK5Y/aTIq0dXqdVi9JDNJKXfHpOLJvBRu5kKemT/QtvZRaJ404hkthraND9BSJRqJOomhBh8Df0VaaMpEWUToxlhA7FTXmyGlA9MtkqHsWYA2Uogkx4P0UliXW/uuK9pv5OlmvScT9Fk1e5ziPdsajCQIqbeQDOnsSOZoJWbDL4MBJO393mqzvf92O0qyORBRe9b5eXFqivxFwXQowZdNuLpa5TYp8WIqR41KAJBSxV3mlykwq3rF1S1UpNcUc730DXka55mIMuIUwA0VmQLqVNX0IpqPpNWppHEqqDJVj3FzjG+MJK6VvJs6koq7fNdY5lE5YaQGYq9Dfaq3YSrr5OUcqoUz4yk/POcMD/E5waf6Q22bt5A3VeYNYPOTFvRjzU0w4zJ1hxdebKVJmYKLINrpnZizUCI58Kumnxvg5/po3KLmtSEuQG+b0FBtSmX+zh68iolmlxpSwp+WOBmcrlOjZfCqUlFGPbw/Ry30EeNShRZmw4PmZFxBCFuunbiHlDVMKkI47FU9mtFiK4OetCHXk+W8QEWl1EEOUd5Bmsj0Aa9JNXyBCnQMssT6tmZ9tlzmcKAtJP1HrMzhqnbKkzVavHFPzq0RWxtVynncJuGbdGdmkSt654l/PZNuC0DsqtB7drbSgnadStQeS5RYALBGugXqOXVaHUl3QD9zAC9ay8hQDMwuL5qi7Fah40J5EsOszIh5JZyq0xoqjlDNQuToyLdtgq7Gqg3edwM9DZPZFJYGbJhxea5NY4dLHHcYJEQFFft3czS8oDF1QG+NKixId8rLgG6gnpWxjXVxELNGEDxWSDoALmHiSbYgC4V2bImW5nasvlcCHQrV7LiAOKzWGhYKXQjRVXZWlymR4dbMTqiepigmLba9PGsSzcjmSWnCnTlQmtdI5EaedGpIvaXN2BWJYrmChkhUgFlOWdwuW4LLES/JlWixaJi5USxyGJRUSx5SZVXsHLHTfSvqciX6hjFcrh+JlXu0YfRLk1oNg/FS1XHyuCZAaxNWp2XWhmjBj2Uc5ieEe/YqMdMaeWEZJ+Uor8ykw5tih6mBFXFDlepkCARhgQzESLps6ijVBKlBtFfKWjXIeQPiUrRfrTB+ij5OZomxH7lYr8i5FZLxb1SmFEjlfN9IZtJ55gIkqmSjnTqHJA0srJTSpouGCUTDh+w5ZRwS4cZyMpItJSQ76L0rZygtfKqJQWo4z77wmBXKorr1vC5JV82jLfaddXIoSUtkgKnLTBLJvBJB2rXaPXU3sr9m3S6650K8uUwnXBpsKWn2BPTu7UUcaWUXjVvYlFHjHDHyZh0SPJTZ4gyEtF0nI10RaOwEgn00+tKZvBRAxmsRlVO7teoYQXT3gembFC1pxloec6ittbl4omajWTCQAiYyosmrT/NbOjoLOARvehkkyELEj2cHNePhY8h2sF58l3jOMkD7T0u09hdK6hr9+DrOpIhjzKZEJl+Tyypehmub9rit6CZVvyPwFSOej4n2z2Rc+88btgTHWMZMGuVVIBHX9DJZksz1GRrEo03NYRModYaVNkQ5oY0c7GxQCbZAjsJBKm1pLdHxo1mNscVmnz3BDtqaOYKTOnBamztUBPxP23me/i5XCZ4dZQ8GMiWo8zHJQ24kjaiuUWNe20GRq2NhDhmWSSQMdyWPFRD1HmuxaYIa8JsVK9HIGCvWcQMNM0xw2lBZhyLiipGM50XQtwOCBL1lOI61RJsvJcq/C3zeKvJlkvU0kg0qd6jVhxaa9TCjOiMQ5AoqlKEXi5Rf2skihoCoZfjtsxg1mqxt8oszsZBopbOFPVCQTVnqGck3e9NyqLJhNKuiNet2zLD6NheNOuPdRGLcq/2r5NCq/4uzcqJmkmvYC6bcNxgCTtTMT87omwsoybnu1dvZ/nKecJ8Q9arqcYGU0qxY7ZC22o4aCCHaiFM7Qe9tO6mUeAU2bJU79sYFfUWsFDNB+oFLxr+cp3VWiSoupKf7ThmN2YgrCO2RwJ80PhDbENwqNd/S0JHVA8xRMCvWDtG2pA2PSFpolWNkdJk2RRCK1C3MQKXL7nYClO1Fj2mkoFuvFUMrrPRdJANRohpttyI3jQ3+CIVnyiKvbFVooX+NaX4RAaN7xns7ho9KlFrE1Q2R/+6iTQDiG0OTenawhSfG3QIEtUYjWXjVqpW/TCXjlWKaLAvUcHUbx3CVCvINMqVyCuRoLZIulZiEVmuWn0pTAfuoNaZ4yODHPW02CpVj4cw7RCkXCSY0GpPVTMlnCoawisl6UORI0gBi0IKbvCgY8pQ10K2pb2qXFNdB3yM9CoXyEo/bS+LROzEQzRMrbSS3jJqbLUPZGPR7DqjW9JK9NTNlmtU3VDP59SzuUxWAlRbBky2ZNSzUlGtGyl+MBNQbeOJgIt939PkwETdqIrFaR6JGEvklNhMYhr91hNaL9oUacqXHXbkKDdl7TGl1qHpfm76UiihnUwmhGyL72hyiEiFeGatEm9Oa9BN1OzOF9LNqXYQ9Z9Bq9bCCq0k5R+1j7qRVGzdN5Sbs1Z+ke6lRMJTpX6yZjOVSB5SkwnRA5ooxQj0dzry3RPq+YzJ5hQlVxR7Hf1rx9JhKojFEgH0yhh11XWEyUSidEqhjEX1Cokc2lhNLoxtKhfSUbZSBYrdVdSnetHVjkrc5iFNX/SoeiJFUuVxs1K5P5vT21Ux1jkEIZ1eQ7Z3LJG8YS92crI0PU05r8lXPMXehskWS7YayBdr3NDG5yvQzOd4q2l6isF1FWbN44c9ybaka4dM6oLV4APFnrGcbg0oTRjmhEzTbOlDmow4pGp/tQ8uSJR5VMJqJK5FJpX/k0l0Eogv9SyT8+Yc/OBagtL0vlGiJtsYnbIghaDpmRqVMslOJDSE1jIK72M0NE4qjWnN/oNCpBK1ZJTUoC9pfmsI80P0dXtFohD3SWVWWshaI7KE6D0LIj1QxkJRQNVg9o5Q2qC0gZkBpvTUM1Lk2I6N0eEimPj/uSFumNP0FeNtaVCllbE0fUW5YMV9Zqujv3nM6duvZFaXfGvXMXzj8uPxe3KuCI7JJCdsFWuacHWPmasM2Yo8n5OtiqYfqOc82co6ZxdoJ+F4hR6L/6mOFlOi21f4QuQBzWyUB9QKHyv/pWYjZr9iZyvxRJboK8XG4ESHWxc6onoY4HqKOvZPBjGhz0ZMo1g+6v6IKVUj3qvZmhCRpq+ng4KXAph82dPbLemzbFWsR+pZK1XXaw26loKLYHRbtW4mQrryJYcpHasnFjQDQ3+Xox4aoEeuFKrIJGLa+NaT0w9EA5d0eEFD8Aasla4umXgthcxIMUkcuEy04/ImVaonghY2nKP1EdZEmFoBfZDuW63XZDMtSFNySEAbKIy60ugEkNqIBvlMtFRTbauphISk6FnqgkVsYJAq0FMnJ29jpLqOZCqRqtpPjyPprFoLIlp/RzuOMgKIWlaPtqqNburaRw3xukYKXqJ6LtdTAgtSbNE4eteNpVq70OgytsXtaVRjwahYgCNvudRcgSDtN4NS03aLThwHpLhBtqsCElmPxDTpaO1EroErIrHTU1cA5cCmiUVuol5XjOV9L61fXqDBgiqn19WOG3nJVskDtZEJw6QWMprI9aSG2L43KElJU0VT+czQDDKJfhvRFYvBvWkLvDCKYrFpdaryDIqWNLk9mIlrfxYtsxYJxJoU4mRLNc2MaA3z5ZpmNme8vaC3N1BH25/+taV0cyorQnyG1KREXbObMBpLu07EX1QN+rAwGyco4mIQjBSETYsG5fnLVzx2tSZ40aUzKiMBinrpKjbfmOujR3Luxif2yJYD/Z0l+Z4SVTnpJa9EkhQyQzOTU8+aNqqvgow39VDTv66We1LFLEaI1mTzmmLJyfrKWq6N9/iZXnvP6iagxhW+sNQLfdG7x7anZnEM3qH3KtHaaoVZKaUCfm0sOtF+TyYhRU69VQicXp1AFcca56SDk0+SAWJkNEAZKL61Awisnr5ZuicBoZFuWaGS6KVCyRsx6lGVEUmF5N+dkF+j0WuldOpaKNBDaUigyyY2qYgFV3FZvJ+SXpAoa8wchb3LEj0vCvCxuKusRL997JB8b41ZLbGTQH+neAwToBkoygXRh4qjgWFyVEbTQ5YbQTWraIbiQTrZAmxpGG5f46Sj9tAb1Hx719HsvWIevWREDrSsKVWG29rIM3NNRr6X1taumpVMiuuBXZPxsJ4PMkn38jc/dAQUahLN+mP2pCkUIQuUm8AXAdUoTG3a4lGfB5QO+FlHyD3ea8xi6uSYAgBqQ3Djxw2HwrUs/dBto4OgI6qHGCpAsego9jpWj9f09gRm/6ei3JJJdTMxMhYQo+QUXYqp6HJ+SjRF3ygkpFjy9HdKdefomAxvFXYcUGXyBTU4FcmNkqKYfCXqFnuK8faceqBaP1KXa0wlUarQz1G5VD67gW17kid/QBdNnn1uIAwwk1KIgg9iqeMlYmPKQJPM851CRe1XUMQe8kKEk15VMSWfKf3rraLpTe2IkmwiecS2Zv/rnmndRHLlA9pJBGV9KlupAEaRTUIkqkJOQ/StTaoAXxhUTiSwUjglWqyp9tbbaevHtA/KBSGMRkmnoejXaaq4XJDtg0RkpX2nTDjylaYlqDqmrkOm2+ha0tEm79ZEvEJmKLf1yVZqimuWGN12jnrGUCw2IsMYaqmgRVJ3PkdsvqJuDDW1mfFW/plSoVRovVFFuykFHMoHQmpp66YTrqYn2rmgUmFYbIyAihpWWrKjvJLOZ5GU25GTAhuTUtwmmtAjGujVkbz8h33Zfm4wq6WQHhfaLknKBexaRTPM8bEYJsSCHWJEVdeBbFX0IfWMTPC0kw5GAKYU+YwvpGJcR3mFuGzIRNL1pZ1psSgFduWWvLXmypcDdrXG7hlJ16UoXWBcwbW7CSkymHSLWYZamJObyDuC1viZAl9Ia1efyYTDjnw7UXMzOQxiW1NjpBWol3s1uXTo1VK42tEDCIa1YzX93Q0o6UQVMtOa/tebenFiKzIicXiQjlr5cqDYOUEphdpLjGiL73K2IhNfs1ZJNy0TTeCHMlkwlUdVDjTUcxZvoFdJAZfevSzXZDwRtUuMZgYvWYxQVm3aPxiNmx9gdq2IvVTqNFfVhPEEP5kI4U+FSkpNH0rnKb67E6U11bahdKOqohg6ThawBqU03lUS0QTZbt1MieSkhElJvbAZV4g2XOQR0pLa7FmTiag1Qqy9hJXVpJq2f9VKirKyDNXvQZ7JMUai6gux7wqqwesA6Hi/xnu30oy3GJSNGSIrVm+bv1kx3mYZH6UpNwdcP04WC0XvmDHF/ISdK7OMdhWMrh1iFzU+h2xZ5D3NANRYQ6PI9mryRbmXhfTGsbGWVH5QYNYku+L6cVtZTPsHSAOiKeXnyWZo5hx6rDFjRBNvwQ28EFXj0SrA2KBL8XC1axLkCTaIRjUV1Ha41aEjqocBpvKUmyEbi3nyZKuc9mxNrGukohoZM7OoXSVq0fy6lEciQ3GWmjfS29vlEjmsB4qe0bg8k8hQ1EfKthxm3OCNYnSUtHR1s558VQby3p4aXXqa2Qy7IkUNuvZYjbT1i6QrpeRTGttnGjPoEaoGfBMjwtFsHWIlNxJljMcYIuEjptql00qKjNHaC4mlUDx0FSvfkwNA5O5BRw2soU2nBZVazU7PXdvtKUY7zdhP7ayMAjvNYaUuLaqBgNgIqUK3nqpKi5bKA8k+TCr6VfRZDaJ/LDJcrtvjTDZX6VKmLi8EYmckIYW6boQo+UCYUbihwVtDEyUOup6eY3qaaktPyF9maIag64FEzddG+F7eantRMvC76NGr4/2mvBxrkmoEK0UTqTuUmN3TNi2QDjfxhZXuTU2rVW0LmIyKKXLdmvenlp82psyDkZdt6rJWz4tXqHgEgwoFdrlE794rUfsZIamsjtB7l9HGiKVPIgFFLq02MTK5KFJlf4xGZ2Z6P2iFmTTke70Qw57BjBpJ0xstJDXdFTHKq2tFNW/kXayUdGVSSHFVlBD4TNHbU2L3jFCLy3JfWgtrY6kG93FWlvTYRgthKXJJkfbF8qqZL2hmMikAKkPbEKQt6vMGrwN2MRBm+0AQsqlAJZsto2lmCsothUx6jdx3YU6D7rfjSXJg8JnopeV6y52aL0s7We0CbiZHTySN3wwtky2ZRJgBZnuEQsipz3X0R3WYiSMUhnJTRj0w7Xbya5eE+FnpZofRUDdSKe+9VNDnuUQjmwaynng/z/eFEE8q8Tmty2ieHyBW+WPixDlpWbWGcUn2le+T9XuEnpVocr8v6zEa1S+mg7YCZa3si3OgtUS8t22i2j5DuWBRXqrvdRPIdjnMzmXxdfUeNegT1kayojwDG+8lpaCq5NrnOQz7MeUUwEBz1JxM/PDo1TF6tWRwTSl2gXHsLbf16O/UFIsVdkU6yKUCu1R06zY5MdSfaMxI474+y7XzM/gskI+gt6xb6ZMvINiAHcvzandpstWoPY1Sn2YQqGdpfcB1KWOeLwIhi8tqBbmDscXngdrI8qEfswZpoq2FoLq+RLyVB71mxPi/lCIqO55KjLwCMzmyIqqdRvXwoiOqhxhBQTlvUSvyRnCFYuk0jVlV5CugS5nJptanupqSqQ3kKhJWeemKcXU9a8lGjnzFRAsrUE2gmhUrHVNLRTpBPtcTh1bQ32WpB5r+LsiXpIK3GVh6V63g+7mYZWeWZmEg1dUutJ6c+xxfZnCzPcx1SzDs4+b7kvpnGmWDdR6nyX6onKZU20KZ9bUS64qvkm7TVLHy2kjRjehAY+oZWo/T9J22I1GIJDIVU+QQfNIJCDlL0VyUahszyHWIA6ROC6Rom1yDYBUqFtYIGZdoquvLTts1FwmaXIcQq7e9VS1JlQhZzOeHgF6rUFFbqbynKTRNL5FasQdqelpsvYJEvfKVJlbGK9wwo+kbbOwbn7pgpQ5l2sXgRCLN0Y0h6DhRcrHxRE+1L5bk+2tHoX0ptl3TwjTSnbplAW20KckF5Lr5lvDrRiKtYjWl8JmNvqrJbSFNGDxh05z4SzYeVlehqggzfcL8jLTH3LUkUf2AtP3MxFLJrNVku9eot85Qz+a4TLfHrFxAr0q3Iyl2K9DjGhVCPB411Up7ifjWs6IxzVedeJY2gWohJ1uu5TwXFjPx2MURamkNRpNpxGxtJP6Z1kCWScpZR8IyO0Mz18MP8rY4z/Ui6YqZAzmnasM5zpcbQs9KJNRIlNeOkgmlFkI5l1HNmRgRo9VD69JTz1nKOY0tA/mehtHRWewWByGfXl/lwQ1y8B6zMsHnBreQtdkRbWUi65Hnzg3kPKlKfm/6VhoorDp0KX3o/fwQ1c9RO/cKkdNaIqjOxwr4mEmIulFlDIxK7Dotu+T4EXJotCyTMhwg7gHeC9n0Pp1OGAXUpnkYDlDLK7KNLBNCujaOBFm1UW/V7xGO3Up5/Bzj7UX0CZb7KN/j0JNGNK9KyXompex/r4Aii7ZjSiQakbQF16BWR7JMLR5MWgXcXJ96pi/HbrVMeEbRSWGQYSZetMO7q+iooHA9Sz2fUQ815TbRHud7DMVOSZ+7QaB/jZYWpWXAFZLGbwYKNZaxMxHQNPa5nkxsq4VAvUWIryol4m5WdZwwAV4R+g7Vd9BIBNT1A2bZgAVDYLhtjXIusNLM4BacXB6vwMdgTOHxfVCLNnbdihmfOHaTTcerDrc+dET1EEMFyFc9xZ5AtUmxdoxh7psVaE25ydLMidbI1FKFm15EphRS5lO0FdosVoh6wPH2nP41Ff3rajgqI1uDfG8DwbZ+pC6XiGMzMNSzffGgjO+x1G0npZ7Lo2cxpaPcugm0wkycVPQORbNqJtI/2umpij5ohRtkmF4uES0vpDZVbYu+kmmUjXU/a9V2iWq7WMVoUUpzO5t8TuV7bTcmPY0SphRz0vC2BT1hWiSFEn1mitCmanG3LtooutdUhRxiYRStDRUGdGr3qmLhVLSvUilSHHtsh2idJIbXUnjTXr90btalzINWYMFZixvMkvxq67lMTPlDJMFR/tCSSyMnNETP0GxJOvv4XFPP5zSDFFKmtTlzhcK46XkKdhqJ0TWtv22q1E2Tpd6iSDWawbQTVppYrLf4aomUmkank0Y5HWsi6+L7Gk9va+Kf5AeisXbHDCj2ZNJRqW6k8rqX47bO4DMjpBCkT3qR08xkEmXPNHapwuXiLSktZGNUalYmdzQZ2aJMzKRtcJwgNIFgvBR0ZLqVvYjNWxAd+LjGD3LynWtyzXs9spUarwJq5yJhUqKs7GvIVCtNILb2Vdaiej0hKpltK/xlO6p9TnQZsGNpSGBLKaQylRdD/cpRbe5FvXDUSnvwRqObhtArKOctPhNJhilDtNpS0sSgr9uoYDVn2gYUrqfazE4Vz1Wx2JAtiRVSvamHGxjs2JOvOumsNNrX8FJXIuGxqzV2tZIOYlYIdAhgd63JuKGEVIaqkpR4SttnVnTwSefpHGp5JGn7aBUVnBOtrtaEOt5MUVgdmoa2kYgxaGNRszOoLMNvmZNuYjNDuSaFtKklz+SaOEk1qF4Bx2zFzw+o57LWGULbgCklM2aWxzIpCUBwIoEKcbLQzwlBoSYTifSaXCLEkxLyuM1IzJUTF4PBDulQVR49Q7G7xC8McDOFyAmsIluuMKNGNMh7R9OJYg35Lk1A4XWgOW0CKxZ7tchbXBG1+z0VfYKlGFcFaEKQ8dOqVm8+2SZNAXTmKa4xhNiCVddKipziRBanUIsZaqJkYrWq0dZjzlhjZmZM4w2j62bBBPRIS7U/ol1VPUeoFXZNk+9WrfRNdPvTydmRFFF1HHoNqbvpRW416IjqYYAZe4rFhmZosaV0nRpvk3RNvhpwDfR2e9an/tcTtqRNTTPKVMTiCoU7Iae3x5OtSOij6UE9K/Yz6UXH/8/en/zaluV3vehnVLNYxa5OEZGZEZnptLkFpngSIEBPskQD+AMsGgiJpi16QAfRsATCEjKiZdGhYfdoAQ2whIQEHUTrvga6lp541ySks4jiVLta1SxGcRu/35hrhy/vXSNeBGHlGVIqT5yz9tprzTnmGL/x/X0LA/4YcQcpYqaLhmkjC1Vr1SuyN9josCnT3o5SJF212OMMK0/qHH6vHoZ9bZ+WpWisqKo9eEwvOd1ViGViIfX6QSqQqUiVKYj36qic1MYuPrLGnF+zWJioN2rR61ALT1HM/55NUlGopK4HtdVVi+KKMNai2am5f+W+ShFsl0CBJVEL4egld24ji6+goIWV5JpaRaGzoK9V6V/tqZakrlKWAi41ZgkHkCJR/THrZ9fPUDgXhlJYWJqHWWI21wIRCy9VC1Q9/FQT/ezFqiw7+XxP2/92Fh5qVtpGDmLXJLSNc5Fc56Wgnyz2OSYqrcDJ/0t61Pme11HUTxejRv8G4touc104r4X+3XnJzmtpz6Y+yO+vcbt9izlNpOsWOyaMEe/geNVxer4Rl4KucPyGX+ZLsVIwUj2AjSF3qsqPSZDxlRf+di6CpnLmGs+XksRmnWF80dG+m4ibQHi9A4y0jtcdpWuk5Z+El7hEdoYgRZGR71UaQVJzo1QJvVzhMOtcFhQ0t04ETzhs6xYv2Hltae8zce3wJ5hfaB690gX6V+K9O23sQisab2SedXeVa1mYV+eDVGrFvqy7k+SitG6Eo+3FBs/OGTtmdYsQ8WFaBYqz+KMU0mml/EtroAgHm5Rxr27FxmkYgfIFYRlO2/05S4xzTqLwHye9ZwjPNOWzab6ulQtiGdMXDgRmvYIg9ySvO0pwuOMEq14OtW0jz9mql6J1jpjoyB/cEF9eMF8ILSWu9AA+QnsvYrbcBXH+GEbo2sXc30wzHC02isjRBHFGoaLqwcGqlXViGIUuNWa6+x25dUKN2jSUxktQQe8l3vrhHNNqTgPFXqoYsbD6HFafQ1rBcGwhQ/tO9pbsz6LHeVtULCVC2/6t+EGPV5Z5o2twMbRvDCbJWjZfazGbWA6hZZUwg8XtLW6AfJUoF4XcZGYsD59vmYZASRZjwR3EV7UWoWUnEaphX5a1CWR9xkDYF/Lqyy0K34+v93hfqH4FowRD6hxuLjT3URSMCJKUnbT/xwtZHEwpNA/a5lY06yliJW94bsnNG4uN0L6bePhfPQVH84C81wyr14maTV68o3knvorxu/2CRqYGwimTGsNwE+hjwZiCvzthDieaQVqUdj+QXlwuinBgaZenTYvdtSIc0ZhLm1HrIxWEUVFKsxSLbhJKAtYwtwq5KoJcRTWg3DzAqqiEXC2kzuiojUXa1Jx5fNKtL4sFFjzxXW3qv0sBaJRHmsLZYaDGq1ZEDSoSbJcis+jCWoxZWvtJqRJyfcpSbMK5SM5qOWPT+fM+RTBNlrSx+vfyWuXAFmQTz5KQFPZiHZa0yEmdWVK3FmP7Tt8jFqGKtCwbQbFQmjO6LUWgoCvVwmlBOeuhSRHdDLgs92IRu1nl0i7WY1qwToXYKqKqIHONxM1O+LNGqQcmC1olrWzEhD6jiL2Io/yjtlidI2/FJigcJ+ZnK7G28SrmiYLOuFNtT2QNCyjkNlC6IGrrC6+IqdGDoyXsJqZLMb7v3o5MVw12SszqHXr4mQ0AzS343YR7uxfe7G6G43AWGgZPGaU9bFY9iyK8CWJbpY4X9RrWz00RXml4nNTmR8RVdhLE2KTCdN1SLAw3fjmQTFu3eAvXbk2xwmXPjWFeC++wfyOHjbkRM/e6xhQH4SEvbgiUQm7cEnFbY2ndURFR5yALzmTnrN2Mgh1mxpcrTMy4nRbcwywFGywtfmOttNxDOIuXShGUtHJFK2Jr4Kmi3raNtO/RYrAUmGdxm1iv4PpCLLgaT279Yp9XvMV4J2iu/puL9XdnUdR/+4r5wjNvHeOVholMYHIW3m5rcQcjv/+JQK5GvJpc1N5KD+uzJvwFT77eklYN/v6IaaSINePEfNXgdzOnj1b4Q9aul5WUPBI2taTW4d/sIIp/8nht6d7NKnx0+B/NmNhKilTlgs7iSxpXhbQuNJ9De1fgyd5SqWKmQO4ztAW3jrj/0hLuLakrxHWhNGIzBeCOojPIq4x5PuFc5rI5ER8bjj9cw7bgPxiZsZjHRq8fKvQV8aHECp/pWrFjCaeI10JN+LqM9xzVr3a8L1S/5FEMjFeW3XcdcVXofcPFDyaJvjwk9bhzUog5eTibB5YiYxnaIoYzZ7MiCPPaUEyDiXDxg5nhuSj1wz6DhXAnyEQOhul5h50yq89npivPtBWxzFPl/LS1YDr8IZI2ARMz4dVOFuGSqbZLokpX4UUppJs1bj8uAiczRy2wA6YpS3yqzfksilLD7llFZUtxac/FTRVFiTJbC2QrJvzCtzsX7jXxCMoXKE1LbKoWeQW1q6oWTF5+d3rqY4rch5oaVYtF4zTbPSoaV9uUtojHaV1sF8SUJ/SG6jVaiEY2HjtmtWI5x8eeI1Tld7pZW75jXhA9vxPku3mMwgk0BhMTsfcivMrK1a33w0o8bDFStOaauOTFJqq2eiuKthSRagUmaC/L/XETGKV12HQWVFT/06yUgroB5VYy0005c4irB20xNRZSbLdqtOyCindO0EvNZJcDgiVtGplLs6Cf/kG8geMm4I+SylSyWO5gLe1GlGFhl4Tn3FryRtquVfjmDlGCA4LFxEzsHMMzT/Mg7ffUGnInAQrdnSCE7buJ4g3uk3upcY6D3LxplprqeiNFyJt7KVgqj7EUyqolrbzwwJPMB3+SFnm1QfM7KVKnK3ECCDspTmIviXRZEVWA3BSyFfsxO0lxEo7C6R6uRemdA4zPivDd91oQWlGPFytKbzdl9bqV+ZC3XkVcMhezV2A9F+wY9aCmKVlJkN/iLfNWrplPsmiZOalvrBXbqVpYBi/83Zgok7T0jfeYtlkOZQvMbKzQBACagFmvoW/lfbQANqUsQqbctyr4E5FXbqyIvKyVtrtJlODIq4BJPWZO5E2L/Xxm3lrGayduGTqnc5AAl+HG0t1m4jrgrjaUmy3zBxvCT+6wd3s9eAvn1qjR/4L+FrDvHolXHxBvNrI+7QcpnmMmXvXETk6CcaXrykNZhGrEhH3zIHqCXtaSsJ+xhwm38qR1Q/OoRvkF+neJ0wtL2hT80WCKHMZS/+QACsxb9IADdjD4JmE/C5jJkKvxvgHTJkqSZya3mbzN2FUiUHCmcPfDa9y9dKS6D47QZKbHlawz2hUKh0LzKPSw2NVWEdoZNKRefl/ukQ7I+/FTOd4Xql/BOHwMvM68/N9mMS3Phv6N+J2amGluWk4feKYLS3sv2eoi2GDxWgVFVdHCDMSrcRTeYneXxV4nwvqTmenSSRE4S/SmO0lxGB5n0kosjxZzeVs5cQWbDdNNQ3ufCA8j44teUKfrLfb+gBmlmikGSZoBEbtUAZV3uFMkraTAtTFj1l4KBW1dL0buUVqGqXek1i5oibSozNI2L7WdrK3zWvxQFHXSz2NTOScnCVV34T8+Vf/XlrGIrbTWzDxR5ZezvVINFlBUGwtGC0Uxg0cLfLW48rqRa3FWQwNcLbCNBAaIZZUUXlbFapWv6tSuzCS9L/LukrA0ZW3VC7plEVQoNZI9ntZOAxE4O0YUzhZQuTBeWkwEp9SN3AhChBWvVH9S+yMVvtXv9RThrtG/RqkCbi5LcVw9YSu1IrUynwvnVBs3idm/FKP6HaswLio3OADYxbVgcV3QuSORxDoPR1V9K6rdvhtwu5F00UEU5M0dZ+zzawDcYaaQxfPTNcwXjnnrWX0+Ee6OTC82UpivPPNauh3jpcWPYhH18L2WuDL07wrhQYza480KVi0FC+OEWXUwTlKkZORzAKx68E7ENL6ltI2gzSdBJpvbkdx6Ui/OF+44U4Jl3gqHdSlkjRTw2VvmrcTjpkYV0zoP3VwIBzngHF96UidpQuk6kpsCgyM3ovS3c6FkGK8tbqyt4PPhr85r6UjU+V9InVsEoNK5kYhZoasU5rVbXELGlx3NnajeLVsxzB9GiUFtgrT/c5FY0VF4qCYEudejhCbgZK0wqZUisOsoq1b+3lo5olZ7qlKfdwvOiN1bdfh40g0hieCqWCm2zZyg8bDqNahECt9qseYP4lhRrBwQivGUn7nBTlm6Z5tOC1UtrmpxGvMCCNTi2+5HaAP24YA5jpTLFemyZ3rWcHphVShX2P5ukvVizNjjLO9/GshXz5i3nvZuxpzk7+1BnF/840T/iaE0Hn+IFNPT3Bt235Xnr39tMBHmS7nPcQVxLWtBXieMK6QHT7jVVr3TNaXNmFWCQTsPq4w7GcybQNlC+8HA+CzgXiSmx5Y4Npg3jvVrS/dWDutxLev6tDVLVLRNUqTGtYQLLNHOX7MiNRVL+pIRzy/7/f8gjfeF6lcw3NHQfw7TpadcwOpNxk6F2FmO3+wXL0+x/amFmHLhchHenkHRp/qukjJULY1EUGSIvSMcEu27SVOkDPOlZ7oMIux6mPAHET+YHJiSI/aGaWtYvUrKAXULV9I/DuSVqK3LStpNUtDJ/+xBVLolyO/CGsw4S4zinFSRbM7cUGpbWAtWI7qHWohU9EaKUrOcvKtaXb+6tIzGsyE+yCZdxUPFCjpZUdDipD1di63ypM1sk6jOjaY8VY5UpV8I2qAq9UZRwCiG8DU1LHuD5Sysqgb/Yo4eFYVRCoSVm1msFgdOuKlVxV9trgRFl+/olLs1XXiq6fvSGvVCixBlt/BBiyK6qdF4VAcW3VSVO5y8dPycOk2ISb0ovkXRX2h2aIyhWThuS8RtLe7zGZG2M0/Sp+T71Hu+/KyRzajOc3kz+bMgqBIXWSyYIK1BUI5tsJJUlIUTTPUYxmCnSNy2NG9PuN1A2naCDBuHe5xVFKcf3ltw4qkZHkdMKjT3E24/MveW4ZkX1b2RjTQ74ZP7U5ZW5Fra6eHVnvD2SLpeSVv8sscD9uSlSLWWdL0R3uUcsbsjpW+FPwnQBNKmIa7lubKpkEdP3IRlXjlnlgONOQgv1J0S2cF0JX7M44VZDg/1OpoM7W2i2SfGSy8o1boQLxNllcUs38tpZrowhOVgLAXCeCFCK+nlW8gSF2tVBCmHS+G2ulEQ7+yFYz5ea2td57CdYbxywoOftIvRrsXYvxOFfe7UxDgLQm7UQ7c4vedrCXwvT6yeTFIOaxfEe9SdkXCoa8O5yMmN0AzcmM4FaRVbpSLWWwZBhL3Fdg3t7cx8IQ4H/du8dHlMYkl+mtee7jbRfyYn4+FbW9bv9piTOgHUk1pKC5pKkMAUf3+Uz3IYqCJKg2XeyAOTWnlWwjHj5ky4PQkP+/EAcyQXASHcfsa9eZDfp8ixmSLuBPNKucW2cPxQDjZhL8/6eG2YL+SQmlaFvMpYm2nfWszRYSYjyWydrqe2EC5HwmpmP3gYLXhFWjeR1fWJl5ePpNlx+N0t/TuxK3NHw/pz6ZbMawh7ERLPva7zvRFaQQfFSzcQBRbsbDTV8P34aRzvC9WvYDT3AJJOlduGcEq07wbC7iTRpbvIfCG+fNnD8aWhORTGS4Mbz+2mqvquxazTdKDpEvJRFpHcWW2bC+etu4/kWM4iFQKuE+GWnYoWZo6wF77ecONFpNUUwlXLeOXZ/pcj2RbS1QpKXkRUOQiiZ7K0rAietG6xSUQUxTuKtQsKVhRhEf6Tct7UVqc6GdQCFFTI4xCuaypfsO2yGnMKUJX+afHMVFshfW3RjaHGqFYRkCm1kBXErnkQ7lhZeRX+GFws+FRIvdgdlVK9LC2mO1t2SXEmCK8bxXTd7yURyGTl5apYJq28mIsr0lnRLzub5bUVza2FeLaIIr16lS48XCkMnoYOVB9a4MxRVdVsqpZTun+7Sa7PvGa5XtOFWfjD2UNpld6RwNSDVKrXXTjOhvM9SeFscSOK4POBQQit8vP1d9ffJeIJ2bwWAVuWw4FdqBYon9bij9qib+SQZGpM6mkmr1oMktI0XjcEZ3CPgxQ2QOq9zE8t8ps3J4q3jC97hude3DCc8PlMgrCHeFGYnoG/z/SvCmGf8W8PlMZz+nhLsdDcZcz9AUYtjIMjXXSYMeI+fxC+5bt7jLXgA2XVifhILZfcLpJ6+f3jtcMk6N4q53uShC+nQho/R0JrsauAmyzTVqgDbizElfp7HrMi2ZbpQuYHyWAODpLBDTJPmh2EXRYRjZX7Nzyvz5PM8XBg8X3GyEHP1pQn55bOzLw603ViLy1mq77OJhVS74XDqq4OdkzLPQFwo8atrho5AE4aEVspBY3YVaHCRTtFciOiN4McCI09J3nZOQtlRPnSbhA7qbQWxX2x8nozRbCdzNNxwqSOeLWitAE3ikjtKX/czWd6CwhlqphewjiCEY/U0ygCMD1cGgyiKBLaA95pSEoRr11Flu0Y6d/OYBqOH1pWn0zYKZGCJTgjSHMp0LaUdStFaOMomx4zRXLfkDpHvG4YrxzTpZz6pgvD+CITHg3rT2V9mS7UiqpV8KGNrH8n4B6srsPyGgkRyNBk+u3AaWy0xSeLYG6KKP5t4c1xw+5+hSmyf4WdIP0makenoECCFKmxR3ivFn3w9a2TrkVJkN/346dzvC9Uv+QhBu2FeS2WIM1jZt5aiu/ghahZ5qvA6YWneczErT2r/guMV/Kg+mOFsWRTj52VDT2pMOdJezR7I/GUxhDXQRwA9GfnlbRSw0E3sJVdNphRi1Q7F7q7dG6tHgbyRUeNN11a595QisUekqBHc8QWESWYYSRvWlVNy6pjY1E6gMaUlkLaiEdocWee1FPPWKMtcIwWmYrCgrym5q5H5fjWAry6HWQFehf+at1Yylm9LU4LVRmfsSUtTgEmoSiPtKLdVM7FrlPVfHnaYpfv0jwIR89pHjjeUnCyqxvzRGRkFu6uoIjmyeZXC2uDMWff2cUaqiJWT9T0xZjlO8tnEm/eimSaKL8vO0FJspXv7wYW7t1Th4Ci863SMZbUtCLXstTLW8CYys3Vn62G33q9FueCJ/nfaAGb1GeVJ4X14lYwy+GmeLkPqTX4IRN74UDWQ4lLWRLBVq3YHwFmzoR9ZLoOrN7txcIK8PfCDw33I343ybPxbAVFnrXmMTFt5AK3j1mvYaH7/IR/dxDFthFU+/TxhhwM/Y92+B/fSSzndgU5M33vBf5+wP34DcQoghnvYb0CIF+uGK+EM+lP4mu6+7akI7T3WZKo5iQc0Fna0rlxQqkZI+3rI/OznumyOwdrnOQ7SLcFphvP4VtyAAAEmUpGojBnmUjjVWG6kGLWH2D9OjPcWPxRDoxWDxupkRtZrBRqfpDnOalALnXCNT4vgCyomD8V2odE2M9LWIgdRUiZW6EqCX3nHLZgZqV41OfF/Z73Rl4vIiYn3Rk9MBUraxQaWJG9nmxz0XY6X5zAT7OYvYeUSdsW1LWieRTwILXgjyydnGoXV72fi7M0u0Qm40D8U52jTDMF4eQT5P2Lt+R1iz2O+nUyHE6UbsN4Hc4Cz84SO7FFY5gFTXWe8mwNq14Ah6CCrSZQWg/WcPrAcfiWVX9uQ9pkVp8aujfK1TeZcDTEjT57TaH/fiC8s8wrPbheifgqt7L2+u3MqpuYosfMhpKMiLVmgz149r7D+ExxBUdh9Up9nNvC8MwuoSWpVS5sJ44cJUi8qkmy7tgia4XJRgt8vjajYMhf8gcqX6cv/D94vC9Uv4LRvxrZ/Hjk9EEQHqkWSHHtiK2or7vbROpF7CILomW6kfQff8z4QdKLhDcolZcbjXraiaVMOJ4FSv5UdPNXVf9RDNyzN+J/XYUb6Vy8mQQ+l6UYs2MmGMP0jQ2nD1o2PzphxyyLIIompizRlvvDYvNSOWS588wbv9hsFeVNmpgxUZCR4kUEkIxuLEY4k0+FRHDeFOTP+tdGEB4Rgshr64b61NYJBGXNFZHVdr8IhQrzRor38izgRr9waAWpPJveL2iwyYSD8mEbu1ADilURnIPhmXh5rh6PWlz4pe1fjFgO5ckxb4RjaOeMHwrTVlumDpLyk63aUyalJFQKRHYoem7ORX1Fu33l2LLQB0Dbc7Ulqp95eT9fr42Ic7Kvyn2UYyjX3JTaIj4XrTWZKivSlhXlNcoVNvGMQNV7WAvu1J4FcUt8bJSfdVH8hF0UekQ9SNXIWxHEGOHprjyp87gxYiaxqBLELdN/Ii336ihhE2Ds0vo9ffcSv48Sx1qg2Ez/CrrgiCsjyW77iHsYMKdZTA5XLcf/9QWHjxrWn87Y40T2hfk7L/AHKSTd7Q53exIEtWmlEFFLKoD5omHeSls97ArHl57DN6Qtu/o80312xO0G8I54vSKuPWXj8MdImBPDBz277/V6M8Cd5B5ZNUufLj37jyzzVg4jw4eJ0igtJDmMM7T3ImTJnbSZ/UnQwe5WnEDC8YyO1hQ9fyyEXcYPmRSMFrDnoq2mGpl4pkx4FckJf7Soz7AcXuvhbbGoa+W59jr/5AAo997GvCDQgNhUPS1kKx89Cad0CSsxYIck/PzOKgKfKW2QyNNxFoutScIB/O2BdCEcFDdI5K6JjuGZgARFvZwrd95GhMN8kl9WtiuYhJpAKRhj5f5rCEFZidWaHWahCDSB+YM181UjKLsptG9H2ldZbPMc+NsBm7LM266hrDvldBfIienFCjuLRdh47RivLHaA7lZ//hMWdw0sTFeGeJXFfqoVr9TVT4rwnftK0SnSUciGtC7gCjE7AYmdIABmMosOIY8Okw3+nad9JXZew7Wgo82dzI3xSovXXhwEUivrlh+12G+li2StwZ0g9ZkcznvA+/HTNd4Xql/BiCvP8EIiFtuHJF6DatkUDplmL0WFOxW6u8hwE3Cjbgb7QvOY8Sf163N+EaMUU7QNp5zJSe09ZmnxzhtBzUAiV2urvDhBpawqtqXdLIhhFdGAFAv+7UBcKa9szrIZO0fujfz3EAV98H7JsTanaSkeawzqkoYzJRGHaOwfpZz9YrXgWczjK72slKUQs9WOyvAF0RAoGrkozs5tJZCfsVnbgZ5q3wlZNs/pQrwlAdq7RP9mwmS/iJlA+MD+EBd/zeJEAGBsRQx088wISgRMLzdShB6TboJiNZM1OcnUTU45hd5lUW8rYmsnTewCFssn80UEh1LOtlLyUVXIxYISPbW/Ak0eqj++tNlZ7JFq4V8NwutlxYiArzRmoQBkK6jb8p7VlaJAbs+CtkotsFNZENYarZq9/rwzC/ptSiF5nRpKD3EVwdP4Wa/vK/PMER5n7JjEgqhyFQ3krpFr0MkFELGcFV6k97hDxA5JnCqyHNIkMKFC5jKn4vUKqyr9uHZMl4H2XsIwyIX5ex/Ifbo/QIHw2aOgaV0j6vQCWLFxworyfPWpXKD27YnwDsJuRXiMdD96wD6eKI87WHWYVSBfBE4vAuEgB5q7n+8YbwzNvSEcCv1tJDWW4dqexYIW3Mkwb5U+0yVKlDnWvxF0u3srbf/TC2n3D89gupRc9thL0dK/hv5Nxk2ZsEuEx0n8bHvHeHkO05CDBPi9FItBu0GVhiLPu1VkU2kbMesz+0Uf3dS5pcgstTAaFR1UQaKb5OSaGz2Ye7HTSr09F7nW4KYE2iVInaV5OwlX2ci8yH3QZ6mI2E1/x/DM4YeCH6TY9kNhdoa4FmQVvcZLkqCDskQ9KzrbePH6TUXQX2vIW4G47U7Sy/K6o/TiwWSnRP+YcXvVGhTwO5nbZpolIOJyTbzqoMh+kttWYrTvsj4Tlu6dCsBmcMeibh6yZsVWnltmQ1oJoin2VYbTC8hapLq9YbwupKuEW0W264E5OaaTF664hrDYPmIPnpwM5uhpPxfR5ngla0DzKKETqZHrNV8U5iuNek0GO1qqnkDEtmBHKL6QVwXquvI1GO/FVF/teF+ofgWjBIeNUvCYWAi7GVO8oghns243FMarQHGG5pDp34j1zf7jhv3HlvZehS5eiqZwzJhimLeIW8Da4o9S0JYZijm3Revi//T/zylNkLUF7YaMqYr7mDFzxh80Xco5cicRi0KOF6ivrDtZPGMkX6ywp1n9ACN2DsIxXNr9CL9qLhgLxTVKR2CxZpIPxRPnJ/mPZUFMZ6TxKVfVxrJshFX5Dyz8TuAJ8qjXoQqnxnMxkjrLdBkW5A5ks0MtkTJaLGsLceGEPnnfWlSn3hPXUELSYlQ37SRFO3hKRYm8IXV2Uf4XU5ZC42ngQC2oF05oIwV5vXZLkpdFkOUotlzJfDHgoNIjKs3CzvozlfKAFN/GnBOx3CjXrN6rZJ8UukUEGYJ0PqELaGFai93iDaVyh7VYtvn8WTB6j/U+VpFhRdBysAtqbtW2qyKtuXGitQqSuGaSxc4Jt5+YbzriRmDctGno/tOJ1Hty52jeHcUcv/eEt6clyjT2RsI0jOHwUa9BEHLfxS8X1j+asMfE/I1LipPnIq8amGa4XGOwmCyenLkJmN0RevEctvsT3eOJ+fmaHCzNmwM2G9x+VisuJEXpesv4vAMV1s0bB3T4wTAgXYjwSnjmj98WKyO32HwZsi+kVQZfKAePHQ3dK8P6M6UXRPHeFDuqgj+JApxiiBvhKsdeiqDu7Yx/HDHjTO4DqTtzp/2pYPVe+LHQ3MuhNLUWG4WuAYj7iB4a5OBpv9ChMPn8rCzUHe08FD2IpV6KXXdKi3NI5bm7sSyHmtjVn1OxZdHuyBwpxmNillCCgtqeyUE8r8RloQpB7ZAIFh63ltiLmFXS/WS+L9SZY6F5mIUz2reYhz35ciX7wHHCzJHct5TgsYeBfNGTPtjqmhpp70dBE7FC0TlGcu+F5jJH6Fpy3xC3LXaYyW2gexc5vRQ9QfMwkxsvqXZbL9SZJNzc6UL4z/OGJRVu7gvuZiLvPdnB/jtSGBqbsfd+6SqZwVK2hdPQMEcHo8UfDeFerkduDL5NxAjNJx53QmlQQFbOvXo81yKVPkGymPFsx2gKmEkOWTlA3ib89YwN77OaflrH+0L1KxixNYxXhuZRoIHcihllTSKKvVlarrW96cZCvPHEFo7fQEyXB0PYyeIdexEi5ABmhuGZLMBuVMuYVnwwY8cSi1lRNjdDtT+CQinatq5tcgfZWU7f6mnuZsJulqI0i/UKKS/FaDXcLjdbSd6ZExxU7HF7FDVuK5tAFUOYYQLrKCsnrfsnLf4qDDIZ8CiHTpFeRY/LcL62C69VP3fleNZithZRNpVFdFWFXVXdH46ZcBBUe9rKdZy2Gg+5S8TVOSfdHWeiJnXZdG5DGuWwmizt6mrrVAvIee2WYj0HK36ogxbC7qygrsiqxL+aM8JspD1bhWJVaZ8DsIibnhTM2v53GgNrkGuQyxfjCGthXzxLYVwzzBeOqwqj3KzFqKKsteVZC86aYlW/t1glyc8vNkemHiikyMutwSuHekFi9T4JYnxu91X+dU32smp1ljoxG48rMfePa7+korlROhix+q3qwcM/DML7tDBcdvg7g9+NlHmmbHqSqu6bx4RJ0kKPG4MdpTXuhkxeWzb/5UjYR/FznSI0jvDuIH8GmftNgP0g7eWUoA3ML9aM1w1YaG4nwus9JgpaFn7whsVeyXvKi2tOf+iG1DvatzPTVpC5uJLnuX1QTuoE46VjupBrs/40L6h7WhdKm7E7acvaEfrXRYV/hfHKcvzQkNpCdysCrtRIznuxLBnxfp+kNb9tYBWYV47hyol7hT6L4aDI4ylhh0xay3yvz2pxRoRT6mFsivBMY31GCot/7mKB1VotaI2kwrVnGkxaOT28GObe6qGzqHjQnlv/ejCVZy9hMCLmNFk51Xr49mIJlVrHvLKLpVo3TYKKE6DVU5o1+F3BHxPhqGLKkwj6KAVzHCjrjnjR4vcTpQuaMmWxJzHnN4cRuztR5hljnHSlukBaOdz9ETNG8XSNRf+8AgzuMAkYEMGkTNMamlcHidFdd9h1wGShR7lTxih9Igd5Hv1JDiDT84J952lvHbGH0hXsyeAUMY2dINnFQR48Q7KQDM1ngU4DA47fLUxbXYuOlu6dzMncyP5XBVLjhSD781WmNAUzWexgsZNdDsd1/Yp9oWwT/bMT29VI478+hWouhlx9I7/E3/F+yHhfqH4Fo3s3096KMbsbtfWrbavKtRIRgbxelNeCDuQg/CD/BvrXmZp6Ujfd5iSIwbyRAm/aWiXWK2+xImdRvT2ftGUXlMsgSFqRIsCpGCkHw+llg4mJ5iielLGXXqw7RjnNr8RIW3wCA/aTdzBHKBlzG/GbjrjyiqypsCgK5Of2huYhMl77M98rPUnnWdpoqA0UC0q3FGf6Pep3WsRXaIFa28yKMFoNCKiqZIxhXlnd+C3DtSGcJCxhVm/J8DDhGsfw3BO7TgUjlu6dfICiqGG1FBPDc0Wqq5iL+vnlvsfekjqLG7LYSmm7srYPa9a7vIeIVKT1LRtG7FRtn8El/T01JKIoz3MWnmcVLFU7qAWpaFj4rWTtxpfztTFJLL3kYuolri5kS/BCFVlpQRzPxXk4qEisOXNdRXAmqVzFy8HLJph7FpqKMSKuslFQucpbrQK++lncIIb3uaK6Sa9vFLTepCLFQMzML1b4IS6q/xK8IuQON0PaNpjdrN9JihY/CJc6rj12KnRvpCARFXqhfVdw+yhCj4cRd9B4z5iko2AdxgdIRVCz6iZRYHzWkVophONFS9w2tJ/t8Ue9CE0QDuMcmV9usFOhuRuYrsPib2uTFKfNI8uhJ62EH97s5LA6PDOMz8Q31URLe2cIO2nBNvvCvLKcnjtOL2G8LnTvDJufCO9X0q8EETNJvJrDIQon0lnm68Bw45guDN1tbXXLx7fqGVsaq+l30vYQcZ10DtxJYmqLsxgyfq+84xnlo2aIhnnjlM+qz0ajQsd4PsTYOZMaKXTD6WwRJ99DKAX+JHxYd1L6zroR0V3+vV0nKaRzI64R4SgHk/lSisWLH0SG51bm7FDo3s1sfueBdLOWA/rbPebTtzK/NivyzVYOVOtG1nsjv8MGg387ClWoZMqmh5jFxcI6zDBjThPmNOHU9YA2gFNKizOUrsGkTNwEmvsZOyVK1zDfdEwXnuHG0d0lvHobiw2d3CR/UsrX55bwWMThYlXITcHvLeFROKTFQtpm7OWE85l532DvPeFOn+OQiR/NlNmRdw53lPVPDjoG1J4sNxLbKhQUEV+ZyYoIa0JEfkbWt9QV8jrRXI1s1yfWIWLN+X6/Hz9d42tfqP7gBz/g1atXX/i71WrFH/tjf+z/8tpPP/2U169f83M/93NsNpv/6vv9fl7z/9dRxMD74nd2lMaRVkEENM05172qzyvvMFfbl1lPqUaLlVYz0+eCUY5g0o3AH8qSJpKdnE79kCU6sfL75t/z2RThqnWc0UVaEDFBWtxQaN6cyJuW8aYVisJUxJpq0sUyONx+wsQkUYX5QVN3wBwGTBabkmr5REowzdjdHvO8JbbC3bPVs12LquK1yImLBubMA2sEATax8lZZrGMKnIs+KyK03Agny40sQoJiRVQgfF8h/RcnqJKJhv5dFi/UyqcFhmdO0O4ehhuncaSGcBCPSX+qrUn7haQpN+YFHXLzWRQXe/U1zWeU8inXDytop9GiJCvS6aaiyOeZd1qpDrWtX9GTKqg6c3ZrnKYUuyL+OFMHxCuRLyAcdtZ5GPiC88AXUsHs8vb6OVjQ7bMV2LkgQOdcVZU/LXTq/ZN5YBbT+dRUQU1RmzCjc17oMsO18AlNFuW+nTOp9diUcYdIuBU4vjSOtBExiztF4kZ8OO0QlbMtLeWsbgRWkcdwP5D6oL6VI6X1lJQJP363dA1K35KvN7i3O+y7B8o4YdY92V8y33TSVYgJh/BBw/2IGxOkQukD7PdwOlHWL4kf3Qi/cizEtefwzeYsakt674qkeVVesz/Ioffxu4b5smCeT9gmU9622BFWr/Li6jBvDacPCtOl8Fj7V/L3sTPMm3PHYuEH70agkG5W0oG4UE6x8qlB1h1gKU6njRTP/iA66XoIcydE1W9lIfKHWea7M+LXrGigUUqSROcaYnPm7hUHiVoMm7Mvr4IAQgWQeZ+9iLNS6/T9i7pUSCRy6izuAHi7/O4cjNiQ7SPNuxNx7UnPG8xsmF+I8X//kwM0HhML/vU9vLqVuNwX15SLFWkVls8uTiFKreodOTiazx4AKT7NNEua2XGEYcR4LyESF2v5Wl0g92HxWq7JgFhRxudtz3zTcfygWWhEVXyavWG8sovlWgoSEuH3kgIl3TlD81piuKctzFcF0ySa65HiCvEYROWfpIXfv5Z7nXdBeKaTobtDU9OU14Mh9sJJTe352QdZv90INlauq6y/JRTMKmFs4Xhs2Y1bTt/7+mSoJiwJ+3//wv/O3/F+yPjaF6q/9mu/xj/9p/+UP/SH/tDydz/7sz/LP/kn/2T573Ec+at/9a/yL//lv+Sjjz7i008/5R/+w3/IX/trf+2/6TVfyjBw/PaKw/0KN2bmi0a8QReeZcEf5WGPahU1r4RzGo7CFZvXVgsN2ZhMc96gqx1ROMoiUNW34SQ+j8XBcG1pjlk5jVYKNUT97yYpRsmKdAVI+ezt6TLE6x6/n+g+O5I/XgvqMUq8qq2t5WGWRbaqlLwIAMztI/aDDem6I7VOMrFzhhghJsLrA83z1VLUufxE9KUbTEFaSNLiApwuvM5I/KZu3PJD+kdrKEgxV2kOqQqA9GCQwhllhEIsZmmVW02HmreeSc3Uwz4zb1DESlv6KxGshX2SyNqiFldBN1BXN0lp5fohL9/PJEHDnzob2FTE9sTI75EsbEGTUmuwGBFFePVtrJzOiYXTV/w5RcZG5ZEuCuUvFqQLJ7i2RvX9lqIxL4AwS3yqnmzqHK7IfOXG1gPD02SvavBfEfAvdLXqz2ZNtarJYk/Rf3umxNQ2cuxrsS8I4byy+EHcLWwSOoXZtlJAz0WsgRTpS62VVKo+YHeTtHnXDuch3E8iFFo1+H1cHA/ckIjbwPHDltWrmdz24gk6Jex+K4eyYcJMM/btg16IIu4DD3u8NfiHE6UJxKtuEWO5yYO1pJsOuw80DwdYdUzfuJD3TyIeS614lIbD2U+5hmdUAWT20N5LDGbqUPP2Ag+B7nOZeKcXlmYn3N5pixSzsBxoU2M4fFOKGDNDbgo2GaYLh/loox0AaB8k/MAf1Jlhoe9YsquWa4Km2lTwg9i+5WBoHgT1nC8bQS4rEl/T4YwhrsW6zk1FuJWdPf87dZ5pGMYTP+Jiheta+aggLXk/5IWTXuwTxwhbuwhGHAQQNHleW+xY8IdEuD1iH06EsaFdB/xRYPyL/zzgxkLadoSHQQ7jV1viy0uxOzMwr9wTUaYg4XYq2KKOASnDuwcMRegQ1sBmRXl5RW4CZd0JzauVha94I5ZqgM1lsRFMrSN1PcOz8ESQCZRCeBjJviWuHamVw3k4FdwswqnxChwZns/Ex4Z0lcnZUjaR/sURA8zZEtpI9hneOelqzeK7bE+F/jOht9n5jN5SNO3qafRqBtSGyiSzhIu4QQ6FuS2UVZLOw33HOFnZF+b3hdtP6/jaF6oAf+7P/Tn+2T/7Z/9f//3v/b2/x7//9/+e73//+3zrW9/in//zf85f+kt/iT/5J/8kf+pP/anf92u+jFEMnG4c9/9Ts7RD7Sz8nYoiVTTNZNl0mj1gpBBp9pnVJwP+MOOSJfWe3bdVGap+c1A5q+cW6LwyFHNut9WWvmzylmLKWS1vFKHTlntdVGsUZm6cnOKFNYmZC+N1oL3XNr41lNYLopqSwKLeS0FaILw5UNogG/rjUTxXtaB19yfCY2R4Hhbfzqz2RtnJQp61oKwm8nWDqu3nOmrKU/YQPYTjGSUmQ9gLslr5bXJxKpdS3BfGS0Eww15EadPWYTQ20h8imx8nsdUCTZKyhEOhvU8iyui9pgyx2INlA0a5cYKm1Ja4WTi01SYqafJV/WziJVqWiNlalNT2XRU5CYf2rM63EVy10KrCMi0q6zWqPpuiiC5LgQlnhN0qraBSKkyGXAouLR9xsSLCioWWrfZm2prNXgpJEZ7o+7szNcHYc9v/aXqViSzFc3YqkFFni3lltdNwRn4r1SI3hhLV6kvfK9xPErOqUb8mF2g89hSxu4HQeEDmYFp7/C4KJ3vlae5GxmcduQvMa0ejBxLmSOks403AjhfYoSP88O3Zfuo4IolOWdq1uyM4B88uBZlrDc39jH+7B+dwDxn3eKI8uyJed4zPmqV4LE64fnElyLqbFMnfZdyI8FVzobsVXvXhG0Gy042jPDr6N7D+JDNdWlIDu4+NCgwN4dbp+8l9OXyzcPpYctxNKoSdwR1ZvFKzh+HGSHSqOc+TqnwfryQswY9yKHRTXqzzslfhUZHDwnghnMxmpyfQJ2EV2Qv6SIOi50JFcae8oOs1YEI+G9I+Rmy1slNe7UlcGXKQg6Of1brPOtyUsZMUttPG4k7iMjBdnOeOvz3gP72HksUreIjsP1pJSlXwzC88zZuD2NA9uyBuPON1c+6Q6S5bvM557Rq5U8TtJ+g7TD9QjgOsWvKzC+G1rj1uFKGXncRKy5SC2Se197PLwTC1hvHa095J8V0PMv5UaN+ccPuR6Wc6xitxKujeFtypEG8M0yWUplBChoPD2IK/lSSp6SPDOATm2eOQmG52ntUnso7J+mPoPzOsXueFphM19CF1ujYlQ3GF1GRKl5VaZDAtmNFi97pur4s4EABMTvirRwvt/89t9isf7zmqX+34A1GoTtPEb//2b3N5ecm3v/1tQSiejN/4jd/gl37pl/jWt74FwC/+4i/yh//wH+Y3f/M3lyL09/OaL2ukTpCy5kGUotXKqG66KVjh6a0MzT7Tv41SfHixSjIxM111TK1Y0jR7zaL3UJozApn0xFpFKDURShYA8Zr0x7NSfBEIzWAmyZ0vVmyaJPVKTaGdIFfjTUtqhJgv7X+DyYLqlSCeqGXTYZzF7I9IEDyYKFY2uXGUnDDjJBs2YJJwxorVzV035erRKYIn2ZyF32fAsxj0L8jhdEbz4NwGBy1KrCCfxWvRM7EUy6I2lgKx2YupdwkGe0i095HmMeLvB6brjvFKbMaavVST/iiQozulhVdXhVELIvkEhaQIer1wPeMTAVQslGC+sKGdrXqKIshnbuJiwYUUCn5QnnPQFBcj39cpTzd2Rm5JVdcmmT+inGdBPOpndVNZCn1T5LtgwP4e5LXyVP0giJAfUEGe/B43icBGuMByn5LCYrllQbQATDG4Uz6jrAVyDRKAJzxubdn2Im6qzgCpMQttudoDuZOEV6RtR6r2P4O0nN39AaYJ/87gP4+M374SBbiJ+P0MeRJqyyj3Newi7btRzOpPibxSy7IpUZpAubmU6xX1wGYMjCOldhsArreEx0iwaGKSU26vpfQdedsyPusWHmZcW7CSkuVP8szGlUamWoPJWdX9he71gCmwcoZiPf4kz2D3Top8Ewt5bcmhMF9n7GAIO+UIruD03DC9TORNwuwNfmcJO0PzUOjfJYqDwzftcqC0sxTQ4t9rNOVMQyco9IeCP2SZq4qcik2VUp+a8/eoPOusASHzWjjibhT+qXgw13WhIvZKh6kFczwXxF7R0Npyr3OmtvTdIPMjrvzyd6KsF4cAf0y0n+7wP7mlnEbMy2cyBzvP2fMXSUhrvPx9KkxXQTUDLB2V6ilbnS38bhLzfmvI3mOeX2LilvnZWrjbdwPd5/fkTc/wvIULT9glSbtLhdw6zJyZt04oId9wYmOoYjcbC2Gf8LuZ8GrH8NGG/cd+QZhzMBw/NIxXwkMNj4b2Vk6JuRHec/yZif/5u5/xo/Gax12LfRDaSfeu0N0WpgvZy5oHAQGWA0Qre9GCItdiuiuULkNQwdxqpkRLmQMmWXJTyKFgJwOTly7G0WCjwR6FIvB+/HSOPxCF6r/6V/+K73//+7x69Yrtdss//sf/mL/4F/8iIJzTzz///P9SbP7pP/2n+Q//4T/8vl/zXxvjODKO56fj8fHxv/mzmwKXP0jc/L9n/DEyXXhOLz2pk7zwAvjBYPeF7jZhY+L0wjFfwOZHYk59etmqAbsUA/Pa0Oyy2IbEAo20Jn1kyWO2UTZvp6jVeG0lVUUXj6WtWnOotdVMRS7defMoa6fKd7Vj6aUdl4yYZrtJE1ZWLWacEe8hBEnKGXO/x40Ru+koF2tBlqr1zDzjH074sSMiqENFmSkSfmC17V382R2hFqiCvhQRFiUVMWmxlRqztAoFIZTittR4UsMS63gW6ECnRvVY9aRtHPGbG8Yry/DM0r8u8JgWRKryT1PnnljrSLsxbdxSQNsoYhxTChG/8CyTk00VU1F1OQgsaJo1C0c5e0Gq3Cy0AZPAL3xVFusyYBHqFV9pInJdYhVXFUGhF5W/OxeeglKaBU19il1/ocXvZL5VTqnVfy9KR1k2xoqgZimySjBYbfNXkYwUIoLbG/3B5fea8+EjOy3Kg7hcNI9y02MwixhPvofRFqTDzmJRlDuZ+HZO2MMEWQvK3QGA5vWevG4pTRDhnxGOY/PuKJZVrSN1Hn+KFO9FzPRuYHrW4Y+J6YMN9jThDjA/v8HfHrB5Lf6thxPkjM0Ftx9ECDMLN9XePkITSDcb4kYiO3MrCGBtZzePQgOZLqTV290l/FGSt4bnjVwtFQaZVOjuMv3bzLR1zGvL8UPHeInYVBWwJ5n044vMdCMtV3sQz9EyWnEQmSvdojouKM+7YUm68sfzYaMKHuuhJnvDeC0H7LDP4jerqL4bM60GN6B+qIIei4JfqEtmSYkD6RzF3i2HuNTq/FFaSlCebGqMctPlZ60R5PULokV7DvWA2pKXiOjV5wP+9SNmnGXN6jtxMLGCBPtBfFpNhrgJFNtghyghdl4etOoXWvRgXIWB3ZuRsI9CbVJ3grJqKbkI6j8iFllXG+aLhunSn3ngBrgQZL+6s8S1cO2b+0h4GGR+HWeKF4R6+tYVh+92up7I8zU808hSJ4eN8CjPTFpBXme2Hz3y8R/5lLe3l0w/2OCMpbk34u99kuseDmp/Vg/fmhAYe6v3SdeHppAlhFHW6OqXWoBZYnztBP5o8HsWbn11ajAJrHDAvjYjY8lfMof0y37/P0jja1+o/vk//+f5O3/n7/Dhhx8SY+Rv/a2/xS/+4i/y27/923zve9/j9vYWgJubmy/83LNnz3j37h3A7+s1/7Xx9//+3+fv/t2/+9/9HfxePDTH60bbUIqkajujFjDhIG2b9r7Q7Ayp8cwbKQ5jr4KKziwekoKUGVCRVI3zFA5boTmIwigFUaeGAyrKEYN7SZRB0TN5j5pslBqjiTxZW8kioKqJQCloBGejHoXeQi7YAcwoSAFdTxlG2fCPA8ZZiveUyw3m9kFWKidCrNVPTkw3Lafnnpr24kZpGcfeKJJSFuGRHbWwsmURKS22VLph1lZ6Ue5j9WHFSLa9m6Smrip42bigOWSmrWW8dLhZuL52zvhDlmz1uYh6PAtlACtiDBszsRNbKzeBO8l99kdp2blBfGlT58Q2qUCxDpNFgPW0EK9oTTFSoKfGnKkYTorLJQLWg6Esc6K26ykFUyMnVZxWnCCqRj1TKxdVOJiQmzon9VrV1nsj77G4Bjigvt+s753kmi5iwOoBm8Q0vhaQYpGWz9zP6YwcFyfoPuh/+/MBw0ShbgDLHKx+q4Jm67M0yPWcLtT+DPQePHkojZGCtG+wt4/CV/UOMyYsM8yFtG3J3mKnzPjhRtqvo/BUo3YL5rVnvPbMK0uzszQP4n86XzQcv93hnzW0r09y3791RVw52ruZHCzhYUSy6y3p+Zb5suHw7dWSKmUSS3Gfg3x/g6LH6mogaUmZ7vVICZb5ul3QfTdmyJJyZzOM11Kc5D4TbqVgT+tM2SSMy1hTKFODGQ3+KDZWxSqSXy3F2nNSmxvPRSKVFvJ7hH2xV3eKBHYSTmJSxM+pSKrO+5qeVjnjqZGCJ3uzFKIVaa9iP6vpU4ulUWfOnaQaikHliLNwYWNrKH2lQ8nEcCexm/P3A6AggHNiCXUliv7xg57hmaxRsYPsHW4QqoFvAsXKd67rCUi3xw0i0OtuZ8LDJIVoJ+lOdpjFs1qn5nTTMzwPxJXwsG2U9S92dqES5MaokFS6Idu3kf4n+3OnofVMVw3FC00oe3FmOH7IOYSjQHMPbpJCMfaG4bpg+4J7MfHb/8f3GF/3uMHAZcYkuV5+KLR3SfYEL960uRNnktQYpkvDtNU11Z9TA93R4O4cjeI9En8s16e9SwJ+dJbYnS3w5o2mV/Xyud+Pn87xtS9Uf/EXf3H5s/eeX/u1X+M3fuM3+Bf/4l/wN/7G3yAEkR8/RT4BTqfT8m+/n9f818bf/tt/m7/5N//m8t+Pj498/PHH/83fIa0cxw+DFJwrS26FYB72EHaZ9Y+P2ATDy37xFZ1XZmkX2aSRqJXTmFhEKvCEQ1ikjV+MRNQVZ1l9npguHPPa4E/QvUu0dzMmN5yeuQXdqOIHntAFUmvo3ij3cu3PqJYWsxThEplUKKVQGodtvMRFjpMgqn0DUxTu6mHAtEEU0Y8HeQ3iAOCPM7l1uK2jxiEKH5OF+1Y3qIL8P5wTujBIUswBamKSWCGBmYTvWzckG+X6xl7uQfso/fnUnP1pq8hiauW/u3ei6OdOrp/wOjPuMJFWAZcL04X4FubmLH9vHiJuSNKqi5LbXgUdAN2ridR75ssGnlg+yZB7kTRD3Y1nOsZZyVuRSLBarFbT/crnXTLaDYsQJ4Uz2mMnBP1qZAOUNrIWn1aFUAmCCL6lAMZAUmusIH9voyKj6RygUHnQboThBbhBUJk5CHpf0bnK165uF/NG8smrSXhtmcp3rm4GYg0We0HPFq71lHX+iADJPCn8UdpQdlCCpRRIH91gjzPuOJE27YLYzRfipdrdztghYaeEfxiYL4IcmhB1fFxbmsezej1eSHJVe59JAeJFI/xpK4X1fNXidzPzTScHEW2Lj9cSz1kctLfQ3ecF5c4BUAV+XIk/bXs7kxuHUQrB3FnGG48bnQYTyLyPK/XOnaF9B/OFpX0H43OxAJIi01AOAXcUE3d/OiOjfpBwkdgZhhuJfHYnvc9qy7Y4jnil4SiynZRf2uyyekY7ijG0D0nFS3K/3SmKgl3T5QTlF252tapb0H5dn5x6/k4b/e8ZfY4V3S9m8RKu9Jm6bgoaKc9X2GcV4KkwdJagFZzyixsPcyS3jvEmLPSVxYVjZQVAaKSoRznVdd1qDlk9lwvhUfj5qXeCnDtDSHlJqpu3nvnCc3r2JCnvviz6gmlrSb18r80nieYhyoHfGkrjMUOkeMvxm91StGMkonteW8Kj1TWjcPlZpn8VOXwzEHvDvCmYYshHzw9fvcA9Wro7mC+zeKumQjjowT2LnV/s9LvXOOReitS4EZur7At2NrijwZ8M7a1Qg0wu+GNZDhzt7UzxhskaLX7FJWC6KuRtwraF0lTy/v/4kYohfckc0i/7/f8gja99ofp7h/ee58+f88knnwDw8ccfY63l008//cLrPv30U77zne/8vl/zXxtt29K2//3HuJqY4o/S6t19XB9UQ3s7yaZ41S5IYOqeqLaRIqT6cbYPghalYJaF2ypfSviuUmDMWzECL2r4HXsRubjxnBBVxUcibNACJRasPfPGUu8Ap0bWgpwWRdkwKmjKWVKWnBNunjUiIokRc7eHoL3mlDD3e6FArjvhqpYCxxOmbQjW4K7Fvmspcoy2p6vKGZYWmHD4WIpWq7zNikTVaNbUSKGXvbSj7VTwRkIY0o1YvHR3GTepjcraaOteNr95ZXCDo3s7097N2Dlz+qAVRKJzGtHIwo/N3kIp+H3ERtmEzJSWNr6Zzz6PufPiIxlVKevNE15dbVcKmrb423ojat8km7EphdSbpd0q/GFFQp2hNDLfnFpMLXxPDMkqCqaG/EY38nktr62cwHBQpGYRrChHWikiIlSD9r4GIOgcU3qDG8X+qBaizYO8v3C1z8EE/lhtvKTNXfmKFU3PQQrThd/dQrPTAsEnYhaUq7mbpXVsBE00pUjO+5P+YW4cNcK3bFvm607f36ptm6BqceVobkc5wARH2AvZMAcD1uD3ibBLlCK+oMdv9WQnhaI7RexRONkuGsxeTN7H5y2HbwlMbafMeOMEuVKuZfsQMUk+Sz2gZkXD55U8A9OlpNvl4OheD8SVdDfCXhTTw3MRVIXjmc9tklmgydTJZzR7h91b3EnvkyKAuTmLNee1XdBxO6NBAfrczfLecSVzcBE1auGWA4yXVoWBKvzC0t5nUC9Rd5gwjaMEJwe26uM6Kz9d31fmnSEaeQaMdl5yc1bvmyRtdoqIVk2pdABL6mQd9ENR6ztFp1HxaOOYr3uat0cpUsdJ1rnHGS56mvuZ4XkjNnReXDiWdb45h43Uws2PhfZuljCD2imwIow0uRA3XpX4kt41r2uIgyDt8wbKTuZvXNlFCJmdhJMU43FTIexqtHPg+M1+uRdyf5S/3Qoy3t4XVp9PdK9OEkJR4OFnVfzVZ9yjxYyW9lYOr9NVwT/as+uKMYyXnmljzrzwSvvoVBDVZ3LQ7zsJvcKNqNhOrlkTxMEi7NJyIJ/XhuNLGF4W4UmvEt16Is8SPvB+/HSOr3WhWkphHEe6rlv+7vvf/z6/+7u/y8///M8D4qn6Z/7Mn+G3fuu3+Ct/5a8AcDwe+Tf/5t/wK7/yK7/v13yp38NKu64qV6/+U6a7nZlXXnxVL5slIrOKVsK+4E+C4s0bB63BDpnmIYlgYevOvpjlvEhWFLZ7q1ZWqdDsZPOvSvbUnzPsU6MoLAZrAVP5lYXUGcZLR3ufhLuada1QdMNNwonLnSfcD8zPAmXbEk4TTIqoNo38f1FS0jhi38TFuFogrQTHgfxiu7Q8q5K10gAE2TsnHUVrSFXxbVgsv+rivHDDRkF6bCzLBiuItBT0UpgKPyqcCs1OaQ+9oN5OU7CEd5qJvcUX4W7OW1EUuVlQPDeIkEGQ00wphdOHLc1DIq/cglTa4ySbVQiYmPGjytatE96W1hJZW9ryAdS+a6r+thnyuTVaKQ1ZkcpF7ITSIZTjZidBRKatladfUfKK3Bn1RzRJCwBfW6xQrIgB0xN6QFbkOCvybWfxTyzGEIbMtDVka+iGTHsvr62c14oYVWGeG7Mgjq1wdmu62mJrJdNzcTBwc6F9lAjQ1AmVJRyTthlnSrB09xk7Ki/SmqVocXd7aWsHp+1giSWtHOP6fDSD3NvUe0H9+kBqqwF9kRCP3YS/O0pOuzG4IdOcJJfdJikki9EiYyuRndOlcJRNhNMHXg+OMj8l2SlzfBnU37Km2oEdxVLIzgZypn07MnxzzXzRYiO0P9rhh8Tx2xdQpOARKoTBTWJNV4wovcHAaLGjxU7i0Wxn1NBfniWjB7DYm2V+NENZhEGmhmegB53zkiSHB+QAmRs5AMaVdIdOLwyxc2LBt7fEzQr/OFEaoRCRC+ExYWJgvPa6dgn1IXYWfzpbXRn9HeEgqF+lq9iIHOj0sDpv5PP0x6xIu3LWvSHshKvsdzOp96RNh3v3KIXqPFNiwsbI6v+TCB9eQgicXrYYIwW9TeI7StEDf9D5lsQ+yk4Zv4vYMZKDI64tpxeeaWuY13KAkHhidbeYjUSQ6qFvXluO38xy2N6ZhT4mTiAZf38CCtOzjhysxF7HIkldkwTBxF74xM2jdHrMnCmNJ3ZWU+IKJOlKSaSuHDKat07+btIkuGAYL4w6qJwPrADzRqJ6cy/PHEmoC8WVhbc6X4rTgtX5Nl5ZxkvLdGk4fsMwfxBprgdsyKRkIUM8nYVgX4fxXvX/1Y6vdaE6zzN/4k/8CX75l3+Zn//5n+dHP/oRv/qrv8of/+N/nL/8l//y8rpf/dVf5S/8hb/Ar/zKr/Bn/+yf5dd//de5ubnhl37pl/6bXvNljbCPNI+6sDrZYKdtWMRRVVldgiCjflBktbWiglav1bgyHD70SwTqskG4M8JYxUVVjUuxS7GztL+1oJETrvBe3VLwmXN7zUk95Y8JDPih8ioRFNGAryhHK1Y/uXWkyxUuRrjfSRHqnKZVFXlDigQCgBZYBuaZamdV1f+mGthrceyHsoiM3CBoTdEZ7EaWAg8UdUy1BSmbbE3sQosyfxAeXPGykRbN67ZR0mgWCyldiOPKs/8oiIhgSEyXsthyABAVsfDPLOOVJB+ZCHaIpKDo1tsj9vEkdl1BNuUSxGfSHDURqJF7XjnMRmv8ioSKIb1ZnBtEZ6DG9OoWgPL3JBVKC8JB+JupNQs1YCnaq8WUIq4mQWwV3dPWY+VHw7m4tVH3D6UV1HhTX5X70dAOeUFXi5HCInuZ806LHh+zCtf0AKVG+7UI5QnHsCJrgB7mhC/njbTX29tRBE/7GQzMm4BNhekyMG/8ck3D7cD4wZoaLVxDEYo1CyKXG8N4HYQ/7lTIkwsmi8gndo7xakXXeeycGW6CYGwmsP9uDxSZF4csLfSHiXkbFn5uOEF5V1j/ZCL1jrCTtvPpZaPFshw8qqNHcYb2TvnW1lK6QNgLWu/uZ/xhZv+Hthy/6Wl2UlyQCtN1LcIBq89EKoQ7t3BNjXKNkzcayVqeHBZlPsghiaUgNMuhyJBV2FTXpkrXsFEOxPNloThpL8e1upIkw+lFoH03ES8ahmsvrgWfDbiDqOm7u6jzVJwXTKopcJnx0pG1A2RTWXjcBeWharslaxhAOOSFBlNFo9kYkjo7lMbhD5pgNs2UYYScMd5TrMWMEX/KJC/eyRjhQmflgYZDWTohftA55MWTVR4cy3QVOL50HL4JcVuwo1nQaa+89uG6rn1FBXCQjcWO2mGIheYxLxQPnLzvdOmJGgxTue0LF72cn/G48rJWt5bTS8fwHNKq0Nwa+ncwXYj3adhLwexm8fVOQbmonTyf81rU/PWZStuknGUDTVZhZYEs91xQ/II7ynscV+cOotAFMuFioltNHA8t8W2HWUfMyS2dnPfjp298rQvVpmn41//6X/Prv/7r/NZv/RbX19f89b/+1/nlX/5lmuacUvHn/tyf49/+23/LP/pH/4h/9+/+HX/0j/5RfvM3f5OLi4v/ptd8WaO2LGsLe7wUEnmzE8V87CxFVf1LGhAs/qd2Fv6hcC6NIoVlQYmKRUUniHI0CkoqxYQgcSkoWtaq+joJYiuFkWPxqtTNyZ0KTm2thuee/tWkrdInbTgtDN1ciJcd7jDjTiLuKE0QOmAuEKy0/2PSytdJYVqUB5ay0ALmtCi/qSihImDFQLMXZCh2srhVlHeJSX0yasEjG6VSB2qcrIes3C1/LAtykJ2KBbRdGDurxT6qsDfKnzQ0dxGT/CJqGa4dw7Vh9bnkzfv9jLs9MH77kuwK/jBhR+H7lm1P2rSk3uMfR+xxJvdQEJGVHY3wddUuTGIltTgrwlUrRgrxXOkfqVD0elQes7xe0W+dL6kVDmS1L0utgXL20F0ifZUqIG1jLVLVxLsW88lWyFY6AFUQ4wZFvfuzrVSlcNQCJq+ttOMTyjtWZ4KnIhmQFmk6F6dCfzgX5ZLMIy13dxArqdQ6pbwYcifcv2ntSF7eDyDebOH1QT1SW2oggh/KWQTzJL8+9g46RfAKC/q6IEzPAmGXaO5GTDEcv9UwXkHYwep2pn03UrwkXzlnuPztB+LNmuIt4S7T3E3Eyw5K4fhhy7xVrup9Frsnrwk+2sYV9X1muGnwY5G4UW/Z/9wldz8fWH9amNYyZ+PaSzKbhi7YEUwv4pZwMPh9WZwqclCetj13gmrHQro+epg+lmWuzb0UtuKeoX6nkzwn9SBtMoQHsxyyTZR5Nm8hBwemEdS0SDGZG0fqnFIrogjqYib2rYjDqtCsSOdD5oaBph6kVWxq0Q5VYlZOZV0rqujPzeJvPK8dNkEzJRE45YJxFtqGEiNlt4eXz4hXoqD3R7HrKlduWRNrwVmpETWMwCZxSwnH82HOFPGorbzumsI2r+U7pW0WbufOYEdw6Ql1Zi/oZrGIEGuYmb+1kg6LuqFUi8OUz56zdX5PV2EBKcZrQ9wKyrn5sYizJFVMPawjGIR7CjIXUo1DvcyUULAnC17tp0YnRaqVA50bjKxpTVlQh9zAeKOUjF74rGS5V2l2HPcd6bahee2YnoPNZuG7fx1GKZZ8FhN8ab/j/ZDxtS5UAT766CP+wT/4B/+3r/uFX/gFfuEXfuG/+zVfxpi2jtjZZeOrCtV5Yxm9Cnd08fRqAyPxmZAVgLQzdG9nIdRfym2rdlHAQvBfREdZ/VJ1wW72usE10ppsD2lJu8kVGdNITTcW/JiJvWP2wk9rOieonxaPVf1fUVijyKCkIxXhn3ovRWgU8/QFTZ1rHqeuTMjndQ9HwmVH9oF5IxWNCDV001FeYEV4qgo4L+jbOVqzIr8ipEFdBKSFVgrYUphXZokXTUH5krqxiCAoE/aAFW7bvDb0bxNjcIS7ke6tZLHWfzPJcXpp6d/OTBtPh7zPdNNip8zqflwOF3YU1MZkpED3DhrxogVU6SyHl8WWyRuaU14Su6ozgviwakFfhWhRxHemIKlMWiD6oRCdfF7Jci9LWpXMgbLEvpokvxOlUBjlc9b41uq0IPzS6lMJ2GoNpvzXAuFxFhN0dawo1qgw6tyqrQcfr3PYq+JdRDv5HBeJeHOWqkavnFgn3L8SrLy2cSJetMJrDSdp1wPk3qutjqDLS8oXLMhbfS5NkaKmGFWrD8KdzcGoiAamRpC+zSfCu+5dYfNfIv7uBCGQTRZ6wMUa/7Aj9wKRxt4xXTai0LYQN06N/CWhKByydkWkQGgeE3ElvNXjB4K6uteR8coTO/HvvPzPidhJK3XeiEDJDUodmIWDmlrw2dDsyiJ8K3WumVpcnVPCanvXVb9iJxemujbYJAhfcYgdlXaJBCnLrD4zi7gnHDNX/8cMxjDcSBt8upB7Fg6yHkwXYtHlhyTPyqAdl5t28Ut1g9KiYInijb3VIA6liJSCqYKdRzm9ZQtJRV3FSqJZ2CdMNuLEMKUllKTkosjqgGkaaFQU2zt8FkS1vZdOk1O0c7FXSmKqb5RP3twNuMeJ8uKK/nWkf1UYXohwStBymNZFopx9oXln6N6pa8uIquzlUAjyXdu7SPMwinVa75bueGpZvKHNWDC24CKLoFQOnUZ4ptbQ3hq6NxD2hmkrLgBWi9vcQglAUXeAlRSp8TLBOsGoa1arkTAqeiqzxT0K9zoHoQelXgpbkhSvRkNr7KSUJV9gcJgfNvgiVK8pWtzJLjSs9+Onb3ztC9U/6MNYQ9dqSkxfldv8nratLAR2BnNU9BSWQjMFRbOcITyItU3q7OJjWf9ffKTkv00rregchNvpJuWs5rIUFqm3SrBX1KOwKMujIm+bT5JEN24d/ZtJCsNWOAduSIvHY0VTcuuwxkDbwGmU1r/SCgRdVYl4TspRhUUFlKWl3r0FUFGVFi9VvY52Q+tYBGgtqjY2X2hJGoRf2dyLGrYic3ElLbFqrxRXhtQV0iT3aNpK6ku1YSkWhuduERaVVUd7nxieWZJnsYlp74Wz2A6G6apZTMkpGXO7g5QxOWO6jny9FR/NgnDXOi2eCmQvnCw3Vy6aWiyp0KQiVVCRnLy08+uckmKLxYcy7DNxZZk2gmw1hyy+ukY/fxKkufR6bT3MQZT6FEGexUdRE876wuGZo/vdxHjp8DX9R++TP2WaR9m0UudU4KXFs86b6kAAqLOA2iFN+YkFlaDbfsiLtVHNhCdVyzI1+k8ZM0u0buz9wnXGgD8kobGAeKoGS1zLEhi1lWmn82ZehWIkdcQwZflZf8zY2TNtrUTcRvX73TaMN43GXM6YYpZnhbah9A3p2Zr5IuCmDBqmMV14oaB44UX7oZCrZZOR9aJ7F/FH4UEfPzBgDN1tZt5YhmuLP6rHZVBD+1FM2VOv6N6A+KpurFrg5aUgn7YWM4tHc/UgDQc5zFUkq4pplkOiPvei/BeLPVGGJ+LKyWGll+Kne1c4fFOFYEaK2+lCimijns8g92q8UuFONhSNBq5KfJOFY908RHIQ+oWd1bN0rQVWtW0LgJNiP/ZKr6kH2eq3+6TjkEPB3x7lQH0a9SANZRzlwL1dk55vF84pps5r4f/X4JBZ7bKcWsBFPciuf+eAOU40tyvixhOOmbTPco8aGG+EQ+qPUuyuPhUv3OxrV6gwr9yS+tS/TUJn6oQ3XbsCi0OCQSzA1CoOZC1xc1EHBOjuCjbZxXpqXguXt1pBVSpHTb8r6yIt+q5g1nKCdg9uAQ1sSBgDZbTYvcNOhukik7sCfcL0SQ6Hg6NE2bQkRU+obyUa3J0l7MSRZd6Kt2qlYn1dRsKQfm8b70v4He+HjPeF6pc8rDE0l40Q2Sst0yItqToPjRDYg2a6z41sQtKelZekYHDeEDd+iQIEeJrFHjVW0x+0zdvI76nKaJPlFF4tiOwkXDWXi/C5FB1tHhOUQg6e2FrCUTzusjPS2h9FrGKMkSi/LohatybvgLT+nUVUPPJ9SqkK3CKvzXlpxVIEuXCPA6b18DycCxttMVLbhhXta86t7uLEc0/i+s5I3tnHFC1ktHDJKpRSHl1diGtRUy2PclMXf0N7LwhoexelYJoibnLCQ52Fy+sPkd3PtYDDnTKnDzxhX+g/T0zfuiCc5L3MMGNSwqQEMVEaj52TCBy8XdC+heenBavJZuHpLrxPtXQ5F8W6sanHpH/KEdV2bnV6qA4Ji6tCwzkSU2r5RcXtRm3JO6AxHL5jKFEEd1W4192diGvPdBHASCEBGkWriGtSioHNUvDa2agdVdYkosoVzuS1bIJuSHKdjdpA5UL2VqyZZikSjNpNud0ohyDqNSmEOylSFypCgdOHnVA6sqA9FCnevT6HVSVdrxMISpZ6x7z1i2fl6Zml2YloafedXtLFLJhjw2oUayIDpIue+abDHSJ+H5kvgzhSKL0EnnREKspcJGEoe/FrrQl288awepVp75JElgZD8dKS799MzBtPwZF9Yb4Qf9Dt7xayFwFTdxtFvFmDN/CLA0iljlS3AYqsXbWVHNuz/+hCBZkzbhJBkk0Gnwurqmzv7OJmkjqwyQh1QulOUtxmki+cPgjMW/nufe/oXxeK7WgouIcTze1IuIfxeSdm/k4Q7XDIrF5F5o2g6OFQNJTAUga5j1ZFe6m1S3dIilXpXkmBWzCPBxhHWWuslcK1dbBZKdUoQ87MF4Go6VnV+zZ7s6y7dhaPiUqnSq3F2V5pC1ktrCT1a/czglxOm0zzzrL5MXS3Mtf9qSzPLrqGSTCLfN7ixTFA7qVZwAmh2+ja4b5IcxAqhUZiR1lLx2vDeK1dDlsw0WAa/fcW4jqLRZQF10dCPzM+thpbXKTdf3JwdLjJkNvC/CKCL4TVTL8aaXximAKjD6Rjhxusrk1iSxYeobuTOdfeJeatY/UKnM3kiye8uPfjp2q8L1S/giHqU0WOylk9axDUqnpWThuFAEvdrLSIU+BRPD6dKLGLFJkooli5mlVJmRsVMXQSh1fFMNNW+FLBQHeSTXTurfpYPonMrJ6eThC58DjixoR/9UgJDnNSa6m2wU2R3DeLir8ER+48br2i7I+CJlqPWXWCVFgDRshjJSbZDAxwOEqy1QdXi6CnFtw2Gvzi2wpON9jzdVLrpifoXHUmcKMUxEa9DKsoY2zl+lb/zdpeq5Y44uNq1JO1LOr69m0kN5b9t1v8CVxMCrYVHn+mpb2PxK4QN1ZNxyE3luHjLf6HJ+zjQAme4sRblQJmmDDqhFC81WxyiRP0XkzSK5dNuHNq0aTiiEonWSgZFko5o2GVt0cGW1g+rxvPCVhZTdXdqK9vpE1aVKxS04naY+L4DQOu0H2WWH02kRuPP0Tcw4CdGsLdsBxg4totiJDcH4OZy1I81MhFO5mlcDJJzL+LkyIkPM76c2LBk1aivK9FdDFGXNFiltZ/4wRdBZp7MVnPfVgOh180ibe4URDn9l59g3u3eGJWNbvk0EMM4iWanV0OStNW2tcL+jhD3nTMzy32NJPbnuK9ZMpvJSYs9pqJbhTxymrmb+q8N5iVpb3L+EEELsKRrchiWQRq/qjCuUlQvml7Fglufpy5/t+PGOM4fdgtc8gNknwn9IZCKXLIzdZ+wZpqORDqoQmEouSPaaFjmFQwyu00c6IET3gQS6940TBeepo7idv0xyJ+0Yry14PJdBO0JS32Zf3rKHZl1pD7gJmzdGwG8SYOjxP5w57mQd0NThUll1YzSgcopiyJWHUC1E6CgAQ1bjpLOMlpoMySSmaaALNw7MWuLIurxxiZbtqFlz33aoGntnJVWOhnPfQ0lof/xzO6txGsFXGVkXkzPJeWtzUZoti4AZyeO+1IyFyZLuq1Vm/bg3S0UuMWHcS8kQOBnWU+2ekJv7goTUtR8NwYprXM5eG5zq+mUPoEoWAfpDwoTcFuZtrVjPMywUOIHI8tZbbgFBV97bGjrCWpF3spu4q03cymH9m2A3NyzMnhm0ReRcyuESFrKjSPhv5t1jACEd5lL3sYFojvEcaf1vG+UP0KholF+DcB5k1V1IJTQUqpXFSgqlGr6t4AVa2Zs8HasghKalZ9UpXrkm9vOZP6T0/+rGlGKVRLFLd4c9aWHkW4sxRLex8FyR1EBJVag2sCZqdm/U0jsZCA8ZfiBzpGSXLpAvmix7gXmPu9IBQVvSkgMnMw3rNErpYC80zuJFFo8SY1Wrg8MW/HQjiwFGnhKAjYvBHBaTjqtVDBjiC/0p62YxIzd1eYNhoLqfn0Vakb9lKw5lZ4XDaK72qNTsyNUyQQmtsZP0BuPKGF9u1MaDPzNtC9nYV3eUg0b44SkegsadOKYEOvH7HyVD2l60mtw59EUp9WTiNGtSjL4sUKYIuBqEWdrYVMnXmCsET1WJXNqiz32Q1iqF4pBtUdItW4wwhGi1dbubtZ3QgS2MdE+2aCaHDjCfcwiV/sqhWroakQNw30jmaXFgGKmQWNMkUQr+wNrRrmx87oxi4CP3/M0kJPqKuFVd9aQ6HgBrH7SStL7rTw1/lCimTXEq/EbzQ8ztiTPCR14668ZHtSk3kDxlQ+5RnhtFNR5NUs/N/U1cOQot5TptnJNZfrZHj8mRY3tviTtNljJ4VBOKovphG0MoWzeb6JRYVocheHZ14OnV6K6tMLKbJEHe5pdgl2sP+mFwGeKWoxBv0roe/M1z3+GFl9OpAbK9SNxi6Rom7IOCO0gWanHFxnSLN+z3RuvdosB6TYSYveRvGCxVnyusWeJBDDDJF0KXPBxEL/eqSQOX6z164Q4AzN/Sy84L2TMIHR6A3SQ716tqVNi90N0HiZE1lQ/HBUH9EpYbLTwBOLOxWanTz/dpJ0wHQdNFZafXg79c31hXAfKTlLp6ht5SExRjo/KUMVnjojh6Ak60MVGYorxHndzwFysIzPLXEtf86hWazyJFRFX9eAO1j83mCiYdoU+rdF2/F2QdGD7h3hkMnekhrLvHbMW8t4IetROLCI3fxQu2tG7anykqbnxgKb2kmC3GfKKokoKlryZcT4TNvPbNYDMVu8y+RsGIaG+NjAJFG7zZ2luS8aDS5m/diC8wnnxGbq3X7NMAZxKJkt4Z2jeSuJac0DtHe1qAeTDOONJ/UQN1AuC4TC12WIg9qXWzjnr8/X/R8+3heqX8EQLqEmmJfKc6sbv77IsFj/aO21tF+XFpW2BOtwoxRs2ZuzAX6uCKSib5ViYFAeGbCqbTyx4akWWWTwY15smXKw+ClTrKOQ8Qcpslh1UqRWb1SnMaDqf2imGZeyEPyv1jhr4fWttLmV0iDVhH4Z5+SpLLIxuMOs9AMRBCQl/meEb1WvQ23NVkU7Kl5KrWFGBGRis2RwRjaYkiT/204Zb1Tdqkb2FDi+tGw+SQvHVTby6sUK/StBROyc6V8l8ZecE8V45o0nHHRDXBlWnw+4h4HSehgnyZankJ9dyD0dZ2kr6pwwRYrd4iz+FBVVdBSkPVqdFqwWqbX9X7wcVNwg6LFJhbh+ko6AWUR6YmouPEQbRVhXxUSpUYRf506Ngqz8QZNlkzx86An7yPN/v4O2IftCeL2HYaL0LSXNirQVhhfiLWoPUhgZYwmj0hW0HSzOEWcxVjX5lyjaci7QNfkJKxxWd4q4/YT1jtx04m96nHFvd+A9w/duFp5p6sV+aL4St5DUSyFsorZFJ7muYrwuAptiIZykUKgOBnYW3p/R4r69FUsxmzLN2xE7JIZvrYkroTqEg4jybNTOxCHhT4K6rT6PWmAIutbspLjNKzm1ukmTkqLQSvpYKUEqRCmZ7jaSOkdUrrnfJ/yQ8SfPvDI0+8x4LX6dl//xRAlCHWpe7fHDxPTxNbGXApcMPkbGNiyCPUFvzSKoAhXYNTL/SizYHbjTTPUpy43HxISJksg23Xh53k5yT9uHxHgFzYPwtZu7gdy1UArTJTR38qz5gzxr2Rq91wO5b5ivtNibhNKTgqCE80Xg9MIzPJN2eXGGXArulAh3g4Y1GGLxi1+u+MEKT3a+bAgv1oRxFm79nCgpiZNK3wmdqRT83Qn77gF31RL7VgrB9mzrF3Zl6W6kTlKWihUnFUnc0oK2iOtB6gp+p4fJpDStWFi9mhek9PS80rXQIAsYr71GBcshOjecOeQaaiDhBpl57RY+v4h6WfxTx2uYrzKlyxhfIBna9SjdlGJo25k5Oo6nFhKUbCnvGuxkKL10fbp3hfYuMzyzjDeAk0I1jp40OY4G8ZxNFgYJmFh/YuV6PBjaBzmkzRtzdprwBn/Qgj44cn5frvy0jvd3/isYEk8nq1hty8d8Fr6AFqRPilZBtAq2sBQjRhHUJdNdBSHV1/Fptnp20uKtG0zs7JnbqL+jpgeZIvzT9pClTV4KqfGMVw43ah5zkpZ03ARszLj9LJvYu0dMjBTbYh+P5Iue0nrMMImqNlimD7a4bYv/yTs4Dpy5rIpWGHv+3qVgHw640yUNhulCSHJVhFOUCluvVTW0rt/Hxic0AG9IF1KEdnfyAx69Xkp3Coez3VFBWmM1RccNhWaXON04Ym/o3ia1pLE09xMmFdppxt7tSR9ccvqgpbmLgqw9zNgxa2s/UppAWUmhUaoQKKiJ9TRTmo6y6aRoVl4lBdwxQi8ejm4UT9Ec7LJJ6/QQXqXSgStK6WMVJum1aLXQM7JZJosK7qQwdBOUylXVdmHzxHbKD5nUoxw7A12DfRxg21G6VgR0KeHf7uFwojy/Uh9a4VA2DwkbM3HlFj6w0Y7sdGFoHuthKp1FY46ljS9FrHz36t05vlxjYyLsBLlO64bxj3xAbCX9CPTAZyWesugDN68s88ouqGXzGMW7Vp+nSnmxc6G9i8xrq+ibob1NNHeZsI8imKFQKMSVZ3reM9xIuEMxekBoLHGF2nyJBVIV9ExbK1GcXgr0s5MGy7Madhk3yefcfdsKJ3OnB96pCKfTaTzrpSdrPopN5/XHjRmDZV45DIZ4vYLcsf9YXty/jkKHuRIRoZ21ACxCMSh6sM2NIeVCE0UCGTtVfLtOivCD2joNM6XxuCGT+sLwPNC/NRKcMBa2Pzhhj6PYtZVCfOYJx8Ll96Vwau+kuJ+3djGnz6uGeRMwKRN7j9XrU1PcpgsvB0c94BcnjRuDoTQOM0ZpayHXOlaP2FnoQNlYSttQNj3mfkeZZ3AW07WU7VoOiUPEHAbK8YQb0yIieupaUe9f3FqKrc4VBX86r/VL3O9o6AZNAnSw/iTRPuq6YQxR56mbWEINMDBeuaUtPl5BaiXp0O+VwjRXioB0q9yoAshG7uF0YTl+YBmfFeZtgYsZ3yXS7GhWE+t+5DC0TCfP42mNHeQ+l8lCn3B7mSebH0H/Kp2fsYvC/CxjtrMwvHymZIPzmTxbOHjco8UfDP2rWUEWLyETFrp3mXBMHL4R1NFEXBC67PnoK7CS/P2O/BXYU33Z7/8HabwvVL+CsXqVWH8qRH8R/IhKVHwsz+3FRbmvhdhTJDUjC1QVMphFcCJZyhKrBzVCtBZyVSyTgxE7prngRjWnP0iyTm4Mw40nBfB7bSlPGRPEwgVXSE4Sduys7cre446R8OjBWsw4LdZK8aLFtl7bY1lA3QJ07WL7UhW1qG/ngs5aC97j1ZPVRjEBr9fpqbelqM81CUmthOrG4TQnfl7JwhxXohbPc8Hlc5EkXoyCCsSVXL/Tc4MfhC9lBin2m520alPX0t4lTh8IJOKPgf7hiJ0E3Qq7GbcfKY2jBC+c09YzPevw+1n5j154qPdihJq3PaXxpFZMu4u3hMeZ9mHAnEbMdY/ZdnJPVERUamqVNcrBPc8b2aRkU4q9XWJzpd0oG7RNVUBVOWtn8YxV9zAoGP1zs0vElVp0vUqsPhlwbx7hOIjLQ3CYYSZdrDBuwA4TxER7O4u1VKOI5lrQrKxm5NWb0x+l/WwytLcjsfdaoGoRNiNF8BBJq0DxjhgscWUxyTKvpHAfr7xw3owiMxRFaAVBlpMfi+NAtTkK+7gc+mzM+IO8Jq4sJGkhmweZs+0bQSYpMF4HKHB6IR6ZFKGHFM4ilnmlc0sRfzcoShyk+1FdEsZQ+dDyaNSuiqCxhtMzx3gFq1fVX9VyehmW1KjYQfaWhrL4aMbWsP5slqQub5gupVAMD2XhCYN8z+NLR+rVQ1mFi7mmK6HdmlYPLcpjDntBYnNrSXMm3EXSuoG2x8SMexzoTjNu6EidIzxMy4Eqr1rcfsAcRtypwe8DNsr6sv7JyHzZLIh/3MpzYWJm3njGS093lxaKUGqdoNHV/k+L1cobnS8a7CCvtWNifu4E6R9kbZwaR7PLzJctcRPofuywr++ha0nPNsTrFc27E6RMmSYJAKAsh+fcyCHXaaKarKGQerPEU4v37dlSLjeG9rHgDxIrevGDeTk4LcJXdfxY9ggLpyurnNVCXIsC3+/Fvqm6GIRjVocL+T12EgBiuPaM14bhGcwvIqXP+E54pLkYihfe2f7QMQ8BXMHMhr4bSXctczaUUUIZ/FGEYHEtn3PewPG7EX81sV6PHB870kOgjI7ZCVJrB4s7ygFZronsGeEoz4o/Jenm1aSrtYgESw+tf1+u/LSO93f+KxixN3TvZrq7tOTYZ29kU6jecBaSPpzFsUReVrPsWqAZpQjE3mJ9Wex3aooRcFZ1yr6Jn4RTRzm3WgHKUWkDikhgDHHt1JBaEbTOklWZb5XXVZxkbZtUyDcbzCCSV3OaMfsBl7O080sB9YmtCAEpU5JAPSKiskvbvv4704R7/SAChrIBBC0R5buQKIqir2dIWm2KVIDlhqI+pGfkGFXvLy1Mvd7+IObkqJVQPUCMV5buXVra5VhZXFOnlkSpCPd4uyJtO0EvjBSPxTtMTKLIXYt9jInSHjZTBC/t0QLkzoM1TDeNxKsajWGcIwSPvzvhjpHSehEoWUPWqElRTWvhOQnaaw3CfTaaEAWLK8AiHNM5UcMj6ver/qiSiS6hFM1O0LbhmaP/fGLzw1HEdMMIfSeHjVQkbevxgLl9pMQE1hAe1pTGE+4GLTbOLX6rvFO5fyzIU1yHhf+YnUSxmjnhHk56DfyS9iPqZgNGNsvxUugK4VDUBcPg1dpmvDLsvyWIWjhK0T9eWUw0FBc03UiKvWqzVUyhNIbZGcmVnwrzVUfsLXElBwET5XfZJFZRNgrimXqJrYydzNHcQA5SqLz4306ktefhZ9slA92NZfEuzV6eC5PkIOY1XtOfNFJzYwWVniUNSXxIa5gHGFcWRDgFw/Bxjz+Jg8ASnvBwYv0TR3YWP0TGqzXTpQjTyoR+X6URqTI+qzPAvILpCtafGtr7qNxjmX/TZUPqJPiisYqoa+KTf7unbDrmqw7/oLx1K2tEuD1idydWzpO3PTMSD4oRfqfQXzJ2tsLLVbpTbA2HbzZK82CxbSv+nFg33AT8ydK8G0jrRiOtNca3iNtDdobSShITbUP54Ia4bYmXLf4gvHszJ+wcKc+uZH3Kcn9Nhv5O42qdYV4plcay+A67UdOkks4JLdZSa5RXWqN1BamuFJ1Z7ajIGj27kiI1XSXMKsLJ4QYrNK4TtA+JsI+kxi0CrGYntmT7jw3Dh5myTqyuTlyuTqzbiTlbDlODAR7ebEj7IOLEdcT5RPzxCqIhZCkicytip9PzcyE9XgPRUk6e05tAeBUIKu6drpRWpHQ0N8G89kwXdkGJc5D95wwusFCy2ndnL+Cvw8gY8pdsH/Vlv/8fpPG+UP0KRg6Wx+91Yrz/IAuVHzMzGvNnq03QGVUVhFX5nEaNtkdZbIplOXUWTQmpfNcqNKKc21+LaXwpzJ0sAjVtyM528bss5kluvPJFK/dVKATnRSkHMSsvtsONETMX/OMR7h6xz28wOcMwwXZF2nRSqMb0hM+aFUE1Z55mRVRjgv2R8uxyUSe7Rrxjpwur/DMp1iuCgJNTuYjL5HsvSTxqV7Uo4JXbCZUuoJxD9REUJbgWrMHRPKogS7+3COIMq88mwuO0FI7zxmHXjla/j5njcv/tLJxK5girDjNHShtIq4a48dgx0rwdaX58S+mCuCgMo3CBU8bsTxIj2DjKzRo7W1Ljlo1c+LxOFeSiIC7eLcVoFaF5FdPVxC7Q9m1B22+KAE3io+n3CTtlhheO9Y9PbP/jI2XVYw4n6FrKqiVe90jVkHGvThBEBZguOhFrBUcOlsO3HcU4UfpX0VeReyCRsUbpB+r1mIrQBAaLcZbcB+E9t27Jb6+RoFFRLD8UkirqcxBRXLMTS53pBcuBbrww8JkcaKbncP8Nz8V/SoRdZnzuMFEKAjtL0T5rUMH687SYpc+9JbdgraCo/iinofHC4tVaKlvdcEMhbTL9Z4b2Fg7f7jl8Ww6nmx8Jgpm9bE4mFQhyXaYqoBkyzaN6I3swMeNntSXTMIDUQndbwBSGK6dFcaF5EDQ1tZbubqZ5tYc2YKZI88kDDCPp5eVCGc9LgSUHIEAtwWQdKB7mC5l0p+cGO3n8YCm2Yf2fHuh+/MD04Yb5IjB82GsnBzZvj5jHA6Vx2DFgp0jxjrztGJ+1dP/xM+zjCa4vsAVaMnndQi6k1sOcCZ8+4LuGeLMSQaSRzzOtFUlVhN4UOaxZWzg9V0/iMVNarzGsmf5VZHjeyhzKiGWV2jnFbYOdPPjq7CCUC38YKF1Lulkzb8NiudXeF7r79MRuTDQJbpL3dpPMQ6cHx2bWwAhNAWxvZ6YLr5Zb2r3xkJ+IreateOLGTYLLSLsZSZOHu4b2TiwO24dEcyeC1OnSElspYA8fek4vYXiZMVcT6+3I1frIdXfiMAdOU8Puky3hweLfNphVofmZA8NjyzQ7XDDgIfVJ/YYNHCtIIHtQ8wDuZLGpIez0HgRZN7tbeV3slfrWSRei2RXa+7TY2GXtFGVlRdkIJJn3Xycf1ffjqx3vC9WvYDQPIowZL6zyxWSDrKfI2qYCWHxROReITxXvtQ2YPRT1X/QDoNSAGqdZ40VNVq4ZLKrm1Mqi5qqvYBYeKq4sEYPNXgpJ6wSFjZ2gjE65T6ZoKIB1NDvD6pOB0nj48BnlYo05DNj9EXZH3BQVLU0Sn1oyJtul7V/aAFmtYSq6ag3mMOBiwq47SJnxRSfXooYlFG3dK/o8bY2ezs9xkaZemoL6KMpGZtVYvxqqm1hA88BLPt+PanJvRimm3JAZL72gKDGpxY9juPGM1472LuGPAulU2x87ydnYnSJl3ZFajztmhg974srTfXbA3Z+Il520FacZM06kLuDe3X+hmDelEE4j5WINm1bQ2LpfGIMbxTJo8VhUde9CBYkSywpSwFaeXuVIm/Kk7evBZEEJ3bHQ//gkCUHGwmmAKAVgsWJg7vezfBZti9u7Pem64/CzHWSLO4lv7Kw2bE9V9VnTssJR7Gn8Pi6isdQ5Uap3TsVOTmkYFXkGOnmm7CzFZW2Hy/8kIaj7zGE+kOswr85tVf9o6D7P+FPh9EIsrPK2cHpZKNnQvyoYI4bkqbVfmFvFCFpFAX+MpMbTaHJQag3jMygu078ylHeW9Wdi4D48M5CgOZzRvPnKihVPriuAJjmdhDueg6i/w1FEXAYk614Pqc2jCO7CLtO5amhvePifelIH3dvCdN1gp5Vc/97SfPoIl2vyqllssio/ufIGY2cWwWWzL4wXYiEVdpyT3Rop7DfjSDHimdb/7gPpakXsGokGnjMEjz2K6M4MM5wGbF5hLxrKzQUlNGJ1dRrxMRG9X0z1i3E0rcc+HPDKOc7BLBHItZjJQZ1QAsze0N7L2jg888wbt3jADs9FWCc2T3pPY14sn9xJ2uDuFLGjCEHTpoOLnthbTs+cFmGZ5rEsPHA7C8KdWllz159GnZtZLfLE9YIiYQThIII4Y84AgkkFayU8YF4Lglktn5qrke32xGlsmO4buntBZNuHRDgm5guvlAiZO3MvYqvYF9gknj3bselG9mPLZ7st8+SZP13R/E6LP4pNVTGG421PzmZJ+kqN0AzcqaZKKce9gdXnZYlvJRumrRTqlBo2IV0HifQuNEdxNehfjfhjYv/tFfNa5n1NHsvBYGY5fDZP9RVfg5GKIX3Jqv8v+/3/II33hepXMayh2RfiSvmUppxRVF3oixPlaSXjL8OwPKCLyfuTVJVaqPkj50Vb4w7rhlPR1dQY0qq2hKXotFM+n2aD0fZiVqTCYDPkBGg7LQVAfU2Nbmpx5RhetMw/00sG9Vwwl4GmFOy7R3jcUYvPxS0gavFaC8bL9ZLcJL/QwjRhKBA87uQIu8i8biimgBYZIk4q56K8VZ6lcr2WYqgmGKmfZ3VBqPxAN0NWIVb2wi/LikbKAgvrT5Na+yhS3QpyGLdhaUObSydtz6HQ3rLwM+0kfFSmTL5oSKueEoTO4HYj9n6PnyYomdy3pKsV9jCSnm2w73YiJkpJXBceD5jDiWAMrHvKuidvO+F0qgl99Ri1vs61rBxQoUuID6gglwVN9lGFfDgUbBJD8nljiCvH6scn/Cf35NZTSsJcrGQjaoNway8N4c2MfThSjidKKaSPbtj9L5eM1w43wOYuMm8d81Y2oEbV0RUNTJ2gePNKCoBUzsIw9M/1ORDLLPm8xlTzeSl05ZBmF5P003NJbZKDhra9ZynA6v03UdOhlIowrw3hAUoRxKxyx+eNIezLUjj2+8K0lQIldg02Ffo3M8cPgvBt74smDUEpBTsmUuNo76SwjCvhsNYI0HmlojZjKKHQf55ZfTYvbhaLmfuNV3GdcDArJ7v/fCQ8Tvhjq9GUidM3Gg7XVulCjuEbPak1dG8mpu8+F7GRU+FczjKPC/o9C24Wr9PUWIq15Bdqy/YgFIfuLqmhvKVcbhlvWtyYZW6NEWiEbjBorLJz4ngxSOJTDQyYPthgrnu6Tx6F1rJuiSvHpMEIYZ/luTiJV6twMP1iblEPoRWlJwqdJSrgn4KhS0V554X2LslzBZgpiTtDMULTsZbcSafDDprwtgrkVgrYeSs8zfZBaEyxt0uiV7WrokDzIH6n4fYkB0J1XTAJ/JTIjWG89swrh5vLcu1NhnkN400h9dphu55pL0dW3cQ4BYbbjvZzR3vPEgowr504GijVqUYDx1UhXmW6i4EXmz2Gwief3TCfAubo6H9kCXvtyKEpbwdL2RTcUdT5EgsL4cGqG4jMa1HsZxW+aqF+hdI6xC7LxkrFkb0q7KC9m2nenkgXndDNrHxmO6uYUOlBYV+Yr8+Urffjp2+8v/VfwfCHRPtuxp0sp+ee6dJqAVXwg+Y4a/KQjWUpuGrMXwrq9ajih9hbXCxnxGMlKnUxvHbEVopMypmHWRN27Mgiboq9wXiNUU1qHXMnC3ZceaF0lkJIkslsk9ikmCSFTThqtOiNZboIgvb20gJtdoa86bC7kwio2iAtfTi3+rX9b/ZHKcKMYbGpyhmsoyRJvpqvusXz0w+ZuHbETk70zV6uHxbm3ixt+tixLPo51JhXKXRq29vqSd1YQcai+iLmgPiTKtczNTBdOvxReITj1rL/lqI/5cxBnI1G1nYwb1pBeAuEh4L/0Z5yvZWW6I1dUmPmq0C6uaJ7NVJCIF+scHOBtpPrsFnB/iRcvpgUWVWT3ccDJkZsSpSrtSC4GqcKcq0WizP1naxeqhICYUlrQS2mC1Fbh4NwQuNG/BnbuxH/7iiHpClx+t6K5vXA4/+yJq8dq/8y0P3uAf9qDykRv33N9OEF8aoHZAN0Y+H4oeTZu5MgtcUa7FgoQROKlMeHHqpAPHxNsBL52yoiE54U2UZV7VPBj0KryU7z0Iuo1VNjF39Lq6bhWc3ws/LmipP2fuV121GR91lsfipaNq+F6xr2jsr5rhGw88bgRiO+pzPYY6Z9KEwb5Ss65YA3grSOl4bVZ4bpAsZnkK2UCO5ROOZuyqw/S/j9LLQO5RBnL9cprqxEn+ZCmaF5zDSvD9gpMd10jNeeHDyHnzHYm0jaN6ISf2ZlnvuW/s1MczeTek97n3AnKzzbVPBHCVqwUxZu8SowYrETdO8Egu/uJD53/7Gluc+4sZXnL2XIBX8/0Hee2DvwjtI2mN0Ba43QYKwlXvRMV0EOkcppzxcd07Oe6ULoK24shL0ILIkJumbhW4fjOQK3eSzKBVZRm5PrahOESeydTJY11CRwpyJhEgVxFT8wr8MAAQAASURBVFCP3rCrcdEeWyKz8m7tLDZY88ZpZ8eQvWXeCJc0ncqZJqViq6wBJ6dv9rpOCbc5tobxpsYbVxqXzOvxwnD6AOaNRm5fJdrLka6J7Hcd8RhofxjY/qAsB7esUdu1W2dSYd46hmcwvUz454LEzrPDHizl007iUwvU4Ji4Mczfikp9kv+lbChNIbWF5t7QvZVr3DzKIUuebUtaAbkwPStLJKqsGSAFrIrJhoKdIs2P75meb4gXzcKfx0lnrDhZz82oAIuGInxdxnvV/1c73heqX8HIwZJ6L+2pWfw9Y4skqGiajD+xtLBtOnsoom2QKpqKvTm3x/0ZWRKbDxFa2GSE3xTkZSZD8kLAb3aCKhZ0AVfTa/copt2xd2Rv8UOSKFak3WmiJc+yKI9XZvHvW3xds2zsYZ8J+0SxGgM6R7F5SZpAdThCE85cVIVDzHGAJlCuNpidFq5JBDkl2EUgId6amebeUKqVTqwBCFI8C7rFoi6u/oZRFbjhUM4Iqy7wNhWy0QNBgqiwduykchGnAbW9UvQ7ri3HD1v6WynABaGB0weW8doIarczNPeZ1f1A2fTkdUt4nPGV91ogdh2EQrkMjN8J+GMiZUF37HEifuMC0prmh7fC/YXFmBwSDJMgpsaCd6TOS6qSUhqEZ1jExzV4RRtlIzOtBFAIAm+l7WcdNspcC/cT/nYSo/VhJH50Q/EeppnNb7/D4HCPI2x6EZYB5jARWyng/UGSnvwEp+dhsV86fWBwJ0P3TpXtet/qIaI4+VmM8H8lKatGxbIgo5V/u9AbcsFoxGo97DUPekhT1TRoi9vIIdFN+rlhCcCoQjwRD0oB1OwyxTlSJ3OpipIkzU0QMPHTtOq9a1QNztImHT6EeJ2I34zYHwphtqZTgaQSuZGFArD/jqO5Wym/XTxYT88d00a6JyYWuvtzW/nwsxf4YxbvzZeOw3fEv3T7/3KYOXF6aRmeWewAxRbcSYIwDLJG1I4MRb1qR431nSGug34OmS/b3x1pbyPxOz3NIxRvmVew/cmIf3vAHAbyzQZ/P0JuyZtW3Bgm4V2zXVG6hrT2nJ45Vp8OdJ8cpXjdtpyeCdXDnwrdnXRg4ibg0+aceFapSIBZfIYrMijrp5vkf3JIRX1rDc1OVPkG4b/7oyQ9hccJf3cUDvm6URQ1YqKVUBNTKE4ODoJYyjVr9lmEQAEohe5dpn8TcafI6UPRKNhUGC88w7VlXj8Rdnqhafhj4fTMis3TWulhHmgy8RB4fNdjHy2bTy2rz8TpYmp1zjRSpMZOClYoHL9ZGF5m3MVM08883q15+PQG/9pje0gvIu1PPGEnB7fpWSbfRMrs6EJkmjz2aMirQrODm/89svo8MjxvmLaW5lFoH8MHimAXmcM1rMVNcko+fkOQ1O5dYvXpCDExffOC8UUnNlsNS5SwuCjId8oBxs5gL55w4t6Pn7rxvlD9CkbqxEZn2mg6yKj/oPwdPyjalVmSb8Taxiwq0nriTE1V9pbFYskPmXmlrWc1sbauLKbdRWM83WRks62bfnP+dzuffTjDw0gJToszQ9jPDM87UpANWKx1DGY6c8JyK+8tqEyUIvjhCF0D/Y2gWyFQxgmzP0jLz7mlpYoRhMXc76BrJeHmMEirMEs7zY15saARvlzWduQ5Rai23GyUDSu1UggtgrNUfVMlgUciUs9UjKqylvuDbgCAqsYxLHy9We2a3CScz/ZBNonmXn5vXIkSNvYWm7d0n480r/e4Ir8nXa9gTnQ/vMcUQwkO393oNbWUMSoH1ZDW/iyuq0K3LIu3mSPpsofGYo8jbmcxvWe8bjDWEB4j7jDhdifmDy6ZNuJNaedCkwrHDzy7n5PEq/ZOCq/+TRE7LcC/2mHuHsFK+lP/ox1ZC153d6Jcrhg/7HGHBrcL2ONM+3bGlkfc3ZHp29ecPhJFuZsE6fajUA7iGihmEcDUToPEP2YJPDByOBDazBkhd5N4fGLKchixSQRKqRf0P23AHo1Ed56KUAPQA8945mTWLPSzx6Xcf38qpF4OKXbOtHcipBuvFQEtkDxMz8UqqH2lbgArFi630seFkmNl3jSfevwt1OhaaX/L5jxvC/3rvOTVx5Xl+KF83/61fM7pUmycVm+ytnwF6Yy9xzyD4UaU1ma2NLdyLXffs8QLWP1EIkfbWwnwmHsp0qr3MFYiSMU6SA6KwgfPkmY3y8GieRRf3HAQtG3eyJqSg6WUIswe7yherKBSsPjHQRwxgHizpjgp/i6/fyK83jE/WzG+7BWlFLGNyXJ/U+cwyQn9oJXPFrtz8po/aWdge0YY3aQHGl0XhO8tnZRKJ6n8dQC/n7FjEs6uFRu41InCNa6cxlTL/8paI6lnmQe1ezKvxKVh9WrCnzLD84bUWMJhZr7wTBtBYKuX83QploHdW+HQp14OKqWV5wBbYLbkfcAfDd1b2P4wkb3h9NIuKHEOhvFao3l7EV9NNxnajLWZ8V2HeRsI78SDNa4y/Q+FhhJ7WL2OhAzmjxwkBe3kcf+5gZNhniyX/zmx/U9HsdJr5FmeN5bpGkqTCQ8yl1Mv17u90+93IRSd9rbQ3EdSYzGtY7oKC681rtSqUQ/vbkR1E4KkhkcjAq6vyciYLz+Z6n1lvoz3hepXMOwsgppwtPhBis1mhvAqLwWpxDMK96eqb70a2dfT6RKJhzz4wmUTakDdBG0S/p1YySg3TlEGKJhosBqDmTTD28TqP5nEn/GikfZ6J5zHedssJuhVtFE3YjnxqyDMwfFlwE2e1Q93sD+Rn12Qtq0UYs4If3K/xX16C5PCHCq0qqgWc8SWQr65FL5qSrpJpUUUJCEGimpV8MSevUCNqnjtUd50sQgK0laqLdSn2fLFiTJa4Bm5lkVDFIo/i9GaQ8YNsiGnIAEBYiljFj4rSGtMCjERvZi5gbzCP04qOCq4McKqh8MgyOPjCNbgb0dK46VgnxLhzREzSsSjhCQo5zdDMRnzeBTaRCyUq17oIpO8zj+csI9HMBb/ZkeXVxgrGfRx29I8ZrbfN4zXlva+kH3G3x45fHdFCRb/WWD+n79B2bSkthDe3GGcIV+umH9mxfBBh9/N2MMRxojZD4R1R9p4ykra/eFhFOuaxmGyJW6EBzevDd3brFxtFetlCHvBtHNrF+pFCme7oco/LU451dZ84aCSgnqXZqvc26J0GKP3+xyXa09laeMC2q6V+93dJ+ZJWuzjMwNtoQyCmjUPRcQk1wYzGroHq3xozhzxWTh8xYiAKq0NzRtDeNBiSnPZS4LUFaa2btKCROVgmC7ku3XvxN5uVtTTH6U9//A9KR7Xn4qQbrowes2F6pCawsMfM+TZYvbQv4nSZekcSffC8Sowb8xiddfeFfwxYuZEbhy5NZxeKGUlIrzmXrjEw41juLGUIPfCP4xy4FQ0HKfWUoOIKXPwyoG3iqAZ/MMga81Vw/Gl2D6FgyjCJc5Wnk3JqFdLsIuaTCcUDH/SkI76nA/nNLca6kGUg3w4Zo3FFXpJeJjBGtxBfZ7nhGnFuzVvvfj6eli9lULNaGEclVNcKVoVdBDEX5B9Nwh/c3gWFkrOEglsxXLMRnl5RVlTq4tamzGjgcHijob2HWx+Imlopxcirls/Sizq/sYLPWWLuEw0cvjJB0e+9XRvZGFLXWG+zvidoXk8F0N5U7j+f75l7ODd44byuqH/xJIaQVPbu4Qxda8x5NYyXcL4MtF+ZqVLt4LcqC91L392Sm/rX490rwVNPX1nK57Ovbb2W0F07Sz7kZ+UCtFL8W7H2kl8P34ax/tC9SsZRRX2ZUmVMgk5LZcq8kjkWYUXmlwkhtX2jAY82QQrsb3yWat7QFU5F2uwTtrZNirqGWDaKk/P1GhMESlgpTU5XrqFJ4uRtn8Vb9lUFGWSE3AVaVVUarwQAUs4wPRyTV63ojI34vGZfSCtArZ1omr9/BZipERZAI2rSpYoLgD3O6bvPpPc7SKIRmqlDS+iqFrU6/U0ZyRUNgGzcHNB2uAGloz3eWUlY97VjUP5YI28f6VY+FMRhEMV0OFgaO9mUtvARr57bFiKpXqNknJobSyMV4bUBqYrT/OY6d5OhM8fBW0bZ5hn8B57u4PGk1cd6bIDjGSYF8QxwXcYYynDCCVjnKXkjB0jZT5IC34YyddBYlQNpO9esP4dLTpsoZT/k70/D9c1ves60c89PcM7rHFPNaZSKYYQQ9CYSOSAgmmINHqMIH2B6EFpFOhzPIq2NH0JEsGOIxxEaSQtcUIFbEZpcYCGFhtEknSQzJWk5l17WtM7PNM9nD9+9/O8uwRxSirVpp7rqqv2Wvvda73vM9z37/f9fQdPLGv8TBTQduOJhaNDCqrqjvhhVjd6Ym0x5y3bly7pL9ccvO0EVluUNVjjGKym+vAZ7vpK0LFZibIGc7bFnGxIVlPl/HmlLc3LDrGrDl8rtveWoBQmK3yLE6GfmD7KuNmqyQc0OqFSmCFNka5kpFX8Q/OFz1MEt45UtzXRpcn67W7OtsnIWDI7dwDbpMlDNuSGsZ9rhrkUoHYNqZNrrQexMhu9O4tzKaxU9rb1dRb0JSY1s90KyhRKsSW624qu30/EUjb44kxoNaEXtCy5hC8UTbCCnqW8eed71AzC+xURXQ67GPIpSonQQ3FDQ4oUF576yS1xXtJeKkQc2MbMM88F8Wlg+VgrKGhtWL20lhG3lfM95tMXK4evLf2eJBKpHOEaS0P38qvCdT8sxbTfSmOTGK+Px89kfO4uBlLp6A4qohPXhFBAdcdLI5FT/Mx2oDyXim5YiAfnGJQiiKuaGp6RbjH5T4eEXcv1Na1QGnQbROSYC9loLLGwmIsG+oFYFzl8Q3xih4UlOXEhGJ1HUhZrqYQ0r1Fs3dw6UJzJ6CwWQvGQJkDRHcCwJ9d6XLNNm4vdUoRP6LzWnpnps7g1VHdkjdpeFuRebORyMpu2E2BhWoWfR2IdMVtF9azCNmJPNVzzqK2huqWwm4ifabpD2H4ytGbO+ukadceyeEKaIT2A20RB7OeO7T2lmPyPHNSVkXNgIqkCFUfbOHnPdivJZ7PHLiSxzBmhTtUykQqVoKYjVc21appIjUKyfi/xUQYw/6OOxEffRzW9WJlPx4uF6vNx3GWYP3bU2qdp/G4bIfeJdUmiP7CClJmcc3+X6f+Ito6j0nHMHcrd1yOqMyVb5f/chonQHh20l2Qk6mspMLUle44q/FzEBtHuuHhjROuUWa0yl2/cFHIGOmpUaIvVjy8VUUdmz/Zi0aQVsXboWUW6fQo+kJwVzqUxoEXhrlKiePKUza+/D7cWxb1KejKBluhXQXH6pdmpbfPzrXJhrcJOoZoy0jx6qwYnG+eY386o9xp23MHkpBDwCzVRNFCiME9GuGY6I4Gh2DkOjOesPAmYrcIvRABmG7HW0d0Msx5IsxJ9YaVAN9nTVCnMumc4KIl7DpsqdAwQE2nwKGsgZCoASNSjUqRNgzGaIoGeG+FsFgX95RnmvIUUsXe2pPOWWFoUiuFqzbDQuFWkPVa4FQxXC9xZj24HEon5+88p7vR0VytsfRWMoXzijOKD53LNQkR5eX90Ayl2U9Go2h5dl/h7FnJel4WIpZSMbvs9g9skFisRtdiLDhUiw0E92R7pALpLjB7BphNo3SgyJURPyVLFKjDMDbYBnXPTR1rAJKKbmjGJMbVtLjy1bJx6kIalvSTXw7RCV1ANhMOMArZMyJqI7DIPupD7I6mE7bNgz8q1so38eRBnJLkfnRSX5VkuNBtoL0uxYTqh2NhhJ7Ls9+XeN51MY4oLphQq2yZ6tSugbQNlI89BsYq4dcIfVMRs8SV2QYI6iyBT7tdYGEKt6Q4M7aGmWAGkPFoeG2Rxe0ha7O6KdcJ2CT+3hLmlL0b3AE+7X2T/zZTXBrFQMq3E5W7vr7PiO4hDQw/NJekq6jvSwJTPrsUbeFGIwlyRi2YR9PhKRHQyile4TaA8D/RLsXCTdDa5/rHQQm0ZxMg/FaODR4GKEb3KPOnbF5CURENrRSwNw8LQ72U0sBKPUNswaQp8rShPxbYi1m5KBYwue6FWTI4pErghTXR/CH4hCLHpslNFA8OevH52Q/QNknQm7hO2lb8Tb9iEn0PMqDx1pDhs0TdqlIt0D3jSMqI2DnfbMCwjxTkMS/D7kbiMrNoK1hYzSLHYL6X4b48MHBlUEO9Y04qILRYAUpiGGahBoQcJ2bDb7EYwwPwpSSRLMRIOlgxLKW7FIzYRCylE9Qg2aJkwhFnEbgRJftFH9eP3eLFQfR4ONezG9aP9lETQCedSunNLceYlc9ogOzB5Cj0WPnkhNF1iJJ2PY2/bjEIO2YRFeatQOk1eodECEfy+bMzzZ+KkiDbDztZJBCU5tShTDYT7KtxUlGzMw1JNi60OsjhGC92++IwIrSBzb+eW7b2G2a0etx6I1oDWqMKBc4IW9oP4iJrRhkioB/VTa/qrC+zaE0vx1Oz2NMkq3EXAbSTe08+NFPh3bf5mK8rvlHYRqxkozZZAYsmlMl84OHIiUi5CWunsdcyFEtAeaqK1ma8rSNpoSzPGj8r4VbwL904HbGnZVIZYi3I8aYPZWnQfiaXwcMl8PTVIyo9uOqyWfPSwqFBdENFZCLsCVQFKZzsjIzG1JMytC8xtoKoIly2hEM6xWXkxVR/kjSYSw/wSVTugB6gLRfH0irSsMSdb+flao9cd5uaFFAdzS/OqI0y/wNxAss+JqLKQawmwbcWCrK5Q+0tSXeL3q8mKzc/E9aDsxrF/kjHp1osq+6DGL8Qn0zYjBzWhejnXtpExd0KmEX4mhYbpxJN05PIK9UX407YJ2HwNo1O4lac/kEjR4ISDbLo0BW8INWZ0FEhTAzK/Icbuvs7KcsXOpHwE9bWAYqMwaZxyhEo4jNFkEZcWpwXTZacCldXjhRR//VKex/0PBdojjT9UxEKeqeaKliJ5I7+3X0oxpAP0M3keq9PAMNdScAQzrQVuHSjOA34m3s7jJCEUIoJbPVhkf1J5z6GX550ktACVchPbJ8rsXSvFv8JsB0wb8Qsp0rp94WWaPkGRz2sQoVkyhmQrooHlozJh6O6ZY1YCi5Z3enSUEXoqLN3lGX4uBbTwZvO9k8QKbBSWmlb8gGWqEnfWfoPYiknBbFGFgZSITv6vUhJfNB92yOrRkmRyUe0j6dBQnSb6QaHOsvuJkbUVJb7Zbu1JhfAwt1eN8Gb1ju8+rpXak5FKRXeQsjBQ4VaJ+fXI5h6NnwkyKfeGIMfVaZyK3eaKoTrJk5urUWgjKKJNhBsVttGwP1DNelplSPs9DAk/aIY9zXCPJx4FaZJuWvRaZ2Q+X2fHFGHta+ENk+R7zRVxyAgFqEZQ97FgT1o+m9sEzLYnzkvSvGTYKzKgIBOBWMj5M41Mq0yf6OYQDj1E8WwtLnhBIaoxPQ8c1RfSB/4YHy8Wqs/DYXqP7iO6UDDsCtbn3IZZQBMqIxt5jvazeeMEJpuhiZNpdiPKcYQEI6KXRHEJJJNyvnIWGlhoj8FtNd2+LILlRZx8XUeHAbvN6nirSFE8QWVzFXX8EPOI3Mr7MDqPP/O4U7iGCZfVtL7WDHOLaYKYfi9qlDHZ3zTCeovqeinEnIWDJcPlhYz5hyRxpIVERbpGUnuGpUYh2edJ6azsZ+KM6Vycq8zfjZmuMBYQo5AlkdHiPokv6zQSTlkkJTZeystG0aMZs89ts+P7jpQN0wpSYRtYPVRPiKsedobefmGJpcFuA34+Q/uEXUmEKj6Aj5iTFQZF2psJSreoifs15nSN6rwU+GNxlBXKKmnSZYNeiyIo5RvGnG7R6xZiFJsrBUobZu+6TaoK/PEMtajQaNStNWrdCEcYJY4MzjIcVwxX5rhbkNLA+rOPqd+5lbAGY7G3VsSqQK23QtlYLkiziuGwwrQi6gr3zqlvdAx7FrcKtJecXJjVCvPMinS8h2o0Fgi1zhnqomp36zCd45Hn2GexzyiUE9RbiWArP2tmkDjgYPMYvomZ8qAzvUXuXVEgSxHlNsKvG9O+xE0ic39Hu502R54i91yfETO32qGnNgu4msti7WbbJBnvWZ0/Im5jkzMshFsonwdmzwYgsblX3nusE/Uz0N4X4Uaeisy1PNNr2P9Aj+nE+cE0QRrH3LxpL9/TXcDFRHdo2F5T8vezwOxxIOYmVImPp5+n6XmePZvyfZzPSW70RnTczzT9vsGtJCiiPcy/2+SY0HacAElxa7eR9tBQ3+pRvae/tkQPke7QETUiJhwS7s422/VFafK63fRmmOeUvsz5THn83S81plSUp7nDUOJkIPZtWvinWgRUdt3La0JEb7vsNmIZru0Rncadd+JteqlEeTAhons1haEUFxHbyRpq19JE+Zlhc4+dxF1mFNGqjMDm6YCf3cXPDKAGWT9GwVJxLue+X8r1LVaR4tznmN9MfekyAtwkzFoeDntqJiAhnjv8HUe837P30gsOrt3h2Q9cQr0sceXBC56+fSRCq9OdA4UIUGHxZMDXwmGPTrx+XRIurGkQ3YOXgnOoRwebLPqNifp6gz5voHDowRMv5U2rJru1SFzzpKOI4OcJc2FICD1imL/IUf14Pl4sVJ+Hw89Esa2yVahtRuP1cVNUmDhm0+cxVq12PMuc0BPz+HB6YFMevSO6GkEEMtKqVPbLlL+PFuJCZSRX/ASHJbgm4TaSmy5q1owSrmOmJ8hqqoeIDglfG/qlnjLNpXDe/V4xwRbT8G5PAaKqtV3CdGHaTJTRWWmdBUPbPueJa9J6Iw4A52v0zOEP5/iZxW0C6IxeGfkcoRJPwmTSFP04jvljAW2pqO8kQqYnMBamdy160zgfKXailTGazvxhURAzqXRVkBGoJB5JsUpSxDwSFVqCjDmjld8Zc5RgcZ5oj8VzU94MJO3QOWJR+Yg9a1D9AIWVgjVEKUpJUDrMhVjnqG0nhdngRWVdOlQuulj3xFlJImJPGzFTD5HUS9ejlCKlSAoBZTQqRuxpC2et0Ajafjw7IuBqWgC0jWx+62WGfUt5PeLaQPdAjXtqg7u1gbZDrTao+QwOlvj9WkSChcGdd5L53gTsRS/IyYHDrQLl46citjEatenQMTIc1Vk0mLJNlBJFcUZJUYLwTLGxo11USFOxSkqYANFoGb23cqGVj5jWY7e5UeoStoT+QBEWieJkHK2mPM5X2duVjOYlilXKBfTo7zpOH+TPXSXN5hRNHHdo/UjZcetAc8lMTaKvFaGWf+/nKqfOabqDjFDl1Ll+T1E/7Tl6W0tY1oTS4VaCxJW3WrqjpaBVTqYnoZBz4QvwlWWYi8F8eyxFUNSw977E7FkvXEyVwx6WAXeucBdSAA4zeb32srYMSyky+n0p6ouLhF53zH75NsN9BwyLpaDHIe0+n5MmoL7l6ZciBDM9tPfvC4KbI3zjTNPvWapbvcTxVsJtt9uI8ophIU4nSY3pfDAsJTnMbaRRsNuIaeXBnazPlCyeKshCkKwWoaKRNTAczBj2C2nCjcJse3RGBN3FgF17/EJoTWkjIq/ydJB1MJKt8AzNJUcoFcVFmnjwsVCYrTSsYcyzL0ZKltwjthXecXco99wIQrhVothE+UydCDGHhaU8Q9wX1rB8n5nCI2KhaC6J80icBfTco1ykDZaz0znm8YL2IY9//AB74fIkKOH3Iskl1KCYP65pLymaK2L5ZzcwOp8kpYhaTZOGKR0sF5xunZg/vsE9eUKqhOsSlhUUBcM+0GjikkmUKwEJwtGVAjsjzIN4so7r7wvheNFH9fk9XixUn4cjZd5NysWkJG4kRo/U0Wx/tMgBMe8WEVC2Y4p5TJKtmcaCj8y7n5StMeW8ZBitn2ybJp7cMMuJWAqx+wgyntY9kIVeYyEsvD9BemKh8EbGxyBepKOS3oxT6CxWKVYirIhOovtA49ZRRqhtEAeA0uU0EoUaAlgt/qpNiyoKeeOFw6w74qzE6GzcXuXEoewZazeR/sDIuBf5rNP7akR13y9U9qUdqRGAu+v6aGkW3Eag1THfPGTO7hTzaXc83XFhnVwZshdgcSFj4miyr20uaNoDPaHWbiOo77C4izrRq8x7tEQ3wzmLWbdZQCUFbawKQYVCRJ2uSTGIGM0awj2HpMJgzlopclMi7dX0+w41SDIOvSCw472kkibFQEpJvFi1uAoo/W9BF6Mrw8ECf+8+sycT8VmPOe+wHdjbW2JlM0odUfsL0uG+nKB+IO7NMpVhICwK2eAK4ZSWt1uSszJm7ALp0gEgHMJQKEwTsdtArHQe6ZP5yFKMBMeUIGYaxeymIE3DwqC8hGCE3GyZPk0Nou4jflHsYlpNRHeB6rZl6wxuEynPPCiNr4yMwc3YiAh61S+EVyroWc54V0J3CYVYZJlW/FVnN2U3bo6FsuKBUBpsI6iY2448WilEYwFxkAJmWKrsUSzCHZcRtuOfXWG9ASe2W8PcUN32pBRzVHOi3zPYTsSAodQsnvHYjXDA/dLJKFonigtFUprNtYLmSkbL2sTeB4RzSBJbsWFPFOnaK0Ip3ELT5Pt+K89H/cQKdbqC+w9lrYHMJU94tbMYWz3gQAmfM1Qmx37uUOqhFgFdcrlxKg3JyvM/zHJjbdU0qajOhOaQ9C5MozzpMOtORtXLMqdNBaJKDPtOHCNCEhstLUVrmDmZbi21JGxtNKkuIGaXltpJHDAwLJ2Is7aSloVW9Ec1zWVLqBTFSlDxYaHYXoXk8kgnr1+ml4aIbNU2NmKjD2pxkSbONFrCVao8PShOWtTMkJSivVTQHcj6npy4skQrzVqsI/ao495LZ1xsK9ptSftULdxvG+F6ge13E6RYKlQjdlDRQXNFCmYZ46csdoSyjxQXcs92+5ruSOd1XywYTR9xT9whDQP+vgMp1Esr9Amc7Hc90wTMrWUt3d4LsRSHGhXURCF4sW77+D1eLFSfhyMZ2ZjNkCa/z3HDM33KYqSEa+KkbBcRgFSb2ieC24mIJrX9cNe4K//caQxssno9AoFJ9DRaJykviGRyTErRFGVzcFsReqkgmy5Jovm0Fz6g3QqSFa2+a1wuwi8dhKM6mrAHp7LliozrtNfZNHyYNgbdeFn82+y8ThKuY0xSRPlAeX0riIsFX8nPMFspYkKpRcRR7dTho22VGTKNoUmixB7Uc85VKMgIhFhNlecho6piEJ/fDdrvXBJ0L6KG9lBNCS2jaGt0JdA+4bY7lM+2UryPG7FtwZdpsr1qjjW6hPW9Dre1xMJQOI29vSLWJXFeoFJGT+sStdmiCkfcn6O0RjlHcoZwAPYk5jCFlMfOilRY0vEeetUIijoEQVd17mhCIHlJCkoR4Q6PEbeDXJ/m19/PsCyY3ehwz5yi7lyQZkIJUEahXEH4hENQCrvqYNPA8YLgNNVpNvk+LPBzSzqyJK2wWy0+wPfsZyeHMDV25dkgm5ozkBPVUka7sYp+IRt+UjmRLDdZwyInv2lyYZ8bjyy4AimEhd+bE+BUxG6huUdRnEeqmx3V9S3dvUtUyl6u2Q1i9O2NpWJ9rxV0KQdO2K0gsMUaeiX34OyWoGDdoRW0O6RprKoHEb+M4r5oFIrMac2Fhi8V/jDh96Sh9BXsvz9gdEl3tZwEj8VKmqT2voUgcNtIt29wWxFR2UYoLMPc4DYmp1pBfSOHFRQi1Aq1IFvlaZrcREwr+fViZE92MBHUa+/xyN77W8LMQtdjr5+JRzKZkwnZlk/WORuycKsFFWN2EhC7peJC1kRf55jOTL1ASVpUqAybeytpClcRY0RcNHqYkqA6CZgu0e3Laxcf9qLu1wrdeHQ7oAaDQgkfFSR+OET83BEqWev0ymPagDnfglKEvZL+WiV8/O2AWQ3oVpAFc96QSktzbUFzxeXEJvnsk7r90BOXARWKySUCJZSSfimodCgksKW8rVg+KTz/DuF++mp0dBiRASkgh3kOYTECYpitrEXJCtfZtApOHRtXM9yp4emK4ob0v9yuMqK5i462WylK61tZYJibAaUEhJjdCDmeN9JccSQU23uFRmWC7C3KQ/HkOZyv2fym+1G2FkGsk+mNoKP53uqY7AI3D8jflTc1fiE/JwFhgSwAL5DjRY7q83u8WKg+D0cs1HMskvQQd2bmWSRiN4MgkkVOhVoNqFBMBWJw0mVHDSZPgYMeEaLM38moKqTJ+iq4HBKQ/80oFAEmAYBphXcpG+do56IoL2SDTUYRlWyiaWamQq66I4u0rw2xEFR4Qn3z7x/5aKFA/A0LQXCTcrKwNYpSC7KqL0B5T+p6iV1VoPoSNwTSrCKFgWidoE2FImnLMJMErNEWKNrsjjCp99MUkTnZRwFkhbaM9HcCG5SgaUnJGG78rCok6lthKnRCpZhfl9FhdyA0iHEhTQqCVdjs4jDM9MSpUxF0KxtU1Bq8bLjByRh1tMgaFgZURfKeNCuFT+cUerBYo1B+QdqbEesCe3uN3vZAieojcVGjvMfe2ZCaVvitOoDWkhQ2K2UH6DpUPYOuJ6ko4jbn5HcayTtnGESo84nXaK4IotseF9gnBtS2QW0b0qJEGY22BaoPtFcq+mNNv3dAfcuDgu5Sia0t7bGTke1MNia3lefCrVK2oRHFcH3LU5y0IuTqQg64kOfFdCnHmYrlTnUWUUlT5YSwMSlI/EjTc0a+KovQNvcWbLai/BD7tlK8hUuYPz2IVZWPFLebzAU0k9elClEoJ6Uilgo/PXtiX2a7RHXHY7cSKjHMxc6ouPCoYOU1IWFPmbiVbh1pLhvxMs0UFpPdBCZOeg79iEXE9Ir2Ss3mHiuJQnvZQigauj2hEoixPGiv8fOcQNeKUr09koZY99BcUpNnZSihuilNWSwEoSvPI7aNzK9nio9SjPYjpg1TCEhxO/v1YkiFEqunYTwvoJDfV93qKc88Ye7YXBNP0oAU+sLFFD642woijlZ0l8pcMAcRbB7JZ1L5miSzmwBJEIqkNoVaMxyWVM+swUdR9/dK7qt+Fy+cNITaiOhQy7pRnPXoTYe6c05azlFU0xrnbm/Qq4a4NydWkmDVX57RHTm51rkxaC5ptveAP/TM71vTt47irKA8Fw5vzOipIN6JtO9hpZk/qyguAv2elenLMnvG9rL22W2ivVSyvt/SHwgCH8oIe55oE/Qa7SJqq5l/0GIaR3t4KPZzF/l+ypaEEiUsPOVhAdVtQXJ9nRuXPfFyNU2iujWIeKo2k4NNewmG44jeyqhJRyjOB8oP3aH9lCu0981RUePWARXi5PUbipz0V4JfZiFcGVl8WBwB+jJivJapW/vCGv2/eDy/x4uF6vN0pGyUrBPQJYnkCwnlTfZKle5exB9qKmJHkYLMz6SrjYY8et4VhNMoGqbQANPJwib8OrFbGrlwowuA6aUwSoMgHqMC2G4T7kLGqJNJdeamJSNpWKGUxK3oVPYN9KRM8PczzTC7qwXOPE9BMCVmEpBRndOgFPXGYS/sjpsJwr3se1TbUa83pOIaq4crIfcfgFsZQi1IgCiXBXWwTcrWKEmiMxWkuSBiKqjpvYyfR9K7cgertKCe28zTtYLK2SbiM98wKUmeCZUhWiNZ7LlgCYVY9QQnhdTIsYxWFmNf53FlNv1WIVGdBrTXItTaH43XFUnPJ1/daMVypz2aY67NcNkFwWwL9HZANwMMPdSleBk2HRSF8FtTQrUDxDh9zWIuIqbsP6qMIYXsK7k3I84q9K0z4rzg7NUHJCWIufeKtJzhZ6VcJyd8R9V7lI+UdxTrl5f0hwp/1RIHQzRaCsfskpC0IuztPEZ9LYbhaOHw+pnDXrHUtwPlnXyenVA/+gONXSfKc0kW65e7xLFhLpSBmE3+VUjoXLDa1uNOplg4ohXzfB2FV6d9ZPl4FJ9hIFWOWNmJJ1iuZdwrrha7hDIyLaQ6E85qeUMQuHi1ptu3UsRdBCma5llE1Eqa1DAXesgYDStj30SqojStYxhBmX/PfpR7qNT4a9LcoHKRWWm2DyfUNlHeUvQHimExPnzS4Ooh0V7Sk7fsyOUmiT+safKEoZLCyDa5aVgF+n1L1DJFMH3CbkPmWmq6o4LiXBPmBWY7l/u1ttN6E2d5eVJQrMT+KmlRrw9zlZs54cA2V6A8g9Tuno/k5DwlrZ4jHh0pO6OAE6QH6xdCtZFCUNw0dOezN6UslqGUImgU4EUj66xtPO5OQ6yEt4n3wvfPVlrEJPGwVtPcvwBrBHioxfN0tAAcFor2EvT3DBxcWXO03HD9xgFuFXGbMPH8k822UrUgqPMnFYunevpl9qhdKoZ5ytx6oWIkJROJUEB7v6dcdsRNgd5oii3oTd4/IthNzC4DGteIrVl3oHOzP95zch/YdWL+jMfPNG6dKE8VoZH7fe/DntmTG/x+Pa2X26ua9lqCDIQIr1vhzgbifsX2Nx9IeMYtTb9n6A8szRVNf5AozoSX2zsyrxXsucl2W0y8XuIuCOSFcsTnwUf1xWSq3fFiofp8HCMiYuTmS2b3nwieRtGSyhGhGpdN9lVMWJ+wdzzN5SIvrjskZjxGf1WZFmQ1viZ7iEolO6Xz5EN7WWyGGTvKgIaokizyThbyUcQ1RleOBe9IGbCtGIlrH+kXY3j1ThU8boSjZVR3IC+pb0XIbgB6SHRXFwxHM0Lo4GKL3Xh028G2zxZSEfXMKc7MGa4Kipu8uCDpJBux2YA3ED2oTSQNidF7MyVDty8bGVtIQf79MGNXrA4CRhdDQm88MSQG42Qj04k4KPCgton1TKF8h3t8YP1QTbqAgYxu5Guj+og7C/h9EYMFrYlBiQm6FmFOsy/Xz51GVO2I99TEzHkc5i5bjSWqW55QSFMgjUxWHGuxplK3TklVgVKDcPpiEm9TJzGsAFhLmteoTSMIa99mBwAl/FVXEQ/mpEWNXreC8h/MqJ9q6K7NRJE7U3T379HtG0k5SuC1orgtMWCxsizfuWWRVvSXHM19c1A2+4yKrVB5FolWT/zS4CDMZUMtLyJJZ9ukxufGx9BcMiQn95afKVK/i60cY4bHJsLmVCJBoeU1oTQynkbSomyb8vMG5TpRnAXKOy2qzzZEtUN3Ad1HhstGrMOCiOSSUbm4TRPf3NeyGbeHS0y/iziuTiJhZuj2DbaVQmEyeu8Euez3NYwiPwM2BpZPBMqTRHNFPEjDPIkbQiPjeZI0aP2BUAKKC4hnNosa5Xm1W7nfTU762d6TC+JCCiTTMXGubSOhBlKEymdySugH/dKwvndXeKo4CkKTFDXnQtvxCwdaGu229HSxFeTuHGy2cfObFhUi/XFFu2fxBRCykGYO+gawgtgn1B1P6Dz2qY5UOfzMEdZCS0mdNHvu3NMtDT6K+l48VTVtRJrnIdD3W5J2eB0weFSTSINiOCjxhZloVcU6EFvPUCVIPcWNm6SuQw2WtPXQ96hmwC8q+qtLukImP1TZ8cGCjtDtO4Z7SvqrgdlRw4NHJ4So4cRRnMv1t1txYRkWMOxLFTb7kGP2VKTfs5y/zNDcH1CdJqGy126c0G7TJpSB+X5DWQ2EZyvqJ8wk8GzuSxy+K1LfirRH4gAw1CNdQGzOCIJoDgvhyxZnAh5Ep6hvB2yjaK4YivNA9WyHXrWo2tLeN2d7zYCG2VMKPxe0XsVEcInqVo/SRm6+bYXpE6uXFAwLSBaqW+LXHJ3sQaGU79e3dnuFCru908/U+McXj4/D48VC9Xk4ppFj5qYKN9PIpo18rbR0wKFUkKQYAXabF2SvTkFfUOPPQhCwkbYUd4pSABNlURSxhiJkZfL4u8Isb2TtTrEajXAmXalxTZz8JFFi+ZQUmLTLvPYzTXO5wLQiRjJdQCdQUdMvbR6lkREASWTp9yBaUYDPrnuGpeHipQ62LSe/9HY4WeHOmkw0TMTSEp1BnSTUaUbhSlHcpoxGSSSpmopu06ecMJXfeykm3XcnfE1oNDtKBGQxQJOyz6neXSefFeUhEWo9jR7DuZrSv6Yo24wImS5hPhwzIiBNScrWQdEoQi0NASGhFzOOy9+M1QWhVLRHY1oQ9PtWokWHwHDsQFncxSCf72It90lZiJgKlcMTshirybZUGuLQYjaN8H+z/ZSaz2BWiTq3tMJlrQuoC/Ce6laPHcTvNmmw24BpI+6kwe9XhFkWtBVynXQl+ea2CSw+3DEciHglOkGU3Toxuxnp9zQxF0yxgOUTAypAe6hojxWrhwsRVUQRpKgo6KEKQNDUWjiNus9CuCGhop6eD5WFJ4q8IeZCVT7DaMkm93FxfYXJEbYpRYYrM0KhaS8LTcXXwoXsl4KE1rcixSqIzVQWfxEFdTY9U/qVziKu4kLOv681YS6jbrdJhJwVrwcRpvhWEVcF/UJM7Pt9xbAnCUOmUwzLiLkdqW8mttcsxTnUOYa2uaSn0IH+KPOjtwp7LnZuyiuhDuUJjIqKVEOxCew9Kiry8dyNRywUzbFh9HDWXvxqk1LZfitIbLPVmMZjtgO99tx89G10bGW96HcCUklRUoRzzXAzh2C0TOix2OBl9w0f0UMQqzWjRRB1Q0mDO5PiqzoZCFYTaoPbhExPyFSeBG7VQ9NBWZCcCLKImcZwc/SxFrcM03ixcENJB9y04k18quFcQ/BCQ+od4aaGW2qacHVLQWRVhHQ0Y/GK17B3z8AnXblJFywnmznFk2LFNSzFtqrfVzRXI8kmylua6rYIptpjTXu/R6uE3khBWJwnyrPMO95E2mNoHx7Y85Hu7QcsbkFxLuuMaSP1nUh9W84jqCkYxhvFsEz4RY4htrI3mW60XIu4TZ4wpUh5Cm4ldDW/X7F+6UK0AJl2I/69OUlxBsfv7ChuNdD2lO9KNA/Iflbf6NncV9BcNvgyC+zaxBjPbRu5J7f3StO6eFwzzHiOJeOLx8fn8WKh+jwcYwrOyLFJRkGImGypkrQiOeFMaZ8wTcBshowk1USraS8XO2RW74pXYOfJmh/oaNWEtkar0GmHKo72UypBsY6EldiOxCJTE3JhLErTJH6DemdOfnd0q1vHKb416UR5GjCNp7ghCTLdtQUzlW1k8iibPLpzG4j3DLSNRQURHmgPQ/T0YYtdFJhGE+eOfs9NCJGKoLuAuegpekX0lmHPEZSoZinAZXsqrRLa5jSwCIaE0oLikdXfzxGgKaRgBFIJqUqoJmETkPKCX4qaVSXJZFBGFtzCJ7q5kcCAIAhvnIH1UkfqIgcmaND5dyiX0FpNGgGve0KzRa0HdF3g1pHy5sDmoQKiYntVUcws+tCKmtco+gNLqA1Vm5Ed59AXETXkZChnRCi1aUTNv5yhSgdVQHUduFIK2nlNnFfEWhCxNHMyLiXibl4QbUTZgF9KuEC/7yBFzFZ8cd1Zh77YEA4X4m16VIn/5KpHDRF37gmVm6JHo5V4UIDDd28ZlgXDUmyTosnenFpG3DqjXcFJ3Kq7yCk/C9hekVGoHqC8kNH7mO8+xmWO8bvRqckRImpFKIQ3J/6+Gmc0/sqS5AzdgaU7chn9TFSnieZYMyylyTKdWKNNjhzk657tp4KT9y/olcnK7swzzxZpY3dps8p9F5s80lekeE8KzFaKrqTEBmrxhCdUVtA1pyjP5HOIMXsW6XXCCR1T6sa0H9OqnZgrJHQn9lMxj8KHuTQSKd/bLo1hBEnG7FH4oLI+yDoxLO1U2NhVS/SRYdiiC4e2DhMTWLAbjx2ScJ9b0PM5Gi2BbHtgA5SbQdgKRqNjxPhBTJqtQZsC1UV0H2gXFf1MOMxu7cFDLAtpArceeoilRVuLrgqSy00KilTo/PwnbFIwkItiBG72gdRGUCXKzqSudxZqQ5g5cSJwKjs8ZIeKudB7oh9I+oIrl27wGQ/cZMDys489QvuBPQ4/lEg6I++XoLsciFXCnWjK24qhlnVs2EuoxjB7Uk2uIrMbQVDpbaQ9NqwfBq81zXv2OHz7hvlTDX6/RiUJOdAXDf6wpn1wTijEjjBp8VzVg8Js8iRJK+K+Jy7Eq7q8CHQHFl9pSTP0iFsLEKuC4tzj54bojCDXlzKfuoHqcc/s8TVhWbL9pEPaaxXdntxTB++PlKch03dyY+93sb9+luj3pQktTgQEGA7S7n2+gKqVF6qYKsbIo48+SlEUPPjgg2j9XAXaBz/4QW7duvWc7y0WC37dr/t1v+JnPf3009y6dYtP+IRPYD6f/0e/l4/k8QK69P/lHjqOSA93eT4KAyVlq5uUNy7deSmWcvFpuigegUHGh9EKh4fRIolcnyr5PROXNezG2UGPm1xGDZWgqKOFCyiiT5OQQ8abuXgdeZwjh2ib8mgwYreeZC3ViZdUpxxWEOpDKQ6VFLO+lofFdClzOLNDwE1H2ku01xTlrYwCORkDGV3SL5cTbzSlLCxRQJGwjUK3AzQJNXMEq9FBMewBRhDkWKkJ+YnZYFwHxVAid/7ovgA754TElN6jlKAuronCD82m71Tir6qCvB89ROFgbrIvrs30DCeAsCz0USgQmXM8Rs6Owh+Vkph2B4/JlAm7jRRngbaV18YSfFATb0tSdwy+SjSvOSY6RXU7UN0pZeNsA/Zki7p+W1T8xkBVQFmA2ZIO9wjHS0lDK62MthOiyjcKezFggiJdPiDslaQRCe4j/cLQXJZw7uJCHAZUXaK3A6r3WK2zZZViOKpyIpC8d7cS2kh3DJhA+LChO7ZZtKbFA3MdJF/e7a6T+FMq1CCj7pGXbBspWjutKC40bhXE7s3JCFN8TcVv12fedMyNUyyMoKnnnuHSDB2k8Bj2hFuqg9jHNZc0wxKGLPpQXqzXVDDZXkpGzsCU6Ga34j08cjP7PTsVBmgmmsLYgEkRqOiOFXRSsIIUU2gk8vJEowdFd1zkYjOnMDVizTQKkqKD8nTne+mzkKpAFP7oBC4RZ5FYKfpeZyrGOP0Q9HNY6nyPy/ObsvVdtNAdWspTj24G2vtq+f0qYYYF0W/FHmrQxIOSOCdbs3WYOEC1IKmENyWx1CgLrgPTDhQN2f6rRMeADR50QZzXMqlJgbisMM5RJEU4BKM9xVlHaoQGkwqH7j1qE4llTVyanD4ntA6CIhkNJgMHMWGaFpogEcAhgnIoZyEoKOS5iYVFObGE8lZBAWmuZfCzyL1h0XO1PuF3vuSXuB3v4V89+jLCv9ljdkeTbGT9QMGwUPTHkVQmymcNdqPwiySF7uiUsJbnpb6d0F1g/lRDd1zSXrGsX6KwF6KOXz42sPjAOarpKdpA2K/RzUCcFWwenDMsNMMiUT87UN0JNFeKXGhCLBMsPO6gg6cr5s8EfGXk/t0M2DbRHlmaKwXRFtiNiMDGdbO5LChteQqLJzuqZ7YMhxXbe2qGbCPnF/JcCBVmp4EIlZq4qKOLhO4V1Z3sQlHt9qykX4RUf60jxsib3/xmvuM7voO9vT02mw1lWfLd3/3dvP71r59e983f/M38+I//OC972cum77385S/nrW996/R10zR86Zd+Kf/kn/wT7rvvPq5fv863f/u38xVf8RXP62e6+3ixUH0ejmhkTK3H4sTICFKFhBoipvHEKtHvF2KOv5GqMDqZRau7IgBHrzuVxlH8XfzUsXkaLajCVMtOk5NR4apiwnaRqBXlWcobkhReIyIb88+RDXVU0o/uADkdKCvph7nKal2JFyzOA8WdlmGvyP6V5NhJ+ZnaC0+wWCWa+2S8qXuF7eRtmDZhVCLOc8RplM1W5aq8v1SjfIm7tcWue1RwkuaTRNAw8gNTtlgaI2H1EFFBTx60Cn5lwap2AQCSQsSULa+H3SgqKYVCkNYE2PNeAgpqsdAaqQXRgUdRngxipp4LFZ1jV906YLeB3mQ7riQFUnQKv1dy+O5W7HOiYZgJN9cvJY3IrZPYY+UGYHOfzQIxRX/omG1a7HIG2pCqgjgvUa0nzSuGew7EsaGU9xqzuf5YsBsD0SiJPs3nKWX6h+kT82elsAIY9oWIbDY9quklKnFfONWx0II+3xUjanLxXZxBe1kiFUXtnj2AlSjmk8nekDk0YUxvgvwzcoykHuTzJ5Uki33foHykvh3kM5p8T4/c4ZAoViPnV1KrkgJv1RSPqiIMGRUFQXTKU0V1S5qGUMjYMtRC5ZF7LlGeSopWLBRBS/E4piWN4ryhzjSfKJ/BbcQLNZRy01QnEp8ZCyYLs+KOnlTf7ZEU53YrI9vTX1dgtor2ShLBkEr4bJG0eDpTTCrhl09rRQR7pqlOE3aV77daOOsqiiJ9TMgrz2UFGXLkqgoiikpa0V2qJleT+dM97mxgmEtxHZwSJM5BmCt0sBSpJlmDboM08VnkZbcxC7x0TmzzQsVQWhwpei/2ZG0PrsKuPcUQ6A8KETI1drKbUilJURnilGYlzhka03mxqRq8UAmMUBYYxAlDilSFqkpZOI0hLipSIT8jaQll6Od6ol/5zBnGwHy/JXWK/+0XX83m7Br2GUs1CDd/WIq/b3dZcuzdicFuobsWwOc1fT9gb1tpxjPVaPZ0gztpiAbOPsVS34rsvbeXQIxtL/uBlkVNRGOJ9p45sVCUp4H99zaYVu7zYVlQnomo1C8gHkWsjaRVpnWFmGOODdqLP5QkYSl0G7BbmQCGSoHSlCdyv2oP24eWdAfiXjEmHKa8rzSXLLMbIU8gZKLiZ3mfGmTyp7zCzxLDXkKfKHBRuL3Dr7XDPv/HCw1R7bqOpml417vexfHxMSklvu7rvo7f/bt/N4899hhHR0fTaz/v8z6Pv/t3/+6/82d9wzd8A+94xzv48Ic/zNWrV/ne7/1efv/v//285jWv4VM/9VP/sz7Tf+rxYqH6PBxjbvKo3E5KoXuNMglFwly0xLkVn8aYIMSM9AS8tjK2zFF5MHqDMvmijmpz2Cn6x+9FJQuB8aJ+HkeMphPUSqx2DKFS2EwbIGbkUO8KAT8b6QRiDj7MNeAm5MrPRBQw+vxpn+iOK0Ktp2J2NOjWg4w6+4UIyuh2RYi+C5UK2QpqcjOwmcvnod/TuC0S+5lTvezaS8G37/K5lE3edJCG0RtWxpe+yjzGtDtvUwLV+L2w+yy6C8RCo5W4GigyFSKP8U2fSKU0HzrsVKrj6DYUimEpj5vKtle+yuNHo+j3Lb2WzaK48PRH0B7LeLW86dHe4+dz3IXYmJ2/3JCiJmTaRnEuTgPNZUEiun2L6SLbRw5QD+1nayTJN5dGqMo8OTNlxLtNIjVMjgPdfk11J5uiw1TIlKdBvE/ngjqGSoRO+shQ37C48x6/V4jiPQdcpFrt0JicRFPeEbgkWuHesa/pDjRtjRTkZb6vo4ysx5hFkykDySgR4iQmwV57pHDbfP2MZvVQSbcvHMjqTsrCQlA+4W5uUAclflZMSWTbA0GBVC6ekpYGMyqwK8XiGYlwjSHhVvJ7QiXPhi/lGoCI5EYuOXnsPo7gJ7/UkYZugZTol4b2WDN7VgQzoYb6pnzm7kD4pCKQyuEFFzB/xtNeNmwvg2rAL6P4YAYFRx59w0jU8Fzn9Dh5T3YrRTcIZcKX8l5USpTnUN0JJCMxyxJLnONjuzRZrRWrwDA34sV6y4uf6VlHMgZfyjg81RprZcLhVmKB1h9WYnZvdj7MdiPjfL1uUb3HhAK6PPIvx2x4eX4JAXO2wWSRYOkTfq8gVAaz8eghSJOf3UpiTrQCJPRkYWFuJ9cCHaNMsrLwUKmMoGppcimcUGiMTBR8pegPcrRvk6bGE5VIs0AzOFZPH3H/5oCZNbTHsL5PGjS7TaQjjz/2qAvhPrcPD9KMr4yY859ryhOVU7hyZG3URCdxy8e/sMWtA7odGC7NZX2rCinOZyVx5tjcV7G95ihWSdaMIdBeKdneZ4UXPk7WAiSv8M9W7D+aJ0RtoL0iyVy6D8yekOARs+lRq4ZwdZ/mWiUpiq3cn0OtCK6YIqxDdhQIVW60+pxKVmWnmhw6Up6NwmAFg9pNouI4HRPdwYgyv3j86kdd13zLt3zL9LVSiq/5mq/hL/7Fv8g73/lOPvuzP3v6u67reOc738nR0RH333+/3O/5iDHy1re+lT/xJ/4EV69eBeD3/t7fyzd90zfx1re+lW/7tm97/j7UXceLherzcKgo1kbCNVITl1RlP9VYOfH3Q8liPUThUCmF3Xi6w4J+X7w4yzOfgwDUXT9/HF3nGMeMvKaMnuJAbaVjtY1k2QuCIebXqEpQpUIxLNSUuXw3TSChSKXw3kKZf67ShGwi6VbSVUtOuGF71TJmgoMgv6YXw+hxY0eLObVtZYSkh4QaRMjkDxQxI2/C6cufN6QpyWRMvyIrYpPVmO2ALQyDyUpenVGrkFBtLmhXXorvSpTWz3FMyEjq8aUDXn7P/YTe8/5//X5a3+ZCT+XAgTgV4LIgSxNis4WNCgk7JLzWE7e339OZBytorJkstXJAwCbQVIrmUoE/En5hUonUtbT3l5hemoLyLHL4tpbVyyr8UtPvy0YwfzZQ3BkY9jV+Ll6TppFCvT8wosoNklYUapUVuiMnTgrUcVOITniLxYUiDQrdyWi7PI8S1mDEskt8SuXzkzTnn1TjLgqSFWS0OEv4pc7uEoLojSKzcROzY2GZqSi2lQviDxKzJwEUthUngGGeN0KXeaxZDHe3YE/5KGisVvR7gioqL/eRbTJCPoBKwh/FCk84uFwIZV/LZCShKRpR1OtRmJeyX2qbpslDmGVkdJ1/bxaYjMWAbZIUEjndSr6W4lYpQInpux4SbgPNZSNI1e3I6iVml06kBIUWRAxA53OaUJ1w+8qTXMTnsf3mXk1yieWHIygRRbmtRFwKlzVg0CSvmK9l/dBDYihzwpNj4l7bLlHe6aXRmot90xgEUj+2QvUD7UuPUVGKwLTIz34r8bWh0PiFRG+WeQxML96kuhlQTS8npGl3z2WKJG1RMfvzaQNtK0j1Qsbcxij8soC5E0Q0QWEMn/yqT6A8nvPMs7d56v1PS/hJRgNDJWET7ryHGKUoVkpGCU642mhFrIocgy3vJ1otorksyAo2N6O10Cn6k5Ly2Yg6SJx9asJf9sS1gwT9/Z7F5Q2qdfShIBWABXPLEouEXhvKW8IRLtYph2AkmqsFlUq4O1vq7SC8c6OlCG071LaDEElGs71vxvoBI84AHTRXS7inZPWAYrh/gE0eFWgR5+pzy/7bBubPdKwfmommoNaUp1loacUuUN+5kOe0GbBrizoWMVvIDYHpduh/dHdtUVH8slWSBk4PeR8kSaGfo4J9meTfAWoQWoI5s/l5YUptfCEcLzRE9Vc73v72twPw0pe+9Dnf/6Ef+iHe/e53c/36dQ4PD3nLW97C53zO5wDw2GOPcXJywmte85rn/JvXvva1vOMd7/jPej//OceLherzcIhXnfAlYwQS2FWP6gawhljo7O+ZraqqbIdUCCpj+ohbyQate8l0Ft6Zfk7OMilN41PUzopKe9mQQiWWPqYX1C86jeo17rRB+Yph34HOnE4nm/GIqCYj3LxQi01IyKIU22Z1e5HzucdO2ilck7JfqfydbNQiQDBKkTxTWpdppTDTm4TZJlKFcOf2spXPKAhBZVRV1NduE3M8KmgfRXQVotAA4s5fkySfu5/4h7mwceBHFDVAETVv+v9+BV/yO1/Po48/xf5ywd5ixl/+y3+H7/3bPy7m7Nuwc1zIHOPxCGVWR0+UgYQvFQRJqur3dUZIAGQ8q1JCrYXqMXpzuhU5r1tz6/WXKE56ylsb3LagvVygQsHhL7eYVZd5igE7GAgee2YobwVIkc1Dc1EXGykQbSsq5bEYDYXcS8WJoIGjIl+FSP1sT7ERxHZYWmwTsBuJbNWdp7y5JRYi5irPduP1IRvOu03I/zajIkYag2ihPwRUpL4u94nuEy5GGWEC7bVEfZFwmzyqVoJi90vZEE2fBInPeelkpLJYpylJx7YxP3dMor+RwhEc+IOa9qrYBY0NQ8qfQQUZS3ZHCbuRothtBIkNmY5iusT2XkV3HJk9KRSaaMWIPmbvYu2ZinkZ7cpzrrJwany+BPHLhvxOGo/lY57uUONr4QCGWkQ286cD0Rj8UtaEqBWzx8P0PJYnifZIxipjTOfy/QPVHU+f733TSSc7LAV5F4HnyFmH4tkVZlEwHFaAJo2OC4Uo/WOhhXpyIY21aSSedxzpp2Ue+1YKrPikxpyuF0tZA6KVNDEdxSlExURa1qjew7ohFdnHdPT6TdKMUlm0tyRnZRTvKnSI2DYQjabYn/HH/siX8rmf/VquP3Oba/de4v57r/DL7/kQ/8Obv4t3PvZhdJKmRXcS7cu6gRAEPa1Kwl4lrizZ/1ooLExpUyqmjBomMerP9CR722JuCtXi/BM0LCCtHdGKN64uIttn57jrltlW0V5N6OuOxZNCn4pObLqKVaK48Nh1wM8N9qLFfvAGaRikcARUWcgE7nwt56gq6I8KLl5iGPakSez3FN2hmsS383c53CbRXILunohaBqoPWOqbkfa4oD1SQjnohV7mZ2KDV9zpIUQorKDXtaDLo4XiGDGdFJAnXyM3WwdAZ8pbIV65Omso/FyhO+GgKlkSpfF0QgcwzVj8yhrx8XhcXFw85+uyLCnL8tf8Nzdv3uSP/tE/ypd92Zfx0EMPTd///M//fP7CX/gLXLlyhWEY+GN/7I/xxje+kV/+5V/mgQce4OTkBOA5VAGA4+NjfumXfukj84H+E44XC9Xn48iRi6GQFKXRc1p3A2w6WFaEQkamdtWSrJGuvhAVruSij6MUs7PrULJxJpvRt7xY6iDIjXAdR15hfi8RYMxuNpjNkDmaGR3LCODdBfDdG6ppc/Z0nxelJIu1SlI4RqsY5vL6UTQklk0qxybK50+dvB6ypYrXdIeKsJDN1W6i8NzyfD5ayRefmvTsIzvMdCbai+0VOR6UJJGtKkq0arKKFCSn+jf8pk9hv5xx/eYd3vPMUzzysvs42l/y8297F1/7VV/Cl73xc/mFX3ovv+erv4H9wwX/x9/7Dr7hT30lT9+5wz//6X9NUiPynMQ5IaPfKmTBnBkRQynMygsRcPi5obiIzx0FX0T8Un4eGmgyQrVOOHLOve7Rg6G6HkhVwFWBUMs1q0486WIlKHzpoB8w1uDv2ceedWicRDrOdY7VFfVvtKCCoBrFRaK+PYoZYP7UFrv2EgxQWPrDCt0FiGKtNcwNxbmg4SFv5qLmF8S42ESGmaLf0yyeHFDBMMwVxkeGpbwP3ctY2zYSHNHviQfm/KmBUBmKc83mXsfmGtR3hD8ZnMQ6KmSzm1wo8r0ZC+gOZXMjaopNzoxf5POroMk+v77WrB90tJehui3WD7GQ8yFJatmd4jwnV1lAxfwcqzyO12zvTdgNlOfyM7UXjmi0ouYfY0hHwVwaHR+C3AM70301NWOhlD/7haG9pAl1Iq00bpXY/4Bn9nTD+ScvcqQp2dv2rohldj6tyw82qCHgVqLaVl42++aaI5SK4iwxLByhEsS7vjVQ3e6xN1e4E4MyxwwLh22gO9TiFVqUwsHNqncdNGoI2N5Lgbfn6JeReFOKlFQlYpULFsh2XfJeTC8Fc7QKKkeoLXoImLGJn5foTmgrfinzX6PALRSv+62/kWQN73nHe1n7gZe96hEuNg3nZyse/eCT/Lm/+ncZBk9hLP/gLX+GT/vUT+R//nN/gt/yxv9OErW2I/ciL6iFIy1nDPsloTaTv3SowR8EVGcwm5HLIb62oYqkpDC9orop8a29TvQF6FZRPmZoryTCPIqZ/WCxW1g+IQ1TeZ6b2TwSd2v5urjwFGdi42U3HnPWQNPk9VDDrCTVpVAVjJHO141NCNgb0B3nWNROkYpEmgfaWjNss5OATqi1eLSuXyKj/PlTQ46BNpg2UF3fMBxUUsRrJeleKdEeC0Jss+3huM6O+8YwI4vD8jXPThgqTxSDySBHFg2Oa5Lu8zOduehjEEHIHskvlOP5RFQfeOCB53z/T//pP803fdM3/Tv/3enpKW94wxt48MEH+a7v+q7n/N0Xf/EXT392zvGt3/qtfM/3fA//6B/9I776q78a56RQ6LruOf+uaZrp7z4Wx4uF6kf5UEpRFy4vIHctjCmJQKBtMZ1kmqt2QG1bUZcezNFdmNDAaOWBNW0Q4YDNqESRkZmEjLiHPFLVI5oov3IsLJNRkH0jk1aERYFpvXC0ks38UXlA3DZNSU/RkQUZspiGbNQ+zEWBX57FKVnHNWrydxWOoogPVNK4dZx4bqXPBUilsV3C3Ij4TZjiTouV/PxQqlzg35U9PpCN8IU/69ZJYkSbnuFKLYucZULo1JCjNAO86Y/+QT7lk17Kv3nvh5hVJc/ePuHJG7d4x7s+wJe/8Q0A/POf/gUATldr/tU7383nfeZr+Yov/138s3/xi/iZiMJGQZtt0oRgR5V5vjr7K1rwSooMPaRshSQRiMnJSMudJ3QpqGfMhv528DRXDOVpor45sH3AcfGKA0yfKM48YW7wy4Jh39O95Cp2M+DuNAzLGeUT59gP3UTVNeXNLag55ZmgI8NcaAGjinvxtJco3AT2vKU/rvCLAndjDT7QX5njZwbbCWcylNLIdEcF/t4C2wgdZRRDqQDdnhSj8+uy0TaXTUaL0nTNopXrnoxc3/VLFZd+MWFzDOOwENFYfUcUXMMcQaoHiDnj3G0iwxJAUZ0muoPs7NDLvj05WHj5f6iYmqPmmuJ8P6HKQHqfNDEqCo+yOxQnAJOFfWSuMVlIGG3KTgMKey6Z7NEIR9utMhexSbhNbhR1osxcw6GW8XnSOeozJFLKRXd2oBvjeLeXdUa4pSkpzwLF6YBqB0KxE1KGKnOlpaeTRLjcdLiLAXPe4C8vpQFGmoth4XAXPXY9sL3mSFb4p8PSyn0dDwm1JVYG08cpTz5aRXspYTdCRdpeMRTrSHl9IGihkvRLicBMBpIT4VlxPvo4j2PilPmigsSrBLYJgpppRTxa5EQqS3AGFaSwSwqUDxxePeI7/86bAPiXP/M2HnjwHj78xHV+8md+kX/wD/4J3/8P/7noAZyiT4F/+Qu/xKd96ifywL1XeOnRJZ55z1Po3j+Hh5qqQgSAtdjMCVqfCEuZMqkIYT+JG4iLmPlA6g2cW6rbUN0OJCe2cTpCeZoYXprwxwETRMWvB9j/YJjWAtPuKEHjlMd0wisdaSym6dA3z0ko1KyGxUyQ3xBQFxvZL5YVw0FFmAli6jYRP9eEg0Q0CffImuQSzXlF32uMjdjZQHqqlnCAK3I9Zzdg/mRDd1xQ3tgy7JeQIvpsI/uWVpggdmj9nsGtxc0jOoU2GdDQMCYmTn68o/i3ylHGQaYSoRaB4yiIjDk+2LayzqcRZn2B2VM9n8eTTz7J3t7e9PWvhaaenZ3xuZ/7uVRVxT/+x//432srVRQFR0dHPP300wA8+OCDADzzzDPPed0zzzzDS17ykv/Uj/CffXycXvrn95jV4u03LERs485azNlWRlwhomJEn2RlhjXEmdyIZtWhtz1Jz/CzAnsu0Zdj8TryR8kqfrLV0eghOY6kdU6pEq9SKRLdVgrCft+iFgbTBOHS5WjU4J4b8xmsLL66Hwvh3ZgQZEStYqJYRfqFJhWSwz36lIZKCjtfaUHw7gSKVaDbl0CAoRZErbrdC/9ztuM9jU4EoUq7n6ml61YBGD0orZ7Q6n5fVKWiJE4TJzbt3jKf+PAD/Ne/77/n0SefJhp41ac+wrwWT6Drt+8IjcLCjdunALzqUx6BypBUxHbCTeuONL5NeSOWX69Dkj5kLEByatL43k0vFIrRC7RYZTSWKM2H07lQ02yvFWzuK7Kli6Cx3ZGIf9CR9csW6AHae2fYB/boF4rl/oLyiXP0zTP0nUThB3RU+MMZ2/tr4qnOEbOR+uaAuWglXrVtaV9aEWeW6ilL/8A+q5dW1LcCqcujV6Mob/f0B5ZYWLZLySF3K0HxQ1aJSyqUwdcyTnfrNHEz20t38TutorsWMUWgOxIvKttJ8Sr85Oeeu36ZbZZWEdMmytOcIx+SKJ6ijJY3+0InqW9G3Dp7XZZqssrxxwF9PWKvO/xM3AuSUlmxDOWdXADmZsetE/Vtj1sFZjegPXa0x4ryXEbt3ZE8G+O9ajpp0NoDJu/iMQhCkrVEKV5cyO8YpxSjAG/0e3VrucfrG57qzIMxdPft4TZCgwi1+E+6VaYX5fOsByhPI35ZohtRy49iPtPHqZBOToSUvlbMn5VzM8wNvprTH0iDpVKiPdI09yR0A7rPU4/MH+8ONDyyxPSLSTQaql0CVtGIu0c0MkpQQZq2KQq1kGdkmBmMibi1J8wEsTNtyBMlky3KxNs51Dt1zcHxAb/zv/4jbFWUyckYdtJLHG60ik99xSfIdfeB1a0LaXxTgiG7AhSOsCzxcztdj2GZfWK3eueoohNurweTiFHBylLfkMItVNIImCHiDTRXIC2hfMaweCox1EJ18rXGxSABDQc57SxjGMU6SaN664KwPwOlUXcupOjbWwg0qRQMXqZLixlhVtBdrmmPbbZjkzAAVB6rz8SOKzw2o+jFB1kfd6itJW7kg4UyZXRfkuXK6xvs6QaljRSp2YM5Vo7+oJCAhIHJelDW6oTJEdHydaa/hN0+EK0EUCSbCPMELUJRyc0kubkkAGQx46B2U8QXyCH960cXUR0/7t7e3nMK1X/XcX5+zud+7udireUnfuInWC6Xz/n7EALe++cUuu95z3t45plneMUrXgHA4eEhv+E3/AZ+7Md+jC/8wi8EhHrw0z/90/z5P//nPzIf7D/heLFQfT6OlJNzFCRyPrgxjLLflCTqMmlNmteEZSU8u8rkUbKCmHLHmdW0ecw3GuHLaH5XnIpyMk0FLVHeh3S5uehQskH4hYacduI2QagAYUR8dlY9pkvg5P2MRapYkMjiVN8RNNYMgJaiMhZKBFz5mQ5VdgfoNHUTKLLhenSaUGs2L6nw56AM2Cjj/ugTSufRKFIAjBnVpk+4s4RZ98KLmlW4VcAvnXAX0VNRZJuYY2vlvfzrd7yb9914GnLQwcHhbjFog8d4sVDcBpGZF86yWM44addi57NQxPyZQicjdLGkytnhOqFyeo84PmTD87WMdUXQIdclFoqAIlWCVrvMVxzPddKKft/gVnGKx+0OhN6g24htR6N7w/a+iuQM7tISd3ON2YqizWwsdlvia8XsmQ532qLXW4Y9h6ks/tolwrKUpmq/wGwHTFPS7+kp5na0riouggRSVOLr2x1Iso/eyLWubwfGyF23Fu71KDpLFuxK7qd+qVCNZvY0GB9zbKyebJFGn9lkhQtdXIzJbLLZjclgvhZxl+kRHqgXTmmoFINVtJfzSFUoWFSPGeqnrIwVS7F96pdSPCoP3SF5NC/G6MV5wq08yUgTITGTcq2bK1bEQjEj/jkAYEx4UokpuQclo/1+mSclbufgUa3EczipHChQSMFb3fYs33tCKiz+cJbPpcJt5eGW+FimYA5fye/RXtaaWBpCKR6ypk0MM+FRx0LjazPFeY50GtMJpaS+KUVcd2jxDxRQRMyFYf60p77hMX2kO3Di5EAWyvVijRS1rA1mEB9QaXJEbW5Cfn6VQpmdlzAKAhqwU0hKLCQIJRmFn0uMrR5kvRiPH/zxn2Hj8oImww0phvtALA2/63f8Vj7zda8C4Id+6KdY3bnI1CqFCoHkxLw+OuGhdvsQFlGK1EZP7gwkUF4R7hR57A3VCtwqSOpW5j8TEqmWxqN6UuE2QlVxK/HEViFS3u5pr1QUF2mKmratUCGq6xvUpsf0XgpV53YFalkIxUerLObMtKdBuPrSKCS6Q4MawHkY0Nifm1FfKJrLORjl6Urs8ebk6FOhYJW3WopnLgSptWLxpjtPPN6DmPAHFcPCiANEnydimaqSjDTefj4i32AzshqtiM1UdvAI+wG70piNvB+lEOQahRpyIevkpJtOpgovpEL1hXZ0Xccb3vAGnn76ad761rfy7ne/e/q7Rx55hEuXLtE0Da973ev4w3/4D/Pyl7+cxx57jG/+5m/mta99LV/0RV80vf7P/tk/yxd8wRfw8MMP8+pXv5pv/dZv5b777uMP/sE/+LH4aMCLherzcig/Kuy9oKgxiWdfP4jaVOUc45RIhZn6tBFVSFl92u+Juf5kR5UL0HG8Eu9yFJjQncz3keJR+KSjR150Cl+qiayuIpKKpQNDNKigJ3R1tNlxOa+bJCkm3d4unWeY6ymSMjhxCZg/63feixGxiXKK7lCjoxM+XExTrGK/TMTKyI2ZeZ96FKEkGedidmMy7ZMU8c2AajpSXaG95Lazb6b419F1IY52XsDtk/NJoao7GJp+uma6EH6pbcFqM31/GyXT3DaepA2mlRQcd9IQjuZTUalCwngZ+3q3+/ehMriVx24CRCMCIyWbtmkUPls3iShOVmY9QL8H1WmkX+psAu7Rg8ppRDJqpU7ZAF/8ONUS3LnDH85RQ8CsGspnwN1S6KTpDyybVx5RnmuSFYupZIRfFl++oLzjMUOkPTCEI0FNi7WMh0MpG2uxCiLKC4KcjfZLoOj2Bbl120BSMuL0MyUbpIVuX4ROtpV70+8Djd4hjXdF0hZn4jPaHgqNQA8JXQgv089g/oxQBNpjuVFjIa4RKijK08Tsep4M3JOvbx5Rjmr+pKQo1U4y0HVKmHUOwEhJAgUOJS7LZzQ8KSUiw0zBkWdVmgvVpQlB1SHvsTpv2OVYxO2ub3GRKC5CFpxkEaOSn12sAuFgLvduSkK/MORrIaiqWwn6OlJuTA/bqxZfK/YuWoa5oTswuI2kd4USukNBJd0mMrveESrL9ppjWCjcRlF0gl4Wm8TyscjsuqY8Gyhvd1MDPXu2I1otynKD2IVlyg95xDtZksEUFoBVU2zsDjkTFFRikaXoCkZhc6Ovezn3vspBEPm4c3IGMBX5erR18pHP+sxfz5v/1FcB8HP/5zt583//V9BtT6wLEWIZnQt2aZSHPaju3dJHQ7hdiJgnD2rG623PFeW58McZl2GrpzCXUIibw/yZSKUi22sa00QWT3asXlqxeGLAzw2m8cw/3IDWYqHVB8x2QK8a2Dak4yVoI04IXoReyRn5hSGiuoBqOszgIeyR7EKaFgPliWZzXw5P6WDvg4OgxWca7QUs6I4yol0Kn9QMmmHPUT6VwInS39y+IBUu29A5QpXTvbIwylfZ99gKBUuex4TdsktpK0RUm1yiOFH0VyPKJMob0O+DnydwURrDVQ4dWeRCt2EK9rg71vdjfbzQVP8XFxeklHjggQf4xm/8xuf83Zve9CY+7/M+j8ViwY//+I/zV/7KX+GHf/iHOT4+5k/+yT/JV37lVz6Hf/qGN7yBf/pP/ynf+Z3fyU/+5E/yaZ/2afy9v/f3mM1mH7HP9h97vFioPg+H8hG9HdDbTsyqt62Q01PKnb2T4rXv0TfPUHsLktMwLwkLuYH0IJtptCrHnUpxqwPCj8wbFDCN1OTf5e/FNI2YxEtxRMfEEkoWBVHw+oUTjl/+vQrh1iWlMOPmO0T6GZmfxIQi2kYQwVAK4hCdljF8TsISK6HEMJMEp+CKPBpNlOee2fUOs/GYOma0hWlDS3kkFOo0jZFGAVN0BrMKqH4Q1DkXUmoAzOhBK3w0NXXmgkyOqPCHPrjj5RwuF5LS08PxbAHA0zdvs0k9WoOvzRTVGSqN2a9lMx2kkJjEVUnoFCPSEypR0Be3WwGAMm1Be/A6gZUitWgEEbp4yJH2c+Rs3oRsL+PZUGXlfkSSkdodj7c7lHPg1rXwn714WOouoExBf1TR71nCXLGZq2wJlaaCp9vXbB4y7L93oPawesjQX4nYRtFctiSVmD25ZfGBgebBPZpjaQZMDzqnF5k+m9gXCj3I/6MGHdUksoiFjJOL84Q6hX6RSEtNvydJaSAIn90K0j+KonSA4iKiYmL5xID2hu01K2P+ShFmEKxYMqkkYRTVnThZYZkc/ymG4yJGFP9VMUIfRU92k3BrQWy7AwuJKcEtGShOwTQSC6uj/FuT7bXGcXHKz9/kKBDHZ4iMNMqG3x5ZcYEI2aFiT7NdKJIucBs3NSluK9OV9pISj9i1oljJ9WuPNboXfm1xESnPgxjfJ3nG+6Wi6mVUrSKsHtJUtxNm6xn2ZK3xNYLIpdwIFTLKDw6SMUQrkK3NiW3tsZlEbLYVXm55DuUFGJswmX8rRYusPaZhimPWfSIu1STiDAV4p55rCZZtwcbjbmGNiAAjFugXmm4ho/pPe/kn8+3f8XUUzvFz/+IdfM3v+9P0TS+uINueVElM8LDUhErTHSeqSy16q1G3S8pcbA0L+U8NEq7htkKf8jMzOUyQaQmjr3J9Eij3I9tPVrTHUjj6uaU8DXRHBdXNjvKJszzSTqKoN0b2hc2W1Lao21l4aXQukkGpCnxArRvoejCauL8gLKspqnr56BrSDLSdaDjJmIy2inApVLJ2mRZiJY2jr6RRSIUVrYQx0PYwq4mlI2VkPhS7tc01KafxCa1HEtB2ItpYZQ5rkfeGKx4OA/X7NcYnhj1IRZJLvM3BI4AdEdQo4Ih+riPji8e/dVy+fJmf//mf//e+7sEHH+Qv/aW/9O993ed8zudMllUvhONjXqg2TcP3fd/38d73vpc/9If+EA8//PCveM2dO3f4/u//fm7cuMErX/lK3vjGN/6KDNuP1Gs+GoceghSpm1aQ1BgzMV1Uu7LgGPm6dKjBo3pBCZNdEvYLGYUFpAAaieppV4CqBEGz85YUOpgcd72evGGGUk2jyVE9HSqN2YqXq5/JojQudNqrSZEcFFCLr+BIOzCtjF1TVndqLyEDwzzzZIdRoZ3QSTp6b6SAsC0TQqw62SBJ2UJHQRqkSA6lFLyjwEV+pgIL0VYoo0WprvWkvrd9yp85n4u797s8LUQLonrzxgk//2/ezae/8lN45UMvnZTZn/KJDwHwwz/1s5OZf78vY1TZzCHMDdVJAHapVoxc2lEhHXfXJtVORme9FGvRKTG8DjLK1V3EzyRONDqysEwR6ruy4TNX2c/ztevIPqlSuIjBtkEPilDV6K7II3M92TfVNwXxGmaCFhUXXsQ8Uay/glOoITB7VuUGRFGe9JRnHndrKx7Ao4K3T5g20h/YjHZL4SBJRtLQKNIkihiL1VDIfVVcBExvKE+iiASt3Ff1nUB55tncWzxnVDosxOsxVJbNkaXfk0z6sVitbsHiyZ5+T7h7ps9NAzKKZSWNyxg1nMKIXgvCJ+EAin6P7G8aaY71VKTqQYovP9NZnSz/ZhQ2jfSUZJGRZrqreB2nHUmKLpvpHKFUwh01SO55nqi0R/k5gqy8l9eWZ2LbM8wyL9TKD/e1cFDd+UB7pZIJSiENmVikiYemiOAM2/tqbJd551msJhxqRXMsFmB6UPjeCAq+TZguMCwc3aHY61Un0qiZNhJSFE/klNAqSnRxLePiMd1NXDsUxmSOYqYjoOUZiZnGZEd09i6C+dhIgKwB3b4VJLURUdwj993DX//ub2A+r/nld36AP/L/ehO9D6S6gN5PC47QJrSg3CiGp2t0I9QjFaVoH/aFSjK7KYl7SYs111DnJL0oAlE9CCKKCQwLze1fb4iPePS5wT4jxV19uyWWDneavU8LJ3uCVrBpSEMPXpwQaFr5rEVBuLyEuYhEtQLqkrSoUEMg1Y6kFeWtnvn5dhrDm07er5/L4tcearYPJoZFwp5r7CaLdJ34nCYN7bGlfMaIk4BSUBek2gmPFzM1LSqCyi4upk0Z6b6rEfPg70JS7WyAwdIfRIobmvoxxfmrInGp0CTolVx3n7naSZ6tUdA4piS+UI4XGqL6X/rxMS1U/9bf+lt8/dd/Pa997Wv5kR/5Ed7whjf8ikL1wx/+MJ/xGZ/BJ37iJ/Ka17yGP/7H/zjf8z3fw4/92I9NReZH6jUf1cNZ0qxCrbZIJGCCFHP7aKSjrgricoZet/L6wmKaQCwjw0LsQswgqNxYCIx8OEEMJctexZwGpASBU1qU0ioJ13McT07Z9nms3y8NSZcU54NYyITsdTiMI2X5/2SVVeSAAdRUnI3q1TExy9dq8tercrTkaMPSHQhPE53EH3Pf4IIj3takmUJ7UembNo/trfyuUXQihXMWZ6SEXxTowkyIVSQJ0kEGJrodd1D+r6aiN1gpQL/+297CP/zWN/FFX/DZPPrE0zxw31U+6eEHedcHHuM7/5f/Vc57L+9jHPfqXjZdX2lUkbAbKTrQu2Jy8hvMojQQ7mDKaK9po4S1ZOFBv9SoJH/XH8g4M9qEW0fqG55QaWJhskm/XBM/EwGDbYRvpkOi2xf/06Qh7VvcVnhgGEHLosnWL9lCLJTCP92/3RKNYvPQDLseKE8D26uW4rynOvGEyhIOZtJQNBF3IYWL7qVQbY905kqqLLKD4k4kOKhOBjb3FJMX72ibZboIWkIHUJHqRM6przTD/aWg7hdifRVKMrpp6A6gP2CaGLht4OD9cn9u73E50UeKe5uTo+w2h140QqswbbYJ2s8K9K3YsJFRUhXIaWw7n1W3ybxxy+5ZGpuHPAYdi1VBbPMkIPOkR2RfghfI6U9SHCWrGI4i1XVBB+1WfHi7PT1loE+cyWpHZRiV0skodB/p9mWk7TaB1UskTSkUiVAYoZPcSlRnkWFp6PehubKzSYpG+Okyhs33mSVHLCehl0Qoz2JuVKUJLu90qKahOO1wzsDCMVR68tYMlUxrTC/N9ehPOnJ1dRZJjmiqr4xYNK17EuLhOfGAGRvpNKF8V7qSv/Xtf4rDoz3atuPv/+1/xGs+89NIRoPV/F9vfy93thtCpadYZ1+JDkD10vgRsz+0UthzoWa4dcTXZqJnuG3CDJJap9uAbnoBHRZCjUkGqqcNsycV1Z0AWuOXEtyhth1KS2ofyxmpdKiLLaoxpKaBIZISqKqAwmFOt6hVD6U0mxiDysW6bgdc71GDCM+2L90XD26j2NxjKdbSCA9Lha8SeqMpT+X+6Q5GD2vheA8L8UktToEQiPOlIPL5fNsmgBaRW3mzJZaW7nI5oaoqgWlgWEgMapjJnpHOrfBSG8XyfXDxiKbbSxgbIChUazCNYgxckXVWJkl6gLKLU7rYi8fH3/ExLVRf8YpX8K53vYvNZsOP/MiP/Kqv+bqv+zoeeughfvInfxJjDF/91V/NJ33SJ/F93/d9fMmXfMlH9DUfrUP12UZkEJV/jqKRJBTnYF4RFpWMcQpDKgx6k/mSSsbsSRm6A0d57neIndohE2Iyn4u5PBpNd/k2ml5QgXHjHItHydqWHWQstpJyjEbXyUgRZZpEvy9CChXvGv9EWZDFUD1NRTBJCoCksyDkJOQ8dYngNL0gEcNcM8xls7LbcROUUd8wFy5aeScrRxOoPqKsmtAW7aVQUlEiKFlY7Ea+1lF+ngqJfmEocpjBv377u7l+64R3vf/DsiGqXHyHxAcffYrX/4Gv5fe/4fW85hWfxJAif+ovvYUf+Ef/O+Gsw+XiU/digxStKNBHu65QCnKncka3HmKmKehpXDkWGcnsit0wh+KGpzVAAOvl/IiyVvjEepDkmfNPLDCNoKbjvWDzOLjfk9HzsJQCp7rlJTN91cv4fVESK0M/k8005hH9aLMVasv2HoNbydIwf7IRlXDXY1qLXXn8ssCuevrjkqRFLOYLTXtsKVZBRvVWcsV9AaaXIiBayQwvr2/xlWFYmilYQgXxGQ6Z1jIW7NpL8aD7yOzRE7p79whFielg/uwg59UZbMvk92s3cn5HKy2dvUNDqdjcJ9DMyDPtjYioRFAk57I4l6LJbshUll30ajKgkHOveyY7HZT4yo6+rbDj15IpHuPzNHIZfamgJjsVjAVqYtiP6FY27Vjke+xCGjY9U0SvqM4T3cF4v2VazyDFfrQiYOv3LfGSy/ZSJie8ZbR2mdOPNkloHvfK/euPhDMUrSDxxXmgPTSgE2Ep/Mu2V0Qrfs52EzBtxK0GEfkpMOcNcWjR2wH2yKllci6CU1mklm2Kcu0hdmAS5zxOOWIxFi6aMBs9QoNwhlcdP/V//CIqwc1nT9A+Ydces2nZe2DB+9//OO9//+OQ4L/67Z+R6QPy7D5x5w7PPNsxLCWHPlpB/cxyIC1B3XFTUa6DUFNQivV9MimwXV53+ohdD+jGwzAIjzSIvN2tAoe/DHbGZIgvjh9ScKWqIHXDNFVTQ5BJW9fJtM05AVCqUv4D+R2ZOyrrvyI5LY4dpaO9Z05/qcoNSyQWVoSrg9wnw0zoYm4rxWS/D9VpmjQG5anE5rZXK+xqQXSaVFj0IKIue9Ghu0B5I2DWHSokhqtLTBspLsTxo1fZt3iP7NKiwCu8S6jOMH/K42eW7kqS6ZFWqAuLblWOLZZnLtpxP5PzNrhdhPgL4XgRUX1+j49pofobf+NvBGCz2fyqf++958d+7Mf4y3/5L2OMbDAPP/wwv+W3/BZ+8Ad/kC/5ki/5iL3mo3nEWUHcm6PP11KsjqMsa8XbUEnRmsw4kjMwL2Us6Qz2vGFxusXvlaTSijVIjrDUPjHUOi+EgqiOhauM7clRlzI6Uz15NJiLS58oMlF9zKBPJqv8+6wEtoJsFucxe5rK5xotQ0YT8fFIhpx+lK2EziW2c5gLUjMsRBBgt1EiYfddLqJFHJIkIGviUI2jn6QgZQRktObSAag0pov0+1k8sDTy/QT1rYA9bXC2pDsU4/Jv/Kt/M2/ogqSLr18uspWIrP7qX/+BjIxlfm0fsV1Ebzr8QUm/tNlZQRZTtwkMC4OKMpa1QcQcChmtjud09LCKTtBMt4kMtST3hAODOktgxIu0PBWkqriI9AeSDlSeJuobkVBn66e8qU+csCKBBXtTbJ7casDXjva4QA8ygk0KhkUuCo1sZEkxRXEKL08ze7ohkWiuVZRnHtNKk9UfWNTSZPR0fB8SxjDEXHzO1KTcDyU0VxUkxaUPrdHNwPyxNcNhweb+imoTKE9EUW+3Y2MmwjMVZZSsfIBCBDDRCYqnooz/Jdks0V9OFM9KgVqeDSJy0eLhOyxEeDUmC8VyvHYq+07Kew6l0CzcJk3nd37d4zaiAi9WhuaShFPoXuJmRz74MN9dhzH0YeShctfzpQM5pCDJOLy96/nroLyl0b0on+1G4lJNJ2P86FR2HRjtsxLF+ch5TVR3wkQH6vct/Z4iOIkKPXi/zzGXioscy3r+sPwuPYA9T5R3DGYQMRIImh/v6wlJYzuwFwrT5uLKR9pLwoMsTjuhDFQGekvSjlg74oEjznK2PBIVrNitT0nJOhYLCR8wXcBnigCMExPuUv7L77u4ec7XfOW3yH2XEqpQwt3Ydlz/wJN81Vf9WfzM4lY9uguEWQFG6EPdnsYvFX6eSAtRus1mHbUd2D66wN4eqSW7NU1G3nLttBdOb3Ey3kyROCtkTWqHHMWc6I4UzVWdAyEU5akXh4PCoFtHYi4obtPBqiWtt5ASymgoCpjPJO3L5ZAXpcQdRsn8P2kFIRHnJf3lGWFmqK83RKvZPlDLOrSVe7I7UPT74C4U9U2JQja9UIv6pVBmmqvSJCStwRyQlGL25Ab6gbg3w2zFBUINwmONpctpY5kWlj2uRUQHapA1IekkvNWkMGeG1SNy2rQVDq7uZEo2RkqD/Hlc20IFfhQKv3h8XB4fc47qr3U88cQTtG3LI4888pzvP/LII/zcz/3cR/Q1v9rRdd1zEhr+7Siz/9BDxUQqLJMowGjYW8g4fvDEnMiSjJYY0JCIlSUaJSEBMRHmBQpNVJJ7Lgp4lbmaaRILTSin2iGnIDYwpmPi4418RhXB5+LTtIliK4jLaCtkm4jZCq+237fYjac/KrOoYjfynygEWjZhE5g4q81VMZPWPYzikYkqoFUWm0jevM9cJNtkfqrJCKZPRJKgsnmkioXks8DMmWlMFF0W7fjsx+kM1bMtKkTCzKGiWPWMXKi7O3cRSSi60d8wCko1BiGYKHZQZIu6mF3GdBswOSJSeL+ZTJZtmXQXxMKnkoU9lZlTmAsXt4HeKMJcFvviPMo5WSqWH25Zv6QkVEYU2WuobnvW9ztML2IeP8shAlbeT3WSLXOsIJftkUYFMe5XEfrMHR6W0gyM/IiQU5Sq2wP2rEUZg9+m3ERF+qNSGiUSw56h2xfebHVHiptQSqPkazU1EsM8X3MPzQNztBmwNy4wJrH3rhZlLBiDn0NzYDGDWBJBRtjnRiyJKkt72RKcwuok3Nq5jKRVBHOhGWb53sDha52DGeQzunW2r8o/t98T0Yb2MgIdR41uk3LBKuNktwqEUtNeEq5rMoK6qpByEEB+FhlRYIhKENnRBcH0aaKAuGzhFXppPOw2TQVNcSEc5OYSqBaqk6x+rxTdcSmRmPuglnIfpCJ7FDdy/fp9S3eQHTbYqaXdRh7QZGWkX91JWcmtGWZivi/BAhlZLyR6ExTVo5biFOxavI/t2mNON8IFv39Bf1CwvW8mz0KCCsUwRHxXQKWzWXumwCR5NscxrkQeg1sLbSTMLG4T0V4aSRVzzGkfSNZMhVDS+e/yxKK408nYXWvivCJajbvo0RdNBgGKTCNQmZaRiGVkNm/pb1fE84LmvEJ5LQj7KHjLa4NQoeQhCVZRbrOVg4JUGPqjipS5rt63xG0glPJ8je4SQscI0MmHSIVDb/P73gofVZUF1DVUhaCtuTDEin4hmpI4K8RSK0+fhqVBe/FfVVERa5kq+UqSEPuFkvvbi4epSjI5c+tx8ZbpgmnlXtR+TFkDv1+RDmvsdpAGu7JSSBtFd1TSHhpByku55+qTSLKafl+mCOKPmp+NAdojQ3TSwKcI9tRit9Ig25bpHhppM6QRvd7tGS+E40VE9fk9XtCF6oi0/ttmt/v7+9PffaRe86sdb37zm3nTm970n/EJ5FBNjzldyUhnf0HYr/NoXWNPNtlqSThJOmdeq20nfFYScX8hAqOw442O9/DIjRvFSCkLOcYHPKmUv8xJSYppHCpZ1aIOHscq4yjRXQwUp7Lwm/MGtW5wjwdwFh2PGPYc3b6YH4YCRvGW2MxkM/dSilC7lc0oGgUZlRjtbSRhKBEHaGdJiqYgo3LrRZiSDCIuU0IjCKUgX2Pa1hh9qYeMIGdFN1EQmfZKhVt5+W870O9ZkjETp2804ReLIun+R6RMZUTQboN4LVYOve0xvRP3BQftJYOvpBgY+cHRgFGQXM6PT5o4Xh9kg9Z5JKdyHrzrEsHI73Nn2fM1KpqrZS5+I+WJRM+6laSB9XtivD1uMFwIz3Bzv6O6FahudxQpSvSjlc9s1wGztPT7hvpxGbkKoiy81e01jW2MjBljwjYB5cWWqrksS4aKY4ypojxJWVGeUcvM41VZNBeqHG+rkvDZFgX6gZL9d5+jb56jqpLuwUP6pcVugjRESlOe9OheXCiaSzL6LS6ioM+5YIxOisARDQ/Zbg10dreA0YM4VMIBBRF/zZ6VJjKUYDaSLGS6hJ9rKZJ8Aqvo952gqzo3gPnHai/JXturdhoV+zpbbuVUqhFJtC1T6ETMzdfdSHbIKKygklLgLJ5KzJ/qshBKi2csCh2EelKsZYyrgiBkvpLCfeRMi6OEOEK4tQgkR96pzUKbi5fI/Tl/JtDva/oZoPR0jcvTSH17EHqNDwx7YlWUZiWxdpg2Ud0e6A7FT9VtxXQ/ai2K+JGLmyc+BMBJ0Wo6WTdGL1s1pKmx1l1Ch0AqjNhIBSlIR65kcorUgc6JVRgNZZ5ClUaer86jUiLUjlCbLGDLHp01mCqgLgzzR+WcdvuaYZnT4jZx4sn6mcSpSlBKjpp2hpDpBMpHTB/ZXpKwCFaaiGKYQXkm64gEXxjchRTQymfXl7afRv2qcLCo5TnNKWLKS4GenBE0trKEykgcd8wNxsajWk+YWYiK8maDrSw+pxI198m1XD4eUSG7c2wHVILttZJooLtHGhU9JMqTnmgV23tLdG8ob3cUH75FchatFP6gpDsQAVcyMuES/10BPUbBoIoI/zQ3aGGe0DGLCiPYRgvSmicAwC4F0QmVrL4pXHI9k0nUi8fH5/GCLlQXC5m9nJ+fP+f7Z2dn0999pF7zqx1f//Vfz9d+7ddOX19cXPyK3N3/kEM1Hcka4uGCWFqSExK9ShD35+hukAXYJ9SmFYpASJmLlFB7siCFmWWYW0ZrpqQVKheHIiTZ2aNALrxGOhO7ONVoRGk5f7rHz01WgMsGEDP/U6OJlQMFurCofhDf167H3nL46mDnPpD/n/L70qjM0WTHX82G7VGNytA0IRJumwiDokqKTu3eu+kiakjZnkUoBsrISCmRN/aQN+W8MZs+F/1GTaIbkxTNvQ53IYb5OkDyopYW/uCI9sifzRCJhaY4GzDrLttCacwmTJ9XBeFfaS2fuT8w6BgzEqym9xsKs7PDGsecKnMwlWx+I8KphozmFbC+31KeCKoaS3EYECW8FGibewVBTkZ4gu0VI7yzpRQ6m4XA0e5CM3v8Qt6TyTeANVQ3kOx0t0Pu/Uy8NkF8dvvjWhqaymRltbgD2AbaQzXFPYZShEbJSoEWCvmswYlHYnRpQgtRwqNVM8fqk/YxDy1lzGw01cnAsLCEGokLvbUVh4IgHMuUBWD9fhaYtYK094scb1kp7CahMl815bFhUtLIJCv3IowImVzL4jzlsICE7SR6cip683RB52J4WOY0sXMoMzfabWW8KapnEfQUG/n5zbHc+zFPMvwsp/X4HQobskF/ebpL9qlvyQTE1wZfS4xpskKxmD0bp1jYWGTlfJcpEF2iOvX4UgvtpBRnBOUjwRkZw2ZUud8zmYMuz291J1Kc5ymHhjIHTnSHjnhpt54NS7HR8pWmWKU82pWCYvR9NhuJCR0dR8ax7eQ8onKkbp6ySIGvsserIcxESEpIIvxbOClmxp/j5ZqNfHZSEr/RvsesRJSHNqSyICwcXY7OHTm/2IgrPOrxApWyO0UlCLZtEqYV0VC/NHT7WaS3EVP9pCRFK1mb117xfh3XOD86PWi5ptrLvVXd6rEboX6p3pOcJc1KGbQZTZrVhIOZNKghYdZdtqXSUhjXguiPKWt6kBSqpBVh6fAzQ3EOKEmtcpuY7dwUiycDthU+eDSKcGBprhjcCvoDld+fZ/GeE3TnWb/8iGFP7v35BxsYAuF4SdgrGeYWMyRUEEVr0lqcH1KOkbYZKUmIaDgoxvCMaJBEr0ERI9ggHsCxyE1nHLncZPcCRcgN4M5W8GN/pKRIH2XE86P98//vdLygC9UHH3yQ+XzO+973Pj7v8z5v+v773vc+Xv7yl39EX/OrHWVZ/pq5uv+hR5pX+EsL/LyYUBPhj0b0mDp10WTV6QDdQOp6IdcvZvSX5/hFMfmGAhmuk581maxnfs9kxTQu6mE3mh+tqEA62b133iTWBcPlBbE0MrofZHMgRkzj0XfOoe1I/SDIxaYBfYj22QWgyMhCGhXxGXEaZFwWraxXk+F5JYhWLNTkEqBIzG4EuiujCliQErfyxEpSY1SUTdZtI8nJWDcUCtNk3md2tgE1+U0O81wkbwWl7Y40xYWnvNVKEVhZotUMeyYLUiTCMWlDf2RJh4bqqTX2tIE6R5dai93KOFhFUNkrOZSa4qyfuHChlAuh+2xA/2+ZS2gvCFNCzNt93LkkSJKLIMhuFSfrIVFky8gWZKNPRrwzu0OhM5hOodaJpALurBXkpuuIBzN0k0mTs1Lieo1wHsd882GR6SQ+0R67bL4fc+GpnpNEZlUiwWRBNl74yeNSgV0pdALdjk2LFHnaw/aaI9QwfzpSZDV+qDT1TbEP8gc1sdDYjadYB/qFwc+EH+ku8g2eHwNJxxl5jTmidJbQnYzzx01v5MCN6VC2FdqM9vL5QrlLkOqXO2cMkqDsfhlJdcT3RgRKhYQajFxK22SEsBD0drQl0x6xvyqYuLF3O27YjRRJKqYcPSn/tZekGPKjt2uS+3r0MD2/V0RSsxtSLOkg/GeVoFh5mmMHKbG9p6A91uIesMpNa4TqJIpYax0yN9nQz8cC3qN9oD0u2V6T4t3lBKtxauMrud8292hsI+fYdIk4cnhg5/EcmcSDo6grOaZAhGFhpAD3wlsItZnWMNNFohGUdhLIZZRWeS+WU1pncVISVLhwDEc1zRUnzg6NynZhiXrR4c8s5lxNLgz1rYgZZNIU9iyhVrRHUnTWN0du6gCDKPhTaQQ4yIJRiXlWUnhtYe+xyPK0pTgX1FS3Q9YkIDHZWklxrRSproiLklgadOvRXS5ohyAFrdGMnN6YhUW+Eqs5+d2CaA5Li131xELT7QuXur4ZmT/Z0l2uxFrNKdrLBncRmT/Vo2KJ9lDdaDEna4arSzYPVBCUUDIuGvoHDumvLmSN9wnTeNx5j507uv16J+psxihWaK5KcTo1GJnKZQZF0MIxN02mWGQP4xHASUrs1VAyIShC4jn51y8eH1fHC7pQNcbwxje+kb/9t/82X/VVX0VRFLz73e/mZ3/2Z/n+7//+j+hrPppHnJX4eUHMKuQxzlP7hBqieH+GIEIrn50B9peyoB3vEWbiVakymjciMcC0qY4cyjGK8G4fVRXHESST/YvpEwoFWqPvXFAMHn+8INROeLEoTBOEarC/EAPo/QXMa8LRXPwOVd78cwqWr/PvG4tilcfcdy1Uygun0m0CvtLYjCAVZ4HZE2uaPN8JhcKgAYfdDJhVL+fIiZdRzJ17KBNUWWmPcAYlclY+Y3kmzgKjRRAkCRQ4awR1CQXxoMwbYo76HDOytaBEzUsXFGcBdxEwqw76Ad0bbCuFngqCwo7XYpjJhouSRJ3oZJMxQ5oQPXL0bcr2X3jw2QBdjecs3nXeopjxd4d6EgQNcymCttf0ZL2lQ8LrRCoj+29v0Kdr2LT0Dxxw/qpjqjsD1R2fr5/w24b5ToxnOkiVFAFuI0ay/Z6YhaOZOJrJiEBjRKLL0zTxokch0Vhw60aQT7dNcJFpAwvhts6uR0mcOjDYTlC6+laQbPo9h10N2Vc2wEKKMreOVGeR5lhSqjB5IhDzuYuge0W1yXSIdFdTlDe7ZERQNZidQX+sFN2BoVjnh0shvrWZVuE2sHgGfCFCpH4PbKtw60h5FuiXmm6hsvguoTJvb3RnCDMgZA6rEd7pKDwxg3ztNiKIEtGPolzFyUljqHOx7EV13+2LQGbxhLz/fk/lFB95Njb3FHJ/XHWEWtEdirimuaoozxCPzVphhlwEx4hpI9aKjVUsNMNC+IZ2myktemxIpeHd3Kuob4p6fJhnoWMyJKwgvNk2WigXuUEfU4bibv0az4H4Iit0DniIxYhuG8bGRA8Rs/HC7wx5NJHFfGgtRapW9Ecl2/scw5z8exPBQrHfUZmB7kY10QGKs0GCIfaMjK8d9Adyc8+fTJQnHnPRQh+EGaEUaRB3lH5ppUAfhaubSLrwLB/dUnon91yQKQ9ALB1+6aTRN4o0LyZHD7MZUL2XiVNMQr8xgtoqBTHH9/YLhSJRnIvqtDyV86C88HyHvSKL/2DxRI9uPe2hznQlQXgP3tVQXt+iOi90r9OONKvo71nga4VrRO8QFiXD5RndocE2kfI04E5botPyOYasb1jJlEpbRDjVC60pjXtSvveJoNHCx27ka9OJYLC9pEgklo/H3HRlhNa8sIrUiCJ+lLkIH+2f/3+n42NaqL7tbW/jB37gB1itVgB893d/Nz/xEz/B61//el7/+tcD8Of+3J/jMz/zM3nd617Hq1/9an70R3+UL/qiL+KNb3zj9HM+Uq/5aB3CMdvddNGqXbJRShBDRgMEXeVon7Q/IzmDn7vsW5oXuSyGGDmpUzHDXQsCTMXqGBsKuYDM6nOxqLGkh4+w6yXmbIs72WKrYsej9BHVDoSjOaq8JiR+oD8UtaeoPMUGaiTTY3bvx+QYyZStZhJM+eMyumM3So9IzGdvhGeq8kaOInqLDpH5fMHv+m/+K17xyk8gWcUP/6t/xT9759tJOS9cDUyUgN/2Wa/mt3/ma/kz/8N3EvuEvVTzhb/7s3jFvQ8Qm4F3/Oz/xT/7oZ9BbzvioRFhiJei2QUtQqQWlA+4dXZnCJIEQzegmwFdWVKppR9IUhiH0khxbxSp0Ji77Ij0EInOZK6iIENRgyoF1YlJiqbZjUT3Mik8bKuwW0EH9z7UY1srXFCTEeNaigPtFdVJYHtVs3hyYPm+FdrD6acfs3z7bTAW2ybCzLJaWroDzfxZGc+6tcfXJkd3JmyrcnKTws+E9xizMl0PmYaSkUHbyj042Z7lzXgsVEcUfUQRu32mtJ/iQq7xxSWbE9RyITa3QqFIMt5VQ8QMAVfJjRxyQTl6CZMRHBQEO8ZG5uKwFCoESTZFlRHVUdg0NgJibi+iMLdONJekuVk+HnAbybvvFyLEGe9paRrlc1W3evpFQdI5CCI/l24jo+ShztGoQ+bjjYLCJKiiiM8SxiiaY4siEWrF+aHJpurSiKFkjIoXZH3vw4nFk8K7RgmSPFqTkeQ6kp/3+llxSyhPJDEsacXsfBD7s8Lg5yZHlSZSKYJCPxMudHnqiVbRXJHzkFSiO+Y5DXFS5IhW6HIgAeXus8pIN/Hg/df4fZ/9OVw9PoQEf+Fv/H1u3DgR0Uy21wqlwWw9/90f+iLaYeAtf+dHUdbyW1/3aXz6q17O3FiuP/YM/+xHf4bH3/MY2OxTrWXSkMqC/rCQRD29syyLdQKt2H54iW2EMlCeDKiQaK5Y4fgGuReIuQi/0aPXTUaBxWJPmnThivZLNaX1VTc9cdsRBo+pBpSxDEc1oTLYrUf5hJ+7SXA57MmURq16QVE74Y5iDalyIqYKSeB4qzJSL9z46iRl0WXEnQ+EmcOs2ildsDwVClOymtNXLRkWo0gxYVdid6a6gepZcSghRPzxnO09pVzTmP2y90vcxejK4XEXnu64ZPNAhQ5SoIc4hlVEQi7+xXYv5UJUqELKy7OWihHNYOIxh2xTV5/FKUExmjHEYrevvHh8/B0f00K1KAoODg44ODjgzW9+8/T9qqqmP99333380i/9Ej/6oz/KjRs3+OIv/uKpiP1Iv+ajdZjGo4ZImFvhHvV5Iwsxm0Rnf7wcCpAKi18WwtUqtRSqGb0cx/eQi7uRd6ryaHmM7ozjyC3z5nKhMCJeelAZFbN0h5b0khqzDditp7zVYTYtqguEwzl+Zon7oqKWTURNqJ4Uv0JJMG3OfU5SNI8k+pTRzVAx5TaH2oh/ZkZ7fa0JyxLbDSJEaiPFqhHKg9N81ue+lm/5lv83P/XP/hVv/KLfBsAHrl/np37x7fhKRkUYqdtVgj/whb+dvdmMYfDc+5Jr/P3/5c9wz+VjvvNv/iD333uFb3vLN/Bzf/B38jVf9HXE61s6o/DLQhZYJeNN5RM6jhzORHu1xm0C9iShty16UYIaixc1FWX9nhQKagCaNCF2QvdIOQ1GCveJsjCAHSIDGZ04T9MYfkw9On+kpDxN2UYqI+tKRmfhMBCtwehAdTugo8HvFdjekpYLVEz4mcZuAvXTDf3+jGEJ8yeDcPSWohYf7Wz6haaIAbeOmcawswyaUDEvNJFYKHmvaYemR0dGgnM/5eQcFivhaRarJIlZTlA+26Tp/o5WxvAqKUJl0Tahe7EDUqmks1KkDvOsVu6E2hFyUTKipj47AGgvRv+2Tairu/t2LJ70NlHfjsTbwpEUeoAWn9F1IjhNcOKXG53KfMo0mdSrCN2hpbmks1BQ0GfTZYu3THcZvU5H0/zxfAETv3tYKEGJlaK+HbHbSHPF0B7J53MrQXa7g7yp3xZahvBowS9FwKa9/FfejLmB0tmzVriEtpHks+6gxAxyjyYt43e3DtnXVBA5PSi6fcOwVPR70oj4LHYpT+Q+6PdEADW74YlOM+R1IJpM+0kycv+GL/8yPv83vZZ3PfoYv+OzXgfAW773R7nT3MlUIkFufaWpFwu++qt+D9/51/8hR1cP+Aff/Wf4N29/P+/+xffw4IPX+CPf+N/y//mGr+AvfN138L1/40dJpZsoAGHuCIWgdiLshGFfhH3prKDYCvppOinmmisyJncXu8betJkqohUoTfI9pEEWXQVKKZS3qChCreLMY1oPIYnQynvizJKcNMJJKVKhsKtueo8qiNWVbgehAWhNXMiER/nMdzeKWFhCJdxQkCjX8lz8a+1Zi+4G7JlCdZ5wOM/iT3me2kuO7RVBYF1U+L2EuQHmxgUMgbgohEo6M6xftpgmQMMc9CDrsuolhtnd2hLnBe3VGj+T0AM/U9PkotsTDvmwTMQyiUXV2AwWCZwizCPlTY1b50lI3tNsm6SQrzVxbwdsVKcBtdxRSV48Pv6Oj2mh+spXvpJXvvKV/97XLRYLvvRLv/R5ec1H4zAXHcWtDW25NyEQpg24OxvJbDZGkNSmIR0tGA4rhqWdhE0j/xPyxp92xSqwQ3gSwoXKY2MVEXuk0YNUyUY5jkB34iophHxt6Q9lbFSe15Q3t4RlkVWmgrCMv0cHGfOMQqSYEVXdycITszR6tMmZ0nTIFkiGnSdhJ0XK5oEZ69mWsIK2tJjThDtpoTB86J0f5As+/ctpUuJLvuzz8xsXkU7UsomDfL55WfGbXvUp/LW3/EOS1XzL//iHeeDaFb7vf/sp/tLf/H5sm/i0T36E173uVXzZm76cv/Y//wDEgO4iKsk43wwievpj/+0Xc++1S7ztXe/nA089zW/+9E9ljuPbv/Y7UEPg8v3HfMEXfBYPPXgPF2dr3vHoh/jxn/8FKdQKwGhmVcn/8/W/mU+8/15Sgne958P88//9F1jFXpKX5uMITJGCFB3FSio+lRLdgRR0FIJMuPWO5qEH4WvaXkZmQ9Rs77FUT6+xz2xY3Haobcv2U67gK1BBoS8a9t6vaB52DPsas01UJwPdgYwLfS3Xrd83+f4SJX1f7hS6esj3Vy5Kx/sijrSTfC1QI+VCfq6kcAm3VodEcREk/SyId6tp5V5oj4RuYFcDetMTa4dGFNfFeSDUOhuD5+Yoq/7NkGQs53LaVS/PQrFJU0gDZCueRn7e7EZgmEksJsiGKqP+3OA54bJO4kGXY4iLRHmWsrjN4prx/lcMFVn1r/DzHVdVLOMy35iMqEfh8Jp+h0QnIwK75VOR+makvWToF5ryIjtqFEz0Fl8bef+1FMmzZ4O4EJSG4iKSrBS2vhaxTygVzXEh6GcPXstFU9niyG485Mhi0wbaSwV+LuiqitLAtZeQEXKbEexexDugdrZ1Sr5vIlK4RsX3/8RP8+f/2t/j8z791VOhqr1cN92LtZHpE9oHPuv1n0ZROH7qZ36RdtXyZX/gGzl/11PQ9Sil2TtY8Dv+m8/la7/la/hff+RnWFUadyYq/2Fhp7Su+ZU53/Q1Xw7A3/mpn+TB/Uv8xnsf5l3v/hA//E/+Be0leMVrH+bzX/5aLs/3efrOHX7659/Be975QdwqZOFn5N77LvP5v+e3cc/9Vzk5Oeft//rd/Mtf+GWKSrizaC2NdR8JMdDds0R7WdvdaZtRyzw9SxGTErGwmE2HOt9Iw3G0JMwd9qJnDCmY/GlTyol1UJ1J0II979DnG7BGpgWZ99rfN6M9svm+TZTnggaHAvAa03qUj/ire3JPzjTrhxf4hbhlmF6asJHLnIyiuN3g90q6K9X0fCeVBZSVytx1PVnk2VVuauYJTUJ3ilgm7FoEmeOzNXKWgyV3NeKxbfKzZFeeKlvQvVCOF+2pnt/jBc1R/S/lGC7N2D60J515RhdCIakfdwcAxMLQ3bMkzK1MJJMUlDETzJ+DWI2c1dzJ3n0kZJy4Q1Wl2NAxZf2VoDEpcw5H43ogW6lodDC4E00K4gfY7+XX5SI4lGriyk7+qXcV0CrkMSVMXpOjkAW9e29D5siRpODRIf+noD+uCMuEaQJPXpyjnMaaXWetA7iLgAqK7TWdf4/it3z6p1EWjp/8l2/j4Mo+n/XprwLgHe/7oLy3IfLL73qUh196H7/7838r3/GW7xcfz1rLAl3lTv5Wz+v/H6/m5a94GZ/zma/m0fc/zg/9nz/Pe89WhHnBZ372b+D/99f+R/ph4C1v+UE+4RMe5Lu+8gv5xX/zPn7f1/9PnA9b1Nzwfd/2zbziE17K3/iuf8izjz/Lp/+mV/BHv/b38nu/5H/kqYtTVMpZ406UsL5UVE0CZAxqG6YUqe4w0R6LlcyYLqMi7D024GcGFTWzpzpBYUpNWhSkvYIwE8VXd2joP+Myegjsv7/B9MJFBOFSDjPZHKNl2uhHqy+lmVwH/v/s/Xm0bml+14d9nmkP73CGe+5QQ1d3V09qCSEhNyAGIZAALYMCBBs5tLyAlZhAghMWIbYF2EEOJqwFdiCIgIJjB2RHCzGDsBQjRwNqBEKoNaCWWmpVt7qr6lbVHc74Dnt4pvzxe/Z+Tyv/kJWoaNJ3r1Xr1h3OOe+7372f/X2+v++gPWX8rw7XGMyNMmbPLENRJabJBgGIZgK5GdG5tWruDJ90rdO1OZxJkLoOipQT7mpAhch41rJ7sRK3sDkwp8nKa3Ull1EYfPne45EuRsLCYBfjx/6+lfdUKuBVkFimbCTNwEyVuU7qNUPRBttAkQXI+Vu+ESSVoJQp5JJScbtRJ+vJ0COgfpa/lOt/NnwVWUN311FtIsef2JNzYjytGO5YyLaYJouxTkN9LcC/fWOPP3L092rGIyMM1/IACJKbIrAUi0cC2IdjMVrVFwNm59m+d01oFG4nu9xpvZhrcXNm9WrJZ6XodK+jBOWvFeN0j4YMTtYD7RWvfOohrpz3+T4eE3qUBIWEjOZVzHz1V36IN996yk/+3GfEvLi5lFgnpcjB8+TNpwA0bc3pex5wefEUvXCMJ26OsItWUZ/U/M6v+nUA/IYv+zK+6x/9c37sJz7BK0/eoj9V/JE/8PX8wd/y2/nxj7/C3/rej/Bv//pfw3/4u/8d/sr/7e/zn//n30J2mvd94J182//wF+n2Pf/Vn/1Wqrbm9/wvfwe/9w99mP/p1//HdC8tGY/E8OlxqIueVBuSsRIF5cWURAhQV8L+RoV9fF1qtRUcr0SnuhnlmZDKGpozZgiQMvW5onJaQOrOy/kAYZKNAmWJxw0o0ZjLNCfRBmnBi7Ws1/V1ZHjPnWIkBB0VYalK8kEqkzvF4q0edy0L93hP5GhSOqHo7gvb7rYCVqtBNhz7e6XmOoI/EnOg7iGVaML6SfEUlGtfohJF9mFvEunMlGmfltSEIUosWPgcQqrPjrf1eAZU34bDne9YfvKKeNQQGwtGS4j1vhiElhJL4k9bFOrguieLsaCMxyc2Izs1P+Aoo3dxS+aZyThEIiHtLSUOSingVpPUxLJObI8qBofYaHbvXhFqJXmo6sCg3WZoJzAy5ViqpGZDkOgAxfn/WXmvsnbOY2sV5eE5nCpih2Qtatlc61EeXGElAtwpPBrkXKiYyUpTXZdRr4Vf/6s+xMNHT/nYZz7DV3zRF0kVIXB5dVP0gYqrK9FFv/zCc9ijmvx0xN2Eklcpi/pwV5qQAMIY+L2/7T+gbzW7l9ccv+OEP/Pn/gOWi4b/9P/wX/Pf/aV/ANbwJb/kC/ilv/gL+IP/7r/Fn/rL/3e+6OV38Yve/zL9MPLnvuVvkz5zifqrmeN3PmAIokfTXj43X85JXEC/ktYYPWbaJxnbKbozhV8XkFgfPrPUZjbvdDQXmeYi4fbQv3TMeGRm8924EnmCNA4BStM9b1l+xlM9GVA+EJaWWDt0P8WVCYOji1QlNopgDqDqYPRiZggluks0ojoKmA1taTrrp9/L/yt1yDUVdp75NU/mvGQ0pnfU137a94iecmGkKjfqUt8rP1tYVmEKZeQtmj6Umke6IA/UKRYpF3CbFVKMUN7DoQTisKGTgg15H7pkGvuFsNyTJnZ2pWuZHsTy2iYg/Vk5kxykEmrS7M0gfvpZmu65FrcNNOcD7Vsd/YOW4bRiXIuu0u0z9ZVoIMezhv0DN49j56Y6JZugae3IhlKQoOb80uG0wiykVGFcK1TStI89YeHQXkEj2tj6St5vf0dRX8lGe/ecwy8FqMZd0WAbhS2MdknbEyPpeFiDtJdQ/2zF4Bcrhc6KX/trPsR//90/KHKMvYddR44ZgscZw1d97VcAcHW14dXhWs7T/Uqum8loqTOpOgCc7/3hH+M/+qa/LJvtFn7Vr/7F/MHf8tsJMfJ7vvFPc/74in/8fT/K9/6Nb+Lf+72/nf/nP/kRfvQf/wRf81u/ksWy5aP/5F/w33zz3wZj+K/+wt/kne95gdzICF/lki3cgxkT1evXOD2S1gvZuA+j3CRRPuBUGeyuB2tg0UgBwCigUAo2StZqTKg+409rzBjR24DZjyIVGKbq1iiLX60x+0hz7tm+VLN7wcpmNoPystEyYwbnSC/W2H3C7SPNmwNHnxqIlcav7XyPq5Cx55IEkCppoevuavxR2RyOUk5SX0b6u5b+RM3RUiCmVB3BryXPe/FGacsqIHxKf5iuiTwTJ8VkqiO6H0uj4ueOSPVZPNXbezwDqm/Dofcj5vEN5moPxpBaJw+kfiS+dJewrkklb1McrpKBOGWlZqaRf4k5KsaRmQFK8mCcmK2ZfS2ZndkcApWBAl7LQzjkWS93+6GWSkvSDF5/nkRIRpRqBp669HxP6QR5cmCXB68dDoB0Cu2ezSSlJMDdSOQeRlgtpfPMcMlYEWlFmd6GT9JY48ysVUy14qt/+ZfxHd//gwC0y4PemUFyScNCM96aI929Nlx2QUaPoyY5i+4kHmo6fvzHP8HoDPZGgMKHfvOv5PTkCICv+VW/jF/93veTFSxaiTP7FV/6RRLBVBpnmrrie77jm/nxH/8ZPvEjP8t3fdcP8vGHb8xs29SEQy5SCaugLYAxF4ZPa7LWM3M9VXSmLCH/tk+EpSLWLaHR8+c8Z+lm+X5hAWEFShu6FwzDiaZ9pFFJ0VyKyUYlMaiZoRiGCjAVkwMz8JnYTLSMr9UthlCVDUeqBNzAxBqK5y4s5DrTAVQWg9jyDU+q9MwE0oIOGuNFr2130sIzNecs3hrxK01318noP8jrHtcik0hOAHZsinu/nAsxpKh5g5VLacR0PSpVTGNWmMdUNNf1RSaHPMsz/EqVCt1UmoIO90usxRyWy706bTaTK382AVVz2DBODvip7WdiqENrilbRzCUXzWUs0w8Zt+/v27n6NBb2DA5Sg2laITm3lGgzaWnKWpFMJiwNfiWABErM1srMG1MzMschjUfCjI3HwrBN6QSTSXDKj00aTFDFeCf6WNsfFqRsNHFhhYU2Ii/6JV/4fs7Ojvm+7/kh7HWP2vYHQKYNf/K//t/x8vvfCcCf/AvfwraNaCvg069E20mYGvcOa8YP/fhPSfh8LRrb3/xLf7ksDaPnP/ndX3+oeC3Hr/iSL+THvu/H2XfCEf+a3/jl/P0f/Cv85Mde4WMf/Rm+4zs/ItrNm8B4LNmv9Rsd6XqP2d/ASY3ej1KDWrm5EpUM5rojH6/IjZv/LFsx1UrhRFmTtLj53fUozVY+oPoR+gFQUr6wqKBy6D7MenaJT5P30TzJhKUiD4r6Uv5svCcZqLFV9GembEglecMMeZa7pBTxK8t4pPEls1ic/mKIXDzyc5NZqkS/bffS9gZFn51g8UhSPnSQSu1YSSyf9hQJlNynbhOpno6ElSmyGCk9QN/+ZJ4dn0/HM6D6dhxaxjeMktKdTxeomz3RwHh3QawmiqX8ckuPmikj1+LindiYKeJlqpqMtZ4B6gQ2VaGg5iaoaTxfmFDRwhVTz63s1VweLtPrmFyXU3vTND5VMc8E6e3O+SkmaEoc0DGXHMsDe5iMgDEJjhZAWl9HdJ8wHajyM1OlC0MmrnntDwBTZWGetXgQ0AE+9IXv4+7pMd/9Ax8F4KLbzv++snYGSnUlbyKEyLWXBT+snDSzXAVh8oZDRey+H6TGNkP1pOfMtfP3/fF/8TNcfuoxyWr+6U9+guQUl/2WZOFTD9/g//p3v4P/2W/9Tdy/c8Jv/Kov5zd+1Zfzv/hDH+b3/4E/xT/6pz9GMrmAtSTnECFHxlaMa82lxAZV18yu31xAiOkl4sabjF9K6Hh/Kp+Z7cRsk41E90TLoXJ0hPqxPFh2716Slj2Ln9vgriu651qqTZAHytpK7WGlZnZR3P23mMGc0b0qhpyS61vMNiRwG9HIVZtENtLiJVpYNUsMkoXFk0Tz1p7UOMZ1Oweo2yEznJT6TEwZQctIPiwk07a5lLgz48WMw0IeeskcWtykM14u6gkcqlQqTaf3VIyBM9hy08RCgLjbC0htnyRxMC8KANNK4qKODg1W081hittZ+1zu8RJl5A+gcaqBnZISpg3BXEdb2puqzZSxCs2VnIPqJkKS0Wh2mvHYypi3jHVjVb4XsoG0/STbOGx4pnVnaqubs181+FbPenK/UvTvAXctAf2hmaQyElFGzjNgn84zumxcY9HCR2n+mo5U39K1Zolh+vVf8SH2+54f/s5/htqL+WhaIL/hT/+v+R/9O78RgD/5Z/8K3/qD/0hYu9NEPoo4kwnXjqwzdqMx9QHg9Fd9ueYy2StOl1L40u17fvgHfkKaAUfPP//+HydbzSsf+xS68/ydv/YP+Td/66/hSz70hbzvg+/mfR98N7/td/wGft8f+jC/9Tf9r7jc7Gjf3KOv94SxIxHguJbR/L4XMLluUD5CEN1rrh1p3ZTNh0zEktNSURySsJGdl2dHlsVZ+QhdD0qR1wtyU5GdRu0GqVpVirCw6CBlDKGVa7G7J1MFW+qB+5cjOSv0YBiWgFU0TyCj5vsz1ormLejff4/+XsW4FuOoirLuSNVzwK8Mu+ctfkmReIgkKdXlAZIzyzeRoopR9N3ThkyFaZOW5Oc99pIwgFQ0owx2t2BxMUjBwOfI8Uyj+vYez4Dq23BkH6TVyRpwFtWLTikeNwIi8uGhOWVRTiaqVD4hieKZqiJlURNtkYwXp4dgsmruw6bUdN5meubYKnVLO6cQcFkejhMQncahKh/YvonJzRqpfSz/dGJOZ3lA+TlSRqDAHpjfahNlxLSYGGR5cEtQuGSXZlceS0EeftMDXt0a/6gxYDY9TecZ79YMp1YecF3PP/3ox0DDxz/5Kn0/0jQVD+7emU02dx/cAeDjH/8UPN2hnKS2ykKbUEqMHdO4KTkBe2FZ4QbP0598bX4dP/Ozr/L93/VD8iA/csRaWm6m0eef+PN/lb/0rX+PL/uiD/ClH3gP//N/+2tZtA2/+Wt+Ff/on/yo1AqmLIYSnefzy2ScM5CtotrKg2g40YxTnedkIuoEmEUnDKbpxbVrewGvfqlmVj2Xzzu0iuo6YVtNco79OzXVTcL2CbuVEaR1Ao7MUNIN1Gd/zrFcK6lmziqdr3stY+HmImLGzLg2h39vZayolJpNFX6hGO4vpMb1gVz/bg9JS6PXlBUcawGE1VaYWr82+JUmI9/L7YU9Mn0mOWH+pCkoSzoEAhrNKKCzvkqERhVDiLCg0z2iA4SyaWouUonzkk2VbAqFARwK2zRV+045oSKDONw7M4M+sdyF5TTF/Ryn0edEON5isUMBkVM8GEpc+dEabJ+orgQEpTt2DrGfJiH6lpRBdRlDAfGGEkElpkYVS4GDmiQPlJg4+b3bAuh5PYiNAB9KvfEkmcg+z6y6iqAHuXaVntrVDhdKNArbSXasLpvvr/6KD/GD//jHGEcP1qJSIivF7/2Pfg+/+9//OgD+9J//b/m/fOd3Eo/KOrWM5Kjxo6wVuhjpYnNYM2QaJQkFsc688ZboXNerBd/+D/8xPN7I+tyI7CcDNJabYeDDv/UP8/KXvIcvec87+ZW/7kP8lq/7Ddx7cIcP/dov5Xu+7btFsmUt2dSktiIct1SXHmq56FXvUTc7aBuoLLmVD3ECpxNRoYcoJqluLJsPg/IlX7sfZH2tXGEwsmQlG0tuHOG0YbhXz9fORDyYgbk5anghUD3XET6xxHYyXWGccnozqcr4taJ5CsPdquTpHuRbkgghG8/xSO692IAZpcEtNrLRNgOkSpIh6nMx603mW7dL0gbWKkwv9191E0mVFuMYMknJStZjqZC95SB+dnxeHc8++bfjSInsPXnfkW+26EeXqI0Ezk8anWRL6091aMjxi8KeaXlwTBmoKue5h1oYGxmnCeuY59H6dMwROLfSAUwJ/dfFwT0B3YmNnXMwC6hJRnSRadKnFuA7d3nfYmpjMbjID/9s1mZqlDFjwu0lBF5HGcV2dy3DUVmkYp7BtI5iqBKK9dauOifoRvR+xG0Cy9c6vuaXfYiP/PN/wdh7VBCm5G9+x/cC8FW/8sswHo6qll/2JR8E4K/8zf8H4bgRxrHWdPcd++crYmsYT+w8bkpW4deW8Y4jHDf82D/5CT75M58B4N/9nb+JuJY+cR0yX/SBd/Mrv/AL0QHO1mu++it/KY9urvnvf/CH+NP/7V/nn33spwG43u4EyJtD65COUohQbTKuZD+OS814pNFDoL4KrF73rF4L2L24bXWUFpepgWwyqtjSSw4FMKSiLYwSmm/6RGqkWWk4MYx3HDfvq4VFO3KEpZWHyl4C7ZuLJBrYW0H6igMDf2AkBSyaAtjMmPGLSUuqiiYtU9/Iv5vqSbNR7J+TakftFXYr4Dospb411orqRgC0KV8zHonb2e4y9U0sKQkSrzNpTauNxH1lezCO1dcSpC8sr3w/M+S5bS0redhO94DbZ9qnUYBwJ9fm7vmpSlTN1bXTzm3aEE1MbSo1kGFx2AzGugDJwjTGqgDqMrWY2NxUiUxiXGe6+9DdzZ8V/6WjXLv752v6uxW6vGeVM36VWb3uaZ5OOoMJvKoZTLhdnoE0RYJgBubRb6xFezmBY7uH6qroobeHMfC0iXU7Kc3ISr5HdR2wfZmITM16t5YoMyTMZqB62uGe7HjH8RFf8MF3890f+aiYjkp26W//3b+Z/81/+vsA+Mt/7dv589/x7cLieSX5qC6TokLvjLz+PWClwndeiivJqw1HGUziv/sb38PoPXVd8eF/6zfI/dI4cmX49V/7q7n7wl3Qmi/58l/Ei1/+Pn7q0Zv8vb/3ffzH3/iXCMXItHl8VTYWmbRqSXdWoCSLOd5bE49aYYqvt1JZfGdFPF1KOsHaMh7b0mwmyQd25wWzakVqpJnMny3IVdGyrhekO2vQGr3p5GdXlv4dK/YvNISFnuUhUi7DfE2TIfea/ONLmjcV1Y0Uicx66VuTktjA5t2O4VjPhIndiUkxW0V3z9Dfk/KLqchl+nrTy6/Nk8zy9YjbSXmM8hG38bNBOFv5msWbo1wfhXyx20B9PlLdREwXSbX5nGJUJ43qL/R/zw45njGqb8ORmwqaClVVorMaBtRNxDwy+OP7xS09PcQFjIkuVcxD7ibMnesqZGwXMHtPNoZcS73elA4wPfDnLFWj5oQAOCxIYmqQnu6sJRsymQPwmLShU/zQxJiixa08AZKJOZq3PBMDVL7PFFMlf1DMJyuD2wXsPpWmFGELkwFfmFS3CejaSEyXU3zZB97Ph3/nv4m+BcK/5rd/FS9/wbt5/dNv8Bf/4t/ghZef44PvfRd/9du+U5isMYFW/Kk//9/w4PSEr/nqL+dv/IX/PXdOjzhZr/imb/07/K3v+wiVLWOxbSC0juFUE50mOw4B9gb6M4PtMuG4xoyZP/B7/zP+7H/5x/h1X/Fv8A/+2n/Bpx++xfve+SL7rudP/Lm/KqPdnefrfv1X8o2//3fzs6++jjWGX/uhL+GVT7/ON/+d75hlHyrlsgFJ2C5jkZxLbwVQeK3ZvdCUQP4kmkinMKPG7RN+oWfN6qQhVVkAaXKlXALmTN3YappXdqRlLYzYHRntgeTA2n2ifewlf7Nysy46OWFWo+PQMlM0mb6MDKtNpr7MDCeSC9pFIwB8zCXBQHSft3XTKh+alYxnBt62L41HC6ivi1ZTy9/P90zRSken5JoySmptC/ujy0NT2JtyHhQSxdSJEc2MIguQ6QTEdSk1iJKu0D5OjGtNf0e0scKCHTSuKgm7K5s10bbCQaITawG+E0CLRTs4SymmdAVg0npP5yUU0BqOCivpFUFJzml9eZi0jGuNX2pZK2phtNsnifZx4PKLSlNUl0sMViY0ai4nmOLH5mSOcr/Pd5sqaQclSsoWYBoryfStrjN2n2Xz44ysY5mSKavm8/I7/8e/gQ998Qd4/vl782f/v/19/xO2v+OG7/mOH+B7vuMH+Kqv/mWklPj+7/lhshGD1QsvPeAb/9wfBqAfRk4eHPFn/+i/P19D3/Ttf4efuXgd3SlMN8lPhN2rLz/7ge+PIC8y7evwM+Mb/ME//uf5U9/w+/hjf/Tf46u+4kNkMu99/7v48Y/9LD/4oz9FqjS9y/yZb/yDWDSvfvpNXn7vi1hr+Ad/93v56Hf9sORgJ0VsDQmR2/jn1ijV4N7aoB9fitt/tWCqQ02VZrjjiE42YCpKNakKGTUGUm0hRLSP6F6T23ouGxAgWz6jxuGPKvo7TqqW3WFiZoYsUqoykRA9OpB1kfYoxrOE2YHtFHExEQ+loc9/9nWbnExqFNO0L1NdydfE+jABzFakIO2jOBfNmEEyY3Nh0Kc3UJ9LpbVfy+Kv+4juPCpU6Ogx2wG7Hz+bpHh2fF4dz4Dq23DkZU1+cIcM6N0gVaSDJ9xZzp3fbhtwlx32qhOtkTUQInFhUbk4/2uH3hVTgbWoYSSHQD5aEM5WJFtJMdQUOg7ikkXPbuN5VHwrHmbWtFIMHxOAUAcJAikXWUE+mLVupQBMzM5kushWCE89jf8STOUDooOzmDGRrJ5NJmYUAjM6BUPGXQ3oPpIay8WjS37oB38CHSI/9JEfJVVWRng+cvnWU3Q/8lVf9ctJKfG9H/loiTyRcdrQDfz+P/pf8N73v4MPvvudDAQ++sorvHV1CS2opCFb3PVI+9oO0y0IKxH1/R//yl/n+HjFp996S8BkKJuK1vHqw0f8tg//h3zhL3oPL7/rBfZ+5Od+7iGf/tRDYbwrzW7T8Qf+kz/LnedO+KL3v5vlsuH/9Ff/Jj/606/IuLQtmYWVgqCKRkxhjBKWfCjj6DLy9itF6EvLSxJGOmtxclc3wk5IhNDh89FjhrYUPBzrwsaDP2vl2ttF6qtE90BDorQyabJWNE8GeWhZPbP9gOgOtWx2klNEmE0Wk5xjut7GY40KolOVVirJ9LQds9zEDHJuJy1lVSo7p8xQ22XqS2nQmqQsumhOVcpzIoYZE9Yq9CbPsVO2LykEY6Z5Kk0VoRVj2v6BYjyS82H3cl79mvn1TcDODJndi4ZxJaUIqTowRzLRkCnAuC4j0igAfgLxKgMSTzqXbkxjcZHHMEsN5nvPga8yKquDwUdJdqkeleTAFmmNX6i5Ujc2cp2YIdM8jQx3HP1dAGGVcxCjzBQpNxnlbH8weskIf7r3D6ywG0TakCxzBFS1FXmHRGtlYcd0YLPL4KTdzO4Tpgt85ic+Q7ruSVbz9779+4pZZkQNgYeffoNsNF/5m38VP/mxT/L0zQtZn4xmu93zx//Y/5nYGvq7MpLX4ZCTu7nsUFZAcXIShTUxwzdxyx/+U38RBfzIT/8s8ShidkY2Exm+4wf+Gd/7Wz7Kr3jne3lw54inT675+GsPedxJu1tqND/y2qf4HV//Dbz/HS/wnve/hP8fEp/50U/y2ideEy9AiMTjhrgwJB+k1a4PVFcb1NUWlgvS3SOmele/cqRKzktaG/zaYPcl/SAFskqoLhLuLBiXDj0mqvMOfJCGwOItylZDSvjTZk6/SFMkWlmokxMeIWo4/sQeu5drYvdSXZIsRLe++vRAdWXoHtj5PkxVBi/XWlbC7KsSMHA7LSbaMkUZREpihszyYSiNVmrO4o51hduJhEY7WTvsXoC9ve6FiR6D/PBiuNM3HaoyfK65/n+hNaTPGNXD8Qyovg2HGiJq10ucSEpQVxLQbI1kx3UJs/foPgqLOXi42haWT4s2yWiMNVIOsN2J+9Va1KJBJYW76EQ3uqo+qzJVgEoiKz1n46nbusti4JjHnHBrPHg4JtOVuqU/nU0X5YE7jSPLt/gsdnbSvUrge/kzqzFjktibSXYwbZo1pFY6sbNWfOb6kod/67vRm/18PnAlh9ZoCImv/soP8bGfeIWnT68ExO1SGX8JSPvEq6/zs596XbSmbTEk5WIe0AZyhbuB+kmHDjVhafm+7/rnc/2tVVPTkMIvDWYU0PdTH/85furjP3dINDAau/dFFiGlDZdvXvGRxz8m59nIzzajNGDlBlBaAHNhg0KjqLby97ZLBXRn6ATUDndK3FQnTJ4p8WPJCZCwg7xOHeT/uSlNTpWwlG4r31MBWU3azIwaBBTpIIzP7h0tKuW5CWoCU7Yr+tTpeYiMWrOWB5W0e5X30oLbHcbeKpaxrJa4nMkJPwX4ayTvN1aFHUJSI6bPcdJwToA4WYMdEvU+oseEKy1tZkioJHFJoVG0TyM0ulzPMNyR+kuVRWahx3IfVAq7g/Y8Ud0Is93fNewfQFxH1Bu6nHfm+2c8kbn57USOCXQqVZhdPzFS6qBdVRxC/6cUDDMxYsKU6hKObrfycych8KQnVUkxHAlobJ9mUpYR7fLNgPGZ7QNhU91GXoekAUikVqyUtNvlwyb2tpEqF9AzMcOmzzOwnupGyYrx2MyMmekCppEbWT5P2VTpMfEjP/gT/Mg/+1iJzEvE1qFyxlxI4H17dsQv/xW/mL/8X/5tYJIxZa77gW/7/n8s5ReNtEaZvgCjJcSXPNZmvJLlACXOczIMYeTvfvv3ERoY7mVMUlIhWrJ0VciovuOHP/2jsiF3Bn9SSVRSzkUiIaDqE2+8wac++bq0CvokINVAtqY49eUcJ5+onuxQ3pAri3/3GWFVYUaZfsTW0D4a5fy0GrsL2J1H3+xRXU+uK+KdFal1JGewO3H7J6vwJzUqlMiubiCTD59dRPT9xaAa21Ifi2L5ek/z1h58RMUFsXVcf4Em3gmkzuBfAH8nw+kIvSEHTdKqFLKUlI4mozzofkrr4FCr3EgJRnWdqG4yeoyEhUahSaXdzm0CmUSqhIipryNZZfJUl6xEHiCMshEzWUzgP3dA6rPj7T+eAdW34VAxooYCqJqKtKwJx60sXH0qFatyc7LdwzCIAQskjslaiFmY1DJCY70i3lmhbPkIQ8SMiTwklJ0YuEOTlEoZhYLCPs3mLc2holUf/kx++K1fM+iUZ02lyvlgnFG3/rsFYGfwyS0QPI2Jl6poAg/SBDNmTCya1daitLRzGS8PwFmjlFLRb1XomKBy5Lri7/21f8hrbzwmq0yqxWos4EAEtHYvL0rHTKZUGgqZStBgWg2qxl0PVJc99gricUtMetYJo+Q8mDFjxiig05rDeZt1x7pkyMqX2YmJrUDZzERa6ySAT96zIoeDVtkvJSaGwnredtSbQb5uNq8YVZhPCV+vbqKYjJa6sGW5SD3ke1ebxHBiCbVCNdPPyMLqanmt+3uHz8gMoi1WWkZ8E6MeK9HWqphnM9VkIjOjACFTMhAnRzmI8zcspu1MGXGbjBqL/OBEEe4k6DWmE9dyrN3s0M+6AD0keSI0ClvLZkwPnua8Q8c147ElF7lBcorunivXo5qBdmyAq6KLTor2cZrPeWg1fik5tCB6vvWrSTSXY2a4Y+jvSNmE9oWhNMLuVtsCJL2wyalSjEXaovwBDE5pGXpilHUxp9lS41mkNCopQisj9vpKXntoKCxwxvSweOQZTqWquX1LHO79A0u8Ezn+pFTPdnfVIdHDHV737dKE6X6dNgvT65skQe11mqOkUNCfKlYPI24zyp9P420n2a1mUOSVJVWSy2t2HjVGCRsJEZKAvnpR88f/xF/mn3zkx4pkYLoeLMOptHwB+ONEbCVsfjzN6DoSeodCIpaai8Pri7V8xn4FelSYXs9Oc9MLSTCNu1GQnf6s6ZHy8ndZK1S8lfmqFWlRieGp3Jt2OxIHD73EOsTT9ZxBqpJU2Y7HVphUpzFDpH1rwG7Gwix70rLFP1iBFpNVtuCPLLE+KlrWRG4d5qpD9z3UjkzGDonkYPGm6PNzbcrnpwltghAEEI4R5RPt4xGUI74qxla/UJgXRxg1obPYQc3FHVk+TjLQXMr1jZLNgl+KlMV20D7JtE9CkUxpstUyIUySp61ililhSFDLwh+ODMYodB/Qmw5GaeUy51uUniIjZIL2uXJMl8sv9M94dsjxDKi+DUduKtLdI8nLyxL0nJ2ifmtLdg41RqnB2+7I/VC+qIzucwGoWqN0QUoK2GzR+z0crwgvnIFyMj7ZBWJbMmGU6NBSAVnTOPL2HRarQ93hlBYwO3KVAJCMmlepSQc7O8gLGyO/+WyQOjG72TGXDkwROJNeNTZF9zZIe5AZszwUjIIokggVMnrqwV4v5HUvLbqXWB5CRCnFd/6DjwibeVyTGm6ZdDRuE7BdZDxys0FG+zK2rkBF+VV7qWCcViK7GdHB4ZfyZqZyBVIS4MahWnPW4ibIVnrjVQ/aiN5LztME7Mr5tPOETnSKTrSAdpJpTGzbmETHuRaDk+kPBqFxNYnWBCjWIUusl1ECEsaMKbFKscQA+ZVkz4ZG8kazgcXDRLKphOTLiH7STWctuaGhUVBYx1nvWYCyisLeThrZif2cwuSnhiqFsLe2K59BGaPrXDrny4PRPREpwm2pyXAsr7W+zsVdL0bC/syyfyAA4PhjG3FVa3Eyi6tdmCy/kms7lhioZDNuk1g8isTWoEKkeTyQWkd3z7J90QhzFKG+gPaporr2km26MEUqk1FBvu+cT1yi3LIR9tiM0/vUUnYQC3A3skmZDGrjevosD6amXPJIcxn7V9dynobT8jO1orqB5cMRdz3S3XM0m0RcVuyeN4xHGdUV4GgV9VWpXm1ELlBtMnYr10doCguqhGXOJWMVps9S4XZlXSnj32qXCbXooQnSMGV2HjMmVJdkA20UoZUJkvYJlRJ4jwqSiKKM5IteXG/5+3/zu8sJkMlFtofYL+WF4cxVRm/LlGcRcCYRvcLdiC5X+0x3RmnhyvOoWo+F9dsWA+lkCC0TiWyNAMiyDh2uY4X2kpeanRFGMIthCi/vWcBYRvtIVIpw/4jxxRORRBTQKxFjifp8wF71JRvbglFkZ8XLgMJeDaAUuneMx4bmLakvTbXoWsmZ9mYPOROeP8GfiDzA7CPV+YA/LnrVyqDHRHvjqd7aYfYBtBYy5LiiPg+QEtuXG/bvUTSrRHy9IhpN3ZUowVL4kp3IY6Seu8RcvQA6SuGEHqC+DGKK6gWQ2i4eNvBRkj9Uytg+kGtLWFpMH+Vc+FhSDZTkyirZqKgQwf28Ed+z4/PqeAZU34YjLirissI93UFf6vGQhQ1bZoX7TsBo28hYv4yQ8+gLKIrkWTuq5L8Q4fEldvAoYyXCY9miBk1cVtAalLMCFG8xq/DzR3yH0P85/3DSr1WyMOkCHicQkkwBXAXQzeBVHb4emAPARYt40C2KSF+RyFgvjJiOmhRvATotY2iVs2QpklHGkNqKWFfCegwGvQ/C8DpLqiypMtKIEyJ6iJhBowZPrgTMS1MRItwq52F67TK+12RbzYurZMQK8IwFcMfWQDGM3AbuE9BPZEzOKDI5aSkvQFixKd5pYqT1BOAKGzeuFbaAozkKijJmC8IYSeVnRg+JZMzMjOssphqRYogWNFuFQuOLThUg96o0e8k1UW0Sdh9JlZn1pfW1fK6hGDQmfZqKyHjeysYlTixhPLyv6VpRSbSP80i7aN+0nzJqxYyRNTQXGdt5YYIXwhr75UF7OR7Jw766ko2PjonQamyXcBupMk1OsX/nmlRradJZipt+PNaEWmQUAPU2Mq4FfC0eyet0NwG7lwshaWm1ms7PpMdTGfbPubnbvrmUbNhxVdjJcHBYx+aw0ciK+R6rbxLRymejkozpTS8JDnP8lxdAD8JgmnDYDPilbPCqm0R9KdKE5CTT0mxHbNdCyvSnlv1zIqSwnbx3t02MawF/khLCnHagUqa7J+H+ZjMxqwJCVBLGDeR91VeZ40+J6DY5yec0g4BjjJJQei/XlGqkcUjFjOkj5ka0liomckoS6dTUpQJUzdOB2OhSTys/V2K+yr21kT8Py0zTevzOojfCvpNgXJfs3yj3HF6qPOfUky7j9oWqTnme0mSrpWra38rWtdPr0nMxCwgoVUOU6CyjUaPsPrMGQgHr24BfS2RdrKaNghcvQl8iC0vEWW4sphhp9RhknWvkffqTGn/syFrTnHthHztPTgJ03TbNwFplRWw048KgY6J+MlI/3GGfbmFRClCc1JS6x1tClRnvNqhBET6+oNqCcpKGEZZaNMlVnp8XZsgSVaeLia6XjYHdZ+w2Yrcjfu0wfUSPsqa4TRDtfXn0ZWtp3xoku3qImM2AGoo0Lmc5p8ta1n2lBFx/Dh0JNd+fv5A/49khxzOg+jYcZphc+gpqixoDedWi9iOpdaiQULmBRS0Lng+wL0LO6fBBACzw/+Z+vLwRxk5r9GoBi3ZuZBGG1eLXtgCqPOsSP6sVqYz8VISc8pzXqEJhVaeQ5lvs4aSDmrSIMytxi2WddFPz/5eXLGJ/0QVOo+TQKgKFZa0goFBRk2uDqtYy6tqP6BhxrcMfOcYHa9z5Xlq/Rg+LSlpv9jKayoDaj+gxSNh5pQEx5CgEpIdaHiBTAD3l/IA8zHNhBMNCHuLzGD7KiZjzaTkwT5rCAKWMjgnVi4g3Nhk1VVbeAslKiWYul6gwM8gJjFUBy1aTp7KDmbUTVs72U74ohJoCqpENRpTPI9RqNsvFoqV1oxQCaD89HA5j/2xB9fL9YkPp7hZjUbJqBte5yuio5uthliEgP9+Mec6BnQxQkw55+v0EurTPbN5p6R4o6guJ6Nq+C/wqU10IWHY70d1FK7pIt82Hal5Es9o9V1FfpQMb7cXxXPdgq7JhGDIuSg6p20LzqAOjGU/qwlxGeSh7ZpnBpC+tbjL1+YCKmeFuPbd/TaYw08trDM1Bx+dXegbcKoAyhTEdM/WNZIRGxJiVrUJZZn33BJKTmfTBEke2fGPA9Inx2GG3HruVBqTVK9dgDNuXVyIHeCifl7seqTaJsGgkxN9nmouJ6ZMMzCkdQsLYp8/7YEiLtZjJslF09yy2zyzeHIS9XjsBrlYRvJiFplxivfFkqzH7EbxsBnJdFQmPIy7c/H6j03Mv/cTgUq5dZRQUA1AuzXVj50hXDuPla8YTzbiapAoCxm0nn18sBRNuG2V8nREmLwtgJiWSduRbcqjJQGii3Fu+1fP0So9eZFkOkQFEmXwQE8oHdC9MvUxkFG4vGcVqjGXzpkmN6FvtzhPWtZynzYDe7NE2l8DqTP1wM7vnUytlAcoZclWurTFRn49zQYvdZ9q3PM2rG5lc3D8BlOj8fWD/XMV6M5JbzepTkf6eon9fojqOpKuauFAl2kqeGW4HdltKBAyYLtI+CrhNKKYqjfIRf9pKDJwPxMpIKcBRhd1F2czURTbhikfjohNA6gspYwx53ZaLoZA2VsyPz47Pz+MZUH0bjrCqCKeLMmYXsbjdR7TW6F7E4nndEo9atI+kVUM+W8kDcIyYyx1sdgJWtQDSvO8++4dkYQXydi8L5aJCDxlUg4qebGX0RtGpMo0sM4UtYNZZzlWe8TD6Ih1GgMK+MIOaGaROo28KY5oBJV83sYdzS1AZH0kTjyy+0d3C4lZ2lHPbUGXxD9boQZgE1XmMVmSnwTloarLWMpYzCrv35MqC0eh9FAMBCnsDBIc/tsJuKjBKzfmOyQojqUPGlU5qs03ERhOWGuWZTT3BHILPZ6Dm1C2AJtWH8oYloUAYZY3mUMuZbwPWBM1lxqpyPsv5GtdaXP3FNIGC/o7Qo26f53Oqg4COMOlIkRE5WZi7jBINr50+6/K1FONSkXYkN3Wlq9nZ60oua6wl7spkSMXMMjvFp+zQsuk55NAyVyuaMTMeiSwhOXEUx0qxfckK6zKIns2vQA+Kesws3hQAEJ1UNepwcOPfvNOCmsxYAkg2L2kmU5PbZhZvBXRINEilrfGZux+9IVeW7Cy5FnnH7gV7ywQm57G+lvMt8UyZ9Sd77DZw9cUrYeALqLMlQ9T2mcFoVCVgISupGY1zEcOUb5mpr0Xv2t/RwpJ7UKU0YCoemGQiOkvua3UjLJYKEGtD/bRHd6Wmc4yYiw3+pTuSsevF3LZ4daD92JuEF88YV6KpnQxpY6mIXTyC5lyuOzNkmgtPd8+JaapMPab7fwLdppca4/6uxJxVFwEaS2i1gJUuYzcDqhtlAzOMYA1pvSDXMv2IjZ5rXqcs3mzVQT9bXOZhBbESA9UsGcmg3nJoI8x+dhn2atbTZqVwm5IKoTLVUDYTYxawON1jCdHJpsNuOk+bulw2O2NiPJaRtOjP4yyzyk6XfxNJGags/rTFVTJCqK+CXNc+YroCyKwmLWtJ7RgCavDoaGA3ovY9bDpcP0p9aAokp4nrmugcygvZQdtgrwfcTYXZjrhrz3ivRaFmlj4e1bD1bD94it15mjcUZj9w/NEn+HtLtu9ZkhoY7mf0E416y2COJLfXdlJwEZYKt4nEWt5/fRmoHve4G4/ZisY3rRtSLRmHKqSyCQB/XBGdRquynowS7K+LZMtserkulOj9qStS69A7iabJqxb/3DG4zx2g+nbknD5z/R+OZ0D1bThUgrA0hLpomrDEZcYMNWY3onwiLp38u1rqBVXMuNJOQkrgHPloSbyzFCD0xjnsO3LlxHmqlKQFBE/eblH7Paqq0OFYUgYU6NHKKEkpyULVU2MPc9D5pFXNGmIBU1M7FZO5YBpzZ1n0sy34tIDU2404KgCmsLh6kguUQPBJFpBuxRmNRdtqFNFMoHBiL0EHQ241SYG76iWzsTKSFdqNMm6vhaXOViolc2VFh5/k4WRRGJ8IK0dyUj2rR3GJx0oTSvVf0pAajSlsYLSgNKgsnw9akZRo2UQTyhxFJMYhja4KqxYF5NkuYveB2Gj8aorYKpRs2RjoEfLicP1kK60tdhdE8lAMTLYT8JYpfdq3QE2qJjmBIi/lYaNjCdiPav6+oZZxp0oyupuY7qwl6zSrA1gQ1q1EUpmpL53ZXDfrnHNhjSvmFALZ7BxAtRmKPrYX9ri7V4xmQaKFsoH9fUV9nVm9KprQWCv6M0t7nmdt4bhWjCfl8ysSg9DC8FzCXWqWn0pU17GMaw8bB6mDTagx0N+z9HeqObw/TpWbqsgWkOzIWMPyaaR57YbhpWMZ5afJ1CXvdZKI2E6YJzsICJ+KMlKF3Ku55BgbRXcmGkwz5IOxKh02L1Psm9tlFo+iOKxrjVpKxFs4quCokjXjfA9G6mZNL1rSrMBdDCilGe63kmrQywZm0n5O79EMuQD8g0TIDLmUgqjZlEYBb1krdi8uJHu4gli10qAWBOR563BXIoFhFK09xRTp17ZMasrkIZR4rXKvUdhwdCEVNVQ3YgwcTqdrUQD0NJXQg2wOxEAo2bf+GMwe6stbEwkfUYOXFJWcD5v3lOZ1LLSi61VhMgPlg1bTZyECjIaUhSm2egZbyTr82QKTNPWTPboLInfoR/LRgtw40lKaCU0XZMpmjcQP9iNJJ+Lzx+ghsn/fmt27DHon9+fyNU/7iUv0GOVryNQPhdEc7jeEI8d4InKgo5/YobuAP6kZ14rqUY++uJGNw9mC/rkK7SL5xUCFQj22xGVifKDRvaF9kgmNGE9jpaWyWSUWrw3Y6wFzsZW1MEbSomY8qYmNloD/UfThqTZlo5zQIZFzxt4MmJ0X7f1+LB+eguWCuHakpkKNEbVoiA9OcGhZH58dn5fHM6D6Nhx+oRlXBpUzoZLFzyiJjIqV1N2lslvMdgIHAoSM0xgNKkRyUxGPWrJWhDsNykvMhxkTyosbVT+6gItrWTCHEfX0Eu7dQUUR208lAMopsjHFM83cjGWmGJAsD0oSs9lSTcxDOfQ00s/MLmKUALwZNBUHOBwefpM2FA4sLpQH3wR2h5Gk5fdRCZtkx8SoFehiLkoj9JCSJVdasmGHPQRDdBa6kVQMN4okmrDaldF3IO+CjJSiJhqFL3mShXQjTOcgSIh87gTgRyuvx4yHhdObw1gXBTmWf2fA+jTr2jRJ3n8PZt+RGwtJtMBRBWnh8mlmq+dsWiOAcgKpEimm5ONwh/EkFCaoOoyLsz0Yo9xOAOkUCYWeTDFCh0smqZp76KfmIhWYq0EnrV26tckJjSItwW2yxP700gs/AWdCLuYlAVB6ZM7BdDsJpR+PHX6lSTYTK6lPra7lmt0/sGzfoefmLTHGFMc+AlLDQnSfqcq4G8Xq9TgnHZgSXaVSud4rTVhVpFoayGIlconmMjMcM7dEJQPhVMxfesg055Fwb01sbXkPGTuItEIAfRY20ZaossQsnUkNqB5yKCReBR416/0mADhpYYnM7XOSBys1uykLiIq1gLzkxDBTP+0hZdKqIS4sepSby3ZiGMNI0UZ1Y6k2kWQldosyDQmtfN56zKBkAlNt0syyc1QmBUrauXQQVlMHKXmQ+3nSdJe1IHo8oE2SmyJEcJacPGmQdS9Wck/bvoDBoOWmB+gkIUPkzIo0ZroWlNzmck0lSUeQn60IPlPtE3oTMKNBbRT1uQeti34dvIkYk0kuoYcgEVOFgU1pICiNL4yWCRL/lsnQSUaqPh9JocRgeE8yhqRL+kfyqJCwG0+1j5iLLTkEVCXgdLy7lJIGJ4ZHm8H4iN4PMi5fOOK6RmWFP1kwntQQFbb3DGuLil5ql5VC9aMkvjhN974zwpGT0gefMbsowLgbMFrRXETq1zeo/UC2hvDcmvE5JdLgc4sbI91CY0LGPZHvEStNtqKhbh8H9BhxFx16yJirHYzlYrYW5YNIim48dhcIK1emShHTJzKiv5UA/3ItxHjQBy8acisJLiokVDeSKpHKmX3P51IzVcoK9QvMeP5C57T+63Q8A6pvw5GmPEil5szRbBShUnPdpZocpuoA7Py6uCKPa+xRS6olrgkgGyPRHQVomFB298sWbkrOas7kEFG7TmJgjhcEp0XYX5d61mJumeoRQR2iWiZmtDBl05g6F7ZjAq2TbnUa0U2VsMrIqHmKvslaoVMWkfgc95Ln/EiVQBmHqxaEfg9MJ6doaKd1qrB3cZEkT7DvydEIu1lDMhGVIioGuOkKW2JK3mqAThD2nESwhbx2wqCU9zMxySYCXYKQSUfSVa8SqD6TO9FbxUaRfAkf10AEfCaPksM4KGbzymSqMimhu0AK5eGpZFRd6RblHLGwuGoUcJKNYjiV16iSjD/NxNaVMamYldTcJCbGLuQBXxXGKt76c/kruQazvEaSABVjyrVQdMdmLIxp+Qymis+JTWSR5/B+5YWdC205J7mYp4JoacOJvMbmPJcRuyZW1VxBOh6VBIFSA9qfWfxaTC7uRgCpitA+DfR3rbz+xAyabK/QA+SsiS6hNITW0TwebsUyKbrnW2Ij4DY0qjRqJZoLafAJrdxrdp9Z/fRAfRHAWvxRRTbiDBcteCmuKIkKseKz4qqmXdlUhjGN3c3AnE3q4mFzkbWct+gEgE9srLj0tQDWIdGfGlTSLJ4E6idixvRnS1TO2H0Qk1U5J3ra/Dgx41QXPf6kwe5Fb+kXZeStRIoQWl0qMRX1uTiyVWjZvSDxXqZPM6NPlhSJWE0ZvBllLaZakHcbog9E3wuosUbukXFH2jnZJBQtdSrAPHol/58gFQlEsDJtMWPZBBaQGh3YawGukAmrMsEYIzlE0t5grjLeKJLWEGQ5wEfSOELUEidVWVItmc0pjIRsCGWypG1huNX0uSW8TmBFf0soQuaAsIIpUemG+mKQaYKXdSwtJJpwivBKyFRE90FG/dtOplfXPeYpxBfWxPetWLzDc9Ut0DGx/qk97ccfQ0ii2cwZnCUUXWhYGLIFe5NYfvwcHRXhbIFGalpRSmRStSFVDnetiS8HeM6Tdpp0Ae1bid17NXYrrHV1lagvvBimbgZ0F0RTGuKBjU4ec93RVEKIEMXIqlLGXHfknMm1E/3tThJcJOILOFrI+pwSuZZUFrMbhcmOI6obGT9wX5q6nh2fl8ezT/5tOI5XreSBlrHaxJbBASBO1ZeS3zeN/eSpKmConXModZAMx4kF0LqE2ltFWrewfBG6EX25ga4nb7bQD+gYMSzpz5aS6XgkY84pGoosmaXTwzKXmkZgDvyemmzmHEp+3oiyvOdUEMFULjAXDWRgAq3+0Bk/hZzrqubsi34lKfry9fL3ujB6088zvvSy+4TpxNxktyNmOxwkBt6jKi8LutbQ92LkSEbcr1rDGEhHLf6kIawrwlIzrsRYpX3GdTJOVDmzvy8NX9VW8jTb85HxyOIXej5HfiUGHHcjLUnjytDfFXawvpSYHj3mmQUHWZTjsmI8thhtoWlwuzS/f8ksBJPAXARhjRp10LVqQaVZldPrQd0aR4dWPs/xSD6L5mIS4ckPSEa0qiokjDpo9KbrYAK9ygvjajyztnh28mtVmM4svfQnog1tnpa0iHKNS6blQcoh7K9cd26TGY8Vfi0VnSFCfQWrV3t2L9Vy4SjJzkRBf2ZlZN5l2qvEeCTuaX8E+TQTNhrbycO2vhGfbly6+b3HSnSwUxqCT1JJWl0Hspb8KrsLLB52NG/siScLCWtvtDDIVYn+GjNsE349NcAdihGm0HwzMGeOzhFu5RwLsyz33zRdiNXh61NZI2x/uDdNL7OQ2IoMQFjREpCfswBnZ6ivMvWVdK37d5zSPahZvdYX9j9hOxjX5X4a5bXP1/8oDLYaPEoZFKo0oZVpipriv+RFJ6tICfzSUF8pXm5+CXrdY/Ie/AZqDeslua0ZTxr6exXDqZpTNapr2ez4NXOslx5FmzquFM1lpjkP9CeG7p5iPJUw++NXItUmcPlBmU7VF5nlGz3xnQdzV6z0Qd8NLJ6MuMc7MUOpjvD8HeKJTKniwrC/byUVopiv6iuobhJuL/efyqC7IKArgx48U/oJgxft6JAKKgacwd9ZiDzj6Za0aDAhFRJANPTECMNA+KIl4YOnDM8r9GAJF7ZM1fLMOqucyVnQc7x/hH+wJqwMWcv0o31tjzvvyM5Q7Uf8vZVcG8NIHgP7990jrjTqOJK2mvr7DaE2mAeZ/csWeyl5wu4m0Ly6keuOiRnNxYCWoXKiL20q8qJGj5IP6+/WoDRmO6KsyJrEXJbL1weJ5GocqhOjcDSZUGeUl2xb+gFioP/iF8jvO5qnjp8LR5bb7Bf8Zzw75HgGVN+Gw1gx50zjWtPLyGzK21TpEA8FFD2nsB8q5hJQfxg1T2HVtovSkLIfJCojQ24rGRGvG+K9tRgEvLR/6D6SKysPm0FYkYmdmvrBgTkqaWJuptGzGGxUGZ0X5rEC3R/MQ5kJPHErqqiM9U0ZL8cCgAtA/awcUg3G1aimkViqWwyTqmRMnCtFXCuCLaNoX5itiwDbEVfSAXLbokyQSLBFS14eo55eCau6TZACLFv86SnxTkPjMzFptNKMlZp8a6RjIEJVzC3WgjqCZBN1n2i3MiIbjg22hspnnEnkJaTnDBwpqXckkyuF6jK6S+gxU513mDHTPVjBmYNRAOF0vsKiXANBmBwo+tOiJRVmc9LBQrZ5HiFPrKew4YpkRTfZ38nUF4dNgKKYfoyaN1DVJpH6w+Yq1mJgykYAfF4fqm8nHeMUCh9rhd1mlm+KZMKvmDvtdQR7KY1hw6maWXXbCYDNWvJK5UIHvwAVE6HR7F+Uh3XzWEoE+juKbDPLN1K5hiQIPy4zuIgZLCqIrrI705Brds9XAPR3NcMgGZthWVjuUc6Xu/FUV6INN50YbuLpCn9UFWBZKmVdKU+4AdtFhmMjrUmFKZ1A6DQOlyxRAV92L+kAbp+KIS+TjcGXz1Zl5jYe7eXcQMJtI6ERJqq6SQxHmnGtqRcWd+MlueDYSXbwLpbJiWb7/hPCQtM86bHXMvo9/BsDJa91XAsgrDYSY2V8JhzVKHSJwTqMI1VIoMV8ZnymuYz4wkK7m0D9ZEDtBlAGjs9k5F9XhJMWu7K41sq0qRJDnV6U+t+lmBvb6V4/UiwGWF+MNG+NVLolvCRZyUdvJE5fvSBXlrhZMK40+iij9hWrcy+xTo2GhTDRKpT7405LWq0x5z1uuEAt1lgsmsTQOFxliWuFAdwNVDpjFpm0RFrQHu2xj/cSIdi4EmovII5tgM1WogarsjFyDnszQIz4+2tSIyH95Ex1HlDeSyD/eoFf3cF8IrJ4JXDzxTVxrXH7jLuMmMs98c5CrhcFedXSvXPNeCyxWXafsbtI9WhbZAGG8OIJ4aylfeUC1Y/4F07oXl5Dqzh78YLNJ1bkoFFWY6+hOg+Sr4qifv0ac74tDwbR0ksgihKtsYJ8tBQfQEyMZ47xrMYvjTyfcDBasJrq4bXk7CpIRwuSzpjdAEMBrUuH7gN242HXk3MmvnCHvGpLRNoz5Pb5ejwDqm/TkZwwkNODHIBp/FoiR2YGq2jGkgGNIhZWS4+5gAUwQ0SFJEJ1b1G7UYKR9wNp2eCPKtHKTbq38vVu64vLXMDP3A9fK+qrSKwEHE1gNDlNzonlGwPjaSXJAerADk05jBLRlMXNfqvJJhvRrGYOPzMXraui/BrkXEzj6GTVPEKemKdcplYCmKbsR+YaTZVhOLWEpcEtLPXDDWonmj1WLWlRExcWYxV615P3PXm9Ih8thKnYRwlwt6VDPXFgsKcMzY65xGD6TJunkiUZFqJB1uHQHhVaOffVdcZ1MsKfPtfQarTNmM6Wc1c2Krlo/5w8wEOtCpOWZzAfK4nwolShJiej27AQoKmCyCompi65EoeVphzVIgUoyopJs5qtgNFphC+1iWJmC4V5t6Upa+qUlw+nbCaSsKm5xBkpD1qiH+a2rFRp/FKMN6FVc/ao7cRUpr2cc+OhuhJjVWyllSi2Cd3pOc8VlamuwW0S1+8z+DXc/ejA8ccHiIn9u9dcv89K7ucF8/sCuebq64R7mNi9aISFelLG2SljLneobUe+c4Q/XeDXVj7X6fxXYjabnPO5mMcmLWkooNv0qWiF9ZyqIPKESU4hKQzSTCbnRCW5L6cWtzwldMSiZW605K/2ScbtGRmlOmFW3Y3HH1Ukp1k8Ggm1YvsOR/PU0/70U/KqJZw0DHckXsr08jpiua9jLZFd0+sxvUNHRX8qMhfTZ4ZjTT415T6QjY3dRexeNhNmL5pQug6OVuT1ElImnDSkWsuUgIzxZaLjc0nBkImDLXmoYVV6498MVOd90ZlK9W/zFOqrhFJSXVpdB8aVE9PVJpFqaejKWtE+9qL3VYiZp2goTSe6F+1FQ0nJMQ2LKalEJkHJFZKhy9RvbCWTdPQoZ6HrD6Us3pNDlDVn2UgSw3ohgNYa4sIxHjuJBntjh77aiRzCyzqS2wp7OVI92pGOW5qHmeQ89cMd+mZLTkZc9j4SHhyRFk6itkrWr3u6l/H89Q6A8OAIfJD1cAikdcPui08JXxg5Otmhas92tFSfUiiXqK5Hjn7ocSEetIDdlEWXoVTRk04mhHIv9SOEwPiOU5lK1aowu5I3bSqLe3MjZqgkrISaIqdMMV46I1KBPqKutuQUCe+6S7p3grvxOD3MU5hnx+ff8Qyovg3HpNFU+cAeqtLMNFUxmiDd6JOWk6m73YIutZpTxqeMaUUbpIcobS2VJS1rzKYnLB2x0XOIt70ZxfByJBl9dh8JK4uOErmiQqaOErCth0z1ZCSunDA5SycRWV3AGan0m/RssYwA6yvZfYtOrZhxSsWeijLSTIVYmEDz7XNBGY9O8VbZyMNu6kqfmMNJGqGLo1n7g25ShzzHyKik8PfX2E2FudyJtikjAdlNRR4j8eUTxtOaSX87hZtPJpjJBDRrMmftLSX7U/Ia/bIuGY2qSBHECJQKAz29Bx0KOOqi4NHy9+NpJS7tLK1OFIAMkFW5PoqDeo6xokQbXUiXu18JwEZDmmJ7lPwbinQgL6QMQPXy9bEuLHU8ZGdOrJ+Z8nCVwq+kW10ivwpAXUpsk+iu5b1NeuWpjjcZeT22k0gq0dHqAsLESOhXCr+SRAK3TZgh0d3T2F7GvrYXkL17R8V4BHhpdcpGpAUk+f5hIRW3kvkI/k7L9kXLcCI7pPpSgN94pKT5CVg8iqxfHRlODLGGxWVi8Ugehv29Gu46lq9o4sLRn1VC9o+Zca3pTxVhqQgLeZ3jkSmfkbQ02U7SI3JJ4xDNqgD+9knCDLLBUAn8WvTisZKNrC05rHqUPNVJnyrxUMUk0ydiq2WzEyU1ITamSHMy/VmF2yX0zmNuelyC9jMBNjvZzLYN5nxLfP4OsRLNc2gPCRxTWYQp2t9sNMHBcCrylepG7m1pS8tFmqTRT0fRJwKmD2W8a0gnS2ldUoqwdFRP9sSlw/SyXsx5s2nS05bK3yETm8zizZH6Stji4aTCrzUZqDro7luyPWbx1kjzZDwYsoz0y48rI/dllE23HgJmCKTayWa/G6FtylqVCK0hLoQtl01BLhMhjd1ljp547NVegGlTS7uW0uSlrK1q26FWC/I4knXGP1jJeYyB3bsa9i8a1p8MLD5xDd0Au050rTnjzxbEuy3VhZdx/mktm8yTyH5V4fYnVJ8csKMm3m0Ip40UWOjE8s0tqveoy03ZUGXCiydSLACkRmLYVDBkpzmyO/y15fFb90nOSHKGThz/00vMZhAjrrPMGtSyNk8xiLKoKQiRtK7o33uGP6lK7jMs3vLoXsL/9eNr1Ohn41SupbhAZ0Va1Wit0HsBuypm0smacG9JPG5EnnK5h5P6s9j8f9XHs3iqt/d4BlTfhmMKwLddnmN+pqgeCVHPM4s4MTCTro+iGYxOQaWkBWSKJaqE0RjPGmJjMEMk1Yawlh273Uk7jHt4TlzWjKcNtowHxVwhgFhF0RVVT3aY605yXRc1hEBsHfFYhPpmEAmBIgvbGaG+DrMhgOTIp67Y5SGbAws4ARqVEVBTMjzjlLGai063PCzNZPAp5458AD85irtXgNYB+E7O9xQkeFqlTG4cejfIAluyB9XowQfs3hAbCeMOC+n/ngwyaIqWtkghyueog/w+WdERxlp6srXP2F5YURPkM9VR9I9SVSp/p+Mh1SEbVUL7xc0vDGee9XQS6l8+pwJSJS+0gAEvn9uka3TbNDdvxerQpiRtSUXaoQ7XVWiFsUxxAvgZvyzpE2VjlArbPm0sshFd5PR6TVfYwEbN7L0dpvehyMgYd/FoBBS75x2pUrhdYv0Z+QxUhOFEmLLqWrIfVc6l7SbR3TOYXkD76rU0Z5wOxzJKFy2jAp3ZP1+TrGL3Drk27F60srbPMv4va39YKPzasHveYnpYvTZg9p5YG7LKVNdhjiqaJg4sBOiG5cSWyjnxy1KwUK5jkTLkssnMkvqxFmZwKiLQPmPGSDaW/X1LNpI4IKCVOc9znlzEw0RCx1y0oMJumj6hE+jeS0TbUsaw7nwHmw5qB0YTXrxLWBqqJ3vMfqS+9Pi1k+ulmaYeUN0EhhNTkiam1jhYvZZYvT4ImGsN7iZg+og/dgzHVjJCd3JvKZCkkqMV/rQtCQFyM+sxkhor8WBRzyUSSVQZVJuM20TMmLAOqk2U6KVTw3ji2Lw/Ya6ljCIswQyaWEs1p9kH0albzXB/IVFeVhFCIiwMplNUKWNvelQ/yhqxqOcpSGwlh3nWzuticisMfHUxiPFnYSBEcizuxO1OrpdFSzhuCcdHpKUAYLvryN0Ou0msfq6l/fRWQGoodaY5kRcNqmnRQbH9gmOmuKbYKKqHGX09gDUoDKmVDV/zcIvqBmwM0A3yXnImHDekszW5rVFP9+RjMdjpJxvCnQXVVcRfVqSo8I1shtwmc+eje0xwwgwvWgGWXk6EyGEzqGLg0kqC+QtD6q5GFIckCnLCbgbMW5dSxFIauNAahUbdiGxCGy3nEcBa0ukSUsQ+3RU5kQBbKj2TBs+Oz7/jGVB9Gw5VgMCUFUoGd8sYlJwA0BTVnMFpPOWhKmyXKp+UZDdmaYHJoEMiNVKJqHZZok0ag+mjsGVDkIXAKmwfcU92QEbdXUnYuYKwsDLur5fUMRbX7Ii63mEvM/a6JSvwL50V7aKwKHYfxTzTGprLPYsnN+iX7zAeO9HZlagm7cvIXIkMQGnmKk6qAjQ9Ag4petcCErXn1shUjALZMo8JVTGXTRE6oZYfYhSEpSOvK0wXsOdbqCv83RV6Z9G9J7dVCekv7VjIAzlMcU9ZWEeTSr1l+TwndnwCggcNby5jfmlZkvG/QcHc5hKdxGhpL8ybKrrPWKm5tWlqvJpAVTKUukvZAJi+ZGk28lBVEaptnAFutZXvixZJQLKqAFxh3HwLc3tVeRhLK5eaf59L0L/tmUsBJnOP6JRl41Vts5xzhAWsNvJZ+JVEYlWbzOrTPWjF9iXH7h1yHo5+NrF6OKBSS3XjISf8kSsZwtLxrYNopJsLeX22E/A9roVJnMPgDfjjjD8W4NM+TahXNbGW9AFpYSubi3a6KYvp5zrTPh6p3twIsx0y7kbGndkawlGFXyj8ulyc04bKHM6dXxVjoJ8SCzTVtmxUFgJQq5tbJQvTRs5qcc/vc9HrShSYrpgD/6ckgVluUSt0UIXZKiz+GGdgk420/ZibHq42AjSsIa1b0a63jrhu0Nue5vUN+rk1/h2VXEdlkjAeiUlNh5I6UJrMlm947GYk1k0xLJbWqWFy/yfU+ZWIuOtKXpOzRU4i0wK7lY73bPWcwHBotJPNj91FqmsvBqtyv+ndSHhhweYlRcSwPJfSgfZJIQCy6Pjd+RZSIp6tpfdey73Vn1mShmYENUT0zX7WWE6sYWyspBDU0j5mO9kEuG0kK5ET6CHIv9/uhWkMJY4kJahqSAl9vce0x2gVMY+u0ZuO4R1r/PMVy5/cY5/uSr5zhdr2pMqRGwH/WWWaRwP+tCG0GVVyZNPJEnc5YLceNQSYxvL7XsbyGZLV5PtnKBL2jStoaykGiJF41GK2e4aXT9m8s2J0maYKknGbFe3rHdVrl5LXXVkBvV0vrGpMqKm5K04XY9FirZfQVHI/DhEixKXFbEYhCCbT1VCkIGR5HrXSSJLHESpbrhUnJML1hnjviO5dK+wu4Bea6tTOeb+fC8czRvXtPZ4B1bfjUPLAMb0sOqI15VA1eevwS1OCtAvb2ifR+Qwy7tdRxnyx0tgh4Rt7YCxjJpb6UxVEa6f3A6mtCGcrWUi0VBeOx5WA50YTlpLDqH0m3lmiNh7dj+IeKs7OdLqUxdVAWGiq60h1NRIWRQdWjBLuomc4dTN4u30O5tF1YfnSZMqa3M23jFWpGKWk3x4mwC4O8zKeNLJeCtvKXFggZhRVxotR9GGLWgBLbchuAb2wNCoLm0aM9Pdq+jNh/MyQS2i7jJWnlhwBSgL89CTXKK55XSIFYyUGFlWsocmUetNGQIbtMnoUYDi1fM0j+EkWUfSHsSqNRbuE3YdiZkowZvLKYab2sAIyp2SFz6rH9Vky+XTZKACUn2e7LNmsMCcNoCapg7y+mNTc+AQlUgw1J0Lksoq4bZGz7CW2a1wr3CZh+kD3XMtwomezVH2T6e7X5fMyZGOw+0R/R4shpC9Ms1NUFyPHXSJVMmKODYyVAkpl5rESEw6F9bqK7J7TdC8k7I0uAExG6RMbXV0F2see5DR2F8l1RVpVxMqgfZKx8dpINNaySFfKtTjFTOnEnOUaWmE9w0IipFZv5KKb9NRPB8zzC4YjjQ5J2NpQHNuNmRMv2icjWWviHTu3VE3GLNvJRje0UsMpFbtidBT5TyQuK/K6EjPe1Za861BawShMq950ZHXE7qUF9VLMV9JBr7itn01ONmjtk4jtxFSlfcad79C7kUoJ42sGMWqaXjatKinivWOonLTpxQijx57vJQwfGY/HhZPryCeqjWyw/FpkDas3ghRbNALa7HYgLC3DCyu27zSMdzKnPylSDu3lYm7OPe68E0364AnPHRPWjtiaAnojzTlkMvayQ6VMPG4FsHYSfxRXDWFhCK3GbRP1VUD5SPWZcxnPpyygbdGQyxRqKi6QTYLsXOQcJvT1SN5dwfWG9OCE6tFeMkzHKIC+y+S2Ynj5lPFugx01YeWEFb7pGE9lBKUSmJuR6rVrzM6TK2HHJXqwsP4pg9Gke8eksyX28Y1E/l3vyDHBdo+uHen+Cf7EosmYdSC+4XCX0HYjq594IiyvD6gQYLlALcuuzocizo63FnMgJQGWZWymGktaOPSQsOc71MVGAPxUSJOzsMdaC9tuRDKhfEJ3XmI3YiQtG/YfPKO7ZwGJDGuv8yGH+9nxeXc8A6pvw6EiNJdxblg6dGuXuKKYiU5iZuIt9rC69vODzHRRYpicJitNtQnE2kg7kC2MbEkJqK68sG4q4+8sCGtLbC2LT12jdh1q39P2I8oHwv01Zqxxl50ARqdhGEkatDOy802ZZKWe0W57om4xnZh4TB8AAcu6G4XxG281HClmk8kcMzXFo4aMnkCVYm68mkbskyFrCq2fxqDzuD8W0FWirg61rAIUk1M4MvVuJLWVvDdu/YwxQlAFxFiay0B17QmtwV2PpNbRPWiETVXldRQ97dRmpbQkGAj7JQya7ZjHVFOo/WSYUUXfmswEBAU8NZcSSC+sUkR3Udi8lbT3GJ/QPuFbadOaWr1sJxplv7bz82MuWZjOVdEST6PdiQUGec2hOPrjWupq3Tbhl3pmtKfxZyoNS3bIuCHPTKyE7+fZrR4WGrfLhX3V9A9awlLQ2PKhgOPunhW2sbRWSSybxu0EhKVKckn9UuNXNXaXcfvE0BR2tKJoESEshBWyVxo9JDGFxUz7ONM8Poz9F296lsU5XF16VEzEtSHrClvJqDu2mowpQFWyVCdpSrbCtk86TjPItRYb2Zw050Xas5DzUt0Uc5bWmD7SxEz7mRv0fiSerYURL2x3tRFTk1+XcoYK2ie5uJ0pm1a5/vVQroVlJUbCYcS+eU0+O8If1egxSqh7zmQf4epaAE1bS9Zmq4kv1piziv6OaIWhFDyMAo6rCzG/Tcy6SknqnnMWvaMtG6YMdjPKJlhlhhfW6DFhbjoIIr9RKcsYOibIk4ZUwJ1f6kOW7E42v+RcMjQT452K4U4lCQu1YvH6lBIR5uvbDPJv1eAhROwbFxBPSW4h57cxZCL9XYs9OS4VvobVK9dwM7UvSLxZrEA1CrPQVJcSXaeUhNYnqwn3lrLBDSt07zGXe1Q3zIY6dXFNvH9MesGyf8caMy4gVFSfkjgsQj/tudG9p35rT/24I5ytpNFKJ8LzinACZjAsfmpH9enr0vymUFqRc0bt5PzmlMhtRXzpLroLZCXscC7GJ3/W4N99Rv14IK5acp2JL3uyNyTkubH82RvMhZivGAo7v+sEWE7aLYX8Wl6HGKsyxIgqBkujkMkVSLnKlMUdhIVWRSqgchYJgDGYqz2z7tWXkpqxon2jx/TSchVrTfPm+Czw//P4eAZU34bDdnFmURQyagc9V5MqnyUnvinsyT5h+oRfu8LEFm2UUqTSdhNbM8sI2jf3uIseasdw1gqIMUrcsUW31Lx2g3lyLbtjY9BedvZJr/ErQ841ZixGkryUqs+dNI3oQcwb7qKXKCwrMSLj/YUAg6KnlYdaZvHpDf3zy1IRCqM7BM1PWZsTYyqZssxaQAAKU4VmThCYG7FmhpVZR5k1GCW6R+PlgS/aOk2qDf64wW69NEwVlk57I5uGlDFdQPtIcgZ32VO9NUJMhPtHVJuAj8Kuif5Kfrbpcwmzl2aioRK2y+Yp31XkEfJ6M5VnBjWT9i9bATtmUCUwvlSzZqCRP5vObaw0LK0YaopeUeQGGjtG3C6gsp1NWnJ+863Rcfn/8vqzgRyFkUSLgz86iFHY5OjkNaqUixRDiTbZFG3qKNFRWaShRYpRGMbZPAQE6O4WhrCcF5VFXxkW5WdkuRdWr43Uj/aEOy3kxO5BTWyKPjPK56symE6Aamxg+VCmFN1dSDZRXfWYYFg+VNJDvvcM91rqK4UZNM1b+3ICpKfdXY+gNMMdd0v+IFmxKkhhRZ6uzzIRmMbCySryIqOiZLWaUa7t1etJYtRKwkI2iupiwJ9Ukn05jCQnP7O6CbRPPH5l8SsnqQGdsNjCmgpAG08lo7W+zoVV1nP6QHYG2hp2PdXVIUpIVY48CPDLRqNSwt706Fizf6AJSwVRzaUMtpi4bCf3cmw09dMBu1OEpSWtGnTRf2Yl5iS7HyRnVTf400YmQo2mIqG7XvScxe0eWjOfw9QYSRBBUW0C7lranLJSxIWkd+ghERtTtMiytownYr6zG1/qg0Vek+yCKmdJanCWuK7n6LOw0Jz/EofdwvFP9lRvdbhHGX2+FWf+smG4W9OdaYY74Daa8Vihn7O4XYvpE81FIFnFeCwTpFjL2rp8rZFNwjiQyfgPPKB/95r66Z7FR7eYm4gapZgEZ8VcpqQQAWsJK8f+/SfEhSPVkJaQ2wb7OLN4paf6zM2cRU3OokUtABWlyJVl+IIHADRv3WBIZJ1hUaH6gbwQbZU/rkg24h/UNK5neK3CbjN2UwA0MC8O1szufBl5pDk9MJd6ZKakEmsFd9fFC1DG8yoWplcplNYCVhVSUjOB3LEkClCA6vSz7p0QlxWmj9jzHXY74oLUHT87Pj+PZ0D1bThUcd+rLGL/bOQhoCPoTliHWCJb3IjEjWSIWomh4GZAbzr8/SPRhY2xVK1qFp/ZinmgqfDrimygetqJMzXnA9MwFhqzqUmnK2Fcakv1ZId7vJG8Q6PJ6Yxw0lBdDOibDrMfpS3ELcUxrDX2co+/twRKfM2QGO+1Ei796jkmZexxLc5bJw/C0MjiNoeeGyXtMjDntt7W4k2AkOnPigs/Gw5j+CgTqcn4MEkJTBRtl1GlztKA9pHQGMa1vCYVxZRUX/rCBpUWJq3w99aFxUq4q5GsKsxgyE0ZcZVgb5XB7iS8X0bGxaFfIoPMkEBp1JDL655SHQToAjO7kmwpX+hFvxgXRvSqKRc9qi5g8Zb0wSpU0qQqz997isSaxsXZCMic2qtiw1woMYHGsS0h/CmTtLzO+iaJ9ldNmlB5pswbCyW63mShHsvnlSUHMyzkw5PNi+guoTDLRjEsBHxN43Tbya+xNezfJZmQw7EitorqWlzmotGV3F+/EvNUdS0bkv6uAKx7P3BD/eaOq1/+POOx5uRph70ZGM8aAcpjQhfavn9uSW866stEfT7i14bQWNwu43ZJmOZTM7ewKeR1mlH0prZP8/mfzFN2qt5t5XxVTzpSbfGrivp8oP7MlXyeR8tZqzpla8b6iGyVyGnammSRmkmlCE2JhDPIhisKOBUpAOxfXLDaSbJHOlrAMKKuboTtqiuy1qQX7pT7KKLHXAxCSlIUtLjss4JUK3IpMXAb2VwnZ6mfdKin12K0VGsxJvURdbmBbkAbjemd3BtGibM7BJS15HVLrm25z+D6/Utcl8skIci0aOflJE/XTAhs39Wye0E25Iu3Et0DAerLN4JET4WM246kYipNjUM5K6zx2jC8L9Fnx/ErgTs/0lG98hT31gaqivTCGeFd99i/0JCsYjjV+CMIq4zdlYkEUxqCZkwWFUqSBhmVE6HWdM+3rK47iGJSVcay/vhG1t7RSDB+P5b1wYO1xOeOsdc9adXAsiYuDalKZFei4q4y9ac73MMbSU4o7vo5wqq47jOZ4V2nKDT1q1fk2qIGT1w61JHD3uyJq4rrLz3m6Oc8/RdBeBCJry5xG4XdRZafvEFtuwNLCmI6pciQnJAqKify7QT6wooCoBXqZidg0xhZ00JZlFHCnjpLjqkA1fL1hyckaC2xXlrj7y7R/Uj12pVEf6UkjYvzQ+Ff/fEs8P/tPZ4B1bfhUFE0ZNkZUmslYDszj8W0F02fOMVL0Hslerb60Q59uSOcLgoDNJBLt7fZySLWvedUxu0Gmk9fYp7cyBoxJdbXRSDfSYi56kfUGGR8FFNxN2fS2RGpsYfRlE+ktip6OllAqtcuUT6Q7BrdB+onO9QoEgK96WHXkceR6tMKXr7HeFJJJ7pjBmnTuBOYI7eA2b0uvwEKIJu0lfIF3NKuykJ4u/HHL8U8IeM8yE6+cX+3ZjzSjEupcVUJQmOw+4CKRuKNdl5qFJ0mOoM732O6kSpn3EU/jyGn16oC2F3ADof2pWwUfqnQ12IIia25pce16DC5ujlkcBpK41Ghm7Quea6pnKNyspyMgFNdWFOt0FrGmNKWk+f826nydP5aNZnSps/2cM7VFPdVxtl2l2YDVWi1uI9L5NWcmYuMiLVnrnj1SzXXg05NZbE6/FuyMKGhEcbXdkVaoORz6u4KUJTXD9lIdJFkYIo0Zv9A/n7xmUBYGnGs18Jq5rZieHcj8UUK4rJiaCv29x2pguoa4lpaLfxSYx4KGDOXO2qrZ6bQ7mUjOG1qAGGf9lOsl2gY/cKUDYuGJNplSe6A+umIHhKbFx1hqXFXPWrfE+8fE1c1KEV1OaD3I2rf444a0W82wjq255Hm9RviuiGbmmQNq091tB9/RHzxjOFei0oiV9i+0wLHrH5uR1rWxLst1oB5eAHLlny0wNz05BAYXzxGB0VzIUYzlZG6Wa1mSYpxYgpbvdIJuEwZfbUjX96Q6wqzD1TOYG/Gw/3qhe2aUkv0mODBGWnZyub28QblA90718RGkiHsVoCXHoOM1p0GazA3PTdfsGTzLgE1asr73SqWbxVpSCOfVfVWj45RjJInjdROLwxZB6l+HRPV4x532ZMverIP5BfvsX/PsXzGR+YQ4xbBdCW9QgOjurUxM7hdwu4TekzUjwfGOxVhYSCEIotAYpa8F82qgni2JN9f4+8tcNcePQSUsTICHz3h3kL0pDGDF0axftjRvnIp63VpfsoxzgkBIFKi8X33ic8d4a68RDn5SNJioM3KMLzrhP0H7+BuwH3pwPq9e37utfu4NhP7zPpndmIqu32kRM4JpY2A1clwBiiU6GMnVtRJ8oGaR/clg0+pg8t/eg4pizKQvUeVhjn5pmWClOXv8v0TwlFF83Ar/3YsJqzKzGbbZ8fn3/EMqL4Nh95JDEpymrE47FVGYpyyjNAkf1LdclineSGPpwvG55bCOo6RVFtSbUgLSzaVjOmvB/SjS1RXopgo4xktAnUVE1Nen+rHslBkcE7+6emaeHeFionm1Uvsk638W2uJZyvGE0d10Yu+rG2oH96IQSImVDdiNgP+bCkPnps9aOl0Nq0lKz0DcNE7Hlg/ysg4G4hWQKROlLGzvI1sKZFKU/annNdk1czaAXMzFirPSQt4AbShEU2d6/T88MkWYiOLaVzYmVWNtbhe06IiNsLW1J98gr2uMP64GIYiagy464HkDOomFVChcFcKt5OIFVtZwklD8+o17njB9r1HTBmlrjtorvxSwM6UoQqFHZ30YRM5EYECQk1hPKcKV7dnLlkQuUAxbPlSuZslicGMxQhmZaytI7jrhNsJk59Vxi8NKsnIdTIqVTv5PqEYmrKRMgOUMKkTW2t6UDmXyCoknSGBnZuWykiwAPXYKpQXJlN7iCUeqNrIv1283hEby+5dC5pzMSid/Og13cvH7F50jKkAirrodxW054nq2jPeqaAY7WJr6B7U5f4qQPyoBi0GqubxgD9yEgkWFG6XGco4320zYVHisF4VF/hwqhlONNpDfVU0uSXqqb9X0TxKmFF0p1kB1jCetYzHjvom4G56ARcnK6onO/zdJbExEp6/Lz3pO49ZOFaveepPPpXPxxqqy5H+jtwYekRc9D6SLOwfVCyibCSH51eMZy3rH3uEGkb0sBI99VSwUXCI6H6lGnhqqMu1Iyxq7GUnNZmAWraYMaKuRzFmLhphMdsavR9pOy+A+3RRmrwy9Rs3soFNCcYGSESn8EeO5nGHudyT27qY2RThQQ3GUl1LVm1zIRm4szRDwXBkZCMXI2rbizmwMYwv1iiCgOmP99RXTyU/OSEs3/1TxheO8GsjGysDbidMJkhWcNaTcbBMNPQkcxENdHUzoDtP/TRTWSOtb8tG3PhdD+OIahrSegltK5juypc10GDON6jrHSkvBNT3mbhItJ8O1G/u0ZfSEZzbktOaEalATGKOKs+EdNxCHEUOsOuhH1FZCBGzHTA+Ut9fcfOlK7a64vy1BXYRib3l7IcvqT91USqli+Epi0xMKVlP1FSnrMr4CA5JB8aIIZWMqiQLmhAPVGNApA5eJFfYKfYlCdidYq7K4pZDQDU14fk7VI92AugnsOskA3auo/0cOORt/sIyvM8Y1cPxDKi+DUduHKmxxJJ5KaPnLPWclfSG5ym7DwGpyWpypemOlvJQzVA92or43GgZ/dcG0wuzah5fSVTJ7LBk1gtNWayHF5RuaT5H8npJrh3u9UtcP4pMIGdoxPWfzDR6RnRFlZGWlXWNuelRCsK6YjhxkFo4qbFXspi7p3viiytUgDiZkQr+mvSls/GnaM5SdWDtkkN20pNkqoyf5zzWW41WsRCSqmRNqizOa+0z1Th9cRRH+rGesz9NL6Po7n41yy6yVoynYgBxl6L/VSHT/uSbzMaCErOilg3VwwvmIOyqkoV5GFEpUT1WMHh0TNR3l4zZSJC+kxxVyViV9qpQzHFmSAWcCsNJ0duBsJoi/VBzCoLt5f1lqwiVoioJAtM4ddIHI99yTiJQCewoOs+sJZbLr6z8DHMrfaHohJMT8DDVncYWquuEGeXP3S7P+aKiD1Tzz73dWDYZoiZG1/Wy0QhOXtvENJsB4qomrCzVlae60cTKsHvfCX5lsDuorqB9LMaf0Oqi8xSmp34yoH2mu+fo7mh2z8nFsnh1z+JhR3+/IZ466nMxAk7XnYoifahv5JxP2l+plFV0dw3bd2j0CM15KiH/An5UFLlEf9aSjCQf2CGRFy12H4gLYSO1T4Q7S2lM6wLjqcMvDGaUpAS0IZdUj/qtrTQL3T2WqUdKs8RCIu00my84AVU2SbtA94F7bF9yrF4dZp2hP6npT4S9n5jv0EKqM/VlkacYWL42YDZDGasn0rKWiCJjUbtB4t0qLSzaMKL7gXznhHjSzDrT/X1LdTnSXG0F6DpL82ZHtYV0JHFZZjOA1oSV5eqDNaHVNBeZ5DJ+BfUVc+uaSon6YsAvrDDiQyItamgr/EnNcE+65nUaJKHgrWtxnoMwk2cnpPunhJWbM4JVku+frWzgAMJCtNZ1cZpLk5zcL36l0b6mehKxF1vinSXjC8fkHKke3qCshq0SidWZSIj09U7WgpAKcAvkAgbN5R6nG+xWY7eBpDOqskI4FNIhWyvgLkaU1qRlzfiBB9h9pPn0Df7eUqQ5bc3w0pLxuZrYgnsSsYOiuh4w55rmiweGyuCeWOx5VypwFRgrIFMpAaczqCwOTOSaF2Y0M6UMZKMlhkxruC0fSKk8Y+R6IfsDiNWa7EOplC7g2EvOqjo5ElNvokgdYtHLivaYZ8Dt8/Z4BlTfhiMuHePa4nYRv7KzYSbWkqPodolQQpyTUeS2GH3GiDYKuwvo3YC52JCORStqdiPJNeV7ZVCafO8UtSna1GKWmkbos4B9nuurg2vzeovZ7mG1mCNI8noBiwZ6eZBUN15Acoyo650ESF8WKtPaYjTQZFPhNoF8nKk/c4lJDVmvZvYTigN9atwJkKzoKM2YDyP/yZ1eDGM/PxUgZ6SCVhX3fVlQVWFjiWKmgkMG6eTSFL2hmK5irbA7WP6c6MpS40Ra4cXYYW969M1epBOjF1YjyaKrYkKFgBrEkEMsAd4xyoN52hwE6QBXxhSntIwRxcAisgqYzschukxN+ZNKpA/W52JgCejrSFg7/FJu4UmzGqsy+h+KaamM/nUpIZgezFO4umTTTqBW9HhmEOY0NgWYZaQ+0kt4fbJSc+n2Wdg8LTpkt5UcVWkzUkV7Wl5/qXl1+yzj/Sxa1lgaribJhmTils/ZyHsZTh3N0wF72TE8tyIsHP2RxfYCNqpr+Z5mHxlODWGhGFea5mHA7D2p0ridITpNfZXK+45zCkR1OaIAv7DESmFTAYqqOgCaPBU8KMajEmF0qdFBMZxI0HlzHucKVOMFpJPBdZnxpKbKYJ5uaIKMClQ3YGIktmvCWrJMQ1uSEBSE4xo9COiMa9Ez+tOmkFCG+ioxnMiGS9eAkk74rDVx6aguOnhJjEnTfRxaPW8ylm8GslZ0DwzmRj6/0ILbINXMCszTmzLeTeTRg3WQNGrvxVTTjWUcLc54tR9RTsL33V6jsyadHaEfX0LbEu+sSmqALtMSWeuGO5bxRFOfyz05rvWhIKUSPfLRpwbqpwM3HxCTXXIaf3cxZyi3D/eSM9qNqKsNuRvFRGYtnJ2QFzWptfNkZ5ILjcdyDU9teGpuyTq0v4WFKffWVNIi4H08ayFnqje26G0n4BK57s1eNvxq3wuJMB3Wig7UGagtCQG55npEDx58FD2oteTGiYN+9OKa94Fw2oqUjExaVujdKOu9Nmgc7etRNgFXA/a6w25W0NSEf2Nk9C2rT9xgzrcS2L9aiAQs+fnl5RBQxtxiWI08P0IZ608sZ3kWkZhJDaKw3BSpgtJSHTvVsKoCiEGJnCFGsg/w/BnhwSlmO8B+QA3D/D2IqcgN/mWetm/P8SxH9e09ngHVt+FIVmN7aUaZ6hKlTz5je7nRdSXVpCpB83jEXQ/SylEtyZUhmobxrCGsK9yNF70QyGhaQX7HHWFpawchot86n12X824WDgCVfGAGi0aVmx1z/Mhmh+pH8tESe7HHXneo8+sDSzcBssoJoLWG6ibSPOoxQyLawkSVB5HJ8sBPWaGUNJ1MjKA8HOT1xKYAtPLS5vF/YVEnNnYCM1Mr1dS2dLsGUpes0KkQIJaxoUR/yXjQ7Mc51koc7BF12YspxAl7RD/IzwwRFSNUdi5LoK5lVDcMojubzjfcChQH5aTxxew9lRNtXC6tXLqASsp7lmYphXJTQ5P8lTemlAZUEk/WaPxSHc5bMZzZiQ0t3z8XsCoMtpp/1pTTGWsBodKYlTDbVCQDosf0K0tsdAHCxQTUC0DMWmpAk5URqttIhetYzHNTp71flh77yAwSUjEqzQ1gdgrPF4ZYpUx0sL9vyLqmsRrbR4Z8q01JScNbqKG6StRXEpvmj7SAOmvxR1KOcfypgWVp2ghHDflci5muj/QPGvb3LfV1xD7dwDDiP7DCr+SaEgOVjPHdJmC7zPJNNVfGqiwbsNXrXqKXCugHqVgdTjR33rxBvXmOiZnxpVOJw0yJ4czhF1IEUd1EiRbyHuUz/YMl9ZUnHNViuIyZ4cTO+mwVS8NdnqQwGZ0z7nyP8pHjVyrMxU5MOcsF9WXAH0nd6vqVLbGxhHZBdR0xQaGyIdRIbeXoSWdHZKvRNx3qejsbZsI7zmTEfN2jb3YC0C6vMecJTo5g9KwuKuLZWnTuRyupGa0NYWkZj+U9mO2ICoHqOnH6cU/Wiv19eX1uN0kUZCOC1oS1NI+ZYsDTPqH3vmwAM6obpCs+Foawqgjvf560rEUe1cd5M2j3eS7iyCqDkQ1hLtLKrMUQaboAKZPXFrstFayVgDftM+amR59vClNYQNkwop5cyloaJ/MTZGfIjSM+WJOPF9htoLmS6tkMsqmdJjM+zGYqlSH7QFw5aGrMVS+bTC8GpXh3hX+wgozod7WietoRj2r8SU14p2G0jvDEUj98KutYiJKZOo3UtT5MhXIu/IcRsG+MbEiMmcGq2uxRKPl7OKx7U65szlKiMUeNWLIJhb1lvpZUUxPuHZHJhJXD7joxoWWZgAnIPciknh2ff8czoPo2HHpMKJ9IS2mNqW4k0mnKRo2tlfHtIAuPO98TjxrZ/eeMO+/w95bEpfRWu40nthZbTFjE0lSlwFmFe/P6ILyfQGU+xIXMkoDJcTQhl8KMECOqcnC0lEX26gZV16JnnVpYtCZ3HfSD/IizltUbNwLarMGkRC677ObNrYzoYsSvHToLiImtwi+NmBfSNBqWeBxFMeJMILQcU4bpBEZVATqfZRSKyAi0ZFNOGa7TCFwc8qLzzZXBXQ3ycKqMbCq6URiP2pFXDTqLDpcSbq3GIFEpCnLnD/q9umKWXMRSr5iSMDptIxmP51vMxqHvLRiPXWm4SvP4NtZSgaqSMI4iA8g0l7JQB6eLs97NTv7qOs9pAHYvdZqhke8lEVzMTKtK0qEegprBfGw0lPzR4VjjdsKYmmHqcZ8C/xW2RCaZQhClqhijesqUQJXXLX82bchUUqVDHmG2kyQmxEY+3Lkq1AuAmOp2U+lc788MaCUtQVpY83EF2kujV/NU0jDqi5HqRqMGLyCdolfOCdN5MSAC3f2KbltRbSLayoO9vgq0b3To6z25tvOGyO4z7ZPI9iUtlbNWo72neToSFobxyGK7JBvImNi91BaWTxi49olUku7ec8S6D6hcpB3Wyr1T2FdzKdml/V1pj7KP9jSPOzEb9Rp13OCPrGS0bsQ1n7XUIaNgOBbWr74KqDGiUsKdd5jznTChPuDeuub0qiIuanJbE44sq4ee9rUt/Qsr2bztRppXr8XgUzlS6+bRc+561MmRZH7Wlny2wDiDefh0vj+4vJHPchihaci1IS8bwrqWjOBYzH5JJEP5yBFbSQWo39qj/JL+niSYjGeiG9UeYm0IC4PK0D4NuI3HvXEjRqzjZUk72Mqa5aUxSi0X2Ms9uU/gDKH8HD0otC4MdrmWbWH6+7vM2vfYmjLNybgbT/VkJ/FQTY0/refcY46WsiZ0PbkboB+laalyIhtpG5TW8m9ixm1GclDF3OoFYIcp2uQw485HC9R+JIdAWjjGd55QPdlhbwbi8YJ01BCXFeG0Ley7J+eI0iJxsU92kDL+S0/g0rL8+IDdBWF1QwGB5RmRbwNNpVEqQeVQbSPaW2ulWltrsrOkpTTJmT7KtC2lw/pXalTzMEpygJX7STknG7Eom/o8FcpoIAV0H4RBnsiT6TH12f/zr/y4NZv8Bf0Zzw45/r8CqldXVwCcnJz8/+Cl/P/voX1CxUR13gsAOaoOQdXIYjjpD92Nx58tSK1Fj4nq6W5+4OmQcdc9agzkVSUu7D6ix4i76mXRvNkfwpqLeerwQm4JFlOS3WqRDdwWtqOUMKXdiDKa9NwZOSb0puiQrJUxkLVw51gA2PWAvtqKBqvIB5TWmOs95qKMgxYtdYyk4wXhpEUHg/bgV6a4/w+jeVLpoS9mq4ktPDRVIbt+cwhkvx1rlawAnLGS762LqUqPk75TtMCTqUa0w4KWcuPmzL5w0qLWNWqMwr7ueqlPNJpcV6jRy3isruScFqNBnkZcjTi86Qd5kK9LYHiC6sYTGzuPHe0+4JcCXtFS2eiXeq4uDY0ums9cgvgz1Ya5kIDCLhIPuai2kw1QKsUSE1iEaZytZnNTaOUBE50UJtwG/tJNn2cWPBUj2pQGMAE6ifMpTOogFahTdNbsHi4A+XYTUrZlkzIg9cG3jlRC9pORKsyp3tZtkUrYhaK77yQ66klHrgzmqpOIJqWxTyoZnaJQ774r72lE0uoRAAEAAElEQVRMxBp6a2jPs2iTQ6J6JCPRdLpGexmH19eSzyvxYeLG19nQvSjmp+bpAEoTW0OsHNV1kAQBrahuwlyVG2sNbSOj6ShB7ckZed0bAav1jaJ9NBKWlv6FJe1rG2l/6nr0dYf/4FmJ/IqYfaB+GjHbEUKgfv6IVGmqRzINUTFhu4HcTwZLIxvJZYtKirFuQUlOs8rQvLkjVUZKRZYLUuPAGhnT3+zI+w5VVeSFaLdzilRvXIs5008xEpCHQSYI1krD3SaQ2orUtORK48tkSUXYvKsu+l8wvWijdVLYPrO/L5uyXKYMxss0qDkPmEHqoFU3iEwpRPTFTTFslXSTtpF1DEVuHcnJjlXlTPPUS15re5DdKIr5LxRjYsnStRtfGuFkrSUm4rHUVtubUdqiuhG12QlALmzu1GIlhEEZmVuLEj89aj8U4Bpn1vWz0IlSst44C0mau9qffko8W5MrRzpqZSlvHHqINJ+5hJgJa8d435HurrD3auw2oN7M5I1l+TNl0jaB0mmClhEph9aywc6JvGykoaps+pQ2qJhIq5Zw3JCJmM2AebI9vP4SazWF/ZOT1KSGiLIS+C+jBCW61NINXn/6XNZH5w4bnolFNVoY2mfH5+3x/xFQHYaBv/7X/zrf9m3fxkc+8hG2WwmXXq1WfOVXfiUf/vCH+bqv+zrquv4FebH/uh7aR+xmJDtDOKpl5LX3mKcbwt31zIhMNaZhbUUOMERy5fB3GkDhrgfsRUc8akmVlkUzIVrWm72MZbadgKMul8iYXIBjLhl36dZ459aLnP5uAq37vojqkeBu+KxFDa1J77iHQoBNXDhsDJhzqc3LbS3yhH6cR0CAPFC6QNXdiB60MtjWMt5tJMw+HJhRMwp49ivJF1Uw61ZlxF+A7aRnLQBqijGJ8owSkFbMRdnIw86UU+KXVgAEzIH7WddYpYitjLxJGu002WmMNXCyFAYgIzpVRE+kLzeAdMSr8tCM735OJAgXGxjFEZ0WDtMFzFbMKmFdyUhQK9w2MR4VOYcu7zsx08qTq18lYZ6nBilTGNDFG738DFeTjMKUgoXJKGWKGx8EGOZKAINf6sJoCpBXMQuwCwcTVJ5G/yOycuTJOJVxmyjtUJ1oryeDnJhzps1ELv3xScwflZinyFBd5bmlSkw+AnrjVBxQNinDUkBvc5FRSbLLYq2KdtRibzTutXPRxS0X8j67HnwgvPMu4335s2wy++cU9WUm3SjGE0OqFPa6wVyXEe10HXYZuwscvwLV61fYN67Z/rJ3sH/eYYeE+Yxn/9KS/QODyonFI2FdVdks+rVBD1IiMJ41VBcKNQTCSSugfhMwC01316K95uRHLjHrRq7xfT/fO+riCnu9pFoa0X/vR2E9C9CpI8TTBXrXw82W5D2HhocswM0HuJGph91bwtpK81NtqJ906JKbrMaANlqWCIusDVrLqPZmj73eYWM8RDGFKCkApYVIckRHeHol8U1HK+yiIh41kmzSy2bK3USaC09/vy7Xnqa6GiX7+LSS5rZeNKFuE0TacjOI/lOJ/jW1DvPWFVlrsknQVKLhrBwsZZM5MYe6D5gbT1q1dA8KSNVl7VCUCDbZnMVG0d23pFpTXXlyyoz3V2if6J5vZF3pDWYr9bRyfuQ+Uqsj0fyPYiQywwhjf2AwnaSMiHGVzyIUZqZxWqNLRFNaN6IdJovUKEf8c2uyNTSvb1GjpFGYzYBtDeo8YUfoX2zovhDqj25xjwfZYHe9gGgEoMvna2QT0/XkyhIfnMpnlRIqF2PtsiZbg7mWa4VQQPYkHyj3ucgIbsnNciL7JP/W6MOvt8+BVof81RgLhzIRK/HnPbD+1R7PNKpv7/EvDVS/9Vu/lW/4hm+grmu+9mu/lg9/+MM8eCCNGI8ePeKHfuiH+ON//I/zR/7IH+HP/Jk/w9d//df/gr3of92ObDRpWYlLUiFdyE+3KB/RMZOiAECzHdDbnlQdAcKihiMZL9ltkKaWk4WMrDUlcqqMrI9aWSzrMp6fwOltbSocApljmEc8gHzN7fsi57JoTDTY9JfTSMaI0SJn0r01+nLEXO8PIvpdJ47PFOeRUH56iWoqGC2MHlNMA1pljD8lLm0Z75WQ/lKfavfMRqusS1ZnKqxc0aVOxywLmAwRHozOM2jSPmMCkA7NUWg9A7RJzxmbhmxkrJqsIjrR1pnWllacLN9jOcUdJbI7Frf4k+uZvfYnNdkZ3MJhL3aoqw12kHDwtJC/UyGju16qEFtDtYkMx2YG5raTlqPQFkNBntjSKXNU2M76QsoLhrVlXMuGYspipZA62SAxUGPG+FzGqpnxuMhP9nHWWKqYS3mBnJep3je04PaJ9vWdsL9OsnfD0pYGskwu1aNTjqsZob5ONBcePSb2z9f4hTBWbndgw2Mlv7pN0S4nUF42GP0d5sYsbhJHP7tjuFOzf6Eu6RGFYe8HaBvSsei78Q3s9ujrDntdNKpLg31SRspW2O1sNeOJoz3fQk4Mp0LV251nPJIedlU1xJcc1UYihVTMmP1I89iwf7BkONW0j+XP+ztGwEyAtIb+TLF6Haorj9726NaRtZ7bv6pNwu0zqbbYzShFHYO0pOVxBK1xNyMKjXl0JakT906kwnLfozY77L4X9n56sPsgzNXxEVSOfHENPgr7d7SQlri1Yrhjqc7L5ObRpUQeOQt3jrCdEjCzXMgUpZgFZ1BKMd8YI4Hu1knGZgZ6qRdVRmM2fYk+ciirMQOY3ShJFY3CJlnTpvSG0EByec4dzlrhrgbc0x1TnJJ/bl1ynoXJZSvReCxaqCvUpiNXjv5Bi06gtgP11uPvLOb1YNJNx0ZRXwu7PK5kA1htonxepd44O01oLMOxwW2lttpt+3lUnZctHK9I1pAai9nLWqd6Yd1zIwy1ChHGUOKmOEy0VFlrb5lf07qFRSMNYEGkR7mt8MeOjKJ59Uays7UWY+eiJtcV4diQ9l4SBt6qqB9ek9YtCjE5Kc0tgKlFZhCzjPeVxj69KQY6yWmOJwvSsUiWbBeoPz1KOoExMp1DzS59jAbKBgE1y6Hk2SJr7vycmfJWfWFUy9RPGTV/zs+Oz+/jXxqofvM3fzPf8i3fwld/9VcfxNG3jt/1u34X3/RN38T3fM/38I3f+I3PgOqtIzlDqgyxkvxUnWQHGo8WxNoK+5Iyeu/F3asoLKsszLE2mG3PeG9Jddmjr3e4/QjO4J87xq8sOlh049DbAf3kShaISUhz2/WfJh3SLXQ312yUnfU0vpl/D3PI8/Q9Y5wfCuYJxfk+zd0n9rYwsJM+6WQtC9HNFtpaWIMQ4HiF7kbMtmd4YY27SdgbyZ7tXljI+LtkbkpGqpojllDMcVRTMoAuY9qsIVXMzVUTWJ2kBCoU9jAdxtemi+KMP7IS0B3lBKaSSUqjScaJyWKIZJKMtTaDmB9uivM3JfLxUvJuK40dLOFshdsP4CPpaCG6ss5jr8T4EgqDnY04v6es19FqQiuA1PYZ8qGFSsWM26a5LrV7oaW7K8CxfRqoLj3jiRMz1JTV6zNWZ9B5LhDQQT4rHaRIIBl1SBwoObbJKtpzj73qi6FPk2tLqCUuDSWvPdQCavW0zymAuXkyYrtIWFpxqy/VZ+WwKspnMIpcISaJTtIFNE+gTw9Z9K2tm2UQ7S7SPNxitoF870Qc2LueuDwirWvGd63JUQoYANwmsX5VtKMqZZpPX5MrQzgurJWPrB5G3I005PTvPWM4cejjBlUi2/xCo6PoRNGSKNBcCkMVraJ9EklOzdm49WXGbZJs4voRvTUCIp9c0zw2qHCfVGkxHeEJJw1qqLGfekT2I8MvfQ86KarPnM/VqJxfyz0Wo2SVTiYiY1BKk3VGrVfkkzVq16HWK7mn9x2q64nVguhEbhGPahRgz68FGI8i/cnHq8KYarlf+0GSL5CfM68NukxjUpw74/O6Fb1kzrI5fXyN6lvRf1tNqjTdcxX9mcYsMn7VoJJIIdrzTH09TVaEqW92xVVvjYy8fcY+vIDtnrzbAxl1cgRrGVkTIiwb6vNBiIIxFhNrks1GYeOzBj1m6utIaLTU9cZM88YedylgNy0rfG0Yj80sh9FD0aorRM+5aGEn0ygdXflzW/TrYsxUKR/WRjistUWQr4yUPuRay/WhNerRlXyv+0fo3UA6aiW55HILKRLureX+7ST8PywN46lDe9H5rH9qT3P+/2LvzYNtS6oy8W9l7uFMd3pTjSAFCKUMArYDrQQ0s9IQhuJI4NBitAO2OFMRqPCjbVqbaANtbQNbW9u2gQhsB4IOUVEJRZFW2wlkLIYaePOdzriHXL8/1lqZec57SNWT0gIrI6ruu+fus3fu3Lkzv/Wttb4lni53MNdET1K3Oqmethr9bQ8KnXglqkoKwjgH1zFWWwX6kcfgjkNRmNHEvxhCpusIOonNZ+e0bLclalHGuvqU2Ou0L16ZWAOyto/EcbqfNNsH7+trfIo1ZsYf/uEf4i1veQve/e534/DwECdPnsTjH/94POc5z8HnfM7nXNN57zFQ/aM/+qNPeAwR4WlPexqe9rSnXVNnPp2bxBd6lMe9gJe9CZrdWlik2qE6WEl2vy7U/dCjOFiC2g7F0Qw8qlGdOxYpklUTLdfqo5eE3djbRj+pJeapKtUdE1Jgey/JGwiZKHNeBs9sD1tAbTGJ1n7u2sn/ofIr+Uc+27Scl0W6acE9A6t5Uh6YHgOTEWjVgQ4lFqu8XMDtz0DzFcLJbdQHJaoDINSyqbVDDyZhEm2dt1r0Eqcqmf5W474vhaUrFlZKVMAU9SKHFUphuB3LRuV6Rl+LjJRrA5rdEt3ACQvLDA6Mcn8h7OhsCb9qQGWJcOYEUHsQLdPCWhbCULaqOjApUQwr0NFM4v96RnHhWMIsykJiJA9b9AOPsCtue+6lz37FmNzdoR17rPYEuLKTpCcTxl+eLIUVXTCqqSgwoA/obqhjVSnTJ7WELfKaKOVJxc2F3ZAQCEmOMjmrYtZjeMcU/vIMYXskG2lgyYoGg9oeqzNDGb9eJJr6AqgPe1EPGIl73TfSx+AkBjRUFJUH6gMZO9F5Ve1SrT/flzIfyymjnPcIlZQdHlxYob4wB/c9Dh53AoPzLcoDyfLuqcPqxFDmwngQK4sV8x7dAKiOOgw/uA9//gDh5DawXYEuH8EfzlFtD4FewHx1eQUupJJZP5CKUPVRkIIIuwOEkmKpWAoi+bU86RUAQbPyZTxx6UBimLeGEs95cAQ3rBG8yH8N75RkkvnNQ7hlia27K5B3kpzTBGE3q1JkfdpOlcWEeTLhdG5bfecFmHc7NXzfidelKhFO7QAhSGJR71Adi7HTblfoH3Edqo9cBg6OwVONA+113VBxeKqquF5wr/GHu1sSzxoCqO3RXreN1ZkhXBtQHC5Rvedj4PFQGcUAf/EIXHhMFiMUsyHYE+bXiUZqKET+rJiz6u0S/LITUX3vpGxr24nR37Ryv2DQeIT+QafQ7NUY3D2Fcw79pBbVAnLAfIl+bwIuPYpFj1B6NBNJABxckudW74ukmV90KC/PRS5pvoRvBqjA6EYj8UrMW5Tv/xgoBPQ3nwYPKjAxyjsuAfuHoO0JVg87jWIZ4Bat5A4YSJXByxbetP5y1+k8ckDTaex7j3BijO7kCP64kepRvVah6lpQUcTiBPAF/AoY3bmSBMKjpYBTBtBKZUJ2amQYY9l26hkR2T1UJdB1kn3fqZ5pXaLab1BdXoq8Vd+nkK6os6prfx/kmWhSFZqsYhUg3wtKihiJYgaPsco231QOS1jaB9r9tb3uda/DK17xCtx+++14whOegIc+9KE4c+YMDg4O8LrXvQ4/9EM/hM///M/Hj/7oj+KpT33qvTr3NSVTve1tb8OTn/zkq/7tv/7X/4pv+7Zvu0fnYWa85S1vwc/+7M/iPe95D/7H//gf+PzP//y1Y17+8pfj9a9//dpnj3jEI/Cbv/mba5+9+c1vxk/+5E/i3LlzeMxjHoNXvOIVeOhDH3qvj7kvWj90aCc+ioaHUrLL2VN0jbpOJHNC6WKlpjCUzPSCSCRgpnNENNi0spgQyWZ6OIPve7Fy87gncskyCz3W9D4BJIFmO95+mstfgzHt74D8HuOPMquYhA0CAeQLAWB9n9gf09cDZIPdkWpb/aQC7w5QXJzC370PjGp0N50Qt/fhClwQlpMhGJJEAhKGUxLSOGqyAgBryctYrrWkqB5QLEVL1bRZ2UnpUL/SEIpSMrj7UsS/2nENhoAaqYgVUH/4MtylQ11YSUoyFoUs7kRAXUd3rbt8hCowmoecQrtVyjMdVfDLRjPXCWEygJvOwX2HbqtGebAANSW6oRfNy0rucXihRygI7ZbDck9AuW9Mj9TFpBCvVaj8XBQWjEEsFuJeDgXFTPtcFcCSnlrVAS3njHbsYjxrMQuoL3dSJrfv4WYL8NIj7IpgPfqAog/gwmlMoWzIfiFu27726IcOWDDqi0vUlx38ymuBA2j2u/wMhdo4Hccyq4NLnfRnKMxws1PANYzhXTO4XgKT25MVVrtSBIO6Eu1uhcX1NcqDFqMPHqKfVHBndgEA1R37qJYtOPTwl4+lXGMAqv0WVNXgxQJu0SKMKvB4ALcQCaRuUmgSY0AoJK54dbKG0zhf1zOG51ssTxRYnBaN3sEioB0TFmcIo4+shHG98SR4WMK//zxoUCPcdAbVNGB45wFcx2iumwAglMc9uJYymvWFOdzRUtiqShQmuGm0fjopYCzAD74ewTH8hSMp1zkohZHeHUv8ZtNJkg4zhncE1OcdaKmgxBGa6ybgQQnnnCS/WPiOAhNS9g1tG2Mpw/Unsbp5RwyyoUN52KA+OwUPSjS7pUhUbU2wfPAOmlNDjO5agIY14AiuCRjdvcDy9EAMx5YBklhqUtWH6iiguryScKK2kxABTVDkphFQ5D0wqNEPC2Gm6xIcGEGTv+hgIUzspIabNahnBGorhKJCE6Dle+Wdco2GKxGJlJMmifrpHMOwJ4zp5WPg8BjsPdylY4S9LaBrgPlS+jMoQVathFnDfLq4biRwh7Se2hpbiKwTq7RgGNfo90aoPnRZQj5O7YCHJVa7Q7imB7UsVeaW8pyK/Qb+WAgNt+iEXXYu5QzsTEQDV0ExA/LvshAw2XXChIcOPChA7ODmK7hjze7vQiJASPeByJoieeLUeyjVrSjdowF21qv3fVSWiKEP1rH7UUWq2P4RYlTxKRSj+sM//MN485vfjNtuuw3Pf/7zMR6PrzjmwoULeN3rXocXvehF+Pf//t/fK6/7NQHVL/uyL8Pv/d7v4fGPf/za5z/zMz+D7//+77/HQPUHf/AH8Vd/9Vf4si/7MvzGb/wG5vP5FcecPXsWn/EZn4HXvOY18bPNZK3/83/+D77sy74Mr3rVq/DEJz4RP/ETP4EnPelJ+Nu//Vvs7e3d42Pus2ZrzyIkJSh1rXLtUM5EoDkMJC7RtBnbbWEt/LKTzNqcBQ29WMEaqI62BV1cJavWwGWfx5m6dA5Av6t/jqLKmbvfzmMLqTGmRMKaep8WFnXp0FLZXlKLue2Sm2kN4Or9B9Gw5KrA5PyhXLtnFOePYCUa3azHcKYSUqMBXCuVinp1q8ayoxZ5oPGthUpTsZeEHoBRzINWAdMNtiS0W4WAEAVB1VS0LEMBDO84lkxdcvDTlcTD1SK1ha4DTUZSnWW2BE8GEps3EakcNA2o6WJlG9dCZMdGFdqtSsDwiRHKrgOdP4CfNgKMSLLLTYkgVBTBaDtU4LiS+FJTi3AdxzjbZseDWLRiuWPVSw0ojxs0uxVC77Qilotu1VAqq7mSMbKs7PqgR31+jvJAQjHoaApUFbqTW+DSCbtHALzD6tQQrmEMpi26sQLtmjA834A6wvBsI+oUWunMNQwMNYGuVRktVXkop/Ku+KWcvzzuwL5EN1KVABKg3+1I7DdPCjQ7HoNLAeVhi+JohebkEKM7l6jvEoHz4q4O44EygdMFqrMH8IdLYemcuJLDwMsrVFWiUzlrhIEqPIpZi9BKecrgCYszW8LKHjL6krDaEXe/m7dYPbQGWMIsghqk1YEmq3GAm66A6VKY0K0xuh1JUgnjGsER+tqhnPaiFDJfibJEG4DpTNcPD+xtyzpwPE/Z5qMhwqjC8swQxckJyssLhEGBMJA5ziGIxvJwCGyNgPkS/rx8n7sONBmj3j8GL+WawphyDOEhW1+00pUJw+NohmK/QntypLJxJAyjKlz4htHvjbE6M5T1rSDRZ718jP7GPbS7NaYPKrHaRXw3J3eIvujqVA2/VCDjCWilmhEfSzKvxMrKM8POBP64EQWPPoC9Qz8qQH0Nf7gUg3VfEp+67RrFMmB4vkWxLMT4KB0o9GDHEtupIRAACQHQdig/JOod9hyoLIBlg+LSEcJsjn5nhPm/uBGr60cYnetQnl8Ah8eizcySpBiZyCgjKPO8PzER1Qt9HoB6gk5NBJB2PbpTYynI4Qhu2aM4Wkrs6kqE/6kU6alQedGBtjW37YCuQ9idyLM0T1hZyDxctcCyjXtIqJ24/lddVFKI+4iCWbGYC7mf1UrGyXHaLwDdD2yNppQ/ASRvnYFX6D7kVBnAQtGKLATggXa/a9/0Td+EV7ziFVcNC7V2+vRp/Lt/9+/wbd/2bTh37ty9Ov81AdX/7//7//DsZz8bf/RHf4TP/MzPBJBA6m/8xm/c4/O88pWvRF3XuPPOO/Ht3/7tH/e4ra0t3HrrrR/37y9/+cvxdV/3dfi+7/s+AMDnfd7n4frrr8fP/uzP4rbbbrvHx9xnjQU4uSboz16TggQ4umWHUGimNCQUwOKeipnqyg1q2ZSci+Xu0EvWf4oNDQIQYUyqijl7daOAFAWUya1iQNVc9ZSdD0gumLX7YemcxRzlHiyTPukW0r9YlSRceY75EhhWKA6WKA6WcpKqBOYmr+UkWJ8IriyAyQg8XWJ5ppY69laSs2fRYoUAAUmiSiL61KvrtUyxjsFTlIlhR7LhBHXRV5JcNbjYyKbR90DXivuq1LCKrpNnYhmv87mcb2ssbEjhhZ3og0ivuFPCpNcFeAh0I69lPoH+5BZoWMEfzNBev41+UqIdS39cw1LxC2JEFCuZUK5LG7qxwyLKr8lXTth7S8BiB4S6kKx7ZVa7EQEkFYA6LURRTnsUix7sCxTTBoM7DuH3Z2muFAV4PEA/qXRsFUA5KWIASDlT6iUOkHqniYDCGHdj0eQsjyV+szqSuu1S4Ur2OFF+UNa4lXtstyQEI8oHTTutoBUEyA8Jg9sP4JyPmpLlUYP2pC5xaiwZsKdeym/6/STl5qZLuPML8HwJPrmNfligvHAMBEZzwwTduMTww4dwFw7gqgLFTSMBjI4wu8EL832xRXNyIFW7ug7sHMp5QDkDAEK/PUT7yJtRffQi+Ggqr5xK+/Q1IRQVqoMVqkOVBGplnlHhY1ELtB14uQTVJfobTsD7AnRxX0Coc5Kk2QWEgYxFcdTAL1cy/5daRa1UQ3LZRCOV1N2Lvs9KaQLcB2FRB1UEO/K+y3vNfQD2j1BCEkK7k2M0J2qsTpYIJaG+JIaDhd2wJxw8coTtDwL1skMxbeDmLZrtbTCVmNzVihdj2sgzWKxQ3X2kmq4VwqQCDT38YpFKf1YFaHsMLFv4poPrA9zhAmFrgPLSXBI9iYC6QhiWUQcWkKIWxVkBsd24AIPRU8DgLo3DNIkpe9kA9CcnABNoVKGdlGi3CgzOr0AnttCeGaM5XWL4sSUG77kAdzyXYiG6xrKus+QLAKxYTM7r5x36cSnepouH4O0S3Zk9FAcLFHNZu8POGH0l8oXFwVJ0WC37vu2kSlXTwJk7PSQgHLzT5DNZI1BoDGq+xDMDo4F8fyHhQ6grWQdbdXuYPKHtEV7BZVEk0gMsTCs4FZ0heQ/g7J7VGApBjCBjUIMRILq5mJzW/aTlfM99eY1PlXbLLbfc42PLssTNN998r85/TUD1O7/zO3Hx4kU84xnPwNvf/nb8+q//On7gB34Av/mbv3mv4lPvqYzV29/+djzhCU/Azs4OnvSkJ+EHfuAHMJlMAADT6RR/9md/hu/+7u+Ox1dVhac//en4/d//fdx222336Jj7tDlEFysFhlv1CEOJKaovrgSsDKW6R69sqmSkBhSzXrLBdwbwF70AN83khVertusy0GkvdxYsb2DT4szMtRL/rQghCjZvMK/GmgFYs4QVpyYq09w+G7FE3s4HAc0GXIlAyxb1By/IvTiSKlfjETCbS/ayiuhT24Gnc1DXY/SBHstbTkhd9A5oRw6sRJnpgpIjBGKUU3EjWkWwbiC6leVMS6AG2Tz9KsCtAnzrJb6VEcvY0lJcZDwSBQapFuNExH86F5aLGZgtpGSguc8CA9zBsUOxCGiVfRKmsoVfdAi1uCmLpUdz8y6Wp+ukO8oisO9XJoAvGdAWa0u9JUEhgrByxarZSTh+UJWY0UM5phuSMseIxlBfAq4HiqOAahqk2lnfCUg9eyCsfF0hbI0RTk4kKYUB3/Rws0YSkLxDMRc3YLtdwi9kY3HEWJ4ZiCRVJ3G/NG/FpQopctANHVpNcmMP9Mp4V5eEyWJPWO0WUiq0kXGgJoCZcfwZQxSLHpO/+BjcwQyLx90osaxOQmvKyw1otkIYVVKfXgEH1TWq952TzGsFgyi8bOIAuC7RbpcoLhLQNmgnhbB0Ttyd1AWUBy38QkqcVlsjgKVKES09XFOh/ui+AKKdEUJdSILeUStVwEZDqQTnCRjWAAjdUAp6oA/iJm5b0PFCmUSRhbKCG+Q8UBTwh3PQ0RTctnDjETAZwV86RlU4NKeG0mdPoGUPbxXgQg8+fwm0vSXZ8SGkkr/mpvUcYw2pqmQ+L1eqlynvMhWleEaUHQzbI6Dw6IdemGNPQACKgyXcpSO4tsN2E7C4eSLa0eRFrmrVgwcaDlUAxw+p0G4FlIcDDC8ETN59CXT+MrA1hj8m0KCAm62AwUDd2UspLjKRBKqwJeL6/d4IYVChG3v4Y/U2dWJEcQn4RSuFWAYF3KoDdQFu1cEfq3LCqpG5wZwqM3U9mBuEwqHbGWBxeoJ2LHO/3xmIN2QVsHX7HOVdlxH6TmSgTHLKOXHpQ2J7bXnFoFZDMsBfngNhivb0GO1n7mD47n2440bGvShQnjtGc+MW/LSDmy71uQVwXYA4CLhU48uUGcg78GggKhjkRClmZxfF/gLctJrgBbnHwQBcV+DKg0onrGzTpv1jWAlgNQDc9cKmkrruLeufKXncHImUGoyR30BhhLRHxN+z/exTCbX9M2wHBwdRrvQTtb29vauGBvx97ZoF/1/xilfg4sWL+LzP+zwcHh7iTW96070OkL0nbXd3F9/zPd+DJz/5ybjrrrvwwz/8w3jTm96EP/3TP0VVVbjzzjvBzLjhhhvWvnf99dfjb//2bwHgHh1ztbZarbBareLvR0dH13wfrO48Yq0xzgJcw6DQmuYMt+hBAycqAMcdqssr0TUsNe5usZKM8roCn9gGHcyApdWQVisVUJyaufLzmB/TsDPrlYFUvxMKevQflJ8rCx8wd5Wdx87dB2URe7GsJ2NZNI15jQUHFCCry4u0ahO3LXBwLOA0hGSx970k+aieoGsChu86i0HfIZzeRbhlRxZfAqDJK141af0qoB84MAlYFI1PYa9c6wSgtgy/FIDil0HKvap7Uu7FAWUNmq9SnO3ORMahrmIVHCizRIMKvLMFKhxABXhQwTV9jNeEI/SVl4pIGl+7OlmjH3h0A0KzJXGixQrAkqPwP3rEBCNAjR71vok8E8UKVJbJ7BtJPhpc6tCNHVa7Hn0FVMeM0d0rFPMezckaHXkgSNKfP5hjeGEJd/lYJH+YgbpGOL2NblwglITB3TPZdLUcIheE6kgUBvxSNqdQOS2NKsZQeb4BLRq4RYOy68GFR396rElGWpxgzuhreQ7lcYtuUqIvhRUeXG5FRssD3XaJZssJC3zYwR3OsPys63Dw6C2M7lYB/A8dC0BwBGqDJC7ZPG9bjdfTpMOqQK6DaQmD/e4IblCimAVQswIdzSV5BcDwgxeFSb5+G34ZMPrIMfxdF+HJoagK0FSyq12zCzqxDX8kYQ9wHv3eGK50oCag2x3FWGJ5sPJuNCeGcLMW7tJRYrNMWJ0ImM41flINp7oWNYntGqHyKKatMOfjAtXRQqSa2kaz4wEsFiKz1nUpWcreURKml9XApUaAFjkn4Mf7TOSfgbpCPypBzqO6uACKAt1WBX+0kKz8XpKe3NnLGLYd2ht20A09QjlAdWkJt+iw9aEFxncCi+tKNNsVyoXM7/7kWGTfjubAfAmnBUdYASTXJXhvC7TSuVh5hKrA4vohujpg68NLAZpNG40MaoNkzDPDjQcIoxrdjgjno+uBoxnCYiHhPYMBDJyjLIQlJML8Oo/lCSmVRz2hWIoubDHvUByJdq+zalNqBFBcLxL4YgD9pES/O0D13nPgQYlw3S4wKFB/cApaiIwfjyrwoAIVBaoLUvhFZAR7LYcqc8SUHxA0zMA5eaZBnlMYVHDzFYrzxzHWHo2ElvHWWN4Fkve2WLWIFQ2NTJhr4RfnRA6xb3Sv0Q0oLzRjWfwGymGeOGTvGbK9CBlgZb2mS/vPA+1+2V72spfhp3/6p+/RsT/1Uz+FF7/4xffq/PcYqP7iL/7iFZ997ud+Ln7zN38Tz3/+8/HRj340HvON3/iN96oTf1/70R/9UXifFvF/8S/+BR760IfiDW94A174whei1xegsixUbXVdo9NA8XtyzNXaq171KrziFa/4h98EQ1jVjuFnnQBVIArMuzaIgLVzoAWDSkZ195EweX0QBs9OVXr0N54AgeC2hiJ63oe00PRdZEoJUJbUQKaepBCXU7RsOVs8NhOm8qB2ys5hm5otKAAwHspitdJ4pukMCaBCmVSNmY2MLoMXSx0jvYDF21WV3Ft0GUE+XyxFU3BYgTrG+I4pmhNDrPZKEEvZVANPbeEleYgoKW2p1FU3IPS16JhK9SpW0NqBeo/isrBZQbNh3WIl+9WJHXkmFlNtzLVqyAKQeDGNzaJFA79YwWsWLBcedGYb/VYNBI4xm1yI/FK5YPgVQL0BasSSseVU+hoKycRvnTxnqzdPvSSIMWmVKr3ffiihBH7FqKaM4UdnqD9wATQaANhBUXkUiw50PIe763KqtFVXotUJglt2wLiU/rC4EfudoegEl4TVbh2LE7CXalvVVJiq5clKmNYjp3JeC2As2fIWGjPYF8mjvpb5FSqvIJxQHfdoth2YGNVBQLPjsdojbH1whfH7D7B41HXY/xc7GL/vCOPb55Ls0XXg0UCMu9kyY2i0OQI6xCSc7swWivkcWACoDBBXqPenqP/mQmIXfSHJVysvSWR3dti6dAynmdAcAjCHgIu2A00XwNYY7mAKPpqiv+V6tKfGKPse2C6wOlWLJNI0oJi1krh11ImE1dFcwmEOFtFFGtt8AdPvpN1thDN7UvpVN3a/7FEdzMXWnAzg5kvwhSPQoAZOn0DYGQlou+NcmscGXPogpS6j0UrxWvE97DU5kwA0rQDSvS3xKLQdiv0O7u5L4gkpdasZDYCykBjsQp796vRAlDc6RjFdYRSAYi6lcbuRx+rUAKH0qMoCzknGP7ctOATw3jb4zJ4mM/YIhYeftehJlSrmAX4hhi5B5LLgSEDdQowwIoILjNWJbfDQwV8CeLGQZ2zGsvPg5UJc1IMK6DuJx74cUCwC6sutGMcLKaPqzh2I4a3sNxtxEBT8K8sY9sbot2r4yzP4jxygfdgJLD7rJEZ/s4/yI5dgHoVwagIqJTmyOGyE+e96TZxVFj40CfjZ9QqnRmMBaAy9SFqxJFjVlazX2jc61qp7WyMURzMZI+/TGm+kh3ndmlaNO5e5640csb5keRLGjsZFC+L8805CTFxuKLJ64CDhDPcjVvUBwf/19vKXvxwveclLAADL5RLPec5z8MxnPhMveMELcPr0adxxxx346Z/+aVy6dAkvfOEL7/X57zFQfdnLXvZx//bWt74Vb33rW+Pvn0ygmoNUAHjQgx6EhzzkIXjXu94FADh58iQA4OLFi2vHXbx4Mf7tnhxztXbbbbfhe77ne+LvR0dHeNCDHnSv78Gyqv1CEgL62qGYi55febSSxArnwN6h26lRnjuWRcR7hPEA7vy+AIa+R/egU+i3h1INpVOR5ZhVKRa0sCN68Vh3WX+3uKDosg9pgSGXJKzsz3YOi3ENDFHONqCpII0hwtZVKdI5yyVi0L2xNRA2KX7PPmPtV5cncamVn7O1Zm3bv4sStD+F73uUfFLBmyx0lpBGwWIepdKR6xG1Q42J5IqwGhRJBL908FornVrNkF6uBDBMhsKqHM9ko6grlU1Rd+lAVA8iy8FaLhEpg5eO5yjnSxSjgbiYb9hG2JYa5oP9TmKVHdBMpHa76wRgdkNJdvJLQpjIoyNjU0tlUDziBtBXIu3UlwATYXC5x9axJGmVC0a4/gR4UALkUF1cwM2lolEMFxkNQY7Qb49Ermu2RDEoxI19Ygh/tEI/EDWDdiTP3zcQoEJAsZJQknYikkO+YclgNwa6kjKU7AmDfdnwu5FXIExodiuR25p1aLcK9KXD5I4Vmh2P+fVSo726uMDsYTtYnfLY/csjjN5/GKuq9dsD+KM5aNVFN2sEeuq2ZADoe4RBITJpRQkMB3CHc1C/DX9pKrGCy6WUC162wigSqcs0gJYruGPzNMhcpboSxo8I2N2WSmWHAmT9oUhEwYu+cnHcotxnFIcLgBzocArMFyjPqYdCDVXmDCga6Ol7uFrCFrgsRPpJb7Ebl3DHUl/eLRoJF3jQDeDxEMQSgkRdB+ztyjuvIQRJAYRUmqiQNaANWg+eAedFM3RnC2FQop9UUmmrIJHyIsDPVgjjGqRKA+KB8VJRb97A62veDwspZ+qAuutR7C9Qnj0EF8qWlh506QiuC0BZgqdzATWDCry7JWvqpIYnArU9ljeOMX3IEH7JGBwH9JMKftaCOEhowGgAaltgUIGHlda8DxjeeYzehTje5Bzc3g760ztwBzOwuTb7gOLCFJOyRDcpJVZ01kp52v0jTYRKMZXMfZxzDMi4EYDlCm7WCLgNWujg9A4mf7Uv7n9b+8YDDfMKKC+IRjO1aijEddEW7Ixc0BhiEAFlgfb0GKEuUM8bAeoaisSDUpKmjlMys5w/iMehy9Z5Y2tZ3fu2J3idl5YQlRMcfS9xzDqmae3PWFcGYklvm9+se1Is9f2pA9z+ubVTp07h1CkpT/0Lv/AL+OIv/mL83M/9XPz7ox71KDzzmc/EF3zBF+Dd7343nvjEJ96r899joHrnnXfeqxPfV61pGpw9exY7OzsAxH1/88034x3veAee97znxeP+5E/+BM94xjPu8TFXa3Vdf1LKwUpsnjGYAdXFhSzcuyMFqQRaNaC2R9n1oEUTWU93vNCMygbhzC7cooWfSc15Misz9MlCdQBBwSDHINL1n7YYEBIotOD3PCMzjy3NY4fsO5atatn/gVONe2Ng2jyLMx8V3liwbJF1mfGdAWwEJNUC/WjVxHjd4ngFeId2uwR1IpPUbkuMputYpY4C/CpoQpWcoh95qfg1kGQ2q4oTKkK4aRv1XUdSr9w5qdhSlamsZVlqHFsr0RPeScLHeABaNeCygFtoZSFjo5wTVmm+UAY0AF2IWfuuEU3XZq+A6xl+yihmknTVjsTtXh8FFEtCqNL49L1owlIA+oEwrqKFKowsCFjtFShmQUOIB6ITu1MKozvyKI5KFCHI3KwrhG1hS6lXFqTp4C/P0N+wjW5SIHhGs1MCBEw+eAR/92VgUGP5mWfQbhWxYhAAcCFhBf3Aw6t7PYxqgEU6CxCFA+oYRSfapc22BzuGn8tUKGdyvtWJAn4J7L53ie7UGMV8hclb7hLxdWW0uWnhz60ADpK9nWcdA7CYbUt6Izj4Oy8Bs5nEJY5OoLq8gr/zkgDTshTR/MtHUr7yxBZWDz2FwXvOgeZL+Y5JvgGSPDMcIFy/hTAqUVw6kPM4B1oJawrv4M8eAhcPhOUcD4FjFa5vW3E5T8ZA04CPZ4ix5JkXyA2Hyoq1cLMlmGt0Y5cKWQyl1BetGoTJAP2OgCR/vAJ1xjT2UeMzphjWokqBSgwxns1hLn4qS3EPDwdY3byD2c0DcEEY37FEtd8Iwz4SgOlGA9C8AVadGG4hSKnSukCxPxeQOyzEs7SUEqA8rDR+nEHHS+B4Kl6XnS2Zu/bcQPI8TmxLmE3Xo9sdShwuA9VRL4apZaAHFmau70Slo/DodkeydrQd6GCKQtU6BAjX6K/bA/cq3TWo5d4nI6CqVCFAPRnLBjydgYcFXNunuWZEQa3ePKsa5qX/WKwErA8K9DefQP3+ixJPC+lvODEGsRPd0lJl8BSgmirDVfMO9Pts4VWBURyuQLwSQ6YoJH6aGFRWEvOryZ9RdiqERCyweuaMXPA+jakB4i4DlDHMSzYNUYtwV/bRiAcAVqI3TW5oEhWnY+8vjQn3uXzUpxCjmrf3vOc9+KzP+qwrPnfO4RGPeATe85733Gug6j7xIf90rWka3HbbbTg8PAQglPKLX/xidF2Hr/qqr4rH/dt/+2/x3/7bf8P73/9+AILoP/CBD+BbvuVb7tUx91ULWuvcz1oJ2m97LK8bSswjswDTo5kwiH0ANS1wcCSfLTQusirhli38xWO4s/viOl2sVBIEV27EpOyl9wn8mSaiLQ4hZItHiNZvihcyAKsg0qx21nNBF7AYmqALVtTCQ4pdsuuBk6soLoDIFls7N+XrXDrGfgeS20kTQoqLUwzvOMLgrmMU01ZiNFcB1aFkiEsXZcGuL68w+NgU49uPMPzoMSa3H2P7fYeYvO8AxCLd1FckiQ9bI2BrLHI7pSTH9NftorthF91nnEb/iJuB03uSXNU0cLMlaLYCXTwADo8lBGKpG0FVgrcn4OtOysa7uwXfMIZnl/DLHu1Ykm662oGJUMzUyGFoVSoZCwoAtMJOsQiiEav7I6v0V3UslazYCbu62nZYnvToxiK8bzGkgIYfjEtxlZclUErCilt1CEO1ZzkAhUMx76Te+ZkafU2oLzXw806ymIcDlZfqRU6nZ7RbHn7JqC+vRBpoNEQ4uY3+xFiE1RtRN6AuoJz1KKdieDVbDovTXkpFekK136AbevhFwM7tLXwrGpxkCgiWoNEHyWQOQZKQ7EXcZGTU1c1NC7qwLwBF4/h4MhSAbnGAANx8Jb/3EjN4+FkjNDdN9CUPWpbSCYgKAVx5tGcm8B87kHfE4rEhwMadPxD2tO1i/CQs+WVnCzi5i/7EJIXOdJ2KqLvE2Bk4dk7Akh5aHkoFMSag2xuivXEX/VYNN2/glp3q+DoNYVmqoSmhK7Q1Bna3BMz0PYJKktGZU1L1aWcifXAEFwjlnDG42KG+sIBbdvCLDq4R2bn5jbXEsk7nwNEx+PAYOJ5LmVYi9Nu1VDMbOXSTEqvTQ3STSpaargOmMwSVoQI5caPfciNwwynwzlj61fbw+3MpmLBditTdR1cYfeQYxcES/mglIRQHx8DxDO7ikRiSwwp+JnHHdGFfEjibFhwYVBaguoZrVAVjWIMffD2wswWQ5BF0QweGMNPtzgAYiT6reAtK1bnWdW65kuczrERlZFCB+w6MgOZB2+gedgblhZmA5qBzuS5FdupwKsx904FXDbjRONQ2zc01wIqMuQTAO2OZz0GYUgoBRE7KqVaVqMrMl3LOukx6qBazbYuued2MhLAcBUBBaojJirCQr7iGGwFhCxilSlSFxKGSyxnhDIRbTsT9Cag+0D5ue8hDHoL/+T//5xUe7Pe+9734rd/6LTzkIQ+51+e8pmSq97znPfiVX/kVvPKVr1z7/GUvexle+MIX4pGPfOQ9Os+v/dqv4bbbbotxol//9V+P0WiEF7/4xXjxi1+Msixx6tQpPPKRj0RZlrh48SI++7M/G7/zO7+Dhz3sYfE8L33pS/HRj34Uj370o7Gzs4Ou6/CLv/iLeOxjH3uvjrmvmgn9U9PBLRu0J8fgQQl/cKDyJwYSA+hwKguGZtxGxjHIgqVnlB9hY6GIm5ZaszkAjVZp9u/chcO6cDR9ukameQqo2wdmSXJ2DZY4opwclQsgMq/g1L+8bB77jPlVNxIj9Tta3gHi41Z2xDJM2yCboCegqiTztelQHK0w/ihrFrJ8BojREGqP4nAJ2tdkm91JNBi8c6jPz7E6PRK3+aCQ+MyDGUI9AFelMneijWmyViACBjV4UAqTuj8FLZdJqqVtZeMditsVgcFE6CaVMDJBErr6IWN+skAoJMa0Gzn0lZeKRkjj6zpGoXl07KRWOkv0B/ySVYYqy+hfBgmNKAjdEAAKBC9SVsOPLcSAYohLsHAIwwruQMIA/PESYVCCd8cyTpcOUN/dotrbQtgZSZcaqZJEswXqj4hSBXtCc2YMv2LU5+aozh6D6xLdybFU1FG2ybWMctZJJalRiWavQrMlMYZg1Yd18tzqi0uMPjBHe2aC1ckaxXETNXdjgo9lWFciw8YIaeO1BBYW9p+8k/hJk3MDgLrC6oYtVB87jIYdWVKIZl73J8fwsw7luZmA4cKLYdg0YEjSTNiZoLzzsiRBshpxrcaiXzpMpSeVqQzjAdxiCQoBfGIbqxu3UZ0VYGfvkxsM4jsnfeolznY0BAaqbFBoPPLRQooxDESg33UB/VaNUDoUxyv4g7kwqW2n3hGXkmX2DxGYQWUJtz0RF//OCKF0Aka7HqwFR+qDTgySkxLz6uct/NEKg66Hmy5As6XEzjeteIq8E2H+rRp+Ie9qWRei+9l2KO64pNq2BF4sQWUJOrkXYzKJJTEunNpGu12AqxLNCYd+WGBwIaA+uwC1PbiScKri4lSSNRfywlBVoL/+ZGRCMV+o1yMLmfIiYM+OgKpAvzOEm4uYP2pNfFK93nZ3ANd0cPuzGN6zBiL1ebFzoB5SlGSxRL8zQHvLSVSXpnC3XwIthI3mUggG6gPcdAFW5ZMoC2beL7j1axiAJBIPDpEYG6Ma/niRmMuyAIjg9+cpY7/UMq8W7tGaBFlGOBj4tf1J1zHpihAaZHsWq3fM3hkbVwOsFo5m3jlPEmIQPYS6r+SJWWlj+Sdvdov39TU+Fds3fdM34Zd/+Zdxyy234OlPfzpOnTqFO++8E29961vxVV/1VfhX/+pf3etzXrM81Utf+tIrPn/KU56C7/qu78Jv/dZv3aPzPPWpT8Wv//qvX/G5xToQEb73e78X3/u934u77roLe3t7GI1GVxxfFAVe+9rX4tWvfjUuXbqEm2++GWVZ3utj7ssmm/YIflrCH6/g2hBdxTGLkiGLee7qIGU0beHLXTwWI0T6ohu4zFyQedWouODYImYLF6BrgF9b7GDroTKtMafJ/meLyFp/kBhV6KJWeNBwAFY2KoLW/E2Mi1cWc7WW+GKi0RaXlQHv0AOBgH4Jmkn1Lpp7+H4L/d4YftrCzxt0O0P4nlW4v486kXQwFTZgR4Swq8tLuE7G1TeaVDJQmaymk1rv5CQpq+9RXJaYQik76OG6Rja60VBdfQoCQi9AppiAixKh8sJqaaZxvyUMimtEqJxJXPjsIAl3rWQX27h1IxeTkUAyJKYCYMoGYK1gpZ67oFNe5K0ktnV53UBKVDZSKtTPGwFXfQBdPJTYPifxfyAIc1yUsrG0Af2gQJgM4iOkEEDzBv3OEH7Rw886FLMeYWsIrgpQ08MdL0FjUQioLiwi2O9rh2bboTzqMfzYEsW0A9cFunEZmbrVg3bQVw7VYQt//gjl3QdxErFpMDonmd5tq95KEmAXHQ5OEmUsEaVbwMqQUtOi/sg+aP9IJXU0KeroOGZUlxfnOPV7M3FNQ+YB1eo2DwyeL+CO5uDxEHAzcCvxpASSOaEGKPdBhPaNXdqeCDvbBZTnp+I50YkuUkNBZKX2tsSNfTxLDF5gUOhULxgIp0aqktGDVi2ak0N0kwKDjxyg+NhBYpAtltaRiLc7D4yVbesEvIVxjdXJAULlUF9YgiZDcSdfFOM5DCt02xouwCLrVl2W8sBMuiac3JXYXe/Rb9XgyoMDo9+uxNNx3KK4cASuSvDWWCSpWMqioq7AIxJDEAweeKxOVVhdN0K749DVhOGFgPruQ/hDceuDKrhj9UipNjPVNXh7kvo5W0rlPDUaRNlAQeqygbv7AjAewWmBFhDQbw3Q7A1QX1zKvGIFfbknyLuk/WkJlt6hb5bgrQn6yQhu3qC64wD+uJW1aFiDnUMYl7LOzHv1nujC2weYvi1bwurmnpARDOQdUJfiCZgvbVEVLduSgLICNT1QFWI8T3WucVj3xPW21iNdD5TKoZpUVR/i+0EEBZ5I37NFymJaLczA9qS85Qm0n6KA7Z9rGw6HePvb347Xve51+L3f+z2cPXsWD3nIQ/CmN70Jz3rWs67pnNcEVP/4j/8YX/AFX3DF51/wBV+At7/97ff4PDs7OzHW9BO1m2666RMes729je3t7X/wMZ/sxk7i86xCDZcii7R68B6qc1OEnYHEjBnzAkqMYf7CAikrF0BiK821DyAG0CMxJOYPjBJT9vuG+92qj/g8XlUXKXJRfSQlZ+kCmTO8eeIWdPHR7OcIlAuJuY0xrsbCWhJXvkKZ68w2OwsPsEU5WvYa9B+TxxzoeIZi1YCrEsRA0QjbRrOlsgZaVtDEq4NWdwksRRlKj35YgguHbiwxl+XhCs3uQNQBmh7sCe11O8CZbamrff5I3bc6nmY0sCSCILDE6A0llpYYogva9uLmc4StOxphxpyMPWtyEzsFrT0jaDYvFgy/FPF8iemkVFZWn7dopSbpKupEFQBe2FaAUB42oFWL4o7LEpLinOjZFh5ogjAlg1rGemusbHYvoNNpucpaULA7XkT2xWqmwzv0oxIAw0970TXtWYoBtAH9qJSEJgYGF1oBoZeOQU0n1XqmDeh4jrA1hJ93GLz3EsLWEN32EDyoQcqWifA4paSt3BgzuR5AE5PS/ExZ7rIJu7OX5Bib++rOj0aBbupR1imEVCoYAKoSywftoLw4h7ckutEQXJexypxlrtPONnhnIlJ0dRE9K/7CIkkNMSRRcTKS5xJY3yEGxkORLVo24EGF8uwR+p0R+i2Jiww1UC0aVPtLFJd6FHdekoQfC48A6Vxx4qIe1KDhUDwVBIQzu2hOjwFHKOZ9SrabzQXgAHAhoNS5Ristcbo7QTi9gzCuJC688vDTBn66RHGxkWp8oxogAUxu1aE/uQUuHPy5Q/B8keSJDo/lvTqxjbA7gl8Bg7tnCIMCcBUG54Hh2SUIhO7UGAygPHsE5gBeiSA+TUYSa1x6KQU8X4CPppmb24vcl0n4NY3MiT6Ipi0R+t0xjh59AsSEwXkGzVcoLx+lwgO2/FlspYE0K5u6M0S3XYAgsfJEDjypQas+6tH6y7MYKgIiDUcIYvAzyzyL67iuv7Ye2tprwFLL6mIkEoBhWKE7swVHErbQj0TzuPzoxbTsOq1pTNl9dJzWStbzh5xV1WQp77M9wF4W+2e2D1H23ybgJiSmFra/ZbkL94dmAPy+vsanaHPO4QUveAFe8IIXfFLOd01A9cSJE/irv/orfNEXfdHa53/1V391j4HnP6cmLmKAWpFbEddti2Laod8egvsOxeVZWgjs5QUQFx+LD0JIL0lkH829ny9car1GSxtpoTBguMaoUlxQsw/TomF9sgokthBZX/LgeOuGuaYMSFo/emgcVNYXZIyAUXMGxJ26kDQBBiZhkt8Pc9R3FHFuCDs9XypbZZuQSnPVlQDJQuV82g50cAxMRgijCt1WjVC5GMfZjRzciqUcZUkoFr1EQww8mAjlcSvyTc4JIHXKli+WWsGqF3bOBdBsjn5nACokOYIdAXUp8WnM4KoAQDF7XpQMKNZR6GqKtodfSnxq6ITJ7IZSb77T50hB5KwISJW6dMxdB1AHccvvq7LBsWZUDwfJIGAWtmdvS0rCVh5cDyKYp66XBDavuqqBEYYF+pHoUlIriRbsxbUYBpItDQKKSzPQohWlqHGJ+s4DoCzQnB6B+yGKgwXc0UJCYrwDbw9RfviCaJRygO97cWU24lKmrpP+L5o0Z40ttPAAIIICm/MEr/tiADcNyHuQK5JaQB8iC2ebKocEUqPRZoYkSaUrOpyBg4CQcN0e2tNbqD54TuIlieB2toHxKHlGp4sIoEy9g8Gxz1SWEm94OBOWUKW1qNEiICGA5kvQuIJbUMzsDkNhR4vLM/BSWEa7X2GfyxRf3no592QkWreTgbj0p53OHRL39NZI46Fl/aFlKxJulmzoBuCJsPXtlsQZ+5kab/MVqAE8OQk76YNIxfUkhtKlfRnPyUg0o4/mAvYQ4Pdn4LpAc3oArgvUl4MWiyAsb5pgcOcx/F2X5D6JFOCPJf6SWerVT+fgxVLZbC8g0Puok8qrlbDohbCrmC8QmNE+/DTYO7hVSLrPuu7kmf5xXQLUG+XQPWgXYeKxumGC+o4jue9VJ4xp6SVcJQi7zRZfmq+brc6EtVhrTmunedOiO12UAsAiq4fCSaIaA6tTEk/r5w38uWMxemzd7Lu0pud7guUv5DGqGmYQZaUsATcYwNTvFi5910qAx70treHxPbJFKm5pn8Ko7Z9pu/322/GXf/mX+OzP/mzceuutmM1m8N5jMBjc63NdE1D9mq/5GnzzN38zXvva1+Jf/st/CUCqR33Lt3wLvuZrvuZaTvlp3Uwupi/lxWMi9AMvnvWCUJ5Thi+XGtnM2M8tZmM285cb0Jeb00LVZ5YqoMZpZsVGNlR/WhyerX3mkswlpYAUJ5qvHRGgkoA/S9iKgBPJEgcS2I0sqqEol+6T9OdV3UKU4nhJzkdVCW5VCNyOtfCEVaNZrZ1cY7lK46ZxjagrcF2BQPDLDn4e0A8LtNslBudX6AceofaqwerhyZJ5hHEMdSldOZyDx6UI/c8qYff6HrQ/BVYr0MUj+FWDxRMeDL9kBGU6i7mAOq6lqlUoJXvbLzr0g/SqWiyqs/KiY49QClsPSByubxncS4wqe5FhsspoNtzFcQtwAEGBR6G6ml0rYLvtUshJBqDd8RIBUqs9Am2wJJF1PTBbwnUdwqhUdylJ7HAfYglTQAw410ohCxcCcErcyVi1YGL0FYkKwUr7UdQipG73EIIweoullAS1dwjZnAmsISwKIvO/R+NO549El6b3ipAE7onSdDfgazF10etAApb1Pao+uq8bOYPRg+6+hOp4IWNGJC7t7YmMa9cDh0fguVUVcnCDWoAzQ1gxR2JQmYvWMq3PXwL2diQ2dV8y5H1ZiGJQXSIMRBPXXToCz7SKWl3DFeLiZ0CUC+ZLyfLfngizORBg5xcdygsLiZVVkXd2BJ4M0Y8rUXfgIO/CNIDHA4SdcWJS9TlzL9XH0PXAsIoxrjQV4OgnI4TJEO5wBj5zEigKhHEFBsO5CfqRRz9wqD58GWHk4ToPBEI7cfDLHs2ZCsPzDfwlldlyDjixg7A9Uo+FxrMvl+CuT1JlRSH6uMwCbvXzmJCkyUs0HKCc9RhekvlYfGxfSiszBKyWpa5nBIReEr+6Hv2owOozT8K3DuXFKaoP7INKDZPoxc3OTZeIAANlOcFgfVLG0uZkNI7sOAtfKQoJV7Jwq7JEGNUI4wp97VDur1B97EhilOM6jRiTbesz931M0ozeISKAfBTxp8KnfhipkYv/9xl5wayqFZz+biTEGqni0jvq7DW9/1CqD+io/v3ttttuw4//+I+jLEu8+tWvxq233oo//dM/xY/92I/hLW95y70+3zUB1Ve+8pW4/fbb8eQnPxlFUYCZ0fc9vvzLvxz//t//+2s55ad1YwcJovcKLhywPFHCdYVURtoexqor4uoGEhI0hhQap4kIzKS01XqSiLT0wjMHELIFxk5pCVfGEBmQzJhRcpQC9+NCQekYW3hsgWGkeKPcIo9WeXb9yJ4aaNYwBVuZ7B01FjXG2FofkBbYyDCQxMCZZFSpdUIBYQsMnGfVWygyZBC3Z1UK69CKC9CvAtylBv54iW5viNBJGAc7VXKYt+qaB9yyBc0WUvGnKqTy0fFcGB0vMWiYjEDzBTAq0Q2dkM4E9LXefxDXvtR9F71ddnJccCJJ1Y7kefqW4RpoSVVh7W399ysgeAZ5itWvuASoExBbHveojjq4VQe37ISh8w68NQRXW1KacSai/CgFdEtCGgkzVUqYgVtq+UXVdgyjGvAO7vIR/LACjwegRauyOoVknjeiL0sadiAlgHtU52figh9WqC4u4Q+V9ZpLpaPFw0+gOj+Dn85FiW3ZAcf78vw08QpOS7Hae2ReBQgzycjfE50ecW6oKHzfRympdFzaNMiMrHzuKYtEhYq722thsY+dAAY6DJKpPhho8l8pEkmXpwIUOx1jc906BxqNBIiDxMA6ONLSnmLMUmDg8FhAtRb+QGDxKJQF3KoVBZHZXOIvT27JfbatxCVyADdSw52GUpaUnCTxASxySY1WoZovwEfHEh7QBwHNVan6rQyMB+BhJfJUjuDnLepjCZEBSV/73RH6cSm28ayBP2KglPActz/VDHJ5H91yBR5VWF0/RjfyGL3vsiSlrgq4c4dw0wXmjzghsm2HPcpLmiBGDrQ9Rn96R0IJjpbAYg4slsKEQ8E/kUiDEYFncxk//RuNR7o+9bI2OAc/XaF0BH9RWEg24zsE0aQFwMRi9C4boHBw9QD1Hcfwx42wwpORsKerXp5ZXYBMlYQcYvJp7hpXw5xz75QCUsb6esuDSip2NVJBjcdDNDfvYHn9EO2OFOzYev+xrE/moQoc9WTj+qxEBxv4tT1GQXMiBBSYWhluS/I1oG8A3vpuUlXRaOa0thtozTwXQlaYUfhAu7+33//938cv//Iv493vfjd+6qd+Kn7+1Kc+Fd/3fd+H//f//h8e//jH36tzXhNQHQwG+NVf/VX83d/9Hf7iL/4CRITHP/7xV9XOeqABrmOt3S6gohlTxJ/OEcK4QnvzKZR3XhJ2yKzTuDfawfYiAzG+LmOEIoMaLV+A4DNgCKwBQbbfsb4gGmNERdYPUss2t3ozi09jueKCRKkPwjBk7lFjrAy0xvOwdTpZ1JGR1XOuhUXYOCpYV8BOVSUbTm7FW1Ja14r49KCWDWq+TOdTdo4KAWGh8ui2SvS1hx8XErJVE4rjVhJBLH7UkTJxjLA9FoHzRQOazuTv22PZEOcrkcUhAo2GGJ1vEQpITOyoFHeiJ/TGjuozkvK6neQflAR/1MOvevh5j36rRrNTImgJTtfJ8dQG+JYQSq9lZAUEj861EmfoCN1WicHhEu7iYdSFpWULOpqlijfeAQWnRKo+gAdynOt6MBHCWGJXqWZh2FqvCgIBWIpbNwxLiVFlRrtdwS07DO48kmSWYS2xhvoMRKKQ0Q8L+GkPDAboxxWK/Tn8+cM4d8jYc6KY7Bc3QzPg7LnauxPMgGN1WVJKerFYPwMCVipUpXM4r0/OnOLxQojsHNs8D30mju/EaDp9QsD+Yin9WTXgalvc5ecvi8u3KGL/ebEQ41QVPagsIgAgJ5V8RESeQS3HNYBqrehWKlM7XwiLyKJNivkiJnHBkgqdE2BWqJZm16OdSAWpflLDdx3oeCZhiTecAAqPUElZYmo6UO8kVKVpRZhfh6ofl0BdwC9aYTWPZvB9D3diG/2khls06E9tgbogcaPLmbjd9w8SM3jTaZT7S9QfXYpaRFUCcHDMCFWF4Z1z0UfulDUuPUg9Sm6qmf5Np1qxqW8gqNu/EONVY9gBSLjOzgRhXAEQ7VsuvMRx36XaugyVoIJ4ASAlZiWOVJJiw2QIN1/B1VUMWaKDmVy+8PIMW4oANHIAXgwe8gpOdY1dK2HLG6EARBLiNKjFA1EXQM9iOHgtp3znEuXHDqV8qhrjV3itDPBm6yKZJ4w5xU1bKI1q2so6bLqr+l9RyLwOfQpNANZB6poEVp/+Zi2GP9zPgOr9rDv3l/a2t70NL3rRi/DIRz5S1uasPeYxj8Gf//mf/+MAVWuf9Vmf9QA4vQcteILrObrenZImvhUQ65a9SMXEZAwDawZYFeDFbHqkn6ZVFzdjygCtgksDpBaoTkB03Wy+bGbdRsYI6foRCGRsqH2WH2vnQXaOHKQafRuZVs5AqTHEmuyyyVrFfkKVDrDeD5C49/secAPEG7T3ZTQCDYVBsWQRDAdpYS1LhNKjPTECl6KlKuL5DuXlOYZ3ScxpqAthytsOrtE+Ny2cJfB0HcJNp9GPK4Rayjr6o2OglHrdXHhQzyinosZfLGVM2i3NgJ4HBatB5LAYkhB21InuoVMdy8MG5bFoxpqxQE0Palp0Jyco5pLgFErATxtUhyKTxVUBN/VwBzN5nh7Acinu3RzEkQNWrTCoW2PR3SSAJ0MA0OxtG4sgYzaUiluhcnLfM4ntbbdK+CbALzpJBtO4yvkjT4k6wLIXQFs5VB++CDqeS7Wl7SHcwQzucptJtiFumFKPPmNcMnZpPS6bsg3X5ouTe7V5lv9nIDUzzsjCZZyPG2hMqCLSuGtlpbzTqj4yL2m2AJ/eE7Z91Yo28uEcfHQcNYGJ1KWYywExS5GB1Uo2/tEA2N2S8VlKaViGAGvuOgGco0E0vDCdCwhTQCplXuXd452xJHBBlCHcVEIDqGtQL+dwcEBZAfvHMucedBqr68bCkAaGu7CAO1qK9vNsLn3ZmcjfGaphOhPWtevAB0cC7lpRfljeMEY3rjC6c5beQXvXgxqUvoBb9hIzvrMNZobrAriTSnLu0lS9UbLkUVGIEbBcqfdiIGB0WAtYjeuIutCnM2WiA+AKuPEI2N1Cd2ZHwPi0RQxJOjiOpVcZEGkwdfcTSE9NYGJQUUqy4nAAWqxEdqxXtpSRDJllSsIzaUIqCn3/KAJUm+tUFGAV4DcgwIAYJqOBzKVW1Rq2h2hOj7A6U2N4xxTVx8Q4TOtmBioNoFrBAv0shhv03VpoGHkvoSKwMdBWFOolYYlNJ8QwgfU41YwgYCDFpfJVjnsAFX6qtOVyGdWZNoHqxz72sasqN32i9g8CqqvVCnfccUfUQbV26623/kNO+2nXfMsoFhJzx4FFGoQgZT69g1t6uKoAb43ElWZafGsA00BeYtriy2uxLPb3GJuaHU8uyVlx2LBSKQONSL+bBmgORkP2nRjjmvUzDyWwvhn7a6A1glhk8Ukbg5YLPNt31uKxUjeiQoKi8FhXO44PrzMGFtuHzML3XqSTwKC+h1uJqHs3FKBXnj1EefZI4lnLEk5ZGBFKDyIrc8NJdKYluezRbdexr+3uAP34epSX5iCWsfMz1U10gD+YgUPA4BLAwxoAC7PZ9eDtiQx3FyRG0YyXwoPHtYDTnkRGar5CqAtJ0vOE4mgpcaFBNncr7eqaHm6xFOMoBHGJ9n2syU7GAIUgcXhdK2V9t8bCVik7SW2PUBVgT3ArAYxh5NBuFQglUAwchosWftGhUgPKNQFUAbwt2evdyKMbeUzefwh//gAlEdB2COOBlLl0JALsrSat6JjHZ3k1qbNYVY2VfcqYNGtqJKVMZU5zxXuJW+w6BQUKgILGNmZxsslQs/dI51RdAd1Cx0qNLu/AkxEwYlEquHwgTJoxW4Cyt8iMN4DqGlGAvapUpSKka+o8d4NaZNEKZWI7ze6vSgGwq0aeZ+nRX7eL9rotMPWo7joGLbr4ThM5FJfncg9OysbyiR102wMUU0n+pNlCQgpaKVHLbQfsbiEMCol5BuCaTlzRbQ+6fCj3MBkDXYf29A5CXWBw9zH8hWMJazCWFwDt7qB9+PVoTg9QHiyx2hOjb+vvDuA6RrczlCRUlegKuxN5lrOlhIyEIOMGQhhVoINGH5OCO6um12scdlHAjYbAsBYx/K5HOZeKgVx6SdBrWpWRzspVA1IOeNUmxYDSaQJtp8y/zktjuddoXcTnZ0w+G2PPwrJy38c5Eg0jO4sBusIJiLb51gZQWwPeY/y3F1BcnAkWdF5jRw0o9sIGQ+OwN96nVHaYFUR7kadz2V6Sh4VFrwQSyLTTmUFt+4X9zdZ4A6jWDyM04ot9/2j31xjVd77znXjHO96BqqrwpCc9CY961KOuOGZ/fx+/9mu/hvPnz+Nxj3scnv3sZ1/TMR+vPeUpT8FLXvISvOQlL1kDqv/7f/9vvO1tb8N//+///V7f1zUB1QsXLuBFL3oR3vSmNyW3RNau9tk/68aIepehlBjBUGiMo8ockZP4OHk5FXTlMTqElLBBFCvYiDtcDyg07qfv14GcLQabWf5EkODHFAO1tvHaeSxDetM9ZH1z2c/otlFAa255GOu5ARhyFswBCQCnU8jAcRqDuOrr8RsyV1QWUdx7bfGj7P5yVrjrhG0pC7DqB/pZg64YiHTL4QrFpXliBZoGWCwQ42ZZBN67vaEaHh267Vpc8B2jH3qJtmCg3x5KNZz5UtySTRsTlqhXQLFYCeOmDDsdzzNDRe9ppKoBczkHFx7YmYjQfpUqkoVBJXXd2wB24vrlWrOutcoNmAWAei/9IZJM69lSqmpBQDG2xtHVzE7YHCsD6xc9aNUhjCsE1Zz0PdBOCtBNE1T7jcjxNL2wuDsjcF2grzRMoA2Y3jLEyAW4eQt3bh983S7cohHGWp8hd13mvs0MkTUGn5ASU0hfBfm/rU3kSCpp5eCUIFWJhgPw6RMCgGa9GBaW8MSQJJk8G9t7cdFaPXNSY2k6j+8SDQYC7C8cRICO2UIrZ5Gw+gZAuk4gQ1bCOGZWN60wqwYC1rwMOte7DuBKDKlWxotGQ52qwgTysAYXHtXtF0BzkSaD/p1UrYIDg7akOAmGA4TtoTDihwtJeFqu5HnYmzgeASd3Ae+jYgZCgJtDzj8cyjtWevS7I6APGL3rrCgjqBanAN5WWMNhhcVNAzR7JaY3F6iOGOM7luqRIpTnDuU9Mfmvi4cAM0LTSFWpqhJjbrEAHRxKJ6tK5oHOIwnnUENoMpaiHWOprkZN5vperISltPAKM5hs3XRSYlnNCoS9IbrtWhLqViz9CCHF+tpczectkOJFWSX9gLjuc7Z+U1nqHAxanEDd7wQJbwJkTnYd6o9cFkacswhtY0RZf0Fy6edVrcD6zvS9zNXRUO7d3sO4BmdERQzz0nfLkc5lfW95wzNohEUkIWxP23yv8UD7OK1pGjztaU9D27b4/M//fEynU3zP93wPfvAHfxA/8iM/Eo+7/fbb8cVf/MV42MMehsc97nF4zWtegyc/+cl4/etff6+O+fvas5/9bDzhCU/ArbfeitFohJMnT+KXf/mX8c53vhOvetWr7pHU6Ga7JqD6Pd/zPej7Hn/913+NxzzmMXj/+9+Pd77znfjBH/xBfO/3fu+1nPLTuynG6GsJAaAeIGLUl1v46QrF+SORZDHwVJXgYQ0yMe/c4rbEI5OqspecWNz+tsFtWu0IWRhB3rnss9yaNYAaWdh8QU2LWAoN0H5coVZg54Va8dkCFtkEs6y1L5usac5Y5bG7du0IWjj1L1/4TWQaSGDVGCyLTzyayWY0GaM/tQV/MEM5X6J0BB7V6M/swt99EXwslXJQaL3zZaOyQIzy0hxhewgKBHcseqxhVMI1QRjMphdx/EEJf+kIOJqmSjbmYmsUoOYshG0ooUufTefyuSb+0GQMdJIh7ptOgKsmtLiOAS/uyDARltcvG7k2EejUHnhQRfdpOLGF7swE5TkWIMyada9VjAgiP9WdGsNPG7hFI5nrVYF+JOLhTKK56doA10l5VAkLKOAP1AhiB7+/wsATiotTLG4YYnXDBKP/+1Hw1hD+3IEwkOOhVCNa2xyzjTE3RixcAQCpVuT6pmj/lk2cLEGl6wSsWAzo4bGGROh8MZCg1yBXxO+vGXh5XKyGYqDwEYCibUFm5GjWu2Xzw0JgnAP6TkFUujc2nWO7Tn5feQWflUpAdQoutidAXUuSYV0AwYMWK5QfmUt1rrJM74MCMW5a4OQOuhMT+KMFaLqAZxaWm0XL03RjqShE29U74HgOfzyHmwzBIynZKkaXqmzUUuLUnz9AMV8J89mHBMqD6s3eeBrdmQmKBaM6WKA4WMLBwy0aCTOYzlR6SdYc7kNMXKPtiSSgmVdoqWWmlZXm5UrCHmwJKgpJDisLhC0xoNg7uEUrSYYaXiEScybiT6CyFnDXCwClbI74roc/e5jWq1y6ahOc2jO2uZ2vqXn4SjavYhUt0ufc96DBIBlQ9p3FSlQm7PtxHVXpM/NcMWQu25pprnznZLn1Xoxok9pTo0nKKhdpPpqxtRFOEBcu0j7bOxvXdqTQFOeEDEA2PraX3F9adkv36TXuYSMi/Mf/+B/XJEOf/exn46u/+qvx9V//9bjlllsAAN/7vd+Lhz3sYfiDP/gDeO/xrd/6rXjMYx6DF7zgBXjuc597j4/5RO1XfuVX8MY3vhFvetObcOHCBdxwww340R/9UTz96U+/5zeVtWsCqr/zO7+Dd7zjHbFm6y233IKHP/zhuPnmm/Ed3/EdeMlLXnJNnfl0bRQkloo9UM5Eoscve5SXZqDLx6kaVQRpvbg5ASTWDkgLWpcAmulDAhlY5IhNk0vfQCEDmy6FXDuVkYLbbfPPF9ZcCiX/GVktvY4xA7bYyolTv5kTg5p8+OuLGpCAb+5aNXbU/m79zLUx7d9AAqt2mRgekTECXl2lR8fwcwm/oMIDtdTC5u0Rwolt8N4Yfn+mpQfbxHKXhQi2K5vpZqLhyJUXBrVnkdopHNyikwpEvbjyMRDmB7Nl2tAj+EBMrllbuHRTYA7AqT1hilaNzJvRACgLkXLSRByuCwWLyrwMatCJXTmXsq4gArYm4HENfzDXMBRx65LGNtp1aboEJgOE2gsQ7Rn9qEA7KeBaRnWoICZ4uEZdrCShLv24gpuuxC108QBF14G6HoMPzIGtMVa3Xod+4DD+y48J2zidg2MiTD43IKxfVnFK5lxIGd0K4AxQ5vqpZIbYcgXa2ZLxXa4E6LXmdkRilLLNl/QdiaL5Ci6i3eWdPFsr1mDGh81TCvKsrChDs4rzk3yRvXcUX40Exl16p3VSiDeGZB55LagxGSGc2UEoHNz+Mdy01XAVja2NLmOJt2UF0mAGb4/RPOw0CITi0rHc42wJqksBZMrUxve/8DJ2Jpzf9qCpSD3xsEI4uSVj03ZSTGG+APcKMhnpOU1GWH32DVhdN8D4vYeoPnIZWDYS3+m9PNdWWGVSwMPMEcRTWYJ8Aa4KKQN81wXp0962jNGqifdLtcRXUilubNbqd6Eq0I9LlFqFzmLO2dbVPoC5BahL6421PNHIXNfmmYoVU5Dma5yzaU5HoGrveXrMa3MfEIOFtyfguoC7eLRm1LMRB/E90HjuDTKBSITZoidUWXKy/AenIFWNnwjO7W/kQKWX2FbbfyzPIA9tyPcKY1xVngtaDSwCXosJtnfsgfb3trIsr9C1t6JMH/7wh3HLLbdguVzizW9+M37mZ34GXtfBRz3qUfjCL/xCvPGNb8Rzn/vce3TMPWlEhK/8yq/EV37lV35S7u+agOq5c+fwGZ/xGQCA3d1dXLp0CWfOnMHnfu7n4n3ve98npWOfbs2telQNUJ2fg9oerumAw+mVC74jYQr6BSJgsZUqur8zEGjg1T6zz8lBNLGAKAmyxmLqv51qGsWFh5Jcz1riyUbMKLABVglAviBbP0i/ayATG4AriyVF1r9cUxbZPRl4M1bWNu+8T30fJWfkoySgja6LrAhrPe2UvKUgXpkolIXG9HXSla0BuKqAYpVlxQubai58D0bYHQuL4R2oDaAA9JNaSkz2Wrd+VAGjU+JC73rQUiovpWeNBFAimxCRdvycRiN1GyvrN6zRn5BkFtdota2eBTB4J4oDjcTNIYQUM7dqVI+0FKDedilWuvApJlLH3B3NUS1bYWW9Q9gZozt9UuJtlyry7wir3QKu9RgsW7h5g+KgkzjWvTHc2X3J8B5UwKqD6wMWuwWWNw2x8yd3A4sVmJr1CWPxc8piRga0LJM0kxk1xoaWZQL6MbZP76XrBbCUZSptWhRakasFd+qqjSEqcn7Or2ONxX1KVQmCzDkaqgzV8TSdQ9UxIlDMz8NQplbc0WthDgZqbd5HlkpLt/Ys73zTgJyTWNHQw995GZjNo0oAigwIE6R08KCSZ7ZcyX9lhfqOA5nb86W8M8uVMJmFxjEXBVjd9dg/BHcd3M42+MS2vMZHIgdFBLjlUMr4zrW+PDkpo+kKkXUKAagqhJtOggcVtv7yAtz+LI4pK+DFZAy6pKDeQfRQV8KYUllKRa3xECg93LnLUUWFlNlmNTZob0fGYLGUd4AlNt0qTLllF/Vh4/hGQyWbD9ncsMS/fm8EP2tFhm3ZqKGXZekD66FHufcnzvF8vtLadeT7CvCqSkKMzh+mv2XkgngMAqxIYGJtKbKvuaoAANXOzhh2nYcx/MRYZcvoByRMIfMOxT0h7j8u9cs8e6D0rnU29uqBIMhaXBZinGxPMnWA+0OLi/N9fA3g6Oho7dO6rlHX9Sf89utf/3oMh0M87nGPAwB86EMfQtu2+MzP/My14z7zMz8T733ve+/xMVdrs9kMi8Xi4/49b5PJ5F6L/l9zMpUFyT760Y/GL/7iL+L7v//78YY3vAE33njjtZ7y07aNW8bwgxfBRQE6nGqwvb6ceRlHAyXG0q1tRliLAWUrjZcfb8yOhQJYZnLuEjfQaOfLNm9ZRCCghZSdMRB4tfAAa/Ecuqjavzf7n7t5sHHOtePsGtmiF/uhrq6AlK0NIAq6FxoWYclVZZFtDrJg9lsDYQzX7kGBAOlxVQkeDaRaFQM4OoY7mq4X7mJOgLW3pCwHWgpzSssWvgvgQsBVeXkBt+wQhsLkcOlAy0ZKjq40K7vvEUvhWlykPWOmbFy1r1UlSWBWmciAqPXFqkaVXhijIOyQxEc6YXOPZ+DpTNmNRgCSuVSZJb7SNhwDiX0Qt6ICFVd4lJcXoO0B/LKHP5Ta59XAwc9W8Ld/DKhKtA+7Dlx5FJcXQOHRfO4taHcHGL9fSrcObm8x/MAlYNWKJq65NZ3TcpZ92tBzoGfNWDebb5FZt7lvv2VGVt9LiU7btDmAQi/ub2MvN4tnZNcUqShNAKrrKHcE71OMqIaH2DvMwaU4cwVjAITldQ7ccww9j7JsajBK0guncAR7j60Cm4IRdzADT+eJDQ5BQkSCMpBEoLqWylHjAsUqwIUe/altea+CxmZO50ljs+81sUcVEXQ+xFe479M6pSErDBaj7WgK6jsBV6oXGsNPygLY3gKqCoP3npciKWa0A0BZIFy3J0L7vXg7uGnF3U8E2t4CTmyDvUcY11IVrKqALX13fBFBOI2GknA2m4uRot4Udk7Kq84buON5BJlr6ij5M8ld3PpH6gLKC1OJZ61KgFyUi1rL3TBGfNPdz2Fd3cW5jWvoezgaxsISfDxPZIeum6TGVEwEzI0ruxmdE2vg0pGypCRrKSiWmibVTLdrkYW0NG1UrTBG3cKSZI7T+rsTtblt32LEQgnmiYiJXmpobu45/4zagx70oLXff+RHfgQvf/nL/97v/NEf/RF++Id/GD/2Yz+Gvb09AMB0OgWAK6qH7u7uxr/dk2Ou1n7wB38QP/3TP/2JbwbAT/3UT+HFL37xPTrW2jUB1Sc/+cnx3694xSvwvOc9Dy972csQQsDP//zPX8spP63bhCCxTo7SptFbEoKBkHyxyNysxqqusZnqyjQ3Dvm0yBjI0U0tgUe9nNMMaFskcz272JIVT+ZCyoHnWlaogTtOfQWSBZ/DQTvt2k8Dq9mH2VoqQIPT950TKaW+T2uXjQMT0HIaL2XMoNnaMVSiKmXj4wAqvTAn5pazRABmyWruMpY4D/h3WZwYEBdami+AYYXuul1J9lgsQW2HYq4ZzYMBvCUsdV1SeXAEHovLnpYar2zjY6yajbshmFy9oe1BnWbvatIHE0tVJ0/ot2qgV9HuQty9/dYAXHoUChZ4UAiAaHvg4FhVALQc7KpJGzaR3K9teoUH1TX8tJFEk1ULmi5k01/1KA5FVql/0Ck0J2qM3n0O7mghKgnbNYpLU9CFQwQw2ht2UVycobtujHLaizvTyp5GYKrzzfQbwdEIIXNlmwyQPVPrey5pZqxSlkUtz9al2L0QUgjNJkg1Ji2Tp+K+i8oJcfpbcoydy5oxmzCdSj2vlU71rPfECZyb3lyuSWmGalUJC6zJKzSdr4FhGg6EmZpLiAlrPfl+MkB3agJedCgL0Qs2xQ9arJK7FwI+SYExr0TAnnRM3PYWsDOR21a9WO464MwJUNsKi2yVzixkw95rAHx4LPJYFq6Sg6LA8HdckGPLQirQtSLt5rbG4OtPif09WwpDezQXY3NQIeyO4S8ciqB/ENaYLu7L3/seqNQ1XnrROtbqYKzJaGsAsywyEKWfew/eGsq70wfQcqUGVkixv2vrq04M+8yltYerQt5fa/m+YMxkrdqti1WKSc3Du1imCcXqUHI9CmGNE1i7tq6ZZC541WmN8dk2Bxgx2Q0lRy1eNu+EUwMlJj1m+4u9kyFobHSh66qVDec4Vtx1wo6bV8sqtt1fmm6J9/k1ANxxxx3Y3t6OH38iNvX//t//i3/9r/81vuu7vmstDHMykXfz8PBw7fiDg4P4t3tyzNXabbfdhhe96EV///1ou/nmm+/RcXm7JqD6B3/wB/HfT33qU3H77bfjr//6r/Hwhz88xq0+0LKWg6Z8k4vlQvOYIWQWvG20+lbEzYoErEWQuhH7lMc22mdrrqr1ywGQpJVVIwuQxbkBKS7L3DVMyS1vQCUDb3EBzs8fWVSKm3ZcVHPAGl2aSMfnm7LLvpMzxAbELfsfOrakY2C1qzkAgeAvTeVvk6G4Z6fi8kbTqOACyULbKIC1RA8zKPLY1rVELQBMoMvHKJaNAL7hQP7QasjBIsWhUhwz7Wen1W2s4laUeMkW+zhXWBb7tosuVg4MbE/EhbmUkrFhXMnUWWgFLQD9pALVBbgQaSwUXsaiLkCXjxMLZwzPYplcf5TNwSAMJFUFcDSFOwhwVvf85E6sZkULiZckJgzvnMEdCkNHTYf6w5dR3LUv4316D/3JCY4ftYvBx5ao7rxrTYonspX58zTwypBnYfJANs9tc7RQgPgaqIJAbnBpPKmw2Il9XQuBWTOO8jlnn1GKOQdHMJg30rnMsRJQBlIBjWGlCBSYACw7oC4lk9v+plW4IkgOPcKoBPa24KaapW5zqygkmWi+AM/mAqgGFXD9KXSnxugGDtTKPKVOCjSsSwzpLYUebO8IQTVZFUB1HXixFEOraeXfZQk+nokUl71DViO+F1ey3ILIIwnbHNbAoRnlMRu9loQeqioxpLYnYhwdHAlAHw5kDk5GaE6PUFyUOR1BMiAhNygjmGTvQU0nYQTKfAdPIHai92trmzHrzEmztetljlt4QZfG3UIN4vzIQi7k5igpCNQleFiCDubpOzlJkc+7tl0/N5Km6pp6il0nzy2wNVf7Q8pwssla9YjPMzLj4AysMjAZSXEKjcMmZAabxV5vgjlj0PteSgfvTECXj+Q6VQGp+dzJvKhKVR6RymkY1vcz1/8/Xtve3l4Dqn9f+/M//3M885nPxIte9CL8+I//+NrfbrnlFpRlife///1rZOP73/9+PPKRj7zHx1yt3XTTTdeUzX9P2zU9+W/91m9d+/3MmTN4+tOf/gBI/UQtVu0A4goSNylOFiyzMFaWqGHNAJ0lUFn9bw4pq9QW8xjMb9/lBHSia14X7V7dnCEIk2QbpV0Tei5js4zBiayAAchsYQQSWIzA0k6YsQRY/zj+w+51jb3Sk4X8PpDuxYCGMX5RtoqTRR96WEarO5ZKN3AuxSfa2BKJu9BAaj7uKv1EzoFIEnTIe2Ej7HqjAcKpHa0MNJfqQE0rGcR96kOMUQ4MWjX6O6e69VYXOz47xAQeGo+kgo6BoYGU5GSQuPpLjYtTFx6tOrhlC39phuLsPopzRyjvPgTtH4EuHQljdXAsAuVbY3GRWgUck9XJXIds7IiCErSdxAw6Bx6K+7X82AFwdAw+PAYdHMPdeT6VsL2wj35niPah1wE3XQc+sSVyVj0wfN9F1YQMa/+RIw15UQPB4uUolcI0JYT47sS5m823CBiy+RXdvDr/YggOZ3M7m5MRBIQ4P0gNDJESMlDAmYEmoCxKDeVelDzMBQLQyHuZY5WEY5ieZgRp+j0GEE7tgCZjuIM5cDAVfVCSdYKGA/BsJiDVFEFO7qLfmwAMVMcdCITVDVvoTozgZiv4uy4Ch8cy3wgRKMpcz1y8Fq7QdcDBEcLFy+gdg8/syT0fHgsD2qsb2u6rtIQ3hzVtU3uv9ZnHGNVOpKvCwSEAgtvdAZ/aFc/ApX2Zh9sT8HiIcHIbzZkxHAhuJnHmcDpHTp9A+8gb0d+wh3DjKfDelrCrZoBaCIXLjB57fhZKVRag8TAZr41qKreSYEm2Fm2ygGzALz3rKHPVdPLsbM7GeRmiXrNpHiet7XR+tu+ZximyeWfGHpmJrFW0LBHRvBF2IiNVjCBgvefCg3a2Zcwa9bKYPJjF9VvMaR5ioOs2EQGjIcKNp+IzZr1H7kTpgooC2NvRwgG9rMNGOtxfGv8j/Xcv2l/8xV/gGc94Br75m78Zr371q6/4+2AwwHOe8xz80i/9EnpdN9/1rnfhHe94B77iK77iHh/zT9GuiVH9pV/6JbzmNa+5RwG9DzRtuXsfQAQfEadmm+IaM0lYYwpt8hqLYfjN+xTnE1lFbIDBDFRm7CXlyRXeErVyC5xEVsq+k583xmpFigCRjUqYRo9XZiePwYovI6fzAUjubRu77BhHkEwKFleqgYjoIqf0XSvrZ2PMiBsruk4BKrJnYddUF7IlX63FV5H072qGgD2jw5mAi/liLZxAFn6fAH/IxjAWLUB2bO7uh7Jo+kyqQmTMbEPxTqR7LC7Sxn00kAX/eCbZ/uYKnmm53raTDQYO2NoRpuPsJZHxKbwkB41GCCcm4NkCbv84jbX11cDVcCDg+eIBeLqQjXBQg+ZL0MUjcFA3ITmEvYlsQpVDII/FDSOU0x6D916Gy5ND4txVoBfS9QAktkgZ0lhWdZOVMjc/kEBcPCa/F6wDBXs+m0A371v2OzOnkqs2t+wiVwMuuTGVg2ST2lJGl1iAHM81/tIUBZyUV/WqIMJZ9S7zhvA8VWTivgeNR+CdCdyqQz1dgQuPflKBC4KbN6ClittbAk2+DmliXQQ24KSn6r3ELm6NgekiJbhZzKI9RWaAlYkLPYhcyu42g9jcz5Dx4FWjwMUBVYGwMxYt6ouHMgeGolUb+g6rm7aAwCgOW3nHieDGY/DuBMtb9iRxrCT4JsAdLsQo6kJ0S+dJRwDk/SAS0DgeCiCdr9afvT47q3JmS0kMlbAx02RVZlGn4GzuJvY1m4PReLex2HgeQAYyOe0NfQAQ4jw0Zjom49k8Z0RmnLQkdPSqtV1y4wcxsKjrQAdTVT1x6+chORfKQp7HqhFAGz0fLAaWMrRgyFwuvNzKeBTl7YRN1WcwXaT3/IF2RTs8PMQznvEMDIdDTCaTtRjWL//yL8djH/tYAMCrX/1qPOlJT8JTnvIUPO5xj8Mb3/hGfNVXfRWe97znxePvyTGfqH3wgx/Ef/pP/wnvfve7r0gGu+222/DVX/3V9+r+rgmoftEXfRF++7d/+x5LFTzQEN1Ja240a3HDzxjAXN4jdx0Z4I3STxqb6bOFLAJRTv/OmLC0SG0AQdq4ljGi5j6NgtOU7mdzo48gNjMJDYyb68ySQ0JAKvGq4M/6m4cQmGZsBK4GjrP7iOEHLl07gkJKoQvW57gxbDyHnG2OTKqCU2Ouc+Y4ByLZEFPTRCkgAy4yD0IaC6IMmGfPwP5ujSi53ZWNI+ck4ahokqu5LPUanJQLHKXiAcZQVGV6ll0H1BX4xA6oaUFVIeLshUd46I2iTnEwA7oO7uKh6n1m92qsTFC2r3cCiG1z83WUuzEXcTgxASYiJF/feQCaL8HDGuHGGvUHz0sogD3caDxw1JwlR2B2kIwbyHPJXPzRSWEeDIszvuqzRpo3OeC2GMn49ziJ07y03zMpNIurZDOkcpBqfdj0kiBkc1PlguLc1HcdFI2PGJeo1xK5qGyu2ffz61Kaf1SWwIkdUQXwTrLGtQRtcdjAXZ4CB0c61okZ5AzsxMEMARYKY2CJmeEuHYO3RugeMoabrSTWOMZD6jNjRHczc7/utbEEmwhw9JnUHrjhFPqT23DLFnTHOdVFdaDBFjCdS3TAYgkMBmpoVeBBLQZTHzD84GWgKtHvjeUcyoZyDlIpew5qBMaY08UyhedsGAR2/+SUOGCWZd1RDHMgk5VjxKS2tXXN2Fj1lDBvlPjVPpErIgPNa8Y/g+Dj+7AWmmRzztYU1jF3BUhj5eM6rV426x+HTv5WlTLnC9V3LkTeLkq1laK3yrbOaLEAmOpE28HfeTGT7YKELp3YAbZGwMVDMZRCUK9Nn5JVH2hXbUSE7/zO7/yExz3sYQ/Du971Lvzqr/4qLly4gF/4hV/Al3zJl9zrY/6+du7cOXze530envWsZ6HrOjzkIQ/Bgx/8YPyv//W/cNNNN/29IQQfr10TUP3CL/xCfN3XfR2++Zu/GZ/92Z+Nyur9avvGb/zGazntp3ljkY8xMBKtZEqgLYI0JIBmLKkBr3xRs4XI9iRbDDYBWGR7so0ibmBI54/MJK8vitY3S/KyxTudTO8FWViA/i0HswZuSY8npFAHA22cL646Pjloiaywfh5BO6VjoOeyUoGRHXGpL9Y/ysZqDSRvGAmAgl5jEnntNBH4cP4hUhzhxlCBkIE+Wo+/Ctk1tB8U45kVEBAEAB7NJGazLAWQmXbnoJaNxpWJIakrKTIwqsBbY1A/BB0vwLsT9Fs1/KE8H54MRPzeF6CuTYxy0yZXonMiwm/jr3OD2w4pVs7JZtN2cT6H63YRJgOUZ4/ATStJNkUBOppj6+0f0aSJDMjlzGUnrlU2YGgGio0nmayaJAxKRjgyI8VpYiBS/3LW1ZqxTvZO2FRRo4Kj5yL+IXtPKJ0vC0uIz12fr3SZ0j0omIyAxLpiyhbxlTLQ3oFCBmxsDDTGMwJZWzOsb96BtiZoz2yjOTmQTgWgvrhEcXkhoLfrgKIQrVIb6ziONi+RgIbhVkswBMnYz5fgXVXAUCmr9I5QmkujoXgGliuJE+UUu4oYFiCGGNUVEAg0b4HLhxJyMh6CtiZikPXCzqKqEJYL0IVD9DedwuqhpzD8wCXQdClGY4DEqus7I4lT7dozjGCfWc69yZ6u/UxzB30Ah2ZtjuXYnuOAxomb1qmcIFCAHE5vw880ocieZZCyzZtzNyXZ6jh7rXiYrZvkOLG79rl5K2xNsvsyVts5kLEK5o2qSvDOWFRFlo2ELhFFyT4yVQYAKEvwUrLGKfSw4osAIpClugIOpsByBa5K8fT12bu26Y34p2xMuEKP/L64xj1s29vbn1AJwNre3t4nTHy6J8d8vPaGN7wBT3/60/G6170OL37xi3HrrbfixS9+MV760pfiCU94Ara2tu71Oa8JqP7iL/4idnZ28MY3vvGqf38AqG62jcUtByz5RpmzbWsAK9vo1uauvsDmoo7gMiTwkG+EsWUrprG4xnIagIx95PXPzYoOyozGzTwDjvbltfMg9odIywHmgDaulQZuMze+gfG1pKIMWNv142LshGGWE8h3LJbOEgSuSC7Ifo+AIgMrxohGyS+7R07XZpLLkUugPlbhsvvbeBZ2bnKSkc4MtLZhQZI8AoMLjZmzZKs6qxBTDoDJEDieCwOxsyWMLlF6Xt6BhxWIx2hv3AUXDuX+UqrwmI6kuvZQCzPrjubA0VSSvzht3AZeGJxAac5CQcpwMiAuvLqO7j+3aOH356nErRpXUuXISloqjHNIc8TAQ9tFwHiFURfBQgbUNo2E/GecQxq1t+ZaBdZldSgBWHtv8hjW6CnJ5mjOIPZZOAylTHm5HsX+sn1X7ymvlR3nSlFEoLD2t/zYNWZS3bbGzro5/PESRe3RjQtQYIRBAeor+AtHAoiMzczeC7KkGpbfjeVnhOhujqxqALBqUH74ot4XJWYt9wiRMI3huj1w18N/9BzQBlGscFJZjDutvlZIBjiFAFpJ+Va6+Xq0122BvUN5aQ46d1nKGy8XoK5H97DrMH3MaZQLgKsCzjthMS0mHTrmtg7kiXNrz9HmEmeeJXsmLhkl9p0MVFFmWEXmcxN05Wu9Fl0wkOsPVH5qIGE+rNqw0UhRlYRo0OTJtRHoZXuQsu5RL1sVaHKlC2ZWGa+BGLiOgMtHcm7LZzi1p+8vZ+8Gizwas4BRZvl+pdq7xsY2jTjJzOs1HMg1rWhEYNHctWSuuMc80O7v7UMf+hC+8Au/EAAwHA5xfHwMALjxxhvxjGc8A3/0R3+Ehz3sYffqnNcEVO+8885r+do/48bp52a8m21K0eUM+VtMtshYnxiriQQCA0PkPfTztTgvXaAc1hdGW+QiC0npfHai6JbPj1OGNwKu7D7yW6XsOsYOlimRjAlJAiVPluGN89lmu8F2gTlt1vk1DRB423R8WrjNQi8LjXVDAsM2oJtglUMCQJsuf/tOfHbZ30i/a/eYl0+MpQ+1f3GTy569aW5CExRYKjeBFZwoUynnVTZ1tpA4xJ0JMKySnBQI8A79zgRhUKDoRdeVekYYlOjGBcpzx/CmfFB6yaCeLVKVJs5vV28yA14WW0gxq55SZS+nahKWkDNdqC6q6jxGaSdEm4D5SmYxd12vZdr36bnEbOursaT5XMw/M7Af/yOZKxbrmb2nbOfwDmsx5YA8F0uMYyBK7ih441gxjrLQFU7nCAyY+9vetxgWk3W6Z/mKczEhi4BokEZQBGXNtC479x3gPNzutvTpcI560aKcDBAGJajr4S8eib4uOMUB6/y2OFIzWiVLH8kYyOOpmZOgif2dIAYLs2TWW5w4ADQN3N0X5RlaZr6tEyFEGSyURfROsHfoHnID2u0K1AdUZ2eg8/vg6Uzkk5xD/7AbsP/E6xAqh/KjKyn1u1zFUqtr88TiJ9XQWpsjZqDpesS2ZkZwunF8/i7n1yDVi+1VycE8N9EAlHnCzOC9icjNjYdw+9PksViZooReJ2TvRZ6klTq03j+9OwKSYkNuVOmcpKJAf2qCxa3XwbUBo/dexJrnpyySQglzBK8WGx4ZWwu9ajtJZDN1FRuTvo95C7R/JGu612TJXrwxVOEqZMs/bduwRe6za3wqtrZto5f9wQ9+MN72trfFv915550oinsPO68JqK7HQN3zv/2zbpGVydi4K4bpKpuzLSIG5qzue/xbho4iSDXUxljTbaTsH9ElT1n/tE/550C2oRqLmsWL2jqYA++Q9SvfwOw6vVQDYueEPbBzmVKBAQID9ljvzhoTmzO5+WLLLIuk3ZQBTXUxcb/MxpvX2Wz7cbWwgzU3rsYHpw80VMP0PUMCvAY48mfeG9jMrhGTZzjFdOWGhW3aUX4LwKoBL+XZ8N5WKnFZVwi7I1DbCzgNjDDUMq5dj25SYHmygFvUQFVINR7TZjSx+6IAulZBZEQfAlRc6oP828Hc9sxa6WftHhABbtQv3WBM5Z8UN/a1Oag/ue20/CWldyN6IXj9ORHUmMvmhV0jBAk7qEoJQ4AAQNrUsM37YUL3+syZ1ACLAItjTGXycAAp5nzjfuzeC5n3pEwlgAREI+tOEcRF17hmxSOQTmd9JwKnBJsQpILZdSfBVSkMaFFEFQgwS3LM0TSNHxCTgGICHxCNZWKOjHpkfS1ZirM4WZ0nYpRojGPhQeOxXGcpslU01ao2zq2FLnCniX7XnxQAc/lI+sYM6hjFvEd59gh0+VAArRWHuOkUjj7veoTKYXR3g/EHDoFls64GcRVmM+1d2TjnbHf0nnB6/3LvzPrJ5EeM/dSxNKacAXhJpiJz5deFFOEgmWthUAAnt0SG7tIxYhEOW1fXKlzlcy5ke4POg7qS8WnVcOlD+n40+BRQF6JiUk47FNNWpOZaNSpVh5qWTRpDi4c35tzmZa+Mrel3W1Jfbmx6Y2l7ib+3YhC9KLeIYfFA4vanYnv+85+P2267Dc95znOwXC7x53/+53jd6153r89zzZWprtaapnlACeDjtbXNSjee3qxEBSZrIHXjy8Y+5qAwP8Ys87XvUTz1GusXcV4GnCNzowdE6iI7Fpw+yBfqtZuMX4j3KRgvW0yd07hFh7jw59cKBjI56xfWx8eApbmFIl7MQQqtu+QAiW80MNFn7JzL+8IZSM3OmQeb5vjUWIROWYPCi45p/lxsaE1CabnSwdO/OSQmwfpum0BdZexxDpwTgCZjjS/KRo5BhXByW0qzNh08CGFYgguH4riBP17C1QXcokD10ctiMHS6qQTdjLYUTKhEVmTRTH7H9si8vKoNU6H6vnmcpgK/yGjl47cG4jeeod23fafvwctVAsq6QRIc4FgztJ2UPzUDiACCE9ejXbYsRUbsxBbocCZ6nxFgBZDzKRNd50zuXpVMd9F0NeYyurYNXBprnP2e5hNFcCqXsEpC2RxQYzRWcNokAnLGD6I0QOAIKEWfswaf2QNvDSWByhFcF+ACS2W0/akaQE6evz2OLmMMlWWLhmffi0EEKADSuWwa0HF9y/qr77Ixq2hVjkiP2VRqICcyXDysEEY16PJUThIYmM5RnPUC6mZS8pcbuQcaDtF8xmmUxwHjjy5Qf2wGms7BbSP3FmMfIUUSYklQHz0BwqZn8b5xauq/zYBZW4Ov/lzyuU1qYLK562162bNdNXBtJ4lIhYeftWAOopVsDL1dI9OzpsKk9JDWZdtbzIAzJrvwwHIZ458ZSElzROJ12h7DHy/hP3QZYXcst7w30TU1wM2WV+qCq+EfFSBi5UXxCkXPkj1vMzRtjLyXtaPr4hqxZhCv2xT/tC3f6u7La3wKtle96lXw6tm54YYb8Cd/8if4hV/4BfR9j9e85jW4/vrr7/U57xVQ/dmf/dmr/hsAQgh45zvfiVtvvfVed+KfRYvAxnaBfHO21YXTsZGB1YXZqtMoMFnLfM+vcTUQC/08j13aBIeU9SFmziNz/wOx6lXuujQQHcFYBmiDMI6xpjkQ2TKxlk37lRDjATkbk/gzA4jWF2PwYgyoAeyMWUAG3FniPNE0khjRmgstG/41F14+ThmAtbG0gwz4kwPtbCGynnZfuRvXNosol2XnYMQQj5hUkV1/ZXFbtqsFYdBiv7X1AeAmjpG7cKiyOwKg3WQom8CeADMXeri+By8a3dPSM4juensGRFouMzNuNl3YjgDKK4lp3GIW18zZnJWvcbbo5xsTRfYpgp2MZY2gJj5C6Qd5cYlTISAnxmgC4L5LpUqtsAUINFuJi3WpepvZhhrvsZSwEbRaQpQ4ex4KaDIwLvPFZecxw4M2kq6s77gSxOp3OWOl+QpjVn8PQf6mwCO9q6KCQIdT8HwFN6hE5aESdz+sRnvbJZAKSGhGF9J4laWMq72LvgBYDQ7T9FQPCBW0ZoxQUUQQT4Dqjao+cN+LcLy9L0CMeYxPlgD3sUtyr4Nak6Y6KXt7RAjLZewjvAdO76E+O8PgowcyrqtGmTxDb9l7nDOsNk8sochaDpTMuPeZYZu/r7b2bL6bBt6dl+c9Uukme9+qIrGW5IBS5cLqEm66lOMXKylCchVjh5nledoc45AkBe196nthnbW/FiZCzPKuAODtkZRnXazkPF0vCg6q0Yw+wB0vZG1QAMz6LKOxFskCA/W9LuNZv+XCYtwbI6vrOltBD3LyHttYb+5pD7T7ZdtMlnrMYx6Dn/iJn/gHnfNeAdVcRHZTULYsSzzkIQ/Ba1/72n9Qhz4t2xqwMZAKJDc60qYT3esGCHTFs4UBmWs4nts27Ku8yWtsgG2s2fdyN6u5kmJfslPmwHTTHbqWzattzVVpYDsxJ+Q9YonETDqK4kar916UabHN2Y0czEY1BAPXLrlQlSFAHyRJJJYBRQLHlN+ojWe+82wcv3ajGUBftQoiQ9rccregI2Et2TYUpGtYAlywe7HQBwW6m+5Fzv5tscIcgE7vZTZPGe5EwHIJahqE07sxmYRiWVGXxhOUZlH+bBSMEXkdmiDDZkl7RBr2kCkBEMUMawGPUn5zbfSuGM80H0nDIGKsqBohBFrf9LI5LmVfKxX9F2ASQwkiU48UdtEvQVo73kTHTdOTLZYuVrtKZSE5n9drBk4CBzHpTI8lInn1Y9WeHKRrM2AcvScb541A0SPGU+ZKBgYObd7YfTedMKALYdVoMpJ3YbmScqpR7i7vC4FIxNYtfjLec6+GXnx/OF0reiz6rKpbeicpBKzF7IZMX9Q5EIt+q4WHUNOCBgMBa6o0kGenW0wqdrYQrj8B1JVUP5sv5bg1d382ptA575xUPmraxAwbE0m67vS9JiZuINC1uGeJ7RXQxyl+M/cOhCC/Kpts7w4FBlatMKl1JTHDRyugOc68M5w8a3a+/Lk7p54MijH4Ud6JOYXhAMnjoeEACCzufK9rpfcSI5upePQ7Q2BYSggRB7i5yt7pGsimOW2Gh87vtQpaGQMr76f2JV/LlxraQ5BzDWrw9jALZbgftPtZ1v/9rf3xH/8xbrnlFtxwww3xs/e+971o2xaPfvSj7/X57hVQ/cAHPgBA5Kne8Y533OuL/bNutohvatolU30DINpmj/S5xQCGPPA9O3/OEF7B/iF9JzKk+Qanv1tZVs4WQ2OJrL9rC6T+L5e08hmTlANl1bPkolASUTe/0EdWlT0l96JpGjonYLNpk6u/bdM19VrRhQoDQPq3sgBCuw6oDTjmgDdHDdb3OKz5+Nq9xovpzzb97vKxZwGo9iyNmYzaqhngysfLrQPI+BzMwIlTJxkVrMUaCJqlrfFkcA5YLOEuHSUwYa5DV6T5Zu42SiUu1xlDCJDr+1RdKa8mZONj/+wVOA1qKWs5X2zMjTRHyKp+WfZ4ZN7XgWxMdqE4AdPvjCg4TnncKAE0HAggBcAcopQSNQw+v9SYzgwE5zHhaoBEZteua2AmB85WzSuPL7bfN8fI5ovNFQMNeUW0eH/2/Gm9LzqO5De1X1289yhpxCzvznKZ7iNqgtqYZsDKwIY+66DJdVSonJD2gbt+XVBev59iZvNyog65RuqackTXp+eSM8iFB46nci7TGdUwEvIetDVG+9Dr0G8NUF6YAhf3hT20dc7WpT5owYIugTsztFT3k9Qolu9zur4xx9k6EytQ6ZhRqeoii1V6zlmsMOs3kzqCeh3KElbliakBZqLVSt6L1q2GS5F3KZE0f/+JJFHJpotHUg8B1kEzUWTI0bQy/mUpiV6dzj9135NzCIMKYXcs7O6qAxcOfS1JnW65Ss/OyBTngKZJBqutu972FUrzk4A1xldZYdsCUdfgrZEkyD5AqX5KtHe/+9148YtffAVG3Nvbw1Oe8hS8/e1vx97e3r065zXFqG524B3veEeUI3igXaUZ0CEkgAOCMGuZW8M2bluAYhJS9ndLaNFTrLmEbdO34/KFzI5nxJi9eE5mcbd5SgCuy8FB3m+7p42/559li3NMRiCSxb4Rq5sjCINsIBbnSJQAlFnayyYlDxBJSVAu1lyvNsyU98WAtyVqGHsXk65sbAhreqo5+CRCKjS8ARpyMB8BqtMEi4yZyQ0QZZrDZCAL/eEsnbso0oZi53X6t8yFHf+Ws+55ZZ+oV6v9texcA/omM5QD5aDlc3Pcl8etccoo574DFx6urIRFWawkXNa0W41VMbBHJCVYO6kuE2NdoeDUssmNhdR+xQzwfN7ZZkgAYXOOq5SRJnPE2Eeba1bi0u7Zas4bQLL30+ZKBjDkfcmZ++wdyo23TfYo9z5EBpGz72L9WO8lzAfQzTlrm+fNr6csVhxPMKLhspk8tPnuroUiZOsUY03EH8zRjZ+79jmsNJOdNH7Zx7WL7R206zoXYxjJO3le1i+LFTXwmwErns/VsA3peQCgugZVFcL1J+F6oLhjH3R+X66pLDmQgD97B64LYKuW9+9YAbsVhQDiHKGyUOCUjVFcHwNQF8KgGuPKeq8+PzYL6bG53WUhCPq3KDkVKIndV4V4AOqhvFfM4LoSvVLovPMusaMmYdf3mQwWJaBo88YM17aTSnJlmeaNgXkicFUibA2xOjMSPwsBbtWBmh7dqSH8NC9xrIlT8CmcJDfCdH6Ry7wMAMzFH5P0Cl0Hg+6NIYCO52qbZ+vfP3EjRkpZuA+v8anY3vjGN+J5z3veFfr6Z86cwWMe8xj8/u//Pr78y7/8Xp3zk5JM9cQnPnHdkn+gXaVlG4QhqriRAdGtnAfEmzvNWIg1FhAJeMWwAFsQ9PO1jHT7u507P78ClMgAZe5xOzh3RefXj0xMDoYZyC9jLmQDRvlGS7pA5q6rpk3AtO8lU1kXXgLEhWmbsCX2IAMFcdMw8MnJkrfNJPYViIlUkSVVkItsvO3zbNGNMb/Z8KaKXYhRHfIZEnPgHNxcRK3XxjL/bm6wxL5mgMeeSQaSSQEwkQdmcxXgb9dZK0AZbJeAmAPQQdyP8ZnIvOBeyipKmV29zmCAcGYX4XgOohqoS2GE6go4dymxdnEzxrpEFwBG5pL3DmTas1bC9yoegQhUAJj7n3wyWBg2xlCgg3iPzAx0YY0FtntiAzNrG6tbBycWJ27jH40SjteL7L/1mzeOt5a7MO3zPKwlA7Yxu99AXDRekebdGpiEhAlXFdC2ylIXkalaU5Gwf9u8jAOd1AesMhNZ2JH2lTVMIn+iAjZt3AXAkC9AVRGrisX7M83efAzyMYzvrp47AFahSVhIn0o/Dwdwl4+lctpSVSv0XeTSQ6o0QYBfkEpeNOvFaK4kuYz6ILGyfS9u8xDAo0rmaNtuGB0EDGs1gIK48QsvoK/vQW0Aoxfjv1T20zxEdkemKWsJaqShBY4QSgBbY/QnxygOllrqGBJSwEieMDPwbY0L+kwsrGWTOFBDiFQWj4YD8Mldlb7jdF5HQCtxs6vrJ+CC0JUEv+pF3J8Y5WUpb8p7W6D94wT047qxriLwcckEp+t1gBrQYmTxYJDCEOZLYJRpBj/Q7tdttVqhNUJgo81mM0yn03t9zk9q1v8D7eO0HBjmG7Bmxa4dY3FLujiv/d1YMttErXRktsfEc6sLeN2lp32wDSCysaSuajsuA5XIFrAI9PSfmikcpYJyOs7YE4vhykEqgMT42oap7uyVsjN1tb6gUSaSHhc+VobOwEQG3OK9ZixhVDLYuJ94v9nYRKMge15GZtv95KET9uzs3sBadMDGjNfjywJL4oRppuZyLfl31sYsf9CcXPi5jFDTA81yzf26NgFCEBBDWGfSAKRiBthgzEIcD1K3nj+3r8k70IxjcVHmhkocTNtIc5dy/nsE+pTuCUhANu+Hspls5XaNuTaw7lwENAAnsBUBqHZhOEju3E2AaT8DpXkAjbHMDZ7N8bO+ZkAv/+yK55zf3ybrauew55wD35DCM+L1cqbckhttLjkHwLRrbT2gdM3caIxZ2Ih9iAwXpPIUVZUaFT4alLxcyd9AkjWucaMSZxqi0Wnfg8/uK+9DzmIbc52FFbGyx2T3BpI4W02UIwXVUdpLr03OSyGBQSEM5qqFM93RRhnediVzotRyoov1EqJhUoNAoGWnBQNk8vJkKPJizol3oevFZU+kLCOl8Aq7N2MYweJtIIAHFbqTNdyS4Y8WUt61C7HMMZpWQS8hEhu2dvZBZOqYNRzBnj5JVSgz8AwcT0YIgxI8GcAfLSS+3s7FCqSdE0dTYJTTgOryAsEDxcEMrvBSlrbrlFzQfcn2pBAkFCHqJKcnJucNaYpGskbfY9Vfxnyp77LT8KTNje6fsGVb+X16jU/B9uQnPxlf+7Vfixe96EV4xCMeET9/61vfit/93d/FT/7kT97rcz4AVP/RW74hZR8zkGLdcrYRWMsSJyj4ygCgMTtZHGECUvFL64CV7TwG0rLO5MxhBJm22SY3Eg3qdas93iLpRxsWPZCYyk1Xu+mp5DqxhMS6xHhBztyeiAucAAO9X9JxZiTGK2eU8xUgjxXNAVUO9CIG1373ATC3cz6gG8AqghNANnMCUBWgJtMwjKCCsp/Z/UWjxcBUdv5cQ5eDJCdkGevxiUZAk56NxcNFFtjG2kCdGjCxGpUjgLVWeVEA45G4bp1u9CzAm23c16jgrF1tryFKscfG3Odz1dyCOZizcxFgMl2mN0oQZiyCyvw7OWvMOQh3688NSAlLCoavOp9zRhTIXN6ZmzKfr9bv+F5hHTRmngDelLMCois7aqsaEHWkrm59riZpxQywMq6m52nuWutTnEbp4US3u8vmOUFAg7Gs1gdLRtPrRHALwBVFqmefP3Io6M/vPQeZeTnofFzIktTkd4lRdfFdl3Ni/d0AoiYnTTWOvC4je0/epzCTtovFKOQZ69gOarimiaCWHaHbG4BHJaisUVyYStyvJdvlcnJ5ImhcLkS2LNQSR96fmoCHtSyBl45AqpbCoZfYUX0+MaafNRQnxpWHeC8RMFomvYF2i1nfHouRXBYS+rBYyTPoenDfJNk+Y1kLh1DJnPAHC9UMBqidpz0ierX6xMJb6EShz4f1Heo6iXGOISrm+mfpnxYaYWaZVwTRl32gfUq0Zz7zmXjGM56BRz/60XjqU5+K66+/Hh/60Ifwh3/4h/ihH/ohPPShD73X5/ykPP1XvepVn4zTfPq3TTehASdzJ+VZ/gCiu9qsTSBZ6AbmIrOGKzaDBKQYqbwnpU3KQN3mZrjGEkGZJKSFy8BTvsnkLOcmOMjPn0s2Wab7Zn+LQhYxciCXMqwjqMizwIOFAYR4q5FNzu/J7td+UHbReBynezDQmIOFTWCQxwuHjRNbbKkL8blTz0DbpGsRrTMOV8jn6Plt7PNyiDkrSelrawkta4xd1r0gOqQRbOUJS4yMNUybKwfS5G4GOw+azcF1if7m03BND3duHzw7FNbHxtUYWAC8aTRlc5+upi+as9shicuvIV0bFyAl3QQGkZYL3QRhGUvNiwXYEopy4AmsH2du8asYYglU8vp3gSx7XJudJ7JpvB5asAl4AcSqQznTacaP3Zf3yqC5CEjEBaxMnIGZCEzXx2ENpNP6cyCbk2zg1MuO0QdhAhXQWNwh6fPMQXrUlu37zM0bpDSwgmBmZN4GvQ8zIIOuXZT1VecBK7sYjdn4TICYrEUUAbT0Udn4ptXbJMRSnyTzR4RXspCLHspsB4TtIXyv3hBHoJ5Rfuzy+jOy2Fh7vzcr6DkC726h2xmAxzWKowbFdIVmbwvV2SPR72VRKuhu2EV5Tl3rhQe1pMtEFn/tHSgQmDU2PJeJ60U9gZxLCVMrCQdyqw40W+qU4CQZpusylz7Os2Laws8aifc3tZDCC9NrGrxB1qhoqDDL9QqvrLG+686vSxoyy/1VZXxmpIltkV3N37v7Q3sg6//vba973evw+te/Hm9+85tx7tw5PPzhD8fLXvYyPOMZz7im831SgOpLX/rST8ZpPn2bbQpRBgjZpgDIpo40MaPeqW7uWfJAXBDNQl/bjNNXYtPFV5pL18s3qk1Qw6xWsJyc85OT9isHgYwYviaALcjiH/ubAdq4qds5NvrA9rcg4+GcgB8DsbbpGlgGyzUd1hc+28xtAd1ky+IaoBshMvYmH2d7HoX1PyQQnIuzG/DMfxrY9ZSeE+UPi5CY5Y3+Gdi28A+7j5zxzcvrEsm0UTkoAtKmvlYxCMIe5YxaCNlpKJ3f4kWNUUQAsQeWK4QQQDtb4IKAy3Pw0bGGC+htqSvaErIoZxmz+RYTtowByg2XPLyCs/7nz8nuM2pw9mrv5c8cEmbjsmeK9G+LdWQrZWvGQLxwdi3KRPc3+2H3FgcW6b0yttCOYSCGAVgYTP79nN3seoAUAGwah0FlnByl+/AuxbTaT0twisUHsrkTpak49o1KjesMDIRW7QoHlBWodpL8o5nz7BEVEwAIcKVMM7fP7tMhMrqx+Ia59i1Mw7v1cIxNkJ+PfSsSWJEVtXG3+/MuxuvKM95gaTURiUx6SuPpTT8WZQkelhrmwnAdi3vfO4STYxTHfRSqZy0jupbgmq/PjkQGy3tQ26O8a1/AnPNgAur3rcRAVyksJqC4ax8oCsHqbZ+KMERDQteBwUD0SC1rv/Byz6yhAOqx4L5PWriLVWK71UAnL8UOOASJ3e0Y5Blu2adkRF2vyJF8f6VJVZzNd7CGQLg0rjYH7Vn2vYYb9WmQFqKJi7pKBs6gTiD2gfYp0YgIX/u1X4uv/dqvBQD0fY+l6h1fS7smoLqpoZq3uq7x0Ic+FE972tMwGAyuuWOfdi0HS3lCVGSufFrgDNhZElIEOAaA9HsAogaoAUjkP+0SLrn88nc9gkJcCZiM1bDzGojMN9gcvHL2fQMKRInFzTfFHIfb3wIj6otugtrIrITUFwOunF0fSJtxBKCcjo33qt/LmeGMUYzXNJCfg9pwlfvYZNwsfngz3MHGJD+n3QspWN4cF2ZgLZEuGxNs9Jvz/mZ/y5+5sh6JoZUDUnXUFHZCe9vA0UzE/6tKgBAgAutOQgvKuw/Alw4yORvtl3dpg7SMdItds7jSHGhnRkiMv1SZswgKvdfHo6Eedv6mS/dlruo805ltvLJGtK5zmh8PBewEkdfKDSk73sZ17R6QzStEIG56oBwoApgYM0iEmNzGuJLddC6B8/zdsGsZAAicQEwehnA1cGd/+3jx7T4D4vG+03yS0pgpuSvqo2ahKVGaCEjSQjkINxe5/qRYYY4SmAbEfWxMXVGILJrp2wJRqopNs3XTGAJJvKmCvbgOG2lgSht9iELzMZFTM+DpeCFx+H2PsDVAGI8RCqA8N4ebakw9WMCV3dsqFd7QKStrwnIlwNkKSCwbcC8MJ0+GonfbMTAaAoL3xVBfNevFHmz+GRBcruR8JpdlrCaRgLzYH0phDqsQdVeJKCowcKvEgCOUh0uEwqHYn4meq4WPWJiPMuRpTYay0iodNhgklYc1MgSJVXXmEeiB4UBCKFYtsFXpWHmNq78fAVVbb+/ra3yKtpe85CX4ru/6Ltxyyy145zvfiS/5ki/B4eEhfuAHfgD/4T/8h3t9vmsCqr/yK7+Cv/zLv0RVVXjwgx8MIsJHPvIRNE2DRz7ykbjjjjtw8uRJvO1tb8Mtt9xyLZf49Gu26G/Gg0Z3dACcZYBmlnJGHAobgfSBsmfx/PF8GeNCem5zn0XXsW4kFs9kYDUCUnX5RUBq57TLczrerm8bQX5v5mqsVK4o9j2zrLNIhNgcRVZDkkqyMAFjqADJaM4lcHSBBfuPA/TtWnrPtoHmyWN2De1HCtMgBRIhjaVJCIUsDIAAcb3ZGDDWNq18DsTHFrDm6rdnuzlfbGNiKBMBrD2btXPy2t+FuDTQlAPaDLBkrC1fPgSBJPGIGWGxRK6DyLO5bIAm52OJMiEds8YQx9AWAV6x1KcdzyECOCsEIMkxAvbiKCggInIxPhaQqbam+BBBaw64bEgUUOl4R4C9MX2vAKE2Z3OGe3MDzUBeFLaPDDtgZUPT+GQPLld2yNj3GIe5aRTlIDqvCpQD3rxf8XNoIl8C6FZBLJZxzZOsQgC3HMumbrLa8oz6jXeU4hhGjVc294d+vtnPzWcG0rjV7Ll6K9pg4QQZMM88CHJtzcgHpNCA9c0qc5kecGa4ss4FHoq8Di20YhkIXDqgcPDLDm7eJAMJAK9WYswNa1mzjGG1zhSqjFEVwOE03ctAklFptpQ5szUGLVYyJ5tWklZzZt9YUk1ilMIKlAykUgGqFg6IBTM4JNmoTp9vWaixpO/mfCFr75kT6LalHLqfa/jGcinH2C31Ot9ypQ7ngNDHcra8NQYOj2RumY5qXJb0WVWVJjYGYDISYH0k40NdJyEIAGLs/gPtft3e/OY348Mf/nDEfi972cvw1V/91Xjuc5+LF7zgBfiGb/gGPPKRj7xX53Sf+JAr23Oe8xw8//nPx1133YX3v//9eN/73oe77roLX/7lX46v/MqvxNmzZ/EFX/AF+O7v/u5rOf2nYaPM7WhITz83sBRYX3wDV3rcWvyV/s8ARpTVyYHQVUCLAc88/i0CJU7xYJR91zbQaClz1l/rO6f+b2688TYNwIaUHGH/WSWTHMDptdiysaNMlEtj6K3mOmXXcOvuzM1m57KxyO+fOeub3R6ljc/cltZiX3QMcobUzmEbfWQtOW2+5k43hjtn2KNW50bfNwGRPW+bJ5R9Nwfb+T0o2xwrVjEL2DUNxDyJgoOUW+1aiWfVZJS8X9xpSUYbk5ypzq/dB70Opw3NAFGfsvLXkpWIQNlcps246BygGABnyKbpnMS4xXhGO0kG8kjBlj0re0+QQBhDkjnIu/R+5KAqZ6/W5j+ycVoHuilWF1hjLdcMzewZ23O2Z2IMVs6wRqChN2bPQ8di7VmsMfD6rDQOkAMnp0oOdu3d6aVSUQzhsHOa3nHmVo+ScXpc1D/dEJ63fhu7HWNebcw5ueG5adI7ZcZCn7mc4/0U8vwLDx7W4EEVly5yyvQvVzF+MwKsOM4cJZ5cG2QeqqfLHzco9lcC3hiicDCswOMB+s84Dd6ZyNyuCmA81LHRFnoBgodTZcKdhAJYdnyrFZkAcadP54gFCOzdjkuArkkqO0ZlKecaDyRRDABpXGhMsDOJMjMEyhKsQv5sYSMhoL/5NGaffRpHtwzQjTz84UKAoxEbhHX22sZQ5w4rQ07Xn0I4syNVxZQxjQl+ZtQWKjtl4V2rVmJlHWlZ3yB/a5qPv7b/UzT+R/rvU7D98R//MZ74xCcCAJbLJf7wD/8Qr3zlK/ElX/Il+NIv/VL82Z/92b0+5zUzqn/yJ3+CU6dOxc9OnTqF//Jf/gu+6Iu+CK985Svx4z/+4w8UAbBmgCLfiNdeOv13jKsMACwbPN9B9WTMmW5dRrmuTWxb1GyD3XDPbFaeshjBj+PuiyBr7TwGSPXzHGAbUs37tAlkgLQAFy5hW1v4IgNlgE6ZNGU/I5OaA8UMCK2PcX7vSIu19SuOP2VgMf9d+hrVBYxRI4ekBHCV+84BdRwaBWzxHEh9ywFvzApHAixEGeupbS0Ol1Osp4mMGwvWtuoetme6AW7yccrHLvTgJqRxiooTLj6LdVaMkivXgHl2+vwZxmec6KL1WG4Fd8LIAbEMaQRLBPQqS5UZVZwDDjMUc0CZ364ZIXG4E9hkcPodSPcU54Y9k8zlbF/G+rVYUaCxqdHYWn9J0vcZwlICAt5yBtQOzd/T/N1jFoYqH2cDnYxUahNI8z5flygLW4hMLK4MTWBOxkoMQwhgk9EF1mNjrS8hrP3OXSeJN3ZsHBJOrnhN0Il9ys+RGzEA4DzIQ3Q/V62EiZSFZNHb8mKlRYkQg+pJypmydyAQ+u2BZMaPB1I6tG9j0RJ7t8gBKEvRFl014D4g7AxB02WqjmZIOfc4OB8BM5hBVYmwNYK7eCDxnZkRamV919bYrlNAL9JwXBagZRNZbxCEHXZOk+D0ewp8w+kd8LCG7yFgcLEEhgM0N25jcboAwPCLDnT5UP6ujHt8pwwsx7VJvE0EaEypg2t6AeydGMQS0qNJWjZfujY9u65DNJJaZVNbAoYl1siCB9r9tg0GA5w9exYA8Hu/93u49dZbcfLkSQBA0zRXFAK4J+2agOrZs2exWCyu+HyxWMQO7u7uXsupP42bARjOflL8OC4+Fq8aN4zc/c4JqKyxKdlCmF0qLd5ATMoxAEQuHcMZYMmvayyJsRt5tn28Trb5wa6JjRAApAU6ZN+xOE9O9yaSNz5tItY/59dOlzYrTj83GLOEFWg9vnMDl61t8rnLcsOkNcBCTjNvo5RSBnjtWdp1gbShGosS/5SPtT0LZHG2G/cAxiYjKW47Yxsh45uPRUjAj9s2XXPz+WxKdOVjGfuWzdk4JfPPZG4IA2Wg2aVnYeOaJ+8QQBDt02iI6UYuQ6kMmPaJmcW1WWj5zqUwLZKVjXUwhOz3nIkFMrCouqu+QIwr1mQai1ONj8mun2NLOyZzc6+1COqy520fb2oLZ0Nt5yXOWNH8v/x6hCTvFRJIScZPNiZxneH0+dWy/i2xac1gy/67YmyRvssMmNwckEDq2nuix9m6oO+9MJceUvKYk1ZvBlKsolV6zhTXSUsUuiIusuuli1ZByxhZc5dnIN0qm6EqQU0HngwEJM9XoIXInkUwyBCMG1YIlRcX97CGn7fgto/VqLguRSlAK0yJIdGlex/UAAju8lEaN5s32dyJBqD1vVT3f1WAFitJkMqNsm6Vnp9l3APgYY1ub4Ri3oHrAjSDhApsT1BfWKDdLUXR4OJcmM1CNWfBgC/SvLHEPYv17XplqR3o4EhY3VWbnlPhRNaQCNwpU2o6u+gkDKCu5HMCMBggGUob79Y/ZYvP5T6+xqdg+9Iv/VI86UlPwmKxwG//9m/jW7/1WwFIIYA/+7M/uyYd1WsyUZ72tKfhG77hG/A3f/M3YHXZ/c3f/A2+/uu/Hk972tMAAG95y1vwzGc+81pO/+nX4ubistg22zCQASfdXZg3ZIsSOEHOcBgrkm8Y3iPqroLSeWyz80VyJeXgjaEbNSWL1zZMc9vFhYJSv0wPNGd9rb+2Wa5lW9txesyGKzTpdmabSM5pWUyZufENVAFX9jFL7LlC99LuN08ocdl4xnFd35w55O5CAyAZ0Iibi4EB+yxzk9nmZILjOeMSN3CXnneeQZwtXpSz5cbuGivemztf3GfcNulZ5a46HR+yDP21Z5i3jwNS7AvW164XkJCDWEDuxxfi5iwLRENJr0UkLKvNzbghx/Prf5b8sWwkjs/YqDivtXtaTYuKIt4bOVoHPAaCQOKWZYCbNoJUedYcmay1OMn8nbCQhk0GPwepLHOadB1YqxG/BvCQ3sEo4m9zSM9nclT2+eZzIUIUXc/ZR7Z3Jnt/kcZ/7fsb545zwxIFsz6TGcv5M9sExznYTg8glkCNYSnKVFJViztb+xzDMUKqLmaFJtY8DRY+RNJXBsQgIM34z9ZP8lLdKlVI07GuSvQnJnJvsxXo/AHowgFoLkk+ZIageSdCAJZL0FxB4rJJYQqA3M9ipTJOlBIMbS4MagFvXavvDqU+ZzHbMQbcS2gEDeo0lrmGsoXxWPiLTUsFe1SVwGiA4mgFNB267QFWDz+D+eNuwuKWHQStAlUdahyuc/LeAqmSls2FPshcDCyeF52/RNqP2Ty57QlCQnAavzVpMZD0uVQ5K40hpqYRrdf7E1B9oH3c9rmf+7l4wxvegPl8jn/zb/5NDAH9gz/4A3z7t387rr/++nt9zmtiVH/u534OL3zhC/HYxz4WdV2DmdE0DZ72tKfhta99LQCheP/zf/7P13L6T7+WuwON0czdzAbYyI4B4maSu+Md0qKQb9527jW3bbaxkX5PF8AYo5i7fiMm4ATicuYmJhTp3/LyrMbSRLejnjP/z7QEo7vb/oYEOBkAlPHIGWJz91lMmjOAr9833cA1UGdjljGYOUPmIExkwsLpmNSpBKhB6ZbjMSR9sb5n2C/eU5RF8ul8ISDKaVE29nZuZhlfDtk92HHZ3OFsHCwcwuJ+bTMmkX/hVZPA8kZL+qT5XNps2iczQLIplsZKQAGpa4dZ9Daj1BYhbrbs+sTixsQ6BT46ngTECjmoCilNGYIkwRBpxSSttW6Mk5P3RbLOuwRMmZMhAmQAdOOZqXeAN0ITNkZs/ZllgC8NX/5+0tVjXJmxppWcM5zp4cjPCHpczK5PLDTStfL+5udhrLNSucHr3Pq57HwGMK0fOQim9G6tFTcAhBWLRmO6VzLVhtxl3yeXMPc9qCw1q1/L4xrj2nUSR2lgK8bcKmh1LjGJ6jZnh+iiJ+8j2DWGl52TRMCgUkyFGFDkHFyr3o9lI+c2A9mleWogkKsCaAEMKlAeY2mtaTNWGTDBfjiXYlIXKzBprGnXwYgEUklBIqS4Trc+J0hVGNgYashP6gQ4kiVX6ZwIWyNQYNB0ie7UBO12hWbHoS8JoSRUhxJPXh4rKDdd2KoQKS2TqDLD0PYESxK0+7R5FxvJvXdISg7RiIFcxztRPjB91qOplJpeNVd6gR5o99v23Oc+F8997nPXPnvWs56FZz3rWdd0vmsCqjfccAN+93d/F+9617vwd3/3dyAi3HrrrXjUox4Vj/n6r//6e3y+/f19FEWBra2tj3vMbDbD/v4+brjhBnizfO+jYz7pzRiyHoCHbPgeGajKQEIuIm/Wer7o5e4z+902YTs+B6fmllesw5vsp/1ebLAhJjYegZAxYDlgZcT4zcgSZ30DsoXM/m6bsx2eb94G+BTY5ODdgKtttpb9HkMjkDbS9R03Y1+xPpY58DQDwgyEq8Vv5oAkBwgWQxs38exvzEDuvl1TOeDU5zXGK3s+8d42+mALuyaTcAhRNxHQ55yDkT4DIjnIMkFtY4o/XmYtA1EKbfMP+jdShgxlAZ4vklGisYVrxHOuqaj3xRZK4XwUOJeKNAr02l67YOOVuZft3kJKzgIg4u6sADmEGPN5xW302XtxxS3yOugD0pz5eI2RvcsZsKCNf+fGlr0L+XE5q2mGK5ECPE5jsaYkwVgHpYb6eX3O5XNPryclaLP7MlCXJ87kIN5Cg6xPsEvZdRD/ZkAqXoM5c9HrnAhZspjP+ptn+jOnQgwhOw8huaUjg5cxuWZ8F0X2vilg3B6Da63U1EspWFIhewPxa2A3H++yRB5iAGZhOHOPVgSpamxFj4/evLGQVZk+A/R84kpfM2r1PqJOaR/UYMNajDfZ7zq3uHBozozhmgC/7LA6PYRvAurLAa4NmN5cg0vC6I6FqBDMF0mq0FjgVuY2lR6xUlYMEbNnmL2DIYgRYOsksxr4SGPpnEhTqWoAKnX/x4TU3MNyP2gPCP6vtZ/7uZ/DLbfcgqc//el/73EhBLz+9a/HZDLB8573vHt8/n9QdPKjHvUoPP/5z8dXfMVXrIHUe9p+/ud/Hp/1WZ+Fhz/84bjxxhvxOZ/zOXj729++dkzf9/iO7/gOnDhxAo997GNx/fXX4/Wvf/19csx91myTcZSAwJpLDPKSW1WRNXC06XYHIjiIln22gNl+a2wNYT3+0M6XS+vYRhM3e1uM3frvV7w32caag6D4H6V7dA4xazkH28Yaxqz7DIAYkLW+GUC1OE+XVS2xLPzNpJkNVmc9sceORQam859YZ8LsMzsmAiJOLvUcxNoG67yClgwIrz2r/JllG2G+MXE23tkcYWZw00it9b5PrlF9ztx24kbTeRcrNunDiiEWm+zb1VoOoin1mZwwQTQYJGmcLIsbXRufMzNLn1YNuJMMcu566WPb6M8OzKqn2vagmWRKx/swRsp0Vzf+W1O30Hn1/7P379G2JVV9OP6ZVeux9z6P++jbTT+hgRaaRweBHxEQ6YYBTTJAbI0IBIno6IgKjiDqII34ijEIGoISNBIVE0RAiBrR7xDlGQUcoAYNIALNo7uhn/d1Hnvv9ar5+2POWVVrn3Oh74XGBm4NmnP33mvVqlWrVtWnPnPOzxz5NAMJWNizXB2vq4AujpeV57Qfk2nPLw+Gs/PtnBxAjdQJsjp1YbfMXayAjLsuCdLnzyZv82gsZ3PNKJAxuyal8TRiXe03a8/K5iK+i6xZiLxPLhLG+BkTqPXEnrJnYuO27+UWqkp8PYPUSY6SLq/do23McsAZN+YWTIf07HUOEVeDMrYVZnbfWcCdnCe/0d2FjEvdEJBuyMmvzInMImNFDpgvxxtC8Li/9N2gohD/V+cjeI2byaYVlwRzxTGXmfiO6n0UmvEp+qxSEsn3HjypwWtT0Wb1Mvdy0yCUDlx6DGslmvNm6GcerhkwuXkHxVaDyfEek1sblDcehbvthLDBfQ9UpSgayIBUFwaX+mO0blFifw2s6rse3WRsnnIkoHRjDagKDXqTZAXJLYDSOD5b7pbl/ve/P37gB34AD3nIQ/Dyl78c73vf+3DLLbdgZ2cHN910E/7sz/4ML37xi3Hve98bv/zLv4z73e9+p1X/GWemeu9734v3vve9OHbs2J7ffuEXfuGLnj8MA97//vfjD//wD3H/+98fXdfhR37kR/Ct3/qt+MQnPhGjxF7+8pfj937v9/ChD30ID3jAA/Ca17wG3/3d340HP/jBePCDH/xlPeYuK8pIkJmbgDTR5YuBlXzBsZ13tvsfm+D8eMce54qMmbV6SL+PE7tPx8ffIec5ZT5g2ogGsimZraNNCtliTWnijHJQQIwUHwXSuNTm1fbngCiajt2euSoHHLFvo67iSr+GlT60+iPIyIDIqnldGxbzgO83aeaareYysarPCmQbA87UAmJjkNw79MxBM7zE56XHDbL4jCL+R7Sl9Xu611EEu/nuOhdNqSlr1WpHxw4ffUHOgabTdLz5D5ZFYpfsGQaN7rV7GyAgBQqga/VJbNS0OEjWHEb23LJ+ipAnAmi9/8xXNVkNxne0R+R/FbwZMIhBbZyOXf27378zoLZnfMU+zRrJSSkhBvNA2s45yz1i+7PvVtuRH7sfMF0tq2A7v0cDUvq9bW545f64H0bgJNWT3lM2E3hkxSEgSt8DYk7MHShKSJEvxORsLkhgnUIo21BnbHpkngOALDCsawEoQzyTQB3eXWRAWvqJHEUppZi4QpVRqEAUvueygOsDeFbDads4D5LSxwsAlnEqWoEmlQDBtVliDm3cmctD1pdUllEWijW5AHV9mmdDAJeF+HjWFbhwcLtL0WJ1DpjU4PUZyhMNwqRAe6AEBQh4LRSw3rIAzRvRjrXnO6kRDm/EzRfVZSQ75Hm6zI2HhE3mkPrPfI1H7wl0HKmaReFFTWFaqbuUiwlGuGnABcbj6p+4kC5Jd/U1vlrKYx/7WHzkIx/B6173OrzmNa/Bddddh5DNU2VZ4sorr8QrX/lKXHPNNaAvNBftU86IUX3Zy16Gxz72sXjTm96Ev/7rv97z350p3nv8xm/8RhR+LcsSP/ETP4Hjx4/jgx/8YDzu137t13DttdfiAQ94AADg+7//+3Gf+9wn+sJ+OY+5y4pO7iJyjoyxGMaTUb4YRrNW9nuWvSUytI4yrb4c3GUTZWTxFKbkTC50ETGTfJbdJoIWA0EWwGWLP+dthk5WWk9utu+6FNyhhyQGCDo5+wTgbAedA1tjueKan+WIB8Z9u4edQmKQYz/pfyOXBf05ZL9bWVlz0gdOwBRIk3bOhuZMgm0W7HwiRA1YIkRf1mzDQat+ccoGheVy5b7yzk3PZo//YbynDFSRsKJuOhH/sMi+ZRsjezYZaCfLPmeLlv3XD5EV5X4AB9XgzOWxrLllKQElfRAfvyEx77kkDwHZQu60Cutn0sXNg/T9IGOMRyAuu/cciNl/Nk7Bya96dVOzH/CLPpOcxlzeby5fzFenXTlP/CB7FUcfs59UFEkc356t/R1dl/XZZNdY3UyuLvir95NZVMgyAhlgj7ds/ohI1/MupipNWsEs8lBm+s/7uyiiuZi8S77Nyyb6ELPOSdxY9LqLZmiyPspZdAWuligiJcjQecJYau9By1ZZUJmHedkIW912mY6zMv59r3+HyA4GgvjDLhqRYTIXF2AcDFj45IvaDTKuuk6ubRYImx+GEAOqUHjQbAqqq/Q8vQfPJum+7fkXCk43pggbUwxrojLAVYH2ggNo7nMEw5EN8SDoBoSCMNQOTECo5bnR8W34kwsJoGIgpi89uAnqgzLOQ9wAREBuc2AY4vrBcX7Xjb1zwprWVVIQKNTfdgjxOVA3CAifTUAb6+IKsd+YPVvudqWua1x77bX4wAc+gDvuuAPvf//78ba3vQ0f/OAHceLECfz5n/85vv3bv/20QSpwhozqL//yL+N//+//jac85Slncvopy8c+9jEAwEUXXQQAuPXWW3HjjTdG8Vgr3/zN3xwB8ZfrmLu0MGQR73uwRpqK6aNPky+wssBln9WhndTnjy2DD6edJ2t2oMhqRhkkQwNJu9JcDdmubcCWkSZ2OzcA2eokrLAtvMb+xUUsWxABlSwZ9II8FomOmpBIbWBg5GtrpkWn0dJ7THo52OQxqWjMsfkyEmHPvsyApgHIEDKNP0RgEVnUVdZYmbDYPSP/VwUPuc9q/n6yHq/sQWK/kLBmBP8undwPgPMydjK9xHheXmyR2K/YQp7fF5Ga8yRdKlsQS2S+tC5TCSi0ryxpQ2AwKaMaQW2A6a1a19m9mJWB1KTPsb8y4J+1n9kyI3H0wY2+iubSMJJuyzY2kf3Tz+ZqkjOAo/GbPdecEc2tG6cqqyAxB2j22Rh3G6uWZclcE8w3kkjlfPRZdV1636zkVhmTnlvpO7nnIYHm1KmI2Y1Gx1N0qxiDYcgzzoKamBRQDiv3Z+0YhiRTWpYAeBztTUgWnF7ni64bu2AAqZ1Oxl+UmbJnaMyvcwKidGxEVQGbV+O8Q6CqTO4i+XtgYNG+0+vybAJ4krSqy1a1WXUeZvWVZdZ5Xt0gosuOS3V5YxILCRQyM7ia/ZG7GMR0tTTWowUE1AHgSYlQF+DCgQaGU93j5fkzbN+rhusYa593cC2j2Okw1B6uC3AdozrWwG3NJclA7EMCZjNgfSqJCKDvHhF4oTnb+7xdPWzi4mHQ4DYdI94LSPVOhf0J8JSuVfjomxs2pgh1gaIfwMtWru19eoZ3l2Jz9F19ja/ScujQoS+rjv4ZAdXFYoHHP/7xX7ZGAMDOzg5++Id/GFdffTWuuOIKAMAdd9wBANENwMqRI0eiL+uX65j9StM0aJomft7a2jrt+wKQQGfmT8mD/mBgxHbVudkSGC8epKlEgeS8zpxMYuQAJH+s1XpW46Dk/wLYzKWsQJSH8ck5WDAwNQyJ/RuZWg2kmloB0gRtx+YvOQEJLLqkSmCT2Sr4jSA+9Un8fWQSzYGlfo4nGfDj1GcZUyjf9XEijQDKrpfPl7n5Ni5s2QJnwCwPnBiy/rWHkV0+mjdNhshni6ylfVw0K/eDMTCLl7P+5KwLM5BqGwBdqIkVYDiVvwlBRMkjY2W+gohA3DRM80Cc9P/KhObyTaT1QMZpCtTh+CzJ9B7z8c+cTMd7zOpImy8g6WmugsqciVw1i4/GGI2/W3kP07Nb/W7lvTHrAusJmQ4msfo3LpTBiqZziIwci68ugMTu7hfsZs8xtpf39Nuobfl7YuNx9ZhV1sMALjNMuitulInGwDOf6yKI1OeRB2WtvLvWRbEo60pFmmd4sQKodTyy6ncSCFTqOCSK705yaUFqGxGIKbHGBjSBTFWAE5D1XkztXaqb6wK0UL9qKHA3JjYEJRg0Un5iagglUBSirbq9m9jbogBNBLixjo8oL6cJC8g2vs6Jid+L2R6ORIhhIceTSlS5ZYl+UgNTwvR2oNwJCNMCxbyHPzaAhiBm/rZPa9DQpUfpPXhtAjiSQLPFcgzqNe5A3DPUZWFo5c03P3Wz0KhfLTobyyyMclUirNWAc6JF2w0iR9U0cq91BVqb7h2TZ8vXTTkjoPqoRz0Kf/EXf3HGUgOrZblc4pprrkEIAa9//evj904nlK7rRse3bRsj9r9cx+xXXvrSl+Jnf/Znz+SWxoWQFlcGuO3FTGKsQ/StVAATFx2smPAN1yjoimZfWzFtQeTRwpKoRqlBPoZ9Fieo358taJwmxXzBzlkOHrcvmrKzxQlAWrCI0rVXQYD1EzDyicvbGO9/FcBafVHbFNnOPeunEBAlpXJzNiOTdcrqyN0AjPldLY4EnOZKBbbq2vEu65PMp06AvB4/ep7IWB25ZzIGhlnGT+qRdM6qjwIRKAepI03brGj/MRPIAzEwpShAhUUe27NDWsSz/ue8LhLzO9vzin2V3/vKs8sBl5UcLNrn0d/8HhDr5ngtTu/ennG6AipXPouPtj3TDORRlrXJ2nCqNmYmYK68bASWoqfJ3QDsLFLb8uBI09tsNdAsb+PqGMzvxQB4zhTnwyNnh+MmiU7dz6Nz5PsIyIYhMZeW793uRTevZIL3pk/rKIrCRz1na4MJx2ufk/ea3KEQcNP38b6Mjbd2k/m1ElKaThLwxkPmM1oU4j9tqgm2ofUuMcImWu89xmZKHrkxMQPUihQVlWXsxxGQJwJXBYaLDgNFAdf2cFsLAaNbOwKgjfWdTaLLAPWaotX6Rjc7YW0CnpRxrIdJAdf0oGUnWbgqVcxoxc/bNQNcD7iOUd+6gF8G9IemKI8vRM4rMOjYloLGUjZPgeKY4WmJMCnl+tMKrmnlGSyWGLlyMIOpBPp23F9lBUwnAnYB0NKnTX9ZgNen4JkkAKB2QNH0YE8R3JIlSDhbvq7LGQHVhz/84XjGM56BH/qhH8Jll12GVZ+D5zznOXe6rqZpcM011+Cmm27Cu9/97lFa1osvvhgAYrYrK7fcckv87ct1zH7luuuuwwtf+ML4eWtrC5dccsmdvrdYVqkCA2Q2sUE1EWPqS5cAjAXWMKtZTOtQNwD5dw5OQnQV2KM7twcY6Pe5SdCOySJl42Jv12CdxQiJjIyLIY1N/ABiMBSyc5ljZLj5XzEgzEy+6OrEn7Mb8Xiry/wY4z2tLOY5cLCFPr83RjINWttNj9CusSr/QzkIyvrHXCdiAAqleoyNjeDAiUwZIXtWBA59Mk1nIIQ7BtpOZXxO8WzTF6m9pNI3dh85aOH8ODmW7fghAGSi5grANU2iARZAIqJ5dA9QEIu9JeRBUPp8vUuMnN2rAULax31hNI71XkesvT7bnHVdBaarag771B8j61c3Z9CNw2gc2rUzVxhAQN2gzBpK6btJJSw18zhYy/4qiOI+Y57sdwu+WzXf54w9MN4I2H1+IaC+elx+btw0hjTWfdZ/ueuBscX7tSOI4sMouYA9Q6IIauF8cpkxF4+qEPmljM3j7H0mcGT6o0uVXlcAb4X4rltkvj43znyiIxMKBbmW1pVITPkxcEnntMKlV42yMQgAsymwMUPYmIK6Hm7RpVz284W0a20m9zCpBZwtG7COjTzpCRGBS4+wVgsL2g/gwsOfXESgPaxV4MqjuPWk1Fl6wBOKOaPcHeCbACbALXuQJS7Y3pF7WZsJQ7xsgHaQtsym4MKLO0E7wC3a6H4xCqSLYzNLLhMCUFagulTW18EtuzgOMJuAZzWGzalMS03mzqL9GEcnc3IzOFu+LssZAdXXvva1WFtbw//4H/9j39/vLFA1kPqZz3wG73rXu/ZkLNjY2MDDH/5wvO1tb8MznvEMAMKCvv3tb48A8st1zH6lrmvUdX3K3+90MYxjEw9rJKRGqbIyjCKIrT5+0S8SKXCE8uwqAPIFP2dPbKLImdkYsa/f2UJgv/cD4EICbJmbwigLFGffIQNeNvEbgM6DfOLCR6kOm4XyxdJYDkdi+l3RjzWWgvNJjFbqSJ2QQKe1z4B/4v7Gi3xZZIxt/uA41Rv73RC6XT/7LQNskqPeFrcVs+eIyVIXDg1CApDMjznDOwQEAzDWxHjP9sUK+Ir9Y+BkFfzJAxnnoM/6pyyBkKViBNKYyDcwESzySrdl49PaE0Ja+G2TEbLxZ4B1tEnibAPFqd9Xc4Bbu4jSuF9tR+yuFfA66pYMfK4ea2wy5Uk05Jq8PgEmE1DXI0y9ujk4MZ02ulgPK2PA6ieti/txn1mfW3u0D0fPAyv3R9k9nAqsxnG70h85YKWMQdY6uR/SPJOztFoZWx3mKmIZoJgTW0rZIAlhJYCMwX0AewZxAHqNpjdfTrt/ZVN1BMd3J44fZtkjW9YrQnIrCek9syHD7CShBKBBP/u8z1YP6S6TAO4HUQMAZP4ilc5bNPCdZYwaxHReFCLJ5Jz4yBp7vupr7BQUlgUwnSBsTKX6uYjf07yJgBVEcAz0tUdYn6A/MAEFRj/1KBaMYgkM6xWoGeBP7EZAT12fgtqIwNMaWJ8BZYEwLUURgAC/aMWXdncuYDYfR1EjVf2pnRP2ezKR+ywk+QC2dsSaEAagcQjnbiJMChQnl3CLFjytwDo/U9endLOr1rW7QSHgro/6v2ur/6oqZwRUb7rppi/5wsMw4F/9q3+Fv/3bv8X/+l//C7u7u/jkJz8JADjvvPOwubkJAPjpn/5pfMd3fAe+8Ru/EY961KPwile8AlVVxfyxX85j7qqyeXCG+z7gAvlgbJjlL7c8x06ZKgARUOYAM58wzacpRskj281nABFAtCsbCxgXIvVpjTJKSBGdecmDrazkDFO++MV/E4TZ1XpldQBy39cYHa91Br2GAUQDoPth0NXCnJnCkQHhfUAb57/btRWslkX6nAPzfS+KdB/Y71hO4uPAOODMrh83CT1C24zBH0HN9D4GwQFIQURmGoy3OPqQrgXth9WNwaitpDKv6psaXVIUEBRqTox+iKxDah9/SRpVm/o7Hy9mJo43tQJkIzBEYlTzOiKI1msYy5inRzUZIIsc1/Mv+QbZDF9y2fljYDD6u3IPq/cXMAaAq8ebL17TpmM4AOdtZOPdAKX2h43X/F7t3MBA7kdtAV35uxqyZ7OfP0T0J4cE8Hkdezb2V/s38OjeRhvnaC2w62b3Ys+gKlOk+hAyyS2dbIrMVQBQxtmeAaX+KCUgibStsZ6c9dV5kMgl9wJ9tyTbVZF8sEndOUxGzcCxbYTzbiOk9zZPK23zpLWhKEBgAWV2Lg9yn3ZO1JuFzDMW7c/QZ2GAXZ+RczJ+mIFJLWxpWcAtO2E2owWJYzan/vAMzblTVDsDKAD9xCGUEt3vO4a7N1DstCiOzREmpUhXLZoIJlF4sGqZDmsyd9Egz8/vtqDtOTCfJ2uCzSHOgcMgG4CNdUT1jKocWzUu2JC+68XFI5x3EOw9/EEJzuJJJYzvbgMs15Nlq/CoZzWqaYWz5aunfOpTn8KHPvQhPPCBD8Tll1+O3d1deO8xMaWY0yjEpwwLvmvL8ePH8YhHPGLf31760pfiaU97Wvz8h3/4h/iVX/kV3Hrrrbjiiivwcz/3c/iGb/iG0TlfrmO+UNna2sKBAwdw8uTJCKTPlrPlbDlbzpaz5Wz5ypV/qrXYrnuvX/h5uDMAXKdTwnKJz/77n/iqxBvXXXcdXv7yl6MsS/zSL/0Snv/85+Od73wnXvayl+Ftb3vbadd3xkB1d3cXr3vd6/AP//APYGY88IEPxLOf/Wysra2dSXVfFeVMX473/X9/i9/9z3+6D6vFymz6MbsIJGYiPp6MzTDmNH9y0W8xZzdozDysugTENgBAENYlsgqkTC9W/D+z9gwrrM7I78+oBGNlODEoZbEPG5j1jbGKq4yrsZB275GFMBMojVnbnOqKv49ZwT0MTmTrOB4GU1pgey6rtGx2j/nn1SA0a0fmjsGLJvkiIqsSyJhNeQ6kCQ+4a8GDjR3aw46O6or3zfuwg+qLGvtg3A9kY9DSJwIiHs4huglEli3v7pxhzCSXxte2y2RuCKeaiVanqFWTfP79qvne2D9lny65/4X497/1A/iF7/tvuPHjN+/TrpVO0jqTesJq25D6mVVb1EzQRIl9iy40Ib3buR/nHqvEPvc9viD2Zc+jVQWI7zAQWXkGg9TKEvvdWFMbB5kKCYch3TugJKG5J6y+t1nbnWk9u3jfbNHe0byf+lf6If07Mukk5vHIUvbGwCqjZ65ZQ2YqtrFszHMIaZwS9j7L1TELAGEAB3EriIkYQi9zHstcSVUp865pxxLJ57JIbOh0ArOaxGPKImlfW5/FuRmilUqEMCkwTAtQYFDPcN0gWsOLNp3HAcP6BIsLZ2gPeMw+v0S5PcDNW3Dt0R6eIlQyBqot6X92QLGVEoWwdxKU1fZwzZD8UlmYZ+qDuCwsljFTVwyIdSq36J2ysmVij/tB3IZszPea5SqfOk3wv64QJqXc37JNfVqVADlUlcOP/cJ34cJ7SQzLWaB69y3vete78OxnPxvveMc78KpXvQqXX345nv/85wMAHvawh+E3f/M38dCHPvS06jwj0/+HP/xhXH311WiaBldccQWICK9//evxH/7Df8Cf/dmf3fWZnr7KytaxOa7/fzeIrpxN8F5lXeygrhtFCEcfrgyMsYGzPA0rY7w40+qMSylYykyu+cRos8bqgqFAK/qm2cQYUnvGPlUuRc7GwCNeOS9rbwTLCh5N8SBP5+qS36QtLFFPdSR0j9hnMX1jfv9SQ2oHZ2Cd8rZiBDpiySP5877OgeKKhqr0m91ztoDnQKhpEebzUwM0Is1IReNgriGMI5kjUM2ffQY67f7t+7ytULCagwdrp44lIl2EqkoCQXQRGWvLrtybldXfVz+vBgV9AaAmudbVrBhdSNJtpY2HfqWR6at9CgA3fuIWfPLvb8iCxFZAOmzcZWM8b8+q6T2rO7krZMFH+b3noG71Xlfvf7QfovE7l/vvWQAl0V4N0txUb2MqGysRdCqwI5cSi0RRd/M3jS4VgwZ3xo5XX9yVtgWTL+PxpmF1Aw2M/V01aIfKUsBOrzqdIZnozfcVIHDbxrlinBVO5wsdB6S+oCMzf/b8iDQjVVC91qJIgZVDyK7tBYQC8k7YBqGuBYguW1EXKHya28IAHoKca+AOUHkp7au6wLA+gV+IL3OoPMKkkExIfRCzeB8wbE7ApUNwjKbs0BxbwN8SsPn3d8C3AG3PEY5soj9nDd2ah1/0oAD4lhE8UG61kqwgMPr1Cs15U/jlgOroEtQOAlLtvpoOWC5jIo64sbYgwY11Wc/0c5qTAJ5Ucp+LBtid6/gz4C99wdMavDYRqa+mB81bUNeJb+6kAgOYVgXaJtvQ/1OXvcvPXXONr8Lynve8B9deey3uf//7YzXQ/oorrsDf/M3ffGWA6r/7d/8OV199NX71V38Vs9kMADCfz/FDP/RDeMELXoC3v/3tZ1Lt13DRF9f0MeM6xAlcGQuAJMw/8vHT3XMEXCAkOaRU5x4tVvNhAuJ6Ai8LisiTIE3sWUS3TTajhZooBU8hPy8DuGBoCDgi6+mytmiGnRjlbTvzPJgA2fH2J2OimKE+qRm4yAE1kC3OOXCjjNnKQXPWhyOJnQyY2/PIGd3IOGYPyxb4EMZRsIBM/OZ3VRbgVpmRPXROumCMQA4A58eyXTNvXF6HHbMCqMiAFOLxzJCI6hw4ZqBKItcHyV5TysIBFfWW5+BGYGMEAiypQfY8RwAtjnFOAF9ZsFUwGEFnzlSv3Fu6IUo53kddugLG87FpWcDY+hqnOJdTV68CTnDqW145N45Nzt7XMO7zPdfcp932Q4YRxZ8ypOvmwDcPBmMeK2vYMczJcLAfuHdOsisR6bhGel72vDUdLsWkGcpkwhID5MfzqA67TvJ/lKh+8U8VpYhcLSAqgWRyYeM+kucpfSQgkQy05gDeALgydyLGL1Yum5sjIHYMGlSOy9KCNm0CnNMa3cWH4FvA376l7KGOxV6j/QnSDzbGAZCK8/OkQn9gKmxm4BglHyqR5PIMDLMKYeLRrZfo1xx2LiIMFaE+DqzfsESx3UpAVCV+sKEglNsdXNMjTCoMtUMogHILEvWv/qf1USeyUACoaUHLRoA5cyI68v63PplOgAProiO7MwdB5fMGmedoCLIRMrbb3stsXPGkEt9YU4sggCe1fKdasf26pIQ9W+7+ZblcRly4ClRvvvnm+NvplDMCqu973/vw2c9+dnTB2WyGl7/85bjXve51JlV+jRcDcFBWE3GSYqJoHhTGiBMTEDK9QCDtVA0wDZzhkxxQrSyoOesXdCGxycSCngyA2d/IHPJ4sQMSIF0FfpGdzQA5EaKoft5Ek5LJo3StnZz6i4lGwJJjGspM/9bAVw5uDMzk7ba81LmJn+L/pUhsu+ewAg5GbCBim+S5kiyITRuz04zAlOn1ajAI5czEHlATLyB1ssjKjI5lHh/3Rbff6YYN8OaTSBTKz7VzgSTBFCQSl4l0Ua/k2TVdypqmrSBNQym3rpnMgCRDNYS0OehD7B/pUmNMV/rdSh5pbmNmlZW0uoKx+4gbjjwwbTVpQBJ5XwnOyq4fTftun7EQ27s3SIuIRLR9lE3Mxvw+oPtULLT1Qe7GkwP6kYsMUh35PoaT9BFnIIR0g8sW9a7jK46Trt8jS7SHmWRO2qrap2zA336LzKcDTSfCQLYC5CiE8YbTrhGftTZrlCSFxrJwyMaDvitklgSbu6JlS03XphtMAPkCTMrAaoQ+FYXel85RcQzq86gKLC87B+15a1j77C7gSLJGOQfMFwmoKUkAIKXrLQqEtRphfYJhVsC1AexFjqrfqNBPHHwbECqH/kCJdt2hPUBYnEfo1oByR5rhdyRxBFeyrPdrFYbKwXUB3cEJXCMM6lAXCKWDG5xsUEsPv9sBYNCylYh729jn4vwj0sKJhNWBDWFNHYHmLs5vAORdN+3y1bFqAcWarIDtP++AqWyIQl1gmJUYJg7YqCKQvluUOzPlfjmu8VVYrrrqKrzgBS/AC17wgtEa8/u///t4z3veg9e+9rWnXecZAdXJZIITJ07gvPPOG31//PjxM4ro+pov5uOXMxXGimamdDaQo1HDRJkpDbrWGO4yViJf6ECgMplVhCHJQJCB3JABMm3fHr3KyP5mwG11Uc2VBvYsjBlAMMZR2ZiY+9kAF/PYNEjZYhBXJltgMFqI04uwutjbeTRuY95+TddKJOkquW1lYbKsWjahjqS+su/todjz01zhOYkbn0vcTFCSyll9LpyfqCA12tAwLiOQuk+xPoybFbuWfiAV98/nfhapNGE15D5jAogQFITqOCkK6aupCrB3fUql6r1k2FF/NipXnvVqqlkSQ7sAJB7/tnp7ubk4fyY5cA8haWyygFN2K/U4REAbwYelNuZ0zyPQp2xczOoFxOw7JjGXNltjpjSCZtvcrd7PCnu8p0QGMDsnH88RuGsfANG9SBi9YXQsQ2Wf7HBGMo87F92QuOsQVRPsmna9wOormhIAxPdOjxtH0us5BjhCADdNxi7y+HnmRfuQLCFA1JNdOZ4RN78ETqDbObFKRBaVQL6Mc1Kcl/Ra5J24upQlwuYUrh0ERDOLFSHoM/biGhAObYDXppjctkRxYgGuCvTnrqM8Ok/34EjAHSPzWUXURw2FQ7HTwS17uKYDOwd2IoZvTGgoCf2U0Bx06Gfybg8ToJ8A/WaJ6mQt5vxDM7AS2/1aARoYfjHANT2YWe6n6YBGXSaGIBuFpo3veur7ZP1K8wOp/6j216AJSVjnLWYBqeYi5lzKMkYEOAbKElyV8qS8MLpcOPl36TBMPPqZR3PQoz8g7PDZcvcv/+Jf/As87GEPw+WXX47ZbIZzzjkHr3vd6/CBD3wAL33pS3HRRReddp1nBFSf+tSn4ru/+7vxq7/6q3jYwx4GZsbf/u3f4gd/8Afx1Kc+9Uyq/JoukrLSp9SgZpE2nGE7fUfi12S+obYoAmmxi6CDsoUJcbeeWA7Td9z7cicdUsJInDtjXOLfVbMkI5nUrS2Ui+Ov1KFtjVqTnP0HjH0vcxCS+1/mbKtDbHMOrFOwRAZe9oBVvZTz8Sc5LdssdJ2mbKTUPms3uTF4JEQgy207BgMAjJEju1DG7qW2Z89w9KhWADjy+8p+3w+n2iZohISzc+yZUDqerA+hYMwC5dgCkZAAfKdpHc0f2QBI/mydS6kpicCNBEiQ9wo4FOApYB+bg1e7IXsW2gcW6JWSB2Av4M/AEpkZ2Ji+9XXQOQclM5QB7NUxDKz4sFIEq7HulXEu1yDJbZ+PQWZEWaucDQb2XtPavgpI882lgTsDGdZG5zQVq4xbJvE5jf1OlPo8f6dJsyt5B/Q9uO+zuUd/J1Izt7Un6yM2HehsLNjYMlekwGCXpWB1BJ5NZJxs76pLwsr9Z5vXHHSTPfuQpJIiCNW+YutvQMar1a3zq7DH4o5D3idLEwGYTRGmFYYj6xjqAvVNx8euPFUZ89CHtQnac9dRHW/ht5YSfFQV8FsNMFf94bJA2JwCsyncHVvCZHovmwkG/PYS3u6768VkPqvh2wDiAe2GR5gRQkHgQjZefi435DuAPQTMzirF+wTXMzolCeqtDn5rAZo3qLdVOq3t4ruPtgP3fRrbQxBgOmR9qn3JXiTzSDeoNATJ0DUMqvOtYD6X9iq8rm0ebHrV3kmWLSLpD+fBpcwLQ+3QrRfopw5DTcin5LtDIcZdr6N6F9d/V5bXv/71eMtb3oK3vvWtuP3223HBBRfg53/+5/GEJzzhjOo7I6D6yle+Et/zPd+DRzziESg0Grjve3zrt34rXvnKV55RQ77mS4bHACCZxwkS2VqJudRJOj1zNI8+f7nJcIyy5HNuUrLJh3KfMNLPCeAJ9qMVrKN1GrAigMgnQABbuI1VosT0WIR6rkygUfJsgJwzYAarn9IEaaDJFl27R6eL9EqkN8f/A0bsioGWyHy62Hdj4orGjOmg6Qdr1ewLYXyvQCY67iQCP0Yb8wo+5HHKUrufogDalVSDe8oqYkvNTcA7A0lfbFKzBZgyU+7oL4GQoqOjb6Et9MY22vHKlKwS2qmdusiZnmZdRZ89qqpkZq0qaZv6tEW9y0p8ADnLSDNqd2T6tQMMqOXjyKVnHvvIAObOLnBiO/WBpfUkS/1qINOAcbr2yPJgbKINRLtGzvjm4zD2VQY4R/2WjeH82QHjoKPc/cFcCnLf6vjMsyAqs0J4Dd7hAHZeg6u0jV0fzfMxWC4DiaP2MOL8ZK4E0vwE6IgQNzg8WNQ/gQpJGdrf61zwzhJ+ez4G9tadRMChdQF/Tae+pnpLoOS6YMXmmMjSZn2K9C6O3BMsYMo0Vb1De+k5GGqH9pwpprdKABMmsvFi7yUyXQHrcGgN7cEC5U2dmM1DALoBrgky304q9Ec2EGYV3K4C0sKnwNEQopoBhaCaxXKfvirABycAAf3UyQaSgXKXwQS0BwDqCX7BKLcHNIdquCBjwLUDfCebFb/TSjYqQMBlUG3booggNc3bqT9Jx130W9Y1BN4DzmsyhSAgteuTBSrfkBVeEgGUBVgtVjwM8m8bk4NsYrhw4IIw1B5c6PowAK5F9KE+W+7+hYjwtKc9bSQz+qWUMwKqhw4dwh/90R/hYx/7GD7ykY+AiKKo69myTyGkyTxnZGwRyATOZaEQ0zCtzcagbxW4ZItnbo4EK6wcBjVNGiDEaMFKDASAVfM9IADa2AznJDe5tbsq1VFezHER/EJ2ygm85ovIShBMNilGX0bO2MacQea0UMaFKoLgeFD6mwN5Y5spY2JXIqGNVRmnzUQC7BH4KvMXAG4bcNPsjynjms4pUImEMecYJWwHZqArgk7eF6dqrelcWgE1o2P2R688etSU/aEMRCl7EgTskDIssb+UueM9952BRQ6gniTbjFewagyNAXjnhKG1caZMK5WlVtjIwmo+vitjSHK5D3Fcx54ZWQmCNN0AHrKujQBXQVaeujbrLM7A6si3F8g2cVlRH+wYnDVyadC/uVnc6szB1ahP7YL7gFjrmxUmGczCjhKpH6beRxZ1Ts6p7FCfruFofxDIki0KQLKQ2Ng2NtI5ydA0yiCVjcVhELcD3Wy5eQu3tdjbfgX4dGgT/b3Og79jC3T7SWHqjJElgGZTYTeXkqXJNjBsSVFsrOpzi+DbWdCqAqmyTO4OKtcUJiXqYw2KnQ4oC7QXHBAR/dph7SO3gYIHT2oQOVQnWrjdBuw9uvNnKLYauN0luCzE93RjgurYErTTJMDmNQvWMAB9L8NCP3MIQF1iWCvRbng0ByVDVNEBxZJRLIDmkDCrrmdQALqDNbp1h/pEQH20Rag9XBvE5UHnF65KeR7mj8+qiBCDWxHZ+GhF8WqyN+JBgSoTiT86Qzb35s7kCDFKUV1guK7SOO172XiQSHCJ2d/F98LiECgwXAe4AigXQfzn7y7l1NPrl/caX6Xlfe97H+5973vjggsuiN/94z/+I7quOyNVqDMCqlYuv/zys+D0zpTMFCYkh0PuD8XGTvki6VXOF2PQljOJxpgiVjH6EBfSokiLruEHM12xZWnJAEgOuFSSJYK6YEyPOP+DNJ0rW/ADhAWD4UoBkZGtMfCcL1wR0Kws5LkclAGJGCzBScUgC44gZablOtpWAx1Wp8uuHxkXA2rJN5b7XiZm7wH48TkutUOi9q3fV575CLxSclfoetWTjA9k5SFSuvfRd5zq/YIlAyn7/pYByRUQMvIQMBcHBa4pUE2+JtOrNYAbz8ufI1LAXs/iclEUmQuEbkRyVk5BD7dterZVhST1BIAIw8YEbmcpTBQzUFfSr8qKc3Qf0YYVXp6pvUcRmCCeM9oZrIK+EEZRydaPcfOZsdvJQoDIUMf7Xd0M7hcctmczJ88gBk9G4JrA36iu1fbb+2/XKQupZxiAZaPMuAOIYy775FJhG5YEoI2RJQTZfJj/ffRTppU2sp5K8lykMUDbwd92ImmOWh8hzRnh8DqGiUcRkHy71QfZbW6AylI2i32fXKPsvtWfVdqbnnFk2p2PY4C9E39bJ6b4+oaTckwhrljD5gRbl03RbjpUW4zJgSmcK8BVAWoGTI7vgtoOw+YUofbCUup4oz6gPNmAdhayubfMVDYH9gJU4/yoQDocmKHbKNEcFFBYLFlM/ksGF4TgAd8Qyp2AYSJMb3uQUB8TM3930QaKxQAuHIa1Er7ReWfZJD1Tmwcp6zeiuCGwsWfBrygLBbtBAkeXbVoXGLqWKCAtPOCEOedpJRveRtJEo1UFhGKKUHkJ9OqDAFdyCBWpOgJQzBlFwV/VpvCvp/LRj34Uz3/+8/FXf/VXo+8PHTqEq666Cu9973tx6NCh06rzTgPV//pf/+udrtTEXc8WKTFfeTQPJ9BJIwCKtEgbAxejrjMn9pVCBFmkTB7GvjSToL3hdlw0ywCR9YwTlE5ajqKDfZz9lZ0gR8L82vkWeWv3GFmfBK6YoZMdp/4Akl9TbBu0vWmHnfvRRpUAY3CM8bLTbIFcDVxzK8x1vNesT73L3AeQPTPrjzRTctNk5twc4eVFngZzENPWkKXzjA9On1gOak8FMnNwkl9rdUzsO6HT+J+5nA/vdx8r7Vph8ax7hOnOQLSx2xYwoy4uPAygSoFU7sPIBuYyfcwQIgME8Oh4AgPTqbBIZQWUSOydBmrwjuo1muan9ZGmiQQArK9JTnNmYNmMXAxGrPB+fZw/B91M5mxu/JyDa2TjzM6nlWedb25y5tTOc9nxcTOD+DzJO1URsch6iueY5ilNJhnY5aRQkW84lHXlnL3OCg+SBABVCRzYkHtcLMf3oyZwNh9SknESQSPp/DJfqM929i5qPbSxBq5KFCfmoJ1FUsnYXAfOOyRDa3suoDBwmod0HMp1M/cP7xGj/61fCcCkxu7l58CxR3FyierzJ0CNWlxqYDg0w85l61ic6zBMGbNbGeHQOjgA/dSjumUbtFgC/QB3rEd9chfwhYIzAN7BbS9ArSpkQPqdhpDSYRvInk1ARAilx7AxARzBN0CxCKABWB526CdqSfCE+iRHBrKfEoodoF8rMWxMwF58WkPlwFMJzi2O7sKZj3zcROlaYZsRsxoB6lc9gFktR30fNzfxXc7n/aIQdlo39TypwNMJuFA3AWZhUwsPriuwlyA3026lXhUPvLxP5e4g7g6Hi73Wm3/Kki1vd+k1vgrLW97yFjz1qU9FZSmFtZx33nm44oor8K53vQvf8R3fcVp1ngWqX4FC5GIwQxKNzifL9G/ue5nkJ3UyofS6E7aFI180zYRtZreMQUW+po0YCyRwGOuitLsGxYhtGFMZ24ok9J0tDlSUqU1mtlsBl9HERNBgEyBKAQWoOdhajGQqiqY+yn5zukAlliqC2NzXKgNkvAe8rizEZsK0YJJcdikDDlGdIQdTsdn7ARrza8yvlX9cmZFo71cRkeRgJl105Tvee372mPdqTqaD5Gtlpa2efFNj14++xuNryYYkA8CMuOnhphV2NGc2g/nxFum4+Pysjj5uQDgA1HWgIXMZYPW3IwFrmE5ksRwG8KQENX0a91Zv0wA7u1KvSehEhl9BcRxXdv/jQCrLKS/7KjdiqaLqwP7dvPrAsj5e3TzYOdkGykDuKpDWvoj/tus4Fy0EZCL1RODFMruWAjgN7jEVg7GuLWQDUniEjSmoruQSu3MB+wpwrU4eqXiI/3N0UcqtJtnGcNTngVHcfEKez7IREFRVwPqa+IkuFgJ0qlJcEQoParr0nluCE2UoY5AqkOaIfkA4tIHdS2rUJxjVLaraoWLzYHkkrgPqE4zycwMmRyV6HuRQnuzh5o34qRPJeRrhHmqP9rx11Ddvw3V9EsNv+7RH1fFEXp4PV6Xcu7GWAfCdiPRzAcABoYBE9AdpFzsAAejWCLPbB/QTwrBexQ1BsdujXy/BXoOW4jNfmUxsk8+M6Jdv49BcAzrdVA6DjP+iTOuUc8n/eRikL7wHtZ1sPp2L8z+rjy71kvnKNdp/E4EkrmX4ZoBfDgiVx1CujPez5W5bmqZBZ3PqStnd3cXOzs5p13mngerHPvax0678bNGSLTpmCo+RyBnDyczgnV1QXUcMAA6JvYr1IZnCV4KLxuZDqxdxQsx97cCcBWHECkagJn1vk9eK+VKDilbNvha0tSrMHU24BowdicRLBpqj4gFyLJeACw9B2IkctI8UEZDaZCZ9QgT1KW3nyvnkkl6i+o2hrMBZcgFeNsnkn4PUfYuucl8IiNrftHLtPcj+SdrfI5CTHb/nUjz+p4OaeA308Phy2YeE13hPVXb91bSUAMbBY/l9lV58WtsWFNTk6iWQh51mvIKAIOpZUsTKRbINmn7VtuImw5wi9jfWxN8PBGpbzaoTRLgckIW/bfUYAEt1LdAAn6QiweldGYHwMeiMriZ6f+ITmQFJBqJWLDDOkpX3/+hxrYzJHIyOhgWN6wGEvew4md5trJcFkLP46pvIQUz14nu4IsnWDyAWRpj7Ifokwjaaa1PQgQ0BZ1s7wK74mFKWqSnfGBtAjbeivq3RwuGcSGUxRpqpPF+AZgTencu1LetT28EdFfBKFvg4qcWnf2cOMlkkQE3YLony2wYcDHiP/pw1tPfcQH2SMfvsFvzRHekHA8fOwTvC5I4Kk9sB1/TwO+IPOxxcgzu6Dbe7EDN1XYnLUyf91J83FdWFRsAve3WHCiFpiJKORd3skFkH+gC/3YjZflJiqCX6vd0AJkfFd7NbB9oNQrXN4AlQnmQUuwOKucyz9a0t3LID1yVc04tVpygAN8g8Z0QEQho3Ns7NQmfrlI1BI0QMhDo39pG2IGEnmwRqsqQmFvCr8wYNAX57GcmOYb1Ge6BCt+bhekax24MCazpXnC1fJeXKK6/EM5/5TFx77bW43/3uF79/xzvegbe//e34lV/5ldOu80vyUT1bTqNkZmoQxSjZ0YLVNGqyzhmTFWA5YmARJwT5rN9b5KsylQIaNaAgZ+Bs4il8tpNGWtSsbpdOGKV29XlwQgZOjE2xvyMneEqLR3aPMNOo1TcMMbhqVL+5D+RSNtE3zQACJVYpmqf02tmlQG5sAiPtC12UI0tiElRNuzdrT+zM/C/SPe1XOP9HBkwiMMwfAo3vaQ9Gpf0vsw8+HgOfNO6kD3I1BGlTzIm+CshjE1eubWM6VrQiCK/jjDvVV2UGOwvSyBquJtoRI2ftsYANa7vVf3JHxsu0BuoK1HZg+MgmclUKWK0y5t8R0PMYkK6+S3tYJyiWVR1SizC3d9gTYgIN3VSkW8s3CFl/rr7T9rzzkm9QCON3Kn+mOfhTjUpAwYQjGdO9soaqrBADa4IANAGW2XiLKUn1fZovQDerrqgmdoBzIkGmAJScE6uQvjPJdQlxIxoDMFetQCpdBWaZExW8EpAAVd+LcgZDLU7yl5xLzJ3NZ4Sku9rrxqYs0d/zCE4+YIb2UIXNT7YojzdJTzVPhBACiu1WZJi6ATRfIkwrcN+BduYyJqcTcFXKxqgfRCaqLDD53BbcXN2EfJn6OpIUId17CMJYlpYFi+HagPp4h2LXoTnkMdQe1XbAUBEoECbHBtQngwj794xip8MwleBW1/ZiTt9t0ibDAriA6LPNQLKk5VaFIcjo1flT/Mh1bSlLRJkxG4bqz4sQopRXTCNNmesVkDIRBgZXBbpDE7SHKoRKlA3KLcmmxYVH8DTK73J3KGflqU5drr76ajzxiU/Egx/8YDz+8Y/H+eefj09/+tP4i7/4C/zkT/4k7nOf+5x2nV8SUG2aBjfeeCP6mGFHytkAq5WiMk+cswhAxjLy+K/3aZdq84CZZaxENtEWRKQFMGTH52B4COLPxJCJxHbDGVsFZbXiYpFpgpBTSRWbxLVeykz0ERhaRHCMFhWmBvmiZJqMOQBjA04KHkw4Pe7m9a+BTwPOwTRMSYIigLRYcUiBM+AMI+giXRZp0e4H0KQGazAbAovoeZsFfNiEnjOeyOocYZvsnLwY0BtRqzlgz76j7BmPqs0ulAP18UXiwkjGaGfXlceRgDYrI0LZ4hLF7O0ZKziObHncGFBibK1yK84pWLHLB3AbAEpzB1mgFZGATQ0ySe+GHMNAYgCNLSTVIJ5M4jtEdYmh8pJD3Hm4o9txYeWhF9eR/QBjjlFtDEbLwHjTM+qbHNAhdX3ajCGxefuxpvljW43+z60HGVDf09fKcjEH7bvE+qJVFwmItiqiJBFgue1jXboJoaKQ+8zSgYKRMhZZyTaETLrpWZsmH8y8cNJSpaqUwLaiEAZT6406p8OgUmV6btOAF0vdMDvZGNSSOQpL3UgOg44LTsDXaz8XXoDReWs4+ZBNDBPgwD8uMf3crozRA2ugnUUElKIEEtBvlBL9PwSEg2sI0xK0s1Q3rUrOGzTxhfdAWaI8toQ/viuWBECkq1TKCcbcR1CefETZOWBSyTUCozy2QDkE1Lc6TA9NZPi0Peb3XMP0pl0ULdAdqOEXPYrjcxTHtI+1LdQPsmHQ9YYpcwEgAtW1bFCGIQHIbEzmbk9xM6rxEAASeWHz/8hSwHvHtwX5BgYXHsOGpEt1A+C3BxS7PYrtJssUCLioS3y2fDWUN7zhDXjjG9+IP/mTP8Gtt96Kyy67DC95yUvwxCc+8YzqOyOgevvtt+Paa6/FW9/61vFEr2XfPNlfx4UHYR5M8Dg6oq++wJl8R8wlnbOohIwloHHwgK2F0Rw4QkuI8k923aJIEcvWnqIQM1pVAvOlMF7KXJKK5OftGUVqA9niinF7w8qiQZQkT1jji3OmyY43Fin2AwBWf18K6fu876I5mxPrxPn31i22KVD2pbAgDyfC9HWl4tXCpI46OQep4yc9/jqCiZXDIniBAAJe/c2er/7bIqVPec0V4GyVWFCaglxWIJGwTcbW22kKYln7jMi0d/MNjbGvOUh1yUqQ3z+lPotXGpny0zgV/U5Efz3U1UgjVFwwIO4zpSx2pGmGURUIs4k0Z7GUII5C0kcyd0BoQYtGzKzWbftIQZmclDQ/e0/zOY0RXRwohAz3712Uo3+n9YeNsXjB1Q3IKebOCAL0s7n+EGXpiFOCEIK8YxEIqU7siInWz1R4dVvQIDZtU3RNAkCs0m0GMHgY+3jb+74CrMOhdaDv4U7O03ygbCp5D8ymMtft7EpWN0AY8ByM6waKVMuXHEQeryzinMetmPvDxkRUArYa0PZCfVMp5qVnDyzutYnty9bBDjj4kTnqO5agLiCsT9AfmKC4w8Mf243yXFyJhFJ3YAJwwPKIpPNc/2QH3piBN9fgOrW0TGoRrS/EN9P8/KkqBcR2HWJwqOnNViUsSx4XHjypEGY1AIbbWoB2l5K+uCxQDWJOH1zAzBGKHTHpV00H1wWg6cTVAPo+VaW4b5g/ss3dhY863ZGxrpJ2NGdkRJKKy+YzIwWiFQWJSY3kCJLPailQg50TN6CiQKhEOpF6hp/3cJ34rLp5C1qKpnjwBNcF+GW4ezGMbDvuu/gaX6WFiPDMZz4Tz3zmM78s9Z0RUH3hC1+IYRjw93//97jiiivwiU98Ah/4wAfwohe9CD/6oz/6ZWnY11QxcWljL0egKk30MlEQeD5HzOyzGp0dmUECKDNrk1dVEFYWgxPIYdXKIwAa2GUAIC4+zgMH1sF1KbtbQIIkFEhYcIP4JLk0CRkQMRbVrhn6xB4NGSCw9pvPmE0+9o+cnbJigFwBWMpwBUSfV50IR9H+FkwBJHAQq80UFYZBxMR1Ygcg+b3bTgNOxiBlf8CY/XYqs/Ho2BUQy/mx+teNDth7Hc6/GKFw/aeBouzZ2LNcPVYZwj2YzPqYs+NI22rAJA+iMNBm4KwsknKEjhUil5kMs40IADhhsKhTH+S46CnzYz6TjGTOLQvJ+NP14MqhP2cN/TkzFLsD3PYC7o5tMPOKfm1Wcr/IOK5sc0Rjq4R2kOnjmiYo264igjHsAW0jq0nsXHtUFIFmTDGcA2n7t2lM2lwCaBpP8W/kvhdgMdPo/q3dFFC0ck2rb492bD4s7N3VdoiecifPyDQ1gWyDokB0COC6AK9NwI5AgUEnd9P9AGKl2GbQdBLdaqgsgOkU1DQC+rZ3E5guPOCUfdWNCi+WwhauT7C47xEsLlnD9LYexeIYUA8CaIP4+fOBGfr1CvN7TVEsgfrEgHLOcS5yO0sUfQ8axps4mjeobjiGcHANu5dMsTjXi+D+pEJ/4SFw6VHdvgNaiFrLsFFLoJP1XeHl9WkaACTBhppqiUuxIlAQ2aphXSL9BbA1oN0F2FQNmOG25+BlA88Mzx7DwTXQbgN3dGfsZ2wuMruSeU0SHGjQq3dp7g5B0z7bu4bxWGMF+YS4mcnfbYpjivZhYgPIV6ob66P7CQAR9q8KcacYAtxCNpDU9SJd5R24ruU8AK7J56Cz5auhnDhxAjfddNMei/vFF1+MI0eOnFZdZwRU//zP/xx/9Vd/hUsvvRQAcO973xuXXXYZLr74Yjzvec/DC17wgjOp9mu3OJdkcUDJpwoYLxxm4lUTNGpd9Q2YxvSFITElKsg+Yms8R38kW2BTTnKdyEK2eGrO7jARvyPqBplcM383AIkxCyZrA5UAQro+oJHDPuqsJt3TpFsZF4HCsm9RWlCj1BVWmCSjGJFhQAPKAcnvCxmwQAIIefau7L6gwVPctnKP9qw4A/Lpge19vqPfV8AfrX6nn3PWewRa7ZnTPufllyfsbQutfG0g0ECU+nmmvdE+Fe8TSBXbpN+Zb6qZ+23zgvSdMPWaRagoNCI+YxbjbZIQB5ay1RY7EyX3IsbOUDN1WQjInUkOdNpdRF3QbrOC8yUcCNUtO7L4LRrVreVxd1n7rT3xb/48VkB0zrxSCraKIJV53+Eh4y7LvmbXsjFADkmHNRsb+bgwwKzXTptQyOZqbQquCtl8VrI5oONbAv4MlBh4sfFl71h2XbKNpEoYkVpcyDl1A2Cxxtg9GBtn4FPrp1IE85kAv7WImZfi68sB4R4H0dz7MOoTHdxOg+UFaygbOag8LuZ3MiawKKVtpWYz6nqwugFwXWDnwUewuNc66qMdJjdugeaNjMnpJFmFepGHm97Sww1AudXCLVsBmF0PNC3clnZICCJSr0QBqZNkt1mg2g6Y3dzCLwa0hyoM0wLFVgm37AR0bS80mj1zr5ovpN1VBZ7UwirG+QEI0wphUiLUHn7Ry9htxdUgviMhyHfmXtAP8Ee3xWVi2QpwjCoL+t7HDaCxuLqR6Lq0CTE5Kt0EclDfVO8BFoJDMhxqkGkIYhGz9psvOTByfyFVMYgZuFTWEICMURZpLTdvQIs2A71QEoVFXYGlT84K/n91lK7r8N3f/d34vd/7vX1/f9WrXnXaylBnBFRvvfVW3Ote9wIAHDx4EEePHsV5552Hhz/84fj4xz9+JlV+bReyXOr6f9liACADedludBhAZkbB6KcMiCFNAEMAesk5DyDKLMXFx7tMtJ0Sq2uTTVUKQOuDmJ8KD7e9G9uXtBApTVbOGFWk+8kmIwG1GoldFuofl6XwHLHFSH3gPKJfoCkSrDJCeX/kGq45yMtBuS38sb1SNwPAMCAslnHCpUF2/2HZfHGQOio0bteqWdfaPQIp9l12bASJWX323amasN+1cuZU+zalz10BwvZPBS+Utyl2rbQpRvY7N2bVbHwQAUG1NiMDqgskMDKns3Wbz8ZSbSmEnUiFFYUs7FQAazMxqZITNk3NikPlMKw5uNt2RLKnl8QKuf+tMPky7sn5lJkoMqkcx3qekGOkt2vjZmTizDZp+bOI+J70mi5uRjgMIFJz75DYIgGWDhwcgJA2n2EYb3qcT1YEAFx6keKaq8l7e0eZMrmHpDgAmN/qKMMWZ8k5rOE5QM/udSTZBsjcwohmX/Nr9Xdsiz8poJthLz6eDlg+8Hyc+P8dwvIeHms3AWufbQFPGBYB/dSh3G5FI9XGFwexLM8m8IFAt58QZrdwaC6/AMuL1uHagM2PbcGdmMvcVxQS3GTtnzcou17MyIHhlp0wjstW1R8oPkcuPbqLD6E80YACI0xLdJslunWHtc93qG6fw+0s4f2aaIAuWvErDQpQ58s0zxtgrWugloA+Nj/6wBjWxB+VvTCp6Adg2arrgDHarOMmIyk6y2qlfvV1FcHsyOWEKM3f5i7Rd3K/mhQBAdGPl2weN9mprpN3ML7j+kxyAAoSt4YAuT+T6bJNFWRdEFcZAnW9rG+s7+SkkjEUAqgXaxw1LUhZdgdK6+XZcrcu//N//k988IMfxLve9S484AEPgI9YQ8r6+vpp13nGwVQ2yT34wQ/Gb//2b+PHf/zH8aY3vQkXXnjhmVb5NVskutLH+T+uzhaYZExpvjj0PXgp5q+oPbhfhLQBRA66Q6YxsAsM5h5ESYQZ3iW21cw7iwYcAobNGtQFuEWTXBYCp2CECPbUTzFf0O3+AJnwvEss0qoZ1MzyMdsMj/U1zWSdsYERoBv4jKZmTsEcBlrNFGXtzlNZrgDYsFgm3yqdSMGcTMt37invDxZXSwSheb99kXNPBVJtAaCs4+05jBCu9h2lOmyPM2IWY70Z0AIS080Qd4RcsWGfZ0uFB/dF+q4bop8gqZpDkoOS+jmCdgfq+wRyGdGvD4UHFgugGzBUDt3hCthck6jorV0Ut2cR4mUZ34sY9BUj4QHJqCbPIW2caNzH+zybmF0pA7bI7ycHd7mCQNyUGdj3cVwKXtVrDdpXg6WVzawagVMqS9t0FgV4cw1cOrhj28kHFwTMppqic2y+j2As34SFAG1IGi4KNmIE/+4imYkNBKnAO7edHDOpwGUBOrkLPrktQ8ilzUw4MMPyngdw7JsOoDlEmN3Wo76tw+SzJ+GKCouLN0DtACwyBRQFP+GCQ+g3StDnT8B1osgRLj6C9qJNFEtgeuMu3NEtYRi9+GDyUv3Lda6gBeAXCl6bNikH1FXcLPPaRNjgaQXsCuikeUB773UU84DpTbtwJ3bB01oi7W84Blo04HMOYji0Brdo4ZQNTf6fZUwjGuoCYSLM8FB79GsyFlwbUM4HYWbbVnxL8zS2zJF8QFmCD6wBywau7eNzZS/v2CjYjSWhAmUZv0CSJY/y+dheeJuHM+kpsjFs/qrqupDWmVX3EUr1ZpYSVkUV2l3KvaxNBdT2g5j97ViGAPWmA3kHB75bMapno/5PXT7+8Y/j2muvxVVXXfVlq/OMgOqVV14Z//2zP/uzeOpTn4qXvOQlCCHgN3/zN79sjfuaK/0gvlg6yUb5GGMy2k5zx8sI5WUju1ld5NzaLIEpjYamstDFTFkb76K5jwOL36oFnADJty1KL+mCMwT4E7sRSLij28k9wATcDQApGGJGmugMYK4GiVk+8SCRxtHEaf6xMXrf0lNSYtoYma+ey3b58nGPHyuQJsgRgM78/aLtUf+v6wUQGRA0M1bX2UH7lBUgt/fDFy57XAVWgWLWvnhO/jspPqXRSXFTwHmVlOrK06LmC8oXbGtWD6V/js/PxhE5WWCrcsy8R2DjQcGlBdwRWIPBItiLEj4AphOppzX/0gLsCf2FBzEcnMC1A9At0rjzPomlr5rih0GACTAClTEIiczXNLvxHCQAmU+3Q15isokVX80xu6ruKYUXUDdfStcd2YTbbQQ4hRBTwZKZuW0z0suY5CGA1teEHQssrNPxBNCgwWa0NgMWS/DO7gh0EygGy5AClCgXRQACpH7vpI39AMwXYq0xwXZm0NoMNJsgOEJ77mGE9QkmJyQVqJ83wqwaMJ7UGNYrNBdtYn5hBcBh89MDDv3dLorbtoHFEsMFh9BXjLVPHQdObmdzCYM3ZugPTlHfvgtqWebE2QTDuZsAA5NbFph8/DYBuGqm565LqgNRbotSMhOtPxzZxHDOBvx2I36+dYnhwBSuFR1e6noMh2YgEDY/ehLFbdvgukR74Sb8TiubIt1YF8d2gEE3P1ngqo1nrguEWYmh9giVQyjlPNcGFDsd/LFdYGcO7sUiwVH9hWXzEhiw2IW2E4vGEMBeskD1GxWK4wQybVYbh4HBpGylzglkCQiKIlngYopjSnKJzoGrStaOnExgFpcOgoxbWw96kS6D8wJCK0vlre9TGzT+ATJG+iDgumnTWmhzMQDAC4gdzZtny921XHbZZfjIRz7yZa3zjIDqu9/97vjvxz/+8fjUpz6Fv//7v8dll10W/VbPllRYgxy47SRQyha9ph0v+maiTmeq/p2YzLmQhYibNgUNTSdJQkYnZPMlI2SZdFijNwvxbWJjbOxyBNCigZsvEU283o/N5hYZ3KvMSgGAir3BJkC6pqKbyGRytqjvN++sLiYGNM18vJoxBUD0y82ZUOtXXulTZU3spsVVwkBtECwRVOh8tX0rwPCMy50Ghyv/zsxotEeuitPxlJ9nX+i5lvI0Z14N3K6ae/V86XZCSkcJRHPi6J70GjZmDaTmvtUGkgnJUsCWGEKbAEYgBtcl4Ae4PsAVXsZyXWKYeGG7nENxfBc0X4Lny+RfrNYBAuR9MTUB0kC80bNAGl8AEAA25jkPaMrZ1T19hNHnGIWPABO8l3t0iWHSzSocwW3PZcFv23Fkfj8kZQ5A2jKtQbMKvDYBbc9FrmlnJzFoOQA1kBbbjjGTDY4AC0ByhSgLUb1YLAUcO5FbErUNgA+sA4VHd3CCfr0EDYyde05QbQdMbjsmG9LDm6C2l2j1ukI4MEOYlRJ4tBVQH+0x+dw2itt25BgAbrvB+oeX8Md20lyhQUBhUmCYFhjqAkXTyob8wDpADpPblqhuOiEgNbdsxOeEJIlkiQsKDwwAb66ju+Ag2BOKk0vwpER7ZCZM6bEFsLsE1yXCrIbf7VBt9ejOP4Dm3AnqYy388Z3I+KLwoGUnoLEqJbMVkYxjBtg7hGmJUHrxzWwD/HwQ4ftFJ8oI84UwaUpiRK1a8/HW94tQiosWAKPeQuUkkt6SBsABPcuaAJEs4yG3MGSygtl6gsLLeFoshXWtNAOZd+C6SoytBuGN1CDgQBR0U0ygrovrEljm1pgQwolrDw2DbM6Cto3VHQa6gRzUpe1uxKjmRrG79BpfheU7v/M78cpXvhJvfOMbcfXVV2M2m41+L8tyjzvAFyt3Gqgul0tMJpN9fzvvvPPwhCc84U4d+3VZ+h68vZOi1WPRBfFO7RRZGFY73oCYTsoRpGZ+n3EyMMYoC3ZCT6keBQ/MFsHMCQhR/D8F1npN21nni3UE3DqBGWjkbPEgve+c4STV34wgyxbWjBrcs/hQmtTMRzdbkCOYtWQGq8FjrAL+K3qQNjHufSa08vc0ywg8fgkg10Bq3h/W1xFs6jWYMdIAhVNLsn3OWCbbPORF6yRj0CjbKKiOImWMDw/qYjIMKo3EAMTHjAFNm5vGnPljRrIXQFifgKoK/blraM+dYHFhifXrl3Btj+3Lp2CqQANj8xMLTG85AdraFWYpBnQpWLR3YOhVBmki7GBeLMAEkJz08b61mlwmLWK7bEO057k4ARjKThEAdgQ+uC7R5yd2xRRfluBSzPq0aFR1otkbfW/XM7eV2QR83kH4rQXo2EmZV4wZNBCmPowxICZ3CdF3W5sr/2d+2WUhbgRrEw3+aTRKHcICHpoBVYX+0AT9RFwE5hfWAAjFklHOGdVO0GQLPWhrDiyXkhJ0fYp+VoILwvSzW2rSVQkiTQaAvgd2GHTuIeAAie+oif1vbKA/OAU7iPRSo+lUB0Z1246Y5ncWiRmkzBWDCCCR3aMhgCdifufSA7tz9BcehJ938J8/BuoG8JFNuI7hTy5AW3PpwbpCeWyO4rjMM6H2aA+VCHWBtWaA35Z2Uptld6q8pHntelDTS/BQ4eK4KnaCWANCADUdaGchgN1Y2D5LPGCpouNzHIC1CfoDU4RpAXd4huLEEv72LfiTpTCas6msFyEAg86JQTdRFoQLqAuW+UgzsFiAD26AlkPyw7ZEGUUhjGzbx3E2IgfiuuRTQGpgEAWwK2TToxkFo+SVPS+dA7gskgILEHVxqTa1m7Pl7l5+8id/Eh/96EdPKU11lwZT3f/+98eLX/xiPOtZzzqlM+zW1hZe//rX4xd+4Rfw2c9+9rQa8jVfwir4sV2tAYoVNot5tCYSYYVxpTShxWsoi2PVWMQlIy1gE/Hdo34Q1jCCGL2+Bcjk7JHX4CbvUvaR3LRuf7P7SzqNiEB4BK4y5nUUkGPfGYuUg9/s99hHKzJco0XeG6DI7qXrVF7HfPeyZ8KQxXq5Ikml3f0lzZRf6u7YAH5el91/buvn7NjRswGopCzBw8q4y4CuSfNwdu7o1vcwwrZA6fXNH9t8IU14Pm4okBZIcqAC4vsWRACepyXq2+comoDJrQ7+5hPg9QncfTYQCsbaDQuUNx2D25onoL42FbUK9eGzRZZ0w8zGVOVN55RBLW7ULOd634/7m4GRKD5s0fcph7tzEmXuAJ4I84uylHbMm/iameg8bc9l89f3yiBJ35JtrmJ/OtDGOvjQOtyyBXbVHK/HxrzrgcW/2m5vz5yjl3AESRavGxD7wTkMRw4A3sHfdlIAYVmgvec56O6xAThCN3NgCggFozno4JeSzrNsgX5KKIlRnNwVdnh9Bj68ATiPcqsRl6JlC5zYTskGdOPDdY3+ksPoz1lHfetc0pL2kvGpv9e5aI9MQD1HDU6UpUgbnZzLcynLlPzD2H9m8PpEIvA7lZ5T1QjanoPXp6JKcGxLUn2qdao8ugs6viNt9F42E4WHCwz2DuV2j+ltPVwXQEH6DctGA7cU2AUGHAsL6YRJ5dKD+oByaymAO4TkmxnnSmUTQxu/S9Yo3ZQUhcjnDQGu5+jzWswLhGklbZgvdfikeXdsAdF3kBwssl/mSQe3swQvFvF9pKrS1LU9MPTqmpJAdyQHnCTZiK4OpibglFndXci9OA/yqi7Qq8LM+lSkEQlw2wuxOFi6Y/OHvTsVxl3vQ3pX138XlRe+8IV4xjOeccrf73vf+552nXcaqL7lLW/BC17wAvzYj/0YHve4x+HhD3847nGPe4CZccstt+CDH/wg3v3ud+OhD30o3vKWt5x2Q76miy0W+gKT6cnl6UgtsEjNH9z1IBM4JxJznApzs5pVZUELsuiYKdH82mzCtmCozGeQdPGDywKQIgbmZB6zdpt/q9VtIuyrYDVnd/PvzLRsZng6xeRpddnvI2YJiQnIGWMwomrVqmmegGjabDqExeILB0g5Gt/3P3XZDxDm4Fy/2stqc2I3zEeVkMnOuOQbPNLrBHiQPmUD+HsY2vz5xIvqGqcgOFMFiGZu6/NMbYJsnAFx/LqdpWRQ8gR3bBdeNxRD6bHxkRMobjkJGiR/ehxnB9eFtVo2KWKfSAJ7wOKvh/2femRiy1LYtiGIr6f1Zdwp6n3m35claDaVd9I7DAdnGNYquJ7BpUdzTo1it0N940nQsS0AyiS1nfjoKUDJM9YxOPO3duLf570EzRzNWCvnRDOVWB9/5l+bt3vkIgNlUIuYZ556zeJUT0BlCb/boD+yju6SQ+gvXsMwK0BFhcnnttGeM8XinhP0M4+hBvwSqFrG9GiPUBDcsoPbkSh6nk2AzTXx11wuxUy9ViNwDb+7BJOT63a9bAoOrKM7dx3dhkf1OWFc4Rx4bYLm3AnaDcn/7s6boR6OCBupG3Vj9Kjt4tgLaxOEWtQi/MkFmBXgBh0P/QCuC5S374DmXQS/GIIE+nS9bERUAYXrUiTUVBO23GrFp7XpQMtW3Lr0+VKmG8x1iWFaSFsIKJYdaCHnscnixdebNQBLSQQjDswaZvN0XQHLBsXtAeHwBjDT1Kz9AGr7qBogJINL+qq2qTVVlcAABX0ndYOkG1mqa12fnLCc3gt4blWiqiSQL6KaREzSEfVZzQLIUe0hvoF9D2YFySEAVKjSjKZ3jf7mLgFiTzhbvjrKfe5znzNKk/qFyp0Gqo94xCPw3ve+F+973/vwxje+EX/0R3+EG2+8EUSEiy++GI95zGPwUz/1U3jkIx/5ZW3g10xRMw7VFWg6SUyQLiQmaB1fR5MaAYR1Mt82IGobAkgMT+ER0xJmiwBAwjioTilZFiZlUljdBSy1ophAB8U6DPNri4ylRdfbJGiBMnofHELykXIu+qgKyAzJwmym+5wyzhfVqkymMEAmqixQyzIIxQCQ1b7WuokAbnuE+UL6Yd8igW00nSKok//dpowAqYtm+PQdsgO0jPLA238GXIJqWlL6HUhjMT6Dffp19Ysc+UUmC2PfN6TP3LagQEkSx843wGrZqDrxKUUXBHwWBfzNJ2StMn1gCLvWX3gYfinyQPaOUEBK39l1yb9zpflkbZ5OgfWpRBV3PeB7kJOxwrksFJlmrI9+uLyjEm6TGu7kHLS1C1p2CJtTlG4D5Y3HxAweGDSbACAJmLSc86btq/9HBlwt0NLcaJpWFA/U9YOBmFmI1bw6eh7RusCJlSUCQ8TfCYyoAHLoAJgDQtNgmHps37NGe4DQbk4xuwWY3dqjOzJDc06Bfh3opwpStxnT2zpMPnVcgJ2CVBQinUW6OW3PWwcXhPKEBGOFtgUVBYgKvQ+H5sIDaA8UMkc2DQCO8wM7oFuTuco1BeppBeobFZFXtlr9TrmuwHWB7uAU/UYJ10pwKIhAA8MtJSKf1yuwd6KjamO17RK7qcooXFcIa6rZuxSWj5Ytilby0Of+k6YJDefA6l7ApROfVQdhYJtemP8ssC+CO3NLyv1sgRQIC5eIiEHmWbe1EAayaUXhYNlEtp0tMCmfs52OCafvEAcFnmX2Hgq4JecEQM5qUD/IuuMIoIxgUYsLE8TdxXvAQUB4p361bSfjW7MhMoUEwM30bxm1mk76ZRiUeZV7ZgskvruUSOzcxdc4WwCcQTDVox/9aDz60Y++K9rytV9CAKsAOU0mMrE1LbhtJYrVpaxREkmastWMWKw+pJc88/kDKSx0pH5JlFQEbJE139KqBDpEyQ9hdCgxbwYko1xUhphWgRJR2omzsEtCKNAKY0cAQpLmMROtXT9zB0BRiI+XRUJH+ShOOp45xkABTwABAABJREFUsO0HVQLITLMWiNK22NcH03tZMKcT0SFcNuNkDP+UxQBm/hkMNmfORMNov1lgUs4YZ8faRoJzdw/EjQRnx4xmSHKIslb2rO2n/HkRiQ+eBkgY+xRZVVbwZcyOsblOzLEx8Eeje6mTTFLhyDr8jvq2WV54U81YX0OxHICjJ2NyAA4BYb2GD4imQ4KB+6ztZSm6lqYHuT0X/7ygbg8xun9lM6WsJDMn5QznQEtJ0WosHIFQX3+7ADfnAGgqXvMpjd1s0kFpoybZmSYgSKpL1CXc7lLe5a6TqO/Sg0/uxPthfR4xnWvcdFA2dpC9NwSe1sBsinBwDc2RGu2GR7fu0R5wGGoGBQGluxeWUj8DxRygjlDOGbNbeqx9/DjcbScEtBMw3OtcDOsViqUI/YeDEkhR3XgcbmeJcHAN3f3OR3nHHNgSVnk4MMXykhmagw6AQ3PhJqZbymoOjGI+ACjFxWA+iC/oMIA4APNG5pyqlACmqkAoneiUEjDUYr0qtjoBW72CpG6Av2NbQCNphqiykPnQ5rDCY9icAqCYOSnOcf0Ami8j+x7drLyPABoMoA9wLghIbgdJ+VsVElRko9N5kCVrYCQXk9yCoeQEdb1s/KYVeHNNapgvJZAsqpcYa5q9axbIOMg4JNUfju/8MKS1xqxwg+ieYgeqeapZ5RDG734wNyoCu04sgfZukFvZOGuwr6lTOJfk3kIAlipbZa4D3iUN17Plq6Zcf/31+MVf/EV89KMfxdbW1ui36667Dk9/+tNPq76zI+ArXjSr0+6uZCmJ/pLK4AAyGWguZu570VK1Ha8ttuYHpExtLDbRlKUwCU2bJpXcX5VZjmFlWTMwOZqErFU2aWpGlPR7Npna+XKX49u2PPMmfxIE/Iwyqaymli0L0dxsWrnfQmVKrCi7xgfXhbXqU1AKecmsNc4/b6u49JObTcXXS/Nwh+2d9Puo7KEWE8u26uP6xcrKKac8xkz2OfO45yIZ+KLsGUVwss95xgQoADN/VPHO2EM5ZmZljBfOfONESD7GusmIUeiBkw+hjRETMiddnBoxU7LJShFJ4AcB7tiu3JJXsyBULmcm4ul0bEtACpEAkVKCbHhh6hWQ46dTyVZkbTCXlywPekybyWPRfyJS06MKrrMqUpQFaDqV+9tcF6Zag1/crcel/rIUU6f2RxT9NzBJpCA16ztHwHwprgiNMG8x0MrJ5hbLPLgGiPq/Vv8edYOMjSoK8KENDEc2sLhwgqJxaA47DBOHfkYIBVBuyzMNJYMGoFwwqq0B1Y7D4hwnKUiPtnAndtWUy8CRg9i97BD6DY+N63fhTwjjV92yAO0u0J9/EIv7HgQFRvWZoyJ55Qjd+RuYn1+i2SRUWwFFA9lQFx7NBetYHhaQWm0FVHcs4U5qUJrOKVxX4FktG1vVXfbtANcF9LMCxY76k9orUHhQ2wn4IgJXJcLBdcCJ+wI7AkrJRR8mBfyiE/9Se7eY9RmIagtVlWikGkDV50sGFNte0qlqtjXKzPpgYWJ5OpGxqP7c5MxnNSMLopRgDzQE7DpJILDMNGfzlMlhiBupOMfmcQ72LgdO0lSlKBSIuV7Hbd+P9sUAY1//ZwWabAoL+h6ngC31f8/HrSN5DoGBXuIHJANdKRu2sgAxi1vH3cUlCzjLqH6Bcuutt+IRj3gEnvSkJ6Hve1x66aW45z3vid/93d/FRRddhPvf//6nXedZoPoVKLImpeAowXZBghW8mliyYCHmIGbPrk+BFfJDellt15mxmQASQGGFF5YhxNghW/CGIZpixsLkssMfCUbnvnk2ydqO177nICyaMnwjNlUnynBgJq4GjeZyBotw8rKTnXvIQHeHZH6bVCIaXxQyCQ5D8kcDIUxrOO9BR08KW2A7cMtOU5UpQErTf1JVAVUNcEDY2hFgs69rgIG+rGMzv88IfOzzfpMp5f/g+OeUxeirPcdkQNQ+2zVD1ohRe+37feohZeHynwkAXEacan/Z54yNTSZxlxbEQSSVOMo9hWRStGMKD3RBwSuEKdINE69NNCtPE9lHPu+wWBpO7MSgQBoCcMdJacN0AnYMLFphNjWzzShtZNMlPzpATPrqQ2dMktw6xc0edSrNpICWQ5AxWxTgw5sIm1NxUWl6uADJTrRYCusZ9YqTrE50dckkq0YuL05dfNam4GMnZIxXlQC6IXvvRmZX/U5l56LbjdVZFEq4a9DVtMZwZBPd+ZvwrQTidB6S2askTI5JZigw0G0wijlj/YYWxa7IhC3On8D1ThjCHb1Xfc4MRnuQ0Bwk1Ld7lJ9pQVudvMezKdqLDqI9XGH9M3MNAmXgnEPozlsX037B4oc6AJjUaM5fx/zSdQylQ30yYHJHA648hkNrEpW/bMFlAZ5U4NIjFE7UJgigLgCFg2+D+M4ulJX3Im0WpiWoG0ADpwQoAMJajVA6hNpL8Ncg7KrrjJGUPiZzDyiSv2+cG8sCXLmof03KNhKnjQy3mjUsJoJhRIUOA7FlmTbw5iZgQVchgLZ2xvEEtrGNry6leqN1JZs/DMAGBccx05kC1yEkfWFja60OA5dx48X6LqkmqtVvkmfMUR+ZnVOd1bTBFMlFScuNUsmDugSRE/ed5bB383W23C3Lm970JjzhCU/AG97wBjz/+c/H5Zdfjuc///n49//+3+NhD3sYNjY2TrvOs0D1K14IRKzvNYvPU1WC+n4EVgHFAyayDERgaKb5CFKBCDzAJCZYm7gMUA4hpc/TLEGjBc8il4GkQxrB7z6MopUM5XAvGYTIol77QZgoLz5bYW2C9vAEIKDY7cFeAJ/faeCP7YKaduTqQG0PBiMcWBNfsn4Qs1pZRNBNqmAQ6gLeScCEBKcQ0HMUnydfSPsUXFJZAF2LsPuFfFexF6RGgJp9bYdw9jf/PqG8WM3+SDX7jmmf7/Y5DlgBxwrGXXY9AqKOfQ44AYyDpmyTsdJ+KwbgbHHyPi20gWGsLmebE+gYjxsli/T2ygw6Dapqdeyc3BHzpOpnYnMdrg/AiR1Z3J0qTzRtBF4iyj4IIxMygB+CsGzRwQFxMaasH6NLjImKBwZ4QAT9IWAoAF5bQ3fpERTLANdDgoKC+ted2Em+fs6rOXSIrgRR7o1DZGrjrtXa5pyAmF4WbG47Vefosw1RPh5SPVFcfzqR/lssgc11ud+TOxJVvTHDMKvQnDfF7oUlqm2GXwYMUy9m9e0e5Vz8EPsa2Ly+xeS2Bq5n6d95A3+gAFCg2OlQHN1J8lLOIcxKtOsNZjcXmNywJT6Hxu4tG/idBtVxD78lDDZNpxgmBZpzSrAHfEOgQBLA1c/QH5qCiVBtS3T74twK7abD5GiPjY8sgFoC4MKsxPyCCdpNj2qHUZ+QzGbtgRIUAspbGuD4tvTVdAJerxGmFdxuK5JUhZdNkiP0axW6DelL3wQEp/nmdTyRzZXsxT2AIBJUC31GZaHfa7CaBTmpIgWZuoMCODJViH6QzTipyH+ljKIyoEwOgIB7CgHQ8AN0+4wNC8xTZQWyVK665sQAQt2csSm5+EKDxiTRgbzLuq7YcwSSqT++z2RsjLh1xTdMN7GOgKBxEwqq2QKKozqMgmlzH7L4h1YC1QSq3H2A6tnMVKcun/70p2Os0nQ6xfa2vHsXXnghnvjEJ+Iv//IvTzvy/yxQ/QqWnJUikDCn4BSxPz5a0xMWY0koM08iMVHqYCjnmG5ezOCUmYKYVS5FJhAKOnFkci4SDZqZFY0t1QjNEUjO/U8BYYeJdBITgWkizfvc9aATO/AlgUuPofYoFr0yGh48qaQ9BsoNrPaDLBTOI6KtkE2a3sGd2EXYnAFgmdz7QdprPliBRdamS+klJbiKxwv/vg9sBbXF2WMf8L4fqB0dzuNjvxBWjXbKLzJbnZLBpawpK+1evS1kgSu8cg/2x3xabXOkfs7EWR55IEb4Rv/gjGmN5vbQi3/ooJmOzC2AAfMl5sqDDm5KW9RkT3ZdY1ULL/Usm2QyzFlHBdVclxJlPQwpxSgpG+a86Dvagh/ZIQDeI1QefGgD7TkTwBHKrRbF1lLO394VEFoUMdOTMKjKepEDeUa0oFhf2obAGDnro7IUV51OADxblPnmhswRlsM9ByRqibBsVigKUOjEYtAPQNcjrE8wHFkH1mdoDpVYnOvBHggFoT23QLFgTI4PqO6YY6gIBRNmxxpUS1LJIGVPOcDv9lj77AL1zdvAyV2JdtdsR+5Tt+D8m4/CHToojKaxaE42K9Wn70B1dF3mrPU1YHsH7sQO1j67hmqrRnvAwzcQoF0IE1nstvAtgdjBO8L653qUW60wp7pfWpxX4fgDSyAA7kZGdRKAJ/Rr4vNar1Xw2zJ2hkNr6A9M4JoBbncJgMDTCsOkEDeEzQKhcHAdIxQEb/OMZbDTjX9Yn4JLLxnFzORQaACVd+KbOojPNbVd0kK1wFXbzOUuTwr6aDZJqUrzjEwMAYL5JhAcmfiY6S+a5Vkzj9n7m+lpmzuBsZtmTQsswWzDkMhXezfBib01YsPGs21EhQlBCqzUYF3bzFo9lsTA3GkAMfPbu6v9zWZpK7IYhrPlbl26rkNVVQCAe97znnjPe94Tf7vppptQnIHP8RkD1d3dXaytiTP30aNH8Qd/8Ae4733vi8c97nFnWuXXdCFSk97uPGOuPMz0CM4CpIw1sknFe0QgmpkKR+Z1myhYJyq4GN3PzomcSCcsFQUAHgnEERTI6DVyEeh8R23XzITFR6yO+cCqacjStdKylenrjhOojm8Dmxvoj6whTEr4LsDNlS2tBdQyIP6GTScMKqC7cBcXCpNxsYnZHVXZlH5AaBqQ8xrgINJdVFZgmPk/iPh8ejj7AL5TTYqUAM0pHzYSOLSJ2RjSfc/j0Z8INM/EJysGpRmwtKpWghry5maMr4j6Z22JwA9pPJqpeRhkbBWF9GldC0sKpMWn6zVS2aeI/T7o5kxYH1pwWrg1205/yWEMawWmH70lAQRAXV7kxriuEqPlFGSrGwJNKrnxwsvYCkHeKRtPROJbaGoDppRhfV4WEqwyqcAYMPnMcaCuwI7QHKzgihpl4UHzBhwG0GQiwU6aRS5ZOKQPSaWPYvYzA6h9D57UoI119TVUX0HTcWW5ZzbTLwDMJtGvnDsd94MAFpzYElb1nIPCOk9r9PdYBxcSfd7PPNgLS1ksGL4lhBLCmjY96htOoJrPQRPRL12ePxUppi0PtAH1p25H3fUpnSoA8kUcF84pozzfFTcc8TuQfp4vQbOZ+uAuRNGh85hefwz+kkOAk8Ar1wX4k0vMju4IwJtUGI5sYFiX/u/XK/h5B9ptEUqPdtMheKDahbgodAHdWiGgezeABgDTCcJaje7IDMPEo+wlVSoCI5QO7aESQ0WiLNBDZGY5e379kOagSlhTy2DGdZmAnneqHiFsuDH/UXbKNkF1lTZeOcNuL2wIsvlqujifMmeBqJkbCVQFAiDxK+UA8oVsVpgT6G2V4dY5nPJr27tl7bV3Hxi5G0QdV1uTjPEHJxAd06CyjF3KwLL9N/RAx2lOsY1tfi3onMPhFElYzpa7e/nO7/xOXHfddXjyk5+M5XKJv/mbv8Eb3vCG067njIDq7/zO7+Dtb387fvu3fxt93+PKK6/Erbfeiq2tLbz61a/GtddeeybVfm0XAnh9JhO0AjzS9JIEqMm80klEpWRspzqYnQdp97rKaNriFhhCLVD8jYAUzT7YAsoZqMkYSmNPQWI+HvSzAWC7pk3MA8c220IMosS85izwZCLRsm2H4nPHJUL30EbafUMylAxrAkD88RCBKBng1msxvASa9MksB8qitcEp9/nQi6+fd+PAMyt7nDQz0H6qx2nPR89JWDcivNE/Ef1JKV2CsHIMYj+MmnKnC+kGiLLPWVWOImOZX8CGk/zbQqpsU6T/zhQpYEx8UWjEfi+YXLMx2UaG+16AYl2J+S5KjSVmlEyap6gS+D20jvK2bZRLUciAmivZOxBTZHTI+8iQsvoBwpHkuGcIaM7OBzSQEUjjsirFPWS5lLFZFJLFSiPA6eQunHMCwnvxGffzDrScg9s0Ps2NJ6/bRPyjHzgBcAWogGT/aXsxQQ8M7OwKwJtNhSFmhgXG8Hwh9ZQl+PAmuvM2UN14DNjeTf1JqV/C+hTtJZuoji3RnDNBe7hCsWD0U4duDSh3AqoTPSY37wJEGKYF/NYS/vgOeL4ANx1oOkG3IT7ExZZGlM8XyUfTe2FFTQ7JgHmp0fcbM0mN2cvmMZqfT26reLwCbyfvfHl0DhAhTDxcM0iK3E4yd9HOAkXXAxceQnt4Cr+1gDu6BYAwHNxAe6gEMWFytMfsc7sIlcfynBqhlMQhcZOjvtNDRRjOq9FtFvBLzTS17hFK6cNyzijmAeXJRoKwhoxB1HnP9UGAVmmmbmSb5xBz08dA2SHEyHoQwansUnSRAuQaZuVRFhZtK2w8UQoMNeKAs/9yHW7bkBkYVT9WztjVWBcHcB+i3NXIDSojHQCVLvTqegUAba+WBAjpYjqs8R2wv5k1Abo+mZnfdFKZNRlLH++RDODa+D5bvirKS1/60pgi9YILLsD73/9+/NZv/RaGYcAv//Iv4/zzzz/tOs8IqL7sZS/Dm9/8ZgDAX/zFX2A+n+Omm27Ce97zHvzIj/zIWaC6T+HAkpM8BxGczPSkvqjReb2RYBKa1ONIzcjWKBA1FjMvToGmOq8DCjYNpBElQBtN1AlkJrMzkq8Qh2hejYDFZxOr+V6ZmPwqoDYgWvv4mesSrG0g80kdBvh+EAZItVSpV2CPECd6AWQuMgnmN8lxAyBSRWISkzbTpBZG+5QlA5FfkDJFBlLTHEp6jyO/z6zqHDjuAaO2+OTnnS6DoMAyV1yIoDOypRLNPgqiYk79qN+T5TTUNkU/TmVwUEsqSgLp+BhisErauAhzw20XdRFl3NimShka+6y+mAZC0OnCrtcm24BoOkc0bQpyKhxwaANuIfqNrEoC0U0GABm4BURn1XuRJOsksIVmU+DAhgLcTnLWqx4mqQ8fNR2K7RaYTcEHKnFL2NmFsc7cj/3MbdMGQFlUyHt9YhsoCriykACsphUwXJUiTbWxHtURCAv5bTYBuh7FTivMlwHwugZPCjAHdBcfRjGXfuzXKlAAXAv0E2H6Dnx4C74DaN7CaZpU16tZ29hDdako5wHljliAhkMz4NAM/o4toO3R32MT3bnrmHzmGOj49miOom21Gk0mcV6DXoM5AJNK/fJT5D7tLFB2PcKhdXSHpuK3Dkl9irZTE/qAYreDP7EUKaxzNjC/5zraDYJfMNZumMMf3YGb1qhOVhimRWRHI8DsAih4hALoNgp0azKfsJN7dz3glwHlyRbFsV1h/y1YSjdCgBxPARGAxnsxxlK/zy1PUZfa5uegkmU2NrxLwNCAv72/NidlbgDxnTeQaimJzb/V1DdCAE9qYXG7DjE73DBoFqxMss7AJUHeS9Z4BadMcR7BrwSKBSlGK2AIuknLSJE8xapaOgQoS93oOtnUmAKN+u5Gd4I+c4G4O5R8Sb4rr/FVWFaDpa644gr8l//yX76kOs8IqH7yk5/EpZdeCgB45zvfiWuuuQZ1XeOxj30sPv3pT39JDfraLQze3tEoXAEzzAoeQOCuA0GdzA1khiDR6mYOIkR9VQDpe9uxOif+YBH0IE12joCQTXTmHgAkQGlanKYluFiIfJOHyGgtG1BZimC3F/3RsUaqXDYGg6hmJxU+XQuQ9nrJRBImBcqjc4mYRpr8aalA12fngWLmEtaLiYSXAhrN9BJlX0x3s+0E6Gysa3T/CpgYgUPEvt4DVveAzf1LTD+as6p2DWNUrY7RZETjY0+7rFwv5gy1vzRqviRNSBsT80+VoZCzstl4i4CVgdCBdfEk5wQgIkmtmdk6Vl7owtRJUBRvrKUI/YWIvMcMakTCapop3Zh8A5rzBSwXOlUVhgsOwe0uhBkdgr4aKoxPGk5lbgqAgCZbtL3XtJRlSjYwnSJ4YRt5NkFxcgGaL+KCLJnjQnavxoBaN5NsGKLf4VTGhWn69vqeNW1atNtOdCQrzUdvPtUMUCt6rLRcRiF9mkj2IPaE7t73QL9egJlRtHMABMeE4rZdgJxEr4NRbndwczXvzhdJv5YASSihzzsE+HmH5sgU3eYaiu1WGNhuAB9cR3PRJtoDBao7JvBL7TPvxD3Ci7uFgQvqB/CiQTi8geHcTYTao7pjIWzpspVhuzZBc+EmugMV2g2HastjeluLYncpPriTAu2hCovza8wKgju8jlARhtqBPWOoge7QBOWOPI/J7S26Q4RipwcxSaaqqgAFoJgPCCWhnwrDyg7wLaNYBPjFAL8c4BddfBd4CBK4peOXggj3w8aAJiaJbCNDLQoGVBXAG+OYBxLZe2VpQqMbV/IhRRhk/NqrbIFHBhrVP5nKQjZTFuSo9XClslPGVgaOWbHixtNAo7435ncd3Te8rBFRocbeeZ/caRhQkI3klqXvRmReIVYCcefR+x+QADpB1shYF6tLW74OnC13t7K7u4vFYoH19XUMw4DFYnHKY9fX1zHR1NZ3tpwRUL3kkkvwzne+E094whPw5je/Ga94xSsAAJ/5zGdwz3ve80yq/LooUbDZgo7MXG7R/Br8EIv6sMF2sgZMNbMP5TvMPPoSSKZGM81TNgkGpInQfPSAyPaAJQiGW/GR4iJJoHAnTvDsJPUh1VXyhYIyjarhx8MAqidxcozRqK3ckyMH1/QSHdwPkb1l70FBI/RtZx5YqJEQIkMXQX2w3bv2TQhR25HKUnb6bQesz8SXcJ6zqjmLyuPv95RTg1Tm8bliidWKbeMwukaOGLMNxOhyq8DVjjsFiM1cEex4hrGKtmhkzIlJKJkZ3PxPbWx6L6DIxpYxSqYJGft6ACZ1BJlRMN82GUP2fNpOXDEs0jkMqR3mM2fX0+ALBgsLRw5YLKMbAZce4cg6UJfwR7dV11KyjBnTSmWpoKHTQLt+3F9VKayd9cOySYLsRHAguDu2JSFAqxqbgdPmMGTj3vrR+/QeAAIc+l6sKX0C4aiqxBQ5uTfMpvJ5sRQXhulEEoJs7wqoNx3jqgImFYaDM8mY5CjTGA2od8XthesCxXYDv72U48ytIBtj0bc8c61BKWk/i2UAVwHFbi+byUkNrktUJzqU2z24LhHO2ZC0thqsRgtlWC0Lnqaa5WmFMJElJ9QeDrW69QhQdQFRyml5ToHJLQsNqunRnXsQ2/eeYqgJk9sJ1YkW2JXsS91aBWJGsdOLH+5mDRoElFM7oF+rECoZv7J3I4TC/FEZ5U6PYt7DLQa4TpMCGFFAElAGp5tk/Y2aJgLEqL9r48GAWd+NLU1VFaXzuK6EWScXI/AzH5wIBFktR1H9JQ+qtcAsm1dMccW5lC3LgLOy9tFH1uYRogRq7T11Tl029F0pixgXwKTvdSnvDZmaTGB9L4fE8Fq/ZG4GNuaiD3u+jzZfWnNBiutWtoadLXfL8qIXvQivfvWr8apXvQof+9jH8OpXv/qUx77qVa/C85///NOq/4yA6o//+I/j277t27C2toZ73eteeOITnwgAeP3rX49/82/+zZlU+XVTWFNYjnLcR1/R0YGZLyji4shhkc7RHTxNJmnnGZD+bS+5W6lbX3oBnQNAqumnZnvu2pHPk/jIIjnfZ/6x4j9HIEv52nUp8MNcE7wHkJmzCJLrPAzA+kyFuvV4SilchVFNIFl0InUijGks1SUBEHPiZCLtXixksl0sQbVknSLvVVM18+09lS/qKb7e/5kCYxZUM0iNzl9hSb8oeZqxmKMT4gW/cMkZ7gwcG4MfzYz2PO2vgU8GsGgEmDknbFDfJ/80W3jUvMiLRdR9ZCIFVH10G4Fzynj3aeHqu3RvxioZ66ksVmRu2i76xMVo/2mNYt6BtxoxS5Z6XtulHlOzJk2n437JNk6wgKS4+A5A6EHbS9DWbtz4yKZon/5XBtXqHqVFBgF1LcFe2i7x263FH69JvpoAEmgZBvByieHwGppLDmL24aXIF22sob3HOvq1Alw4+A6oP7tA8fkTcNtzqS+mmZVr+RAEfOUbImXO4pxh1y28+srLJrKbFnDLAa4dIphw7QDqlwhTYRlp3ogElrl4mH5xXcn7rdrHfqeRvefmDP1GDVf1KNsO3Ae4RYdqt0H5uR7VOWsIGzWKnTZKKRXHdrHxaUlJWh/rIrNYzAcc+FQDv9uiPLaQTcZQwbWDaK0yMMwKdOulEHj6vrmeUW63ClA7WGYwdgSeFKAhgFSBgNQPOg9gY9ULjlHz1n+mG9rL3GsZ9cireovNzTYnauYlCkH0RasSPFdZKeej1jAp4IejpARA5jc+JEbXOU1fKkFYbGZzTSQQn3skPexdHLJNa5A1x0tQL5Ui+SeWEFPfkLmCKxJpRXu3jU22DXKcxggwNQAr+WbO3AaGQabenJ1G9q7eTcpZeapxue6663Dttdfi4osvRtM0X9D98+KLLz7t+s8IqP7bf/tv8ahHPQo33HADrrzySpS6E3rgAx+Ib/u2bzuTKr/uCpvvEgBj4HITf1y8owO/vKhEEG07rcPMgDHbU1ansCTGoHGaxIYAtIu46+YY7Zx287HkZJwGNQFQcKg/bm8Dw1SAISFj4CCTW1lkFYlZKWwWCNMCHg68UQNb82RyjgAKiS0dsohZsomszCKtlRFwPkaO23mWLYZ3dkF1DZqq+sLI3H+6JbufnBCNmNAAAY2/368e+iLt2AN48wvSynEZQI4gFHE4jYId8k0MQxjyXOfRUWLSob6/5ocXFxnRqR2ZLM0kbmPcxi9zkqIynz4LUlEpMe57hA1JH+rggN2Fgq8B7AjhnA04OPGLXGayVaAUzJV3i7F6NqaiJaGXgB6vSS8UoHMzjFNRWqR0RDhuD1iNWpP7Pj/dYHasvnuDgNZFliqyUH9q5+ReD24izErsXjzF8rwJyhON3IMGWxYnG4RZDWaH8tYTCLMK/vZtiRC3YtI+TZv636K183eUHFAgBdfUlcjJqcm+uum41BFY1ARCAHaXYuk/CRX8p/jsLOAyyp1NKrCmgKVFA9cP4LJAKCoxr1vfabAWdT3ctELYnErGMU2z6nYJ0xu24vMcNqYIsxLsCOWJBv7EQoK3iFBsNyLw3w+SlIEcyp0BoXYInlAsBhRbrQDnZSdBnZMSPCkRSid+vfMW1LSaDU0HVN9n7iLm5qHviSYayJnR6JtswC4CQR0/dQWuAS490AoZwIsmxRY4AtbWkqQgQywWEcAhxThYW2yjYGsBqW/4yJUgJBO9BVHZ+WZ9MVcWrz7t3kuchY0TdTkg75Il0O4NkLmCOQZIxrlJgWeSw8ssOSGkYLBSVTEIymLfzXxU76blL//yL/Hrv/7r+MQnPoHf/M3fxIMe9KDR7z/3cz+HP/mTPxl994AHPACvfe1rR9+9853vxH/7b/8Nt912G77xG78RL37xi3Heeeed8roXXXQRLrrootHnL2c5I6D6wz/8w7jqqqtw5ZVXRokqAHjmM5/5ZWvY11fRPNynfBETKIovb86K5jtO8+8JLLI5OqEau2gBUba4kvcgV0YfOTbH+hWwakE2o5zppnkJimko4wRn4u+dRIRLdp8EZhw50OCAoYezfOjGIlvdudtCNAUrLZKxGFSW0gdeRaEHVRwws78GcpBKqlBRqLarLez79Dvt/Wr0M40PGneZTdgZaIzHcwKvo2uvAky7CKX67COUzSRglBozL2baywC0yenQpJaFp23T4umdypaN3QEiKA4MRoheDOKHS0mo33QcoXUMCspAabEy/zxmoNSbHQJQy6LUbZZwvkTYmMI1PXi31WQAymg5B7cr4v5Rt7QsEQP9sPdJikSaXidXycieT9S19IWy9BrlbNHt9vppRDfie5D1Ncvzotys6XwK/DKf2GjlEDDCaxNgY11cgpoOPCnRn7eOxfkTDBWh2mFMb15iOLyO4tYtwBG6C9bQrzlUJ2RjsVz3mHlKsnEeiPJwxlQzMhYd8TmRKTTYRsP0LbtemDTTD2UW9m1LcttjNgW2d8VSMa2BwwdB6zPgxHa6T+dAbZ9SiSoz73dbYTuNYS4LUfRYE9Z7ODBB8JD3s+uTe4amqA0bU3Dl4ZYDUHAC+wTxH110YAJ4rUaYCIlCDPgmwDPg5x2KrQWo6YVBrQpw5SUjVemFMW46UGsBfzKXJn9eiiBOrGHqB8oM6jTtqPnCK8tKdTW2OKjmqhEMXHrJlKUANk4JrPaQCIgFGFIMPMqAdD4eCTErIZFoWtv7wHF+0HHNIYHnOK4VzPad3F9uSVEgK8wtEihWX2dmFnUO83u1OUTbxQrEyZRErCFEIEoBh/AUlQC4qHC3K3cz3PxjP/ZjeP/7348nP/nJ+J3f+Z0otJ+X66+/HgcPHsTP/MzPxO/W19dHx7ztbW/DU57yFLzkJS/B93zP9+AVr3gFHvOYx+BDH/oQZrPZvtc+ceIEdnZ27lQ7Dx06NMKNd6acEVC9+eab8QM/8AM4evQoHvSgB+Gqq66KwPXIkSNnUuXZ8gVLQhucLzSA7PIbEZ0m3dFHkXUgpVBVh/8opO904agqMXeWhUyAcTENkWVDzLOsE9oe0fvUJmmfmltzpsV8oEzZYBiEvctNz5afGkgskC2g+YSqkx1BfagMKDHLfbad+KJa3/iMtVM2wdU1wikjSb8ISsW42aNnRECKltevzLUj3o/VERKjlJ/inAY6yc2y9XlkRzkx5aPLrwBaBU/pe03R2XbgkqMpkmNq3ezm9BlI0oacDZLfohA3MzD04JC1xSTFrL1DBg6rTHrNJHqqUq4znWKoPbj2KE4sxOxOECaxbWWzZf1SlQibE/iTy8SoW/CGU78+cgmgEiXzPSDgsa7iRiYmDMgeKmV528XthvcfL2yLbCZZZm4UBzaBrR0R8reIcfPx3VgDHz6AsDEBDz36mUO/XqHoHVzPmN7SSHT5AAk2U4ab53O4fgl/WwM6uo3p5wJQlApIw5g9M0CPfBOobe4Hlf8Kafwsm8gMRikv3XTguIBUmtQyNvouWVkIMSAt6oPWlchMBQY5FrBDFOcBATQAF4WANgBhUoBAmNxwEm5nKdJmlUWAC+hzjSiBDBsTcOlAnhAmJaiX30NVoF8v5ZUJAAUW39NlD2p7uEUrmajKAjwpMcwqhFrkqahnSZdKFFVHeGgVrIcIisnmVWNWlb0W9wfdpNkYKyWoky09tc6v1CnT2A2pDueASsmF6CKA5MPPLM/U3gfLEBWtFMo+FoXo2+r7gAGIknGMGCchFjbOCAHEZ8Tm8lVnbgvMwMDp/SfA9IejXzapb7xaw9Kx8u4lvXBK76z8kLm5sb6XfXy/zpYvXH7yJ38SBw4cwCc/+Un8xE/8xCmPO3LkSMwctV958YtfjGc961n46Z/+aQDAt3zLt+CCCy7Aa1/7Wjzvec/b95yXvOQlX9AvNS9fMR/Vt7zlLWBmfPjDH8a73/1uvPvd7x4B1//3//7fna7rYx/7GN7//vejKAo86lGPwmWXXTb6/e1vfzs+9KEPjb47cuQInvOc54y+m8/n+JM/+RPceuutuOKKK3DllVfuudadOeartygru6ITKv6iWVrMnKEERG2AA7hJ6IazAK/op5oDAaloBIJySaS4sBOJOW53LixnVepkGxDzwxvzF5Amo8jyJX1I3s9PyRZcpOxI3EmAV2yl6qeKfyBFNpk8BMzuG53I2JPN6VT9DSgo0nZGIK+TsvW19+JnZiauIYACgTkzM+93LUegQnN+mw+b+QaPgEcGNsw/VnUURdPWZSyKyOJwZDHkmchCkwByQtTalqAMjsv8hq1O5xEBcRgiMEY+7jTYigFgCAgkKXDRE9r7HMHy3BJu8Ci3W1UBgIBDT6D1mYALrYuWLdxJ8UMW32llnMxFYTUz2zCozqOLfYBhiAEgHPOaI41zk18DNPCFMjZK+yhbQCOj7FxajI2hXJ+BN2Yiu6abAx8Argr0ax6L86boZoTp7T2KrR5+QXBtQKgclveYgu9RY3LzHNVn7sDkelECiZrBalkhC1bpOn0s8juN/NSz3RUNKfjHwLlaNiJAsDEWghpLdBOrvt8A5BlszwWors10EzqAp7UEYgYGF04eRS+WEPYO5KoYGU9L0U4dpiX8vJVXaH0qcl/OgesC/ayQoC0A/bRAmHiU2wKmwqwEdfIehlqffy/pT92yk4DN3aWwtN6BpxLc1W/U6Nc1G1Uf4DppK0/KlIPefJgJAsT1vuO4ZpbkJIuluJ+YT3dlIDXLPhbfIwF8FNORKji1Y2O/y1ijIah7ACNmIrOkC1a3BTBlm1jxUc2CdAukgC4NkNoDBBWwRmmxqpTNYtcl1zGbFAZ9F0jnOn3fOOiYMrk2q9PY6DiXp/EVN9gGVA003x1Bqk0Bd/U1TqMcOHDgTh333ve+F4973ONw+PBhXHnllfjBH/zB6L55/Phx/O3f/i1e/OIXx+M3Nzdx1VVX4e1vf/spgerP/MzP4AUveAEAYLlc4slPfjKuvvpqPOtZz8K5556LG2+8Ea9+9atx9OhRPPvZzz69G8OXkJmKiPCgBz0Ifd+j6zo0TYM//dM/xR133HGnzmdmPPWpT8WnPvUpfNM3fRPm8zm+//u/Hy95yUtGu4G3vOUteNe73oVv/dZvHV07LzfffDMe+9jHYm1tDQ996EPxH/7Df8DVV1+N3/md3zmtY74miwKnuDYBI1aImcHtyjmrGYysvzMCNb2pxrZlv2fH2K6fqhJYmwkTkS+CMX1rxuhRdiHbhUcTkbSf1WE/MrH6PdV1AmllqcFiOmYydkkUC+rEpu3Xcaw3Tdl9rviEpoABsv/Ffs3bi34YZ3wxcLDKkJtZzYB7GKIvI5mrR1VKRHijgvgjua2MGbEADQt8C9ZX2QZB2Y80JmygGBBDbGcKAFwZH8rQyAKsjE0+Zhiw4Lz4feEwnHcAYW0CVAX6qUd1ogMQUB5bSgrVRQOsTRFogFdtUDIfPHICXHUhGyU5MIUMi7A3fzkgLZAcMv/T7JmoHx6HoIyQFlPaMCuBBY5keD5qYVo0fyeC7cbm80R8TNtzJ2BP8MuAdsOhOeRQ7AZsXN+gOrqEIwd0A4aCsbzHOvqKMTkeQFWFcO5B0G0nxCQbH4M+15AzwCvjb8g+Z6zxWK0iyQiNQHhgwHkQNIocEBP8uQfFZL2zEH/SSQUUBfyiA7c9uCoRao9+vRS2shtQzAdRaygIxZZoldKyEbP4EOD6gOX5M/hljfq2eWQdh0mB9lAtjGonQL9Yioi9sM4K0AaGW3TwJ8ViQ626MWRBl7w+w3BoDcN6iX7iwYWCOhY1ANcEuK2FMOG60YdXwLY+EzCZJ3cIpsBCGgAlvsBUJSlBBiKDSMq6rkbCp4QYyc8VgILUTjYjmVoLqy+qBCIRQKpWURYy9+m8k3xQ0/hPqhTZJiaCY63be1Ah7lPc90DTjEEq5e3k5L4VhxnFKdQ6QcabqH2QAVbvAdbgryF759jqWAHSX2dla2tr9Lmua9T5Zuk0yvr6Op797GfjW77lW3DDDTfg537u5/AHf/AHeMc73gHnHG644QYAwIUXXjg678ILL8Tf/M3fnLLeI0eORGv6b/3Wb+Exj3kM/vt//+/x9wc96EG4+uqr8U3f9E346Ec/ikc96lGn1e4zAqqvfOUr8e53vxvvec97MJlM8NjHPhZPfvKT8Yu/+It4wAMecKfqYGY897nPxVOe8pT43Zvf/GZ813d9F572tKfhfve7X/z+iiuuwC/90i+dsq4XvehF2NjYwPvf/37UdY0Pf/jDeMhDHoLv/M7vxDXXXHOnj/maKDmWGi1YCXQksfcVoHSqucB2tyP7tP1z9bMWNcejqoQVDBnQyU0+DMAylRBirnhpD+0FzXmbbBYsveqpJs3OmH/dDg+JOSBy6nPWg2Yz8Pb2Ctj7QmXcWax9TJR3POIx8XeHZDqOff9FrsHjvmXiCPioKDBcci7oxA7o2Fb23Gl8bteP2e5YWX4v+TW1isgo09522jOx4WBMpHcAvPhI2tgjKOuDxKauTcHrU5D38M0At9XAr9WgZQd3dFuekUYVY2cObyZ/W8wDg7lPgIstytgCPTi5kOTgmilJ7vTZ72Y+hTKKlZiN0Xfqm8sg8uLDGgLQ6SJrKTRJmUaL8vcO6CGbIAUSAQOWRwr4BujWCMXROYpjHcqbA9bUZcWd2JH2lCXQdfBth/XPH0OUAKsrYHMddGgz+oeO3DEsOMv6xbnRxikFsIQIAuR5hugi1B+ewRc1Ql3AL3rQ1g54IYoZ0fd0fYawMUV/cIru0ARDfQjUA6EmlNsDquMObkFoD5VYnj9Bc0B9ZKlEuWMbJKA44LHW9Sg0OQP6AL/dYNIqyGx6SVeq2cAmgdGeM8FQO/g2SGDUsodfiisA9YOkadVIe1bmFwDYgNvaFP2RdfQbFULlVKZKh3PPKHZaFHfsgHYXsgmq6yixFTYmCFNNojBvpH2FF1m0EGJQobkrMCC+x7rpYX0vuesFd5FLfvv2Sg0WQxCSe0E/pMDXAvGZk6lj2MY8d/kwlY0c/JqFhRl5FsH03iewHNlUsFzbXAbippYUZHMkReF0TghI1olBLRyZRc7SpDKp24haYNKmSefpFVLg7lS+klH/l1xyyej7n/7pnx75mJ5O+c//+T+PQO6jH/1oPPCBD8Qf/dEf4ZprrkGnm7lVIDydTuNvX6x87GMf2xcHOudwv/vdDx/72Me+MkD1R37kR3DkyBG86EUvwnOf+1wcOnTotOtwzo1AKoBoiv/kJz85Aqqf//zn8au/+qs4cOAAHvnIR+K+971v/G0YBvz+7/8+fv7nfz527oMf/GA85jGPwe/93u/hmmuuuVPHfE2VCFpy8JEmw4R/VsDSF3rxbJK6MxOGgdSyAK1NQb4QYGgTJEgnNWO3tFHGsGbSU3HRXXELiMLToORrFU1GNNanRLZoT/QFnC+iH5lbX0fY3h4DQwCJIjVERmlCj/2QaShilaVK9bFqgu7r45gfa2ZsZMePmAoFR10P9/mjCOceAG/O4G47IaZNYMyEITMNhtV2ZQ+T9/k+/07dF+Jv1i+eRkksUlR9GHdbVWJx6QY8l3DsRC4JgFt0kmf+2FxkbrwXE3Y/AMtGAKBGPLNqtMoiloEvc20hyKJHLjKg4g9ZAGUljFAMABS1CxoUoEL96oAke5ZrPRpYBMYbNwOrgVO61r6XQMaiAFnATF2h26xAdyww+/QOitu3RNFA6+MwANqGUWBittmitgeObakpGekY+y9/R8wVhZAAgn1vVgXziTx8AMN6jf6cGcJajcYF1FsB6BbAbCqJPZoOtD4DVwXaCzfRHKnRHPLwLdBsEqZH5Rq7FxbYuo8DuynaIwA6DzCBBkZ9HFgeJvQzGSPljgN1a1hfCuM5bE7QzwpUJxox1RMhlB48KQGWTFLthkc/IfjOoZgPqG9ZigIEAHM14bpSU/9CLCcmrVZXCAfWEOoCXKiWKgEUGH4xoDq2RHFC1AksRS8XHmFWY9ioJdNVF1BsSfsoMHhAZMxNPopNoUXN7azWILJsVcySTcxRTLUqLGZI45cZqGSjzq3KCFqiDfPJtnFoWaF0Do0bFkZ0n4oMq23YgRQElY8LomTlskQAZoUhBaWrm9zx9KfzH4NcIVO8vkfRghRsDVDLkYHauLmyhDh3grD4Oig33ngjNjc34+czZVP3O/cBD3gALrroIvzd3/0drrnmGhw+fBgAcOzYsdFxR48exTnnnHOnrnHppZfiV37lV/ADP/ADo5ilf/zHf8Sf/umfnlHm0jMCqm9961vxrne9C29+85vxUz/1U7jiiitw1VVX4XGPexy+5Vu+5U77SqyW3//930dRFHjoQx86+v748eP40Ic+hM997nP4vu/7PvzMz/wMrrvuOgDyEHd3d3H/+99/dM7ll1+OD3zgA3f6mP1K0zRomiZ+XqXg7zaFVz/oJHVKEGrg40wutsKqrvxEk4mmfQ2qpRkAqPoAM2LK11wSK2OFoH6kY2AKWfjz74A4GSfmVCZucnlQCyTiv/CIuoPMEtxg2VlUfzX6q47MTBloXHUBIER2mr4Q47wP/k2/58dwAngQIXYGEuOXM5kKaNxNraTWzLIiRW1MB4QDa8D6DMVuB97eUb9GSnXEhuSNpHQrLPVRFiGeFCacCMBPJ6DdRWqn92Ae0E88hnVZwHk2QTEXHcZ+rUR5shEmbN6qz6Je2QBh04zZHiAGI4m/pIIvqDkeFM2GZNnZjGE15QcLropDRcGpUyqo72Vx7Ie4eEZ9VN00cNxA2HiwLlSzOJFYEaayIDT3WEO3WaA+GTC7uYG75ST89jICjlQfpyCwQu/RQA2gTKswbLxcZmOBxsesglZtWw5QsbEm300nCLMK/TlrCKUEIbEnCTwKAWGtRtis0ZxToVgEEItlpDtYoVt36KcC9EIFLI4Q+jVgeY8B2Bjgpz2GwYFudXBLwDWEbh2gASh3WYKcBsANAKoCzWaJYa0GFwQuPYYKGGqCb4Fye4DrA7o1h+Ch2esY1A4pCLBpU9rQTKyeCi+uH94DsynCVHRJXcfwixZu2cPttHDbc1CrUfc6ZnhSIUxKUQ7wDn7Rwy8UoM5qYVyZReJKn5889DZNrYVPmx/VX5Vn6ZO2LSBjN85HFahOahGySVxxuzHTfT4n2ubd5hADzKTspwXFhQzQ2u/62o8sECRtl01UPkcjjbdTrQWB5UGZNrdZMgipzebylQcxZu/2aHyfcoP/T1RWp8y76hoQH9EcqH45S9u2OHbsWIzCv/TSS3H48GF88IMfxBOe8IR43Ac+8IE9xOKpyvd+7/fida97He5973vjCU94Ao4cOYKbbroJ73jHO/Bd3/VdeNzjHnfa7TwjoPqUpzwlNvrkyZP4P//n/+Atb3lLZCb7PPvLnSx/93d/hx//8R/Hi1/8YlxwwQXx+x/8wR/Er/3ar8WX6U1vehOe+cxn4nGPexwe+chHRgmGgwcPjuo7ePBg/O3OHLNfeelLX4qf/dmfPe17+YqWfcHQnXyDTvdFMyZxv/MIoNkMdGAjZcwKnJmfdFK13XSMoF5ZWHM9TiACVQO+HNIMYWLgUV5Io1DNtJQmOTslJB+owkfwir4TRmIyERBgN5QQCU5l5xm7Atr9ZD+ubgb2ANqVSdh+56B54/XYPEYuYnqSRWl7rqyO+scFwKm/JE81EGLeyQLYaPrMnG0fsSMU/5IxKwQJSisLAaZE4FmJ7sAExWKAW7SyaJsZ0DGGIxsI65UETdUe5e4AagZgWsJtd5Kv3krTwtmCHMcCxecZGRfVN819as3cyTEYQ91NKpUsW7biK0puxCbZfEIGcHNmKY49RHcLS39JBi6BBBR0IeVWWECqRf4LO7uojnsUWw7u5C4wXyb9Sn3MxISxawZLW21DlQc1LpcKtocMeCIB1D0BMco8R6UPwrBWo7vPuerfy/CDQ3myBZcO4A7L8ybwjdxze6jA7oUT9DOCbwC/ZLAH+hmh3QT6GcAOMe89O4DJgf0ATwB2CtH5BOA6+a86yai2B1BgFDsd6tuXoE42PxRknHPpsDxSYHmYUJ9kdOsF1j43x/o/HMWwVmFYr1BstSIjZRJSRCr75ATEeid+3Cpjx5Maw4EZuFR3k6NzuHkj2rNtpvhQFtGfmOtC2Nad5GJB/SAqBRMV4p834nMaGLRYpnmtEv1YsAZaLfXZO/GdZ6EaY0Q+gSTwrCxVbUIBbF3JdsqSKYBU3SHbdMVxIOmq0yvN6iYz6D3q2IvjIXMVsLnZxpFtumygsoz3qA1r4Be0x+JD6l4S5+V8Dszdnyj7d8THK3OR6cd+HfuofrnKzs4OXvOa1+CHf/iHUZYluq7Dj/7ojyKEgG//9m8HIJbu5zznOfj1X/91fN/3fR/ucY974PWvfz0+9alP4Xu/93vv1HWm0yne+9734g1veAPe+c534pZbbsGll16Kt771rXjSk550Rm0/42CqY8eO4T3veQ/e/e53413vehc+/OEP4+DBg/iWb/mW067rH/7hH3D11Vfj6U9/+h7fi4c85CGjz09/+tPxghe8AO94xzvwyEc+Mup6rbKdJ0+ejLuEO3PMfuW6667DC1/4wvh5a2trj7/IP1nZF6B+hco+YJWqCrSxrkSdgTuKOpdyPKWF1yrJAqFykJTvsuMUOGRgxqXJfMxMGgOq/86ZJEbawTN0EgwxYp0KSV/JTQvs63NqF6M9fzmkiRr5qavPx8Dsnt9sE6DMjPOjADLWHPTie6smRJNzUUaZyhLDhYcBIrjjIpTud1q0mzWWDzoX08/ugG4/IdHWHCSK2KKBiVLdEP83qkqgKMFrtWTPUVkl4gC0A8rbtkHLFgQFkpWxTx7UM+qbtgQo1pXkDS8daDGouRMCPKeavrRpU38OQVw0uj715zDERYuY9DFLkCA5EiANTqZOXXTT0AjJlJh1uQEktmeTLZTRnSGyV5zA334+zXZc3wPzhZjwdxdwK/WaCZ6cG4FedmIuRQYGOH8XLMGC1WfvQO6XmjN7liQDENA2myKcv4FiPsANYlrliUe/Xkmk/cCoj3fo10v06yV2L/DoZ4ShJDAx2k0xl/czAawIAPUkrCgh+nr2pcdwvEB50oEJKOaEYsEodoFyHlDuBvhmQHn7XABzVUq60+MiwdUeqBCqEm4Aqi1GOR/gthtQO6DoFihuOSEXXJumZBMkmrRcetBSJPVI2UUuC4TNKcKkgGsHEfPflgQBcWOj6axZtUrBLGy/MaCWNKLtVf9Vn2GjZnYHMBWykdExCdZofXXriCZ6QMZ7K/JeUB/smJ3J/PT7PmlFO5d83J1KvHkFz7m7DSegGFl70wb2ThREjAklM2PohjdqU2ebrzhRyX/2TphMIrnVxYDShjEHvvn7YuM0ymKtvEfRFQDqCy7z3t0JrN4dM1P9wR/8AV72spdFK/C1116L9fV1PO95z8Ozn/1sTKdT3H777Tj//PNx4YUX4nOf+xzOPfdc/PEf//HInfI//sf/iOuvvx73vve9cdFFF+Hmm2/Gr//6r+Of/bN/dqfb4pzDs571LDzrWc86vZs4RTkjoPqN3/iN+Pu///sITL/3e78XV111FR7ykIfArUoIfZHyj//4j3j84x+PJz/5yXjNa16D1Yj+fRtdFBF03ute90Jd17j++utHx1x//fX4hm/4hjt9zH7lS4mu+4qUrzhI1a2vASpAJpG6Bh3YTNqftkNmO04ZSYKAR2ZER36Tu7E6M/+60e7aNEjt35wkqWIiAFukM9O8AJ2Q2hB389Y2XfBV0shSbY7AqjGjtjmw+4gln4RX/toHXj0AiCZlQK5diz5l1KE0nzRWGRtAFjtl7ySZAyHszgWILRr4G26Xy5WFmj0JftGjY8Yw9eD7HAHPavidDsXt2+CdXeSMtaudBA1ZP4YBOLkNcpZak6TubgBXXkzcvQBE9iRBMFtzYXDKAiZlxZMSXHq4E3PtBn0WW10yzw+DaEqugnkDmBaUAQhrn48VM5Pb9VwQvzzvNCe7LnbOwL9sBuLCH5UR1MUkqhgIcOe+T8c5SuM4f5bW4E6kipJ8mC3I2ZixxV5NvTiwIf01XwLLZQIlOcObDyFvrHMY/U7TichgDQNw61EZO1UFTCfo77EJggNPHLDbojsyQyg9it0epKBhqB3aDYeh9ujWHYolEAqISZ7k374Byl2gOQS4hlFtCUhdniPAtTjh4RugPg4USwUkjuBbFk1Yu426AC060KKJvscggDZKVCcHAbjLAL8YgLpEe1GNYeJRf24L7phkJgubU2BaCmuc+TNTsGQj6se+7OBVWH+YlqDKwy37FIFPlN43IPkjlz4GYtHWrpj1bQPpCzmfxF0Bk0qNAOp7qYkTcncesG5kmmaUyQtFnUBbCFHXl3L9UW9gFaN5LmYEBFL7c/k428jmfqfMUAdbAei9pW3VcRXnSB2/ZgnLcOXIsjAan5z+W3XXss1l3JSbyxKtnJt9l2XPO1tOXb75m78Zr3zlK/d8f8973hMA4L2PVuKPf/zjOOecc0bWayvT6RR/+Id/iJtuugm333477ne/+522QP+Xu5wRUH3Oc56DK6+88oyAaV4+/vGP43GPexz+5b/8l/iN3/iNPXUNw4BPfOITuPzyy+N3b3/723HTTTfhsY99rNxAUeDJT34yXv/61+O5z30unHP4zGc+g/e85z0xLdidOeZsuROFASokSQCrDyHNpqDZNC36BkKHFTbTJj9HAFwKEskXcAWvbGLxK36qCRzTeCJ0LoEtRtrNj5zwM+Brk3y+6w9BGQYWHVbnJKo6AtO8H7LvVn/br9Psvim/7qBBZ5I+000mwj5HNpjTAkfIApkUWFUlLOjCrc0Q5vOUWMBY4x4iF3RyibWPiOYiz2r0ILjdFlxXCAdmcEEYMwwBtG1+unJNdk5Mh43mN4f2cynsFMoCYepEnL3tU9+avyCJpJTbWaYANwv8sEhiY1B0rDAzaL4c+8uZKdzAiPmbGrNqEl7ZGDGNVTa2NXfFqKuUAMLSpy4lcUYcs4X56IXYp0wSvDdyOcgZTu+F/R6NlTHjaUFMVHoJUFqbgiyKP0ZXAzlAkf2WAXakMW9j3BGwvib3NZnALRtgNpNgorUZhsPrGNZrFCeX8CfmQOnhmgF+p4Xf7TBs1mgP1RgmDvN7eAWlhFAwXM9wnYDRyXGGX0gDizngWoLrgXaD4DqJoKdGXAXqkwHV1oDq9iXgCcOshN8VP+Xy6Bx0clcAoPOSGKDtwVWBYeJRzAOKpQQuceEwrFVYHi5BgVGXBbC5huHADP3mBMVOB9f2yVVEN5TUD6Lc0LagMBGBf+9AzKIS0Kg5XWXDJPOVuomUqlQQ9L3YXUgyBGPDly1Q6HylbiEYgj4reQep61XTNm2oOE8coAF75Is035kfqY1tC0Qy/VIF3hwULEfNYhtwNJ5DgBRIlbtXhWHkuiJuPn6vEL/NjazjTutcDRjlfE40y0JONtgc6Fx6R4Hkl63/humvEkCxz+y+70Yl20vfpdc4jXLeeed9wTSnVqqqwoMf/OAvetzFF1+Miy+++PQaoeX666/HL/7iL+KjH/3oHkv2ddddh6c//emnVd8ZAVUTdv1SymKxwOMf/3gMw4DLL78cr3jFK+JvT3rSk3DFFVeAmfGv//W/xmWXXYYHPehBuOGGG/C7v/u7eO5zn4snP/nJ8fiXv/zlePSjH42rr74a//yf/3O88Y1vxOMe9zg84xnPOK1jvqqK7dC/0uZ/Nee79bW0OwcQU6Ra1Go06WRg08Cgw17W1JzobbGBLMwCjLLF3iLZ4w5ffO845IyVziJRM9Ta7vb4U0UAacLXRSFi5kUBzJwwY/tNknHxOVVHZfcGgCbTBIYouTBwP8BNJQCNc2bCTM150EwESAosI/BSU31ZaoIHCJtalImdiWZBoLxlUH3FAf6kLrxASt2ogTtkqQ6pACo1ty/axNJoRiu306fFzFi+geKiZel6o+9pzAhG4lOYsS0S9WurgIJ681c19n00bgTEUq3JFNTEac+AbeyYbqUKW4/MsKRAwBZdvRfKWKTRc7cv9J7YO/DmFFyXKE42EpTHHFNmmnQa972A3EmN7rLzwVWB+rPHgDuOK9B2aTgREOV5VoDrHiBQlaBzDsH8eGm+AM8moM01AVgT8dktj0u2r1AQlpdsoj1QwTcBQw00hz2YJHgplEC5zRhqwC+lLUMFlDsB6zcs4Ldb8dWsSywvWEO7IWlmnXZhtc0oFgJoh9KhOzQBBUZ1xwLFrSfGAvTeifViPgc218HTGtWJDtQu4JadmMi7Hv0FB9FfVKHcDeBJhaES9wTqBrjtBaix7FH6PjhN7lCqqXtSSeKIfgB1IW6yeFLKBksBZ1ivEaYF/LyDu+2kvHYqEYVag0QtYFD9WQEISG378VjO9Y9t44nxeKSiSG4FyoISIC4IIQOtfZ/Np0GtGC4BQxunqiU7GitmubKNbJ7QxQAkm7VC31EDpZY+d3VDHvFwyOINsnFKSNaLOK/nc3ReEcZzqY397LO5JJ0td/9y66234hGPeASe9KQnoe97XHrppbjnPe+J3/3d38VFF120J6j9zpQz9lHd3d3F6173OvzDP/wDmBkPfOAD8exnP/tOU8TMHEHibbfdNvptodHXRVHgr//6r/HHf/zH+L//9//iIQ95CJ73vOfhYQ972Oj4+973vvjwhz+MN7zhDbj11lvxn/7Tf8LTnvY0+MzH784cc7cq+S553/fzn+ClLbwyqJOxKd5ApwU0eU47TpPFsgnTzGsrPku5zimYNNIUUMEg/doDnHwqzRTMOTu7ai61a9ukHkGTRpz6zBRMdqzI2VBVgtwMYWcXI/N+avhoMs2/HpXo/zmka3A6kdnuMgMfNnGPrAwC3LhXdrOuVbSexA+0+f+z9+dhu21nWSf6G2PM7u2+dvW7TXaSvdORGEJnQFADVAlEq/RSChv0qJQaUESrBDmlwnU4oHAUpPHIQaoOpxQoUZrSCCQVBDFAgCRA2h2y+2Z1X/92sxvj/PGMMed4v7V2s9Zea++VnTWua+/1fd8739mOOcY97ud+7qfygEuBKyGVClQrnqJlJQAs6NRivW5gREN2ufO1y5HPVWOl9GWW+Go1iVQk6rKMVR8yxUFtI4bG9olEIVkk+DqGc1b+HBN/zV3pXiIQGnR1noXtEsP8s49Ly4bEu84nNeoXra86FBYuTUNwAQgMvguLgKAVDVdmfRUr50HM+oijt5whOViSfOgp388TCcPPF7iyFI3uxpjl2RFaJ5BqkiNJ5hGNrOqjAMp7SHZgIO4TbjXcnyaotQnN5lDeNZNgdo5EwtBY8f/MpaSoTTLc2RHLTc1y20hWfampNsAsFOlMrjs78KVNG68pPaz9ekhkJHpWolpLUyQ0A8VyS9EWAmazI0c6dQIoEyU6VgeqsbgswU6G6Et7uLIS3ex4CDjcUvapliWQS2b/bNHph9siIVlYho9MMXsz0BqzyAX8X96TMH+QkGQpLvcJda3F5YmAyi6EbIVZrRuUk/KrNk9wmZG/t1LeVGVpv0DyIM8BZIk8l0ymT1U1HaDu+qrq+1tvYi/vr0oMTnsdcpTI5OJxITxnn6Xv2lYkB0bJYr+pBawGyUMYL8I7gI/a+LVWF3EKfci/H86Jm0M//tn+XQrjgpX9OmzXLxWa4MfbvW/x+Ouvra/WplbHsiDzWFkIynkpVP+eW+sVWMcB7kvcwvx2s4/xadh+8id/kre//e38+I//OF//9V/PAw88wNd//dfzzd/8zbzlLW9hMplc8z6vC6h++MMf5su+7Msoy5I3vvGNKKX41//6X/Pt3/7t/OIv/uLzopWHw+GzmviHprXmHe94B+94xzuedbuTJ0/yN//m33zB29wSzR379/mwpmG17W5C79YKPRKbIwnTRBNnGPyC7UncYgPyrgLVcTAW/dwBiogxNbKNc0RZqzKwKi8T6M4hTiqAfmLyWk68p6gyxk8KkUQglHUNv4ca3UrJWH00i+5tNJmw+qcrm9eeJgadZ8K+LUpf2cgzoaHyS8zWBXDpdH8dOgJ4XtPZ63StLxPrPEPYrnjJqiyTiS5mNUL4uEu+acAqPznXsh8jmcidUX6a4NZHwiAtSl8S0/hsa4u4oasoDBsvSiIwGpjhwO54k3uyrM9qz9Ie+Co/+Rrd/U1lmdy3uoG2kVB/nkUyAXq2p3V9ohPhNjs5pvNldQP7FR6oku+Lob/uw51+knL+B5cn5JeXZA/veL2gAiulg11ZyrVuTKhfew4yhb44JXt8X+5dXXvPzkzYew/Ge89TuoWVUqq3NwqAdjJmcd829UaGbh3FI/vi8emg3R5TbxaUJzKqNbGespkUHBDGGNK56zL6TQNtCsVui00VKZDMLKZ22ETTDAx6vSBRGmcU5YkCmyjqscIZGF1oGT5ZYyqHzQyt0qSHNenFKXpeUZ1bZ3H/OiNlMU/uwGIBeUpzZgPVjjBPXkbtlrC1RrM9RqVrUpFMK0wD+W6DmZXCnnqPU1VGZUSNkQXbeEC7PcJpja5kEaUaScii9f3VKJEZDFP5N9OC8xcNZlahFpU8ZA8CXSh/bPwCqaxRFcJgN5K85ULo/3gL0pEwVASGUfv+33i5gR8jlU+gcijpH1qh8Lr1Lkxu+uhCnFQXErdU6D+uJz0cEC2WV22g6MEs9EA1yFW6kP+xa4wiZ/3cINe4sv+uhK98R8XzQgdE3bHxKEgjQvTjFgOrt9tV28MPP8znf/7nA6J3Dc5K586d40u/9Ev51V/91ZXkrefTrguo/q2/9bf4si/7Mn7oh36oy6ifz+f8jb/xN/jGb/xG3vOe91zPbm+30MKgATwnSI1Xmqr733N/7/meSpZKNn8IC4dBd2Vw8UAgHDowWfFKOwzEYfAKjGxgU8N2Abha59kDP1MH3SV4lsBntoZ9oSJ2zkXnoXr2zSdAuWPgSRnTeSLKoO/6qjAo1HCI1hp7OO0B5PO6eQq0QQ2KHoymqQy8x/0R4wEaBKB2oF4JEx3AUl0LGxgKIwSfwiuy2n3N8USjTBJNRo5OVtBNFo5VyYY/rrXiaQo4oyAzqHkpjzeU5WzbfrINGcuK/vl3/SGwuI5uMeIQiUKYuGp/HXENcm+kLrrbvvqYC7ZCuK5mvKsbD8j9/QuJaUr1PpXgZSq2WxyotE+kUc6C8+HaJPFEUzRBO8SLVCsO37RJfmApHjmAusWtDbHrI/Sihou74rd5ZotmM2N6X87mbx6iWkV15wbZU0eys1DmMtyDIPGIdYX4BUcAzz7xxWUSOlYO8ssVpobm5DrlyVyy9weaeqI6vWmygOzQYkrpAoMLFdnukmp7iDOKaqLIDoSlr0eatjAsTySkRy2D83Ovb02ww5z80pLkSLE4MUIBw/MtwydmqP0ptkip7twgKZ2UN20t9SShGSYs71pnMF2iZyVumFOvZ+jKotfGqKalXSsoT+ToKiWdNajaYhY1uvQMYZriAus+kEWgslY015OCZi2jGSQkS4tyovlVVYsdZqIxbiVJyWWJAPpEYVONKYWFVkuJOrg08YBSY4eZsMKJRpeNlHYNFamg8yftKqT5/u+CNV/Hdvr3xVoInkwhCqVNVxlNWH76RbYOC3vfF8J7G/qjcz04XamAR/Rz//fVEs/07CgIi+nfn841IsgXukgPXobUH6ffh3+nlC9+4KKqcWEMcrafr8JiLDi2NN4CLi74cou1WzHr/1ZpdV2TZYIX7r77bn75l3+5++yJJ54gSa4ddl4XUH3f+97Ho48+2oFUEIb0n/yTf8I999xzPbu83Y63bn6KQyNxc1duG352Kz9c9/HVoBAmNTBvHSj1iSXQGVJ3NcA7kEM/wMQT7nE9k4vYqqCLcnQ2Q3GIvMv6DoASosGbCPDqnlkwqg/7a6899KHZOBGmKy/Zaan0yvHVYIBWCnt4tFIt6FlvIPjKSmFCipifbkAP1yDgqJcFOAF9MQPqrWy6ZJ3ARFaVZxptf9w8F0Y4dmIIC4uY8YyTlKzrE50cqNT02rDWgtOoRe1ZyOgBhv5mW/oFAP6+2/4Z2uD/2QKmA4ngPEClA9AdMFQa6kquWStUmvWAPABghy/5mPQ6wlZYVrxTASD3ronuXbj38XsSdIFKSUWmPJMKWVU/kTtr4WgGd5wkrXOS/X3A4cZDqo2E5T0bTD6yiz61zeL+NQ5eN6A4spiipF3LKbcybOpI5hY11eh56SUanvH3lazwCTQBlMqzM+C8PjhLKc+OWZ5IGVyoSOYNdjLADhK0NeT7DfmupRloFqczkoUj32/J9pa0hZQmTWYNugFdW6yF8SPebkwr8r2GZpxhU0UyazAXD8QTdHsDa+TdShYt659cohxke7Uk480W6OmcLEnE2F5r7NqQ4nLlq5I5lElhHLxpHdV6iimHwoCmBrO0tLm4DxiHAMy6xQ0y3Egy5J1W2FwWYDbRuFS2t6nCVLazhlLLRooDOIcufZWnIscWqRQ4WIqNm1k2YjdVtxJJ8ItHV0hJXWUtqrQCUL3mWDqE62UtTuGIJCohSqQVqEQWxbEPrlKdm0bXJ5vYF9qjuJXwetC6RuPycfP/eIw1/RgpQTcPEkPFMjwQ7To4Ir3qjqVWTE66Ihth7A377A6p+u2CQ0ZwMQF/rzp02r3vK1rYLqIQzX+3CdVPu/an/tSf4lu+5Vv4iq/4CpbLJb/927/Nj//4j1/zfq4LqBZFwf7+/hUZZnt7exRFcT27vN2eqT3jy3mVD2Lw80JWY0qhQ+nETnfEikjfgdilHF/tegZiJcsd6FjSMKh2GcyqA4qyTz+Qx8AqXFfQS4XwfVyRCn9+4edgN9VpUB2YpAezV1ulJ8ZnpEYDfkiksFbAapLgDo8kpPuszYEyXZWujsXV2rOCx+8PHlwHEK6u3MY/mxWngihhgzz3k56/fkXPWvoCApJJG4HwpumZ2eDXaKKM9jQR5qmReuXCIjmZwOIkqdhdIezbOxt0/Sc8TwsiQqRf+CRJb+WD62UK4Zqh94DUptcDQq/Jwx+zKwqhep3rcY2bjvetOkBI24oOd3sDV2To8zudr6tbLCUxbVjA2gjVOorLJcr6CkJZimnFQ9YOU+ZnBszuTmhHUDzoSI407VBj5hX5UYPem0q1oqrq5Q4BpC/LXrPoHM4pYViM8t1C05xcY/rqMTgBkmq2RE8tOjXojRFqWWF2Z7g8JZ2vYxNFMmtJDkpU7WhHyLGPlmRHc2EMi5R2e0yyJwlh1Yb43KaXZ6iZWG5JgpbG1S368pzRRaQP1d4/tpXEMO1Lm6pU/Hm10ahyjK4dqqzEeklr0v0Es2x7hh5Q1qFrh64teu6z+h2ic00NLtXYVPpWcrBENyJXUKlEK/S8QlUter705UeTftGZJjjn0NNSwvaN9TZUCS7RuOFQNKp1K7ZToZ/WbZe0FUt1lNKix20ivXS3KPXV8KzrPVHjd9onZnVAs229nMlFAE3em+Al2tta+cVeXffHpe8zstinfwe9TZgiIfYVDg4WHTcSxtwYPPpxt19cqhUuRCFgfMWxxftBdy4HYdyPtLIuRE7iEzjebFgIvJBJ7Qa3aKq5qcf4NGzf+Z3f2eX+nD17ll/7tV/jR3/0R2nblu/7vu/jzJkz17zP6wKq73jHO/hzf+7P8UM/9EO85S1vwTnHBz7wAf76X//rz6klvd1uUgur0BfaYpDqf1+Z1KNjiCYrYv065sz2TF1Yudf1KliIGFYJl6l+cAS/kvehom7g7K1YuokiDIAdoPajZ5j0XeR/qSIdFcIidGCwO77UXe+SHOIbbL0G8sQWHE5xs/lVpAAy8agslWSMLjEhAsArWuLjx/AjoJ9kVEjGCD/bugP93USjNGo0EHnB1YB4HA5MPFPkKyyp+PrDMwsFBUIW8iJsoyXE71ZPuX+e0QedjEILkx3kBgGX142A6kR3TDHgJ1WvF+6YJ90DcNsizhG6v6chvBrOPy7qED9Dd+zE40fi+6rKcxavPQVFQf7Ji6J7DfZVTQMbE5YPnKHeTBk8fkR9MqO4ZKlfdYKkVFjt0I1l53Mn4ITpXP9kiZk1qJ0DkqrBVB6YzwUMBtlCrNlzK9cg5+f8eSuUMK6DnOJyS3rpAHPQ0I5S1IU9dGNJ0L7gwBzV5mRP+n2MCmyeoMqa5OAItXskANg5SUJaFwCOVtgiI90rSc+XJLuL/jlN56TzhVR1CvZeXcKcZ/UVYucUdJhaFg3mYosqsv5RlDVm5wiTZxJqV6CblqR1AlZnpSSFhchNa9GtwdUabVupDDVdQlWjQwJmfD9DpIceNLosA+vEwguFzVNcnqJ8n3BGWO6u/zgk8apbSIX3su29o0EWujrSUYfxyMuJuncv7o8WOn/n1vY+qV18nW4M7UBgd/Pina0CR+dcnzQZgG+0KZbOM3UFXCoplrFSHKML+bt+URy9N53cAfrPuvE0+LnSHWdFenVsMdpdV9iPlx905MXtdsu38+fPMxwOu4j7G9/4Rv7ZP/tnL2if1wVUv/d7v5ev/dqv5XM+53M6vUHTNHzVV33VVQ1nP9ObvLfKjy+39tumhkVvU7QSdo5YNEc/4EAfpm89U7iiRer2vAom/WAlc4HqDtefSLR6D/ctDmE7eimAH9A6JrfTaHnA02kybf/dsKJ3FuV0Z/AedFgCUMyxQT6cp0KtjXHDAjed4RYlwZZLFT4JK5ZLBDYiZJ6HgTxoNYO8Q2nRqgU9r78PytfL7lrQjvn746wV5jBk0cehvzDg6xSVKrAxG0QPMML1g9hcNV46Ee4j0FdFOvaciP4Wrm3F0zX6gr+WrnKPHz9cXXfXsMIw+evtQHx4dvHnxNuG8wh90K5u4/u2q71dlOm1v0prXGqotwsGT87FHklr7GIhgOvsFu2ZLcpTOQpFfWJMeuEIfVijhhNsrlmcTJmfdQwuOgbn51Lb/vHLsKy6yl7ChonN1wqjFL8b/cNmJQmxdRIGt5Zkb8Fobw77R9jTG7SZIlmUot2tKv9VBUukvKf2deetg6kvylDkcp8WJWQpelaCtTRrBXrZkO7OUIuyK4fp2hZVhYWSX2A2tT/10NfCex6YvBZJ0vPWYWUtTL7Wcj4NYEvJnG8tyjl0kUv/CO9yMLXXGpYOVfkse+8727GMHZsn71Dw0sX0LL3yUQg3kEpWOCfA1PdPM1tKxSyjxS/V+QpTTduPMV4f3T0/Y7okqA7FBX10954QlZSO1kl+Qeic1x07tTpmhETVthLNpy/FivVyGf9drLyLKuhDrdzLKxxalOujU9DLk8J4FS2YVs5dRWVXw+IGZOHkF3p9xSrXlzWOtnXQPyei/YcxvMPgrk96jd+R2+2Wbz/4gz/Ifffdxzd8wzfcsH1eF1Dd3Nzk537u5/j4xz/ORz7yEZRSvO51r1sx5r/d+hZjtZuCU6OB4LpbmARWMuZjsOhWQ/bg7VJM9P3IDzBmWT3QcK33RY0G7y5zH3pWVYUd2j5c3k1CKxfdn39UH3tl0IsGyBWj6RjIIUBJKTGMd+H6PeMhfq4K53ylGw8klUlQoxEuywUYBDbl+KMIbGVg/kLiWXet/ocA8DvpAd11uyzBDXKphDNfQJy44FwvRSjy/t7HEgHoS68Ghrm7FU7KSZrUhyktnbY0BsnOeUmB6p5przmOnje2lx60fX/pwva27s49aE9XwGzHzLlez9v1y5D1HI7n/2YdnQa2u+9AsNHxrF4nBWmt1GJXWhLbshSSBDspGD26wOwvQCnscgmJoXzNSaq7Nhl/4oD1Ry7gRgP0sqY2NctzG+y9aUCx66jzio3fLSl2JGys96biPbs2lnM7OAKVSH8Jiz9HL78Iz8vRM+ZxXwqFBqoatXvQAR99YR/1uC/L6RA9ZZZJMlgmJWwxUtI0ADXyrH//slRYsVY8RvWlI5gtpYJScGZwYYFB1H/D2fXOCf0JW1nwhHC3fxc6q6WQeFc3vezCIefs6Ppqd6zWL7Kapq/cFcYHH9pXfsEnCx8Bww4EaAanAJ9IhUIYWedE7qIU1I38rpU37G+6Ag3OOzKoEH4P75/2uuLwjuCfZ9hniChB5wqhjH8HvYm/g87yDKKxbsX834GTe+TqKyUtyo8dzr+XKtw7e8z6ygPObtyNNesepCoPiF0Upicwm6q/3uNJWSsJsiFiFUe6Yg17eNe7fh0BVhWXpebY2H8LtGPTz007xqdhu/fee3nwwQdv6D6vC6iePXuWp59+mgceeOA2OH0eTcX/ema1J05uUG98ISBYK/Rw2AneVeYTVo5XF4FVtgzkoOGlDRNHYDDVVUaWLsSErOi1QlkZ8GTeU95KyPYgrhP2X2VQNAZlArureoAVEg4skvXuQ8Xd4KdW/ul3Gz72LEPHJIVBt7W4tu7vQ+uZx1D9KEwCTcuKh2ynQQwAM+oVAfR1E0LPfggu1jKB+trkPeMZbgTCtC2WuLKkK5UYmNfjOjCle71csK0Kxws6u8CqBNAaTxoh7O5BlncBjf4OXTIbnsFBCZjoTsL3q+DSEJ5fmKw6Rja6N90xbLQfogVJvE3bM7B1jRsVKDRu6ku4jofYe06jn7gEONTmuniSFinsHuAOpzilsKOcxWefY3H3hPXfuoy+sEt9YkQzgtzkVPecoBlqRk9JBaatT16GopAw885hv1iYzuXnqoYik37oWUK1Nhbd43TWT/KRc4bz7GSofSDRiz7pC+dgvpTQtdb+nTACvkfDnl3MU+wow+zOfNhe3lOVZysLS+V1yK5t5bwir1pZsIVQcd8lwt+dcz4Jrl+Arry3S6lo53yfxtmeFcUb9ZelLLxSb90W7kUjFmR91jzeqs2z4lWFq6NFctZbzKGUB69V5+QgHsSI56pSkjTXtF1Fsq5IBnQAmaaRc/fvS+hvK5jxODMe3sOgz/RyHhWP/w7vHa0EIHpge0VJ8RApiN6JbpuwiOiSpPz4F0L2UbQlVHLrn3u071gfG19PmGP8OKqCZdrKgpXV/YYWO4EoVscT6Bcc8Ty2wgLfSij1dnu29hf+wl/gC77gC/iRH/kRvuIrvoLNzc2Vz9M0vWb/+usCqlVVsbe3d8UJ3G7P1vo3MCIXZIq/EWxoLxpa+ec5v5oY1GAgST9hPyEhJQ6Vh7BWHCbyq/WedQuTK31YMFyo1qKZCsDXetBo/TGjEpUdWLFe73bc1iq0wBr4fSpFH4oL+wnfCRNHF46SY7rIScBFA62zDuXalX11EgX/knWsQWCGA3sbSh12AMrfLBUB/DBod/gqAm9d6N9PWkr5ydICrVhcta0kwhyTBNCCI4DEfrcr/cK1Mik6ulK4GINKU8/CRdm54dzC5Ojor83fKxUOZKN7H44Z9804SWT1Jei3ddExQui466z0k71Son0NFjkxcAqsjtcJulMblPedJH/wInYglanqOzdRH3+Sertg9rotJo/VpBdnqOlM9MfW0p7d5PBz1pneN2T7fTOSWrN4850oNO1aDo8eMXxiLsxjXUsZ3CQRRwDnfW0VKKWFAc1S3OZEtrdWNMy+SIIry+58u+QT7zerohCy8guIlXEjLAxN0jOVHrCSmA5YKQdmdyZA1GgpExqx76EKkvS11rs7hIWQZ/ZDv8RfV9A3hmcJPeseLZBc9/wjSUn8HejPPfSTmNELwDz+XtimS2LqO4oqss6/ONwjeV8i9hLX67FDV7UWqarmeneNMP7EY0/cnIsY/lCAxLOOQW4QxgdnJXkrMT744McHF/0XEQRdoQkP5Dr2M0KSQbYSvFW7kruufx9lzHJiU+foGNkuiuVc/2zCOxuNrf1D7O/xSqb/cZBK2FUYF/17HZ5b/J3o3q4U3QjgNd72Fmm37ameuf2Df/APePDBB/mrf/WvXvXz7//+7+frv/7rr2mf1wVUv+Zrvobv/u7v5ju+4zuuXPHdbldv8Urx2J/jwfqKLPprPcbqUviZAatSUmVqNJRBLmY/VL9NBwBiEBCqtQSfO4iyMpWwSYH16JiFeGDzA3bMzHW2UGHAjyeF6JoiYEiiOoDZ1YuOwlTye/R3Ha3mO0NsVgdi//uKwTvHFvTKJ4iEP0bfi+txd/8SDd4oydwO33NREhF46YDrP1N+Anc+OQLEzzQkDj1jC9ekrvjzal1u/8dWgJVaLCDLeoY9hBvD/uJ+HBYsx1n3lZvSX3aXYBI+t3j/SCX6ug7Y+y/EofFul9FxrBOj/7AA7Kzcen2cvesUzWaBrizVvdvM/6A4lajDGe3pdarTQwYXFpjHLuOO5lDktEXC9K1nqE57f9CnNNWJIS7PUIsSpSHbLdGzpZzTooLxQM5nLqx2d0+0xmUKtjZoFejLB7iqQhUFbKzJeun8ZfGqDQuzzv826bxbg/bPOYdyqltrhWxyKcWZdAk9LvWlOX11JbUoJbkq2F117Dk9KHAIY6hYXfCFx+hcFwXpHqvv125l3Og/c8fBTnim+irvawDkXrvtfElUyXaX96ADmx2wC7fMM8lpIgu5wKSGsSfICLyPcYgWuLru7mFnWReuPa6qFPpmCGHr+GJ77WZXgCS8NrEes7tW/y7Q9ruIXDOcH18Vurdt8vfO1RETCt1xV47h9ylFAsKLE72PyuvenaMrcxoW8DFRAKvuKnHYvusb0fPzrG3Mmq4sLuLIUnw/eiq6l3QEWyt/jSpN+/O/3W7p9k3f9E3PWpr+Ws3+4TqB6oMPPsgv/uIv8hM/8RM88MADnblraD/zMz9zPbt9ebfnAUBv6KKxA61XAatGoyeTPrPfRSC1A0nRxBJqUQf/PaO70JEKtjQdW9kPQi4a2GRMU/0pqSgcL9RCdCOIJu2wA706GHpmITAuXQZ7NGj2YTJ/PSvsY7g98eo+GkB9okc30IYJudOLrZ6vq48P4vTHd/7nboJTAkSck8ksAvVKmxV/13hC7xjbssTNl8/cYVYwYvSL6/4XXf+xr1oHyxJbVqhBjhqO6PtQDwxQiFG/tX6+9UBnZcIME6qLFiKsTMpXyBLCDxGQDiBIKdGbhjCzHEajuuuTLzhvGF7fvcXsTdsUu5bltqZ4eI/BB/dl20FBtV1QPHgJ8+QuWEt7csz8zadpJkNmd8PWb0xJ9kqmn3USVVaMPrlPeXYi4LNe0GyNMTtTdGJoU425fNhXA1MKJiNUlonRvLXoC7tSKnQ4EM3q7oGwlrUUS1Bpz4SqNPW6Wfmb8mH4OOytnIPM9KxdmuAS8UcVJlVq2zNfCrsbEpLw97Tz+PTvVuwzGzNxSipP9eHZaOEVkuL8jjtro1AFDuRZBes4xwr7uNLP48iJfx/DPQk+s6EcaRdJCf0lTVBFLix1lnUlUt2ylG0HuSTSBbDnq0l13zW6Y5SJmMiOATR6JYze9XUd6T1DXw6LK9tCo/pk0+Ba4t+HAJ5XwKZfjF3pSOK6fzswuMJ2hp9DWF5141gPsl1PNIR7HsbAeEHRLTqi59F9L5LdmH58VWnSj9FhDumu6dj+jzWV+kVW064Wf4nvi47G8luhBex/s4/xadhe+cpX8spXvvKG7vO6gOqrX/1qXv3qV9/QE7nd4Kb0zGi1GkL4emNdJsI4jLoywEQAKUwqcdjaa8pUKHEZZ9t2wCQAiQi4BKDS2VqJxlN5NqUrLbgS8/CTAQgUjSfJ7paFa4smhTDQx4bzXVIWqwNxmCC6cVF1+lPRYEUOB3Et7JAwFO5BCCdG97rLFD4OnuMBW+nuPFfLDnqtX9tKkkxVHZtM6QF6tyaJgGiPr69k6o8tHI5v45xoXrVDarKvJPuEycv/rhUQkrBY7Ufh2cfPawUgR9nj3akHMNqfTy8wCKHB/jq6/eBEq5smlA+cot4uyC+XJDtLNj56BPtT7B/elM3ThOGHL6CqGrc+ZvmKAeqtBctqQP7YjK1PLRg8fIjSmmLgKC6UKBKyi3Ps+pB6mJI/fCClNo1GP7UjAMho3PoYNynQpYXpHLWz1/nV6vFIijQcTrsEOOVD/GKfJJO2ShMpB5qKdyatlUS6uu51ml5jTOL9Pz2jinVQ1bJ9WdGFnrtFX+jv/g/eGL+rSX88SmZCRazo7zE7ePyZ2qgvB0AcvqOi73ZASfXPXytf6AJJgPJMv2Tv+3B6WEgaLYulNJGFH4A2khgVvDc9My391+thF2WX3BQSvbqEsatdf5xA5q9FMvSFsRY7LA9Cu8TFfoHbgepOp+nf9/BZ8Dv1i3PV2fKtSoqOR8xWE5lc9EwiycCxhcfK84uIhV7DHy2Sj9+HRNMX6vDn23lrB1BsRSfspLqf0gmuqVf3GY7d9QlNcDzpklkdPus/IlFut8/Ydl1A9Qd+4Adu9Hl8RrcXFO5/Ps1PBijQw6EAzLrp9VFhouySpFy0ilW99rDxIn+lJAHDHhvQwr+tT4yK9xmXB41LqEU62HCaq/uUfxxICPA46xsSflBRpqm/BE0HsPsa7HKv+9B+SM5x3T1y0DFjKh5UiSaDmG0I5VZtiyvrLlQWAK9KU88++Mk1Pk+tBZi3fv+ds4LzLEPTG83H4K97rv5vVycr/N+u9kH0s3qGPhjmR60FhAXtciglar2O1Eo2NGnaZ0mv7v4qB/V/iRM/8IDUXTkJu+54YXERTa7RxGmLFHvHNtmFOfnDe6jKV3dqatqz69RnxwCYRy5iDZRvuYtyy1Bta7aeOuLEBy6gDmcCZtZGoBSjRxdS+GC5RBVrmFlF8vC+sJVt24OSPMWe3UY1Ug2J3UM5N2PQoyF2fYgrcvTuEe5wGb13SvpIYJaKDJtJ6FrVjRRZqOo+TB2aEZDj8hSy6J0qK1RVyXNIPIiLgZiLFlOeAQzPofNFjpm6pu2O1Sd50blhxM8xPOeuD8RuDceBEghLbltZrLQNaEnkdFW9yh5rDZkkV5FlXUb9yhhjrbDJIeEuSeQwTSv30TlhZptGPvNJTc62nU9rd83herQ/13AuYRyrLc6AavoFVgcS4wWW14Z2Glut8dmjMhakSbQIpNOOdxraePz1jK47HnIPxz4u4XIheTRiWOnfn/g5dM8rilZdkcx0tbEkDIVt21mOdccOi/QwUB3X+IbFvbPd/e3G8PAziArsFgOqtzWqL267LqB6u30aNoWU1RyPZNzQGrDRgByH9FzPSKAEgNUCmNTIA90ue923MJAYLQxJCA11gNKsJAl0A2YHNuxqZCcOFQfgGtteeY2sgFthIFaIOsIYGhgDFTENkX2K8seKQ2QdG6JlkIzLkIZ7FbSBPuznqgq3LPvBPZyLUjLpGg9Yi1zAaweuPFCrK1zpK8x0IVPoM+5dtNPoCI7jU8fzbldYy1xtm7LC5bW3/7EQTxoqZoMcYL1kQvpPYHs7P0VLd8+7cH34+fjDi1vM/vhjiwwAz+pIghmTEfb0OnpeYicFSWNhXuKUo7r/NC5PGH5sR/ZZpBx+/lnqzZT0oGH7vRdILs+lRCgOt73O4jXbZLsVZt6IFVRqaNZzzFO7Yhbfmdy3OKOxd54AFObSgTxz7bPk10a0J9aotofo2pFNF6JRHRTiAJCnvT0SSMg+uALMl+IYEJh8rXtj+STp69GXtXh/am+xFpLirH+3wnse2Hgbvfsev4Q+oZTqa8x3nwcwGC1wg1b9ao/Ma6iDY0HHLoZ9h3ffRy46IFQLIHdNK7cjSToZRFcSuIv2+LEj6HEVOK2FiYXOf9Q5xNItVITrfF5hJeLiF2JSvjcqftHJGqJFVxhPqrpnZWOnlBUw6b/YFaTwnq4hQTW4UwRASfSOhf4fg9J4HIwTGIOlW/gOftwLyW3hKpyKPo800NAzuEpJ8l/QlXcAmEhH73rbvSDVClGWsPA0WnTKsSQmXgiBsNlxpbnuuvr7fLt9ZrfbQPUlbi/qO6jF/0/5QR2lZIIPg+5s7pmzaOAxkmnq6kYmyMCGBpBHxDiGgT22nvB4eCXju40GUz/QrlRc6VjdfjcrOsRYv9RalOk/E+CqusFfSFIfkooB34qFluonXa957Bk+P4h3q3/XX0c437LCLZb0+q2ohUmqtbi2FDnBcCDnqLUkA9WNhIE7kBuFaY8zizejvzzLPp212KMj9Hjc6Ws7ZjUuohD6S5pJiLhtu4pHnc4xCiu68IgjBtwdR90xW6SO2evEbM/Gmpzb0Yzk8RrGQ/TRArWoxH/21Abp7hK9exn3ujsAsKc2GD90ieTj+1Kd6Wgux0kS1MYExgOGj01RsyVuscRujjGLmvTBp3sfT2/g73AsXrONO7XG6CMX5dqzFIYDXNOIhdVaRrI7I7+0kKz/joV3njUNgEmhY1uo0O9M0gG7LhFGKW9Zprp3VukAgJSAA2+uH6ym5J71z7yT24T9Ge1Bnw8/B7N5JKFuNclKiY62itwBvIQhFASIoy3Kb6+SRMaTVPxkg+a8B0Wus5xSxngNqekLB4ThRSsP8OmAr2pakTuEyEaQSQRgGidStfF7j4xLzl3piRr2by0uSvAJfbEbpq5gIfGsc2B/I5AenD1WwusBxMXJYtE7EI+PcRSr03ICRFGw8DzCdv4966436gPBT7dPipN3XRndP5erWQqFRKtwTvFYECJZoR1fGMdjXIjOhHt9PEp3q7VoKrmpx7jdgNtA9SVvgs+ejU66cc0tlj47eCAH9hOasxZ3cCSM4HEkVHuwZxJhgbqwbxjl7JWDaDwpyEb9yt+Dl267iBHojuzcqi4sgOJ4IKyOTZghSzTY5ZhICuANtbuVfgeyw9/CL6pj94KLgDvOHEfSiDBZ2WDAf/W73n9fIRP0shQto6/EwxVxe3dldzi+yYvYXGuxi4XYL62Y8x8Hlsi9Cwbznv1jsYSm8fOoPKdgWePssecRt2Mgp5u8u7CxX1DMxBtVpQIOOZoLQ62E3dcX9mFZCug+twnA4kyBftCij5bCWob+mhhJKKp9NKGqZeEyGUBlhbUM59FY3DCnfOUWh59zgo2PzgS0rU1QzmGNwm5tkJSO9OE99O5UQFS06FGN6cF+WDQq1YGzwEZ3C8QuKkHf55yNNJZ1/44EwHsc7MRAJ5ZpBNATPvPVuzqQqeJ9IKA4JDSGBUkoNxvOW+mepc1zVO517aHiUmBd2/6dwsi5OOcdCmLQFd51HwFR3vkB/AK1aeR5BnAamFu/MFDQjQvdAso5YYohYhYjwOaicsWx3CSA15XFGv2418pzdgH8rsir4n5t+32F4hTdOxU9r+6/cB50wFIdf4GM6Rd+4XCEMdZ1oDx6k/tj6eA6YcB5trgOybORbr4b69XqHBAW9CsJb1Efg5V72/0hLBDC/YyA/Eo1vdvtM67dBqq3SOttXuBmgla3kAxgFTRnxuDmi76y0VW/5AeKo6lMBEUuk5ScuGwQwufHMno7rVmoyJKlq1qq6BgqgNUAHmPGTkcTXviKc1GFJTmP42AGayX0FM4zJFVcwd6qjlwlWLKEidvGWqtwKNedq0oMroqYg2e8iXJNrqyiv93EwfcGrn9cVYszUZ5duV9Ff38aD258iUc3nflqV36KDAwe+PtLH/o8xvT4I/dgwn8n7gNd0pXCs3sVrq6xJ9cxs1ocDKoKh6V64Az7XyZAdbmtZcEwnYnmUWtsbmiHKemhaEI5OBIrKWNIntqTBJwQGbAWtzlm9uYzmNKx9TtHpLsl9b3b6FZh9maUd22A0uRPHKB29iPzfCIbH9X3Mw/sndaSGBjY1gBCrTdqDwl1of/Ei79IdnFcO3kFqDjOeAZ2MiRDxUyk0issthSVkIhAt0g0/TXF16fCItPLdYKZvVzP6nvTsXuNv+7EdNfXAcxwTf2XPHNq5V3tsu/9wtRZAg3bfSsR4Oqs9dW32tWwfXjXO3ZV+fKmUXj/aixnuI/+de/HDB1JiDwYThI6sBY8Y4meUdw//LmowLqGV8AvpF380oR3JDbhD9cef/c4axnOK4yp8Tu3UhSkkQWIHwdj+UBY0HRV8Nzqea0A+m6c97fp+HUfv8e3UvNd66Yf43YDbgPVW6D5gTzqlTcTtHYlCFf+yMrK+5m/K9VzlLWo4bBnPVE9i+CQCaCpe92R1pDprsxh2M5FLKSKV9hXDG5SBpHWFwTwjIIK2jcdJuhoIvWnIqCiETbYV49yi9InJljiEFx31Nqfu5c6OBydH2t0jd215dmqOfoz38ErQdjzae46Q/43eqCrpSqPiqpwyXECc+N8ZrMHMT5caxcLn9TjE3u0YsUfVUdsaQBdoQXwFelYO2DaVdBR0rdK0TfarQltYdB7MwEARcLuf3Mv6jWackPOWZUteudQymwmCOCaWvSywCUpajr3Pqbefq2sOqsoN5vDsKB89UlcmlJ87AJqusSdXEcvW/ThAmUhOz8Vc/2DaW8efxxkKH/ux0Bi0H5IHxbXB6pjiXqwwlyG/rWiv3Z45t/KPmOwGt1jFTN9cQLT1UBLiMaEr6MiY/2o2AShPyB9wtW9oCZEUzq3jP64sZemSpPODs8tlhE7anpWtlu4RAAz3BuQPmftKri3VlwS6iZy0nAr3w1+q13hiLAgj5u/b1JBy2f+B+N9Fel0Q3WvsKAL+tQrwJjqF34BOPpETDmvtk+yCf9exa3gCulA2N53kyuAfsSmdn3M+khUuMdtCzaS8cT32QNQd5W+dUVb6YNhTIwAeTyuHNOm326fme02UL0VWsQixe+1vJ83kBZ71nOIJpdnaw7cfIFtWtRo5P3z6IFumMRKzzysjVazha/w/7zK9SkPgENmLx5gRzrSviKO6gFLxLasDNSeOVGBlcHvxwbNKdD5uPrzCSG+qupPK2TvR5ZTdjYX4HJNz+gatr1ekHoTmnNOSrQ2jb8Xhq72O9YnbfTaYQllawEelWglGQ7lO0kq4NA/O9EoezamA0XydxcARjyBGS3Mvk9mCWxlde8micvInt7zGd2W5t6zVK8ekO4q1n5HwZ+BrQ8esN8q2kmBagRUtCc3sCfWSPaXmEsHwtA2DW7uE6PWJnA0pdkeYV95lmZsGHxyB703lfKkOHTV4sYD3FOXJQHLT8TKBEbSg0JfHrS7Hutw1nt7hgVqYFBXwqoquid04N4pqUjkjoMejgNX/1l4l3Tv4ykWUPHir9+Ni9m57jn4xUZgyWKgF6prAcFuKYD1DjgH2UcAK1HoXIUkPaX8IhBv/K86HWxn7UQYH2xfVCJiNiWJyXqbJLm3Kkk7y7fOTzaAxHB83YP/bhEVN+0LLXgLMVX7mxVHi3RkNxUD/yAp8NnyK/KMlWOo/h5Z17Plx8PtIAt55/pF/wpzemwxH84hXFQMekN/jDFmHMVQURQj3JtwPvbYOBq/s1H0qgOpnS6X1aIx4XCxLvYWGQfh+JLo5h3jdpN2G6i+5O0qA2DUbvpiMp7Tnu9xHF5f2cJw2Cc7oOTvIQMeB4uF1DLPPagAP3E0Pbi1HUbpJwRnwSpU0JqihA2IGZPAOHSDYf9PmGhieUBnsbQyaOKTP8KkG+0kBt9RBRfnnNRljyvXHGdabkRzN/nZX09zAmhc20r4zzNp8gxqWRB4lsnNZr2BvP9usAYSM/tcQIi35umAjQerYSGyUiUsLDzWx+ipVIZynhWzZzZR+RB14QDXSllSe3Kd2RvWGL3qkOmTE6Zrcr42836bJzdhugQU7bk11MEU88Ql3HhIM05InzoC52hOb5DMK5R1VK89h2kN4w+eR82XAkYa8dy1GpInL4vk5dh965hEf5ES3fBMW2BEfSj8igxy6EK/K6CxA7CeqTtevCO0jn32n0U/d4s3R2Qr1R9bHQNFUh2rB01dmDkGtEpFuknXvR/duxqHzwNY7qQDenU86hLEdF9mVamOBXW+aIILhUciFrhjU630V7K0O+4KSI2SjrqM/GApFUlVlNZ9Vw3AObCN0bHlPVCgAuDWq8jDWgGccYLb1SyhGodz3q0gbBcDQwdB5tGpBFbkAsciQWE/wYkjuDnEi5A4mTYOwxsjMqeO1dc4fRz8sro/1/2vB6Q20vx2x/eTQPiSL3EtziKa2+0zu90Gqp8GbVUKADd0aXl82XYNgNU1Le7oSAbwokDlGe5o6j1L/UZlBXsHqNEQl2UywflBvUtMCJOhnyQkVIawIK3rJ1lHD1a7cJXzIDIkdfjv2Z7R6fSmaQJLPzEEQBz0srHVTgSawmCu/AThmha3LHHz+TXf6mtu8bO5FQGr80ltrJ7eM52qc04cEqxFe1bRlb6caJgcw+IjBjmhWYfNNM2JIem8D+U6o1jefwqGBYOPXRYTf+eYfd5pzJcOwLVszZbsFmvYUwIgF3eP4deVVJOqZdGUfXyGWlY452hOTmQSHVfYUcbyVRuMf+sJ7CinuLDE7E1Rcyk3GxhelefiwRpnxvt+2JUtBfmb90QNJTeDBjBO0ukjCKrr/51cJoCBrv/6JK/Yrii0DgjQAw+lehYxBrXxdwMwjZm5AOS0BuWiRCfVgSVZdHrw1zGrCpX0561CieTANELvbBCAtK+K1yUixWWDOwAV+kx0XYoe8FcWVNO7BxSZ3MfS24slpgem4Z47J5KAwECGayYspFQvdQBZfMUSBJ+0tXI+sTdpLKfwgH/V55bwsLt7F78OUnnKdR+rcB/9sUmSKBs//pC+b3XjH6ufEW0frifW63ugGTbrErTi74Z9q+g64uslzjVw0SsevesKOlstpXobvFulOW7+mHyrjfkvYbsNVG+J9vzQYT9/9NuvJiDdgNOgO8jz+46Tbd18gVss+suIvh60rXrkxEc0JF7JBQh4jQf5jjGQ03HYfsJT8b2SDbpM2W7yUv0EHiaCMFF0oeqwi34y6iaEcB8CEHCeIQmh2pglvMktECgvl+acg6rGBhN55/r7CriQcBJKZQYmTSnJsH/FOtCSPbjXZ1xrRVIpzP5UgJOf1JIqoXp0hJ7B5QdPMtzQrF1S8KcgPWpoT63jmpr0kUvQtmjPTimlMY9eRJ09BYMClackc0s7TLGZIrl0gJqXdGFprWE4QF86EIcDZ/t+FoBOl7Vve7AahUJdVfUZ4WESDCBupcvHIMC3UI0qgAlcl+y4UtrTM2Idu+eZUBeSxEIp1jiznQBG/M8hYdInRvk/emAZHBHC+R0DlSAspY2ebffe+Xev9f3CG/JjdO+TGnYZwHtVoyp/3Vnq9cR17zgRs7VZJiDV+35K8RDo/GnDSSe6ux7pS3TFOmi8v2u4377vdSxwzF7GoXCtIkkCojJSSGGUtl0pbOBv+Or4GLG02N4+qxsKg+UVrCaqOtdXjoqfQQcSjy1mugnGRsD02OATM+uhX0WkAPgSrsctvgj9I9ya0Lfo+1q33ji2IALiBMrb7TOv3Qaqt0S7NiSijq2Snx/MvZYD+H+vdafPtn1rsdM52jmZNI4PgnE4i2ggS1KUagETlXjE1+b2v3RMqqOvJOOzThVRotfx1T39gBwPrDEQCAxImuIWC+x0dmWo62Y1527sc72FWmASAbmnaYLOcx+aBdU5IyhJUlEaZguKTzaSSGcRdwajqO5Yo7x3jeSwZrg/RzUtTjnM0pK8YcH+Rsro3VBc0gwuHAKQ7jfUmwXpYzORqfh+oNIENxpgM027kZCfL9HzimJZMX3DGZbbhq1fvwSVD9mHxczRtM909uAo6DSdtauLm9DXuyQi13mmdqb2DlbCsiuAwa2+azEY8fdMDhOxZ9pP+oG17L7rJQppQpecGEkwgiRB4d8Rk8jxvV4yAO3AgHZJXWEHIVlRG0IFM5ULqykyEA+oi0yM+qsajKE5s4ZuQS+9REhrXKK7d1vFmf3h3vjM+RUA7F1GYj1rWNSqNOmBfAD6kSl/dw3WQVvRRYH8sWQ71VftcuF++PsW5Buepe2qd6lWFhIxmPWP9Upv1aipCOUG0BsViugW5THrHv7eAV/oigyEfuQXGT2brfr+Gf89luDAKjPbyUkUSh3rn8RDqvPbKPlqdx4BaJu+DHaeyX/Lsv/bLdJuV6Z6cdttoPqyaQJXV2pDv9D9rYwLVw4+19ysFS/XEJ7qdu1X4Z1HXwCCrgvBKaVQWdJNWrR+AsP27I6jD0t1INQPukEH2YVkXc+UdKDUf7crw+j6CQ2ws/nNBandqbuV31/uzTkHdY21FlXX3gMSQmgRralPDDHO0E5ykktH1KdHpPsV8/vXUcowuNSgDuddlrnSmvrNOdsP7FH/l5PYTOESB/sCGA9fnWJ+cY65cEBzZp12c0h+cQEoyrvXabZGtKaVvzUtNjWkhy3Fp3bQF0S36toWtbHWa7KjsLsLJvvOs0HW9p6xgEojQKSUOCmoq4CUq/W3WAMYsVkKrmTBlAIT2Qt1oMARfDu70Lf/uAuzxmHpsO+wTQeAlQdk0m+7kqp4I/zESAUurXCJQTmoNwqaUUIyrUiOavSyprpjHZsqiscPoGpYnClwecbgUkWyv0Q1tgNhqmpQZSXa5MAGN1EpW53KYjhNBFjHlZyg949u2l4j7Bnn7voI198vjjsw6p9lqHYnIDey2YocQjongPi5OUB5/WWsSTWBXZZz6JwYjofOo+jTSh8J1eFQqyxraJ0LQoJTbc/sxk15k//AGB/rfyr4s3bODFoWCH5sXXGP6CQZ9JX4jssQIlCt0hQ1GHQLDrc2ktwGY2CU39aqfga320D1ZdBkDIhpwBvQ4l35ee1GtFAuT6Vpz56Gz2INk9ZefiaDmeuyk6PBPpzoClPqB/p4sGyjySIAV+O7ftBdgbwNweA88Zq0kIxR1TcPpEaP7sYsMj4Nm6Pz1FRd2E+YOGUtpgZSjdOKxX1jGKRkl+YMP7aLbp2AoLrFFTnucEp59xrmD1p2H95EfzJHG0gOG9zJdQB0o0gvHIGCo8/aYPa6MafeV6Ibx+JcyuChXfKjEhpNeWaCmVUoNJoUCmF57NaY5p5t0kcuS1JVJz2RZyhYzwOSJJEqUjHQuCIkS1eSd8UL9Pj23T2L+31UFji06Oe+KphFrTC1fmHkk8FkURiqXcXH98BFs8q6ueg8nAdmwS+1tV2ZY4zubJbMEdjROs3JCUl1hGsszdBgB6mAf62oJ5p6XTM43wowrepeEtS0uOVSEjcD0Ne6lzXkGcTFSYzuy9IGD1xfwco1TV9m1Nq+al5YmCdJP2Z0Fld04WmICh50lnWuZ1Nb551RlF/cNB7IRpW4ghuAv81hkeCc67Wux1ne8GxDNCmcMypK7uyBYqdZBa/Zj9+9aNGDwql+IbPSrO0qyq0s+pPEl62Nxq7onASL9p91v3syQWmNMwa21uV+zxbCuistUpq6AZveWgv3GzgnPusxbjfgNlB9GbUo3HfD2w3cp3PCQOU5wRy6qzAUWgwyg14pCle6yhuyh/BUHKaKQ/chBBcm2uDxaUJt7jDw+3+07ooDuKbtGBTl6NnWG908UFDu2D34DG2u8Xq9NPXPvvHJKQp1OCe7uE9mfaKM1ujYqkxrVFVjjWL2WSdY7Gckj6esHZboRQko2nNynOH5GuUU5b3b2M9PyHZhdveAersl37W09485LDbY+HhFUjnKs2OSaUM7yalPT0if3gcF6YUpav+o13j6hQ6E+V/6meqSqqJywXFSTfj+aIQqS+zySFi1LuSpVi2j4taxWnFExZfsDKCmk8eA0z70vcJ80WlHnUNApS+DGu5tD14Uvj5ury0MwMM5Oqc3v0jsKt55rbGezsmXNc2ZDVyaYE9kpJVCHyxQ2mCHGZiE9U/OSZ/ah7qVhEujxVKqaWQMsBY1KHqgl/jKWMZAanAe4Mr4oXrWNfQx8FrVwJLa7l5Af+87WyxrcTQ924wCjQDgwMiGz7QBLBhHF6J3Dlyvee/6QBgHPUiUfxGw759hB4y77VU0PkbnE/S+QXt7vMvELHH4PdLDdhXN4mO4+Ltu1XM2lFKOI27K94eO6Xcd44r/CK16ra/RuDtOUN67TXZ5ibFOEl+zFOYNLJeiFX6xJFe32y3XbgPVl0FbjRaqiGG9YUfoB58bsFthCtzqiccTZ/g9+EL67GgVkgmMwZm4ag4ok/QlFDttqtfTASizyp46+qQRkEmolmII9uCwY4v0eCST6dHRyiR2Q1qHk28gE/5p18IEG/3FxtW7EJDxdCmLiDYOsUZFGkL5TsCuFeT3WfRkydFmwvws5BdT6o2UarsAoBlp7NqI5i7H4J4Fy0VK9daa5EOayQcPqP9wgjlcB+ewqaJa0xSPL1huGOzIYF95ApqW/LE90RturqEWFW7WJ/Io7/kbEnjw+klhGiOmLbSVUKtCgI54dbqywjW2B12OLgLRh4iP39sIbMQ6SCd/v8KcvZPFrNZ8l2TFPlNbWGLfb1cAiFvdT7juoM+1PjKSpqANyaEAWFdkuETTjjJUO0I5xeByCzrBTgboFhkDykoA37xGaY1dH2O31zBLHzExyjOewiiq4K2qACvXqkDAX0jotG2f0BQx152Pa9PIfdL+LY0SfPprjdjLAECNEkeBAC79sVSS9JrkeMwLSUPOdouZLrHQn9PxhbsLi5uQsBUqvMXPInpXVv49/rzCv8ef4VXlA47jVbZksdQnyvVsruoPGYCrVpCmqDTFlSVukNGuD9GVRTcWBgUu0aimhbJmpdjKrdRu8wovWrsNVF+G7Wrjywvb4RU/vLAD+KQJl2eEBA4VGJswwQX9UiMsqPIhv+7YDvl7YJy6SUhHVi+ejUuSDvAGoIsWz1dXlqum6gE3nTsJe0eS6OPsjbuhx3FZjM2dD7u9rAfAFdrleX0uerkW8SyLPurmQu8t6p9je9eEutak/7ZkfTQjP3LoRpPNa9Sdsv96mFCeKbCfX7FcJsxzw8alFqbQqIbkV3OGJxqatYzliQRdO5pRSn5Y09olen8uYEFBc+9J3GRIcukI3SVDOSkEsaz6jP+Q/Y1kjweP2U4/6hzu4DB6H1Sv/8tSYZacA5VICDmw/AG8OyvKUEeILncAtS9vqXqwEqpGxWAo6C9D5aR+NeWJU9cl2Lho/+H8VyIb4bz8+6biRJm2leIfynvQppp2PaMZj8kvl6RHDcuTOclkgN5fyAJymKGPWrkXaYo9u8Xy9IDiYinSjLrt9183faGRLrzugWwo4RoW3p2VUwCBatUmC88S61CVK7DcLkqU8mOO91/t7rMx/h4GBlbYzs49IQB9bx/Wsdrx62EdzgX5kutBJKvbrDCW3fWpZ/jOsQVS3DpZgbtiU4iuu9dTrTLSfoETpCwrxK4xUkY7SeS4eYY9dwKKjOziFD2vZDHTqN53O0uvvN7b7TOq3QaqL8MWQo43BfFcbby4jsO4pkEPCn+yfoWO9n6GbnXysBYwPdjsJlcnmf9hUggANdZ9ofra4tqABofDTefe8Lu9yskB53eurFX9QpujC/M/2zYv3/ZMF3eM1YN+snuu3XQ/W5EFjhLaP16Qf3TJ4IMXabeGLF99gnTqaApHeUb2WW6k7H5WjjvXoo4SmCXMAfXWmuRCTv6ElAp2GmwyYnE6ZXEyZe23LqOfkgpOzckxs9dsMr8jpdhXmO2UwfmS5cmEamIYPDqluLigPDEke2If1sfowznqYLrKWDmfER5Vc5JL8n/TFp1JokmnhzQG0j6ZpjNhzzJvd+QkQqC9B3BgV4OmG+jCxt19VF2E4hmBQQgxX42FC793LKFnNkNWvD9XnIO5f4/HI0BhpiVJnuBSTTtIqCcJ1ZpBVyl6UeMGKbr0BRKMQaUJ5mhJMhZvZuX1nu0wQzUtemlxxvRJPM7fj6qSBM3gsBAkCWk0Fa7ob/FjhJKxxuhIhuTHWO+b2kmJAsgPz6+7R6q/RyHsjXzu4mcStLKBKY8LYnhv2o65jKQdK9X6OpmJi14pt/Lon7G5Y78EnKv9tTWRZ7VWcg3R+ajE9MUXjBFLwtYKQPWLBxUiIHmKcZrkiT3wHsZi5WVx2hMWWoG6gWTB7fZp124D1Vu6rcwiz9meTZ9649wAuh36g9KzDteye89C9EkJfn9NS10tsDTRhOHAeqYiZImGjFXHajJC29AVBWhcfwu1BqdwixJXLp9bc1qX13Ax19GudngnrGqi0pt77JekRWx1+B2OTT5qZfPnq4jo+rVWLL74NIPSon9vBmWF1SPaYcryTqhf5bj7nJcUaCjXNXaekx1ozFyx3DQMnnAUFyqcgoMHJuimZfS4MJnzswPmf+AOkqMap+Dw/iH1JKHYaWlyR5sbtMtBK+p1WFtYlneOKU8NSPbmNKcnpE2DmUp/VXkm2c3L0rtYOAmJJokkC3kWVE1GOKdQbYuranklAuPXSHKOSlMBNKEcpw/RitTA16p3wWoq3PaQWIUHQfIeqiAy7fyH7eq72MkMjrF0sebSWhpXY2lRbQNOR1ZKTsjx1KBKD3qGOfagph2llNs51bihMdAWDtIKM6tR0wW0JRQ5rnBgS9TjF2hbS6sNLtHY1qGsQ+XeccHWqKbBLaViniToAYlCmQap+mRFAxmDwnD9ASCGm9YCjeoBq78P/T0HtMa4FKMTaFUPzpUHbgSdqdfMu9XqV0Qh/75IhP/+ygvC6kKH8Hhcx9Q6v8/+tZNn5kIBiChE3194bMgfHdE6lGsJGujO8SEcI7Ck4JOhgEGOveMken/e95XZov+5alDGl8gN5bH9wqA7n2WJK5JbahF/257qxW23gerLoPVz/XFgqyLS5ib1+u6QSt6s53sYn1jRh5lkMmzakseXH6VulyshJBl4r+an4vptIFr6+8/C5OkcVL6E6q3Ujt2vxGXcwStfpmCV52BFos+uNdLnu0D2uEP/1iHqcAnjEW5tyPgjl6k3M3bWTrAcDwCwGSS7UA4MbqZR+KS5JqVeS7GjlOUpxeRRxezeEbNzmiZXLLcHAjCBVhk2PlGz/sEdnIGDP3CK+QnF8IJl8/0HmI8/hZkMSeenUXkhl1RW2PlCQvpVtXKhziH2XPEtyDOqV58lWTToh89LvXqtYXOCGxZSZCCAjyZUfFN9UlFny0YHrJxt+6pe2vV6zJj50yKrcTFwC4uNwPza8DzDqsJ1+2hoeKL5JLXzC4PjFbVgNZnsUMOgwI4y2osKl2lsIvtMZxazaHq/07mC0mfytwEg9uxmx4K21pd69Q4EIRQNdD6n4Vwa+ohNd51uBcB39ygGld3DCiBenlyqcu4avI7EmT5apPAhb0dXFMLSj0+RT7Qco5UFCfTOA1cL+4fDe22unIbqTff993pSN7qGTn4Qh/977bd8tQfN3fMK46zXy8rCK5f9pyluNJBkqWWFnpXi0ztddM89lFruFk1FJv13WcqCwhhhVWvRGbsEbiebfua220D1JWkR+HrOl+/ZP49DOe7Y/q72tyvO40a9/Kr73+qJXW3T4UCydaNJKwxc1rXU7RKjDFpl/SnGS9iYbYvmyI4Z8gJ+F1iI1kr432lYqRl4azXrWmpKLPa5N/60aVdhgZ6zRQz7NRzGKUjGDtoh7M+hrMgeuoQyBuXGDJ+2ZNtyDsVly+TRmjZPwSqawqHniuUrGsr9gkYPsKnCGo01muVZi12zuJnBAM4p0l0otxTN0KBbxfDJBckTO+hFg5ouBOQdTNFHaxy8eYvs0JH5CkYu2PlEAKHTTodkJudQWUp5MqeZG4YPh2t14npxcgNX5KinLuPm4gGrEoMaDSW8vVz2QNOJPEAlCYqoNGXYX3g0ARCtAKP+uIG560LKIbkG8RtWRoCibVtqV2JMinY+GqKVd0aIZD06gcxg8xQ3yjC1JSsd1iqqzYymUGAspq3RjYO2xeZiGeW0Qi9blHa0gwTVOlRjUWUttqYuMuE34BIjJW8VYsflQZCci9fjam+nFFhOE8S+vl8qBzoAdRfdx36xbGmo7RLb+kWFloVAVyaXyJ0kPOcIHMpzCBGkY6A4/jf+TGvhCUKI3J9XZ6hvYwY1XI7uqj+5qu4SxmKbQIdeHW+V1xpH/tSutXLsuu702ApEJwzoSvpgYPY7yUW4d2UJsyg5Ns/kPi19El6SoLLsqizvS9bC+uxmH+N2A24D1RexHWM7u3ASzwLqnrunrr67q9s/txTgOXd/7S0+n2fYvzKmZzas61bKrml9FSLQSU5CCPccF/tf5ZhdckI86SIlFWupbIUy3LLNQe1gxTj8ZdGuYzF0vfORVizPjcinMxL/frlRikOjKotT1rN0MHpszvB8RT02tIVCl456XdE4hWoyVALFZcX8nGZxCvRck0w1ziqGT7UUuw26cuiyYXnPGvOzKaOnWtJLBeriRe/xiUzMl/bJ9tcpnpzC7qHoSJPEh6J1b00VgJHRsCiFPZ0vGXz8EvW9J3CnN1FP1LiqQh3N0ZcOUEXuWSeH2l7DbUyot0ckT+/DEzNJ2PKDhDZS195ZAQCuSyxkla3z5+TaWsBSsFbyJvfOhaz1PtlKFTlqfSLPoaqlslij0DojqZ28e3mOnRTog3kPmowGlWDzAqcMxttOtcOCJsswKejMkmiFRkzq27SgXktoM0U6Fz2nyzSqcZhZjSYB00qRgACQlerZSYeANKUhVTjvtyo6VyBFxqWmufqiOCzKTQwiA4AUHN5Syxe6evV+F4EVDob68UIghN+dz+oPzyT0kS7ZS/vn57/v3VBcYLTxC3QXLdhRvSTK4T1nxWQ/JDa5RhLQVHASCNrZjsVV/bWEiccYlHYCVoP2F9fppFWcCNW2nS+tcvJ75+4R+p3S0seCR67R1zx83G4vv3YbqL4YLQalsaA+0nO9ENR4JWt6Nbrx+Hdu9tvv2Yfjh1H0gFIpsXABnwHtosHYh8VcxBBcsSMX3TcrFjT+2pWSSUESqW79ke7WP8PraYEBv4ariyf95/0d+Ua7PaSapOSXF1KTHUV75za61KhZK4zmkeu+lF1esnVUS8nV1HDwugnNSDM7qxg9UWH2HbiE+ekUl1qyyxqzcBRPzxk+WaKXDfXmAJKUtYdrVGOpT43JLuxBWUt02TlYVBRPzlDzUpjOkAmepnLiJvMVrmoB0sMCdWEPygrqmmRvQcI+7IojAIWv0rN/hDNzAaoKmhNj5vdvk84syUUtgNizsyrLIM+FZfWgRxmNGg08aK5F3+p1rt24FEBJCCmnSRea1aMhbrFcGb/ajSHm0qEARO9wgE4F1OYpNk/QRnxxnbeSUtai51WnYbWjjHIjoRn4IIrS2Nx0w4PNNfVYYw00Q/l7NnXQQjNK0ZkhmVYC9EJiU9v2hv8xY2gM5KnIggTV4WrbjzuBOdMRQIuHVes8APR/jMfisOjwbKZrgxbV9QlwzknyUUga8omWHUDsztX3Wq16KYK31eqLOfSvRF/8Icw9cn6BQUUrlEnErzSchy8zq9LEA2rvkNCV9HUEZj6Mx13uQwfi/TG9lZhrdQ/K0wSGA/9OLEWWEYCos51rh/P9TqVJ76t8PePCTWy3NaovbrsNVF+spsKKlmigiweX62CeunYcpEYDmwLnXsi+r7Mp6HSrHDt808okHfRjISnEWlBeyN/pwPSxfbho//QsBEQaL8+efJqA1JdnW51gn1e7zslIARhD9YVbJEuLPvT65tRgkxG2MJi8lQSYcEpG4xKDLhtJ9BjkrH+oJjkYcfCmgp3NHLNQtAOHrmH0lKJZc7iRZXHXhPrECFNZskNIpjXZeQFnbuhBZJoIqPMTbfLYRQmxGt35iqqTW3L21kplrcMp1f2nabaGFLYlqRx1oWgnOWmp0PMC5iXcfYZqsyD/1CWYzruFnNmZQbNOuaZJmiVJWUpIeH1Mc8cWZl6hz7dooyW82lpJTNKgPIANDFgIBXe60PWxyAoaK6CvKCBJ5HrGQ1TV4BKD2ZlKyFchXqImpfMwRpHsL3xGu0RWXJqIIsc6UBqXavHQdGB8PqOyDpsZnNGYGejGke+1VGuGagNsKoCpWleoFoodYVJV5ZnjXEOW4OaldLGuzLLzY5FMgy4kHTm7WhlMq34RHDl2dZ2vS8wM+42+20ZAa4VQ6EGo68AzV74z8SLdbyu/ykLABelFNxZG+wjsaueUQsemS4idTsMrHsSuA9/CvIfyur0PcEh0ChG5FZAKPXBWqmdmg+zAF8RQXvrhvC7XLZf99fl99BIuhcrzvsTw7fYZ2W4D1ZeiqWM/PzPx+ZwtTqSKhe/95y8xUDsOJp2wpyoOK7XB6kT3LDN0LEA30HZNRRfu+t+DbgrPjLzASibGGIY++aauapaLm+QEEFibl1O71ut5QYyJfG/wS7u4eSUAxZuK62VDeW5AeUJRjzRtsDStLC41Mmk2DezMMa3FbGkGa4pFndKMockVqlE0Jeg7l+iPJgyetuiyRu0dki0TGBaizzuai9dp5YFaK64WTivRh6JQoxFumGMzjR0VJLsz1NFCnALuPoFqLOWahlduMnx8hj01ppkktLVlWDa4YUa7VrC4e4xRCcnDF2BnH5WmNJNMHAiGFrU2gUTAs92eMH39NqOPXEK94gRmZ4Y9t42uxQ9VNcJsukEG+1OUtdj1ETrP4fI+Lk9gaw11MMVVFW5rDTceoi7s4rbXqO47SX5hLtrF6VLCyaXFZSPa0RjtElyi0PMatehlB9BAqmknQ1TZ0I4S2lykCDZVKAvNSPqGTSVxStc+7G0UzQDaDLRP3EeDUxYzFRsrlxjaQUKyPaY5XGLKWnSq1ok+FcSCrGlpxxmmbHGVWmWU474chrEYnIUxqsuiRxI2XYtbVmKRFbSYsbwifj/COBhbTh3/LHynbSJG09FJAULCVLRYD0BR6jso8d5FdXZcqsg9iPTMtg+9h+tSiRFLrnC8xFfq80y1CuVoFb0cobUo5WA8hCTtE6OUknfDl7jtL9+JBjVUAVQIi9q28m8uFapUYLRvlfZijNkvtznhBbTbQPXFas/U6Y6FbFbbs6PXHoQeB6k3nkFVPgnkmgDg1UJlyEDk/GrZBZNsP+AG38OVJIArSkcevzbXaaucNyOnbFnNZL3W61X8wE9/D1/8x74QgHf95C/yd//st173/o6frhyE6yIeb/3mrqELhgno+mYhpQCtsZsj1NYG6onLoBrRQRupfuSGBYvTGaoVNg7A5gbVWvRCLIucZ9DaUUK9n7H1kYrFyZTD+xTDJy3L04r0Usbmo5ZkYUkvzqW8o6tZnBvj1jYY/fYUjubCpKaZz+qnZ9QGCfbkOs3GgGZssAYxqtcKN0iZ37cuBQTGhnSp2Htzik01poZs32LHBdN7C8r1hKSCaiNDpQozGtK88gyHD4wZPnLE4EOXRHqABDVskVCuWdRr1mmLhMnDA6qtnGo9RdeOwaUGtVkIEBwklCdzlidzBhcqBrsH2CLB5QozGlDfvUmzlqHmJcNqHXtyxOzOATbVDB857PxM3fqQps2pN3NalWFTRX5Zk9aNL41Zyus9yGgHGpWkLE4bbKrQjRKWtwXVgA0WrCOFzVJM7WgzhTMwuOxIZpZst/RaU4c5XPKmt76Wb/iHf4U3vfl+El/w48FPPMIP/ui/45d/5r+i5/T16a2TftG0vq68E5Y1mPd3rOaxsTo2vY/Z0I4dFfbZXS0BKnwnfGZdP+YRV+mL2VH/qdec9t6rPuHL9VIN1emMvQes6ROnUAqVZ6jM91GfiBVraUUfalDa4GzpQXRwjRCWVGkjdmoAWYbKEtGplt7NIksF3KJgOpPFXJ7LYqeqexAOXTItxoh7QJoIOB0KUdDpqG+3z8h2G6i+GK1bhUeDVKfnIZqjj4eHnmF3V2zjol3fpDB/nqEGBW4u2dTX3mKk6genUHfbs6HOJIC3ktF4ixLvL6mOxdyOh8kcokcNk0HILL5KG46HGKNXWNLheMh8Ou+2+Zvf/tc6kHpD2+pjexkumo+FAp+rvQCQKt/X2HHG3h+5i7UP7ZJWlWjvnBOG0DqcsujGkU5r8nWxf3IK9MV9VGtxWYoaKdz+AebijMqsUQ01yUxx4jcdw9/fZ/6KMcYmJHPx6Zy/ao361AS70DiTkE4T2rtOYma1VFM7mvYsWcj0z1Kq7QEKRXFhKSH0JMGd2UZXLcXFkmozwyWwOGko9izWKmZnFcutTELkStOMFE5XDOY1ZikWRi7RKGWY37NGethintyRSX7vgORTFzh9WMJwwNEDGxy+aoxKa+pX17QHKcoltJkmWVqqcUG55cjPl7AUv1ibJ9QbGUVt2XnbiGLQMvxPDU4rpq8YUm0oqrWCZN6QP7QA66i2BrRTgx1DmysGly1m1uAGuficGo1DoWcV2ayE1KCbDJvIvSo3EuqRIl1IOLgtwG63zBPQqcW1mgkTlIVqryTdr8jmNUmaYDdH/Mt/+11MJiP+1f/5n/i//9S/5C//oa/k//GX/wo/8D3/E1/10Ud57AO/L7p4rSFXqNmyB6oepJFL/6GuvX6Szjapr37n+/yVnbpnUYGQjBYWz+KRq7tENWej4iLK+5yG74V9hl0RBakUXbGHXiscvFcldK+GA3E7CAumNIU8wR3N+5KzztuVhd+Rfi4lfA2oBFc3AqBDaWAPxIUR1f7eAIul/Fc3oqceDmT+8DSkK2vp+1mKCwlVSnVVvBRyXAYDWTDElQNvkXZbo/ritttA9cVoIap5fDV9tfFtBWc+Iw37LAe7Ob3bLUsoq34AvZYW4xCHr1Uu4n1HE31mkVKBPhzVieivdkJhUEcya+MBPbgHPEP73//z/4cH3vwa/ssv/BqL2YK3/ME3sXNxl//uLV8DwNv/xB/mr/69v8hv/ZcPsHlik/te+4prv+aVc139scNmLvrDy2lQOt7Xr7pNeK7XD1KVEtZGra+x9sEd0k9dFK1dUUBZSilG5bBFgqmc1ISnz/B2VSV9eoaEOSdDzMKS6YbD+1PMkSadWgYPOSYPLXB5CtbRDgzzOzKau2oWNqW4BJAwfc0mo8dnpE/sddY8nVeotXA4I33oIm48oN0Y4VLR3bWJIttbYipIDxvSdUMzUDSFwhlFMgdnFItTGc0I8h3L2oNLksOK5u4TVGua4kJJcpgzP5uxPFNg7z5Hcv6IYu8Atz5GzUrU4Zx0OwM7ROUVw0XN4miNemAwDUzv0rSJ49SvHlE8tIvTiub0Bu3ZdepTBelRTbZoGacLklLTbg44fJ1CbVZkHxN7KIoc6gZzsCA9KilPDqjXHdkU3CCFqkUtS2wuVYps6jBzyeavJinVpkHXfpJWDmtgOF5y7o4dqjW4UE6orWFjcIbf+e4fBeB//an/yGe/6lXcddcZ/v1P/AL/5pf+C5PJCIBf++iHMIOGX/7EBwFIjOGVD9zNY7/7iDzLtRw7ykl3ZpJQFvS7aUKXkd/6hJ8sFcA3X/RJUhzr611IPurbAaQS5E7Iz1hovO9tzK524X7oykdDN/YqpXEh2rSSaOqEHc0yAb9tK/0v1opqLSH4uZVx0+/HOQu1T/byjgAO12msQ0IdPoKhiry/riwVd5Vl2YPKJPGLgEykI9kEtefEESJIAbQ4L0hpXUm66sz+rV8MTOeSgJiZ5x5TbreXbXtJgWrTNPzYj/0Yv/ALv8B0OuX1r38973znO7nnnntWtnvf+97HD/7gD3LhwgXe+MY38s3f/M2cPn36pmxzM9rGyTXSPKVaBCbSHfs3hJWuhYZ6sV/aqMzftX2t/8Eh2aZZ1n8eKupAz0CFAX5FmxoGe9+s7cNKbdsD1qbxtjLPfa5f9OVfwN/9s9/K3/4z39xd26te90q+83/9hxztH/E///l/wL/8D9937dd8lRakbMcwe/e3T/8heJUtf8Z2AwBq93WtUEWBOpiTPiVJRWpYoIoCNyyEEVouSQ9r2kIqF4keE3TtJEKwrKJwqSGdtaQ7lvETDWYOLhEfyHZSUK9nKOtI95aMf19RX0hJ12USzw8s6e4Cc+lAwpzVsUQ+72RhZhVuVtKOCmxmJGmoaqk2c5qhnGMz0JhKtJdNIv+61klxpwWUm5qdz54wfnhJvZ5y9IqEtU8mDB/cRS3GHLx2TDNSrJVTBoMC1sZw/jJutqD42Hn06+5ENxr1UEJa7cOygkFB8aTGacgvLWEwYHb/GkevEj/Z4aNLdKsZfErBZYuqLW69gFZhDhSTh0vSg7p7l03lUA1QgzIOO3DYRJMeLGknKYszA0zlKDcNxcWK4vEpyaxmfocGp9A1uBTcuGVy1yFbGwccNgOS2jKf56SL3mruv33b5/F1f+Zb+OTjT+OsxU4yfuMjH+PzXv9avvJtX8gHnvgkX/2GPwLAY48+xW+9+wNU2zmqzWkmCbq0BOP9dmtItZmTX1yij6QimVLewkqJe0AP/jxItG3kJhAlNwVdj7VXSOpjVsJ17iaRljWE770utCtJ6pzXhCqRT+UZGCOWZZlUNSNJcIullwiAm829dlT1fX04gNEAVdVdzgAZIlUIJvteV43Xwnag2DrcfInKEphMOps1ZWWOUIMCcgGydmOEKzL07lEPYgMLXNcS6h8NZb9em9pFGxdL+U7T4mx6awHVqxFNN+MYtxvwEruff+3Xfi0f+MAH+Oqv/mr+2l/7a3z84x/nrW99K0888US3za/8yq/wJV/yJdx11118wzd8Ax/+8Id529vexnQ6veHb3Kx2/2e/ksnWqE/2iRNHYl3QFb3/mSbzT88erAY5en0NJmPRk4LoUlNfhSkunbcyoIcd0OtVfRbxSsKDbSX8b1uezz36nd/4Pd71k7/YgdTJ+pjv/3ffzWgy4h/8j9/B+ScuvPCL9ufdPeaINb8a0f5p3Z71QuJ+/xwg9bk+Np41ylJwLW466/tB5evba406mMKyRM8rzKIRkBpeu6bFbk1gWEhFpLMnUFqTzGrWfntJM0w5vD/DmRS7PhH2LzOUm1Lis3h6weRTU9Y/sWRwsRXwYEGZDAZFVM0o6q+DAWo89H6jCpsZ2kzRFprDV2YcviJhdlrTDBWLk9AM5LvBWrcdQDOE5SnH8oRm+oohzShB14rZPTn1HRtkhy2kLW69IZ1KWUt1MIVBIRGMxZL0k+dxCmZ3DXA4TNVSbxckM8f4k1NU1WAnOdlBi2ksZrJksA+Le0agHOmFqehWjWb0qMI8kdKMU5ZnBn6t7VjeOWJ+LsPlCpVaTGupNvw1D1LKbc38bk0zhDYHtCI9qFj/RMnkkQrdOMywYrQ1Z2kTdusRs2XO7NKA9lLarW0B/o//7T/wscsXObg/Z3r/AFrH3/57/5SPPPwIf+ILv4hf/2f/knf+hT/JxfM7fNM7v4uj3QOqdUO9noIDc7CAxTJizDU2UzQnx8IIBh9S60PdmQdNiYEiEwY/FYAoyUjauwMIQ+hCyD92A3D0jKj30dXDQrSjCvrKVdZrnZ2wq3mOHkp1ND0oBJzmGXowQCXeBqxpfDJSg6tqbFn6JKym1/DnmVRJWywEMLbWF4kocVXti0P460PJteU5oDzr6XqP2PDdupbjG0N7ckL9ilPUm0NckBFoLcxt7LqgFBQ59tQG9swWanMdhgMB0j7BCoUvlvACF7e326dte0kZ1R/+4R9mNBp1v3/5l385o9GI97znPfzFv/gXAfjWb/1W/sSf+BN813d9FwBvf/vbOXv2LD/8wz/MN33TN93QbW5WUysANYr1hhX0M07wLwME41fHejCEtXFvWdK0vqSj6/8L23f/hvsUPosGqsTIAJn0+3u+TGpoTzz81MrvX/zHvpB7Xn03/+Hf/Dy//t7fZLI+RntgnKQJk/UxRwfXubB52Y6xz/N+H190vJBdKuWZH7uql/ZlP6kqqFtcWYLRNOMUO0hJL88xh2KF0xYJzSTHzAbo83sdu4OD9NKc5ecNacctLQ2qqmnXCpS1DB6dkT2+J6A3TTB2jD2VYUqLmTd96U5jkDrycr6qyKVMpBYgoeYL3HZBWxim5wzNSGEWDlODso7sEPJ9Yed0JRO9WdTUQ0110aBrizOSeGUzQ7UFtAPGT2ZMHrbMKs1gH9rtCW5jRDufYVxDfd9piod20E9eorr/Tuq3bKNrx/wVis3fnJPsJ7STgsVdI2hb1j+yZL5XUI8t+69JWX+wwo5yFndPqMe+4hIOpzXJQYlaVDQnR8zvHFA/rtAFmCND6xTurgq7ZzCLlmTpaE80uKnBZSnN5gDdgs00prTkey3mIixPDTm8u+WgGuAuZqRPQXHUMN7uS80+dv4izcTA0NEmoCcb/NS/+E7OnTrB9/zsv+X7//lP8Mc//2388+/4Jv6//8c/5k/96b/Lh6cXaQeQ7TaYWU27NWJ5ZkA6bVG1pborRx86kt25gEZjIEtxicaOcszuFJdn2HGBaix6kQg7WStoG9AJKs1QjU9qsp4FDVZNyklEQJuuYpirGpztx0VX11KRKU19NSdv5afA+cgAbbv6DgS7vxCqSRJUqEgWCk0MMlyRoQ7nsmg6nOHKUs4jz1Gq8axoBtrg6n1hbscjOJqh2lYWY9bCcikAtfU2X8ZIaduqpT3l37lLB2LB6t1dnBOnBRToPBMv7cbSTDJIJqi6FZa/0/XiE26f3/DxorTbjOqL2l5SRjUGqQDvf//7aduWN7zhDQDM53Pe97738Y53vGPlO29/+9t597vffUO3uektWIjEGaDQv4gv59Zhc+eNxXvxf1cuMtybNmzch6k6Ji6E13T4WRgJV1a4uurDbs+HtQNssHLxrakbDveP+EN/7G28+1M/x7s/9XPce7/IUP7wV34R7/7Uz3Hy7Ikbc09upUH3hbbnSnR4QdZTx3YVWKbGh1tDGBYlNca1Eh1hZ6JuBEQeLFB1i5nJpN6sZ5TbKS410Lbo/ZnIUIoMrTSTT8HwU5rxQ3PSvSWuXNLkkD59iLu0h93dw17aQT+5w/jje5jSYpX19cydL9XprzlNxK80FRbSrg0p79qk3ExYbBvqsUKXMNhxDC+2DC9b0iOLaiXM22YK1VpU4xhcrNn63UM2P3LE1m/vc+LX9zn1Szts/+ohw/Mt7UDTFIp8F9x4SHnPJtV6SnZQ057doF0vhEW1hrUP7WBpOXyFoZ1Y9GLJ4u4Jh6+d0GaO8kQmVl8KFqcydKVYnjS4cUG1ppmd1Rzdo5jdCWZekyxaKDLsIKU1TiqNakfqpOJTmymWJxJM2ZIctTTTBGtgcUrRDBXVWsr8TEJbGBYnDfNTGcsNjXFQLxLa3NGccdjEUJ3uOZZqpElmjuy8Ia0dX/r2z+LcKXlP/80v/wKcaPjJj/9XDmczRsMB7/jv/wi68Ux12+KKjHprQDvQlFuGdh2aTYs5KkW3mUj2ejvKsJmhniSSYLY1oNzOOm/cEDLv+nueogYDkafkmfxXFBJZGo3Qw6H41mopP0uRodcmkkmfZejJGDUadhEnZ0UzGiyohDGtcLVUK3ONrwylFHqQo7c20ZsbwmS2rbwnaUJ9doPy7JroiYPzinMCZjcmfVJUkXsvanyFMgOba2I95S2qUHKdTEYCcscj3Jktyrs3cMqhl7XowBdLuomubVFaqmK5qobpHLVzQHKw9PIcmR9COVbXtr1LwO32Gdle8mSq3/iN3+Dv/J2/w+HhIU8++SQ//dM/zVvf+lYAHn/8cay13HHHHSvfueOOO3jve997Q7e5WivLkrLsvTMPDw+v/0K76iHHX7Zre/lecl/U62oOO5tLWcVCwlWd4B4njEDQph7HM2FVHQP8oBUL2f0rdlnq2M/P/379/E+9h5//qfes/O1nP/QTvPoN9/Hun/6lG2dP9bJuV3mGNwqVH3u0wT/SNY1o6doW5kv522LZvWv60j729Drt5rD7W3KwxClFa0C3rWShj2TiVsuafK+mWi9Y3DNh/LsXyS9C0igJYYb+ay3M5qgnajIrWsbm7AbtMCV76gBlfd/Mc8kSnkl42a4PMGWLbowkSy0cg0uW/KAlmUnpT6fBJYrliZy2UDTDDGcy0pkl20sxS0syLbGpJn/qgOJxS3saFmeH1GspunHsv27E8GJLkyLM8uYAXTkYDSjv3oDFkvUPXKbaOkU51NRrW+SXlszPDtDWkE7B5QnZzoKjeya0OVSbisnDOdWaotx2tOMW1SqmdyfkFzVGZRy9akxSLVEt2MRhtcIV8sxMDTYxZPuWZpRQbzsYtJIsg6JZU0wHBpyiHkA2qikGS472RqhhA9OE8qShPNl3hqYwlCcM3FFRZoo4P/PE+pL9iy2uTTBadK1NotCNoxk6srlieTZFWzClo9pQtGPH+JOWZK+kPTmhHRjM0tIWCc44qjVNup9QbyTQ1pj9KSxKMa+3Du+DJln3aQKDXBZOeSqWWLVfqNcC4lRjxMh/MpIkMg84u8pTnSQK0XQOCxnWpjOJIuSZANQkFbC6WEJrqU8MSWqHOvAhdKNxo4JquyB/egrzBW6+kNdpYw3SFLsxEo/r/SNcqlFt05fUNYp2Y4DebSFLQCfoowUk3rawbqnPTGg2cpYnUiYf2ZH+fnYLszuF2RwQplgSqYSEcLO5MLhKQKqaLgScBokBHpTfQnPf7az/F7e95ED1/vvv57u+67u4fPky/+pf/Su+8Ru/kc/+7M/mzjvvpParuaIoVr4zGAyovEfhjdrmau07v/M7+bZv+7YXcHW+OVbD18Ev79pw1C31ol5Pc02Dm86kLrhSkHnBftPXgKaNxJwdSMVr/gIrjcgmMH12dX8UPm3oymNKkJdFu5YQ/7XsVvnXyPeHzmeysyFzMqmjulCoynMpw2gMbpCRPL4DqXyvyTT5E7WENAeFZCzXrYDVqsbMG7LDhtndGcmFATrLyR7bgz0pY6qyFDvzVaHqBh59UrxT7ztDeWaIUorMKQETyxLrlqgix22MfDUmcRTIDhrMtCKZeTN6oyVRySjq9Qxn5HzbXGETSOeK+bmcZgC4gtF5S54mJAdLzLxh9OAe9ekJi1MZgydLsiOH20xptwVAJLOGvc/ZINuzLO9eZ+2DNePHLKbWtCNFa3O2PjRn7wsKyrsq+H2LrhVoh80UOM3ibEo6s7iJY3x6znyvwGYZ9dYIlzeYxjCfgEtadAltoVE5sFQkl5ZUWwNJlkosuoGktTSF16knFrYa3KEhGbSs6wUHj05wA2j3M8gc6R1zNk/2yVTtEJxRVImCpeJXfu4DXP6afU5sb/CXvvBr+d4P/1v+yh/9IkaDgmVV8bP/+b+yPKHQwxo7VGilUUVLe4+jVYZsx5LtStGIdpxRbYFaJrS5PAubQLVdUG5osh1LvTkkcQgzOMjBGQldlzVOt1JdSWtY1hJR8gBU9Kc+mcn3ZVc3PhEPghOAMkbK39aSMW+3xW9XLxa4qhZpgDEwGoCzqAs7EmkqEuwgxeQZbjpHVTVqUZLvVpgGCdN7myjKGjcZsbhjjNlIyR/xC0HrYDKCusEWCUevGdAUOTYxrP9+gxknVGsiARlcbCnvGDI7Y5g8OCe5eCjFFboiLlLxLFSacl5LK8UExLfWJhoyhZo2sCyFpQa5p7fbZ2x7yYHqxsYGX/iF4lf5VV/1VbzmNa/he7/3e/me7/ketra2ANjZ2Vn5zs7OTvfZjdrmau1bvuVbVvSrh4eH3HXXXdd8jYAXz8cZNIEh9J89D6QSytb1O/x0bE7qjQMsFv4vCj3UoMyqNhVWigHgvPNAEO+3bXQbVLf/VbAa/13abDrjcP+IxWzxnGc7PXr+2153+3R9lEDHoHY2OTdnkRC7j9kzGyhl0BcPcHg2NdrIVaJv03kGowF2c0yrLcnOAZxbByDbWWCOSurNIeaV51AXD8SyalnRbI+xmaI4X+K0YX7/NuPHlhLiDV69Fb15utYd4+OahjZXTO8ZMig0+WMavXuEqmooctpxTj1OaAaabL8i3ZmjFxLWtOMCV9Y457DjnLYwtCk4DelcJEJtrjClk3nbtjBbyneaBtKEdiI+pcNHp+ijBSrLGV08hMQwrluqzYTqTMbibI6uFcv7tkAryi1NPS5YpBWjhxqMBfOxnOm5jGakUOs1+dzQWsPsFQo9VdjUMjssyOaQLhpcopm+ogDVMnm05Ogxixk56rOK6lwDNTSbGfVEMXqqZfQYzM+lNLmGMZKMttCo2pDoFp42zKcT2pOgG4U5UrgNS5K0pG3D4WyKQ2GnNU0BOMXkQkP9yT3+5Ff/T/ylb/iTfN7rX8t//H//E/YPp/z0e3+Vf/Fvf5aPP/oY7baF1lDe11LnlvWTM8am5cLuOnYIzshYXRcOe8rCzMC4gZnGJYpFoWhzh81TXCo+q8pLlez6CPaF2aduxPA/+IWGqlfd2BWNVculSFqCdj/xLiZJgj21jjpaSLWt9QHJxUOvg66wh0ciK2hb3KkN1NoIqgaV5ahpJcxckYu0xRhsnqDKBl2WooGdjHBHM5gv0Ishy1M55YmzFOcXJPsJ1f2nKC4ucaOc8q6WeqBJn1bsviGnHuXYDAaXGmwhMpLsUk3+9JGA4KX0baeUOBMEqU6aoLbXBaQfzSXyUFXUd26wfN1ZRr9fku4v0Zf3sfsHrGTP3Qrttkb1RW0vOVCNmzGGM2fOcPHiRQDOnTvH6dOn+e3f/m2+8iu/stvu/e9/P29729tu6DZXa3mek+f5DbiykDAUwttxeDSi1Z4HY/qsuVcvqF0J6F68JtmxUhs9sM2qqw0tJgCtsKpNI4P5ymle27n/+S/5uud9Zn/2i/7y8972mttzSDs/fVrEgt/sI2lJtuHwSJjN6BS6Fmx8rKW+cxOXKJIndmFZiacjoGdL0Jr0sKIdpqjlQpJhtiSJqMlTBpdr8t2K+ZmM6T0Za7MxpI7lHUO0M6iyIakUzTghf3omOtVxLs9VO/ZeP2AyShk+lGL259iNEbZIsIkiWTSk5w/Rlw4AB+MRerqE/SNJdEGRtxYOGtr1AVqLN6aaLsj2KtRc3AzUdOGN1TOqB+6gWS9IDpcwSGlOjMmfPpLkLgfm6V0GT1qSw20W53KyQ8vizIBmqBk/6jCloykyjl5pKJaWxUbC8lUOlzpGR5bJw46Ds4YmN6Rakr10pRg+ZBg+WaGsox4bFuc0ukppn0gg0yRzS2sdrVZUmxnKWqpJgiktyUwqT+kG6omA8uTQkF8G3YoVlx7UqIUmPYTqbEvTGD76VMXr/+KfQ19wDB6ryM9klBONTkTTePl3H+X/+Xd/ANWKftaOMg7vy8Eo3MRC4lBHGlsp3Iaj2c9o9wzFJUMyb7Fawzgl2y0pk4L2hGN8cs68zBjsWNrGoKeO9NKC5LDsjPOdVtjcG/mnCaS5lNg1Gi7t9dWinJMsfZBypuORjHVIlcF2nFPfcwJ9uGRxQsPmBvnlnGZkUM7Q2oK0KjCtlaz6wUDY+LKhPb2BOVyg0Kj9qfx9MqKd5NRrKe1QkT69FBZ2MMCNBqjZHHc4Y/CQgWSLy28ZYeY1+swmarmEukbv1Jx4l6Eaa9K55fLbNkjnGn3Rkixa6pFm7SMzludG1GfWySuLYoFbLEWOoIDJWDyOZ3MY5LjNMXZ9hE0VrKW0n79kXo8Yf6IVJ4ZSFp1q7BNxb7fPyPaSAdXFYsEP//AP8853vpPEi6bf9a538f73v593vvOd3XZ/6S/9JX7kR36Er/u6r+Ps2bP8zM/8DB/+8If5kR/5kRu+zYvSrpbBHv/8HMjFPU/29Vpaz1Y+4xY3/JjHmytLSYpSPtvTtVCVvmLLtZzG1cDSLYgGX3Y5dNcBUq9rbaRguvDh90zsdHCoLkIR3dg0AaVIP3kBdTjD4bDbEwDssEBdmtLmGlWK7tRlGWq6RA+H5JfFHSB7Yp9JsUa9nrP35gnl9hh11jL83YTscksJoqtLazg6ItsrMeUeelpSDwX8qWRAc24TmxmS/SXJTouaLcXofDSA2QKWpfi6Fjn2zAb1ZiGscGMwC009UZilo3h6jr4s8gM3X0hW96DAKUWyMyM5LNFOUZ4eikayanDjoUgIpjOx7dKG4SWH2VuQXZxjUwnxKusk8/p3rVg1vSahHSiGF2D4lGJwvqEhpZ4odAWVFWuseuCYn03Jjiwqc0wegr1TmjZXqFThUoWdG0ZPNChrqUcam0CbG+qRhO2bwqE3K7ickswsyWEpSVm5oUYzvNySXVhi1wqSSwZ72tIkmtRazP6SYeWAAfpCi54uoLGki1KkIUajMoOpHNUJh8sc1irsmYbRYEk1zZjujEhmoFPH8pRh7cyCg90xZt9hE4WZQbmbUTykqQYG3Sjyw1KsmNaHHStOYrC5odka4hhi8wHVHRskByXmspdvWXGMYJCJndrGhOW9W+SX5qidQ+wwZ//zt5m+ashgZ0ybabJ7ZqyvT3l6uUa51GRPrXPiP1spwds0OGdpz20zu7Og3EqYPDJAWwUnJjT5JiiNWTQkpUXvV6ja21Th5N1oLSox2GFGtZGx+bGSYrdFL1vSgwaXJdhBgt6bMnhijjIJJ95bw3hIkynSvRJdt3A4JbuwRnp5hjqYd1EGlSbY05vsfsE26V7D5Hcuo/YOUMsS1kfU5zY5fIsiKxPSXT8fZQlqPICqwm2viTTmFmnKua7c9808xu0m7SUDqnme8/TTT3P27Fnuuusu9vf3OTg44Du+4zv4mq/5mm67f/gP/yGf+MQneNWrXsU999zDI488wvd93/fxeZ/3eTd8mxe9HQetQYj3LDP31RnVF8aGOhsqnvhEJQ9alVYymGl9rNqTkuQTH46RKiUCNl9Y86UEmxqHwql09ZKeN0i9GrK9VrB9k8G5WsVUL8umQBHVJI8/Clm/dcPzrnamkKhELRO9a4J+DVyk+Va+6g0o0id2pe9miWT3L+U7dpzTrBfouXeLaC12c4y+fIjam6LKUjL39w8Zti31mXXUmZzqRIJ5SpNfakimlnZgyD5xEXXhADceoo4WJI9L0mVunbwbmxqFEueBI1/VqKoF1GyM0dZCVXdhX320RE9yyq2UapyTLB3NQNOeNCy2TzD+VE62K2FU5+2B1MY6prJweRc3GQIjYVwPpuJTOcxR1sKgwCwt+AiFPphhNwYs792k3NQoqxg9WbI4lzF9Bdi8ZfSEQ1nD4rTBVJA/1pBfLim3EqpJwvKkZOk3W3DqVTuc/9Q2bgG6ctgCGChGj1nynZb5Wa9F1VBtCJtqSgdrNepIM35wiVlamrWcasPAqMVgSc8vMfsLBh8sUUqR5gqHQlklgPxwxvATS7ENq8WpgDpEshz6YM7wSYOpMtrMoBPLxmsOWe4W2GlCO3TYVNEOHGbQskgNdetwGxbdWMoMhqMW+1qoU0PTaJb3ZSSlolkYiksW5xqGTyzRtaUZpxzcs0auB+jGkT1xSRYL4wEczrFnNlk8sE22t8AWKbufO2DtownjRQkasqlDlwp7Z4mrEtzAcuHRLVSZkN2/xM4y7Eg8XN3RFGUdel6Tzgusacguz6m3hxw9MMFMG9Z+7zIcLaBpMKMBbjISkOiQ+1fkPfNeKZphQj2qMMkAM6/FX7YwlPdtkR6tyaLo/CGoI4xyKLwspqrJZkt5r4PEwRMhel6x9smSejNn/qZzZJdnJDsL6pNDDt6oWE40k19pKeqSvTdO0GXO1rvlXVL7s84N4Hb7zGsvGVDVWvNd3/Vd/KN/9I/4xCc+wWg04p577iEN5u++FUXBv//3/57HHnuMCxcu8JrXvIb19fWbss3Na1671wFRjzZjvWkHVnlO9CJa1eMITq1oWK+oPHpVEKx6A/1uG9f5USqjvQ2QAAPV+m2TRPa/9AA3TWWbWst5hZOIMeIz3pfj53Qj2nGAej3fP/7zzYGUN0/KcWs2pQBtJMsXfLjzeTYPSBUqSqJa/RwQX8bRUEzDHbL48tpPte99cBtLM9AMnpihD8Sayi1r3NYEfX5XXsnE4dIUdTgnW1bo6Zh64wTTOw2XP8swetKy/nt7opUtK3lnMosNSSLGwNoQBjlqf4rbO5DTyaREp9OK+uSQVCuRIhzOROto1jygTlHecc0mUI8Vi5MJ9WSNU798WczevYm/m8+9R7EwZNmTCXZjjF0boWdL9I4PT6cJalHhUrHJUllCdWZIuSXlNHVjmb5iwOKkRi8h2XdkF6bM7x2z2E5ohmAq2Fg4hg8fMqpaqrNjZncPqMeWo/cO4Zxi+NiCxUGDrkqWEw+CGidlVlMlJv8WikNoM0hMi7ksVmL4EK8twG03ZE+Dnokdma7lhqg60iV7b1IVrJuUhNNJEmwmnrMYjc00LqnJ9g3NxLD7yDqu0nBXTbqTklx2tIUlMTW1KjADKNYrxuOSg/mQ4dyyfzhkfPeU+X4OFxLKLUM6btHDhoUyaDukbUvqiePwDQPSZMTJdz1JfWbM/NVj8kemFB8rKc8NuPjFQ5QZkEwVnKypHnUcvHWLdlhQTRSTh+cMdhwHDyTohzOyA4uyFYvDjMEFkTRIf5Hnrg9mDMuaYSUG/spCtqPQB3M4nHtfYSOWY4dzGA1wqcEmci/NhQPUdIFelOx+zpD0aMTaQw20GWu/u0N2cZ+s8hrtQSE2VTv7wngq1ZdoVQp3YoPq7glqWZPulKiL+3A4Jf3EEn33KXY/7wS7n5Vz8rcWHNyXUicp279eYZ1l/MkdzN6Q5HCJmpVQ5OJ08EzltF+Kdluj+qK2l1yjWhQFb3rTm55zu7vvvpu77777RdnmprQ4t+d4ApU7jk6fDa3KZ33952dSEUQgtPNstVceJjSte39SiGxRkMzo4UAE+SFrdb6QCaXIJWMzrMrrphe+J4mEuMpK9veM1lzPcr3XTWy+wEFNKZRJvJ7seTJ+13wMujXKrQ5Wr+scHTjlpMJN2yKVdTLxfZzPfcWfaz0Pr11W6hlBrgDGrK9hvljKc2ytZPcD1ZkR6uCwN+FHoXYOcCc2sFsT9OECO8zFI/LgCIqU6tw6xeWGbKdh/7U52aUF5pGLUNadxtAFlsqXZG3WCpozI4rZvAtDu7qWsN7aSOyorMOuj9Hau1ikEj7uSokahakcwwvy/ppFlIADqOFAZAC6wW2tszwzkuMMEpJ8nfSCRl3ek/cvT7s69nomtdmLh3YoPgWqbmA44Oh1G+jZknynRrVKrLamc5LtXLK67yk4vH+IS1OsrRk9UbK5V8n1LUvyh2a0hwfsTZckhw2jJBPmU2vyA0uJxiUw3GvQDUzvTqhmBQMLZqIxs5pk3mDmGvOUpvhEhVl6jXqS0I6lApNZio4R6I3uxVmf6tyYZr1AKQNNSzK3JEct2cVKNLGzBHeQM7tD0x5ljB8ryZ9c4IqEajNF5TB4TDS8l7MhxfmahR6RDVpKNyC7rDEHNelBhb3b4E43uP0U96aKunIU9YJ23ZJYOPqcDdp7EuplxpnHK1RRYGrF9q/uYRYarTMWr8i9dVdDuakYPtmw9vE5qrVs75XgnNhNXTpi+KhINcylAylukedy7+dLWJagNfb0Jou7xqiqZbh7RCeIb1spr6q9hbpzuCzFZQbtNlDTJdlOyfYHRd5Rr2UkC0t9Zo3skQpXaJGq7B/2tnD0IFVPxti1Ie7kOs0Eqvs2WfvoAeZgLm4G1pEsWiYPHjB41JE+XTE2Q6ZJSnGhFF/jZUX2sb1+0FmWuP1DrwO+3T4T20sOVD9j2hXJHvGH1xADVnTANuhVYwChYmb2GEPaVRDp2FV6wOwctM6HY73PXQCejQemddMb7ZsENRIjbBID04Wwr3jGCGAyEu/A/SlusUB1VVOON3fVH1ev+Xnen2dsYXJ/PjtSoh1s2mtj/K6z3eIYdbUvXcvXgim4nxTVYCA/l9W1g1TlAWieo7JUtKl1IyH/Y821rQDBYB2llOhZq8p794KpLGbRohupo65ai6tkWzca4uYlzcaAZCaVqYI8ZvDkHP30LunlDexkAFtr2NMbKJOgL+zCskavT7DTGa5t0IcL2B5Jmde2gRbU6RPyHg1y9KIWOcDIr1gGOe0woy3EDL/N5OKVdSRLR3ok75jdlPKe+mAmYG1zjXZjyPSVI2yRkh1YzKzEHLWosvI2Pw51MMUZLcNRWQvQaW0P/IdLBk8VtE1J/vuXuuee7DWk5zNGT68xuLyOM4qje1PqYUqzWVBcqskvLtB7FfmyohwFI/uM9MhLK7IEXVmKyyXUDWZeUW+PMCWYJWLVNW/QZYszmmyvRV+ymIWVyk1pIuNSA812xvKcIT3ISY4a1MEMNypwCWLUn6SU2yk2R5LXZspXDxNrrXIdbC5gjI0WN5AEKDWv4OQQqwW4u6FGOUimLeZghtMRg2shPW9pDie4ByGfWOp7E06O97i4pxidmvHGsxe4/MYR5z9+gpPvX5I9PYO6If/YRfKPIdZQW+sUl6Samt0YYocKlyYs7lkjvTwne+oAnJNiFaUkrTnvKECaSnncupbXs2kgSXCpQbWKdOYXaJFMJiSlqrKG3TlJkclYDbRbI5rNgrXfX6JmS6x20le9B+vyzjXRWT+5i1qUssO5sKxqPO6KW6iyYfJ7B9R3iC9w5yHetrhLuwz2E7BS0MLdUZAsLC5NMMuW9tQ6pqxgUcp7pxCLrFtIo3q7vbjtNlB9UZsHSqHE3fUgsCtC/qv77hhWPygAMiD48qJSgS8Kzcdsq7cQkeQDXzWk9kkCdd2ZqXdfDiDXT2ZdolewYNnzGfvOCbP1fIHOKmG00l775tfwurc8AMDv/eZHefD3fv+q273q9a/kTZ/3Bn7u//cu6shr9b7XvoI3f8FnAfD4Q0/w/v/821c/kPc0fDGaCv+7VRGrf4bX0pQPv1M3YnivEHA5nb0wP2BfZceV5TPvxycaqTyTvugrB6kkoTkjch9TtrQpwg4dHGFr8VRVKCj9ZG8U7ThFHVr0dEFxUTSQLk/Izs9Ybgw5/OwzLE5IZ518LGX0yQPIMpSzuOkcvXNAMS9lfxtrngHLoLFiywNSqefSngDmjQnt9pA211KK0onWM523mKXFaYVuLGa6FEnA+hgmQ+wwZXEqBwWTT83Qixq9qKhPjNFN490zHO5oSjQC9AtZX97TlSWUNcnRUozYixzSDGWcAJDGMfzweZxzFA8m1AUcfv5dDBYz9M6hsHVFLqzwuKAphiiXSsgf0PMSXTV84Re/hZN3nsYNUt71K7/B7OKhMKTO34+2Jd2t+aK3fy7awS+/5zewg5S1u7Z48z33sH52i/1qwe/sP8WTj19k+ISw7NXJFF0OaXMDqcNOLNnTinynwWloxrCYKJJDx/CRQ5Z3DyhHhmoMeaoxByWDh/ZkkbA5IrsIbQHTV+RMPl5LGB3EuN8vtsyTu2A0ZgvsjmaWDtBJw3Iv52PJBC5qtn6xonjkCI5mkiRU1r4YRAatRe/NaE6MqScp+b7l4FUJM6cpLo9Zaxq0k0IUTonrhSpryDPc2hA3yNG7U+zGUCQAh3PM+T0G+3MZW9o4ktYDbee828pSQLJSoJoBzemCvKpwaYK2DlwDTkqYJktLsjuX92R7A7d/iBoORQawtYZrHa4wAqSNIX3qEIdUDwTlvYKVVKAaDanPTKjP5TRj0AdTkoMKO8glyuF17KBErnALWVTdNvx/cdttoPpiNccqULsB0sdek+o8VlTPIONxPnotB3Mu3sj2EtlwflaqjKyytcdlCj2yUt4/UynnF86u147FIUolg11gp575wrjivrz2za/hW//532U4GvLAm14NwD/9+z/4jED1r/39/xuvf8sD/Lsf/bnub9untvjhd30/Z+86DcC7fvIXnwGoOmEusqyTP9y0djU57MuieR2p1ijnJ8bl8vpAqooiBR5MPSsj21rpe20rLG7bSl32VGNPrgGw3MpQT0hd8pAE6JTCDaVsqMpSkp0ZzYkJZm2E0omYuDcNzdYINyo4fGUOypEeORYnDdXJgrQ2VJsp+c4Yc/FQjNazjOqVp2gHYuavnSK7MEM/vQvWm7yXFWo8xOUpybymXs+wPjCRzhrynQpdt9giQU9L1O5UgOeJNdpJhjkqGT/ki5do5d9TTXJ5Jpn/DgHsEL2b9PcUPFtpMR9/nGCfpCYTAQiDXHSJPhqkmhZz2KKrjNGjM9xygT04FPcFz+g5paRuu0loBwZdtrzjz345f+Nv/g8s50te/cC9APzu2/4Kv39wodOmggBBjeMf/+D/zM/+65/nl//jf+FvfPOf53/8hq+mWta899d+m8/97NdzanODn/qlX+F/+effixvULI1Dz8R/Nm0aBjNL/khFelmcIjBa/GedPG9zmDF+ek52IPXlnVa0habZLCjPDsjPL7CJxg1z6q0CdzrHpppstyE5f9gDzrpGna8xgNMt5tSA4UcT7Mkh2++bkT81hekct7mGWxugL0ko2xmpsteeXscmkD+6hxtktCrHDhOqDc3FL9tE1Qq9VOgG1h+ckz2yQ7s9kSS9WQ1FJj60u4denmVRdYurSnmOg0IiGZ54cFUliybr2VYt5IRyoMuWeqMge/oQOxmCdj7p0FGP1nAnhqimwEwrdJaJzdTaiHaYoctGmOfU4IY5arqEw6nsf1DAIPc2bSnkKdWaYvB4w7AV4E05Re0eyMJqNJQF1OEUe3T03PPG7faybbeB6ova3LP+ej0tANQAAFZxwHE0fBV0HPDnFefyTCfnrvj82QeQaLsrJA9XaerYv74lacL/65t/gN/9jY/we+X7nnUXxhi+8Ms/n3//v/2f3fGTxPDPfvI7OX3HSebTOcPx8DlOBNCKP/rHv4SN7TUe+9TjfPxDD/KGz3kd6xtrK6VWP+tzX889r7qbg/1DPv6hB7n41KUrdvXKB+7lvte+Aufgox/8OE89+vQzXvqnXfNAMoBHpbwrxFLsxTo99XVoUsP+/EEE7D6XVi0sulIJP7vWwbKiufesVOQB6pGmzXWv2/byBIeTyVFpVFlJOUkkOqF2Bexki4p6vABVMH60ZPRoyXLTkF6eY0c5sztGVBsZ6ekB+mhBeSqhHYqFVDq1DD+5Cxd2sdMZ+JCtLnLU2gTrQ/82FX1qOmtI5hbVtOhZiVOIiXrbSkJWmmDmjWgA80xspZRCNQ3MF6jFQkBLLsxUB0zidzHSzHcOIN4InmEh0odEGEsBvU4WIc6hmpbhh54S+YFzqPUxKkvRsxJdtZi2xtgWNcrBGI5sxZ/+29/GHzh7Nz/0A9/iH4aUEiWXJDNaAdKf/flvYH1jwnvf+34m95/lG77pzwPwj777R/ix/+v/4rO/8PX87Ld9G3/6j34JP/crP88Hf+d3GD1hUdMSt65Jdiw2T5jMHF/xZ/8b0Jpff+9v4tqW1735fi6d3+F3fuuj4GAwyHnL2z+XzXvO8FAx48O/8yl4bFdsl6qMttKkC8tr//BnceaukxycP+Ijv/FxZpf2SC5O0bMKtzbCJRqrG6xpaAsYHLYk+yXlneskBznKgl7WLF+xRTKTyJPZmWIuHZLMlt7KKWX9osGNci5/wQazN6Y45cguGDZ+b0GyG551QvLEvjCizucttK0UGXBOFoiV9C/V6iiq5UcarVCZlA0WoJrBsmb40fO49YnYBRYp9V0bZI/sCKNrNM2JMWbeYIcpybhAHy6Y3zkgmTYkOyIRUzPvbuF9UPHJVmpRYqoGk6W4UU76qZlErnx/dI1IzVzTwNFUFj3+nNWtNEI6bn4E7Daj2rXbQPVFbRFVeAOzZ1QXO453fbU36dO35//eb34UEBD6XO2tf+jNrG1M+OX/+Kvd3775n34Tb/2iP8CPfPeP8cX/7dt49Rvue/adOHBlxTv/l7/CA29+DZ/66EOYxPDh3/oYTz9xgZ//qfdw93138r0/+Y959Rvv45ff9V+56xV3cO/99/C/f/9P8D1/7593i4fv+Ff/kP/ua7+S3/6vH+Lik5f429/xTs4/cYFv+h/+Pge7B9d/U26BpozXPzfCwPe2U3UHTF9IqF91CYEIM/pcYDe8BtZLXyZDKCuqV52m2RxQboiriE2VtzJqUWtjVJ7jDo/Qe0e0pzfQicGNJZyeJhazc4QqS5HDpClqvE627zBVgk0rhg8fwv4h1rVsXdyjvesEyc4MhgWmtpQnE5K5JX/8APPIBako5SxKadQgR21vdho8ZR3ZYSMMcArVeoJZ1FDWot3LUuzJdfSyRi9rydxeH8lAELTEVQ1lCUrDIBON52IpQLTXB/Xfsa7T8qo8gzxDKY2bLyS64qycn0nEaSDzSVnWoepafjZG3BOyFJuCbcRQn0bA7+JUws988LdoRvDaE/d2j8xujSFL+2pNTYOra77ky7+Ao4MpH/il32Tr3nNYa9FaU64dkJ1acnQw6/aRPGo4OBrCdsNgz5J/THxz9XjA+mTAt/8LAcUf+vAnyFXCxz74CX7tPe/ng7/1Ub70v/8Svv37/x4A73v/7/L3/uBn0TaW7/g738e7/83PY6YVG3cO+bH/8APc9Ypz/NJ7fh3zBwe87pv/Ov/p3f+Z7/m678UZTXX3hMVpg1Nz2vmS/z97fxqu23aVhaJv66P6qlmtchfZOzs7CQkpCEmQCEkgoCgIKIJcr8q9Eq5wIHjOFQ5eBPQERORBOV7QXEWRowg8oFIGFBRSUIgJARKSkIqUu1zlrL56FL3dH621Pvr45pyr2NlrrbmzZ3ueudac3zeKPvoYo/e3v621tyUPlJjtrKH3wBD1mRSLZxP67wLSGWF+JsXgsRLJ7hSJluUN9eydZOe7ssbmH+co797A4vk1KCP0rzRIL0kRh2S8aMuMGkvunABW5hBzTWkiwE+3Y7Cwr3khGrxaWIWnM0n0yzPQvsTSusevIt0fA1WD+q4tLM4SRh9dIv/IJfj1AZq7NrE820c1zJCOa/g8QX1mC3Wf0OSEwcf2JemrKOR50/wFajxo2YBdAlRz0ZN1FBaY1MuEbc5y0HwhCh7uGAHVE7utdgJUP8WsxQRPQmzBnbYnOC59/pe+Cvu7Y/zBb78LAPCVX/vl+Ouv+2q8+x1/jH/+D/4VPv9Ljq5GZicl15UAu/uZd+MvfPpXBbbUOYc3/Pz/iee88EH889f/CH7k+34MRa/Ar3/4l/Dab/0aPP7QBfzkG/4jnvW8Z+Iv/80vw2K+wN/8gv8FXhmrV/65P40sf2q+fkQkMkeRxq4oRigojUDqzR8c4ZEN7n5I8t/NHFP0eEXSyG8NUW/14RY10rlQqq7WpJssgb/3DNyyAvb3JYEkc+DUoR4kKDcSNMUA+ZWRSEhBEmASyjF4rAR5Ai1ryVYGgNkS6bKSJJZlBThCCqA3Ggi7tTcWUMA+HAtntsAbI2l3KuEIbtkgmZao1jJk8yXSi1ritZfDD3sSIwkC1Q2aUQ7OciT7C7iyATuS8AdV3SAiYaGdSthZiU7pZP1dWSvr87oB+xpB8SLPBIQWmYTDZKnE0Gk5YzQ+JNz4QY7leoZ5kQJlAW4clucKLE+JYkG+172PbroUYK0sLdiDPePz/8Ln4nf++9vQzEpc/vBj+D9/8Mfxzf/bX8PrvvJvYGt/A3/hz7wKVVXj5/7dG/GOn/8drK33wOThdmZA5SULoG7AltwJYFFV+Mpv/i7QuEQ2qfHAF74EP/jvvxt5luHP/e1vw7sf/xj+9Nuej1/87u/DP/0334W/9EcfxCf++GP4iq/6Ajz7ec/Eb/zSW/Gt//fvgt8aIs8IX/TnXil9TkC6UyE/B+AKY84Oi90esAVc+awc6+sz3LsxwYd7Z0HzBHUBzO8eYP0DjOzyEHRlTy79njPwwwLJlTH85hooyUGlg9/JMHqUJUQhz4HpDJjNIzZSGfKmEkm1xLVetrJq9bC9F49HKgsLUamQ/XkpigG8LNsM+7JCUpZgZqSesTmZS6w1AHdxGzwoUDSM4uoSs3v7mN/TQzVy6F+oMXhoH8neTEBq4iR2W6tyIXFt1aleD8gkfIJVbmv5aecxf2CAfNej/8gUGBSSTHdM7CRG9fba8bnzn+oWWM7bftJPLbsB8PoFX/pq/M5/exvqpsGnvfi5+Adv+P9gsj/B3/0b34X6hkSjCdwrxH2q5/uD335nx6X/mZ/zYjznhQ8CAPIiw1d93V8CAOxe3cOZu07jz/7lL8BPvuE/ojcQvdBev4c3/MIP4h2/+Yf4wB99CL/31j9AVVY3denHwggCUvp9YVKnU2FPI+3cm2JQSWOX2bd4SS2EitxgZQSrtS7SYomAq7oBrw+QTTT7XUd/V3pk0wb1fWdFIWB/JsCu3wM7gMkJYNVrQpGDhn1hFbMMzSDF+ME+OCEMNjP0Hp4geeSCbNw0kmTS64kbu65FPspqv6sLlvJcMqWXFTBbAlkqbtGpgMdyq4fsyhTp9kz2Wx/Cr/UlycozuJeh6WdoBplohToHhshdoVcAvULYVgJcWQO7DRhVm71nNehNe1QT1TAXZRDKUmDQl/MOComRzRONPwVcLa5/KhvJkM9SNMMc9XoO+CnSJaPpJ0BRoOkBxZUa/ccqZOMSg+eV7Y2bzAXEqyKJ3+jjWc++Dw889378q3/0Y2D28AXhEx97FBd3dnBm/RRe/sJPx93POI/93TE++oGPg+dL0GIp9zLWmV4JS/r1n/jv6H9oV9jmxuOr/rdXIs8yjPcneOk9z8JLH7wf+UBe+ixL8Zov/zz8+Ps+jr7q/r7yi/40Xv8vvg3ve+eH8J53vB+/+hO/Js+eZ7jL++iVAzRNhdkzAF94pFmN0/+zQXGZMd46hfSFKdgBw0tLpGOHxV0D9M8Oke3PQY5Qb/SwvGcN6ak+fD9D78IcG380Rb4zwODhBZKdqYDUupaFG3Mk26QMeS3AmZWhplx1rhsV5VX2lpyTBZ15HyxEp/FAs5T3MspT4PEMblECO7OghpI8dEkWN0WB0e4U5V0j9BelgCxywrLnmUhmDXJwLs9jMq/hdmpgsWgXS2kibS1yNKMcu68gFB/NgCpHdV8G3zthVJ+udgJUb4vdjoAWsZuoxvopac963jPxzOfeh3/5vVIa93kvfg6KXoH/8etvx2e/5k/hs18DrG9JGc1nPHgvvurr/hL+y0//GhbzqKoWQeK7LPkEAkBju/u+u8Lvz3zO/Thz/jQA4F1vezfe9bZ34+KjlwAAH3r3h/FHb38PXvKKF+M1X/pqvOZLXw0AuHLhKr72z34jPvqBjz/ZXXDrjRk8mYBJYzw/yWf7ukkS1zp8iAxQ4KVglRsPmi8k23+tgJuXWN41lAo6gDCeLKxtsjOVBI5egebUCK5icCrSOeSBbFKLDFQu8Z88ncFnWyg3CCBG8pEK6c6sC9C1X6go4JfKWnl1u2o8IPUKSS7ZGErIxGShDGCGZpRLGcrJHBj00Jh7nCXGkRqG74lck4BUQrNWgHopkkkJampwkUpFrqqWbHxT8GBELJyEayBJJLmnqqQ3lQFDrxAmdinndMyAsrYCUlWyzsIWALhFg3yyRHGlRNLP4IoE+R4h3V3CjRfC6kULRsnt1DEyTVHdvYFX/s0vRF03ePO73gveGOK+z38hfvgN34EkSfD//K7vw+/86h/g3vvO4Td/4V/iO//Zt+LCI5fwGz//FmlA55mkzuJ279I2MJ7K9wzcfdcZfQYZn/XAg5L8RYSf/fe/DHjGox/4BADgV3/2zfibf+evY21jhP/b3/rL4Xi/95t/iK//kv8VtWbP03wBnwD9xuHUf9tBsuWQPzpFs9bD7HSKbMIYPFph7T1XUY9yLO/fkrjOuga8R3ZxDEoy7L54A+mkRvFIhdF7rqK3fQrNMFd5QA5SgAAkVMPKYDdNlB1PoDwVdlXvkTGwlDoJB/C+BbRpoowrJHufGtiChohkkec9sFTZKC9lRDlJRL917JDv7Es4AjPcYCDvZJqCqxLclOJ5WB+oygzkuzQBLUtgbYRmawhfpFie76H/qEd1Cth+2TrSexM0xTECqicxqrfVToDqp6h9UhJAT2F7zZe+CnVd47d+7XcBBj7xkUfwsz/2SwCAl7ziRQCAXr8AAGye2sBLXvEi/PrPv1mBqg7Kw74mARx9nr2d/fD7T//Iz+L3f+sPD92uaRp8zed9Pb7gyz8PL/3cz8ALX/7p+KxXvxRn7jqNv/HNfxXf+7/+wOEnOET54FgYQxgbMAj+k3cUXA+EHvU9GTiNPrCCFaxqEybJtCxR3r8pjGMqQLV4ZF/cd0tJ/OCmASU90HgO6mWoBgmIgWyqigWzGQiJSLT5BsmVfaSLHvyQkD26I/XSVwA3z5dAkcM/eA/cQxeBsgJpVS46vQlW9zn3MrAjJNMlOHHwo6LVPt4Yodnow/dSpPtLcZNr1StKHBw1oh6US9GNZF/LtPYkSYamS9DuPngs9dwDgyY6daHfSEtdEqXCavX7ktxEBJqXcJ4lUcsTaDwVbwNIFnNZBpQ1yHs4/cF8ApotkSwJacai61mqm7rIUW227nghuVU5hIH8sT180ctehj98zwdxYY3BWxt4+YueG+LTP/ILvw9KPT42vYqdvTFOb23g5V/4p/Cm//Y2YRpVwB6LJahqk/k6Dx0Jm2jvsXMOr/+67wXqykhHWVCkCcCMj//JQ/jiF3w1vugvvwYvetmn42WvfAkefN4z8dmf/zJ8zhe9Ar/9q5LgSS4BoUGyO8fw3VeQ9eZAmmB67zqyqwts/u4OXAXQdIG08XDvvyj3i0QerLx3HYsHhnB1g8HFUp7xskJyeQy3GChDmQuj3jSajKex1kmigFIYSkpcFBLQhGsnXYCTc8FrQavhIKZ9bDHMeqNC/oM+P6zqGrLg0VhXDQXi+VzuadMAZQlqGrgsA10ZA+uj9lbYS1xW8nyDMXzvZYw+kGLyvDVMnuWQ7qZw1TECqid2W+0EqH6KWlu56jiinVtnr/myV+Fd//M92NuWCejdb38v3v3290ZbMF7yihdh49QG3vv778P/8b98X/cARPBrfbiqUQ3Z+EsHQMDIH/z2O7F7dRebpzfx57/yCztAtegVOHv3GTzysUcxGPYxWBvgN37xLfiNX3wLAODf/tob8Ll/9hVIVgWsFXzRcQWpaiH27Zaf6PCPg4s/AFU6CGpJtEL96RHmLzgH1xCKx/ZRFOLCdZd2QBeuSmWqnX1hmjwDgxzzMxk4dXA10Ls4Q3ZpAppqgQEravHIFYx+D6jOD5E+vgc/nR/iwmBgtkB16hyK+RZw4aoULFiX0qbNWg5XNlIulQjNxkDkgcZzYDoHb41QnhvBLT2yS2PQspYFlPfgrTVhVNXcvBSNz0UJ9HIgSyQbfDID709EjkhBBmucIqBaleSAXMI5kGfK3LJIL1mtdiIBQ1r8Qyp8SVyrXTf1CgGdzEA91RhdB1RoKyE1HigyNLEbN01UNkrerc2ij5e9/IX44e/51xh8dA+z553Cx3k3bH7f+XN4fPcC1vMe1kdDAMDFhy6gOT2CLxJUa8K+uZJRPDrpupnIddr85jf+Fv7G674ao/UhXvkFL8fv/Le3CcPMHmfvPo3FYonJ/gx3338Xrly4iv/8b38J/xm/hF6R4e1X34Q0TZEqgCZHcnyL7fUNaFGBMmD4ew8JKFuULeNfN3BVJSw2EdxQGP/BowskswrJ9kRK/zYeNF2AJjMBqlUtINXiTqF97iSWG57azwAteU2hOpvFlXOKFnCyyRQ6fadYwSsQVDTsmbZkvBDfrMlbYLn/jiLgK7GvlmyJuoGvKjiTKlwsQXUKP1+KysZyCXepUf1WxtqlPbj5PcjWtHDAMbGTGNXbaydA9TbYnXze4lKrxxr9XMee8ax78Iov+Cw4G5gBvOizXoCv+rq/iJ3Lu3jzr/wW1jfX8NLP/Qz80N//Vy3TduCSV1fl1P2ddIBICEC2snl7sPlsgW//m6/HP/vpf4y/9rqvRpql+NiHPoEHn/cAXvnn/jR+8Nv/OR752KPoD/v48Tf9a7znHX+MD73nT5BmKT7js1+I5WKJn//3b8Q1jVbmiKe7rbKopCyqoVT2gQ0i58DntsDnt5CPG7h5LWL9uisva/DOHkLGOyB6lsMM5UaCbMZwyxrZQ1eBi9sqiWWxsgx4wO2VyNbXRTFgOuu2lTkklvUem4BHQ9BoIW7aPEMzyjA/10OxvUQ+XqJZK1Bt9ZBtz+BU6gmeJalqshTX+7ISgKgxf7aiobKBm8k2SJwkndQe2B1LgozGMIYErjSVsAOtRsS9HJSJtBVNF6DFUi7T6rYbwLHqRmXVFvWwW5GmrawQM5hVKYCVcfPiNv5Tr3wJ7v+0+/G853162PeL/tLn4yWf9el43zs/iPf/ycN49Ze+ClmW4jd/+beRTCqkkxpvec+78ZY3vx1f8IWvwPe+4dvxcz/5X/F5f+nVyLIUH3z3n+Bn/90b0WwWWJ5K4bhG7/ElkkkjoQbne9F9aQuPEBHe9tY/wI/94E/g//Vt/w/805/8R/jxH/5pgBmf/tLn4fkv+TR87Re9DpPxHM//jOfgf/+V/y9+57+9DQ995BE894UPIk1TfOT9H8Pb3vIHUTy1hgwlBXg0BGbCfDpKwbWUEOWmEkCrOqYhmamqUHz8amDMrVQwORe0fimPyIcg+8ThebEkR64qeQZUFipUG7QFgeuOe4I52+O2LDQDcJ3tumLdJPJtCpLDIjZOfGSLgU6E0VcPBduiRstUc62FaewF9w2SXWD9tx9CLyO4b4/imk/saWUnQPU22K1xWNwc7bYqYWX2VAGwm6c3guv+Z/8vceWDxZ3/6Ccex5t/5bfw6i/+HKRpirdGslSHddOv/8Jb8Edvf69KXq30CQNU6sTsGb/+C2/Fe3///XjX295z4EC//Wu/iy9+3lfii7/6z+KBT3smzt59Bu/+vffin33nG7C/OwYAXL20jb/4GX8Vr/myV+OFL38+hqMh/uX3/lv82n/+DVx45OIRV9uCsROQqkZARwXALLj6WSR9egJKeNgHn91StzbARYa6SAQsAAhyPvGxiJCUjGxcw3mHfHshTKq5TTv3gpDtN8AeB1kgSU6K4iMZ4LoBXd0TYHh2C9idoFnvodrIQQz4zGF+/xp8kSCdexAI9T1boIaRzCtkl8bCojonblZNNiHvpfxqXQvT2TSScd8T0XbaGcPv7Yv+a5aBkIJySXrhrTX4YR886km/1qwKCRKnyEUh7tqmAWuRg6BxyayJPMrKJolce5GH70Lfeg9wA7gUgICRZzx4Dz7js16AEAcK4K5nnMdd957F9vY+3v+xx/H5f+4VeOijj+CjH/g4KEmQ7ZUYPOTxur/y7XjFy16Al7/yJbj//rvwrt99N/7jD/9HvOnn3gyfJnCDFL3HKqRXphKbrGBpPl3gZ/+vNwJgPPSRR1eAFvDPvutf4r/+p9/Aa770lTh/7zlcuXgVb/ypX8X//jX/B3zjwd7jLW/8Lfzh77wLf/YrXoMHn/8sTPan+K6v/0f4tZ9/CxaLNr6d0hRIGejnwNY6qJ5J/yQJMF8EoCZya77VrXVOEspsAWC6o1nW9meaAqrMwJEclVUVDGVwvYFmahcakTFzx9UfJODicBAz58JqWRhjOsCokunz6uerYJab1fdMQwZ0nAuSadYGIyPIhcIEPOofL4aRceunzeN0vXfYToDqU86oO5h8kkjGCgYc67eCgfe+4/147zvef5AptaYT8JovfTUe+vDD101QesP3/Og1zsUCDJIEqEv8q3/0Y9EJD/bT1Uvb+Kn/33+65vmapsGbfumteNMvvfWa28V2zO/I7bNDWVQT6vdhI8pziZU0lhGA2x7DEcE7AMslaH8G92maBBf2bXuZ6xp0YRsjCLBNHt8WppSjh81CDsBI9hegj11CkwF89yYo7yHZmcLvj0WyyWYzAqhq4Nd6oCyVhB0PpLMaTT/B7HyKdOrRuzBHU6SoN3Kk4wrJrJIkEw054MVCMqMdAVyAZgthWRMHr7JQvkiRjJfioncEDEfA1rp4XTd6qDd74CKDqxnJvEYyLUGzElTVEu84X2qCjRflBAWcbMAzMoYALCKSqkfGjgEtS8gMwIcu/Pl/98v4hR//L2EbNgAEAvIMSZriVX/ms/HGn/yvAeinj+wifVSSt37vt/4Qv/eWd0RlX/XAZY30sV2JQQ4gWQ67vzvG67/xH8u5Ig8TmW4nGO9/5wfxgXd9MBpPdDsD5ETYvbqHn/2xX5J+sYOsemS8F03QqgItroCbVDaxkqBw4Zjh2i0cIWY5laFlk3OKnlF4uTfcNC1ItUIO+nvnPTFQabGkBiINcOrvQW4unlPsePG713kI9BhJogsDbrcNxxD1ALhEvg7Hs3eqfVUEiEcVDPUzCy04saennQDV22BP7uvFT+oBnxIxrPFcsNrc6O+Lj17C//j1tx35/Y2dRyZdACvJMbcROoaFyFPg3lzLnugldEjOQ/wRPn4HSFytrGUhjYHa2QuuRTJ3bzxJHmaNB4+noNlcmNmqkp/Y4velrAAwJi+5G4sHNtB/vML6O1VuxwB2mkns52wByhNwnsJNl+g/tAcuMkzvH4ITgBNCeVrYYKo8klmlx4eUea1azUnKMmC+FFd7loBHA/ihlIhlR+CMRArozDNQnRmCEwcC4HMBGW5eIbs6h9udSiLZYglfWVylsmoxWxquHUGU3dhUcq5lWm0bw/Khy7oPQQtAEAFDBqoaZ+86jV//xbfiF3/yv7benkrdwcrsdUIOAlhl+KZGc3oNzek15BcmoN1JAKJW3cjeLQr0HIM9I5SjtnPaNTIEIMWXELN+xiTaxXsPERRuAJTtZcb9qIlTlCgLv4p3V/oa3ofkObZnAixg1dhIA5gWAuB0/yQJnwWgvgo2Y5Z0FaTacxA/06Qs6Uo/yKLMrie6R5bURXq/YHq91IYM+FrfY8j/FtJg9ytNDh8L7qAdK4Y3srquMZlMsLa2dmSBHGbGcrlEr9c79Psb3eZ2mbv+Jid2PO3J8j3Qys8xt6Oay8APfvu/wC/++H9pu+UJdA+tvhF3olsYbczbU9WuBVKP6E+ZF6nzc8CYEWLe+n3QoK96kAwqctF0XSwkOapp5Fz9Hmg0BE6tA6c29GSHDX167LoWiZ0Dmrvc/ihzy2WF9d+7iLNvvYzhn+yB9/aVgXOgXgF3alOA5XIJevwKaDwT0Lo7gU+lrjzVQFMQqmGCdNogm9TijocAAp7OpT+2NoFhX4oCpAl41IffHMGraoDPHJpegvL0APV9p+E3BsgmFXqX58gfH6P4+A6KD15C8cePwn30UfCFy/DjiQq8K2vLLZBvS9UquNGkJ8pE/J/SFAGcGUgykHvYve+wbARKNOmGBGxy0+DCQxfw+m/8x3j/Oz8Y7aN9befQl5JZ+8dYw36B5swInLsW7BgAjW45e9bwWa8gl8JlWsOF6bRTt+w9WaZjqPAVL6bs/xVmMW4nSJQBjL102tbA1qMFp/aj7vcg7q8hJoFttf0sA99c9BoXbDGgZAsPz21ctpmFrijz271PEtvauU4nWsVkz4FdC8UMqd0v6wcOahZhO7JjyeeUJm24gfZ3CDk4sWvaI488gr//9/8+7r//fmxtbeEd73jHgW2YGd/xHd+Bzc1NjEYjPP/5z8eb3/zmm97mdtsJUL0NdpxfMVs0tyokx7m1kV0Ppz9RkBdmsxYoUppGLOdt6J/O5PcUs/As0dFddeS9ucY+ZkkCDAZwW5sio6SfUZFLopG5nolAZzbRfMaDWH72szH70w+ifOH94LOb4VTXMq4roKmvtYWyVRA9yclCXJ8+ijsc9IH1IZhZWMvJFDyTUAIeFqi2CjSFxNC6SgT0w9FVRounU7mmSC4KRBKPOizCBM6JSG+RZ2T7JbKrM2QXx0iuTECXd0APXwB99FHQQxfA23sSe+ojBvWIa2QF+yLVlIpbNkvlnWDu1GkPTBof/nIKLokWIApmWBny+Jk3QEgQ0BgYOHL6NxRsqS5tksBVDYqP76L4+C7cviW3cQBMbYJP3D4FwV4SwQLojUKr2MrLBiDWguuY2Q9rH7uupmljdu2aTOEgTVYAYbjwCDC6ls00b0AAgLq9ActV9jO2znFYt0cLiOP/mSUJK/zeiNqFhZ+EMBBuw0GixU04X7rSjrjd8fMSFjgWl9r2OyURmD9uC3fm2/NzE/ZjP/ZjKIoCP/MzP3PkNj/4gz+If/2v/zX++3//75hOp/irf/Wv4su+7MvwiU984qa2ud12AlSfNnbUbNQFX08JsHqLBiyrkX1ggLUa5LIVbnn/xNd3zG8FAMEPiQNlqbjMXVu+8ajtD7+ua1CwaQqsDUH3nhed27oWQfpT66A1qXPv+j1QUQAuAfUK+PUB6vUC5XqKaqRVm/bncsjrFRm4ntkkCwCnNkCjIWiyEBaybqSqU68AJ4lkOGtCFK2vAesj+A0RNk+WQFIy8qnXZCqAGg+3OwH2JyBywhxnKZAl4EEhP1kSCfE38Bkh3V+ieHQf6YU90PY+sLMPvnwV/sqOxNpWVeuijbLfxS0cXVo0ScY6mtw0IjU0m4MXC/jFQhjswGqGA4TbZjGsFpMZPPAuOhe4fSaifY017T4XrHO4xHcKO0lyPXUDmi8FpMYAWpm72P3egl8DQNRJKmKN02Xv23NIhwQQEZKGCO33of+i8yaqx5qmXfbTgDNRyzJer569gTfrK1NkOMxiwBuzoaYSYAsL+1EwHEKe7N7E5zkE2LLnCMTrT8z2Wnutvw9bkFpf5Vl7LGVsAzt+Yte017/+9fgH/+Af4J577jlymx/+4R/GN33TN+EVr3gFiqLA61//emxubuJHf/RHb2qb220nMapPC6NWY+8GVmmrYPXgZHEH7VY0gxBJp7B6+yIX6KF9ZoPuk2wMMJ4iiQMEKRO6NgCPenDLBtifSnlK4PDuOcAWs05d1N3IJjRHEpe5sYbq7g2ku+IGx6lNcC8HO4Au7wq7mqbAbC6gLs/ACcFd3sXog3PQdCExny+495O75jgmz0Tyaw/UC00WkRAE2liXjPsrOwJSkwS0tQ5/dlPKjA5k6HUVg51ofhJL/KibLkGzpVSTKgrp316Beq1AM5SEMbdspMb8QITzsytT0VEtS83gZ8nOr1QLFTEg4cjFHwFW63MFlEQcYhylXjxpbKIP7KQAWdmPvYC9LhnE4Xa2LLuBPsCQa8CM8d9xm2xbBkBxUpR8RqsAT0GSvbsGSkXBjJQEXGXpothVtkQvp0A4bq9dl4F4Cm0LcaAGzDjqdwO5cbKTvQ/kgFCMIbpuoB27neueG3F70N7j8GekEBAW4L7zerVt4nbIj76X+F07NjRsoAnbmgasFRkIIQdxx9rnndVQe3mBMbWYXOY2TIEI5Feu6xjYU1FH9ZFHHsGjjz6KV7/61eEz5xxe9apX4e1vf/sNb3Mn7ASoHmPjzoAVa9vdqNmIw6ZTH0203H53vaMcAK53EETdAnxISSKVfKYzWDxZx1bPtzro3ko7xniVAAGlVQXa2VdXqCSXyCOj4ACI8AatHMBFzxcHdim4z7MMNBoARYZkewranwFrQ9RnRmh6CdILe23S0f5Y1RoacDmB25+oyyhCTnbcPBd2c1nKZHuYq81pAotOxqttk+PpxJ3noLICb4xAayNgUYLHk3BsWl8Dzm6JXuoohc8cXMPwGYETwOcEGjci8j6eCUPoRIgfRQ6fp2gGGXyRgGqW0IBKmH5XNqBdqQHPVS0VsHpa+Ynbsq0BhPqI7VplliMgxqCuS9ib1JH1FXXwRiexyHvBwMRSelNvuLw63EqDEQWs1z7r3PUm2+kOew/t+wCcw4MVATQXHZ8PYLvudUdgyUBqGzDZbkcOiJP0QpOsTfE+aPuwS13DAGC4J6FN0XsSKolFYDcGf+G76DpopQ+A7r2OQwxYUZeBepeEzu4sGGJ1GNIERu9bptoA70rzw4FMRSKO37Vn0NQlaq26hihul9Fe39PQ9vf3O38XRYGiKG76OJcuSVnvM2fOdD4/d+4cPvjBD97wNnfCToDqMbYuQHwCb6kCgc4oH8aqY4SAbqYpt6DZ3DQg00IM84sO9KtJBxT/coz68Habzh8xw0IghTfU6adOl5mlKajfa9mjZSXVkVItsjCbg4sU/u4zSPYX4Evb4uJuGvDmEPVaDp8SsjwHBn2pvlTXwigyJOkncSrhE4EQ9TlPP/MeTDZz9C7OkT50Fbw3hmRqqzkHnF4Hpylw4SqMPabhQHQdJ9OQuMKTGdBrhMW9/zx4ugQubyuT6kCbG+Dzp9Bs9FFuSOITeaDuO3BCSOeMZNEg3V+2YuwVy7kGPSmPmjgkC9EG5YRAVSM6qmWtkkgVeFmK8gGRuL69h8R0sgISoIMA4zCXwxZexo5xBC5WESTa4YVM7D48HNwuUDrxp9DwkJaQBFr289B2sDGBCpg6w2F7ng5yDifg6BJacNjpB7npYXsJFVhB0AFYGkC09mHl93bMFoaZQXHyXtzn8RhtbXfuoDs/3ifup8OAq7XDto8lquyzGFyuHisGkpZ8ZW1lamNiFcwjSVpXf+c4UZ85dNu4SrrE1wGEylsWBnDsYvYPWzjdinMAuO+++zofv/71r8d3f/d3P+HD+pXFaV3XB/r3Rra5nXYCVI+bkWvLCa6umm/WGLJSXmErYAFhEcugJ4+26TSq8/mTX+0qZjPkN48G9e0YDOz0vmrlYgApQzlfgllkZGJJHcrSNuv2SWygx2qW+fE1y/hli3t0MlnRKggIO0S/ZpmI8ROBWFm+QQMa9GRSnC+B8wMsn7mBtHJwk6UAsMaDihx+fQAAKK5oAhOzxl/Ks01ZAh71wLUPJT05k/a6rXUAAI96oDQDDyF14TuDMIG31jB72b1IH9tDcdmBN4dwWQ/1WgHigZS+nC+EfdJkG3/XllSFGu9In4wGwLlT8Gt9iZXdyEAe8Jn2kQfSmUc2bZBtLwToj/oCPusa6BfgQU/6qayQ7gs7y6kDai8lNZ0DlktwWQnwT1PAi8g/QBoKoIk/vgbHIMGYvjhGcfVdDN5mAq8mzQDRuGRLFMseB+BJ3+PIlc/xw2BgRsFkNMaZXJRIcBqIbdtG+qe52gPZF4UOtJWWomcwBrTxdwCkMoRtQ0ATebE6wPaI//WeejKFAP14NWv9QJ/rNnqdhMiVbgfqMKeE7gkOgj4Dxmyg9DCQcYDhRReohuMhYl4RWFAJjUjavjHWPvZg2N+eRZvXUVdKi9ECX7OQNNYEwMq1uz1zwTG0hx9+GOvr6+HvJ8KmAsC990rY08WL3UIzly5dCnGtN7LNnbAToHrczJGUWbTAddPOa54IiOHrv9xEMrnlmZyvbtqMTVuNM7rB8Vp9xxjfTzoUIJo4HRKkyFFzefuBW5ppdiwAvwT8AkgdUBTAvGz70tcKCKontoC4VhOQwx3XHEeCTEyJA42GwhgydOLxOBSgHnIQbjxoZyxYqMgF6DUePFvAJjXK19H72C786TX4YSGVneaLUIe+7jlkzKCr+/I5EXDPGaDx8FmCvZdtwvkM+YRFR9QTfA5MniMurfyKlillD1qUneo9zakh+P4z8DmQcgI+vYb5/esY/MkO3PaOgACTDQKAtQHqB84DziF7dBs8X4DPbsHftYXqVA8+lUnWNYBPSLL7PZAuPahhUCWA2s2WMqGP+uBTIyAVzVV4D8wWqu/LEurgG/iyFjepAQlAYnVdASjop7FmZ9eRHmxnXRozfYbi0AI6ZRDZ19d/1lky3SkBHKVIKXqPOVCn3UawsW0AKNJXhZP2BBe6IdOVa7BtO0zxgYa1F+yO+N5cy36lmbaoPwykHzgMhf8zFHBI0GFgA9FKEVANSDWc48B4GgPW4OJXwoBaLwavbge08a3hco4ArIed57B9ou8o1XKtkdKG/iLjqB2Tw6cS88rNQeCu+1OSiBayfNF6RJ7Grv/19fUOUH2idv78eTznOc/Bm970Jnz5l385AKCqKrz1rW/Ft33bt93wNnfCToDqcTPVTWzNYqq6g9cnR8O3rCoVGTDow28MAWa4/Tk4Ian73Xhxyc4WHZmVzpGeLKCmq/kUKZ7hnnP7QSoBtLEFrA1lwtjdB1dTUJYLe0AVoGMvuQRIM3Cz0FCKJw+sOjikyKJP+MnGwk/MCG0sWl2Dd/eVaUnQySC/rjHgG/Bcn/HZ/JBtCGgaNHdtwTclXF2BtBoPOYfk4cvo1w04z8CLhcx5GyP4s5tYnilQbWaYvIRBuwmKq3pE5zG/hzA+K7Gb4+cMUS7H6F0U9zgcBUZ2+dyzyDjF2nt2MPmMM8j6DqMPXYEfTwRIxhng/QL1M8/CjwqkO3OgaeDPbaK6/xSqUYYmdyCwSlAxktLDVQxXNkjm6sqPMZwjNKeG8Ckh3Z5J4YKFxAEbq89e3g1KM7gi12xyyAKyroFhXxacVQXkmbDOzsliU9/jFlzYbWkZu5B1bfd2pTrSNR8SPXbqkvY9tgz72N1sLmErGuC9aLkaIxpE4qmzTxgLA76LPFDqMo+Z3yDkr6oE4VyIjksAyOm2HgdczRqL2QXvB8dgYYDlM8cOKWUHQW+M+ZRFba9tBTDGv3dCNEh/XS1KwC3Ys3AJttNSJ6G2U7a0E2Pqu+dNIiYz3k5Z0cDQx6ytxaqGa6WA99s6C/GKowW/5qUiDVWhJAFSkqTCY+T+Jy8/t/ocN2NlWWI2m2E8lvLdk8kEu7u76Pf7gYX9zu/8Trzuda/D537u5+LlL385vu/7vg/OOXz91399OM6NbHO77QSoHjs7OCEcSBCI/pfvn8ALbERB40GzOWg8FUAmB5ezHTJw8mpG55NpyjCklAEdsHYbjAAaV+DNQpioxRjI18TljASgtsIHDQag9RH8hcvoxDXeqobdIaTaiZEOmc/RBMO4jtboEzUGL5dwD18Svs+eeZAAWyK4j18AshQ8ncn8XNdIdnpo7kkxP5+in5TwuwXWPjIHs0e1xcDZBGkp96vcYFQjwv5zehjgFIoPlMLoEpDOGqQXLoLmNQYfAJZ3j1Cf34CbziQe1+IH+wWaZ5yBX+vDVR6cpygfOINqq4d6mKDJpc/SuXRbOq2R7ZfwvRTUMJKpMKScaviAlrxMru7D5Tlc1YAXSymdihZ4EIncEfV7wj55BqpSElG8B9U5sD4Crw1AC1EBIO/FnVxrxja1oEXvdgBylOfi1WGGny90E6XxjjQDYfq8eEZKCUBZC/wYETMWARwGwB6MNMIsul0oA6rPRRRjSlZ5CRxpifpwf9ryrADDJOaMVeV4vR7aHVzTNqZ6A74x8EIHzAbwbMeJiYUOe919xg25xXHwgSWN40oN2LvIpR+1Ncjq1Q06Gf7RUM1gIaxDAQC79hgAAyH0TK+xBfJYeV6i7+33cN8IIRkiDheI+tQuwtobQnhtseH1eo1xf7rSqTdhP/VTP4Vv+ZZvAQBsbGzgr/yVvwIA+O7v/m78nb/zdwAAr33ta7FcLvEP/+E/xOXLl/GZn/mZeMtb3oKzZ8+G49zINrfbToDqMbKj8EjX8/IkvbA2mNY12MqSU/wdDsxNT15M6iFGq7/wLTvVUQ3gpgFd3JZJetDXOu/RJk7ZpuFAXNahvbe2oUFi5kk/MFpmito/BE8Ef2w3ZppXs/gR/3JjJ7tRO6SEbajGY0lT1ubFEvT4ZYx29zB4dw9+rQfnnbDf8yX6f7gD/0frOP2iEfD/Bk7/wRSXL1ZI90uk4xqUpGAn1aTyR/eB/Ql42Ecyb5CPGZNPG2H9Uh/YHatkVgF/z2k0Z9bgKo9qLUXdlwQv8kBdEDghZFMP8ox04ZHtlXCLCm7ZwBepxM1WtQArR3K94xmwJ1m+fHYLGPUFZNYKkAkqGJ8KQF0sNVzFAa7tC5QluBiISsFiqUwqAPYhfpUb+4xbkJqmoDwXAKylhK97+2KXr92SEEYQM4DAik5Am+gWyFMDNNEiOV6c67FDEg+iUwSGUABUYHEtlhIMY8+5rtvjw6ofxXqfdu62fzqgPrCY8eVQq2YACMCNEoKsr0iBqDDj3T4KR1qt8mTXpcUGyK6FzSMAORdIF1MNLDyAORLoj48b9FjtGulgvGi4xQ7cDhZRG6N7aPco3AO024fFAEd9AWmvvceWuGceC68LEyZZEN+Z9frhdgv5ms45bsJe+9rX4rWvfe11t/vGb/xGfOM3fuMnvc3ttBOgekzsWkCE+WiAGnvHbvKMMG+RGUX/AisSMbdrlIgH5luPASPT/pgvhFFdXwNpJZYAEJQVoCyVyf92tW11AfFJHKN7j9GyJVrdh70HQWpri0i9Tlxh0oiOaX8SC/Nx5HNoE+4NXMiBpJ7oZMDRsdqDHjAagsYzuMd34R5XLcZ7zsLrJJlMK4lpBUhGZm0AALxXSURBVOA8oRol6H9kCnr4IvxSJa4WC6AsQUmC+tQQ1TNPgZiw9keXganomtLaCM3ZddSnRyAPVGsZylECn7fNTCoGLRiuYhS7FdzSg5iBLAEahlvWofoUNQ24YtC8BM/n0u++AXZT4NwpAVmTKXimiX3MWi1IEtkoTSWunOU+8rIEHrsE2loHCknG4kYSU0jBFGWpqgvUYIsZTFIgSQTEWZLcjRRGuNYgtELAtYuaFhBxVFCDkpXvm1aztROaECfkGPjqJPDoya1tCakSRArWDGaR7YoqREVu9bbd11i1B4Acg7vo3BSVC436iGOwFl6i6PvYLQ+A0lTAZiWftcC3tlVlWwgggGcFr56F3IxBN6Cxze2gwOGaVu6l/Z4kIAO8oa8YEksc9VNodjQedMIo0LUOGNcFgT1zIYHLFhbHCame2O20E6B6TCwGoi1zSdclq64FUtux7vovOOW5uBLLMpTLA0xW5Q7ESd6p8zHLRL+3D6ROSnPOFu1mdQNs77aVb251Q5W5eaKYPXhcj3qQiEBrI9EqnS8lUaeuNeQBKmzvr7mQur5xdwK7VmPN1Xvd01HLQgKi0LCo2oz3fk/ONCvhGpnkeLFsdVTJIZ01yjTpfUwSkaBSBjvJCszXcviMkH8EMumvD1HdfxoochAIPifRQk0lUYogsajZ2COpJP7ULUSc38ACmYu+BLAogWUJWizhLYbU3rfJFHx6HTi3gaSswLNFYAKlGpAwbFzLfpSmoH5f4mSXS2B7DygWUhWp1wMWCwGsVSWgWcEanIPL86jvNfawbtp4zxu9/9Te7jg3CwBCXXtTajCLAVQU/ygVs2LdTXSVOcL+3P050CBEiy2T7SKEuM1VVjNqS4jBXAXBHdBtF6H/a7zrQQCt33N0npX2BpAagVeOvBmym44H+ndw/VtsaBR/zFrWVypO6XieprJQAUJibKcvgRDLG/rbALnluDG3DHl4bxlAEwFgZXPt/q4maQFRSJFeQxQjy3Ujm0cVxY6LPRUF/5/KdgJU76AdRkS0IT9PiCbtWHsI6hx7FQVQqo9BWbWDpE04N5Lt+mRaPGndKWMvYHUJmeQ1q52yTAFBBm8Z2Le6Kcb03uyO5lbD6jOmk4ojuR6r2T6bS78rkGkna7QuvyfFrnEs5qMZ08OOY0xblqmLW2I5uW5Ay1JiP6czAX9e5cT0eXaX9zF47wVgbyKLDiJQvyeVthYLYS6JkM080ke2kSAF330G1d0baNY1JjV1aHJCXRB8qovKmiWrX93XiTKpVDdSwYr0OssKGE9FVgoSC4rGwzK4TcMz2ZnA1x7oF8DYgctGk9oiYKR9x3UNnk7RVjcSYMBlJeEshSgnsPdSGEDjHt2gD8pycFkKEDbh/pt5D2PQtJKI1GE9BT11gBdpwk5gGldLsoJCW61SVid207ohLBx18LIQAkYLgKzKkYFhIIqB1XNFFpKxjG0NK0Y9jrKMXfaQAUq6bXQRUxyDarLFFgky0djMFu2jBXChb0XqKSQ0aXEFkL478ULAR1XE0kQWYzbeM+R+6/2hJBEQrCEVwlxH/e0ANFH4DYmMltxzGSfJgKnpnzYcGFtjgi2Rj6zUMlk/dwGzLaYoTaXtJ/a0tROgegftcJD6RCpQ3YzFNIf+nqYCzsqyu9mdtCdKIT4ZxuEfAIAbDoSF2twA7+62g/ttaJ9oKq7Iz1xvnxAT1j0S0gS0uS5VuIgEzE3n4NnsSFBywN1/dEPvjBHBba7LwqKqlE0tBJTt7AFAG49IBDYZp6u7wONXWqm1TCThuKoAiEScW9TofXQHtKjAoz7m968DziGde/jcoe45VEMHTgBXK3tasWijTmq4eS3ZwXUjoFlBGPlGYmCnc2E4gRa0rbjGebGUQgd3nREWt6qkvQraKEkkITJLhf1flvCqqMBNDcw1NKBRdqzfglVyJCA/FXc4L5ehROoTMw0XikIfCRDglEC9NLVcpTFlVq3IOQEmgdFrmUi2wgVRH7YJUcbU2QkDYuwyeBFDGbN3Vk3Nsnk6lagsWcl7cKcqk11uBAhd0oY2xOVcLVzI1AZWQHpH5sx7uRy7DlM+MGAYVxU0FYcYwK6Cd/2bKGqTHY8gz0+etcmBFg5A0fUHTdOWOSW2pasuopnlmSYXtgnttRhhLY4hbDPa++yh7GwEphXMS7UuROPenRpkDrGbXcg90XOcGIAToHqsLAx0h1g89tzkUWEDrB2/+/yzMlHHwMJkAgSG4U6Tq3UNLESnkycTYaJ8N5HnllrMjGJl7Ap4NIIF8fOR5zIRgUB5Bu7lwmqUNXg8gV8sogMesjLggx8d3sQ7N4FQUQQ3Nd1zDs1mH00vRX5xgurZ5wD2SCY1klklzKl5F6q6w96Gv4sM6GUyYU9mMsGOhmhGPRATXMmo+wmaHqEaOpAH0gXDLT3ycS3xzR5Ix0tQ3cAXGThPpRpV4+GWNTCtpYpUUyuIc1J8wBaKDATdUAC8LEHTOXhjJJqx3oCVLjJ9KQuKNAHKbn33EJtaVZIkxSzA1QsTSEki117XLVP2SRmrhJeL2uEl5jUCMXKJOi5lqTB3gLQjLnZiMalW/cjYzwBSI2bUPo/BkgG5GIAGF7o9RC0D2zLJDNMNo7Ardceo4H0yBhwtQ7oCHLtxp/oMWmzuKlvqAcrkermu2+9MMF8ZT9ufkhjAUtuuwCqjBcQxqG+8gOEkab8LMem+/WFGYIgN4BI6SVRd4Gb9J892myzIgjjIZM98q1oQ4ngh99T7iOSmNvHrxJ6WdgJUj4nFq8Y2rOmwScOYNboh0NqVser+fazMVu1AO3Ech6ayghhAJluOvrjdRodAwnY0FzYxioujjbU27hAQXdzJHH46a2WlNC5TYpOrlYPfwmskBVlAV7vxRpJ3IuOqAnb2QWe30Ny1hfm5HgAGJ4x6LUfxyBgYZMDOVEusxsL3QexIJs6iAM5sCqCdlUC/B6QJmo0+kDgUVxdoeil8moE8wVVAuvDId0skkxJuUYfJnhoGJ4nopEbueZQVMJ1JEQ+LjfUMhoLPkAlOgTkjZuDqLlyvgDdG2Dlw45UNhzClgz4wnbcgJXrXuWlkQUoUXLsABwZZsqo/yfsd728sqQHJMGZJ/7ApGdSNuI+dPg8x0DNwac+F3awAauKs9fg7bUP07HdiJDusI1QRAMomR6sz7UdW8CSHDk9MOAdpnKWMrSoh5tBlbBldpjUeR1iPr+wyN7712hBJApgysexVOjDEgerPajzsYdn7BporvU5HABvoVEbUYlKtNDKi/iQniCGAV+sKQjcEIlpANHYvE1GlsKx+i9P1HsjSgyEdbUk0vW/Hy/V/EqN6e+0EqB4TOzyZ6qC1QNMSnI4GrKvHOXYY1cb8A270YwJSV63TJjrsw1tvFP8SnZuoBZ2jvkxcVS26mXUt2eDzuagarD4IxtzExk/C8+JcCyZil3KWgc6eAgY9YR3zBD5PkVzeA7b3RO+zuoGqX3F8X56BHaHYq4BFicWpBOmiQbo9b9nCuu5gDDu88mugsgJd2RPAP+oDSQLfy8BZimRvHgCC76XgWiWndpbIHt2VWLwslT5XZpY3R6CqgZtXEp86mwPTucQD+6j8LkuMobDfmcaJCmDi5VISpKpKmFWrWmfuWyYwRAKLvLhQj4wpNqAS3KypMNLL5Se3gD1sX2URSWWTQuY5AGSphENY4k3MgMbufAM+TXNwm5Vrit3M7Y2NwGm8fbwYCqVAY2bWEFh8XRrWYAAtBF7amMzts8gMJiebmawSEaDxmoH5dBEoZA+uddHiG6CGyoUlErLTRO01oKgLGW48KAapyUp8bLhWDhXGyN5Ni0d2DkQxqIey3IxQrWu1GEAMvM2bY/1tgFeBqiVlyQLNi8JECBGIFhDNyjkSDQVI1INwYk9LOwGqx9C6LvrVSYA6vxrOO57I7gZMwXbHzf9UuZTVuey2nNMpC+SCMkMwE/Pen8K4H5RVkDESV5zKGHnN9lXX8MHz6P83e30WxzYcAJtr8KOeZJVvj4HJTBjFLEWzNQSPevBZIuyEZ3jP4PObcMsG9PCFw0F1bC4BqSYmLSskswrsGLPzGeoRIak8eNSD2x6DLYmj42FYqSGfi1C+3xgK60cAO0KyPxcQ2BMw7EpRC8iWNdK9BaiSeuSYzsGTiVbT2QAtpV3Q+4C9icSPGmMYOloma8pziR+ezQTMAgJG6loWII4ErCZOWuy9uIiV8eeZSFsdSEwJcZoRgNMYTsrawhqBxXuyzMBqVPmLmwZUuygmVZjMdlSLGFQ7RsRQHojHtMSxVVCmh+omFqmKgI2XHeH5KPs9jKfUvuOrTCsbeuOWHYzBoh7TFCUIrs1wz6LSo+btSFJhUn0Ud8oeIJ2ik6RdcKnebbvwiPomzpBfAe2hklWsnGAg0mJ6rU8Sk+1SmaumgbHF4QJN2sv6I140GHOfZQiMMhCx3NqfgTXXMQ0C2gNItjYdN5Ylehxu6TlODMAJUD3WFo973QQramN+bssbc4vsTgC9J9XuAKuqg/6BCmEMmcSWywAIDk2KCQ/V9dvcPnORyP9h29hmaQq3NgJvjNCcHqHpZ+BcXHZuvY9kVsJnBFrWSK+MUScJmo0CrvRwNaM6twYQI3t0V5hgi0vsxPa1v1OWgoYD8NUd8HgKGvawPJ0BSQ+uJvQfn0ncpmVRu9h92L0YGvRB955Hc3qIpp+Bag8qa6SX90G1B48G8IVoj1LNSJcVkr0ZaF5K+6paALMxQGUJurps2bNlJWVjQ/a5sVYKBliYLZckwPq6uMSN6SwlvpN6hRzfyqKay/xAAswhN/PARC9ufz+ZRMDrCVp8/lU2k4UhpDQDUkj7VXUClEYst4E+AYBBVkkBI4PaEr7xWBjChDjEHLflTqllB61NsfcmgKdo0WD4Tc8VFjIrTC/Dkl4FSIW/FZTLAqpdSDJz68ptmgBKCQgMqKgfuLY/nSmOhElA5NOMnazqNpbTwLQ9X6tuNiJQ2pV5CrGtBtQjpjQEGRmbbccmKBtK7TlDW/Vg2i9sbYvuEaUJmLTkb6WeA02MaxPWogWC9elTmYw5sU/aToDqcbc45ioYg5unKEA9HHMoK/FUup7V2e5OnT/6+yh21Ixc1wV/I6YgQghvXvl8tQkySdVn1rC4qy9s5FImK6pl8q3Xe2gKh55zcMsarvRI9hdwkwXSsgbGU7jaA6MhUJbw8yXgG2EbASBNJdbSs7CBCiTYAfVGASRAcbVEtVGgWStA4xmWz9pE/tGroHmcNKgaomCRpbr7HJrTI1TrAlKTq2OkO1NJYOkVQCVaqJwKo+3GCylPav2tVa2QJODlEpgt5H9AmFqNPWzBgGtlmVjOQYDIS62vgdZH4Ku1uI69l2PVDWjQExDbNKBBH6ikqpb1DXoFeDpHYEzT5OgkKeZD4pI/GYtcPBFjJyBH7iEN+gKyFnI9AEJyV1h8MXdZOBLWUr73LWCNryOwbgaK0AIkz922cStabyVJwzvhZT82f3d4V+RYxhCHkAVz1cfhAtFurQ61Mq/hvWnd760EHndq2kvcbtaSEhwtcjy3hQ+ggDp2zVtXhFsTLSY6fdftR/mfNHHNFh8mnxUxJyZbxVE8MRkzSrpbFKYQPxO6WKEkkfCPNJX2W8iLIwmTSJxODdRNhjsGdhKjenvtBKgecwtkQ2Q3H092i0FgDDhv6HsdtMOffEub9+SbtfdONfpa9zPq1ziD12SAbiZZaeW+dRhWmwjje940ItFUN0jHJYhkMnOlR7KoUfcTVGsJfEIozw6QX1kgvzAGXdwG749DNruUp62CO9NtbkhikwG9ppGiFL28nfzKGsmVMcoHN9EU4m6khTCR6eP7Uswgem8MdFO/B9xzDvX5dVRrGdyiRn51Dnd5T8T4e70QUsHK/Lgr+6DpAmxyT1kKNCwyRloSlbXEKzNLbGpwwxo7Jr/KwoJDQhUvS9FdHQwEwFgsKghcV0AtbmPUNVAqUMlS6b+6BuVFG5dsbvTb4TbVWENK0kPBLzeNlL0lYcJBELa7abSghALQNGv1NctSwCmh1f5sGk1QYo3zNTNmGRoPa655ZXXtnbX31p5fZRVDkhIoYjENZCGgBnIm6SSLhVCWlCWsQICpgFNrsxy7ZWNtARHc9GyfqTs/SdCJ91yJMzUwHGLAAXn2Qpa+tbcFjx2zScVwaXgmSXeJxhfnZKw2MM5o1RcsztYS/IhCuANF4QkcFdlg7zV2nkKSGqdJ+x2i67NW3GSC5Yl96tkJUH2K2LXjUA8HLgcTtBANXE/25LW6hI9Pwe1/8WdPNRLV7I67oY44N0WjOwE4fxo86gGzJdzuRGI+SattEUTqaPV5WLmNJkAfJo44xnP1/FprPHl8B739vrKBDKQpFg+eQj0QkApmuOkSyccek4pSZRk9oF60Q3uFuDmLHHxqDVQKCKZFKecpcvDZTRGzvyLuVrc7Rf8jjOaeU0h35qAre4DWueeOBBBALoXr9+HvOY3ymaeAxMFnhN7DU9QZIyWGc5F2p3MSDjBbaGY9Ay6VGLy6AZWVXIfGBHOlLm2XCDBjDcewSkCNJBOFfl4uW4ZuOpN71UQTtGV9L5bC0JLG5g4HApxGQ5UcW8KNBqDRlsSs7uzdcqBq7vzAeptgf+c51QpLyzKUMKVeIawbNxrH6tqCE1kqTDcg/ZLnwGIJX9ehjj06TJuB1yhZzPoNBqLaAYgSJ0l9WSYJa9Bnm4Rrt1CM0Hrz+JAw+Ww6puGFsTCMVrmBLaazE8/KbYZ7OHisxBBZHN5D9rcaQxOhGg0FcPqcoctixsDc/k6U5QVakGzgPDHw26Fao8tUZrnxQKV9O+hHOrERcxqKbEDiq23Mj7VrCRIWQ9BqWSTvkXO6cEnk/UqOmTzV7VgAHre43DtoxwKoeu/hvUeaHmzOfD7H0lxoakmSYG1t7dBjLRYL9Hq9a57vRrY5DnbjzGmLLigCFAf3p3YxfSvegUOwahjkjtr+KWcdtH28LL6pDODiVdAlnczzHED7Ow3UTb0xAu1r8o5l/q8yLZFZ7BofqI8pgIXHE/DaAL4iJFfGYUBPTvXB6RBgj95Du0geugLeG4ejtuyvTnRpAj67BT/IxfObq5v/6o6Ax401cJqAexnc+gi8uw+uG/h7tpA+sg2azKWU6LAAJo1k5Uf94wY90OY66q0+llspehfnSPdruPEc2c6etOn0lmzsvUyWV2cSC5umoEFPJubFEpjNwXUDtsS1UHaU5PckF3bJ9HiBSP4nuncBq/vAQgEGkrSfbIK076sKnKdSMna5BM+XAnKt9ruL4vtuxUvvnLDSeh6uqlZ+qHM+VhClZTFNvzWWndLtWWN+AxhtGgG4Jg9HDkisIlLEmmqGvYxxBmzs2RLhfjsH9XsS3zyZtiWCWd3pBgjNbWDsr/dtcYSqkvCLEE+q7KIeiwAN9ZBrp0RZZMgii6ycrHVRUCw46PUIDLVub+dsq4ilIGflXrWvzQgIYVVEQvYacyqQPAohYHW9c6t/GoT80SbGKUimNG3vuy2qSO+LhVcE9QFI3G6IdSWAVxYcIXQg0nS1ClymZHBiT0tz19/k1tm73/1ufOVXfiVOnz6N4XCIF7zgBfiZn/mZzjbf8i3fgnPnzuGBBx4IP3/+z//5A8d6/etfj83NTYxGIzz3uc/Fr/3arz2hbY6DyZh5/UmFdFCQn2hMOHJfPgLA3mwDEQafdkyMBxGK/iMcq5XwJ2vHFKMeaqYCUNXg6UwmnaYBj8fgy9vy3eUd8GQCNDU4ej7YJhdAJp8sCxOcTXIHCPRKspJ5rScTXarMUZoiuzJDdnUOV3kkuzNgXwFfvwe3tQG3uSExnnIkYDhAddcamrUCvi8LWKobmfD7Ih3ltidItifAspL65b0C6ZWJJBotlsI+zuaoHzgDf2ZNa5xrlnuaSub+7hLrf3QJxfseR/G+x8BXdsT9bm5YAzf7Y3Gva4UdXiyFkd4fg7XSE/whCWwMlQfTBcJwANfrwfV7K8ldaquxhAYyre8jkOqXpYDS+RLQcAzqFXJtywrUCJg4UNb0yTRm+Nkcfn8MPx6DFwtVD4hc7yvbs8qh8XIp7KqVFw0JVMosl6X8NLIICGxd4lp5JUDYzwD6owWU9Z1nZfcbdU1raEaahBLC4diabc8KxFyRw+WFxNcmaQucQ3wrtVn4ypqK6kMq35Ms4Chx4iHYWgetDYWFzHMgz+QnLrFqAytrHyyW8IuFVF9rmgCqQ+iAycs1PsSvAmjveXwL4j5BC3plrPDh3qCsWubaaxY+Q+5bFO4gTL9vz0PohAMAaJPLLDSB0ALTeIHS6P3RcAGumzZcKU72OgZmMaq3+ufExO4oUP3pn/5pfMM3fAMee+wxTKdTvO51r8Nf/+t/Hb//+7/f2e4v/sW/iN3d3fDzu7/7u53v/8W/+Bf4oR/6IfzKr/wKZrMZXvva1+IrvuIr8OEPf/imtjkO1pHLuYatllltAegtfroDOwMciLmLv1/d9lPCbkP/3nLTSa5pBORo2Uw2mZ9VPKP1vg8k5ByKe+TYbumR7MzAk2mb3HV1B03GqIcJ/IbEXzKzTI6LpTCx8wUAFmmrjRHgGdVaivm5Hpbn+vCZA2+M4M9tAssS2BsDl7YDsOT5Arw7FrCpsaI0K5H9yUUkkxK0PgKNBtIeZfPc/hzu0p4A29kCXJbCEA76wpSWFbis4KezAMT9ZCo/8wX8dA4MB6B+r8OCHujDfg84f0rL1wJ+uYzA3Mq90V87rxEAyjJQv9+yf0TC7M0Xwigvl60LV6tw0aCvla/SWwNWY3Z31YKr+OA+HMV4ct20fWeMXNgWXRBpTKAmBbIlqSkLLd2mPWaueDtnYPOUtau1EpnhOQWclOdwhYLTPA+yYFzX0tZahfCTlulr3w8Brq5fgLIMLs/D/ff3nUVz31mg1wtgrMPeaogJLAzCQk6yVOvdp1oUQecJogho6/XGpVI5Orb2rRVhiBPSwr2wY3K8YDXvgG+fLVNXsLHddH2NHbX7qO77UIgktIW0vdp/Jo9lMegGtjsLCHdrnt8Te0rYHQWq3//9348v/uIvRr/fR5qmeN3rXockSfDud7/7wLbLa4hS/9AP/RD+1t/6W3jVq16FPM/xnd/5nbjrrrvwIz/yIze1zZ22G2M66VCQetvMJp+wGrZGoAtWOzFSnyL2qXQtgE5Iq59Fv5OCoyRyhx6wCAwAQJZJtj2g7JOXmMteDqIEvUfGoJ1pCy6qWhilIgeNhsA954DTm/C9FL5IQDXDVR5uXsJd2gXGU9DlHfgr2/CzmUg+sYBdScypFYQqQLa4z2UpOqfjqV66l/OWlTBIlQqhp6kwZ2UpMZ57++C9/ZadruvuD3sB2dNZhCgD7SzvQN2ApzPQbCku7PlC9zXmDNE74w8+ZwwBm+trwsYlSfvOG+s2X4SYScoyCZ2Yz8FVJYyexpDeMsC6YpQkeq7rbOiVDbV4zxgchQFGGDlK0pBFDyA8Q/DN4XGZFuOpiy1rDCWJLCwyBW0GpDSJi1VqjBcLYTJrfZ4svEAZQQGPCSi+37bY0PhqANIPm2tAliG9MpZF0XQq4TYEcE+9FZUy0VE4gQFnu3eUZ8LMmh6plVh11H6XZV3AGgAw6UftA2ayWoH1NQ3UADSteIDekSxrY2w9tyyp13fP2PLVIg2AxiEn4b4HNYYQdqCJVo2FhPDhrPBxML5NPycG4BjEqNZ1jclkgv39ffybf/NvcObMGXzxF39xZ5tf/uVfxvr6OtI0xStf+Ur80A/9EF7wghcAAK5cuYKPfvSjePWrX93Z5/M+7/Pw9re//Ya3udN2M/GozFZm9Q49yatMaViJr3weNqbo/yOM4l+625pWZEfe51ZYDLyfBnYjl8qh5OgRW5sLr9HOaxokl/Za8Xi7X3sT5O9/VOSlru7KZxsj+PU+mjMjlKd7IDgkJaNcS5EuGdmkQT6tQNv7wM4+eL5sXYhHyXCxsU2GG+yZcR1NVur32sSePBNAlybCoNU1eFG35UXbmJrDz3lqHeS1r1iASSzmzk0NqmpJwmqaA8wrH/rOrJj34P0xqCgktnJ3LwAUA7J2v+x60DSakJKC53MBGb2esOghHjli2+K/b9DMzS3XHl2XJgdJks0Rs27M4Hll6kJMrfVDHGLCaMOJuAVL1haLS43F4psG7OtoeHGqewr4jSHc7lT0f21BU1fd+GBzY5t8lD4PAuyS1g3vtT8tCUgLW1gsKhcFkqsTkNdkMc+SPJSmaM5tIPnEJVVtGEhBBwt10D6iNBV1h601+CJF8riG7lgiW5YCayMZwsqo1HNcWjVi8I09JaKQaGgESNBGDmEQ3BYFcE6S98wtr88ua3iF6fuCCExV+1ypHJWwvpmGqDbdhVmqiwkD60D7/5EL5RN7OtgdB6q/+Zu/ia/6qq/CeDzG+vo6fuqnfgr33HNP+P7FL34xfuM3fgOf+7mfi0uXLuFv/+2/jS/8wi/Ee9/7Xpw5cwaXLl0CAJw5c6Zz3HPnzgUQeiPbHGbL5bKTyLW/v//JXewRdjOAk8Kq+JY0RWyVHV398lrnNmbo4IfyawxIdTAMQtkhi1fNVt0Khogh7Mv1rt0G2rj9T0aHfSoB2Ru4DrqRDVXbMlijmd3KUJp7Txi2DDyeAGCZ7Pp9NHdtgGYlHBJUI4eaEviUQOSR7SyAK7ugvSn8bKGTJrr3cqV5whAhcjUi1JBnZk0qk+95IRqtDNdmrfdy+GEPuLwDVGgn+APPD7UT+WIJrhoJZyg107mToa2MLgGomi5TZIk317oPBAEkea4xncpSGWjjBvBoJZySBOQSOaYjoKwlvINLSSgi0vr23AUprBoPthi43jtDDpTl6sntbssqRWVddZAl5vZ/gvRjEytMUHAft/2tu4RYTN+CVJcEpQDo4oryDDxbyG2yJLfAJhOSR68KI28yUjFIJWFwg6ubFGil8iyH49jCw1zzFsowmYDSDFRkACWg6VzY+8YDdSV6qTrW+SwBzm0gfaRqVQwyvZdWNEDP74tMGFhTozAQ2nhgvpAKbH7lGatV4kxBdAjHsZAFuyVAm8gUh0lYJSuLD04S0TYNN0RK+MrFaPxq0H5tn1O2BELn9PbbQsu20z42xrwTN3yNheIdsBMd1dtrdxyo/pk/82ewu7uLsizxoz/6o/iKr/gK/Pqv/zo+//M/HwDwzd/8zWHbu+++G//hP/wHnD17Fv/pP/0nvO51rwvf+RWWolYJlNhuZJvYvv/7vx/f8z3f84Sv7XrGxkDekFE0t92CJ5hXfrFM0eueKkwV6ADSo9CuDkgyaFJ3PwasfnUnbMCvrLCvd/1hkNbJ7Ub761N9YOAIUFwTGQGhMo1tG+Z37VfncCBDWSc5NmH9PAM/4xxcA8nerz1ob1/KgXoP7I6RlxXQK5DtXgYaj/r8BqrNAvnDO3CPXwUWpcDgA3JH1jRlSCM0xNBB3ir4bI5A47m4NnNNpmKGP7uG6bM3kS6B3sP7IjXVeMzvH6GYTeHmFkd6WAe1zyHtTYHhAIACgvC8uvbxDixZdAxrLWnrj3pOVVKM8gw8KcF1BVpfA+/uA9REZXE1DlPZOHIiTO+bGoH5qurQdDcawLlEQgeqGsxN8F5ISc8jSqoaiPMevlweCiKMaUXdSKa/S8BHJcTY86WLgpC0FL6Pyn+ai9g3ERksbfb9DOVLnoH86iIk2dGg3/YxszLJBNQVvBZsoCwT4AhIyIeFgFjinR6/TUqLmE4ikbmyWEtzeTcNuJLFCcX6phaSwh5SnSLD8mwOfz7DxngJqhrREXYOVFYAVW3/gOH2Z3B7kBjtuAurCqiqFtjF42SatP2oSgGhlGnQZdV9nDHO9l7pWOxZrq9WHVtL/tLxgDIDzmhDMmIG3G60AWE7twFZq8JF8rwDaFUaiFpgfmJPS7vjQNUsz3N88zd/M37iJ34CP/ETPxGA6qoNh0M84xnPwMc+9jEACOzrxYsXO9tdunQpfHcj2xxm3/Ed34Fv/dZvDX/v7+/jvvvuu8kru5ZdHxl1tVBvEZI6kgW9gR1jEGNGQEfQP/6cklabEmhjkQCdjNDGPnVilLht540wm2ElfxN2JIv8KWB8Y89PpyRq+PCQDS0Tt/PZCrsKgpuV8KfWUJ1fQ3p5grQowL5RwERSZcrcpc4hnc6QeA9M5oeDRF75I6yr2meRLGaPSGJfPeR56hetBNeyQjJvsPbHV4BeAfIAFhV4Zxe9i5dByxJtRR6svB8rwMzAaZq2ZSmTRBKnHAG1Fy3Yx65IXGJY0JHsoywXaWiC5ZsIfqCQAIMkkWSqqpKKVHnWMtcArE48z+ouoOrcRJbLciTJY0mU8FILQyzhCwK8xE3ddem7Xk/kpabTFmwAXXBEBLe5LtqnunAhJMpsRu91h1ltmVwKcZCtnmlIvguLFr03GyM0pwegeQ3uZZg9kKLfz5Bdmgiw2t1vWW47li2mIkbPFBMoPr95eShisRsfyTyp1q6x2URyTqCNB3aJZuT76Jx6zXWNagBwmqE+u4Z0d4lmsy/V0Xb0PlpZ2cYDexM5hjGhoRpV+8wEd7rq9wKycAjhKKtjb2fx3wr0w5h1s7ppFwtowyEAyPNrygemQGAWFrVoQ4WcAyUU9oX+sKPggek8I/URi6YTe1rYsQGqZuPxGLm55w6xy5cv4xOf+ATuv/9+AMDm5iZe9KIX4U1vehO++qu/GoAwp29+85vxDd/wDTe8zWFWFAUKW2k/iXYtJjV27T95C0hjY2WQCYLY5g696QFghZULTANBfJA6EMeMrLkbo9V9h/lkDgeUZAqdFMLgGx3rZpp7KAi/xrZPpUX7gcuKQAl1Pz5ME3XVVhl7io8V7idH3RSdhA5pkPegZQUul0guswAV9gISOI4tJNBoKMzeeHp4FrldwxGXQQFQKCuUZ8Fd7vsZls/aAAjwymhxVYL3xuJObbwAkfkCPJ2DDsYTHN1hzqG+ewP+zAi9nQaYSVEF3loLWpS0PwVmWthgZX9S8ElVBT+fS+wifAtWAbmuRAAR55mUgmWICzVUCVINTwOnCnK5qgVIKXMWgIfWq0dTgxWoUpFr+EIVGEWeTlWhQN5V1+9LjOx8LgtLA0CAAm55d6mnygm1xMlyXR90PR9mxt6FuNYWSFq8JIwhNQZ/UGDx3DNIKof80T0kF/aCm573p23YhYnMK/ALkmvet0lnVhWK9f6aKzqAXGrbaM+btdueFS39KfdOFy4xKLQ4TomZQP9yg+l9Gaq1HOl+2R5PQbktVgI4PYLlPhBWpZJTYcz3vh1ybTwN7KsdOgKuYaFk0lK6mGga8VhYpj/rs0QUig50Fi8u6rMw1gMMCqEEsLhu3Y65aReIzGDOjn5m7oTFMmC38hwnBuAOAtXpdIqv+IqvwLd/+7fjBS94AXZ3d/GGN7wBH/7wh/HjP/7jACRG9Eu+5Evw9/7e38MLX/hCPPTQQ/i7f/fv4uzZs/iar/macKzv/M7vxNd+7dfi1a9+NT7ncz4H//Sf/lMsl0t80zd9001tczvsRkCq/B5vf/Q+N2LmzgNr0oIdcTXJ4TCm0gbAsF8EbKMMUcTZxPZZDGjt/GFfauVIlGEwdzN1QCx0cjWGCN0B+RrgpT35TdhxHhtWgTStfKbhGgboDoDJ6x1+5dlkACDukqTxd+AVBja6587BrY3A8wXcxwQQYmMUZKEse5jLSmL69vYR4uIOOdm12GCZ8yPm0RE8sVZ/qlCe7cM1QLZXAc/alJ2SBLQ2EtfvZB6q4SBxrZs2MJ9HnLTIgdMbaB44A9rbh7+8Le7mxIGbCi5JBTDPF1IYYPXamCUcwFhDW6zpu0M2kWeZhCUAwpItKLiYKUk0uUzjCdEuPuUIHtyQspWr16ILEiIQqXB/koj6QuNl3PASf8hVCQMZPJ4IsHMONBpJkhe4HU8COFNgU4v8UWCzV/tx9d7aQjW0MQapaMeZPAOd2oJzhNEH91CnDZKHrkqVrzSVeGTmluUuCkl0WyyCPitZFjp7AezGONrC3jwHxuSGuEmAfKtAgLppQa0uIoLqgbHFocSqHBqOgCKDzxO4CkhKBuoGyc5UtI+rqgWp8ZhrQBsK1DXMA+BWeB/oeKsMVFLUntZ1r/2sWqlxKIfpKaP2AlgN8NbRYiNN2rhpUHT/jLnVMR7cLqpsrGiEfQ7PjC1AmKNxX89/nMfmE7uldseA6nA4xOtf/3r8k3/yT/DOd74Tw+EQL33pS/G2t70NL33pSwEIo/m93/u9+IEf+AG8853vxNbWFl796lfj537u57C1tRWO9df+2l/DfD7HD/zAD+DixYt48YtfjDe/+c24++67b2qbW21Hg1RqJ/xomyfD1U+BFcBK5aFDAB53dozYzMO2EUaAQtUQBcRWgSUG2JbJ6z0oSobiOO40Pm/jESq9aGxaW/kEB9jCI+0aOOOaFtymhxzvuJjNA9E8Iyb1ZsKl32ioxLXOc5StYmBCAMvwDD+Zapyf3svJXFzVINU5bdpJ8TCSTZ/T6zZdq+UYaCMGXMVALwWvj5DMatCyhk8TkE2w60PwxhB0WSpdUTGC3xiCru5JMti1lAUA+M0hpn/qfhQLQv7QNujx7VDLnl0C1DXmn3YefpSj//AEvFjAXdiRBK74ApnBVTQJE4GKHC7PRNuyEuksni8kmWo6C+1r9SmjFQsRKNGqRRCFEHgpUUqOBLR2FqfyEHFTA9OZSCqlgxZkba7DAfBjkR3y87mCYQ83GkrcLwGUZppYpE9gWQJgWXQ6EjZ9VYs3Zt2iz+QeyvUEoMQRpmUF10UBjPpoehnc41eR7o27ccAGdGzHpgHSBP7+c6DxDLi8qwBcrZbvoXJeIV7TgKqOn9I3rpVmYm7DV5IElFKkhuHbZ1zHQAsZAANoGNWQ0BQMVzaguhbN1vlCzlPkEetpi/oWXNtzxObuj5nd4KU6bHWL9rjxPQj6tCzjeZooSG8EGDPaOFvtI0LEyFoMsF2jIwXALIs2k9MK4QfaxigkIWbNpW0aJnDja+5bb090brnZc5wYgDvs+n/Vq16FV73qVdfc5pWvfCXe+MY3XvdYX/d1X4ev+7qv+6S3uRUmY8bhT3ab8Y4wsFyLdb1pI9dmyMYD5sGGRLtQtw2r8Xi6kidje0IWcjuwBBqO9djBna+sn8VsxQNlHIYQU8phdorae73u+aT60Ab3QxH6nbMDoBThOq+5prnBph9Gbl2rLbQ6cxijQgTOBBSy9+La3lwHpjNNMuH2vh51Qr6ZhRq3izEXMVZlDXdpHy5xgfXn50rpZB4NQI1vBdPLCnj8igDDuLTlYeYc6NxppK4Apx7YWANtT6RYQJ6juf8cwB6LMymKq0swN9h9+Wls/fZSM9INfHH43fhPOK37nqSgtZGEZu/sCsCNyna2C1t7L0jJrJWyrARxpRILe2jZ2ME0S9yrS7eqQVUF5AUw6IPXctCyAMZa7tb7NlSg32/7PM+B5bKtnFR50O4+MBjAndqUkI5YFiuc/lrogzVevWUDg5c6caJH+tBjcFkmYN6AZBKHF0XjnmfAL1DnG6C7TyGblfD74zZxKtqO4bvVlIy1tNhVBb5WwUr6YuWhCf2svg0jYO2+qw5q78IC+VVCuj0Nsk+BSbXdk0Tc6mXVhm3YseqIOQ0AMCpAEK1j5H6ztsjmggjcGsuusaKdamHMCKFdEXi2PpDwCCUZvEmFKQPc+BWlAsj1eNWmtephSQKJK7DrcUByG6QJT+xY27GLUX36WDTZgBXXPQnlTVdNZV86QPLoJq3ErR6CXEg1/ZJkhUGNBr2YKdN9bFUubbLBD93tEB0nxEOtDlBHAO0n0w4FuYSQ0HVcTAHOJ90minnYG91eG3CA5mDwxgizl96F3od3kTy6DQwK1OfXkXx8Li7DCKAdsBsB3oft4xnsq7ZVoyH82Q1gOgfNS/DaAH5rhGZdgKpblEBZd9zx8hh7mfiPvHYCn1rH7IE1lFsJ+g/P4bbHmmkPcFkheeQKAGDzggLMLMHQNcDeJMjvsIUX6PWKLJMTpq6ugaoKblouyzbB0GL+kkS2zyLWbhV4kFMsYZ0p5+F4RaKSTWG7pgFXJNJK3gPTg4VWTIQeAdRrGxlBToqbBn5vH7RYwp07I2EWzF1W9RrjURtL63VtbDJVrDiGNTELbT14u4n2i4U6GZBnD64Y+Sd2RPC/quHyXJjZTBUKLLGHdTGt4vXU60kIQZapzu5SwWOm7VOlhOWyDR2JkbWNv0FtS1HrokTvI1fl/DEATJNIqi9azKepJitRWHSQI3C9kiQVM7Dab/YZEaIksihuNTC9+oEC9M7UYddl7dGfwIJnmlClMlQoSwHGuphAo4yrufd1MXJ4YiYAqxlhMb3HxAi49fJUt/bwTyk7Aap3wDq1tzsTc5fpuGkEwgf/6B7XgEW0oQ1Q+nmYQA8eUABKcG9FVWds/yDCfTAWL0yi8UQVr/jD6ey7mGGNV/w32glP9mt+jEBqdGkUYcWjbtv1D0fXB7zhNl3HBecSuAYY/t6joLyQ+vYgJI9tg3f2cM1QBMYBUHTDtio2P+jDDwukezP4zRG4SEGVR/rYrmwznopovoKrayb4dBpMUoaVHAYf3UX+2D5oeyrtdjpBa2Z7iGmsauR/cjECL2hljOwnlNL04FqeeR5PZDsrHOCV6cozibX0jRYo0IxphiRDmfYmGKBEQgFCfKUTPVsDeauxiuYd8aoHO63A+5Nu/9g77Eg0ZL1XndwEyPvCdBrIKUvwzq4kVwEtgAIOB6wxILE4SSCKeaeVJCbdLJTwFAAYpO+89rN5ccACwBMHnD8Nqhrpv7Js3fgRMpOFlTCc1OtJ1SWVhhL1EmEMKc76t0pLwVsWLcqJ1BUesZS1Av4iD9Ji3YU+unJOAYjq+ZJEntDVRb0xwHbueGyPyAgqsrYd1ueWIJck8fTQtie+f/a/SV7Zs1/XbVGCug5jDOW5KEpYOIa8hECCNmnMrtF7sEtUyxUn9jS1E6B6Wy1mUdEdVGCDcXf7drNDQOahxt0BxdiEziGjQT+wDXygPR0zl6S5ycw9GrvlSXT2ZBXeDmIUwEkMOFfOFX2m82n72U1jl6NGNL7GdzdixwWpRhaHbPCNcaIdF/+1uiPGpNdj482GPTTrPalOtSjlmSlrYLFQlvyI/Z4ISKXD3hkAvRzYGCIZL8F5imZrAFexxIgOhdLy4yl4phJFiWp8HpZlS8qUqSQSDfrAzhiD/7mPBE6Twer2oU0dcGoTmMwkgcpBGL9a3ZqmearH9s+8Cw4Eurgj781iEd7FTsKKWeymLivwxrpM5pOZACdAs/+VUbQa7XbKPDtQGSskMUZFEtpEHpI4ztV7Y+yrJYnVNThJQE0j50yS0C9+OgPNFuqpic59RKwJOdKKVh5tMp+OT5aZHxKrtDnetwCW26Sf9jOEkCZeLoF9gGhNQhZM/5QZVNuxTMvZWGwnt81K7WaZhEd4DyStegBlmZ5b97VSwdzG2lt1qzYWnoFlpeELtjCJWEu9/KBdmiQgNGDWQdJBY2Q1rprQSaoKihiJVgmL4q8lJjkRNlnDGkxJghKFB2nS5jfErG08QJgGqvdtuMRqYQGVcAvfed+eW59TLqXdAfg3HuAK7I9Z1v/15ssn6xwnBuAEqN4WE8KCdJWPQ4HatXCAjOd01Lh+8GykzIllu+oqta26AgAquG8umMMmxagBlpRFeS6Dm3MyOZkrN0laLbwVIel24DaWARFmtD+6F8Y20D+hd5U7/3Wv5UYQ2tGHPLZ21Lh5GBMSfWiVgIip1SLVTSieiK5n5IB+Dr85FFf4oA/sTwCn4AtAG6t8SNtvsoMpPDsrF9gr4O/aAqcMDAdoBuvwvRTZhX3wdAYuzsumCpqlxGgCVP5g20gkjKhXgBdL+LUe6mecQvroDtz2BJy2YAwMYGMkBQV29oSxJAL1+hJbWpbdmMaiUBCcAFf3IpdxoLyOuG5q3dNJArIqYM7CZMyV70IIj9Vdl2IAZbfqFLVsOgGiMqCDkV8s5NhxeESWgbY2JDGmqrXSmIC7UNVI3/UgXcUqN3TAIkZuZQA0QGWu+yDTZEynuYztwbfxJFYysQz7WNLKKuBVFfzlbdCgJ4sPY8ENZBuQSlIZJ5smhDpQr9CxMEoO8i2gJUAlr1hjitGGVNn1GuhkaOlYA+Roxz1ToDCwbWytAlzSLgyVqPR+SniWAW2Vk7MuMkkvkhyDoL4C7T9lZUOcrzGk+uyFaw0eOOl462owtPqagvNofiHN/JcwEZa+ajTxjzRWmqKs/7iAQV2cALensZ0A1dtmR/hPwkdHvYTtPt33NNCyKx+tlCSNXUVEbbxXpATQZlmuNENZUkpkMqcskwB4c8mYC5BImNQqYpcAhHi6AJBJpXtW45F856REUQjCjZDIwWL29YidrtXN3V9WdjoGg+R1CGHzBh6I2IhYdUbEdkePZMf1f7MgNcvAd58GZgu4x7fl+WtkocE1axlIHA5S42u7nhEEaHQ2bhvNawPUz78XTU8WUS7N4fbnSC/swaPG5HPvx/hlovJBqROwaGxa5/2kcF3+3Bacc6ArDXB+C+Q93GQhz3/ZZl2LC9aBE9e6UJlbYfnQVBbwlwp75R67KgC2iYGytKUbX6pgR2M2qd8T4GRyXwFc6bPqnNZd5/a8jIMhDocsYti8IE3TZnhLA0Tv9u6zoMaDL1xp33WWqkdBg5YINBgAs9nBBKprAY4IDIUCICEsIZJPCmOPi8YZAcQdSScNIWLWWFddULOdCyShL40PfcOsGf4MYamdgH5qRAsWlo3vHEIGvoUahMWB1zhjCi5xMtYxZuMYnfFRWHktAmF9YvJOvgHYwQ8LUJWCllUUSuWjmxn1mfZh69SScZWyFHBRAQZ1/XM0V8gzLcmGZPfNQlaAIBcWTqXkQvA+2DGa6J7YWGCxzBHAt3lqVU0BQNvOY2InJVRvr50A1dtidMg8GCGwCEgceBkJCJI/0UC0OonZxoGYYA/EC22r1GMbaEZ2mBwPANRWeoqKQoBqmERa2RwDh1KaTweqQJDoRbvOhbcDtp63o5NqTB+RVCkBANwAsxpitqIJ4JrGh/95o+DsdlsEJg8FkbZIsd+5+7lNkIE5jY4b+txi68L28bF0H83UFRbIoTmzBhoM4K7ui9h9rxC2plKmKU07cZaHXdeNLgIOXJuZc/CbQ/j7zyHdX4CqBKgZzb0Z5vekoL1N0HiG4cenWKulOh2vDbD9JfeiPk0oHiKsvW9PWNK6ao95/3nwxgD0+C6orpE+fBXJshQJJAWDIUbFe1BZg5IMPla9ULYrPP32i8ZUiqu/BRByHxDFinK7TyLgmgZ9BD3KLBOX9rJs3eWMcH+sXHF4Vw+7AdSWcKW6AkDgNGLvYrCcZxHIWomJZAbP5iFmlc9sAI9XXf3Uw8CGjkmUZoHRNaAoz6Iwf7ZIEZbVqfgIBTaXuWmvoxFZKdMtbRfvDpSn8lxqSV2uovupg5fr9+T8pq0bj512Hc4BKbX7eq+hT3ajWcA1Rfdz1V1un9kYmLoAzoI2qQFER+BehuXdI/iU0H9oDLcoOwAUpDGf4VykYFXP2yhbWkjYAtUULV6UzLA+TTQ21BY4MYj1vmXtI1As7SYA7gBJEbaz/1X7N1yj/cRhHXGowQlwe9raCVC9XWYvZDzYGT47igoDooH9+m9pwGrtCcPnMnbpyjs+1AGsq4OVlbLLs3Bg9pJ00HEHBlefD80NLIgOjkGEHGizcBsOA16IXXTtIA1jdbyWfIzbHS4o6tsuHXhTAKhjx2jVHizcO/uT23t8FLC2zzXxLdT4JoiAu22iTBCRujSJwAmBqkaF5lPwdCr3nAg87IFm6sbeHIFOb4IubAPDPujMFthBwMDOBNhrBLguljpvHwSrgcmNFi6HOgvCe9K9P36QY/nie9CcXkc6reH2plg8cwtJncDtLZBfaZCAkT60B9qbgjZVUmk8x9ofPw5sjeCoB1czsDbA8sFTICbkV0QvNPnoBXl+Bz0pharJH5RlWjDAA1kiCUezuVxrxFoGHdD4cjiiY5r28SVlZSnPQaMBeG8iWdIs98mNRhJSYQlbaSrgZaqVl/JMXdgRSwW0klG26A0hSNEzFbmJQRSE7wWMGOMMSSQqK9CyPugZAVrQkySg6eIgmxpuZvf85BIB4FYYwEALAVYOV+KIfWdfw2MYDkBRYpewgE61dVk9QLXq9WZwvR78PafBnuF2JpL0Z6U/Hcnf9t5Yn1hjg3ZtBO4NkNrCwuIxrZGxLFgM2AJDqYNWo25zO0+aqoeigSBzoB4kKDdSFNu5yInF4yY0jEuBrYFJsntvYVp2XXFYARTnktyPVqaNwz3thDkkieYfRPuTFHhAQtF1oQWtnTnQxnfWc9qCQO+9S9pwuZjcOA6m65Bbfo4TA3ACVG+zHRygAURJHAefTL4ZwOU0vswGA2VMJcE0ni354CEJAjCoHRjIJHC8uLFCbFvc/iYafFZddQFPyvls0OF4smEEKRayajJAC4gdQJ6UHY7Zm9WOin75FHzBVzGaPRdh+qSVjc0N2XiwL9uJJU2lRKbFiPXarHE0AixDXFqRtRWQikJ+H8/lu34Pzbk1JPMSLstRPusc3KJG+oGHpX2JA4YDiWFkHHzm7SLC3O2AIgOWZWfNccD9216kfJanSC7tI//4blgADX9/Bj/IQCA0p0aoNghJttKBVYX04gy4PBcArkxSkRCQ5aDtPVAp1Zj86Q1g1Adtq5YoOXlONa6Od6cIITarzM9RzyIjeBZYFxDIUtDaULLypzPJ6jf5N+eAPAXP51LpKklAvaSVMapruY+qOymyRSZKbwtWZSHTTIXcG0kGi937oc3xex4tDMsSNFkAXkqjUp4LmFsJKeCyBHb2OgycNqK997FpdSNWl39or4YoCdhsmT9LTgJBxo26CSFNbjgE+gUwm4fjcF2Ljqu5kL0H7U3Bp9bES2Bxk+buBrXx9yThAUHSydrfCIMrXgMf3NqhUlgUTxoY2OBSVyAYhQsceGg8S1nfuCzpbIl8e4nF6RS+SJFoW8iCLswTZqZEQaAvjPmVB1CeE+tjsIBZu+WNB0cA0hZS3KBVPACkb7VELocStPGcxu37YWa5DBq+Ebx1K2FjrNdGSbs4OLGnn50A1dtp9p51goYArMxm7Zh1+Cx3INNZmY8w8RPJIHMgk9nYRmPiONo/YmBIQaNmaFrcKTkn41jD3aQFS9oyl1zUroCjnE04vnVLWkKBDa4uCd9RrwckdYiTY0AE2s31Z9e5CkxvBtgfdzO26CCR2G6iz5GsQyL2wRJAOgy+D6UvxZWsMX+Wob1cyg9IgOaVHT2xslf9AtzPkHgHPruB5NEd0HQBDPpIroyRzCVzGVkq7RpPViasTsO7BPmgB785gHtsO1wziIStTBN55noZMOjJ5DpfAvszuL058r05kCSozwzAm0PUoxR+5EAv7qO5lKH3vm3sf9l5FO89A7aFkLUpeDVUL/LSDgIb6XQiv7wj3WcZ2QSpdT+bHXpjDrDEhxg5p9qddQCt1CuEgd6fqLSPb9m7xoN39uWYRSELuWkDoiGsFjsVBUhdtOwr+FJllGyit/faJICANmGn457gkLy0Gl7EdSOJOp4AV8OdOw3en8Lvj9FhzFmSYVyv12aC6+eHLTqCRBhpWdj4ufHoAhi040lo9vpIEsv29jWcwqvqgoNVjZIEIomx56oCTefg9QH8Wg+uaSTznn0Ic2IDUaFbVlaKpiNr8f6WUFrX2hfGdCpQS1MgTVCd7qNey5HWDm68QLI3D2oCALqJp3FcaEMAarhFBZ8S6oKQ2X10JPfE2hqDZDMfExisz7xvF7vxA2tziRY/AHMAraQDEvsmKoPdsvft8xWNR3brlVkN4V7hXY/mDcg8QQ2FqofxXHIcjMzjd4vPcWJiJ0D1dtrqAB2BgM5HRwJUjZfSjPv2aBQdS1bFncxeO6SJbgbPS/R7SErQUoBpKoOtsRjG/ChYDE209sRB8dF1htiwEH/kwyBI5MBoWRLJZHYhkcIG36APaONuzLBdIz/nllsnZi38E2+AaJY7Gm0eYZ0EpyN2PcA2sjJPHghlGq0padoBUNzLQE7c1l1GjLt/Zxk4JZSfdg7p1Rn4wh7ooQthMuXpDO4jCwG3EJ1K3lyTONWqPjjJR6cBQQBE3cBdEECIfk8BFYEzB58Rqmefw+J8gnRB8Alh8KFduDxBtZGC1/oorlQonzlCsvDIHtsDHqvhmxwYJEgvTjF8cyO6rs8YxR0XNUL6mutGEpU2RsD+FGBxkYYYPbsn17uXhC7QI4TFJIPbJC4fxQ9WNfjytiwK01QSXopCklyWGj6ROKkcBb2fZalMKomGqi5GOiEHxBLaEVeRswpLxryGeFMDSz4wdPGCFp7B+xONVfVyr0CgshS2t3N/W8WBtl8OWXWxb93V9nxy9KDCfm1jSEPIETSzHgw+tSHJmntjoCPX1USSSy7yDMmBp88aYbk5wqk/2Eey2y4+KFw/EEqKdu6xPkOhiAVCieAQm62gkZIEfmMIv9bD7L4+lqdSFLse1PQw+kiCZH+u3gQWRjx0IUdMMgONh9ubI5uso1rP0Bv0ZLFYRvGetsAJccqyawjLMGIihE/w0Yy3l1wHuY62KlecSEtp2r4fmvjFnqXsKRCSqEj7K0im2fvAPhSOsMu0/QIpc3CqPLGnkZ0A1dtpsdvoCEBKCmwOAlaKBqJmJeMy1i0FuiXowj8HjaJfXARSLWHC4ofUpckxi4o22Sp8lrg2tsniVolkIjKwaSvpSBoruH0IMI09bnxgWbhuQr9YrJjMqaso9TaPZDaZHrnSP/o+X/u4KyD1EGv7o/NpG3MW7WsTNpdVWEhQmoDmZTuxXeNEVrqxePejLZghkqz4PIErG2DUx/xFZ9F/xyPgqpbJU+PtVhlvjp5NIgKf3oDfHMF99HEF1ImwYlUlxC8Rkp0ZikGB5UvuhS8SLO9bh9sqxGN+aQreHGHwrgughcgvUZaCPrwDfmAd/twG0nkFzhM4nZApXmCd3gCmc2XgtE791d0WOIG7HoTr3DvpNtLqbfqe9nqgtSF4NgfG0zakot8LTHfI9i4lYYvUPR+AmUonIU2FfWUO8ZxuMAAvl6HWfSfhzsJqjJ3T+EnKRcXDzxmoo7EpfsgUzBkDTAB4fywxnFkK7E8l6VHB84HuOJCtfXgfmoxTy8JFi7uAWaM21txi2dEA1X2bWN49wvBjGZKG4ScTlT1yQT81KCMYs+w96NFLyHuM6TNOoekncDPR66SlhH20CU8y/nUSUq2N5nVqdGGfZqoKUYEyBjJh8Wm2QFLWGNU1stkIPnUSV10qmxonTxnz6QiihN8uqNx4jo33bIOzVN5hY0qtiwLDq2DQ4qpVvSD0OesYjeiaVmKA20ReUgAs2wdXvD1jNbegszEPWXQ96nULC5csC+cjjs5v8li2QGALTThmKNXj1pMkd5KEOWZ2AlTvhN0AeGkBazSwKMiTWt/R4cIcyiuB9RS59tBWr4nBjcVL2YcGMptGXDsmX9Vhf6kFw6wl/AzkWoYsWFbg4BZ06qDD0IncXMrGduj+bCLZQbInqtzFiID+zffrk2/XBpRPyLR7meKPYjoZGi+nf6apiqD7iPlDJyYuhAgUmbj650s5rlV84fZ+HLi82ULOlyWqkSiTavm8c9j+/DM4+6sXkTxyFdmeBw364N0xaL48NNmmBRvRtboEtDNtGZ5J+7t8wMBiCSor5O95FHxmE9MXrIHrBqM/vAI4h2qzD5cl4JnSP3mG+q4N+MTBj1KQB6qzA/hcgUjRk4zvsgJ2xvIcDwcSZjCeisdCQyjYmLHOutG1C6vQTI4uT0p9Uq8n17g2AqpaYn29F9kqA7WDPrAQQEGJAw0H8FPJnocxqVCReQawXMIvl2GhRIOeaLpOosx+0kmeVAs2y2SBoDJM8j6i63I+wHRyAHWkIRO8XMJc536xAE1n8s4eljRlx1j17BxmwTMQg8N47JO/yfodqt1JhPruLex+xgY4IfQeS5DYAiNk8bswvJGT4g4csazZhy8ie3Yf4+dtYO0DhOzqNIy75n4Ni2aKkqpsXDwA7mX8lFLTadCzpqoBGka6w3AVpFpaWcs7ZWN1vKBnBZfwEvpitKL3cFf225CGNAH3c4AK0GwhnioLsTKFDlNOCMA6loRp73V7LdRhg0OJVyUwwv1ihMVUG3PaLpgpsxAy0U8NiW7qfQtnc+ZtQHv9cZGMcN9P7OloJ0D1mFvrPtQBU8dyqb4Sr34jOSkFnlzV7WAV9qd2kDFXP9mxLIFAJ7y4hngAM6FlaF1IaNsRBjodENnYqyQE41Pjg1uMiMLgxFUFVFhhbtGC02vayj4He7IdkJ8KFk+IwVybpW+yMQZggM4EJ4fQBCWGZHE7B5w9Je5ellg+NiZsxSXLaYL6gdPgNAVSh2aUwg8zDP/oCub35GhGOfzmCMUVDx71gcYj/dBjQRHCtBQ7xqY2QIBDe74ruyvAxB3cV/d3V8egRYO1nQlodwxUDXith9kDPaxdzOBPn0JSCntYbkqoQ3phgvJsgSbVtlpfMStYLYFejvL598DnhN4fXwCPBayQZl1zJZndoj+pAKiuZRIm0rKaBwEZ5bmCRhWsr2tJlnJRyc6qEiA5X8DXdcuG1tqHGqcq7ZF4XS7LAECp15NysCqYHktdsQGJJAH1+214jVVBom57Vx5CiUm0ikWlFjGIBPGlVGZ3n+7Jb8BsHNHfO56e8CxTADxtSVkWkL7eBztg/b27SC+MNabet8wpy2JYEoAANNSWkNUFXzpj7L0wRT3awqnfY2SXJ93xzI4VW6wP7azqE+TcGuNPqYVY+HafxosGKrNImjFa0GeJjDHos3djNeyhqcGJAw8LlPduIZ1VSBhAKWFhAYymSXscl+h9raN+jNUU9Bbam5okEje9OQI1DOzutyw5tVJWwUMQ5zkUuSTbJQkwKED7U4nrNmUFQlSURkgN4kRyEmq04WQxi31M7CRG9fbaCVC9HaYrUwBHDt6tq58OvJOxG4TjwTPsokkCxlDWGiflSBiEVR3LeFKwj0zGxVhPc9E4EQ6XKiPR/qaxZ5MJRd8FvOFkEA5VWLidaCy0wDaOY2ptrou7yhjYaMEfrv96FrvFnqrWGbCpfQ5YWS6gncjsWRj0ZAKtNZu/rkGTGXhZiQu6EzphM5Q+g6MBcOYUsktj8M4U6aMVCATOUmQLApFH/pHH4aYaI9l4oFle7yLktqUJsDYA9gwMrMbHHcLEOtEQ5bIET+egmSRQ0WgIP8ox/PAC1d1r2PnKAQbvTTB8/xLpXoV04UG1R3Z5DioZtGGTs7ZZPQD1s84DRY50Vkq/Teea1FeABz0szxboPbIPWlTBzSvdHYEpUCesQbLxVbpobxLuAZcVTKSf0lQ9F8bwCWtn95MBSZDS94wh7JMbDoW9XizA+2Nhr4laFttuJ6FNqCyXwSvDyt6ai5kKSWBaddUzs7CujuS+eIaPi3ocsJsEqXbfzY9vLLWNG9aXNs6wBxV5kAlr7t3C7kvXkc4b9D66DTIFBgXU0id1OwZb6JCSjNDF83Irgy8IbtnALbvVuAQj+tCnZP3idRHh6/aabUxMlUmNQqYovtY00bFRWdQg06cg1NhaZ9ce9am9+zZeLyqkj20jmdeqzhI9gwYEzbw+82miyVncVquqKv1elSTSFFgfSXwpSMog19G1WuEEu42pjjvWL9BjBp1akoVbqObVLgI60lU677TPhr+55+nEPuXsBKjeJrNBc9WlddB45Z2MNARXj6kvNRUqlWOAlAEkusqHvvzK/ISBxoAmEcytQomc70BgvVOIYeez8AIL1LdAeSKZlEP4gA74qplqpfLCYBZcSe35jiyd2iFz4z+uN4DpbH3dfj/OZuDfQL2JHdpErvePdAIyKaO1AWhZS8LNUhhVXlgc41F9QeA8xfQzzyGfVHCX98BliWZrAKoZy2efQv8DV5Cqe/ymVgwEcJaC7zkN72uke4dtcFi4AEmMZ78n7V5TF/2gB+73wFTDDwukF/cweluBZLpAemkOnxPmzxgh3yHQ3hTZ1TmStV05otV4dw60PsLynhGGF0q4K/uSXJaqhnBRgLIM+ce3wbNlV/gcBK4szEIm3gD1SZlI5wJzLUDAFnVtv5FLwF7AH8eAJLr1QnIJaBQXvrZD66SHd8r6K5F3kVKNaS1yYX1VuUDc0kkLpqo6aGKGs9ti0kkGNt8KwGD9CEiyEgFB65UIpqnJ7EGs45UyyTi/heWDmyDvsP6HF0H7My3GIP0aFtqx/mcnrEAWcewAJIyNP6mx/r49uPGidf3b2FtWCvwSsHMSumGubUDHQ4TxVBhNXdCUyp73+0EWDHUDXyRohhmSKZBMo2RUZsngNxd6AMAuXFpnQTBfIJm1C1cBuHYsdF/RDigEulreCvCzDBgN4DcGaIoM6YUdidleDROJFxOMdu5JXZhrTO2B6qbd1pQsyKu6RPQshAU4tzkTFr5wnMDq7ZhOjtHl3mk7Aaq3yUKW5CET+0Fg2i4ubVsZMKP9jNUscglMJxXpNr1BBYxUVuBGkmZEpzSTbdJEtjHgGLOsVVtXO8Q2WuyYlQpEPKBQ++Ladeq1StUYZYOqWn6PA+3tnLG7i9tTdMyqANkgeyMvsjG5T+m3Xjsk9E00obkWEIUFRC7lETEr21hIZUoMpIb4zOh5oizD8tmn0ZxeQ7PVA3Z3wXUNf34TPMzhHtlB7/cf6sa33RBAbYE2VTXokctwB+JX6ZAd268C2zMaoHrwPKrNAumsAZU1fJED3mP+vNPIH5miGSSYPbMHogzZpTGSxyfwd22i3hiAM000KYoQP8frIwwulqDxXBmgGlgbKqhrgOkMbrpoJZYMPaauZaxjN3CSiGi/AoXwXGvMnRsOhJlcLKJYVQ56qgSE+xtq3du9txbYQs/J+wpAYxAVnGnCFVd1ezyScYiyLDC5puTBpSWh5XCkddeVMQtM8bWAgoEi4IjFxmH3VTw+wd1vVaRC1jsJD+lUIkrDiVBVch2Xd5GeG8LNnYCj6HmhJGvj5VWPGURBAcCSy2htgNln3o3q3hTr/2OO5PJ+q6KgYyI5Bw6FTzgoJXQKlFDbToaAVK4qoFQGHpIp74YDoMhRDzNMnreBauCw9vASvU/sgRatlmsgEYBQZjTcB+8h7IGFE3ALNsHtOBlkrrRTAJi2toVDSH8nACKg7D2wLOF2Ga5uVNO6ao+nx6FeTxZixrAbCdJIphEbg62Li5aAsEUVt8oMxhCH6VGfe9/IAnxFTebEnl52AlRvhzHUvXP45N6+fy1YtDEnPgjZgKMMKfWKNslhsZQBnDVQPSORFTFJEnPr2fEB2YYi0GgrYmtnopp5psEYwgNaN1jrzjcpFnUbwcGylMNABpl4Q0yWJUwF0Bt3A7WDVhDajgbKANqp+/mBvn8qA9TYomeHW91JYW4aUEaiX1rVIguFuk2Ks+QS1UgNoMiO6Rz4njNAWSFdAtmHLqP/PnGZy/0iZA/vaHb3UaU4jzDn0Nx/Bu6xHYnLAzT2EtH91cneXwPgNA0wHMCf28T87j6ymUdTJKBcGJd0ewJay1F8bAeL8wWWzxyg9+FdJBfVFTydozm/jvrsmhwvS9sF3niGpKzBu/uy7eY6+MymtLeqgL1JFHKjz6UuDKjIQYW4OLmu5X3UmD1f1y3jxrpPryfnTRNQVbflOzvX3jJPBN+6cuM+M2bMK5S0hJ1+T4oRNI2cx3v4zTW4ealxtFGsZVkLoGLLtHZhURm/69dlUp2DGwyCJqwvlzf03rWJnwZSxFMQ6q7ZwtgOZTGVVnwkIaSzBqff/CgwXSggde1+Fu9pbGwUEsBNg+b8GiZ/6h5w0cPmOxYoHh6DbGiLQZHdeysLTCQLfgOEtr1l22v8PZdlt3ys3UAGqGlQXJiiv/TIJrUwtsZOWIiXVWwy0sBiSW3YC0USIoAXchIQsv1Du3yrphLCVdJUK3b5IFlmVexIVTDCnIPoHYgSZ8m8eaA2HrauQyEBJAlo0BP239QRSMG2HbupuwVlmGFZ75zYPbjuI3X7bDUE71ad48QAnADV22fXZPUiUAZqB1mgdZcERlMzWHWS5Vpcu63LS9mXptHJJppkGLAkA7b4Ue9lADYpFIsbjWNJbaA0AK0DEvWkHjaXmkjCDNQ6iZBrJYBIE7tCMzyoNgb1sL4CWs1Xagfnwzv2eA1gn4zZBHSoGetE2tXGqEkMcZiE+z0Ie+MBXwGFlFn0Kpsj044wZtW5IbKdEs35TbilSFclD18JUmKhothjVw5RfriOJYlM5oslksd2gLI+5Nr0/iaJAuCjr52SFKgqlBspmgIAHJrCoditkW8v4fsZsscWwHiKom5QfGxXJn9Armuawc8q+GEhn83n8lz1CgGtqmZAg76W02xE/qcSkN8m/el7qbJpIoAv74IsGhl+Vmoioo8WaXLvgqxUVQtrGfrUgADAYLmnYeFqYMWFzchRKOpBWSpqAokLIBjQWMCmAXb24OdLSeJR1QO/WARlDyIH5FJWlMsK3FTCCqssGV9rAZEkcBvrwtbvj2/cRUsKUnxUicq+YxP9tyQffU5Md1PHNudS0KNXgcmsVTRRoBTAVppqcYBum3i9j91X34vEp1j/4D7S7ZkupCIZp3gxDsj4qHHNxgTHiwg2Ca+yknXJYACT5pMiBAbAPNKrU6S785UFt/6uZAMjyo6PQ05s4W5gWtVZ4JI2LMjOZTGzvmmZYFUXCFJnAJBwKPxB/R7YkSiDmPckcaFkL/mV+5tnovzS+LZiVeyhI5V8s9jb4MWxZ8gB7LSNvl24Jq6tmnVYcuaJPW3sBKjeFrveCyYsWauBye2AZFne+h3XUrfbcsJDDfd4rDO28kAmJ2BlBilJZBVrunVapYgjBtZ+LOSAiCSkKdHKLZoUwssyYne4rU/tWcIOLAuXo/bJL+iWdrU2UtuG1UHx0K79FBnArunZ4sDKddgi29UegTQBm05nngNZAn96Dc1AtHFpukA2a4DFAum0BlUNkou74na0CX61T1fKY173MgZ9NHdtAfMl3IWlVPw5FKTKeQII7HxN7XObiHpB9cBZ1Bs9jD4yxeTBNSkEsJYgu+yBagkQUD73LmDYAy8WKD50KYBLrmpkH3oc9Py75fhFAZzZEuAxmUlyGQArWymTpNPSmr59ZhVIhgbXtbxHqtlplasAyMReVSEpyxJb/GQaeT9c9I7ppTsS0JEmQJ6Cal1MsrpbzfXtnGb+q0ZqkUsowb7cS0pTiUluBIxSkQvoWWH6GAyXpsrYNYFxNZf10Tea4Ho9GRfG41b54FpA1RZXcThIrOEc7r2++2HRChXr53A//N4+YrWA0A/G5hmjZ4vrCHD7u0+Dshzr751Ihr+Foui5TT6vDbkgzeRHeO/08Q0LSC5S8OYIbnsiz/SgD6oqUONFQmq+kB08A1Dm08Z8CCvKumAjZX7NFS9gMgJtFI2RGucbxlgtodsuBiL5K6eel1QWh1Q3slAbDcC9HEyManOA5ekcxZUl8ssTYLYEr/X12A7Yk+c3nle4LOEtbtfC0iyW2MgQhpw/STTcVtvYkxwLYpYFJAO8WMocNxzIsery6GfqxD7l7QSo3gFrF8MRS+ZckBzqbssKOtGCR6LWjR+HE9iAGh/EEgmiqiQS+9Z0B2dzBzVNYDg6q/2w4GdhcryU2wxSUmHScco2xckhK8lZdl3WB9Fk1LIB1+3Flf+fJhbHdloMXZ5pydlEQAihjXHcG4N295Fye4+8LmRoDMkwX3Ql0G7aDHTkmbi8hz34QYb0ExfRxshFtjECQKJXalXLDju3E4aY+n3UZ0aoT/XR+/BVJPMKwwRY3DOEd0A6WcLtzuHLEv7UCPAlaG8uz+DGGup7NjB77gi9R8vwLPrMgRMHmkmcKC+WAoTm8/ZdnC9aT0UErDpNJSBUAOM2/q/dRjPxyxJubQ08m8s9slcsvBuyDyWibkDDAdAr4Ic53KIWYf3ZTBQeFKgwSxUwe8f93j4wX4q3Qz0uBlgpz+V5KMu2vKW6jgMLWtcIAuvRO3ykMYOXS3grJXs9JlXjoNtYa4TzmQC/fcd1vGAG2GIo7XqU/WOvsfep6ghXldwPTfwhSy5MEonZ9RJCxUWGjQ/MkV6eCGsYXROAFhDbzQnMagsQO2MYIExjw/DrfVAl8dOoHZCZxnSirKYxxHr4CECH8sbmwbA+sffZxnHzehihYUVaLGHV3ivzlDErI+qAPAdvDGQcrxu4sgb3c1SbffgiQX55Cs4SpIsmeNZodwKAQBrjzdZ+hoZ9SVx0qIpm1dTsvue5PNeDfpsgZX2q4JzzFFhfE7YXkOczSYWNTqnt+2NgxNGUdQvPcWJiJ0D1DhjZ5JY6ecHVBQPftJNYHKsTjY8ArjEhRBsFVkJdKWmisUE6qBpDAIkb5abpgtRwLv2HITKqpJOrD1/ah7qo90dXOqLuQN8NjtdR72bicp6WMTx6zVHCDFTsP/SHTQJN3c6vYfGx0sfBLQ2g15c41jhpSJMdyLlDqgypbY7QDFIklyYCGq7uId3eP8jEEonE1GzZZq0Td3NvVCuThn3wqA8/7IEaDz/qofeuh4HpHK7fR9bvoT41gHfCEvNkBnJOkmHYA04KS2B/itQ36OWEpCTUaxLTjVolofYnwS3LnoGmkgl3MhPWiEgSz2wyDdcCJcEUPK0NZeKfzbpJISv3LsQLr5gxeJQkQL9A+eBZuEWNZFKCU8nep0Ef5D38VKTFKMvETbsspa1lqRWnJEbVz+fSl2kSAGrIwg6aoArM6kaYYQshseSV67xj1wWzscUJlHpuMvd/qZWgSNtmXiFd/JIuwokgISzGLq7oMVOSCkPYSeoE/F1bWN67jnTukU5KNOs9FFcXbVIa0OmfzsI+9nTF70vMaqrGdNNPsDw1QHF1ifTqVN6fKB4UGhbVAakH4mGj32MPm7UHJDN3EPTnVtXFpOkIaCsDQs+pjPWyhLu4BJJEPB/NHHR5F9lEF2mLEsX+TParVDUE0HfThYUwhXsksdeUJmj2D3kedEHDZQmqa7hBX56FZQlflhq60pPSy34R2FjuFfD9XHMpEIXBndjTzU6A6u00G2yck1ixIJvCQFUGsfTuoEgHj9HxEyL6exU4xgMshcQFMo27EJx/FEBc/SweRFfOH9jRazEw9k/ETh12mhO7AaOWQQJa6ZhBL8QaA4iY0kCJy3+W9FPXLTOi1Y4ozzvMbId1s6M4B94awu1M0eQO9ShF8mh17VvJLKAw/A103OrOwY2GQJbC9zIsHzgFcgmy7Tnc7hSYzOXRUXmf/MpCPAPTubgkRwOUZwbIPnwBNBhIslJZgaYLFO+7ABr20X9oIqda1qDtPfiFVn4yAfIsFzZzuZTwAAPoBvDIMuDjLvVSfpUI1O+32pEsQMuu1ecJ0N8AdvdFlJ0g4v3shaHKEi20cEaStMZLYG8sLGSRiYt0vgRlVWB6RW6sbOu6MwQU1E2416y14s2dTEUhbFetMapO9VzJAb6W4x0AlUff0xsy56IwBwGo1jcStmLxmK0KAPV7woKOJ0FrlC1Bk5VJ1bj9IOifJALWqiooGYBFa9QPUuw9K8fGh+boPTYRxjNOUmqadjHfNBLfbX1qz6mOd0Qq/WcMLFiF/GsUF2okc0tqhIJJH/qhMy7H5jmcx2JT27j0iLRgvdfkIMr4aIF14oRE8FH53858oefWvnf7M1SnBsjmC9B4pttANFNNRirSRbU2kLXXws6YNfQDAjJXtbv1WeH5HF7DVgCAF3PwgkDLEq7f7yZpLZfgBKjPraPONVzhuNiNeBCejHOcGIAToHqbTFfl6soIpKK+2IcmIMSD2ervB1zzKxaxoO2ogjBAtaLg3H5uoGG13fHxr4llr7PapZXvg8vsib6MK8DraWPaZ14E59F4qfSlrj3eG3dZmg4LpM9RUHmIWFagXTc0msBibrlBP0pqkTbwIEe91Ue+PUVycR/JJW1bkbXJeXbs+LyxTBsBnWpn6yPwmU1w6jB+zhrSJUBwWNwzRO+dV8MkyYsl6LHLSC9eFfYwTYGU4K/sIJ3NJFFpe1cefUfgfqEsTYpmrSfNGk+EhU0TSUAzAGFlLLNMlDTKsjvpdhgvgElUEXipwN7iv6Psf2giCE2X4K01LF98L3q7WhN+d19iZIcF6vvPwCcM30vRuzpHcnUMni/h98YKSnzr8gUD83rFA0IQlKIAUMEMmcKB9+D5XHRdYxCROJE0W7TghlfZ8MPsRiZSA6j6PIb2EoTtjWNW9ZhBKsvrAsBAuBYekbhhBlvlJ2V1/aJWJYailV4yELs3xfDdF5DfvQk/1HszlTCMkInuXBsqkBWhoAmvjs8GWEMJVQDEwLJEcmm/leBrO6rdL1ZYifuRo3vW8X4ggPvOWFuv3J9wvHafVjZQlQ+8LQgJFk9NZY1k3mjcqBON4iQB7U06JU+h8cvtwovb67e+yFIkucZBLxfwlrsQ33NjV8Pf0mZeLtFUlcQ8A+BMPSsAsotAutY7mMR1Yk8bOwGqt8NIVpkyCHlwszJQ2URuAfSJZqkaeLQBOh4wA6Ozwk7CJgOVszoMsFjckg2metwDbn87PgGhfvSRk9P1BhE+ZJNPZuB5ug5aMUoCQgIGy6BORR6S3Dpxlb0eyFybzDLR5Zm48gBZRA36QFmBnIOfzAS8nNkEdsZyGKcxhmkKV1bIP3y5bQ9Dznf+NHgyBW3vazvlOWuesYVkUgPbe+Hj8L+yfH7YQ7VVoN7qw8Gh99A26lMDAZzjeXQujbW061PdR9QNaH+qx1UZpvWRnCpLUd13Gpwrk1NLX7hBT4CuulG5qsCTafu+MFoG9YjbwZbsA2XfGi+xpr1eYK25roVNvrBEcYGlotbmCCgy+P4G0mmJ5EMXgcVSWcMUXFfg2msyjADQbtWhBGRxiwaWgJWkJN8ywpZgaTGP0W1oNTKv817dDMtDkU6qgeeO10XHoK0R6rvWkV4cA1f3WnDlfXstJmVnjGaWCfhuRHIJTa0hTim4aTqxvHAKZncnyGqP3VfdA5+uYfC+ecsC5rmysa4TetABkAY0owSnIFtGqnNalqKOkmctKLXFWiTF1S2RinBdCL9yF+TBunD1PsWLTfOkxEBZPQGBqaZWCYAAlBXcxW1Z0OSZqHO4BujloEb0hLlWdtjCPGJiw/qYon4jKdCRZDm4qiQEReOTY+/EgUfNe4l3tjjxLIUbrYkXYHmtIiW338gjyNjeynOcmNgJUL1NxmGgbd2cZmEwjsvd2apYV8MdseV4m0OIzJCohYPnkvPo5zZ5BdKrW1SAbFCzJK9qdaCImDHoOS0CPJ5Qbwn7aecyIH74Jp2mPiXB7VGss/a7MVJOpYkGPbiiEVYzFYH/GLhakg0VwkRKUhGBruwBs4XsUzdalSkD700ECOVpm7RS1croREyRTc7zEpioe18BYHNqgPruNbiP7enjQFJdKHHgskL94Hm4okB1qo9qLUNSO6QzKfuaXZ5KjfBlecjzz9KeZdkygMYgOgc+s4nqvi24Rs5JlUdyZdLuyx4MgktT+JkwjR35HNnwhtZgFCfHsGoWq84qihyYzaVfE43N29kXNhWSAC18tbKOYDBH5WijQwdck0iJTks6MoF49j4AODm4C8kpnfLL9n+atSzX9VjUmwUKdHA8C65t1qSiJAH6PUyfu4VBv0A2XUpCGyOEULCBIpW8ozzXuFstF6pu7lCByhQYUtdl/BzAeYJ6lCBd6AJEi59wXYPAAEXC/gYcraSojSEGtIiioU9BYBNdb/BYrPTdCgAlZ8mM2kfW17b4C33fLp46D0UApzrmh211u1RyFLhXoDwvC7f88XGr3ar7dEqoWizsbA7qKYhvNL6WzeOycu0BwOpnaSpgU/uT8gyeqBv+c5gpKcNNg6aq4cohON04VkD1xG6vnQDV22VsGahJO5DoywyG1AS3F1y/P9TlFP7kLhCLv4sATIh30h9LmopdmHLK1UGg3d+KFQTg6lxILoElOGBlHDF8FTE9T8jsWjqur/jLg78eeZzYjmrS9Y6zeo2HHSuAc175nrufr54wXOthjYpAOaEV01bdQsoz0QQlEvkZR/BFikSZCRBpMhwBRS5VkQYpOHVwywYYDYBFKRnBDhLfOVOtTUcAUomR3JtoDJkea9CThIzFEunuQstD1uBejvnL7kX/Dx9BsjNH+s7H2pATIDyTlGVAv0C9NQTnCYgc0kWDZFbDTZbA1T3R5zxKyzPP5RiLBbisBRgCEiN68Sqyug4Z0VR7UBq7SBlYLOB9oyC1y/Rck0mN7w6Ff4LwPtdaljRJgCIBbayBr+yojBXadyMyXv0gejQOlFBuaikxT9CM6hyUpvBTSSqjfl9c/GUpOp7sAxAObHOkS3rNYgtPxGK5qRWmNrCT3oMHBebPO4XpfRkW59dx/soM7ooT/damaWOwrcCCln6V28cqSZWEggutkgkk5GA0FGZ7MgUXOZbP3ISrHfqP7oPKWt6JWtlYJzq4rNJLbXa+Lfq5BdwW+xqKFkD3sTGzacdg64Mj4ho7C4jOwt/YSxvrqUsAGAAOElfQftXdsxTNmTUs7x5guZXB5wnKUynggc335+h/dBekC0A5fZsoBV1QoWkkzrvIZYxhiEcwgGgC0kS8A00DN6s6nj9KEpGYYgbIwTmHxkrK3og1Dfx4DJ+7J/8Z/WTsiHv5pJ/jxACcANXbZhTYUm5XvkDQR+wwfpG7qZPwZPt3BjMgxEzZIGOThA1e5vKLtU5vhGG0OMh4uwY6GagGJAzkHobWVoDaUeTgURZW6f7m9jv6gIf+elO7BvcZwWp6izQOa+Yt5PdlKRVfDF/aRJNnUr7cKjyRxsUVGXg0AA+KAErcZAFUDWiucXqZZjRrvCUbANV4OywWUjdea5O76QxsC6PRQETsGfBcw49yJA2DycOnBOdTYNBHPcpE/H1vBtoYCgvIEL3F/QmajQH8IAWlUqJy+cApZFcXyD5xUUgvlcchz+i/7zKobNrnz+LgbJLzDCpyZPsl6ixDkiRInYMrG3E1XrgscaLXmqDmC2DQB991Wipe7SioZQhYvXAlbMoM8LlBZ3cuSy0M0D5gNwpQ44dDqh8BrOwtGJJFX+kiQsX2ed7Wkb/uUS372UCYuT5Ca1mypdeG4L0xeCbJZVxVIAV4wV0OhJAiVxSgwUASW+bzJ29CjIAZheIEjBA+Id8A/R5wdgt+PoWbVuh/fIzF3T0szqao79lCluag7T3wdCZxqmkaxkJmBtU1OE3htHhCKyHmhF3VeFbaWAdOrYuOb5HDn98C93KsfXAf6ZWZvEd5LiEGRd4ysqtxot633q4A7Lkt0WpgMk8R6tJ7Vs+VPksmKWbjsFlgTsMHkAVPEpU4dd0KfubhChUCdYCxBRMB3MtR3r+Jnc9cw/QBB18w3DQBO6B3Bag3euBhIfHtTSMZ9yFkTAsZZKk8t7awAdoiFQaYnUN1doTdV5wDPLD+4SmKh3ZBSxvfqNVSBcBOFpZBuupGjCUJ65qFJ07sU9pOgOrtsiSVH9Mv7QxatlIHwiraEk8OuCLR/Tus+BH2IwASm3ZITGvM9vG1kCOD40SXQ8+vgyoBpiUZQGs4z8p+h9Kvdi3x79rYJw2kPgEz5pJIE+ESoFeAezmq0wOk4xK0N23x+GKpyTgNkKluYy1VfthKXFopQY3vIufE/ZpnaO7ZQjNIQTWLDuOoAiCFFTgBqk3JQq8zRrZgsHNwTKgHKVBXImXkCK72oKVMMGAg2RmDpwpI8gzV3RuY3zdAtnCoBwmy/RL59hLJfon0ygSYzeGLFORS8KCQ6ytrNA/eDZ8nmN/Tw+hdF+FKD0wIVArgFhFzDz6zAbc/k8lqOJCYz9EAGA3Q9BKkF/bAy1L6p/HA9j6y/Rn49Earh3lpW0T4rwOieLGUOM+tEdye6IzKxK6hCQd2P0BjwhzvT/RBM2Ar7FzTMqwMSeRhAIO+PAeOQGUVngFSkGMe2PCKdBiy+B2g4P7mhWnALg70E2vym1WHs5hOWi5F1cC5m5OWupYpKBXGM4tKYXZd5Gzu/mWJai3D9LMfRP/hCbiXw9UJtt67BM1KUFmDsgzunnNyf50DdvYl3IQgQEdDqSjLQIWLJJQKBbWNxIp6lmIWWYZkvMBgf65JRJU8e0nSJj9ZnxsjaGOrVaSKFgp2vZ0Y1KZBCHeI2dg4ES/coEPGcEabOJagZaQ12YytSpSdt/YRqGZIbIMA2cWzt3DpC9axPM2gGkDCoEbaWQ8Bn0bt4IjL14UkEUSJIs86UmVEUqEQ0GfSJajO9DG5P0EzZNTDEc6UHvmje21Mq81z+hxQfpNA9TjaYdPyrTjHiQE4Aaq3zXihsVdAuwI3YBozjvZdqBAUfRf/YWwFVv73Xg8bDaAxrmxb1Glfp7b1AaNoXI2Yp5hJPWTCI9W9axkkF+Jnw742Q9vpown7oArBbTCCTF79njBhWQYuMgX/AKZzqe40nUuwO2uGeOrgt07B91Kwb9Bs9iUbnBhJJRNRPXAgOCSLGg1JkkxSEZp+iqZPqNdz+IzQv1iCnAdygDMHHhWAIyTjJdysROobuGUjE3C/B4cGyXgRgDIxxPU7KFDetYbpM88D8MjmhGRageZLFDsNiotj0KwEdva0Qk2umeEL0ITBp9aAOTSRCXDbCRLvAXdKkk8WFbLHd+GJJQ6ursFFLoL+ywZclSifew75ex+RCXh/ApdtgFMHzEU7kyxUodaQlLICLm2LPM4NgSgGFqVUA5otJGnpQCz10bu2UlM3y6J2jxP/L4+2LNao8QKeNbnG9fvyvExnQN0++yGsxnRP60aTS+aCY5JEYgVHQ9F+rZvoHbrmBQbAHBKAFotQserGr/Hwk4QEGouvtQWCfBvGqVBNj0RLtzpdYPLMBNXGJvqXa4w+uIvskkpGJU5iklPxDLGOTSFBKU2ApYK2xrcsn3Py3qapNMklEjOtIJKMGW1Wk8p0sdA04XrYys8maVhMxJ6utlvkc2Ec9TieQ7hNqCBnRRbCMKt9EYFkNrF+8EHlDmerGLQeNvs+6IvKgtGPCux/+hDlAxWSfg2epWhmKTbumqLyCfhjPSRVvPaRRDAk1LLWUI+RhTbYNYRzKqubpWjWc1SbHr7nMXsWYbI9wvq0Qro9QQiTAKTyFKhNXLvR50/H5IPEx4k9XewEqN4Os4krriK1OpgD7SAQf26AdDWoHvEg1mbGhsNfA0Be2yIXUnAxsQwy5saLj38NY12Bt2UOXaiSQt5YpJXBJya2njjJdeOm1yqxVH0VXO+Bh314gkxunuETB7c7ke3zHFRVYDTixkwTGYyv7sI1HjRfIunl4EGORL2SnBAo8aAGcKVHVmqMr3PIEqmS5Ie5znUspU9Hffg0BxpGuvBI9hbgPIWrGtD2RBYzOxMklkwSXRYvKmCHkY+nyD7QSEZ/3QggzXPgTy4GSR6uNCmlmnUZ/J2x3DsT4Z/MgDRFtrcErkoikB+ySAgtK/CoD372vQI0dqfAeIL08V3xIszKUGkpuaClNusGnKWgjTVldRh08aoA7hu98SyJQPT4lRuopBT+0T8jkHcrnjMGGB6Yz8UdrzXn6fSWALC9/ZBwxVkKPrvx/2/vzMOsqM78/z213Xu7b3dDNwgouKECgoIh7kSjgho1RDGaGdfIJI+OJj9HzWhiZiYxMZplMpknZmJM4vZTUaOPipNoVJDFRCMz7vkpbuwuNNB7362W9/fHe86pql7oBnsjnM/zNHTXPbfq1KmqU+95V3aVaGkHOgoQlss+pgQIECiIIMqcMkhleuhO+qEhiljzFiB+pmUJ1v6dw3YGJplbUx9WCf6J+YmghVQAID9AdlMHxlYitE0bBT8nUNUh83jaFuBmgcAHNVc4fZjjgIj4nAV04BhIBQCRzEghA/6kP6QWLlVBDD1EQgeniowXBxHJ50H3XbrYQKnLu45F0kdVRfQDXL1JzduWYHcpvQCnxGWKszjoOAJbaUjlYl4WjxBQFbaUe1GUfuDV+MpFgwWC8CJ4XoDQjlBTV0Au46NSzKJccdBWEchssmG3C0BIf/cg0PmYKcMBa3oMiYtRUJTU4vJ5OS1l2OUMohpCMDpCyxQXll+Hmv8XwWopyHGV7gQW3zdJ14Ye0deAF3d2bXXCfW74EeqdOMjHMDBGUB0qut5ziQCnVB5BIUsjAvwOkCXsejUVqdV3P4XHxE7ifakVuUyYLXJZDkBxHfbvau+MqxIFQUIrquZFEZdS7XraKXNXFDv69wYlfhnI57Sr0GvJikPZDJDPIaqpgvBD1sBUZLJ2CoFywKZIx0ZEBLR1sGAr2LyIjk59fZITi/ADWMWK9q8Ttg3LElpTps+yJE1gRLDa4/reIl8F+uhjmZDd4mTX+SpOv9RR0N+hMA5qS52gTPKOlnYICIiSz9oS9aJJakdSC6gECU09hQFQkBqnjNQIEvj8XRdijwagOguxrQ2iWAEKJVAYwvq4Od5PuQL7nQ8SmhTinKdbmlkgaGzSyel3CAILIzrAr6c2lFSKYcDvr+30jXN/+iDhx9o4x+F8nxPGsGDa2g7RWUykkEIcTEkEgmDztu/LMqRdBC/5MArLjjWM8rxTWluVVL5ffd/OAMlngG+7xFwEJBbY8SbtR29ZsGqqQZYNrzWE20mo2liAvbVdajEFhEy3JdTz4nN6L619lGVICZb2XRU2Px9w3dgaJcACq57jRELAo7hMrDpXS5amVimvlEZUWPoU1C/kOrwgc/l5EH4IUShJf2ckkvXbWrjWw5m8EYXFQjwlhFU1vhAs2Km/VcwChMzsoDSrap/czioFyG4qoqUzB99xMCpfwLjqdmx5ZwzKbXm4WwWq1xbhtlXiawPwM+TweQnPTYyX4PtNxT4EXEGRhXQBtzVApokQ7RmCBFCeEKIlciDCeuTftmC1dkKEBLJkjIQlXVeCIL2AUKfquqx1BXhe8Dx2jzLsthhBdagQQKoEnJq4hZXyAVK+XalJLWkGUtuSrgM70xkBIOMhnFAPeA4sP2Lhy3MQubxqF0UfVhhxeh01qSSCB4R88cCyOMBBzzkJjS9Uc9Ir9B5X0gMlQPSkhRWJ/6Vzv8hXIazOcABE2Yf4cAvQWeIXlDLxde1arE7uu4vSv0sJKiKKAFcGbPg+5ynt6vYRWYCI2Hzd7GutDyHkBUNnSR+5+6XveaGgPtMBJ2phA2xfENFfpTjymuR+trakXzAVH2hq1S9q/fJPHoPk71HYRRNErD0LfOw8xKVLe/6IP+9FBh9yiEBbm9gM77kcdFcoJgQm/k+IRMoibVqXwnalglRFL/k5B8H0VDxEHVrd2/0wofYxQMKy0/NZt0UO/6MrToHkIpWrdVUm1IJcC3ZnAKulAAHl+0hxYCIRBIVIVaEKQxYopb+lHiPXATyXze6qKEIgNa2WLbOVCHatVBWo5EJJeC5ICHbNSqYQjCJeHAgBCF4sCtsGuQ78vUZrf3AIC06LXLhZlhT4bF1NS18jihLjmrBcqdRXArFFI5lNQH3uB0i9B4A4oEu6FghpscpuKKLmrSxKs4EwsrClkEfBtZD9SCCzJUDt/2vj55Xk/lXQpcyVTJ7LC+9Iak9DirXNAjrNHYjgdAbwmgN0lmxU1xVRCAX8MQKde7nItNbAznuwOiqwWrksMVutcrDk3KIWZMLmFHtcocpOjBslFtMjhPSqd/COYQBgBNWhQUCndUqaUnhyitAtv6GSQpL3acq8BqBXoUQdEPFEqL8v4j44DqihDqUDxwAQsPwIVkBwW8qwijLFiG0hHF0NK58DKnn2AWzlPJR6da9S21ByDk1IhomusLaop34L6GTlKhhBJExfyXNNvWfZ3EeANtkL2wJKHHGvND6ksh0Q6fRJUXMrRFMP45wa28SA79CiQEa6dt1nyH6puryl3qd8EVEkhYnkOaKf17wvBmrSI06uruFrTBWfX2wW+6p2/UpSsy5SvnqDCCFt3h9GhBRIKGThRwgBKobARxWpGUu3p0Qgkvp+avFqWdqczm0pnkeE4Ap4FHVPccc76L2j2kyyHWRifL34UHOTFqYpIUMLLcCJqgwq+4xBZXwVbMdBcQ8H1e+2w123VQZHhXyerkjMF5FMQSUr6imtqnJ9EDJ/b0217j/JUrNKs0pOBPhgS1EkLQmOze4Qype0woGLKpm/2rcqay2yGW6vBOggAmRqN+FXuD+WYA0qUVydLTmeasGhypt2nZsh5yqrhxKq0vc36R8LN/H6Vm3lpfVafDSsaEepMYvSnnlOge1ZyG4JUfdGG6ySH6fyUu4Ecn6kIEi4PFBsqRAkNbwCcJW7QMjVrdoDuDbgZQLYToSiyKAy1cI2z4XdmUHteyXkij4v2IVgpUW+mrN7KOuOKriQstDJk7JF3/el4W8WI6gOJT2tkHpdmcXCW78e0C4CHATYfFKdA8koaOG6oJos4IcI63Ioj82iUss5Ca1AwClG8HNZTrYOQESEKOPA6QgAOwunxYWVyQAUIcrJUnmCYLUVgS3Nsdkr+SK0ulTZSr0kZe3xXJa1do4UNsOQzcnaZ4r3SaVyPF6Ow9+rzoGyDtdA7yhxNKkfcD5QAe5TmHiRh4k+9Pq+pl5+7x/CdeREr65JYoFgyej4xBikJmT1AtshwXg4kX22ZQAQYt/bWCNMXb4hgzUGvWcjREi1BPsIV2WBbS38TERKiAx77mPCt5ukFlRYIq6tDorddEplkF9JHM/ijAp9JVZP0sV3sucTEenUdySFCSVMKV9Gef+q68z/E5ur66rReUANyAbq3mqH934jpxEjQFXMo3IFcElmN5BWiSCIM2Qod6iEG4UWDDMceAg/4Dkvk+E50LWBpHDmB0A2w4Fr5QoQySIXRJxdQFp+2MISsea1tgZUnQV5LsizYZVCWEVf5yLV1q9kcRbRVcCSc4DStsqCAzqzgM4WgFhjraL9VTlTNY8kfUUtC7FJi7/vbSvB/YuPKo+DWCNbQBAHVOrvqP75AS8KUoFOIr6+yawHUQRYbnzNBOBtCyHaMijXOsjnyhhT3QFnQoQP6urhv18Nu5yB21oFtzHOeqMyqpBMQaA075Rc+AjwNa+pThfEGW4IfbuxDcQxDACMoDo0qAdaIly3Z01H8mWhful6s7qO1Fh1edEn/5T5BZHL8URQW4VgVA52WxHh6GoO3HEFBAFORwCnAtidPqcOaq8gcjly3GorwN+7DmGDC7c9hFXmiNwwn4Nf6yLyLFjFANn2ctrvTQXgZDNATRX80VmQJeC9v5lPs6GO/UEpQmVMNewKwfIjTlBfqEixTQAFAqqkL1axyFoNpcl1bE7N094hTVRRejgrvZmSlZCa1Jqq7UnNB7pfn76Qvqhw3S6yZ8QZAgS0D5heiBDiht36swvR1Z1jOzkPd1pITQg/Kfm+l7YjYQiFkFHOYQRqaY/nAvW89CYTImFeTQaJKeGQwGb+QoFf7AmhhSLiALe+zKU9Lpx7PInYj149GzqxfuJZoeRtLxcp6vrIKmVOcxFuezWKe1iwKhGsTBbIcsEF9osEL1RV3l3b1otNneA/5OcfEDwnqEIXGY/N/iUfVJ0Dsi7gh0C5AtERAOWyfP44zZzIeHE6KLCwpo8pF9WWzcUE4LnAqDz8uiyirAvvY/bFFsnSs4T0mCTHWSS04srClhQyIWKXAdfh4hthQhjXJn6VraDrMSJ9nfR1jCIIP4Djc1sbkO4PFFv4VCCZur6W+tHOsdCmd+XnqwLW1D0QEao3llH53yxa3SxKe4XoKHs83dX4EFM60OlWIbc5C6epwAGdKruAEHpdrjXxroson+F8ymGEKJ9DZUItIqXFNex2GEF1KBCIV68k03VoLQTSq+9e/MsAqSGtyoLaOxOCgXppx/ugUdUI9qhF6AJBbYYF0FKIyqTRIFvArhC8jgiWT3DbfYiQYBd8ZD6ucOWhIOAXTSVAfnM7wrE18BuqURpfBbcjgNVZgVfygUoFVqHMzu7CAmyp5fE4Lyi5DqLRNbBEBGtbO9cvr6vmiHYHEJ0BXCm8IiRYiWTY5LBjv/BkyiRL8AReYVMRdRb7n96k24BSbIbrtU3yYxFfQ6VpsKWJUPmFCSte8UeRTFEr5CVRL3Nwmhzpv0o60XwXDW6v+Ws/CcMkACcESpHqRz9ICPusaYFcu5HWZnRzI0i2HRHI8qRqDFRSevlZepGS+FZErBFNBtF01bKrVHSyDWSFKuosdvH57fkYfWLbsXBqqch56j5nRZS4vfRF0gKbAPjZjSJYW1qR2VaDcn2ONZPVWc4rW6mw4JivBjW1sAAl3WeIOCE/VMnVIIBwPSCX4WIPGZdNyJ1FDhYrse+l6Iw1kir1k1WdifseEbjkrivTH0EXgFAmeAAQ2QzC8aMRjKmCEBbsos9VzpRWVO1PuUPocUks1pJTvPolJeTLOalc0YKcHjwrMbewLxNSz7MMUEq5GCgXByV0Jhc6+qtRLDCr81V5o7WfbhftsLKUqMWWYJ9cu7OC0a+2IaqqQzuqEdaFqMmX4BWAYiAgciHIFrGvcIj4nFXMgyVAnoNgjzr4DTm4LWU4zQVQ1tMpykYKJup/aDGC6lAhH0ihqhcJTuQe+3YhfnB7+S6qcwj2rIe9zYNoL3BC9IzHk7p0do/qaxCMq0FpjAO3PYDbGcApA5ETIddYge2zITasckC2AFkW7EKF/VJLZU5dk6wG1BLAbu+E/XEG/oRRiHJZ2OUKRyhLE5USnEV1FVBbLYVd6T5QKMFqLyDKWPDrc3A+bubJWD+DiYcxoZRAGPELo1CScQhdhbmdvQ7yn27f7zLu0udLVWRJaT9sW9caj69X1x3GQiopv6xEJRuRkQJ4EKB74YUBnKCSGpakCrKr0DOIbD9Hb88Q9XKNuxkhumhYh0VI7f1+TG2W15m0oEc9teqyg16CD7u2IYIlTcrdo/p70pz2psqV96e0imh/QZKLaxLgVQLJu8nSlgHt4pEQWoXnQWQzCCaMhuV6XG1NCHhtHIQjWju4VKc0bZMjBSfX1YKTcFz27S5zoQThOOxGITXOQqWWKpU5EDEIefEYinj8oojdABQyk4aIIta6kuy90tZWIp7DXBfIVyMcW4eoyoHbXGKtoAq60gsxtfAlXkgn3CD0U6fGlmJnmJR7R1I4VTljdX8F2xKiIBYYiYBIsP+mY8cBT1HECwubv6NTAioNqHJvUL66YQRYUaxtlpdZhBFr89X9p/rny5KzifbwA1jNBdS/QLALo9GxHxdeiD4ECjNtuO0WyAq44IVyTRNWvPgnAuWyiEZVIaxy2eqXcxGGOYQ5B5liwAULDLslRlAdKgSAujzIdSGaWoF8jpOBa0dyC0JYrAkhyHKTIjZhOzaCsbUgCwjG1cLOuBBbiAXDziInd9+jCnAceJta4L3ZwfuzRFziU/m1CQGqrUZUlQGCEHZZ1shu6+z+UiTiyao9hFuqgGrlOSCe7IQfcNQsEYLROfjjPdhlAJYFu6MCq6MA0eTDVtrk7ZKwHyojYoTeX6y9jTUlflcToypJ2dXtIrlAkNt1MJTUQMQ5DYXWIgnbjoOE5MtKR2vLPqSEVP0G55eHqKoCymUWeHcmLVNfuC6sqip+yVd8WdmmS7DWEAqs/SUlpPaja0kN69DR5f7ps5kABCXObQdOsF/dIUSqSMLOSuqWLf1PAYDvcRJKQ8rax6R6XKTU5eoaxM+RVZVDNCqPyt71cDtClCbm4W1zUByfQWZbCc5mzsWLfBVQlUHYUAt/VAbZtk5QsaSfNZV8n3PRSu1iZ4E/syyI2hpeYJc5fRfPpy4grDgFkuPwol6Az4OkYBtJYUwJeJH0S5VlVVnrmwEiQnZdM0TZZ+1t8vIl5w9lmpfzLSltd8pqxl8UGS6XrDWoJLMb2E4c6Q9iNyfLktkMEvsg8HFcB+Q4EEjMa9JML5B4nrQgbAEWxcJuEPAxHDutKFGaU9Vv1S/pH0u2zfNWqcKLDduC3QyM/p8I1euqIYpldB5QA3ebQNUmwCkjvpeSyOscNFSjPK6aBXlB8PMOIlvACojdLMIhf8h7Ry82B/kYBgAjSFDduHEjli5dioMPPhhHHHFE6rMgCPDcc89h8+bNOOSQQzB9+vRu3x+oNoNGRFw3Gb5e4aK6CqJSAWU8VPYeDcuP4H7YAoQRgoZqVBqycDp8OK1liM4S7I+bWSi02VwVjamDCAmiugoUBfDWbuNJVGkIhHywK37qBUYAUCzD9lwWNqMwztcKAF1fpmoF7wcQ21rY3FZfx1pVKUjr4KFtrci0F9kHNaI4yKEvuglMcqKVE7Yuv5jQRiRfEDq6WGktk+bIhHkJIDn+SS2cbCYnd5LR9wIyp62QZWmVX5jal2XpKNakGUsVRyB5LJUnMVbaEh+fIogsV8CK2jowYDOTZUFkMhD5ahacw5A1WzJHZFSuxP5lfwsM6YSuFiY7etDeta4Dwo4IqD20E0ntmHoW4wcNLLjKxZQQUihVz18cACNcN47itmTJ4YyLwMuCHAuVsVWAANzmCgcmjcpDlANEro0oa8NtKUtfb0ub+dUxuVyql3rehOtyCqlimSPJbYsj9RXS11XkslzIw3UgiiUAvHjkRaJ8FgKeB4VtgRwH0fgGlPfKw6/xkPuoCNFZ5gBPPWiQQp8ltbiRnqsAitNiJV26KDEnBAELZcrlyZYpuLT7j9JUJxbRemytxN9yakn5kiJO96UqS7kO+9TKMSHb0qVkBQBhh1LLLO8l7feqhFPZD4sLlCAMgWKJrWlq/o8IaC8h086BfLYvUP1BBlYxQOQIBKOycIMAoixSWRGEELAqAYp72OicYMEiglUSqFkbonZ1GyynBwHXsNswIgRV3/dx9tln4/XXX8dll12WElSbmpowb948NDU1YcaMGVixYgUWLlyI//zP/xzwNoMLcaJ229Kr+yifBSKC1VGCt24r16euhKzl7Cwg94Gly3cKy2b/TAGgWAYVSrAKJe1jpNN8pDSF+p/ugmClwv5YXQOHevKTVcgJT0jTVji+nqs1bW2ByFcBpTKcD5tAOz2hCP2fsC0dMAGAhT+R+F1/RWjzmvJzAqDLAcaaH7kIjigOGlCHFAIUch5Y4VgQpF7YUawVTXZRJgFP9in18tDCs/xCsr86TyO/VAgh906Wdvxk0oyszlNdJV/o/DKJq/UIUKUCK5Nh7VsvRRqGnRHYpRS7+gtze884gNjEnxR+E5o26WoglH8jsShFroPKlAnw1m6FKEg/2YoPq7kd7Z/aA1YF8PMCVgBEVRkE5MJtKsJqL0CUK7CVX6fvx2blcpnvX/UMqgT8nqe1q1Tx+TseB17G7WV+TpU03uXsAOQHsUtOFHKmgDAErIjnWceByGYQZXl/TkcZdkcZIrlIUUK9FrYgiwRAa9uIZBClGnM1V9gyE0qgTOpSWIMUIoVgf38ITgclwKZ/5aqgflRhgyDhN++wuwCpoKikBtbiRbjO2qB8cBPZBYTqa7LPah5T22TSf5Qr/Lvr8P7DUOaojYPh7I+bYbdkpPUN8CeO5kC3oDM+F3k8qxSgemMJVsVCWAN4TRaq13ZAFMsQrrXrP3eGnWZECKrf+ta3MH36dFQqlW6fXX/99SgWi3jjjTeQz+fx4osv4uijj8bnPvc5nHLKKQPaZlCRphcCIFyugCK2lHj1CkBUKnFuQEVEbBayLGB0nXaaFwBrDXIcBY/2jl4CixITazeNZbpJN22mldikzEbSZ4oi4tx5HWWu7V5bjWBUFewNhZ0XUvU8KLQfaNqEH2tOU0eQL03VhhLO/1zyjzUQBIr3J8ATtgqAChNBUUoTa9nSvC+gyjFSGLLQq9LEJDW1Ou8l/0OhrCglNbOqr0ow1uY/+TKxshlQGPHioT8a6K44DkTGY82p50khH5zWh7j8pKo/zrkpXTaVjkCpMJXsfsSwnWdooFHmYv5DBlINngack+nbqWeNreOU0Jwivm+FYO2h7B8sIQMfHVT2HgWqq0LmrY8hKEJx6h4QERDZQHG8haqPQ+Q3FGEVfThbOiCEdEsKpAApqyMJx2GhJwhT/puiKgfUVCWsNcR+uTXVEOWKrpjEgrTUpGYz7NMahhClMqedUm4wsnIcBSH/btuA5yGqycGqRMhtaGeNbFLzqhbQCcWAUHMMyQlGSAlTa6elT68SxtX8oU3+dsLvNBHZb1lcblo69ZPr8DtBCadOQmMrrw1ZcpHPK3N5nWS/HBsEioPB1DVX3wEShQoofQ7sWMrGqCjiuV/1R73HlO+qSr9mWWwF9H0g48HdyiVVRfJ9JYVmUfaRW9uC3DrB5+u6sNo5aJZUftqRwidxsdmRYxgAQBdoGzb++Mc/YvHixfj5z3/e7TMiwgMPPICFCxcin88DAI488kgceeSRWLRo0YC2GVTkChsZjyfaMIJoL0AUy6BSiX9UsFDq5qR44lLaWNvSq1OqznHAUdJJfnvoVX1CO6KdndSf6piU+EhuCyP5YpAmn84CRFMbEIawN27hHKafAGHJ1E4q2hg8sasVvw5GAlhzaHOlGFXKD6qt0ghYiXOV5yLU+RO07y5FUbyd9x7nM1TXTmki1GSu9q+rdamgJUoImqTT6igBEVAvJ6V9ofiaWOzSIVw31iipKNzesB2IfB5WTU1CSHVSUcAUhtKUaiFV8SUZKTwCILno6Jp3dfihLv8PIoIDLuMfO65hn9TKybb6HklWMoobJLRioudrrSrLJS0MSPrSyo1qPpBCq/A8iFF1wLh6ntP22RPhgXuhtIeLSr0sgel58JorqDRkAFio/ihC/gMfbnMZ7oYmiEKZS+1WKgBk4v6MF+fkLSXmEyFz0dblOaG/78f+p54DkfV0U1UGFWBhRzgOz5mFEldCKldYWJULf/Klj7gsMEACIE8KYEqYrCRiB9QzrK6BdkWAHkuhkvYri40cT10kRfVVajpT1yiSgVzKJx7Q1bZAADmOrMQlU915TjwvEVjLrEzzfsDBqwXpphVygv5UpUErMXcBPBZBEOdvVfNUFLH7lx9w6elcJr6nojBOr5XYp1A+xvJeFRWfXZCS55u4d0W5AlGuwOosQ7R2gip8rWCPrLnKMLQMq0b1o48+wsKFC/HII4+gpqam2+cbN25Ea2trN1/SGTNm4OWXXx7QNj1RLpdRTghfbW1tO3aCCgF+SCOK065IjSH7CKlKRXLV2hUinsx9X2ubhCWAba19p2gi2QGh/0DfL9zePlcTWcR+YQBPHm0Fmey9N5Kq0S6f6ImKhT0dIS4AodZRlgVh80YKglio1FqeCIikBjVMTK5hhFTEeRBw0IHM6UhJ311HBkapsfVJahmsONciARygwfeEUP5k8lhJNwrdR8vSmQP0iyuhYeUiBIE20wkpePBpke4f+UFCjpbCjOfx4keZOpXQ60u/M/XyiggENRbcRgB8zpWkxmWYIMTC6UiTUYHB06Qm3W6E0Bp+0UXg5IUYBwIqYQpAfA8gFoBICRggvo8S2n/SWSYACIpNwID2q+xm8heIXUSI2wmwxi2qq0J5n1FwPm5D2JBF5355+PkQY1Y2A7kM/HG1EH4Ir4WjvTOtAbyP2iFKMso/CAER6edPj0fAgpJ2uZE+1ghCoK2T7/diSQZHyft9S3NstrZtLhZQXS3LGBNrUoNQlkzlQihKcIuT9EfsU1vDygSUfZ0WKi7zaccLvC5uU0LNEdp3V40r9DUlJewqNypSYw42zVucN1YklQNaa2uDpMuRDq5SU6saT4vjDoRaRHcWeXwch+8vlYNbCZ4i8bsav2SOXCLWqkcRyFfXyomrYqn51rJAjqUthHxuNqgSQGmuUa5wcJlahEeJvLVJN4CIZBEGvh6ozrHpfyQhdQ6DfgwDgGEUVKMowgUXXIBLL70URx11VI9tWltbAQCjRo1Kba+vr9efDVSbnrj55ptxww039Ot8+kLYcqg9JaRacR1pIBY4e7r5tU8ZsQYtAjveh0HfJlK1vwE2VZDSTibrZvfeuueuqVRPtqV9R3VCdzthXlM5AdUEq7QOCtuGQChN89A590jlG0xoDjiaPxGxL19SFEZaINVWfMdmNzff5+96LlcAUn5vUpgUkKUeEyZHfb3U+asXlEAcECEnZQAQCcGb67V3EWLkS1lIrY0OvFACd+LliDCU5jfWUpEMniKfCzbogBcAwAgx/4+ALvRMF4vDAKFr1ytJg5AQbhAvtpBY4CjtZ8LHlFRwT7LaT9JXWu1XqJr36rSi1O0pjwQtpGpB1WK7m9TEK0GEogjWx03wggD+xFFoP6gGQU5AREDb9DpkOiwEeRdBzkJ2q4/a1W28tiwUgUIpFo50jlD5rCtrUSI/qchmed4E5LMOneRfCbNUk4MoVgBfRs5nvVR5VPI5tZWq0CfCKA4gjQgUhSzIEUF0FGEJmerL99mvtaOT+1idizOCJK5DbBVR44i4/3acdUUkNd8UZ0ERsDmK3pYBmqrP0oVICZDCdVhbKqTPqtZ6Co7+V4n8QwJVyRy1smAE+b5ciMcKAN1PrRmN0n+ruT0ZvCWFSpHQoJLryCAreSsFYSxI2y5A0nfYsUGeCyiHKKWc0T7IxNfFtiCqsjLoy461zoZeefHFF7F27drUtvr6epx88smpbWEY4sUXX0RjYyMOPfRQ7L///kPZzZ1i2ATV+++/Hy+99BLOO+883HXXXQA44OnNN9/EXXfdhYsvvhi5XA4A0NnZmfpue3u7/myg2vTEt771LVx99dX677a2NkyaNGlHTxUAZNqpSK527VgOCRN56pIk/BjjnYC1Aq6DcHwd7JYCRKnCAkhfQuhOvmtJ9qFrLkz1sqRSeYf9CYXgEo+piVppGFRQgDp/x06t/lX+UZUvUjiu2itA0syuJletnRXsAyU4iIHKlfglIwQgKC08hmEciZsSCmKhnBLaICUoEhBrXwUASE2wElzVS0UGfegXmetATdY6sbuA1lTodlCCMYGCsixByKeqg8MI2seXiLjmOcXHAvFLAK7D2vztaLuHhMHSVo5UBEe0C7UQUxp2dY+lrn/ClSW5OOsmIAEA8UueIm11UUKA6OkaK+26cnPRZt9YQE4J0To1G7S7DEolWFsImaoq2G+0IHIFyuOr0DyjGpkWQqaZkGusINNYhN3cydlFCDIdlBQ+lNa/XE5rLQUHBnLSf6EXX0IWDuDFZairN4l8HrDLEL6vlQKkUvtVZJYLuRCEkIvPih+bnFXqJT9gYVxZZwCes2trQMUi567ORjK/q6OFegoC3kciyEpfA+3fL6+hmmuAuJiDEOy3Kedy7QoWxhp06OwjHudOFbZ2EyDPTQiNich91wUsWXpa+p6SFelYB40UQpV7ErvYCn0fqoUOqXukUgFV5UD5nCx+QnHarjBiTbHrAJ4bZzZQ950Q3Gfl35o07QvB22DLxZH82xlW4283RmLC/1tvvRXLly9PKf4mT56cElS3bduGU045BZs3b8bUqVPx/PPP4xvf+MaAKeQGi2G7+uPHj8eZZ56J5557Tm/r6OjApk2bsHz5clx00UXYe++94bou1q1bl/ruunXrMHnyZAAYsDY9kclkkEkmif4kqJsuDHnCU5Nsbzdjb9ul1sQuBRBBlPYjSmock9//RA+UfIEqzZ7cxBVcKl00h30h4rQzsl+cPimhHVWaAyLW5ggrfsEo0xohzj9LERDE2iTtRqHbs4aFiLUmsSApWGMqTacoldn05gf8QpQvTAoC6ecm+6wSYkehjDDmHIf6heRKPztlgnXs+HyVJka99MMQQk3I6iWhr5UUTh2HBfAwIdBDjRu/GNi1QL52VKSvejlGYXx5BHG/Eu4VUInRh0NYJCne93Ro9Y4cVhmWPnkHhNCme139RwmS8tzjpO/qH6md04KV/Fy5sliI+6UWjNrkinjfIs7rq1Kt9bguUcdUftO8Y24YQfpih1JwIF70RRbE6Dq2WrS2wymzf7TlA4XxXEnIqoRwWyqwWjql5r8izfXS1SeT5UN1dMbPT8RmbQCA64FG10I0t8X5pD2Xn1FVVjbDPtmivVO6s7j8XKiMKMqUnfFYmFLzQhjGpabVviMCBEn3CALlc1yYxHPikrTqu64bLy6UJtjz9DXV7j9CxL7hAlyRSeWjVcGxSsuq2kZhvB9dWQo8Bzk2L1RDmX/VD3jRmbisnKg/hAhCiCDg8VSCol7QJtNi2bHbROKeUFkMhDLNq0WEI0A+EkFX4PyyEXFCf3Vv2lyKm+R9CCLO1Rol7jM1htkMn7sf8pgH8hq7CbcmQ5/MmTMH9957b6+fX3fddSiVSnjrrbeQz+exZMkSzJs3D/PmzcOcOXOGsKc7xrAJqieddBJOOumk1LZZs2bhs5/9rE4Z5Xke5s2bhwcffBBf+cpXAACbN2/Gs88+i1/84hcD2mawEdkM4JXZTyeZi6/fO5CrzWwGyGQgmttl5GqsgSDlpJ5kIE3+JA3zukZ9vzvPmiEZ+ESIq+0Iy5LR+UmHHDXZK8FSaZeVWQqxNiNMf08IwaZ/Zep3OOBABCEokJNtJsMTvtJmqDEiqbEF4heAk0hyncgzK2DHQojSRiifVxV0ZltALqcnbvJ9xFo0yD5CCqlh+lopoSUKWZOijkOUeNlILbJ0edD9FLxPKO2zToMTxeMYstBkZbOIiiXsXMEBqfWSAmeynKn2r9XRw73Q20c7eosNOJ/wuUkKqELVM9cXHrF/SRxoo/6OF5ppwUHd+xSSNL1KgU6/yFWbRMaA5EJSl96kxGJFpO85pcFVgq/nQlTlQJ0FfiaUFpaIb7/6WoT11SiNq4LtE8KMBREC2dYQtW+1wOooA6WKTtqPhKYQKpURkApSFLksWz0sC6IgE/9nsyyoKQ2c0vyqoCshQJ4HQYFedOrE/qrICdTYiNjlKAiBrMc5RcvSn9KyQLVVKO1XDxGE8KsBb0sZmXVN8SJTLQSl5UdUV3EfytLSoa6zCmKUeUsBLjogKgFgRbHwq5DuRiKT0UIkpDmf5PUWYaTzuVLEAitlbejyzur+U4tlrcGV2nMVGJfIJkGWnVCy89MMgThQNYJ2lRK2DeF5rEVuauN5NOtxFoAgMY9VOLOCIOgx0PeZtCiQvDYiOU/pezDie04IIKcsZyOEgXyvbu8YO8i2bduwePFi1NfXY+bMmaitrdWfBUGABx54ADfddJMOKp87dy4OPfRQ3HfffUZQ/ST86Ec/wrHHHotzzz0XRx11FO68807MmjULF1988YC3GUyoXOFqKzt68ykTkW3pkoGxqU5OmkrzR0D317teuu54n3vsa18lKnm2i3P1KTO40hoprYbcJj8T0nykz1lphq1E/xPaYi1gyhcGz8M2YFFsSk+ct8h4rEHREbUyfYrqgwo+UD5zXsIPzbIglGk/KVTYlp68IYQM+Aik9klqPmU/SZnxVRUc1buKzxO/eokIFvKEFs7VWMhTkUKEMhfq8QhDcDnLRHRsUeZKTQoyQJxLlvjcrOoqRIVC34F5Xa+067D/oDKDCbBgRpGuIkMAB8YEQRyUk9yH0hYmJdNhUvDGfAIpWWr2he0khEQCkRQU1P7l76zxVH/yL2oBlfRnVJYCChPPQVKbqhcxVnr8lBY3eW7JX9WzKaC1ewSC8NjsLlwHNHY0wkwDrM3NsJo7dEJ94QcQrQVYpQB+nYfy2AxCV0CEgAiAKOvC6iwDrh2fn9SSCc/jnpTKbNZVWTVsi/MAK21nEMbCGiBTqkn8gJ8fS2jLCAWBdm3hvNOJRR7kPerYXG2qHEBAIKqtgl9fBW/9Fm7iuiAIhBmBzn1zqNQJ1FcIGddl31FVatp12F81CPlcXCc9v6u5QS8oSI8FOSzQIwpi07fFlQRFxHM6XCchWFJsJleWOMeW1psQoizdj5JlZdVi17Ji4ZkIFAV6n/o+4CTSseUIkJrcKPajT/oTR4lAVSF4TDOuXBBwZgB9gzmyipU264PzvILPgSKRqs6V6pty2eiPe9vfKF2DuLdn6X3ppZfw61//Ghs2bMCmTZvwi1/8Aueffz4AYO3atejs7MSMGTNS3znkkEPwxhtvDE7nB4gRFUo3f/78blWpZsyYgddeew1Tp07F22+/jUsvvRTLly+H67oD3mZQ6WLq6DdKGxcRC6quA8pwwQBh27ySx/Y0V92Fg/4dtotGpx8I+aJjp/mENhK8K6G0THKOoqSvmRS+SApdlNT6KC2ikL8rn8vEZKaTbTuOHicduAaw+UkJ+m46fRMCfuHpcooqLY1lcXogh3M78oQsI16VCSvhJweVbD+blcf30schYkFOHoMqMsAjCGTOQdYCiYyn/UxTLzkluCufWyXwSqGFwoiDvaRPHpXLnI5HJuKmIC4PGW9jLZKVzcoI8h245urll5S/dHCduieErvcupJk2/jD+EVLrrtL6xBkShholpO7ES1ELqba8PolzAWJhTQkQFC/61LPBAT2ysRpfHWgZa2I52T7iLBfKbC81fKm2ShjWgy2FDaU51aZ/kkKqDEQaVw+qrUJQm0F5Yh2ooU7WoGfBBPkqlKeMQzAmj8zWMgiETHOA0W+0Ir+2HXahwoKfmhc8D6jK6TybUBlVApkyqix9KctlGWUeSF9w2U/lI678OKVbj3apKVfisZIVmrTWOWFlQS6DsKEGVFOFsCGvfToLU8YiGpUHoghW2UfV2laM+msr9ljZhKp3mrhsa8Vn/8wgZP98P0jMGwHPMZbFJaXV3CfzxArf56pYlYC1jMplQFlh/ICzE0hBGL7P51TxgWIJVCjyZ8oiF0UskCb8O3mOsji4KTnPJedLkWhv2xCeGwf3OXY8d2Y8wHGln6taMHGAGQUykFdak0SpwunGpCWJMp7Os0oyiEpEkbxGyjKF+J4N5RiqnKs6AFakNc4jBW2FG+QfAJMmTUJdXZ3+ufnmm3vs0kUXXYSNGzfiD3/4A9544w1cd911WLhwIVavXg0gDiqvr69Pfa+hoQEtLS2DN1YDwIjSqH7ve9/rcfu+++7b62cD3WZQIKT8eXZuH8QCiGWx073Kn1ooDvhKM3559m/XQk14drwaJ1CsbQRi39Qo9reESCTvVy9zlSRaSSlqIrYsqUmIpMbRkvn17Dj6FEhHPMugKw5eCuN8qUqwk6Z18oNY66C0BsrsJoO5OF0KxZNsEICktiEV/KGCOxKDR8kUODqqVo6b57KArvrgSFN6qDRMiewHakLXLgfQv2sNsz6vKBagtdm4i+Sn+8cRuSKf56CWUqlvvzDblmZ/1SZe2Gg3ALXZAgeaCD4HjrbuQXtL3X7pH0kN4ifSxtLOP0uCFzVq/FNVy6Q2TwuMCbO/viTJ/ykuF5wMcNFm/USpX61t1wJoUvCEFFQs1tyJRL5Uy5IBQLYW+gDiiPjaPNBRQLHORjS6FuUxHsIMkFnjx/ef40D4AbzGTkS1VYhcC5nmECIC3LYAVkeRjxPI58uXmlCl+Uy6AciAKU63JReXEWmhSafcUlpGVRwgkeYPRLpKnx5O9Twn3HuEZbEhoRKiUp9BuT6Dqg8LsDsrsMoWrJKvn1O7uQBrC+cbpbJMb5XIa6x8N4VtA9mM1kaGddUIalxYAeBs6+RCBNI3XHgef12Ni7pXlO88wIJeEAIlP/38UwSoQNxIRtGrZ9xhX3cB6Kh5UpkPOovS7UjdqgIkkn6rVjxOYcICpM7RdQBhA8TzGlVkIJqKxlfCalG6XIQRB3fZNvukqmeASC++dY5any0CVKlo/2GtuU2W9d6N2bhxY8qE35s29cQTT0z9fd111+EHP/gBnn76aUydOlV/r6OjI9Wuo6MD2Wx2gHs9sIwoQXW3YYeUlYmXnRJ2yY4TR4uEQNDtODv+4k2a+/uO5hcyIbkKEorS31EaD2VylkEKKlqdLAuUz8iI0SievNTLnKAnQipXYk1tIlk3J8e3tZCgX85qxe+pQCg79msLI55sky8ci10r4qICfJGo4rPwFnBaG2XOSwqGAFgbYNuxy4Dvp3yIeVhU4mtLRg3bLCRqLVCkX0ZCVb8hknl3ZRCHsPXLQPmQJfuiq21RJH11kRBYRCKQQWjfX+2HRhGsfDUoX83jJ7U43W+uhHZav0hEejzimwBaO2hbEAgAS/rkplpR3wJmT0KogM5Ty+fCuXZ1cFG/kG136FlJa+t0Qn7tx6z2l3yeVCeT7QnaQiCFeKH8K5WAqnwtLXl9lbApY250YYsuSftl11iglb+rqkp6oaMCCJW2Pww5f6jnIreuBdQSwEI9rLYinI/bASFg1dTw/VGdgz+uDmGVDRHy4sNr8lmzpnwLleuBI03SIlH4QlohwoZqkGPD2dohZWzBgrUq0WkJriwVEdDWwZaLulqoZS6VytJ8zr6T+vmwlOAuh0U+v6LA7gjFAxqQ/aATzsZt3F4XVpAXTGk8paYPgL4m7PaSYV9SafpWmtMoZ6PjgDwyWypwmjpT9wi5Dkfky3KlFBFnhFGFXAKZL1nNVdqvPHmtwddKCc3JgEmAU28pk7vnQCAHdII1tDLgU8iFir4xVGAVqSAqEd9HRNISQjxXZzM8zyVTY8mgURIAKkWgEPCiw3Xi4DjLYolDKx14LhVqASAD1Uhpih07vrfVfDNS2Il3604dA0BtbW1KUO0vQgjk83ls2bIFALDffvtBCIENGzak2q1fv37Ep6gyguoOoISwHU3839beBj8qI6CK2hF0Yu2+Hj4lfAE80QgBITyQCAGqbP/lvgO13Hf0mRMCcsKLACrrnejcpaodBYmXLmTJPwCWhbAug5Yjx8LujJBtCeE0tsNpbIvbygk4zjVIANmAiEARawhEEACRBQGZsiVC4sUOgMI4j6AS7km+vLTQSIBNEE4ECNIvBzZFAogC1hIqE70cAO3PFwWALwAEEHCBkPg8LQKVCnwNbCfhuypfDCptThQCjnxxWwAQcL5L3wcQcdBFEOhyjyACWYhdDxy1WIm4vdJEyEORzE7NQmxyPJXPmRSWIgGhNZMEyrugoCiTdlN83p4L4Qkgkv1LTdoJNbwAAIvHI6rIwCICuepaJNxV1NeVqS8Iut+TPdyjQmkl1eLPskAItHDWlUpYRltbGyphGQFJLRP1/znRx1WaPEAKrLJyUcoPOLH7ZP8FIFRuYHkv6oAqAQ6mkWVJIUSc/Jwdsfk6Ql5Xivj+V6U0LYsXSXJfgmRfbBsi6ybKZIYg4UO4Hls/inJuigREMYSoqgIyLuCXgNYOoLOCoNYDKgKVvUbBbu6EE1RQscqgMpD7oANuia0OYdKPUmmYPZVKKYIuZ2wJkBOi3ODCKgRAWAb8EChLDWM2y/c2ERAUgXLA42xbQKWgx578khaqWDuJ+N5LpmbzKzrSnTIEu9GDtbUDQcjBWCKKgDCI72cBwOVFFIURaFQekSvgNBdZKM4InoOFAAKhBS9s3oaqUhGWHyEsF6V2WAAugYKiLCkqNaR6kenERVRsO76hhQNhq4wNEYQnb6goAAI/1koHgjWfrnR1Ci2ALMCX7TNyzgkqLChbFkChTHcXxAJnJMt8k7xRwxCAD7I8qCzXvMiQ86WyytiC5/qIeCFa8aXfrNSsqgWW4POAC86aEgQ85rbFY+DKU48ikGNpX1gfPto72tHWVg0gfgePvFLLw4Pv+2htbcWYMWP0thdeeAEff/wxDj/8cABAPp/Hcccdh4ceegjnnXceAC66tHLlSvzmN78Zln73F0HmSvebNWvWbDedlcFgMBgMhqFh48aNmDhx4pAdr62tDXV1dThpyjVw7AFKXdkLQVjG0rd/itbW1j41qoVCAbNnz8bpp5+OadOmYd26dbjllltw0kkn4eGHH9Z+8qtWrcLxxx+Pv//7v8fs2bNx2223oaqqCn/605/gjLBctUlGbs9GIMoJecOGDairqxvm3uzeqOILXf13DEOPuRYjC3M9Rg7mWgwORIT29nbsueeew92VEUFVVRVWrVqFu+++Gy+88AIaGhqwaNEinHbaaal2RxxxBF5++WXcfvvtWLVqFS655BJcdtllI1pIBYygukNY0temrq7OTDojhJ313zEMPOZajCzM9Rg5mGsx8AynsmgkVqaqqanB1772tT7bTZs2Df/+7/++s90aFkZg3geDwWAwGAwGg8FoVA0Gg8FgMBj6zxBG/RuMRnWHyGQy+M53vtNrHjPD0GGuxcjBXIuRhbkeIwdzLQyGT46J+jcYDAaDwWDoAxX1P3fyPw1J1P+S9/+zX1H/f+sYjarBYDAYDAaDYURifFQNBoPBYDAY+ovxUR1SjEbVYDAYDAaDwTAiMRrVfhBFEZ588km89dZb2HPPPfGFL3wB1dXVw92tXR4iwpIlS7Bq1Sp87nOfw6c+9alubXzfx+OPP441a9Zg//33x/z58+G67qC02Z0pFAp45plnsGbNGkyaNAmnn346crlct3avvvoqli1bhmw2izPOOAOTJk0atDa7M++++y6WL1+OSqWCWbNm4dhjj+3WpqmpCYsXL0ZTUxM+/elP4/jjjx+0NgagXC7jZz/7GfL5fI/5Kp966im88cYbGDduHM4880zU1NQMWhuDYXfCaFT7IAxDfP7zn8c//uM/Ys2aNfjJT36Cww47DI2NjcPdtV2a5557DlOmTMEPf/hD3HDDDVi1alW3Np2dnZgzZw6uv/56rFu3Dtdffz3mzJmDzs7OAW+zO/PUU09h+vTpuPPOO7Fhwwb8+Mc/xgEHHIC333471e4//uM/cOyxx+K1117DH//4R0ydOhVLly4dlDa7M1dddRXOPvtsvPLKK3j99ddx1llnYf78+QiCQLd5++23MW3aNNx555145513cPbZZ+PSSy9N7Weg2hiYq6++Gj/84Q+7JUsnIpxzzjm45JJLsGbNGtxyyy045JBDsGnTpgFvYxgpUGz+H6wfGNO/hgzb5Y477qBcLkfr168nIqJCoUBTp06lSy+9dJh7tmvz2muv0TvvvENERNXV1XTrrbd2a/O9732Pxo8fT01NTUREtHXrVtpjjz3o+9///oC32Z155ZVXqLGxUf8dRRHNmTOHzjjjDL1t/fr15Lou3XPPPXrbpZdeSvvttx9FUTSgbXZ3XnjhhdTfr732GgGgpUuX6m0nn3wyzZ07l8Iw1N8BQMuWLRvwNgaiRx55hGbMmEHXXXcd7bPPPqnPfve735HjOHo+K5fLdNhhh9H5558/4G0Mw0traysBoLn7/x869YB/HtSfufv/HwJAra2tw33aw47RqPbBww8/jHnz5mHvvfcGAORyOVxwwQV4+OGHh7lnuzaHHnooDjzwwO22efjhh7FgwQKMHj0aANDQ0IAFCxakxn6g2uzOzJo1C2PHjtV/CyFw1FFHYc2aNXrb4sWLkc1mce655+ptX/3qV7F27Vq89NJLA9pmd+eoo45K/a1ycKr/W1tbsWTJEixcuFCXdT7qqKMwY8YMfU8PVBsDsHHjRlxxxRW47777kM1mu33+8MMP47jjjtPzmed5uPjii/Hoo48iDMMBbWMYIQy2NnUogrV2IYyg2gerV6/GQQcdlNp20EEHYdu2bdi6desw9Wr3oLexX7169YC3McRUKhUsXrw4JTCtXr0a++yzDzzP09vUmKpxHKg2BuCvf/0rbrzxRlxzzTU4++yz8d3vflf7qb7zzjuIomi79/RAtdndCcMQ5513Hq699loceuihPbbpbX4pFArYuHHjgLYxGHZHjKDaBx0dHairq0ttGzVqlP7MMDj4vo9KpdLj2JfLZQRBMGBtDGkuu+wyNDc344YbbtDbenoOampqYNu2fg4Gqo2BBaRSqYS2tjY0NTVh69atWqumxqmnezo5zgPRZnfnO9/5DnK5HK688spe2/TnHTFQbQwjhIiG5scAwET990l1dTXa2tpS21pbW/VnhsHBdV24rtvj2HueB8dxdLuBaGNgrrnmGjz66KNYsmQJJk6cqLf39Bx0dHQgDEP9HAxUGwMwc+ZMzJw5EwCwbt06TJs2DbNnz8aXv/xlPU493dPJcR6INrszW7Zswc0334xLL70UP/jBDwAAK1euRGtrK2688UZ88YtfxNSpU/v1jhioNgbD7ojRqPbBlClT8N5776W2vfvuuxg9enTKr88w8PQ29lOmTBnwNgbgn//5n3H77bfj6aefxuzZs1OfTZkyBevXr4fv+3rbu+++qz8byDaGNPvuuy8mT56MV199FQBw4IEHQgix3Xt6oNrszmQyGXzrW99CfX09SqUSSqUSgiAAEaFUKmkNd2/zSy6X07ENA9XGMEKgaGh+DACMoNonCxYswNNPP40PP/wQAOfSu++++7BgwYJh7tnfPgsWLMAjjzyitQwtLS145JFHUmM/UG12d6677jr89re/xTPPPIPDDz+82+fz589HoVDAI488orfdcccd2HvvvfHpT396QNvszrS1teH9999PbXv//ffx3nvvYfr06QCA0aNH44QTTsBdd90FkgEXL730El5//XV9Tw9Um92Z2tpa3HjjjamfE088EaNGjcKNN96or8eCBQuwfPlyrF27FgAQBAHuuecezJ8/H7ZtD2gbg2F3RBCZ0LLtEQQBTj31VKxduxZnnnkm/vSnP6GxsRHPP/88JkyYMNzd22X54IMPcOeddwIAvv/97+PUU0/F4YcfjunTp+Oss84CALS3t+O4445DEAQ4+eST8dRTT8F1XaxcuVInwR6oNrszt912Gy677DKcddZZqaIL2WwW3/jGN/TfN910E2666SZceOGFOkn8Y489hlNPPXXA2+yuNDc348QTT8TkyZMxZcoUbNmyBQ899BCOP/54/O53v9NBaH/9619x/PHHY/bs2Tj44INx//3349RTT8Xdd9+t9zVQbQwx3/3ud3HXXXdh3bp1elsURfjCF76A1157DV/84hexatUqrF27Fn/+85+x7777Dmgbw/DS1taGuro6zJ30j3CszKAeK4jKWLLxVrS2tqK2tnZQjzXSMYJqPwjDEI8++qiuTHXOOefs9jfOJ2XTpk341a9+1W37oYcemkpdVCqV8PDDD+uKUl/84he7pYgZqDa7K08//TRWrlzZbXsul8O3v/3t1LYXX3wRzz77LDKZDM4880zsv//+3b43UG12V8IwxJNPPok33ngDo0aNwuGHH96jtrmxsREPP/ywrijVk6A/UG0MzLPPPotXXnkF11xzTWp7FEV4/PHHdUWpc845R6fDG+g2huHDCKrDgxFUDQaDwWAwGPpAC6p7XTY0guoHvzKCKoyPqsFgMBgMBoNhhGJy8xgMBoPBYDD0l6GoHGWM3RqjUTUYDAaDwWAwjEiMRtVgMBgMBoOhvxCGQKM6uLvflTAaVYPBYDAYDAbDiMRoVA0Gg8FgMBj6i/FRHVKMRtVgMBgMBoPBMCIxgqrBsJty++2349577x3ubuw0RITrr78+VSXIsONEUYTLLrsM77zzTo+fVyoVXHnllWhubh7inhkMI5QoGpofAwAjqBoMuy3PPPMMli9fPtzd2Gnuu+8+LF269G+yvOQVV1yBN998c0iOFUURbrvtNnz44Yc9fu55HoIgwL/9278NSX8MBoMhiRFUDQbDLgcR4Xvf+x6uuuqq4e7KoHDbbbdhw4YNw90NzZVXXolf//rX2Lx583B3xWAYfpSP6mD/GACYYCqDYZelsbERixYtwvr16zF9+nRcdNFF8DxPf/7OO+/ggQcewLZt2zB9+nRceOGFyOVyve7vxz/+MQ455BB87nOf09vuvvtuRFGESy65BADwy1/+EmPHjkVDQwNWrlyJUqmEv/u7v8OsWbPwzDPP4Omnn0Y+n8eXv/xl7LPPPno/6nsTJ07EM888g0qlgrPOOguzZ8/WbYrFIhYtWoQ333wTEyZMwDnnnJPaR5Jly5bhgw8+wFlnnaW3PfTQQ1i6dCkAoL6+HkcccQTOPPPMHRo31c9x48bhD3/4AxoaGnDttdcCAJ566iksWbIEADB37lyccsopqf1u2LAB999/PxobGzF9+nScf/75yGQyfX7Wleuuuw5RFOGWW27BY489hoaGBnz/+9/H5ZdfjiuvvBIvvPACXnvtNZx22mk45ZRT8O1vfxvbtm2DZVmYOHEiTj/9dMycObPbfl9++WU8/vjjKBQKmDdvHubNm9fj8QHg1VdfxW233YYrrrgCM2bMwEEHHYQZM2bg7rvv1uNhMBgMQ4HRqBoMuyD/+7//i2nTpuGJJ57AhAkTsGrVqpRQtnz5chx66KF49913MWHCBPziF7/A0UcfjXK53Os+H3nkEbz00kupbcuWLdPCHwA88cQT+NrXvoZ//dd/RT6fx/vvv48jjzwSF198MW688UaMGzcOL7/8Mg4//HC0tramvnf11Vfj6quvRi6Xw+bNm3H00UfjxRdf1G3mzp2L2267DXvuuSe2bduG+fPnY/Xq1T329emnn8bs2bNTwt5ee+2FWbNmYdasWchms7jqqqvwla98ZYfG7YknnsBVV12Fa665BmPGjMGBBx4IgIXHc889F57nwfM8nHPOOfjmN7+pv/f+++9jxowZePPNNzFp0iS8+OKLWhDc3mc9MX36dAghMHnyZMyaNQsHH3ywNs+fcsopeOaZZ3DggQdi3LhxAICDDz4Ys2bNwowZM/DRRx9hzpw5eOyxx1L7/OlPf4qjjz4aH3/8McaMGYOf/OQnuOWWW3o8/ooVK3DCCSdg2rRpmDFjht7+mc98Bk899VSv/TYYDIbBwGhUDYZdkIULF+KUU07BokWL9LakqfjrX/86LrnkEtx6660AgMsvvxz7778//uu//gtXX331Jzr2qFGjsGLFCjiOAyLCvvvui1deeQWvvvoqLMvCP/3TP2HChAn47//+b1xwwQX6e7lcDitXroTrugCAjRs34s4778SRRx6JDz/8EM8//zzWrVuntaj/8i//glKp1GMf3nrrLey///6pbccccwyOOeYY/ffFF1+M/fbbD9dff71u29e4AYAQAs899xyy2SwA1kz/9Kc/xR/+8AetRT322GMxf/58LFy4EAcddBCeeuopTJ48GXfffbfez/r16wFgu5/1xEUXXYSFCxfitNNOw6mnngoACIIAAHDyySfjt7/9bar9+eefn/r7wAMPxHe+8x0tgL/33nu49tprsWjRInzpS18CAFx77bU9uhY8/vjjuOCCC3Drrbd22+/kyZPx4IMP9tpvg2G3waSnGlKMoGow7GJs3LgRb7zxRjeN2N577w0A2Lp1K/76179qIRUAamtr8YUvfAHLli37xILqZz/7WTgOTx1K83fIIYfAsthA4zgO9ttvP2zcuDH1vRNOOEELqQAwbdo0HWne0NCAMWPG4Oabb8ZVV12FKVOmoLq6GtXV1T32ob29HZMmTeq2/Y9//CNeeOEFbNmyBVEUwXVdrF69Gvvvv3+f46Y48cQTtZAKACtXrsTo0aNTpv7TTjsNo0aNwnPPPYeDDjoIU6ZMwerVq/Gb3/wGZ511FsaMGaMF7u19tqOcfvrp3bZ1dnbiwQcfxNtvv43W1lZ89NFHePvtt0FEEELgySefRF1dnRZSezvve+65Bw899BDuv//+Ho+Tz+fR1ta2U/02GAyGncWY/g2GXYympiYA0KbfrjQ2NgIAxo4dm9o+duzYAQmG6ernallWj9vCMNzu92zb1m0ymQyWLVuGjo4OHHfccdhrr71w7bXXolgs9tiH+vp6tLS0pLZ99atfxVe+8hWUSiVMnToVs2bNguM4Wrjqa9wUo0ePTv3d2NiIMWPGdGs3ZswYPZ4nnXQS7rrrLjz44IPYe++9cdhhh+G+++7r87NFixbhsssu0z99CYJd+9ba2opZs2bh9ttvR01NDQ499FAccMABKJfL2s2jqakJe+yxx3b3CwBLly7FxIkTcdRRR/X4eUtLCxoaGvrcj8HwN09EQ/NjAGA0qgbDLseee+4JAFizZg2mTp3a7XOladywYQOmTJmit69fv76bFi2J53moVCqpbS0tLcjn8wPR7T6ZMWMG7r33XhAR/ud//gcLFixAXV0dvv3tb3drO3PmTDz66KP670KhgDvuuAMrVqzAnDlzAAAdHR24/PLLdZu+xq03Jk2ahA8//BBhGMK2bQBsiv/www9T4/mlL30JX/rSl1Aul3HPPffgwgsvxMyZMzFjxoxeP5s0aRJmzZql96E0zkKIfvXtySefRHt7O9566y2t5VZCsGKvvfbCpk2b4Pt+SqPdlV/96lf42c9+hrlz52Lp0qWor69Pff7mm2/isMMO61e/DAaDYaAwGlWDYRdj7NixOOmkk/CjH/0opXFctmwZAKCmpgZz587FLbfcgkgmjV6zZg0WL16cipLvygEHHIC//OUv+u+NGzfqfQ42H3zwAVatWgWAhbQjjjgCkydPxtatW3tsf9ppp+H111/XWlIiAhGhUCjoNj/+8Y9BCT+vvsatN+bNm4coinDHHXfobb/97W9BRDoo6s9//rPWZGcyGT3O27Zt2+5nn/nMZ1IaVaV1Hj16dL8S7EdRhCAI9AKjWCx2c234/Oc/DyLCT37yE72tVCqlrjUAZLNZLF68GHvssQfmzp2rx1axYsUKnHbaaX32yWD4W4coGpIfA2M0qgbDLsgdd9yB0047DQcffDCOOeYYvPfee5g5cyZOOOEEAMAtt9yCuXPnYvbs2Zg6dSqeeeYZnHHGGTjvvPN63edVV12F4447TpveX3rppe1qYAcS27Zx5ZVXIooiTJ06Fe+//z7WrFmD3/zmNz22nz17Nj796U/jvvvuw9e//nVUV1fjiiuuwLnnnoszzjgDGzZsQGNjYzcf177GrSfGjx+Pn//857j88suxePFiAGwm/+Uvf6ndCNrb23HMMcdg8uTJmDBhApYvX45TTz0VxxxzDJYuXdrrZ70xf/58fPOb38TSpUsxbtw43HDDDb22u/HGG/V4PP/8893cA8aNG4dFixbhwgsvxO9//3vsu+++eOmll3DTTTd1258SVufPn4+5c+diyZIlqK+vx4svvojNmzd3C7AyGAyGwUYQmdAyg2FXJAgCrFixAps2bcIhhxyCT33qU6nPOzs7sWTJEjQ1NWH69Ok44ogjUp8vWbIEruvi+OOP19s2b96MFStWIJfL4ZhjjsHrr78OIsKJJ54IADowJylk/f73v8fYsWNx5JFH6m2PPvoo9tlnH92nnr73l7/8BU1NTSkt3apVq7B69WqMHTsWJ5xwQiqoqSvLli3DP/zDP2D16tU6D+rzzz+Pt99+G+PGjcNJJ52EBx54AHPmzMHkyZP7NW499VOxceNGrFixAkIIHHfccd2CuTo7O/GnP/0JjY2NmDJlSmq8t/dZTxARnn32Waxbtw7ZbBbnnXcebrvtNsyfP1+7MChKpRKeeuopNDU14ZBDDsHEiRPx2GOP4atf/ap2VQDYV3XZsmXwfR9z5szBxIkT9bG67rtYLOLee+/FtGnTMGfOHCxYsABHHHFEKiWXwbC70dbWhrq6Opw06iI4wuv7C5+AgCpY2vJ/0draitra2kE91kjHCKoGg2GX5cEHH8ScOXOw1157DXdX/mbxfR933nknvvzlL6cKShgMuxtGUB0ejKBqMBgMBoPB0AdaUK27cGgE1dZ7jKAKE0xlMBgMBoPBYBihmGAqg8FgMBgMhv4SRYAY5Kh8E/WvMRpVg8FgMBgMBsOIxGhUDQaDwWAwGPoLEYBBDu8x4UMao1E1GAwGg8FgMIxIjEbVYDAYDAaDoZ9QFIEG2UfVVKaKMRpVg8FgMBgMBsOIxGhUDQaDwWAwGPqL8VEdUoxG1WAwGAwGg8EwIjEaVYPBYDAYDIb+EhEgjEZ1qDAaVYPBYDAYDAbDiMQIqgaDwWAwGAyGEYkx/RsMBoPBYDD0FyIAg11C1Zj+FUajajAYDAaDwWAYkRiNqsFgMBgMBkM/oYhAgxxMRUajqjEaVYPBYDAYDAbDiMRoVA0Gg8FgMBj6C0UYfB9VU0JVYTSqBoPBYDAYDIYRidGoGgwGg8FgMPQT46M6tBiNqsFgMBgMBoNhRGI0qgaDwWAwGAz9xfioDilGUDUYDAaDwWDoJwF8YJAt8wH8wT3ALoQRVA0Gg8FgMBj6wPM8jB8/Hn/6+IkhOd748ePhed6QHGskI8h47BoMBoPBYDD0SalUQqVSGZJjeZ6HbDY7JMcayRhB1WAwGAwGg8EwIjFR/waDwWAwGAyGEYkRVA0Gg8FgMBgMIxIjqBoMBoPBYDAYRiRGUDUYDAaDwWAwjEiMoGowGAwGg8FgGJEYQdVgMBgMBoPBMCIxgqrBYDAYDAaDYUTy/wGiZLdkxz9KjAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md b/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md index f33147b1..e6a7a7c5 100644 --- a/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md +++ b/docs/superpowers/plans/2026-07-27-s3-olci-reprojection.md @@ -37,6 +37,7 @@ Create `tests/test_olci_reproject.py`: ```python +# test: skip """Tests for OLCI swath -> regular grid reprojection.""" from __future__ import annotations diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 8177052f..a6731550 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -1302,6 +1302,12 @@ def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> action="store_true", help="Preserve scale-offset encoding instead of decoding to float", ) + p.add_argument( + "--target-crs", + type=str, + default="EPSG:4326", + help="Target CRS for the reprojected output grid (default: EPSG:4326)", + ) p.add_argument("--verbose", action="store_true", help="Enable verbose output") p.set_defaults(func=convert_s3_olci_optimized_command) @@ -1324,6 +1330,7 @@ def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: compression_level=args.compression_level, min_dimension=args.min_dimension, keep_scale_offset=args.keep_scale_offset, + target_crs=args.target_crs, ) log.info("S3 OLCI optimization completed", output_path=args.output_path) diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json index 115ae6af..78d96999 100644 --- a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -2326,11 +2326,26 @@ ], "resampling_method": "average" }, + "proj:code": "EPSG:4326", + "spatial:bbox": [ + 10.0, + 45.0, + 26.0, + 61.0 + ], "spatial:dimensions": [ - "rows", - "columns" + "y", + "x" ], "spatial:registration": "pixel", + "spatial:transform": [ + 1.0, + 0.0, + 10.0, + 0.0, + -1.0, + 61.0 + ], "zarr_conventions": [ { "description": "Multiscale layout of zarr datasets", @@ -2345,6 +2360,13 @@ "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" + }, + { + "description": "Coordinate reference system information for geospatial data", + "name": "proj:", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", + "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" } ] }, @@ -4247,10 +4269,49 @@ "zarr_format": 3 }, "r0": { - "attributes": {}, + "attributes": { + "proj:code": "EPSG:4326", + "spatial:bbox": [ + 10.0, + 45.0, + 26.0, + 61.0 + ], + "spatial:dimensions": [ + "y", + "x" + ], + "spatial:registration": "pixel", + "spatial:transform": [ + 1.0, + 0.0, + 10.0, + 0.0, + -1.0, + 61.0 + ], + "zarr_conventions": [ + { + "description": "Spatial coordinate information", + "name": "spatial:", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/spatial/54d81b7ced0376e63ee10f34db31db7d08dcc28d/schema.json", + "spec_url": "https://github.com/zarr-conventions/spatial/blob/54d81b7ced0376e63ee10f34db31db7d08dcc28d/README.md", + "uuid": "689b58e2-cf7b-45e0-9fff-9cfc0883d6b4" + }, + { + "description": "Coordinate reference system information for geospatial data", + "name": "proj:", + "schema_url": "https://raw.githubusercontent.com/zarr-conventions/proj/5ca5b2f92e5c7245f957d9128b289ee535f0720d/schema.json", + "spec_url": "https://github.com/zarr-conventions/proj/blob/5ca5b2f92e5c7245f957d9128b289ee535f0720d/README.md", + "uuid": "f17cb550-5864-4468-aeb7-f3180cfb622f" + } + ] + }, "members": { "altitude": { "attributes": { + "_FillValue": 32767, + "coordinates": "spatial_ref", "dimensions": [ "rows", "columns" @@ -4259,6 +4320,7 @@ "eopf_is_masked": true, "eopf_target_dtype": " Date: Mon, 27 Jul 2026 21:53:22 +0200 Subject: [PATCH 54/58] test: cross-product contract - every converted product is a regular grid with CRS Adds tests/test_geozarr_output_contract.py, a parametrized test over all three converters (OLCI, S1, S2) asserting the hard requirement that every multiscale level is a regular grid with a declared, pyproj-round-trippable CRS. OLCI passes with no marks. S1/S2 whole-store open_datatree is xfailed (legacy asset='.' nested layout). S1/S2 per-level CRS detection is also xfailed: the generic converter (geozarr.py) only stamps zarr-cm proj:/ spatial: convention attrs on the base-resolution group, not on overview sub-groups, so rioxarray can't auto-detect CRS there on a plain xr.open_dataset read. Also extracts the Sentinel-2 fixture body into an importable build_sample_sentinel2_datatree() so the contract test can build the same sample tree without needing the pytest fixture machinery. Assisted-by: ClaudeCode:claude-sonnet-5 --- tests/test_geozarr_output_contract.py | 164 ++++++++++++++++++++++++++ tests/test_integration_sentinel2.py | 12 +- 2 files changed, 172 insertions(+), 4 deletions(-) create mode 100644 tests/test_geozarr_output_contract.py diff --git a/tests/test_geozarr_output_contract.py b/tests/test_geozarr_output_contract.py new file mode 100644 index 00000000..9c256326 --- /dev/null +++ b/tests/test_geozarr_output_contract.py @@ -0,0 +1,164 @@ +"""Cross-product output contract. + +Reprojection to a regular grid with a declared CRS is a hard requirement for +every converted product (see +docs/superpowers/specs/2026-07-27-s3-olci-reprojection-design.md). One +parametrized test walks each converter's output and asserts the contract at +every multiscale level. Products whose converter has not yet migrated off the +legacy nested layout carry an xfail on the whole-store DataTree check so the +requirement stays on record. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING +from unittest.mock import patch + +import numpy as np +import pytest +import rioxarray # noqa: F401 +import xarray as xr +import zarr +from pyproj import CRS as ProjCRS + +from eopf_geozarr.conversion import create_geozarr_dataset +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + +from .test_integration_sentinel1 import MockSentinel1L1GRDBuilder +from .test_integration_sentinel2 import build_sample_sentinel2_datatree +from .test_olci_integration import build_synthetic_olci + +if TYPE_CHECKING: + import pathlib + from collections.abc import Callable + + +def _convert_olci(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "olci.zarr" + convert_olci_optimized( + build_synthetic_olci(rows=256, cols=256), output_path=str(out), min_dimension=64 + ) + return out + + +def _convert_s1(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "s1.zarr" + dt = MockSentinel1L1GRDBuilder("20170508T164830_0025_A094_8604_01B54C").build() + with patch("eopf_geozarr.conversion.geozarr.print"): + create_geozarr_dataset( + dt, + groups=["measurements"], + output_path=str(out), + gcp_group="conditions/gcp", + ) + return out + + +def _convert_s2(tmp: pathlib.Path) -> pathlib.Path: + out = tmp / "s2.zarr" + with patch("eopf_geozarr.conversion.geozarr.print"): + create_geozarr_dataset( + build_sample_sentinel2_datatree(), + groups=["/measurements/reflectance/r10m"], + output_path=str(out), + ) + return out + + +PRODUCT_CONVERTERS: dict[str, Callable[[pathlib.Path], pathlib.Path]] = { + "olci": _convert_olci, + "s1": _convert_s1, + "s2": _convert_s2, +} + +#: Converters that still write the legacy layout (native at group root with +#: asset "."), which xr.open_datatree rejects. The xfail keeps the hard +#: requirement on record until the generic converter migrates (cf. PR #212). +DATATREE_XFAIL: dict[str, str] = { + "s1": "generic converter still writes asset='.' nested overview layout", + "s2": "generic converter still writes asset='.' nested overview layout", +} + +#: Converters whose overview (non-base) pyramid levels don't carry a +#: rioxarray-detectable CRS. The generic converter (geozarr.py) only stamps +#: the zarr-cm proj:/spatial: convention attrs on the base-resolution group; +#: overview sub-groups (r2, r4, ...) get a legacy CF-style `grid_mapping` +#: attribute plus a `spatial_ref` variable that is never promoted back to a +#: coordinate on plain `xr.open_dataset` reads, so rioxarray's CF and Zarr +#: convention readers both fail to auto-detect the CRS there. OLCI does not +#: have this gap: it stamps proj:/spatial: convention attrs on every level +#: (cf. PR #212, commit c21e793). +REGULAR_GRID_XFAIL: dict[str, str] = { + "s1": "generic converter only stamps proj:/spatial: convention attrs on the " + "base group; overview levels (r2, ...) have no rioxarray-detectable CRS", + "s2": "generic converter only stamps proj:/spatial: convention attrs on the " + "base group; overview levels (r2, ...) have no rioxarray-detectable CRS", +} + + +@pytest.fixture(scope="module", params=sorted(PRODUCT_CONVERTERS), ids=str) +def converted_store( + request: pytest.FixtureRequest, tmp_path_factory: pytest.TempPathFactory +) -> tuple[pathlib.Path, str]: + name = str(request.param) + store = PRODUCT_CONVERTERS[name](tmp_path_factory.mktemp(name)) + return store, name + + +def _multiscale_level_paths(store: pathlib.Path) -> list[str]: + """Every pyramid-level group path, discovered via multiscales layout attrs.""" + root = zarr.open_group(str(store), mode="r") + found: list[str] = [] + + def walk(group: zarr.Group, path: str) -> None: + attrs = dict(group.attrs) + multiscales = attrs.get("multiscales") + if isinstance(multiscales, dict): + layout = multiscales.get("layout") + assert isinstance(layout, list) + for entry in layout: + assert isinstance(entry, dict) + asset = entry["asset"] + assert isinstance(asset, str) + found.append(path if asset == "." else f"{path}/{asset}" if path else asset) + for key in group.group_keys(): + child = group[key] + assert isinstance(child, zarr.Group) + walk(child, f"{path}/{key}" if path else key) + + walk(root, "") + return found + + +def test_every_level_is_regular_grid_with_crs( + converted_store: tuple[pathlib.Path, str], +) -> None: + """Hard requirement: each pyramid level is a regular grid with a real CRS.""" + store, name = converted_store + if name in REGULAR_GRID_XFAIL: + pytest.xfail(REGULAR_GRID_XFAIL[name]) + levels = _multiscale_level_paths(store) + assert levels, f"{name}: no multiscale groups found in {store}" + for level in levels: + ds = xr.open_dataset(str(store), group=level, engine="zarr", consolidated=False) + crs = ds.rio.crs + assert crs is not None, f"{name}:{level}: no CRS declared" + # CRS round-trips through pyproj + ProjCRS.from_user_input(crs.to_wkt()) + for dim in ("y", "x"): + assert dim in ds.sizes, f"{name}:{level}: missing spatial dim {dim}" + coord = ds[dim] + assert coord.ndim == 1, f"{name}:{level}: {dim} coordinate is not 1-D" + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]), ( + f"{name}:{level}: {dim} coordinate spacing is not regular" + ) + ds.close() + + +def test_store_opens_as_datatree(converted_store: tuple[pathlib.Path, str]) -> None: + """Hard requirement: the whole store opens with xr.open_datatree.""" + store, name = converted_store + if name in DATATREE_XFAIL: + pytest.xfail(DATATREE_XFAIL[name]) + xr.open_datatree(str(store), engine="zarr", consolidated=False, chunks={}) diff --git a/tests/test_integration_sentinel2.py b/tests/test_integration_sentinel2.py index 91b6b7bc..96cf50ba 100644 --- a/tests/test_integration_sentinel2.py +++ b/tests/test_integration_sentinel2.py @@ -27,10 +27,8 @@ ) -@pytest.fixture -def sample_sentinel2_datatree() -> xr.DataTree: - """ - Create a sample Sentinel-2 EOPF DataTree structure for testing. +def build_sample_sentinel2_datatree() -> xr.DataTree: + """Build the sample Sentinel-2 EOPF DataTree (importable, non-fixture form). This mimics the structure from the notebook: - Multiple resolution groups (r10m, r20m, r60m) @@ -221,6 +219,12 @@ def sample_sentinel2_datatree() -> xr.DataTree: return dt +@pytest.fixture +def sample_sentinel2_datatree() -> xr.DataTree: + """Create a sample Sentinel-2 EOPF DataTree structure for testing.""" + return build_sample_sentinel2_datatree() + + @pytest.fixture def temp_output_dir() -> Generator[str, None, None]: """Create a temporary directory for test outputs.""" From 2cab0105416e28c322b5c618dddec5614adce54c Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 21:54:33 +0200 Subject: [PATCH 55/58] docs(s3-olci): fix stale notebook intro to describe reprojected grid Assisted-by: ClaudeCode:claude-fable-5 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index 80307c74..e829a982 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -16,9 +16,11 @@ " four quadrants, each rendered from a *different* overview level.\n", "\n", "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", - "no projected CRS). The exporter preserves that native geometry — it does not\n", - "reproject — and builds overviews by fill-aware 2×2 block averaging of the\n", - "radiance bands (coordinates are decimated to keep real measured positions).\n", + "no projected CRS). The exporter warps the swath once onto a regular grid\n", + "(default `EPSG:4326`) using the dense per-pixel geolocation, then builds\n", + "overviews by fill-aware 2×2 block averaging of the radiance bands. Every\n", + "pyramid level declares its CRS (`spatial_ref`/`grid_mapping` plus `proj:`\n", + "convention attrs), so generic GeoZarr readers can tile it directly.\n", "\n", "> Requires the `notebooks` dependency group:\n", "> `uv sync --group notebooks` (jupyter, matplotlib, nbformat)." From 863a1f5ecde5180da2c69badc19cbae957c83b38 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Mon, 27 Jul 2026 22:09:13 +0200 Subject: [PATCH 56/58] fix(test): open contract levels with decode_coords=all, drop bogus S1/S2 xfail Opening each pyramid level with the default xarray zarr decode never promotes a CF grid_mapping/spatial_ref reference into a coordinate, so ds.rio.crs came back None for S1/S2 overview levels and I wrongly attributed that to a converter gap and added an xfail. The converter's own read path already uses decode_coords="all" for exactly this reason (geozarr.py:1132, :1541). Passing the same flag in the test makes CRS detection succeed for every product's every level (S2 r2 -> EPSG:32632, S1 r2 -> EPSG:4326), so REGULAR_GRID_XFAIL is removed entirely - test_every_level_is_regular_grid_with_crs now genuinely passes for olci/s1/s2 with no marks. DATATREE_XFAIL (asset='.' nested layout) is unrelated and unchanged. Assisted-by: ClaudeCode:claude-sonnet-5 --- tests/test_geozarr_output_contract.py | 31 +++++++++++---------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/tests/test_geozarr_output_contract.py b/tests/test_geozarr_output_contract.py index 9c256326..f968c938 100644 --- a/tests/test_geozarr_output_contract.py +++ b/tests/test_geozarr_output_contract.py @@ -7,6 +7,15 @@ every multiscale level. Products whose converter has not yet migrated off the legacy nested layout carry an xfail on the whole-store DataTree check so the requirement stays on record. + +Per-level CRS detection requires opening each level with +``decode_coords="all"`` (the generic converter's own read path uses the same +flag, see geozarr.py) so the CF `grid_mapping`/`spatial_ref` reference gets +promoted into a coordinate; the default `xr.open_dataset` decode never does +this. Separately, S1/S2 overview sub-groups (r2, r4, ...) still lack the +zarr-cm proj:/spatial: convention attrs that OLCI stamps on every level — a +real design-consistency gap, but not one that defeats CRS detection here, so +it is tracked outside this test rather than xfailed. """ from __future__ import annotations @@ -79,22 +88,6 @@ def _convert_s2(tmp: pathlib.Path) -> pathlib.Path: "s2": "generic converter still writes asset='.' nested overview layout", } -#: Converters whose overview (non-base) pyramid levels don't carry a -#: rioxarray-detectable CRS. The generic converter (geozarr.py) only stamps -#: the zarr-cm proj:/spatial: convention attrs on the base-resolution group; -#: overview sub-groups (r2, r4, ...) get a legacy CF-style `grid_mapping` -#: attribute plus a `spatial_ref` variable that is never promoted back to a -#: coordinate on plain `xr.open_dataset` reads, so rioxarray's CF and Zarr -#: convention readers both fail to auto-detect the CRS there. OLCI does not -#: have this gap: it stamps proj:/spatial: convention attrs on every level -#: (cf. PR #212, commit c21e793). -REGULAR_GRID_XFAIL: dict[str, str] = { - "s1": "generic converter only stamps proj:/spatial: convention attrs on the " - "base group; overview levels (r2, ...) have no rioxarray-detectable CRS", - "s2": "generic converter only stamps proj:/spatial: convention attrs on the " - "base group; overview levels (r2, ...) have no rioxarray-detectable CRS", -} - @pytest.fixture(scope="module", params=sorted(PRODUCT_CONVERTERS), ids=str) def converted_store( @@ -135,12 +128,12 @@ def test_every_level_is_regular_grid_with_crs( ) -> None: """Hard requirement: each pyramid level is a regular grid with a real CRS.""" store, name = converted_store - if name in REGULAR_GRID_XFAIL: - pytest.xfail(REGULAR_GRID_XFAIL[name]) levels = _multiscale_level_paths(store) assert levels, f"{name}: no multiscale groups found in {store}" for level in levels: - ds = xr.open_dataset(str(store), group=level, engine="zarr", consolidated=False) + ds = xr.open_dataset( + str(store), group=level, engine="zarr", consolidated=False, decode_coords="all" + ) crs = ds.rio.crs assert crs is not None, f"{name}:{level}: no CRS declared" # CRS round-trips through pyproj From bc65f79d218ac4604ae2d5c3381619888c8def24 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 28 Jul 2026 06:41:00 +0200 Subject: [PATCH 57/58] test(s3-olci): cover projected --target-crs end-to-end (EPSG:3857) Assisted-by: ClaudeCode:claude-fable-5 --- tests/test_olci_reproject.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/tests/test_olci_reproject.py b/tests/test_olci_reproject.py index 0db49d26..33aa30fd 100644 --- a/tests/test_olci_reproject.py +++ b/tests/test_olci_reproject.py @@ -119,3 +119,30 @@ def test_reproject_olci_degenerate_extent_raises() -> None: ) with pytest.raises(ValueError, match="degenerate"): reproject_olci(ds) + + +def test_reproject_olci_projected_target_crs() -> None: + """Warping to a projected target CRS yields a metric grid with matching coord attrs. + + Exercises the non-geographic branch end-to-end: the CLI-advertised + --target-crs flag must produce a regular grid in the requested CRS, with + projection_x/y_coordinate standard names and metre units on the 1-D coords. + """ + ds = build_rotated_swath() + out = reproject_olci(ds, target_crs="EPSG:3857") + + assert out.rio.crs is not None + assert out.rio.crs.to_epsg() == 3857 + for dim, std_name in ( + ("y", "projection_y_coordinate"), + ("x", "projection_x_coordinate"), + ): + coord = out[dim] + assert coord.ndim == 1 + steps = np.diff(coord.values) + assert np.allclose(steps, steps[0]) + assert coord.attrs["standard_name"] == std_name + assert coord.attrs["units"] == "m" + band = out["oa01_radiance"] + assert band.dtype == np.dtype("uint16") + assert band.attrs["grid_mapping"] == "spatial_ref" From 547981dec2ff8ff6e7a9ecd7e170443f171582b0 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Tue, 28 Jul 2026 08:50:28 +0200 Subject: [PATCH 58/58] docs(s3-olci): re-execute notebook against merged converter Assisted-by: ClaudeCode:claude-fable-5 --- docs/notebooks/sentinel3_olci_geozarr.ipynb | 138 ++++++++++---------- 1 file changed, 69 insertions(+), 69 deletions(-) diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb index e829a982..36ad101d 100644 --- a/docs/notebooks/sentinel3_olci_geozarr.ipynb +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -32,10 +32,10 @@ "id": "96531b64", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:44:34.843116Z", - "iopub.status.busy": "2026-07-27T17:44:34.843026Z", - "iopub.status.idle": "2026-07-27T17:44:36.176995Z", - "shell.execute_reply": "2026-07-27T17:44:36.176300Z" + "iopub.execute_input": "2026-07-28T06:42:29.715144Z", + "iopub.status.busy": "2026-07-28T06:42:29.715055Z", + "iopub.status.idle": "2026-07-28T06:42:31.808045Z", + "shell.execute_reply": "2026-07-28T06:42:31.807326Z" } }, "outputs": [], @@ -79,10 +79,10 @@ "id": "baf81f90", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:44:36.179646Z", - "iopub.status.busy": "2026-07-27T17:44:36.179406Z", - "iopub.status.idle": "2026-07-27T17:44:36.884522Z", - "shell.execute_reply": "2026-07-27T17:44:36.883632Z" + "iopub.execute_input": "2026-07-28T06:42:31.810203Z", + "iopub.status.busy": "2026-07-28T06:42:31.809957Z", + "iopub.status.idle": "2026-07-28T06:42:32.915643Z", + "shell.execute_reply": "2026-07-28T06:42:32.914869Z" } }, "outputs": [ @@ -168,10 +168,10 @@ "id": "3bab9194", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:44:36.886439Z", - "iopub.status.busy": "2026-07-27T17:44:36.886283Z", - "iopub.status.idle": "2026-07-27T17:44:36.890669Z", - "shell.execute_reply": "2026-07-27T17:44:36.890086Z" + "iopub.execute_input": "2026-07-28T06:42:32.917397Z", + "iopub.status.busy": "2026-07-28T06:42:32.917242Z", + "iopub.status.idle": "2026-07-28T06:42:32.921736Z", + "shell.execute_reply": "2026-07-28T06:42:32.921001Z" } }, "outputs": [ @@ -213,10 +213,10 @@ "id": "35c20e40", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:44:36.892714Z", - "iopub.status.busy": "2026-07-27T17:44:36.892535Z", - "iopub.status.idle": "2026-07-27T17:44:36.969219Z", - "shell.execute_reply": "2026-07-27T17:44:36.968562Z" + "iopub.execute_input": "2026-07-28T06:42:32.923263Z", + "iopub.status.busy": "2026-07-28T06:42:32.923119Z", + "iopub.status.idle": "2026-07-28T06:42:33.001243Z", + "shell.execute_reply": "2026-07-28T06:42:33.000704Z" } }, "outputs": [ @@ -256,10 +256,10 @@ "id": "781d44e8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:44:36.970816Z", - "iopub.status.busy": "2026-07-27T17:44:36.970716Z", - "iopub.status.idle": "2026-07-27T17:51:07.680749Z", - "shell.execute_reply": "2026-07-27T17:51:07.680089Z" + "iopub.execute_input": "2026-07-28T06:42:33.002683Z", + "iopub.status.busy": "2026-07-28T06:42:33.002577Z", + "iopub.status.idle": "2026-07-28T06:48:56.873720Z", + "shell.execute_reply": "2026-07-28T06:48:56.873157Z" } }, "outputs": [ @@ -267,175 +267,175 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:44:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mReprojecting OLCI swath \u001b[0m \u001b[36mdst_shape\u001b[0m=\u001b[35m(4371, 6773)\u001b[0m \u001b[36msrc_shape\u001b[0m=\u001b[35m(4090, 4865)\u001b[0m \u001b[36mtarget_crs\u001b[0m=\u001b[35mEPSG:4326\u001b[0m\n" + "\u001b[2m2026-07-28 08:42:46\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mReprojecting OLCI swath \u001b[0m \u001b[36mdst_shape\u001b[0m=\u001b[35m(4371, 6773)\u001b[0m \u001b[36msrc_shape\u001b[0m=\u001b[35m(4090, 4865)\u001b[0m \u001b[36mtarget_crs\u001b[0m=\u001b[35mEPSG:4326\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mDropping swath-bound variable with no grid home\u001b[0m \u001b[36mvariable\u001b[0m=\u001b[35mtime_stamp\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:08\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mDropping swath-bound variable with no grid home\u001b[0m \u001b[36mvariable\u001b[0m=\u001b[35mtime_stamp\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:22\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4371, 'x': 6773}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4371, 'x': 6773}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:24\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m10\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:11\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m10\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:44\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 2185, 'x': 3386}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:31\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 2185, 'x': 3386}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 1092, 'x': 1693}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:36\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 1092, 'x': 1693}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 546, 'x': 846}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:37\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 546, 'x': 846}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 273, 'x': 423}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 273, 'x': 423}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 136, 'x': 211}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 136, 'x': 211}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:50\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 68, 'x': 105}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 68, 'x': 105}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 34, 'x': 52}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:38\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 34, 'x': 52}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 17, 'x': 26}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 17, 'x': 26}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 8, 'x': 13}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 8, 'x': 13}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r1024\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4, 'x': 6}\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r1024\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'y': 4, 'x': 6}\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:51\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:52\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:40\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:43\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:50:56\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:51:05\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:54\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:51:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[2m2026-07-27 19:51:06\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + "\u001b[2m2026-07-28 08:48:55\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" ] }, { @@ -450,7 +450,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3423171/683526426.py:13: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/683526426.py:13: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", @@ -494,10 +494,10 @@ "id": "3f654e2e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:51:07.682641Z", - "iopub.status.busy": "2026-07-27T17:51:07.682491Z", - "iopub.status.idle": "2026-07-27T17:51:07.937062Z", - "shell.execute_reply": "2026-07-27T17:51:07.935995Z" + "iopub.execute_input": "2026-07-28T06:48:56.875690Z", + "iopub.status.busy": "2026-07-28T06:48:56.875581Z", + "iopub.status.idle": "2026-07-28T06:48:57.124716Z", + "shell.execute_reply": "2026-07-28T06:48:57.123792Z" } }, "outputs": [ @@ -505,42 +505,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", @@ -551,7 +551,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", @@ -579,12 +584,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", - "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", - "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", - "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", - " ds = xr.open_dataset(output_path, engine=\"zarr\", group=f\"measurements/{level}\")\n", - "/tmp/ipykernel_3423171/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "/tmp/ipykernel_3687551/3670716255.py:5: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", @@ -629,10 +629,10 @@ "id": "b40965eb", "metadata": { "execution": { - "iopub.execute_input": "2026-07-27T17:51:07.939078Z", - "iopub.status.busy": "2026-07-27T17:51:07.938861Z", - "iopub.status.idle": "2026-07-27T17:51:13.873319Z", - "shell.execute_reply": "2026-07-27T17:51:13.872677Z" + "iopub.execute_input": "2026-07-28T06:48:57.126653Z", + "iopub.status.busy": "2026-07-28T06:48:57.126456Z", + "iopub.status.idle": "2026-07-28T06:49:03.348857Z", + "shell.execute_reply": "2026-07-28T06:49:03.348179Z" } }, "outputs": [