From 0709c05611cbabc32f49372754b0c2202d90e0cb Mon Sep 17 00:00:00 2001 From: Nic Pittman Date: Fri, 29 May 2026 10:33:16 +1000 Subject: [PATCH 1/8] Create chd.py, two example notebooks and a readme --- use-cases/emmi-chd/README.md | 38 + use-cases/emmi-chd/chd.py | 453 ++++++++ .../portfolio-screening-east-texas.ipynb | 995 ++++++++++++++++++ .../emmi-chd/single-asset-deep-dive.ipynb | 489 +++++++++ 4 files changed, 1975 insertions(+) create mode 100644 use-cases/emmi-chd/README.md create mode 100644 use-cases/emmi-chd/chd.py create mode 100644 use-cases/emmi-chd/portfolio-screening-east-texas.ipynb create mode 100644 use-cases/emmi-chd/single-asset-deep-dive.ipynb diff --git a/use-cases/emmi-chd/README.md b/use-cases/emmi-chd/README.md new file mode 100644 index 0000000..3e33502 --- /dev/null +++ b/use-cases/emmi-chd/README.md @@ -0,0 +1,38 @@ +# Emmi Climate Hazard Diagnostics + +End-to-end examples using Emmi's Climate Hazard Diagnostics (CHD) datasets via Cecil: + +- [Wildfire](https://docs.cecil.earth/datasets/a70e1872-aaa6-480d-b2fc-f778e0343de5) +- [Tropical Cyclones](https://docs.cecil.earth/datasets/158e774c-fd11-4402-b6ce-2596960f4637) +- [Coastal Floods](https://docs.cecil.earth/datasets/e4de28e6-6e9b-412b-97e2-45e3c7c80e6e) +- [Fluvial Floods](https://docs.cecil.earth/datasets/9e2f989c-1df1-44d6-b281-9252002f388a) + +See the Cecil Docs for the full per-dataset variable list and methodology notes. + +Wildfire and Cyclones are provided on a ~0.1° (~11 km) (Floods are ~0.0089°, ~1km) global grid for a historical baseline (1980, calibrated to present-day) and 2030 / 2050 / 2080 under IPCC RCP2.6 / 4.5 / 6.0 / 8.5. Floods are not provided for RCPs 2.5 or 6.0 + +## Examples + +- [`single-asset-deep-dive.ipynb`](single-asset-deep-dive.ipynb): notebook that picks one asset (Channelview Cogeneration Plant) and pulls every variable Emmi publishes for it; intensity, probability, AAL, fire-danger-days, wind speed and depth, across baseline plus four RCP scenarios. +- [`portfolio-screening-east-texas.ipynb`](portfolio-screening-east-texas.ipynb): multi-hazard screening of a small US power-generation portfolio in East Texas. Uses small per-asset AOIs to keep cost low and prints an upfront cost estimate before any subscription is created. + +Both notebooks share a `chd.py` helper (in this directory) that wraps the Cecil SDK with hectare-scale point AOIs, safe re-runnable provisioning, and scenario-aware sampling. + +## Cecil Dataset IDs + +| Hazard | Dataset UUID | +|---|---| +| Wildfire | `a70e1872-aaa6-480d-b2fc-f778e0343de5` | +| Cyclones | `158e774c-fd11-4402-b6ce-2596960f4637` | +| Coastal floods | `e4de28e6-6e9b-412b-97e2-45e3c7c80e6e` | +| Fluvial floods | `9e2f989c-1df1-44d6-b281-9252002f388a` | + +## Cost note + +Cecil charges per hectare of AOI. Emmi CHD is **bundle priced**: one `$/ha` covers all four hazard datasets and every layer (intensity, probability, AAL, fire-danger-days) across baseline plus four RCP scenarios. You do **not** multiply by the number of datasets. + +The examples here use 1 hectare AOIs per asset (well below the 0.1° / ~11 km CHD pixel), so the whole 5-asset portfolio costs cents at the subscription tier. + +## License + +Released under the [MIT License](../../LICENSE) (same as the rest of `cecil_examples`). diff --git a/use-cases/emmi-chd/chd.py b/use-cases/emmi-chd/chd.py new file mode 100644 index 0000000..4e5fb94 --- /dev/null +++ b/use-cases/emmi-chd/chd.py @@ -0,0 +1,453 @@ +"""Emmi Climate Hazard Diagnostics helpers for the Cecil SDK. + +Plain functions composing ``cecil.Client`` calls into the common CHD patterns: +hectare-scale point AOIs, safe re-runnable provisioning, scenario-aware +sampling. Requires ``CECIL_API_KEY`` in the environment. + +Public API: + DATASETS, METRICS, SCENARIOS_BY_HAZARD catalogue + list_variables discover valid variable names + verify_catalog cross-check the catalogue against the live API + point_aoi build a square AOI for an asset + estimate_cost preview $ before subscribing + provision create or reuse AOIs + subscriptions + load, sample read data from a subscription + screen one-call portfolio sweep + +Portfolio shape: + Functions taking a ``portfolio`` argument expect a pandas DataFrame with: + + name str unique label per asset (used as a key) + lat float latitude in degrees, EPSG:4326 + lon float longitude in degrees, EPSG:4326 + value_usd float asset value (optional; drives ``total_usd``) +""" +import logging +import math + +import numpy as np +import pandas as pd +import xarray as xr + +log = logging.getLogger(__name__) + + +# ---------- Catalogue ---------------------------------------------------- + +DATASETS = { + "wildfire": "a70e1872-aaa6-480d-b2fc-f778e0343de5", + "cyclones": "158e774c-fd11-4402-b6ce-2596960f4637", + "coastal_floods": "e4de28e6-6e9b-412b-97e2-45e3c7c80e6e", + "fluvial_floods": "9e2f989c-1df1-44d6-b281-9252002f388a", +} + +# Each metric maps to the hazards that publish it. See the README for units +# and methodology notes. +METRICS = { + "average_annual_loss": ["wildfire", "cyclones", "coastal_floods", "fluvial_floods"], + "intensity": ["wildfire", "cyclones", "coastal_floods", "fluvial_floods"], + "probability": ["wildfire", "cyclones", "coastal_floods", "fluvial_floods"], + "fire_danger_days": ["wildfire"], + "wind_speed_mps": ["cyclones"], + "depth_meters": ["coastal_floods", "fluvial_floods"], +} + +# Floods are only published for baseline / rcp4p5 / rcp8p5. +SCENARIOS_BY_HAZARD = { + "wildfire": ["baseline", "rcp2p6", "rcp4p5", "rcp6p0", "rcp8p5"], + "cyclones": ["baseline", "rcp2p6", "rcp4p5", "rcp6p0", "rcp8p5"], + "coastal_floods": ["baseline", "rcp4p5", "rcp8p5"], + "fluvial_floods": ["baseline", "rcp4p5", "rcp8p5"], +} + +VALID_SCENARIOS = ("baseline", "rcp2p6", "rcp4p5", "rcp6p0", "rcp8p5") +VALID_FUTURE_YEARS = (2030, 2050, 2080) +BASELINE_YEAR = 1980 + +# Variables that exist in Cecil's response but are deliberately omitted from +# METRICS because they aren't necessary for portfolio-style continuous sampling. +# verify_catalog() subtracts these so they don't show up as drift. +KNOWN_EXCLUDED = frozenset(f"land_mask_{s}" for s in VALID_SCENARIOS) + + +def list_variables(metric: str | None = None, + scenario: str | None = None, + hazard: str | None = None, + client=None, + verify: bool = True) -> list[str]: + """Return CHD variable names matching the filters. ``None`` means any. + + list_variables() # every valid name + list_variables(metric="intensity") # intensity_* across applicable hazards + list_variables(scenario="rcp4p5") # *_rcp4p5 across applicable metrics + list_variables(hazard="wildfire") # only what wildfire publishes + + If ``client`` is provided and ``verify=True`` (default), the live Cecil + catalogue is cross-checked via :func:`verify_catalog` and any drift is + logged as warnings. Pass ``verify=False`` to skip the check even when a + client is given. With no client, returns the static catalogue. + """ + names = sorted({ + f"{m}_{s}" + for m, hazards in METRICS.items() if metric in (None, m) + for h in hazards if hazard in (None, h) + for s in SCENARIOS_BY_HAZARD[h] if scenario in (None, s) + }) + if client is not None and verify: + _log_catalog_drift(verify_catalog(client)) + return names + + +def _log_catalog_drift(report: dict) -> None: + """Emit a warning for each hazard with missing or extra variables.""" + for hazard, info in report.items(): + if info["missing"]: + log.warning(f"{hazard}: catalogue expects variables not in live data: {sorted(info['missing'])}") + if info["extra"]: + log.warning(f"{hazard}: live data has variables not in catalogue: {sorted(info['extra'])}") + + +_ALL_VARIABLES = frozenset(list_variables()) + + +def verify_catalog(client) -> dict[str, dict]: + """Cross-check the hardcoded catalogue against Cecil's live dataset metadata. + + Queries each dataset in :data:`DATASETS` for its actual variable list and + compares to what :func:`list_variables` predicts. Useful at session start + to detect drift if Emmi adds/renames variables between releases. + + Returns ``{hazard: {...}}`` with these fields per hazard: + + * ``missing`` -- expected but not in live (drift: maybe Emmi removed it). + * ``extra`` -- in live but neither expected nor in :data:`KNOWN_EXCLUDED` + (drift: maybe Emmi added something new). + * ``excluded`` -- live variables that match :data:`KNOWN_EXCLUDED`. Confirms + which intentional omissions are actually present. If this + shrinks unexpectedly, our exclusion list is stale. + * ``live``, ``expected`` -- the raw sets, for reference. + + Non-empty ``missing`` or ``extra`` indicates the catalogue should be updated. + """ + report = {} + for hazard, dataset_id in DATASETS.items(): + ds = client.get_dataset(dataset_id) + live = {v.name for v in ds.variables} + expected = set(list_variables(hazard=hazard)) + report[hazard] = { + "live": live, + "expected": expected, + "missing": expected - live, + "extra": live - expected - KNOWN_EXCLUDED, + "excluded": live & KNOWN_EXCLUDED, + } + return report + + +# ---------- AOI geometry ------------------------------------------------- + +def point_aoi(lat: float, lon: float, target_ha: float = 1.0) -> dict: + """GeoJSON Polygon of area ``target_ha`` centred on (lat, lon). + + Lat/lon buffers correct for longitude shrinkage so the AOI is square on + the ground at any latitude (1 ha = 100 m x 100 m anywhere). + """ + side_m = math.sqrt(target_ha * 10_000) + half = side_m / 2 + lat_buf = half / 111_000 + lon_buf = half / (111_000 * math.cos(math.radians(lat))) + return { + "type": "Polygon", + "coordinates": [[ + [lon - lon_buf, lat - lat_buf], + [lon + lon_buf, lat - lat_buf], + [lon + lon_buf, lat + lat_buf], + [lon - lon_buf, lat + lat_buf], + [lon - lon_buf, lat - lat_buf], + ]], + } + + +# ---------- Cost --------------------------------------------------------- + +def estimate_cost(portfolio: pd.DataFrame, target_ha: float = 1.0) -> dict: + """Print and return a bundle-priced cost estimate. + + CHD is bundle priced: one $/ha covers all four hazard datasets, so + billable hectares = ``len(portfolio) * target_ha``. + """ + n_assets = len(portfolio) + total_ha = float(n_assets * target_ha) + entry_usd = total_ha * 5.0 + subscription_usd = total_ha * 0.5 + + log.info(f"Per-asset AOI area: {target_ha:.3f} ha") + log.info(f"Assets: {n_assets}, hazards bundled into one $/ha charge") + log.info(f"Total billable hectares: {total_ha:.3f}") + log.info(f"Entry tier @ $5.0/ha: ${entry_usd:>8,.2f}") + log.info(f"Subscription tier @ $0.5/ha: ${subscription_usd:>8,.2f}") + + return { + "total_ha": total_ha, + "entry_usd": entry_usd, + "subscription_usd": subscription_usd, + } + + +# ---------- Provisioning ------------------------------------------------- + +def provision(client, + portfolio: pd.DataFrame, + datasets: dict | None = None, + target_ha: float = 1.0, + tag: str = "emmi-chd") -> dict: + """Create or reuse AOIs and subscriptions for portfolio x datasets. + + Safe to re-run. AOIs match by ``external_ref`` (includes ``tag`` and + ``target_ha``); subscriptions match by ``(aoi_id, dataset_id)``. + Returns ``{asset_name: {hazard: Subscription}}``. + """ + if datasets is None: + datasets = DATASETS + + existing_aois = {a.external_ref: a for a in client.list_aois() if a.external_ref} + existing_subs = {(s.aoi_id, s.dataset_id): s for s in client.list_subscriptions()} + + aois_new = aois_reused = 0 + subs_new = subs_reused = 0 + out = {} + + for _, row in portfolio.iterrows(): + name = row["name"] + aoi_ref = f"{name} | {tag} | {target_ha}ha" + + aoi = existing_aois.get(aoi_ref) + if aoi is None: + aoi = client.create_aoi( + external_ref=aoi_ref, + geometry=point_aoi(row["lat"], row["lon"], target_ha), + ) + aois_new += 1 + log.info(f" + AOI created {name:<28} ({aoi.hectares:.3f} ha)") + else: + aois_reused += 1 + log.info(f" = AOI reused {name:<28} ({aoi.hectares:.3f} ha)") + + out[name] = {} + for hazard, dataset_id in datasets.items(): + sub = existing_subs.get((aoi.id, dataset_id)) + if sub is None: + sub = client.create_subscription( + external_ref=f"{hazard} - {name}", + aoi_id=aoi.id, + dataset_id=dataset_id, + ) + subs_new += 1 + else: + subs_reused += 1 + out[name][hazard] = sub + + log.info(f"AOIs: {aois_new + aois_reused:>3} total ({aois_new} new, {aois_reused} reused)") + log.info(f"Subscriptions: {subs_new + subs_reused:>3} total ({subs_new} new, {subs_reused} reused)") + + return out + + +# ---------- Sampling ----------------------------------------------------- + +def load(client, subscription, cache: dict | None = None) -> xr.Dataset: + """Load a subscription's dataset. Pass a ``cache`` dict to dedupe loads.""" + if cache is not None and subscription.id in cache: + return cache[subscription.id] + ds = client.load_xarray(subscription.id) + if cache is not None: + cache[subscription.id] = ds + return ds + + +def sample(ds: xr.Dataset, variable: str, year: int | None = None) -> float: + """Sample one scalar from a sub-pixel CHD subscription. + + ``variable`` is the full name (e.g. ``"average_annual_loss_rcp4p5"``). + ``year`` filters time; ``None`` picks the only populated entry via + nan-aware mean. Returns NaN if variable/time has no data. Raises + ``ValueError`` for an unknown variable name. + """ + if variable not in _ALL_VARIABLES: + raise ValueError( + f"Unknown CHD variable {variable!r}. See chd.list_variables()." + ) + if variable not in ds or ds[variable].size == 0: + return float("nan") + + da = ds[variable] + if year is not None and "time" in da.dims: + years = _years_from_time(da["time"]) + matches = np.where(years == year)[0] + if matches.size == 0: + return float("nan") + da = da.isel(time=int(matches[0])) + + return float(da.mean(skipna=True).values) + + +# ---------- Screen orchestrator ------------------------------------------ + +def screen( + client, + portfolio: pd.DataFrame, + scenario: str | list[str] = "rcp4p5", + year: int | list[int] = 2050, + metric: str | list[str] = "average_annual_loss", + hazards: list[str] | None = None, + delta: bool = True, + target_ha: float = 1.0, + tag: str = "emmi-chd", + subs: dict | None = None, + cache: dict | None = None, + require_confirmation: bool = True, +) -> pd.DataFrame | None: + """End-to-end multi-hazard portfolio screen. + + Default: per-asset per-hazard climate-attributable delta in AAL under + RCP4.5 at 2050. ``scenario``, ``year``, ``metric`` accept lists to sweep. + + Args: + client: a connected ``cecil.Client``. + portfolio: DataFrame with ``name``, ``lat``, ``lon``, optional ``value_usd``. + scenario: ``baseline, rcp2p6, rcp4p5, rcp6p0, rcp8p5``, or a list. + year: 2030, 2050, 2080, or a list. Baseline rows always use 1980. + metric: a key from :data:`METRICS`, or a list. + hazards: subset of :data:`DATASETS`. ``None`` means all four. + delta: ``True`` -- hazard columns hold ``future - baseline``. + ``False`` -- hazard columns hold the absolute value. + Baseline rows always return absolute (delta is meaningless). + target_ha: AOI size per asset. + tag: inserted into the AOI ``external_ref`` for namespacing. + subs: reuse the output of :func:`provision` instead of re-running + it. Useful when calling :func:`screen` multiple times. + cache: reuse an xarray cache across calls. Each subscription + downloads once; repeat screens are much faster. + require_confirmation: print cost and prompt y/n. Returns ``None`` on abort. + + Returns: + Long-format DataFrame, one row per ``(asset, scenario, year, metric)``. + Columns: ``name, [value_usd,] scenario, year, metric, , + total[, total_usd]``. NaN propagates for combos Emmi doesn't publish. + """ + scenarios = scenario if isinstance(scenario, list) else [scenario] + years = year if isinstance(year, list) else [year] + metrics = metric if isinstance(metric, list) else [metric] + if hazards is None: + hazards = list(DATASETS.keys()) + + for m in metrics: + if m not in METRICS: + raise ValueError(f"Unknown metric: {m!r}. Valid: {list(METRICS)}") + for s in scenarios: + if s not in VALID_SCENARIOS: + raise ValueError(f"Unknown scenario: {s!r}. Valid: {list(VALID_SCENARIOS)}") + for h in hazards: + if h not in DATASETS: + raise ValueError(f"Unknown hazard: {h!r}. Valid: {list(DATASETS)}") + + if require_confirmation: + estimate_cost(portfolio, target_ha=target_ha) + try: + response = input("\nProceed? [y/N]: ").strip().lower() + except EOFError: + response = "" + if response not in ("y", "yes"): + log.info("Aborted.") + return None + + if subs is None: + selected_datasets = {h: DATASETS[h] for h in hazards} + subs = provision(client, portfolio, selected_datasets, target_ha=target_ha, tag=tag) + if cache is None: + cache = {} + + use_value = "value_usd" in portfolio.columns + combos = _build_combos(scenarios, years, metrics) + combos_df = pd.DataFrame(combos, columns=["scenario", "year", "metric"]) + keep_cols = ["name"] + (["value_usd"] if use_value else []) + df = portfolio[keep_cols].merge(combos_df, how="cross") + + records = df.to_dict(orient="records") + for h in hazards: + df[h] = [ + _sample_one(client, subs[r["name"]][h], h, + r["metric"], r["scenario"], r["year"], delta, cache) + for r in records + ] + + # Sum Hazard Aggregation recommended per https://support.emmi.io/questions/climate-hazard-diagnostics-multi-hazard-aggregation + df["total"] = df[list(hazards)].sum(axis=1, skipna=False) + if use_value: + df["total_usd"] = df["total"] * df["value_usd"] + + id_cols = ["name"] + (["value_usd"] if use_value else []) + ["scenario", "year", "metric"] + data_cols = list(hazards) + ["total"] + (["total_usd"] if use_value else []) + return df[id_cols + data_cols] + + +# ---------- Private helpers ---------------------------------------------- + +def _exists(metric: str, scenario: str, hazard: str) -> bool: + """True if ``(metric, scenario)`` is published for ``hazard``.""" + if hazard not in METRICS[metric]: + return False + if scenario == "baseline": + return True + return scenario in SCENARIOS_BY_HAZARD.get(hazard, []) + + +def _build_combos(scenarios: list[str], + years: list[int], + metrics: list[str]) -> list[tuple[str, int, str]]: + """Cartesian product of (scenario, year, metric). Baseline forced to 1980.""" + combos = [] + for s in scenarios: + for m in metrics: + if s == "baseline": + combos.append((s, BASELINE_YEAR, m)) + else: + for y in years: + combos.append((s, y, m)) + return list(dict.fromkeys(combos)) + + +def _sample_one(client, + sub, + hazard: str, + metric: str, + scenario: str, + year: int | None, + delta: bool, + cache: dict) -> float: + """Sample one (asset, hazard) cell. NaN for invalid combos; baseline rows + always return the absolute value (delta is meaningless against itself).""" + if not _exists(metric, scenario, hazard): + return float("nan") + + ds = load(client, sub, cache=cache) + + if scenario == "baseline": + return sample(ds, f"{metric}_baseline") + + future = sample(ds, f"{metric}_{scenario}", year=year) + if not delta or pd.isna(future): + return future + + baseline = sample(ds, f"{metric}_baseline") + if pd.isna(baseline): + return float("nan") + return future - baseline + + +def _years_from_time(time_da: xr.DataArray) -> np.ndarray: + """Return an int array of years for whatever time encoding xarray returns.""" + vals = time_da.values + if np.issubdtype(vals.dtype, np.datetime64): + return pd.DatetimeIndex(vals).year.to_numpy() + return vals.astype(int) diff --git a/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb b/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb new file mode 100644 index 0000000..01a187b --- /dev/null +++ b/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb @@ -0,0 +1,995 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "title", + "metadata": {}, + "source": "## Multi-hazard climate risk screening (East Texas power portfolio)\n\nEnd-to-end multi-hazard climate-risk screening for a small US power-generation portfolio in East Texas, using Emmi's Climate Hazard Diagnostics (CHD) datasets via the Cecil SDK. The heavy lifting lives in the `chd.py` helper in this directory; this notebook composes the helpers into a short, readable workflow.\n\nFor a single-asset walkthrough that pulls every variable Emmi publishes across baseline + four RCP scenarios, see [`single-asset-deep-dive.ipynb`](single-asset-deep-dive.ipynb) next to this one.\n\n### What you need\n\n```bash\npip install cecil matplotlib pandas folium\n```\n\nA Cecil API key exported in your shell:\n\n```bash\nexport CECIL_API_KEY=\"your-key-here\"\n```\n\nIf you'd rather load the key from a `.env` file, see [`tutorials/cecil-data-analysis-xql/scripts/_env.py`](../../tutorials/cecil-data-analysis-xql/scripts/_env.py) for the repo's reference dotenv loader, or use `python-dotenv` directly.\n\n### What the helper provides\n\n* `chd.DATASETS` and `chd.METRICS`: the four CHD UUIDs and the metric catalog.\n* `chd.list_variables(...)`: discoverable variable names with filters. Pass `client=client` to also cross-check against the live Cecil catalogue.\n* `chd.verify_catalog(client)`: cross-check the hardcoded catalogue against Cecil's live dataset metadata. Useful at session start to spot drift.\n* `chd.point_aoi(lat, lon, target_ha)`: latitude-corrected square AOIs.\n* `chd.estimate_cost(...)`: bundle-aware cost preview.\n* `chd.provision(...)`: creates or reuses AOIs and subscriptions; safe to re-run.\n* `chd.load(...)` and `chd.sample(...)`: cacheable I/O and typed sampling.\n* `chd.screen(...)`: one-call orchestration. Default: per-asset per-hazard climate-attributable delta in average annual loss under RCP4.5 at 2050. Long-format DataFrame, NaN propagates for missing combos (e.g. RCP2.6 on floods)." + }, + { + "cell_type": "markdown", + "id": "s1-md", + "metadata": {}, + "source": [ + "### 1. Connect" + ] + }, + { + "cell_type": "code", + "id": "s1-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:02.722423Z", + "start_time": "2026-05-29T00:08:01.810684Z" + } + }, + "source": [ + "import os\n", + "import logging\n", + "\n", + "import cecil\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import chd\n", + "\n", + "# Surface chd's info logs (cost preview, provisioning summary) in the notebook.\n", + "logging.basicConfig(level=logging.INFO, format=\"%(message)s\")\n", + "\n", + "assert os.environ.get(\"CECIL_API_KEY\"), \"Set CECIL_API_KEY in your environment first.\"\n", + "client = cecil.Client()" + ], + "outputs": [], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "s2-md", + "metadata": {}, + "source": [ + "### 2. Define the portfolio\n", + "\n", + "Each row is one asset (Powerplants in this example). Replace these with your own assets to apply the notebook to a different portfolio.\n", + "\n", + "**Source:** asset names and coordinates are from [Climate TRACE](https://climatetrace.org)'s `electricity-generation` inventory (CC BY 4.0).\n", + "\n", + "Asset values are illustrative placeholders (Climate TRACE publishes emissions, not financial valuations). To cite the underlying records:\n", + "\n", + "> Freeman, J. et al. (2025). *Power sector: Emissions from Electricity Generation.* WattTime, Pixel Scientia Labs, Global Energy Monitor. Climate TRACE Emissions Inventory v5.4.1. https://climatetrace.org" + ] + }, + { + "cell_type": "code", + "id": "s2-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:02.758513Z", + "start_time": "2026-05-29T00:08:02.725705Z" + } + }, + "source": [ + "PORTFOLIO = pd.DataFrame([\n", + " {\"name\": \"Barney M Davis\", \"lat\": 27.606, \"lon\": -97.312, \"value_usd\": 1_500_000_000},\n", + " {\"name\": \"W. A. Parish\", \"lat\": 29.479, \"lon\": -95.633, \"value_usd\": 4_000_000_000},\n", + " {\"name\": \"Channelview\", \"lat\": 29.837, \"lon\": -95.122, \"value_usd\": 900_000_000},\n", + " {\"name\": \"Limestone\", \"lat\": 31.423, \"lon\": -96.253, \"value_usd\": 1_800_000_000},\n", + " {\"name\": \"Martin Lake\", \"lat\": 32.261, \"lon\": -94.571, \"value_usd\": 2_200_000_000},\n", + "])\n", + "\n", + "PORTFOLIO" + ], + "outputs": [ + { + "data": { + "text/plain": [ + " name lat lon value_usd\n", + "0 Barney M Davis 27.606 -97.312 1500000000\n", + "1 W. A. Parish 29.479 -95.633 4000000000\n", + "2 Channelview 29.837 -95.122 900000000\n", + "3 Limestone 31.423 -96.253 1800000000\n", + "4 Martin Lake 32.261 -94.571 2200000000" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
namelatlonvalue_usd
0Barney M Davis27.606-97.3121500000000
1W. A. Parish29.479-95.6334000000000
2Channelview29.837-95.122900000000
3Limestone31.423-96.2531800000000
4Martin Lake32.261-94.5712200000000
\n", + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "s3-md", + "metadata": {}, + "source": [ + "### 3. Show the assets on a map\n", + "\n", + "Optional Sanity check the coordinates before subscribing (using folium)." + ] + }, + { + "cell_type": "code", + "id": "s3-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:02.888338Z", + "start_time": "2026-05-29T00:08:02.780541Z" + } + }, + "source": [ + "import folium\n", + "fig = folium.Figure(width=700, height=450)\n", + "m = folium.Map(tiles=\"OpenStreetMap\").add_to(fig)\n", + "\n", + "for _, row in PORTFOLIO.iterrows():\n", + " folium.CircleMarker(\n", + " location=[row[\"lat\"], row[\"lon\"]],\n", + " radius=7,\n", + " color=\"white\", weight=2,\n", + " fill=True, fill_color=\"#d62728\", fill_opacity=1.0,\n", + " tooltip=folium.Tooltip(row[\"name\"], permanent=True, direction=\"right\"),\n", + " ).add_to(m)\n", + "\n", + "# Auto-fit the view to the portfolio bbox, with a little padding for the labels.\n", + "m.fit_bounds(\n", + " [[PORTFOLIO[\"lat\"].min(), PORTFOLIO[\"lon\"].min()],\n", + " [PORTFOLIO[\"lat\"].max(), PORTFOLIO[\"lon\"].max()]],\n", + " padding=(40, 40),\n", + ")\n", + "fig" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "id": "s4-md", + "metadata": {}, + "source": "### 4. Explore what's available\n\nThe helper exposes the dataset UUIDs, the metric catalog, and a `list_variables` query that respects per-hazard scenario availability. Floods only have `baseline / rcp4p5 / rcp8p5`; wildfire and cyclones have all five RCPs.\n\nPassing `client=client` to `chd.list_variables` (or calling `chd.verify_catalog(client)` directly) cross-checks the hardcoded catalogue against Cecil's live dataset metadata and logs a warning on any drift. Good to run at session start in case Emmi has shipped new variables since the helper was last updated." + }, + { + "cell_type": "code", + "id": "s4-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:05.524841Z", + "start_time": "2026-05-29T00:08:02.915655Z" + } + }, + "source": "print(\"Datasets:\", list(chd.DATASETS.keys()))\nprint()\nprint(\"Metrics (hazards that publish each):\")\nfor name, hazards in chd.METRICS.items():\n print(f\" {name:22} {hazards}\")\nprint()\n# Passing `client` triggers an automatic cross-check; drift is logged as warnings.\nprint(\"Variables on wildfire (verified against live Cecil catalogue):\")\nfor v in chd.list_variables(hazard=\"wildfire\", client=client):\n print(f\" {v}\")", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Datasets: ['wildfire', 'cyclones', 'coastal_floods', 'fluvial_floods']\n", + "\n", + "Metrics (hazards that publish each):\n", + " average_annual_loss ['wildfire', 'cyclones', 'coastal_floods', 'fluvial_floods']\n", + " intensity ['wildfire', 'cyclones', 'coastal_floods', 'fluvial_floods']\n", + " probability ['wildfire', 'cyclones', 'coastal_floods', 'fluvial_floods']\n", + " fire_danger_days ['wildfire']\n", + " wind_speed_mps ['cyclones']\n", + " depth_meters ['coastal_floods', 'fluvial_floods']\n", + "\n", + "Variables on wildfire (verified against live Cecil catalogue):\n", + " average_annual_loss_baseline\n", + " average_annual_loss_rcp2p6\n", + " average_annual_loss_rcp4p5\n", + " average_annual_loss_rcp6p0\n", + " average_annual_loss_rcp8p5\n", + " fire_danger_days_baseline\n", + " fire_danger_days_rcp2p6\n", + " fire_danger_days_rcp4p5\n", + " fire_danger_days_rcp6p0\n", + " fire_danger_days_rcp8p5\n", + " intensity_baseline\n", + " intensity_rcp2p6\n", + " intensity_rcp4p5\n", + " intensity_rcp6p0\n", + " intensity_rcp8p5\n", + " probability_baseline\n", + " probability_rcp2p6\n", + " probability_rcp4p5\n", + " probability_rcp6p0\n", + " probability_rcp8p5\n" + ] + } + ], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "id": "s5-md", + "metadata": {}, + "source": "### 5. Cost estimate and provision\n\nPreview the cost, then create the AOIs and subscriptions once. The helper assumes bundle pricing (one $/ha covers all four CHD datasets). Re-running `chd.provision()` is a no-op: it matches by `external_ref` and reuses anything already on the account.\n\nWe also create an empty `cache` dict here. Every `chd.screen()` call below shares it, so each subscription downloads once across the whole notebook instead of once per call." + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:06.450415Z", + "start_time": "2026-05-29T00:08:05.544301Z" + } + }, + "cell_type": "code", + "source": [ + "chd.estimate_cost(PORTFOLIO, target_ha=1.0)\n", + "\n", + "# Create AOIs + subscriptions once. Safe to re-run.\n", + "subs = chd.provision(client, PORTFOLIO, target_ha=1.0, tag=\"emmi-chd-example\")\n", + "\n", + "# Shared xarray cache: each subscription downloads once across all chd.screen() calls below.\n", + "cache = {}" + ], + "id": "7c81ed74f67de71", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Per-asset AOI area: 1.000 ha\n", + "Assets: 5, hazards bundled into one $/ha charge\n", + "Total billable hectares: 5.000\n", + "Entry tier @ $5.0/ha: $ 25.00\n", + "Subscription tier @ $0.5/ha: $ 2.50\n", + " = AOI reused Barney M Davis (1.002 ha)\n", + " = AOI reused W. A. Parish (1.002 ha)\n", + " = AOI reused Channelview (1.002 ha)\n", + " = AOI reused Limestone (1.003 ha)\n", + " = AOI reused Martin Lake (1.003 ha)\n", + "AOIs: 5 total (0 new, 5 reused)\n", + "Subscriptions: 20 total (0 new, 20 reused)\n" + ] + } + ], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "id": "s6-md", + "metadata": {}, + "source": "### 6. Screen the portfolio\n\nOne call. `chd.screen()` loads each subscription once (cached), samples baseline and the chosen future scenario, and returns a long-format DataFrame with one row per `(asset, scenario, year, metric)`. Columns: `name[, value_usd], scenario, year, metric, wildfire, cyclones, coastal_floods, fluvial_floods, total[, total_usd]`.\n\nBy default `delta=True`, so each hazard column holds the climate-attributable change (`future - baseline`). NaN propagates: any missing combo (e.g. `rcp2p6` on floods) makes that cell NaN, and `total` is NaN if any hazard cell is NaN. Baseline rows always return absolute values regardless of `delta`.\n\nIf your portfolio has a `value_usd` column, the output adds a `total_usd` column (`total` × `value_usd`). Otherwise the dollar columns are skipped.\n\n`scenario`, `year`, and `metric` accept lists too — see sections 10 and 11. We pass the `subs` and `cache` from section 5 so this and the later screens share state." + }, + { + "cell_type": "code", + "id": "s6-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:12:10.875Z", + "start_time": "2026-05-29T00:08:06.462619Z" + } + }, + "source": "SCENARIO = \"rcp4p5\" # one of: rcp2p6, rcp4p5, rcp6p0, rcp8p5 (floods only have rcp4p5/rcp8p5)\nSCENARIO_YEAR = 2050 # one of: 2030, 2050, 2080\n\nrisk = chd.screen(\n client, PORTFOLIO,\n scenario=SCENARIO, year=SCENARIO_YEAR,\n metric=\"average_annual_loss\",\n delta=True,\n subs=subs, cache=cache,\n require_confirmation=False,\n)\n\nrisk.sort_values(\"total_usd\", ascending=False)", + "outputs": [ + { + "data": { + "text/plain": [ + " name value_usd scenario year metric wildfire \\\n", + "1 W. A. Parish 4000000000 rcp4p5 2050 average_annual_loss 0.000110 \n", + "0 Barney M Davis 1500000000 rcp4p5 2050 average_annual_loss 0.000018 \n", + "2 Channelview 900000000 rcp4p5 2050 average_annual_loss 0.000465 \n", + "4 Martin Lake 2200000000 rcp4p5 2050 average_annual_loss 0.002963 \n", + "3 Limestone 1800000000 rcp4p5 2050 average_annual_loss 0.001342 \n", + "\n", + " cyclones coastal_floods fluvial_floods total total_usd \n", + "1 1.236606e-02 0.0 -0.000058 0.012419 4.967468e+07 \n", + "0 2.237038e-02 0.0 0.000000 0.022388 3.358236e+07 \n", + "2 1.135418e-02 0.0 -0.000058 0.011761 1.058488e+07 \n", + "4 5.855761e-08 0.0 0.000000 0.002963 6.519415e+06 \n", + "3 1.915760e-07 0.0 0.000000 0.001342 2.415734e+06 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
namevalue_usdscenarioyearmetricwildfirecyclonescoastal_floodsfluvial_floodstotaltotal_usd
1W. A. Parish4000000000rcp4p52050average_annual_loss0.0001101.236606e-020.0-0.0000580.0124194.967468e+07
0Barney M Davis1500000000rcp4p52050average_annual_loss0.0000182.237038e-020.00.0000000.0223883.358236e+07
2Channelview900000000rcp4p52050average_annual_loss0.0004651.135418e-020.0-0.0000580.0117611.058488e+07
4Martin Lake2200000000rcp4p52050average_annual_loss0.0029635.855761e-080.00.0000000.0029636.519415e+06
3Limestone1800000000rcp4p52050average_annual_loss0.0013421.915760e-070.00.0000000.0013422.415734e+06
\n", + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 6 + }, + { + "cell_type": "markdown", + "id": "s7-md", + "metadata": {}, + "source": "### 7. Per-hazard delta AAL\n\nOne panel per hazard. Each bar is the climate-attributable change in AAL for one asset under the selected scenario at the selected year. NaN cells appear as gaps (e.g. cyclone or coastal-flood AAL for an inland asset)." + }, + { + "cell_type": "code", + "id": "s7-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:12:11.065612Z", + "start_time": "2026-05-29T00:12:10.941167Z" + } + }, + "source": "DELTA_COLOR = \"#e45756\" # Vega red\n\n# Filter to one (scenario, year, metric) so the chart has one bar per asset per panel.\nplot_df = risk[\n (risk[\"scenario\"] == SCENARIO)\n & (risk[\"year\"] == SCENARIO_YEAR)\n & (risk[\"metric\"] == \"average_annual_loss\")\n]\n\nhazards = list(chd.DATASETS.keys())\norder = plot_df.sort_values(\"total\", ascending=True, na_position=\"first\")[\"name\"].tolist()\ndf = plot_df.set_index(\"name\").loc[order]\n\nfig, axes = plt.subplots(2, 2, figsize=(12, 6.5), sharey=True)\nfor ax, hazard in zip(axes.flatten(), hazards):\n values = df[hazard]\n y = np.arange(len(order))\n ax.barh(y, values.fillna(0), height=0.7, color=DELTA_COLOR)\n ax.set_yticks(y)\n ax.set_yticklabels(order)\n ax.set_title(hazard.replace(\"_\", \" \"), fontsize=11, loc=\"left\", pad=8)\n ax.set_xlabel(\"delta AAL (fraction)\")\n ax.grid(axis=\"x\", color=\"0.92\", linewidth=0.7, zorder=0)\n ax.set_axisbelow(True)\n for spine in (\"top\", \"right\"):\n ax.spines[spine].set_visible(False)\n\nfig.suptitle(f\"Per-hazard delta AAL ({SCENARIO} @ {SCENARIO_YEAR} minus baseline)\",\n fontsize=13, fontweight=\"semibold\")\nplt.tight_layout()\nplt.show()", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "s8-md", + "metadata": {}, + "source": "### 8. Total delta EAL by asset\n\nTotal delta AAL across all four hazards, multiplied by asset value. This is the headline portfolio-level number: dollars of climate-attributable expected annual loss.\n\nNote: `total` is NaN-propagating, so the same applies to `total_usd`. Assets with any NaN hazard cell are dropped from this chart." + }, + { + "cell_type": "code", + "id": "s8-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:12:11.107519Z", + "start_time": "2026-05-29T00:12:11.068226Z" + } + }, + "source": "def _fmt_usd(x, _pos=None):\n if abs(x) >= 1e9:\n return f\"${x/1e9:.1f}B\"\n if abs(x) >= 1e6:\n return f\"${x/1e6:.1f}M\"\n if abs(x) >= 1e3:\n return f\"${x/1e3:.0f}K\"\n return f\"${x:,.0f}\"\n\nranked = (\n risk[\n (risk[\"scenario\"] == SCENARIO)\n & (risk[\"year\"] == SCENARIO_YEAR)\n & (risk[\"metric\"] == \"average_annual_loss\")\n ]\n .dropna(subset=[\"total_usd\"])\n .sort_values(\"total_usd\", ascending=True)\n)\n\nfig, ax = plt.subplots(figsize=(9, 4))\ny = np.arange(len(ranked))\nax.barh(y, ranked[\"total_usd\"], color=DELTA_COLOR)\nax.set_yticks(y)\nax.set_yticklabels(ranked[\"name\"])\nax.set_xlabel(\"delta EAL\")\nax.xaxis.set_major_formatter(plt.FuncFormatter(_fmt_usd))\nax.set_title(f\"Total climate-attributable delta EAL: {SCENARIO} @ {SCENARIO_YEAR} minus baseline\")\nax.grid(axis=\"x\", color=\"0.92\", linewidth=0.7, zorder=0)\nax.set_axisbelow(True)\nfor spine in (\"top\", \"right\"):\n ax.spines[spine].set_visible(False)\nplt.tight_layout()\nplt.show()", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 8 + }, + { + "cell_type": "markdown", + "id": "1f790136", + "source": "### 9. Portfolio composition: baseline + 2050 RCP4.5 per hazard\n\nA single-ring donut, eight slices: for each hazard, the value-weighted mean baseline AAL (darker) plus the climate-attributable increase to RCP4.5 @ 2050 (lighter). The centre carries the portfolio's total AAL at 2050 and the delta vs baseline. Adapted from the Holcim multi-hazard chart in `emmi-methodologies/scripts/blog_holcim_multi_hazard_charts.py`.\n\nValue-weighted means each asset contributes proportionally to its `value_usd`, which matches how an EAL number would be aggregated. With the illustrative placeholder values here it's a portfolio-shape demo; with real valuations it would be your headline number.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "6cec4603", + "source": [ + "# Get absolute baseline and 2050 RCP4.5 values (one screen call, delta off).\n", + "abs_risk = chd.screen(\n", + " client, PORTFOLIO,\n", + " scenario=[\"baseline\", \"rcp4p5\"], year=2050,\n", + " metric=\"average_annual_loss\",\n", + " delta=False,\n", + " subs=subs, cache=cache,\n", + " require_confirmation=False,\n", + ")" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:13:32.537049Z", + "start_time": "2026-05-29T00:12:11.114213Z" + } + }, + "outputs": [], + "execution_count": 9 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:13:32.642902Z", + "start_time": "2026-05-29T00:13:32.569019Z" + } + }, + "cell_type": "code", + "source": [ + "# Plot Donut chart with Emmi hazard colours\n", + "HAZARD_BASE = {\n", + " \"wildfire\": \"#d7301f\",\n", + " \"cyclones\": \"#810f7c\",\n", + " \"coastal_floods\": \"#0868ac\",\n", + " \"fluvial_floods\": \"#01665e\",\n", + "}\n", + "HAZARD_DELTA = {\n", + " \"wildfire\": \"#fc8d59\",\n", + " \"cyclones\": \"#bc80bd\",\n", + " \"coastal_floods\": \"#80b1d3\",\n", + " \"fluvial_floods\": \"#8dd3c7\",\n", + "}\n", + "CHARCOAL = \"#252734\"\n", + "\n", + "def weighted_mean(scenario):\n", + " \"\"\"Value-weighted mean AAL across the portfolio, per hazard. NaN -> 0.\"\"\"\n", + " sub = abs_risk[abs_risk[\"scenario\"] == scenario]\n", + " w = sub[\"value_usd\"].fillna(0).to_numpy()\n", + " return {h: float((sub[h].fillna(0).to_numpy() * w).sum() / w.sum())\n", + " for h in chd.DATASETS}\n", + "\n", + "baseline = weighted_mean(\"baseline\")\n", + "rcp45 = weighted_mean(\"rcp4p5\")\n", + "deltas = {h: max(0.0, rcp45[h] - baseline[h]) for h in chd.DATASETS}\n", + "\n", + "# Build 8 slices: baseline + delta per hazard. Values in % for label readability.\n", + "hazards = list(chd.DATASETS.keys())\n", + "values, colors, labels = [], [], []\n", + "for h in hazards:\n", + " values.append(baseline[h] * 100)\n", + " colors.append(HAZARD_BASE[h])\n", + " labels.append(f\"{h.replace('_', ' ')}\\nbase {baseline[h]*100:.2f}%\")\n", + " values.append(deltas[h] * 100)\n", + " colors.append(HAZARD_DELTA[h])\n", + " labels.append(f\"{h.replace('_', ' ')}\\n+Δ {deltas[h]*100:.2f}%\")\n", + "\n", + "total_base = sum(baseline.values()) * 100\n", + "total_2050 = sum(rcp45.values()) * 100\n", + "total_delta = total_2050 - total_base\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 8))\n", + "wedges, _ = ax.pie(\n", + " values, colors=colors,\n", + " startangle=90, counterclock=False,\n", + " wedgeprops=dict(width=0.42, edgecolor=\"white\", linewidth=2),\n", + ")\n", + "\n", + "# External labels for non-trivial slices (skip tiny slivers).\n", + "slice_total = sum(values) or 1\n", + "for i, w in enumerate(wedges):\n", + " if values[i] / slice_total < 0.015:\n", + " continue\n", + " ang = (w.theta2 + w.theta1) / 2\n", + " x = np.cos(np.deg2rad(ang))\n", + " y = np.sin(np.deg2rad(ang))\n", + " ax.annotate(\n", + " labels[i],\n", + " xy=(x*0.95, y*0.95), xytext=(x*1.28, y*1.18),\n", + " ha=\"center\" if abs(x) < 0.4 else (\"left\" if x > 0 else \"right\"),\n", + " va=\"center\", fontsize=9, color=CHARCOAL,\n", + " arrowprops=dict(arrowstyle=\"-\", color=\"#999\", lw=0.6),\n", + " )\n", + "\n", + "# Centre annotation.\n", + "ax.text(0, 0.12, f\"{total_2050:.2f}%\", ha=\"center\", va=\"center\", fontsize=22, weight=\"bold\", color=CHARCOAL)\n", + "ax.text(0, -0.04, \"portfolio AAL\\n(2050 RCP4.5)\", ha=\"center\", va=\"center\", fontsize=9.5, color=\"#666\")\n", + "ax.text(0, -0.22, f\"+{total_delta:.2f}%\", ha=\"center\", va=\"center\", fontsize=12, weight=\"bold\", color=\"#d6342d\")\n", + "ax.text(0, -0.32, \"vs baseline\", ha=\"center\", va=\"center\", fontsize=8.5, color=\"#666\")\n", + "\n", + "ax.set_title(f\"Portfolio AAL composition • {len(PORTFOLIO)} assets • value-weighted\",\n", + " fontsize=12, weight=\"bold\", color=CHARCOAL, pad=18)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "id": "2528a20cbee9443a", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 10 + }, + { + "cell_type": "markdown", + "id": "s9-md", + "metadata": {}, + "source": "### 10. Drill into one subscription\n\nFor ad-hoc exploration after the headline screen. Load one (asset, hazard) dataset once and sample any variable across any scenario or year." + }, + { + "cell_type": "code", + "id": "s9-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:13:53.582510Z", + "start_time": "2026-05-29T00:13:32.645757Z" + } + }, + "source": "sub = subs[\"W. A. Parish\"][\"wildfire\"]\nds = chd.load(client, sub, cache=cache)\n\nprint(f\"Today's AAL: {chd.sample(ds, 'average_annual_loss_baseline'):.4f}\")\nprint(f\"Today's fire danger days: {chd.sample(ds, 'fire_danger_days_baseline'):.1f}\")\nprint(f\"Today's intensity: {chd.sample(ds, 'intensity_baseline'):.4f}\")\nprint()\nprint(\"RCP8.5 AAL trajectory:\")\nfor year in [2030, 2050, 2080]:\n aal = chd.sample(ds, \"average_annual_loss_rcp8p5\", year=year)\n print(f\" {year}: {aal:.4f}\")", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Today's AAL: 0.0001\n", + "Today's fire danger days: 21.0\n", + "Today's intensity: 0.0370\n", + "\n", + "RCP8.5 AAL trajectory:\n", + " 2030: 0.0002\n", + " 2050: 0.0002\n", + " 2080: 0.0003\n" + ] + } + ], + "execution_count": 11 + }, + { + "cell_type": "markdown", + "id": "60f52cf3", + "source": "### 11. Climate trajectory: how does AAL evolve under each RCP?\n\nSweep all four future scenarios across 2030, 2050, 2080 in one call. The result has one row per `(asset, scenario, year)`. Line plot per asset shows the four RCPs diverging through the century.\n\n> **Why RCP6.0 sometimes dips below RCP4.5:** the RCPs are radiative-forcing pathways, not strictly-ordered warming trajectories. RCP6.0 back-loads emissions, so mid-century (2030/2050) forcing is *lower* than RCP4.5; the ordering only locks in by 2080. Non-monotonic crossings are a real feature of the underlying CMIP6 models, not a data bug.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "b2002071", + "source": "trajectory = chd.screen(\n client, PORTFOLIO,\n scenario=[\"rcp2p6\", \"rcp4p5\", \"rcp6p0\", \"rcp8p5\"],\n year=[2030, 2050, 2080],\n metric=\"average_annual_loss\",\n delta=True,\n subs=subs, cache=cache,\n require_confirmation=False,\n)", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:31:19.683285Z", + "start_time": "2026-05-29T00:13:53.610429Z" + } + }, + "outputs": [], + "execution_count": 12 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:31:19.946920Z", + "start_time": "2026-05-29T00:31:19.720946Z" + } + }, + "cell_type": "code", + "source": [ + "SCENARIO_COLORS = {\n", + " \"rcp2p6\": \"#4c78a8\",\n", + " \"rcp4p5\": \"#f58518\",\n", + " \"rcp6p0\": \"#e45756\",\n", + " \"rcp8p5\": \"#54a24b\",\n", + "}\n", + "\n", + "assets = PORTFOLIO[\"name\"].tolist()\n", + "ncols = 3\n", + "nrows = (len(assets) + ncols - 1) // ncols\n", + "fig, axes = plt.subplots(nrows, ncols, figsize=(12, 3 * nrows), sharey=True, sharex=True)\n", + "axes = axes.flatten()\n", + "\n", + "for ax, asset_name in zip(axes, assets):\n", + " asset_data = trajectory[trajectory[\"name\"] == asset_name]\n", + " for s, color in SCENARIO_COLORS.items():\n", + " s_data = asset_data[asset_data[\"scenario\"] == s].sort_values(\"year\")\n", + " ax.plot(s_data[\"year\"], s_data[\"total\"], marker=\"o\", linewidth=1.5, color=color, label=s)\n", + " ax.set_title(asset_name, fontsize=10, loc=\"left\")\n", + " ax.grid(axis=\"y\", color=\"0.92\", linewidth=0.7, zorder=0)\n", + " ax.set_axisbelow(True)\n", + " for spine in (\"top\", \"right\"):\n", + " ax.spines[spine].set_visible(False)\n", + "\n", + "for ax in axes[len(assets):]:\n", + " ax.set_visible(False)\n", + "\n", + "handles = [\n", + " plt.Line2D([0], [0], color=c, marker=\"o\", linewidth=1.5, label=s)\n", + " for s, c in SCENARIO_COLORS.items()\n", + "]\n", + "fig.legend(handles=handles, loc=\"upper center\", ncol=4, frameon=False, bbox_to_anchor=(0.5, 1.02))\n", + "fig.suptitle(\"Climate-attributable delta AAL trajectory by asset\", fontsize=13, fontweight=\"semibold\", y=1.05)\n", + "fig.supxlabel(\"Year\")\n", + "fig.supylabel(\"delta AAL (total across hazards)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "id": "3e21141cdf3fa90d", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 13 + }, + { + "cell_type": "markdown", + "id": "next-steps", + "metadata": {}, + "source": "### Next steps\n\n* **Sweep different metrics.** Pass `metric=[\"average_annual_loss\", \"intensity\", \"probability\"]` to `chd.screen()` to compare physical and economic measures side by side.\n* **Use your own portfolio.** Replace the rows in `PORTFOLIO` with real assets and values, then re-run from section 2. Add a `value_usd` column to get `total_usd` in the output, or omit it if you only want hazard fractions.\n* **Drill into one variable.** Section 10 shows `chd.load()` + `chd.sample()` for ad-hoc exploration of any variable in `chd.list_variables()`." + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (cecil_examples)", + "language": "python", + "name": "cecil-examples" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/use-cases/emmi-chd/single-asset-deep-dive.ipynb b/use-cases/emmi-chd/single-asset-deep-dive.ipynb new file mode 100644 index 0000000..7a525f0 --- /dev/null +++ b/use-cases/emmi-chd/single-asset-deep-dive.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "title", + "metadata": {}, + "source": "## Single-asset climate deep-dive\n\nCompanion to `portfolio-screening-east-texas.ipynb`. Instead of screening a portfolio, this notebook walks through **one** asset and pulls every variable Emmi publishes for it: intensity, probability, AAL, fire-danger-days, wind speed, depth, across baseline + four RCP scenarios.\n\nWe pick **Channelview Cogeneration Plant**, on the Houston Ship Channel. It's the most multi-hazard-exposed asset in the East Texas portfolio:\n\n* **Wildfire**: nonzero from East Texas fire weather\n* **Tropical cyclones**: Gulf coast, directly in the storm track\n* **Fluvial flooding**: the only asset in the portfolio with nonzero fluvial-flood AAL at a 1 ha AOI (it sits on the Ship Channel)\n* **Coastal flooding**: zero at this point. Coastal-flood mapping at 0.1° resolution doesn't reach Channelview's pixel even though it's on the Bay. See the caveat below.\n\n> **About zeros in CHD floods:** the coastal-flood and fluvial-flood datasets only have nonzero values at pixels Emmi has modelled for storm-surge / river-flood exposure. With a 1 ha point AOI, a small offset can put you on a pixel that isn't flood-mapped (so you see zero), even if a neighbouring pixel is. To screen for flood risk at scale, either pick AOIs that are *literally* on the coast/in a flood plain, or use a larger AOI (e.g. 100 ha) that intersects multiple grid cells.\n\nUses `chd.load()` + `chd.sample()` directly (the lower-level primitives), rather than the one-call `chd.screen()`. Subscriptions are reused from the portfolio notebook's `tag=\"emmi-chd-example\"` namespace, so this notebook costs nothing if you've already run it.\n\n### Prereqs\n\nSame as the portfolio notebook: `cecil`, `pandas`, `matplotlib`, and `CECIL_API_KEY` in the environment." + }, + { + "cell_type": "markdown", + "id": "s1-md", + "metadata": {}, + "source": [ + "### 1. Connect" + ] + }, + { + "cell_type": "code", + "id": "s1-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:09.831514Z", + "start_time": "2026-05-29T00:08:09.110388Z" + } + }, + "source": [ + "import os\n", + "import logging\n", + "\n", + "import cecil\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import chd\n", + "\n", + "logging.basicConfig(level=logging.INFO, format=\"%(message)s\")\n", + "assert os.environ.get(\"CECIL_API_KEY\"), \"Set CECIL_API_KEY in your environment first.\"\n", + "client = cecil.Client()" + ], + "outputs": [], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "s2-md", + "metadata": {}, + "source": "### 2. Pick the asset and provision\n\nOne-row DataFrame so we can reuse `chd.provision()` unchanged. The `tag` matches the portfolio notebook's, so if you've already run that, this is a no-op reuse." + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:10.646404Z", + "start_time": "2026-05-29T00:08:09.834523Z" + } + }, + "cell_type": "code", + "source": [ + "ASSET = pd.DataFrame([\n", + " {\"name\": \"Channelview\", \"lat\": 29.837, \"lon\": -95.122, \"value_usd\": 900_000_000},\n", + "])\n", + "\n", + "subs = chd.provision(client, ASSET, target_ha=1.0, tag=\"emmi-chd-example\")\n", + "sub_by_hazard = subs[\"Channelview\"]" + ], + "id": "133edba5aa583017", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " = AOI reused Channelview (1.002 ha)\n", + "AOIs: 1 total (0 new, 1 reused)\n", + "Subscriptions: 4 total (0 new, 4 reused)\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "s3-md", + "metadata": {}, + "source": [ + "### 3. What variables can we ask about?\n", + "\n", + "Use `chd.list_variables(hazard=...)` to see the catalogue per hazard. Different hazards publish different metrics (e.g. only wildfire publishes `fire_danger_days`, only cyclones publishes `wind_speed_mps`, only floods publish `depth_meters`)." + ] + }, + { + "cell_type": "code", + "id": "s3-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:08:10.682742Z", + "start_time": "2026-05-29T00:08:10.670405Z" + } + }, + "source": "for hazard in chd.DATASETS:\n metrics_here = [m for m, hazards in chd.METRICS.items() if hazard in hazards]\n print(f\"{hazard:<16} metrics: {metrics_here}\")", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wildfire metrics: ['average_annual_loss', 'intensity', 'probability', 'fire_danger_days']\n", + "cyclones metrics: ['average_annual_loss', 'intensity', 'probability', 'wind_speed_mps']\n", + "coastal_floods metrics: ['average_annual_loss', 'intensity', 'probability', 'depth_meters']\n", + "fluvial_floods metrics: ['average_annual_loss', 'intensity', 'probability', 'depth_meters']\n" + ] + } + ], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "id": "s4-md", + "metadata": {}, + "source": [ + "### 4. Sample every (hazard, metric, scenario, year) for this asset\n", + "\n", + "Walk the catalogue and call `chd.sample()` on each loaded subscription. The result is a long-format DataFrame, one row per measurement. Cached `chd.load()` means each hazard's dataset is opened once." + ] + }, + { + "cell_type": "code", + "id": "s4-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:16:54.813483Z", + "start_time": "2026-05-29T00:08:10.687646Z" + } + }, + "source": "cache = {}\nrows = []\nfor hazard, sub in sub_by_hazard.items():\n ds = chd.load(client, sub, cache=cache)\n for metric, hazards_with_metric in chd.METRICS.items():\n if hazard not in hazards_with_metric:\n continue\n for scenario in chd.SCENARIOS_BY_HAZARD[hazard]:\n years = [chd.BASELINE_YEAR] if scenario == \"baseline\" else chd.VALID_FUTURE_YEARS\n for year in years:\n value = chd.sample(ds, f\"{metric}_{scenario}\",\n year=year if scenario != \"baseline\" else None)\n rows.append({\"hazard\": hazard, \"metric\": metric,\n \"scenario\": scenario, \"year\": year, \"value\": value})\n\ndf = pd.DataFrame(rows)\ndf.head(10)", + "outputs": [ + { + "data": { + "text/plain": [ + " hazard metric scenario year value\n", + "0 wildfire average_annual_loss baseline 1980 0.001523\n", + "1 wildfire average_annual_loss rcp2p6 2030 0.001735\n", + "2 wildfire average_annual_loss rcp2p6 2050 0.001755\n", + "3 wildfire average_annual_loss rcp2p6 2080 0.001856\n", + "4 wildfire average_annual_loss rcp4p5 2030 0.001810\n", + "5 wildfire average_annual_loss rcp4p5 2050 0.001987\n", + "6 wildfire average_annual_loss rcp4p5 2080 0.002234\n", + "7 wildfire average_annual_loss rcp6p0 2030 0.001566\n", + "8 wildfire average_annual_loss rcp6p0 2050 0.001684\n", + "9 wildfire average_annual_loss rcp6p0 2080 0.001710" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hazardmetricscenarioyearvalue
0wildfireaverage_annual_lossbaseline19800.001523
1wildfireaverage_annual_lossrcp2p620300.001735
2wildfireaverage_annual_lossrcp2p620500.001755
3wildfireaverage_annual_lossrcp2p620800.001856
4wildfireaverage_annual_lossrcp4p520300.001810
5wildfireaverage_annual_lossrcp4p520500.001987
6wildfireaverage_annual_lossrcp4p520800.002234
7wildfireaverage_annual_lossrcp6p020300.001566
8wildfireaverage_annual_lossrcp6p020500.001684
9wildfireaverage_annual_lossrcp6p020800.001710
\n", + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "id": "s5-md", + "metadata": {}, + "source": [ + "### 5. Per-metric trajectory chart\n", + "\n", + "One panel per (hazard, metric). Lines are the four RCP scenarios + the baseline anchor at 1980. Some panels are flat (e.g. fluvial flood probability under low warming) and some explode (wildfire AAL under RCP8.5)." + ] + }, + { + "cell_type": "code", + "id": "s5-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:16:55.382687Z", + "start_time": "2026-05-29T00:16:54.877899Z" + } + }, + "source": "SCENARIO_COLORS = {\n \"baseline\": \"#666666\",\n \"rcp2p6\": \"#4c78a8\",\n \"rcp4p5\": \"#f58518\",\n \"rcp6p0\": \"#e45756\",\n \"rcp8p5\": \"#54a24b\",\n}\n\n# Build a (hazard, metric) panel grid for everything in the data.\npanels = sorted({(r.hazard, r.metric) for r in df.itertuples()})\nncols = 4\nnrows = (len(panels) + ncols - 1) // ncols\nfig, axes = plt.subplots(nrows, ncols, figsize=(13, 2.5 * nrows))\naxes = axes.flatten()\n\nfor ax, (hazard, metric) in zip(axes, panels):\n panel = df[(df[\"hazard\"] == hazard) & (df[\"metric\"] == metric)]\n for scenario, color in SCENARIO_COLORS.items():\n s_data = panel[panel[\"scenario\"] == scenario].sort_values(\"year\")\n if s_data.empty or s_data[\"value\"].isna().all():\n continue\n marker = \"D\" if scenario == \"baseline\" else \"o\"\n ax.plot(s_data[\"year\"], s_data[\"value\"], marker=marker, linewidth=1.4,\n color=color, label=scenario, markersize=5)\n ax.set_title(f\"{hazard} / {metric}\", fontsize=9, loc=\"left\")\n ax.grid(axis=\"y\", color=\"0.92\", linewidth=0.7, zorder=0)\n ax.set_axisbelow(True)\n for spine in (\"top\", \"right\"):\n ax.spines[spine].set_visible(False)\n\nfor ax in axes[len(panels):]:\n ax.set_visible(False)\n\nhandles = [plt.Line2D([0], [0], color=c, marker=(\"D\" if s == \"baseline\" else \"o\"),\n linewidth=1.4, markersize=5, label=s)\n for s, c in SCENARIO_COLORS.items()]\nfig.legend(handles=handles, loc=\"upper center\", ncol=5, frameon=False, bbox_to_anchor=(0.5, 1.02))\nfig.suptitle(\"Channelview: every variable, every scenario, every year\",\n fontsize=13, fontweight=\"semibold\", y=1.05)\nplt.tight_layout()\nplt.show()", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQkAAAQfCAYAAACwBm/HAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QmcTfX/x/HPzNi3se8kJVqEiFRCKWlV2rSQdm2KX4tS0iZaaKX6VdpJ268iFSFFKVu2tKLs69gZM+f/eH917v/OuLOa5d45r2eP27j3nHv287nnfM53ifM8zzMAAAAAAAAAgRVf2AsAAAAAAAAAoHCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBIAiZsqUKRYXF+deDRo0sCDp0KFDaN1HjRqV6+lou/nT0fYECuM4vPLKK0PTeeCBBwp03sCB8I9BvZYuXcrGBAAgRpAkBIAYkJqaav/73//soosucgms0qVLW4UKFezwww+3yy+/3D799FPzPK+wFxMAAAAAEKOKFfYCAAAyt2bNGpcc/Oabb9J8vmvXLvvll1/c6+2337ZNmzZZxYoV2Zx54P3333fbV5o2bco2RY48++yzlpSU5P592GGHsfUQONOmTQv9u1atWoW6LAAAIPtIEgJAFNuxY4d17tzZ5s2b597Hx8e7KohnnXWWJSYm2t9//22ff/65ffjhh4W9qEVKq1atCnsRAmPnzp1WsmRJd2zHum3btlm5cuVILMdI6ezdu3e7UtnIO9u3b7eyZcvaiSeeyGYNWPzLbbwEAESX4P0iAUAMefrpp0MJQlGJwVdeecXOO+88O/nkk61nz542evRoW7BggZUpUybiNFatWmW9evWyqlWruhvidu3a2U8//ZRmHL1XtWWVmqtWrZoVL17cypcvb82bN7eBAwe6i/lwah/Nb29KScvvvvvOLY9uDpW8vPjii23t2rWZtpX26quvWrNmzaxUqVJWu3Zt69+/v6WkpOy3/DNnzrTu3btbvXr1rESJElapUiXr1KmTffLJJ9nahvquP9/Bgwfvl4TVevrDf/311yzbJPznn3/stttusyZNmrjtqZucli1b2rBhwyw5OTk0nraJP41jjjkm9PmyZctCn5900kmhzxcuXBj6vGHDhqHPta38z7UNs0vrNnToUGvdurWrmq4b0UaNGlnfvn1t3bp1ofG++OKL0PS1TuldffXVoeH33HNPjqcfqZ1Mbefzzz/f7Usdtw899FBouI7p9I444ojQ8HHjxmW4zi+++GJoPCXX0zvllFNCw1966SX32ZdffulK6mrdq1Sp4o59HcNt2rSxp556Ks0+jdRO4FtvvWUtWrRwx7HOoczaBczpvNLTA4HjjjvObbPq1avb9ddf70oQZ9fGjRvtvvvuc+edjlsdv0ceeaRbj/Tn+IEYM2aMnXbaaS7m6JxVSTKdhz///HNonM2bN7v5axslJCTYihUr0kzjzTffDG3D448/PsfTj9Q2nob36dPH6tSp47a9jl9/2MEHH7xfkw033nhjaPgdd9yR5XrrWFB81XFdrFgxt48VU3XMfP/992nGVYLymWeecck0ja/1UBzUA6AZM2akGXfx4sV2zTXXuLig40zn2wknnOCOrfTLnP74VJzUMaNtrdiuY0aJvHDPPfecdenSxW0DTVvbRseXzqGPPvpov/UMj486pvUboWXTOr/88stZtkmo37QePXrYQQcd5OKG5qk48sQTT7jtkheCGP8GDRqUq+nkJC788ccfdtVVV7nftBo1arjjVr/7mvbtt9++3+9++t+vH3/80U499VS3zfSbDgCIQh4AIGo1btxYd4DudfLJJ2frO5MnTw59p2LFil7dunVD7/1X1apVvS1btoS+M2LEiP3GCX+1bNnSS05ODo0/cODA0LCDDz7YK1as2H7f6dy5c5rlat++fWhYo0aNIs5n8ODBab7z/PPPe/Hx8RkuV//+/TOcx2uvveY+++qrr0KfHXXUUWnGf/fdd0PD2rVrF/r8oIMOCn2u7embMWOG26YZLU/Hjh29Xbt2uXH37NnjlStXzn2udUhKSnKfv/HGG6HxS5YsGRpf6+p/fvXVV4fmqfXwP9f6Zce6devcuma0nHXq1PH+/PNPN25KSopXr1690LCffvopNB0tW2Jiovs8Li7O+/3333M8/fTHpKZXrVq1NOOvXLnSK168uPt3mTJlQttKFixYEBqvVq1a3t69ezNcb31P39e4CQkJ3urVq0PDVqxYETqWypYtGzr+77rrrkyP/XPPPTfNPHr27JnhceyPG+k4PNB5NW/e3O2D9N9p1qyZt2PHjtB3Mpr3b7/9FjEWhJ8bGzZs8A6EjqVLL700w3noeP/kk09C41922WWhYU888USaaSl++MNeeeWVXE1fwoen318fffSRd+SRR4beT5w4Mc261KhRIzRs4cKFma77q6++mum+DY9t2s4tWrTIcNxhw4aFxtUylipVKsNxtQ1TU1MjHjOHHnpoxO9cf/31aZa9TZs2mS57+PKkj4/pt6k/bvhnf/31V5qY65/rGf3WhP825UZQ419uppPTuPD5559neqw0aNDA27RpU8TfL22X0qVLp9kWAIDoQ0lCAIhSKu2xZMmS0HuVnMkpldZRqZB33nnHXnvtNVdqSdavX+8+8x199NH25JNPulIjEydOtMmTJ9vYsWPt2GOPdcNnzZoVsUSJ/PXXX9axY0dXYkUlSsJLaIQvf7jffvvNbrnlFlea4YILLkhTcjK8ZJ3GUbVAVcW69957XakVlRZTCQxRycCvv/46022g0mN+L88qcRle2ih8G6jESGZUwkUlJLVNpVu3bm751X6htp9ouz3yyCPu39ruKlUkWgeVLEzfVpemqZKSMnXq1DTLfCBuuukmt66i0qDvvvuuK4WmZRaV2vJLmmjbqqRpeGlVn9bPb1uvffv2dsghh+R4+ulpeioxN3z4cLc/tc/VlqZKx/oldFQ61qft61NJPZU6y4hKp/jHk0qlqsSZT9PUfpALL7zQlSAVleZUia6PP/7YJk2a5I4nbYNDDz3UDVeHQSr9ktFxrBJdmo+21SWXXJLhsh3ovObOnetK8IwfP94efvhhd3z5pbJUCjEr2nYqBSs6X3U+q8Mj7VfR/lQJ2QOhc9M/p1TK7/nnn7evvvrKBgwY4EoS6Xi/4oorQqUfw8+58ONOpZG0fUQlm1T6MjfTT0+loPr16+eOVZVU1PGsY9mnUto+nadqD1YUB1VSKjMffPBB6N8qgaXl1zbWvjn99NPTVGu++eabbc6cOe7fKomlUoo6fnSMapuoVJqoRJrWx28f9YYbbrAJEya4ZVcpPH+7KbZH8vvvv7sSlp999pn17t07zXqGlxDTuarPNJ5KvWmbqnShvxxan71792Z4Dih+6LvvvfeeK1WdkdWrV7v180vMqvSijsEXXngh9Nuk35q7777bDkRQ459K1OZ0OjmNCzruHnvsMTc9Lb+OF31Hx7io1KhfmjQ9bZfKlSu74frugw8+mOG6AAAKUWFnKQEAkf3zzz9pntC//PLL2dpU4aUW9Jo5c2Zo2A033BD6vG/fvqHPVUrw2Wef9U444QSvUqVKEUvvhY8fXpJQpRLDSzI1adIkNCy8VE94Caczzjgj9LlKe4XPxy9F0q9fv9BnnTp18qZNmxZ6XXXVVaFhl1xySZalqAYNGhT6/M4773SfqXSEX+qiQoUK3vbt2zMtSfjpp5+GPlNJkG+++Sa0PNp24aU0fI8//njo87vvvjtN6VCVANPfhx9+2H1es2bN0LjhJeBySqU4VIrOn9Y777wTWk6tS3gpnl9++cV9RyV9/FJqWn6VrpHzzz8/NO6bb76Z6+mnPybTl/aSqVOnhoa3bt069Hl4iZ1FixZluf4ZTeeYY44Jfa5l9Wm/ax+oBJOOg0il9Z555pmIJbVUMmbnzp37LUNGx+GBzOvYY49NM4+bb745NOzoo4/OdN7z588Pfab988UXX4T22fvvv59m2NatW73c0nr507rjjjvSnLPhJedGjhzpxlcJuIYNG+63f7UNIpWqzen0JaMY5tP6al9ouErsbdy4cb/t+8ILL2S57uElHFVaTqXNItm8eXOaktdPP/10htMMjys6D8LX99577w0NO+644yIeMyol6Zcy1Dntl7LV6+effw59Z/ny5d6NN97oYlN4Sa/wV/j44fFRMSKSSCUJta7hMTT83HnuuedCw7Q/MisxlxniX/bjaG7jgkrDq2aDfvvDfwsiHRPhJQkV7+bNm5er/QoAKDgkCQEgSm3bti3Nhfdjjz2Wre+FJ2TKly+fZlj4jeWVV14Z+vyKK66IeGMY/urVq1fEJOHZZ5+dZh5KNPrDRo0aFTF58eSTT6ZJUIbPZ+nSpe7zLl26ZLlM/s1zVsmZZcuWhRKfqlqmG2clEvxxr7vuujTrEClJOGTIkGwtj17r169335k9e3boM22XNWvWuH/rZt2/eVK1yiVLloTGO+KII7wD8cMPP2R7OXUj6FMi1v9cVbRVVc2v5qhqYX4iODfTDz8mVSU0vHpkuPAbWVWPC98u4Te8WQmvAqnqdEpW+u+VCPFpOcKPmYxeSjJHSsJce+21Eecf6Tg80HndfvvtaeYxevTo0DAldjKb95gxY7K9z8KrW+ZURgmm9C8l4HxKmvqfKz6Jkl7+Z9OnTz+g6Yd//t1330Vc7vCEoBJz2le1a9cOHa/h1SczomM8fcJED1y0P/SwwH8IoYc24eP8/fffGU6zd+/e2VpfNWsQ6Zi55ZZb0kxPSW1/2JQpU9xnq1at8qpXr57lPJR8jxQf33777YjLHilJGL4+iu/h5s6dm+Y7SlzmBvEv+3E0N3Hhvvvuy3JcNbsRKUmouAwAiH5UNwaAKKXGwBs3bhx6r2rAOaWqPeHUsLzPb/BeVYBUfc2nqkWqCqTqdmpc3udX1czNPDL7Tvj4mX0nI9npcKF+/fqusxNRj9DffPNNjqoa55S/TKqK5q+rqpGqGp+oIwG/SvH06dNDVSvzoqpxbpZTVJU1vMqdqk/61RwvvfTSXPUCG2nfqLF7VQ2NJH3VT1V594VXCcxK+uqD4fs6fD3VQYRfzVvV79SBgPaFjn01rp/Vsa/qfdl1oPMqKHnZgUl25qFqmX7PrtpPqhLsd/KhKr5t27Y9oOlnZ3+pgxKfOlTSObly5Ur3vmvXrq46aFbUKYM6gFLHKKqCrurQqvasfa7qxJdddpnll4zWNzuxWevrdzahc1PnnZZZx6XWIS/PgWhTVONfXk0n/bqomnR40wY6plXNWsfKnXfeWaSPFQAIEpKEABDF1FNleJIw/GI/fbtQe/bsydU8lDTzqTdO9dKrpIV63Uzf42hBOvzww0P/Vrta/5Z+3+/ltw2VlfBEoNpU8tsGVO+j6qEyJ8ujpKNumCItj26m/PbCwnsk1v5R751+23Tq2VG9iW7dutW1/+VTL9EH4rDDDkvTbpXahcxoOcPbzVJbVn5bjx9++KFLHvjUs+qBTt+X0Q2y3z6W2hUUJa79NrXUo2tW7f2F03z9ZQxPEipJEr5My5cvD/1bCV21baftryRu+LCMZLYu6R3ovPw2LSO999s0zM6xq2SH2tXMaJ/5bZHlRvh81H5gpHmo3UC/Z2mpW7duqCdqtW966623Zpi8z830s7O/NF3/vFNbgerpNVIMzozmrf2qtua+/fZb156g2gRUm4p+e5NqJy79+ROprVc/gRe+vurhOaMYeCCJ3fBjT+efkmWKT4pxGzZsyNNzILz3YLU96Cfh0h/PigG5TSgR/7IfR3MaF3Q8hPeMPXLkSNcWoa4V8vpYAQAUnrTFNwAAUUWlUnSBr84J/GSZSvmdddZZ7iZASTw1ZK/koRrZVyP4OdWwYcPQv3Whr443WrVq5RomDy/hVtB0c64bbpVKUMPw6mhC663G9NXQ+qJFi1xnKffcc0+2buRVIkhJUK2jtllOSxEqcarEnpKqurFWYuPaa6+16tWr26pVq1wJKO2bRo0apelIQCUDlXTzO58Qv0MT3YwrMaJ1EZWo8pOKvlGjRoVKf+hGTQ3FZ0alns4///xQQvmMM85wJZmUSNJN4LJly1xJyl9++cW9fLqBVMkQJSy3bNniEh2ixMcxxxxzwNPPDiVUlMR79tlnXec6euWkNJevdu3arlMEdaagBLpPx49K8kQ69tWhjTpQUOJWSaaMOt3JrQOdlzq4ue6669y2VyJLSTKf37FHRpQIV+cbKs26c+dOlxBTMk7Hs5JZOgbViYrOtfASy+E39RrH7wAoIzqXZs+e7f6tDkI0bc1XCXKdNyppp3NWyxE+LX1PJZJEHbOIOmZRpx15Mf3slr7yO0FSB0RSp06dNKU8M3P77be7GKAOprRd1RGHllWJQfETmErEq+McP3Gjc0dxXOe2kjGKuc2aNXMdjaijJMU3fa7SjeqUR6XaNG19R8eNtpfOj/BOo3J7XCrmq+SmjoNBgwbluFR3VnSc9u/f320TlV7U+qgzFsVzdUwVnuTySz0q3qlDDdHDF3WMkRniX/bjaE7jgmKnajj4iUIdm2effbYbJ6POcwAAMaiw6zsDADKnNqNOOumkLNsB8tvNCm//TW1HhQtvS1BtV/nU+Uf66al9rXbt2kUcP6PpZNYuYEafZ9R+ld+YfaROVMJf2Z2H9OnTJ813S5QoEWo/MKs2CUXto1WsWDHT5Um/PRYvXpxmuBqB99v3e+WVV9IMa9Wq1X7LEt6mk9YvO9auXZumXapIr/THhsyZM2e/8dRG24FOP7NjMr3020uvCRMmeDn10Ucf7TcddT4TTp05HH/88fuNV7ZsWddRiP9ex3ukNt/CPw8X6Tg80Hn5Hd6kfzVt2jRNpzsZnQO//vqrV7du3Uz3WfrjK6PzMiNax+7du2cZq9JPa8+ePa4ji/BxunXrlifTz+46qKOM9NvH72woO66//vpMl+mcc84JjauYo85mMhp32LBhoXE//PDDUNugGb2ye3xGimv6fVHbiemnqbZRw9sqDI+DGcXHcBltd3XqEt65UfqXOqdRe6i5iR0+4l/242hO44LOiUjjdOjQIeL4ufn9AgAULqobA0CUq1mzpivZomppKnmhamAq9aXSAmqzUCVLVJVNpUty67///a9ri1BV/1TtqE2bNq6EyoFWfT1QKt2j9slUwk3rrZKSKkGp9VZpnDfeeMOVrMqu9KUG/dKF2aVSNvPnz7e+ffvakUceaWXKlHHbSyXCVOJIVbUffPDB/arYqWSbT6U0/fat0lftzKvtXa1aNVfyTNWbVZ1Vx4ZKZmk59F6ldtTmVnrpSw36pQvzavrZoe0V3i6jjsnsluYKl77UoF+6MJxKburcUUlUv5SMSi2p9JLaw8tLBzovVRNUSa+WLVu6/aL24lSSVbFBx2FWVMJVJRjvv/9+a9GihYsfKpWr80olWlWCWNUHfSkpKWm+r3Gzs46q2v3ee++5aog6TlQiTMt69NFHu1JjiisqqRQuo1KDeTX97FAV4Ouvvz7NZ9mtauyX8la1fJXOUkzR9LSPta0VE8aMGRMaV8N/+OEH176bYop//qiKrUrmKv6GNwOgkqMqRarSutr3mq7+rWNc+yy8TcXc/L7oGFSbrYqtWjaV5NNxlZt2+LJzHCt2aB7aT1pvHYs6rocOHepKMPtVZdMfh1r37CD+ZT+O5jQuqC1VvVQCVftD552adIjUtAQAIDbFKVNY2AsBAADge/755+3mm292/1b1xEcffZSNU8CUxFLCV5T8evnll4v8Pli4cKEdddRR7t9K3qmKLwrXkCFD7O6773b/fuutt/K1A5iiFv+IowCA3KBNQgAAUOj0zFJtXa1evTrUvpVKjoV3moKC47dNqBKYfoc7RZXayFMHQioJ7EtfqhCFexyqhGVRThDmVfwjjgIADhRJQgAAUOjU4YmqbYdTFcvwjhVQcPxOi9TByoE0ZRALVN1bx59PVYaLckIqVqijF/V6rE6rwqu8FkV5Ff+IowCAA0WSEAAARA31qKvSa2prU21foXD4Pf0GSeXKlV07bmor0O9dF4VHbeP5vUMHRV7FP+IoACC3aJMQAAAAAAAACDh6NwYAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQA5KkOHTrYbbfdVmhb9corr7SuXbtGzfIgdwYPHmzHHnuslS9f3qpXr+726ZIlS3I1rXHjxlmbNm2sdOnSVqlSpTTHBwrWY489ZnFxcbk6Jxs0aOC+G/7S9FCwVqxYYZdffrlVqVLFnVNNmza1n376KUfT2LVrl910001uGuXKlbNu3brZmjVr8m2ZEVlKSordd999dvDBB7t9ecghh9hDDz1knuflaJPpdzb9uXnDDTew2QEgBhUr7AUAAOQ/JUk++eQTO+ecc+zMM88M1Cb/8MMPrXjx4oW9GIGyZ88eK1GixAFNY+rUqS6JoETh3r177Z577rHTTjvNFi1aZGXLls32dD744AO79tpr7dFHH7WTTz7ZTWvBggUHtGxBkhf70vfjjz/aiy++aEcffXSup/Hggw+6/elTEhkFty83bdpkJ5xwgnXs2NE+//xzq1atmv32228u+Z4Tt99+u/tdGjt2rCUmJtrNN99s559/vn333XcHtHxBkhf7c8iQITZixAh7/fXX7cgjj3TJ3l69erl9cuutt+ZoWjovdX76ypQpc0DLBgAoHJQkBICAJAhFf/U+SCpXrhy4RMLK9Vvt9Qk/2+PvznB/9T4/qRSJbvJVOqxq1arWuXNnW7hwoZ111llWoUIFt/3btWtnf/zxR5rSnoMGDXJJBo2jUie66fVNmDDBjacb12bNmtmoUaNs+fLlNmvWrNA4Kq2iG9wuXbq4UjANGza0999/PzRcCcE+ffrY448/7qZ/2GGH2RFHHGEXXXSRxYrUjX/ansmP2O6Pe7u/eh9r+1K2bdtml112mb388ssRE0pZ7Uuf5l+zZs3QKycJ48K2d9UqS3r3Hdv4zNPur97H2r5UUqlevXr22muvWevWrV0JNCXvVQItvMSnSqN1797d7Z86derY888/HxqelJRkr7zyij311FMucd+yZUs3venTp9v3339vsWDVlhX29uxRNnzaUPdX7/NbfuxPbfNzzz3XPTzUfrvgggvc/pw5c2a292d4UjD83NT8AACxhyQhAAQkQegriEShkjO6mVFpBN3MqDqTX33pzTfftFatWoVu9i+99FJbu3ZtmpIqSibopkbJgkaNGrkbSN/ff//tkjwVK1Z0CUDd4CxdujTDZUlf3Vg3PCpVdtVVV7llqF+/vr300ktpvpPTeUSTiT/9aTc8Nd4+nPaLTZu/3P3V+4mz/srX+aokikq1qCTQAw88YCeddJKVLFnSvv76a5fY0/bWceGbNGmSLV682KZMmWLvvvuuK/Gpm9mMKLEg2h/hdGypquK8efPccXPJJZe46crs2bNd1cj4+Hhr0aKF1apVyyWhYqUk4d55o23Xi+1s7/cjLGXxJ+6ve//zmJjblyoVqkREp06dMpxvZvvSp+rFqqKq/ankb/hyRLPtUybbmr6327ZPP7WdM2a4v3q/fcqUmNqX+v1Q/L7wwgtdMwDaD0r8pqd9o+T+nDlz7O6773bJ+q+++soN03yTk5PTHAtNmjRxsXjGjBkW7Sb//pX1+d8N9smiD2360mnur95P/mNivs87r/fn8ccf78b59ddf3Xude99++62Lk9ndn763337b/d4fddRR1r9/f9uxY0e+bw8AQN6jujEABChB6PM/z6+qx7qRufrqq11pBFVfuu6669wNoKoj6eZQpRIaN27skoN9+/Z1JR7Gjx8fShSoSqmqsumG4/fff7edO3e6YfquSk+0bdvWpk2bZsWKFbOHH37YTj/9dPv555+zXfXqySefdMugKqwqrdS7d29r3769W6a8mkdhUInBZz780ZSP9ZOy/t9nPphpRxxU1WpXzZ9SlUrmDh06NLT/lSAePXp0qKq3SvGF03Z89dVXXekTlRZUNbU77rjD7Rcl9cKlpqa6RK+qOeoGNJySFddcc437t76rG9dnn33WXnjhBfvzz32l7nQzrVJLShBr3ytxrJvi9AnHqCtBOL6fmZe637A94/pafN3WFl/54JjYl/quEraqbpyZzPalqPrjMccc4/abSkApEbFq1Sq3b6OZSgxufvFFnYz7XvLv380vjrSSTZpYsZo1Y2Jf6pxSiU/FbcVP7VPtF32vZ8+eoenoXFUyyZ+HklrDhg2zU0891VavXu3G10OYcDVq1HDDoplKDI6Y8Yx5+i9djB0x/WlrUu0Iq1Whdr7NP6/3p/bRli1bXJI2ISHBtVH4yCOPuCR9uMz2p+hh30EHHWS1a9d2v5N33XWXa0NWSUkAQGwhSQgAMUQ3Y7qIz4qSKnplRonCzz77bL+ETHq6cXjmmWdytJyqjqYbCFUhVOJt/vz57r2ShCrp4FOVQk1b7c6pOqIasFeVUpVOUWkVUWLHN2bMGLde//3vf920RaUMdbOpkhKqJpUdZ5xxht14443u37qZ0bJNnjzZLWtezSOvXDTwA0tOyXxf+lJSU0M5iPT0uUoUJmSxv6V4Qry9N6hbjpZTVQZ9c+fOddXeMmsLUqVSwtusUlJWx4BKcepmM30pNJX+UwmX9PS99O81f/HPgXvvvdeVUPP3Zd26dV1baNdff70VpB1PHGqWkpy9kVP3RkwQOl6q7XrxRLP4bFzGJRS3Mv/5vdD2peKLX+qoVKlSmc43s30pSkz51K6hEiDah+rkRqWpCtLKK3ual91SjIrZmZyYa26/TYE2y8nEFStmtUe9Xqjnpc4pxWaVxhbFap2bI0eOTJMkjLQvhw8fbtHoincvtL2p2TsvU1JTXIIwEn3e53/XW0J81vuyWHxxe7P72Bwva17vz/fee8+VAHznnXdcElHT1AMZJftysj/1INCnjmxUavuUU05xVZ/Dq6IDAKIf1Y0BoAjKKkGY0/Fy6rjjjgsl2PwbCjVurwSnqkSdffbZrmShqvuqBJ8oOSgq1aeSEc2bN7c777zTlRjyqSqUShbqe0oo6qVSReop02+HKTvCO07Qcqras1/lOa/mETThbcOpmnheUbV1JbOVxFVyLyd0oypqh9CnZJKS0/7xhvzdlzrfdW6pBKBK5eqlTmn0cED/zs5Dj4yox2pVrYyVpgCKwnmpcyr8fJLDDz88R+eT4q3axdu8eXOaz9W7sYah4PanShWqhKCq9iu5d8UVV7hOZZR4PxA6N0W/pQCA2EJJQgCIIdkt0ZdZVeNwBd3bsRJtqsqrl0ovqN1B3Vzqvd+YutpCWrZsmat+rNJHKo2gkmRPPPGEKwGhkhT6bnqaVnalL3mhRKGfMM2reeSVnJToUyclaoMwNXX/ki7xcXF2/klNrOfpue9ZNidJWFWFU9XtjEq5KBmrauT+ja46LFBCVqVQ/Sp8t9xyi3300UeuBKc6SIhE3+vRo0ea9yrdJNqPSgqq2tuJJ57oPtMyKamUvrRiQchJiT51UqI2CM2LkESLS7Bix/W2Eh3vtWjfl0qwqyRxOPWequqNKsWrksrZ2ZeRqNSTSiqqbbyClpMSfeqkRG0QWqSHMvHxVu7ssy2x+6UWC+elqp3qfAqnqvvpz6f0HZDovZKJ/nmp+astPL+Er6ap34L0JdYKQk5K9KmTErVBmBqhlG98XLydc8T5dtkxV1pByIv9qXYD09cm0DmZ/gFiZvszEr8EsP+gBgAQOyhJCABFkBJ/SgAWVoLwhx9+2O+GQm0p/fLLL7ZhwwbX+YCqSSlREN5pSXgyTlWd3nrrLVelye9YRKWRVCJRSYFDDz00zUttM+WFgphHfjm11cGh9rEiVYXT8IKg0n9q50qlU9QmpbanOqwJTy4oKax2K9X+pBLCAwcOdN/zb1iVGNb+VzU4lepUW2V6+e1T+lRtWG1uKVGhaagdTE1H/N489fmXX37p5q+Sqn77d9GsWLPubq9F5lmxZvmfVMqLfal9p3Ykw18qDaXOR9K3L5nZvlSHFooFSnqoXTwl8VXi6fLLL4/YW3I0KduhY6bVjct2PDlmzkttc8VzVTdWKTGdn4rPOl/Dqc06tZ2nfamecLVvVe1cFEc1D1UfVwlhlTZV4lgJQpVCj2YnH3pqxjHW8+zkQwuuOYq82J8q1a82CPVgUQ9P9FBGbXyed9552d6fKmGvNg61HzUNPaBUsl+dqoSX2gcAxAaShAAQwERhfpcgVIkQ3QDqZkU9KqrzAd1QqIqx2hHTe93o62ZCNxfh7r//fvvf//7nbkAXLlzoqpr6JRbUmLo6M1Fvw+pU5K+//nKlzNRW4z///JMny14Q88gv6pTk1m6tTTW94+PjXOlBvfRen+dXpyXpKQGk3jZVKlPVyVVySD2ghpd2UQlRJY51I3nxxRe7Y1IdjPjUOYJ6NFYnIyqN4r/UZmQ49dSp6um6GX3jjTfc8RZeHVK9cuomWtXo1PalSqlq2aI9sRRfuaGVOPMps7h4V3Iw/K8+z69OS/JjX2ZXZvtSJUI1TMugttOU2FDCKn3P5NGoWK1aVvH6G1Rk2ZUcDP+rz/Or05L82Jc6h5RI0r5RklfxW8nb9B1d9OvXzyWuVBJUHT8p8aQS4z61A3vWWWe5koSal6oZx0InF7Uq1LHex/exOFNsjbe4uPh9fy3OfZ6fnZbkx/7Ub/EFF1zg2ujV7+x//vMf185n+t/lzPanftMnTpzo2uvVgz+Nq/36qUrPAgBiTpyX0eMwAECRkL7qcX4nCJXU0U28qiuplImqLqn0lm4sVK1XN5fqFVO9kqrUnnoo1TLNmTPHtUOo8fQ9lUhQFSmVONQNpV/dVKXJVE1RpSK2bt1qderUcTdCqo6skmPqKVltXX388ceh5dF0/UbW1RGKGmbXy6fhXbt2Dd08ZTWPaKdejr/66S9bu2m7Va9U1pUgLKgEYXak30e5peNJCQvtu6IqdeNftnfeO+Yl/WNxiXVdCcKCShBmB/sy+/auXm3bJ39tKevWWUK1aq4EYUElCAtyX0aKsUXNqi0r7evfv7R129datbLVXQnCgkwQZgf7EwCQG7RJCABFnJ8QVKKwINogVKm78NJg6XXv3t29woU/rxowYIB7ZUQlTtQOU0ZGjRqV4fJIpE4OwntQzc48op0SggXR9iDynxKCBdH2IPKfEoIF0fYg8p8SggXV9iAAAAWJJCEABIASgwXZQQkAAAAAILZQ3RgAAAAAAAAIODouAQAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiRhETZq1Chr3rx5tsa97rrrrHLlylazZk1bunSpxcXF2ebNm/NlubRMWjYUPR06dLDhw4dnOZ6Or7lz5xbIMiF4gh77tPxaD61Pfsjv7QQgd4IW+2644Qa76667LNpMmzbN6tatW9iLAQRG0GJfXpsyZYpVrFgx19+/8sor7bbbbstweJcuXeyFF16IOK/wYYgeJAljSH4lVr799lt7//337a+//rLVq1dbNNu9e7cLLOvXry/sRQFQQIh9hRv7ojWpT7ISRR2xL/PYN3LkSBsyZEiB3ATnRLt27eyff/7J8QNUAPsQ+4rWPe/nn39uN954Y5bDCjJOI3MkCeGSg/Xr17fExMSo3xqTJ0+2pk2bWtWqVQt1Ofbu3Vuo8wdw4Ih9SE5OZiMgcIh9AIIoqLGP+1bkFEnCXNqyZYvdfPPNdtBBB1mFChXs2GOPtb///tsNW7NmjV100UVWrVo1F4juvffe0Mm5bds2O/fcc6169eouQJ100kk2b9680HRnz55txx13nJumgsLZZ5/tPm/durX7e/zxx1u5cuXs0Ucfde8vv/xyq127thu/ZcuWLqDkxDPPPGPXXnutzZ8/301XxYUj3UT179/frYvW6eKLL7Z169aFhv/+++/WuXNnV3T7kEMO2e9p6XPPPWf16tWzKlWquG2RPlh36tTJbQt9/4QTTrAdO3ZkuLyffvqpnXPOORGHffnll9aqVSs3rVq1armnEjt37nTDhg0bZieffHKa8ceMGWNNmjQJvR89erQdffTR7gmG9uf06dPTPAW+88477bTTTrOyZcu6px6ZzU/0FPnUU08N7RvtswYNGoSG61jQMaTtquOhR48elpSUZFl56qmnrFGjRla+fHm3vbV905esefPNN+3QQw9166J96t8I+09o/vvf/4b2idbL98ADD1jXrl3TzE/j63syZ84cO/HEE92+0rHQvXt327Bhgx0Iz/PsySefdOui6Z5++un2559/pllfbSOtr7aflj03xw7yBrEv+mKfnjb37t3bTefggw92JcPTn2OK9Yp3Op8VzxYvXhwarvPqkUcesWOOOcbFK63TypUrM/3t8ZcpUpzJjOKTtssRRxzhYukVV1xhmzZtcr8rmneLFi3sl19+yVac9JdN1fq0bG+//Xbod7Rjx45ue2j5Xn755TQx7qyzzgptr7vvvptYgmwh9kVf7Auv4pbZ9Y+uU1SlTbFDsUIvVQmWiRMnulii8Y888kj75JNP0kxf18iXXHKJuwZp3Lhx6HpIFHP867E6derYQw89tF9pmH79+rl5qVq05qvlePrpp10cDqdrUMVFINoQ+6Iz9l111VXunk1xRfevqhmY2X1rZvkJ37PPPuvuaVUVe+DAge76UZYvX+7uafXdSpUq2ZlnnrlfkzY6TjJbnoxKU/vDMorTNWrUSBN35fDDD3f38chHHnLlvPPO8zp37uytWLHCS0lJ8WbPnu2tW7fODTv55JO9Sy+91Nu6dau3dOlS74gjjvAeeeQRNywpKckbPXq0t23bNm/nzp3erbfe6h122GFeamqqG962bVvv4YcfdtPctWuXN3Xq1NA8tbvmzJmTZjleffVVb/Pmzd6ePXu8oUOHepUrV/a2bNnihr322mtes2bNslyX9OP99ddfbl6bNm1y7wcNGuQdddRR3rJly9w6XXzxxd6pp57qhiUnJ3uNGzf27rjjDrc+8+bN82rVquW9/fbbbvikSZO8ChUqeNOnT/d2797t3XPPPV5CQoKbp3Tv3t27/vrr3fLr9d1337nxMlKvXj3vl19+iTjsm2++cfth79693h9//OE1adLEbUtZvXq1V7x4cW/58uWh8c8888zQ8HHjxnl16tTxZs2a5bb9Bx984Lbl+vXr3fD27dt71apV83744Qe3r3bs2JHp/KRdu3be1Vdf7cZdsmSJ17BhQ++ggw4KDb/wwgvd+ms763i45JJLvMsvvzzL/fX++++79dByfP31116pUqW8b7/9Ns2+03R1HOj4rFu3bmh7T5482YuPj/duv/12t78WLVrklSlTxn0uAwcO9M4999w080tMTAwNnzt3rjdt2jS3r7RNtY7XXHNNaFxtp2HDhmW5DuHH8uuvv+7Vrl3b+/nnn90y9e3b150zOra03UqXLu0tXrw4tB91jOXm2EHeIPZFX+y77777XAzX+a540qVLF3eOKR7I888/7x199NHer7/+6pb76aef9g455JDQ/BSXGjRo4M6z7du3ez169PA6duyY4W9PVnEmM/pep06dvA0bNrjvVa9e3WvatKmLK1q2K6+80jv77LOzFSfT/1bJqlWrXOweM2aMi83z5893+2XixImhGOfvB81P60ssQXYQ+6Iv9vXs2dPr06dPtq9/dD0TTstesWJFt8y69lMc0rL789P0y5cv776rePLQQw+FruMUj4oVKxa6TlccmjlzZsR5pb820rWlrt3+/PPP0GennXaau44Hog2xLzpjX8mSJb1PPvnELdeIESO8SpUqha6HIt23Zpaf8O8PdQ2m6yJdDyp+jho1KhRfx48f79ZbuYwLLrjAXcvlZHn8GJhZfIwUp/v16+em79P21bSVJ0H+IUmYC0pU6EJESbP0/vnnHzdM4/gUPBo1ahRxWjp5NL6+JyeddJJ37bXXen///ff+OytCkjA9Xez4CaO8ShIeeuihLrHp04WXhuuv5qWAGB7kFHD8JOJVV13l9e7dOzRMQVHj+wFTN6PnnHOOu3nNitY9o+0YiQJOeADTjfPgwYPdv9esWeOVKFEitA/POOMMb/jw4Wm+f/zxx3tvvPFGKID5F6LZmZ+SeNpGfuJYdPHnX1yuXbvWBeONGzeGhmsbKJGpC9GcUFLPT076+85PqomSeDfffHMo+MbFxbkfAJ+W+YknnshWkjC9jz76yB0fB5Ik1Pwfe+yx0DAFfV2U68fz999/dxfSSozqBy5cTo4d5A1iX3TGPj2AUFLM9/3336dJEupC8OOPP07zHSXm9aBDFJeGDBmy3372f4cyShJmFGcyo+9NmDAhTRJQiT+f/8AmO3EyUpJQcbZr165p5qkLde0PP8al/10kliArxL7ojH2RkoSZXf+kv/m88cYbvdtuuy3NZ7qJfvDBB0PT14Px9Nf4SvIpSaiHmCNHjnQ3zeGyShLKRRdd5OKRP13dYOshBxBNiH3RG/t0XxtOhVXefPPNiPetWeUnFLM0XPfHPt2bnXLKKRkun2KWHq5kd3lymyRUgZZy5cq55KZcd9113k033ZThtkHeoLpxLixbtsxKlizpiuqmpyqmpUqVckVjfQ0bNgw1YKzqqKqWqupdqlrlVz/1GyV99dVXbdeuXa56qqqGhVclTS81NdUVFVZVB01LVRtURDevGzjVsodXk1X1Zq2/PtdL70uUKBFxfVVlTVWyfcWLF3fFmH2PP/64q6Kh4teah6qCab1yWuxafvzxRzcdbXttj3vuuSfNtlA1NVVDkXfffddVn/P3oYpMa3xtQ/+lhvpXrFgR+n76/Z3Z/LTeOg7C25EI/77mp/VU1UB/fqriHB8fn2XnMareomqBKqqu740fP36/fa5i4j4VM9+6dWvovZa1TJkyGQ7PjIrZq7q8X8Vd1d0P9HhLf3zp2NL09bmK8r/++uvuPNB2VrF5vwOFnBw7yBvEvuiMfennFf5vP97oXA2Pb6riG96wfvh3dK5pPcPjXySZxZnMhP8+Khalf68qxrmNk/qOYmL4uqqq9apVqzKM5cQSZIXYF52x70DjkuKFOj8Jjxf/+9//Qs0tRJqeaJr6t5ZP46t6oZpiyUmTP6oq+MYbb7jqfPqr65vweQHRgNgXvbEv/bWe3md035pVfkI0XM26RJqemhm79NJLXazT/Z+aS1NTN+HxNavlyS1VLT7qqKNcUzrKkaiaseIn8hdJwlzQQa8Tw2+DMJzaRtIBrHr/4Rch+lzU9tqsWbNcPX3V3ffr8/t1/pUU0cWCboDU9tp//vMfN76orZVw77zzjnuNGzfOJQfVfbvaOfCnlVe07OHtDmjZtP76XC8FxfC2qMLXV8FUPzA+jRd+s6ZgpG7PNY4Coi7WPvroo4jLoXZiMguYah9P7VCpPTttW7WdFb4tlNxSMNT2VLJQbWH5FPS0b7QN/df27dtde1U+3Zhmd35abx0H4Qk0tecQPj9NT9sufJ76jn5AMqJp9OzZ04YOHWpr16513znjjDPybJ+r/Yfw9jG0DbRuvhtuuMEt36JFi9znb7311gHPO/3xtWfPHrdd/GNI7WfowlvnVLNmzUL7LSfHDvIGsS86Y1/6eYXHGj/ejB07Nk2s0XmuGOYL/75ii9bTj0Xpf3sKSlZxMn1M9r9z3nnnpRlfF7FKHPrSf49YgqwQ+6Iz9uVERvGiT58+aeKFHlKMGDEiW9M85ZRTQg9qL7zwQtceV6Sb/kjzVvteag9s6tSp7mFor169crlmQP4h9kVv7Aufl3/tF34PGR53sspPiIbr+i/S9NQ3ga4b1eaz7v+++eYb93n4PWBWy5MdkWKlXH311TZq1Ci3vXRMqrAM8hdJwlxQFl4JJyVMdPLrgkAdOqjBTZ0MShwpuacEi04QNQivxI7oxFKmXo1+6kJEpc/CKUGoE1g3ZXqiqZMlISEhNN8//vgjNK6mpacZKq2mxMqDDz6Y7ZIcOaESKEqAKSmqZe7bt697CqJgqMaetVz333+/C6ILFixwjZ7666ubUJV8++GHH0LLqO3ie++999w2UpDR+mpdixUrtt8yaDurwVc18poRbQ9NQ0931Sh/+ou80qVL2wUXXOBKXyrJpQs630033eSe8CiBqGVRIFRj1uFPWHIyP114alm1f1V69LfffrOXXnopNFxPi3UxqQb5/USikq9ZJbm0/bV8+qHRsaGLU3WgklcUdGfMmOE6DtCPhZY/PEGgdVYD3XqKpONB2ywvji+VFNQ+0TE0YMAAdx7p2FqyZIl99dVXbhvqWFcS0z8+snvsIO8Q+6Iz9mlejz32WCiZpnmFU3zTcup88s9jlX4J/7148cUX3XCda2pgX0+J/YvH9L89BSWrOKkGtBUHw5dNDxG+/vpr++CDD9wFul4qfayS3xkhliArxL7ojH05oWVWzAu/Cb7++uvttddecw8iU1JS3ProGii8Y6eM6FpdsUjT1PLruiija5BIMVSxS4lBdbyyceNG16ESEG2IfdEb+3Sto4JCetigDtr0PXUoEklW+Qk/JikZqOtAXQ8+//zzdtlll4WuG1XTQ8utfMegQYMOaHlyEqdFndvpHl3XupQiLBgkCXNJT/2UCFLvtjphlDD0e7ZV6T79W5luneA6QfweZJVgU1DQSaCis23btk0zXSWmVFpKyRAlIpWEad68uRumXtNuvfVWl2DUSaITWz2xaT4qMqwkWPgTgbyigKGenLSsKh6tmy6VIPOLUn/22WfuxNUNnZ56aB1VJFkUWLXc3bp1c0WulVDVevv0Pb/XTE1fTwoiPTnRPNTjkZ8wjUQ3uU888YSblvaHeqNLT1WOv/jiC3fjqWSXT71Ia5uqFzttX1VvU+9zmVVfzWp+Og5UylD7WsOUDFORdZ+eiPjV53Rx2a5du1Cp0Yyo5zslOdVTs3rOUpHrvHrKLpquLpq1T9Q7YNOmTdNsJ/U0rH2h5dXxqf16oLRPbrnlFneBrGNIvX3rCZt+OPUje99997ltqPXVD5C2W06OHeQtYl/0xT4l1vVbpOnr9yJ9D+VKsqknvPPPP9+du6q6ofgUThddusDVuabqIX5PwZF+ewpSZnFSv3nqfU/bR+NonXQhrBiv+KztrvVRkjS8RHR6xBJkB7Ev+mJfTqhnYs1L11GKF6rRo97U1fyMYqgeOih+6JpDCYCsaL10nah7AdXi0Q21qsNFKgmjRKCu7zXf8GSgkoQ///yzuz7UdgWiEbEvOmOf5qtknN+sih7+6jotI5nlJ0T3e7qGVE5BD4p1f+YnEZUUVJNTmr6+q+U70OXJbpz2l02Fe1SIxU9cIn/FqWHCfJ4HcMCUxFOwCi/9F2sGDx7sklwqGQcA0RL79PBn+PDh+yUXAaCwFIXrvqyo1opqhnz//fdpkgkAgis7sU8PfpVE07VbUKhkph6q6GEM8h8lCRETVHrk9NNPt1iidhv0xEN5eD09UpH0onyxCyDvxWLsA4ADVdRjn64NdV2o0owkCAEEJfblhjpOUSnF3r17F/aiBAZJwgBQuwMq2hzpFV6lLJqpOHR4tddYCWgqjq02C1X0XFWZVYQ6K9onGe2v9B0SRCu1YZnROgAFhdhX8Dj3gcJH7Ituav9QzSeo4wJVWQaQN4h9RY/aTlSNF1WPVmdRKBhUNwYAAAAAAAACjpKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCXPRG9mWLVvcXwAICmIfgCAi9gEIImIfEFwkCXNo69atlpiY6P4CQFAQ+wAEEbEPQBAR+4DgIkkIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIuKhOEj7//PPWoEEDK1WqlLVp08ZmzpyZ6fhjx461Jk2auPGbNm1q48ePz3DcG264weLi4mz48OH5sOQAkHvEPgBBROwDEETEPgDRJGqThGPGjLG+ffvawIEDbfbs2dasWTPr3LmzrV27NuL406dPt+7du9vVV19tc+bMsa5du7rXggUL9hv3o48+su+//95q165dAGsCANlH7AMQRMQ+AEFE7AMQdbwo1bp1a++mm24KvU9JSfFq167tDR48OOL4F110kXfmmWem+axNmzbe9ddfn+azf/75x6tTp463YMEC76CDDvKGDRuWo+VKSkrytNn0FwDyGrEPQBAR+wAEEbEPQLSJypKEe/bssVmzZlmnTp1Cn8XHx7v3M2bMiPgdfR4+vqjkYfj4qampdsUVV9gdd9xhRx55ZLaWZffu3bZly5Y0LwDID8Q+AEFE7AMQRMQ+ANGomEWh9evXW0pKitWoUSPN53r/yy+/RPzO6tWrI46vz31DhgyxYsWK2a233prtZRk8eLANGjRov883bNjgAjuAoqFq1aqFvQjEPgAFjtiXFtd9QDAQ+9Ii9gHBUDUb97xRmSTMDyqZ+PTTT7v2DdVhSXb179/ftY3oU0nCevXqWZUqVaxChQr5tLQAkDeIfQCCiNgHIIiIfQAOVHy0ZjcTEhJszZo1aT7X+5o1a0b8jj7PbPxp06a5Tk/q16/vShPqtWzZMuvXr5/rQTkjJUuWdMnA8BcA5AdiH4AgIvYBCCJiH4BoFJVJwhIlSljLli1t0qRJadoT1Pu2bdtG/I4+Dx9fvvrqq9D4aovw559/trlz54Ze6t1Y7RN+8cUX+bxGAJA1Yh+AICL2AQgiYh+AaBS11Y1Vxbdnz57WqlUra926tQ0fPty2b99uvXr1csN79OhhderUce0nSJ8+fax9+/b25JNP2plnnmmjR4+2n376yV566SU3XNWD9QpXvHhxV9KwcePGhbCGALA/Yh+AICL2AQgiYh+AaBO1ScKLL77Y1q1bZ/fff7/rfKR58+Y2YcKEUOcky5cvdz0e+44//nh75513bMCAAXbPPfdYo0aN7OOPP7ajjjqqENcCAHKG2AcgiIh9AIKI2Acg2sR5nucV9kLEEnVckpiYaElJSbRPCCAwiH0AgojYByCIiH1AcEVlm4QAAAAAAAAACg5JQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMBFdZLw+eeftwYNGlipUqWsTZs2NnPmzEzHHzt2rDVp0sSN37RpUxs/fnxoWHJyst11113u87Jly1rt2rWtR48etnLlygJYEwDIPmIfgCAi9gEIImIfgGgStUnCMWPGWN++fW3gwIE2e/Zsa9asmXXu3NnWrl0bcfzp06db9+7d7eqrr7Y5c+ZY165d3WvBggVu+I4dO9x07rvvPvf3ww8/tCVLltg555xTwGsGABkj9gEIImIfgCAi9gGINnGe53kWhVRy8Nhjj7XnnnvOvU9NTbV69erZLbfcYnffffd+41988cW2fft2++yzz0KfHXfccda8eXMbOXJkxHn8+OOP1rp1a1u2bJnVr18/W8u1ZcsWS0xMtKSkJKtQoUKu1w8AIiH2AQgiYh+AICL2AYg2UVmScM+ePTZr1izr1KlT6LP4+Hj3fsaMGRG/o8/DxxeVPMxofFGiLy4uzipWrJiHSw8AuUPsAxBExD4AQUTsAxCNilkUWr9+vaWkpFiNGjXSfK73v/zyS8TvrF69OuL4+jySXbt2uTYKVUU5sxKBu3fvdq/wkoQAkB+IfQCCiNgHIIiIfQCiUVQmCfObOjG56KKLTDWtR4wYkem4gwcPtkGDBu33+YYNG9zTHwBFQ9WqVa2oI/YBSI/YlxbXfUAwEPvSIvYBwVA1G/e8xaJ1wRMSEmzNmjVpPtf7mjVrRvyOPs/O+P5Nstoh/Prrr7NsV7B///6uA5XwkoRqG7FKlSq0SQggTxH7AAQRsQ9AEBH7AESjqGyTsESJEtayZUubNGlS6DN1XKL3bdu2jfgdfR4+vnz11VdpxvcThL/99ptNnDjRJfqyUrJkSZcMDH8BQH4g9gEIImIfgCAi9gGIRlFZklBUeq9nz57WqlUr1wPx8OHDXe/FvXr1csN79OhhderUcUWjpU+fPta+fXt78skn7cwzz7TRo0fbTz/9ZC+99FIoQXjBBRfY7NmzXQ/IavPQb6+wcuXKLkgDQGEj9gEIImIfgCAi9gGIOl4Ue/bZZ7369et7JUqU8Fq3bu19//33oWHt27f3evbsmWb89957zzvssMPc+EceeaQ3bty40LC//vrL0+pGek2ePDnby5SUlOS+o78AkB+IfQCCiNgHIIiIfQCiSZz+V9iJyliiNgkTExMtKSmJqscAAoPYByCIiH0AgojYBwRXVLZJCAAAAAAAAKDgkCQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOCiOkn4/PPPW4MGDaxUqVLWpk0bmzlzZqbjjx071po0aeLGb9q0qY0fPz7NcM/z7P7777datWpZ6dKlrVOnTvbbb7/l2/KPGzfOrr/+evcXALKL2AcgiIh9AIKI2AcgmkRtknDMmDHWt29fGzhwoM2ePduaNWtmnTt3trVr10Ycf/r06da9e3e7+uqrbc6cOda1a1f3WrBgQWicoUOH2jPPPGMjR460H374wcqWLeumuWvXrjxffiUGP/nkE/dv/SVRGFtW/P29vfHxdfbkuxe5v3of7WJxmfNLLG8LYh8KUyyeO7G4zPkllrcFsQ+FKRbPnVhc5vwSy9uC2IfCFIvnTiwuc6xtizhPxeuikEoOHnvssfbcc8+596mpqVavXj275ZZb7O67795v/Isvvti2b99un332Weiz4447zpo3b+6SglrN2rVrW79+/ew///mPG56UlGQ1atSwUaNG2SWXXJKt5dqyZYslJia671aoUCHLBGG4c845x84888xsbwMUjomTH7GX/p5ucSp9qpPk37/X1z/BTulwT1Tullhc5vwS69uC2IfCEovnTiwuc36J9W1B7ENhicVzJxaXOb/E+rYg9qGwxOK5E4vLHIvbIipLEu7Zs8dmzZrlqgP74uPj3fsZM2ZE/I4+Dx9fVErQH/+vv/6y1atXpxlHyT4F5oymmRsZJQiFEoXRT9l3nWxeXJylxsX9/18ze3H5d7by78yrvBeGWFzm/BLr24LYh8ISi+dOLC5zfon1bUHsQ2GJxXMnFpc5v8T6tiD2obDE4rkTi8scq9uimEWh9evXW0pKiivlF07vf/nll4jfUQIw0vj63B/uf5bROJHs3r3bvcJLEuYmQejzh1OiMDpNmvVqKAufhk46z7PbJg+yhP2HFqoU2xcQLIaWuTC2RZzn2cRZ/7Ue9VpbtCL2obAQ+2IbsW8frvuQU8S+2Ebs24fYh5wi9sW2lHy+543KJGE0GTx4sA0aNGi/zzds2OCe/oTLKkEYPp5KMCL6rNm+ISDptODx/t2/SsRFUrVq1QJfpmhG7AsWYl/RRezLGWJfsBD7ii5iX84Q+4KF2Fd0eXlwzxuVSUIteEJCgq1ZsybN53pfs2bNiN/R55mN7//VZ+rdOHwctVuYkf79+7sOVMJLEqptxCpVquzXJqHaHMxOolDjkZCITjXKVrG4LSsiJgpVN//MCnWsR9eXLJqokdJxW1ZYagwtc2Fsi7h/9280n3vEPhQWYl9sI/btw3UfcorYF9uIffsQ+5BTxL7Y9kY+3/NGZZuEJUqUsJYtW9qkSZNCn6njEr1v27ZtxO/o8/Dx5auvvgqNf/DBB7tEYfg4Svipl+OMpiklS5Z0ycDwV0ZUhVgJwMzQeUl0O6XlVfsShOn78/E893mnltdYtInFZc4vsb4tiH0oLLF47sTiMueXWN8WxD4Ullg8d2JxmfNLrG8LYh8KSyyeO7G4zLG6LaIySSgqvffyyy/b66+/bosXL7bevXu73ot79erlhvfo0cOV8vP16dPHJkyYYE8++aRrt/CBBx6wn376yW6++WY3PC4uzm677TZ7+OGHXWm/+fPnu2mox+OuXbvm2XJnligkQRj96tQ7zvUIpAx8vOe5Ov3u7789BdWOwvbsYnGZ80tR2BbEPhSGWDx3YnGZ80tR2BbEPhSGWDx3YnGZ80tR2BbEPhSGWDx3YnGZY3VbxHnq2SBKPffcc/b444+7jkVUJfiZZ54JteXXoUMHa9CggY0aNSo0/tixY23AgAG2dOlSa9SokQ0dOtTOOOOM0HCt6sCBA+2ll16yzZs324knnmgvvPCCHXbYYdleJpU+VK/ISUlJmZYqTN+JCQnC2KIegdTg57qdm61a6YouGx/tgScWlzm/xPq2IPahsMTiuROLy5xfYn1bEPtQWGLx3InFZc4vsb4tiH0oLLF47sTiMsfatojqJGE0ym6SMDxRSIIQQKwj9gEIImIfgCAi9gHBRZIwHwMmABQVxD4AQUTsAxBExD4guKK2TUIAAAAAAAAABYMkIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOCiMkm4ceNGu+yyy6xChQpWsWJFu/rqq23btm2ZfmfXrl120003WZUqVaxcuXLWrVs3W7NmTWj4vHnzrHv37lavXj0rXbq0HX744fb0008XwNoAQPYQ+wAEEbEPQBAR+wBEo6hMEipBuHDhQvvqq6/ss88+s2+++cauu+66TL9z++2326effmpjx461qVOn2sqVK+38888PDZ81a5ZVr17d3nrrLTfte++91/r372/PPfdcAawRAGSN2AcgiIh9AIKI2AcgKnlRZtGiRZ4W68cffwx99vnnn3txcXHeihUrIn5n8+bNXvHixb2xY8eGPlu8eLGbzowZMzKc14033uh17NgxR8uXlJTkpqu/AJBXiH0AgojYByCIiH0AolXUlSScMWOGq2LcqlWr0GedOnWy+Ph4++GHHyJ+R6UEk5OT3Xi+Jk2aWP369d30MpKUlGSVK1fO4zUAgJwj9gEIImIfgCAi9gGIVsUsyqxevdpVCw5XrFgxl8zTsIy+U6JECZdcDFejRo0MvzN9+nQbM2aMjRs3LtPl2b17t3v5tmzZkoO1AYDsIfYBCCJiH4AgIvYBsKAnCe+++24bMmRIpuMsXry4QJZlwYIFdu6559rAgQPttNNOy3TcwYMH26BBg/b7fMOGDbZnz558XEoABalq1ar5Ml1iH4BoRuxLi+s+IBiIfWkR+4BgqJqNe94CSxL269fPrrzyykzHadiwodWsWdPWrl2b5vO9e/e63p80LBJ9roTd5s2b05QmVO/G6b+zaNEiO+WUU1xHKAMGDMhyudW5Sd++fdOUJFQPyepFWb0vA0BmiH0AgojYByCIiH0AYl2BJQmrVavmXllp27atS/apncGWLVu6z77++mtLTU21Nm3aRPyOxitevLhNmjTJunXr5j5bsmSJLV++3E3Pp16NTz75ZOvZs6c98sgj2VrukiVLuhcA5AaxD0AQEfsABBGxD0Csi1PvJRZlunTp4koBjhw50nVI0qtXL9eRyTvvvOOGr1ixwpUGfOONN6x169bus969e9v48eNt1KhRroTfLbfcEmp70K9irARh586d7fHHHw/NKyEhIVvJy/CShImJia7TE0oSAshLxD4AQUTsAxBExD4AUcmLQhs2bPC6d+/ulStXzqtQoYLXq1cvb+vWraHhf/31lxKb3uTJk0Of7dy507vxxhu9SpUqeWXKlPHOO+88b9WqVaHhAwcOdN9J/zrooINytGxJSUnue/oLAHmJ2AcgiIh9AIKI2AcgGkVlScJoRklCAEFE7AMQRMQ+AEFE7AOCK76wFwAAAAAAAABA4SJJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDARWWScOPGjXbZZZdZhQoVrGLFinb11Vfbtm3bMv3Orl277KabbrIqVapYuXLlrFu3brZmzZqI427YsMHq1q1rcXFxtnnz5nxaCwDIGWIfgCAi9gEIImIfgGgUlUlCJQgXLlxoX331lX322Wf2zTff2HXXXZfpd26//Xb79NNPbezYsTZ16lRbuXKlnX/++RHHVdLx6KOPzqelB4DcIfYBCCJiH4AgIvYBiEpelFm0aJGnxfrxxx9Dn33++edeXFyct2LFiojf2bx5s1e8eHFv7Nixoc8WL17spjNjxow0477wwgte+/btvUmTJrnhmzZtytHyJSUlue/pLwDkFWIfgCAi9gEIImIfgGgVdSUJZ8yY4aoYt2rVKvRZp06dLD4+3n744YeI35k1a5YlJye78XxNmjSx+vXru+n5Fi1aZA8++KC98cYbbnoAEC2IfQCCiNgHIIiIfQCiVTGLMqtXr7bq1aun+axYsWJWuXJlNyyj75QoUcIlF8PVqFEj9J3du3db9+7d7fHHH3fJwz///DNby6Pv6eXbsmVLLtYKADJH7AMQRMQ+AEFE7ANgQU8S3n333TZkyJBMx1m8eHG+zb9///52+OGH2+WXX56j7w0ePNgGDRoUsfOTPXv25OESAihMVatWzZfpEvsARDNiX1pc9wHBQOxLi9gHBEPVbNzzFliSsF+/fnbllVdmOk7Dhg2tZs2atnbt2jSf79271/X+pGGR6HMl7NRTcXhpQvVu7H/n66+/tvnz59v777/v3nueF9pI9957b8REoJ9c7Nu3b5qShPXq1XO9KKv3ZQAg9gEA130AwD0vgFhXYEnCatWquVdW2rZt65J9amewZcuWoQRfamqqtWnTJuJ3NF7x4sVt0qRJ1q1bN/fZkiVLbPny5W568sEHH9jOnTtD3/nxxx/tqquusmnTptkhhxyS4fKULFnSvQAgN4h9AIKI2AcgiIh9AGJdnHovsSjTpUsXVwpw5MiRrkOSXr16uY5M3nnnHTd8xYoVdsopp7gOSFq3bu0+6927t40fP95GjRrlSvjdcsst7vPp06dHnMeUKVOsY8eOtmnTpv3aMsyMShImJiZaUlISJQkB5CliH4AgIvYBCCJiH4BoFHUdl8jbb79tN998s0sEqhdilQ585plnQsOVOFRJwR07doQ+GzZsWGhcdTTSuXNne+GFFwppDQAg54h9AIKI2AcgiIh9AKJRVJYkjGaUJAQQRMQ+AEFE7AMQRMQ+ILjiC3sBAAAAAAAAABQukoQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABR5IQAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kIQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIuGKFvQCxxvM893fLli2FvSgA8lj58uUtLi6O7RoBsQ8ouoh9GSP2AUUXsS9jxD4guLGPJGEObdiwwf2tV6/ege0ZAFEnKSnJKlSoUNiLEZWIfUDRRezLGLEPKLqIfRkj9gHBjX0kCXOocuXK7u/y5cstMTHRihqVkFQC9O+//y6SyRLWL3YVxL7TUxVERuyLbcS+2Jbf+4/YlzFiX2wj9sU2Yl/hIfbFNmJfbNtSyNd9JAlzKD5+XzOOShAWxSSaT+vG+sWuorz/ivK6RTNiX9FQ1M8f1g95jdhXNBAbYltR33/RiNhXNBT1c4f1yx90XAIAAAAAAAAEHElCAAAAAAAAIOBIEuZQyZIlbeDAge5vUcT6xbaivP+K8rrFgqK+/Vm/2Mb+A8cW5w6xoegp6rE9mhX1bc/6xTb2X/6K8/z+zQEAAAAAAAAEEiUJAQAAAAAAgIAjSQgAAAAAAAAEHElCAAAAAAAAIOBIEgIAAAAAAAABF8gk4TfffGNnn3221a5d2+Li4uzjjz9OM3zNmjV25ZVXuuFlypSx008/3X777bfQ8KVLl7rvRXqNHTs2NF6k4aNHj87XdRs8eLAde+yxVr58eatevbp17drVlixZkmacXbt22U033WRVqlSxcuXKWbdu3dw6h1u+fLmdeeaZbv01nTvuuMP27t2bZpwpU6bYMccc43oXOvTQQ23UqFH5um55tX7z5s2z7t27W7169ax06dJ2+OGH29NPP73fukXaf6tXr4769cvusRer+0/LmdH5t3bt2kLdf9GO2EfsI/YR+4KI2EfsI/YR+4KI2EfsI/YR+3LFC6Dx48d79957r/fhhx+qZ2fvo48+Cg1LTU31jjvuOK9du3bezJkzvV9++cW77rrrvPr163vbtm1z4+zdu9dbtWpVmtegQYO8cuXKeVu3bg1NS9N+7bXX0oy3c+fOfF23zp07u3kuWLDAmzt3rnfGGWekWXa54YYbvHr16nmTJk3yfvrpJ7e+xx9/fGi41u+oo47yOnXq5M2ZM8dtr6pVq3r9+/cPjfPnn396ZcqU8fr27estWrTIe/bZZ72EhARvwoQJUb9+r7zyinfrrbd6U6ZM8f744w/vzTff9EqXLu3WwTd58mS3/5YsWZJm/6WkpET9+mXn2Ivl/bdjx479zj9Nt3379oW+/6IdsY/YR+wj9gURsY/YR+wj9gURsY/YR+wj9uVGIJOE4dInCZVU0GdKYviUWKhWrZr38ssvZzid5s2be1dddVWm0y4Ma9eudcsxdepU937z5s1e8eLFvbFjx4bGWbx4sRtnxowZoR+U+Ph4b/Xq1aFxRowY4VWoUMHbvXu3e3/nnXd6Rx55ZJp5XXzxxS5ZE+3rF8mNN97odezYcb8k06ZNm7zClNv1y+rYK0r7T9PQd954442o23/RjNhH7BNiH7EvaIh9xD4h9hH7gobYR+wTYh+xLzsCWd04M7t373Z/S5UqFfosPj7eVcn89ttvI35n1qxZNnfuXLv66qv3G6Zqk1WrVrXWrVvbq6++qqSsFaSkpCT3t3LlyqFlTU5Otk6dOoXGadKkidWvX99mzJjh3utv06ZNrUaNGqFxOnfubFu2bLGFCxeGxgmfhj+OP41oXr+MpuNPI1zz5s2tVq1aduqpp9p3331nBe1A1i+zY68o7b833njDVYu/4IILom7/xRJiH7Evms4dYh+xr6AQ+4h94Yh9+YvrvuhB7CP2hSP25a+kGLvnLXbAUyhi/J3Tv39/e/HFF61s2bI2bNgw++eff2zVqlURv/PKK6+4du2OP/74NJ8/+OCDdvLJJ7ud+eWXX9qNN95o27Zts1tvvbVA1iU1NdVuu+02O+GEE+yoo45yn6lNthIlSljFihXTjKuEoN9em/6GJwj94f6wzMZRInHnzp2urb9oXb/0pk+fbmPGjLFx48aFPtNJNnLkSGvVqpX7Ef3vf/9rHTp0sB9++MG141cQDmT9sjr2itL+0/l36aWXplnmaNh/sYbYR+yLlnOH2Pf/iH35j9hH7BNiH9d9QUPsI/YJsY/YFwlJwnSKFy9uH374oSsVqExvQkKCy/B26dIlYilAJVTeeecdu++++/YbFv5ZixYtbPv27fb4448XWJJQJckWLFiQYQnIWJcX66fvn3vuuTZw4EA77bTTQp83btzYvXxKAP/xxx8uYfzmm29atK9fYR97BbX/9KRl8eLF++2TaNh/sYbYFzuIfRkj9hH7corYFzuIfRkj9hH7corYFzuIfRkj9jXOl3teqhtH0LJlS1d9ePPmza704IQJE2zDhg3WsGHD/cZ9//33bceOHdajR48sN3abNm1ciUS/eHd+uvnmm+2zzz6zyZMnW926dUOf16xZ0/bs2ePWLZx6j9Uwf5z0veX677Map0KFCgVSCu1A1s+3aNEiO+WUU+y6666zAQMGZDlPVdv9/fffrSDkxfplduwVhf0nKuWk4tU6Z6Np/8UqYh+xLxJiX94h9kUnYh+xLxJiX94h9kUnYh+xLxJiX96J2djnBVx2Ohf59ddfXUceX3zxxX7D1KNqt27dsjWvhx9+2KtUqZKXn9Q780033eTVrl3bLXd6fscQ77//fugz9eAcqeOSNWvWhMZ58cUXXcclu3btCnV8oR6Qw3Xv3j3fO77Ii/UTdUxTvXp174477sj2vNXb83nnnefFwvpldezF+v4T9SSuHsXDe6Uu7P0XS4h9xL7sIvYdOGJf9CD2Efuyi9h34Ih90YPYR+zLLmLfgYv12BfIJKE29Jw5c9xLO+Kpp55y/162bJkb/t5777neUf/44w/v448/9g466CDv/PPP3286v/32mxcXF+d9/vnn+w375JNPXG/I8+fPd+O98MILXpkyZbz7778/X9etd+/eXmJiojdlyhRv1apVodeOHTtC49xwww1e/fr1va+//tr76aefvLZt27qXb+/evS6BdNppp3lz5871JkyY4Hp37t+/f2icP//tTlxJNvU++/zzz3sJCQlu3GhfP+0Trc/ll1+eZhrqJdc3bNgwt++17zR+nz59XOJ04sSJUb9+2Tn2Ynn/+f773/96pUqVitiDcWHtv2hH7CP2EfuIfUFE7CP2EfuIfUFE7CP2EfuIfbkRyCShEoBKDqZ/9ezZ0w1/+umnvbp167rsrpIVAwYM8Hbv3r3fdJQ0q1evnpeSkrLfMCUOmzdv7rK+ZcuW9Zo1a+aNHDky4rh5KdJ66fXaa6+Fxtm5c6fr/lwly5QoUqZZiZpwS5cu9bp06eKVLl3aq1q1qtevXz8vOTl5v+2odSxRooTXsGHDNPOI5vUbOHBgxGkoGewbMmSId8ghh7gkVOXKlb0OHTq4pFUsrF92j71Y3X8+JQ4vvfTSiPMprP0X7Yh9xD5iH7EviIh9xD5iH7EviIh9xD5iH7EvN+L0vwOrsAwAAAAAAAAgltFxCQAAAAAAABBwJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFHkhAAAAAAAAAIOJKEAAAAAAAAQMCRJAQAAAAAAAACjiQhAAAAAAAAEHAkCQEAAAAAAICAI0kIAAAAAAAABBxJQgAAAAAAACDgSBICAAAAAAAAAUeSEAAAAAAAAAg4koQAAAAAAABAwJEkBAAAAAAAAAKOJCEAAAAAAAAQcCQJo8gDDzxgXbt2LezFQIxZunSpxcXF2ebNmzMdb9SoUda8efMCWy6gqMe+cuXK2fz58y3a3HDDDXbXXXcV9mIAKKKxL69deeWVdtttt+X6+7oGmjt3bsRhy5cvd7E6KSlpv3mlHwagYBT12NelSxd74YUXcv193a/pvi1WaF9qn6LoIEmIbHn77bft3HPPZWsBCJTMYt+2bdusadOmBXITnBMjR460IUOG5OghAgAUxeu++vXru1idmJiY5bCCjNMAim7s+/zzz+3GG2/Ms2UCChpJQmTLp59+auecc06hbq3k5ORCnT+A4ImG2AcAsRr7uHYDEEu47gNIEubali1b7Oabb7aDDjrIKlSoYMcee6z9/fff9vTTT1uHDh3SjDt69Gg74ogjQu/fffdda9asmfuevp9RceLff//dOnfubJUrV7ZDDjnEhg8fvl/V0YceesiqV69uNWrUSDPcn+/RRx9tFStWdMs3ffr0NE9JGjVqZOXLl7c6deq46WR2gffll1/aWWedFXH4nXfe6dZD09J6jh07NjRM6/nGG2/sVwR78ODB7t96gqvtqKe5Wo8ePXqEqn34JWBee+01O/TQQ61u3bpZzk/ef/99N76eDF977bVuucOLQM+ePds6duzotqvGe/nlly0rWk49VdIyaronnXSSzZs3LzRc0z/77LPdumh7a33GjBkTGq6n01qWSy65xC1348aNbcqUKaHhDRo0sI8//jj0Xv/WZ76nnnoqtL90LDz33HN2oNasWWMXXXSRVatWzS3vvffea3v37nXDNm7caOedd55VqlTJrU/Lli1t2bJlOT52UPQQ+yJXccssBjzzzDPuvFHVE1VtO/LII0Ox9f7773fndJUqVdwN+cqVK9NMX6UCjzrqKPd7oeF+fNy9e7ddddVVVrVqVReTNM6PP/64X2mY1q1bu7+Kn5q3lqNFixb7/e6cfvrpodKHAIh9mV33KTbpelfXMop3F198cZbXbpqeYo/i1THHHGMTJ07c77dFVdYUp3Tt+u2334aGvfXWWy7G6bpDsfW+++4zz/PSfH/q1KmZLk+k0tThwyLF6f/973/WsGHDNPP6/vvv3fXjrl27OE0QCFz37aNrJN3H+XRvdNxxx4Xed+vWzZ588kn3b+UC/Pty3e8pLv33v/+1evXques93cuG032dP0z3Y9mR1XWghmUUU7O6/ly7dq1ddtllVqtWLatdu7a7ptT8fB988EGae23//jErirdaV92/ly1b1q644grbtGmTi9m6ztVvxC+//BIaX/fCjzzyiPvN0HDlRfzlVFxW0zo1a9Z0ww477DD77LPPsrUcyAYPuXLeeed5nTt39lasWOGlpKR4s2fP9tatW+etX7/eK1WqlPfnn3+Gxj3ttNO8oUOHun9/8sknXuXKlb1Jkya5761Zs8Z9VwYOHOide+657t/Jycle48aNvTvuuMPbuXOnN2/ePK9WrVre22+/7Ya/9tprXrFixbwnnnjC27Nnjzd58mT3/vfff3fDx40b59WpU8ebNWuWm88HH3zg5qvl27Ztmxt36tSpbtxNmzZ5M2fOzHBdJ06c6B133HEZDn/rrbfceuzdu9d79913vZIlS4bW//HHH/c6deoUGnfVqlVe8eLFveXLl7v3F154ode9e3e3DFquSy65xLv88svdsL/++ktXZV7Xrl3d8O3bt2c5vyVLlrjt//nnn7tt+NJLL7l11bb156/tMGbMGPf9+fPnu+2qdcxMUlKSN3r0aLeM2h+33nqrd9hhh3mpqamhfaf18qf7+uuve+XKlfO2bNnihvfs2dMrX768208a/tBDD3kHHXRQaPr690cffRR6r3+HD3///ffdNtP8vv76a7eO3377bZrtpG2UGR0zzZo1C70/+eSTvUsvvdTbunWrt3TpUu+II47wHnnkETesf//+3llnneW2uZZ3zpw53oYNG3J87KDoIfb9P513OjeyGwP69OmTZlsqvus8XLlypbd7926vX79+Xrt27dJMv2PHji7e6Vxr0aJFKJa9+OKL3jHHHOM+V1xQ7PPjavi8IsWHZ5991mvfvn3o/T///OOVKFHCLQcAYl9W132KKS1btnTXwIotp556qnfllVdmeO3222+/uesWXYvq2mzs2LFe6dKlQ9duilm6ltM1soaPGDHCq1SpUihujR8/3sU4xTrF3OrVq7trwZwsjz+tzOJj+jitZalRo4a7dvNdd9113o033shpgsDgum+fH374wcUD2bhxo/u37il1nafYpH/79/S6xho2bJj7t+JHfHy8d/vtt7t7yEWLFnllypQJxRXlBCpUqOBNnz7dXQvec889XkJCgrtvy0xW14GZxdTMrj81rTZt2nh9+/Z18Vu5gw4dOngDBgxwwzUfXTOGT1vL61+fZkbxVnkB3VMqXiuWN23a1Js2bZqbluL22WefHRpf98INGjTwFi9e7JalR48e7rpYvvjiC69u3bpuOrJs2TK3bMgbJAlzYfXq1e4g18EYyUUXXRQ6UXTzpZNUySk5/fTTvUGDBkX8XniSUAkgBQyduD4lcHThIwocNWvWTPP9Qw891CWT5IwzzvCGDx+eZvjxxx/vvfHGGy7Ro4uzkSNHuuRXVnTB5CePskOJKP/iTcFHN87aDvLUU0+5oCRr1651QVOB1vfrr7+68XWT7V+8+Tfh2Znfgw8+6J155plphiv55e8PJWt14RpOwfiqq67yckJBVsvmr5emr4DqU4BVAP3pp59Cwfriiy8ODdf39H0F3uwkCdPTcfLwww/nOknoz1/Hsk8J6EaNGrl/33///V7btm29uXPnpplGTo8dFC3EvsyThFnFgPCbTw0vW7ZsmnNMF4+Kif5FnqavBx4+nfNK3surr77qzlddVOpBULiskoSKueE36I8++uh+cRMAsS8jiil6IOL7/vvvXbxTLIp07abYpevfcLqe9a8tFbO6dOmSZniTJk28N998M+L8Fd+uueaaHC1PbpKEcuedd7rP/RidmJjo/fjjj5weCASu+/6f7k11b75w4ULvww8/dAVddE2mgjlKDipJ6BceSZ8kjIuLCxV2ESXKVNBHdA/au3fv0DAV/tF8skoSZnUdmFFMzer6U4U/tC7h0/zyyy+9hg0bhu61I007u0nCCRMmhN5rG6qAkM8v5OTTvfCQIUP2Ox7//vtvV2imatWqbtm0zZC3aJMwF1TtsmTJkq7KQyQq3qsqtjoX9Pe0005zRWH976qqZlb++ecfV7y3RIkSoc9U5UGf+1TFOJyK7W7dujVUheKee+5xxZv9l6rFrVixwo2n9hZUjUJFm0888USbPHlyrttmGDZsmKuWoSLHms+CBQts/fr1bpiKKZ988smuCodoe6hKsb+MqampdvDBB4eWUdWi4+PjbfXq1aHpp9/Omc1PRZC1TuHCv695jh8/Ps12URWTVatWWWZ27tzpGqBVsWcVafarAvvzFX8f+8WpS5cuHdof6YdrH0j48Mxo+6motaq4aJm1DuHzzikdR6VKlUpzDIUfX3fccYe1a9fOVUfWcvfp08dtg5weOyhaiH2ZyyoGhNP5u337dtd0gR+L9H3FfDVdEWma4TFeVTRUnUQ9Gauqif6d3ZigZgTUfMLrr7/u3uuvfrcAEPuy2yaXmn0J//eePXts3bp1Ea+9dG0R3oRKpGva8On573XNKl988YUdf/zxoWp1aoYhfbzLanlyS7FRVevU7MxHH33k1qtVq1YHPF0gFnDd9/8SEhLcvZHue77++mvXdNUpp5wSeq8qxrr2i0T3jmXKlIl4Pad71/D4Vbx4cXf/nJWsrgMziqlZXX/qXllNMPj3nHpdcMEFrpmqSMsbaV6ZCb/31DZJ/16xNqNpa1zlYLQe2v6DBg1yzU9o/VXd+6+//sr2ciBzJAlzQQer6uWH38iFO/XUU13dfLWPopuvXr16pfmu2hrMitpw0UkY3uCzTlq/bZesKIGjdhF0kvsvBYS7777bDVdQ8xNNF154oWuzQAm79BYuXOiSnWrnIBK1b6C2uJT8U5sCmo/GDW+/RUHszTffdMm8X3/91Z3E/jIqIaj1DF9OtfOitu58Gie781NiNf1+Wb58eZrtorb2wuenIK1tkRlty1mzZrn5q20O7QtJ3yZObqm9iB07doTehycttfw9e/a0oUOHujYitMxnnHHGAc1bx5G2sx/w0x9fWh61vbFkyRKbMWOGTZo0ybXTk5NjB0UPsS/3wuOYqA0YXQz98MMPaeKRkvG6Gc5KsWLF3IMgtY26ePFiFyd0sZTVfH1XX321i6Nqq3bDhg2uPUUAkRH79ue3UyyKP7rBVBvHkWKPri3866aMrmnDp+dPU9eCSvadf/75dv3117sbQ7U1qJvi9NdAWS1PdkSKl2rnUO1rq71rteUafk0PFHXEvrSUmPKTgioEo1d40jA3dO8aHr90759V4ZXsXAdmFFOzuv7UvbLa4A8fprjrJ+/SL68/7fwSPi/dBysH4+cJVIBH7cRq/koe3nrrrfm2HEFDkjAXlMVWKQxdpOgkVoJkzpw57kbLbdT4eHcRoUY+1QFEeMPPushRY89KIOp7Otj13fTU2Lzmo0ZFdTIowfbss8+6ZFF23HTTTfb444+7xJYupJSAUiPRemqrxJCehio5pgCjpxv6m9HT5MxuHpUw05MVXYhpfV599VW3rOGUlNMJ/p///Mf9Wwko0VMLJZjU0L//5EMlCLVsuZ2fSr5pPdVAthK1Gq7EZHjCUoFcT4UVhPVSCUu/odfM5quSdyqBoyCpoJyXVEpQHdoocffnn3/a888/Hxqm+WkfKmDr2FKCTut3IBRc9WOmfaLksYKrGob1jy81/Krtpm2s40NPtXSM5OTYQdFD7Duwbadz27+x1bms35B+/fqFHmzoNyS8w6PMKI4pdinO6Ym04lOkc1GxUvP6448/0nyuZL+WRRdYl19+uTvHAWR8/nLdl5auMf2HvLpWVYP+GT2UUKP0arxftRAUsz788EP75ptv0nQCoJg2btw4N1wdyun6+swzz3TXwLo20o2tbgJ1Y/vOO+8c0PJkN06HP1TRw2Its+IlEBTEvrR076R7MCXN9AChadOm7t5a9/VKGOZG9+7dXY0xxTY9FHnwwQfdvdmBXgdmFFOzuv5UrT4lCgcMGODu9xQPdR//+eefh+61VXgkfNrh99p57cUXX3SFVpTEVEclKgGpB0y6d9eDbm0z1dzRNuCeNO+QJMwllRDUCaQqByqGq5NNB69PScKff/55v5svJcXUU62SeKoyoRNx/vz5+01f31GiRkk+JdNU7aNv37526aWXZmv5lNh77LHHXI9DSmypSq+Sk0r66KV/a/m1DEpI6QlppIuprKqcqEdMFUFWkNSTBZU8POGEE9KMo6cVKj2o6iJ+VWOfnsr61YyVcFIxbq1zbuengK1907t3b3dBqVJwCtq6sPSTY1oOBRwV5daPn/aFkoCZ0bZXclLjq+Ri27ZtLS89/PDD7sJWN/Tax+HbST1AqacrrYfWSUE8q2pA2aGLbB2zekqobagfDr+3LZV21bb2e5DW+mqb5uTYQdFE7Muda665xpWCUfUN9TIn6uVd55bObZ1r6ikvuw8AlLDXhaXip+K7zseBAwfuN54unPS5epXXuP7NtarE6HdKT6ApGQNkjdiXlq5vdcOsawjFL10bZES9YCoxqFikGKibYD1wVJVjn659dLPpNwOjhKKuXzVtXWtcd9117jpRDzSVdDyQ5clJnPZvinWTrDia09KJQKwj9v2/5s2bu0SUqhb711Lt27cP3S/lRqdOneyhhx5y98q6N9W9VkY1+HJyHZhRTM3q+lP3u8pBKBYefvjhbrq6R/RrQupeWzUEVWpP96VKbuqeMb+oyQetp+7BtUx+E2a6d9eDbi2DciV6SJSbuI/I4tQwYQbDcABUck8lv1QENjsnejRSWy5NmjRxpftiuZSJgpmeKqsrdwD5i9gXO1TdWBeOP/30U2EvChDzghT7dGOsWjC6YQ6KQw45xN2AhtcOAhCs2Bcr1D6hkoPDhw+3WKa2bLUOKmSFgkXxn3ygvKuqBrdo0SJmg6WozT+dmLEWLFX6UcWjVUVF1UNUvDo/n3AA2IfYFzvUjIEShCohDODAEPuKttGjR1tKSoorSQjg/xH7gKKJxsTymC4ilLlXLztq9y6WHXbYYe4Va1SdWG3rqb1BlSL85JNPXFHkrOjib9q0aft9rirQfjsM0U69PqdvTNavhqPeAIH8QuyLHaomoiYyVMUlu+3cAoiM2Fe0qbqd2hdXlUtVwwOwD7Ev/+la7a233trvczWroCa3os2jjz7qXpGk77UY0Y3qxgAAAAAAAEDAUd0YAAAAAAAACDiShAAAAAAAAEDAkSQEAAAAAAAAAo4kYS56cdqyZYv7CwBBQewDEETEPgBBROwDgoskYQ5t3brVEhMT3V8ACApiH4AgIvYBCCJiHxBcJAkBAAAAAACAgCNJCAAAAAAAAAQcSUIAAAAAAAAg4EgSAgAAAAAAAAFXrLAXAADy2qotK+zr37+yddvXWrWy1e3kQ0+1WhXqsKEBFGnEPgBBROwDEESr8umeN85T/+bIti1btrjejZOSkqxChQpsOSDKTP79Kxsx4xmLi4szhTf/b+/j+1jHQzoV9uLFLGIfEN2IffmD2AdEN2Jf/iD2AcGNfVQ3BlCknqYoWHrmWaqXmubviOlP26otKwt7EQEgzxH7AAQRsQ9AEK3K53tekoQAigwVt9ZTlEj0+de/f1ngywQA+Y3YByCIiH0AgujrfL7nJUkIoMhYvXWVe4oSidpVUHsNAFDULN+8jNgHIHD+3PA7sQ9A4PyTtDxfY19UJwmff/55a9CggZUqVcratGljM2fOzHT8sWPHWpMmTdz4TZs2tfHjx6cZ/sADD7jhZcuWtUqVKlmnTp3shx9+yOe1AFAQdibvsN/WL8lwuJ61qEFXAChKFqz+2eavmpfhcGIfgKJG7W6NX/yJzV9N7AMQLAtX/2w/r5qbr9d9UZskHDNmjPXt29cGDhxos2fPtmbNmlnnzp1t7drIWdHp06db9+7d7eqrr7Y5c+ZY165d3WvBggWhcQ477DB77rnnbP78+fbtt9+6BORpp51m69atK8A1A5DXtu/ZZg9NvM827Fif6QXlyYeexsYHUGR89evn9vDE+yw5dU+G4xD7ABQlO/bssGHThthrP73k2t/KCLEPQFF8OPLgxAG2JyV/r/uitndjlRw89thjXVJPUlNTrV69enbLLbfY3Xffvd/4F198sW3fvt0+++yz0GfHHXecNW/e3EaOHJlpr00TJ060U045JVvLRU9PQHTZsivJHp50v/218Q+rm1jfOh3a2V6f9d99PTz9+zSF3o3zYDvTszsQNVJSU2zUTy/bhCWfWZzF2aUtelpiqcT/7+WO2JdniH1A9Fi26S97cupgW7V1pVUomWi3nvgf27hzg2uon9iXt4h9QPRQUvCl75+3qX9Osri4eLusRQ8XA/Pruq+YRaE9e/bYrFmzrH///qHP4uPjXfXgGTNmRPyOPlfJw3Aqefjxxx9nOI+XXnrJJQlVSjEju3fvdq/wgAkgOmzasdEemjjA/k5abg0qNbQBnR5yN8rH1D3WNdiq9hhU3FpPU2pVqF3YiwsAB2zb7m321DeP2fzVc61ksVLW58Q77Nh6bdywJtWPJPYBKJJ0XfffmSMtOWWPNa52hN1+0p1WpUxVN6xJtSOIfQCKpPXb19kTUx+1Pzb8ZmVLlLXb2t1pzWu3zNfrvqhMEq5fv95SUlKsRo0aaT7X+19++SXid1avXh1xfH0eTiUNL7nkEtuxY4fVqlXLvvrqK6tadd8PTCSDBw+2QYMG7ff5hg0bXKIRQOHQk+OnZw61tTvWWIPEhnZzy36WvC3Z1m9bb8WthHWuf9b/j7xnX1zJTGZxAACiwcotK+yxyQ/aqi0r3MXgXR3vs4MqHRwargvDy465slCXEQDy0u69u+yVmSNt8h8T3fuzjzjfLm3Rw4rF//9tLLEPQFG0aM0C92A4addmq1fxILuzwwCrWb5Wvse+qEwS5qeOHTva3LlzXcLg5Zdftosuush1XlK9euTGHVWaMbyEokoSqtpzlSpVrEKFCgW45AB8a7autuHfDLV1O9bY4dWPtLs7DrQyJcqwgQAUWfNWzrFh0x6z7Xu2W5PqR9h/TrrHEktXLOzFAoB8fTCi6sXLNy+1MsXL2s0n3G7H1juOLQ6gSPM8z774dZyN+vFlS/FS7Lj6J9iNx99mpYuXLpD5R2WSUCV6EhISbM2aNWk+1/uaNWtG/I4+z8746tn40EMPdS+1WdioUSN75ZVX0lRtDleyZEn3AhAdViT97Rps3bhjgx1dq4Xd2eFeV+UOAIrqhaLaHlQbhKleqmtn5to2N1nxhOKFvWgAkG9mLPvWRsx42nYm77SDKx9i/U7qbzXKR74PBICi1P7gf38YYZP/+Gpfu9PNe1jXoy50bQ8WlKjs3bhEiRLWsmVLmzRpUugzdVyi923bto34HX0ePr6oKnFG44dPN7zNQQDRa9mmpTbwy/4uQdiyzrGuqh0JQgBF1d7UvfbyD8/bqz++6Bql7tHyauvdtg8JQgBFVnJKsr0680VXxU4JwlMP62IPn/44CUIARd6GHett4Bd3uwShSk/3P3mgndf0ogJNEEZtSUJRFd+ePXtaq1atrHXr1jZ8+HDXe3GvXr3c8B49elidOnVcm4HSp08fa9++vT355JN25pln2ujRo+2nn35ynZOIvvvII4/YOeec49oiVHXj559/3lasWGEXXnhhoa4rgKz9seF3e3jifbZtz1Zre9CJdssJ/bhRBlBkbd29xVWzW7hmvqteooaqj6lzbGEvFgDkm3Xb1rrk4O8bfrWSCSXt+uNutnYNO7LFARR5v6xd5DooUfuDdRPru9pytSrUKZRlidok4cUXX2zr1q2z+++/33U+0rx5c5swYUKoc5Lly5e7Ho99xx9/vL3zzjs2YMAAu+eee1w1YvVsfNRRR7nhqr6sTk9ef/11lyBUm4LHHnusTZs2zY488shCW08AWVuydrE98vVA25m8w05q2NFubHubJcQnsOkAFEn/JP3tOihZs3WV1ShX0+7qeL/Vq1i/sBcLAPLN7BU/2rPfPuUeBtdJrOeqFxP3AATBV79+bq/8+KKlpO611vXauvZXSxcvvPb24zw1doNsU8cliYmJlpSURMclQAFYsPpnd7Os3u06NTrdrm1zo8XHRWVLCXlGpZwff/xx94CkWbNm9uyzz7oS1ZGoA6Y33njDFixY4N6rqYZHH310v/EXL15sd911l02dOtX27t1rRxxxhH3wwQdWv372Eg/EPqBgzFnxkw2bNtQ9FDmixlHuRrlCqUQ2fyEh9gH5KyU1xcbMe8s+WjDWvW93cAfX7mpBNdCPyIh9QME0r6De2yf9/oVrf/DiZpe56sWFfa8btSUJAWDOiln2+NRHLDllj3Vpcrb1anVdgbfJUNDGjBnjmlsYOXKktWnTxjW10LlzZ1uyZEnEXtinTJli3bt3d6WpS5UqZUOGDLHTTjvNFi5c6JpkkD/++MNOPPFEu/rqq23QoEHuAYeGa3wA0UHPbMct/p+9MftV87xU91DkqmOvp1kFAEXWpp2b7OlpQ12zCsXii7mYp9hX1K/1AGDjjg325DeD7dd1v7hSg31O/I+1rBu5UEhBoyRhDvFUBSgYM5fPsKemDXHFrs876kLr3rxHIC4alRhUUwjPPfdcqHOlevXq2S233GJ33313lt9PSUmxSpUque+r7Va55JJLrHjx4vbmm2/mermIfUD+Pkn+78wR9vXvX1pcXLz1anWtnd74rEDEvGhH7APyx8LVP9vwbx+3zTs3WfVyNVyp6YZVDmVzZ8OIESPca+nSpe69ms5SE11dunTZ7+HTGWec4Zrs+uijj6xr167Z3r7EPiD/LFm32LU7vWnnRqtToa7d0WGA1Umsa9GiaNfZAxCTvvtrqnuyogThJc0ut0tb9AzEzfKePXts1qxZ1qlTp9BnantV72fMmJGtaezYscOSk5OtcuXKoSTjuHHj7LDDDnMlElUaUYlItdkKoPAl7UqyhyYOcAlC9WR378kPuJLTQYh5AIIn1Uu1j+a/Z4MmDnAJwmPrHWdDz3yaBGEO1K1b1x577DF3zaiOOk8++WQ799xzXS2RcKqNwm8JEF0m/faFDfyyv0sQtqrbxh7t8lRUJQiF6sYAosrk37+yETOeMc8869HyKjv7iPMtKNSpkkoC+h00+fReHS9lh9odrF27dijRuHbtWtu2bZu7mHz44YdddWQ9UT7//PNt8uTJrlf4SHbv3u1e4U+UAeStZZuW2pDJD9m67WusVvnaroOSaLtQBIC87LX92e+ecm2vqs2tK1peZWcdfh6JrBw6++yz07x/5JFHXMnC77//PtQh59y5c+3JJ590ScRatWpxEANRUGvktZ9ecp2UyEVHX2rdjr6k0NsfjIQkIYCo8cWSca7KnVzTurd1bnxmYS9STFEicPTo0a6dQr+9QZUkFD1hvv32292/1Vv89OnTXbuHGSUJBw8e7NovTG/Dhg2uxCOAA/Pzmjn26rwXbXfKLmtc5Qi7tvmNVjK5lHtYUJCqVq1aoPMDEEy/rV9iT33zmK3fvs4ql6lit7e7y5pUP6KwFyvm6eHy2LFjbfv27da2bdtQrZJLL73UdYRXs2bNwl5EIPA27dzkqhcvWbfIdcp0ywn/sWPrtYna7UKSEEBU+HTRR/bGrFdce1y9295qHQ/5/yq3QaGb9YSEBFuzZk2az/U+q4u8J554wiUJJ06caEcffXSaaRYrVsz1Zhzu8MMPt2+//TbD6fXv3991oBJeklBtI1apUoWe3YEDoDaiPln0gb09+3VXYloPQ65sda1rtB8AimLMm7DkM3t91iuuGZmja7WwW0/8jyXSa/sBmT9/vksK7tq1y8qVK+faHPSv9fRQWB3a6QFxdlGDBMi/ByRPTH3UdVRSq0Idu8u1P1gvqjc3V6QACv3i8cP5Y2z0vLdccetbT+hnJxwcuXRbUVeiRAlr2bKlTZo0KdS4tEoC6v3NN9+c4feGDh3qqpp88cUX1qpVq/2mqY5Q1DtyuF9//dUOOuigDKdZsmRJ9wKQd/ak7LGXvn/Opv75tYt3Vx+rEtNnsIkBFEk79uywkd8/YzOWfWtxFueq153f9GJLiE8o7EWLeY0bN3ZVipOSkuz999+3nj172tSpU+3333+3r7/+2ubMmZOj6VGDBMh70/+ZZu8ueN32enutabVm1qvZ9VYyuXSB1xrJaQ0SejfOIXp6AvI2Qfju3DfsowVjLSG+mPVtd5e1rr+vqkRQjRkzxl3ovfjii9a6dWvX6PR7773n2iRU24TqsbhOnTruYk7UxqB6tHvnnXfshBNOCE1HT5X1Ej1dvvjii121k44dO7o2CW+77TZXLfnEE0/M1nIR+4ADowb6H5/6iP267hcrW6Kc68mzaa1mgdmsij+PP/64rV692po1a2bPPvusi3GRqPF9xTU1yr9s2TIbNmyYi1nhFAM//PBDFxtLly7tSs0oHurG2dehQwd30xzu+uuvd00tZBexD8idZZv+ctXrVm1daeVLVrA+J95hzWq3YHPmE7VFfcghh7h4+Mwzz7iO78KrJOt9u3bt3LVfdksSqgaJkpAVKlRgvwE5sDd1r4366WXXlJZ0a3qJXdTs0qhsfzASShICKLQEoYLn+F8+seIJJeyO9vdaizotA783lMxbt26du0HWzbTaD1RSz+/MZPny5Wku/NRQtdoIvOCCC9Jsu4EDB9oDDzzg/n3eeee5m2LdVN96663uJvqDDz7IdoIQwIH5a+OfroOSDTvWWZ0KdV0HJbUq1A7Uww81X6A4pN7V9fBDva2rhLN6XE9P7Wk1bNjQLrzwwlBbqukp+XfTTTe5ktJ79+61e+65x0477TRbtGiRlS1bNjTetddeaw8++GDofZkyZfJpLQGEd0L38swRlpyyxxpXO8JuP+lOq1KG9k/zk2qeKMmn9qSvueaaNMOaNm3qHrak7/AkHDVIgLyRtHOzPfnNY7Z47QIrVay03XzC7dam/vH5snn3rlpl26dMtpR16yyhWjUr26GjFcuDjoooSZhDPFEGDlyql2ov//CCTfxtgpUsVsru7ni/HVXz/9vRQ/Qh9gG588Py6fbst0/a7pTd1qz2MXZ7uztdScJYulg8UEoMKpn33HPPhW5mVULllltusbvvvjvT7zZo0MCVIkxfkjA9PVxRwlHJw5NOOilUklAPWpSUzC1iH5B9u/fusldmjrTJf0x0788+4ny7tEUP2lzNY2o3ukuXLla/fn3bunWrq02iktRqdubUU0/db/y4uDhXq8RvyiY7iH1Azv2x4Td7fMojtmHHeqtZvpbd2eE+q1exvuUHXe9tfvFFneAqfRP6W/H6G6xshw4HNG1KEgIoUCmpKfbCjOH2zZ+TrXTxMnbvyYOscfXD2QsAil57qwves9Fz33Tvz2xyrl3R8qp8a4sr0sXitk8+yZOLxQOhks6qNqybWp9KQ6tq3IwZM/JsPqoSJ5UrV07z+dtvv21vvfWW6/xJpWjuu+++TEsT0ng/kDsrt6xw1YuXb15qZYqXtZuOvy3wTcjkl7Vr17rmZ1atWmWJiYmuw7qMEoQACsbUPybZi98/Z8mpydaidkvr0+6OfH0o7K75dL2nl/z7d/OLI61kkyZW7AB6NidJCKDAJKck2zPfPmHfL//OypUobwM6PWSHVDmUPQCgSNm9d7eNmPGMfbd0qmtv9drWve2URp3zbX75fbF4INQ4t9rD8ptM8Om92hPMCyqZqJKGapf1qKOOCn1+6aWXug6aateubT///LPdddddroqz2jLMCI33Azk3a9VMe2v+q7YrZZfVq3CQXdviJqtWpnqhNs6fF433R6tXXnklxw+tAORf+4NvznrVNaEl5x11kV3c7LJ87aBJD4ZDD4XTi4uz7ZO/tsTul+Z6+iQJARRYr55PffOYzfpnpiWWqmj3dXrYDqrUgK0PoEjZuGODDZ3ysKtyosb6/9P+Hjuixv8nrmLxYjHaqW3CBQsW2Lfffpvm8+uuuy5Nm1y1atWyU045xf744w/XwH8kKvGo9hPTN95fpUoVGu8HIjz8fXP2q/b5L5+696c2Ot2uPPY6K5FQgm0FoMhL2pVkw755zBaume+a0FIJ6rYH5X+b7ylr1ugJaeSBnueanTkQJAkBFEgbNUOnPGI/r5pjlctUsfs7PWJ1Euuy5QEUKX9s+N2GTnnIJQrrJdZ3HZTUKJ//JfhS1qzN14vFAy2tk5CQYGt0QRtG71UF+EDdfPPN9tlnn9k333xjdevWzbJtRPn9998zTBLSeD+QPeu2r7Vh3wyx39YvsZIJJe264262kxp2ZPMBCIQ/N/xuj099xNZvX2c1ytW0OzsMsPr5XABGpYJ3zZ5tu+bPz3ikuDjXLvWBIEkIIF/tTN5hg78eZIvXLrRqZWvYwFMfKZCbZgAoSDOWfWvPfTfM9qTstpZ1jrVbT7zDypTI/550dy9YYLsW5O/F4oEoUaKEtWzZ0iZNmhRqNF/Vg/VeCb4DuVBWxydqjH/KlCl28MEHZ/mduXPnur8qUQgg9+as+Mme+fZJ27Znq9VJrGf9Tuqfb43zA0C0mfbnZBvx/bOuB/dmtVpYn3Z3WvmS5fN1nskrV1rS66/b7nn7rmUy5HlWtuPJBzQvkoQA8s223dvs0a8HuqfMtcrXtvtPfcSqli28m1UAyI/e2t//+V0b+/O77v05rjfPnvnaFo2kbNhgSW++aTu/n5HvF4sHStV3e/bsaa1atbLWrVu73oa3b99uvXr1csPVAH+dOnVce4B+ZyeLFi0K/XvFihUuwVeuXDk79NBDQ1WM1aPn//73PytfvrytXr3afa5G/EuXLu2qFGv4GWec4aoKq03C22+/3fV8rEb+AeSu87kx8962jxa8596f2KC9K0FYunhpNieAQMTAt2a/Zp8t/ti9P/fIC6x78yvy9ZovdccO2/rBB7ZtwudmKSkWn5hoFdSEjOfZ5pci9258oO1QkyQEkG9tNDw88T5buulPV+3uvlMfsUqlK7G1ARSpphSenz7clSIsFl/Mrj/uFutwyCn5Ok9v717bNm6cbf3wA/N277a4smWtwkUXW1zx4rb55Zfy5WLxQF188cW2bt06u//++10yr3nz5jZhwoRQZybLly93PR77Vq5caS1atAi9f+KJJ9yrffv2rtSgjBgxwv3tkK7n5tdee82uvPJKV4Jx4sSJoYSk2hXs1q2bDRgwoIDWGihaNu3cZE9PG+ra3lK863XsdXZqoy4Wp1gDAEXcll1JNnzaUJu/ep5rYqH38X3shAYn5dv8vNRU2/HNVNvy7ruWmpRklpBg5c4628qff77Fl9lXU6Xk4Ye7dqfVrIxqjeihcF5c88V5dHeUI2rAWk+pk5KSaMAayMCmHRvtwYkD7J+k5dagUkO7r9NDVqFUItsrhhH7gLQ2bF9vQ6Y8ZH9t/MN1xnRH+3utcfXD83Uz7fr5Z0sa9ZrtXbnSvS/ToaNV6N7dEhL3xde9q1fny8VikBH7AHOJQd0cb965yaqXq2F9T+pvh1TZV6oXRROxD/h/Szf+6drXX7d9jWs+684O91qDyg0tv+z57VfbPGqUJf/xh3tfskULS7yihxWvXdsKAiUJAeR5Q9YPfnWvrd66yhpVbWz3nDzIypUsx1YGUGT8tm6JDZ36sLthVi/td3W436qVq55v89u7fr0lvfGG7Zr5g3tf/OCDreJVV1mJRoelGU8JwaLcizGAgm9O4X8L3rd3571lnpdqx9Y9zm48/jau6wAExnd/TbUXZjzj2pxuWrO53X6S2h+skC/zStm0yZLefcd2fvONe59Qs5ZV7NHDSh1zjBUkkoQA8owSg0oQKlF4ePWjrP/J91vp4vnfcD8AFJRpf02xEdOftuTUZDu23nF2ywn98q09Li852bZ99plt/fijUNXixEu6W5lTTrG4sOq5AJDXtu7eas9995TNXvGjxcfF2+XHXGVnH3Ee1YsBBKb9wXfmvG6fLPrQvT/7iPPtsnxqc9pd740fb1s/+tC8XbssrlQpK9+tm5XrcobFFSv4lB1JQgB5YkXS3zboq3tt086NdnStFq4Ydslipdi6AIpMiZrRc98KNdh/3lEX2SXNL3c3z/lh19y5rqpJyupVrn3BMiefYhUuucQSKuTP02sA8KnDuWHfDHEPfSuVrmy3n3SXHV79SDYQgMA8JBk+baj9vGqOlUgoaTe0vcXaHZy2DeS8oJb/ds2ebUlvvmEp/3bAVuak9vuakqlUeG35kyQEcMCWbfrLHvxqgG3ZnWQt67a2vifdbSUSSrBlARQJO5N32rPfPWk//v29FY8v7hqrzo+LRdm7dq0lvfG67frpJ/e++CGH7KtafAjtfwHIX7phnbDkM3t91iuWkrrXVa3rc+J/LLF0xaje9HtXrbLtUyb/f3usHTpasVq1CnuxAMTofe3QKQ/b2m1qf7C63dHhXju48iF5Pp/klSst6fXXbfe8ue598UMOtYrqeK1RIytsJAkBHJA/NvxmD0+837bt2WptDzrRbj3xP67XOwAoCtZtW2tDpjxoyzYttYqlK9md7QdYo2qN83w+3p49tvXTT2zrxx+bJSdbfPny7kmyOiehajGA/LYzeYeNmPGszVg2zeIszi48urt1a3pJvlSty0tKDm5+8cU0Pbtv++QT17N72XS9nwNAZqYvnWYvTB9uu1N225E1jra+J92V551vpu7YYVs/+MC2TfjcLCXF4hMTrcKll1mZdu2i5nqPO3kAufbL2kX26NcPuAvL9g1Ptt5t+0T9xSQAZNeStYvt8amPWNKuze4p8l0d7rMqZavm+QbcOWuWe5qcsnaNu8Ete+qpVuHiSyy+HJ0+Ach/egjy5DeDbdWWFa5BfpUebFa7YBvKz20JQpcgVHJQL/n37+YXR1rJJk3o4R1AttoffHfum/a/he+792c2OdeuaHlVnt7XeqmptmPqVNsy+l1LTUoyS0iwcmefbeXPO9/iy0RXG/4kCQHkyvxV82zI5Afdk5ZTG51u17S5Md/a5gKAgjblj0n24vfP2t7UvXZc/RPspuNvt1LF87ad1b1r1ljS66NcezRSvFGjfVWLD26Yp/MBgIxM/mOi/feHEa7nzsbVDrfb292VLw9D8qsUYagEYXpxcbZ98tf0+A4gU9t2b7Ph3w61eStnW/GEEnb9cTe7wi95ac9vv7p2ppP/+MO9L9mihSVe0cOK164dlXuHJCGAHJuz4id7fOqjlpyyxz1p6dnqGnq7A1Ake7NTlbsLju6epw9BXNXi/31sWz/5ZF/V4goVrMKll7rGqqOlqgmAom333t32ysyRNvmPr9x79Vx8aYueMdNkjNpP3PPLL2apqRmN4NooBICMLN+01IZOfcTWbF1lVcpUc+0PHlIl79qATtm40ZLefcd2Tpvm3ifUrGUVe/a0Ui1aRPVOiY1fAQBR44fl023YtKGuQWv17tm9+RUkCAEUCWo64elpj9usFT+63uxuOv42O75Bu7ztxW7WT/uqFuvmVVWLO3e2ChdeRNViAAVG1YpVvVjVjEsXL+NiXZv6x8fMHtjX4P8o27NkScYjxcW5TkwAIJLvl31nz00fZrv37rIjahxlfdvdnWedNHnJybZt/Hjb+tGH5u3aZXGlS1v587tZuS5dLK5Y9Kfgon8JAUSNb/+a6nr4TPVS7ZLmV1i3phdbNKKXOwA5tWbrahsy5SH7e/Myq1S6st3V8f48fZrs2s56fZTtnruvF7sSjZtYxat6WfGDGrCzABSYGcu+tREznna9tqut1b4n3W01y8dGT8Cpu3bZ1o8+sm3jPjPbu9fiypc3b9u2yNWNPc/KdszbKoMAikaNkffmvWMfLhjj3ndpfLb1aHV1npSi9vQwePZsS3rzDUtZvdp9VqZ9e6vQ/VJLqBjdvcSHI0kIIFu+/v1LGznjWfPMsx4tr3bVUqIRvdwByKlFaxbYE1Mfta27t9ghVRrZnR0GWOUyVfLupvbjj23bZ5+6m1r1Ypd42eVWWr3YqS0tACgAySnJ9ubsV+3zXz517zs1Ot16HXudlUgoEfXb3914//DDvhvvDRvM4uOt3JlnWvluF9jOmTNdJyXhvRvrr3o3LlazZmEvOoAosn3PNnv62ydc01nF44vbtcfdZB0P6ZQn005escKS3njDds/b9zC4+CGHWsUrr7QSjRpZrCFJCCBLE5Z85tqtkWta32idG58RlVuNXu4A5NSk3760l2e+4JpQOKFBe+vd9lYrWaxk3tzUzpy576Z2/Xp3U1u2yxlW4cILo64XOwBF27rta23YN0Pst/VLrGRCSbvuuJvtpIYdLRa4G+9Rr9nu+fPd+xJHHGEVe11lxevVc+/LduhgxWuWsW0fv2EpG5MsoXKilevaw0o0aV3ISw4gmvy9ebk9PuVhW7V1pXsQfEf7e+3Qqocd8HRTd+ywrR+8b9smTDBLSbH4ihVdycEyehgco+1MkyQEkKlPFn7onjzHxcXbjW37WIdDTonaLUYvdwByUt3kzVmv2rhf/ufeqwmF84+6KE9K97n2sl7TTe3P7n2Jww/fd1Nbvz47CECBUomZZ7590rbt2Wp1KtS1fu37W72KB0X9XkjdudO2fviBa9fL3XhXqmSJV1xhpdsenyZO75032vaO72elLM6skmfmxdnejz6y+DOfsmJHR2ezOAAK1szlM+zZ756yXXt32uHVj3TNLFQsXemApumlptqOqVNty+h3LTUpySwhwcqdfY6VP++8mH8YTJIQQIalYN6fP9rem/e269Xz1hP/Yyc0OCmqt1by0mX0cgcgS9v3bLfh04ba3JWzXKmaW07slyeN9ruqxR9+uK+9LP+mVlWLTziBqsUACrXdrRMbtHclCEsXLx311587Z0y3pDfftNRNm/7/xrtbN4svVSrNuKkb/7Q94/vpbn2/6ewZ19fi67a2+MoHF+DSA4gmakd/7M/v2vs/v+ved258pvVseY0VTyh+QNPd/euvroRz8p9/uvclWxzjHmIUr13bigKShAAiXqC9M+d1+3jh+64RVz1tObbecVG7pbyUFNv26Se2++d5GY9EL3cAXK+eK23I5AdtxZZ/rEqZanZXx/vs4MoND/ym9vvvbcubb1rKxg37bmrPPGvfTW2MP00GEHs27dzkempfuOZndx2ntgdPbdQl6h9WJP/9t20e9ZrtWbjQvS/ZtKklXtnLitepE3H8vfN045/ROsXZ3nnvWImO9+bjEgOI5gfC6nBz1j8zXRy8ts2NdvKhpx3QNFM2brSkd9+xndOmuffFatWyxB49rVSLFlaUxGYlaQD5+sTltZ9ecgnC4gkl3A10NCcIk1f8Y+vuv8+2jB4duXe7GOzl7vnnn7cGDRpYqVKlrE2bNjZz5swMx3355ZetXbt2VqlSJffq1KlTpuPfcMMN7iZh+PDh+bT0QPSav2qe9f+8r0sQHlatiT12xlMHnCBUDNrwyMO26enhLkFY4sgjrfqQoe6JMglCAAVt4Zr5due4W12CsHq5Gvbw6U/YaYedEdUJQrXppfZb1959l0sQJlSpYpVvu92q3HNvhglC8TYtjViK8N+h5iX9Y0XRiBEj7Oijj7YKFSq4V9u2be3zzz93wzZu3Gi33HKLNW7c2EqXLm3169e3W2+91ZJUHRIIiBVJf9s9n/dzCcJKpSvbg6cNOaAEoZecbFv/97Gtuf02lyCMK13aKlx2uVV//IlCTRC60tSTH7HdH/d2f/U+L1CSEECaqikv//C8Tfr9SytZrJT173i/HVnz6KjcQmoHQlX6trz3nllyshWrXdsq9b7RNXAdy73cjRkzxvr27WsjR450CUIl8zp37mxLliyx6tWr7zf+lClTrHv37nb88ce7pOKQIUPstNNOs4ULF1qddBfWH330kX3//fdWu4gUhQdy4stfx9urM1+0FC/F2jc82VW7O5BePV17WR98YNs+/7e9rMqVLfGKHlb6uOOi+mYcQNF9yPu/hR/Yu3PfNM9LtVZ129hNx99u5UqWs2jlSmF/960lvfWWpW7evK8U9rld97Xpla5qcXopf06xlL++ccnAyOIsLrGuFUV169a1xx57zBo1auS24euvv27nnnuuzZkzx71fuXKlPfHEE3bEEUfYsmXL3ANiffb+++8X9qID+e6nv3+wZ757wnYm77TG1Q63fu3vsUq5bH/QUyd0s2db0huvW8qaNe6zMh06WIVLultCxYpWmNQeq2tuwZWmVhyMs73fv2Al8qA91jhPa45s27JliyUmJrqnMXpyAxSlBOHz04fbtL8mW+niZezeUwa5wBqN1CnA5hEjbM9vv7okoKr1VbjoIosrse+Gf+/q1bZ98teWsm6dJVSr5koQxkKCUJQYPPbYY+25555z71NTU61evXruqfDdd9+d5fdTUlJciUJ9v0ePHqHPV6xY4ab9xRdf2Jlnnmm33Xabe2UXsQ+xHNtUOvqLJeN0y2iXHdPTzjmiW64Tee6mdvp0S3orrL0sVS0+//wsb2rzm54gq/qdSs/o5rhYs+4Wf4AlJYOO2IdotWrLCvv6969cz8WJpSrask1/uVKEakf60haKc+dH9QOL5OXLbfNrr9qexYvd+5LNmllizyuzbNPL27HB9kx8wFIWZJHwiou3Utd/G5g2CStXrmyPP/64XX311fsNGzt2rF1++eW2fft2K1Yse2WEiH2IxQclH8wf49rTl1MP62K9Wl2X6/YHk9Wz+huv2+55+5qzKn7ooVbxyl5W4tBDrbDpem/Xi+0il6TOg9hHSUIAlpySbE9/+7j9sHy6lStR3gZ0esgOqVL4ATBS6cHtEz63pHffdaUHE2rWtEq9e1vJxk3SjKeEYGL3Sy3W7Nmzx2bNmmX9+/cPfRYfH++qEM+YMSNb09ixY4clJye7i0WfEo1XXHGF3XHHHXbkkUdmazq7d+92r/CLRSDWbNu9zZ765jGbv3qulSpW2vqc+B9rVa9NrqeX/Pdy2/zqa7Zn8SL3vmTToy3xyiszrQ5XFJ4oA4guk3//ykbMeMYlAfXgQv9JmeJl7e6O99nhNY6yaK5avGXse7b9iy9cZ3MJVatZYs+eVqpVq0yTmlrPlIUf2p6v7jfbudGsZHkr3nGAWUJxSx7/nzSxT38V+4KQINTDYSUBlQBUteNI/MIt2U0QArFmx54d9tz0p+zHv7+3hPhidk3rG6xTo9NzHaO2fvC+bZswYV9NkYoVLfHSS630ie0sLr5wW+vz9u6y1DULLXnqkEya2Trw9liJFEDA7UnZY09OHWyzV/zonkTf3+lhq1+pgUUblQ7cNHKE7fnlF/e+bJcurqh3fMmSVlSsX7/eXezVqFEjzed6/8u/652Vu+66y1UnVmLRpyrIujBUmzTZNXjwYBs0aNB+n2/YsMElM4Fot3rbKhsxa7it3bHGqpSuar1b9rE6peu58yynvJ07LWX8OEuZOnVfD+qVKlmx87uZ17y5JemmNhfTzEtxScus1Ph+FpfuibIuH3eP62tJZRuZl1g/4nerVq1aQEsJIK9KECpB6FKD6W4SdybvsIql//8hYbQ96N0xbZpteedtS1X7eMWLW/mu51m5c8/N8loudfPftmfCXZb652T3PqHxGVb8tEcsvvy+WiIJ9Y5zN8X/X4r60iKfIJw/f75LCu7atcvKlSvnmpRR9eL09Jv30EMP2XXXXZfp9Hg4jFgsRV2tbHXXNNaon1527RBWLF3J/nPSPda4+uG5i1FTptiWMaP3xSi/Z3XVFCld8L3Cq9kIb+OflrpytqWunLvv75pFZqnJWX3zgNtjJUkIBNiu5F02dMrDrpRN5TJV7P5Oj1idKGu/xZUe/Oord1Hp7d5tCdWrW6UbelvJCBdCQaf2aUaPHu3aKVT7hKKSiU8//bTNnj07R9WOVJpRbSOGlyRUtecqVarQ1AKi3ryVs+2p74fYjuTtdnj1I117NImlEnNXtXjaNEt6+619F4zFilm5c8618l27FnrVYm/PDktdpYvGObZ37jvuYjK9fWd8nJVf/jk9fAJFhG6O/RKE6enzr3//0i475kqLJnuWLrWkV1+xPb/+6t6XbHGMVezZM8umYLzUFNv70yuWPPUxs+SdFleuhhXv/KgVa3xGmvGUEAxaL8bqmGTu3LmulKDaGuzZs6dNnTo1TaJQ125qYkafPfDAA5lOj4fDiAXT/5lmb81/NU0MVGebcnDFQ+y6FjdbxfhKOX4gnPrnn7Z37Fjz/l7u3scfdZQlnN/NkqtXt43bt5vpld92rLeEdQssfu3PFr92gcWvW2Bxe7amGcVLKGGpNZqZpey1+PWLLc72v/bzLM52lahiWzPYBtl5OEySEAhwsezHJg+yxWsXWrWyNWzgqY9YjX+fyEaLvWvX2uYXX7TdCxe492VPO80qXHpZod+c5xcF7YSEBFvzb8O4Pr2vmcWFtBqoVpJw4sSJrsc737Rp02zt2rWudzufSiv269fPdYqydOnSiNMrWbKkewGx9kRZ1Uw+WvCea5um4yGn2rVtbsxVezTJy5buq1q8ZF8p3pLNmlvFK6+0YrVqWaE8TV7/m0sIpq6YZSkr55i3bnEmvXoGo4dPIIgU6zJqUt77d3i0SN22zXUwt/2rL13VOD3oVbuDpVu2zPq7axfZnnH93MMQKdbiCive8V6Ly8UDn6KoRIkSdui/baO1bNnSfvzxR/dQ+MUXX3Sfbd261U4//XQrX768K2VYvHjmv4M8HEYsXO8pQRipFLXc0q6f1asYudZERlI2brSkd96x3d9Oc+91jZfYo2e+91jsJetB78/7HvaumG2pq+ZEvFaLq9LI4mu3sPjax1hC7eYWV/0Ii0soHtYm4f7TjjPPyh93tcVXzn1NEZKEQABt3b3VHp000H7f8KvVqlDHBnZ6xKqUjZ4qZwr8OyZNch0DeLt2WULVqq534lJNm1pRv+DThd6kSZOsa9euofYE9f7mm2/O8HtDhw61Rx55xHVK0qpVqzTD1BZheNVjUW/J+rxXr175tCZA4bTLJfva5oqzni2vsTMPPzfHDfenbt/+/+1l6aZW7WVd2dNKtcy8vay85G1f7xKCKStm7UsMrppjtjvt02QrXubfC8cW7mIx9Vctb0qgevgEgqhKmaqhNgjTU4TSw5LC5qrtTZ1qW959x1LVprGqFp97rpU/59xQJ3MZfjd5pyV/N8z2fj/CLHWvxVU+xEqc8YQl1D+uwJY/Ful60W9LWiUIda2nh72ffPJJqHZJZng4jFguRa0Om7758+tsl6L2kpNt2/hxtvXDD11NtbjSpa18t25W7vQuFpfHbXeqRPS+B72qNjzn3we9v+x/zaYH3XVaWHytfUnB+FrNLK5U5I5y1Smd2l3dM65vvrTHSpIQCJikXUn20MQBrhe8eon17b5TH8l1t/D5Ye/69bb5pRdt988/u/dlTj7FEi+/3OLLlLEgUBVfVRlRsq9169autJ8ao/YTeuqxuE6dOq5aiN/e4P3332/vvPOONWjQwFavXu0+V/s0eql6sF7h9DRZJRNVVQUoiu1y6TKpZd3WOUrquZvab77Zd1Prt5d1zjmuenF+tn3q7d3tGqF2F496mrxytnmbl6UbK87iqja2+DotLUGJwTotLa7qYRYXn+CGuifKv07IaA6ufa7C9vzzz7ueNxWjmjVrZs8++6yLcZEsXLjQxTU1l7Bs2TIbNmxYxN7Ys5qm2upSqWk1w6CbZ900v/DCC/u1+wrEErU7mBHFwpMPPc0K054//7TNr75iyb//7t7rAYs6JilWPevkZcqy6bbn8ztcO1wWX9yKnXC7FT/hVosrVjRrkOSWSv116dLF1RJRiUFdA6qpGT0sVoLwtNNOcx3ZvfXWW+693/lctWrVXI0VIKilqPX9XbNmWdKbb1jKvzW3ynTo4Nq5T6hYMU+WM3XLyn0PeP3X6nlme9JVVy5e2uJrNrP4OkoG6rquhcWVr52j61Z1Shdft3W+tMdKkhAIkE07Ntqgife6hl0PrnyIDTjlQasQJdU2XOnBqVMs6fXXXScB8ZUrW6Xrr7dSzZrneFq6Yd47792wgNndPXGJBRdffLGtW7fO3SDrxrd58+Y2YcKE0E3t8uXLXY/HvhEjRriORC644II00xk4cGCW7c8AsSwv2+Xa89eflqSqxb/tay+r1DHHuOomWbWXlVOuF9LNy/9NCP5bSnDNArOUdJ0BlalqCXVa7ispqL96mlyyfIbTze8nygdqzJgx7gHIyJEjrU2bNu7hhxJ2S5YsseoREge6uW3YsKFdeOGFdvvtt+d6mvruuHHjXM+fiYmJrkT2+eefb999912+rzOQHxavWWATf/vClZpRPHEx0D/bPc96H9/HalWoXXhVi0ePtu2TJu4rhV2jhlW8sle2qu15OzfbnskPWcrcd9x7xb0SXZ6w+OpNCmDJY4+akdFD41WrVrnYpmZmlCA89dRTXbLwhx9+cOP51ZF9f/31l3ugDMSqAylFnbziH3ef6RdEKd6okWtGpsQhh+Z+eXZvtdRV8/5NCO7rYMTbtjrdwsW7asLxtZtbgkoI1m7x74PeA0/F5Vd7rHFeRulYRKQnMQrGflfyQKzQ05UHv7rXVm9dZY2qNrZ7TxlkZUuUs2ig9iA2vfyy7Z4z270v0769u0GPL1s2x9PaO2+07RnfL+KNsp64IHeIfYg2w6cNtelLp0W8YIyLi7fjDzrRbmt3ZzbayxrjOkfa115WDVfiJTvtZWWHt2vLv52LzLaUf0sJ2o4NaUdK+D/27gO8qer9A/g3o+luadl7y957KEOGiIgKijgAxYWiuPiJirj/bkWG4GI4EEQRERBlg+y9996jpXsmuf/nPSEhbdPSlrZJk+/HJ6ZJbm5ukvZw7nvOeV8T9OUa2ZaWyEVmCYZXytfSZmv0MY+s8ClBvFatWmHChAm247RaVSGkZ599FqNGjcrxuXJCK7MIM88kvN4+pZ8ms2Zkho19EEWqxNerVw/r1q1D27a5W7rIto88RWJaIkbOf1b15wa1eBQtK7VVgyH2fKwyg9AdAUI1C3vZMltF0Ph4tZw49O67EdL7jusvLdY0WPYvQNq/rwGJlwBTMPw6vwZj88GOmdLkHmz7yFNIO7Fw/zxM3/xdDkFCHb7s+7XLNtCalIS4335D4j+LJDE79CVKIPyBBxDY8WbonCZeXPc4LOlqmbDFqdqwLCPOnBhQF1bhap/OlhJGX64xdKa8n9O6E2cSEvkACQy+vfg1XE68hPplG2JUlzEI9HP/8l1VOfS//xAzbSq0xETVaJd4/Il8n6DLDEIVIHSRzF9m2MiUbE84YSaiG287opOi8z2irE5qVyxH3C+/qJNatbT4rrsQ2ufO657UZr9PM7RLBzIEBF12HiOqZQgI6stKEur8vWZmnljhU2Y6y7JhWR5nJ7OhJVeqBOsKa5/yeHp6eoacrHXr1lXL8/ISJCTyFFM2TVYBwYblGqN3vbvUbEJ3VzFOO3zYtrT46FF1O6B1a4Q/PAjG0qVztSQv/Z/XYDn0j7qtr9Udpts+gD6sYqEfNxEVD2mWNHyzfiJWHl2qBoA7VLkZa0+sztUsaltfbwXiZv5iy41qMKgUMjKIoQ8MvP7Kj9hTTjMEZdnwLsCcknFD/1Doyzd1BAQlJYxUYS/uGCQk8nKnY0+pGYRXkqPRpHwzjOz8Ovw9ILeLJSYGMd99i5TNm9VtGc2RKd/6kPzPbpQlxrZ/LlzRqRk2nnYCTUR5k2pOwVdrv8S+i7aq53nNy5V25AhipkxB+pGr+bJatrQtLc5Fvixn1vjzGfIIynITZM4V5h+mlpfoK7SAQeWdaQqdBxWJKgqXL19WFdUz5wGU2zKzr7D2KekapBhUiUw5hmQbe+5WVyR3oT35v7Dn8iJypzXHV2HV0eUINgVjePsXVYDQnSyS527mL0havlzNwlYVQYcMyVWKGKnWbt76A9KXvw+kJaj0CqYe78FQ784iKw5FRJ4vKukyPl3xf6rQpqx+e+HmV9CkQjMMiHvourOoUw8cQOz0adcGMCSNjAxglC+fbcoDKRJnLyxiPbst68oPvVHNCrRXG5b+na5kLRW89DYMEhJ5sePRR/HukjcQlxqLlpXa4MVbRsHP4Of+2YPr1iF26hQ1g0cfHo4SQx9DYDYJ7PNCSsm7ru6pXtllaXkiKj6kQ/jJivdxLPoIQv3DcGutHvhzz++5GlG2xMfbTmqXLbMtLS5XDiUGD8ldvqz0JDWCrEaSVS7BrdDizmbcSGeArmxDW74ZCQhWaA5dyZpe2Xn0ZlIU6u23385yf1RUlJrBSFTUopOj8PU627L6gfUHQ0sGLidfdssXITNzrGv+g/mvvyR5KGAywXBbL+i7dEGCnx8SLud8XLorR2Ba9RYMF7ar2+Y6dyOtzUtIkvzYUZlOyAtZqVK+NWBDVJwcuLQPn678P8QkX1GFNv/X5Q2UC7UF+KR/l90saklhFTvjZ7VSTRgrVFADwQFNm2YsGHdxr22Q92pgUBVLykQnKz9UpeGrl7INoPPLeQait2CQkMhLHb58EO8tHYPEtAS0q3oznuv4EowFkCD1RkeeY77/DilXEyoHtm2H8EcfheEG83ta48+pEWnr8VU5bKVTObqIqHjad3EPPlv5AWJTYlA1ojpe6fwGSofYRpBzGlG25ctaitiZM6ElJFzNl3UPQu64Azo/P5ezXKSzaJ8lKLlntAt7swxA6ELLXyssonLONIHO5P40Dp5GTsSlmuaFq1UE7eS2VFkvrH3KtQT1YmJiMswmvN7ryhJmKYjiPJNQch1KlXjmoqaiZtWsmLD4cySbk3BLjS7o2eh2t30JqQcPqgFe87Fj6nZg27YIe+hhGHMRbJOT8vS142FeOw6wpquTb1OvTxBUrWMRHDkRFSfSp/t2w1cwW81oVbktnu3wYoY0WWn7NyJh7g+wRMfCEBmOkLsGwa9GUyQsXID4P/6AlpoKXWAgQvv1Q3DP24C4kzDv/g3WM9tsQcELe7IWjAuMsPXlyjeDoaJcN4UuqCR8lUcHCSdOnIhPPvlELQtp0qQJxo8fj9Y5zDaS6nVvvPEGjh8/jtq1a+Ojjz7C7bfb/jGVvDSjR4/GwoULcfToUVV8RPLUfPjhh6hQwT1VwIgK0rm4M6rap5woyzKUjafWIdWcik41bsWwds/B4OYE0MkbNyDmu+9UTgh9aCjCHx2KoHbtbmifWnoyzBsmI33deCA9GZB/QOTaZZ4yTSXxJ6LiZ8mhRfhu42RYrGa0q9oRT7d7HgF+AdcdUU47dAgxU6c45ctqg/BBgzKc1GpJ0arTaM8jKMmokRKTcUfGAOjLt7wWEJTZgm6qIFrcyJLfFi1aYOnSpbjrrrscRUbktlQbLqx9yuN+fn7qvn79+qn7pPKxVIhvl8O/Pf7+/upC5AkW7JuLPRd2qgGQR1s95ZZjsMTGIu6XGSq3l2NmziOPIKBR49w9/9RGpC18GVrUITXj2thuOPw6vugzM3KIKHckKPjD5u/x94G/1O17Gw9E/8YDM6RXiP/xI8Qt2HLtSScvInn7p9AF+kNLtgX+ApvfhKBGAUDMz0gZ/7+sfTqDv1N/ztan05WoynQHxSFIOGvWLDWSO3nyZFXBbuzYsejZs6fq4JVxkTdo7dq1GDhwoFomcscdd6hqdtJx3Lp1Kxo2bIikpCT1swQRJeB45coVjBgxAnfeeSc2X82JRlRcLT+8GJPWjbMtuZNEq1eDZA3KNsLT7Ue4NXeNLPGLnToVyWvXqNsBrVqp5cWGTHmi8sJeDS992dtXlxDrYGj6AEy3jILl6DJVpMRVdWMWLSEqfh1GqWa36MB8dfv+Jg/hnkYDMnTkXI0oGyrUtZ3USr4s+0nt4CHwb1hPLTFJ3/wXrGe3ZL/EpGStq4VFmqvlw7rSdaFzc6qG4kz6c4MHD0bLli3VYK/06RITE/HII4+oxwcNGoSKFSuqPpyQGYB79+51/HzmzBls374dISEhqFWrVq72KYPBQ4cOVdtFRkaqWYBS+VgChCxaQsUlZcyMbT+oqp0yk0byERYlzWJB4uJ/Effrr9CSkqDz90do//4I6XU7dMbrn0JqqfFqlYd563R1W3J5mXp/Bn3ZhkVw9ERUnMSlxOLzVR+pQRHJnS9tXpsq7TNsI/09W4Awa+5SCRDqg1IQXGEvjOZVsG679pgusqYjDYzKE12m4ArGeSudJmfbHkgCg61atcKECRMcI8Sy3EM6eKNGjcqy/YABA1TncP5824mEkE5g06ZNVaDRlU2bNqmO5YkTJ1S1u9xgOXjyxBmEI/58ymWVz5zKwReF5M2bEfPtN7DGxkIXHIwSjzyKwA4dbmikxnphN9IWj4H1pK2CpVQsNvV4V3U+HdtEH1NFSiSAKEuMZQYhA4Q3hm0fFbX41Dh8tvJD1WEMMAaqDmPrKhlngGUZUbaTE1izBTp/E4I71kdAlWRoF7bb8pZarhWluLbEpLmtsIh0IGWJSWD+BzHINenP2VeHSN9s3Lhxqq8nOnfujGrVqmHatGnqtqwIqV49ayX6Tp06YcXV2UzX26dISUnBSy+9hF9++UUVI5HB5q+++ipPy5zZ9pG7KnqOWvA8TsWexN0N78UDzQYX6eun7t+vlhannzihbge274Dwhx6CITIyV883H1ykKhdr8ecAv0D43fI/GFs9Bp2b095Q7rHto6IcEPl4xfu4lHgBZUPKYWTn0agaUS3LdtEfDkfy9ovZFKnU4F/6FIJqJdpyQ6uicdKnawKd5DylPPHIllpGjbds2aLywtjp9Xq1PHjdOltgIDO53zmHjJDO4Ny5c7N9nVgJXOh0WSrfERUnssTYPoMwM7lf8jpktxSvsFgTEhDzw3Qkr1rlqChV4vEnYIiIyPc+tcTLSF/5Eczbf1b/EOjCKsCv6xiX1fAkIMgqxkTF14krx/HxindxMeECyoSUVfkHq2TqMOY0oiwBQmN4PILL74H+0hJYLl29X++ngoD2WYJqiUlENS4xKQKyDDi75cXOgT8hAcPcjGHntE8REBCgUtfIhag4mbF1ugoQVo+siXsbF12qFEtMDGJ//gnJq1er28ZKldQAr3+DBrl6vpZwAWn/joZlv23Shr56J5h6fQx9idxNxiAi37LuxH+YuOYLpFpS0ahcU7xwyysI9Q91ua0lKtOy4Uw0/2oIfG4G+3TeGiS8fPkyLBYLypYtm+F+ub1//36Xz5FRZFfby/2uyOjyK6+8opYo55SIWkae5eI8qkLkSSQHYXYnU9rVx4tSyrZtuPLN17BeuQJdUJBa4hd0yy35brA1SxrMW6YiffXnQGqcyg3m1+5ZGNs+BZ1TElsi8g4bT67DuDWfIdWcgoblGquq7FLJODNZYpw9DUbTFRhKl80QENSXawid0ZbLkIjIE+04uw0L9v8Jk8EfIzq+DL8iSHWglhb/swhxs2dDS05WSf/D+t+L4J49c7e0WNLA7JiBtKXv2PpqgREwdX8Hhgb9eMJORC6LMs3a/jPm7J6lbveu1xcPN3802xz6Kfv3If2C5BzM/nzSUKok2xtvDhIWNilict9996l/0CZNmpTjtpIf5+23385yf1RUlJrxSORugbpgl0uNcbUZDdGHqsB7YZNOpXnOHFjXrbW9dv368Bv4AJIjIpAcFZWvfepProJp3SfQxx5Xt801eyG9zYtICikHxCYBkEvBkGqZROTeDuPvu2bh1x0yWxjoVacPBrUcmm1V9uuNKFsDqiPwmRmFcqxERIWVZmHi2i/Uz4NaDEXF8MqF/kGn7t2rCjyZT51StwM73ozwBx/M9eoPa9QRpP090pEGxtDgHpi6vQ1dMPtVRJRVYloixv/3Kbac2QQ/vR+ebDscnWre6vKjskRHI/bHaUhet8Ep3zwyBQtt94XcVbRpGbyZRwYJ5WTdYDDgwoULGe6X29nlkZH7c7O9PUAoeQiXLVuW4yxCIUuenZcxy0xCyY1YsmTJ6z6XqCikQKr5uiaB8N6N+qJUWOF21FJ27UTM5MmwRkWp0efwhwchqEuXfI/mWC8fQtrSt2A9skzdlnyDft3fRVDl7KubE1HxlZKegglrP8eGk2th0BvxeOthuLV2z2y3T962GWnnZJZ/9kWZDCVzlzuLiMgTSJ/t6/UTcCU5Gs0qtkSPm3oV6uupk29ZWrzGVljOWKWKbWlxvXq5O15LOszrv0L6f1+oXK+SA9p020cw1OxaqMdNRMXX2bgz+Hj5uzgTdxoRgZEY2fl11C5VJ8t2WloaEhbMR/wfc6ClpQN6M4KqRENftSUSVkqu1IwTZMLuaAlT3VZF+E68m0cGCU0mE1q0aIGlS5eqCsX2wiVyO7vcM1KtTh5//vnnHfctXrxY3Z85QHjo0CEsX75cBfqux9/fX12IPNHqYyvw37EVaqaNxWqx5Sa0j7NoGoa1H1GoRUusycmI+/lnJC5ZrG77N2yIEk8+BWPp0vnan5YSi/TVn6nlxbCageDSMHV+DYbG90HnxgrNRFR4LiVcxEcr3sWJK8cQHlACL3d6DXXL1He5rfn8ecRO+w4p23ddDRByRJmIvMOKo0vVQEmYfziebjei0JbNaWYzEhb9jfjffoOWkmJbWnzfAAT36AGdwfVSv8wsZ7chbcFL0C7tA3R6GFs/oYqT6Iq4AjMRFR/bzmzB2NUfIyk9ETeVrouXb3kNEUEZB3Tl/DVl82bE/vgDLBclZZYGU8R5BDcNQ8ADv0AfWg6BXTYhYe50WKJjYYgMVzMIGSD0gSChkNl7gwcPRsuWLVUF4rFjx6rqxY888oh6fNCgQahYsaJaDixGjBihqt599tln6N27N2bOnInNmzfjm2++cQQI+/fvj61bt6oKyJLz0J6vMDIyUgUmiYqTUzEn8fW68ern4e1fQI2StVWREslBWDq4DLrW6lGoAcLUPbtxZfJkWC5dgs7fH+EPPYygbt3y1anVrBZVkEQKkyA5GjCYYGw3HH7tn4Mum+S1RFT87b2wG5+u/D+1xE4S9MuIsrRfmVlTUhD/xx9ImP8XYLFAZ0hDYM0E6Cu1QsKywxxRJqJi7UL8eUzZ+LX6+al2z6FEYP4LveUkdfdu29LiM2fU7aBOnRA28AEYclnEUUtLRPrKD2He9L2tiFyZ+jDd/hkMFZoWyvESUfEngb95e3/Hz1unqxRZco76WOthWfKtpp8+jdjp05C6SwaCAUNQHIIqHIZ/294w3fahI6e0BAQjR3HWoE8GCQcMGIBLly5hzJgxKpjXtGlTLFq0yFGc5OTJk6risV379u0xY8YMjB49Gq+99hpq166tKhs3bNhQPX7mzBnMmzdP/Sz7ciazCjt37lyk74/oRiSnJ+Ozlf+nKkHdVucOdKjeSd1fFFWM5WQ9buYvSFy0SN021auPiKeegjFT4aDcspxYi7TFY6Bd3KNuG27qCb+ub6oKxUTkvf49uFCdFFs0C9pXvRlPtx8B/0xFRaRjKUvhZEmcFEOSk1L/UmcQ1LoKAu+bBl1AOAJv4YgyERVfshJk/JrPkGJORrfat6FV5TYF/xpRUYj98Uckr7flDfSrVg3hsrS4Tp3c7+PIUqT9/Qq0uDOAwR9+N78EY5unoCuCwipEVDxJEbpJ68ZjzfGV0Ov0eKTlE+rc1XlSiTUhAXG//YbEf/+R5aPQB+oRUGovTBFRMHV/C8aWQ1mQpIjptOzKopJLkpMwPDwcsbGxzElIbiF/sl/+9wnWHF+lcji83ePDIql8J1L378eVSV/BcuECdCaTGn1Wle+cAva5ZY05ifSl78ByYIG6rSt1k60S3tWAJ3kWtn1UUMxWM6Zu+kYFCXXQYWDTh3FXw3uzdADTjh1D7LSpSDtwQN02hlxBUIUj8O/8CPw6vwpdNhXwiAoS2z4qbL/vnImZO35C+dAK+Lj3OAT4BRTs0uIFCxA/53doqanQBQcjbMAABHfrnuu+m5Z4GWlLxsCy5w91W1+lPUy3fwJ9ZI0CO07yPGz76EbJ6rZPVryPY9FHEOofhhdvGYWG5Ro7HtesViQtW4q4WbNgjY8HjAYEVk6Ef9Bm6ELC4X/3NzBU68gvwg08diYhEbm26MB8FSCUxvaFW14pkgChJI+NnTkTiX8vlCglTHXqIOKpYTCWL5+PfSUife14mDdMVomuEVACfreMhLH5IOiyqWJKRN4hNiUWn638APsu7kagXyCe6/AyWmaaNWOJi0PcrJlIWrZMtTf6ICCw9B74RSbC/47PYGxwj9uOn4ioIB26fAC/7pyhZtg81/HlAg0QpuzcqQZazGfPqttSUE4tLc5l4UUZlLbsno20JW8ByVeAgHCYuo6BoclAzuohohztU+lkPkBcaiyqRlTD/zq/gTIh11adpe7bp5YWpx8/rm77N6gFf9MiGCxnoStdD/79p0IfUZWfspvwjJyoGDl06QCmb/lezb55ruNLLnN3FbS0Qwdx5auvYD53DvDzQ9j99yOk1+15nj2oaVZY9sxB+rL3oSWcB3QGGFs8qpar6DIlrSUi73M8+ig+XvGeGlkuG1oer3R+A5VLVHE8rlksSFz8L+Jmz4aWmKjam8CKUfAP2Ql9eDn49/8Z+vJN3PoeiIgKsqr7+P8+g1Wz4v4mD6FWqZsKZL/my5cR+8MPSNm4Qd32q1FDVS021a6d631Yr5xA2qL/wXpslbptqNsHph7vQRdS+P1OIvKedDLtqnbE0+2edwyASPsUJ1XV19lSHxgrVkRIh8rQHZQq6ekw1OkNU58vWQTJzRgkJCom4mQGzqoPYbGacW/jgWhaoUWhzx6Uk3VVKEDT4FerFiKGPQ2/ihXzvC/Lma1IX/wGrGe3qtv6ajfD1O0d6MvULYQjJyJPs/7EGkxY87nKo9qoXFM1CzrUqShRyq5dakTZfPq0uh3QqAb8dfOgR7QqTuJ/z/fQheSvajoRkSf6Yct3OBd/FnVK11MpF/JKBm8TVyxXBeQMpUsjqOPNqipo/B9zVB9OFxKC8PvvR1DXW3O/tNhqhnnjt0hf9TFgToEutAL8bvsAxto98vEOiciXpFvSMXXT11h8aNHVdDKDcPfVdDLSJsX/9RcS/pxra5+CghDa7x6YdGtg2f6xer5aWdbheeh0eU9jRQWLQUKiYpLUetyazxCVdAlNyjdDv0b3F+rrpR05onIPqhN2oxFh996HkDvugM6Qtxxg1vjzSF/xf7Dsmq1u6yKqwe/WN2Go3ZNLVYh8gMyQmb3zF/y28xd1u3fdvni4xaMwXM0naL54EbE//eSY8WKsUgUhLcOhO/yVKlJiaPogTD3/DzqDya3vg4ioIG06tUGdSAcYA/Fsh5ccbWJuSXAw5uuvAcnlejW9fMKff9oe1OkQ1K0bwgbcD0PotcGY67Ge34XUhS9BOy+VRXUwtria/9VpQIeIyJWY5Cv4bNUH2H9xr0onM6LjSLSo1NpWgG7DBlU4yXL5kq19uvVWhPbpDvPiF2E5tR4wBcN05wQYb7qNH66HYJCQqBiYs/tX7Di7FSWDSqmcNXntTOaWlp6uklvHS0fTalVLVNTswcqV87YfcwrMG75G+tpxQHqSavz9OrwAY6vHoDP6F8qxE5HnVWGX2YMbT62DUW/EE22eQZda3dVj1tRUJMz7E/Hz5gHp6bZk+v3vgTHpL1gP/ATojfDr/p4tV2mmgiZERMXZleQrmLTuS/Xzo62fRNnQcnmeQagChBIcdFF/MvKFFxHYunWu96elJyF99ee2XNGaxVZI7vZPYajUKk/HRUS+6UjUYXyy4j1EJV1WBZj+1+UNVAqvjPSTJxEzfRrS9uxR25nq1EX4kMEwBiUhdfa9qlK6TCDx7z8N+tK5r7ROhY9BQiIPJ8HB2TtmwKA3qqpQYQHhhfI6UklUzR48eRIwGBB6330IvbMvdMbcNxMqyfWBhUhf+ja02FNqJNrQ+H6YZCSaeWyIfMaF+PMq/+DJmOMIDyiBkZ1fV0vqpI1I2bDeNqIcFaVGlIN79EBIz45IXzQc1gu7gcBI+N/zLQxV27v7bRARFShpAyVAGJ8ahzZV2qNzjVvzvA+ZReg8gzADvR5pRw7nOkhoObYaaX+PhBZzAjCY4Nf+RRjbPcMBXSLKldXHVmDSunFIt6SpVFjP3zwSgWlAzJQpKs+0KkAXGYnwhx5CYLv2sOybh5TZz6t0Bvrqt8D/rsnQBUbw0/YwDBISebDLiZfw5X+fQoOGwS2G4qbSBZ/DTzObET/3D8T/8QdgscCvalVEPP00/KpWy9N+rBf3Im3xGFhPrFG3JY+YX/d3YCjftMCPmYg81+7zO/H5qg/VSXCNyFr4X+fRKBlcyjaiPG0q0vbuVduZ6tVDiSFDoNedQ+rsfkBSFHRlGsD/3qnQh+dt9jIRUXHw78G/se3MZkQERuLJtsPzNVNachC6DBAKGayVx69DS4pG2rJ3YNk5y9Fnk9mD+gIqnkKFa9KkSepy/Gpl2AYNGmDMmDHo1auXup2SkoKXXnoJM2fORGpqKnr27ImvvvoKZcteqy5LdKOpsH7eNh1/7Z2jbvdt0B8DGz2A5OXLcf7XX6ElJKgCdKF39EFI377QmfyQvvIDmNeOV9sb2zwFvy6vQ6dnOMoT8Vsh8uDkr/YT7XZVb8Ztde4o+Nc4eRJXvppoKz+v1yO0Xz+E3n1P3mYPJkUhfeXHMG//STJe25Jcdx0NQ/27uEwwnyZOnIhPPvkE58+fR5MmTTB+/Hi0zmZWwLfffosffvgBu3fvVrdbtGiB//u//3Nsn56ejtGjR2PhwoU4evQowsPD0a1bN3z44YeoUKFCfg+RyOUMmX8OLsDUTd+oXIQdq3XCU+2eg19KeoYRZUNkSYQ9/DAC27aFedsPSP13NGA1w1DvTph6fwGdKYifLhF5nTOxp/DDlu/Vz8+0fwGh/mH5Tg2TbZBQp1NFTLJ9rgQR9/6JtMWj1cAMTCGqz2Zs9jCLBRQjlSpVUv242rVrq+90+vTp6Nu3L7Zt26YChi+88AIWLFiA2bNnq37f8OHDcc8992DNGttAPtGNSEhNwNj/Plar3fwMJjzdbgRaJZXC5ddft61IkwJ0rVsj/KGHYSxTBlpKHFJ/exzWw0sAgz9MvT+FsWF/fgkejEFCIg/149YpOHT5ACqGVcKwds8WaMBNs1iQMG8e4n6brWYPGitXVrkHTTVq5GEf6TBvmYb0/z4DUmIBYwCMbZ+BX9uneZJ/A2bNmoUXX3wRkydPRps2bTB27Fg1AnzgwAGUKVMmy/YrVqzAwIED0b59ewQEBOCjjz5Cjx49sGfPHlSsWBFJSUnYunUr3njjDRVwvHLlCkaMGIE777wTmzdvvpFDJcowqPH9xslYevgfVdHuoeZD0Kfu3UhetgzRv86CNT7eNqLc506E3HkndH56pC96BeZtP6q0BJIc31jA7RwRkSe1kbIyJM2Sqgo4NanQLF/7SV6/TlUwzpamIbhLV5cPWWNPI23RKFiPLFW3DTf1hF/PD6APLZ+vYyH36dOnT4bb77//vppZuH79ehVA/P777zFjxgx07Wr7XZg6dSrq1aunHm/btq2bjpq8wamYk/h4xbs4H38OJYNK46UmT6Pkn//h8vr16nFjpUoIHzwEAY0aqdvWqMNInT0EWvQR6ELLw9RvCgwVuMrM0+k0GX6gXIuLi1MjMrGxsQgLy98IINH1rDm+CmNXfwx/gz8+uP1zVC5RtcA+tPQzp3Hlq6+QfuSIGnEOubMvwvr3h87PL9f7sBxZhrQlb0KLOqxuG+r1hV/X17lEsABIYLBVq1aYMGGCum21WlG5cmU8++yzGDVq1PW/G4sFERER6vmDBg1yuc2mTZvUTMMTJ06gSpUquToutn2UndjkGHy66v+uVrQLUhXtGsYHI3baNKSfOJF1RDnxMlJ/Hwrr6Y1qFot/369gqG0raELkadj2UUGYse0H/LH7V1QOr4IPe4+FKR8V25PWrsWVCeNVYbmA9u2Rsm7dtdyEV69LPPkUgjt3zvA8zWqBectUpK/4wFZMLrgMTD3fh6FObw7MeAHp98mMwcGDB6uZhLIK5dZbb1WDwiVKlHBsV7VqVTz//PNqlqErsixZLs5tn/Q/ec5LzlXZx6/5VBWmq1uqHp6MbwTdX/9eK0B3730I7t4dOoOtwKblyFKkzn0aSI1TKQ387/mOOeqLCc4kJPLA5SiT19nyNUi+moIKEGpWKxIWzEfcr7+qxtxYoQIinn4Gplq1cr0Pa9QRpC19yzZdXEYZyjaEqfu7MFThqGRBSEtLw5YtW/Dqq6867tPr9Wp58Do5GcgFmTkoS4wjIyOz3UY6fDJjy7nzSJQfx6KP4KPlUtHukqpo91LT4QidsxyX1651GlEejIBGjdVt6/mdSP3tEWhxZ6GLrAH//lOZA4uIvNq+C7sxd/dsVeX9uY4v5y9AuGaNLUCoaQgfNAght/eG+b4BSFy+TOUglCXGMoPQWC5jpWTrxX1IW/gyrGe3qtuGpg/C1PUN6AqpCB4VnV27dqFdu3Yq/2BISAj++OMP1K9fH9u3b4fJZMrSx5N8hBJAzM4HH3yAt99+O8v9UVFRqn9KvkvmlP195C/8dciWf/DmwEbo+1c0dNEL1ACFvmNHGO/og5SQEKRcuaLaKeOOKfDb+CV00GCucw/SOr6OhBQ9kHLZ3W/H55UqVeq6nwGDhEQeJCU9BZ+t/AAp5mT0uOl23FyjS4HsN/3sWcRMmoS0Qwdtswfv6IOw++6DzpS7jqrkkkhf8wXMm75TucMQVEpVLDY0HgCd3jZaRDfu8uXLakQ4c2Jpub1///5c7eOVV15RuQYlsOiKdCZlG1minNNsaFcjykTO1h5fjYlrx6rlc03KNcVj8Q1gffNTJKemQhcUhLD+96rKxfYcp+Y9c5G24AVbRbsaneHfdxJ0gQxUE5H3SkxLxPg1n6sCdA80G4RqkblP62KXtHq1yh+tAoRDhiDkNltxCgkIhg98wOVzNHMK0v8bC/P6iarfJoMypl6fsGq8F6lTp44KCMrA72+//aZmEq5cuTLf+5MBakl3k3kmYcmSJbl6zofJrMGJa7/AhpNrYdDpcd/Fymiz8WiGAnTOxS619CSkLXgJlr1zAb0Rft3eQWCLIZy1XMwwSEjkQaM032yYgFOxJ1GzZG0Mafn4je/TakXior8R+8svavagoVx5RAwbBv86dXL5fAssO35B2soPbQmu9X4wthkGvw7PQxfA5faeRpJYSyU7yVMo+QkzkxmG9913n/pdk9w1OeGIMmVHipL8degPLDryl7rdNbgFes+9CEvUXNuIcvsOMPbpg5TQUKTExABWC/w2j4ffdlvC/vTGjyC99QgkJJqBRI4oF4cRZSLKnymbJuNS4kU0KNsYvevdlefnJ61aiSvy77UECB99FCE9el73OZaT65C2cKTKASYn6cb2z8Gv4wvQGbP2C6j4ktmCta6uBpKidZJK5ssvv8SAAQPUzL+YmJgMswkvXLiAcplmmjrz9/dXFyLH70z8eXy84j2cjDmOUM0fj6zTo0b0ZRgkcPyQrQCdcy5pyXuqVotc2A0ERsL/nm85MFHIzl6Ox+LNx3DxSiLKRASje8vqqFAq9Ib3yyAhkYdYfOhvrD62AsGmELx4yyj4GXKfI1CYz51D4orljmUn/g0bIv7335EmM9B0OgT3uh1h998PfS47AKqTuXiMraGXZa+1usN065vQl6yZr/dHuTtZNxgMqiPn7HodO/Hpp5+qIOGSJUvQuLFtaaerAKHkIVy2bNl1R4U5okyuJKUlYfyaz7D59Ab46Y144FI1NFtgm+Vqqn0Twh95JEMBJFXR7s+nbYnyjQEw3f4pghr244dLRD6RX3rV0eUINgVjeIcXoNfp8/R86dPFfP21LdfgY48huFvG3K3W6KMw7/gFWuxp6MIrwVD3Dli2/QTz9p/U4/oKzVSbqy9Tv0DfF3kmyWEtK0AkYOjn54elS5eiXz/bv7dS/O7kyZNqeTJRbuw6twOfr/oQCWnxqBRvxNCNekRY/BHar68qQJf5fNJycj1S5zymJpXoyjSwpZMpUZkfdiFasvkoxs3ZpAK1MgFErn9ftQ/P9WuNbi2q39C+GSQk8gBHog5h6qZv1M/PdXwJZUIyLjfNdUfSnsBaytP/+ae6NpQpi4hhT8G/Xu46idbYU0hf+i4s+22zhHQla8PU/W0YCmjpM+U8KiydO+nY3XXXXY5On9wePnx4ts/7+OOPVWW7f/75By1btsw2QHjo0CEsX75cLR25Ho4oU2ZSye6j5e/idOxJhGsBeGSNHtWiz0EfEYHwBx9EYIeOGUeUM1S0qwBT/+9hKM+KdsVxRJmI8iYq8TK+3TBR/fx4m2dQKrh0np6fuGwZYr79xhYgfPwJBN96a4bHzTtmIm3hS6o6PGDr95nX2QqewS8Ifp1GwdjyUaaE8VIykNurVy9VfC4+Pl5VMpZVJNIPlAKbQ4cOVUuHJT+1DApL8TsJELKyMeUq/+D+vzB983ewwooWZwwYsNOE8NbtEPbgQzCWztqWpW+djvR/R6vUBoa6fWC6Yyx0piB+2IXc35MAoZz22+sQ26/H/b4R9auWuqH+H4OERG4Wnxqn8hCarWb0azQAzSu2yvMMQvtIsz1A6CzypZdgqnr94idaWhLS102AecMklTMMAeHwu/llGJsPhi6Psxop/6RTJ3llJNgnFYjHjh2LxMREPPLII+pxqVhcsWJFtRxYfPTRRxgzZozqIFarVs2RlFqSWMtFAoT9+/fH1q1bMX/+fJXz0L6NdB4lMEl0PTvPbVcjyolpCagS74ehG3QIt/ghpG9vhN51N/SBgRm2txxeitQ/hwGp8axo5wUjykSUt5QME9Z+rvIR3lKjCzpUuyVPH1/ikiWI+e5bNfCrqhV36ZJlBqEKEGpWl8833fcjjFXb8yvzYhcvXlT9wXPnzqmgoKwgkQBh9+622aZffPGFKnwnMwlldmHPnj3x1VdfufuwyQOdOrIdi9fNwOXUKET6RyIqTI/NsXug04A795vQ3VwDEa8/Av8GDbI8V7OkqeCgeduPasDCr/OrMLZ7lvkHi8DfGw5Dp8rCZD33l/tlwHjwbVlXluUWg4REbu5ISkJryVfTqFwT3NvYdQLq680idJ5BmIFej+S1a3IMEsrJpGXPHKQvfx9a/DlAp1eBQb9bRkIXdP0ZZ1SwJJfMpUuXVOBPgnlNmzbFokWLHMVMZLmIdPzsJLeg5J6RQKCzN998E2+99RbOnDmDefPmqftkX85kVmHnzp35FVKuR5RbnjZiwC4/hDZtgfCHB8FYvnyW7SVRfvry/1OzWwxNH4Cpx/9BZ2Seo+I8okxEubdg35/YfX4nSgeXwaOtnsrTR5fw77+InfK9LUD41DAEd+qUZRvz1unZ70BngPXocoBBQq/2/fe2HL/ZkbzUEydOVBei7CyaPx5Tov9RAUHNT8YdLgCxgNEMPLa3BNp0fxjBt3aDzpC1SKWWcEktL7ae3giYQuDf9ysYamdMiUA3zmrVcOFKIo6fj8GxczHq+vi5WJyLTsjxebKi5EYwSEjkRn/sno1tZzYjMqgkRnQcCUM+KgVLDkKXAUIhAUB5PLvnnt2O9MVvwHpms7qtr9oBpu7vQl+mXp6PgwqOLC3ObnmxLCdxdvz48Rz3JbML7cECoryOKEeX8MOmKztVB7LvPhO6pVRGiZFDENCsWZbnZqlo1/1d20xkpyXIVDj+3Xy0UEeUC4qcsH7yySdqAKRJkyYYP368mjGdndmzZ+ONN95Q7Vzt2rXVzOnbb7/d8Xh2v1uSgmHkyJGONlBysTqTmdijRo0qsPdFZHfiyjHM2DZd/d092+FFlY8wtxL++QexU6eoAGHEsKcRdMu1GYjW+HOwHPwXlkOLYD22KttZhDI4IzkKiYiu19+TAKEm80yc/ynVAIsBqD14OEIatnX5XOv5nbYCJXFnVeV0lX+w1E38wG9QYkoajp+PxfFzMTh2NRh44kIsUtLMWbb1M+iRbsnu3wGolDM3gkFCIjfZdW47Zu34GQadAS/ePArhgdcqkOWlerH5/IXsg4Q6nSpikuV5CReQtuIDWHbOsm1Wogr8bn0Thpt68YSeyEe5HFG+cnVEeXcYWnceiJBevaAzZu06sKJd0ZHO4gnpRF6wdSBlVHn/yShYcxgMuNER5YIwa9YslU5h8uTJaNOmjUqlIEvgJKF+mTJlsmy/du1aDBw4UAX07rjjDpVSQXK1SuqEhg0bqm1kqZ2zv//+W+Xisifrt3vnnXfw+OOPO26HhnJWJRW8NEsavvzvU5U+5u6G96JeWdvvaW4k/P03YqdPswUInxmOwA4dYL24XwUFLQcXwXpux7WNdYYMuQgz0qkiJkREOZEBYdXfyzzWpgN0VmDJ9jl41EWQ0LznD6QteFGlptLX6AL/uyZBFxDODzsPLFYrzkUlZAoIxuBiTFKWbfU6HSqVDkW1ciVQrXwJVFfX4UhPt2DYF3+7DAHIgLHkpL4RDBISuUFU0mWMXf0JNM2Kh1s+jjr5mLmnpaUheuIEpB89ksNGGoK7dL1205wC88Zvkb72SyAt0ZbcusPzMLZ+HDpjQH7fDhF5+YhyrcHPILRxB5fPZUW7wl9iYutE2gKC56MTsh0XKqwR5YLw+eefq0CdPb+qBAsXLFiAKVOmuJzV9+WXX+K2225zzAh89913sXjxYkyYMEE9V2Su+v7nn3+iS5cuqOFUYdseFLxehXiiGzVj63ScijmB6pE185Q+JmHBAsT++INKERM+oAeMKYuRMullaDFOM2ADI2Co1Q2G2j2hi6iG1Ck9shkg1mBskvfUNUTkW2TFiJZNJEi7+niG+6wWpK/4QKWUEca2z6gchLp8rILzJfFJqSoY6FgqfN42OzAt3ZJl29BAE6qXL4Fq5cJtAcHyJVC5TBj8/Vx/UZJzWlLKqFUV2rUAodx/oylmGCQkKmIywvzFqo8RlxqLtlU64Pa6d+Z5H5b4eER/+gnSDhyAPjwcwd26IX7OnGu5Ca9eS8JrY7lytryDBxchfenbjk6nodF9qnHXh/LEicjXXW9EeenOP/GoiyBh+tYfkP7v66xod4MSktNsswPPX3+JSZC/nxpFrlo2/GpnsgRMRgNemPhvoY0o3yjJm7plyxZVkdNOcqt269YN69atc/kcuV9mHjqTmYdz5851uf2FCxdU0HH69Kz52j788EMVZJRKoA888ABeeOEFGF3MiBWS5F8udnFxcbl+n+S7dpzdhgX7/4TJ4I8RHV+GXy4LvsXP/R1xM39VbW1wjePQ73kN9r96XYmqMNzUUwUG9ZVbQ6e/9jtr6v25bTaPY0ah7Vru10eyUBER5ayUf0noLBeymY9se9xOS4lF6txhtnynxgDVzhgb3M2P2InFYsWZy/FXg4G2/pxcLscmIzODXqf6cPZgoPTjqpcLR2RYYJ5W9ElROsk5LSllZMWIDAhLf68gclAzSEhUxH7aOhUHLu1F+bCKGNZuRJ6X95ovXkTUhx/AfPYsjBUqoOSoV2EsUwZBN9+CxOXLVA5CWWIsMwglQCjLVdKWjIH1+Gr1fH3FFipXmKFC1pxiROSb8jyirCravQHzth9sFe06jYKx/XNMV5DLTqS9A2nvTF6Ozc0SE+lQlkDpEkEuP+fCHFG+UZcvX1aV1e0FmOzk9v79+10+R/IWutreXp09MwkOyozBe+65J8P9zz33HJo3b66qucsSZglUyjJlmdnoiixvfvvtt7PcHxUVpYKdRJklpCVg/H+fqZ/vqXMf/NMD1e98tpIuw3ByJSxLliFV/fpbEVx5P0xBl2Ep3RCWql1gqdYFWkQt26CviI7JuI8Kt0J3318wHpgDXfxZaKEVYK5zD5LCq8gfHL+kXChVqhQ/J/JZ3ds9gEVrRl8bY7C7OmDco/2D6qb18kFb/sHoo9CFVoB//ynQl28CXxabkOKYHagGds/H4NTFOKSbs+YILBHin6UfJ7MD/YwFMwNT+neFkXOaQUKiIrT+xBpV9U5Gml+65VUEmYLy9Py0I0cQ9fFHsMbGwlSnDiJfHgnD1dxKelMSAssdgxZ4GrrwBOgs55C26EvbSbxmhS6kHPy6joahwd3Q6a5VxyUiytOIcuJlW0W7UxtURTtT34kw1u7BDzGTGNWJtM0KvF4nMixYOpG2zqPqRF5niUlRjygXB7Js+cEHH1RVPZ05z0Zs3LgxTCYTnnzySRUM9PfPWnVbgojOz5GZhJUrV0bJkiURFhZWyO+CihtZqTFt1TeITY1Bs4otcU/z+1wG8a2XD8Fy6B9YDv4D65ktSL5YCannZcafFSGtDQjq9DIMN/WAPjRjxfgcSZCrZvOCfUNE5BMq12yKR/ffhilRi9SKEcd8ZB3waMnbUKlGE1gOLUbqn08DaQnQV2oN/3u+gy4ka657b5VutuD0pfgMg7ry85X4lCzbGg16x1Jh+yoPuUSEFs90XgwSEhWRs3Fn8NW6sernJ9o8jaoR1fL0/OQtW3Bl3JfQUlMR0KYNIp8ZDp3JpB4z75iJtIUvOS070WBeN8H2RIM/jG2Hwa+dbO/+vFREVIxHlM/vQupvQ2wV7SKqw//eaT5f0U7yypy6FKfyBh6/YEtCLR1JCRLm1Im0dyCrlw9HiZCAApmFWVgjygUxY8dgMKglwc7kdna5AuX+3G6/evVqVQBFiqNcjxRNMZvNqmJynTp1sjwugUNXwUMiV1YeXYYNJ9cizD8cTzutDpH8XRIMtAcGtehr+aOTo2oj5Xx5lYMw4tlnENTuWhVjIqKiclvv4Wh49Gb8u/ZntWJEBoSlv1exemOkr/kS6Ss/suU5bfYw/Hq8B53Bdt7pjYM9Eviz5ww8du7awK7FmnX4XJYFq2Cg0wzBiqXDVB/PWzBISFQEUs0p+GzlB0hOT0a32rehU81b8/T8xCWLEfP99yrPYEjv3gh78CHo9LaGyBp91BYg1FyXQTfdPwPGqu0L5H0Qke+OKJv3zEXagheuVrTrDP++k6DLR1X24tyJlNwy9jwz9hmCsnxYioxkVlJ1Im1V6OwzBL2tE5lbMnuvRYsWWLp0qapQLKxWq7o9fPhwl89p166devz555933CeFS+T+zL7//nu1/yZNrr8Eavv27SofoquKykR5cSH+PL7faCui81S75xBuDID54D+2wOChf4Gka2kadGEVYLipF5JPRCBl50bAaETkCy8isEULfuhE5DYVSoTioYrh0GLjoQsPhyHYiLQ/noRl/1+A3qiCg37NB3vUN3T2cny+V03IwO7JizIj8NqgrvTl4hKv5SK28zPaB3avFRORn8ODvX8gkUFCoiI4sfx2w1c4GXNcVbx7pNUTeXpu3MyZSPhzrspLEz54CEJ69cqwjXnrj9nvQGewJZllkJCI8juiXK0h0pa/75idbGz7NPw6v+bVFe2SU9Nx8kKcIyCoKgufi0FiSnqWbU1+BlSrYO882mcIhiM0yPs7kXkhS3gHDx6Mli1bonXr1hg7diwSExMd1Y4HDRqEihUrqmXAYsSIEejUqRM+++wz9O7dGzNnzsTmzZvxzTffZNivLAeePXu22s5V8ZMNGzaoiseSr1BuS9GShx56CBEREUX0zskbWawWjF/zOVLMybg1sjYab5iM5KMr1CCKna5sQ1V0xHhTT6BMAyT89hsSlv6uAoQlX3oZAc2YG5qI3CfrSjTdtZVoQSXhf8+3MFTJOjDnTks2H8W4OZvUrG05T5br31ftU/mXJe2KnTwWFZd8rarwdQZ2S4UHZVkuXKFkCAw+OLArGCQkKmRLD/+jlqMEm4JVHkJTLqdqa2YzrkyehOT//gP8/BD57LMIbN3G8bj14l4VIDRv/ynbWYQqbX3s6QJ6J0Tk7WTG4KM1rs3G0lLikDp7MKxHlqrUBaben8LYsD+8hXQUz0cnZKhEJx3Jc9EJLrcvFxnsWCYsMwRlqUnZyGAYrs7spuwNGDAAly5dwpgxY1TxkaZNm2LRokWO4iQnT55UM/zs2rdvjxkzZmD06NF47bXXULt2bVXZuGHDhhn2K8FDORkYOHBglteUZcPy+FtvvaUqFlevXl0FCTNXTSbKC2v0Mfy+fgIORB1A2fQUDNj5KyzSD9Mboa92swoMqvyC4ZWvDfjOmoWEuX+o/pwKEDZtyg+diNzmuivR7va8AKHMIJQAoSapcOR/V9tXIYXbouKSEBOf6lg2nJCctdiYv58BVa8O7NqWC9sGd0MCvXMpdX7pNPsnS7kiI9bh4eGIjY1lAmu6rqNRhzF60UikW9MxqssYtKjUOlefmjUxEVGff4a0PXugDw1VBUr869SBlp6spn9LcNB6ZvP1d6QzqHyEpi6v89uiG8K2z3c6jeYdv9gGF0zBsBxbBcSegi60PEz9p8BQ3vNObHO77EQ6i/YgoD0geOJCHFLSzFm2DQ7wc8wIrHo170yVcuEI8vcrondFnoJtn++1fbrwSjA2GQh9ZA31mKZZYT27HZZDi1R+wcNxp/FembrqsdHRJ3BTlfYw1LkNhhpds6RgUAHCX35Bwrw/bQHCl0ciIBfL4gt7yR3R9bDt825qhcj6SYBmKTbnj9MX7cSc1ftdzgR0pWxEsGOVh8wO5MBu7nEmIVEhSUhNwGerPlABwrsb3pvrAKH58mVEffgBzKdPw1CmLEqOGgWDKRFpS96EeeevQEqMbcPg0rZObLVbkPbLfdmMBGkwNnmgYN8YEXn/shPVntg6YVKgJODhudCFeF4Ot+yWnTzYrSHKRYZkmCEo+QQz0+t0qoqwcyERGVUuHR5UIIVEiKiYLrlb/xWMLR8D0pNgObwYWoKtiE6qTo+vyzeCVafDvZXbo+EDc6Azuk4toAKEP/+MhPl/qUJzkSNHIqBR4yJdckdE5LJ9UivNtGKzEk2KiGzafzbHAGH5kiG4q2MdFRCsWjYcQQEc2M0vBgmJCoFVs2LC2s9xMeECGpRtjAFNHsrV89JPHMflDz+E9coV+NWogRJ3NYFl2bNIP7nWsY0sZTE2G6SWsjiqTPX+HGkLXszQwZVrU+/PoY9kZ5GI8r/sRIs5AS0tMUPRY09fdvLT4t1ZtpdE0xmTT4erAKG/H7tCRL4qp7bPvOla/ktd6bpqGfGP1lRcOLMJdUrXQ79bXsk2N6u0RbE//ojEhQtUgLDk/16Bf6al8oW15K5+1VKcUUhEOZIZ07bzRZePXn3c/YHB/3adwppdp3DiQmyO28qgb4eGlXF721pFdnzejD1jokLw557fseX0RkQERuL5m0fCkIsE/yk7dyL6i8+hJSfDVDUUQSXnw7xkmu3BwAgYG98PY7OHHMtfnBkbD4C+UmuYd8xwWirzAAOERJQrsswup86itC2etOxEOo4T/rCdJGdHRpFvbVHNMUMwIjSgKA+RiIp92ycDsx1h6vUJ9BHVsPnUBixZ8S4CjIF4tsNL2fbtVIDwh+lI/Ptv6Pz9UfKVUfCvX7/AjnnB+sM5Pv7L0j14qm9zBAcwxxYRuSar0WTGtGvuW4mWXWCwZFggmtQsg+XbT7js+2nQVMoFKhgMEhIVsD3nd+KX7T9Cr9PjhZv/hxKB16+gmLhsKWK++1amIMK/5FkEhh2GLhXQV24DY/NBMNS5HTpjzie4MmPQk07iiaj48PRlJ3LSffJCLP7bdRprdp9SncjrjShLkPDum215w4iI8tz26fTQBZVSAcKY5CuYtG6cuvvR1k+ibGi5bNuq2GlTkfjPP7YA4ahX4V+v3g1/+BaLFdsOncfSrcdVG5jdAIncv2L7CXWRfFyy7K6GzJyW6woRKFOCqRSISM4ba6gVZ56wEi2nwGCHhpXQsXEV1KlcEnq9Do1qllUzplVKGO1agFBSLTAna8FhkJCoAF1JisYXqz9WSa4fav4o6pXNeWmJJeYU4r7/DEmbzqnbgeWOwr9SHPwaD4Wx2cPQl67D74eIfHLZiZxsHzsXgzW7bYHBM5fiHY+VCg9EiZAAHD17RcZWXJJE/kREN9r2SVskAcK41Fi0qdIenWvc6rrNsloRO3UKEhcvhi4gACVffRX+dW5soELyqUpgcOX2E7gSn2I7qhxyP8hDpUoEISXVjAtXEtVl/d4zWYoyqST+KnBYAlXKhMPkd/0VL0TkXdy5Ek0CgxIU/C8XgUFnknNVUiqwaFPhYpCQqICYrWZ8sfojxKbEoHXlduhT/26X22lWC6xHlyNt83QkrDqJtOhygM6KkEZpCO79Egz174TOL4jfCxH53LITORk/fOaKCgqu3XUa56ITMgT9pOMoOWdqV4rE+egEPPX5wmyOmMtOiKhg2r7Fh/7G1jObVAqZJ9sOd1nUSAKEMd9/h6SlS6ELDLTNIKyTv4He2IQUrNxxEku3HsPRs1eL1QGoVTECtzavjpsqR+LlSUtczybUAe8N7awS+EfFJavnHzsfg2Nnr6hBF2lT9xy/pC52chJeqXSoqvxpCx5GqGumaCDyfkW5Eu16gcEOjSqjbpVSWQKDmcmMwcG3FUwRKHKNQUKiAvLLth+w7+IelA0tj6fbP5+lEymV8czbZ8C8/WdYr5xHwsl6MMeXg86kR8QTDyOw4x38LojI55adSKW6g6ej1IzBtbtO4WJMkuOx8pEhaN+oEjo2qoyaFSIytKvSSZTlJVx2QkSF1fadMxgxffP3attn2j+PUP8w1wHC775F0rJlKkBY6rXXYKp9U56OI91swcb9Z7Fs63FsOXAOlqtTpCPDAtGlWVV0bVYNVcqGO7bPTdtXKjxIXVrXq+B4XnJqOk6cj8XRczEqaCgXma148kKcukhw0k6ChCpwWKGEupblyhVKhsBg0Of1YyYiH1VQgUEqWjrNXg6LciUuLg7h4eGIjY1FWFjWjgL5po0n1+GTle/Dz2DC/932KapdLS4iy46tx1fDvPUHWA79C1jNsKabkHC6JSzxRhgiI1Hy1dfgV7myu98CUY7Y9vkGa/SxIll2IoHB/Scvq47j2j2ncTk22fFYxVKhqtMonUeZzeJq1k7mSp9cdkKFhW2f77Z9lvBKeH3RyzgWfQS3170Tj7R6wnWA8JuvkbRiBXRBQSj12usw1cpddU05BTt0OlotJ1694yTik9PU/bL0t139iujavDqa1CoDg15fqG2fxWrF+ahEHD1nm21ov8hMxMxMRgOqlgu3zTh0CiAGBfjl+XXJs7HtoxsNDMqqkOPnGRgsjhgkzCM2mJTZubizeGXh80hOT8LT7UagS63u0BIvw7xzFszbf4J25bhtQ2MAtAq9EbcmFdYrcfCrVg0l//eKChQSeTq2fXSj5ER07/HLWCtLiXefRvTV/FqiStkwtYxYAoMyW+Z6gUGiosK2z3fN2PYD/tj9KyqHV8EHt38Bf6N/1gDh5MlIWrUSuuBgW4CwZs3r7vdybBKWbzuBZVuP4bRTrtUG1Uqja/Nqaua0JwTdYhNTcfxqwNAeQJSTf/ssR2flIoMzLFWWYimlWSSlWGPbRwURGJTZ0B05Y7DY4XJjohuQak7FZ6s+UAHCrjW74xa/YKTOfRqWAwsAi21EWFfqJhibDYLFrxGix0+GlpgI/8aNEfnCi9AHBvLzJyKvJRU5dx+7pDqN6/acRkxCquOxauXC1clw+4aVUbkMZ+YTkefYd2E35u6eDaPeiOc6vuwyQHhl0ldIXr3aFiAcPRqm6rZVJK6kpJmxfs9pNWtwx5ELjnyCUoFYAoNyKRcZAk8SHuyPJrXKqovzsmgJBjgvV5bL+ehEdVm3J2ORFHuBFPuFRVKIvAcDg96LQUKiG/D9xsk4ceUYqvqH4YFdvyF1xYe2BwwmGBrcA2PzQapqVPK6tbjy5ZeA2Yygzp1R4rHHoTPyz4+IvI/ZYsXOIxdUjkEJDMYn2QZMhOQV7NCoEto3qIyKpfO+LI6IqLAlpiVi/JrPVY6/B5oNcqSQsdMsFlz5aiKS16yBLiQEpUa/AVO1ai7TKkiBEMkzKDNsktPM6v5Af6MaIJEiJPWqFq9cXH5Gg8pNKBfnZdOSMuLY1dmG9gDiuagENUgkFzt5r5VLh2UJHkq1esq9Dz74AHPmzMH+/fsRGBiI9u3b46OPPkIdp2I558+fx8iRI7F48WLEx8erx15//XX069ePHzXl2+lLcfhvJ2cMejtGKYjyQTpESzd/i+VHFiPIasEzx9bAz5IGXUR1GJs9DGPj+6ALKqm2S5j/F+J+/lk9L7R/f4T268+ldETkVWR2yfbDEhg8hQ17zyLham4tcVOlSJVjsH3DSh43U4aISJyLO4NlhxfjUuJFnIw5oa4blG2M3vXuyhognDgByWvXQh8aqmYQ+lXNGCCU4JgEBpdvO44LVxLVfXqdDs1ql1MzBtvWr4gAk/ecgkl6CFlaLJfW9So67k+6WiTFvlxZLV0+H6uKF8hlxfYTjm0jpUjK1aXK9kuFUiHZ5mP09dy0K1euxDPPPINWrVrBbDbjtddeQ48ePbB3714EBwerbQYNGoSYmBjMmzcPpUqVwowZM3Dfffdh8+bNaNasmbvfAnmI3PztSGDQXnwk81JiSRMjgx4sPuJdmJMwj5ifwTdYo4/CvOMXpwTWA1UFPC01Hubdc3Bk+494x2hCul6PEVHH0KpKBxUc1FfrAJ1O71iKEjttKhL//RcwGFDi8ccR3LlLoR2zr3WQvNnEiRPxySefqFHgJk2aYPz48WjdurXLbb/99lv88MMP2L17t7rdokUL/N///V+G7SVY/eabb6ptpcPYoUMHTJo0CbVr1871MbHto8zS0i3Ydui8Cgxu3HcWiSnpjsfqVS2plhG3b1BJtUdExRXbPu+3/PBiTFo3TgW75N9L+U8MajEUferf7dhOM5txZcJ4JK9fD31YmJpB6FelinosMSVNnUBLcFByr9pJKgUJDHZpWhUlw4Pg6yQ3rQRR7cuUj56VwGEMol0VSfEzoFrZq0VSrl6qlS+BIP+M+RqXbD6KcXM2Ob4/+7VUeu7WouALb3miS5cuoUyZMip4eMstt6j7QkJCVF/v4YcfdmxXsmRJNePwscceu+4+2fZ5v5z+dupWKcnAoA/znmEsogJi3jETaQtfkhi6dAnVtXn9ROgqtYF2ficSzakYX7auChD2Ca+GDndPgS6kTIZ9WFNTcWX8OKRs3gxdQIDKPxjQpEmRNvK/r9rnUx0kbzFr1iy8+OKLmDx5Mtq0aYOxY8eiZ8+eOHDggOoAZrZixQoMHDhQLTUJCAhQnT8ZTd6zZw8qVrSN6H/88ccYN24cpk+fjurVq+ONN95Q+5QRZ3kOUW4HGySv1taDtsDgpn1nHcvnpM6IJN2X2YJyKcWTYSIqJjMIJUCoQoP2RIFX/bhlClpWaoPyYRVUgDB63DikbNwAfXi4ChDqK1bE1oPnVJ7B9XvOIM1sUc8LDTShU9Mq6NKsGmpXiuTqEScyM7BS6TB1ubmxLcAqYhNSVLDQHjg8ft5WJOXg6Wh1cVY+MkQFC6U4iuRNnDRvi8rxaP/+7Nfjft+I+lVL+cSAeWysbXZXpFMxROkXSp+yd+/eKFGiBH799VekpKSgc+fOLveRmpqqLs5BQvLu/p6cO7r62/nyt40ZtuWMQd/DmYR5xFEV759BmPL1zTIN0OXjGnQYX7UttljTUK9MA7zZ/f9g0BsybGOJi0PUxx8h/fBh6CMiUPKVUS5z1RRkI//U5wsdSbCdyYn75Bdv94kOkreQwKAsH5kwYYK6bbVaUblyZTz77LMYNWrUdZ9vsVgQERGhni9LTeQf/AoVKuCll17Cyy+/7OhMli1bFtOmTcP999+fq+Ni2+e7I8rD7myBkCCTyjG4ef9ZpKZbHMvnGla3BQbbNaikOpFE3oZtn3f7ees0zNs7B1YX/T69To8769+DBxo/hOgvxyJl0yYVIEx/+gUsO5uG5dtPOGbAGfQ6tKxbAbc2r4aWdcqr3H1042ksTl6Mw7GztlyHslT56NkrGWat50T+jbrnlroYfFtjr/4qpJ945513qpUi//33n+N+uT1gwAD8+++/MBqNCAoKwuzZs9VAsitvvfUW3n777Sz3Hz16FKGhPI/wNrNXH8aiTSdhdXUCCcDfz4CbG5ZHq5vKolbFcPX3RN5B0g9cD2cSEjmRJca2GYSu6PBP3duxJfE8wgNK4IWbX8kSIDSfO4fLH34Ay4ULMFaqhJKjXoUxF3+IN2LemoPZPibt/tjfNqpOq5zAlwwLVNdhQf7FKlG2r0hLS8OWLVvw6quvOu7T6/Xo1q0b1q1bl6t9JCUlIT093TGafOzYMbVsWfZhFx4eroKRss/cBgnJd0eUv/pzi2M7aTea1iqrcgxKXi0mmyei4kxyD2aeQWgn916MP4/oL75AypbNSAsOxU81u2HjzJ0ZijHJcuJOTaognMU3CpQEWuXzlYvjO9E0XIpNwjFZpnwuBos2HkGUi6XKdjIr3ttJbkJJOeMcIBSyakQChUuWLFFBgblz56qchKtXr0ajRo2y7Ef6nrKSxXmARAapZYlyWFhYkbwXKjoJKYccqRUyk3hg63oVMOK+9vxKfBSDhEROJAehrVuY1X7/EMxKPK9yDr5wyyuICLo2pV+kHjyI6E8+hjU+Hqb69VHypZehv5o8uKBJPhepGrp292kcOBWV47b7TlxWF2dGgx4RoQGOoKFcO/9svw7MlPeFCtfly5fVTECZ5edMbksFu9x45ZVX1MxBe1BQAoT2fWTep/0xV7jsxLfIEmP7zEFXykYEY0DX+mhTryLCgv2L/PiIiApD6eAyTullMtEAv+2HkbIlHjGGAHwe0RYXr2iq/9S5aVU1AFu1XAl+MUVI/p0qUyJYXdrUr6hmts9ZvV9VknbF23PiDh8+HPPnz8eqVatQqVIlx/1HjhxRK0okeNigQQN1n+S4lgCh5L2WlDaZ+fv7qwv5BvnbyK7fp4MOZSNYaM6XMUhI5ESKlLiaSRijN+KrktUhi1EebDoIDcpmHIFL3rgR0ePHAenpCOzQARFPDYPOr+ACbNKAn7wQi7V7zqjgoIye2vkZ9Ug3W7MdCWpYvYxK9iwjrbIsxn59KSZJXXIS6G/MFEgMQmRYQIZr6SxL0JHc78MPP8TMmTNVnsIbzTX4wQcfuFx2EhUVpWY8knc5dT462wChtCPVyoSgWbUwpCXH43JyfJEfH7l32QmRt2pQsj3+0H5TPzuvppPmUAcrOu6IxRVDECZU6oy6TetiWPNqaFarLAzs93gEyZsrObhdkVlS8rg3kn+vJQ3NH3/8ofp8km8686oS+2oUZwaDQS1PJvLVvx3KHQYJiZz/IJoMhHn9Vxk+E8m+NalkDcQa/NCybCP0bdAvw+MJi/5G7PTpqkcZ0rcvwgbcD12mf5Tz2wE4dDoaa/ecxrrdp3E2KsHxmATmZKmf5AKLDA3E8C8XucxJKIbf3TJLTkLZd1xSGqLjkhAVl4KouCREZ7lORkxCKk5fileX7EinOjw4wBE0dDUj0bbE2cTk3bk4WZcO3IULFzLcL7fLlSuX43M//fRTFSSUZSWNG1/Lv2N/nuyjfPnyGfbZtGnTbPfHZSe+pXK5SGw6dDHbEWV5nMEkIvI2O/alwHK+PYzl1kLn1PxJvPD+nSb4pYfg4uBh+PTmpggJNLnzUMkF6d9KkT4pUiKzouwTQiXIIfd7a05uWWI8Y8YM/PnnnypfoH1liKSTCQwMRN26dVGrVi08+eSTqn8oS4ZlufHixYvVzEMiX/3bodxhkJDIiT6yBky9P8fJf17FqqCSuGw04bLBhCP+wShjCsHwzq87Al2a1Yq4n39GwoL5KlIW/uhQhGSTDDi3LFYr9h6/rJYRr997GpdjkzNMC1eVQxtUQp3KJTPkFMxrIy/bSUU4uVS/FjfKwmyxIjo+4wxE52v7zzEJKeoiFemyIzMeJaDpKoDovNw5wGQs9AqtnspkMqFFixZYunQp7rrrLnWfjPjKbVlSkh2pXvz+++/jn3/+QcuWLTM8JqPLEiiUfdiDgpJnZsOGDRg2bFi2++SyE9/CEWUi8kXST2h9yoCe+wOxobIZVwKtiEzWo+0pIwJT/LG06wA83aO1uw+TctCtRXVVxbg49vvya9KkSeo6c6XiqVOnYsiQIfDz88PChQtVwbs+ffogISFBBQ2nT5+O22+/3U1HTZ7GF/92yAuChJIz4ZNPPlGjI5JHYfz48WjdOvt/qKVikyRpPX78OGrXro2PPvooQ0M4Z84clYNBCgNER0dj27ZtOc6kId+0OigSk8o1gO5qOlf7wHLnunci2GTLz6ClpeHKVxORvH49dP7+iHhuBAJbtMh39bYdRy6qZcQb9p5BbGKq47HKZcJUULBdw0qoUb5EtjPxCquRl2XE9twvOUlKTc8+kBib7Ag0XriSqC45CQ7wyzaAaP9ZiiVkt9THVYVWmU4vAVP5nDydJI0ePHiwCvZJezd27FgkJibikUceUY9LxeKKFSuq5cBC2rkxY8aoEeVq1ao5RpNDQkLURd7/888/j/fee0+1ixI0lHZS8hbaA5FEHFEmIl9U1ZCKdpe2Qg897jxwbaagrf+XjlJhN5a6g4ru3zBvr2LsLLv0IM6kz/f7778XyfFQ8eVrfztUzIOEs2bNUifLEtSTKpxyotyzZ08cOHAAZcpIkuGM1q5di4EDB6oT5zvuuEOdMMsJ8NatW9GwYUO1jZxod+zYUVV2evzxx93wrsjTnYs7g0nrxqnwYOZ/fmfv/AUdq3dGWX0Yoj75BGkH9kMfFoaSr7wCU81aeXqdlDQzthw8p5YRb9p/TgXZ7GpVjFAzBtvWr6SChMWhkQ/y90NQaT9UKp398UpS6bikVJcBRMd1XDLiElORmJKOUxfjst2XXqdDiRD/LMFEuf/HxbtcVmiVmZYSSPX00bEBAwbg0qVLKvAnAT8ZyFi0aJGj8MjJkycz5JiR0WTJEdi/f/8M+3nzzTfx1ltvqZ//97//qfbviSeeUJXupB2Ufd5o3kLyLhxRJiJf0yH+OCwuCpfIPVbo1ONERES+RKflZijCDSQw2KpVK1WZyb7kTsqwS5JWmTrt6sRaToKd8yy0bdtWnWBnruAkMw1lNk1+ZhLKMj3J9xAbG8ty8F7o563TMG/vHFi1rEl99To97qh2G3rMOQTz2bMwlCuPUqNGwXidXHF2Cclp2LjvrJoxuPXgeaSZLY6cfvWrlka7BhXRrkElr6/ElpuZldHxKYiKTcr2WoKJUtEuLySAeM8tdTlalk9s+4jIF7Ht827R475E0rp1ckKU5TFNp0NQu3aIfG6EW46NyJ3Y9hH5Lo+cSSizYmRJsCTOt5OZM926dcO6detcPkful5mHzmTmoSRpJcqtS4muE/cLuf/0xuUwn9XDVPsmRI4cCUNYzjP9rsSnYMO+M2rG4I4jF2Cx2vZt0OvQvHY5tYy4Tb2KqhAJ2fgZDSgbEawu2ZHvQmZfZp6JuGTzsQwFXjKTpdhEROQdaWQk95bk2Mrc95OZ0naSXkYGmP/66y/Vl+zXrx++/PJLlY6ByFC69NV8zi6KNul06nEiIiJf4pFBwsuXL8NisTiW19nJ7f3797t8jnQ4XW1vz8+VX6mpqeriPKpC3qt0cBlHLrvMdFYNEbFmBLTuiMjhz0JnMmUbiJLZguv2nMHeE5cc/U6TnwGt65VTswVb1a3AKnk3QL6j4ACTulQpG+64PynFjDmr96ulza74+ixNIiJvSiMjbrvtNpWs37nokrMHH3wQ586dU1U909PTVX5XSb0g+yMK7twFCfPmuf4gNA3BXbryQyIiIp/ikUFCTyKd07fffjvL/VFRUWrGI3mXZiVb4k/td1tqGucaIZLjTgd0qNAR1rsfRlSmYPG56ERsOXQJWw5dxPEL8Y77A00GNKlRCi1uKoNG1UrC38+g7k9JjEMKJ7UVuBY1S+D3VdnMBIWGljVLqEEIV0qVKlXwB0RERMrnn3+u8kHbizBJsHDBggWYMmWKyzQyMttPAoAjR45Ut999910V6JM0NM5pZCQoKBXcXdm3b5+aVbhp0yZH5XeZvSizET/99FNVwIl8m7F8eZR48inEfD3Zlv9FRnavXsv9uU0pQ0RE5C08MkgoJ+sGgwEXLlzIcL/czq4jKPfnZfvckiXPzsuYZSah5EYsWbIkcxJ6oRLp6bh/hwkzG6dCZ70WK5QA4f07Taj38oMwlimjZhoePRejlhGv3XM6Q5GNsGB/tK1vyy/YpGYZtXyWiobE+Z7rZ1FFSmzLh64FCKW6cYPaVfhVEBF5URqZFStWqJmIERER6Nq1q6rkLn00+z5KlCjhCBAKeU157Q0bNuDuu+8u4HdKxVFw587wr1sXicuXwXLpklpiLDMIGSAkIiJf5JFBQpPJhBYtWmDp0qVqaYm9cIncHj58uMvntGvXTj3+/PPPO+6TEWe5/0bICHXmpSvkvRJXLEfrMybUiNZjfWUzogOtiEzWo+0pI0olG3Bi7nysqNwCa/ecyZDfrlR4oAoKykUq6BoM16rPUtFihVYiIt9IIyMzDe+55x5VjO7IkSN47bXX0KtXLxUclMFm2TbzUmaj0YjIyMhs09EwzYxvkoBg+MAH3H0YREREbueRQUIho8eDBw9Wo7+S1Fpy10j1YvsylUGDBqFixYpqObAYMWIEOnXqhM8++wy9e/fGzJkzsXnzZnzzzTcZklefPHkSZ8+eVbclD46Q2YY3OuOQvEPC6XPQNCtKJ+nR50DGnIMWaNi1aR/mnghVt8uXDEH7hpXQvkEl1K4UaZu5Rh6hQqlQVjEmIvJy999/v+PnRo0aoXHjxqhZs6aaXXjrrbfma59MM0PkG5hmhoiomAUJBwwYgEuXLmHMmDFqtLdp06Yqr4x9VFmCfbJcxK59+/YqCfXo0aPVSLJUwZMlKc7JrefNm+cIMjp3Lt9880289dZbRfr+yDMdSzOiim2BsYtHdUgIDMUD3RqifYOKqmAGA4NERESekUamRo0a6rUOHz6sgoSy7cWLFzNsYzab1aBxdvthmhkiIiLyZR69JlKWFp84cUIt/ZDcMVINz05GiadNm5Zh+3vvvVfNDpTtd+/erRJTOxsyZIjKJZf5wgAh2e0uUxs6lcEuI1tuQg3xTdpg4K0NULVcCQYIiYiI8phGxs6eRia7tDD2NDLOrpdG5vTp06qwXPny5R37iImJUfkQ7ZYtW6Ze27lP6UxSzISFhWW4EBEREfkKjw4SEhW1wMqV8FPpFiooaIEOlqvXclvuD6pckV8KERFRPtLIfPvtt5g+fbqqOjxs2LAsaWScC5tIGhlZQSJpZCRvoQzoShoZe27qhIQEVfl4/fr1OH78uAoo9u3bF7Vq1VIFTkS9evVU3kKpqrxx40asWbNGPV9WkrCyMREREVExWm5M5A7dW1bHU6uq4pB/SXSIP46S5iREGYOwJrQaLptCMLlldX4xREREbk4jI8uXd+7cqYKOMltQgn49evTAu+++m6Hg3M8//0CyLZ8AAQAASURBVKwCg7L8WPbfr18/jBs3jt8fERERkQs6TdbbUq7FxcUhPDwcsbGxXILipZZsOYZxv2+0LSe++tchC5Cf69daVc4l8kVs+4jIF7HtIyJfxLaPyHdxJiFRJhIIrF+1FBZvPoaLVxJRJiJYzTCUirlERERERERERN6IQUIiFyQgOPi2xvxsiIiIiIiIiMgnsHAJERERERERERGRj2OQkIiIiIiIiIiIyMcxSEhEREREREREROTjGCQkIiIiIiIiIiLycQwSEhERERERERER+TgGCYmIiIiIiIiKgQ8++ACtWrVCaGgoypQpg7vuugsHDhzIst26devQtWtXBAcHIywsDLfccguSk5PdcsxEVHwwSEhERERERERUDKxcuRLPPPMM1q9fj8WLFyM9PR09evRAYmJihgDhbbfdpu7fuHEjNm3ahOHDh0Ov5+k/EeVMp2madp1tyElcXBzCw8MRGxurRmSIiHwB2z4i8kVs+4jI0126dEnNKJTgocwWFG3btkX37t3x7rvv5mufbPuIfBeHEoiIiIiIiIiKIZm8IiIjI9X1xYsXsWHDBhU4bN++PcqWLYtOnTrhv//+c/ORElFxwCAhERERERERUTFjtVrx/PPPo0OHDmjYsKG67+jRo+r6rbfewuOPP45FixahefPmuPXWW3Ho0CGX+0lNTVWzB50vROSbjO4+ACIiymjixIn45JNPcP78eTRp0gTjx49H69atXX5Me/bswZgxY7BlyxacOHECX3zxheosOrNYLKqj+NNPP6l9VqhQAUOGDMHo0aOh0+n48RMREREVQ5KbcPfu3RlmCUrgUDz55JN45JFH1M/NmjXD0qVLMWXKFFX4JDO57+23385yf1RUFNLS0gr1PRBR0SlVqtR1t2GQkIjIg8yaNQsvvvgiJk+ejDZt2mDs2LHo2bOnqlony0YyS0pKQo0aNXDvvffihRdecLnPjz76CJMmTcL06dPRoEEDbN68WXUaJb/qc889VwTvioiIiIgKkhQimT9/PlatWoVKlSo57i9fvry6rl+/fobt69Wrh5MnT7rc16uvvqr6n3Yyk7By5cooWbIk8/AT+RguNyYi8iCff/65WhoiQTzp3EmwMCgoSI38utKqVSs16/D++++Hv7+/y23Wrl2Lvn37onfv3qhWrRr69+/vqHZHRERERMWH1B2VAOEff/yBZcuWoXr16hkel76erBqRAWZnBw8eRNWqVV3uU/qQUpTT+UJEvolBQiIiDyHLOWTZcLdu3Rz36fV6dXvdunX53q8krZYlJtI5FDt27FDLUnr16pXtc5ibhoiIiMgzlxhLCpkZM2YgNDRUpZKRS3JysnpcUsmMHDkS48aNw2+//YbDhw/jjTfewP79+zF06FB3Hz4ReTguNyYi8hCXL19W+QOlCp0zuS0du/waNWqUWjZSt25dGAwG9Rrvv/8+HnzwwWyfw9w0RL4hN7lpiIjIc0gKGdG5c+cM90+dOlXlnBaSnzolJUWloomOjlY5rhcvXoyaNWu65ZiJqPhgkJCIyMv9+uuv+Pnnn9WIs+Qk3L59u+o8ylKUwYMHu3wOc9MQEREReeZy49wOEsuFiCgvGCQkIvKgGT0y0+/ChQsZ7pfb5cqVy/d+ZcmJdBIlb6Fo1KiRqoQsswWzCxJKbprschwSERERERGR92FOQiIiD2EymdCiRQuVP9DOarWq2+3atcv3fqUCsuQ2dCbBSNk3ERERERERkeBMQiIiD/Liiy+q2X0tW7ZE69atMXbsWCQmJqpqx2LQoEGoWLGimgVoL3ayd+9ex89nzpxRy4lDQkJQq1YtdX+fPn1UDsIqVaqo5cbbtm1TVZQfffRRN75TIiIiIiIi8iQMEhIReZABAwbg0qVLGDNmjKpU17RpUyxatMhRzOTkyZMZZgWePXsWzZo1c9z+9NNP1aVTp05YsWKFum/8+PGqqt3TTz+NixcvqlyETz75pHoNIiIiIiIiIqHTcpv5lBSpEBoeHo7Y2FiEhYXxUyEin8C2j4h8Eds+IvJFbPuIfBdzEhIREREREREREfk4BgmJiIiIqNBNnDgR1apVQ0BAANq0aYONGzfmuP3s2bNRt25dtb1UZV+4cKHjsfT0dLzyyivq/uDgYJVGQXK2SgoGZ/J6Op0uw+XDDz8stPdIREREVJwxSEhEREREhWrWrFmqMNObb76JrVu3okmTJujZs6fKk+rK2rVrMXDgQAwdOlQVW7rrrrvUZffu3Y6q7bIfybcq13PmzMGBAwdw5513ZtnXO++8g3Pnzjkuzz77LL9tIiIiIheYk7AQ8zMsWLAA8+bNUx3W3r175/WliIg8Bts+IroRMnOwVatWmDBhgrpttVpRuXJlFbAbNWqUyyJOUtl9/vz5jvvatm2rijlNnjzZ5Wts2rRJVYU/ceKEquZun0n4/PPPq0t+sO0jIl/Eto/Id3EmYSGxBwiFXMttIiJvx7aPiDJLS0vDli1b0K1bN8d9UqVdbq9bt87lByb3O28vZOZhdtsLGcCV5cQlSpTIcL8sLy5ZsqSqBP/JJ5/AbDZnu4/U1FR1cux8yQ22fUTki9j2EXkfo7sPwNsbSzv7bc4oJCJvxbaPiFy5fPkyLBYLypYtm+F+ub1//36Xzzl//rzL7eV+V1JSUlSOQlmi7LzS47nnnkPz5s0RGRmpljC/+uqrasnx559/7nI/H3zwAd5+++0s90dFRalgpyvLli3D0qVLs/T7ZCZk165dXT6HiNyrVKlS/ApuEPt9RN6JQcIiaCztGCgkIm/Fto+I3EWKmNx3333QNA2TJk3K8JjkQbRr3LgxTCYTnnzySRUM9Pf3z7IvCSI6P0dmEsqyaJmJ6CrNjLR9mQOEdnK/FFXhADEReRv2+4i8F4OERdRY2jFQSETehm0fEV1vxo7BYMCFCxcy3C+3y5Ur5/I5cn9utrcHCCUPoczou16+aMmNKMuNjx8/jjp16mR5XAKHroKHrrDtIyJfxLaPyLsxJ2EBul6AMK/bEREVB2z7iCgnMnuvRYsWGWbcSeESud2uXTuXz5H7M8/QW7x4cYbt7QHCQ4cOYcmSJWq23/Vs375d5UMsU6bMDX9pbPuIyBex7SPybgwSFiCpYlyQ2xERFQds+4joemQJ77fffovp06dj3759GDZsmMrZ98gjj6jHBw0apJb62o0YMQKLFi3CZ599pvIWvvXWW9i8eTOGDx/uCBD2799f3ffzzz+rnIeSr1Au9tyBUuRk7Nix2LFjB44ePaq2e+GFF/DQQw8hIiKCbR8REft9RJQJlxsXIHvOmZxGV+RkmrlpiMibsO0jousZMGAALl26hDFjxqhAXtOmTVUQ0F6c5OTJk2qGn1379u0xY8YMjB49Gq+99hpq166NuXPnomHDhurxM2fOOPpbsi9ny5cvR+fOndWy4ZkzZ6oAo1Qtrl69ugoSOuccZNtHRMR+HxFdo9MkyzPlmiSwDg8PR2xsbLZ5b7LL08AAIREVV2z7iMgXse0jIl/Eto/Id3G5cSHNqsm8/I4BQiLydmz7iMgXse0jIl/Eto/IOzFIWASNJgOEROQr2PYRkS9i20dEvohtH5H34XLjQph6TUTkbdj2EZEvYttHRL6IbR+R72Lhkjyyp3CUhpOIvEtoaCh0Op27D8Mjse0j8l5s+7LHto/Ie7Htyx7bPiLfbfsYJMyjqKgodV25cuUb+2aIyONwhnD22PYReS+2fdlj20fkvdj2ZY9tH5Hvtn0MEuZRZGSkuj558qRaduxtZIakBEBPnTrllcup+f6Kr6L47mRUhVxj21e8se0r3gr7+2Pblz22fcUb277ijW2f+7DtK97Y9hVvcW7u9zFImEd6va3WiwQIvTGIZifvje+v+PLm78+b35snY9vnHbz974fvjwoa2z7vwLahePP2788Tse3zDt7+t8P3VzhY3ZiIiIiIiIiIiMjHMUhIRERERERERETk4xgkzCN/f3+8+eab6tob8f0Vb978/XnzeysOvP3z5/sr3vj9EX+3+LfDtsH7eHvb7sm8/bPn+yve+P0VLp1mr29OREREREREREREPokzCYmIiIiIiIiIiHwcg4REREREREREREQ+jkFCIiIiIiIiIiIiH8cgIRERERERERERkY/zySDhqlWr0KdPH1SoUAE6nQ5z587N8PiFCxcwZMgQ9XhQUBBuu+02HDp0yPH48ePH1fNcXWbPnu3YztXjM2fOLNT39sEHH6BVq1YIDQ1FmTJlcNddd+HAgQMZtklJScEzzzyDkiVLIiQkBP369VPv2dnJkyfRu3dv9f5lPyNHjoTZbM6wzYoVK9C8eXNVXahWrVqYNm1aob63gnp/O3bswMCBA1G5cmUEBgaiXr16+PLLL7O8N1ff3/nz5z3+/eX2d6+4fn9ynNn9/V28eNGt35+nY9vHto9tH9s+X8S2j20f2z62fb6IbR/bPrZ9bPvyRfNBCxcu1F5//XVtzpw5UtlZ++OPPxyPWa1WrW3bttrNN9+sbdy4Udu/f7/2xBNPaFWqVNESEhLUNmazWTt37lyGy9tvv62FhIRo8fHxjn3JvqdOnZphu+Tk5EJ9bz179lSvuXv3bm379u3a7bffnuHYxVNPPaVVrlxZW7p0qbZ582b1ftu3b+94XN5fw4YNtW7dumnbtm1Tn1epUqW0V1991bHN0aNHtaCgIO3FF1/U9u7dq40fP14zGAzaokWLPP79ff/999pzzz2nrVixQjty5Ij2448/aoGBgeo92C1fvlx9fwcOHMjw/VksFo9/f7n53SvO319SUlKWvz/Zb6dOndz+/Xk6tn1s+9j2se3zRWz72Pax7WPb54vY9rHtY9vHti8/fDJI6CxzkFCCCnKfBDHsJLBQunRp7dtvv812P02bNtUeffTRHPftDhcvXlTHsXLlSnU7JiZG8/Pz02bPnu3YZt++fWqbdevWOf5B0ev12vnz5x3bTJo0SQsLC9NSU1PV7f/9739agwYNMrzWgAEDVLDG09+fK08//bTWpUuXLEGmK1euaO6U3/d3vd89b/r+ZB/ynB9++MHjvj9PxraPbZ9g28e2z9ew7WPbJ9j2se3zNWz72PYJtn1s+3LDJ5cb5yQ1NVVdBwQEOO7T6/VqSeZ///3n8jlbtmzB9u3bMXTo0CyPybLJUqVKoXXr1pgyZYoEZVGUYmNj1XVkZKTjWNPT09GtWzfHNnXr1kWVKlWwbt06dVuuGzVqhLJlyzq26dmzJ+Li4rBnzx7HNs77sG9j34cnv7/s9mPfh7OmTZuifPny6N69O9asWYOidiPvL6ffPW/6/n744Qe1LL5///4e9/0VJ2z72PZ50t8O2z62fUWFbR/bPmds+woX+32eg20f2z5nbPsKV2wxO+c13vAevIz9y3n11Vfx9ddfIzg4GF988QVOnz6Nc+fOuXzO999/r/LatW/fPsP977zzDrp27aq+zH///RdPP/00EhIS8NxzzxXJe7FarXj++efRoUMHNGzYUN0nOdlMJhNKlCiRYVsJCNrztcm1c4DQ/rj9sZy2kUBicnKyyvXnqe8vs7Vr12LWrFlYsGCB4z75I5s8eTJatmyp/hH97rvv0LlzZ2zYsEHl8SsKN/L+rve7503fn/z9PfDAAxmO2RO+v+KGbR/bPk/522Hbdw3bvsLHto9tn2Dbx36fr2Hbx7ZPsO1j2+cKg4SZ+Pn5Yc6cOWpWoER6DQaDivD26tXL5SxACajMmDEDb7zxRpbHnO9r1qwZEhMT8cknnxRZkFBmku3evTvbGZDFXUG8P3l+37598eabb6JHjx6O++vUqaMudhIAPnLkiAoY//jjj/D09+fu372i+v5kpGXfvn1ZvhNP+P6KG7Z9xQfbvuyx7WPbl1ds+4oPtn3ZY9vHti+v2PYVH2z7sse2r06hnPNyubELLVq0UMuHY2Ji1OzBRYsWISoqCjVq1Miy7W+//YakpCQMGjTouh92mzZt1IxE+/TuwjR8+HDMnz8fy5cvR6VKlRz3lytXDmlpaeq9OZPqsfKYfZvM1XLtt6+3TVhYWJHMQruR92e3d+9e3HrrrXjiiScwevTo676mLNs9fPgwikJBvL+cfve84fsTMstJplfL36wnfX/FFds+tn2usO0rOGz7PBPbPrZ9rrDtKzhs+zwT2z62fa6w7Ss4xbbt03xcboqLHDx4UBXy+Oeff7I8JhVV+/Xrl6vXeu+997SIiAitMEl15meeeUarUKGCOu7M7IUhfvvtN8d9UsHZVeGSCxcuOLb5+uuvVeGSlJQUR+ELqYDsbODAgYVe+KIg3p+QwjRlypTRRo4cmevXlmrPd999t1Yc3t/1fveK+/cnpJK4VBR3rkrt7u+vOGHbx7Yvt9j23Ti2fZ6DbR/bvtxi23fj2PZ5DrZ9bPtyi23fjSvubZ9PBgnlg962bZu6yBfx+eefq59PnDihHv/1119VddQjR45oc+fO1apWrardc889WfZz6NAhTafTaX///XeWx+bNm6eqIe/atUtt99VXX2lBQUHamDFjCvW9DRs2TAsPD9dWrFihnTt3znFJSkpybPPUU09pVapU0ZYtW6Zt3rxZa9eunbrYmc1mFUDq0aOHtn37dm3RokWquvOrr77q2Obo1XLiEmST6rMTJ07UDAaD2tbT3598J/J+HnrooQz7kCq5dl988YX67uW7k+1HjBihAqdLlizx+PeXm9+94vz92X333XdaQECAywrG7vr+PB3bPrZ9bPvY9vkitn1s+9j2se3zRWz72Pax7WPblx8+GSSUAKAEBzNfBg8erB7/8ssvtUqVKqnorgQrRo8eraWmpmbZjwTNKleurFksliyPSeCwadOmKuobHBysNWnSRJs8ebLLbQuSq/cll6lTpzq2SU5OVuXPZWaZBIok0iyBGmfHjx/XevXqpQUGBmqlSpXSXnrpJS09PT3L5yjv0WQyaTVq1MjwGp78/t58802X+5BgsN1HH32k1axZUwWhIiMjtc6dO6ugVXF4f7n93Suu35+dBA4feOABl6/jru/P07HtY9vHto9tny9i28e2j20f2z5fxLaPbR/bPrZ9+aGT/93YgmUiIiIiIiIiIiIqzli4hIiIiIiIiIiIyMcxSEhEREREREREROTjGCQkIiIiIiIiIiLycQwSEhERERERERER+TgGCYmIiIiIiIiIiHwcg4REREREREREREQ+jkFCIiIiIiIiIiIiH8cgIRERERERERERkY9jkJCIiIiIiIiIiMjHMUhIRERERERERETk4xgkJCIiIiIiIiIi8nEMEhIREREREREREfk4BgmJiIiIiIiIiIh8HIOEREREREREREREPo5BQiIiIiIiIiIiIh/HICEREREREREREZGPY5CQiIiIiIiIiIjIxzFImE+XLl1C165dERYWhnvvvRfTpk1D06ZNC+RLeeqpp/DKK6/katu8vO4TTzyByMhIlCtXDsePH4dOp0NMTAwKgxyTHBt5n86dO2Ps2LHX3U5+v7Zv314kx0RFh22fZ7R90nbL35i05YWhsP+NICpu2Pa5p+3LS5+4KK1evRqVKlVy92EQFTq2fd5xzrtixQqUKFEi388fMmQInn/++Wwf79WrF7766iuXr+X8GBUPRncfQHH19ddfw2AwqBMovV5foI3D5MmTUdD+++8//Pbbbzh27BjCw8ML7cSyIKSmpqJs2bI4fPgwSpUq5e7DISInbPu8s+2TgOC2bdsKbLCroMi/VdWrV8eVK1duqHNLdKPY9rmn7ctLn1hOTO+6664iGdy4+eabcfr06QwDqPLaOZ1EExVHbPsKjzed8/7999+5eqwo22nKP84kzCcJtjVo0EAFCIvL8VapUkUFCD3d8uXL0ahRI7c3lmaz2a2vT+SJ2PZ5f9vnbdLT0919COQF2PYVHrZ9RJ6LbV/xaPt43koFqXhEuDyMLC/+4Ycf1LTZkJAQfP/999ddainLM2WUUYwYMQKPPvpohu0/+ugj9OzZ0+V03oceeggVKlRQS5tbtGihGpS8GDduHB5//HHs2rVLHa/s39VJ1KuvvqoCiaVLl8aAAQPU9HI7GeGQ45PlyjVr1syy3HTChAmoXLkySpYsiddffz3LPy7dunVTAUp5focOHZCUlJTt8f7111+48847XT7277//omXLlmpf5cuXx9NPP43k5GT12BdffKGWgDubNWsW6tat67g9c+ZMNG7cWM1IadWqFdauXet4TL6f//3vf+jRoweCg4PVqEdOrydkFLl79+6O7+b//u//UK1aNcfjCQkJGD58uPpcy5Qpg0GDBiE2NhbX8/nnn6N27doIDQ1Vn7d8vpmXAf7444+oVauWei/yndpPhO1TvL/77jvHdyLvy+6tt95SIzjOZHt5npDZRB07dlTflfwuDBw4EFFRUbgRmqbhs88+U+9F9nvbbbfh6NGjGd6vfEbyfuXzk2PPz+8OFS62fe5r+2S0ediwYWo/MrNOZoZn/huTtl7aO/l7lvZs3759jsfl7+r9999H8+bNVXsl7fnZs2fVY61bt1bX7du3V/9GSDvmfEyu2pmcSPskn0v9+vVVW/rwww+rmYDy74q8drNmzbB///5ctZP2Y5NlfXJsP//8s7q9detWdOnSRX0ecnzffvtthjbujjvucHxeo0aNYltCN4Rtn/vaPuc+cU79H+mnyJI2aTukrZCLLAkWS5YsUW2JbC8D/PPmzcuwf+kj33///aoPUqdOHUd/SEibY++PVaxYEe+++26W5XQvvfSSei1ZFi2vK8fx5ZdfOvr9zn1QaReJigu2fe5t+yReIOds0q7I+ausDMzpvPXChQu477771Pmb9Knk+DIHD8ePH6/OaSX92Jtvvqn6j+LkyZPqnFaeGxERgd69e2dZeRgXF5fj8WSXjsr+WHbttMymdG53Rb169dR5PLmJRvkyePBgbcSIEY7bU6dO1Zo0aeK4LR/ttm3bHLe/+OILrVOnTurnTZs2aWFhYVpSUpLj8QYNGmg//fSTy31PmTJFi4mJ0dLS0rSPP/5Yi4yM1OLi4ly+bnYyb3fs2DF1jFeuXFG33377ba1hw4baiRMntPj4eG3AgAFa9+7d1WPp6elanTp1tJEjR2rJycnajh07tPLly2s///yzenzp0qXq/axdu1ZLTU3VXnvtNc1gMKjXFAMHDtSefPJJdfxyWbNmjdouO5UrV9b279/v8rFVq1ZpW7du1cxms3bkyBGtbt262nvvvaceO3/+vObn56edPHnSsX3v3r0djy9YsECrWLGitmXLFs1isWi///67+iwvX76sHpfvp3Tp0tqGDRs0q9Wqvp+cXk/cfPPN2tChQ9W2Bw4c0GrUqKFVrVrV8fi9996r3r98zgkJCdr999+vPfTQQ9f9vn777Tf1PuQ4li1bpgUEBGj//fdfhu9O9iu/B2fOnNEqVark+LyXL1+u6fV67YUXXlDf1969e7WgoCB1v3jzzTe1vn37Zni98PBwx+Pbt2/XVq9erb4r+UzlPT722GOObeVzkt/n63H+G5g+fbpWoUIFbefOneqYXnzxRa1+/frqd0s+t8DAQG3fvn2O71F+x/Lzu0OFj22fe9q+N954Q7Xh8vcu7UmvXr3U35i0B2LixIla48aNtYMHD6q/qy+//FKrWbOm4/WkXapWrZr6O0tMTNQGDRqkdenSJdt/s67XzuREntetWzctKipKPa9MmTJao0aNVLsixzZkyBCtT58+uWonM/9bJc6dO6fa7lmzZqm2edeuXerfpCVLljjaOPv3IK8n75dtCd0otn3uafucP/fc9H+kP+NM+hMlSpRQxyx9P2mH5Njtryf7Dw0NVc+V9uTdd9919OOkPTIajdrKlSvVbWmHNm7c6PK1MveNpG8pfbejR4867uvRo4fqxxMVJ2z73Nf2+fv7a/PmzVN9mUmTJmkRERGO/pCr89auXbtqDzzwgDqXP378uDrXev/99zOcH0ofTPpF0h+U9nPatGmO9nXhwoXqPC02Nlbr37+/6svl5XjsbWBO7aOrdvqll15S+7eTz1f2nZKSksffVioonEnoBjIzTWZF/Pnnn46ZWxK9v/vuu11u/8gjj6gRCT8/P4wcORJWqxU7d+4s0GOSUdnRo0erUQeJ6svMrsWLF6uZJhs2bMC5c+fw3nvvISAgQI0cyKwPex5GGWV98MEH0a5dO5hMJjWLQ0Y07OS45fkyGiE/y2wV2c4VmX0pryEjudnlgJFZKJIPskaNGnjyyScdIw8yCiGjN/aZJhcvXlTvQWaxiIkTJ6rPT2bSyDLxe+65R826WbhwoWP/DzzwgBptlpHqwMDAHF/v1KlTavTjww8/VNvedNNNKsG2nczE/P3339XrymizfCbvvPOOGhWxWCw5fh/9+vVTo1RyHDJbRmb9ZB5hGTNmjBrZllmmMjNvy5YtjsfkPN3+fclIjHzmzo/npEmTJmomoXxX8pm++OKLWV47P79fzz33nJpSL8ckM5Xk89u4caP6bOV49+zZo2ZpymvK71hef3fI87Hty3/bJ+3aa6+9pv7epT2R0V9n0s5I+yIzXoxGo/p7k78nab/tZGadtHlBQUH4+OOP1ax055xaruTUzuTk5ZdfVqPo8rxOnTqp2TvSrsixycwEmQmY33ZS2pNbbrlFjZZL+9GwYUP17+SMGTMc28h9Mgovryfvl20JuRPbvvy3fTfaLkk+NWkLZKWJ9P2kHZKZxr/++qtjm9tvv13NdJH2RNqSEydOOFZQSNshs7JlBo19FUpuyCwjmSE0ffp0dfvMmTNYuXKlo09K5AvY9t1Y2yftVp8+fVRfRs4x5Rxp/vz5Ls9bo6OjsWzZMnUOL+fyVatWVTMJnesmSAxBVi9Kv0j6g3I+L30q+4oTmeUnxySrPuS5cp4rz8nt8eTX0KFDVV9QVpYIOWZ5b/7+/je8b8ofBgndRDoJsmRZyLUEheQPNjP5w5Q/Ujnxkz9Y6aDIFN3Lly8X6PHIiaLzMlnpeMkfptwvF7nt3MhJwMx+cimBRGmI7KRDJdOY7T755BO1REMCePIaEkR0bnByO+1abNq0Se1HGiX5POSk2fmzkGVq9sbul19+UUElCXwKCTTJ9vIZ2i/SQEvHzc6+bW5eT963NKTOeSScny+vJ+9TlgbaX086l9JJPX/+PHIiAQEJZspJtjxPApmZv3OZJm4nJ9bx8fGO23Kszr9PmR/PiSwt79u3r2OJuyx3v9Hft8y/X/K7JfuX+2UJsnSiZfq+fM4ybd6+VD8vvztUPLDty1/bl7mddf7Z3t7I36pz+yZLfJ2DgM7Pkb81+Tt0bv9cyamdyYns307aosy37R3B/LST8hxpE53fqyy1lgGF7NpytiXkbmz78tf23Wi7JO2FFD9xbi9kkN6ebsHV/oTsU36W45PtZeBWAox5SfkjSwWljy8DoXIt/Rvn1yLyBWz78t/2Ze7rye3szlulvyfnpc79LefzdSGPS1oXV/uTQVsJzElbJ+d/MhgrqW6c29frHU9+yYQWGdyVVDopKSlqoDhzajYqWgwSFhLpWDjnIHA+eREy827p0qXqD0uCWdmNLMrMCLksWLBABQelEpDMKrTnDygoMrPROe+AnJxJwyD3y0U6U865qGRbuV9IsEdGXe1kO+f3K42R5G+UbaRBlM7aH3/84fI4JE9MTg2m5MeTmXWSz05GdWVGmvNnIcEtaQxlVFmChc6fqzR6khdPPkP7JTExUeWrsstciCan15P3LQ2ZcwBNZoQ6v57sTz4759eU50jgKzuyj8GDB6uZPjIbUp4jo9wF9Z3L6JLz76Z8BvLe7GRkSI5v79696v6ffvrphl878+9XWlqa+lzsv0MyI0g63pJLQ2Yy2r+3vPzukGdg21c4bV/mdta5rbG3N7Nnz87Q1sjfubRhds7Pl7ZF2nh7WySj0O5wvXbSVXEweY7MvHfeXjqxzrPCMz+PbQkVNrZ9hdP25UV27YXkAnduL2SQYtKkSbna56233uoYqJVZ0JKPy9VgpavXlvxekg9MZhDKYKjMUiTyNmz7Cq/tc+632ft+zueQzu2OnFNJ30nOpVydrwt5XPp/rvYntQmk3ygrPeT8b9WqVep+53PA6x1PbmRX9FVmE8oMQvm8JPgok2XIfRgkLCTyiy1BKukcyKwo++w2O/uIpPxByAw9CUS5In+k8rjMVpPAiizDyu1MjryQGSj2JaDSeZIlpjJ7S05MZRqzjErI8g45qdy9e7dKeiqBLCEnoTLzTZa12Y9RAk92sqRDGhFpZGQEV5ZzyDTlzCSwKAlfJclrduzLPeQfJFn+kbmTJ8t++/fvr2ZfSpBLOnR2zzzzjJpNIgFEORZpCCWZdU7L7XJ6PfkO5VhldqEs6zt06BC++eYbx+MyWiydSZnKbQ8kSvD1ekEu+fzl+OQfGmlIpXMqBVQK8ndz3bp1qnCA/GMhx+8cIJD3LMt4ZBRJfh/kMyuI3y+ZKSjfifwOydJ2+UdFfrcOHDigloXLZyi/6xLEtP9+5PZ3hzwH277CafuknZXUBvZgmrSzzqR9kzZa/p7sf8cy+8X53wtZdiePy9+aJNiXUWJ751Ha+CNHjqCoXa+dlATa0g46H5sMIsiSGlmaIoNScpF/Z2Xmd3bYllBhY9tXOG1fXkg7Jm2e80mwpImZOnWqGoiUFAbSB5E+kHNhp+zIyba0RbJPOX7pF2XXB3HVhkrbJYFBKbwiSwFlmTORt2HbV3htn/R1ZKKQxBOkQJs8TwqKuCLnVRJPkHQvch4uxyEF6+zn6/Y2SYKB0g+U/qCkepGJS/Z+o6z0kOOWdAtvv/32DR1PXtppIcXt5Bxd+rqcReh+DBIWEgmiSSdE/tDkZMz5D9R5aew///yjAijZzeKQ50kuJ4moy5RhCYI5jwgUFGkwJO+d5BWUZZ1y0iUzyOzLhyXfgPzhygmdjHpIEFGmJAsJJkq1N1kyLcuMZYRVpgzbyfPsVTNl/xIYdTVyIq8huRCkQc2OnOR++umnal8y402q0WX3ucqJpwS77CSHgjQ8UsVOqjbJ8japPpfT8tXrvZ7M8pRZhtLgyWPyXTrnT5AREfvyOelcSo7D6+X0ksp3EuSUvA+S00amXBfUKLuQ/UqnWb4TqQ4oeQKdPyfJZSHfhRyvzMyU7/VGyXfy7LPPqg6y/A7t2LFDjbDJP5wSWH7jjTfUZyjvV/4BsufPyO3vDnkOtn2F0/ZJYF1y+0jb2rRp0ywVyiXIJnm3JNeq/O3K0g3nHH1COl0SbJS/NZnFbs/fKqQNlzyG0jZKO1mUcmon5d88yb8on49sI+9JOsLSxkv7LP/myPuRIKnzjOjM2JZQYWPbVzhtX15Ibi95LelHSXshlTclr7Ss2JE2VAYdpP2QPocEC69H+ofST5RBYVnFIyfUshzO1UwYCQTKwLO8rnMwUIKEkkdc+ofSnybyNmz7Cq/tk3NtCcbZ06rI4K/007IjfSQJAErcQAKQEsCTCsh2cr4nfUiJKchAsZyf2WMUEhSUlFOyf3muHN+NHk9u22n7scnkHpnEYg9ckvvopHqJG1+fKEMQTxor59l/xc0HH3ygglwyM46IyFPaPhn8GTt2bJbgIhGRu3hDv+96ZNWKrAxZv359hgF0IvJduWn7ZOBXgmjSd/MVskpGBlVkMIbcizMJyWPI7BGpUlecSN4GGfGQWLuMHslomjd3domo4BXHto+I6EZ5e9snfUPpF8psRgYIichX2r78kMIpMktx2LBh7j4UYpDQe0jeAZna7OrivKTMk8l0aOdlr8WlQZPp2JKzUJblylJmmUJ9PfKdZPd9ZS5I4Kkkh2V274GoqLDtK3r82ydyP7Z9nk3yH0r6BClcIEuWiahgsO3zPpI7UVa8yPJoKRZF7sflxkRERERERERERD6Oy42JiIiIiIiIiIh8HIOEREREREREREREPo5BQiIiIiIiIiIiIh/HIGE+KpXFxcWpayIiX8G2j4h8Eds+IvJFbPuIfBeDhHkUHx+P8PBwdU1E5CvY9hGRL2LbR0S+iG0fke9ikJCIiIiIiIiIiMjHMUhIRERERERERETk4xgkJCIiIiIiIiIi8nEMEhIRUYFasGABnnzySXVNROQr2PYRERFRcWd09wEQERU0a/RRmHf8Ai32NHThlWBsMhD6yBr8oIvoJHnevHnqZ/t17969+dkTFQG2fe7Dto/Ifdj2EZEvshbSOS+DhETkVcw7ZiJt4UsAdAA0dW1e/xVMvT+HsfEAdx+ez5wk2zFQSFQ02Pa5D9s+Ivdh20dEvshciOe8XG5MRF41mqIaS80KaJYM12kLXoQ1+pi7D9GnTpLt5H4uPSYqPGz73IdtH5H7sO0jIl9U2G0fg4RE5DVkurVtNMUVHcw7ZhTxEfmGnE6S7RgoJCo8bPvcg20fkXux7SMiX2Qu5HPefAUJJ06ciGrVqiEgIABt2rTBxo0bc9x+9uzZqFu3rtq+UaNGWLhwYYbHNU3DmDFjUL58eQQGBqJbt244dOhQhm2io6Px4IMPIiwsDCVKlMDQoUORkJDgeDwlJQVDhgxR+zcajbjrrrtyPKY1a9ao7Zo2bZqfj4CIPJDkY7BNt3b56NXHqaBdL0CY1+2IKG/Y9rkH2z4i92LbR0S+SCvkc948BwlnzZqFF198EW+++Sa2bt2KJk2aoGfPnrh48aLL7deuXYuBAweqoN62bdtU8E4uu3fvdmzz8ccfY9y4cZg8eTI2bNiA4OBgtU8J/NlJgHDPnj1YvHgx5s+fj1WrVuGJJ55wPG6xWFSA8bnnnlNBxpzExMRg0KBBuPXWW/P69onIg0nC1hwevc7jlF933nlngW5HRHlja9uyH1Fm21c42PYRuRfbPiLyRbpC7vflOUj4+eef4/HHH8cjjzyC+vXrq8BeUFAQpkyZ4nL7L7/8ErfddhtGjhyJevXq4d1330Xz5s0xYcIExyzCsWPHYvTo0ejbty8aN26MH374AWfPnsXcuXPVNvv27cOiRYvw3XffqZmLHTt2xPjx4zFz5ky1nZDA4qRJk9SxlStXLsf38NRTT+GBBx5Au3bt8vr2iciDSUUnlZPBJQ3GJg+gOMjrbG07aRN1Ol2GmdTp6el45ZVX1CxraScrVKigBknsbWdBkOrF1ztZlsdZ5ZgKw7m4M/h56zSMXf2xupbbvsZb2r7ihm0fuRPbPrZ9ROSbjIXc78tTkDAtLQ1btmzJMFNPr9er2+vWrXP5HLk/88w+mSVo3/7YsWM4f/58hm3Cw8PVibF9G7mWJcYtW7Z0bCPby2vLzMO8mDp1Ko4ePapmQhKRd9GZQgGd4eoNA6DTO66l0pM+sjo8XV5na9sdP34cL7/8Mm6++eYM9yclJan9vPHGG+p6zpw5OHDgQIHP6svpZJkBQiosyw8vxog/n8K8vXOw9vhqdS23lx9Z4lMfui6iOhBc5uoNfbFs+4ortn3kDmz7bPSRNaArUcV2g20fEfkInbR7AWGF1u/LU5Dw8uXLallv2bJlM9wvtyXQ54rcn9P29uvrbVOmzNXO71WSTzAyMjLb13VF8hyOGjUKP/30k3p+bqSmpiIuLi7DhYg8k0rSqlmgv6kXjG2HwVDvTnUd8OR/N1wKvqjkdba2kHZZUjK8/fbbqFGjRobHZNBF0jTcd999qFOnDtq2batmcsuAz8mTJwv9ZJkBQirMWTST1o2TzCuwatYM15PWfolzcQU3W9bTWU+uAxIvAGGVYGz7tEe2fXmZIS3pZfr166e2l9nRsuIkM/tjmS/PPPOMY5vOnTtneVxWkxQ0tn1UlNj2XWO9sBtazAkgqCSMbZ7yyLaPiKigWQ4uAlJioStTv1D6fbmLlHkBOYmWJcZyEn3TTTfl+nkffPCBek5mUVFRamYlEXkIqwUBm6epkY+k+g/BWqax02NqlCPHp5cqVQruZp+t/eqrr+Z6trZ455131ECK5H5dvXr1dV8nNjZWnSzLDO2cBkjkYpfbARL7kmJJ6M8AIRWmZYcXq99jSVuSmdy/7PC/eLD5EJ/4EszbflTXfi0fhV/bYfDUGdIy6CEBQgn6yQxpmdWceRDYPgNaBjzuvfdevPDCCy73uWnTJtW3s5Nc1927d1fPcSaDLtJG2smgS2Fg20dFhW3fNeYt09W1sdkgmDr9j7+EROQTzFumqWu/Nk/B2Chjv6cg5ClIKCfRBoMBFy5cyHC/3M4uD6Dcn9P29mu5T6obO29jrzws22Reamc2m1XF4+vlH7SLj4/H5s2bVfGU4cOHq/usVqs6uZBZhf/++y+6du2a5Xlysi4dW+cT5cqVK6NkyZKq0jIReQbzwUVISzwPfbnGiKjXRQUJipucZmvv37/f5XP+++8/fP/999i+fXuuXkMKQkmOQikolVMbdiMDJBIEkIv9PREVhtPRp1wGCIXcL4/7xO9f0mUE7p8PGEyIrdT9ugMi7hggcZ4hLSRYuGDBAjVDWlZ4ZNaqVSt1Ea4eF6VLl85w+8MPP0TNmjXRqVOnDPdLUDC3fcWCCBQy9yoVtkuJF7Nv+64+7gu01HiY98xRy+uMzR509+EQERUJ66UDsJ5Yo2ZQG+r1KZTXyFOQ0GQyoUWLFli6dKkjMb4E2uS2PfCWmRQHkceff/55x32y9M1eNKR69eqq8ybb2IOCEoiTXIPDhtlGw2VbqUgsM2zk9cWyZcvUa9tPRK9HToZ37dqV4b6vvvpK7ee3335Tx+GKv7+/uhBR8RhRMbYYUiwDhPkhgx8PP/wwvv3221yd6EsRE1l2LCcXUugpJxwgIU9XKbIytpxzvWRV2gB53BNmCBe29LUzkG41w9CwP0pVqgVPk98Z0nl9DUklI4O6mdv/n3/+WT0mfc0+ffqo/Kw5zSbM7yxqoqJSOriMSqvgiu7q477AvPt3ID0Jhpt6Qh9W0d2HQ0RUJMxbpqprY9MHoDMGFMpr5Hm5sXTABg8erIqItG7dWi0ZSUxMdIwOS9XMihUrqlkoYsSIEWpU97PPPlOjq1J9U2b0ffPNN+px6cxJAPG9995D7dq1VbBOOnBSgdMeiJSqyFIhWUahZfRZTnQlKHn//fer7ez27t2rOooyw1BOnu0zayT4KB3Shg0bZngvssRFcuNkvp+Iihdr9FFYj60EAsJhqN8XxVVeZ2sfOXJEFSyRE187GTwRMkNalvLJzBrnAOGJEyfU4Mj1ZkJzgIQ8Xf2yjTB3z28uH5NAeNdaPeDtNKsF5m0/qZ+NzQfBW2ZI59XcuXPVYPKQIRmXl0uamapVq6q+4s6dO9UsamkXpYBTdphmhjxdgBaY7WPS9jUr2cr7Z1FrGgI2fq9SzCTWvAvx+Xi/RTWIJPlYP/nkE5VHX4rRjR8/Xp1DZ2f27NnqXFj6d3Ju/NFHH+H22293PC7tl5wPy+CLnPPKKjn7RBtnMgjz+uuvq4k30reUbf755x8EBmb/+0NEnk1LiYN51+yrM6gLr9+X5yDhgAEDcOnSJYwZM0Y1dtLgLFq0yNH5k0T4EpCza9++PWbMmIHRo0fjtddeU42ddOacA3P/+9//VKDxiSeeUJ28jh07qn1KAM95JFgCg7feeqvavyS0HjduXIZjkwZUToDtmjVrpq6zm5JPRN7BvPUHdS2JWnV+hZNvqijkdbZ23bp1s8yQlrZWBkm+/PJLlRrBOUAoxZuWL1+u0iUQFWfy7/rcPbMdt/U6vSpaInTQYVj7ESgfdm0Q0VtZj66AFntKJa7WV2wJXyUpF3r16pVh4FhIv9KuUaNGKq2N9CNlgMU+gJIZZ1GTJ0tKS8K/xxc62jqZbGFv+4S0ffWrNoC3s5zaiNQrh6ErURURTe+ETip7eqC85mNdu3atSgcjgxV33HGHOoeW/uDWrVsd585yziznytKvkwk0rkiAUCbYSHsmQUkZON6xY0eGc3QiKn7Mu369OoO6F/ThlQrtdXQaI2h5IstOpFqoJP5nTkIi99PSk5A8vgWQEoOAp9ZAH5mxum9xIx1Kma399ddfO2Zr//rrr2rGjQzGZJ6tnZnMpJHBFhmMsQcI+/fvrzqY8+fPzzCbRyrES2AyN9j2kSdZcWQpJq79AqWCS2NU5zH47/hK7Lu4Bwcu7UO5kPL48q6vVeDQ26X8OgjWw4vhd9uH8Gs+GJ5IVnjI8l5J7WIf/BDSzklb9eeff+b4fKliLCtOnNPWOJPBYSlyIrNr+vbNeSa5nFyHhISogWg5Uc8Ntn3kSb7bMAn/HFyAJhWaY2irJ1URk1MxJ7HlzEYY9X6YdM8UlAiMgLdL/fMZWPbMgV+X0fBrd62iuaeRwKDkV50wYYJj4FcGcJ999lmX+VZlMo60U9Jfs2vbtq2alCOBRmcy01BW4LmaSSjPkUJO7777br6PnW0fkWfRNCtSvr4FWvQR+D8wG4ZqHQvttby/B01EXs2y908VINRX71TsA4T2DuKnn36qZmtLp0/SJmSerX3u3Llc7+/MmTOq0vDp06fV/mQmjf0iI9ZExU18ahx+2PK9+nloq6dQNbK6qmL8Ts+PUDGsEs4nnMPmUxvg7ayxp2A9vAQwBcPYoB+KwwxpO/sMaXt+6hsxdepUNSMnNwVD7GlonAvlERUXBy7uw78HF8Jk8MfjrZ9G+bCKqu0b1XUMOtXoCrM1HfP32QYIvZmWeBmWq8WaZAWJp7LnY5X8q7nNxyr3O28vZEAjL/lbpdinLDGWdlFW9En/UVJ/SaG7nEguVgkMOl+IyHNYj69WAUJdydrQV+1QqK+V5+XGRESeQiZCp9uTt7bImIuqOJOlxdkVg1qxYkWOz502zVbAxXkWDieMkzf5aes0FShsXbkdWla+VrxMZg7e3fBeTFj7Bebs/hWtKrf16iJG5m0/q1qmEiDU+YfAk+U1n7WcXEueafvPMtghAT6ZBVirVq0MwUYJEsq+ZTmdM1lSLEv1JBWNpFiQnIQvvPACbrnlFjRu3LhI3z/RjUq3pOPr9eNVwZIBTR5E2dCMeYql7Vt1dDn+ObAQfRv0R6h/qHcvt7OkwdDgbuiCPbc4VX7ysUoqL1fby/25dfToUXX91ltvqUFnGSD+4YcfVKqF3bt3q9RfrjAfK5FnM62drIJ3qXXvRWJUVL73k5t8rAwSElGxZT23Hdr5XdCFVYChVsaRVyLyPvsu7Mayw/8iwBiIR1pdyzdn16F6J/y6cwaORB3CjnNb0bRCC3gjzZIG844ZHl2w5EbyWZ89e9aRV1rIia5cZDaM80DJkiVL1HMfffRRlzMY5XF7QFKW+Ek+a8nbSlTczNvzO07FnkT1yJroXS/rsvqK4ZXRtmpHrDuxGn/vn4f7mjwIb11uZ972o/rZ6KEpFtzNXsDuySefdAzESHsqs7enTJmSbboa5mMl8lzWmFNIObESMIUgvO0jhT44zCAhERVb5i22WXPGZg9Dp2dzRuTtM2m+3fCV+llm0kg+wsyMeiPuatAf32yYiDm7fvXaIKHl4D9A4iVVrERftoHXzZDO7QzoHj16ZLudBAVXrlyZz6Ml8hxnYk/jt10zVXGOJ9s+C4Pe4HK7fo3uU0HChfvn4Y56dyPIVHwLuWXHemwltCvHoStVB/pK2VcI9gQyW0eqCl+4cCHD/XK7XLmMM0Ht5P68bO+KPZ1C/fr1M9xfr149NaiSHX9/f3UhIs9j3jrdtnqk0X1FsnqEOQmJqFjSkqJt+Qj1fjB66Yg5EV0jubZkJk21iBroVbdPth9N55rdEBEYqQqZ7L2w24s7i8VjFiER5Z9ULv56/QSYrWbcUa8vapa8ttw+s6oR1dGyUhskpiWq4ibeyLz1B8csQk9PJ5GffKxyv/P2YvHixXnK3yqDLFLpXSooOzt48CCqVq2a5/dBRO6lpSdfWz1SROm1GCQkomLJvHMmYEmFoe4d0IVknVFERN7jQvx5/LZzJnTQ4Yk2z2Q7k0b4GfzQ92ohjzm7ZsHbWC8fgvXEGiAwAoZ62QdLiaj4W354MfZd3I3SwWVxX+PrD4je0+g+df3X3j+Qkp4Cb2KNOwvLoX8BvyAYG/VHcSD5WL/99ltMnz4d+/btw7Bhw7LkY5VlvnYjRoxQqRg+++wzlbdQ8gpu3rw5wyzs6OholaPVnrdVgoFy2563UIKnI0eOxLhx41RV+cOHD+ONN95Q+xs6dGiRfwZEdGMs++YByVegr3YL9KVc5xQtaAwSElHxzEljn0nTgjlpiLyZLCf9ftNkpFlS0f2mXqhdus51n3NrrZ4I9Q/DjnPbcPjyQXgTRz6uxgOgMwa4+3CIqJBcSb6CH7dOUT8/0fZpBPhd/++9dqk6aFy+mSrutPTwP1713Zi3/wxoVlvBkmJSmEXysUo+VcnHKrlYJZiXOR/ruXPnHNtLNWIpuPTNN9+gSZMmKsg3d+5cNGzY0LHNvHnzVI5Be0X3+++/X92ePHmyY5vnn39eBR+lWJPsR2YnyozEmjVrFun7J6ICKNK5+fsiL9Kp01j2Mk+kHHx4eDhiY2MRFhZWWN8LEeXAcmQpUmc9BF3pegh4bKnHLznxBmz7yF3Wn1iDz1Z9gPCAEviy72QEm3KXi+WPXb9ixvYf0KpSW/yvi3cUq9DSk5A8vjmQEouAp9ZAH1nD3Yfk9dj2kbt8vuojlWPw5uqd8VzHl3P9PEmz8Oa/o1TahQl3fweTwYTiTrOkI2ViK2gJFxDw6L/Ql2vk7kPyemz7iNzPcmYLUqffAV1YRQQ8vb7IcvBzJiERFTvpW67NImSAkMh7JaUlYcqmr9XPQ1o+nusAoehRpzeC/IKx6fR6nLhyHN7AsneeChDqq9/CACGRF9tyeqMKEIaYQjG4xWN5em79sg1Rr0wDXEmOxoojS+ANZJmxBAj1FZozQEhEPsO8ecq1PKxFWKSTQUIiKnYl4K2Hl6gS8MareceIyDvN2vGTOtGV5XMdqt2Sp+cGm4LRq+4d6uc/ds+GNzBvu5q0vxkLlhB5q+T0JHy7YZL6eXDLxxAeWCLP++jXaIC6nrv7N1X0xHsKlrDtIyLfoCVcgmX/fMDgD2OTgUX62gwSElExPEkuuhLwROQeR6MO4+8D8+Gn98NjrYfla9bw7XXvhL8xAGtPrMa5uDMozqznd8J6dht0IeVguKmnuw+HiArJL9t/RFTSJTQq1wSdanTN1z5kYKVmydq4lHgRq4+tQHFmjT4K6/FVQEA4DPXudPfhEBEVCfOOnwFLGgz1+0IXXApFiUFCIio2NHMKzNuvloDnaDKR17JYLfhmw0RVpEiqdZYPq5Cv/YQFhKPHTb3Ufv7Y/RuKs/SrxZoMTR8s0iUnRFR0Dl06gEX758PPYMLjbZ7Jd0oVeV6/Rvc78rNKm1rsizXJ4LBfoLsPh4io0GlW87UZ1C1s1dCLEoOERFRsqCnXydHQV2kPfS4qnBJR8fTvwYU4EnUIFcIqoW+D/je0rz717lazEVcdXYZLCRdRHGkpcbDs+QPQGWBs+oC7D4eICoEsC568fjw0aLiv8QP5Hhyxa1GpFapGVMO5+LNYf+I/FEdaejLMO2epnzk4TES+wnJwEbT4c9BXaAZDhaZF/voMEhJRsWF2FCwpuhLwRFS0opOi8Mt22+jp422ehp/B74b2FxEUia61esCiWfDn3t9RHJllFmR6Mgy1u0N/g4EDIvJMf+2Zg5Mxx1E1ojruqH/XDe9Pr9Pjnoa23IS/7/4VVs2K4jk4fAX6qh2hL1nL3YdDRFQkzJunum0WoWCQkIiKBev5XbCe2QxdSFkYbrrN3YdDRIVk2ubvkJyejFtqdEHDco0LZJ99G/SDQWfAskP/4kryFRQnmqbBfHWpsVS3IyLvIzlTZ+/8BTro8FTbZ2EsoJQCbaq0VzOyT8WcUBWTixsWLCEiX2O9dADWk2uBoJIw1OvjlmNgkJCIioX0rdPUtaHpQ9Dd4MwiIvJM285swboTqxFsCsGg5kMLbL+lQ8qooGO6NR1/7f0DxYn11AZolw9CF1EN+up5q/BMRMVjIEBysEr71KtuH9QqdVOB7dugN+Cehveqn3/fNUu9VnFhvbBHDQ4juAwHh4nIZ5i3XJ1FKDmojQFuOQYGCYnI42kpsbDsnmPLx9XsQXcfDhEVglRzKr7fOEn9/FDzIQgPLFGg+7+r4b3Q6fQq32F8ahyK3UyaZg+r4yci77LiyBLsPr8TpYJL4/6mDxf4/jtU74QyIWVVntcd57ai2LV9TR/g4DAR+QQtJQ7mXbMBnV71+9yFvU0i8njmnb8C5hQ1kqwPLe/uwyGiQjBn16+4kHAedUrXUzkEC1qFsIpoX7UjUs0pWLBvHooDLfGyLSeXwQRjY1tuMSLyHrHJMZi+5Xv182Otn0ZgIVTvlaXLd10tAPXbzuIxm1BLTYB5z++2E+WmHBwmIt9g3vUrkJ4EQ+2e0IdXcttxMEhIRMUnHxcLlhB5pdOxp1RREckb+HibZ1TC/cJwd8P71PWiA38hKS0Jns68cyZgTYeh7h3QBZV09+EQUQGbuvlbJKYloH3Vm1U14sLSuWY3RARG4sClvdh7cTc8nXn370BaIgy1urn1RJmIqKhomhXmLbb0WsaWj8KdGCQkIo9mPf4ftOgj0JWsBX3VDu4+HCIqjHxc6yfCYjWrip5VI6oV2mcs+25ZqQ0S0xLxz8EF8PjO4rYf1c8sWELkfbad2Yw1x1ci2BSMR1o9UaivJVXipYCT+H3nrEJ9rYIt1jTI3YdDRFQkrMdXXz3nre32c14GCYmoeCRvbT4EOp3O3YdDRAVsxdGl2HdxN0oHl0H/RgML/fO9p5FtNuH8vXPV0mNPZT26HFrMSehK14O+EGcYEVHRkwru3274Sv38cPOhKBEYUeiv2a12T4T5h2PX+e04eGk/PJUUK9Eu7YMuvDL01Tu7+3CIiIqEefPVc96Wj7r9nJdBQiLyWNa4s7Ac+gfwC4Sxka06HxF5Dykg8uOWKernoa2fQoBf4Vdxq12qDhqXb4a41FgskfbFQ5m32mcRDnJ7Z5GICtavO37GpcSLaFC2EbrW6l4kH6+/MQB96t+tfp6zy3NnEzpmEUqxJr3B3YdDRFTorDGnYDn0L2AKgbGhLYesOzFISEQey7ztJ0CzwtigH3QBYe4+HCIqYD9umaoCha0rt0OLSq2L7PO1zyact3cO0i3p8DTW2NOwHF4M+AXB2NC2RJCIvINUGV6wfx789H54ou3wIh0E6HHT7Qg2hWDLmU04Fn0EnkZLioJl33xA7wdjk8KfWU5E5DmDIxqMje6Dzj/E3YfDICEReSbNkgbz9p/Vz8YWg919OERUwPZd2I3lRxYjwBiIR1s9WaSfb/0yDVG3TH1EJ0VhxZGl8DSq7ZMBkob9oPMPdffhEFEBMVvNmLxuvMo52q/x/arqelEKMgWhd907HRXlPY1556+AJRWGur2hCy7l7sMhIip0WnoyzDtmeFSRTs4kJCKPZDmwCEi8qHJx6cs2dPfhEFEBktl731zNxzWgyYMoWcQngzJz556GA9TPc/fMhsVqgafQLOkwb7/aWWTSfiKvsmDfnzh+5Sgql6iKO+vf45ZjuK1uHwT6BWLDybWqsrxnFWv6Qf3Mto+IfIVl3zwg+Qr01W6BvlRteAIGCYnIswuWeMiIChEVnPn75uJ07ElUi6iBXnX7uOWjbVqhOWpE1sLFhAv47/hKeArLwX9sAyQVW3CAhMiLXIg/j193zIAOOjzV9llVcdgdQv1D0fOm3tCg4Y/dv3pWZc8rx6ErdRP0ldu6+3CIiIqkmnv65u/Vz8aWj8BTMEhIRB7HenE/rKfWA0ElYajT292HQ0QFfKL8286Z6kT5ibbPwOCmxPRqNuHV3IR/7J4Nq2aFRyXt5yxCIq86Efxmw0SkWVLRs05v3FS6rluP5456d8Fk8Md/x1bifPw5eALzFnvBEhZrIiLfYD27Fdr5XdCFVYShiIpY5QaDhETkcRwnyU0fgM7o7+7DIaICPFH+fuMkdaIsCfSl0rA7tarcFpXDq+BM7ClsPLkO7maNOgzrif+AwAgY3DTDkogK3qpjy7Hz3DZEBpXEwKaD3P4RhweWQPfat6nBkbm7f3P34cAaf85W2dMvEMZG97r7cIiIioR58xR1bWw+2KOquTNISEQeRUtNgHn3bJnnA2Ozh919OERUgNafXINtZ7egRGAEBjZz/4myXqfH3VdnE87Z/asKYrqTeduP6lpVt/MLdOuxEFHBiE2JxfTN36mfH2v9tCoe4gn6NLgbRr0RK44uxeXES249FovkYdUsMDS4G7qAMLceCxFRUdASLsGy7y/A4O9x1dwZJCxECxYswJNPPqmuiSh3zLt/B9ISYajdHfrwyvzYiLxEUloSpm76Rv08pMVjCDYFwxO0r3ozyoaWx7HoI9h2drN7q9tJZU8uNSbyKj9s+Q7xqXFoU6U9WlVuA09RMqgUutTsBovVjHl75rjtODSr2VbRHYCfBwweEREVBfOOnwFrOgz1+3pcNfd8BQknTpyIatWqISAgAG3atMHGjRtz3H727NmoW7eu2r5Ro0ZYuHBhhsdl5H7MmDEoX748AgMD0a1bNxw6dCjDNtHR0XjwwQcRFhaGEiVKYOjQoUhISHA8npKSgiFDhqj9G41G3HXXXVmOY86cOejevTtKly6t9tOuXTv8888/KAwSGJw3b576Wa4ZKCS6PmkLWLCEyDvN3PEjriRHo0n5Zmhf7RZ4CsmJeHcD2/K233fNcttsQjWanBJjq24XWcMtx0BEBWvH2a1YdXQ5gvyCMbTVUx738fZt0F/NqF5y+B9cSb7ilmOQZcZa/DnoyzeFvnwTtxwDEVGRD45s/cHjCpbkO0g4a9YsvPjii3jzzTexdetWNGnSBD179sTFixddbr927VoMHDhQBfW2bdumgndy2b17t2Objz/+GOPGjcPkyZOxYcMGBAcHq31K4M9OAoR79uzB4sWLMX/+fKxatQpPPPGE43GLxaICjM8995wKMroiz5EgoQQpt2zZgi5duqBPnz7quAorQGjHQCHR9UmxEu3yAegiqkFfvRM/MiIvcSTqMBYdWAA/vR+Gth6mioZ4kltqdEHJoNI4eGk/9lzY5eaCJUyzQOQNUs0pqliJeKj5EEQERcLTlA0th5urd0G6JQ3z9/7hlmNwnCg3H+yW1yciKmqWg4tsgyMVmsFQvqnHfQE6LY9D5jJzsFWrVpgwYYK6bbVaUblyZTz77LMYNWpUlu0HDBiAxMREFdiza9u2LZo2baqCgvLyFSpUwEsvvYSXX35ZPR4bG4uyZcti2rRpuP/++7Fv3z7Ur18fmzZtQsuWLdU2ixYtwu23347Tp0+r5zuTGYUxMTGYO3fudd9PgwYN1DHKTMbciIuLQ3h4uDpGmY2YmwChszvvvBO9e7NaKxW8c3FnsOzwYlxKvIjSwWXQtVZ3lA+rWKw+6tQ/noJl35/wu/VN+LXxvBF3X3a9to8oOxarBa8vehlHog7h/iYPoV/j+z3yw/p7/1+YsulrNCrXBGO6v1+kr209vwspU3pAF1IWAc9sgs7gV6SvT9lj20f59eOWKZi3dw7qlWmAt3p8oGbseaIzsafxwrxhMBn9MemeKQj1L7p/463Rx5AyuT0QEI7AZ7dC5+cZ+RqJbR9RYUr5qR+sJ9fC1GecRxZrytO/VmlpaWoGnvNMPb1er26vW+e6KqDcn3lmn8wStG9/7NgxnD9/PsM2ciIqwUj7NnItS4ztAUIh28try8zD/JIAZ3x8PCIjsx/ZS01NVR1E50t2rhcgFJxRSIVh+eHFGPHnU6ozuvb4anUtt5cfWVJsPnAt4SIsBxYAxgCVtN+X5TWlg93MmTPVDK3M6RZyk9KBqLD8e3ChChBWCKuEOxv089gPumutHggPKIFd53eoGYXumEljaPogA4REXkBynM7fN1cVBnmi7XCPDRD+P3v3ARbFtcUB/L+FrqCAKHaxIwqIPXaNGnuNNdZoNMZokpdiYjSmmWJiTGKMJdZo7L33FjuIiiD2CoqiotJ3d953LuxmwQVpy7bze9++bbMzs7NyM3PvuecAQBm3smhcoamIfNwakf11jPGKNfXhDkILxnn4Gcs5TcxF0UEIZw8oanaBOVLmZuGHDx+Kab0U5aePnl+8aPiEmjoADS1Pr2vf176W3TJeXl4Zd1ypFJ172mXyYvr06SKv4euvZ90hMW3aNEydOvWF12NjY0Wnqb6XdRDqL0cX/owVhJj4e5h97FdI9L/0wGDt/eyjM1FS6Q0vl4x/X+ZIGTIP9pSfoUonxCZogISHhbp9T0/zSBirTelAkdbUTvzyyy9iYCUyMvKFdlDfjRs3RDR2s2bNXnhPm9Jh8eLFqFSpEj7//HOxzvDwcNERyZixPEqIxT+haR1goxq+DTszjpBzUDqgi293/B2yCOvOr8QnracUynal5GdQUdEAmRzKgAGFsk3GmHGjp/889hs0kga9a/dDWQsowtaz9us4evOwiKju4tujUApLSaokqM6tEI+VVl6whAZ/f/zxR3HdSqm6fvvtNzRo0CDbfP50rkbndlWrVsX3338vZtDp59mn80QK3qG8/ZQ6i2bpGULXBPRZmoW3fv16g3n7CzIPP+FZc8yYLH32nCpkkbhX0sCw0tHyOwmtyfLly0Xn38aNG7O98J44caK4YNeiSEKaXu3h4fHClDuaSpyTjkJazlw6JJjl23lri4geM5Q5gF4/E3sKAysMhbknb02KXAf6Bi6vjIarDf99/Pzzzxg5ciSGDUtLYksngXQCtmDBAoMpHQgN3lDeVmrTDh8+LNItaNG/C+ponDRpErp16yZeW7JkiRiIoZQMlNKBMWNZdHo+ElMT0cKnNWqVqmP2B7pdtY5YH7YGwXdP4fqja6hUCAVEVOfXAKkJUFRrD7kFneQyxgzbdnETrj26gjJu5dDdz/ymkRlSoXgl1C/bCKfuHMfOyK2i09DY1Be3AImPIS/fBHLPqrBWuR381ebzp0CVzp07i2tW6tijWgB+fn5iGUrl1bRpUxHoQueM2aHtGSsPcFZ5+Al3FDJjzZ6j4BjttS/db7ywFmOajBfV2s2dlPQUqvOr0waG65rv4EiuYt+pY0uhUOD+/fsZXqfnpUqVMvgZej275bX3L1smc2EUlUolRk6y2u7LpuS9+eabWLVqVZZFTrQcHBxEZ6D+LSvUGFIHYHY4JyEraDHPY8RotSHU6UajLOYurbJdlKhsZ47JWwtLXlI6kC+//FKcaFKBqMxyktIhv6kWGDPkzN1gHLt5GC72RfBG0Iv/Ns2Rk50zOtVI++/4+rBVhVPR/Qwn7WfMWsQ8v4+VoX+Lx281eseso6cz03YM0jTppNT/ikcai60ULNEf/KUc+9RZ6OzsLAZ/DZk5cyY6dOiADz/8EDVr1sRXX32FunXr6uoBkDfeeEOkkXnZdWxoaCh++umnLLeVH9ml2eL0WsxYEYTa2XN07at/T7Pnop9Gmf2BV51flTYwXNW8B4ZzFUlob2+PoKAg7N27VxeqTHn96Pk777xj8DONGzcW70+YMEH3GlUoptcJTX2jjj5aRhsmTRejlGtwzJgxunVQZAxdPNP2yb59+8S2cztt959//sHw4cNFR6ExRji06zTUaHIHITOGRwkPsnyPxg0pDNvcqYLTq3oGmXfEo7HlJaXDkSNH8Ndff4kTQUNyktIhv6kWGMssRZ2COcfSLmi6V+uD1OepePi8cFMI5FWDEk2wUbEOx2/+i7Ab51CqSMbiaAVJfi8Ejg8uQlO0LB4XrUWNAAobz2xgrOA6/eed+APJ6mS8Wu01UbDEklTxrAb/0nVxNioEey7vQGffgp2Wqk8TEw7NnVOASwkoqneAtQ/+0sy03OTz15/FRijyMCcFOfUlJCRgwIABYqpzToJqaHCYbloFkYefcEQhKyg0xTi72XP7ruzCwLrmey0pSRqogtOnGtcbDnOW6+nG1GgNGTJEFBGhXAoUwkwhz9qpcYMHD0aZMmXEBSYZP348WrRoIUYxqJGgzrnTp09j7ty5uh+UOhC//vprkXNBmy+LKhZrOyJpFIVGVGgUhkZfUlNTRackTZPTr2xM+bWoMaYIQypIor1o1nY+Urg27TuN0FDnovYCmRL5U2SNMTsKuYOQGcPeyztx8UFElu9TI0rJ+M2ZJvYKNDcOAY7FoKiZfSQuy4jaORpNnjdvXoFf6Ocm1QJjmS0/swSxiQ9QvYQvugb0MOuk/Zl5whMdanTGxgtrcODuHrzzSsaLtYKU/O8GqGnWQr2hKFLC/Ad0GGNZ+/fGIYRGBaO4kzsGBprvhWp2etXuKzoJqQBeu+odYa+wN24UoX9/yIy0DXNgjHz+OfXee++hSZMmulQzL8N5+Jm5u/PotsEOQkKv0/v0N2eu5HeOwvHRVWiK+eCxS3WTDAyTnFwz5rqTsG/fvnjw4IEIcabGijrgKBGqtjG7deuWGCHRosaJOucoH9ann34qOgJpJESbU4F89NFHoqNx1KhRImKQcizQOvUT6i9btkx0DLZp00asv1evXiIRvz5Kynrz5k3d88DAQHGv/cdEHZM0TXns2LHipkUdh4sWpfXqGqOjkDsImTGE3D2FuSdm6fJo7b60XTe6Qv8jVFHP29V4UTAFe6LYDzI7J9iy3KZ0uHr1qkhq3aXLf5WxKMJaW9yJ8t3op3Sg6sb668wqybU21QLdGMut209uiQtMhUwhipVYUgehVuea3URescPXD6BPnQEoWTT3qU1eRop/CPXFrYDCHso6fQt8/YyxwvMs+SkWnkoLgBjRYHShFP4wBop+9C3ph/D7Ydh/ZQ/aV/+vWEZBkZKfQxW2Rsx3UQYOKvD1s7TrT5p1RwVNcorz8DNzV8K1BKRow52EdA1c1r2cWc+OSN6/Lm1guOFIFClRAuYsT4VLqLMuq+nFBw4ceOG1Pn36iFtW6EelnFp0ywpVMqbOxuzQxXJ2DO2bMVFHIYdYM2O4GnsZPx/8TuRhGBw0QlSi61yzuwizpnw4dHL3JOkxElMTzPoHkFISoDq30iZy0hgjpUONGjVw/vz5DK/RgAxFGFLENEX+2dnZvTSlA2MFPd1OrVGhW63eKF+8okUe3GJOxdG2Sntsj9wsIgppwKWgibZPnQJFrR6QuZjvSS1j7OWWBC/A0+Q41C/XCA3LN7HoQ9ardj+E35+EDRdWo03VdlDKC7bOpajmnhIPeZVXIbeAys/5YYx8/jlBHYQ0kFysWLEMr1OQTbNmzQxeE+dmcDi79FpaHCTDClJcUpzIdW2ps+c0T26LHPywLwKlX2+YO8sb3mfMxt1/dg/T9k0VOW861egmOggJRQxSHob3mn+M/7X4VLy25twK0aiaK3X4eiD5KeQ+rSC30M6EgkZTfGn68OLFixERESE68jKndNDmtqFoa4rK1r/RCWHRokXFY+p01E/pQCdz1KlI69BP6cBYQTlwbS8iYsJELtTetS27cnbXWj2hkCux/+oexCY8LPi8NGeW2tQACeXFqlixomi3KOXLyZMns1z2woUL4mKWlqc2jFLbZKZ9L/NNf6ZIUlKSeE5pEooUKSLWmfnim7H8Oh99Fgeu7oGTnZOIIrR0tUv5o6pndTyMf4DD1/YXfLGm9BkkdmZc2dMYg79a2sFfbX7+rPL569PP558Tn3zyCc6dOydSb2lvZMaMGVi4cCEKQnYFO7mDkBV0pPZXez7DvefR8HIpCRlk6bNU/qvaPabxu2Y9e04VQvn3JShrvw6ZQxGYO+4kZMyCUIffN3snIy7pCRpXaIrB9QxXDK3uVROvVGyOhNR4rDybVmXP3NCJYqo2eauNFyzJnNJh+vTpIqUDRf7RiV3mlA7R0dG5WieldBg3bpxI6VC/fn08f/78hZQOjOXX06Q4LA1Oq6A4osEYONpZ9r8vT5cSaOnTGiqNCptpQKMAaa4fhPTkJmQlakBetgGs3cqVK8UAyJQpUxASEgJ/f3+RiD8mJibLhPs+Pj747rvvsoyeOXXqlGgLtTe6iCb6M1coJ9fmzZuxevVqHDx4EFFRUejZs6eRviWzRcmqZMw5kVakifIQejhbflQwdbb39EurdLwubBXUGpogVzA0d4MhxVyAzK2sGCC2BbkZ/NXm86dzNMrnT3kLv/jiC5HPX39GCeXfp/NDysdPKL0MPdfmLaR2M/MgMilfvrzI/19QDHUUcgchK0jPk5/jqz2f4+bjG/Bxr4IfOs/EzG5z0NW3JxqVbwJHZdq5ppOds9keeCk1Eaqzyy3rmldiuRIXF0cT4cU9Y4UpKTVRmrjtfan3kk7S5zs+kpJVydkuH/P8vtR/WQ+pz9Iu0o1H1yVzo7pzWor/ppSU8FuQpFGrTL077CW47WMvM+vfX0T79OOBb6zmYEU/jRJt6IBlPaUniU8KbL1Jq4eI9i/l1ALJFjRo0EAaO3as7rlarZZKly4tTZs27aWfrVChgjRjxoyXLjd+/HipcuXKkkajEc+fPHki2dnZSatXr9YtExERIc7hjh07luN957aPZWdZyCLR7n26/QNJrVFbzcGiv6MPNr8jvtvhawcKbL1Jm8altX3/zpRsyW+//SaVL19esre3F+3h8ePHde+1aNFCGjJkSIblV61aJVWrVk0sX6tWLWnr1q0Z3l+4cKFoyzLfpkyZkuU+0Pvr1683Stu3ZcsWadSoUeKesYLyPPmZ9PHWCaId+t/mcdLTpKcvLEPtE70/Zu0wKSk1ySwPfmroP6LdS1z2umQpOJKQMQtAo7i/HP4Rlx9GooxbOXzYctJLK87RdD8aZaFpbYtPz8uyGpSp6ErA1x0MmVxh6t1hjOVDBCW5v7objkonDKs3ymqOZami3mhasTlS1MnYGrGxQNapeXoX6su7ATtnKGubf16a/EpJSUFwcDDatm2re40K0NHzY8eOFdg2/v77bwwfPlxEQRHaZmpqaobtUh5XiqTJbrvJyckib6v+jTFDbj6+jk0X1om0BKMbjbPIIk1Zob8jqnRM1p1fKXJg55eU8Ajq8E2A3A7KOv1hSygKkIprUvtCOaEp5YIW5QfMXECTIqIpOpCWDwsLE8U59Q0dOjStUGGmG0UdZoXeN1aaGYoonDNnDufiZwUmPiUeX++ZLPLwly9WEZNf/RpFHYq+sBzNnKvh5YsH8TGiaJ55zpxbIB4r66VFD1uCgs1EyxgzSuOy4NQcnL5zAsWd3PFZm6kGG0lDutXqJYqZnL93FqfvnET9cv+dlJiSqOoZsSmtqqf/AFPvDmMsH1LVqZh74g/xuF/AIHhYWRGOHn59RJXjHZFb0K1WT7jY5y+XjCp0OSBpoKzVE7IctuWW7OHDh1Cr1bqUCVr0nKbSFYQNGzbgyZMn4sJZi6bdUT6wzIn7abvaKXmGTJs2DVOnTn3h9djYWNEZyRihTrPfjv0MtaRGR5+ucFK5iH/r1qSyczWUcvHG7bhb2HdhNwJKBeVrfcpzi2GvTobKpwNik2RAkmmPlzlXQWXMllHhzW/3TcGV2Eso51Yek1/9BkUdXLMc0Bhe/y18vHUCNoStQcvKbUSgjLnQRIVAunceMtcyUFR5FZaCOwkZM3MbwlZj16VtIiH2xNZf5Krho88MDByC34/OwJLg+QgoXRd2CjuYmurcivSqnj25qidjFm5L+HrcibuFSu6V0aF6Z1ibcsUqiGqlJ24dxY6LW9CrTt4LskjqVKhDl+miqFnB+Ouvv/Daa6+Jgkz5RbnBKIeYFkUSUqV4Kn7i6mr4IoXZnm0Rm3Az7jpKu5bFwIZDXzq7w1L1DuiP3//9GbtubkObWu10kbq5RbNaki6tE3NiXRqPhCt30DHGDEhMTcS3+77ApQcXUca1rOggdHN0y/ZY0fln26rtsfvyDiwNXoj3m39sNsdWdTo9irDuEIuaOWc9cfGMWaGD1/ZheegSKGQKfND8U1Ry98n1Opr5tEJlj6q49yxaRMKYmqRR6yrbWUzyVsZYltXWV59fISrNjWz4NhQWdAKUGz3Sk/hvvbhJnMDmlfryTkjP70Neui7kpWrDFlC0jkKheKGqMD3PqihJbtAUvj179uDNN9/M8DqtmyL/KMIwN9t1cHAQnYH6N8b00bQ2OjcjoxqNtdoOQtK0Ygt4FSmJ64+uIjQqOM/r0dw4AunRNcg8qkJePudVehljtiNZlYTv93+JizHh8HYtgymvfotiTsVz9Nl+AW/Axd4Fx24exoV752AOpOcPoI7YDCgcoPS3rBQL3EnImJk6Fx2K2UdnisdjmoyHf+nAPK2HcuRoc4StObdCVEg2Jc21/ZDibkPmVQvyMvVMui+MsfylQvjr5GykqlPQrnpHVPWsbrWHs7JHFQSUDsKz5KfYc3l7ntejClmqG1G2FTTlNygoCHv37tW9ptFoxPPGjfPfWbBw4UJ4eXm9kAuLtmlnZ5dhu5TjiyrEF8R2me22e/NPzBYXs22qtEOtktbd2U8DP5Rygaw9vzLP+a1VIYv/y0Odx2hExph1V4r/fv9XuHD/PEoW9caUV79BcWf3HH/e1dENff0HiccLTs0t0KrseaUK/RvQpELh283iZs5xJyFjZuj6o2uYfvAbketmQMBgtPBpna/1VfeqKRK7JqTGY+XZv2FKqekFS+yChvCJImMW7Pitf3EmKliM8vYPsP6ps9ok/pvC1yNFnfvcdJpH16C5cQhwLAZFzS6wJTR9d968eVi8eDEiIiIwZswYxMfHY9iwtCTegwcPFtN8tSgCMDQ0VNzo8d27d8XjK1euZFgvdTZSJ+GQIUOgVGbMoOPm5oYRI0aIbe/fv18UMqHtUQdho0aNCumbM2tz7OYRhNw9BTfHYhhUdzhsQQufNvBw9kTkgwiE3z+f689rnt2D+tJOQOkIZe20DkfGGNOic6ofD3wtcuhT5PIXr34r2pzcaleto8hheOvJDey5vMOkB1jSqKA6s9TiCpZocSchY2Y4jWXavi/ElLZXq72G7ukjuPk1MHAo7BT22HN5J24+vgFT0Dy+Cc3VfYBDUShq9TLJPjDG8i8hJQELT80Vj4fWGymmeFg7qp7nW9IPTxIfY/+VPbn+vC7NQp3XIbNzgi3p27cvpk+fjsmTJyMgIEB0+O3YsUNXzISi+6Kjo3XLR0VFITAwUNzodfosPc48pZimGdNnqaqxITNmzEDnzp3Rq1cvNG/eXEwzXrfO/KofMsvwPPm5KCRHKFF+EYf8FTGyFJTLmgrhaaMJc0stijWpoajVA7KX5BZjjNle8bvpB77B2egzIu/+F69Og6dLiTxHPg+r/5Z4/E/oUjH7w1TUl3ZAehYt0ssovANgabiTkDEzOwH9Zu8UPE58hHplG2JE/dEFFm1XoogXuvr2EMmjF5+el+cpI/mhOkMXyRKUtV+HzN650LfPGCsYK84uFe2Uv3cgmlRoZjOHtVfttKIlGy+sgUqjyvHnpNREqM6vEo+VgW8Ybf/M2TvvvCPyByYnJ+PEiRNo2LCh7r0DBw5g0aK0KHNSsWJF8d+ozDdaTl+7du3E69WqVTO4TUdHR8yaNQuPHj0SkYvUQVgQeRCZbfo7ZAHikp4gqEx9NK7QFLakdZV2InqSIn0oojBX0TQ05Y6LNTHGDHQQ/nRompiVQpGDlIOQrlfzo7a3vyg2F5/yHCvTC8WZgur0QovOv8+dhIyZUaj1Dwe+wt242yK314RmHxZ4EYButXqjuJO7OMkLvnMShUlcJJ/9x+bycTFmba7GXsGOyK2wk9vhzYZv21TagNql/FHFo5qI+D58PWOHVXbUFzcDiY8hr9AUco8qRt1HxljBozxZe6/sgqPSyebaPeKgdEAX3x7i8br0AY+cUF/ZkxZN4+1vkdE0jDHjoIHWXw7/IK5H6dqUOghLFi2YQbzBQSPE7Lldl7fjxqNrKGyamIvQ3DoKOHtYbHoZ7iRkzAxoJA1+//dnRMRcQKmi3vi41WQ4KB0LfDtOdk4YGJjWQbck+C8xglNYMlwke1YttO0yxgoOJYKee/x3EZFMOfqovbIl1DHQMz034frzq3KcGFs31ZgHSBizyEHcOcd/F4/7B7yR56lwlq5dtddQxL6oyMlI1Y5zVbAk0Prz1jLGcobOnWYe/hEnbx8Tea2/aDcN3q6lC+zwUV5DSpFA56pUxKSwZ8+pQtJmRigDBkJmhOv5wsCdhIyZAeqwo2TYNJXjszZfws2IOVua+bRCZY+qiH4WhR2RW1BYVMHpJ4pBHEXImKXadWkbrj26gjKuZdHVRvOKBpWtjwrFK4o2lIq3vIzmfhg0d4MBFy8oqrUvlH1kjBWcdedXIvrpXRFF3L56xiratsTJzhkda3bNcW5CzeMb0Fw7ADi4QuHbvRD2kDFmCR2Ev/37kzh/outeKlJS2rVMgW+ne61e8HAugYiYMHGNXVikpKdQnV8NyOSimrul4k5CxkxsS/gGbI3YCAeFAz5pNdnokTlymVwUGiBrzq1AXFIcjE0TfRaaqBDIipSColoHo2+PMVbwHiXE4p/QtIi4kY3GimT2toja0B5+r+um3VEkeI6iCAMGQGajx4wxS3Xr8Q1sCFsDhUyB0Y3HFXgaGEvzWvUuYlbKiVtHcfvJzWyXVZ1Jz0VYuw/noWaMiQ7CWUd/wb83DqGogyumvPoNyriVM8qRoRl5Q+qNEI+XBC9AUmpSofwCKkrHkJogrnflRuj8LCzcSciYCR29cRiLg+eLi873W3yCKp6Gk68bo0rnKxWbIyE1HqvOGj+pa6puuskbkMmVRt8eY6zgLTo9T1Rdb+HTBrVK1rbpQ9yo/Cvwdi2DW09uIPjOqSyXk5KfQRW2Nm1EOXBQoe4jYyx/aABgzonfoZbU6FqrJyoUr2Tzh5QqOneo3lkch/Vhq7M8HpIq+b881DZarIkxlrE9nX3sVxy+vl+kLaAOwnLFKhj9XM23pB9iEx5gw4U1Rv85JEkDVXD6VOOgYbBk3EnImImE3w8T4dZkVMOxqFumfqFuf2DgUJHUdfflHbj5+IbRtiMlPoH6wnpAroQiYIDRtsMYM54zd0+L6Rp0YvdG0HCbP9QUTdTDr49uKmJW+W5UYevSRpSrvGrRI8qM2Wp6hUsPLooZHtrK5gzoVLM77BUOOHLjEKKfRhk8JOqLW4DER5CXbwx5iep82Biz9QGX47/j4LW9cLEvgsmvfl0ogy6UR3p4/bcgk8mx6cJa3H92z6jb01w/BOnRVcg8qkJe4RVYMu4kZMwEaIoGVTKmyk696/RHm6qFn6eKSsx39e0hRj0Wn55ntKSuKspbo0qCotprkBdQ1SrGWOFJViVh/snZ4vGgusOMmjPVkjSr1BIlXLxwJfYSzkWHvvA+tam6pP11OZKGMUsSG/8Qy8+k/f2OaviOqO7L0tB/A16t1kGcP2YVncPFmhhj2nOh+Sf+wL4ru+Bs54LP236NSu6VC+3gUGdku6qvIVWTiqUhC4y6LZU2irDecNFBacm4k5CxQhab8BDf7P0C8SnxaFW5LV6vY7roum61eouy8+fvnRUl6I0Sdq3NxxU0tMDXzxgzvrXnVyHm+X2RpqBVlbZ8yNMp5UrRhpJ1YS8m8dfcOQXpQQRkxcpD7tOKjxtjFnRR+9fJP0V6BTpPq+3tb+pdMjtdfXuKNvDg1b14EB+T4T1NTAQ0dE7p7AlF9ddMto+MMTNoS0/9KWatUeGjSW2/RGWPKoW+H30DBoqZMJRL9byBQd2CoHlyG+rLuwD7IlD6pZ0bWjLuJGSsECWkJGDavi9EboSA0kEY1egdk440UPLpgYFDdBWWU9WpRgi7vgaZZzUx5YQxZlluP7mFTeHrRNJ+SotA+VPZf6jTlAZaKH1ERMyFDIdGdWbJf7lY+bgxZjFO3j6GU3eOw9XBjdMrZMHd2QOtq7QT+Ro3XViXRbGm/pAp7I3/gzHGzLKDkHJZ74zcCkelEz5rMxVVPU2TeoCKpPQLSJvRsfDUXDGTr6CpxMwRCco6fSFzKAJLx2f7jBUS6oCbfvAbkf+Pwqzfb/6JGIU1tWY+rVDZoyqin0VhR+SWAl23KiQ97LruUIsPu2bMFk/w5p2YBbVGhS6+PYyeYNoS2Svs0cW3u67SsZaUEAt1xGZAbgdlHc5lxpi5i356F8tCFmH6wW/x+78/i9eG1R8lLi6ZYd1q9RIDSHsv78TjxMfiNSklHqowmoIsgzL9opwxZnvnjzS1d9vFTaLK8KdtvkD1EjVNuk9tq7ZHheIVcTvuFnZFbivQdUupiVCdXS4eK+umBd9YOu4kZKyQGkuq6ETTeku4lMTE1l+IKD5zQJFBQ+uNFI/XnFuBuKS4AlmvJu4O1Jd3A3bOUNa2/LBrxmzNgat7RHQctVm9uaMrS22rviY6EkKjgnE19op4TXVuJaBOgaJGZ8hcPAvvR2OM5dr+K7sxfuNoETVN09GSVEni9VR1Ch/NbHgVKYnmPq1Erq/N4evFa2qKKkx5Dnnl1pAXK8fHjzEbvOalfK7UJlCBo4mtp6CmVy2zKDg3rP5b4vGqc8sK7HqXqMM3AomPIa/YHHLPqrAG3EnIWCH4J3SJruQ7hVsXdypuVsedco01qdAMCanxWHV2WYGsU3Xmb0DSiLwMMoeiBbJOxljhRNP8eOAbXbGSNxuOFiPBzDAa8OlUo6t4vD5sVVou1jNLxXNl3cF82Bgz8zaPBnElSKICpz56PavqvSxNd78+Ip0CVYKOS3yC1PSpxnZWEk3DGMudlWeXiYJGdgp7fNJqMmqVrG02h5D2ha53qS7AitC087SC6BRNDU4riKKsNwzWgjsJGTOynZHbsD5sta6xLONW1iyPOVUtpX2k5LK3Ht/I17okdQpUoWmdjVywhDHLi6ahnFwp6VE0BTnaaq061OgsknJTFNLNC+sgPb4BmWd1yMs1NPWuMcayse/K7izTodDrVJGTZa20axlx0Z2sSsLW0/Mg3Q+DzLWMiCRkjNmW1ef+wdrzK2Ant8PHLSeZZdGnN4KGiwhHSpNwLX32R35ookIg3Tsv2j1FlVdhLbiTkDEjOnX7uKjqJIMM45v+D9W9TJuPITslinihq28PEQWz6PR8MTKSV+qLW4GEh+ICWW7G35kxloNomqMzOZrmJVzsi6BD9c7i8fpz/+iiCDkXK2PmjSrzZnW+Q69mrtzLXtTTr4+433HjMOJlCigDB0EmV/ChYsyGUF5mmo1G+fY/bPkZ/EvXhTnydCmBHn69xfnuglNz83W9S1Sn06MIg4ZaVbvHnYSMGUnkgwjMOPyD6HQb3uAtNCzfxOyPdbdavUWlzvP3QhF852Se16MK/q9gCWPM/HE0Tf51qtkNDgp7HFMl4b6jq0i1wBgzbyVcvLKOJEx/n2WvfPGKaFC6HhKhwd6iJaH0H8CHjDEbsvHCWpFaSyFX4oPmExFYph7MWRffniLfduSDcBy5cTDP65GeP0grUqdwgNK/P6wJdxIyZgRRT+/i+/1fiaTXVP1NG2FiCbm1BgSm5ZFZEvyXqMicW5qYcGiog9HZE4oaHY2wl4yxgsbRNPnn5uiG1s5ekGQybCtbDzJHrorKmLlrXeXVrCMJJQmtq7Qr9H2yRF3Ti/HtdCuDJM5DzZjN2BK+AX+HLBSVzt9v9jHqWUCaFQelA4bUGyEe074npibmaT2q0L8BTSoUvt0gc/aANeFOQsYK2JPEx/hm72Q8S36KZpVa6jrdLAVVqqvsURXRz6KwM3Jrrj+vCl4s7pUBAyFT2BthDxljBY2jafJPUqeiw+1TUEoaHE55jofxDwpgrYwxY/J2LYMxTcaLtDBymVwU4RD3kInXvV1L8w/wEtSZWj58M2onxuE5NNhzeTsfM8ZswPaLm7E4eL5oM8c3+xANyjeGpWhQrjFql/LHo4RYUTsgtySN6r8idVZUsESLOwkZK0A0EjFt31TEPL8Pv1J1MKbxeNFwWhLa36H1RuoS0OamaIGU/AyqsDWATC5y0jDGLANH0+Sf+spuFHsWheaSDGpJjU0X1hXAWhljxtaqclvM7DYHXX17okmFpuKentPr7OU0N45AenQV3dIvKzeFr0eyKpkPHWNWXphzwak5YmDl3ab/Q+MKTWFJKM3EsPqjxHXv5vB1uPcsOlefV1/aAelZNOSl60LhHQBrk6fei1mzZqFixYpwdHREw4YNcfJk9rnLVq9ejRo1aojla9eujW3btr0wAjV58mR4e3vDyckJbdu2xeXLlzMs8+jRIwwcOBCurq4oVqwYRowYgefPn+veT0pKwtChQ8X6lUolunfvbnBfDhw4gLp168LBwQFVqlTBokVpudMYyy+1Ro0Zh77DtUdXUL5YRfyvxWewU9hZ5IGt4eUrqtUlpMaLJLQ5pTq/GkhNgKJqO8jNtIozY+xFHE2Tf6qQtCjqbr49xEnnnis7RWQ5Y8z8UcTgwLpDMaHZR+KeIwhzTnVmibj3DRiIWiVri3Zv/9XdRvutGGOmtefyDsw/+YeIuB7X5D28UrG5Rf4k5YpVQPvqnaDSqLDk9F+5+qzq9EKrjSLMUyfhypUr8f7772PKlCkICQmBv78/2rdvj5gYw9W/jh49iv79+4tOvTNnzojOO7qFhYXplvnhhx/w66+/4s8//8SJEyfg4uIi1kkdf1rUQXjhwgXs3r0bW7ZswaFDhzBq1Cjd+2q1WnQwvvvuu6KT0ZDr16+jU6dOaNWqFUJDQzFhwgS8+eab2LlzZ24PA2MvdHTPPTELZ6KC4eHsiU9bfwEXexeLPkqD6g6DncIeuy/vwK3HN3J0DHQFS4K4YAljloajafJO8+gaNNcPAY5u8A4YIFJNUE7aLREbCvAXYowx8yI9vy8iaqB0hLL26+hVu6+ukEFe8lpbq4IOsFm3bh3atWsHDw8PERFF17WZg2vGjRuH6tWri+vj8uXLi2vkuLiczw5izJD9V3ZjzvHfRQfh200moJlPK4s+UK/XGYiiDq44dec4QqOCc/QZTcxFaG4dBZw9oKjRBdYo152EP//8M0aOHIlhw4bB19dXdOw5OztjwYK08s+ZzZw5Ex06dMCHH36ImjVr4quvvhKRfL///ruuY+GXX37BpEmT0K1bN9SpUwdLlixBVFQUNmxIO7mOiIjAjh07MH/+fNGwNm3aFL/99htWrFghliPUsTh79myxb6VKlTK4L7SvlSpVwk8//ST25Z133kHv3r0xY8aM3B4GxjJYc+4f7LuyC852LqKD0MPF0+KPUIkiXujq20NUZ150ev5LS8Rrbh2DFHsZMncfyCs2K7T9ZIwVHI6myRvVmb/FPV0ky+yc0cOvjziBpuk4z5Kf8T9RxphVUoUuBzQqKHy7Q+ZUDH6l/FHVs7rIyXr4+n5T755ZMEaATXx8vLge/v777w2ug66P6TZ9+nTxOZo5R9fStE7G8urgtX2YfexX8Xh043FoWbmNxR/MIg5F0D9gsHi86NQ8EVX4Mqrghf/l31c6ALbeSZiSkoLg4OAMkXpyuVw8P3bsmMHP0OuZI/uoYdQuT9F99+7dy7CMm5ub6AzULkP3NMW4Xr3/ymnT8rRtijzMqZftiyHJycl4+vRphhtj+qhzcNW55VDKlfio5WcoX7yi1RygbrV6o7iTO87fC0UwVSzOhi6KsO5gkZ+CMcZsgaRKgurcCvFYGfiGuC/jVg6NKryCJFUidlzcbOI9ZIyxgidp1GnVPdPP/QhFtfWq3U88pmIAlIrH1hV0gA154403RKqurGbP+fn5Ye3atejSpQsqV66M1q1b45tvvsHmzZuhUr28E4SxzA5fP4BZR3+BBAmjGr5jVZXfKS93JffKuPv0DnZc3JLtslLS0//y76e3e9ZImZuFHz58KKb1lixZMsPr9PzixYsGP0MdgIaWp9e172tfy24ZLy+vjDuuVMLd3V23TE5ktS/U8ZeYmCjCsTObNm0apk6d+sLrsbGxotOU2bawB+cwJzjtP9qDa7+JksrS4u/EmnSp0hNLzs/HwpNzUdahgugMzUwWHwPHyO2AwhFxZdpSYwFL4+npaVbTUn788UfRZtGIM0VON2jQwOCyNOXk22+/xZUrV5CamoqqVavigw8+ECeQWpS/9ZNPPhHR2dR2UUQ1TTsZPXp0IX4rxqyTOmIzkPgY8gqvQO5ZVfd6D7/XcezmEWy9uAmdfbvDyc7ZpPvJGGMFSX1lD6SnUZCVqg25XuL+umXqoWJxH9x4fA1Hbx4W6RdslTbAZuLEibkKsKHIw8xBLdoZdnlFU40ptz9dQ2cVGEM3LQ6MYVpHbxzGb//+LGaXjWgwGq9W62BVB0chV2B4/bfw+c6PROBP00otUMypuMFlVedXpeXfr94RctcysFa56iS0RdSo6zfU1GCWK1dO5ICghpbZrquxlzE/9A9oJA0GBw3Ha76dYY06eXTFv1EHxfc9/fC4uNjNLDViMVIlFRR+r8OzTGWT7Ke1TUuhkWaKqKZ0DHRyGBkZ+cJgCaHBks8++0zkrrG3txc5W2m0mpalzxFa3759+/D333+LnDi7du3C22+/jdKlS6Nr164m+JaMWQ/VmaXiXll3SIbXK7n7IKhMfQTfPYVdl7aJyGzGGLO2giV2dYeICEKttGjCvvjp0DSsO79KFDWgYk62yBgBNnndD4pI1M/nnxkHxjBDQu6dwl+hs0UHYZ+aA1DPo5HVBcQQT7kX6ns3wqno41h4fB7eqD38xYUkDRxP/iWm4sZX7YVnFnocchIYo8ztChUKBe7fv5/hdXqeVR5Aej275bX39BpVN9ZfJiAgQLdM5rwNFCpNSVmz2m5u9oU6+wxFERKqgkw3xjL8u3l2D9P2TUWyKgkda3RF55o9rPYA0Ynd0HojxejK6nP/oLlPK7g6uunel9SpunxcdkEZL5JZ/qalEOos3Lp1q5iWQtGAmbVsmXGEfvz48Vi8eDGOHDmi6ySk/DZDhgzRLUsniXPmzBGJs7mTkLG808SEQ3PnFOBSAopqaX9v+nrW7is6CTeHb0CH6l3gYKW5axhjtkXz5BY0V/cDDkWh8H3xHLhB+cYi7cKduFs4dfs4GpZvYpL9ZGkBLlS4k6Y6f/HFF1keEg6MYZnR3+6C0D/TA2JGoIuBv3VrMqLJaJzbGIpjdw6jS+3uqOJZLcP76msHkBx3AzLPaihe+7UMgyPWJlfDOhSlEhQUhL179+pe02g04nnjxo0NfoZe11+eUIVi7fI07Y067/SXocaMcg1ql6H7J0+eiHBtLYqKoW1TpE1OvWxfGMuJp0lx+GbvZMQlPREnPdRoWnMjQWp4+aJJhWZISI3HyrPLMrynvrwT0vN7kJeuC3mpOibbR2uQl7yv+qi4DLVxFHXYvHlz3etNmjTBpk2bcPfuXbHM/v37cenSJVEZjzGWd6rgxeJe6T8AMoX9C+9XK1EDtUv5i/9eUP5axhiznghqCUoq0mTvbHCAuZff6+Lx2vMrX1r8zloZI8AmN549eybyGxYtWhTr16+HnZ1dlstSUAwFzujfmO2iXPQ/HfoOakmNgYFDrb6DkHg4e6Kn3+si7+KCU3NE56jBgiVBw6z+2j/Xsd80bW3evHkiUoWqDo8ZM0ZUWNJGvQwePDhD3gWKaqFqSlRRmMKqaQTj9OnTorIwoQM8YcIEfP311+Ii9vz582IdNA2OKjkRStpKDRxF11Dky7///is+369fP7GcVnh4uCgBTxGGlHeBHuuXhKf8W9euXcNHH30k9uWPP/7AqlWr8N577+XvKDKbQZGD3x/4CtHPokTH2btN/yfyGNiCQXWHwU5uh92Xd+DW4xsvXiRzFKFRp6VkN82E2rsiRYqIgRwaLaYchq+++qrufXpOI8hly5YVy1B7SnkP9TsSM+OiTYxlT0p+DtWFtWnJqwMHZbkcRROSjRfWIlWdyoeVMWbRJFUyVGf/EY+zS9zfpGJzlCzqjeuPruJM1GnYImME2OQUBd3QYDDtA11jOzo65vFbMFtz5m4wph/8FmqNCv0C3kB3P9tJl0JptUoWKYXLDyNFsRYtzZPbUF/eDdgXgdIGjkeucxL27dsXDx48EBWV6KKVpgRTJ6D2ovbWrVsi8kU/gmX58uWYNGkSPv30U5FUnxKvUtUlLeq0o45GmgJHEYNU0p3Wqd+YLVu2THQMtmnTRqy/V69e+PXXtBLcWh07dsTNmzd1zwMDA8W9dvSKohZp2h51ClLlKLpgnj9/vm5KHmPZoQptM49Mx6UHF1HGtSw+avk57A1EjlirEkW80MW3J9aFrcSi0/PxeduvIMVehubmEcCpOBQ1ObedqdAIMQ2IUIESOrGkwRwfHx/d9GLqJDx+/Lg4SaxQoQIOHTqEsWPHikGWrCrjcW4axrKnDF8F+5R4qMq3xKNUxywLNpVUeMOnWBVce3IFW89tQtNyLczq0JpT0SbGmPlTR24DEmIhL9cQ8hLVs1yOBtF71OqNP4//hjXnViCwdD2rj74xhM7JKOVLvXr1RBE6yjWdOcCmTJky4rxLG2DTokULEWBDA78rVqwQATZz587VrZMCYuiaOyoqSjynGSSEog3ppu0gTEhIEPmo6bm2EEmJEiVEdCNjhpyNOoMfD3wNlUaFPnX6i/yitoSu7YfUG4kfDnyFv0MWokG5RqLwnCqEgmIkKOv0hcyhCKydTLLV+O88ogbWzc1NVyGK2Qb6M/nr5J/YeWmrqHb0TYfp8CqSMdrLFiSmJmL8xrfwOPERPmk1GbXDN0F1+i8oG42FfetJpt49q5hu7OzsjDVr1ugiqQmdXNIAysaNG3O0njfffBO3b9/Gzp07ReV2arNomgmdbOovc+fOHTEgk9Mqd1S0ids+xtL+m5D0V1tIMeFweP1vKKq0yfawhNw9JfLYUlTNzK5/2kwEujXg8z7GMkpa2h2a2ydg3+0PKGtlPwWRoqfHbRiJ2ISHmNz2G9T29rfJw/n777/jxx9/1AXYUKCLNmUWDehSUblFixbpll+9erUIsLlx44YIsPnhhx9EMIwWLavtZNQ3ZcoUMWvvwIEDaNWqlcF9uX79utjey3DbZxuin97Fviu78SA+rf7DiVvHoNKkoqdfX/QLGGSTHfuSJInUYmejz6BbrV4YWLsfEn8PAhIfw3HUIcg9q8LacXVjxnKApolRB6Gj0gmftp5qkx2ExMnOCQMCh2DW0RlYfHoevr56EErIoAx8w9S7ZnXTUrSdhNppKdoUDTlBn9F28KWmpoqbfoQ3oVFkWi4rXLSJsWz+xu4Giw5CmVs5yH0yFg8yhCJoKrlXFtPujt48jGaVXv4ZxhgzN5oHkaKDEM4eUFT/r9MqK3YKO3GRTfm9KDehrXYS0jlcVudx1KGXWZ8+fcQtK0OHDhW3rFDHI8cBsZfZf2U3Zh/7VXQE0r8X+h8JLB1ksx2ERCaTYWj9Ufjf5newJWIjWqhS4ZH4GHKq1G4DHYTENuvRM5aDUZVlIYvwy+Ef8N2+L7HszCIoZAr8r8VEVHL3senjR9WNfdyrIPpZNPbYOUFeuTXkxSuYeresRm7zvtL0FMpVQ/lWaXmanrJ06VIMGpSWI40inmnayocffihORGkEmUaglyxZgh49rD8JMWPGkDbtBGKARJaDqEA64ezhl3bBt+78qheSYTPGmCVQhSwR90r//pDlsFp76yrt4OZYDBfun0NkTISR95AxltNrXeogpI5BOifRdhCS0KgQ3HsWbdMHsqxbObxWo4vIy7g4YoN4TVnvxehda8WdhIwZGFUZv3E0NoWvw9EbhxF896R4vUXlNvAvXdfmjxdVrBta701xHDa6eSOxjm3lqjA2yvs6ffp0kfeVpqRQrsHMeV+jo//7Dzd1IL799tuoVasWXnnlFaxdu1bkn6HpxFqUz6Z+/foYOHCgKGDy3Xff4ZtvvhHFnBhjuSMlPII6YjMgtxMXyjnVsHwTlHErhztxt3Dq9nE+7IwxiyJRDtaw1TTskasZJA5KB3T17Skerw1bacQ9ZIzlFE0xzipSkF7fd2WXzR/M3nX6w83OBWflcpxzrwRFlf+KQlo77iRkLIejKtR5GP00LUGwrauWmoiGCY+QIFdiTdwtU++O1aEpKVSEiaYMnzhxQpe3hlA0oH7eGqoMf/nyZZF7kBJZHz16VHQ06qMk1gsXLsTdu3fFclTdnSIWbXUaAWP5oTq/ClAnQ1GjE2QunrkaYNFGE9K0O54KxhizJOrwDUDyM8grt4K8WPlcffbVaq+hiH1RnLl7GtdirxhtHxljOUM5CLM6D6FXtTkKbZmLvQteV6QV0l1WrCxUNjQLhDsJGdPDoyo5owpeiNef3IWdTI7dV3bi1uMb/O+IMWb1JEnz33S7uoNz/fmmFVuInLaUm5Cm8zDGmCWgzoRUXZqFwXnKad25ZjfxeF3YqgLfP8ZY7pRw8co6kjD9fVsnPX+AJlf3o1JKAu6lJmDbxU2wFdxJyJgeHlV5OSn+IdQRW+AJGbpU7yQumhcH/8VRMYwxq6e5cRjS4+uQeVaDvFyjXH+eqhp3r8XRhIwxy6KJDoV07zxkrqWhqNI2T+voUKMznOycceLWUdx+crPA95ExlnOtq7yadSShJIlcorZOFfo35JpUDHZPK1ay5twKPE54BFvAnYSM6eFRlZdTnV0OaFKhqNkF3QMGo7iTO85Fn0HI3VP8b4kxZtV0UYSBg/M8Xb9l5TZwd/ZA5INwhMeEFfAeMsaYEds+qniag2JNhrjYF8Fr1bvoCjgxxkzH27UMxjQZDxlkIh2KTCZPu4dMvO7tWtqmfx5Jo4LqzFLxuGajMWjh0xpJqkQsO5MWUW3tuJOQMT08qpI9SaP+70QxaKiYPjIgcIh4TtGEqepU/vfEGLNKmmfRUF/aCdg5QVk7LRowL+wUdrok/rZ0oTxr1ixUrFgRjo6OIs/qyZNpRcEMuXDhAnr16iWWp87YX375xeBylGeVKrl7eHjAyckJtWvXxunTp3XvDx06VHxe/9ahQwejfD/GrJWU+CQtH6FcCWXAgHytq1PNrnBQOODfm4dFHnDGmOm0qtwWM7vNEeckTSo0Fff0nF63depLOyA9i4a8dF0ovAMwMHAoHJVOOHhtLy4/iIS1405CxvTwqEr21Ff3Qnp6F7KSfqLRJM19WsHHvYo42dt1aRv/e2KMWSV16HJAUkPh2wMyR9d8ratt1fZwdXATUdiXH1r/yebKlStFsaQpU6YgJCQE/v7+aN++PWJiDCdGT0hIgI+Pj6jEToWXDHn8+LGo6G5nZ4ft27cjPDwcP/30E4oXL55hOeoUpIrw2ts///xjlO/ImFUXa1IlQVGtA2RFSuZrXa6ObmhXvaNIVbM+bE2B7SNjLG8oYnBg3aGY0OwjcW/rEYRaqtMLxb2y3jBxX9zZHb3rpBWG/OvUn6LAqTXjTkLGMuFRlewLlhC7oGG6qXYUmj60/kjxePW55XiaFMf/phhj1jftJHSZeGyXh4IlmTkoHdHZt7vNRBP+/PPPGDlyJIYNGwZfX1/8+eefcHZ2xoIFCwwuX79+ffz444/o168fHBwcDC7z/fffo1y5cqJye4MGDVCpUiW0a9cOlStXzrAcfZ46GrW3zJ2IjLGsUW6y/4o1pc0cya8uNXvATm6HQ9f24cFzrqDKGDMvmpiL0Nw6Cjh7QFEjLUUC6VijG7yLlsbV2Ms4eHUvrBl3EjJmAI+qvEjz6Do01w4ADq5Q1Eq7uNWq6VULjSs0Q3xKPFZRzkLGGLMi6su706adeAdA7u1fIOtsX60TXOxdcPrOCdx8fB3WKiUlBcHBwWjb9r/pS3K5XDw/duxYnte7adMm1KtXD3369IGXlxcCAwMxb968F5Y7cOCAeL969eoYM2YMYmNj87xNxmyN5uZRSI+uQuZeGfIKrxTIOikih4oiqCU1Nl5YWyDrZIyxgg6KUQYMhEzpkCFdzJB6aYExlJuQrnutFXcSMsZyRHUmfSS5Tl/I7JxfeP+NusPEyPCuy9tx6/ENPqqMMauhCklLVK0sgChCLWd7Z3SwgST+Dx8+hFqtRsmSGacp0vN79+7leb3Xrl3D7NmzUbVqVezcuVN0AL777rtYvHhxhqnGS5Yswd69e0Xk4cGDB/Haa6+J/clKcnIynj59muHGmK36r+17I8/FmgzpVqsXFDIF9l3ZhUcJ3HHPGDMPUtJTqCgVgkxu8JwvqGx9BJaph7ikJ1h7fgWsldLUO8AYM39SaiJUZ1dke5FcoogXuvj2xLqwlaKIyaQ2XxboCSVjjJmC5vENaK4fBBzdoPDtVqDrpiT+WyI24NjNI3g9biDKuJUt0PVbM41GIyIJv/32W/GcIgnDwsLEVOYhQ9KmRdJ0ZS0qalKnTh0xHZmiC9u0aWNwvdOmTcPUqVNfeJ0iECkqkjGbkfAQTpHbAYUD4kq3pR7/Alu1DHI0LNMER+8cxqrg5ehdsz8Km6enZ6FvkzFmATlYUxOgqN4RctcyBpcZWm8kzkWHYlvEJrSp0g5l3MrB2nAnIWPspdQRm4CkJ5BXbA65R5Usl+vu1xv7ru4SyfhD7p5CUNkGfHQZYxZNdWapuKeKxoaiqPOjqIMr2lXriM3h67DhwhqMbTIB1oYuxBUKBe7fv5/hdXqeVVGSnPD29hb5DfXVrFkTa9dmPX2RiqHQ/ly5ciXLTsKJEyeKIitaFElIuQ+pgrKra/4K1jBmSVL//RupkgoK357wLJsx12dB6Bc0CMfu/osjtw9gQP3BoqgJY4yZChVUUgUvEo+VQcOzXK60axl0qtEVm8LXYeHpefis9VSrC4zh6caMsZznZggamu1yTnZOGBCYFsFB0YSp6lQ+uowxiyWpkqA6m1YNVxn4hlG20aVmd5Gq4fC1/VaZxN/e3h5BQUFiyq9+FCA9b9y4cZ7XS5WNIyMzVoa+dOkSKlSokOVn7ty5IyICqYMxK1TohDoD9W+M2RpJo4bqzN8FWrAkM2/XMnilQjMkq5OxlQajGWPMhDTXD6XlYPWsBnmFJtku26t2PxRzKo6zUSEIvnOy0PaxsHAnIWMsW+qoUGiiz0JWtDQUVV996dFq4dMaPu5VEP30LnZd2sZHlzFmsdQXtwKJjyEv3wRyz2pG2YZI4l/VupP4U2QeFRWhfIEREREif2B8fLyodkwGDx4sIvi0aFpvaGiouNHju3fviscUAaj13nvv4fjx42K6Mb2+fPlyzJ07F2PHjhXvP3/+HB9++KFY5saNG6JTslu3bqhSpQrat29vgqPAmOXQXN0H6eldyEr6QV460Gjb6Vn7dXG/PXIz4lOeG207jDGW86CYYS+NDKS80gMD04JnFgXPt7rAGO4kZIxlSxWSHnYdOAgy+cszFMhlcgytn1b5afW55XiaFMdHmDFm4Un7jRNJYyiJ/+OER7A2ffv2xfTp0zF58mQEBASIDr8dO3boipncunUL0dHRuuWjoqJEjkG60ev0WXr85ptv6papX78+1q9fj3/++Qd+fn746quv8Msvv2DgwIHifZrifO7cOXTt2hXVqlXDiBEjRETj4cOHRbQgYyxrqeltn13dwUadRleuWAU0LN8EiakJ2HFxC/8kjDGT0Dy5BfXl3YB9ESj9eufoM819WqGqZ3XcfxYt8ktbE5kkSZKpd8KSUG4aNzc3xMXF8RQUZvWkhEdI/D0I0Kjg9E4wZEW8cvzZnw99j2M3D6N9tU54s+EYo+4nMz5u+5it0cREIGl+a8ClBJzeOQ2Zwt6o2/vj6Ezsv7obXXx7YHDQCKNui+Uct33MFi+Wk/5oBNi7wOndUMjsXYy6vWuxV/DxtgkoYl8Uf/RcIFLXMNPjto/ZkpR9X0N1fBaU9UbAvt3XOf7clYeXMHH7+3BQOmJmtz/h4WwdBZE4kpAxln2FJ1USFNU75aqDkAyqO1Tk2dp1eTtuPb7BR5kxZlFUIUvEvdK/v9E7CEkPv96QyeTYFbmNI7AZYyajCqVchFJasSYjdxASH48qCCxTD89TnmH3pe1G3x5jjOmTUhOhOrs8TzNHqnhWQ6vKbZGsSsKy9Ahsa8CdhIyxrCs8aafavaRgiSFeRUqii29PsR4qYsJBy4wxSyGlxEMVtoYmXIhUC4WBkvg3qdBUJPHfdpGT+DPGCp+kToEqVFusaXChbbdX7b7inqqFJquSC227jDGmDt+Yln+6YnPIPavm+oBQ0U4nO2ccvr4fF2PCreKAcichY8wgzbUDkB7fgKxEDcjLNczTUeru11tUfjoXfQYhd0/zkWaMWQRV2Fog5TnkVdpA7lau0Lbbwy89if/FLYhPiS+07TLGGFFf3AYkPIS8bAPIvWoU2kGpXqIm/ErVQVzSE5GblTHGCgMFsaSe/ks8VtZLK6aWW3St26dOf/F4wak5UGvUsHTcScgYe0nC/qF5TlpNeWVodIUstsLKT4wx6zxh1E41tjNywZLMKhSviPplGyEhNR47I7cW6rYZY0x1Jj3NQlDhtn2kV+1+4p6qvPP5ImOsMGjuBkO6HwaZaxkoqrya5/V0qN4ZpV3L4vqjqzhwdQ8sHXcSMsZeoHlyO73CkwuUfr3ydYRa+LSGj3sVRD+9i12XtvHRZoyZNU1UCKSYC5C5lYXcp1Whb79n7bRoQqqUl5SaVOjbZ4zZJs2DSGhuHQOc3EUu6sJWq2RtEVEYm/AQh67tK/TtM8Zsjyp4oS61lkyuyPN67BR2GFpvpHi87MxixKc8hyXjTkLG2AtUoUvTklb79YHMoUj+GhmZHEPrpzWaq88t54T8jDHLiKIOGJSvE8a8oiTY/t6BeJb8FHuv7Cz07TPGbJPqzNL/ijUpHQp9+zRrRTtIsj5stVVM2WOMmS/p+QOoIzYDCgfR7uVXYJkgBJVtIM7fVqUXQrFU3EnIGMtAUiVDFbo8zwVLDKnpVQuNKzQTObZWnbPsRpMxZr2kxMdQh28C5HZQ+g8w2X70TE/iz9PuGGOFQUpJgOr8avFYGfiGyQ56YOl6qOReGfef38O/Nw6ZbD8YYzZSyV2TCoVvN8icPQpknUOC3oRSrsSOyC24/eQWLBV3EjLGMlBf3AIkxEJevjHkJaoX2NEZVHco7OR22H1pO24/uclHnTFmdlTnVgLqZCiqd4SsSAmT7YdvST8xuPI48ZFV5LZhjJk3dfgGIPkp5D4tIS9ewWT7QdGE2krH68JWQSNpTLYvjDHrJalT/4uezmPBEkO8XUuji28P0XYtPDVX5Lm2RNxJyBjLsmBJQfIqUhKd0xvNRafnW2yjyRizTpKk+e+Ese5gU++O3rS7NVBpVKbeHcaYTZz7FX7Bkszql2uEsm7lcTfuNk5SjkTGGCtg6ks7IT2Lhrx0XSi8Awp03T38XkdxJ3ecvxeKU7ePwxJxJyFjTEdzPwyaO6cAFy8oqnco8CPTw6+PKBN/LvoMQu6e5iPPGDMbmhv/Qnp0DTKPqiKS2tT8veuKok8P4u/j3+sHTb07jDErpY4OhebeOciKloaiSltT747IZa0dJFl7fqVVDCrPmjULFStWhKOjIxo2bIiTJ09mu/zq1atRo0YNsXzt2rWxbVvGwn/r1q1Du3bt4OHhIaIvQ0NDX1hHUlISxo4dK5YpUqQIevXqhfv37xf4d2PMoguWFGAUoZaTnRPeqJu2XgqMSVYlw9JwJyFjTEcVrE3YPxAyhb1RGs0BgWmj1IuD53N0DGPMDCNpBouLLlPTn3bHSfwZY8aiClny37mfXGkWB7pJhWYoVdQbNx5fs/hB5ZUrV+L999/HlClTEBISAn9/f7Rv3x4xMTEGlz969Cj69++PESNG4MyZM+jevbu4hYWF6ZaJj49H06ZN8f3332e53ffeew+bN28WHY4HDx5EVFQUevbsaZTvyJgl0cRchObWUcDZA4oaXYyyjaaVWopq7TTQuyV8PWyik7CgR0NohGjy5Mnw9vaGk5MT2rZti8uXL2dY5tGjRxg4cCBcXV1RrFgx0XA+f56xtPS5c+fQrFkzsZ1y5crhhx9+eGFffvnlF1SvXl1sh5ahBpRGWhizdVJSHFQX1gIyBZSBg4y2nRY+rUVS6uind7EzcqvRtsMYYzmleXYP6ks7AKUjlLX7mM2Bq1euIcrRtLund3DyNk+7Y4wVLCnxCdQX1otzP0WA6Yo1ZaaQK8TsE7L2/AqLjib8+eefMXLkSAwbNgy+vr74888/4ezsjAULFhhcfubMmejQoQM+/PBD1KxZE1999RXq1q2L33//XbfMG2+8Ia6d6ZrZkLi4OPz1119i261bt0ZQUBAWLlwoOiCPH7fM6Y+MFXgUIQ2MGKmSu0wmw/D6b0EGmRjofRj/AFbdSWiM0RDqzPv1119Fo3nixAm4uLiIdep33lEH4YULF7B7925s2bIFhw4dwqhRo3TvP336VIRdV6hQAcHBwfjxxx/xxRdfYO7cubplli9fjk8++UTse0REhGg86ft8+umnuT0MjFkdUdUuNRGKau0hdy1t1Gkkw+qNFI9Xn1uOp0lxRtsWY4zlhPrscspiDUWtHpA5upnNQUubdtfXqqbdMcbMhypsDaBKgqJaB8iLloI5aVapFTxdSuDyw0iE3TsLS5SSkiKuS/U78+RyuXh+7JjhgR96PXPnH10XZ7W8IbTN1NTUDOuhgJ3y5ctnuZ7k5GRxPa1/Y8wqg2LCVgMyudHzT/t4VEHrKu2QrE7G3yFpHZOWQpmf0RBCHXtbt24VoyHUAZfdaAih0RDq6KPREPosnfBSdN+kSZPQrVs3scySJUtQsmRJbNiwAf369RMdejt27MCpU6dQr149scxvv/2Gjh07Yvr06ShdujSWLVsmGmLaD3t7e9SqVUvkZ6D91XYmUoflK6+8ggED0kbKKBqSOjCpY5IxW0Z/h6rgRUYpWGJIzZJ+aFyhGY7dPIxV55bjzQZjjL5NxhgzRNKooDqzzGwKlmTWuEJTrDz7N24+vo6Qu6cQVLaBqXeJMWYt537aqcZm2PbZKezQvVZvzD85WwyS1C7g4gKF4eHDh1Cr1eK6Vh89v3jxosHP3Lt3z+Dy9HpO0bJ0PUyz73K6nmnTpmHq1KkvvB4bGyuusRmzBsrzf8M+NRGqim3xKMWB/kiNur325Tvh6I1D+PfGITQs+QqquleHqXl6ehZsJ6F2NGTixIm5Gg2hyMPMoyHUAUiuX78uGiv9kQ43NzcxjZk+S52EdE+NnLaDkNDytG3q4OvRo4dYpnnz5qJB1N8O5Wp4/PgxihcvjiZNmuDvv/8W06MbNGiAa9euianPFLKdFRpVoZsWj6owa6S5SQn7r0LmXhnyik0LZZuD6g7F6dvHsfvSdrSv1hHlilUolO0yxpg+9ZU9kJ5FQV6qToFXuCuoaXfda/XBn8d/FRfKdcvUN4uciYwxy6a5dQxS7GXI3H0K7dwvt1pVeRVrzq/AhfvnERFzATW9apl6l6wWXd/rX7PTNS+l5qLCJ5TuizFLJ0kaJEWuAc3JcGkyGq456CzLL094om/AICw6PQ9rL63A9x1/Eed15k5p6tEQ7f3LlvHy8sq440ol3N3dMyxTqVKlF9ahfY86CSmCkL4DJXoVo2cqFUaPHp3tdGMeVWG2wP7YXNEYJFfvjfjY2ELZphwKtKnUHjuubsG8Y7Mxrt4HJr3wzcmoCmPM+vwXSZNWVMkcNfdphdXn/kmfdncOtb39Tb1LjDFrafsC34BMZp61LO0V9ujq2xNLgv/CuvOr8FmbFyPdzBmdWyoUiheqCtPzUqUMT++m13OzfFbroOCeJ0+eZIgmzG49Dg4O4saYtdJcP5QWFONZDfIKTQptu+2rd8KeyzvFjJC9V3aiXbWOMHfmUcKqkBw4cADffvst/vjjDxGpeOXKFYwfP15Mgf78888NfoZHVZi10zyNQtKNfYCdE9waDyvUfFwD3AbjeNS/iHgYhlvJNxBUtn6hbZsxxjSPb0Jz7QDg4AqFb3ezPSA07a5brZ5YcGpO+rQ77iRkjOWd9PwB1JHbAIUDlLVfN+tD+WrV10Ti/9CoYFyNvYzKHlVhKWiGGxUN2bt3r8jJTzQajXj+zjvvGPxM48aNxfsTJkzQvUapuuj1nKJt2tnZifX06tVLvBYZGYlbt27laj2MWWXBkqBhhRqYopQrMaz+KHy1ZxJWhP4tUm4VdSgKcyY39WiI9v5ly2QujEJRgFTxWH8ZQ+vQ3wZ1BNLU4jfffFNUWaZpytRpSNGC1GAbQiMqFGKtf2PMmqhCl6Un7O9Z6An7neycMSAwLXpncfB8qDSqQt2+ucpNBfl169aJVAw0UkxFnwICArB06dIXlqPcrl27dhXpHGi5+vXri5NFxmyZ6gz9rUiiorHM3hnmjJJfuzkWw4X75xAZE2Hq3WGMWTAVFWvSpELh2xUyZ3eYM0c7R3SqmZa3ngZJLA1N4Z03bx4WL14szsXGjBmD+Ph4XX7/wYMHZ0jlRQEslIv/p59+EjP1qBDn6dOnM3Qq0jUw5d4PDw/XdQDSc+0MOzrXo6KhtO39+/eLdGG0PeogbNSoUaEfA8ZMTfPkFtSXdwP2RaD0613o26/jHYAG5RrjWfJTrDqblgfbajoJ9UdDtLSjIVmNSmhHQ/Tpj4bQFGHqxNNfhnIgUK5B7TJ0T+HS1MBp7du3T2ybLqC1y1DFY6rkpL+d6tWri6nGJCEhQeQx1EednoQrBjJbJKlToTrzt3hsF2T8giWGtPBpjUrulRH99C52Rm6FrcttBXlKu/DZZ5+JvKznzp0TJ4F027lzp26Zq1evijQLVNmOIqppORo0oU5IxmyVpEqG6uw/uul25s5B6YAuvj3E47VhlnehzBgzD5JGDVXo32afZkFfh+qd4WznglO3j+Pm4xuwJH379hWFNidPniwGcqkzjzoBtWmxaMA2Ojpatzzl0F++fDnmzp0rzgHXrFkjcvn7+fnpltm0aRMCAwPRqVMn8Zxy+NNzKgqqNWPGDHTu3FlEElLefrrepoFlxmyRKmRx2qBwnb6QORQxyT4MDhoBO7kddl7aZv7tmJRLK1askBwcHKRFixZJ4eHh0qhRo6RixYpJ9+7dE++/8cYb0ieffKJb/t9//5WUSqU0ffp0KSIiQpoyZYpkZ2cnnT9/XrfMd999J9axceNG6dy5c1K3bt2kSpUqSYmJibplOnToIAUGBkonTpyQjhw5IlWtWlXq37+/7v0nT55IJUuWFNsPCwsT++ns7CzNmTNHtwxtu2jRotI///wjXbt2Tdq1a5dUuXJl6fXXX8/x94+Li6Ncl+KeMUuXGr5Jiv+mlJS4qLNJ9yP83nmp95JO0pAVr0txiU8kW9agQQNp7NixuudqtVoqXbq0NG3atByvg9rKSZMm6Z737dtXGjRoUL72i9s+Zm1Sw9amtX9Le0iWIiElXhqyoq9oL6/FXjH17tgEbvuYtVFd3i3avoR5bSSNRiNZin/OLBFt34xDP5h6V2wCt33MWmhSEqT4n2uKdk/94JJZtGNTdk406/ZXbg6jIR999BHGjRuHUaNGiSlwz58/F+vUj3JZtmyZiIJp06YNOnbsKKJiaJ1aFFa9a9cuUS2Zoh0/+OADsY+0Tq1JkyaJ1+ne19dXhGFThM6cOXPy1sPKmIVTBS8S98og044k1yzph8YVmiI+JR6rzi2HrdJWkNev9v6yCvL6KCKaorJp2gmNGhOKuN66dSuqVasm2jsqAkUR2NoK81mhqu4U1a1/Y8yaqIIXp0cRDoaloBQN2ml3lMSfMcZyK1VE1FAU4WCLqpTesUZXOCgdcfTmYUQ9vWvq3WGMWQh1+EYg8THklZpD7mnanKbda/WBh7OnSB1z/Na/MFcy6ik09U5YErpQpg7JuLg4zk/ILJrmQSSS5rUEnNzhNC4EMqVpK5rFPL+PCRtHQy2pMb3zbyhXrAJsTVRUFMqUKYOjR49mSOFAAykHDx4UaRgMofaIPkcde5RCgYozDR8+XLxH+Wm8vb3h7OyMr7/+Gq1atRKDMFTVnfLUtGjRwuA6KQfO1KkvVhG8du0aihY172S7jL2M7NFlOK3pCcnJHYkD9gAKO4s5aPGp8Zi0/wMkq5PxebNv4F2kdL7Wx5Xds8fnfcyaaOJuI2lWQ8DeBU7jzphs2l1eLQlegM3h69Cqclu83eS/wh6s4HHbx6wBdXUlLWgH6X4Y7HsvhLJaB1PvEv69fhC/HPkRni4l8EvX2WLww9zYVHVjxljm3AyAMmCAyTsIiVeRkujs2wPrw1Zh8en5+KzNlxY1wm1K1GlHUd0UhU2RhJTT0MfHBy1bttQVZerWrRvee+898ZiiwKkjknLXZNVJyJXdmTVLCf4ZVCbJLnAgXEp6w5J4whPta3TGxgtrcODubox75QNT7xJjzEKk5aGWoPTrZXEdhITysu64uBmHru1H7zr9xbkjY4xlRXM3WHQQylzLQFHlVbM4UE0qNhd5CSNiLmDThXXo4z8A5ibX040ZY5ZPSn4O1fnVFE9jVlPtevj1RjGn4jgbfQYhd0/D1uSlgrx2SnKVKlVE5x+lVOjdu7eo2q5dp1KpFCkW9NWsWTPb6sZc2Z1ZKykl/r/2L8D8C5YY0qVmd9grHHDk+kHcf5ZWzZIxxrIjqVOgCl1uUQVLMivuVBxtqrYXs042Xlhr6t1hjJk5VfACca8MGgqZPK1granJZDIMq/8WZDI51l9YgwfPDRenNCXuJGTMBqnoxCrlOeRV2kJerBzMKd/WgIC0TsvFwfOh0lCsj+3ISwV5Q+gzNPVYu07K9Up5CvVdunQJFSrY3pRuxtQX1qe1f5Vbm1X7lxtuTsXQpmo7aCQNNlxYY+rdYYxZAHXkDiDhIeRl60PuVROWqmutnlDIldh3ZRceJcSaencYY2ZKev4A6ogtgMIBSv/+MCeV3H3Qtmp7pKpTsCT4L5gb7iRkzAZzM2gT9tuZuGCJIS0qt0El98qIfnoXOyO3wtbQVOF58+Zh8eLFiIiIwJgxYxAfH49hw4aJ9wcPHiymAmtRxODu3btFrkBa/qeffsLSpUsxaNAg3TIffvghVq5cKdZ75coV/P7779i8eTPefvttk3xHxkzZ/mmT9ttZaCSNVjffXuJC+cDVPYiNf2jq3WGMWUqambrmM4MkL0q4eKGlT2sxkLwpfJ2pd4cxZqZUoX8DmlQoanWHzNkD5qaf/yC42BcRBUzC7p2DOeFOQsZsjOb2CUgPIiArVgFyn1YwN3KZHMPqjRSPV59bjmfJtlVVN7cV5KkDkTr7atWqhVdeeQVr167F33//jTfffFO3TI8ePUT+wR9++AG1a9fG/PnzxXJUJZ4xW6KJOqPLTUORhJbMw8UTLX3a8IUyY+ylNA8vQXPrKOBUHIoanS3+iHX36yOm6u2+tANxSXGm3h3GmJmR1KlQnVmqm2psjlwd3dAvIC2oY8GpOVBr1DAX3EnImM2OJA8RJ1jmqGZJPzSu0BTxKfFYeXYZbM0777yDmzdviinDVNG4YcOGuvcOHDiARYsW6Z5TxeLLly8jMTERjx49EgVJqKMxM6p2rF2OOh6pkAljtkZ1Zom4VwYOMpvcNPnR3a+3aMf3XN6JuMQnpt4dxpiZ0l0s+/eHzAwraeZWqaLeaFqxBVLUydgascHUu8MYMzPqSzshPYuGvHRdKLwDYK5erfoayheriNtPbmL35e0wF+bZQ8AYMwrpeQzUF7em5Wao82JHkjkZVHcY7OR22H1pu2g4GWMsP6TEx1CHbwTkSijNsJJcvi+UL2409e4wxsyQlJqQXqwJUKZHrViDHhRNCBl2RG7B8+Tnpt4dxpg5Fiypl5auyVwp5AoMqz9KPF4R+jeemklkNHcSMmZDVGeXp+Vm8O0GmbM7zJlXkZLo7NtDJOZffHq+yCXGGGN5pTq/ClAlQVG9I2RFvKzqQpnwhTJjzBAxOJIUB3mlFpC7V7Kag1SuWHk0KN8YiamJ2B652dS7wxgzE5qYi9DcOgY4e0BRowvMnV+pOukz6J5jxdm/YQ64k5AxGyFpVGafmyGzHn69UcypOM5Gn8GZqNOm3h3GmCUXbApJb/8CLTtpv6EL5Yblm4gL5R18ocwYy0QVssQqCpYY0qt22qyYzeHrxYDyL4d/wLKQRaL4HWPMNqmCF+oip2VKB1iCN+oOh53CXqSPuf7omql3hzsJGbMV6su7IT2NgtzbH4rSgbAETnbOGBCQdlK7+PRfIkE/Y4zllubmv5AeXYXMowrkFZpY8YXyBr5QZozpaKLPQhMdCllRbyiqtrO6I1PJvTIqFKuIxNQEbI3YiKM3DouKx+M3jsb+q3tMvXuMsUImJcVBFbYakMmhrPuGxRz/EkW80KNWb0iSBgtPzTH5DDqOJGTMRqhC0opdKOtaRhShVovKbcRJYNTTO9gZudXUu8MYs+SCTYGDIZPJYG2ojSxfrAISUuP5QpkxppOqjSIMGAiZXGl1R4YiBm+l562W0v9HaWrofvbRmYh+GmXqXWSMFSLVuVVAaiIU1TpA7lrGoo5911o94elSAhExF3D0xiGT7gt3EjJmAzSxV6G5fghwLAaFb1dYErlMjmH1RorHq88tx7Pkp6beJcaYBZGe34f60g5A6Qhl7bT8fdZ4oXz7yS3xmC+UGWOiLUiKgzp8PSBTQBFgHcWaMtt3ZXeWAz/0+r4ruwp9nxhjpkFReLqgmKDhFvczOCgdMThohHi8NGQhklKTTLYv3EnImA1QnUkfSa7TFzI7Z1iamiX90hO6xmMVFV9hjLEcUoVSwSYVFL7dIXMqZpXHjS+UGWOZqc6vSYuoqdoO8qLeVnmAHsTHZDktT0p/nzFmGyggRnp0DTLPahabWqZR+VdQq2QdxCY8xIYLaVXpTYE7CRmzclJqAlTnVlp80uqBgUNhJ7fDrkvbcDt9agljjGVH0qihCk2rFKesO8RqDxZfKDPGXizWlJ5mIch6274SLl5ZRxKmv88Ys7GCJUHDLTa1jEwmw7D6oyCTybHpwjrcf3bPJPvBnYSMWTn1hQ1AUhzkPi0hd/eBpSpZtBQ6+3YXuWaogp2pE7oyxsyf+upeUbBJVqq2KNpkrfhCmTGmT3P7OKTYy5AVrwh5xWZWe3BaV3k160hCSULrKtZXrIUx9iLNk1uiSCfsi0Dp18uiD1GF4hXRvlpHpGpSsST4L5PsA3cSMmbF6AQpVTuqYmEFSwzp4dcHxZyK42z0GZyJOm3q3WGMmTltJI1d3SEWO6psLRfKs2bNQsWKFeHo6IiGDRvi5MmTWS574cIF9OrVSyxPv9svv/xicLm7d+9i0KBB8PDwgJOTE2rXro3Tp09n+O6TJ0+Gt7e3eL9t27a4fPmyUb4fY+ZEpS1YIoo1We/lnrdrGYxpMh4yyEQOa/qu4h4y8bq3a2lT7yJjrNDO96S01FoORSz+mL/uPxBFHVxx8vYxnIsOLfTtW+9/NRhj0ESdgXQ/DDLXMlBUaWvxR8TJzhkDAtKmTC8+/RdUGpWpd4kxZsajypqr+wGHolD49oA1M/cL5ZUrV+L999/HlClTEBISAn9/f7Rv3x4xMYbzhSUkJMDHxwffffcdSpUqZXCZx48f45VXXoGdnR22b9+O8PBw/PTTTyhevLhumR9++AG//vor/vzzT5w4cQIuLi5iu0lJpksGzpixSc8fQH1xK6BwgLLO61Z/wFtVbouZ3eagq29PNKnQVNzTc3qdMWb9pNREqM7+Y1WpZYo6FEW/gEHi8cJTcwv9mldZqFtjjBUqXYWnwDcgkyus4ui3qNwG2yO34Pqjq9gZuRWdanYz9S4xxsyQ6szStFFlvz6Q2VtewabcogviGiV8RTVPylFIU5ApgtDUHYTk559/xsiRIzFs2DDxnDrttm7digULFuCTTz55Yfn69euLGzH0Pvn+++9Rrlw5LFyYFi1PKlWqlCGKkCIQJ02ahG7d0v47sWTJEpQsWRIbNmxAv379Cvx7MmYOVOdWAJpUKPx6QebsAVtA7dxAK5gxwxjLPXX4RiDxMeSVmkPuWdVqDmGbKu2x69J23Hx8vdCveTmSkDErJSXEQh2+CZDbQek/ANaComOG1RspHq8+txzPkp+aepcYY2ZGUiXrjSpbbsGmvF4oT2j2kbg3hw7ClJQUBAcHi6m+WnK5XDw/duxYnte7adMm1KtXD3369IGXlxcCAwMxb9483fvXr1/HvXv3MmzXzc1NTHXObrvJycl4+vRphhuzfppH15Cy/xskbxgj7um5xRZrEgMk1hNRwxhj2abWOv2XrmCJNVHIFRhR/y3xeNXZ5YhLiiu0bXMkIWNWSnV2BaBOhqJWD8iKlIA1qVnSD40rNMWxm0dEozmiwWhT7xJjVoEujKlzTYq7A5lbWSj9+1tkwSN15DYgIRbyco0gL1Hd1Ltj0x4+fAi1Wi0i+PTR84sXL+Z5vdeuXcPs2bPFNOZPP/0Up06dwrvvvgt7e3sMGTJEdBBqt5N5u9r3DJk2bRqmTp36wuuxsbGiw5NZH0Xketgf+iK9Hi7l9pQh9fgfSGk+Ferq3WFJ5LcOwTHuNjTu1fDYoSL9AZp6l8yWp6enqXeBMZOz9PM+zd3gtNRabmWtIrWWoWveVyo2x783DuGfM0swuvE4FAbuJGTMCqWNJKcnrbbS6RcDA4fi9O0T2HVpG9pV64hyxcqbepcYs/iBhZRtH2S4UFYd/wP2nX4WiaAtMmm/DUUR2hqNRiMiCb/99lvxnCIJw8LCxFRm6iTMq4kTJ4qORy2KJKRpzVQcxdXVtUD2nZnXBXISdRBKmhfeczg0BY4120Du/t80dnOXvH8j1LTv9YejSAnrGiBmjBUsazjvUwUv0EVOW0tqrcwG1R0mrnkpncyr1V5DZY8qMDaebsyYFU470Vw7AOnJLci8fCEvm5bXydqULFoKnX27QyNpTFYenjGravPoRJEulCV1hvuUre9D8+g6LIXmQSQ0t48Dzh5QVO9o6t2xeRSto1AocP/+/QzHgp5nVZQkJ6hisa+vb4bXatasiVu3bonH2nXndrsODg6iM1D/xqxXWlqCrCqfy6A6uxyWQhN3B+orewB7Fyj9epl6dxhjZswazvtEkaaILWlFmvz7w1p5upRAD78+kCBh4ak5Yoq1sXEnIWMGRlWS5jSD6vhsqCM2iXvx/NxKizlWqdqCJTSqIsvq5NfyUYNZzKk4QqOCEXL3lKl3hzHrvFCmfC9HZkBSJVlWFKF/f8iUDqbeHZtH03+DgoKwd+/eDFGA9Lxx48Z5Pj5U2TgyMjLDa5cuXUKFChV0RUyoM1B/uxQVSFWO87NdZl1oil1aBI2hN9VQX9iA1JPzoL4bInKdmjPVmb/FBb6yVi/IHIqYencYYxZ73qdB0twWSPzzFSQt7YHk9aORsnsyUo/Ngur8aqivH4Qm5iKkhEeF0mGVFVXo32lFmmp1t/oiTV1q9YRXkZKIfBCBI9cPGH17PN2YsaxGVTKhURV52QZmP+1E8+QWNFf2Ag5FrX4k2cnOGQMCBuOPYzOx+PRfqOMdCKWcmzXGCvRCGRLUYauRGL4eMq+aUJTyh7x0AOTeAZCVqA6ZGf3NSSkJUIWtFie+VNWdmQeavktTgGl6cIMGDUTV4fj4eF2148GDB6NMmTIiHyCh3H/h4eG6x3fv3kVoaCiKFCmCKlXSptm89957aNKkiZhu/Prrr+PkyZOYO3euuBEaIJswYQK+/vprVK1aVXQafv755yhdujS6d7esPHPMeCiPVdaRhID09A5S90xOe6Kwh7ykH+SlAyEvEwR56bqQFStvFoOxkjpVF/XIaRYYY/k776MLylRIj66JW7YU9pC5lICsSEnIinhlui8p3oO49yyw80WRRzF0GVSn06YaK6q0g7WzV9hjSNCb+PHgN1gashD1yjWCk52T0bZnPmf2jFnAqErymqEiKWpa41dK774kZPbOMJ8oGgnK2q9DZu8Ca9eichtsj9yC64+uYlfkNnSs2dXUu8SYlV0oy8QJHpKeQLp3Hqp75wEavSVKR8hL1Ybc2z/9FgCZuw9kMtNMVFCHrweSn0FeuTXknKfUbPTt2xcPHjzA5MmTRdGQgIAA7NixQ1dUhKYIU8VjraioKJFjUGv69Oni1qJFCxw4kDaCXr9+faxfv17kEPzyyy9FJyB1Pg4cOFD3uY8++kh0Ro4aNQpPnjxB06ZNxXYdHR0L9fsz80URx5SDyyCZHHZtvoBEhUCizkBz7zw0USHihvRqmpTWgDoLFWXqinvRBjoW/hR19aUdQPwDyMvUg7xkrULfPsverFmz8OOPP4r2z9/fH7/99psYMMnK6tWrxaDGjRs3xCDH999/j44d/0ufQdFbU6ZMERXdqW2jyGoq5ETL6kdWf/jhh/j333/FYEudOnXw1VdfoVWrVvxzsezP+2QKKBuOhrL+CEjP7wPPH4h76XlM2n283mN67+ldccsWnRc6e2TsRHQx0KlYpARkSscc5FFMuzYnKetHAhaURzGv6pdrhNqlAnD+XijWh63CgEDjVbCXSaaMEbVANFXFzc0NcXFxnKfGClEOQppibCiS8KUciqY3bumdh0UzdSLSrWhJyOyM05koRlXO/A3V6fmAOhX2fZdBWbk1bEH4/TBM2fUJXOyL4Lfuc1HUgXNIFTRu+2wgef+cZobbPpkcjm8dESeU0sNIaKJCoY4OhSb6LKSYiLQcNvocXCEvVSc92jC949C1jNGjbeh0Jmlhe9GRad9nMZRVrX9kmRkft33Wj9LJ0GwR/eT9dJ85eb+kToHmfriopqntLJQe38i0NhlknlVFpKEiPeJQ5lnd6An1k5b1hubmv7Dv8iuUtfsYdVssd1auXCmipamoUsOGDcVgBnUCUroELy+vF5Y/evQomjdvLiKrO3fujOXLl4tOwpCQEPj5+Yll6Dm9v3jxYl2U9Pnz50UEtnYQpFq1aqLTkJZzcnIS2120aBGuXr2ao3yw3PZZt5yc9+Vk9pxEn098rNdpGAMpXu+x3j1SE3K2c45uBjoQ6W9FhtS9Uw1HQOZiny3Z7Se38L8t70Auk+PnLn/A27W0UbbDnYS5xA2mdaMiJZSD8IWLXiKTQ16tAxQVm6U3ePchPbuX3vDdAxJic7YRB9eMkYiiM7GkXkdi+uu56Ew0NKpC+2tJ1any66eD03D81r/oUL0zRjQYberdsTrc9lm/nF4o65NSE6GJCRcdhxrRcRgKKfbqiydwzp66DkOFdqqyi2eB7r86KhTJi16DzLU0HN8+abVV7ljh4rbPNlCSfpquS1PwaEBE6T8gZxfI8Q9Fu6fWdRyeEdHMGdg5izZPnh5tSFGHdL5XYPv+8DKS5jYHnIrDaVxItlE4rPBRxyBFPv/++++6nKxUMX3cuHH45JNPDEZeUwT0li1bdK81atRIRGBTRyMNiFHahA8++AD/+9//xPsUvEKR2dQJ2K9fPzx8+BAlSpTAoUOH0KxZM7HMs2fPRIDL7t270bZt25fuN7d91i8v5335ISU//+8aWnQmpkciZohSjBGdjrlG0Y+NxsC+1WewdgtPzcW2i5sQVLYBPmmVng6jgPF0Y8ZyOu2E8gG0mpTlSSONMEvxDyA9u5+xE5FGUzJ1JkrJTyHFXsl5ZyJFIOo6EjNGKtK6DeZRTK9OZQl5FAuqPHzwnZPYdWkb2lXriHI81ZCxXKETQmovcnOhLLNzgoIiZsoE6V6Tkp+lTcujTsP0zkMxXe/qXnFTaT/rWibtwjm985Du8zNNTxWyOO17BAziDkLGWK5QO5eXi0sa7KA0NHTTRtXQ+Z3mblqkoSh48iACmltHxQ367Z/Ia5ie37Ckn2hP80J1ZqmuDecOQvNC03yDg4NFWgQtSq1AnXTHjh0z+Bl6nfK46mvfvj02bNggHl+/fl1MW9bv6KNZbtQZSZ+lTkIPDw9Ur14dS5YsQd26dUXV9jlz5ojIRSokZUhycrK46XcSMuuWl/O+/KCCSqKokkflbJejIlFp0YgZIxHVF9ZDenIzq0+l51m0fq/7D8Dh6wfEde+Zu8EI1DsHLyjcSciYHrm7jxg9yWpUJduLZUrc6loGoFs2MnYmpnceZuhMTOtgzHFnosI+m+nRMtHw28KoSsmipdDZtzvWh63GvBOzUL1ETTyIj0EJFy+0rvIqvF/yuzDG8n6hrE/mUBSKCk3ELUO0zb2zYooy3Sjqj/LXqOkWufW/z7pXztBpKC/l99KoapFqIXgR1OdXiTZPXvEV/ikZYyZB+VhlntUg96wG+PcTr0kp8WltH+U1TI841LV/lOKGyJUil6DIa5gecSgrXinbNA1paWaWivZPrKJSy8L5kizHKKJPrVbr8q9q0fOLFy8a/Ax1ABpanl7Xvq99Latl6N/Nnj17RJGmokWLio5J6iCknKzFixc3uF2aljx1Kk3lzCg2NlZ0djJrVRSo/dZ/T+mS8uFDmJ4T4FAh7ZZeuNgu/hmUZxdBZmDGnwQZkuw98Mws9t34ulbthWVhCzHn2G+oW6o+Hic9goeTJ5qUbQYvl+zTCXh6ehqnk9AUyVcfPXokwrI3b94sGrpevXph5syZotKd1rlz5zB27FicOnVKhFjT8pS0Wh+t/7PPPsO6devEOitUqCByNOjvD7Ntxh5VyVVnohg5icnYmagL0/6vMzGbtdjMqArp4dcHOy5uQUTMBVyMCdedKG28sBZjmoxHq8ovn17BGCt4Itqmchtx0/53X3oWnT5F+Wz6/TlIj65CTbcL69I/qBAVlLWdhjRVWVaihmhHM6ZakGilopMweWkPm0q1wBgzb1RETn/gJK39i9JFG4qOQxF9nTaIguCFaR90Kp42PVnXcRgImaNb1sn7Vw6wieT97OXo3xhdE1PH4OHDh0VOwvnz56NLly7iOtnb2/uFz1C0o34EI0US0rRoikqkacqMmZqm0XAknU1vHzORQULRRiMgdy/YVDbmqot7d+y8vgUP4x9gz/UdumveXde2Fcg1rzIvyVepAdFPvkoh0NklX+3fv3+G5Ks0qqGffPWHH37Ar7/+miH5Kq1TP/kqVauLjo4WeRRSU1MxbNgwUa2O1qdtyNq1aydCr2nfKHnr8OHDUaxYMbEcoVGQV199VeznmjVrUKZMGdy8eVMsw1hBR9MUSGciVZ4S1aeylrLvK6hOzDGcR5ESaL/k89bkSeJjJKmSxGMpPSeatjbT7KMzUaOEr9ESvDLGco5OZCh3oJz+Hqt3/O/C+fENXW5DccF87xykmHCo6XZ2OVJpQYUD5CV9RZQNTT3JmP8wrbPQllItMMYssf0rAzkNFtfsIl6T1KlpbZ0u2vCMGDTRpmnQfdajCmQeVaGhasaZc7/aWJoZS0AROwqFAvfv38/wOj3PqngIvZ7d8tp7ek2/s4+eU95Csm/fPpHT8PHjx7oOvj/++ENcR9P1tqFciDQlmW6MWeOMP2sT8/weYuMfGu2aV57bD/z8888YOXKk6KTz9fUVHXLOzs5YsGCBweUp2q9Dhw6iBHvNmjVF6XXKjaBN3kpfhjoaJ02ahG7duony7JQ/ISoqSpd7ISIiQoRH0wgIdUw2bdpURC+uWLFCLEeWLVsmOgFpP2rVqiXyMbz77rtif7XoPYoepPVStGLFihXRokULEQ3JmKVSBgw0XOVJkEQUpK3Yd2V3llNz6PV9V3YV+j4xxnKG/kbpBE9Zqwfs206F4xsb4PTBZTi+uR/2nWZAWXeIiCikdo0uoNOiDaVsUy0wxpglkCnsRLS0XdBQOHT9DU6jj8DpvXA49F0GZdMPIPdpBTgWS8t3eGk7t30Wwt7eXuQA3Lv3v45eKlxCzxs3bmzwM/S6/vKEOve0y1NADXUU6i9DwTInTpzQLZOQkFZFlmbf6aPntH3GLBVFSlMVYypSoqjZVdyL5zYWQb3PyNe88rwkX9VPlJqT5KuZKyhRlKB2+ZclX9Wug6L96tWrp1uGlqdtU4OoXYbKxVNjrL8dinCkURSyadMm0XhS+DXlbaBIxm+//VbkimDM0kdVqJoxTc3Tv7e1URXKQagdRclMSn+fMWY5qEKx3KsGlP79YN/hOzgO2w6nDy7BYdh2yEplN8BnW6kWGGPWR+ZUHIrKrWHf/H9w7LccTu9dgONbh8UU5LToGUO47TM3NAOPUmpRBB8FvowZM0ZUL6aAGzJ48OAMhU3Gjx8vgmN++uknkbfwiy++wOnTp/HOO+/oOgAmTJiAr7/+Wlzb0uw5WgdVPKbZeoSudyn34JAhQ3D27FlcunRJBOzQdXenTp1MdCQYK9gZfw7dZ4t7W7rWLaxrXqUlJF+l+8xTmZVKJdzd3TMsQyMrmdehfY8aymvXronwa5q6vG3bNly5cgVvv/22mL5MOREN4UpPzBIUdnUqc0VFSujkyVCjKUt/nzFm2WRKByi8A6Co1Ayq+2GcaoExZjtFUTyqQF6hSVruQk4zYxH69u2LBw8eYPLkyeKalKYEUyeg9jr11q1bGSL+mjRpItJp0Sy7Tz/9VOTop1lw2jRdhHLuU0cjpdSifPs0y47WqU3TRdOc6Tnl4W/durW41qWZdhs3buQZdIxZgRJGvua1qerGFF5NnY1z584V+SEo/Pvu3buiCEtWnYRc6YlZDnOtTlV4Aj3qYaO01uB71IgGetQXgx15rfTEGDMfSv/+UB3/I4t3bSvVAmPMdnDbZ3koClAbCZjZgQMHXnitT58+4pYV6hz48ssvxS0rNANv586dedxjxpg5a13lVVGYM6tr3tZV2hVeJ6Gpkq/SMjExGUMmVSqVyC+ovx5D29HfBq3fzs5OfActypNIozo0lVp/qrIWV3pizHJQG0UVnShhqxhd0aazlSTxum+FWqbeRcZYAeEE1owxW8RtH2OM2TZv1zLZXvPmt1CnMq/JV7U5D7TJV7MaHdEmX6XcCS9LvqrtFNQmX6WcDdp1UCg15UOk7ROaNkzbptyF2mUopJrCqakjULud6tWri6nGhIqVUPg2fU4b1k05Gqjz0FAHIeFKT4xZFir5ThWdKGEr5WOgcGsaTeGqxoxZH061wBizRdz2McaYbWtlxGtemZRVxsMsrFy5UiRBnTNnDho0aCAqE69atUrkJKTcCpQ4tUyZMmKaLjl69KioIPzdd9+JRKlUkZiKhYSEhOhyK3z//ffifUroSp2Gn3/+Oc6dO4fw8HBdboXXXntNRAZSNWXqCKRkrxRGTZ1+JC4uTnQItmvXDh9//DHCwsIwfPhwzJgxQ+RrILdv3xb5GGj/x40bh8uXL4tlqAoydTDmBHVgUmEV2p62pDxjjFk7bvsYY7aI2z7GmC3ito8x26W0hOSrZNmyZSJasU2bNmL9vXr1wq+//qp7nzrudu3aJSoXU7QhTTukfdR2EJJy5cqJ3Azvvfce6tSpIzozqYIUdSoyxhhjjDHGGGOMMWarch1JaOsogrBYsWIiKpEjCRmzLkWLFhV5HdiLuO1jzHpx25c1bvsYs17c9mWN2z7GbLfts6nqxgUhNjZWF5XIGLMunEYga9z2MWa9uO3LGrd9jFkvbvuyxm0fY7bb9nEnYS65u7vrplXTFGdrzD9BHaDWGinJ389yFcZvR6MqzDBu+ywbt32Wzdi/H7d9WeO2z7Jx22fZuO0zHW77LBu3fZbtqYnP+7iTMJe0+Rapg9AaO9G06Lvx97Nc1vz7WfN3M2fc9lkHa//74e/HChq3fdaB2wbLZu2/nznits86WPvfDn8/4/ivwghjjDHGGGOMMcYYY8wmcSchY4wxxhhjjDHGGGM2jjsJc8nBwQFTpkwR99aIv59ls+bfz5q/myWw9uPP38+y8e/H+N8W/+1w22B9rL1tN2fWfuz5+1k2/v2MSyZJkmTkbTDGGGOMMcYYY4wxxswYRxIyxhhjjDHGGGOMMWbjuJOQMcYYY4wxxhhjjDEbx52EjDHGGGOMMcYYY4zZOO4kZIwxxhhjjDHGGGPMxtlkJ+GhQ4fQpUsXlC5dGjKZDBs2bMjw/v379zF06FDxvrOzMzp06IDLly/r3r9x44b4nKHb6tWrdcsZen/FihVG/W7Tpk1D/fr1UbRoUXh5eaF79+6IjIzMsExSUhLGjh0LDw8PFClSBL169RLfWd+tW7fQqVMn8f1pPR9++CFUKlWGZQ4cOIC6deuK6kJVqlTBokWLjPrdCur7nT17Fv3790e5cuXg5OSEmjVrYubMmS98N0O/371798z+++X0356l/n60n1n9/cXExJj09zN33PZx28dtH7d9tojbPm77uO3jts8WcdvHbR+3fdz25Ylkg7Zt2yZ99tln0rp166iys7R+/XrdexqNRmrUqJHUrFkz6eTJk9LFixelUaNGSeXLl5eeP38ullGpVFJ0dHSG29SpU6UiRYpIz549062L1r1w4cIMyyUmJhr1u7Vv315sMywsTAoNDZU6duyYYd/J6NGjpXLlykl79+6VTp8+Lb5vkyZNdO/T9/Pz85Patm0rnTlzRhwvT09PaeLEibplrl27Jjk7O0vvv/++FB4eLv3222+SQqGQduzYYfbf76+//pLeffdd6cCBA9LVq1elpUuXSk5OTuI7aO3fv1/8fpGRkRl+P7VabfbfLyf/9iz590tISHjh74/W26JFC5P/fuaO2z5u+7jt47bPFnHbx20ft33c9tkibvu47eO2j9u+vLDJTkJ9mTsJqVOBXqNODC3qWChRooQ0b968LNcTEBAgDR8+PNt1m0JMTIzYj4MHD4rnT548kezs7KTVq1frlomIiBDLHDt2TPcfFLlcLt27d0+3zOzZsyVXV1cpOTlZPP/oo4+kWrVqZdhW3759RWeNuX8/Q95++22pVatWL3QyPX78WDKlvH6/l/3bs6bfj9ZBn1myZInZ/X7mjNs+bvsIt33c9tkabvu47SPc9nHbZ2u47eO2j3Dbx21fTtjkdOPsJCcni3tHR0fda3K5XEzJPHLkiMHPBAcHIzQ0FCNGjHjhPZo26enpiQYNGmDBggXUKYvCFBcXJ+7d3d11+5qamoq2bdvqlqlRowbKly+PY8eOied0X7t2bZQsWVK3TPv27fH06VNcuHBBt4z+OrTLaNdhzt8vq/Vo16EvICAA3t7eePXVV/Hvv/+isOXn+2X3b8+afr8lS5aIafG9e/c2u9/PknDbx22fOf3tcNvHbV9h4baP2z593PYZF5/3mQ9u+7jt08dtn3HFWdg1rzLfa7Ay2h9n4sSJmDNnDlxcXDBjxgzcuXMH0dHRBj/z119/ibx2TZo0yfD6l19+idatW4sfc9euXXj77bfx/PlzvPvuu4XyXTQaDSZMmIBXXnkFfn5+4jXKyWZvb49ixYplWJY6BLX52uhev4NQ+772veyWoY7ExMREkevPXL9fZkePHsXKlSuxdetW3Wv0R/bnn3+iXr164j+i8+fPR8uWLXHixAmRx68w5Of7vezfnjX9fvT3N2DAgAz7bA6/n6Xhto/bPnP52+G27z/c9hkft33c9hFu+/i8z9Zw28dtH+G2j9s+Q7iTMBM7OzusW7dORAVST69CoRA9vK+99prBKEDqUFm+fDk+//zzF97Tfy0wMBDx8fH48ccfC62TkCLJwsLCsoyAtHQF8f3o8926dcOUKVPQrl073evVq1cXNy3qAL569aroMF66dCnM/fuZ+t9eYf1+NNISERHxwm9iDr+fpeG2z3Jw25c1bvu47cstbvssB7d9WeO2j9u+3OK2z3Jw25c1bvuqG+Wal6cbGxAUFCSmDz958kRED+7YsQOxsbHw8fF5Ydk1a9YgISEBgwcPfunBbtiwoYhI1IZ3G9M777yDLVu2YP/+/Shbtqzu9VKlSiElJUV8N31UPZbe0y6TuVqu9vnLlnF1dS2UKLT8fD+t8PBwtGnTBqNGjcKkSZNeuk2atnvlyhUUhoL4ftn927OG349QlBOFV9PfrDn9fpaK2z5u+wzhtq/gcNtnnrjt47bPEG77Cg63feaJ2z5u+wzhtq/gWGzbJ9m4nBQXuXTpkijksXPnzhfeo4qqvXr1ytG2vv76a6l48eKSMVF15rFjx0qlS5cW+52ZtjDEmjVrdK9RBWdDhUvu37+vW2bOnDmicElSUpKu8AVVQNbXv39/oxe+KIjvR6gwjZeXl/Thhx/meNtU7blHjx6SJXy/l/3bs/Tfj1Alcaoorl+V2tS/nyXhto/bvpziti//uO0zH9z2cduXU9z25R+3feaD2z5u+3KK2778s/S2zyY7CelAnzlzRtzoh/j555/F45s3b4r3V61aJaqjXr16VdqwYYNUoUIFqWfPni+s5/Lly5JMJpO2b9/+wnubNm0S1ZDPnz8vlvvjjz8kZ2dnafLkyUb9bmPGjJHc3NykAwcOSNHR0bpbQkKCbpnRo0dL5cuXl/bt2yedPn1aaty4sbhpqVQq0YHUrl07KTQ0VNqxY4eo7jxx4kTdMtfSy4lTJxtVn501a5akUCjEsub+/eg3oe8zaNCgDOugKrlaM2bMEL89/Xa0/Pjx40XH6Z49e8z+++Xk354l/35a8+fPlxwdHQ1WMDbV72fuuO3jto/bPm77bBG3fdz2cdvHbZ8t4raP2z5u+7jtywub7CSkDkDqHMx8GzJkiHh/5syZUtmyZUXvLnVWTJo0SUpOTn5hPdRpVq5cOUmtVr/wHnUcBgQEiF5fFxcXyd/fX/rzzz8NLluQDH0vui1cuFC3TGJioih/TpFl1FFEPc3UUaPvxo0b0muvvSY5OTlJnp6e0gcffCClpqa+cBzpO9rb20s+Pj4ZtmHO32/KlCkG10GdwVrff/+9VLlyZdEJ5e7uLrVs2VJ0WlnC98vpvz1L/f20qONwwIABBrdjqt/P3HHbx20ft33c9tkibvu47eO2j9s+W8RtH7d93PZx25cXMvq//E1YZowxxhhjjDHGGGOMWTIuXMIYY4wxxhhjjDHGmI3jTkLGGGOMMcYYY4wxxmwcdxIyxhhjjDHGGGOMMWbjuJOQMcYYY4wxxhhjjDEbx52EjDHGGGOMMcYYY4zZOO4kZIwxxhhjjDHGGGPMxnEnIWOMMcYYY4wxxhhjNo47CRljjDHGGGOMMcYYs3HcScgYY4wxxhhjjDHGmI3jTkLGGGOMMcYYY4wxxmwcdxIyxhhjjDHGGGOMMWbjuJOQMcYYY4wxxhhjjDEbx52EjDHGGGOMMcYYY4zZOO4kZIwxxhhjjDHGGGPMxnEnIWOMMcYYY4wxxhhjNo47CRljjDHGGGOMMcYYs3HcScgYY4wxxhhjjDHGmI3jTkIjGz16ND7++GPx+MaNG5DJZHjy5InBZel1ep+W0xo1ahTc3d1RqlQp3Lp1C0WKFEFcXJyxd5uZkYoVK2LDhg3ZLvOyf1uMFTZLb/uSkpLQo0cPFCtWDA0aNMDhw4dRtmzZQtk2/b3T3701mDBhAoYOHWrq3WCs0Fh62/faa6/hjz/+gLlZtmwZmjRpYurdYIxZadtX0BYtWoSAgIA8f75ly5b45Zdfsny/Vq1a2LJli8Ft6b/HWF4o8/QplmN//vlnno/WkSNHsGbNGly/fh1ubm7itefPnxf40b979y78/f1x//59KBSKAl8/Y8z2WHrbR9uPjIwU7zk4OIjX7ty5U+D7wBizLpbe9m3fvj3H66ELU7qIDQ0NhbENHDhQ3LRoIIW23b17d6NvmzFm/W2fpblw4UKO3ivMdppZD44kNGPUUJYvX17XWL5MampqnrazefNmMXJsysZSkiSo1WqTbZ8xZj7Moe2jfahWrZqug/BlVCoVbEFejzVjzDLaPsYYK2yW1vbxdSuzdtxJmAcrV65Eo0aNdM979eoFb29v3fMPPvgA48aNE49pmhVNtzIkOTkZY8aMEaHVlSpVEiMoWr/++itGjhyJ8+fPi3BrWk/m0G16bcSIEXj99dfh6uoqRnCo0Zw8eTIqV64MDw8PdO3aFVFRUS9tMGk5Q/7++2/4+fmhaNGiovH+/PPPRcNIxo8fj+HDh2dY/vvvv0f79u3FY1qOvkeNGjXElD0Km46IiMgwCjxt2jRxLJ2dnREeHp7t9rQjI7Q8vd+qVSt89NFHYr1aMTExYqSZfo/SpUuLY0/H+WVoPRUqVBDr9fX1xerVq3XvHThwQOz//PnzUa5cOXFcaXktbYj3V199BS8vL5QsWTJDeHjmfwOZQ+x37dqFevXqif8w0n6//fbbSExMRH7Qv4OJEyeKY1iiRAn07dsXDx48EO/R8aTpABTOT/9uqCNEG5IeEhIiji+97unpiS5duuRrP5h1sZW2j74H/T3T3wXtw5QpU3TtgBa1O9QOtGvXDi4uLiL6hka933nnHfF3R23B4MGDczRVhiIUaT30XYKCgkRbqO/nn39G1apVRftE3+/333/Xvac9NkuXLkWVKlXEPtLx0T+BpuNL71EbQ8e2c+fO+OKLL3Tv0989taf0e9By8+bN071Hy9Hy2t/rk08+yfa7HDp0CLVr1xbHrWfPnnj27FmG9wcNGiTaZu133b9/v3id9pfaTjrO+mrWrCn+3WXXbjFmbLbS9mWe4pbd+c+ZM2fE9ELt/tKNpgiSFStWoE6dOuKz9evXx9GjRzOsn85P6FyR2rS6deuKdei3d9SG0nt0nkjbzjydrk+fPmJb/fv3F9ul/XjvvfdeSG3w3XffiQ4Bxlje2Frb9+GHH4p7an8aN2780uvWK1euiLaMvhfth6HpwZ9++qnYP2rX9FM5UBvatGlT8Vm6VqP2LDY29oXIx+z2J6t0VNr3DLXTN2/ehKOjo+iY1U+xU7x4cZw4cSLb48dsiMRy7d69e5JSqZSePn0qaTQaycvLS6pYsaIUHh4u3g8ICJDWrVsnHg8ZMkQaP368eHz9+nXq7ZIeP34snn/++eeSv7+/dPfuXfHaa6+9Jt6n5cjChQvF+1qZP0/rdnJyknbs2CGp1WopPj5e+vDDD6XWrVtLUVFRUnJysvTBBx9IzZo1y/K7PH/+XHJ1dRXfxZBt27ZJkZGR4nueOXNGfNe///5bvHfq1Cnx2YSEBN3ytWrV0r0/a9YsqU6dOtKlS5ek1NRUaebMmVLlypXFfpEKFSpI1apVky5evCipVCrxenbbS0lJkXx8fKQvvvhCLHv8+HHJw8NDatGihXifPtOwYUPp/fffF8fi4cOHUsuWLaVJkya99Delbdy/f1/sxz///CM5ODhI165dE+/t379fksvl0nvvvSclJiaK39nZ2Vm8rv2d6N/D9OnTxT7S6/T8ypUrL/wbIPT76f/Ohw4dkkJCQsS2r169KtWoUUP6+uuvdcvTcVq/fn22+5/538bUqVMlPz8/6ebNm9KzZ8+kvn37Sq+++qp4b+fOnVLZsmXFvztCy9AxJ40bNxbbpn9PSUlJ0sGDB1967JjtsKW2b8qUKVK3bt10z+nv2s3NTfec2p0SJUpIJ06cEMeC2sE+ffpI/fv3F/tJ6+/Xr580aNCglx5X2s/BgweL7xERESGOKf3da61Zs0a6deuW2M6+ffskR0dH6ciRIxmODW2XvgsdU/r7pmNI6G+blt++fbtoh+fOnSt+Q/p+JDo6WnJ3d5dWrlwp2qDz589L3t7e0p49e3THQaFQiPXR52kfs/Lo0SNxjP7880+x7KZNmyR7e3vxe2ktWLBAevLkiWgrf/jhB7Ft7W9Av5n+skePHpWKFy8u2qLs2i3GjM2W2j5q22bMmJHj8x/9/SVbt26VypQpIwUHB4t9XLt2rfg7p3My7frp/dDQUNFOjBw5UnceR3/T9P2oHdQe97NnzxrcVuZzI2q7ihQpIs55tKpXry6tWrXqpb8vY8wwW2v76JyDzj1ofZ9++qlUtWpV0U5ldd1KbQztB7WP1FbR+dOyZct034nOn2g9tCytt2jRorprK2oDDx8+LM6H6DjTvr/55pu52h9tG5hd+2ione7Vq5fuPJAsX75c8vX15T8DpsOdhHlEf0h0IkSdO/Xr15feeecd0SkWGxsrGlO6WHpZg0kdXnRhpkWdXrltMPUvYqnxdnFxEY2OFjVadIJHF5iGUAOi7TzKCfou+g0YHQfqVCN0LKjx015E0nsbNmzI8PnSpUuLTjFtA6Y9Ec3J9uhzdAGqbRzJ22+/rTu5PHnypDgRpf94aO3atUsc59yi467tnKSTYZlMluHiuG3btqJTUPs7lSpVKsPnq1SpIi7sc9JJmBkdE1p/fjoJafsrVqzQvU//Uab36Z46GTw9PcWxof8w6WvevLk4Yb99+3YOjhKzRbbS9uWkk1D/7zomJkZsT/v9CQ2Q2NnZiZPJrND+0XejQQqt7777LkMnYWa0X9qBBO2x0V5UE2oz6XchX375pdSpU6cXfkPtySF11HXv3j3D+3QiOnz4cN1xyHxymZUlS5ZINWvWzPBahw4dMnT8ZVasWDFdhydddOhf5I8aNUoaO3aseJxdu8VYYbCVti9zJ+HLzn8ytw8dO3aUfvnllwyvNWnSRLQP2vV//PHHuvfo75/+7gkNrtKgBp0/6Q9AG9qWoXOjBg0a6AZI6MKazglpkIExlne21PaNGTNG95zONahTkTryDF23UttF72uDX8g333yj2wZ9J3pf/5xl9OjR0ogRI7LcP7p+y83+5LWTkIJyKlWqJI4jadeunfTjjz9meWyY7eHpxnlEU7NomtS+ffvE4zZt2ojndKMpFhSy+zIUEk1TXLX0H+cUhS5rPXz4EPHx8WjevLmY4kE3mpplb2+P27dv5zrsmuzcuVNUk6OppzRVjcK7aTtab7zxBpYsWSIe0z2FoVMINqFQcZpapt0Xuj1+/DhD8n/9/X/Z9uh4UYi7Uqk0+HnaHoWlU9i2dnu9e/cWyWlfZsaMGaISFG2TPhcWFpbhe1Jou/Z7EZpeqD+NjqbJ6cv8fnZOnTqFtm3binXQdigsXX/beUHHWL86Kk3vo9xq9Dr9e506daqYyk3HmX4zbcj5ggULRMg5TQOkaeL60xoZs6W2L7f7QO2PRqMR02i0+0DT7ORyOe7du5ftsaBpHzQ9OavjQVU9aUqetm3btm3bC20EfV9D7Q+tn6YJZrfftD79dpqm/kRHRxtcPje/a+bvQsfns88+E1Onqa2jbdF0bO13oanFlG6CpiFRO0TTnLQpLbJrtxgrDLba9r3s/CczalPoPEa/TaGE+TRtLqv2SluggKbrLV68WJx70DkRpWHITbJ9ai9oWjKhe0o/k9O8sowxw2yp7dPfLzs7O3Hdqd926e8DXVPR9RVtU8vHxyfDdS69T+vRX792fTRVuVu3broULHTNnPnc7mX7k1c0RTolJQUHDx4U66N7uqZnTIs7CQugwWzdurXIF3D48GHs3btXvJcT1ChQXgAtbS6X3KALUC3Kd0AncpRPgDrLtDfKb0cdb5nRBdvWrVuzbDCp8aCcUm+99ZZoQOhijvIa6OcIpBMw+s70/j///JOhgaELU8rtp78vCQkJIueCof1/2fboeNHFtn6BAP1jRtujC2397dE6XlYdiypqUd4t6uSkTkz6HF2o6n/P/KD8D/S9tfQvvgkdD/o3c+3aNTx9+hTffvttvrddtmxZXc5DQseN8oHQ64TyHh4/flwcPzqBfvfdd3Un6HQcaHnKA/S///0PwcHB+doXZl1soe3Lyz5Q+0PP6URYfx+os6tMmTLZHgtahvKpGjoe9HjIkCH44YcfxDK0zo4dO+a4jaD1Zz5hztxu9ujRI8M+UwcAdRwa+p65+V0zb2v58uXiRsee2mbaFg3M6H8XyjlEF/fr168XJ8fUOaqVVbvFWGHgtu9FhtoGalN++umnDG0KXcy/LJ+pFuUco//G0AAvVSHN6sLV0LbpfOr06dMiVxgNMgwbNixH22SMZc2W2j79faSch3TNpn8Op78PdE1F53z6OaDp2kt7rUUyv0/fW7s+usalx9Re0fUf5eXPfG73sv3JCUNtJb1GeR7pfIuu+6jTMHPAC7Nt3EmYRy1atMDZs2dx7NgxkXSURjCoUaCID2pAc4JOZiipsvai8ssvv0R+0B88NTiURFZ7UUgJUOlEyZCTJ0+KBiGrKBHqVKKLV2qI6YKMGmK6wMt8Mkjfny7saCRF/z8WY8eOFQllIyMjxXNqADdu3JjlCPTLtkeJYuk4U9JYaigpAm/VqlW69ylqh/Zn0qRJYhvU0FLjSgUFskP7RVWuKGks/UeEoukokrCg0EUuRUhSw077RdEwmbdP34tG0ykh7ezZs/O9TRqNos5G+ndAnaTvv/++iFak/0jTcaMk4tQp6+TkJLarjc6k/1DQiTklC6Z9on9TXP2Q2Vrblxc0gt29e3dRuEQ7Ekyd7dTZlR1qs1555RVxAU0nt9RezpkzR/c+/f1SW0YDIPQ9qfOOih3lFF1w79mzR3yGBliofbt06ZLufboApxP/tWvXinaVbhS5Q+1EbnXq1EkM8FDhE9oWnZDTuvXbOvrvBEUCUvtDv3vm/x5QkSUamKB/H/qFsbJrtxgrDNz2vYjaUTq30S+2Rud+P/74o/g7praLBkmpDdKPrskKtX+7d+8W66O2ggZZs/o7p21fvXo1w2sUjUNRxgMGDBBR3YGBgXn4pRljttr20efp+lN7jkLXhvqFW/Q1aNBArJOudekalq4df/vtNzGwq0UDJFQIj9ZH66VjRgE22nMiKkhC7RZ9B2o387M/uWmnCZ1jrVu3Dn/99dcLhUgZ407CPKKLHKqCSze6WCEUfk0nQxT6nBPUmUVVbSlqjSq20QVmflEHGlU/okabGh6aNprVBeXLwq7p87NmzcKoUaNEA/bNN9+IC7jMqIIndYJRxxR1LmnRxTKNUlB0IH2eppJl7mTMzfYozJo6GamiJYW2U4U92qZ2Kgl1ZtF7dJFK26IIFbpopXDu7HTo0EFMS6aKnNSJRhWU6aK9oNA+0n9gafou/c60T/qoQ2D69Om6Cn39+vXL9za1lQPp3wJNO6YLfxqh0v5HiSJyqDOWOjboP9gzZ84U79GJPI3c075QCDz9B0tbTZAxW2n78opGZLXTjKkNa9asWY4icaldpBNE6giki1v9kzU6zjRFl74X/c3SCWNu9r169epi+h5VFaTP00k+rUvbbtKINLXf1A7RNBY6maSLfGoncoumQ1MbTe2JtiKq9mSY0IkzpXWgCEGakkOdffoj7oR+O6pcevHixQyfza7dYqwwcNv3ImpL6IKV2hH6m6comS5duojOAKpWSudq1FlHf6s0CPsydCFMKQWoHaK/dRpk0E4fzoymNNO0ZNoutQ1aNGhNHRocRchYwbClto/Ovz7++GNxPkMDFlQhOKuBCroupetOOs+j8xJaPwVl0HmcFn1fGjSl8yu61qRrW21ADVVyp8/T+SJdc9EAR372JzftNKHzMPpNaLA287UpYzJKTMiHwTZRpxhFldAFraWiqcl04kmRK4wxZittX35QxyGNfOt3wpkTGi0/d+6cyE3IGCs4ttD20QUw5T2lgQTqaGSMsZy0fTSNmjovJ0yYYDMHjDohqQOSglUY08eRhDaKRmspSo9GECwJ5cCgiBvqGKRcGBS2TVEnjDFmzW1fftAIOo0U03QYyhVG004ogtocPXjwQAz6UOQjY6zg2ELbp1ar8f3334s0C9xByBizlbYvLyhdAw3GUsANY5lxJ6GNolwvFPqtPz3YElBxDwqZpumwdBFJU1qo+t3LUH4++oyhm6WgqciG9p+m7zHGzLfto8GMrNqfvCTvzi2aTkxTfGnKEBWY2rRpU54voI3ZDtE0HEqPQNNeaCoTY6zgWOp5X05RtXOatkdVOqktYYwxW2j78oI6BmnaN01lpshrxjLj6caMMcYYY4wxxhhjjNk4jiRkjDHGGGOMMcYYY8zGcSchY4wxxhhjjDHGGGM2jjsJGWOMMcYYY4wxxhizcdxJmEuSJOHp06finjHGbAW3fYyx/Jg1a5YoTOPo6IiGDRvi5MmTWS574cIF9OrVSyxPyeZ/+eWXF5aZNm0a6tevj6JFi8LLywvdu3dHZGRkhmWSkpIwduxYUaiHCuzQOu/fv5+r/ea2jzFmi7jtY8x2cSdhLj179gxubm7injHGbAW3fYyxvFq5ciXef/99TJkyBSEhIfD390f79u0RExNjcPmEhAT4+Pjgu+++Q6lSpQwuQ1VsqQPw+PHj2L17N1JTU9GuXTvEx8frlnnvvfewefNmrF69WiwfFRWFnj175mrfue1jjNkibvsYs11c3TiXKIqQOgnj4uLg6upqnF+FMcbMDLd9jLG8oshBivr7/fffxXONRoNy5cph3Lhx+OSTT7L9LEUTTpgwQdyy8+DBAxFRSJ2BzZs3F+dpJUqUwPLly9G7d2+xzMWLF1GzZk0cO3YMjRo1ytG+c9vHGLNF3PYxZrs4kpAxxhhjjBlFSkoKgoOD0bZt2/9OPuVy8Zw66woKdQoSd3d3cU/bpOhC/e3WqFED5cuXz3a7ycnJ4uJY/8YYY4wxZiuUpt4BxhhjjDFmnR4+fAi1Wo2SJUtmeJ2eU2RfQaDIRIo0fOWVV+Dn5ydeu3fvHuzt7VGsWLEXtkvvZYVyHU6dOvWF12NjY0WHJ2PMOnh6epp6FxhjzCxxJyFjjDHGGLNYlJswLCwMR44cyfe6Jk6cKPInalEkIU2NpuInnGaGMcYYY9aOOwkZY1Yn+uld7LuyGw/iY1DCxQutq7wKb9cypt4txhizubaPonUUCsULVYXpeVZFSXLjnXfewZYtW3Do0CGULVtW9zqtmyL/njx5kiGa8GXbdXBwEDfGmOUwx7aPMcaMTfPoGlRn/4EUdwcyt7JQ+veH3N0n3+vlTkLGmFXZf2U3Zh/7FTKZDJIkifuNF9ZiTJPxaFX5v9xUjDFmTcy17aMpv0FBQdi7dy+6d++umx5Mz6mDL6/oO1Lhk/Xr1+PAgQOoVKlShvdpm3Z2dmI7vXr1Eq9FRkbi1q1baNy4cT6/FWPMXJhr28cYY8akOrsCKds+oFrEdFYk7lXH/4B9p5+hrNM3X+vmTkLGmFWNJNOJokT/kyTdhSSZfXQmapTwhbdraRPvJWOM2VbbR9N3hwwZgnr16qFBgwb45ZdfEB8fj2HDhon3Bw8ejDJlyoh8gIQiAMPDw3WP7969i9DQUBQpUgRVqlTRTTGmysUbN25E0aJFdXkG3dzc4OTkJO5HjBghtk3FTGiqMHUqUgdhTisbM8bMm7m3fYwxZqwIQtFBKGleeC9l6/uQl20AuXvGwdPc4OrGjDGrQVNNaATZEHp935Vdhb5PjDFm621f3759MX36dEyePBkBAQGiw2/Hjh26YiYU3RcdHa1bPioqCoGBgeJGr9Nn6fGbb76pW2b27NmionHLli3h7e2tu61cuVK3zIwZM9C5c2cRSdi8eXMxzXjdunWF/O0ZY7ba9jHGmDHQFOO0CEJDZFCdXZ6v9XMkIWPMalAuGu0IcmZS+vuMMWZtLKHto6nFWU0vpunC+ipWrJjl99F62fvE0dERs2bNEjfGmPWxhLaPMcYKGuUgTGvlDL6b/n7ecSQhY8xqFHfyEFNODJFJkkhmzRhj1kYjabJu+wBu+xhjVsnVwZXbPsaYzZG5lDA41Tj9XVHEJD+4k5AxZjWeaEdNMo8qS5SrRoNWJXxNsl+MMWYsNx5dQ/CdU1m+T1E2rau04x+AMWZV1Bo1Lj+8lOX73PYxxqyRJGmgiYnIbgko/QfkaxvcScgYswpno87gSNQpKDQaETkjpwp3kpR2D2DE49vwvLLb1LvJGGMF5lFCLL7b/yVS1MnwK1WHxo4hl8khk8nT7iETFT45cT9jzNr8E7oEV2IviWhCbvsYY7ZCdWwWNDePAPZFcc/OCavcyuIPDx9xT8+punF+ipYQzknIGLN4z5Of449jv4jHA5/cgV/yUxx08cBDhQM81cloER+LkurUfOdnYIwxc5GYmig6CGMTHiKwTD183PJzxDy/LxL1Ux4uSq9AEYTcQcgYszYnbh3FxgtrYaewx6S2X8NR6chtH2PM6qlvHEHqwe8AmQLHmr+POZFbIUtPukBBMdtcS2GMiwda5XM73EnIGLN4C07NERE1tTVqtI5/IBrJ1+OiMi4kU+Q7PwNjjJnLNLuZh3/A9UdXUaF4JbzX7CMo5ArRITiw7lBT7x5jjBlN9NO7mHU0bWB4ZIMxqOTuIx5z28cYs2aaZ9FI3jBa5CJ82OwD0UFI3YPaJFtp9xJmH52JGiV88zVIzNONGWMW7fjNf3H4+n44S8DwexeyLAZfEPkZGGPMHCwOno/gu6dQ3MkdE1tNgZOds6l3iTHGjC4pNQk/HvwWiakJaFOlHVpVeVW8rnl0DSn7v0HyhjHinp4zxpi1kNQpSFk3CkiIhaJGZxx28YRMZviql16nWSX5YbROwlmzZqFixYpwdHREw4YNcfLkyWyXX716NWrUqCGWr127NrZt2/ZC8tnJkyfD29sbTk5OaNu2LS5fvqx7/8aNGxgxYgQqVaok3q9cuTKmTJmClJQU3TIHDhxAt27dxDpcXFwQEBCAZcuWGeHbM8YKw+PEx5h7bKZ4PPjRNXi4lYOy5URAJheRg/r3BZGfgTHGTG1bxCZsv7gZDkpHTGz9BTxcPE29S4wxZnR0LTj3xCzcfnITldwrY3iD0eJ11dkVSJrTDKrjs6GO2CTuxfNzK/lXYYxZhdR9X0Fz9zRk7pXFNS2llaE20RB6ld43u07ClStX4v333xeddCEhIfD390f79u0RE2N4Z48ePYr+/fuLTr4zZ86ge/fu4hYWFqZb5ocffsCvv/6KP//8EydOnBCdfLTOpKQk8f7Fixeh0WgwZ84cXLhwATNmzBDLfvrppxm2U6dOHaxduxbnzp3DsGHDMHjwYGzZssUYh4ExZkTUMP6553M8S01A/YRHaFLCD45DtsK+ybtwfOsIlI3GQFGzq7gXz+v05d+DMWbRTt8+gUXB80VhkveafaybZscYY9Zu16XtYuaIi30RfNB8IuwV9mkRhNs+ENPvIKkz3KdsfR+aR9dNvduMMZYvqvCNUJ2aD9g5waHXX5A5FBV5p7NC8YXZvZ8TMimrLsh8oMjB+vXr4/fffxfPqfOuXLlyGDduHD755JMXlu/bty/i4+MzdNY1atRIRPpRRx/tYunSpfHBBx/gf//7n3g/Li4OJUuWxKJFi9CvXz+D+/Hjjz9i9uzZuHYt65DzTp06ifUsWLAgR9/t6dOncHNzE9t3dXXN0WcYYwWL2oQ9Oz7G3IfhcFOn4vtSgXBv9zVkck6zaizc9jFmWldjr2DKzo+RrE7GiAaj0aF6Z/5JCgG3fYyZ3uWHkfh858fQaNSY2HqKKNZEaGoxRQ6KjsHMZAoxUGzf6rPC32ErwG0fY6aneRCJpEUdgdQE2HebBWWtnuL1q7GX8cm29wx+hqq9z+w2x7xyEtL03uDgYDEdWLcRuVw8P3bsmMHP0Ov6yxOKEtQuf/36ddy7dy/DMtRRR52RWa2TUEeeu7t7tvubk2UYY+ZDSk3EnfVvYUnMefF8lE9reHT4jjsIGWNW62H8A3y//0vRQdipRjfuIGSM2YynSXH46eB3UGtU6FWnn66DkM4H1dcOGu4gTFsCUtydQt1XxhgrKFLycySve1N0ECqDhus6CMnuS9t1j+UyuZhhIu4hw5gm4/PVQUgKPOzm4cOHUKvVIjpPHz2nKcGGUAegoeXpde372teyWiazK1eu4LfffsP06dOz3NdVq1bh1KlTYopyVpKTk8VNf1SFMWa6qk5Ja4ZhrioRSY5F0bpUABo0/5h/DsaY1UpIScC0fVPxOPER6pdthDeChpt6lxhjrPAquR+ZjtiEB/D3DkTv2v0gJT+DKmQxUk/MARIeZvNpGWRuZfmXYoxZ5Ky5lG0fQIq9AnnpurBrO0X3Xti9c9h7ZRcclU74pPVkhN4NFjkIaYpx6yrt8t1BSKxybt7du3fRoUMH9OnTByNHjjS4zP79+0VOwnnz5qFWrVpZrmvatGmYOnXqC6/HxsZmKIrCGDMuecx52O8aj11yGS4WLwdPh+LoUvstMTBREDw9Ofk/Y8z8LpBnHP4et57cgI97Fbzb9H9QyBWm3i3GGCsUq8/9g3PRZ+DpUgLjgt6E+sjPSD79F5AUJ96XlQ6CFBWSnqo/MwlK/wH8SzHGLI7q1HxRiAlO7rDvORcyhb14PVmVhD+P/yYeDwgcjFola4tbQSvwTkK60FYoFLh//36G1+l5qVKlDH6GXs9uee09vUaVifWXobyF+qKiotCqVSs0adIEc+fONbi9gwcPokuXLqK4CRUuyc7EiRNFERb9SELKr+jh4cE5CRkrJKoL60UC6rsA1njXEqHU77b4GGVLluPfgDFmtaPIf52cjdCoYHg4l8AnrSbD0c7R1LvFGGOFIvjOKaw9vwJKuRLvOpWA3fzWUKUmiPfkVV6F3SvjoSgTJKoY0zliWrp+SXdPFUDl7pX412KMWRT17ZNI3fclIJPDofufkLuW0b236uxy3H8WjeolaqJ99U5G24cCz0lob2+PoKAg7N27V/caFS6h540bNzb4GXpdf3mye/du3fKVKlUSHYX6y1BnHVU51l8nRRC2bNlSbH/hwoUiF2JmBw4cEMVKvv/+e4waNeql38fBwUF0BurfGGOFQ6LqdAemIWXj21CpkjC3fAOkAujs2wM1S/rxz8AYs1pbItZj9+UdcLJzEon6iztz/mTGmG24/+wefjvyg3g88NFNVDizFEhNhKJmVziO2APH15eIDkKirNMXjm8dEUVK6H26F8/r9DXxt2CMsdyRnj9Ayvq3AI0Kds0/gqJSswwF7DZHbBADJ6MbvytyEBqLUdZMkXc0jXfx4sWIiIjAmDFjRPVimt5LKHqPIvS0xo8fjx07duCnn34SeQu/+OILnD59Gu+88454XyaTYcKECfj666+xadMmnD9/XqyDKh537949Qwdh+fLlRR7CBw8eiHyF+jkLaYoxdRC+++676NWrl+79R48eGeMwMMbymaw1Ze1wqI7+CigcsLX+cNxIjUc5t/LoFzCIjy1jzGqduHUUS4MXihPAD5pPRIXiFU29S4wxViiSYiLw4+axiE9NxCvxsWgV/xCKOv3g+NYhOPSYA3nJF9NEUcQgVTF26D5b3BdmBOGsWbNQsWJFODo6iqKaJ0+ezHLZCxcuiGtQWp6ub3/55Zdcr5OuW8eNG4fq1avDyclJXPvStS0V49RH6898W7FiRQF+c8ZYQZI0KiRvHAPp+T0RLa1sMk73nkqjwuxjM0UATa/afVHWzbiz6YySk7Bv376ik27y5MmiE46mBFMnoLbwyK1btzJE+dHU4OXLl2PSpEn49NNPUbVqVWzYsAF+fv9FCn300Ueio5Gi/548eYKmTZuKdVLjqY08pGIldCtbtuwLU3YIdVomJCSIPIN002rRooWIMGSMmQfNk9tIXj0E0oMIwMULd9p9jQ3B86CQKTCu6QewT8/LwBhj1ubyw0j8euQnqsuJUQ3Hwr90XVPvEmOMGZ3mfhhS//0V8+6fw80iniiXmogRFVvAqfFYyI18QZxXK1euFMExf/75p+jMo06/9u3bIzIyEl5eXi8sT9ehPj4+Im/+e++9l6d1UmotulFQjK+vL27evInRo0eL19asWZNhXTSzjvL0axUrVswIR4ExVhBSD34Pzc1/IStWHg5dfhUVi7U2X1iHm4+vo1yxCuhWqzeMTSZpe9BYjtA0Zzc3NzFaw1OPGSt46lvHkLz2TSDxEeSl6gA95uDjQ98h6ukd9At4Q4yesMLHbR9jxhfz/D4+3f4B4pKeoFutXhhUN20GBjMdbvsYMy71ndNIPToTmit7cNDFAwvcK8JJpsD3bb+Gd6mCT8hfkKgTr379+vj99991KbYodz1F+n3yySfZfpYiBWmmHN3yu87Vq1dj0KBBIqBGqUyLAaLIwfXr1+tm3eUWt32MFR5V5HYxg45mzzkO2Qy5Xtt3N+4OPtwyDipJjW86/IiqntWNvj/Gm8jMGGO5pApdjuTlfUUHoaJmNzi8sR7/XNklOgipQexeCCMnjDFmCvEpzzFt31TRQdiwfBMMCBzCPwRjzCpRjIr6+mEkLeuN5CVdRAfhzSJeWJo+TXhci4lm30GYkpKC4OBgtG3bVvcazZSj58eOHSvUdWqDV7QdhFpjx44VRUUbNGiABQsW6GbXMcbMh+bRdaRsGS8e23eYlqGDUCNpMOf4b0jVpKJjjS6F0kFotOnGjDGW2xwMqXuninLvhBK1Kl+ZgLB757Dt4ibYKxwwtsl7UMgVfGAZY1aHcs38dHAa7sTdEieA4175wKgJqRljzGSdg1d2Q/XvTGiiQtJedCmB5KDh+D3mHFLjY8RUuvrlGpn9D/Tw4UOo1WpdOi0tek459gtrnfSZr7766oWCnF9++SVat24NZ2dn7Nq1C2+//TaeP38u8hcakpycLG76kYSMMeOSUhOQvO5NIPkZFP4DoPTvn+H9PZd3ICLmAryKlEQ//zdQWLiTkDFmUlJSHJLXvwXN9YOAnRPsu/4OZfWOiE+Jx6yjaQmdB9UdijJuGXONMsaYtVw0zzvxB87fO4sSLiXxUctJcFA6wNpQIv4ff/xR5Kr29/fHb7/9JqJbskruT3mtKaKG8m3NmDHjhSl5hw4dEuujZaKjow1Oqxs6dKjIR62PcntRTmvGWOGRNGqoL25B6tFfIcWEi9dkrqWhbDQW8jp9MfPIdMTEx6BWyTroH1B4F8KWjjryqCgn5Sakwp/6Pv/8c93jwMBAMRWZ2sysOgkpX//UqVNfeD02NlZEODLGCpgkwf7AJChjwqHxrImEoPfx7OFD3duPEx9h6ekF4nG/moPxPO456H/5RdHFL8OdhIwxk9HEXk0rUPLoKmSuZeDQZxHkJdMKFi08NRexCQ9Qu1QA2lfvxL8SY8wqbQhbjX1XdsHZzgWftvkCxZyKw9oYI7k/XfBSZ+Pw4cPRs2fPLLdNSfspeb+Wg4P1dcAyZq4kdSrUYWuReux3ca5HZO4+sGs8Dgq/npAp7LH23AqE3D2F4k7umNDsQ4uZNUIX2gqFAvfv38/wOj0vVaqU0df57Nkz0b4VLVpUDJLY2dllu25qeynikKIFDbWDEydOFO20fgck5UL08PDgPPyMGYHqzFKkXN4EOLrB+fVFKFKsTIYB5PkH/kCSOgktK7dFsxotUJi4k5AxZhLqaweQvGE0kBQHedn6cOi1ADKXtJGNk7eO4eC1veKi+e0m43naHWP/b+8+wJsqvz+Af7O7J5TZMsoqexYoewsoIKgMFUQcICBLXH/HD/dkiCwVAQdbNsgQGULZG8re0EL3bjPv/zlvmtDSFApdaXI+z1OT3NzcpAl9zT3vec9hDmnvtd1YfPw30bn9rQ7vo7KddvAsqKlTp+LVV1/F8OHmRiwULNy4caOokWWrED8V7acfkleh/p49e4qfh6GT4cc9YWeMPR5JnwHDiaUw7J8FKfm22CYLqAtV2JtQ1HkSsqxA4InIY1h24k8xBk5q/16pmiRRq9Vo1qwZtm/fbs1ipiYjdHvMmDFFekwK4NFEC41v69atg4uLy0OPffz4cfj6+uY5UULbeRKFseJhjDwO3dYPzH97fX6E3Ccox/3h1//DkVsH4e3ig6HNRhT7x8IFbxhjxYpmRvSHfoF22fMiQKhoOAiaISusAcKkjETM22/u6PZy6Oso416WP6GHoCUm1MUu+0+dOnWs92dmZori1TQb7OHhgQEDBuSapWaMFa/z0Wcxa+80cf31VmPQoEIjh/wIiqK4/6PYuXOnyFasXbs2Ro0aJZbOPQhl2dAJePYfxlj+SNpU6PfNQsbsltBvfV8ECOUVm0L97CK4jPgHyrp9rQHCmLRozNjzLSRI4iS4dkBIqXubKfPu559/FmUNzp49K8YYynK2TIgMHTpUZOhlHw8pWEc/dP327dvi+qVLl/J9TBqTunfvLrbNnz9f3KYyDvRD9QzJ+vXr8csvv+D06dPi2HPmzMEXX3whOiQzxkqWlB4PHdUhNOpEDX5FjXvfj0iKNhm/Hpwnro8IHQlPjWexv0bOJGSMFRvJqINuy/swHv8TkMmh6vo/KFu8JoJa4n5JEgHCZG2S6O7Zvlon/nTyqV69evjnn3+st7N3uKPlepS1s2LFCnh7e4vZaFqet3fvXn5/GSsBd1Ki8PXOT0W3uv71B6JTjW4O+zkURXH//KKleDTWVatWDZcvX8b7778vsg8pOElL+mzhulyMPYbMJKhO/wnlmT8h05oD68aKodA3eRWmii0B+p6XLUCvN+ox9cCX4mS4WYVQtCjTWowVxSk/dbkeZuDAgYiJiRE1VClI17hxY1Hz1DLe3bhxQ0yKWERGRor6gBbfffed+OnQoYOY0MjPMY8ePYoDBw6I6zVq1Mjxeq5evYqqVauKpcdUB5a+/9F3a9rPktHNGCvZ+qzadaPNEyhV20PV7q1c+yw6PF+cC7eo3AqtgtqUyOvkICFjrFhIabHQrnoVppv7AY0nNP3mQhHcOcc+u678i0O39ovU6ldbjrYGD9nDUVDQ1pK6pKQkMdO8ePFi0eWOUH2ukJAQ7N+/H61a2X8HQcYcSYo2BV/+O0WcHLep2gGDGr9Q0i/JYQ0aNMh6vUGDBmjYsCGCg4PFyXiXLl1sPobrcjGWf1JqNPQH58FwdBGgSxPb5DW6QhU2DorKzfN83C8H5uBa0hVU8g7EuA6T4apyLbVvO0285rW82BL4s6AAHgXtCnLMjh07PvQYNEFCP4wx+2LYOx2mKzsh86wITd9Z1sxqixORR0XJLVeVG0a0HFli58IcJGSMFTlT9Flzg5Kkm5D5VjM3KClTK8c+ManR+PWQObX69VZj4e3izZ/MI7h48SIqVqwo6tK0bt1aZMMEBQWJZX56vT7HUj9aikz3UTYNBwkZKz6UPfPtzs8RmXwLtcvWFTVXHX0ypCiK+z8uaoZCr4eW3+UVJOS6XIw9nCnpFgz7Z8NwYglgyKSKg1DUeQqqNm9aG9DlZfeVHdhyYSNclK6Y3OH9Uh0gZIyx/DJe/hf6/74H5Cqo+/9sLbVlkaHPwLz9s8T1F5sOh79bwbOdHxcHCRljRcpwYTN068aIGWZ51XbQPD0PsvsKU5skE2aFT0eGPh2dgruhRWBL/lQeAXWsW7hwoai5FRUVhSlTpqBdu3aiFg0tVaFC2D4+PjkeQ8tW6L4H1eWiHwuuy8VYwVDmx9z9P+Bs9GmU86yAtzv+H9QKtcO/rUVR3P9x3bp1S9QkrFChQrE+L2OOwhR3WXQqNp5eCZgMgFwJRcOBULUeA7l/zqWvtlxPuGatO02TJJRJyBhjjs6UdBNaOh+GBFW3T6Co1DTXPsuO/4GYtLsICaiPLjV7oCRxkJAxVmQnxIZ9M6Hf+ZUYEJXNXhY1CGUKVa59N5/bgDN3T6KsewBeas71Uh5V9g6ftJyOgoZVqlTB8uXL4er6eDP0XJeLscK18eJakUFDXdtHNRkHXaoesanFW4OrqOpyPQwV4h82bBiaN2+O0NBQTJ8+PVdx/0qVKolxh1BB/4iICOt1S3F/arxkqcGVmpqao9g/1eKiffz8/ESmNN1PEybUqIkyFqkm4dtvvy0eT11BGWP5Z4qOgH7vDzCeW09FtQCFBsqmL0DZ6g3IffIX6EvTpeH7XV9AZ9Sid0hftK7Slj8CxpjDkwxa6Fa9CmQkQFGvP5RNh+Xa52LMeWw6tw4quQojW4+FXFay/YU5SMgYK3SSPgO6TZNgPLNazDKrun8OVdOhNve9nXQTfxxbKK6PDhsPN7UbfyIFRFmDtWrVEifQ3bp1EyfZiYmJObIJH7bUj+tyMVZ4KDi44dJqKOVKvNPpQ9R9yHK8x2WKvyKW/0lJtyDzrgxlo8GQ+1VHSSuK4v6HDx9Gp06dcgQiCQUjKbOaljifPHlSdAil8Y/KMVBH0E8//VQsKWaMPZzx9hEYwn+A8eJW8waVmzjBVbV8HTKPnM2IHjZxPDt8OqJSIkWphReamicIGGPM0em3fQhT1AnIytSGuue3ucrMUCmaOft/EJ3en200BBW9KqGkcZCQMVaoTCl3oFs5HKao44CrLzT9f4GiSpjNfQ0mA2bunQq9USdmleuVb8ifRiGgDBrKmnnxxRfFMj/qckdL+yijhpw/f16clFPtwrxwXS7GCkfE3dOYvW+GuP5G63FFFiA0nFgqJmeoNhhlb9Ml1QxT954KZcOBcLTi/g8r3k9Z1Fu2bHnMV8uY86K/K9P1vdDvnQHT9T3mjS7eUDYfAVXzEZC5+T3yMddFrMLBm/tEY7qJ7d8REyaMMeboDCeXw3Dsd0DtAc2AXyCzkQyz5sxK3Ey8jqq+1fFU3adhD3iEZowVGmPUcehWDIeUekfMlmieXQS5b5U89199egUux10UNWkGN7adacge7q233sJTTz0llhhTBs7HH38ssmgGDx4Mb29vjBgxQmTZ0DI8Ly8vjB07VgQIuWkJY0XrdtItfLPzMxhNBjzX6Hm0q34v862wMwhFgJCWAd5Ht3Ei5JVDIferViTPzRhzoODgpX+gD58B0+0j5o1uZUTWIGUPyjSej3XcM3dO4s9ji8TyuQnt34Gfm3/hvnDGGLNDprtnoNv8jriufnKazbqtNxNv4K9Ty8T4OKr1m3YzgWIfr4IxVuoZzqyBbuME0eVOXqObua37A75QXo67hL9OLoVCpsDYNpOgUfLyr4IU46eAIBXkL1u2LNq2bYv9+/eL62TatGliKR9lElIzEqrHNXv27Md+PsbYwyVnJuHLHVOQpktF++qd8EyDQUX2tokOoyKD0BYZDCcWQ93p/4rs+RljpZdkMsJ4biP04T9Aij4jtsm8KkLZ8g0oGw+BrADdh+PT4zDtv28gSSY833Q46pVrUIivnDHG7JOUmQTtqlfEebGy5Ugo6zyZax+jySga2tFEct96A1A9H82figsHCRljBUJf/PS7v4Vh73TzoNJ6DFQd3oVMrsjzMVqDFjP3fg+jZBTZNcF2NCiWRkuXLn3g/S4uLpg1a5b4YYwVPZ1Rh292fo67KVFiefHIVm/mqkFTmKT4qzazCLPuFTUKGWMsx8hg1MN4ZhX04TMhxV8W22S+1aAKGwtF/QGQFbD7OpWUmbr7ayRlJqJlUBj61O3PHwBjzCmysnUbxkFKuAZ5YEuoOr5vc7+tFzbhQsw5lPesgGcbDoE94SAhY+yxSbo06NaNhfHC36LTnbr3d1DWf+ahj1t6/HfRsCTYvyaerv8sfwKMMYdhkkyiQP/5mAhU9KqMtzr8H1Q2uroXBsmog+Ho7zBe3p5Vh9AWmWhiwhhjYtwwZIoapob9s6wTCLKyIVCFvQlFyFMPnOR9FH8cXSDGwQqeFTGq9bginShhjDF7Ydg/G8YLWwD3AGiengeZje+AManRogwDGdlqrN2tqOMgIWPssZiSbkK74iVI0RHmQfCZBVBUapqv2jQbz66FSqHGmDYT7ab2AmOMFYZlx//E3mu74anxwnudP4bnY9bxetgstfHcBuh3fiFmqh+yN5SN7GuGmjFWMhO7hqO/QX9gLpAWLbbJKzaBMmwcFDW7QSa712G8oMKv/Se+66kVGkzq8D7c1e6FdmzGGLNXxuvh4rs/nxLsAACJfElEQVQZZAponp5rsws8fYf76cAsaA2Z6FKjh1027uSzc8bYIzPePADtXyOA9DjIyjeA5pmFkHtVfOjj0nXpmBU+XbR4f77JMFT2DuR3nzHmMHZc2oZVp5dBJVfhnY4fiiUkhc14Yx/0/34KU+QxcVteoTFUnT+ElHRTNCnJ3t2YLqm7MTctYcx5SRmJMBz+FfrDvwAZCWKbPCgMqjbjIK/artAz/G4l3cScfT+I6yNbjUEV36qFenzGGLNHppQoaFe/Lsq/qLp8DEVQa5v7/Xd1J45HHoGvqx9ebDYc9oiDhIyxR2I4vhi6ze8CJj0UIX1EtyaZKnc7d1sWHv4ZMWnRqFeuIXrWeYrfecaYwzgVdQLz9v8oro9uMwG1A0IK9fim2AvQ7/gCxotbxG2ZTxVR50YsD8w6yacuxtSkhJYQ0hJjyiDkACFjzklKjYH+4DwYji4EdGlimzy4iwgOKiq3KJLnzNBn4LtdXyDTkIEetXoXWUd3xhiztxqvOgoQpsdCUbsXlKGv29wvKTNJnA+TV0JHwV3tAXvEQULGWL5IJgP02z+B4ZB5YFO1nwxlmwn5noE+fPMAdlzeBleVG0a3GS9avTPGmCO4mXhDnBhTM6YhjYeiTdX2hXZsU8od6P/7DkbqYEzNSVx9oWo7EcqmQ3M1FqCAIHcxZsw5mOKviM7m9yYFBkPuVx2mpFsw7J8jJgyosyZlFSvqPCUaksjLF113YVpCN3ffD6LmdM0ytTGs+StF9lyMMWZP9LTC49YhyPyqQ/3k9DzPjxcc+gkp2mS0CmqD0DwyDe0BBwkZY/lr475mJExXdgIqV6if+sFmK/e80KzJ3P0zxfXhLV5DWfcAftcZYw4hMSMBX/47Ben6NHSu0R39CqkZk6RNhX7/bBgOzgX0GYDSBcrQ16BqNRoyF69CeQ7GWOlEjUd0myblKC9AxfJllVtAun0EMBlETSxFg+egaj0G8jI1i/w1/X1uPcKv/yfqsU5s/26RNWxijDF7YohYZ06iUblC038+ZHnUoj5y6xD2XtslsgdfDh0Je8ZBQsbYQ2eqtcuHQoq/DJlXRWieXQR5ufqPNLP884FZSMpMRIvKrdCxehd+xxljDoGKTn+941PEpN1Fg/KN8GrLNwpc34uWrBiO/QH9nu9F3VeRBdRoMFTt3spX7VfGmON/LxMBQsosvo908wAgV0PZdBiUrUZD7lM8tZ/PRUfgtyPzqZc6xrWdjDLuZYvleRljrCSZYi9At4nqQQPqnt9CHlAnz7r8dD5MhjUbAV9XX9gzDhIyxvJkvLrLXIA1Mwnyyi3MsyMej/bFj4qzHrgRDi+NN15vNabQC2QzxlhJMEkmzNw7FZfiLqCydxAmdXivQN3aRcfi8xuh3/klpPgr1vphtHxYXsj1DRljpRctMTZnENoig7LJC1D3+LxYs6mn7v5KlFsY1PhFNKrYpNiemzHGSrJjvPavV0TNV2XTl6CsPyDPfRcfW4S49Fg0KN8YHYO7wt5xkJAxZvNkVXTC++djSmuBouFAqJ/4GjKl5pHerdi0GMynpXIAXms1Gt6uPvxuM8Ycwp9HF4oJEG8XH7zX+eMCFZ+mjvGing0tE6TgYPmGUHX+CIqqbQrxFTPGHAHVIDQvMbZBJoOUEV9sr8VoMmL6f98iISMeTSu1wNOFVG6BMcbs/VxZt+ktSHEXIa/YFKqu/8tz37PRZ7DlwkZoFJpSkzDDQULGWA6SUQfdlvdhPP4nIJOLFu7UoelRBzTKspkdPkPU6epQvQtaBoXxO80YcwjbLvyNdRGroFZo8E6nDxHgUe6xjmOKvQj9zi9gvLBZ3Jb5BEHV4T0o6vaBjJs7McZsUbvbXGpsJhNNTIrLkuO/48zdk2IMHNtmEjelY4w5BcPh+TBGrBHN5NT9f8ozkUZn1GHuPnNd/oGNX0A5z/IoDThIyBizktLjRNq06eZ+QOMJTb85UAQ/Xg3BrRc24dSd4/B3KyualTDGmCM4HnkEvxycI2pvvdl2kuji+aik1GjRsdhwfLHI1hYdi9uMF3XEHjVjmzHmPEx3T8N4buMD9pCgbDSkWF7LwRv7sPbMSqjkKrzV4X14aB4/m5oxxkoL461D0G+fIiZl6FxZ7lUpz33/OrkMkcm3EOxfE73q9EFpwUFCxphgij4H7cphkBJvQOZb1dygpEytx3p3IpNv4/cjC8T10WHj4E6z3owxVspdT7gmam9RpvTQZi8/coY01a/R758Dw4E5gD7d3LG4xSjRfVTm4l1kr5sx5hgnptplLwDaZMgqNIZ052SO7sZ0qe49FXK/akX+WqKSI/Fj+DRx/ZWWo1DNL7jIn5MxxkqalBYL3arXRAd5Vfu3oajWIc99rydcFRMpCpkCo1q/CYVcgdJCXtIvgDFW8gwXtiDztydFgFBepS1cXtr02AFCqk/z496p0Bm16FnnKTSo0LjQXy9jjBW3hPR4fPnvFGToM9CtVk88GfL0I3Us1h9dhIw5rWGgrsX6DFHr1WXkHtGYhAOEjLEHMV7dDe2SgSJAqGg8BC7DNsDl9T1QthoFRUgfcSluNxxYLF3dv9/9BTL06ehSozs61+ju1B/erFmzULVqVbi4uKBly5Y4ePBgnvueOXMGAwYMEPtTGZ/p06c/1jEzMzMxevRo+Pv7w8PDQxzz7t27Ofa5ceMGevfuDTc3NwQEBGDy5MkwGAyF9Fsz5nwkkwHaNSMhpd4RjeWUbcY98Hx4zr4fREOnfvWfQRXfop+8KUwcJGTMyYuu6sNnQrdyuLkzU7Ph0AxaDFkB2rKvObMSF2PPo6JXZTzfZFihvl7GGCsJmfpMfLXjE8Slx6BxxWYY0WJkvuq0iiZQ5zch8+dO0G9+F0iLgbx6J7i88g80T05/4BIVxhgjhvN/Q7v8RTG5QDWi1T2/g0yuEBmDNMlAy91EF/RiyCCkMe2nA7NEVjVlD74cOtKpP6Rly5Zh4sSJ+Pjjj3H06FE0atQIPXr0QHR0tM3909PTUb16dXz11VcoX778Yx9zwoQJWL9+PVasWIFdu3YhMjIS/fv3t95vNBpFgFCn0yE8PByLFi3CwoUL8dFHHxXBu8CYc9Dv/gam63sh8w6Eps/MB9aO3nRuLS7HXUQlr8oY0GAQShuZRKM9y7fk5GR4e3sjKSkJXl5e/M6xUksyZEK3cRKMZ1YBciVU3T+DqmnBgnpX4y/jvU0TIUHCZ098+1i1uph94rGPOSuaDf5u1xc4fOsAqvhWxSfdv4Gb2i1/NWuoY/GtQ+K2rFx9qDt/CEW19sXwqllh4bGPlSTD6ZXQrR8vapeq2k2Gsu2EEu2MSfWmfz4wW3Rz/7rX9FJThL+oUJZfixYt8OOPP4rbJpMJgYGBGDt2LN59990HPpYyBcePHy9+HuWYdA5atmxZLF68GM8884zY59y5cwgJCcG+ffvQqlUr/P3333jyySdF8LBcOXNjrblz5+Kdd95BTEwM1Gr1Q383HvsYy7nqTrfyJUChgcuwdZCXb4i83EmJwqT1Y6A36vBJj69RJ6AuShvOJGTMCUmpd6H9o785QOjqC82gpQUOEFL3ppl7p4q06v4NBnKAkDHmEH4/8qsIEPq6+uHdTh8/NEBoirsM7V8joP2tjwgQUqdRdd9ZcHl5CwcIGWP5pj+yELp1Y80Bwq5ToGo3sUQDhLRKZMGhn8R1atrk7AFCytI7cuQIunbtat0ml8vFbQrWFdUx6X69Xp9jnzp16iAoKMi6D102aNDAGiAklI1IgT9a8myLVqsV92f/YYwBpvir0K1/U7wV6h5fPDBASPl38/bPFGW3utfuVSoDhIQblzDmZExRJ6BdORxSShRkZWqZG5T4Vi3wcZcd/wM3E6+L5ScDGhR9TRzGGCtqf59bj43n1kKj0ODdTh+hjHvZPPeVUmOg3/M9DMf+MHcsdvGBqs04UcaBOxaba2x9++23uHPnjlg+N3PmTISGhtp8L+kklpbF0cnw9evXMW3atFzZNrt37xbHo32ioqKwevVq9OvXL+dnIkliyd7PP/+MxMREtGnTBnPmzEHNmjUL6V8IY0WDSsHod34ByORQ9/oOykaDS/StTs5MEk2bDCaDWDrXtFILOLvY2FixrDd7II7QbcrsK6pj0hhKmYA+Pj659qH7LPvYOoblPlu+/PJLTJlCHVtziouLE8FLxpySIQMua16CXJsMQ+2nkV65O/2h5rl7+M3dOH3nJHxd/PBE0JPib9relClT5qH7cJCQMSdiiFgL3YbxgCET8hrdoOk7CzKNZ4GPe/buaayPWA2VXIWxbSZCKeehhTFWuh25dRALDv8MGWQY3+5tVPevkWfHYsOBedAfmC1qu9JSFGWL16FqPRYy15wncc7KUmOLlrvRUjoq1k9ZLefPnxcF9fOq2/Xss8+K2lu2pKWliWDjyy+/nKMWV3bffPMNfvjhB1GPq1q1avjwww/F80ZERIiGAIzZZa3onV/AsO9HQK4SWcjKkKdKvOTCD3u+Q2xaDBpVaIJnG5ZswJIVjffee0+M0xaUSUjLnKk5CpfYYs46Hus2jIcx/oIoGePZ53vIVK4PbHC36sIycX1k2FhULh+I0kpuD52eCBVepVRp2p/Sozdt2pTrQ6JZ5QoVKsDV1VWkWF+8eNF6/7Vr1zBixAjxJZDuDw4OFrPH9898nDx5Eu3atRPPQwMffYFkzNFJkgm6Xd9At2akCBAqW42G5pkFhRIgpO52P4ZPE3UIBzcZikCfKoXymhljrKRQfdVp/30jxs6Xmr+K5oEtbXa5Mxz7HRlzwqD/71tAlw5Fg2fNHYs7f8gBwmymTp2KV199FcOHD0fdunVFsJA6bv76668233+qx0VZgoMGDYJGo7G5T8+ePfHZZ5/h6adtd5mm740UjPzggw/Qt29fNGzYEL/99puo0bVmzZrH+4fBWBGi8Ua/5T1zgFDpAs2zC0o8QEhWnlqKE1HH4O9WFm+2fQsKuaKkX5LdZOMoFIpcXYXpdl5NSQrjmHRJ57eUHf2gfWwdw3KfLTTWUjAw+w9jzsx4/E8YTy0HXLyh6f/LAwOEZP6huUjTpaFt1Q6lPttabg+dnqjr0uDBg0WQ79ixY2K5CP2cPn0612wwfbE8cOAA3N3dxTGpBTyhFGwq7Dpv3jyxTIWWptC+77//fo4Zke7du6NKlSpieQp9Af3f//6Hn34y19dgzBFRlovur1dg2DsNUKihfmoG1J0/EJ3xCsOiw/MRnXoXdcvVR++QvoVyTMYYKylxabH48t8p0Boy0bPOU+gV0id3x+ILm0XHYt3fbwNp0ZBX6wCXEVuheeoHyL0rl9hrd5a6Xflx9epVsawu+/NS4zmauH7Q83JdLlYSJKNe1B80HF0EqD2gGbQYiuAuJf5hHL19CCtPLhErRCZ1eBdeLt4l/ZLsBi35bdasGbZv327dRueidLt169ZFdky6X6VS5diHsrJv3Lhh3YcuT506lePce9u2bSLwRxM1jLEHM0Ydh27r/5n/Lum7ne+Dk2AO3AgXP54aL7zU4rVS//Yqi3rGmFCwbuPGjWLG2FanpxkzZuCJJ57A5MmTxe1PP/1UDGTU1Ykee/9sMKHZYKqtQLPBNNNMj6cfC1qmQgMm1Z757rvvxLY///xTfFml10GDcL169XD8+HHxel97rfR/mIzdz5R0E9oVwyFFnwHcy0Iz4FcoKjcv1C+P2y9tgYvSFaPDJkD+gFbwjDFm7ygz+ssdU5CQEY9mlUMxrNkrOe433j4C/fZPYLp1MFvH4g+gqNahhF6xc9btyg9L3S1bz5tXTS7CdblYsTNood4+GcrrOyBpfKDtNRfpbjUfWPeqOMSmx2BGuPkc6tmQIfCFv13W1yrKulwPQ0kxw4YNQ/PmzUWNVTpfpVIIlnPgoUOHolKlSmJcIXQeSuUOLNdv374tzkU9PDxQo0aNfB2TJjsosYb28/PzE4E/6nxMgUHqbEwoKYaCgS+++KJItKExj86jR48enWd2NmPMTMpIgG7Vq4BRB2XYm1DW7P7AtyZNl4r5B+eK68ObvwpvB5hMURbVjDHVNcjvjDFtz14DgVCWoGU5yMNmgylIaAu1iKfBM/vztG/fPkfbd3qer7/+GgkJCfD19S3Ab86YfTHePCg6bCI9VpzIap5dCLlXpUI7foo2GXP2/SCu03K8AI+cJ2KMMVaaUN0tWmJ8PeGqaMA0ru1k67I6U/wV6Hd+CeO5DeK2zKsSVB3fhaJef8h4csShcF0uVtyrPbQr34Dp+n+QeZSDy+BlcC9bu8Q/BJ1Rh28OfIp0fRraV++Ep5s8W6Kdle3VwIEDERMTI0pi0blq48aNsXnzZuvkBGX30XmwBZU7aNKkifU2JbLQT4cOHbBz5858HZPQijk67oABA0T2M53Pzp4923o/LVnesGEDRo0aJYKHtAKPAo+ffPJJMb0zjJXesg/adWMgJd2CvGo7qNq//dDH/H7kVzG53KRiM7St1hGOQGkPM8Z5dWDK3qHJsi2vfe536dIl0TnPkkVoOQ7VLLz/GJb7bAUJaeClHwtuB8/sFZ3EGk4sEYOapE2B6couQDJAUecpqJ+cDpnardCei7J7fz4wG4kZCWhWqQU61+hWaMdmjLHiRmPagkM/4djtw/B3KyM6GbuqXCGlxUK/ZxoMx34DTAZRl0YVNg7K5tSxmBtflFTdrvywHJueh+pZZ39eOunOC2XZcKYNKw5SRiK0y1+E6fZhyHyCoBm8/KFL2orLrwfnidqsQT5V8VrL0RwgfIAxY8aIH1ssgT8LqtdP/78pyDEJ1dan+v/0kxcqr3V/jX/G2IMZ9kyH6fK/kHlWhKbv7IeW56JOxtsvbRWr6l5t5ThjpUO2IKXUbVp6TF3xaNlzQfCyE1YaKM6vhnr3/yi/harpQwbzFxBDlc5Ib/c5kJxO/SIL7fkORe7Hvut74K7ywLO1n0dcXBxKu8JYdsIYK502nl2LLRc2ii95FCD0VbqK4KB+/6ysjsVqKFuOgiqMOhbzqoPHrbFF9aaz19h60ElwQdGkMAUK6XksQUGa6KW61pRdw1hJklJjkLl0sCgHI/OvCc2QZZB73gtml6Qdl7aJUjKuKje81eE9aHhChDHmBIxXdkD/33fmzvL9f4LM/cHnhlS7eu7+meL6kCZDUdY9AI5CaQ8zxnl1YMreoSm/s8GUxt2pUyeEhYXlakjyOJ2eeNkJKw0ZhJkUIJRMue5T3tgJD0Uq5H45M2gLIi49FsvO/i6uj2w9FsGVzDVUGGOsNDp4Yx9+OzJf1FSd2G4yKt/Yh8zd30JKNX8/UNQfAFX7dyD3CSzpl1pqFUXdrtTUVLFqxIJK09A+VGYmKChIzOaPHz9edECuWbOmCBp++OGHqFixojVYyVhJMCXdgnbJIEjxlyEv31A0KZG5+dvFh0HZgz8fnCOujwmbgAqFWKaGMcbsuo7/2tE0hQNV1/9BUanZQx+z/MRi3E2JQu2yIehRuzccidweOj3R9uz7E2pcYtk/+2ywhWU2OPsx6Utkx44dxfMvWLAgRw0Iy/Ps3r0ber0+x/PUrl07z3qE3A6e2TtaYiwyCG2SwXBicaE9Fy2RoDqE1N69XbVOaFWlTaEdmzHGitvluIuYsec7SJDwUpX2qLNpMnSb3hIBQqpF4/LyFmj6/MgBwgKiGltU/oVqbNHkLgXz7q/bFRUVlatuF/3QdnosXX/llXuNZA4fPmzdxxKIpOv0HBZvv/22KOhPzelatGghAov0vLRUj7GSYIq7DO3vfc0BwsCW0AxZYTcBwlRtKr7b9QX0Rh361huA0KDH69DLGGOliWTQQrfqNSAjAYq6T0PZzDyB+SCX4y5h/dk1ovP7yNZvOlzzTpmUn8IIj2jZsmVixnjevHnWGePly5eLmoT0hfD+GePw8HBRsPWrr75C7969sXTpUnzxxRc4evQo6tevL/ah5iJ0/6JFi6yzwSdPnhQzzfRlzxIgpPoLtA9lM1pYsgSpkQkFBKnj0zvvvIPTp0/j5ZdfFsVf89vdmIKT1DSFjkXdpBgraZnLnhe1E2ySyaEI6QNNP/OscEFtvbBJ1CL0c/PH1KdmwV3tUSjHZfaPxz7maGJSo/He3xORlJmInpBj0M1DYrssoK7oWCyv1tFhasuwx8djHysspugIZC4eKBrKyat3gmbAL5CpCq9edEGYJBO+2fEpjtw+hHrlGuDDrp9ZGzcx58RjH3MWus3vwnB0EWRlasHlpU2Qqd0fuL/BZMC7myaIRncDGz2PZxoOhqNR2kOnJ1oavHjxYtGa/f333xfLQqizsSVAaJkNpqUpFMxLTExE27Ztc8wGU0YgLTuhn8qVK+d4PZY4KAX3tm7dKtq/U7YhLY2m15jfACFj9sZ48wBM1/Y+YA8ZZN45/x4eV1RyJH47PF9cf6P1eA4QMsZKLcqG/uKf/xMBwmbpCXgu7gpkXhWh6vAOFPUGPLRQNWOMPQrj7SPQLnseyEwyN5Tr+yNkCrXdvIlrTq8UAUJfVz+Mb/c2BwgZY07BcGqFCBBC7Q5N/18eGiAk68+sEgHCQJ8q6FvvGTiiIskkdGQ8q8LsheH8JuiodoIhM++dZHK4vL6nwDUJjSYjPtr6Di7EnBM1F14J5aLvzobHPuYo9Cl38MWmCTitS0E1bRreS4qCR9hYKJu/DJnKtaRfHrMzPPaxgjJe2wPtimGAPh2KhoOg7vWdXU1EnIw6js+2fwQ5ZPhf9y9RJ6BuSb8kZgd47GOOzhR9FpkLe4lzafXTP0EZ8tRDH3M76RYmbxgLg2TE5098i5plasMROWR3Y8Ycnf7IQui3vC+KqyrD3oTMtxr0myZl1SaUrJfq3lMLpWnJuohVIkBYwbMiXmjy8DoNjDFmbyR9OvQHfsJPZ1bitJsPyhh0eCuwNXyGvAWZm19JvzzGmAMyXNgC3erXAaMWyhavQNV1CmR2VLsqNi0G0//7BpJkwovNX+UAIWPMKUiZydD+NUIECJWhr+UrQGiSTJi3fyb0Jj16h/R12AAh4SAhY6UIJf7qd30JQzi1W5dB1eNLqJq9JO5TBLYUTUqkpFtiibGy0ZBCCRBei7+CZSf+FF9qx7SZCBcVF3xnjJUekskI46nl0O/6BhtkEnb5VIYrZHi36ycICGxV0i+PMeagDGdWQbfuTUAyQtl2IlTt3rKrOqd6ox5Td3+FFG0ywqq0Q686fUr6JTHGWLGcT+s2jIOUcBXyyqFQdfogX4/75+JmnI0+gwCPchjU6EU4Mg4SMlZKSEY9dJsmwXhqBaB0gbrvLChr97LeTwFBdaf/K/QvkD+GT4XRZMDT9Z9DrbJ1CvX4jDFWlF8CqamT7t9PIcWex0FXHywvEwyFTI63unyCKhUa85vPGCsS+qOLoN/8nljVoeryMVQtR9rdO73oyC+4GHselbwDRXdOewpgMsZYUTEcmAPjhc2Ae1mon54HmUL10MfEpcXij6MLxPXXW411+KQZDhIyVgpI2lRoV78K05WdgIsPNM8ugiIwtMifd/mJP3E94Rqq+FbDsw7YuYkxVvqZ4q/AcGJJtizqwZC0ydBv/xSmG+Fin0sBdfGTi4fI6Hm15Rg0dNAAoSEqCmk7d8AYEwNF2bJw79gJygoVSvplMeZU9Pt+hH7H52LFB9UfVDZ+Hvbmvys7sOX8RmiULnirw/tw5XqsjDEnYLwebh6fZQpo+s2F3LN8viadfz44Gxn6DHQM7uqw3yGz4yAhY3ZOSo2BdvkLMN05CZlXJWgGLYa8TK0if95z0RFYG7EKSrkSY9tMgiofsyyMMVacDCeWigzr7PVYDft+tN4v86yA+FZvYMbVHdBrk/B0/WfRpWZ3h/yQKDiYOG8eQNlA1JNOJkPqunXweX0k3Dt2LOmXx5iTlIT5CobwHwC5Euo+P0JZty/szY2Ea5i33zxOvtF6HCp7B5b0S2KMsSJnSrkD7ZqRVIcGqs4fQlElLF+PC7/+H47cOghvFx8MbTYCzsB+KucyxmxmyGT+9qQ5QBhQF5phG4olQEgzJT+GTxOFrAc1fhFVfKvyp8MYs7vxUQQIJZPIELReZlGGjoTh5S34NvIwkrVJaF2lnRjPHDWDUAQIKThoMuW4TJw3F4Y7d0r6JTLm0Oj7kn7rB+YAodIFmmcW2GWAMF2Xju92fQGtUYvedfoirGq7kn5JjDFWPGW7qIlUWgwUtZ6AsuWofD0uRZuMXw/OE9dHhI6Ep8YTzoCDhIzZKWPkMWQuegpS4g3Iq7SBywur85USXRh+P/or7qZEiS53T4b0K5bnZIyxR0FLjM0ZhDbIFDDI5fh+7zTcTr4l6qmODhsPuR11FS1MaTt25H2nTIa0Hf8W58thzKlIJgN0G8bDcORXQO0OzcA/oajRFfaY6Th733REpUSidtm6eKHZ8JJ+SYwxVixoibHp1kHIfKtB/eSMfNdgXXT4FzHR3KJyK7QKagNn4Zjflhkr5YyX/oH2zwFARjwUdZ8WXzhlLl7F8tzHI49g24W/RZ2aMWEToZAriuV5WeH46quvxP/4xo8fb92WmZmJ0aNHw9/fHx4eHhgwYADu3r3Lbzkr1agGocgetHUfJPxy9xTO3D2Jch7l8XbHD6FRauBo9LdvIXnZMqRt2WzOHrRFkkSNQsZY4ZMMWuhWvWZuKufqC82QFflewlbc1kesxoEb4WLJ3MT274hyMowx5ugMZ9fDQNmAlOU94Jd8n1MfjzyCXVf+havKDSNajnSq5k78fwfG7Izh+J/Q/f2OWDanbDlS1EyQFVP2S4o2BbPDZ4jrw5q9gnLFlLnICsehQ4cwb948NGzYMMf2CRMmYOPGjVixYgW8vb0xZswY9O/fH3v37uW3npVaUmZyVh3C3NZ5lsd/hnS4qz3wXuf/wdvFG47CEBuLjPC9yNi7F/rr1x/+AJlMNDFhjBUuSZcO7V/DYbq6G3APgMvgZZAH1LHLt/nM3VP489hC8X1yQru34efmX9IviTHGipwp9iJ0GyeI6+pe30IeUDffpbd+2j9LXH+x6cvwdysDZ8JBQsbsaBmIYc806P/7ViyhU3WdAlXoa8X6GuYfnIuEjHg0qdgMXWv2KNbnZgWTmpqK559/Hj///DM+++wz6/akpCTMnz8fixcvRufOncW2BQsWICQkBPv370erVq34rWeljv7gTzBdsb2Edp+bL1Z5V4BCpsDkDu+jkndllHbG5GRk7N8vAoO68+es2+W+vnALC4OqVm0kTJ9mO5tQkuDeyfy3zxgrHFJmErTLX4Tp1iHIvAOhGbIccjut35yQHo9pu7+GSTLhhaYvoV75nBOJjDHmiCRdGrSrXgF0aVA2HQZl/Wfy/dilx39HTFo06par77AN7x6Eg4SM2Us9m83vwnj8T0ChhvqpmVDW7VOsr2Hvtd3Ye20XPNSeGNV6nFOlVDsCWk7cu3dvdO3aNUeQ8MiRI9Dr9WK7RZ06dRAUFIR9+/ZxkJCVvsmUvdOg3/2tqDuoaDQIRmttQgnn1R74xc98oj6q9Zul+mTYlJGBzMOHkb53D7SnTgFGc1MWmbs7XFu2glubNlCHhEAmN2eaS6+PFE1Ksnc3pkvqbqwsz1nhjBUWKS0WmUsHQ7p7GjL/GtBQBqFXRbt8gw0mA6b+9xWSMhPRIrAV+tQdAEcUGZuCbYevIjohDQG+7ujWvBoqlnGOBgOMMdvfF3WbJkOKvQB5hcYi+Sa/LsScw9/n1kOlUGNkq7EOW8/6QThIyFgJk/Tp0K0ZBePFrYDGS3TEK+56NjTL/MuBOeL6qy3fgK+bX7E+PyuYpUuX4ujRo2K58f3u3LkDtVoNHx+fHNvLlSsn7suLVqsVPxbJybS0k7GS/cKn//dTGGisosmUfnOhrN0Ttxs8i+1H5uNmejzOGLUwQMIzDQejQ3CXUvdxSXo9Mk8cR8aevcg8egSSTie2y9RquLRsCdc2beHSqBFkytxf39w7doSmTh3RpIRqENISY8og5AAhY4XHlBwJ7eLnIMVfhqxcfbgMWgKZu/0uQ/vz6EKci45Aec8KGB02wSEngP85fAU/rDokfjf6/wRd/rX7LN4cEIquzaqV9MtjjJUAw5EFMEasFrVi1f1/hiyfdan1Rj3m7vtB1LZ+ruEQVPCqBGfEQULGSpCUHgft8qEwRR6FzLOCaFAiDwgp3tcgSZiz/wek6lLQpmoHhFVtV6zPzwrm5s2bGDduHLZt2wYXF5dCezu//PJLTJmSe9YtLi4OuqzABWPFxmSEas9nUJ1bCUnpCm336Uj3b4Hw46vxx6lfxUkhLaWzcDW5ITY2tlR8QJLJBOniBRgPH4Hp+DEgI8N8h1wOeb36kDdvDnnDBjBpXJBGnYwTE/M+GAUPu5mXxdC7IfZ8yPtQpoz9BjgYsyem+KvQLnlONE2SVw6F5rnfi62p3OPYd30PNpxdA7VCg7c6vA93tTscMYOQAoSUPE3fZ4nl8oe/DqJulTKcUciYkzHeOgz9P/8Tq0w0fWdB/ghlZ9acWYmbSTdQzS8YT9V9Gs6Kg4SMlRBT4g1oablK/BXIytSCZtBiyEtgtmL7pS04dvswfF39MCJ0ZLE/PysYWk4cHR2Npk2bWrcZjUbs3r0bP/74I7Zs2SKCeomJiTmyCam7cfkHLEF87733MHHixByZhIGBgaJDspeX/Z4UMccjGfXQrR8H47nVgMYTLs/9AffAUEQl3xYBQprttZwUWvxx+le0CG6JCna6BFBkRV6+jPS9e5Gxfx9MCQnW+2gJMS0ldgltCQX/rTFmF0zRZ5G5ZBCQFg15tQ7QPPMrZCo32KvbSTetjehebzUGVXwdM6Nu6+ErkEEm/j9wP9pOS5CHPVG0ZSdmzZqFb7/9VqzOaNSoEWbOnInQ0NA896cmch9++CGuXbuGmjVr4uuvv0avXr1yfD975513sHXrVvHdrX379uKYtC+hx1WrZvvzXL58OZ599llx3VbW6JIlSzBo0KBC+K0Zs99yELrVrwEmPVTtJkNRvVO+H3sz8Qb+OrVMLC+mkjUKuQLOioOEjJUA052TyFz2ApAWA3lgS2ieWQiZa87loMXhbsodLDz8i7hOdQg9NVy/pbTp0qULTlG9smyGDx8u6g7Sl0wK7KlUKmzfvh0DBphrEZ0/fx43btxA69at8zyuRqMRP4yVJMmQCd3qkTBe3AK4+sFl8BLIs+oM/ntpm3V52f1o+7+XtuL5pi/Bnuhv30LG3nBRZ9B49651u6pqVbGU2LV1ayg5s48xu2KMPAbt0iFAZiIUtXtB3Xd2vpeulQTqyvndri+RachA91q90P4RTpJLA73BiDPXYnAg4rYIAppsNWzKQjUKi9KyZcvEhOrcuXPRsmVLTJ8+HT169BDfswICAnLtHx4ejsGDB4vVGk8++aRoKtevXz9RMqZ+/fri/2d0m763rV27VkzKTp06VdSVjoiIgLu7u/heFxUVleO4P/30kwhU9uzZM8d2alT3xBNPWG/fX3qGMUcimYzQrhkFKSUK8uDOULYdn+/HGk1GzN3/A4wmA/rWe0ZkEjozDhIyVsyMV3ZaOy0paveGuu+PkCldiv91mIz4MXwqtIZMdKvVE00qNSv218AKztPTU3yxzI6+RFLGn2X7iBEjxJdYPz8/8YVz7NixIkDInY2Z3XelWzkcpmv/QeZRHpohyyAvU8t6/7WEqzmWGOd4LCC60tkDQ2wsMsL3IiM8HPpr16zbFeXLi4xB17A2UFVyzpo3jNk747W90K4cZv7O1uA5qHt/D5ncfk+fKMg0b/9M3Eq6gRr+tfBS81fhCFIzdDhyPgoHzt7GkfN3kK7V5+tx1MSkKFEA79VXXxWTs4SChRs3bsSvv/6Kd999N9f+M2bMEEG7yZMni9uffvqpKBdDKz/osRcvXsT+/ftx+vRp1KtXT+wzZ84csfKDsgBfeeUVKBSKXCtBVq9ejeeeew4eHh45tlNQ8EGrRhhzJPrd38B0fQ9k3pWh6fMjZI/QcGTrhU2iYUkFz4p4tuFgODv7/b8cYw7IcGoFdBsnAiYDlM1ehqrbJ5CVUCoz1amhYtblPCvgxaYvl8hrYMVj2rRpkMvlIpOQmpHQLPfs2bP57Wd2S8pMgnbZCzDdPgyZTxA0Q1ZA7hNkvf/o7UM4fedEno+nRVZl3XNncRQXY3IyMvbvF8FB3blz1u1yX1+4tg4TwUFV9eoO2USAMUdhuLgVulWvAUYtlM1HmL+z2XmXy83nN2Dvtd3w1HhhYod3oVKoUFrdTUgT2YIHz0bi9NVoGE3mjEEaNkOq+KNlSCVULe+DKYt2i5qE96MlyNTluKhQKRcq+ULlWSzouxZl/e3bt8/mY2h79lIuhL6TrVmzRly3NIzLXmOajkkrO/bs2SOChPej13D8+HGx7Pl+o0ePFo+pXr06Ro4cKYKZ/P8d5qjjtSH8B9HYTtP/F8hcffP92JjUaPx5bJG4/nrrsdDYcaZ4ceEgIWPFNLNr2D8L+h2fi9uqTh9A2eqNEvsf9fWEa1h6/HfxZXdM2AS4qlxL5HWworFz584ct+nLJn15tPUFkjF7rCdDtb+k6DOQ+dc0ZxB6VjDfJ0nYdG4dFh2ZDymPLELLfp1rmBt4FBdTRgYyDx9GevheaE+epOKgYrvM3R2uLVuKwKA6pC5kcvsOMthD3a4zZ87go48+Eie/169fFxMd48ePf+RjduzYEbt27crxmNdff11k7DCWnSn+CgwnloimJJSFInMrC/2OT82Tum3GQ9X+bbsPrpyPOYtFh38RtfjGtX2rRCdKHgeN25duJ4hsQQoOXruTZL1PrVKgeZ3yaBlSES3qVISPx70gGnUxpiYl4vOR7gUIaXvFMkVXRoeaY1EN6HLlyuXYTrfPZZscyo7GKlv703ZCpWKCgoJE4HHevHliZQiNf7du3cq1xNhi/vz5CAkJQVhYWI7tn3zyCTp37gw3NzdR3/CNN95Aamoq3nzzTZvHoQClJUhpqUXNWGlgSrgO3bqx4rq6++eQV2j0SOPOTwdmiZV1XWs+gXrlGhThKy09OEjIWDHUR9Bv+wiGI78CciXUvadC2cBcVLgkUGv3H/dOhSGr5kKdgLol9loYYyw7U3IktIufgxR/GbJy9eEyaAlk7ubuuzRm/XpwLrZd3CwmOF5u8TpclC6Ys+8Hc23CrAxC+sI3KmxcsTQtkfR6ZJ44joy9e5F55AikrM7fMrUaLqGhos6gS6NGkKlKbzZPSdTtSk9PF5kvVIB/woQJBTomLQWkk2ULOmFmLDvDiaXQbZpkGUHMG7MmIVSdP4Kq1Si7f8OSMhIxdfdXMEpGDGr0AhpVvNfMzN7rC568HC0Cg5QxGJeccW+prIdGBARb1a2EhsHl4KK2fdratVk10cWY6hNSDUJaYkwZhEUZICwqVItw1apVokwMlYihpcWUmUi1Bm3V383IyBB1DakRyv2yb2vSpAnS0tLEpEpeQUKqkzhlypRc2+Pi4kTWJGN2yZAJl7UvQa5NhqFWX6RX7kER/Hw//MDtcByPPAJvjQ96VnlKBP8dXZl81L7mICFjRV10f+0YGM9vBNTu0AyYD0W1DiX6nq88uRTXEq4gyKcqBjZ6vkRfC2OMWZgSrkG7+FmRySOv3AKa5/6AzMXcSTtVm4qpu7/EqTsnRObzhHbvWuuo1gmoJ5qUUA1CypyhDMKiDBBKJhN0EREiYzDjwAFIaVmF8RUKaJo0MXcmbt4C8mzLxZzdo9btatGihfghtu5/lGNSUJBrcrEHZRCKAKHNzGQZFLXuNX2wN9ThnRo4RafeFbW04tPj0KRSczzd4DnYs+Q0LQ5n1Rc8duEOMnQG632BAV5iGXHLuhVRq7I/5PL8ZW9SQLCouxjbOtGmIB51I86Obuc15tD2h+3frFkzsXw4KSlJBOfKli0rJkKaN2+e63grV64UkypDhw596OulY1ANRMoWtNWYjrIXsy+FpkxCapJCNa6pnjVj9pj5bYo9DynuHGQB9eDZd+ojdZ1PykzCX+eXiuuvtRqNoApVivBVly4cJGSsiEgZidCufAmmmwcA97JwGfgn5OVLNoWZvkSuPrMCCrkSY9tMLNW1ahhjjsMUcx7aJQMhpd6FvFoHaAb8CpnazXoi/OWOT8RlgEc5vNvpIwT63PsiRwHBou5iTBkc+iuXkb5nLzL274MpIcF6nzokBG5hbeDSsiUUfCJVKHW7CvOYf/75J/744w9xEv7UU0+J7JoHZRPykjvnQiea5gxCG2RyGE4shrrT/8He7Li0zZpFnb2BU5OKzSG3w7qJUXGpYgkxBQYjrsfClFVfUC6ToV61smgVUgmhIRVLVfafWq0WAb3t27eLjsTEZDKJ22PGjLH5GGoaR/dnL59AjUto+/28vb3FJTUzOXz4sAjw2Vpq3KdPHxFIfBgKPPr6+toMEBLantd9jNll5rcY+8xjiaJuv0cKEJIFh35CijYZrYLaIDQo99+gM+MgIWNFwJR0C9plz0OKvQCZXzA0gxbnKLpfEjL1mWKZMdXxGtj4RVT1q16ir4cxxogx6ji0S4cAGQlQ1OoJdb85kGUVjT595yS+2/UF0nSpojTCWx3+D94u5hOn4qC/fQsZe8NF1qAxq2YUUVWtClfqTNw6DMp8LNtwZo9Tt6uwjjlkyBBUqVIFFStWxMmTJ/HOO++I5ci0nC8vvOTOuaijL0MByWaYkOraZUZfRrKdLT+LTrsjAoT0+u5fgrrg0DxUca2GAPecfxvFzSRJuBqVjGOXY3Dsciwi49LuBaNUCjQI9kPj4LJoVL0MPFwtE9ZaxMbeq4lnD0vuHoYy74YNGyay/KgeKpU9oGW9lgxnyvCrVKmSGFfIuHHj0KFDB3z//ffo3bs3li5dKgKAP/30k/WYK1asEEE/qk146tQp8RgKQnbvnrPO7qVLl7B7925s2rQp1+tav369yFBs1aqVqEtNgcgvvvgCb731VoF/Z8bsMfPbsOtLKOv0htwvf82Kjtw6hL3XdsFd7YGXQ0cWwast3ThIyFghM0WfNQcIU6Igr9QMmmcXQebmX+Lv8x/HFiAqJRK1y4agT93+cGSRsSkOUZuGMUdnvLEP2uVDAV0qFPUHQP3kdMjk5q8m/1zcjF8OzBE1tjpU74zXW40tluxnQ2wsMvaFizqD+mvXrNsV5cuLjEHXNmFQVapc5K+DFdxrr71mvd6gQQNUqFABXbp0weXLlxEcHGzzMbzkzrnoAoJhuGI7k5AagLgEBMPLziYCttzYYK7DaqNGHW0/FncIz1cp2uxqW7R6A05culdfMDE103qfn6cLQsUy4kpoWD1ANCJxBAMHDkRMTIxotETNRxo3bozNmzdbJzBu3LghspwtqLkI1RD84IMP8P7776NmzZqis3H9+vWt+1CDEgo+UpCPxiwKNNqqOUilFSpXrpwreGipbUiNnaimK/07qVGjhrVEA2MOmfkNWb4zv9N16fj5gLmZ47BmI+D7CJ2QnQUHCRkrRMbr4WKJMbQpUNTsbs6IecTU56JwIvIYtpzfCI1Cg9FhE6CQO8aXM1v+OXwFP6w6ZP0CTZd/7T4rutxRcWvGmH0wXv4X2r9GiKLTyqbDoOrxhWhIYjQZ8fvRX7Hx7Fqx35Amw9Cv3jNF2lnUmJyMzAMHkL53D3TZMtHkvr5wbdUabm3bQFU92O67m9qjx6nbVVTHpJpclgycvIKEvOTOuSgbDYZh/+w87pWgbDQE9oSyqo/dPpxjiXF2FDak+qzFJSk1E4fOReLA2Ugcu3gHWr25qzupWt5b1BekZcQ1Kvnlu75gaUNLi/NaXrxz585c26ghE/3khRqL5NVcJDvKDKQfW5544gnxw5gjoRqEtuvHinvN9+fD4mOLEJceiwblG6NjcNdCfY2OgoOEjBUSQ8Ra6Na/CRh1UDR+HuonvrJmxJQkKvg/e990cf3FZiOKpeNnSWYQUoCQJtctM+yWyx/+Oii633FGIWMlz3BuA3Rr3gBMeihbj4Gq4/siAJehT8f0/77F0duHxKTG2LaT0DIorEhegykzE5mHDyF9715oT54EjOaTW5m7O1xDQ+HWpi3UdetCli0LhBVP3a6iOibV5CKUncMYkftVh7r3VOg2TszW3dh8Sdvzu3StqFHgjyZOtl/cikzDvQ7A96NXTg2citKtmOSs+oKROHcjVnznIhQEbBgcYA0MlvfzKNLXwRhzHpLJKMp5WTvQ5yKDzPvhqzzORp/BlgvmxJnXW43hyd88lHwEgzEHoD/4E/T/fCyuq9pPhrLNBLsZdH49NE90vGtUsSm61+oJR7b18BWxPIjq9NyPttMS5OLufscYy8lwcjl0GyeI2WBVh3ehajNObI9JjcZXOz7BjcRr8HPzFw1KqvnZzvZ6XJLBgMzjx5Gxdw8yjxyBpNOJ7TK1Gi6hoaLOoEujxpCpuKlTYXrUul3UmCQiIsJ6/fbt2yLA5+HhIZbN5eeYtKSYlvX16tVLdOekmoS09K59+/Zo2JD/P8DuUTYcCHnlULFUjTJR6ESTMgjtIUB4Lf4K1kWsQvi1/0TpBfou06hCE5yMOm7zuw5NjFKH98JkNJlw7kacWEJMwcHbsSnW+9w0KjSrXV4sJW5euwI8XNWF+tyMMSalRkO79g1Itw8/4M14eOa3zqjD3H0zxfWBjV9AOc/HW83gDDhIyFgBUBMQ/b+fwnBgLiBTQN3zGygb28/SlH3X9+C/qzvgrnbHqNZv2k3gsjDRF+Jrd5Kw59RNbNx3SRTLzgvVKGSMlRz94V+h32quF6Pq9hlULUaI6+ejz+LbXZ8jKTMRwf418XbHD0SgsDBIJhN0ZyNExmDGgQOQ0rLGAbkcmiZNzJ2JmzeH3NW1UJ6PFbxuV2RkJJo0aWK9/d1334kfKvhvWb73sGNStuE///xjDR4GBgZiwIABohYYY/ejgKC9dDGm7zUUBKTg4MmoY2KbSqFGl+AeeDKkn1gRsuPyP5gTPsNcWsWS+yhJGBU2rlBWjGTqDGL5MNUXPHQuCslp9xqKlPF2Q8uQiqK+YP1qZaFSOm4JG8aYHdSuXj0SSIuGzCcIivrPwLB3+mNlfv91chkik2+J75m96vQptt+hNJJJtqresjwlJyeLlvRJSUnw8vLid8qJSQYtdBsmwBixGlC5QvP0T1DUsJ+6BgkZCZi0frRo7T6u7WS0rdYBjuTG3ST8d/Im9py6gVsx92a18yKXydC/fR3OJHxMPPaxgtKH/wD9zi8BmVx8maPsHfLflR2YvW8GDCYDWldpi9Fh46FRuuT7uIaoKKTt3AFjTAwUZcvCvWMn0WREf+Uy0veGiyYkpoQE6/7qOnXgSg1IWrWCgv8/zh6Cxz5WXGgM3HftP6yLWI1rCVfENk+NF56o3Rs9aj+Zq7N7VHIk/r20VSxFpiXGlEFYkABhQkqGOVvwbCROXLoLneFefcHgir4iMBhatxKqV/BxyElnlhOPfaykE3GoXqx+51eAZISiZg9zcztXH5jirz5y5vf1hKt4Z+N4cf3r3tNRxbfkM8XtGWcSMvYYpMxkUXDfdH0P4OoHzcA/oKh4L+uhpFHsf97+mSJASCfdbaq2hyOgOjh7RGDwJq7fTbJuD/BxQ7uGQagd5Icv/wy31sfJjpblUJdjxljxj0f6nV/AsO9HQK6Cuu9sKEOeFIX3l5/4E3+dWib2G9BgEJ6jL3qy/NcApOBg4rx51NKTnkhcpq5dC5mXF6TkZOt+qqpV4RoWJoKDSjvrVFqYuLM7Y6UP1WKlWoMbz61FbFqM2FbOozyeqvs0OgZ3yXPShAKCzzd9qUBj843oZBw8e1ssIz5/M956n1IhR5Oa5c2BwZBKKOtT8k34GGPOQcpIhHb9mzBd2iZW6qk6fwhly1HWyYlHzfymhnhz9v0gSjYMaDCQA4T5wEFCxh6RKeUOtMuehxQdAZlPFWgGLRaFr+3JjsvbcOTWQfi4+uKV0HuDamkUFZeK/07eEIHBq1GJ1u1lvF3RtkGgCA7WrOxn/R2pizE1KRG3pXsBQtrOTUsYK4GSDFv+D4ajCwGlCzQDfoEiuAu0hkz8uHca9t/YC5VcJcohtKve6ZGOTRmEIkBo7lRkeULzRXIy5P7+cO/QEa5twqCq9PBi1qUdd3ZnrHRJSI/H3+fXY+uFTUjTmcsg1PCvhT71+iM0sDUU8sJfxms0mhBxPVYEBSlrMCo+1Xqfu4sKLepQULAimtWqADcXrs3KGCtexqjj0K16DVLSTcg8ykHdby4UQa0KdMxN59bictxFVPKqLCak2cNxkJCxR2CKvQDt0iGQkm9DXr4hNM/9AZlHWbt4D6OSb+PfS9twM/EGjkceFdtGtnoTXvctTykN7iakYU9WYPDS7XvLBP08XdAmKzBYO9BfdNK7X9dm1UQXY2pSQjUIA3zdRQYhBwgZK16SyWAuyXB6JaD2gObZRVBUCRONlL7Z+Zn4wubt4oPJHf8PtcuGPNKxTWlpSFy08F5w8H4ymehO7PXcc3AG3NmdsdLjVtJNrI9Yjd1X/hVLjEmzSi3Qp94AhATUK/SJ3XStHscu3MH+iNs4fD4KqRnmhk2EviO1yqovWLdqWZFByBhjxY0ymw1Hf4P+n48Aow7yKm2h6Tu7wOfZd1KisPT4n6Lp08jWb0Kl4MmP/OAgIWP5ZLx5ENoVw4DMRMird4Sm/y+Qqd3t4v3bcWmbSKOmL5a0hM8iWXtvSa69i0lMx95TN0XW4IVb95a8+Hi4oE39ymjbMBB1q5S1GRi8HwUEuYsxYyVcs3XNKBgv/A24+kIzcDEUFRvjStwlfL3zUxEoDPSpgvc6fYyyHgH5O6ZeLzoTp//3HzKPHQX0+gfub4w1L9sr9Uu1DSZo9QZk6oyimQBd12ZdzxTXDdh5/Eaex+DO7ozZx9/yuegzWBuxSqz0IEq5Ep2Cu4llxYE+QYVaXiAuKV3UFqTGIycvR8NgvPfdkFZfUFCQlhJXKeddqlebMMZKP0mXBt2myeY6/zQ2tpkAVbtJkBUwm9pSfktn1KJH7d6oE1C3kF6x4+MgIWM2mOKvwHBiibUgqsyzEvT/TgEMmVA0eA7qXt9BZiczEZRBSAFCWlJ7fx8i6nxXp2zdQul0VxTikjNEYJCaj5y9Hmfd7uWuQVi9ymjXMBD1qpWFIlvXS8aYfZP06dCufBmmq7sA9wC4DF4GeUAdHLgRjpl7vofWqEXTSi0wvt1kuKrcHt6Z+Pw5pO/Zg4z9++91JlYoRHMSw9271IEt9+MgE01MigOdfIvgHQXtdMasgN6962K7PivAJ4J8WQE+cduYFei7FwA0X1r2Nz6wY3t+cWd3xkoG1cI6dHO/6FR8Mfa82Oamckf3Wj1Fd01fN79CLS/QMqQSYpPSc6zCUCnlaF67glhGTPUF/b24kztjzD6YYs5Du+oVSHGXzJPKfX6EIrhzoZXfOn3nJPzdyuL5JsMK5ZjOgoOEjN3HcGIpdJsmZWutLs5UzX8wYW9C1eFdu5p1pSXGli+J96Pt1PmuIIWtCxt1zws/fUt0Jo64HmNdLejpqkZryhhsEIiG1QOg4CUvjJXOpk7LX4Tp1kExwaIZvBwy36pYfXoFFh9bJPZ5MqQfXmg6/IH1tvQ3b5gDg3v3whgbm6MzsVvbdqIzcdSNO5A+MReuzj4iS1m1EFMbh4KKLRhNJhFsy5GNZ83Cy56Rl3ufHAG9HPsbs4KCBhhNBQ/i5UWtVECjVsBFrRQ/GhXdVsJFRbcV0KiU4v7LtxNw8XZ8nquvKcuIMVZ8tAYtdl7ejg1nV4vlboROVJ8M6YsuNbs/dILkccsL0JJi4ummFvUFKWjYpGY5uGrsY2KbMcYsDKdXQvf324A+A/JKzaB+eh7kXpUKrebrb0fmi+uvtXqjQGOuMyqyIOGsWbPw7bff4s6dO2jUqBFmzpyJ0NDQPPdfsWIFPvzwQ1y7dg01a9bE119/jV69elnvp//5ffzxx/j555+RmJiINm3aYM6cOWJfi88//xwbN27E8ePHoVarxX73O3ToEN59910cOXJEBFDoNX3zzTfiNTJGGYQiQJhtye49MigbDrKrACEtLT4bfSbHEuPs6CtjTFo0SlpSaibCz9wSnYlPX42xZsZQkexW9SqhXYMgNKpRjmvhMFaKSelxyFw6GNKdU5D5BUMzZBmM7gGYFz4Nu678C4VMgVdajkLXmk/YfLwxLg7p4XuRsWcP9NevW7crK1eGW7t25s7E2bIDN1xKQlzZZngx5ghM1kkdWlwr4fcyzXBk8TFIOCaW6xYVytChk28RsMsK3omgnri8F8iz3p8V6Msz6Ce23XtcfsorWIIGI6dusnkfd3ZnrPgkZyZhy/mN+Pv8BqRozR3Wq/hWQ9+6/dG6ajuxxPhBTCYJSWmZYqVFXFKG+VL8pFtv34lLzbscK4AOjatg/DOhPNnKGLNLkiET+q0fwnD8D3Fb2eIV0cFYplAX2nPMPzRXNIRqW7WDWL3C7CBIuGzZMkycOBFz585Fy5YtMX36dPTo0QPnz59HQEDu2kPh4eEYPHgwvvzySzz55JNYvHgx+vXrh6NHj6J+/fpiHwrk/fDDD1i0aBGqVasmAop0zIiICLi4uIh9dDodnn32WbRu3Rrz55sjx9mlpqbiiSeeQJ8+fTB79mwYDAYReKTj3Lx5EyoVz7I5O1pinDMnJRuZHIYTix+p5XpRLl/Zf30P/jq1DDeTHlSLCijrnr96X4UtOU2LfRHmwODJK9Hiiy9x1SjRqm4ltG0QJGa3VcrC797HGCuBru9LBkKKvQBZQD24DFqCZKUa3/3zfzgXHQF3tQfe6vA+6pdvmPNxaWnIOHAA6Xv3QBcRYW1EIvfzg1tYG7i1awtlUBVkaA2IuB2PCxFnceFmPC7eihdL6uBRBZc0/miTcg3+hnTEKd2w17MqYlQegMEkJh5oMsIciDMH5yiIZw7E3ReoyxbUswT6LPvfC/rdC/LRpb1kPFMdMu7sztjje1B9v/ygbMENEWuw4/I/ov4VaVC+MfrWG4CGFRqLCWbKPI5OTskKAKZnCwDeCwjSaouCZCeL2tQmyW7GJsYYy86UcA3aVa9CuntaNLVT954GZciThfomUXkb+vHUeOGlFq/xB/AYZJKtNYoFRIHBFi1a4McffxS3TSYTAgMDMXbsWJHFd7+BAwciLS0NGzZssG5r1aoVGjduLAKN9BIrVqyISZMm4a233hL3JyUloVy5cli4cCEGDcrZypq2jR8/Plcm4eHDh8XrunHjhng95NSpU2jYsCEuXryIGjVqPPR3S05Ohre3t3h+Ly+vx3yHmL3SUqH9s+tsZxLK5FCE9IGm3xyUZHBw77XdIjgYmXxLbCvnUR7RqXdFtsj9KKdmRt95xVaTkDrm0VIXaj5y4tJd6xddOqGmWji0lLhZrQpQqzgwWNrw2MfyYkq8Ae3i5yAlXhfLRajr+y1tEr7a8YkYmyp4VcJ7nT4Slw9qQCJzdYVry1ZQh4Uh0qciLtxOEE2MKCB4KyY5V+YMjSt00m2LXCZDv3a1Mbync60SKGigg+XGY5/js1Xfjy4p8N61WbUHPpbqDK49swoHb+yDJHKa5ajm2QSBqjAYM3xzZAGmZT642RKhiQ2qGejv7Wq+FD9u4rZf1u2/91/Cmr0XrJOv9499/dvX4eZtrMB47GOFzXD+b+g2jAe0yZAF1IXm6Z8g9w8u1OdI06Viwro3kJARjzfbTEK76p0K9fjOotAzCSmbj5byvvfee9ZtcrkcXbt2xb59+2w+hrZT5mF2lN23Zs0acf3q1ati2TIdw4ICdRSMpMfeHyTMS+3ateHv7y+yDN9//30YjUZxPSQkBFWrVn3M35g5EqqhlWcmIYXcxP3Fz2Ay4L8rO/DX6eW4m1XbJsinKp5pOAgtg8LEUj5qUiK+2FqqKUoSRoWNK/IAYXqmXgQG95y6iWMX71g76FEgsFW9iqL5CAUG6YSeMeZYTLEXzRmEKVGQV2kLzbMLcTzmHKb99zUy9Okic3BS+/fhrnKD9myEzQYkUsPGiKxWDydcyuFcZDKuLD8Pg/FsjuehbEDqyGn5qVXZT9QLpCW2tqY6adKkR4vqcDbc2Z2xwqvv98NfB1Gjkq+oDWrJ+ItPzkBsYiquJJ/GLcM+aBXmGoCSUQljYm0Y4kIQYXBHBChRIWeyAtUJzB70uxcENAcF/bzc4OWmfmhZmx6hwVi9x9wE5X5cXoAxZm8kox76nV/AcGCuuK1oNBjq7p9Dpir8Jkq/H/lVBAibVGyGttU6FvrxnUWhn7XHxsaK4Btl+WVHt8+dO2fzMRQAtLU/bbfcb9mW1z754enpiZ07d4qlzJ9++qnYRjUNt2zZAqXS9luh1WrFT/ZZFea4lI0Gw7B/dh73SlA2GlKsr0dv1IvC11T0PybtrthWzS8YzzQYhOaBLSGXmZeTdAruKroYU5MSqkFIS4w71+heZAHCdK0eh85G4r9TN3H0QpS15hd9kW6d1ZWYCmZzYJAxx2W6cwqZSwYBGfFQ1OwOVb+52Hz5Hyw4/LNoHNKt5hN4sUJv6Fatw937GpAklAvECd/q+Mfki9gUOXAyA8A1ayZN7UBLQNAftQL9UNHf02Z9Pl5iyxgrCMq8zav5G20aO2PLvQ0yIxTeV6Hwj4BckwQoKDPaFabEEPgYG6GMpw/8Q+4F/UQw0BIA9HQttFUUXF6AMVZamFKioFv9Oky3DgFKF6h7fAllo/wleD0q6mS8/dJWuChd8Wqr0XbVR6C0rSBxqtSejIwMjBgxQjQ9WbJkiQhmfvfdd+jdu7doaOLqmjuaTXUSp0yZkmt7XFycyJpkjsYLivZToN79cbbuxuZLXfspSDd5UiS8yF+F3qjD3lu7sfXKJiRkxottVb2ro1eNPqhftpEY9OLjzNstVFCjR1C2mg46c9C+sFDWzokrsTh0/i5OXI2zBgaVChkaB5dBaO1y4tI1K2MwNTkRqSg9ypQpU9IvgbFSw3jzoOhiTEtGFHX7Qd57KuYfXYCtFzaJMgeDXVuj1V/XEH/zXomRuy7eCHetjEPugYinLnNaqp8FBAZ4iUBgzUp+qBXoj6rlvfNdq5SWAtatUoaX2DLGHgudWD2o8hJNWlQMUANe55GoPAqdZP5m4+9SAZ2r9Ubnml3g7+VR7CejPPYxxuyd8epuaNe+AaTHQeZXHZr+P0MeULdInktryMTc/TPF9SFNhpZYTf6SLpXx1+6z+SqVUexBQjrRVigUuHvXnPVkQbfLly9v8zG0/UH7Wy5pW4UKFXLsQ3UL84saolD3ZFqiTEugLdt8fX2xdu1am8uWadl09qXQlElI9Qxp2TLXJHRQZV6BKaSLaFIiJd0SS4wpg9Ddr2B/bPkd4P65uAVrz/wlUqVJ7bIhYllxowpNi/1LqFZvwJHzd0SNwUPnIkWg0PKluXntCiJjsGXdSnB3KbxuVIwx+2a8ugvalcMBfQYUjYdA1+kjfP/PFJyJPQ2NUY6hR1SoF3NSTLEkKFxwyCMQB9wDcVvtjTI+7qgTaF4uTJmCNSr5wc2lYE3DeIktY+xxUeaF+G6lSoLC5xJkqjRIencYE2tAJilQs+FdROmPItOQIeaNQwLqo2+9/mhSqbl1NUdJ4bGPMWaPaDWJYc906P/7TiTaKOo8CXXvqZBpiq5G8vITi0VJLjpv7lG7N5y9VEbdKmUKlFFY6EFCtVqNZs2aYfv27WJZr6VxCd0eM2aMzcdQN2K6n5qNWGzbtk1sJ9TNmAKFtI8lKEjBugMHDmDUqFH5fm3p6ekiOJg90GK5Ta/RFo1GI36Yc5H7VSvWLsYZ+gxsu/A31kWsQlKmuYZN3XL18UyDwaKmV3EGB/UGI45eMAcGD56NREZWYwBa6te0Znm0bRgolhR7uHJgkDFnW7ZguLBZLBuBUYfIygMRfq02/vt9OBJddfBLl+HVQxr4pKmx16MSTvhVg7J2HdQMLIPhWUFBKrzPGGP2gsa41SfWQ1VhX44VJAr/M+L+qxmU8SxHq6A26FO3P2qWrV3SL5kxxuyWlBYL7boxMF3dBchVUHX5CMrmI4r0XPZy3CWsP7sGSrkSI1u/WeITOMVh3d4Led5HK3rou/ywJxra13JjyrwbNmwYmjdvjtDQUEyfPl10Lx4+fLi4f+jQoahUqZJYykvGjRuHDh064PvvvxdLf5cuXSo6Ef/000/ifvpHRQHEzz77TNQQpKDhhx9+KDoeWwKRhLoWx8fHi0taSnz8+HGxnboWe3h4oFu3bpg8eTJGjx4tOi1TYPCrr74S9Qg7deLON6z4pevSseX8BjGwpWjN9S4blG8sMgcpSFicgcHjl+5iz8mbogkJ1Ry0dMlrFFxOZAy2qlcZ3u4cMGfM2ZYtDO/ZGAG+btCeXIkWV7+DKc0T5+LaIiEyCtubXEK6GqgaL0fnKzUQ1aQ50lqGom3VcnjWv/iX4DHG2KOQqZOhrrhfhAbNAcLsl0Dbqh0xsPHzKO95byUTY4yx3Iy3DomJZGpmJ/OqCPXTP0FRqVmRN/ecs2+GyF4c0HAwKnsHOuxHYzSZcOzCHWw+eBkHzkY+cF+a7C+IIgkSDhw4EDExMfjoo49EYxHK/tu8ebO18QgF8SzLfUlYWJhY9vvBBx+IrsMUCKTOxvXr3wuSvP322yLQ+NprryExMRFt27YVx3RxcbHuQ8+3aNEi6+0mTZqIyx07dqBjx46oU6cO1q9fL2oMUpYivQbah46TfRkzY0WN2rP/fW49NpxdK66TxhWbiYYktQNCiuUDoC7EJy/fxX8nb2LfmVtIyzQHBumcvkH1ALRtEIiw+pXh43Hvb4wx5tjLFsrqUhGWcg3+hnTEKd0Q7lkVv246jv6mXXgq/ThSE5vDpHfBrcAMLK+vg0kONFXUwNgXP4CHH9f1ZIyVLv9e2pZn4xLKRinjXoYDhIwx9gA0fhoO/QT9v58BJgPk1TtB0+dHyNz8ivx9W39mFa4nXEWgTxX0rfeMQ35OcckZ2HboCrYevoKYxHSxTSGnlbDUz942Wg1UEDLpQdV6WS60zNnb2xtJSUlck5A9shRtCjaeXYtN59YhQ2/+I29WOVQEB2uUqVXk76jRaMKpq9EiYzD8zC2kpN9rvlO3ahm0axAkAoO8JJDdj8c+x7Zo80lEbtyMF2KOQBILFeiLhwxySMhQyuBmMH9VMEHChhYa/BuQIG4PbjwUT9d/ljMGmcPisc+xTf/vG4Rf+0+MePejZcZhVdpifLu3S+S1sdJh1qxZ+Pbbb0ViTKNGjTBz5kyxki4vK1asECviqE4+JcZ8/fXX6NWrV46a+++88w62bt0qEmPat28vjkn7WlDyy65du3Ic9/XXX8fcuXOttykph8pyUbIMraijVX60io9W0OUHj30sP6TMZOg2ToDx/CZAJoeq/WQow94U42dRiUq+LSZ4ridew4nbR8V30y96foeaZWo7VtbgxbvYcvAyDp6LFAFBUr2CD55oGYxalf0xYdZWUZPwfpTwM3diL/uqScgYyy0pMwkbIlZj8/mN5uLXAFoGhWFAg4Go5hdcpLXEaJCJuBYragyGn76FpDSt9TF1gvxFxiD9+Hu78UfHmJPKuHlLBAjlNpbciQChUgt5i/r4rYYBR+NPQ63QYGybiWhVpU0JvmrGGCsY6oCZVyYhFUtwhg6Z7PEtW7ZMlNmi4FzLli1Fia0ePXrg/PnzCAjI/W8nPDwcgwcPFsG6J598Uqyko9JZR48eFSvo6N8h3VapVKKpJjXJnDp1Krp27YqIiAi4u9/LDnr11VfxySefWG+7ud37Hk9lt6iEF9X0p+eMiooS5b7ouF988QV/5KxQmO6ehnbVa5ASrgJuZaDpNweKqm2L9N3dcWkb5uz7wdxTQrrXU+JW0k2HCBLGJWfgnyNXsfXgZURnZQ1qVAq0bxqEJ0KDRX1vSykf6mJMTUrE7az/hdGEF20vSICQcCbhI+JZFfYoEjISsD5iFbae3wStUSvyc1pVaSuCg1V8qxZdLbGsPKCG1QNwIzoZCSmZ1n1pcKEag23qBxY4FZk5Dx77HNuez2egyqnwrCDh/SRcCqmI9c0MuJ5wDb6ufnin00cI9q9R7K+TseLGY59jo4yUcWtH2s4khAwz+s5DBa+KJfLamP2jwGCLFi3w448/ittU7z4wMFDUvn/33XdtluSi8lkbNmywbmvVqpUozUWBxgsXLqB27do4ffo06tWrZz0mBfsouPfKK69YMwnpMRSUtOXvv/8WQcjIyEhruS86PmUoUkkwajT6MDz2sbzQuabxxBLotrwPGLWQB7aEut9cyD3LF+mb5qjjtckk4file7UGLVmD1ShrMDQYHRoHwd1F/VgNBx+X47d+YawExKXHYsGhnzB69Qisj1gNnUmPdtU6Ymqf2ZjY/p1CDRBmb4EuahPQpWS+PHE5WgQIgyv6ig5HP0/ujamju+HpdnU4QMgYs6ouSxRLi2255mPEwirXRICwul8NfNlrKgcI2WMtyatataqoJU0n1gcPHsxz3zNnzmDAgAFif5r8yutE+GHHzMzMFM3q/P39xXI7OiYt5WPMooJXJYwKGydOMKkGIS2RE5eQie2l8YSTFQ+dTocjR46ILD8LqndPt/fto27ZudH27PsTyjy07K/Vmlf7ZK+5T8fUaDTYs2dPjsf9+eefKFOmjMhAfO+995Cenp7jeRo0aGANEFqehwJ/NL4y9rgkfTp0G8ZDt2mSCBAqW4+B5vmVRR4gzF5D1hba/u+lrShN4pMzsHxHBF79biM+XrAb+87chkohF4G+70Z1xYyx3dGrVY08A4SEAoJ0jj95cGtxWRgBQsLLjRkrRDFp0Vh7+i9sv7RFdFuiL5odg7uif/1nxRfRx5mpobqB8SkZiE/OFJcJ4noG4pIzxfUbd5Ns1iMgNIz2CK2O0U+3KPgvxxhzWC7yGFAhhBg3E/YHGhDvaoJfhhweOmBjbT0MCnOJBFpirFFyMyNWtEvy6GS3evXqePbZZzFhwoTHPiY9duPGjaIGGNWTHjNmDPr374+9e/fyR8isOgV3RZ2ydcUJJn2PoyXGnWt05wAhe6DY2FixrDd7II7Q7XPnztl8DNUttLU/bSfUZDMoKEgE/ebNmyeWF0+bNg23bt0SS4YthgwZgipVqqBixYo4efKkyBCksW/VqlUPfB7LfbZQgNISpCQUUGQsO1PcJWhXvQop5hzg4g31kzOgrNWj2N6kawlXcywxzo5OhWn8Lh1Zg3dF1uDBs7dhzMoarFreW2QNdmxS5YFBweLCQULGCiF1927KHaw+vQI7r2yH0WSAQqZAlxrd8XT951DOxsxKfoJ/dD0+JVN0IX5cNKuSnmngz5gx9kAulXTYGWvA0oY6yKSs0iYyI6SsCdun4IEX2r8rJj4Ye1RUU4vqZw0fPlzcpsAeBe9+/fVXm0vyaPke/RBb9+fnmNRgbv78+aLmV+fOncU+CxYsQEhICPbv3y+W+DFmQRmDzzd9id8QVqKoZiAF+kaMGAE/Pz8oFAqRedizZ88cdTNfe+0163XKGKxQoQK6dOmCy5cvIzj48WqdU53EKVOm5NoeFxcnsiaZc1Nc3gz17o8h06fDWKYudF2/R7pXZYqWF/lzp+pSsP7iahyPPJLnPvR11UPuKYL39igpTYv/Tkdh96nbiEkylwFTK+VoHVIeHRtWQvUKXuK8PSM1GRmpRftaKAP5YThIyNjD6vvJZPhr91lRBLRrs2o59o1KjsTq08ux68q/YmZDKVeiY7UeCKvUE5LeA6cuZGB3SoQ14CcuHyH4p1TIUdbHDX6eLqLjsJ+nK3y9XOHv6QJfT1exbdvhK9i475JYYmwL1x1kjD1MbLkALG14GxKNe9lXckj0xUtCxwo1OEDICrQkjzJj8rskrzCOSffr9focS/ssWTq0DwcJGWMFPdGmIN79JQzoNtUQtIW2P2z/Zs2a4fjx42Kig8a6smXLimzp5s2b5/la6H5y6dIlESSk491ffsHyvHm9NhpPKTs7eyYh1Vekcg3UQIU5J8mghX77JzAc+VXcVjYdBteu/4OsGFaV6I16bL2wCStOLkaaLg1KuQoGk97265Qk9G7QF2W8Hh4AK86swROXzR2K90fcyxqsUu5e1qCHa8lnDdrCQULG8qjvZ5mxs1xS9yAfdzXkcgWuxF7F/qi/cT39mDiLlkkKqNPrI/1OHWw+7YrNOPJIwT9LwC978I/u83TTQC63XXvB4snWNbFh30Wb91FhV8qCZIyxB9ntUUbMwuaaapBRhzNgt3tZvMBvISumJXmFcUxaUkfF+X18fHLtk9dyO8JL7hhj+UHjCwX0tm/fLjoSW5qM0G0qbWBL69atxf3jx4+3btu2bZvYfj8qkUAuXryIw4cP49NPP83ztVBQkVBGoeV5Pv/8c0RHR1vLL9DzULCvbt26No9BdQ/phzELU9JN6Fa/DlPkMUDlBnWvb6Gs17/I3yA69z56+zAWHflFNCshYVXa4YWmw3H67knMCZ9hTubJyiCk/e2phmxCSqa5Q/Ghy7gTnya2qZUKdGgciJ6hwagd5J9nbUV7wUFCxrKhJcbij1aVBIXPJchUaZD07jAm1oCk88InS9dDWeYU5F7XIbqNmxQwJtSCIa4uMgxuIvhXxtsF/l4FD/7lFy2DLsoW6Iwxxxdr1IksQlskmRyxxnt1ihhzZLzkjjHnkJ8ldw9DmXfDhg0TWX6hoaGiNip1L7aUQRg6dCgqVaokxhUybtw4dOjQAd9//z169+6NpUuXigDgTz/9ZD0m1VCl7EHKej516pR4DAUhu3fvLu6nJcVURqFXr14iy49qElL91fbt26Nhw4ZiH9qXgoEvvvgivvnmGzEx8sEHH4hGThwIZPlhvLQd2nVjgMxEyMrUgqb/z5CXqVXkb97NxOtYdPgXnIiiRByIhnkvtXgVIQHmbt+dPOyzhqzJJOHkFao1eAUHIm5bVwwGlfMSWYOdmlS126xBWzhIyFg2VINQ5nURqgq0XMmSVyODwv8MpEw/yF3jxX4KqFHDMwyh5buhkm9AkQT/HgUtg65bpUyRtEBnjDk++pJFXT0lGwWhafKB7mesuJbkFcYx6ZKW6iUmJubIJnzY8/KSO8ZKH0NUFNJ27oAxJgaKsmXh3rETlFlZdUVp4MCBiImJwUcffSQCcY0bN8bmzZutWc43btwQpRAswsLCRICPAnbvv/8+atasiTVr1ogOxRbUoISCjzRWUWYgBRo//PDDHBmM//zzjzUgSUuCqXM7HdOCxscNGzZg1KhRIquQGqBQMPOTTz4p8veElS6m+CswnFgCKekWZN6VoWjwHIynV8AQPlPcr6jXH+qe30KmdivS15GiTcayE39i24W/RQkvH1dfDGkyDB2qd85V7saeasgmpmZi+5Gr2HLwCqLiU61Zg52bVMUTLYNRp4izBotq7JNJ2augsoei+gyU/k11Irg+g+OZteFf7IifKrIEbaHgYL8GT6N3SF94arg+B7MPc+bMET/Xrl0Tt+vVqye+sFKha5KZmYlJkyaJGWtaSkcdQGfPnp1rqd6D8Njn2Gg5x7i1I0UG8v1kkGFG33klPkvLSi+ql0VZNjNnzrQuyaMsGVqSl1djEouqVauKpXnZl+fl55j0PY2ycZYsWSJOoAl1/6S6hI9Sk5DHPmavSiowZm/oPUicN49mtGjdofXS5/WRcO/YsaRfXqnFY5/jM5xYCt2mSTkSYyAZzXcq1FB1+xTKJi8WbZDLZMCW8xutdQdVchWerPs0nq7/DFxVRRuYLEjW4Kmr0dh8wFxr0JI1GBhgyRqsIhKHSvPYx5mEjGX/g/C9BMTbrMwl/vbaVuuCQY1f5PfMzjnbF+fKlSvjq6++EjPSNO+zaNEi9O3bF8eOHRMBQ1qGQl0/aQkLTXLQSXT//v2xd+/ekn7pzE5U8Kok6rnYe50XVjo96pI8ygCMiIiwXr99+7aoueXh4YEaNWrk65g01lGHUNqPuoTSxO7YsWNFVg03LWGlna2Tw9R160pNYEwymQCDAZLRCMlgACyXWdty3mfIus8IyZh1mXW/MS4OKSuWm98DS95L1mXivLnQ1KkD5WNmLDPm6BmEIkBoYwUJUT89F8pa5mSDonL09iEsOjwfkcm3xO3WVdqKuoMBHvlPYihOSZQ1ePQaNh+8jKg4c9agSikXQcEeocFiVV9x1Rqkc13x/4AiGvs4SMhYNhmmRNBqYVvptXKZDAaYi48y+1Xavzg/jqeeeirHbSpWTZmF+/fvFwHE+fPni+UtnTt3FvcvWLAAISEh4n4+WWYWnYLts84LK/0edUleZGQkmjRpYr393XffiR+q5bVz5858HZNMmzZNHJcyCbNnUTNWmj3s5FBBy/H9/HIG17IF4u4F4bKCcvfdb32cZX+DMWtbtsfdf6xs9+U81n3PnRUItL7uoiSTIW3Hv/AePKTon4uxUoaWGJung22QKWC6fRQooiDhzcQb+O3IfByPNDf6rOYXjJeav4q65e4tu7cXkiTh1JVoERjcdyZn1mCPFtXRuWnVYskavF/q5s1FOvZxkJCxXHW5ZNaOxjn/3rgul70r6lmV0oA6flLGIGXUUMbMkSNHoNfr0bVrV+s+tNyOluU9ypI75hzsqc4LcyyUwZxXx09L4C/7EuP8VMN50DGJi4sLZs2aJX4Yc6TJUOtE6P0kCXGf5d0Ft8QpFJCp1eZLpTLbpRIyZc7rUCohy76fQmnelu0+7alTMERG2n4uSRIrShhjNv48kih7L6//z0pZ9xeuFG0KVpxYjC0XNoq6g94uPhjSZCg6VO8ChVxhVx9TUpo2q9bgZURmyxrs2LiKWFJct2rxZQ3SZIz+xg3oLl6A7oL5xxgd/YAHFHzs4yAhY9l0rtENa8/8lcffmySyaljJoNlnU0oKjElJMCUlwpSUnHU9CcZk86WeavLldWLp4DPK1AGPgoJUf5CW5K1evVp0tqMlelTkOnvhfkLZNpR9kxfKuqGf7LVpGGOMMVayjNSwh5br5kHm5iYmRHME1e4LyuW8L3uALnugLtv+1sBc1uPuD/LlCPCZ77fsZ36erH0L+aQ6aclipK5fb/v9kMlEyRnGmI0/D+/KeWcSUjVqcX/h1R2khiTUmCRNlwqlXIk+dfujf4Pn7KruIJ3rn74aI2oNhp+5Zc0arFzWUywnpmYkXu5FnzVoSk2F7uJFa0BQd+kipGznZIJGQydrtg9QCGMfBwkZy4brchUvSae7F+jLFfxLhDE5WdwnflJSCvhkjj2jXLt2bREQpGL9K1euFLW6du3a9djHo9pgU6ZMybU9Li5O1AhjjDkG6hTMGCsdjPHx0J47l/cOcjncu3Vz2AnR+1HNaSopY5Mkwb2TucwKYywnZaPBMOzPq/yGBGWjwhlDjt0+gkVHfsHtpJvidsugMLzY9GWU8yxvV1mD/x41dyi+HWs+31Qq5OjQKEh0KK5XtWyRZQ1SfVZDVCR05y9YMwUNt2/n3Ekmg6pqVahr1Ya6Vk1xSckz0ZMm5plRXtCxj4OEjN2H63IVbAZGysiAMTERpqwAnzEr8HfvOmX+mW/Tvvklc3WF3NsbCi8v86W3D+Te2a97I333bqTTMhwnnFGmbEFLQf9mzZrh0KFDmDFjhqjbRUG9xMTEHNmEd+/eRfkHLL1+7733RMH/7JmEgYGB8Pf3587ujDHGWDHTnj2L+OnTxPenPDlZYIya0lHNaSopY6vDp6OXmGHsccn9qkPdeyp0Gyfm7G4MSWyX+1Ur0JtLQcFFR+bj2O3D4nZV3+p4qcWrqFeugV1lDdJy4r2n72UNVirriSdaBKNT06rwLoKsQVNmJvSXLomAoDYrU1BKy9nzQObuDnWtWlDXrAlNrdpQ1agBuYtLrmMV5djHQULGHKQuV1F19KUZDkp7Fpl9iUlZwb/ErGy/e1l/luAf9Pp8H1vu6SmCe/eCfz5QiNvZrnt5QeHjY65h8xC0f/qOf/P4RZzri7PJZBLLhSlgqFKpsH37dlG8n5w/f140CqDlyXnRaDTihzHGGGMlezKbtmUzkn7/XTQAcQkNhaZBAyT9+isHxkQ2YUdRc5pKyli/A3fqzAFCxh5C2XAg5JVDYTixWNQgpCXGlEFYkAChqDt4cjG2nt8Eo2QUdQcHNx6KjsH2UXcwmbIGj10TwcFbMfeyBttT1mBoMOpXK7ysQRq7aUyyLhu+cB7669dzZf8pK1XKCgrWgrp2LSgrVIQsWzO3khj7ZFJ+KkOzHNk03t7eYkmfl5cXvzPMbjv6WmYSbHX0FfX9kinAlwhTYtZS36y6fveCf+bAH+2X7y50cnlWZp858CcCfFlZfrmCf56e5ho1hf5e7MxzVsVRuxtT1l/Pnj1FM5KUlBTRyfjrr7/Gli1b0K1bN4waNQqbNm3CwoULxbg1duxY8bjw8PB8PwePfYwxZ8RjHyvpsiwJv/yMjN27xfcZr4ED4dG3nziJNdy5w4ExVmR47GOPwmgyYtvFv7Hs+J9I1aWIuoO9Q/qhf/3n4KYu2bqDFO6KuBYrOhTvPX0TekNW1mAZqjVIHYqrFUrWoKTTQXf1ao4GI6bExBz7yDQaqGvQkuFa1mxBuYcH7A1nEjLmyB19586B9vQpwGDIUfvv/rTmB6EMPnPAzxsKH0vw714g0BoQpB9393zNfBQlZ5xRjo6OxtChQxEVFSUmMRo2bGgNEJJp06ZBLpeLTELKLuzRowdmz86rDgljjDHGSpohJgbxU7+H/upVsfzMb+ybcGnc2Ho/fa9xltqDjDH7dSLyKBYe/gW3km5Y6w6+0HQ4ynsWfEVbQaSkU63Ba9hy6ApuRiffyxpsGCSCgw2qBxQoa9CYkJAtS/ACdFeviHPu7BQBAfeyBGvVgiooyNzQyc5xJuEj4lkVZm8e2NntAZ3v7mX73Qv+KbzuBfws98tcXIqtxTuzXzz2McacEY99rCRknjqFhB9miKZtyqAg+E96C8py5fjDYMWGxz72MLeTbuH3I/Nx5PYhcbuKbzW81PxV1C/fsGSzBq/Hig7F2bMGK/h7iOXEXajWoIfLox/XaIT+xnXoLlDX4fMiKJirIaZSCXX16vcajNSsBYWvL0ojziRkrBQzabXIPHIk7wAhdUMKDoZX/wE5av/lp74fY4wxxhgr3hPc1A0bkLz4T7EqxDWsDXxee81m0XrGGCsJqdpUrDy5BJvPbxB1B7003hjc5EV0Cu5WLHUHI2NTsO3wVUQnpCHA1x3dmleDl7tGZA3SkuLsWYPtGgaiR2gwGlQLgFye/6QXU2oqdBfNAUFqMELNRiStNsc+ch+fHB2H1dWqQaZSwRFwkJCxUvolMvPAflHE2hgXl/eOMhk09erBpWnT4nx5jDHGGGPsEbteUk3ljH37RI1n7xdehHuvXryagzFmN3UH/7m4GctO/IkUbTIUciX6hPRH/wYD4a52L5bX8M/hK/hh1SExLtL5MIX9Vu46C4VcBqPJXG6rgp+HWE7cpVk1+OQja5CadBoiI3M0GDFERubcSS6Hqlq1HEuHqaSVo6624yAhY6WM/uZNJC1cCO2Z0+I2ZQrqr1yx3VzEyTr6MsYYY4yVNtSEJO7772C4eVM0dvMbPx6aevVL+mUxxphwMuo4Fh7+GTcTr4vbLQJb4cWmL6OCV8VieYd0eiPO3ogVAUJzGX7zea/l7JcChE1rlUf/dnVErcEHZQ2aMjKgu3TpXoORixdz1euXubuL7ECNaDBSE6rgGk6V0c1BQsZKCVN6OpJXrEDals1iebHczw/eL7wA19ZhSN+1K8+Ovo7csIMxxhhjrDTLPHYM8T/OFCepqurV4TdxEpRlypT0y2KMMUQl38Yiqjt466B4N4J8qoq6gw0qNCqc8goZOiSkZIqf+JSMrOsZiE/JRGK2bWmZeuvjAvSpCEu5Bn9DOuKUbgj3rIpYtSeqV/BFoxrlcj2HMTo6R8dh/fXruZJrlJUr58gSVFaoUOLNOEsSBwkZs3OUAp2+exeSlywR3YmpKKrHU33g+fTT1hkNZ+zoyxhjjDFWmr/fpaxZjZQVK8QJq1uHDvAZ8QrXjWaMFRtb9f0qlvFEmo7qDi7F31R30GSAp8YLgxu/iM41uj+07qDBaEJSKgX4zAE/cwDw3nXrZWqmtbHIw3i6qWE0mtAo9hJejD0KWmgsgyQuuyddwB9lmyE6IRCSTgfd1avWZcN0Kc6fs6GmnOoaNcx1BGtSg5GakHt4FOh9dDTc3fgRcacnVpx0ly8hccECUSyVaJo0hc/QoWJ2g7HixGMfY8wZ8djHimp1SMKc2cg8dAhQKOA9bBjcu3V32PpWrPThsc/xUX2/meu3Q+F7GVCmAgYPGBOqoUtbNxxP+Ntad7BXnacwoMFAyCWNjay/nBmAdJmcrrVZBet+VEfQ19MFvp6uWZcu8LNed4Wfpwt86LqHC1RKBZYv34nWq+bg/vw+y1Ol+JWDV3IcYDDkfJ6AcuYswawfVWAgZIqib7BSmnEmIWN2yJicjOSlS5C+Y4eYXVaUKwfvocPg2qxZSb80xhhjjDH2mPS3byOe6g9GRorumH7jJ4jVIIwxVpwZhD9uXwJV8D7KG8sKtckg9zuN/+6Y9/FGTXiltcWeHS5Yv24LMnU5g295cdUoRbCPAnx+2YKA2a/Tpaer+pE6DrdJuQaj9bXeYzmCV/xdQKWCunbtnA1GfHzy/8YwgYOEjNkRyWhE2ratovYg1aaRaTTw7Pc0PHr35uUnjDHGGGOlWMahQ0iYPQtSRoY4gfWbMAEKP7+SflmMMSezev8hKCvsE2Xs7wXdspqBSIA+Mgx3k4JxFxQYTBX7Uafg3Bl/LtkCguZtLurCCzHR8mHt+XPQnjgJ2d5dUNwXILTuB8ClQQP4v/0OZCpVoT2/s+IgIWN2QhsRgcSFC2C4cUPcdm3dGl7Pv8DFqxljjDHGSnv9wRUrkLJ6lbjt3rWbWGLMJ7OMsZJwPnF/tgzC+8ngX0aHUf3aWYOA3u4aKBRF38iDGo0YIm9De+IEMk+chO5shAgUPgw1GaHGTzymFg4OEjJWwoxxcUj68w9khIeL28rAQPi8NByaevVK+qUxxhhjjLECMKWmiu7F2uPHRfM5n5dHwL1zZ35PGWMlRqZOBTLzvt/TS4cWdSoW2xipPX0amSdPiOAgnRtbKRRQh4TApWEjKCpVQsK0qbk6EwuSJJp2ssLhvH2dGSthkl4vutrdnThBBAhlbm7wHvYSAr76mgOEjDHGGGOlnP7GDUT/3/siQKjw80fZ/03hAKGDmTVrFqpWrQoXFxe0bNkSBw8efOD+K1asQJ06dcT+DRo0wKZNm3Lcf/fuXbz00kuoWLEi3Nzc8MQTT+DixYvW++Pj4zF27FjUrl0brq6uCAoKwptvvomk+zu4ymS5fpYuXVrIvz0rrepWqlqg+wuaWa29cAHJK1cg5sMPEfXqK4ifPg3p//4rAoTUaMS9Wzf4vfUWKvz8C8p+/D94Pv003EJD4fP6SPrHDcjlOS5pu7J8+SJ7zc6GMwkZKwGZR48i8bdFMN65IwY2t06d4DVoMBTe3vx5MMYYY4yVcun79iFx7hxIWi3UIXXhN348f89zMMuWLcPEiRMxd+5cESCcPn06evTogfPnzyMgICDX/uHh4Rg8eDC+/PJLPPnkk1i8eDH69euHo0ePon79+mKpJd1WqVRYu3YtvLy8MHXqVHTt2hURERFwd3dHZGSk+Pnuu+9Qt25dXL9+HSNHjhTbVq5cmeP5FixYIIKMFj7cwIFl6dOgN7ZfWQ+TZI61WVCSHvUS6dPgyUJ9rwyxsdCepCXEJ0TWINXet5C5uEBTrz40jRqKjMEHBfvcO3YUjZ7SdvwLY0wMFGXLigxCDhAWLplEoxHLN24HzwrCcOcOEhctgvbYUXFbFVwDPi8Phzq4Br+xzK7x2McYK2i2zbfffos7d+6gUaNGmDlzJkJDQx+YbfPhhx/i2rVrqFmzJr7++mv06tUrR7bNO++8g61btyIxMRHt27cXx6R9LTp27Ihdu3blOO7rr78uTujzi8c+9jhN6JKXLEHqhvXitnvPnvB+/gXIlJyb4WgoMNiiRQv8+OOP4rbJZEJgYKDI9Hv33Xdz7T9w4ECkpaVhw4YN1m2tWrVC48aNxbh04cIFkSF4+vRp1MsqO0THLF++PL744gu88soreY6XL7zwgji2MuvfGWUOrl69WgQdHwePfY5vx+V/MCd8hqhBKEGydgkeFTYOnYK7FujYJq0WurNnzUHBkydguH07x/2qatWgadgILo0aiQ7EPD7aF/6/FWPFwJSZiZQ1a8xfGA0GyL294TV4MNzadxCFVhljjDFHVRLZNhavvvoqPvnkE+ttWr7HWFExJicj4YcZIlNGplbD59XX4NauHb/hDkin0+HIkSN47733rNvkcrkYh/bt22fzMbSdxsLsaCxcs2aNuK7VasUlLUXOfkyNRoM9e/bkGSSkpcY0DloChBajR48Wj6levbrINhw+fLgIHtpCz215fkuQkDk2CgTWKVsX/17aipi0aJR1D0DnGt1Rwavi4zUcuXnTGhTUnjsH6PXW++ncV9OwoQgKaho05KxqZw0SFvaMMf3D+/jjj/Hzzz+LGeM2bdpgzpw5OWaMP//8c2zcuBHHjx+HWq0W+9mycOFC8WWSZmtoQH322WfF62WssNG/24x9+5D8xx8wxseJugnuPXvB65lnIM92EsMYY4w5KvrORcE6OkElFCyk72u//vqrzWybGTNmiCVykydPFrc//fRTbNu2TWTr0GOpPtf+/ftzZNvQd0LKtlmyZEmOE2kKCtJ2xoqa7uoVxH8/FcZY8xI4v0lvQV216Op6sZIVGxsLo9GIcuXK5dhOt89RgMQGOi+2tT9tJ1SrkGoMUuBx3rx5YsJj2rRpuHXrFqKiovJ8HTRGvvbaazm20+RI586dxRhIGddvvPEGUlNTRf1CW2hSZsqUKbm2x8XFiYAoc0wqqNEjKNvSYp3531R+SKmpMJ07B9PZszCdO0vR6nt3KpWQ1aoFeUhdyENCIKtUCSaZDOlUioGCh/l8Dlb4ypQpUzJBwsKeMSbffPMNfvjhByxatAjVqlUTAUU6Js0YW2ZbaACjgF/r1q0xf/78PL+ofv/99yKASa+N0rIpMMlYURSrTly4ALqICHFbXa8efF56CarAIH6zGWOMOYWSzrb5888/8ccff4hA4VNPPSW+P3I2ISts6bt3IeHnn0XmjKZBA/i+OQ4KT09+o9kjoezoVatWYcSIEfDz84NCoRBjZc+ePUXiwf0o2693796iNuH//ve/HPfRWGfRpEkTcc5L5795BQlpjM4+7tKxaem0v7+/SKphTDIYoLt4EdqTJ0UnYv2VKzk6DSsrVICmUSNRV1Bdty7k2f4fzUoXZWmYMaZBkQKNH3zwAfr27Sv2+e2338TMC31hHDRokNhmmf2gTEFbEhISxDHWr1+PLl26WLc3bNiwCN4F5qxMaWlIXrEcaVu3UiERKPz94f3ii3Bp2SrPFH/GGGPMEZVkts2QIUNQpUoV0SX05MmTooYhTVjTSXheeMkde9ST5qQ/fkfa5s3itkefvvAaNIhLyThJNg4F8ag+anZ0O6/sZdr+sP2bNWsmVsXREmKaZClbtqxIbGnevHmOx6WkpIjzZ09PT1F7kAKMD0LHoHNsGuNoQuV+tM3WdubYDFFRSNu5414TkI6dRLDPen90NLQnToigoGg4kpFhvU/m6iomRVwaNhT1BZU2ksFY6aQsDTPGV69eFV8M6RgW3t7eYrCjx1qChA9DgUcq/nr79m2EhISIwTUsLExkFtJMCWMFbeeevnMnkpcugYnqeKhU8OzbDx59+/JMCmOMMVbM2TbZl981aNAAFSpUEJPEly9fRnBwsM1j85I7ll9ScjL083+BdPkyoFZD+cKL0Ddtirj4eH4THWTJ3YNQaSsK6G3fvt3aHITOM+n2mDFjbD6GVrvR/ePHj89xfkrb70fnuoTKKxw+fFgE+LJn+dG5MgX11q1blyOrOi8UePT19eVAILOi4GDivHnm9sb0/06ZDKnr1sGdOmKbTMg8cRLGO9mWuctkoummqCvYqCHUNWpCplDwO+qAlKVhxthy+aB98uPKlSti8KbuUJS9SIMvZRZ269ZNzDDTYH8/nlFm+aG7dAmJC36Fnr4o0hKoZs3g/eJQbsfOGGPMqZV0tk12dD+5dOlSnkFCXnLH8kN38QLipk6FlJAARfny8J80icvJOCFKchk2bJgYd6j2Pq18o2W9ltV0Q4cORaVKlcTkAxk3bhw6dOggElRomfDSpUtFAPCnn37KUaefxjPKlj516pR4DAUhu3fvbg0Q0vX09HRRSoFuW5qM0ONovKVVczRmUudkCiBSIJLOf996660SeZ+YfWYQigAhBQctk2tZl2l//23dT+7raw4KNqSGIw24jIKTcKruxhQg1Ov1orahZaClAtf0pXPHjh1iRuZ+PKPMHkRKSYFh3VqYsrJkZWUDoHjmGUj16kG0zeGirE4zo8wYY8y+sm3uR0FFQhmFeeEld+xh0rZvFxPDMBigadIUfmPGcDM6JzVw4EDExMTgo48+EokrjRs3xubNm62JLTdu3BAr6ixoBRvV3qcklffff1804KSVc5Ya/IRKJlDwkYJ8NFZRoDF7fUGq2X/gwAFxvUaNGjleD62+q1q1qsi2pqacEyZMENnVtJ+lHBhjlixCawahDZZa+srKgVwuywkpS8OMseXSMlhm34cG4/yyPJaKu1rQjAu9ZhrEbeEZZZZXDRqqOZi8cgWk9HTINBp49h8Aj169IHtITRDGGGPMmZREtg0tKaaT8V69eonC+7RihE6Y27dvz7Wo2WOR9HrRkC59+3Zx23PAAHgOeIbrDzo5muzIa8Jj586dubZRk036yQs1FsmruQjp2LGjzSYm2VGtQvphLC9UgzCvACEFDxXe3pwd7cSUpWHGmLoZU6CQ9rEEBSmtmmZRRo0ale/X1qZNG3FJRasrV64srsfHx4sl0lTY2haeUWb30545jcQFC2C4dUvcdm3TBt7PvwCFnx+/WYwxxpgdZNvQ99F//vnHGpCk2tMDBgwQx2TsURnj4xE3bSr0Fy+KYv2+o8fA9QFL2xljzJ5Rk5I8MwkpSEj3M6clkx42FfEYli1bJmaMqeOcZcZ4+fLloiYhfSG8f8Y4PDxczBh/9dVX1hljqptA6dSWL4Rff/21uH/RokUiaEhfBGlWOCIiwlqslb5kUtCPCrhSi/f//vtPbKcUaw8PD3GdApdUi4Zmo6mdO2UKUq1CWoLysK5QluAkLW2hGjjcDt65Oj1RI5LkP35Hxv79Yh9lUBB8hr8MTUhISb9cxoocj32MMWfEYx/Tnj2L+OnTYEpKgrJSJfhNeguqihX5jWEOjcc+xz/XvTtxQp5BwnLTpnNtfSemLC0zxm+//baYCaZOdYmJiWjbtq04ZvZuTvR8FES0aNKkibikeoOUmk1+++03sdyEgpH0Gig4ScfJT4CQOXGnp7VrAereZDRC5u4Or+cGwr1rV+7oxBhjjDHmgCiPIm3LZiT9/rv4/ucSGgrfUW9A7upa0i+NMcYKRFmhAnxeH4nEeXNznPPSJW1X5lEmjjmHIskkdGQ8q+LEsyrUtbh1a5E9qPDyKvbXxlhJ4rGPMeaMeOxzzhUkbm3aImXDemTs3i1OnL0GDoRH335cwJ85DR77nIPhzh2k7fj33uq5Tp05QMicq7sxYwXq9CSTQRkQwAFCxhhjjDFHX0FCX/3c3eE39k24PEKjRMYYKy0oY9B78JCSfhnMznCQkLH8dnqy3M8YY4wxxhwig1AECOm7n+X7X7bvgX4TJsIlW/kjxhhjzNHdKwzIGLvX6ckW7vTEGGOMMeZ4K0hskcuhPXWyuF8SY4wxVqI4SMhYNqKLcV6ZhJIk6jQwxhhjjDEHX0EiSbyChDHGmNPhICFjNjo9iVll6sCd7ZI7PTHGGGOMOQ5eQcIYY4zlxDUJGbuPe8eO0NSpw52eGGOMMcYcfAVJ6rp1tu/kFSSMMcacEGcSFqGNGzfi9ddfF5esdHZ68ntznLik24yx/OGxjzHmjHjsK314BQljBcdjH2OOhTMJi3CwXJc1M2m57N27d1E9HWOM2QUe+xhjzojHvtKLV5Aw9vh47GPM8XCQsIgHSwsOFDLGHB2PfYwxZ8Rjn+OsIGGM5R+PfYw5Jl5uXAyDpQVt56XHjDFHxGMfY8wZ8djHGHNGPPYx5rg4SFhMg6UFBwoZY46Gxz7GmDPisY8x5ox47GPMsXGQsBA9LED4qPsxxlh+fPnll2jRogU8PT0REBCAfv364fz58zn2yczMxOjRo+Hv7w8PDw8MGDAAd+/eLZQ3mMc+xpgz4rGPMeaMeOxjzLFxkLAQ9enTp1D3Y4yx/Ni1a5cIAO7fvx/btm2DXq9H9+7dkZaWZt1nwoQJWL9+PVasWCH2j4yMRP/+/QvlDeaxjzHmjHjsY4w5Ix77GHNsMkmSpJJ+EaVJcnIyvL29kZSUBC8vr0dOv6ZBlbscM8aKUkxMjMgopGBg+/btxXhVtmxZLF68GM8884zY59y5cwgJCcG+ffvQqlWrhx6Txz7GmDPisY8x5ox47GPMeXEmYSGjAGBesyscIGSMFQcKChI/Pz9xeeTIEZFd2LVrV+s+derUQVBQkAgSFgYe+xhjzojHPsaYM+KxjzHHpSzpF+CILJmC2TMKOUDIGCsOJpMJ48ePR5s2bVC/fn2x7c6dO1Cr1fDx8cmxb7ly5cR9tmi1WvGTfUb5YXjsY4w5Ix77GGPOiMc+xhwTBwmLYdDkACFjrLhQbcLTp09jz549BW6GMmXKlFzb4+LioNPp8nxcy5YtRS3E7du3o0uXLuJ2bGxsgV4LY6zolClTht/eQsDf+xhjzojHPsYcD9ckLOT6DIwxVlLGjBmDtWvXYvfu3ahWrZp1+7///isCdgkJCTmyCatUqSKyDqmpSX4yCQMDA3nsY4w5Ff7exxhzRjz2Mea8OJPwEVn6vORn6R1jrHTx9PSETCZDaRyXxo4di9WrV2Pnzp05AoSkWbNmUKlUIrtvwIABYtv58+dx48YNtG7d2uYxNRqN+Mn+HITHPsYcT2kd+4oDj32MOS4e+/LGYx9jzjv2cZDwEdFSO0IZNYwxx1JaM4RpiTF1LqYsQhr0LXUGKevZ1dVVXI4YMQITJ04UzUzod6SgIgUI89PZmPDYx5jjKq1jX3HgsY8xx8VjX9547GPMecc+Xm78iBITE+Hr6ysycOjE29FYlhTevHnTIU8Y+PcrvYrjsyutM8p5veYFCxbgpZdeEtczMzMxadIkLFmyRCwj7tGjB2bPno3y5cvn6zl47CvdeOwr3Yr68yutY19x4LGvdOOxr3Tjsa/k8NhXuvHYV7qV9NjHmYSPSC6Xi0sKEDpiEM2Cfjf+/UovR/78HPl3K+iSkAdxcXHBrFmzxM/j4LHPMTj63w//fqyw8djnGHhsKN0c/fOzRzz2OQZH/9vh369omCNejDHGGGOMMcYYY4wxp8VBQsYYY4wxxhhjjDHGnBwHCR8Rdfv8+OOPc3T9dCT8+5Vujvz5OfLvVho4+vvPv1/pxp8f439b/LfDY4PjcfSx3Z45+nvPv1/pxp9f0eLGJYwxxhhjjDHGGGOMOTnOJGSMMcYYY4wxxhhjzMlxkJAxxhhjjDHGGGOMMSfHQULGGGOMMcYYY4wxxpwcBwkZY4wxxhhjjDHGGHNyThkk3L17N5566ilUrFgRMpkMa9asyXH/3bt38dJLL4n73dzc8MQTT+DixYvW+69duyYeZ+tnxYoV1v1s3b906dIi/d2+/PJLtGjRAp6enggICEC/fv1w/vz5HPtkZmZi9OjR8Pf3h4eHBwYMGCB+5+xu3LiB3r17i9+fjjN58mQYDIYc++zcuRNNmzYV3YVq1KiBhQsXFunvVli/34kTJzB48GAEBgbC1dUVISEhmDFjRq7fzdbnd+fOHbv//fL7b6+0fn70OvP6+4uOji7Rz8/e8djHYx+PfTz2OSMe+3js47GPxz5nxGMfj3089vHY91gkJ7Rp0ybp//7v/6RVq1ZJ9BasXr3aep/JZJJatWoltWvXTjp48KB07tw56bXXXpOCgoKk1NRUsY/BYJCioqJy/EyZMkXy8PCQUlJSrMeiYy9YsCDHfhkZGUX6u/Xo0UM85+nTp6Xjx49LvXr1yvHayciRI6XAwEBp+/bt0uHDh8XvGxYWZr2ffr/69etLXbt2lY4dOyberzJlykjvvfeedZ8rV65Ibm5u0sSJE6WIiAhp5syZkkKhkDZv3mz3v9/8+fOlN998U9q5c6d0+fJl6ffff5dcXV3F72CxY8cO8fmdP38+x+dnNBrt/vfLz7+90vz5paen5/r7o+N26NChxD8/e8djH499PPbx2OeMeOzjsY/HPh77nBGPfTz28djHY9/jcMogYXb3BwkpqEDbKIhhQYGFsmXLSj///HOex2ncuLH08ssvP/DYJSE6Olq8jl27donbiYmJkkqlklasWGHd5+zZs2Kfffv2Wf+HIpfLpTt37lj3mTNnjuTl5SVptVpx++2335bq1auX47kGDhwogjX2/vvZ8sYbb0idOnXKFWRKSEiQStLj/n4P+7fnSJ8fHYMe89tvv9nd52fPeOzjsY/w2Mdjn7PhsY/HPsJjH499zobHPh77CI99PPblh1MuN34QrVYrLl1cXKzb5HK5WJK5Z88em485cuQIjh8/jhEjRuS6j5ZNlilTBqGhofj1118pKIvilJSUJC79/Pysr1Wv16Nr167WferUqYOgoCDs27dP3KbLBg0aoFy5ctZ9evTogeTkZJw5c8a6T/ZjWPaxHMOef7+8jmM5RnaNGzdGhQoV0K1bN+zduxfFrSC/34P+7TnS5/fbb7+JZfHPPPOM3X1+pQmPfTz22dPfDo99PPYVFx77eOzLjse+osXf++wHj3089mXHY1/RSipl57zKAh/BwVg+nPfeew/z5s2Du7s7pk2bhlu3biEqKsrmY+bPny/q2oWFheXY/sknn6Bz587iw9y6dSveeOMNpKam4s033yyW38VkMmH8+PFo06YN6tevL7ZRTTa1Wg0fH58c+1JA0FKvjS6zBwgt91vue9A+FEjMyMgQtf7s9fe7X3h4OJYtW4aNGzdat9Ef2dy5c9G8eXPxP9FffvkFHTt2xIEDB0Qdv+JQkN/vYf/2HOnzo7+/IUOG5HjN9vD5lTY89vHYZy9/Ozz23cNjX9HjsY/HPsJjH3/vczY89vHYR3js47HPFg4S3kelUmHVqlUiK5AivQqFQkR4e/bsaTMLkAIqixcvxocffpjrvuzbmjRpgrS0NHz77bfFFiSkTLLTp0/nmQFZ2hXG70eP79u3Lz7++GN0797dur127drix4ICwJcvXxYB499//x32/vuV9L+94vr8aKbl7NmzuT4Te/j8Shse+0oPHvvyxmMfj32Pise+0oPHvrzx2Mdj36Pisa/04LEvbzz21S6Sc15ebmxDs2bNxPLhxMREkT24efNmxMXFoXr16rn2XblyJdLT0zF06NCHvtktW7YUGYmW9O6iNGbMGGzYsAE7duxA5cqVrdvLly8PnU4nfrfsqHss3WfZ5/5uuZbbD9vHy8urWLLQCvL7WURERKBLly547bXX8MEHHzz0OWnZ7qVLl1AcCuP3e9C/PUf4/AhlOVF6Nf3N2tPnV1rx2Mdjny089hUeHvvsE499PPbZwmNf4eGxzz7x2Mdjny089hWeUjv2SU4uP81FLly4IBp5bNmyJdd91FF1wIAB+Xquzz77TPL19ZWKEnVnHj16tFSxYkXxuu9naQyxcuVK6zbq4Gyrccndu3et+8ybN080LsnMzLQ2vqAOyNkNHjy4yBtfFMbvR6gxTUBAgDR58uR8Pzd1e3766ael0vD7PezfXmn//Ah1EqeO4tm7Upf051ea8NjHY19+8dhXcDz22Q8e+3jsyy8e+wqOxz77wWMfj335xWNfwZX2sc8pg4T0Rh87dkz80AcxdepUcf369evi/uXLl4vuqJcvX5bWrFkjValSRerfv3+u41y8eFGSyWTS33//neu+devWiW7Ip06dEvvNnj1bcnNzkz766KMi/d1GjRoleXt7Szt37pSioqKsP+np6dZ9Ro4cKQUFBUn//vuvdPjwYal169bix8JgMIgAUvfu3aXjx49LmzdvFt2d33vvPes+V7LaiVOQjbrPzpo1S1IoFGJfe//96DOh3+eFF17IcQzqkmsxbdo08dnTZ0f7jxs3TgRO//nnH7v//fLzb680f34Wv/zyi+Ti4mKzg3FJfX72jsc+Hvt47OOxzxnx2MdjH499PPY5Ix77eOzjsY/HvsfhlEFCCgBScPD+n2HDhon7Z8yYIVWuXFlEdylY8cEHH0harTbXcShoFhgYKBmNxlz3UeCwcePGIurr7u4uNWrUSJo7d67NfQuTrd+LfhYsWGDdJyMjQ7Q/p8wyChRRpJkCNdldu3ZN6tmzp+Tq6iqVKVNGmjRpkqTX63O9j/Q7qtVqqXr16jmew55/v48//tjmMSgYbPH1119LwcHBIgjl5+cndezYUQStSsPvl99/e6X187OgwOGQIUNsPk9JfX72jsc+Hvt47OOxzxnx2MdjH499PPY5Ix77eOzjsY/Hvscho/8UbMEyY4wxxhhjjDHGGGOsNOPGJYwxxhhjjDHGGGOMOTkOEjLGGGOMMcYYY4wx5uQ4SMgYY4wxxhhjjDHGmJPjICFjjDHGGGOMMcYYY06Og4SMMcYYY4wxxhhjjDk5DhIyxhhjjDHGGGOMMebkOEjIGGOMMcYYY4wxxpiT4yAhY4wxxhhjjDHGGGNOjoOEjDHGGGOMMcYYY4w5OQ4SMsYYY4wxxhhjjDHm5DhIyBhjjDHGGGOMMcaYk+MgIWOMMcYYY4wxxhhjcG7/D/w85aITjF1zAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "id": "s6-md", + "metadata": {}, + "source": [ + "### 6. Where is the biggest climate-attributable shift?\n", + "\n", + "Pivot the DataFrame to compute the delta (RCP8.5 @ 2080 minus baseline) per (hazard, metric). Ranks which dimensions of risk move the most under a worst-case future." + ] + }, + { + "cell_type": "code", + "id": "s6-code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-29T00:16:55.406847Z", + "start_time": "2026-05-29T00:16:55.386381Z" + } + }, + "source": "wide = df.pivot_table(\n index=[\"hazard\", \"metric\"],\n columns=[\"scenario\", \"year\"],\n values=\"value\",\n aggfunc=\"first\",\n)\n\nbaseline = wide[(\"baseline\", chd.BASELINE_YEAR)]\nworst_case = wide[(\"rcp8p5\", 2080)]\ndelta = (worst_case - baseline).dropna().sort_index()\n\ndelta.to_frame(\"rcp8p5_2080_minus_baseline\")", + "outputs": [ + { + "data": { + "text/plain": [ + " rcp8p5_2080_minus_baseline\n", + "hazard metric \n", + "coastal_floods average_annual_loss 0.000000\n", + " depth_meters 0.000000\n", + " intensity 0.000000\n", + " probability 0.000000\n", + "cyclones average_annual_loss 0.027791\n", + " intensity 0.098297\n", + " probability 0.118995\n", + " wind_speed_mps 10.353498\n", + "fluvial_floods average_annual_loss -0.000059\n", + " depth_meters -0.069956\n", + " intensity -0.015193\n", + " probability -0.006244\n", + "wildfire average_annual_loss 0.000731\n", + " fire_danger_days 35.000000\n", + " intensity 0.027271\n", + " probability 0.012807" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
rcp8p5_2080_minus_baseline
hazardmetric
coastal_floodsaverage_annual_loss0.000000
depth_meters0.000000
intensity0.000000
probability0.000000
cyclonesaverage_annual_loss0.027791
intensity0.098297
probability0.118995
wind_speed_mps10.353498
fluvial_floodsaverage_annual_loss-0.000059
depth_meters-0.069956
intensity-0.015193
probability-0.006244
wildfireaverage_annual_loss0.000731
fire_danger_days35.000000
intensity0.027271
probability0.012807
\n", + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 6 + }, + { + "cell_type": "markdown", + "id": "s7-md", + "metadata": {}, + "source": [ + "### Next steps\n", + "\n", + "* **A different asset.** Try changing the `ASSET` row in section 2.\n", + "* **Compare two assets.** Run sections 2-5 twice with different `ASSET` rows and overlay.\n", + "* **Custom variable filter.** `chd.list_variables(metric=\"fire_danger_days\")` to focus on one metric across hazards (where applicable)." + ] + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "82a20b6dcd1b6e66" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (cecil_examples)", + "language": "python", + "name": "cecil-examples" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6069a6cc417da906fe860b58e15a7a25e012c6a1 Mon Sep 17 00:00:00 2001 From: Nic Pittman Date: Fri, 29 May 2026 11:38:47 +1000 Subject: [PATCH 2/8] clearer comments --- use-cases/emmi-chd/README.md | 4 +++- .../emmi-chd/single-asset-deep-dive.ipynb | 21 ++++++++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/use-cases/emmi-chd/README.md b/use-cases/emmi-chd/README.md index 3e33502..91ae84c 100644 --- a/use-cases/emmi-chd/README.md +++ b/use-cases/emmi-chd/README.md @@ -35,4 +35,6 @@ The examples here use 1 hectare AOIs per asset (well below the 0.1° / ~11 km CH ## License -Released under the [MIT License](../../LICENSE) (same as the rest of `cecil_examples`). +The example code in this directory (notebooks, `chd.py`) is released under the [MIT License](../../LICENSE), same as the rest of `cecil_examples`. + +The Emmi Climate Hazard Diagnostics **datasets themselves are commercial** and licensed through Cecil under their standard data agreement. Running the notebooks creates Cecil subscriptions against your account; you'll need a valid Cecil API key and the associated data entitlement. See the [Cecil dataset pages](https://docs.cecil.earth/datasets) for current licensing terms, and contact Cecil or Emmi for commercial use beyond the example. diff --git a/use-cases/emmi-chd/single-asset-deep-dive.ipynb b/use-cases/emmi-chd/single-asset-deep-dive.ipynb index 7a525f0..bd945db 100644 --- a/use-cases/emmi-chd/single-asset-deep-dive.ipynb +++ b/use-cases/emmi-chd/single-asset-deep-dive.ipynb @@ -4,7 +4,26 @@ "cell_type": "markdown", "id": "title", "metadata": {}, - "source": "## Single-asset climate deep-dive\n\nCompanion to `portfolio-screening-east-texas.ipynb`. Instead of screening a portfolio, this notebook walks through **one** asset and pulls every variable Emmi publishes for it: intensity, probability, AAL, fire-danger-days, wind speed, depth, across baseline + four RCP scenarios.\n\nWe pick **Channelview Cogeneration Plant**, on the Houston Ship Channel. It's the most multi-hazard-exposed asset in the East Texas portfolio:\n\n* **Wildfire**: nonzero from East Texas fire weather\n* **Tropical cyclones**: Gulf coast, directly in the storm track\n* **Fluvial flooding**: the only asset in the portfolio with nonzero fluvial-flood AAL at a 1 ha AOI (it sits on the Ship Channel)\n* **Coastal flooding**: zero at this point. Coastal-flood mapping at 0.1° resolution doesn't reach Channelview's pixel even though it's on the Bay. See the caveat below.\n\n> **About zeros in CHD floods:** the coastal-flood and fluvial-flood datasets only have nonzero values at pixels Emmi has modelled for storm-surge / river-flood exposure. With a 1 ha point AOI, a small offset can put you on a pixel that isn't flood-mapped (so you see zero), even if a neighbouring pixel is. To screen for flood risk at scale, either pick AOIs that are *literally* on the coast/in a flood plain, or use a larger AOI (e.g. 100 ha) that intersects multiple grid cells.\n\nUses `chd.load()` + `chd.sample()` directly (the lower-level primitives), rather than the one-call `chd.screen()`. Subscriptions are reused from the portfolio notebook's `tag=\"emmi-chd-example\"` namespace, so this notebook costs nothing if you've already run it.\n\n### Prereqs\n\nSame as the portfolio notebook: `cecil`, `pandas`, `matplotlib`, and `CECIL_API_KEY` in the environment." + "source": [ + "## Single-asset climate deep-dive\n", + "\n", + "Companion to `portfolio-screening-east-texas.ipynb`. Instead of screening a portfolio, this notebook walks through one asset and pulls every variable Emmi publishes for it: intensity, probability, AAL, fire-danger-days, wind speed, depth, across baseline + four RCP scenarios.\n", + "\n", + "We pick **Channelview Cogeneration Plant**, on the Houston Ship Channel. It's the most multi-hazard-exposed asset in the East Texas portfolio:\n", + "\n", + "* **Wildfire**: nonzero from East Texas fire weather\n", + "* **Tropical cyclones**: Gulf coast, directly in the storm track\n", + "* **Fluvial flooding**: the only asset in the portfolio with nonzero fluvial-flood AAL at a 1 ha AOI (it sits on the Ship Channel)\n", + "* **Coastal flooding**: zero at this point. Coastal-flood mapping at 0.1° resolution doesn't reach Channelview's pixel even though it's on the Bay. See the caveat below.\n", + "\n", + "> **About zeros in CHD floods:** the coastal-flood and fluvial-flood datasets only have nonzero values at pixels Emmi has modelled for storm-surge / river-flood exposure. With a 1 ha point AOI, a small offset can put you on a pixel that isn't flood-mapped (so you see zero), even if a neighbouring pixel is. To screen for flood risk at scale, either pick AOIs that are on the coast/in a flood plain, or use a larger AOI (e.g. 100 ha) that intersects multiple grid cells.\n", + "\n", + "Uses `chd.load()` + `chd.sample()` directly (the lower-level primitives), rather than the one-call `chd.screen()`. Subscriptions are reused from the portfolio notebook's `tag=\"emmi-chd-example\"` namespace, so this notebook costs nothing if you've already run it.\n", + "\n", + "### Prereqs\n", + "\n", + "Same as the portfolio notebook: `cecil`, `pandas`, `matplotlib`, and `CECIL_API_KEY` in the environment." + ] }, { "cell_type": "markdown", From b889ff67f31d4b4c2cb33a0f5eef755b89b2a573 Mon Sep 17 00:00:00 2001 From: Nic Pittman Date: Mon, 1 Jun 2026 17:08:07 +1000 Subject: [PATCH 3/8] cleanup notebooks and rerun --- use-cases/emmi-chd/README.md | 8 +- use-cases/emmi-chd/chd.py | 107 +++----- .../portfolio-screening-east-texas.ipynb | 242 +++++++++++------- .../emmi-chd/single-asset-deep-dive.ipynb | 70 ++--- 4 files changed, 206 insertions(+), 221 deletions(-) diff --git a/use-cases/emmi-chd/README.md b/use-cases/emmi-chd/README.md index 91ae84c..227f54d 100644 --- a/use-cases/emmi-chd/README.md +++ b/use-cases/emmi-chd/README.md @@ -1,6 +1,6 @@ # Emmi Climate Hazard Diagnostics -End-to-end examples using Emmi's Climate Hazard Diagnostics (CHD) datasets via Cecil: +Portfolio and single-asset examples using Emmi's Climate Hazard Diagnostics (CHD) datasets via Cecil: - [Wildfire](https://docs.cecil.earth/datasets/a70e1872-aaa6-480d-b2fc-f778e0343de5) - [Tropical Cyclones](https://docs.cecil.earth/datasets/158e774c-fd11-4402-b6ce-2596960f4637) @@ -9,7 +9,7 @@ End-to-end examples using Emmi's Climate Hazard Diagnostics (CHD) datasets via C See the Cecil Docs for the full per-dataset variable list and methodology notes. -Wildfire and Cyclones are provided on a ~0.1° (~11 km) (Floods are ~0.0089°, ~1km) global grid for a historical baseline (1980, calibrated to present-day) and 2030 / 2050 / 2080 under IPCC RCP2.6 / 4.5 / 6.0 / 8.5. Floods are not provided for RCPs 2.5 or 6.0 +Wildfire and cyclones are provided on a ~0.1° (~11 km) global grid; floods are finer at ~0.0089° (~1 km). All datasets carry a historical baseline (1980, calibrated to present-day) and futures at 2030 / 2050 / 2080 under IPCC Representative Concentration Pathways (RCPs) 2.6 / 4.5 / 6.0 / 8.5. Floods are not provided for RCP2.6 or RCP6.0. ## Examples @@ -29,7 +29,7 @@ Both notebooks share a `chd.py` helper (in this directory) that wraps the Cecil ## Cost note -Cecil charges per hectare of AOI. Emmi CHD is **bundle priced**: one `$/ha` covers all four hazard datasets and every layer (intensity, probability, AAL, fire-danger-days) across baseline plus four RCP scenarios. You do **not** multiply by the number of datasets. +Cecil charges per hectare of Area of Interest (AOI). Emmi CHD is **bundle priced**: one `$/ha` covers all four hazard datasets and every layer they publish (intensity, probability, Average Annual Loss (AAL), fire-danger-days, wind speed, flood depth) across baseline plus four RCP scenarios. You do **not** multiply by the number of datasets. The examples here use 1 hectare AOIs per asset (well below the 0.1° / ~11 km CHD pixel), so the whole 5-asset portfolio costs cents at the subscription tier. @@ -37,4 +37,4 @@ The examples here use 1 hectare AOIs per asset (well below the 0.1° / ~11 km CH The example code in this directory (notebooks, `chd.py`) is released under the [MIT License](../../LICENSE), same as the rest of `cecil_examples`. -The Emmi Climate Hazard Diagnostics **datasets themselves are commercial** and licensed through Cecil under their standard data agreement. Running the notebooks creates Cecil subscriptions against your account; you'll need a valid Cecil API key and the associated data entitlement. See the [Cecil dataset pages](https://docs.cecil.earth/datasets) for current licensing terms, and contact Cecil or Emmi for commercial use beyond the example. +The Emmi Climate Hazard Diagnostics **datasets themselves are commercial** and licensed through Cecil under their standard data agreement. Running the notebooks creates Cecil subscriptions against your account; you'll need a valid Cecil API key and the associated data entitlement. See the [Cecil dataset pages](https://docs.cecil.earth/datasets) for current licensing terms, and contact Cecil for commercial use beyond this example. diff --git a/use-cases/emmi-chd/chd.py b/use-cases/emmi-chd/chd.py index 4e5fb94..8ee29a2 100644 --- a/use-cases/emmi-chd/chd.py +++ b/use-cases/emmi-chd/chd.py @@ -1,13 +1,12 @@ -"""Emmi Climate Hazard Diagnostics helpers for the Cecil SDK. +"""Emmi Climate Hazard Diagnostics (CHD) helpers for the Cecil SDK. Plain functions composing ``cecil.Client`` calls into the common CHD patterns: -hectare-scale point AOIs, safe re-runnable provisioning, scenario-aware -sampling. Requires ``CECIL_API_KEY`` in the environment. +hectare-scale point Areas of Interest (AOIs), safe re-runnable provisioning, +scenario-aware sampling. Requires ``CECIL_API_KEY`` in the environment. Public API: DATASETS, METRICS, SCENARIOS_BY_HAZARD catalogue list_variables discover valid variable names - verify_catalog cross-check the catalogue against the live API point_aoi build a square AOI for an asset estimate_cost preview $ before subscribing provision create or reuse AOIs + subscriptions @@ -64,28 +63,15 @@ VALID_FUTURE_YEARS = (2030, 2050, 2080) BASELINE_YEAR = 1980 -# Variables that exist in Cecil's response but are deliberately omitted from -# METRICS because they aren't necessary for portfolio-style continuous sampling. -# verify_catalog() subtracts these so they don't show up as drift. -KNOWN_EXCLUDED = frozenset(f"land_mask_{s}" for s in VALID_SCENARIOS) - - def list_variables(metric: str | None = None, scenario: str | None = None, - hazard: str | None = None, - client=None, - verify: bool = True) -> list[str]: + hazard: str | None = None) -> list[str]: """Return CHD variable names matching the filters. ``None`` means any. list_variables() # every valid name list_variables(metric="intensity") # intensity_* across applicable hazards list_variables(scenario="rcp4p5") # *_rcp4p5 across applicable metrics list_variables(hazard="wildfire") # only what wildfire publishes - - If ``client`` is provided and ``verify=True`` (default), the live Cecil - catalogue is cross-checked via :func:`verify_catalog` and any drift is - logged as warnings. Pass ``verify=False`` to skip the check even when a - client is given. With no client, returns the static catalogue. """ names = sorted({ f"{m}_{s}" @@ -93,57 +79,12 @@ def list_variables(metric: str | None = None, for h in hazards if hazard in (None, h) for s in SCENARIOS_BY_HAZARD[h] if scenario in (None, s) }) - if client is not None and verify: - _log_catalog_drift(verify_catalog(client)) return names -def _log_catalog_drift(report: dict) -> None: - """Emit a warning for each hazard with missing or extra variables.""" - for hazard, info in report.items(): - if info["missing"]: - log.warning(f"{hazard}: catalogue expects variables not in live data: {sorted(info['missing'])}") - if info["extra"]: - log.warning(f"{hazard}: live data has variables not in catalogue: {sorted(info['extra'])}") - - _ALL_VARIABLES = frozenset(list_variables()) -def verify_catalog(client) -> dict[str, dict]: - """Cross-check the hardcoded catalogue against Cecil's live dataset metadata. - - Queries each dataset in :data:`DATASETS` for its actual variable list and - compares to what :func:`list_variables` predicts. Useful at session start - to detect drift if Emmi adds/renames variables between releases. - - Returns ``{hazard: {...}}`` with these fields per hazard: - - * ``missing`` -- expected but not in live (drift: maybe Emmi removed it). - * ``extra`` -- in live but neither expected nor in :data:`KNOWN_EXCLUDED` - (drift: maybe Emmi added something new). - * ``excluded`` -- live variables that match :data:`KNOWN_EXCLUDED`. Confirms - which intentional omissions are actually present. If this - shrinks unexpectedly, our exclusion list is stale. - * ``live``, ``expected`` -- the raw sets, for reference. - - Non-empty ``missing`` or ``extra`` indicates the catalogue should be updated. - """ - report = {} - for hazard, dataset_id in DATASETS.items(): - ds = client.get_dataset(dataset_id) - live = {v.name for v in ds.variables} - expected = set(list_variables(hazard=hazard)) - report[hazard] = { - "live": live, - "expected": expected, - "missing": expected - live, - "extra": live - expected - KNOWN_EXCLUDED, - "excluded": live & KNOWN_EXCLUDED, - } - return report - - # ---------- AOI geometry ------------------------------------------------- def point_aoi(lat: float, lon: float, target_ha: float = 1.0) -> dict: @@ -170,27 +111,36 @@ def point_aoi(lat: float, lon: float, target_ha: float = 1.0) -> dict: # ---------- Cost --------------------------------------------------------- -def estimate_cost(portfolio: pd.DataFrame, target_ha: float = 1.0) -> dict: - """Print and return a bundle-priced cost estimate. +def estimate_cost(client, portfolio: pd.DataFrame, target_ha: float = 1.0) -> dict: + """Print and return a bundle-priced cost estimate, using live Cecil rates. + + Per-hectare rates are fetched from ``Dataset.pricing.tiers`` on one CHD + dataset (CHD is bundle priced, so all four share the same per-ha rate). + Billable hectares = ``len(portfolio) * target_ha``. - CHD is bundle priced: one $/ha covers all four hazard datasets, so - billable hectares = ``len(portfolio) * target_ha``. + Returns ``{"total_ha": float, "rates_per_ha": {tier: $/ha}, + "totals": {tier: $}}``. """ n_assets = len(portfolio) total_ha = float(n_assets * target_ha) - entry_usd = total_ha * 5.0 - subscription_usd = total_ha * 0.5 + + # All four CHD datasets share bundle pricing; query one. + ds = client.get_dataset(DATASETS["wildfire"]) + rates = {t.volume.nominal: t.price.amount for t in (ds.pricing.tiers or [])} + totals = {tier: total_ha * rate for tier, rate in rates.items()} log.info(f"Per-asset AOI area: {target_ha:.3f} ha") - log.info(f"Assets: {n_assets}, hazards bundled into one $/ha charge") + log.info(f"Assets: {n_assets} (all four hazards bundled into one $/ha charge)") log.info(f"Total billable hectares: {total_ha:.3f}") - log.info(f"Entry tier @ $5.0/ha: ${entry_usd:>8,.2f}") - log.info(f"Subscription tier @ $0.5/ha: ${subscription_usd:>8,.2f}") + for tier, rate in rates.items(): + log.info(f" {tier:25s} @ ${rate}/ha: ${totals[tier]:>8,.2f}") + for line in (ds.pricing.description or []): + log.info(f"Pricing details: {line}") return { "total_ha": total_ha, - "entry_usd": entry_usd, - "subscription_usd": subscription_usd, + "rates_per_ha": rates, + "totals": totals, } @@ -291,7 +241,7 @@ def sample(ds: xr.Dataset, variable: str, year: int | None = None) -> float: return float(da.mean(skipna=True).values) -# ---------- Screen orchestrator ------------------------------------------ +# ---------- Get hazard data for portfolio ------------------------------------------ def screen( client, @@ -326,7 +276,7 @@ def screen( tag: inserted into the AOI ``external_ref`` for namespacing. subs: reuse the output of :func:`provision` instead of re-running it. Useful when calling :func:`screen` multiple times. - cache: reuse an xarray cache across calls. Each subscription + cache: dict; reuse xarray cache across calls. Each subscription downloads once; repeat screens are much faster. require_confirmation: print cost and prompt y/n. Returns ``None`` on abort. @@ -352,7 +302,7 @@ def screen( raise ValueError(f"Unknown hazard: {h!r}. Valid: {list(DATASETS)}") if require_confirmation: - estimate_cost(portfolio, target_ha=target_ha) + estimate_cost(client, portfolio, target_ha=target_ha) try: response = input("\nProceed? [y/N]: ").strip().lower() except EOFError: @@ -381,7 +331,8 @@ def screen( for r in records ] - # Sum Hazard Aggregation recommended per https://support.emmi.io/questions/climate-hazard-diagnostics-multi-hazard-aggregation + # Aggregate across hazards by summing. See: + # https://support.emmi.io/questions/climate-hazard-diagnostics-multi-hazard-aggregation df["total"] = df[list(hazards)].sum(axis=1, skipna=False) if use_value: df["total_usd"] = df["total"] * df["value_usd"] diff --git a/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb b/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb index 01a187b..763f07c 100644 --- a/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb +++ b/use-cases/emmi-chd/portfolio-screening-east-texas.ipynb @@ -4,7 +4,37 @@ "cell_type": "markdown", "id": "title", "metadata": {}, - "source": "## Multi-hazard climate risk screening (East Texas power portfolio)\n\nEnd-to-end multi-hazard climate-risk screening for a small US power-generation portfolio in East Texas, using Emmi's Climate Hazard Diagnostics (CHD) datasets via the Cecil SDK. The heavy lifting lives in the `chd.py` helper in this directory; this notebook composes the helpers into a short, readable workflow.\n\nFor a single-asset walkthrough that pulls every variable Emmi publishes across baseline + four RCP scenarios, see [`single-asset-deep-dive.ipynb`](single-asset-deep-dive.ipynb) next to this one.\n\n### What you need\n\n```bash\npip install cecil matplotlib pandas folium\n```\n\nA Cecil API key exported in your shell:\n\n```bash\nexport CECIL_API_KEY=\"your-key-here\"\n```\n\nIf you'd rather load the key from a `.env` file, see [`tutorials/cecil-data-analysis-xql/scripts/_env.py`](../../tutorials/cecil-data-analysis-xql/scripts/_env.py) for the repo's reference dotenv loader, or use `python-dotenv` directly.\n\n### What the helper provides\n\n* `chd.DATASETS` and `chd.METRICS`: the four CHD UUIDs and the metric catalog.\n* `chd.list_variables(...)`: discoverable variable names with filters. Pass `client=client` to also cross-check against the live Cecil catalogue.\n* `chd.verify_catalog(client)`: cross-check the hardcoded catalogue against Cecil's live dataset metadata. Useful at session start to spot drift.\n* `chd.point_aoi(lat, lon, target_ha)`: latitude-corrected square AOIs.\n* `chd.estimate_cost(...)`: bundle-aware cost preview.\n* `chd.provision(...)`: creates or reuses AOIs and subscriptions; safe to re-run.\n* `chd.load(...)` and `chd.sample(...)`: cacheable I/O and typed sampling.\n* `chd.screen(...)`: one-call orchestration. Default: per-asset per-hazard climate-attributable delta in average annual loss under RCP4.5 at 2050. Long-format DataFrame, NaN propagates for missing combos (e.g. RCP2.6 on floods)." + "source": [ + "## Multi-hazard climate risk screening (East Texas power portfolio)\n", + "\n", + "Multi-hazard climate-risk screening for a small US power-generation portfolio in East Texas, using Emmi's Climate Hazard Diagnostics (CHD) datasets via the Cecil SDK. The reusable helpers live in `chd.py`; this notebook calls them in a short portfolio focused workflow.\n", + "\n", + "For a single-asset walkthrough that pulls every variable Emmi publishes across baseline + four Representative Concentration Pathway (RCP) climate scenarios, see [`single-asset-deep-dive.ipynb`](single-asset-deep-dive.ipynb) next to this one.\n", + "\n", + "### What you need\n", + "\n", + "```bash\n", + "pip install cecil matplotlib pandas folium\n", + "```\n", + "\n", + "A Cecil API key exported in your shell with access to the Emmi CHD Data:\n", + "\n", + "```bash\n", + "export CECIL_API_KEY=\"your-key-here\"\n", + "```\n", + "\n", + "If you'd rather load the key from a `.env` file, see [`tutorials/cecil-data-analysis-xql/scripts/_env.py`](../../tutorials/cecil-data-analysis-xql/scripts/_env.py) for the repo's reference dotenv loader, or use `python-dotenv` directly.\n", + "\n", + "### What the helper provides\n", + "\n", + "* `chd.DATASETS` and `chd.METRICS`: the four CHD UUIDs and the metric catalog.\n", + "* `chd.list_variables(...)`: discoverable variable names with filters.\n", + "* `chd.point_aoi(lat, lon, target_ha)`: latitude-corrected square Areas of Interest (AOIs).\n", + "* `chd.estimate_cost(...)`: bundle-aware cost preview, pulled live from Cecil.\n", + "* `chd.provision(...)`: creates or reuses AOIs and subscriptions; safe to re-run.\n", + "* `chd.load(...)` and `chd.sample(...)`: cacheable I/O and typed sampling.\n", + "* `chd.screen(...)`: one-call portfolio screen. Default: per-asset per-hazard climate-attributable delta in average annual loss under RCP4.5 at 2050. Long-format DataFrame; NaN propagates for missing combos (e.g. RCP2.6 on floods)." + ] }, { "cell_type": "markdown", @@ -19,8 +49,8 @@ "id": "s1-code", "metadata": { "ExecuteTime": { - "end_time": "2026-05-29T00:08:02.722423Z", - "start_time": "2026-05-29T00:08:01.810684Z" + "end_time": "2026-06-01T06:24:57.908652Z", + "start_time": "2026-06-01T06:24:57.027887Z" } }, "source": [ @@ -47,25 +77,15 @@ "cell_type": "markdown", "id": "s2-md", "metadata": {}, - "source": [ - "### 2. Define the portfolio\n", - "\n", - "Each row is one asset (Powerplants in this example). Replace these with your own assets to apply the notebook to a different portfolio.\n", - "\n", - "**Source:** asset names and coordinates are from [Climate TRACE](https://climatetrace.org)'s `electricity-generation` inventory (CC BY 4.0).\n", - "\n", - "Asset values are illustrative placeholders (Climate TRACE publishes emissions, not financial valuations). To cite the underlying records:\n", - "\n", - "> Freeman, J. et al. (2025). *Power sector: Emissions from Electricity Generation.* WattTime, Pixel Scientia Labs, Global Energy Monitor. Climate TRACE Emissions Inventory v5.4.1. https://climatetrace.org" - ] + "source": "### 2. Define the portfolio\n\nEach row is one asset (a power plant, in this example). Replace these with your own assets to apply the notebook to a different portfolio.\n\n**Source:** asset names and coordinates are from [Climate TRACE](https://climatetrace.org)'s `electricity-generation` inventory (CC BY 4.0).\n\nAsset values are illustrative placeholders (Climate TRACE publishes emissions, not financial valuations). To cite the underlying records:\n\n> Freeman, J. et al. (2025). *Power sector: Emissions from Electricity Generation.* WattTime, Pixel Scientia Labs, Global Energy Monitor. Climate TRACE Emissions Inventory v5.4.1. https://climatetrace.org" }, { "cell_type": "code", "id": "s2-code", "metadata": { "ExecuteTime": { - "end_time": "2026-05-29T00:08:02.758513Z", - "start_time": "2026-05-29T00:08:02.725705Z" + "end_time": "2026-06-01T06:24:57.946254Z", + "start_time": "2026-06-01T06:24:57.914346Z" } }, "source": [ @@ -167,19 +187,15 @@ "cell_type": "markdown", "id": "s3-md", "metadata": {}, - "source": [ - "### 3. Show the assets on a map\n", - "\n", - "Optional Sanity check the coordinates before subscribing (using folium)." - ] + "source": "### 3. Show the assets on a map\n\nOptional: sanity-check the coordinates before subscribing. Uses folium." }, { "cell_type": "code", "id": "s3-code", "metadata": { "ExecuteTime": { - "end_time": "2026-05-29T00:08:02.888338Z", - "start_time": "2026-05-29T00:08:02.780541Z" + "end_time": "2026-06-01T06:24:58.067900Z", + "start_time": "2026-06-01T06:24:57.968288Z" } }, "source": [ @@ -208,7 +224,7 @@ { "data": { "text/plain": [ - "" + "" ], "text/html": [ "" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 3 + "execution_count": 5 }, { "cell_type": "markdown", @@ -448,8 +448,8 @@ "id": "s4-code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T06:12:16.119926Z", - "start_time": "2026-06-02T06:12:13.802070Z" + "end_time": "2026-06-02T06:46:26.408411Z", + "start_time": "2026-06-02T06:46:24.551488Z" } }, "source": [ @@ -500,7 +500,7 @@ ] } ], - "execution_count": 2 + "execution_count": 6 }, { "cell_type": "markdown", @@ -517,8 +517,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:13:44.338571Z", - "start_time": "2026-06-02T01:13:43.179880Z" + "end_time": "2026-06-02T06:46:28.315029Z", + "start_time": "2026-06-02T06:46:26.432206Z" } }, "cell_type": "code", @@ -545,7 +545,7 @@ ] } ], - "execution_count": 5 + "execution_count": 7 }, { "cell_type": "markdown", @@ -570,8 +570,8 @@ "id": "s6-code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:20:22.527630Z", - "start_time": "2026-06-02T01:13:44.369222Z" + "end_time": "2026-06-02T06:50:43.527754Z", + "start_time": "2026-06-02T06:46:28.325322Z" } }, "source": [ @@ -713,12 +713,12 @@ "" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 6 + "execution_count": 8 }, { "cell_type": "markdown", @@ -735,8 +735,8 @@ "id": "s7-code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:20:23.014181Z", - "start_time": "2026-06-02T01:20:22.823868Z" + "end_time": "2026-06-02T06:50:43.810664Z", + "start_time": "2026-06-02T06:50:43.610433Z" } }, "source": "DELTA_COLOR = \"#e45756\" # Vega red\n\n# Filter to one (scenario, year, metric) so the chart has one bar per asset per panel.\nplot_df = risk[\n (risk[\"scenario\"] == SCENARIO)\n & (risk[\"year\"] == SCENARIO_YEAR)\n & (risk[\"metric\"] == \"average_annual_loss\")\n]\n\nhazards = list(chd.DATASETS.keys())\norder = plot_df.sort_values(\"total\", ascending=True, na_position=\"first\")[\"name\"].tolist()\ndf = plot_df.set_index(\"name\").loc[order]\n\nfig, axes = plt.subplots(2, 2, figsize=(12, 6.5), sharey=True)\nfor ax, hazard in zip(axes.flatten(), hazards):\n values = df[hazard]\n y = np.arange(len(order))\n ax.barh(y, values.fillna(0), height=0.7, color=DELTA_COLOR)\n ax.set_yticks(y)\n ax.set_yticklabels(order)\n ax.set_title(hazard.replace(\"_\", \" \"), fontsize=11, loc=\"left\", pad=8)\n ax.set_xlabel(\"delta AAL (fraction)\")\n ax.grid(axis=\"x\", color=\"0.92\", linewidth=0.7, zorder=0)\n ax.set_axisbelow(True)\n for spine in (\"top\", \"right\"):\n ax.spines[spine].set_visible(False)\n\nfig.suptitle(f\"Per-hazard delta AAL ({SCENARIO} @ {SCENARIO_YEAR} minus baseline)\",\n fontsize=13, fontweight=\"semibold\")\nplt.tight_layout()\nplt.show()", @@ -752,7 +752,7 @@ "output_type": "display_data" } ], - "execution_count": 7 + "execution_count": 9 }, { "cell_type": "markdown", @@ -765,8 +765,8 @@ "id": "s8-code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:20:23.058117Z", - "start_time": "2026-06-02T01:20:23.017347Z" + "end_time": "2026-06-02T06:50:43.879572Z", + "start_time": "2026-06-02T06:50:43.832035Z" } }, "source": "def _fmt_usd(x, _pos=None):\n if abs(x) >= 1e9:\n return f\"${x/1e9:.1f}B\"\n if abs(x) >= 1e6:\n return f\"${x/1e6:.1f}M\"\n if abs(x) >= 1e3:\n return f\"${x/1e3:.0f}K\"\n return f\"${x:,.0f}\"\n\nranked = (\n risk[\n (risk[\"scenario\"] == SCENARIO)\n & (risk[\"year\"] == SCENARIO_YEAR)\n & (risk[\"metric\"] == \"average_annual_loss\")\n ]\n .dropna(subset=[\"total_usd\"])\n .sort_values(\"total_usd\", ascending=True)\n)\n\nfig, ax = plt.subplots(figsize=(9, 4))\ny = np.arange(len(ranked))\nax.barh(y, ranked[\"total_usd\"], color=DELTA_COLOR)\nax.set_yticks(y)\nax.set_yticklabels(ranked[\"name\"])\nax.set_xlabel(\"delta EAL\")\nax.xaxis.set_major_formatter(plt.FuncFormatter(_fmt_usd))\nax.set_title(f\"Total climate-attributable delta EAL: {SCENARIO} @ {SCENARIO_YEAR} minus baseline\")\nax.grid(axis=\"x\", color=\"0.92\", linewidth=0.7, zorder=0)\nax.set_axisbelow(True)\nfor spine in (\"top\", \"right\"):\n ax.spines[spine].set_visible(False)\nplt.tight_layout()\nplt.show()", @@ -782,7 +782,7 @@ "output_type": "display_data" } ], - "execution_count": 8 + "execution_count": 10 }, { "cell_type": "markdown", @@ -806,18 +806,18 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:23:11.514316Z", - "start_time": "2026-06-02T01:20:23.061014Z" + "end_time": "2026-06-02T06:53:02.051984Z", + "start_time": "2026-06-02T06:50:43.891351Z" } }, "outputs": [], - "execution_count": 9 + "execution_count": 11 }, { "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:23:11.618065Z", - "start_time": "2026-06-02T01:23:11.546216Z" + "end_time": "2026-06-02T06:53:02.164399Z", + "start_time": "2026-06-02T06:53:02.091683Z" } }, "cell_type": "code", @@ -910,7 +910,7 @@ "output_type": "display_data" } ], - "execution_count": 10 + "execution_count": 12 }, { "cell_type": "markdown", @@ -927,8 +927,8 @@ "id": "s9-code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-02T01:23:45.895725Z", - "start_time": "2026-06-02T01:23:11.621431Z" + "end_time": "2026-06-02T06:53:17.958274Z", + "start_time": "2026-06-02T06:53:02.169157Z" } }, "source": "sub = subs[\"W. A. Parish\"][\"wildfire\"]\nds = chd.load(client, sub, cache=cache)\n\nprint(f\"Today's AAL: {chd.sample(ds, 'average_annual_loss_baseline'):.4f}\")\nprint(f\"Today's fire danger days: {chd.sample(ds, 'fire_danger_days_baseline'):.1f}\")\nprint(f\"Today's intensity: {chd.sample(ds, 'intensity_baseline'):.4f}\")\nprint()\nprint(\"RCP8.5 AAL trajectory:\")\nfor year in [2030, 2050, 2080]:\n aal = chd.sample(ds, \"average_annual_loss_rcp8p5\", year=year)\n print(f\" {year}: {aal:.4f}\")", @@ -948,7 +948,7 @@ ] } ], - "execution_count": 11 + "execution_count": 13 }, { "cell_type": "markdown", @@ -961,13 +961,15 @@ "id": "b2002071", "source": "trajectory = chd.screen(\n client, PORTFOLIO,\n scenario=[\"rcp2p6\", \"rcp4p5\", \"rcp6p0\", \"rcp8p5\"],\n year=[2030, 2050, 2080],\n metric=\"average_annual_loss\",\n delta=True,\n subs=subs, cache=cache,\n require_confirmation=False,\n)", "metadata": { + "jupyter": { + "is_executing": true + }, "ExecuteTime": { - "end_time": "2026-06-02T02:54:18.989413Z", - "start_time": "2026-06-02T01:23:45.926426Z" + "start_time": "2026-06-02T06:53:17.983875Z" } }, "outputs": [], - "execution_count": 12 + "execution_count": null }, { "metadata": { From 95a714b5049ef141a2eab8ff31637884ad1edb59 Mon Sep 17 00:00:00 2001 From: Nic Pittman Date: Tue, 2 Jun 2026 16:57:37 +1000 Subject: [PATCH 8/8] rogue file --- .../emmi-chd/__pycache__/chd.cpython-311.pyc | Bin 24501 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 use-cases/emmi-chd/__pycache__/chd.cpython-311.pyc diff --git a/use-cases/emmi-chd/__pycache__/chd.cpython-311.pyc b/use-cases/emmi-chd/__pycache__/chd.cpython-311.pyc deleted file mode 100644 index 79083232aed2e04678e2800933378438a46a05f1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24501 zcmbt+dvF^^n&064CP0uP_>@KxB@q%yQKTLe^;lCPWy#jdq9j|gwIqZYkdQ!to&hD1 z3)T?ya@jc?1A&b<{_#nU`)_npK3dht*Z;-9 zarZfayUGbVK_Agw)v>Gos-9g9SB>myx@u-u%T=qM6LmLiWk90+3mwOOiNA7ObqEH* zD3}DZV0mD?>YU^R>koAZZ7j5xL-y1KSapKq15R{h++_&b>le8BvXU^u)!wgpvj=Z+ zGWbg9VsV7*UG;+Vs#mDH+90^EHnR76@LuoV0ds?mEB}Nc!7DZi`gse-2@RE4Vy0gC=pm!94LPLP3|E)m4#Brn3(_#L2Bs?96i~PyJd_WTTk#Jx#8k6JU zpv-q2KRM#(r^LvND9L;%Ch_qpkv}d5!x4UL;={d^=4j`E?|XfPg*MP)u1o1Tfu z;pikkF%hJEy#Oyp;}a8nFc68zd^j49F(}A69gFgK13wdp$3-bB580>0U_2m+Ju)(j z{7ekF`C&;6$b2lspNb-vD98D(;d7^Ce>X1&LL!gc(rh#uxK0J6*sZXPil74Bb~z|U z15!BF6SxhS$UQw1!Gm7@g81%i7?4oMj$ptrAK3IA4`R-K6TlfsycHI2^PT*45i=R{VfMNll)~3BC6sEFC(k!Q zp=Uu%NURsE21%TiS-oU_R~g<6TL=tdBo+{8mSWzC-v|@{1zteU@gXTTO)XaH#$Yi} zsHrGMzY&P?FcuYiXr*ECNbyiC5{~imZBd-TEUqR@1!hELDxavV+<4$7E!zMVMWrYf zL_nIHrDed2cV@6S@q8u_6|f*jP~8&}rXGJg9G@DpvuaWuXgZcFD#xXAl%I`;-^EIZ z1g?vy9VQv!`e8-oE~x>-&RZPyfDy`w#B#3+>%MaA3Yu+$)IvgW~?4{o=vvJ$v`` zU++11KQM6iVYc;n!no`e1S`uqC&Lj!|@ z0l%?my^SRn0x~RGgL6UjnJ5?Qg0X;1jX<+w0`5bR*<0btJxVnMfFA;r;&>n$oyCI) za6r)pWGzPJaD1-l03yB~xE_wsjfcRG3xVjQDB&_E`;8LFB~G$ZKtyA)?shmTjLS2k zD2z|fJST%w5NG03<3M=Wh=LWu5@n6}8}R?S9l?EWic4_UYzw-CZiKsLT+k=xgn@yg&CUu}8z{J(XlczD7pQZz@`^12%Rnv1pcpGyOCB*>&&CK6c$d)5orZGyD7o zX#Cksd&k0;Y_XF-T{blaH zPRA|V1s%u*ebFAlvLBxg$T!E&vX1;Cy+q`BQ76lKTzOvd;)0e>ic#PS>8M21CwL4_ zCW7RD;76?=#ks1>w(VM>fKHaA4W&lpzgRRY+gs6E-p7k(W#25CmE8%=7vr;1Gzdzj za?pHY^Wjf0OFra2)P1PG&&4$}CaF(yNnOYw=svKX9(ivLr9}o@;aOpgs%c1xvyrXoy3pKTgX=Ju=#smlL^!`3Ia})V8@6 zMs0mC)@y30m($l=x2jZ?LK9VpD$2D6f-*6W zY^fl;Eeg!7MBOSVaC|2pV5AWrm;u!pWaOzbeH8-hIbh54{Kyt8cPw)iD!-NAIj*EU z2c}Y&7s6Ctd1Ol&%~xT@qLDfN_7wKj@-u#h=v;Y9l$E|a6+*uT%jA1lR>*6CcI&8s zN6IQZa#5P4p6?RGP+&F^2VGvF_!y_a#-U0H1CEAf1TbtZ{19;vLn_2F)d}JQ@4;Bo z<{FCgVWpKIs3#SQ0c1T<`WXN7*p;g_IuVG-R3&g4^3Cv!LYFcM6?AhHjYbeqs>NCd z$owR>?`SXoCTJNx8sn8_cZ0$s3?nlT*b~7ORf+mu1%w8-aJ23T;eRb5xMxuJqXD*- zbqo3>6Jgho{uU>7CG^;#wk;Tz%t$k^w2pXX4Rgp>U4h8yUNA0Mkkd#x|Ja%^V2$e% zMq0g}7?(ZE+n4teo<3XDjr(=QhUf4jeyfVGrz8*FBh^!|k%BE0@DyxDAQOV2>B%oH zE;6Lf_OSWQwX2}_a3lsoQ$E^T+3Vh+(*F>_Zx^`|XKFN8gTHpxCx?^Lig|VKqxw~U zw(AhiLVZKY!1)hT)agpy%5<*iGA&u(PMlBcJ2P+O>vteS^Df*Y!^+?z*3}M>v=5nI$6q#JivISu z7?j^^;am;XL3v*6mmAveU;E_R$K!X$OC}8AuV@^9O#xyq3t}$I;%LdqS?jWvmUIZg zQ{T2sDCg_R`+A=E1|Itca=v|e-@X!Ov`y-iaOqWye!SprNS#`Kzr^WW)4HdghWn0B z9O-wn?Kg4$)rGgRSFUBhJ(<5UmAeqmUkEGdIZq_-iDW$yD*Wp50u`Rr78bMZ;$Mcc zm#$>52J)A#=gtQ6XM;$?ne&A5o>0~k`fb7CSv<`qL~!kLWyFF9srR`sx1iH5!HhO9 zI#M}m<#kw^VYa;W3x)*u{LOtW39tb9=?7TKH|X8$SW8$enBqjps7KsUjsY#`AL?s2 z)7rZQbHbD`<7b+Oq?h7!jXSFll=PYuv{NuVFeP*e{b6KWzL6lJ&lvbiRPgv327d}d zA|i$b&1x#M`V8OikgLmu#1+_~0<@si9r=w}h!(&piGko0<9R6$7TyqBbQ5LS$^>Ke z!*Oip!8mw~%1ULMG3^Wr_63a%*#Ho9OxeuTouqatOknF0g>W#AtpbF8Xg0z#SqcyX zxJ2M}Nf9OhhyWG?Y_7WFgm@+*3kZU|TY@wRYp_xg8G?j3SnDV@i3mhgqO7)1Azo-d z`i`>w4)NdV?d@Gyz-lF4nKl!M4MJftB4ASmC#+^uw%wg5sNyVI-aS1kvOVYl;G&zRRXXIK`yj@eFU<5oocw}lHlMa>XJlbn9 zIE>CKPl`3w=;e>cqTnj0t7Olb3f-OxV|FoWjKndRJ~7s%B%&lyk}{`20AXIpB;?~k z?4Y7A1Sn5Q;pj~nLX2`xMdrHs*evxNn!@H0%{d|^h<6sNolmWsnCNE1Kq8cKtBFdI z0=G$|2LT2NS0yn70cSLb!mOu3)AoqdGx52a8G($|5e452;xbMP0N^V75HC-~W+6Mn zteBm_!V-n&5G#az7_rihh?aG}Q9%};=!tb!7-wD4NDIJU=KF4G`976IsNLb7Ln3?t z&@w5Szze#2lrz02rMqjc+%h!n*Rf3yT(FV)uV^iIyR;L9CE_S4O_@c0OVL`!8&WSl za!iVG$Qt5UmGPpjGPQ~Z+_QbLSXVoz{1&O73WB91>6fwt+f@kTVWFrOWNCMk_5r|*2~{&8=vc@Xi>-pe)jlpN+(yb(dtoV>MEm#iz*aZc~z z8P?B#gPP(feGAk`AWkGnv}gl9r2d-<1S=a9@(@`__h0MTW~t@%Zd5kP1XP6c;7ZqQ zN`{01$`@>73&w;|FtC`3Vl_}I9C%G?r4ETTP;1{oZ)I@Jf)N`T+x8OJ0BO6M)Uy;+ z{sk#`qUJ$vmS=qmgEMKG)Cr~sq(U*z|HoIw*lT0w&hqDDk-16iB#_JlyO0RA(uKfq zP(#GA{qV@pg--6~(aFGtY>A%^#CMaV^7?EDYoGKdl0^Ftp#!9=l1c^pK;Q<1$`(3_ z!U@wTg7H|C!6FPWDaB@qX@Z~@d{aeM+O-FJ41a{*)7QsO^LNxMvVa$oL=`cIJv&Hd zgqDZXKhbeTi`pzme~j_D8L{XH#$u8XjuO6s6wnA9JykTy?@E|B5Wg2KQa}iU|HfiE z0VvX|6p#c6Bym^}$ESTYud6uzfX{^AF|y zLplCXo_(UogZgO9GSCkkGGRa39%UM2p7Fc$azz z8WwZSJB)&!QK-gp-WwHB(+o8C>*>{`J){#1A6OHnjOGpH(tnpAZNVHT;jDUOG$O8Y z8YomFkc;UDM!~#ZVD%EEEsSNh{y&wqE!pYKpRJ+1At-yv)?VvlJc4Dx`Vuv@L;U7I zJDmwDn0yy#c}rCkAk?8A=GxJMn061iiRxHYcn4*yu5DVdy~KOn2^$H1*TLqO?8HY1 zo(Be?z52jBu>E(_GtTNHiJRA9@HqDJcGx3IR4<9*m-k^CKM$`IeVdn&Nd%^IN;k~PnW zc~D3=i57pbvf<)}#+}h|#Jdp}3qgJhsX%VvUO6-ywC+Y_o2~Mnzo%brEz@~M$k$^L z=st>;D5z!-&qWjKzM?rWjol?)p#bAr3h;OK!^B}RrN{i{^2jr_tcDJ(WFcfOZ$$t? z(0N`tS2ri$Sbi(->PWx);P!*}D(UMPcS1(2$y*S)r&Am4D9hOrx+N7YqG3+8VG0#% zRD@tg>hq$JMxtmf50Okg39?R=dX3}mC0g>Ykd3wEw`huML^=P+zG7Svl0xcaI{xvw zN-}H7d?QVGMUO}uIgt!Q{O=6C1EF~X@q*T2Qg6#c{CuBcIKZZ>!X%bwG&nr6q@bx! z6Ne9CGEa*B`Id{Mf8?QitDU+4rsw&hp?{w|Z{%O$JLk*Kd-DT zVu1tU2wo4pQV@+RI<*tFXlC6d`|Y3>#c0vQl%vv7WR#9jZi~7?izc>289^@f(c``J z*dd6dc4vxHzk^ZT(wp>@5enAmIO`Z$8llW4_GW34o(CwnPN`rCq9UuB43e@;h-2Vh zQ3PSGn%O7KAkRO?UtYkf!65ynk@Ga94lcd7{NCcpr|!noTNzt!gFolqnRoA8JPApn z-SfoO_Sn|;*~!e+e0yKcwkL1fvv{n)Ch8;o&+PfZli9(uzc_{|nsc7dJI^nU7Rp19 z!Cn>r<;_32`IG6NPU9x$8p*px7Ek=rX!-Eu_fBSA`!lByRL-37K;C#DYdr9@oZ&*+ znsr@J&YW>9Zyd`S$0|<`tTbm`2b42s9LyUBv&O+fQ``NUpWOU-`tCF&WTsakccXC0 zo-`(fr&h=Jtshyl^`j{PfpTU>l*zyRDGHX6t)a`UzkU z3&4z&0q)9N%+~M1nX`81t=(C6q60T{6q-8<-sY0UNJNkls6^23tfWvSZE4Y}Vr#i* zhzBO0ugA*+-$6I2U$kgNa|?P#pl~lIqWc1)|0Vv)v0wtB0wno-VO?$Bb%YMMi#xgn zY~<`}Td+fD=t$@?gq7DFYhk5y*ZLWbaxSIDnWreo952&1zPfDr8N)jUtqf+m7H?m zJs?iz0d2wZ5+sE)Q75=S%G4!1Rr656jTFykrrH+hxM)wps=|I5GO7OW0~?#7BT+{i zWI~@Ia(msecC4q}l;SH@JoE91q4U1hE5sm1zoEx>M#|V3A z%s(@rZ!~ZoHq?#);Mmk&u|-V@yBfDA8mL8@k*lZHEx(h}E$@Aak!eg=64rT?5H?^m zni3Y&$HxfH=Fco^N9HBqwIpl_y9OReNx-usd=9*X1B7I2zz%$T{CUPyL|1A}pcLD~ z3eg1ywv0Gbf@_Q{0kIt_#(=$KDkiHUM3~z#aTyE@VW|QU8)(L^aFj`oNJb09gOsv7 zxrTH1A6iojMJUN2cENrPa-r^WO%V5&Ni>ZBm~Cd`BsT+{r;2&`F^zRsm9RVee4>u* zH&yzkzLu!_W1E)5OXxuBc*{hbuIPl&x6j z*}1ak=YhY7BA$BV?zb~Uh z6{#Apm#P1MrZQU*fH-TstemTFqyl%RGCBy@HuS8#TS;g2m*@r3AOa9$3BITYVReF% zNSc9uyoF2AIw_K5Tblb@s{6c`hy5Rsa*AmnnT*XF4)+g&k%N09__F4f02Hm1IF5D|9W17_4E8^Gs3fzPnrw*8 z#w7@>xS|2oX9HHWpd2mnq5%;m!)3h*u`fV0B5%1nwO55^v{hDtltRY8#9#gpQvqV! zCeG@~T6|9%+8}Oa3t-j!r0pl}-f8xf=Xwq;i8u&Uq&9ganPwXHH*wPtMt%eEsiN z^jTw5(vTckvK6-M{KMWK_U5+q=eL0Hbl5sskaKQKo=Ck`@NQC?lNtN`^2*h0=U~oz zFz-E>JdS=s*EY33Y3h62)K}=-ncch(=Sp0;7TPvG*k9P>hv|TC&#yS6&--f%QihV9 zt8YmUf9y(GQ`Tpmw)DF>51(=r_^rv~DdX~~R4C`{$T~ZI#(PjN!a7oHd3k6#U<>*fU4n;%f{w6-_}XO~o3~AyI1d|N46f zh)(`)Q_ZeGwkECw@M={UP^B5hhzhP?UjV2a+WfWD0My+2@7hW1sLjJDD-sXs=0{J% z?3oYLY@N^vt2?%8t3xt!))?%)Bom;`8~VW685jtoxZDd&`wvi?qJwV7?*t?%FbBg? zrlfJwaxU|b(#OcgxWzL2u9`y_sibrdPpxR8d=q+bNo!fd zR5Z?s0jXwy%*en7=)a>D7@!&pgIhYOK`YILNssOaU~Se)DZhvG1b0g(*F!m>k=j;e zIfCIPZCsq>)*2rQ#@fN70oRsigZVx&998KdCd{oGivxpTu1=X+cnd}?V{yYmHJ~E_ zS*=o^+WcBmMwm;Q{vYaZc)oNvPGp99B*5UksKyW15Vw$~S87et^yf1Ng7u-Twk1`P zy*3?7z#ce;p&nDr{z*V1!%iw7X>9v@X2N%11W&#%+NrD(v#_jF9Wt;uAi^ZQ4onsz zie-J5*gHuEk6WH&gRPngZh`5!A}pMkp!oyylSf7aQPqit>?_HEMzM-J8#v2{LlujN-2@$k4jEIi^^Tl@FbpFY zkco-QWKus0YJ=4X8ZLNp%tmiUW4EIf7_5;><>xnCQXf)BmHULBZ|mj9L@2vqYF%sQ z(dF-D)LYSj3ZI423e|xk`S&p`F2X3zOvZrGfZtiH8y`M>di*jRc7~6g9vv&%t2Ki@ zD?ASi6_hC&g)q#vJmb`d@;J$%#|dOnADt zlKu(cNcRbtUI-LT3=&Mz$cR;xWx@>#DWVV|X2n-TB59SEkkJ4<~-ebPj}Mv)Z2Ks zE4?o>^7}_}UVq-}U)h}Zb|)|Dy~(uHw(d=u-h8PyIi$Hb znairj686x9<)OJ&P@{uauyz*`*6cLT-&tzMEmIK$mET3z+B^&OQSVkR-dxSm$w?+1 ze5x1fuW(W0ZSIcY3U^zVs26PLjrKULA@#^;w5;Vch=A7kYXcVS|CVfvJo#ZK(9dgX z;Eh*2i#d+7qW&ePo9gQ+I=`j@faGTWE-HE#G0+btYVi zy4v1cXpC>G=D1PW-4l)Q=&t*r?xDMOl`d=$Jd?UagJck39~y;@nuJjcAchkf-|Gx9 zf$NUM2BH3;cMUvW!j~bhnstZJ@UXFV)+{trA6@f()CNmr4rVrONn6MyY=Abrd2Qb% zd`oRiP}iLBX;*k+jX1PQzhs)$RRIY?li+*UTwCXaPiSF;c!ShP@hS}5xvF<$FMyO* z%KN-tQ+k;7U&}YuQD~XeQ7+c&t(snMP52TmiB@`6eJd!Vw!kZ9cpXQDo_MTBgph9< z4g+CmU76=`RlcWqJF4W+h~if;#1yoO)=W{=vO+MD#%?P1z=asToU?JJuVp&~nK2Fz zp9X~?h!UefE*w9mwpcR$YV@`#gnKB1=8Rs{(XWAQ*(_8M8SBouv9w zsudfSCgHMN79}Xw+Dv2vZCorGWu|_B#hk_}ZqN#8Lxn2M9a`f{i83TGRO$qBOpU~% z6e)WgA`_!D6i>q{)N+eZk%@`20~!1nm;)KR!n1^3;XuZ&a3EuVL5{I@R$)ZliDzA(3xNe*PHD>_{cYlN<^9_1kdrgT`Ov_Z%GTtAbNHl>sEG7{*en&2Nnh zG_|n;y3)Jq=1+xb-&ee#*P0Bk_XAQ@{na|KnW404VnX#?fd#5M1B0aZhKcA@47QUK z6QNmx(w*>8)m~+t&s-SbNf;8K&cjopAE<# z;tPo0ge(oN-m*&W6Re6g!Vr@*5;a@(wynMvVsCY5u}eW5VKLZ)aRNrH;uNeWWofc$Ffq}^ za41Y+RNU9i(>m`aJAD`cRFoLh;N!}A7{X+rk?-c;uHc;RYcBxM%^y}5D{S76D)uY{ zi;1q^hI3fiKl&P06Hgo@nmhv!0y1KzIR*=o>oHleW*1_j9NiHwd!{LUd3N4YW(>m{wyaBC2l2L%JEQhFU9Tfli~oqM2c0c~v399D3HPG+NaS zuJEhMik=rh`nDCep!{l<^1EA^i{DoKom!b`}gLXo}03R-n&hqhreB@DA0Tqibf24qkm=fC zxYB6)YzcmD37w!J2dad@lEzPT2~H?lvqao!K74~ajbLZVxTOCArh;GMuN)uimydwV zFtS##rd3;t+B?P-{(2k>0ye6O`?9165J|8oJ*2=-!H*HBR;loUTU0E9VB$mq2gSr` z{TNlAEz%eT0O7ab-8o}D81qVC=IXt_F>$WuG_=Z@H!`q?pozeXoj!$QFB|`-g!BjZq1YUK5taJlVuSh?@9c*uC znZcC1yxRP}q8*<`0p<+=X^{yHzRkewb&UAz0(3Doo3Qj5fJmgYE4q~j6^BA*P6L;= zDA0S+1R!AuLn5);FsHJPo;$(BJ5{X_Q>I9NN`PFj^u@;pz^T*vF6w85qHP35ee5F= zMboqh`=z2K9vi2*PAZ#ef4fGNR6AuQGUrgnt1`vepedvIFX)A~G6ImL6}q=5*g~#) zJ{GNT|CoVOh*+!#3BxG1vfBVYXaEuhpHsoAfiIp?X`6B#7eYnbO?*`YjftQsLP&bV z-VmndA;m`0ZWdKmcsrg>5EkSSPT*gAsCG+cW!X!lbM2)$^pC(E!*P$f?p@Sz9Xm32 z{IX9``)Z)BxO#SA6)48u!Fh9abGGA6oL?Eg8qd9QDgO$9(tXbRR^Izo*7+8}=~U}; zp20bwn@KeC!*{`G)eop(nmq9{XO&`Htm% z$C4+LCx83Y?Sm)3%))qp~08h z`^@54OcWRrUwsppJJ)_Bk2`D2Q+IQ^368McM}EIIv#f5^$ zn>3M@YA(O2FYD>U_`6!u2Q%Ud1Z?~Au6^)1@p$h#)0eY7udAo$bk1`+?>W7As!;Ds zSy!%P+mEK-PM=Aid2}r2`4*CG-qgXot>cMp>toy2%&FA_S=-i}?NHu!Xz|#yI?wlS zd~_pYOWw%U?abHh#Pp#_Vj^D_1W8>@I{6_ zOQxg=V$OyQ_b#S)e0=ThwY+!h6Yq}4-W@A%tj=b=J96G5dGC?MV~e-H`+C9RAw#sm zLTh{a%?Gay$U_%$nv-xs(&Ks@a#48Vs=d4sx*z0Qec-RClvx3ka9w8HoHg)qn?_cQS z^z^B-qvKabhc8I~29+Wu3ASr1X-9~V09{o(B+_3Ym-3wf_Qipp;C7wAkM!>-69o@w zsysjhq?48T&lPAJF_Y~n0&GV0&A>S}+#*O07u=rIYahLze81pny6^hLm45d}J*)NE zjRQH)-n<7}9-YrxHUeSPllf|WPinZ(*n0oWCucHyGJ%!)j6c`dop0>UvJ==F*=zs} zKO?8-o{_-}L_KtpbhkmrN^6)dW3pu z3$_G&mb6~zRS%%V8eJ$fB(~>5Uss0(`wJkhkw8O>t--A8`-d4D+Nn)`%ls!ARco2K zRnV6ozITy`!etU#3r9iDg~>UENYFzSxegOtF;-s{Ua3Nt^>Q2f%*lH33tx7ChrhZQ z2|*3{DLNcH=Eu0OMO3tnmxV~oXbI1V{eqg1@FP<uZN`_Lw%!aION6xk*Z`%Q?po*-Yx;Lb*gWhQERnDAyciz1_Yu)`zS3~Mp zdVjXL7bldK?7Dg}>l(_rhVrf<^4w#adDFdPcVA7P`1su2bM*420(NoNFP{q*M*9}q z2e*@Va+c=21=wIsUC9^lWDew^v7IecFcpvsfvyjt#g&6_E889ZD5tS>#CW3 zRT~B9Fe>Ri@Gv_TbsiA#=DW%!APoD##PfIdE8f*aYod*)PsRA=)QNT3EAyJK_ zKR`fCCFErS^A9yC7jl~xsmu58Rc5jaY#vKE1yTGRMI8>OoAK!E^voPK7nw>+p935u z7Joxfjaa8O-xZTGNM^ymrD;2cJJ1qPJ|A5iq1mvIx_I~MkG!9E5OE84Kv&O_1&c^w;v zzn~{Xl1X3Dd%Oz6e&W)_OBa-ldQ5soPlxHL0UUeLcs&-2u#IMtP?@2ch_wEl_3$(Zm56v$;xNECIr;w>IS%`=4$MWf&RF6o=;w6q#X9;GIL9LUJ>$ID z@>$>-vgK17e`fYAPUg+Nv^8hmoHuV?G~f$1z9WUE!^(*r->C;h;nXi$OO2fG+q!Ji zHJpW}x3lalG+oKEvl2lO2NiL^GXM9lH7whaf$WY5a7EMGGDD z)qtxd1CpP$ZDi>t%4g-;d8LGv>+V}MJUmz}&q^x6D>_z-^wIRuT-&aE+pb)FH|#j* z^_z6ww2&ECF=h@vh?O|pt_@D=8gy_CLXg6zf^bRCvdiiQcKJEj%W?)ytZyR~LXf%e z`8zD~NMx5^2<);pcumLc*j3ovS!mf>vhCNoOB{kiOWT9?k^wP%Js}Sxy}AUJ73s1P~bZY-ll@Dwcu{S*BuHi9fi%?N-YyQ z-PRIE;WKyra-w8n31$v9!z1a2yQh|7B@0Wka*jGkhQ{vNmUfqHEXmHn-@P*>-}Nt@ zD>+yax!0$*E?-GE=3E^m7fZtjBRnNHi+VWEhEhF?dO5qR)WD*RoWq@JT-sIIz;2t6 zKh?Q(sN`d}&0O0iwVth<+4{jdsgazixzxrUvYIRPSHsr~X5FFGanSp^Lzw|~Sv9cB zBVYj}t_{3S-H!Cd%+?22N*to-m~`+#OUZ!vv$jnc!-In*6UF^KE8^<$M-7jHt7r1P z$MXK;ES(k71RGm)9nYHEN+w(}DO%b~7K&N9wv8nl#q6A~H9hk2jgo`zoLqBz$wjd` nin*28=Iu(1quXjQXwtQ(uRn-jZR^@sq=%Rch`cah2=e~|Vv9F9