diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0e85e8b..f572876 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,7 +18,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ['3.12', '3.13', '3.14'] + python-version: ['3.11', '3.12', '3.13', '3.14'] steps: - name: Cancel previous runs diff --git a/.gitignore b/.gitignore index 9d47493..e72b25b 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,4 @@ __pycache__ .ipynb_checkpoints /data/* .pytest_cache -.DS_Store \ No newline at end of file +.DS_Store diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..c5152f1 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,114 @@ +# Changelog + +## 0.7.0 — internals refactor (typed engine) + +This release replaces the recursive dict-walking engine with a typed expression +tree (parse → evaluate). The convention/YAML format is **unchanged**; the +in-memory representation, the engine, and the default output variable names are +new. Numerical results are identical to the previous engine — verified by +end-to-end equivalence tests on the example MOM6 grid (108 → 57 variables) and +the ECCOv4r4 LLC90 grid (140 → 75 variables, 0 mismatches). + +### Quick migration + +Add `name_scheme="legacy"` to your `collect_budgets` call to keep the previous +behavior exactly — historical variable names *and* the in-place filling of the +recipe dict that `get_vars`/`aggregate` depend on: + +```python +xbudget.collect_budgets(grid, xbudget_dict, name_scheme="legacy") +``` + +Everything downstream (old variable names, `get_vars`, `aggregate`) then works +unchanged. Adopt the new scheme at your own pace. + +### Breaking changes + +1. **Simplified variable names (default `name_scheme="v1"`).** Derived + variables are now named by their term path with the `sum`/`product`/ + `difference` operator infixes dropped, and the redundant "copy" duplicates + the old engine emitted are gone. One variable is produced per operation. + + | Legacy name | New name | + |---|---| + | `heat_rhs` | `heat_rhs` *(unchanged)* | + | `heat_rhs_sum` | `heat_rhs` *(the copy/sum collapse into one)* | + | `heat_rhs_sum_diffusion` | `heat_rhs_diffusion` | + | `heat_rhs_sum_diffusion_sum_lateral_product` | `heat_rhs_diffusion_lateral` | + | `mass_rhs_sum_advection_sum_lateral_sum_zonal_convergence_product_zonal_divergence_difference` | `mass_rhs_advection_lateral_zonal_convergence_zonal_divergence` | + + On the example MOM6 grid this reduces 108 variables to 57. The canonical + identity of each variable is also stored structurally in its + `xbudget_path` attribute (a list of term names), so you never need to parse + the flat name. + +2. **`collect_budgets` no longer mutates the recipe dict** (in `v1` mode). It + previously filled each node's `var` field in place; it now leaves + `xbudget_dict` untouched and returns the data object. Because the legacy + `get_vars`/`aggregate` helpers read those filled `var` fields, they only work + after a `name_scheme="legacy"` run (which still fills the dict). To query the + `v1` output, use the `records`/`alias_map` returned by `evaluate_budgets` + (below) and the `provenance` / `xbudget_path` attributes on each variable. + +3. **`collect_budgets` signature** gained a `name_scheme` keyword and its first + parameter is named `data` (a grid or dataset), matching its long-standing + behavior of accepting either. + +### New + +- `xbudget.parse_budgets(xbudget_dict)` → typed tree (`xbudget.nodes.Budget`), + the single schema-validating entry point; raises `xbudget.BudgetParseError` + with the offending path on malformed conventions. +- `xbudget.evaluate_budgets(data, budgets)` → pure evaluator; returns + `(alias_map, records)` where `alias_map` maps every legacy name to its new + name and `records` maps each new variable to its `{path, op, ...}` metadata. +- Each derived variable carries `xbudget_path` (structured identity), + `xbudget_op` (operation kind), and `provenance` (immediate inputs) attributes. +- **ECCOv4r4 / LLC90 support in the typed engine.** The `reciprocal` and + `lateral_divergence` operations and a `difference` of a *computed sub-term* + (not just a raw variable) are all handled, so the native-grid ECCO mass/heat/ + salt budgets evaluate under `name_scheme="v1"`. New `ECCOV4r4_native` + convention and example notebooks (`eccov4r4_budget_examples_mass_heat_salt`, + `eccov4r4_heat_budget_decomposition`). +- **`lateral_divergence` now uses native xgcm** (`grid.diff` with + `other_component` + `face_connections`) instead of a hand-rolled LLC90 flux + stitcher; verified bit-for-bit identical on the ECCO grid. The + `xbudget/llc90` module is removed. + +### Fixed + +- **ECCO mass budget: the lateral eddy-bolus transport was silently dropped.** + The `bolus_mass_flux_convergence` term in `ECCOV4r4_native.yaml` was missing + its enclosing `product:` wrapper, so its `sign`/`density`/`volume_flux_divergence` + children sat directly on the term and were ignored — the GM bolus velocity + (`UVELSTAR`/`VVELSTAR`) contributed nothing to the mass budget. The wrapper is + now restored, so the bolus convergence is materialized and included. **This + changes ECCO mass-budget results** (the bolus term is no longer zero). +- The `difference` operation's grid guard was misattached, so a `difference` + on a plain `Dataset` raised an opaque `NameError`, and a `difference` term + evaluated after another operation in the same node raised spuriously even + with a valid grid. It now raises a clear `ValueError` up front when no grid + is supplied. (Also fixes a mutable-default-argument footgun in the internal + search helper.) + +### Deprecated + +- `budget_fill_dict` is retained as the legacy reference engine (still used + internally by `name_scheme="legacy"`) but is superseded by `collect_budgets` + / `evaluate_budgets`. + +### Dependencies + +- The LLC `lateral_divergence` relies on native face-connected differencing in + `xgcm` (`grid.diff` with `other_component`). This is only available in xgcm + **after 0.9.0** (currently from the development `main` branch); the + `requires-python`/`xgcm` pins should be tightened once a release ships it. + +### Parser tolerance + +- The parser **warns and skips** unavailable-diagnostic placeholders (e.g. a + `difference` whose source is `null`) and terms with stray non-operation keys, + mirroring the legacy engine's behavior rather than failing, so real + conventions with such placeholders still load. (This same tolerance is what + let the malformed bolus term above pass silently before it was fixed — the + warning it emitted is what surfaced the bug.) diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..bf31d3f --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,89 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## What this is + +`xbudget` wrangles finite-volume budgets (mass, heat, salt) diagnosed from ocean General Circulation Models — primarily MOM6 — into closed budgets using `xarray` and `xgcm`. The library's job is to take a dataset of raw model diagnostics plus a *convention* describing how those diagnostics combine, and materialize every intermediate and aggregate term as a named variable in the dataset. + +> This branch refactors the engine internals. The convention/YAML format is unchanged, but the in-memory representation is now a typed expression tree and the default output variable names are simplified. See `CHANGELOG.md` for the migration guide. + +## Commands + +Tests use `pytest` (no separate build/lint step). The base conda environment may have a NumPy 1.x/2.x mismatch — run tests in the project env (e.g. `docs_env_xbudget`): + +```bash +pytest # full suite +pytest xbudget/tests/test_parse.py # one file +pytest xbudget/tests/test_utilities.py::TestCollectBudgets::test_collect_budgets_basic # one test +``` + +The end-to-end characterization and engine-equivalence tests need the ~600 MB example MOM6 dataset (gitignored, fetched from Zenodo); they **skip** when it is absent. Regenerate the characterization golden after an intended change with `XBUDGET_REGEN_CHARN=1 pytest xbudget/tests/test_characterization.py -s`. + +Dev environment (conda + editable install): + +```bash +conda env create -f docs/environment.yml # or ci/environment.yml for the minimal test env +conda activate docs_env_xbudget +pip install -e . +``` + +## Core architecture + +The central abstraction is the **`xbudget_dict`** — a nested provenance tree (loaded from a YAML *convention* file) describing how to build each budget term from raw diagnostics. It is the public input format. Internally it is parsed into a typed expression tree and evaluated. + +### The xbudget_dict tree (input format — unchanged) + +Top-level keys are budgets (`mass`, `heat`, `salt`). Each budget has `lhs` and/or `rhs` sub-trees plus metadata keys (`lambda`, `thickness`, `surface_lambda`) that the engine does not interpret. Within a side, terms nest recursively. Every node carries a `var` key (a variable name, or `null` for derived terms) plus optionally one or more **operation** keys: + +- `sum` — add the child terms together +- `product` — multiply child terms (scalar numbers allowed as factors, e.g. `density: 1035.`, `sign: -1.`) +- `difference` — finite-difference across a grid axis (**requires an `xgcm.Grid`**); the operand is a raw variable *or* a computed sub-term +- `reciprocal` — safe `1/x` (zeros → inf) of a variable +- `lateral_divergence` — horizontal flux divergence `div(Fx, Fy)` of two flux sub-terms, via native xgcm (`grid.diff` with `other_component` + `face_connections`); works on face-connected LLC grids + +A node may carry more than one operation (e.g. a bulk `product` and an equivalent finer `sum`). Leaf string values (`"areacello"`, `"umo"`) are raw diagnostic names. Conventions live in `xbudget/conventions/*.yaml` — `MOM6.yaml` (canonical; also `MOM6_3Donly`, `MOM6_drift`, `MOM6_surface`) and `ECCOV4r4_native.yaml` (LLC90 native-grid budgets). + +### The typed engine (parse → evaluate) + +``` +xbudget_dict ──parse_budgets──▶ typed tree (nodes.py) ──evaluate_budgets──▶ derived variables + alias map +``` + +- **`nodes.py`** — immutable dataclasses: `Budget`, `Term`, and the operations `Sum`/`Product`/`Difference`/`Reciprocal`/`LateralDivergence` plus `Constant`/`VarRef`. A `Term` carries its structured `path` (its canonical identity) and may hold multiple operations. The native `lateral_divergence` helper lives in `collect.py` and is shared by both engines. +- **`parse.py`** — `parse_budgets(dict) -> {name: Budget}`. The single source of schema truth; validates and raises `BudgetParseError` naming the offending path on malformed conventions. +- **`evaluate.py`** — `evaluate_budgets(data, budgets)` walks the tree and materializes **one variable per operation**, named by its term path with operator infixes dropped (e.g. `heat_rhs_diffusion_lateral`). It is pure with respect to the recipe (never mutates it); it only writes derived variables into the dataset. Each variable gets `xbudget_path` (structured identity), `xbudget_op` (the operation kind), and `provenance` (immediate inputs) attrs. Returns `(alias_map, records)` — `alias_map` maps every legacy name to its new name; `records` maps each new variable to its metadata. Dispatch is on node type (`Difference` requires an `xgcm.Grid` in its signature, so a grid-less difference fails fast with a clear error). +- **`collect.py`** — the public surface: + - `collect_budgets(data, xbudget_dict, allow_rechunk=True, name_scheme="v1")` → parses then evaluates. **`v1` (default)** uses the simplified names and does **not** mutate the recipe dict. **`legacy`** reuses `budget_fill_dict` to reproduce the historical operator-suffixed names *and* fill the recipe dict in place. + - `budget_fill_dict(...)` → the legacy dict-walking engine, retained as a reference implementation (pinned by the equivalence test) and used by `name_scheme="legacy"`. It mutates both the dataset and the recipe dict. + - `aggregate` / `disaggregate` / `get_vars` → dict-based query helpers. **They read the `var` fields that the legacy engine fills**, so they only work after a `name_scheme="legacy"` run. For `v1`, query via the `records`/`alias_map` from `evaluate_budgets` and the `provenance`/`xbudget_path` attrs. + +### Key behaviors to know + +- **Naming changed (major-version cleanup).** `v1` emits one variable per node/operation with operator infixes dropped; the legacy engine emitted duplicate "copy" variables (108 → 57 on the MOM6 example). Use `name_scheme="legacy"` or the `alias_map` to bridge. `CHANGELOG.md` has the old→new table. +- **Missing diagnostics are skipped with a `UserWarning`, not an error** — a `sum`/`product` containing missing inputs collapses accordingly, so one convention can serve datasets with different available diagnostics. +- **`difference` rechunking:** `allow_rechunk=True` (default) temporarily rechunks the difference dimension into a single chunk (required by `grid.diff`) then restores chunking. +- **Lenient parser.** `parse.py` mirrors the legacy engine: it **warns and skips** unavailable-diagnostic placeholders (e.g. a `null`-source `difference`) and stray non-operation keys instead of failing, so real conventions with such terms still load. (This tolerance previously masked the malformed `bolus_mass_flux_convergence` term in `ECCOV4r4_native.yaml` — missing its `product:` wrapper, so the eddy bolus transport was silently dropped from the mass budget; that has since been fixed in the convention.) +- **xgcm version:** `lateral_divergence` needs native face-connected differencing, available only in xgcm **after 0.9.0** (currently the dev `main`). Run/test in an env with that xgcm. + +### Tests + +- `test_parse.py` — parser units + validation; asserts all shipped conventions parse; covers the tolerated-malformation path. +- `test_evaluate_equivalence.py` — proves the typed engine is numerically identical to the legacy `budget_fill_dict`: a synthetic grid (always), the MOM6 grid, and the **ECCO LLC90 grid** (both gated on their data files; the ECCO case exercises reciprocal, difference-of-sub-term, and native `lateral_divergence`). +- `test_characterization.py` (+ `characterization_MOM6.json`) — golden snapshot of the typed engine's absolute MOM6 output. +- `test_utilities.py` — the legacy engine, `aggregate`/`get_vars`/`disaggregate`, and `collect_budgets` behavior. + +## Data & examples + +- `examples/load_example_model_grid.py` — `load_MOM6_coarsened_diagnostics()` builds a MOM6 `xgcm.Grid` (X/Y center/outer, `areacello` metric). `examples/load_example_ecco_grid.py` — `load_ECCOV4r4_coarsened_diagnostics()` builds the ECCO **LLC90** grid with 13-tile `face_connections`. Both download from Zenodo, cached in `data/` (gitignored; only `data/README.md` tracked). +- Notebooks: `MOM6_budget_examples_mass_heat_salt.ipynb`; `eccov4r4_budget_examples_mass_heat_salt.ipynb` (ECCO closure); `eccov4r4_heat_budget_decomposition.ipynb` (ECCO heat decomposition). The ECCO notebooks and the MOM6 one call `collect_budgets(..., name_scheme="legacy")` because they use `get_vars`/`aggregate`. + +## Pull request workflow + +When you push a new commit to a branch that already has an open pull request, update the PR description (the top comment / body) so it stays consistent with the latest commit — don't leave it describing only the original state: + +- Refresh the summary so it reflects what the branch does now. +- If the description contains a task list / checklist, check off (`- [x]`) the items the new commit completed and add entries for any follow-up work it introduced. +- Reflect scope, naming, or API changes so a reviewer reading only the PR body sees the current truth. + +Update it with the GitHub CLI as part of the same push, e.g. `gh pr edit --body-file ` (or `--body "..."`), so the description never lags behind the commits. diff --git a/ci/environment.yml b/ci/environment.yml index 144c199..4abea13 100644 --- a/ci/environment.yml +++ b/ci/environment.yml @@ -3,7 +3,7 @@ channels: - conda-forge - nodefaults dependencies: - - python>=3.12 + - python>=3.11 - cftime - netcdf4 - pydap diff --git a/conda/meta.yaml b/conda/meta.yaml index 894a5d5..0d077d7 100644 --- a/conda/meta.yaml +++ b/conda/meta.yaml @@ -1,5 +1,5 @@ {% set name = "xbudget" %} -{% set version = "0.6.2" %} +{% set version = "0.7.0" %} {% set python_min = "3.11" %} package: @@ -8,7 +8,8 @@ package: source: url: https://pypi.org/packages/source/x/xbudget/xbudget-{{ version }}.tar.gz - sha256: 0ab9571aae2196523c0dbc394468567446d61e475624921055a3b1e074c05112 + # TODO(release): regenerate against the published 0.7.0 sdist. + sha256: 0000000000000000000000000000000000000000000000000000000000000000 build: noarch: python diff --git a/docs/source/index.rst b/docs/source/index.rst index 48eaf48..2b6d259 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -11,7 +11,7 @@ xbudget expects budgets which have a Left-Hand Side (LHS) equal to a Right-Hand where :math:`\lambda` is the property density (or tracer concentration), :math:`\mathbf{u}` is the flow velocity, and :math:`\mathbf{F}_{\lambda}` is the sum of all non-advective fluxes of :math:`\lambda`. -xbudget ingests an `xgcm.Grid` object containing the budget diagnostics and uses structured metadata, in the form of a nested dictionary (or `.yaml` file), to close such budgets. While this may seem trivial for use cases in which there is a single flux to keep track of, total non-advective fluxes in general circulation models can be composed of dozens of contributing processes. Since budget diagnostics are often not output as volume-integrated tendencies, xbudget allows for terms to be derived as sums, products, or differences (or some combination of these). For example, ocean heat tendency due to air-sea heat fluxes might be derived from the difference between vertical heat fluxes across depth interfaces, summed over longwave, shortwave, sensible, and latent components of the flux, and multiplied by the ocean cell area. +xbudget ingests an `xgcm.Grid` object containing the budget diagnostics and uses structured metadata, in the form of a nested dictionary (or `.yaml` file), to close such budgets. While this may seem trivial for use cases in which there is a single flux to keep track of, total non-advective fluxes in general circulation models can be composed of dozens of contributing processes. Since budget diagnostics are often not output as volume-integrated tendencies, xbudget allows for terms to be derived as sums, products, differences, reciprocals, or lateral flux divergences (or some combination of these), including on face-connected grids such as the ECCO LLC90 tiles. For example, ocean heat tendency due to air-sea heat fluxes might be derived from the difference between vertical heat fluxes across depth interfaces, summed over longwave, shortwave, sensible, and latent components of the flux, and multiplied by the ocean cell area. While drafting a `.yaml` file from scratch for a new model can be daunting, it only needs to be done once -- then closing budgets is a breeze! @@ -22,3 +22,4 @@ While drafting a `.yaml` file from scratch for a new model can be daunting, it o installation examples/MOM6_budget_examples_mass_heat_salt examples/eccov4r4_budget_examples_mass_heat_salt + examples/eccov4r4_heat_budget_decomposition diff --git a/examples/MOM6_budget_examples_mass_heat_salt.ipynb b/examples/MOM6_budget_examples_mass_heat_salt.ipynb index f1d40b9..6ab88c1 100644 --- a/examples/MOM6_budget_examples_mass_heat_salt.ipynb +++ b/examples/MOM6_budget_examples_mass_heat_salt.ipynb @@ -286,13 +286,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "527f1b10", "metadata": {}, "outputs": [], - "source": [ - "xbudget.collect_budgets(grid, xbudget_dict)" - ] + "source": "# name_scheme=\"legacy\" reproduces the historical variable names (e.g.\n# \"heat_rhs_sum_diffusion_sum_lateral\") and fills the recipe dict in place,\n# which the get_vars/aggregate helpers used below rely on. The default\n# name_scheme=\"v1\" instead uses simplified names (e.g. \"heat_rhs_diffusion_lateral\")\n# and leaves the recipe dict untouched; see the migration notes in CHANGELOG.md.\nxbudget.collect_budgets(grid, xbudget_dict, name_scheme=\"legacy\")" }, { "cell_type": "markdown", @@ -2086,4 +2084,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/eccov4r4_budget_examples_mass_heat_salt.ipynb b/examples/eccov4r4_budget_examples_mass_heat_salt.ipynb index e6105b5..093e3ae 100755 --- a/examples/eccov4r4_budget_examples_mass_heat_salt.ipynb +++ b/examples/eccov4r4_budget_examples_mass_heat_salt.ipynb @@ -13,33 +13,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "a5f0eef4-7368-4f12-bc35-e09387046539", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xarray: 2026.2.0\n", - "xgcm: 0.9.0\n" - ] - } - ], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "from scipy.interpolate import griddata\n", - "import xgcm\n", - "import matplotlib.pyplot as plt\n", - "import xbudget\n", - "\n", - "from load_example_ecco_grid import * \n", - "from eccov4r4_budget_diagnostics import * \n", - "from xbudget.llc90 import * \n", - "print(\"xarray:\", xr.__version__)\n", - "print(\"xgcm:\", xgcm.__version__)" - ] + "outputs": [], + "source": "import xarray as xr\nimport numpy as np\nfrom scipy.interpolate import griddata\nimport xgcm\nimport matplotlib.pyplot as plt\nimport xbudget\n\nfrom load_example_ecco_grid import * \nfrom eccov4r4_budget_diagnostics import * \nprint(\"xarray:\", xr.__version__)\nprint(\"xgcm:\", xgcm.__version__)" }, { "cell_type": "markdown", @@ -140,44 +118,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "de0673e9", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'mass': {'lambda': 'density',\n", - " 'thickness': 'thkcello',\n", - " 'lhs': {'Eulerian_tendency': 'mass_lhs_sum_Eulerian_tendency'},\n", - " 'rhs': {'advection': 'mass_rhs_sum_advection',\n", - " 'surface_exchange_flux': 'mass_rhs_sum_surface_exchange_flux'}},\n", - " 'heat': {'lambda': 'THETA',\n", - " 'lhs': {'Eulerian_tendency': 'heat_lhs_sum_Eulerian_tendency'},\n", - " 'rhs': {'advection': 'heat_rhs_sum_advection',\n", - " 'diffusion': 'heat_rhs_sum_diffusion',\n", - " 'surface_exchange_flux': 'heat_rhs_sum_surface_exchange_flux',\n", - " 'bottom_flux': 'heat_rhs_sum_bottom_flux'}},\n", - " 'salt': {'lambda': 'SALT',\n", - " 'lhs': {'Eulerian_tendency': 'salt_lhs_sum_Eulerian_tendency'},\n", - " 'rhs': {'advection': 'salt_rhs_sum_advection',\n", - " 'diffusion': 'salt_rhs_sum_diffusion',\n", - " 'surface_exchange_flux': 'salt_rhs_sum_surface_exchange_flux'}}}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Load the preset metadata dictionary and let xbudget attach the derived budget terms.\n", - "xbudget_dict = xbudget.load_preset_budget(model=\"ECCOV4r4_native\").copy()\n", - "xbudget.collect_budgets(grid, xbudget_dict,allow_rechunk= True)\n", - "# Aggregate the full metadata tree into a simpler budget summary for inspection.\n", - "simple_budgets = xbudget.aggregate(xbudget_dict)\n", - "simple_budgets" - ] + "outputs": [], + "source": "# Load the preset metadata dictionary and let xbudget attach the derived budget terms.\n# name_scheme=\"legacy\" reproduces the historical variable names and fills the\n# recipe dict in place, which aggregate()/get_vars() below rely on.\nxbudget_dict = xbudget.load_preset_budget(model=\"ECCOV4r4_native\").copy()\nxbudget.collect_budgets(grid, xbudget_dict, allow_rechunk=True, name_scheme=\"legacy\")\n# Aggregate the full metadata tree into a simpler budget summary for inspection.\nsimple_budgets = xbudget.aggregate(xbudget_dict)\nsimple_budgets" }, { "cell_type": "markdown", @@ -456,4 +401,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/eccov4r4_heat_budget_decomposition.ipynb b/examples/eccov4r4_heat_budget_decomposition.ipynb new file mode 100644 index 0000000..9a71e17 --- /dev/null +++ b/examples/eccov4r4_heat_budget_decomposition.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "db585993", + "metadata": {}, + "source": [ + "# Tutorial: decomposing the ECCO V4r4 heat budget\n", + "\n", + "This companion to `eccov4r4_budget_examples_mass_heat_salt.ipynb` shows how to **decompose** the native-grid (LLC90) ECCO heat budget into its physical contributions (advection, diffusion, surface forcing, …) with `xbudget`, mirroring the decomposition workflow in `MOM6_budget_examples_mass_heat_salt.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "15a60801", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:44:32.671751Z", + "iopub.status.busy": "2026-06-30T18:44:32.671523Z", + "iopub.status.idle": "2026-06-30T18:44:34.120028Z", + "shell.execute_reply": "2026-06-30T18:44:34.119761Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xarray: 2026.1.0\n", + "xgcm: 0.9.1.dev35+g41f1a575b\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "import numpy as np\n", + "from scipy.interpolate import griddata\n", + "import xgcm\n", + "import matplotlib.pyplot as plt\n", + "import xbudget\n", + "\n", + "from load_example_ecco_grid import * \n", + "from eccov4r4_budget_diagnostics import * \n", + "print(\"xarray:\", xr.__version__)\n", + "print(\"xgcm:\", xgcm.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "3dd29d64", + "metadata": {}, + "source": [ + "### Load the example ECCO V4r4 grid" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f6135116", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:44:34.121600Z", + "iopub.status.busy": "2026-06-30T18:44:34.121389Z", + "iopub.status.idle": "2026-06-30T18:44:59.292993Z", + "shell.execute_reply": "2026-06-30T18:44:59.292446Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File 'ECCO_budget_terms.nc' already exists at ../data/ECCO_budget_terms.nc. Skipping download.\n" + ] + } + ], + "source": [ + "grid = load_ECCOV4r4_coarsened_diagnostics() # this takes about 7 minutes\n", + "\n", + "# Build a time-step coordinate and a cell-volume metric used repeatedly below.\n", + "dt = grid._ds[\"time_bounds\"].diff(\"time_bounds\").rename({\"time_bounds\":\"time\"})\n", + "\n", + "grid._ds = grid._ds.assign_coords(\n", + " {\"dt\":(\"time\", dt.dt.total_seconds().values), \n", + " \"volcello\": (grid._ds[\"drF\"] * grid._ds[\"hFacC\"]) * grid._ds[\"rA\"]\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "02dc29f5", + "metadata": {}, + "source": [ + "### Preprocess the ECCO diagnostics into xbudget's budget components" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "62ed2b7e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:44:59.296025Z", + "iopub.status.busy": "2026-06-30T18:44:59.295886Z", + "iopub.status.idle": "2026-06-30T18:45:05.266349Z", + "shell.execute_reply": "2026-06-30T18:45:05.265765Z" + } + }, + "outputs": [], + "source": [ + "def zero_top_layer(ds, varname = \"\", zdim = \"k_l\"):\n", + " # Remove the surface layer contribution when a diagnostic should only represent interior transport.\n", + " return xr.where(ds[f\"{zdim}\"] != ds[f\"{zdim}\"].isel({f\"{zdim}\":0}),ds[varname].copy(),0.0,)\n", + "def make_flux_3d(ds, varname = \"\", zdim = \"k\"):\n", + " # Broadcast a surface flux into a 3D array that only occupies the top model layer.\n", + " k = ds[f\"{zdim}\"]\n", + " return xr.where(k == k.isel({f\"{zdim}\":0}), ds[varname].copy().expand_dims({f\"{zdim}\":k}),0.0,)\n", + "\n", + "# Assemble ECCO heat-flux terms into the budget components expected by xbudget.\n", + "grid._ds[\"geothermal_heat_flux_convergence\"] = eccov4r4_geothermal_heat_flux_tendency(grid._ds) \n", + "grid._ds[\"pen_boundary_forcing_heat_tendency\"] = eccov4r4_penetrative_heat_flux_tendency(grid._ds)\n", + "grid._ds[\"nonpen_boundary_forcing_heat_tendency\"] = eccov4r4_nonpenetrative_heat_flux_tendency(grid._ds)\n", + "grid._ds[\"boundary_forcing_heat_tendency\"] = grid._ds[\"pen_boundary_forcing_heat_tendency\"] + grid._ds[\"nonpen_boundary_forcing_heat_tendency\"]\n", + "\n", + "# Put the sea-ice salt exchange and salt-plume tendency onto the same vertical grid.\n", + "SFLUX = grid._ds[\"SFLUX\"].assign_coords(k=0).expand_dims(dim='k',axis=1) # sea-ice salt exchange\n", + "grid._ds[\"boundary_forcing_salt_tendency\"] = xr.concat([SFLUX+grid._ds[\"oceSPtnd\"],grid._ds[\"oceSPtnd\"].isel(k=slice(1,None))], dim='k') # combine surface salt flux and plume tendency\n", + "\n", + "# Separate interior vertical transport from the freshwater boundary forcing term.\n", + "grid._ds[\"WVELMASS_interior\"] = zero_top_layer(grid._ds, varname = \"WVELMASS\", zdim = \"k_l\") #\n", + "grid._ds[\"boundary_forcing_volume_tendency\"] = make_flux_3d(grid._ds, varname = \"oceFWflx\", zdim = \"k\")\n", + "\n", + "# Rechunk once before calling xbudget so later difference and convergence steps stay tractable.\n", + "grid._ds = grid._ds.chunk({\"tile\":2, \"i\":50, \"j\":50, \"i_g\":50, \"j_g\":50, \"k\": 10}).fillna(0.0)\n", + "# to-do: add comparable chunking inside the difference and convergence routines " + ] + }, + { + "cell_type": "markdown", + "id": "8537372d", + "metadata": {}, + "source": [ + "### Collect the budget terms\n", + "\n", + "We use `name_scheme=\"legacy\"` so the historical variable names are produced and the recipe dict is filled in place, which `aggregate`/`get_vars` rely on." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2c5a3ee9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:45:05.269739Z", + "iopub.status.busy": "2026-06-30T18:45:05.269620Z", + "iopub.status.idle": "2026-06-30T18:45:13.945620Z", + "shell.execute_reply": "2026-06-30T18:45:13.945305Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hfdrake/code/xbudget/xbudget/collect.py:437: UserWarning: Dataset chunks are inconsistent; using unify_chunks()\n", + " warnings.warn(\"Dataset chunks are inconsistent; using unify_chunks()\", UserWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "\n", + "X Axis (not periodic, boundary='fill'):\n", + " * center i --> left\n", + " * left i_g --> center\n", + "Y Axis (not periodic, boundary='fill'):\n", + " * center j --> left\n", + " * left j_g --> center\n", + "T Axis (not periodic, boundary='fill'):\n", + " * center time --> outer\n", + " * outer time_bounds --> center\n", + "Z Axis (not periodic, boundary='fill'):\n", + " * center k --> left\n", + " * left k_l --> center" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xbudget_dict = xbudget.load_preset_budget(model=\"ECCOV4r4_native\").copy()\n", + "xbudget.collect_budgets(grid, xbudget_dict, allow_rechunk=True, name_scheme=\"legacy\")" + ] + }, + { + "cell_type": "markdown", + "id": "e304c401", + "metadata": {}, + "source": [ + "### Decompose the heat budget\n", + "\n", + "`aggregate` collapses the full provenance tree into a flat mapping of high-level terms to variable names. Passing `decompose=[...]` breaks the named terms into their constituent parts — here we split the right-hand-side heat sources/sinks into advection, diffusion, and surface-exchange-flux components." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e0fa039e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:45:13.947046Z", + "iopub.status.busy": "2026-06-30T18:45:13.946944Z", + "iopub.status.idle": "2026-06-30T18:45:13.949675Z", + "shell.execute_reply": "2026-06-30T18:45:13.949411Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'advection_lateral': 'heat_rhs_sum_advection_sum_lateral',\n", + " 'advection_interfacial': 'heat_rhs_sum_advection_sum_interfacial',\n", + " 'diffusion_lateral': 'heat_rhs_sum_diffusion_sum_lateral',\n", + " 'diffusion_explicit_vertical_diffusion': 'heat_rhs_sum_diffusion_sum_explicit_vertical_diffusion',\n", + " 'diffusion_implicit_vertical_diffusion': 'heat_rhs_sum_diffusion_sum_implicit_vertical_diffusion',\n", + " 'surface_exchange_flux': 'heat_rhs_sum_surface_exchange_flux',\n", + " 'bottom_flux': 'heat_rhs_sum_bottom_flux'}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decomposed = xbudget.aggregate(\n", + " xbudget_dict, decompose=[\"advection\", \"diffusion\", \"surface_exchange_flux\"]\n", + ")\n", + "heat_rhs_terms = decomposed[\"heat\"][\"rhs\"]\n", + "heat_rhs_terms" + ] + }, + { + "cell_type": "markdown", + "id": "6924d7a0", + "metadata": {}, + "source": [ + "### Plot the decomposed heat-budget terms\n", + "\n", + "Each term is a native volume-integrated heat tendency (J/s); we convert to a column tendency per unit area (W/m²) and remap the LLC tiles to lat-lon for visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "997ec4fe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:45:13.950846Z", + "iopub.status.busy": "2026-06-30T18:45:13.950757Z", + "iopub.status.idle": "2026-06-30T18:45:13.953223Z", + "shell.execute_reply": "2026-06-30T18:45:13.952969Z" + } + }, + "outputs": [], + "source": [ + "def plot_interpolated_ecco(fig, ax, ds, vmin=0, vmax=30, cmap=\"coolwarm\"):\n", + " # Build a simple regular lat-lon target grid for quick visual comparison.\n", + " target_lon = np.arange(-180, 180, 1)\n", + " target_lat = np.arange(-90, 90, 1)\n", + " lon_grid, lat_grid = np.meshgrid(target_lon, target_lat)\n", + " \n", + " # Flatten the LLC field into point/value pairs for interpolation.\n", + " points = np.column_stack((ds.XC.values.ravel(), ds.YC.values.ravel()))\n", + " values = ds.values.ravel()\n", + " \n", + " # Use nearest-neighbor remapping to preserve the native diagnostic values.\n", + " interpolated_data = griddata(points, values, (lon_grid, lat_grid), method='nearest')\n", + " \n", + " # Plot the remapped field.\n", + " cb = ax.pcolormesh(lon_grid, lat_grid, interpolated_data, \n", + " vmin=vmin, vmax=vmax, cmap=cmap)\n", + " \n", + " return cb" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e1ed9bcd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:45:13.954364Z", + "iopub.status.busy": "2026-06-30T18:45:13.954276Z", + "iopub.status.idle": "2026-06-30T18:45:20.234754Z", + "shell.execute_reply": "2026-06-30T18:45:20.234463Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'ECCO heat budget RHS, decomposed (column tendency)')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIgAAAQ/CAYAAAB/49cOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXec3MT5/z8jadvdXnU/1yu2MbaxaaHb9ACmhQQcqglf+FG/QEIgQGhOAFMCXwiQQAotYFoSegkkEEIxhGJjwGD79s4dd1/fJml+f2hHN9JKe3vnO5fb5/167Wt3pdFoNBqNZp55CuOccxAEQRAEQRAEQRAEQRAFi7K9C0AQBEEQBEEQBEEQBEFsX0hARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAE0U959NFHwRjz/fz73/92pE8mk7j//vtx4IEHoqKiAsFgEMOHD8cpp5yCd999Nyv/hoYGXHLJJRg3bhwikQiKioowceJEXHfddVi9erUjLeccc+fOxaGHHoqKigqEQiHU1NTg4osvxsqVK/O6nptuugmMMWzcuLHHddJTPvzwQ9x0001oamrKK/3ZZ5+NaDTat4XKIOqlL1mzZg1uuukmLFiwIK/0//73vx1tTVVVDBo0CMcddxw+/fTTrPRd1Vc0GsXZZ5/t2LZy5UpcdNFFdvurrKzE5MmTcd555+XdpvKFMYabbrqpV/Mk8qc79f/ee+8hFAph+fLlfVKWbfG89RWLFi3CTTfdhGXLlm3Xcuxsz9OZZ56JE088cXsXgyAIYpugbe8CEARBEH3LI488gl122SVr+6677mr/3rhxI4466igsXLgQ55xzDq688kpUVlZi9erVePHFF3HYYYfhs88+w5QpUwAAr7zyCn784x9j4MCBuOSSS7D77ruDMYYvv/wSDz/8MF599VXMnz8fAGCaJk477TQ888wzOPXUU/Hoo4+irKwMCxcuxJ133om5c+filVdewQEHHLBtKqQHfPjhh5g9ezbOPvtslJeXb+/ibHPWrFmD2bNnY8yYMZg6dWrex91666045JBDkE6nMX/+fMyePRvTp0/HggULMHbs2B6XZ9WqVdhjjz1QXl6OK664AuPHj0dzczMWLVqEZ599Fg0NDRg5cmSP8yd2TjjnuPzyy3Heeedh9OjR27s4OxyLFi3C7NmzcfDBB2PMmDHbuzg7DTfddBN22WUXvP322zj00EO3d3EIgiD6FBIQEQRB9HMmTZqEvfbaK2eas846C1988QX+8Y9/ZA2Af/zjH+NnP/sZKioqAACNjY348Y9/jHHjxuGdd95BWVmZnfbQQw/FpZdeiueff97edvvtt+OZZ57Bbbfdhl/84hf29oMPPhgzZ87EPvvsgx/+8If49ttvC1L40p8ZO3Ys9t13XwDAQQcdhPLycsyaNQtPPPEEZs+e3eN8//jHP2Ljxo3473//i+rqanv7iSeeiGuvvRamaW512YmdjzfeeAOff/455s6du72LQvQjamtrcdRRR+G2224jARFBEP0eMjEjCIIocD777DO8/vrr+J//+R/fwe/ee++NUaNGAQDuvvtutLe343e/+51DOCRgjOGkk04CAKRSKdx5552YMGECrrrqqqy0Q4YMwZw5c7Bu3Tr8+c9/zqu869atw6mnnoqysjIMGTIE55xzDpqbmx1pOOf43e9+h6lTpyISiaCiogI/+tGP0NDQ4Ej31ltv4YQTTsCIESMQDodRV1eH888/32HGdtNNN+HKK68EAFRXV/ua6Hnx9ddf47DDDkNxcTEGDRqESy65BB0dHfb+ZcuWgTGGRx99NOtYLzOMV199FVOnTkUoFEJ1dTV+85vfeJ63qakJ//M//4PKykpEo1HMmDEDDQ0NnnkuXboUp512GgYPHoxQKIQJEybggQcesPf/+9//xt577w0A+MlPfmJff09MRISgct26dd0+VmbTpk1QFAWDBw/23K8oPRvetLS04LzzzsOAAQMQjUZx1FFHYcmSJZ5pu6o3QVNTE6644grU1NQgFAph8ODBOOaYY/Dtt9/aaTZv3oyLLroIw4cPRzAYRE1NDX75y18imUw68mKM4ZJLLsEjjzyC8ePHIxKJYK+99sJHH30EzjnuvPNOVFdXIxqN4tBDD0V9fb3j+IMPPhiTJk3Ce++9h3333ReRSATDhw/H9ddfD8MwHGnzLdNzzz2HffbZB2VlZSgqKkJNTQ3OOeecrHr9+c9/jurqatt09fLLL0d7e3uP69+L3//+99h7770xfvz4rH1z587Ffvvth2g0img0iqlTp2b1OQ8//DCmTJmCcDiMyspK/OAHP8A333zT5Xn9nocxY8Y4TCOF2e/bb79tX2dpaSnOOusstLe3Y+3atTjllFNQXl6OYcOG4ec//znS6bR9vOgvfvOb3+Duu++27/V+++2Hjz76KGcZH330UZx88skAgEMOOcR+juW+55///CcOO+wwlJaWoqioCAcccAD+9a9/OfIRJnZff/11l/1wbz9PwnT1qaeewi9/+UtUVVWhtLQUhx9+OBYvXpyV5xtvvIHDDjvMbpsTJkzAnDlzAAB/+ctfwBjDvHnzso771a9+hUAggDVr1tjbzjzzTPzzn/9ELBbLUcsEQRA7PyQgIgiC6OcYhgFd1x0feTL45ptvAkDePhbefPNNDBkyxNYMycVnn32GLVu24Pjjj/f123HcccdBURS89dZbeZ3/hz/8IcaNG4e//e1vuPrqqzF37lz89Kc/daQ5//zzcfnll+Pwww/HCy+8gN/97nf4+uuvsf/++zuEE7FYDPvttx9+//vf480338QNN9yAjz/+GAceeKA9MTv33HPxv//7vwCAv//975g3bx7mzZuHPfbYI2c50+k0jjnmGBx22GF44YUXcMkll+Chhx7CzJkz87pON//6179wwgknoKSkBE8//TTuvPNOPPvss3jkkUcc6UzTxHHHHYe5c+fiF7/4BZ5//nnss88+OOqoo7LyXLRoEfbee2989dVXuOuuu/DKK69gxowZuPTSS20Nnz322MM+x3XXXWdf/7nnntvta2hsbAQAjBs3znO/u52Kj5v99tsPpmnipJNOwj/+8Q+0tLR0uyxuOOc48cQT8Ze//AVXXHEFnn/+eey77744+uijs9LmU28A0NraigMPPBAPPfQQfvKTn+Dll1/Ggw8+iHHjxuG7774DACQSCRxyyCF4/PHH8bOf/QyvvvoqzjjjDNxxxx22oFXmlVdewZ/+9CfcdttteOqpp9Da2ooZM2bgiiuuwAcffID7778ff/jDH7Bo0SL88Ic/BOfccfzatWvx4x//GKeffjpefPFF/OhHP8LNN9+Myy67zE6Tb5nmzZuHmTNnoqamBk8//TReffVV3HDDDY571tHRgenTp+Oxxx7DpZdeitdffx2/+MUv8Oijj+L444+3y9ed+vcilUrhn//8Jw455JCsfTfccANOP/10VFVV4dFHH8Xzzz+PWbNmOfwUzZkzB//zP/+DiRMn4u9//zvuvfdeLFy4EPvttx+WLl2aVxny5dxzz0VZWRmefvppXHfddZg7dy7OO+88zJgxA1OmTMFf//pXzJo1C3fddRfuu+++rOMfeOABvPXWW7jnnnvw5JNPor29Hcccc0yWgEZmxowZuPXWW+3jxXM8Y8YMAMATTzyBI488EqWlpXjsscfw7LPPorKyEt///vezhERA1/1wXzxPgmuvvRbLly/Hn/70J/zhD3/A0qVLcdxxxznea3/+859xzDHHwDRNPPjgg3j55Zdx6aWXYtWqVQCAmTNnYujQoVlCKF3X8dBDD+EHP/gBqqqq7O0HH3wwOOd47bXXfOuYIAiiX8AJgiCIfskjjzzCAXh+VFW1011wwQUcAP/222/zyjccDvN99903r7RPP/00B8AffPDBnOmGDBnCJ0yYkDPNjTfeyAHwO+64w7H9oosu4uFwmJumyTnnfN68eRwAv+uuuxzpVq5cySORCL/qqqs88zdNk6fTab58+XIOgL/44ov2vjvvvJMD4I2NjTnLKJg1axYHwO+9917H9ltuuYUD4O+//z7nnPPGxkYOgD/yyCNZeQDgN954o/1/n3324VVVVTwej9vbWlpaeGVlJZdf56+++ioHwH//+9878pszZ05Wnt///vf5iBEjeHNzsyPtJZdcwsPhMN+8eTPnnPNPPvnEt5xevPPOOxwAf+aZZ3g6neYdHR38gw8+4OPHj+e77ror37JliyO9qK9cn1mzZtnpTdPk559/PlcUhQPgjDE+YcIE/tOf/jTve+Tm9ddfz3nPelJvv/rVrzgA/tZbb/me98EHH+QA+LPPPuvYfvvtt3MA/M0337S3AeBDhw7lbW1t9rYXXniBA+BTp061nwHOOb/nnns4AL5w4UJ72/Tp07PaNuecn3feeVxRFL58+fJulek3v/kNB8Cbmpp8r2/OnDlcURT+ySefOLb/9a9/5QD4a6+9xjnvXv178fHHH3MA/Omnn3Zsb2ho4Kqq8tNPP9332C1btvBIJMKPOeYYx/YVK1bwUCjETzvtNHub6Idk/Mo3evRoR7sVffL//u//OtKdeOKJHAC/++67HdunTp3K99hjD/u/6C8mT57MdV23t//3v//lAPhTTz3le42cc/7cc89xAPydd95xbG9vb+eVlZX8uOOOc2w3DINPmTKFf+9738u6/q764b54nkS/4r5Pzz77LAfA582bxznnvLW1lZeWlvIDDzzQ8Uy4ufHGG3kwGOTr1q2ztz3zzDMcAH/33Xez0g8fPpzPnDnTNz+CIIj+AGkQEQRB9HMef/xxfPLJJ47Pxx9/vL2L5YBznndkoOOPP97xf7fddkMikcD69esBWBoWjDGcccYZDi2UoUOHYsqUKQ7TsPXr1+OCCy7AyJEjoWkaAoGA7dw2H9OSrjj99NMd/0877TQAwDvvvNOtfNrb2/HJJ5/gpJNOQjgctreXlJTguOOOc6QVEedOOeUUx/ZTTz3V8T+RSOBf//oXfvCDH6CoqMhRV8cccwwSiUSXZitdMXPmTAQCAdtcpaWlBa+++qqnr6lIJJLVTsUnEok40jLG8OCDD6KhoQG/+93v8JOf/ATpdBr/93//h4kTJ3pG3esKcU/87pmgO/X2+uuvY9y4cTj88MN9z/v222+juLgYP/rRjxzbhWmSW3vjkEMOQXFxsf1/woQJAICjjz7a8QyJ7e5oXiUlJVnP0GmnnQbTNPGf//ynW2USpoennHIKnn322azohYD1PE6aNAlTp0511NX3v/99h6lmvvXvhzAHcpsdvvXWWzAMAxdffLHvsfPmzUM8Hs+KlDdy5Egceuihnho0W8Oxxx7r+C/uldDmkbd7RWObMWMGVFW1/++2224Asu91vnz44YfYvHkzZs2a5bhHpmniqKOOwieffJJlDthVP9wXz1Ouc8vX/+GHH6KlpQUXXXRRzvfKhRdeCMDyaSa4//77MXnyZEybNi0r/eDBgz3bOEEQRH+CnFQTBEH0cyZMmJDTSbXwLdTY2Ojpu8MrvTAVyietyNuP9vZ2bNy4EbvvvnteeQ4YMMDxPxQKAQDi8TgAy78N5xxDhgzxPL6mpgaAZYp15JFHYs2aNbj++usxefJkFBcXwzRN7LvvvnZ+PUXTtKyyDh06FIDlQ6c7bNmyBaZp2sd75SnYtGkTNE1DZWWlY7u7PjZt2gRd13Hfffd5mrEAcPhi6gm33347Dj30UHR0dODNN9/EnDlzcOKJJ+Ljjz+275tAURTfdurnU2j06NH2JA8Ann32WZx66qm48sor8d///rdbZRX15nfP5HT51tuGDRvsZyDXeYcOHZo1kR08eDA0TctqK+77GgwGc25PJBKO7V7Phbtd5lumadOm4YUXXsBvf/tbnHXWWUgmk5g4cSJ++ctf2gLJdevWob6+HoFAwPP6RV3lW/9+iOdVFqAC1j0AgBEjRvgeK65n2LBhWfuqqqryNn/Nl+7cQ/f9A7ruA7uLMLt1CwRlNm/e7BBMdlWGvnie8j13PvccsJ6FmTNn4qGHHsLVV1+Nr7/+Gu+99x4eeughz/ThcHir3wsEQRA7OiQgIgiCKHC+//3v49prr8ULL7zg6afGK/19992Hjz76qEs/RHvuuScqKirw0ksvYc6cOZ6ruS+99BJM08QRRxzR42uQGThwIBhjeO+997KEEEDnZOKrr77CF198gUcffRSzZs2y97sd+/YUXdexadMmx2Rm7dq1ADonOGIy63b86xYKVFRUgDFmHy/j3jZgwADouo7Nmzc7JpzudBUVFVBVFWeeeaavdoUcIawn1NTU2EKfadOmIRKJ4LrrrsN9992Hn//851uVtxennHIK5syZg6+++qrbx4p687tngu7U26BBg2yfJ7nO+/HHH2dp0a1fvx66rmPgwIHdvpZceDkId7fL7pTphBNOwAknnIBkMomPPvoIc+bMwWmnnYYxY8Zgv/32w8CBAxGJRPDwww97lkfklW/9+yHy2bx5s2P7oEGDAACrVq3CyJEjPY8V5xN+oWTWrFnT5T0IhUJZzzDQfUHw9kJc33333efbp/sJ3P3oi+cpX+R73hWXXXYZ/vKXv+DFF1/EG2+8gfLy8iytJ8HmzZsxZsyYbpWFIAhiZ4NMzAiCIAqcPfbYA0cffTT+/Oc/4+233/ZM8+mnn2LFihUAgJ/+9KcoLi7GRRdd5OkUlXNuh7kPBoO48sor8c033+DOO+/MSrt+/Xpcc801GDJkSI+cHntx7LHHgnOO1atXY6+99sr6TJ48GQDsia9biOS1etzTFfonn3zS8V+E3z744IMBWJOucDiMhQsXOtK9+OKLjv/FxcX43ve+h7///e8OjYLW1la8/PLLjrTTp08HADzzzDOO7U8//bTjf1FREQ455BDMnz8fu+22m2ddiYnd1mooCK666irU1dXhtttuQ2tra4/z8ZrIA0BbWxtWrlzpcC6bL8K5sd89E3Sn3o4++mgsWbLE97kCgMMOOwxtbW144YUXHNsff/xxe39v0traipdeesmxbe7cuVAUxTar6UmZQqEQpk+fjttvvx0AMH/+fADW8xiLxTBgwADPuhIT7nzr3w9hpuWOMnXkkUdCVVX8/ve/9z12v/32QyQSwRNPPOHYvmrVKrz99ttd3oMxY8ZkPcNvv/022tra8ir7tsLvOT7ggANQXl6ORYsWed6jvfbay9Zyype+eJ7yZf/990dZWRkefPDBLCftbvbcc0/sv//+uP322/Hkk0/i7LPPdmhKCXRdx8qVK7Hrrrt2qywEQRA7G6RBRBAE0c/56quvPCNB1dbW2iutjz/+OI466igcffTROOecc3D00UejoqIC3333HV5++WU89dRT+OyzzzBq1ChUV1fj6aefxsyZMzF16lRccskltnnYokWL8PDDD4Nzjh/84AcAgF/84hf44osv7O+ZM2eirKwMCxcuxJ133onW1la88sorKCsr65XrPeCAA/D//t//w09+8hN8+umnmDZtGoqLi/Hdd9/h/fffx+TJk3HhhRdil112QW1tLa6++mpwzlFZWYmXX37Z05xECJXuvfdezJo1C4FAAOPHj0dJSYlvOYLBIO666y60tbVh7733xocffoibb74ZRx99NA488EAAsH0lPfzww6itrcWUKVPw3//+13NS/Otf/xpHHXUUjjjiCFxxxRUwDAO33347iouLHVoTRx11FA444ABcccUVaGlpwZ577ol58+bZk3vZXOvee+/FgQceiIMOOggXXnghxowZg9bWVtTX1+Pll1+2BRu1tbWIRCJ48sknMWHCBESjUVRVVXVbEBMIBHDrrbfilFNOwb333ovrrruuW8cLbrnlFnzwwQd2G4xEImhsbMT999+PTZs2OYSRy5YtQ3V1NWbNmuUI6e3myCOPxLRp03DVVVehvb0de+21Fz744AP85S9/yUqbb71dfvnleOaZZ3DCCSfg6quvxve+9z3E43G8++67OPbYY3HIIYfgrLPOwgMPPIBZs2Zh2bJlmDx5Mt5//33ceuutOOaYY3L6L+oJAwYMwIUXXogVK1Zg3LhxeO211/DHP/4RF154oW0Ol2+ZbrjhBqxatQqHHXYYRowYgaamJtx7770IBAK2oPLyyy/H3/72N0ybNg0//elPsdtuu8E0TaxYsQJvvvkmrrjiCuyzzz7dqn8vRowYgZqaGnz00Ue49NJL7e1jxozBtddei1//+teIx+N2aPZFixZh48aNmD17NsrLy3H99dfj2muvxVlnnYVTTz0VmzZtwuzZsxEOh3HjjTfmPPeZZ56J66+/HjfccAOmT5+ORYsW4f777++1Pq23mDRpEgDgD3/4A0pKShAOh1FdXY0BAwbgvvvuw6xZs7B582b86Ec/wuDBg7FhwwZ88cUX2LBhQ04Bmxd98TzlSzQaxV133YVzzz0Xhx9+OM477zwMGTIE9fX1+OKLL3D//fc70l922WWYOXMmGGO46KKLPPNcuHAhOjo6PKPkEQRB9Cu2m3tsgiAIok/JFcUMAP/jH//oSB+Px/lvf/tbvt9++/HS0lKuaRqvqqriJ510En/11Vez8o/FYvyiiy7idXV1PBQK8UgkwnfddVf+s5/9LCuSlGma/Mknn+QHH3wwLy8v58FgkFdXV/MLL7zQjpzUFSJ6zoYNGzyv033Ohx9+mO+zzz68uLiYRyIRXltby8866yz+6aef2mkWLVrEjzjiCF5SUsIrKir4ySefzFesWOEZleiaa67hVVVVduQsdyQgmVmzZvHi4mK+cOFCfvDBB/NIJMIrKyv5hRde6IhAxTnnzc3N/Nxzz+VDhgzhxcXF/LjjjuPLli3zLMNLL73Ed9ttNx4MBvmoUaP4bbfd5hlVafPmzfwnP/kJLy8v50VFRfyII47gH330kWdUocbGRn7OOefw4cOH80AgwAcNGsT3339/fvPNNzvSPfXUU3yXXXbhgUCgy6hSItrQc88957l/n3324RUVFXb0K1FffhQXFzuiQX300Uf84osv5lOmTOGVlZVcVVU+aNAgftRRR9lRsQRffvklB8Cvvvpq3/wFTU1N/JxzznHU27fffut5vfnW25YtW/hll13GR40axQOBAB88eDCfMWOGI2rgpk2b+AUXXMCHDRvGNU3jo0eP5tdccw1PJBKOvADwiy++OKscAPidd97p2O51D6ZPn84nTpzI//3vf/O99tqLh0IhPmzYMH7ttdfydDrtOD6fMr3yyiv86KOP5sOHD+fBYJAPHjyYH3PMMfy9995z5NXW1savu+46Pn78eB4MBnlZWRmfPHky/+lPf8rXrl3bo/r34vrrr+cVFRVZ9cY5548//jjfe++9eTgc5tFolO++++5ZUfn+9Kc/2c9XWVkZP+GEE/jXX3/tSOP1vCWTSX7VVVfxkSNH8kgkwqdPn84XLFjgG8XMHdHNr29zPxd+95pz/0hqbu655x5eXV3NVVXNikz47rvv8hkzZvDKykoeCAT48OHD+YwZMxxtqDv9cG8/T379il80yNdee41Pnz6dFxcX86KiIr7rrrvy22+/PatOkskkD4VC/KijjvKtt+uvv54PHDjQs20RBEH0JxjnXeheEgRBEASx0zN37lycfvrp+OCDD7D//vtv7+JsM373u9/hqquuQiwW67Yflf7GwQcfjI0bN/bIR9POwJo1a1BdXY3HH38cM2fO3N7FIXYSXn75ZRx//PF49dVXccwxx2TtNwwDdXV1OO2003DLLbdshxISBEFsO8jEjCAIgiD6GU899RRWr16NyZMnQ1EUfPTRR7jzzjsxbdq0ghIOAVa47UsvvbTghUOFQFVVFS6//HLccsstOPnkk32j3xEEYJlEL1++HFdccQWmTp2Ko48+2jPdE088gba2Nlx55ZXbuIQEQRDbHhIQEQRBEEQ/o6SkBE8//TRuvvlmtLe3Y9iwYTj77LNx8803b++ibXOee+657V0EYhty3XXXoaioCKtXr/aNWkYQAHDRRRfhgw8+wB577IHHHnvMM8omAJimiSeffBLl5eXbtoAEQRDbATIxIwiCIAiCIAiCIAiCKHBI95YgCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARBAEQRAEQRAEQRAEUeCQgIggCIIgCIIgCIIgCKLAIQERQRAEQRAEQRAEQRBEgUMCIoIgCIIgCIIgCIIgiAKHBEQEQRAEQRAEQRAEQRAFDgmICIIgCIIgCIIgCIIgChwSEBEEQRAEQRAEQRAEQRQ4JCAiCIIgCIIgCIIgCIIocEhARGwVl19+Oc4+++xtft4VK1YgGo2iubm5T88zZswYvPDCC316ju6wbNkyMMbQ1NS0vYtCEAVJf+/zJk6ciFdeeaVPz+EmkUjgBz/4AcrLy/G9731vq/K69dZbceqpp+aV9t///jfKy8u36nwEQXSPF154AWPGjAGQ3d/88Y9/xLBhwxCNRjF//nxs2LABhx56KEpLS3HyySdv1Xmj0Si+/PLLrcqjKw4++GDcc889fXqO7sIYw4IFC7Z3MQiC2InQtncBCCIfGGOYP38+pk6dCgAYNWoU2tratm+hXJx99tkoLy/f4QYHBEHsfGyvPu/rr7/OO+1NN92EBQsWbLUQ/W9/+xsWL16MdevWIRQKbVVe11577VYdTxDEtkPub9LpNC677DK88cYbmDZtGgDglltugaqqaGpqgqJs3Zr2jjZm7K3+kyAIorchDSKC2EEwDAOc8+1dDIIgiG0C5xyGYaCxsRHjxo3bauEQQRA7L+vWrUM8Hsduu+1mb2tsbMTEiRO3WjjUHxH9J0EQRG9DPS6Rxd13342xY8eipKQEtbW1uP/+++19//nPfzB58mREo1GcdNJJaG1ttfcdf/zx+NWvfuXI68ILL8QFF1wAwFoduuGGG1BbW4sBAwbg+OOPx5o1a+y0a9euxRlnnIGqqiqUl5dj2rRpiMfjtsnB/vvvj2g0iltvvTXL1CqdTuOaa67BqFGjMGjQIMycORMbNmyw82aM4cEHH8SkSZNQWlqK448/vtumGitWrMARRxyBQYMGoaKiAjNmzMCyZcsAAL/97W/x5JNP4ne/+x2i0SgmTpyY1zUzxnD//fdj0qRJKCoqQltbW876Jwii96E+rxPZrPbRRx/F1KlT8etf/xqDBw/GkCFDbA3JF154AbfeeiteeeUVRKNRRKNRANak5be//S122WUXlJeX4+CDD8Y333zjyH/OnDnYd999UVRUhFNOOQW/+tWv7HxuvPFGtLW14YQTTsDgwYNRVlaGadOm4YsvvnCU86mnnsKUKVNQWlqK0aNH49FHHwVgrcqfeOKJdrqrrroKo0ePRklJCXbddVc899xzXdYBQRC9x6pVq3DkkUeitLQUe+65JxYtWmTvE/3N/PnzMX78eADAiBEjUFtbi5NPPhmPPfaYPa7685//nPV8A0B5eTn+/e9/AwA+//xz7LvvvigtLcXAgQNx3HHH2elkUyvOOe666y7U1taisrISRx11FBoaGhzluuOOO7DvvvuipKQE06dPx8qVK7t13bn6sd7qPxctWoQnn3wSkyZNQklJCUaNGoXrr7+eFhsJgtg6OEG4+Otf/8pXrFjBTdPkb7/9Ng+Hw/z999/nmzdv5mVlZfzBBx/k6XSav/TSSzwYDPJZs2Zxzjl/7rnneF1dnZ1PMpnklZWV/P333+ecc37llVfyQw89lK9Zs4Ynk0l+xRVX8IMOOohzzrlhGHzvvffms2bN4ps3b+bpdJq/9957PJFIcM45B8Dnz59v593Y2MgB8C1btnDOOZ89ezafNGkSX758OW9tbeUzZ87kRxxxhJ0eAD/44IP52rVr+ZYtW/juu+/Ob7zxxi7rYvTo0fz555+3z/naa6/xeDzOm5ub+Y9+9CN++OGH22lnzZrFL7vsMsfxua5ZlGu//fbjq1ev5olEghuG4Vv/XtdNEMTWQ31eJ3Kf98gjj3BN0/gdd9zBU6kUf+edd7iqqry+vp5zzvmNN97ITzjhBMfxDzzwAN9tt934kiVLeDqd5vfeey+vra3lyWTSzn/cuHH822+/5bqu82QymZVPc3Mzf/rpp3lbWxuPx+P80ksv5ePGjeOmaXLOOX/ppZd4ZWUl/9e//sUNw+Dr1q3jn3/+uWeZnnjiCb5u3Tqu6zp/6qmneCgU4g0NDZxzzt955x1eVlbWZZ0QBNFzDjroIH7WWWfx9vZ2/s033/AxY8bw0aNHc86zx1ju8Y17XOXV55SVlfF33nmHc875fvvtx2+++WZuGAZPJBL83XfftdPJfepjjz3Gq6qq+MKFC3k8Huc/+9nP+IQJE3g6nbbLNXHiRB6LxXg8HudHH3203e/nYvr06fz//u//OOdd92O91X++9tprfPHixdw0TT5//nw+ePBg/sQTT3heN0EQRD6QgIjokhNOOIHffPPN/PHHH+cTJkxw7DvqqKPsl2YikeAVFRV83rx5nHPO//73v/Pa2lrOOeemafLi4mK+YMEC+9h4PM4VReErVqzgH330ES8uLuYdHR2eZehqslRXV8effvppe//q1as5AL569Wr7+Ndff93ef/PNN/Njjz22y2uXBy9u5s+fz4PBIDcMg3OePZDp6ppFufzyF4j697pugiB6H+rznuecWwKiIUOGOPbX1dXxv/71r5xz7wnOrrvuyl944QXHtqqqKv6f//zHzl9MoARe+chs2bKFA+CrVq3inFv3YPbs2Z5pu8prypQp9uSJBEQE0besWLGCA+Dr1q2zt9122219JiCaNm0aP++88/jKlSuzyiL3qYcffji/7bbb7H2JRIKXlJTwDz74wC7X73//e3v/E088wSdNmtTl9coCIjfufqy3+k83l112GT/33HPt/yQgIgiiu5CJGZHFk08+iT322AMVFRUoLy/Ha6+9ho0bN2LNmjUYPXq0I638PxQK4ZRTTsHjjz8OAHj88cdx5plnAgA2btyI9vZ2TJs2DeXl5SgvL8fQoUMRDAaxcuVKLF++HMOHD0ckEulRmVetWmVHxQCAqqoqhEIhrFq1yt42dOhQ+3dxcbHDVCQfNmzYgNNOOw0jR45EaWkppk2bhlQq5ZtPV9csGDVqlOM4v/onCKJvoD7PHzmPfPJZtmwZzjjjDPuay8vLsWXLFke53H2em3g8josuughjxoxBaWmpfZ2iH1y+fDnGjh2bV/n/7//+DxMnTkRZWRnKy8vx1VdfUX9KENuINWvWIBwOY/DgwfY2d5/amzz88MNIJBLYc889scsuu/ia6Lv7z1AohKqqql7tP7vqx7zoSf/5j3/8A/vvvz8GDhyIsrIyPPjgg9THEQSxVZCAiHCwYsUKzJo1C3fccQc2bNiApqYmHHPMMeCco6qqCsuXL89KL3PmmWfimWeewdq1a/H666/jjDPOAAAMGDAARUVF+Pjjj9HU1GR/4vE49t9/f4wePRqrV69GPB73LBdjLGe5R4wYYfsDAizfHslkEiNGjOhBLXhzzTXXoKOjA59//jlaWlrwn//8BwBsW2+3E8WurlkgH5er/gmC6H2oz+s5Xo5jR44cieeee85xzR0dHY7Q8105nL3rrrvw2Wef4f3330dLS4t9naIfHD16NOrr67ss3/vvv4+bbroJjz/+OLZs2YKmpiZMmjSJ+lOC2EZUVVUhkUhg/fr19jZ3H9odotEoOjo67P8dHR1oaWmx/9fW1uLxxx/H2rVr8ac//Qk///nP8dlnn2Xl4+4/U6kU1qxZ06v9Z1f9WG/0n6lUCieddBLOP/98rF69Gs3NzbjggguojyMIYqsgARHhoK2tDZxzDB48GIqi4LXXXsObb74JAJgxYwZWr16NP/7xj9B1Ha+++irefvttx/EHHHAAKioqcPbZZ2OvvfZCbW0tAOuFdsEFF+CKK66wtWc2bdqEZ555BgCw9957Y/z48bj44ovR1NQEXdfx/vvvI5lMAgCGDBmCWCzmW+4zzjgDt956K1auXIm2tjb87Gc/w+GHH46qqqpeq5uWlhYUFRWhvLwcmzZtwuzZsx37hwwZ4nBy2NU1e5Gr/gmC6H2oz+s5Q4YMwfLlyx2RdC6++GLccMMNWLx4MQCr33zxxRe7tfre0tKCcDiMiooKtLW1ZYWuP//883Hvvffi3XffhWmaWL9+PebPn++Zj6ZpGDRoEEzTxMMPP4yvvvqqh1dLEER3GTlyJA444ABcffXViMfjWLx4MR566KEe57fHHntg3rx5+Pbbb5FIJHDNNdc4hOmPP/441q1bB8YYKioqoCgKNE3LyueMM87A/fffj0WLFiGZTOK6667D8OHD7QABvUFX/Vhv9J/JZBKJRAIDBgxAKBTCxx9/jLlz5/baNRAEUZiQgIhwsOuuu+KXv/wlDj30UAwYMADPPPMMjj/+eABAZWUlXnzxRdx7770oLy/Hn/70J5x++ulZeZx55pn4xz/+gbPOOsuxfc6cOdhvv/1w6KGHoqSkBHvuuac9EVMUBS+//DI6Ojowfvx4DBw4ENdddx1M0wQA/PrXv8all16KiooK3HbbbVnnvOaaa/D9738f++23H8aMGYN0Oo0nnniiV+tm9uzZqK+vR0VFBQ444AAcffTRjv3nnnsuVq9ejYqKCjtMa65r9iJX/RME0ftQn9dzTj75ZDtaUHl5OQDgkksuwdlnn42TTjoJpaWlmDBhQrcnLD/72c+gqiqGDBmCSZMmYb/99nPsP/HEE3H33Xfj4osvRllZGfbee298+eWXWfkcddRR+OEPf4jJkyejqqoKX3/9NQ444IAeXy9BEN1n7ty5WLlyJQYPHozTTjsN55xzTo/zOvTQQ3H++edj//33R11dHSZPnoySkhJ7/z//+U9MmTIF0WgUxx9/PO68805MmTIlK5+zzjoL//u//4tjjz0WQ4cOxRdffIGXX37ZU5jUU7rqx3qj/ywpKcEDDzyA//f//h9KS0txyy23YObMmb12DQRBFCaMkx4iQRAEQRAEQRAEQRBEQUMaRARBEARBEARBEARBEAUOCYiIgubJJ59ENBr1/GyNI0WCIIgdEerzCIIgesZ7773n23++995727t4BEEQvQKZmBEEQRAEQRAEQRAEQRQ4pEFEEARBEARBEARBEARR4PSeu/7thGmaWLNmDUpKShyhLgmCIPKFc47W1lZUVVVBUfqP3Jz6R4Igtpb+2j8C1EcSBLF19Of+kShcdnoB0Zo1azBy5MjtXQyCIPoBK1euxIgRI7Z3MXoN6h8Jgugt+lv/CFAfSRBE79Af+0eicNnpBUQlJSUAgP+89wFKSorBMi6VGDg4rNUg7rEqxDxcL6ncsH8bTLV/i+MZ51l5yfnI6bzO63V8d9FM3f6tK/ndPq9rzXUdju2Qrg/+ZZfTeaXnjEHhpu/+fOjqPnanbnt63LYg33Yi0vldi9897VGZXO3A637ni7tdAFZZGThM5r36wrkq/bPaEWPc8az5PZ+m1M0x1vmMi/ZoMgVtbW046MAD7f6kvyCu5/2MY82u+igAqKmuRmNDg/1fTlNTXW3/ltNU19SgsaEhZ3t0426f+fbT1TU1AICGxkbfNO58va431zZ5u1c5/Y7t6rntqm625pntrf4x133p6h0o7g0AzzaUqy7d+F2P3/2Szy3ahmiv4n8u/O59vu/K7vTZXeXlRjxffuf0K6fYJj+3gPe9cR8r09bWhgMPOqjf9Y9Adh8p8Gub8thSTgsABg/Y2zSkfPvbXM9lPm0i1z3zy48zBs6ltsd4Vhqvc3iVPdd15Cp/T8daud5X3cmjL95HXuQzT8iVX759RHfbTq5+uLvncqff2nvbVR75vq/95hnuMSsHyzpGbJPHhnJ+fnOW9rZWHHDQtH7ZPxKFy04vIBIqwdFoFCUlUYeACHB2AjIKN7Medq8XP+A/IQCyO6iuXvz5DHrzwW+gmasTzyU0yzWAyas8eQiItnbyk6ueuluHsnClt/Ls6lzdSQ/kP7l2X0dvCobs83k8G2Kbn7Coq32As13kEhABgJkREjGY9uDW67q96sGEAgVml89kfzMxcPaPJZ7PobtOSktLs9KKNBs3bLDTicFQTW0tYg0N9v9c/aWjbHkOyOX8amprAcBxPndeNbW1aIjF8j5/vn1hroFprglAV4Nyr3N3l66u0+9d0ZVgIdfk0KvMXu3Dfby73LkmSV0tbrjP7W6LGzZuRG1NjW9b8bpX7uuX09TW1Nhty6+8XU3auisgEm1ePJPuvLs6rzi+IRYDZwy1NTWYMnWq4zpEvbmPdd+D/tY/Atl9pCCXgMhkSh5CnpBvf5uvgKirybDYno9gujuCXvkcXY2R5PT5CB7yyber8neXXIKsrsZNPRHobu14t7fy6O0885n/9OQ+cc4cAst86a6A0mvBWwiE3HMjhZv2eFT89stb5Nsf+0eicOk3xpKyNoHcCTBwx0OtcDNLwswsMVJ2npntcr6MczsPx8DJ63jOHR+xzb3f63+u7V6/5bTy9fl2aJnt7vrwylO+vq4m/KJD7YlwiLNOYZ78kvF6QedTn/I2d7pcZfOrA3ea7uzP+dJynU9+0XXnZd6dwYvXS9zvxc4Z8xacihdq55Nif/zS2GV1PXN2+/K5TwKFGVkDiVzPkX2c0DryeMa6W887K34TE/f1x1zaBe4BvfyM+j2n+UxY5DxytT35d6yhwVE+r3ReE91c5/dLJ+qlO5MvP6FPPsIhN+40XvXkvj/yOQFLoJHvQoL7WvzK4D6XX9nyuaZaSevHK11Nba39cV+DFw2xWNbzHWtocNyDrsqaawIrhCzutO46znW+XMIBv+3ivH5jilzvjFhDg0MYJJ4PuY69hF5+z3khkGuym2sRA/AXZni1K/c99cqrq33it/zt3u93jPs4d3/sdy1d9d9+eeQzifciVx/nVS75f1fpunr/57oHuY7ZWvpiTJIrz+48415jVq822NU57TQ9EA6J88rf4rdvu/QYozLurRggP+f2vMYn3676BILYGaFWTRAEQRAEQRAEQRAEUeD0GwGRLb320XBxa/zYx3n4VvHbJszV/OxQc60Se60w+h3rp9mQazXcfd2yZpB8TY7fHvllqZC6jpW32WZ8Qorv1iJyS9l72NzklXw5T1Xyx5RrBdedlzt9Lg0n2Wa/O3itaORKy5nTP4AJpbNeufPbnYZz5qhbL80OE0pW/Ytt8vnlY+UyeF2X1397u4cWkfgtr+A4VqHQqdprfQzHfkXyH+QuQ3dXuQtBY0hGbuOiruRnKpfmS1erq7LWRlb/kaMP81s97+q8Xd277q5gujUwcmkDeV2D12+5z6qprXXUsawN4ybXirzQthHHi29xrpraWtTW1KC2pgY1tbW+K7q5VvH9NF388nLvl6/Nr08WdeK+ZjfCnEt8uiKXNo+7rPJ9FnXWFeIYUdfi2HyOy6W91FW/5daYk9uIuy2576373SbK0lV9FprGkBsv7Sw//O6nlwZWV3nl+17KNbbx63N70p/2RPOtq/rwSyefJ5eWU76aUT19f+Ria3wvbi/8LCT80nr9zpXea/ws/mdZa3Qx9+kJfmMOxrntlsArnR890RgjiP5I/xEQgUORnEy7hTiyPxR5guqesLp/O9JILzqTKY6Bmp8KotdvrwGE/N3d6/YS/uR7XOek3Mja5+V3xoAKA1anK+8Tx5tcBecMaQSh8wDSCNoCDB0BGNDsj45Aj9Rau/OCyTVY88pfTuMQunCnAMd3gOQhUPIT8Ig85bzdv0UZxDZRvwY0cChWeijgUKxtUn62AMgleHKXxev8XoO8XO3Y6+M+zl137rYl2pzJFMn224Bq6p3CTtdg0W8A2x12xkFfT5DvhWx6lM/zlKvevdJ6CaPkCbZX+8hHGOU12fUrs7vtucsltgnhi3tSKOrIS8DilTcAOx/3fiFI4IzZAjU5X3GcEFaIj5yH2/TPXSZhSiQLVGIZx+FyGbuqY69v+X751YufkEguq+xDym025u6rZT9S7k9Xpmny+dwCOneZZLPFrtqT+BbpG2IxhzDOjZeAwa+d+/W5QiDldYxseiYfJ645V/7iGFlY1JN3bH/Cq1/rrbrwE3b0BbnGOV5pu0Luu72ET+7xRFd55VUu3vm8yX2q/PHqn7y+PcvhWuh0b/f67ZeuK/wEL/kKYbYGt0mVO2/3grG7fHIa98Kz2OaX1s7H593tJwjsyXMhl18uhwGtc9zr8e72wi9NofePRGHRbwREBEEQBEEQBEEQBEEQRM/otwIiof3iZd6SC7fkOF+Js0ibL7lWPLqz+gNY1+XlJI2DOTWDPMI1ulXUvRx4C0ymQONpKMh49Bc1KknPAzwJBSZCPI4AUlChg2ciSGlIZ+VdW1PjMGWSV4YVbiCSboXKdeiwwsdyZmnPAIChaLaWTFdaRG4NlM468VZVZpyDMd7p3JjxLEd6bq0bk6u2Vo/Q9BEqruLb4JaWT5oHrf/QYEKFCdXWrOKy5pLPI8rgvk+u/yLKl1RmcS35RIwQaby0nvLF/RzJ32ZG48mE4tBUE2FFFW6CMwUmU2EyFSxjIuqltdHjFaccq4P9FVFXbm0Ut/aM2N5Vf+SlSeO+1/I2v+fNS8tETp9rRdhPG8OrXfitggtNG7mcsYYGW1vGTwvHS1tIIGslCS0Nt6aH+C/OL7RZxP1xa+t4RdES2iV+ml9emlPuY93HiH3ubeJavO6ziITl1saRNaHc+8S1iHN59Rnu1eXamhqHo2WvtiXnL5tAetWJXBd+5/fCfU2ylliu9urWqhMaQl6Ife726ZVGIMoh6kre7n6evfpTt3ZGodCdMZeMnzaE+5NvGbo7/stVJr+xrFc78GoL8rFe6exnRBoreI0bvPLyqh/5vCLqqLgO1dSz0rv7L7m92+fJWBd4jkck6wC3RpBbq94qnymNe701Z9z4aSO5fyvccHx7HSv/F+m89uVLrjlSV5pHXf0X9SOXM1eZ3XMJxrntGqQ7z5LQQDeZAhU6NFhzFtEm/dyNOMrfzWd4a59XgtgR6TcCIvHwWn5LTGdH7tGBe3Wi9ksjY2KTr8+cbakmLMptT7SZApVLvnhcHbrJVPvqxe/q2jrU1NaiurbOPmZM3bisPMT+6tq6jLDJtCbr4JLAxbTLJMoh+8ioq62GCt3+PbZ2tOMDAHW11Q4/EOL4MXXj0BEsRZJFMK52VOZ83BI6ZQYM3GW65gXjHKqZBuMcmplCSO+wBh2ZF0ZRqsU2dwuYSft6ilPNAADNTEM1dXuAAriEQ5l2wmCCwQSHYn8DgJkxyRMCEQVWnaURdLQxE9YLzd3uZGGPCPEufiuZczLG7QhfQpgmzqtIwiMTKhSY0HkAQTMBJSOaUmxRm+mM+CUJknrqj0kca0KBwTUYXEMaQbs8SYQz90/NOod4bnlGAOo38JV/56NebqfvQmDcn/CbJMsTefHtNWH1GtjL+9z/ZXMrsc3LNMC9XzaL8jMjcAtmuvLr41dG+VtcmzBL8uvX5XqSr1MILsR5hPmPn78XuZ7dpmXuib3wL+S+VnEet4DFz7TKjVxegThWFiJ61a9XXbrvlSiflzBGzt9dR6I+vXzsiKhk7nLIaeVrd7fbrvoFkcZvUiAL/tzlcpfJncZ9DrHdLSiTkfMV55avxauNif+iDbojlcltV+BlluZ3Lf0ZP0FKPoKbrurKU0jh83z6CXK88pLTu397pe2qzF7CIrndyX2eoK62GkCmjTLnPq9z5apP0QfJfd+YunGOqIZyfyj3FbIvNsa5Pb6Vnzm5n7LNjyBfs+n4bTLFHlcZUB3CD4UbiPMiqGYabWYJUgiBgSPOizqvVRK6uM8h5iucKfY34DL1ktJaC6Kd6WWTfHmxTcav3eWaYwDWmJ6DOc4vriPOi+x9aQSzzsulRWvmXniW8nPP2WQhklwexzaPNun2Wem+JgWdgiEvYVqhLBISRL70GwERQRAEQRAEQRAEQRAE0TMY5323PKTrOm666SY8+eSTWLt2LYYNG4azzz4b1113HRRFOMvlmD17Nv7whz9gy5Yt2GefffDAAw9g4sSJeZ2jpaUFZWVl+PLzT1FSErW3O9QmmeLYbmvhoFMFVaiZcs4sEyootqqsrEUhry560R1VQ69VSHllw73a6U4vyu31XV1b51hZ3hqW1S+xNYwaY/UALK2iFUu/waixEwAAy+sXY3Td+K0+lxeyI06x8iybGdTW1GBxbCU0loZmpqErAftYcf9Ceof1P9MWNCMFAAjocVuVOBmIgoFjjTIKlcomRBObkAiWgDMF7UopwrwDHYgiyJIZUzBmawNxMKR5ACGWsNuNCitfcU8UbkBXAtkaMHlo5shtUW6TcnvReSCzUmIgYrTBYBrSashOZ0BDyOxAUimyvzWkrdWxzLF2mcA6zQOl6GGyGrl8fnu/j5aGbWoHBQZXHaZlCkxwMGhMhwpLC02uV8Bq6yZTsp4Pv3OLZ9mr3kyu2lpoQhOupbUNU3ffHc3NzSgtLe3yfvQG27J/XDB/PkpKSqw8pb7F/S1MmNwaB/I+v2dRfLvzcp/HXQZBV/dWTpfrvxuvvOQy9za91e9293ziW9awka/Vq+7leySQ69Nrv5xO5Cf/l88h//dqW7LTar/8/P57ndPvOK+255eXV/sWZXTn55eXV116Heu13X0Pc5XT71zu++anJZLvOdpaWvpl/wh09pHzFyyw+8ju4lW/ftocQNfjxK60erYGr37ArVkhyt3b/Zhok/Iz5fW7t/F6Ftx9puxeQWi1GJmxpI4AhBk/Yxw6D4CDIWUGEVRSaDeKEFESSPEAFHCorHPspzEdISTsOYZq6kizEII80alZxBTpd2c5DWi2NroKHWkEobF0l/MQL7zaD+cMGk/DUDQEjCQ6lBKEeQfaUIqI0oEUDyGAFExYlgMGVISQsDWY0ggiYrYhrYTscbTQbJJ/u7Vz3PMzeV7WXWStK8CyqvBzo6BkNK4Y5475krtM3aWlrQ27T526TftHguhrvG1yeonbb78dDz74IB577DFMnDgRn376KX7yk5+grKwMl112GQDgjjvuwN13341HH30U48aNw80334wjjjgCixcv7tbL2v1wyy9n0TFLiW0BkPxitF+cmUkreOaFmelnulLX76qz9hsc+h3vTpv1X7o++SVbU+MMg9wThMCnMVZv1+yKpd+gOiMQAmALhwD0mXAIyL4O2cRDDNpV6LYJXMBIwlACmRe8BsY5UmoEDBwBIwGFmwjocRhqEFxRYXAFaS2ClBoGZwoGmuux0RyMQDCJpFYE1dQR4e1W3khD42mozLBUjVlnKM0gs4ROJlehMMOOIMaY1YYMZpXFhJLxscNsFWhhcgUAE2qHe07OG2P1GTM0ozOqWaYdK9xEEEkAlgp0QivOqkcGE2k1ZKkEqyEoMGBwFXU11XaapbHlAAAFRsY3kgKTKw4zNSEw6kpIynlGaMk72ymDZbamwVJdNrkChTmjYog8LPVlbl+jnLedxkNYZl9vRijEocDkGXv6zDOtIwDr0TYc17Yt2ab9Y8bMRPbdIp4jefAca2gAk75l5G2cZaJxoXPi7DaFkf3u+Jk7eA10u5pEy3il9UonCyLk/qOnuAVjQKegZlsKh4DssPddmXYAne8SdwQrd73FGhoAn4mpyMNPyOC+dyKvrPbGueMcfgIQ98TSa5t78icLTIBsUzb3tYvr8bqHch5evqC6EkC5r0U+r/yOl69Nzlc+VpTTq07c6bzO6ZXG7dtJNuPoLeFEd9iW/WM+ePUxfoJGzqx3jd8kPte7M6cAp5v3IpcgQc5TtPfGWL3tWqA3EIKX6to6q6/0Gcu5f/c2XfXJYhwm6spkKlRuQjNTmXGfCZXrMJiGJCJImtbCW8oMIGUGoHMFDCFokmAowNIwuCVQaedRFLM2GFyDzgJQYCLBiqAxyy+nauqd71Z0CkzEghkyY5QAUvZ8RG4LSsZUa3TdeCyvX+xYiPR6vuVjhPsIXQkiiCQMRUMRbwc4EGTWmFLjVjk1pG2BDAdDACmk1LDj3ln9rpqJQJsGZwoUbsBkGVcLzJp2yuNE26+pz8KV+9lzjhU7hWv2/fTxsSlHm7bndVmmcdnPnbydIAqFPjUxmzdvHk444QTMmDEDY8aMwY9+9CMceeSR+PTTTwFYqz/33HMPfvnLX+Kkk07CpEmT8Nhjj6GjowNz587ty6IRBEFsV6h/JAiC8Ib6R4IgCILYPvSpgOjAAw/Ev/71LyxZsgQA8MUXX+D999/HMcccAwBobGzE2rVrceSRR9rHhEIhTJ8+HR9++KFnnslkEi0tLY4P0KlxIKIeyR8Z4YC604GwYjnHtV2gZTsOlFf4cuGXRl5ldX870rlULB3aQpLGSC6TpK1ZhRHmY8vql4BxE0tjy5FCyDYvkzWGtjdytJxYQ4OlVQMrapuhWOq/aRZCwEgiYCYRTW5BwEggYCQRbfsODByakYSuBPHPpu/hOzYCJlORQAQJpRh7jBuAhFZsO0ccXTce1bV1GFs7GmPqxkHhBgI8hYBhrbAEeQIqdMvhs2SSxRiHaupQuAHNTEEzUwiaCQAZZ47gUGGgiLehiLchhERGM8OpUeGOgsTAoXLdLoNmpjKOuDNOp6XoD7ZDcQ+H08KxpEA4D7ecYHNrxQgZB9iZSHReUSAcq+CZqG7yeRg61Yyt6HYGNOgIsQQ0pDORJpymbCZXHY7HRb4KtyJSiDJY9WvaDiPd0TDsegTPesYAy3n49lgh35b9o1tbBOiM8CSvzLmjwAjHtbJmhVtrRCBrNbhNiLxW2kWbcWtJulfM3d9eGkdeyFGl3Nt6guhvhNNlt0nEttYcyoUcDc3P6bfs2FqONCYjO8wW91duJ7LTWJGP7CBWHCfyytLyc9178S3ycre1WENDltNrsc2N3LZEW5fPKWsXyXUha/F4tRe3+aV8Pvdvuc688NLC8jqfl6aWrAUm6kR8hJaTu1xu7Sg5Ty9n4tuTvugfAf8+Ml+8+isZv/aczzvG673q9e2XXn7mvMaafvkIekN7qDFWj4ZYDI2xetTW1NimR32pIdRdGmIxR38ukLVTrHGEZf7ejhIklGLEWTGa06Vo18No18PQuQKdKxgc2IgBykaUKC0YaK7FpLqhiJht2LWuCtW1dZhUNxSANb4aXzvSGmOB20E7OFPAmQJDsYJ1AN4mT+K+qVx3BKcxmYI0C2JZ/RJ7ziMHkxHXKcaDSua6dCVgp5ejCYtzMZ4dkU6eU1XX1mXdV9G/mEy1x+IG02AyFbpiBYMxoDki/4p5jV97d5fLzGgNCQfduZ4xeTwKwK5zMba0gqBYx9oOy32e3VxzPILob/SpidkvfvELNDc3Y5dddoGqqjAMA7fccgtOPfVUAMDatWsBAEOGDHEcN2TIECxfvtwzzzlz5mD27NlZ2w2oMBTNU3hiQLM6xczEXTV1S4U0YwsMAJz5T0is/ZLZjCuk59bgUCmWVFwZt0xrbHVSV1QItwkSANTHGrMm/PnQEIshjaBt5DSmbhwaY/V2lLEdBdmfCVz3Q9gdg2m28MRgGjQzbQmGUh3Q9DgU00AyXI71ISsqWhQtqB7Qgj3HVQKodJzPq76FLxwlo0KbVkNWpIeMGi0AaBm1XYHY3unrSoFmprBi6TcQr1qeIwpFZ+QG095j++/hBnQl6Iz8IAYFkuqtMJW0wr0qtjqv7FdDNsMB4Lj/QmhlMgWaaakbi2tRuGG/bDnztv22dlrll6O8WTb2liAqW4VXMv3infXAIXwJWaZnaYQs/wBMtZ9NjaehI5DxZWTdD9me36oT0/7emghtPWVb9o8y7j5N3HsxaBY1Iauke+2XJ9ji+XALfER697m8IlEJoYAs0IDrXPJ/t5mP/LwKwYjIL9eEvyvcPnjENe5IEx6B7P/Is/9y3RvkMD8R6RpisSzTEHf+7vMA2cIoue24hTRepjOyeZvcZv2OcQs74BI2utumfB7xTsmqHylvUa9uPypyWnfesqmb+9x+Jl1u3yjys+VXHvk4N26BhjuNlwnH9hCYu+mL/hHw7yO7YwrmFlSL6KR+bSxXXoKe1LnfhBgMWX4QZcGgu4/dGr9p9bFGeyFsTN04mExxPBt96X6gOzj6cel5EMISd9QwDgZDCVrRfzlDi1GCsJJEeaAZYdNyOdCGUgxJrYAS1zFg0v6O88kLqtYzl4nQaS+adY6DHGN/10KWe9EagO1nUx63MMZhMC2vMO7ifMI9gsKMTpOrTPsR7Vjhnf4gxbhRmGrJfYm7/cj/3QucVhkUewwmyu9ZVp+xmXAZ4CbLT2fGlYioR5XpjrIIVwY5x67yeV39cL7CX4LY2ehTDaJnnnkGTzzxBObOnYvPP/8cjz32GH7zm9/gsccec6Rj7sE/51nbBNdccw2am5vtz8qVK/us/ARBEH0F9Y8EQRDe9EX/CFAfSRAEQRBd0acaRFdeeSWuvvpq/PjHPwYATJ48GcuXL8ecOXMwa9YsDB1qqV2KCBWC9evXZ60KCUKhEEKhkOc+WdLMJdmXcPQmpOVCa0h8OzQIWO6VHll7SD5vLslzlkkEnJJrOY2cTjjPdazGZ1YO5dV7sULOWLajSpHGC7FqJCJKJRG29/Wmo8LewrFixzvVXDm37qGIfBUwEkioxZaZmRpCJLEFaqod6eKBSAZD0NUgilg7AKC8eSU2lwzA1/XfYXX7AIyOrsP42pGO8y6NLcfYzOqsiA6nIwBFsVZTgkbcNmdUuZ5ZjerUHAKE5lFmtUZy2Ad0auLIacW3iKZhXX9GWyfj5M9QNEtFlzGYUB3nEwiNIUc9InuVUzarkBFtRNYeEo4Nw3oH2oPlCBhJhHgHFNNAe6gcHAxBI46kVmQ7iWYwHZEwgtBtzR77uj1U4WXkVVux0sbBsqKsCa0ioFMHSZTBilDo/Rxva7Z1/whkO9IVq19uDROhXSb+C+0PWevBy5wsH9Mbt1aSfE/dmkVyWWWNCdvhtqT1IJfDT7tE1iTy0gTxwt1/74iaQwL7fmTq2cvMCOisD9lxuaxJJmuvyPfMbaIk464XWTtG1uiRzy9+d6XC797nNjkUyNppXppy7vN7Xb9XxDfAqakj6sZdF27NEvHceJXXHflPINe5Vznk50zWAhPnkq/JrWUknndRP+7rdz+r7nNvS/qifwT8+0ivtilvl//7jdWE5rfbRHxr8dJKcr8v7TaW0TaPNTRYZZHar9c1ypqCXs9frv7OMu83oZid7/IdtX/00uaTNUscTqoVDczktjZ60gyiSI1DgYmI2QYRmYsxju8CY1DJ12PzwvcQD5dDNXUM3WV3AJ1Ovx3ah8hEbmViHOMM+iFH5coKsJNBHv/Y35JGjIBnRj0iMrOIhsYZy2iY6SIhxGEiqqwdaZYxuOcqcnkFXibscv/o7L873R447oXXteYYq/nNu0SQIUfaLp7rnkCaQ0R/pk81iDo6OuxwpAJVVWGaVudQXV2NoUOH4q233rL3p1IpvPvuu9h/f6e6ZtcoGVVNxSEcAgATatY2WbVRHOPw0ZJDbdDdKXXHzExM+E2mOPw32C8HyRuSmJgLcwZ5suYVuUT2/yB//DChYHFspR2tCrDUhXdkLGGIYr/YxItM2DEDlu2zCsPydWOmoQciSBQPBGeWgEI1dUTSrShKNSMRqcBg/h1KeBO+Z74PnXfKTBfHVuLL+nVI8DDqY42OybDCDGhmGirXoZlpaGYaYb0dmpGytwnfOKqpg3EOzUhBy/gJEmW31V4z28VH4QbaeAkMpsFQAogrUWzmA5BSw9jCK9GCcocdtVU3iuMj6kI+j8nUbqnEihe8sDU3mIaUGkZaDaE9WA7OGBJaMdqDZWgLVaAo1QzOGJJakVVPMK0IczAzvod0O9qaGPx4fYBOPwryYNz9knenUWCpV6vQLb9HQs0487zbNuY+wuRtybbsH3NNLgDYQmf3pNA9ufYSIspCJnkC6j6PuEdy3+VXLs6Y3TcKHzFugYPs00YWmscaGhx9qjhe5CX7z+lq8uMWsnhd/46G25REFpjI7xH39cj9m+yPxj0ZlvP282sljvMTMvhNMvwm017CIa/9flHK3Hm4Tb0Ap78s98RGbo+ibuQ0crsS/pzcgiv3NQihpshLjoDnbpdyG5bLL+6naMtyvbqjC8rHuM2JxX6vut0ewiFgW48fO3HfO/c7pqv6kMeD+dZddyeaCjezxo9yud331a89im1ePsS6Gj8uq19i+/5TzTQ0M5Xz+dtR4Jw5BGf2M+MS6nEwJFkEBtNQorZBy4xdhDk/AISVOAJKGq1qBb4NTMUaPhKGYo3Jvq7/DoC1wLi8fjEAa/yvwjpe+NwRfnSEL1RD0Tp97AjfPJmPWBC0ytgZhQzIuNnIjOUtD48B208RZyzjV9I6JmAkEeDWWLVzIdK/bfstuPiN39ztWX7X2uM0lj2uc79z7A+TjpE+cnncz2c+z1RX7ziCKGT6VIPouOOOwy233IJRo0Zh4sSJmD9/Pu6++26cc845ACzV4Msvvxy33norxo4di7Fjx+LWW29FUVERTjvttL4sGkEQxHaF+keCIAhvqH8kCIIgiO0D47zvxKatra24/vrr8fzzz2P9+vWoqqrCqaeeihtuuAHBoOUSmXOO2bNn46GHHsKWLVuwzz774IEHHsCkSZPyOkdLSwvKysrw+fwvES0psbc7nPPC0vhwm4K51RZtbYNeUkV0O5ATzvC66wzQrfrr5RxTmEx4qpTLDtsk6bqlgaLaKqphxJFGECrTUVtTg8WxlRmzLRN1tdU9doLdWyyOrYTG0tB5wKFeG+QJS2vHSEFXgwinWu1jIq3rkIgOAmcK0loEhqKBZbR6hEmWyVQktSLoLIAATyGox23n05uVwQizBFqMEgxUNkBXAghmoqEppgHOLDM21dRhKJpTQ4gptilZp1q6cIzcWf60GrIiqLEipDPXBgAT64b5Oo9cteSrjDaQcHDY6ZC6K/zac09Uw/PVqMhHM0CUQTa9yCePfHBoD7hNRKGgrbUVe+w+Gc3NzSgtLe3xebrDtuwf5y9YgNJo1N7uZUoj8DJrEcd0FS3KjV9f6rVd1gbqLn5OqGUzMnf/6DY18CqLH7Iplvt7eyKeHS+zP3HPZfM6GS+tVCDbNEvWRJHNk+TzeWmGuduPVxqvus8yCcmjrcjmke72LNqDbLLtCICQSSu3ma25tw6TSBde73K5PvI5p1xGINs5rLzPry7dz6V7f2trK6buvnu/6x+Bzj5ywfz5KJHGkH501T/49XFe+7saW7rvhzBP78kYEoBnW/Zr2+5n203ATGaCvVja0qbSGTU4rVjjJ5OpYNzEmLpxO0T/KDTkhdawPC8wueoIYqEhjRRC0LmGItZuR0mVtbGFmT8ApHkACjOxKVkOxjiSuoZBkWYrL6YjhAQ0M2W7CEixsGMcCMCOYCZbElj/TUdwD9m5NQBLZ4inwZmCoBHPXCPDiHHez4EcdEThpjUP6IYlhFdfvTX9ox/5PCvud4/7tzufrsg1nvE6N2cMbS0t27x/JIi+pk8FRNsCeQJUHC3vjEzk0dnlEhC51RXzFQr5TTDES0MujzifsFeXI0p5TWyAzk63PtZo2xEDVnhytw8NrwGiF/WxRnAoUJhhvxSt0OjWy0/lOnQlaL+s3HAo2yXCmRBYCZtqBhMaT6MksRGJYAk0IwVDCdiCIjUTbQvI+AZQVKRVy/dAh1Jim6m1mVFUsM1Yna7CwOAWRPUmMG4iEt+M9uJBSCshlCQ2wlCCUM0UFCMNrlghPAEgrUUsARMClrAqM2AS99ZQAlDNtP1tmZ1lIoExBUmtKBN9wsCYunF2mcVgRgjnmG2zLkeCYF0OWK3zOCdHvYV7IpZPWUR53LgnZG78tueLW0gkt6Xm1vg2FxBtC+TJT7S0NKdgxguvwZLbb4pbuNSdPL36Wi9hglefJrcVd55e/orybf9ewgX3dbqv1x1RbXtNhHL5cAKQJSwAvH3zeB3jd51+gtyuzMryEch4RdxyC1Xk9igLr+Qye0123eWRBWjbAvlc7uvMZwLfnXN45eH1bHjVRayhAa2trdh96tR+1z8CXQuIvPqpfM1Y8l0YyXWc3E5NlysEwDI38/IZKd8/+Rlh4Hb6ngq5l9UvgezbUEfAFrYAVuRgYUoOdC7YuvvnbY0sIBLj3lazFMVqm13nsmBLFuDY4eMz24XASDV1aHoCAKDpSawtqUOx2YJmVgmTK6hb+y7aBlTDVCyBUjDdgWSgGAo3kdCKETI6UBTfjHSgGJwxtAYrkUbQ9qkJwCEoMuF0G6DCgMIsE7E0gg4fmsIHUmOsHpZri86Q9gBswZjwS5TrvWxde+/fu1zvo1x4LVzk6k/9ImzK9HTetz0E6ATR12wf5xsEQRAEQRAEQRAEQRDEDkO/0SD6Yv7niJZ4S26FVFhEVLK3g0FD2l6VEdo0bi2jXE4HZW0OkSfQKaFXM5GaDGhQmOFYnVxevxij68ajIRazVYfFioVX3nL+XqussmR/5dJF2dGxJPMmgVhRMJhmr5w4oiC4Vq86y7HttYiWxFZAZZbWjzDp0nkAIR5HWG/vdMAs1Z9mpKCYOkRkCD2jQbRZG4Kkaampt6Wt6G2Dw1swatX7aB6yC0q3LENzZQ2SWhEqWlchtGge+PBqGEWlSIdL0RYeAM1MgzOGyjVfoWnoBCS1IsRZMYIsiZLEZqS0MAwlYDmahgYNltZQQJiocQPMNKBrYWwJDEaEtzs0iGINDfaKnDBRFOSKbgF4m1P09sp4LnMRrzLlkxaA7ypQLvIxb8pFf10Bcq+O52v649YUkfd5aZx4kSutl8aPXxt1a8V0pUnm1kaRTYn88uxqRdGtMeDWtACcJlcizbZcKc+lSSWnkfHqJwReGkR+pl3u/SJvgbsPcmt/iTRyPm7tpFz30Ou++NWR+54VCm7tEC8NE4FbC6+lra3faxDNX7AgLxOz7mqYAz3TWHD3nW4NYwAOzeJ88wWy+yp5ey6TSDv/zFhaaNfIQV8Ap7sGeUwLwPF/W/aPy+qXQGcBW3te5wFEzDYYSgAKN5BmQUe5hYa/cBYtEMdH0m0oaVmFQMtG6NEKtJaNREtgAFr1KIq1DgzpaESobSOURDuWjjgClXw9ACDavh5gCkxFha5F0BIagM3pSoxNLoCWjiMdLMaaorG2iVmApR3aWWZGs9+ACoOr0JjlaLo8tR5DJuxpl1OYkVll7pyXcHtuIjmwztE23SbLvYXXu8Z9bjf5jCfcptLd0WzPde5c9GcNS6Jw6TcCIlk9mDNmd6ZydCvZptf6byLFQ9CYbqdRMjEAvIRE4mUnhA1uFVQZg2ngjNn2vSZU27ePH16DbHmQJqsG+xFraIBmpjG6bnyXdQfAjq7AwbL85YjfbsTgYFsJiL6NrYLJFSjMtNVpg0bCrn8Adph5OYQ84yYChqXmzMDtyFopFsaWdDnSppVuYupTmKplFx7Z0Ai2yXqRo6QMPFwMlkoAiQ7w0kqwls1ID6vGyoqpCLM4SuPrEV22AMZ3q6EOGIQPxp6PAeFWDNNXoCU4EAkeRpClkDRDKFLakeRhqMxAkdmKoJFAKNmCDdFqBHnCHvy524GtXiwJiAxF8/UZItiekx+/yb5bndgPPwGFH/kIqNyDJfmY/vqCl/vHKVOn+qpZy4NBINuXjTwoc0/s/cwv5PN44XVcrgFoV5N7L0GQVx5A/gNdP5Mtt1mT36RxWzyDchn9/Ol4lcttdpWv7wUvAa6faZ9fe/PyledVp/I+gVe4bvcEYUfwd7K98ZoguYVv+QhFgf4rQAfyExD5CT5zmdm6j5PT+eUnLwi58/YzJZPJ119lruMF+T4/cuTbfCO4iXdxV9fTW7gX29wuIIBMeHfp/jijmnUurqpmGqF0O4o3r4ASb0PLiMloDg1CyOwAZwo2mQOxMV6CokAapYF2S4DDOEyuIMUDqGCbMXDTYnBFxZbyaixNVEMBR0A1MbX1bWir6rFm6vFoMUtRiY0oTm6BoQShmJaPITMTJa09WI42swQ6VzGUr0bV+N0c1+vuy63obaot0FNhoLq2LueYbHuNId3uMwRuoZK7XwOc7xIv8lkY8iLXe7G/jh+JwoZMzAiCIAiCIAiCIAiCIAqcPg1zvy0R0l0Tir06INBYGiZXoTAj67gw4vbxOg9A5xo0Zqlf6jwAEwoivB2qaaljCud14J15CbmybM6lcMO5usl4l9L4XCs28mqsn8NJURY94zw5H4Sm0bL6JVC5ntGxEpGxvLWHACv6w7L6JVkqz31BEEkkWRgGV6EwSyvIZCoC9j1RMhpbSkaTSLGcEDMThhKwTfzazSIMwAYM6FiBIfoSAIChBhEPl9uaYKFwMdTSciCZALZsQnKXGsQjldDMFIqa18AYXofNZdXoMCLQNB3t4UoUrV8LpqpAWQXqIsuxOl2FBoxFKW/HAGMdQuk2MG4irUVQxg2ktAiSahFMpiKYbocCw6E9BLhWOSQNNaHy7G5LO5qphF95RDvuSj1YpHXjZyLjh1t7yC+NO7JZf4Mz5hldyl3HQnPIHelKXpGLNTQAObRNvFbJvVbM3domXSHS+LUtUZ6t1V6Tca/Ai+uQVyfdTru7e47eRtYSEc+aWwPMa4VZ0JVWhPt+yenkuo81NGTFVRTntleIJY0wS0vW2T78tAj9+g+RD5H7neA2L3Pvc/fHC774ok/LuqMhIs564fW+kZ8Z9zOVS7syKx+W3a79zMu82BqtOS/NvHwQkW3Fc2y/S5nrHeA2d2LKNouMa3LLdYLKdHDOEOQJa1yY0cYR5vtWfZu2pYDCDWhmGqqZhpaOQ0u2Ye2ASViPYcCQOgSVNEIsiSKjBeFUK9JaBJpqYFNbAE2KBq1CR0UgCY2lYUBD0gwiZHQAnIMZuh005bvmMAaWpPFZ9DBMHluOYSs+QvmAUdDSHdhYXgcDGsJme6asBpJqEQJmEmlegTK1GUq6cz5iaXQxR/3bWmiw0gntIWDbO+fPB7927NYsl/t9txZ0rjGAnN5L2zaf9u83viGI/kK/MTH7Yv7nKCkpsYQFXLN91XSFn5qioJ1HUczarLTg0GEJX4qMFtuUSfjDMZhmh70UNsMqDASMBHQlaJulKdywom2ZKYwcu2u3rrerULm9YSvcGKsH4G2KI17+Kgz7WlJKuM9f8guXrkex2maHuFdgIGTG7ZChlsAoaftdEuZlmjAx4yYCqXY7GoURCNuquoYSgGqkoOkJqEYK4CYCLRvRNmQsQvEtVv5KAOlQFBwKND2OQLIVJXsfg80L30PRd0vQPnwC2sIDUBLfAGYa4IoKxdCh6gnogQg6IpW2GZyuBKCaOpSMkDGthsA5c9Th0tjyjOV7p2qzENrtSC/y7YWXunwulWLZNFRGRO5raWvHlN336Hcqwm4T3HwierlNlrrCK5Q2kLtv9TJP8xqk9TScs8jHy28NsHUCVbegzUvF3f0e6WtzJ7f/IQCeQj4vAaugq0GyuAa36ZL828+MyV0GWTjoZRLgNheTzy/K4GfaWOimZd0lV4QzcX8GDRyIsrKyftc/Ak4Ts2i01I4e5Scg8iOnQFN6fwO5Tczk83PGYHBrnBJAyk6nIwAVOgxo3TL194rm59U/Aj3vI4XJmYjc6zaXY5zbvnA4LGGNwg2MGjuhR+fLt0wmVKR5AFG0QFcCCBhJOxKtjBxhVvjkNKAhbkYAACaYVXpmQmUGAkghZMbt+UArytCciiKkplER2IIUDyFhhhBkaQxKrcaawGgo4AgrCRQbzXhrzWSUFxvYrXIZGDjivCjLxcXA1Brr3IqKpFaENAuCQ0GaB8AYhwbd0Q5k/0MA7EVTWTBU6Lj7PXn84mUaKp7NLAEwZ2hvbe63JrhE4UImZgRBEARBEARBEARBEAVOv9Eg+nz+l4iWlGRMpJhjtQXoHQdsQrNGSOCXxpZnVhdUhJDoNHPLaBDJ+dfHGqHxtL1S0hirh2qmwcCRUsPdLovbuaffvp6swsv5eK2Ui1UhYerV12ZmC5ZugMYMqMxAhLcjzooRQMpeaWPchMp126zP7cxZNa0oD4pp2E4JRSQHxg1wpsJQNKTVEAJG0ooI8cVb+HaPn2Dq2EEArHvf1cpLY6weIb0DjJswFdXWZtKVYOZclgaL0FoR6s2y80AACPIEdCWA2poaLKu3TOE4U2jlpwu8ovEA2c+5+14uq1+CLW0p7LH75H63AiSvjpdGowCcmiBeTpZ76uTXL1qY2/G1lzq7rLHgtRLf07J4HdubEVlyOc0U2/pao8UdHczLZNPrfSE7Inc7jRZp/Rx6epmsdfUO8zLxk493/8/l7NzvOGLrcd/LWEMD2lpa+u0KuaxlGS0ttc3LutJ67OmYDejse4SmsBw9S0Zu00tjyx2a6XIZe9I/CvwcAW+tRp5XlEER4MSEYmlzQ8EutSN6lH93qI81QkcAEd5uR5BNqWHbZN8qYyZQTUazW7hqEBpPgKW5JVwdAIC4GmGxkMhoGa1uH4A91M/QESrHqLETsHnhe6jc7aCcZVyzeKGlTZ4ZNwpNJs1Mw2QK0mrYKjcLg8EEh4IATzqsFtI8CBUGNKTBwbKi0ZH2eW68zCzzGT98sWBBv+0ficKl3wiIvpj/OcIlA2wP/YoUnUDGbafaGzTG6mEypUd5yqHuga5fxt0x/8hHNT9XmUVYUDF4ESqWRsZ1VYAnbZMtHYFej2q2qH4Nxqybh02DJ8BgGoJGwnoZMtU2LQOsF7owL5OxXrLWi1s10/aLn0OxBmWm9d9UAlDNFIq/W4L1Y/ZB5eaMiZ0aQMleR/W4/KuXfIlgugOmolmDjIx6MAeDZqYwYtykLGFeX7RPomtEP9LfXvDydW3YuNFTEATAMSnv7Yn21vg36OtoVLn6SPd2N16mVuI/0CmM6YsQwTJe0S/F+d34+Uvympj6maP1Rd/kFmx1R/BE9D39tX8EvIXoXdHb4b57o9/Nt6+Un7V8+jfA240B4L1AKRDjYrk/NLnqiCoMACrTETCSiCtRjK8d2WX582XN4oVQzTQ+i++GcWWr7PDwQZ5wpJOjxDJwe6HRZIrtrsAqv4K0EoKOjJsDZtjXY0KBzjU0Ng3EhIpVYDARNBNbZTa3rH4JUiwMDpbxjWpFWw4hgTSsRccAUlm+nQAys93W9Of+kShcyMSMIAiCIAiCIAiCIAiiwOk3GkSy5Nbh5R4cqpkGtyNdFY6TX7/VcYFbTd+vXpbVL3Go36ZZxmSKcSjcBONmr5mZvb+oHSYHirQUitQ4WvRi1JqLoZg6koEodCVgO3sGOle1g0bCVs0V95lxjqARRyTVAmYaUIw0uKLCUIMw1KB9zuJ3/wq+50FIh0qwtqgWu9ZV9cq1CNZ98xl0NYiEVpxl3kHsGPTXFSCv68rV9nb2dtkdjSM/zZ5cpnC58vFyvC3+99aKrpfGoVxWt9mg22wvn4gtfqY13amT7uLWotjZ22F/o7/2j0D2tXmZjYrfQG6tmR2d7jxXfuNCL4f4Ar+8heNqEyoMqJbmS2b8WJRqxpAJe3b3UjxZ981niMQ3w1QC2FgyGkM2fwOuqNhUXmtr3ahMt++lyjuD2WhmCoppZFwSmJa2d2bcazurzmiDK9yw3Ro0KQOxKVmKoeFNtnuL3tTgEaaFJlehQkdNbW2Wuwti+9Kf+0eicOk3Ye5l5M65MVYPhRswYYV4NKEWzODT7yUlh/5uiMWALgY8cgj2DhZFsdkCzUzDUDREks2Ih8q2qpxvfZHE0OImKDCxqmkoGleZ+HzeeoyfMhxnHbQWLG4gHixFWg3bId+LU01gnCMRKLajTRhMs6NjgAMqdCjchKEEocASDplMBWcqUpplKx5OtULf5wiAKWgpGtLrwiEAWYOfQml/xI6J21xA7id29nCt3RmYd9U/djcfMaFyR+/qDdMRGXlSJkzYakVI+8x2WTjEGcsyK5HL5yfY8jtPX+DuD6l/JLYXucypRNj5nZXuPFddpe2OELyuthrfxFaDgSOMOAyotqBla/l8ySa0pcMoD7ZjTHwzAk1rwZo2Y4T+KVK1k9EWHYY0grbfI4NrMKBC5xpK0IyAmYRiGtDMFJhp2BHkNDNt+wRSzbS1MMlV2wxNNXV0aCXQoGNgqBkMHEVGC0aMm7TV1yTjdt0Qa2hALQmGCILoY8jEjCAIgiAIgiAIgiAIosDplyZmblYv+RImUzFy7K7buHQ7Fm7VabFS0h2V6a/q1wIAilg7hq5dACMQRqqoAgMm7d/t8lx+Xxum72Np8tz16/ft7UeffiDa23X80vw1is+7GYClolxXW22nWbXkK5RvaQRXVKQi5WiJDAYAS32Zp6Bww3JerSdhKqq1QmQkEEi2AaYBPWQ5ozTUIEwlgESgGAEjiWG7TO32dRA7P/1VRTjf6yKttt6J/uiOCNZbjp3dWkSCXGUUZXH3+4B3RDKx3339fe1km9jx6a/9I5DftVH/mK1NJZNv3SyqX4OQkoBq6jAUDQo3EU1uxqBdv9ejMi2NLUfYbMegb97Bv8+4H0bccih96D+uwytFp2P/yq8xfNxkT9Pjdd98hqbgYAyMr0Qg1Q5TCViOtNUAUloRUloEJlOtcaSRBGcMKTWCdh4FA4fGdKjQ7chmJbxpq5xSEzsv/bl/JAoX0iAiCIIgCIIgCIIgCIIocPqNBtH8BQtQUlICk6sOm93vvl0ABg5dCSCthgveqZtf6FI/Pl28BapiQGMGdJ5xDM0ZAoqOulVvw4hEoa1bgfDxF+d9/rcbanB64GkkKoYj1L4J6qbvsPTBZ7HiH2sAANG6CKY++Rs0lY7E6LrxOfNr+/hlpP/5GlInnYuOYBkUbiCcboNmJMFMA6lgFCk1DJOpiCY2QTVS0NJxpMKWlD+lFaEjWIriVDOG7rJ7XtdA9D/66wqQuK4F8+djytSpWfvlkOc7s/PV3kLW+umOFpFbw0f2/9Md587u+yF+u7WSZAfV+eTn1hJy5y//9/NJVOhto5Dpr/0j0HltX8z/HKXRYkfAjVhDAzi3ngEFZsFr0eUb4l5m7bfzsUkbCpUZMLmCIEsibLRDNXUktSI08QpUsM1djvUEbR+/jCebj0MwAEwZvgm6qSGqteOOJ1TUf/YtAKBuz11w37HzoSbbUXTAD33z2vD1x/gkuQd2L/oakUQT0oEIdDWEpFaEFAtbmkJII5rcDA4F8WAJtvBKKEKDiBlWmHuuYGLdsLzKT/Q/+nP/SBQu/cZJdVl8AyrMTQBTsDQGhMwOBIyk5ZRO0exoBPIEAOifg155UCObZQGdzkYNaKiPNUKBaZuaeQ1+9hpfga/rv8uo01qRHIJKCpXx1WDtzdDWr0bbrgdg8+KFqBq/W85yPfgPYGjlaJzZ/H8wqqqBl55ARyKF4roxWHfrGxj+fy2o2zQP7x50JUKxLxCdUITNX74PLR1H6R5H2Pm0f/h3JKODEG5eC+Oj/2DhE/Ow+9EnIYZxKNISKAuqUM00AKCNldnOCZORCKJGE0rTq5EMWCZmHVoJShObMHjXvbaqzomdm0ZJcNofEX2eEFQIlXt3/1cophR+0c5kB84iXVdmYm6hDePcyiOzP9bNtiWES7JDabscklBHnMerXPZEjjGHkMp9ne7fXuUQvwmiP5NCGC28HGu/nY+UGrY2qiEwlhGi8uxnub/2lY2xeqhmOstkyiGo5syOpgXAN5rt0F12x6b676AhjSBPQDPSMJmC9kAZdAQQYiloRgobv5qHgZP2y1mu9nkv4ImWE3FI3UqkeBApM4DKwGaM+Po13D90FdbccyHeWjIKr/99ETZUjEVZfB1avp3vWPxbs3ghNCOFcGILvtCm4ZNFwNqqqThVeQooG4JUcRGY5XwBCjPAOYOuBGEq1vi3SImj1YiCMY4A0gggBY2nAJCAqFBZ1uBtAk4QOzNkYkYQBEEQBEEQBEEQBFHg9BsNonDbenRUTAJnDGGzHQbTEA+UwIQCBaadrr9rDwkUmNDMFFYuXYS0ErK1hADYKyMA7FCjBtN8V9VLeBPAAV0JgjOGytaVCHZsAS8uAyLF0NJxPLV8XxyobMTuYwf6lumJ+9/FGzPewLeH/QwjkvVo+/EV2GwOQEuqCG1xDR2pShQPmoK6k8ZgzavvYOjg4WgfWA1oHJu++hAbIyNRmVgDrXgAIl+9D6OlBaHaOox49adYZkQxUNmCNfFBSGlBRLQEFJhIcw0hJQWDqzC4itKmFVDjrQiHoqicfGCmZNW+ZSYKg+p+3BfIeGm3yKZE/blPFAitGLdTatm0yk0ubR2vd0qsocFRp7GGhry0s2STsoZYzBG63r1fXIOcr6xp5HVu0cfL+YrfnLEsbSLSHCIKhRCPI6gksUUZjABSAAA1E4ZdBPMoBHPcFUu/AVeC6FBK8G1sFTSkO7Wo0NkHKTBhMgUG16AyHQzML0sozITG09DMNBRuIK2GoMCECgMMJtazYSgtaoH/6BH4uv47VC/+Aj+eUop1GIsI60DNpi+gblgN3tYCGAaqNizA+OFDsGLvaqxMcPAiBs4ZltcvhmamEG1bh+ayCViTGoB2M4CBgQ5cOvlzaKl2fFN2JAyuIm2oqFBbEGRJKNyEaqZth9pBI4EliTGYHFqEhBoteJcVhMWYGnpPEv2PPtcgWr16Nc444wwMGDAARUVFmDp1Kj777DN7P+ccN910E6qqqhCJRHDwwQfj66+/7vZ59GAxwslmBNMd0IwUVK5D4QY0ngbPqNmLl7r49DdiDQ1YElsB1dShch2cKXYUBsZNqFwHA4fJFDDOUVtTg+raOoyuG29PBBpj9WiM1duThM+XbEIk1QIASCGEksRmqEYKphZEuqQSZqQEwdaNOK/tTnSkw/jvt82+5Tv78ungex6ETYkSbIyMxCZzIHRTQ1moHSPLmjGspBXNeikGX3stqn40A1CssgsGdSxHPFiK1qLBSO2yN9TSUqRHjkXV8nlImQEUG83YRfsWw9TVUGGAg2GosQrDWpdiSGoFitCGRPFAbBi+uyQcIgqZ5fWLsXrJl/hu6Vfb5fzbqn+sqbaEoOI5F0KC2poa1NTW2v1Bf8dtYuz2wwM4hSLCDE/UkcDP1EQIY9znZJx7Cp7c6eS8hcBGfnfV1NY6TL9E+YUwye1rSPYZIgut5G8vwVghtAWia0Rb3F4muNuqfwQAQ1GhwEQI1uKSLQCBmuUPrL8+HyuWfgOTqTChQEMaGixTfZOr0HkAOg/AgAYTCnQEUFtTg3G1o+y+qSEWw7L6JVhWv8TO87tvFyDIkoikW8EZQ0IrBgfLmHGZCJoJDObfoaF1OJbXL/Yt2/DWb/DmxOsQ7NiCIS1LMWTzN1DbmsBLyoGqMdDGToDW3oQp6gKcc9hGJHUNrUYJ4rwILSjHBjYUS4v3RAApjCleg7EVa1EaaMdnbF8wQ0e52oQxxhLsP6EExWYLwno7IulWJJUibGaDYTIFKTWMuuhKDNtlKgmHCKxe8iXWLF6I9Yvnb++iEESv06cCoi1btuCAAw5AIBDA66+/jkWLFuGuu+5CeXm5neaOO+7A3Xffjfvvvx+ffPIJhg4diiOOOAKtra19WTSCIIjtCvWPBEEQ3lD/SBAEQRDbhz41Mbv99tsxcuRIPPLII/a2MWPG2L8557jnnnvwy1/+EieddBIA4LHHHsOQIUMwd+5cnH/++XmfiysaVD0Jxk2AMZiKCoNpMJlqO2yW1WT7G7GGBiTMCMJKHIqZUYtmSkY1WrHNy9IIQuEmmGR2J5DNFkyuYklsBUpUjiZ1KOJmBGEk0BIagEC6HSo3YaohmJEQWEiHOjqMyW9ch1RTK/CrP2fl3bTg3zjDXIZvy2eggrdDhYEKdQsUJaMhxICAmbScB25aAbNsIFIlg2AoQeiBIFJqGAlWBCMTSS0SboVWPQGBFYthDhqOUUYMJQvewn2hX2DaxFa0pcLYk38EUw1knAsqSLII9HAAnFxv9SvqY41gLH8NmFhDAwJGEgPXfIHiAaMtE8u4v+ZbX7Et+8fGhgaUlJRkOVEWGgK1BWBKFGtosJ08u7VmZHMwWTtHRvSPos5Eulrh2BpwOKr2cgQtRzZzl03kI/bJzqjdTsbt8zOn6Yuc1u2cWo7KJpdTvlbZQTfRP5Dbc759pFsbbXuwLftHK7/s62WcQ4Hpua+/sax+CQw1BDMzxhJjRMY4GAwoMKBwEwo3oCsBwKObEP2ccGDNwYBACUJ6B1JaBAAQ1tvREbAiPSkw7WAyk0OL8GLD7jgAazGpbqgj301ffYj26DD88+U2HLm3iWDbJnBVRWvVBJhKZpzPFCS0YnTwYqxsGYCycMIa/3KGqNKKAE9ChQ4tmUIiUIwkC2PJ5sEYWtKOpQP2x9L1lZjx1SNYx1SUxzdjddmuaDajCBo6StUWMIND5TpSLNyHd4HYHiyrXwLOlLy1wtYsXoh1ShWCykCEWAIdAaPrgwhiJ6NPZ8ovvfQS9tprL5x88skYPHgwdt99d/zxj3+09zc2NmLt2rU48sgj7W2hUAjTp0/Hhx9+6JlnMplES0uL4wMAphaEEQjDUIPgUKCYBkJ6h2VqBcX6cIb6WGO3r2PVkq+wYuk32LzwvW4fu61I8yCCLJUZ+Cu2eZn1EQrTCjRmqQznEpJwxsBg2irGY2tHo1htQ5An0GZGsTE6Bnqw2BpAchOMG1A7mhHcdRKiUyah47FfYcPXH2PD1x/beRpaEOmKoQgpKZSrTQAAE1Y5NdMyCTSZCs1IQi8dhET5MHREKpHSwpZJXCbcqMJMhFgCWjoOPRTF2ikzsG74HvjamIiv97wAxz5xBCa/dycmBr9BIlQGk6noCFcgHixBiMexITUAsVaKNtFfWBJbYbdl2bRn9ZIvsWHRf7F54XtYteQr3P0ix6L6NViwdAMGNC9DUbIJm6p2Q1qLwFACMNVt745tW/aPgNNcSv4vC0W2hu5G69qW+IWPF/8FfsIhGXmS7Q4JLybhnLGsaGhuwY9sjibMwdz3QpiFCUGP2M9Ztk8U2VxMPr62psYhsLKFgpny+AnCiJ0f2Vwxl+BPCC/dbVK0y+0hLOqL/hHw7yMZs/w06ghkxkBWfZlMAWcMCjcc5p35smLpN4g1NODL+nUO06sdCUc0MphQmGH7CLKEQtYHAEym5mxLtTU1tnmeCQUGNHSopUgoxUgrIdvtAWC1y6RWhPZgGbYEBmN8VRx/fiOK2U+k8WX9OqxY+g0AIJBqx79WTcD+3yuFESkB1wIwtRBSgSK0hSrQEhiANq0czWYZNiVLEdZ0RLQkNGbABEMHL0YTs9J0BEvRrpQibobxvfJFGKM0YpixEkerr+PHn56O0rXf4m/NRyCEBAYFN6FcbUKApzoXnHP4WiJ2LpbXL0ZjrB5pFoIB1fEcrFy6CMvrF2NpbDm+rv8O6xd9iqWx5aiPNSIeiGIw/w5l5iaEzLj9bBBEf6JPBUQNDQ34/e9/j7Fjx+If//gHLrjgAlx66aV4/PHHAQBr164FAAwZMsRx3JAhQ+x9bubMmYOysjL7M3LkyL68BIIgiD6B+keCIAhv+qJ/BKiPJAiCIIiuYJz3nT55MBjEXnvt5VjNufTSS/HJJ59g3rx5+PDDD3HAAQdgzZo1GDasU6vjvPPOw8qVK/HGG29k5ZlMJpFMJu3/LS0tGDlyJJb/5yWEBlYBsFY4dDWYWekwoStBAJ2raCrXETCSCBgJDNr1e77lb4zVI2AkEEq3w8jkl9CKoXIdmpmCYhowFRXDx03e6rraWuTVe9XUJfMy65rFapjCLefNhqLlVDd3rzIDlilPkd4KzUghmGqDoVn1qhhpewVdNVIItGwEa2vCd39/HcOOOABGSwuUsbugfXAdDDWIRCCKOCuGhjQCPIWAkQRnDAE9iUC6HelAsaUCrBRZ1wOrvk2mWo62uQkGDtXUkdSKkGBFGBBfhUjrOrSVW4M9QwkgrYYQ1ON2NDvGOFqNEmxJRHHI5Ejv3gCi17FV1CUYuEMNONbQAM1Mg4NhTN04e/umrz7EitA4DMR6JJRi6/5nngENaSuSHzegmtbvePNmjP3ewWhubkZpaek2ub5t2T/OX7AApdFoVpQqWTPFvb0r5IhYXuZK7ohb2xu3dpCXFpGsadNdR7SypoXbtMuN21zNXRb5vshll++f170T/bC8zctsTuyXTdLceRI7Nu6oo15RSOV77L6nbk0Y0ba8TDBbW1sxdffdd/r+EfDvIxfMn49oaSlM3qklosAAhwIGE4xxyzw/M/4wmdqlSYqtwcWZZarGWMbZswYOhgBLY3zt9hdQWZEMrQAmAOwxI+OmYywpTO1UGNARwNja0b55useQ9bFG8IzzayZrI0GYx5q2JrnJVDw+bzQWf7UOe+47HIMqGCYN24RitQPDmhZBTcVhBCPYVF6LFEJI8wA4GNp1y/wrpKYtszDOoSOAJLeipinM0qW3HGRzqNDtc65ODkNYTaEisMUO9JJWQvazoJo6AMt1A+OmY7xB7HgIszHR1kQ7G1033k7TGKu3NAbBEOQJ+56uXvIlTKZiIwYjqrRDhe5oB5ZlCrMtNZrb2rH71KnbtH8kiL6mT+0qhg0bhl133dWxbcKECfjb3/4GABg61LIzXrt2reMFv379+qxVIUEoFEIoFMraroeKEcl04AEzDiAKADAVFYphQFeCMGGptircsCISaBGsXLrI7kBGjJvkyFM1rbCcnKkwMnbOJhQEuAHFNMCZAl0JYuNX82CoQQyZsGcPaql3kCcBJrNsyGVfFCa3Xvw6C0CFbquO+03evCYIdbXVWLH0GzSpAzFUj4GZBsAYdC2MRLAEKTUMg2tIlEyBCYboL49CvG0FmGlANVJIBqPoUEuhQwPnDCqzJujy5DIdKEZzaBBSPAiTKwiyFALcQMBIIqVFoCtBaGYK4CYMRUOaBREx26BwA4mSwYh0bETpnt+3y7ysfgkMWIOxsNGOAUigqCiOb2NWfaTMIFrSxVCZgUHBTairpZD3OwL1sUZo3LTFQ/IgUo50EjLTSGpFWe01ESzB8PQypLUQgjxhb5dVxC1BaQCMm7Z/hG3JtuwfxaTPLXQQE0I57DlnzO4bck0wRd/hZb7i9psj+7/ZnnhFMPMyG5FDwueLyEf28yOf020mZiVinmlEndmCnxznlcPUy2WvzZTH7YPGS/gPZEdgk/0ldbcuiL5F+KyShbPiuXVHsvPzeSVS1UjtROQp2sn29EPUF/0j4N9HGgiAc5bxvSMLhaxxJbj1zjAVa/zCodhCDwbTc+wg/PkAsPz4mAY0pO1FOp0HsCS2AmGzHaPGTsi7bnob2f+kbarKAUjCIQC2kMuEAgVGTmGye3tdbTViDQ0wuIoALBMzBsusT+U6gnocAT0OxdShGGlcOnk14ntXQOEbYDIVaSWEstbvoCXaoEdKkQyVIo2gvfjDwVCkJhFQ0gjAWng0mQqwAHSuIsA4VBi2u4Uw4pkQ9gHEeRGGh76DyRRoZtoWIoiobmlmCYpUGAgYCaimjm9jq6AhjTSCCCMOABTZbAdh5dJFSClRKDDAFMUWbIpnVmBm2s8utSMcx5c2r0Rj+V6oYJutBfeMMAiwxqAczPZ7ZW0jv31E/6NPTcwOOOAALF7sDFu5ZMkSjB5trTpUV1dj6NCheOutt+z9qVQK7777Lvbff/++LBpBEMR2hfpHgiAIb6h/JAiCIIjtQ59qEP30pz/F/vvvj1tvvRWnnHIK/vvf/+IPf/gD/vCHPwAAGGO4/PLLceutt2Ls2LEYO3Ysbr31VhQVFeG0007r1rk6AmUIBCMIGEkYatB2gqfpKSimDl0NgTMFHYFSmEyFAQ0qdCjcQIAnMXzcZHulNZJuhamoCOuWGnJKC0NXghlVWwUJpRhQihEyO6BwA/FQmX2+7Yl7hdfWKMo46TagIsw7rG1M7dGKsK4EUa5vBBiDlo7DVAK2FF0z04BiOXtUwWFAQ1N0OEymWJpFZhgwARMMESWR0R6yFH5NRUWHVoIUD6FdL4LBGRQAwYDlwFqocsrl2MIrARMYZjRBS7UjuHEVVtYdDreCp8Kse5NWQ1BNHUVGxillRk08Gmr1rD9i22OtMGoIwIChaJ3RmTLq7gydZpIKN5BWw54rmCuM0RitLoPBNNskAIBLZV4BuAnOVJhQs/Loa7Zl/yhr+dhaBpJmgd9KsLxN1gRyaNy4tGD8tIm2t+mSX/8om8rJ/3t6Di9zMAAO7SFZO0sgNEBkTS7ZTE84Ehb1LUcxkzWDZO0SGVkjSUbe5rhXrmshdgzcWmhyRDovrTivZ86tWcSlNmUfKz3P1dvhud2W/SMAaEhBhaVZlETAeiNI7w5H/8YAk1tGSgoM1NVWW9rKigbV1KGzAADAhAaNpZ3PuTBf4yY0lobOA0goxfg2tipLk2Fb4zZZFGVlnNtj3CQiCCCVlT4fbNNW07QDqFjmd9YYkCsqDKZYLh2UzLubm4gkW1BspKHoSejhKNqKhyChFVvjAJgAAzToCKMDAT1pRSZVNKTVEAyuwuRKJihKp4kcAKhch4EAgiyJVrMUpazJYdY+auwENMbqoUKHCQVpBAEVSKtAENb8YELtcNKw3IFYXr8YKaUYAaSsNpt59ITWHtA5RlFgWhYJLjZWjkMJWhAwrHusK0Fb+9wdDVseXxJEf6JPBUR77703nn/+eVxzzTX41a9+herqatxzzz04/fTT7TRXXXUV4vE4LrroImzZsgX77LMP3nzzTZSUlHT7fBwMKTUMzUwjkmyxQpwzNfOi4QBMhIwOpFTLnETYIQsfQpwxlCQ2w1SsKA2mYk0ak5rlC0e2TWfgMJQAAoZlvqIZKSyvX+ywb93e2P5BoHS+SDMw5DYx84MzhsWpsZiCz2CoQcunk56CEjRsny5cZUhx68WcYiEo3IRhxcOwz53mAUQAW1UzySJI8wDS3GqSGjMz32lbxbk42WR38K1aOUoUS7DDDQYwBUgmEE1vAdBpFz+mbhyWxpZ3XjfjtlmREDTQi33HYGlsOQJchwpLpZ/ZA2nLnNNQNEuwa+rWC9lHKLu8fjEGBsMIJOJQFStqnzAhs44zrfYiRZ7YHpFJtnn/mKe5iF+/IAb3XoIHPx9EcmStHU0N2z0ZctNT8xpRF8JkRyDqTvTLwixMFu7Ivon8fBc5zEAAx7lkIZGXoCmXgM4WxvpEeCO2P7JJqF9kMiFozIVD4AgAUl6xhgZbOCTSfrFgQa9dQ75s6/5RxopmZpmSKZmxiMoNe7EJsPwTAUDQtMaADByamUaCFVmmWGCWj5vM+0p+x4hFNdW03ncdiEJlxg4laHAvBHCm2GMmwLrexlh9t8yqRL9nKJYALaR32HkzzpHSInY71AxrcTCthWCGyjLbkpaJXybKnBgraBn/UGKyL8qYMDvf+wYUdJgRhJUkVKZDM1KIqxlXFJkFInkRUlBdW2eVm3H4yQF2lHtWyAifQzoL29uEUEj41OqMxKdA5wEEkLKfRcGaxQsRAtCiVUJRDDsfOU8BA7fbLkH0N/o8tvOxxx6LY4891nc/Yww33XQTbrrppr4uCkEQxA4F9Y8EQRDeUP9IEARBENuePhcQbStkJ2KGoiEdKAYTGgacQ+FpJINRBPQkOBiqx9VlopQlbQ2TAe2roWsRKKYBXQsgpYYzqyaW1FmB6fCIbzANKTUChRv2/8ZYPYAdx1ldjWsFW4e1cqPC6NGqR21NDWoBfF1fizJzk62CmVYs1WyV65baJtNhQIXOtSz1S6HyKyttmBktJwBQmAk1s1KXNMPoYMWo5OthKBpSWgStKEOaazChQGM6om1rwd9/E22Hn4xhu0zFsvolAGBHJBhbOxrfxlYhwFJg3LpPGk85nMwR2x8VOlLS6k+Sh8DAEUWLFW0sc7/EKp/CDM/nbKM5CKVqKww1iKG77A4AWPvtfKTVkB3ZUJirea0Y9le8Vrnk6Fd+5kRuczIvjSBZi0hoxLhXoHfkVVa5rMLEqqergu6IcIAUzcjDSbb7XPJ/oekha454OdWW61Y2G2Sc+zoq9iuvV17E9setkeaOTOfWLvNrv1732q2R5G6PhaBJJl+zMKECs8ZKCjdgMC1jqqRibM1ofPftAgCWhnmsoQFpVgzAMj1yuxyQx6eO7ZkoSxHWAR0BGNC6rZXTl8h9QWOsHiZTbcfMALodgU3kJxwF84w2vxWl1nq3c8WqJ/G+BgCoVtAYgTB5S7Og5YiYc9t5MBgss3Gmooi1W+dROtuvBh0mV5FSwwAH0gjC4CpKlBa73t3m0LYzbaZ3OjzO8YwR2x5bKy+jVVacbAIANIcGWaZhlr2Cw0SMM4bRtU6rjxatEgBQZLbajuOtoClpgCl2pD/OmR3ZkCD6I30a5n5b0NLSgrKyMnz1+X9RXFJmb1czkSeCehzFLWvQVGFFmLAjGwCIxDdDD0SQ1iIwFRUpNWI//CZXwWBChZHlwwSA7cdEJqxbLyNNT6A9XLlDmZsJRDhTYOuFWItjKwEAYd5hq/YaTEMTBsAEg8FVpM3MZB6AYUcSsMKlDgxtsfPSuYaEaQmZ0qZqR11LmypSuoqR0Q2OgVdRqgXBpOVLqK14MDhTMHKsFfGkPtZovwTkl7wc4UU1dQQz5oFV43fbqnogeg954mtCgZGRYUfMNgCdA2oRHld+xr6sXwcASJkBFKlxFJst9j1Oq51Ra4SQCLBU3TnYdgnjvC0Q/WNzczM2btgAINu3jRt54ukOg+43IHb72xFpvUKo7ygRzfzoTb877jD27nryEiaJ9G6zPT9zIq/Q9n7mae5y+fWPJBjaMZEnrrIg0esZ9bqXTpOhbLNQkd6dd2tra78N4yz6yIWff4aSEsvkSEw2xRivxSxFVGlDXW21/ZzEzSJozDIfU2BCQ9ohGPITCsn5yjBYIdl1aDu0X5ve7B+XxFZAZTqUjMk/AITT1ru+I1jmqKeAaY3/FNNKZyoq4mrUjiIHwBFlTDNTVqRdAK2RQUjCWnwS90sIDcQ5xtWOss8lBAJyKHt338oZy/hPMnfI+1SoiPYpxo4a0jAzZmDingkMaA4h5+LYSnusGdI70BQcbOUh+RGzo0Pzzsh+ba0tmLL7Hv2yfyQKF1KfIAiCIAiCIAiCIAiCKHD6jYCIuy4lpYZhMhVpNQQ9WIxQuh3Rjo22ORgDR1vxYLSFByARiCKhFUNHwFIb5NxaDcqsMgizFpOpMJQADCVg/+dMsT+6EoCuBBDPONRriMVsk7MdhZraWqhm2qGuu7UYzHIcbDIVbawMHUYIcT2EqNqOqBYH5wwGZ0joASSNAFqSIbSmgljZPrjz0zYA69pKsK6tBC3JCDrSQXSkgzBNhpCWcfLIrHtRktiI0u8WoaNoILaUjkJKjdgmboClMpziIdsBooAzBoN3OqyrGr8baQ/tYNTU1tofjaehQofG0vbzBlgrgCrXoZpp25wQAFrTRWhNF6FC3YIyfRNCeofl2FrptKSVtYcEhRCBoqGx0f4ta/YIR7Xyx8tERTZVAqz7JNLZ0bcy5mW1NTVZJmfiXG7TFS/tme2NaH+9gbh2UV9imxxRTiDqGJBWKaVj5PqWj5HvpYCzTuf7ftfi1hIS6chsYsdFvmeiTcj3TXYML7czGbkNyc+6O627rfV3xPjCZKqlqZLRaEkhBDXjqHppbLltpl/E2hFEEiEeR4AnbRMneWxo522POplvQARLo8XSWhf9wo7aP5q9NHVg4DC5Vd8mUxHU4zCZilCiGToCSCNom7MZTLPHmqqpI6AnUZxuRjS9BcXpZkSMNqQQQkItRloNQTF1+z5yMARYynIzkNEaSvIQFGbNB4TWiIxb+6u2pqbTyXHm+utqq0l7aAdDvL/H1o6GhnQm4q2ZaQum5SqEdUYxk9/BEbPNnje2hSpgxb4zwTmzo+BxzmzzMsYy/e12CHJCEH1NvxEQqTyNkG6FnQ8aiczgyERQT9gRq5KhEqTVMFJqGB2BUiTUYugsAAOqbVLmDmEoY738Ffsjtrlf+pqRQoqF7UnsjoYQcm0tAaRsW/2EVgyDaVbUAFOFyjiKjWaozEB5sLXT1IyZiAR0BFQTusmgmwwJXUVTRwDNcQ26qUBhHJpiIqAaCGtpRLQ04mbYEjRBRVt4AJBM2GFOdQQck3yTKygxtmSVt7amxlYD3xHN/whvOm3+O806hdmnrAI+NLgepYF2aGYKnDHoarBzsJ55RsWgXwzgxX/VJyJaf0OePLq3ybgjkIl0AiEQcgs0hJCpprbWNiWTVfNFnjvixKcvkH0HidDkcnhyQW1NjS1Ecgvm5N9eE35ZCCfvF+fximiVyx8RTXh2Lrz8WwnfVvI28V8IceW0AOxnVrQXkc5P0NTfMJkVxlxHAKPrxmN03XjbTCXMEtbEMmP43DnhzEQ5khYK85ks5lqUYOCZaemOOzzPNU7uDip0x/hZV4Mobl8HxUxbkW+5NW7kjGUWewIwFA2motpRhhVuQDOSCOhJGFxFgkcQV6JIBqJIBYqRChQ76ltl1jkNbvkXVaFnLxr5XF91bZ3VRzNOZrg7OGJxXggEZYEf49xWKhDvu6Wx5UgqRfaCIueWwJZJ0Z9l8zSC6O/suG8ggiAIgiAIgiAIgiAIYpvQb5xUL/nkPxisJJEMl8NUVMcqjq4GLe2WzOqOWJlxeLOXJMOMea/UAiLaVub4jGRZ5KOZnU4KFW5ANS1H2SKSUn9h1ZKvAADrMQxhxYpiFmZxAEA7jyJlBlCpbgYAFKWakdSKAACbMRAhJYUibqnzrjeGAABShgYlo8KtMg5N0e3/ESXhcBDHwKGaaYTT7QimrHzaiwYgoRXb9W0omufqzoql38BkqkPrhNixeX9ROyqCLYgwy1xQrNqK6HkpLdKpVQTxHKaQVkL2ihHjpv1bM1P2aqFQF0+pYbS2tmG3Pfbsd04GRf+4YP58REtLPR1FC40fWatHNl2SzcXc34C/g1y3k2p5v3zcju60uqe4Hf16XbsXou+SI0u574XAfS/k/P3uRX+t70JEOK32chAv6MrJvNtBtTs6Wm1NjcPZfX/qH4HOPvKT+YugFQ9EsdLh0BqwzVG46dA0cZuQ5aKnEa8MaFCY0e+0VZbEVsCEgghvh64E7HexCHaiGSkYioa4WgIA0KEhbQbQYYRQHmgFAISQsNwlcB2Mc3RoJdiiVyCgpFGitjrul+x0nDMGnYtovtaYMWy0I6EWO8pYV1vt+N8Qi8GEkrWd2LFZsfQb6EowS2svjSDSPACN6QjxuO3CwIBmtwsZt4Nr2a1Je1tTv3XiTxQu/SbMfVoNoTk60O4EZNMSA5bpkwKj06Y087CbyKiwyi943um13u2x3oQsfFKsiAjcAGPcac7CGCKZaAxLY8sxtnb0tqmIPqT10zdgKhqC4XIM3nUvjIDl9V+Bic16JRjjiCgJlKhJfN08BqWhJMYrzQjpHSjZEMPgLeuhDx2NtrIRaA+WQTEzQiAtiXK1CWG9HZqRQodWaoc7V5nVUQszMoUZCHIdmh6Hqah2RAuFm50h0rlV54AVwUBQnQlZSezYrFryFUJ6Bwbt+j0MDm1Cu1mEIMuo/SrW82woAZS1fwddDdr+p8J6u2UmoEjhcWGFvGXgMJmClBq21MrNdGdYVK5D46ltf6HbGHkiKZt51XqYgYnfIq34dvSJPZj0eAlG+oufE3d0HzHZ9hKqufcDnXXvjiLnJtckXw5TLvuWESHQRfnckdR21IhJhDfuMNwy7nYlcAt4xTZ5e6yhwdEfAFa7bmnL9tHS31CRRlRpswVC8rPkNkFyC4fkaFi9gR01N+P/ZHn94p3eLF7u18bVdrbd+lgjUgghiKQVeh7Wos2QDV+jJBBBOliMDZFRWNVagY2tAUytSqICGxFOtyGlRQBY5oEBnkJUa7fuRcYdAVMU2+ekgHOWMW2zFnsNqGhTyxHmHZnyWZFSl9cvRpoF7VDmNVsZ9ZfYNqxa8hUMJWA/L5xZ8zThlkA8y00oB2C5vRBmnYBzzmC6/FDJSgUMUsRCMj0j+iFkYkYQBEEQBEEQBEEQBFHg9BsBkYlMhLFMpAOhyWOZhGVWvDNe6E0otvaQcAbodjbNOXNoD4nVBq9VIp7JTzix5ozB5CqSWhE4YwjyhKej0J2FTV99iE1ffYiO4kGIFw1AMlCElUsXAQDG147E2NrRSJkakkYAq9oHoildho6kgsXfFaMBYy1nwIl2IBCEtuk7qEYKaW5FplCYCYWZGa0QS0vEdioHK+qYwTX7PjHOoStBJEJl0LUITEVFSesa6R5b3xrS0JBGdW2d/SF2DkJ6B4KJFiyrX4KI2QYVJoyM5p5oDxwMlbsdhKQSsY/TlQBSagQ6C2Q5WLadynPrGRV9hR2dkG290/YdHbcJmRxdTCAc1bqRHSQLp7VemggiDyB/zSDZMe7OiIjG5nW9NbW1tuNnORKZOE7Ut9gncP/OJ8KUrPHljjYn169be0ikI3Y+3OZlsnNqtzNqsV+0Obc2m+y8XtaeAYCa6v5vVqNkIohZDqhNe0QokB1RA3COF7vQHuqpk2+hsZBmwR4dv6OwvH6xFbSF69DMNFYs/cbeV1dbbQc7CevtCOvtCBoJaN81QjFSCMW3QIOOhK6iskQHY9x2JyDqXTV1BPU4AkhBhdEZYYqzTu0R4Vg8M5pUoUNhlhZIkdlqmapl0ppMRZJFEOAp1NbU0PhxJ8JQAvbzsqx+CTgYVMn9h3iudx87ELuPHYgSYwsYt5596/nv1AwS/WRXHwWmZ1kIYmem3wiIdEVDGkEkWBESrAgphKAj4DAhM6FA5wHosD4GLNMTFQY0pK0XS0Y4YUCDya3oZsKszD0YkAcQlqqqfIwlTEqqRZbPFDOJxbGV26dytpLW8EC0hgciEYgCADqUEowcu2tWurCaQkW4A8ubSvDhpx04etRXGBLcgHigBGYkihV/+TvM71YhlGhCEEkElTQ0ZkBlJnRoli+YcCUSrAjthvXRuQada3ZdpxBCnBWjXStDe6gciVAZUqFSlCQ2WiZoMKEy3RLUUejJnY61385HINWBjqKBSLAitLAKpLmW9QJWuY4Ni/6LkBmHAQ1JhNHMKtHBi61nm1vPogHNjkTDOLee5Yz6uc6sgYSuBKAr/cbaNi9kEzN5oCMLOvyimLmjJrlN0YTvHfkjn8d9Tnd5djbckZ78rkNEMpMRaUVUOMBbOCQm77kiy3kJjES+4jhZ2FQIkan6I7JvK/lZk4U7QnAkTNHcz5m73Yh2Io4R+dj7Gxu35SVuF9SMfzv5I8xR5EiY8kKg+NghsD0Et17Iab2O6Yy62RmWe2ftHwEgxcL2NSVZBKNc5v41tbW2eXhQjyOcbkP9pFOwunI3rK7cDSGzAyWhNL7brMHgChJaMTqCZfZ9EXcmZMYRNtsRMJIIGgmEzDgCRgKamYJmpmwhlcr1zP3l0JBGXIkioRQjxcJIM8tkPcTjO71ZXyHSijLosBb8GDiKUi3QMi4FOJi9MLg0thxLY8sRV0vAwBE04ggali9V8fyLduLoE6SeoHM7CYiI/ke/ERARBEEQBEEQBEEQBEEQPaPfLJtzLmkK8YzzaJZZfclIey3NIDUrYplQMzV5p4aQ+Lg93zvO6YqeJGusMHA7AoVmpMCZAlPZeeVxhqKBc4Yg4hjc1oBPFpcgoKQRURIAAN2sRIppaE+HYJgMX3+0GEsP3hWtySDWN6v4/qgUhh+8J7hugJmGrc4LACZXkORBcMagMgPtRhGMzP0U0cw0ZjmOM3gIJlf+P3v/HmRHct/3gp/MrMd5dKPxBgbDmSHQwAxnRNKUSJGW/CBtSZRk2bKtvev1pa7W3pBt7ephc2WvwrqKvXcc4SAj5Aia1+KV/FxLtqwrx421ZflayxAlXVHWHVEkhxyRw8EA6AZmBpgXBs9+nXOqKjP3j6ysk6e6zukGBo8GUN+Ijj6nTj2zsrIyf/n9fn/OWM4aMtVBWENkMnp6hYviIXapFcDN0p1bXmrpwfcQpNEMOrtZifdhrERbhRSmNJl3/zdMl8dPPMozJ1c5IK8wtKWxpYmRwqCE3vT8mqB9sLW4uLXj9uN+RlMGLI/QuDiUnoXrTJOeNWU0a8qA5pfXMyyFTKJZ5rs7Gctnz0JwLU0sjEVvFB1IeUIT6xA3koUKNhtP1+GlRZ490mYyuzfh609TVruwDobwy5swS6b4IDPMKra4kJuMaqt1btKYtolhFGZpnTg+kyzNe7U/YxHkImVgumCpJGaFTCiI6ekVUsostYXLULoQX6FTZqpNB1fpdh/lsQM+WYwEEVXJJYxQE5mDoWRpISYMxesQ2MqEutovABFWlsw67D1Z5g8qBJaEMsut6NARrg5Jq9FlspOkGLBn4xWGnT2M4t4mE/pqX9YgYCLpSfhbixb3M+6bAJEQTiYmsBQiqqRjCkcnHb8oErRQVQAC3ODRS9CMldV/IdxwUonNbvVCjHWnTYGk8LuWEcoUdBjcxhK4fainhX9x+QIP6QusiL1cyRbIjeLh7psAHIwtS68vsveh/fzTX7rI3/ihw3ws/v/C6yDL9I+Xdx91QR1ZYKyjZuOzTmDZpVacPNBKJIaYjLgYkqsOHQbkIiGzCTkxSmiKOCY1AyKdcVC+zhVzkIuDBQAe7b15z3aqHjScXn6FXtTB+KxjZWetK4dBVheLtopnT19BCsWlbA8AuXHP81w8ZKA7dNVwYt8KTVF6WcVlsNEFj82mgNH9inqgJpQvuY6wQ1MGpK2CFD744KUt0wJL9QFoPRByLwaHgInzrgdq/LX6TGFnl5fHAaRgHY96sC0M7iyWQZ169jNf9nUvp/Ceh/elLum7V8v9QUNYT5bPnkWwOfDr68qsjIT157Se3ax+rAcBWigKuX0vuomMRtYyYy6xwqzgULUOYtN9u9fx+OKjE99fWrpW9Yu7duR8JYWbGOzrtwA48JX/jeKdT6LjLtd3PcJoqNjT2WCXdBOAAouWMcaqagLYZ7KVpQ9RCGGtm5j0A3shwZa9DOGzm00O+g0SFWSrarGz8fLSKQy7iUzGK2dOkgjJKOpVAR4jFMcWF3njxa8y7OxxHrHFYDIAJKnagciUfUWrnZyxlKlZIRABQeBBaytbPBh4MEZGLVq0aNGiRYsWLVq0aNGiRYsWLabivmEQAWX2MFllKZDCmdB59pBGUdgIzThaHFJ5Q4mYwbFaZMkgCjNrefNAxCR7qElq5s5rnPniXsaZ5ZcdRZiEgZrnvy4fAWDvLsN8souOHJGIEd/86HX+L/+dM7Vc///8FGs9Z/q368/+Wfd//U3WevurbBMSQyqcubSP2CNAi6jKbmGFJNEDcpmihaqMG6HMYCciUK7sFZo96TqDIiW2o22X/bnlJSyilV7cBSyfPYsmpZAJyhbEZAhh0UIRkWNQnFh8jGdPX+Hc1d08NL+BFAZj3b31ssPCuCbNSFk9swCIcsY3mFQUvg5ZA/d5FoppM1zTpCShsbH/Hu6nzngJGSz1I9XZCXVz6vA3z7K5F9HEvPJsDn9NdbnPdu9LaGbtZi83s7HqcrWwbKdJ2O5l1taDhIoZVnte6iwzjzC7Wfh5KyP1kFnU9Lzezwiz1vq+RdN1N7GtbhZblWv92b2XZS1Ly+eIbGkVUCaF2DW4iFYJg3ieRIycUXXqkqF88V0f58xrCaPM8vgjmj2dIV01RBOhKMZMK+H7AIrMJggskRBE5NWxfZZhhNu2Wl4yQvw4AVzCGVH2B4SwE2qDWTi3vFR9bhnrdxZesiiAAkWuUgrrWEBGuDFhwojYjHj19NfZffVlVva8s9rej918vTTVPc8n17EGK9S4PuHqSJsQp8X9iPsmQGTK9Nf+QVcUYHFSJeFCRtqqUkJWpsYUppKxVEEeYStKqR90+oATOBqyX16XltWDTQJbNTRaRlO17DsNr7/4XNVQvuPxd3Ny+dXylwiD4JXre3lyzwWOHRqhrcAYwZXhHDDnGk4LnVdfBCB+yr0o1d69bBx2n7O4T2RyuqwCruzTUmtupWKls5/CxuN7Yg2FTKoMAokYbfKScR5J7mW/S1/Byn2kSbZJHhcilGMcW1zk6OJxls+e5czyy5xYfOztF2SLbeF///oAeIiHepcZiD4dMdjUwfrSqWv83jfWkSLl6J5rgPOnslZUQaLCSjYKl97UeYuZymMgQmOtILcRuYhQGCIfaMRiuf89iDzqgYNZA50m2RJslrXAdA+UMGtWKG3zcqvwPO4VqnZTMMgHfsIy8wPxSs4zJeDml4VlUM9gFt6HWRLA+m9V4G7KvmZdo99fGES6l4N49yLq/lZNQb3wfs4KBh0LJIpNCAO8TYGo+xnKjLMRNfkLVX298t+04Os0bMdLrOpT3uPxuOWzZ9HW9SEfX3zUyX3K3wSW3LpJwzd7RwHYpa8gjCXWI7SM6a+9yd75dZ542GItzKdDempEKkYIxv12W777vb+oEi5VeUyG0uPMVYUYSwe9nMhnK/bbAkQUnFh8jJeWThPpjKHqc3zx6NTrfHnpVCVHWiz7LGGgqMWdwd7LZxjsOsx6shvsZsn0K2dOkquUTraKFYrre49VYxygltq+zISMRIvI/SYkqpy8tsItt0K6gK2lzWLW4r7EvRGxaNGiRYsWLVq0aNGiRYsWLVq0aHHbcN8wiKQoJiQlJoh9GSRFOZtRBHRRWa7vKYKeJSSwlXwstxGxyKtMZ9YKJ1fBVlmVPOqZJ/xskGe/VPKpHQ7HdlKMZI/nzrwFJMSiILcRmU7oJQVfePUxzr+u2TUv6XUE51+DwUDTn1McfYfi3Lv+Ao/+1s+j9u51O929jyhbp4h7RMWQIurUMk6UNGGhKGxc3Y9YD8tzisuMAhZho7GpeHmfe2ZYGdABvGPG9TXNxHuJjJ9dr2d0anF7cG55iQPdOVbzHufXDvBdfyyd+H357FmuFbtZy7pIaYmCzHme/l1YhRCWTEfkRpEbxXqelhnNLIkqUNJQWIU2ihyFEpZCKDpyhBIaKYqm07uvUGcNbcUi8tKxJslYuD//2f/WlNUsZBH55aHJLtw7z1qdKVUvS39dIVuniSlUl9p5RpX/Hv4P26ymcvdoYhaF2/oy3ooBFDK7QglhWAZtJrQ7iybmUN0Qvv7dwy8LJYrhfpue15Dp90fPPXdrL2YHwvUtjGMGNNgFhFlr69nFtrX/G2Qc1c8Nxv2knYyl5XMoDLZk4p9dXoayD7z/kmOWj+b2I4z7fb27Dy0i9l06hXrpFMy7ZCaj3p+kG+UIYUlkgRIajUJO2Dr4RDFjNrASBdLoMmuVRMuxsqDOzHJJKhS5ienKQcUcn8U8v3D6eWeOLRRWRJven0cXj3N6+RUi8rZ9vAN448Wv0lcRnfVLdNbe4p0f/L6J37925iIH9Ije6Bp51MVnJpywFBFqIuOdtBqJruxBLKDIHVPIGoQw6MDQfla26xYt7lXcsbfNJz/5SYQQfPzjH6+WWWt5+umnOXLkCN1ul4985CN84xvfuKn9V9TgMnBg8VnIDAqNthJtJZmJyEyEtgodXL53F1IULgMCtpKveI1ymIrUexz5df2xm/6EdYEkn2Jxp8N3kAamSywKYlHw7KsP8Tsv7OdRzvJQ7wqHFjL27lYoKcgL6PcUDx1OeexIxIcPn+ToV37VBYeshb0HKOb3UiR9l6JXqoqu6WFkhFbJRDaBjlkn1iPSYoO02EDZogy0ZdhSMlhYdy99OW8Hmsj5VSEnqOQ+KHRscfGB8V24Gzi7vMyF089z4fTzRCZjwV7hHdEFjs2/yk/9U5fp761v/CH/xwtrXC8WEFhiZZiPB1VHMZVDOgxccAdLLAoSVRBL1+ncyCJWRikro5TCSNaLDiMdM9QR1goKI4mEHj+nOyDN/e1uI6E5fXpTRrFw/XpwoymQEwaGmrbxAZD68cJzWD57dlvSp7uNxWPHpmZp89/rgZ16gKxJYlYPAjWtO8sXpl7mN9uGTfMy8ucX3sd74X7di/CTFPXy9d/PLi9XssHwNx/QmSZnqt9XH3SqD2Trz+VOkJjd7vZxq5ToMBkcuhlM8zSakIjW9u+PqVETUpidCoMix6WvL4iZH17iyKnf5vCp3+HVA9/Mqwe+GVVkRMUQVYyI9YhutkLe3c3oiffz5rv+LG++688yH29UmYQTmZfverNpMO58LHU5XajLds+QK5cR1ViFttEm2aDvxytREIli2/e1kImTIQV92LB9BJdFzSCnen21eHt4eekUb558ljde/CoAw94+3tr7BBf2vQ9wE49Xvv77vPWNP6Qn18lVShb3MVK54FD550dpEPpRGWLj/IrcWENsDh5Z4yasg3Fnixb3G+5IgOhLX/oS//yf/3Pe+973Tiz/2Z/9WT71qU/xmc98hi996UscPnyY7/qu72J1dfVOnFaLFi1a7Ai0bWSLFi1aNKNtH1u0aNGiRYs7h9tOaVlbW+MHf/AH+Rf/4l/wD//hP6yWW2v59Kc/zc/8zM/wAz/wAwD80i/9EocOHeJXfuVX+JEf+ZEbOo4mRqMqw9pI5EQmR5mcXHXoSMnAdChMVEpPHPNHChcB9rMPEuNmc6zLZGasLLMoOUaStaKMJxs3U4HFlhkvrHWslCrjWSlHuxdw/swLgIuEr4i9XMvmGRYRx/oXAPjIkZNwBNbVAl27wYm5dR493iG3MdYKolKiE4mC+dWLmMOPIgdrFAv7ybq7yeMeRrgZsM0z3xJdRueVyemZVYayz1D26dpVkuEK0hQUcZci6pBHXTLp7iF2nJ1qq9m/pWWXWa0y4RQWaQ1Hjx1nafkcQjgpRaxHHDvxJAAvLZ3eRDc+t7zUZql4G0j0oKJoS6vZtf6GW75xlf/3B04D3wNAPx4wKJzkbE+yQiqGxDYjyR3LyEiFVYJYOkaZsgnWCpSwjAo3GxQrl+ksUQWpzOjIYSU37YoNgImshncDd6KNPHb0KLt27ZqY0WxiEzUZGNefV29kW5dL1OVlddTZNE3ytp1MyfcyqyYz7rrMrC4tm8biCDFNNuYxiwkyi5nUtP2sa6xfW3gt3qB6KzlgXZLWYvuYZfZeZ/15+Gx5UD5nNYli+FzX60vVJjRIzXYC7lgfUqpGJsCE7K7h95thFTVK2Braw3odeOz4Ezd0nDuJ82deQFrN7mJEpIcMk11E/+ZTXPy/fZKVdx3AlIxvgJf63zQh2ZPKYhJBJMYMKY2kFw2JhKYjBuNEMeWwxWchdeb/IMpEFAaJljGRychlSkFEbmJnYC00KcNKSmiQGKtK1cHW9/Dc8hKmTIjiERq/u3ej5XjQP6y3hRdOP48VkkdOPHWzRf1AY/nsWbTokgjXD1SmYBT3uaZ3c2kwz5O4PuZr3eMczC6wMHrLMcmEQsuk+lwQI8okRNWYTQiEsVUfcxT1yEt79VwmCGknx4m4cV8hRnelLFq0uJ247QyiH/uxH+P7vu/7+M7v/M6J5efOneONN97gox/9aLUsTVM+/OEP88wzz0zd32g0YmVlZeLPI/SlMaiqITBCOqmYFUhhiMoAkWrKRCbERApDawUj23Fk1PJFAlRpUGFM55e4DAphRjQYZ03YyTrVTHXIVIe02OD4qV/jcHqR/d0Vuvkq3XyVXetvMje4RDdfI9UbxHpIwoiu2KCv1uiKDXqs0THrjsaZdCaCQ7lKy2CaLINreizCs6bsHBmk1cR6RETupEWjNRf4sQap84piHdmc1A7oiAEpQ5TdmiIshB3/+XtW7s9nRJPWsCHnq860EaoKLEGZtYJ4885bbAsXX/gykcmJTIYyedVRs0Jyef8TLC18AIAD3/Qh1vMu/WhIPxoyxwq9YpWkcC9uTweOTEZsMyJychsRSSc129PL2Nsbcai/zqH0LQ6qN1kQV+nr68QiJxaOHh6ZzD2z4u5R929lGzmtfTx39mzlT1L3vgkHQD4lu18efp6WYasJswIi9YxbjYPVHYqzy8uVxKxeduG1eFlOUwCt/tlvX/cjqm8X3otZA/lQIuvPddvBIagkR/V9hz42YXa2aTKoFjeOrer/NL+u8NluqhP1e9KUnaxep+vHvFu4U33I0ELAY6tA2Xb7dNPWqy+f2p5isUjOLL+8rePdDShTsKF2YYUgj7pEOoMf/HF6Yt3JvBhnD/MTqL6vbRBIbGXpADjZePmurgbxQpRrl36h9cB4aS9REFdSodzE5RaytJZQVf/BGVA4H0PFbB/Cs8vLld1EmKnYo0qVjqqet/NnXtj0/BRy0kqhxfbhM8RJNLlKyVWKlhHSGvpqg4O96wA8/Ph7ODw8hzQ5hUzchKQsM0qLsYepJqqkkJrI1VMRMYznyKIuueq4OlPaWPg64+0pmrIdtmhxv+C2Moh+9Vd/la985St86Utf2vTbG2841sChQ4cmlh86dIiXX57+EvzkJz/JP/gH/+DWnmiLFi1a3AXc6jaybR9btGhxv6DtQ7Zo0aJFixZ3HreNQXT+/Hn+zt/5O/zyL/8ynU5n6nqinnXF2k3LQvz0T/80169fr/7Onz8PUMnLxlFex+cpZEJh44r5EwmDkhopxmZ3Y0NpWVJUlWMbYYlVPmES6CVm0pqArSTHM3LlrIL/JSbb0cwhj8NvPMfhN55j4fQfYN56k4f/4H/h8Yu/R3/9TRYuL5OsXyYerrhZIagc/CUGZQrHxLAFkcnRUUrW20Pe2YVWCVmVOUAhja6yV8jyvxWynL2U1cyKtC5jxcrcQyidQSkfE0ZjhCQ2zrw60YPKvHrL2T47yRzybCU/K2etu8ddu46ybjZJYNFEvHLmJOAkcIqCl5ZO38riv29wdnmZc8tLnFte4uWlU9WMT4ioGJJma3Qzx1Aroi5WKl5YX+TN9V3VeiujlFjm7OYyvew6sR6iTFEZDQosyhbunpicRLi/bjTiYOcqBztX2R9fYmF4kf7wCr3sOpHOUBQoCoQ1FcPwbuB2tJHT2sc6mgyPwyxcHt74NmSjTJM0bZVRy7Nipm3blKVppyDMDlU37W1iXYS/3Uj2opClA5OG2HWWSF2SVpcceYPh7SLc3h+rbkQdSpb8/5DtVM/Y1mI2tpJzTjN+r6/j/2+1Tv0YdUbhduSNdwp3ug8Z9uHC79V+Z+xzqz6el680bjvDUL6+X59la6fhtVNfYy3ajRSaq8khLsbv4NX4nbwav5MRHQqiib5xInIS6f5iURCV8q9IFI7TIzSxyMvvkxmKYcwGryPs/0cmJ9Yj5uUKKpASQTle8H13K1jLe0R2dpbhpntcEHP+zAuVRYNfx7PMXaYzUf0eruP7lC0m4aV6wES5efjnJJMdcpU6GVipUAgR5QNnTaEStIzQwmVnFthKUhiOFasxIzGZ6jBSTl5WqQ4CQ2uoKRIa6mKLFvc6btvI6Nlnn+XixYu8//3vJ4oioiji85//PP/kn/wToiiqZn38LJDHxYsXN80IhUjTlF27dk38AeNsY1Wox1FQw1ToUhgiWSDFuHnw8J8NYx26e2G5YJIt/YjcuqZaVxO5/6W22mc1C/cXZtdqGjDvCAiJWr2KXV/FjjLMYANx7hTJ5dewUmGlYjh3gDxKyWWKFpEbnNsyOGTGQRov7bNSgRBVMKaSc5XLtYwoZIwpU5FqGXHoyfeTq5RYO02vpxU7arElKob0B5eJi1F1XGENmepu2YndlLGgDAz09AoCU1JHFYWMGYkuy2fPYoREYhjJHgDvePzdpHqDyGS3607c07BinL3Ppw49ufxq9XuhEpTOiIoRyWgVVYwQVjNM5vme9yV8z/uc3vvU8nm6cYG2ik6+7rLhWVvRhKU1SKMnskt0hJMczstV5ux19hQX2bN2gWS0SpQPUDpD6YxuvoqyBVpG5CLBWHVXspjdjjZyWvsIm9Oj1weeTQNHj3o2o6ZB6VZys9ADJZRKhYPTnSpPWjx2rFESVvfqATaV8XZkeHX4beq+TccWFycCbU0BhVACVt/fVmi6B00yJC8tWy6li2EGyBZbw5fXtACcR/2ZnJZtrL5+07NeD+xu+b68y9KyO92HhGbp3SyE2Wonlk8J1lVt3w16Frm+reH08is7sg9ZSOcBKqwlZcicWK38hAbGyXS856ezeSiIRU4isuovKrOJVUEiCpeynsnstI2BobKsH198lMcXHyUS42CPtM76IRKu7+8zrJnAe3Au3mAkujOvsemeaRQbcp6h7FcZsPzE8MtLp7AIlCkYyn61TSY6ZKIzkSa9xRh+wv2lpdPkMuXlpVPVb34iWghb2X7kInXlieJ9Jw4A8NYLXyRZu4yVJUlAun6ln+jXZcAyfHb9Z40it76OyIAGYKotbG3o3ErNWtyPuG0Bou/4ju/g61//Os8991z194EPfIAf/MEf5LnnnuPYsWMcPnyYz33uc9U2WZbx+c9/nm//9m+/XafVokWLFjsCbRvZokWLFs1o28cWLVq0aNHi7uC2eRDNz8/z7ne/e2JZv99n37591fKPf/zjfOITn+DEiROcOHGCT3ziE/R6PT72sY/d1DElY9NpVWbVcuyAkn0iNAU49pAYGxL69U1gRCaFjxprbEBBdPREhUIj0dUsRGhMLdAUNq7OpRBxFX3OSPnqmUt884n9N3WNtwPXvvo7qC/+V4ZXr7P+xhW6+xfoHjmEffwYo4XDrPf2MVBz7rpFQaKHzrx645LbgZAUcbeUkBWV8TBCOJM3EY1lZLI+01ZK/7ST4r158ln6+QbSaHpcAWvGM5klAwkFwmqMjFwmKyHJSBmZlFfOnGRNLPDU8SO8evrrbCg3OyiFxpS032k07a+duUgiM6LShDCzaTV75Wek3nrhi0jpZHNNGc4edIQSoVfOnETLeGIG8MgT72X1S7+BVTGjzoIzA1QduvnaxH4UBR+88p9Buecr6+8jj7uIsj4UMqaQCSOc9CCiYC6/SqRHxPkAlbsMZQhZztpKx0ISLjMFgLYRI5ui0OT2zs/m3Y02MmQS1Bk8xxYXGxk8N8I+2Wr9uqlz/TvszAxYPnMbsClDmYfPPuXRJMVrQt10OrwfoXF0yAxqMv2us7FCNkSVfY1aNrZy32HmrGksoJDN5OtK/VyFdfOx/vtOu487BWG5hOUd3hePJunlLClfnbU2jckSrt+E7UjXbifudPsYmiZ7cvk06citKI+Q8R4srLUbpRkzYKVbvtOSZFw4/TyRNRghKUQ87kNjSEorh0gUlaDHZ4+FzaycabLZKuNZ7R1Tr8eVNBbJIJ6vJEQxObKWiKLKSCwsCbCue5xefgWJW0+hq/IvRAxlJuNpbdrS8jki6/qxuUgmz9G6348vHq3Wv1vS9p2OsIwunH6eoerz6umv8/Dj7+GRE09x4fTzZKJT3U9tI2KyiX69RfLSQ3+Cdd1DakNHjkjlsDIlt1ZMjAH9/1B+NmYPueP4LNZ+/y1rqMX9jtue5n4WfuqnforBYMCP/uiPcvXqVT70oQ/xm7/5m8zPz9/U/uqZBXzKS//Aa9vcIPsBrJOOjdcZi9VkJS8Lj6PQwTJZZccKKcSVt1H5WyRyYrGzXvCdKxe4tFTq8I2h98gR1ENHyOb3kSc9CpkQW5d1KimGdIZXAZD5yMnPVATWhdGsVFgURkZo6bS8Ljhk8FnKACI9culChXQys1I6pEyBlQqVrSN0Xg7qRSlLk9U2WrlMEIVM0CKisBFSGFbZzaNXv8rp5YJYOcqwxmUheNfiO2aWQyQKchtPdDq8PFHbiOtf+S10bx9Z1EVa13l49fTXg2x5qrq+nZyO9k7g3PISVrpOUm4m63t85XX34cCjXIiPYQvB4hOTna6F0VvIS69D4qjBKuliVISREavRHgByGzMyCVIY0jII5Dt0VsXunkQJWdyvvK20jFzQVsbBy17sWA35rW4jYXOQyKMudWmSn03LoDXLu2SrAepW6+40bCWD206gbJaHUz0gME325YNG9WBQU5AoTH0eDqT8bz6oMwv1OhEGsPx+/TK/fx/ICD2m2sCRw0RaejZ7dPkg3LSyagoSbue5qt/HepB2WvBxJ+LWto9hH89lWw0HgULUytG+/fdGPRMWlIHeQAovrcZnzxI1udVOgJYxwmTEIp8I+PhMoU5aVvpOWgNTiqxe9+oWEBMeRLU2tiqzYN85SeB7NO6ry8DyQePuukYhhCWzCedX97HQGXIguQLCjQssckv/p4IYoSyRyYMxhTsngZO2feX0ZXYrN3ld2HhTQApcnXjQpbpnl5edjYNQ9IrVid8ik7Mm+hgr6cgRSmiOLh6fWOdScoSr2S6GOiJVGqsERnmPWeGsQ6wppWrjZ9CP+KZJQMMgUYsW9zvuaIDod3/3dye+CyF4+umnefrpp+/kabRo0aLFjkTbRrZo0aJFM9r2sUWLFi1atLj9uKsMolsJIZwBnrVOHgagccyS3EZV1Nf/BpOzN6KUFU2YUYvxsonZi2obg5CyPKZGWEdPnDZDAo4hE4mCr525yHtPHLylZXAzGP7aPwEg7qUA9A7tQR07Qbb3IbCGeLTGwmgs/xHWVLIvkziGjpHxhLQij7qVBEjLqDKcdobS2mUlA6xMKEqjPl++hYwRyiCSPlExdCyiUiZkZFwZZucqpZAJOY5h4g0QtVW8tvc9PLH4yA2XRVdssGbnq1mEzCal/FBjkFzafcxl0RKKXJTHLWcQjXXU1b5dueHj3o8Q1hDZgkImqBq1O9/3MMPeXg489UG+ubbd1T/6PADdwXXsnv2IPMOkXdbmjwCQRV0MktzErBdOXjYfbzg6cFm3rBDkSZ9CpWRRlw05PyFzi+3IMdWEQJUzh/c7vEzEs05C1OVeTb/V9+V/C7/Xt2nMytPATmha5+zy8o6cRW2Sc01bZ9p2/ntdqhWWWSXnqu0jXK+JydQkIQx/ezvlWpcBhlg+exZRW14vh5Y1tBlbMXPq9yo0eodJSdq0e98k49wK06Sg9zcm2TmeRdSEin1aYxHdDKuoiUU0wYT38irPbihN4nfS8+RNgEMmhhJFI7PHo87SmM5CNZUVwcT29fcSgWSZQG4bWEqAk3bJktEupESgSUrWiEXw3v6LrKndN5wxLmFEpDO0dCx0z1SSVoOAlCFJNKrOKyJ3thW+D4lk8dgxlpbP3dBx71fkKiW3CfP26sTyK9EhUjKeOnGkcbsLp59nyEMkqiBRRVUncxNhrEQKQ1ayjyo2UK15a8pYN8Em3IFMvhYtbjXumwBR5JITVlISY52sKMxgBqDE9AfbllKywkaVTrr+cpFinCrT++pIDMKUmc18OvYJXWtJNy33F5HvCP3x9a/8FvGBhwHoPvQSAPHBA2R7H8IKhSxGJBsu4GGVwkSp+/NBndL/xweHbCkBG0W9SsITmZzIOKqxMpkLMAmBljGFSqrgkUtxL8u0oK5sjIyhPJYpA0M+a5UWkctzUWaPi4TLeJGT3FRwCCAjJRFZde/8yySULGai41TJVrnfype9P4+BnGM+v3JTx7+f4MtMmZy09J26/PwzrHX20e8scOCpD27aZvjr/zPikScByHp7iFWE0AVFOocVkrVoN7mNyUxMrmOMdZ0rH/yJiwFSu7pWxF1GUY8VsYdMxwhhSYWjwXsZICKuMhQ+KLTh0LukPpisDyq3GhROC4TUgyBb+eU0reuzO93tIFEV8NhiwFy/5mnynfr6Tb5F4e/h8mkD/yY0BeimBe22i/o5+HsTBqpCmVlT0OvBCDRsD2GA0MMH2qbV+2meK/63pnteP2bTedQ/h/V8p8rLbie2OwCsB4NudrKhSdLig0ShdBqoJiJ3Qvt46fk/YJfOeHNuEYUuvYf0hM9QE7abxW3iukuZmbOMkJV0q/yxXH/czoaeQxNtshVldtpJ+L7ew4+/Z1vnVoe02k2KEk1I2vy5+/Pw1yX8eXuLTSHKDHV3PqPqToOp7q8lU+PscpeffwbZfXTC3sPjlTMnnWVF1KNvNwJ7CFeeFkERZKv1HkOzEGYs83Wt/r1Fi/sVdz9K0aJFixYtWrRo0aJFixYtWrRo0eKu4v5hENmMyCaYkiFkhShpoyUzpXSd9w72AC5ZhftskGQ2YWQSRtqxVmKpSVVGQgaCSnrmsplJYptVrCBPg/UMJigq02pnaGyrdWMyChHz/NIblfztWx7fd0fL6/Lzz9C/dB59bgmA5MgR7MGHKeb2gJBEQ8cc0qnL+IQQ5Ok8VjoDaqCSigmjMSqmUClr6R6sFSiriUxGrEfVekZGlexMWuMYHyWbY63jrj8THbSMyVVamlqHM2cGIxUj1SM2IwoRo4SemJ3Zyoh6Fjzz6M2Tz9IZXGWjt59BPE9kMqTVvOPxd3PxhS9jpGIt3o0mqszKfZYzl4Hh0Zs+h/sRmojXX3yOjs7ZvXKehW/5TgCGv/HPIbi/Zs9BkrXLjHYdZL27D907hJYRI9NhaFKGWUJuxhkoBJaeyiszzLg0NrcqZhDPsy53MdIJ63nKXDxkaFOkGhul9/Pr6NJMXbO2+cTvIzSxBKwQEwyGJkmKR938uGn5NIPk8LdZspcm9o1nndwtOcVWjAy/Tnh94bX58m1i3TSVs2ffbMUG2cpEvG4gHe7/ZuHvwfLZs5PXFez77PJyZXpdP99wHy2YKEOYzJTnv2/CNkyjp0kMw9/9Pqax4cJ24UFhfQlht80AqhKSTDOznSqX2ro9Cderkp2ISVaJZz7crfbx0vN/wEa6myjuc7lzjIQMKXQp3ZYI4/rDjcyoGfVpQhZWYyBVrHs7No4O75eXs4UsHXc8OcESjmzOOxcfZ/nsWbQdD4FShm+rfQwz2r6w9BodMagYYBpVZedyCQM2l42wFiMkx48d5UGHv6+xzUj0AHBlWqTH2V+8wZEn3ssrZ04CYymakr3SWF5W/XGosdXEmAEUSjfd/82MoKb2QKCrulRlQnsAbApaPHi4bwJEisJ5kNgyvb0Yy5EyXLpyIyTWlC8JUZTbucFiZlO0VVVwyHcWfOMhMRWNtWp8rHv5YA3UpGUSUwWFlC0mX3ZCkTCqGpWRTW5TqTTj1dNfZ9dwBXPhJUTsMpDpR1wWACsVWIOJO+4lJscdE2k0hXTrOy+isdROy4RCJQhrUbYgMhmRyVEmr649i/pkyvnGKFsgVQLGZSrz9FyFuy8WAWJMAHUvWpcpTNkCLaJqPYsgMwnvPXFrAjOHnnw/58+8wPzaGyTFBvve/e3Vbwef+gBvvPhVFkZvlceXrKQuuDWfXQHalzu4LG7nz7xQPYfOf8oSr14CYPXLn0X1d20KJOT9PQzTBXKZMrA9rHGeYEPtgkPGCKS0KGGJZEEicyLc86hVgpAxOkooZFIFdGOpyUxER2VVx9rXzUiPQAiyUur4ICAMZnhJS/hb/XMY2JkWRKoHeZqOF6IpYDXtXO8G6oPjadcPbJIJNQWCfD2vAgLbGOiHx/FeM02SwKZBvl83PI9bJUfxg1F/zHC/4eemAMNO806522jyBZsWMPV1xa9ff67CrHbTjuX3E8rH6rI173HDAyovg+mS0K3Wm7buJr+cbQRJdjKyuM9Q9jFSkjIiInfBIUQ1WToObjUEiaZIuid8lwIbBp/FrVyp/FdLWy9EJUvaFBwqfwPIRcrp5VeAaNxfF5pjx26dXG/eXmNd7HJeTBQTqdutCLIcWzHpdbXzb/0dgX9HvLR0mkhnFMp5WRY2orfh+pBGKEai68YbjANCimJ6G4jAe429nb5FGxBq8SCglZi1aNGiRYsWLVq0aNGiRYsWLVo84Lh/GESmcKwUo5FWBzMHsrpKjQJJleksnK0wjvNDogonkZKaWBRVBqaQjmisQgo9Qf8VOBaMl694g0HhsyV44+OSKuwzUkSioBB31pRu17VXkDpHdnvotVV3XnGnOm9prWPvyAgrx1XEyNp5lhF4IxSj2EnRYuMyREU6Q5rc3YfSyDpXKUaoiXLS3oS6LANli+q3usTMm1h7A2zLeJZK3+JY5yMnngKe4uILX9702+F3ffPE93EuupY9VIeWLnPEMO4jrKZTZLz1jT+E7h562QYWKvNzKyPypEehEjfLZkVpGq+IhEEqg5VOXhYJ455RmaNRpGaAVgneKB1ACU0i8+pZ3yWdbDIphoiyDgprHCvN5DOu4v7BLKYPNDNk6jPpdcZMfbs6U2GWiW79GNOYOneSedIo7akhvI4628IzMKYZgM+S1Tn5wWY5n5eLNbEa6sfxyyZkZreBibXV/bjbBrr3AoS1EzIzzwIK649H+CwI2HS//fK63HGauflWLL6wft0LrJZbhWky2Vnrb2UY3/S5WhZmR7pJZsKdNqxejxbKvvBY5lX1t6vP22cOAVXW4PHK5b9amzdLphcmkAnPo56BynlDj5k7t7p+u/6jw5nllyd+axmU20dkMoR1RtVds8aIlJW5hxidfJYi2VsxwiupV6lGCNGUAc9LEaex3OoSsq3wILWPLR4c3DcMImk1kc6IiwFKZyTZGmnu/rr5qvvTay7VpCgpsRRogkxnZUrzSBakIiMShZOmldnNrB2nHq1naPCBIB/88INPcA2UKeVRlfQNUYWlIrHZkf9W4JUzJ3n19Nc3l5XOEdkQlELtO4DadwCMdhIdqyd9YaRyfypyAaMy2GOlct4tMsbIuLpmZQp3D0rfHiMj8qhLrjqYMpAWBst8WbgyHQfdQm8nX44+OJTbBFPeN4lx3lLm9gTZDj71gduy3wcBuUwZmQ4du0Ehk+o+zr9xivlTX0BdeZOis4vB3CHW+wfZ6O51MkNTkOghqRiRyhE9NWAuWmcuGtCPhnRURiJzunJIREFkc5Ji4OSQ5Ys+NiMSRqRiRFcO6clBtdzXTR8cctnx7pumcCZ8B7tp8FkP7oT/w/VC6VD9LzxGfd91NAU7pnn83OkOWCjBqQe/pklKmq4nHAxMK9+mAfus44THCterLwvTn7cd2J2LY4uLE5JPj7D+NQVO6/Uz3MZ/9qgHg5qkiU31c9qzez9i2nPydp6daWVnraj+6stvFLfr2b5w+nkunH6e1059bdNvrufq/iKROxuFMstYo+9Q7VorC4fA9yksE2tFtf9w22nvnOq8/MQwLlOZFQJjVTmZKCvfIiEsUugqC2pTWvNbhROLj922fd/viEzOerobZVwdS+WIdbmLt+KHGdgeBZG7p9ZlzavIATV5YlO9nBUc2sqPLGyX23frvYXf+73f4y/8hb/AkSNHEELwa7/2axO/W2t5+umnOXLkCN1ul4985CN84xvfmFhnNBrxEz/xE+zfv59+v8/3f//3c+HChYl1rl69yg/90A+xsLDAwsICP/RDP8S1a9du89XdWjwYo6IWLVq0aNGiRYsWLVq0aNGixQOH9fV1/tgf+2N85jOfafz9Z3/2Z/nUpz7FZz7zGb70pS9x+PBhvuu7vovV1dVqnY9//OP8x//4H/nVX/1Vfv/3f5+1tTX+/J//82g9Jnt87GMf47nnnuOzn/0sn/3sZ3nuuef4oR/6odt+fbcS943ETFhDpEcIo53MzJvOBmZ5QiUlC8WZQhshKxqrxCCExfNQfHYsi5O5+H14U2sjJKrOIsIiShaMo3qHNNfNn4WwYN2xnj19hfc/vvemr39p+Vw1ExLrIUkxJEv3sXfjVS6cfh5pDaOox9HF4xgVoyIN+5w4ysQdinTOnVMxdObTAqyMAhaUKo2iRcW2EMJlkrDCmRADY4kfAitUyZ6SaBlXrKCQAmqFRFjjGCDljM+YRTQZmdcle6iwTrYUy9KcGMXe6Aqw56bL727h3PISRxeP3+3TuC0Y0aHPqpv9MQVzp78IRY498BDs2Y9VMWtzhxhGfawVJGZIrEdEOiPSGSIq6cNYCplQyJjCxhTWmUvGIkOZgrTYcNJFXwetkzgKa1CyKGWTntlnJqShumwTtMzuWjndCdRZJsCEOW4TO8V/nvZbk7SpaZsmCcY0yUsTa2aWNO3tom7mHB63fq7TysEjNAmuy4HCfU5lFTQwicLzqZd1XZZU/x7u916VNdxp6czdQJOksc7wqbOIZj0/TSygJjTVpfry7cqs7kfcbLszizV0O4/7dmW4Ly+dmuibGRlTyBhpDefPvIAWUZWpy79DO2JQ9f2MUNPrmrAT138zTKlpsp9N+xLlsmA1i0DirQsmJc/SarS8N4dC93v7GBVDbLwLAC0itFWkckhB7AzARVExhyBgCwmBaGAIVfd+igQSpsvKWqbQ/YHv/d7v5Xu/93sbf7PW8ulPf5qf+Zmf4Qd+4AcA+KVf+iUOHTrEr/zKr/AjP/IjXL9+nX/1r/4V//bf/lu+8ztdRuZf/uVf5pFHHuG3fuu3+O7v/m5OnjzJZz/7Wb7whS/woQ99CIB/8S/+Bd/2bd/GqVOneOKJJ+7Mxb5N3JutYgOk1QgjkUYjTIHQLnOYlWocnCmDRdLqyvOmcr8XbJKZhJTEiewKuBdQ6CdEuU/vPeQkLKXPTphxK8zuYIXzRYIq49LN4KWl08jS28djkMzTz6+z0j2IwDKSMXEVNBMU3V2IuINV7tyEKRtYFbtU4fVOZhk0GpfHODjmy1eVGcksAq1cEC5XaZW5rMpqRr3jKsttdSXHGx/HlztBtrKDfPnUVd574iCnl18htzHHjt+bL8lpaXLvB/TsGkkxoDu8hsrWYTSEJKGY34fMNjBRSqa6LkWp77yVQVZpNbEuB+YYbCTIhctyJ4VBCk1kctJio6p3XjZmhXTPgqHqvIbPbxGN/ba8r1aTTv1+Qr1zE3qWeNS9S/x6dR+TetsQet3UB5TTBpj1Tvq0z00D2LeLaSnmfWe7KSvZrHPw51kvT49ZAbNpAbHwc339+r1s8qTxg4amVPf3Eu7nwQ+Mg3e+7oX/oTno01QHwiBn3f+qCVv5D4Xn9yAHiW4VbjQgMqvN3O7628UrZ06692NpgQCuLzeU89WEipVplSEYqLxfLJP9tabzrepuLUg09VqmCBt8n3Mrz6ZKjhakM3e9CIUSRZWt7MzyywgMkc1457HHN+3nXsGZ5ZfvWxnbMJnHCuEmh0mIKFg8doyl5XMT9WQ86Sdn9hlu9Dlpg0KbMRwOybKdNaFqrUXU7m2apqRpekP7OXfuHG+88QYf/ehHJ/bz4Q9/mGeeeYYf+ZEf4dlnnyXP84l1jhw5wrvf/W6eeeYZvvu7v5s/+IM/YGFhoQoOAfzxP/7HWVhY4JlnnmkDRC1atGjRokWLFi1atGjRokWLexfD4ZAj3Tmucnt8c28Wc3NzrK2tTSz7H//H/5Gnn376hvbzxhtvAHDo0KGJ5YcOHeLll1+u1kmShD179mxax2//xhtvcPDgQeo4ePBgtc69gPsmQCSLDFUYhNUu6isEJuqgVcJGuhtgIoNWrEcokxMXg+q3LO6TKxdxzEWCF5yF7ANtHY1WoSvWAzj5U8geCrOY+W3D/6Y0zPPoqBGnls8jsDy++OgNXfv88BJZ5LKI5SplqPoAjOKu+29TIluQl9K6z6uP8q3dPwJAaRcJTjL3cBkZUyRzzvAXwNoxE6uUkwlrSxna2FDa7weotvUZyhI9rJhbE2UhvDn4mPorrHbStZJppWVU/o8Z2i4jk/AbX8kZFgt8AG64rG43Xj39daTRPPSu921rfT9bXBAj0dXM3L0+c371jz7PoQsnYWMdgM7/+e/CB7+PK1/7r0T5BqP5g1zqPUpmS7knkoXcratMjiyySi5qVETHaFK54X7X5W/aZckjmDUCQFikHLPRTGBa6Fl+4J7ryDiZWqyHd6po7gqmSUbqEpY6i2jaTHbIGmpiDzVJY2adz7R1wlloz6rwx96unCI01W5iTtRZN00MozqLata1NO07ZIqE8NvUf2s6Vl3iFkrawnMMy+lelZbVETKhmiSB9xrC+luXA/r612RMPeu7Zw4RPLez5Gaz2EHTjnE/o6m9u1XMqS1lUX45EurWBbVtvfXBxLKgDiweO3ZDrJKR7JX7HWeEKmRMRF6dZ2xGGKEqSbw/fkReyX3EFLPniXZxi6xQLhHM5PWPmUDj/nITm2hWoglnjOD6mUvL5wBIzZBHTzw583zuBm5ENnZscZFzy0ubmKL3ert/4fTzrKndoHaDdYy1xxcfZfnsWU4tnwciUjuoZIShhcfNMB5vtH27Xe3ETkeWZVxF84vqKL0dYmG8geGvr53j/Pnz7Nq1q1p+o+yhEHU2UhNDqY76Ok3rb2c/Owk74w7fAvhADEJipaJI+hgZM0wX8NmKTCk9iXRGd3iVJFsjygdE+aCUoolqXY/CRtWftm5wmYgRiR1OpMY2wmVc0CinlZVx9d8KOfHi9I2Jz55mrSAWOZHIMUiePX2FM8svb0qPOQ0W5wFUqMR5/ZSZGRI7pGPW6QsX/ImFC+IYI0rflZhr3cNc6x6miLtolaCjxP2XsfN9UWmVhSyP0jJrmfNuKWTiAjjl9VX+QtZnKXP+QsKaip7sMwyEmd3G5RQOKseZy7SMyUXCwHTIdMSwULx734V6MewIPPz4e25YrnRscZGYDCHcwEdgObe8dJvO8M7ACom9cons/Hmy8+e59tzvcu2530VYw6izm5XuQQobkduIwpZyz2JAZ3CZKFtHmhxVjMAaZOGyjklTuD9duCCR1SidIfWoChoZFWOlIou6jKIeo6hHprquropoIjgkrHGeWUYjjJl1Ofc8ZklNpkm86ttu8taxmzN5TDuOH3w1eaRMC7jUP3v4QdB20tGHx26Sb23l9zFr0FjffqsBvB/4NwWU6tcSnm/TQN5LBP26fkBRL+OdiO3etxCLx45Vf/cLwvvnv097Fur1YVrgJgzwCmtZPHZsU5Ax/B5mUPPrTpN5trhxqdg0TMuSVA+OVMvrksKGQEzYlpxYfGzb8lIpdJXRS4ggy6UVaCKGtosWkes7m0lpiSYiIp963uF5bQdbZY9q3H9tstUFqjb7g3ooNLHNbrifdqdwo8Hvo4vHq3bR2uaJiHsNVkj6ZoXcxlVA1PeJXbBv7E/ZhHrfpN5Pqa+3vXPa+e/WO4Uekp5QO+OvfPZ37do18XczAaLDhw8DbGL5XLx4sWIVHT582AXKrl6duc6bb765af9vvfXWJnbSTsbObCFbtGjRokWLFi1atGjRokWLFjsCIhY76u9W4ejRoxw+fJjPfe5z1bIsy/j85z/Pt3/7twPw/ve/nziOJ9Z5/fXXef7556t1vu3bvo3r16/zxS9+sVrnD//wD7l+/Xq1zr2A+0ZiZlWMjtIx80TFlaSskAmaCKxjGqX5GlYqZOFmQ0rui/ssxnRWjWMMeYaDEJaIAmMViR0irCHDGd4aO5auaBwlUkpnpOtRSdXKmRmLwFoRSNMMXbvO5WI3B8X6tq77zZPPgkoYxPPVMmUKlC0qtpRSBSkbrKo9/MZXct695xUGzNPNV9kwTo7WS3YR62EpI5OVoXau0gnz7ZAN5MvaGwFDKbUrmUF188LQoNutWxpk12Ysx1nQZMkuishtwpWBO9eje66gRMFOxKunv15J724UY0aFK9eXlk5jhCIyWVV3kmLAerJ7R0ssBr/7v7D3I/8tJ/vHeHLxYVa/+F+Q5XNgEazNPcyanWeoU5TQxLIgFjlGRsjcGalbqUCBjlKMjCqJo8AQmQ2E0QjtDeYlSIXuuPpRqJRh1EfbqMxeYugY9zx5huCEcb0QWHn/x8qbWCgwW4biv89iBoUyqfqsddPxwuX13+vHamL53AgdfJp5dn1ZKEMLn9+6DGi7zKP6uk3n3nSt9RnNaeyuJlmZYPO93Il4u22XFaLxvvpr3sltI7i6tBjIJOsSs+3Mak+TKzYdq46wvJbPnoXymNNM1h9EWCuaGT7i5tqhar/1NijYXxM7aRqbpi4xa2I1GNtsHr0VKoa7VWirKKzCSEVabCCwXH7+GZLuwdI0OMdZEJR92aDc3g7TotpHKTlrkpdNPf9ZUrOSnb6Tk4O8vHSKx47fuImtsLbqJ2akvLh8gVhkVT3wZt0du3FT+7+TeOTEU5xdXqbP2lhpgcBYVVkxeGZRfVzR9J6f9b2Oe+Ed2uLmsba2xtLSWKFx7tw5nnvuOfbu3cujjz7Kxz/+cT7xiU9w4sQJTpw4wSc+8Ql6vR4f+9jHAFhYWOCHf/iH+bt/9++yb98+9u7dy9/7e3+P97znPVVWsyeffJLv+Z7v4W/+zb/JP/tn/wyAv/W3/hZ//s//+XvGoBruowCRkQodpWN5k4xKmVRMQYxBlmnax34kVqoqi1ikh2gZIYRxPjylpKyw4+CIwhCLnNiOUKZgI5ons47G5vfjEYu8GuiHAQ8Pga0avpAyaREcSK+gChcAObn8Kk8uPjz1ugfxPP3R1TJVp/P8sUJiUKT5Bkm2RqwipC7oquscUsuwVjZ+1vDeb34fLy2dJlMdN5gJGlwjFEPRmzhnKcYSvNiMKl8hXfobWSEoytThYYDIp7sPoW0U7NdlgRPYSrpnhWQkumCd1G+k3f4W5PUqE8VOw8OPvweA1198bts+RMBEqvt3Hn+cl5ZOMxJdEkYoW1T3w9/jnYqNz/9qNcDu2nU2Pv+r2Lk9LphjLUVnF2/mB4BSWhnlRKIgsUPSjSsucKtzMGCVCwwJbOWfFekRKnNeRMIajIpBqjKAJMijLlnkMqNZBB2cx5jP4OfL0AgFZQBZNAQz70fMkm5N87xp6uTX/VGmBSn87/VjNnW8wv007R+YyO7k5Vo+ULBd6dEsyUyT9Cs8Vn0/4TbTrjfcV9P1b0fGUy+Xellt1SHeiXg76ZnDoF1YV0JfrJ2KMAhTBVRnPGN1GWboNUPtOWsK9E6TjG4VFA7Xuxfq063GVjKnmy2TmeUdBEW2Olbdh2jinmNZWj6HFLby2zm+eHRb5xceW6KRQtIRIzJShpHztCSi9OAs0CiUKOvKNoIuTe+D7ZxLGBSqB9XqAaRNx6zJkHw/POxz7SQ8dvyJyuvpRhC2px27QSFirBUovL2DC7AUMuaVMyd3pP/Sq6e/zrpa4PHFR6v2XAXepVJolCm2HRwKl23nmZ0mJ28xCREJ5A4pG3GDst8vf/nL/Jk/82eq7z/5kz8JwF/7a3+NX/zFX+SnfuqnGAwG/OiP/ihXr17lQx/6EL/5m7/J/PyYhPGP//E/Jooi/spf+SsMBgO+4zu+g1/8xV9EqfE44t/9u3/H3/7bf7vKdvb93//9fOYzn3k7l3rHcd8EiFq0aNGiRYsWLVq0aNGiRYsWLUJ85CMfwc4IFgohePrpp2dmQOt0Ovzcz/0cP/dzPzd1nb179/LLv/zLb+dU7zruG12FRU6YKmdRl0x1yGSnYgN5xk4edV1mLJVUf0YolCkYyZ6LstsIYyUSSywKUpmRyhGp2SDRQ2fALFwUe2hSRjphpBOGOmWoU4qSHVPJvGxRMYpCCOFYOX6GJBepY0yolFyldO06Lyy9NvW6+6Or1XE0ipwEjZclGawQbKS7WekfYhTPYVQ8EUl/64UvEhlnAqxFRCETNuQ863IXG8yR23jCpNvNG8Vj9lO5Ly2dFKxQCblMyVSHQsQVk8gIibbRxB/4WSpdMbs8U8bP8sQ4GaDAsrc7IFH3hpmwwPLKmZM3vf07jz9OJHL6o2uk2Rppvk5abCCtZmHwJhdOP38Lz/bW4LVTX2O0+yFGux8C4OBrzyGvXiS5dAGVOSaPjtKKil43jEYqxwYS47qliqyaKUrK6/fG5wA2SijiLnnSZ5AucD3ez0D0y2fXEJnMPQvBNka4ehwy2u73WfKmWbRpJtHesDY0sA1/a5KqTTNv3C7dexprKFy+fPbs2zaKDLfzpsd+WchCmmBqBMvC658mfQvPb9Z51q+9zpYKt29iDE2TI90LRpoh++vt7CO8di/Z2uksolmm1NPWbXqO6qbS9W2mPVvh/3B/ft2mY+70+nQrcDOGtf7zxH6wm1gr045V/4OxUbM3jN50bMRUto5n8kQ2n9h2lmnxproQHD8iJxZZ+ZdXf4oCha76wNutHzdSjybKIfhrXDdkGJUm1U1SNPcsjPsCOxUFMWeWX77ptuydxx93NhelFMv1sRxTP7MphUzeVv/0duDlpVPkMq3GFq+cOUlu3XhGWDeWkUFW6JA9tJ133lYs3ZthD9Wf3RYt7ifc1gDRJz/5Sb71W7+V+fl5Dh48yF/6S3+JU6dOTaxjreXpp5/myJEjdLtdPvKRj/CNb3zjho9lpHLBCZU6WZlMXICCybTWLhtSEJAo5SlF1EGavHr5Cmzpj5LTkUM6ckDHuuCQtJpR1GNVz5OXPidCWIyV5EYx0jGZibFIIp2VsqmikmP5l1yV+Quz6cU3El1GouuCKzNuU6FSCuVkbjkJa7pPYoYuPbhw1+UDLkmxgSoydr/vI+x+30dASNLBVXrDq6TFBsoWDEWPzCZs6C5D4wbzxsqJcglRDbql06nnMqUQMblNqkCSwQWHwoxwXvKncD5N0mo3+Pf3yDoqqRWCqOyUJLJASbPjPSZg/AJ7O1g8dsxl2itGJKNVkmyNJFtD5cMJ36e7iVfOnOSVMyd548WvIq0mj/vkcd99f/M8RDGm04ciB+mChbHUxFKTyAJfs9JigyLuVvsV1oA16ChBYIl0hpZONlakc5i4Q97ZRZ70GaW72Eh3syYXyExCZhLXmfQ0ZERVp7zcM8RWnfnbhTvZPsJ0yUh9IOgH7z4g07Re/fu0QFK4z6YBa31/02RYYTDED46bjrvdcqhL0qwQVcr4Y4uLVYr4epn538JznCbjqR9zmrSufu2eWj9N9tMUqAqv637L9jUN4TX6e+QHVDspi094Lr5OhcGhxiBBQyCnHpTwMr1ji4tTA7Z1eWK4fFqwtX7su/W+vdPto8e057RpMBiWne/rvB1/m1s10PSSad+vnNWHDI8bZjELv1srqmxnUmiOLx6tJFBV+7PNDGSb3iPlhNHbRRUYCgNKVbarcR/7nccf553HH3/bx7udcAG44m2VS9U2UAbFyn5OTMaIDrm6+TTgtwovL53i5aVTvLR0uuozxyLj/JkXGMo+Aktihlghy3o5nuQz3j+y1jeY9gxNW77VJM6N7u9BgIjljvprcXtwW0v285//PD/2Yz/GF77wBT73uc9RFAUf/ehHWV8fGzD/7M/+LJ/61Kf4zGc+w5e+9CUOHz7Md33Xd7G6uno7T61FixYt7ira9rFFixYtmtG2jy1atGjRosXdwW31IPrsZz878f1f/+t/zcGDB3n22Wf503/6T2Ot5dOf/jQ/8zM/ww/8wA8A8Eu/9EscOnSIX/mVX+FHfuRHtn0szxryMEJWmcU8k0BgkUYjMJgyg5afafGGwsPTzzNUfSJRVEZ8yhYonSPL7AdaRhQ2JhGOcRQLZyI8IiErSumUMETkRCarDPSEjEoGg0SQu8xquNkNaQ3K5CjyyhzaG1fvsld5Ycnw1PEjm677oXe9j1dPf51MdRnoDmt5h92dZMKA7pUzJ1EmR+ocIxVvvfBFDjz1QXa/7yMuC1pZDlpEE/TowkTEkWOqeKoqlNkEcOujKOmf7hql1ViRktvYnb8YZ9wIZ9esFcQyQxhTbR/OvEmjy/2Z6vhreQcl7NsyOL1TeOhd7+PlpVNbrzgDg9/5t6i5ve5LaT6JNch8RKpiLpx+nnc8/u4b3u9LS6fJRUpqNrBC3nBGC2+geOH080hgFPW4jDOefojzAPTX3sQOBwgVIUcDEAIbb5BGq/Tnncm0sZJY5KR24JhFwxV3qZ4dJeQmKriRMVk674zMrWUUz5GpDrlIK8abFONtCpk4M3VTlBnNZFWPjVVkyrH08mh4w+X4dnEn28dps951uVh9mf/spTt19s8sNlB43LocI/y9ieFQZ+7UlzdlgGpC/bynMSaamBlNZVcdb4rErEkaVy+TrWYszy4vTzUunrUdjGVLO7193M692w6mlUlYR24UYUa7t8PEqjKtNey7Xuc9prH86nWrCVvNkE873rR9hKysuzFbfifbR5guU9mK+Qhj1t+0rHQ3ik33pWZKPesebtrXNlg9TfB13xtdT1vH13OfwcyzXmYd93ZIFitJXnBYl5hmzIhTtrgn+o/HFhdnlvt2cW55qao1whoMMQJDTEZhby7hydLyOQpiInIMiscXH72h7f3z4RQVZbZkxmM3aTW5TEt1hS7ZQwYCG4ppmPX8bnf9+nY3us8WLe4X3FGT6uvXrwPOvAlcerk33nijcvkGSNOUD3/4wzzzzDONL/jRaMRoNKq+r6y4QWUmO8RBJrHCxlUa+Yk0iVIxki4zV6a6jOgQUXBueYluvsooWUBgicmITI4y+TgwIgRaJmgRoSiIZF69DAtichGRKresI0dEJgNrsXI8GIpMVu5LVt47QOUD5OUwcVQGmox2/kWyuUFaWj4Hao4VvYuroz5ZoTj2TZMvPx8Ey+O+C44JxbnlJSyCY0++H6DSI8dk7kUrLZlwLxCFnhh0a582U3RJhLsX3humkEklH8vtZPXyQTqBpSMHJHoY/FaWSSkz8x2iyGQUpbRoLh6yXqQTL5OdDGn1TWWj8BgcOEq6dgmRZ5ikA16yJgSda6+zeuQgLy+dwiK2TZk+t7zEmfV3Miokh/puJvaxbW7n4a9HyxgtIs6svAOAXEv27XoLgL7RFNeuo7R2Qb60gxoNkKMBB6KULO6jZYTSBbEeooqRu/86dx0BqdBRB6xFRynCamxZjyvvMBmRy5SB6FfnFksXXPKdCy8rA9w+ZVQFOA3SeRFJyUiO5W13C7ezfWySedWDQPXPIXzQYpqHyVYDoSY51izqdl3a1hTcmUhNPwNhkGjW+dWDRDCW19QzZoXnUx8UhtcYZtza6jqnlU3TwH7Wfu4VvJ0gDoyDYdPq0s3uN8yGdqPnF64f3peq/gTHmBYsmnVNHn6dah8Nv3s0yUS3Cgw3ndfdxq1oH2F6GzkN9XazjjCo696Tm6W404LFfvv6/ia+M7YkaBoc32wQqr5/7Pi8mgIoodzJ9wcsgsUymGGRSOsyTNUlbdsJHvl1buoaGraryi2QJoG7xrfTL7tTkJhqEvlm4NoGUfWpjfB2G27sEZE39utmYWn5HJqIBJ/BOOfU8nmeWHxkW+fjM0kvHjvGueUlJxOzAiWKiWessDFKFG4i3g6xQs0MDHls1VZttx2b9bz75dPa2AcBUgmk3BnXLM3OOI/7EXdMvGet5Sd/8if5k3/yT/LudzvWwxtvvAHAoUOHJtY9dOhQ9Vsdn/zkJ1lYWKj+Hnlk64apRYsWLXYy2vaxRYsWLZpxq9pHaNvIFi1atGjRYivcMQbRj//4j/O1r32N3//939/0m9hkWmc3LfP46Z/+aX7yJ3+y+r6yssIjjzxCQYIpGUQW4TJuWYVBILEVA2akegysYxBtFF0GRUyiCjoqg9jNOp4/8wLCGmeebLQzYBaOfWCEcgwjm4F1ZtL+mN7YGuGi/z5TmtIZCIHUTl5mAiYD1kupNMI6g2YjXUY1b9isTMGcuA48vKk8ji8e5Te+kmMQZIXkPfvOE3JCvvjidfbEKUIYijQh0QPSYoO50RWG8Vx1rYXqTswanVo+TyQKDGU2KOGyYhgkWcngEVgKHMsoEmBF5KL/JqKwyplbi7HET2KQwtC160SFY2j5svNlLKwhLkYIDLomG9wonGHx6WsPcWOiqDsPx8hyXKibpTQn61eQo0E5W2GwwSyY0DkHL3yFlUOPc6hkgW2FL5+6ymr2ML04R0nF115dAGB/vPX5HV08vimjxjrzXB3tQgrItEQISAsnH4svvUpermdWV7BXLgOgdq3SSzqkaR+tkso8UZSSQhMlWBVTRB3y2D2nomThCWudEXpgrqhlhCoz+NXNpi2ykk7mUddJQ+W47vqZTk1EcZdZabe7fQylXDCdvQJj5kVTBpWQXVHfbpbkqv65/n3i+hoYD00IjzfrGXMzl+NtQkaIZ3aE5xGyrUJ5TbhdWAbLZ88GNP7Ja9lKRtU0Uznr3mw1s3kv4VZmHGuqZ+G92077O42Rtt32O6xn4X6a2HDLZ882ygi3wxqaJTeb9czNej79vajXr2mMwTuNW9U+wvQ2chrqrME6qnthhXsPiUmZU9O620X4TgsZFLeyHTBB1lBrxQQB6qWl04jSjiFkEOmArf/i8gVy2yMWOScWx31PL5ESwmJQKIpJFlFDec4yZfYsoaZ1KoZSQ7vp2e3uWlWZ/GRnG9t6aZgU+qZZllY4BYWiOaGJsLa699vdf05Ch8FEsg+B3dY5etakv38aBTa4r3VWjnXjuFDB4c/b/99O/b/ZZ2QrhuX98A5u0WIW7kiA6Cd+4if49V//dX7v936Pd7zjHdXyw4cPA24m6KGHHqqWX7x4cdOskEeapqTpZvd9LykBNzCUwrgAkZUo6fxHjJUM6XI12wXA6ihBScuwiDGJZHd8lbde+CKJUGW2M5eaPhddbBnQCT2NChGjcYGoeupRi6hSvCc6Q+rcaYBVjFExUiYI1eTP4dz6Y+Mo0MJa57cCnD/zAo+ceGrTtf+5bwm1xJOCoaGOGKixfCZRLsVlP7vGIyee4rVTXwMmO9DLZ88S43wsKgqqdR2J2GRsWCfpyW2MkuXAvqSKahuR28iViR2Xl8SQymF1TdIalM6qF7eVqvRmcsu1jAnTkQphiaT7HN8Dqe4fPfEkZ5eXUbaoJH43gmtf/R0SnYMpkNZiorgKoshsiDCabPd+uhuXtuVF9AcnVxgWHfZ01khlxobuMtd1z9F/efEYP7GN+JUuJYPfWHrdnWO2C20FvTinF4MSmizqsvvaS5j5PcT791NcvwZak129joxjrNZEc28huhuotFdlEQTQcRcdd8ijLrlK0TKekIgB1TMFTlOvTOF4kBYioScy7TkpmZwI7o5ljgYRrHs3cSfax6aO8zQZU+iz49erB0x8oKXyWQkkV3U52DQ52naDSVsFtfx/fy71jup2g7NN59sUYPBykrp8rF4m4T7DfYUyjnr51bevy85myalC/6F7wWfD42YGQGEwZppEpy6r3C5uxeC7KdgS7tvfp2nrNX2f9bzU16s/M3WZVP1Zqvtezdr/ncatbB9hehvZhFl1a9O6YvrA9Wbq0rTg0Kzzm/X7NH+yWc9e2HepPH6gkj6dWHyMF5Ze4z3Hx+V9bnmJnITHF48CcHL5VVTZN/d9CB+0ENZOBKRmBYim/TZNllb5XSKgFhAyOzxA5OVe55aXyLjxbGNnl5cxRFU5h+MTKYL+lFXbDkKdXH6Vnl2rvlf2GOQ37Gfk3pnje+DvrbMFkSR2yDuPP87p5VdmBhRvBNvxxqrWbYM/MyFigdghEjPRSsxuG25rK2mt5cd//Mf5D//hP/A7v/M7HD16dOL3o0ePcvjwYT73uc9Vy7Is4/Of/zzf/u3ffjtPrUWLFi3uKtr2sUWLFi2a0baPLVq0aNGixd3BbWUQ/diP/Ri/8iu/wn/6T/+J+fn5She+sLBAt9tFCMHHP/5xPvGJT3DixAlOnDjBJz7xCXq9Hh/72Mdu6FixHRGVUWwjFAWRm/EIZmEMkqFOWRk6Ocl6pugmYzZKWmwgjHamzKZw8jIVVVInLaIyE5ckswnaqPGsERaFqcykI5ET6Yze4AqqGCIKx5YxcQejc0SkUSZzrIaS4eARMiaEdfIbVc7cvLh8AWNlY0azJhgrWSu6GCsxFrpRQhKNWE33YU4+S6cYkMV9Xly+gEIT2xEdM0KZgosvfJmOjDBSsaZ2o6xjYqVyxMB0iIQmswlK6DFt1Ev7bGkMXlJ/ldDjTG3WGRP7chNGV1I7rK1mMr1pNYASRSUT3CGB6y1xbHGRl5ZOUxBzevmVbWV7uPjCl4nzdccaM2XmBgxojRDOwBkpwRiS1x3T4B3v/+6Z+/zCi9fJTcRDvcvM66tcs/vpyBFJ5OrUpcsa2HoGyM9AxSInswnz8QapHJHaAQDKFiysvoraWKH34b/K8Nf+CfrV1wAQQmILjc0LGI0QKsKqGBG5+1x0dpEnPUZRj0x1KYgd80w6iWVkskpyWdWJkuGXRY4hJ2R/kzkmuP2HM6EFMQV+JtOZNUZkW17/rcadbB9hullqyJKpmy03yVL8f8/iqLOFZs2eTzN23GqmfhrdexYrYjsIWTtN8pomuZI/ViVPC9YPGVazrqOSGdXKImQUzTrn+jrTJG87HTdzz+qywJCJE9aJ7TJfqrJrqE/+83bg1wvZONOeuXC2PmTU1a8rPL+mOt70PDWx8+rrTNvXNAnV3ZhRv9PtY4gbYU3dDMNqppRwG8yhm4UVN2cM71jfujo3RUEmOpxcfhUpLK+cOen6yETYUq59cvnVUnYX0WUdLaJKmub3dSP16kYNrP2+DWqcqCKQ090LOLp4nHPLSywtn+P44tGtNwDOLL+MFILIji0crHB2D9gxawgc+0dbNXPfLyy5PlyP9WqZFuPxig2OtRWsmMwqba0olQbjfpvATCRd8X23RtZeja3ceMwa8+xGmET1c2/R4kHCbQ0Q/cIv/AIAH/nIRyaW/+t//a/563/9rwPwUz/1UwwGA370R3+Uq1ev8qEPfYjf/M3fZH5+/oaONdapyspfxAdtfOpriyAzEZl2jZE2gm7sKJjdaESUZ1VgCGvKrEcxhYydtAVJZlM0itxERMIFkyLh03K7fxJNp1gnzdYQpkDmQ0Th0nKrIkdJSVRKa4rEybV03KkymLkLcYGSKrMToHRGEu8CAV9fepN9+k2OPPHemeWyOorZ03U+Lw93L5LbhA3bpy/WiPMNjIwopAsO+BeJNJqoGJblKchFirYKKQyFiMltjLaKwkQo6WQ9vgwMEiXKTGQ+MCQMigJl8lK6564xlJBRdeoNViiMjKrfEj1Ey5ieGrFedND3EKXQCEVEPhH0m4bzZ16gr4conSHzEUiJjRIwejwINRox2phYdv0rv8XCt3zn1P2OdMw70/PMb7yF1AXFXMJ1u4d9/SGX1zvYbXaWfKaKr5x2fkIdOeLA+ktExXCsR9c5urerPPCQeM8CxfUVZFp6/8SRi/AJAZGTW9ooIU96DOJ5hrLPyKYUVhGLgq7YQMuItNioMgDiO6vWIIuMVKyiowSRlFn0ymcVnBdYrIfjLB5CUuAkkJEoqkxn2+3g3Erc0faxYQBa/+99UabJmpqCHk2D3/pxmzxYNvkNTBmcT+vIzzp2GGTZrsxqVmDLZymbJempf26SEE07/6ayqK/XFMTygYa6z9GNXPfdhi+j7Qxaw0AOjO/ZNE+sG8U0CeB2B9Oh5DCsB7OCTbPkmNOChaGM0KPuDVbHVgHWaevcTdzJ9tFjO9d8u6R30+TOswamNxPICp8Zac3M7FVhQLHy+BQCZQoXZLARscjGg/jQJwknH4txXp4j260mDyNZYIVtbHcbz33KYL4pqB+ee+WpZMfBISOky6x6j8CX6VZtkc8kF27ns4aFEOWYqArUiK09hObsdYCqDwU3FzDZJKGuJtj9mMBOZG6TaLSMpr5DbwY3Ghi6FZLj+w0yarOYPQi4rQGi7Qw8hRA8/fTTPP3007fzVFq0aNFiR6FtH1u0aNGiGW372KJFixYtWtwd3LEsZrcbRkiskJWhcyIFSmh0aUwLjlqYyIJ+4tguaSSJpGEuHtKXG449pB3bwwjH8LGBNMVZLTsz5lRm9Fn1PzjmkjWVBCbJN4jyAVJnYA1Yi9A5Ihs6toxUmLRLMlzHxgmq6ExcjzDaRep91LrsLO0t2UT9zgJ/lL2H3/49ePLQVY5wnlylPHZ8Mr/XX3h/hL/NZ5ffJBYZ2irmRlcoSmlOIROGxhnhKZFiEkm/nM3SMmIg51C4TFFD06vkY1IYopKq6hlbUphq5khgiURBXMp3lC1QpiDJ16trrMq2NCo2MsbIqJIFJaUUDcCURuNvXr8xQ7y7iWOLi1x84ctbrnfh9PPEJicerrgFQmCixDGGCkBKhNZVPaBkpAGkry9x/syRTQbmv/cNV84HO9fYf/EkosjR3XkuamcomWuFsfB//ZOvcnbZVPV+K/aBv//z9hrdy6+AkOTzewHIurvHK0Yxcm4OZQwijpFpWce7fWxpUG3iFCsUWdTlCvvBQKYTtBUYJStmWpq5Z00VI6Qpxs+UNSXrLcfIiEjmVbay6rkX0q2PY6hJYSq2X2TzCer8/YwmZkqIUGoGY/PlcL2QsVJnF4XMhlnysSb2TJOx7rRjNF3TNHlYnV0zzaC1btIfop5xqn5t9fKqM5m2I+eZdo3+cyjnC1G/F/crpmUIg82Mtqb/00y76xnuwrroGVs3Kslpegbq59q0bJZUYlq9rte1cP2metT0DE3DNMna/YpZbMXtrjtt/W1tV5OTVQyYhk3CzE+zMIshBq7f/NLS6fLz5nd/PePjeDuFsJaYrKyTY8Picb0pk0lgyFXqEsYI7SwJCNg9UFkR3Cym3jskAj3BotmKNbUTITGN9SCEQmMCo3QvyfdysLERtEsGs522YPnsWXq4rG8+8Q5sbn8NkjPLLyNw/axZkrU6iyhkcwlrJuRrEoO20YSxdqMMdgvZWNPyrZ6NljnU4kHHfRMgatGiRYsWLVq0aNGiRYsWLVrcerRZzB4M3DcBImmd10isS4aBcNHuLOpW6a2NUERRQbc/JLcRxkpn1itGpGbgGC1CYgATJWgZT0SPpdAkZChZEJkcZfJAe+3S0SvjWDJRMXS+M+EsntGQZ6Cdf4w0GpukjlmUZ+N1oPIsQghnSkyp/Y5Kpo/O2L9rlV7pXXQ92sdrG/sYLF/gXYvjVLAhBJYN02ePeYss6lYRci0jNkaO3WGsJItiRlGHSBSTqUKBWBRVilCFmw2CcoajXC8SReABVVTMqu7I6ZhVPnT3CMccMjJ2TC8h0SpBywgtHItoKHooCgzO/Lqwkt19Ddx46vi7hYNPfYDVL/6Xxt+uf+W30FFKHPeIc2eS7pg1HbAGYTQSxvVD54jBuqtDZb1gNCLNNzbtu6MK5uM1Hlo5hXrzFejNU/R2MdKOgVUYgRKWk9ce4cnd5xnSJWG05fVcXJ/jsV2XOHD69yEbQm+eUWc3ACvdA6SFO5fO/+n/yStnTnLw9OdhNIL+HAB61z73P+liVIqRalM63UhYYlHQsW5fnlmlhuvIkVtmlQIZOfaZckwzrRKMismj7oQ5o7DWKe6twSqJERJhLZHJkNbccjPQnYyQbdLEaqmbL4e/+9+a2EfhtrO8iWb5CczyPJrFLPL7mOX3M4tJ4hEaDDexfurHCb1gms6tXkZbYRrTqD7rWj8f/30rL5qdCM9Ka7o3lQ9Pw3Yha82vO60u3MgscFN5+nq9XSbRND8rv1+PsP7MYvls5fXl15nmEzbL82qr4zyoM+izrvtGWUU3c9wm895qnRnp4GH7DCNw/T9V9se2w5bz7BSLQOIY48K69C0iYINoOWZ6WyuIKCbesxbpuriYsRdNwPSYdY03W9b34nv+2OIi55aXGs/9/JkXENbdgxhBrjoYIVG2qNYZ1yfvzzrpvzSrLI1VKIqyPz5uN3yfybcPAouyeWVCPgt1NmgIKyQRYz/IY4uLnFl+efz7TTDNRMCqmrpOAwN3W95YDwCzssWDi/smQNTLr9MfKJTO3CC6lGh1ohSjnBmuKaUnWdQF4RqARA+JdIY0OcIajHJF4oJDLmihbIHUYykVMNFQuu/GDTZNgSoypB6NO2QyQiiL1QohlctOZS3oApGXHbpsBLpwA/+igNEQ64+pFKQdBCDKQbYwmof7L7GRLtDJ14hGGXkn5oXLR8jtm8yJ1U00WiOkk4qJCGk1VgiXecJGjAp33SOtGGmFTcaUTW1U9VkJTUeOkMIQi6y6/uplUTbgsjSgtkJW5sJR7rJdyXyIMBqddCvpjzcE34h3URCX2eIEuYkBFxTLjcIYQXEPRoznP/h9E9/X/vA/Y4UkzoeoKEHqfNy58nRoIUFYFwCJIicxExKSDgzGGSVQit7q65xbXpq4591oyEJxmeSrn8dIiUxcEFCXHS9jBH/5g4p/+dvw288cAOBH/9yVLa/l8YUL7sP1q+XF7UaZnMu9R3h14yCpytn7+V+l9+G/yqMnnmT12jnUYK3a3qgy26BKMcoFAtN8g27qgjyJcB2EVA7pD8pjCIHaWEGuXYM1FywSUQydLkJFoCKUEIi4g1FJFWh1AcjIdUbrAQ8sSeECw91ssOV138sIB4phR2+ayec0qU59f+G2HltJymYdL9ymvu/6fn1gYdq5NQUIvHTIb99UTnXU9xN+bzKIrq/bVD5hICTcR71c/OcwcBWiHhC614JDHk2BLX/NTQGO+nZu0Noc/JgVgAr31xRgCbffrtys6R7U60H9XKbVc7+8bpQ+bb16WU0LBofbN11z0/oPCm72upvKcavA+LTjVZKZ+mB+i8FxJSNqCK7Ut/XrSEw1QVO1NWyW4048g6UBstvGBSgik9WuXVZ9GoElIqukXiPRHSe2mHItQthN1xEGpyaW1/RXFneuCpd0pm7UfK/h6OJxlpbPTSxbPnuWkdhNRw5QtqCTr5GrSauK0F6jXpeAmW0SuPoXZlieaFuwHDvm1vcBLNlwjK3QdC/DrG2yzJIshHUBU2s21eVZz8V2gjg3+szfzORPixb3Gu6bAFGLFi1atGjRokWLFi1atGjR4tZDKoFUO2MCQeqdcR73I+6bAFH3+mukSYQsylTYRV7JcGzaxSYdTJRQJH2SuIOWLu12HBomC4m1tjRJVpjSODkuRojSfNrIaCJK79O2C6tdenKjHRtJF6U8TGEBawqEn8Uo5UJo7aQ34BhDRY41BrTGDAbYQjsWkZREu1zaVhm5WyasZe7aeTrp1epc5tMVjuxKefHSAYbZIb562fDE3jf5puMPVevEZGgZo4kZ4kyqtVXMJ0OGOuFQ9yoX1vdzZdgnUZrCSLJCspG7sujFmj3dAbvidbrWyex8CnEv5ZNGV8a/EzNNpcH2+H+BiVJ0lLCaOtnRiA4buts4A1aYiMJIrq3dm7NBg9/5t4i1FTbe+V6669cw3XkwhuiV06jRiO5/99+z/ge/VsnMALAW4eV4yi8zCC8vEwKsIbp+iWhvNnG8hwdnAJBz8xRXLiOLvJqB8/hfv2CwVpLEbt9KjKnJdUaSR2zL4xx8CK68he7tYq2zj8v5br5xvkued3jn4++iV64//61/jrUv/DrS33ejKdI5Rul8NfNipKrMzOPy1kc6w8gIaQrilUtuYZ5h1tZAKWRqodN1z1gUV8wrgSXKNwLGjELHnWpGMy4G1XlE2TrCaPLV1W3dw3sZ02Qm09g609gIdSZSfZlfN9xXKJOaxgaZJlsLzz+EN4+extppYkmFv3nmyaZZ04Zz3045bvXd76duah2izhTxbBXPXAnlbF4yV28pb8RQeScivMYmOdZ2Z2v99tMYEeE6dQZOWEcWjx3bdD9mYRrrbhqzpJ6yvmmdsK5PY+HN+l6XRVb7bECTxPFBYhO9HSbVjTIJpu37Zg2bNzErwjoXsEkm1rXN7XCdadnUrknrmLpGKDLVnWCDRCarjJITL4Evj5OnCQZvzxAkkZjCDAlZK8KaMct6WjkQnqucvP57tC5LDC8svYYUhtzG5GaBrhqiiShEzGNPPlG1j2PrC4GxY9lXaPYMk0yzJgmbQk+uU7YFnqHlWUdNZTur3QUwyEb5l2VSRhYyOKs6s4XU7Eafw63W3w4TsEWL+w33TYBIvfUaMlZOumUNNsuwxg2kRX8ekSROYrMARdxFmtxlKZNqIpuWKemURqqAAmtcdjRrsTKpPHi8vMpIhfCyHWmQRiF9A+33XzYwKi8DQnkG2Qg7dINVvbrmgkHGYLVGD0aYPMcUGhkpZOzOS+YZpB3QBWrlMipawUpFMb+PXnadfUnMcC7h2iBhdaD40oWH+KZyjG+twKCwSAoihiatMlL11IAPPLEH6PMU8NtfH5JpRSfKSRQsLlxhw3Q5c2kv2vZYWFhDi4jUuBd/ZDOMUGgZIX02N6OdvrwsX5k7CZHIM2zSwUYJ6/2DAKyYXQAMdUJhoiojWqKK8h6UWRmkRU++4+4ZFLsOILsu0GfTngtY9vYg5g+w9i//Z/Y/9G9QxkAZrESVckQpMYkL5mEtYlTKocrfiBNQin2vfQ2CTGYTtGpjXf0NXnSmrN9KQhSXwZXay6+JdnzJHOCgeMMFOOcXyHp7WBMLJLLg9OlV/qe/M89LS72JbfLugssQqDN03CNL5siiLrlMq0BiwdizQIkCLWNGUY9EDyn6u4lWLkNeBpmUgiTBzO+l6C+4jXyASOeo4TpCF+56oxhZjIJ6OELoAjHacNdgNGptnQcBTfIraO70NMl1tgq6+GX1TrgPDtUH4FsFipoGa3U/nmnHbtpnU1DL13Evaapfd1MQqZI11YJf9bKol93E4LwhiFAPelWBAyEaJUbhsf3/G826tVNQlSGT9ym8Lmr3OpTeNQV7vAQtLKM6pgVzmu5juI9pvkTT7r//zQ94wn2F5xne56bnIzzHab9NW9dfg5fkhdtPCyjVt3/Q8Hauvd4u3ci+biZQteVANwgOTas/9ecgDJJKayr/Put7ZWWGK5gMBoTZ0UadHso6P0rvUSjRVUYtoMo4Fh67Lh0LPY62i3rwQlozdfJrJ8O3EZlNkRi6asi8vso7Hn8355aXeP3F55BRj0IE3k+Bh1U9OBTC14etPPpCWCHGksaGun0zgbiwDaqfi7OscM6msqwn23memuSHN4oHuf1r8eDivgkQtWjRokWLFi1atGjRokWLFi1uPYQSiB0iMRP3oPH8vYL7JkBkVq5hktixJIzB5o55IntdxGjoDKCNQcyNHfIdtdU6poUs2T6BXMoI6WQp2DKblGPEVMwhIcmVM1Cuu/x7VoRfFpsRSTGgm15CZQNENkRefhPRn4fREKQADdbP6liDKSVmsttB9vvupDtdiN0xKTOdCRUhiowkW2NOKDrRbqLSCLgIJg2OLx7la2cuVpnHOnJUMYieOn5kojy/4z1ORvfcmeu878QBwB1/Xp7j3NoRhiZFKIuILYkeEBcjF9U37tqVyZ00KFsnGjhTYbk6NhzWcYIRCmk1G/Eu1keOIVNYiRIWJTUdlREJ7TJliPGMVRLDy0uneOz4EzdZW+4O5j/wPYAvyTEuP/8Mcb+DufASstNxTBg/+yIlCInslbIuY2A4cPVZSohi7Lxj0JjO5J7Pxk9xWL5Gd20V2UkhctLJXckG10ZzrA0dy219YNm9O+b69XxixsYIOTHbdnL5VQBeWz3EgV1vYpMOujvHc/KDMIBvnO/wP/0dd96xGU3MiM/HXYRKEPQYJvPkMiUXKQZJTElFL2eFLLJkZ4yZaDIbQjbEjkaOGSgcc0p35xh19wDQ2XAG22qwhrzyBoyGCGMhSZBxUl6Udiwko10b4U3SB8O3c2t3PKbJsJrQxF6YJpepS16mMY5Cdk3T8eqsoFnynJA1Mm27JtnQtPP28CyicLZ/2mxqExOlziypn7cvhzq2NQsasGHqzA6/LPztXmYRTUOT3KmJLRbCS/DCMgrvk2crNTHLQhbXYlA3wmNPqwdhNr+tGHPh9XkGVdNvfrv6PuvlM+17E5qe7WkSthY3j2ll2CQ73M664fpNaNrXBCNnyi2dxnwEJiSupmSmWOlYJN5QOMQ7jz8OTLZFy2fPkquUyLh+eJi91ApbyaEExvX7AsaQLfvjjddbsf23rqueAXUjbJmdgs3tzcOAY9esxwtOdmWppFjg2fezmVdVmxLIyVz2sLjKKjaRgS5Yb2n5HLIsd2lNxcyqM3SBqe0bjOusr2fKFpved9W6Jdts03t9i/t/L2axa9HibuG+CRAJFSGS1A34SmkZQri/xElwUAphLUm2Rp70nUN/lOJT0TvvIYkRikLG1cvICJeK3bex0mrX5MqYdZxkaKhTBkWKtgJjJYWRGCswFiJpSVRBN8o5sDBPN18lLgakSQd1/VbeDZUAAQAASURBVBL0+kTgPIi0xmuohJAYrYn3LCCSBDG3CzO3G0p/GlFkYA3CWmQ2JJKKVCo6nYxO1KGTSIQQvLD0OuCCQOtFh1TlLETXKWyMFIYnFh+ZWq4uODSGQZFEmtW8lDwpKFRMKjYqPXqsRyidEY/WiC9dgPVV7GiILa+J/hwyGSDTfrlPWWXWAkhkQaIyEpHTEU5OZYXASEkmIuZ7hlfzI6wtvT7hr3Svov/1/8po/27yi2+RHD5USsssNhtVdZNrV8Zp7Y1Bdnul1FBX0qp65+lbn9jNi8trLPyxbyc5fwrbXyBL57m44QJKSlrWBpLRyJDnlvp72GnZ3T5fWHoNSm14N9ZoGZPP72Vt7iHmGbJ0eTdXrmog4sLp5wFBp3CyrYKYQiYVxbmQSZnVJJ+knNtxthFpNJF22e6Uzlxq+yzDFrmTy4HzF5Oq6mTKrNzP2jXy8+fRGwOEFMgkQc3PuXKFsX9TdaFyS0+Dex3TZAT1gadfVg/6NP0PMUtSA5slZvXfq3TmMwa8TccLZWF++bTzbAqS1RFKffz+b2QQ4WVQ4fGmDdbC35qurY4woFGXX83a7n5BGLRr8uwJ1/GfPaYFBGfVyXC9MOCzFepp6+vHn5Vpbqs6Ev5ev/dNwa0QYZCqyc9pWrCiHpRrcXtwo89v0/2q3/tNQcRyAD1toDyt7vh2cCzFdcuNVZxYfGzmeTYFUb1HZTigF8agZYwREmMVRjiBVF1WNmuQP+u67neMbIeOGKCCiTbYLC1rCgY1lY+/r+eWl0p5l5rw/gllijCeFA/hsqe5wLe1ogok+e2nwQpRSeWquo2cCHaFcsnxOttro29U7tmixYOI+yZA1KJFixYtWrRo0aJFixYtWrS49dhRWcxaVthtw30TILKPLGJ7XTebXDKFrBAgJHnk5CVGJQy7e8iiLiPZJSdhaFK0UY71YyXS2zhbU342RKpARmYyMwKCwkZcz+YAWM0SXruSsDG0DIeWldUCrS1aW5JE0ul06HV7HN6/wFxHs7c7YOHAGulBJ21ZGL2F0pmTsumcePUSEbiMVlFC0Z0nT+dY7+xFWENkcjqDq6hiiNpYcUyLwSrCaPZ13iLqaTrRPCvDhK9dfAglLc+/ZXjX/iHvPXGQn/sve/mJ77vxB+vxxUd5HEcrvZTvJTNzSCAz+4lkQSw1u5JVemqFKB+gXz7H4NU3GF1fY/4xx/ZR/T5qsI6Y24OwTj7WUQW5UQhhkMJU5TvEZcbITcTVoSvrNDJcuNbnDdXn9a+N+M73pjdfcXYARhcuEB/YD4CIYscky3P06hrF2gb52jobb13HGouMJLsee4jk4D7UgpNWmbRkcwnB6hf/C5f2PcH+K6eZ/9Y/x7sW38GpZcue7j6upQe5lO3h2kbE1VXJ6pphY1DwP/xgxN/7hQ2Gg5y/8ndf5xM/ajm+eBRlC3ISBraHthKJRWIY5Iorei9X5/dwYWU3zy8DGISE08uvkMqYpBjw0LveB7g689qpa2ghsUIwN7zszlsotEqQxhsOOrYQgCpGxIPriDxD5CO4egmbZYgoRh445LbffQBZZPRW33DmtXlG8dUvooHT//EPAIi7MbuO7Gb/Nz9BtHsB0Z9HH3aMOSsjJyu1BnOfZzEL5S0w3VSyzkCYxiaq73srplGdNdHEdGiaBd+u/MqjzgppOt+maw+3CZkZizcoQQhny5uYJE3n0CQfaiqXpusNKfj1fU4zUb7XUK87dZbWtPrqES4L5V+Lx441ygI9/Pfwt1AyEbLiwsx0TXUwPJc6S63pmOE5T2PShcf2ZTRNMlZ//psYUeH3UE7UwqGJydXExLzbmHVOTQyLrdifHtVzGCzfij1URyg1E9ZWTCJwrKKoyKvjDqM+BTFCmC2zum31nqiXha/r96LMrI6Xl07xev4QR+LXSbMNtIwYRn2kLRO82Mlxi0FWEkOFdlYaViAxRDbnpaXTWCEnTLxz4frYno0khK2sNgCOLh6v7ulLS6d55/HHXRnjJG/SmkmJ2hSGrxWCc8tLIOSm9vH8mRdAjhllVXa6hixr28GNsHdbtHgQcd8EiLL+Xoq+882xCDf4Ey7DwjB1kppcpayyUAV1tBWMiohcO4mTEpY0LmVSUiMFVTYtJcr/Upd+KRaNJJaaoY4wRpAXkOUwyizDgSYvNEVhGI0kRRFjbcTaQGGMQokOxkpS5Qb3WZKihNu3EgW9ngsYKFOgZUShEnKZMrRdpDTEUVYNpkVHuyAREqlzkmJAmozoRgk6FRTGNaRrQ8kzZw/yn5/VXLo04BtLqzct0Tq+eBQZdCBfGx2mMBHWCtZFD60UZl5x4PBDdIocESmi3e4+yL370IceJU/nyVWKthHaCgorscadry97f58yHTHInURoVEi0EUhpMVbwf7ywxp94au6mruNu49XTX2deKWTX1QMzHGKHI6w16OGI1fNvArD+1ipGW9L5lMGla3SPH3XZywJE69cR1y/z0OvnYG5XtXzDdCmSh3ljYw+X1xJOvWQAw+r1nMEw58c/ZRmsZ1hjWbu6ytAeqDyezi0vodDkNkKW9TOSltWsS64lb15TiLLT8N9+8DxvZfs4Eg8YxPNcfOHLABx86gMMo7E/kooKomLoaMulT5c0hZOYSYXUOcJqKHIXHMozSBKXuQywPSfrFHmGyoaIovQVGw2wZZazdL7D6htrWG1JF/qY4RBYcJnP4g5F0qeIOq6zay2DTc5Q9xdCz5KtZFt+/fqycHl9m1n73c7v2w1CTVvHn0fds6C+rg8MhEECP/DxA+1bJdmqpxOvB4SapEvhefp1w9/CoMR2Bqn3+iDIy+o8tgqg1CWGfpsJSSKT97YpEFKvMyGayrIuwfFbhMGjEE0SxvA8pwWZmqRfoSdXff1QjtdUJk1Ss/p5TfMBeVDQ1G5NCybuJEw7p7crrwnr2M22Lb4dM6jJ8zRjj9BYjyrJ2VaY9r7aaht/DQJ7z2U1A5cp7qrdhxKWpBggjUbL5mGd72v54JAspVrC2gm/JxfUGQd/0mIDqVI2xBwJetyGBC3zy0unQMZY4TIle982mN5+ND1Dvl5YK1haPocQtmorLcIFFK3BCokorT6c7HpzFt4b8Rtqeu+2mA4hBULujDZP2J1xHvcj7m/jjRYtWrRo0aJFixYtWrRo0aJFixZb4r5hEK33D9DtjONdueqgZcRIdlkzjl2SFQlXhl2GuSIrBNoIrIVCOzPpNLbEuSJRliQas1iEACUMUlq6KkeWMihwVEslLLEy9Dqe7igZjRSi9BiWUiCE8xiWpW/2IFcoGZNrSawM1vbH5m9YNkrGhTd+y0wMGnKjiIRhPrIMkl3VzKEsHJvIqBhhLYqCTEcksiDTjlklJWjjNokjxZcuPMQ3vY1Jk3DmaFAaYV8aLWALQSEjchWz++HjxGmHaO9l2O+kQcMD7wTgcv9RAEY2ZaRjBnlEYdx98ZDCnXOuRcVszgtR3hNLP3bX/etf1nz/B8aZG5ow/C//FIYD7GhI92M/ffMXfgux7/xXKXpdZ7wsBWZtDWssQgqsMaQLfYZXV9G5QUhB3E1I98zD/G5sFIM1yOE6oiiwb77K+rlXkEqRHj7AS0unAUjEPK+t7+XVqylXrlvWVnPWVkasXh8wGmRIKShyxwLa//B+BJZCOoPAo4vHeXH5AsZKYuXkkOuZYj1TvHVVsr5h+Mvvd/f++OJR7PLL5Dhm00ayi0LEXFt+hcJ20bgsgV1WySPHmBJYpCkzDmo3eyiMJhquIXTusrUVuTNmLxlTViqIYic/u34Zu+HMsM36OtHuBYpr10nnU3RWIKRg/eJ1dr/vSZf9TCoG/YMAjOJeOasmGWQPTqx8FlNomhxrGouhab36vsPjNjF6/G918+GtJHF1aRmwafuQOeURSoZClsZW0rSbRZORdMX8qF1HnQ1Tx7QsaHWGVNN1bkdqFp7nTmAdNdW/pnvUVAYh0ypka/n1Q8lMyDwK0bSskh+WErUwW2P93Ovrw6QMbTGQh4XbhbPu0567Wct9+YRZg6Zdi18SyvD8eQI3MA9/b6MuT7mVbcBOQxP7suk3//s0FtXbYVqE7dHy2bMUMqZuSC2sQXBjsqFZ5zT1HbWNy6gzYXZC+yiwrOdd5uINojyrMjBD0HbWnmBvLi2wZfmO4bM3g2MnxWbEVXWQRGQotBvfiM3lqIkwViFwrPBQEmit2HwOtXd7+N7y52itM9Ku2iEZo8w4o9qEyXndyLzMPl3HNFZRyxhq0WIz7psA0YbcxWo69qIZ0aGwEet5h2tDNxgdZIqra4rBCPLcUhRuIC6ERQqY6wsW+pZRIQCFlE5KJqXFCkkcBIX8f4UmUa7h2d1XdBJJvytRMmaUReS5xVhLmkj6Pclc1xArSxxZlDR0ywCHELbMfObkbkM9lg9pK8j1OPihyvMoVESRJnRUpwwMOeplFnXQRHSijMJEeCagtWCty1a1vjZCye4tK/9vOv4Qy2fPsi8VvDVYYETESMVc2nOchXSOeO91hnMuI9r11P3PbEJuIzKdsDqKWRsqRrlgOCqvU4GSlQqIJLbV90hZImUZ6oh+POKdC5f5ra8tVH5Ep5dfceVaviRiO+Jw4lLIC63ZCXjuzFu8a22FaGG3S0E/HGALjYgUIoqJ5vqMrqyQLsyRXh8QpRGdPXOk+3ZjO10nx8py7BsXXJDj5fNcW3qVqBMzpzV7VlwZqPkjnBwe4vqq5crVnLdeX2VtZYP162vko5y016HT6/C//uOjAHxj6XUyO36WBBZjJREukPP43ksu+90+wfmVvbxr8R3VuicWH+PU8nliMkai657BokdhXacjlppR1HNSSpOjTFHdYCtVFejUcYd4YxWMqbKPUaa2t0kHKySyyGFtjeKy8zQS0Xi9KI3YdWQBISXz7zhAcfUa8f79EMXkkbu2QiYYIdE2Yih2Rp24XZg2APZoGoDXP9stBtJN29b337TvMEBDrfM+LZhVDxCEMpr6+dTPsx6I2o6E5O1ilqdLvWy2GvjXz68uQZsmmQrlIGF5hdsIbszH4XZiu9KEcNlEfQiCg011qwlhUNGvF8q1/L7DwaEv22n7axpI+qCQDy7Vr7X+jIX1o2n5NEx7Hmc9w/Xr2yn14U7g7QwUJ7xQSnL+lunFy76k3YZMYisfnpvFrHs7Kyh/K9HkTXSjmDYh0LQe1LyZhNhU7+vSTMHmd9Ldxkh06ccD+tJlcHWSvOaJ0q2eYSOc3M9aJxMrRMxIdYkokEzej6p9LOutRUz4Uc3K1FhHvY1cPHaMk8uvAhCTVX14P74xQmERRKYcOwXZ06pMvuW6twtNGdseJAglEWpnTKo2BQJb3BrsjDvcokWLFi1atGjRokWLFi1atGjR4q7hvmEQreg5bDFffc9MRKYj1rKYQSYZZpKNIVy+qhmNDEVh0NpFHpNEkqaKOFasK0kaOyNeECjl2EWRNERyLC0LIYUhkgXzqUSImG5iiCNFoQV5IdEGIgWdxLKrWxBJixKGTpSTyIJEOtpkJmJGOkZbxbAY35rCCIwZm01H0iBlSmEluYoYRR1GUa+adRmJLiObMiwcCymJDINMsjYQZLmtrv2H/vStvQd+JnpY7EOXMwuXi32IroHuQXKRMjBdRkWCtgIJGCDTEa9ectd7fdVQFI51BTDfV3RSt69ukKwsVpa93SHdyNGNUjniSO8yXzsTkcoREktXrxKVlNT+6uuY3ryTJUnJK2dOMpBzdOwGjx1/4tYWxDZxdPWPYGMdul0YDTHDISKOkZ0UkaSITsrcYoRe2yjlUZJ09zyy03GzWKUES6+ugRRk19fJ1jPmH96HHgzpXziFPvAwql9gDBQasqHmjZed8fXKW1dc2SzMsf/IHv4f/+gav/D/2k0iMnIbV+e5Ybp01IiB6aKEJpEZhY3ITMze3gawUK37xRevA7uIVe6kaiZioOOq/qZRgY0kFjBKIRiQi041M6einEiPSDauumyEpVwN6TKgWRVjVHluQrqMb1pTbAxQnQ4yjhBSsPDOw5hCIyOF6nZIHn4YABsnxMWIYdzHCElhYwobsWZ6t/t233VsJRML1/O/TZOETdv3VjOssxg+TWyHaeyaOqsmPK+QEdN0zdPYRuF+bscscchcmiZ1mCb1q5sJ16V5HqHpdX3/leSo9ls9K1iIepauO4l63Zi2TpjFq4nxMI0pU68bTQyucH+hEfU0yV5oLj2LNRaed92Iu4llN61+bFVfm5iA9XJoWr/OuHoQIK2pmAFbsS2cbKbMolSXz3jGwwz2UCihcTz12cerGwffLjbRxDG38a641e2CtU46dDPsj6b27kaxlWF9uO9w3bslN9swXbpySE+vuKywMtrEIJr6zi4Nnt064/J2ygjHFvcMoZDpZq0Y19/yGZBCc255acLo27eRMngOprGLQ7xy5iRdoRiJMnGLN6AuZWU5ScVoUraY7J9YgZZxdT23kuUTMpnch62f2xYt7mXcNwGiV67topvtwtixr5A2MBjCtRUNaNY3NJff2iDPCopcU+QaKQVRpJjf3SVN+igpywZQkkSWTmxJlCZRLoW7xcm9tFVs5DHGZwQQlJIx17CmSlf9q0iayqsokUXlYTSv1kjssMzWEDFUfSLRZb3osJGPB+jGCLR11+MaJMlGFmNjl91LiS5KunTzoVTt+tBFVNaGimEmWF23DAaGwUATxbeHPGaQHN/1Gl+9+AhZkTLII64qN/geFi5oZhHEyrCnO0IKgzaSKIKVNYvWliwzWGvpdt2LLimLQkmLlNCLNd24YFfivGc6Yki/uF5lOKjoydZWmd6KpI+OOkiTIzt9Drz6nPO4Wb3G8NT/Tuf7/u+3pTymYeUrnyNZuYR96FHEyhVsXiCkRO3fD72+89gBpC6IioL00UfAS+OSBNZW3Isqz0ujJk3vof1E3RSZRCR7FiDtYKKEC/YxIgVXrmTEiaQz12X18nWEdHVg9fJ19h7aXZ2bpwp/felN3nP8EF05ZGCcjxUWtFVoJInMef/jeyeua6DdzVrJOlgLuZbs7W3wxsYcGyPJnr5EJTmqTMEKVBnOdNkcKQoGyS56o2tIXYA1pVbePWxGKKTJK+mZyQuKwQiVJshOB9nrkrzjHaVGUYGx2D0uK2Axv4/Lqcvcl+uYoU7JTMT10fqtuK07Glt1+OuD43DQXPfRaaLyzxq0TgsebXfw3rSP+v78701eMHWJTng9/vdQ5nC7UA8S1c+zLh/yy+pp2MNtm4IjTeXqrzMMYvh16/f0dgbKtotpQcf6eYdZvJrKqCnQGS4PEa7b9LuHD/4cW1zcHGyDCY+hadflM/3U5Y5NQdDw2mY9M3U0BVDDYzWtP+23+x2a2KVVx2zypGmSjFUpv+3YC2VasGgsgRGbthFoQu+dcUYmM7H9xKB3xmN5q+QvW00G3A4IUQboEFUadZ8q/ZYfa0aAtP77Vm1iPThyJ/DKmZMsyJhED1CmYBjPoUU08/74gI/B9Z0K4fpr9eBHaKMxbT9CjIOW1oqJbHO+faxPPoTnZZAcXzzauH8jFDGu716vy5lNSMVowm9JWo0NAjZVprMZAd+ZMkTCez8Z6DVCYXx7IGZLfO9XSCWQame8I2QbpLttaCVmLVq0aNGiRYsWLVq0aNGiRYsWDzh2BIPo53/+5/lH/+gf8frrr/NN3/RNfPrTn+ZP/ak/dUP7ePOKIFkXFaPHWsdGKQrL+nrBaKQZjQo2VocMN0boXKO1rpgT8wupy5ZVOGlZpARSWIa5ohPlFEZW0fcsMIyWwiWgMhYwLmIdScNCZ0AkCyyCwkSV5CpRGYkoszUFs1GxLp2ZJRDBWpYy0qrMsCYoSvJIrFzGtF3paCK6r41CA4V17KLVYTlDoAWrG+7YSoLWFqUEvd7YBPtWIifBWsF7Dr7O1y8+xAhZmUyvDtz19DqGWDlZnrsmw0LfEClJMafQWlGSW0hjZ0gdR5ZObFDCMpdmdFRBR7isWqnZoJOtuOLTbp9GljMLZmyuJ6xx0X4hsCpyzJQopth35LaUxTS8sPQaj43W0Z0+VipinSOUQqiIYvfB8mTLQhNu5lBYA9YiTIEoCkQxcmbbRhOlHRgOYN9BEmOwUYxNOqwtHGGts4/IFKwNJHt2x7x1aUQ+yunM9YjTBKkUuw/upjfv2Gb//b8a8Ykfdp+tFZxcfpUnF9/BV89cAkAj6cgRHTSPLz666doOpNd4fbCXQa7ItWSUC64PdvHqmxawfOwHYt54cUhv4xJZMscwmUdajZYR69oxzYyVxHKOopuUFGJDUrh7LTBE+QAtFcnwTeh2EVKQ7p4n2r2A2rsP+vOY7pzLfCYlGEM2t4/1vjNHvzJaYCOPGWlVsQ3fuLKzTapvRRsJNDIpmmYc68yDUAazlRxq1szsLAZQ0/GbpGXTttuKYREiZAn53+vyrO1k/boZNGXUCs9lGmMm/H07aLqnwFRJU6O8jLvDJmkyqN6q7kxbv4k11MQqamKt1fcdGtn6//XsZB5N9afOTqvPsDcx2+qMpiY2QxObbxY7atq1bkcCshNxK9pHSVFJa+oQeLbQZlZLyHCYVlLVcuu/T2f5SKur3+pyIZ91apYEq2JR1Gg3N8oqmtU2w52VVVkhXEKLTcs3l8PUTFVBeWynLGYxqCa+WzEho7rdOLu8jLSaQnaIbI4WEVpF5ML16ev3feL9Qfnsc3P9nTqjyF932E+Acd3wjNWl5XNjNly57vFjm9lDS8vnQHY2Hcu3WceOLfLi8gU0ihG7iESZAbe0/lCicFLR8s9tLME2s/c8ptUHxz5yz6BnuPsMap5BOI2h2aLFvY67HiD69//+3/Pxj3+cn//5n+dP/Ik/wT/7Z/+M7/3e7+WFF17g0Uc3D0CnYTCwDLPyJS4d81FrW2XtkkKglCSKFWk3QcdOxlTkmm4/ZTgomJ+L0NqNKf3AMZPOIwdc9rBYGZQ0GCtRsmyAjEQbl+BRCVz2M2GQWHKrKsmXEE5tHjZGuUgQ0hBrt6814+Q2hZHkhSDXgvWhrAJEncRlNdO2Qz/OEcI1pFnhGrFrg5jByPktgbsOE7SFnY7kf/jB23fbV/M5tBWkKuf4vqucvrSXNHLXFkcu85i1LqNcJDvEyl1YP9HEypIV4zT3SlqXsUy6C4ikRUnrgkNqRGxdUC0yuZOTFSNkKSmrulXWIgu3nigKhM4RRQ4+cFTkzP3x779t5VHHxRe+zMPDa+i0TxF1XMp2qRD9DCsVw76TQvmXmxUSKxTCapTJEUajiiFCF+POankta7sfcfRXqdAiYkXsYaPocm3UZWXdsr6hyTLN3kN7KHKNilznqttPyYYFC7u7fOKHU84sv8yJxcd474mDnFl+mTPLLxOLsQHUk4sPT72+gemwO93gHb11FAVnVt7B61dj/t4PjOu8NNrp5VXispnZgrgYoZWrl6H/0bgcyu2txKgYVWTk8/uI11aI9+5x+z30UHkAVQWHdNLFqIQi7vKWOAzAm2s91oeSUQ5FAdrAtes7lyZ8q9pI2FqG5JffiKfJVkGbenBn1iB0WgBkmvSmacA8TZo06xxDv5g7MfCZVo71DGvT1r2RDmn9+pr2Oy3Ycqc7vvVsauG5eNQDOk0BDhjLHJpkVk3lOC0oV8cs/6Gt0FTPQlla/fizrnHWMzgr+NO0/xA3U8fuJm5V++jTZtclJeHvHpNBIbvpu19nVoadrX5zMqta9qgZA9ntLJuFRnnmlGu73XIqYcfXL7AUxJUcClxgQgq9LXlPVZ9vheyuIducxNzRYJlBokWEoign1+KJ37cqk+1Koqa9p6e1Fx71APrS8rmJANqsiZfji0dZWj6HQfH4sUeriZRwwsbvK6ybmU1cpl1RoIQubTzGEtD6+Vpm93GM9XLOzQFIVQalwu3llDbjfoUQAiF3xvtBmJ1xHvcj7rrE7FOf+hQ//MM/zN/4G3+DJ598kk9/+tM88sgj/MIv/ELj+qPRiJWVlYm/Fi1atLhfcSNtZNs+tmjR4kFC24ds0aJFixYtbi3uKoMoyzKeffZZ/v7f//sTyz/60Y/yzDPPNG7zyU9+kn/wD/7BpuVRJOj2S1lRGVAsSTlYY9EGNjY0/X7MxoaTeOWZrqKg/X5MmpQysDIgH0fOWLooI5SdxJlLz8WOnpObmFRm1TmElMiiNPLVRrmZEOGyoOU2Ireu2IW0CGHJZUIqh2zYPtYIRjrGWscUunxdMhg5qZwUUPQkaxuSuZ5kVSnmOppCi0qRpKTLVmUtDEZBhFuMy+l24oPvWuA/fNGwt+dYO08deItXVp2RcaHdsbWBQgriyMmQtBWsDRXGOLaTFJTMKCep8+ceK3dDc6OYiwpykRKRU8iYPO5hZERURAhToPIBwmjk0JkPiyKHjTVn9DwaghSYtTVE2rmt5RHi1dNfp6uH6LjDKJ4DINIjZ54tx1TyQqXkKh1Ly4BuvopWCYqMIukji3G9y9JdAAzieQaiNHy2irWiy7BIyLSkkwrm5yOkEiRJKT8sDEIIpBDEiaTXi/g3n4c//g5RsYi8YfXJ5VcZma1lieeu7ua/+ZDkN74yTz/NuboeISV8+tctf/pdLmvatzz1AV479TXmV1/DCkGW7iLO1ukkq+SRy1xhcZRyZTJ3H3UOQmJUhNSFY1EZjZ1fQHa67reuK1OrFCbpYaWiiDroKOVi8ggxBSt5n6wQ5IVjD60PbJXNcCfiRtvIae2jn4WbJk9pWn/Wd7/9dvbbJOFp+v52jjOLSbKVnA6Yahx9J2GFqGRd/vssSVlTOU+TWYVysa3MWeu4XVK7OuqZs5qYP355HXXmjN+fCH5vkpqFmMbMafq9iUW0XQZayBLzBtt+n/Xz2UpGV193Frso/Fxn4dWP0SRv24m4lX1II6Qz2m2SLTUwR2Dc5/Plo4kq5sLEvq2qLAVCVoIUGmPVVFnYNMlbaJJbGQbfIrjsVKIyjJ54Bm6zIax/ppaWzyGERYsIYS2JHU4c2wiFttG4HBpMwsfGy7OYWrMzzW2FO8keGjNAZcUeKmRSlYE/nyZsxQacJZNrYiZudZ4h4+f44tEJ+fY0Bia4NltikZiJ94G0ppRGWyIExxYX+cbS6+68hXFSMzG+54axJYhn/NSv16DGMrHw+Q4ucVr98M+Ih7mJrHstWux03NUA0aVLl9Bac+jQoYnlhw4d4o033mjc5qd/+qf5yZ/8yer7ysoKjzzyCL2OoNtxgZLSdgRTPdvOmyhNBEVhSRL3MGeZYWMjx1pYWRmhjaXbUWgjmesJtJHEka36rLEydJRFW8UutUpSeuBA6Wxfps12SBjpBCkMG5kLQhRGoITzKIqVYSTiqkGLZN+lcDRu8D4sFFLAXA+MFVXQqlvGM1QpuxrmkliVjbcAJSwHFgpeuRhVAa9RZjFl8MiUHku3Ez/wQQl0ee7MWyihmUvyid+zwnnTeE8igGHm7pdS7jxVKfPTE/RBV12NFSSqR1cNGZEihcHECmJIiw2UKUjByc06IAerLmW6UmAN1hqKiy5YoY4/dVvLIkRcjMijLlrGGCGR1hBn66h8gCxGCGsxMibOB9DZjRWSSGcIq5HWBUmifACAzDaqDrwqhlgVI01OEg8pZEwhE0YyIU4GZFqxd96gtaTfjZjvK4rCkuUu8BjHrozTVHJ1xfL/e+EROqngRNnveWHpNQobI7EUVk27PAD+mw+5Z+vPfUsMxPzHL2qGmaLbGdN2l8+eZfGJ9wLv5dpzv4sVkmTlLWKpiOZcMHHQ24eRCiO7dIbXUeV1k/RRxRCZD8EaTHceuqUUT0VV596WATcdOWmcEpp13SNRBf1Uo6RkdcN1IrSBwc4c/9xwGzmtffRoCjpMk6fUt/Gfw/+zAjbTBqnhcZvOqSmIVJf/1ANG06RC9eOE/+u4kzKBsINcz2JVv+ZpAZH6dYSSKr+vWf/r69Xrgf9c99a5XZhVR0LMCizOkk7NCo5MC1xuJ3gaospetkVQzZfntOBeWN71+lE/3+2cV1O5hIO4epa8+nY7FbeyDzkLPhBTX+bhy06iG4NJ4UDTmRG495Qp36fT5GZ6qy56kEXqZtAUBKkv284zeavhpUbugOOsWz6zmwsU5Ggm+yO3KlDm07nX97lp/3az99jtgg8E+UCOltGW933bAV4xDq5tNxg0a9/hMt9+SWu2DDBaK1hc3Bx493JNv/3Z5WW+6fhYwtYkBZt1DGf2IdDlZL28AU+mpnrxoEEodkwWswf4Ntx23HUPInB6xhDW2k3LPNI0JU3Txt9atGjR4n7EdtvItn1s0aLFg4a2D9miRYsWLVrcOtzVANH+/ftRSm2a6bl48eKmGaGtsG+3odsbz9JoI8iLyUivyzgmWB/EZLlb9talcSciTiRz/ZKBYJ0USmcCkEQKICbuuRmikU2JGU2cQ24TBsZRfDbyDrlRXBskZIUgKwSFFkTKkkTl+cixAfN8JydVunLj70SajVwhhKXfFfRSt96ubl5di8+Y5lEYJ9eyVnBor2GYuWtb2wgkFncw2vq+Ewc4tXyeh7qXMEhSNU9uFDqW5Kni0urYXC8tP/o+XaHH7CFv0J2XRtyib7k27DKK3UZSGIrIVeVO3CEir2a9uhuXKjaJVDGyyBDzu1FDx/4qnv0CfPiv3r5CAH776+5Y75UaUBUdNS4GqGJIfOlVl4UM6KjXIU5IO12Kub147aA3opY6R65eheFGtX+5sM/97w1J1XWGPcfC2Uic3CyNCoyFhTlXXnHkno28sGjt6rmSTn64b8FVkLXB+PyfOu6yvH1j6fUtr/Vf/jb8je9wn/+3rxT85Q+6+/Kfny14fW2evd0hxG7W5/jiUZZ772VBXef6Iwc5vniUtS/8ujtnFXNt7mEyUgbxPHtWXsFETuKWXrvqDmANujvvmENA5U4PqOEGVkYkCHTcYd/oNdLUlUu8qyC3ESv9LsMiYlRINtZ2psngrWojQ0bPdkxoQ6bCrJnEreRbs5hH9eVNrI1ZkrS6FKZpva3kNOE2XuJzpyRVTecw7Ry3w3yprzuLTRNiGrvE/7/d5VFJq2rH30ryFZ5n07JZ9zrcV51ZVF+nqVyaytOzh2YhZBucXV5mscYU8uXdlC0NNmdBazqXkIVWv576NYRlX9/nVvVmJ+BW9iGbMNHe1Fk+dnod24pdcLNZpO427mR9OL54FHB13gjZmMWsLot6O+e3yXh8izbHL7/d7CHPpKrqVK3eTTDZbjKD26z3rF9WX3/W+zREnQ056x4pNOeWlzi6eHz8Pi63P7e81LiNxGCFnZAnVucpbMXSi8ixiDEbbaJM5Ey5YR0PMnuoxYODuxogSpKE97///Xzuc5/jL//lv1wt/9znPsdf/It/8Yb29c7d17Dp/5+9f4+VJLnve8FPROSjqs6ru6fnPZzhdA+fonQtk7g2LcMSLZukLMt3bUCWVjYhrmVeaGlZa0iCAWEXsGyIkAFL1xcmLrwWri79kAFr1za016JkU5Qt7+qKlkVKskmTnJk+Pe/39Ou8qiozI2L/iIzIqDyZdep0n36wJ7+DM12VlRkZr4yM+MX3+/tlmNqooK2k1Iu0QyUdNXU6Tjgo3G9au0VzUVomY3dtmgiUaowpRSkwxkVCm1dJ7SPHUonTgBtwyyqlNIrdwi1i9+YJRSm4tic4mNlw/ySBRMlGtpZAllryRKGEJa0NRvtF409pkhtGqWWSVZwd1+HcW5OV0iaURlHohEInrOeW9dwZjdZHtaHFiGA0ulV41/lF6vZT289jkOxVa8yrjUDX9P6FrIVCS2ZlLQMsRfAlVWlIlKN4VkYyq5rocsY6Y8hMOsnZLHW+bDY23b/KVKR6BtaSllO856Fs7VV2v/hv2fjAR29aHYyTkkeSFxlfeo1yvIUVgo0364n5xa9R7e1hyqoOda9ACmSWka6tOaOHEKASJ4+bz7BA9cabCGe1RO3uINY2kFJRrZ9G1hMpiWGvWsMYQVEpssRJDScjV69KCfYPLEZbjIaytBQTV+/3bTljVgwpDN/0xIOdZXxq+3kA/up3NlFjJJZf/l1NohqZ5re9d53fe2pOUmu/3//OM8CZcE0cUe717RcobUpJSrL+QIjocuY7/jiz//1/AaVIqhKT1a1ZGwKFrhB7V0Eq1Kj2aZRPWOMFrFScVSkIwXx8mvnaOoUa83pyZxqITmqM7PLlsuzc+HOfVMd/bmOZzxN/vB2ta5mvlWUT9b6FbJeRJE5jFePDrUJ7gdElKfKf2/T/+Jj32XCccvSVPU5/FcnUjUBYG4wrXdLHdv6W9cfjtGX7eeiTQy6Tm7URh6nvQtzWvsxxXn09990rbof2te08dEk34+euy5DaJXFcddy4HTjJOWQsKwq4jqJfz+LxTjLE3Wnt3R57ti9eRJkKK+Qh30Mn6SPp0DjT8mnkQqDf/I2F4Geqvq8mAev8V7VDwXu03xvLonZ1YZmssG28j8/3/rD67tUVpRPiTQIZ6tGPY3Fky3bkRzj8/owNi9aKQ4Yf71czltUeV6LZPv96JZ7fqBBKIO4YidmdkY+7EbddYvZjP/ZjfOxjH+MDH/gAH/zgB/n5n/95nn/+eX74h3/4dmdtwIABA247hjFywIABA7oxjI8DBgwYMGDAyeK2G4i+7/u+j0uXLvF3/s7f4ZVXXuF973sfv/qrv8pjjz12rHQeKS9SbilKm2KsRCPdv0ZR2YZJlAjDeia4ljjWgby3cXzcGL1d1DNjRIiqlSiLlC6y2KxKmGsVWDwGgTGCuXZOl411Eh5tBKPcSXeEcOmMMhe5TEnHqljLHCvi1GhKrkpSWWGt4KFNmFYpReXyvjkq6vxrUlGiqMLugbYJiU2QIkMC2kiscAwqiWWSGWR9rhkJ4OhoVDcL7zzvGCZPbz9HteYdNTY7QcZ653GOraVN0y6pcs69c1Ue2qWb10ywaf3vTGdksmIqR2SyRClNns4Q1qLyiunoFFl1QLZ5luTrv8f0a19k/LH/x00p87v0l0FD8tzXScZrjNc2YHaAvfwm5aXL7L/0OtZYZKKYPHjW1cNsDlevYUrHBvLR9kylsVpTTecIIUjWxiT33oc9dYbZmUc4yE+xr7bYrdZ5/vIW+zNJWbl+N8kNG3nFWlYwrxKmZcLOOOGpZwyzmeuH2rj6u3fT8L/8muKvfVdTDoUODDBP7Zbomp57GH/mD6f8my9VWOvazhjBr/5eyaObTib55PYLnCpe5/73vL+73s6/jS9feM2VWygXuUQkfH37Rd795/4as8/+P2G6j5zXeripk93Z+ZxqZweRJsjRCJGkQXomAFHLC9fHE9Yna5jT9zHePzh0/zsFJzVGwursiLbUp4+10ZaiLZO2xIjZLl33XiYPWkaHb18Xy37i/Hk2RZyfO2XnvEuq1CWja6OrXpbJrbpYIsdpi5OEj+YV37NLcud3lVeRg/nfjjoeo4v91v4dup1Rx23WjmgW75rH/a6dp7ivHsVMaLOVYiZZzCKKyxJHE+ordxfulGejCyc1PgphF+U6HYyimyUtWVXOt4zZcStwJ/SDuN8H2ZmQgdFzUmjLC+P0b2W9C2sXonPF86+F8+o8SqvRolna+T7sI9P5NPvYmjHia5uD8UcR7g2Lz4eXhD1+/olwzEeWPMQiWsKY9NHLjJCBFQSid0yNr/X3BBfZV2Iip9k6OLdu9534vdg4ku9mmbfHjQED7hbcdgMRwCc/+Uk++clP3lAa+f4lstP3UagxlUipbOKiigmFNIkbAKxASY20gs18TqET5KRJw1g3IGorKCqJsTaEjk+krY0TbiFtcDInP0Aa6yQ1WR1RLFViwbihJEhpnZ8hWfvQFzBKnOFnIzkgFaXzpi+AFFKZUyQJ2joP/pmqUELXrwgTBjHjB2fcQCWlRViXR5c3i7GCRNpgKLrdeMf5xygvvFz7bNKRkaihzY6VwuAis7nvbmGfiCq0p49ikQiDsc1rUwJKapTQLgQm9ctONJFBimSCHQuShx9D7O/wxSev8IF3nT7Rcv6HL0+5Z/QEj0yfdAfmTubG7AC9u4eezrGmbsdKc/nPfRItEx749V/AViVIia00Zu76idEaWztlklmKGo+w8xnz0w8zyzZ5xT7Clb0Jl/dTXn7DhbIHePBeSZ4YTo2mnE6uUGYZrx6cYZxW7N4/5vJVye5exc6OM9589bmMM1vwf//f5nzqr+Q8vf3cghHI4NpLkzgNeA+1WwnLel4gBUHyeXm+QaYqzqZTdrMz7Nb+iLrwzU/cz399+nWmco2s9vn17vOPsPufP4vaOIPcueQmF7MpWIu+dhUAfTBFpglCKcxshtXaPaSAKVxdyqJAFnOkUog7YyjsxUmMkR5+0tWWk/QZII7ywRAjXowvm6z3LcSXTbyXGTv6jARtY0J8r67F9Z2C9uS2b1Hvf/Pf2/KgOL0+SdIqRqF26OKTQmwoXFaeuM2WyRGPMny0+3tX31gmkYRIJrFkUdPOZ5c0Is5TH4RdHkXOP8ttuEXV4ee4T1bXvuey5/9OxEmOjx5dkcv6IhjF513vYvF6jBsnbbC4EwxAq+AoKedJIw5j3repcrOkuAaJQi8YY7qMFWEtItTKBl/fbyVmwbdRGPfqvnxsCZYQC4YkWHyX+Xu00dePvUQuztMyH2BdacZ+pc6fO8dzF54MG4e2rrOua2XtDuGtJiNbBiElQq4eOe5m4k7Jx92IoWYHDBgwYMCAAQMGDBgwYMCAAQPe4rizt82PATXbJS12UElFqXJmcg2NwiLwsQ+EsA3LRhhGSUGunEXaW8oMTuY0r5LAwFHCRQuTwjiqo5WURiGlbc4BVFLLx+r7WJxEzUcaS4QhVSUK486rI1lIYciZoUzpaI9CYqUkERWVTaisIqmZMBO758pSW76NUCSiRAtFgsZKwVgJEmGoaofdnrlRGRaint1u5HJGYZtIZACpqBw7SlhQTtakagZQXjkZkLQGIySlcjJBIySpKA+xWCQGVbe+EBZpDcK4NixV7pweJ2PKrfuQ4w3Wk33gZBlEqTI8WDyDVhmMJm7HwhpsLR2TWUJ+egOpFOnpLZLt/x8A9h3vRly9jD3Yd2Xc38cUBbYsg+xMTcYkp7awWrO/di9fn7+DN3Zz3rgCV65qrlyZoZRkNE548N6MLNFM1JTN+SUA9Nixr65tZVy5JtjcSLh0ybF0Rrlga81w370Z/+tvwIceb6KuVNYNG65/S2TN3gLHmAJ4dWdEmljOnd4hqZ0p7leuvbRRaKMWnAleWMIi+pZ33MdzF57ksSfeBcDlL/8WjLfY+O+/m9mv/ryr0zQDUTmmUA1TVojZHKs1tizDcX+OY9BImB4gDmbHbdpvOHQ5M+5iEfUxho5CFwNpmePMrvPi+/exkbryd5RD3aMkHN8IO+dHSQO76tTX3VFMpHhntS3Jg9UidF0PjpILxn3B56Ht6LSL9dOXXrssXeyiZTIeL9PyiKVkXewBz/6JHa0u1GNP3/VsrdiRah+62EXtaGldWPY8fCOyiG4G2pKz9ucg2ek571ZJT7r6/t2O8+fO8eyFp8L3m1XmPtbdrXpGVBTxztbM7ZjZc4jN1mZGRky4rvNhkSEVrovH1J7+HR/ry1M8hnWydLCBbSSwC0703bHD5bJCLMh8l8lxF6JG1r9f3N7mXD2f7B0ffaZsONBZ/oFZNOBuxV1jIJLzGWmxj7AGZSpMpihFzszmYfEKgHDGiJEqkFhSWYeNr2VbpjYVVWmCQTpZWk0xFNhgsFEmWRgYVG10UlKjMMHg4Y0Wsj6WUDVGi4iD6Y1DAouwmoQSIQxKaNJac6yoEMaE8yyippMaEuH88iSiIhMlB3rMPeOKaZWyY/I6upulMpIvX3iNb37ixkPA3iiEtYc1zFgntRMaYS2ZdgYHZSoSU4C1CGuwUiFrI5mWCWktPxLYEO3KQ5rF71bI8PIxUlFk6yRCsaGvAI+cbBmxTLNNANa37kGUczAaoTVKCuTahExKRD6C0RibT6gmm8wnZ0hP7SNNhSxnqNeed2K66RRTuLLKyRpsnkJIxY46w8tXRrz8uuHVVw/YvTZjujcnzRM2To0pKxfhT2DJ5i4S3unkDfbUKUap5lvOw+W9lHlR+3CaW67uSR661/D6lUVpyde2X3L1WD8bEsPlYguArfyAvXLExlgjsaypAzLmGCGZC+f7yk9GfvMrU77jfS7K2FET6VTPeXL7BQCyyQOMyj2u/sFvcurP/I/MPvcZ7DhB7F5Djl16es8ZE/W+M7BV0zkYg0gUajSq82+x1mDLAtL0epr3GxbxwtvjKAPPKn5w2ukfNWnvkhUty1eXAaHLT03b10of5b7LmLBM0nOr0WcM6yt7fF1s9GlPutuf47KLjt9vppxjVZmMz5s3cMbXLJM1dhla+oxI/jdvOG0fb+c5lr7FY2S8aPF+N7rSWnafOM+ryFfaRjMvc1tFarLMMBef91bGqsae2+mPZGinBqv03VXPWSZrjnEzIz56adlClDARGSjE4fe1XyfE57UNOCFKmuh+58bp+XxYcdg/16HvrTTasun4mtinks+zz7+fL8blSUzJsxeeQojFSLvLYIXg2QtPYeprntm+gEUc8lN4qNwtQ1EsVXurGoeEFMEv6u3GnZKPuxGDxGzAgAEDBgwYMGDAgAEDBgwYMOAtjruGQcT8gGS6gzAamVRomSASSypybGRhTKWTMHnHxbmdkpiCxJSk1TQwWqpkhJYJlWwiflkEpczRKMbqsAVdCh9jQAeLuIlscF7m1AVv1Y5ZRfH5/rgV0tnQrXaSqfq4u28RrNt5MqMiJZcZxkqmZUJlXLS1kbgz5DTnzp/nqe3n2dXraKOYJK7+vVM4cPWibLVQL1YqLBJpdWBQCVwdKVOhTC0nstY5n/O7E2G3SKFlHb1OKqpkhMAyKnZPvIz35Zd4fv4oZ7JrbJ56EFUeIHSFyidgKoSQ2GxElY7Q2Rr7k3uYqnVmdkyVK9akY8Kc2nqIfHbN9fH5AUJrTDZCTzYpR5sc6DGn1iq+dk2ze23G7pV99q/tk40zpBDs7m+wt55wMBoj6/rZ3HmJdfka+eaUXbbYyNZIkwl7U8negWU6dxHx1sbwP/1/LK+/PucT3/ky7znf7JBd2H6GzMx4ZfcRPnDPBa7YM2SqYiMXnM72mJucNXuNUo0YqTlXiw1y5e5vrAzOXn2kiD7MkjWulJukUnOPnDJPJoy5yv4Xfhk2TrP2wf8TO7/366RbbyKuXSIpCoo3L6Onjm01v+akmdnGBKEUajxCZhlCKee8uipOuunvSCxjWkC3U96+845Kv0+21kfRj69vn9c+Z9k9Y4ZJV9mWpXWnYdW6atdvXCcxs6TdHm2ZYXzPON1Y8nSS7Kq2dK1P4tjlOLqNdj/wx4K8K2Lm+N/ifz362DNHyUnajrxjOUNX+fqkcXHdtKOhrYI4D7DIauhjgrXz4u+9KrtrwN2PO7EPaJmgTFXPARfHvaPGixjHOWcZ6+hm1FFJRkrh1BFOCIB3MRFHK+vLg4/WZYRcYBFBwx6ySLCmk/3WuWaxLLKXYEFi1uXM/cL2M0gM51tj2fbFiyHozKG0iN5VWJQpKVUO1q0Nwvi+wntcWEslHFM8dvp9cXs75GlhrI54n469FdVNS3Y2YMDdiLvHQJTmiPkBSmtkOsOoBGk1SpUUahwokZ6emRi3IDy1+6K7fOdNRDGDWo5k8zE2yTDZiHK0iVGpGyKkCoYGN/CKYLAw0i1yXcjEOnyiEFQycyG6rWLGmLmppTa19E0KQybKWp5WBeOSG7hFkLpBghWSRJRkeooVAmVKjFBIdJBXZdUUYW3ID/nDkMOl2QZzrahI+Nr2S7zn/MM3v12W4ML2M1Q2Z1ZlSGHYLSek0kU087I+JXNn/FKaxJahjMIarJAh/HlF7cso0Yyq/XAPb0CCWn5manle3T5GKLRKeqNw3Sjecf4xXvzylNemp5mvvY9UVKSiRFGhSdBWUVjXt0qdcml/wrRUzArBlV1BnkFVwZnNt7E5rtg8M2cr3SMTBbk5QNmKWbLGut3n8a2C/ANn+MKXt+CxLf7gPz2LNZa9nQMuXtxjc32Dq/un2Xz0PQCMzD5JLW1cl7tMRvuczVMKm7FfjXjx2gYHM8m8hDwTPPJwzq/8t8cp/8CgDVSV5fLl+9Da8r73Sr6aPs7ZyUEwiT5QPg/Afn6KkozCpCihKXTCTCecm7wYUYkNF7afWdTLIxmZfe598j9y7s/+X/FLnt/48oS3r73MbLSFkQppNJe+8ttc2zrHuT/8p7n2e58n29hitPYi+1+/sNAe5f6MbGsdNR4jJ2PEhpP/Mbu7DURH+XqJz+mS3LTRtxhv/9s2Eh0lXevy67BMBhQjhMQ9wqDULle8KAY3SbwTZWZd0qcug19c/j7DQJ8hpiuNWOZ0M0bJo9qrz2DTZezqSmPV9l81j8ukasLaBXmjFWLp4qXv3m3DXp90Jb5X3F/bxh0vNztfG+SWGX7C+fXnc+fPs7Oz01uGuwU3Y3G/iuHhGxHXY7g8afg+7TdX+8aCru8eq8gvu753jburbKxcDyQajSLBhLksuPlsXh24OaxM0VYdkplZBMpqhHWRf0uVN9db5/vHzYcb4w4Q1kkLG9YL92ZBchVf6zaxhc/AQn6h6TvOnYZBUc/TacZSa0Uw4vjjRkhKuRaMQ6KOvBaXucufkG+j81EkycqmwdWHFSLIzcBt6jtfT6ZZi/W8+fr6290OqQRS3RnjmnyLyvxuBQaJ2YABAwYMGDBgwIABAwYMGDBgwFscdw2DyEw2MKM1dL4GQKVGaJk2uws1jdLU1kYjawaJdMyTarJJWjpHtlQloioRSYospk6qlGRYqcL54b4qAe0ijynTsIcqlaOlY/y0aaBKGEqTUJnouIIUgRQGXVuvbWS/8xZsTS1FkyZEPIsRnD5bjaqjNa1lTl4jx4ZL802e3bkPgPccu5ZPFqktKMjJVNU4qxOLNFeLoHb7jRWuXpwDb3eOFolj4vh6sYa5mgRH3kaoBeu/khXS6gVH1lbIsLNysxx4l0ZxabqBEoZMaXJVUhpFYRLmVUIqNVK6MiXSkiaQKME3PeR2bv/zhQ0uZxmTUcaptQkbecF6NieXBaktmdg9zhTXuDd7iUf+6IM8t3svu7sPs3ttRlVqhBRc23Xpf/3Kw2zkBWvpFqkqXZSxaDcJoDIJmbJka5pCC4xxG+FKunMqI5iXkq3NCQAPnS6R0vLfv3srKvUHAHj167/PxBo2xGWKdMxL5UM8OnkNI2TYeZEYbCQ18ztH927/NmbzHt746n9mZ3SWvDpgkjzKrt5gLPbC7rxFUJDz9e0Xefcf/lO88dX/zEYxZ/2P3QvzGdl2zSSS0rGHNtYRkzVY28QmKSYvuZvR5Qy3zcTok5/1Scb6mB599+g65yiGUJuV1GbExHloO6buukc7PzH7ou3U92Y6HF0VXQyVPgZYlzNmX6Yup85teddRMrZ29LCTRh8rrc3YabfjuYgV02amtSPdxNd29YWufPSx2qCpky6GXl+fi5lqfRHVutq5qz/GUrCFtmzdz7ebl1PE7Rin0dWvLm5vc/bee7nb0TeeXQ8DqN0Pj7rXsuuPc92qaV5POquM97cSsfP94+AkGF1tVmeMk35vCGEd40XowJ6P57XKVkitqdQGWBMYNZ6JU8kszIdjuVjMCMJSM/Jlr+NlK2Rg7sfXttk13uVDfF0f4rTa7/hnti8sjo+BWV6Pp9Apiet6j0DzLhTg1ld+vK+VGv7aJ849zoXtZxby1MaqLOW7FYOT6rcG7hoDUbFxL8XaOlXiIhTN00kt7ZLBOGQRVDZZ8As0zzcAyIRAZbtIa90gWxZQlVDMUUJg0xE2SSEbY4VyNMpawnXIf5AQGKnwEihvjBDCYtAY6tDgdR4kTm6mUeg6LUVtbKpDifvP1jrioxbKvTB8hLWaDiqBSmWk4QWmmRTOyFCkOevpjIM6UtXtjmY2ExMKk2KtYKScrxhXpubl48vufSt5o4+k1lXT1A2AwbeJDN/D4I9AihQlK/LqoKG0IqB+UZ10fTy1/TwPT+Di7gMcFAnGChJpEWJEqV3I0lILskQxyVw4+EQaSCRrY8uTr23ywKmCnT1NVVqUEiSJ4IF7x2yu5axlmvvWdpnIPbLZDvmbL8Db4J7RK+x967fy6qUxu3uuPtPU1cPOVKJNxrRMSJUhVS7CnhKWTDl/T7kq2cjriH5GIgQk0pBKHQx6hUnYXXdyyVQZMlXx6//FousX+aPrb7LGLmOjUaZA6pL9dIv78zeAxUg/1orap5bBh3IFYD5Dn3mQN7JHmFU5lbmHtWTGt7zjPuBeXv/qFxFSU6QTKuukgl++8Bo6fZyNd55lrbgGwOaps8jdK1AUkCSQj7C1D6cqW6PYa2SJdyvai+MumdeyCVGf8SVOr2tytkye0zYGdMmI4t/a0UbaFP+2kWRZfuPv3o+BTwNubuSuVdAn6YrLFC/u29KmuKxt/0EXt7cb41Er7dhY1nf9SSI2YPTJNPpkdD4/ff03jnzWrpe2wavLKLVMTubTj491PT/tvIU+zGIfi41YfaHr24vP9gLZ3+tcJKdo+0BqX9P+PU7Hl/OZ2/ws3E4cVyZ2XMPJcdK/3UaZNm6nFLer76+CGzH8rYKbsang57kAWqbBUFPJDGUr54cpigQGzneQ99MJLZ86HX6FhHUrI4sI0rBD0qrgOmO5+KQx+hw+r+3bx0ZRygCef/przt8QTvpFlIZEB6PQwvyxx4DfbmO/9pMYzp07zzPbFzBC1usMCZZgHFoWjfCtZhAa8NbEIDEbMGDAgAEDBgwYMGDAgAEDBgx4i+OuYRDtrt2HmKwFx9EzuYZGIawlESUCHRw9GyspjGPRXEofZCSmGKFIJvvIqgA1Aa2dw2qjEWXtwNZaRDrCCpxjaqmolGMsNRZruUD/dJb+Rv4khEUJl8dclQuOqmOLtdsNWJSYWSvQyPo/Uzuuc47WvHNri6id1rmmlVaQVS4S1lnzElfz+xFrlivzNabV6Ca0xGp4cvsF5ianrNvBIMhESSKqZqfEKkrryqGEcY7rhHPYp1Gh7qB2eCfsAjvMpSsXWFjCxYAjkWnoK3GEuJPGO88/ylPbz6OEpagEf/GDkn/6H+FgBo/eW/K2zct85bX7OJgLrIU8cTsviTRsjl0al/dSZtOC/f0SrQ1SCLQZs7+pWJ+kjJIxk8k669mEfPcqm7//OcTmKR4+/04e3oLL0zF7M4Wtd2jSxLF8Ci0ptEQKxwACGKeKRJq6PxLyMkqcBGuUFKzLfQQGTcJmmmMQrpaFZZ5koV02zWWkNezk97i2sa7dElvyxPnHAQ5F23EyN+8YUMKBY/ZcKTaZ6aRmORU8tf08KQXkpwDYsxu8dnCKompYT2v5BlvZaQAeeDBlcvoKaeHS08kInWRUKqdSGbtsnGzD34HoYui00cUU6pIiLUtzGeuia3evi+3T3g3uc0DdTr8tsWp/bu/Wx2Xzv7XTuF2IGSV9EqZ2hC7/exv+vJi90iVJ8+d0SaN8OifNGPBR5zxzJmYGxHnskz9ZIWg7gu6TGbbRZsz0peEZQHFb9LHc4t/aTLq2pCyWyXgWW1/99kn82vloPwd97Kb2c92uhxuVJH2jo4/Ntsp1Hn3Xr9o/72Rcb/2cBPqeg1uRn9tRbs+g94x4WysTjFCUIifnAFU7s/bnL+a5JQtrfffXCB94xzOFWgyiVYK5xKygo65p/xbcZlgT3D6EcY3uwBQe7bEsZhjFaXi4PhRFXOMwq6o33x0R195KEEIi5J3BLxE3Yd02wOGuMRDtsUUix+R2CjhfPe8+/whPbz9HYkqENejaf5A3DlVWcqDHGCUxqSQbH2ClQhVTlDGgK+eTiPoFHtEmrVQhPe9ryIhGGhMPtsZL0hCIejmthPeRI5vza+OFQtfe8w0VKbI2jnhDhwGwKhhEJG5Bb4XFItEkmESRmAKDIiucDyJVFWyKNxGZQWeKC29uIZ+8wgfedfpWNFHAS099GaXWKe0alXHlV6I2StQlMKiFiFaVVaSiWhiYGy2yDYO0xCxIx+IXUHy+9wslrKk10/amRDL7+vaLgHTyLGX537+omYwEr74Jf+YjKXA/X3/TUGlBqQWj2sWVEJa1tOSe0S4XzT1cvez6dVFopBRk6RoHU4sQME4LrpXrrOWnWVMKO51i9vf57878OrtnHidff4zZKKM0ispIikqi61CkhXaGKV23g7UJibIumhwiHFf1c5BbgaJC2YqUAilNMMpZBFI131VVMU8mzOyYhCpEp/PGoRhh0VRf+47zj7HzP/0NCiB94BHKiWJ/niKEJVMjbCLIRMpUOyPnq/sbvPRmwnRmKWop3ub6iI1JzlqumWydYWdyhnx9RmJKqvrZnZsRGsU17n6JWRvtMNpdUhNofCocis7UQnvS3GV86UOXLCpOc1no+va9j1rYtuVJXefGBphbLaFoh0vvkuF1Gb58vtvHlxkwPOL6j2Vo/lxf/yctn2iHuO+KytXXL/pkBX0GzC5jYlwLXWnEUq34/jGOkl7G58USMS8Z8/16lbr1z2lcN31GtHYe29/b5X+rY6Hf1G4JEtzGyPXODZYZ4ped1yeRPQl8oxmi2lhmMD4Ortcot8y4dzPqVth6bWDFYqh6KYIRxEfr9Yt2318rmWKsQgqNahmEYiOOsCZslsZrF+KIZBwe6zrH3Ot8VpStmrzU/ilN7G4gQnus7DIOLcPCu6Mj/RhdY3nbKHSnST8HDDgJDKa3AQMGDBgwYMCAAQMGDBgwYMCAtzjuGgbRTrVGbjK0UKSiDM5qE5EwMUWwwgs5DhIYbRRKWcdCUDDNNlFVgRnX1MaqRFQFwujgkJoFmqYK7KHYuiyNDlZpT5P0EMK6qANInC+4xoGyt95LoVHGWdMlmlLkeKO8rSVX1jpHckqaRlpl63RkHR1K+nzWjA49Y3zwJtJUMIJRusGFS6fqWFO3DuPZVS5P7kPgHDIn0snj/G6dENaVDU0iNNoetmPG0rCw61GzgOLjisZBuLCNDM2KxhGfdyLupYAniXeff4Tf/toueVKhbY7WUGnB//CHXgTeBrioZdaCsY7NkyrjHFUDuXTyxtHEMV6SVJGkEq0taxNJmghe31vn7NoBhRzB2ibiYB+mU+TOZdbSEY+sGy5lD1LYFGMle+WI0iiMESRSsjdXzEpXx6UWJAoSqUiVcewiKyh0zlpaoq2LKEfNwNKRE3CBk0/63ZRZus6cESkl7zr/tqX1FOQ0UfS+zR/7nwG49rP/N7b+h49w5SBDCMFekWOspFIJB1XG119ykdSeeW7G7rUZ83nF2nrOxlbOqc2EU1sJ1t7PJKs4lR84J+gG5trVR2Ule/OTaO07H/GOX8xe8A6R+xg38bl90po208MzFFZhenTlr52HLoZEF7um67eua7rYTX1MptuBNj2+/bmNvnwfJeFr74CH3dieOjlJtGUAbYZMGz4vPr9dsqtljKpY0tXut139p8/xt/89zlPXOUfVXR+brQ/tsi6T4HX1ZX8srvc4nThPvnznz53jv/zBH6yUv290hDoTLn6qtqpmc58slkkbu87z57aPxcePk8b1IshxxO0fH49bD0ddf5zr+t5PN8NBtSZZ6IO+7n0e/FohzsciQ6ZWIPTJxoRjCoU1UocD63Ae3fV2Eu8Hz4KiJRmKx6E+9Dms9setcEFQGtcf3UEP2uibu7SvOYqFdLdhiGL21sBdYyAqdMJBNaIQmYvIJF1w9GCEqf81VlIaZwiorKQsc1KpEeQcJJtU6xmpmTNKMlQ5Izu4gjUGk+ZY1ciStEzrgbgxDilTBWOD828jSSiwqla3eplZPfnoW+xI04RhtwiUqF8AAlJRUVnVlMUmQZrlTnGGDy+jEhgORqfJqwOkLklnu4yMS/ve9ft44crkZjZLJ/K9NzibbfCGeihELJPCGQak0Ehr8EHoffw5qNsvIr0tRCGLEJ/j/TJJzCFaqIuGBtQhQAt5c3wyJXUZy8oZgIAFg0mibN2e1kUDSzSpdD6zUgpGiebxt0/Y3XMGmzyXPFRHHc5Tw+aoYKQKhLDotU2UrhCzA5AKWRVkxR5r6S6ZzDAoEqEpTEppFFdnY1Ll/CMBVFpSaUuiItkZgq1x4cR7VjjZI05KNjN5LYs0KKFDFLqRPQjnydCa/fD+N5xxcHGCcunP/yhnzeu8mm7xypUUsy7QRrAnUg6KhDSBN68Ynnv6dQBmB3NmW2vMZxVnz5xib9+Sp4prBwqzJUilRkkTjGTaCqbFXTMULsVRUp32uX6y2Wd48BKmLoNE1++rGJeWndf+HF/btVBfNpmPy9eOXHYzJR6rYJkhov17X/33GUn8sdj3T1f7to0INxtHyXH62uSofhi3dxwZrt0/+owm7b5G6/q+fPcZkNo+no6zqDxqEdploIrz4n/3463HMr9bfoF1t6Nrkec3q24WjlOvy/rZquPUjbbjneBvJXYHYK247jyd5CbArXo+vJHDisZXmZYJylRNNOVWX/D+Sk1tBFoYI22zUerXJt5YFM5ZZsCMDIZHjd9HwUva/PwvnscfNUYe9Z4Sttk8XiaBa48B3nep32iOf34rjIkD3toYJGYDBgwYMGDAgAEDBgwYMGDAgAFvcdw1BiJrYVql7BQjrs4n7JdjSusilmmZYoRyf0hSqdFWUGqFtVBoxUxn7Ok1dtliR53h2vh+dtYfZPfM29HjDcceqp1TAyhd1M6nm13CwOKJLOZGNrIlxxJR4Q8aeVQ4x7OSIgfL0mrnGBjnONhHPAs0XwTaKiqbUNkEjaK0qfsjc+yYZEyVjrEyQeiKfHaVB/LXefuZXf7l75w8hXoZXr7//aTVlERUJMLJyOI6MEKGSGWBcVWX1VhZy4JchDNt1WL91SwjbZX7iyRQ3oF17PBPCycRfEM8wJ5ZP/Gybl+8WLsbh/WR5v0PvsgP/PHFnYc8MaTKMEoNk7RkLZmzkR7wtvQFJIat0Zy1seCBexUP3qd48CycmlTctznnvvUpD47fZE0dkOo5Ol/DbJzGnrqXauusc6auMvLqgLHeY2z22JA7bCa75Krk/rUdNkYVWxPNKKsleJbgNLvUAm2opYCun2irmNuc0qYu0pxOQ1tYBBOzi7KVY4TR7ZS6jXPnzzc79a0dwXPnz7O18wJboxmba4ZLO5J5JZmViks7Em1AKUE2yshGGUmaYI0lHyUUpXNa/Xv/dY8XXtG8dDljWiaBRQgwSjTjrOJuRswS8d9hkX0RH+9iFrWZO11pxJ+7dg672Dxx+kcxlmImRjtPXTt6R0myPLYvXjwc8cQ2jqq7oubcbMTl7WMPebTbtos50ndtXzqxQ+U4jZNEO2IZdDsP7+oH3gm6r5t4DOmTVi1jAcXlDSwb6OxrMeuo3ffja5b19/Pnzh1bktJ1vi+3r7e4Htr37RoD4mu6nu++Z/luRdf41VV/7eO3s57isTPurzfMGFqhPNsXL96W8dEjOG1u1UHfXxvL3lV95e9iKt5sODcJhnPnzy+MA8LasBaJy7jAtu+QBMYBX+JjLtpsgqn537YOaOL/uq7vSiv8dow28RHUjFBh3r/KGLlsLD1/7lxwKxGzh7qe2T520ePnnzj0Wxjr67XEWwlSiTvqb8DNwV2lqzBGMC29jx4nW1pX+y4iVk1bdD5+DFK4QTPIzYxE2zFJLU/L5IhEaDZTBWuQVlOkrlDlAVYpjEwwsjE+IMCgoNbRBqmZ0VRJRpCiWX+6D+Xtrtc4Y5bAOlGUaPIbfBOhyWWBro1LcYSv2EgirQ2hx7Gwo86QiTlZeUCVr6O088l0avoq6ajgYPIY//J3MspK8H/+tpv/sE3NmE2VOTlSXQ8hWogVaBI36NYvJx/NzCAODdIagarldrERydeasU2UN4UOFFOLo7JaBFok3GteZarWgXtPrJxfvfAymjWmZQbA+a3XO33xZMr1FSUNa+mUsZyRMSerZhih2Mr2uHdrVNeP81m0mc/JVEUqSwTWRRSzmiqtJYO1Ws7I1PmcwvVFiSbVczKZMBL7FHJElSUokaFEQqUTH7gPYwVSWBLpopq5POqmz9a+oVJVMpYzANbMDsIa5smEd5x77Fj1tcwPR/bac5x913uo1iVrWcaV/YRJblgb1W1uBA88sgXAbLoGOG3ytWuuXykluXx5zhOPjmrjsCSR7trveN+Y//ClN46V1280dBle4sVxnxQlPtaXbvy5awEe/9uVhzaOs8hatmBrL9Lb+VtVuuR/bxtMbjaWGRd8/vzxtiEovmbZb/5428Dhf/f+gJZJkE4KffXbZdzxeYvlYm1/QasYadrneOmVTyf2cdTVl+OFcZ/xKb5X7BPjpCPk+frrivgX3zfOmy9L1zX+3HPnz78lfBDFvvSigwFHGYn6vsOtl6OcxP26+ntIvxXmu21gvdkIz3hwtHnYhcD1pHnU8VttGHKbFs1833T4yfTRkGO5nV9rSKs7rwEWogQvptf4geyCv0/f9deDeFwKZWE141CMvvOP0zdiP6ZeWtZnABX25kQ/HjDgTsBby+w5YMCAAQMGDBgwYMCAAQMGDBgw4BBumoHo2Wef5Yd+6Id4/PHHGY/HnD9/nr/1t/4WRVEsnPf888/zPd/zPaytrXH27Fl+9Ed/9NA5q0AIkNLJY4x1VuDSKHaqDZRxLAJpHWNFSU0iK3LlnNXK2rpcasVMJ8x1ykE1Yqdc45XyAa5l97I/OkOZTbAqpcg3Ag3SwyKoZOr+lGMMASEqgPurI5RRBbmT3+l0LrW9S19FJVK0TNAicfTRaHfLW7e9c2prRZBUVSahMCmVSShtQlVLzwqbM8s2KPJNitEmVTpGYFmfXeK96dc5d/oKZ9cL/u0fHL/uj4OvXniZwqQUyZhElCg0qSgWZWSe2sriLlVc/niXr82o8tfqWo7mvzsOkqthz+AydV2XcjHa3I3i1a//PhP2uDzfYK4Vc614ducwO+mLT14hUxV5UjFOHBNnZA9I9QylC1LjwmudGs05NZpzejxnazRjK9tjrGbksiDFtZkVkjKdMB+fdu2cb1Lm65TphEqmNYtNokxJVh4wKved7CyZMU4L8lSTKIsQ9TNkQUrnRNtYJ830TsXB9flUVIzknHV9lXV9lUKNKNWIVJ9cWLAL28/AtSucnr/KI6NX0VZwalKRKcOZ9ZKNsWZr3fLIwyMeeXjEo4+t8/jj65w+nWPrclhrOX06Z17KOkqc629SWv7Dl6dU5uQj2C3DrR4fu9BmjHQxa7rOWSY/65MHrcJgWkU6FeczTt//3mZAta/vk2z1sQDadXKrnDavIhXpkgF1ldd/jo+30+mqt1h6dbN2y5e1PfQ7SPb9bFm+utrZX9PVt9vX+rK379fVx9tlade3/4t3ok+KPeTT9E612/KT9ud2e/c9B23H7bcSd8L4CIddAPhjx07nNknPbhb8fK3NzLgVfWUxUq0Jc7lbgVvVjhe3t3l6+7ngigLcXLXd957ZvhDkTXFbSGvIzIxS5MvHyKgd4z8pdO9v8X36+sFRaMvW/J9XD5wk4j656nssdvEBhLVajEbZYe665/so+Chmd8rfgJuDmyYx+/rXv44xhn/0j/4RTzzxBF/5ylf4xCc+wf7+Pj/7sz8LgNaa7/7u7+bee+/lt37rt7h06RI/+IM/iLWWT3/608e6X65KRsqFby8qFRlOBKXKybSTwCihSdBYKVDChgWvl5rFIdIrKyl1yq5axyiJTQXSVGjlJENOL9sM2t5gJK2uQ90bKqFcRDMhHd2TxfvEg6GxjVHJhXy0kRSt+U3VPnsqEkyQ+6gmT7bxueMNJQLFXI4xmUKZEmUqEj1HWk1e7nF//jKjtXt4c74FZMeq++NACsNIzUmqAi3qCGzGEIfg9IOuxWl7fV15X0VeJhZL0BZeWtggM9M4qq1w/1s4z1qXWklGQU7CyfmhmSVrXLFnMEZQmX47rBSGTFbh35E9IKumGKkoarlYJgq2sj2quo0zUaKEDmWtSJFCU8kMoWohnnWGSSMVWiRomSKsQdmKtLJOAmk1otSMRwcu0p6V7Ku0NqgIZ3QVTtLmZJkGVRs2jZUoDLmcMzG7jIpd5tk6eXWAlimVPLk+9MT5x9kW38vpvZc4Vb3M45sT3pidIpWaQitypUmVQUk3nM1LwQcffobfeflxXnmzbo9ZwtseVDx0ehbkclK4+k+lZq84OtLaSeJWj4/QbyCB5fKjLslY+1zvD6bvfnFaR02m+owhfdKwrs99crFlhpJ2+l3yrFh2dbPQJe/rkzm066Ud9r3PSNSFVX4/KRlJkG1x9KS9q71j2VeXgeM4ZY37abv+4vvFEjGfk668x+0X5y8OJX+SUhzfF71MrO1Ly/92viUVjA26bX9LIb2oTLcSt2N89IgNEB59348jL+l7hm8ERy2mTzLqWNdz2IVbITXz89xmXmwWImotvXaFd5CfYx4XJ1V2KwQSjbZJiAIrWL2/GSExKl8aQbbv/df1+0k+/52+j6J2BFb2PbQKYkO3tcKtA5ZsjDXrOdkpMW3jegzGAwZ8I+CmGYg++tGP8tGPfjR8P3fuHE8++ST/8B/+w/CC/9znPsdXv/pVXnjhBR566CEAfu7nfo6Pf/zjfOpTn2Jzc/NmZW/AgAEDbhuG8XHAgAEDujGMjwMGDBgwYMDtwy11Un3t2jXOnDkTvn/hC1/gfe97X3i5A3zkIx9hPp/zpS99iQ996EOH0pjP58znjXxlZ2cHgEkyJ0+cVEm1WCKpnoddIUWFICWTJcZq0pqeZhGUOg1k1UQYpFEUJEwrJz+ySkCtRHJRA2qrt22iY3nn1PXNSUyBkbWT7Pr8OLqAt5z7nYFGQOX+2tyTQHkW1E6XmzO8k2sd5GgiHK+AghwtEpSqUEqTygRlKvJyj1Gxi80ENhfA2qF6Pymcnb4AwDTfQlqNsI61Y20TvUBi3C5P7WRbUNNeaRx3G2Sz8xvRwH09mohJhXAMK1OzuRqn107WV9n6MTihjYCnt58jt5pr8zWuzTJU7Qx5lGi6HrlcFSirSEXFZH4VgN30LMpWtSxSk9ZyPCGsi+8mKhcNr25/YxXKVo55VvOrrHTyRC0SSjJGHNT9VmGtQRoXGW+s90CBSC0HWYYQCiEkmbKMUs+2qRlEQgdpI8C6vsrG7svsbrhneKo2eMf5x06mIiOcP3eOZy+4vpKLGfeOrpKLGbtmA20UYyvZyp3Ucnee8dUrj/IDf1zwmf/grr8iJFJapmXC5tqsbn/IZEUqK6ycnniej4ubOT72MWr8b8tYN/5zjPYOnI8m5Z38dp3XlpQtOydOu33fVRgnffeIpW3+WBf7yf8eGCO3iELu89FXxmVlj50md7FWYmfTx63HVdlfq6Dt8HpVKdMqDIbj7nS3GXVtZ819fcSziTzaddyVF888ulnsiq78tJlvff2+zeRq76qfe/zxm5Ln4+AkxkfoHyNjdDqs7sD1MIlgdTZOH1aR4dwoe6iPebjK2HEzoUk6ZWXHcZp81Fh2vY6HT/I9YergMwvt2Eo+XleEUyJn1SfFIG2/PxfudwJ9IW7Pk2QPxQgO/OlneULDIDxW3b3FWERCSoS8M1wY3yn5uBtxywxE29vbfPrTn+bnfu7nwrFXX32V+++/f+G806dPk2UZr776amc6P/MzP8Pf/tt/+9DxXMwZyTkCS65KZlVGVcuMpnKdjDnKlAhhySjQOEOEH0i1VQhlg1QrFRWJrCiKhLlWaDtCG4VOVKCfpnXkLSe9qcIgoUxZGy4cBdaHbgyyqNrHDjQvIh8i3A/uBhkZRJqoAsH/EAZELSOrpVJSaCpAtV5uTmammCNIqbBCOFmS1GiZkpgCaSpSPSdXsxVb9Ph4avt5TtcvMy2SJtKb1QjrohcIYShlhkJjkEFOp6gWZWRWIYVZmMh1vdQtgtImKOHSc9JDQlu4tHXwe/T7T7/Jt77j7A2VUwrNrjhFoRWJavKcJxXBwgh8+cJrjKQOxi8pDPd+0x/h4vY2BTlKJChR1TnzxhmNMhVYqETq6hLlylAbwIDQ33w5K5twINbJxJxKZSS+3o0mq6YIa5GJYT0boURGqhSVkag6tH0ijHsm6vx43fvWlWdR+1d5+P0fuaE6WwVvf+Kd9SLLsmZ3SfUcrRKQzfNT2JSRKrgym/Crv2f5v3wo5V/+jsFaSVFSR4FrnlXvw6kSJ+cz6Xpws8fHx8+dY3Nzc2Fx3p7sLZPL9FGyVzEqtSdgqxonjkqjnWc/qby4vd35e/uY/zeW5LQnhEcZbE4acX3GC/h2PSyToMXwBo/YQLDsupu1AGgjvkcsN4sRRylr56WvXZdJB47qm3391NedaOUplqL562IjTFtedisQG4bacru2YdDLYdqSui5p5cVnnrkl+e/DSY2P0D9Gxu4F4g27rsVf2z/J9eJ6DUUnKR07Cl1jwo0auK4XF7e3MWQkQmPqd37sruFY0ap68n4jRh5vZL7R570rhLxFolpuEHQtqxfWhjXFE+cfXxpd8UbQVTc3bOxE3pRNxVUQR4Dzj7SwdaTjehOgL4LZgAF3O45tevupn/ophBBL/774xS8uXPPyyy/z0Y9+lO/93u/lr/7Vv7rwm+halFjbeRzgJ3/yJ7l27Vr4e+GFF45bhAEDBgy4KRjGxwEDBgzoxu0eH2EYIwcMGDBgwICjcGwG0Y/8yI/w/d///UvPefvb3x4+v/zyy3zoQx/igx/8ID//8z+/cN4DDzzA7/zO7ywcu3LlCmVZHtoZ8sjznDw/HHEqoSARFVYKKqvIVAXaFa+yjomBbKzxXqblo4kJYeuIVzVDRxgSDKezPV472KIwCmOc02slLEpqjJBBcqNRLhqXNUjrnC4boFJZkPnEcFIwx1bSVjl5mI8IQCOngsMO3NznaHdLRJRoYcE0TvygcX4NUOHupYSmFM6R8EG2xaS4hhVy4b4njdOzV1x5anmeFpJRuVeXx8nzjDBkYlZLoZpJnrQGaWp2DG6nyIq2o0JXp86Rd80uss65tUe8M+gdYQthT0xe5uHa1DFWSi2RwvInvmmtdY5kovbRNgk7X//twivABG0VIzmjIg0SuszOwDqGWqHGpBSUOLZVUrPZ4t1MI1RgGRmcw72KFCsEZZLjRHYFShdgnVPrzWRMKjVznTKvEjLl6m4tOQBAUdVsJYm0huTSK4z+zP94spW3BNK6/qlr+ZyP4CZFQkVCRkkpLVmiqYzkn/1/4WN/QvJP/6O7XhvX/tKz/WiidZwE7tTx8ZmLF9nY2ABW3wVchUnSZiUsYwt1MXS8dCk+vysvfayn+LpYLtOV36NYTH338LuIq0qzbhSrsD9iLDsnlof1Xdd3rItxcxLOudtSt/a9+tBXB+1+0seK6pMMLJPQxDvI8TEvOzwqL/78W4Wu9omZY+269w7XPeuhK2rcScpmbvf4CP1jZDw3OA6uV44Uo6uOb6eMq42TkpeeJGTNIroRhCAnHaw5uL6+fxL1FAezCXMTa3rHX3+etYIL28907vzf7DZc5d3YJQG8lVHoYgS2PU0UZL+uABbGx/b7yl0nOj+/FXAnRQ+7U/JxN+LYBqKzZ89y9uxqEpyXXnqJD33oQ7z//e/nM5/5DLKlFfzgBz/Ipz71KV555RUefPBBwDkezPOc97///cfKl8CSUpDIksqmaG8kwi3WS5GhMUGKEmipovH3o5Eh+lVpLalw0aXWsoJplaKtpDCJC/dtDVI2vlgswmmG/QBjncxHmQqtkmC88AO/j8DlrnNmKsXi4OOpzvGif9Fw1Hz20diEtbXkRmJFnbZpfB9ZK5DCYBCkddQ1I5x/nps1yH35wmsA3CedrKxM8iDxCxTZqB6l1Qu+nAL1uza8ecme909E6wUjRC0VFKCRjYQr8mHUjoTmDWrrcp+nt/dvmPLqDIfOIKENmI4XZ6EzKpkGg6CXw/l6CL6R6vRKkTHS+6EMJVnoV5567OV67gsoW3EgN0LZtVWU0k2OhbJYJEk1RRlnYJoke84/lcgRjII/Lx/hTaFRpkQKiTIl+4++j9EN1dTx8Pj5J3hm+wKn917izbXHnNGMWrJYy/QANtIpuSrJkpz/8GVLlrpcJspSmYR5NFHJZIGxJ6O2vVPHR28k6DME9Rkl4u/tz31ypVWNFH0L0a4Fffve8Xl9ee3Kbx8dvn1enF7sl+ZmTLIXZEE09RXfd5kRrg9H+VBYVpY+g9JJyCfa0qzYN0Rf/tr9038/14rMFZ+7TG7WPrerbq0QnZItLzPrq6MbXWCeBPr8ZsXR2HzZYuNQGydtEL1Tx8cYy+TqtxJ9clL/26q4lYYmYxVS9EfOul64Z85iRe17Mmz03rhxwcuLuiRqfbLVZTDHF2YczlM075e23uzsuLWwdqG/Nsakw+fdCiyT83Yah4RFn9DcaxWs4u+uXVfPbF9wtXtn2UcHDLjpuGlP5ssvv8x3fMd38Oijj/KzP/uzvPHGG+G3Bx54AIAPf/jDvPe97+VjH/sYf+/v/T0uX77MT/zET/CJT3xiiEAxYMCAuxbD+DhgwIAB3RjGxwEDBgwYMOD24aYZiD73uc9x4cIFLly4wCOPPLLwm60ttEopPvvZz/LJT36Sb/u2b2M8HvMDP/ADIYzpceAt7lk1JQekMhQ2C79ZK6hImBt3zMuOPLOisiowSbQVlFVOKVISWZHJCqMkpZbOcW8tSVFCB+ZH4/RYUsq83sE8zGzxcq8FJ4fCYq2kqumymSg7HR96KmxT3ohBVH/27CUhbM2KssGhcGDKtKjUwYm2kOgT7hJfufAqEstYHFCqnHkyAagdDErmySTslLmoDYbMOFZIHBXO16eRTq4X77CEKHLWIGTt7DqUVDVlbDmWjFk62jr22K5ev6GdwucuPEkCKJEhhUVJS2UE1sL/6wuGv/jBZndppxhxOr166H7BcTkNfVpiqEippOu/RjiHhZVNQ9/z10rrHFlLqylVjqLCiIYdNxVr5MyopJOfKeOlkZrUzEGClIZKqcDI8RJKpUuUdU6y02rOtfH93HPdtXV9GJe7FJlrp8ZJoyGtWU5CWHI1wyjFZuJ+V3KLWZVyZrSPFIbKpBQmQQnL3GQYe3BLy3Crx8cuHMXO6GMLHYfNskyWtiz9OI990qIuZlP73Ph7n5ypza7qSjsu70nIrDxi9kuf5Ksvf+0ydjG4+q4/ij3kGSW+rF0U++tFF4Nl2blxOdqRumIn3F1t3FW3x5HbrVrmvv55kn3lJBBLy/x34FD0QegfC24Fbuf46B3UxnOt24VlUsjrSWMZbpRptGoEsePg2QtPASA8c9wKZC0Lh9Y4GN3/uJK9k8h7GH9vkGriHHGPULigJMLUkcoshxicXY7V7wQpYNfY2Y4yZ5FYe+P1dT1Ytb1XyVsXO/puxyAxe2vgphmIPv7xj/Pxj3/8yPMeffRRfuVXfuWG72dopEpGKHJzQCKdbEZ7Ly219AycXx4XrntR6uVeQKCtoLAJlZVOUiYM1Oc63zLi0ODsvQdJq+sBo160R2Eo/f0Xrq3T8r95PzrgpEUAEr34Aoy0yS7Pi3IzH7lMiNpLP4tlNEgKm5GIKoRH19L5cTkpfOXCq2SiYE+vgYSZHAf/SGHgtWn9b0PNFaqh1nrjj7SaRDt/M5XMmnOF80AkjTOqpXqGlmnw5eSpw0ATxay+v09DW0llXLn3q8O+CY4Db9BaN1eZpFtYmyEEGCModNN+v/vkVawdMzVjcjkP7aVE7GeqMSj6dimFy59kUX+vSQ5FuFCmRJkSnTl/PQjX7zMxD0ZBI6SLfoZrF2UqhLUoWVHW9QgwtvtgnWQt+IIS4sQNiqvgIN3k1P7LiPQeF9ENV1eJcf0jEUkwGCrjIpbl4xkzM64jDmpSmbNXjimNIpMVU3Nj7X5c3OrxERZ9p8SL1y6/IzHaC+8+Q01b7tMl/zrKMLHKonzZYr/PYLVKem2ZEnAozP1JTgS7oqMsk/UdVdY+Q9qy3+PPcVm90Sb26xRL325EZhbL9mIpYZyXvshyC3KyVjnbEWdiGVrbCLXMoHSUseg4BtTbibjeusrW1XfuFNyO8bHdB+8EqeCtRJf8cpVrrBAnKvnyeGb7Aj6Ee4g0RT3nqze03OaY81cZb6D25RVa7RrNoZdd075uGW7U4JGYgqv2FGvqoEnPGqxQIZ/NONcdZe9OQOc4GtW3iKJI32rEfaVtuIoRR0keMOCthhsXyw4YMGDAgAEDBgwYMGDAgAEDBgz4hsat3/6/ScjslFQ3UiJpNVLXzvKUo2taIVBCh4hhFoE2PpKYWHBS563KpYlkPrJmJdTnaNtIcIDaSe6ig+VK1hIgsWiLM8jADlJojE2ClbqKmCEGSSIqJE0ErzZcXus81GlaK2oZkiYREo1028AmkpbVTKKZmJCI4hi1fTS+euFlJHBgxqyrfWZmxH41IpHOkbAUJrCZLIJEVqh696mwtRNlbKjfjBlWCbRM0SRBfiWsberdlChTYYVjcUnh2vxQ3dvGabeuP0vhHJhPkoKDKrvucie6cFKtasr66D6kMOR1NL17R1f52ja8uHeWWbXO6fGcTBaRzE2FvPjyhx0XHEussJmrPysPOUPUJJG0ziBqps+k2MHkdZ+KGVWicShpaoflShcoIBEKnSXY6B6qrt9YOnmjzryvB+fOn+eFp+cILKOqdtptDbJmE2mVoWWCNJrx7CoAWbFHmU7Cs1kkY/Jsiz295iIWypN3rHknwbMvYue6y5zSxgyamJWxjDWxffEi52sWUXy8nWYXw6hPVhbfq+t7zF4Ct7MaO6LsY9/07Qa3mSJ90apuFG3JVpccqot5tYxh1P7Xp9GWo3WV2eeJqJ3idDwL50broi0Ja7N7AsMtyn8f2nmJnXq3yxWn0u6LR7EOVpE99vVVHwXndqD9fMXfu9hWbUaVT+Pc+fPs7Ozc4tzfeoSyR0wVj+MyrOKgG9ebxu3GqnkVtpE3WSRPnDvZOUEckdffzwcy0YEtHLte6JCXHSETPIrJssqYF865gSZ+ZvsCUki0cUFcgoNqn749LEv2Zb6evtU1ft0KxPV9K6M8xvd8/umvAYvsMe+w/BCbjn7m9DfSM31SGCRmbw3cNQYigwqSpHk2CeGwnT8WJzVLpCKXKkSu0vW/VW2oUMI6Q1H9QtJRmHglNLmq0xHGhbmvrxdYJ9USFUl9L4BCuchJlUixtf8XJXSIpBZkYQIX30wYF33MLe/re7sXhZep2XjSYpuXcnxMYlya1i/+ZZCyIWPJlXASu8g/j+JkFsqpKLEIUlFS2pSZdkafykiEEO5ORlFZiTGCPHFSHyU1mHThBeKiV4gFfzjaNjK8RJYLg3xWTZ3BQ7kXkUIv+Bvyxj+JIRU+mpn7tzQqGACvB+t7rwJQjDaZyH1yOcekzv/P5fkW2grWsoLToyYqGAJKmwbDoKjbU0V0bSGcJE7VUsOKZEEiBy50u1BbTNhxBhNha8NJ2fgWQjvtN6KWHyqs8Ma25lmxQjOq9oOPHy/lkkbXtSURGL584TW++Yn+kMI3C297x3t59eu/T1LNgtHHCNVEwEvGSKMxKkFWBUlVOrli/TI3QrGl30Dlzo+TFrNbXoZbiXgB2CUlaC/YFwwkHee1r/VoL9KPkuN0pdO3+PYL2y5DRWyUCgvflrGgLRnpmvR3LeLa9z0JtA0jsTyvbyEZ10vXYr5drtg457/HabWPdaURlz3Ow/WibWiJpWQ+/a7IZO189+WlbdSCw1HTlsnsltXRUX1/WV5vNbwBqM8w6J/rZZI6j4vb2+zu7t7U/N4piI0dbXT1k77n6Kg0jnqGjjpvmaH3dmCZTOdGEPtXDPeKjG9eftX82C2KWDAatarp0OZBZCA8zjPcyOyuvx3mjNg3E0ZqTkJJYooQZVhYi7JuAxTbGgtX9JPVV56THquOY1y8XUb0Qo4af6ctqeEyOW7XsbeikWjA3Y+7xkA0YMCAAQMGDBgwYMCAAQMGDDh5OAbRneGhZmAQ3TzcNQai1M6xIqWSjqlSkJOIEiNkoGlKDGNxgBUCbRMqm3DAOEjL1pN9lNAUNqOyKkigABJZkQjNWB6gjHPqPLNjoEVFRmCEopIZFSmFzTCmkZON5JRUQGXT4FQ4QwdrtKkjic1rp7k+Wppjj1SLlmrPaLXNDoIhweKYVF6WlormfEMTzSp22O1lWWOzd8Nt8fT2c2gUG/oKs2SNFDidXqUiCXUtsEzNiMokFDqhNIrSKHJVsp5MA7vK1GyXqRlh6khjvl6kMKSics6a67FKWoMBjHQsLUVV70A1bZDbac2caaR2WiQoq9FmghSG3/jyjO/85tGxyv38019jU2VMx2cokjGTajcwcgAe1FPqQqFVxixdZ8Ya2ipKk1CYBInrawC6Zn4BJHV9LDr5a/qCsa7GCpth1RaZmrM5fd3JzIRgVOySySlapkzTdSftq8tdJq6veXkcgDCa0ewaZer6OEJAvPtfs7nG4tZG/4rxwLu/NbCIAKxUWONYU0k1Q5oKVc2RpsLIBKldW1TZBKULpKk4XR6436pq2a3uGvQxT2LZWVtW02YBtY+fi2Rl0FDG+5gby2Rfy3bmu2RyXffqQ5sZs0zC1j4/ZtDcKLrkZT7/bTlel8TJH48/e0bSMmZMzFpaJV3/eyzRiuvjuNKArv7QVZZ2XbTz18eIimVTC0wyFvtwu27jtLrYa+289l3fJ0W7XWg/l0ftivf1ibca2nKjPsnZwjlCHGLQLJMt9clV/G9HMYeWjeHt9PqwKtNlFXZKHDDjRvHM9gXAzeHjYC7hXnXgFWFtCEbRhXbU2vhzL8OrJTdqt2EXu7Td7lYInr3wFG9/4p29ZezCM9sXqOw6uSzYspcdAzqwu0393pMrRyvzZW67WDgpdD0X4bcVx71lbXGz8cT5x3n+6a8tqhViJpxYfQy/neP8gAE3C3eNgchHXxLCor2UKNIlhwki1slk6lD1YyXIpBuEE1E5WqcsMVbVPmoUGoVCo4QLH66s+7NKHBokPR1UkwRJk4uW1vjTSfWcjBla1L9bHxVKIqmNFbVRCKCyCbloQr8H1B8VVXhRGVQ94DYvBe+Txn+WwgTDS/BYU7+I9uXmDbfFvnGh7E/VsqTcOCNCIlO0UEGelAnF3KYoqbHGGTyUsLX0yy3myzrKmRCWojZsVcZFltNWkSjt2se6e1UyJTHlgm7bWi/ZqkI9h34QRYuTwlCqBKMzUqn5/H+d86e+ZfXoVlqmWOmiwVlEmLi4fmeQukInGUYmFMm47icqyL1SqUP7xNHMnAzSRTjzhrNENAaNRCgK4/wm+XpTpsTIBGQSfBFJ6yKf+ecAXH+oZOYmINJp+7EWKcFa46KgyXTBOIRwvqAAHnrpd/k6Ke8+vxiK+Fbg2QtPMQJMnRfho5rU31U1R9aR7+JIgl6KZqVClTO0ylC6PJT+3YQ+mUz8Wxt+gdln0PHH2saZYACh3yAV37tL9hOnH+exvQgKMpolE7Sjyts2Gi2TaJ3URHBZncTnLDNoxeiSv7XL0zb09BkC+wwwJ2E48Ol0SQVXqd9leYvljV1pdS2gjzLIdS3A22nfbkNQH7p8gfnvcNgw19XGbyWDke8Hh+qpXjQu+MFpSVI6F8lLfuu6d9/3vr7Y1y6rytdckNeTadtmI+7GYREkpkDILGzsStFEbW0bbmzLANLlh2hZNKplz2+Xkcin0/aNFF9jhOKZ7Qs8fv6JI0rbIDGF84coKichi1w/hOi7dTSzPiyUo6Npu/J7VN+9GdLBcJ8en1G3Ahe3t0lr1xttI1GMO3V8HzDgZuOuMRANGDBgwIABAwYMGDBgwIABA04eQgqkujOMZkLfGfm4G3FniAhPAI6O6YqT4lgDmkWGjiYJ50irSShZY5dNcZVNcZWR2SfTU0bVPmO9y8TsMhYHZKIgFSUpBcq6KE7CGjI9Y6T3Gel9Uj13LCbsws6TEhqJcZIonJNc70g3MQWJKUi1i8jkj2fMndNrdM2q0VR4lkTkuLjeY1C2QpmKxJYklEh0YAzFcA6bXR592h5aJLxh7+dAj2+4LU6Ly5wWlx2TxopQLml1YDgJYcnFjM1kHwnkqmQz22ek5uRyRmZnpHbuWFtCk4iKVFYhCp3/81HQ4rpw7AUbHHN7R4fGuQJH4xgkmZ6RVVMSU5DpKZmdkYmStWRGIs1KO38eX77wGmeuPUuVjJDWNFItv5tnLWU6pkgmHGRbzNWESqbBKXgqKlJRkcuCVFSh/X27GSsbp+a4HbvUzsnsDIVmLKcLrDMtU2bpOqUaYWSKDcythjfm4ejLFi0TSjVCq8wx4VSKVtkiO0OI4BRdy4T51v1slW8eu4/cKJ678GQog5YJlcqaZ0MIjEwoszWqbA2rUkz9p9MRRiaB6YePeGdPxjn7NwLacrGYpRL/2xfl7Py5cyGNNgshvt6jj23hz/dSpT52U8zy6JMltY91pdFmUcRpttlC8Tmr3OM46Ep3lbT9dXF9tRlY7XK1r18lb8vaMW6zVWR9Hl7+5vPZxR46d/78obZaJoGLj3UxrLr6Z9/1fe2/jEnUJSmLz1lgNt1ixHLDZfXSy5yI+mj8+a2AzmezQ3a2KrOi77xV0+ir/2Vtt1K+RDwbEAuMldsJz2pu2DMmsLAFzbzMChehtiv/vRKyHibRobESGeY5wXFxHfW3T9YWX7MsD33YEaed2wSKwOpvs6OOQrscq7C6lvXD47CHusbuhbGn5z63q88JbFBxHPqt510xYMBbCXeNgQgaqqmwBkWFFDoYDRJTYpBUNqUSaR0VwJBXB0yKHdaKq4yLHUbFLnmxR1Y548G43GVkD0gogyHGGQAMiS7q82bO2KBnIRS4onLU2PqF5l9IqZk7iVM9+Ehr3Pm1HMu/fLzMKhVlSMf/Lq1251hNWt8zNfPmzxa1GaQKL1UPbxjzdRMW2SSM1Yw//M57bqgNnt5+jlJkJKZglqwdmlh5A1amZ+RmSipK1pN9JmpKLubkYu5+qw5cWShI6jpIRUkmSybpDIObtGkf2SuaGPj6lFY30r/YOBLlSZmKtJojrCXVzjAnMeSqRK5Iff2vT7/O/cULqHJKkU6CgcoKiZaJq38hOMhPUSRjJ5MjRVsXicy3rxTOV5bPg4/AptAkdfS70qaujLXMUVpNaufOWCSKQEUuycLLz9QSSv+vMmXoP9K2DIUycX+qnqBZWxtSRDAOGVnLKEXCwfhMCCV/K/HYE+9iDyeHrFQWIgZ6WCGD1EyrDJ3k7k8641eZjDEywQoRfBO9ldAlMYIm8lOfJMVLyvoWkO3F9qFJYofhIjY0HGXUiPN97vz5XvlY22jShbaxKD7WN0G80WgrbSlYVx3Fv3Xlxcv+uowWXX6Bzp87d0g+5uENM+37LDMgeAOP7wuroi9t/z3289RnZGwbbbrO7TIq9vWFdhpH9b++37sMUSdpVDwuvBE3Rp/Bp6/st7sMdyK8a4JO2dEyn0M90p7jbELdDHQ+3ysaimKzjBVu0++J84/fUH4ubm+HDT8/N7LIkD4s1qW1onMc8HlaOv4f2ihr2sPPmdtGIoMKxqH42kXDUPPZ+1M6Ci8+9RXnMgE3F/EbWN5Q5I1FJpKXLXuv+fEu3lSExT7X/tw+7ygs67+9Y7NY/n691fBRevvyssr8YcA3Ft7+9rcjhDj099f+2l8D4OMf//ih3/7oH/2jC2nM53P++l//65w9e5a1tTX+3J/7c7z44ou3ozg3FYPEbMCAAQMGDBgwYMCAAQMGDBjQCxfF7PazDYFj5+N3f/d30bpRDHzlK1/hT//pP833fu/3hmMf/ehH+cxnPhO+Z1m2kMbf+Bt/g3/zb/4N/+Jf/AvuuecefvzHf5w/+2f/LF/60pdQ6uQc9t9u3DUGokplpPXOg2PJEJzwCWtQ1pDLKXMxdpZv6xge7ncdWDneoW+8OyCNpkzymp1SHt5pwyCsQNDIqbR0TCUP52yviUqArI/ZmjZby9bcT5oM55Ta7R54ZtTifZUpkcERssE5uY4cEguFaF3vy+tlXrEzvPZuw3GxffEiUsCk2GGWrlPZtI4kpxYkPBKDFgmJKZjoHUqZMxdjlFiM0qZMRSrm7vrArimBMShCJC+Ls/JLo2lHeRDWItH1n/GNEepb1lHGMlNiZIpOVIiOpu1qBLv79Etk8x2qbG3B8bgREoSLEKdMGdreOSPUlGRBAueytfhvQoXfyPPOAr1z6tgJdmKdpHKuxiHKGwJKkZOIAiMkqTVI76zaO8Ou28Q7665kulB/rh+7nStd9yEf/c0I5WRsrCFHmje3n1l593D74kWsFTe823jKvBkiBmpU7Wy6cP3FOJmlVpmLblbvQrqqsajaeTWAlSqwq+52LJNMCXs4Spg/7qVNwSl0hJiZcpQMrGtHzjssbh9rs1Pa6cXXdLEfjiOzarNaYkZOV5mvB3Hd9tVZO/9dvy9jTbXrMY5c1sfK8c6dPZuoK6Ja+7O/fpV6ubi97diHLdZau67jz+227jved91Rafb14S6pWRvtvrWsT3W17Sq4uL19w2y1NvOvKz9txl3X5wEOXSyLrshlqzoCPvb9j9Emq/a7Zeccx4GwtObEomUJbHCpoFFIjAuuEbF6rI1YPpGTYStEmBPH6GPJ+fuFz9YGlwTuN7PAXFq1PsLztgIT6/mnv8ZUbZEzJ7Hlykyho7CsbZc5Ze463uWgvY2FMXcFaVpclxeOOX+EbrbscRDWRfU6qOudu+xdEM69iU68B5w87r333oXvf/fv/l3Onz/Pt3/7t4djeZ7zwAMPdF5/7do1fuEXfoF/9s/+GX/qT/0pAH7xF3+Rt73tbXz+85/nIx/5yM3L/C3GXWMgOlCbZDINYcXjyGBGqEbiRREMBOD+NTLBWoU0JVI0+mJvLErMFIGpoz05A4uwxi0shXIefWTq9NCtl2Rlk/CS8LIc/znTUzfJRlKpLBx3RqgqfK9kFvIKjQFByxRM6ei4UbpOwlYbner/oDGWgTNCeembj2h2Iwaip7efQwo3UbBCUpGGl6wVLmU/4bC1Ic3lW1GKPIowJkh0EfKpTIUQLopFMIJJQyXSECUOCJEjAErVhEdNTBEibgGNrKr2u2NrHzSufowzygBaKB6aXAIeWlru//r06zxx6SJ7px8DYCbXUKIi1fPQFzQErbyXhZVk9W+LhglrRTjm9eg+b0FCiQkGQC97nCcTRvaAXbawCLRVzneVzEIdBF9cMo36v6sDatmkrevNG1B83XkqrkXUfd2J30qbIlhOLb+w/YxLE+d3K0Uwl5PrCpXt8bXtl0CdYau6FCaT0lSuPb1c0zYTSp9/afWCcUjqEi0ksiq429FlBOmSZHXJy4BDhpJVF+vtY+00vAGhfaxP3uTTbYc1b+flqAV61wK6/T3Ox0lQyrvuE6OvPWK0y902oMTtG9dt5+Kodf72xYuHDITtfPf1gS7EkcXa17T7x6rt1Ye4DroMg0fJxfqMUl15jfPc1WZd31eBb1dvqLteI5FfRLXrusvY5o2/7WvanwccxnGlZidyzxWN3suuX2acXnjWV/QPcxLGITeHrIVfViy4VnB5aUcrkwsGnDgvS8eQ1k+H/BG5GT1GLD47FoEUGi2Seq4US9oi4xUCY1Xw97kMr3/1i4yAl8TD3Je/iTQaLeRCmx4nGl4XusayVTZPFsa1jsheXdcEf00d3kvaflFjA+Sy+WO86eHSbzY2bmSjUZkqzAu70GsY6miPwUh0+7Gzs7PwPc9z8nx5FOqiKPjFX/xFfuzHfgwRtfdv/uZvct9993Hq1Cm+/du/nU996lPcd999AHzpS1+iLEs+/OEPh/Mfeugh3ve+9/Hbv/3bd5WB6K7yQTRgwIABAwYMGDBgwIABAwYMOFkIKe+oP4C3ve1tbG1thb+f+ZmfObIcv/zLv8zVq1f5+Mc/Ho5913d9F//8n/9z/v2///f83M/9HL/7u7/Ln/yTf5L5fA7Aq6++SpZlnD59eiGt+++/n1dfffXkKvkOwF3DIPKSG8+SqWRGKXLHxhDOOXJiS0bVPqVyVkUjVPgMIG3WMI8i1o2X5niLs4yd5EWOsYUQiOh6JSvmNkdbiRKG0qZUJLWzbEWuxoztPiRQqBGVrZkQyrBWXQtsKCWrcL9pur5Qbs9I8pZ4L7fqpNNbApsq7JJ4ls+Kjgn7MDL7bO2+BMDu+gOuvilRugysIYEl1VN3frHr7ikViSwokjElGRUpRTImq9x50mqscK62JZa0mjIyu5TJeKEu/I6Od04cW/lT7R5sZasgpwInrUKIQB2WpuLM9CW0zCgT1y++tm15z/mHARepDJxE7kCPuSe5xONXn+S1B/47wO1cFSYDm6FlghJNu1UyrWnYjnWWM6MkIxEVxsrgPLuiYZxZHJtIoUmsq0ff3r7fWSvQdVQucDs7hakj3smcOTnj5ABpTWAmaVzeFA2Tqom65phEWmUYmbjvpgpsnINsiwLH+BLCoo3izeRBPBnTs4XWymuUKndR/5I1NmaX6118x27LOaBSGU9uv8C7zr/tWH3t1a//PqeBpJpRJmNS69q3qp9lzxIr1dh9NhWJcWPCPJlghWRU7gEwnTin7GXWeau7Cl2yG//5OKyOPlbEUcfa91hFotTeqYzzcZTcrc0k6bpXl9RpmQznRtDFLGnXZVe7tMvexcppX98lD+tCLEHrYxj5dFeRankn3D7ddjm7+tQypk5Xn1m2893+zTNx+q7vqp+uOu9Lq/ddG6XTzlMskYidllshwhvY9+3rZRHF9R0fa5fJ/95m8cW/v1VYRF3Ms1Wvi3E948RR912WZte1RzHm+sbg49SBn9MJa7DcmET7qe3nUUJT2iwwwzMRsaejvWwp9CFH1UBwHeHL1ZtvIQ5JprrK3GYJKfQC+6gd8MQlbvChRQySlGLhGY5l06Nqn2fFu9hM93mbeZ45k6AWiLEgB1vyvli4Zgk7sqtsXeeEMvaxsegYS2uJZdxmzX0cU71OuJcZ5eeQ/riOlAKiFgACGKuQQl/XGPnM9gUEhMjTWiSH+kW4Z5uhhiKzM3fNwBy6Y/DCCy+wubkZvh/FHgL4hV/4Bb7ru76Lhx5qlCLf933fFz6/733v4wMf+ACPPfYYn/3sZ/kLf+Ev9KZlrV1gId0NuGsMRJmdoawzElkhKUVOYTNMHeXKyXGc0SExBaXMMZH8zBsXuh74tqd7XS9yYzmZqKORQW1skd6/kCedumtnxnXayiRsqN2arqqR1pAxpyIltXOXt1oqlehu+cvCy2KFd7oVLjd4Q5qPnGUFhcn4lnfct0JNN/ja9ktYKxiJKWd3X0LNdhHWYjYexkfJ8hIoYU2QNkmrQ+QoayRCambpem2wUlQyRahaChdJBTUJVglU7Qcnqf36+DSd/5y6nepqSYyLPgccMg75F40/JqxBVgVKFChToGXGafM6T2/X19eyMCU0j9hnyfd3XRh1LyG0zSTJIBcMiUAw9jifObWhxwqkaKi3wceQ9f6WqF+4Dr4sQDAg+ryXwvUXKQylSanql/HMjBnJKTbyqWRwfnkQbsIlrfMTJQGLxaBQkZY/raZB/pgoibau366pPQqb89T284zNHsgxe2YdnSYu/9r5pKpUFiSYjSHX1ftzF56kFNnKVGGli9AvEj0P/pP8c6pJyCrnw8sKiVYZWbEHietP82TC/e95P2/8t9+hSCfM1YTpXTMSLkd7QtdlFImlM32GpK5rfPp9hpY+OVR7IR0bLfx3OOx7oL1Yj/9tf+5aHPed05f/65VDBp8+Hfnsym/X5L7r/Pi6rnZdVh7/b2wYWGZ86Vp4LRgXQmabY/7MPqNNVxn7jDN9x7oMSO3ytSVUy/qx/x77nooNc4L+vt7OR1xXXZLABelElE6XdPJ6FkHLjGpx2l3XxPdq+7W6WxEicnF4TDhWOtdhUF5m5LyefHQZhbv67UkhseVSuU4XfL9SpiIDDuw6lU1C9FYPP4MG10ZHLcqX9evmALX/x9poITrq5Ygqj31deuOCqQ1l/reCnJE9CIZgP0/dt+scqDU21AGb9kowDB3VLgvjb+R7aeEc75vzCONuu6/3lbFPJrcYxS26l/D/eENebCiq56DWBGOSsYqntp8PaxJN4tKuk/PR7FyajaRQoMOc+zg+jIAwB/X5Ms4p7OHzOuo3pcBHovYuOm53NMIBsLm5uWAgOgrPPfccn//85/nX//pfLz3vwQcf5LHHHuPpp58G4IEHHqAoCq5cubLAInr99df5Y3/sj11f5u9QDBKzAQMGDBgwYMCAAQMGDBgwYEAvfBSzO+XvevCZz3yG++67j+/+7u9eet6lS5d44YUXePDBBwF4//vfT5qm/Pqv/3o455VXXuErX/nKYCC6U5HrA0Qt4alkRkWCrq3L3hmzl185R7uNU2ctEsfqEEn481KgECVJJLWUxzmQ0zKhVDmlyqlkWjMkVEO7rWU7iahQomGuJEI7SZGwGKswVtXOr2unzDhHu4UaU6gxczUJUcCk1SSmDH8Lu07RPb1lO/zZ5i+GxKDQpKJkvxodu86NdTs7Uzshe/L3UPs7yINdlKlcpC6rkcb9JXpOVu6T6HlwJuzy5Cz5eXWAMiUpBcYq5nKyIP/zbatlSqnywBxykdx0oDo3kinH6Er1vCk/i7vEngKrpWs7rEWaElXsk812SMt9DtLNIJdLRclITjk7fYGsOsDIhFm+hY+64ds+ERWy3umI/xLrGD8lWeMYXJjQTr5OjZWBVSSjnQ5fD4GFVcvBPDMqszMMkqTub9oqUlGR1kwkKbRz9u3vVbuB1Nb166p2Pu0j5/k2st7xOTb0vVg+N7b7rOlrjIpd1sur3K9fYrO8xMbsMnl1AFAzfNKFZ80KQYaLUpeZGc9sX1ip35XJGFUVqKoAIQKTqpKZS1umWCEWIudZqVDaOetO9Zyvb7/IPF1j89oL7vcbkFd+I2AZAwX6d6iXSa26GEddaXVJi/oo8LGMJ2ZuxGyh7YsXF9ggnnVx/ty5znS95CmW3fTJg7okRzcCz/xYxg7y9+7KS5vl1VU2/5tnffi66Duvj/VylCxhlTppS5u67rUsOl2bvRZf19cubdZRu51hkQVz/ty5Qwyf9vlxJLd2Po9iWXWh3d/id3K7TO36OS57qM1MWsaya5fBf14WIfBuR/w+bh/vO7/z+HXWW7svnjTaz0rXb31o100TMOX4FFw/Xo+qfaTVvDE/xUznIXpsPIv1cxU3b+r5s8vrLDDE/HOwZPmzLK0udww+clrIr5VoqxZYRn4+sm8b1wgT6cpeCecWITh5rj/3/UE3uwXcvD5+1rv60nFcSrRWE53nxGdIa5rxTdh6zmk6nxO3BqkCE0d3iFoCw79D0ufSdXPteF6wDI7d6taDlUwpRb7Qj5bWhRW18iRSj/RELhxw58IYw2c+8xl+8Ad/kCRp+tze3h4/8RM/wRe+8AWeffZZfvM3f5Pv+Z7v4ezZs/z5P//nAdja2uKHfuiH+PEf/3F+4zd+g9///d/nL//lv8w3f/M3h6hmdwveIsKKAQMGDBgwYMCAAQMGDBgwYMBbEZ///Od5/vnn+St/5a8sHFdK8eUvf5l/+k//KVevXuXBBx/kQx/6EL/0S7/ExsZGOO/v//2/T5Ik/MW/+BeZTqd853d+J//4H/9jlLoxX2x3Gu4qA5EP8S6trq3REmVN49dF+F2GxvobnP0K4RwABx9q7Z2V2r9NZEH3jCFE7RtGOj21v1JYQyoLVO2wLuirpdPmFjYjFY4J5EN1g3OG58OgA6Sq9n1TM3M8vMNiDxH5jIkdCIqonO3ffXj5g+r4Xnq9g2uB5ZVf/z/YOvcgk2/5FvJyj0rlLhy6VGHnROkCXZcFITCy0Ws7dpTzGVQmpwCobIpVa8GZMrg6RyhSPUPQtJNjh6kFf1FWNA9r2/k4QuKM/o6JlNRhzmVVhJDnoio4JSQHI6cz3SjeQKsslKNKRs4RsymxUlCQI4VxzrnRKF0GH1c+DwbldlUijb1va6eJr3fkrCLvCAtKcIreOJX27axlSs6cqRmTyZI2/C6Xifp2wyJSgfVkEUg0RhhMNOCJmsXmWGpJpDWvfXOpbGGHScsEK2T4NzgRFzKw5/LqACtEcLK9ipZ8Mr2MKvbdvU3F1U3n5LoSqWNqmRItUxJdIE2BrVlRyARlSiqVkVDyyDvfx8H/9v9m8sceRFd7S+/5jY4uVoY/3vb508Vq8MyeZQyOPoZRH/OjfU0Xu6TtP6ft98X7lgmOllv58ojzHvujaZ/Xzv+N7uK3nTXH6fYxDFbyodEBX3ehbEsYQu16jY8ta8f4Gl+O2EdUVz9rs7KO8o3R54+lnc5R7dPXL2P/SF356WOXtetiWTmW+SeK02z3xa7yWyFC267CJDqqr8R57yrDW40x1IVlTIllx7sc/94sJtBR6HuOu85biR24xClPYkoKcXwWOsBodo29jVNcfH3C+fv2UVKjO5jVQOR/pisvkRNkn+cFB8/ej41nEHm/RjRphsm7m49530Rt9jk0vn7aeTFISuuCjShr0GKTEVN2rPOP4hneSji2f6HGgbkiMI1vpJAVz05aPKePQdTLfDpi3F31mtgfVB/Cb7b5bmvVRDgnqlcp3By/7W9q8V9z+H0gfP9wDqtXLheCSqQYqxbKEfyS9tRtcMItbMvx+F0jxlkJNyLtOmlcTz4+/OEPYzuehfF4zL/7d//uyOtHoxGf/vSn+fSnP33se38j4Zb06vl8zh/6Q38IIQR/8Ad/sPDb888/z/d8z/ewtrbG2bNn+dEf/VGKotsp8zIEqVEtwfFGocoqyjo6WCwX84vlijTQBX1EqIXIZK0/XUtlKpmFqFsVKYUY1fIZ5yzXG2AyPSM3B2TMyURBIipGcs5IzoPRyHvpNyj3JySJKMNfKXNm6TrTbCMYpdzLpwovKFMvxL0cLUxYakfcMT3Ul88v9pWteGB85fh1jmauM+4vnmd2zTkAx+gQHa5Qo1qa55xTW+kMeN5xsE5yZ1SQqpahFSS6YGT2GZl9UgoqUmaMmYo1KpGGPHsplEU0n2sDoLaJa1ck88RJ1ebJZOHPywPnyYQiGbM/vocynaCme8irbyDfeInk1WeZvPwkZy/+J85e+G0ml55j/cpzpLMdsvkO44NLrM2vBLmfRbBurpGbKZPiGmvzK6zPLrE2u8xkfpW8PGBc7LJZvMnW7HX3N3+DreoSa2aHsTggFWUjS4zkZEYoKuH6WSmcQSnVMxJTkFZTxsUOqZ6hqNgUV9kUV8nlHClMMOT5Nk/tPMjmEhpDkkWgaeSVWrr+XMmUIhkxT51D7kQXpGZOYspawuelna7va5lQqSzIL2O5phEytE8hRhwkG0zVOqXMGZe7jPQ+T20/z1Pbzy/0ta9eeJkXnv4q137v8+SXX0CVM2dkVCnjYtc9//XEqRQZs2SNWbqGkQmJnjFP1ygSF9VsriaAM0ZN/srf5oF3fyv5bOfY/f+kcCvGRzg82YslW/H3GP5YLLlpy5Xa8pSjFtbttNufV5HCxPnyn710qEu6E+crlrB1ybjiMt7IYtlL47ry3VeeNrqkYX3Xdxn/uuqhzxAUn9OWQPUZe4RtqP1dC804ja7fu2RkMbw8ryvdo+ppWV5W6VvxOV6y12e8iu+9bIHWzk/cf/vyGudnmYTi4vY22xcvdhqY2p99ev6Z8d9jOeRxjFI3E7dqfATq+YRcaMsgb/KbHEukOYtinMNywvgvluL05ifKx1F/vXk64h7tPC6rm7jsC8/adUi0n7vwJOvzK+RXX+HZ/YcoytptQSynatWol27pKFKY/6tIXCCTaL7jN6IM0hkEog27xqhXb1jVm8veTUMIJCIEjaxfo0zlpP349qvXB8KGzbbKJMx1ym454fJ8gxcOHmCmM2Y6o7TO/cXUjLiqT3FVn2JqxkFi5dYUSfjz64ymzO5P12sHX8ajZGnOibY81G+CdK+nT/X1t/h5OEp61nxvGbvqulPGRdWN56WKqvWnD0nZ4nR9GZ/efo6nt587lJf4fVyJFItcyTi0MDeJpGTx+OgjBA8YcDfhljCI/ubf/Js89NBD/Jf/8l8Wjmut+e7v/m7uvfdefuu3fotLly7xgz/4g1hr73rL3IABAwbAMD4OGDBgQB+G8XHAgAEDBgy4tbjpBqJf+7Vf43Of+xz/6l/9K37t135t4bfPfe5zfPWrX+WFF17goYceAuDnfu7n+PjHP86nPvWpY4Wsc8wZE6zKmZxTiYSiZpJ4FkWQlNUWb4MM1n9gYUcA2hImGdgSbUih3U4E3mq+GB5SWIMSlbN0e2t9vUNS2YSkJddxuxQ6MIB8GT1DKC6Dzzc0rCAiB71aNvI1f077+6Vitbr+yoVXGyu+sLz3VUfHmz94inRrEyYbHOSnmIkJBkkuZozK/VAGG/49TFNVtXxuXLj8aZUh0o267M5hspfY+bCgWsiFevDhUf2/GoWRfrciZinIYPWXwpDrAyqVYVWCKAvs3h5YgzD1NdrtGjGaoMfrCJVSpblzVJ2sUdUsNV+30mrnRNmaWs5W78qbCqkLqPOi0zFklpSpk9+lhHz5skprQIGVKcYKDM7Rs69TZQsk1HIt10crmaGokDTsOBMxx4TVrhWlQFoTGG++bWztPjA8J77fSUj1nEQXGKmadq0lfr6P+nTCjn1Nm/a7WL7tTb0LCKCSCcIaJnqHxJRc2Pb9XGLIsQjyN1/AJgloHRhp0pSkWjimmmfLCSdbLFW+6KwaibIV5554Vzi286V/R5WNuR24VeMjHC0x6GIYtaUo8TnL2Al9kqKu87sYJl2/xXIt4FAo8jhke18Z/bWxM+yu846qs2UIMrkWOyYO795Vz1356JMFLKvHZekfxUjqyk9fXtrl6aq3LkZWH8On6/pljJk+hthROIqtFX/v6lt991pWB3E+vays6/dDEoqOc9qsNGCBCbSsv7Tz6+V2cTkFh8PcL2Oo3EzcyvHRvzd6f68lR/XJQL/M5pDULJYoRe9agZN09/XJG6n3Zf3hRtAum59Tx2zkPlzYfiaELFeAkYq9e89RzCWTEaRSo6RGCuP+aufGumPO3SXrMzUrxKJadS4RmIWQ6VLowAjxjJaYYWRx8xbF4nxZYIkl/r4OpDUkVCAcE0obhbaO9TTXCmpXAhIocfNOIWqpWc0+gib4y8L8PsqTrxMAJXR0Xrc8q91HrSXIsWJGTPy5V77WOmfh3RPdexVGWRwefnHNRZjHHrp/y1VG6NuiyZsUGmMVT20/j0QHWZjCNM94VDzPHOpMdwniMVJ2pHE3Q0iJkHeGrO5OycfdiJtqIHrttdf4xCc+wS//8i8zmUwO/f6FL3yB973vfeHlDvCRj3yE+XzOl770JT70oQ8dumY+nzOfz8P3nR0nDfG+h/ygkpgCIzZIhIsktvASiSRl4F8ezcLew70I/AtAhWPSarRMnAGnHpT9AlxSjz11lC2fnsA6P0UiwdaDojcEGOuMFX7g95GrXPrNYOv9uPgFuIgW9spW4bPPd3hJmOblEvwm+bLWaf6Jb1rra8YFyPolaxGUJqHYegCAzXMPk95/P3rjNHMxZmpGLoqcgiwZASOSOtrUAk25frjTaorUZf15F6Ny0nKK0s5IMk/XwstBmapuR1cP3ljkB39BE1VAk4B1+ZaiifCmUcHvU8acuZqgbIUerSHHa7C3h5nNkEIi0voxERLmM6QQzNfvZTo6xY46E6Ll+X6W6jnCaEfDTZwu38iEfHqFZLaH3N8JhiM1WkNNXBl1MqJQI2ytqR0Vu6H/JGrEPJ2wLzdD20/TDVLjosIJa8Bakrq+lKkgmSwYRONJh6jv76nSC20SUbsbI1RV9z+Lj2gmjcZKZzj199HSUZ4t0Us4yNEbmjiwEF3QWMlMTJDCRbUwQjG1bsxIRUllFbviFPdsnMaoNNQXdXvHhjmLcLEx6n4hlQkGLi0ThDWBgvyO848xH59GHzRjyq3CrRwfY3QZa/yitWvx2zYKLUsrPr9tlPHn9y1W2wvitlHh4vY25yNfSNsXLy4s2tv561soe1mUaN1nmcFqVWxfvMj5liHLp+3z21W/cX7bxpuuvPSVs8uY05V++/w+I1XX9XFZWdI3lhkI+wyC7Wu78tNnCPPGl5C3JefG16yS7658xOcuM3K2r237QIojzi0ziC0zSsUSv6PasZ3PttEvlmLcTnnZzRgfoX+MNPUGxjJ4/yOhjq/D9hIvoP2btlei09M3r/e8mwE/R377E+888tx4Ie2j0KblFCktG2NNrkrSWmLvfTlC9yI+hq0lZtYKdG3k8feKpWQiivC1UIbIv42bPzTyo7AGaBlswmYsbp4pASEUKUXw5egkcQJjBHs6JU8MB1VGrkoSaRjJph826xFBFUVAS+uouEW9CVnYNOQtlW4u3DZi+blWiKYbGYzqE/DRv/y9ff3EeQF6o3QtHBMs1N+hc+tNQl/XjUGujmbcOr+9ie3TFdYcMhJ15dOVwxkDjW2MgmEMjMraTqMPcfQ4aY1719djd+zGYcCAuwU3rVdba/n4xz/OD//wD/OBD3yg85xXX32V+++/f+HY6dOnybKMV199tfOan/mZn2Frayv8ve1tbzvxvA8YMGDAzcQwPg4YMGBAN27W+AjDGDlgwIABAwYchWMbiH7qp34KIcTSvy9+8Yt8+tOfZmdnh5/8yZ9cmp7osOZbazuPA/zkT/4k165dC38vvPACAEqXwVG1/0tERSIq9vWE0qaUZAsRlA45KRPxzmATdQkOU4m9tdyzaXS9e7HguE1ItEybtOIdCGvJxNy5oRPVofRVzbZZYAJZt/vh03IOtReZIQ07qHGAqExFootOummc/ioobEplFYVJuTZf498efDuvb5wjO3eOg/f8UebrZ50zPavQRjE3GTvyDKVy7JhCjZyUq2adWCEWIo85GZZG6jlSz8lnV8lnVxkVu+TlAco4dol3ap3qeWCNtHfdrRCB8WSQgZnlGSbe4WFJVjuhVJSjTfTmPYj1dYSU2GLumENCYicb2MkGeu0UO5P7uSLv5Vq5TmUVVR0FLK8Owu5HlY6ZZRtcGT/ItfxejMrBGBACm2bYJEFUc9I3XyS9/ArZtVcZlfs46ZXrm/nu6+S7rzPef53J/Crr+iqpKIKUq5KZixinMmzNkvH3T82cTE/Dn5ct+v6sTEliCqTQKFEFCaTfcXKOvz0boaEAe2fosQN0cIyu0ma1s8hFB5L+OXHPSu1ssa5/T6murHPKCI4VVpiUwqRcLraoTMKZ6jV2Tr+dcrzFfHLGRZJTI7TMgiP02Jmk7++xo+xKZTz6jvcER4iXvvLbSFORzXdXfgaW4U4dH6F5JmKGyTKWTPt4zCZo71j7nbQ4zT7mSCyHWSjrClIozx46f+5cM1507J4vlYq0mBSxY96u8zzDahXE57Xrup1uXM4uSVZcNl/mdj7isnTdy6fdxTiK67vNFOmTW/XlO85D373j+oyv72rHdvv2pdEut3fUvCqWMS+WyQxWZXl15b99rWfstOWHXWy6rnaO+0W7Xtt57Xpe/HHP0mszkZbVw3Fxu8dH6B8jDUktq16MmNXcyx46dtRYE87rYQi1JUHhXj1zsnafWtae8b83E1bIldhDMbx8frT3BqqacXa8z8aoZKTmpKIkE3NyMyUxBYkpaNxSaxJbdnxfnEN3zYndZ8dYkdY4J88koV2dSwfXnqZm9Ce2nod7FpJorRnq+k/quVRupuRmSirLICEDR3QVAqSwZKpinMzZUHuMxQFjcRBkZp515POsMEzEPiMxJRUVaR18x1gnz6qsYq4zDrRj7c9thq5dA5Q2YW4z5iajtKmbX9UOsqu6r3vn1q6M3SytPladU0/Uf5EDbF9f8XqjYRfJ8HzFacesoGXrkS720MKY22I7KVuR2iKoS6Q1h8rj2z92M9JG+/35+PknQnChJ7dfCIGQ3irwUczulL8BNwfHlpj9yI/8CN///d+/9Jy3v/3t/PRP/zT/6T/9J/I8X/jtAx/4AH/pL/0l/sk/+Sc88MAD/M7v/M7C71euXKEsy0M7Qx55nh9KE0CaEmF0kFflRnM6cYPpLueYGsWUEZNkGgagRFQhzDtQG3hqvzRBfgVi4QWz+EKvQgQySSIkyupG9xoWzi3qsku09tzv7u+NJD4f0jaUSG8sclG6osGVZpLY9otklFqgaYYFfus8F15+uXb869svotBu4W+drxYfRv2b7nuduc25/J7vYJquMzNjSpOQiopJOg3ypamd4KtRCkMuZwuSQCMT5vkGqvZtI6xxhqK6XUf7b2JVys7mwwDsJGfZrC6ztv8a6+WM2dpZymRMkSz6kjHC3V+JirSaAVCqkesn9cvE0UPdZOHa5AFG6Tr5+lk4D5UasTs6A8CBWaM07gV7MM+ozOLLyiKoskdCujvVGvMypZpLEmmwG5Lx5CzSGvaSU2gUY7vP2Te/TnL5VeTeDsnph0mTEWmdntq5DIDavUZyz31MAL12ivnaPY1vqjrynhEiyO9SPXX1azSqmmFUTpXkGB9lL/hF0ozLJsS78YY7Fn1oaZEslNO35UKUvJpGrO1iH2tP3HTdhzUSicVEsrNUVlSsk4iK9774WQDGf/JjADyzfYlds8la5vIbJsGtCYW0mtTMFxZsWqbsizUy4SjdZ64968qrUpJIynijuFPHx2UGEO/Lp+2/py2biUPFd8qNOu7Vdd8u+ZVPM75nnA9/nj/HS7liH0Rd58ff28f953bI+z7J1TLEdPM+A0Wfkaid1z7jWai3HkNQnNYqkpO2kaLrmlh62HXdqsbFrvJ1GUDivuYR+zpqo68f+e99ddF17/j+7XS7jGxdBtCu9usqX/u3PmNq+15d+WrXU1c/b5e3K+12OkDn83UjuN3jI/SPkdDM7yzK1bf3V9OSILkNFBnCa69SR6sYibqMGteLrn4QH78R+Hf9qgiST58HLKeuPgtCMJ2cZaKm5OOCdXbcpp/RwRhghCTVs+jezj9iUx638Ze0NqxiI5E3ukhhyOyMrJoyxvKKehvarDNSc0aiWRsoUTnZlTdI+M0x1EJ9Kqpwf6mb+fa9yavOyZKq5/mqmWMLrZGVm5tNR6dd/lLXl6wQpKJ08cxsSaZnpMUUKxQqc3O7sUrCHKdQY2ZyzNxkXJ2vAzBJCqQwi/1Kui07U9eJ7wNJFBpeCR2289x1ZsEg6mVooRxRRDIXPU7U0jVbu8uoNxutawkng9MLc0WIfBHVcjPokZi1/Me6Yx3vSp9na9AiWdj8+Pr2i67clJ1yMp/XkH4rrxIT0hO4d7JEhajZAwbcTTi2gejs2bOcPXv2yPP+wT/4B/z0T/90+P7yyy/zkY98hF/6pV/ij/yRPwLABz/4QT71qU/xyiuv8OCDDwLO8WCe57z//e8/btYGDBgw4LZiGB8HDBgwoBvD+DhgwIABAwbc+bhpTqofffTRhe/r6866ff78eR555BEAPvzhD/Pe976Xj33sY/y9v/f3uHz5Mj/xEz/BJz7xiWNHoJjmWzA6Q1bvNIzm18iKPbTKODW6xr6ZUJmEwqTBcbW2ilQUza7agmVahl0DWpZrgQVrqMRo8RpbW5trp9cLu3Y1q8RbrY1VIGmYQi2Hbwu7ofVPImLcWOGpsjowPtp5X2B9SNlEPwvlsVQ1C+Wp7ed55/nFNvNIKJEYdB0ZQgqfZ3h9usV942vMkjVKm1EGRpUIuxECl5eYWVKRkmLqXQNDkYxJ9ZwqGSGscYwOBUkJ0u/imGZXYV9PeGB6ASNTkvkVRvYNknydJFtjnjYOt4UweM/hRiiUdTs+iShdtANPVLYNC0aniv10C3CsoYPC7TZWJgntnwhDohYpuXOdMrNZoAlPywRtBUpYkDA1Y+Yyp7QJr+5sMSslG6OK09nz6AfOkcx2UNWcvNynUjmTS89hxuvIvavY2RRefgGxvk6ycwVxX80qkwlVvo5JshCBIykOQn8BHBOLOUrUO59SIazupPcmpgzSMlkz8gBQhN25ONJHm7mm0CDcjl2X4z7vfNFfrz092UqMlVQmYZJM0Vax94CLNOY5YWvzq8zzUbTzpA7tUrlym8Ck8ueWKsNYyfnzjuXx+tY7XHnryCu7yclIzFbFrR4fzz3+OG++8UbnbnKX8+SuXWbvwLYLXayEGIGlFKHNiuhiSfTdA1hgEbXz2MXY6GIHnZQ8w7OH4qhQ7fT6ZEgxunZEPYsnTqPrt2X5XSUPXSyItrPnPnZTV977JFLx/fvy09U+vm3PdTDHulg5y9DX/jFr6qj8tNPqqoP29bD4LPQxgrrYb31MOY82w2+V/ttmMPnd8T4G2K3CrR4fAUZ2n7Fx76ZCjdA2QVAzEqKq9O8ZaQ2aBG0Txzi5QabVSbCGFtI7IebXKunEQR/6EKchrWZn621sXnsBI5WbU9bsk4YV3wS/WMhPm2VVzyFTCiqZLgSfcRyw5l9jHcvISEVe7KGUYWYyCrOGSC0JVZizgmMMCeF4M9I6Vo9n+xuUc7Ls31vCBCbyqKgj0GrHgA9uEGSCkT7Kq0SZklLlzg0E3k2Gc94tTRXUA1o1SoLcHJAVe2TTq1iV8ubpJxDScnbUuA840GMKnTjGlKpQGCdjq+dkjqVkakZ3Mwf2wXKkcDN4YW1QRLjnoFuGpqgW5tI+Ap1z69AwkbybB2HtgrIidtDtIro1QYG62n4VtJ9bIDDVjVBBPrhwzRJ5W8we8mXGuqhpOdOV83U3YIhi9tbATQ9zvwxKKT772c/yyU9+km/7tm9jPB7zAz/wA/zsz/7ssdPSIqUSKWWSM9E72DAIKyqbkIsiaHOFsGEgrEhJbOkmQNHY4IwFhwepJhSjJaEMkcg8Aj0zkr9441M7WkWIFiWEMxj5NGwUutJLeToGxqDxrSNSxXk8bDRyvl8UkZEJR6HNqlmI+NQFhWZWL9Nz6V58hU3JlA6SIW8AirXTrt5ntaGoQIok1ENq58FPjBHKGdxko+P1L01ptQsxDwtGL2sEz6y9j/vsK6hin2T/aihXkTYRTwRNhCvvN8fXmUCgqCgiw5aLEJGH+plW+YKULJGGRBhSVaLCJMIZNqZVyqxKm/tKy1hV9XWV81Wkc2Y6YV5JEmVZS+c8P/lmRmJGslVSkpFZZ+S0aR2dbbKB2N9DX7mCfv11rLGk164i0hSRj5D3PUI12XQ+jnBGo2S+i6ijwlmVYmVNmbcGabQzEnk6dT2psUJQqQxhnd+qILsSgkKNaio1oS6X9RchbHgZt/tu/DyFF7Zt4psUxtXhNN0A4I2v/md2RmdZF4I1s0MlnS8xgTNy+fDD3igkra6NWy5ahvMpIPmmJx4M971WuQXERE2RwqA56C3P7cJJjo+w6GcmjlLUJS9qo8+Q0SeLaV/no4Z1nd8nAVtmvPHn+XTb53QtaH1Zj5L4tMsprPNt0xfRKZaX+XPaUaWWGWj6pHAebaOT/9cbGvp+83mIDXs+7VgO1yc/a0u12nnrk2e10WUoio0kXW0QS9t8G/syxAbBLiNjXz0flScPL7fsM3D56/vaq6uO4mN9BtlVDGxtI20w8AJtiWgb3vgVy9DiMnX172V1eLtx0uOjx1yOqaJIUV0I8xiKIGVaaE8aOdrtxFHSxVWwynl+zrJKGgaJMhWj2TV0OnFS+npjyW3kyeBDKhiDorDnXtbuISN/nYkpF64xQoJNFjarvJ9QI1PW1B6VVRxUI2YmJ5OSRFSkLErOw8ZYnQe/savrOasyJVLIRWmUL7PPR5yeVM6tQuLmqgLLuNglqaYL5QTQKgv3ARfxN9+/BEA52mRz+rrLky5R2vXH17beyVW7VbtzKIJBaGZHbpPOCnI5X4hyZqyso8jqhb7vfAw1krLQpt5nDzqsX7xxqbSp8/vp07POROfrwW1um2C4W6ibel0UG3hW8ZPaNUcxSJ7efi648rDUkXHr9o2fz657+LWZojo0Pub6gEK5je39I3M3YMA3Hm6Zgejtb387tuNF8+ijj/Irv/IrtyobAwYMGHDHYRgfBwwYMKAbw/g4YMCAAXcIhDhyQ+KW4U7Jx12I28ogOknss8FBeYbHzZMA6JoRo2XClrlEJTPydEZVW7Y9DJKpnZBSup0NahlWRGP1TB0p9IIjNYMiFWWgsC5Y3X2nbc1pYimZj5gRHOh59pGwlGoEEHnf1+G7S9axkTyl1stswDktDhb92gmd/+5cAjeQVnMtv7eXGvz8019DCCfFAziwa2gfYat2vGcRTI1jGAlP7BUWJRrKa2IKkmhXxjN7XL0JtEzRpAs7CiKpGVIpZOU+RigKOWJHO/ZHKiquiHsZj666QcJaynwdYS2lapxQembSoXqq7+Opx77u47ZMpSYRbldkpJyDY7/r4h0eJ6ZknoxJ5Zi1VIW8+fR8/5nqEVIY1tI5a1tz54xcGEqTULLuWEg65f6Rc0z95n3f1DCyHqlYm7nj+e7ryDdfgaTeVTKadNf9ZvJxYM+FNq4KrEoxKqFI1yhVviCXTHHlEG36cDTwjsvdwMDyFOtYhmmFWujbEkMmikBhjh1Gxrs2StRsOQnCSuY6RRuXf5278pVqxOb0DZQuSMsDdib3o6yhEumCo0EjFMqUNWtPU9YOy/eTLd59/pFw3s7v/Tr3bj7KPo6hpK1iZhvW2d2Ii888w8bGxiHmgGeg+O9d7IeYRROPHTE7Zpn05iiJQp+sx//bJVcDFmRXbXTdL2ZKdcnOYulSnEYfc6idH4jYLT3MofhzXH8xS6fNEGqXK26PGDG7JK6bmGXk0w4Sp4668G3RxziL5V19DKw+5ok/r82iiVks2xcv9joyjz+vInuLy9Sulz5W3DL2mW+Trv6zjGnTxxLrk9Z1ldPnP762S/bZzmOcfrvt/PG4rbskiychVbrTkekZm3u7vLjxXq4V69yTX8Xi3nGB0RChzRrSJBFToZk33moW0arywOMyidoI7hJwDJm+SI8xy9M7K56mG4GRo2XiGOXSBQppK9MbRlDD6I+Z/J5p4+bKmjgyrxGKQo1CVFiAteJaKP+o2mdXbLCeHlCZhKye5/qyOfl77YgcAUIGprLPWylyUCMy2bConJPthsnUhmfvlyqnqiNgZXKKydbriKtRMJqa8eQZ99Nsk+k9m8ROmzf3XyOZ7ZDsX4Wy4HS+QZbPsEKyPrtEPt8hme5AVVJunKXM1qiSkQtYUs+/PSsrBI4Rql7b+PssOqiW0XzRr12MkG6NVUdZ81GEAYxNcZKs2qk3BikatlKbZRYzicJ8dQlb00PZOtIbioK8jjDmXDtYK1hTDVs8dksQ16dvu8qmpBSd78JEJEH2N6oGDtGAuw93jYFoanJGwJX8AR564w842Hwo/OYH18QQvPubaNBzEhMV/Oy04V/y3sBgRf25Pu61vGGwacnMoNtg1Jzf0JElxhlzImlZYouFl6Cj22q0SGodvAtXGaIKWInX/SamRNfSLhlRR33elSl5xzvf1Vmn2xcvomq/PYkpggxNG0VVG1QkgKkn3F5nXBuGtFUooUmMo81KFiecQQoX0YcRcuHlPE03XJjTKNJaIjRzq3j14DQAB9m3cHbtTTbml0jKKdN0Y+ElF9qgnuwh3P1D5AVc9Kyy9jGkapqsu16GKAuxAc9YycyO2bBXSUxJlaZsqF0Km3e2LRAMTICTtAmC9BFgrGZMEieJzERBIZyR0CDJxJzLk4e5prcgfy/vUv+HS2e0iVEpo51XEVq7yaxIMUkO6RhpKkTVGOaMUK4/tCSJ0hq0ypnLcV0HmrX51boMJhiHfNshmueqSchNkn25w5+wjfxQOD9EHq5P2NDmmawo6nY4sM6X1L5aJ01KxsZFL/MGqthfgWvfxj+SFYpZ4q5PbVPv4CjbAGNxgEZRkt31USi8EadP0hX/HmOZdKy9QO9Kzx/vMgLF6JNKdU0IuwxJseGj79rY4BIvon3+Yr8wvlzLwtvH+WhLpjy6Fmdtw0+XsSKekC6THsXH2ga8dnp9+Wun540QsayubdiJz4+lS31lat+zfb4/t8+I1y5/l9Gwyyji4dPtkyP2ycX8MX99LJWM+37bUNN+ppb54GrXT5yP2IjYdV6XMaft36htqO0zjHXhKOPu3YS0moFSXJq7DaggHat/j+dYAfWPylSdBqRbjVXkgCctG+wbI9tG6NAfEeTaLdLjeS2mNkpEUi6PZu5hFuo1nncHA0dkTAFn+AubWjSRihOjWTu4RJY5/zGvZo+xryeM1QxpnfuJcJ9o80vLhFS7OUUlMxQVJRlaJBT1xq6SjaGwC37uMjfNHG+abgQfmbHLh9hFwuL1zXnzfIMyHZOMt5xrACFITEFWzVC17K4ab5K9+BT5tUukp+/j6n3vItEuBLwRilm6HtL38yjnhkMtlMPVq4s/Gx/L9BSLIBXOv6q2yhmKWhvGfkPWr6MAZB3dzG/gSkz4ve2fteu9smjMdvlKrHYbj7VLEVUbo9rywaPQNyfyde98lo0PXTdgwDc67hoD0YABAwYMGDBgwIABAwYMGDDg5CGEQMg7Q9olTtDYPWARd42BaCJnTr6jryHLOfnsKgcTF07VOyWWHJbReKt8l1PnNuLdN3euObSL29zPH6upi97ALRZ3I2JYRBMFABMYGJVM68+G1BYhXeeMtyDFyXAsgooUJSoSU4Z7ljhLt0IHyRrgImUVO711ev7cOb6+/SJj9qGup5nOyVRBpTP2yxyJRVvJKKkYJ3MyWYadAl8mx16ygTXk60iZEqxFqBwhazaRFYHD5XeN/O5GogtGep9MzLgsz3J2XHJQjbg6HzPVD2LMQ5ye7HFKXAEgNW6XR5NQ2qyRD9ZOja0V7FVrrCV11C9pG2mZKClrR5WJ9JRVGcpmcZG3CjliMr9KUjt0nkUR1MJumN/JEg2TpRIppU2DEz9Pt/X0WOwiNVlaTSVSNtUuFQkvnv1W17Y2JRMFk/xUkKDN652gUuUkpmTj2gvIckZqDVhLNU7RUX8v1SjslhU2czs/CKaZk13lcsa43AvOn/dHW8zMGIPkHvNaXdaaNaY8C6sKO1MVjazTRYDTh54BJQyJ0AhpyWqH4Qe62ZWZMmJfuPyMa4eYCdWCXNTJQJ0ETljjdrSEJNVzZv/2f3VpPvxudtceiORukoRqgel1N6JLwtSFLulJO5KVT6NPBtbFUIhZGKtgGYvEM5Ha/7bZIG1pUcx+abNd2vn194wdULcRM6LitNt12K73NlOpa0c0sGFaLKa4nG3ELK04qppnR8Vt2ZaSxY6LY9aKP7+vjv35sWSsjzXl89OW7LUde8dsp7hO2pK/uD/F6XZFOutjdXUxavrOi/Pbrpf4vC7GTtw/2mn765Y5jO+TnvUd68p7F3MsZo11oY+5dDdCFQeIrHl/71cTtpJmfmRrgdSCKwH/UXYwtqKotXBzZHrXy/C6kbys2hfa7w6BDfMMIxxLPtFFHSHMoKV1TB8LRKxyx3b3927mLV7+5FldsmM+7plEmW1YRAfJhmPXKxeRLC/3sELy8PRpZtkmVLCbnEZbFZjFCdqxya1CoClVjrCWjdmbALyeP+pUCDIPkVGDE+eY3VKXxLOC/DmFTpFy7CT3QiwEfImv9SwYReXYNPX1u9kZF0PMlAus7jLJqVSGyU+5On/PIxih3FzOakTkNiAEgBEiyOgEUNUBajQquEWQtcNpz+BSVEijHZMOE+R2lUypZBbSrmwaHJL7NY0mCf1CRvLA5p+GJearUvgIya1+BW4eD5DqmftjdmguHkd4DmyzyF2CbzNFhbCWp7efoyIJc/g2c/12O6MfMOBm4K4xEHkfMVtvPoNJc6SpyKoDKpVjrQThQq+3pTWNBnXRqIGlczBpXlrgQ823B4fYv0u4xhs7vK+bOsJSfB74l55Y0N828Z1kkxfRDGxOC2/cwMbiwNXQbuPJZCMVSst9ntm+wOPnn+isV4GlFM7AVJLV+bGsJTOsFWy/6fy4bE0UeiQ4nVXBX5GpJ1OVzFDahewMlGKjEUZzkJ/qpNPG9/fQMnEvI1sxUY4WrFJDoRMu7+fsThUvyRF/8r5XADf50GkSIpIE/wA1dVVbxVjN0FYFY5xBkooSJSo0ilRWaNu0k28/gFSWIeJDUk0x9QRkJteY29y9TOsXmRSGkY20z8KQiXnUB5qXXYiUYQp3z7oNU+ZMxVpoW2dM0xQ2I5X5grFTywRlK9JqipofIIspUiqE0ajRqVrG2NC7c+vC25f1i9YimNvM9S8jSOUcZQVaJszMmLnJsAhmyRqjah9lKvbTLTSKpPbnJdHu5W+TJkJGZGADgryuNAkjOWckpmR1H9+1ztCl66gbVW040t7Hkmj6R5BnokhrSabzceUMZZfO/RHSao6RikqmIYKGwoUn9sbDuxU+zL1Hn3xnFQlL36LxuIvITuN6j8QnXtAuRLPqMZTE+ffSoq4FcpcBp0ty1WckahsO2saf2GjRPv8og13bWNJ1vj/H3yOWmW1fvMj5KDR8nK9YktZl3IkNH77sXRGw2vUV563Lb4Nvv7b0KpZqtY09bQNP7OfJp+nLs2Dw6DHwdLV5+5w+w1Jb4tjll+soo0q7vnxdd/lH6pJCto1/wtreqHBd+VilzHG/akvj7lboJEcnORvplGnVRDKlY57mETYabLNIbN5JjY+++ofm4w0ai7r65Sq4GUaq5y48yWNPdLspiBHPk+dyjEJTyYx7rm5T1Ya5avIAFWm9WdbUnffJU9l0YUGeM1uYMxpUI10SzRwUmrIbFNZCKQRlmiGtZrL/Bmr/KiMh2T/7dgqVYa0gFY2fTWNV8I2jhJs3zLIN8vKAdXbYZcv1AyGC8QIaQ4g3qghra/cQOsw7pGjcGih0+AzNHMn5Q5K1T57UrQui5pQYtEydi4lWv/MGkliuZoRCy5TEFAhrw0aysDbc3yKojDfuqDDPUjRSP7+xrdJ1Uj0jMWUj8zIlylR4f0veJ6evEVv7hnJytkWjWajvqN/4tZCt/bd6VxrKuvaobNqUQ5qw4eqjFzeuLKL3Kc5lR9fz7e+nqJBCk5iymWfTjK9vBQP6gLce7hoD0YABAwYMGDBgwIABAwYMGDDg5CGkRMjDztdvB+6UfNyNuGsMRBZBIqrgnDrRM8cQqmVNwjr5S+zoTUKIegQNJdVHGPBWYUUZqK2L9OKu3WsZmDtGSHzUs2Bhts5C7pxce2t44z3fO4aLo2AoIgeItom+FTObAjNHaIxVFKKhqMaRNfw1IcKGVL3sIeeQM8FGVvzY0fJ6OuUPPXjA5fkGp/M9dssJlVULjopLm7JjNij0vSTSMFFTlHA7JwklJRlzm9fSo4pUFgsOAgUmUGcBSul29jLrIjSkomA8PgAeYJQm3DM+4Ko6y4a9ipYJB3KjbmvjIqmZEisEpcwpcGlNxH5TPySO3WUjWmvN1vE7OUK4vJ6dvQjA+MpLLm9rp3lWfAsAs8rL0wxrqWNUybTeVaEMO0em7gtAoP2CY52leo6WKcpWzJOJOxY52Hviicf58oXXSOrdrGm+RRyNYVTsks12QEqsVNiaQWRxDgxLNcIIGZ4BZSukNFRGMdcpmarqurMUchT6aogGR+Oo1QQKcUJhMwyCkZwzMzn75ZhplTJOSkZJwZa6BsJJ/7I6glqq3I5Ypqchgl8um7Jqq9irHNV5rxqzlsyobLLgXNrvLJZk7pmNdp6map19teV2qSyhDvxuVmanHU/A3YNnLl5kY2MjfF9FOnIUG6KPldEnaVl2fZ8kpku+1mY6xLKcLkZUzIrpcxTcl7+YsdFGm7HRx1qJWSZdMqJ2PbRZNV3572NJLeQtYuu0y9VmNnm0o33F8OVr568vAt1C/bAYAc2f107Hfw/5js7tY711tZNnIfU5ru6SMMZt4/PS1RZ9krV2v+2S48W/+2u6nJ3HTCjRuq6rD3c5/O57vrryEbOFYoZSO827GUW2jk4yTqsrTOp3kMchVnjNAG+YsH2BE6JoVFEVhkAm4nBfbqNvjPbzBh84ZRV0SRuPi3b/72MPdTnN9wFMrBVBer63/iDg5Ejrs0vMso3AcPHzvo1aPl+pjGvJPSHy74xxkP2EICK2nkPbhuHi57s+D24+54KUXM4eACBXGbPxaXc/rjGTEzfPxEUqK2xWX9+kndsD5umEPTZDlCxZy+UD+0RolI/mZQlMMlPPJyubkMsizPUT2wRk8fMTcHP8qo70e6hNavZ76E/isEQNFh1dh2uFYa4mjkkv7EIk54o0zHfTWjpX2cTN820TGc7WdZmonFQVZPrwfEqZkoQirK/cXN7JArVNQn00TC/37CSUoVzaJqE9HbtINWqPel7nr5uKtSCH8/0uqSV4iSko5Mg9n3U1BeZ+7RoBmudaCo20prv+rEVHErcBA+4W3DUGoowZsM48dX5K/AvMhW+sDTDBp40LVbngmd9aEl0EqZkVaiGct40GajhMN27oljYMgB2MxUaXLOKJhDOIhMlHbTTwdE6LRNUvDRcNTLvwlLYpUxvxhMZPUmLvSy6yVMI03+q8HmBuRmEB3tBAG+qp10Q/MLrEK7OzpFIz0xlp7bNHoZmaUXiZ7xQjdhgxUhWjpFmcFzohU844MbcjcjkLdSeEexGECGoyCWFH47ZYT2dIkTHTCRupZZdTQDNpCPRVazAioRAjEqpgVHByvYjKTIq2KkTcEqKh3boQ7s7PVbJ3xdVtPqEYbWKtYGeWUWpJIi2bo4KDKmOUFMGgYUVDkY7LIqwNNOCF6B71v1okkdwQntx+gUzA1Iyc7x5mVDJbpFzLBPI17HgTI12o+1CXKPfClY3ESlsVok/4cPNSOemWEhVYs+BjSkZ+AsZ6jwOxRmHcy7KqQ8NaBKWWKKE4lc1bxs5GAinRpHrufAal6xR1+NeJnJKIiplwBj0lIx9G0RyobcD17X2gNkOY20bS5+5lhQvR25Y2vpXQXsj2SbFiHLUg6TLqAIf8y/TloX1dn4FgFflM22DRloK101xW7hix754+I5SXeflj3nDTJwNqGwBi40HbQBNf15YFxfDSMytEuD6uo3a9tw0WPt++Zn1abWNSV13FhqhY8tb3O610u4yFsTGjbSgL5eKwdG6ZoSa+3huoYglb7NspbvO2BLDLWNbnU6ld/tjIGF/XJyFqH++ThPU9Q21pROyvKr7u/Llz7Oz0+yq8WyCwbkPGlKRKBok40MiWiOZw6CA59++etj+SsBHX3lz0m4K2MRbVF6wuFxOrnbcMx5GnHRexcePQb8Jtx1kruKzuYyL22Zi9ibCGUbG7YCQCKBJnsEtMyZrZoZAjTC1n9zIiUS/gK5E2xqKuSbi/vx9bELyRPsy9dRr++MTsIq12G2lIElEFmbtBMmIa5lKZKFzUXhlJxiJ5krvP/5+9N4+zoyj3/z/V3WebPRtJJvsMYQ2yBEVAREBALuvlKrIKVy+CuPEVXBDU4A+CIiLfr4CiXgQRxO3KveAGiguoF9kFZEkmIQnZEzL7nKW76/dHddWprqk+50ySyUzOPO/Xa15zTp/u6qrq6qern3qW8twDEH0v3bc8+EjxgoqbqV+TkDlR9lkHHkpllzNUnvsnPS/FYkJ5WzoQi60lpNTin5wHg4tsrwCQ4iLjme+kkWe5mAJOtln2TeCk1DWx9j84vFCEAuBcD4URRlmCh2cf1tPdA4gtpOuKxyLPxEJziCzPUd+z8jUX5xGugxwMrqEoEm0uxJRPegwscisj6p26URARBEEQBEEQBEEQBLHzYc44ymI2TupRj9SNgsjhoQpY54Y+Quai6EXR97Xo/JwzZfUgia3uMAZwDicsKWsi382AGdY6ejYwsU9kfhr6kMGvw8jMUwazNs/JmagL4yEY88pmk5yhxMsmyy4LlEY/HUbuSkEQ09JLlzi1yhVbrZKa/rK1BuciY1XGSWPDK89ixj4Hx+q3rGsV0ixU1kziOAcBd5GOXH9KPIU0inDhY0Z2a3klASH8yBS0yR1QJp/NKQ/5IIOMU0TKKWEoyKIUCu1+MfAAiFUiaaEizYQ5HMAR1jZ+ZMaLKAOY3C/n5tXqQE+pCa2pftFfKESmzC5yxV6UvBw4c9BcehNFLyfMXsMS+lKTAQB5HjctT7OSOo8yZeYh0v4Q8rkpQG6KylzWz1rR0y2sXHKpAJ4TIusV0RC55aVZQQUWDLRbT2WM0ExYpRWRHGO5Yh8CxxMZKaJxlcEQSiyDFBNZuAadZmwttgEAPBZietZBKtUUrfqkIms6FyWkVeBooBwEMYSDoSCLYuAh4AzZaDVMBiQsB/sOkHaivgiFZVPIXAyxRgyWMugrZJH3XWS9BjgORxA6yJcccO5hi9OKWdm8ciEsBz301apeycvAC4tIO2VTawchmrwB9PuNSDE/ZsUkx3TZpNsXwRd9cXwKRRW40GHCckgENSxbFtpMh+sJ3VqgknuTub2SK00tVkXmvjaXGX1f030sqS1JdajUPnmsXgdb/XXLoaRVQt0iR3dJkmWbgaPNsnSXJtPdK+mcNkso04XMDPBsts3cDks/65YmKlC1xWrH5tpmns/mqqb3rc29Sm+D2UbTpdCss+4yVcmSxhb82yxPnltZDaHcv7IOpkuceQ1NqyC9/bI/AcRc8PS+0e8VvZ16f8n62Czz9Pupmsunrd2AuIb9E8CCKO82IuNmhTu1nA7KD5FrEOO87NIC8Wwxs2lJ1zM579Gti+T3OJolCC9bHUlrCvWTFtLAQaisXlVYA8StJMxjzN/UPhXkdhL6OExKcpJkPaTjMh8O95DnOTiZSeXsWlEW0oIrPAJ8RyTMkO7n0vI46w+oOZLvpoWbfDR3CjU3K30+rOb/zI9CCbhIsaJ6X3BDH+kgj0GvWZ3HYyX0+MLavtntR55n0Y9mlcCEc4Y2pxuNhW4UvayqpyRkjto35A68KPh1M+9GttQvgkuDRUk0ZLDoyALGKc+VhLtuPESFuiasLFerWdnGAoZ7DXB4gKwzBAaOhmKPmCe6GTBHXOesL8IwpH3hOtYIB76bVmWFzFV9BSCWTEfvez0zncMDeIGYR7qOH7tWAfOUt4DMiMu4sOLX39dUO3i5TDWvA0N/0IiU46v7wHV8hExkNBauiEEUxCIVhZfgcCMPCM4ZuCPeqXS3P3mf6dbzDsqhDgiiXqgbBRGDSJsei/8DIajky2H5WR8Kdx3DTUm6lAGGIAs19yTHjc4h0me7UXpzLyioLFZ6eVJwSqWRFJxyXw4GMAeuStntROaOIQLuIB9mkHPzKPIMXIiXcZf75faqjGSBUjBwTakDAI6WblPG2GGMI4USvKCIlD/cXziEIxQDWjkufDQ4PvbsXIBXut4QWSgg+lFkjooURDxEiglzVDcoIVMaQOh4WON0oNEV5qrdxWZ4jujj5tQgAjhIMV8pl6QQbmT9QKSgMCdaMjNWuZ0hSkEKLuPIh1GsIregHpa9uWmqH4acJvjcg+OGSHlFFEMxRvpKYkLisRBpt4hslK7Tha8ejpw5GHBb4Xo+ilycJx9mAA40Z4pgDMh6RbiMw3N8ZCJlSn/YhBTzkWIl4VcNaape/u+FRaU0LLmZ8iQwGtfyenuRojCFArjbiiJPY9DPwQ8d9BfSyKV8rOMz0ZwaRIqVRFYNzexaug7KfpVuZQwcKSdA1gliipgSL/tYe8wHuAcHQXRNBENBFkOlNPoLHkoBg+dwNHpF5LwS3GiS4zKOQqSEk8pPB8JfP+QOhtLNyuWvt9SIkDuYkulGQ9CLQbcFDd6QyHQWiutSYA0oRZlN+oImpJwS2tg2uNwXkzInFaVz5SoLhcMDlJxMTIkLDAy7B+oJPSaKqejRX0xtn82YKrpbk+5SU+2lwnSHSnIh0/e3ufKYv+lt1M9jvkzrGbFscWPM77pSy4xDpLfddFmrpvAxX8KTFDk29Gtiy/AlFRKmG5mJzc1JKmfMvtPbYktlb14LqTDT66G72JnXX1d8mconU8FkG0N6G+T+uruarQwzXpTeZvlfz/Km72m7rpXGfpJCynY+E7Nv9dThZowgOSaT4hHpx+rH6P01rA8h7p3nn3susX31QsiEK7vuniRj4HDmxF6A9Vh/Yv/yPIRH8y1HueDEXYH0F2Y9S5P6r8X4i6X9VseLbXIBSWawtaFnhBJll8uw7Vduw/B7I4kkNyJ9wdIxzhdyV7lLyTmGyF4mspDJRTO5kJTnzWhy+tBY7MZAug1thU2qrMF0S9QmrubHblhS8/uSk1HvA8MWDzSXvoB5SIUFcCbmWplwCHlHLP45PMQUR6S055whhULsncFHChl/EIwHaCh0o+TlUPRyCKKFX1k/0ReBUrg4oXDZkoohfTFb1lHOhRv8PgBA0c0qVy89Rk6sf+EMGzexaxMtvLLoXShkLhqL3QAgMt+WxPwqSGUxmGlTx+mKr7IsLmf5kwviZeWoA4cFMbe2WAgEdV3KmZ4BiHeckCNk8XGjx+gUx5cz92Z88W7RVNoKP5o7TwKwIT0PbxZE/EU/7YoF6khBJ+skshFb3NuiLpRui1JBJ/aJFiTDsvKIIOqJulEQEQRBEARBEARBEASx86EsZhODuupZqQ0OmaPMbqUJpP4XIHL9MsxvZVA8aamhByQz91PuOpHLEuMhXL8ArzSEdL4XKX8ITpQxStaN8VBZ/zgyw1q0HdAj5odRgEQeabQdFZANKFt9AEKTLs1yRaBlLQh29BfvIxE8j3GONAooujl0N8wY1sa9O+eIQM1RFjOJiwAru5Yjg7xa+Qm4FwV19lTAN7ny4/AQfdmpWO/NFSaffiP6fbEq44cOsm4RIeKrTC4LlNVLlINA9aEMLuewMLI+EatpDguFxYsTwI2yVHjSVY1FqwPRirPspwAuimEafmSBwsGQdnykHR+N3iBSzIeHEtI8H1mkiHERMA8FnsG20iTkwwwCbcUh4/lIuz5STgDP8ZF1CmqVMOBu2bIpGEIqyKtsD+WVQBE0WVqqydUd3WRaXns39OEFRTgI4DEfTd4AJmf60JD20T2UBgdDIUyjyNPwIbJEcK0v9T7liLJvOD5SbinKxDE8Q5gay9LEN7LSGUSTyFrme8imQuTSIaY19KPBK6LBy6MxVUDOKyHjlpAPMyhxTwWhDiBW/bLBQOTyJ6zPNg80YutgDlsLbWjb2oWGoFe0iWfFKiH30RD0ioCQLETAGfJBGiWWgReIAIgyK6FcxQqYB84cESAxkgVhfYnBmpGWOdJSQFphSAsb3TKoo7MzZo0jkQF7bS4/ujVOkrWFabGT5B4mrUsqucnZXMQktsxhldzITOsjEz1YsWkBpFzNIksa/VymJYdy07LU2ayrvCZJrkJ6nZMsgWQfynrprnFJ/aD/yb4w22Srp+lyZatH0hgxz2+2VaJbP+kWLxLZD+Y17OzoUH2Q1Jf6Z9sYNo/t6Owctl3eN2bGO/1zJauxzo4OuyWXVrZeJ3kd9T/92Er3mHkd5Z/NsqkeUWNSe77pyGe0bj2kH6f+osC3YZSrVZ/DANICKFRzMZnR1Ym+czCE3FHJPfQ/QFhlhJr7eRKVZIpp1cT58PmwrW/M8gFhXZFYB2MOKuvkoRRl5HJUu9V8j7sosYxIxBK1e1ZhOVqHNsIJfbQMbYKwmA/gu+koO21RWA1F7vRFNwffSSt3Ldm+EM7wayVmUPH5f2SxbVrmyO2psAAvLKK5sBXNha1o8rtlgxE4KeRTTQiZW573hyVkwwFkwwGkeBFeIP6kFZKwchLWUwG8ssUXY6r//CiAunyHKCEdWQpFWXerWPDGrrVm4SOv61CqGUOpZvRnp8AtDsItDkZzqPLcOYzmp4HjCTewaH4q34eE10S5bN1qXY5X/d3K1uf6d/39K/ZZt1qKPhe8BhTdrOh3zuGEPnK9GzDVX4+Vm3NYuTkHxjiKPKUF+hZl+vDgIogs9sLYuWUmZSmvdQsjvS4EUW/UjQWRzFIlkW4qCIXpqHxJj73cwinf3Jrwkkg3Hj39eIAUSl4GnDkoejlk/EEEbhqcuXDCUhSDKIBbyiMVnU93FWLRC2sYudxAWLkK157In53BBRyRTpKHDAWeRol5cKOYQK7jK+WSwwM40sRRThqimEfy5V9XsOimvjLFfBpFrF72MuYu3DfWh1Lx4bIAacRNft0oA5hennxI+k4KA6wJRaTBXYYppQ3wUyk4Tr8yOQ24JxR10gRZiycklTcuC8rpYzmHy3ykeBh/8ERxaxwmfIkzbgFDYQ4hGALuYCBoUjGTZKYuFz7SPI+AuRjiWQwEDephkHHFvmlWVGNAugduYlE61kDEQUq5JbhRPTLR/vCE65vLgliq0xSKcFzxuS9oQgN6kfEHxSTGE+bJDg8RsHgGCHmNJbpfvdye4kWkUFQuh7mGQczMpbCt1AKHhciyPGRaXh3dvFb2vzS9lddCjYXogeogFNnMJNqcpMhTmJITZr4hgFavN7q2AXJOCiWeQol78EMR/4hzoTRLMR9ZNohUUIAXFDAUmYwPFER9W3MOuqd0orl/A8JmF0U3Cx6K+F2cicl0v9+IvJ9Ga2YAuaAPjYObUci0IJ9uhst9eH7Zdc8LCmA8xObcXITcQSP6MISJE4NIosdWAeKuVOZL7Iqurlg2LtOVxea2JsuU2003m6QXVd2NSJ5LL8vaBosLjSw3yR1KfyGW3013MV3ZYWYIS3Jl0+tqZuYCyhnBdHcx87ik/q2E3jazf023Llkvs636cTbFmC1tvJma3aac06mkONSvg+kOpe+TVB+l0DCurxy/8hg1LhEfm3qd9GtgG6vmeDYVKbqCLMm9y+xL/bt5f5rocZCSxr5erq095r1hjjtZ94mQxUwpETR3JJnVTDyL7WnCAQx7aQSibE68/Lz2Ihd6rruqQcxd3NBHKkoBzli2vNiJ4YuUcoFRLkyqbLsyU5M2F2YQMZNkaneuzYNVu7V5gX7r2tzQzHuccTGnXL3sZfhO2ppF0SbbhTt7vPwAHnr8FhV7cDLfhMZobluK4gOFzMVQqgkAlEuR3C4VD7LfGCu76JUXG91y3Y1MZwFE3Bt5PVzuI+OLUADyuku3rkG3Rcxr8t2ijDCKfcMY8ulmFFnZFYuxECleRGvfWrhBEaVMk2pTf6ot1geca+5ZmsIuhIMCyyKfbkST342hVBM8lBBy4Qon62Zb+I6XryuH5LUQykxfixuEKQvh8AC5Yi+KblYpeMoL7+UFeL2u5TEYquxt4rlTVqqq0aBitMbrPCxOFgd4pGyDphSVbpX6PQDmwHfFIqwTluD1bIbTOgvzp4o+6imIxWmeZsi5+aj9DhrYAFKB+F5yWzAQilATOScPQMTt5KF4e5SLvNOxTpzH4gZKEPVA3SiICIIgCIIgCIIgCILY+TAH4yZ7GBlwjR6M8xrtEscpvb29aG1txT+f/huam5ripr+RhrzgNJQjz2uabQDK3UhooaXLi6ui1rvcR67QI/aNAucFXkZo6yNzSwDCpBUpFHgGk8LNyBV7EThplLwMim4O2ZLIquUFBXDmopBqGLYapUyImYMAbuS25aIQppU1T4M7BJcFIu4+LygrJ7mapAcyBqTbXDnqPrNou2Vgv9a+tXB4gJZDjle/rVr+quonoJxxK+UPIV3oQ6r/TQxOnoN0sV9p9wvZNpS8HPyoP3MlEVyv4DUok1+HiyxsjIfwwmIs+F0AVwWEC3hZhymtxGKZ1bQA3DKDgbRykobLsr0pVhQZ4iAyYsgsXoxx+NF5pJVRM++OtZczhiG3CSFcFHkaIXeQcoRZuMdKalWqgCxKYQo+d+GxoBzkmvmqLQwcaZ5X11wFp45WoWSQRADCqsbPizHhppH3xAqICMToR4HAo4DgpTy6m2djAM0I4SDHBpHi4jc9o55t1UYiLbJkPUXflrOrKTNb7X4CgCEuVlx6Sk2qrCZvCFknjzTPC/NjePDhoRCmUQpl0OoAaaeEnDOosovJQI39rBUFnsbGAWFRNKNR3IeNzqAy/S6EWTy1th0AMLnZxwEtXZj+z9+hNGM+etrmARD3Zp7nVODPLB9UK3wOAni8hL6+frzlkMXo6elBS0vLsH7ZXZHy8dnnnkNzswjUaDNF160mTHcsc9XY9r2aq4zpdgPEAxablhMS3ULEFnDYdp4kt6ta3ImSXIAquZxVslqyWWToVMumpZ/PtL6qZm2jk1S2bhlls8bR6ylJ2s/WT6bbV1Jbk/rXtEzS22qOB7PdNqsu2z5J49osx0Svpx4w3DYGbeXJ/fSA3rXce7bxagvibjt/peurn9vscylH6k0+AmUZ+cyzzysZCUBZoOiJIvQMSYBm7ajNR+ScQT7zZEgDPfi1cnHhDFk2hKbCNgCAGxYxkJkEABh0mpXFu+neneIFVU+RCKUcRFufJwHJ118db7F+km3U54qmxY/Yp2wxkuLCAmr+nnvF9ulasUIl8xAWLAxDgXj+9peyaEkLS6B8IOZVGVfMvZu8AZU5tsRF8HA5byqxjCpfzgVk9mL9msh5vOwjvV9UG7Rg4sraCyWVEU1av5QccU6X+8pdyuXau0SUzKbkZjDgtJRDJsCHi0BZPKkEOk4KedYQ6+9yX/PYsbrVuJzz6y5sgMjCF8JVVmkxS03Nckg/XwCRnCTgLvJBBiGAaemtyEXvK76TUhnkzHmgrQ9VX0SeAHpGZ73tgGZFqdVNhcDQxrzeJ8zi6QFAcxlzkAlFP6eiDGlNfesQRlmmt7YuGDb3dRFg+rpn4Te2wSnl8bfsCQCA1kxehLJwAmRYES4T74oyYUuaFZEJBxEyFz39gzjo4IPrUj7qSFm57JNnoTmTHuvqAAD6CkUs/L8/qfu+HwvqRkG07O9/RGNzK0LHVS+YUuFTgJY1KRK4AKD7cEtXHmmmKVOXAiIdvCTFSpjWvxL5TKtwM4sUG/LFW04IUqyIVFBQJqkeSkgHQ8gU+9X+xVSD8uEVgl8+zISbUYml0R82KeUQA0faKSk3oIawD2l/KJb6XI+bpMxtmVPOjBEpUhweRA86IXSLkUKnZWgz8ulmDDpiojR39Z+xbt7haB3cGOv3kpdDptSPQqopUhb1Kre5jS0LUQgzUVygErJcCOy0li0t5YuUmv3ZKeJaRddM1k3WvcSilJ/GZMc20TVd6oD4BEb/DJRTpepxeDgYUqyIdJBH2h9S9QgcD73uZHFclD1NjKdAPZA4czCA5ui8bJgSRV433R3SgUjn6oa+qkdJmsjyAE2DW6KGhAi9NIqpRhTdrEhBGrU7EwyKvuUcPdk9MBg2wmUBMiyvFESinzQfcDDtYa8/tIc/gKXrGgeDz1JR7AA5kfLBECLPhQm4nPgBENkinFJkOi/vD+FWKBVyjImMagwiJpbuzllwxOSpwDP42+szkIm8Mt82+43o3CX0h0Ih1VtsEO5iqQL27n8CoZPC1tb56A3EA8ONMlRkWEH1fwAPHish6w+gr78f+y4+ou4eMvqL3eYtW2K/6S/tSUoU8+VWf0HX70XdzahSZrNKigFdAaC78VRTCpl1sW3X22NLgW6ro03pZdarWtwHm5zSFTLV9rXVJUkBZfa9eR3061lJMZWk4LApU2x1NcuqlMErSclTqd1JdbC5vgFIHK/AcIVV0jW33Qu11LESpjLJppCrRQFmO7aS0tLWD7Y+0svs6+ur2xcgKSOffvZFNDU3lxdGtJdVQCqI7EpEoPwinuLl0AQcTLgqFftjc6RtLXPhIyWywCJEU9ANAPCirLiAWFCTWbR0RY3DArXYp6e41+czEt0VX6+3/gKepDjRF+ds6C/wsTiMTh7pII+im8XL3XMBALOaRftkbCVZx/5SFk2pKCNpkELa9dHoDqIB/UiF4gXfd9IYYo1qhuaycvZYL1rsTfO8mv+KlPIeXOZXlOHA8HtYz7qmz0UAzY1NU9bIOZRUXshtedag2uggRIoXVFm+k1Z9LmNUybbp2WalcktmPJN9HjrxdPIi/o8Dn5fDP+jhAeS7jFBSBrHfZJtDuErx0YReuGEJgSPmeYHjqT6TZcmMX0kwzmMKIllOwL2orfHjdQWrfEcR9Sv3d9wtcrhrbqjek0JVTiosIBUUkBvcisyyZ4BsA4I9ZmPr1L1RdMRcNRf0o2HoTbi+GIf/yL1D9C1nmJ59U11DkbW3rCCWykoA6B4YwsEHHVSX8lGHFEQTC3IxIwiCIAiCIAiCIAgiEeawceRiNj7qUY/UjYLICYOyBUkUBR9AzJpEEjJHmQGbSM25XI3xuYehIItS6KIQpNCcHkJDbgocHqpgeSLjmMhQ5iIyc+WsnJVArq64QJDxlHWGFxbjqz2R9UYqLKHgiRWINCshz+NucwF3VQaxkLlwQx++V7YiAuLadtVu7orVCSZ+9/xidF6uMkEUUw1o27YSmabpKNx6Azb/n+uQDsqa8r7cNPE/bIHvuMg4RWRSeaQzbQCEeW1vSVjReI6PDCsgZC68sBiz7hIZuPJIBQUMpZqGmQPLNsTcyXg5wHg8aGgYOy4WdFH1R/mzw8rmu+V+EWMnxwcALlbyyoEPI1fFMK3KzKCItFMo15OHCKM2i0wc5VUyBh4FqIwHUgfMVWARCFNlaOA+SqkcUqUhODxAyU2LTB1OCiF34cODBx89zhR4GR+9fjO6BxowOduPRrdfjXHdTU6aQQdOeRyG2mqM/KSy0LEATpRBLZD5Vng5a4kYh2KVpxR6kXmzuB4yOLi8l0SfBwiZgzQrqiwtso9CONAXhqT57hDP4YDZPVjfK+43DyW1+tTgDGEwzKElPYhBX9ynm9qEifubRWHx5ToBMlFdOMQ481lKWBNGmeB067Z6ZMXKlVYXM92KxbQy0K08JKZlgmmNowcvNd2BZDBpE91qQXe1UfVLsHywWT3Ic5mZ2fR621ykzHbr5enYggrrblp6+bZA07JsGSQ6iUqWCmad9X42g47bymWcW93VZLm2PtO3Mc5jlic2FzW1Ii/dPSz9prfFbId+fKWybK5psm1m0HXb+GBGOTYXsSS3LvPaJLmYmej3SBJJFnh6+3WrPb2OZkBu8/ck1zvOmLqfkyyJ6pmyDbFmdRM13XTL1p/t5m/qmcaFvUW2KFzsUz2bAABBQ6uYg3IfRS4s1gfdFjQEvfDdNJwwUM9n3dpCXQcu66MFu2bC6kJ/1g4LMp00lrjdHc3WP+o4xNuq16M3aAFDM37420b8xwkbAEDNGQJwNLqDyqp8qluet5W8NDxWQnP+zWjMOsqlXs4Vsk5kbR1ZlodwkEYhylwVqjZ4KGnXofr4lcG8Gcr3sN5eWUdpFSb6Lp4RFhDzX2klI3FYoMaRy30ghLJe0ftRJAspu4aFzBUu9075NU1ZfWlBs2XmN+kSKOa/mpWQ5jonfyvPWWVGthLSJWGplMn3YPOkhVEbDZnLy2XGgqGbslBa3TEHkJZusftDHG+GijDRrfYsrzTl/ThTXgKyLM4Yim4W2VI/itkW8L3fhuyG5Qi9tAhvEb1bFNwGuBkfKTcFFgaYnO4Rfcu9aBw56l2BM64s63QXv0qBwQlid2XUwzv98pe/xGGHHYZcLoepU6fizDPPjP2+evVqnHrqqWhsbMTUqVPxiU98AsViMaG0ygSOJ2IBRW4wMk27RPh+e/B5CkWWVak0ZcpGKWCLyGAwzKHHb8FA0ADXCZD1imhJDyIIXeTdRgx6zRgKGzAYNqLAs+qF2guLSAV55ScsBWeBZ9AXtmCtPwvr/Rl4k09B3msUL6xRWu/A8RA6LkpuBl5YUiaTaackXMscH0GU5aDEUyg5GRS9HAqeyMIVc5njcRNZxqT7lYhtVGRZ+G4avptG4HjwgiJSfgHZYh+GfvFj4J7/BzeTxkv9e+LF/oV4MzcLb+ZmiThLyMJhIhVkPsygJ2hFV34+uvLzsXpgpppoZVgR2XAAjYVuZEqDaO5bp1KPdmf2QD7dItJ/+gNRGkmRhaLERMrPgHkx5RAANYWTbdTbrFznIBR1DDKDhegDDyWhXOBRFhDOlE88AJViVigJPdW3Q24ThtwmFIM0ikEapSAyveUenMgvO9B8tUVcIh9pVkQj60eODSLN87GUr4zxyIxZxL7y3XTsWop6+OXseW4ablBE4KTgRSlTc3wALnxknDy2FCehGHqY3bgZzW6/6g83LIlrG+SRLfYh7Q8KpUiUTp5FmcBEfKCUuh9k9pSAeyiwHPp5M4Z4AwbDHIpRjCWfuypNvFCCBfAcX41X1d/RNZDf0yjAg3CVlH7dMtVsAA8+S8UmZC2sG62pfuw1eRMOmLI6NpnwUEKz24dmt09NSjYWpmGIN6A11YvWVC9a3D40oB8N6EcuFKbr2WBAmBYXe0VssTF6B9qV8lGm9ZYvjHpKbKCseJGptU2Fhk3BI1/GZSYlua/tBVn+LtNz6+fWFSxm5jP5Wd8vKWW3VH7oL8srurrUy7DeLl0JZr4825QA+ndd+ZCkNEpSDpkKNf1P324rW2+DLEvvC/03E1P5ZVO4yHEh+1Bvr65I0PeRvyW5f5llAeWxCNgz3un/zTYkbZPXWj+/2demorIWJaDeX6bCqqOzEx2dnTElapJLi9kHNmWsTZljXh+J3l+2/c37UD+f7Afzntb7T7ar0pgabXalfHTkvMFIzS5fUsVLuHSx4So+DQDlphPAE+7pQR4ZfxCZYr/IcAWGoanzkZ8yF0G6ASWeRn/YHD33xGLPkNuEgtuAkiviVso5aQhXc5/hKs05EL/eDkL1jPVQEgoH6SZnuifqi0Kacki2S8XmVK5PQTSfEn+OXra2KDQUZLFsy2Tc80gDhgaKmNnzCmb2vIJW/iZa+ZtoY9uQ5YMqlo4XFpH1B9BY7Ma0wVVoG9wgFhKdFEpuBiUm/gK4GAxy2FqcgnSQR2tpC7J8EBxMzfWlwsblfjl8AiwuZlq71LUzYtqEzEHAPBEiwikviKkwDiquZ6Dmoer8zBeu61wowrwoNb2MiWMu3jJwePCHxQ0CUK6DllLed9IoOA0oOA0oIQ0fKYRwVHxVF37MNU6ew4kUUGK+54p5Fhz4ThoDXiuc0EfJy+HNtgVqThhwT2Q5466mHC27wcm5tD5u9D5R90dUA1MJG6ujfA6Cl1PdR4pXcX85ibJI3rMM2ryei3u2PzMZ/ZnJGMq2YVPnkdjWtiCWQZmBo+hm4RUH4foFTM+/LuKCOX1Q7nSyBbz8mTMxbjhzYm57BFEvjKoF0c9//nNcfPHFWLp0KY499lhwzvHCCy+o34MgwMknn4xp06bh8ccfx9atW3HhhReCc45vfvObo1k1giCIMYXkI0EQhB2SjwRBEOMQxxF/44HxUo86hI1WkGrf9zF//nxce+21+NCHPmTd59e//jVOOeUUrFmzBu3tIhPR/fffj4suugibNm2qKeCUDJrV9b+/R2bSNJScTCzDAQBlGcQgTCp1tzM3WhmRLmL9aIkdB4jgwipAHnwViBqAyoTlMLF6kwv6VTYq30kpTfggF6ayPcUmtf+UdDfSPA+X+5rJaAolLrKWcYgMF65myllCWungVaaAyARZD1yoW9aUXd08dRwQuerwUJgzc6bOM6l3NVw/jx/3/gteeW0QhxwgAhDPnTyIyekeEdkfgbCKKjXE+iHjllAIxIrL9MxmZMIhNBS6AQDZ3g3onipMVwfdFtH2KACyDA4OlN0CHYSxz/oKaNYfQCpyfRPWO2IFyXSxKzmZiivq+vkAqACT8voXWE59lq6CDguRQlGs0PFABdLWg0TKzBq6qXLZNJnB4ab5dznDiRsFK28odMOJ3ABLmSYUvIboeCeyECsHRdzqTo+slgqqXQHE9XaZLyyV4CLFi8iW+hE4KRVgvcByMSsqWV+V4QIuilHWsRTzlfUTAHjMj7ct+u8iQIYPKZNsWWbM/TMKJimPYxABKFX/R4HVs/4Aim4OJZTNymVd5TkAoN9pBQCkWQFtgxvglqJMcY6LwdxkVa4Tlle6ZGbCvr4+LDjiPbss0N2ulo/PPvccWpoil1jbCpzFskHPrqS7TQH24Lm6dUWSO0tScOhKLl962eYxpntSpQDZIz2nrT9smdfM/W2BvLeHSu5K1bKj6fU2r4kN6VpkXmNpxWUL5pxUz0rjxVYH/dyVxlJS+yTmmEtyK9PrmJSdzex3m8WR7Juk7F+V6pnU1krns7UJGJ6dLWlcyt/062OWLa+FOYZ7+/t3aRDWXSUfgbKM/MczT6O5uWlYpibZ53oWUjl3Usk0UA7Y2lrcDCf0EUauQSU3Ax65aRdZNrK8Fs/eAA7SrBRLYKFnrZKW6YCYr1W6tnpGXomeiMJ0B5NtdAzLc4nPUrF9kxKF6McHcLGhsAcA4NCV9wAACi+/jPQhh2Jo2gL0NMwAABQh5uhpFNBUEIGAfSctMt2yFFoLm1Vm24LXgAHehL5SAxjjmO2sgcND5L1GYb0c1cucU3EwpMKCmufIfRweCIucKKuqmNfHLW6kBbW0CJeBwU30MWBuB8rzOXn9A+Ypa7TYvBPxcBMBXGsyHRmEW7qUqXZF40YPCq1nrJV1NxOVlJBWISsaA+FaVXRzql+dKMswAOWO3x9l2SuHewiHWSzpyCDasv9VW8CUh4ecL4vyuOojuZ/eTiDZJQ0YnpUvhKNcGr2wqK6DHghb9psXFFH0cuhDqzq3A5Fsx0Mp2j+a62rucf29vXUbxF9HysrlV5wzroJU7/n1H9V9348Fo2ZB9Mwzz2Dt2rVwHAcHH3wwNmzYgIMOOgg33XQT9t9/fwDA3/72NyxatEg93AHgxBNPRKFQwNNPP41jjjlmWLmFQgGFQjnFZ29vr/jAhADjYPDdFPQ4NA4CJexcBFHa0XI0egYos0Ypo+UD22V+ObV7lFUhYB4GnBalMOBg8EMPRaRRcLLwXB8ZPhQzRcyggBJPIeVEKTmdQGRyYllh9ilFfFh22QHExCMdijZyJoR2GKs7j6VWdXgA8HJ8InGcfPkPYg9THymAAYUwg0E/h5wnXqhf9w4HPGDzygCTJmUwrVk8IDzHR44JQdtQ7EFPehqmpUXsFh8plZlqW14oMl7329HR+IbKVCbTtwZOSsVqkg8GPZVsyJzo4c2GCWX5ecBrBfOaVR9JZQIAlRoVKJvAis/lh7n+0NEnBzJGkjyPh1L5+CizBeM8yh7hRRniHGV2LceVz1NqIqnOw31lMq6fX7oYinOINrihD3AOPyUUVPlUk6obi87CIXyo3bAEuFDucrIMPRX8QNCAnJsXJstROjB9wqub/so2BNxFPszE6iX6t6jVwzBlZmUzYWkSzXio7h3GxWQrYB5cHlZ0cpXXs+jmkAryYE6oJkgyNWrAPBU/KOPkwcCR8qOMJo477HqHzAV3GFjIETAHLIpdtqvZ1fKxY8ECtLS0DHuZ1V+czRciua/+MqmUEsZLrfmSa8alsSkzkhQ0+ja9bPMYW6wiPWZRkoKlktLFdMsxU65XQ/ZbpbaabdNf9G0KLl0JZr7YJ5VrO05HV2yoOkf9pcaIxZxfd4WyuYKp46PvSXGidGzZ3HQliqkkqvSSbBJz69OOk+2NKYWMYyopaST6vZOkNDOVbGZba2mTrmDV26SPH/P3pLrbYoaZ97eMZTVWrmWjJR+BZBkZaq5DQHysSxcX+fLNhr1wl5+7QbRY5Tsp5Z7kOyn4XLj0cM7QqNzAo1AAYTxblsrqqr0Qi/NGY1NTBJlKoVgbEE8Xbo6z+L1rLFolxYXRXpAdhHDDkopTmfcaMT2zBdN7XkO4eSMQBEhNakWpbYZwkw9LGHKaMBCIOWLKLaI3O1UtijJwpFBCdvBNNA71YWDKPKSCPNxUCbnMoHDT4kDRzULG2+FczHWkEkLOP2QKen1uKNuZDssZauWcTh6vL2LJ/pQKI9mn+rWyKcr0/YJooVguKgfci1zB7FnyHB4iHZbjfvpOOtbvomw9ciRUvCyh+IEqT9bLMd8J1EKer94pZBblwEkBzBPlaWdJ+UMIHQ+ZYBAlJxNTENmUZGYdpBJGjxnKLQGGVX9GLne6skgtwvLywnisz3nZfU3OYx2E8B1D2Rm5xLmhj9BxMei2IMULCDwR+6sR/UqJKc7rwEcqcrUsh4kw60wQ9cSo2WatiCZOS5YswTXXXIOHHnoIkyZNwtFHH4033xQrBhs2bMD06dNjx02aNAnpdBobNmywlnvDDTegtbVV/c2ZM2e0mkAQBDEqkHwkCIKwM1ryESAZSRAEsSMwxsbVHzE6jFhBtGTJkqoX66mnnkIYCi3u1VdfjX/7t3/D4sWL8f3vfx+MMfz0pz9V5dkuLuc88aJfddVV6OnpUX9r1qwR5YQhnDCAF5aQ4kUVdV6co6yhd3iATDiENM8jzSMXFG11IM2Kym3GiaLsS+uKkpNB3mvEoNMMn3sIuYMS91AKPaXPlys2BZZDiaVRYmk4PESKF5BmBaTdogrkyxiPAhSmUOIplfnKRYBUZHYssj65KkOZCGcotrtRYDuHhyownwrUHH1Xwfo4V9YdqaAgVn2iPsiwArKuWFFzEWBqrhdt2QEc85Z+HHPgICbnBjA5N4CMW8IQb4CPFPKpJqzom4FpPV2Y2rcKGeTRjB40o0ftP7txMwrIYhufjDf5FAw6zRh0mlGEcPsKmYOimxWrQUbAadmX6nPUBjcUFl1ylSCECz1IIgNHiafVXxEZFchPWfxo10quaJjnlquGjHNlWyOzPch9xapIPOBeCCdmnmyWL1ejZMA9HYeLMSytwUqpBvheFoV0k8hWwdzYSk3AvCjIeApTgo1oC7YgHQqXRbly7XARMLvRHVTjWgUdjGpY7ouwbE7NAuFKx3ykmBivWaeAtFNU7SrfOzJAYhALrF1EBgVkUWRZEXzTyagVLDlW5fV0Ipc5M5Crw0PVl1l/IApsWRKui0GvCHAe9ZcMtJ13G1FMNcL3sshnWpHPtGLQbcGg26JWdBkPlek3BwMSVsBGyniVjytWrhxmXSAtD2QgWhm8VkcG4ZXXRQ8arQex1a0lpJWC6Y5lBpg0r7VpzWBaqpir39LawbQ20fcxz2WeT99m9o+0NJGBoGUdbBYmel31MvX+0v/07XqwYGlFJPtVD+itW7volk5mu8w6mcHI9esvr638rl93iX5e3b3Jdj1Ni5Zq18JWb/1/pePNMWUGNNd/s1nS2Kx1TKs42/krlWOOjSTrIds41OtsjicZCFxi3hv6/WZa9VVqm35/68hxZytnRxhr+Qgky0gAsec2EPVZFICagcPnHnzuqeDJcl9PC0NQcjMoeA1qziaTbaRRQAPvRyP60FTYhqbCNjQUe5Ar9mnPQeEm5IVFuNyHx0sqyHT8uRgoKwj5WXdj0oMa665Gqp22fossqORf0jO5nNxDzGOki7+wmPLgsADdzbMx8Nb3YOgw8TfYMBW+k4YXltDsb0Or14O93vwL9tj8Ejbk98DWQhsC7qLA0+gNmrFl0p54c/q+KHgNKHgNyJX60JLfoqyCZNtTvIAULwhLkCiQsrT8ENbobsw1joOphCK6W3x5rDvK+sgLi0iFBaSibLtyzmJis8JSfR79ieQpkbW8zErHyoGOQy1brm5Nblq0yTmdiwAeLwci1+ep8k+ff8auMwz5Fu3Xn2rDUKq5nJ0rugdkYpmhdItIpOI2xMaZ+D2FEkujyLJRAiDx7uOzlAhVEI1N6fom22nO//TxJt9rUkEBmXAwZo0v2uGosahfB3W99UxuWgY1WQ/fSaPkZkQQcLgqNInDA5SQhgwpIt+5pIdAyN1hwbspixlRj4zYxexjH/sYzj777Ir7zJ8/H319IrXnfvvtp7ZnMhl0dHRg9erVAIAZM2bgiSeeiB27bds2lEqlYStDehmZTGbY9pInsnIBQCooIIWCEoAFt6GcJYl5ACu738jU6lIYeihpPr5mZgMhEFwEIr03KwshFQ+Ih9rkUEsnyVx4AJqcfsjI+DKuDudCaJp+uLJeuqLE4YEyc5TlSxPZcj0dZaLMo3SqHEy5z4XMRcYXmSQ4c+A5RbhuOTOGysAWufT0sTbxnXHs2zkLAPDP5eswt2kLXgsOFSnEI1nssgCtrvBlbvD7EDgesk4aeeRi7k+6exMg/PRlG+RDT9RfKjpEXVXKTw7IrAgyjlTcjJjHygdgFeLigeUO2y7byzhX/QEIU/Gik1WTI9PsWLmIRaa7nJeVD05YgstDuCjF3BnFJC+EFxThhCX4nvCZL3o5dV4Zl0ieg/EQiCYhfpTZDBCKlxAuUkGoJocyro+sr3LrM93DItNsWS8PPhwnjGXISOojScjivvUcTGU6AxP7e6yU+NIfRgonNVbhwkNJmVnLSYVMyZpPN6PoZdVDPuotDHrNcKIUuYDw8Qci337mwgl9uGEJLAwQuPFMJTvCeJWPHQsWYMvmzbGX1VgWJGN/2wujGYfGtq/9xaPsZmOmTpcZxmwxUWxlSMwYPLrSxVRoJNUvyYXJjDWkbzOVUGbZUkEi97W5T5l1N9utXxczvkzSfaO3Xd8ufzPrkaSwkNdId3czlWLV3Oiki5mt38366u3T26b3s9lHNmWFVKDZsCmxTIWmvp8Zr8hWjmyDbayZ9bPFV7K1w9Zfepm6Ukdvq3SXMzGVVLpLYVLb5DF6lr5q9+ZIGGv5KMuxyUiJjPsj5ysufKS4yLglX3D9KO5gwLxoDhZ3FQIA4aIn3dIchEy4MXlhCUOpZnU+6aZkjg8TPU5kOXxA3CVej79ic8FRv+njYIS6Pxal+hbPeZG5reSKF+qQOwi4i6KTQW8UUgAA2sItKm5QR2cnVnYtx8Y9FiEVFNARLBflBiLMQ7/XBsZD9LttWogB6T4Wxty/ym13kOJikVM/hmN43Bu5IBTI2DMsft20DtTKGe5eplNeyBruqicWBSOFLji8sKDdm8P3BRCbj8Rd2iLFE2dApPwqKz/KSilHyzQWsMzwtokDYiolmfVZHivndvLYkLlKISnn4WpOzWVdh8dpchBG7m9M3VvM4YlKFf28IXPVbNLhATIYUnURpx2+CKDmsWJPNR8NubjPQoh+c1iAkLtRuXmEzEEqKIhFWieujCq6ORSQVfNIDhdFrsfg6bO2pV5hjgM2ToJDj5d61CMjVhBNnToVU6dOrbrf4sWLkclk8Oqrr+Id73gHAKBUKuH111/HvHnzAACHH344rr/+eqxfvx4zZ84EADz88MPIZDJYvHjxSKtGEAQxppB8JAiCsEPykSAIgiDGP2y0spgBwOWXX46f/exnuPPOOzFv3jx87Wtfw4MPPohXXnkFkyZNQhAEOOiggzB9+nR87Wtfw5tvvomLLroIZ5xxRs1pSmVU9Ref+TtamhqVuwnjobIoKjkZBPBQ5GmEcCI3MqEhli5DpvtOaJh2AsKFJWlVRlq52FYYdLNKuSqlr0aZ2n2bWSgAZUIs99fNi72gqPYRZqvusPMCQJ41IOQO0qygsh6EzEUJaWUhIi2nGEIE8LAhPwWzshsBQAX5Zky4o/zvK8JaaFO/yJDUkPbR3rAVTbxHZWeTAZ19Xl4VkRZC+kpF0uqMdH4CNHdBbfWh0vF6IEfdPFjvez2Ytx7QULiycdXX+kqKabZtroboljVmAGr9esjf5TX3wpJanQmZW3afcjxlHm0eL48V7oTlLBayDN9Jyzx94GBqFUSiZ5KQlkgOD9DLJoGDwWO+NCYHELe6K5srCzPpUrSqIldeAXGt9XuDaaut+kqQXEmVq6ByNUoGYZfuZRLPzyN0UsinhKVQ0ckiz3MohGmknRJybBDZQFgaDblixdZDCakgL1Ycg4KqQ8/AIPZbfPguzYSwK+Xjs889h+bm5kRXEX3VupqFi8S0ptEthYDhlgeVLCiSrJJs7i1m1qtK1hmmpUqSu0ylNpq/286Z5CplttHWZ7YybRYftvPZAlfbzmlm27K1WXeHsu2f1C69vpXqCWDYdavWR0ltstXBJKksM/uXbezbzp9Unq2Oej0rtTGpXUnjImmsS8s0iZmRLaletjba2rSrs5gBu0Y+AmUZ+dyzz6KppSVmheOhpKx3M75I0ME4x1BaPE985bJctiBW7j1aMF5JLbJPkiR7GLiyltWt3HXLXeEAFiRaVZtuRknn1+c3HA6y4UB03vJcJIzc0WRGXL3e0npHnk/PygYAe3XOxeaXnkC60IfUwDYE2UYEqQYM5iaj4DXE5rpJ86dqAZJlm4e3r+wOVul4vQ+CKOuZWa6c66jA2Nrc21afpDpVO7/YXp6f698dFqjrJAnhqCxlej3NObM+x5YeDtI6qTxX5yoDXGysGWPMnOfpc0Q5Z9azsLHo7Gad9GQkygpItT3uYSHL0PvD1pfyvvEi1zG9nzKhsE5qGtws9nXTKsGO/i5TrouLFIooIY3B/m27XD6OBVJWrvjM+eMqi1nHjT+s+74fC0YtixkAfO1rX4PnebjgggswNDSEww47DI8++igmTRKmp67r4pe//CUuu+wyHHnkkcjlcjj33HNx0003bdf5pLsNEBf6DMKcMIP8MAVDwLxIMJVTxAPGwzEmoEXWBKAcZV+eI6lOuhJIKgv0zBVJSiXZDqkciP3OogdBpLiQSgUGHvM9N8srhuKmLvIUXBa9qEemplIplkIRIVyUeAYe8zEl04sAHjxWwoKOPVWZXStWoC2VxlCYxR5N/Ug5wvXOYz7yrLEs6CHc3KRSTl0Xw7XArKtsZ7QxfiwbPunlYImKImVajLjJsOwz+TByEQA8nlVN/O7Grh2H9PmOK+DUBNH2EqqdU580imMARNcslmpWTcLcKBNGWZmjlKFRe+VYNs/pch9gybd6LuhT55BKEwBo8kR2FxaGSAUFlNxMOYZPdM5UWEDIXBRYDuAiba3sJy8sqv6QmTT0iZOMWyDvtRJPxycYejtYOYMMAISOC3hZ6AyGjVHfhOUUsVFZDYFoy5DbhCFnshinblbVy2fD3edGm10tHwH7S6t8uZQv+KbLSpJSw/YbAKVgMJUGthfiai/5ep1lGbbYQ2abkrApAHS3oKQ621y2kpRXOjZXJdnXejm6IguIZ5GytclUuOjuQBK9jXoWL/M3va16FiuZxawWxZ4t1bv8zHjZVU53j5Ln1F275G+V2lOLYs48v62uck+9DJviUdbR5tZo7mNi/mbWXa+fOY4rtcXcR/Zx+cfka23WL6n8pDbtKsZCPjo8cv2XL7JwwKJndT4lFsH0Z7cb+rH5hO5GLyk/A4PI1UbbP2EM69vMFOXCjVtmdXLK4Q30l3E5N+HDFzRjcx+LPDdRMV6ihR457+BBAZw5KLlld710kFeLPYyX6+PyAIGTwl6dc2Nlv9L1BppSjSikGuE1TIn1rVzIAcTcZvgcePjcS+8nPa5gfG5fWTEky7SNfakskf2hMr5CZCYrh3ZIXhjRz1HLYoW++GgqP/T5p54WXu8rj/lKgSIX9/Tj5PnKrnihLFzMfbVsYPL66GPKDf3Y4qS+iB04KfF+Es1bOVhsLq8WYCM3NF1hJeeCIQA36mv5DmHO82XsLh6F15CLveXzGH1sXF+p4Mz4gwjctCjHTav2yverXElkH8yU+lGKQkCkHQ+lsIiJBHMYmCUD3VgwXupRj4yqgiiVSuGmm26q+MCeO3cuHnroodGsBkEQxLiD5CNBEIQdko8EQRAEMTaMqoJoVyLcmKKI+XDhMr+80hFpo6WWWm4DNMsTzSw4aWXBQSBC9UYBljOR2WZ5NTBasYG+Clc2qxTmmuUggzLYNAdD6Lgxrb/ugmNzRZMrDzLjQIiyJYq5siJNOgFopqZxbT0gzC6BssuRy0T9Fu05Q513WdcquPCjYMLi3GlWQlNqIKp3Ofg2gKjNlbFZR8ljZVfqwfjUfoabmTx2+IqcNAmFusaI3PWk5RiLLG10E2HRHsMaLTpWXGcoSyKmnctmZp7kkiZXpOTKU4ml1SqPyk4SXX8GDg+l2MqTfg1lUEaJG5bgyBUdzdxbBt2W1kAyAHSB5cCZAzcsqXHXWNgGz89jU1MHGDiaS28q10agvKqaCYcQMG+YO13JySBwPLQObhQrMk4KRTer9un22wAALW6fcP/iRdXPavVQjkfNfRRhZMLMuVpVakz1I+QiqLXDA7hBKW6pxUOkeBHMKWe6cxACDPBZ2XKqXjGtZ0yrBpt1g80dR98mMa18dCscM6iuuWpts9jQ99UxrS7MQLrm/spaJTpPkvWRPKe03Ek6v2x3p2EpZDtnkkuStM7RgzkrCxzjGJu1jq3N6rpqx+lWUTIYuGnRZFq4VLLKMa1q5TlM6ydbkG+975hWrs0KTO9D/fxmHWz1NcdokruYrW1Jv8vv0rLOZjFktsMWhNtmESQx7xFzjNvcDc1+SOqDSlZ8ZnBz3bUwyYKuXtHdyQHx3BHZRuX8IdlFyGq1bLoYyaDIXMyeOJgKcq0/70yrjnLW1CCWBEL+d5mv9pO/65Ym0m0+yRpxmIyFcT+hbP2usqlKS97IslmvnyxDn9fNXbiv+vxK1xuQLuiedr58lFTCNv+u5C6WZL0fm3tpltlm+brFduLcn4cImQOGQCVYMZNASzf+EE7MwsWJkq5YgzLbNsm5vebyFT+knBjH5UVlmS3doBgPRRY9zaJIojwNpAzT5tjKlUyzVJPzRt3tS/aH3p951ohsOCDePyILMmFtVkLgpJQFd58bWf8hQJrny2OaucqV00wYIq3BgQAsNO4F5iLrD0RZ4BwwGQqCD2+vLEvea3rICxfCErDgNaDo5qJ2DZ+HlNwMvLCIfLoZKV8kQnLCQL03EEQ9UTcKIpGCPANEL7syYj1jPJbFADCUQ1Joi7d9yIxW+m9SOSGzBEiTzZC7YAjhavFpEAkpeR75sGecKwWEFxRV5jHOGMLIDFO+qIvzOzEfXOU7jAQf30g5oD/sdPce5RLEyr7Gso5C8eAP2yZNrXXEQzCNNAoII9c8zykNM/lUk2IwmCartmuhYyo/5DbGQ2Vabf6ufwyZU570xDJQQPWVHo+IRW5GQFlRI5UoXLue8rv5WZrVMh4qH2eppHQgFRlRDrGw/PB1eICC0wDuxONHPPPaVgz6WbSm+zEp3IxUWAIPCsKtCoiNEwAxhY3sKzGZS6kUtEWeQb/fiGLgYXZ6LQoshzTPA4BK77l35xwk0bP8NdXmvlQrAGDPzgUAgJeWr0eGibIc5iIVFmL19MISBjNtyDtiAiizjDBwtHndsZgP2VI/hlLN4EykHXVYoDKEdKemqf1cBNFDncUyaTgsiCZoYWyiIa+r8KMPkeWDsWuZ5vWtIFJKCMQVQfJlXn/5lb/pigv9Lk16+U9ypbFltbJ9NpVESUocU/Gh/2bub1OK6eczXZ4qxTey9Yush9k35v42RUZSfWU55u/6dRRfmDq/LZ6OrvSSyjGGuBudqcTSFT5JWcFMZYbZ5qSxBMTdyMz+N5VHeptN171KmbVMhY7ttyQFnE2hJ9FltEmSAk5X7tiUn/Ke0duu/ybLlu1I6j9TeSePS7pPZTm6Ykh+Z8CwPhhLV7NdRQE5NMCFGy3QeLxXJZ84AAEAAElEQVSYmCZeKU4sbvxJihjxW7R/NE9zQz86hz2Tqo7vpCEX++QipcPC2PzWC4tafbWFQh6XzzrmPTFswY5LZVBUdyaev3p7ATHn4YyV3dQ1V3LJ8q6VaCt1xxaJim4ucvOO3NcTYnyq+ti0KtAWyxKUPLrySpSZ7GomlHZxJZe8x2S6czPmjZybyjidurtfaCgT5UKqnNfa6iDLkW6Ect4kFS+AyNjsu2kU3AbM7Swr4bqf+yMGGkT8nAG3VcQNhYgV5UK8h3Aej/tYQErUiQm3Mhd+NF8K1Hy4pW8t+prbAQBeUBRp71kO2XAAcxbuhyRWLX8VAJBBProWDuZ17q1+X73s5WHXSC02agpS3YVNvgsVvAZVRw4G7jhqf09b7JTbRJkBXPkMiK6NzHAdz1pcjqkpFbBSgST/Mx5iaKJl0mIOMF7aXMFVlNgxqGcJgiAIgiAIgiAIgiAmOGw0s5jtCmRU9ReeeQq51klIBYVhAZolZmYwaaUDYJj5p26potzCENdc65H39VUjx7A40S08pPWQbo4r6yvNITkYhhzhuuNzDw6LVpsQwGW+1cJGWf1EZUvNt7nKo5tVyuNd5qMQZpFlQ8PqP3/PvYb1o1p9jvrMRwopJl2D4pZEeh0qmQInrfro18w0X45bGIXWlT59dU1fkVDm3hAZsnwnBRngTq9r0jHSjBYom44DZZNWGfBaD9isBw/3wiJ8J410MIRZex0Qa/PLXWsBAFMK69GTEVYzjX4Per3JaAj70MfakGZFZQnWEPapLHZ9qckARKBxZQYOR1n7jCamO4W54v5a12o4CGquS9eKFco8nnEe5VHzIus2aaXnwIen7g1lCs7jWeuqjcnevgG85ZDFdZcJQcrHnp4ebN6yZZjFhI7NFaaSRQUQt2iwWWXI7bWc1ySpPN0CxqSSe5T8nuRqpdfV5spjyxJlsyqpZnlTybXKPK9e16TrY7OkMvvC7HOzLWYdTLcm/but//X9bO2v5DJnliN/M12lJKbLVFJ7arF6kfU1LZRGA73Pqo2bWupjWpklBVi3/Zf7yHOZFnGmu1tfX1/dZunRs5i1NjUot33AcFOqMI8JrfNN06ra7sqkz1lMeaCSZRgW5SEc9RxUCRmiuYmeuVV3BUs6p46eBUvPZCWOKW+X7kjS+gQAsuEA8k4jHBYgFYhkFbP3WjTsHADwemSRrNexkgVRuQ9H9rqirKK07LTSPcqcc+qW5/rcQZQzPESAgxA+UihFc+oUK6l5aSUrJzmHN0MQiPaVr105vART7vX6eABEWAAz8DcArH3tBRTcBgBArtSH7tQ0ZDGEVJBHS/96+KmcKid0PAyk21BgObjwkQ7zMSt1URenogXlzsCUObbzLetaBQBY2Dmv5vJc7qPERHv0jGxJoS3MoPCADAxvuPpp47S/txcHHXxwXcpHHSkrV151IZqz4ySLWb6IBTfcXfd9PxbUlYKoublJU4hUVjiYcXrEtsom6+Y+NmWIPIf5gCkf71gnCmbq7yITJrgBypMVka1CcyHT0kLq7TInK5wz5Rst2+siiL1k6w996Utte/DoE1CHByiyLDgY0th+Fx1TcWdObGzbdWSMGmmCmw6G1LFlpUyUJSuaXkmfaN9Jo6HYA680hFKqEQOZNsiU8bIMqQyS7kyyv2SsoJC5yHPxwJVxm/TsIhwitXwAd6cqal5cvgEAkGEF1XYvLKrxU8tDdHdhRVcXsv4Aim5WjYn+sBlpp4jBQPR9yvGRZkWkUFTmyPqES5oI22RDX18/Djjk0Lp7yJgpnKu9oAMY9hKZpMhIUljYyre58pjlJdXFjHFTTWllK6NSvW1ttLlt6e5flV7gk+LnmG2yxZyp1NZaFHg2hYCp0DEVA7bjzH4z+85sn65Asv2e5Mpltmm0XkJM5YvuWlUPmO2xuZfZxmJSrCZzXE2bOlUpmutJPgJlGfnsc8+hubl52BhOWtgChs9dktiejFmifPscM7YIWc3lCvEYlpVkpxv6iccNLzN+b5fjJVa+l1d2LY/tJ1/IS5Av8ZHCq4KiqBZ013V9MddEzvWkEiGAhxJPwWVl5ZvLfDQVton6RcqawUwbUkEBjIcoejkEzBvmXg8Mfx/Q40oWWE5tb/K7ETIHgZNSIQskKvMrUjt1Xrfx5afFPN7LYchtUueQrmALOvesdPhug1RI6gu4mXBIxMiEF8VPYiIkA8qL6Oa95SCwjssJpyC6+iK0jBMFUW++iAXX31X3fT8WkIsZQRAEQRAEQRAEQRDEBKduglSHUVaqSmbANrNSW2BlG0qbX2VRQ7p56S5Iwyxi2HDTV32liIPBibKNOQhiq3kB98pWQFHQ61RYiFlOFZzcMDNhhwcquJ6Ew4GHElhkCQMIl7IVXV1wEWBl1/JhKwh6UG89o5vPUiqonX4NTA38sAwUlhW4ShkrJIE2dF34sRUaaVoLCIsauUI0Y8s/xO9NU1Hycii5GXAw9GWmwM+k4DIf6SAv3PuYOLeHkjI9ZpwDDAAPweGgyLLwuYf9OtvV+eSKvBP102i6dunZ5QBhfhs4O9dKabxQbaW/a8UKDIaNKPI0ArgqkDzUcC1byEnrIgCam2d968r1ALY2OZfkimJaeSRZ45jBoGWZcr9qViOVrG5MFyu9vua5kgJXy30qWdzo59eDOJuWQ9XGYqV2yfPJoMRmf5hZ1/S62tze5HlsFkJye9eKFbG66AGJYbmGSRZW+jYdxvmw7G82iywdeZ5dZcFjnqdeLIck1dqX5FKpBzy3XWc5hlYmuHTWEw4Ph7kfyWACQJIFXfXg0vpcT1ItELPaluSips33kp5d0nJcx0EA8PL5zTrJpBx6tlYY7k/SCkO6PelZzObtKQIPb3jlWaxZ9s+KgYsl0v3edfxofisstJP6S3cXq7TN1ROvaONa7istl4osCx8eUhBu+ikUkWZiTl2ESOBRCnPo85qxZagFrRlhoZ7hReS8IXUeGTaAg6nMWjJRhnkdRcISjlRked++91sACIv98vNL9Otoyqrp+y5Wn6WVjcuCurEckthCZeis6OoSCYTCIlyUhoWYKHsROAAvJz0BIuv0ai+GBLEbUjcKIkkl/1/TXFbur35P+M0Wu0jtY8mQZiqGdGFivpw4CGNKJ6Vc0SYL6WAIDBwB88Cd8kPfhXjRlQ8lIHp487hJLeNl019HS8cYwsGCzj3x+vLXYgK00gNJKZg0lzjR1vJ3XdE1/PjK8YikC568VqbPtRLcrKwQCrmDPHIqhlJi/aPJSmNi63ac0fbTrkQ9uZSNFP0lOR3kRRa5KNOHbu7dUOxF0csicFJwwxK4M9yMvh5RCk4kKxqquYHpv+n7SwVBkkuLLa6M7Vi9nklxU8w2yXLl72ZZel1kWTZXsqR4LfL3zo6OmifquguZLd25ua9eX9PFTEcf47pCTlfO6HGOdBc5U3mX1JaxUtgQo4ue8t68H81MfkD5vkiK9VWPhPI5sIPPg5hSV0sjXolEWRsLgeBqn8tKJ861+Sji81HprgWUU3wziGyqMSVYFN+o3AfDXcZcLfOaOJdw25ZuVXosxRn7HFxzmx0exOfIYCPufV05VC1OkYobCvlMCNHA+5W7V/UFtswIazcyxko2VlOi1DO6a66KOwqu3kGCKNP0IIQbnotAxSTy4Nf9AqMJYw7YOGnzeKlHPUI9SxAEQRAEQRAEQRAEMcGpGwsiYbkjTWE53LAELywhcDxlQSAsU6qbBANxC5ewwjHcCKIs6lKlbB63tLGdV7dM8p20Wu1JcWGOK01lfWnCymUGM81EmqNclpaFQZrWSkukkawcMAj3KgchOGPYODgJe2ZXIlMcRNETAYSlKaZuzTXMmgAs0YoocLyYK5vLfXhBPmZdVHIyKCGNgLtwWIj99my3lkVMHCpZb/1j2SY0uv0YSjfjjeIszE2thhv6UXaK+mdBRwdaWlqs7lpAbcGEbe5nEpsb2rBgr8Z2s2zzvPo+5vYki6KkQMq27Fq6lU2lMkZiFShdx/T/SccnubYJV9bhbnB6XWVbzCDDeht1iyOy2CGA5LFsBk2X7ocTCUfLUApABauVgWk5ZxipaYvp9qTu9wqTxBEF4GccTLMScgw3NIcHMUsh6TYWOql4OdEcMeSOmhdKayRloeTEy0c0n567cN+a6yvkYhRuAQ5SvIgBtxW9fjNcHiDn5OEg1Oog58pakOcRZDmTVk4lZGLugrI/GOco8jT23LP+3PKJkVPpObm8ayVSKGFabxdCN4W1DXvBRYCAucOyYBNEPVA3CiL5ICmEWQyFWTS7/UizPFzuI+MPAhCKB5k+EtD8uBNcoar5jlcyC66UlULfz9YG4ZZWTvmpFDrMsfoGL+taFcUtcqL9yi5nDByu4xsveKI8j5WwvGvliGPWpHhBNgALcmtQYDl4ThGpoIChVLNKCenxEhzZJs6U77qOGROKQ6RNlX7d6WAIXlgS7kKcI3Q8BE4KjIfIYHBYiniCsPGWhXsA2AOvdq3BnNQaNA9sglfow9YpQjk6EXzIzYxVSbF/bEoZWywcia7M0V2c9N+TYhmZChK9TkkytFJcJMAe70a6e+lKFpvLnXmeSgoeG3ocn1h7GIvVy8yQZsNUxOllymupx5AxYxGNtO7ExMZ0izQVqvWOXGBsGdqEfLoZKVbAkNMksmtx6aI13MW9EtXcnYDKCqGk45NCI8iFN+FKJssQi2rSdcZcEBTyKXKXieJR6hlARR2F4iieLddVmcdqRcpD6Z5TZFlkwwEEnqtiPsrMYT5Sar+QOyLGZULspmHPJBVj0AGHCx8ewkjR5TARjzDkDi0sEjWzZ+cCrFn2T2SXPYOVi8/BlsEW7JHrVrEtJxQOE3/jgfFSjzqEXMwIgiAIgiAIgiAIgiAmOHVjQRTAVdZD/aUsJrnb4IVFODyEG5YQMletoOguY+VAdcODq9rMBs1sCdLVC9CC30m3CXCRyYB78FDCAG9Cjg3CiQI6x1djHLXCIeoVmQXzaFWIcfg8bhYsqRacWF+R55xZXcpqXW0WrmWibgFcZQrsu2l4QRHpII+im0WRZVBAFhmWRzYYiFkXOTyAy/1YYMLA8ZSlVDYcUNvTfh4MIQInhYLXoLJkEMRIWNHVhTzPocizyLJBDOYmo9Q0EwNoRmu4NW46X4esXLECBx50kLLu0e/1atY9lVa4dasVxrn4bMmIZFq/2KyVzIDVkkrBsk3rJJsM0y13bL/rlhJJJua6ZUUtyDpJVzNZhuwDm1UVYA8cbvaHmbFMlrOiqwud5EpGbCddK1agU7MA7NQsiUbi9rS74oYBUkEe6UIvnNBHd2M7ArgIuKsCNwNx65pas5HZqMXK3Pq7EYbAMb7r+5UzjYmMWrb5UzW5tnrZy5FFkszkxIbJ0TdeexFFN1d7IP9oruzyIhweoDHsRcnNoMTTan7cWtgMJyxhIDsZPXwSHJZCKsowFcBFyB2kmcg8Jg2qVLZgOHARKPdAlwfq+u3bOaumOhKEzqrlryLrD6H7LcchhSJmNWxGCkV4YRH9qC10CUHsTtSNgmiAN4GHGZRCF1MzPWgo9SJkIpORyBYWCF/q6CEhFUMyywQHU6aCatJdwdcZiFKt67vwUGR/iOIBhcxFPsxh/z1n1tyO17pWw0GAAG7cBY0L5dT2uITV8tCu1RWBMxZlSeNwxfRJZW4LHA9u6KPEMmgtbUHBa0Bv2IbW0ia8mW1HIcwgxUoo8DQccMzveRahk0Ip3Yjs4FY4pTxKuTYMNE5D0RUZJfxMGiFzyFWC2C6Wd62MPjnIOHlk+RDcoIQwMrnPOkMouA3wnfpWEAHxF0CVdSz6zYwtZCpukj7bsiLJz7b9k9Kh1/piobtvJSlZRkot5x5pDB9dYSX7SLrwSKWRLb6TmdFMb6/uvme2mWIMEduDrtyVMbNk7CF90ahWpcfuTIoXkPZD9DbPQr/bBp97ymVLpIwXcRXByoohm1tqkrK3GrY+DiDqsFfn3JrKeK1rdRRpJ4SLIJbBk/EQy7pWwYc3IiVJLTGGZu+1qObyXO6rRVUOhsBJwXdSalE1gIeGoBf9mUloKPWiMf8mnEyAAB5yxT4AYpF3ozsLWwqtSDs+iqGHwWIKuZSPxlQBOTcPlwXwosXhzhr7jyB0yvNHIM1DDKWa4bMUfIisZj5vQMpJwcW2Mazlroc5DpgzPhyQxks96hHqWYIgCIIgCIIgCIIgiAlO3VgQbexvxfRMFjMymzD7mf8Ccg3wp82Gn25EKdOEgKWV1QAQmelyxLNS8LL5MIej3MOcyFKG8RAFlosCKTvROo2DA/acvtPaoa8UydU9uQodjgMzxiLPqM8sygsBAAHz4LkuAidAQ9ALAMj4g5gZdiNw02gI+9CAPgTcQ8opwkcKT6aPxqbeDJp5gAMmdSHtD8F30xhwWpS7HQURJLaH5V0r4SBEigsTexmos8iy6HUmowH9yPiD8IIiOHOQDwtjXOPRhetWAVGwZn27xGYtlGRdVCnbl+6WsjOt/8xAz+Y5x0Ng5g6tf4F4pjFJUtDvJGshaX1lHjPWbSV2X0xrPol+T+sukvXO5Fcfh7f/2/E/6w/F1m0h5s5kmD+5D2nXh8NCpFgJPheu8NLt37S2FJZGbjlLKxdZ0OS2NMRzRrcO35nWf6al0evLX1MhBda+9gJc5keuaGPnZuWGpdh3zhxk/BI4c8AcEZZhwG0FB0N3ahpKXgpZJkIN9KanIsULSIUFzCqtxD6vP4OweTIGJ8/BlpY5kdtZQc3XKSQBsT2s6OqCy32ApVUGw5KbgReW0OD3weEBulPTEMJBkadRQqZ6oQSxm1E3CqJZTW+itzQPG7AHCgefi4C7CMEwlW9ErtiLhnwv+ppmYMBtRRApWlIoRgohHvlri4dUiaXhIwU/9OAxv2bz3p2NPvkfLy8CNtNkmZUigIuAuSi6WcAVaVJ1U+wQjoqt5CLArIYtmJET1yJgHgpeAwLHwz4ds3ddg4i6REzIHZWZhjkcIRfZTHJsEM1DW5Ae3AbupVHItGDE+Yt3Y2wxbCS21PZyu9zfPLZa3J/RwjzveHKzsirLLJnGAHvcIV05ZCrxxsuzgNj90ZWZ8Uyn5ef2RIg/BAD52ftgUr4X75nzIsK5LjL+IN5Mz0DIHeRD8QLY4AyIrKpBCUU3J7JsMSCM4hSFcMoxJsGRCQdHlAZ+Z6PHmxwvGV9Nd7TVy14Gj+KCumEJHngUAkI8u3MQije5uAuI+WI+1YSw461qvwzyaqzasv0SRK2I+LWB8LGRIUhC4bLIeIiC14CthTYEnMFzQqTRPdZV3qUwh4GNk+xh46Ue9Qi5mBEEQRAEQRAEQRAEQUxw6saCCACa03kwxlEI05jsbIXDRZC+rbnZcHIBPF5Chg+hxNIo8gxKLI3JhQ1gnKM3MwVDrAE+F4GnU04JOWeQVmtrwFy5X9a1Sn2WwQhDuMKiKAoEzuHAQwlpVkAIZ1yt/hO7P82lN1FyM/CdtLBc4wwMIVIoYog3YCDbAZblyLA8XAQo+gPVC92NSbIIsFkG6dnHJJ0dHcOyGdE9WxtmP+nXQHc/k65leuBveex4cJ0j6gfprqiPK92SCMAwK8J6J0jlEKQ9ZEoDKKQa0Z+ZhAzPIxMOwgkDlFgGIXMRMhceikgHQ8i7jegLmtHgDMFDCZwxODxEyBy4oT+m1kO7C2YfrVr+KoCyGx5DOemLDGng8ABeUETBawADR8nJ0POI2Gm43EfRzSHjDwp3epkdjznweIBsqR974Z/w3TR8N42e/NAY13gXwxjAxol9yQSxcB0LRvUKv/baazj99NMxdepUtLS04Mgjj8Qf/vCH2D6rV6/GqaeeisbGRkydOhWf+MQnUCwWR3yurDOI9tR6zHFWYwZfCy8UZYRM5NrK8xxKLIMCyyGAB4eF4JxhW3o6tmZmYs/OBdhvz3a8ZeEeeMvCPbBv5yyakG8nCzvnwWEivSjXhhiPXMzktj07F6Cjs3PEWdkIohoz9zkILQMb4SOF3qAF/WETXAglcYqV4DKRfa8/bEJ32IbeoHWX13FXykdgeJYc/bucXOsvhPKzrqzo7OhQf8T2IftRjyskX8Z15ZAO9TexM+no7FRjTmY11H8D4jHIFozB+NvV8nEo04LexunozYksqoxzNY90eCBi5EShCHwnDd9Jg8NBozOIvTrnqvt6Qeee6OzoiLl3EbUzb8+9MW/PvRE45fVrBg6X+3B4EGUmFjEF5y7cF3MW7kfKIWKnMmuvA7Cgc0/0epNRdHMouVkUvAYU3RwKXgNKrlAWe2ER2WIfmgpvjnWVCWKnM6oKopNPPhm+7+PRRx/F008/jYMOOginnHIKNmzYAAAIggAnn3wyBgYG8Pjjj+P+++/Hz3/+c1xxxRWjWS2CIIgxh+QjQRCEHZKPBEEQBDE2MM5Hx354y5YtmDZtGv785z/jqKOOAgD09fWhpaUFv/vd73Dcccfh17/+NU455RSsWbMG7e0iW9X999+Piy66CJs2bUJLS0vV8/T29qK1tRVdT/wewZROuPARwgFjYuXb4QEYOGUzIAgCALD+lecwc5+D8ErXG2jx34TDAwz2bEPn249DT09PTXJnR9nV8vHZ555DS1NTLACt6UJGEAQh0V1K+/r6cPBBB9WdfATKMvKZZ1/A1EaxZipdSnwnDQaRWYtkJEEQgAijkQ1FWALfSaO7L49DDj5gl8nHsULKyjXXX4qW7PjI3NabL2DO1d+u+74fC0YtBtGUKVOw77774gc/+AEOOeQQZDIZ3HHHHZg+fToWL14MAPjb3/6GRYsWqYc7AJx44okoFAp4+umnccwxxwwrt1AooFAop6Tu7RUp1d9Mz8ShnfNGqzkEQdQJM/c5CIB4Cej1JgMABjK79mG3q+Uj45zM8AmCqBkpL1Z0de3yOESjJR+BZBmZ5kOYs/Cto9gqgiDqgYWd87Bq+auYt+feWNHVhTSfYDGIiAnBqCmIGGN45JFHcPrpp6O5uRmO42D69On4zW9+g7a2NgDAhg0bMH369NhxkyZNQjqdVmbEJjfccAOuvfba0ao2QRDEqEPykSAIws5oyUeAZCRBEARBVGPEMYiWLFkCxljFv6eeegqcc1x22WXYY4898Nhjj+Hvf/87Tj/9dJxyyilYv369Ko9ZIpBzzq3bAeCqq65CT0+P+luzZg0AYK+OWSNtCkEQE5h9O2dhn87Z2KdzNhZ2zN4pZY5X+TgWQWYJgtj96ejs3GnyY6zlI5AsI+d0UhgCgiBqQ4Yt6ejsnHiyw3HG1x8xKozYguhjH/sYzj777Ir7zJ8/H48++igeeughbNu2TfkF3n777XjkkUdw991343Of+xxmzJiBJ554Inbstm3bUCqVhq0MSTKZDDK72B2EIAiiFkg+EgRB2Blr+QiQjCQIgiCIaoxYQTR16lRMnTq16n6Dg4MAAMfQ7jmOgzAMAQCHH344rr/+eqxfvx4zZ84EADz88MPIZDLKz5wgCGJ3geQjQRCEHZKPBEEQBDH+GTXbrMMPPxyTJk3ChRdeiOeffx6vvfYaPv3pT2PlypU4+eSTAQAnnHAC9ttvP1xwwQV49tln8fvf/x5XXnklLr74YopGThBE3ULykSAIwg7JR4IgiPFJNTfhXf1HjA6jpiCaOnUqfvOb36C/vx/HHnssDj30UDz++OP47//+bxx44IEAANd18ctf/hLZbBZHHnkkzjrrLJxxxhm46aabRqtaBEEQYw7JR4IgCDskHwmCIAhi7GCc7+L8pTuZ3t5etLa2oqenh1aNCILYLupVjtRruwiC2HXUsxyp57YRBDH6TBQZItv5xlc+ipbs+Ijj1psvYPbnbqv7vh8LRi3NPUEQBEEQBEEQBEEQdQAbR9nD2DipRx1CPUsQBEEQBEEQBEEQBDHBIQURQRAEQRAEQRAEQRDEBIdczAiCIAiCIAiCIAiCSIQ5DMwZH9nDxks96hGyICIIgiAIgiAIgiAIgpjgkIKIIAiCIAiCIAiCIAhigkMuZgRBEARBEARBEARBJMOc8ZM9bLzUow6hniUIgiAIgiAIgiAIgpjg7PYWRJxzAEBvb+8Y14QgiN0VKT+kPKkXSD4SBLGj1Kt8BEhGEgSxY9SzfCQmLru9gqivrw8AMGfOnDGuCUEQuzt9fX1obW0d62rsNEg+EgSxs6g3+QiQjCQIYudQj/LRisPE33hgvNSjDtntFUTt7e1Ys2YNmpubwdjEGCi9vb2YM2cO1qxZg5aWlrGuzriH+mtkTMT+4pyjr68P7e3tY12VnQrJx4kxfncE6q+RMRH7q17lI0AycqKM4R2B+mtkTLT+qmf5SExcdnsFkeM4mD179lhXY0xoaWmZEMJ3Z0H9NTImWn/V48oPyceJM353FOqvkTHR+qse5SNAMnIijeEdhfprZEyk/qpX+VhvLFmyBNdee21s2/Tp07FhwwYAQtl37bXX4jvf+Q62bduGww47DLfddhv2339/tX+hUMCVV16JH/3oRxgaGsJxxx2H22+/ve6eIxSkmiAIgiAIgiAIgiCIRBhzxtXfSNl///2xfv169ffCCy+o32688UbcfPPNuPXWW/Hkk09ixowZOP7445UrMgBcfvnl+MUvfoH7778fjz/+OPr7+3HKKacgCIKd0r/jhd3egoggCIIgCIIgCIIgiImFmWQgk8kgk8lY9/U8DzNmzBi2nXOOW265BVdffTXOPPNMAMDdd9+N6dOn47777sMll1yCnp4e/Od//ifuuecevPvd7wYA/PCHP8ScOXPwu9/9DieeeOJObtnYQRZEuyGZTAZf+tKXEgc/EYf6a2RQfxG7MzR+Rwb118ig/iJ2d2gMjwzqr5FB/VXnyCDV4+UPIslAa2ur+rvhhhsSq79s2TK0t7djwYIFOPvss7FixQoAwMqVK7FhwwaccMIJat9MJoOjjz4af/3rXwEATz/9NEqlUmyf9vZ2LFq0SO1TLzBOefkIgiAIgiAIgiAIgjDo7e1Fa2sr1v3fK9GSGx/Kv96hAto/edOwgOhJFkS//vWvMTg4iL322gsbN27Eddddh1deeQUvvfQSXn31VRx55JFYu3ZtLOD4hz/8YaxatQq//e1vcd999+Hf//3fUSgUYuWecMIJWLBgAe64447Ra+wuhlzMCIIgCIIgCIIgCILYrag1IPpJJ52kPh9wwAE4/PDD0dnZibvvvhtvf/vbAWBYNkvOedUMl7Xss7tBLmYEQRAEQRAEQRAEQSTCHGdc/e0IjY2NOOCAA7Bs2TIVl0hmNJNs2rQJ06dPBwDMmDEDxWIR27ZtS9ynXiAFEUEQBEEQBEEQBEEQE4JCoYCXX34ZM2fOxIIFCzBjxgw88sgj6vdisYg//elPOOKIIwAAixcvRiqViu2zfv16vPjii2qfeoFczAiCIAiCIAiCIAiCqEuuvPJKnHrqqZg7dy42bdqE6667Dr29vbjwwgvBGMPll1+OpUuXYuHChVi4cCGWLl2KhoYGnHvuuQCA1tZWfOhDH8IVV1yBKVOmYPLkybjyyitxwAEHqKxm9QJZEI1zrr/+ehxxxBFoaGhAW1ubdZ/Vq1fj1FNPRWNjI6ZOnYpPfOITKBaLsX1eeOEFHH300cjlcpg1axa+/OUvY6LEJ7/99tuxYMECZLNZLF68GI899thYV2mX8+c//xmnnnoq2tvbwRjDAw88EPudc44lS5agvb0duVwO73rXu/DSSy/F9ikUCvj4xz+OqVOnorGxEaeddhreeOONXdgKgohD8nHHIfkoIBlJ1BskH3ccko8Cko+EgrHx9TcC3njjDZxzzjnYe++9ceaZZyKdTuN///d/MW/ePADAZz7zGVx++eW47LLLcOihh2Lt2rV4+OGH0dzcrMr4xje+gTPOOANnnXUWjjzySDQ0NODBBx+E67o7tZvHGlIQjXOKxSLe97734SMf+Yj19yAIcPLJJ2NgYACPP/447r//fvz85z/HFVdcofbp7e3F8ccfj/b2djz55JP45je/iZtuugk333zzrmrGmPHjH/8Yl19+Oa6++mo8++yzOOqoo3DSSSdh9erVY121XcrAwAAOPPBA3Hrrrdbfb7zxRtx888249dZb8eSTT2LGjBk4/vjj0dfXp/a5/PLL8Ytf/AL3338/Hn/8cfT39+OUU05BEAS7qhkEEYPk445B8rEMyUii3iD5uGOQfCxD8pGoB+6//36sW7cOxWIRa9euxc9//nPst99+6nfGGJYsWYL169cjn8/jT3/6ExYtWhQrI5vN4pvf/Ca2bt2KwcFBPPjgg5gzZ86ubsqoQ2nudxPuuusuXH755eju7o5t//Wvf41TTjkFa9asUWn57r//flx00UXYtGkTWlpa8K1vfQtXXXUVNm7cqNL+feUrX8E3v/lNvPHGG3UXeV3nsMMOwyGHHIJvfetbatu+++6LM844AzfccMMY1mzsYIzhF7/4Bc444wwAYuWnvb0dl19+OT772c8CECs906dPx1e/+lVccskl6OnpwbRp03DPPffg/e9/PwBg3bp1mDNnDn71q1/hxBNPHKvmEATJx+2E5KMdkpFEPUHycfsg+WiH5OPERKa5X3/rZ8dVmvuZH/sqenp6aspiRtQOWRDt5vztb3/DokWL1MMdAE488UQUCgU8/fTTap+jjz5aPdzlPuvWrcPrr7++q6u8yygWi3j66adxwgknxLafcMIJ+Otf/zpGtRp/rFy5Ehs2bIj1UyaTwdFHH6366emnn0apVIrt097ejkWLFlFfEuMWko/JkHysHZKRRD1C8jEZko+1Q/JxguEwwHHGyV/9KqjHGlIQ7eZs2LBhWGq9SZMmIZ1Oq1R9tn3kdzOdXz2xZcsWBEFgbXs9t3ukyL6o1E8bNmxAOp3GpEmTEvchiPEGycdkSD7WDslIoh4h+ZgMycfaIflIEPUHKYjGgCVLloAxVvHvqaeeqrk8m4kv5zy23dxHehbWs3mwxNb2idDukbI9/UR9SexsSD7uWkg+1g7JSGKsIfm4ayH5WDskHwmifqA092PAxz72MZx99tkV95k/f35NZc2YMQNPPPFEbNu2bdtQKpWUNn/GjBnDNPSbNm0CMFzjX09MnToVruta217P7R4pM2bMACBWeGbOnKm26/00Y8YMFItFbNu2LbYCtGnTJhxxxBG7tsJEXUPycddA8rF2SEYS4wWSj7sGko+1Q/JxgrEd2cNGjfFSjzqELIjGgKlTp2Kfffap+JfNZmsq6/DDD8eLL76I9evXq20PP/wwMpkMFi9erPb585//HEtd+vDDD6O9vb3micTuSDqdxuLFi/HII4/Etj/yyCP0QNJYsGABZsyYEeunYrGIP/3pT6qfFi9ejFQqFdtn/fr1ePHFF6kviZ0KycddA8nH2iEZSYwXSD7uGkg+1g7JR4KoP8iCaJyzevVqvPnmm1i9ejWCIMBzzz0HANhzzz3R1NSEE044Afvttx8uuOACfO1rX8Obb76JK6+8EhdffLGK6H7uuefi2muvxUUXXYTPf/7zWLZsGZYuXYovfvGLdW/a+alPfQoXXHABDj30UBx++OH4zne+g9WrV+PSSy8d66rtUvr7+7F8+XL1feXKlXjuuecwefJkzJ07F5dffjmWLl2KhQsXYuHChVi6dCkaGhpw7rnnAgBaW1vxoQ99CFdccQWmTJmCyZMn48orr8QBBxyAd7/73WPVLGKCQ/JxxyD5WIZkJFFvkHzcMUg+liH5SBATC1IQjXO++MUv4u6771bfDz74YADAH/7wB7zrXe+C67r45S9/icsuuwxHHnkkcrkczj33XNx0003qmNbWVjzyyCP46Ec/ikMPPRSTJk3Cpz71KXzqU5/a5e3Z1bz//e/H1q1b8eUvfxnr16/HokWL8Ktf/Qrz5s0b66rtUp566ikcc8wx6ru89hdeeCHuuusufOYzn8HQ0BAuu+wybNu2DYcddhgefvhhNDc3q2O+8Y1vwPM8nHXWWRgaGsJxxx2Hu+66C67r7vL2EARA8nFHIflYhmQkUW+QfNwxSD6WIflISJjjgDnjwwFpvNSjHmFcRpsjCIIgCIIgCIIgCIKI6O3tRWtrKzbccTVacrW5sY42vUN5zLjkevT09CirR2LnQKo3giAIgiAIgiAIgiCICQ65mBEEQRAEQRAEQRAEkQxzxN94YLzUow6hniUIgiAIgiAIgiAIgpjgkIKIIAiCIAiCIAiCIAhigkMuZgRBEARBEARBEARBJMMY4LCxroWAjZN61CFkQUQQBEEQBEEQBEEQBDHBIQURQRAEQRAEQRAEQRDEBIdczAiCIAiCIAiCIAiCSIQxB2ycZA8bL/WoR6hnCYIgCIIgCIIgCIIgJjhkQUQQBEEQBEEQBEEQRDLOOApSPV7qUYeQBRFBEARBEARBEARBEMQEhxREBEEQBEEQBEEQBEEQExxyMSMIgiAIgiAIgiAIIhnmiL/xwHipRx1CPUsQBEEQBEEQBEEQBDHBIQURQRAEQRAEQRAEQRDEBIcURDuJBx54APPnzwcA7L///njooYfUb9/97ncxc+ZMNDU14dlnn8XmzZtx7LHHoqWlBe973/t26LxNTU144YUXdqiMsYQxhueeew4AsHTpUpxzzjk1HTee2/3YY49h9uzZO6UsvX9GwhlnnIElS5ZY65PP5/Gv//qvaGtrw9ve9jYAwIMPPoj58+ejqakJDzzwwHbX995778URRxyx3ccT9Uk9y8eTTjoJt99++6iU/cc//hFtbW0jPtfOlEGjwUhkfSXM/hkJbW1t+OMf/2itz7Jly/DWt74Vzc3NuOKKKwAA1157LfbYYw80NTVh69at213nSy+9FJ/97Ge3+3iC2B0w5Xq9sGTJEpxxxhljXY0RY8q03bUdxDiAsfH1R4wKFINoFHjppZfU51KphE9+8pP4zW9+g3e+850AgOuvvx6u66K7uxuOs2M6uv7+/h06fjzx+c9/vuZ99XYvWbIEzz333A4pNraX119/HQsWLMC2bdvUi8pRRx2FN954Y5fXJQmzPj//+c/x6quvYuPGjchkMgCAT33qU/jyl7+MD3zgAzt0rvPOOw/nnXfeDpVB1Df1Jh9//etfj/o5Rnou855/17vehTPOOAOXX375KNUsmbvuugu33HJLTNE9Elm/KzDrc+ONN+Itb3kLnnzySQDAG2+8gf/v//v/0NXVhXnz5u3Qub797W/v0PEEMd6xyXVibDFlmlxAJAiCsEEWRKPMxo0bMTQ0hLe85S1q28qVK7H//vvv8MsPMbb4vj/WVdguVq5cib322ksph+Q2fYwSxK6A5GN9szvLyAMOOEB9f/3119HU1LTDyiGCqHd837fKdWJsMWUaQRBEJWgGvp288cYbOOGEE9DS0oLFixfjn//8p/pt/vz5eOCBB/Dss89i7733BgDMnj0bnZ2deN/73oe7774bt99+O5qamvCf//mfVlNP3fz9mWeewdvf/na0tLRg6tSpOPXUU9V+ugsS5xxf//rX0dnZicmTJ+M973kPVqxYEavXjTfeiLe//e1obm7G0UcfjTVr1lRta6lUwhe/+EV0dnZiypQpOO2007Bu3ToAwK233op99tkHAwMDAIC//e1vaG1txcsvv6zOef311+OQQw5BS0sLTjzxRHWsidkPGzZswPnnn4/29na0tbXhne98J4aGhmLtfuCBB7B06VI89NBDaGpqQlNTU8V2TJs2DX/+859j2/fbbz/cf//9AIBNmzbhvPPOQ3t7O9rb23H55ZejUCgAKLszfOtb38LcuXNx+OGHKxet2bNno6mpCffee+8wt4disaj6r7m5GQcccACeeeYZAMIla9GiRWhubsbcuXPxhS98AZzzqtfE5Oc//zn23HNPtLa24uKLL469mOn1ueKKK/DlL39Z9dfHP/5xNDU1IQgCHHHEEWhqakKhUFBjWKK7CAHAzTffjLlz56K5uRnz58/H9773PQDCWuCggw5S+23cuBFnnXUWpk2bhrlz5+Lqq69WdZP1+t73voc5c+ZgypQp+MxnPjPithPjj4kkH9/1rnfhlltuARCXEbNmzcKkSZNwyy234OWXX8Zhhx2GlpYWnHHGGUpevv7662CM4bvf/S7mz5+PKVOm4LLLLkOxWKx6LgB4+umnceyxx2Ly5MmYNm0aPv7xj8fqAYh7/rHHHsNnP/tZNDU14aSTTkpsyzPPPIPm5mYMDg6qbevXr0c6ncbatWvVPscccwwmT56MPffcE9/97nfVvkuWLMEpp5yCj3zkI5g8eTJOPPFEXHrppXjhhReUfF69evWIZP1nPvMZzJs3D83Nzdhvv/3w05/+tOo1MQnDEF/4whcwffp0tLe347bbbov9rtfnbW97G/7whz+o/vrZz36G448/Hj09PWhqasKxxx6rrlt3d7cq4/LLL8dFF10EACgUCvjgBz+IqVOnorW1FYsWLVIr9xdddFHMkuupp57CkUceiba2Nuy333740Y9+FKvXqaeeio997GNoa2vD3Llz8eMf/3jE7SeIWrA916vJX9s9b8p1WfbChQvR3NyMzs5O3HrrrbEyly1bhtNOOw3Tpk3D5MmTceaZZ6rfurq6cOqpp2LatGmYN28errvuOoRhWLU9Scf5vo/DDz8c11xzjdr3ox/9KI477jhV7o9+9CMceOCBaGlpwbx583DXXXepfYMgSLwnH374YRx66KFobW3FzJkzcdlllylZBlR/zrz00kvqt2OOOQaf+cxn8K53vUv9XmmOmoQp0373u9/Ffq8mzx566CFMnz4d69evBwCsWLECkyZNwh/+8IfKF4CoTxxnfP0RowL17HZy7rnnYubMmdiwYQPuvffe2CRZcvDBByt3ijfeeANdXV346U9/ivPOOw+XXXYZ+vv78aEPfajquT72sY/h1FNPRXd3N9auXYtPf/rT1v3uuece3HzzzXjggQewbt067L///jjllFNiyoIf/OAHuO+++7B582Y0NjbiC1/4QtXzX3311fjLX/6Cxx9/HOvXr8dee+2Fs88+W9Vt7733xsc//nH09PTg3HPPxU033YR9991XHf+9730P9913HzZs2IAZM2bU5IIUhiFOO+00eJ6Hl156CVu2bMHSpUuHWRWcccYZ+PznP49TTjkF/f39FV1KUqkU3v/+9+Oee+5R25566imsXbsWp59+OjjnOO200zBjxgwsX74cL7zwAp5//nlcd911av++vj48//zzeOWVV/CnP/0Jf//73wGI69vf329t2+c+9zn86le/wm9+8xv09vbiZz/7GaZMmQIAmDx5Mv7rv/4Lvb29+J//+R985zvfwX333Ve1f3SWLVuGc889F9/4xjewdetWLF68GL/5zW+s+37961+P9dc3v/lN1Wd//etf0d/fH7MssvHaa6/hmmuuwcMPP4y+vj488cQTSlFmcu655yKVSmHlypV47LHH8MADD+DGG29Uv/f19eGFF17AsmXL8Pjjj+O2225TE09i92UiyUeTvr4+dHV1YeXKlfjJT36CK6+8Ep/61Kfwk5/8BKtXr8ayZctwxx13xI75xS9+geeeew4vvPAC/vrXv+KGG26oep61a9fi2GOPxXvf+16sW7cOq1atwllnnTVsv69//es46qij8NWvfhX9/f0V3dQOOeQQzJ8/H7/4xS/UtnvvvRdHH300Zs2ahQ0bNuD444/HRz7yEWzevBkPPPAAvvSlL+H3v/+92v83v/kNDjvsMGzatAkPPvggvv3tb+OAAw5Q8nnu3Lmxc1aT9QceeCCefPJJdHd344tf/CIuuOACrFy5smr/6Nx1112466678Kc//QnLly/HU089hb6+Puu+f//732P99d73vhe//vWv0draiv7+fjz66KNVz3f33Xfj+eefx/Lly9Hd3Y3/+q//wowZM4bt193djfe85z04++yzsXnzZnzrW9/CxRdfjL/85S9qn9/+9rc48sgjsXXrVlx33XX4j//4j8S6E8T2MpLnuol5z5tyHQDmzZuHRx99FL29vfje976HT3/602qcDwwM4N3vfjcWLVqE119/HRs2bFDK7qGhIRx33HE49thjsXbtWjz22GO4//778f3vf79inSod53ke7rvvPtx+++344x//iP/+7//GT3/6U9xzzz1wHAcPPvggPvaxj+Eb3/gGuru78eSTT+LAAw9UZVe6J3O5HL773e/izTffxF/+8hf84Q9/wM033xyrW9JzplQq4bTTTsNJJ52ErVu34itf+QruvPNOdVwtc1Qbpkx797vfXfWa6pxyyil4//vfjw984AMoFAo455xzcNlll+GYY44ZUTkEQew+kIJoO1izZg0ee+wxfO1rX0NDQwP22WcfXHrppaN2vlQqhVWrVmHdunXIZDKJPt333HMPPvGJT+CAAw5ANpvF0qVL8cYbbyglBiBepjo6OpDNZnHeeefh6aefrnhuzjluv/123HzzzZg5cybS6TSuu+46/OUvf1GrHnfeeScefvhhvPOd78Shhx6Kiy++OFbGRz7yEeyzzz5oaGjAjTfeiD/+8Y9VY/Q8+eST+Oc//4lvfetbmDRpEjzPwzve8Y6qyotqfOADH8BPf/pT5PN5AKLP3vve9yKXy+Gpp57CsmXL1HWdMmUKPv/5z8cUNmEY4itf+QoaGhrQ0NBQ9Xycc9xxxx1q9Ywxhr333lu5Kpx00knYa6+9wBjDQQcdhHPOOWfECpL7778fxx13HE499VR4nodLL70UCxcuHFEZI8F1XXDO8dJLL2FoaAjTp0+3mpKvXbsWjz76KL7+9a8r94yrr746thLHOccNN9yAbDaLfffdF0cccUTVMUmMbyaSfEziy1/+MtLpNI4//nhMnjwZp59+OubNm4e2tjacfPLJyoJQsmTJErS1taG9vR1XXXVVTImdxA9/+EMsXrwYl112GbLZLBoaGnDUUUdtV311Lrjggtj577nnHhWb7J577sE73/lOnHXWWXBdF4sWLcK///u/x2TkokWLcNFFF8HzvJpkZDVZf95552GPPfaA67o4++yzsc8+++Cvf/3riNp077334uMf/7h6Dn3lK1+pyQJhe0mlUujr68PLL78Mzjn22msvzJkzZ9h+v/zlL5XlVyqVwtFHH41zzz0Xd999t9rnkEMOwTnnnAPXdXHBBRegWCzitddeG7W6ExOTWp/rNmq55//t3/4Nc+bMAWMMxxxzDE488UQ113nooYeQSqVw/fXXo7GxEel0WikfHnroIUyaNAn/5//8H6TTacydOxef/OQnqy6kVTtuwYIFuO2223D++efjQx/6EO688060t7cDAG6//XZ88pOfxLHHHgvHcbDHHnvg4IMPVmVXuiePOuooHHzwwXBdFx0dHbjkkkuGzemSnjP/+7//i61bt+Lqq69GOp3GYYcdhve///3quFrmqKPF1772NWzatAlve9vb4DgOrr322lE/J0EQYwcpiLaDdevWIZvNYo899lDbRjM2wZ133ol8Po/Fixdjn332GWaaK3njjTdibkCZTAbt7e0xZYy+itnY2Fh1JXLLli0YGBjAO9/5TrS1taGtrQ0zZsxAOp1WCqIpU6bgfe97H/7xj3/gc5/73LAy9L6ZPn06MpmMcldIYtWqVZg1axZyuVzF/UbK2972NsyYMQP/8z//A9/3cf/996uXn9dffx3d3d2YPHmyaut73/tebNy4UR3f3Nw8oqw5mzdvxuDgYKLC5re//S2OOOII5Yrw7W9/G1u2bBlRm9atWzds/I3meOzs7MTdd9+NW2+9FdOnT8cJJ5xgzbT2xhtvIJvNxsZcR0dHbDy2tLTEJpS1jElifDOR5KON5ubm2JhuaGiIldvQ0DDM0lHvn3nz5lWVj4CQkaOhCD7//PPx6KOPYv369fjHP/6Brq4u5e7x+uuv41e/+pWSj21tbfh//+//KdcDAMMshKpRTdZ/4xvfwP7774/W1la0tbXhxRdf3GEZKZ9Do8UFF1yAiy66CJdeeimmTp2Kiy66yFpnc0wCw2WkPnYYY8jlciQjiZ1Orc91G7Xc8/feey8OOeQQTJo0CW1tbfjVr36l7olVq1ahs7MTzJKR6PXXX8eLL74YkzlXXHEFNmzYUPF8tRx35plnIggCtLe345RTTlHbq8nWSvfkk08+iXe/+92YPn06Wlpa8PnPf37YvZ/0nFm3bh1mzpwJzyvnD9L7tpY56miRyWTwwQ9+EP/4xz9w5ZVXxupITDCYM77+iFGBenY7aG9vRz6fx6ZNm9S21atXb3d5TU1NsZgPg4OD6O3tVd87Ozvxgx/8ABs2bMD3vvc9XHnlldaV7dmzZ+P1119X34vFItatW7dD6Y6nTJmChoYGPPHEE+ju7lZ/Q0NDKp35//7v/+L73/8+LrjgAnz0ox8dFph01apV6vOmTZtQKBQwa9asiueVL0m673YSIw1mK1fIf/Ob3yCXyymLgzlz5mCPPfaItbOnpyf2Mmeeq9q5p02bhoaGBixfvnzYb8ViEWeeeSYuueQSrF27Fj09Pbj00ktHHIOovb091sfAjo1HYPiY1F8AAeCss87CH/7wB2zcuBEHHnggLrjggmFlzJ49G/l8PjZ5Wbly5bhOv03sOBNJPu4s9Pt39erVVeUjIGSkTa7YGImMbG9vx9FHH4377rsPP/jBD3DmmWeisbERgJCR//qv/xqTkX19ffjVr36VeK5q564k6x9//HEsWbIEP/jBD7Bt2zZ0d3dj0aJFOywj5XNoe5Gx7pJkpOd5+PznP4/nn38eL7/8MlavXm1dcTfHJEAykhg7bM/1avIXqH6Pr169GhdeeCFuvPFGbN68Gd3d3fiXf/kXdR/PmzcPXV1d1vt6zpw5WLx4cUzm9Pb2xrJh2qjluCuuuAL77bcfCoUCvvnNb6rtI5GtJueccw6OOeYYrFixAr29vVi6dGnN8qq9vR0bNmyIzaH1Z2ctc9TtoZo8A4Rcuvbaa3HxxRfj05/+9LAxQBBEfUEKou1gzpw5OPLII/G5z30OQ0NDePXVV4fFlBgJhxxyCP72t7/hlVdeQT6fx1VXXRVbSfnBD36AjRs3gjGGSZMmwXEcq/b+/PPPx6233op//vOfKBQKuOaaazBr1qya/chtOI6DSy+9FFdccYWyGNq6dasKytfb26viDt15551gjOGLX/xirIw77rgDr776KoaGhvDZz34W73znO6tOgN/61rdi7733xkc/+lF0d3fD9308/vjj1kn99OnTsWrVKgRBUFObLrjgAjz88MP4xje+gfPPP1/19Vvf+lbMnTsX11xzDfr6+sA5x6pVqyrG7Jg2bRocx1F+9iaMMVx88cW44oorsHz5cnDO8eqrr2LVqlUoFArI5/OYMmUKMpkMnnjiie0yFT7rrLPw+9//Hr/85S/h+z6++93v7rALwiGHHIIf/ehHyOfzWLFiRSyo66uvvopHHnkEQ0NDSKfTaGpqso7HWbNm4ZhjjsGVV16JgYEBrF69GkuXLsWFF164Q3UjxjcTST7uLL785S+ju7sb69atww033FBTnLbzzjsPf//73/Htb38bhUIBg4ODeOyxx6z7Tp8+PVFG2fjABz6Au+++G/fdd5+ysASE7Hz00Ufx85//HKVSCaVSCc8995wKwJx07vXr1ycq+yvJ+t7eXnieh2nTpiEMQ9x555148cUXa26H5JxzzsFtt92mnkNXXXXVDmXJmzp1KubOnYu7774bYRjiD3/4Q0xJ9uijj+K5556D7/tobGxENpu1jsl/+Zd/waZNm3D77bfD93089thjw/qcIHYFSc/1avK3Fvr7+8E5xx577AHHcfCrX/0KDz/8sPr95JNPRqFQwBe/+EUMDAygWCyqAMinnHIKNm7ciNtvvx35fB5BEODVV1+t6opf7bj/+Z//wU9+8hP88Ic/xI9+9CNcc801+Mc//gEAuOSSS/B//+//xZ/+9CeEYYhNmzbh2Weframtvb29aGtrQ2NjI15++WV861vfqrmf3v72t2PSpEm44YYbUCqV8OSTT+InP/mJ+n175qi1UE2e+b6v4g595zvfweLFi0fVbZwgiLGHFETbyX333Yc1a9Zgjz32wLnnnosPfvCD213Wsccei0suuQRHHHEE9txzTxxwwAFobm5Wv//ud7/DgQceiKamJpx22mn42te+FguYJ/nABz6Aj3/84zjllFMwY8YMPP/883jwwQd32BT0hhtuwOGHH45jjz0Wzc3NWLx4sXq4X3LJJTjkkEPwH//xH/A8Dz/60Y/w7W9/O5bd4IMf/CDOOeccTJ8+HWvXrsW9995b9ZwyUODg4CD23ntvTJ06Fddcc401bsT73vc+lcGoFvevuXPn4ogjjsCjjz4as3xxXRcPPvgg1q5di3333Retra04+eSTK64k5XI5fOlLX8JJJ52EtrY2q4Lnq1/9Ko477ji8+93vRktLC973vvfhzTffRHNzM2677TZ8+MMfRktLC66//vqYv3mt7L333iq+ypQpU/DEE0/gPe95z4jL0bnuuuvQ3d2NadOm4dxzz429sBSLRZURaMqUKXj00UdjcYV07rvvPgwNDWHevHk48sgjcfLJJ1OmsgnARJKPO4PTTz8dBx10EBYtWoTDDjsMn//856seM3v2bPzud7/Dfffdh+nTp2P+/Pn42c9+Zt338ssvx+9+9zu0tbXFXCmSOPPMM7Fy5Uo4joNjjz1WbZ81axZ++9vf4o477sDMmTMxffp0fPSjH624mnzsscfi7W9/O2bNmoW2trZh1mSVZP173vMe/Nu//RsOOOAAtLe346WXXsKRRx5Ztf4mH/zgB3H++efjqKOOQkdHBw4++ODYGNoe7rzzTnz/+99Ha2sr7rjjDpW4ARDZG8855xy0tbVhwYIFaG1txZe+9KVhZUyaNAm//vWv8cMf/hBTpkzBhz/8YXzrW9/CO97xjh2qG0GMlKTnejX5Wwv77bcfrr76ahx77LGYMmUKfvzjH+O0005Tv8vMWk8//TTmzp2LmTNnqkUp+dvvf/97lenx3HPPrepiVum4devWqbhDM2fOxCGHHIIlS5bgnHPOwdDQEM444wzcfPPN+OhHP4rW1la89a1vxQsvvFBTW++44w7cdNNNaGpqwqWXXhqTC9VIpVJ44IEHVPykz3zmMzj//POVO+z2zFFrpZI8k0G0lyxZAgD47ne/i7/+9a+xWGnEBMJh4+uPGBUY356c2gRRI/Pnz8ctt9wyLE0qQRDEROf111/HggULsG3bthHFNiMIgiDqnw9/+MMIwxDf+973xroqxASnt7cXra2t2HjvV9HSkB3r6gAAegfzmH7eZ9HT04OWlpaxrk5dQRZEBEEQBEEQBEEQY8hjjz2GNWvWIAxD/P73v8d9992H973vfWNdLYIgJhikICLw2GOPoampyfqXFNNiPLP//vtb27I7+0yfdNJJ1jaddNJJY101gqhr6k0+rl69OrE9tbj/jleS2rR06dKxrhpBEKPApZdear3n999//7Gu2nazYsUKvP3tb1dz1qVLl+LEE0+setzSpUsTZSBB7FQYG/vMZeqPXMxGC3IxIwiCIAiCIAiCIAhiGMrF7L4b0dKQG+vqAAB6B4cw/dzPkIvZKEAWRARBEARBEARBEARBEBOcsU/fQhAEQRAEQRAEQRDE+IWx8ePaNV7qUYfs9gqiMAyxbt06NDc3g9FAIQhiO+Cco6+vD+3t7XCc+jGsJPlIEMSOUq/yESAZSRDEjlHP8pGYuOz2CqJ169Zhzpw5Y10NgiDqgDVr1mD27NljXY2dBslHgiB2FvUmHwGSkQRB7BzqUT4SE5fdXkHU3NwMAHjs8cfR3NgIrq0AsSj+NmdMfZbI/RjnWNDRAQBYsXJl7Fg+wtUk8xzVGI3yzTLlMWYbK7VvpO2oVoekcvVrkFTvauXb9tOvt36OpHL032xjpVo5tZSZtM2G3h9J56vUd3o5lY6tdN5KZe/ovVHt+tWKea1s1x0AOhYsUJ9t479jwQL09vZizpw5Sp7UC7I9j0eZuJKub61jU8fs11rv41rHtr5PpTFTy3ga6Zg3/48UW723d5+R9ockSZZV2q/a55H0RZIMrEXG2Mowy9G/V9o3qS611Fevo638kVznpP1G8qyq5Ry2+iWVU6uM7+/vx1HveEfdyUcgPofUMz5xzsDY2ORw4TwaC9r5bdsIghh76lk+WnEc8TceGC/1qEN2ewWRNAluampCc/QCZJvUVpoob9m8GR2dnbGbu5aJn9wvaWJXaTKo/17LxLvahJgzhs6ODnStWDHsuI7OTnStWIHOjg60aH1UyyR4e6j1JSLpJayWl8pKL6LV+j2pTLltJC+utexTq9LIPH81ZZV5jmovGpVe8kbyMpdUv2ovH7brXYvCrdYX4KQXts1btqjPzc3Nw47RMx/Um4tBTD42N9c05msZw5wxbN6yRcmcFv3Fyhg/I1GM2s5fSebVIg90ksZoZ0cHVnR1Weu+PXXW61dNIbGzFWbmcbb7Vj+22j1dSU6PVDEy0jIqYcqRWsaxSTX5pB9ruwdqnSfU2pZa5b35+/Yox6rJbusxdSYfgeEyUlJJQZT0285SKpGCiCB2P+pRPhITl7pRvSW9fNYyyeeMKcUK47zqpE/fR35P2m8k+1TabqsLZ6ziy77837ViBRjnWNHVhY7Ozli/dHZ0oDOyLtLLNMuV35P6RP9d9k8tyqZaro3+u20iW22iW4sSohpJLzXVjq1Ud7nN7PNKCiVzu+1ctjabx1cam7WMW/03WXfbdTfHYlIdbPW09bFtXOrnr6WNZhkrurpi1oP1TjXFRCVFpj5OpUyx7VtNKaSPlaSxYJMNSd/143V5ZivTVr4p/2tR7lQa5+b9ZqtTLfe0+ZttrNvKs5H0vNCPraYcSrqfR3LOkTwLR/oMTZIHpnyt1ld6O6s9Z6uNb1uZlcpIqmfSeKzlGTqS7TZqvd71glTGyP/6dnObud38bDvO3G47ppa6VduXIAhip8PY+PojRoW6URARBEEQBEEQBEEQBEEQ20ddKYhqMZfXSbKUqWY2X+vKm7TWsa0uyzI6OjvR0dkZK1/uZ1r36L9XW8mV2zs6O9HZ0QHOGDo6O2NWRPp59eNsFkWSzo4OVWe9DTq1rown1Vkvx2YVkmSJU41qlihJx4zUeihpZbnSarR+XKWyk0haLbf9bsNctR6JhUBSfWxWCZXKrbTCX6leptWfbfxt75isN2xjMMlqsNZ+0uWVzRJOP0/S96R72maFYVqsSaTc0l3FTFlVDX3MJvWHKZOTxrle1xVdXVZLrUoWcea+STLfZh1Ti4VMJSvDShYz1ahmoVjrsfrzfCQWTOb+SfuaFm/V5LJNxmyPnK50n1W7Bytds6TzVbJ0SipX7j/S9u3OmBY80pWrVoseeYzuAmZ+tpWV5DIm9ydLIYIgCGJXU1cKIkm1CbbcR99eaeJp26eWl1k9HpB8UTGVQV0rVgyLGyTLkL+Z9dbL0M9vng8QL0tyu1QO6f/N/fW62VjR1aWOk8oiG0ntte1newGUx9leZPWybAoB23W2vfwkmf9XcymoBb28aseZY8t2jNneJKVItQm9vl9SX9n2s5WT9MJve2G1HZtUZ70PbC9n5r56uZX6ztbOWl446wlT7tl+T7pekqRjpRLEpiiRn816VBsrcrv5Ep90vcztunyVx1ZyQZP7mXJNP0YqoGx1Mdsgj6vUf7b+SlIemeeQ5dtkiHmc7XxJilPzfkv6bzuf7ZzmdlsbbTLHlMe1Kh/17TYZVumaJZ3Htk8l5ZN5btu9ZxtH5vyimmyqZR+9/Gr7mNdloshGHam0MZU3tu1SKZSkGLIdZ/tf6bP5Z+5HEMTYMCGVt8wZX3/EqEA9SxAEQRAEQRAEQRAEMcGpGwWRzbJCbrftW2mVNsmEX/4lWduYK4Z6OV0rVijrG9sKtr5Nlt/Z0QHGh7uCSQse23nkZ7mP2Z6uFSvAGYtZD8m6VbOMMq2C5Oq8LEuvp7Rc0i2gOGPKbU66o+jt1/vWtJyytddmeaR/t63cJq0mmyvGSfuaZSeRtAJtsx4wx1fSqnrSKneSxUaSZY55TFIZsr7marbZDpvVk7mt0gp/pb621dFst37fJd3vZp1qtUCoJ2xyz2a9UIsFVlI/2ywP5DabK20liyP92EqWJxLTEtN23eV+NmskfQzKrI9SLutBrM1+TLpvOWOqHCnHzTFrWhiZMtZmyST/kp5zSdenkpWPrS22/c172uzHpGtTzWLHlDm2OtraYNvHLFPfJ8kCST+mVuuZpGdD0mebLDXHpu0+NK2QzPGW1F+2+9xWb70ss9yk61mPVLMaSvpOjB3mXLqadeiuwBaMfLxSbX5bSZ5V+zzesQWgt323BaAfaWB5gtgd2e3T3CdR7SVoe8yy5THmC0a185rHr+jqAow66W4QK7q6wFBW8sjvSVSbwJn1sT1EdZczWReZwlr+19vNOAe0FwSZJhraZ/3lqpJSTFeI6efVlUX68frLmv4/iaQXHdt/ub9N0Zc0ZmwvNUmKkUovQDaFh60M2zhW/W/ZL+llz4btGFt/VHuBtL1k2Mqwnd92v+p1ruWlzXaupOMnwgtQtTGkf05S0pj3ijl29e1m2nggLseS6lNJwZTUFn2bTYlhu78BxOpo1l3WV8/6KJHHdXR2xuRjkmzoWrEiJs/1cuQ+tchHE3277f6XbTXbb/u90ndbm8yXgqRz2F4ekq6HWb75vDLbZ14T8/lkk0eV9k1qc5J8rySPKj2bTGVe0n5mWdXqattu6w99u/nZVu5EUhIRtWHODW3b9N+2p/zt3dc2V9yRuphwzoYpCUPugiEEhwOGMLZNP0b/r7OzlY7V5L5qS8KcV27T/2/PZ/M84w0zfph5fXYnZd8uhTmAM07sS8jFbNSgniUIgiAIgiAIgiAIgpjgjKqCyPd9XHPNNViwYAFyuRw6Ojrw5S9/GWEYqn0451iyZAna29uRy+Xwrne9Cy+99NKIz2WuGuvbzBVxk1qtC6qt8pladHN/U5tfadXONPuW/20rmbY2ysw9ukuCLSsaEF+pNvfTV4OkGxjjPOYCoa+o21a9t8fs13aMbjmku6glZVEz+zqp7yutACeNDZuFjJ61Tq+Tvl3ua7qKmCvmevtke+VnPSuTDBRuro5Vyihlc5G0jVeb5YZZps06yHaM3n/VVptsq/6VPifda/r5bfJhrBkL+VjpGsr9zOPkf5vFkKqncbzpBqvvYyvb3Cb3N61A9HGmt8VmNWQ7n36vSitFeQ+Z8tGUcTbXL91aUt6Xsny9TN11TJeTsoydhe56JmWFLrdt95W+TcomXc7o7dL3S5KNSbJEl5GmfDSfF3q50o3ZvKb6eXSX6kowzq1u3knyQW+vrKfev2bfJY1P23i0je1K++p1Nfs1aXuSFYFZZ7091Z4Du4pdKR8nOkmuM7b5oz431Pcxt9mOl5jH2D7vDGR5Nushs64S03pkmHsRHPU55G60Ldoe/Q+4cM4I4SLgnvrP4Yhj4IBrr19J/T8SzPu32jwr1maLXLfJoe3FfE8x61ntHW00SAr8bvutUhB5/T9B1BOj6mL21a9+Fd/+9rdx9913Y//998dTTz2Ff//3f0drays++clPAgBuvPFG3Hzzzbjrrruw11574brrrsPxxx+PV199Fc3NzTWfSwoz28PAnLSZE7ukF1ubwsnEZpppnqeW/eWk2Xyxsm2zla1nLTNdtraHJBPhpBebJDeInYH5ILe1z/aiAyS7OOjub5UeTLIPbOWZriW6u4ruXmPGg5IvPbbrZ8PMWreiqwud0bgw3e06qmxX44nFFX0mujtH0kuGifkSox9nu5eSro1tm/k5qUybwiNJMVFt22izK+UjMPxFT5cZlfq6luuUpKhJeulOemm1KZ5s5zI/m3LdHCM2d9UdkY+6i5neirGIgWHKRds9nfS8q6ScS3INtt1/UlGWdG/KenatWAFoZcu4fJwx1Y+mS7VNTuky1XQZM8+rP0Nl3eR1M11kzFh8+gKJjvm7PEclRY5tu16nSjLNPM4mD83y5Gebwst2Ptu8ZCzZ1fJxZ2BeC5s8GiuFm4nuTrNn5wIAwPKulerzzsDmfqYzWopyk1rKlsofhjBS4ghFjYMQnAMcDGGk1GGxtXXxmYOBgYNH0kv+T9omvsvyQphIJZHu+iS32xQSuhy2jbEddbOr9B5kxh+tFdt7kH6u8YYtU+GEVA4xBoyXazRe6lGHjKoF0d/+9jecfvrpOPnkkzF//ny8973vxQknnICnnnoKgFj9ueWWW3D11VfjzDPPxKJFi3D33XdjcHAQ991332hWjSAIYkwh+UgQBGGH5CNBEARBjA2jqiB6xzvegd///vd47bXXAADPP/88Hn/8cfzLv/wLAGDlypXYsGEDTjjhBHVMJpPB0Ucfjb/+9a/WMguFAnp7e2N/Onqw52omkrYVPnOFrdIqetIKoXm8WZekVTpd8y//6+2x/Tc/74gljzyXNMGXq7JjsSpeDWklI//r10R3x7KtxOor17priH6dTZcH01VErkJLzFVu2zjSt5vnkEHA9cxw0tVD1lWWJ/eX7iP6eNKtmOT59HOOZHVHHi/bJsvUz5lkEVTrarTZN0nXwOaaI8+bVOdazmu7LruKsZCPOnKsVZIplfrHtNgZyeq4eS7bd5vsBeKrwUnWRvp/04plezGD+OvyYzyiyxO5umy6nproMjLJHVmWxRmL3ZP6d5sbq2k1mWSZqZdlq6v+TJTyUa+fadlquqfplhxmNk+9Dbq809FloT4Wkiyn9PbZngemNY/eB2b/6PeGLYC6fqx57qTvSVSbr4w2oyEfgZHJyEpI2aT/mdvld/O/bQ65q5GWD45mvbIzrId0udPZ0RFzVxsvyPoBwmpKWg8Bwi1MWguFcFDiKRR4Bj73hv0F3EXAXYSRe5k8Zq/Ouer/ws552KtzLhg49uqcq7YxhOpPIs4ddz+TLmkhd4d/NtzSpAwblpErsto0sbm22Y5Nel6b7sFyWxJjOd8iCGJkjKqL2Wc/+1n09PRgn332geu6CIIA119/Pc455xwAwIYNGwAA06dPjx03ffp0rFq1ylrmDTfcgGuvvbbieW0vr/K7aWZpmqfbXniSzLJlmaYyqVZspshmPfWJhKlQ0NsAxN3LRoI6jyb0k9wLxhJb9jLzgWNeX3MsyAdlp2ES22nptyS3Bh3dpFd3jbBN3E23AN09xfaia2ZY0seAqRjTX4T0Fxu5j3Tt0OstFVFmW23b9LpWU0KZ7TeVq0kvL+YxulJMtkNOSEyXkaQybb/L9usK2Y4FO8+svlbGQj5Wc2+RL55JY8sk6QXXJgsrvQibyOuj/y6P1+9vva6VzNx3RJ4luaGOR8WQfm92GtfRlJ9JSjjTXcsWP0T/r283r4X8bC50mGPBtt1039X3M8uWn23PwKTnsu5SBpTHktkGmzy0tV9HvqglLVLobbApZvXfbb/pz48kWSvnEXqdKp27krJpLBQZoyEfgdrmkLWyI32zq/rUtuBiysftnTsCmsJWc1XTx93OdFnbEWpxr9JdwTiYUP5wBwEchNyBw2SGMgcuCwAAAXfhsgAHLZwWK2ufztmxczMwLO9aaZxPKqUc5YomXdVCeMoVTUfuJ/7HXdQqZd0ys6fpsXRsx5qubcP6SnsWm89fYPj80Xb8WCpIiR2AORg32cPGSz3qkFHt2R//+Mf44Q9/iPvuuw/PPPMM7r77btx00024++67Y/sxY1LCOR+2TXLVVVehp6dH/a1Zs2bU6k8QBDFakHwkCIKwMxryESAZSRAEQRDVGFULok9/+tP43Oc+h7PPPhsAcMABB2DVqlW44YYbcOGFF2LGjBkAxErQzJkz1XGbNm0atiokyWQyyGQyw7Z3LFiAlpaWmDk9MNyM3VxFNa1NdOsdcxXbXF2rtEJYi3m2vnqqr1baVsl1ixFbJhi5mmiu/I8Eva7jzXoIiAeMtlkR6dZDSf1uWs4A5ZUQ/frryLFgBrrVs+uYq9mVVoKTVs/lb5UCDcqVPnP1RVoI6fWwWTTZ6inPpyzHNAsdvd/M/lDnNdppu0/MfkhaPbL9rt9nKuilcb+Y+5l1MetlWkGtWBlf2dsV7Er5CCRbb1ktE4yxofetbZssJ8k6qFYrI916RI5n3bJJnld3E4VmcQcMN3vXrUT0bXLfaph1H4+yUUe3punsHJ7hEEh2UZbH6+3V73ebpYGZGEEFydevZcL5ZT0ryQK5vz4W5Db9mag/AyWm9Zc+Zs2xpI9704pOx7RAtfURjLGd9FnfZt5jutWVKaNt49YWJFu/T+Uvetv0sWKzJhxLRkM+ApVl5EioNNcbC+sI8xlvsxKqRNLvlWSkbj0kGa/y0ZrARmYoi1zExOfIVYxLtzGGIBSWRCErW/qEXFrvcARw8cxrW1W5h+w1BQCwrGsVFnbOi7+PaO5s0mLItFwqB7FmMYshc5s8PzfW+isFvQaGB1a2ZU0baSa1alZpSXNDsiIiiPHJqFoQDQ4OwnHip3BdV6UpXbBgAWbMmIFHHnlE/V4sFvGnP/0JRxxxxGhWjSAIYkwh+UgQBGGH5CNBEMQ4hLHx9UeMCqNqQXTqqafi+uuvx9y5c7H//vvj2Wefxc0334wPfvCDAIRp8OWXX46lS5di4cKFWLhwIZYuXYqGhgace+65IzrXyhUr0NTSYrVssFmZVFr1kZYXleKc6NgsHcwybbETdEztu74KpKcn16089BVOWwydapj+wzuSAnNXIK+L3pdm+nb5i9nf+qpxJXGijwfTykRu6zRW5/WVdtOyyVxl1M9hjkG5v816SN9Hr4OtXLmCbcbQMK3m9PGuH1dppVGPacS4iFtl3nPmKrTNysT8rq94mvWW6BZ9+oq9uQJlW5FKsiQayxWsXSkfJebY060ebP1ixjmxWcLpn21ytVarMiCekty0WtPjaOmyUO5rrljq6dNHEkhTR7935L03HmMPmZgBtQG7FYvNUk/+blrc2c7BGYs9e8y4aqbFmY5pKZZ0XybJQn3MxZ6FlvhVepmmNZhuNalb75jnV30Qnc8Wl8lmgWkrT58D2KwgY3XTgoDr51L9bSlXb4u+r+wbvb36fMLWV50dHXj+ueewqxkL+bgj1Crjdvg8UVwY89rqYyhpbiAxLYyS4ndVwjZfXN61ctzEHKqEaTlkpqIPuYOAu8gHwtJM2uPw0NGCe0PtDw64TgCHhXCjvV/uWgsHDl7pegMuAizsnIeQu+VjULYYUtZIMk6QNpT0+tksimT8IvldtyjiYHAQgMOxWhWF3AVDaP29Wvr2JPlsI2ZdCft8YmdQqbyxtogkiN0NxvnovR319fXhC1/4An7xi19g06ZNaG9vxznnnIMvfvGLSKfTAIS/+LXXXos77rgD27Ztw2GHHYbbbrsNixYtqukcvb29aG1txXPPPovm5mbrS3c1oZE0IRyJyXAldwn9OzByE1x9YmdO+kwzed0NKmniaNbNdoypeBkPgauTFFrmw8b2cmG7Djo2JV6Se0wlVxn9GtsUTPr+SUoL87rYSAraavuedJ131ouu7nKn19+8t2x9WK0OugJAr7tsj35umyJY7weJ7dr19fXhoIMPRk9PD1paWna4T2phV8rHZ597Ds3NzRUndbXIQbndNsGrdI/UiinfasUmG4H4+NHlo81FTsccY/o22/bxIB+B4S5VSQHdk+6JWibRNnliUwLZzpU0bvTfqp3TdOu1YXvOmd+T+kO/nrqSZHsx5Z8Z9N0mG3X5lXRumwuc+dyW5clybK5ket9IzH7p7+2tS/kIDJeRu4pK470a2zOH1MeeqUi33UfVFgxrcUGSSgZT2TlWyCDRuktZiafAwFHgabgIEcCBH3rww7KSRUcpYixuWp4TwmHij4Ej4C4a3KFY0GeHhRgMcsi5eaWIkuXpih79XLpCSO4rlUqAUBJxzuCyACEcuBDKKj1Qts5rXasj5VGoymYIqwamrvR83975pG3xYaT3hW2RsZpL5c5UGPX19eHggw7apfJxLJCycuMvbkdLY26sqwMA6B0YwvR/vazu+34sGFULoubmZtxyyy245ZZbEvdhjGHJkiVYsmTJaFaFIAhiXEHykSAIwg7JR4IgiHGI44i/8cB4qUcdMqoWRLsC2wq5zYpIx1yps6Xttq0yJpWZtMJuSw+dtHJnrqzY3G3MFU5z1bzaiqNZvm3FVK+j2TZz/12NbdVVUmllVn4G7KvV1Va15XdzVdW2Alhtf71sWz1sqUFtwRXNlW0z6LZtv9Fwj7GVOSxgq1Yv0/qgFmuAStj6yGYtJ0mynBgLC6JdgS4fDzrwQKtlRSVLilqt7WxUst4w9zPLMeuUtMJtu+62oMqmO0UlTFcjYLjbUjWrtLFcKTetSmWdkuS6pJqVpE4lyxPbtmr76HW1nV/fZsrIJJcym1WjLdB5pfJ3BjYryKSECrq1T9Lx23N+2zNeP59ZD70+jHP09vfX7Qp5rRZElSwrxhrb2NDHmU1OAnFX3ZFY+SzvWjksbXo1ZN9xzsbMDW1510oE0bo4B4PPPZXGPgjdKLU9U/VUKec1ax3dzSvkIuV9MXBR8B2UAgeTcgVsGchgcmMRnhOiN5/G5FwepdBFa2YA6/ta0ZotYLCUQtoLEIYMPfk0ZjT3I+UESDEfDhPuXqbrm97foWbZpFsivXXvNrVdv662ayWvSS3WmzbZtDNIsvSpVJ+kuURSeIIki6KdZUU04SyI/vvb48uC6PRL677vx4K6URBJFzOguim9bbI7EkFRzS1Bx/ZSLEkyBTfLs22vZiKcFIOpWn8kKUtsyo7xoCSS9bNR6WW0luOTyrH1Q7UXsUomr0n9acvAI8tM6vtKsS7GmtEwMbcpzvQJbyVXE516fcDrLz8tTU0AapMztUwYk46ppEi1KUtrUQQlKaHMMgAkKodsyvZqmC9TlRRmZvbLXX3fJbl6VSJJeV1NAVbp2WS75tWec7Uo0JMWUZLOl4S5IDRe5ONooSsBbAp6wK70lEwUBdEzzz6v5pC6MqMSu0phJDNfLeycF9ue5EZdDduik7496fekum0PZhyl0ea1rtUAgABuOUMZdxBG//WsYCEXWcwY4wg4U9/D6HJzMIQhQyl00V/wUCgxmI8oua+rGTgwBrgOB+dAqBRR4rdMiiPthZiUzSPnFeCxoFwWGBxwBDK2UKSsDEI3OpcDh4U4dO9J6pharp9tbmuiz6N2pqys5gK2vSQpiZIYyX2juwrqMqK/v7du5aMOKYgmFqPqYkYQBEEQBEEQBEEQxO4NZ2xEirXRZLzUox6pGwWRHCT6yqCpHTdXg/Vja3VBqmY5lGShUskc0mbuK4+zZSFJKkfuA9RuBmrTspsrumbdTdP80SYWLFRzEah1tVvfXs2VxrYSbcsEJPdJCvwty5H76dl6zHrJciQ2C4BK409nrINAVmI06maOVT2bnT5GbWN6Ij1Ykix2JEkySj9Wp5oVnyk7zP7WLW6qjW3TIigpeLDNrFz/r+8zEvlojiMdeY8zHs9+ydnwTFejiZRRtiDEla51rc81HVumULl9RVeX+p9keWkeY8ueJT+b59TPy7TfklxsbdS7xZDEDNjKMPwa2LKXJllyTSSkVUytFkKVrGh2hpWRCGAcDNueFJTf9rs5N0xyS5P/a5Vdsft3BNZE22t5tD1I66EQTtxaiHE4HHBYgFCGiI6sQ2QAZ1nXkJcth/zQQSFwkS858ANZlt42wGGIZeF2GEfa49FnAOAo+MLyKAgZ/ABgYNiWz6KUdtHgFRECGCqlkUsVVeBszwkRcIaMW4JmnJRoPaT3s2kZ19nZUfH5ZnuG7ixqScJSLdtz0rEjqW8lz4/YnEVzPZT/GePj1u2UIHaUulEQAdV9VvVJu21ilPSSZCqfKr0c6b/bYhBVQgq1pAezPF81l7KRvJTomWgklVwIVB+OQdYe+RJW7WU2SQEkt9eiJJC/rejqsip2bOe3ZdrSj0vKIqPXIUmpMVEVG9WwTQQq3RsmE+XFRx//5v2tv6TbZJaplAGSlbD6d5tSQt/XFhOjEtXko6RSVh75klwrlRS3usLZ5uZWq4vGzsCmgLMpAmzXrdL1Mn+X8h+IZ4brWrEirsDT6ib7UFfqyb6U8lXvL13mJSmuTOU7M34fDxmTxhp97FaKE2cqaoHh98iCCdCXo/Gyx+EAvJw+3Fa+7rZi1kf/rZa4PTsy5kVcoZEfF5v3jCAuEYeDZV2rhrnNjRZccyUzM5OFxneZgcznDoqBB86BUujCD4RyKORlJVDa4+q7dB2T/eg6HJ7DkfI4/IDBdThcxtX5sinRXwUfyKZCMAb4AUN/MYX+YgoOxL5DJfGqxhiQckO4LITPPGTcEjzHj9VdyVHLdVDKDc1d0ZbZbqxJqkst2ckqKbVqXdiudV5oKo0Iop6oKwURQRAEQRAEQRAEQRA7GcYANk6yh9GC+ajB6iVItcxAkbRyq7ug6Ktn1VYabdlvklbTTe12ktuSzki19rZV4J2Z8STpHJIk14XRXn1IcmeotMIsPwOVLX/k7zZXNfMayvGlu5+ZFhCmNZfNndFWb5u5uM1NcTyt9OxO2FwB5T07ddo0tLa21l2gOykfZbtsAZ9NVx4zy5MpY4DhAZFH4oaW5NKp7ysZ6Vi3Bd013dBs7RnpOarJF5sV42jetzaZXakutmtWS5vM45OegeazUrdM07/bzpMU0Np2HSWmRRxRO3ow96SsqfUqH4Has5hJkuZGtrlnGGWWAqCyXwEAQ4gkdDegEK7KZOUgAIcDhjBmXTSS8W4Lam2bP5rbR0IllzMOx/gurHlCONi3c9Z2na8WXutarc7jcy/qWxbLDKasi7jIZDZQysAPxXf5X+wXL5tHrmdBWP7OGOA5HJ4rrlPKFT/6obAuKvmizJLP0JwLwBiQ9QIwxhGGLNrXUWPBZRyOI37LeD5STgCXcaTcEtKsBAaO/fZsV3Va3rXS2g+2QOcTFdNqqlKWMxkk3gYHw0BfNw45+MC6lI86UlZuePA7aGlsGOvqAAB6BwYx49QP133fjwV1oyDq6enBls2bh/2uTxhHkurYhqlMMn389UlxJd9wWwyf7VEUAfYXD5sLwPaQNIE3J+a7QjlkU5To35NeiJJM5mt5mdLbVks/JmXp0c+X5F5me1kzlWD04jM6rOjqqvs09z09Pdi8ZYv1ZR3YOS/WtnvEVNgkKVXNcW4q4Udat0qyfkfLNssBhitP9JfF0b5vK8kdSSVFeSWXXfN3m5KoVvmv94ct9bvtxbuSMtF8jpLifPQwFc31xPYoiBg4FnTuOaLzLOtapT7Ll3T5Ip/keqa7lcnjbcqlkaaNr6QIqhTHaHvOoSuJ9Jds6ea1V+fc7Sp/JLzatQYhHOTDjOZmFbmccdGj8rPPHZQCF4NFTymDnKgJIRduYzoyPpH4LP67DuA5wmXs/2fv3YMsuav78M+3+96ZfeiFEFo9kMTO7OqFhFEEJggMyDyMwY5tEpMEnESJ7TIlwCGOTUXlVCy7ylKZBEIZx5RxEoKLgP2LbRLKGCzZINkgMJKQ0K5W+5g7Qlo9FqHX6rU7M7f7+/uj+/Q9fe453+47O487d76fqVtzb/f3/er+nu/nnPPjV3Txf2/P8NOvThHC1/YcQ5LUPWSlpRe1jsuRuEIwuCVdROZTdF2/tE1VfFKXVd8TZJXwUBt3ETo0IZF8rsz17h8StN393e9uKi9mR/7iv4+XgOgnfmHi2349MCYcsYiIiIiIiIiIiIiIiIiIiIiI9cLEMYi0E1JukHo1TnNPhKXD2UZt0tFO30PlAuwT9DaMmJDKFWG1GC6aSpD2m5chxDTiddDir7QKl6Tpa6oUo/RnxOphUk/IqV5333UXThL1kipY1npxojgRg8FS7aXtutcmnOUNjbNZ2nhakdAYiU1pLQfSu2JoDWyrcmuxLuXzdCWgqQPyvMbReOpmxaSuj8BoDKLVmMsr9W7adp1tu75ZLKO27HdN1YwYRMR76fsOXsi2Fr+cx5UXnt5Y/rbYN/cIAGDRd5H5VDCZBmpcpFrWz5Pyt0M/c3hhqc74SVxhvDpNhr2BAcW1TuIr5lA/d3j7K6eWXf7b7nsWicvRcQVjLE2ySp0scTmSkklGaovF93xktcOIE8ckr48ckUG0uTBRAiI+OEJ2XzbL4hnydjbKi47meYuw0i/v3B4CQVPLalJH4LDCymuE1RB0abZQ4sZnfDCpD/im9dGy8bJRMcq8CtlXAtq3hyUI5r9Xqm01u2uWGlZI+KNdD6kSk1rYaowRbSMavZCNFyZ1fQR0O20EbnuENt8b+UBnOe7rm1TQ2rwPcnWzQgEqRd93sJh3kfuk5qL9RLBv7hEmfEqR+RS5T3Cs38WWdKCSRQKixazw09P3CRb7aSkkcshyh1yojtFy2Ek8EgckpapZUgpoprsZukkGAHjDy7evSH0A4PYDT6ObLGFLsoCuW8TszEylmjiqamHE6mCS10cOquejX/ofYyUgOvudPz/xbb8eiCpmEREREREREREREREREREREZscE+vmnqslbOQTnxPBStVZMyZLp0Yr4RWoli5sxpL8T/coXNMJOUGyyYh1sFqn1lo/bMbxGDE+kF73nPcTwdoYZV6FwoaMNlvpaN4zV2JtlCf5kuGjMYZGNUptsY6IOaR5v1spaO2z0cdhxMYFH3uHeg8gR6GClAKAz4EN7FV5lHnVJqz3A89sofWUG6bPkeC5/nYcz6YKw8qKge5RsG/uESQuR993sOSnqnI9u7S1YCx5YGt3sTLynLi8ZDIVxqCX8rRSL8u8q+I4eHQSqudALQ0o1MkSFJ7FSPUsQaFedtUlzYbOR8GrLzqt9nu+18Ou+P4YERGxyphYARGB1JUmYfNzopjv9eAwvLEYBZp9jRPZOFhukKVqRsgzXMjWhlZ2Xm9StZnv9TAbH7oRmxCrqT60kaC5gB4F3KvWStnR4WXqzc/X1m++Rlp5hDycha4572ve5KJAO2IzgjwV3dd7eNN7gNIE4IQ26wNXjer7QiDzQtY9oTLdsvcYMn86HntmGmni0c8cOqkvbABlDlu6OX7mh1N8fV+Of3hpXe3rm/c9g6U8xbGlTiUUAgrhT7dTVyvLc4es1DdLXHGdhENpUtgCOmlqYUiYsxqIa3HEusMlxWccMC7lmEDElo2IiIiIiIiIiIiIiIiIiIjY5JgYBtH98/OVlx7pkWaWqZttZuk7nWaPYjhVGrWmE2zO2BmVecDVFRy/BpjpWmoIvD6aGoXFlpIsqOUwBiIiNgrm778fp5x0kmosncb+Zl8fOVtxFFakxjzibeqdG8nDEC8LT5f/5yrUgH2qLNc1Td1WXid1XSrzfK+36cdGxOTj0PxD2H7yKbh49qXVtT1z3wcAOKQ41HtgU7OIuJoYoY2R5Pt6DyNFBg+HBAkyn6Kfd7CYpcg90E1z3PzdBbz1h6ZbleOm7y7iiee6eO6YwwvHtiDLC1ZPp+PQSR2cc0gSYLoLeF+cgb/+0mGj0a+95BT88W0eifPopMBUp1QmLL2Uee+QloaoM+eQJK5iFSXwSF2hYtZJcjj4NWEPRURERKwVJkZApLkq5u6byb7NZoGlGkC2doB27kqlC2xpE8g7N5J77PleD3CuVg5Ki8DVJkLpcttBmvcgC7JdonpNxKRjZudOPP6DH8B5PzTvN6OANKQ6RWvHKB4fNU9iy/GcSZswzVsZTzNUfsv7kOadTPvO69ubnwdW0AtbRMS44pjfgiTfgrsOPV65L09cUggNSjs5c737K09mwOSq+/Tm55H5Di6cPb92nQvRgaI9cqSVZzAZHgAumT0X+3sPIfMpFvIpvNDfgmeOT6GTFipa3jtMdTL8zZ7jePPlW4Ll+vJdS3jiuS6eeBo4vlC4k+90HLZMO6Qp0Ck90zuHIv0E+NO/z/FPXjNQlvjs33ks9R1cmXeaOHQ7Hp3EIUl8aacIgCuERwDgEg9XjQkgcR7dNKvsLyWb6/EZIdCbf3C9i7C2cG6gf7neGJdyTCCiillERERERERERERERERERETEJsfEMIhmdu6sMUm4gU1gc3lF4caoJSXY+YEvBunJy1IjIPUvbkiawJk+TWoIFnNBM1JN5ZNexmpsB3biLT0JaZ56rDGwmcZGxOYEqeBqcw7YXHOAryOcbWOxJNs4OpDsG6nG1ZZlqam3ceZQyAh/FZept0GEl+xMzeA1f2ZspnERsbnx/NJWTGVdbEkX4ErVoim3iASFEWKHvOZxa1LZQ4d6D8Ch8E5GjCmOgl01eAdMXb/0ZmYj98nAG5zLkCQeWe7KtB3y3GE6zYLl+vw3PLzv4PtPAD73FXNoegqlipiHeDVE4jy8B/7Pt4o+zHKHTlpcz33pha2sXz93ABJ0kCNJPdIkR1rGz51DQmwhFPlMJX289pJT2jZrxARjdmaYORcxnrjxxhvx53/+59i/fz+2bt2Kq666Cr/zO7+Diy66qApzzTXX4DOf+Uwt3mte8xp861vfqn4vLCzgV3/1V/H5z38ex44dw5vf/Gb8/u//Pl760pdiUrDqDKKHH34YP/dzP4cXv/jF2LZtG175ylfizjvvrO5773H99dfjnHPOwdatW/GmN70J995778j5zN9/f014wDcBm0l9QvM0IVXCfKniNTszU20ApIBFCnMI3MsYbXy43Q0rHt0HBpsOvhHj8ags5LlHpivzJ8z3ejVX0NpmKlS+iM2JkHeW1cZarY/AsOoTnwvr2QZrCWmzjKuT0dqo2fqZmZ2t1iMSFhHI45elqjfKM0h7ZkmbcVIgTsJ9mQ791+wMzczOVr9nZ2aGnptRMBQBsPF1//3rkv9aro/PHp/Ck8e34tmlbTjW34Jj/S14PtuG5/NtWCzdpwPF+8skC4cAwCOBKwVjEs750ql7gl2zOzE7M4Ndszuxa3YnDvYexMHegzjQO1yFJztOCXJ0XR/dJKtUshIH5B5YyFIsZClu+u6iWbYsBxaWHLLMI8sLIdBUF5jqANNdjy1THtunc2yfzrGlm2O6k6OTAmkCdBKPNCmESFMdj6mux3TXF6plKSpbQ855vOMfdDHdoXLmlc2hBB7dJINzwJsu2xqFQxHYM/d93HXocdx+8Oh6F2VtkSTj9RkBt956K97//vfjW9/6Fm6++Wb0+3287W1vw/PPP18L9/a3vx2PPvpo9fnLv/zL2v0PfehD+MIXvoA//uM/xte//nU899xz+Imf+AlkWVjQvZGwqgKip556Cq973evQ7Xbx5S9/Gfv27cNHP/pRnHbaaVWYj3zkI/jYxz6G3/u938Ptt9+Os846C29961vx7LPPrmbRIiIiItYVcX2MiIiI0BHXx4iIiIiIlcRXvvIVXHPNNXj5y1+OH/qhH8KnP/1pPPjgg7WDBwCYnp7GWWedVX1OP/306t7Ro0fxP/7H/8BHP/pRvOUtb8EVV1yBz372s9izZw/++q//eq2rtGpYVRWz3/md38F5552HT3/609W1l73sZdV37z0+/vGP49d//dfxrne9CwDwmc98Bjt27MDnPvc5/NIv/VLrvDTDoFwtadK9sNAJslQfo++SRaSpS9RYRMwQKqmrcZUF3rYyPw38xJ2rksk+o1P64sew0VdZJyqHZnCbG3KVbIl4Qj45CBns1SBViRwKFay1xlqujxzaXCLVokmeF02Gnzm0a9xzGGdPOgzUcClNSkN6BqM4sp2lyhfF5+Dqs1pdZDypam2p4nK27WY0WD7poHk9yvzm7xOauvZaYK3XR+eAPHd4fmkK050+AGDKO3SSHLlLkKYZUj85p8MSc737oZ0ZczWsJlw4ez7mevfDI6lYRFMOyJEAHkhcjjTJChWvkj2U58V6s4QE02mGv75nAW95Rd2j2X/7MpAmDi8c9+j3Paa6DmkCbJ0umEDTHY9umiNNBqpjmXfw3lcGx1EaG/feFfmW9SKtXDI4/eW7ltBJ0sI7mStYRd1kwKZKnM6siti4uK/3MIDCoHob3H7gaSxkXeT+JHg4PLe49utjRB3PPPNM7ff09DSmp5s9Ix49WrC/uAAIAG655RaceeaZOO200/DGN74Rv/3bv40zzzwTAHDnnXdiaWkJb3vb26rw55xzDi677DLcdttt+LEf+7ETrc5YYFUZRF/84hfxqle9Cj/7sz+LM888E1dccQX+8A//sLp///3348iRI7VGnp6exhvf+EbcdtttapoLCwt45plnah+CpOJLew7LVaPQ1ArGDbQB0TY6mv2K0AufJjiSG0rL1o9m94jS5OWQtjo0QVOTK3raKGneerTNVFQvmzxQP0uveAAq1Zve/HztA6zfpodjrddHguaOfVTX7hK8nccRXCgt1z/temh8aJ4hOaRQSF4Hhp8pXK1Wrtm0/soyynCyvFwFl7uu532tPQvWe15ErBy4MFOCz1e6L+fweq6Tq7E+AvYa2UlzdNNi87/Q72Cxn+L5pWk8vzSN49kUjuVbsHv2Auybe2Skenxr/1F8875ncPuBp/GNfc+NFHetoK3bnm0PvHfVByjsMSVOF5btmt2JFH0kyJGij45bQgf9SrDi4JG6vPJglpeide8dlvLCDdnX9hzD1/c9j7+9t1D7OIV5qZ/qOmzflmDbVleoiaUeU50M3TRHNyn/pzk6pQ2hJBl8AFReyhyK/2kCpM5XXs36uUM/TwrVMlekmZafxOXoJP0TbO2IccG+uUewd+4IlvIujufTuOvQ49W9uw49jq/tOYav7TmGW/Yewzf2PVd9jvW7yMtl0aHwaLeZwPeb4/ABgPPOOw+nnnpq9bnxxhub6+E9fuVXfgWvf/3rcdlll1XXf/zHfxz/+3//b3z1q1/FRz/6Udx+++340R/9USwsLAAAjhw5gqmpKbzoRS+qpbdjxw4cOXJkBVt6fbGqAqL5+Xl88pOfxO7du/FXf/VXeN/73odf/uVfxh/90R8BQNWQO3bsqMULNfKNN95YGwTnnXfealYhIiIiYlUQ18eIiIgIHauxPgJxjYyIiIiYNBw+fBhHjx6tPtddd11jnA984AO455578PnPf752/Z/+03+Kd77znbjsssvwkz/5k/jyl7+MgwcP4ktf+lIwPe893AQxsFdVxSzPc7zqVa/CDTfcAAC44oorcO+99+KTn/wk/uW//JdVONmgoUa+7rrr8Cu/8ivV72eeeaZ6wHP6PLFKuPcYOrFtq47CvcLQSZpG7R83tQyufmWpIjSpEWgsImngVapu8Xuq+pnCNpLx5Imldnop1edIvUPrl978fE01RKtbxHhC85hnQapPyDHB1REJcvytNdZyfaT6cXZllT6r/yiquJqqKF0H6uvQeoP6npczxI5oU24+nsgzGPcQRpBsLUqfs7eKi8PjsfIqJsqtlZfXSVMrtv7L+BEbA5ZqIF8H+TjQ1k/OLuLeT4Hh5+xaYzXWR8BeI7tphk6SI/MJaFnwHljMUixlCbx3+Nb+o0jdNnxr/1F47xoNFd958El0k4JlUKgqLeHuQ8eQ+RS5T9DPk7ExduycB3zB8iH2EP0ng9UeRdt4OKSwmTRybQQKA9iFJ7P6tsN7IINDqeGFDA5953C830HmHf7v7Rn6WcEsmuoC6XSCLdMl8ycBOqkvjFCXBqVT+OLPJUACOI+qP+GAHIVqWcEYQsUESROP1Hl0Uo/pTh8dV3itI9Uzjm/vP4ofvvjUEVs4Yi2xb+4RFL1XrmcoGHCv2H1mFYY86+Vw2JYcw0WzxV5yz9z38eziSUiTgokmx0AilpdusrkYROOIU045Baec0n4t/eAHP4gvfvGL+Nu//dtGz2Nnn302LrjgAhw6dAgAcNZZZ2FxcRFPPfVUjUX02GOP4aqrrlpeBcYQqyogOvvss3HppZfWrl1yySX4sz/7MwBFIwPFSdDZZ59dhXnssceGToUIIb1CvumpHk6lEEO+tGs2HzRVJf7ypalG1fJaR8EDbUy0jZollBnV5ogUEnG7GwS+ESd1P2sjqZVZbtZDGx/+nQuBrI2dVD/kZRiHTWzEAFw4VBtvylgOuR7nc1dugNZblWat10euZkkzzJp3fPNJsDaYPH3tXlsX76sNKTQPCaubbLZQXfj9yu4Z6u0ZEkJZAhu6T2OWymipg3E1OUpDHhBomzau4iY9QvL+mnT7VBsNlrdSLugFBvNczj1uT1A+U6001xqrsT4C9hrZcTnSJAfywq35wPZO4cGq7xNkmUPqCm9WadrH3Yd+UAgm4HHZrrOG0uT2alyZTvGjUFdKncM39j2H41kHb758S+u2WWnw9aBwWV8XFEkkyKrw1rogr++evQBzvfvhnMdUugWZT5A7IC2FNkkpRAMGNoT6WaHy1e14pIkDjehO6pEkKOwOOV8JfAa2klzpfQzI4at4zrE+QGH/iFTcptIcU2mGLZ1F/MNS+POt/UfLNMDiF7jz4JOFCprrI3UZuljErtmdDS0dsRa4d+5RlGJZ5L7osbz8fufBJ6twDl0453HF7jNq8Z9Z3I6kVDFMXF6bBZo9rnSz2aVySfEZB4xYDu89PvjBD+ILX/gCbrnlFuzc2Txnn3jiCRw+fLh6zlx55ZXodru4+eab8e53vxsA8Oijj2Lv3r34yEc+MnodxhSr2sOve93rcODAgdq1gwcP4oILLgAA7Ny5E2eddRZuvvnm6v7i4iJuvfXWiZLCRUREREjE9TEiIiJCR1wfIyIiIiJWEu9///vx2c9+Fp/73Odw8skn48iRIzhy5AiOHTsGAHjuuefwq7/6q/jmN7+J733ve7jlllvwkz/5kzjjjDPwMz/zMwCAU089FT//8z+Pf//v/z3+5m/+BnfddRd+7ud+Dpdffjne8pa3rGf1VhSryiD6d//u3+Gqq67CDTfcgHe/+9349re/jU996lP41Kc+BaCgBn/oQx/CDTfcgN27d2P37t244YYbsG3bNrznPe8ZKS+LMh/yXMNRUflRZ7ZY+fDv46RGoUFjSy23vLzO/DdPnzM9SD2CIE8krfbU8qT4/CRcqv7NKgZjK9UydkpO4Xrz80NxItYP1K+chaEZoCaEWA2SHRMau+uBtVwfgWG2j6XaydkFnKHH1XM1r10WlqO+thqgvKUnL8JKGGvmXsMIFvuR8tAYk1oYrXyaGhBdlwxSzkbi5ZUMW6mSOzM7G9lDY4JqfVTUsGvPX/Y71HdNz2KZ11pirdfHNMnQTTIkDujnCTx8xS4hhouHQzfpF2FdoWLlvcPlu3fg9gNPI3UZnPNIS85JWsYFUGOuVIwDByTdHNu6DnccOIZXXVQ3errWGFbTzirD1AO1M4ek9AY2KmNm1+xOHOgdRjfJsOhS5C6FdwV7i6vtZEwtLHUeUx2U3snKa0nBIOKsIe9RlKtSIfMobg28sJFxahr23vnS21nh2SxxORazwbboH158Ku48+CRSVgdSN3LOY9ot4tJd50SG5Rjh3rlH4eAr9TGgmIOePf0qz3YO1TzmSEuVMTLM7ko1M/KCJ9HWy1/E+uOTn/wkAOBNb3pT7fqnP/1pXHPNNUjTFHv27MEf/dEf4emnn8bZZ5+Nq6++Gn/yJ3+Ck08+uQr/X//rf0Wn08G73/1uHDt2DG9+85vxv/7X/0KappgUrKqA6NWvfjW+8IUv4LrrrsNv/dZvYefOnfj4xz+O9773vVWYD3/4wzh27BiuvfZaPPXUU3jNa16Dm266qdYRbaG94EjVI7kp4Iu69rJM4C/j2oZoHNTMmqCpkYxaXi5II4Q2iFa7cTUzzWtKSKjHN7AyL1kn3ud8DND3ce6vzQauAtbU301CB2tTTXGlIHI9NkFruT42CSwIUvgKDK9pUlWP0rfmLBfQjRNC9oLk91HQxraPNS6t+1o6lsBJlkErVyhfLqSNGB/M93qYVWxpcWgq2Rq4wJfHtYSSk74+AuWhhCvWq8Tlhb2aPK02hP08Qeo8lvJU9WSVGl69EmG/hDaTJGjouAx9nyJNMtx16PEhdZf1QiXsLjfFDnmpJOeQ+xQeDgd7D+LC2fNbpznXux8pCkHMyVPHsZB1cazfBYDKttFiVgiistwh9w5ZXrikBwrBEB/SpCK2hASdhEpXtmuSY8mn6DiPfu4qAZRURUvh4UvBkbQtAwBXXnh6zbsVt0dDQof4Hrn+uK/3cDlX68IgAgmNgLpAJ0V93t516HFMp8BC1q3FreYtU4MczI3NJSDyLilsfI0BRi2Hb3iWbd26FX/1V3/VmM6WLVvwiU98Ap/4xCdGyn8jYVUFRADwEz/xE/iJn/gJ875zDtdffz2uv/761S5KRERExFghro8REREROuL6GBERERERsfYYDxHgCoCfnPGTL2KLkJFbkvTPzM6qhjkJ1umsZB7Ik9ve/LypDrNeoLpynAgldnZmBrMzM2p7yH7QDLVyFQgyeq2F4Wk3qX/MzM5WxmUlC4zXkzwN0XeNLRaxPpBjVP6enZkZYjto7CE+/2jsSwO+fHyOG7NlNaCxezikWhLNcT6fJBPImqP8umzfcZtzND5o/QCYcehlsib4eCNozw35rJLQxiVvWy19jYXEw/E+5desso6D6nTEAHJtI2jMN2ts8XcUPvY1tcfNsj4CKI1Ge6RJ4c2sk+SYTjNs6fSLT9rHVNpH4nL8gwtfXKkx5XC469DjlUHbFMwwdWVAefABmJpSyXjpun712Tt3ZF3qr4HWC1Ilc6WyDjExRmEPAYWK2a7ZnTip8zxO6jyPLZ1FnDJ1HN00g3OFGlmeO+S5w2LfoZ8NVMeSyhB16cHMeSSCUURIXHE/dTlSob5WqZvBo5Pk6JbGqbd2+3j9pdvx+ku31wwZAwXLq+OyWj91SkPjEeOBDoq5SXNKqpdVv32CLC+8COY+waW7zqmlc6w/jWP96cpL4WsvOaXyZqcxhfi8joiYJKw6g2itYG2A5Esy0aq5XZ7K3pBBqbZe4DVB0ThDo5WvBDTVPnlNe1mVG01LFU2zi0D3qF6ArgrD73FVMx4vYnzA+4RUy7idKRhjCcCQqmKVBjC0+bHG1GaCpoJCawS3ddJkI0det/IIqbyMA1ZSTWBoHCOs2gcMC9etONZ6y9Oge/Rf1k0TxvJ1cb3tRUUMI3SgRZBjyxIyErR5HhpTkwznStUyJEhdYXsnZwKAbpLhygtPxx0HnipVjgpbEw6FzSHLJbqaFxMQ8Wt8I7tv7pGhzet6goREc7374ZFg9+wFy07r4tnCrfTeuSM47qexNV0q1YMS9JOiTXKfgA8951B6OivbPEHl+ayT1NV+eBygEDARSOXPOfJSVVx//aXbqzBd16+1/+W7dmDf3CO1tL136PvO2PXTZgWNx7ne/QCARV94KuxjoCaa5WlhcwoO8Biar7fe+wK2psWczwF8e/9RAEDi3LBwl4+zVarT2IIkteOAcSnHBGJiGEQREREREREREREREREREREREcvDxAiIQupJQJ3FIlVLtFO30Em3Rr/W8iT1tnECqems5Ek+T1M77SaEVHqk4WCpohIyrirbmcJrKkpRdWLjgPpIY7FoY0IbP9o9ic2gRiEZAVbbEMNQMlQslp+l+qmxATmIpTRu6rirBcvgr2xHi5WlMYY0Q8RSdY0+8jmktTtfE+P6OJ7gKpFSNQxoZvsQW1qOEYqrqSpuhvURKFgmhaHiHKnL0En66CYZOi5Hp1RduevQ4+gk/Yo1lIJUmPIhtTGOgZKL+CiqZwly7Jt7BACq/+OEXbM7kWHlPPWQmtaWziJSl2N7dwmdJEc/A5b6Dkt9h4Ulh+OLDgtLCabSgj1E6mHdNK9UybwvVYhKr2QEx9XNElJN85VXsylhdDyHG6rjpbvOQYqsxiC5fNeOyB4aM5Aa46W7zilUQD0ZVk+QA5VqWT9PkPkU37zvmSrudLoEANAUB4nZR/OVVErps5ngURipHovP5Igxxg4T27L0ghuiWDe5yJYv4zy90IuYthEYJ5Be+YmC23HSbJHQ95DNDEvtxNrM8nv0XUvDqp9mjyliPKHZgWlS/ZTjgW+GLDXUzQC5ltHmUgomNMFQSEjL05ff5QZUm9PjukauFGhD3rSGaRv2UP9YKmraWsvtKxFC62PExoHs79B7CgkJQwdoPF3t+2aAg8c/uPDFhZ0h1DeCaek8O4FvtD1iqZtpKir027JZNG7oYGnF0qLNtvcO3TSvvMX50oNZPwPyvPjQUOwkeRmXqZ2Vw9f70j05U/yRYYCB0C5xudrOWv9dOHs+PAqvVZfMnrtibRCx8tjfe6hQ2/SuEhKRqhkXHr72klMAALfd9yxyX2yJ+cZ4XOdgRMRqY2IFRBERERERERERERERERERERER7TAxRqoJdNolT245q4AMsc73ekPGxTQ1KUulRQNXe5pU41nc6OrszEzVnm1hnX6HDK3KE02ep2X0NWJjQxpl1Rgo0ui6Nt8tFTX+e9LHj2RE0toXYu/xuPy6ZiRZy4unZzFoqCyTxFzhY5bqxY0By/9ynGrqfCEWFsF6PpFxd61cERsbIXVtQjX2GsLJ65ra42aAc740Qj0wblwxhhpYQdZvea2JecTZL+NoBJkMVi8XN393AVOdDKdPD9R2ptI+nlnoopPkWMpTbJnK8dyxBFmpveMckOUF+2MxSzDdKQ2DuyK+9w5ZyQDpuLxKl+ICpQpfqVZWeaYqw5BB4oLRlOKVu19SK/PeuSNIkOPSXZE5tBFAhtBvP/B0YZjaOyzlhdpg7pNS/czjG/ueQ+YdptK6mlgCPn7qY2XTQ9Lx1hPjUo4JxMQJiJrUSGhDQt6QCE02SiyhhnWNxzkRl/LjhEoI5FzNVfzM7GzNS1ioHfl3S12iSSWD8nXsnuxLKbAioVLExoCcM5bQcNSxZqW3WTZBmtBBa1v5W24YZZtq6ima6mdo3m90aOtjZdMJthqPtUmn/9aBBU/HUn3WhKRSeEC/4/q4cUDroxwbIbVEeV8TTmrxNxOkECglQYPh4roWV1MdE1Hqno/KdmbCINW7mfO4r/fwhldp+srdiwAK9a8fv2K6vLoNdxx4CkBpJ4ipjm2dSpAmwMJSoWqW50U7LfYdpjpinfMDQVMi2pAEQnRftm3hjcyhm2SDNFyOew49VtmWcfC4bNfZK9oeEauDb+8/iqcXtuJtPzQFAFjIupXQlXvGK8aMg098JVAkSI9lBO4lr7JJ1NJzYUTERkNUMYuIiIiIiIiIiIiIiIiIiIjY5Jg4BhGh6XTaOv3WmAdNJ+U8rJaW835Dq1GQasJsqdbFmR2WCkUbY94ynFSD4bDaljA7M1OpFYKdgm7UNo8owPuZWGo0FkgFTVPRod9aOk0qjJMKq96SDRRSO7HChlgwGstBprmR10dt7aN1kjOJLIRYQqG+4LAYJBobhMpH8TZqu29maHNQzqvQ2Aute/LeZlHh5iyhhLNMWjAELPUTYqgQOANh1LJtZNz03UVMpxmO94stxzfve6YyDvyqi16Euw49jtwnmEoH3sS6SYZnFqaxtQs8ezzFYn/AFErY65/3Ay2TRGNxAZVhae9dXdeyDEberjQ1wst2nXWi1Y9YQzz2wvaKbXbv3KPI/KlVlzvnKzXEN1++BQBw670vANDZEhW7zwMomWicrVYLs5ngHODGhF+yCZmua4Ux6eETRxMdmujT/EPXQ/YdLIGRVLcgyBc3Tt3eqC6deR019S0NWvtZG0uN3s7DWap8/NObn6/yIrtIm5Eiv9FBrs/l+KB7BBK6SiFuaGNNCM3ZzYqQeoncKFoqeXKdsDauMk36L12xb2RIlWJSBwJQ27xz8LZtIyC3nmkSmlAvCtA3Jsh2Ygg0VvhaaqmVAcNz3Zq7mxHcG5a1EaxUxUo7J/Sha1qalB4JLujja79cTY3lQO/witdvrUC2nLZ0+ugkeSUcIlyx+ww4eEynSzipcwwndY5hKu3j5OlFnDy9iC1dj06KyuYQMPBWVsundGEPDNo394Xdosy7yhZN9cGgn6oNf5lmhiQKhzYgOkmOLd1CXfDZ/jYAhc2hLC9c2xNu2XsMt+w9VnmyI+RQxkqpniY/fC5HREwaJkZAFBERERERERERERERERERERGxPEyciplko2gnXyHqtDxplafioXQt2nYbVsO4o1LvKX9zVR+CpRoG1NlXsg0tlhCHTNc6YSdmCVCoxEVsLPA5x9XH+H2g7uHMMsbKr2ksQX46Pukn5BYTQK5LTcwVfl2Lr4Wz1J5kvlw1ayOB1Fs5NLUz2YpyTaTwVptq7A+ZFn3XwshnI5U7sog2HixmM/3mKtehZ7JMQ/4PqZBOMvJytpLKUqWiJGYxV0eSRms19tByIFlEF82etyLpriW2dRexmBXbjW6a48t3LQEoGEFbu32c3D0GAEiRV+3XTZaq+J1kCmlSGBWmYevcgFEUUtujvuO/AdRYI6QKmJaGqgl3H/oBuq6Pl0cD1RsGXeaNrJ93kOeuGFViPnoUbLNEjJ9aOMYqc64+/xPkw+E3CcbpnXlcyjGJmBgBkUaj1jYmTRslTXgh47QdkE3Ck40C2rBxz2XAYJNOLuc14VlbtQceVtvUy82ktpGS6fFyRow/SADpvK/GlJyTXAgo56gmhCQ0/Z70DZC2/li/mwTcmtDHCmsJ0rXN6EYWovM1hguLrPpzdUlrA0/3mtrGEsBpYXg4mm8bUSi32SE9PPJ+54c5bZ/H8j1no87DE0HmE2S+cINdCXncYM7U7BK5YYEDR5PNIG7HhKs5aZgE19pXXXJy7fff7DleCGRcjm6SYTHvIC9tw0wlhR2ivk9wvD+F4/0Ux/tFv0x1PLZ0CiFOmvhan0jwPuCezGQY5zxSZntICpMWfXc5VY5YB9z03UVs62ZwKNzX535YOPSWV0zja3uOFYJF+EL9ME+RqSmSVz2PhKVBNqsG3zfm3i4iIoSoYhYRERERERERERERERERERGxyTExDCIJ7UQ1xB7iYdtQskPqLCF1qo0Mbjy4OgVndZesD7ouoTG8LMg+0/pSY4nxa1GNYvwx3+vVvBEQw4L3KVebaFJLDLEoRmUCThLaqobxMNoca6t6YjGJmtbcjQjuRZHQxHSUbWs9e7T4GstVS7vtMy1ifFGx0tgY4c9fYMDotdS/JTQVM35dG1+TDO8LQ7SkSuacB/deJMMCxT1CSN0slGfttxFPqkltRPz1PQtIS7WuBACcx1SaIXE5EhQqX32f4Mnj2wEAzy+kWOgnyPNimKeJR6c0QF2oBtXVyyzGkMXAIvaQ6r2KVIpGYIbsm3ukiAsXVdLWGF/4dsH/2T5d/K5UBp3HElB5uktdjr/ZcxxJeS3zSbmE5rX0EqPbKV3uDY8bpd80cAnGx4vZmJRjAjFxAiKL0g8Mv+hYtjAs1aemdC2hyEZ7ueK2XYiuLsHrSC+q0vsUh/YCam06rQ28pnqmpc1tgoRUJ2Q9I9YHNH5kH8owXDjUBpMkfFgpNK1l/HtoHQupRVlCCiv/jajSIj3q8e9t1Get9tbU9UJoo9Iny0iCfIK19nE7SlKFLgrc1w5cZZH3I++3+V6vtj5qKrUSUrAYWgM22vxcDvp5in6eVEKDBHnNlXXGpEEOhXqTdHndhLbejrhAyHtXs5ezEfB/bx8o7Pz0q1P89T0L6CRFHTpJXrm7P9ZPsK3r0Un6SFyOPO/glOljOLY0haWsg6V+0V7djkc39djSzTCVFmknLi9Uw4SAiPqvqU9IQEQgAeGrLzoN3zn4BPp5UcZXX3SamcZdhx5H1xUqcZftOqe6FrG2WMocuqlHlhde615/aV2lkVzZe++QeI9+ntTtCTEhQ+py5GTfCkk19/hYyQFk2WD73M/T1ahWRMS6IoreIiIiIiIiIiIiIiIiIiIiIjY5JoZBFDp51U54ZTztujTKKtOw8tFOkOUp7DiDl5+zgvg9jWXQ1nht6KTcavNQ3vw3tXGoraXHIed9zVBrZBatHeZ7PTgM+lD2G2cxNI09Qpsx2KR+MWnQ1MQ0hNrRYqmE1sdQW/O+2EhzjdQhLZakXAe1ttbYHRYjlV+TcXhaTexZYDC/Qm1drfmsXJw1RL95ehGrBz6WtPbWGJgyPmCrO9JYs+b6ZmFhFmaKHeCB3BUcntwnlbeiGlzBIggZSaY0KyZQgD3kBTuJx5Xek8YdX7l7EWmSoJ8VZf7iHRm6aYLnFjqV6g5X38q9w5ZOgq2dJeQ+wWLWgXPAYr9Q8+qkhXHq6U7h4SxxecVGSrjKGgZph9TxOBOEt7WHq9hC/+DCF5vxv7HvOQDA9u4xdN2waeMrdp+Buw/9AP28g1dd9KJAS0WsBP74tmKMZN5hKUvwhpdvr92/Ze/AIHVlEB4F02iAgWpn7hw6jLHnKyPXhSpkjlKtjKVBxu03C6q1cgwwLuWYRKwZg+jGG2+Ecw4f+tCHqmvee1x//fU455xzsHXrVrzpTW/Cvffeu+J50wuQZuOBhwGaKdWhTSZ/0ZJ5eedUVa1xhWWTgLePtWmR6naW4Ij3CYWbmZ01X2R5GayX3LZ108rJNz2b4YV4PdGbn6883/G2pjnCbWnwcSbHm/Zbm5tyXlvqiuuJ1V4jLWF4UzhN2M0/oTWVz9emtqYxMe6w1ni6x7/L544l9Ab0NVVre01AKsPI76Osj7I8FF9T25XC9oiVAc0FbouN9wGtj5o3PO35GDq8kbCE6+uN1V4fc5/UbIkMBBiJugnxKDwkhdBog0jZaGl5JciRIK88J407umle1e2FxQRPv9DB08+n+P7Txeep5zo4+kKK544nOHqsg6ePbcHRha1Y6HdwbKn4THc90rK6WzoZpjo5tnWXMJUW6midUsWs4/LCjpHLkSaFTSPnfHWNftM1V5aMrgPN/cRB9TqeTVVjw8PhjgNPVWEyn8I5j2/vP7qi7RpR4M+/neOzf+fx/30zR+I8+pnDUr8YawDw/30zx5/+fY6/+E6/ilMIelDN2Tx3g48fhOHwcOjnSfnpYClPkeVp8b8SEiXINpsNoohNgTV52tx+++341Kc+hVe84hW16x/5yEfwsY99DL/3e7+H22+/HWeddRbe+ta34tlnn12LYkVERESMBeIaGREREaEjro8RERERERFrh1UXED333HN473vfiz/8wz/Ei140oFt67/Hxj38cv/7rv453vetduOyyy/CZz3wGL7zwAj73uc8tKy/tNJa+a/8tloHGitFO4SS0097Q73ECGbmc7/WG2k5T+7IYV1o8QuiEk5+QauoZlvqFlWaojvIUnhhDnOU1OzNjGuiOODFIY+Yac4KYZBJWH2tqT/ye9uH31nNursUaac2PEKOF4slrGgOPh9e+a/lqa8U4q5kRe8Ni6BA0hk/b8aWxNkKMOBlHy7/N2kiQjBXvBqp/UrWMPhEri+U+cyRbTI5JS20sxAYeB6zVO2Tm3RAroO8T9H2CLE+R+2TAGGGei7hK0yiMIf6/rcrGpaUh5HHEV+5exBfvyNBJPE6aWsLZJz+HF28/DgBYWHJY6gP98vP8sfJz3OG5YwmOvpDi8eem8NSxaSz0Eyz0E3RTj5O3Zjht2xJO2bKIU6ePYSrto5tk6CYZOkkfnaSPNMmqj8Ya4mwifq1q9RFYRN/Y91wVL3UeS76Dy3ftwOW7diBxOb5z8AncefBJXHnh6bjywtPxwxefitvuqwsr7zr0OO48+OTKd8AmwV98p4/EeWyZ8kgSoJMC3gPHFhyOPlfMoVO29tFJCmbR8X6KpSytmEBLWaH+SPM9L+dzlhcfzixayFI8tzCF5xam8MzxKTyzMI3nl6aw0O9gsZ9isZ9iKUuwlG0yFTOXjNUnYnWw6i37/ve/H+985zvxlre8pXb9/vvvx5EjR/C2t72tujY9PY03vvGNuO2228z0FhYW8Mwzz9Q+BE14EFIJaxL0yHhWOgRtIzXOQiEOSzWiTVhLSCShtY32YqoJhax0l6teJtPjggqi79N1/sJOQqaI5UG2nVQztCDnpCbQ5eOpreBwHObnSq6R1voYEuRY1zRBGg+nCeFlX/L+kCpnGsZ9blWu7EtodWoSxsk1yFpDtXEs+0M+m3gaIUGeBumZTTvgICE69RP/zn+Pez+OK7gQUjtIIZBgTobThLv8u3wnAmxBb0gIuZZYq3dIEvhU/zEQAuXQVb88HDJD7UsKfazvbUDhD/QOjxRvLZE6jyeeTfH0sS6OPLsVTx3biucXushLcy7OAUlSfJyrTJxVruq9Hwhp0qTwWLalU3w6Sb/MI6uphzkmXtMQujcqyPYQCZs0tSLqJ1Itu+2+Z1W1wE3nFn2F8JffWQJQCIQIuQeyvPhP19/+yimkiUea+NI7XSHwyXyhMpazuU3pZd5V/5dKj4ZLWcJUzBL0c1cJl0YR7EZEbESsqpHqP/7jP8Z3vvMd3H777UP3jhw5AgDYsWNH7fqOHTvwwAMPmGneeOON+M3f/M2VLWhERETEOmCl18i4PkZEREwK4jtkRERERETE2mPVGESHDx/Gv/23/xaf/exnsWXLFjOck/R474eucVx33XU4evRo9Tl8uDhR4adikpVSy0+caGunaCGGjPZbhrMwTrRtDW0YVqFTTdl+2im3dp+fgmqn3zwfeVrfxEiw6sfz517LtHpFrCwk0yI0ntr0icYc4rDGSBPjbbWxGmuktT4C9vqjMSMBW31UpmeFk+wXeX2onn68PT1q49Gql1zbmtiYGmtTS1djPfK0LHaX875Rfc+qC2cDNc2VURmdmxWWGpnF+rLGkHYtNM/kOwtdsxhqVjprgbV+hwTaM3ssw9LEKMiRDF1rC66uxj1uAcBFs+e1Tmct8Td7juOhJ6fRz4Cnn0vwwvEEzxzv4JnjxRm090DigG6n+ExPAVNdYLoLbJnymO6Wn06OqTTHdCfHdJphKu1jKu1XhqgB1JhDCfs48UnLXtDuSVZRW+PflTpa+d97h7sOPY67Dj0+6G/vqrICRT9ylbLcJ3DO4+5DP1hma0827p17FN85+AQA4Ov7nq/dcw6FQeqsYPKQceqlvkOWAadsH/RrJ/EVSy3LS+ZQ7pDAI/QYy0uWUKE6liDLBwwlAEPso5ViqG0ouGS8PhGrglVr2TvvvBOPPfYYrrzySnQ6HXQ6Hdx666343d/9XXQ6nerUh06BCI899tjQiRDH9PQ0TjnllNrHQpsNoSY0CG2INAGTJmjiL1z8BWyj2LTRNjscciOgbWLaCJnkfc0Ns6bespwX2NBmTdZ3Zna21lf0fZw3sOMGajM55rVNMQkHqH017zyALeCle9ac5WgrUFxtrMYaaa2PbeeinNfWppHuEaz+sAQfcr7R/3FdHzUhSUiFq0k9xxKeNY3NJrs/mlCevrdV+7IOQeQ9siXG+41sh43D/Bpn0PONqzNzWG1Ifa/ZwyJYh1WyLy2Br5XuWmOt3yGb3KM3QVM5yYV4IoRQ3nTvYO9B7O89tOwyrhaeemEKi0vAwqLH0hKw2AeOLzocX3RYWCrq3UmZgKjrsXXa46StObZ0y08nQzfNMd3NMJUW37tJhg5XJ3N1wRC3KZS6HK/c/RK8cvdLhu4lRtuSGqEUxGmgsqTOVx8Ph6z0bAWgVGcqBEDfOfhEpY62lA9s1JD9qo3ikW6tkboMzvlSPQ/45n0DMyJbu/1KuLO45LC4VIyxflZce8/ri7H2xTsyLPSTSq2M1Mdy5nmQ+pzGRgJf3ac4WW4c7JRlKMYkWo2fiIiNhlVbod785jdjz549uPvuu6vPq171Krz3ve/F3XffjZmZGZx11lm4+eabqziLi4u49dZbcdVVV61WsSIiIiLGAnGNjIiIiNAR18eIiIiIiIj1warZIDr55JNx2WWX1a5t374dL37xi6vrH/rQh3DDDTdg9+7d2L17N2644QZs27YN73nPe04ob+0ETTJQ+HfJAJJxtHR4fH4ypzFU5Ilsb35+7Lz1WCeGobaUYSSLwGIU8PxkWr35eaBU+3LKfRlHlm2+16uxUGr5lOWx2p4M0M7OzFT5y3JzI7U8r4hhkBc43kczs7M1T3VNp90hNZsQg4zHD7Fe1vOkfC3XSGtd09rDYl7yuFbbynXQal/JruTXx3FeWUw0/t1iWfKwWvu0YbHSNZpPPIaWtvWb4mvzkPj41vrIGUOy/nQfQFW2cezHcQRvR84sknNWsmpD84//tvqLp6OVRUtzLbHW75CF8WNxjTEDvHeAG1Yhqu5paZYsEy2vprLU0ifWAzwS5FqUdcPX9hzDkSe2YGGxKHMn9QAcOiVpppMC0928MFDtijp00oKB001zJEnJCEo8uklBBXHw6CR5jTXE2UNczYzj3rlH4eGqfqT7uUuQlAwSrgrGDZEDwB0HnqqYPYt5B/08wbbOYpGWKwwe//DFp6rtcPuBpysD2lmeInE5Oi4v5qB3+Pb+o/jhi08tDZs7IDKIVFw8+9Lq+9f2HEOWJ/jmfc/gtZecgjddthV//u0czx8vVL+Ags1z6vYc737toD1fWEyw1C9YQ1PdwXhLWZMnSXGt8HJXXMu9L1hH5RhJHKoHGo1T54BOkg/93kzQWNPrhXEpxyRiVY1UN+HDH/4wjh07hmuvvRZPPfUUXvOa1+Cmm27CySefPHJa1ks1/83DcliCIvmCRWG1cFq8UJ7jBqnywIU9VjuGNoFyI8mvafHlxknb3Gjl0NLnL9c8z7ZCORJSSfANVW9+Hk5c42WJG6OwWh6fq9p9a1w0CXS0Tbu1yZHqU+OI1VojAVuA0bSWcVgCPJmXJqCS4ax1YhwQWgeB4TrJuFr4JgGTBKm9NgmdrLz42ioFENY81GA9Fykvuk4CYh4nro8D8OcMPzSiZwu1mfbcsgTf2kENv8+hzW/tPUATGo8LVnJ9TEkA4ezNHldH8nBAIQupiWw0dSZuV+hEMI4ek44en0K/cDKGNAHSFOiUamRAITDqJMXmPEnKa0leCIvKzbUr3caTICgBqu+ArsJDIiLepprQqBKuOY/Eo9r8A3XBHqWVlkKqKQBTyUAw9OqLTmvVHpQfqZo5+Eqw+O39RysVpwSFtzNuz8g5j63pcVy266xWeU0q7p17FAv5FNJkCzpJXhv3/QxYWCzG2XQX6HZ8TTgEAEt9h4WlQnhU2SNLURkS6qQDtUMSWpJgsZQDlxjYMSJhEFdNo9+b0g5RxMRjTQVEt9xyS+23cw7XX389rr/++rUsRkRERMRYIq6RERERETri+hgRERGxvvAugR8T49DjUo5JxLoyiFYSbVRR+DWNndAmfeu7drocYkCMG/0+pJYQOtkPqZBQnFFVfGR+ITUWK//lqPA1jZ02bJNxZD+sF6ivNJVK62S8Mr4q0mhiAMnfIXbKKAyZSYO1TmmwWDPWvJRxKIw2TzWWA09z3NZHbR0AdHaqxjLlsNZAUm2V1wnzvR4gxmwTS9ZaX5fTtk2MUdnPVF6Zb1tj2ZMOzrDSoPWRbDttLFksXBlPW1etdXIzrJGFqkluGpzNMTDaKQ0b1w1T11lETewhYi/ItHh4ft/B40Dv8Nh4NHv6+RRAwRDqdl3lnayTlqwhN1DxAYp2LjxMFSpliSsMEwOoVH4kqL0LD3EoaB4o2tnDVSyONgwrHk62KyF1Ga68+PSR2iF1GTKflgaRXWHEuk5HGS6LY4w1B1x54enYO3fEjrBJQOyx1PkhY95Hn0+QpsAvvmUQmuNzX/d44fjgWicdeC3Lyn7pZw6dkuGWeyAR6xvN35w/vxz114AJR30nVVMjIiYBEyMgIrRReQgJJThCFGwZxxIoWMKOcaFsS7sR2stlSMDDw7RR2ZHXQwIpLU+tjHSNXriXu7HUbOZYZdNewMdZRWacMGr/hDbh/L6ltmNtnjcrLEGaVE8JrQGWAMSK06SeJdcQUoNabyGRVJEiaILFNoI2QBciVXmJNrAEb1aeWjvye8sVDgG6/TAJTQBL36mOm3v2DUACtJpqWaET0SgcCs05PpctYWTTe4gcd+PyvrKa0NzK19xZC1WgavPPolCYHG5I1UyqQ/Hr5jXP8mXhEuTY33uoZq9lPfB/b89wfCEt1MpSh+mpwm19t+Mx3fGVnZc0KdX3yo01t/1CXquAurrOkADOD74P2rlAUqr6hVR9LDtRBMr7H1z44mW0RIF+nlQCDVcKvZJyvNCYSVCvG4VPXI47Dz6JbmREFMIhnyNNMixk3er657/hkSYOW6fLDmf4b18G+n2PbVsdkgTIcyBhTZnnhZCH1r5+7tBNixFUU1MsVR+9d0j4+2Q5XskOVpoMhENRxSxiEjFxAqKIiIiIiIiIiIiIiIiIiIgVBEnRxgHjUo4JxMQIiDSGjsUaalIlstQp+MlcqAzymsUw4V5h1sOrmaS3N6nkNKGpD2Q+oRNN7fST37f680TbscmLjGV0lbDejIdxAhnVlcwsaiPZxrMzMzUVFIu1orGECBqLiENjHm0WaMwUfl2bW9p6oK2JEk0MIxnOYuPQWFiPeSXZhE0MST6uQqw2LT3+21oXLSac1s4a22clnjPcULbMl+7xa1o7xTWyAPVRxQwSfS/Vyaj/5ns9k71sMYf4d/keYzHjrDQmFUlpHJlA7JSBUdr6b4LGDCL2UBvj1JqaU029TLCYKHyCHId6D8DD4cLZ88OVW2F8+a4lPPBYF94Xrsq2by1YHadu7cM5IE08EueRuhzOFewY7lmsalOX19qVGwineqtqYx41g+LeFWO6ptpnqAoCwBW7z8AdB54ahIVH6jK8cvdLRm4LAmcefW3PMaSlOlNelu21l5wCoPB2xutHNe7nHTjnR1Ztm0R479BxfUynCX7w/HYAwB/f5rGw5HDaSTne9cMJ/tuXi7BLS77yaLZl2sG5gsUGFEbTyVg6gMqDHoDCg54r5j0fK5qRebruSjUzadCeDJtHREwSJorLaAkm6OVYvmxbVH4O67qVt4yn3QvFWyvQS6alFiXbZWZ2tvZCqVHZrY2lbH8eRl7XNj2hzRgPu5KYmZ2tqWTQxmp2Zia4aY4YgDY4mjczvnkFirac7/VqG0xLUEsI9bsMbwmFN1u/hQQ98j4PZ81fGbatUJenYQnfrXzXArQ+Ws8O+i6vUbkJTQcK1vNGW2NDbSHbWptfK3UIMTszU0uL/6b/y32Objbw5yrvexLC8Y/zfkgAR7DmIKVrzW8Zjv/n4TZLvzm2WUxQqELRfyc2km3SsiCFQtL7VpMtnZy9uidY+83pD57pwvtChWf7VuDkbTlefNISpjo5pjoZukmGbpohSQp39Wkp/EldVth5KjfXXDhkqd95P/yhe7lPqv+5T5Ch+ORwyHxS/5T3+nkHtx94ut4Hzp+QcEhia3cRQGHzJvdJJRyia5kvbCnlqAvCmtTgNgsu3XUOLt11DnKf4KSpJQCo7AiVjsjQScv/HWB6Cti2pVBx3DbtMdXxlapjJ/Hopnnx6RTCnU7ia8KhVHw6SV59ugmN5/Kay0uBZ6me5sbRt2BExIljYhhEERERERERERERERERERERq4Ax8mKGcSnHBGJiBETaCTRgq0hZ1+kepcn/W9Rr6+RNUzOw1GbWEly1x1IRkZDqaBZzSEKyuvh17eSdp6u1W0hdZaXBVSbk9YhmUPtRXxKjqPJUFph/chzw8PK+No8kg82amzL8JEPOudB6Zs0/TTVFa2vZdzx8qHxW2LU0WG2pOGrlkpCsyFBbcq9l/Loci1o5Qm28VmPZ6o+4PrYH9/RmGQGXTGft+aiFC6152ruJBo3lO6kgZgs3gkw4USO00jNZzSiuwhyia5JpRAwTXj7n1t6rWT8rhm2aAtu25NjWzTCVZrVykdcyaldebr6lk+whyajJUYfcDnIPZ5oha54m3ePxVgP/8OJTq+9/e+/z5r2IMLI8xVKeDtTxcuDYQoL/dUsx9go4bNtSfOukvmIJpeVA6STE9ClDlyyhJPGV2pj0RibHq2bAXo7hiIhJw8SI3kJUaKlOIV+45Uu3TDOUZ0jII1/qLFr3Wr98kfoUVxOwVBh4HWR4+V9rO21Tz6/LsJbAjX5bL7OrtSlaD9tQkwTqU2pHqTahCf60cWBtaLRNFL+ubaJl/M2wAZKqS4RQ/eV8lUI5mabV9tp8lgJ9LazWz2sBS8BjCdgsIbi1ISdwQWnTYYVWvqYDBqvPI8YLszMz8M7V7NtpsOaD1bdyHMt78ru1NrQ9RNroIBUyrvKlqX7VXNJzYQZTEcpJNYqlosWXgqdRbBXxtFL0l1ttE9/afxTf2Pccbtl7bOiec4Vaz3QX2D6VYWu3X6mS0YfUyGhzTep65MWLbA5pXsuWi1qvCZU0ul8LTwK3VfRC9YaXb1+1tCcdmXfIchKKFp8sL9TNknIMbt/qsWUqx/YtObZO5Zju5KVqWaESliSF3aE0oWu+Uh1LmSpZJ8lrapD06bh8WAWN3efqZhERk4SJYRBFRERERERERERERERERESsPKSgez0xLuWYREyMgChEvSZobAJ5r40qgXV6Z6Uvf2thyNvTSoKrkmlpc1UKS32Hl18aPiWE2B9aOpZ6T0hVool9FE/Ixw+kFtSbny9UzVBXq2kzNmQ4axwQQifdFkumKd4kQFNPIVjMSW0Oh9o8tM5Z67LFxpH3VwPSI6E0tAzUWT5tGBkhdpsVT/aLxULi17R2Da3jG3V9XI3n4riB1My0cSL/a+8WFruyjepYKO5me7ZSLZ3zA7Ulw5MWVwXjqkp845QDSLzNjJHqZjVmUukZTWMNSbYL5X+o9wB2z16wjJoX2DP3fSzlnSr/x547FVlesDZu/u4Cztr+NC7ftQMA0O0UZTh1W1YYpU4LFgVn63AjvqnSBk3MoVEMNmvqYtbGUbZr4vINqyK0d+4ILtt11noXY9WwkHVxfClBP3fIy7E41fHIfeGhrJN6dFOP6c6AwVMw0/j4GoyxlLEESfUMQI0BxNVq+BiW4PMw2aDjJyIihIlRMeOQLz38Ywlv2qihyLS0sPyaVJew1C2sNEZFb36+5jmKv/RxD1FaWTU1hKZNo3eu8vBl0dA1tRKenqZiopWDXyPPL2TrwvmV89Cz1rD6ZBLgnau8QXEX9txGSRtBbNO4ssatlfZ6qS6tJ0LrTWhjqamC8f9aWBlHxpcfHkZbd1eqj7hLce4qXEu/5n5cgK+XVpkpnLbeNwkqtWeMFU8KgPiaTKrEXPi10eC8N/thUsD7idbKJoGpfJZqwnZrrllzl8fheUy68JwjJLTQBBaaOlPuk0q9TItXKUEJz2hSpS10Ml4XJhWv8Ylbnjezew49hjsOPIXnlrbi2aWtOLqwDc8sbIVzhWrOVJojE3XYMlV6iUpzVfgDMDUy7Z5m46Wlmhd5/uIqfODXGj6vuuhFePVFpxUCvFI96IrdZ7TKe9zg4bBn7vvrXYxVwzPHp/Dc8RTHFhIsLDl0Uo/3vN6hkxbu67d0C5UyriZWeMzzlQe9YRWygQokqUF22CdxOdIkQ5pk1XeuSibnL1eTjIiYJEwMgygiIiIiIiIiIiIiIiIiImLl4cfIi9m4lGMSMTEColGYCKGT2SZ6f0jFKnQqb4Gf3JHHp1G9wFA8Kvl8r1d9p7IRe4PuW6wBjSlEv7XTTO6lil8PtYl26q6d5lu0d16/cTsZJ0ZQ23LNzszU2pDqu9E9AZHahOYJTjICQoyKNmPDUocIpaGpWEwyQuxADtmmTW1Mv7W2tpiJMn2tXy1WDzDwjtd2jlXjzw2ryvJyc3abtg6GWFEhFhGvs5YmR1NbyXhaf/F2Gsd1ZJS+o/JLtdRxrNdy0ZufB0qWFzHX+Ciwxl6IjWwxj+R9a65Rvk1hJgkeQO6T8rvO/rHUniqVM6czYWrmqpUwXEWNe+LS0pF5cuzvPYSLZ1+KOw48hVdd9CK1rBJPLZ4EAMhzh5ylubWbVWVLncdS3sG+uUdw6a5zcNJ0YRSbvD7lHiCFBKojbdtC6lvcA1nImDSFJfRJ1a6Mnyie5yzcdehxAMC2NMcrdp/ZKs5a4st3LeHHr+i2Cnv5rh3YM/d93HPoMSzkU1V7vvqi01a3kKuML9+1hAce6wJIkeWFMepfeDPwxTtyfOHbwJYuqjHYSQYqglzVsGAH1dXHaGwCQIepj1lGprX5xtOX9yIiJglR9BYRERERERERERERERERERGxyTExAiJN/147nebfQ/r9VhyNLSP19C3bExzaqSCB7AW1tU+j2fiQZSebRABqp+RWeG7XQLN7wOtANhSk7RGZh9YWPI6Wn3VtXE80l8NoInsh9B/Y+LaJaExQPWg8W6wLDdqYDoWT9lvkCbjFSNsMaGIdhNYC/luLr7WpNp+18Np1bV3m1+Z7vZqx8ybINVobezRvpe0hXg/+P8Qa0uoj25dDu6cxtzRoz7txXh9PBPy5tdHtEvHnO/U1Z0k1jSf6r41BPu9Cc0o+X0Os3qa1ehIgDVK3NZLMuQeV23Tm5l3aLQEEo4gxETjDiN8bMkzNQgBA7lN475Aiw8Heg3jVRS/C3Yd+0Kr8ZJOlm+ZDNlvS0vB05h22pser8nfTvLA/VNl2GbYjpHEyLFtD3J5QiD1UsznE+ilHuL+4O/sUObquP7auyduyhwiX79qBV+w+E91kCVPpIl590Wn49v6jq1S6tcFSluCcF2fIcmCqC0x3gb/4Tr9yWd9JPbwH0tLAuLRplZaGqgl8/iXlfQCN9oOCY7K8nvsE+QgG1ScCDiitf4/BZ70bY3IxMSpmgE2j5r8t+rW1OQrRtUPqAZbwp20abV/I5GZG27hJQZHzxXInXwKt8oTK4p2rPFTx8KNQ2Hl5rU2lDD+uL6xSPeBEYKnvARtDBc07N7SRD6neyLj8njZWrfR4eG0TxfPdTEIiwBZyN60do2wWpcDaKoNMv+38HqW/tLEnyyDDhYS0VvuFoG3iQ3Hks8rqL55204HERgf1CankAnUvnRLjpnrMMd/rYbZUkyTV79D8Cgl55O/QQcwoc3kzCtKtjWAIufifYFj1JEE+pFrG81GFJg6AR+W1rI0RXM9UvICBulwTppI+slJAk7iBMCWDQ+YTeF9c+/6x09FJctx237PoJCmAQk1Hq9eQCp0QjlntrAl5EgA5eZZT4lbpCtWfWhuXZSSDw+OMm7+7gLf+0PTI8TrMSHnictxx4CnkPsFSXvSVh0PqMqTO44cvPnXFyrsa+EevSvE/vwpsnQZecmqhSpa6QigEh8oANV+WtDFX+18Kh/h4oflFGDIoz8Z22/kUETEpiCM+IiIiIiIiIiIiIiIiIiIiYpNj4gREkn4tqdQW/brp9Nyiclt0cO20TsaV6WnMmTZUeu1EXuZj1ZlcxvN2CqlPaAwM7bRRY2eETiHbnmQ672uqWOMGMgx7IipipG5mnRBvpNNcfsrflkkmWSVWfG0O8etWPEuVYpKhMU7kWhBqX4LFDgr1k5avXO80Ro62ThJIXbGNKq7FWgut39zYvMaItFhpvI68DlZdtOeRTIvHCTGQNsrawFlAy41P67/23B7n+UysIWDQDqF3Aq1PLeajNR+1uRdacy1W86RjSN2LuaGXHwKpZ5HaSlIyalIU6lkae0jmaZWFq6bV7gljzFLtysNhf+8hAMC9c4/i3rlHg/VOXI5ukqGbZOgwF9+p8zWGhveF6s9i1qnqDgDdMix3HQ6gYmtwNbuEMY7a1E3ek3EpfGUQW6rrsU/icqTIqyuX7Tor2C7rhbf+0DRu2Xts5HiX7TqrqtN0uog0ydBNlzCV9otP0q/6jAx1jxv+9t7n8ad/XzC8/s2PAlumPLZ2M2ztZuimOZLEY7qbYTrNSg0j6lvUPpLFB6DOHjLUHHl4yYxrawR9M8AjGatPxOpgYlq2zUtMSEhDsF4y5SZKvnRZH/lC37Qpkt+9a7a3IMssN1/aZoWnLcupbeA0yLSs9pTtweseemmVeW0kOO9P2E6GNj7GffOj2dbg0IRecrNO0MZgqE3kpkmbj1p5NtrYWg60+ddG6KGtV6F+1QQebdpYE6poZQttZENpy7Jbay+Aak2Uc5jSkepLMs2mdVDLU4svBUKhdXQjjuETtbMWEiCOI2hc0ZgiFWKCHNNy/lj3Q/G18TGKINIKP4nQ7ANV9xRBBt8wVsIcEmBwQUbIixdTyVI/bjhfLT5958KijsuqK/vmHjHLQAKc1BWCIRIU0fUk8UgSjy2dJWzvLmJbZxFb0yV0kj7SJKsJflL2IeFQZfuFCbwqQVHLTXcCJgRigjoSzFkCOApPdQEKQUBb+1LrhW6S4Rv7nsO3lmlL6PJdO6rvnaRffajdl7Iu7jz45EoVd0Vw58EnsZSnOGVLoVJ203cX0e145N6hkxR910lIPaw+F+S8KcLU52MtrCIoqoSNNB9Q935WS3OEsRsRsVExMQKiiIiIiIiIiIiIiIiIiIiIiIjlYVUFRDfeeCNe/epX4+STT8aZZ56Jn/7pn8aBAwdqYbz3uP7663HOOedg69ateNOb3oR77713WflJ2j59bzr55id0Wnh5uq4xc7T/MrwspxU3RB3X6qzF4RR8eW92ZqZ2Ci5P6yVCJ98afV1jLDWdYMrrMu5GY3qsRFmpjzRmxzh5OZOsITol19Rh2qhOWGwSCiNhjVmZFx9HGqtkrbHW6yOgs64kNFWVNmuSNu/lvNXWmjbsIGsctWUSacwhWge1tZM+Wjoaq0jLS6uLHINWWIuBZc0p/tsq+zhhFAaYBVL/057H47g+eudMA+hyvWqapxrLTLsn42jjh9+jvJrYSmuBtV4fHYYZOjVGgsJSqMIx9gGpliUQHswMZtJQWgYTJgSpYpb7BInLkSNBx/XRcX0zbsLYQqnL0HV9TCVL2NJZxNbOErakfUynhRpZjsIg9w9ffCr+4cWnYjpdGrB5uHpaklWMFWJjcKUQXk9LBU9T7UvdMEtJa0PZnkXcgj3zit1n4hW7zxy5jdcS1IbdJGsObOCK3Wfgit1nFOqOyGssqhyoVAXXE3vnjmDv3BH87b3P4/mlaXjvsKWzVPxeSNFNPaY7/WpeFZ96vycOtTEoPQdWaqB0XbCH6mnl6LisGqN8vBJ0ltLmgvZuvZ6fiNXBqgqIbr31Vrz//e/Ht771Ldx8883o9/t429vehueff74K85GPfAQf+9jH8Hu/93u4/fbbcdZZZ+Gtb30rnn322ZHyatpY0jUZnsKRXQNtIyHzsV7GQoIjOZjlZlhLl/+21JU0QQ9do42CLBe3r8Gv8+/yhZWnL9tZwtrQW4IeuWmSeciwG8HFsbbxHBWynnJTudx26M3PD7nzPpF0QpsHTejaNOa1TYwU1spNdkgQIdOwfq811nJ9JGhzms8/2ab04bZ4NOGGtraGhCdyTbEETlp8TVBkCQTIxhrPg+pjtQ1Py9p8a21nhZdtI9vbetmxBAWyXeTvcRKOWOD9ciKQawUfG8ttB64qu1LPGuo3EhRJG3OyDtqY0H5rz0nrec6hzbs283UtsdbrI3dNH7I/pG1Gr7zwdHg4XLH7jJrdoSrtwCZTLYu47+EKkZMvPlxFShMOeQy8ny35bk0VTYILblKXo+P6mE4WcMXuM/Dqi06r6popallX7D4DqRuomXVdv/SUVVwjwRC1b6i+Vb0V9R1NyNbUhlVc7gYdHnvmvt8YZ73xDy8+FVvSRaRu+QIiANgz932mjlf81/pxFMz17se+uUfwnYNPLEtNjdbW7xx8Aot5F8ez6ao3U5cjyxO8sNRFJ/WYSvNS3bFQK0uSwdjg9oaqjyJMlEIj/rvjsspeGH3kGlAJp1AXdMp8IyImDasqQv7KV75S+/3pT38aZ555Ju6880684Q1vgPceH//4x/Hrv/7reNe73gUA+MxnPoMdO3bgc5/7HH7pl35pKM2FhQUsLCxUv5955pnVrEJERETEqiCujxERERE6VmN9BOIaGRERERER0YQ1tUF09GhhcO30008HANx///04cuQI3va2t1Vhpqen8cY3vhG33XabmsaNN96IU089tfqcd955AGzjtdYJLAed7NHpHl3T2DMc8rS9CaGTdeukvCltqdpjQTIqiEHC1RGs00nthNw6JZdMj1Hrza+FTu43AmhcLRdNbb0SaiQrYUhbY+sQc00ygWR9CPLUWzKEtNPyppNzPt60+Wwx3dYLq7k+ErQ2s9q3DStF9r3VjpKJYK1tsp9C5W4DboSf8pPzRlun6HlAamih+oXqpK2foXxlmm0g59hGwYmuj/zZJ5mH9Fnu+sb7o20aVB4Kz1masj+59zLKj2D1vTa2Qgyj0JjQ3ot4/tY6uZ5YifURsNdIzhzQVMOk6gr/3HXocXSSPu4+9INBOtJorqFiJuHga8amgWGWkIerjC3LaxIh9TIAWPId5HAly6So40Wzg+dG5eEsySuPbXcdehx3HXoc9xx6DK/c/RI45wvVnJKVUTCJ6kwsDVR/j4GXKJUp1NI4MGdREeg7tZVD2Gj3OKFzAgyi+3oPqyyrbuWhzuPOg0/ivt7DuK/3cKs053u9ikdDTLa7D/2gVdze/DwO9h5E5juYnZlBNynGpYfDdLqE6XQJWzpLSJMc3TTHdCdHJ9XVxvic5IwhMlpe88aXZHU1ShRjlMZrwlRCU2QVA5CuDc1/xsjibKLNBO+SsfpErA7WrGW99/iVX/kVvP71r8dll10GADhy5AgAYMeOHbWwO3bsqO5JXHfddTh69Gj1OXz48CAPg5JN37UwHFKVwkLovrUBaBvWSt/KT1Mx4+BCLwrDN2tcTYg2Q1wtzSpfWwEW5dO0MZTlW67AbJxwohs3qXIg6z7f6420weIqEyv50s/LRX0t1XSaNsCagFG7zvPQvmuCIdl+IYHlemEt1kdguC/abgYpPK03fDMu0w9B5ivTCQmFtXI2rQncFpum1iTHKS8nCRjInha3TaSFlbCeNdYY5/e0esuwMtxGWRcJJyrg5u0u//O2b7tGhgQ6bcBVu3kZLKFsaD3UnnfaGjmKUFKue1KwxuMvtw1WCyu1PgL2Gslt40hVlNrmVFE1S5Fjyi2hWwpjKCwX8khwwVGtrqUQQ4aVYpMcA8EHqZ7x8PTJG17zp5IlpKVtmsTl6GCpunfv3KM1L1ipK2wLkSDKOY+9c0cKgRCyytX6y3edrQvExOa6uma0rebanqfD24wEZJl3yNk1aruchGqs7cYVe+a+X9myOtA73BxBgfduaAzyduyUfb6QT+GS2XNbpZmhgwxpJdCjPjjUe6Ax7uzMTK08fZ+Wgp2sEA6li9jaWcD27gK2pH1s6SxhqrR91SltD3FX9rw+5MKeq37SHCbVMFIhq3nTY7bCpFqZDBcSWnKPZxERk4I1s1L2gQ98APfccw++/vWvD91zcrPo/dA1wvT0NKanp1eljBERERHrgbg+RkREROhYqfURiGtkRERExIlAMhzXE+NSjknEmgiIPvjBD+KLX/wi/vZv/xYvfelLq+tnnXUWgOIk6Oyzz66uP/bYY0OnQk3QGAH8pAwYPmWVzANgQA+XLAQtbCh9S/XCOqnj5bdOHUnlQUK7JttAq//szEzNaCaB2mBmdrZ2+hqqg2wvgtaGWjyr7bRTzHE62QxhdmamYvmE+kgDsRYIcqwBg3Zok35vft5ktJGqYRO4SkfxRfcGFppv2sl2E2tFxrXYbRr7Qp6WUziLnbIeWIv10WIRAhhqI9lOvL3mez3AYLRoDBaZZhMDRmNSWP0n86MxLscy/20Zpw7lJeNRG9A1PresOlpl5vd4fqGxbjFJ+LW2c3q9QSytUcvam5+vXgstBtpymTDLZWJx9pHG7OXlpPpKxpL17NTKqDGE+G+epza/tDV1HFloa7E+AgUbgZg0EnXVrQGLhcclVoFMk98vYrvadf6f7mubHo2RRL+HGEeKgez5Xg99dHHh7Pm1sJfvCrdVl6moybl0+a4d2Df3CC7ddU517e5DP8CUW8Jl5bW9c8NsLuc8vHdIUHhGG0zm4fypLhVribWjBO89Cp8jYWwqINkAbA/qk71zR9BBWEVQw/7eQ5AKIs55oGyTxOXVOOy4DHvnjuCyXWcF05zr3Y8cnYqZRB7REhSG0NsiQY59c48gLbefLhkwdIrfizgpfR4XzZ6Hb+8/ijTJ4L1DNwH6kiXnBnORflfsIfrN+luy2eS1IYhpr83dxjQiIjYoVpVn6b3HBz7wAfz5n/85vvrVr2Lnzp21+zt37sRZZ52Fm2++ubq2uLiIW2+9FVddddVoeQkhg/bC0/TyI+nW1gumJXDRaN4yXuhFTHvRlZvXUT2rWC/M3rlKtYyETyTM4IKHJio8bzNLSMfjafWT17V0NCr8RgFtgtqAqznIdrA2jU3CIe5pjLfjqO3JxwLfBNF1vsmzXITL723mgSZYktfbbJYswdJ6YS3Xx7ZtT32pCZa19pNjQpu3Wl6W4KNpzZRzoa2w0YKsr1V+7vlPXtPaSqsjT7ONoFMTmIUEbNr/ccdy1nRNfZWPUd6fbdKW/crLNUrZeHjt2UlhtDiWwEcb57Jc1ty08rTCWGNYS38tsJbrI4C6vRHkNRskUt0sdRlSDD4J8krowdXBAEV4o6hehSBVrKQwif+Xqlc8jncOU/44Hpg70L5NqK7lp1OqktGHbPnc13sY+3sPYe/cEUy5QkXt3rlHK+GQVn5LwCbV9zS1Ml5fig9gYJepVDXLmPpd7hNkPkXm09b1X2+Q0Gaud3/rOHvnjlSe7CQS1O1sJS5H7pOgcKiyz1rOCAK349OWxeFKYU2HebvjKl70m2xgbe+8UI2LHKjNRW5ziNdpoE5WT3tIhUzaGBK/h1TLFI9oo87liIiNhFVlEL3//e/H5z73Ofy///f/cPLJJ1d64aeeeiq2bt0K5xw+9KEP4YYbbsDu3buxe/du3HDDDdi2bRve8573rGbRIiIiItYVcX2MiIiI0BHXx4iIiIjxwzgZhx6XckwiVlVA9MlPfhIA8KY3val2/dOf/jSuueYaAMCHP/xhHDt2DNdeey2eeuopvOY1r8FNN92Ek08+eaS8rFPvEPvCOkGn+KFrhBANnJcj9Fsrr0xb5kOnqE3sEcnsoJNNLR+tXloZ5X1+ymkxhjR1CKsteLpaudab+bFaILUJre1CbdNWhc3qv7agccS99VCafIyFxhY/jZZzUZ6Mh8abDKOdxGvhrbjrgbVcHzkk60K7T5D90sSICKXB42u/aRxxNkdTeI2NY6n6tCknh7ZOhtor1K4Ww03OcRlfliH0zOLhR1VpXU+QKm6Tmplk+RCaWFZNzwvOPpLfRwFXOaQ6aeNWK1/ouaaNgaZ3EW2+hq5Z19fzebvW6yMxBji4SgmFAQasHiWRoTT1vPIyfX1zM6TG4qAaHQ7Vhf5XH+/hXQLnM3xv7iByl2IJUzWPZRIpsiEmVF5uyMgoNIDK+LNsP0sdjOrhnEdSVjEXbQ0MDIfnShoaeBjvyZByjsw7UOd4n2Kqs2SkMH4g9krTGrln7vtIkcGJ/tL6gK4lKIxE3zv3KF6+62xo8N6hj7oKWYKBilrIq5zErtmdlapawtQ5UxTe2lLXR+IH13MkpWoc0HF5sR4p6pSUFjGMuApcG3aPpS6mtRnPl8JEBlHEJMJ5v7F328888wxOPfVU3H3XXTjplFOCgohRhDnayxah6YUutDlqetlvk45WDrrXRt2I0raEBW1fCJvSsNo9JLTT0ubXKN5GsK9BaCPMs1TQQmNXtrlMX/a1JhCRaY9ii4inIctE9q2sfNqWSeZhCRibxnDT5v7ZZ5/FFa98JY4ePYpTTjmlqQk2DPj6GNo0hdbGNvOYh+P3JNqMg7Zrbmhd1dbZtoITblOozTOhrdC16XkUWvN4uDb3N9L6yG3eWZAu7a3nS0iQqfU9F3LL8FrabQVvTes5t0HUVpjD42vpEtoKlKw85X3vHJ575hm88oorJm59BAZr5O137cP2k+26aapiBE0AQv/rm08pgEpq17nAiKupVWIeP/itlUOqXA1U5DIkPofzw/Z3+q7Y/KfIsHN2l1H7gaeqXKgaWSChEa/PUJhKaFNXGdPSykUbUPzK1pBPSkHQ4LqHQ+qySv2P7l11yfIPWNYapF7W8Ut42a4LzXCk7scFenIMSXABIrcjRTjYe7CmSCVRdwOfYSo7DgA4b/elwTod6j2AHAM1OBIsdrGIxGe4YNdFAAo1xcynVS4WOi6rlYcLn3hd2/y28uGCIDmun3v2Wbz6iksncn3koLVy/x3fwMknnbTexQEAPPvcc7j4Va+b+LZfD6yZF7OIiIiIiIiIiIiIiIiIiIiNB40Ju14Yl3JMIiZGec86vQ6dwMpBbqks8PvWKTfF4xR1LQxPR8az8pP14GXldXe+2RiyPBGVdQ2xouSniRI/ChMp1A683BsRoVPnygAg60uCPCnnfQagNs40hOaBdQot2UEhyDLxclK9ed21OSFP6eXYkXnI+aDlK+tL6bSJN6nQ5q8250L3AJstY7Wr/EhmhLaOWf0vx//szEwtnFZOWb4maF6ltGeIrFPTMyPE4rDWPYvZoq3BofTHHTOzs2bZuVOGtkzDUedzm7EivY6FQGtoaP7wdOW7gBZOIjQOrLz4NTkm5ZyVYTcDhozSKh8OyeKR4YYZChqrIa9dp99OMZYrDe5Kw7uWB7WkZFcAANkOoU/fddFHF9P5MTifNxqwJuaQZuC3ZrBbYVBpajg1lT3FGDePk9A1hWWkMbiofaprrp163rhh1+xO9NGFZmtlz9z3sXfuCPbMfb/GHAq2tRxXop04klLFUG3fikuWIUUfad43mUYcvfn5akzKcmZIkbkBb+Hlu84ujaNn6Lo+Oi4rjFCXHzKUXRlOL41ma3NRfmQ5m8peZwIOpx0RsZ74/d//fbzlLW/Bu9/9bnz1q1+t3Xv88ccxswyzAxMjIAL0TZ+2abRexORGXEs/lCdPL7RpsDbr2oY+lIa1OSChQwiW8EDbMPJyakKJUTc+2kusrIu24dvIm3kpJOIekIDhjTJd4//lddm+2uYltKFy3lcblFHaVxuzMi4viyXYovihzb01V0MbodCcs+bpZoC1+WvTriEBkCbQ4fFCQiZtfFqbXTlWSLAaGiNyzJOnxjbtZK2RsuzW80aG1zbkMr4shxRUWfNUE55uJEiVVGB4PZNtEXoe8+/UNtb6qAlEKQ8ScvO1uk1dKA3ZJ/RfemKT4eU9mUZovITGmPYO1Oa9aDPB2vDJLaa8ZsVXVXsMoU69HMXmO0E2JCgiQYz8aIIV8uqVuwS5SyofZEuYQoYOtufPVOVO8yXc35vD/b25ofIkLhvaZPO8O1hCB0tI0UcHS8OCrIDgIiSQ04RCVQhfb9vU+erTSXJ0kwydpK4QJ+NsBFw8+1IsYrp2bd/cIzWbT+o4E23O27QSDpXjKfRctIQtu2cvwK7ZnUV6Pqs+IXjvkPu01tNSZfF7cwer79zjWIK8EgKRl7IUmXBvrwt5tTo1CYUsIbBsz4iI9cTv/u7v4td+7ddw8cUXY3p6Gu94xztw4403VvezLMMDDzwwcrpRxSwiIiIiIiIiIiIiIiIiIsJEG6bYWmFcyrGe+IM/+AP84R/+YeW989prr8VP//RP49ixY/it3/qtZac7MQKiENvCYqdoJ2ZNJ9iEUU5sQwwh6yQ4VGZZHqssZGyVG/+02FEUf2Z2tkaRtxg9FK6JdWLdk+2tnWbKU0yr7BsFNYOoSj3opBrQVSNDJ+dtTrc1hpKWX1to7AYtHW1MaeW2mHUyzxBDyEpXm0cbmXFxImjqLwoTCh9iPWjpWAwfi9klEco/1H/a+g6EPfBpLKumMaLVw2JPyTxGeS7IdrfqtxExtB6JOnOWkfb80NaWEAtM5q21PXkOOtH1UebDr0mPZzysVVat3NoYseKG1lHrHWPSQZsern7CNx+cecLVlYhFQHGb4JxgWaKerhoHWSvmi+UVDQAz0kxqYlndE5PPkbu0YoAcPrQPgG5wmHgfFD/N+9X1lOrkBnl5FOMq86nZvhrzSlMF0uDgUWRZrqvCy1yGFIkvUtuo+8kcCQ72HkTq+sh9isSlyHwKoKj3ZbvOwr65R2oGuQnUjpKVlVQstRxJrjN/yJNdjqTGHHPIK4+NZPyct/kjB+6Bdw7nXnh5LT1fKgvyvrXUtwDgktlzcaj3ADKkZfzhutF/jVGleSZsQm3eG2UcJyFJxObG/fffj6uuuqr6/drXvhZf/epX8eY3vxlLS0v40Ic+tKx0J0bFTL4oAjrlmv5bgqEmqn9oc25tPuVLfdNmXtsE8bxCG+TQC7JU+5Hp0UZpdmZG3UDSfe9c7UW+zSbTqp8MI9uIv/hbL7UbBVIAIvuMq8xoG01LaCTT1sDbVWtfmS6hyeaGFB4472u2YazwHCGhEQ+jxbc2zdp8tebnRh5TbaGtjfRfW5eaNtaWAIO+yw+PE1pLtbGhrUW8r2W5rT7XysvXspAKEo3rmdnZmlomT6utAC30PJFjmPeN9VyTddqo45k/XzhoPeFCZvlfthG/3hbamhgS2ljqilz4KMeodwNPaDwu1V2bV7Ic1lpI97Q0tPkYeq7IPDfqmFoOaoopnn2M67kfeGPSVM4G6Q6/bnvnakIhSwjkfF2dq6ZW5gab/RT9wmMZ+0hVNoccicvQ8UtI8z5ylyr55UjzPqaXXsAP9n27KluCrEoDADr5Erb0ny9sGbkuLth1ES7YdRFetuvCenlKIQR5FBuUZSAM8HCtVO9kPIJmn4ls6yQuRw5Uqki3H3g6mP444pLZc5G6Pjp5ocYHFPW6bNdZcPC4r/dwg8qir+KQAC1hNqMc/LCHWleIhkigY6lrkU2r3KXVeMqSjj62SqEULxd9On6pEjZxNTPXoFY5qMPAhtdAPXNwjecnv1d1MeayVFojL2xRUBSx3jjjjDNw+PDh2rWXv/zl+OpXv4pPf/rT+LVf+7VlpTsxAqKIiIiIiIiIiIiIiIiIiIiVhzR2v96fzY7Xv/71+LM/+7Oh65deein+5m/+Bl/5yleWle7EqJgBulqS9p1gMX9ClG0rTe103GJCaEwHycQIlduqhzxBlnE1VR+uXsFBp5xEsW/KW9aR52HFCbE4QqyDjXqaaXkz4156AJ010cTGsvKj02wrHfmb93Vvfh6zRt9bc6VprGj9KP/L+xrDSJsrWhllvvKe/D7p0BgN/B7/32bMaOuXlbbF9KCwWv9bzCeevpZPU59q82lmdram6kOsIQ3WOCe1W218aWNeK4vFFmmauzx807o9rrDKbI1TrW25xzF5n7fLfK8HiDGkrS3zvR4chtcJzgayyjrK8yrEygux75reY0Lji+7zOE3r5aRCMgGINcTvc3B1Jnmfq/QM2Ap5la4kHHC1IKnKJvNTCl4vj9fVsmplyfOh9BJfGqHOC4PDab4EABULZNfsTvTm55Giz9TVHDLXwa7ZnUP50Ty7vzeHnbO7AKBQkUJWqz+vL30nhotVD7rM1YcqdTehUpS4DBkSdNygzInLcefBJ3HlhacPpT/OsJ5HFoNlSIWPqd7VDJuXrB1SFQSAQ70HAKQF2wxLlWFpqV5YvL+6apxcsOsiAMW4cT7H4UP7KjXFhw7uRZpuKcYNhHqYy5AjxczsLB48dB8cirFDqmWJy5CXKooWQgwq791gDpbqchbIaHaIGRRaGyIi1hL/4T/8B9x5553qvZe//OX42te+hj/90z8dOd2JFb3JlyPtBVtSrOVLeyiuvKapBPByaOoBUn3A2gDINLUyyJdSnt58rzekPkF5Nnn0kS/smhqApKzLPGQbhMKFNkS8TbQ6bVRI+r82DjV1ABkmBEtoyK+12QRo3nfkbwrDwzaNZZ6GJsDQ5hH/z6HNTWvuNJVnUmAJYeVmW5ubFFbbWLbNLzT3ef5aeei3tU7wtKy0LcGYXAelqs9y15iQQEdrS2v+8/vye2jetlnbJwWyf8lDJL+nCQ65i3kKK8dgSJCnbdas5yxQF95ZfWbN09C6bz1jef5yfMn101pPQ+vspIJUxySEkllxzdiQNm0Ya0IgGqOKalVNeGKoskg1LVlW7l3K+bz4VMKkfHAPHmneR5ovVfZoSGWIvJpJ9fHEZzh/9yXBupJwCABS1y/UpNCvVIa4e/tKncfX61HlV1mw8QOBB33gkWJYxcy54non6aOT9NFNltB1fUwlS8FybyRIYQeNIweP1A27fy/U/fqVcIj+cw9ku2cvwO7ZC5D4HM575sUur6tF8vVHCE2ypAugEAw9fHBPZeMq9f26qpjL6mttWc40X0LHL1XqkFKFUv4G9Hc7Pr9Ibc7+SGWywdyKKmUR44hXvOIV+Nf/+l+b91/+8pfjN37jN0ZOd6IYRBERERERERERERERERERESuLcRKSjUs5JhETwyCSp2n8N1CXcrdhM8hTNxlXnmyHWEM8TR5Hlp/CyHpoaclyynpp+c73enDeV0aoZ2dmTMpqCDxeiHWinfJr7WixBHgcq30nhUVEaMuMkWOcs3f4CXqTygaNAwLFBwYqavwaP2WXHwpPZeTpWqwJ6x6/z/O12ky7r81vjV0k85pUSKaBxm6Q7AKNkcPTalrzOKy1VsvPWivbsr60ssryyWcFzRlaH71zI6tpcUPWoTrw73J9C4ULMbO0uJPAIpJMRI0to7WLta5w9qnWv9rzh//m5aG0NAcQGuuLf2969spnQdP7hDZXrXEhv1vYVOsjV29irJRC/SWvmBjExuCMDILFPiDWBTcoba5tTnzk+1xgQ2Qxg4Y+5X1iGFE8YgzlSanW4zN08kWctPAkjuy/C48cuAfdfAEnLT2NUxaeaGQPSdC7Y4p+yfgp2EQd1x+wXGT9S8YL9UHicnRchtTlSME+ok+or7puCVPJIrYkC9iaHMe25Bi2Jsew1b0wEe+P9/UeLtoGWdGW6KOLRUy5BUy5BXSwVH1SZOi4pYI95H1tnNDnwUP3Ya53f5V+5aGMWESuvi4B5TMTDt4lFdssdykyFGppxELq5EvoZgvFuEJhbDtFH0lZjtT38eCh+wAU3vPO330JXrbrQrxs14UAgNSXRrrz8j/7TR9Zn8GYLz6JDxi8LtlF3Ph1UYusppIHDLO2IiLWE957fPCDH1zRNCdGQGS9LIUEOFoaWjwrDyt+aBMUyp/fDwmc5CZOgyUkWkmhCj3sQ+0dernVBEi8/Lw9JUXeemHfaLDKrglPZJtpGxl+jyAFovIe97oDDG9cqI/JfoeWtyw72XORqh6yH3k5QoJOSyCmjQurzbT2ld8nFdpmpM2GUt5vK5QJCeW0MJS3FJhowp0mIVLTvVD+JFxtEkC1AQmLtDbVBJqW8CckRKL71rMK2Njro3xW8TaSzxnrGaS9GzQJTjRhXdM6wr1QyrjO+9rBCrfxZ5WDp689U7X1USuXbIvQ2q3luZlQ2Clhgh0hKOIqOtz7k/ab1HHkptpcj8RGtmlNtkAbeu06fWp15jWjtbW0KZO7FB4JsqRbCaY62WKlgnb40L6RykaYmZ0tbBkFtiC1PqgJ21gbG17PtP4qNvqFiltKKm4+wwNzB/DA3IFl1WO9sW/uESbgGKhdkVCDCzcKD25MDYtUp0ojv+SFLEu6hZ2oEg4eqe/X8pVjuPJqXLb4od4DmJmdxa7ZnZVtIjn2KtW2UmDpXVLZL8pcB9+bO1gJiwDUVCRr6pIsHV0wxOKw31KIW7ULU8+r1VkV/G6u9TFiPJFlGd773vfijjvuWNF0o4pZRERERERERERERERERESECY/x8R4WEjJvBhw/fhzvete78Oijj+JrX/vaiqY9sQIifupqMVW0E1p+nb7L+/y6DK+dgIfS0e41sRtC5dZOOq2TqJXydENsEV4GWbfQSeQo9SXIOvXm5xsp+/y0dpw8/GhMsRC7RhtvPB2C1SeSncXjOu9rKmbk+c6xNDXmA0HzlKepX2j15+mF+rqJxaLVS7JO5PdJh8U2k7/lWmKxEnhYawxa49kqnxWnDXtJlkuy7eT62lT2lcTszEzl3UwrJ2Czp7QwWnwLFL7tWs/XjOWoH68G2o4prS81thlB83Im89F+kyrtzOxs9V0rs8XUkeyhKn4gT/lbY0bJ+lGcJqag9Q6x2ZhEnC0E1NkBkmnArxM8nIhTN+ZbY21geFyGVMeGxpEfzr9IJ69dt9hEvAzgGz2fV+plLqcxgUp9aMC8KNLlRo1HhfSY2vfdmlcy3p7OFe0jjXYnyGvtZrE+EmSVut5gruQjlb9iQ5dMFWK7rCc6ro+kZPukyGre6YiV4+EAl9TGGNVbjkdi+yQ+w8MH92Ax3Qq4tLqvrZHq+z7vR5eU1wfl5qwiclVOxszJkDWV8eGDe7CUTMO5ZFBuX0/fiX70cIMwLhm+xtLwrvBoxhl0vE0kImsoYpzwlre8BU8++SRuvfVWnHbaaSua9sQIiEJ03NBmk743hdE2qZagRubdJGSyNrVt6io3FU3l4XVYyQ2yJiQKCdGs+sj7luBMa1cuJJI2Jnrz80CLjepaQm4atc2gJuiQ4Qht+1PbBAC22oOVNpVJ20hyIZEWT5s72uZGy4/XgV8PbfStzfSowoeNDG0OhaCFtV4QrTWpaSPP48j4IeHJcmDlGxLCrBS4UEEKTLU2k/dkmbU6afOB39PWRxIEVcKSVRaWjQIpjG4rHAuNRRlXS0cbj0D9WTIbELY57weC9fI7h1z3rTVclsF6BjaVW1tXrWvae9BmgbQxwsGFIgBUb2N8FGl2WkIby6Z1h9tH0lDb+DIBwXI2sySYITflRflW95Se1qWDvQeDZYJDzcOZDEPXpaCvEg6Vwh0NDx66r2ZTqXC17tFPpgAASSnMIPWmcUAHA09s3BtZpbZFgo/yP5iQj8fTkHPBkNLWcmxzb3VSZS9zHSTIKmFR4rMqfefzysYQALxs14V46ODeKl0PV6m4SQFocS2rCXNI4DMoZ167JuuhwSGHR6reGw6rC48jItYCt912Gz7xiU/gJS95yYqnvbm5WREREREREREREREREREREUEMW2Vb389mxsc//nH86q/+Kr70pS+teNoTIyDSqNTaiQyFo/vytLWJjh06YdNOJS2mh3USbJVBy8eqP/8fOmVdaRWCJo9ZlK8sl2QiWCfivM8sdgN53aL75IFLntgSw2W9DbhqfQ7o46EtO64pP/6fx+GsH96XPAwZrLbADfzysNrptOwTjTUi28Ea+/K31VYW62gl2XQbARYDwxqLVhoUh//nacn/fO2zwvP0rXGilVkbO/SbjEWHyrzaY4GrX3LwMWmxSUIsIZmWXE/5Nb4+Untwpo7s6/X28hNitWjfrfuhdm1ipfG2I/DvvC3JAx5geynjeZHRf+0evybfW6xnqDYPZJ2td402c2uSwY39VmpJ0ogt80BWeF4qP8wLEvdQxrcxElU/+ebnu8UcKsIMWBWaalnNmG/Dh9IZlHFga4QbB/ZI4JHg3Asvb9Gy7dFmO0ge5MjjWfUbg2ucPVSU3VesGtluPO/Dh/bhwUP34cFD94HUsyqDyKgbQX744J7qs15Ifd1rFy8n/y+9lVkGy3kbkapXdU8amWZ9kuZLQ6whMjCd+KzGQJMqgZLRRW1PYSV7rdan5Yfm4VAfK/MhhGq9RJ2FNBQO3BC9r6lGRkSsJX75l38Z//2//3e85z3vwVe/+tUVTXviVMz4d20jYtHPrfAybQ75IsZfpEIv/fKFz3o5D5U5VEYrTykMWw1oNhlkvSzqvCZYs9KRbUjQ6i2vU1zarK2ULaZRMN/rwSnlld+bBISy/hpCc0PLgzY2pJLC1WK4PSJgWCjIy0Zhrc2sVj4eTo6PUP2a5rMmGLDG0KRCW2+s9cpaQ+g7hW0jqNCuafOxKQz/r9XJGgckBIGSh6wbz3c11khujyg0H6x1QQvLoY1l6/kUqqd3rhIctbHvtlqQ41PrX35dxl2OEElLn0Ouj7xstK5LFWetTpQGjL7W1mjtmanBek9oU8e27z+ThhRL6PqFSq0FALKkeEUmAUOSDzbh0g4KbWa5Wg7f/PLNbu5SkBwm9X3Wz7lqH4Y8TFEcuXFPKlfk9TJxaBtnbQNurkvwLGw+FG8lQGp8mgpfozFap6dRCBDqbQoU7RMSHJhqeySMYOp3Dx/cs+LCsiY8eOg+JOVY5WOtWB8GamRctatmw4mNWcfGj8PARpBndn8AEiDpKnppPlB3u2DXRXjkwD14+OAeZOk2AECepLU54nxeU+njeVDeYGUpbqbVHKkJbqu+IntCfHzrqmJ87NeEVn7g7S33g7h8XA09e9DellVExErjve99L170ohfhn//zf47vf//7K5buxAiIIiIiIiIiIiIiIiIiIiIiVh7F4cN4KCBtBnZrG7zjHe/AF77whRVNcyx6+Pd///exc+dObNmyBVdeeSX+7u/+7oTS007F+f8Qo4hfo+8WHZvuy/AaU6eJ5SJP/OR3WQ+LVcQZETJPq8wrjZnZ2Yo6L8sl603QmF4hZom8Hmpr7RTaymMtIL18aWWxxuqoY5og299ifnAVGM4aoD4lRhH9l6AyyjFN+VCaclxoZeNlt9pHMl+aMGr4ccFKrZEaO0j7Tf8l00RbA+V80lhZFlPLmre8LE3rGC9Hm3ERGmv82mqxZmS6FqNFg8UK0Z4XPE1tzWvKd73mB6nBAfqaTf8t5hMfa6GxJce1NtbkNb4+EjON1kHnfbVO0kdCc0zAP8RI0sa89vy02D5WfULxQ8/ocWcRrcT6mPo+Ut9HJ19EN18o/mcL6ORL1fU0X0InX0InWyz+l5/EZzV1n9T3kdL1vF98amksVh+6XnyW0M0WMNU/jm5/AUk+iE/lmeofq/5P9Y9huv8Cppaex9TS8+j2j6HbP4ZOtoBudrz6LT9pvlR++ux78en2F9DtL1S/B2plA6WifjqFsy6+YsX7cSo/jqn8OKb7L6CbLaCbLRRlRIYUfaToo4Ol2qfrF6rPdP4Cun4RXT/oH94vmkodgdszIdW60CZ4vTbIDx3ci4cO7kUnX4Lz+aB+efkR7BqAmE++YprJewBUVciB1zqvtp8TTKrDh/bh8KF9LH6xJialIWnOsNPYQw/MHUDuUmSug9yllSFr+lyw6yLTyDhn9VXrFo/NVCRlGjV1PM5MEobpiT1UzXHfL8ZZaUQ7YuNgpeUO44CrrrpqRdNbdwbRn/zJn+BDH/oQfv/3fx+ve93r8Ad/8Af48R//cezbtw/nn3/+yOnJDQNdI4Ro2TwOT8t6SdXiWJsXnqaWp/Yip70Mh77ztLSXZ7q+VuoC0mMPlU/7br34a3XUXlpDL8oWqK3WUr2MVF20PpdjIyTEaBpX1kahadPHvS0NlbtEqL14X3GbK3zMWRt0rd+1uRwa4xRW2whraWh5jxtWco202k+OF/ldS0PGlWG0/LT1VOavldXKKzSPQnlJoRK/vxbrY827olImumahqW+stZXH19Jr87xaTXBvk9qzjf/WxocM3zSurOcRT0emResjXwfbPkNIxZC+V3XG8BoZEnBZglHrXUT+DtVbq/s4Y6XWx0q4k/dBno9yl1f1p803hSV4FCo6uUuBBJXKD20kNbUvUl0DUAuX+AwuH2zwaYNK6lUOOeAHKkSOVN68B3wOn6S1fKp7AMDLkaRFGDdgAlBatbI6V2zUky68KwRDAFZNnWr7wlMAgCRbQp520U+nkSVd9JNuTSBD5ZSqY0k+6Jc8YepB3iNvIeyp1AP9sAodF6QM5l6Rx1qql6X5QBhh1YirTNXs/9TWwRxQ2oSEJLwt+G8+tih8Icgp+uO83ZcCAM656BUAgO/NHQQAZEkXlloZ4YJdF+F7cweRu7R6f+yUqmsX7Lqoln+OQb97lzY+q0hIRC2Qoo+s3AIPVAizcv6WdYWr1M0offKoxlXqkk2mYsaFqeuN5ZRjpeUOk4p1ZxB97GMfw8///M/jF37hF3DJJZfg4x//OM477zx88pOfXO+iRURERKw74hoZERERoSOujxERERERbTGpzwzvPf7P//k/uPbaa/FP/sk/wbve9a7aZ1SsK4NocXERd955J/7Df/gPtetve9vbcNttt6lxFhYWsLCwUP1+5plnqu/WyWIT40DGldebTnRDNG4rrabf8pQzVA6LRSTvN7GnVhLVyTjsE0rJLJBl5WElrFNTfl/GtU5U1wrSaDOVQTIkQvWR4ZZbdys8nY6fiOFuYiFxdQrOQJpVmGVambT523TKz6+1ZRqt5bwYFaOukW3WRyC8Tsl7Vhtb489idMg4GpPBisu/h+Yx70/tOWDVt+n5sNKg8S9zXE7bh1h4Mp2m+9pzZq0Ylpr6FWedNT3feJkt5pk1Znl+HNY6pBnu1phAGohFpKmryTxDYz7E3GtiX4XqH3oHGjes5Dukd0llhBog5oQDKvaOr8JIeJdUrCG4AcujYhl4DzgHEAMpz8qxSHlmQ+GlGhRngiTZ0mCMMEaJy/Ja2CHPZJSeMJ5dxYcfhCGmRtIFsICsMzXEqllpvPiyQkXi+M3/C0unnYlkajv6nS3wXYccnBGUD9pbXKP+IXYRlVmyuSS40WY7TH098HB46YWXLbO2o+GRA/cAANLSK1juUvG8GDbGPNS3/L8f9DVPJy8NQXN2ETcUTQw5ri5G6Xo4PHjoPuQuxct2XQgAeNmuCysPZw4eD8wdqNhAEvf35gCXoJsv4MFD96HLyvvA3IEiP9fBy3ZdiIO9BwEA0/5YWV5eN91bHa+75ywp7rFM6X+umkf1jxgv8HddAJiensb09PRQuOU8MzYK/u2//bf41Kc+hauvvho7duyAO8Hn9roKiB5//HFkWYYdO3bUru/YsQNHjhxR49x44434zd/8TfWe9qKrbRS08PRbg7ahbxvXKptMSyuPJeTh97T4tMHXXhLX6kWPvySPYk+ijUCO0CR4kmHGgTbfJPji15s2rpagy2pPLU2+8SJowpu2fUL9LlVoJPh9rY5NQtBQfXh4axNtCSbHDaOukW3WR6sPm4RvTeugJnQKbVi18KF+1spmrRehtUGm0XZsryS40KUSFrH2XK7Qrmnd09K0+pnur6UXs7YCx5DQl4dpEhhZacvnqpa+Vk7vXFC4TveoPek5LcvH40vBmVWW0LtJ6F1Ctoc1d8cRK/kO6eEK1a98sGGsq4KV7r+TFIkiZ6hUcLgtGyQDOya8DxI5plI45APX4q702lUKlqTAh+IV/TXwQjXskay4V21qDZWiWh1cWhMUJdkCvEvh8hRTi88hT1Z/27Dlrdfg2Xv/HgCQlWptVXmZhy5+jZAn6ZCAwHzXYjZmPI19w8aNdwngB/3sfJHXWnkwk3VKAPRd1y6rEs8SbhYCy6QcU6VwqFSblIKnQjBUpKuPy6TWPw8euq84GCU7QA11JMESjy/rNd/r4cJyjby/N4eU5mYp3KLZxVXjBnn4suwpUt+vCb9c6f/Mu8LjG3nC40Ih6WWtuL/uyjhrirXcSzaBynHeeefVrv/Gb/wGrr/++qHwy3lmbBR89rOfxZ//+Z/jHe94x4qkNxajWkq5vPem5Ou6667D0aNHq8/hw4fXoogRERER64a2a2RcHyMiIjYb4jtkRERExObF4cOHa+v6ddddFww/yjNjo+DUU0/FzAoe5q0rg+iMM85AmqZDUrvHHntsSLpHsGhjTWwS7WRMY1K0PWG2TjEtWrt2n98LnYiOwqoB6oY+eRpreULOwQ1zcoRYXVxCPcpJpsZE0Bhaa9kWsu4aw8c6Bdb632ITyHHWlnXTBqQ21qau3PgqPynnYYjpBuhsCm1syOvWfOXfQ6f/cn0YR4y6Rlrro6yjNQZCzAs5t7S2lWmHmERtx6tWLu2eNb+b2Gmjrq8rDTLGGcq7DVOqLYOEpyFPArV5s9rsoWptCKxxsnzyO4dkBlpxQkwsK/2mNXOU8dObn8esWPsofc5C4u3P11E5x3j52jDRrGejVqdJWR8Be43MXAdZUjAyiCXA2QVIClUTX34HBmwSYhpVajfl/YI14QAnx95AncmhYCokeZFuTgwmMdSK8CW7J0HJSMoBl8IjtZ/pvjTAbKlXDbGOynmQk3HegrGT9heQdaaR5GvjseklL38NAODhg3sGak9UxkrNiepLHZJX6k9UdsB+T/IYVsuq7kk1PaF653wOl/tV8ebGQV7BumSI22cD716WIW3OGmIGvSXTp+61TdnPlAwcS+1OU+WSanzcKPXhQ/uCRoVzl1Zr3/29OQDAzjL+/b05Ne5UdgxLyXTFPHpg7gByFMaknfc1Y+UoVdGIFZVLdhRXmXO+YhHx8UNjkcfNFPW+iLXFKaecglNOOaUx3HKeGRsF119/PX7zN38T//N//k9s3br1hNNbVwHR1NQUrrzyStx88834mZ/5mer6zTffjJ/6qZ8aKS1LwKMJdUKCiaZNubWpDL2ISYSEA1q80Mub9sLXtDlYD1gvuQRLGBeqn9U//F7TJtQ73Z7ESkMbV6EyW0KQNuFlOB5G2zhYm3aJNrZIeDs67webnjJdEjR59tvKQ1OTpDCavRJZl9B1Od9HEZatJVZyjdTGSZPgoWnOtRW2qC+fLdYpS+hhpRuaQ01r6KhC05WEtj6GhGH8txbGitNWCMV/n4g9sjZoEmJoYWT4pnYJ9b02F0KCU6ssTWq1Ml25FsK5Ic9mVh5AMU4sgV5vfr5W3rbPiI2GlVwf89Kui3N5TY2k5r2ptBFUFzK4arNI/71Lqo08SO3FDdq6EiiVNk/SvI8s6RSe1JLiNHsINDZ9IR4hmyuVEITKyMoFDIRdTlEvAjDwfCa8VFUe1XyOJFtS464FpPrWQwf3VvaHhgWiSaXcRGpEQCnoKLvM8vA1iCOuyXYUApAj++8CgFUTFDmfo59MIUmK/qMxliWdWl2kR7fBfB9WydNQExY12GKSaco2seKet/vSyh4RB3k6cy7BztldAICds7vw4KH7BuFLz2Y8PDA8Psi+0cMH91Rlq7zUuQQvLb2scWGVbJ+kUlnT6+Fdgpy1fb7+DsHXFN4XKnjjgFHLsZLPjHHDz/7sz+Lzn/88zjzzTLzsZS9Dt1tXQf3Od74zUnrrPqp/5Vd+Bf/iX/wLvOpVr8JrX/tafOpTn8KDDz6I973vfetdtIiIiIh1R1wjIyIiInTE9TEiIiIioi0m9ZlxzTXX4M4778TP/dzPbXwj1QDwT//pP8UTTzyB3/qt38Kjjz6Kyy67DH/5l3+JCy64YKR0OAtgFPUCmYZkEfHrMixPT57UWWwV7RSv6bpke8j0NFp5iIGy3iAj2lab0netHa2T4RDDQWsXedq8miwirW8lQmOM4mrMI2vsaGXQ2BWheG2YA6F2I6YPz597ciOmhJXHjOHtjPLkp+zaeLHYRPy7xgYcN6zUGkloy8Lj93k8i3FlxZPtq63VIaaIxRCxWDEWW85iEbWZC2sJmjfWM4YjtLa3qYu1nvJn2VqxLGV5LDaPtn6FnpUyfBMDSxs/WjuH2oR7gwQGa1yIFVZTxy2ZWzyuhFwfOeNrVqy9oTpK1pI2n8btHYJjxd4hfVowBpJuxYiQBmxJkykRXsCGWBelCgqxkbxLh9qV1IQcfMkeygcmk53eD3Sv8tBVFBxSdagI5wZhAMBQg+FGiIu+LuNni0CaotM/jjztwvnCQ1jWmVLTWSu89MLL8PDBPcF5Xfw26tvAIBoCqZQJZg6Ps5perZbSLQCAxXRrwTCr+p6tY2QafYTnFzdGPcya8nA+G3j1Et7wZDsRk61i6gAV84d7LLu/NwfvOsPvdRXzrt6H5+++BI8cuAe5S+BcXnky8y5Bb34eSenpTxq2BgbMoocO7oXzObJyXlPenFuhsefov7wXsfGx0u/U44IvfelL+Ku/+iu8/vWvX5H01l1ABADXXnstrr322hNKg28ONYFCSOCjbSKaBAryhVS+xGvl4elbL1zWJkbGtcovw/OyjRPky622UbVeAELtw79rwoJQ262GKgWpEITGofXf2uRSufl/DdYmPTRW5DXeJlLYA7SzT2LNpTbCSy5kIpBqBo+pbfKt+mpzeZw3QMCJr5FWGzStUbINLeELv6cJg6zxL68RrL5rE86aE9q84/fGaQxotrvk3Nd+a88HQtO6qbUJx2qtj5q9PC3/0Jpnbaa1cavFsZ7vEjId3ibUV7Pls40LeLhtNa2cPL4lGNPA10cej9q1jeBM2oDaiFiJd0igVJ0Qrq6rtvODjaS0XVJLQ2yqq408E/rUhBRleA8PgP4D3tU34tKtOFA+111e96JUCYaS+hphdO9g3Ij0y+tZOoU0WzTrux4498LLKxUiQLz7BWzcFGGH1fAqhFzcg9SVhGCmHBc/2PdtvOTSH25Zg/YgwYsmlKH7TfBwNaEmT5vGqnMD73s1e0vM5X2TMIyXVZaZbApVZeJ9NtD/Gy67c5UADKy8Sdu61+ZygtT3ccGui2re0Xj5ZZxK3VTUcXMjGSPPbcsrx0o9M8YJ5513Xis7TG0xLj0cEREREREREREREREREREREdESH/3oR/HhD38Y3/ve91YkvbFgEK0UrJNQ7TTQOp0Lnbbx+yGGkfxtnY62PbGWJ6dt2CNWWcYJodPqEOPACmMxunh+ozCwVgLWabDGnrDYU9bYo2tWeEKIccB/y+/ylFyqInCWg9Z+zhfnUVZ5+Mm7d85kI8nr5KWPe1az2sXCRmEOrRQsVqS1vmnjVrvXhs3HrzUxk0LskCb2UGgutGEajSPTkqNpzDY9F0Lz3+qv1Ya1FofW5BALyGIFWfG0/GW6GiOO/5ZeGSVrlNRqCfw+Xx9leUmNtknVTFs3pQfJ0PuP1k5yTRj3ubEyqHvJAljflMwinxRto7ExOIgVlDMjyeRBqUg3GQqfuxSOlYEbWZbhc0oTOeCTgp0EYiwlbEyRcd4w80Fj3RBDIEG/jFd6w1pHg9UcQywiRXVMM54cYhhJta2h+7L9WJuGWGUnCmLuuFKlqnZPUX2rz+kBoycpDZVbayyNU/JeVmMYUf6iXaz2pHKSMWifTFV5FGkX6eSMjeKQozc/j262UOWT8PQqlbgUO2d34XtzB/GyXRcOPJ6VBq45ziuNUt/fm6vuP3RwL86/8DIAaM8kkh7bKnU6B752RESsF37u534OL7zwAmZnZ7Ft27YhI9VPPvnkSOlNlIBIg0Yxl/+tl0T54iY3NyEKvBbHEk5Y5baEUbJusswalZ5fX22vNCcCS0DC2y/UFm0EJqE8Vxpt1BS0F3G+EWl6Obc26nJDGWoPLaw17prK1CQ05Rsn2sQ01bFma4Nd4x7NQoIBOSdGFShNAuRa0lZIZm2mm/KR1+T/JsFsqD+1Osl6aeHazMe1srfTBtY4bqpHqJ9CbcnBvWw19dWJYGiTYjy/ZNg2Qoymsdv0bLU2XaF0NZVcK79QX4W8oWmo2fVwbtjOB8JrvyWca7NGTApcoS9k3ysxZJuohFQd4wIiV9obslAJlcrw0oZO3QU3CRgdnCvtv4DbEqrbROLCJh5GrSfZX0qYO+/SFlFxf+M8K5tUgaQaFAkvgnGY5ytf9ldSCmAe3X83zr74lSda7Bq4KlmlaqWVi9ZIQ8hVF3CI6y4ZPGMojkMlJHLl9WKd5V7BnNpmsowOAwH6/b25StjUd8UGNkUfQGn7x9c9slVldQCpmDl4fG/uYK1/LY9jhMRnAw94KLyc5S7F+bsvxeFD+4bajtqmmkNinldqdPC1tWEzwFetuP4Yl3KMA/7rf/2vJ2yYmmPiBUQRERERERERERERERERERERk4KbbroJV199Na655poVTXdiBEQhynSI0dDmFF1jFGmnbdrppowTYi2EWA4WK0kra5tyjQO4JyqtfUJsKH6f36PrBKvP5f3VOhWTRpa10+RQ+fg1axyE4vJwISaRxj7g33kdJLuiiWVklRdoVi+z2oFA5SJDsFpe2hgKlXsSYc35JhZJE2NFCyvvh1hcWjlCafDrkjXSxJ7R1hGNKTcu6yNHW9aQteZzhPpJzi0n4q00u4qeAbztrXWf/+fheD2sZzX/Lv9b/R5iD2nrtmwbqYKrzQMrD1nXtm2uzQsen7e1lpf8L+9PMgomzoChwU+mE+Qms6jNCfbAEHWdyQEIlkvJ9DFZIsRCKtXVyDua01TEXMLG1PLMjXqXIE86cN4XnszyDK5BvW4tUbUHBuyfEGtIY4hU31k6VhjNwHWCci3J81XhMlD+AxUzg52rqgkO2qdgS2W1ODIfre0072gDI9S+YhFV+SmGo71L8OCh+7CUTmNWqIH15ueR5IV3tkqtrFSl4+VJ8qxibLlyxOcoGElN7CEqcydfqsZIXrLHHjx0H84v1dBC6mZUD2oTq64REWuN973vfXjyySfxYz/2Y/ipn/opvOMd78Bpp512wulOjIDI2oRoL4dW3NBLoPZCZ232rZesti+kmiBAQ9OmJpT/uKiZaZuati+n8mW/qY+sMbBWQjNLyENlk2GBYQGTtem2xryWdtuxot2njRDPW4vTNNdkHSxBkbTvwa8BA8FQb34es8KbkIXNJBgi8HWnSQBJ1/h/LZ4mkNHGo7U5tsJb66A1Ry3BT5NgNfRs0MbdekCbY7xcUo1JEzg0tY/1HONYzfXRWu+tsdG05st+1vo3NKbkHGgS7HBoa6PWctZzzxqj1njkNthmDRtIJNgD6mqDWl21Ntgsa2XC7KwARb9JTz1NG0LL9o0MM2TPhMUFwkKnYoPLbBu1mJouYCOlrobkB+WoypUiQVapmsEt4cl7/g5L3W3YccmVzZmvEh48dB9Spt7UxrOUVIcKCYNkGG6Th4QMlQoeULlRX2lwFbPE5zX7V0VdkpqQxkJRZvkuWPfWRa7t8yTgpa8meAyXufpdljnt9ys1L8KWKkxxLUs6pVv7Yu3JkmKbmvgMzvtqnuYuRer78N4hKfuEbBE5nyP1hdpaJ1tElnQqm0NH9t8F8tpG6ZKKGa8VF64NLuoqZ2k+PkLTtUBUMRsvzM/P45577sEXv/hFfPzjH8e/+Tf/Bq973evwUz/1U/hH/+gf4WUve9my0o1ezCIiIiIiIiIiIiIiIiIiIiI2EF7xilfgP/7H/4hvf/vb6PV6+Nmf/Vl85StfwSWXXIIf+qEfwn/6T/8Jd9xxx0hpToyAKHQiqNHNNWhsE/5dO3lvYqNY7A2eJn1CJ5yhNClfq4xamdeCMdMEOv1sOsHm5bWYCRSX9xmPY/W9jD+qYdDlwDq9tcrIWTXWSbl2T44J7beWVmisydN0Pnad95idmcHszEzl9Wx2Zkatk9Wnkv1DaRNLSHrk6c3PV/Hne72KGdfErrPqP8mw1kaLVSfHibZ2yDYMMY5kGbRxKZkhTewhmZZWH4v5Idkl48iUsFhdNNbldf7R2HrWOirbS1tXtefLSoLYMW363FrfeHn591D9mtLXxogco9a6qo2tmdlZzMzOqowgnr617styUjl68/Pozc8PpSmZcfw+nxehubEZ1seiDXLBqMlrn+Y08iqNoU9DOub1kGFi4/RcnvC3YdcU4YbjDFSUUsCV3tZ8jumFZ1uluVo4f/cljWFk/w31TaB/ZbtbbCNKLXcJsqSDhw7uXYHaKXXRxmVZhyTPhtbp+nxOat/pI0HMKD5+qG5NewdpoL3G1OLrI+plTPKsUjFLfIbzdl+Kl154GdK8j3MuegU62SI62WJZR+orzvQr28BnSPOl4uP7tTZK8z4ePrgHDx3cOzAcT2UQ7Xre7kur9NR+iGplEWOGubm52u9zzz0X73vf+/CXf/mXePzxx/Gf/tN/wve+9z28/e1vxw033NA63YlSMeMvXNpGE7DVmOQLIb+mCSxCwgbtxZy+hzZpTRtWuQmSaWj1kvF53PVWM7NevLXvoU0ev2+Fk+nx+zzeangvCtH6rfFB37mHLllWDXIshcaFtRFrI7iy+kmqvHjnAJFPqI01AZ1Wdq5iI8sr26ypTpth82PNDTm/QnPIEjKE5rCEtmHW+iI0x7XrWvpNwiqrfDL99cJ8r1e9Ymt90lQ+rR+s50boWptny4mA1ESpvlY9tWdBSBBoxWvbJk3jOzRfrLXHeV8T7Fk2gWiN5M9niidtHcmxHnJxT8JF2evWnF3vObCe0IQyqtqJFjcg7NHSpHtN3qA0LFfFoskbVjGuCrfiKO3XeCTFsXIGuLyPx/bdgTMvfdWy8j9RPHxwT9CmUHVNURPS7su0tL4e2H9KhsLnpe0ocqu+UshdiqRU/SrmaelVzHsAxXcS2gEDYdDwO2MCL+ozVOfSNk+VRtkGhZc8fexraQBGX9Se1QMBD8eR/XeBrGo9uv/uofseDlnSwXm7L60EPnzuSFtShe0ihyTLakKxsy96BY7svws5UjjkldDs8KF97Lk7qEPubLW7NvN0khBVzMYLF154Ic4991xcffXV1YfUyrZv345//I//Mf7xP/7HyPMcTzzxROt0J0ZAFBERERERERERERERERERETHpuPXWW3HrrbfilltuwQc+8AEcP34c559/Pn70R3+0Ehide+65SJIEL3nJS1qnOzECIs4eAFCdRIaYPjwePyUMnT6HmBzWiaMGi5kk89ROKa30mqCVdb0gmSIhxlSIxcDja/1hscLkd5nPSoIbDaXTcgL3vtXEiJCwGB1NTCrtmhxnGgtJpm3NHS2vpvkA6B52LIaANMSqtYfFNNiMsNaP0LzhvykNnpY1/jTIsWUxheTY4uVvqo8cgyFGiVxfZb3Xe7z05ueBAKtDY35xSIYLXeNpyLAyPs9rNdtDro9cbbRt/Xm5tbVJxpdhm1hFPJ4sQ9N8seJp61NojaS2sdhDfH5pz5gmhOboaj0bxxXcMDDBu6SVUWMtHQsW62GlYbE1invN85sMFxdMkhR52gUAdLLjK1/YFnjkwD01tiFg13FoblttHGgC+72zblh8NfpPM2JOBpqpbGREXLKHBuUs5jRnGsk6eOfqKmbcWHlpkFuOVwmpyoZSxavN+59adyMfUv96aWl4GgAemDtQYzqde+HlBctMGSPeJXh0/93gnd5kWJ5/j2pmEeOEH/mRH8GP/MiP4D/+x/+IpaUlfPOb38Qtt9yCW265BZ///OexsLCAXbt24cCBAyOlOzE2iAhcIDA7M9O4aZHfrU0UT5/+axunNjRt+eKlvYxpAgNLUCU/oU2O3Ny1eXFcaYQ878iNm6wX/64JE3ibclgCD5n/SoNvdrxzNcGYZmNCbjrIVgVvB4L2Ai/rTnmE4nNo44r/lsIguaGwNqptNt5yvvJx0qaPrLbhaWjjY7NsgGTdaWzRPR6O0Gbj2rbttM2wFM5oQj9r864JebT8ePqhtLR7a2GTTIIEpdqckm2jCcXkd9kO1hy0hCWh+X2i4M8f71xNJYpsmVn1CMF6PvB7TYIc+i/bX3uWaO8PoXhaebnttlC9miDbRhO4ac+DUQVWk4YhmzNSFUmxZ9M2rRMNx8PKjxbOil99F+Ox6Rk4sENUbBlyl8InKZKs36rsK4lH999derTS27+tyslwf9pzdPi9pm6rigtWVgM1VaekEARlSafyIue8Z31UHyEWuB0ii94SFgAA0x5JREFUWb/cpdUHYPVjqmeanSttXrRpE83+k7zPBYDnXnh57f735g7W8iE1vzTvQ9paGrbHJPq2xZyUNpxCXgInEfpKtH6fiAG63S7e8IY34Nd+7ddw3XXX4dprr8VJJ500ZKeoDSaGQRQRERERERERERERERERERGxGXD8+HHcdttt+NrXvoZbbrkFt99+O3bu3Ik3vvGN+OQnP4k3vvGNI6c5MQKiUU5/Q/Rzui9PGLUTbu2knecvT3e1k9im0worD+20XaufVqZxgDyBDTFQKFwbJopskzZtuZptQgaqm2CxK3rz8zX5uNbvoVN/Ht9iYIXaSGMAtT1952m1NYausZ+a2i/Uf9rJvpwH4zQvVgva+OJjo6n/Qv1urTN8nQyNpTbltsrD07fKqTGJQus4Z5isB4PCYjkBYaZr6HmktaPF2uJxZPuttBF/Upuyys1hzdOm9tLGHQ+njXdtzPK1M/SM5dDakDA7M1Oxe9q2q1QzkyrKTWNAm5Na3SUmfX0EwiwATa3EVLNZgRNtTa3IDBsw0MvTGvwOqcklQ9e1enqXIksArMf6CG8aDG5ULwsYqLbaYSg9Z/fxy3ZdGCr6skCqZPCFIeXcpaVKWbF9G4xbUh8jj2NhVSjnyTBz+UzR1MswML5dGfc2xiTPa0g102f6OlsawOZxOEuJkKVTQ6whjpftuhD39+aQAzXvY2ddfEWhSkYqcg3sIQ1t1MtWSzV0XOG9g/fj8UwYl3KsJ974xjfi9ttvx+zsLN7whjfggx/8IN74xjdix44dJ5TuxAiIOKxNhfZbXrM226GwoZfvUBqaoGiUFzFrw6Vtiij8uGyGLcFQ0ybAuhe63lZQtlabQbkh0MZR23paQkO5aeb5yLihDfYoZdPqCYy2qbQESdpmRv5vEjBq5dc2SJMIq37WuqTFDW042+ZnpSPjWWtwGyER/x0SSFkCkqa1aLXRRoDRNJ7ldw1WnUNprhVC/RQS+oYEJPxaSNjZJJCznq2jji+KN4onUWmDSOaj5cHzsu6F0pNtMqmgzaomlKHrtp2bQbxRNouNNowsNSpRxlHyHIxzpS6aq3elDN45JHmOPFmfLYTVTxLDc7zlBt+w01ML73M4EmKUQpDVgJy3Hg65Sys1Ko8EDqUKVs3rnOZFbFhtkoRh9XVpuH2p7UwBaMs8q+s14RBfgwd5k1c1bmtIw/29uUF4cS9PUkPVbNCevH68fP1kqlYHsy7RJlHEOuK2227D2WefjauvvhpvetOb8IY3vAFnnHHGCac7cTaIIiIiIiIiIiIiIiIiIiIiIiYVTz/9ND71qU9h27Zt+J3f+R2ce+65uPzyy/GBD3wAf/qnf4of/OAHy0p3YhhEoZNwiw7O41o0dBnPYg3JNLTTX0lRb2IzWfUL3bcYRTIPXo75Xm+kU8wThdZeVN5QPa1T7iZmQxODajVPR4n+T/mEGDK8LNbJdIjtJj0AccgxYTErrPa3GB1WHxBWQiVFq1eI8UDXQwwTjqZxN0loai/+vWmeWL8txkdTfiHGjEw3VJcmBk5b5hOFIxWolVavsmCtAfIaL6css3aPpy/TCT2vVhPzvV5NzVFr49Dzku7z//I6IcQe4mFCzwir/ZueRdrYXc5zV2sfUlWz3l1k22njQ6pCb5b1kKMyPNzgzYh7SqJ4/H8oLs8rWBZNraulx6Wm9Dh7qE2+FvKk8GT2xN7b4PIMp7/iR0Yq01phOe930gB1jSHG53E1BrKaatNqoFAlBM7ffYm4LlS7XILE58W6hMF6Iw1rA5w9oz0nhhlmQdYWMZiMuIN1ejBfqmtUB0/MIcrPNbKHAGDn7C4ABZNIlvHcCy8vvN5pTDihTifvUZzzd1+CBw/dNxRGGm/fLBgn49DjUo71xPbt2/H2t78db3/72wEAzz77LL7+9a/ja1/7Gj7ykY/gve99L3bv3o29e/eOlO5EjerQJtESQnChgfYSxV/8NCGQlp71Mq9toLRyh17OpJBDq6PMS9ZBK+d8r7dmHnusevM6hIQ5vC+aIAUE2maxScixXIzqhYuXR7YFv0+QaZIHIPnREBICtBFGyn7SsJIbasqD0gwJFeWGTOv31SrnRkHbzTYJNbU1in+scWMJL6ywfMNsjXW5nofqo63VTYIEfp2XYT08msl1epS6W/dCAiXrObKcTdaoaFuP0HPOGqd8PdSegaE8tfbR1hVr7ZX9t1rg80d715Bl5nXnBxmyrtr8n2S08WAkN82aCpKDR+JzJOXGvOYxK+CRzMpfhpPXQh9Amdt0X3ieauupzTuHPCk8XWXpFB7f+81gu60U0mzRbCtt4zo87uveuJrABYFcJSopfyc+Q5r30ckWT6xiCgpX7GHkLoVXtnLOU//qwiEAVf8neTYYC/CFlzgxPiwBS/Wd7Bfxa+Brb33sa5B2wEJ2hzTsnN1VCYtq5XSFIChP0sHHpbUyk7CoaM/6uAgKh8ZIWBIRARQCo9NPPx2nn346XvSiF6HT6eC++4bHcBMmhkEUERERERERERERERERERERMenI8xx33HEHbrnlFnzta1/DN77xDTz//PM499xzcfXVV+O//bf/hquvvnrkdFeNQfS9730PP//zP4+dO3di69atmJ2dxW/8xm9gcbEuZX/wwQfxkz/5k9i+fTvOOOMM/PIv//JQmDaw6OT0XWPPhBg8Mj6Pp8XRTgZDLBiZtnW6pzFKrNO8UByer3bqSWjjcetEMTszM3SiG2IjyJN/Xl7J/mhqo1FP25cLSflvewKrMXI0hpr20cKHxp41Dnk5tDBa/7RhLa0EOIujiSElw1hzgZhXa4m1Xh81WCwH+k/9zNtHY2Ro8az8JOT4lP2rhbfmk8Vqk2Vumo/yPk93LdbHECvLYsloZQ3d0+Y1/y77caUZJL35+UptNNSnHBqTymJRyesWY00yy0apc2iNlO8bWporpdbN5ycfn9Y7ifxNbWA9G/izbK2wHutjTQVMsG+GDNySag5jD4SMVCd5NmASBRhKku1jPVOHmEQNz8Iag8Nik4zgOY2zcLJ0Cr5kYzyx97bGuCeKxGesLjZjSmJ4jbBZRCHWDL+elGVIfIYk759o1So8fHAPHj64B3mS1usqyvPwwT1lXerqhzwOsYGaMGAcDVhEUm1OaxPJwAnmUWNjCfUymeYKqW09dHBvadh7wBbSvOBprMDQuGpb50lEO97i2n02O0477TS89rWvxe/+7u/ixS9+MT72sY/h4MGDePDBB/GZz3wG11xzDS644IKR0101BtH+/fuR5zn+4A/+ALt27cLevXvxi7/4i3j++efxX/7LfwEAZFmGd77znXjJS16Cr3/963jiiSfwr/7Vv4L3Hp/4xCeWnTd/8bNezuRGgYeX9GwtvryvheVpypda7QXXetmV6Vj58/D8mnzx0zYB1oZktRDKTwqDrM0gbV5hbEot4YhMe7Xq3WaTxdXQ5MawTbm0jbuWn0xPzg95PdTm2viU+a202pasC9nMoE2WtomR44hcQq/1ZkfDWq+PmgBQWw+tddPagDchtPnUhFHWeA4JnkL3tTlkrY8hASjHatpso3HcJPiQ/+V9qz+tOdzUR7x8KzG3285BEniEngnaOOZx5DUtjVBa1ljX1mjr2b2a4GsglYmvdaH8rXYMCSHXAuv5/ihddMtr1T1lY+JLL1J14Q23UWTYOzHGEBfahObMoHztN6th9bGwi/Th8A5ACvgMP7j37/GSl7+mddxRQe3u4AHDC9dy0+UCwVq/cVfnlD+zs0Pfn9h7G1582VUnVA6eh4Qm6FG97lWCmNHsIjnvAQfU7HBpAhDm8r7WH6xMI9nJqp43adWP51z0ipHKboFsGB0+tC/Yrto9LiAjlTSg6PtR1BQjIlYT//k//2dcffXVuPDCC1c03VUTEHGDSQAwMzODAwcO4JOf/GT1gL/pppuwb98+HD58GOeccw4A4KMf/SiuueYa/PZv/zZOOeWU1SpeRERExLohro8REREROuL6GBERERER0Yxf+qVfWpV019QG0dGjR3H66adXv7/5zW/isssuqx7uAPBjP/ZjWFhYwJ133qnqzC0sLGBhYaH6/cwzzwDQT6EtpkPomnUaKdO02Df8xFI75dXYO9pvWSarTlo52zBXQmmtJjhjhv9vOqWVv0NsLpluiEUWOq1fLiyPMhq0MvPvkllklVMbc1obaGyyEIOiiY1G4PdXg13BWQtkUN1heDxRWZz3lXcfui/ZCBqzYD2xmutj07phn2A3eyHjcSTjQmNuyN8hVtOo0NLXWCUyfW0eSKzVGLGeEUB7BpAWNvSM0PKnsKE8loPe/LzK+mzL1KE+DcWxyq2x1/h1bRxbY7RpPbbKtVrsM152aXRaa2u5PmrvPqv9PjAKVmJ9BALvkC1ZG2Y4xXOTFQbQmR9t4mnlk6yWUNjhtPmYzhvZH7LcSV5nqay2N68aq8slcD4r6798VR+uMthGHQvQ21JTXVpWeRSmihqOqUtRu3u4Wh9wpova/4I9U7GIqgQUNTsUdZXsKjluHDiTNakxj4CcrVn1djv74leadV4uztt9Kb43d7A+X0r2lzWnTQ9npK5Wte3mUjMbJ9WucSnHJGLNRnWv18MnPvEJvO9976uuHTlyBDt27KiFe9GLXoSpqSkcOXJETefGG2/EqaeeWn3OO++86l6IMs7/8w03/w0Mb8yb0pYvr1o6fJMiX275/Tb1kHkTZBoyb35fvgS32RytNKyNqayH1kd0neJrL7GyXhzWZnalIIU6Wt8AdXsrVA7yGKPVmYeT5W/a1FljqmlchsY4/z47M4PZmZlV2/wQNG87vBz8P6nDSOGZNtbXeyO02uvjTtY3oXWCwxIKar+XM480AUaoH6zxzstoCYZCa4SV5noIDUP9EBq/WjgKa8XT5rG19sq0TgR8ToZAc92qgyUo4/et5798Plv3NTT1kfw479dkfeTzW9ZBW//me72a4F2+q/B6Tcr6CDS8Q5abPunpqraB1qxgGMKhoGCn5jmsWehZiyvsorS11qHlPbyWDjx1We8uah1KWzIuXz0B0ZH9d1XCZed94X2Le94SHtiW66EtBM0eDcdKeHMjoY9l+6r67ZLCto5zlbAoJFxZzsa+zXji5anmDVM/4/d5PYpyJzjz0ldVnx2XXDlS+UZB7lJkrjOY46XQzJpH5+2+FJnr1AR/1V3hAS0iYtIwsoDo+uuvh3Mu+LnjjjtqcR555BG8/e1vx8/+7M/iF37hF2r3nLbZ8169DgDXXXcdjh49Wn0OHz48ahUiIiIiVgVxfYyIiIjQsd7rIxDXyIiIiIiIiCaMrGL2gQ98AP/sn/2zYJiXvexl1fdHHnkEV199NV772tfiU5/6VC3cWWedhb//+7+vXXvqqaewtLQ0dDJEmJ6exvT0dDB/eULYxLLQGCXayZl10qyl2RRXsjOseCFmkXWyqp3Ma3XlkCyS1cB8r1fYvxP9o5VD+22dJtP3NgwEK/5Ksokshotm3FWG5awigtVn8oRfpmmdsFttZI2JUN7Or57KhIaZ2dmKGSTbSuvX3vw8Zss4EqvBJBvX9fH++XmcfPLJgMIkIDSxcuhaE5NFpqGx2LT5GloTtPxCa59VB40xp9VRIjQXVhJNc1n7T2WWzy/ZniHGDf9tPRtXCtzTltZnHFod6HcTi0irt7VmWvnIMNZckOnwPNdyfaTykBF/WUZpqJ/WUs7W4vVYaaz3+gg0v0NqRnfp+sD4r2LIGsPzpgmaClGQsdNS/Wk94ZOVUbPSkGaL8C6t2EoeSbmWZ8U4N1SCBmpo4rrRnkOqUqK/h+8PxsVK9JGHQ+Y6BTfFld7vvK8MLtfClqpbVK6CZTVsVFumXxnk1tql6Z2zppI2PIalOls9naSKI9UT1wq5S5CWXud4XWS5H91/N1528Svx4KH7avE5O6qJUTaJ8HDwfjxYU5G9tXoYWUB0xhln4IwzzmgV9uGHH8bVV1+NK6+8Ep/+9KeRJPVF5LWvfS1++7d/G48++ijOPvtsAIXhwenpaVx55fJphk30cIk2m2a+oWh6yQ7lbQkPNKGIfNEN5RsSHln1WU4dThRthWva9fYvXTpFPlTn1XghbpNm04aWvofKb/V1W0FjKK2QMCC0sVtNOO9rwsamspCnOw1NQsVRMa7ro9xMNwmWZ4RQTWtfre2bBLWWQEJbA3neHJaQV6tXKP+meSeFSas91uWY5pDPABI208Z+OfOXX7d+8+srPVd4uiFYQiRtnZfxKJyMF8qjzbNRhg0J5dcSclzw62S7Da5uf0gKh5rmxYlgXNdHDXLjwVXJqjA1+ysn3u9NacgNrNyct3FVbwk3injt+9lS0cqTlTdtWqltkfCJ1kPHyuCTgaBIQ0ObtPG8ZQnzHPJKOHRs6sSNo2dJB4nPK8EPfA5rH0z5FvVmdn4C5Q/b3bHHQH1tKOwPmenAFc8zIXAtnlcpkjzQV6sEEtbzQwoJXp8s6eChg3uRJ1OV7SJSN9PWg4iIScKqGal+5JFH8KY3vQnnn38+/st/+S/4wQ9+UN0766yzAABve9vbcOmll+Jf/It/gf/8n/8znnzySfzqr/4qfvEXfzF6oIiIiJhYxPUxIiIiQkdcHyMiIiIiItYPqyYguummmzA3N4e5uTm89KUvrd3zpdQ9TVN86UtfwrXXXovXve512Lp1K97znvdUbkxHRVvmkEWlDp1M87gyTUlb104iRz2Bbjr5DZWRwlunnKPksRLgXr1GYfFYp/kybIhtE6o/v07h5nu9E1IJIBaAVjYtbV+e5soTjVEYbTKePM3WVCy0sRliCVgsN01tbrWhzdGmsa2NrRArcLWxHusj0MygIUg2i8Uc08ZbaK21GBoyzdCapM137b/Mk1hRsjwcTestzdeVRMX2MPpDm88V6wPDfaCV2Wr3Jkbgaj4b2owLGd4aaxozLsROaxpf1hqoldvCaoyV5YKYQ8CAgck9yfFnUJvnwWpjXd4fS1WR5agicW9No7IKQu+cFqtFGl4O3Q+hLYOwbXxg5Tx5AcAP7i1VCC1vUZS/cwMj2eUlGVayi4bLbjOrzDDMMHfiM7g8w7bjTwVq1Iy53v3wSAFXGIn13hX19zke3X93zQi1hytZPMSCckiq7wHvZyHPYyPuVULg41czWL20CmyzNsiRIEFWlcNkw0nj1C4ZUjMtzYOvconHC3nBmVvvYgDA2JRjErFqs/Oaa67BNddc0xju/PPPx1/8xV+sVjEiIiIixg5xfYyIiIjQEdfHiIiIiIiI9cOaublfbTSddMrTUmDgUpzfD51ea/fbSNrlqQU/gaQPpcXzsE5zmspg2RCQ+Z3o6VEbcIOYWlnlCbBkttD/NjYeeN1kGhajROtTzaDxqJBsCI2hwb/LcSjbSo4NjQnSdFrOw2rj3mKXyLRCY3MtwN1kh8oj5xXBYltMOrT5ro2nUDytLS1mijZ+rTBybMtxqaWplcGqC7FutHg8D37dmmMrhd78PHrz8+aaKH+HGB2hcjU9SwghhgxPI2S/oQ34c5eXg1+jNVhbv9v2gWwvyaTS1o+msWw9y9o+o9YKkqnaVD8ah/JZQmE2A8j1eeJLNkjAnTcA9X7VfsswWqu9A9hhR3t1t9Z+ACUXIB+wYdh3Lf6Q63jkcD4DSvbUqGWzQOyhwtZNwbCs2qQap2VZvB/6OJ8NPmWdqG8Tdk3es9qGwgy9c/hyDJTXusefOaF65yhd3HvhTt0l6KdTAICHD+7Bwwf3oOZqnVy3O2f2gf5sTlr3GXfpzo2zV2waNjaGjLyX+eQuRe5SeOeQ+LywtbTGcM4P1Vu6u+flrsIoxukBhdkWETEBWB9+3ypA2+haL0UErg6kCYU0YYO1SdfyCb1saeXU4mppt31Z1tLXyr8aL7ZcBYJDq4dWZgqrCYy0uFZ7anloafJ2WSmvM1oZuTqJtjGVZZJpaH3E02kzlqy4PG9tY2ZtINYD2iYeQGV8VbvH+5h+b6ZNkGwzOdfovxS48P9Nax6/HtpAy/jWJtzKi9fFmvtN93k6oTm0GmNkvtcb8q4n5xi/Rt/leiXvaUItDis+R+i5cKJtIAU/PE3n/UAF0BgjWjk1WM9p+QyX4WWdQ2OLl0FrI6rPeqiZcVVK7d2Iymf1vzX/JxlS2ON8qYIygsoZoY1nHVJnCz3vi+sDw8JavqMITAd565tyfp1/1zbAar7e46yLr2hVnlZwDrnrNq47jUamSZbTJAhxrt42vI7aeqp44fKdqXAeAcz17ocDGX5O4J0HfClcAdDJF/HIgXvqwglW78r4tGseF9pzWF63DVlr40EXDPH7Uv2wky3izEtfFSznaoCr1JIxbQKVP/EZcpeCjHFX9xWPeJtNxYwLCtcb41KOSUQUe0ZERERERERERERERERERERsckyUgCh08ss/2kmrxlwZ5URbO63j6UtaqjzFlPea6sRPm7X6WUwSjX0yRJldAXhXGOiUbcvLKcPLk0vttFOLS3FI9UhDiDkiy3ciKmahPqB78kRZGwP8tzbONEZPE5OoqazyBF0bozzv9TxVprFF5aGPxh6yxrfWrpOKpnkh1w8O6/TWWmNGKYPWh3J+WmwPiifZHvJ7EwNoPVkUoeeEVp9QebXnDM+naQw0rTUrBT53Zdnkf23Nt8q6nGeZfCfQ1kKtLNYzTP5er3VFe/YC+jiw3mMIFrNl0uC8R5Jn1acaC5oqGezxOFD1GXyG8mKqLAP2R3iscOO4PI5UCZNqUdqnBl+qR+UZampa64w86SBLusiSTqmSFHBTb7gc533n4EsVsRxSnbC6LtqAh62prpXt6JMUpOYF55An6YowGsjwsfN1o+mZ6yBnqloErobWBpIBYr5bC1Ur+vB2IWZbTUWLtxvEeBcMo8oQ+RrDwSMfMmQ+XG4aW3Lc8PGU+GEmWUTERsfECIjk5th66ZQv5NYGRL4gWRsYDim84XmHNvNaWtaGXeZFQpFQ+WRZ+DVZ/pV4ESQBC7dVITdc1su83ARpG0WZDtm0oHxDddP6ldLi7bQcIZFF6ydQeckuk9yYyLJbmyjtmhxf1gZXuxYah1pZePwTtUdyIggJBIHh8W7NJbo2ybD6TxPQyHjW2to0Pum6tvZpY7dNelofyvLxcsu02ggapGCJt9dKbvgrNdyAUCOUn7aua+ACGU0gYgkRtPWJ7i9nfZzv9Spqv3y28Tppa6cGK578aM8NrW9lmhyaEEVb22U667mu8PVRW+e1uaC9t1hjc9IgN7qV8IAJjdK8jzTvI/G5GFP50BwbtOWw4IKLLWT84rdcl+q2T/T3gQxJvlR41Mr76sfl2dCH21ziApOaoAR5bR5V9UYhOKE4PjlxD2YPHdyLhw7uxWJnK/qlgIgEIGS7pvifFgKaJK0ESFIox9tX1pe8jlXX8z4SnyHNl5DmS7VNP2+bms0j1ie5SwuhVncLjn7nr0eu9/fmDsI5j8Rl6PoFdPwSUt8fEqgMbPjUBTVU36rugXc6Bz8os7OFWnVBqG5/R46bun0qXxMO1cMNVLnWAztndyFBofY2KFtefbhgKPEZUt+vfTr5YvW9SeV00uC9G6tPxOpgYgREERERERERERERERERERERERHLw8QIiEKnqRZzYDknthpLQ6VmGmwPi60RYhJp6XA2ihVHO9XUTmdlvVYS2ukth5a3FsYKy5lDPGxTWeQpuRb2RKGdOmv3tTFknUaGxonFktDYAzyfJnaSLKvEerGIiIFh1Zdg1VGyWjYD+Fiwxoy1HmhjxBqPMh/tOqUh54HGAgJsz0wynSbWRohpYrFaVhpWm4XaM8RYCaXPPUnK9GR7h1hTPCw38tkWFoupTR14mTRmkPXMk3WTa6AcM6H3B2tcynkgy7Re0Bi8st7a3JT9EmIiTBJcQD1m6KOp2CjvFxo0tTObFSTYIaR8lKT1PuHjsWZoO6+npdRFy2/okw/UqtQ6wRVMi2xJvT8KiNnC2TC8L2reupAUH5eCPJ0NPJ4Z3rkYM8q8R+1heLGr2lWwiKjsWWcaT999y0j17rsucp8W40CMMwnL057FZBn0pcLaL9tZqp1p6WlqZcV1Nu6H1M2UcV3ey5OCdbUeePDQfULtsN7ezvs6o8jXVVClKmpExKRhYryYhV70tBce/l9e53GsTYdF05Yvr7IsVpmsl0+JpvsarLxCL7knAlkXq55anJDQhqDd5/G0PmiKL8t2Ip5nrI0m/21tjqyNi1Zuqx1kXvK6BmsTZPVTUz1WG735eUApoyxXfHAXoLmgtY81xtps4pvytDbkVlj+X/Yh9zqpCZp4Wlb5Q88JS0hgzeXlgtdDwhLkyL7TyqetGaH1QYvTpr+X0w4kxA+pprXpL2tON43VUJtZ35ueEVq6sjxA0d8r5RlzFMzMzlZCIm1+hNZ3LeykQ9uMW16xHOpqNsCwqoyltlPdL1WENCHGoF90F9sUH8gBn6DwWpUV14S3MykkGsTV0+X1qezrAIUwxBVevjwS1ZaR5tVrVDifI0umSgFJVgmFyEMX1Y3qX81JaU/GFapgHg5w1Eb5QKjj3LCQaLlrfO0ZmsLDw4/ovj1HigTZQDBEXu7ga30qVbhIwKPeD8xb8tJFcUzhkil0an+9KBP3vFa0V5qfuEBxueDtzL8XBcyHwgL6HHRCrW4zwKN5fVsrTP6Taf0wMQyiiIiIiIiIiIiIiIiIiIiIiIjlYWIERNrJXxMjRmNjhOiC1omixhaS6gJN5WhSLdBO8jQauHWarLWLdnp4IswZoE5rl2wACXldK5NUDeDXtXysNpQn0PKabLtRjLD25ucb1S1Cp/y8HjIOH1/WybmFUJ9rrJEQiy007tYDfJzK0/Em9pA1XzcTQusSZ/1ofc3HUtO81satTIe+S2aDNld5Hvy7Np+t+mlpyLR4Wfl4Won1UVvLJHOLwwrfhikk28FaT2Vc7bnG26ENI8hKk9eDl9V6XshxZpVfjiGr3rKNJENLK3voumR5aeVYD8hnkjYvrHcLic2wPspxH2oP532pXlJnHTmfD64b6lwDFZb6fw31ea8xjUoVLOQq+6UWx/vqI9XohiMOylorN10X7KE0W4TzOU674kfNurTBQwf3Iku61W9iZS2boeFcYciaesAlqNTQyvs8rIVaL0rVNd5HpPJWhmtrrLpglXokyNHJF2vesaS3NVJ5SvN+MU6l8eeaaledMTakPjnENtNVJeVa6fj4UD61LjDGuXeuMpK9HuAMmKHnpzFvpZHtStVsk3kxW2+j1NFI9dpgYgREwLBwxnrx016K+Mudtpm3NhMELa62WbVeyGR4a4OklU+mK9sg9HIX2piMit78fOtNWkgYooVt2nRa+XhXqItZruWta87r9p0syHprD1RrfFh9J79r5Q2NQWtjrZXP2oTK+sm0CKMI1OZ7vVW1WxQSLHDI/p5kaGsG/23NJ62NrA2UtpHXYAkKtPlhCUas8Wittbz82nquCVJWGnx9bCqHVobQ2qjFbfP80QQFPI0260fbejflxdOTghyrP6wySsjxFnr+8PyahGlWmU9kHK302ijnwCh1o3CbAcVmWbiMtzbMZTjp6Yzu0TXTHbiyiW4SgtS8SCH8bK7fL1/zeTgaE3KueK/eGxISiTB52l2RZyi3PVSplDWkaz0XBsKapObtjHsB4wIjywuaqUrDBE0DW0iFfagsnQIAZJ3pxjrP93rI0KmNJy6cqOzglF70pNe5NO8bdnGYEEizY5TX1dm40EfzSjb87jDs3r52LzCmaR5lSRfeJXjkwD2N7UR4dP/dOLL/rtbhLVDew2XTy+34mPek/liE22wCoojNgYkSEEVEREREREREREREREREREREjI6JMVLNIU8cQyfd8uTSOn0MMZJkGCsvCYvxwsthneByloTMO3QyHYpzopBl42UJ5an1l8Z40MLI/1o5iN0ia9jmZKoJ870epLHkUH+MMhbkaa9Wdln3pvRkGbR21tpUS4f/Dhlh7c3PV16PPDt1OxHjrRpjSZvL2niUZW9zir7R0TTuQuslv9YUzhqHofbXytK2DFqZmvKw1mprvK8Uq4jmCc0DOc/argEhNozFUJJt1NR3GpMmFNcCn6ehdV4rQxNCzwlefv67TVrWfZ62VtbQO0AIcjys2PpovNvwcUjlm52ZGTwnjfE06ajYMc6Z3roqyLUD2YChQ+3sSgPStTyyso+Ns1lhzLd2yzAsba7tzKBzsA7qWjswnk3fHRlNpnuMcZL2F+18WuLhg3sAN9iSEHvGwjALizOeyPNbweqp+oEP55IBUxlqJuPXkGuS6A/BUhqEK65npVcu7xKkWbhdDvUeANCBh0MHGVLfF+9iOSTjTF3TRbpe9DvViZhZVNckz5AnA0PVACr1KUKepHAlQ6amliWZcIx1xcPwa1LljZg351z0CqV1ChzZf9dwn8Dh0f13I0s6eOmFl5lxmzBQG3RwxlSpGZL3A8ZVye8q5vkmQ5BZt8YYl3JMIiZKQCQ34qGX0dAGwdogN738tREOtdmIyU1taEOgpWm91IU2QCdKD9ZeSK3Ni3xhD21yZHir/SxhU5PgTMuPp81f0rXNDsWkNEgQogmMZDll3hSO1OE0DzTWpkRD00ZFlssSOlltRte1TYwU4PTm5+GMtEYFeYGS88QqH4c2PjYDNAFEm01v07htK4wJrc1WGeQ4tISZVjqyfG3CWmvMia6RtD7SPJD5hdo1VAYZLyR00tpSSyt0zVpnCZUQ2EBoroYELm3iyeeEfMbIcsvvcixo4zc0PmT9Qusnre187eThqR1PREgUejbwfqL8+EGHNc4mHcVmkNlEYUIQSx2lCoq6S3Z4YGjXWW5EvTWeUWzu+YZey48LfrgAxLmy/FW5s1o9ZDqqG3i63uLZWAkw8n5j2BAe23cHkqSDfmdqkK7P4Z1DonhGM9WeUO8Ph3yoC6r+da7WD40jnNYZIcCjeVSprcGhn0xhMd0K18mxcHBvJcR46OBeeJcgcx1kSQc5unDw6GAJab4UtLnkvBfqj4GyVgKdpFZGCFUoByDJlPalfLxHyu+zNuBCuAJlHOb5rmnzrt1/dP/dlSCrKHtdgDUoo0c3W8D377sTOy65MpiPxANzB6pSV3bDhgRx9e9U34FaXjlXvWsxeCIiNh6iillERERERERERERERERERETEJsfEMIjk6Z48SeThZDyCdarahp2i/ebXLOaOLIc8dWw6odR+W+wP7WSZX1uuh57e/HytnNqJuMZQCDEX2lxvc8qp9V+bU18ZN5QPT09jUllxrdNdak+LScGvWfUKjVs5BjS2gcUkkeMSUFQkjLpq/aCdpLdBGzaJdQ1AXeUtEG5SoLEfLFaEFpfCS2ZGaK3h/+W4kWNV9mMTq0TmxxFiDWlhrfzl/RNVh2waq1b5ZHhtLlvPHR5e1kmmZa21ErJftPrJNOT6ooVpek5afd80FmVaWtw2zyJ5TT7rZFl5GGqjSpWrDCdZolofkYruKGgz7vl3OadnZmdrLNDQ+jCx8MPGpAk6w2OY3QPpuQkDpo+8PhgDgzR4L2rpF0wbpa+dA7yv1Mx8ksIxJo7lhau42bw2cUZV2l+ETzpI+8cb43H8YN+3B+lhwMzg6ncae6hWjoAqIGfBFBfEOw2pB7VZi43xP5ivhWHrnNSsShZNnhRMoQcP3QcHjyyZQu5SZOgMsU68S5AjLVhP1ZwsDHXDJcW48G4kg8gV60XmReNwiAVEAQbMORGxYPcgq9pl0M6MSaSom9XKxdk58DWj0wUzZxicVUQg9cDDh/bhvN2XqnlZ+VdqdqWh70E+4WeIxr5btpe9DYpx8h42LuWYREwcg6hJMGFthEPXmoQuTcKf0Oaafss0ZmZnaxsSuYmRwh7rRb9po0/XTlQ4ZAkAQkIc3h4hgZj14i43rKEX9hC0/m7azGjlkGFkm1ibJV7+pg073bc246HxrKUd2khYm0hZLy2ODG/lTzhRzz2WQMKaG1IVZtI3QNo6JeeMNkatzbQWRhvTTXNRrh1avjw9WRYep2kOakInGU7bOIeEG02g9bGpvKE5KYVAsm2b1kcr3ab6WWuILItVB218aQitk7INZF68La36h8a3VffQc0drG+2Zp7WTVFOWaUphF+UzqpdInkdoflhtAqDy/hnqu4mE90NCg0qtxPJwZHlzkq7uKT7lUX7IK1qhEiVUW7hbcuZNzBQOUR0wEFQUQgbjM1SZ9muddwmyzhTSxeeBBmGOxEsu/WEkeb8muKq1M9VVbUM2Jnlbyt+8fZR+5Qhu8vmzRxFKDVTiCkERV4FzvvDWtZRMI3cp+ugiR4K8EtIMxg15cJMqhlT7ygMb99DGPkN1NT7OZ3A+GwiCauMvGxpz/JPw+2IMD+osvPYZOlhSrYtCN6lAUlgHD+8SpHkfhw/tK+xYNYA8ppFgaKp/rGoPR+7rSw9lvE1QXude7qgOoXJGRGxUxFEdERERERERERERERERERERsckxMSpmgH4Kq7EytJM7CXn62XTaq53O8/xlWhYTheJyz1vWKb28Lk/YZdlDbI/l0Ni1cofCaCfeoVNUK32tPbR+ssoZYpnwNDjbpLjZbGxXK591st6EUH9ZY1be08aBLKuWjtanoXFrsTuscLJcfMw3jcOm+RAaV/y6VDObZFgsFrk20b2msaaF0cYYH+9W37QZO1r4EDtGK691PbTetFlXmspqrc0yL+0/Xz9Czy+LUSTL3oadE2LryLppddXCyvKE1ggt/TbPTpm/Ne5Ca6dWf+tZaj2H6L42h6wy8jJoaxV/FjWpOmrPG9lOWlgOno98hm02cCZLY1iFhTLENmAMieq+90Bt7IS9nS2H0SVVdCwD2MUPNxROqgtxNbNsanvBIhoRLs/gE+a5rFQxq1hCjDE1CktDqjDVys7Hsh+k7+CBQPvU0kcuPJgNvHJlrjNoMzdQxakMRrOyJCXrJqe+cUlRBpcgK6/JUnh4FOpmw4a6K+PRzg2z4BgraxDewRrW2niv2rXy6iWNghfe/Jyn+vJ+GKiEUfqDOgw85VG52vQ3n0ttVe+ypFMwofJStaxkBhFyo+2q/MoyvviyqwAAj+/9Zqt8JwkeCCh3ri02Ebd1zbEmDKKFhQW88pWvhHMOd999d+3egw8+iJ/8yZ/E9u3bccYZZ+CXf/mXsbh44i4zAVsgwO/TCxR/uQ4JkHh4+XLYtAkPCRZ4mqHNjCxjaHPHX2JDL8feLU/FTNLepaBFllmGDW1W5Ev0cjaRWl/xe7I9Q3mEBEhafKtMWp20TSC/zj88vpa2LI8cD9Z/bR7IslljSIa1NnnaxkRry/leb0jlbL7XQ29+vuaaWatLaFPM86bNz8zs7LIFoyuFtVgfZd+Exrq2odQ+Mj051ngYmSbvd218j1IHbazyMmj1G2XdX+7muDc/r45HrZ0shNpdtr02/+i+lXZovspr1vzV1rVQ/bR8ZVr8mvV8CK032jOQj8WmdUnmx+9ZaWppyTYJtREPL+vnvK/GU29+XlU549dlHZvWcLpHamXA4GBkM6yPhCGhSZNqGbvn8lJlhz4ijAWprkNqLVyVh38Kj0tSJSirqz5V/a3nK1WXKtUm9iF1plpbKOpCHg79zjSOn/QSs44anrzn7+B8Dp+kyJIucpcOVJikKlOoHZ1DTV3ODYQLVRpcRapUa3M5a1+hzsbzG3ilE/1a9dFA0EFqYBkKO0OZ7yBDB0uYwpLvYsl3KwGRg0fisuLD3NlT21dplXaM8tLGUT/pop90kZWffjqFfjqFPEmRs7b0LlUFfbxuic+Q5P3i47PaR9afykPpDLUrxavatp62834o/Vo3snyC3vUMJHmGJM/w6P678ej+u4fu/+Dev8eR/Xehmy0Un/4xJKXnOJq/1TymNKmsYuw7n+PJPV8HAJxx2WvNMkVEbGSsCYPowx/+MM455xx897vfrV3PsgzvfOc78ZKXvARf//rX8cQTT+Bf/at/Be89PvGJT6xF0SIiIiLWFXF9jIiIiNAR18eIiIiIiIi1xaoLiL785S/jpptuwp/92Z/hy1/+cu3eTTfdhH379uHw4cM455xzAAAf/ehHcc011+C3f/u3ccopp7TOR57UNp36yhNQixVixbGgnaSHTsTlaWToxFWWQ0s7dEIo4/AytlUxCxnLtE5UtdNmWd/QibT8btVHtqMWVkvXuqfFJWjta7EEQgid7odgnbY3sWe0uKExFMpDG2vWeA/1qTVW+VibZV51LCaDlp82v0L5rDXWan20EGIWhOYLD2OxiDSEGBn8mrVWyHJr6YTGglUfbV3U8moDPk5lebTnjcX0aMP6sOKE6jFKejItbb62XW+1sSLja88mft0af23ay2IRaeXX2lJjCll5NT2vmp7d1ljn8eS6FXr/aTs2SOV2lqmxnagDgRPBWq6PbVRaTCaQtubxa43vo8LAsLEWBfNU8mtSK2sDznjhvymtTn8BAJDkS41pHdl/F7r9YzDZQGh+9ynytr15kXcy71LkOYYYT3ocN1S/epmY0WQqn/WODY8caY2dlfuB4em09ABWMIbq7JsiE9tDHhmwdvCVChrPk7OhvHOATwYe87yv1ZOuDTeGPm4tlTONdTdkaNr70mPcQPXOQpOqnzWm5bVH///27j5OrrK+///7zCaZLCG7BBZ3sxBIstJKGhVM+sWAGlBJsAHhS4vS0EgeRRQhpRjwJuBXFmoShZBSQxHQCmil2BbxBqpNfoBoSsSQJspNBUmCiSRrRNJsuNvd7JzfH7PX2Wuuuc6Zmc3OzuzM6/l4zCPZM+fmOjdzzZzP+VzX9astasgcGMysCwKlMv2D9b+VDWTvq7t9d1/N/Ie/9V0579UTRjGrD2VtYva73/1OF198sb75zW/qkEMOyXt/w4YNmjlzZvTlLknz589XT0+PNm3a5F1nT0+Puru7c15SfGq8/aNrekeH9wee/YPR/iHru9mIu4mw37P/jgskJAWC7OXcgJX9sqcn3ZS75fFtu9g0cl853BsJ+5j7fuzG3dC5y/q4N1txP9rt4xj3o9kus+/9QsEb302PW5ak8pu/zYh1cddb3D4U2jffcffdiMXd7CQtnzQtrjy+5Xw3P27ZTF9B7jXqXsu+ay/uJs9tplHMj9LhNtL1Y6HPqjvN/G2/71vWN787n30+4uq+uPrNt17fPiV9fn0BBLd8vnKVKm5o8Lj9NfPFfVfE7XfSNHe9cfP4ymRz61Bf3e3ua9znzp7Hnd/8Gxe0cP+OK3fctWxff+5+++ohX/1k/520r0n1nm97vrrTLYd7fHyfkY7p0xOvt7hjaf/f3u+4ZmwjqRz1oxRfR/r4ggVeBc57duSoEm4iw9B/8+7bdFwTOPt6KDJIkrO4pymZ73iY66bpHacX3Ma43lcUZPqV6h9s5pWzzaL3OXm+aGSvVIM/4BMFUax+hGL2zzdvdsLgOTLvZYJskCbbUDClTJh9mfWklImCNKmgX2MyvWqwmzkNNPuyg0YNmQNREzTzXlQE0yRQgTLW/webCgaDI5yZz7nZR/cY+o5pVMfkX1/uaF7uMcsLwLirtpozJklq4plz/gLrOIcmCOeWOcib7uuLyxcsdIO4dt9DjGKGWlS2qzoMQy1evFiXXHKJZs+e7Z2nq6tLra2tOdMmTZqkcePGqaury7vMypUr1dzcHL2mTJky7GUHgHKifgQAv3LVjxJ1JAAAhZQcIOrs7FQQBImvJ554QmvWrFF3d7eWLVuWuL7A8+QlDEPvdElatmyZ9u3bF7127tyZXSbmCbg9zR6xyPdkLu4JXNzTx6Qnmb6n2cU8XXT3odCTwLj34p7uxz35LVXcE2Xzt52t5R4/X+ZIoSdCceW2n/6789v/+p4EF/N03t0vd764rBz376Trxu582V7OXjbu+om7Tgpd0+a9uKwK96lyXNmKKW/S5yEus8XetnmSbTppjSuzb59853i603ziYLNGbNVaP0qlZYSY+aNyxFx/cZkvefvhyZTwZRfFbcMtf9xnzncu3WV8x8L3Obf/LiXD0t433z7HHYekbCjfduI+p3Gf2bg6z+b7TPr+H5fxU+z3VjHliNtn9/++7cdd4751xh3rpPo2aR9815m7vrjfKUnnyvfZDcJQ0zs6onos7nNRqOwmC8mnmOumWJWuH6XkOjJRGMZn9vimxZShmGyewXk9TV2Uic0uysmyKOKc2WWxMz5KyXbqbxinSW+fW9S8QZhRw4GeqHNg972kbJHB+Yo8/gPT40ZrC4NsVk2hTBjzb2yTOGU7DrellD9iWKBQDYHpvrpvIDOo39sRsskaasgc0Jj+Xo3p71VD5kD0d0PU8bO1L/JlCqZyvwtSDVGn4GFqoBNr84o7jjn1hieLJ6fkuVlYbhaR73q2y2/W5x63OEnXSSrsV8OBHjX0D3Zab2/HdARupseVIW//gpQOf9u7o/dffnJ90SOo1QrfOa/kC+VRch9ES5Ys0fnnn584z9SpU/WFL3xBP/vZz5ROp3Pemz17ti644ALdfffdamtr0+OPP57z/t69e9XX15f3ZMhIp9N567T5AjlxP/TcH9G+wIX7XtIPsLh1+G5ifD+m424OfEEOd/3F/IDzBVWSfiDbfP0Q+Pbdnj8MsqOjmf6N7BGo3H02N+1uWvt0p+8Z94bOXofZntlOoX3znU+fuEBIoZsktwy+ee3yuvtoM8cxaR98ZYsLztjLJt1MxO1nUnDGd10UumF057PXY64N9xpMCm647GvRLfNwqtb60Xes4uqyuOvCV2fa0wudD991EvcZ9AWR4ups337GbTfpui20niSmvjNLJW3L/tvl2093uaTPa9L3V9y23OWS3o87R751FPoes6f7yi0pJ/hh/u/bhluPxinmu9J33Ny6rZiAV6EAk70N3/kt9Bmx/zbHxveZjAsMuXXutq1bFVjrMtMKNp8qQaXrRym+jjSBiTA1MHJXdMxTeU2h7KY33uBCXHDImT/6/xCPsa/ZT1S+IBgMkFh91eStww4SuSNL2c2Z3Bux6DptUCEv//Kn2dHXwuyoa5KUSY2Nymr6hsmWwVfGIvp+MudE+TfrplmXpGzTNvUrSGV0oGG8wlR2u6mwPy9AErg3/vZ5CrNBIzO8eyoMNLa/R5lUg8aFb+T11ZTdd2u0LyfwkhugyzZSy5Y1O70hMzivKWcmNUaZ1FhlBprSxTXrCoNApv+fgYOk/qAhCjYGYUZBEOasO+44Bxq8hk3AxL1+Q3cdQbapW95qc5pw+a8j9zi6/8/dz5QCK3DWPyatI2f8n+j9rl9tHvg8xPRfNdDHUCrsl91czy7jm2ZkMxpTYb/2/uJRwhOoWSUHiFpaWtTS0lJwvi9/+cv6whe+EP29a9cuzZ8/X9/+9rd10kknSZLmzJmj5cuXa/fu3Zo8ebKkbMeD6XRas2bNKrVoAFBR1I8A4Ef9CABA9SvbKGbHHHNMzt+HHnqopOxoREcffbQkad68eZoxY4YWLVqkG2+8US+//LKuuuoqXXzxxSWPQOFmpMTNUyi7x+bLuPH9HVeWuO361hH3BDVpetzTRl9ZCj3RThI9HY/JTInL/DDLKhhoJmQ97d26bVv+fJICp0zbtm6NRrBKempr3jPb8V0PxTzRLvRUvJh1xmXv+M6B74m4+zQ8DILo6a4r7mlz3FPpQvtbTPaPbx32NpM+K0nZPsVkAblljfv8+jJa7JH63GyE4c4kKqRS9aP5v32ekjJW7P8XynrxzRt33RWq44qpA32ZRcXUvXH7FZd9U8jWbdtyPpu+z0HcZ6mY751C89nrt5sJxY36V+izWGyGUlwZizkv7nrdZeysFsOXIWPva+Cs095fuz5w97PQsXDLburnuPXFXYPutVDoO9tXjqTvnrh98+2n/bm3y2Cun6RjNRJGun7MYbJvbAPZOD6xWURmOXvVCdlGboZFoIx3mru+UpqD2Vkm3qYZRa7P3Y/fP/NzScrJ1shZ7cA6TXOfMAiUyvQpkxqrweZHA+Uxx9l3zSX8vi9Y5pwMmzDKcok6mJYGGqxYGToDnU7Hbd/OAAvCUEGQbR4W17mxyRTKqyMGmrCZzKEoq8fTtM3t3DsMUko5pyxb3+VmLtnXU/R5DlPZH91BoCBzIHs9JTRhNMfAZBEFAyN+2Z1gm+PhO4859ZInM6iQYu7fouspYR9CpZQK+6Jy5GTKxWT4ZYIGtR4/GHg258DO0KsXjGJWHyra9XpDQ4MefPBBjR8/Xqeccoo+9KEP6ZxzztGqVatKXtc064ex+TFY7I8at9KxX/Z0e177R2fcNPvmPWnb9g82ezvuj1vffvl+jPrW5a7XLXfSiCW+0d/cH6C+G6K4Y+vemNvz+o6FHUyyf9iakb98xyJuvW6Z3OWSvlRsvnL61u1bzvfj2z0XvnnsvnPsMph57fNk1uXegNnbMTeUvnMWd8349j0pwODeYBW6UfYd/21bt+YFFN3lfDfLdtk6pk/Pu3k20+O2W2nDWT+6n8e4+i2O+767nqRAgz2fPb/vOvKV1V6f7zy7+5NU9xb6fPrqdSm/6au7jPnX1Elx12Xcfrg/dAvtl/vZtgMq7ufFPRZx58XebjH76q7Lt7/u9VGo7vMdI9+16yt73DF1ucewmO95+z03OOTO43vPvebjjpdvv32fPXs5c87dffLVs+767GMZ1wdRNdaN0vDWj5IJDniCcwmNSGJvbnPOcXGjNeVv19ckx2qSFl0ng+uPC2YkjdaV1/9KiWWNRslKEGT6s4GEIJAyuU3MoiBIGA4GRsJMbLO+vHUX0W+RPdqXkW3yltuPTxgEg8EOz/H1F2DgczrQF1Eq068xmb6ozyD3NdjULrfcqbBfqUxfdpQ3a7SynGaDYZgNEFnLNWT6NKb/DTVketWQ6ZXbLC5bD2SDSqlMnwKriVtU1yiV0ydPXt9EeQd0MHAVfWbc82MfQ6Wsem3wWEbHvMhX7jl1f8f7r4E9zzyhrl9tVtevNg/OOxDgymkql9C3TahUTnDI3Q+gFpUtg8g1derU/Hapyj4peuCBB0aqGABQdagfAcCP+hEAgJEzYgGictu2fbuaBtKQk55oF/O026zDt6w9bylPW+O27VuHu624eex1uBkbvifNvjKYp95xoifnzjK+bbv75W7PfeIfdyx8T4rjngabp54mI8TOGJFyR6kq5li68/iWjXuSUWyGi31sfPPa7A6afZ182//ftnVrTtMpX6aAe07cp+GFzqX9t/v/uH1w1+vLIkrK7HC3Hbdee96k9dnZIEmZIbXEl7ljxH0u7Pfcc+b7TMdlqNjTivlMx63Dt0+++d3tFNpPN9PFXabQCGZuplFcPWB/NuPOhV1m3z7F1UNx0+3tuAMF2NvybS9OXJaMryy+ZX3bKnRu7PIX+i6QlJdB5e5n0vewrz50607fv759jTsXxdRnheq6pOukmH2z37d/A5hj5/s81zTfCE0DWTmZoEFBYP8uGJg3DIvOIohrdpR9zz8KlffcDXQ2HCijpKZvcfsSWwanqYw3m8pqcmPKfKBhnCSp/Y/f5t3uH556TKb74dSBgRGlMv1KSYNNzDzNdLLlCaPtuftqd+w8OG2g2Y+n+VKUqdPfF+3f2N6M+seOzxbJ7STZyoAZLFR+ky87e8p0kN3Q36+4poOD+xeoP+qo212ns90g2xTMdKIeDhzRbOaVcrKtGoKU+sY2RttPZQ4o1T+YmRQqUJgao/4x44rrANoqSl5zN3NMzbKhsz7rOrGn250/52YyxX9G7O255z1brzZk1xW9l8k5TiaDLFCY/TzLurZc1nXnNi37w1OPDbwVDM5b5GewVlTT6GHVUo5aVDMBIsn/Q6bQjzipuHT5Ym5skn5IxQVVfD9e7X+Tbgri9jEumFXMj1qbe7PjLuMbFcrdZ3v7ScGLuJtKc1Pgm8duqmb6KTLbsANbbhDJ3mbcyFbF3Dj5fujH3VDELeceO3dee3Qke0Q397iZdfr64rBviOLK5Qv6JJ0jt9y+9RZ74xu3jbjPQNyxiruh8ZUjaV9rkX1j6v4/7rNrL2v/65snaXnzt289ccEq97qOO/+FboaTPn++bbn7nCSuj5+45e3+0dzrL06hwJ07X9wxCYMgb2RJt5xmuaTRwpLK4tunpO+PpICW77jE9fVk/vXVjb59Svr8JwVhCn1vF/qNkPTd7b7vHpNC12uh6yhpvmJ+UxT6rVArQnmCAtZ7brOf2NG1SmT6hynm2gmDIHZYbe+oaDnXaSlNxwJvkMjc9JsyJQWGpOzNeWbMOAWZfmXGjldwoDcb5DD9+4QD/e5YTcAKje5mByp8I7kNNnuKH5VNYSYbuhgIWgUNY6LlswEMJ2Bk1105I7/15weXrPkD9Q8Gt3LOi9OsT6lspMUbhBpYLkgpbMhvShgEYbSvmVRDNhAUZq8T02eRuWYChVLmgFL9Qc5xjrs27H6YzDHJD8yZwE1uoDFUSkGQ35fW4H4P/XdXXL0Z9UljBUQHP6/259eUsSH/OzMY2J9Mv4IUzchQn7jyAQAAAAAA6lxNBYjsJ13m/8VkyxTKeIib1zx5jFu+UFmTpidtO2kZN0vAXT4uS8PHbVrRMX26wiDIafaU9HTRbK9j+vScFHZfZ8um/GYbZprJ+rHLaS9vl8d9Om06YM7JKFJu9lDck3KzXvsJqnuui31q6/KNFGNndbjH1Pzf1xyqUKaTe20mPXU227WPp+8zVCg7JO54FfvZcT/Hvm24x8p33OzlTBM9O4sg7pjVi7jjaU+TlHick65bV9z15q4nLsPBvWbs98z67GnuNRf3WfFts5i63Nf0zP3+cffNvc5911/ScSylzvHVs26n7B3O4A6ScrI8fd8jbjl9ZfXVAfY67f/Hzetm7yR9z9jbtKeZZeNGLDTHxHxX+K7vpO245TTz2MfVPWe+68Yth/teoXMQVxbfy7e8+Y60s+Lc81TrMqmx3iwKu5PiTNAQvUwzGfdlz5PT8a/F16FuoEz25Xzver/X7Y6hgyDvVej9uJfbIXNOp712Z8lFOGLmyQOdU1t1osnWyfQr1d+bbf6U6Veqf6AZlAaa7AXZDB6zH9H+WOU05Rs8KKFyOrkOM9mOn61XEGaUaRg4zwOZLqn+HgWZA0od6B0oV1/O+twmRGY9JjMn6lTa6Xg655UZXCbnfFvlDIPB5li+68p3bZnzm0k1ZLOyUtlsn1R/nxr6ewe2G0pBSpnU2OgVprLZUqZTbbfja/f6jMowsI1Makz25ZYlDAc6wz6QfZkMptA5RtaobfZ1lj0u2b9SVgfiPoPHN8y5TjOphuzxULZ5mPczPfCeed8sY179qbHZ91INCpTR7/5nk37/zM/10lMbcj4P5lqN7cy7RmXC6nqhPGoqQGQk3Si4PzZ9N5S+H5mFbigKlcGdbvP9CHXLa5fNDU7E/esrh688bpAkrmyG3Tyh0I9Hc5Oyddu2aDvbtm6Nfgjb/4ZBEDVrc19mPnOzb2/X3Pib5e1y+gIQ7n7HBU/c4xJ342D/bcpq9tu3fXe77v+Tftj7bjyTbqjNMr4Aj+/Gyxxfd/3uOnzHKy64YM9TqLz2PL7Psbst95j5jqVbVntbceurNb5jGXdjaY/4Fnf83HUlzeeb7rtWCpXfF5Cwr0vfdVNMoMY9Ju7fxfZTFRcIidsf3+dnKAGkuM+T24zMLBM1Wx2o45Lqtbhtxn2W7en2sfadv6TPt7vduLrGN4+vbvDtix0csb9T3LL76r24oIuZzx2JMq7+t8sdNxpZ3L74jotvf+P2211v3HGth/pxOBUzalnOzeWQtuF85t1AijPdN6+XdbNbTHO0MEhp17O/jH0/Z0Qy3whrAwEaM3pXFJhwf68NBM/cbXubwEXrDv0vKRswCbLN3KJmU1bAIq/8VuAkEzRYQS8roBI7Ftbgyz2mJnCVXUcY32TRCULYo4Ap+tzHN+MKTRApp95KOf8fwuh1QUM2YJcaCBK5dW2mP2eUusH6JDdIZB8jcywkWfNkco6xexzspmN24Cdbzvwzkbsf/vfsY5HKHMgbVS8KSAUN2WAjUGNqqg8iAAAAAAAwvHyBtkqplnLUopoKELlP+uL+73KfErpPIpOyReLW5csKcrflPpWMm+bbtrtNd/329LinzWb9caOYuaOZ+EaGcbM/3HIldeQqDY685UttlwY7wjZPVu0Op931+Z6o+p4Gu2V3t+U7Tu4+2MfWzZ6w98V3bO0n+O727VHXbL7zbo/q42ZSuExZ3Cfb7rp9+xX3ZN8s6/u/ve64933XYpJC1749jzvdzmRzMwOKzWIZ7dxrI+4z7Ou03earH+MyOJLqyrgy+dbtKnTN+ubzTYurO9w6yCcuQydp39zjVOizaNchdn1stuV+pu3j5qsrfU2tCn1P+OYtpg7xZdf46gO7TrbrYF+Z3M+tWx73vMU1LfPVl+758A2q4Nv/pGvHXo89sqbNrpuTjpHvmLjHptBx873nW0+h7dUiX3OWpCYuUv7NiZsVFGXqDIyi5F9H8dkH7rnwdo7smT8viygIrBGerOvGZLAEgWJHaMvZvyC2k+qXntogNYzLNnUy5RgzLieTKNq26TC6/4DUIIUKFVrzpTIHBreZ8jfbc8tmj3qW35F1IAUNgx0UD4ykZq77VNivjKzMFAWD2UKeDBb3OPmum2gUuXDw71R4IFvOgf2LWy6xWV9O3dNg/d9z7txRxsxgfAMZQNH2PaO/ZWfMv8YzA6OHKSVlMlIQhIPZNqbOUfYYm9HEgjBb1ux1GCqj/OvYXBt2h+yhdY4yqcHOpU0WUjgwQpkk9afG5J2zpN+n1i5Gy5l1pcIDiee40OcQGI1qJkDkC67Y75lpvh94cT8Uzd/mh6Y7ukvcDW/SDzC3PPa0Ym5Sk2623R+XvvnifigmbctezhdUcZt8uftn38wY9og07mhpblDK3hczb4cVVHKHP44LVLjzufNs27pVHVb/Sm55C90k2cw+uEPTZ3+YBHk3Qmabbpndm1+7DL5rMSnQsm3r1mjb5u9CnxN7/Uahvptc7ueqlOvO/jvus+vOG3fzum3r1oFRNgqXodbEXau+IJH7nuQPbMedV985SdpuMXWfL3CStC1feXzbSaoPC5XJF2Q0//cFA9x54rbrfr7cOtCe3w3i28H2pBEm48SdY9/+uAGouM+tbxvufGEQDH6/eo6Le4xdvu9vXyAmbn/t/5t/fU2Qk65t8393ZEwzep17ruyy+oaWL1Qfx/3mcY9F0ndI3HGst/pR8t9Qu0PDl7p8bKAl5jtqqOJuXov9rRetR6m8IFESbxOvAXZQZ3D92cCMVdDc9WUOKGWGcs9p4pMNEmQG+tjxNumJPjtm+PQCwb1oHRlpIMgx+BmJD9plt597bAYDH8nbzAYxgmiZbEFy388vqDMSV8IIbva+2UG0pPNk1hO3x3nLhpmc0cly66Bsv05BwvUcHStlpDClIOxXmEqY3w7Iyfc9Yx8PSancwK09qpoCf53tMsc6ChL69qf+qkjUmZoJEAEAAAAAgOEXhoHCsDqy7qulHLWoZgJE7pOxQk/H3CekSU/ApcEns3YGQrHZOO5Tw7h08KQn6UlPuX1PQOMUejJp2E2XfE8VzdNe+yltoaeZUvZps90JrvnbfkpuN+nwZeC4zbbsbCR3m0nXgdmuPb+9PfspsDnvvuPom2ZfV/a+mvdNNou7vF3GuHPpyxBzn67HPU22y1EoeySOm4VlN4+I27ZvnfZ5iGsKErffcZkiccu612ncZ7BWuVlYvvd99YfvGok7fr5j72aeFLqmfet3r99C9by7naSMp0L1vjRYR9ncjEV7O/b+FpOFZNifBXekSHtdbqaSXU/56hVX0neM/Xm2y+f7fLoZkHHXhm+f3XlNpk1gve9bj6/Otae7/8bVOUn1q285d3lfWQw7C8otS6H6vNj9TVqHyz6Odl2b9Hmo1yyiHEEQNZUZbKKSm80h5WYr2AZHEXNWq0xuR9IFMlai5cKM93o30+xmLsHARk3znEK/CXPLbZrV9A9ex/a1EIYKgmz2h5TRjl//j4457njvulNWx75hqmFgGauuyCvMQGfE/ZlopC1b9hg05Pyduy9xHTUndxhuH9vBvxuSs3DsLKIwVGA1hUrqfNxeT1yTMt92c9ZfYL/MKFuDf5vMp/jsKl/n4L7zHwSBFPYPdM7sz+Yp9PmImtoNLD8mM/iZsM+DW9ZU3Prsz6e1a9nRzAbXZbLaos+Fe5zyMvsGm88NdqhdXEYhMNrVTNfr7g9t+2Wm+d43PxTdGxR7mhn+Ne7mKS7w5N7wm5G67GlxQRV3n5J+ZBb6MecGz9x1FjtKj1mXCQ6ZYeDd8sf9gLb7YTB/Rzc11rx2eaZ3dGh6R0fO8MzuSC/muJp1TO/o8N48us3E3KZtpuzuOTLT7XPtG6red8NhtuP2V2L/694MJd24uNu0/3bPbdwNvCm7Pdqau5xbFt91av5v75tZX1JZ3PW4o+K5N+P2cfdd6+5n2eWrG+C/GfUdG1/dZj5zcZ8X+6Y/rq8e8zn1BT7c+ZOuJ18d5M7nq6vtsiTtQ6HjZw9Nbo6N/blKWo97DE0d5RtZy/5sup8ds037M2iOcVy53TKY4JA7spk7r7tfdt1cbHDIXZddLjdoV8x3t69OdM+z73vVLof9/WzPY86vu39uWXx1eaGgUNy+xe2PXRa3/O5++/Y3rjl43OfCt42aFWjwpn/gFY1t5Az7Hd0IFwjHuuc0DMzQ2/bIUrmjLblDmdvT45rBmXIMfrZyh0V3h0vPWz5mSHW37yJ3lLEgDPMDJ/YxMq8BfWMb1Te2UQfGNqp/zLi84cWzw6iPyQsOuccqbrSz/EIEyS/PMTB/F2qWlQ0K5Q9pL+cc+I65ez2Z+aPznbCMOyR9zjqsIdjdfTXXSc767eOQ8x1rjz7nHAdz7p0Rxmz29RsnsIayz452lh2pLjst/zNnypUK+/PGJTPvSVJD5kD0GnugRw2ZA9G6snXcYJnNKHLRyw5oRp+7lPpTY2T6P/J9pugnGbWoZjKIAAAAAADA8DMx9GpQLeWoRTWTQTTNeoor5WcN2P/a7ydljPgyJ9wnlvby7lNjOxPCzrSwuU/zfE/wfPPE7avN9xTY90TLN0qPebrvLisNPrV2m3/Z2TX2E1W7SVlSWYy40V7M03HTBMLOYDJPv+3lzPtmubjjYR8r94mz72muyYzwPS2Py9px12m2bY6V/RTe96+Pu243eyDuuJpjY7IUzPZNFoI5bklP+337ao6Lu233qbZ73tx9NE16kjJA3O2a9drZZva5t7MEfMenLp6QKz9jxb3G3es/7pzZWXx25oX7mYirfyRFn+FCy/nqLPe8+epr+333OnKzLnyffyOufjTzuaNubdu61TtaoM2XCWKWj5tmfzbdddifZTtLxJTD/izYdUQxTefM/33HScofzc3lu+bsfbOXjfs8utuOqwcKrTeO/f3sZvra+2Dz1c2++iruOz2pbjfz2NeZ/blzv7/jRiJ1y+6rd5M+O/VSL/pEIyAldDyclGXiZvP4XtG8yv+smVfG6bDZZDLEnZ/c852bnZS7jvwslbh9yNvvMKMg7B9owhMzj2meZzXfasj0Re9F2Tbm5exbbjliyhkEsfPY2UCxx97ZvptZlLM+WcfU89m112tnfrnH3lcmX+ZQXsaafVcexoww5y334L4mZY/59t17nMy5cjuCdo5B3jryyjV4XMKUNfqazP4nZaLmZxaZZQJlr03TJM/OODIZQnaZ8rMDw9xzbU3LyYhKuFaAWlAzAaLtdn8x1o/HuBt494eX+6Wc9EPPnmZz+2nwDVnuC0z5bsTdH7+++eJujuJ++PmCPvbNhcsNLsQN92zWbdZnbvzswIc9so7dZM+83H6JzI2N3UTFrNttqmbK6hsVzP5h7d4o+W40kgIhcdeHu17fTagvmGIfF/fGzL0+3Bt39/9mXrd/Cbv5izvUsn0DYq4B33XgHgt7u+a8Jd1I+D4rdhDRLq9h39iadcT9GDb/mrK7+2ACTuYaKeamvNYkHTv3GvLNF9fsyP7c2fWM79zFBRfc5ppx9be7bNw6fUEk3/p8ARB3ebcOiuP7/ki6rnwjbCV9D5ljZQfm3FEI3SCevW57He6w98XWg0n76jbD8tVfyT/4/Z/JuGV835e+AE6hdbhBJ/MdY//tXvtxn6W469b+bnADg3ZTTXsZM5/dlNt3Hdvf3+5DEBMMNOcn7vy659/+7nAfXNS0ULKHRTdNaHyPy303ve6NZsrpM8bXfMwEBnJCCfa1EzUJyt7cu4GEaJq36ZknQOUJWLiBDLcZUqiUwqAhCjDY22ro71X6wGva9ewv9eJzT+ZsPzNmnDJjxuU2FwvD6BjlNdUxTcyi8sYHwUyAJG7f3Bt8377mNb2ztp1/LAe3IQ0ENKzjEf09MFx8tC8DL99xzgQNyqTGKJMaMzhfTNAhCuAYQSA3SJITYAqC7HmLucXzXgf2slZ5cs9J7jVXTJAx5/j5XqlsU8bB6yHhvFt8zdvCIIiCj9kmY33Z/2dym4/lrieMmpc1DPRRZMoW20eUu891UD2i/tDEDAAAAAAAxMoM9BhVDaqlHLUoCMPR/Wiou7tbzc3N2rxli054+9sl5WdRJGVz+LI9XG7mUNy6TLMd8393tCi7TEll8f2dlElhb8P3JLPQetx12tk5bufc9np8o4CZeezMlKTMALMeN/vK3Rd3Hpvvqa09Pe5YFTuvvU/2CEO+4xMn6Tzb05Lec8vpe6prP/11Rxbz/T9u+aRz6JYjabqvLL79MGWyP0NJ+23vp/2ZS8qES7r+TD2yb98+NTU1eY/NaGTv1+9feklS/HVT6nXsjnZVaNlS5ktaJula881bTN1ury+pPpXym2X5ru24az2pvHHXp+/7J+4zFVevJX1u445toc+ebz2F9idu3XHHOum4uPO4+51UP/rqWvtv+9ouZrtJ5Us6Dj6F9rfYdRimHndH43Mz/8z6fH/v379fJ5x4Ys3Vj9JgHbn1Zw9p4qEToqyBKINoQPFNenKbzWQzcAabp4QDnd4a2Q51B5pehWH0ntt8y84usrOT4rJl4tj7Zy/vndfqADjKWpPdSXXu8ekb06j2P35bzjpeempDVN7BzBNzLIJoZKloO/Kv2+Zr3uTunyunuZSUlxXmW0dcplj0fyt1JOc82J9LdztJ33+e4+peh9GsThNFe7txmUOm2VVeE60iUmB8zeSyCxc+nrFMplMRvwl8GT2+Oj418FkaHMEvpYz5THk6zc5mUJp5G9Qz9pDs/wcy+0x2kXuMUgMdaysMtf/VV9Vx0vtqsn60mbrye4/9ThMOrY79fPWVbp19cmvNH/tKqJkMounTpnnT9u3/uynU7jzufHE//nzCIMjZvhlu2Ny0uj+8fOt2f5zbP2KLCRD4fpTa03xlsOcx7+WUN+ZY2MMruwEcN7AQ9+PavOc2lYh+iFjnwl6X2Z6kvCCIe1x8NzzF3iy567KbMEXBCOf4xd0YxAVEfMfD/tvlW6fvujTXn++Yu//3HY+cm39PGe3zH1cWXwDBF+izPyNxwR7ffvvW5TuuhYJkW7dt0/79+1XLtm/bpokTJyaef/P/uOvZ5V5j5ppwh163t+U7B/b5j5MUXHTXa0/zfabcusss4x4H3/UbhGFs4NW3f75jYK/P3beka9fm6/fHF7iKO0bu8UgKyhZTJ7l/J+1r3D7GTff97dahcYG0uDK5wSApt08sN5jiq4uSfg/EvRf3HZw0j1R8XWe/5zbv9n3X2uuxP6Nme0n7WIvsAMWQ12ECHJkDAzeZ/dmb22DgGIf9ytjNouy6S3aAJC4Ym4luXs32QuU3OZKSgyfmhj9uf00TpECmv5uBZcPUwDD3YXTTng1i9Gvsgde155knooBYuu+VnFBFtqwaHCo8zA2mhEopGvXMatLlHl9T5uiG31lHtt+jmICZfU27xzeqQwb7AYrrU8ecB3e6u86ig4yJ9xdFBMgKBIfs8hR7jbvXmW/7JQeG7IBSGCpQv6TcwM1gXZR7DZj/+eolc02ZazK6NjP9ahhoXpYaCLpmUmPzljNBpMC6/kyTs9ggnRjBDLWrZgJEAAAAAABg+IVhoDCsjshYtZSjFtVMJ9Xbtm/Pe0JoPxHzPbmzM2jsp492x76+dSa97247KXsoiT3ajC/Lx7efUu4ILGYf7SeeZv4wGOw0M65M9v64o9/YI76YJ5O+4xH3pNzdjl1Wdz2+J2mmw1bzpN9eh+/c+/YraZu+Ze1jZ7KI7GvBLq87skzS03A3Y8M93+50X6aD7zq2r1X7ujDn3O143F6vmx3kPvm3O2513zPbdjvgtq8TO2vAzQ4zy5jj555fu4xuh8i+Ucrirgdf1kmtmjZw/n11oOHLzEnKdrA7RXbPt72sL8vG5jZhjMsEchXzWfdlw7gdTseNsOhr9uqTdI3FHe+4usZ3zbr74RsBzf5sudzz5B4Pt8y+Y+0ri/m/b9m4z1XcupPqPHc7dl3nqxPjtuOr702WmMkKszvqt/8fN7Kj77pNOoeFsod85bevRV9db49u56sH3e2aet89Hvbf9ih8cWWsNXEjIw1lPdHLbqKlbMe5QRjmZWWYZmUm+yVal9N5tds8zDuflWGTUxZPs6KkTJJC7+eMPGayjcKMUpk+pcJ+jenviV/Wyphyp0V/Op1xh0HKXx5vnTLEW5sgyM1GiumoOHH5nIJ4ynuQvzWKyVrKK9ZArzF502OuDbcD6/z1hd7lkgsRxJbTV7ZizmEQ9YbjjPgWs44o283dXhAoFfbnzG+PvgfUo7IHiB588EGddNJJamxsVEtLi84999yc93fs2KGzzjpLEyZMUEtLiy6//HL19vYOaVtxASDfjyDfj1HDTSd3b6TdIZ7jyuL+kJUGf7j5fljay5qhkuPKaNYRd+Pu+9Htzu+OaGPm9QWO4kbyMT8k7VHM7CGX7XW4+1IoYOQua5fRHv0lbhtxf5t9dId0L3QD6N4E2DcQ7j7ZASz33NnnJm5kubibSd/xsM+LOQ/mBsA33LbdlMJej7v+uBtR382Pmd8Vd0Plbss+32Y+93No1mHKZPfDYvbVHf3MVx53W/b+j7SRqh+3bd8e/d93A+s7F2Ze9xq2z49dB9o3rL7Rmdzj7rvB9wUY3IBBXN1urzuufrGXMa9CzdvsZQ13FEz3pjtpWXu5pL/tY20fF981buoyUyfZdYIdzPcFUH31unvcfftgpvnqKzdolPR+Et/n3ldOe73usu71bC9n19HuQxDDrufd/TUPAgodI/fvuP33HUv7mvadK/v71v2+dr/fzTqS6kl3NLS4/RoJI/n7sZSgQtyNdXZF4WDzmYEb0mgY8IH+VoIwv8lKJmeo70Cm3x/zMsN1Z4NMmYKvVNgfvYoNIMUGkwoEAvJuxM0w9g5fk7CcUeKC3KCQO7S6WX5wWPOhBfFytp3ArD86jnEBFbffIc+6c46RdY3Y+18oWBP9a4+k5X63+IIt0dDxg8ct7hy7gTnfPO60vOn2eUsIDLnldsvuCxKaEe687DrLBLic7ZuRCd3thUpFI5n5grLZZfMfiJplgVpT1iZm9913ny6++GKtWLFC733vexWGoZ58cnAozP7+fi1YsEBHHnmk1q9frz/84Q+68MILFYah1qxZU86iAUBFUT8CgB/1IwBUHzumW2nVUo5aFJRrFLMDBw5o6tSpuu6663TRRRd55/nhD3+oM888Uzt37lR7e7sk6d5779XixYu1Z8+eonokN72qb9m8WYc2NeU9iZb8T8Tt/yc9bTbLh8Fgp4++J87uU3H3vbh128va8yaVzfeeu217mbhOYJPW7yu3OQYmayPuaauvnD6+c2XzdZ5qyhC3Py53ObuM9v7Y67CzlHxN55IkPXX1lc8+N76yuPvh+9s34o6ZZq/TPXe+ffNtwz52cZ0Pu8v7zr1v5CW7U1gzj9tRtXv9xnUe6yu3u0732Jl59u/frxNPOGHERkIY6fpx85YtmjhxoqT8c+c7T5J/NEjDdwyLUeroW3b5CtUlbr3oWyZuHXF1ZxJfnW32sdBnK2n5uDL4zlfcd0Mx0wqtq9Cy7vL2377vlkLLxc3nlten0DK+78ok7ufBrT9svvPnZlMWO7JqMd8ZvrK659F3jdvfm3FZVXG/LWq1fpTyRzFLxYz05DY/sdmjI5nmN4OdUGezS/pTY6O/M9a6UmEmZxSz7LYGM0XM9oIwv2mML3PBzYoYLL+/3ovjXp95mSlW1ouPGZ0sCDMKUw3ZEcwGsqQGM4GSmrjFby8Y6Jg7W04rk8ZZX9I5zN+gk9VkLW8yrtxmV7FNvDzHpqgmU0VkRMWuxymDfe7t0cvimg3mHc8B9oh5SZ1/R9d6QpnyFzLXe34n1faof+ZabLCuqShDNOrw3H/uzecxmsdkqdlN9azrMvv5bMhbl2ke6vPKK911NYrZ/ev3VNUoZv/3XW+q+WNfCWXLi/vv//5vvfjii0qlUjrxxBM1efJkfeADH9DTTz8dzbNhwwbNnDkz+nKXpPnz56unp0ebNm3yrrenp0fd3d05L8P9keRLBbT/tlPQ3XRru5mVmcc0G7LX71uPnX4uDaZ2uwEVdx2+H+tu2ZJuxuLeM+nkcfvuspsi+H4o2wEGk65u/u/70Zt0HtzjbDdXsYMe9nTfqGfF/JC2y2iOx7atW/N+zJt1+fpGcZtp2O/Z58q+Duzy2ecxDIKcgIvbr4+9LnsZ0wTAHXHH7g/J7lPDDe6Y7brlTGouaTPNKuymCGZ5e532us3xlJTzOXCb6dnn3Ex3rytfMxr72Jr/28fCnccuZyWMdP3ou67MdMM+T74RIZNu8O1+rdzlbHH95Nh863UDfma9dj1VKDhkr9vdb99Ns29ZM83XDMfeR7e5UtK63c+hmWYv777vbtu9nuOCD+62Cu237xi6dZr7+fdt110u7rwkLesqJcAU19eafUzspmL2PIVGvPN9R7jfjfZ8bv90vv039blbX/m43+Vx9Zrdb567r779SdpmuZWrfpSSf0Pa3GYthd6L/o6CQNmASBg0qH9g1CRzszom06cxmT6N7e/R2P43rKZgg30VmeG1U5nB97IbsuouT3OiYtk32P6+XKzfL25fQQnfm6YZnH2szI23lBtMsz9/eb93lIq2ZZqs2c2gBsuZHCCIO4f2fGa0qyDTHxscsv8f28TLlDehf55CzfoS+32y99dlzktUhoHryToXkvL6F4oaHRZoUhY1zcr4m9p5+yVyyuQ2qUtqfhY1jQwz0ecg71jEBIekwXNkrr0wSA18HlOD5TXNLQeWN5+5Mf29asj0Wa8D0efA90LteeGFF3TRRRdp2rRpamxsVEdHh6699tq8JsxBEOS9brvttpx5nnzySc2dO1eNjY066qijdP3116tMuTnDqmwBom0DP6o6Ozv1uc99Tg888IAmTZqkuXPn6uWXX5YkdXV1qbW1NWe5SZMmady4cerq6vKud+XKlWpubo5eU6ZMKdcuAEBZUD8CgF+56keJOhIADkZ+j2aVfZXDr371K2UyGd1+++16+umn9fd///e67bbbdPXVV+fNe+edd2r37t3R68ILL4ze6+7u1umnn6729nZt3LhRa9as0apVq7R69eqylHs4lRwg6uzs9EbM7NcTTzyhTCYbVb3mmmv053/+55o1a5buvPNOBUGgf/u3f4vWF3iix2EYeqdL0rJly7Rv377otXPnzuwy1tO5uCe0vmwMe1l7ut3JsJnmPtGzlzHcp3Nu5ovboWXceuKe3sVlesQ9BbTfc59Cx23X7sTSPp52Ro2vKZRZt29UFd/TdHtbZlm3Y2I308b3tN3HPX6+0drsp/x2RpM9epx7TM2T4biR7Nyyx4nL6PBlmfk6DLezgMxxc7MzzDpNFpF7zNzjZ2cV2RkY9npMlo87wo/dObb5DNiZRvY0+4m6vS131D47i8IcB98x932W3WvSzbBwMx6GK5Oo2utHN+vL5fscJDHH1G02Zl8HvowTs6zvOjPzmOvarn/d5j523WGvy/78xW3bx13Odx3anz17P8x+29mVvuwdu0xu1pBdLnsbbn3iXvOFjmlcVol9XOI+C3EZP249b2dDFso+ceshX3l96/Jdk77vBN93mnu+7GXs7x63rvBty13WLqPbDNfwXb/u/pt57O9F97eEXRZzTNxz57vOzPeXL/vSlTQK2sGodP0oxdeRJvsh6cbDvTHJBA2D2TFBNhvCbqIy2Cm103n0QEZEEIbZeWJekidLKAii97PbDpRJNSiTGvi/KVOB5mVxisqQCAYzP+ysE7PvmaBBmdSY6GWOT26zIf8ru6yZryEvw8TNdPFlBhXTVMseac5+5XXsXWi0rpysncKZQ9733M7Dnb/d/S7UQXlO2eKKnXBznZPRZP4/sH/2enPOg2ddiWUsok5xz4/9ucmdMch9OQY/E7mfW/PKWZWdxZc5oFTmgIKwX0HYn5ARVXBXMMqcccYZuvPOOzVv3jxNnz5dH/zgB3XVVVfpO9/5Tt68hx12mNra2qJXY2Nj9N63vvUtvfHGG7rrrrs0c+ZMnXvuubr66qu1evXqqs8iKrmT6iVLluj8889PnGfq1Knav3+/JGnGjBnR9HQ6renTp2vHjh2SpLa2Nj3++OM5y+7du1d9fX15T4bsdaTT6cTtmx9h5sek28eL/ePPnsfm/ui3uX2+mPlzbpSCIKcMZvvbtm5VoPgAk8v9sW/fNLnvS/E3unE/vN3/2+sw+2n/6HT7YfL1B+Tr08e9gUwStz++H+1xQTGbfQ4Mt58Ve5q9XjeoYAdL7Gn2teLejLg3Q75zZt9kuXuxbevW6EvPt7/ufts3BOZ9s173HMaVzWUv74oLTLnHLJqm3L6HzDEz++l+Nu2bG5e9Hjf4Z6a7ZTPBqG1bt6ojpn+uoarW+tEOLrrXkl2f5d3kWuuI6yPL7ivKyGlW47ke3OvYd+Ps3vT7yuRb3vd5dddp/20vY//f99k1x8HeR3se+yGAuc7cPsDcdfvK5Cu7XV5bMfvpzhu3nmK2756PuHLEraPQfviCXeY4+uoAX1Aobl+KPabuvvqOZ9x3g69OlazjZX0fmkCb3SQ4rjx2HewLPvk+m3aZ7HmSzk1OWYdZpetHs55CvyELCVMNzgRPs6sCv8miRT3f39H/ZZpUuU3cgujm3DQPys4/sE2FCoPBQMlwBfgGC+B+FnKbW4UJAarW42dp96+25AQ78lYf7Ud8YCapTx83kOITBWOspmj29gf3qSFv2WgdRY6iFtdsLC5Ak9MELGE/A6svpmIU3UeQaQFmNb+yA0bu9e+WoeRR75zzHNiHK8xvWlYUb6Bo7MD2878rfOWI1pF331HaKH8oP7ep8HDU8659+/bp8MMPz5u+ZMkSffSjH9W0adN00UUX6WMf+5hSqew1vmHDBs2dOzenLPPnz9eyZcv0wgsvaNq0acNaxuFUcoCopaVFLS0tBeebNWuW0um0nn32Wb3rXe+SJPX19emFF17QscceK0maM2eOli9frt27d2vy5MmSpLVr1yqdTmvWrFmlFg0AKor6EQD8qB8BYHTLhNlXNTDlcJsKX3vtters7By27WzdulVr1qzRTTfdlDP97/7u7/S+971PjY2Neuihh3TllVfqpZde0uc+9zlJ2abQU6dOzVnGPMDo6uqq6gBRUK5RzCTpiiuu0L//+7/r61//uo499ljdeOON+sEPfqBf/epXmjRpkvr7+3XCCSeotbVVN954o15++WUtXrxY55xzTtHDlJpe1U0P5nGjjbhPz+x54lLJzbz2/+2n5IWyYuKeIvtGEknapvv/uGn2Nn3/2tyn/+7x8s3rltM3Wo/vyaVvO8U89XX3x1ce931fZpDZvhH3dLTQE/C4fSuWe859mWhxGVFJ27IzOOyMHHvEqGIyZJIy0QplLiRtI+nJu2/9cdeG7xr2fcaT9sPOGLRHRxvpUXqkka0ft2zerIkTJxZ9vpLqF5eb/eNmbvq2l/SZtreTtF3fcu6yvvUUus6T9j+ufL73StmvpP0sdh99+5y0v4W+I2xuhoqvjHHHLm5/47K5fOX0rcM3X9xIo4XOU9J+uO8VW75iso9K+S5xM3rNtKSRyYotl/ud7n5f12r9KA3Wkds2rNPEQyfkvW+yP0yWRNScrAi+Ucby5ikig8hdV39q8NluXMfCg6OxxV9bQ+5g116nU35TTnu/3Gwh06xn8ltOUNevNueWyZknW07TWfGB5HL5zktoNY1SfDZPJjUm9nzZnSHbI4EVm72T01SsxD5T3GNnrysu+8m3fHYB/7nKrte/j4HdOXSBcxplFlnryPnceMqQt7/W9TNcmW+DGaSDWXc2c31JBTKKJG820f5XXtX0OafX/Ehapq7895/+vqpGMfuLdx+pnTt35hz7uAyizs5OXXfddYnr3Lhxo2bPnh39vWvXLs2dO1dz587V1772tcRlb7rpJl1//fXat2+fJGnevHmaNm2abr/99mieF198UUcffbQ2bNigd77znUXtZyWUnEFUihtvvFFjxozRokWL9Prrr+ukk07Sww8/rEmTJkmSGhoa9OCDD+rSSy/VKaecosbGRi1cuFCrVq0qeVvbt23ToU1NOWm9vsrF9yMzKTU87kezaSrmrsNej1mHb2Qm3w/1uB+M9g2YL9DlBq7MdswPZrdfH998ccfKPQZ2Myy3uUrSfL6mU+623O36pttBFfeYmW35bppyAkZJP8jyKn//jVPcDYcvIOELWkZlcm4U7HUUE1iRBq8psz7zr3szUSjA5X4m4o5F3Jd20k2fvc2k4J9vneYYFrpps5tvuteub1/dAMZIG8n60RyLpJtWe17fNN/nTRps+pLXrK9AYEmKD9z4thtXbvvGuVDgx8yfNJqaG7gt9ntEym+O7DbRdcsQd0371p30GTL/9wX87fW458gXqHCbXZvPittU0LcNXx1STADL3X/fvsbNY28r7rvOFwzxzeMGzez3bEn1tDst6f24OtgNVJl9c39z2N/Bbpl9x9XdF9+xiK7/AgG2chvJ+lHK3jz6mvNEe57wPVVMIKj4ciTfGGes5j2+4FBcAMS7LaVKCxK55bKvJU+TMjdw0XZ8bmbX7/5nk/obxuVMO5AaF81v9mXcgdcVBg3KNGT33b6hzyleTtOyMGff3ONihmzPDATb7JHWzPuDK045wbog6henmIBPbFOyhJHVDHeY+eyCbtCrf3Df3WNvB5HM+TP1jDs6nbNtSTnnxwxHHygT9a+1f9zhyig3mJcK+tWQOaBDeruVM4qa+xlyymPWOTgyoBUYi/nNHfee3TzT1KPuCHrRvGH2jKbC/sKBKbNcVJ/Gj5CHkdPU1FRUcK7YZs7Grl27dNppp2nOnDm64447Cq7/ne98p7q7u/W73/1Ora2tamtryxs0Yc+ePZKU2BS6GpQ1QDR27FitWrUq8Qv7mGOO0QMPPFDOYgBA1aF+BAA/6kcAqEJhoDAsLROubEosR7HNnKVsps9pp50WDZJg+hVKsnnzZo0fP16HHXaYpGxT6Kuvvlq9vb0aNy4bbF27dq3a29vzmp5Vm6CcTcxGgkl527xliyZOnFgwy6GYdHD771KWcacVygBxnxa66yhUHl82kS/lPGndxWZwGIWa6RV68mrvb9w6kv4u5ljH7a9v3rj3fOX2NQ+MW18x10wxx963bFJZC2XZJLHPtZ2R4bvOCpXJlnTdu/MkXS/utKRt2tvxLeN6pbtbJ5x4Ys2lCLv1oxRfbyV95grVJfZ79ryFmqEm1ddmui8LL245N8PQLUOhdRT7ufRl3Bhx2Ulx+2H+7+vw396mT9KxSHq6Wsx6kspRyufOtw+l1Ie+bJq48vvWlfS9EVfOpDrezliLa6Kd9L1TbB2X9F7Sd2wpv218fJ+JWq0fpcE6cuvjD2nioYfmvFdKZlCxn1uTfZG0nijDzNPELBrhy8pKcTtcLiXjq9gMorhso6TR0sIgpVCBJr/lhGha1682K5Xpj5rJvTYu93oa3Pcwyp4Z29/jvc4TRwWzmqTFZVZls4Ya1J8ak5OZJSk7WpZ1XE25Upm+aBtJnUnHlS2pyZcviycaSS2T32TwwJi0wlSD+lNjZUbIUxiqob83Wr85B8WW0W4KFiqlfjMKnQazrnobxlsj0vnrmf4we35T6teEvn2SpLEHXo+28Wp6UlS2hvBAVJZoBDnrWKScjqpNtlcYBOpLDTYjMteMOd8NA+ff7H/PmEOyI5dZowRKUirIjoyWCvs1/sCr0XZ9n0Of/a+8oo6T3leT9aMtamL2k5d0SJU0MXvtlW79xXtahv3Ym2ZlxxxzjL7xjW+ooWGwfmhra5Mk/eAHP1BXV5fmzJmjxsZGPfLII7ryyiu1ePFi/cM//IOkbMfWf/zHf6z3vve9uvrqq/XrX/9aixcv1uc//3ldeeWVw1becihrBlGlJf0Qy/8iC2Lft3+gJS1n/s5+cSX3DeSuw/0R6N7ouPsg+fvScUc4K7QPvh/Tvv10t510LIoJChX60e+bntRcy7wvxTfrcPfP96Pf957523fzFnfzEVdG33tSfpO8uHPuO+ZxI9iY993jbAcR7WXtG123qYy7PZu9bd8+2aO6ufviXg9J77vlcP9v90Hk66/DXa6Y6bUi7oahmBvpuDqsmGNpB1R9datvXWZ7JmDiNnfxlcWwr0VznSeNfOWuz14urq5OCo74tmX2zTeCnPt+IP9nwd1n854bgCsUHPAdh7jz6fsOKzaAFDfdvhbcv+PqXbfO8TUntJd36/tC39n290rcqKZuENAuj91c0J3PXldcICdpJFV3dD7fsbDX5Z4jt0xJAUpfXWyvu9a5Q8NLpV3jPnHBnsQbzjA5KJXKDDSDMX/bN89u2ey6NiYoVUzgRxo4FqEZLc0XWMg9ViaAYJfv+a3b1TOmTQ1BdlpKGTXogP/3kQabBPU1WEEAE+wJ8gM/0XrCTPb4BEHeMQkVREGVA6mxeU3LzDYyDQ1W0CKTs60g7Fc4sG+lNh/TQLn6B7bt7ldDf2/uPmX6pSDQgTHjJUm9Yw9Rb0NjtC+SNCbTq2OOOz5aZvvW5zXx9d8PlL0/KmHo9IVklzGTGqO+hrQyQcNgM7+c6zc3IJZRKpqeCjOa1vHm2N2NfluPbZYkjQ17NfXNfxS9n23C7Pl9GwZKmaZiwWDWShDk/y6M3rdX0TA4r1mfkRN8HViuPxij18dOjK7ZcQMBrUL9eWUSRrqrRWGYX9VUSrnKsXbtWj3//PN6/vnndfTRRzvbzG507NixuvXWW7V06VJlMhlNnz5d119/vS677LJo3ubmZq1bt06XXXaZZs+erUmTJmnp0qVaunRpeQo+jGo6QAQAAAAAAFDI4sWLtXjx4sR5zjjjDJ1xxhkF1/XWt75VP/nJT4apZCOnZgJE9lNEqXDKuTs97qlj0hNc93172bgMEHvb7ogh9ntxWRlx63XntbM34srsZuS4T4Z9WSTuSFmFMhB8T4XNuu3MkkKZC1L8yDRmG27TkjjFZkLY23afdNvTfGX1PWX3ZfKYY2mzz4+d1WS/b2/HzpTxPcHeum1b3vRisoVsSfP4nmjb09xr0VfGOL7MqLjzldcZvHOe4jI/kjJCaknctWuUml3l+1y723Hnc99PyvDwZQ75lrHrFLs+M8v7siTcstnT3XrGt/++TDrJPzKhuy13Pe70uHUUU1a3vIWy9OLKZcrhZlIV8zkpVLcm1ZvuPviOczFlt5fzdUZvZ5ua68TNCipF0vxux+DmuLjLuFlshdZtd1qddG37mqHb6/BdL25GUtJ3ZK3w1Yd285zBGe3/ZpdJZfpL+w6x57WzXIIgNrsoJwPJLB76R+iKmhSZLCBnvd7RqzzvSfH1ie99wx6lzPbmjmmSsplE2WL5fzcNliU7vT+wblUCk7XSr8DqyNrsS7Z5kjV7aKZl97Nv7IRsM6Mgpf7U2LxMmuxCTnOzsF+psF9j+nuVSTUolTFZRL7vp+TmSAfGjM8223K2a8rZnxoz8BkcLHfvmMac42C2MS7To6P+6K1528gEKe07JNsBbtPrv5dpLnagYVze+uxj47vewyAomCFUSKHfmO49UKDQu72dv35GkjTluBkFt+n9Do3JJsqZJ8xEx8AcL2XMZ8v+DBb+HgJGs6CW+iBqstqPx6XL23/bkm7sk24wkubz3QS5P57jbhriymne9/UL41s2bl1x6eXuNuLYKflJzSqS9tPetluepDLHpX3HpfAXuhaS3vMdo6Sb26TgolRcMKZY9hegfTNktjec26q0pOZiScG5Yj+7lRjGeSTYw9wfOrBfSZ9FI+lzlrRsMTcPST+mkm5E44Ywt4PV9nqKCVi72/bV4e6Ntd0808f9DMb132WXy51e6HvBp1C9FreepO8kN6DvO7++5eM+m24/bu72Sg3MJPE1R7aD1fbfo11c82cpuZ6M+3y4n4V66IPo2Y0/1cRDD5Xp28S9gY/rx8WwhyF3+6ZxgxT5I2pl/27I9MXWT/aoTIMB1JRSmX7/vEP5aW8HgzzD1fvKHFf3v2nG7LxlJP+Ne8FiFbkvJpAjZfstSoX92X6IgsEmXXZgKFt+/9DnLm9wfeBcZwYay6XUryAINcb0U2Sd98E+e3xBmNTA9TY4PTVwrYzJ9Mr0/dOQOaD2P35bUceiGHagLgjD6LrMDByTWqkfi73mwjCIgkipMKOx/W9IUtQnUlzwr/vV1/SW2afUZP1oM3Xltx/9Q1X1QfThuUfU/LGvBMbmAwAAAAAAqHM108TMKJTdYc8Xl/Fjz2vSq+MyEZKezPqm26nzcU+0fU+U3acXbkfMrmLK6KaTS7nNG3zNn6InrwPzuc1A4jKnisnuKKY5QtI5LTZzRMp9km2vOy7TJCkjbDifepfCPTemuWItKvQkK+7zkJTJVm8pwkn1hTtfXEZfUv3qistGSfoM+/423OawZv2mOaG73qQMTd93QaHjY+pDu/PruM+bWYdpBlSo42t3/+PK6M7vfk8ZbhPguOwwXx1tv2fet49xoXrb10TO/vzamVXlfEKdVBfWypNxo1C9H9eU3M3Ks79rzTz1UDdK0mtjJ6ph3MScab59942GlX0jv6NakyliN23Jrjc/EyFQqL6GdF4mkpvhYo/uFYQZpQa2m9thc8PAKFwD24nOq9XMLEhJQRB1SJxJNXizaNxmUCazxazLjBQlDWYNvfjck9r9qy15TcyGqlB2pZHNEGqI/h81ARw4XnbH18Vsy96m9/vQOicNGjwOB1Jjk7cx0LzJdMDsjhQchINZaMU0pxoq0+RPGqgDNPyZ7tWgmN+PUu7nNBOk9EbDBEmD2XTm8+R+nl/vqf0muKg/NRMgmj5tml76/e/zpsc1GYi7GfB9EflS530/lONS7Yv9Qe6+H7cfbpp+0vbs/TLrsJf39YOTVJmadZgbn6TjZ8/vvh93w570g9S3rD3/cPYbMRrV2v6Uwh3tR/IH9mxxN921LOnzF/e+73jGNUUpFPj2HXNfnRUXXLLX5SujzQ7K+I5DXODZ3ke7iVgpfdS46zQjlLn745bdDubYdb2vnvQdF3t77n6aeUeiniimz7JauwmpZr6R0oLQ6rfPmS+uD8R6U2xgImcZX5Alr0lRQpAicP+0P/tOf0FBNsRggjj2aEuZhsFhyA+kxulAamxsvys52/OMEOWWxR6SvK8hrUBhTiDD1y/OcIn7PnfZgSBfky4z3azPBL6mT6/s76hK1Yv1/vtRym+KFgWC3M+dNbqaVB8PGG1hOLQWrOVQLeWoRTQxAwAAAAAAqHM1k0G0fds2TZw40ft0WvI/vfY9efZlCfmeNpumRe6TtmKyecw0d9QdX2q+r/x2poS7jJsi7hupzM20KPWJhdtcwpSh0LH3/d+ez55m739SBtZQs4dQe5KuAbfjYPvvuAyUWuN+7pKaWbnTfc1P3PWa9+KyiJKyC5OyvOzpcZlL7jrDIMjL2rHL53K3G5c5VMjWbdvUYY3I4mZo+kbUsvfVPX72PiRlV8YdE/u7BkiqI831bpoT1lt2ZVJmec60gY9gbFMzj0KZ1UnzRs2YwlAKUgqlnKZn9jxx6wrD7GhfbtOYUspsbyfUQLO21JiS6hZ7dNGDlVQfmveNIAzVYDqOVmh9l2WUCvvVevysYSkTRrekaznKyh3IwssoFXXuDdSimgkQ2c0bpOTgQ9wPnrimBu6Pbzsd0e3LJm49vrK4Nwu+YWvdYEih4XTdEWIKDfU81H4g7MCT+dK3g1X2MUpqQuLeyMR96dvvu+UACvENKS3FX1e1yg2OSfnNtZKah7l/FwqEm+3Y2/AF6t11uk2q7HmTAtC+YIi9v75gti9oberiUvv1coP+9nrCIJA9nLovsJ8kLrhl74e7T9SPKJb9uUm61upBUmA7mm4FZdyRy3LmKyE4lCQMgsFtDASHig3A2yMzucOHD2VUsZQyCoNAY/t7SlrO9xD0YBRzjQZhODASWLbvpqiPpzCMHWkNcNkPjWz1WE+GYVBUc9WRUC3lqEU0MQMAAAAAAKhzNZNBJOVn6viaUJjpdtZAXPMFX1Mz++lvEIZRE4C4LCFfxot5Kh11EJnQZMIWN72YzlPdJmGuYjOJ7CYT7j7Y//qaZ7hPzOOeerv7av5PMwkcDPMZ6Jg+PafJTz0wnyE3e8j+f1x2ji2uuae9Lruu9HWW7GYH+ZqM+jKJ3I7IfXW6r45w6ztfhpGdCepbRymZRPa++7IF3CxPN+vI3n/3//a+uv+nKRkOlptxbK6nLb/4RSWLVVHFZPzEZQ955x1CxkFUzw00a8vvdHmwKVloP/eNmsNlNCbs09Q3/1HeugvVGb/e+hulgn6NyfTJjJTmjqy1betWjet/XUf/0cyS9qtc3OOVyvQrFfYrlTmgI//kpEoWDaOUb6Qzox6ziFD7aiZANH3aNDU1NeXdQNj/j2siIcWPmuMua24U4n40uE3Okm5YfO+5ARf3/0MdyrzQMsXeWJjmZO6wuOHANO/8AwLlVqS+myj3JtIOqAGlsq8dE9DM6Y/I6i+m1sWlSEuF+wYz3CC6r+mZ+cy6dZkv4G6XrVS+Zm5DaTJrXx+F5imF+10QF9hxb8rt93x9yPma6lI/Yijcvtjk/A4y38/1UD9WkyAMFShU+sBrSoX9anvLiUUtt/tXW5RJDY7elT13mYF+dzL63f9sUiZoKGn4+eM6ji04Tyn1T6EHocPF7LOkkvYXMHwP1CBlwuyrGlRLOWoRTcwAAAAAAADqXM1kEG3bvl0TJ05Ux0CWgPs0PKkz1bin4nHNzexlpPynJwfzNNd++m2i12Z9bmfYleBrKuIeI98oUTYzr925taTYzCuejmMoTGaGYToMdjtYd7MLa9W2rVuj+lHyNykz/49rdmvP62v6FHUC7UwbLva6zH6YacPZ+enBsjMj3SzUuO8Z854RBoOjmNn77Y58CZQqagLu+e4t1EwehZVyzIazWaibKbPz189EzcF+8/yzasj0yR79rJLKeW0FynZIfeyb/7gs60dtc1tDUA+iHtVMgAgAAAAAAAy/MMy+qkG1lKMW1UyAaPq0aXrp97+PslKMpA6nbaX26zASnYEOZ2bScInrwNXX2WrcsZZyM7qi/ow0/BkHqE8mW8j83zCZa76+XWqZ3UebOS5JnfSb6b7OrF1unTBSHSVXaruFuOUw2UT28Y3r38ntly10Mizt+YChMt/V5lpzB5ww9aMvq6ieDeU4VPKzancmXS3ZNO7vu+HOjA/CUNM63jxs6wOAelQduabDYPu2bZre0RH9eDYp/ObHThCG0XQ7xX96R0c0qlHH9Ok5waF6GeHoYJljaP5vN/GzbzbteexOWCVFo6IRHMJwsG+sDbsz4npqWiZl60d7RDE38GPqTV+QSFJUP9rNpgjmFsfUbeZf32hu7t92U1u7KZ1d1wJDtXXg95JhRvKTBoPo9u+kepAUuM0opYxSCsPs++P639DY/h6NyfQpFWaUCjMKwlCpgU6RwzBQGBLILYb7G7zU681co2Z5vpNwsMIgUL/GZD/zdfQ7EbDVTAYRAAAAAAAYftkxFqsjaFYt5ahFZc0geu6553T22WerpaVFTU1NOuWUU/TII4/kzLNjxw6dddZZmjBhglpaWnT55Zert7d3SNszGT9xnZWa980TcnfYa0k5TyB4EjE09tMgm0lnN8OK2xlFwHAyTSjMtRV1+DswFLrJ5DCvaRV40juS9eM0J3vSZp7a2hlGcU9i7UwYPrdDY46h2xmwlPvdZWdXAsPJHUjCZA25nadLlft+Hunfj4Y5HiZzyGQNjQn7NC7zhsb1v6EgzKghPKCx/T1q7NuvaR1v1vSODk3reLM6pk/Xmzum6c0d0w6qHPXK1I/293Pci+8ilEPH9Ok6ruNYNff8Xs2v/U7Nr/1OY/t71JA5UDcZlUBZM4gWLFigP/qjP9LDDz+sxsZG3XzzzTrzzDO1detWtbW1qb+/XwsWLNCRRx6p9evX6w9/+IMuvPBChWGoNWvWlLStQimAcV8g/PguL44vKiUu0GsHQsyX/bbt20e2cBrZ+nH7tm2aOHGit/mYFF8/8sO7fKgbUUmFPtt2QL0SN0UjWT8abr9rQTC431M7/uig9wnF47sHlXbkjP/jnb596/OSBrNXCBqhFpUtQPTSSy/p+eef19e//nW97W1vkyR98Ytf1K233qqnn35abW1tWrt2rZ555hnt3LlT7e3tkqSbbrpJixcv1vLly9XU1JS33p6eHvX09ER/d3d3l2sXAKAsqB8BwK9c9aNEHQkAByMjKVMlMbFMpQtQw8rWxOyII47Q8ccfr2984xt69dVXdeDAAd1+++1qbW3VrFmzJEkbNmzQzJkzoy93SZo/f756enq0adMm73pXrlyp5ubm6DVlyhRJgyNv2B3VkXoKwGUyN5JGlCq3ka4fpcGOu906EgBc9gAfI11Hlqt+lOLryIZMf16HyXHN5QHUr2kdb1YQZjS9o0MN4QEFqpJoCTCMypZBFASB1q1bp7PPPlsTJ05UKpVSa2urfvSjH+mwww6TJHV1dam1tTVnuUmTJmncuHHq6uryrnfZsmVaunRp9Hd3d7emTJlSkT5EAIxednBkpJ8iV6J+jHuiDgAuu4lurdSPUnwdeSxDowMo0tQ3Z5ucHvvmPyYLETWp5Ayizs5OBUGQ+HriiScUhqEuvfRSvelNb9JPf/pT/fznP9fZZ5+tM888U7t3747WF/iGFQ1D73RJSqfTampqynkBQDWgfgQAv0rXjxJ1JAAcjDCsrhfKo+QMoiVLluj8889PnGfq1Kl6+OGH9cADD2jv3r3RF/Ctt96qdevW6e6779ZnP/tZtbW16fHHH89Zdu/everr68t7MgQA1Y76EQD8qB8BAKh+JQeIWlpa1NLSUnC+1157TZKUSuUmKaVSKWUy2W6l5syZo+XLl2v37t2aPHmyJGnt2rVKp9NRO3MAGC2oHwHAj/oRAEa3asrcqZZy1KKydVI9Z84cTZo0SRdeeKF+8Ytf6LnnntOnPvUpbd++XQsWLJAkzZs3TzNmzNCiRYu0efNmPfTQQ7rqqqt08cUXk/YLoGZRPwKAH/UjAACVU7YAUUtLi370ox/plVde0Xvf+17Nnj1b69ev1/e+9z29/e1vlyQ1NDTowQcf1Pjx43XKKafoQx/6kM455xytWrWqXMUCgIqjfgQAP+pHAAAqJwjD0Z2g1d3drebmZu3bt4+nRgCGpFbrkVrdLwAjp5brkVreNwDlVy91iNnPf1r7vzpkQnXs52uvduuieYfV/LGvhLJlEAEAAAAAAGB0IEAEAAAAAABQ50oexQwAAAAAANQPRjGrD2QQAQAAAAAA1DkCRAAAAAAAAHWOJmYAAAAAACAWTczqAxlEAAAAAAAAdW7UZxCFA+HD7u7uCpcEwGhl6o+wxh5HUD8COFi1Wj9K1JEADk4t14+oX6M+QLR//35J0pQpUypcEgCj3f79+9Xc3FzpYgwb6kcAw6XW6keJOhLA8KjF+tEnDKVMlcTCiMmVz6gPELW3t2vnzp2aOHGigiCodHFGRHd3t6ZMmaKdO3eqqamp0sWpehyv0tTj8QrDUPv371d7e3ulizKsqB/r4/o9GByv0tTj8arV+lGijqyXa/hgcLxKU2/Hq5brR9SvUR8gSqVSOvrooytdjIpoamqqi8p3uHC8SlNvx6sWn/xQP9bP9XuwOF6lqbfjVYv1o0QdWU/X8MHieJWmno5XrdaPqF+jPkAEAAAAAADKJwwDhWF1ZFtWSzlqEaOYAQAAAAAA1DkCRKNQOp3Wtddeq3Q6XemijAocr9JwvDCacf2WhuNVGo4XRjuu4dJwvErD8QJGvyBkXD4AAAAAAODo7u5Wc3OzbntwnxonVEffUq+/2q1LFjRr3759ddPf1UghgwgAAAAAAKDOESACAAAAAACoc4xiBgAAAAAAYmXC7KsaVEs5ahEZRAAAAAAAAHWOABEAAAAAAECdI0BU5ZYvX66TTz5ZhxxyiA477DDvPDt27NBZZ52lCRMmqKWlRZdffrl6e3tz5nnyySc1d+5cNTY26qijjtL111+vehnA7tZbb9W0adM0fvx4zZo1Sz/96U8rXaQR95Of/ERnnXWW2tvbFQSBvvvd7+a8H4ahOjs71d7ersbGRp166ql6+umnc+bp6enR3/zN36ilpUUTJkzQBz/4Qf32t78dwb0AclE/HjzqxyzqSNQa6seDR/2YRf0IIwyr64XyIEBU5Xp7e3XeeefpE5/4hPf9/v5+LViwQK+++qrWr1+ve++9V/fdd5+uvPLKaJ7u7m6dfvrpam9v18aNG7VmzRqtWrVKq1evHqndqJhvf/vbuuKKK3TNNddo8+bNeve7360PfOAD2rFjR6WLNqJeffVVvf3tb9ctt9ziff+GG27Q6tWrdcstt2jjxo1qa2vT6aefrv3790fzXHHFFbr//vt17733av369XrllVd05plnqr+/f6R2A8hB/XhwqB8HUUei1lA/Hhzqx0HUj0CdCTEq3HnnnWFzc3Pe9P/4j/8IU6lU+OKLL0bT/uVf/iVMp9Phvn37wjAMw1tvvTVsbm4O33jjjWielStXhu3t7WEmkyl72Svp//yf/xNecsklOdPe8pa3hJ/97GcrVKLKkxTef//90d+ZTCZsa2sLv/jFL0bT3njjjbC5uTm87bbbwjAMw//93/8Nx44dG957773RPC+++GKYSqXCH/3oRyNWdsCH+nFoqB/9qCNRS6gfh4b60Y/6sT7t27cvlBTe8v194T89FFbF65bvZ8tk6isMHzKIRrkNGzZo5syZam9vj6bNnz9fPT092rRpUzTP3LlzlU6nc+bZtWuXXnjhhZEu8ojp7e3Vpk2bNG/evJzp8+bN02OPPVahUlWf7du3q6urK+c4pdNpzZ07NzpOmzZtUl9fX8487e3tmjlzJscSVYv6MR71Y/GoI1GLqB/jUT8Wj/oRqD0EiEa5rq4utba25kybNGmSxo0bp66urth5zN9mnlr00ksvqb+/37vvtbzfpTLHIuk4dXV1ady4cZo0aVLsPEC1oX6MR/1YPOpI1CLqx3jUj8WjfgRqDwGiCujs7FQQBImvJ554ouj1BUGQNy0Mw5zp7jzhQM9evmVrjW/f62G/SzWU48SxxHCjfhxZ1I/Fo45EpVE/jizqx+JRP9aHTFhdL5THmEoXoB4tWbJE559/fuI8U6dOLWpdbW1tevzxx3Om7d27V319fVE0v62tLS9Cv2fPHkn5Ef9a0tLSooaGBu++1/J+l6qtrU1S9gnP5MmTo+n2cWpra1Nvb6/27t2b8wRoz549Ovnkk0e2wKhp1I8jg/qxeNSRqBbUjyOD+rF41I9A7SGDqAJaWlr0lre8JfE1fvz4otY1Z84cPfXUU9q9e3c0be3atUqn05o1a1Y0z09+8pOcoUvXrl2r9vb2on9IjEbjxo3TrFmztG7dupzp69at4wvJMm3aNLW1teUcp97eXj366KPRcZo1a5bGjh2bM8/u3bv11FNPcSwxrKgfRwb1Y/GoI1EtqB9HBvVj8agfgdpDBlGV27Fjh15++WXt2LFD/f392rJliyTpzW9+sw499FDNmzdPM2bM0KJFi3TjjTfq5Zdf1lVXXaWLL75YTU1NkqSFCxfquuuu0+LFi3X11Vfr17/+tVasWKHPf/7zNZ/auXTpUi1atEizZ8/WnDlzdMcdd2jHjh265JJLKl20EfXKK6/o+eefj/7evn27tmzZosMPP1zHHHOMrrjiCq1YsULHHXecjjvuOK1YsUKHHHKIFi5cKElqbm7WRRddpCuvvFJHHHGEDj/8cF111VV661vfqve///2V2i3UOerHg0P9OIg6ErWG+vHgUD8Oon6EEYbZVzWolnLUpAqMnIYSXHjhhaGkvNcjjzwSzfOb3/wmXLBgQdjY2Bgefvjh4ZIlS3KGJA3DMPzlL38Zvvvd7w7T6XTY1tYWdnZ21vwQpcY//uM/hscee2w4bty48B3veEf46KOPVrpII+6RRx7xXkcXXnhhGIbZYUqvvfbasK2tLUyn0+F73vOe8Mknn8xZx+uvvx4uWbIkPPzww8PGxsbwzDPPDHfs2FGBvQGyqB8PHvVjFnUkag3148GjfsyifoQZ5v4fvrsvvGNdWBWvf/guw9yXSxCGxN8AAAAAAECu7u5uNTc36x++u0+NE5oqXRxJ0uuvdutvz2nWvn37oqxHDA+amAEAAAAAgFiZTPZVDaqlHLWITqoBAAAAAADqHAEiAAAAAACAOkcTMwAAAAAAEItRzOoDGUQAAAAAAAB1jgARAAAAAABAnaOJGQAAAAAAiEUTs/pABhEAAAAAAECdI0AEAAAAAABQ52hiBgAAAAAAYmUkZaqkaVem0gWoYWQQAQAAAAAA1DkCRAAAAAAAAHWOJmYAAAAAACBWGIYKq2T4sGopRy0igwgAAAAAAKDOESACAAAAAACocwSIUBZTp07Vd7/73UoXY1h87GMf0+GHH662tja98MILCoJA//u//1vpYgEAAADAiAjD6nqhPAgQoarcddddOuGEE3KmdXZ26pxzzqlIef7rv/5L//7v/67t27erq6urImUAAAAAAKDc6KQaSLB9+3Ydc8wxam5urnRRAAAAAKAiwoyUyVS6FFlhlZSjFpFBhLJ5+umn9Y53vENNTU2aP3++du3aJUl6/vnnNX/+fB1++OHq6OjQzTffLEnavHmzLrnkEj355JM69NBDdeihh+ob3/iGVqxYoQceeCCaJkl9fX1atmyZjjnmGB155JH68Ic/rN///vfRtoMg0D/+4z9qxowZmjBhghYtWqSXX35ZH/7wh9XU1KQTTzxRv/rVrxLL/+Uvf1kf/ehHo/IsXrw4b55TTz01Kr8kbdmyRUEQSJK6u7vV0dGhr33ta9H7Z555pv76r/96KIcTAAAAAICyIUCEsvna176me+65R11dXWpra9MFF1ygAwcO6Mwzz9Tb3/527dq1S/fff79uuOEG3XPPPTrxxBN122236a1vfateeeUVvfLKK/rIRz6iq6++WmeeeWY0TZJWrlypBx54QOvXr9f27dsVBIEuuOCCnO1/5zvf0U9/+lM999xzWrt2rd7znvdoyZIlevnll/W2t71Nn/70pxPLf/nll+eU56677ipp/5uamnTPPffoqquu0q9+9Sv9wz/8g379619rzZo1Ja0HAAAAAIByo4kZyuYTn/iE3vKWt0iSbrjhBrW1tem//uu/tHv3bn3hC1/QuHHj9La3vU1LlizRXXfdpYULFxa97m9+85v6whe+oGOOOUaStHr1ah111FHatWuX2tvbJUmf+tSndMQRR0iS5s6dq1QqpXe/+92SpA9/+MP62Mc+Npy763XSSSfpM5/5jM4++2zt3r1bP/7xjzVhwoSybxcAAAAAhks1dQ5dLeWoRWQQoWyOPfbY6P+tra1Kp9P62c9+pvb2do0bNy56b/r06frtb39b0rp/+9vfaurUqdHf7e3tSqfTOetpa2uL/n/IIYfk/W2ykcrtoosu0gsvvKC5c+fqHe94x4hsEwAAAACAUhAgQtn85je/if6/Z88e9fT06J3vfKd27dqlvr6+6L3t27fr6KOPliSlUvmXpG/a0UcfrRdeeCH6u6urSz09PdF6Rsqhhx6q1157Lfp79+7defN89KMf1VlnnaWf/exn+v73vz+SxQMAAAAAFGnq1KkKgiDn9dnPfjZnnh07duiss87ShAkT1NLSossvv1y9vb058zz55JOaO3euGhsbddRRR+n6669XOApSnwgQoWxuv/12Pfvss3r99df1mc98Ru95z3t08sknq7W1VZ///OfV09Ojp556SrfccosuvPBCSdlMo927d+v111+P1tPa2qrf/OY36u/vj6b91V/9lVasWKGdO3fqlVde0dKlS/X+978/al42Ut7xjnfoO9/5jvbt26c9e/bohhtuyHn/y1/+sp599lndfffduvPOO3XRRRdFnXUDAAAAwGiQCavrVU7XX3+9du/eHb0+97nPRe/19/drwYIFevXVV7V+/Xrde++9uu+++3TllVdG83R3d+v0009Xe3u7Nm7cqDVr1mjVqlVavXp1eQs+DAgQoWz++q//Wn/5l3+p1tZWvfjii/rWt76lsWPH6oEHHtCmTZvU1tamD37wg1q6dGnU/9B73/tevfOd79RRRx2lww47TDt27NB5552npqYmtbS06LDDDpMkLVu2TPPnz9ecOXM0depU9fX16Z//+Z9HfB8/+clPavLkyZoyZYre+9736sMf/nD03i9/+Ut97nOf07/8y79owoQJOvPMM7Vw4UItWrRImWoZIxIAAAAAEJk4caLa2tqilxlJW5LWrl2rZ555Rv/8z/+sE088Ue9///t100036atf/aq6u7slSd/61rf0xhtv6K677tLMmTN17rnn6uqrr9bq1aurPosoCKu9hAAAAAAAYMR1d3erublZy+/5X40/pKnSxZEkvfFat65ZeJh27typpqbBMqXTaaXT6YNa99SpU9XT06Pe3l5NmTJF5513nj71qU9Ffeh+/vOf1/e+9z394he/iJbZu3evDj/8cD388MM67bTT9JGPfET79u3T9773vWiezZs36x3veIe2bdumadOmHVQZy4kMIgAAAAAAEMuMYlYtL0maMmWKmpubo9fKlSsPej//9m//Vvfee68eeeQRLVmyRDfffLMuvfTS6P2uri61trbmLDNp0iSNGzdOXV1dsfOYv8081Yph7lHXduzYoRkzZnjfu/3223XBBReMcIkAAAAAAIX4Moh8Ojs7dd111yWua+PGjZo9e7Y++clPRtPe9ra3adKkSfqLv/gLfelLX9IRRxwhSQqCIG/5MAxzprvzmIZbvmWrCQEi1LVjjjlmxIa7BwAAAAAMj6amppwAUZwlS5bo/PPPT5xn6tSp3unvfOc7JUnPP/+8jjjiCLW1tenxxx/PmWfv3r3q6+uLsoTa2tryMoX27NkjSXmZRdWGABEAAAAAAIgVZkKF5R4+rEillqOlpUUtLS1D2tbmzZslSZMnT5YkzZkzR8uXL9fu3bujaWvXrlU6ndasWbOiea6++mr19vZGfRetXbtW7e3tsYGoakEfRAAAAAAAoK5t2LBBf//3f68tW7Zo+/bt+td//Vd9/OMf1wc/+EEdc8wxkqR58+ZpxowZWrRokTZv3qyHHnpIV111lS6++OIom2nhwoVKp9NavHixnnrqKd1///1asWKFli5dShOzcstkMtq1a5cmTpxY9QcbQHUKw1D79+9Xe3u7Uini5gAAAEC9SafT+va3v63rrrtOPT09OvbYY3XxxRfr05/+dDRPQ0ODHnzwQV166aU65ZRT1NjYqIULF2rVqlXRPM3NzVq3bp0uu+wyzZ49W5MmTdLSpUu1dOnSSuxWSUb9MPe//e1vNWXKlEoXA0AN2Llzp44++uhKFwMAAACoCmaY++u+sbeqhrm/9iOTtG/fvqL6IELxRn0G0cSJEyVJ63/6Ux166KEVLg2A0eiVV17Ru9797qg+AQAAAIB6M+oDRKZZ2aGHHsrNHYCDQjNVAAAAAPVq1AeIAAAAAABA+YRh9lUNqqUctYjeWAEAAAAAAOocASIAAAAAAIA6RxMzAAAAAAAQK5MJlclUR9uuailHLSKDqM5N7+ioqu1XujwAAAAAANQjAkQAAAAAAAB1jiZmdciXpTO9o0Pbtm71TvO9V2j9ZjlJOf8vpjy+7ZZaBgAAAADA8GAUs/pQ1gyiAwcO6HOf+5ymTZumxsZGTZ8+Xddff70ymUw0TxiG6uzsVHt7uxobG3Xqqafq6aefLmex6oIJukzv6Mh7FTuvmWaCNfay7jK+/7vzDrX8knICRcOxfgAAAAAAMKisAaIvfelLuu2223TLLbfof/7nf3TDDTfoxhtv1Jo1a6J5brjhBq1evVq33HKLNm7cqLa2Np1++unav39/OYsGAAAAAACKYDKIquWF8ihrgGjDhg06++yztWDBAk2dOlV/8Rd/oXnz5umJJ56QlM0euvnmm3XNNdfo3HPP1cyZM3X33Xfrtdde0z333FPOotUcX/bOwWTWmIwdu1mXm0k0Ulk8vqymcm+zkpKyvMq1vbjsMgAAAABAfShrgOhd73qXHnroIT333HOSpF/84hdav369/uzP/kyStH37dnV1dWnevHnRMul0WnPnztVjjz3mXWdPT4+6u7tzXhg0nEGhpGZdlbZt61ZvEGu4JDXRG67jELce3/6Uq/8lX/9P1XSeAQAAAAAjo6ydVH/mM5/Rvn379Ja3vEUNDQ3q7+/X8uXL9Zd/+ZeSpK6uLklSa2trznKtra36zW9+413nypUrdd1115Wz2AAAAAAAYEAmDJWpkrZd1VKOWlTWANG3v/1t/fM//7Puuece/cmf/Im2bNmiK664Qu3t7brwwguj+YIgyFkuDMO8acayZcu0dOnS6O/u7m5NmTKlPDtQZezMjrgsk6FkfySNXlZNyjmKWaFmXeXYdjWMymaXIa5DcHc+AAAAAEDtKWuA6FOf+pQ++9nP6vzzz5ckvfWtb9VvfvMbrVy5UhdeeKHa2tokZTOJJk+eHC23Z8+evKwiI51OK51Ol7PYVct3426COUnNrZKaMsW9V23BoXLzBUrs9+ygWa0GS4Yz6AgAAAAAGF3K2gfRa6+9plQqdxMNDQ3RMPfTpk1TW1ub1q1bF73f29urRx99VCeffHI5iwYAAAAAAIoQZqrrhfIoawbRWWedpeXLl+uYY47Rn/zJn2jz5s1avXq1/vqv/1pStmnZFVdcoRUrVui4447TcccdpxUrVuiQQw7RwoULy1m0qlCoCY+drWL/385kScp8KYa7XTJGBrkjuLnT6oHbQXm97T8AAAAA1IuyBojWrFmj//f//p8uvfRS7dmzR+3t7fr4xz+uz3/+89E8n/70p/X666/r0ksv1d69e3XSSSdp7dq1mjhxYjmLVlGlDGOeFAjyBZCG40be15SqWvslKodqCYIkHfNyjtxWyjzDXY56aMoHAAAAANWorAGiiRMn6uabb9bNN98cO08QBOrs7FRnZ2c5iwIAAAAAAIYgVKiwSkYPC1Ud5ahFZQ0Qwa+YjqTtzCA3m8LNsHCbqpllStl+oXncJlb1kElUCXHNDoczm6Zaz12h7CGyigAAAACgfAgQjTBfMMdtQmYrdEOcFCgqp3ppblYNDvZclqt54HBfY74mjeXcHgAAAABgEAEiAAAAAAAQK8xImSoZPYxRzMqHAFEFFTNClPuenQXiLh83X5LRkJUxGso4HErtYLzQ/L5rZTgVasY41M61yU4DAAAAgJFHgGgEFbrpTXrfN8y9bahBlIMZ9Ywb+eEz1OBQ3N+VVmhUvmKWG6nR2wAAAAAABIgAAAAAAECCMKyiUcyqpBy1iADRCCpm9LIkbhaRPf1gMoHccpSyjpEY1axaR68aznK5o88Vm2Xj+7vaHUx5k5pcVuM1AgAAAACjRV0HiEq9UXVvSosZYcxd1kwf6rDxxfQ7446KVup+Hmxzp+FWyRt/+1j49nM4AxTu8m4AarQFgsqplCZsvuaYBJYAAAAAIFddB4gAAAAAAECyTJh9VYNqKUctqtsA0VCyMeKa9hSTBZS0rJ31UKhcxWSUJGUAFcquGIpyNTOrpsyOYvat1I7Dk5qo+UaoQ7Jij5nvs9jd3V22cgEAAADAaFAzAaJp06erqalJUmlNv4bDcPSpUmoTs+EUF+AppanZcJWrGoJCw7UvvuNXSlARAAAAAICRUjMBIgAAAAAAMPzCTKiwStp2VUs5alFNBogKdUAb1+FwrSlmH0tpHleu7J5qyBoyynFdFOokGQAAAACASqvJAJGtlP59at3BBmKGe7j5Upqu1dLIU/V+HQIAAAAAqk/NB4gAAAAAAMDQhWH2VQ2qpRy1qGYCRNu3bdPEiRMlxTcxq/emPW4GUClN0IbLUNd3MB1oD3UbAAAAAADUi5oJENmSggblGOa92iQFgewgUTHHothmZcUE34YSzPE1DyxH87JavA5QvO3btlW6CAAAAEDVymRCZaqkc+hqKUctSlW6AAAAAAAAAKismswgKlY9ZI2Ukm1zsE3wytmEj6whlNO06dMrXQQAAAAAqKiyZxC9+OKL+qu/+isdccQROuSQQ3TCCSdo06ZN0fthGKqzs1Pt7e1qbGzUqaeeqqeffrps5Zne0RG9as22rVtLCqTYx8Lu08deT6mBmdEyulgtnn+UzlzrNDEDAAAA4oVhWFUvlEdZA0R79+7VKaecorFjx+qHP/yhnnnmGd1000067LDDonluuOEGrV69Wrfccos2btyotrY2nX766dq/f385iwYAAAAAAIABZW1i9qUvfUlTpkzRnXfeGU2bOnVq9P8wDHXzzTfrmmuu0bnnnitJuvvuu9Xa2qp77rlHH//4x8tZvJoyHJk77shgw5kNNFoyizD6+DoyL2Z+AAAAAMCgsmYQff/739fs2bN13nnn6U1vepNOPPFEffWrX43e3759u7q6ujRv3rxoWjqd1ty5c/XYY49519nT06Pu7u6cVymGOpJWqc23akmpzbHq/Xhh5NjXmPv/uBcAAACA0oSZ6nqhPMoaINq2bZu+8pWv6LjjjtN//ud/6pJLLtHll1+ub3zjG5Kkrq4uSVJra2vOcq2trdF7rpUrV6q5uTl6TZkypZy7AAAAAAAAUPPK2sQsk8lo9uzZWrFihSTpxBNP1NNPP62vfOUr+shHPhLNFwRBznJhGOZNM5YtW6alS5dGf3d3d5ccJLKzCJKyY3zZBr5ptdbh8fSOjrxmO/a0UpCxgaGKu3biPm+19jkEAAAAgJFU1gDR5MmTNWPGjJxpxx9/vO677z5JUltbm6RsJtHkyZOjefbs2ZOXVWSk02ml0+lhK2OxwaJi1lHJG9ShBHCShqX3TR9qkGik2WWPK2+pwQeMrKTrrB6CtAAAAEA1yYShMlUyeli1lKMWlbWJ2SmnnKJnn302Z9pzzz2nY489VpI0bdo0tbW1ad26ddH7vb29evTRR3XyySeXs2gAAAAAAAAYUNYMok9+8pM6+eSTtWLFCn3oQx/Sz3/+c91xxx264447JGWbll1xxRVasWKFjjvuOB133HFasWKFDjnkEC1cuLCcRcszWrJjkrhZFIX2h6yLXByPyhvKZ5DzBgAAAAAHr6wBoj/90z/V/fffr2XLlun666/XtGnTdPPNN+uCCy6I5vn0pz+t119/XZdeeqn27t2rk046SWvXrtXEiRPLWbQcw3WDmdRkqxIKBb2qrbzlUEzgr9aPwWgxXAHa0R7oBQAAAKpNGIYKq6RpV7WUoxaVNUAkSWeeeabOPPPM2PeDIFBnZ6c6OzvLXRQAAAAAAAB4lLUPomrmdmQ8nNkL1ZTBML2jI3r53hvq+qqVyRgajs7HUf0Kndtqv14BAAAAoFrUbYCo3EGcagoSGcN5o1yNN91JfTBVY3mR62DPkS84W20BWwAAAGA0ymTCqnqhPOo2QAQAAAAAAIAsAkRlVI3ZC2TSDKL5UfVJahLpU22fLwAAAAAYrWo2QMSNP1z2NcH1URs4jwAAAED5hWF1vVAeNRsgAgAAAAAAQHHKPsx9pdD0JN5wdAZcjQp1Sm3eJ+tkdDAj0iWp1msRAAAAAEabmg0QVZNtW7fWRFDCF4Cp1ht0X7lq4RzUAwJ5AAAAQHUJw1BhlYweFtLGrGxoYgYAAAAAAFDnyCAaIaM5i8iXjWP2p9oziUbrMUfha6qYJmgAAAAADl4YhspUSeYOGUTlQwbRCKqlm1kCLyiHUj4jtfR5AgAAAIBKI0AEAAAAAABQ52hihiEZLdkbo7lpH+LRvAwAAAAYOWGmijqprpJy1CICRCjIDbCMthtzgkSjA83LAAAAAKByaGIGAAAAAABQ58ggQtFqPWvD7B/ZRiOvmGuLZmUAAABAZdDErD4QIEIe+yZ8tN+UJwV73P00+0qTtJHlu758zRpH83UIAAAAANWOJmYAAAAAAAB1jgwiJBptWRvFZP749slkDdlZRMWuD0PnnovR3iE6AAAAUIsyYfZVDaqlHLVoxDKIVq5cqSAIdMUVV0TTwjBUZ2en2tvb1djYqFNPPVVPP/30SBUJyEFQaGSYAFxcoM6eBwAAAAAwMkYkQLRx40bdcccdetvb3pYz/YYbbtDq1at1yy23aOPGjWpra9Ppp5+u/fv3j0SxAAAAAAAAoBEIEL3yyiu64IIL9NWvflWTJk2KpodhqJtvvlnXXHONzj33XM2cOVN33323XnvtNd1zzz3lLhYcSVkdtSJu/+yMIbuT6rgOumv5GAEAAACAy4xiVi0vlEfZA0SXXXaZFixYoPe///0507dv366uri7NmzcvmpZOpzV37lw99thjsevr6elRd3d3zgsYbnYQKO7/KF2xx49mfgAAAAAwssraSfW9996r//7v/9bGjRvz3uvq6pIktba25kxvbW3Vb37zm9h1rly5Utddd93wFhQAAAAAAKCOlS1AtHPnTv3t3/6t1q5dq/Hjx8fOFwRBzt9hGOZNsy1btkxLly6N/u7u7taUKVMOvsCoW8VktZhmZ3F/I6tQEz4AAAAAo08YhgrD6mjaVS3lqEVlCxBt2rRJe/bs0axZs6Jp/f39+slPfqJbbrlFzz77rKRsJtHkyZOjefbs2ZOXVWRLp9NKp9PlKjYAAAAAAEDdKVsfRO973/v05JNPasuWLdFr9uzZuuCCC7RlyxZNnz5dbW1tWrduXbRMb2+vHn30UZ188snlKlbF0YdNsmrKNiEbZniU0u+QOb58TgAAAABgZJUtg2jixImaOXNmzrQJEyboiCOOiKZfccUVWrFihY477jgdd9xxWrFihQ455BAtXLiwXMWqCtXWPKmabsYPtixm+bgRyMx7Q92222F1NZ3HauA2w/O9X03XGwAAAIDCMhkpUyWjh2UylS5B7SprJ9WFfPrTn9brr7+uSy+9VHv37tVJJ52ktWvXauLEiZUsFgAAAAAAQF0Z0QDRj3/845y/gyBQZ2enOjs7R7IYqAPlaB7mW2epWUr1otQsoXo/XgAAAABQaRXNIKpn1dI8qVab+1TDsUUy3zmq1esRAAAAGM0Yxaw+lK2TagAAAAAAAIwOBIjqWK1ma5A9VJ22bd2a04m4730AAAAAqIQf//jHCoLA+9q4cWM0n+/92267LWddTz75pObOnavGxkYdddRRuv7660dF5hNNzCrIviEe6aBGrd6MH8xxLDTEejEjcBGc8vNd67V6DQIAAAC1JsyECqtkFLNylePkk0/W7t27c6b9v//3//T//X//n2bPnp0z/c4779QZZ5wR/d3c3Bz9v7u7W6effrpOO+00bdy4Uc8995wWL16sCRMm6MorryxL2YcLASIAAAAAADCqdHd35/ydTqeVTqeHvL5x48apra0t+ruvr0/f//73tWTJEgVBkDPvYYcdljOv7Vvf+pbeeOMN3XXXXUqn05o5c6aee+45rV69WkuXLs1bVzWhiVkdqtXMjeHK3nHXM72jI5pGhlBxCh2nWr0GAQAAgFpkMoiq5SVJU6ZMUXNzc/RauXLlsO7z97//fb300ktavHhx3ntLlixRS0uL/vRP/1S33XabMplM9N6GDRs0d+7cnGDV/PnztWvXLr3wwgvDWsbhRgYR4JHUDIog0cEhOAQAAADgYO3cuVNNTU3R3weTPeTzT//0T5o/f76mTJmSM/3v/u7v9L73vU+NjY166KGHdOWVV+qll17S5z73OUlSV1eXpk6dmrNMa2tr9N60adOGtZzDiQARAAAAAAAYVZqamnICRHE6Ozt13XXXJc6zcePGnH6Gfvvb3+o///M/9a//+q9585pAkCSdcMIJkqTrr78+Z7rbjMx0UF3NzcskAkQ1LWnEKBSHYwcAAACg3mUUKlMlo3BlVFo5lixZovPPPz9xHjfj584779QRRxyhD37wgwXX/853vlPd3d363e9+p9bWVrW1tamrqytnnj179kgazCSqVgSIqsS2rVsPKhiR1GynkqOlIdnBnncAAAAAQLyWlha1tLQUPX8Yhrrzzjv1kY98RGPHji04/+bNmzV+/HgddthhkqQ5c+bo6quvVm9vr8aNGydJWrt2rdrb2/MCUdWGTqoBAAAAAAAkPfzww9q+fbsuuuiivPd+8IMf6Ktf/aqeeuopbd26VV/72td0zTXX6GMf+1jUB9LChQuVTqe1ePFiPfXUU7r//vu1YsWKqh/BTCKDqCbUW6e/0zs6oswbmtEBAAAAQHnZo4dVWrnL8U//9E86+eSTdfzxx+e9N3bsWN16661aunSpMpmMpk+fruuvv16XXXZZNE9zc7PWrVunyy67TLNnz9akSZO0dOlSLV26tKzlHg4EiKoIwY7iVHOTuVLPoR3kcqePZu4+JY0KBwAAAADV4p577ol974wzztAZZ5xRcB1vfetb9ZOf/GQ4izUiaGIGAAAAAABQ5wgQVaFtW7dGL4wuQ8n8sZep1UwbrmcAAABg9ArDsKpeKA+amI1ypd50c5NeXsN5fJPWVc1N0Oz+oeKa0AEAAAAAqgsZRAAAAAAAAHWOAFGVK3f2RTVnoiSp1nJP7+gYUtaMWc78f7Ry95vsIQAAAGD0CzOhMlXyqpbR1GoRAaJRoJw32dzAl8/BHNtCQaJqPG/VWCYAAAAAQHEIEAEAAAAAANS5sgaIVq5cqT/90z/VxIkT9aY3vUnnnHOOnn322Zx5wjBUZ2en2tvb1djYqFNPPVVPP/10OYtV9+zmTKPRaC57KUbDfsaNuEc2EQAAAFA7woGmXdXyQnmUNUD06KOP6rLLLtPPfvYzrVu3TgcOHNC8efP06quvRvPccMMNWr16tW655RZt3LhRbW1tOv3007V///5yFi1PtQdN4m6448ps9sf3vllXNe9vktEQfBiOY1toP4d6HOygzlDWYZYZDecBAAAAAFCcsg5z/6Mf/Sjn7zvvvFNvetObtGnTJr3nPe9RGIa6+eabdc011+jcc8+VJN19991qbW3VPffco49//ON56+zp6VFPT0/0d3d3dzl3AQAAAAAAoOaNaB9E+/btkyQdfvjhkqTt27erq6tL8+bNi+ZJp9OaO3euHnvsMe86Vq5cqebm5ug1ZcqUYSnbULMpKs1X5mKyV8z+Vnvm1GhX7muq1Ot2OLKOuF4AAACA+hKGYVW9UB4jFiAKw1BLly7Vu971Ls2cOVOS1NXVJUlqbW3Nmbe1tTV6z7Vs2TLt27cveu3cuXNYyznabn4PdrQrO8CQ1CwNpbGPe7mDRMWer7hyFFM+rgkAAAAAqG1lbWJmW7JkiX75y19q/fr1ee8FQZDzdxiGedOMdDqtdDpdljICAAAAAADUoxHJIPqbv/kbff/739cjjzyio48+Opre1tYmSXnZQnv27MnLKhop1dzMLKmj6qFk/9jz2v8f7Z1YV4ODPXbD3WxsOK/r0docEwAAAMDQhJlMVb1QHmUNEIVhqCVLlug73/mOHn74YU2bNi3n/WnTpqmtrU3r1q2LpvX29urRRx/VySefXM6ijVrDeXPuNoNy100Q4OD4gm6FDOX8Hmwzw3IguAgAAAAAo0tZm5hddtlluueee/S9731PEydOjDKFmpub1djYqCAIdMUVV2jFihU67rjjdNxxx2nFihU65JBDtHDhwnIWDQAAAAAAAAPKGiD6yle+Ikk69dRTc6bfeeedWrx4sSTp05/+tF5//XVdeuml2rt3r0466SStXbtWEydOLGfRRj2agdWegxlhbCSuA7MNMssAAACA+pLJhMpkqmP0sGopRy0qa4ComOHngiBQZ2enOjs7y1mUmuXerLuBgqE0c8Lwmd7RMSJ9BPmCREPtx4igIwAAAADUnxEbxQwAAAAAAIw+YRgWlQAyEqqlHLVoREYxw8ghS6j6JGXk1PKIYGQiAQAAAMDoQYCoBtVy0GG08jX/Gu5zNJT1lSuIQx9ZAAAAADC60MQMAAAAAADECjOhwirpHLpaylGLyCCqYWQSVRdzPuLOSSWybZKuj+G6dsgiAgAAAIDqR4AIkekdHdELI68ag3nV1GwNAAAAAFA+NDEDAAAAAACxaGJWHwgQ1ZHpHR1FN28yf2/bujXnvWrJcnHLNRrElbdajqnkL6M51sWU071Wil0OAAAAAFBZNDGrA4X6IkoKtFRzEIbAQ7LhPHelHGvOCwAAAACMPmQQAQAAAACAWBlllAkzlS6GpGxZUB5kENURk9lhMkuG0iF1tXViTbZKLnektGLOldss7GCOqb2sfZ0BAAAAAKobAaI6ZG7iDyYQUE03/aM5SFQNZfeVYTj6eDrYYBMAAAAAYOTQxAwAAAAAAMQKM9UzeliVtHSrSWQQYchMc7NqyCYqJlPFbX5V64ZjX0s5t6NhlDYAAAAAgB8ZRBgW1TCcud0sqtJlKUa1lXGox84ODFXDdQAAAAAAKB0BIgAAAAAAECvMhFXUxKw6ylGLaGJWx4a7aVi1NDWjudnQDMex4HgCAAAAwOhEgAh1rxJBjWoOpJh+pYopYzUEBQEAAAAAB48mZgAAAAAAIFYYhgrD6mjaVS3lqEVVkUF06623atq0aRo/frxmzZqln/70p5UuElA21Zw95JbN7vjbNZTsITKOAAAAAKA6VTxA9O1vf1tXXHGFrrnmGm3evFnvfve79YEPfEA7duyodNFqVrUMTV8tRvJYVHNwSModhSxuVLOhXD9ccwAAAABQ3SoeIFq9erUuuugiffSjH9Xxxx+vm2++WVOmTNFXvvKVShcNAAAAAIC6l8lkquqF8qhogKi3t1ebNm3SvHnzcqbPmzdPjz32mHeZnp4edXd357xQPcgSiVft2UPSYBntLKKhZAv51mteXCMAAAAAUH0qGiB66aWX1N/fr9bW1pzpra2t6urq8i6zcuVKNTc3R68pU6aMRFFRApoT1ZZSAlvmvCddAyZIxDUCAAAAANWj4k3MJCkIgpy/wzDMm2YsW7ZM+/bti147d+4ciSICAAAAAFCXwkxYVS+UR0UDRC0tLWpoaMjLFtqzZ09eVpGRTqfV1NSU80J1IkMkyzStGq1Kyfax9zMpU8h3PLheAAAAAKByxlRy4+PGjdOsWbO0bt06/d//+3+j6evWrdPZZ59dwZJhuLg3/dUYKKFfnOIlNRvzve8bAc2e5s5v/x13rbjrAAAAAFBeYZhRGFZH59DVUo5aVNEAkSQtXbpUixYt0uzZszVnzhzdcccd2rFjhy655JJKFw0AAAAAAKAuVDxA9OEPf1h/+MMfdP3112v37t2aOXOm/uM//kPHHntspYuGMjAZItWWAUIWUT7fMSm1w2p3frcJmpmv2OXtclXbNQQAAAAAo1lVdFJ96aWX6oUXXlBPT482bdqk97znPZUuEsqsGoMx5Qg4jPYghjvsfTm34eO7TggOAQAAACOr0p1S00n1yKiKABEAAAAAAAAqp+JNzABUt1KydUptgmaWSWriZzKG3OaJZBIBAAAAwPAhQFSH6G8HpSpmdLFSlXod+vozIkgEAAAAjIBqatpVLeWoQTQxAwAAAAAAqHNkEKFiyP4YPezzNJzZRMO1PNcSAAAAABwcAkR1qhqamdXDDX0tBi7KtT/Fjmbmm49AEQAAAFA+mTCjTJipdDEkqWrKUYtoYgYAAAAAAFDnyCACLNWQWTWa+Y7dcGT0FLsOOq4GAAAAgKEhQFTHCIbkG+7jUW+BilKHuR/q8XGHvB9qGQAAAAAUFlbRKGbVUo5aRBMzAAAAAACAOkeACBVRL1kebkYSGVtZ5jhM7+iIXqXYtnVr3VxDAAAAADASaGIGAAAAAABihWFGYaY6Rg8LGcWsbGo6g4hsjcIqkYVRT5kf7r7afw8lc6YWFNORdT0eFwAAAACopJoOENVTIALViUBHVqGmZL7p9RpAAwAAAIBKoIkZAAAAAACIxShm9aGmM4iAakVmTC6y/QAAAACgsggQgZvzMvId23oLDhWzv0nz1NvxAgAAAIBKoIkZAAAAAACIFYaZqhk9rFrKUYsIEEHSYKYL2RrDp96zh0rd10odm+kdHfrFli0V2TYAAAAAVIuyNTF74YUXdNFFF2natGlqbGxUR0eHrr32WvX29ubMt2PHDp111lmaMGGCWlpadPnll+fNg5FT7uZm9dKcrdj9rJfjcTC4JgEAAACg/MqWQfSrX/1KmUxGt99+u9785jfrqaee0sUXX6xXX31Vq1atkiT19/drwYIFOvLII7V+/Xr94Q9/0IUXXqgwDLVmzZpyFQ0AAAAAABQpk5EyVTJ6WIYWZmVTtgDRGWecoTPOOCP6e/r06Xr22Wf1la98JQoQrV27Vs8884x27typ9vZ2SdJNN92kxYsXa/ny5WpqaipX8QCMEtM7OsjyAQAAAIAyG9FRzPbt26fDDz88+nvDhg2aOXNmFBySpPnz56unp0ebNm3yrqOnp0fd3d05L6Ca1HswY3pHx7D3JzSU9dVTf08AAABAOYWZTFW9UB4jFiDaunWr1qxZo0suuSSa1tXVpdbW1pz5Jk2apHHjxqmrq8u7npUrV6q5uTl6TZkypazlBgAAAAAAqHUlB4g6OzsVBEHi64knnshZZteuXTrjjDN03nnn6aMf/WjOe0EQ5G0jDEPvdElatmyZ9u3bF7127txZ6i6gQkZDZs1IlrGWRjkzWUPlLH+p6962deuoPZ4AAAAAMNJK7oNoyZIlOv/88xPnmTp1avT/Xbt26bTTTtOcOXN0xx135MzX1tamxx9/PGfa3r171dfXl5dZZKTTaaXT6VKLDVRcMcGK0RBEc1VzEMYEiUbjcQUAAACqRZgJFVZJJ9XVUo5aVHKAqKWlRS0tLUXN++KLL+q0007TrFmzdOeddyqVyk1YmjNnjpYvX67du3dr8uTJkrIdV6fTac2aNavUogEAAAAAAGAIytYH0a5du3TqqadqypQpWrVqlX7/+9+rq6srp2+hefPmacaMGVq0aJE2b96shx56SFdddZUuvvhiRjCrIdu2bh1VGRyjqaz1ZijZSpxPAAAAACisbMPcr127Vs8//7yef/55HX300TnvhWE2JayhoUEPPvigLr30Up1yyilqbGzUwoULtWrVqnIVCyOs3m7Ok/aXPnEAAAAAjEZhmFEYVsfoYdVSjlpUtgDR4sWLtXjx4oLzHXPMMXrggQfKVQwAAAAAAAAUMGLD3KP+1Fv2UCk4NgAAAACAalK2DCLUNwIgfrV2XCrRZI5RyQAAAICRxShm9YEMIgAAAAAAgDpHgAjAkFUqk4fOvgEAAAAMt+XLl+vkk0/WIYccosMOO8w7z44dO3TWWWdpwoQJamlp0eWXX67e3t6ceZ588knNnTtXjY2NOuqoo3T99ddHg3UZjz76qGbNmqXx48dr+vTpuu2228q1W0UjQIRhVwvNf4ayD7Ww36MJQSIAAABgZISZTFW9yqW3t1fnnXeePvGJT3jf7+/v14IFC/Tqq69q/fr1uvfee3XffffpyiuvjObp7u7W6aefrvb2dm3cuFFr1qzRqlWrtHr16mie7du368/+7M/07ne/W5s3b9bVV1+tyy+/XPfdd1/Z9q0Y9EEEAAAAAADq3nXXXSdJuuuuu7zvr127Vs8884x27typ9vZ2SdJNN92kxYsXa/ny5WpqatK3vvUtvfHGG7rrrruUTqc1c+ZMPffcc1q9erWWLl2qIAh022236ZhjjtHNN98sSTr++OP1xBNPaNWqVfrzP//zkdhVLzKIgBhkBBWnUseJ8wMAAACMjP4Dr+pAX3W8+g+8KimbqWO/enp6yn4cNmzYoJkzZ0bBIUmaP3++enp6tGnTpmieuXPnKp1O58yza9cuvfDCC9E88+bNy1n3/Pnz9cQTT6ivr6/s+xGHDCJgGBCsGFkcbwAAAKD8xo0bp7a2Nj3x0IcqXZQchx56qKZMmZIz7dprr1VnZ2dZt9vV1aXW1tacaZMmTdK4cePU1dUVzTN16tScecwyXV1dmjZtmnc9ra2tOnDggF566SVNnjy5fDuRgAARAAAAAADIM378eG3fvj2vE+ZKC8NQQRDkTLMzdmydnZ1R07E4Gzdu1OzZs4vatrtdX3nceUwH1aXOM9IIECHHwXb8W4+ZHfW4z5U2vaOD4w4AAACMgPHjx2v8+PGVLsaQLVmyROeff37iPG7GT5y2tjY9/vjjOdP27t2rvr6+KCOora0tyiYy9uzZI0kF5xkzZoyOOOKIospSDgSIMGy4Ya9f27ZuLTq4aK4TRiEDAAAAUG4tLS1qaWkZlnXNmTNHy5cv1+7du6NmYGvXrlU6ndasWbOiea6++mr19vZq3Lhx0Tzt7e1RIGrOnDn6wQ9+kLPutWvXavbs2Ro7duywlHUo6KQaAAAAAADUvR07dmjLli3asWOH+vv7tWXLFm3ZskWvvPKKJGnevHmaMWOGFi1apM2bN+uhhx7SVVddpYsvvlhNTU2SpIULFyqdTmvx4sV66qmndP/992vFihXRCGaSdMkll+g3v/mNli5dqv/5n//R17/+df3TP/2TrrrqqortuyQFoWnoNkp1d3erublZWzZv1sSJEytdnFFvqFkdtZo9VOh41Op+lyrpOCUdo2q53vbv368TTjxR+/btiyp2AAAAAPVl8eLFuvvuu/OmP/LIIzr11FMlZYNIl156qR5++GE1NjZq4cKFWrVqVU4fSE8++aQuu+wy/fznP9ekSZN0ySWX6POf/3xO/0KPPvqoPvnJT+rpp59We3u7PvOZz+iSSy4p+z4mIUCEHNVyw15NzDGp5X08WAdzjEq95spxHggQAQAAAKh3NDEDAAAAAACoc3RSjUg1ZHJUo3rZz4NxMMeoEp1WMwoaAAAAAOQigwhAVRjJgA3BIQAAAADIRYAIAAAAAACgzhEgAlA1RjKzZySbtAEAAABAtRuRAFFPT49OOOEEBUGgLVu25Ly3Y8cOnXXWWZowYYJaWlp0+eWXq7e3dySKBaAKbdu6NS9QZKYNZwBp29atmt7RQaAIAAAAADRCnVR/+tOfVnt7u37xi1/kTO/v79eCBQt05JFHav369frDH/6gCy+8UGEYas2aNSNRNAAAAAAAgLpX9gDRD3/4Q61du1b33XeffvjDH+a8t3btWj3zzDPauXOn2tvbJUk33XSTFi9erOXLl6upqancxUOJ6NwXI6Wc15qdNcQ1DQAAAABlbmL2u9/9ThdffLG++c1v6pBDDsl7f8OGDZo5c2YUHJKk+fPnq6enR5s2bfKus6enR93d3TkvHDya2aCeDHdzNQAAAAAY7coWIArDUIsXL9Yll1yi2bNne+fp6upSa2trzrRJkyZp3Lhx6urq8i6zcuVKNTc3R68pU6YMe9kBAAAAAADqSckBos7OTgVBkPh64okntGbNGnV3d2vZsmWJ6wuCIG9aGIbe6ZK0bNky7du3L3rt3Lmz1F0AUMdoXgYAAAAA+Urug2jJkiU6//zzE+eZOnWqvvCFL+hnP/uZ0ul0znuzZ8/WBRdcoLvvvlttbW16/PHHc97fu3ev+vr68jKLjHQ6nbdOlBc30agkE9DhOgQAAACA8ik5QNTS0qKWlpaC8335y1/WF77whejvXbt2af78+fr2t7+tk046SZI0Z84cLV++XLt379bkyZMlZTuuTqfTmjVrVqlFAwAAAAAAwBCUbRSzY445JufvQw89VJLU0dGho48+WpI0b948zZgxQ4sWLdKNN96ol19+WVdddZUuvvhiRjAbYdu2bqWjatQ8rnEAAAAA8Cv7MPdJGhoa9OCDD+rSSy/VKaecosbGRi1cuFCrVq2qZLEAVJHhalpGcAgAAAAA4o1YgGjq1KkKwzBv+jHHHKMHHnhgpIoBAAAAAAAAR9mGucfoEpddQcfAqAWMXAYAAAAAyQgQgeAQAAAAAAB1jgARAAAAAABAnatoJ9WobtM7OsgiQk3gOgYAAACAZGQQgZtnAAAAAADqHAEiAAAAAACAOkeACHRSPUrFnTcAAAAAAEpFgAgYpQjgAQAAAACGCwEiAAAAAACAOkeACN5MFLJTAAAAAACoHwSIUDL6vgEAAAAAoLYQIAIAAAAAAKhzBIjglZQlRPMzAAAAAABqCwEiSCLoAwAAAABAPSNABAAAAAAAUOcIECGybevWnEwiOqMGAAAAAKA+jKl0AVB9aG4GAAAAAEB9IYMIAAAAAACgzhEgAgAAAAAAqHNlDxA9+OCDOumkk9TY2KiWlhade+65Oe/v2LFDZ511liZMmKCWlhZdfvnl6u3tLXexAAAAAAAAMKCsfRDdd999uvjii7VixQq9973vVRiGevLJJ6P3+/v7tWDBAh155JFav369/vCHP+jCCy9UGIZas2ZNOYsGAAAAAACAAUEYhmE5VnzgwAFNnTpV1113nS666CLvPD/84Q915plnaufOnWpvb5ck3XvvvVq8eLH27Nmjpqamgtvp7u5Wc3OztmzerIkTJw7rPgCoD/v379cJJ56offv2FVXvAAAAAECtKVsTs//+7//Wiy++qFQqpRNPPFGTJ0/WBz7wAT399NPRPBs2bNDMmTOj4JAkzZ8/Xz09Pdq0aZN3vT09Peru7s55AQAAAAAAYOjKFiDatm2bJKmzs1Of+9zn9MADD2jSpEmaO3euXn75ZUlSV1eXWltbc5abNGmSxo0bp66uLu96V65cqebm5ug1ZcqUcu0CAAAAAABAXSg5QNTZ2akgCBJfTzzxhDKZjCTpmmuu0Z//+Z9r1qxZuvPOOxUEgf7t3/4tWl8QBHnbCMPQO12Sli1bpn379kWvnTt3lroLAAAAAAAAsJTcSfWSJUt0/vnnJ84zdepU7d+/X5I0Y8aMaHo6ndb06dO1Y8cOSVJbW5sef/zxnGX37t2rvr6+vMwiex3pdLrUYmOYTO/okCRt27q1wiUBAAAAAADDpeQAUUtLi1paWgrON2vWLKXTaT377LN617veJUnq6+vTCy+8oGOPPVaSNGfOHC1fvly7d+/W5MmTJUlr165VOp3WrFmzSi0aAAAAAAAAhqBsw9w3NTXpkksu0bXXXqspU6bo2GOP1Y033ihJOu+88yRJ8+bN04wZM7Ro0SLdeOONevnll3XVVVfp4osvZiShKmVnDk3v6CCTCAAAAACAGlC2AJEk3XjjjRozZowWLVqk119/XSeddJIefvhhTZo0SZLU0NCgBx98UJdeeqlOOeUUNTY2auHChVq1alU5iwUAAAAAAABLEIZhWOlCHIzu7m41Nzdry+bNmjhxYqWLU/NMH0QS/RChduzfv18nnHii9u3bR/YiAAAAgLpU1gwi1AaCQgAAAAAA1LaSh7kHAAAAAABAbSGDCKgC1ZClZZfB5SuTmZ+sMgAAAAAY/QgQIZEbNGDksuGXFJiplm0kLR8XKHKXMe8XWxauMwAAAAAYOTQxAwAAAAAAqHNkECGWL9ODrI6DU0z2zHBl2IxEZlIp2yu1PNXQ7A4AAAAA6gUBIuSwm5Bt27p1xIMMo1FSIKOcx+9gm3CNJoX2iQASAAAAABwcmpgBAAAAAADUOTKI6pzJGLIzNEZ7Bkoly1+v2640Ok8HAAAAgINDgAg1EViohX3AwUm6BggeAQAAAEAympgBAAAAAADUOTKIRpnhHllstHdEPZrLjpFjrhMyiQAAAADAjwBRDSh1hKe4INNoCLaMhjKi+hAYAgAAAIBkNDEDAAAAAACoc2QQjYBSsl4KZToMJdOnmPmrPTOn2suH6kTmEAAAAAAUhwDRMBjO4IW9LnNzW89DeBMYwlDU6+cFAAAAAIaKJmYAAAAAAAB1jgyiIlQqi8XebrVk0gz3KGrFbgMAAAAAAJQPAaICCFYU5h6joQSMOM4AAAAAAFQOTcwAAAAAAADqXFkDRM8995zOPvtstbS0qKmpSaeccooeeeSRnHl27Nihs846SxMmTFBLS4suv/xy9fb2lrNYXtM7OrwvlK7Y48ZxRrlwTQEAAABAacraxGzBggX6oz/6Iz388MNqbGzUzTffrDPPPFNbt25VW1ub+vv7tWDBAh155JFav369/vCHP+jCCy9UGIZas2bNsJaFG8aRxfFGpcVdg9u2bq3rkQEBAAAAwKdsAaKXXnpJzz//vL7+9a/rbW97myTpi1/8om699VY9/fTTamtr09q1a/XMM89o586dam9vlyTddNNNWrx4sZYvX66mpqa89fb09Kinpyf6u7u7u1y7AAAAAAAAUBfKFiA64ogjdPzxx+sb3/iG3vGOdyidTuv2229Xa2urZs2aJUnasGGDZs6cGQWHJGn+/Pnq6enRpk2bdNppp+Wtd+XKlbruuuu82yRrBUAh1BMAAAAAkK9sAaIgCLRu3TqdffbZmjhxolKplFpbW/WjH/1Ihx12mCSpq6tLra2tOctNmjRJ48aNU1dXl3e9y5Yt09KlS6O/u7u7NWXKFE2bPr1cuwKgBtmBIjIRAQAAANS7kjup7uzsVBAEia8nnnhCYRjq0ksv1Zve9Cb99Kc/1c9//nOdffbZOvPMM7V79+5ofUEQ5G0jDEPvdElKp9NqamrKeQEAAAAAAGDoSs4gWrJkic4///zEeaZOnaqHH35YDzzwgPbu3RsFcW699VatW7dOd999tz772c+qra1Njz/+eM6ye/fuVV9fX15mEQAAAAAAAMqj5ABRS0uLWlpaCs732muvSZJSqdwkpVQqpUwmI0maM2eOli9frt27d2vy5MmSpLVr1yqdTkf9FAEAAAAAAKC8Sm5iVqw5c+Zo0qRJuvDCC/WLX/xCzz33nD71qU9p+/btWrBggSRp3rx5mjFjhhYtWqTNmzfroYce0lVXXaWLL76YpmMAAAAAAAAjpGwBopaWFv3oRz/SK6+8ove+972aPXu21q9fr+9973t6+9vfLklqaGjQgw8+qPHjx+uUU07Rhz70IZ1zzjlatWpVuYoFAAAAAAAARxCGYVjpQhyM7u5uNTc3a9++fWQdARgS6hEAAAAA9a5sGUQAAAAAAAAYHQgQAQAAAAAA1DkCRAAAAAAAAHWOABEAAAAAAECdI0AEAAAAAABQ5wgQAQAAAAAA1DkCRAAAAAAAAHVuTKULcLDCMJQkdXd3V7gkAEYrU3+Y+gQAAAAA6s2oDxDt379fkjRlypQKlwTAaLd//341NzdXuhgAAAAAMOKCcJQ/Ms9kMtq1a5cmTpyoIAgqXZwR0d3drSlTpmjnzp1qamqqdHGqHserNPV4vMIw1P79+9Xe3q5Uipa3AAAAAOrPqM8gSqVSOvrooytdjIpoamqqmxv44cDxKk29HS8yhwAAAADUMx6VAwAAAAAA1DkCRAAAAAAAAHWOANEolE6nde211yqdTle6KKMCx6s0HC8AAAAAqD+jvpNqAAAAAAAAHBwyiAAAAAAAAOocASIAAAAAAIA6R4AIAAAAAACgzhEgAgAAAAAAqHMEiAAAAAAAAOocAaIqt3z5cp188sk65JBDdNhhh3nn2bFjh8466yxNmDBBLS0tuvzyy9Xb25szz5NPPqm5c+eqsbFRRx11lK6//nrVywB2t956q6ZNm6bx48dr1qxZ+ulPf1rpIo24n/zkJzrrrLPU3t6uIAj03e9+N+f9MAzV2dmp9vZ2NTY26tRTT9XTTz+dM09PT4/+5m/+Ri0tLZowYYI++MEP6re//e0I7gUAAAAAoFwIEFW53t5enXfeefrEJz7hfb+/v18LFizQq6++qvXr1+vee+/VfffdpyuvvDKap7u7W6effrra29u1ceNGrVmzRqtWrdLq1atHajcq5tvf/rauuOIKXXPNNdq8ebPe/e536wMf+IB27NhR6aKNqFdffVVvf/vbdcstt3jfv+GGG7R69Wrdcsst2rhxo9ra2nT66adr//790TxXXHGF7r//ft17771av369XnnlFZ155pnq7+8fqd0AAAAAAJRJENZLGskod9ddd+mKK67Q//7v/+ZM/+EPf6gzzzxTO3fuVHt7uyTp3nvv1eLFi7Vnzx41NTXpK1/5ipYtW6bf/e53SqfTkqQvfvGLWrNmjX77298qCIKR3p0Rc9JJJ+kd73iHvvKVr0TTjj/+eJ1zzjlauXJlBUtWOUEQ6P7779c555wjKZs91N7eriuuuEKf+cxnJGWzhVpbW/WlL31JH//4x7Vv3z4deeSR+uY3v6kPf/jDkqRdu3ZpypQp+o//+A/Nnz+/UrsDAAAAABgGZBCNchs2bNDMmTOj4JAkzZ8/Xz09Pdq0aVM0z9y5c6PgkJln165deuGFF0a6yCOmt7dXmzZt0rx583Kmz5s3T4899liFSlV9tm/frq6urpzjlE6nNXfu3Og4bdq0SX19fTnztLe3a+bMmRxLAAAAAKgBBIhGua6uLrW2tuZMmzRpksaNG6eurq7YeczfZp5a9NJLL6m/v9+777W836UyxyLpOHV1dWncuHGaNGlS7DwAAAAAgNGLAFEFdHZ2KgiCxNcTTzxR9Pp8TcTCMMyZ7s5jWhbWcvMyw7fv9bDfpRrKceJYAgAAAEBtGFPpAtSjJUuW6Pzzz0+cZ+rUqUWtq62tTY8//njOtL1796qvry/KCGlra8vL8tizZ4+k/KyRWtLS0qKGhgbvvtfyfpeqra1NUjZLaPLkydF0+zi1tbWpt7dXe/fuzcki2rNnj04++eSRLTAAAAAAYNiRQVQBLS0testb3pL4Gj9+fFHrmjNnjp566int3r07mrZ27Vql02nNmjUrmucnP/mJent7c+Zpb28vOhA1Go0bN06zZs3SunXrcqavW7eOoIZl2rRpamtryzlOvb29evTRR6PjNGvWLI0dOzZnnt27d+upp57iWAIAAABADSCDqMrt2LFDL7/8snbs2KH+/n5t2bJFkvTmN79Zhx56qObNm6cZM2Zo0aJFuvHGG/Xyyy/rqquu0sUXX6ympiZJ0sKFC3Xddddp8eLFuvrqq/XrX/9aK1as0Oc///mabx60dOlSLVq0SLNnz9acOXN0xx13aMeOHbrkkksqXbQR9corr+j555+P/t6+fbu2bNmiww8/XMccc4yuuOIKrVixQscdd5yOO+44rVixQocccogWLlwoSWpubtZFF12kK6+8UkcccYQOP/xwXXXVVXrrW9+q97///ZXaLQAAAADAMGGY+yq3ePFi3X333XnTH3nkEZ166qmSskGkSy+9VA8//LAaGxu1cOFCrVq1KmfUsieffFKXXXaZfv7zn2vSpEm65JJL6iJAJEm33nqrbrjhBu3evVszZ87U3//93+s973lPpYs1on784x/rtNNOy5t+4YUX6q677lIYhrruuut0++23a+/evTrppJP0j//4j5o5c2Y07xtvvKFPfepTuueee/T666/rfe97n2699VZNmTJlJHcFAAAAAFAGBIgAAAAAAADqHH0QAQAAAAAA1DkCRAAAAAAAAHWOABEAAAAAAECdI0AEAAAAAABQ5wgQAQAAAAAA1DkCRAAAAAAAAHWOABEAAAAAAECdI0AEAAAAAABQ5wgQAQAAAAAA1DkCRAAAAAAAAHWOABEAAAAAAECd+/8BsGkYzQdQAaoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "area = grid._ds[\"rA\"].where(grid._ds[\"Depth\"] > 0.0)\n", + "\n", + "def column_tendency(varname):\n", + " \"\"\"Column-integrated heat tendency per unit area [W/m^2] at the first time.\n", + "\n", + " Robust to terms lacking a vertical (`k`) or `time` dimension (e.g. a static\n", + " bottom/geothermal flux).\n", + " \"\"\"\n", + " da = grid._ds[varname] / area\n", + " if \"k\" in da.dims:\n", + " da = da.sum(\"k\")\n", + " if \"time\" in da.dims:\n", + " da = da.isel(time=0)\n", + " return da.where(np.abs(da) > 0.0)\n", + "\n", + "terms = list(heat_rhs_terms.items())\n", + "ncol = 3\n", + "nrow = int(np.ceil(len(terms) / ncol))\n", + "vmax = 1000.0 # W/m^2\n", + "fig, axes = plt.subplots(nrow, ncol, figsize=(5 * ncol, 4 * nrow), squeeze=False)\n", + "for ax in axes.ravel():\n", + " ax.set_visible(False)\n", + "cb = None\n", + "for (name, varname), ax in zip(terms, axes.ravel()):\n", + " ax.set_visible(True)\n", + " cb = plot_interpolated_ecco(fig, ax, column_tendency(varname), vmin=-vmax, vmax=vmax)\n", + " ax.set_title(name, fontsize=9)\n", + "if cb is not None:\n", + " fig.colorbar(cb, ax=axes.ravel().tolist(), orientation=\"vertical\", label=\"W/m^2\", shrink=0.8)\n", + "fig.suptitle(\"ECCO heat budget RHS, decomposed (column tendency)\")" + ] + }, + { + "cell_type": "markdown", + "id": "36ffe8d1", + "metadata": {}, + "source": [ + "### Global-mean time series of each decomposed term\n", + "\n", + "Area-weighted global means summarize the relative magnitude of each contribution over the record." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4aa8b929", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-30T18:45:20.237459Z", + "iopub.status.busy": "2026-06-30T18:45:20.237371Z", + "iopub.status.idle": "2026-06-30T18:45:30.475768Z", + "shell.execute_reply": "2026-06-30T18:45:30.475498Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "for name, varname in heat_rhs_terms.items():\n", + " da = grid._ds[varname] / area\n", + " if \"k\" in da.dims:\n", + " da = da.sum(\"k\")\n", + " # area-weighted global mean over the horizontal (and tiles)\n", + " global_mean = ((da * area) / area.sum()).sum([\"tile\", \"i\", \"j\"])\n", + " if \"time\" not in global_mean.dims:\n", + " # static term (e.g. geothermal bottom flux): broadcast to the time axis\n", + " global_mean = global_mean.broadcast_like(grid._ds[\"time\"])\n", + " if not bool(np.isfinite(global_mean).any()):\n", + " continue # nothing finite to plot for this term\n", + " global_mean.plot(ax=ax, marker=\"o\", ms=3, label=name)\n", + "ax.set_ylabel(\"W/m^2\")\n", + "ax.set_title(\"Global-mean decomposed heat-budget terms\")\n", + "ax.legend(fontsize=8, ncol=2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "docs_env_xbudget", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/xbudget/__init__.py b/xbudget/__init__.py index 3fa8550..50aaad4 100644 --- a/xbudget/__init__.py +++ b/xbudget/__init__.py @@ -1,5 +1,6 @@ """ xbudget: xarray and xgcm-based functions for evaluating finite-volume budgets""" from .presets import * -from .llc90 import * from .collect import * +from .parse import parse_budgets, BudgetParseError +from .evaluate import evaluate_budgets from .version import __version__ diff --git a/xbudget/collect.py b/xbudget/collect.py index ba46ca1..0788dea 100644 --- a/xbudget/collect.py +++ b/xbudget/collect.py @@ -5,13 +5,57 @@ import numbers import xarray as xr import xgcm -from .llc90 import diff_2d_flux_llc90 import warnings +__all__ = [ + "aggregate", + "disaggregate", + "deep_search", + "collect_budgets", + "budget_fill_dict", + "get_vars", + "flatten", + "flatten_lol", + "lateral_divergence", +] + +def _warn_missing_variable(name): + """Warn that a requested variable is absent from the dataset and skipped.""" + warnings.warn( + f"Variable {name} is missing from the dataset `ds`, so it is being " + f"skipped. To suppress this warning, remove {name} from the " + f"`xbudget_dict`.", + UserWarning, + ) + +def lateral_divergence(grid, Fx, Fy): + """Horizontal flux divergence ``div(Fx, Fy)`` on cell centers, via xgcm. + + Uses ``grid.diff`` with a vector ``other_component`` so face-connected + topologies (e.g. the LLC tiles of ECCO) are stitched correctly. This + reproduces the previously hand-rolled LLC90 flux stitching exactly, for any + grid topology xgcm supports. + """ + if grid is None: + raise ValueError( + "Input `data` must be an `xgcm.Grid` instance when using " + "`lateral_divergence` operations." + ) + dFx = grid.diff({"X": Fx}, "X", other_component={"Y": Fy}) + dFy = grid.diff({"Y": Fy}, "Y", other_component={"X": Fx}) + return dFx + dFy + def aggregate(xbudget_dict, decompose=[]): """Aggregate xbudget dictionary into simpler root-level budgets. + .. note:: + This reads the ``var`` fields that the engine fills in, so it only + returns meaningful results after a legacy run, i.e. + ``collect_budgets(data, xbudget_dict, name_scheme="legacy")``. The + default ``name_scheme="v1"`` does not mutate the recipe; query its output + via the ``records``/``alias_map`` from ``evaluate_budgets`` instead. + Parameters ---------- xbudget_dict : dictionary in xbudget-compatible format @@ -141,15 +185,17 @@ def deep_search(b): -------- aggregate, _deep_search """ - return _deep_search(b, new_b={}, k_last=None) + return _deep_search(b, new_b=None, k_last=None) -def _deep_search(b, new_b={}, k_last=None): +def _deep_search(b, new_b=None, k_last=None): """Recursive function for searching for variables in xbudget dictionary. - + See also -------- aggregate, deep_search """ + if new_b is None: + new_b = {} if type(b) is str: new_b[k_last] = b elif type(b) is dict: @@ -159,39 +205,73 @@ def _deep_search(b, new_b={}, k_last=None): _deep_search(v, new_b=new_b, k_last=k) return new_b -def collect_budgets(ds, xbudget_dict, allow_rechunk = True): - """Fills xbudget dictionary with all tracer content tendencies +def collect_budgets(data, xbudget_dict, allow_rechunk=True, name_scheme="v1"): + """Materialize every budget term described by ``xbudget_dict`` into ``data``. + + The convention dict is parsed into a typed expression tree + (:mod:`xbudget.nodes`) and evaluated (:func:`xbudget.evaluate.evaluate_budgets`). + Unlike the historical engine, this does **not** mutate ``xbudget_dict``; it + only adds derived variables to the dataset. Parameters ---------- - ds : xr.Dataset containing budget diagnostics - xbudget_dict : dictionary in xbudget-compatible format - Example format: - >>> xbudget_dict = { - "heat": { - "rhs": { - "sum": { - "advection": { - "var":"advective_tendency" - }, - "var": "heat_rhs_sum" - }, - "var": "heat_rhs", - } - } - } + data : xgcm.Grid or xr.Dataset + Budget diagnostics to read from and write derived variables into, + modified in place. A grid is required if the convention uses + ``difference`` or ``lateral_divergence`` operations. + xbudget_dict : dict + A convention in xbudget format (e.g. from ``load_preset_budget``). allow_rechunk : bool (default: True) Whether to temporarily rechunk when taking differences along a dimension, e.g. to compute flux divergences on `center` from fluxes on `outer` or tendencies on `center` from snapshots on `outer`. + name_scheme : {"v1", "legacy"} (default: "v1") + ``"v1"`` (recommended) uses the typed engine: each derived variable is + named by its term path with operator infixes dropped (e.g. + ``heat_rhs_diffusion_lateral``) and the recipe dict is left untouched. + ``"legacy"`` reproduces the historical behavior exactly: the + operator-suffixed names (e.g. ``heat_rhs_sum_diffusion_sum_lateral_product``) + plus their plain "copy" aliases, **and it mutates ``xbudget_dict`` in + place** to fill in ``var`` fields (which the legacy ``get_vars`` / + ``aggregate`` query helpers rely on). + + Returns + ------- + data : xgcm.Grid or xr.Dataset + The same object passed in, for convenience. """ - for eq, v in xbudget_dict.items(): - for side in ["lhs", "rhs"]: - if side in v: - budget_fill_dict(ds, v[side], f"{eq}_{side}", allow_rechunk = allow_rechunk) + if name_scheme == "legacy": + # Faithful legacy behavior: reuse the reference engine, which emits the + # historical names and fills the recipe dict in place so that the + # dict-based query helpers (get_vars/aggregate) keep working. + for eq, sides in xbudget_dict.items(): + for side in ("lhs", "rhs"): + if side in sides: + budget_fill_dict( + data, sides[side], f"{eq}_{side}", allow_rechunk=allow_rechunk + ) + return data + + if name_scheme != "v1": + raise ValueError( + f"Unknown name_scheme {name_scheme!r}; expected 'v1' or 'legacy'." + ) + + from .parse import parse_budgets + from .evaluate import evaluate_budgets + + budgets = parse_budgets(xbudget_dict) + evaluate_budgets(data, budgets, allow_rechunk=allow_rechunk) + return data def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): - """Recursively fill xbudget dictionary + """Recursively fill xbudget dictionary (legacy engine). + + .. deprecated:: + The historical dict-walking engine, retained as the reference + implementation behind ``name_scheme="legacy"``. Prefer + :func:`collect_budgets` (typed engine); this mutates both ``data`` and + ``xbudget_dict`` in place. Parameters ---------- @@ -229,14 +309,14 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): if v_term_recursive is not None: op_list.append(v_term_recursive) elif v_term.get("var") is not None and v_term.get("var") not in ds: - warnings.warn(f"Variable {v_term.get('var')} is missing from the dataset `ds`, so it is being skipped. To suppress this warning, remove {v_term.get('var')} from the `xbudget_dict`.", UserWarning) + _warn_missing_variable(v_term.get("var")) elif isinstance(v_term, numbers.Number): op_list.append(v_term) elif isinstance(v_term, str): if v_term in ds: op_list.append(ds[v_term]) else: - warnings.warn(f"Variable {v_term} is missing from the dataset `ds`, so it is being skipped. To suppress this warning, remove {v_term} from the `xbudget_dict`.", UserWarning) + _warn_missing_variable(v_term) if k=="product": op_list.append(0.) @@ -275,7 +355,7 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): if k == "reciprocal": v_term = [v_term for k_term, v_term in v.items() if k_term != "var"][0] if v_term['var'] not in ds: - warnings.warn(f"Variable {v_term['var']} is missing from the dataset `ds`, so it is being skipped. To suppress this warning, remove {v_term['var']} from the `xbudget_dict`.") + _warn_missing_variable(v_term['var']) continue #A safe reciprocal that filters zeros out. @@ -297,26 +377,16 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): var_pref = var.copy() if k == "lateral_divergence": - if grid is None: - raise ValueError("Input `ds` must be `xgcm.Grid` instance if using `lateral_divergence` operations.") - - Fx = budget_fill_dict(data, v["Fx"], f"{namepath}_Fx") - Fy = budget_fill_dict(data, v["Fy"], f"{namepath}_Fy") + Fx = budget_fill_dict(data, v["Fx"], f"{namepath}_Fx", allow_rechunk=allow_rechunk) + Fy = budget_fill_dict(data, v["Fy"], f"{namepath}_Fy", allow_rechunk=allow_rechunk) if Fx is None or Fy is None: warnings.warn(f"Could not compute fluxes for {namepath}, skipping.") continue - if ("tile" in ds.coords) or ("face" in ds.coords): - div = diff_2d_flux_llc90(grid, Fx, Fy, allow_rechunk=allow_rechunk) - var = div["X"] + div["Y"] - elif not hasattr(grid, "_face_connections"): - raise NotImplementedError("`lateral_divergence` operator is not implemented for grids without face connections.") - else: - raise NotImplementedError("`lateral_divergence` operator is not implemented for your grid type.") - + var = lateral_divergence(grid, Fx, Fy) var_name = f"{namepath}_lateral_divergence" var = var.rename(var_name) - var.attrs["provenance"] = f"diff_2d_flux_llc90(Fx={Fx.name}, Fy={Fy.name})" + var.attrs["provenance"] = [Fx.name, Fy.name] ds[var_name] = var if v["var"] is None: v["var"] = var_name @@ -332,18 +402,24 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): var_pref = var.copy() if k == "difference": - if grid is not None: - staggered_axes = { - axn:c for axn,ax in grid.axes.items() - for pos,c in ax.coords.items() - if pos!="center" - } + if grid is None: + raise ValueError( + "Input `data` must be an `xgcm.Grid` instance when using " + "`difference` operations." + ) + staggered_axes = { + axn:c for axn,ax in grid.axes.items() + for pos,c in ax.coords.items() + if pos!="center" + } k_term, v_term = [(k_term, v_term) for k_term, v_term in v.items() if k_term != "var"][0] if isinstance(v_term, dict): source = budget_fill_dict(data, v_term, f"{namepath}_difference_{k_term}", allow_rechunk = allow_rechunk) + if source is None: + continue else: if v_term not in ds: - warnings.warn(f"Variable {v_term} is missing from the dataset `ds`, so it is being skipped. To suppress this warning, remove {v_term} from the `xbudget_dict`.") + _warn_missing_variable(v_term) continue source = ds[v_term] @@ -382,8 +458,6 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): ds[var_name] = var if var_pref is None: var_pref = var.copy() - else: - raise ValueError("Input `ds` must be `xgcm.Grid` instance if using `difference` operations.") @@ -392,6 +466,13 @@ def budget_fill_dict(data, xbudget_dict, namepath, allow_rechunk = True): def get_vars(xbudget_dict, terms): """Get xbudget sub-dictionaries for specified terms. + .. note:: + Reads the ``var`` fields filled in by a legacy run, i.e. + ``collect_budgets(data, xbudget_dict, name_scheme="legacy")``. For the + default ``name_scheme="v1"`` engine, query the ``records``/``alias_map`` + from :func:`xbudget.evaluate.evaluate_budgets` and the + ``provenance``/``xbudget_path`` variable attributes instead. + Parameters ---------- xbudget_dict : dictionary in xbudget-compatible format diff --git a/xbudget/conventions/ECCOV4r4_native.yaml b/xbudget/conventions/ECCOV4r4_native.yaml index 8375589..8eee70e 100755 --- a/xbudget/conventions/ECCOV4r4_native.yaml +++ b/xbudget/conventions/ECCOV4r4_native.yaml @@ -57,11 +57,13 @@ mass: # finite-volume mass budget in units of kg/s Fy: var: null product: {var: null, v_velocity: "VVELMASS", dxG: "dxG", dz: "drF"} - bolus_mass_flux_convergence: - var: null + bolus_mass_flux_convergence: # div(-Fx,-Fy) = -div(Fx,Fy) + var: null + product: + var: null sign: -1.0 density: 1029.0 - volume_flux_divergence: + volume_flux_divergence: var: null lateral_divergence: var: null diff --git a/xbudget/conventions/MOM6.yaml b/xbudget/conventions/MOM6.yaml index 1a5af2b..3bb8693 100644 --- a/xbudget/conventions/MOM6.yaml +++ b/xbudget/conventions/MOM6.yaml @@ -182,7 +182,11 @@ heat: # finite-volume heat budget in units of J/s nonadvective: var: null sum: - var: null # This sum is currently broken because the shortwave terms are 3D while the other terms are 2D! + # NOTE: this sum mixes 2D and 3D fields — the shortwave term + # (rsdoabsorb) is 3D while the other terms are 2D — so the summed + # result is only meaningful where they are reconciled (e.g. after + # vertically integrating the shortwave absorption). + var: null latent: var: null product: @@ -207,10 +211,9 @@ heat: # finite-volume heat budget in units of J/s var: null tracer_content_tendency_per_unit_area: "rsdoabsorb" area: "areacello" - # Not yet supported! - #var: "rsdoabsorb" - #finite_difference: - # Z: "rsdo" + # Alternative (not yet supported): derive the per-layer + # shortwave heating from the radiative flux `rsdo` via a vertical + # `difference` along the Z axis, instead of using `rsdoabsorb`. advective: var: null product: diff --git a/xbudget/evaluate.py b/xbudget/evaluate.py new file mode 100644 index 0000000..f2e9393 --- /dev/null +++ b/xbudget/evaluate.py @@ -0,0 +1,297 @@ +"""Evaluate a typed budget tree against a dataset/grid. + +The evaluator walks the :mod:`xbudget.nodes` tree and materializes one output +variable per *operation* (a ``sum``/``product``/``difference``), naming it by +its structured path with the operator infixes dropped (see ``_new_name``). This +collapses the legacy engine's duplicate "copy" variables while preserving the +numerical results. + +It is intentionally side-effecting in one place only: it writes the derived +variables into the dataset. It never mutates the recipe (the typed tree is +immutable). Alongside the new variables it records a legacy->new name map so +callers can offer backward-compatible names and a migration table. +""" +import warnings +from functools import reduce +from operator import mul + +import numpy as np +import xarray as xr +import xgcm + +from .nodes import ( + Constant, + Difference, + LateralDivergence, + Product, + Reciprocal, + Sum, + Term, + VarRef, +) +from .collect import _warn_missing_variable, lateral_divergence + + +def _new_name(path): + """Output variable name: the term path joined, without operator infixes.""" + return "_".join(path) + + +class _Evaluator: + def __init__(self, data, allow_rechunk=True): + if isinstance(data, xgcm.grid.Grid): + self.grid = data + self.ds = data._ds + else: + self.grid = None + self.ds = data + self.allow_rechunk = allow_rechunk + # legacy variable name -> new variable name (covers both the legacy + # "actual" operator-suffixed names and the plain "copy" names). + self.alias_map = {} + # new variable name -> {"path", "op", "legacy_actual", "legacy_copy"} + self.records = {} + + def run(self, budgets): + for budget in budgets.values(): + for side, term in budget.sides.items(): + self._eval_term(term, f"{budget.name}_{side}") + return self.alias_map, self.records + + # -- term --------------------------------------------------------------- + + def _eval_term(self, term, legacy_namepath): + """Evaluate a term; emit a variable per operation; return primary value. + + ``legacy_namepath`` is the variable name the previous engine would have + used for this term (operator infixes included via the parents), used to + build the backward-compatibility alias map. + """ + base = _new_name(term.path) + + primary = None + first_emitted = True + + # Leaf term: ``var`` references an existing diagnostic directly (e.g. + # ``{"var": "advective_tendency"}``). The legacy engine aliased it to the + # term's name; we do the same and treat it as the term's primary value. + if isinstance(term.explicit_var, str) and term.explicit_var in self.ds: + out = self.ds[term.explicit_var].rename(base).copy() + out.attrs["provenance"] = term.explicit_var + out.attrs["xbudget_path"] = list(term.path) + out.attrs["xbudget_op"] = "var" + self.ds[base] = out + self.alias_map[legacy_namepath] = base + self.records[base] = { + "path": list(term.path), + "op": "var", + "legacy_actual": legacy_namepath, + } + primary = out + first_emitted = False + + evaluated = [] # (op, value, provenance) for value-producing operations + for op in term.operations: + value, provenance = self._eval_op(op, term, legacy_namepath) + if value is not None: + evaluated.append((op, value, provenance)) + + # Choose which operation gets the bare path name (the term's primary + # value). The legacy engine reserved the plain namepath ("copy") for the + # first sum/product term, so prefer that; a lone difference takes the + # bare name (with no legacy copy). A leaf var, if present, already claimed + # it above (first_emitted is False), so no operation does. + primary_idx = None + if first_emitted: + for i, (op, _v, _p) in enumerate(evaluated): + if op.kind in ("sum", "product"): + primary_idx = i + break + if primary_idx is None and evaluated: + primary_idx = 0 + + for i, (op, value, provenance) in enumerate(evaluated): + is_primary = i == primary_idx + new_name = base if is_primary else f"{base}_{op.kind}" + legacy_actual = f"{legacy_namepath}_{op.kind}" + + out = value.rename(new_name) + out.attrs["provenance"] = provenance + out.attrs["xbudget_path"] = list(term.path) + out.attrs["xbudget_op"] = op.kind + self.ds[new_name] = out + + self.alias_map[legacy_actual] = new_name + self.records[new_name] = { + "path": list(term.path), + "op": op.kind, + "legacy_actual": legacy_actual, + } + if is_primary: + # The legacy engine also emitted a plain "copy" at the namepath + # for every operation except a lone difference. + if op.kind != "difference": + self.alias_map[legacy_namepath] = new_name + self.records[new_name]["legacy_copy"] = legacy_namepath + primary = out + + return primary + + # -- operations --------------------------------------------------------- + + def _eval_op(self, op, term, legacy_namepath): + if isinstance(op, (Sum, Product)): + return self._eval_nary(op, legacy_namepath) + if isinstance(op, Difference): + return self._eval_difference(op, legacy_namepath) + if isinstance(op, Reciprocal): + return self._eval_reciprocal(op) + if isinstance(op, LateralDivergence): + return self._eval_lateral_divergence(op, legacy_namepath) + raise TypeError(f"Unknown operation type {type(op).__name__}") + + def _eval_reciprocal(self, op): + ds = self.ds + if op.source not in ds: + _warn_missing_variable(op.source) + return None, None + var = 1.0 / xr.where(ds[op.source] == 0, np.inf, ds[op.source]) + return var, op.source + + def _eval_lateral_divergence(self, op, legacy_namepath): + fx = self._eval_term(op.fx, f"{legacy_namepath}_Fx") + fy = self._eval_term(op.fy, f"{legacy_namepath}_Fy") + if fx is None or fy is None: + warnings.warn( + f"Could not compute fluxes for {legacy_namepath}, skipping.", + UserWarning, + ) + return None, None + var = lateral_divergence(self.grid, fx, fy) + return var, [fx.name, fy.name] + + def _eval_nary(self, op, legacy_namepath): + ds = self.ds + op_list = [] + for name, operand in op.terms: + if isinstance(operand, Term): + child_legacy = f"{legacy_namepath}_{op.kind}_{name}" + child_value = self._eval_term(operand, child_legacy) + if child_value is not None: + op_list.append(child_value) + elif operand.explicit_var is not None and operand.explicit_var not in ds: + _warn_missing_variable(operand.explicit_var) + elif isinstance(operand, Constant): + op_list.append(operand.value) + elif isinstance(operand, VarRef): + if operand.name in ds: + op_list.append(ds[operand.name]) + else: + _warn_missing_variable(operand.name) + if op.kind == "product": + op_list.append(0.0) + + if len(op_list) == 0: + return None, None + var = sum(op_list) if op.kind == "sum" else reduce(mul, op_list, 1) + if not isinstance(var, xr.DataArray): + # Reduced to a pure scalar (e.g. all variable operands missing); + # the legacy engine emitted no variable in this case. + return None, None + provenance = [o.name if isinstance(o, xr.DataArray) else o for o in op_list] + return var, provenance + + def _eval_difference(self, op, legacy_namepath): + if self.grid is None: + raise ValueError( + "Input `data` must be an `xgcm.Grid` instance when using " + "`difference` operations." + ) + ds = self.ds + operand = op.operand + if isinstance(operand, VarRef): + if operand.name not in ds: + _warn_missing_variable(operand.name) + return None, None + source = ds[operand.name] + provenance = operand.name + else: # a computed sub-term, differenced after evaluation + source = self._eval_term( + operand, f"{legacy_namepath}_difference_{operand.name}" + ) + if source is None: + return None, None + provenance = source.name + + staggered_axes = { + axn: c + for axn, ax in self.grid.axes.items() + for pos, c in ax.coords.items() + if pos != "center" + } + candidate_axes = [ + axn for (axn, c) in staggered_axes.items() if c in source.dims + ] + if len(candidate_axes) != 1: + raise ValueError( + "Finite difference inconsistent with finite volume discretization." + ) + axis = candidate_axes[0] + + if self.allow_rechunk: + try: + original_chunks = dict(ds.chunksizes) + except Exception: + warnings.warn( + "Dataset chunks are inconsistent; using unify_chunks()", + UserWarning, + ) + original_chunks = dict(ds.unify_chunks().chunksizes) + + axis_dim = [ + d for d in source.dims if d in self.grid.axes[axis].coords.values() + ] + if len(axis_dim) != 1: + raise ValueError( + f"Expected to find one dimension for axis '{axis}' in " + f"'{provenance}', but found {len(axis_dim)}: {axis_dim}" + ) + axis_dim = axis_dim[0] + + temporary_chunks = { + axis_dim: -1, + **{d: "auto" for d in source.dims if d != axis_dim}, + } + var = self.grid.diff( + source.chunk(temporary_chunks).fillna(0.0), axis=axis + ) + var = var.chunk( + {d: original_chunks.get(d, var.chunksizes[d]) for d in var.dims} + ) + else: + var = self.grid.diff(source.fillna(0.0), axis) + + return var, provenance + + +def evaluate_budgets(data, budgets, allow_rechunk=True): + """Evaluate parsed budgets into ``data``; return ``(alias_map, records)``. + + Parameters + ---------- + data : xgcm.Grid or xr.Dataset + The dataset (or grid) to read diagnostics from and write derived + variables into. Modified in place. + budgets : dict of str -> Budget + Parsed budgets, from :func:`xbudget.parse.parse_budgets`. + allow_rechunk : bool, default True + Temporarily rechunk staggered variables for ``difference`` operations. + + Returns + ------- + alias_map : dict + Legacy variable name -> new variable name. + records : dict + New variable name -> metadata ({path, op, legacy_actual, legacy_copy}). + """ + return _Evaluator(data, allow_rechunk=allow_rechunk).run(budgets) diff --git a/xbudget/llc90/__init__.py b/xbudget/llc90/__init__.py deleted file mode 100644 index 59e5de5..0000000 --- a/xbudget/llc90/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .operations import * - diff --git a/xbudget/llc90/operations.py b/xbudget/llc90/operations.py deleted file mode 100644 index b1864b7..0000000 --- a/xbudget/llc90/operations.py +++ /dev/null @@ -1,162 +0,0 @@ -import warnings -import numpy as np -import xarray as xr - -def diff_2d_flux_llc90(grid, Fx, Fy, allow_rechunk=True): - """Computes 2D flux divergences on an LLC90 grid. - - Why this exists: - `xgcm.Grid.diff_2d_vector` (and related vector operators) rely on face-connection metadata. - Ideally, `xgcm.Grid.diff_2d_vector` could be used to calculate - divergences/convergences on LLC-type grids, but at the moment this is not available. - For now, we can use this function which is dask-native, and topology-correct for LLC90 grids. - - Args: - grid: xgcm.Grid instance. Used to infer axis coordinate names and access center - coordinates via `grid._ds`. - Fx: X-face flux `xarray.DataArray` (e.g., `UVELMASS * dyG * drF`). Must be staggered - on exactly one non-center X dimension (e.g., `i_g`) and include the LLC face - dimension inferred from `grid._face_connections`. - Fy: Y-face flux `xarray.DataArray` (e.g., `VVELMASS * dxG * drF`). Must be staggered - on exactly one non-center Y dimension (e.g., `j_g`) and include the LLC face - dimension inferred from `grid._face_connections`. - allow_rechunk: Whether to temporarily rechunk LLC90 horizontal dimensions before - taking stitched differences. - - Returns: - Dict with keys {"X","Y"}: - - out["X"] is the X-direction divergence contribution on C-points. - - out["Y"] is the Y-direction divergence contribution on C-points. - - Combine as: - div = out["X"] + out["Y"] - conv = -(out["X"] + out["Y"]) - - Raises: - ValueError: If the LLC face dimension cannot be inferred uniquely from - `grid._face_connections`, or if Fx/Fy staggering is ambiguous. - """ - keys = list(getattr(grid, "_face_connections", {}).keys()) - if len(keys) != 1: - raise ValueError("Could not infer a unique LLC face dimension from grid._face_connections.") - face_dim = keys[0] - - ds = grid._ds - - def _center_dim(axis): - return grid.axes[axis].coords["center"] - - def _staggered_dim(axis, da): - candidates = [c for pos, c in grid.axes[axis].coords.items() if pos != "center" and c in da.dims] - if len(candidates) != 1: - raise ValueError("Flux difference inconsistent with finite volume discretization.") - return candidates[0] - - Xc, Yc = _center_dim("X"), _center_dim("Y") - Xs = _staggered_dim("X", Fx) - Ys = _staggered_dim("Y", Fy) - - if allow_rechunk: - try: - original_chunks = dict(ds.chunksizes) - except Exception: - warnings.warn("Dataset chunks are inconsistent; using unify_chunks()", UserWarning) - original_chunks = dict(ds.unify_chunks().chunksizes) - Fx = Fx.chunk({d: -1 for d in [face_dim, Xc, Yc, Xs, Ys] if d in Fx.dims}) - Fy = Fy.chunk({d: -1 for d in [face_dim, Xc, Yc, Xs, Ys] if d in Fy.dims}) - - xs_new = int(Fx[Xs].isel({Xs: -1}).values) + 1 - ys_new = int(Fy[Ys].isel({Ys: -1}).values) + 1 - - faces = Fx[face_dim].values - - def x_neighbors(face): - """Returns the +X edge slice for Fx on `face`, stitched from the LLC90 neighbor.""" - f = int(face) - - if 0 <= f <= 2: - g = Fx.sel({face_dim: f + 3}).isel({Xs: 0}) - elif 3 <= f <= 5: - g = ( - Fy.sel({face_dim: 12 - f}) - .isel({Ys: 0, Xc: slice(None, None, -1)}) - .rename({Xc: Yc}) - .assign_coords({Yc: ds[Yc]}) - ) - elif f == 6: - g = Fx.sel({face_dim: 7}).isel({Xs: 0}) - elif 7 <= f <= 8: - g = Fx.sel({face_dim: f + 1}).isel({Xs: 0}) - elif 10 <= f <= 11: - g = Fx.sel({face_dim: f + 1}).isel({Xs: 0}) - else: - g = xr.full_like(Fx.sel({face_dim: f}).isel({Xs: 0}), np.nan) - - return g.expand_dims({face_dim: [f], Xs: [xs_new]}) - - def y_neighbors(face): - """Returns the +Y edge slice for Fy on `face`, stitched from the LLC90 neighbor.""" - f = int(face) - - if 0 <= f <= 1: - g = Fy.sel({face_dim: f + 1}).isel({Ys: 0}) - elif f == 2: - g = ( - Fx.sel({face_dim: 6}) - .isel({Xs: 0, Yc: slice(None, None, -1)}) - .rename({Yc: Xc}) - .assign_coords({Xc: ds[Xc]}) - ) - elif 3 <= f <= 5: - g = Fy.sel({face_dim: f + 1}).isel({Ys: 0}) - elif f == 6: - g = ( - Fx.sel({face_dim: 10}) - .isel({Xs: 0, Yc: slice(None, None, -1)}) - .rename({Yc: Xc}) - .assign_coords({Xc: ds[Xc]}) - ) - elif 7 <= f <= 9: - g = Fy.sel({face_dim: f + 3}).isel({Ys: 0}) - elif 10 <= f <= 12: - g = ( - Fx.sel({face_dim: 12 - f}) - .isel({Xs: 0, Yc: slice(None, None, -1)}) - .rename({Yc: Xc}) - .assign_coords({Xc: ds[Xc]}) - ) - else: - g = xr.full_like(Fy.sel({face_dim: f}).isel({Ys: 0}), np.nan) - - return g.expand_dims({face_dim: [f], Ys: [ys_new]}) - - gx = xr.concat( - [x_neighbors(f) for f in faces], - dim=face_dim, - coords="minimal", - compat="override", - join="override", - ) - gy = xr.concat( - [y_neighbors(f) for f in faces], - dim=face_dim, - coords="minimal", - compat="override", - join="override", - ) - - Fx_p = xr.concat([Fx, gx], dim=Xs, coords="minimal", compat="override", join="override") - Fy_p = xr.concat([Fy, gy], dim=Ys, coords="minimal", compat="override", join="override") - - if allow_rechunk: - Fx_p = Fx_p.chunk({d: -1 for d in [face_dim, Xc, Yc, Xs, Ys] if d in Fx_p.dims}) - Fy_p = Fy_p.chunk({d: -1 for d in [face_dim, Xc, Yc, Xs, Ys] if d in Fy_p.dims}) - - dFx = Fx_p.diff(Xs).rename({Xs: Xc}).assign_coords({Xc: ds[Xc]}) - dFy = Fy_p.diff(Ys).rename({Ys: Yc}).assign_coords({Yc: ds[Yc]}) - - if allow_rechunk: - dFx = dFx.chunk({d: original_chunks.get(d, dFx.chunksizes[d]) for d in dFx.dims}) - dFy = dFy.chunk({d: original_chunks.get(d, dFy.chunksizes[d]) for d in dFy.dims}) - - return {"X": dFx, "Y": dFy} diff --git a/xbudget/nodes.py b/xbudget/nodes.py new file mode 100644 index 0000000..894a19b --- /dev/null +++ b/xbudget/nodes.py @@ -0,0 +1,120 @@ +"""Typed expression tree for xbudget recipes. + +An xbudget convention (the nested ``xbudget_dict`` loaded from YAML) describes +how to build each budget term from raw model diagnostics. Historically that +recipe was walked directly as untyped nested dicts, with a node's meaning +inferred from which magic keys it happened to carry. These dataclasses give the +recipe an explicit, immutable shape so the parser, evaluator, and query helpers +can dispatch on node *type* instead of probing dict keys. + +The grammar (mirrors the YAML, see ``conventions/*.yaml``):: + + Budget := name, metadata, {side: Term} # side in {lhs, rhs} + Term := name, path, explicit_var?, [Operation] + Operation := Sum | Product | Difference + Sum/Product := [(operand_name, Operand)] + Difference := source variable name (differenced across a grid axis) + Operand := Constant | VarRef | Term + +A ``Term`` may carry more than one ``Operation`` (e.g. a bulk ``Product`` and an +equivalent finer ``Sum`` decomposition of the same quantity); each operation +yields its own output variable when evaluated. +""" +from dataclasses import dataclass + + +@dataclass(frozen=True) +class Constant: + """A scalar factor/addend in a sum or product (e.g. a density, a sign).""" + value: float + + +@dataclass(frozen=True) +class VarRef: + """A reference to a raw diagnostic variable expected in the dataset.""" + name: str + + +@dataclass(frozen=True) +class Sum: + """Add named operands together.""" + terms: tuple # tuple[(name: str, operand: Constant | VarRef | "Term")] + kind = "sum" + + +@dataclass(frozen=True) +class Product: + """Multiply named operands together.""" + terms: tuple # tuple[(name: str, operand: Constant | VarRef | "Term")] + kind = "product" + + +@dataclass(frozen=True) +class Difference: + """Finite-difference a staggered quantity across its grid axis. + + ``operand`` is either a :class:`VarRef` (a raw diagnostic) or a nested + :class:`Term` (a quantity computed first, then differenced) — both expose a + ``.name`` for legacy naming. + """ + operand: object + kind = "difference" + + +@dataclass(frozen=True) +class Reciprocal: + """Safe reciprocal (1/x with zeros mapped to infinity) of a variable.""" + source: str # name of the variable to invert + kind = "reciprocal" + + +@dataclass(frozen=True) +class LateralDivergence: + """Horizontal flux divergence ``div(Fx, Fy)`` of two flux sub-terms. + + Evaluated on cell centers with native xgcm so face-connected (e.g. LLC) + topologies are handled correctly. + """ + fx: object # Term producing the X-face flux + fy: object # Term producing the Y-face flux + kind = "lateral_divergence" + + +@dataclass(frozen=True) +class Term: + """A node in a budget tree: a named quantity defined by its operations. + + Attributes + ---------- + name : str + This term's key under its parent (the budget side name for a root). + path : tuple of str + Full path of term names from the budget root, e.g. + ``("heat", "rhs", "diffusion", "lateral")``. Used as the canonical + identity and to derive output variable names. + operations : tuple of Operation + One or more of Sum/Product/Difference. The first sum/product operation + provides the term's primary value. + explicit_var : str or None + A pre-named output variable, if the convention pinned one (rare). + """ + name: str + path: tuple + operations: tuple + explicit_var: object = None + + +@dataclass(frozen=True) +class Budget: + """A named budget (e.g. ``heat``) with lhs/rhs term trees and metadata.""" + name: str + metadata: dict + sides: dict # {"lhs": Term, "rhs": Term} (either may be absent) + + +# Operations that introduce a single source variable rather than named terms. +UNARY_OPS = {"difference": Difference, "reciprocal": Reciprocal} +NARY_OPS = {"sum": Sum, "product": Product} +# Operations with their own bespoke operand shape (handled specially in parse). +SPECIAL_OPS = {"lateral_divergence": LateralDivergence} +OPERATION_KEYS = set(UNARY_OPS) | set(NARY_OPS) | set(SPECIAL_OPS) diff --git a/xbudget/parse.py b/xbudget/parse.py new file mode 100644 index 0000000..f6ada5e --- /dev/null +++ b/xbudget/parse.py @@ -0,0 +1,232 @@ +"""Parse an ``xbudget_dict`` convention into the typed expression tree. + +This is the single place that knows the YAML/dict schema. It validates as it +builds, so malformed conventions raise a clear ``BudgetParseError`` naming the +offending path instead of surfacing as a deep ``KeyError``/``NameError`` during +evaluation. +""" +import numbers +import warnings + +from .nodes import ( + Budget, + Constant, + Difference, + LateralDivergence, + Reciprocal, + Term, + VarRef, + NARY_OPS, + SPECIAL_OPS, + OPERATION_KEYS, +) + +SIDES = ("lhs", "rhs") + + +class BudgetParseError(ValueError): + """Raised when an xbudget convention does not match the expected schema.""" + + +def _fmt(path): + return "/".join(str(p) for p in path) or "" + + +def parse_budgets(xbudget_dict): + """Parse a convention dict into ``{budget_name: Budget}``. + + Parameters + ---------- + xbudget_dict : dict + A convention in xbudget format (e.g. from ``load_preset_budget``). + + Returns + ------- + dict of str -> Budget + """ + if not isinstance(xbudget_dict, dict): + raise BudgetParseError( + f"Top-level xbudget convention must be a dict, got " + f"{type(xbudget_dict).__name__}." + ) + + budgets = {} + for name, body in xbudget_dict.items(): + if not isinstance(body, dict): + raise BudgetParseError( + f"Budget '{name}' must be a dict, got {type(body).__name__}." + ) + metadata = {k: v for k, v in body.items() if k not in SIDES} + sides = {} + for side in SIDES: + if body.get(side) is not None: + sides[side] = _parse_term(body[side], (name, side), side) + budgets[name] = Budget(name=name, metadata=metadata, sides=sides) + return budgets + + +def _parse_term(node, path, name): + """Parse a single term node (a quantity defined by its operations).""" + if not isinstance(node, dict): + raise BudgetParseError( + f"Term at {_fmt(path)} must be a dict, got {type(node).__name__}." + ) + + operations = [] + for key, value in node.items(): + if key == "var": + continue + if key in NARY_OPS: + operations.append(_parse_nary(key, value, path)) + elif key == "difference": + op = _parse_difference(value, path) + if op is not None: + operations.append(op) + elif key == "reciprocal": + op = _parse_reciprocal(value, path) + if op is not None: + operations.append(op) + elif key in SPECIAL_OPS: + operations.append(_parse_lateral_divergence(value, path)) + else: + # The legacy engine silently ignores keys that are neither `var` + # nor an operation (e.g. a `sign`/`density` scalar left directly on + # a term because its enclosing `product:` was omitted). Mirror that + # tolerance, but warn so the malformation is visible. + warnings.warn( + f"Ignoring unexpected key '{key}' on term at {_fmt(path)}; " + f"expected 'var' or one of {sorted(OPERATION_KEYS)}. This term " + f"may be missing an enclosing operation (e.g. 'product').", + UserWarning, + ) + + return Term( + name=name, + path=path, + operations=tuple(operations), + explicit_var=node.get("var"), + ) + + +def _parse_nary(kind, body, path): + """Parse a ``sum`` or ``product`` operation.""" + if not isinstance(body, dict): + raise BudgetParseError( + f"'{kind}' at {_fmt(path)} must be a dict, got " + f"{type(body).__name__}." + ) + terms = [] + for term_name, term_value in body.items(): + if term_name == "var": + continue + operand = _parse_operand(term_value, path + (term_name,), term_name) + if operand is not None: + terms.append((term_name, operand)) + return NARY_OPS[kind](terms=tuple(terms)) + + +def _parse_operand(value, path, name): + """Parse one operand of a sum/product: constant, var reference, or term.""" + if value is None: + # Tolerated: a placeholder operand with no content (legacy behavior + # silently skipped these). + return None + if isinstance(value, dict): + return _parse_term(value, path, name) + if isinstance(value, bool): + raise BudgetParseError( + f"Operand '{name}' at {_fmt(path)} is a bool; expected a number, " + f"variable name, or sub-term." + ) + if isinstance(value, numbers.Number): + return Constant(float(value)) + if isinstance(value, str): + return VarRef(value) + raise BudgetParseError( + f"Operand '{name}' at {_fmt(path)} has unsupported type " + f"{type(value).__name__}." + ) + + +def _single_operand(kind, body, path): + """Return the single non-``var`` (name, value) of a unary op body, or None. + + Warns and returns ``None`` for the malformed/placeholder cases the legacy + engine tolerates (zero or several operands). + """ + if not isinstance(body, dict): + raise BudgetParseError( + f"'{kind}' at {_fmt(path)} must be a dict, got " + f"{type(body).__name__}." + ) + operands = [(k, v) for k, v in body.items() if k != "var"] + if len(operands) != 1: + warnings.warn( + f"'{kind}' at {_fmt(path)} should reference exactly one operand, " + f"found {len(operands)}: {[k for k, _ in operands]}; skipping.", + UserWarning, + ) + return None + return operands[0] + + +def _parse_difference(body, path): + """Parse a ``difference`` operation. + + The operand is either a raw variable name (``VarRef``) or a nested term that + is computed first and then differenced (``Term``). Returns ``None`` for an + unavailable-diagnostic placeholder, matching the legacy engine. + """ + operand = _single_operand("difference", body, path) + if operand is None: + return None + name, value = operand + if isinstance(value, str): + return Difference(operand=VarRef(value)) + if isinstance(value, dict): + return Difference(operand=_parse_term(value, path + (name,), name)) + warnings.warn( + f"'difference' at {_fmt(path)} operand '{name}' is " + f"{type(value).__name__}, not a variable or sub-term; skipping.", + UserWarning, + ) + return None + + +def _parse_reciprocal(body, path): + """Parse a ``reciprocal`` operation (a single source variable name). + + The operand is a variable name, either bare or wrapped as ``{var: name}``. + Returns ``None`` for an unavailable-diagnostic placeholder. + """ + operand = _single_operand("reciprocal", body, path) + if operand is None: + return None + _, value = operand + source = value.get("var") if isinstance(value, dict) else value + if not isinstance(source, str): + warnings.warn( + f"'reciprocal' at {_fmt(path)} does not reference a variable name " + f"(got {type(source).__name__}); skipping.", + UserWarning, + ) + return None + return Reciprocal(source=source) + + +def _parse_lateral_divergence(body, path): + """Parse a ``lateral_divergence`` operation (an Fx/Fy flux pair).""" + if not isinstance(body, dict): + raise BudgetParseError( + f"'lateral_divergence' at {_fmt(path)} must be a dict, got " + f"{type(body).__name__}." + ) + missing = [c for c in ("Fx", "Fy") if c not in body] + if missing: + raise BudgetParseError( + f"'lateral_divergence' at {_fmt(path)} requires 'Fx' and 'Fy' " + f"flux sub-terms; missing {missing}." + ) + fx = _parse_term(body["Fx"], path + ("Fx",), "Fx") + fy = _parse_term(body["Fy"], path + ("Fy",), "Fy") + return LateralDivergence(fx=fx, fy=fy) diff --git a/xbudget/presets.py b/xbudget/presets.py index e462744..5745a14 100644 --- a/xbudget/presets.py +++ b/xbudget/presets.py @@ -10,7 +10,9 @@ def load_preset_budget(model="MOM6"): Parameters ---------- model : str (default "MOM6") - Currently supported models: ["MOM6"] + Name of any convention shipped in ``xbudget/conventions/`` (without the + ``.yaml`` suffix). Currently: "MOM6", "MOM6_3Donly", "MOM6_drift", + "MOM6_surface". Please open an Issue if you would like to contribute an xbudget yaml file for a new model–see /conventions/ for examples. diff --git a/xbudget/tests/characterization_MOM6.json b/xbudget/tests/characterization_MOM6.json new file mode 100644 index 0000000..2c77bfc --- /dev/null +++ b/xbudget/tests/characterization_MOM6.json @@ -0,0 +1,1231 @@ +{ + "heat_lhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 3940351370639.1494, + "nanmin": -5551136678721.273, + "nansum": 465392557504166.7, + "provenance": [ + "heat_lhs_Eulerian_tendency", + "heat_lhs_advection", + "heat_lhs_surface_ocean_flux_advective_negative_lhs" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_lhs_Eulerian_tendency": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 31760549339386.81, + "nanmin": -50587387594801.766, + "nansum": 359498039810372.4, + "provenance": [ + "opottemptend", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_lhs_advection": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 50947166350802.836, + "nanmin": -31753242879300.414, + "nansum": -40008497.625, + "provenance": [ + "heat_lhs_advection_lateral", + "heat_lhs_advection_interfacial" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_lhs_advection_interfacial": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 52011903632147.234, + "nanmin": -66339650467105.27, + "nansum": -7964552.625, + "provenance": [ + -1.0, + "Th_tendency_vert_remap", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_lhs_advection_lateral": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 69858875966090.484, + "nanmin": -53668947014140.43, + "nansum": -32043947.75, + "provenance": [ + -1.0, + "T_advection_xy", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_lhs_surface_ocean_flux_advective_negative_lhs": { + "dims": [ + "time", + "yh", + "xh", + "z_l" + ], + "nanmax": 204413737780.63818, + "nanmin": -17530828054821.393, + "nansum": 105894557702285.67, + "provenance": [ + -1.0, + 3992.0, + "tos", + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 180, + 240, + 35 + ] + }, + "heat_rhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 3940351305575.682, + "nanmin": -5551136489805.616, + "nansum": 465392547223857.06, + "provenance": [ + "heat_rhs_diffusion", + "heat_rhs_surface_exchange_flux", + "heat_rhs_surface_ocean_flux_advective_negative_rhs", + "heat_rhs_bottom_flux", + "heat_rhs_frazil_ice" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_bottom_flux": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 15602808942.544117, + "nanmin": 0.0, + "nansum": 34197020834727.336, + "provenance": [ + "internal_heat_heat_tendency", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_diffusion": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 4403310884265.735, + "nanmin": -5668737491808.836, + "nansum": -513722.65625, + "provenance": [ + "heat_rhs_diffusion_lateral", + "heat_rhs_diffusion_interfacial" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_diffusion_interfacial": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 4403310884265.735, + "nanmin": -5668737491808.836, + "nansum": -513722.65625, + "provenance": [ + "opottempdiff", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_diffusion_lateral": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": 0.0, + "nansum": 0.0, + "provenance": [ + "opottemppmdiff", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_frazil_ice": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 333573077881.8586, + "nanmin": -86785150.2558585, + "nansum": 10533909859144.72, + "provenance": [ + "frazil_heat_tendency", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 17392565831274.252, + "nanmin": -5720652791938.084, + "nansum": 314767059341419.3, + "provenance": [ + "boundary_forcing_heat_tendency", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_advective": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 17638101725505.902, + "nanmin": -203329990587.71277, + "nansum": -91207548946119.94, + "provenance": [ + "heat_content_surfwater", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_nonadvective": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2595512189140.2495, + "nanmin": -5648622249701.43, + "nansum": 405960520308607.25, + "provenance": [ + "heat_rhs_surface_exchange_flux_nonadvective_latent", + "heat_rhs_surface_exchange_flux_nonadvective_sensible", + "heat_rhs_surface_exchange_flux_nonadvective_longwave", + "heat_rhs_surface_exchange_flux_nonadvective_shortwave" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_nonadvective_latent": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": -5751041213211.73, + "nansum": -3.707192070055726e+16, + "provenance": [ + "hflso", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_nonadvective_longwave": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": -2250414053810.4854, + "nansum": -1.922110158863712e+16, + "provenance": [ + "rlntds", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_nonadvective_sensible": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 261182636956.48416, + "nanmin": -1626395528795.3396, + "nansum": -5742803130717152.0, + "provenance": [ + "hfsso", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_nonadvective_shortwave": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 6012543456110.167, + "nanmin": 0.0, + "nansum": 6.244178594022014e+16, + "provenance": [ + "rsdoabsorb", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_exchange_flux_sum": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 17380103825523.656, + "nanmin": -5720032356896.66, + "nansum": 314752971362487.25, + "provenance": [ + "heat_rhs_surface_exchange_flux_nonadvective", + "heat_rhs_surface_exchange_flux_advective" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "heat_rhs_surface_ocean_flux_advective_negative_rhs": { + "dims": [ + "time", + "yh", + "xh", + "z_l" + ], + "nanmax": 204413737780.63818, + "nanmin": -17530828054821.393, + "nansum": 105894557702285.67, + "provenance": [ + -1.0, + 3992.0, + "tos", + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 180, + 240, + 35 + ] + }, + "mass_lhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 772357898.5436696, + "nanmin": -1098185583.5343657, + "nansum": 115673902.00515747, + "provenance": [ + "mass_lhs_Eulerian_tendency" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_lhs_Eulerian_tendency": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 772357898.5436696, + "nanmin": -1098185583.5343657, + "nansum": 115673902.00515747, + "provenance": [ + "dhdt", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 772357889.8314499, + "nanmin": -1098185581.6161919, + "nansum": 115674835.3581543, + "provenance": [ + "mass_rhs_advection", + "mass_rhs_surface_exchange_flux" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 772357889.8314499, + "nanmin": -1098185581.6161919, + "nansum": 867.4076232910156, + "provenance": [ + "mass_rhs_advection_lateral", + "mass_rhs_advection_interfacial" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_interfacial": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2671057340.27241, + "nanmin": -2427147368.4921412, + "nansum": 517.6741333007812, + "provenance": [ + "vert_remap_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2440148050.6813173, + "nanmin": -2497054017.584284, + "nansum": 349.73358154296875, + "provenance": [ + "dynamics_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral_meridional_convergence": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 8579974954.958902, + "nanmin": -9557597306.465754, + "nansum": 1.9669532775878906e-05, + "provenance": [ + "mass_rhs_advection_lateral_meridional_convergence_meridional_divergence", + -1.0 + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral_meridional_convergence_meridional_divergence": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 9557597306.465754, + "nanmin": -8579974954.958902, + "nansum": -1.9669532775878906e-05, + "provenance": "vmo", + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral_sum": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2912457444.776712, + "nanmin": -4003050052.4816775, + "nansum": -2.1696090698242188e-05, + "provenance": [ + "mass_rhs_advection_lateral_zonal_convergence", + "mass_rhs_advection_lateral_meridional_convergence" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral_zonal_convergence": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 9710258626.887672, + "nanmin": -8493629541.5945215, + "nansum": -2.5358131097164005e-05, + "provenance": [ + "mass_rhs_advection_lateral_zonal_convergence_zonal_divergence", + -1.0 + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_advection_lateral_zonal_convergence_zonal_divergence": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 8493629541.5945215, + "nanmin": -9710258626.887672, + "nansum": 2.5358131097164005e-05, + "provenance": "umo", + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 150994667.24675918, + "nanmin": -1904967.9231000121, + "nansum": 115673967.95055571, + "provenance": [ + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_evaporation": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": -2300416.4874340678, + "nansum": -14730094071.40564, + "provenance": [ + "evs", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_icebergs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 1083971.7984599557, + "nanmin": -1.9552115609538865e-17, + "nansum": 83931421.94583575, + "provenance": [ + "ficeberg", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_rain_and_ice": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 6086412.035137083, + "nanmin": 0.0, + "nansum": 12440605354.218473, + "provenance": [ + "prlq", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_rivers": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 150788357.63074237, + "nanmin": 0.0, + "nansum": 1348385571.4572797, + "provenance": [ + "friver", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_sea_ice_melt": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 769519.4319497072, + "nanmin": -1316129.1160761716, + "nansum": 318197709.37157536, + "provenance": [ + "fsitherm", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_snow": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 218942.7784607154, + "nanmin": 0.0, + "nansum": 654647984.1850371, + "provenance": [ + "prsn", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_sum": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 150994723.95384806, + "nanmin": -1904967.918458563, + "nansum": 115673969.77256012, + "provenance": [ + "mass_rhs_surface_exchange_flux_rain_and_ice", + "mass_rhs_surface_exchange_flux_snow", + "mass_rhs_surface_exchange_flux_evaporation", + "mass_rhs_surface_exchange_flux_rivers", + "mass_rhs_surface_exchange_flux_icebergs", + "mass_rhs_surface_exchange_flux_sea_ice_melt", + "mass_rhs_surface_exchange_flux_virtual_precip_restoring" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "mass_rhs_surface_exchange_flux_virtual_precip_restoring": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": 0.0, + "nansum": 0.0, + "provenance": [ + "vprec", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2884969.3389652804, + "nanmin": -2557682.911046171, + "nansum": 22015698.012058213, + "provenance": [ + "salt_lhs_Eulerian_tendency", + "salt_lhs_advection", + "salt_lhs_surface_ocean_flux_advective_negative_lhs" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs_Eulerian_tendency": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 26922679.91256405, + "nanmin": -38341991.951405145, + "nansum": 155930.49178028107, + "provenance": [ + "osalttend", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs_advection": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 38340568.789027676, + "nanmin": -26925361.134083405, + "nansum": -5.824695110321045, + "provenance": [ + "salt_lhs_advection_lateral", + "salt_lhs_advection_interfacial" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs_advection_interfacial": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 84183420.2203544, + "nanmin": -91964669.39212582, + "nansum": 1.1313326358795166, + "provenance": [ + -1.0, + "Sh_tendency_vert_remap", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs_advection_lateral": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 86609080.98676263, + "nanmin": -84634259.08775437, + "nansum": -6.956027030944824, + "provenance": [ + -1.0, + "S_advection_xy", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_lhs_surface_ocean_flux_advective_negative_lhs": { + "dims": [ + "time", + "yh", + "xh", + "z_l" + ], + "nanmax": 66860.41314122651, + "nanmin": -1196339.2712781483, + "nansum": 21859773.34497478, + "provenance": [ + -1.0, + 0.001, + "sos", + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 180, + 240, + 35 + ] + }, + "salt_rhs": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2884965.8031573864, + "nanmin": -2557682.9323331164, + "nansum": 22012949.476222686, + "provenance": [ + "salt_rhs_diffusion", + "salt_rhs_surface_exchange_flux", + "salt_rhs_surface_ocean_flux_advective_negative_rhs" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_diffusion": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2884752.5718469503, + "nanmin": -2557647.378450736, + "nansum": 0.013583011459559202, + "provenance": [ + "salt_rhs_diffusion_lateral", + "salt_rhs_diffusion_interfacial" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_diffusion_interfacial": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2884752.5718469503, + "nanmin": -2557647.378450736, + "nansum": 0.013583011459559202, + "provenance": [ + "osaltdiff", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_diffusion_lateral": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": 0.0, + "nansum": 0.0, + "provenance": [ + "osaltpmdiff", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_exchange_flux": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2276.0619504758206, + "nanmin": -4416.354356011937, + "nansum": 153176.1176649518, + "provenance": [ + "boundary_forcing_salt_tendency", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_exchange_flux_advective": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 0.0, + "nanmin": -0.0, + "nansum": 0.0, + "provenance": [ + 0.001, + 0.0, + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_exchange_flux_nonadvective": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2276.061950475834, + "nanmin": -4416.354356011937, + "nansum": 153176.1176644049, + "provenance": [ + "salt_rhs_surface_exchange_flux_nonadvective_basal" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_exchange_flux_nonadvective_basal": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2276.061950475834, + "nanmin": -4416.354356011937, + "nansum": 153176.1176644049, + "provenance": [ + "sfdsi", + "areacello" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_exchange_flux_sum": { + "dims": [ + "time", + "z_l", + "yh", + "xh" + ], + "nanmax": 2276.061950475834, + "nanmin": -4416.354356011937, + "nansum": 153176.1176644049, + "provenance": [ + "salt_rhs_surface_exchange_flux_nonadvective", + "salt_rhs_surface_exchange_flux_advective" + ], + "shape": [ + 1, + 35, + 180, + 240 + ] + }, + "salt_rhs_surface_ocean_flux_advective_negative_rhs": { + "dims": [ + "time", + "yh", + "xh", + "z_l" + ], + "nanmax": 66860.41314122651, + "nanmin": -1196339.2712781483, + "nansum": 21859773.34497478, + "provenance": [ + -1.0, + 0.001, + "sos", + "boundary_forcing_h_tendency", + 1035.0, + "areacello" + ], + "shape": [ + 1, + 180, + 240, + 35 + ] + } +} \ No newline at end of file diff --git a/xbudget/tests/test_characterization.py b/xbudget/tests/test_characterization.py new file mode 100644 index 0000000..0a88a52 --- /dev/null +++ b/xbudget/tests/test_characterization.py @@ -0,0 +1,154 @@ +"""End-to-end characterization ("golden") test for the MOM6 preset. + +Pins the exact set of variables that ``collect_budgets`` materializes from the +example MOM6 grid, together with each variable's shape, provenance, and a +numerical fingerprint. This guards the absolute output of the (typed) engine; +``test_evaluate_equivalence`` separately ties it to the legacy engine. + +Originally introduced as the Phase 0 safety net for the internals refactor; the +reference now reflects the typed engine's simplified variable names. + +The example dataset (~600 MB) is downloaded on demand from Zenodo and is not +tracked in git, so this test is skipped when the file is absent (e.g. in CI that +does not fetch it). The small reference fingerprint lives next to this file in +``characterization_MOM6.json`` and *is* tracked. + +To regenerate the reference after an intended change:: + + XBUDGET_REGEN_CHARN=1 python -m pytest \ + xbudget/tests/test_characterization.py -s +""" +import os +import json +import warnings + +import numpy as np +import xarray as xr +import xgcm +import pytest + +import xbudget + +DATA_PATH = os.path.normpath( + os.path.join( + os.path.dirname(__file__), + "..", + "..", + "data", + "MOM6_global_example_diagnostics_zlevels_v0_0_6.nc", + ) +) +REFERENCE_PATH = os.path.join( + os.path.dirname(__file__), "characterization_MOM6.json" +) + +# Tolerance for the numerical fingerprints. The recipe is deterministic, so the +# only expected drift is last-bit floating point from library version changes. +RTOL = 1e-9 + + +def _build_example_grid(): + """Reconstruct the example xgcm.Grid from the local data file. + + Mirrors ``examples/load_example_model_grid.py`` but reads the already + downloaded file directly (the example loader uses a relative ``../data`` + path that only resolves from the examples directory). + """ + ds = xr.open_dataset(DATA_PATH).fillna(0.0) + if "z_l" not in ds.dims: + ds = ds.expand_dims(["z_l"]).assign_coords( + { + "z_l": xr.DataArray([3000], dims=("z_l",)), + "z_i": xr.DataArray([0, 6000], dims=("z_i",)), + } + ) + # Chunk so the difference/rechunking code path is exercised, matching the + # example loader. + ds = ds.chunk({"xh": 100, "yh": 100, "xq": 100, "yq": 100, "time": 1}) + coords = { + "X": {"center": "xh", "outer": "xq"}, + "Y": {"center": "yh", "outer": "yq"}, + } + return xgcm.Grid( + ds, + coords=coords, + metrics={("X", "Y"): "areacello"}, + boundary={"X": "periodic", "Y": "extend"}, + autoparse_metadata=False, + ) + + +def _normalize_provenance(prov): + """Make provenance JSON-comparable (numpy arrays/scalars -> lists/floats).""" + if isinstance(prov, np.ndarray): + prov = prov.tolist() + if isinstance(prov, (list, tuple)): + return [_normalize_provenance(p) for p in prov] + if isinstance(prov, np.generic): + return prov.item() + return prov + + +def _fingerprint(ds, created): + """Build a small, comparable fingerprint for each created variable.""" + fp = {} + for name in created: + da = ds[name] + values = np.asarray(da.values, dtype="float64") + fp[name] = { + "dims": list(da.dims), + "shape": list(da.shape), + "nansum": float(np.nansum(values)), + "nanmin": float(np.nanmin(values)) if values.size else 0.0, + "nanmax": float(np.nanmax(values)) if values.size else 0.0, + "provenance": _normalize_provenance(da.attrs.get("provenance")), + } + return fp + + +def _collect_example_budgets(): + """Run the MOM6 preset over the example grid; return (ds, created_names).""" + grid = _build_example_grid() + ds = grid._ds + before = set(ds.data_vars) + budget = xbudget.load_preset_budget("MOM6") + with warnings.catch_warnings(): + # Missing-diagnostic warnings are expected for the example subset. + warnings.simplefilter("ignore") + xbudget.collect_budgets(grid, budget) + created = sorted(set(ds.data_vars) - before) + return ds, created + + +@pytest.mark.skipif( + not os.path.exists(DATA_PATH), + reason="example MOM6 dataset not present (download from Zenodo to run)", +) +def test_mom6_characterization_matches_reference(): + ds, created = _collect_example_budgets() + fingerprint = _fingerprint(ds, created) + + if os.environ.get("XBUDGET_REGEN_CHARN"): + with open(REFERENCE_PATH, "w") as f: + json.dump(fingerprint, f, indent=2, sort_keys=True) + pytest.skip(f"regenerated reference at {REFERENCE_PATH}") + + with open(REFERENCE_PATH) as f: + reference = json.load(f) + + missing = set(reference) - set(fingerprint) + extra = set(fingerprint) - set(reference) + assert not missing, f"variables no longer produced: {sorted(missing)}" + assert not extra, f"unexpected new variables: {sorted(extra)}" + + for name, ref in reference.items(): + got = fingerprint[name] + assert got["dims"] == ref["dims"], f"{name}: dims changed" + assert got["shape"] == ref["shape"], f"{name}: shape changed" + assert got["provenance"] == ref["provenance"], ( + f"{name}: provenance changed" + ) + for stat in ("nansum", "nanmin", "nanmax"): + assert np.isclose(got[stat], ref[stat], rtol=RTOL, atol=0.0), ( + f"{name}: {stat} changed {ref[stat]} -> {got[stat]}" + ) diff --git a/xbudget/tests/test_evaluate_equivalence.py b/xbudget/tests/test_evaluate_equivalence.py new file mode 100644 index 0000000..5b6752d --- /dev/null +++ b/xbudget/tests/test_evaluate_equivalence.py @@ -0,0 +1,276 @@ +"""Prove the typed evaluator is numerically equivalent to the legacy engine. + +The new engine (parse -> evaluate) emits one variable per operation with the +simplified path-based names, collapsing the legacy engine's duplicate "copy" +variables. These tests run both engines on the same data and assert that every +new variable matches its legacy counterpart (mapped via the alias map) to +floating-point tolerance. + +Two fixtures are used: +- a tiny synthetic grid that always runs (covers sum/product/difference, + multi-operation terms, and missing-variable handling); +- the full example MOM6 grid, skipped when the (~600 MB) file is absent. +""" +import copy +import os +import warnings + +import numpy as np +import xarray as xr +import xgcm +import pytest + +import xbudget +from xbudget.parse import parse_budgets +from xbudget.evaluate import evaluate_budgets + +OPS = {"sum", "product", "difference", "reciprocal", "lateral_divergence"} +RTOL = 1e-9 + + +def _data(name): + return os.path.normpath( + os.path.join(os.path.dirname(__file__), "..", "..", "data", name) + ) + + +DATA_PATH = _data("MOM6_global_example_diagnostics_zlevels_v0_0_6.nc") +ECCO_DATA_PATH = _data("ECCO_budget_terms.nc") + + +def _run_legacy(build_grid, preset): + """Drive the legacy dict-walking engine (budget_fill_dict) directly. + + ``collect_budgets`` now uses the typed engine, so the equivalence oracle + must call the legacy ``budget_fill_dict`` itself (the same loop the old + ``collect_budgets`` performed). + """ + grid = build_grid() + ds = grid._ds + before = set(ds.data_vars) + preset = copy.deepcopy(preset) # legacy engine mutates the dict + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + for eq, sides in preset.items(): + for side in ("lhs", "rhs"): + if side in sides: + xbudget.budget_fill_dict(grid, sides[side], f"{eq}_{side}") + return ds, set(ds.data_vars) - before + + +def _run_new(build_grid, preset): + grid = build_grid() + ds = grid._ds + before = set(ds.data_vars) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + alias_map, records = evaluate_budgets(grid, parse_budgets(preset)) + return ds, set(ds.data_vars) - before, alias_map, records + + +def _assert_equivalent(build_grid, preset): + legacy_ds, legacy_new = _run_legacy(build_grid, preset) + new_ds, new_new, alias_map, records = _run_new(build_grid, preset) + + # Every legacy variable (copies + operator-suffixed actuals) is reachable + # from the alias map. + unmapped = legacy_new - set(alias_map) + assert not unmapped, f"legacy names with no new equivalent: {sorted(unmapped)}" + + # Every new variable matches its legacy counterpart numerically. + assert set(records), "new engine produced no variables" + for new_name, rec in records.items(): + legacy_actual = rec["legacy_actual"] + assert legacy_actual in legacy_ds, ( + f"{new_name}: legacy actual {legacy_actual} missing" + ) + a = np.asarray(new_ds[new_name].values, dtype="float64") + b = np.asarray(legacy_ds[legacy_actual].values, dtype="float64") + assert a.shape == b.shape, f"{new_name}: shape {a.shape} != {b.shape}" + assert np.allclose( + np.nan_to_num(a), np.nan_to_num(b), rtol=RTOL, atol=0.0 + ), f"{new_name}: values differ from legacy {legacy_actual}" + + # The new engine emits exactly one variable per legacy "producer": each + # operator-suffixed actual, plus each leaf var (a bare legacy name with no + # operator-suffixed sibling). The redundant legacy "copies" are dropped. + legacy_actuals = {v for v in legacy_new if v.rsplit("_", 1)[-1] in OPS} + bare_legacy = legacy_new - legacy_actuals + legacy_leaves = { + v for v in bare_legacy if not any(f"{v}_{op}" in legacy_new for op in OPS) + } + legacy_producers = legacy_actuals | legacy_leaves + record_targets = {rec["legacy_actual"] for rec in records.values()} + assert record_targets == legacy_producers, ( + f"new->legacy targets {sorted(record_targets)} != " + f"legacy producers {sorted(legacy_producers)}" + ) + # No two new variables collide on a name or a legacy target (injective). + assert len(record_targets) == len(records) + return records, alias_map + + +def _build_synthetic_grid(): + """A small chunked grid exercising sum, product, and difference.""" + rng = np.random.RandomState(0) + ds = xr.Dataset( + { + "flux": xr.DataArray(rng.rand(5, 3), dims=("x_g", "y_c")), + "diag_a": xr.DataArray(rng.rand(4, 3), dims=("x_c", "y_c")), + "diag_b": xr.DataArray(rng.rand(4, 3), dims=("x_c", "y_c")), + "area": xr.DataArray(rng.rand(4, 3) + 1.0, dims=("x_c", "y_c")), + }, + coords={ + "x_g": np.arange(5), + "x_c": np.arange(4) + 0.5, + "y_c": np.arange(3), + }, + ).chunk({"x_c": 2, "x_g": 2, "y_c": 3}) + return xgcm.Grid( + ds, + coords={"X": {"center": "x_c", "left": "x_g"}}, + periodic=False, + autoparse_metadata=False, + ) + + +SYNTHETIC_PRESET = { + "tracer": { + "rhs": { + "var": None, + "sum": { + "var": None, + "diffusion": { + "var": None, + "product": {"var": None, "sign": -1.0, "d": "diag_a", "area": "area"}, + }, + # multi-operation term: a bulk product AND a finer sum + "boundary": { + "var": None, + "product": {"var": None, "d": "diag_b", "area": "area"}, + "sum": { + "var": None, + "convergence": { + "var": None, + "difference": {"var": None, "transport": "flux"}, + }, + }, + }, + # leaf term: var references an existing diagnostic directly + "direct": {"var": "diag_a"}, + # references a diagnostic absent from the dataset + "missing": {"var": None, "product": {"var": None, "d": "not_present"}}, + }, + } + } +} + + +def test_equivalent_on_synthetic_grid(): + records, alias_map = _assert_equivalent(_build_synthetic_grid, SYNTHETIC_PRESET) + # The simplified names drop operator infixes and the redundant copies. + assert "tracer_rhs" in records + assert "tracer_rhs_diffusion" in records + assert "tracer_rhs_boundary" in records # primary (product) + assert "tracer_rhs_boundary_sum" in records # second decomposition + assert "tracer_rhs_boundary_convergence" in records # difference leaf + # leaf term: var references an existing diagnostic directly + assert "tracer_rhs_direct" in records + assert records["tracer_rhs_direct"]["op"] == "var" + + +def _build_mom6_grid(): + ds = xr.open_dataset(DATA_PATH).fillna(0.0) + if "z_l" not in ds.dims: + ds = ds.expand_dims(["z_l"]).assign_coords( + { + "z_l": xr.DataArray([3000], dims=("z_l",)), + "z_i": xr.DataArray([0, 6000], dims=("z_i",)), + } + ) + ds = ds.chunk({"xh": 100, "yh": 100, "xq": 100, "yq": 100, "time": 1}) + return xgcm.Grid( + ds, + coords={"X": {"center": "xh", "outer": "xq"}, "Y": {"center": "yh", "outer": "yq"}}, + metrics={("X", "Y"): "areacello"}, + boundary={"X": "periodic", "Y": "extend"}, + autoparse_metadata=False, + ) + + +@pytest.mark.skipif( + not os.path.exists(DATA_PATH), + reason="example MOM6 dataset not present (download from Zenodo to run)", +) +def test_equivalent_on_mom6_example(): + records, alias_map = _assert_equivalent( + _build_mom6_grid, xbudget.load_preset_budget("MOM6") + ) + # 108 legacy variables collapse to 57 operation-named variables. + assert len(records) == 57 + assert len(alias_map) == 108 + + +# ECCOv4r4 LLC90 face connectivity (13 tiles), mirroring +# examples/load_example_ecco_grid.py. +_ECCO_FACE_CONNECTIONS = { + "tile": { + 0: {"X": ((12, "Y", False), (3, "X", False)), "Y": (None, (1, "Y", False))}, + 1: {"X": ((11, "Y", False), (4, "X", False)), "Y": ((0, "Y", False), (2, "Y", False))}, + 2: {"X": ((10, "Y", False), (5, "X", False)), "Y": ((1, "Y", False), (6, "X", False))}, + 3: {"X": ((0, "X", False), (9, "Y", False)), "Y": (None, (4, "Y", False))}, + 4: {"X": ((1, "X", False), (8, "Y", False)), "Y": ((3, "Y", False), (5, "Y", False))}, + 5: {"X": ((2, "X", False), (7, "Y", False)), "Y": ((4, "Y", False), (6, "Y", False))}, + 6: {"X": ((2, "Y", False), (7, "X", False)), "Y": ((5, "Y", False), (10, "X", False))}, + 7: {"X": ((6, "X", False), (8, "X", False)), "Y": ((5, "X", False), (10, "Y", False))}, + 8: {"X": ((7, "X", False), (9, "X", False)), "Y": ((4, "X", False), (11, "Y", False))}, + 9: {"X": ((8, "X", False), None), "Y": ((3, "X", False), (12, "Y", False))}, + 10: {"X": ((6, "Y", False), (11, "X", False)), "Y": ((7, "Y", False), (2, "X", False))}, + 11: {"X": ((10, "X", False), (12, "X", False)), "Y": ((8, "Y", False), (1, "X", False))}, + 12: {"X": ((11, "X", False), None), "Y": ((9, "Y", False), (0, "X", False))}, + } +} + + +def _build_ecco_grid(): + ds = xr.open_dataset(ECCO_DATA_PATH).fillna(0.0) + return xgcm.Grid( + ds, + coords={ + "X": {"center": "i", "left": "i_g"}, + "Y": {"center": "j", "left": "j_g"}, + "T": {"center": "time", "outer": "time_bounds"}, + "Z": {"center": "k", "left": "k_l"}, + }, + metrics={ + ("X",): ["dxG"], + ("Y",): ["dyG"], + ("Z",): ["drF"], + ("X", "Y"): ["rA", "rAw", "rAs"], + }, + boundary={"X": None, "Y": None, "Z": "fill", "T": None}, + periodic=False, + fill_value={"Z": 0.0}, + face_connections=_ECCO_FACE_CONNECTIONS, + autoparse_metadata=False, + ) + + +@pytest.mark.skipif( + not os.path.exists(ECCO_DATA_PATH), + reason="example ECCO LLC90 dataset not present (download from Zenodo to run)", +) +def test_equivalent_on_ecco_native_example(): + """The typed engine reproduces the legacy engine on the LLC90 ECCO budget. + + Exercises reciprocal, difference-of-sub-term, and the native-xgcm + lateral_divergence on a face-connected (13-tile) grid. Slow (full 1.6 GB + grid); skipped unless the data file is present. + """ + records, alias_map = _assert_equivalent( + _build_ecco_grid, xbudget.load_preset_budget("ECCOV4r4_native") + ) + assert len(records) == 75 + assert len(alias_map) == 140 + # the (previously dropped) lateral eddy-bolus convergence is materialized + assert "mass_rhs_advection_lateral_bolus_mass_flux_convergence" in records diff --git a/xbudget/tests/test_parse.py b/xbudget/tests/test_parse.py new file mode 100644 index 0000000..e672d82 --- /dev/null +++ b/xbudget/tests/test_parse.py @@ -0,0 +1,137 @@ +"""Unit tests for parsing xbudget conventions into the typed tree.""" +import glob +import os + +import pytest + +from xbudget.nodes import ( + Budget, + Constant, + Difference, + Product, + Sum, + Term, + VarRef, +) +from xbudget.parse import BudgetParseError, parse_budgets + +CONVENTIONS = sorted( + glob.glob( + os.path.join(os.path.dirname(__file__), "..", "conventions", "*.yaml") + ) +) + + +def test_parses_simple_sum(): + d = {"heat": {"rhs": {"var": None, "sum": {"var": None, "adv": "advd"}}}} + budgets = parse_budgets(d) + assert set(budgets) == {"heat"} + heat = budgets["heat"] + assert isinstance(heat, Budget) + rhs = heat.sides["rhs"] + assert rhs.path == ("heat", "rhs") + assert len(rhs.operations) == 1 + (op,) = rhs.operations + assert isinstance(op, Sum) + (name, operand) = op.terms[0] + assert name == "adv" + # A bare-string operand resolves to a nested term whose single operation is + # represented by its VarRef value; here "advd" is a leaf variable. + assert operand == VarRef("advd") + + +def test_parses_product_with_constant_and_varref(): + d = { + "mass": { + "lhs": { + "var": None, + "product": {"var": None, "density": 1035.0, "area": "areacello"}, + } + } + } + (op,) = parse_budgets(d)["mass"].sides["lhs"].operations + assert isinstance(op, Product) + operands = dict(op.terms) + assert operands["density"] == Constant(1035.0) + assert operands["area"] == VarRef("areacello") + + +def test_parses_multi_operation_term(): + """A term may carry both a product and a sum (two decompositions).""" + d = { + "mass": { + "rhs": { + "var": None, + "product": {"var": None, "a": "x"}, + "sum": {"var": None, "b": {"var": None, "difference": {"d": "umo"}}}, + } + } + } + term = parse_budgets(d)["mass"].sides["rhs"] + kinds = [op.kind for op in term.operations] + assert kinds == ["product", "sum"] + sum_op = term.operations[1] + (_, sub_term) = sum_op.terms[0] + assert isinstance(sub_term, Term) + assert sub_term.operations[0] == Difference(operand=VarRef("umo")) + + +def test_metadata_preserved_and_not_treated_as_side(): + d = {"heat": {"lambda": "thetao", "surface_lambda": "tos", "rhs": {"var": None}}} + heat = parse_budgets(d)["heat"] + assert heat.metadata == {"lambda": "thetao", "surface_lambda": "tos"} + assert set(heat.sides) == {"rhs"} + + +def test_none_operand_is_skipped(): + d = {"heat": {"rhs": {"var": None, "sum": {"var": None, "ghost": None, "a": "x"}}}} + (op,) = parse_budgets(d)["heat"].sides["rhs"].operations + assert [n for n, _ in op.terms] == ["a"] + + +@pytest.mark.parametrize( + "bad", + [ + "not a dict", + {"heat": "not a dict"}, + {"heat": {"rhs": {"var": None, "sum": "not a dict"}}}, + {"heat": {"rhs": {"var": None, "difference": "not a dict"}}}, + ], +) +def test_structural_errors_raise(bad): + """Genuinely malformed structure (non-dict where a mapping is required).""" + with pytest.raises(BudgetParseError): + parse_budgets(bad) + + +@pytest.mark.parametrize( + "tolerated", + [ + # unknown key on a term (e.g. a scalar left without its enclosing product) + {"heat": {"rhs": {"var": None, "bogus": 1.0}}}, + # difference / unary op with an unavailable (null) or ambiguous source + {"heat": {"rhs": {"var": None, "difference": {"a": "x", "b": "y"}}}}, + {"heat": {"rhs": {"var": None, "difference": {"a": None}}}}, + ], +) +def test_tolerated_malformations_warn_and_skip(tolerated): + """The parser mirrors the legacy engine: it warns and skips placeholders / + malformed-but-ignorable terms rather than failing, so real conventions that + contain unavailable-diagnostic placeholders still load.""" + with pytest.warns(UserWarning): + budgets = parse_budgets(tolerated) + # the offending operation is skipped, leaving the term with no operations + rhs = budgets["heat"].sides["rhs"] + assert rhs.operations == () + + +@pytest.mark.parametrize("path", CONVENTIONS) +def test_all_shipped_conventions_parse(path): + import yaml + + with open(path) as f: + budgets = parse_budgets(yaml.safe_load(f)) + assert budgets + for budget in budgets.values(): + assert isinstance(budget, Budget) + assert set(budget.sides) <= {"lhs", "rhs"} diff --git a/xbudget/tests/test_utilities.py b/xbudget/tests/test_utilities.py index 1d39902..f25eda7 100644 --- a/xbudget/tests/test_utilities.py +++ b/xbudget/tests/test_utilities.py @@ -303,10 +303,44 @@ def test_collect_budgets_basic(self): } collect_budgets(ds, xbudget_dict) + # New scheme: one variable per node, operator infixes dropped. + assert "heat_rhs_forcing" in ds + assert "heat_rhs" in ds + # The redundant operator-suffixed names are gone by default. + assert "heat_rhs_sum" not in ds + assert "heat_rhs_sum_forcing" not in ds + + def test_collect_budgets_legacy_name_scheme(self): + """name_scheme='legacy' reproduces the historical names and fills the dict.""" + ds = xr.Dataset({ + "forcing_diag": xr.DataArray(np.random.rand(3, 3), dims=("x", "y")), + }, coords={"x": [0, 1, 2], "y": [0, 1, 2]}) + xbudget_dict = { + "heat": {"rhs": {"sum": {"forcing": {"var": "forcing_diag"}, "var": None}, "var": None}} + } + collect_budgets(ds, xbudget_dict, name_scheme="legacy") + # Historical variable names are produced... assert "heat_rhs_sum_forcing" in ds assert "heat_rhs_sum" in ds assert "heat_rhs" in ds - + # ...the simplified names are not (legacy mode is faithful to the old engine)... + assert "heat_rhs_forcing" not in ds + # ...and the recipe dict is filled in place (get_vars/aggregate rely on this). + assert xbudget_dict["heat"]["rhs"]["var"] == "heat_rhs" + + def test_collect_budgets_does_not_mutate_recipe(self): + """collect_budgets must not mutate the input convention dict.""" + import copy as _copy + ds = xr.Dataset({ + "forcing_diag": xr.DataArray(np.random.rand(3, 3), dims=("x", "y")), + }, coords={"x": [0, 1, 2], "y": [0, 1, 2]}) + xbudget_dict = { + "heat": {"rhs": {"sum": {"forcing": {"var": "forcing_diag"}, "var": None}, "var": None}} + } + original = _copy.deepcopy(xbudget_dict) + collect_budgets(ds, xbudget_dict) + assert xbudget_dict == original + def test_collect_budgets_with_lhs_rhs(self): """Test budget collection with both lhs and rhs""" @@ -384,26 +418,6 @@ def test_budget_fill_dict_product_operation(self): # Check that product is correct (2.0 * 3.0 = 6.0) assert np.allclose(ds["heat_rhs_product"].values, 6.0) - def test_budget_fill_dict_reciprocal_operation(self): - """Test budget_fill_dict with reciprocal operation, including zero division""" - ds = xr.Dataset({ - "var_to_invert": xr.DataArray([1.0, 0.0, 3.0], dims=("x",)), - }, coords={"x": [0, 1, 2]}) - - xbudget_dict = { - "var": None, - "reciprocal": { - "inverted_var": {"var": "var_to_invert"}, - "var": None, - } - } - - result = budget_fill_dict(ds, xbudget_dict, "heat_rhs") - assert result is not None - assert "heat_rhs_reciprocal" in ds - expected = np.array([1.0, 0.0, 1.0/3.0]) - assert np.allclose(ds["heat_rhs_reciprocal"].values, expected) - def test_budget_fill_dict_missing_variable_warning(self): """Test that missing variables generate warnings""" ds = xr.Dataset({ @@ -504,3 +518,54 @@ def test_budget_fill_dict_allow_rechunk(self): # The numerical results should be identical xr.testing.assert_allclose(tendency_rechunked, tendency_correct) + + def test_difference_without_grid_raises_value_error(self): + """A `difference` op without an xgcm.Grid must raise a clear ValueError. + + Regression test: previously the grid guard was misplaced, so passing a + plain Dataset reached an undefined ``staggered_axes`` and raised an + opaque NameError instead. + """ + ds = xr.Dataset( + {"flux": xr.DataArray(np.random.rand(5), dims=("x_g",))}, + coords={"x_g": np.arange(5)}, + ) + xbudget_dict = {"var": None, "difference": {"flux": "flux", "var": None}} + + with pytest.raises(ValueError, match="xgcm.Grid"): + budget_fill_dict(ds, xbudget_dict, "tendency_rhs") + + def test_difference_not_first_term_does_not_raise(self): + """A `difference` term that is not evaluated first must not raise. + + Regression test: the `else: raise(...must be xgcm.Grid...)` was attached + to `if var_pref is None` rather than to a grid check, so any difference + reached after another operation in the same node spuriously errored even + when a valid grid was supplied. + """ + ds = xr.Dataset( + {"flux": xr.DataArray(np.random.rand(5, 3), dims=("x_g", "y_c"))}, + coords={ + "x_g": np.arange(5), + "x_c": np.arange(4) + 0.5, + "y_c": np.arange(3), + }, + ) + grid = xgcm.Grid( + ds, + coords={"X": {"center": "x_c", "left": "x_g"}}, + periodic=False, + autoparse_metadata=False, + ) + # A node with a `product` (evaluated first, sets the running variable) + # followed by a `difference` (previously tripped the misplaced raise). + xbudget_dict = { + "var": None, + "product": {"var": None, "scale": -1.0, "a": "flux"}, + "difference": {"var": None, "d": "flux"}, + } + + budget_fill_dict(grid, xbudget_dict, "tendency_rhs") + + assert "tendency_rhs_product" in grid._ds + assert "tendency_rhs_difference" in grid._ds diff --git a/xbudget/version.py b/xbudget/version.py index 276441f..48bd9f8 100644 --- a/xbudget/version.py +++ b/xbudget/version.py @@ -1,3 +1,3 @@ """xbudget: version information""" -__version__ = "0.6.3" +__version__ = "0.7.0"