From 7b9ba11374eafcd271b65c49e7ebe1b229e6f465 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Thu, 22 Oct 2026 14:20:51 -0700
Subject: [PATCH 01/10] feat(tabby): add Tabby foundation model wrapper

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 foundationforecast/__init__.py        |   2 +
 foundationforecast/models/__init__.py |   2 +
 foundationforecast/models/tabby.py    | 257 ++++++++++++++++++++++++++
 3 files changed, 261 insertions(+)
 create mode 100644 foundationforecast/models/tabby.py

diff --git a/foundationforecast/__init__.py b/foundationforecast/__init__.py
index 5f9892d..770b0c5 100644
--- a/foundationforecast/__init__.py
+++ b/foundationforecast/__init__.py
@@ -6,6 +6,7 @@
     Chronos,
     ChronosFinetuningConfig,
     Moirai,
+    Tabby,
     TimeGPT,
     TimeGPTFinetuningConfig,
     TimesFM,
@@ -19,6 +20,7 @@
     "Chronos",
     "ChronosFinetuningConfig",
     "Moirai",
+    "Tabby",
     "TimeGPT",
     "TimeGPTFinetuningConfig",
     "TimesFM",
diff --git a/foundationforecast/models/__init__.py b/foundationforecast/models/__init__.py
index 4ebf2dc..11ac5b0 100644
--- a/foundationforecast/models/__init__.py
+++ b/foundationforecast/models/__init__.py
@@ -2,6 +2,7 @@
 
 from .chronos import Chronos, ChronosFinetuningConfig
 from .moirai import Moirai
+from .tabby import Tabby
 from .tafsut import Tafsut
 from .timegpt import TimeGPT, TimeGPTFinetuningConfig
 from .timesfm import TimesFM
@@ -12,6 +13,7 @@
     "Chronos",
     "ChronosFinetuningConfig",
     "Moirai",
+    "Tabby",
     "Tafsut",
     "TimeGPT",
     "TimeGPTFinetuningConfig",
diff --git a/foundationforecast/models/tabby.py b/foundationforecast/models/tabby.py
new file mode 100644
index 0000000..b6612ee
--- /dev/null
+++ b/foundationforecast/models/tabby.py
@@ -0,0 +1,257 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from tqdm import tqdm
+from transformers import AutoModel
+
+from ..core.exog.covariates import ExogStrategyConfig
+from ..core.forecaster import ExogCapableForecaster, QuantileConverter, _DataProcessor
+from ..core.quantiles import resolve_quantile_values
+from ..core.utils import PanelData, TimeSeriesDataset
+
+TABBY_QUANTILES = [round(i / 100, 2) for i in range(1, 100)]
+
+
+class Tabby(ExogCapableForecaster, _DataProcessor):
+    """
+    Tabby is a zero-shot probabilistic univariate time series foundation model
+    from [Huawei Paris Noah's Ark Lab](https://huggingface.co/paris-noah).
+    It is a prompted encoder-only patch Transformer (~147M) that emits 99
+    quantile forecasts (0.01 through 0.99) from up to 8,192 historical
+    observations. See the [paper](https://arxiv.org/abs/2609.13956) and
+    [model card](https://huggingface.co/paris-noah/Tabby) for more details.
+    """
+
+    def __init__(
+        self,
+        repo_id: str = "paris-noah/Tabby",
+        context_length: int = 8096,
+        batch_size: int = 64,
+        alias: str = "Tabby",
+        reuse_loaded_model: bool = True,
+        exog_strategy: ExogStrategyConfig = "auto",
+    ):
+        """
+        Args:
+            repo_id (str, optional): The Hugging Face Hub model ID or local path to
+                load the Tabby model from. Defaults to ``paris-noah/Tabby``.
+                The released checkpoint is a self-contained prompted model
+                (``AutoModel`` + ``trust_remote_code``).
+            context_length (int, optional): Maximum history length passed to the
+                model. Defaults to 8,096 (the published GIFT-Eval input cap).
+                The backbone window is 8,192; for horizon ``H`` the model uses at
+                most ``8192 - max(H, 128)`` observed steps. Longer inputs are
+                truncated to the most recent observations.
+            batch_size (int, optional): Batch size for inference. Defaults to 64.
+            alias (str, optional): Name to use for the model in output DataFrames
+                and logs. Defaults to ``Tabby``.
+            reuse_loaded_model (bool, optional): When True (default), reuse
+                loaded checkpoint weights across repeated ``forecast()`` calls
+                via the process-wide LRU cache. Set to False to load and
+                release weights on every call.
+
+        Notes:
+            **Academic Reference:**
+
+            - Paper: [Tabby: An Open Pretraining Recipe for Time Series Foundation Models](https://arxiv.org/abs/2609.13956)
+
+            **Resources:**
+
+            - HuggingFace: [paris-noah/Tabby](https://huggingface.co/paris-noah/Tabby)
+            - Code: [huawei-noah/trustworthyAI](https://github.com/huawei-noah/trustworthyAI)
+
+            **Technical Details:**
+
+            - Requires ``trust_remote_code=True`` (custom ``TabbyForForecasting``).
+            - 99 native quantile knots (0.01–0.99); the median (0.5) is the
+              point forecast. Requested ``level`` / ``quantiles`` are linearly
+              interpolated with edge clamping.
+            - Missing values in the context are handled natively via NaN.
+            - Univariate only; no covariates.
+            - Weights are [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/).
+        """
+        super().__init__(
+            reuse_loaded_model=reuse_loaded_model,
+            exog_strategy=exog_strategy,
+        )
+        self.repo_id = repo_id
+        self.context_length = context_length
+        self.batch_size = batch_size
+        self.alias = alias
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def _load_model(self) -> Any:
+        return (
+            AutoModel.from_pretrained(self.repo_id, trust_remote_code=True)
+            .to(self.device)
+            .eval()
+        )
+
+    @contextmanager
+    def _get_model(self) -> Iterator[Any]:
+        with self._cached_model(self._load_model) as model:
+            yield model
+
+    def _native_quantiles(self, model: Any) -> list[float]:
+        levels = getattr(model, "quantile_levels", None)
+        if levels:
+            return [float(q) for q in levels]
+        return list(TABBY_QUANTILES)
+
+    def _predict_batch(
+        self,
+        model: Any,
+        batch: list[torch.Tensor],
+        h: int,
+        quantiles: list[float] | None,
+        supported_quantiles: list[float],
+    ) -> tuple[np.ndarray, np.ndarray | None]:
+        context = self._prepare_and_validate_context(batch)
+        if context.shape[1] > self.context_length:
+            context = context[..., -self.context_length :]
+        with torch.inference_mode():
+            # (batch_size, 99, h)
+            out = model.predict(context.to(dtype=torch.float32), prediction_length=h)
+        fcst_np = np.asarray(out.detach().cpu().numpy())
+        fcst_np = np.moveaxis(fcst_np, 1, -1)  # (batch_size, h, 99)
+        median_idx = supported_quantiles.index(0.5)
+        fcst_mean_np = fcst_np[..., median_idx]
+        fcst_quantiles_np = fcst_np if quantiles is not None else None
+        return fcst_mean_np, fcst_quantiles_np
+
+    def _predict(
+        self,
+        model: Any,
+        dataset: TimeSeriesDataset,
+        h: int,
+        quantiles: list[float] | None,
+        supported_quantiles: list[float],
+    ) -> tuple[np.ndarray, np.ndarray | None]:
+        fcsts = [
+            self._predict_batch(
+                model,
+                batch,
+                h,
+                quantiles,
+                supported_quantiles,
+            )
+            for batch in tqdm(dataset)
+        ]
+        fcsts_mean_tp, fcsts_quantiles_tp = zip(*fcsts, strict=False)
+        fcsts_mean_np = fcsts_mean_tp[0]
+        if fcsts_mean_tp[0].shape != tuple():
+            fcsts_mean_np = np.concatenate(fcsts_mean_tp)
+        if quantiles is not None:
+            fcsts_quantiles_np = np.concatenate(fcsts_quantiles_tp)
+        else:
+            fcsts_quantiles_np = None
+        return fcsts_mean_np, fcsts_quantiles_np
+
+    def _forecast_univariate(
+        self,
+        df: pd.DataFrame,
+        h: int,
+        freq: str | None = None,
+        level: list[int | float] | None = None,
+        quantiles: list[float] | None = None,
+        panel: PanelData | None = None,
+    ) -> pd.DataFrame:
+        """Generate forecasts for time series data using the model.
+
+        This method produces point forecasts and, optionally, prediction
+        intervals or quantile forecasts. The input DataFrame can contain one
+        or multiple time series in stacked (long) format.
+
+        Args:
+            df (pd.DataFrame):
+                DataFrame containing the time series to forecast. It must
+                include as columns:
+
+                    - "unique_id": an ID column to distinguish multiple series.
+                    - "ds": a time column indicating timestamps or periods.
+                    - "y": a target column with the observed values.
+
+            h (int):
+                Forecast horizon specifying how many future steps to predict.
+            freq (str, optional):
+                Frequency of the time series (e.g. "D" for daily, "M" for
+                monthly). See [Pandas frequency aliases](https://pandas.pydata.org/
+                pandas-docs/stable/user_guide/timeseries.html#offset-aliases) for
+                valid values. If not provided, the frequency will be inferred
+                from the data.
+            level (list[int | float], optional):
+                Confidence levels for prediction intervals, expressed as
+                percentages (e.g. [80, 95]). If provided, the returned
+                DataFrame will include lower and upper interval columns for
+                each specified level.
+            quantiles (list[float], optional):
+                List of quantiles to forecast, expressed as floats between 0
+                and 1. Should not be used simultaneously with `level`. When
+                provided, the output DataFrame will contain additional columns
+                named in the format "model-q-{percentile}", where {percentile}
+                = 100 × quantile value.
+
+        Returns:
+            pd.DataFrame:
+                DataFrame containing forecast results. Includes:
+
+                    - point forecasts for each timestamp and series.
+                    - prediction intervals if `level` is specified.
+                    - quantile forecasts if `quantiles` is specified.
+
+                For multi-series data, the output retains the same unique
+                identifiers as the input DataFrame.
+
+        Examples:
+            ```python
+            import pandas as pd
+            from foundationforecast.models import Tabby
+
+            df = pd.read_csv(
+                "https://timecopilot.s3.amazonaws.com/public/data/air_passengers.csv",
+                parse_dates=["ds"],
+            )
+            model = Tabby()
+            fcst = model.forecast(df, h=12, freq="MS", level=[90])
+            assert "Tabby" in fcst.columns
+            ```
+        """
+        freq = self._maybe_infer_freq(df, freq)
+        qc = QuantileConverter(level=level, quantiles=quantiles)
+        dataset = self._make_timeseries_dataset(
+            df,
+            batch_size=self.batch_size,
+            panel=panel,
+        )
+        fcst_df = dataset.make_future_dataframe(h=h, freq=freq)
+        with self._get_model() as model:
+            supported_quantiles = self._native_quantiles(model)
+            fcsts_mean_np, fcsts_quantiles_np = self._predict(
+                model,
+                dataset,
+                h,
+                quantiles=supported_quantiles if qc.quantiles is not None else None,
+                supported_quantiles=supported_quantiles,
+            )
+        fcst_df[self.alias] = fcsts_mean_np.reshape(-1, 1)
+        if qc.quantiles is not None and fcsts_quantiles_np is not None:
+            fcsts_quantiles_np = resolve_quantile_values(
+                supported_quantiles,
+                fcsts_quantiles_np,
+                qc.quantiles,
+            )
+            fcst_df = self._assign_quantile_forecasts(
+                fcst_df,
+                self.alias,
+                qc.quantiles,
+                fcsts_quantiles_np,
+            )
+            fcst_df = qc.maybe_convert_quantiles_to_level(
+                fcst_df,
+                models=[self.alias],
+            )
+        return fcst_df

From 56d4312bb4017064b2b970a8fb34795ed5bb2c23 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Thu, 22 Oct 2026 14:20:51 -0700
Subject: [PATCH 02/10] test(tabby): cover Tabby forecast columns and
 cross-model contract

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 tests/models/conftest.py   |  2 ++
 tests/models/test_tabby.py | 73 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 tests/models/test_tabby.py

diff --git a/tests/models/conftest.py b/tests/models/conftest.py
index aac4951..e119b24 100644
--- a/tests/models/conftest.py
+++ b/tests/models/conftest.py
@@ -2,6 +2,7 @@
 
 from foundationforecast.models.chronos import Chronos
 from foundationforecast.models.moirai import Moirai
+from foundationforecast.models.tabby import Tabby
 from foundationforecast.models.tafsut import Tafsut
 from foundationforecast.models.timesfm import TimesFM
 from foundationforecast.models.timestral import Timestral
@@ -41,6 +42,7 @@
         repo_id="Salesforce/moirai-2.0-R-small",
     ),
     Tafsut(context_length=512, batch_size=2),
+    Tabby(context_length=512, batch_size=2),
     Timestral(
         repo_id="mistralai/Timestral-5M",
         alias="Timestral-5M",
diff --git a/tests/models/test_tabby.py b/tests/models/test_tabby.py
new file mode 100644
index 0000000..e0d3384
--- /dev/null
+++ b/tests/models/test_tabby.py
@@ -0,0 +1,73 @@
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from tests.helpers import generate_series
+from foundationforecast.models.tabby import TABBY_QUANTILES, Tabby
+
+pytestmark = pytest.mark.models
+
+
+def test_tabby_default_alias_and_repo():
+    model = Tabby()
+    assert model.alias == "Tabby"
+    assert model.repo_id == "paris-noah/Tabby"
+    assert not model.supports_native_futr_exog()
+
+
+def test_tabby_predict_axis_maps_to_ff_columns(mocker):
+    model = Tabby(context_length=64, batch_size=2)
+    df = generate_series(2, freq="D", min_length=32, max_length=32, equal_ends=True)
+    h = 4
+    n_q = len(TABBY_QUANTILES)
+    # Rising knots so 0.1 < 0.9 after remap from [B, 99, H]
+    knots = np.linspace(0.0, 1.0, n_q, dtype=np.float32)
+    fake = np.broadcast_to(knots[None, :, None], (2, n_q, h)).copy()
+
+    mock_model = MagicMock()
+    mock_model.quantile_levels = TABBY_QUANTILES
+    mock_model.predict.return_value = _Tensor(fake)
+    mock_cm = MagicMock()
+    mock_cm.__enter__.return_value = mock_model
+    mock_cm.__exit__.return_value = None
+    mocker.patch.object(model, "_get_model", return_value=mock_cm)
+
+    fcst = model.forecast(df, h=h, freq="D", quantiles=[0.1, 0.5, 0.9])
+    assert fcst.shape[0] == 2 * h
+    assert "Tabby" in fcst.columns
+    assert (fcst["Tabby-q-10"] < fcst["Tabby-q-90"]).all()
+    assert mock_model.predict.call_args.kwargs["prediction_length"] == h
+
+
+class _Tensor:
+    def __init__(self, array: np.ndarray):
+        self._array = array
+
+    def detach(self):
+        return self
+
+    def cpu(self):
+        return self
+
+    def numpy(self):
+        return self._array
+
+
+def test_tabby_forecasts_tail_quantiles():
+    df = generate_series(2, freq="D", min_length=50, max_length=50)
+    model = Tabby(context_length=256, batch_size=2)
+    fcst = model.forecast(df, h=3, freq="D", quantiles=[0.01, 0.1, 0.9, 0.99])
+    assert "Tabby" in fcst.columns
+    assert (fcst["Tabby-q-1"] < fcst["Tabby-q-10"]).all()
+    assert (fcst["Tabby-q-99"] > fcst["Tabby-q-90"]).all()
+
+
+def test_tabby_level_columns():
+    df = generate_series(1, freq="D", min_length=40, max_length=40)
+    model = Tabby(context_length=256, batch_size=1)
+    fcst = model.forecast(df, h=4, freq="D", level=[90])
+    assert "Tabby-lo-90" in fcst.columns
+    assert "Tabby-hi-90" in fcst.columns
+    assert (fcst["Tabby-lo-90"] <= fcst["Tabby"]).all()
+    assert (fcst["Tabby"] <= fcst["Tabby-hi-90"]).all()

From 2af5a67ce14a18af8ef54f6b2c0959ba141a3d86 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Thu, 22 Oct 2026 14:20:51 -0700
Subject: [PATCH 03/10] docs(tabby): document Tabby in the hub, README, and
 family notebook

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 README.md                            |   5 +-
 docs/api/models/foundation/models.md |  11 +++
 docs/examples/index.md               |   1 +
 docs/examples/tabby-family.ipynb     | 139 +++++++++++++++++++++++++++
 docs/exogenous-variables.md          |   1 +
 docs/forecasting-parameters.md       |   2 +-
 docs/getting-started/installation.md |   2 +-
 docs/getting-started/introduction.md |   2 +-
 docs/model-hub.md                    |   1 +
 mkdocs.yml                           |   1 +
 10 files changed, 161 insertions(+), 4 deletions(-)
 create mode 100644 docs/examples/tabby-family.ipynb

diff --git a/README.md b/README.md
index a7c5ae8..ed503a3 100644
--- a/README.md
+++ b/README.md
@@ -87,6 +87,7 @@ Pass any Hugging Face `repo_id` (or local checkpoint path) supported by the unde
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/ibm.png" width="28" alt="IBM"> | [PatchTST-FM](https://arxiv.org/abs/2602.06909) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-SA-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/thuml.png" width="28" alt="THUML"> | [Sundial](https://arxiv.org/abs/2502.00816) | ✓ | ✓ | ✓ | ✓ | | | Apache-2.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tfc.png" width="28" alt="The Forecasting Company"> | [T0](https://huggingface.co/theforecastingcompany/t0-alpha) | ✓ | ✓ | ✓ | ✓ | ✓ | | Apache-2.0† |
+| Huawei Paris Noah | [Tabby](https://arxiv.org/abs/2609.13956) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/priorlabs.png" width="28" alt="Prior Labs"> | [TabPFN](https://arxiv.org/abs/2501.02945) | ✓ | ✓ | ✓ | ✓ | | | TabPFN NC‡ |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tafsut.png" width="28" alt="Tafsut"> | [Tafsut](https://github.com/Tafsut-FM/tafsut) | ✓ | ✓ | ✓ | ✓ | | | MIT |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/nx-ai.png" width="28" alt="NX-AI"> | [TiRex](https://arxiv.org/abs/2505.23719) | ✓ | ✓ | ✓ | ✓ | ✓¶ | | Community / Apache-2.0 |
@@ -103,7 +104,7 @@ Licenses verified against Hugging Face model cards. Check the model card for you
 <details><summary><strong>What this means for production</strong></summary>
 
 - **Apache-2.0**, **MIT**: generally fine for commercial production (retain notices; T0† is also gated on Hugging Face: accept terms and set `HF_TOKEN`).
-- **CC-BY-NC-4.0** (Moirai), **CC-BY-NC-SA-4.0** (PatchTST-FM r1 checkpoints): **non-commercial** only; not for revenue-generating production without a separate agreement from the rights holder.
+- **CC-BY-NC-4.0** (Moirai, Tabby), **CC-BY-NC-SA-4.0** (PatchTST-FM r1 checkpoints): **non-commercial** only; not for revenue-generating production without a separate agreement from the rights holder.
 - **Apache-2.0 / OpenMDW 1.0** (Granite PatchTST-FM r2): commercial-friendly; choose either license per the [model card](https://huggingface.co/ibm-granite/granite-timeseries-patchtst-fm-r2).
 - **TimesFM 3.0**: weights for `google/timesfm-3.0-pytorch` are [non-commercial](https://huggingface.co/google/timesfm-3.0-pytorch/blob/main/LICENSE); TimesFM 1.0–2.5 checkpoints remain Apache-2.0.
 - **TabPFN NC**‡: TabPFN-2.6+ and TabPFN-3 weights are non-commercial; production requires a [Prior Labs commercial license or API](https://docs.priorlabs.ai/models). First LOCAL use requires accepting terms at [ux.priorlabs.ai](https://ux.priorlabs.ai) (`TABPFN_TOKEN`). TabPFN-3 is LOCAL-only today.
@@ -126,6 +127,7 @@ Some models require specific Python versions (e.g. FlowState 3.11-3.13, TabPFN &
 - **PatchTST-FM:** `ibm-research/patchtst-fm-r1`, `ibm-granite/granite-timeseries-patchtst-fm-r1`, `ibm-granite/granite-timeseries-patchtst-fm-r2` (r2 requires `granite-tsfm>=0.3.9`)
 - **Sundial:** `thuml/sundial-base-128m`
 - **T0:** `theforecastingcompany/t0-alpha`, `theforecastingcompany/t0-beta`, `theforecastingcompany/t0-gamma` (requires `tfc-t0[torch]>=0.6.0`)
+- **Tabby:** `paris-noah/Tabby` (requires `trust_remote_code`; CC-BY-NC-4.0)
 - **TabPFN:** default `tabpfn-v2-regressor-2noar4o2.ckpt`; TabPFN-3 via `model_path="tabpfn-v3-regressor-v3_20260506_timeseries.ckpt"` (LOCAL, `TABPFN_TOKEN`); or CLIENT mode with a Prior Labs API token
 - **Tafsut:** `Tafsut-FM/tafsut-univariate-base`
 - **TiRex:** `NX-AI/TiRex`, `NX-AI/TiRex-2`
@@ -145,6 +147,7 @@ Recent additions and checkpoints (newest first). See the [changelog](https://git
 
 | When | What | Checkpoint / detail |
 |------|------|---------------------|
+| Oct 2026 | [**Tabby**](https://huggingface.co/paris-noah/Tabby) | `paris-noah/Tabby` — 99 native quantiles; `trust_remote_code`; CC-BY-NC-4.0 |
 | Oct 2026 | [**TimeH2O**](https://huggingface.co/h2oai/timeh2o-v1) | `h2oai/timeh2o-v1`, `h2oai/timeh2o-v1-tiny` — requires `h2ofm>=0.43.0` (Python 3.12+); native `X_df`; GIFT-Eval and fev-bench CI ([v0.1.16](https://github.com/TimeCopilot/foundationforecast/blob/main/docs/changelogs/v0.1.16.md)) |
 | Oct 2026 | [**Timestral**](https://huggingface.co/collections/mistralai/timestral) | `mistralai/Timestral-{5M,28M,123M,209M}` — requires `timecopilot-timestral>=0.1.0`; native `X_df`; GIFT-Eval and fev-bench CI ([v0.1.15](https://github.com/TimeCopilot/foundationforecast/blob/main/docs/changelogs/v0.1.15.md)) |
 | Oct 2026 | [**T0 gamma**](https://huggingface.co/theforecastingcompany/t0-gamma) | `theforecastingcompany/t0-gamma` — requires `tfc-t0[torch]>=0.6.0`; GIFT-Eval and fev-bench CI ([v0.1.14](https://github.com/TimeCopilot/foundationforecast/blob/main/docs/changelogs/v0.1.14.md)) |
diff --git a/docs/api/models/foundation/models.md b/docs/api/models/foundation/models.md
index ef80457..cc1e427 100644
--- a/docs/api/models/foundation/models.md
+++ b/docs/api/models/foundation/models.md
@@ -82,6 +82,17 @@
             - plot
             - supports_native_futr_exog
 
+::: foundationforecast.models.tabby.Tabby
+    options:
+        show_root_heading: true
+        show_root_full_path: false
+        members:
+            - forecast
+            - cross_validation
+            - detect_anomalies
+            - plot
+            - supports_native_futr_exog
+
 ::: foundationforecast.models.tabpfn.TabPFN
     options:
         show_root_heading: true
diff --git a/docs/examples/index.md b/docs/examples/index.md
index c700b1a..dece411 100644
--- a/docs/examples/index.md
+++ b/docs/examples/index.md
@@ -20,6 +20,7 @@ For model API details, see the [Model Hub](../model-hub.md).
 | [Chronos Family](chronos-family.ipynb) | Forecast with Chronos 1.x and 2.x checkpoints | Python 3.10+ |
 | [TimesFM Family](timesfm-family.ipynb) | Forecast with TimesFM 1.0, 2.0, 2.5, and 3.0 with prediction intervals | Python 3.10+ |
 | [TiRex Family](tirex-family.ipynb) | Forecast with TiRex 1.0 and 2.0 | Python 3.11+ |
+| [Tabby Family](tabby-family.ipynb) | Forecast with Tabby (`paris-noah/Tabby`) | Python 3.10+ |
 | [TabPFN Family](tabpfn-family.ipynb) | Forecast with TabPFN-2 and TabPFN-3 (LOCAL) | Python 3.10–3.12; `TABPFN_TOKEN` |
 | [Toto Family](toto-family.ipynb) | Forecast with Toto 1.0 and 2.0 | Python 3.10+ |
 | [PatchTST-FM Family](patchtst-fm-family.ipynb) | Forecast with IBM Research and Granite PatchTST-FM r1/r2 | Python 3.11–3.13; GPU recommended |
diff --git a/docs/examples/tabby-family.ipynb b/docs/examples/tabby-family.ipynb
new file mode 100644
index 0000000..0e1bd83
--- /dev/null
+++ b/docs/examples/tabby-family.ipynb
@@ -0,0 +1,139 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Forecast Using Tabby\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "!UV_CONSTRAINT= UV_BUILD_CONSTRAINT= uv pip install -q \"foundationforecast[plot]\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "foundationforecast ships a `Tabby` class for [Huawei Paris Noah's Ark Lab](https://huggingface.co/paris-noah)'s [Tabby](https://huggingface.co/paris-noah/Tabby) checkpoint ([arXiv:2609.13956](https://arxiv.org/abs/2609.13956)). The released weights are a self-contained prompted PatchTST-style model (~147M) loaded with `transformers.AutoModel` and `trust_remote_code=True`.\n",
+        "\n",
+        "Tabby forecasts each series independently with 99 native quantile knots (0.01–0.99). The backbone window is 8,192 steps; for horizon `H` it masks `max(H, 128)` future positions. It does not accept known-future covariates — use `exog_strategy=False` in mixed `FoundationForecast` runs.\n",
+        "\n",
+        "*Requirements:*\n",
+        "\n",
+        "    - Python 3.10+\n",
+        "    - `transformers` and `torch` (installed with foundationforecast)\n",
+        "\n",
+        "**License:** checkpoint weights are [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) (non-commercial).\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Import libraries\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "\n",
+        "from foundationforecast import FoundationForecast\n",
+        "from foundationforecast.models import Tabby\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the dataset\n",
+        "\n",
+        "The DataFrame must include at least the following columns:\n",
+        "- unique_id: Unique identifier for each time series (string)\n",
+        "- ds: Date column (datetime format)\n",
+        "- y: Target variable for forecasting (float format)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df = pd.read_csv(\n",
+        "    \"https://timecopilot.s3.amazonaws.com/public/data/air_passengers.csv\",\n",
+        "    parse_dates=[\"ds\"],\n",
+        ")\n",
+        "df.head()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create a FoundationForecast\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ff = FoundationForecast(\n",
+        "    models=[\n",
+        "        Tabby(alias=\"Tabby\"),\n",
+        "    ]\n",
+        ")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Forecast\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "fcst_df = ff.forecast(df, h=12, freq=\"MS\", level=[90])\n",
+        "fcst_df.head()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ff.plot(df=df, forecasts_df=fcst_df)\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "pygments_lexer": "ipython3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/docs/exogenous-variables.md b/docs/exogenous-variables.md
index 4eb07ff..6de91c6 100644
--- a/docs/exogenous-variables.md
+++ b/docs/exogenous-variables.md
@@ -41,6 +41,7 @@ FoundationForecast uses **`supports_native_futr_exog()`** on the forecaster inst
 | **Moirai** | any | No | Use `exog_strategy=False` in multi-model runs |
 | **PatchTST-FM** | any | No | Use `exog_strategy=False` in multi-model runs |
 | **Sundial** | any | No | Use `exog_strategy=False` in multi-model runs |
+| **Tabby** | any | No | Use `exog_strategy=False` in multi-model runs |
 | **TabPFN** | any | No | Use `exog_strategy=False` in multi-model runs |
 | **T0** | `theforecastingcompany/t0-alpha`, `theforecastingcompany/t0-beta`, `theforecastingcompany/t0-gamma` | Yes | `future_covariates` in `tfc-t0` |
 | **Tafsut** | any | No | Use `exog_strategy=False` in multi-model runs |
diff --git a/docs/forecasting-parameters.md b/docs/forecasting-parameters.md
index fd27d3e..5a87924 100644
--- a/docs/forecasting-parameters.md
+++ b/docs/forecasting-parameters.md
@@ -95,7 +95,7 @@ request the median.
 
 ### Interpolation on fixed-knot models
 
-Some models (TiRex, TimesFM, TabPFN, FlowState, Tafsut, Toto 2.0, …) predict a
+Some models (TiRex, TimesFM, TabPFN, Tabby, FlowState, Tafsut, Toto 2.0, …) predict a
 fixed set of native quantile **knots** internally. When you request levels or
 quantiles that do not exactly match those knots, the library linearly
 interpolates between adjacent knots.
diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md
index b582323..63008c9 100644
--- a/docs/getting-started/installation.md
+++ b/docs/getting-started/installation.md
@@ -32,7 +32,7 @@ Some models are gated by Python version:
 
 | Model | Python requirement |
 |-------|-------------------|
-| Chronos, Moirai, TimesFM, Toto, TimeGPT, Sundial, Tafsut | 3.10+ |
+| Chronos, Moirai, TimesFM, Toto, TimeGPT, Sundial, Tafsut, Tabby | 3.10+ |
 | TiRex / TiRex-2 | 3.11+ |
 | T0, FlowState, PatchTST-FM | 3.11 – 3.13 |
 | TabPFN | 3.10 – 3.12 |
diff --git a/docs/getting-started/introduction.md b/docs/getting-started/introduction.md
index 4f65d87..259a23f 100644
--- a/docs/getting-started/introduction.md
+++ b/docs/getting-started/introduction.md
@@ -5,7 +5,7 @@
 ## What you can do
 
 - Run multiple pretrained foundation models with one interface via [`FoundationForecast`](../api/forecaster.md).
-- Compare Chronos, Moirai, TimesFM, Toto, TiRex, TimeGPT, FlowState, Tafsut, and more side by side.
+- Compare Chronos, Moirai, TimesFM, Toto, TiRex, TimeGPT, FlowState, Tafsut, Tabby, and more side by side.
 - Finetune supported models (Chronos 2, TimeGPT) on your own data.
 - Detect anomalies using cross-validated z-score tests on any forecaster.
 
diff --git a/docs/model-hub.md b/docs/model-hub.md
index c75d9ca..acbcece 100644
--- a/docs/model-hub.md
+++ b/docs/model-hub.md
@@ -42,6 +42,7 @@ Below is the list of available foundation models. Click a model name for API det
 - [PatchTST-FM](api/models/foundation/models.md#foundationforecast.models.patchtst_fm.PatchTSTFM) ([arXiv:2602.06909](https://arxiv.org/abs/2602.06909)) — Python 3.11–3.13; [`ibm-research/patchtst-fm-r1`](https://huggingface.co/ibm-research/patchtst-fm-r1), [`ibm-granite/granite-timeseries-patchtst-fm-r1`](https://huggingface.co/ibm-granite/granite-timeseries-patchtst-fm-r1) (CC-BY-NC-SA-4.0), and [`ibm-granite/granite-timeseries-patchtst-fm-r2`](https://huggingface.co/ibm-granite/granite-timeseries-patchtst-fm-r2) (Apache-2.0 / OpenMDW 1.0; requires `granite-tsfm>=0.3.9`)
 - [Sundial](api/models/foundation/models.md#foundationforecast.models.sundial.Sundial) ([arXiv:2502.00816](https://arxiv.org/pdf/2502.00816))
 - [T0](api/models/foundation/models.md#foundationforecast.models.t0.T0) ([t0-alpha](https://huggingface.co/theforecastingcompany/t0-alpha), [t0-beta](https://huggingface.co/theforecastingcompany/t0-beta), [t0-gamma](https://huggingface.co/theforecastingcompany/t0-gamma); requires `tfc-t0[torch]>=0.6.0`) — Python 3.11–3.13
+- [Tabby](api/models/foundation/models.md#foundationforecast.models.tabby.Tabby) ([arXiv:2609.13956](https://arxiv.org/abs/2609.13956), [`paris-noah/Tabby`](https://huggingface.co/paris-noah/Tabby)) — 99 native quantiles (0.01–0.99); `trust_remote_code`; [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)
 - [TabPFN](api/models/foundation/models.md#foundationforecast.models.tabpfn.TabPFN) ([arXiv:2501.02945](https://arxiv.org/abs/2501.02945)) — Python 3.10–3.12; TabPFN-2 (default) and TabPFN-3 via `model_path`; TabPFN-3 is LOCAL-only; weights use the [TabPFN NC license](https://ux.priorlabs.ai) (`TABPFN_TOKEN`)
 - [Tafsut](api/models/foundation/models.md#foundationforecast.models.tafsut.Tafsut) ([GitHub](https://github.com/Tafsut-FM/tafsut))
 - [TiRex / TiRex-2](api/models/foundation/models.md#foundationforecast.models.tirex.TiRex) ([arXiv:2505.23719](https://arxiv.org/abs/2505.23719), [arXiv:2607.01204](https://arxiv.org/abs/2607.01204)) — Python 3.11+
diff --git a/mkdocs.yml b/mkdocs.yml
index 1feccb4..5fbf037 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -31,6 +31,7 @@ nav:
           - Chronos: examples/chronos-family.ipynb
           - TimesFM: examples/timesfm-family.ipynb
           - TiRex: examples/tirex-family.ipynb
+          - Tabby: examples/tabby-family.ipynb
           - TabPFN: examples/tabpfn-family.ipynb
           - Toto: examples/toto-family.ipynb
           - PatchTST-FM: examples/patchtst-fm-family.ipynb

From f25cb7bd9a76473d9f6c29476dd737f40546326c Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:26:39 -0600
Subject: [PATCH 04/10] feat(tabby): match the official GIFT-Eval inference
 path

Call the model forward with context_mask and past_is_pad so batch left
padding is not treated as missing history, keep the context in float32,
and add a precision option (bf16 autocast on CUDA by default).

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 foundationforecast/models/tabby.py | 53 +++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 12 deletions(-)

diff --git a/foundationforecast/models/tabby.py b/foundationforecast/models/tabby.py
index b6612ee..983f5dd 100644
--- a/foundationforecast/models/tabby.py
+++ b/foundationforecast/models/tabby.py
@@ -1,6 +1,6 @@
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Any
+from typing import Any, Literal
 
 import numpy as np
 import pandas as pd
@@ -9,14 +9,14 @@
 from transformers import AutoModel
 
 from ..core.exog.covariates import ExogStrategyConfig
-from ..core.forecaster import ExogCapableForecaster, QuantileConverter, _DataProcessor
+from ..core.forecaster import ExogCapableForecaster, QuantileConverter
 from ..core.quantiles import resolve_quantile_values
 from ..core.utils import PanelData, TimeSeriesDataset
 
 TABBY_QUANTILES = [round(i / 100, 2) for i in range(1, 100)]
 
 
-class Tabby(ExogCapableForecaster, _DataProcessor):
+class Tabby(ExogCapableForecaster):
     """
     Tabby is a zero-shot probabilistic univariate time series foundation model
     from [Huawei Paris Noah's Ark Lab](https://huggingface.co/paris-noah).
@@ -34,6 +34,7 @@ def __init__(
         alias: str = "Tabby",
         reuse_loaded_model: bool = True,
         exog_strategy: ExogStrategyConfig = "auto",
+        precision: Literal["bf16", "fp32"] = "bf16",
     ):
         """
         Args:
@@ -53,6 +54,10 @@ def __init__(
                 loaded checkpoint weights across repeated ``forecast()`` calls
                 via the process-wide LRU cache. Set to False to load and
                 release weights on every call.
+            precision (str, optional): ``"bf16"`` (default) runs the forward
+                pass under bfloat16 autocast on CUDA, as in the published
+                GIFT-Eval evaluation; ``"fp32"`` disables autocast. On CPU the
+                model always runs in float32.
 
         Notes:
             **Academic Reference:**
@@ -70,7 +75,9 @@ def __init__(
             - 99 native quantile knots (0.01–0.99); the median (0.5) is the
               point forecast. Requested ``level`` / ``quantiles`` are linearly
               interpolated with edge clamping.
-            - Missing values in the context are handled natively via NaN.
+            - Missing values in the context are handled natively via NaN;
+              left padding of shorter series in a batch is flagged as padding
+              (``past_is_pad``) rather than missing data.
             - Univariate only; no covariates.
             - Weights are [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/).
         """
@@ -82,6 +89,7 @@ def __init__(
         self.context_length = context_length
         self.batch_size = batch_size
         self.alias = alias
+        self.precision = precision
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
     def _load_model(self) -> Any:
@@ -102,6 +110,19 @@ def _native_quantiles(self, model: Any) -> list[float]:
             return [float(q) for q in levels]
         return list(TABBY_QUANTILES)
 
+    def _to_context(
+        self, batch: list[torch.Tensor]
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Left-pad a ragged batch, returning ``(context, past_is_pad)``."""
+        series = [ts[-self.context_length :].to(torch.float32) for ts in batch]
+        width = max(len(ts) for ts in series)
+        context = torch.full((len(series), width), float("nan"))
+        past_is_pad = torch.zeros((len(series), width), dtype=torch.bool)
+        for idx, ts in enumerate(series):
+            context[idx, width - len(ts) :] = ts
+            past_is_pad[idx, : width - len(ts)] = True
+        return context, past_is_pad
+
     def _predict_batch(
         self,
         model: Any,
@@ -110,14 +131,21 @@ def _predict_batch(
         quantiles: list[float] | None,
         supported_quantiles: list[float],
     ) -> tuple[np.ndarray, np.ndarray | None]:
-        context = self._prepare_and_validate_context(batch)
-        if context.shape[1] > self.context_length:
-            context = context[..., -self.context_length :]
-        with torch.inference_mode():
-            # (batch_size, 99, h)
-            out = model.predict(context.to(dtype=torch.float32), prediction_length=h)
-        fcst_np = np.asarray(out.detach().cpu().numpy())
-        fcst_np = np.moveaxis(fcst_np, 1, -1)  # (batch_size, h, 99)
+        context, past_is_pad = self._to_context(batch)
+        context = context.to(self.device)
+        use_bf16 = self.precision == "bf16" and self.device.type == "cuda"
+        with (
+            torch.inference_mode(),
+            torch.autocast("cuda", dtype=torch.bfloat16, enabled=use_bf16),
+        ):
+            out = model(
+                context=context,
+                context_mask=torch.isfinite(context).float(),
+                past_is_pad=past_is_pad.to(self.device),
+                prediction_length=h,
+            )["quantile_preds"]
+        # (batch_size, 99, h) -> (batch_size, h, 99)
+        fcst_np = np.moveaxis(out.float().cpu().numpy(), 1, -1)
         median_idx = supported_quantiles.index(0.5)
         fcst_mean_np = fcst_np[..., median_idx]
         fcst_quantiles_np = fcst_np if quantiles is not None else None
@@ -225,6 +253,7 @@ def _forecast_univariate(
         dataset = self._make_timeseries_dataset(
             df,
             batch_size=self.batch_size,
+            dtype=torch.float32,
             panel=panel,
         )
         fcst_df = dataset.make_future_dataframe(h=h, freq=freq)

From b1b7d3c81c71bada64c7e17525f6275269f2fd29 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:26:39 -0600
Subject: [PATCH 05/10] test(tabby): cover padding mask, fp32 context and
 precision autocast

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 tests/models/test_tabby.py | 99 +++++++++++++++++++++++++++-----------
 1 file changed, 72 insertions(+), 27 deletions(-)

diff --git a/tests/models/test_tabby.py b/tests/models/test_tabby.py
index e0d3384..783f2b9 100644
--- a/tests/models/test_tabby.py
+++ b/tests/models/test_tabby.py
@@ -1,7 +1,9 @@
 from unittest.mock import MagicMock
 
 import numpy as np
+import pandas as pd
 import pytest
+import torch
 
 from tests.helpers import generate_series
 from foundationforecast.models.tabby import TABBY_QUANTILES, Tabby
@@ -9,10 +11,29 @@
 pytestmark = pytest.mark.models
 
 
+def _mock_model(mocker, model: Tabby, h: int) -> MagicMock:
+    n_q = len(TABBY_QUANTILES)
+    # Rising knots so 0.1 < 0.9 after remap from [B, 99, H]
+    knots = torch.linspace(0.0, 1.0, n_q)
+    backend = MagicMock()
+    backend.quantile_levels = TABBY_QUANTILES
+    backend.side_effect = lambda **kwargs: {
+        "quantile_preds": knots[None, :, None].expand(
+            kwargs["context"].shape[0], n_q, h
+        )
+    }
+    cm = MagicMock()
+    cm.__enter__.return_value = backend
+    cm.__exit__.return_value = None
+    mocker.patch.object(model, "_get_model", return_value=cm)
+    return backend
+
+
 def test_tabby_default_alias_and_repo():
     model = Tabby()
     assert model.alias == "Tabby"
     assert model.repo_id == "paris-noah/Tabby"
+    assert model.precision == "bf16"
     assert not model.supports_native_futr_exog()
 
 
@@ -20,38 +41,62 @@ def test_tabby_predict_axis_maps_to_ff_columns(mocker):
     model = Tabby(context_length=64, batch_size=2)
     df = generate_series(2, freq="D", min_length=32, max_length=32, equal_ends=True)
     h = 4
-    n_q = len(TABBY_QUANTILES)
-    # Rising knots so 0.1 < 0.9 after remap from [B, 99, H]
-    knots = np.linspace(0.0, 1.0, n_q, dtype=np.float32)
-    fake = np.broadcast_to(knots[None, :, None], (2, n_q, h)).copy()
-
-    mock_model = MagicMock()
-    mock_model.quantile_levels = TABBY_QUANTILES
-    mock_model.predict.return_value = _Tensor(fake)
-    mock_cm = MagicMock()
-    mock_cm.__enter__.return_value = mock_model
-    mock_cm.__exit__.return_value = None
-    mocker.patch.object(model, "_get_model", return_value=mock_cm)
+    backend = _mock_model(mocker, model, h)
 
     fcst = model.forecast(df, h=h, freq="D", quantiles=[0.1, 0.5, 0.9])
     assert fcst.shape[0] == 2 * h
     assert "Tabby" in fcst.columns
     assert (fcst["Tabby-q-10"] < fcst["Tabby-q-90"]).all()
-    assert mock_model.predict.call_args.kwargs["prediction_length"] == h
-
-
-class _Tensor:
-    def __init__(self, array: np.ndarray):
-        self._array = array
-
-    def detach(self):
-        return self
-
-    def cpu(self):
-        return self
-
-    def numpy(self):
-        return self._array
+    assert backend.call_args.kwargs["prediction_length"] == h
+
+
+def test_tabby_flags_left_padding_and_keeps_fp32_context(mocker):
+    model = Tabby(context_length=16, batch_size=2)
+    backend = _mock_model(mocker, model, h=2)
+    df = pd.DataFrame(
+        {
+            "unique_id": ["a"] * 10 + ["b"] * 20,
+            "ds": list(pd.date_range("2020-01-01", periods=10, freq="D"))
+            + list(pd.date_range("2020-01-01", periods=20, freq="D")),
+            "y": np.r_[np.full(10, 12345.678), np.arange(20) + 0.001],
+        }
+    )
+    df.loc[25, "y"] = np.nan
+
+    model.forecast(df, h=2, freq="D")
+
+    kwargs = backend.call_args.kwargs
+    context = kwargs["context"]
+    mask = kwargs["context_mask"]
+    pad = kwargs["past_is_pad"]
+    assert context.shape == (2, 16)
+    assert context.dtype == torch.float32
+    assert pad[0].tolist() == [True] * 6 + [False] * 10
+    assert not pad[1].any()
+    np.testing.assert_allclose(context[0, 6:].numpy(), 12345.678, rtol=1e-7)
+    assert mask[0, :6].sum() == 0
+    assert mask[1].sum() == 15
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="autocast needs CUDA")
+@pytest.mark.parametrize(
+    ("precision", "dtype"), [("bf16", torch.bfloat16), ("fp32", None)]
+)
+def test_tabby_precision_controls_autocast(mocker, precision, dtype):
+    model = Tabby(batch_size=2, precision=precision)
+    backend = _mock_model(mocker, model, h=2)
+    inner = backend.side_effect
+    seen = []
+
+    def record(**kwargs):
+        enabled = torch.is_autocast_enabled("cuda")
+        seen.append(torch.get_autocast_dtype("cuda") if enabled else None)
+        return inner(**kwargs)
+
+    backend.side_effect = record
+    df = generate_series(1, freq="D", min_length=20, max_length=20)
+    model.forecast(df, h=2, freq="D")
+    assert seen == [dtype]
 
 
 def test_tabby_forecasts_tail_quantiles():

From e888e140dad87585d37690614036673b83024314 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:27:31 -0600
Subject: [PATCH 06/10] feat(experiments): replicate Tabby on GIFT-Eval

Register paris-noah/Tabby against the official Tabby results (seed-42
prompt release, flagged testdata_leakage) with the published settings:
8,096-step context and bf16 autocast. Adds it to the CI subset.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 experiments/gift-eval/configs/ci_subset.yaml |  3 +++
 experiments/gift-eval/configs/models.yaml    | 10 ++++++++++
 2 files changed, 13 insertions(+)

diff --git a/experiments/gift-eval/configs/ci_subset.yaml b/experiments/gift-eval/configs/ci_subset.yaml
index 3f99a0d..6300416 100644
--- a/experiments/gift-eval/configs/ci_subset.yaml
+++ b/experiments/gift-eval/configs/ci_subset.yaml
@@ -50,3 +50,6 @@ jobs:
   - model_key: h2oai--timeh2o-v1
     dataset_name: m4_weekly
     term: short
+  - model_key: paris-noah--Tabby
+    dataset_name: m4_weekly
+    term: short
diff --git a/experiments/gift-eval/configs/models.yaml b/experiments/gift-eval/configs/models.yaml
index 95f3923..e52dcc2 100644
--- a/experiments/gift-eval/configs/models.yaml
+++ b/experiments/gift-eval/configs/models.yaml
@@ -350,6 +350,16 @@ models:
       clip_nonnegative: true
       snap_integer: true
 
+  paris-noah--Tabby:
+    class: foundationforecast.models.tabby.Tabby
+    reference_slug: Tabby
+    kwargs:
+      repo_id: paris-noah/Tabby
+      alias: Tabby
+      context_length: 8096
+      batch_size: 64
+      precision: bf16
+
   thuml--sundial-base-128m:
     class: foundationforecast.models.sundial.Sundial
     reference_slug: sundial_base_128m

From 659e47c04d9ca6a949442c51db6f948e20499759 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:27:31 -0600
Subject: [PATCH 07/10] test(experiments): check Tabby GIFT-Eval registration

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 experiments/gift-eval/tests/test_models_config.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/experiments/gift-eval/tests/test_models_config.py b/experiments/gift-eval/tests/test_models_config.py
index 4f3e287..23750d3 100644
--- a/experiments/gift-eval/tests/test_models_config.py
+++ b/experiments/gift-eval/tests/test_models_config.py
@@ -67,3 +67,14 @@ def test_model_python_defaults_unless_overridden():
 
     assert model_python("h2oai--timeh2o-v1", default="3.11") == "3.12"
     assert model_python("mistralai--Timestral-209M", default="3.11") == "3.11"
+
+
+def test_tabby_registered_with_leaderboard_settings():
+    models = load_models_config()
+    entry = models["paris-noah--Tabby"]
+    assert entry["class"] == "foundationforecast.models.tabby.Tabby"
+    assert entry["reference_slug"] == "Tabby"
+    kwargs = entry["kwargs"]
+    assert kwargs["repo_id"] == "paris-noah/Tabby"
+    assert kwargs["context_length"] == 8096
+    assert kwargs["precision"] == "bf16"

From 463e9cb3c3042e03743ded21b55e64379b20d451 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:42:08 -0600
Subject: [PATCH 08/10] docs(examples): rework Tabby notebook with
 cross-validation and executed outputs

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 docs/examples/index.md           |   2 +-
 docs/examples/tabby-family.ipynb | 978 +++++++++++++++++++++++++++----
 2 files changed, 856 insertions(+), 124 deletions(-)

diff --git a/docs/examples/index.md b/docs/examples/index.md
index dece411..84107aa 100644
--- a/docs/examples/index.md
+++ b/docs/examples/index.md
@@ -20,7 +20,7 @@ For model API details, see the [Model Hub](../model-hub.md).
 | [Chronos Family](chronos-family.ipynb) | Forecast with Chronos 1.x and 2.x checkpoints | Python 3.10+ |
 | [TimesFM Family](timesfm-family.ipynb) | Forecast with TimesFM 1.0, 2.0, 2.5, and 3.0 with prediction intervals | Python 3.10+ |
 | [TiRex Family](tirex-family.ipynb) | Forecast with TiRex 1.0 and 2.0 | Python 3.11+ |
-| [Tabby Family](tabby-family.ipynb) | Forecast with Tabby (`paris-noah/Tabby`) | Python 3.10+ |
+| [Tabby Family](tabby-family.ipynb) | Cross-validate Tabby (`paris-noah/Tabby`) with its published GIFT-Eval inference settings | Python 3.10+ |
 | [TabPFN Family](tabpfn-family.ipynb) | Forecast with TabPFN-2 and TabPFN-3 (LOCAL) | Python 3.10–3.12; `TABPFN_TOKEN` |
 | [Toto Family](toto-family.ipynb) | Forecast with Toto 1.0 and 2.0 | Python 3.10+ |
 | [PatchTST-FM Family](patchtst-fm-family.ipynb) | Forecast with IBM Research and Granite PatchTST-FM r1/r2 | Python 3.11–3.13; GPU recommended |
diff --git a/docs/examples/tabby-family.ipynb b/docs/examples/tabby-family.ipynb
index 0e1bd83..6bc47d7 100644
--- a/docs/examples/tabby-family.ipynb
+++ b/docs/examples/tabby-family.ipynb
@@ -1,139 +1,871 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Forecast Using Tabby\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "!UV_CONSTRAINT= UV_BUILD_CONSTRAINT= uv pip install -q \"foundationforecast[plot]\""
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "foundationforecast ships a `Tabby` class for [Huawei Paris Noah's Ark Lab](https://huggingface.co/paris-noah)'s [Tabby](https://huggingface.co/paris-noah/Tabby) checkpoint ([arXiv:2609.13956](https://arxiv.org/abs/2609.13956)). The released weights are a self-contained prompted PatchTST-style model (~147M) loaded with `transformers.AutoModel` and `trust_remote_code=True`.\n",
-        "\n",
-        "Tabby forecasts each series independently with 99 native quantile knots (0.01–0.99). The backbone window is 8,192 steps; for horizon `H` it masks `max(H, 128)` future positions. It does not accept known-future covariates — use `exog_strategy=False` in mixed `FoundationForecast` runs.\n",
-        "\n",
-        "*Requirements:*\n",
-        "\n",
-        "    - Python 3.10+\n",
-        "    - `transformers` and `torch` (installed with foundationforecast)\n",
-        "\n",
-        "**License:** checkpoint weights are [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) (non-commercial).\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Import libraries\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import pandas as pd\n",
-        "\n",
-        "from foundationforecast import FoundationForecast\n",
-        "from foundationforecast.models import Tabby\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Load the dataset\n",
-        "\n",
-        "The DataFrame must include at least the following columns:\n",
-        "- unique_id: Unique identifier for each time series (string)\n",
-        "- ds: Date column (datetime format)\n",
-        "- y: Target variable for forecasting (float format)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "df = pd.read_csv(\n",
-        "    \"https://timecopilot.s3.amazonaws.com/public/data/air_passengers.csv\",\n",
-        "    parse_dates=[\"ds\"],\n",
-        ")\n",
-        "df.head()\n"
-      ]
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7077d7df",
+   "metadata": {
+    "id": "7077d7df"
+   },
+   "source": [
+    "# Forecast Using Tabby"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "07c31036",
+   "metadata": {
+    "id": "07c31036"
+   },
+   "outputs": [],
+   "source": [
+    "!UV_CONSTRAINT= UV_BUILD_CONSTRAINT= uv pip install -q \"foundationforecast[plot]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d0b199e",
+   "metadata": {
+    "id": "8d0b199e"
+   },
+   "source": [
+    "foundationforecast ships a `Tabby` class for [Huawei Paris Noah's Ark Lab](https://huggingface.co/paris-noah)'s [Tabby](https://huggingface.co/paris-noah/Tabby) model ([arXiv:2609.13956](https://arxiv.org/abs/2609.13956)):\n",
+    "\n",
+    "| Checkpoint | `repo_id` | Parameters | Native quantiles |\n",
+    "|------------|-----------|------------|------------------|\n",
+    "| **Tabby** (default) | `paris-noah/Tabby` | ~147M | 99 (0.01–0.99) |\n",
+    "\n",
+    "The released weights are a frozen pretrained patch-transformer backbone plus a small prompt module, loaded with `transformers.AutoModel` and `trust_remote_code=True`. Tabby forecasts each series independently. Its backbone window is 8,192 steps; for a horizon `H` it masks `max(H, 128)` future positions, so it uses at most `8192 - max(H, 128)` observed steps of history (the default `context_length` is 8,096, the published GIFT-Eval input cap).\n",
+    "\n",
+    "**Benchmarks and license:** the prompt was trained on GIFT-Eval *training* tasks, so the [GIFT-Eval](https://huggingface.co/spaces/Salesforce/GIFT-Eval) leaderboard flags the submission as `testdata_leakage: Yes` (MASE 0.688, CRPS 0.476). The weights are released under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) (non-commercial).\n",
+    "\n",
+    "**Prediction intervals:** pass any `level` or `quantiles`. Values between the 99 native knots are linearly interpolated; the median (0.5) is the point forecast.\n",
+    "\n",
+    "In this example we cross-validate Tabby with its published inference settings (`precision=\"bf16\"`, the default, which runs bfloat16 autocast on GPU) on event pageview data. Pass `precision=\"fp32\"` to keep the whole forward pass in float32."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8be8bfd",
+   "metadata": {
+    "id": "b8be8bfd"
+   },
+   "source": [
+    "## Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "bb6b6ffa",
+   "metadata": {
+    "id": "bb6b6ffa"
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "from foundationforecast import FoundationForecast"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c54571b2",
+   "metadata": {
+    "id": "c54571b2"
+   },
+   "source": [
+    "## Load the dataset\n",
+    "\n",
+    "The DataFrame must include at least the following columns:\n",
+    "- unique_id: Unique identifier for each time series (string)\n",
+    "- ds: Date column (datetime format)\n",
+    "- y: Target variable for forecasting (float format)\n",
+    "\n",
+    "The pandas frequency will be inferred from the ds column, if not provided.\n",
+    "If the seasonality is not provided, it will be inferred based on the frequency.\n",
+    "If the horizon is not set, it will default to 2 times the inferred seasonality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "41dd3d2c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 206
     },
+    "id": "41dd3d2c",
+    "outputId": "e5b1ce12-7769-48c6-b70f-c2327bb48e3e"
+   },
+   "outputs": [
     {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Create a FoundationForecast\n"
-      ]
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "     unique_id         ds      y\n",
+       "0  Oktoberfest 2020-01-31  25376\n",
+       "1  Oktoberfest 2020-02-29  28470\n",
+       "2  Oktoberfest 2020-03-31  23816\n",
+       "3  Oktoberfest 2020-04-30  46186\n",
+       "4  Oktoberfest 2020-05-31  31213"
+      ],
+      "text/html": [
+       "\n",
+       "  <div id=\"df-49c59363-a13e-45e5-8c63-b36d20c395fb\" class=\"colab-df-container\">\n",
+       "    <div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>unique_id</th>\n",
+       "      <th>ds</th>\n",
+       "      <th>y</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Oktoberfest</td>\n",
+       "      <td>2020-01-31</td>\n",
+       "      <td>25376</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Oktoberfest</td>\n",
+       "      <td>2020-02-29</td>\n",
+       "      <td>28470</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Oktoberfest</td>\n",
+       "      <td>2020-03-31</td>\n",
+       "      <td>23816</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Oktoberfest</td>\n",
+       "      <td>2020-04-30</td>\n",
+       "      <td>46186</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Oktoberfest</td>\n",
+       "      <td>2020-05-31</td>\n",
+       "      <td>31213</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>\n",
+       "    <div class=\"colab-df-buttons\">\n",
+       "\n",
+       "  <div class=\"colab-df-container\">\n",
+       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-49c59363-a13e-45e5-8c63-b36d20c395fb')\"\n",
+       "            title=\"Convert this dataframe to an interactive table.\"\n",
+       "            style=\"display:none;\">\n",
+       "\n",
+       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+       "  </svg>\n",
+       "    </button>\n",
+       "\n",
+       "  <style>\n",
+       "    .colab-df-container {\n",
+       "      display:flex;\n",
+       "      gap: 12px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert {\n",
+       "      background-color: #E8F0FE;\n",
+       "      border: none;\n",
+       "      border-radius: 50%;\n",
+       "      cursor: pointer;\n",
+       "      display: none;\n",
+       "      fill: #1967D2;\n",
+       "      height: 32px;\n",
+       "      padding: 0 0 0 0;\n",
+       "      width: 32px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert:hover {\n",
+       "      background-color: #E2EBFA;\n",
+       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+       "      fill: #174EA6;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-buttons div {\n",
+       "      margin-bottom: 4px;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert {\n",
+       "      background-color: #3B4455;\n",
+       "      fill: #D2E3FC;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert:hover {\n",
+       "      background-color: #434B5C;\n",
+       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+       "      fill: #FFFFFF;\n",
+       "    }\n",
+       "  </style>\n",
+       "\n",
+       "    <script>\n",
+       "      const buttonEl =\n",
+       "        document.querySelector('#df-49c59363-a13e-45e5-8c63-b36d20c395fb button.colab-df-convert');\n",
+       "      buttonEl.style.display =\n",
+       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+       "\n",
+       "      async function convertToInteractive(key) {\n",
+       "        const element = document.querySelector('#df-49c59363-a13e-45e5-8c63-b36d20c395fb');\n",
+       "        const dataTable =\n",
+       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+       "                                                    [key], {});\n",
+       "        if (!dataTable) return;\n",
+       "\n",
+       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+       "          + ' to learn more about interactive tables.';\n",
+       "        element.innerHTML = '';\n",
+       "        dataTable['output_type'] = 'display_data';\n",
+       "        await google.colab.output.renderOutput(dataTable, element);\n",
+       "        const docLink = document.createElement('div');\n",
+       "        docLink.innerHTML = docLinkHtml;\n",
+       "        element.appendChild(docLink);\n",
+       "      }\n",
+       "    </script>\n",
+       "  </div>\n",
+       "\n",
+       "\n",
+       "    </div>\n",
+       "  </div>\n"
+      ],
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "dataframe",
+       "variable_name": "df",
+       "summary": "{\n  \"name\": \"df\",\n  \"rows\": 408,\n  \"fields\": [\n    {\n      \"column\": \"unique_id\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Oktoberfest\",\n          \"Black Friday\",\n          \"Thanksgiving\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"ds\",\n      \"properties\": {\n        \"dtype\": \"date\",\n        \"min\": \"2020-01-31 00:00:00\",\n        \"max\": \"2025-08-31 00:00:00\",\n        \"num_unique_values\": 68,\n        \"samples\": [\n          \"2023-11-30 00:00:00\",\n          \"2021-05-31 00:00:00\",\n          \"2020-05-31 00:00:00\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 285170,\n        \"min\": 384,\n        \"max\": 3215198,\n        \"num_unique_values\": 404,\n        \"samples\": [\n          3774,\n          5880,\n          113904\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+      }
+     },
+     "metadata": {},
+     "execution_count": 3
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\n",
+    "    \"https://timecopilot.s3.amazonaws.com/public/data/events_pageviews.csv\",\n",
+    "    parse_dates=[\"ds\"],\n",
+    ")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ccb0e238",
+   "metadata": {
+    "id": "ccb0e238"
+   },
+   "source": [
+    "## Plot the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d1da7db0",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 964
     },
+    "id": "d1da7db0",
+    "outputId": "bdd2d2f3-c125-45bc-bbf9-01532f44e79e"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ff = FoundationForecast(\n",
-        "    models=[\n",
-        "        Tabby(alias=\"Tabby\"),\n",
-        "    ]\n",
-        ")\n"
-      ]
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "<Figure size 1600x1050 with 6 Axes>"
+      ],
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "execution_count": 4
+    }
+   ],
+   "source": [
+    "FoundationForecast.plot(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8b5f7426",
+   "metadata": {
+    "id": "8b5f7426"
+   },
+   "source": [
+    "## Import the models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e00a0fab",
+   "metadata": {
+    "id": "e00a0fab"
+   },
+   "outputs": [],
+   "source": [
+    "from foundationforecast.models import Tabby"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e73822d0",
+   "metadata": {
+    "id": "e73822d0"
+   },
+   "source": [
+    "## Create a FoundationForecast"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "95dec9b8",
+   "metadata": {
+    "id": "95dec9b8"
+   },
+   "outputs": [],
+   "source": [
+    "models = [\n",
+    "    Tabby(alias=\"Tabby\", precision=\"bf16\"),\n",
+    "]\n",
+    "\n",
+    "ff = FoundationForecast(models=models)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2b10e18",
+   "metadata": {
+    "id": "e2b10e18"
+   },
+   "source": [
+    "## Generate forecast\n",
+    "\n",
+    "You can optionally specify the following parameters:\n",
+    "- freq: The frequency of your data (e.g., 'D' for daily, 'M' for monthly)\n",
+    "- h: The forecast horizon, which is the number of periods to predict\n",
+    "- seasonality: The seasonal period of your data, which can be inferred if not provided\n",
+    "- level: Prediction interval levels (percent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f1497532",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
+    "id": "f1497532",
+    "outputId": "ec9bf9e3-40d9-41b1-e940-6f5a701ff9aa"
+   },
+   "outputs": [
     {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Forecast\n"
-      ]
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "0it [00:00, ?it/s]\n",
+      "  0%|          | 0/1 [00:00<?, ?it/s]\u001b[A\n",
+      "100%|██████████| 1/1 [00:00<00:00,  1.39it/s]\n",
+      "1it [00:00,  1.34it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "level = [70, 80, 90]\n",
+    "cv_df = ff.cross_validation(df=df, h=12, level=level)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "437b1d5b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 912
     },
+    "id": "437b1d5b",
+    "outputId": "ac6f49e8-b5f2-4001-b29f-69544a3f4d05"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "fcst_df = ff.forecast(df, h=12, freq=\"MS\", level=[90])\n",
-        "fcst_df.head()\n"
-      ]
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "<Figure size 1600x1050 with 6 Axes>"
+      ],
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABwIAAAQlCAYAAAC1awk6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xl4U1X6B/DvTdKka1oW27KvIiA7OIiOgICURUdGdAQZAQUcGeqIKCr+FEUccUVcUGZcWBRccFcUqCwugIOUxY3FBUSQUpa2adI2y73n90dyb5s2bZM2bXLb7+d5+kCSk9uTpss99z3v+0pCCAEiIiIiIiIiIiIiIiIialAMkZ4AEREREREREREREREREYUfA4FEREREREREREREREREDRADgUREREREREREREREREQNEAOBRERERERERERERERERA0QA4FEREREREREREREREREDRADgUREREREREREREREREQNEAOBRERERERERERERERERA0QA4FEREREREREREREREREDRADgUREREREREREREREREQNEAOBREQN0IoVKyBJEo4cORLpqQTlyJEjkCQJK1asqHbs1KlT0b59+zqfUyBbt26FJEl4++236/xztW/fHpdffnmdfx7VyZMncfXVV6NZs2aQJAlLliypt89NRERERNGPa4zwGzp0KIYOHVpnx5ckCZmZmXV2/MoE+7rU9dXWrVvrfE5ERESNGQOBRETUqJ05cwZz587Feeedh9jYWDRt2hQZGRn4+OOPa3zM7du344EHHkB+fn74JlrHbrvtNmzYsAHz5s3Dq6++ilGjRoX1+D/++CMeeOAB3Vw4IiIiIiIKlRp8LPthtVrRp08fPPfcc5BlOdJTDFr79u0rvBb1o6SkJNLTIyIiohCYIj0BIiIKv+uvvx4TJkyAxWKJ9FSC0q5dOxQXFyMmJqZeP+/BgwcxfPhwnDp1CjfccAMGDBiA/Px8rF69GldccQXuuOMOPP744yEfd/v27ViwYAGmTp2KlJSU8E+8DmzevBlXXnkl7rjjjjo5/o8//ogFCxZg6NChEcvoJCIiIqKa4xojeBMnTsSYMWMAAAUFBfjkk09wyy234LfffqvR+iJS+vTpg9tvv73C/Wazucrnbdy4sa6mRERERDXAQCARUQNkNBphNBojPY2gSZKE2NjYev2cbrcbV199NfLy8vDFF19g4MCB2mO33XYbJk2ahCeeeAIDBgzAtddeW69zqy8ejweKosBsNiM3N1c3QUsiIiIiqn9cYwSvX79++Pvf/67d/uc//4mBAwdizZo1ugoEtmrVyu91VKeoqAjx8fHVBgqJiIiofrE0KBFRFKisJ8UDDzwASZK022qPh/fffx89evSAxWLB+eefj/Xr1/s9L1D/DiEEHnroIbRu3Rrx8fG49NJL8cMPP6B9+/aYOnVqpZ+zqmMCwKeffopLLrkECQkJSEpKwtixY/HDDz+E9Por69+hvs7Y2Fj06NED7733XkjHrco777yD77//HnfffbdfEBDwXuT4z3/+g5SUFDzwwANVHsfpdOLyyy9HcnKyVhJ07ty5AIAOHTpo5XPUr5vH48HChQvRqVMnWCwWtG/fHvfccw+cTmfA42/cuBF9+vRBbGwsunfvjnfffbfCmPz8fMyePRtt2rSBxWJB586d8eijj0JRFG2M+jV+4oknsGTJEu3zP//885AkCUIILF26VJtvKMcGgDfeeAP9+/dHUlISrFYrevbsiaeffhqA93vnmmuuAQBceuml2udgLxAiIiKiuhHs+gLgGiOca4zKSJKEtLQ0mExV78d3uVyYP38++vfvj+TkZCQkJOCSSy7Bli1bKoxVFAVPP/00evbsidjYWJxzzjkYNWoUdu3aVeXneOihh2AwGPDss8/W6jUNHToUPXr0QHZ2NgYPHoz4+Hjcc8892mPlewQeO3YM48aNQ0JCAlJTU3HbbbcFXAN9+eWXuOaaa9C2bVtYLBa0adMGt912G4qLi7Uxy5cvhyRJ2LNnT4XnP/zwwzAajTh+/HitXh8REVFDwoxAIiKd+eqrr/Duu+/in//8J5KSkvDMM89g/PjxOHr0KJo1a1bp8+bPn4+HHnoIY8aMwZgxY7B7926MHDkSLperxnN59dVXMWXKFGRkZODRRx9FUVERXnjhBfz5z3/Gnj17alUCcuPGjRg/fjy6d++ORYsW4cyZM7jhhhvQunXrCmPz8vKC6rcRHx+P+Ph4AMBHH30EAJg8eXLAscnJybjyyiuxcuVK/Pzzz+jcuXOFMcXFxbjyyiuxa9cufPbZZ7jggguQmJiIQ4cO4fXXX8dTTz2F5s2bAwDOOeccAMD06dOxcuVKXH311bj99tvxv//9D4sWLcL+/fsrXIT46aefcO211+Lmm2/GlClTsHz5clxzzTVYv349LrvsMgDeXbdDhgzB8ePH8Y9//ANt27bF9u3bMW/ePJw4cQJLlizxO+by5ctRUlKCm266CRaLBf369cOrr76K66+/Hpdddpnf1yPYY2dlZWHixIkYPnw4Hn30UQDA/v37sW3bNtx6660YPHgw/vWvf+GZZ57BPffcg27dugGA9i8RERERRRbXGOFZY6iKiopw+vRpAIDNZsOnn36K9evXY968eVUey2az4aWXXsLEiRMxY8YMFBYW4uWXX0ZGRgZ27tyJPn36aGOnTZuGFStWYPTo0Zg+fTo8Hg++/PJLfP311xgwYEDA49977714+OGH8Z///AczZsyo9rW53W7tdQR6vWfOnMHo0aMxYcIE/P3vf0daWlrA4xQXF2P48OE4evQo/vWvf6Fly5Z49dVXsXnz5gpj165di6KiIsycORPNmjXDzp078eyzz+LYsWNYu3YtAODqq6/GrFmzsHr1avTt29fv+atXr8bQoUPRqlWral8fERFRoyGIiCjipkyZItq1a1fh/vvvv1+U/VUNQJjNZvHzzz9r9+3bt08AEM8++6x23/LlywUAcfjwYSGEELm5ucJsNouxY8cKRVG0cffcc48AIKZMmVLp56zsmIWFhSIlJUXMmDHDb1xOTo5ITk6ucH9VDh8+LACI5cuXa/f16dNHtGjRQuTn52v3bdy4UQCo8LVq166dAFDtx/333+93/OTk5CrntXjxYgFAfPjhh0IIIbZs2SIAiLVr14rCwkIxZMgQ0bx5c7Fnzx6/5z3++ON+XyvV3r17BQAxffp0v/vvuOMOAUBs3ry5wmt65513tPsKCgpEixYtRN++fbX7Fi5cKBISEsShQ4f8jnn33XcLo9Eojh49KoQo/RpbrVaRm5tb4bUCELNmzfK7L9hj33rrrcJqtQqPx1PhuKq1a9cKAGLLli2VjiEiIiKi8Ah2fSEE1xjhXGOonzPQx8yZM/2+TkIIMWTIEDFkyBDttsfjEU6n029MXl6eSEtLEzfeeKN23+bNmwUA8a9//avC6y77Ocqe499+++3CYDCIFStWVPu1q+r1q693yJAhAoBYtmxZheeWf11LliwRAMRbb72l3edwOETnzp0rrBGKiooqHG/RokVCkiTx22+/afdNnDhRtGzZUsiyrN23e/fuCu85ERERCcGMQCIinRkxYgQ6deqk3e7VqxesVit+/fXXSp/z2WefweVy4ZZbbvEryTN79mw8/PDDNZpHVlYW8vPzMXHiRL9dokajEQMHDgxYviZYJ06cwN69e3H33XcjOTlZu/+yyy5D9+7d4XA4/MavXr3ar1RMZTp27Kj9v7CwEElJSVWOVx+32Wx+9xcUFGDkyJH49ddfsXXrVpx//vnVfm4A+OSTTwAAc+bM8bv/9ttvxxNPPIF169bh0ksv1e5v2bIl/vrXv2q3rVYrJk+ejEcffRQ5OTlIT0/H2rVrcckll6BJkyZ+78OIESPwyCOP4IsvvsCkSZO0+8ePH69lJ1Yn2GOnpKTA4XAgKysLo0aNCurYRERERBQ9uMYIzxpDddNNN2ml8W02GzZv3owXXngBFosFTz31VKXHKtuHUVEU5OfnQ1EUDBgwALt379bGvfPOO5AkCffff3+FY5QvwSqEQGZmJv7zn//gtddew8SJE6t9TaqBAwfioYceqvT1WiwW3HDDDdUe55NPPkGLFi1w9dVXa/fFx8fjpptuwp133uk3Ni4uTvu/w+FAcXExLrroIgghsGfPHrRt2xaAt7LL66+/ji1btmD48OEAvO9ZXFwcxo8fH/RrJCIiagwYCCQi0hl14VNWkyZNkJeXV+lzfvvtNwDAueee63f/OeecgyZNmtRoHj/99BMAYNiwYQEft1qtNTouUPl8AeC8887zWwQDwMUXXxzy50hKSqpQ5qa8wsJCbWxZs2fPRklJCfbs2RN0EBDwvi6DwVChzGh6ejpSUlK0163q3LlzhYV8ly5dAHh7nqSnp+Onn37Ct99+W2lwLzc31+92hw4dgp5vsMf+5z//ibfeegujR49Gq1atMHLkSPztb39jUJCIiIhIJ7jGCM8aQ3XuuedixIgR2u2rrroKkiRhyZIluPHGG9GzZ89Kn7ty5Uo8+eSTOHDgANxut3Z/2fP4X375BS1btkTTpk2rncuqVatgt9vxwgsvhBQEBIDmzZv7vY7yWrVqBbPZXO1xfvvtt4Brm/POO6/C2KNHj2L+/Pn48MMPK3z/FRQUaP+/7LLL0KJFC6xevRrDhw+Hoih4/fXXceWVV1a74ZOIiKixYSCQiCgKlF8QqQL1pFB3iJYnhKjXuSiKAsDbwyM9Pb3CeJOp/v7EnDp1Kqj+HYmJiUhMTATg7U+3d+9eHD16NOCFDwD49ttvAQDdu3f3u//KK6/EG2+8gUceeQSrVq2CwWAIab6VfY1rQlEUXHbZZRV20qrUwKGq7A7bcB07NTUVe/fuxYYNG/Dpp5/i008/xfLlyzF58mSsXLky6M9HREREROERyvoC4BojkJqsMaoyfPhwPPfcc/jiiy8qDQS+9tprmDp1KsaNG4e5c+ciNTUVRqMRixYtwi+//BLyawC8Ac29e/fiueeew9/+9reggofBCmVtEQxZlnHZZZfh7NmzuOuuu9C1a1ckJCTg+PHjmDp1qvb9AXi/Z6+77jq8+OKLeP7557Ft2zb88ccf+Pvf/x7WORERETUEDAQSEUWBJk2aID8/v8L95TPEaqpdu3YAvDtsy5ZyOXXqVIVdluru3fz8fKSkpFQ6F7V0UGpqapW7RGs73/IOHjxY4b4LLrggqK/V/fffjwceeAAAcPnll+P111/HqlWrcO+991YYa7PZ8MEHH6Br164VMvjGjRuHkSNHYurUqUhKSsILL7zg93hlFzratWsHRVHw008/oVu3btr9J0+eRH5+vva6VT///DOEEH7HO3ToEACgffv2ALzvg91uD/t7EOqxzWYzrrjiClxxxRVQFAX//Oc/8Z///Af33XdfwN2/RERERFR36np9AXCNoSq7xqiKx+MBANjt9krHvP322+jYsSPeffddv/Pn8iVAO3XqhA0bNuDs2bPVBvY6d+6Mxx57DEOHDsWoUaOwadOmes+Ya9euHb7//vsKa5vyX/fvvvsOhw4dwsqVKzF58mTt/qysrIDHnTx5Mp588kl89NFH+PTTT3HOOecgIyOjbl4EERGRjoWWwkBERHWiU6dOKCgo0DLQAG8Pi/feey8sxx8xYgRiYmLw7LPP+u3qXbJkScC5AMAXX3yh3edwOCpkdmVkZMBqteLhhx/2K1mjOnXqVI3n26JFC/Tp0wcrV670K/+SlZWFH3/8scL41atXIysrq9qPsovJq6++Gt27d8cjjzyCXbt2+R1PURTMnDkTeXl5AftuAN5F5zPPPINly5bhrrvu8nssISEBACpcfBkzZgyAil/3xYsXAwDGjh3rd/8ff/zh9z1gs9mwatUq9OnTR9sh/be//Q07duzAhg0bKswxPz9fu+BQE8Ee+8yZM36PGQwG9OrVCwDgdDoBVP41ISIiIqLwq+v1BcA1RqA1RlU++ugjAEDv3r0rHaNmZpb9ev7vf//Djh07/MaNHz8eQggsWLCgwjECZXH26tULn3zyCfbv348rrrgiqN6H4TRmzBj88ccfePvtt7X7ioqK8N///tdvXKDXL4TA008/HfC4vXr1Qq9evfDSSy/hnXfewYQJE+o1a5SIiEgv+NeRiCgKTJgwAXfddRf++te/4l//+heKiorwwgsvoEuXLhV6VdTEOeecgzvuuAOLFi3C5ZdfjjFjxmDPnj349NNP0bx5c7+xI0eORNu2bTFt2jTMnTsXRqMRr7zyCs455xwcPXpUG2e1WvHCCy/g+uuvR79+/TBhwgRtzLp163DxxRfjueeeq/GcFy1ahLFjx+LPf/4zbrzxRpw9exbPPvsszj///Aq7aGvSv8NsNuPtt9/G8OHD8ec//xk33HADBgwYgPz8fKxZswa7d+/G7bffjgkTJlR6jMzMTNhsNvzf//0fkpOTcc899wAA+vfvDwD4v//7P0yYMAExMTG44oor0Lt3b0yZMgX//e9/kZ+fjyFDhmDnzp1YuXIlxo0bh0svvdTv+F26dMG0adPwzTffIC0tDa+88gpOnjyJ5cuXa2Pmzp2LDz/8EJdffjmmTp2K/v37w+Fw4LvvvsPbb7+NI0eOVHiPgxXssadPn46zZ89i2LBhaN26NX777Tc8++yz6NOnj5b52KdPHxiNRjz66KMoKCiAxWLBsGHDkJqaWqO5EREREVHl6np9AXCNUZXdu3fjtddeA+DtO75p0ya88847uOiiizBy5MhKn3f55Zfj3XffxV//+leMHTsWhw8fxrJly9C9e3e/+V166aW4/vrr8cwzz+Cnn37CqFGjoCgKvvzyS1x66aXIzMyscOwLL7wQH3zwAcaMGYOrr74a77//PmJiYmr8GkMxY8YMPPfcc5g8eTKys7PRokULvPrqq4iPj/cb17VrV3Tq1Al33HEHjh8/DqvVinfeeafKXpWTJ0/GHXfcAQAsC0pERFQZQUREUWHjxo2iR48ewmw2i/POO0+89tpr4v777xdlf1UDELNmzarw3Hbt2okpU6Zot5cvXy4AiMOHD2v3ybIsFixYIFq0aCHi4uLE0KFDxffff1/huUIIkZ2dLQYOHCjMZrNo27atWLx4ccBjCiHEli1bREZGhkhOThaxsbGiU6dOYurUqWLXrl1Bv/bDhw8LAGL58uV+97/zzjuiW7duwmKxiO7du4t3331XTJkyRbRr1y7oY1cnNzdXzJkzR3Tu3FlYLBaRkpIiRowYIT788MMKY7ds2SIAiLVr1/rdf+eddwoA4rnnntPuW7hwoWjVqpUwGAx+Xze32y0WLFggOnToIGJiYkSbNm3EvHnzRElJid8x27VrJ8aOHSs2bNggevXqJSwWi+jatWuFzy2EEIWFhWLevHmic+fOwmw2i+bNm4uLLrpIPPHEE8LlcgkhSr/Gjz/+eMCvQ2XfW8Ec++233xYjR44Uqamp2vfMP/7xD3HixAm/Y7344ouiY8eOwmg0CgBiy5YtAedCRERERLUXzPpCCK4xwrnGUD9n2Q+TySQ6duwo5s6dKwoLC/3GDxkyRAwZMkS7rSiKePjhh0W7du2ExWIRffv2FR9//HHA+Xk8HvH444+Lrl27CrPZLM455xwxevRokZ2drY0J9N5+8MEHwmQyiWuvvVbIslzpa1HXI5UZMmSIOP/88yt9rOzrEkKI3377TfzlL38R8fHxonnz5uLWW28V69evr7Au+PHHH8WIESNEYmKiaN68uZgxY4bYt29fwPdSCCFOnDghjEaj6NKlS6VzJSIiauwkIcLU+ZmIiHSpffv2GDp0KFasWBHpqRARERERUQPANQbVl9OnT6NFixaYP38+7rvvvkhPh4iIKCqxRyARERERERERERHpzooVKyDLMq6//vpIT4WIiChqsUcgERHVGZfLhbNnz1Y5Jjk5GXFxcfU0IyIiIiIi0jOuMQgANm/ejB9//BH//ve/MW7cOLRv3z7SUyIiIopaDAQSEVGd2b59Oy699NIqxyxfvhxTp06tnwkREREREZGucY1BAPDggw9i+/btuPjii/Hss89GejpERERRjT0CiYiozuTl5SE7O7vKMeeffz5atGhRTzMiIiIiIiI94xqDiIiIKDQMBBIRERERERERERERERE1QIZIT4CIiIiIiIiIiIiIiIiIwo89AuuRoij4448/kJSUBEmSIj0dIiIiIqKoIoRAYWEhWrZsCYOBexaDxXUGEREREVHluM6gxo6BwHr0xx9/oE2bNpGeBhERERFRVPv999/RunXrSE9DN7jOICIiIiKqHtcZ1FgxEFiPkpKSAHh/4Vit1gjPhoiIiIgouthsNrRp00Y7b6bgcJ1BRERERFQ5rjOosWMgsB6pZXqsVisX6ERERERElWB5y9BwnUFEREREVD2uM6ixYkFcIiIiIiIiIiIiIiIiogaIgUAiIiIiIiIiIiIiIiKiBoiBQCIiIiIiIiIiIiIiIqIGiIFAIiIiIiIiIiIiIiIiogaIgUAiIiIiIiIiIiIiIiKiBoiBQCIiIiIiIiIiIiIiIqIGiIFAIiIiIiIiIiIiIiIiogaIgUAiIiIiIiIiIiIiIiKiBsgU6QkQERERUcMmhIAkSZGeBhERUcR9uO8PLN54EEsn9cP5LZMjPR0iIiKqI0IIeDweyLIc6alQA2Q0GmEymYK+1sJAIBERERHVGSEEvs6349yEODQ389STiIgat/Xfn8CRM0V4b/dxBgKJiIgaKJfLhRMnTqCoqCjSU6EGLD4+Hi1atIDZbK52LK/GEBEREVGdKvDIOO1yMxBIRESNnt3pzQrIPpoX4ZkQERFRXVAUBYcPH4bRaETLli1hNptZIYfCSggBl8uFU6dO4fDhwzj33HNhMFTdBZBXY4iIiIioTskCOOF047yEWC6AiIioUStyegAAPxy3wemRYTEZIzwjIiIiCieXywVFUdCmTRvEx8dHejrUQMXFxSEmJga//fYbXC4XYmNjqxxfdZiQiIiIiCgMzro9cMhKpKdBREQUUQ6XNyPQJSv4/rgtwrMhIiKiulJdhhZRbYXyPcbvRiIiIiKqc3ZZwVm3J9LTICIiiiiHs/Rv4e7fWB6UiIiIiOoeA4FEREREVOeKZJmBQCIiavSKXGUCgewTSERERET1gIFAIiLSLSEEHv5kP1ZuPxLpqRBRNeKMBvxR4oYsRKSnQkREFDEOp6z9P/u3PAj+XSQiigolsoIzLm5cJKKGiYFAIiLSrWN5xfjvF7/i3+v2Q1F4EYUomiUZjbDLMvLdcvWDiYiIGiBZESgu83cwt9CJ4/nFEZwRERGpTrrcOOjg72QiapgYCCQiIt2ylbgBAC5ZwRmHK8KzIaKqmA0SnIpAvoe7bImIqHEqWxa0a3oSAG9WIBERRZ5HCBRzgzERNVAMBBIRkW4VuUp3VJ+0lURwJkQUDLNBQo7THelpEBERRYR67moySLiwYzMAwJ6j+RGcERERqTwCcCkKWxlQ2AkhUOTyROQjlBLkq1atQrNmzeB0Ov3uHzduHK6//vpwf1monpkiPQEiIqKasjtLd1WftJWgR6vkCM6GiKqTaDLitNuDYllBnJH70YiIqHFRz13jzUb0a9cEK7YfYUYgEVGUkIWAWwh4hIBRkiI9HWpAit0yus/fEJHP/eODGYg3BxcCuuaaa/Cvf/0LH374Ia655hoAQG5uLtatW4eNGzfW5TSpHvAKDBER6ZbDLxDorGIkEUWDRKMBDo/C8qBERNQoFTm9GYGJFhP6t2sCANh/woZiF/vnEhFFmltR4BHeEqFEjVFcXByuu+46LF++XLvvtddeQ9u2bTF06NDITYzCghmBRESkW2UDgTksDUoU9YySBAUCeS4PWljMkZ4OERFRvdIyAi0mtEyORZrVgpM2J749lo+BvlKhREQUGU5FQBECMuOAFGZxMUb8+GBGxD53KGbMmIELLrgAx48fR6tWrbBixQpMnToVErNkdY+BQCIi0i2Hs3T3dC4DgUS6EG8w4A+nG90SBRcTRETUqBS5vIHABLMRkiShf7sm+OS7HGQfzWMgkIgowpzC2x+QGYEUbpIkBV2eM9L69u2L3r17Y9WqVRg5ciR++OEHrFu3LtLTojBgaVAiItItZgQS6U+iyYgCj4xCWYn0VIiIiOqVw1cCNMHivRjYr623POju3/IjNSUiIvJxKYAMAZmBQGrkpk+fjhUrVmD58uUYMWIE2rRpE+kpURhENBC4aNEiXHDBBUhKSkJqairGjRuHgwcP+o0ZOnQoJEny+7j55pv9xhw9ehRjx45FfHw8UlNTMXfuXHjK9Z7ZunUr+vXrB4vFgs6dO2PFihUV5rN06VK0b98esbGxGDhwIHbu3On3eElJCWbNmoVmzZohMTER48ePx8mTJ8PzxSAiopDZXewRSKQ3cQYJxbKCPDf7BBIRUeOibmJTswL6+foE7j6aB8ELz0REEeVSFCjsEUiE6667DseOHcOLL76IG2+8MdLToTCJaCDw888/x6xZs/D1118jKysLbrcbI0eOhMPh8Bs3Y8YMnDhxQvt47LHHtMdkWcbYsWPhcrmwfft2rFy5EitWrMD8+fO1MYcPH8bYsWNx6aWXYu/evZg9ezamT5+ODRs2aGPefPNNzJkzB/fffz92796N3r17IyMjA7m5udqY2267DR999BHWrl2Lzz//HH/88QeuuuqqOvwKERFRVYrKlAY9yYxAIl2QJAkGCTjlYiCQiIgaFzUQmGDx9us5v6UVZqMBZx0u/HamKJJTIyJq1Ly9Ab39AT2MA1Ijl5ycjPHjxyMxMRHjxo2L9HQoTCJanHb9+vV+t1esWIHU1FRkZ2dj8ODB2v3x8fFIT08PeIyNGzfixx9/xGeffYa0tDT06dMHCxcuxF133YUHHngAZrMZy5YtQ4cOHfDkk08CALp164avvvoKTz31FDIyvI06Fy9ejBkzZuCGG24AACxbtgzr1q3DK6+8grvvvhsFBQV4+eWXsWbNGgwbNgwAsHz5cnTr1g1ff/01LrzwwrB/fYiIqGplS4Oedbjg9MiwmEJrhExE9S/RZMRJpxtuRSDGwD6BRETUOBSVKw1qMRnRo5UVu4/mI/u3PLRvnhDJ6RERNVoeIaAAvmAgI4FEx48fx6RJk2CxWCI9FQqTqOoRWFBQAABo2rSp3/2rV69G8+bN0aNHD8ybNw9FRaU75Xbs2IGePXsiLS1Nuy8jIwM2mw0//PCDNmbEiBF+x8zIyMCOHTsAAC6XC9nZ2X5jDAYDRowYoY3Jzs6G2+32G9O1a1e0bdtWG1Oe0+mEzWbz+yAiovCxO/0zinJZHpRIFxKNBhTKMvI9zAqkyHnhhRfQq1cvWK1WWK1WDBo0CJ9++qn2eDBtAeqrRQERNQxaRqC5dONa/zLlQYmIKDI8ApCFNxDI0qDUmOXl5eG9997D1q1bMWvWrEhPh8IoagKBiqJg9uzZuPjii9GjRw/t/uuuuw6vvfYatmzZgnnz5uHVV1/F3//+d+3xnJwcvyAgAO12Tk5OlWNsNhuKi4tx+vRpyLIccEzZY5jNZqSkpFQ6prxFixYhOTlZ+2BjTSKi8HKUKy3I8qBE+mA2GOBWBPLdcvWDiepI69at8cgjjyA7Oxu7du3CsGHDcOWVV2qbCatrC1CfLQqIqGFQz13VHoEA0K+tNxCY/RsDgUREkSILAUUIABIDgdSo9e3bF1OnTsWjjz6K8847L9LToTCKaGnQsmbNmoXvv/8eX331ld/9N910k/b/nj17okWLFhg+fDh++eUXdOrUqb6nGZJ58+Zhzpw52m2bzcZgIBFRGDmc/kGEk8wIJNKNWKOEE04Xzk2IjfRUqJG64oor/G7/+9//xgsvvICvv/4arVu3rrYtQH21KCCihkPtb51oKRMI9GUEHjpZCLvT4/cYERHVD4+vJKhJAjwKA4HUeB05ciTSU6A6EhUZgZmZmfj444+xZcsWtG7dusqxAwcOBAD8/PPPAID09PQKJXrU22pfwcrGWK1WxMXFoXnz5jAajQHHlD2Gy+VCfn5+pWPKs1gsWqkh9YOIiMJHLa/ULMEMAMhhRiCRbiQajTjjluGQmRVIkSfLMt544w04HA4MGjQoqLYA9dWiIBC2ICDSJ7WsfbyltDRomjUWrVLioAhg3+/5EZoZEVHjJgtABhBjkOBkIJCIGqCIBgKFEMjMzMR7772HzZs3o0OHDtU+Z+/evQCAFi1aAAAGDRqE7777zq90TlZWFqxWK7p3766N2bRpk99xsrKyMGjQIACA2WxG//79/cYoioJNmzZpY/r374+YmBi/MQcPHsTRo0e1MUREVL/UQGCncxIBALkMBBLpRrzRgCJZYXlQiqjvvvsOiYmJsFgsuPnmm/Hee++he/fuQbUFqK8WBYGwBQGRPhW5vH/zEsz+WX9qn0CWByUiigy1NKhZYiCQiBqmiAYCZ82ahddeew1r1qxBUlIScnJykJOTg+LiYgDAL7/8goULFyI7OxtHjhzBhx9+iMmTJ2Pw4MHo1asXAGDkyJHo3r07rr/+euzbtw8bNmzAvffei1mzZsFisQAAbr75Zvz666+48847ceDAATz//PN46623cNttt2lzmTNnDl588UWsXLkS+/fvx8yZM+FwOLQSPcnJyZg2bRrmzJmDLVu2IDs7GzfccAMGDRqECy+8sJ6/ckREBAAO38WUjuckAGBGIJGeGCUJQgBn3Z7qBxPVkfPOOw979+7F//73P8ycORNTpkzBjz/+GOlpVWvevHkoKCjQPn7//fdIT4mIgqD2CEwoV/6zX9sUAMDuowwEEhFFgkcICHjXKC5FifR0iIjCLqLF51944QUAwNChQ/3uX758OaZOnQqz2YzPPvsMS5YsgcPhQJs2bTB+/Hjce++92lij0YiPP/4YM2fOxKBBg5CQkIApU6bgwQcf1MZ06NAB69atw2233Yann34arVu3xksvvaT15QCAa6+9FqdOncL8+fORk5ODPn36YP369X67c5966ikYDAaMHz8eTqcTGRkZeP755+voq0NERFURQmgZgWog8CQDgbq3+cBJPLf5ZzxxTW909GV6UsOVYJLwR4kL5yfGwSBJkZ4ONUJmsxmdO3cG4K0A8s033+Dpp5/Gtddeq7UFKJsVWL51wM6dO/2OF2qLAqPRWG2LgkAsFou26ZGI9EM9d00wG/3u79+uKQBg9295UBQBg4F/E4mI6pM3ECh5A4GCGYFE1PBENBAoqvnF2qZNG3z++efVHqddu3b45JNPqhwzdOhQ7Nmzp8oxmZmZyMzMrPTx2NhYLF26FEuXLq12TkREVLecHkVr4t2xuTdgdNLmjOSUKAzezj6G3Ufz8dG+E7h1xLmRng7VsUSjEfluGTaPjJSYiJ6WEgHwtgdwOp1+bQHGjx8PoGJbgEGDBuHf//43cnNzkZqaCiBwi4Ly65TKWhSMGzdOm8OmTZuqXJcQkT45nN5qFvHlMgK7tkhCbIwBthIPfj1tR+fUpEhMj4io0ZIFIEHAKAFuxVsmlBsViagh4RUXIiLSJXVHNeCfESiEgMQTdt0qLPG+r0fOOCI8E6oPcUYDclxu5LkZCKT6N2/ePIwePRpt27ZFYWEh1qxZg61bt2LDhg1+bQGaNm0Kq9WKW265xa8tQNkWBY899hhycnICtih47rnncOedd+LGG2/E5s2b8dZbb2HdunXaPObMmYMpU6ZgwIAB+NOf/qRVQ1FbFBBRw1HkKw2aaPHPCIwxGtC7dQr+d/gssn/LYyCQiKieyb5kFYMkQRYCsgCYnE1EDUlEewQSERHVVJGvP2BcjBEtkuO0+wqd7DemZ3bf+3f4NAOBjYVJknDK5Y70NKgRys3NxeTJk3Heeedh+PDh+Oabb7BhwwZcdtllALxtAS6//HKMHz8egwcPRnp6Ot59913t+WqLAqPRiEGDBuHvf/87Jk+eHLBFQVZWFnr37o0nn3wyYIuCJ554AvPnz0efPn2wd+/eCi0KiKhh0DICzRU3v/Rr1wQAsPu3/PqcEhERwVsaFAIwwpsd6GF5UKKQtG/fHkuWLKlyjCRJeP/99+tlPlQRt14TEZEuqQGjBIsRcWYjrLEm2Eo8OFlQAmtsTIRnRzVlZ0Zgo5NoNOCkyw2XosBs4B41qj8vv/xylY8H0xagvloUEJH+uTwKXLICAEgIEAjs39YbCMw+mlev8yIiIm85UIMEGCUJilC0DEGixqK6ylr3338/HnjggfqZDNUJBgKJiEiXHFog0PunLD05FrYSO07anDg3jeWU9Ep9X/OL3MgvciEl3hzhGVFdSzQakeNyI98tI9XCQCARETVMxb5qFgAQX640KAD0bZsCAPg5146CIjeS47mxjYiovjiFAqMkwSB5y4S6GQikRubEiRPa/998803Mnz8fBw8e1O5LTEyMxLQojHi1hYiIdMnhu5ii7qhOs8YCAHJsJRGbE9Ve2dKuLA/aOMQYJHgUgTyPXP1gIiIinbL7+gOaTQbEGCteimmWaEH7ZvEAgD2/MyuQiKg+uXwZgSZJggxveVCicBFCwCHLEfkQQQa109PTtY/k5GRIkqTddjgcmDRpEtLS0pCYmIgLLrgAn332WYVjFBYWYuLEiUhISECrVq0CVlY5ceIERo8ejbi4OHTs2BFvv/229tiwYcMqVEk5deoUzGYzNm3aFOJXncpjRiAREemSmjmWaPEPBJ5kIFC3hBDa+wp4y4P29ZXJooYtzmjAiRIXusRbqi1JQkREpEdFajULc8VsQFW/dk1w5EwRdv+Wh6HnpdbX1IiIGj23ImCABAO8GYHsEUjhVKQo6PTFdxH53L8M7okEY+XnHsGw2+0YM2YM/v3vf8NisWDVqlW44oorcPDgQbRt21Yb9/jjj+Oee+7BggULsGHDBtx6663o0qWL1oMdAO677z488sgjePrpp/Hqq69iwoQJ+O6779CtWzdMnz4dmZmZePLJJ2GxWAAAr732Glq1aoVhw4bV6jUQMwKJiEin1B6BammldAYCda/YLUMps946fLoocpOhepVoNOCsR4bD1zuJiIioobGXK2sfSD/fBqjdR/PrY0pEROTjEgJGSdI2JTIQSFSqd+/e+Mc//oEePXrg3HPPxcKFC9GpUyd8+OGHfuMuvvhi3H333ejSpQtuueUWXH311Xjqqaf8xlxzzTWYPn06unTpgoULF2LAgAF49tlnAQBXXXUVAOCDDz7Qxq9YsQJTp07lhuEwYEYgERHpUlG5iylpVu9uIQYC9cte4vG7zdKgjUe80YDTbhfyPDISTbXbrUhERBSNisqVtQ+kfztvIHDP0TzIioDRwIteRER1TQgBtyJgLPMrV2YgkMIo3mDAL4N7Ruxz15bdbscDDzyAdevW4cSJE/B4PCguLsbRo0f9xg0aNKjC7SVLllQ7Zu/evQCA2NhYXH/99XjllVfwt7/9Dbt378b3339fIeBINcNAIBER6ZLaIzCxQo9AZ8TmRLVjd/oHAo8wENhoGCQJEoCzLjfaxJojPR0iIqKwc5SrZhFIl7QkJFpMsDs9OHSyEN1aWOtrekREjZZHADK8GYFeEjMCKawkSap1ec5IuuOOO5CVlYUnnngCnTt3RlxcHK6++mq4XK6wf67p06ejT58+OHbsGJYvX45hw4ahXbt2Yf88jRFLgxIRkS6VLw2qBgJzmRGoW4ECgcE2tib9SzQacbzEzd23RETUIDlc/v2tAzEaJPRpkwIAyP4trz6mRUTU6HmEgCzKXiQX8HBJQqTZtm0bpk6dir/+9a/o2bMn0tPTceTIkQrjvv766wq3u3XrFtKYnj17YsCAAXjxxRexZs0a3HjjjeF7IY0cA4FERKRL6q5q9WJKerIvEFjohKzwrF2P1NKg7ZrFQ5KAQqcHZxzh32FG0SnBaIBDVlDokSM9FSIiorBzOL1/3+LNVWcE9GubAgDYfZSBQCKi+qAIAUWUzQhkaVCiss4991y8++672Lt3L/bt24frrrsOiqJUGLdt2zY89thjOHToEJYuXYq1a9fi1ltv9Ruzdu1avPLKKzh06BDuv/9+7Ny5E5mZmX5jpk+fjkceeQRCCPz1r3+t09fWmDAQSEREuqReTFF7BDZLMMMgAbIicMbO8qB6pGYENk0wo2VyHACWB21MTAYJHu6+JSKiBqrI5d/fujL9fH0CdzMjkIioXniEgCKg9Qg0ShKccsUgB1FjtXjxYjRp0gQXXXQRrrjiCmRkZKBfv34Vxt1+++3YtWsX+vbti4ceegiLFy9GRkaG35gFCxbgjTfeQK9evbBq1Sq8/vrr6N69u9+YiRMnwmQyYeLEiYiNja3T19aYsEcgERHpkpoRmODbVW0yGnBOkgUnbU6ctDmRauXJgt7Yy2R5xjc34nh+MQ6fdmBA+6YRnhnVBwO8u3G5+5aIiBoiu7qJzVz1ZZi+bbyBwCNninDG7kSzREudz42IqDFTewQa4I0EGgE4WWWIGrGpU6di6tSp2u327dtj8+bNfmNmzZrldztQqdDy1NYv//znP6scd/r0aZSUlGDatGnBTZiCwoxAIiLSJUeAXdVqn8Ac9gnUpbLlXts3SwAAHDnDjMDGwiBJEIJleIiIqGEqKtffujLJ8TE4NzURALDnaH5dT4uIqNGTfZsRy2YEugQzAonqm9vtRk5ODu69915ceOGFAbMOqeYYCCQiIl3SMgIDBAJPMhCoS4VlAoEdmvsCgaeLIjkligAPA4FERNQAOVzejMDEajICAaBfW29WYDb7BBIR1TmPEBDCuzERAAwS4GJGIFG927ZtG1q0aIFvvvkGy5Yti/R0GhyWBiUiIl1SewQm+gUCvaWTGAjUJ3uJLxAYWxoI/JU9AhsVCQD33hIRUUPk0DICgwgEtkvBm7t+Z59AIqJ6IJe7bZQkOBUBIQQkX3CQiOre0KFDtfKhFH7MCCQiIl1S+8nFm0vLK6UzI1DX/EqD+gKBv51x8ESwERFgRiARETVMRS7//tZV6d/OmxG471g+FGalEBHVKVkIlA33GQEoEJD565eIGhAGAomISJfUHoGJAXsEOiMyJ6qdsqVB2zSJh0ECilwycgv5fjYaErjgJiKiBkmtZpEQREZg6ybxAIASt4Iid/lcFSIiCqfyGxENkgRZcIMiETUsDAQSEZEuFQW4mKIGAnOZEahLZfs+mk0G7SLYYZYHbVRkLriJiKgBUjexJViqzwi0mAwwGbz5KWrpdCIiqhseIVA2J9AoSZCF4LqEiBoUBgKJiEh3XB4FLtnbSSzBXBoITE9WMwIZCNQjtdxrUqz3PVXLgx5hILDRMEKCW2GXQCIiani0HoHm6jMCJUlCou98yO501+m8iIgaO48iAKk06GeUAIUZgUTUwDAQSEREuqNeSAH8d1WnJXkDgflFbpSwjJLuqDve1XKvHZr5MgLPMBDYWBgkwMleSERE1AAVubznpolBlAYtO66QGYFERHXKrQgYpdKMQAMkyBDwcFlCRA1IcGegREREUUQtrWQxGWAylu5pscaZEBtjQIlbQa7Niba+QBLpg71MaVCAGYGNkUGS4ObOWyIiaoDsWkZg9aVBgdJAoN3JQCARUV1yKgJlfzMbJbA0KNWJElmp10xTkyQh1sg8MPJiIJCIiHTHEaA/IOAto5RmjcVvZ4qQYythIFBn1AtdiRUCgUURmxPVLyMAFzMCiYiogRFCaBmB5c9fK6OWSmePQCKiuuUSin9GoCRBsDQohVmJrOCLvEIUeuqvelWSyYjBTZLqJRjYvn17zJ49G7Nnz650jCRJeO+99zBu3LiIzSHchg4dij59+mDJkiX19jlriiFhIiLSndLMsYo7qtOs3vKgJ9knUHfUAG9paVBfIPCMAwqDQ40CMwKJiKghcnoUyL5zmWADgVppUGYEEhHVKZciYJD87xNcl1CYeYRAoUeG2SDBajLW+YfZIKHQIwcd0JYkqcqPBx54oG6/QI2A3W5HZmYmWrdujbi4OHTv3h3Lli3zG1NSUoJZs2ahWbNmSExMxPjx43Hy5MmwfH5mBBIRke4U+UqDJpgr/hljIFCfFEWUZgT6dsC3bhIHk0GC06PghK0ErVLiIjlFqgdGydujQwgBSZKqfwIREZEOlO1vHRcTXGnQpNgYAMwIJCKqay5FwAD/tYcBAtyLSnUh1mBAXD2V63QpwWcfnjhxQvv/m2++ifnz5+PgwYPafYmJiWGdW2M0Z84cbN68Ga+99hrat2+PjRs34p///CdatmyJv/zlLwCA2267DevWrcPatWuRnJyMzMxMXHXVVdi2bVutPz8zAomISHcc5UpIlpVutQBgIFBv1L6PQOn7ajIa0Lapt7wr+wQ2DgYACgRkLrqJiKgBUcuCxsUYYSyfdlIJdWNUIQOBRER1RhYCCgSM5TMCAWYEUqOSnp6ufSQnJ0OSJO22w+HApEmTkJaWhsTERFxwwQX47LPPKhyjsLAQEydOREJCAlq1aoWlS5dWGHPixAmMHj0acXFx6NixI95++23tsWHDhiEzM9Nv/KlTp2A2m7Fp06aQX1N+fj6mT5+Oc845B1arFcOGDcO+ffsAAIcOHYIkSThw4IDfc5566il06tRJu/39999j9OjRSExMRFpaGq6//nqcPn065LkAwPbt2zFlyhQMHToU7du3x0033YTevXtj586dAICCggK8/PLLWLx4MYYNG4b+/ftj+fLl2L59O77++usafc6yGAgkIiLdsftKSMYHCASqGYE5Nme9zolqRy0LajJIsJhKT0/UPoGHGQhsFAySBJn9OIiIqIEpLWsffFGmJN9Yu9NdJ3MiIiLvukMG/HoEAgCEN0hIRN6SlmPGjMGmTZuwZ88ejBo1CldccQWOHj3qN+7xxx9H7969sWfPHtx999249dZbkZWV5Tfmvvvuw/jx47Fv3z5MmjQJEyZMwP79+wEA06dPx5o1a+B0ll7Pe+2119CqVSsMGzYs5Hlfc801yM3Nxaeffors7Gz069cPw4cPx9mzZ9GlSxcMGDAAq1ev9nvO6tWrcd111wHwBhKHDRuGvn37YteuXVi/fj1OnjyJv/3tbyHPBQAuuugifPjhhzh+/DiEENiyZQsOHTqEkSNHAgCys7PhdrsxYsQI7Tldu3ZF27ZtsWPHjhp9zrIYCCQiIt0pzQhkj8CGQr3IlRhr8isJ2V7tE8hAYKNgkAAFgAwuuomIqOHQytoHOHetTKIWCGRGIBFRXfEIbzWS8snaRkmCS1EiMymiKNO7d2/84x//QI8ePXDuuedi4cKF6NSpEz788EO/cRdffDHuvvtudOnSBbfccguuvvpqPPXUU35jrrnmGkyfPh1dunTBwoULMWDAADz77LMAgKuuugoA8MEHH2jjV6xYgalTp4bcOuSrr77Czp07sXbtWgwYMADnnnsunnjiCaSkpGhZiJMmTcLrr7+uPefQoUPIzs7GpEmTAADPPfcc+vbti4cffhhdu3ZF37598corr2gBvFA9++yz6N69O1q3bg2z2YxRo0Zh6dKlGDx4MAAgJycHZrMZKSkpfs9LS0tDTk5OyJ+vPAYCiYhIdxxV9AhMT2YgUI/ULM/y72mH5r7SoGcYCGwMjJCgCJYGJSKihkWtfBAf4Ny1MiwNSkRU92QBKELAWL5HoOTtHUhE3ozAO+64A926dUNKSgoSExOxf//+ChmBgwYNqnBbzfYLZkxsbCyuv/56vPLKKwCA3bt34/vvv8fUqVNDnvO+fftgt9vRrFkzJCYmah+HDx/GL7/8AgCYMGECjhw5opXdXL16Nfr164euXbtqx9iyZYvf89XH1GOE4tlnn8XXX3+NDz/8ENnZ2XjyyScxa9asgGVW60LwZ6FERERRwlFFeaW0JF9p0IISCCFC3jVEkWH3XeRKivV/T1katHExSN4SPCzDQ0REDUlV1Swqw4xAIqK65/GtPQJlBJYIZgQSAcAdd9yBrKwsPPHEE+jcuTPi4uJw9dVXw+Vyhf1zTZ8+HX369MGxY8ewfPlyDBs2DO3atQv5OHa7HS1atMDWrVsrPKZm3KWnp2PYsGFYs2YNLrzwQqxZswYzZ870O8YVV1yBRx99tMIxWrRoEdJ8iouLcc899+C9997D2LFjAQC9evXC3r178cQTT2DEiBFIT0+Hy+VCfn6+X1bgyZMnkZ6eHtLnC4SBQCIi0h11V3Wg8kqpVgsAwOlRYCv2IDk+pl7nRjWjlQYtF9xVS4MePVsEWREwll+hUYNilCQoYI9AIiJqWByu0DMC1c1RdmYEEhHVGVkIKKjYI9AoAS7GAYkAANu2bcPUqVPx17/+FYA3QHbkyJEK49TMurK3u3XrVuG+yZMn+93u27evdrtnz54YMGAAXnzxRaxZswbPPfdcjebcr18/5OTkwGQyoX379pWOmzRpEu68805MnDgRv/76KyZMmOB3jHfeeQft27eHyVS7MJrb7Ybb7YbB4F+g02g0QvGVIe7fvz9iYmKwadMmjB8/HgBw8OBBHD16tEImZU2wNCgREelOVRmBsTFGpPiCfzksD6obWmnQcu9py5Q4mI0GuGWB43nFkZga1SMDfItxxgGpji1atAgXXHABkpKSkJqainHjxuHgwYN+Y4YOHQpJkvw+br75Zr8xR48exdixYxEfH4/U1FTMnTsXHo//RfutW7eiX79+sFgs6Ny5M1asWFFhPkuXLkX79u0RGxuLgQMHYufOnWF/zUQUOTXrEeg9n2VGIBFR3ZGFd/1R/gK5AewRSHWjRFFQLNf9R0kYv3/PPfdcvPvuu9i7dy/27duH6667TgtelbVt2zY89thjOHToEJYuXYq1a9fi1ltv9Ruzdu1avPLKKzh06BDuv/9+7Ny5E5mZmX5jpk+fjkceeQRCCC34GKoRI0Zg0KBBGDduHDZu3IgjR45g+/bt+L//+z/s2rVLG3fVVVehsLAQM2fOxKWXXoqWLVtqj82aNQtnz57FxIkT8c033+CXX37Bhg0bcMMNN0CW5ZDmY7VaMWTIEMydOxdbt27F4cOHsWLFCqxatUp7jcnJyZg2bRrmzJmDLVu2IDs7GzfccAMGDRqECy+8sEZfh7IYCCQiIt1RewSWzx5TpVvZJ1Bv7CW+jMBypUGNBgntmnn7BB5mn8AGTy3ly4xAqmuff/45Zs2aha+//hpZWVlwu90YOXIkHA7/3zMzZszAiRMntI/HHntMe0yWZYwdOxYulwvbt2/HypUrsWLFCsyfP18bc/jwYYwdOxaXXnop9u7di9mzZ2P69OnYsGGDNubNN9/EnDlzcP/992P37t3o3bs3MjIykJubW/dfCCKqF2owL1B/68qwRyARUd1T1x3lW4oY2bKAwswkSUgyGeFSBGweuc4/XIpAkskIUxja5SxevBhNmjTBRRddhCuuuAIZGRno169fhXG33347du3ahb59++Khhx7C4sWLkZGR4TdmwYIFeOONN9CrVy+sWrUKr7/+Orp37+43ZuLEiTCZTJg4cSJiY2NrNGdJkvDJJ59g8ODBuOGGG9ClSxdMmDABv/32G9LS0rRxSUlJuOKKK7Bv3z5MmjTJ7xgtW7bEtm3bIMsyRo4ciZ49e2L27NlISUmpkNkXjDfeeAMXXHABJk2ahO7du+ORRx7Bv//9b7/Npk899RQuv/xyjB8/HoMHD0Z6ejrefffdGn0NypOE4G+0+mKz2ZCcnIyCggJYrdZIT4eISLcmv7ITXxw6hSeu6Y2r+7eu9PHHru6Fvw1oE4EZUqiWbvkZj284iGsHtMGjV/fye2zGql3I+vEkFvzlfEy5qH1kJkg1JoTAJ6cKoECgSUz1F0APF7swpEki2sZZ6mF2FG0idb586tQppKam4vPPP8fgwYMBeDMC+/TpgyVLlgR8zqefforLL78cf/zxh7aYXLZsGe666y6cOnUKZrMZd911F9atW4fvv/9ee96ECROQn5+P9evXAwAGDhyICy64QCt7oygK2rRpg1tuuQV33313UPPnOoMouj2x4SCe2/Izpl7UHg/85fygnvNzrh0jFn+O5LgY7Lt/ZB3PkIiocfqt2Ikv8wrRvtzao9AjwyUERjVPhqUGF/wp+tTn+XJJSQkOHz6MDh06+AWySmSlXje9miQJsUb9ff8eOXIEnTp1wjfffBMw4EilKvteC0R/3wlERNToqaVBEyspr5Tu6xOYy4xA3VB3u5fPCASADs29fQIPn2ZGYGNggIDMbWpUzwoKCgAATZs29bt/9erVaN68OXr06IF58+ahqKhIe2zHjh3o2bOn347SjIwM2Gw2/PDDD9qYESNG+B0zIyMDO3bsAAC4XC5kZ2f7jTEYDBgxYoQ2JhCn0wmbzeb3QUTRS61mEW8OvjSoVe0R6PSA+7eJiOqGNyhTMWPKIHnLhrJSCYVTrNGARJOx3j70FgR0u93IycnBvffeiwsvvJBBwDCrXZdDIiKiCKiqRyAApPlKg7JHoH7Ynb7SoAHe0/bNvIHAIywN2igIAcjggpvqj6IomD17Ni6++GL06NFDu/+6665Du3bt0LJlS3z77be46667cPDgQa00S05Ojl8QEIB2Oycnp8oxNpsNxcXFyMvLgyzLAcccOHCg0jkvWrQICxYsqPmLJqJ6Vd25ayDq5ihZESh2y4gPoawoEREFx7sBseLawwgJilC4QZGoHm3btg2XXnopunTpgrffftvvsS+//BKjR4+u9Ll2u72up1elaJ8fwEAgERHpUOmu6qoDgSdtznqbE9WOw+lttBwwENjc2yPwCDMCdelosRNbzxbikiYJQT5D4s5bqlezZs3C999/j6+++srv/ptuukn7f8+ePdGiRQsMHz4cv/zyCzp16lTf0/Qzb948zJkzR7tts9nQpg1LYRNFK4fLe56TEEJGYFyMEQYJUARgL/EwEEhEVAcq6wFolCTIQnBdQlSPhg4dWmkVhAEDBmDv3r31O6EQRPv8AAYCiYhIh6oKGgFAuhYIZEagXgRTGvT3vGK4ZQUxOitv0ZiVyAqGfnMIxYqC9nFmNDXHVP8kSUBWuOCm+pGZmYmPP/4YX3zxBVq3rthztqyBAwcCAH7++Wd06tQJ6enp2Llzp9+YkydPAgDS09O1f9X7yo6xWq2Ii4uD0WiE0WgMOEY9RiAWiwUWC/toEulFUQ0yAiVJQqLFBFuJB4VOD1LranJERI2YS1FgrKw0KESlgUIiql9xcXHo3LlzpKdRqWifH8AegUREpEOl5ZUC76rWSoMWMBCoF1WVzEpLikVsjAGyInAsr7i+p0a1EGs0YEjTRADA3sKiakZ7GSUJLgYCqY4JIZCZmYn33nsPmzdvRocOHap9jrrDs0WLFgCAQYMG4bvvvkNubq42JisrC1arFd27d9fGbNq0ye84WVlZGDRoEADAbDajf//+fmMURcGmTZu0MUSkf+omtlACgQCQFOvdQGP3bZgiIqLwcioChopxQBglCYpgpRKqHfb4pboWyvcYA4FERKQrHlmB06MAABIqKw2a7M2SOG13wiMr9TY3qjm7LxCYFOACmcEgaX0CD5+OfF11Cs3o5skAgD1BBgINANxcMFEdmzVrFl577TWsWbMGSUlJyMnJQU5ODoqLvZsNfvnlFyxcuBDZ2dk4cuQIPvzwQ0yePBmDBw9Gr169AAAjR45E9+7dcf3112Pfvn3YsGED7r33XsyaNUvL1rv55pvx66+/4s4778SBAwfw/PPP46233sJtt92mzWXOnDl48cUXsXLlSuzfvx8zZ86Ew+HADTfcUP9fGCKqE6Vl7YMvDQqUVr9Qz5OIiCi8nEKBQQoQCQQACHi4LKEaiInxbuQpKgpuDUxUU+r3mPo9V5WIlgZdtGgR3n33XRw4cABxcXG46KKL8Oijj+K8887TxpSUlOD222/HG2+8AafTiYyMDDz//PNIS0vTxhw9ehQzZ87Eli1bkJiYiClTpmDRokUwmUpf3tatWzFnzhz88MMPaNOmDe69915MnTrVbz5Lly7F448/jpycHPTu3RvPPvss/vSnP4U0FyIiqlvqjmqg8l3VzRIsMBokyIrAabsL6cmx9TU9qiH1Aleg0qCAtzzogZxCHD7NE2m9GdHMCgnAsRI3TjrdSLNUfYJqlCQ4BQP4VLdeeOEFAN4+FGUtX74cU6dOhdlsxmeffYYlS5bA4XCgTZs2GD9+PO69915trNFoxMcff4yZM2di0KBBSEhIwJQpU/Dggw9qYzp06IB169bhtttuw9NPP43WrVvjpZdeQkZGhjbm2muvxalTpzB//nzk5OSgT58+WL9+PdcYRA1IkavqsvaVUc+LCpkRSERUJ9wKUNkWDUlU3kOQqCpGoxEpKSla5ZD4+HhIlQaciUInhEBRURFyc3ORkpICo7H6zWYRDQR+/vnnmDVrFi644AJ4PB7cc889GDlyJH788UckJHh3/t92221Yt24d1q5di+TkZGRmZuKqq67Ctm3bAACyLGPs2LFIT0/H9u3bceLECUyePBkxMTF4+OGHAQCHDx/G2LFjcfPNN2P16tXYtGkTpk+fjhYtWmiL8DfffBNz5szBsmXLMHDgQCxZsgQZGRk4ePAgUlNTg5oLERHVPbtvR7XZaIDZFDix3WiQkJpkwYmCEpy0lTAQqANqILCyLM/2vj6BR0476m1OFB5NY0zoEh+Lg0Ul+KbAgctTU6ocb4B3QU5Ul6orodKmTRt8/vnn1R6nXbt2+OSTT6ocM3ToUOzZs6fKMZmZmcjMzKz28xGRPqnnOfGVnOdUhhmBRER1y60oMFYRoGFpUKoptd932TYCROGWkpJSZW/5siIaCFy/fr3f7RUrViA1NRXZ2dkYPHgwCgoK8PLLL2PNmjUYNmwYAO8u3W7duuHrr7/GhRdeiI0bN+LHH3/EZ599hrS0NPTp0wcLFy7EXXfdhQceeABmsxnLli1Dhw4d8OSTTwIAunXrhq+++gpPPfWUFghcvHgxZsyYoZXgWbZsGdatW4dXXnkFd999d1BzISKiuldUTX9AVao1FicKSpBjK0Hv+pgY1Yra+yapsoxAX2nQI2cYCNSjvtZ4byDQVn0g0ChJcCuMBBIRUcMR7PlreWpGoL3EHfY5ERE1dooQcIvAPQIBQIA9AqnmJElCixYtkJqaCrebf8cp/GJiYoLKBFRFNBBYXkFBAQCgadOmAIDs7Gy43W6MGDFCG9O1a1e0bdsWO3bswIUXXogdO3agZ8+efqVzMjIyMHPmTPzwww/o27cvduzY4XcMdczs2bMBAC6XC9nZ2Zg3b572uMFgwIgRI7Bjx46g51Ke0+mE0+nUbttstpp+aYiIyCfYHdXpVgv2Aci1ldTDrKg2ZEWg2O0tmVVZuVc1I/AwMwJ1qW9SHN7IAfbbS1DokZFkqvxk1SABHuHN2GL5FCIi0jtFESiq5jynMknMCCQiqjMeIaAAMFWy5pAkAbfMQCDVjtFoDClYQ1RXAtdUiwBFUTB79mxcfPHF6NGjBwAgJycHZrMZKSkpfmPT0tKQk5OjjSnfP0O9Xd0Ym82G4uJinD59GrIsBxxT9hjVzaW8RYsWITk5Wfto06ZNkF8NIiKqjNojsLoeK2lWbznQHAYCo17Zi1uV7ZRv3zweAPBHfjGcHjngGIpezc0xaBMbAwVAtq3qYK5BkiBDwMM1NxERNQDFbhlqQkllJdArk8QegUREdcYjAFlUfnHc27ucixIiahiiJhA4a9YsfP/993jjjTciPZWwmTdvHgoKCrSP33//PdJTIiLSPYcruNJKaiDwpM1Z5TiKPDUQaDYZYKkkU+ycRAsSzEYoAvj9bFF9To/CpE+SN5i7s6Dq988AQBGAzEU3ERE1AOq5q0ECYmNCuwSTaIkBABQyI7BByC9yRXoKRFSGIgQUISrtEWiUABdbFhBRAxEVgcDMzEx8/PHH2LJlC1q3bq3dn56eDpfLhfz8fL/xJ0+e1Jogpqen4+TJkxUeVx+raozVakVcXByaN28Oo9EYcEzZY1Q3l/IsFgusVqvfBxER1Y5D67FSXWlQNRDIjMBop76nVWV5SpJUpjwoA4F6pAYC99qK4KxiQW2UJMhCMBBIREQNQpGvmkWC2RRyyevSHoEMBOrdK18dRp8Hs7D++8AVpYio/nmE8GYEVvKr2QAJLoVrEiJqGCIaCBRCIDMzE++99x42b96MDh06+D3ev39/xMTEYNOmTdp9Bw8exNGjRzFo0CAAwKBBg/Ddd98hNzdXG5OVlQWr1Yru3btrY8oeQx2jHsNsNqN///5+YxRFwaZNm7QxwcyFiIjqnhYIrKa0klYatICBwGinlruqrtyrGgg8wj6ButQmNgbnxJjgEgL7CosrHWcAIACwACwRETUEWn/raqpZBMIegQ3HvmP5AIDvjudHdB5EVMojABlVZQRKVW5gJCLSk9AK1IfZrFmzsGbNGnzwwQdISkrSeu0lJycjLi4OycnJmDZtGubMmYOmTZvCarXilltuwaBBg3DhhRcCAEaOHInu3bvj+uuvx2OPPYacnBzce++9mDVrFiwWCwDg5ptvxnPPPYc777wTN954IzZv3oy33noL69at0+YyZ84cTJkyBQMGDMCf/vQnLFmyBA6HAzfccIM2p+rmQkREdc/h8u2qri4jMNn7N4AZgdEv2CzPDs28gcBfGQjUJUmS8KfkBKw7XYBvChz4U3JCwHFqRqCHGYFERNQAFLlKMwJDxYzAhsNW7Pb9y/eSKFrIamnQSh43St5goSIEDCFmdBMRRZuIBgJfeOEFAMDQoUP97l++fDmmTp0KAHjqqadgMBgwfvx4OJ1OZGRk4Pnnn9fGGo1GfPzxx5g5cyYGDRqEhIQETJkyBQ8++KA2pkOHDli3bh1uu+02PP3002jdujVeeuklZGRkaGOuvfZanDp1CvPnz0dOTg769OmD9evXIy0tTRtT3VyIiKjulZaRrHpXdaovI9BW4kGxS0acOfRd2FQ/1F3uSdUFApkRqHsX+AKBuwockCvpx2GQAAXsEUhERA1DsBueAlGrJbBHoP6pFTBsJe4Iz4SIVLIQEAKVlm02ShI8vg2KZgYCiUjnIhoIFEFc4ImNjcXSpUuxdOnSSse0a9cOn3zySZXHGTp0KPbs2VPlmMzMTGRmZtZqLkREVLdKyytV/ScsyWJCvNmIIpeMk7YSrawkRR91l7u6670yWmnQMwwE6lW3xFgkGg0olBUcdJSge2JchTEGwNcjsP7nR0REFG4Ol+/ctQab0rSMQCeDR3qnBgILivleEkULjxAQVQT4jACcwpsVaK6/aRER1YmI9ggkIiIKVWlGYNVBI0mSSvsEsjxoVLMHWxrUFwg8UVCCYhc7yOmRUZIwwOp9H3cWBA7oqjtyWRqUiIgagiJncGXtA9F6BLI0qO4VlqilQRkIJIoWsgAMqHzNYZAkKEKwUgkRNQgMBBIRka5oPQKD2FWdZmWfQD2wBxncbRIfA6tvZ/xvZ5kVqFdqb8CdBY4qqkNIXHATEVGDEOyGp0BKMwI9QVVUouhl00qDMqhLFC08QlQRBvT2CGTvciJqKBgIJCIiXXEEWRoUgJYRyEBgdAu276MkSewT2AD0SoqDWZKQ6/LgtxJXJaMEFK63iYioASjylQYNZhNbeUmxMQAAtyzg9ChhnRfVH1kRWkCYpUGJoodHCFQVCTRKEmSwUgkRNQwMBBIRka4EWxoUANK1QKCzTudEtVOovacx1Y5V+wQePl1Up3OiuhNrNKBXkrc34DeVlAcFuOAmIqKGQa1mEW8OPSMwPsYItX1VITPJdEsNAgIsDUoUTdyKQBUtAtm7nIgaFAYCiYhIVxwh9Flhj0B9UPveqOWvqtK+GTMCG4Ky5UEDEQKQqyzUQ0REpA/BVj4IxGCQkGguLQ9K+qT2BwQAp0dBiZu9romigUsIGKuIBLJ3ORE1JAwEEhGRrjhCKK+klQYtYCAwmoVygayDlhHIQKCe9U9OgAHA4WIXTrkq7ow3SICHtUGJiKgBUDexBVPWPhCtTyAzAnXLVuz/3tlKmBVIFA1cioCxioxAFXuXE1FDwEAgERHpiho0CiYjMD3ZAgA4WchAYDQLpTSoFgg8w0CgniWbjOia4A3Uf1NQscyrQZLgZiCQiIgagNr0CARKy+EXOhk80qvCcoG/8oFBIooMt6LAgKojgRIkZgQSUYPAQCAREemKPYQegalJpT0CBU/eo1ZpcLf6C2Rqj8BThU6WyNK5C6ooD2oE4GQgkIiIGgB7CJvYAmFGoP6V7+/IjECi6OAUAoZqMgIFBDxclhBRA8BAIBER6YasCJS4FQDBXUxJtXozAl0eBflFXHBHK/UCWVIQPQKT42LQNMEMgH0C9U7tE/ijvRiFHv9eOQZJghtKJKZFREQUVkUuX2lQcw0DgRb2CNS78tmcBcVclxBFmhACbqXqHoEqj8J1CRHpHwOBRESkG2p/QACID6K8ksVk1IJGOTaWB41W6g73YEqDAkD7ZvEAgCMsD6praZYYtI01QwGw2+ZfHtQoAS6ut4mIqAEIpfJBIOpGKQYC9atCj0AGAokiThaAAoHqfjMbJQkuViohogaAgUAiItIN9UKKySDBYgruT1iaVS0PykBgtLKHeIFMLQ/KjEB9+PT7E3j388NQAiyg/1RJeVADJLi485aIiBoAdSNbjUuDqj0CWRpUtyr0COR7SRRxHiEgC28lkqqwZQERNRQMBBIRkW44nN7SSgkWE6QgSngAQJqvPCgDgdHJ5VHg9HgDPklBZgR2aOYNHh0+XVTNSIoGiz45gE3Zf2D/kfwKj6mBwL2FRXCWCfwZJEAWAgp7exIRkc4VqeevNS4N6j0/YkagflXoEciMQKKIk4WALKovDWqUJLgENygSkf4xEEhERLqhlVYKoiyoKl3LCHTWyZyodhxlLmqFnBHI0qC6cNruAgD8fKygwmMd4sxoHmOCUxH4rrBYu98oSVDgLdlDRESkZ2pGYDBl7QPRSoMyi0y3ymcAMhBIFHkeIaAIb0uCqhgksDQoETUIDAQSEZFulPZYCX5HdaovEMgegdFJ3d0eG2OAyRjcaUmH5mpGIAOB0a7YJaPY7c2E+OmYrcLjkiThAl9W4DdlyoMa4A0CepgRSEREOuaRFZS4vZkkiTUsDaoGAsuXlyT9sPneu2a+3uU2vpdEEScDkCFgQPUZgU5FQHBdQkQ6x0AgERHphsNVWho0WFpGYAEDgdFIDQQmBlkWFCjNCDzrcKGAO6qjWl6RS/v/7yftKA5Q1uxPyfEAgG9sDsi+BbZRkqCwNCgREelckW8zDADEB1n5oDw1gMjSoPqllgZt1SQOAGAr5ntJFGmyEFAgYKgmI9AIQIFgpRIi0j0GAomISDccWtAohEBgsq9HYCEDgdGo9D0N/uJYosWEc5K87+sRZgVGtbOO0kCgIoCfjlfMCuyWGIdEowE2j4JDDu/PqUHyjmdGIBFRcH46WYhbXt+Dn3MLIz0VKkPtDxhjlGAx1TAQqGUEMnikV2o2Z2tfIJAb2Ygiz1saVKq2R6BBkliphIgahKCupF511VUhH3jZsmVITU0N+XlERESVUXdCh9JjJTXJVxq0gD0Co1GhGgiMDa1cVrum8ThV6MSxvGL0bpNSBzOjcCgbCASA/b8XoFfHpn73mSQJ/azx+CLPjp0FDnRLjIMBEmQIyCAiomC88c3v+GjfH0i3WvB/Y7tHejrkU3ruWrOyoAAzAhsCLSMwxZcRyNKgRBHnEQBQfXDPKEmQhaJVLiEi0qugMgLff/99mM1mJCcnB/Wxbt062O32up47ERE1MjXLCPQGAs84nHDLSp3Mi2rO7rswkhDiBbImvh4r+cWuakZSJJUtDQoAB44WBBz3pzJ9AoXwlujxluDhgpuIKBhn7N4NT2cc/LsYTYpc6nlOzbIBgdIegQwE6petWM0IjPe7TUSRIwsBKYilhtFXqcTNdQkR6VzQV92eeeaZoDP83n777RpPiIiIqDI16RHYNN6MGKMEtyxwqtCJlr6duBQd1OBuUogZgSlx3p6C+UW8kBLN1IzAtmmJOHrSjl9zClHikhFb7oJo76R4GAHkuDw465bRzGyCIiT24iAiClKe7+8h/y5GFzV4F8q5a3lqH2U7S4PqVvmMQJYGJYo8jxBB5AN6MwI9EL4MQiIi/QoqI3DLli1o2rRp9QN9Pv30U7Rq1arGkyIiIgpEDRrFh9BPzmCQtPKgJ23sExht7DXI8gTKZAQWMfMhmuX5AoHt0hPRJMkMWRH4+Y+KfQLjjAZYfb2TCjxqQVDBXhxEREFS/x6Wz8SmyFJ7BMbXJhCo9ghkRqAuuWUFxW7v90HrpmppUA8Ez3GIIkoWAKpuDwjAe+FcEaxUQkT6F1QgcMiQITCZgj9x/fOf/wyLxVLjSREREQWilQYNsYxkqtX7N4mBwOhT053yycwI1IWzvgvSiXEx6Nw6GQCwv5LyoIkm72mpXfZeLBMAF9xUZxYtWoQLLrgASUlJSE1Nxbhx43Dw4EG/MSUlJZg1axaaNWuGxMREjB8/HidPnvQbc/ToUYwdOxbx8fFITU3F3Llz4fH4X6zfunUr+vXrB4vFgs6dO2PFihUV5rN06VK0b98esbGxGDhwIHbu3Bn210wNW34xMwKjkSMMpUHVzVIujwKnh91z9aZsJqdamURWBIpcfC+JIsmjBNc2xCBJEALcoEhEuhdUILCsIUOGYNWqVSguLq6L+RAREVWqJqVBASDdqmYEOsM+J6od9eJIYqilQeN9gUCWVopqeQ7v+5MYZ8K5ra0AgAO/5wccm2j0XiS1+3p5GsDSoFR3Pv/8c8yaNQtff/01srKy4Ha7MXLkSDgcDm3Mbbfdho8++ghr167F559/jj/++ANXXXWV9rgsyxg7dixcLhe2b9+OlStXYsWKFZg/f7425vDhwxg7diwuvfRS7N27F7Nnz8b06dOxYcMGbcybb76JOXPm4P7778fu3bvRu3dvZGRkIDc3t36+GNQgqBnYzAiMLg5nzc5dyypbNUE9HumHrcR7LhRvNiLJYkKM0ZuCxPKgRJHlUgSMUhApgQCEJDEQSES6F3IgsG/fvrjjjjuQnp6OGTNm4Ouvv66LeREREVXg0LLHQttVneYLBOYwIzDq2GuY5ZkS5y0NWsDMh6im9gj0ZgR6A4G/nCiEy13xQmai0ZcR6FEzAlkalOrO+vXrMXXqVJx//vno3bs3VqxYgaNHjyI7OxsAUFBQgJdffhmLFy/GsGHD0L9/fyxfvhzbt2/X1j8bN27Ejz/+iNdeew19+vTB6NGjsXDhQixduhQul/d7f9myZejQoQOefPJJdOvWDZmZmbj66qvx1FNPaXNZvHgxZsyYgRtuuAHdu3fHsmXLEB8fj1deeaXS+TudTthsNr8Parw8sgKbb2NNQbEbssLfndGiKAwZgUaDpD2ffQL1R+0PmBRrgiRJsMZ6N7OpAUIiigynIoK+KC5BcIMiEeleyIHAJUuW4I8//sDy5cuRm5uLwYMHo3v37njiiScqlMohIiIKp5qWkUyzskdgtNICgTXOCGTmQzRTM1MS4mLQPCUWTRLN8MgCP/9RWGFsosk/IxCCpUGp/hQUeEvWqn3Rs7Oz4Xa7MWLECG1M165d0bZtW+zYsQMAsGPHDvTs2RNpaWnamIyMDNhsNvzwww/amLLHUMeox3C5XMjOzvYbYzAYMGLECG1MIIsWLUJycrL20aZNm9q8fNK5splFQgA2ZhpFDUcYegQCpedJDB7pj/qeJfkCgGp5e1sxg7pEkeQSStAZgQBLgxKR/oUcCAQAk8mEq666Ch988AGOHTuG6667Dvfddx/atGmDcePGYfPmzeGeJxERUZmMwBBLgyazR2C00gKB7BHYIJVmBHp3wXdt4+sTGKA8aPmMQEkC3MxqoXqgKApmz56Niy++GD169AAA5OTkwGw2IyUlxW9sWloacnJytDFlg4Dq4+pjVY2x2WwoLi7G6dOnIctywDHqMQKZN28eCgoKtI/ff/899BdODUZeub+FLJsdPdQegaGe55SnPl89byL9KJsRCABJWiCQP6dEkeQWgDH4OCA3KBKR7tUoEKjauXMn7r//fjz55JNITU3FvHnz0Lx5c1x++eW44447wjVHIiIiAECRr0dgqBdT0pJ8pUELGAiMNo4aBgLL9ggUXJRFJSGElhGY6Lvo1a1tCgDgwO8FFcaXzwg0ShLcfG+pHsyaNQvff/893njjjUhPJWgWiwVWq9Xvgxqv/HJ9AdknMHqo5znxtSgNCgCJvmwylgbVHzXgp5YEtfoCguwRSBRZLkWBAcFFAo2Q4FKUOp4REVHdCjkQmJubiyeffBI9evTAJZdcglOnTuH111/HkSNHsGDBArz00kvYuHEjli1bVhfzJSKiRsxew4spzRK9GYHld8xT5Km7pEMvDertEejyKChxc1EWjexOD9y+ZhoJvvdXzQj8+bgNLo//+5bkywgs9GUEGuDt3UFUlzIzM/Hxxx9jy5YtaN26tXZ/eno6XC4X8vPz/cafPHkS6enp2pjyrRHU29WNsVqtiIuLQ/PmzWE0GgOOUY9BVJ3y2fHlA4MUOeomtoQQeyGXl8SMQN0qnxGolQZlmVeiiJGFgCxE0BmBBonrEiLSv5ADga1bt8ZLL72EKVOm4NixY3j77bcxatQoSGXqKvfq1QsXXHBBWCdKRERU0+yxJmr2WJELCk/go0pN+z4mmI0wGbznHuwTGJ3yHN4LXHExRphjvMH7Fk3jkJwQA7cs8OsJm9/4QBmBHsEgL9UNIQQyMzPx3nvvYfPmzejQoYPf4/3790dMTAw2bdqk3Xfw4EEcPXoUgwYNAgAMGjQI3333HXJzc7UxWVlZsFqt6N69uzam7DHUMeoxzGYz+vfv7zdGURRs2rRJG0NUnfIZgOrvX4q8mp7nlKee+xYyEKg7pYFAX0YgewQSRZxHCMhA0D0CjZIEJ9clRKRzIZ+Nbtq0CZdcckmVY6xWK7Zs2VLjSREREZWnKKJ0V3XIZSS92WOK8O6+VW9T5KnB3aQQ31NJkpASH4PTdhfyi9xokRxXF9OjWjjruzDdJCFGu8/bJzAF/ztwCvuPFqBrmxTtMa1HoOzLCJQAFwP3VEdmzZqFNWvW4IMPPkBSUpLWjy85ORlxcXFITk7GtGnTMGfOHDRt2hRWqxW33HILBg0ahAsvvBAAMHLkSHTv3h3XX389HnvsMeTk5ODee+/FrFmzYLF4M9FvvvlmPPfcc7jzzjtx4403YvPmzXjrrbewbt06bS5z5szBlClTMGDAAPzpT3/CkiVL4HA4cMMNN9T/F4Z0qXxGIEuDRo8ilxoIrG1pUF9GIEuD6k5hiVoa1OT713texNKgRJEjC++HIciMQKMEuBgHJCKdCzkQWF0QkIiIqC4UuWXt/6GWVzKbDEi0mGB3epBXxEBgNFF3yodaGhTwllZSA4EUffIc3gvRTcv9vHVrm4z/HThVoU9gotGXEegrGWoAewRS3XnhhRcAAEOHDvW7f/ny5Zg6dSoA4KmnnoLBYMD48ePhdDqRkZGB559/XhtrNBrx8ccfY+bMmRg0aBASEhIwZcoUPPjgg9qYDh06YN26dbjtttvw9NNPa9VVMjIytDHXXnstTp06hfnz5yMnJwd9+vTB+vXrkZaWVndfAGpQygf++Hcxejic3vPX+FqWBk3USoPyvdUbtQSomgnI0qBEkScLASEEDFJwhfIM7BFIRA1AUGej/fr1w6ZNm9CkSZOgDvrnP/8Zb775Jlq1alWryREREanUzDGDBMTGhFzZGk0SYmB3enDW4UKH5gnhnh7VgNMjl/aQq0HJLG9A14EClgaNSmccakZguUCgr0/gT8dt8MgKTL5MwCSTmhGo+Bbm3kW6IgQMQZbtIQqWCCLIHBsbi6VLl2Lp0qWVjmnXrh0++eSTKo8zdOhQ7Nmzp8oxmZmZyMzMrHZORIGoPZBNBgkeRTAjMIo4nOHJCExiRqBule8RaI3z/mtjRiBRxHhC7BFolMr2FeS6hIj0Kairbnv37sW+ffvQtGnToA66d+9eOJ3OWk2MiIioLEeZHitSDU6+m8Sb8fvZYuTz4ljUKHsxK9QsT6C092MeMx+iUmUZgS2bxcMaHwNbkRu/nihEl9bewKCaEegWAi7fItsjBDxCwMwFNxFRpdQNMW2axuPwaQczAqOIVtY+TBmB7BGoPxUCgSwNShRxNekR6PKtSxgIJCK9CvpsdPjw4UHtnAVQowu0REREVVFLKyXWIHMM8AYCAeCsg4HAaKGWBY03G2EMtkFDGclx3veUFzyjU2mPQP9AoCRJOK91Mr45dBr7fy/QAoGxBglGADK85UEtBgmyADwCYDFfIqLK5Tm8fwc7NE/A4dMOZgRGEUeYegQm+YJHhcwI1B21R2CSpXxpUL6XRJHi7REoEGydIYMEyIo3gGip05kREdWdoK6mHj58OOQDt27dOuTnEBERVaZs0Kgm1OwxBo2ih9YfsIbB3RT1PWVp0KikZQQmVAzjdWvrDQQeOFqAKwd575MkCUkmI/I9MgplGfHGGChCgcI+gUREVVIDf2rpc2bKR4+yFS1qI5GlQXVLDfipPQLVf1kalChyPL71RbCJLEZIUIQCmcsSItKxoM5G27VrV9fzICIiqpKjlkEjNSvpLHfJRw31YpZ6cStUKb4LKQW84BmVzmqBwJgKj3VrmwIAOHS8wK9PYKLRgHyPDLtHQQsLfBmBXHETEVVF3eSkBgILeK4TFVweReuFHF/L0qBJvvNfO0uD6o6WEaiVBmWPQKJIk4UAEHxFGqMkQfaVBiUi0qtgs6CJiIgiqrS0Uu1Kg7JHYPRQ39NaZwQyEBiV1AyVJvEVMwJbNY9HYqwJTreCIzl27f5Ekzfj1y7LMECCAsGdt0RE1VB/33ZkRmBUKXKV7YVcu9KgWkYgA4G6YyvfI9C3ka3Q6YGs8CSHKBJkEUoY0FcaFMIXQCQi0icGAomISBfUHoE13VGtZQSyR2DUUPvc1DQQmKwGd1kaNCqdraI0qEGScF4bb2/A/b8XaPcn+jIDC2UFRsm7W5cLbiKiypW4ZTg9CgCgvS8QWOyWUeKWIzktQmnQzmIyaJnvNaWeK7FHoL6UuGW4fD+fWmnQ2NJKCSz1ShQZHiEgEPwawyhJUITEjEAi0jUGAomISBdKS4PWrkdgnoO75KOFvZZ9c9TSoMwIjE5qRkqgjECgtDzogd/ztfsSjb6MQI8MgyRBQIIcwiKdiKixUbMBTQYJ6dZYmAzeHAf+bYy8Ipc3GFvb/oBAaSDQ7uT7qidq4FaSgETfZkazyYC4GO/5jq2E7ydRJNRoo6EQcDOLl4h0jIFAIiLShdqWBm3qC0bksTRo1FCDu0m1LA1awB4rUUdWhFaGN1BGIAB082UEHjxm00pjJZq8p6Z2WfGNEvBwvU1EVCl1g1NKfAwMBkn728jznchTNzzF17IsKFBaVrLErcCt/Y2kaKf2B0w0m2AwlBYitMZ530+ewxJFhktRanRBnL99iUjPQv6917FjR5w5c6bC/fn5+ejYsWNYJkVERFSeo7bZYwwERh21HJLa9yZUKXFq30deRIk2tmI31A2z6kXp8tqck4B4iwklLhlHTnr7BJbNCFQpLMFDRFQpddOFep7D853oUeQra1/TEuhllT3/dbBPoG4UlusPqEr2VbWwMRBIFBEuRcAohdIl0IsZgUSkZyEHAo8cOQJZrthvwOl04vjx4yEd64svvsAVV1yBli1bQpIkvP/++36PT506FZIk+X2MGjXKb8zZs2cxadIkWK1WpKSkYNq0abDb7X5jvv32W1xyySWIjY1FmzZt8Nhjj1WYy9q1a9G1a1fExsaiZ8+e+OSTT/weF0Jg/vz5aNGiBeLi4jBixAj89NNPIb1eIiKqObvvYkpCDXsEqllJeUVuCAYWooL2nta4R6D3Igp7IUWfs74L0EmxJsRU0hfJYJBwXhsrAODA0XzveFNpj0Av9uIgIqpKaRnmGL9/uUkm8tRqFuHICIwxGhAb4/sbyb5yuqG+V2p/QJXaJ5ClQYkiwyUEDCEGAgXAdQkR6VrQV94+/PBD7f8bNmxAcnKydluWZWzatAnt27cP6ZM7HA707t0bN954I6666qqAY0aNGoXly5drty0Wi9/jkyZNwokTJ5CVlQW3240bbrgBN910E9asWQMAsNlsGDlyJEaMGIFly5bhu+++w4033oiUlBTcdNNNAIDt27dj4sSJWLRoES6//HKsWbMG48aNw+7du9GjRw8AwGOPPYZnnnkGK1euRIcOHXDfffchIyMDP/74I2JjY0N63UREFLrSjMCaXUxRs5JkRcBW4tF24lLkqH1uarpTPsligkECFOHdUR0bU/sLbRQeeY6qy4KqurVJwZ6fz+LA7wUYO7BNgIxAAZnrbSKiSuUxIzBq1baaRXlJsTEocTu1kqMU/dRAX/mMQDUwyNKgRJHhUgRCXTkaJGYEEpG+BX1GOm7cOACAJEmYMmWK32MxMTFo3749nnzyyZA++ejRozF69Ogqx1gsFqSnpwd8bP/+/Vi/fj2++eYbDBgwAADw7LPPYsyYMXjiiSfQsmVLrF69Gi6XC6+88grMZjPOP/987N27F4sXL9YCgU8//TRGjRqFuXPnAgAWLlyIrKwsPPfcc1i2bBmEEFiyZAnuvfdeXHnllQCAVatWIS0tDe+//z4mTJgQcH5OpxNOp1O7bbPZQvr6EBFRqSLfruqaBo1iY4yINxtR5JKRX+RiIDAKqBeyavqeGgwSkuNikFfkRn6xG6lWbsyJFmd9gcAm8dUEAtuqfQILoCiiQo9AIQCZO2+JiCqlBhJSfOc16r/MCIw8h6t21SzKS7KYcKrQyYxAHSnUAoH+647S0qB8L4kiwaUoIZcGNUoSnIJdAolIv4IuDaooChRFQdu2bZGbm6vdVhQFTqcTBw8exOWXXx72CW7duhWpqak477zzMHPmTL/+hDt27EBKSooWBASAESNGwGAw4H//+582ZvDgwTCbSy9EZWRk4ODBg8jLy9PGjBgxwu/zZmRkYMeOHQCAw4cPIycnx29McnIyBg4cqI0JZNGiRUhOTtY+2rRpU4uvBBGFw9EzRXjk0wM4VeisfjBFFTVoFF+LXdVqUEINUlBk2cPQO0fNfOAFz+hyNsiMwHapiYgzG1HklPFbrr00I9BXht7InbdERFVSM7Cb+H7fqv/m8Vwn4oq0c9fwVCxQeyqrFRUo+lXWI9Dqu83SoET1TxECHuHN8CvLrQi8fzIPvxUHvlZklCS4uC4hIh0LuUfg4cOH0bx5cwBASUlJ2CdU1qhRo7Bq1Sps2rQJjz76KD7//HOMHj1a61GYk5OD1NRUv+eYTCY0bdoUOTk52pi0tDS/Mert6saUfbzs8wKNCWTevHkoKCjQPn7//feQXj8Rhd9/vvgFyz7/BfPe/TbSU6EQObSgUc0vpjRJ4C75aGL3XfxIjK1NIND7nrIEWnRRewRWlxFoMEjo0tqbFXjg9wIk+voJ2j3e3bbceUtEVDW1R6D691D9N58lByPOUcvKB+Wpx2FGoH7Y1B6B5TICWRqUKHJkAcio2CMw2+bAayfO4tU/zgR8nhFgIJCIdC3kQKCiKFi4cCFatWqFxMRE/PrrrwCA++67Dy+//HJYJzdhwgT85S9/Qc+ePTFu3Dh8/PHH+Oabb7B169awfp66YrFYYLVa/T6IKLL+yC8GAHy2Pxfbfj4d4dlQKBy+0qC1Ka/EjMDo4ghHRqB6IYXB3ahS2iOw+hK8annQA78XaKVBXULAqSi+Xhx1N08iIr3LL7fxoomWKc9znUhTS4PGh6k0qHq+xB6B+mErDtwjsLQ0KM9f9Wz99yew68jZSE+DQuQR3h7k5bcXn3F7f7eedgf+HevNCOTChIj0K+RA4EMPPYQVK1bgscce8yu32aNHD7z00kthnVx5HTt2RPPmzfHzzz8DANLT05Gbm+s3xuPx4OzZs1pfwfT0dJw8edJvjHq7ujFlHy/7vEBjiEgfcsuUBH1o3X7I3NGlG+qu6oQwlAZl9lh0qG2PQKBMadBivqfR5KzDe2GrSTWlQQGgW5vSQGCsJGknpw5ZgQES3FxwExFVKk8LBMb4/ZvHDTIRV6RtYgtzaVBmBOpGaWnQchmBvts2vpe6lVNQgptf242bXs2GYD9rXZGFgCJEhR6BNo9384bNLQd8nkEC3L7nEhHpUciBwFWrVuG///0vJk2aBKOx9IS2d+/eOHDgQFgnV96xY8dw5swZtGjRAgAwaNAg5OfnIzs7WxuzefNmKIqCgQMHamO++OILuN2lC6GsrCycd955aNKkiTZm06ZNfp8rKysLgwYNAgB06NAB6enpfmNsNhv+97//aWOISB/U3oAGCdh/woa3s1myVy/U7LHaBALVfmUMBEaHQl9p0Nq8p+qOapZ7jS7qz1izIAKB7dOTEGs2wlHiwbHTRVpWYKFH1hbcREQUmFoCVN0Yk8JNT1HDHoZz17KSmBGoO+q5boUegXHe2ywNql/H8ooAeCvNMKCrL2pGYPkegQW+QGChrEAOsP4wShIU3/OJiPQo5EDg8ePH0blz5wr3K4riF2wLht1ux969e7F3714A3v6De/fuxdGjR2G32zF37lx8/fXXOHLkCDZt2oQrr7wSnTt3RkZGBgCgW7duGDVqFGbMmIGdO3di27ZtyMzMxIQJE9CyZUsAwHXXXQez2Yxp06bhhx9+wJtvvomnn34ac+bM0eZx6623Yv369XjyySdx4MABPPDAA9i1axcyMzMBAJIkYfbs2XjooYfw4Ycf4rvvvsPkyZPRsmVLjBs3LtQvIRFFiKwInLZ7A4HTL+kIAHhi4yEupnVACFFaGrQWPQJTuEs+anjfU+9iq/zFkVCwF1J0UsvvVtcjEACMBgnntvKWTz9wtACJvo1mdlnx9ghk5jYRUaXyy/UILC0Nyr+LkVbkrP25a1lqRiB7BOqH+l6pPQFVWkYgz191S72uAAAnbSURnAmFSu0RWDEj0FuFRMC7IbE8o++5Hi5NiEinQg4Edu/eHV9++WWF+99++2307ds3pGPt2rULffv21Z43Z84c9O3bF/Pnz4fRaMS3336Lv/zlL+jSpQumTZuG/v3748svv4TFYtGOsXr1anTt2hXDhw/HmDFj8Oc//xn//e9/tceTk5OxceNGHD58GP3798ftt9+O+fPn46abbtLGXHTRRVizZg3++9//onfv3nj77bfx/vvvo0ePHtqYO++8E7fccgtuuukmXHDBBbDb7Vi/fj1iY2NDes1EFDlnHS4oApAk4LYRXdC+WTxOFTrxn89/ifTUqBrFbhnqxrvalJHUMgLZIzDiStyKVpqXPQIbHjUTpWkQGYFAuT6BRu/pqd0jwwBAQATclUtE1NgpigjQI1DNlHdB4UaKiFI3sYWvR6D3veUmRv2wVZoRGOP3OOnPqTItR04UMBCoJ2pp0PIXxAvKBP8KAgQCDZIERXBdQkT6FfIZ6fz58zFlyhQcP34ciqLg3XffxcGDB7Fq1Sp8/PHHIR1r6NChVdbS3rBhQ7XHaNq0KdasWVPlmF69egUMXpZ1zTXX4Jprrqn0cUmS8OCDD+LBBx+sdk5EFJ1yC70n6M0SzIgzG3H36G64+bVs/PeLXzHxT23RMiUuwjOkyqgXPCQJiIupTUYgy2VFi7LvaXwteuewR2B00jICgw0EtkkB4A0EtunlLd2uZgS6fAvu8rt2iYgau8ISD9RYn5oRqP5dVIT38eT4mMqeTnVMLWtfmw1PZbFHoP5oGYHlAoFqaXtbMd9LvTplL1175BQUR3AmFCqPEBDCG9gry1ZNINAoeYOILA1KRHoVckbglVdeiY8++gifffYZEhISMH/+fOzfvx8fffQRLrvssrqYIxFRWOT6du2dk+TN5M04Pw0DOzSF06Pg8Q0HIzk1qobWH9BsglSLYEBTNRDo4O7bSFMDgYm1fE+T49kjMNq4ZUW78NU0iNKgANAhPREmo4TCYjdifItru+zNCFRYgoeIKCB1Y1O82QiLybupxmwyIMG3wYYbnyKrNCMwPKVB1WASMwL1o7RHYODSoMVuGS5fOULSl7IZgTkFzipGUrTxCF+ZqHIK3KXBP1vAQKAEGewRSET6FXIgEAAuueQSZGVlITc3F0VFRfjqq68wcuTIcM+NiCis1JP11CRveWFJknDf5d0hScB7e45j7+/5EZwdVcURph4rpT0CeWEs0tTd7Am13CWvlgZlIDB6qD9fBqliT5zKmIwGJPuyB02+dbfdo7AEDxFRFdT+uOX7sbICQnQoUjeyhSsj0KL2COQ5jx4IIcpkBPqfDyXFmrQ4BMuD6lPZHoE5NmYE6oksAAn+awu3IlCklAblA5YGhTcjUOayhIh0qkaBQCIiPTqlZQSW9hnt0SoZV/VtDQB46OMfqyxXTJGjBQJr2WNF6xFY5OJ7HWFaRmBsLQOBvoudBcW8iBIt1IzblHgzjIbgsz3VQKDBo2YEKjBI3sU6A4FERBWpgb6UcuU/U5gtHxVKN7KFORDIjEBdKHbL8Phq95bvEWgwSNr7aeM5rC6VDQSyR6C+qKVByyqfARgoEKhWsWFGIBHpVciBwCZNmqBp06YVPpo1a4ZWrVphyJAhWL58eV3MlYioVspnBKrmZpyH2BgDdv2Wh0+/z4nE1Kgaamml2l5IUXfMu2XBskoRpgUCw5QRaHd64JZZWikaaP0BQ+xLpZZ5lXxleQo9sq8Ej2BpUCKiAPIrCQQ2Yf/ciBNClJ6/hqk0KHsE6ouaDWg0SAHLw6pZgtzMpk/+pUEZCNQTGQJA5f0BAf8yoRWez0AgEelUyIHA+fPnw2AwYOzYsViwYAEWLFiAsWPHwmAwYNasWejSpQtmzpyJF198sS7mS0RUY7mF3hP0c8oFAtOTY/GPwZ0AAIs+3Q9ngN1fFFlaj8BalgaNMxsRG+P908dd8pHlCFMgsGzpSV5IiQ5qhoqagRssq2+87Pt5L+0RKKBwwU1EVEHZDOyytFLo7IkcMU6PAl8yGOLDlBGYZCnd/ETRTy3hmmgJ3A872XcOa2NgV3eEEOVKgzIQqCceRUCS/NcW5TMAA2UEAoAEiRmBRKRbIZ+RfvXVV3jooYdw8803+93/n//8Bxs3bsQ777yDXr164ZlnnsGMGTPCNlEiotoqzQiMrfDYP4Z0xBvfHMXvZ4uxcvsR3OQLDFJ0CFdpUMC7S/5EQQnOOlxo0zS+1sejmikMUyDQaJBgjTXBVuJBfpEbzRMt1T+J6lRpRmBogcDkBO8FMblEBiyS1iNQCJbgISIKRM0ILJ+BrWUEskdgxJQN1sXHhDcjsMglQ1ZESOW3qf6pAT5rXOBzXfV+lgbVH7vTgxJ3aSWS/CI3il0y4sKU/Ut1y6kIGKWqMwLL31YJViohIh0LOSNww4YNGDFiRIX7hw8fjg0bNgAAxowZg19//bX2syMiCqPcAD0CVfFmE+ZmdAUAPLvpZ5wps8OPIs8exh4r6sWxPF4ciyi1rFVY3tMEtU8g39NooAYCQ84I9P1sOou83xt2tdSrBDBPm4ioojxfdYPyGy/UwGAeqx9ETJEvuz3ebIQhTAG7spUxmBUY/dQAn5rJWR5Lg+rXabv3XDfebNTKvjIrUD+ciqhwMVzNAGweY/K7HYhbYTsKItKnkAOBTZs2xUcffVTh/o8++ghNmzYFADgcDiQlJdV+dkREYSKEQK4tcI9A1VV9W6FHKysKnR4s+eyn+pweVaO0NGg4gkbqxTEGjSJJzfJMiq39e6r2CWQJtOigZQSGGAhUewSW+C6u2GXvz70k2IuDiCiQ/OLKSoNy01OkqYG6+DBUs1BZTEaYTQa/41P0UnsEVnauW1oalOevenOqzAbj9GRvtSH2CdQPt6JUmhHYJta3wbSSQKBRkuBWuC4hIn0KORB43333Ye7cufjLX/6Chx56CA899BCuvPJK3Hnnnbj//vsBAFlZWRgyZEjYJ0tEVFMOl4xiX8PnQBmBAGAwSPi/Md0BAGt2HsVPJwvrbX5UtSKXWkay9uVWtIxABo0iyh6m0qAAkKyWQOOO6qig9QgMuTSod3xRoff5JYrwLrQliYFAqhNffPEFrrjiCrRs2RKSJOH999/3e3zq1KmQJMnvY9SoUX5jzp49i0mTJsFqtSIlJQXTpk2D3W73G/Ptt9/ikksuQWxsLNq0aYPHHnuswlzWrl2Lrl27IjY2Fj179sQnn3wS9tdLDY9a+jMlrlxpUN+mJ/ZDjpxwnruWleQ7b7Kzr1zUKw0EVpIRqAYCi/le6o3aH/CcRAvSrb5AoK04klOiELiFQPlEbTUQ2DbOux4pUQScATL/jL7HiIj0KORA4IwZM/D5558jISEB7777Lt59913Ex8fj888/x7Rp0wAAt99+O958882wT5aIqKZyfaU6EszGKrPKBnVqhpHd0yArAg9/sr++pkfVCOeuapYGjQ7hLPeqXgBlL6ToUNPSoGqPQHuhSztBtcsye3FQnXE4HOjduzeWLl1a6ZhRo0bhxIkT2sfrr7/u9/ikSZPwww8/ICsrCx9//DG++OIL3HTTTdrjNpsNI0eORLt27ZCdnY3HH38cDzzwAP773/9qY7Zv346JEydi2rRp2LNnD8aNG4dx48bh+++/D/+LpgZFPZdRA38qZgRGnsOllgYNX0YgUNon0O5kkDfaFfoy/SrtEcjSoLqlZgQ2TyzNCDzBjEBdEEIE7BGoZgCmm2Ng8j0UqE+gUZLgYmlQItKpkM5K3W43/vGPf+C+++6rsAgmIopm6sl6qm/HXlXmjemGLQdzseXgKXxz5CwuaN+0rqdH1XCEMXtMLVfIi2ORpe5kTwxHadB4XkiJJlpGYA17BDpKPEgwGlAoK7B7vAtthRmBVAdGjx6N0aNHVznGYrEgPT094GP79+/H+vXr8c0332DAgAEAgGeffRZjxozBE088gZYtW2L16tVwuVx45ZVXYDabcf7552Pv3r1YvHixFjB8+umnMWrUKMydOxcAsHDhQmRlZeG5557DsmXLwviKqaFRqxuULw2qbnpiRmDkOLQNT2HOCPSdN9mYERj11JKf1kozAk1+40g/tIzAJIv2PrI0qD7IAlAgUP43sxr0SzYZkWwy4oxbRoFHxjlm/59fgwQ4uS4hIp0KKSMwJiYG77zzTl3NhYiozuQWlpbvqE6H5gkY3jUNAPDdsYI6nRcFR91VHZYegfHsJxcNSkuD1v4CWWlGIN/TaKD+bIXaIzAhzqSV6YkzeE9RC2UZRnDnLUXO1q1bkZqaivPOOw8zZ87EmTNntMd27NiBlJQULQgIACNGjIDBYMD//vc/bczgwYNhNpf+PGRkZODgwYPIy8vTxowYMcLv82ZkZGDHjh2VzsvpdMJms/l9UOOjZsI3qRAIZD/kSHOEsfJBWYksDaobQfcI5EY23fHPCIwDwECgXniEgCwAQyUZgVaTAckm7/q0soxAtyIgGAwkIh0KuTTouHHjKvTPICKKdlpDb2v1gUAAaJHizRw85dvtR5EVzl3VTZkRGBVKA4GBd0mHgj0Co4tWGjTEHoEGSYLV9/Op5m7bZQUGCXBxsU0RMGrUKKxatQqbNm3Co48+is8//xyjR4+GLHsvDOXk5CA1NdXvOSaTCU2bNkVOTo42Ji0tzW+Meru6MerjgSxatAjJycnaR5s2bWr3Ykl3XB5F2yilBv5UKb4eR0UuGc4AFzKp7hWpm9jCXRrUd96knkdR9KouEKhmCjK7U3/KZgSW9ghkIFAPZAjIomJpUC0jMMYIqy8QWOAOHAiU2baAiHQq5LPSc889Fw8++CC2bduG/v37IyEhwe/xf/3rX2GbHBFRuKgZgalJwQUCz/GNUwOIFFlaIDCMPQLVYAVFhj2M5V7ZIzB6FLtkFPsWzeV7VgUjOT4G+XYXzL7Ftd0jwxBrhkvhapvq34QJE7T/9+zZE7169UKnTp2wdetWDB8+PIIzA+bNm4c5c+Zot202G4OBjUx+sfdvniRVLD2YFOvNsFYEUFDkRqo1vOUpqXql/a3rpjQoMwKjX2G1pUGZEahXpRmBZrRgj0BdkQUg4J8V41IUFPvWGlajUcsILAiwkcYAwCW8mYUxkCo8TkQUzUK++vbyyy8jJSUF2dnZyM7O9ntMkiQGAokoKuUWek/Mzwk2EJjIQGA0sYexvBL75kSHcPZ9ZI/A6KFm2sYYpRq9t94+gQ4YZe9i3C4rMADwMBBIUaBjx45o3rw5fv75ZwwfPhzp6enIzc31G+PxeHD27Fmtr2B6ejpOnjzpN0a9Xd2YynoTAt7ehRZLcOc01DCp5zHJcTEwGPwvRhoMElLizTjrcCGvyB1Uj2wKryJX3ZYGLWRGYNSzFasZgYEDgSwNql+n7d7z3XOSLEj3BQJP251wywpijCEXXqN65C0N6p8RaPP1JDdJQLzRUGUg0CRJUIQCmdVKiEiHQv4Ldfjw4Uo/fv3117qYIxFRrZ3SMgKDuxDCjMDoopZXCkfQSM1SOlvkYm3/CFJ3sidWUi4pFGogkMHdyFMzbZvEmyFJoe+STfb9fBrcaiBQhlGS4OTPKkWBY8eO4cyZM2jRogUAYNCgQcjPz/fbHLl582YoioKBAwdqY7744gu43aW/n7KysnDeeeehSZMm2phNmzb5fa6srCwMGjSorl8S6VieI3B/QFUK+wRGlMOp9rcOb0ZgIjMCdcPmywistDRonEkbxzWJfggh/HoENo03I8YoQYjSKkQUvWQhIEOg7P6Z0v6ARkiShOSYKjICJW9WoYc/s0SkQ9yqQkSNgtYjMMTSoKfZIzAqaOWVwnAxRb1g5vIoWglDql9CCNhd4ev7mBynZnnyYmekqRec1V6coVJ7BAq3d2eu3ePtEehWBC+SUdjZ7Xbs3bsXe/fuBeDd8Lh3714cPXoUdrsdc+fOxddff40jR45g06ZNuPLKK9G5c2dkZGQAALp164ZRo0ZhxowZ2LlzJ7Zt24bMzExMmDABLVu2BABcd911MJvNmDZtGn744Qe8+eabePrpp/3Ket56661Yv349nnzySRw4cAAPPPAAdu3ahczMzHr/mpB+5Pk2v6TEB842Kq2AwL+NkeDQSoPWTUag3cnNT9Eu2B6BbllwTaIjthIPXLL3PPWcJAsMBglpap/AguJITo2C4BECipDKZQSWBgIBaBmBtgCBQPYIJCI9q9FZ6bFjx/Dhhx/i6NGjcLn8FxaLFy8Oy8SIiMLpVKg9An2lQc84XJAVAaOB9d8jRQgR1jKS8WYjzCYDXB4FZx2usF+goeoVuWSoMZ0kS+h95MpTL4LaSjz8eY2ws9VkqFQn2fdeKiUyEGdEoSzDCECBgCy8JXuIwmXXrl249NJLtdtqcG7KlCl44YUX8O2332LlypXIz89Hy5YtMXLkSCxcuNCvJOfq1auRmZmJ4cOHw2AwYPz48XjmmWe0x5OTk7Fx40bMmjUL/fv3R/PmzTF//nzcdNNN2piLLroIa9aswb333ot77rkH5557Lt5//3306NGjHr4KpFdqgK+y37dNtIxABowiIZzVLMrSegSyNGjU03oExgU+1403G2EySPAoArZiD9ckOqFuFE6ymBDryxxrkRyLY3nF7BOoA94Ann8Ur6BcINBaRWlQIwDFV16UiEhvQj7T2LRpE/7yl7+gY8eOOHDgAHr06IEjR45ACIF+/frVxRyJiGrFLSs44yit4x+MpglmSBIgKwJ5RS40T2QfnkhxehSo7cHC0WdFkiQ0iY/BSZsTeQ43Wjep9SEpROrFK6NBQmxM7YsTpJS5wGIrdqNJDbPRqPbUUnW1zQh0F7uBJkZfRqDk7ecBARMYCaTwGTp0aJWZphs2bKj2GE2bNsWaNWuqHNOrVy98+eWXVY655pprcM0111T7+YhU+cVVZwSm+AKELA0aGQ6XmhEY5tKgao9AlgaNaooitD6OlWUESpIEa1wMzjpcsJW4tV5zFN20sqBlriukJ8cByEMOA4FRTwlw3qdm/iVrGYHen9lAgUBJkiDA0qBEpE8hX32bN28e7rjjDnz33XeIjY3FO++8g99//x1Dhgzh4pWIotIZXzNvk0FC0yCzVExGA5r5LkizT2Bkld3xHB8TnospTXhxLKLU9zTBbKxRH7nyTEYDknwXxtQLoxQZZ32ZJ2ovzlCpGYGuIu/3iF2W2YuDiCgA9RwmJa7qjED2z40MtZpFODaxlVVaGpSBwGjmcHm06hdqCdBArL4gYQHPX3VDzQg8p8xG4XSr9/8MBEY/jxCQym0sLJ8RWLY0aOANYxLXJUSkSyEHAvfv34/JkycDAEwmE4qLi5GYmIgHH3wQjz76aNgnSERUW7mF3hPy5oneGv7BUrMAGQiMrNIeK8aQ3r+qMBAYWXatZ0rty4KqkrUSaHxPI+msw/v7MthNF+Ul+zZgFPs2cNg9CgyQIITQMoOJiAjId/g2XlSXEejg38VIcDi9F5bDHQhUz52YERjd1PcnxijBYqr8sluyr6qFjYFA3SjNCCw91/VmBAInbAwERjuPAES50qDlMwKtvp9ZjwCKfP0gy5Lg3aRIRKQ3IQcCExIStL6ALVq0wC+//KI9dvr06fDNjIgoTHJtvl17QZYFVanjGQiMrLq4kKKWLeTFscjQMgIt4SuXpZZGK2DmQ0TlqRema1wa1Ps+OtRAoCzDKAGyENx5S0RUhpYRWMnv29JNT/y7GAlFrtLqB+Gk9QhkIDCqqYFAa2xMldUv1P6BthL+nOpFoIzAFr6yrieZERj1AvX2K58RaDYYEOfbgByoPKgA1yVEpE9BBwIffPBBOBwOXHjhhfjqq68AAGPGjMHtt9+Of//737jxxhtx4YUX1tlEiaJdibuysgEUaad8J+upNQ0E2hkIjCRHHVxIUYNGZ3lxLCLUQGBiGIO7amm0/GIGdyPpbG17BKqZhC7v39NiRUABIIM7b4mIylJLflaeEaiWBuXfxUiw11FGIEuD6oMa2KusP6BKLRvKjWz6oWUElgkEplm9gcATDARGPZeiwFiuNGj5jMCy/w8UCAQCBxSJiKJd0IHABQsWwOFwYPHixRg4cKB23/Dhw/Hmm2+iffv2ePnll+tsokTR7JdTdlz0yGZMXf5NpKdCATAjUN/sddBjRQ1S8OJYZKi72BProDQoeyFFlpqhUtNAoNEgITHOBLgVbYle4lGgCMEFNxFRGerGlyaVlGLWAoEsORgRpRmBYQ4ExpYGAhXWzI5ahVogsOpz3dKMQAZ29eK0r2pF2WsLWkagrYQ/l1HOpQiU7zZiK5cRWPb/gQKBRkhwKRVLhhIRRbugz0rVTKeOHTtq9yUkJGDZsmXhnxWRjsiKwB1r9+Gsw4Xtv5yGrAgYw9THjMLjlN27My/kjED2CIwKjjoIBKp9c86yNGhElGYEhjHLM46BwGig/kxVdmE6GMnxZtiLPbBIEkqEgF1RIAR33hIRlaWW/EypJCNQ/T3MTU/1T1EEilzei8fxYTzXAfyrKThcnrD2W6bwKdT6YVeTERjnfZw9AvUjUEbgOUkWGCTAowicdjiRmhQbqelRNZxCgVGqXUagQQKcDPgSkQ6F1COwqtrmRI3Vf7/4FXuO5gMA3LLQasZT9GBGoL4V+UorhbOMZNMEBo0iqU5Kg6o9AnkhJWKEELXOCASAZN/Pp8W3vrZ7ZECS2IuDiMhHCKEF+FIq2XhRGgh0s31BPStyl144Due5DgBYTAbEGL3XZVgeNHrZyvQIrIr6OHsE6ofWI7DMtYUYo0ELDJ4s4LWDaOZSAGOZS9tORUGJL6jnFwiM8f7fFigjUJLgFMwIJCL9CemstEuXLtUGA8+ePVurCRHpyaGThXgq6xAA764gRQDH84u1GvEUHXIL1ZP10N4X9giMDupFjviw9ghkRmAk1UW5V61HIDMfIsbu9MDta+RXm4xAqy+IaFYAGAC7rCDOYACX20REXg6XXOb3bdU9Aj2KQKHTU21AgsKnyHeeY5C8gbtwkiQJiRYT8orc3lLryWE9PIWJmuFXfUYgN7LpiRClG7+bl9tk3CI5FrmFTpwoKEbP1vzBjFYuRYGhTI9ANdAXI0mILVPZq6qMQKPkDSgSEelNSFfgFixYgORk/kEjAgC3rOD2t/bBJSsY1jUVhSVufHMkD8fzitGvbZNIT4/KUDP6Uq2hZQSmMiMwKjjqIHusKctlRZT6niaF8T1NZi+kiMtzeL/2cTFGxNUicG/1vZcGWfgCgTLOiTExI5CIyCfPt5HJbDIgLibw79vYGCPiYowodsvId7gZCKxH2oYns6lOqiolxnoDgYXMCIxapaVBq/65S1Z7BBbzvdSDgmK3tgmjeaL/prf05FjsO1aAHFtJJKZGQVB7jpft5FNQpixo2d/XVfUINLBHIBHpVEhX4CZMmIDU1NS6mguRrizb+gu+O16A5LgYLLqqJxZ9sh/fIA9/5BdHempUhhBCC+Sdkxhqj0BvBmFBsRtOjwyLKbw9Pig4Dl+PlXBmj6nZSmcZCIwIu+/iSGI1u6RDwR6BkXc2DGVBASDZ93zJrQAxBhR6FAgJkBkHJCICUJo91CQ+pspAU5P4GBQXyMgrcqFts/j6ml6jV1QH565lJVpiABRr51MUfQpLgswI9D3O0qD6oF5XsMaaKlwbaJEcBwDIKWAgMFp5hIACwFTm72aBr5SztVz2tpYR6A6cESj7gorl+w0SEUWzoOtUsD8gUakf/7Dhmc0/AQAW/OV8pFlj0TLFe+LHQGB0sRV74JK9u7VC7RFojTPBbPT+mjxtZ8AoUhzarurwBWKb+HqQlbgVFLsqntxT3Sqsi9KgvuAuSytFjpqhov581ZSa3Sl8NXfsvt/hMjMCiYgAQOvHWl0ZZvVvYx43PtUr9dw13lI3mwjVigrsERi9tB6BcdX0CGRpUF05FaA/oEptD8NAYPTyCO/GwrK/mdXSoNZygV01EFhZj0AZgFvh2oSI9CXoQCAbjBN5uTwKbl+7D25ZYGT3NFzZpyUAaIHA4/k88YsmuYXe98Maa0JsJaWTKiNJUmmfQJYHjRhHHQSNEi0mmHw1QXhxrP7VRblXtRcSy71Gjtpzs/yFaUmSkGgywiEHV0JHzQiUfRfR7LIMIyS4WYKHiAgAkOfLfk+ppD+gSt2YwWz5+uVwlZYGrQtqllkhs8iiVrAZgaWlQfle6oF6TaB5gEpDLZK9gcATDARGLVkIKELAUDYjsJpAYMDSoJK3/64MXicnIn0JOhCoKArLghIBeG7zT9h/woYm8TH49197atmyrZowIzAalfYHjK3R85szEBhx9joIBEqShCYJ3CUfKfY6DAQWFLuhcHdmRORVURr03HgLBICSIIKBao9At69fTqFHgUECnHxfiYgAlG56SYljRmA0cjjV0qB1kxGYqAUCmREYrdT3xlptaVDvOU+h08PzVx1QqwQFyghM9wUC2SMwenm0cp6l99nK9AgsS71tl5UKVUmMkKAIbzCQiEhPgg4EEhHw7bF8LN36CwBg4bgefieArbSMQAYCo0luDfsDqtTnMRAYOWqflXAGjQCgqXpxzMEduPWtLgKB6o5qRZSWHqX6VVlGIACkW2LQxmLGSVf1P29qRmCJ72fTLsswSBLcrE5BRASg9NylulLMav/cPGYE1quiOs4ITGRp0KhXmhFYXWlQ73speP6qC6ftlWcEppcpDcqKatFJFoAM+PX1qywjMNFkhARA4P/Zu/PwuOp68ePvc2bPvidN932hKwVKsexlBwERRFEUEdzwiqh4vdeL/oArVxQUFUUUFARkEVlkKUvL3tLSQvd9S5c0SbNOZiaznXN+f5w5k6TNntmSfl7PkydtMpk5yclMvuf72aD1iKpAszWoQVROsxBiiJFAoBB9FIpqfP/pdWi6wUWzR3Dx7MpOn7daQbS0ReSiLINYrUHL8gYYCJSKwLSznk9ZCZwRCO0VZJIln3q+WJZ0Ti9Z0v3hstvivyMtsuGZFlYgsKuKQFVRmJLtxq4oBHqpCsyLfb0eq6jwRXVsQFiyboUQAmhfuxT0MiPQSsxokbVOSvlif7+yEpzEZrHWTz6pCMxY3jarIrDnQKDLbsPtUGNfI+vXTGftCfRUEdgW0eLnX2SWeGvQDh/zRs3rkiMrAm2KQq7dvOWR7UFVxbwvmV8uhBhqJBAoRB/9+o0d7KjzUZLj5I5LZx71+Vy3I97645BUBWaMeGvQLhbrfREPBPqkxUe6JGOeHLQHKyQQmHrJqAiEjpUPck7TIV4R2EUgEKDUaWecx8XhXpJlnHYVj9OGEjEvrqUiUAghOmuJBQwKe5kR2J70JAGGVArE1znJaQ2aKxWBGa+vMwKhPVjolZmPGc+qCOyq25DbYYu/Jh/yyn5QJooaBgbEx/tA9xWB0P2cQJuiYBjm/QkhxFAigUAh+uDjfU08+K7ZEvR/L5/VZbUDQKW0B804dT1k7fWFVASmn9UaNJEzAqE9i94KXojU0HQjae1e82PntFkyqtMiPiOwmwoVRVGYmOXGZVPwHXFBfaS8bAdEzAxdX1THpkBEN6TVkhBC0P+KQEmQSS1/bJ2TleTWoNJKMjNpuhH/HehTINDTPudaZDZrT6Akt+vX3op8cz+opkWSiDORGbhTOn2suxmBHT/m7ea6RQKBQoihRgKBQvQiGNH4wTPr0A24fN5Izjuuotvbjio0F37VzbLwyxTtFYHuAX29zAhMPyvbOTvBWdVFsbk6zZIln1L+cPumVcKDux7rnMqGZzr01BrUUuK0M87t4nCk583L/CwnSiwQGNB1DMNAx0CT620hhIhX+Fl/97pTKGudtLC6WWQnuK29JSdWQSatQTNTx/PS24xAaJ9zLe0kM197RWDXewsVsXEkEgjMTOZ1RPvFhGEY8SBfVxWBeXbzWvXIisDO9yeEEEOHBAKF6MWvXtvG7sN+ynJd/OyS43q8rVURWC0VgRkjYRWBPgkEpoNhGO2bKQkOGhVKRWBaWOfTYVNw2RO7DLFaoElGdXpYG9M9BQIBJma7yFLVbrNrAfKznRBtnyUY1M0goGTeCiFEe8JLd62YLQVSEZgWVtJToteulhxpDZrRrBafboeKsw9rXWu8iLQGzWy6blDvM19Le6sIPCSBwIx05HVEUDcIxz7WU0Vgd4FAuS4RQgw1EggUogfeYIS/Lt8LwP9dMYv8XuZwSGvQzDPYGYFlHVqDSku61AtFdaK6+XNPViBQNsdSy8qSznHZO81nSAQrECiVD6mn6UaHjeleKlQcdiZluWgIR7t9Xc3LdqAY4Ih9uk3X0QENeR0WQogmayZrL9cm1lpH/i6mViAUaw2apECg1W5SKgIzkzc+H7D3akBobw3qlUS2jNbcFkGLXZcWZ3e9tzAi36wUlIrAzKQZRseCwHhSolNRcNuO3h6PBwIjEggUQgwPaQ0Evvvuu1xyySVUVlaiKArPP/98p88bhsFtt93GiBEj8Hg8LF68mB07dnS6TWNjI9dccw15eXkUFBRw/fXX4/P5Ot1m/fr1nHrqqbjdbkaPHs3dd9991LE888wzTJs2DbfbzaxZs3jllVf6fSxi+Nlb70fTDUpzXZw1rbzX20sgMLMEI1q8MmigrUFLYq1BgxFdsm7TwJolB5DlSGx7JStYIYHA1GpNUoUnQL5HNjzTxdsWIbY3Et947smELDe5dlu3GbZ5sc1te6znTiCqoxvSGlQIITTdwBsLAPU+IzDWQjIUJdyhylokV7wiMEmtQa1AYKtUkGWk1tjzsy/zAQHy3BIIHAqsBOOCLEe3lZ4VebFAoFcCgZkoohuoHfJQW3qYD9jx411dryix+eVCCDGUpDUQ6Pf7mTNnDvfff3+Xn7/77rv57W9/ywMPPMDKlSvJzs7mvPPOIxhs/6N6zTXXsGnTJt544w1eeukl3n33XW688cb4571eL+eeey5jx45lzZo1/PKXv+RnP/sZDz74YPw2y5cv5/Of/zzXX389n3zyCZdddhmXXXYZGzdu7NexiOFnb0MAgHHFWX26/cgCc+EnrUEzg7VYd9pV8jwDCzp4nLZ4+x2ZE5h6VhtJt0PF3kWW3mDEKwL9ctGdStY5zUlCIDBeEdgmwd1Ua4wF1HPddhx9eK7m2m1MynLRFNG6rArMj7W7U61AoK6jGYaZySuEEMewju2ve5sRmOd2xDc95W9j6iSrrb3FWkO1SpJiRmoPBPatIjA+I1AqPDNa+3zA7jsNVUhFYEYLGTq2Dh1pepoPCO2BwK7GGdgVhZAuCTZCiKElrYHACy64gDvvvJPLL7/8qM8ZhsFvfvMbfvKTn3DppZcye/ZsHn30Uaqrq+OVg1u2bGHJkiX85S9/YcGCBSxatIjf/e53PPnkk1RXVwPw+OOPEw6HefjhhznuuOO4+uqr+Y//+A/uvffe+GPdd999nH/++fzwhz9k+vTp3HHHHRx//PH8/ve/7/OxiOFpX4MfgDFF2X26vVURWNMSjLeNEOlzuMNifTAtCEs7tAcVqeVLYtBIWoOmR8fWoIlmbYi2SEVgyllt6nqbD9jReI+LfIeNxi7a7eTHnp9K2LzADmhma1BpwSOEONY1dUi86C1JSlWVeJBBquVTx+poke1MUiDQ3T4jUEYXZB6rsi+vrxWBsYRVqQjMbNZeQEkPgUCrNeihFkkMz0Rh3UDtsC8UrwiMdR7SdYP3N9ZyOBbIzYtVfnZVEehUFZp7mHcuhBCZKGNnBO7Zs4eamhoWL14c/1h+fj4LFixgxYoVAKxYsYKCggJOOOGE+G0WL16MqqqsXLkyfpvTTjsNp7N9Y+q8885j27ZtNDU1xW/T8XGs21iP05dj6UooFMLr9XZ6E0OLVRE4to8VgWW5buyqQlQ3JGiUAeq8sUDgAOcDWqysP2s4uEidQDh5GdWFsYBFIKwR7Kbvv0i8eHC3j5sj/dFeESgbKanWGJ9X1fdAYLbdxpQsN96ohn7ERmZ+rHWvHttM9WtmRaDk2AghjnXWPNaCXuYDWto7IMg6NlWstU6WK0mtQV3muTeMzm30RWawWrbm9XVGYOx2LbJ+zWjxisAe9hasikBvMBq/jhWZI6IbnTbB4xWBNvO1+pNdDTzw8jb+9ro5BsoKEHYVCHSpKm26LlWBQoghJWMDgTU1NQCUl3eey1ZeXh7/XE1NDWVlZZ0+b7fbKSoq6nSbru6j42N0d5uOn+/tWLpy1113kZ+fH38bPXp0L9+1yDT7+hkItKlKfPF3sDmQtOMSfWNVBJYNNhAYrwiUFh+p5guZi+6sJGRU57nt2GL9siRLPnWSWeXZPiNQNjtTzapQ6U9FIMBYj4sih52GSOfNkrzY/USD7YFAkIpAIYSwWpr3NfEiX5JkUs4KziVjrQNmy3xrDSszzDNPf2cEtrcGledoJutLRWCu2xGfDSrtQTNP2DC6bA1qBfz21ZkdwfbU+ID2lqFB3Tgq4OdSFUKaQZsmgUAhxNCRsYHA4eDHP/4xLS0t8bf9+/en+5BEP1U1mguBscV9aw0K7e1BDzbLwi/dDseGdA+6ItAKBPqkyjPV2ufJJT6jWlEUCmObY9IeNHWS2Rq0MFsyqtOlsZ8b0xaPTWVqjhtfVO80/y8v9tzUYr8vPk3DQJEZgUKIY54V0Cvo4+ut9bosSTKpY61fs5zJqQhUFKV9TqDMlcs41uzGvgYC86xAYJucy0x2uA8VgSBzAjOVYRhEdANbh4kxLfEZgebWeG2z2dLVG4jQGoiQparYY7c/ck6gU1EIGQZtUhEohBhCMjYQWFFRAUBtbW2nj9fW1sY/V1FRQV1dXafPR6NRGhsbO92mq/vo+Bjd3abj53s7lq64XC7y8vI6vYmhoy2sURtrLTmujxWBACNjgcDqZukLn27tFYHuQd2PzAhMH2sjJRmtQaF9E03aZaWOL5zMGYHWZmdEZuakWHtFYN/aYHU02u2k1GmnvkMLJY/ThsOuokTMi+vWqI6KgSanNemi0n9ViIxmBfQK+9gatCCe9CRJMqkQ1XRCUfNvV7JmBEL7OkoqAjNP+4xAaQ06nLRXBPachDEi39wPOiSBwIwSMQw0uqkIjFX+1Ta1n7MD9X4URYl/7sj2oIqiAAYBqQgUQgwhGRsIHD9+PBUVFSxdujT+Ma/Xy8qVK1m4cCEACxcupLm5mTVr1sRvs2zZMnRdZ8GCBfHbvPvuu0Qi7YuqN954g6lTp1JYWBi/TcfHsW5jPU5fjkUMP/sazdaeeW57nzNuASoLzKCTBALTz5oRWJaXmBmBEghMvXggMEkbKUVWIFA2x1ImXhGYxBmBUd3ALzNzUio+I7CfrUHBnLExNdtDm67HW38qikJ+lgMlYv7fp2kYBmhIkCqZQrrOymYfvi5moQghMkNToH8zWeMzAqUiMCU6rj+SlcgG7dVmPqkIzDjSGnR4qveZr6G9VQSW58UqAr0SCMwkAU0npBm41PZAYHtFoBUIbN/DO1Bv7gfGA4GRrtfG/qgEAoUQQ0daA4E+n4+1a9eydu1aAPbs2cPatWvZt28fiqJw8803c+edd/Liiy+yYcMGrr32WiorK7nssssAmD59Oueffz433HADq1at4oMPPuCmm27i6quvprKyEoAvfOELOJ1Orr/+ejZt2sRTTz3Ffffdxy233BI/ju9+97ssWbKEe+65h61bt/Kzn/2M1atXc9NNNwH06VjE8LO3of9tQQFGFpjVgxIITL+6WOCutIc+/n0hrUHTx9pMyU5Ca1BoDxw1yuZYyviTOCPQ7bDhirV2kSrP1LICgUX9bA1qGeV2UuF0cDjcvgmWn+2EWEWgT9MBRWYEJpkvqhPQdSLHyM/53Xff5ZJLLqGyshJFUXj++ec7fd4wDG677TZGjBiBx+Nh8eLF7Nixo9NtGhsbueaaa8jLy6OgoIDrr78en8/X6Tbr16/n1FNPxe12M3r0aO6+++6jjuWZZ55h2rRpuN1uZs2axSuvvJLw71cMD1byUkEfKwKtysFmvwQZUsFa5zhsCk578rZb2isC5bxmGiugl9vXikCPeS4DYY2IVBdlrHpf7zMCAUZIa9CMFNB0QoaBs4uKwDy7jUAoirdDcvDBen/8c3B0RSCAW1VpjkoyhhBi6EhrIHD16tXMmzePefPmAXDLLbcwb948brvtNgBuvfVWvvOd73DjjTdy4okn4vP5WLJkCW53e5u/xx9/nGnTpnH22Wdz4YUXsmjRIh588MH45/Pz83n99dfZs2cP8+fP5/vf/z633XYbN954Y/w2p5xyCk888QQPPvggc+bM4Z///CfPP/88M2fOjN+mL8cihpd9DWYG0Nh+tAWF9orAA00SCEw3q4Jv0BWB0ho0bXxJbg1aFKteapagUcr4khgIhPaNUWmvlFqDqQgEcKgKk7PdhHWIxFpT5mU54q1BfVENFEPaViaZT9MIHkOzTvx+P3PmzOH+++/v8vN33303v/3tb3nggQdYuXIl2dnZnHfeeQSD7Zt711xzDZs2beKNN97gpZde4t133+10neH1ejn33HMZO3Ysa9as4Ze//CU/+9nPOl2vLF++nM9//vNcf/31fPLJJ1x22WVcdtllbNy4MXnfvBiyrNagBZ6+tgaVisBUCoSTu3a1WJ0VZEZg5ulvRWDHgKFX1q8ZSdMNGuJjR/o2I1Bag2aWQGx9q8QCgYZhxIN7+XZbp2pA6KIisItAoEtV8EY1mWEuhBgykrs67cUZZ5zR4wwfRVG4/fbbuf3227u9TVFREU888USPjzN79mzee++9Hm9z5ZVXcuWVVw7qWMTwUtVoVQT2LxAoMwIzg64b8ay93tp39Mb6+npfGF03UDu0kxDJFUh60MjcHJOKwNSxNkeSNvfR46TWG6JZ2r2mlLXBXDzAQCBApctJvl3Fr2kUqHbysp1Q014RaFOUeJBQJIc/qhE6hn7GF1xwARdccEGXnzMMg9/85jf85Cc/4dJLLwXg0Ucfpby8nOeff56rr76aLVu2sGTJEj766CNOOOEEAH73u99x4YUX8qtf/YrKykoef/xxwuEwDz/8ME6nk+OOO461a9dy7733xgOG9913H+effz4//OEPAbjjjjt44403+P3vf88DDzyQgp+EGEqaYpV9fU28sFqDyt/F1PCHYt0skjgfENqDRxIIzDxWRWBeH4P1NlUh12WnNRTFG4xSPMhuNiLxmgJhdAMUpT2RtDtWRWCttAbNKL6ohtphxEBA14nG/ptnt7ErFgj0OG20hTUOHhEI9HYZCFRpjWoENZ1se3I6GAkhRCJl7IxAIdKtKl4R2L/WoCNigUBvMEqr9PlPm6ZAOF450lv7jt4UZTtRFDMTULKpU8sX20zJStaMwGzzAl3aSKaOP5y8GYEA+VYLtDY5p6k02IpAMKsCc2y2eCAqP7u9ItCv6WAYx1SQKh0aoxq6ZDUD5siCmpoaFi9eHP9Yfn4+CxYsYMWKFQCsWLGCgoKCeBAQYPHixaiqysqVK+O3Oe2003A6258b5513Htu2baOpqSl+m46PY93GepyuhEIhvF5vpzdxbGhus1qD9jUQGFvryBo2JazWoFnO5G4Kt7cGlUBgpulvRSC0Bw2lIjAzWZ2BCrOc2G09b6NaMwKlIjCzNEY0XGr7ufPGZvu5VQWXqlLbZJ6vWeMLUYDWtggt/jD5jp4rAsOGEa82FEKITCeBQCG6EQ8EFvWvIjDHZY8P/JbFX/pY8wGLsp04elms98ZhU+Nzr2ROYGq1z5NLzmZKYbxdllx0p4rP2hxJWkVgLBAo5zRlIpoe3/Qa6IxAS6HDFm9NmZ/VPiPQAMKGQQS50E4WzTBojsiGsqWmpgaA8vLyTh8vLy+Pf66mpoaysrJOn7fb7RQVFXW6TVf30fExuruN9fmu3HXXXeTn58ffRo8e3d9vUQxRVmvQwj7OCCyQtU5Ktc+3TnZFoAQCM5WVDJzXxxmB0H4+vZJInJHinYb6kGBsVQTW+0KEo7JuzQQR3cCnabg7dHZq6TAfEKAmVhE4tiyH0ti4n4P1gR5bg9oUhahhzh8UQoihQAKBQnQhoukcjLX27G9FILS3Bz0o7UHTJj4fcJBtQS0yJzA9/Emes1Ioc3NSzqryTFprUJkRmHLW80dV+t4Gqzs5dhsG5kV6XpYDxQBVMyvU2jTdiguKJPBrulRcDiE//vGPaWlpib/t378/3YckUqQpHgjsY0VgtpUgE+5xLIdIjPYZgampCJTWoJklHNUJxhYrA6kIlPVrZrL2AEpye3/dLcp24owlIkt70MwQ0DRCmnFERWD7fEAgPiOwvNDNyBKzGOBAvT8eKOwqEAiAYdAmFYFCiCFCAoFCdOFgUxuabuB2qAMKJFXKnMC0syoCBzsf0CKBwPRob6+UpEBgtgQCU80XMjc4kj33sVnOacpY86oKspzYBjlD1RO7QDcMg/zY81ONZVMHNYOIXGgnjV/TZCOjg4qKCgBqa2s7fby2tjb+uYqKCurq6jp9PhqN0tjY2Ok2Xd1Hx8fo7jbW57vicrnIy8vr9CaGv2BEiwcZ8vtaEegxX0ujuhGvVhPJ40vy2tUirUEzU8fRIP1Z6+bHW4PK+cxE/akIVBSF8nzzdhIIzAwBXSdkGLh6qAisbbYCgR5GlZjFAGZFYKxat5tAoFNVaInI31YhxNAggUAhulDVaLYFHVOUhTqATc2RViuBJgkEpktdq7noTlggMEcCgengj1WPJStoFJ+b45fs21SIau1Z0sk6p/nSGjTl4vMB+7gp3ZMsm4pLMedt5MeqWIyw+TsT0HWiBjLDLkn8UnHZyfjx46moqGDp0qXxj3m9XlauXMnChQsBWLhwIc3NzaxZsyZ+m2XLlqHrOgsWLIjf5t133yUSaX9NeuONN5g6dSqFhYXx23R8HOs21uMIYbESl+yq0ucW2x6nDZfdvOyXmcjJF0jy2tVizVr2SSvJjGJVaGY7bb3OkuvIaiMqrUEzU7wisA+BQIAReWZiuIyKyQxW605Fad/b61gRGAhFaYntB5QXejpVBFoVg96o1mVVvVNVaI5EpeJeCDEkSCBQiC5UNfiBgbUFBakIzATtrUHdCbk/qQhMDyvLOVntlYpiFUe+UFRmOKSAFdiF5LcGbZbWSiljbUxbz6fByLKpuGwKQd0gL3Z/RqyCpU3X0TDQ5Do7KbwRDdvgCjqHHJ/Px9q1a1m7di0Ae/bsYe3atezbtw9FUbj55pu58847efHFF9mwYQPXXnstlZWVXHbZZQBMnz6d888/nxtuuIFVq1bxwQcfcNNNN3H11VdTWVkJwBe+8AWcTifXX389mzZt4qmnnuK+++7jlltuiR/Hd7/7XZYsWcI999zD1q1b+dnPfsbq1au56aabUv0jERnOSnIpyHJ02tDsTWG8Wl7+Niab1dY+y5nc1qC5UhGYkaxAYG4/5gMC5HnM8ymtQTNTvc9c6/Y1ybgiNiewRgKBGcEX1VDpfAHhjbRXBNY1m+cpL8tBlsveqSIwN7Y47m4WoFtVCRqGtNcXQgwJEggUogtVDWZF4NiirAF9fXsgUBZ+6ZK01qA+CQSmUiDJMwLz3A6sol9pJZl8rbG2oC67itOenCWItdnZIpudKdNeETj4QKBTVcm22QjrOtluu/n8jJWpBTQd3QBNMm4TzjAMGiJR3INs7TrUrF69mnnz5jFv3jwAbrnlFubNm8dtt90GwK233sp3vvMdbrzxRk488UR8Ph9LlizB7W5PMnr88ceZNm0aZ599NhdeeCGLFi3iwQcfjH8+Pz+f119/nT179jB//ny+//3vc9ttt3HjjTfGb3PKKafwxBNP8OCDDzJnzhz++c9/8vzzzzNz5swU/STEUGElXhT08/XWSpKRVujJ5w8ld+1qsSoCZUZgZrFag1qBvb5qbw0q69dM1O+KQCsQKK1BM0JTROs0HxCgRWuvCIzPB4zt41UWeVAU8AWjtLVpZMW+tqs5gU5VIaTp0l5fCDEkJHd1KsQQFa8ILBlcReBBqQhMm/aKQJkROJRZFWTJ2kxRVYWCLCeN/jBNgQhleYmpIBVdS3arV4ACqzVom2x2porVai4RFYFgXpDXhSOoikJetpNQxAz8BTQdzTAkEJgEQd3Ar+m4bSrBLrKdh6szzjijx1ZOiqJw++23c/vtt3d7m6KiIp544okeH2f27Nm89957Pd7myiuv5Morr+z5gMUxz6ro628rZitRQwKByWfNYcyWGYHHJKu1Z78rAuOtQeV8ZqL4jMA+7i2U50lFYKaI6AZeTTsq2a1jRWBNkxeA8iLzvDkdNsoK3NQ2BTlQ7yfPbiMQ1mmJalQecf9ORSGsG7RpOoWDn5IghBBJJRWBQnRhsBWBowrNQGCNN4gmLQLS4nCiKwJlRmDKhaM64diGdE4SN1OsLPlGmZuTdL5YRaCVxZ4M+VkyIzDVGmMby4UJCgTm2W3xv535WY5OFYEGEJVAYML5Y5nMblUuDYTIZAOtCCzMlr+NqRJIclt7S65bAoGZyBtvDdq/tW5eLJFNWoNmpoFWBB5qkcTwdAtoGmHdOKoisOOMwCMrAoFO7UHzHebreVcVgYqigKIQkIpAIcQQIFf7QhxB1w32NcYCgcUDCwSW5rhw2BQ03aBW2kGkRdIqAqU1aMpYbUEBspK4mVIUn5sjgcBks9pXJTNL3tocbW6LyND2FIlXBCagNSiYcwKJJe3mZTtRwuaFtc+qCEzIo4iO/JpG1AD7sdUZVIghJz4j0NO/soMCqQhMGV+s+0FWkisCrYqz1mBU1jsZZKAzAqU1aOaKano86U1mBA49AV0nqBs4j6gItIJ6ZkVgLBBY2B4IHFli7gUeqPeTb+8+EAigYuDv5nNCCJFJJBAoxBFqW4OEojp2VWFkh4yg/lBVJb74q5b2oCkXCEfj2bGJavVoLfqbAxFCsshLCescOu0qDlvy/lxZm2ONsjmWdPHWoEmsCLQ2R8NRnWBEMjNTocGf2IpAj6riUBTCuk5+dntFoF/T0JEZgcngi2oo8nMVIuM1DfD1tlCq5VOmfb51cisCrdagmm7IeieDxGcE9rciMHZ7q7WoyByN/jCGAarS9zb41l5QXWtIOkSlWUDTUQBVaQ8EGoZxREWgGbCtKOymIjAWCPR2sw/kUlWaI7JHJITIfBIIFOIIVlvQkYUe7IMIPlTmy5zAdKnzmlV7HoeNbGdiLsLzPQ4cNnPx2OCTgFEqpGKeHECRtMtKGas1aG4Sz2mW0xZ/rkrlQ2pYP2fruTRYWTYVl6oS0g3yspwo8UCgNSMwIQ8jOmiIRHElMeFCCJEYzbFqoQKZEZixUjUjMMtpw9rXbg3JGjZTeNsGVhGYJxWBGcvqCFSU7cKm9q11QmmOC1WBqG7QIB2F0soX1VDofPHg1/R4hxGnDi2xJJuuKwID5MbWyN1VBDpVhVZNIypBXyFEhpMrfiGOUNXgB2Bscfag7seqJqxulnYQqWYt1svyXGbP9gRQFEXmBKaYP0UZ1dbmmMwITD6rXVZ2EgOBiqKQ77HavcpmSio0+c2fc2GCWoO6VQWPqhDSDfKzHPFAoC82M1RmBCZWVDezot193NwSQqSP1ca8v6+37a1B5e9isvljHS2S2dYezPWOlSznC8qcwExhVQT2d0Zge2tQafWaaepjScAlOX1/3bXbVMpyrTmBsh+UTk0Rrdv5gFmqSmPs/OR6HGR3eN6OKMpCUcy5r85YFmJ3gUB3LIGxTeYECiEynAQChTiCVRE4tmhg8wEtIwutQKBUBKaaVRFY2sdh3n1VkiuBwFSyNlKSnVFttdeSLPnkszaqktkaFNorJZrb5JymghVEL85OzGuuoigUOOyEdJ38bGe8NagvqgGKtAZNML+mEdQN3KpcFgiR6axAXmG/KwLN27fIWifpArH1a7I7WkB7hwWrnb5IP2tGYL9bg1qt7TWdUFSCCZnEuvbv63xAS3xOoFcCgekS0Q1ataOT3drnA6rUxucDdh4p47Sr8QrBSMB8Xrd00/7TqSqEDJ02TZ67QojMJlf8QhwhHggsHlwgsLJAAoHpcrjVXGyX5SU2EBivCJT2HikRDwQmeSPF2hxrkorApLNagyZ7c8yaE9gilQ9J1xbWaItdFBcmqDUoQL7DRlg3yM92dGoNqhs60nUnsfyaTkg3pCJQiCHASlqyKt/7ykqQkYrA5LNag2YlOZEN2hOrpCIwc1htWq3AXl9lO23xtpPSHjSz1PsGlmRckRcLBEpFYNoENI2QbnRbEZhnt1HTbAUCPUd9/ahYe9C21nCnrzuSTVHQDKQiUAiR8SQQKMQRqhoT0xrUCgTKjMDUq4tl7VntOBKlVCoCUyoVbSSh49wcuehONl+K5j62VwTKOU02a1PaYVMSel49qooC5GW1VwTqQEg3pDVogvk1HcMwEtZKWwiRPFbL6/4mXhTIjMCUMAyjQyJbcluDQvt6qlUqAjNG+4zA/q2JFEWJVxG2yPo1owy2IlBag6ZPQDeT3ZzdVgTaqG009+squggEjoztCbY0BTt9XZcMCEhFoBAiw0kgUIgODMNIWEXgyAJz4SeBwNQb6GK9NxIITK1A2GqtlOQZgdIaNGV8KWqXJTMCU8dqC1qY5UxoICnLpmJTFbKzHCgGELXag+poSCAwkVqiGnapBhQi4+m6MeAZgdbtW4NRorJRmTRhTScaK1tPdiIbQI7bDAhLRWDmaJ8R2P8uCVYVoTco69dMYlUElvSzInCE1Rq0RfaD0iWg6RgYqEdco3hj1xX5dhu1zWaQr6eKwMbD5jls1fRuRxQ4VYXmblqHCiFEppBAoBAdNAUi8b7+YwY5I3BEvrmQaA1GZTGfYnUSCBwWrKBRslsrWZtjjdIaNOn8KQoEyozA1LEC6EXZ/duU7k2WquJSVZwuGwrEqwKDevsmqxg8wzBoCEdwSSBQiIzXGorGWyMX9HNGYL7HgbUPKtXyyRMItW8CZzmSXxEoMwIzj7WX0N+KQIC8WPDQqioUmcG69i/J7d9aV2YEpp8vqtHVCrdTRaA1I7Dg6G5So0rNisBDtb74/XTXHtStqnijUQzpXCKEyGASCBSig6oGsy1oRZ4b9yAv3rJd9vhF+qFmWfylUtICgbEswHqZEZgSqQoaWTMCW4NRIpIln1RWxnrOADZH+kNmBKZOx4rARPLYVNyKQlSBHE/7nMCgrhOWQGDCtOkGAd3AE5ud8tCr23nxnb0y31iIDGRVA2Y5bbjs/btOsalKPMjQLB0QksYKyLnsKnZb8rdaciQQmFEMw4gHAvMGVBEorUEzUfuMwP6NHZEZgenXFNFwq0e/FlvBvGxFocln/k2sKDq6IrCi0IOqQDCskRO7n+7agzpVhYBuEJTrFCFEBpNAoBAdWG1BxwyyLahlZGxOoGyopdbh+IzAJFUESiAwJfzxGYHJzajulCUvgaOkao3PzUlyIDBbWoOmSpM/ORWBqqKQ57AR0nXyshwoEfOiWgKBieXXNIK6jtum4g9GWLGpjvfX1qDJz1iIjGPNMh5o4oWV+CQzkZMnEE7NLGSLVXUm3WcyQyiqE44lFQ6kIjBfWoNmpIFWBFodog61BKVKLA0iukGrpnXZ9cIK5hnW/Hq3newugvcOuxqfHWiFgburCHSpCmFdp02XxGIhROaSQKAQHViBwHEJCgRWxgKBByQQmDJRTafBL61BhwN/ilqD2m1q/MJbsuSTK2WtQT3SGjRVGq2N6ez+Z773ptBuI6wb5Gc74q1B2zSDsCEX2Ini13SihoFdUVi3uwndgPIiD6MH2R5dCJF4Vitma83SXwWxAGKTtEJPmnhb+yQnsVmsDgsyIzAzWAE8RYHsAVy/tLcGlUBgpohoejx5orSfMwLL8szbh6K6JCemQUDTCOkGrh4qAiMB87Wzq/mAlpElZntQe9QM5nZXEehQFCKGQUA6DAkhMpgEAoXooKrRbA06tjg7IfcnFYGp1+gPYxigKlCcndhAoDUgPBDW4gENkTz+cGqCRiBzAlPF2iAbSJZ0f8RnBMpFd9LFKwIT3BoUINtuwzAgL9sZbw3aputEJKk6YXxRLX4x8PHOBgBmTChM3wEJIbrVMsjEi0L525h0gdjadSBBoIGQ1qCZxWoLmuOyow5g9m6e1dpeAoEZoyHWNtKmKv2uxnY7bPGOGTInMPUCuh4LBB79XLQCgW2t5vntKRA4qsRMjrOqB1siXQcCFUUBA9okECiEyGASCBSiA6sicGzCKgLNBgISCEwdaz5gSY4L2wAuwHqS7bKT7TQzfKUqMLkMw2BTtRdoH7SeTNIuKzV8qWoN6jEvumUjJfkaYxUqhQluDQrgUVUUBfKy2isCA5pOWFruJExDOIpLVYlqOut3NwISCBQiU1kVgQUDbg3q7HQ/IvHa29qntjWoVARmhsHMB4QOrUHb5HxmCms+YHG2c0DBXZkTmD4BTcfAQFU6nzfdMOKBwNZm8/yWF3a/32BVBIb95nVldxWBADZFwdfD54UQIt0kEChEB/FAYFFiKgIrpSIw5awAXaLbglpkTmBqbDnUSlVDAJddZdGkkqQ/nmyOJV8oqhGOmgGcpLcGlaqHlEnWjECALJuKW1XJ8jjiFYF+TUczDHSZtTJoEd3Aq2m4VYWt+1sIhDTyshyMrshJ96EJIbrQPiNwcK1BmyVJJmna29qnqDWoy/xdaJWKwIxgtfQcaOeLPJn5mHEOd0gyHogRsYTWQxIITDlfVKOr0K1f07FSChsbzH26vlQEBrzmNU93MwIBnKpCkwQChRAZTAKBQsT4QtF4xteYBFUEtrcGlYVfqtS1mj/rsmQHAqUiMKmWbDwEwOlTSlOSVW1VM0kgMHmsLHkgXlmbLPmxTdK2iEawm/YtIjGsdrr9bZfUFx5VxaUqZHns7RWBunnxrkkccND8mkZQM3Crarwt6JyJRUdlTgshMoM1x3igr7ftSTKy1kmWlLcGlYrAjDLYikCrNagEAjOHlfw70CTj8lggUFqDpl5TRMPdxXxAq6Iv26ZyuMkMBFb0EAisKPJgUxWisUrdnioCXaqCX9OI6HKhIoTITBIIFCJmX6wasDDLEW/LMVhWILDGGyQqvcJTos6boopACQQm1ZJNNQCcP7MiJY8Xbw0qMwKTxsqS9zhs2G3JXX7kuuzx1sDSHjS5GpNYEWhXFXJtNjwdKgIDUR3NgKhUBA6aX9MJ6TpOBT7eYQYC504qSvNRCSG6Y1UEDrw1qLXWkb+LyeIPp7Y1qMwIzCytwUFWBMqMwIwz6IrAeGtQ6RCVSlHdoFXTepwPmGtTafL1PiPQblOpKPSghM1rkZ4DgSph3aBNxhgIITKUBAKFiNnX6AdgTHFi2oKCuWB02BQ03aBWAkcpYWXtleUmZ65caY4EApNt12Ef22t9OGwKZ08vT8ljtlcEyoV3slhZ0jkD3BzpD0VR4gkd0h40eQzDiFfRJiMQCFDgsOH02Npbg+o6urQGTQh/LEHpQH2Aem8Ih11lxtiC9B6UEKJbViVfwQATFgukDXrS+eOzkFPTGjQ+I1ACgRkhXhE4wOeoVUkoMwIzR/0gKwIrpDVoWgR0nZBu4OqhItATaxya7baT28tzdmRJVjwQ2Ftr0KCu0yZFAEKIDCWBQCFi9sYqAsclqC0ogKoqjMiXOYGpJBWBQ9+SjWY14CkTSxJWndub+IxAqQhMmi2HvAAUJylgdKQCj7RASzZfKEok1qMzGa1BAXLsNnKynPHWoP6ohi4VgQnREoliV5V4W9CZ4wpwOVKzeS2E6D8rsaUwe2BrI+t1WhJkkmf9gRYAyvOSk5B4pHhFoLQGzQjeQVYE5ntkRmCmqY9VjJXkDGydawUCayQQmFIBzQoEdl8R6Ihdw/RUDWgZVZINsYrvnioCbYqCYSAVgUKIjCWBQCFiqmKBwLFFiQsEAlQWmIs/CQSmRntFYJIDgT4JBCaLFQhMVVtQ6BAIlKBR0jy+sgqAi2aNSMnjWXMCm6W9UtJY7eU8DhueJM19zLKpZHVoDerTdKKGjkx+HBzDMGiMRPGoKh/vbATg+EnFaT4qIURPrDXKQFuDWjMCZa2THPW+EO/vrAfgwhStdayAU1jTZSZyBrAqAgfbGtTbFkGXGWMZ4XCrGcAbaJLxCJkRmBYBTcfA6HLudTyQF6vwKy/oPXFjVEkWSsi8fVA3CPUS6PP3ECwUQoh0kkCgEDFVDWZr0LEJbA0KUBmbE3hQAoEpURdbrJflSUXgULS/McCGgy2oCpw7IzVtQaHD3BzJkk+KzdVePt7XjF1V+NxJo1PymFZFYIuc06RpTHJbUACPqpLjsOGJXcjrmFm2mlQEDkpA1/HrBsFAmN2HWgGYN1ECgUJksnhF4EBnBGa3VwQa8hqacC+vP4SmG8wZlc/4ksReT3Yn29kecJL2oOnXXhE4uNagugH+sJzPTGBVBJYOcEZgRaw7VGswKs/RFPJFNY4OAZqsikAt1oK3og8VgSNLskEzzDd6bg/qsik9Vg0KIUQ6SSBQiJh4RWACW4MCjCqQ1qCpYhhGPEBXmpOsGYHm/UogMDle22RWA540vojiAV5wDURRtlQEJtNjsWrA846rSNr8ziNZFRPNbXJOk8VqpTvQNnV9kWVTcdkUM0s+Nm+jNWpIa9BBMlsm6WzZ0wzAxBG5FAyw7ZUQIvnCUT2+iWwlL/WX9XVhTScQlk3KRHt+7UEALp07MmWPqaqKtAfNIPEZgQMMBLodNpx2c4vOK+czI8T3FgZYEZjjspMbe45Ke9DUaYpEcXcxHxDaKwJDPjNw35fWoOWFbuyq0qf2oE5FpTmiScKNECIjSSBQCCAU1ahuMQN1YxIcCIxXBDZJIDDZWkNRgrH2ccmeEVjvC0nLliSItwU9LnVtQaE9aNTSFiEqw70TqjUY4flPzM2xa04ek7LHzY/PCJSKwGRptAKBSZoPCOBUVbJtNrI9DoiYr7ltumYl5IoB8ms6mm6wdlesLehkqQYUIpNZSS2KMvBqI0+HIIMkPiVWVYOfT/Y1oypw8ZzUtAW1xAOBUm2Udt62wc0IhPYgonS0SL9QVKMldk5LBpGgWh5rD1or7UFTIqobeDWty/mA0F7N528xg7x9CQTabSojijwosXaiLT20YnapCiHDoE32ioQQGUgCgUIAB5raMAzIctoG3PahO5XxikBZ+CVbnddczOW67EmbV1Ucq5iI6obMHkuwOm+QNfuaADh/Zmo3Uay5OYZB/IJPJMbznxwkENaYWJrNwgmpCzYUxisC5Xwmy7oDzQBJr/IstNs6zQkMaNIadLC8EY1wVGPTXvM1V+YDCpHZrKBAvseBrZvNzd4oihKvCpQkmcR6cW01AJ+aVJKyzgeWnFjQqVUqyNJusDMCAfI95tdabUZF+jTE2oI6bEo8wXAgrDmBh6QiMCUCuk5YN3D1UhHo85rnty+tQQFGlWS3BwJ7ag2qqoR0nYAkFwshMpAEAoUA9sXago4pykLpYqDwYFRKa9CUibfuSNJ8QACHTY23kZT2oIn12qYaDAPmjSmgIj+1mygOmxq/aJc5gYljGAaPfbgPgGsWjE3462tPrOCuZFQnR4MvxNOr9wPwmeOT2wYtx24jO8sO8UCgIRWBg9QYibJvfysRzaA0382oksR2QxBCJFbTIOcDWuJJMvK3MWEMw0hLW1CLVARmjtbQ4GYEAmYrdNqrC0X61PvMa/3ibBfqABMwACryzOvamhbZD0qFgKYT1I1eKwKVsEaWy0aOp2+B+5ElWdCHQKBDVYgaBm26BAKFEJlHAoFCAHsb/ACMK078YPfKAnPh1xqKSmZfktW1mll2ia7qPJJ1/xIITKwlm9LTFtQicwITb3VVE9tqW3E7VK6YPyqlj20FAmVGYHI8snwvwYjOrJH5nDIxudVkWTaVnKyOFYGazAgchLCu49U0tu5prwZMZZBeCNF/1tqkYIDzAS3W18taJ3E2VXvZddiPy65y3nHlKX98K5HNF5LrzHSzKgLz+xhY6Eq8NagEAtPOutYvyR1cAkaFVASmlFmJZ6B2sbbVDIPWqHk9oYR1ygs9fV4DmxWBZgDQ20Mg0NImFYFCiAwkgUAhgKpYReDYBM8HBMhy2uMBBqkKTC5rsV6Wl9xqMmtO4GGfLOYTpckf5sPd5qyqC1LcFtRizQls8svmWKI8/mEVAJ+eUzmoljoDITMCk8cfivLICvPcfuP0iUkPImXZVPKznNIaNEH8mk4gorMpFgicL/MBhch4zYHEzGQt8FgVgbLWSZQXYtWAi6eXD6oSbKDiFYHSGjStDMPo0Bp04L8H1vrVK+cz7ayKwMEmGVfIjMCU8vUQpPNpOvEriIjep/mAlpElWfHWoM29BAJtitKnYKEQQqSaBAKFwBzwDjAmCYFAaK8KPNgkgcBkigcCc5NbEViSI61BE+2NzbVousGMEXlJex72pkiy5BOqwRfilQ1mlecXTx6b8scvkPZnSfPkR/tpaYswrjiL82cmv4LXo6oUZDvjrUHbdJ2ILoHAgfJrOrtrvLQGImS57EwZlZfuQ8pYP/vZz1AUpdPbtGnT4p8PBoN8+9vfpri4mJycHK644gpqa2s73ce+ffu46KKLyMrKoqysjB/+8IdEo503eN9++22OP/54XC4XkyZN4m9/+1sqvj0xhFitQQdbEViYba115G9jImi6wYvrzPmAn55bmZZjsAKBrdIaNK0CYQ0ttjYZzIzAPGtGoFQEpl28InCQgUBrRqCVfC6SqykSxd3NfEBvxAzOOXQDxYDygr4HAssLPdhi1YT1vTw/XYrSY/tQIYRIFwkECgFUNZqLsmS0BgWozJc5gakQnxGY5EBgvCJQAoEJE28LmoKgQnesLHvZHEuMZ9YcIKzpzB6Vz+xRBSl//AKPtFZKhnBU56H3dgNw42kTsQ1iZkpfuVWFkpz2isA2XSciFYED5td0tuw2qwHnTizEbpPLgZ4cd9xxHDp0KP72/vvvxz/3ve99j3//+98888wzvPPOO1RXV/OZz3wm/nlN07jooosIh8MsX76cRx55hL/97W/cdttt8dvs2bOHiy66iDPPPJO1a9dy880387WvfY3XXnstpd+nyGxWUotV0TdQ8e4HkvSUECv3NFDrDZHntnPG1NK0HEOOWyoCM4FVDWhTFTwO24Dvx2oNKiNF0q/eZ75ODnZvYdbIAhw2hR11Pj7e15SIQxPdiOoGrZrW7XxAKzinRszriPLCvneSsqkKJS7z+dkY7vn11mVT8WsaYZkTKITIMHLlL455mm5woNEM0I0pSlZFoBkIPNgs7SCSqS5FFYESCEys1mCE93fUA3BBOgOB2dIaNFF03eCJlfsA+OKC1FcDQnvVhC8UJRyVi7BEeXFdNdUtQUpyXHzm+JEpeUxFURiV74lXBAY0nYCmY0gwcECaI1G27m6fDyh6ZrfbqaioiL+VlJQA0NLSwkMPPcS9997LWWedxfz58/nrX//K8uXL+fDDDwF4/fXX2bx5M4899hhz587lggsu4I477uD+++8nHDb/1jzwwAOMHz+ee+65h+nTp3PTTTfx2c9+ll//+tdp+55F5mlvDTrIisAsaZudSC98YlYDXjR7BC77wIM/g2G1oWyVQGBatcYCd3lu+6BapudLIlvGSFRFYGmui0vnmmvmB9/ZPejjEt0L6Doh3cDVXUVgLBBohMz3Ff1oDQowItv8XfBqPVf7uRSFkGbInEAhRMaRQKA45h1qaSOs6ThsSjxgl2gjC6QiMBXqWs1Aa8oqAn0SCEyEZVvrCGs6E0qzmVSWk7bjsGZ5Spb84L274zD7GgPkue1cMic9rbJy3Q6sfRjZTEkMXTf40zu7APjqonG4B5Hx3l+j893xisCgZnAgFOZgSM5rf+mGwZbaVg43BbGpCrMnFHX6/MfeAHva5G9bRzt27KCyspIJEyZwzTXXsG+fmeSwZs0aIpEIixcvjt922rRpjBkzhhUrVgCwYsUKZs2aRXl5efw25513Hl6vl02bNsVv0/E+rNtY99GdUCiE1+vt9CaGL2ttUpAtFYGZIhjReGXjIQA+PSc1iTFdybVmBEpr0LSyKvgGOycyz5oR2CbnM92sa/1E7C3ceNoEAF7bXMOeev+g7090LaBZgcCeKwKjAfP51Z8ZgQBjYvt6QYweExKdqkLYMGiTUQZCiAyT0YHATJrLcf/99zNu3DjcbjcLFixg1apVSfmeRerti/VqH12YlbQWZ5USCEyJ9hmBfW/xMBClOe5OjycGZ8lGsy3oBTMrBpVBO1hWBVmjX4ILg/XYh+ZG+RXzR+FxpidD3qYq8fZKLW2y4ZkIy7bWsaPOR67LnvK5j0VuBzbNvJj2RTVswGZfG0HJtO2XNk3n410NAEwfnU+Wq32OUWtU40/7D/Obqjreb2pN1yFmlAULFvC3v/2NJUuW8Mc//pE9e/Zw6qmn0traSk1NDU6nk4KCgk5fU15eTk2N+XetpqamUxDQ+rz1uZ5u4/V6aWvrft141113kZ+fH38bPXr0YL9dkcGstuWDrwiUNuiJ8va2w7QGo4zId7NgfFHvX5AkVmtQqQhML2/s5z+Y+YAgrUEzSX2CKgIBppTncta0MgwD/vyeVAUmS0DT0Q0DtZs9BasiUAlreJw28vr5N3VCrIOYoSj4e7gGURUFwzAIyHWKECLDZHQgEDJjLsdTTz3FLbfcwk9/+lM+/vhj5syZw3nnnUddXV1qfggiqfbGAoFjipPTFhRgZKEEApMtHNXjmxoyI3DoaAtrvL3tMAAXzByR1mMpim2ONUuW/KAcbG5j2VYzKeeaNLUFtRRIC7SEeiBWDfiFk8fEN6pSJdtuIzs2y84X1Sh3OagNRdgRkJbb/eHXdNbvagTg+Mmd24I+Wt1Aq6ZT4XKwID991dmZ5IILLuDKK69k9uzZnHfeebzyyis0Nzfz9NNPp/vQ+PGPf0xLS0v8bf/+/ek+JJFE7a1BB1cR2N4aVNY6g/XC2oMAfHpOJWoK5uV2JydeEShrnXRqTVAgMD9eESjnM90SWREI7VWB/1xzgHrpLJQUvqgGPbwcW4FAwjrlhZ5+JyGPK82JjypojvSSfKFAoJcWokIIkWoZHwjMhLkc9957LzfccAPXXXcdM2bM4IEHHiArK4uHH3449T8QkXBVjWZrhnHF2Ul7jMoCs4KsxhskIllBSWG1BXXYlEFnS/fGuhhoCkRk9tggvbP9MG0RjVGFHo6rzEvrsVjtshplc2xQnly1D92AhROK09rqFaDAI4HARPlobyOrq5pw2lSu/9T4lD9+lk0lz2lurgUMAxUodtrZ7g9yOCznt6+qW4NUVZvVfvM6zAfc2NrGW43mxz9XXogjjZvamaygoIApU6awc+dOKioqCIfDNDc3d7pNbW0tFRXmvNuKioqjupVY/+/tNnl5eXg83bescrlc5OXldXoTw5eV7GYFCQYq3hpU5iEPijcYYelWMyn403PT0wLdYlUESmvQ9GqfETjY1qDm+ZRAYHoFI1o8uFuagIpAgAXji5gzuoBwVOfR5XsTcp+is6ZIFHc38wGhvTWoEtG7bQvqi2rUdJNYUVbQPqqgqpckf5eq0hSV12UhRGbJ+EBguudyhMNh1qxZ0+k2qqqyePFimd0xTFitQccUJa8isCTbhdOmohtQ65XqhWR4/hMzK3diaU7S20sWeBzYY5ukDX7J5huMJbHZKucfl962oNA+I1CCRgMX0XSe/MisSkl168iu5FtVnrKZMmgPvG1WA14xfyRlecltv9wVj6pSGAsE6kBQN8iz2wjqOpt9bURlBkefvL2tDsOAMaXZlOab5zGiGzx4wKzMPrsolwlZya2qH8p8Ph+7du1ixIgRzJ8/H4fDwdKlS+Of37ZtG/v27WPhwoUALFy4kA0bNnTqIvLGG2+Ql5fHjBkz4rfpeB/Wbaz7EMIwDFqs1qCDnBFoJct5g1E0ed0csCUbawhHdSaX5TBjRHqD8PEZgdIaNK2smX6DnhHobn+OivSxKvacNjUenB0sRVH4eqwq8NEPqwiE5RwnUlQ3aNW0bucDQofWoCGdisKur2cOh6NEDYO2LhL4VVXBFfvw3l4DgQreiNmqVAghMkVGBwIzYS5HfX09mqZ1eRvrProjszuGBqs16LiS5AUCVVVhRKwqsLpZAoGJ5g1G+PN7ewD45hkTk/54qqrEZwXUt0pG9UCFohpLt5iboxfMqkjz0XRul6XL5tiAvL6plsOtIUpzXZx7XHnvX5Bk0gItMbbVtLJ0ax2KAjecOiEtx6AqCqXZLrDmBMZa7VS6nOwLhtnTJkkZffH+tnqgczXgc3VNVIciFNhtXD2iMF2HlpF+8IMf8M4777B3716WL1/O5Zdfjs1m4/Of/zz5+flcf/313HLLLbz11lusWbOG6667joULF3LyyScDcO655zJjxgy+9KUvsW7dOl577TV+8pOf8O1vfxuXy1xHfOMb32D37t3ceuutbN26lT/84Q88/fTTfO9730vnty4ySCCsEY5tSA6260XHisIWSZIZMKst6GXzRqY9ka08lpyzrzHAzjpfWo/lWGZVBCaqNagvFCUqnYTSpt5nXjuU5DgT+hw/77gKxhZn0RyI8PRH0tI7kdp0nZBu9KkikIjWZUWgP6qRZVMpdzqo7yZQmxO7/+rWnvf1XIpCqJuAohBCpEtGBwIzeS5HX8jsjsxnGAb7GszWoGOKktcaFKAyX+YEJstf399LS1uESWU5XDw7Ne154nMCfRLYHajluxpoDUUpy3Uxb3T6N5+tdlm6YQaXRf899mEVAFefOBqHLf1LDKs1qGx2Ds6f3jWrAc8/roIJpelr91qe44rP5WiNtWV2qAp5Nhub/W209Dar4xjXGo6wYU/n+YAHg2H+VdsEwHUjS8i22dJ2fJnowIEDfP7zn2fq1KlcddVVFBcX8+GHH1JaWgrAr3/9ay6++GKuuOIKTjvtNCoqKvjXv/4V/3qbzcZLL72EzWZj4cKFfPGLX+Taa6/l9ttvj99m/PjxvPzyy7zxxhvMmTOHe+65h7/85S+cd955Kf9+RWayZilnO214HIN7jtptajxQ0SRJMgNS5w2yfFcDYM4HTLfRRVmcM6Mc3YBfvrY13YdzzLLaSOYNMhDYMZDYKlWBaXO4NbHzAS02VeFri8wW+395f48EexMooOkEdb3HisCWDhWBXQUC6yNRRrmdTMl2Y2B2zTiS1aGkrpfrS5dNJaTrBHQ5x0KIzJGYGvcU6TiX45xzzonP5ehYFXjkXI5Vq1Z1uo/+zuWw2WzYbLYub2PdR3dcLlc82/dYFdF0wlGdbFdm/qrV+8L4wxqKAqOLup/DkggjYwuNgxIITKiWtgh/eX83AN89ezK2FM01igcCW6UKZaCWbDCrqs87rgI1A+ZROe0qOS47vlCURn84HhgUfbOzzseK3Q2oCnz+pDHpPhygQ2tQafc6YAeb23hxbTUA3zg9+RXXPSnPc6F42zDctnhFIECRw8beYJit/iAn5mejprk6I1O9s7OBUEQnP9vJ+IocDMNsCRo1YF5uFqcUZBOR9kWdPPnkkz1+3u12c//993P//fd3e5uxY8fyyiuv9Hg/Z5xxBp988smAjlEMb3XeIP/9/AYAvvKpcQmpTCnMctIajEq1/AC9uK4aw4D5YwsZncTREv1x63lTWbqlltc21bKmqon5Y9OfYHesic8IHOQcT7tNJdtpwx/W8AYjg24HLAbGag1akqD5gB19dv5ofv3mDg40tfHKxpqMSCgYDgKajmHQ7XWAZhj4YoFXJaJTcUQgMKTrqIrCWI+LEoedMqedhkiUClfn53Spx8GOSIimXlq72hUFTZeKQCFEZkl/un4/pGMuh9PpZP78+Z1uo+s6S5culdkdvTAMgy89tJKT71rKjtrWdB9Ol/Y1mtWAlfkeXPbkZsFXFkggMBkeen8PrcEoU8pzuGjWiJQ9rjU0XAKBAxPVdF7fbAYCL5iZ/raglsJsc6HfJIGjfnt8pVkNeNa08vjrXbpZFYEyI3Dg/vLebqK6wSkTi5kzuiCtx1Ke645XBPo6XFQrikKF08GuQIgDQdnY7s7SLWZS2/GTilAVhbcbW9nkC+JUFL42qiTt7e3E0GdIIDmhDMPgh/9cT3MgwsyReXz37CkJuV+rvWiTX/42DsSL68zkmMvmZs7m/eTyXK46wRxD8n+vbpHnYhpYM/0G2xoU2oOJ0tEifZJVEQjgcdq4dqE5S/3Bd3fJ8zVBfJoGPSxlrfmAGAZuFPKOaLXdEI4ywumgzGnHripMzHLTpuloR5yfkbF9IJ+u9z5ORIE2GTkihMggGR0IzJS5HLfccgt//vOfeeSRR9iyZQvf/OY38fv9XHfddWn5uQwVa6qa+HB3I63BKLc+uz4jB9LvrTfnA45JQTbnyPiMQAkEJkpLIMJf3zdnA3737CkprSqTisDBWbW3kaZAhMIsByeNL0r34cQVxirImvwSTOiPtrDGs2sOAPDFkzOjGhCgQGYEDkqTP8yTq8y25umuBgSozHWhWIHAqNbpcx6bilNV2ORrIyCZt0cxDIP3Yu0F508uwRvVeLTabG13VUUh5a7BVTAIsa2mlSv+uJxtNYNP/tN0gw93N9ByjCflPPZhFe9sP4zLrvLrq+bitCfm0t3qeGBVvIi+233Yx/oDLdhUhQtTmIDYFzcvnoLLrvLR3qb4DG6ROu0zAgf/99SaE+htk9ag6ZLMikCAaxeOw+1Q2XjQy4pYq2ExOE2RaI/zAeOBwIhORYG7UwKcZhiEDYPxWa54ReEIl4Mih53mSOdrjpG55r6e5lCpa+55TIxdUfDK6AIhRAbJ6EBgpszl+NznPsevfvUrbrvtNubOncvatWtZsmQJ5eXlqfthDEGPrKiK//uTfc08snxv+g6mG1WNZiBwXEnyA4FWhYwEAhPnL+/vpjUUZVpFbsqrytpnBMomykAs2WhWA54zoxx7BsySs1iBwDoJ8PbLv9dV4w1GGVOUxWmTS9N9OHFWIFAyqgfm0RVVtEU0jqvM49TJJek+HEbkutsDgV0E+8qcdurDUbb75e/skTZVe6n3hnDYVWaMLeDRgw20ajpj3U4uLitI9+GJYeDOlzfz8b5mLvnd+/zh7Z0Dnnu0dn8zl93/AVc/+CGLfrGMe9/Yfky+hu867ON/X9kCwH9eMI3J5bkJu++JsVmvv3p9O3vq/Qm732PB87FW2adNLqE4SQGCgarId/PV2OyxXyzZKrPHUqw1kRWBbqtDiSSypYNhGGyPdbQqyUlOa9aibGe8iveBd3cn5TGOJVHdwBvV+jYfMHz0fMDGSJRih50RHRLj3DaVCR4nXk3rVLVZ4Ig9x50qB3r5G+pSFZqPSF4UQoh0ypzd1y48+eSTVFdXEwqFOHDgAE8++SQTJ7ZnpFtzORobG/H7/fzrX/86am6fNZcjEAhw+PBhfvWrX2G3d16cWXM5QqEQu3bt4itf+cpRx3LTTTdRVVVFKBRi5cqVLFiwICnf83BR5w3y6oZDQHt1yC9f28a+hkA6D+so+xrMP9xjirKT/ljx1qBNbcOu/YOuGwTC5ly1g81t7KzzsbOuNanfZ5M/zMOxasCbF09O+Yw5qQgcOF034oHAC2ZmVjb1tApzo+23S3fIue0jXTd4LNYW9AsLxmTEvEdLvse8eD/Q1HZMbiQPRiAc5W/LzdfYb5w+MSPaRlbktbcG9UaOvqhWFYUSp53t/hC1oaF1vg3DIKobBDUdv6bRGtVojkTxRrVB/S2N6gaHQmEe/cSs7Jw+roBtbUHebmpFAb4+uhR7BpxbMfT96so5nDWtjLCmc/eSbXz2gRXsOuzr89c3+sP8+F/rufwPH7DhYAuqAq2hKL9duoNFv1jGr4+hgGBE0/neU2sJRnROnVzClxeOS+j9f/fsyUyryKXeF+KLf1kpSYp9ZBgGL649CMBl80am+Wi69o3TJ1KQ5WBHnY9/fXww3YdzTLECgXkJqAgcX2LuTfz5vd1EJKCbcg9/sJcPdzdiUxVOnlictMf52qIJqAq8u/0wWw55k/Y4x4I2XSekG32rCDwiEGgYBr6ozsQsN84jvn6kx0W2zUZrh+dhfmykkOFUOVjf8/6mS1UJ6DohXZ7HQojMMPh0JSG68I9V+4nqBvPHFnL7p2eyo9bHyj2N/Pi59Tx2/YKM2FAE2BsLTI4rTkVrUHOxYQ7+jsZbfgwlWw55ueOlzRxqCRKMaLRFNNrCGqFo1wubb54xkR+dPy0px/Ln93bjD2vMGJHHuTNSP2NOAoED98n+ZupaQ+S67JwyKXkXVwNx01mTeHNLLbsO+/n2Ex/z+NcW4MigisVM09IW4Zan1rL+QAtOm8qV80el+5A6mT4il5IcF/W+ENf9dRV/v34B2S5Z+vTF0x/tpykQYUxRVsbM8cz3OFCjBhrQEOw6IJBrt9Ec1djka6PQYTvqgj7dAppOXThCXShCyNCJ6BDRdaIG6BjogGaYmxKaATbFzDyudNopcjr69D3phkFTRKM2FKYqGGZbrY9XPzGrWOZPKubBA/UAnFuSx5Rsd7K/ZXGMKM9z89CXT+CZNQe449+bWbu/mQvve49bz5/GdaeM6zZJRNcNnvxoP3e/tpXmWCvQK44fxY8umMrqvU3c9+YOttW2ct/SHfz1gz1cv2gC1y0al5DN9kz1u6U7WH+ghXyPg19+dk7CE2zysxz8/foFfO5PK9hd7+eLf1nJ099YmLQWeMPFugMt7G0I4HHYWDw9MzsD5Xsc3HTmJO58eQv3vrGdS+ZU4nHa0n1YxwRvm9UadPDrzO+dM4VXNx5i/YEW/vDWLr67ePKg71P0zYpdDfw8Vo39k4umM60iL2mPNaY4iwtmjuDlDYf487u7ufdzc5P2WMNdQNMJ6jolavfPv/aKQI2KSk+nj+c5bIzsok1+nt3GWLeTLb4gebEAYJ4j9prqtPHB+jouOGlUt627XaqCL6zTpum4MuyaRAhxbJJXIpFwEU3n8Vh1yLULx6KqCr+4YjYuu8oHOxt4ZvWBNB9hu32x1qBjUhAIdDtsFGeb1SkHm4Ze5u2eej9femgly3c1sKfez6GWIM2ByFFBQKddJS92AfTAO7uS0vO+wRfib7FWs+moBgQozZFA4EDUtAS546XNAJw1vQyXPbM2J3LdDv70pRPIcdlZtaeRu17Zmu5DylhbDnn59O/fZ+nWOpx2lV9eOTvj2mRlOe38/fqTyPc4+HhfM197ZDXBLirJ+ur5Tw5yyl1Lue/NHQk8yswT0XT+/J5ZDXjDaRMypn2vqipkxxKJPvQF+MO+Opq7mLsxwuXgYDDM7kBmvD5rhkFdKMJar583G1p4r7GV3W0hakNRmiNRgrqBjoEKOBWFbJtCnt1GsdNmBjYjUVa3Blja2MKS+hZWNfuoagvREol2qhZsjWrsCgR5p7GVpQ0trPEGWL+3iT89s5FWf4SKQg+Hih0cCkUotNv4wojMmc8qhgdFUbjqhNG89r3TOHVyCaGozh0vbebqBz+kquHo9lnrDzRz+R+X81/PbaA5EGFaRS7PfGMh91w1h7JcNxfOGsGr3z2V+79wPFPKc/AGo/z6ze0s+r9l/G7pjvhMruFkTVUTv39rJwD/e/lMKvKTE6wvzXXx2NcWMLLAw+56P196aNUxP5OxNy/EqgHPPa48o5OKvrRwLCMLPNR4g/HrJZFcum7gC1utQQefpFCR7+aOy2YC8LtlO9hwoGXQ9yl6V93cxk1PfIymG1w+byRfOWVc0h/zxtMmAPDiumqpzh6EgKZjGGDroeDAG9u3OrI1aFNUY5zbSXY3+xJjPE6cKrTFqgJzbCrWoxxsDfLMu3u6fUynohA2DJlfLoTIGJmxsyOGldc21VDXGqIkxxVv+zeuJJvvnzsFgDte3kytt+ehuqngDUZo9Jt998cWJ781KAzdOYE1LUG++JeV1PvCzBiRx5M3nsy/b1rEm7ecxvs/OpPVP1nMpv93Hrt+fiHb77yA9T87j6tPHI1hwPefXpvwVk4PvrebQFhj5sg8zpmRnoxcqyLQH9bwh2QAdF8s31nPxb97j7X7m8l12bnh1AnpPqQuTSrL4Z6r5gDw8Ad74hs/ot1znxzg8j98QFVDgJEFHv71zVO4dG5mtsmaPiKPR796EjkuOyt2N/CNx9YQ6uesBl03+OVrW7n5qbVUtwT59Zvb462Jh5s1VU1cdv8HHGxuoyTHmXFVnpVtBmp1AANY1tjKd7bs44W6ZiJ6e0DMrigUOGxs8QfNyjtdT0tLbl9UY2cgyFsNXpY2etnYGkQFxnqcjHI7qXA5KHM5KHbaKXTYyXfYybXbyLbZ8NhUXKpKlk2l3OVgvMdFpcuJCuxqC/FuYytvNnhZ1tjK5tYAy5taeaPBy/ImH/WRKIUOO3t3NPLgc1toC2lMGZXHDVcex0sN5mbiV0eVkG3LrEQMMXxUFnh49KsncedlM8ly2li1t5EL7nuPv6/Yi64bNAfC/PdzG7j0/g9Yt7+ZHJed2y6ewUvfWcSJ4zoHqFVV4aLZI1jy3dP43efnManMDAje88Z2Fv3iLe5/ayeB8PBYh/lDUW55ei26AZfNreTi2ZVJfbzKAg+PfW0BJTkuthzy8pW/rZI1bTda2iL8e5059uLSuck9L4Plstvi191/eHsnTX6ZM5dsvnAUa5mRiIpAgE/PqeSiWSOI6gbfe3rtoBLZRO+CEY1vPLaGBn+Y4yrz+Pnls1LSxWrO6AJOnlBEVDeG7bVFKvg0DXo5XVbyoBkINJNs/JqGR1UZ7ek+mbXEYafS5aQ+9vU2RSE3VgFoOFWWfHSQzfuau/xaRVFQgIC0BhVCZAgJBIqEe3R5+6yojiXyX/3UeGaPyqc1GOUnz29M+5w8a15hSY6TnBRldVYWmAuOFbsb0v7991WTP8yXHlrJweY2xhVn8chXT+LkCcXMGpXPpLJcRhVmUZLjIttlx9ahMu9/Lp7B2OIsqluC/PSFjQk7nnpfKP479r3FU9LWZjbbZScr1mqn3pcZVSeZStcN7n9rJ198yAwmTx+Rx7+/s4iZI/PTfWjdOu+4Cm46cxIAP3p2PZurZW4DQDiq89MXNvK9p9YRjOicNqWUlzL8XIJ5kf3wV07E7VB5e9thvvuPtUT7mJnpD0X55uNruP+tXQAsnGC2s73j5c28vP5Q0o451Rp8IW795zqu+ONyNlV7yXPbueszs3E7MitYVJHlxLmhicsVFxM9Ltp0g79XN/D9bfv52NtecVTosBOI6rzX1MqSerOS7r0mL+u8frb5g1S1hagJRWiKRAloOlHdGPTfZcMwCOs61cEwq5p9vNHgZUWTj5aoRpnTzrgsJwUOO+oA/26ZAU47o91Oxnmc8WrBj1sDVAXDeFSFcR4n5U47L7xXxUNLdqDpBqfMKOVHV83isfomogYcn5fFyfmpSYASxy5FUfjiyWNZ8t3TWDC+iEBY439e2MRVf1rBWfe8w+Mr92EYcPm8kSz7/ul8ddH4HquPVVXhkjmVvHbzadx39VwmlmbT0hbhl69t48xfvc3Tq/ej6UNjbd2dO1/eTFVDgMp8N//v0pkpeczxJdk89jWzcv6Tfc3c+PfBVc4PR3WtQa5+8EPqfSHK81ycOrk03YfUq0vnjmRaRS6twSh/eHtnug9n2LPagjrtasLWTYqicMdlMynNdbGzzsevXtuWkPsVRzMMg/95fiPrD7RQmOXggS/OT2lL3a+fNhGAf6zad8zMwk20pki0x/mAAIfbzKQIu2ZQEOvUVR+OMtLtoLCHLkWKojAuy4VuEE88tOYEzp5WggH86eVtBLpJpHEosN0X5HBYzq0QIv0kECgSasshL6v2moOVv3DSmE6fs9tU7v7sbOyqwhuba3llQ02ajtJUFQsEjilKfltQy6cmlQDw0Pt7+M4/PsGX4Vm3/lCUr/ztI3bU+ajIc/P36xfEK+F6k+2yc+9Vc1EVeH5tNf9eV52QY/rTO7toi2jMGZXPWdPKEnKfAyVzAnvXEohww6Or+eVr29ANuHL+KJ771imMK8n8TejvnTOF06aUEozofP2x1TQHhk9G9Ye7G/jflzfzr48PxCuje1PrDfL5P3/IIyvMQPx/nDWJv37lRApjF1KZ7qTxRfz52hNw2lSWbKrhB8+sQ+9l0/hgcxuffWAFr22qxWlX+fXn5vDEDQu4duFYDAO+99RaPtyd+PbHfeUNRthW08pbW+t4fGUVj67YG09y6StNN3jswyrOuucdno617r5y/iiW/eCMtFVc96Qs10yocfk17poykm+NLqXAbqM6FOHnu2v4+e5DVAfN3+kxHgd5dhsORSGsG9SGomz2Bfmoxce7Ta282dDCG/UtvFbfwqv1zbxyuIXX61t4J1ZZ93GLn42tAbb629gZCLIzEGSrv41NrQE+afGzqtnHe01eljV4ee2w+fVL6lt4u7GVHYEgbisw53L0OBfEMAxaoxp7AiE+avHz6uEW/l7dwH1VtTx1qJGt/iDaEUFKRVHi1YLjPC5Gu83AYDiq87vnt/DSyv0AXP6pMVx13iSer29hiz+IS1X42siSjJnVLIa/McVZ/OOGk7nt4hm47Cqrq5po9IeZUp7DkzeezK8/N5eyvL63v7SpCpfOHcnr3zud33xuLqMKPdR6Q9z6z/Vc9Nv3eG/H4SR+N8nz5uZa/rHKfN7+6qo5KZ0lPq0ij0e+ehLZThsf7Gzgpic+ISJtzAAzcfTKB1aw5ZCXkhwXf/3KSUNidrRNVfjPC8w57Y8sr+JAU//WBqLvVu9t5Lq/fgRAUVZi18RF2U5+ccUsAB76YE9a15zD2WMr9/HMmgOoCvzu88czOoX7QwBnTC1lSnkO/rDGEyv3pfSxh4ugbmDvZW3bGOseUOi0oygKIV1HVRTGeVy9rosrnA7KnHYaY1WBViDwxFnllOa7afCG+Pubu7r82hEuBy2axopmX/waRQgh0iVzm9uLIenR2Abx+cdVdDnTYlpFHt86cxK/XbqDn764kVMmFqdtE3lvbFbJuBS1BQX40sljCUd1/u/Vrby0/hCbq73cf83xTB+RvCHUAxWKatz499Ws299MQZaDv19/Ur8XxfPHFnLTmZP47bKd/PdzGzhhXCEj8j29f2E36lqD/P1D83fs5nPSVw1oKc1xUdUQkEBgNzYcaOGbj6/hQFMbTrvKHZcex+dOHNP7F2YIm6rw26vncsnv32d/Yxv/8eRa/vqVEztVvg41O+taueuVrSzdWhf/mKLA8WMKOWtaGWdNK2NaRe5Rz62Vuxv49hOfUO8Lkeu28+ur5rI4A4NEvTl1cin3X3M833xsDc+vrcbjtPPzy2d2+VqypqqJr/99DfW+ECU5Tv70pROYP7YQgJ9echy13iCvbarlhkdX889vnMLUitykHHNLIMKybbUcbGrjYHOQQy1tVDe3cag5SGuXySSbmD4ij/OPq+D8mRVMKc/p9rVy3f5m/ucFMwMazDaqd152HPPHZu7suPJYAkaTP4yqKJxVnMfJBTn8s6aRV+pb+NgbYH1rgAtK8vlsRaHZZrOb+zIMg4hhENENooaBhkFY02k1zLl+GuZ7w+jYbUgBxcCmKKjQ+b1ivh/hcuDo4nXCF9XY3RZidyBEbTjK4XCE+kiU+rA5J7A7z9Q2kaWqzMz1MCfXw9zcLMpdRwcJmn1hfv2vTexoCsDILCbNKmWZA/6xuX1T6XMVRZR18bUWbWgXVIkMpaoKX100njOmlvK7ZTuZOTKfaxeOHVRAxaYqXDZvJBfMquDR5VX8btkOtta08qWHVnH6lFJ+fOE0plVk3vq6K/W+EP/5r/UAfG3ReE6ZWJLyY5g7uoC/fPlEvvLXVby5pZYfPLOOe6+aO6TXPIO15ZCXax9exeHWEKOLPDx2/YKUjZNIhNOnlLJwQjErdjdw7xvbufequek+pGGlpS3CL5ZsjQduirOd3HlZ4it5z5pWztUnjubJj/bzg2fWseTm01LWzehYsHpvI//vxU0A/Oj8aSyanPrXX0VRuPG0ifzgmXU8/MEevrpoHK4eKtTE0Qx67gwa0Q2ao2b70NLYHM/GSDQW4Os98cauKkzIcrG8yYduGOTZzedgGwbfuHgqdz6+jvc21nL85GJOnNL5d0hRFEa5HNSEo6xo9nFCfjZje2hFKoQQyaQYQ6U/4TDg9XrJz8+npaWFvLyhcWHaHy2BCCfftZS2iMZTN57Mglj7tCOFohoX//Z9dtT5+My8kdz7ubmpPVDMVoVffGgly3c1cPPiydy8eEpKH39NVRM3PfExh1qCuOwqd1w2k6tOGJ3SY+iJphvc9MTHvLqxhiynjSduOJm5owsGdF8RTeezf1zOugMtfGpSMX//6gLUAW4q3P7vzTz8wR7mjSngX988Je2BwG8+toZXN9Zw+6XHce3CcWk9lmQ73BoiEI4yqjCr100hwzD4x6r9/OzfmwhHdcYUZfGHa47P+PaR3dlc7eUzf/yAYETnO2dN4vvnTk33IfVbXWuQ37y5g6c+Mlun2VSF82dWsOewn82HOrc9rcx3c9b0Ms6eVs7CicU89mEVd726FU03mFqey5++NH9IVHT25N/rqvnuk5+gG2bb6v+5eHqn15PnPjnAj/65gbCmM31EHn/58gmMLOgcTgpGNL74l5WsrmpiRL6bf33rlEElOnTllQ2HuO2FjdT7us8eLchyUJnvobLAjT+ksWpvY6f2eBNKsjlvZgXnH1fB7FH5KIpCkz/M3a9t48mPzNZ8uS473z93Cl88eWyPrfkywYPv7uLnr2xl8th8bvvc7E7nrToY5m/VDXzsNSsf8mwqI9zmXD0FUGPBOtX6d+y9XVEod9qpdDmodDupdDnIHeQGTEDT2R0IsastxK5AiN2BIDW9zDHLt9socdgptNvwNQaprm5Fz3MQyncQOeJ1t8JpZ05uFnNysxjhdrCypoUXd9QRyLGDp/MGoQqM87hYUJDNZWUF2I7426kZBt6ohjeqoaBQ6rRzSmFO2mYIDvf1crIc6z+3Jn+Y3y3byd8/3EtEM1AVuHL+aG45dwrl/ag4TDXDMLjh0dW8uaWOqeW5vHDTp9LakvmtrXXc8OhqorrB508a022yzHD30d5Grv/bR3iDUaZV5PLoV0/qV+Vqpli3v5lL7/8ARYFX/uPUjEw+HWoMw+CVDTX87N+b4smgnzthND++cBoFCa4ItPhCUc7/zbscaGrj6hNH839XzE7K4xxrar1BLv7d+xxuDXHR7BH8/vPz0vZ6F47qnHb3W9R4g/y/Tx/Hl08Zl5bjGIrCUZ1nqg7jctup6OI5uNYb4OGD9VSHzNacF3oVvnzqePYHw5xamNvnoFybpvNmQwsG8FxtM6/Wt3B5WQHXVBbz5Nt7eGnlfnI9Du766nwKcrp+LTgcjhDRDeblZTMpq/dKRJF4x/p6WQgJBKbQcH/B+ct7u7nz5S1Mq8jl1e+e2uMftU/2NfGZPy7HMOCv153ImVNT2+LxF0u28se3d+G0q7x406fSkjHc6A9zy9NreXub2cLos/NHccelM1Paj74rhmHwn89u4KnV+3HaVP563YnxlqYDteuwj4t++x7BiM7/XDyD6xeN7/d91HqDnHb3W4SiOo9+9SROm5L++Ry3vbCRR1dUDdngUG+CEY3XN9fyzOr9vL+zHsMwZ19MLM1hSnkOk8tymFSWy5TyHMYUZWG3qbSFNf77+Q386+ODACyeXs49KW5xlQzPf3KQm59aC8CfvjSf846rSPkxRDWdsKaT5ex7FnAgHOXP7+7hT+/uIhA2Z/6cM6OcH50/jUllOQBUN7fx1rY6lm2p44Nd9QQj7e3AHDaFSKxE6NK5ldz1mVn9evxM9szq/fzwn2YFxk1nTuIH501F1w1++fo2/vi22drl3Bnl/Ppzc8nuJvO6ORDmij8uZ9dhP1PLc3n6GwsT8rte1xrktuc3sWST2UJ7fEk288cWUlngYWSBmxH5HioLzODfkeejyR/mzS21LNlYw3s76gl3aO9Wme9m0eQS3thcS1PAvBj+zPEj+fEF0/vc9jndPt7XxGf+sByAM44fwZfPnojjiLabH3v9/O1gQ/yCfyDybCqVbicjXA4qXWa2sI5BVDerCKMGsffmx6Kx6sLmqMbuQKjbxy532pmQ5WKUy0mJ006p006Jw06x044RNXj944O8suoAvrb2oKEBGHkO9GIXarmHSJ4Do4c1lgpMynIxI8fDjBw3U7PdRwX1DMPAp+k0RzU0wyDPbmOUy8kIt4MSR9cVjaky3NfLySI/N9Peej93v7Y1PoLA47Bx42kTuPG0Cd2+lqeLYRj8/cMqbnthE06byvPf/hQzKtN/7l5aX81//MNMlrnxtAn8+IJpx9Rm5bKttXzr8Y8JRnROGFvIQ18+kfysobuO/fYTH/Py+kOcMbWUv113UroPZ0g72NzGbc9vjHfWmFCSzc8/M4uTu0mATqSVuxu4+s8fYhjw8FdO4KxpQ68zRyYJR3WufnAFH+9rZmp5Lv/61ilp/xthJbsBXDirgh9fMD3lbUqHkv2NAZ5YtY+nPtofH3WR47FTlOuiKNeFO9/FzkIbB+zmtaw9oqNsbubrc0dx3PQSXIrK2SV5PbbvP9Lm1gCrvQE+9vp5sqaJIoeNKyuKWJSbzR2PrWXfYT/zJhZxyxXHdft3sykSxafpzM7xMD3HM+DZ4UOJYRi06QZ+TSOoG4xwOrCn6VpD1sviWCeBwBQazi84um5w1j1vs7chwM8vn8UXFvTe/u+Olzbz0Pt7qMx389r3TiPXnZoLrH99fIBbnl4HwG8+N5fL5o1MyeN2RdcN/vjOLu553ZyfNrU8l/uvOT6+QZ8Od726hT+9sxtVgT9cczznzxyRkPv9+4dV/M/zG3HaVf5906J+t9H72Yub+NvyvZwwtpBnvrEwIzYkfrt0B/e+sX1YZWYahsG6Ay08s3o//15XjTfYvhnttKuEo13PjHHaVCaUZhOMaOxtCKAqcOv50/j6aRMy4lwlwv/79yb++sFeclx2XrjpU0wsTc3zVNcNnl69n18s2UpzW4QJJdnMHlXA7FH5zB6Vz4wR+UclEGi6wTOr93PvG9upi2UrzxldwH9fOJ2Txnff9jEY0Vixq4GlW2tZtqWO6pYgdlXhJxdN58unjBs259Ly9xV7+Z8XzHZA3z17MlsOeXl9cy0A3z5zIt8/Z2qvFcwHmgJ85g/LqWsNsWB8EY9ef9KA2/kYhsG/Pj7I7S9tpqUtgl1V+NYZE/n2WZMGdJ++UJS3ttaxZFMNb22tiweDAaZV5HL7pTN7/H3IVI+s2MtPY+dt0bwRnL9oNEVOBzk2NX4xHdENNvnaCOk6OqAbYGCgG6DH34NuGIR0g5pQhIOhCNWhMI0RrfsH74dSh52JWS4mZrmYkOVigsfVZaVhMKzx5ifVvLzyAK1tZgCxosjDZQvH4HSobD/gZftBL3trWs3vw6agF7nQi10YJW50tw3FG6Y0CtfOG8Wcwhw83VR2BjSd5kiUkGGQY7NR4bIz0uWk1Ono9mtSbTivl5NJfm6dralq5M6Xt/DJvmYACrMcXDp3JFccP4qZI/PS9vdM1w3WHmjm1Q2HeGVDDQeb2wD48QXT+PrpE9NyTF15+qP93PqsmSwzZ3QBPzp/alpalqbac58c4AfPrEfTDc6aVsb9Xzg+7Umag7W33s/ie98hqhs8ccOCY+I8JpqmG/xt+V7ueX0bgbCGw6bwzTMm8a0zJqa0gvd/X97Mn9/bQ0mOi9e/dxpFQ2ROdyb67+c28PjKfeS57bx406KM6HYSjurc8dJmHl9ZhR5LwP3aovF868xJ0g42RtcN3tlxmMdWVLFsWx3WbraiEP+3oYI2Ppfo+FywKaAb2Pb5sO9sRdEM/uvqWXhKszgxP5tpOf3r5tISibK0sZX6cIR79tbSEjWvGUocdk7P8rDkuW1oEYOvnT+ZM+Z0v4/mjWo0hqPMzPUwMycrbUGxZIjGAn5+Tcev6bRENRojUfyaTlDXcSoKpxflUZKm5GJZL4tjnQQCU2g4v+C8va2Or/z1I3Lddlb+19l9qhgJhKOc/5v32NcY4Esnj+WOJPTUP9KaqiY+/+CHhDWdb50xkVvPn5b0x+yL5bvq+Y9/rKXeFyLbaeOuK2bz6TmVKT+OP769i18sMbPQ7r5iNledmLh2pYZh8NW/fcRb2w4zfUQez3/7lD5vbB9qaeP0X75NOKrz+NcWDLpCMVH+sWofP/7XBs6eVsZDXzkx3YczKHWtQZ7/5CDPrD7Ajjpf/OMjCzxccfxIrpg/ilGFWRxoCrCj1sf2ulZ21vrYUedjZ52Ptg4b5yU5Ln73+XksnJj87NhUimg61/xlJav2NDKpLIfnv/2ppF+Uba728pPnN/BxbCOzK6oCU8pzmTUyn9mjC8j3OLh/2U621bYCMLrIw63nTePi2SP6tfFpGAbba3047SrjM+DiOFn+9M4u7np1a/z/TrvKL66YxeXzRvX5PjZXe/ncn1bQGopy0ewR/O7qef1ugXywuY3/+tcG3tluVonPHJnH3VfMSVh1SDCi8f6Oet7fWc/Eshw+f+LojG8D2pPHV1bx389tBODTC0Zz5sJR+DQdl6pQ6LAPKqjVpukcigUFq0MRqkMRGsNRbLE2og5Vwa5g/ltRsKux94pClk1lvMcM/OX38jcuFNFY+kk1L608gDdWoVlS4Ob8k0cxd2pJvOovy6aSbVOJRnR2H2pl+8EWth3wsvOgl7ZYcPdTx5XxtfOn4LB3/r6jhoE/quHTdMK6gcemUuq0M9rtosxpJycDZ9AM5/VyMsnP7WhWC79fLNnKvsZA/ONTynO44vhRXD5vZL/aPdb7Qmw40MLOOh+F2U7GFGUxpiiLslxXj6/5mm6wpqqJVzceYsnGGg61BOOf8zhsXHXCKG675LiMm8f3xMp93Pny5ngSyelTSvnR+dPSXrUY1XRqvEFG5HsS+jN7+P093P7SZgAunzeSuz87e1BzLDOJ1cVkzqh8nv/2p4ZdYleyhKM6n+xr4s6Xt7DhoDlP+YSxhdz1mVlMLk/ObOieBCMal/zOHLFy4awK7v/C8XIuB+Cpj/bxo2c3oCjw8JdP5Mxpqe1O1Zsth7zc8dJmlu9qAKA018Wt503liuNHDXjEylDX6A/z9Or9PL6yiv2NbfGPnzq5hC+ePBat1E1TIMTmljaebfLSbJjJy0Uhg8pDQYINQRpbwxTnufje1TNR7DbOKc4b0Dr4o2Y/2/1BKtx23qj38kJdM02xgKDHgMi2ZrJrg9z15eMpK+g+0OjXNGpDUaZle5iT5+lXZWJXmvxhXt5wiFc3HmJccTb/fdH0hHfy0Q2DsG4Qjr2PGOb1RVg3COk6TdEoLRGz6i+oG2CYI0ncqoJbVXGqCnXhKIuL8yjtw2zGZJD1sjjWSSAwhYbzC85X//YRy7bW8dVPjee2S2b0+euW76znC39ZCcDTX1+Y1MqEg81tXPr796n3hTlnRjl/+uL8jFpI1bUG+Y9/fMKHuxsBuPrE0SyeXs6Y4ixGF2YlNRvVMAweWb6Xn/3bvPj9rwunceNpic9KrmsNcv5v3qPRH+brp0/gxxdM7/VrIprOT57byFOr93PS+CKeuvHkjLngeXNzLV97dDWzR+Xz4k2L0n04/abpBsu21vHkqn28vf1wfK6Yy65ywcwKrjxhNAsnFPf6PNF1g4PNbeyoa6W+NcyZ08qGTJvB/jrcGuLi371HrTfE4ullfOWU8ZTmuijJcVKY5UzYa4ovFOXXb2znb8v3oukG2U4b3ztnCp+eU8mmQ142HGhh/YFm1h1oic8nOVK+x8F3zprElxaOlYHzvfj1G9u5b+kOSnJcPHjtfI4fU9jv+1i+s54v/3UVEc3g+kXj+Z+L+/a3UNcNnli1j/97dSu+UBSnXeXmxZO58dQJQzpQlwodKzqvP3U815wxgf2hMHWhKG26Tq5dJcdmQ1XA1mEmYDpohkFQ0wnoOt5QlJUb63h3dTW+WACwKM/FuSePZsGMUpyqitum4lYVooZBS9TMqo0aBs5YsDHbpmJHYX+9H19bhBljClAUBc0wYhm4GkHNwKZCjs2cPVjmclDssFNgt2XM39GuDOf1cjLJz617UU3nvZ31PLvmAK9vro13N1AVOHVyKVfMH8W5M8o7VfY0B8JsONjC+gMtbDjQwoaDLfHqvSM57SqjCj2MLsyKBwdHF3lwO2ws21rHqxtrOv2tznHZOXt6GRfMHMHpU0ozuuLscGuI3y/bweMr9xHVDRQFLp1TyffPnZqSlnVRTWfnYV/8HGw42MKWQ16CEZ2RBR6uOmE0V504alAzeg3D4N43tvO7ZTsBc3bwTy6anlHXiYN1uDXE6b98i0BY438vn8nnTxyTEd9fOKoTCEcJhDXcDhuFWY60/X0yDIOqhgDrDjTzyb5m1u5vZnO1N95iPddt58cXTOfqE0en9We34UALl//hA6K6wX1Xz+XSuV13NzIMgwNNbayuauRwa4iCLCdFWU4Ks50UZZv/znXbM+L3IFV8oSgvravmthc2EdZ0vn/OFL5z9uR0H1aXDMPgjc21/O8rW6hqMBNZZo3M57ZLZnDiuKHXzWOgPtnXxN9XVPHShloY0J0AAQAASURBVEPxv915bjtXnjCaaxaMYUKsQ88jB+v5e3U9G31mok2Rw8ZXKktYWJB91GvK3rYQM3M8zM0bWKLr4XCEZQ1eimKJh2FdZ2lDK8/XNdFgJUeHNCqaItx99jSyeqgaDsaSDyd4XEzMdqMZRuwNNNpHEESs4JuhY0Ml26bgVFV0TeejHQ28uaGGD3fWE9Xat/enlOfymy/MZUxxNgZmEM/A7IhixDqkGLHH0QzzWkXv8H+9w/iDgK7TFqvoixrERyJosY4rigEo4FLVeNDPpSpHXXdphkF1KCKBQCHSSAKBKTRcX3CqGvyc8au3MQx46wdn9Lty5D+fXc+TH+1ndJGHh798YlKy6wLhKJ/94wo2H/IyrSKXZ7+Z/h7wXdF0g9+82X4h2lFprqt9c6HQw+jYvyeV5VCcM/Cgywc76/nFkq2sP2BmOX7zjIn8KImVkq9tquHrf1+DosA/bji5y5kKtd4gb2+r4+1th3l/Rz2tIbM95T9uODmjqszW7W/m0vs/oDjbyVs/PIO8FLW3HSxvMMLTH+3nkRV7O2XUHT+mgCtPGM1Fs0cMme8lHT7e18Tn/rQiPjvPYlMVirOdlOS4YsFBFyW5TkYXZnHKxGLGlxx9IXIkwzB4dWMNt/97MzVe80Lmolkj+J+LZ1CR33XVQq03yPpYYHD9gRb2NwY4e3oZN505eUjPtEklqyXu2KIsCgfRZumFtQf57pNrAfj0nEpGF3nIcTnIcdnIcdvJdtrJcdvJcZlvwYjO7S9tiieAzB9byC+umJ3W9tBDzSPL9/LTF81g4LfOmMgPzp1Cs6ZTGwxTFQzj1/T4xbRuGO0thAAUBfOSmHi1n10hXt1nj1X72fu4KVndEGBTVTO+tgj+UJTWYJTWUJS2YJRQWIu/BYLR+GZGRYGbr50+kcvmVeJx2HAqKnaFTq8VQU3HG9XwahqHQ1EaIhH8mk5EN7DFAoMRwyCo66iY/y9y2KhwOSmw28h32AadZZxKw3W9nGzyc+ublrYIL68/xLMfH2BNVVP847luO+cfV0FbRGP9gZZOFYQWRYGJpTlMrcilJRBhX2OA6uY2onrvl9O5bjvnzCjnwpkjWDS5JKXtBBOhqsHPPa9v58V11YA5Q/iaBWP5zlmTOl2HGIZBXWuIqoYAexv87GsIUNUYYF+DH39Yo8DjoCDLQb7HSUGWo/3/WU4KPA6yXXb21PvZcKCZDQdb2BwL+h2pYxs4VYEzppZx9YmjOWtaWZ+SaAzDYE+9n9V7m3hjSy1vxNqC//C8qXzrjIkZnSwxUFbSE0B5nosLZo7gwlkjOGFsYUKDQZpusPuwj7X7Y+vSpgCBkEYgEjXfh7V48O/I506+x8H4kmwmlGYzoSSb8SU5jC/JZnxJdkID5oFwlJqWIFUNAdbuN4N+6w400xw4er5vQZaDs6aV8Z/nT+tXBXEy3ffmDn795nby3HZe/97pVOS7CUd1Nh/ysnpvI2uqmlhT1RQfD9Adm6pQmOWkKNtBYZaTKeW5fGnhWKakodoxWaKazvs763nuk4O8tqkm/npy7oxyHsiwxPCuhKIajyzfy++W7ozviVw8ewRfOWUcBVlO8tx2ct0O3A51WL1ufbS3kV+/sT1eFQlmt5RrTx7HJXMq468HQU3n11W13L+vlqgBdgUuKS3gM+WFXXYHCWg6LRGNs4rzKB5gtZxhGLzX5KM6FGaUu/26MaIbvN3Yyj9rGmmIVQi6DLh8RBFTs12UOO0UOexHrcnDus6BYASbQuyqREHBwNAN2nRo1qK0RDVaIhphwyBXVfA3haja3czOHY2EQ+2dmSpLszhuQhEfbqilNRDB7bRx9bmTmDWpKD4mwYD4mxkcVIiF81BjwUFiv0oKZhKldY1kXR9ZHVFstF+zRA0DX1SjVdNpjXUjsd77Yu+9UY2GSJQ/zRjLcbnpmX8p62VxrJNAYAoN1xccq1f96VNKeeSr/R9A3tIW4cL73uNgcxsuu8p/XTidaxeOTdhCRtcNvvn4Gl7bVEtJjpPnv/0pRhVm9tDl93fU849V+6hq9FPVEKC1w5y2I6kKnHdcBV9dNJ4Txhb2+ee24UALd7+2lfd21AOQ7bTxrTMnpeTi99Z/ruPp1QcYWeDh1ZtPJcth45P9zby9rY63th5m8yFvp9sXZTv5yinj+I8My9hraYuw6P+W0RqKUpnv5u7PzmHR5MxoW9qVPfV+Hlm+l2dW78cfa/OU73Fw9YmjufKE0RJ86IdlW2t5+P291LUGqfeF4wPKezKywMOiSSUsmlzCKROLjwrgVzX4ue2FTfHWkGOLs/h/nz6OM6ZmVrsa0bM/v7ub/31lS7++xuOwcev5U7l24biMaw03FPz1gz38v1hF+01nTuL7505BURSiukGbrqMZBlErs9Uw0CCecRuNZcCGNB2frtGmGYR1nUjs4xHDQNMNDAXMy/b282MY5qXz4aY23vroIOu3NdDXRXVlvpubzprMZ+ePwmnvX5AuohtmYDB2MV0XipBlU6lwOShw2Mm32zJm3t9ADNf1crLJz63/9tb7+dfHB3j244NdVvuNK85i1qgCZo/MZ9aofGaOzD+qJXhU0znUEmR/Y4B9jQH2NwXY19jGvsYATf4wJ08o4oJZI/jUxJJ+P9cz0caDLfxiSefrh4tnV9LgD7Ov0c++xkCXgbvByHHZOa4yj1mx8zBrZD4j8j0s2XSIJ1ftZ+Wexvhty3JdXHnCKD53whjGFLdf70U0nU3VZpDko72NrN7bREOHtZuiwJ2XzeSaBWMTeuyZJBjRuPPlzbzwSXU8oADmz+yCmRVmUHBcUb/WIYZhcKglyLr9zaw90My6/c1sPOjFF+r+2rUrDptyVILdkSrz3YwryaYw20luLKHKSq7KddvNxKvY/112lXpfiJqWIIdagtR6zffm/9s6zUDvyGlTmVGZx9zRBcwbU8CcUQWMLc7KuABLRNP57B+Xs+5ACzNG5JHjtrNufzOhI2a5O2wKx1XmM7Y4i5a2CE3+MI2BME3+SI/n6NTJJXz1U+M5fUppxgfKurO52stznxzg+bXVnSqyJ5Rmc8Xxo/jqp8ZndDX2kQ63hrj3jW08+dF+utrBtatKh+eDg1y3nVyXnfwsB8XZToqyXbH3ZlVocbaTohzzuZRJv99rqpr4zZvb439jHDaFS+ZUcu3CccwZlX/UsUZ1g3NWb2OLP8iMbDffGF1KpbvrpE7dMDgQDDPW4+KUgpxBfd/7g2HebWyl0uXAccRzJGoY/GX9AZb6AhjZRwcbc20qxU47xQ47JQ47xU47OTaV5oi5rq+PRGkIm++DvSUaGQZqRKdAtTE618XIbBdFDjvBUJT3NtdR7wuDTWF0ZS4jy7MJdWjjGYpV+dsVpVNCZMdkSIeioABh3Uw4DOsGIcP8+o73E9LNa6a+enrOBE4rSs9aVdbL4lgngcAUGiovOP5QFI/D1qdFX1tY4+S7ltLSFuGhL5/A2dPLB/SYdd4gP/jnet6NbYCfMbWUuz87m7LcwWfd/eq1bfz+rZ04bSr/uHEB88cOvVYKVtZxx7f9jQGqGv2dKrpmj8rn+kXjuXDWiG5nWuyp9/Or17fx8vpDQHtG701nTaJkEJWF/eELRbnwPnM+5OSyHGq9wU4XZIoCs0cVcObUUs6YWsbskfkZexGypqqRW55eF2/Z8aWTx/LjC6clvB/7QBmGwfJdDTz8/p5OA7Unl+Vw3afGc/m8kUPqIihTRTSdRn+Yw60hDvtCHG4NUR97v/VQK2uqmuKthSzHVeaxaHIJp04qZU1VE/e/vZNwVMdpU/nGGRP51hkTh1zFgGhv5bP+QAu+UBRfKIo/9t4XiuILtv+7LaxxyqQS7rx0ZqcNS9F/D72/hztis53+4+zJ3HLOlAHflxafexGbg6HrRGLtcswMWvOF9GBjgMfe28ub6w9hXafPG19EZYGbQo+DYo+TfE9sM8btiGdt57rtjCr0JKz1q24YaWt5mgxDZb2caeTnNnC6brByTyNLt9RSlONk9sgCZo3Ml6r6Hry/w+woYs1N60hVYGShh7FF2YwpzmJsURZji7PJc9tpaYvQ3BahORChuS1MS6D9382BCN62CKOKssy5x7Hg6/ji7B6vA3Yd9vHUR/t5ds2BTsG9RZNKmD0qn0/2NfPJ/qajApROu8qcUfmcMK6Ic2eUM28AbcGHolDUnBn88oZDvLG5tlPCaWmui/OPq4hXmEU0680grOlEou3/94WibKr2Uu87uurM47Axa1Q+c0blM7k8lxyXHY/TRrbTTpbTFv+3x2kjy2nDYVNpC2tUNfrZfdjPnnrrvY899X6auqjUG6xsp43KAg+zRuYzNxb0mz4ib8gE7HfW+bjot+91Cv4VZDmYP6aQ+eMKOWFsEbNH5Xd7LRGKajQHIjT4wjQFwtT7QizZWMNrm2ria5oJJdlc96lxXDF/VMqvbUNRjTVVTby7vZ4PdtbT0hahMMthtjjNNiuKC2OtTgtj/85121m5u5FnPz7A1prW+H0VZjn49JxKPnP8KGZ3EUwaSjZVt3DP69vZVtNKa9AM6PahKL1bTptKfpYDp03FblOwqQoO1fy3XVWw29TYe4U8t4NTJhZzxtSyhLeGXru/mV+/sT2eEGtXFa48YRTfPnNSr0n8H7X4eaO+hQkeJ9l2m9lO0zCI6qAZsQryWN1bls3GyQXZjHANvAMMmAHIZY1eGiNR8u22eIWc1UXEMAzu/ddmVvsDOMbmkl3kpkXT6D11uAthHSUYRQlqEDXAZQOP+aZn2O+yAmTbVHLtNnI6vrfZyLGrZKkqLYEw35tSyeTsgbf0HgxZL4tjnQQCUyiTX3Cqm9t4ef0hXlpfzboDLUwozeabp0/ksnkjexySbg1aHl3k4e0fnDmoSgZdN3h0xV5+/upWwlGdomwnv7hiNufMGFhwETq3abvnyjlcMX/UgO8rU22raeXh9/fw3NqD7a3G8txce8pYvnDSGAqyzEVOnTfIfUt38NRH++MzPi6bO5JbzpmSkhkfR1pT1ciVD6yIL1wLshycNrmUM6eVctrk0kG1O021QDjK/726lUdXVAFmJdevrpyT1v79rcEIL60/xN8+2Mu22vYLobOmlXHdp8axaFLJkL4IGmoC4Sir9jTy/o563t9Z3+nitKNTJ5dw+6Uz+91iWQxNhmHI8zCB/vLebu582azGvHnxZG5e3HUwUNMN9jUG2FnnY2edj3pfiOMq8zh5QjGVBb1flO5vDPD7ZTv558cH4rNVF08v4+bFU5g5Mj9x39AxKpPXy5lMfm4i1XTd4LVNNaw90MzIAg9ji7MZW5TFyEJPj9ePyRKO6ryxuZYnP9oXrybpqCDLwQljCzlhXBEnjitk5sj8Y36Gciiq8cHOel5eX8Prm2t67ELTHZuqMK0ilzmjC5gzKp85owuYVJqT0DnHTf4wu+v9VDX48baZwY/WjslVwc7/b4toFGc7GZHvpiLfTUWeJ/5v633uMBiDsGxrLcu21jFrZD7zxxYxsbT3MQS92d8Y4NEVe3ly1f545Wie287nF4zh2oXjGNmHddJAGIbB7no/720/zLs76vlwdwOBsNb7F3bDaVM5e3oZnzl+FKdPKR0yAd7+MgyDQFgz29EHI7TGWtP7Yv9vCkRo9Ido8IfNilB/mIbY+8H8fCeX5XDmtDLOnFrGCeMKB/yav+FAC79+czvLttYB5uvJFceP5DtnTe7XHtV7ja00RqPYUXDbVDyqOUfPZVNxKioOVcGpKLhUhQJHYoLaVW0hNra2EYkFHq0uIlbzEH8gwm8fX4+/zXweGQB2BcNtO+oNh4oS1s1gX5uGEmx/Uw2DghwnhTkuSgrczJ9czNyJRXjsKq2azuEOFYT1sfeGAa7YrL6G5iAbdjSgRXSy7Crnza1kbHFWvEWpZgVO42/EZxNGDQMd876cqoor9jN0xWYAWu+dscfKsqmomPHKiGEQiXVZCWk663Y28O6aag43tvHqD85gwiBm+w6GrJfFsU4CgSmUaS84dd4gL284xEvrD3WakdHRyAIPXz99AledMPqobDLDMLjot++z+ZCX/7pwGjeeNjEhx7W9tpXvPrmWLbH2kJ8/aQz/c/H0fmehrd3fzFV/WkE4qvP10yfw4wumJ+T4MlW9L8QTK/fx6IqqeGamx2HjivkjyXU7+NsHe2mLDS8+c2opt54/jekj0vt7+NqmGrYeamXR5BLmji4Y8i3x3t9Rz63/XEd1SxBFgRtOncAt50xJWVVXS1uEpVtqeWXDId7dXh+vQMty2rhy/ii+fMq4+EBtkV51rUGW72zg/Z1mlqvLrvL9c6dy8ewREhgSYhAefHcXP39lKwDfWzyFc2aUs/OwGfDbFQv87an3H1Whaxld5OHk8cUsmFDMyROKOmUhVze38fu3dvJ0LKEGzA4GNy+ewtzRBUn/3o4VmbZeHirk5yZEu/2NAZ5ZvZ8ab5C5ows5cVwhE0tzMrbDSCYIR3U+2FnPW9vqCEd1HDbVfLMrZrWQ2v5vh03FZVeZXJ7DcZXdV52JocsXivLsmgP89YM97I11vrGpCucfV8HpU0uZUp7L5LIcsl0Dn7N2uDVkVv3tOMy72+uPatFcmuvi1MklnDa5lFGFHpoDERoDYZoDYZoCZqvTpg7/bm6LMK44i8vmjeTiWZVS1d2LYESj0W9WY0d1s9I3quloukFEN/8d1Q2imkFU1znY3Mbb2w6zpqopnggHkOuyc+qUEs6cWsbpU0vjXb0Mw6wkDkdjb5pOJGoQ1jQafGH+8v6e+HxWVYHL543iP86exNji/ifERnQDHQOHoqS0S4ZutLfFDOnm/O5wrKNIUNP5cGc9jyzbRVRrDxC2TxlQUJTYHD5VITfbQUGui/xcJ3k5TgpyXRTluijIceK0qaiKgqqYVY7RWIBNj1U62lBwxFp5OjpWJmK2M6luCPCnF7dS09iGqipccfo4TptbYZZL9sLAnMmrY3ZH0bFmC5rvdQBDAcX8mIKCI9ZiFN3gky2HWbqmmkOxTmZOm8ofv3j8gLvJDZasl8WxTgKBKZQJLzj1vhCvbqzhpXXVrNrbGG8TqChw4rgiLpk9gtOmlPLaphr+/N6eeD/1khwXXzt1PNcsGBPPnlu9t5HPPrACl11l5X+dHa88S4RQVOOe17fz5/d2YxgwviSb33xuLnP6uNF2qKWNT//+Aw63hjh7WhkPXnvCkA8y9VUoqvHvdYd46P098WCq5fgxBfzo/GksmFCcpqMb/rzBCHf8ezPPrDkAwKSyHO69ag6zRxUk5fFa2iK8sdkM/r2343Cn+RoTSrP5wkljuPKE0eR75EJICHFseOCdXfzfq1t7vI3LrjKhNIdJZTkUZzv5ZF8TG6u9nTY2wEyIWjChCJfdxrNrDsQDiKdOLuHmxVOYP/bYaCWXSpmwXh6K5OcmhBAi0XTdYNnWOh7+YA/LdzUc9fnRRR6mlucyuTyXqeW5TCnPZUJpNm6HDV03qPEG2dvgp6ohYL6vD8T/byUpW5w2lRPHF3La5FJOnVzK9BG5kiCZgVoCEd7dcZi3ttXxzrbDnVoyg9l2NxxrIdwbVYFL547kO2dNGtYJy0as0i5smMHVSKzqLhKrvAvHNmatGX3WzD5bh5l9ttj/o4Y1588MPgZ1g6Cm4dU0fFE9Voln3p8Sm/GnAKGIxj9e38na7ebzeP7UEi4/fRx5WQ5sas8VnaqCGWSMtUDtGHi0q2aA0oZZGehUFUIhjec/2s9jK6rMOYWYlcXXLhzHl08ZR2lu+rp/yXpZHOskEJhC6X7B+c9n1/PMmgOdNrnmjSngktmVXDhrBBX5nefxBSMaz6w5wANv74pnZ+W57XzlU+O57pRx/PTFTby4rpqrThjF3Z+dk5RjXr6znu8/s45DLUHsqsJ3z57M4hnlZpZSLFupY5aS9f/fLdvBxoNeppbn8uy3TiFngJlqQ5lhGHy4u5FHlu/FG4zwlVPGcc6McllMp8ibm2v5z39toN4XwqYqfPuMiVx/6gRyXPZBBaUNw6A5EOGNLbW8uuEQ7++s77TInlSWw4WzRnDRrBFMKR/cEGwhhBiqHnhnF79YspU8t4NJZTlMigX9JpZlM6k0l5GFnqNei1uDEVZXNbFydyMf7m5gw8GWowKDC8YXccs5UyShJonSvV4equTnJoQQIpm2HPLy7JoDbD7kZXutr8v5kGAGDUbkezjsC8VHl3R3uwmlOfGqvwUTilI+i1AMjq4brD/YwrKtdby9rY71B46eG2uxqwpOu2q+2VQWTizmO2dNZlLZ8A0AppphtM84VwAUs0JPJVb8Zxg88kEVv1iyNX6NoypQnOOiLNd8K7XeclyU5bkoy3VTnOOiOMdJrsve4/5SdXMbD7+/h3+s2oc/1nq2Mt/N9adO4HMnjs6IfVlZL4tjnQQCUyjdLzi/fG0r97+1i1kj87l49ggumj2i18G7ABFN58W11fzh7Z3sOuwHzFaD4aiZzfLSdxYldSZOSyDCfz2/gZfXH+rX1xVlO3nh259Ky/w7IcCcZ/E/L2zkpSN+d112lWyXHY/DRrbLhsdpJ9tpI8tp/jsS1QlENAKhKIGwRltEwx+K0hbWCES0ozamp5S3B/8ml+em8lsUQoiMFYxouOzqgBMi/KEoa6qa+HB3A7XeEFfMH8kpE0sSfJTiSOleLw9V8nMTQgiRSo3+MNtrW9le28q2mlZ21PrYVttKS1skfhu7qjC6KIuxxVmMK87u9H5UYdawnd13rGr0h2kNRnDazRbCVtDPaVOlNXMGWbWnkf96bgO7DvvoT0TAaVMpynZSnOOkKNtJSY6L4mwnRTlOdtX5eWHtwfj4hKnluXz99AlcMqcyLXODuyPrZXGsk0BgCqX7BafWG6QtrDGupP89twE03eD1TTX8/q2dbKo2W07OH1vIs988JZGH2SXDMHjuk4P8dukO/GENu6pgtynYVRWbqsT/b1NV7KpCvsfBzYsnJ60doxD98e911dzx0mbqWrvOmhyIaRW5XDhrBBfOqmBSmQT/hBBCDA/pXi8PVfJzE0IIkW7W7L99jQHK89yMyHdjz6AggBCiXVTTafCHOdwaoq41aL73hjjs6/C+NUijLxyv8OvNyROK+PrpEzljSmlGdqeS9bI41kkgMIWGywuOYRi8s/0wr22q5bpPjWOKVCAJ0SvDMAhFdQLhWHVfhyo/f1gjEI7GP+eyq/EqQY/TFq8ezIr9O9tlz4i2CkIIIUSiDZf1cqrJz00IIYQQQiRDMKLR4A/T4AvR4Au3/9sfpsEXxmFTuPqkMcwdXZDuQ+2RrJfFsU52kkW/KYrCGVPLOGNqWboPRYghQ1EU3A4bboeNomxnug9HCCGEEEIIIYQQQogeuR02RhZ4GFngSfehCCEGQWr0hRBCCCGEEEIIIYQQQgghhBiGJBAohBBCCCGEEEIIIYQQQgghxDAkgUAhhBBCCCGEEEIIIYQQQgghhiEJBAohhBBCCCFEmt1///2MGzcOt9vNggULWLVqVboPSQghhBBCCCHEMCCBQCGEEEIIIYRIo6eeeopbbrmFn/70p3z88cfMmTOH8847j7q6unQfmhBCCCGEEEKIIU4CgUIIIYQQQgiRRvfeey833HAD1113HTNmzOCBBx4gKyuLhx9+uMvbh0IhvF5vpzchhBBCCCGEEKIrEggUQgghhBBCiDQJh8OsWbOGxYsXxz+mqiqLFy9mxYoVXX7NXXfdRX5+fvxt9OjRqTpcIYQQQgghhBBDjAQChRBCCCGEECJN6uvr0TSN8vLyTh8vLy+npqamy6/58Y9/TEtLS/xt//79qThUIYQQQgghhBBDkD3dByCEEEIIIYQQou9cLhculyvdhyGEEEIIIYQQYgiQQGAKGYYBIDM8hBBCCCGE6IK1TrbWzceCkpISbDYbtbW1nT5eW1tLRUVFn+5DrjOEEEIIIYTo3rF4nSFERxIITKHW1lYAmeEhhBBCCCFED1pbW8nPz0/3YaSE0+lk/vz5LF26lMsuuwwAXddZunQpN910U5/uQ64zhBBCCCGE6N2xdJ0hREcSCEyhyspK9u/fT25uLoqiJPS+vV4vo0ePZv/+/eTl5SX0vkV6yDkdXuR8Dj9yTocXOZ/Dj5zTockwDFpbW6msrEz3oaTULbfcwpe//GVOOOEETjrpJH7zm9/g9/u57rrr+vT1cp0h+kPO6fAi53P4kXM6vMj5HH7knA5Nx+p1hhAWCQSmkKqqjBo1KqmPkZeXJ3+Ehhk5p8OLnM/hR87p8CLnc/iRczr0HIsZup/73Oc4fPgwt912GzU1NcydO5clS5ZQXl7ep6+X6wwxEHJOhxc5n8OPnNPhRc7n8CPndOg5Fq8zhLBIIFAIIYQQQggh0uymm27qcytQIYQQQgghhBCir9R0H4AQQgghhBBCCCGEEEIIIYQQIvEkEDhMuFwufvrTn+JyudJ9KCJB5JwOL3I+hx85p8OLnM/hR86pEIkhz6XhR87p8CLnc/iRczq8yPkcfuScCiGGIsUwDCPdByGEEEIIIYQQQgghhBBCCCGESCypCBRCCCGEEEIIIYQQQgghhBBiGJJAoBBCCCGEEEIIIYQQQgghhBDDkAQChRBCCCGEEEIIIYQQQgghhBiGJBAohBBCCCGEEEIIIYQQQgghxDAkgUAhhBBCCCGEEEIIIYQQQgghhiEJBB5j2tra0n0IQogeRKPRdB+CSCCfz5fuQxAJVlVVxYEDBwDQNC3NRyMSYePGjbz33nvpPgwhhjy5zhAis8l1xvAi1xnDj1xnDD9ynSGEyCQSCDxGRCIRvvnNb/KZz3yGa6+9lg8//BDDMNJ9WCJB5FwOfeFwmFtvvZUbb7yRW265hd27d6f7kMQghMNhvvOd73DZZZfxmc98hqeeekqep8PACy+8wPjx47npppsAsNlsaT4iMRjhcJivfe1rzJ49m2XLlqX7cIQYsuQ6Y3iTczn0yXXG8CLXGcOTXGcML3KdIYTIRBIIPAbU1NSwYMEC1q9fzyWXXML69ev5xje+wS9/+UsAdF1P8xGK/opEIvzqV7/iueeeA0BRlDQfkRiMZ555hvHjx7N69WpGjRrFU089xTe+8Q2WL1+e7kMTA/D3v/+dcePGsXHjRr785S/T2trKfffdx2uvvZbuQxODtGrVKhYsWMD+/ft59tlnAcnWHap+//vfU1RUxJYtW/jkk0/46U9/mu5DEmJIkuuM4UeuM4YXuc4YXuQ6Y/iS64zhQ64zhBCZSgKBx4APPviAcDjM008/zbe+9S3eeecdLr/8cn7605+yadMmVFWVDLIh5NVXX2XOnDnceuutPPvss1RXVwOSrTtUrV27lr/+9a985zvfYdmyZdx+++2sXLmSnTt3snfv3nQfnuin7du38+KLL3Lrrbfy1ltv8aUvfYmHHnqI3bt3Y7fb0314YoCsjeyWlhZOPPFE5s2bx3333UckEsFms8nr7xCzbds2br31Vi666CI++OAD5syZw65du6ivryccDqf78IQYUuQ6Y3iR64zhRa4zhhe5zhie5DpjeJHrDCFEJpNA4DBmLSgOHz5MU1MTI0eOBCA/P5+vf/3rLFq0iK9//euAZHoOFX6/n+eee45zzjmHn//852zbto0XXngBkHM4VIXDYWbMmMG1114LmFnYo0aNorCwkC1btqT56ER/lZaW8sMf/pCvfOUr8Y81NDQwZ84ccnJyCIVC6Ts4MWDWRvbOnTv54he/yOX/n707D4+izN4G/FR3p7MnECAENAIKoggI4oiACI7IqiMuKOAIKMKoMArMqIOfIosOKqKA+oNhVBAFddxwRwIuMENEQKKCiiKrSEAJSZPupJeq9/uju6r3bIR0VeW5r6svSHd18iZFkzp93nPONdfg2LFjWLx4MQD/65aMo23btrjvvvvw3//+Fz/88ANGjRqFYcOGoXfv3hg+fDjWrVuX6CUS6R7jDPNhnGE+jDPMhXGGOTHOMBfGGUSkZ0wEmswbb7yBdevW4fDhw7BY/KfXarUiLy8vbEBtXl4e/vGPf2DLli0oKCgAwJ2eRpCWloZx48bhzjvvxD/+8Q+cccYZ+Oijj/DNN98AYPslI1Bfo+oO64suughPPPEEWrduDQBISkpCWVkZnE4n+vTpk8ilUg2E/p8LAE2bNsVFF12EJk2aAAAmT56Miy66CEePHsVVV12Fa6+9lsPCdS7ynAL+tjySJMFqtcLtduPiiy/GNddcg+effx5//vOf8eSTT/LNFx2LPKfJyckYN24cMjIy0KlTJ6SlpWHBggWYOXMmPB4P7rvvPmzZsiXBqybSH8YZ5sY4w/gYZ5gL4wzzYZxhPowziMhQBJnCihUrRG5urrjoootEixYtRJ8+fcSbb74phBDiq6++Ep06dRKPPvqocLvd2nOKi4vFn/70J3HzzTcnatlUjddff10UFBSIX3/9Nebja9euFd27dxczZ84UiqI08OqoNmK9Rt9++20hhBCKoghZlrVj9+3bJzp06CB2796doNVSdao6n6HncuTIkWLNmjWivLxc/O9//xMjRowQvXr1StCqqSpVnVMhhCgpKRF5eXna79GpU6eKlJQUkZqaKrZu3ZqgVVNVYp3Tt956SwghhNvtFqtXrxZz5swRZWVl2nO+/PJL8cc//lFMmjQpUcsm0h3GGebEOMM8GGeYC+MM82GcYT6MM4jIiFgRaHA+nw8LFy7E3Llz8c9//hMbN27E6tWrcdZZZ+G5555DRUUFunfvjksuuQRvvfVW2FDwli1bIikpSdvRS/rx0ksvoWXLlpg3bx5Gjx6NESNGYPXq1QD8u3FFYFf1FVdcgV69euHTTz/FJ598AoA7rvWmqtfo0qVL4Xa7IUlS2Aydzz77DAC03bsAUFJSkojlU4SanE+LxQKfzwcAWLVqFQYNGoT09HT07t0bHTt2RGVlpbZTmxKvJucUACoqKtCvXz+89dZb6Nq1K1566SUMGDAAbdq00aokZFlO5LdCAVWd03//+9+orKyE3W7HH//4R0yZMgVZWVnac//whz9AlmVUVlYm8Dsg0gfGGebEOMM8GGeYC+MM82GcYT6MM4jIyBiZGZzT6cRvv/2GsWPH4pZbboHdbkfv3r3RqVMnOBwObRjtrFmz4PV6sXTpUhw6dEh7fkVFBXJychK1fIpQ04t/SZK0C8K//vWvqKysxDvvvAOn0wkhBH788ccEfyekqu41qgZyQHD+yurVqzFs2DCkpqaiqKgIAwcOxJw5c/jmiw7U9HzabDYIIcJm6siyjJ9//hkXXnhh2JsvlFjVnVN1Locsy/jPf/6DMWPG4NJLL8VPP/2Exx57DG3btsW0adMA+FvkUeLV9HWamZmJjIyMsOceO3YMDocD7du3T8TSiXSFcYa5MM4wH8YZ5sI4w3wYZ5gP4wwiMjJbohdAtffTTz+hffv2kCQJ2dnZuP7669GlSxdYLBYoigKLxYL8/Hw4nU6kpqYC8M/quP/++7Fo0SL06dMHd911F4qKirB161ZMnz49wd8RqSIvKiwWC3r37o2NGzfivffeg8/nQ3JyMoDgUOlzzjkH11xzDd555x08/PDDWLt2LSwWC7744gteLCZIbV6jSUlJYc91Op1wOBzo2bMn7rzzTixduhQjR47E448/HhbsUcOp6/lUz1dFRQVKSkowc+ZMfPXVV1iyZAkARAXw1HBqc07tdjsAID8/H6+88gratWuHiy66CADQpEkTDB8+HCdOnNDeQOM5TYy6nNNQlZWVOH78OB544AEAwHXXXdfQ3wKRLjDOMC/GGebAOMNcGGeYD+MM82GcQUSm0dC9SKnuXnvtNdG2bVvRsWNHcdFFF4nnnnsu7PHQfvGjR48W48aNE0KIsHkdv/zyi5g4caIYPny4GDp0qPjhhx8aZvEU148//hg2d2P79u3C5/MJIYLndOXKlaJbt25h5zL08S1btoikpCQhSZKYOHFi1HHUMOr6GvV6vdr9RUVFQpIkIUmSuPjii8V3333XMIunKHU9n+rrVwgh3nzzTXHXXXeJli1biv79+4uffvqpYRZPMdX1nHo8nqjPpf6/HXq+qeHVx+v0tddeE7fffrto1qyZ6N+/v/j5558bZvFEOsI4w5wYZ5gH4wxzYZxhPowzzIdxBhGZDROBBrF27VrRtm1b8eyzz4o1a9aIadOmiaSkJLF06VJRUVEhhPBfLCiKIioqKkTXrl3FSy+9FPfzqc+hxKmPYE4IIRYvXiwkSRIDBw7kRUUC1ddrdMOGDaJ///6ioKCgob8FClFf53Pnzp3iiSeeEOvWrWvob4Ei1Nc5ZUCuH/V1Tr/55hsxZ84c8fHHHzf0t0CkC4wzzIdxhrkwzjAXxhnmwzjDfBhnEJEZMRGoc+pOoFmzZokePXqE7Ra68847xYUXXijeeuutsOccOnRItG3bVvz4449CCP9O0KlTpzbcoqla9fmGy9dffy1ee+21hlw+haiv1+iUKVMabtEUF8+n+fD3qPnwdUpUP/j/ozkxzjAP/r4zF55P8+HvUfPh65SIzMyS6NakVDW1B/h3332Hs846C0lJSdpA4YcffhgpKSl45513UFxcrD1n3bp1yM/PR6tWrXD33XejU6dO2L9/P7xeL4eAJ5j68y8sLESzZs0wYcIEDBo0CPPnz8eECROwdOlSfPTRRwD8516SJJSUlGizHAB/f3J1YDQAdO3aFTfccEPDfzMEoP5eowcOHIDX64WiKAn5Psivvs8n/89NPP4eNR++TonqB/9/NBfGGebDOMNceP1iPvw9aj58nRKRmTERqDMFBQW46667sGDBAnz55Zfa/Zdffjk++ugjyLKs/SJq2rQpxowZg8LCQvzwww8A/AHg+++/jx07dqBt27ZYv349CgsL8eabbyIpKYnDhROMF4rGd6pfoxYL/1tuSPw/13x4Ts2H55SofvC1ZG6MM4yPcYa58P9c8+E5NR+eUyJqTHglqBOHDx/GVVddhT//+c8oKSnBCy+8gIEDB2q/iPr164esrCzMmjULQHDH54QJE+BwOFBUVAQAqKioQEVFBdLT0/Hss89ix44duPDCCxPyPREvKsyEr1Fz4fk0H55T8+E5JaoffC2ZE+MM8+Br1Fx4Ps2H59R8eE6JqFE61b1HqXpOp1OMHTtW3HjjjWLPnj3a/RdddJE2uN3hcIiHH35YpKamigMHDgghgr2r+/XrJ2677TbteVu3bm3A1VMsv/76q7jyyitFbm6uuOmmm0SXLl1Edna22Lx5sxBCiF27donTTjtNPPjgg0IIIdxut/bcvLw88dRTTwkh/P82rrzySnH66aeLV199tcG/D/Lja9RceD7Nh+fUfHhOieoHX0vmwzjDXPgaNReeT/PhOTUfnlMiaqxYEagDaWlpSE5Oxrhx49CuXTv4fD4AwNChQ/H9999DCIHMzEyMHj0aF1xwAW644Qbs378fkiThwIEDOHr0KIYPH659vh49eiToOyEAcLlcmD59OtLT0/HFF1/g5ZdfxjfffIOOHTti8eLFAIBWrVrhjjvuwBNPPIGDBw/CbrdrO4w6duyInTt3AvD/25g5cyYOHjyIG2+8MWHfU2PH16i58HyaD8+p+fCcEtUPvpbMhXGG+fA1ai48n+bDc2o+PKdE1FhJQrD5vx54vV4kJSUBABRFgcViwU033YT09HQsXbpUO+7QoUPo378/fD4fLrzwQmzatAnnnHMOVq1ahZYtWyZq+RThL3/5C6655hoMHjwYPp8PNpsNs2bNwkcffYTCwkJIkoS9e/fi5ptvhizLePXVV9GmTRscOHAAgwcPxrx58zBs2LBEfxsUgq9Rc+H5NB+eU/PhOSWqH3wtmQvjDPPha9RceD7Nh+fUfHhOiagxYiJQxy655BJMmDABY8eOhaIoAACLxYLdu3dj27Zt2Lx5M84//3yMHTs2wSulSLyoaBz4GjUXnk/z4Tk1H55TovrB15JxMc5oHPgaNReeT/PhOTUfnlMiMjsmAnVqz5496N27Nz744AOtzNzj8cButyd4ZVRXvKgwF75GzYXn03x4Ts2H55SofvC1ZD6MM8yFr1Fz4fk0H55T8+E5JaLGgDMCdUbNy/73v/9FRkaG9gto1qxZuPvuu3H06NFELo/qaM+ePdi9ezc6d+4MwB+Yq33I27dvjxtvvBFPPvkkg3MD4GvUXHg+zYfn1Hx4TonqB19L5sQ4wzz4GjUXnk/z4Tk1H55TImpMbIleAIWTJAkA8OWXX+K6665DQUEBJk6cCJfLhZdeegm5ubkJXiHVhhACkiTFvKgoLi7GrFmzeE4Nhq9Rc+H5NB+eU/PhOSWqH3wtmQvjDPPha9RceD7Nh+fUfHhOiagxYWtQHaqsrESXLl3w888/w263Y9asWbjvvvsSvSw6CZMnT0Z6ejoGDBgQdlExcODARC+N6oCvUXPh+TQfnlPz4Tklqh98LZkP4wxz4WvUXHg+zYfn1Hx4TomosWAiUKeuuOIKdOjQAU8++SRSUlISvRw6CbyoMCe+Rs2F59N8eE7Nh+eUqH7wtWQejDPMia9Rc+H5NB+eU/PhOSWixoCJQJ2SZRlWqzXRy6B6wosK8+Fr1Fx4Ps2H59R8eE6J6gdfS+bCOMN8+Bo1F55P8+E5NR+eUyJqDJgIJGoAvKggIiIiIqL6xjiDiIiIiIiqw0QgERERERERERERERERkQlZEr0AIiIiIiIiIiIiIiIiIqp/TAQSERERERERERERERERmRATgUREREREREREREREREQmxEQgERERERERERERERERkQkxEUhERERERERERERERERkQkwEEhEREREREREREREREZkQE4FEREREREREREREREREJsREIBEREREREREREREREZEJMRFIREREREREREREREREZEJMBBIRNSLLly+HJEnYt29fopdSI/v27YMkSVi+fHm1x44bNw5t27Y95Ws6GTNnzoQkSWH3tW3bFuPGjUvMgoiIiIiIwDghkdq2bYsrr7wy0cvQPUmSMHPmzEQvg4iIyJCYCCQiIgqhvqnwxBNPxHxcTeb9/vvvDbwyIiIiIiJKNIfDgVmzZuH8889HRkYGUlNT0blzZ9x333349ddfE728Omnbti0kScKAAQNiPv7vf/8bkiRBkiRs3bq1gVdHREREJ8uW6AUQEVHDufnmmzFy5EgkJycneik10qZNG1RUVCApKSnRSyEiIiIiMi3GCTWzZ88eDBgwAAcOHMCIESMwceJE2O12fPPNN3j++efx9ttv48cff2zQNdWXlJQUfPrppyguLkZeXl7YYytXrkRKSgoqKysTtDoiIiI6GawIJCJqRKxWK1JSUqLaU+qVJElISUmB1WpN9FKIiIiIiEyLcUL1fD4frr32Whw5cgSfffYZXnnlFUyaNAkTJkzA008/jT179mDEiBENtp7a8Pl88Hg8VR7Tp08fZGRk4LXXXgu7/5dffsHGjRsxbNiwU7lEIiIiOoWYCCQi0rF48ywiZ81JkoTJkydj9erV6Ny5M5KTk3HeeedhzZo1Yc+LNftDCIGHH34Yp59+OtLS0nDZZZdh586dUbPrYs23i/c5AeCjjz5C3759kZ6ejszMTAwbNgw7d+6s1fcfb/aH+n2mpKSgc+fOePvtt2v1eevbxo0bMWLECJxxxhlITk5Gfn4+pk6dioqKijp9PvVNhJycHKSlpeHiiy/GBx98oD0uhEDz5s0xbdo07T5FUdCkSRNYrVaUlpZq9z/22GOw2WwoLy/X7vvhhx9w/fXXIycnBykpKbjwwgvx7rvvRq2jtLQUU6ZMQX5+PpKTk9G+fXs89thjUBRFOya0lerSpUtx1llnITk5GX/4wx+wZcuWOn3/RERERBRfTWMEgHFCfcYJb775Jr7++mv8v//3/3DJJZdEPZ6VlYVHHnkEAPDQQw8hKSkJv/32W9RxEydORJMmTaKq69auXYtu3bohJSUFnTp1wltvvRX13Npeny9YsEC7Pv/uu++q/P5SUlJw7bXXYtWqVWH3v/LKK2jatCkGDRoU83mffPKJdj6bNGmCq6++Gt9//33YMeq/kd27d2PcuHFo0qQJsrOzccstt8DlcoUd63a7MXXqVLRo0QKZmZn405/+hF9++SXq6+7fvx933nknOnbsiNTUVDRr1gwjRowI+/e2Z88eSJKEp556Kur5mzZtgiRJeOWVV6r8uRAREZkBW4MSEZnEf//7X7z11lu48847kZmZiUWLFuG6667DgQMH0KxZs7jPmzFjBh5++GEMHToUQ4cOxVdffYWBAwdWu2O0Ki+99BLGjh2LQYMG4bHHHoPL5cLixYtxySWXYPv27THfuKiptWvX4rrrrkOnTp0wd+5cHDt2DLfccgtOP/30qGOPHz8OWZar/ZxpaWlIS0sLu8/lcsWcAxgZqALA66+/DpfLhTvuuAPNmjXDl19+iaeffhq//PILXn/99Vp8d8CRI0fQu3dvuFwu3HXXXWjWrBlefPFF/OlPf8Ibb7yBa665BpIkoU+fPtiwYYP2vG+++QZlZWWwWCz43//+p+3Y3bhxI7p3746MjAwAwM6dO9GnTx+cdtpp+Mc//oH09HT85z//wfDhw/Hmm2/immuu0b7Pfv364dChQ/jLX/6CM844A5s2bcL06dNx+PBhLFiwIGzdq1atwokTJ/CXv/wFkiTh8ccfx7XXXos9e/awtSsRERFRAjFOqJ84Qd04d/PNN1f7vJtvvhmzZ8/Ga6+9hsmTJ2v3ezwevPHGG7juuuuQkpKi3f/TTz/hxhtvxO23346xY8di2bJlGDFiBNasWYMrrrgCQO2vz5ctW4bKykpMnDgRycnJyMnJqXbdo0ePxsCBA/Hzzz/jrLPOAuC/zr/++utjXtOvW7cOQ4YMwZlnnomZM2eioqICTz/9NPr06YOvvvoq6nzecMMNaNeuHebOnYuvvvoKzz33HHJzc/HYY49px9x22214+eWXMXr0aPTu3RuffPJJzGrELVu2YNOmTRg5ciROP/107Nu3D4sXL0b//v3x3XffIS0tDWeeeSb69OmDlStXYurUqWHPX7lyJTIzM3H11VdX+3MhIiIyPEFERLo1duxY0aZNm6j7H3roIRH6XzgAYbfbxe7du7X7vv76awFAPP3009p9y5YtEwDE3r17hRBCHD16VNjtdjFs2DChKIp23P333y8AiLFjx8b9mvE+54kTJ0STJk3EhAkTwo4rLi4W2dnZUfdXZe/evQKAWLZsmXZft27dRKtWrURpaal239q1awWAqJ9VmzZtBIBqbw899FDU16zu9ttvv2nPcblcUWufO3eukCRJ7N+/X7sv1s+wTZs2YT/nKVOmCABi48aN2n0nTpwQ7dq1E23bthWyLAshhJg3b56wWq3C4XAIIYRYtGiRaNOmjbjooovEfffdJ4QQQpZl0aRJEzF16lTtc11++eWiS5cuorKyUrtPURTRu3dv0aFDB+2+OXPmiPT0dPHjjz+Grfcf//iHsFqt4sCBA2E/r2bNmomSkhLtuHfeeUcAEO+9917Uz4aIiIiI6q6mMYIQjBPqM07o3r27yM7OrvEae/XqJXr27Bl231tvvSUAiE8//TRqLW+++aZ2X1lZmWjVqpXo3r27dl9tr8+zsrLE0aNHa7TWNm3aiGHDhgmfzyfy8vLEnDlzhBBCfPfddwKA+Pzzz7XzuWXLFu153bp1E7m5ueLYsWPafV9//bWwWCxizJgx2n3qv5Fbb7017Otec801olmzZtrHRUVFAoC48847w44bPXp01PmIFYMVFhYKAGLFihXaff/6178EAPH9999r93k8HtG8efOwf8dERERmxtagREQmMWDAAG3XJgB07doVWVlZ2LNnT9znrFu3Dh6PB3/961/D2vlMmTKlzusoKChAaWkpRo0ahd9//127Wa1W9OzZE59++mmdP/fhw4dRVFSEsWPHIjs7W7v/iiuuQKdOnaKOX7lyJQoKCqq9jRkzJuq5EydOjHlsrB3Aqamp2t+dTid+//139O7dG0IIbN++vVbf44cffoiLLroorN1QRkYGJk6ciH379mktffr27QtZlrFp0yYA/sq/vn37om/fvti4cSMAYMeOHSgtLUXfvn0BACUlJfjkk09www034MSJE9q5OXbsGAYNGoSffvoJhw4dAuCvcuzbty+aNm0adh4HDBgAWZbDqhEB4MYbb0TTpk21j9WvWdW/PyIiIiI69Rgn1E+c4HA4kJmZWeM1jRkzBps3b8bPP/8c9nXz8/PRr1+/sGNbt26tdeYA/G1Gx4wZg+3bt6O4uBhA7a/Pr7vuOrRo0aLG6wX8syJvuOEGrV2mul712j6U+jMfN25cWLVh165dccUVV+DDDz+Mes7tt98e9nHfvn1x7NgxOBwOANCec9ddd4UdF+vfXWgM5vV6cezYMbRv3x5NmjTBV199pT12ww03ICUlBStXrtTu+/jjj/H777/jz3/+c9yfBRERkZmwNWgCbNiwAfPmzcO2bdtw+PBhvP322xg+fHitPocQAvPnz8fSpUuxf/9+NG/eHHfeeSf+3//7f6dm0USke2eccUbUfU2bNsXx48fjPmf//v0AgA4dOoTd36JFi7CkTm389NNPAIA//vGPMR/Pysqq0+cF4q8XADp27BgW8AH+gfd11aFDBwwYMCDq/v/+979R9x04cAAzZszAu+++G/XzLisrq9XX3b9/P3r27Bl1/7nnnqs93rlzZ1xwwQVIS0vDxo0bMWjQIGzcuBGzZs1CXl4enn76aVRWVmoJQTWpuHv3bggh8OCDD+LBBx+M+fWPHj2K0047DT/99BO++eabuG8eHD16NOzjyH9/6r+fqv79EREREdGpxzihfuKE6pKnkW688UZMmTIFK1euxIwZM1BWVob3338fU6dOjZqp2L59+6j7zj77bAD+mX95eXm1vj5v165djdcaavTo0Vi0aBG+/vprrFq1CiNHjow5A1L9mXfs2DHqsXPPPRcff/wxnE4n0tPTtfurihmysrKwf/9+WCyWsMR1vK9RUVGBuXPnYtmyZTh06BCEENpjoTFYkyZNcNVVV2HVqlWYM2cOAH+C87TTTov7b5GIiMhsmAhMAKfTifPPPx+33norrr322jp9jrvvvhtr167FE088gS5duqCkpAQlJSX1vFIiSrRYAReAmPMsrFZrzGNDA6KGWIs6qP6ll15CXl5e1PE2W8P96vntt99qNPsjIyNDm6FXW7Is44orrkBJSQnuu+8+nHPOOUhPT8ehQ4cwbtw47edR35KSktCzZ09s2LABu3fvRnFxMfr27YuWLVvC6/Vi8+bN2LhxI8455xztzQJ1LX//+98xaNCgmJ+3ffv22rFXXHEF7r333pjHqW9MqE71vz8iIiIi8qtNjAAwToilLnHCOeecg+3bt+PgwYPIz8+v9rlNmzbFlVdeqSUC33jjDbjd7jpXodX2+jy0Yq42evbsibPOOgtTpkzB3r17MXr06Dp9nljq89/iX//6VyxbtgxTpkxBr169kJ2dDUmSMHLkyKgYbMyYMXj99dexadMmdOnSBe+++y7uvPNOWCxslEZERI0DE4EJMGTIEAwZMiTu4263G//v//0/vPLKKygtLUXnzp3x2GOPoX///gCA77//HosXL8aOHTu0XVF13elFRPrWtGlTlJaWRt2v7r48WW3atAHg35175plnavf/9ttvUTuE1d2apaWlaNKkSdy1qLs3c3NzY1bU1dd6I+3atSvqvj/84Q81+lk99NBDmDlzZp3W9O233+LHH3/Eiy++GNY6qKCgoE6fr02bNjG/lx9++EF7XNW3b1889thjWLduHZo3b45zzjkHkiThvPPOw8aNG7Fx40ZceeWV2vHqOU5KSqr23Jx11lkoLy+v93NIRERERCfnVMcIAOMEVWiccNVVV+GVV17Byy+/jOnTp9doXWPGjMHVV1+NLVu2YOXKlejevTvOO++8qOPUzh2hSdUff/wRANC2bVsADXt9PmrUKDz88MM499xz0a1bt5jHqD/zeLFL8+bNw6oBa6JNmzZQFAU///xzWBVgrK/xxhtvYOzYsZg/f752X2VlZczXxuDBg9GiRQusXLkSPXv2hMvlijnygYiIyKy49UWHJk+ejMLCQrz66qv45ptvMGLECAwePFi7oH3vvfdw5pln4v3330e7du3Qtm1b3HbbbawIJDKhs846C2VlZfjmm2+0+9SWwvVhwIABSEpKwtNPPx22C3PBggUx1wIgbPaE0+nEiy++GHbcoEGDkJWVhX/+85/wer1Rn+e3336r83pbtWqFbt264cUXXwxr91JQUKDNzgt1MjMCa0rd1Rr68xNCYOHChXX6fEOHDsWXX36JwsJC7T6n04mlS5eibdu2YTNO+vbtC7fbjQULFuCSSy7R3jjo27cvXnrpJfz6669h8zxyc3PRv39//Otf/8Lhw4ejvnboubnhhhtQWFiIjz/+OOq40tJS+Hy+On1/RERERHRyTnWMADBOiBUnXH/99ejSpQseeeSRsGt11YkTJ6LGtQwZMgTNmzfHY489hs8//zxuNeCvv/4adv4cDgdWrFiBbt26adWTDXl9ftttt+Ghhx4KS7JFCv2ZhybfduzYgbVr12Lo0KG1/rrqpvlFixaF3R/r353Vao2qJHz66adjVnrabDaMGjUK//nPf7B8+XJ06dIFXbt2rfX6iIiIjIoVgTpz4MABLFu2DAcOHEDr1q0B+Fu4rVmzBsuWLcM///lP7NmzB/v378frr7+OFStWQJZlTJ06Fddffz0++eSTBH8HRFSfRo4cifvuuw/XXHMN7rrrLrhcLixevBhnn3121JyLumjRogX+/ve/Y+7cubjyyisxdOhQbN++HR999BGaN28eduzAgQNxxhlnYPz48bjnnntgtVrxwgsvoEWLFjhw4IB2XFZWFhYvXoybb74ZF1xwAUaOHKkd88EHH6BPnz545pln6rzmuXPnYtiwYbjkkktw6623oqSkBE8//TTOO+88lJeXhx17MjMCa+qcc87BWWedhb///e84dOgQsrKy8Oabb9Z5Nt4//vEPvPLKKxgyZAjuuusu5OTk4MUXX8TevXvx5ptvhrWv6dWrF2w2G3bt2oWJEydq91966aVYvHgxAIQlAgHg2WefxSWXXIIuXbpgwoQJOPPMM3HkyBEUFhbil19+wddffw0AuOeee/Duu+/iyiuvxLhx49CjRw84nU58++23eOONN7Bv376ofyNEREREdOqd6hgBYJwQS1JSEt566y0MGDAAl156KW644Qb06dMHSUlJ2LlzJ1atWoWmTZvikUceCXvOyJEj8cwzz8BqtWLUqFExP/fZZ5+N8ePHY8uWLWjZsiVeeOEFHDlyBMuWLdOOacjr8zZt2tSoY8q8efMwZMgQ9OrVC+PHj0dFRQWefvppZGdn16njSrdu3TBq1Cj83//9H8rKytC7d2+sX78eu3fvjjr2yiuvxEsvvYTs7Gx06tQJhYWFWLduHZo1axbzc48ZMwaLFi3Cp59+iscee6zWayMiIjIyJgJ15ttvv4Usy1G93d1ut3YxoygK3G43VqxYoR33/PPPo0ePHti1a1fMIcpEZEzNmjXD22+/jWnTpuHee+9Fu3btMHfuXPz000/1FuQ//PDDSElJwZIlS/Dpp5+iZ8+eWLt2LYYNGxZ2XFJSEt5++23ceeedePDBB5GXl4cpU6agadOmuOWWW8KOHT16NFq3bo1HH30U8+bNg9vtxmmnnYa+fftGHVtbgwcPxuuvv44HHngA06dPx1lnnYVly5bhnXfewWeffXZSn7sukpKS8N577+Guu+7C3LlzkZKSgmuuuQaTJ0/G+eefX+vP17JlS2zatAn33Xcfnn76aVRWVqJr16547733os5Jeno6unfvji1btuCSSy7R7leTf/n5+WGtRAGgU6dO2Lp1K2bNmoXly5fj2LFjyM3NRffu3TFjxgztuLS0NHz++ef45z//qW08ycrKwtlnn41Zs2YhOzu71t8bEREREZ28hogRAMYJsbRv3x5FRUV46qmn8Pbbb2P16tVQFAXt27fHbbfdhrvuuivqOWPGjMEzzzyDyy+/HK1atYr5eTt06ICnn34a99xzD3bt2oV27drhtddeC5vrrcfr8wEDBmDNmjV46KGHMGPGDCQlJaFfv3547LHH6jzCRk0ir1y5EqtXr8Yf//hHfPDBB1FzGRcuXAir1YqVK1eisrISffr0wbp16+LOQu/RowfOO+88fP/997jpppvqtDYiIiKjkkR9TYemOpEkCW+//TaGDx8OAHjttddw0003YefOnVFDlDMyMpCXl4eHHnooqpVGRUUF0tLSsHbtWlxxxRUN+S0QkUm1bdsW/fv3x/LlyxO9FCIiIiIi0gnGCbXz9ddfo1u3blixYgXn0iVY9+7dkZOTg/Xr1yd6KURERA2KFYE60717d8iyjKNHj0a1c1P16dMHPp8PP//8s9aLXx0iHVn5QUREREREREREifHvf/8bGRkZuPbaaxO9lEZt69atKCoqYgKbiIgaJSYCE6C8vDysv/nevXtRVFSEnJwcnH322bjpppswZswYzJ8/H927d8dvv/2G9evXo2vXrhg2bBgGDBiACy64ALfeeisWLFgARVEwadIkXHHFFVEtRYmI9Mjj8aCkpKTKY7Kzs5GamtpAKyIiIiIiokQzU5zw3nvv4bvvvsPSpUsxefJkpKenJ3pJjdKOHTuwbds2zJ8/H61atcKNN96Y6CURERE1OCYCE2Dr1q247LLLtI+nTZsGABg7diyWL1+OZcuW4eGHH8bf/vY3HDp0CM2bN8fFF1+MK6+8EgBgsVjw3nvv4a9//SsuvfRSpKenY8iQIZg/f35Cvh8iotratGlT2P+DsSxbtgzjxo1rmAUREREREVHCmSlO+Otf/4ojR45g6NChmDVrVqKX02i98cYbmD17Njp27IhXXnkFKSkpiV4SERFRg+OMQCIianDHjx/Htm3bqjzmvPPOQ6tWrRpoRURERERElGiME4iIiIjqHxOBRERERERERERERERERCbE1qANSFEU/Prrr8jMzIQkSYleDhERERGRrgghcOLECbRu3RoWiyXRyzEMxhlERERERPExzqDGjonABvTrr78iPz8/0csgIiIiItK1gwcP4vTTT0/0MgyDcQYRERERUfUYZ1BjxURgA8rMzATg/w8nKysrwashIiIiItIXh8OB/Px87bqZaoZxBhERERFRfIwzqLFjIrABqW16srKyGKATEREREcXB9pa1wziDiIiIiKh6jDOosWJDXCIiIiIiIiIiIiIiIiITYiKQiIiIiIiIiIiIiIiIyIQaZSJw8eLF6Nq1q9Y6p1evXvjoo4/iHr98+XJIkhR2S0lJacAVExEREREREREREREREdVOo5wRePrpp+PRRx9Fhw4dIITAiy++iKuvvhrbt2/HeeedF/M5WVlZ2LVrl/Yx+wkTERERERERERERERGRnjXKROBVV10V9vEjjzyCxYsX44svvoibCJQkCXl5ebX6Om63G263W/vY4XDUfrFEREREREREREREREREddAoW4OGkmUZr776KpxOJ3r16hX3uPLycrRp0wb5+fm4+uqrsXPnzmo/99y5c5Gdna3d8vPz63PpRERERERERERERERERHE12kTgt99+i4yMDCQnJ+P222/H22+/jU6dOsU8tmPHjnjhhRfwzjvv4OWXX4aiKOjduzd++eWXKr/G9OnTUVZWpt0OHjx4Kr4VIiIiIiIiIiIiIiIioiiSEEIkehGJ4PF4cODAAZSVleGNN97Ac889h88//zxuMjCU1+vFueeei1GjRmHOnDk1/poOhwPZ2dkoKytDVlbWySyfiIiIiMh0eL1cN/y5ERERERHFx+tlauwa5YxAALDb7Wjfvj0AoEePHtiyZQsWLlyIf/3rX9U+NykpCd27d8fu3btP9TKJiIiIiIiIiIiIiIiI6qTRtgaNpCgK3G53jY6VZRnffvstWrVqdYpXRURERNQ4CCFwoMINuXE2qyAiIiIiogRyyjKOuL2JXgYR0SnRKCsCp0+fjiFDhuCMM87AiRMnsGrVKnz22Wf4+OOPAQBjxozBaaedhrlz5wIAZs+ejYsvvhjt27dHaWkp5s2bh/379+O2225L5LdBREREZBoVisDeCjfSrVY0szfKS1QiIiIiIkqQ3z0+HKr0oGVyUqKXQkRU7xrluyxHjx7FmDFjcPjwYWRnZ6Nr1674+OOPccUVVwAADhw4AIslWCx5/PhxTJgwAcXFxWjatCl69OiBTZs21WieIBERERFVTxECHkXAx4pAIiIiIiJqYLLwb04kIjIjSQi+29JQOJSUiIiIKLYyrw//PV6O87PScHqKPdHLoQTh9XLd8OdGREREdHJ+clbiZ1clrmieDaskJXo5VM94vUyNHWcEEhEREVHCyQC8ghWBVD82bNiAq666Cq1bt4YkSVi9enXY45IkxbzNmzdPO6Zt27ZRjz/66KNhn+ebb75B3759kZKSgvz8fDz++ONRa3n99ddxzjnnICUlBV26dMGHH34Y9rgQAjNmzECrVq2QmpqKAQMG4Keffqq/HwYRERERVUuGYDxCRKbFRCARERERJZwsBLyK/0Z0spxOJ84//3w8++yzMR8/fPhw2O2FF16AJEm47rrrwo6bPXt22HF//etftcccDgcGDhyINm3aYNu2bZg3bx5mzpyJpUuXasds2rQJo0aNwvjx47F9+3YMHz4cw4cPx44dO7RjHn/8cSxatAhLlizB5s2bkZ6ejkGDBqGysrKefypEREREFI8iAK8AE4FEZEqNckYgEREREemLIgCPUOBl4E31YMiQIRgyZEjcx/Py8sI+fuedd3DZZZfhzDPPDLs/MzMz6ljVypUr4fF48MILL8But+O8885DUVERnnzySUycOBEAsHDhQgwePBj33HMPAGDOnDkoKCjAM888gyVLlkAIgQULFuCBBx7A1VdfDQBYsWIFWrZsidWrV2PkyJF1/hkQERERUc15FQWKEJAZjhCRCbEikIiIiIgSThYCigAqZCXRS6FG5siRI/jggw8wfvz4qMceffRRNGvWDN27d8e8efPg8/m0xwoLC3HppZfCbg/OtBw0aBB27dqF48ePa8cMGDAg7HMOGjQIhYWFAIC9e/eiuLg47Jjs7Gz07NlTOyYWt9sNh8MRdiMiIiKiuvMIAZmtQYnIpFgRSEREREQJJwNQAFQqTARSw3rxxReRmZmJa6+9Nuz+u+66CxdccAFycnKwadMmTJ8+HYcPH8aTTz4JACguLka7du3CntOyZUvtsaZNm6K4uFi7L/SY4uJi7bjQ58U6Jpa5c+di1qxZdfhuiYiIiCgWr+KfEygzEUhEJsREIBERERElnBLYgVvJGYHUwF544QXcdNNNSElJCbt/2rRp2t+7du0Ku92Ov/zlL5g7dy6Sk5Mbeplhpk+fHrY+h8OB/Pz8BK6IiIiIyNh8QoHCGYFEZFJsDUpERERECScLQABwywoEg29qIBs3bsSuXbtw2223VXtsz5494fP5sG/fPgD+OYNHjhwJO0b9WJ0rGO+Y0MdDnxfrmFiSk5ORlZUVdiMiIiKiuvMKwKcAXm5MJCITYiKQiIiIiBLOPyNQwAcBH2NvaiDPP/88evTogfPPP7/aY4uKimCxWJCbmwsA6NWrFzZs2ACv16sdU1BQgI4dO6Jp06baMevXrw/7PAUFBejVqxcAoF27dsjLyws7xuFwYPPmzdoxRERERHTq+RQFCgQ4qICIzIitQYmIiIgo4WQIKMJfGegVAkmQEr0kMrDy8nLs3r1b+3jv3r0oKipCTk4OzjjjDAD+hNvrr7+O+fPnRz2/sLAQmzdvxmWXXYbMzEwUFhZi6tSp+POf/6wl+UaPHo1Zs2Zh/PjxuO+++7Bjxw4sXLgQTz31lPZ57r77bvTr1w/z58/HsGHD8Oqrr2Lr1q1YunQpAECSJEyZMgUPP/wwOnTogHbt2uHBBx9E69atMXz48FP4EyIiIiIilRD+zYiyEKwIJCJTYiKQiIiIiBJOEYDNIkEWgnM56KRt3boVl112mfaxOk9v7NixWL58OQDg1VdfhRACo0aNinp+cnIyXn31VcycORNutxvt2rXD1KlTw+byZWdnY+3atZg0aRJ69OiB5s2bY8aMGZg4caJ2TO/evbFq1So88MADuP/++9GhQwesXr0anTt31o6599574XQ6MXHiRJSWluKSSy7BmjVromYWEhEREdGpIQtAgWAsQkSmJQkOYWkwDocD2dnZKCsr4xwPIiIiohBfO5z4+kQF7BYJVzTLRjM796s1Rrxerhv+3IiIiIjqzq0oWPN7GQ5XetG7SQa6ZqUleklUz3i9TI0dZwQSERERUcJ5BZBkkeDjLlwiIiIiImpAsvB3KEmySHALTgkkIvNhIpCIiExPUQSeLPgRn+06muilEFEcHkXAqv6diUAiIiIiImogihBQhECSJMHDGYFEZELsuURERKZX9EspFq3/CWe1SEf/jrmJXg4RxeATCqySBCgCPgbfRERERETUQGQh/BWBTAQSkUmxIpCIiEyvzOUFABwP/ElE+uMTgAQAEuBlRSARERERETUQGYACAZtFgkdha1AiMh8mAomIyPTK3T7/n5W+BK+EiOLxKoGKwMDfiYiIiIiIGoIiAAWAXZLgDbQJJSIyEyYCiYjI9FwefwLQIyuo9MoJXg0RRRJCwCcAiwTYJAmVbMdDREREREQNRA4k/2wWCQoAHxOBRGQyTAQSEZHplbvlkL+zKpBIb2Thb8UjAbBKEipZEUhERERERA1EgYAQgA3+2MTHPCARmQwTgUREZHqukOTfCbYHJdIdGQIK/ElAmwRWBBIRERERUYPxCQASYJEkKEJAZkUgEZkME4FERGR65Z5g8o9zAon0Rxb+uRwWBCoCZQWCwTcRERERETUARQgIAFbJ3yaUrUGJyGyYCCQiItNzhbQGPVHpTeBKiCgWJTCTwyJJsEoSZAi24yEiIiIiogahCGhjCmRwRiARmQ8TgUREZHrO0NagnBFIpDuyEP6KQMk/l8MnAC+DbyIiIiIiagAyBBDoUCILAZmhCBGZDBOBRERkek4PZwQS6ZkMQIGABRJsFgmyIuBVlEQvi4iIiIiIGgHZnweEJEkAuCmRiMzHlugFEBERnWrOkNag5WwNSqQ7shBQ4K8IlCDBBwEvY28iIiIiImoAihAI5AAB4Y9PiIjMhIlAIiIyPVYEEumbIgLBN4LteDiXg4iIiIiIGoJXEVrbPEmSGIsQkek0ytagixcvRteuXZGVlYWsrCz06tULH330UZXPef3113HOOecgJSUFXbp0wYcffthAqyUiopMVOiOwnDMCiXRHFgJCABZJYjseIiIiIiJqUF4hYAnEIQo3JRKRCTXKRODpp5+ORx99FNu2bcPWrVvxxz/+EVdffTV27twZ8/hNmzZh1KhRGD9+PLZv347hw4dj+PDh2LFjRwOvnIiI6iK0NaiDFYFEuiMDgBT8WALgUxh8ExERERHRqRdeEchYhIjMp1EmAq+66ioMHToUHTp0wNlnn41HHnkEGRkZ+OKLL2Iev3DhQgwePBj33HMPzj33XMyZMwcXXHABnnnmmQZeORER1YXLw4pAIj1TInbcCrAikIiIiIj065UvD+CTH44kehlUT7xQtIpAmyTBzUQgEZlMo0wEhpJlGa+++iqcTid69eoV85jCwkIMGDAg7L5BgwahsLCwys/tdrvhcDjCbkRE1PBCKwJPVHoTuBIiikUWgBRaEgjAqygJWg0RERERUXyHyyow/a1v8bf/fJ3opVA98SnBN8mtEpgIJCLTabSJwG+//RYZGRlITk7G7bffjrfffhudOnWKeWxxcTFatmwZdl/Lli1RXFxc5deYO3cusrOztVt+fn69rZ+IiGrG41PgkYMJhXK2BiXSHf+MwGCwbZMkVDD4JiIiIiIdKnF6AADHXV4ovGY1hdAZgRZI3JRIRKbTaBOBHTt2RFFRETZv3ow77rgDY8eOxXfffVevX2P69OkoKyvTbgcPHqzXz09ERNULbQsKACeYCCTSHRkCoUMCrZIEN4NvIiIiItIhlyfYccbllas4koxACOGfERgIR6ySBDfHFBCRydgSvYBEsdvtaN++PQCgR48e2LJlCxYuXIh//etfUcfm5eXhyJHwvt9HjhxBXl5elV8jOTkZycnJ9bdoIiKqNacnPDDjjEAi/VEEACm0IhCokJkIJCIiIiL9CY0pnW4fMpIb7durpqAAEBBhrUG9ir9jiSRJVT2ViMgwGm1FYCRFUeB2u2M+1qtXL6xfvz7svoKCgrgzBYmISD+cEYk/B2cEEumOV1FgDakItEkS3Ep4u1AiIiIiIj1wRiQCydhkIaAAwdagkgQZAj6GIkRkIo1yy8r06dMxZMgQnHHGGThx4gRWrVqFzz77DB9//DEAYMyYMTjttNMwd+5cAMDdd9+Nfv36Yf78+Rg2bBheffVVbN26FUuXLk3kt0FERDWgBmbJNgvcPgXlbh939hHpjEcEW/EA/nY8PiHgFQJ2vlaJiIiISEdc7mDXGaebrUGNThb+m11tDQrAIwCfEEgCYxEiModGmQg8evQoxowZg8OHDyM7Oxtdu3bFxx9/jCuuuAIAcODAAVgswWLJ3r17Y9WqVXjggQdw//33o0OHDli9ejU6d+6cqG+BiIhqSA3MWmal4ECJC0L424WyfQuRfngVRCQCgUoF/kRg4pZFRERERBQltDUoR08YnyIEFCFgkfzvBVslCYpQILM7CRGZSKN8F/T555+v8vHPPvss6r4RI0ZgxIgRp2hFRER0qjg9/sCsWYYdv5ZWwKcIlFdyjgORnviEAktEa1BZUeBThH9LLhERERGRToS2A3V5mAg0OhmAQHB+lkXyVwj6mAgkIhPhjEAiIjI1NUjLSLYhI8Wf/DvBOYFEuuIVkRWBEnwQ8DL2pjrasGEDrrrqKrRu3RqSJGH16tVhj48bNw6SJIXdBg8eHHZMSUkJbrrpJmRlZaFJkyYYP348ysvLw4755ptv0LdvX6SkpCA/Px+PP/541Fpef/11nHPOOUhJSUGXLl3w4Ycfhj0uhMCMGTPQqlUrpKamYsCAAfjpp5/q5wdBRERE9c7pCbYDZUWg8claRaD/YytnBBKRCTERSEREpqYGaWl2KzLVRCCDNSJd8SnhFYFWAAp34dJJcDqdOP/88/Hss8/GPWbw4ME4fPiwdnvllVfCHr/pppuwc+dOFBQU4P3338eGDRswceJE7XGHw4GBAweiTZs22LZtG+bNm4eZM2eGzRHftGkTRo0ahfHjx2P79u0YPnw4hg8fjh07dmjHPP7441i0aBGWLFmCzZs3Iz09HYMGDUJlZWU9/kSIiIiovoRXBHJGoNHJwl8VaAnMJvfHIoKtQYnIVNgXjYiITE0N0tKTbchITgJQgROVTAQS6YUQ/t22oRWBkiRBCAEvg2+qoyFDhmDIkCFVHpOcnIy8vLyYj33//fdYs2YNtmzZggsvvBAA8PTTT2Po0KF44okn0Lp1a6xcuRIejwcvvPAC7HY7zjvvPBQVFeHJJ5/UEoYLFy7E4MGDcc899wAA5syZg4KCAjzzzDNYsmQJhBBYsGABHnjgAVx99dUAgBUrVqBly5ZYvXo1Ro4cWV8/EiIiIqonoYlAJzeZGp42IzDwsSRJEABjESIyFVYEEhGRqbnURKDdplUEljMRSKQbsgAUiKiLUkmCf0Yg0Sny2WefITc3Fx07dsQdd9yBY8eOaY8VFhaiSZMmWhIQAAYMGACLxYLNmzdrx1x66aWw2+3aMYMGDcKuXbtw/Phx7ZgBAwaEfd1BgwahsLAQALB3714UFxeHHZOdnY2ePXtqx8TidrvhcDjCbkRERNQwnCFzAdka1PhkCAhIWkUg4J8ZyIpAIjITJgKJiMjUyt3+Vi3pyTZkJnNGIJHeyBBQgLDAGwB34dIpNXjwYKxYsQLr16/HY489hs8//xxDhgyBLPt/ZxQXFyM3NzfsOTabDTk5OSguLtaOadmyZdgx6sfVHRP6eOjzYh0Ty9y5c5Gdna3d8vPza/X9ExERUd053cF2oGwNanyyAPzRR5AEiWMKiMhU2BqUiIhMzeVRKwKDMwK5a5NIP2ThnwdokaIf8yhKwy+IGoXQlptdunRB165dcdZZZ+Gzzz7D5ZdfnsCV1cz06dMxbdo07WOHw8FkIBERUQMJjScZWxqfLPwVgeH84wuIiMyCFYFERGRq5aEzAgOJQAdbgxLphjaTI6IiMEmSUMFEIDWQM888E82bN8fu3bsBAHl5eTh69GjYMT6fDyUlJdpcwby8PBw5ciTsGPXj6o4JfTz0ebGOiSU5ORlZWVlhNyIiImoYrpDWoC4mAg1PEYAF0Vk/tgYlIjNhIpCIiExNbdWSnmxFZkoSAM4IJNITWYiYFYFWSUIlE4HUQH755RccO3YMrVq1AgD06tULpaWl2LZtm3bMJ598AkVR0LNnT+2YDRs2wOsNtpsuKChAx44d0bRpU+2Y9evXh32tgoIC9OrVCwDQrl075OXlhR3jcDiwefNm7RgiIiLSl9DWoOVutgY1OhkCkTk/qyTBLTMWISLzYCKQiIhMLawikDMCiXRHBqBAwBLRjscqAW6Zu3CpbsrLy1FUVISioiIAwN69e1FUVIQDBw6gvLwc99xzD7744gvs27cP69evx9VXX4327dtj0KBBAIBzzz0XgwcPxoQJE/Dll1/if//7HyZPnoyRI0eidevWAIDRo0fDbrdj/Pjx2LlzJ1577TUsXLgwrGXn3XffjTVr1mD+/Pn44YcfMHPmTGzduhWTJ08GAEiShClTpuDhhx/Gu+++i2+//RZjxoxB69atMXz48Ab9mREREVHNhLYDDa0OJGOSBRDZGdQKwK0wFiEi8+CMQCIiMrXgjEAbsjgjkEh3ZCGgILoi0CZJcCsCQghIUowBgkRV2Lp1Ky677DLtYzU5N3bsWCxevBjffPMNXnzxRZSWlqJ169YYOHAg5syZg+TkZO05K1euxOTJk3H55ZfDYrHguuuuw6JFi7THs7OzsXbtWkyaNAk9evRA8+bNMWPGDEycOFE7pnfv3li1ahUeeOAB3H///ejQoQNWr16Nzp07a8fce++9cDqdmDhxIkpLS3HJJZdgzZo1SElJOZU/IiIiIqqj0OSfk7Gl4SkidkWgR7AikIjMg4lAIiIyNbVtS+iMwBNsDUqkG4rwB9+RbSqskgSfEPAKATsTgVRL/fv3h6hirsvHH39c7efIycnBqlWrqjyma9eu2LhxY5XHjBgxAiNGjIj7uCRJmD17NmbPnl3tmoiIiCix3D4Z3pCuFdxkanxeRURtSrRIgIcVgURkImwNSkREpqbu0EyzW5GZ7J8ReILBGpFuyIEduJFVf1YJ8AnAW0Uyh4iIiIioITkjZgKqM+nJuGQhYImKRYLdSYiIzICJQCIiMjU1EZgRVhHIGYFEeiEDUTM5AH9rUFkR8HEnLhERERHpRGQrUFYEGp9bidGdBP455hxZTkRmwUQgERGZlqIIuLz+HZppyVZkqjMC2RqUSDeUOLtsrZIEHwS8DL6JiIiISCecnvBY0uWRWTVmcDKiKwItkgRZAD6eWyIyCSYCiYjItCq8sjb0O91uC7YGZSKQSDdkAUgxSgKtgccYfBMRERGRXqgVgc3S7QAAWRFw+5RELolOkjdWRaAkQRYCMmMRIjIJJgKJiMi01N2akgSkJgUrAiu8MnwygzUiPZCFgEB0gC1JEiAEPApfq0RERESkD+qMwBaZydp9bA9qbD4hYInYl2iVAIWbEonIRJgIJCIi01KDtLQkKywWSZsRCDBYI9ILGQIQMYYEwp8M9DH2JiIiIiKdUCsCM1NsSLNbAQCuQNxJxuQVApaIDiUWSJAhGIsQkWkwEUhERKalBmnpyf4EYJLVgpQk/68+tgcl0gdFAJBiR9gCAl7uwiUiIiIinVA3lKbZbUiz28LuI+NRAu0/Y1UEsjUoEZkJE4FERGRakYlAAMjgnEAiXfEqCqwxZgQCgBR4nIiIiIhID1wef/VfRrINGcmBikAPY0ujkgWgALBIERWBkgTB1qBEZCJMBBIRkWmpQVp6IEADgKxAe9ATld6ErImIwnli7MBV2SQJFUwEEhEREZFOlGubTa2sCDQBWQgoIvYb5EKS2J2EiEyDiUAiIjKt0LYtKnVOIIM1In3wKoibCLRKEiqZCCQiIiIinXCGxJgZgc4zTs4INCwZIlARGP2YBH+SkIjIDJgIJCIi01JbtGSEtAbN1CoCmQgk0gOfUGCJ0xrUKgFumdE3EREREelDaGtQtfOMk61BDUsRgBAibjzCikAiMgsmAomIyLTUnZlp9mBrUDUpeIIVgUS64BX+Hbi/VHrwk7My7DGbJMGtCCgMwImIiIhIB8pD5tCnaRWBjC2NShYCsojToUT4HyciMgMmAomIyLTUgCy8IjAJAGcEEumFT/FXBM7++Vc8uPsQTviCrZWskgQZAj4G4ERERESkA86QGYEZgREUapUgGY8sAAWxKwKtkgQPxxQQkUkwEUhERKbl9KgVgdGtQcvZGpQo4YQQ8AlAEQIlXhk+AZR4g69NmyTBqwi25CEiIiIiXVBjzHS7DWmB1qCcP29cCoQ/ERijItAiAW4OCSQik2AikIiITCtYERhsDZqZzBmBRHqh7sB1h+y0dcrBv1sl/zFeBuBERERkYC6PDxt+/A0eH6uLjM4Z0hpU7TzjYiLQsGThnxMY6w1yqyTBLfiaJSJzaJSJwLlz5+IPf/gDMjMzkZubi+HDh2PXrl1VPmf58uWQJCnslpKS0kArJiKiulCHtqfFaA3KXZtEiSdDQEH4TtvQRKAt0BqUFYFERERkZM98shtjXvgSb2z7JdFLoZMU2hpU7TxT7mZrUKNSZwBKUqzWoICHeUAiMolGmQj8/PPPMWnSJHzxxRcoKCiA1+vFwIED4XQ6q3xeVlYWDh8+rN3279/fQCsmIqK6CN2tqcpIUSsCOSOQKNHUHbiVYRWBETMCBTgjkIiIiAztQIkr7E8yLnWzqb8i0N95xslNpoblTwTG6AsKwALOCCQi87BVf4j5rFmzJuzj5cuXIzc3F9u2bcOll14a93mSJCEvL+9UL4+IiOqJS5vfENIaNIWtQYn0QhECihCoDKkILI/RMoutQYmIiMjI1NiDmxGNzxmo/stItmkbTtXkIBmPAkCKs+nQP6ZAQBYC1hgVg0RERtIoKwIjlZWVAQBycnKqPK68vBxt2rRBfn4+rr76auzcubPK491uNxwOR9iNiIgaTnmsikDOCCTSDVmIGBWB4YlACYCPeUAiIiIyMDUByBjE+NQYM80ebA3KikDjkoUA4iT5rJIEGexOQkTm0OgTgYqiYMqUKejTpw86d+4c97iOHTvihRdewDvvvIOXX34ZiqKgd+/e+OWX+P3d586di+zsbO2Wn59/Kr4FIiKKw+VWKwI5I5BIj2QACiIqAiMSgYIzAomIiMjgWBFoDl5ZgSfQvSIj2aZtMlU70ZDxyMIfb8RikcAxBURkGo0+EThp0iTs2LEDr776apXH9erVC2PGjEG3bt3Qr18/vPXWW2jRogX+9a9/xX3O9OnTUVZWpt0OHjxY38snIqIqlIcMcldlckYgkW7IQkBB/BmBgL8i0MvZHERERGRgwUQgNyMambrRFADS7DakBeJMbjI1LlkIxMkDwgoJihCQmQckIhNolDMCVZMnT8b777+PDRs24PTTT6/Vc5OSktC9e3fs3r077jHJyclITk4+2WUSEVEduTzRrUHVRGC52wchBCT2+idKGEX45wRWhFQBRlYE2iQp7HEiIiIio2FrUHNQZwHarRbYbRatIpCtQY1LFiJeZ1B/a1AhWBFIRKbQKCsChRCYPHky3n77bXzyySdo165drT+HLMv49ttv0apVq1OwQiIiqg/qIPdYMwK9soDbx+QCUSLJQkAIoCKkNWjkjECrJKGCFYFERERkULIi4Ay0jmRXEmNzRnScUeNMJ1uDGpZXEbDEyQRaJECG8FcNEhEZXKOsCJw0aRJWrVqFd955B5mZmSguLgYAZGdnIzU1FQAwZswYnHbaaZg7dy4AYPbs2bj44ovRvn17lJaWYt68edi/fz9uu+22hH0fREQUn8enwBNIKKTbg61B0+02SBIghH9HbkqSNd6nIKJTTAYACXDJ8VuDWiWEzRAkIiIiMpLykCrAE6wcM7Tg6An/26lqnOnxKfDKCpKsjbLewtC8QsStkrFKEhQhsSKQiEyhUf6GWrx4McrKytC/f3+0atVKu7322mvaMQcOHMDhw4e1j48fP44JEybg3HPPxdChQ+FwOLBp0yZ06tQpEd8CERFVQ20LCvjnN6gsFgkZds4JJNIDJRBUhyUCfdGtQT2Koh1LVBMbNmzAVVddhdatW0OSJKxevVp7zOv14r777kOXLl2Qnp6O1q1bY8yYMfj111/DPkfbtm0hSVLY7dFHHw075ptvvkHfvn2RkpKC/Px8PP7441Fref3113HOOecgJSUFXbp0wYcffhj2uBACM2bMQKtWrZCamooBAwbgp59+qr8fBhERJZQjJOYod/ugcIOTYbkClX/pgXgyNM4MnR9IxuEV8SsCAQBCwMvXLBGZQKNMBAohYt7GjRunHfPZZ59h+fLl2sdPPfUU9u/fD7fbjeLiYnzwwQfo3r17wy+eiIhqRG3Pos5vCBU6J5CIEkcWgAQpoiIwOhEowx+kE9WU0+nE+eefj2effTbqMZfLha+++goPPvggvvrqK7z11lvYtWsX/vSnP0UdO3v2bBw+fFi7/fWvf9UeczgcGDhwINq0aYNt27Zh3rx5mDlzJpYuXaods2nTJowaNQrjx4/H9u3bMXz4cAwfPhw7duzQjnn88cexaNEiLFmyBJs3b0Z6ejoGDRqEysrKev6pEBFRIoTOBRQiOGeOjKc8ojWo3WaBPVAFWM7zakg+JX5FoIpDCojIDBpla1AiIjK/yPkNoTJSbEBZeFBORA1PFgICImwGoEcIeBQFdos/JLdKEnyyAp8ikNwot7BRXQwZMgRDhgyJ+Vh2djYKCgrC7nvmmWdw0UUX4cCBAzjjjDO0+zMzM5GXlxfz86xcuRIejwcvvPAC7HY7zjvvPBQVFeHJJ5/ExIkTAQALFy7E4MGDcc899wAA5syZg4KCAjzzzDNYsmQJhBBYsGABHnjgAVx99dUAgBUrVqBly5ZYvXo1Ro4cedI/C2oc3D4Z2w+U4oIzmkZtgCKixIrsQnKi0ofMlKQErYZOhjOiNaj/71Z4XIr2GBmLvyKwmmNYEUhEJsAIgYiITEkNxELbtajUwJuJQKLEkiEAEV4RCIRXBVolf+UgKwLpVCorK4MkSWjSpEnY/Y8++iiaNWuG7t27Y968efD5gr83CgsLcemll8Jut2v3DRo0CLt27cLx48e1YwYMGBD2OQcNGoTCwkIAwN69e1FcXBx2THZ2Nnr27KkdE4vb7YbD4Qi7UeO2/H/7MHLpF1hRuC/RSyGiCJExB2MQ43JGtAYFgvEmE4HG5J8RGD8TKADOCCQiU2BFIBERmZIzMKMhIzn6V516H2cEEiWWIgBIIioRWC4raBrYKO9vDSqYCKRTprKyEvfddx9GjRqFrKws7f677roLF1xwAXJycrBp0yZMnz4dhw8fxpNPPgkAKC4uRrt27cI+V8uWLbXHmjZtiuLiYu2+0GOKi4u140KfF+uYWObOnYtZs2bV8TsmM9p3zAkA2PO7M8ErIaJIJ9yRFYGMQYwqVkWgGls6OSPQcBQhoAhUWRFokVgRSETmwEQgERGZkjp7Iy1Ga1DOCCTSB6+iwBoyI1CCf9et0xd8I8UqSZAFd+LSqeH1enHDDTdACIHFixeHPTZt2jTt7127doXdbsdf/vIXzJ07F8nJyQ291DDTp08PW5/D4UB+fn4CV0SJ5qjwX9OUuZhgINIbVgSah5oIzAiJMdVRFJz9aDyK8HcosUoSjnt9mL/vCAY2y8KlOZnaMTZJgltwSiARGR9bgxIRkSkFg7RYrUHVikAGa0SJ5BECCJkR2DTJ/0ZKeUSFoAB34lL9U5OA+/fvR0FBQVg1YCw9e/aEz+fDvn37AAB5eXk4cuRI2DHqx+pcwXjHhD4e+rxYx8SSnJyMrKyssBs1bmUV/gRgaYUnwSshokiRMYeDFYGGpVb9pYXNCGRrUKPyCQEB/5vjX5+owA/OSqw9Ft5u3SJJ8DAOISITYCKQiIhMSZ3fkGaPVRHo7znIikCixPIqwQAcAHLt/temMyIRKIEzAql+qUnAn376CevWrUOzZs2qfU5RUREsFgtyc3MBAL169cKGDRvg9Qbf0C0oKEDHjh3RtGlT7Zj169eHfZ6CggL06tULANCuXTvk5eWFHeNwOLB582btGKKaUBMLx51MMBDpTWTij5sRjSvWZlN1XqAaf5JxKPDPIrcAcMr+8xc5ssAKMBFIRKbA1qBERGRK2vwGO2cEEumVTyhwBwJrK0IrAsPfSBGCMwKpdsrLy7F7927t471796KoqAg5OTlo1aoVrr/+enz11Vd4//33IcuyNo8vJycHdrsdhYWF2Lx5My677DJkZmaisLAQU6dOxZ///GctyTd69GjMmjUL48ePx3333YcdO3Zg4cKFeOqpp7Sve/fdd6Nfv36YP38+hg0bhldffRVbt27F0qVLAQCSJGHKlCl4+OGH0aFDB7Rr1w4PPvggWrdujeHDhzfcD4wMT60IVP8kIv1ga1DzKPeoMWZws6k6ioIVgcajCAEhBCySRUsAOiPiEKskwaOwNSgRGR8TgUREZEquGIPcVWwNSqQPXgG4A4F1qtWCDKv/jZTInbgWCfDITARSzW3duhWXXXaZ9rE6T2/s2LGYOXMm3n33XQBAt27dwp736aefon///khOTsarr76KmTNnwu12o127dpg6dWrYXL7s7GysXbsWkyZNQo8ePdC8eXPMmDEDEydO1I7p3bs3Vq1ahQceeAD3338/OnTogNWrV6Nz587aMffeey+cTicmTpyI0tJSXHLJJVizZg1SUlJOxY+GTMqhtgZ1sTUokd6oMYckAUIA5W4m7I1KjTFDW4NmsDWoYclCQBH+WCOYCIyOQ7xCQBECFklKxDKJiOoFE4FERGRK5dr8hujWoMGKQAZrRInkUxS4A7F2mtWCdKu/a33kjECbJKGSO3GpFvr37w9RRRVpVY8BwAUXXIAvvvii2q/TtWtXbNy4scpjRowYgREjRsR9XJIkzJ49G7Nnz6726xHFIoSAI3BN4/TI8PgU2G2cAkKkF2oXkpaZKSh2VDIGMTB1RmBGzBmBbA1qNDIABQIWSFoCsFIR8AkBWyDpZ5Uk+IT/PjsTgURkYIwOiIjIlFyBti0ZMVqDckYgUeIJIeALqQgMTQQ6fUwEEhHVlNMjQw6ZX8T2oET6oib+WjdJCfuYjEeNH0Pn0KttQlkRaDyyEFDgr/oLrQQM7U5ihX+OoI/NSYjI4JgIJCIiUyqP0bZFFWwNyjfKiBJFFv4duFoi0BJsDRo5I9AqSahUGH0TEcUSmfgrq2B7UCI9UWOO1k1Swz4m49E2m8aqCPQwEWg0ivDPCbQgPBEY+neLJEERAjLnlRORwTERSEREpuTyqG1boluDqonAcu7GJUoYGf4duGqCL81qQXqglV3kbA6rBHgUBQoDcCKiKI6IRGCpi0kGIj1RKwBPCyQCHYxBDEsdPxE6hz7dzhmBRiULASH8bdpdYYnA4KZEq+Q/zsc4hIgMjolAIiIypWDbluiKQM4IJEo8Wfh34VYEKgJTQ1uDxpgRKAPwMgAnIooSWRHIRCCRvgRbg6aGfUzGoyb70u2cEWgGMgAExv65QpJ/obGINRCHMBFIREbHRCAREZlSrLYtKm1GoMcHhe0GiRJCEQKKEHCHVgQGEoGxWoP6FAEfX69ERFGiKgI5I5BIN2RFaBsU2RrU2GRFoMKrVgQGu86kBf7O1qDGE9ptJG5rUPgrAmWGIURkcEwEEhGRKak7MkMHuavU1qBCMGAjShRZCH9FoBw9IzBWa1BZCFYEEhHFENlmsNTFGYFEelEe0i6yVXYKAFYEGpUrJG4MbQ2akczWoEYlC0CCBCFE3ESgJPlLBhmHEJHRMRFIRESmpLVtiVERmGyzIMnqv6AvZ8BGlBAyAAVCaw0aWhHoVgS8IdV/NkmCD0wEEhHFEtkaNPJjIkoctfrPbrOgeUYyAH/8IXhNYzjqRlOrRUKyLfh2qjYj0MPWoEYjCwEBgUrFP7tc5YroTgIBzionIsNjIpCIiEzJ5Yke5K6SJIlzAokSTBb+gDs0EZhmDV6ahgbgVkmCoiAsOUhERH5RrUE5I5BIN9RYIyvFpnUlkRWhxSpkHGonmXS7VasSA4JtQlkRaDwyBCAkuCK6kUR2JwFYEUhExhf97qjOXHvttbV+zpIlS5Cbm3sKVkNEREYghAgGasnRrUEB/5zA4y4vE4FECaIEdtZqrUGtFlglCWkWC1yKgnJZQXZS8HghSQzAiYhiUCsAU5OsqPDKOM7WoES6ocYamSlJSLNbYZH810Dlbl/MDYukX2qiL3IGvXoeXR4ZiiJgsUhRzyV9UgQASUQnAn2RiUAJPsYhRGRwuq8IXL16Nex2O7Kzs2t0++CDD1BeXp7oZRMRUQJVeGWo1+lqq5ZIwYpA7ponSgRZCAgBVMj+F2uqxX9ZmhFotRS5E9cCMAAnIorBEbiWOSMnDQBbgxLpiRprZKbYIrqS8HVqNOpIibTIRGBIvOnystLTSLyKAiskOCNagUZVBEoCPnYmISKDM8T2o0WLFtW4wu+NN944xashIiK9U4M0SfLvjo9Fbc3DGYHGtPizn/HyF/vxn9t74bQmqYleDtWBDAAS4AppDQpAmxNYHhGQC8GWPEREsaitQfNz0rDryAm2BiXSkWBFoC3wZxIclT442JXEcFzu2KMnUpIsWqWn0+2Lqhgk/fIIAYsUnfiL/NgmSXAzEUhEBqf7isBPP/0UOTk5NT7+o48+wmmnnXYKV0RERHqnBmlpSda4rVnUYJytQY3pg29/xaHSCnzx87FEL4XqSAkk9VxyZCIwMGclsiJQEvDIDMCJiCI5KvzXMm2a+SsCSyvYGpRIL7SKwGR/v3PGIMaljp7IiBg9IUmSlhzknEBj8SqIkwgM35BolcBEIBEZnu4Tgf369YPNVvPdNJdccgmSk5NP4YqIiEjv1Cq/quZuZKb4g/FyBuGGdNzpf1Pl93J3gldCdSULQIIUnBGotgZVKwIjZnNYJQmVSuS8DiIiUluBaolAVgQS6YYjoiIwKxCDsDWo8WitQWOMnlDbgzrdbA1qJD6hwAJJ61CSGYhDImcGWiDByziEiAxO94nAUP369cOKFStQUVGR6KUQEZGOuTyx27aE4nwOYyt1+asdmAg0LlkIeIUCT6AyMLI1aKyWPEwEEhFFi5wReKLSB1/kfCMiSohga1BWBBqd2nUmVuvP9ECVoFo1SMbgFeEVgS3sgc3CcvSGRDdHFBCRwRkqEdi9e3f8/e9/R15eHiZMmIAvvvgi0UsiIiIdcmoVgbHnAwIhQTjbtxiOx6fAGUj2Hitn+zOjkiHgDmn1mRqVCIxsySOhki15iIiilIXMCFRx/hiRPmitQbUZgdyMaFTlVcSYbA1qTD4lUBEYSPzlBio7IysCrRLgVQQEk4FEZGCGSgQuWLAAv/76K5YtW4ajR4/i0ksvRadOnfDEE0/gyJEjiV4eERHphLoTM1bbFlUGd+MalloNCAC/sSLQsBQBVAQq/FIsEqySf55nus3/5kr0TlzAoyiQGYATEWm8sqJ1QshJs2tJhtDflUSUOCciWoNmaq1BGYMYjbbZtIrWoOVMBBqGEAI+rSLQ/3u0ReA8eoSAJ6QTiUWSIMN/PBGRURkqEQgANpsN1157Ld555x388ssvGD16NB588EHk5+dj+PDh+OSTTxK9RCIiSjA1SIvVtkXFGYHGdTxk9tHvrAg0LK+iwKOEtwUFgjMCY7UG9Qn/blwiIvILTSZkptjQJM1/fVNawWojIj1QK/+y2BrU8JxVjJ9Q71M3ZpD+yQJQIGBBsAKwud0GKfB4aFWgNXC8jxsSicjADJcIVH355Zd46KGHMH/+fOTm5mL69Olo3rw5rrzySvz973+v8rlz587FH/7wB2RmZiI3NxfDhw/Hrl27qv2ar7/+Os455xykpKSgS5cu+PDDD+vr2yEionqkDmlPs1fRGlSdEejmG2VGU+IMJv+OsSLQsEJ32qZagpek8VqD2iQJshAMwImIQqhtQTOSbbBZLWiSavff7+L1DZEexKsIdLA1qOEEx09UMSOQFYGGIUNAgb/aT92AmG61xpxXbpUkKEKwMwkRGZqhEoFHjx7F/Pnz0blzZ/Tt2xe//fYbXnnlFezbtw+zZs3Cc889h7Vr12LJkiVVfp7PP/8ckyZNwhdffIGCggJ4vV4MHDgQTqcz7nM2bdqEUaNGYfz48di+fTuGDx+O4cOHY8eOHfX9bRIR0UmqWUVgoH0Ld+MaTmi7s2NODxRWiBmSVwHcIlZFYOCNFF90a1BZCHgZgBMRaRwVarWR/7omWBHIinkiPQgmAsMrAhmDGE+wNWhVMwJZEWgUsvCPKrAAIYlAixaXhCYCLRIrAonI+OK/Q6pDp59+Os466yzceuutGDduHFq0aBF1TNeuXfGHP/yhys+zZs2asI+XL1+O3NxcbNu2DZdeemnM5yxcuBCDBw/GPffcAwCYM2cOCgoK8Mwzz1SbeCQiooaltm2pckZgMtvyGFVoa1BZESit8CIn3Z7AFVFd+IQCdyDATrVGVwRGzwiU4AMrAomIQqkVgVmp/iRDduDPUlYEEumC2ho0WBHIGMSo1Dn0MSsCA8lB9RjSP0UIKELAIlm0NqDpVkvcikDOCCQiozNUInD9+vXo27dvlcdkZWXh008/rdXnLSsrAwDk5OTEPaawsBDTpk0Lu2/QoEFYvXp13Oe43W643cGWZQ6Ho1brIiKiuglWBFbRGjSwK/cE27cYznFXeJXD7+VuJgINyCtCKgJDWoNm2GK3BrVKEhSFMwKJiEKp7QXVRKBaEXiciUAiXYhuDcrxBEalVvvF6jqjJgfLGVsahiyEvyJQCib90sISgcFYxBo4nq1BicjIDNUatLokYF0oioIpU6agT58+6Ny5c9zjiouL0bJly7D7WrZsieLi4rjPmTt3LrKzs7Vbfn5+va2biE4tIQRnqxiYuhMzrQatQU9wPofhlMZIBJLx+BQFlbI/mE4Pqwj0J/ArlBjBtiSxNSgRUQitIjCwwSk4I5CtQYkSTVEEyj2RrUEDmxFZEWg46mbTWHPo0wOdaFxMBBqGDECBgAVSWEVgmjqmIKQiUJIkAGAcQkSGpvtE4AUXXIDjx4/X+PhLLrkEhw4dqvHxkyZNwo4dO/Dqq6/WZXlVmj59OsrKyrTbwYMH6/1rENGp8eiaH9B9zlps21+S6KVQHVQ1yF2lJgIrvQq8ES0ISd8iqxx+L+ebnUYjhL+1TqUSvzUoEB6AA4AEzuYgIgrlqPBf82RHVASWVnCjE1GilXt8UC9b2BrU+KpsDapVBHJGoFEoAlDgH1fgDZlbnhGIRVwRcYgAWBFIRIam+9agRUVF+Prrr6ts2xl5fGg7zqpMnjwZ77//PjZs2IDTTz+9ymPz8vJw5MiRsPuOHDmCvLy8uM9JTk5GcnJyjdZCRPqyfX8pFAFsP1CKHm1q9v8P6YcrMCMw1iB3VWgAV17pQ1O2ljSMqIrAE6wINBpZ+HfgqonAtJDkn1WSkGKRUKkIOGUZWbbg61gI7sQlIgoVnBHov67hjEAi/VCTfXarBSlJ/uuZYEWgF0IIrdKI9K/q1qD+8+vijEDDkAMzAisCCT8JQKrFEndeuQSJGxKJyNB0XxEIAJdffjm6detWo1tFRUW1n08IgcmTJ+Ptt9/GJ598gnbt2lX7nF69emH9+vVh9xUUFKBXr151/r6ISL+OOf2JBVYaGVN5DSoCk6wWpAYCcs5yMBa1IrBlln+zDVuDGo8MAQVApRI9IxAAMgItecp94QG4RRLwyAzAqXobNmzAVVddhdatW0OSpKi53kIIzJgxA61atUJqaioGDBiAn376KeyYkpIS3HTTTcjKykKTJk0wfvx4lJeXhx3zzTffoG/fvkhJSUF+fj4ef/zxqLW8/vrrOOecc5CSkoIuXbrgww8/rPVaiOJRZwQGKwL9G5tYEUiUeOoIArUKMPTvXlnA7WNXEqMQQoSMn4jfGtTJuNIwFAgI4R9HAPg3JlokSdugGFkRCPg7mhARGZXuE4F79+7Fnj17sHfv3hrd9uzZgzZt2lT5OSdNmoSXX34Zq1atQmZmJoqLi1FcXByWRBwzZgymT5+ufXz33XdjzZo1mD9/Pn744QfMnDkTW7duxeTJk0/Z905EiVPi9CcAmWAwJpdbrQisuvA9IxCIOzgn0FCOByoCO+RmAgCOMWFvOLLwt+OplKNbgwLB9qCRrUGtkhQjKCeK5nQ6cf755+PZZ5+N+fjjjz+ORYsWYcmSJdi8eTPS09MxaNAgVFZWasfcdNNN2LlzJwoKCrQuIhMnTtQedzgcGDhwINq0aYNt27Zh3rx5mDlzJpYuXaods2nTJowaNQrjx4/H9u3bMXz4cAwfPhw7duyo1VqI4omcEdg00BqUMwKJEk+tCAxNBGbYbVCLABmDGEeFV9bavMauCAwkAj1sDWoUPgFACsYbavyRrs0IjD6XbA1KREam+9ag1SX16mLx4sUAgP79+4fdv2zZMowbNw4AcODAAVhCdqf37t0bq1atwgMPPID7778fHTp0wOrVq9G5c+d6Xx8RJZasCG0XNROBxhSsCIzfGhTwB+W/nXCjnDM6DEVtd9Y+NwP/3f07X6cGpKiteJTwwFsVLxFokyS4FSYCqXpDhgzBkCFDYj4mhMCCBQvwwAMP4OqrrwYArFixAi1btsTq1asxcuRIfP/991izZg22bNmCCy+8EADw9NNPY+jQoXjiiSfQunVrrFy5Eh6PBy+88ALsdjvOO+88FBUV4cknn9QShgsXLsTgwYNxzz33AADmzJmDgoICPPPMM1iyZEmN1kJUFUdFZEUgZwQS6UWwIjBJu89ikZBht+GE24cTlT4E9rWRzqnxpSRB6yoTSo07WRFoHIoQEAhW/qkdSqrakOjmhkQiMjDdVwSeCkKImDc1CQgAn332GZYvXx72vBEjRmDXrl1wu93YsWMHhg4d2rALJ6IGUeryaLv9mGAwJlcVg9xDZQYeP8FEoGEoitBmBHZomQGAr1Mj8s/kAFxK7IrAjMBcwPKInbg2SdLmChLV1d69e1FcXIwBAwZo92VnZ6Nnz54oLCwEABQWFqJJkyZaEhAABgwYAIvFgs2bN2vHXHrppbDbgzNmBw0ahF27duH48ePaMaFfRz1G/To1WUssbrcbDocj7EaNkyNwDZMVSARmp/r/PZZVeKEorFwgSqRYFYGhH3MzonE4QzrOxJrrqMadHDlhHIrwvymuJvzSrNUkAgG4+XuViAysUSYCiYiqorYFBYDfT7CtkhGpgVqavbqKQP+bZgzYjMNR6YUaf7VvoSYC+To1Ghn+uRyVcuwZgfF34gJeIdiWh05KcXExAKBly5Zh97ds2VJ7rLi4GLm5uWGP22w25OTkhB0T63OEfo14x4Q+Xt1aYpk7dy6ys7O1W35+fjXfNZlVZEWg+qcQ3OhElGiOuIlA/+uUr1HjcFbTcUZtF+ryyBC8TjUEn/DPCFRbgKZXlwiUJHgENyQSkXExEUhEFCE0EXjM6eaFvMF4fAo8gYv2WPMbQmVoFYFsn2UUxwNtQdPtVrRukgrAXxHI16mxyEJAQUgrnsiKwCoCcJ8AvNyNS43c9OnTUVZWpt0OHjyY6CVRgqiJwKxU/zWN3WZBemAjVGkFN8oY2UPv7MDja35I9DLoJMRqDer/mDGI0WiJwDgz6NUNqLIi4PYxWWQEChAxI9Aa+FONQ8I7k1gkwMMYhIgMjIlAIqIIoYlAryxQxhkrhqK2BQWAtDiBmkoLwlkRaBjHA21Bm6TZ0SzD3/7M7VNY1WkwigBkRdFmBEYmAtVAvNwX3RpUFgI+Jn7pJOTl5QEAjhw5Enb/kSNHtMfy8vJw9OjRsMd9Ph9KSkrCjon1OUK/RrxjQh+vbi2xJCcnIysrK+xGjY8QwevUrJBEQ5M0/+9HdaYuGc9RRyVeLNyP//vsZ1R65eqfQLoUrzVoRgrHExiNs5rRE6FxJ+cEGoPaYcQlh88sV+MQl6yEbTa1ShLciuAGVCIyLEMlAs8880wcO3Ys6v7S0lKceeaZCVgREZnRMWf47mm2HTQWp8f/ZondaoHdVvWvOQbhxqPOB2yanoQ0u03bfcvXqbHIQqBSEVDD6OhEYPzWoLIQ8DIAp5PQrl075OXlYf369dp9DocDmzdvRq9evQAAvXr1QmlpKbZt26Yd88knn0BRFPTs2VM7ZsOGDfB6g8mWgoICdOzYEU2bNtWOCf066jHq16nJWojiqfDK8AWqE9SWoKF/L+VmNsMKva6JjE3IOOJXBPo/drAi0DC0GYFxWoNaLRJSk6xhx5K++RQBC6I7lKh/+gTgCU0Ewj/aQGYYQkQGZahE4L59+yDL0b9Q3W43Dh06lIAVEZEZHY9KBLoTtBKqC3UHZlqcIC1UcD4Hg3CjOO70n6umgWqH5hnJAIBjfJ0aigygMlANaAVgl6Swx9VEYHms1qBgRSBVr7y8HEVFRSgqKgIA7N27F0VFRThw4AAkScKUKVPw8MMP491338W3336LMWPGoHXr1hg+fDgA4Nxzz8XgwYMxYcIEfPnll/jf//6HyZMnY+TIkWjdujUAYPTo0bDb7Rg/fjx27tyJ1157DQsXLsS0adO0ddx9991Ys2YN5s+fjx9++AEzZ87E1q1bMXnyZACo0VqI4lGrAa0WKWwucpO0QCLQxQSSUYWNKuA1jmGpmw2zomYEcjOi0VTXGhQIVguyU4kxeISARZK0jYdqAjDFIkH9jVoe0ubVIkmQBRiHEJFhVd0zTSfeffdd7e8ff/wxsrOztY9lWcb69evRtm3bBKyMiMwouiKQwbeR1CRIU2WqwRqDcMMIbQ0KAM0y7DhQ4uLr1GCUQEUgAKRaLZAiEoEZttizOaySBEXhjECq3tatW3HZZZdpH6vJubFjx2L58uW499574XQ6MXHiRJSWluKSSy7BmjVrkJKSoj1n5cqVmDx5Mi6//HJYLBZcd911WLRokfZ4dnY21q5di0mTJqFHjx5o3rw5ZsyYgYkTJ2rH9O7dG6tWrcIDDzyA+++/Hx06dMDq1avRuXNn7ZiarIUoFkeF//olOzUp7P/RYCKQG52M6pgzeF1zjF0PDCtea1AmAo1H7ToTrzWo/zErfi8PH1VB+qVWBDojWoNKkoR0qwUOWYFLVtAscLxVkiALRWspSkRkNIZIBKq7YSVJwtixY8MeS0pKQtu2bTF//vwErIyIzKgkMhF4ggkGI6mubUsoBuHGo76p2TTwJqdaEfgb3yQzFFkA7kAyL7ItKBCczRHZGhQAhAS2BqVq9e/fv8oZLpIkYfbs2Zg9e3bcY3JycrBq1aoqv07Xrl2xcePGKo8ZMWIERowYcVJrIYolOB8wPKzPTuWMQKML7VDC1qDGFa81aBa7khiOttm0qkSgnRWBRuKFEqgIDLx/EBKTpFmtcMhK2KZEq+Sfc86KQCIyKkMkApVA66h27dphy5YtaN68eYJXRERmplYcZSTbUO72cfaYwVQ3yD2UNiOQwZphRFYEsjWoMclCoCJwfZdmiU4EZsSZEQgAkmAikIgIAByBRGDofEAgpCKwgtewRsXWoObAikDzCHadib/ZNCMQf7o8nBFoBD4FYTMC1Y2I/r9HxyIWSJAh4GMYQkQGZagZgXv37tWSgJWVlQleDRGZldp+p0PLDABsDWo0tWoNqu3GZRBuFGp1Q07gTc4WGf6EIF+nxiJDoFKuqiLQf59LVqBEJP0E2BqUiAgIqQiMTAQGPi5jRaBhHWNFoCkEE4Hhr1EtEejma9QoarLZVJ1Rz4pAY/AGZgS6lPAZgUDsRKBV8m9mZGtQIjIqQyUCFUXBnDlzcNpppyEjIwN79uwBADz44IN4/vnnE7w6IjILdQdux5aZAJhgMJrg/IbqW4NmaAPdGYQbhVoR2DRdnRHorwj8/QTfJDMSWRGoVPyv1apagwoEd+mqbJIEjxJdKUhE1Ng4KuMkArWKQF7fGFV4RSCvcYzKobUGjagITPa/Rjmn3DjU8RMZVc4ItAWO5XnVOyEEvIqARYqeEQgA6bYYFYGSBMHWoERkYIZKBD788MNYvnw5Hn/8cdjtdu3+zp0747nnnkvgyojILIQQKAkkGs4OJAI5e8xYalMRmMW2PIajvjEW2RqUCXtj8QkBT6CqLzVGIjDJIiHZIgGIbg9qlYAKmQE4EZGjwn/9khVRbRScEchrWKMKSwQ6eY1jRIoitMowtgY1PvVcplWx2VRtG8rWoPqnABAQUBQRc255rIpAABCSxBEFRGRYhkoErlixAkuXLsVNN90Ea0jv5vPPPx8//PBDAldGRGbh9Mjw+PwXe2oi8PcTDL6NxFWDQe4qdUZgeaUPghf0hqC2Bm0aqHZoHmgNyrZZxuIRsYPuUGoAXh6VCJRQyYpAIqKQ1qDh1zxNWRFoeKwIND6nxwc1vIhM1qutQh1MBBqGK9AatCYVgWwNqn+yEFAAVIa8BxCeCPS/5+yUw5O6EgQ4oYCIjMpQicBDhw6hffv2UfcrigKvl0EOEZ28kkCgnWyz4IycNAD+XbhMEhmH2hq0qt2aKjUI9ykClV4mFoxAaw2aFtkalAl7I/Eq0JJ5aZbYl6MZcQJwmyShQlH4/zIRNXpq28HsqNag/t+RnBFoXOGJQF7jGJFa7ZdklZBsC7/WCVYE8jVqFOWB1qBVdZ1Rk4QuJgJ1Txb+mzuw4TDVIsEqSdrjaSHzyiOxIpCIjMpQicBOnTph48aNUfe/8cYb6N69ewJWRERmo7YFbZZuR/NM/5solV5FSy6R/qmtQTNq0Bo0LckK9Xr/BOcE6l6FR4Y7ULGrzj9qEUgEnnD7UOnl69QofEKpc0WgzeJvyeNjDE5EjZxWEZgSf0YgN00Yj6IIbeMT4O96wPNoPGoiMDMlCVJIgsF/nz9OcfsUrRsN6ZuzBq1B0+xqRSBjEr1ThIAiBCrixCNxW4MKfzUhEZERVf8uqY7MmDEDY8eOxaFDh6AoCt566y3s2rULK1aswPvvv5/o5RGRCZQEZnDkZNiRZrchzW6FyyPj9xPuKtuAkH4EKwKrP18Wi4SMZBtOVPpwotKH3MxTvTo6GeqbYrbAeQP87dDsVgs8soLfy904vWlaIpdINeQVIRWB1SQCnRFvkNkkwK0AHqEgCdVX/hIRmZWjInZFoPqxHJhRlhmRKCR9K6vwhrWec/v8mxIZixiLWu0XOR8QCG8veaLSq3W4IP1Sq/yqeh1mJKszAlkRqHcyAIFgPJJuDY8pMuJtSJQkeDiigIgMylAVgVdffTXee+89rFu3Dunp6ZgxYwa+//57vPfee7jiiisSvTwiMoESpzp/zF8N2FxtO8iWPIahVQTWoDUoAGQmB+cEkr6picAmaXZtZ7UkSWimzgnkDB3D8CkKKgPvcqbGaQ0arAiMbg3qUwS8HNBBRI1ccEZgeKIvJcmKlCT//6GlbA9qOOrc48wU/6ZEgO1BjShYERidOLJZLdq5PcEYxBDKazCHPlgRyHOqd7JaESjH3pgYbA0aHodYJGhdTYiIjMZwW8r69u2LgoKCRC+DiExKrQhslq4mAu04UOJiItBAtLYtNWgNCgTmBJZVMgg3APXNzKZp4W94Nsuw43BZJV+nBiECbT3jBd6q4IzA6J24Piicz0FEjZ567RJZEQgATVLtKPZWotTlRX5OQ6+MToY6H7BZuh2yEHCVVOCY04M2zdITvDKqDXWGZ2Zy7IrczBQbXB6ZMYgBCCG0rjNVzQhUk4ROJgJ1Txb+qsAKrSIwsjVo7DjEKklwC1YEEpExGaoikIjoVFN34Oak+ysB1TYtv7HSyDCcnurbtoTKSFF3bnLHvN6pFYFqxa6KlbvGIgtAgai+Nagt9mwOqyRBUQAPd+MSUSMXnBEYfc0TnBPIa1ij0UYVpNu1mIRdD4ynqopA//1JgeMYg+id26dADlx3plfRdSZdaw3KGYF6p0RUBEYnAuPFIYCHeUAiMihDVQQ2bdo0asgy4G8LlpKSgvbt22PcuHG45ZZbErA6IjKD41oi0B+YaQmGE0wwGIUrMJxdbbdTHTU4d3A3ru4dD1QENomoCAwmAvkmmRHIEFAQ3IFb7YxAOfabKawIJKLGzCcrWvu5WBWB6n1sDWo8wY2Jdqi/6tga1HiCicD4FYEAYxAjCK3wq6rrjFoRyNag+idDQECCK5DgjYxH0rXWoAqEENp70RZwRiARGZehEoEzZszAI488giFDhuCiiy4CAHz55ZdYs2YNJk2ahL179+KOO+6Az+fDhAkTErxaIjKikoiKwBaB2WOsNDKOmsxvCJXBGYGGURryxlgoVgQaiywARQAVciDwjjMjUG0NWi7HCLYlcEYgETVqoe0EI2cEAqEVgUwEGs3xGNc7anKQjEOt9KuuIpBJI/1zBjaapiZZYbVEFyeo1LiSFYH65w9DhDYDMF5FoH/zokCa1X/erZJ/vqAsBKwxClWIiPTMUInA//73v3j44Ydx++23h93/r3/9C2vXrsWbb76Jrl27YtGiRUwEElGdHIsIvJtnMsFgNGrgVdNEYLAtD4NwvQtWBEYmAtWEPd8kMwJFCHiU4Iy/aisCfbF33XI3LhE1Zur8sTS7FUkx/h9tkur/3Vjm4u9GowkdVaC+z8zWoMajxhaxWvcCwQQhW4Pqnzp6orr4Uu1Iw+Su/snCXxHo1GaWh3cTslssSJIkeIWAU5a1eMUqSfAIAR8TgURkQIaaEfjxxx9jwIABUfdffvnl+PjjjwEAQ4cOxZ49exp6aURkEpE7cNVKIwbfxuAf5K4GarVrDcoZgfoXnBEYpzUoW/gagiwEXCHJvdQ4icCMKlqDJkkSXEwEElEj5qhQkwyx2w5qFYFsDWo4aoeSZul2NAvEJMecvMYxmmBFYOzXaJaWCGTSSO/U1qAZ1cSXakWgx6fAG6ujBemGIgALhJYIjKwIDL0vdE6gRfJXE/o4ooCIDMhQicCcnBy89957Ufe/9957yMnJAQA4nU5kZmY29NKIyCSiKgLZctBQKryyNkslvYr5DaEykxmEG0UwERi7NSjfJDMGGdCSeCkWKe5u2nRb/NagNklCBd9gIaJGrCzQ8jMrNfb1TjZbgxpWSUg80izQ9YCbEo0nOCOw6tagrAjUP7XCr6r5gJGPq3PrSZ9kCAjhnwEIxO5QkhYyJ1BlhQRFiEBrUSIiYzFUa9AHH3wQd9xxBz799FNtRuCWLVvw4YcfYsmSJQCAgoIC9OvXL5HLJCKD8vgULWBrpiUC2XLQSNQgTZL8MxxqIkPdjcsWLroXbA0avrO6GV+nhiILoSUCU+PMBwSCFYEuWYEiBCwhCUMmAomosVNbg2bHmA8IBFuDsiLQeEITgeo8Mm5KNJ5gIjD2azSDmxENQx09kVFNa1C7zQK71QKPrKDc49M2ZJD+yAKAhFpXBFolCXKgNSgRkdEYKhE4YcIEdOrUCc888wzeeustAEDHjh3x+eefo3fv3gCAv/3tb4lcIjViJyq9SEmKPaODjKE0UG1kkYJvqqgzAsvdPlR6ZaTUMLlEiaHuvExLssJSxSD3UJwRaBzqa7RpeuyKwOMuD3yyAhv/H9Y1RQCuQLvPePMBQx9TAFQoCtJDZndYJfjncygCthq+1omIzESrCKymNWhZBTfJGE2sRKB6HxmHQ2sNWt2MQMYgeqduNq3J6In0ZCs8LgUubjLVNUWEVwRWnQgMVndaJH81ocxEIBEZkGHeKfN6vbj11lvRunVrvPLKK/jqq6/w1Vdf4ZVXXtGSgLWxYcMGXHXVVWjdujUkScLq1aurPP6zzz6DJElRt+Li4jp+R2QmpS4Pej/6CW5+fnOil0InQW0L2jTNriWRMpNtsNv8/1X+xvljuhcM0mq+z0Xd2VnOtjy6d9wZe0ZgTrodFgkQgm+UGYEsBCoC/XSqSgQmWyxIClQBOn3h1X82SYJPAF4G4UTUSDkqqqkI5IxAQxJChI0qUDc7lTg9UBT+zjOSmrYGdTAG0T11RmBaDWJMtT1oOROBuuZTBCxSMMkXOxHoT/xGVgQqCmcEEpExGSYRmJSUhDfffLPePp/T6cT555+PZ599tlbP27VrFw4fPqzdcnNz621NZFy7ik/gRKUPW/Ydh4+tygyrJGI+IABIkoTm6WrbQSYC9U5t21KbRGAWd+Magk9W4AicoyYRMwKtFkl73bI9qP7JANxqa9BqqjdjteQB/IlAWQgmAomo0QrOCKymNShnBBqK0yPDE9j80izDrl3f+BTBhJHBnNAqAmO/RlkRaBxaa9AazKBXN5k6OSNQ19QYokJRNydGV3vGi0MAwMuNGURkQIZqDTp8+HCsXr0aU6dOPenPNWTIEAwZMqTWz8vNzUWTJk1O+uuTuRwJVIrJisDhskrk56QleEVUF2oiMKrtYGYyfi2rZILBAJy1aNuiUmcEctemvpWFvJHZJMabns3Sk/F7uYcJewNQhAgG3VXMCAT8cwJLfXJ0ItAiwSsEPAzCiaiRUpNCcROBamtQlxdCCEgS2ygbgdr9INlmQWqSFZIkISvFBkelD8ecnqjNUKRPQggttsiqtjUoE7x6V5uuM2mBONTpYWypZ5FxRKyYpKpEILf/E5ERGSoR2KFDB8yePRv/+9//0KNHD6Snp4c9ftddd53yNXTr1g1utxudO3fGzJkz0adPn7jHut1uuN3BNyQdDscpXx8lxlFHpfb3gyUuJgINSk0ENoszf4wJBv1TA660GuzWVHFGoDEcdwXnrMSaAdg8045dR/g6NQKfEHAHAu9YbXhCpdusgNuLcjl8V7UVgCwAr2AYTkSNU1lF1UkGNRHokRW4PHKtuiVQ4hwLiUfU5G2zjGR/IrDcg7NaJHJ1VFNOjww1xxCvIlCd78nNiPpXm82mwYpAnlc98wqBysCL1C5JSIoxc1wdYeBiRSARmYShooHnn38eTZo0wbZt27Bt27awxyRJOqWJwFatWmHJkiW48MIL4Xa78dxzz6F///7YvHkzLrjggpjPmTt3LmbNmnXK1kT6cTRkdtzB464EroROxrEYrUEBoHlGoOUgZwTqnhpwZdRlRqDbB0UR2nxI0pdSV3CGZyxqwv4YK3d1TxFAheJP7NW1NagkSRAAKwKJqNGqbkZgapIVdqsFHllBaYWXiUCDKHH6442cjOD1TrN0O/b+7sQxbnYyDLXKz2aRkJIU+1qHrUGNQ23zWaOKQLtaEcjWoHrmU4Q2qiDexsSMQLvQcl/0ueSMQCIyIkNFA3v37k3Y1+7YsSM6duyofdy7d2/8/PPPeOqpp/DSSy/FfM706dMxbdo07WOHw4H8/PxTvlZqeOEVgRUJXAmdjONxE4GBBIOTCQa9U4M0NQCricyQnfTlHp+2O5f0Ra0IjGzdq2qWzspdo5AhUCmr8ziqbw0KAOUxduJKnBFIRI1YdTMCJUlCdloSfjvhRqnLg9OapDbk8qiO1A1NOYHrGsA/KxAAfmcsYhhqci8zxRa3La9aKejyyPDJSsyOF6QPzlq0Bk1nRaAh+CsCq04Ext+QyIpAIjImXmmchIsuugi7d++O+3hycjKysrLCbmRORxysCDSDkmoSgb8xwaB7WpBWi9agyTYLkqz+AL2cO3J1S03UN02L/YZn80z/65avU/0L3YGbWs2MwPTATlynHHtXNYNwImqs1BmB8SoCgeBM3TIXZ5AZhRaPhFzvqEnBEnY9MAy1IjBeW1D/YyGbEZk00jV1/ER6DTabqt1mXDynuuYT1W9MjNca1CZJcHM8AREZkOESgb/88gv+7//+D//4xz8wbdq0sFtDKyoqQqtWrRr865L+HD0RPiOQjOmY2oonMhGYGag0YmtQ3VNbsNSm/ZUkSZwTaADHa9ga9He+SaZ7cshMjppWBDp90cG21SKhMkalIFFNtW3bFpIkRd0mTZoEAOjfv3/UY7fffnvY5zhw4ACGDRuGtLQ05Obm4p577oHPF/675LPPPsMFF1yA5ORktG/fHsuXL49ay7PPPou2bdsiJSUFPXv2xJdffnnKvm8yB4c2I7CKRGAgmVRawUSgUZS4oisC1TEFaqxC+ucIqQiMJ8lq0dqGMgbRt9pUBKqz6svdbA2qV4oQgXjEH0fEi0fiVQRaJInjCYjIkAzVGnT9+vX405/+hDPPPBM//PADOnfujH379kEIEXdOXzzl5eVh1Xx79+5FUVERcnJycMYZZ2D69Ok4dOgQVqxYAQBYsGAB2rVrh/POOw+VlZV47rnn8Mknn2Dt2rX1+j2SMR0Nqwhka1CjOu70v0kSd0YgK410rzaD3ENlJNtQ4vSg3M03yvRKbQ3aJE5FYAttRiBfp3rnUapvxaNKq6I1qE2S4FKYCKS627JlC+SQatMdO3bgiiuuwIgRI7T7JkyYgNmzZ2sfp6WlaX+XZRnDhg1DXl4eNm3ahMOHD2PMmDFISkrCP//5TwD+GGPYsGG4/fbbsXLlSqxfvx633XYbWrVqhUGDBgEAXnvtNUybNg1LlixBz549sWDBAgwaNAi7du1Cbm7uqf4xkAEJIbQZgVmp8UP67FT/NWwpKwINQ636axYxIxDgHGQjOVGDRCAAZCQnodLr1ip8SZ+0GYE16DqTEYhD2RpUv2QBKEBIPBL7vYN4iUArOKeciIzJUBWB06dPx9///nd8++23SElJwZtvvomDBw+iX79+YQF7TWzduhXdu3dH9+7dAQDTpk1D9+7dMWPGDADA4cOHceDAAe14j8eDv/3tb+jSpQv69euHr7/+GuvWrcPll19ef98gGZLL48OJkIu83064Uenl7i8jOhanNWgLVhoZhta2pRYVgUAwSHdwN65ulVZTEdiMCXvD8AoBdyB4Tq1pRWCM1qA2CahgRSCdhBYtWiAvL0+7vf/++zjrrLPQr18/7Zi0tLSwY0Jb/a9duxbfffcdXn75ZXTr1g1DhgzBnDlz8Oyzz8Lj8f+ftWTJErRr1w7z58/Hueeei8mTJ+P666/HU089pX2eJ598EhMmTMAtt9yCTp06YcmSJUhLS8MLL7zQcD8MMhS3T4En8P9fla1BtYpAXsMaRaxRBTnavHJe4xhFTVqDAkBWIAZhRaC+lddis6laEajGpaQ/shBQRDCOiDsj0OY/3y5FgRwyl9wqSfBwMyIRGZChEoHff/89xowZAwCw2WyoqKhARkYGZs+ejccee6xWn6t///4QQkTd1FY9y5cvx2effaYdf++992L37t2oqKjAsWPH8Omnn+Kyyy6rr2+NDEytBkxNsmr94H/hnEDDURShtR5sFtKKBwCaBYLvsgovPDHa05F+BGcE1r4iEOCMQD0LtgaNMyNQqwj0QOEOTV3zCaEF3mnVzQi0qTMCY1cEVioKFMHzTSfP4/Hg5Zdfxq233gpJkrT7V65ciebNm6Nz586YPn06XK7gNV5hYSG6dOmCli1bavcNGjQIDocDO3fu1I4ZMGBA2NcaNGgQCgsLta+7bdu2sGMsFgsGDBigHROL2+2Gw+EIu1HjURaoBrRIVVeocEag8cTamNicFYGGU9OKwEwmAg3BFUjqZdRgs6l6DCsC9UuGgAKgopoOJaFxSujmQ4vk39jIGISIjMZQicD09HRtd22rVq3w888/a4/9/vvviVoWNXJHA3PjWmYl4/SmqQCAgyVsD2o0Jyp9kAPJg6bp4YmGJqlJsFr8bwpyJ66+ueowIxAAZwQaQLA1aNUVgT5FaG+Qkj55BaqdyaHKiNOSB/AnAn2CrXmofqxevRqlpaUYN26cdt/o0aPx8ssv49NPP8X06dPx0ksv4c9//rP2eHFxcVgSEID2cXFxcZXHOBwOVFRU4Pfff4csyzGPUT9HLHPnzkV2drZ2y8/Pr9P3TcYUbAuaBItFinucVhHIRKBhHHdFJwKbaRWBTAQahVoRWNUMTyA0BuFrVM/U1qBpNYgx1ThUnV1P+qMIf4ttl1z1zPIki4TkwO/Y0FjEKklQ4N/cSERkJIZIBM6ePRtOpxMXX3wx/vvf/wIAhg4dir/97W945JFHcOutt+Liiy9O8CqpsTriqAQA5Gam4PSm/rkxB1kRaDhqgi8j2YZkW3g1mcUiabM5fj/BAFzP1LYtaTWY3xBK3Y3LGYH6VV1r0GSbVWuvxIS9vnlkGZVK1YG3Kl2bERirNagEWQh4GYRTPXj++ecxZMgQtG7dWrtv4sSJGDRoELp06YKbbroJK1aswNtvvx22GTFRpk+fjrKyMu128ODBRC+JGpC64aW6JEN24HcmW4MahzojMDwR6P/7cZdH27hI+saKQPPwhLRizqhBjJnGGYG6JwsBuYYbE2PNCbTCP2fQx/+OichgDJEInDVrFpxOJ5588kn07NlTu+/yyy/Ha6+9hrZt2+L5559P8CqpsVIrAnOzkpGfo1YEMhFoNLHmcYRqrs0JZIJBz1yB3Zo1adsSikG4/gUrAuO/6am+Tn9jwl63FCHglAXUuLn6isDAmyk+BSIi4WeTJHiZCKR6sH//fqxbtw633XZblcepccju3bsBAHl5eThy5EjYMerHeXl5VR6TlZWF1NRUNG/eHFarNeYx6ueIJTk5GVlZWWE3ajwcgeqhquYDAsF22qwINAa3T9ZmzzcLiUmaptkhSYAQwYpB0rfaJgLLmTTSLVfIrL+0GswIZGtQ/ZMFoEDAVc2MQCAYq7jCWoNKUIQImxtIRGQEhkgEqm/8nHnmmejatSsAf5vQJUuW4JtvvsGbb76JNm3aJHKJ1IgdDakIzFcrAtka1HDURGDTeInAzECCgYlAXdMqAmsQpIVSAzYmAvVJCBGsCIzzGgWYsDcCRQAuxZ+wtwCwS/Fb2gHBwFwGtCpClU3y7+j1sjqCTtKyZcuQm5uLYcOGVXlcUVERAP+IAgDo1asXvv32Wxw9elQ7pqCgAFlZWejUqZN2zPr168M+T0FBAXr16gUAsNvt6NGjR9gxiqJg/fr12jFEkbSKwNSqkwxNUu1hx5O+HXf6z5PVIoVVe1otktYRgXMCjUFt9ZlZw9agDrYG1S01vrTbLEiqZgMbAKQFZtWzNah+KRARicD47x2omxJDu5NYAzEIW4MSkdEYIhEIAFI1bxQRJUrojMD8HLYGNSo1EdgsbkUgg28jqM0g91CcEahvTo8Mb2CGQ9OqKgIz1dcpE4F65RNCa62TZrWEXd/9Z8NeLPngByghQXWyRYItcEjknEBJkiAAeBiE00lQFAXLli3D2LFjYbMFf3f8/PPPmDNnDrZt24Z9+/bh3XffxZgxY3DppZdqGxMHDhyITp064eabb8bXX3+Njz/+GA888AAmTZqE5GT/xoTbb78de/bswb333osffvgB//d//4f//Oc/mDp1qva1pk2bhn//+9948cUX8f333+OOO+6A0+nELbfc0rA/DDIMR4X/eqW6ikC1ip5VZMagbUxMi579qMYovMYxBgdbg5qGs5YdZ1gRqH+y8G9OdCo1rwiMnBEogzMCich4avdOaQKdffbZ1SYDS0pKGmg1REHajEC2BjW0Y9W0Bm3BSiND0Aa522tZEcgZgbp2PPD6TLZZkJoU/9w2S1dfp3zDU68UAE45ej6gT1bwXuFBCABX9czHac3TAfiTfelWK8p8MsplGc0jLl0lSKwIpJOybt06HDhwALfeemvY/Xa7HevWrcOCBQvgdDqRn5+P6667Dg888IB2jNVqxfvvv4877rgDvXr1Qnp6OsaOHYvZs2drx7Rr1w4ffPABpk6dioULF+L000/Hc889h0GDBmnH3Hjjjfjtt98wY8YMFBcXo1u3blizZg1atmx56n8AZEg1nhGYytagRlLVqAL1PjVmIX0LtgatWUUgE4H65QxsNE2vYccZdVa9yyNDUURUUp8ST23pWVGD1qDpsVqDwp9MlBmCEJHBGCYROGvWLGRnZyd6GURRtIrAkNagjkofyiq81e7SJf04zhmBhhc2yL2WFYFZ3I2ra2olg39GTvxgmq9T/VOEQEWgtU6aJRh0H3O4tbmBxccrtEQg4A/Ay3xyVEUg4J+X5BHR9xPV1MCBA6PmTwJAfn4+Pv/882qf36ZNG3z44YdVHtO/f39s3769ymMmT56MyZMnV/v1iADAobUGrVlFoNunoNIrI6WKzTSUeMec/uuXWPGIeo3DikBjCLYGrWlFIJP1eqVW9qXba1cRCAAur1zruJROPVkI/7iCkC4l8aTHqAj0x6OcU05ExmOY30gjR45Ebm5uopdBFCW0IjA92YacdDtKnB4cLHEh+zQmr42iqh24ANAs0BqUCQb9qgiZw5BWw0BNpQZo5WzhokvHA5UMTapoCwoEW4PydapfPiFiBt2/B36XAkBxxJxdLQD3RSf8rBLgjpEgJCIyM3WeWHWbDjOSbbBaJMiKQKnLi7xsJgL1LDiqIDnqMTUWYUWgMaibC7OqSQRyM6L+aYnAGib0UpIssEiBudhuHxOBOqQA8MoK1AiitolAAIBA2DgDIiIjMMSMQM4HJL2q8MjaRXtuVgoAIL+pvz3oL5wTaCglrhpWBJ5g8K1X5YG2LXarBXZb7X69sS2PvpWGVARWJVgRyNepXikAXEqMRGBZMHlbfDx2IrBclhHJKgVbjRIRNRbB1qBVv8EsSRKaqO1BK/i7Ue+0GYHp0Qletj83DiGEtrmwutagGclqDMKKQL1SR0/UNBEoSZJWPchNpvokC4GKQBLPJgH2Kt5zTrf6N9A4Y8QhrAgkIqMxRCIwVrseIj04esJfwZCSZEFm4MLw9Bx/e9CDERUNpG9aRWCcRANbDuqfKxBopdVwfkModacmE4H6dLyKN8ZCNWflru7JQmjzOFLjVAQeiUgEZmgBeHTln02SUKmwIpCIGhdHRaDaqAZjCLLTOCfQKIIdSqIrAnMC1zglTl7j6J3LI0MOzC+ueWtQxiB6pc0IrMUMejVpqCYRSV9kAbgCib10q7XK4pO4FYGQ4ON71URkMIaoUVf4Bg/plDYfMCtFu3hQ5wQeZEWgoRwL7K5Vg+xIasvBEpcHPlmBrYr2EZQY5bWc3xCK8zn0LdgatKYVgW4IIdhRQIcUUYeKQFu8ABywWSRUyArPNxE1KmU1nBEIIFgRyESg7gVbg8aYERi47xgrAnVPTepZLRJSq5nLyUSg/pXXsjUoENyYqiYRSV9kIVAZ6CiSXs37OnETgZKAT2EikIiMhe9kE50EbT5gZnDXZn6OvzXowRImAo3kuCt+4A34KwUlCRAi2EaU9MXlUdu21L4iUA3C3T4FnhhzyCixgq1Bq6sI9P9fXOlVtH8PpC+yEHAHAu80S/Ay9FhIRWDJCQ/c3uD5y9AC8OhzapMkyBBszUNEjUpNZwQCwU00ZWwNqnvHqphZ3ixwjcMZgfqnbizMTLFVu0lJbR1a7vZpVYSkL65AVV9tZv1laBWBTATqkSwEKkX0xsRY1MddEYlAmyTBzdcsERkME4FEJ+Gow1/BoM4HBEIrAtka1CgqvbKWNGgaJxFos1q0tqGcE6hPddmtqQoN7DjLQX/UisDqZgSm2a1ISfJf2rA9qD75hEBFrIpAR/j5Cm0Pqs7mKI/TGtSrCHgZiBNRIxKcEciKQDMpqSIRmKNVBPL6Ru8clep8wOpjktBjWD2mT2psmFab1qCBDjVObkzUJa8iUBmIHapLBGbEmRFok6SYmxSJiPSMiUCik3DkRKyKQH8i8JfjLs63NAh1Z22SVdJmPcbSXNuJywBcj1yeurcGtVktWuuecrbm0R21Yre61qCSJHGep84JQJvppwbeihA4FkgENgm0Zy4OSwRW0RpU8u/q9fD3LRE1EooitDema1IRqM0IrGAiUO+OV5EIVOcgOyp97F6hc1pFYHL1r8+UJCvsgesctgfVJ2cdNpuqHWpYEahPXiHgDsQVdW0NardIKPcpfM+PiAyFiUCik/CbIzgjUNW6SQokyd+a7je+EW0IoUF3Ve1b1DmBTDDoU7m77q1BgeCOXAfnBOpOqVYRWP0bKmoi8DdW7uqSTwitjU5qoDVoabkHsiJgkYBz8rMBhCcC1dag5b7oXbdWSYJXsCKQiBqPE5U+qO87ZqVW/8Z0k1T/9SsrAvVNUUSVowqyUpJgs/jjlBK2B9W1E7WoCAw9jrPK9UntHFSb1qDpbA2qa14RrAisLhGoblysVAR8IUm/JEmCO+TzEBEZAROBRCchVkVgss2KvEBi8GAJ24MagVoRWF3bQa3SiAkGXXK5614RCAAZgSCcrUH1p6YVgQArd/VOFohqDfp7mf93aU5mMloHquqPlES3Bo1VEWiVJAiAFYFE1GioG5ZSkixItlW/+alJYBMNZwTqW2mFF+r7ybFGFVgsklYpyE2J+hZMBFa/gc1/nJoIZAyiR3VpDZqmtgZ1s3WkHvkUoXUoUeMM1YkKL5SQ5F5o69DQOYF2ixRoMcoKbSIyDiYCiU7C0RgVgUBwTuAvx10NviaqvZJAwqBZRtVJhmbpbDmoZ3Vp2xJKDdYZhOuPWsUQq1VWJLV1FhP2+qRAwC2Hz+RQ5wM2z05BXk4qgIiKQFv81qAAIAmE7dAlIjKz2swHBIKJwONOVhvpmRqPZKXYkBSnQkW9DmJFoL6plX1ZNa4IVGMQvkb1SB0/UZuKwAy1NSjnPuqSN3RmuSX4/+2+I+W4c1EhFr//g3afVZKQGqjGDo1F7IGuJG5WBBKRgTARSHQSjjiiKwIB4PTAG5kHS5gINIISp5pkSK7yOLU1KFu+6pM6jD2trq1Bk9WKQAbheuLxKdpO3Nq0BmXCXp9Cd+AGE4H+36XNs5LRsqmaCKzUnqO27CmX5ZhzOIQEeBiEE1Ej4VATgTWYDwgEq+k5I1DfgvFI/E1P7HpgDHVvDcqkkR4Fx0/UPBEYrAjkOdUjrxCojNiYCADf7S+FAFD4/W/47kCpdn+wO0mwwlOSJAjBikAiMhYmAonqqNIrwxG4WM+NUxHI1qDGoO7AzakmyRBMMHAXrh6pgVZGHVuDMgjXp9JAW1CLVLPqB60ikIlAXfKFzNJQd+AeKwtUZWelIC+QCCxzelChVvkGgm+fiN0CVALgYRBORI2E2ho0u6aJwMBxZS5ev+qZFo9UkQhUu5ccYyyia2plX01bg6qVZg7GILoU7DpT882mGZwRqFuKEFBCRhWEzgg8Uhp8/+6VT/dAEeFzBKO7k0hMBBKRoTARSFRHv53wB2vJNktU24/8wIyjg2wNaghqe53qKgJbaDMCmWDQo2BFYB1nBCYzEahHx13BNzwtgbYsVWmm7pbnm2S65PIp8IrI1qCBisDsZKSn2JAZeNP6SKn//lSLpF2wxmoPapOksJkdRERmFmwNWrPrHbU1KCsC9e1YDeKR4IxAXuPoWe0rAtkaVM/U1qC1qQhM1zrNcEag3sgCkCG02CEsERgymmBvcTkKvzsadkxkHGKzAOU+xiBEZBxMBBLVkdoWtGVWCiQp/M3p/EBFAxOBxqAlAquZEciWg/qmVQTWtTUoZwTq0vFABUPTtOrnAwJ8neqdI6SlTqqaCAxUBDYPVNerVYHFgap6SZKCAXiMYNsmSahgIpCIGglHhf86peYVgf7fny6PDLePb0rrVUkgudesBq1BS9gaVNccWiKwZq9RdiXRN3VEQXotus6o1YMuzgjUHVkICAQrAtPCEoH+9/jOP7MpAOA/G/bB45W1YyITgXZJgoO/V4nIQJgIJKqjo4GqsMj5gECwIvDX0kr4+Oak7mmJwGoSDeqMwGNODxTOo9IdNRGYVsfWoBkpnBGoR2pr0CY1mA8IAC04y1PXyrz+YDnFIv1/9u47zI3yXBv4PTPq0mp7ce+ACy4YbEyzAYMDTnIoSejtBAihnABJyCHJoQS+wyEJJCShhiQQAgmdJBCK6QGb5oJxw717e9Guumbe748p2rV3vbta7WpWe/+uS5fW2pE0q9eS5p3nfZ4HitFbo8H4Pi0r1L9PK0v0gGD7VblmedA29cDJtkOSEGFZHiIaIlp62SOwwOOAuWaxhVmBtmVmBBYfrDSon6VBB4N0adCezUnM7N42BgJtJ6VqiCWNzLHeZASyR6BtqRBQBaxFhOZiw5SqWVVKLl44ESUFLjSE4nh9+V5rm8h+8xCnLCGiqlA7aV1ARGRHDAQSZah9RuD+KoMeOBUJqiawryU20LtGvZQuxXPwQGCpUapH1QRPpNhQOGFmBGYWCAxyNa4tmaVBe5sR2BpLMfPBhlqNCbTX6A8YjqUQM8r6lhoLa6yMwHaBwICjq94cgEMCkkIgxQUaRDQE9LZHoCxL1rYtER6/2pVZAeFgGYFm+fP6MAOBdsbSoPkjkkzPJXrTI9BnbGu2riD7EALQNK1daVB9rOpaYhACcDlkVBR58K0TxgEA/rFsJ5zGFOOAjEBZQkKAfQKJaNBgIJAoQ2ZGYHknGYGKLGFEEcuDDhZNxmS6tJvSoC6HbJ1IYdlB+4kYPRh8rsxKg5oBRK7GtZcmKyOwZ4HAoMcJh9FLkCvm7afVCM6m+wPqn6VBnxMup/7e7SwQaK7EbeuiR6AqgARX4xLREJDuEdizQCAAFHnZJ9DuGnuwMNH8HUuD2ltr3MwIZGnQwc7M6HMqEtyOns8xzXklMwLtJyUEYpqAGaI15yRmWdDKYi8kScIxUyswpjKAaELFzj2tAA5sUeCSZCQ0DTGVcxAiGhwYCCTK0MEyAoF0edDdjdFOf0/2oGrCOinSk4yjsgDLDtqV1b8hw4xA9gi0p2YrI7DnmQ9mUJ8Be3vRhEDEmChbgUAja76sMP1dWmkEAjsrDRrurDSoLCGlCSS5GpeIhoBQtHcZgQBQaBzjNjMj0LbMxUsH61luzkO40MnezLlEsNcZgZyD2E2mrSf8DATalob0fEKG3q4ASM87Kov1OYksSTj/RD0rcPvuEIADMwIdEpDSBOKcgxDRIMFAIFGG6g7SIxAARhbrgUBmBNpbUyQBM4mkJ4EGqyQPJ+C2EzFKr2QaCDR7BLZywmYrTT3ombO/Mut9ykCgnWgCaNOM0qD7ZQSWBdPfpWZGYCiSRMR4PwbMjMBU5xmBKQhmBBLRkJDuEdjz4x0rIzDC41e76knPcnMeEkmoiCR4vGpHQoh2pUF7lxEYYmlQ2wkbFWd623rC6hGYUCF4fGorqhCIaOmFiZLRRLem2QgEGpW9AGDqmGLMmlACLaHPP/YPBEqSBEhAjO0JiGiQGLKBwPfffx9f+9rXMHz4cEiShJdeeqnb+7z77rs44ogj4Ha7MXHiRDz22GP9vp9kX91nBBqlQRsZCLQzM8hQ5HPCoXT/kVhuBhhaGWCwEyGE1SPQn2Fp0HRZHk7C7cTsEVjUw4xAoH0gkCc87SQlBKLGBNon75cR2O671Ot2oNCvj3e1kVVvlgbtrEegIuk9eZOchBPREBCyso16URrU+A5lj2t7EkKgMdJ9aVC/S4HL6JnLrEB7iiZVqMbxSM97BLI0qF2lMwJ7N780+wmqmkC8k0VslDuaSGcE+tud/0lnBHo7bH/ugnGQjTGsjx74uSsBiHZSsYSIyI6GbCAwHA5jxowZuP/++3u0/bZt27B48WKceOKJWLVqFa6//npcfvnleP311/t5T8muzB6BFcHOMwJHWRmBLA1qZw09WH3bXhlLDtpSNKlamZ0ZlwY1ewQyI9BWzOyFnr5HAbA0qE2pSJcGNSfeDWZGYGHH79LK/foEpnsEdjHRloAkV1wT0RAQsjICM+gRyNKgthROqEgYJ5oP1rNckiSUWX0CGQi0IzOYp8hSj4NH6dKgfH/aTaatJ9qXEmV5UHtRhUDU+LztGAg0ewR2XOg/osyPWWOK9W3a4tD2m284JAmtDPYS0SCR2dnSPHDaaafhtNNO6/H2Dz30EMaNG4d77rkHADB58mR88MEH+NWvfoVFixb1126STcWSqjWRriw4eI9AZgTam1WGp4dlB1ly0J7aB++8zkwzAtP9OYQQVpkQyi1zhXxRLwKB6cxdniSzEyGA6AGlQfVJd+l+2fVVxV5s3B2yVuf6Hfr7OtJJRqD+4ECCGYFENAS09KFHYBNLg9pSo5Hd53HK3fYiKw24sbclhoYw5yJ2ZAbzAm5Hj+cSZi/BtjjnIHZjtp7obWlQRZbgdSqIJlWE4ypKA/2xd5QJFUBUmKVB05mbdS1mINB7wH2+MmMYPt5Vg4QEfLy+DvOmVFi/c8kSWpkRSESDxJDNCOytZcuWYeHChR1uW7RoEZYtW9blfeLxOEKhUIcL5QezP6DLIXfZn2OUcQBR2xpHLMkDA7vqdSCwgCUH7Shi9G/wuxTIcmaTZ7NHoKoJRPmetQ1z0UWxP5PSoDxJZicpkc4I9JmBwJbOMwKr9ssItHoEdhUIZEYgEQ0BsaRqlZnrTUag2Qe7maVBbckM6pX6O6800545Z+FcxJ5CVn/AngeOzDmIJvTsULKPtgxLgwLp8qBh9vO0FU0IxNSOGYENoRhUTcCpSCgpOPBzuMq8zSHj6fe2WRncAOCSJEQ1jS0KiGhQYCCwh6qrq1FZWdnhtsrKSoRCIUSjnZd+vOuuu1BYWGhdRo0aNRC7SgOgttXsD+jucsVeid9lHTDuZnlQ22JGYH6wJmkZlgUF9CCi+XZuY48OW9A0YZUGLc6gNChXy9uLKoCopk+cvbKMWEJFq3FSuizogSoENoVjiGtaOhB4QI/Azk+QOSSp62xBIqI8ETKyjSQpXdK8J6wegSwNaktmpmZPFj2ZxzgsDWpPrVYgsOeBeq9TgWIsZGR5UHsxy3r2NiMQSJcTZWlQe1EFENM6Lkw0y4KWF3khd3J+z9wOioS6tjiWLN9j/c4ly0hqAjGN8xAisj8GAvvRzTffjJaWFuuya9euXO8SZUmt0dOooouyoIDewyHdJ5DlQe2q94FAI8DAVbi2kmnZlvYkSbLuH2Ig0BZaYymYiyvNk5g9UcbSoLakQSBqBOt8imz1B/S6FPg9DkRVDbIkIaxqqCzRA4E1Vkagsaq6i2CfQ5KssqNEPXXbbbdBkqQOl8MOO8z6fSwWwzXXXIPS0lIEAgGcffbZqKmp6fAYO3fuxOLFi+Hz+VBRUYEf/vCHSKU6foe8++67OOKII+B2uzFx4kQ89thjB+zL/fffj7Fjx8Lj8WDu3Ln45JNP+uVvpsEtFDWCDG5HryogFHn149fmKL8X7cicV5T0ICPQPMZp4KJEWzIDeb3JCJQkydqeixHtxczQzKQHvd/F/vN2pAqBiDFnMBca1jTr8439+wOavLIM6xvXIePvy3ZaixldsoSEYCCQiAYHBgJ7qKqq6oCJf01NDYLBILzeA2tIA4Db7UYwGOxwofxQE0pnBB7MKONE5m72CbStTDMC69riECxDZxvhPpRtaS9orN7lhM0ezBXyPpcCt6PnY8vMXXvSV+CmS/GY/QHLCvVJd1wTCDoUxDUNlUX692dbLIW2aNKaqLelDhIIVPmZTL03depU7Nu3z7p88MEH1u9uuOEG/POf/8Szzz6L9957D3v37sVZZ51l/V5VVSxevBiJRAJLly7F448/jsceewy33HKLtc22bduwePFinHjiiVi1ahWuv/56XH755Xj99detbZ5++mnceOONuPXWW7FixQrMmDEDixYtQm1t7cC8CDRomP0Be1MWFAAKzdKgzAi0JXM+UtqD+Yi5DRcl2pOZERjsRSAQSAcOuRjRXqw5pjvz0qARlnu1FRUCMWPOYAUCjYWH5vxjf7IkWdsOq/QjElfx0oc7AQCKJEEVwsoyJCKyMwYCe2jevHl46623Oty2ZMkSzJs3L0d7RLlU29p9RiAAjLQyAlka1K4yDQQmUhpaGSyyDbP3QiarNdszMwJZlscemjIoCwoAZQVG2axIAionZbahivTE29s+EGgsqolrGgoUBQlNwONSUGxkYFc3Ra0egQkhOu3B4ZCAhKZB5QIN6iWHw4GqqirrUlZWBgBoaWnBH/7wB9x777046aSTMHv2bPzpT3/C0qVL8dFHHwEA3njjDaxbtw5/+ctfMHPmTJx22mm44447cP/99yOR0D+/HnroIYwbNw733HMPJk+ejGuvvRbf+MY38Ktf/crah3vvvRdXXHEFLrvsMkyZMgUPPfQQfD4f/vjHPw78C0K2ZpYGLexlILDIy9Kgdtab+YjVI5ClQW0pnRHYu/dogdvZ4f5kD1ZpUFfmpUG5wNRetHatCvYvDVpZ3HkgsP22Jx81EgDw5sq9Vi9zCH0eQ0Rkd0M2ENjW1oZVq1Zh1apVAPTVuqtWrcLOnfqqjptvvhkXX3yxtf1VV12FrVu34qabbsKGDRvwwAMP4JlnnsENN9yQi92nHKsxS4N2mxFoBAKZEWhbDb0MBHpdCvxG1ll9K7ON7MKcpPn7mBHIsjz2YmYu9KYsKACU+FyQJEAI9tCxE1WI9MRbllHfon+GmhmBCU3ALevjBqQn49VNUXiVdEmetk76BDokCUmhPwZRb2zatAnDhw/H+PHjccEFF1hzgeXLlyOZTGLhwoXWtocddhhGjx6NZcuWAQCWLVuGww8/vEMf8UWLFiEUCmHt2rXWNu0fw9zGfIxEIoHly5d32EaWZSxcuNDapjPxeByhUKjDhfJfyMwI7GWQochYUNMaTyHJfqq205v5iLkosZF9kG0p3SMws4zAVs5BbCUbpUEjDATaSlLTELcyAvVzB2ZGYFUXpUH1bfXT51WVfkwfVwxVE3j1090A9L69kS6qlhAR2cmQDQR+9tlnmDVrFmbNmgUAuPHGGzFr1iyrlM++ffusEwEAMG7cOLzyyitYsmQJZsyYgXvuuQePPvooFi1alJP9p9yqbdVXDHWXETjKOInJHoH21WSV4um+J4eprMAsO8gAg12E45lP0trjJNxeMs0IdCiydR+WB7UPDenVsnqPQP27tLTdohqXLEOS9KBhlfEdWtMY7VCSp7M+gWZZnhQzAqkX5s6di8ceewyvvfYaHnzwQWzbtg3HH388WltbUV1dDZfLhaKiog73qaysRHV1NQCgurq6QxDQ/L35u4NtEwqFEI1GUV9fD1VVO93GfIzO3HXXXSgsLLQuo0aNyug1oMHFDAT2NiOwfZlC8zHIPpp6EQgsZb9yW8s8EGhmBHIOYifWYtM+lAYNszSorSTaL0xUZGhCoNbqEdh1RmB6HqLihMOrAAA7atoA6POX1k4WKhIR2U3fzpgOYgsWLDhof6/HHnus0/usXLmyH/eKBotaIyOw+x6BZkYgS4PakRDCyhYq9vf8hEpZwI0dDREGGGwknRHYt681c8V8HcfWFpoyzAgEgLKAC43hBN+nNpLSNKt/hk9plxEY9EAVApIElLoc2B2TkdAEqkrSGYHmfdpUDW2dBAIdkoSUEMwIpF457bTTrJ+nT5+OuXPnYsyYMXjmmWe67AFuFzfffDNuvPFG69+hUIjBwCEg3SOwd8c7DkVGgceB1lgKzdEkSgM9XwBH/a83GYEl7XoECiEgSVI396CBFMqwNGjQw/YEdtQWz7z9BEuD2lNSS5cG9SsymlrjSKoCiiyhNNj1Qn+fkT0YVjVMKdPP8+1tiEAIAZckoS2l8jOZiGxvyGYEEvVFjzMCjUBgSzRpTQrIPtriKSSME8q9yggMMNPIbvpStqW9CeV+AMCmmtY+7xP1XXOGGYFA+j3NFfP20aYKmGE6X/segYVuvS+gLKPU6YBblhDXtA6lQQFYfQIjnZYGBVQBJJkRSH1QVFSEQw45BJs3b0ZVVRUSiQSam5s7bFNTU4OqKn0leFVVFWpqag74vfm7g20TDAbh9XpRVlYGRVE63cZ8jM643W4Eg8EOF8p/ISNbqLelQYH0oppm9gm0nUarQkkPMgKN45uEqjHAYEMsDZpfIn3oQ8/SoPaUEhqiajoQaPYHLC/0QJG7DuIF2lUmqSr26uVA4yqawwm4ZAkxIZDgPISIbI6BQKJeiqdUK0ulu4zAgNuBYmPSzT6B9tMU1sfR61Tg7UVvObM3B3sE2kd6kta3HoGTKgsAAJtq2/q8T9R36Yzd3gcC0yV8+T61i1BKf5/KAGRNoMkI0pYFPYhpGtyyhAJFQUBRENfalQZtikIIYfXxaOukB4ckSRAAEhr7c1Dm2trasGXLFgwbNgyzZ8+G0+nEW2+9Zf3+yy+/xM6dOzFv3jwAwLx58/DFF1+gtrbW2mbJkiUIBoOYMmWKtU37xzC3MR/D5XJh9uzZHbbRNA1vvfWWtQ2RKdPSoABQ5NW/S1uiXCBjN7053mnfr5yLneynNcOMwHRpUAbq7cRqP5FB1Zl0RiBLRtpJUnTMCDT7A1YepD+guS2gBwKdDhmVRfo8ZU99BE5JQlITiLEHLxHZHAOBRL1UZwR/XA65R5Nwlge1r4awPpY9KcPTnhkIrOPk2zb6UralvUOMQODm2jaoLDGYc2bWQnGGpUEBlnm1k9aUfiLEp8hoaktACMCpSAj6nUhoAgWKAocsodipIKZpqCzSJ+SRuIrWaPKgPQIBQAIzAql3fvCDH+C9997D9u3bsXTpUpx55plQFAXnnXceCgsL8e1vfxs33ngj3nnnHSxfvhyXXXYZ5s2bh6OPPhoAcOqpp2LKlCm46KKL8Pnnn+P111/HT3/6U1xzzTVwu/Vjhauuugpbt27FTTfdhA0bNuCBBx7AM888gxtuuMHajxtvvBG///3v8fjjj2P9+vX47ne/i3A4jMsuuywnrwvZV7o0KDMC80U8pVrHsT3JCARglXY15zJkH5lmBAaYEWhLbVnoEWguWCV7iKRSSBnTBZ8io6YH/QHNbQEgYsxDhpemy4M6jWomcZ4/ICKbG7I9AokyVWP0B6wocPeo/veoYh9W727B7iZmBNpNU6Tn/TjaMzONGhhgsI2ItVqzbxmBo0t8cDtkxFMadjVGMLbMn43doww19aE0qBmw52p5+2hpFwisN75LS4MeyJKEmKahyKm/fwMOBQISXE4FpQVuNLTGUd0YRcChT8DbOikNCuh9X9kjkHpj9+7dOO+889DQ0IDy8nIcd9xx+Oijj1BeXg4A+NWvfgVZlnH22WcjHo9j0aJFeOCBB6z7K4qCl19+Gd/97ncxb948+P1+XHLJJfjZz35mbTNu3Di88soruOGGG3Dfffdh5MiRePTRR7Fo0SJrm3POOQd1dXW45ZZbUF1djZkzZ+K1115DZWXlwL0YNCiYrQYyyQg079PEQKCtmBVKFFnqccnXEr8LOxsjqOcxju20WuV7MysNGmIg0FbMsp6BPpQGZQlf+xBCoFXV5woSAK+cLg1qZvh1xW/1CNTnIcNLfVixuQF7GyJQJAkaJCvTkIjIrhgIJOqlOqs/YM96yo0s0Q8oWBrUfswAQW8DgeXsEWg74T70b2hPkSVMKA9g3b4QNta0MhCYY+bJyqI+ZATyfWofVkagLKO+xegPaJTYFpDgd+gTbK+sB/yEEKgs8eqBwKYo/KX6/4OuMgIVWWJJHuqVv/3tbwf9vcfjwf3334/777+/y23GjBmDf/3rXwd9nAULFmDlypUH3ebaa6/Ftddee9BtiNIZgb0/3jG/S1siDB7ZiZnVV+xzQT5If6r2zGMcs6Qo2UdfS4O2xRmotwtNE1Yfel9GpUHNjECWBrULVaQDeV5ZhixJ7UqDdhcI7FiZZESZnhG4p0E/zydBIMYFiURkcywNStRL6YzAg9cQN40qNkqDNrE0qN2Yk+dMS4NyFa59hI2VlplM0vZ3SGUAAPsE2kFzFjICGQi0jxajt59PkdFgZgQWeiCEAISAzwgA+hQZLklCQggMMybl1U1RBLopDeqQgAhX4hJRHgtF9eOdvvQIbI4y0GAn5nykp2VB9W1ZncSOhBAZlwYtYGlQ24kk0wG8jDICjfuEmRFoGyqENY/wKzKEEO1Kg/a8RyDQsTQoACiQEO2iagkRkV0wEEjUS7VGRmBlsGcZgekegcwItJvGDEuDljLAYDtmI/dMJmn7m2T0CdxY09rnx6K+yUZp0PpWBuztoq19adB2GYEJIeCSZXiVdCDQo0iIa8JanVvdGLUm4Obj7M8hSVyJS0R5zcoI7GW2EcAegXZlBgKL/T0f0xKr6gGPcewkltSQMo5DepsRGGQg0HbMsqCyBHicvT91agYCWRrUPvSMwHQgsDmcQDypQZKA8sJeBgKNyl8t4STaokm4ZAktSQYCicjeGAgk6iUrIzDY04xA/QBhd1NUz3og22jMsDSoWY4nklDZ/NsmzNKgvgwaue/vECsQyIzAXIolVcSS+kSrqBcnx0ylxvu0IRznZ69NtBkTZ2+7HoFlhR7ENQG3IsFnTLBdsgyfLCOuaagyJtk1TVEErN4cXWUE6qVBNY43EeUhTRNW2cGMMgJ9zAi0o3RGYM8WmerbsjSoHZnvT1nqfd9yM3BoPgblnhnA87sckKSele1tz+wRyNKg9qEJYZUG9Snp/oBlQQ8cysFPj6cDgUZpUbcDpUa7oL0NEThlCW2chxCRzTEQSNRLta1madCeTdZGFHshSUA0qXLVps1kWho04HbA7dA/PpltZA/hPjRy39+kCr006Ja6NqjMLsoZMxvQIUsoyGBczYzApCqsUmqUW23tJt71oXRGYFzT4JNluOX0YWmR04GYJlDVrjSoT5GMx+k6EJiCQJITcCLKQ22JFMzDkmBGpUHZI9COMpmPmMc4Zn9BsodQLD0f6W3gqH1pUC5gswez4kymPejNHoHMCLQPVQhEVP39pQcCe1YWFAD8xoLEiKpZ71GzPOiehojV1oDVSYjIzhgIJOqlWuPkZU8zAt0OBZVGP8FdTSwPaieZlgaVJMmagNexPKgtpBu59z0jcFSJD26HjERKw06W9M2ZprC+IrrI58xoFa7HqVgBRL5Pc08TAhEzI1BO9wg0MwKLHB3fu0GHAlUIVBR5IElAPKlBS+j3jxwsEKgJJDkBJ6I8FDIy+VyKbC1I6w2rNCgzAm2lIYNAoFX1gItMbcXM5uttWdD290lpwqqIQbllVpzxZ1hxxswITKQ0JLs4dqWBpQKIGAsT/Yrcrj+gt9v7mpVLUgJIGIHAEWXpPoFOWUJS0xBnv3IisjEGAol6ycwI7GmPQAAYZZQ2Y59Ae0mX4smg/1gB+wTaRVLVkEjpB9zZyAhUZAkTjaxA9gnMnWYjUF+UQX9AE9+n9qEKIGJMjGVVQ0oVkCSgOOBCSggEnR3fu2a/QIcio8xYeBM1TniamYX7c0gSUkJYk3Mionxi9Qf0ZrZAhj0C7SmTVgXmtqw2Yy9mfz8zu683/C4FsmQ+Dt+jdmBWnMk8IzB9v0ic5UHtQBXCmo/4FcUqDVpZ1H0g0CNLMEPCbca5BysjsF7PCEwKIMZAIBHZGAOBRL2QSGlW8KiioGcZgQAwqlg/QNhtlB4gezAn3sUZBALLA+YEnAGGXGs/sfK5+h4IBNJ9AjcxEJgzTcaJymJf71dVm8wgP1fM554qBKJGKR4trk+QSwJuqx+HV+54Utsny3BIEpLtyoOGmvXP25gmkOok2KdIQEowI5CI8pNZ5jrozexYp9CrfyeGYkmWPreRTCqUmJVJmiIJaBxL2zADgcEMMgIlSbIWNJolRim32vcIzITLIcNlHOe2JTimdqCJdGURfxelQcMpFTXxA4PxkiRZfQLNxzADgXsbIpAkCUIIxPmZTEQ2xkAgUS+Y5eWcitSrk9MjS/QDBGYE2kcipaHVOLjPKCPQmICzR2DumRMrlyLDlUGprM5MqjQzAtuy8njUe+aJseK+ZAQGmBFoFyrSK3ATxgmu0kI3kpqAIknwKR3LLnkVvWdgTNNQZWTVNzfHrN+HOymxJEsSBMCMQCLKSyEjS6gwg/6A7e8nBDOO7CSTCiXmsZGqCStTlHIvXRo0s8CRWR6U7097iCT61iMQAHxGWdEI+wTagr4wUZ9D+BQpHQhslxHYmFIRVjWoncwnzPlK2KhOYpYGrQ/FEUuoACTr8YmI7IiBQKJeqDH7AxZ4elWSZ5SRzcAegfbRZAQZFFnKaNWmGWBoCDPAkGvmxMqXYf+GzhxSoWcEsjRo7jSHsxAILGDmrl1oAtbEOG5ktZQFPUhoGjyyDK/S8TvVK0vwyRISmrD6dtQ2xeCT9UPXcKrzEksS9P46RET5xioNmsFxK6Bnp/iNXsosD2ofZiCwJNDz4x2XQ0bQCDZxLmIffSkN2v5+bQwa2UK6NGjmc0wzm5Bjag8qgKgxT5BVgagR7K0oSmcEqkIg4FAQ6ySgZ2YEmgsSC7xOBI0EgX2NETjkrlsYEBHZAQOBRL1QG9InWhW96A8IAKOsjECWBrULs1Rgsc8JWe59n5VSlga1jb6WbemMWRp0a10YKa7qywmzNGiRP/PSoOmMQGbu5poqhNUzI2KMR1mhGzFNwC1J8ModD0klSULQ4dAzAo1AYHVT1JqAt3XxvmRGIBHlq1C0bxmBQLrvbjOzyGxB1YS1OLGklwufrEWJPMaxjXRGYGbvUTMQ2MrSoLbQ1scegfp9jYzABINDdqC1ywhMRPUxKSlwweXUxykljEolsmRVMmlv/0Ag0K5PYIPeJ7A1xXMHRGRfDAQS9UJtq5kRmFkgcG9zlD05bKIpg34c7bE0qH2ky7ZkLyNwZLEXXqeChKphB0v65kRzFkqDlrI0qG2o7TIC24zPzbKgBwmhocipQO4ky77IqSCpwQoE1rQLBHZWGhTQD2zjDN4TUR4yA4GZ9ggE0kFE8ziYcqslmoS5dqW3PcvNRYkNYY6lXYT6nBHI0qB2Ys4xA30KBDIj0E40AWthYsxYRGFWHgH0uYpXllHkdHRa4tPvOHAeMqJdn0CnLCGiqp2WFSUisgMGAol6wcwIrAx6utmyo6qgB05FQkoT2NfCrEA7MCfNfQ4EMsCQc9lYrbk/WZYwsULvE7iJfQJzoimSztrNVDkzd21Dg0DMWAgTatHHoyzoRlwVKHR0HsT3KTKEpGcOypLe29UNPWAY7qLsjkOSEGEgkIjykBlk6FtGoH7fFpYGtYVGo6xn0OOAU+ndqRlzDtPAYxzbSJcGZUZgPjDnmD5X30uDhhkItIWUSM9HzIWJ7fsDRlQNhQ4FlS4nOlu/f9CMwPoIXLKEhECnZUWJiOyAgUCiXkj3COxdRqAiSxhuHGCwPKg9NBqT5kwDgeVG77E6Tr5zLpLIfmlQAJhkBQLZJzAXrNKgfekRaATszUUclDsxVSBprI5tata/S8sK9UU1/oMEAh0SIMkSyo3eHYpqTN67mGA7JAnRTkr5EBENdn3tEQikA4HNzAi0BbOsp1nBoDdKWf7cdtKlQfvWIzDEQKAtmMG7vmUE6se4YZYGtQUN6QolLS36fGT/jMAKlwMBhwxFlpDcLxroV4zxbLcgcXi7jECXJCOhaVawkYjIbhgIJOqF2lazR2DvMgIBYFSx0SewiWUG7aDRCDL0NSOwNZZCLMkD+1xqi+uvf19Wa3ZmktEncGMtMwJzIRulQSeU68HcPc1R1LUyGJhLLan0Sa14VP+5qMAFScIB/QFNPlmGS5I69AnUjM/bcBf9NxRJQlTVIFiSh4jyTDZ6BBZ62SPQThr7UKGkzLhPI0uD2kYrS4PmlbA1x+x7aVBmBNpDXNWsXuJNTUa1r2L93J4QApCAAoeCAkWBT5EPWFzoMzIC21cfGVGmn+eraYpCEgIpLd0XnYjIbhgIJOqFTDMCAWBUiX4Sczf7jdmCWYqnxN/7sQT0kzBORS9Rx94cuRXJwmrNzhxSyYzAXDIzAvtSGrTY78KUYUEAwNIt9VnZL8pMa0o/meKSJEgCKPA6ISkyPLJsTar35zV+n9CEtVpXjRmBwK5Kg8oSUhBIMQ5IRHnGygjsQyCw2MoIZKDBDhr7sOjJzAhsCHOhk120xvuWtcvSoPYSttpP9L00aISBQFtoSaXnD/X1+nk5c44R1wTckoygQ4FHkVGoKAf0CeysNGhxwAWPS4EmgOrGKCCBgUAisi0GAol6wcwo6W2PQAAYaWUEsjSoHVgrcDMMMkiShFIjiFjPTKOcMidpvj5M0jpziJERuLUujBTr/A8oVRMIxfpeGhQAjp1YCgBYurmhz/tFmQsZ7yFzNMsK3YhrGtyy1GVGoCxJCDplxDRhZQTGjZPX4S5LgwIpASQE37NElF/M78VslAZtYUagLTSapUEzyAg0swhZGtQ+mBGYX8KJbJQG1e9rVrCh3GpK6mPqkSSEjfer2SMwqmnwKhIKjJYF5S7HAYHAgBEIbN+iQJIkjGhXHhRgj0Aisi8GAol6KJHSrMyvzDICjUAgMwJtwQoEZtCTw1RWYE7AGQjMJbPngj/LGYEjirzwOhUkVA3bG/i+HUgt0STMyo5FfcgIBIBjJpYBAD5kRmBOhYzSoA5jXlwW9CCuCQQUBQ5Z6vJ+xQ4H4u1Kg0Za9c/uplQXGYGShJQmDujpQUQ02LVkoTRokVkalD0CbaHBmo9kkhGo36eB8xDbSAcCM3uPBpkRaCvWYtO+lAY1WleYPe0pt0LG/MEt6XOPQr+ezQfo5T7LXU4oxu8KHAogoUO7gXRp0I7zELNP4J6GCFyShFAXLQyIiHKNgUCiHjKDPU5Fyqh8yyjjJCZ7BNqDGQjMZAWuyewT2MCVuDlllW3pwyStM7IsYRLLg+ZEk3GCssDtgLOLspE9NWdsCRyyhN1NUexkQDdnWo0JsaTqk+nSoJ4RWOw8eCavX1EAAVQZ5bUj1foYrmuLdhrsc0gSUtCQZI9AIsozIaO/atCb+fFOoVkalBmBttCX+Yg5D2GPQHsQQliZfJlnBDIQaCdmj8DsZARyTO0gZATwHMY0wewPCABJTaDEmR7rAocCtyRbPQUBY16CAyuTmH0C9zRE4JQltHbRwoCIKNcYCCTqIbM/YHnADfkg2QtdMTMCa0JxxJI8MMg1c9KcSVDXZJYGreNK3Jzqr4xAAJhUoZcH3VTblvXHpq41me/PPgTqTX63A7NGFwFgVmAumT0CRVKfOJcVeqBBgt9x8ECgV5EhSxKKC9xQZAlqcwIFsl4u9Mtw7IDtFUmCJoAEMwKJKI8kUhqixvyhbxmBRmlQ9gi0hb7MR8zSoE2RJEvY20A8pSFpLHbKNBAYcOvvTwaN7CEbPQLNIGKYY2oLZkagbCxQNMuCqkJAkoBgu3lJgaLAq0iItPt87axHIJDOCNzbEIFLlhHTNFYnISJbYiCQqIdqjT5wFRn0BwT0lZ5eI/NhTzP7BOaSpgk0GSdASjMoxWNiaVB7SGcEZrdHIAAcYmQEbmRG4IAy35/FfSwLajpmglEedDMDgbli9tJQjdXVpUEXIAR8XfQHNPkUGS5ZQgpARZEHEoDxin5SZUUo3Ol9JAFmBBJRXgm16xmWadlBIN13lxmB9tDYh9KgxT4XjAp2aGSp15wz36OSlHmVknRGIN+fuSaEsHoE9mWxqdnD3ly4SrllVigxFyaarQeiqgafoiDgSM9LHLKEEqej00BgRNU6lAw1ewTua4zCIfTswpjGBRpEZD8MBBL1UK2REZhJf0BAbyI8yihtxj6BuRWKJaEaK7T6khFYbpTkqWdp0JxKr9bMfkbgIZVGRmANMwIHklkatKgP78/2jjX6BC7b0gCNqzNzwlyBmzTKXRUWuOGSZXi7Kf3qlWW4ZalDn8DyhD6GK1o7/y4VEjMCiSi/hIzAXYHbASWDyiQms+9ucyTB70Mb6EtpUEWWUGIcJ7E8aO6Z5TwDbkdG1YOAdCAwxNKgORdLajA/Ivsyx/QzI9A2hBBWhZJUTL82S4NGVA0FinzAAsUyl7NDZp8ZCNQARNvdXl7ogVORkExpaGmNIyEYCCQiexrSgcD7778fY8eOhcfjwdy5c/HJJ590ue1jjz0GSZI6XDyezDLDaHAyMwIrM8wIBIBRxfpKoV1NzAjMpYZwuv+Yy5H5x6DZm6O+lRmBuZRerZn9jMCJFXpG4Nb6NiRZdmnANEfMUlnZyQicOaoIXqeChnACXzK7MydarUCgfl0QcMGtSPB1Ewh0yhICioK4JlBpBAJdTUnIAHbHkqhLdL5qPsHJNxHlkRYjEBjsQ1lQIF1WVBNAW4InpnNJCJHOCMywFLpZ2YT9ynPPDAQG+5Cxa2b7JlIa4ilmkOVSuN3no6+bftYHY2aHRpgRmHMagIgxP4gb1WfMuUVE01DhckKSOgbxCxwyJEmCZmT/uWQZTmObcLs+gLIsYZjZCqgxClUIxLjYhohsaMgGAp9++mnceOONuPXWW7FixQrMmDEDixYtQm1tbZf3CQaD2Ldvn3XZsWPHAO4x5VpNHzMCAWCSkV20fHtjVvaJMtPUhzI87VmBQJYGzamIUWow0zI8BzOiyAufS0FSFdjR0HkZQso+szRotjICXQ4Zc8aVAGB50FwxS4NKKQ0elwLFJRvZft0fihY7FSQ0gSojq76pMYpD/PqinBWhA7MCnZKEKAP3RJRHzAyhvgYCPU4FHqf+udscZvnBXGqLp5AwvqsyDQSa9+NcJPfMcp6Z9gcE0v3k9MdjoD6XzAw+n0vJOMMTSC9UZd/H3GtOqtbCxERUv64wegQKARR2EvAtUBR4ZAlRrQd9Asv0QOCehggkAcQ4FyEiGxqygcB7770XV1xxBS677DJMmTIFDz30EHw+H/74xz92eR9JklBVVWVdKisrB3CPKdeykRF40mEVAIC3N9QyuyiHGvq4+tZk9gisbY13qBFPA6utH0uDyrKESRVmn0CWBx0o6YzA7AQCAeCYCaUAgKVbGrL2mNRz1qrZlIayoBsJARQ7erbCOuBQoAphlQatboriiKA+2V7ZSSDQIXWcsBMRDXZWRmAfggymIq/ZJ5BZZLnUZARiPU4ZvgwXs5UaixKZEZh7ZuCuL4FARZasYCADgbmVrfmluVCVpUFzb3csgdZ2CxMLvE74PQ7ENQ1uWUJBJ/MSvyIjoMiIqulzPb52fQLbM/sE7qmPABK4KJGIbGlIBgITiQSWL1+OhQsXWrfJsoyFCxdi2bJlXd6vra0NY8aMwahRo/Af//EfWLt27UGfJx6PIxQKdbjQ4FUT0gOB5cHMMwJnjylGid+FUCyFT5kVmDNWGZ4+BhnGlPjhccpoiSaxdi/f37lillrpj0AgkM7k3ciSkgPGPDlW7M9OaVAg3Sfw460NXIiRA9aq2ZRAadCDlBAIOnv2nvUaWYOVRfpCnNrmGGYE9KDgF23RDr07ACMQyDGmbtx111046qijUFBQgIqKCpxxxhn48ssvO2yzYMGCA1oDXHXVVR222blzJxYvXgyfz4eKigr88Ic/RCrV8YTfu+++iyOOOAJutxsTJ07EY489dsD+9KZlAQ09oSyVBgXa9wlkRmAuNYT1uWWpP/O5ZZmfPQLtIp0R2Lf3qBlINB+PcsOcXwb6Ggh0p0uDsi9r7oRVFTticajm4u2UZvUHjKoavIqMAuXAQKAkSSh3OTvMK7rMCDQCgXsbInDJMkIqy8ESkf0MyUBgfX09VFU9IKOvsrIS1dXVnd7n0EMPxR//+Ef8/e9/x1/+8hdomoZjjjkGu3fv7vJ57rrrLhQWFlqXUaNGZfXvoIFV16qXBq0syDwjUJElKytwybqarOwX9V5f+3GYvC4F8w8pBwC8tqbzzw7qX0KIdI9AV/Z7BALAIZV6RuAmZgQOmCYjIzBbpUEBYMqwIIp8ToQTKlbvbs7a41LPhNutwC0r1E96entYasmnyHDJEgIFLjgVCaomEEhoKHbovQPXhTv23XVIQEIIpHjChQ7ivffewzXXXIOPPvoIS5YsQTKZxKmnnopwuGMZ6CuuuKJDa4Cf//zn1u9UVcXixYuRSCSwdOlSPP7443jsscdwyy23WNts27YNixcvxoknnohVq1bh+uuvx+WXX47XX3/d2iaTlgU0tJgZgYVZCASaj9EcZaAhl7IxHykxgohmUJFyJxsZge3vz4zA3GprVxq0L9oHEiNJBoZypTqeREtKRcKYG0hJLd0fUNVQ6nTA2cW8pMjpSAcQ0T4Q2HE8R7QLBDqh90dn1SgispshGQjMxLx583DxxRdj5syZmD9/Pl544QWUl5fj4Ycf7vI+N998M1paWqzLrl27BnCPKZuSqoZ6o+RKRR8yAgFg4WQ9AP3m+hoeGORIY5Z6BALAadOGAQBeXbOvz49FvRdNqjDfRv2dEbiplhmBA8XMUij2ZS8jUJYlzBuvlwf9cDPLgw4kIUR6JW1KoLjADUWS4Otk5W1nvLIMtyIjKdK9PGqaYlZ50P37BDokCSmhBwOJuvLaa6/h0ksvxdSpUzFjxgw89thj2LlzJ5YvX95hO5/P16E1QDAYtH73xhtvYN26dfjLX/6CmTNn4rTTTsMdd9yB+++/H4mEfqzx0EMPYdy4cbjnnnswefJkXHvttfjGN76BX/3qV9bjZNKygIaWUMwsDdr370Wz7HZNS6zPj0WZM1sVFPchEFgaMHsEMiMw10JZCwTq73FmBOZWOEulQT1OGWZ8KcLyoDmR0gS2RuLwyXK6nGdKoNKYUySEQKmr6+/WAocMRZaQMuYVfmP+sn9GYFWJF7IERBMqopEkEkIgzkWJRGQzQzIQWFZWBkVRUFPTMSOrpqYGVVVVPXoMp9OJWbNmYfPmzV1u43a7EQwGO1xocDIbsDtkqc/lJE84pAxuh4xdjVF8yVKDOZGt0qAAcNLkCjgVCVvqwtjE8Rxw4Xh6JZ63kwbf2XCIEQjcVh9mSckB0tQPPQIB4BijPOiHm+uz+rjUPbNnn5TSUFTggluW4VV6lhHoUWR4ZRlxTUNVSbpP4Kwu+gQqkoSUJpBkn0DqhZaWFgBASUlJh9uffPJJlJWVYdq0abj55psRiaT/vy1btgyHH354hyojixYtQigUsloILFu2rEM7AnMbsx1Bpi0L2IJgaAllMSPwiDFFALiILdeajPlIaR8CgWUBlga1i2yXBg0xIzCnIvHslAaVJMnqE9jGQGBO1CaSqEukUOJ0dKhQUlnsgSYEAAlBR9enxgOKAq8sW4sauyoN6lBkK8uwrimGhCoQ51yEiGxmSAYCXS4XZs+ejbfeesu6TdM0vPXWW5g3b16PHkNVVXzxxRcYNmxYf+0m2YjVH7DADbmHpcy64nM5cJxxMnrJWpYHzYVslQYF9JXZ5ni+yvKgA27ZVj2zqzLY9/dmV4YXehBwO5BUBbbXh7u/A/WJEKJdadDsZQQCwLET9IzAlTubEU2wPM9AiqpmTw6BQMANjyRZvf96wiwDak6wq5uiOLzACwXA3ngS1fH0ynmHLCEFgSQX4VIPaZqG66+/HsceeyymTZtm3X7++efjL3/5C9555x3cfPPNeOKJJ3DhhRdav6+uru601YD5u4NtEwqFEI1GM2pZALAFwVATiuonkIPevlc/OGPmCMgSsGJnM7bWsex5rmRjPlIaMEqDtrE0aK5lrzSofuzbxkBgTmWrNCgA+NxGBlmcc49c2BGLAxBwylI6IzCpzymimgavLHXaH9DkVWQEHYp1364CgUC6T2BtYwQJoSHGjEAispkhGQgEgBtvvBG///3v8fjjj2P9+vX47ne/i3A4jMsuuwwAcPHFF+Pmm2+2tv/Zz36GN954A1u3bsWKFStw4YUXYseOHbj88stz9SfQAKoN6aVzKoKZ9wdsb+GUdHlQGnjmxLs0C6VBgXR5UPYJHFhCCDzy/hYAwPlzxvTb80iShIkVep/AjewT2O/CCRVJI2iUjWB9e+PK/BhW6EFC1fDp9sasPjZ1TQiRzghMaggUOFHoVCBLPQ/eB50OpISw+m98uTsEv6LgsID+vdw+K9AhSVAFkBRchUs9c80112DNmjX429/+1uH2K6+8EosWLcLhhx+OCy64AH/+85/x4osvYsuWLTna0zS2IBhazNKg2cgIrAh6cILR4/r5FV33u6f+1ZCVHoH6fRtYGjTnspURaGagsUdgbpmlQfuaEQiky4uafe1p4DQnU9gbS6LU6PMX0dpnBHoRUTUEFNkK7nWl3OVAzLivz9g2cpBA4L6GKDRI1n2IiOxiyAYCzznnHPzyl7/ELbfcgpkzZ2LVqlV47bXXrNW4O3fuxL596XIpTU1NuOKKKzB58mScfvrpCIVCWLp0KaZMmZKrP4EGUE2rvsqyoqBv/QFNJ0+ugCQBn+9uQU2I/TkGmhkIzFbZwYVTKqHIEtbtC2FnQ6T7O1BWfLS1EWv2hOB2yLhoXv8FAgFgkhUIZPnX/maWynI55KyXe5UkCcdM0DN4l25hn8CBElE1mOthHQJwex0ocvRubL1Gxu8RE0vhUCTsqGnDturWLvsEAkCCq3CpB6699lq8/PLLeOeddzBy5MiDbjt37lwAsFoDVFVVddpqwPzdwbYJBoPwer0ZtyxgC4KhpSWavR6BAHD2Efr/9RdX7IHGz8qcaMxGaVC/PjdtjacQTzHbKJfMwF2wjxmB5v3ZIzC3wkblkGz0oDeDiWGWBh1we2IJRFQNfoeS7lcOwCfLCHgciKoaKlxOSN0sTgw6FJitxwNG9mBbJ5+5I8r0ecmehggkCGYEEpHtDNlAIKBP/Hfs2IF4PI6PP/7YmtwDwLvvvovHHnvM+vevfvUra9vq6mq88sormDVrVg72mnKhzgjWVQazEwisKPBg5qgiAMCSdcwKHGjpiXd2xrPE78LccXpPIfZbGTi///dWAMA3jxyZ9cyx/Zl9AjfVMhDY35oj+omPYl/3k7JMHDtRLw+6dAv7BA6UkDnx1gRK/C5IkODvZSDQpyhwSBI8HgeOnKQHc99dXY1ZBfqEe21btEMfDkkIJAUn39Q1IQSuvfZavPjii3j77bcxbty4bu+zatUqALBaA8ybNw9ffPEFamtrrW2WLFmCYDBoLRacN29eh3YE5jZmO4JstCyg/Gf1CMxSyexTplSiwOPA3paYVWadBpaZEVjch2PYoNcBh7FQhn0Ccyt7pUGZEWgHZtDOn43SoMZjhNmWYEDFVA3bowkUGgtLrQw+VUNVkQeSJEETQJGz+/dsgUOBS5YQ17SDlgY1K5fsbYhAkSREuECDiGxmSAcCiXrK7BFYUZCd0qAAsHAyy4PmQjShIprUD8hKslQaFABOm6av2mefwIGxqaYVb2+ohSQB3z5ufL8/36RKlgYdKGZ/wGxl7O7vWKOn5xd7WtAS4WrrgdBqToJTAuVBNyQJveoPCOhleNyyjLimYcEM/fN26dpalMsKypwOJITA2raotb2QgCRX4dJBXHPNNfjLX/6Cp556CgUFBaiurkZ1dTWiUf3/0ZYtW3DHHXdg+fLl2L59O/7xj3/g4osvxgknnIDp06cDAE499VRMmTIFF110ET7//HO8/vrr+OlPf4prrrkGbre+2Oiqq67C1q1bcdNNN2HDhg144IEH8Mwzz+CGG26w9qW7lgVE2c4I9DgVfHX6cADA88tZHjQXmrKQEShJEsuD2kS2SoOa92+N8xg1l6xAIDMCB63qRBJNqRQKjcWHVuAupfcHTGoCDllCQQ8WJxYoCryKjKiqHbQ06LASPRAYiiSRjKUQYiCQiGyGgUCiHqhtzW5GIACcavQJXLq5wWpGTf2v0QgyuBQ5Kyv8TIumVkGSgFW7mrGvJdr9HahPHv33NgD6+2hcmb/fn8/MCNxeH0YixVr//ckMBBZlKethf5VBDyaU+yEEmAUxQMxAoJTSUBx0wyPL1iS6p7yyBI8sIa4JTBlThPJCD6IJFZ9urMcsozxo+z6BiiR1OkEnMj344INoaWnBggULMGzYMOvy9NNPA9Az9d58802ceuqpOOyww/D9738fZ599Nv75z39aj6EoCl5++WUoioJ58+bhwgsvxMUXX4yf/exn1jbjxo3DK6+8giVLlmDGjBm455578Oijj2LRokXWNt21LKChTQiBkJEdlI0egaZvzNbLg766pppzkRxozEKPQAAoDejz0/q2eJ/3iTLHjMD8Yp4zyEYg0OdiIHCgaUJgWyQOtyxBMSrMmIFAKamhssiLiKYH9Qoc3c9JnLKEEqdDLzN6kIxAj0tBmXHOsLE5hjZVg8YKJURkI33/ViMaAvojI3BiRQBjS33Y3hDB+xvrcPrhw7L22NS1xrb0pDubZQcrgh7MHl2Mz3Y04bU11bjs2O5LjFFmaltjeHHlHgDAlSf0fzYgAAwr9KDA7UBrPIXtDWErMEjZly4N2n/lXo+dWIYtdWEs3VKPr0zrugcXZUdINTMCNRQWeOCSpV5nBEqShEKHA7tjcciSAwtmVOHZ97fj3c+r8ZWvTcKShhBWhCL4TyEgSRIckoSoxkAgdU10c2Jm1KhReO+997p9nDFjxuBf//rXQbdZsGABVq5cedBtrr32Wlx77bXdPh8NPeGECtXIcA56szd9P2J0EcaV+bGtPoxXv9iHbx45KmuPTQcXT6lW8LWvrQrKjAonLA2aW+lAYHYyAkMMBObMB5vq8e6XdQCAKcP73n/Xb2UEMjtsoNQlUqhOJFHhSn9nRtpnBJZ6EFE1VLoccPdwTlLmcmJbNH7QQCAADC/1oT4UR11jFGOGBxHTBHxK9ttdEBFlghmBRD1Q22oEArOYEShJUro8KPsEDpiGsD6W/dFT7issDzogHl+6HQlVwxGjizB7TMmAPKckSZholQdln8D+lM4I7L9A4DET9PKgH25mn8CB0JZKT7wLAi4UKIrV06g3ihwyEsbJ8BOmVUKWgI17QiiLa3BIQE0ihX1GKS2HBESZEUhEeeDTbY0AAJdDhteZvWoWkiTh7CNGAACeX8HyoAPJDNopstTnDDKWBs29WFJFwjjmyF5GIEuD5kJzJIHvP7sKAHDR0WNwxOjiPj9mwG32CGRwd6DsjCagCdEhyBc2FiZKSQ1VxV7ENQ3lPegPaCpQZEiQ0qVBNQ1qJ4vKhht9Amsbo0hqWoce5kREucZAIFE3UqpmBY+ymREIAKcY5UHf/rIWKZ6wHBBmkKE/A4Gfbm9EXSvL8/SHcDyFv3y0EwBw5QkTBvS5D6nQswDZJ7B/pTMC+6c0KADMG18KWQK21IVR3RLrt+chXahdadBAwIniDE9k+x0KhBE/LC5wY+aEUgDAsjW1mOL3AgBWGOVBHZKEuMZyPEQ0uNWEYvjBs58DAM45clRWq1kAwJlHjIQkAR9tbcSuxkj3d6CsMAOBxT4X5AwWxrRnZhTWhzn3yBUzG1CSgICLpUEHKyEEfvziF6gJxTG+3I8fnz45K4/L0qADqzWlYlc8gZL9gnytyXSFkvJCDyCAgt4EAh0KPLIEGenP7M4WHY4o0wOB1Y1RJAQQYyCQiGyEgUCibtS3JSCEvmKzL83cOzN7TDGKfU40R5L4dHtTVh+bOtfQ1n+BwJHFPkwfWQghgCXM8uwXz362Cy3RJMaW+qxA+kCZZGQEbmJGYL+JJVV8bGQ+mD1v+kOhz4lpIwoBAEu3MCuwv5mBQKQEioIe+B2ZBQK9sgxFgrX69sQZ+uKLf6+pwfSAEQhsTQcCUwJWBiER0WCTUjVc99RKNIQTmDwsiJ8szs5J6fZGFHkxb7y+qOKFFXuy/vjUOTMQmI25ZWmAGYG5ZvaHD7gcfQ7sBo3SoMwIHHjPr9iDf31RDYcs4b5zZsHryk4GdsDNQOBA2hNLIJxSEdivH3mdsSDcoQm4vQ54FRnBXsxJ/Ire4zwpBNxyx76D7Y0wMgL31kcgCYGYyrkIEdkHA4FE3agJ6dki5QF3nw/s9+dQZJx4WAUA4M31DBwNBHPi3R+BQKB9edB9/fL4Q1lK1fCHD7cBAL59/HgoWX4/dsfsC8jSoP1DCIGfvrQG6/eFUORz4rR+7t2XLg/a0K/PQ0BNVP/clVIaCvxO+HrZH9DkU2S4JRlxI7g3fXwJigMutEVTcDbomRDr2qKIqRockgRVCCSZEUhEg9Q9Szbik+2NCLgdeOCCI+DJYlnQ9s4+YiQA4IWVu7vtnUnZkc35CHsE5lZTOIHr/7YKADBjVFGfH8/MCIwlNSRZMWjA7GyI4Na/rwEA3HDKITh8ZGHWHttnlQZlj8D+ltA0bIvGEXDIB2TQN0T14LrfoSCqCXhl+YBg4cHIkoRylxMRTTton0CzNGhDaxyxhMaMQCKyFQYCibph9geszGJ/wPZONbKalqyr4eS7n8WSqpWpN6wwu2VeTadNGwYAWLalAS0RruTMptfX1mBXYxTFPie+YZy0GkhmRuD2hgjiKU7ksu3xpdvx3PLdkCXgd+cdgeFF3n59vmMn6hkQS7fU87O3n1UbK3DdsgyfU4G3F5Pu9ryKDLcsWb02FFnCCYfrAePVX9SiwuVASgBr2qJwSBKSQjAjkIgGpXc21OLBd7cAAO4+ezrGlfn77bm+Mq0KPpeCHQ0RfLaDFUoGQjYrlJQYpUEb2lgadKDFkiou//Nn2FofxogiL+751ow+P6bfnS5V2MbyoAMipWq48ZlVCCdUHDW2GFfNz277CWYEDpzqeBINidQBZUEBoMnoI17odCCiaahwOyH3stx2sVOBKkS6T2AngcCA14lCv57Z29wSRRvPGxCRjTAQSNQNKyMwy/0BTcdPKofLIWNnY4S9x/rZz1/7Eptq21AWcOMbs/snkDSuzI/DqgqQ0gSWMMsza4QQeOR9/YTYRfPGZq1US29UBT0ocDugagLb6sMD/vz5bNmWBtzxynoAwI9Pn4zjJpX1+3MeOaYELkXGvpYYx7Of1RvlrXyKDLciw5thRqAiSQg6FCsjEAAWzKiCBGDtjmYc5tZPqK4IReCQgBQzAoloENrbHMUNz6wCAFw8bwwWTx/Wr8/ndztw+uH6czy/fHe/Phfpstmz3CwNuqMxghDLSQ4YVRP43t9WYvmOJgQ9Djx22VGoDPb9fIFTkeE1sn/ZJ3BgPPTeFny2owkBtwP3fmtm1qvOsEfgwBBCYHs0AacsQekkwGf2CCz2OKEKkVHP8gJFgSwBfmMu06Z2HuQzswLrG2NoZWYvEdkIA4FE3ejvjEC/24FjJ+iZKSwP2n8+2FSPPxplJX/xjen92n9s0VQ9Q+U1lgfNmk+3N+Hz3S1wOWRcPG9MTvZBkqR2fQIZtM+W3U0RXPPUCqiawJmzRuDbx40bkOf1uhQcMaYIAPDhFpYH7U+NxokPn0MPArr7cIKlyOHoUGKnvNCDqWOLAACiRu/RszKk9wmE0EsEERENFklVw7VPrUBzJInDRxT2S1/AzpjlQV9ZvQ+xJLMX+tvuJv37KhuBwCnDghhR5EVzJImbnl3NKgcDQAiBO15eh9fX1sClyPj9xUdiktFCIBvM8qAM7Pa/z3c149dvbgIA/Ow/pmJUiS/rzxE0xnNLXRhr97Zk/fFJ15BUUR1PdJoNCKTLeJb6nNbiwt4KOBR4ZQWeg5QGBdoFApuiiKgqUqxQQkQ2wUAgUTdqjYzAin7KCASAU6bogaM31jEQ2B9aIkn84NnPAQAXHj3a6svYX04zStW9v6kebVz5lxWPvL8VgH6iqqwfg7jdMfsEbmKfwKyIJlR854nlaAwnMG1EEHeddfgB/Rz6k9kncOnm+gF7zqEoZJTE8bscKHYofRrjQCeT9hNn6Jksmz6vhVOSUJdMYXc8CckoD0pENFj8/LUNWLGzGQUevS+gO4MTlZmYO64EI4q8aI2n8Pra6gF5zqFI1QTu+td6vLhyDwBg8rC+B488TgW/O38WnIqE19ZW4w8fbOvzY9LBPfrvbXhs6XYAwL3nzMDc8aVZfXwzEMiMwP4VSaRww9OrkNIEFk8fhjNnjeiX5zliTDGmjyxEWzyF8x75CCt2sgRzf9gTiyOuiU5bEDS1xRE1FgeW+FxGf8Def796ZT2A6DLmMp2VBgWAEUYgsLYpirgmrLYGRES5xkAgUTf6OyMQABZO1gNTn+9qtkqRUvb89O9rUB2KYVyZHz8+vf9XVh9aWYBxZX4kUhre3lDb78+X7zbXtuHN9TWQJODy4wcmW6wr5mpflvHtOyEEfvT8aqzdG0Kp34WHLzoSngxKtPSF2Sdw2dYGaFyp2W/MsjlBrwPBLlbp9pRXkSBBgtYuwHfExFIUeJ1oDiUwStb/D60IRSAEGAgkokFjyboa/P7fZvWKGf2SmdIVWZZw9hH6SfDnV+wZsOcdStriKXznic/wsLG47bqTJuJUYzFoX80aXYyfLp4CAPi/Vzfgs+2NWXlcOtA/Pt+L//cvvZz9T06fjK9OH5715yjw6P3FWpkR2K/ufGU9ttaHURX04P+dMa3fFiM6FRl/uXwuZo8pRiiWwkWPfoxlrEaSVWFVxbZoAiWdzCV314Vx6xOrkFL08a0s9iDoyKxnuSRJKHc64DSqm3SXEVjdEEVSCEQ5zyQim2AgkKgbZmCuoh8DgRVBD2aMKgIAvLWegaNs+vuqPfjn53uhyBJ+dc5Mq0Z/f5IkCV+ZxvKg2fKHD/QTJgsnV2JCeSCn+3KIURp0Yy0zAvvq9//ein98vhcOWcIDFxyBEUXeAd+H6SOL4HcpaI4ksW5faMCffyhoiSYRMSa/ZT43vH3su+KTZbgkCYl2E2qnQ8bx0yoBAFqNXhZ0ZSgClwxsDsexKRxjiVAisrVdjRF83+gL+O3jxlnHkQPpLKM86Aeb6lDdwoWJ2bS7KYJvPLgUb66vhcsh475zZ+L7px4KOYu9yC6eNwZfnT4MKU3g2qdWor4tnrXHJt1HWxvwg2f0KjOXHjO23xYomiVjn1u+G4kUj1/6w5vravDUxzsBAPd8awaKfH0v03swQY8TT3x7Do6dWIpwQsWlf/oE737J8z7Zsi+eRGtKPaDc57odzbjtmdWonhQAvA7IAIrcTlT24ZxQoVMvDwp03SPQyghsjiKWVJkRSES2wUAgUTfMjMD+LA0KAKdO0U9iLlnHcjzZsqc5ip++tAYA8F8nTcJMI9g6EE4zTuC8s6GOvVb6oK41bq1Mv/KE8Tnem3Rp0B0NEcRTHNdMvbexDv/36gYAwC1fm5L1kko95VRk67k/ZHnQrGsKJ3DBox9BjSQhx1RMqPBntPq2PZ+iwK1IiO+X6bdghv6Zu2+9ngWxIRxF0KEgJQSWNbfh3cZW7IjGoTJDkIhsJpHS+wKGYinMHFWEH33lsJzsx9gyP44cUww6RuwTAAEAAElEQVRNwCpdSX23fEcjzrj/Q2yobkVZwI2nrzwa/zEz+yUIJUnC/509HePL/agOxXD931ZBZRZK1mysacWVf/4MCVXDV6ZW4X++OqXfMsj+89hxcCoS3lhXg6ufXM65ZJbVtcbxo+dXAwCuOH4cjp1YNiDP63M58IdLjsLJh1UgntJwxZ8/w2treO4nG3ZGE/Apcof35AdravC/S75E8+xSaGUeuCQJ144uR6FTQUEfym4HFAWlRubh2w2teLMhdEBv1qKACz63AiGAxpZ4h/7mRES5xEAg0UG0RJPWasr+zAgEgFOMQOCHWxoQZl+5PtM0gR888zlajZMq15w4YUCf//ARhRhR5EU0qeK9jXUD+tz55Ill25FIaZg5qghHjinO9e6gosCNoMcBVRPYWhfO9e4MStvrw7juqRXQBHDOkaNw0dFjcro/x0wwAoEs0ZNVda1xnPvIR1izJ4Rh61tx2+gqHFbkh6+PgUCnLCGgKIjvV4pneKkPh4wMQoqoKNCAlADWtkVR5nJgjNeFUErFB01t+KCpFfviiQMm7EREufK//1qPz3e3oNDrxO/OnwWXI3dT9LNn61mBz6/Yzc/JLHh++W6c98jHqG9LYMqwIP5x7bGYNbr/jmcDbgceunA2vE4FH2yux31vbeq35xpKakIxXPrHTxCKpTB7TDF+fe5MKFnM5tzfcZPK8PuLj4TbIePN9bW44s+fIZpgMDAbzNYEDeEEDqsqwA8WHTqgz+9xKnjootlYPH0YkqrANU+twEtceNFnSSHgMIKAQgi88OF2/G7dHsRmlwIeBSPcTtx96EjMKQzALckHZA72RoFDxvElARwe8CAhBB7aVYff7KxFtN3cRJIkqzxoXWMUm8Ix7Ipx/kFEucdAIFEXttWHceYDH0IIoCroQam/fwOBkyoCGF3iQyKl4d+bGDjqqz9+uA3LtjbA61Twq3NmwtHHk8+91bE8KFf6ZSKaUPHnj3YA0LMB+2vVbW9IkmRlBW6sYXnQ3grHU7jyic8QiqUwa3QRfnbG1JyPq7kK+NNtjSy/lCXVLTGc88gyfFnTiooCN/525dEYUe6HR5Lglfv+WVzkUBDvJMvhxBnDAACiJgpA7xMIAIokocrtxDC3A/viSbzb2IqPWtpQn+CiGyLKrX99sQ+PLd0OALj3WzMwsnjg+gJ2ZvH0YXA7ZGyubcPq3S053ZfBTNME7n5tA77/7OdIqBoWTa3Ec9+dh+EDUAb9kMoC3HXW4QCA3769ieUHOyGEwCur9+Hap1bg5hdW494lG/HERzvw+tpqrNzZhN1N6cofrbEkLv3Tp9jbEsP4Mj8evXhgelovOLQCf7r0KPhcCv69qR6X/ukTtHGxcJ9srm3FDU+vwtsb9BK9vz53Jtx9CAhlyqnI+M25s/CN2SOhagI3PLMKf/1k54DvRz5KqRruf30j/hYNI3VIISBJOKE4gLsPGYlRHheimgavIvUpI9Aly6h0OXH5yHJcMKwEMoB/N7XhRxt3Y3s0XZLZDARGQ3G0qho+aGrFZy0RhFlViIhyqP+bZRENQks31+O7T65ASzSJYYUe/P7iI/t11R+gBxhOmVKJP3ywDW+sq8FXpg3r1+fLZxuqQ/j5a18CAP7nq1Mwrsyfk/04bVoV/vDBNry5vgaJlJbTFd6DTVLV8Ju3N6E5ksSoEi8WTR34XjldmVQZwGc7mrC5ti3XuzJoCCGwqbYNP39tAzbWtKG8wI2HLpydk8n3/g6tLECp34WGcAKrdjVjzriSPj9mUtWgSFJWe/8MFrsaI7jg0Y+xszGCEUVePHn5XIwp9WFjXQsKnQrkLAR+CxwKEkIgrKrwK+n/Q3MOLcMTb25G654wMMyLla0RCCGsYLNLljHS40JU1bAlHMeeWBLjvW5M9Hv6tDJ4sBNCIKJpCKc0tKkaoqqKSX4PXFkI2hLRgYQQWLa1AX/8YBveNHqDf2f+eJw8uTLHe6b3sVo0tQr/+Hwvnl+x2+phTj0Xjqdw/dOrsGRdDQDgmhMn4PunZLcfYHfOmDUCn25vxJMf78QNT6/Cy/91fE56MdvR5to23PqPNfhwc/eVIIp8TjhkGfVtcZQFXHj8P+eg2N+/veTaO2ZiGf78n3Nw6Z8+xcfbGnHRHz7GY5fNQaHXOWD7MNgJIfDZjiY8/N4W6/MWAH66eDIOqwrmbL8UWcLPz54Or1PBEx/twM0vfIFIQsW3j+ufvpNDQSyewr3vbMaXFS7A44EigO+MLsdJpelxjqgaxnjcUPo4H6lwO7EzlsCZlcWY7Pfg3h012BtP4scb9+CykWVYWFJg9QmsbohimNuJiKphfTiK2kQS0wq8GOVxZWVeRETUGwwEEu3nLx/twG3/WIuUJjBzVBEeuWg2KoL92x/QZAYC395Qi5SqDXgWWz6Ip1Rc/7dVSKgaTj6sAufNGZWzfTlidDEqCtyobY3jwy31OPHQipzty2CRUjW8uHIPfvP2Juxq1LN6rjx+fL8H4ntjUgUzAnuiJZLEB5vr8f7GOry/qQ77WmIAAJci46ELZ6NygD5XuyPLEuZNKMXLq/fhmc92IZJIwanIcCoyHIoEpyzD6ZDgkGU4FQmyJKEpkkBNKI6aUAy1oZj+c6t+XRuKoSGcgN+l4LBhQUwZFsSU4UFMHhbEoZUF8LryN+C0rT6MC37/Efa2xDC6xIenrpiLkcU+IxinZ/JlwwiPC1P8XmyNxtCUVFHpcsIpS3A7FRwzpQJLPt8HWRNoTKrYEUtgrLdjRr9XkTHW50ZrSsWatih2xBIoabdv7efk7X/2ygoCDhkeWYZbluA2rj2y3OcTCoB+skoVQEoI6wLoAUyPLGXlZIEZ9GtLaWhTVbQkVdQnUwirGqKaClUD3LKE4R4XA4FEWZZIaXh59V48+u9tWLcvBED/jDlj5gj84NSBLU93MGfPHol/fL4X//h8L36yeLItFu0MFqt2NePmF77A+n0huBwy7j77cJw5a2RO9uV/vjoFq3e34Is9LbjmyRV45jvzhvSixEgihd+8tRl/+GArkqqAyyHj0mPGwu9yoLY1hrrWOGpb46gzLglVQ3MkCQDwuRT88dKjMKpk4DN2jxxbgicvn4uL//gJVu5sxgWPfoQn/nPugAYkByNVE1iyrhoPv78VK3c2A9A/b0+ZXInvzB+P2WP6vvCvr2RZws/+Yyp8LgUPv78Vd7y8DpF4CteeNDHnFVMGm4ZQDHd8uAVNI72ALKFUlvHjScMxZr85QFITKHX1/TR4QFEAoR9XHxbw4peHjsLvdtZiRSiCh3fVYW1bFEeX6osv9jToFUp8ioyxXhfqEyl80NSG8T59PlPo5Gl5Iho4/MQhMqRUDXe8vA6PL9NLEZ4xczj+7+zpA1L6w3TkmGIU+ZxojiSxfEcT5o4vHbDnzhf3vLERG6pbUep34f/Onp7Tg2hZlrBoahWe+GgHXvuimoHAg0ipGv7x+V785q1N2G4cLJcFXPjugom4MMc95PZnlgbdVNP/GYGtsSR2N0WxqzGC3U1RqJpARdCN8gI3Kgo8qAi6UeB2dPv/XAiBUCyFxnACDW1xNIQTiCRSmFhegEOrCrJyYkjVBL7Y04L3vtQDfyt3NqF99Ua3Q8bc8aW4/LhxmG2Dfo/tHTuxDC+v3ofnlu/Gc8t3Z+UxwwkVy3c0YfmOJus2WQLGlwcwuV2AcOaoorxY2b2pphUXPPoxalvjmFDux5OXH42qwnSw1yXJ8CnZ+T71KTKOLPRhpNeJDW0x7I4lEHQoKHEqWDBjGN5cuQ9SQxwo9+CWTXtR7nKgxOlAiVPRr10OlDgU6zYIgbpEEhoA1QjGqUYgTjVuAyQEHTKEkCBBQEgSnJIepHNKgF/Rg4QBpWPWo0D6TdC+LYgAEFc1xDWBhNCQ0ATimoAK/fk1Yz8AvS+iUwJ8ioKAIqPAocAty3DJkhWIBPT+KKoVRNT3O6np/05qAnFNQ2MyhbAmEFVVCAAKJHgUvWRr0OHEnlgCq0JRnFJWmJWxIiKgOZLAkx/vxONLt6O2VS8b5nHK+ObsUbjs2LEYXx7I8R52dNzEMlQG3agJxfHOhlpWKelGPKXildX78PiyHfh8VzMA/Rj24YuOzOnxjsep4IELjsDi3/wbq3Y143//tR63fX1qzvYnV4QQeG1NNe54eR32GovSTjqsArd9bSpGl3Ye2BNCoCWaRG1rHLWhOEaX+LrcdiDMGFWEv15xNC76w8dYsyeEcx/5CH+5fC7KC/q3dclgFEuqeH7Fbjz6723YVq/3c3c5ZJx9xEhcfvw4TLDZ560kSfjv0w6D3+3AvUs24p4lG7FyVzP+Y+ZwLJxcCb+bp2wPRtUEXt9Yg5vX7kB8pP4eneVx48ZJw+E1FtVrQqBN1dCSUuGSpaxUAQk6FHgVGTFNwKvoj/nf46rwj9pmPLWvER80tWGjQ4FW4EB1YwSaJiAbi/oq3E7EVA2bI3HUJVKYGvBirLdnWYqaEJAAWwSKzblFzLhOaAIaBGRIkCTo+wlAliTjGpAgQZGAUqeD2ZBEOcJvFSLomSvX/nUF/r2pHgDww0WH4uoFEwb8C9ahyDjp0Aq8sHIPlqyrYSCwl5ZtacDv/70VAPB/Z0+3xeToK9P0QOAb66rx/9RpzPLcj6oJvLx6L+57cxO2GpO1Er8L3zlhPC6aNwa+LKzYy7ZDKvUJ5PaGMGJJtU+LBZKqht1NUWxvCGN3UxS7GyPY1RTBrsYodjVFrJXIB+Nxyqgo8BjBQTdK/C60xfWgX31bAo3hOBrDCSTVzpuTuxQZk4cVYPrIIkwfWYjpI4swsSLQZRZmLKlawcmdjRHsaoxge0MEn+1oPGB/J1YEMP+QcpxwSDnmjisZ0IUVvfG1GcPx/sY67G2JIaVqSKkCSVVDUjN/1v+dUjWkNIFinwuVQTcqgh5UBt2oLPCgMqgHZiuDHlQUuNEYTmDdvpB+2RvC+n0h1LclsLm2DZtr2/DPz/cC0EsDzRxVZL1Oh48otFUGbE+s3duCi/7wCRrDCRxWVYAnvn3gySmfIiGQxUwESZIwzO1CmdOJ7dE41oej2BZNoLLUi3FVAWzeHYZW5kFE07AjlsCOWKLLx5IB9KQ7pFOSMNztxEiPCyM9TgxzO1HpcqDI6UBjMoWahEBKAyC1j/jpYykgIIQe7ItqGjQADkmCQ9KvFUnvZaj/LMEpSfDIgEeRoQk9yNecTKEuoQf1JEmCgIAiSXBJEgSMICYENCF1jDpCn3wrkp7F6JWAlCRhTzyJnbEEdkUT2BlLYG88gZRxt/8cWY5irlCmXnhi2XY8u3w3xpb6MbbMj/Fl+vW4Mn9WFzs0hRPYXNeGTTX6Z2lzJIGyAjfKA27re7DcuBR6nTk9Wba1rg1//HAbnlu+G7Gk/ilTUeDGJceMxQVzR6PIZ8+MHkWWcMasEXj4va14bvkeBgK7sK8liic/2om/frITDWH9O8alyPjqjGH4/qmH2qIU56gSH+791kxc/ufP8NjS7ThybDG+On14rndrwGyta8Ot/1hrzfFHFntx29emYuGUg5fhlSQJRT4XinwuawFgrk0ZHsTT3zka5//+Y3xZ04pzHl6GJ6+Yi2GFuf9/lmv1bXF8sbsFn+1oxNOf7kJ9m/5+LPQ6cdHRY3DJMWNtcV6gK5Ik4b9OngSfS8Gdr6zH2xtq8faGWnicMk46rAJfnT4cJx5akddVRXojpWr4eFsj/vXFPry6oQZ7ZxQBJW5AE7igohhnjNCzPVtTKlpSKlJCwK8oGOd1Y7jbiYosnF/wKzK8soyIqlkBR1mScEZlMQ7ze/CrHTWoTarA3ApoG5qxvSmCcSU+65jEo8gY63GhMaliWXMb9sWSGO5x6YsQhUBKE0gIgYQmkBQaIikNjakUoqqmL3B0OVGgyPAqirUosH21EjPIprVbINjZz2a3Qqmra+OHpLFgMarqFUVaUyrixkLDqKYhlFSREBpkyJAlPRgoSxJkALKsLzyUjccLOhw4vrggK5mZRNR7khCi8zODlHWhUAiFhYVoaWlBMJi7euTU0da6Nlz++GfYWh+G16ngV+fMxFem5a4f2atf7MN3n1yBMaU+vPuDBbZY7WNXsaSK9ftCWL27Bat3t+DtDTVoiiRx7lGj8H9nT8/17gHQD1SP+n9voimSxFOXz8UxE8tyvUu2oGkCr3yxD/e9tcnqtVfkc+LKE8bjknljbb36UQiBmT9bgpZoEmcfMRKjS3wo8TtR7HehxOdCSUC/LvK54HLIEEKgrjWOrfVhbK0LY1t9G7YZP+9sjCClHfxruNjnxKgSH0YWe+GQZdS2xvTSRaE4WuOpXu17wO1Aid+F0oALboeM9fta0RI9MNjocymYNrwQh48sRIHHoQcmjcBfdSjW5eMXeBw4bmIZ5h9SjuMPKbfFSTA7qW2NYd3edHBw7d6QtVrZVORz4vhJ5Thhkv46DlRp6kx9vqsZF/3hY4RiKRw+ohB/7qJ/TkoTcPRjgLM1pWJjOIYtkRiWflGDl97ehqoKH64953A0pVQ0JlPGpePPLSm1y8eUoQfPFAlQjWBcZxwSMNytBwdLnQ5EVA1h66JaP0dUrUcBx/Yk6Ccbgg6l3cX4t5GF6JJkpIS+ClcTsMqLJo1LysgKbEmp2BlLYHcsgVgXnzseWUKVy4kHpozBEYW56a/L4+XM5Pp1u/mF1fjrJ7s6/V2J34VxZX6MLfVjXJkPRT79O8jjVOB2yHAb19a/HTIcsoxdTRFsqmm1An9b6tqsE7w94VQkK0BYVejBuLIAxpf5Ma5cD1CW+l29Os4Ox1N62cC2OBraEmiKJNAY1i9N4QQa9/t3OJH+fJkyLIjLjx+Hr04fPijKM26qacUpv3ofDlnC/551OI6bWIbh/E6HEAKfbGvEn5ftwGtrq6Ean6VVQQ8uPHo0zp0zGmUB+wUc7n5tAx58dwv8LgV//vYczBhZlNeLE6MJFb97ZxN+//42JFQNLkXGVfPH47sLJg76YMr2+jAuePRj7GmOYlSJF09dfnROSpbmSks0iS92t2D1nmas3qWXvt3THO2wzYgiL7593Dicc9QoW88pO7OxphX/WLUXL6/ea1XJAfS52cLJlfjq9GE44ZBy2y6u7ClN09sG9PQ7OKlqWLqlAa9+sQ+vr61GU7vFp/KUImCYD98dU4FpxX6EUiqSmoDfoaDS5cAIjwtlLkeHvuLZ8GlzGzZGYhjudsG53xynNaXit0apUJNTklDkUFDoVFDkUFDsdKDIocCvyEgKgYgRZGszenaHVRVtqobWlIrofsftAUVGsVNBkcOBYqdeFaXM6USF24kqlwNeWUabqiKUUhHWNIRTAhHj8SKaPieJqRogmQsT2y9OlOCA/m9FkiBJUoc5TaTdHKc1pT9eb0gAnp05AccV52aRRa6Pl4lyjYHAAcQPHPv5YFM9rn5yOUKxFIYXevD7S47E1OG5LYfVFk/hiJ8tQULV9Pr1o4sxbUQhhhV6hnRQMKlq+LK61eh10YzPd7VgY03rAUGUiRUB/P2aY2110H/Tc5/jmc924/hJZThvzmiMKfVhbKnfVvvY34QQ2N0UxZo9LVi7N4Q31lVjo1FaM+hx6AHAY8aiwDM4SiRe9IePrdXFB1PgdkATosPJwP15nDLGlvoxstiHUSVejCr2WYG/kcXeg74m0YRqBQZrQ3HUtsbQFE4g4HGg1O9GacBlXZf4XQdMGoUQ2NkYwee7W/DF7mZ8vrsFa/a0IHKQ/QUAv0vB6FI/RhV7rXJJU4bpZS7z+cRSf9jTHMX7G+vw3pd1+HBz/QHB3cOqCnDcxDJMqAjor3WJD8MKPTl7nVOqhg3VrVi5qxkrdzbhjbU1+vfW6CL86bI5OS1zKoRATSKFlQ2t+K8HPkYypeGCk8bjkBFBVBR7EfAcWEY3qQm0qWq7oJ9kZei1L1mjCoH6RAq7YgnsMoJpu2JJ7IknEO8mmL8/pzHZFgA0oV8LI4jX20BhphwSMNLtwiivC6M9xsXrgpLU8GVtGy4/fGTOMgJ5vJyZXL9uOxsiWF+tL27YXh/GVuPaLIWZTSOKvJhYEcDEigBKAy40tiVQ15bu7VXXFu9RRn2Bx4HxZX6MLw9gXJkfY0p9iCXVDo/Tvm9Yd9+N+5Mk4OTDKvDt48bj6PElg+44/oz7P8Qqo9QlAIwv8+OYiaU4bmIZjh5fatuMxp5IpDTUhGKoDsWwryWGtlgKmhD6RTM+j81/C72CRSKl4fW11dhQne4RPXdcCS45ZixOnVJp6+OflKrhgkc/xsfbGgHopRIPqQxgcpXew/iwYQWYMizYozFVNYFIIoVoUoVLSQfwe/r/O55SEYqm0BpLIhRLIRRNIhRLQoKE0oALZQE3ygKuHmX0JlIa9rVEsacpqlfWaI5id1MEH21psMqAzj+kHLd/fSrGluVmcUt/2N0Uwfm//xg7GyMo8btw5JhiTKwIYEJ5ABMqAphQ7u/xnErTBFpjKTRHE/A4FVQUuHP6WSWEQCiaQk1rDNUtMdSE9MvGmjas3t3cIThmkiT982nGyCLMP7Qcpx8+DE4bvx97QgiBtXtD+OfqvXhl9T7sbkoHOwvcDswYVYRCnxNBjxOFXv0S9Dqsnwu9+u+KjG3kHFUbaY0lsaUujC21+mKezcb1joaI3j/c50Kxz2ldFxuLac2f3U4Z/95UjyXrajosXi3xu7BoaiVOmzYMR44rwZLGEJpSKoLtgn/lTgf8/djjdlskjs9bI4hpmlGtA0ZFDz0rzyVL+J/3NmGLXwKysABBht4uoLfzjoEgQV9MqFco0edNB5vTvDhrAuYVMRBIlAsMBA6gofSB0/4ArjVmfmHrBx/mcWX72tYS9FVOFUEPgp2cqMtULKmiNhRHtTHRqzEOJquNA8oVO5uhagKzRhfh4Ytmo6LAHpkXV/z5MyxZV9PhthK/C1OHBzFtRCGmDS/EtBFBjG5XXqA3hBCIpzS0xlIIx1NoMy4pVcChSHAqMpz7XTvMn2W5Z/W8JcAhS1Bk/f4HK3VnjpMZ0KgJdQxsmNlUidSBhxOlfpdVznD6yELMm1Bqu3KS735Zi0v/9OkBt1cUuPWyWaVm+SwfxpT6EXA7oBivnSzp14okQZYBhyxDkvTXLJxQEY6njIuKcML42bg9llThdzmMiUF6UlDo06/9LqVHveVSmkBK1Q9uezLRVzWBbfVtWLMnhLV7W6zrUKxjgKPA48Dlx43HZceNRXCQBABN+1qi+NcX1UbZzaSeCWBkAzSF9SyB9sfosqSXZxpX5sf4sgDGletl08aV+VEV9ORsctYZVRPYWtdmBQdjSQ2jS/XgpBmIKvblttxavkqqGlbtatYDgxvr8MWelv0rPALQP1tHGEHY9uMystiLqqAHpQF31sqL1hrflSt3NWHlzmZ8sbsF0WTHk+Fzx5XgD5cehYBNFjckNYFrn1mJ11ft63C7x6WguNCN0kIPigvdKCn0oCToRnHQDa/XAbdTgSxLemVPo/SmfoSiXwsISAJwKzI8RhkepwQ0JlU9OBhPoDmpwqfovQL9iqxfHHpvP/PfLvngJ6eEMXnWBBA2VvOGUhpC1s/tbkupiGlah9W8TkmCQ5aMgKNk/dsnyxjtdWGU2wlvCthdH8Gu+jD2NESwryGC6sYo2ozgybs3n4ixhbnJMBhKx8vZZNfXrS2ewvb6MLY3hLGtLoztDRG0xZOIpzTEkxpiKRXxpIZ4StVvS2mIJVUkVQ3DC9MBv4kVAUyqKMD48p4tpIqnVDS0JaxA3p6miJ6NXx/Gtvow9jRHO/187Y7PpaDcKMNd6neh2KcvtCnxuw6oDFBW4LbN52ImdjVG8NdPduLDLQ34Yndzh+MaSQKmDS/EMRNLMW14IRIpDZFECpGEfnwaTaSMa/2YNJpUIQSsE9Udjku96ZPZQa8T8ZSK1pgeKGqNpRBq97N5HY6rcDkkeJ0OeF0yvE4FXpdDv3bK8Lkc8LgUpFRNnwe26AE/87q+LfMAtccp48xZI3DxvLGYPMw+77Xu1LbG8KPnVuPjbY1dBrWHFXpwSGUBnIqMiDWG+usdTepjGe9kPgbor4vHqcDjUOB1pbN8AXQI+nV1//05FclazFYW0K+LfS40tMWxuymKPc1RVIdiXb6PRxR5ccvXpuDUKZV5ecxa3RLDBY9+hC114U5/Xxl0W8HBUr8bzdEEWiJJNEeTaIroPzdFEmiJJju8t0v8LquP9ZRhQUwdHsS4Mn+vAt2xpIqWaBLhuP6ZEEuqiCTU/X7W56pNkaQ+9w/FUdOqn6MxSyl3ZXSJz5j/6+cApg4PDprFpJkQQmDVrma8vHofXlm976DVWTojGwG3Ip/TqlpT7NOr2RT79KC7ec5HP3cjwSHLUIxzPw5FP46UJAlJVUMiZVzU/a6N7/C9zVFsqdMDfjWh7C0GKgu4sGhqFU4/fBjmjivp8H9yayQOCUC5y4FAPwb/2hNCIKrpmXwRVUVE09CcUNGUSiGmCcQ0Das3NeCZ1zYjBQHhUgC3bF37i9zwFbrh9DshO/VSo15IcGuAC4BLFXCogCMlIKc0SCkNsYSGlngSzSkVLZqGNghEZEB1KxBeBcKjAG7j79cEkNLg0AAXJHhlCQGHgqBTQbHHiVKvEw4jGzHVropIcr+fNQAFil6VJOCQ4Zf1+YxHluE15kQuSYIsy5CMD2S9S4FeelQICSoEIrEUGpujCLUlcf2RYzE6R9nzdj1eJhooDAQOIDt94CRVzToAC8c7XkcSKgT0AwZZMmo7mz/LevBOliQIIdDQlrACN3XGdU2rfiDX04P8/XmcMqqCHqP3kgdVZs+loAflATcSqqZPJqLtJ4jpyWEomkJLNIma1liPVgOfOWsE7jrrcFuVV2gMJ/CPVXuwZm8Ia/a0YFNtm1V6pj1zJbMsS1ZgVb/WG/Gaxb1VTSAcT6E1pgf8wvFUt+UIs00yAoMOWdavFQkORUYsqU/2eyLocbTrY1aIw0cWYfggyJQUQuCJj3Zg1c5mbGvQV8g39eD/Zn9zyBKCXie8TgVJVYOqifS1JqAal/25FBkuo3RXx2sFAgJbasMHBAoAfUJ/aFUBpg4rxLSRhfj69OEo9OXnpE3TBFqiSTRGEhBCn7AOhlJgZC8NbXF8sLkeK3Y0YafZk7Ep2umiiPZkCSgvMPsVGn0MjX6GFUEPZEmyTuxFkvpJvoh5wtb4uTWWwrq9oQPKLQH6d8/MUUWYNboYs0YX4fiJZbbLhKhuieEXb3yJzXVt2NMURX0PspIkAH6PAwHr4kSBx4ECjxN+t4KkKhBNqYik9OBFQhVIahpUVc8agQZACAgrk0T//Nd/lb5diPR3oqzo34mKIkExTrpY/1ZkPQYJPW1QiPTjm9dC6NmE5sIRWZb0YwDj35Jx3CZJEqIJFdWNEdQ2RhGLd53ZVBH04M//eRQOq8rNsaqdjpcHE75uvRNLqtjZGMHWujC21rdhm1Gu2wz06f0GPdbPZonRoVTNob2WaBIfb23Ah5vr8eGWBqus+2DmUmRUFXpQVehBoddpLbqTjOzw9Pw3/fOkygJ844iRg/r4VdMEdjVFsH5fCOv2tWLDvhDWV4ewq/HA7/v+Ikl6ufqgRw/+Bj16BY0GI7u3p3NDQF+kOKLYi5HF+oKoEUVejCn14aTDKmy3ODTbYkkVn2xrtIIuW2rD2FzXhroMMrG9TgUJYx64P7dDxmFVBZgyPIhDKgugagLNRiDRvG6KJNEc0RdDdhfI64kinxOVBXr/7aqgB2NKfdZ5gMGcjdxXmiawanczdjSE0RJJosU49xWKJdES1S+haPrn3may94fyAjcmlgcwocKvZ62WBzC+3A9JktAUTrT7v6T/P2r//6o1lsLU4UGcfvgwHDW2ZFD0URdCWOU3I6qGxlgSa/e0YP2eEDbtDWHLvlY0ZDFAanI6ZBT4nPD6HEikNDQ2xaCqBz/n53TIcDlluF2KfnEq1s8up2z92+NW4HY54PM4EHA7UOB1IOByoNTnRJnfjSKXA04JaA4nsbcxgr1NUexpjGBPUxR7G/Wf23+uv3njCZhYwYxAolxgIHAA5foD5/Z/rsVLK/cgnFC7PYmYLeYqT0mCtVpPX2Hf7t/GdVs81Wmvqr5yO/RJXuV+gcWqQg/GlvoxdXjQ9oGkWFLFl9WtWGNkV63b24L11a1ZGceAW/8yD3gccMj6Kq+UJpBMaUioAilNQzKlIakKJNT++3/jdsioCOonXSoK3Pol6DFOxLgxtlQv2WT3seqplkjSCgpuM1bKb68PY0djBPGkPglTReeBOJPLISPgdsDnUqxrv9sBv8sBv9sBt1NG2Hhf7T8xSHZzUNhXPpeCycOCmDY8iKnDCzF1RBCTKgoYDCPqI00TqGmNYWeDERg0AoQ7GyPY3RRFfVsc2VznIUnAoZUFmDW6CLNGFeOIMUUYXxawVRZrT0QTKnY1RbCzIYIdxuu2o0E/8b+nOZqVk1aDiSwBI4p9mFDhx6GVBZhUUYBJFXpJsVxnMOX6eHmw4utGA6kmFNODgpsbsLMxDI9Tgd+lH4v63Ap85s+u9M8AjOPQzk9c6yUiU3A7ZGsRhn7d/mc9aORzOZDSNGsRi5llFE3q/zavJQmoKvRgWKEHVYVeDDPmgMMKPSjpZY/IfNcaS+LL6lardL9/v3H0u/WMS78x53A7ZKQ0gVhSRSypZ/LGUyqiCX2xjHm7EMII9umlC4NeJwIux0GPI8yM3nqjH2ddWxz1RsnfEr/LKJ/vw4giL8oCHMf9tUST2FrXhi11YWyubUNLNIkinxNFXr1UZJHPZfysZ4YFvU54nApiSRUba1qtftZr94awfl8oo2CSIkvW/510xq6RretM3x70OqzzNPq5Gj34Z6dF2oNZPKWiJZI0qtYkOwTb9Co2+mdwStOQMs79pFRzUbB5m0BK1aAJfWGvy6HA5ZDhUiTjWl8U7HIoem9eI/A3sSKA8eWBnLYNsKuaUAyrdjdj5c5mrN7djK11YTgUCW6HAo9T7njt0LPe3U79PVMScKLQ50LQ50SBzwm/zwWf1wFZ0Xv5takaoqoGRQLa2pJoDEVR3xRHfSiGuqYYqpujqG6K9mrBRXf0qlHodj5VXuDG2FIffvYf03KWUc/jZRrqGAgcQLn+wPnxi1/gqY93drjNYRyg+dsFEbxOBbIkWavW2/dHECLdM0EIvXREhZmxV9Dxuryg9wdwZr+rGqOcZ23ILOWpZxvWt8bhdioo8DgQ9OirCK1JoTc9SQx6nNbqsZ70FxiMkqqGzbVt2N0U1TMOYAZVjSwBtMsUkCQ9u8GtT6YDbicCHgd8Rhm0nhJGYKonHxrC6KeRPpjUg1sptV3WmSrgckgoL8huSdh8o7ULCmrGtcepZNz7QAiBqFGypSWaRDypGSU/0qU/HEaWSvufNSGskh8dr1Xr3ylNYJxR8nIwrNgjyjeqJtDQFre+R2us71Kz5JK+AjV9glY/0ed1KfC79BM15u0TywOYPqoo54GhgWBmp4di6ZPR1snpWBKRuGqVS1Jk2SibJFlls83PTwFYpZ2V/aoqSO2u238fJlR9sU1K1Yx/67cnU5p+n3ZZ//oPgDAex+ozaGYIakL/WTOO2TT99pQm4HbImFARwKQKvR+aXU+y5fp4ebDi60ZERNmmaQI7GiNGcLAFm2vb4HYoHfu6+V379XhzIuDm3J7IzlqiSbREknrFsES6cpjeOkjt0EIoXX3NrMSm/zu83yIBfaGhF2NK9EX8Y0p9GF3ix9gyvY2FHbK0ebxMQ92QDgTef//9+MUvfoHq6mrMmDEDv/3tbzFnzpwut3/22WfxP//zP9i+fTsmTZqEu+++G6effnqPny/XHzh7mqOIxFPwuR3wGyf+mJ1DRERERHaR6+PlwYqvGxERERENFFUTaDMWUmpCYFih1/bnmHm8TEOdvd+h/ejpp5/GjTfeiFtvvRUrVqzAjBkzsGjRItTW1na6/dKlS3Heeefh29/+NlauXIkzzjgDZ5xxBtasWTPAe565EUVeTKoswIgiL4p8Ltt/QBMRERERERERERGRfSiyhEKfE6NKfBhT6uc5ZqJBYMi+S++9915cccUVuOyyyzBlyhQ89NBD8Pl8+OMf/9jp9vfddx++8pWv4Ic//CEmT56MO+64A0cccQR+97vfdfkc8XgcoVCow4WIiIiIiGh/999/P8aOHQuPx4O5c+fik08+yfUuERERERERUR4YkoHARCKB5cuXY+HChdZtsixj4cKFWLZsWaf3WbZsWYftAWDRokVdbg8Ad911FwoLC63LqFGjsvMHEBERERFR3uhttRIiIiIiIiKinhqSgcD6+nqoqorKysoOt1dWVqK6urrT+1RXV/dqewC4+eab0dLSYl127drV950nIiIiIqK80ttqJUREREREREQ95cj1DuQzt9sNt9ud690gIiIiIiKbMquV3HzzzdZt3VUricfjiMfj1r/ZgoCIiIiIiIi6MiQzAsvKyqAoCmpqajrcXlNTg6qqqk7vU1VV1avtiYiIiIiIupNJtRK2ICAiIiIiIqKeGpKBQJfLhdmzZ+Ott96ybtM0DW+99RbmzZvX6X3mzZvXYXsAWLJkSZfbExERERER9Qe2ICAiIiIiIqKeGrKlQW+88UZccsklOPLIIzFnzhz8+te/RjgcxmWXXQYAuPjiizFixAjcddddAIDvfe97mD9/Pu655x4sXrwYf/vb3/DZZ5/hkUceyeWfQUREREREg1gm1UrYgoCIiIiIiIh6akhmBALAOeecg1/+8pe45ZZbMHPmTKxatQqvvfaaVZJn586d2Ldvn7X9Mcccg6eeegqPPPIIZsyYgeeeew4vvfQSpk2blqs/gYiIiIiIBrlMqpUQERERERER9ZQkhBC53omhIhQKobCwEC0tLQgGg7neHSIiIiIiWxmqx8tPP/00LrnkEjz88MNWtZJnnnkGGzZsOKB3YGeG6utGRERERNQTPF6moW7IlgbNBTPmGgqFcrwnRERERET2Yx4nD7W1iueccw7q6upwyy23oLq6GjNnzuxQraQ7nGcQEREREXVtqM4ziEzMCBxAu3fvxqhRo3K9G0REREREtrZr1y6MHDky17sxaHCeQURERETUPc4zaKhiIHAAaZqGvXv3oqCgAJIkZfWxQ6EQRo0ahV27djG9OU9wTPMLxzP/cEzzC8cz/3BMBychBFpbWzF8+HDI8pBtZ95rnGdQb3BM8wvHM/9wTPMLxzP/cEwHJ84zaKhjadABJMtyv684CAaD/BLKMxzT/MLxzD8c0/zC8cw/HNPBp7CwMNe7MOhwnkGZ4JjmF45n/uGY5heOZ/7hmA4+nGfQUMbwNxEREREREREREREREVEeYiCQiIiIiIiIiIiIiIiIKA8xEJgn3G43br31Vrjd7lzvCmUJxzS/cDzzD8c0v3A88w/HlCg7+F7KPxzT/MLxzD8c0/zC8cw/HFMiGowkIYTI9U4QERERERERERERERERUXYxI5CIiIiIiIiIiIiIiIgoDzEQSERERERERERERERERJSHGAgkIiIiIiIiIiIiIiIiykMMBBIRERERERERERERERHlIQYCiYiIiIiIiIiIiIiIiPIQA4FDTDQazfUuUD8QQuR6FyhLUqlUrneBsqitrS3Xu0BZtmPHDuzevRsAoKpqjveGsmHNmjX497//nevdIBr0OM/IT5xn5A/OM/IL5xn5h/OM/MN5BhHZCQOBQ0QymcR3v/tdnHXWWbj44ovx0UcfcVI3iCWTSfzyl7/Eiy++CACQJCnHe0R9lUgkcNNNN+HKK6/EjTfeiK1bt+Z6l6gPEokErrvuOpxxxhk466yz8PTTT/MzNw/8/e9/x7hx43DttdcCABRFyfEeUV8kEglcfvnlmD59Ot5+++1c7w7RoMV5Rn7hPCP/cJ6RXzjPyE+cZ+QXzjOIyI4YCBwCqqurMXfuXKxevRpf+9rXsHr1alx11VX4xS9+AQDQNC3He0i98eqrr2LGjBm46aab8Pzzz2Pv3r0AuFp3MHv22Wcxbtw4fPbZZxg5ciSefvppXHXVVVi6dGmud40y8MQTT2Ds2LFYs2YNLrnkErS2tuK+++7D66+/nutdoz765JNPMHfuXOzatQvPP/88AK7WHax+97vfoaSkBOvXr8fKlStx66235nqXiAYlzjPyC+cZ+YfzjPzCeUb+4jwjf3CeQUR2xUDgEPDhhx8ikUjgmWeewdVXX4333nsPZ555Jm699VasXbsWsixzcjdIhMNhvPjiizjllFPwv//7v/jyyy/x97//HQBX6w5Wq1atwp/+9Cdcd911ePvtt/Gzn/0MH3/8MTZv3ozt27fneveolzZu3Ih//OMfuOmmm/DOO+/goosuwh/+8Ads3boVDocj17tHGTJPZLe0tOCoo47CrFmzcN999yGZTEJRFH6HDjJffvklbrrpJixevBgffvghZsyYgS1btqC+vh6JRCLXu0c0qHCekT84z8g/nGfkF84z8hPnGfmF8wwisjMGAvOYeUBRV1eHpqYmjBgxAgBQWFiI73znOzjuuOPwne98BwAnd4OFz+fDpZdeiquvvhr//d//jdGjR+PVV1/F6tWrAXDV9WCUSCQwZcoUXHzxxQD0ckwjR45EcXEx1q9fn+O9o94qLy/HD3/4Q1x66aXWbQ0NDZgxYwYCgQDi8Xjudo4yZp7I3rx5My688EKceeaZaGhowIMPPghAf9/S4DF27Fj86Ec/wgcffIANGzbgvPPOw+LFi3HMMcfgjDPOwJtvvpnrXSSyPc4z8g/nGfmH84z8wnlGfuI8I79wnkFEdsZAYJ557rnn8Oabb2Lfvn2QZX14FUVBVVVVhwa1VVVV+O///m98+umnWLJkCQCWfLGj9uMJ6CdSjjnmGBx66KEAgKuuugq7d+/Giy++CCGENeZkX+aYmqWW5syZg1/+8pcYPnw4AMDpdKKlpQXhcBjHHntsLneVemD/92hxcTHmzJmDoqIiAMC1116LOXPmoLa2Fl/72tdw1llnsVm4ze0/poBelkeSJCiKgng8jqOPPhpnnnkm/vCHP+DCCy/Evffey5MvNrb/mLrdblx66aUIBAKYMmUKfD4ffv3rX+O2225DIpHAj370I3z66ac53msi++E8I79wnpF/OM/IL5xn5B/OM/IP5xlENKgIygt//vOfRUVFhZgzZ44oLy8Xxx57rHj++eeFEEKsWLFCTJkyRfzf//2fiMfj1n2qq6vF17/+dXHRRRflarepC52N54svviiEEEJVVaFpmrXt1VdfLebPny/efPNNIYTo8Duyj4ONqaZpQlVVa9vt27eLSZMmic2bN+dob6k73b1HTeeee6547bXXRFtbm/jwww/FN7/5TTFv3rwc7TUdzMHGVAghGhsbRVVVlfU9esMNNwiPxyO8Xq/47LPPcrTXdDCdjekLL7wghBAiHo+Ll156Sdxxxx2ipaXFus8nn3wiTjrpJHHNNdfkareJbIfzjPzCeUb+4Twjv3CekX84z8g/nGcQ0WDEZX2DXCqVwn333Ye77roL//u//4t///vfeOmllzBhwgQ8+uijiEajmDVrFo477ji88MILHZqCV1ZWwul0cnWnjRxsPB955BHE43HIsgxJkqzyPNdddx1isRj+/ve/IxwOQwiBjRs35vgvIVNPxlSSpA49dN59910AsFbvAkBjY2Mudp/209P3aCqVAgA89dRTWLRoEfx+v7XKPhaLWSu1Kfd6MqYAEI1GMX/+fLzwwguYPn06nnjiCSxcuBBjxoyxPo9VVc3ln0KGg43p73//e8RiMbhcLpx00km4/vrrEQwGrfseddRRUFUVsVgsh38BkT1wnpFfOM/IP5xn5BfOM/IP5xn5h/MMIhrMODMb5MLhMOrq6nDJJZfgsssug8vlwjHHHIMpU6YgFApZzWhvv/12JJNJPPLII9izZ491/2g0ipKSklztPu2nu/E0D/qBdC35ww47DGeeeSY+++wz3HnnnTjqqKNwwQUX8EDRJnozpmYPnZdeegmLFy+G1+vFqlWrcOqpp+KOO+5gWS0b6Ol4OhwOCCE69EVSVRVbtmzBkUce2eHkC+VWd2Nq9uVQVRXPPPMMLr74YpxwwgnYtGkT7r77bowdOxY33ngjAL1EHuVeT9+nBQUFCAQCHe7b0NCAUCiEiRMn5mLXiWyF84z8wnlG/uE8I79wnpF/OM/IP5xnENFg5sj1DlDvbdq0CRMnToQkSSgsLMQ3vvENHH744ZBlGZqmQZZljBo1CuFwGF6vF4Deq+PHP/4xfvOb3+DYY4/Ff/3Xf2HVqlX47LPPcPPNN+f4LxraejOeTqezw33NCcDJJ5+M//mf/8FHH32EK664Ar/97W95oJhDfRnTcDiMUCiEuXPn4uqrr8YjjzyCc889Fz//+c87TPZo4GQ6nuZ4RaNRNDY24rbbbsOKFSvw0EMPAcABE3gaOL0ZU5fLBQAYNWoU/vrXv2LcuHGYM2cOAKCoqAhnnHEGWltbrRNoHNPcyGRM24vFYmhqasJPf/pTAMDZZ5890H8CkS1wnpFfOM/IP5xn5BfOM/IP5xn5h/MMIsobA1+NlDL19NNPi7Fjx4pDDz1UzJkzRzz66KMdft++Xvz5558vLr30UiGE6NCvY/fu3eLKK68UZ5xxhjj99NPFhg0bBmbn6QCZjmcymeyw3YMPPigkSRKnnnqq2LJlS//vOHUpG2O6atUqIUmSkCRJHH300WLdunUDs/N0gEzHM5VKWbc///zz4r/+679EZWWlWLBggdi0adPA7Dx1KtMxTSQSBzyW2Sep/XjTwMvG+/Tpp58WV111lSgtLRULFizgdykNSZxn5BfOM/IP5xn5hfOM/MN5Rv7hPIOI8g0zAgeJJUuW4Ec/+hF++MMfYsKECXjjjTfw3e9+F5qm4aKLLoLH44EkSRBCIB6PY82aNfjhD38IAB1WpIwYMQIPP/wwYrEYPB5Prv6cIa8v4+lwdHzbHnPMMfjb3/6Gb33rW7n4U8iQrTENhUKYP38+fvKTn2DhwoW5+nOGvL6MZ/tV8ocddhi2bduGJ598EieffHKu/hxC38a0/QpsVVWhKIq1IpdZEbmTrffp5MmTsXHjRjz11FM49dRTc/XnEOUM5xn5hfOM/MN5Rn7hPCP/cJ6RfzjPIKK8lJv4I/WUuRLo9ttvF7Nnz+6wWujqq68WRx55pHjhhRc63GfPnj1i7NixYuPGjUIIITZu3ChuuOGGgdtp6hLHM/9ka0yvv/76gdtp6hLHM//wczf/8H1KlB38fMwvHM/8w++7/MLxzD/83M0/fJ8SUT6Tcx2IpIMzVwKtW7cOEyZMgNPptBoK33nnnfB4PPj73/+O6upq6z5vvvkmRo0ahWHDhuF73/sepkyZgh07diCZTLIJeI5xPPNPtsZ0586dSCaT0DQtJ38H6bI9nnyP5h4/d/MP36dE2cHPx/zC8cw/nGfkFx6/5B9+7uYfvk+JKJ+xNKjNLFmyBP/85z8xfvx4HHPMMVaj4JNPPhnf//73oaqq9UVUXFyMiy++GL/85S+xYcMGVFVVQQiBl19+GWvWrMHYsWNRVVWFZcuW4cgjj8zxXzY0cTzzD8c0v3A88w/HNP9wTImyg++l/MLxzD8c0/zC8cw/HNP8wzEloqGEGYE2sW/fPnzta1/DhRdeiMbGRvzxj3/Eqaeeik8++QQAMH/+fASDQdx+++0AYK0queKKKxAKhbBq1SoAQDQaRTQahd/vx/333481a9bwCygHOJ75h2OaXzie+Ydjmn84pkTZwfdSfuF45h+OaX7heOYfjmn+4ZgS0ZDU37VHqXvhcFhccskl4pxzzhFbt261bp8zZ4649NJLhRBChEIhceeddwqv1yt27twphEjXrp4/f764/PLLrft99tlnA7j3tD+OZ/7hmOYXjmf+4ZjmH44pUXbwvZRfOJ75h2OaXzie+Ydjmn84pkQ0VDEj0AZ8Ph/cbjcuvfRSjBs3DqlUCgBw+umnY/369RBCoKCgAOeffz6OOOIIfOtb38KOHTsgSRJ27tyJ2tpanHHGGdbjzZ49O0d/CQEcz3zEMc0vHM/8wzHNPxxTouzgeym/cDzzD8c0v3A88w/HNP9wTIloqJKEYOdSO0gmk3A6nQAATdMgyzIuuOAC+P1+PPLII9Z2e/bswYIFC5BKpXDkkUdi6dKlOOyww/DUU0+hsrIyV7tP++F45h+OaX7heOYfjmn+4ZgSZQffS/mF45l/OKb5heOZfzim+YdjSkRDEQOBNnbcccfhiiuuwCWXXAJN0wAAsixj8+bNWL58OT7++GPMmDEDl1xySY73lHqC45l/OKb5heOZfzim+YdjSpQdfC/lF45n/uGY5heOZ/7hmOYfjikR5TsGAm1q69atOOaYY/DKK69YaeaJRAIulyvHe0aZ4HjmH45pfuF45h+Oaf7hmBJlB99L+YXjmX84pvmF45l/OKb5h2NKREMBewTajBmX/eCDDxAIBKwvoNtvvx3f+973UFtbm8vdo17ieOYfjml+4XjmH45p/uGYEmUH30v5heOZfzim+YXjmX84pvmHY0pEQ4kj1ztAHUmSBAD45JNPcPbZZ2PJkiW48sorEYlE8MQTT6CioiLHe0i9wfHMPxzT/MLxzD8c0/zDMSXKDr6X8gvHM/9wTPMLxzP/cEzzD8eUiIYSlga1oVgshsMPPxxbtmyBy+XC7bffjh/96Ee53i3KEMcz/3BM8wvHM/9wTPMPx5QoO/heyi8cz/zDMc0vHM/8wzHNPxxTIhoqGAi0qVNOOQWTJk3CvffeC4/Hk+vdoT7ieOYfjml+4XjmH45p/uGYEmUH30v5heOZfzim+YXjmX84pvmHY0pEQwEDgTalqioURcn1blCWcDzzD8c0v3A88w/HNP9wTImyg++l/MLxzD8c0/zC8cw/HNP8wzEloqGAgUAiIiIiIiIiIiIiIiKiPCTnegeIiIiIiIiIiIiIiIiIKPsYCCQiIiIiIiIiIiIiIiLKQwwEEhEREREREREREREREeUhBgKJiIiIiIiIiIiIiIiI8hADgURERERERERERERERER5iIFAIiIiIiIiIiIiIiIiojzEQCARERERERERERERERFRHmIgkIiIiIiIiIiIiIiIiCgPMRBIRERERERERERERERElIcYCCQiykOPPfYYJEnC9u3bc70rPbJ9+3ZIkoTHHnus220vvfRSjB07tt/3qSd68zqPHTsWl156ab/vk52Yr89nn32W610hIiIiol7gfCK7JEnCtddeO6DPaRo7diy++tWvDuhzLliwAAsWLOj1/d59911IkoR333036/tEREQ0lDEQSEREQ5J5ssC8KIqC0aNH48wzz8SqVatyvXvdWrBgASRJwqRJkzr9/ZIlS6y/7bnnnuvXfXnggQd6dNKFiIiIiCgfmMfi3V1uu+22XO8qERERERy53gEiIsq+iy66COeeey7cbneud6VHxowZg2g0CqfTOeDPfd555+H000+HqqpYv349HnzwQbz66qv46KOPMHPmzIPeN9evs8fjwebNm/HJJ59gzpw5HX735JNPwuPxIBaL9ft+PPDAAygrKxtyGY9ERERE+SrXx7m9NdDziZ/85Ce4/PLLrX9/+umn+M1vfoMf//jHmDx5snX79OnTB2R/7OaNN97I6H4nnHACotEoXC5XlveIiIhoaGMgkIgoDymKAkVRcr0bPSZJEjweT06e+4gjjsCFF15o/fvYY4/F17/+dTz44IN4+OGHO71POByG3+/P+es8YcIEpFIp/PWvf+0QCIzFYnjxxRexePFiPP/88znbPyIiIiIanHJ9nNtbAz2fOOWUUzr82+Px4De/+Q1OOeWUjEpi5ptMA3myLOdsXkhERJTPWBqUiCjHuupRcdttt0GSpA63mb0lXnrpJUybNg1utxtTp07Fa6+91mG7znp6CCFw5513YuTIkfD5fDjxxBOxdu3aA3rXdfa8XT0mALz66qs4/vjj4ff7UVBQgMWLF2Pt2rW9eg266ulh/p0ejwfTpk3Diy++2KvHzcRJJ50EANi2bRuA9N/93nvv4eqrr0ZFRQVGjhzZ4Xc9eZ0709zcjOuvvx6jRo2C2+3GxIkTcffdd0PTtB7v73nnnYenn366w33++c9/IhKJ4Fvf+lan91m5ciVOO+00BINBBAIBnHzyyfjoo486bGP+bR9++CFuvPFGlJeXw+/348wzz0RdXZ213dixY7F27Vq89957Vgmk/U9+xOPxgz4GEREREfVNT+cUnE/0/3ziYLp73Xfs2IGrr74ahx56KLxeL0pLS/HNb37zgNesp8fqXXn88cfhcDjwwx/+0Lrtb3/7G2bPno2CggIEg0EcfvjhuO+++zrcb/Xq1Zg/fz68Xi9GjhyJO++8E3/6058OGNf2PQJramrgcDhw++23H7AfX375JSRJwu9+9zsAnfcIXLBgAaZNm4Z169bhxBNPhM/nw4gRI/Dzn//8gMfbsWMHvv71r8Pv96OiogI33HADXn/9dfYdJCKiIY8ZgUREg8wHH3yAF154AVdffTUKCgrwm9/8BmeffTZ27tyJ0tLSLu93yy234M4778Tpp5+O008/HStWrMCpp56KRCKR8b488cQTuOSSS7Bo0SLcfffdiEQiePDBB3Hcccdh5cqVnZ6M6Kk33ngDZ599NqZMmYK77roLDQ0NuOyyy6wgXHtNTU1QVbXbx/T5fPD5fAfdZsuWLQBwwGt59dVXo7y8HLfccgvC4XCX9+/p6xyJRDB//nzs2bMH3/nOdzB69GgsXboUN998M/bt24df//rX3f49AHD++efjtttuw7vvvmsFMZ966imcfPLJqKioOGD7tWvX4vjjj0cwGMRNN90Ep9OJhx9+GAsWLMB7772HuXPndtj+uuuuQ3FxMW699VZs374dv/71r3Httdfi6aefBgD8+te/xnXXXYdAIICf/OQnAIDKyspePQYRERERDRzOJ/p3PtGVnrzun376KZYuXYpzzz0XI0eOxPbt2/Hggw9iwYIFWLdu3QHPnclx9iOPPIKrrroKP/7xj3HnnXcC0PuLn3feeTj55JNx9913AwDWr1+PDz/8EN/73vcAAHv27MGJJ54ISZJw8803w+/349FHH+22fGxlZSXmz5+PZ555BrfeemuH3z399NNQFAXf/OY3D/oYTU1N+MpXvoKzzjoL3/rWt/Dcc8/hRz/6EQ4//HCcdtppAPSqLSeddBL27duH733ve6iqqsJTTz2Fd95556CPTURENCQIIiLKqUsuuUSMGTPmgNtvvfVWsf/HNADhcrnE5s2brds+//xzAUD89re/tW7705/+JACIbdu2CSGEqK2tFS6XSyxevFhommZt9+Mf/1gAEJdccslBn7ezx2xtbRVFRUXiiiuu6LBddXW1KCwsPOD2g9m2bZsAIP70pz9Zt82cOVMMGzZMNDc3W7e98cYbAsABr9eYMWMEgG4vt9566wHPefvtt4u6ujpRXV0t3n33XTFr1iwBQDz//PMd/u7jjjtOpFKpg74mvXmd77jjDuH3+8XGjRs7POZ///d/C0VRxM6dOw/6ms2fP19MnTpVCCHEkUceKb797W8LIYRoamoSLpdLPP744+Kdd94RAMSzzz5r3e+MM84QLpdLbNmyxbpt7969oqCgQJxwwgkH/G0LFy7s8LfccMMNQlGUDuMydepUMX/+/AP2sTePQURERESZ6+mcgvOJ7M0n2nv22WcFAPHOO+90+vuevu6RSOSA+y5btkwAEH/+85+t23pznD1mzBixePFiIYQQ9913n5AkSdxxxx0dnuN73/ueCAaDB8x32rvuuuuEJEli5cqV1m0NDQ2ipKSkw7gKoc9V2s8PHn74YQFAfPHFFx0ec8qUKeKkk06y/m3OX9q/jvPnzz/g74/H46KqqkqcffbZ1m333HOPACBeeukl67ZoNCoOO+ywg44NERHRUMDSoEREg8zChQsxYcIE69/Tp09HMBjE1q1bu7zPm2++iUQigeuuu65DmZ7rr78+4/1YsmQJmpubcd5556G+vt66KIqCuXPn9mnl5b59+7Bq1SpccsklKCwstG4/5ZRTMGXKlAO2f/LJJ7FkyZJuLxdffPEB97311ltRXl6OqqoqLFiwAFu2bMHdd9+Ns846q8N2V1xxRbd9UnrzOj/77LM4/vjjUVxc3OH1W7hwIVRVxfvvv9/dy2Q5//zz8cILLyCRSOC5556Doig488wzD9hOVVW88cYbOOOMMzB+/Hjr9mHDhuH888/HBx98gFAo1OE+V155ZYe/5fjjj4eqqtixY0eP9y8bj0FERERE2cH5RHbnEz3Vk9fd6/VaPyeTSTQ0NGDixIkoKirCihUrDnjM3hxn//znP8f3vvc93H333fjpT3/a4XdFRUUIh8NYsmRJl/v/2muvYd68eZg5c6Z1W0lJCS644IKD/+EAzjrrLDgcjg6ZimvWrMG6detwzjnndHv/QCDQoa+7y+XCnDlzOrx2r732GkaMGIGvf/3r1m0ejwdXXHFFt49PRESU71galIhokBk9evQBtxUXF6OpqanL+5gTwUmTJnW4vby8HMXFxRntx6ZNmwCke+rtLxgMZvS4QNf7CwCHHnroAZPgY489NuPnuvLKK/HNb34TsiyjqKgIU6dO7bS8zbhx47p9rN68zps2bcLq1atRXl7e6WPV1tb29E/Aueeeix/84Ad49dVX8eSTT+KrX/0qCgoKDtiurq4OkUgEhx566AG/mzx5MjRNw65duzB16lTr9v3/v5l/x8H+v+0vG49BREQ98/777+MXv/gFli9fjn379uHFF1/EGWec0avHEELgnnvuwSOPPIIdO3agrKwMV199tVUCmogGN84n/j97dx4mRXmuDfyuql6nZ2PYBmQRJS64oZjgGBeMyIgkR6LJ0cQTiVuiARMl0YTzKa5f+I45uERR4nEhnkjcElcMiuASI25E4k40oqAybMNMT+9dVe/3R9db3T1r92xd1XP/rqsvme7qppiyt/ep+3n69/tEoQr5vcfjcSxZsgT33nsvvvjiCwgh7NtaW1t7fMyuPme/+OKLWLVqFX75y1/mzQWUfvKTn+Chhx7C7Nmzsddee2HWrFn493//d5x88sn2Np999hkaGho63Hfy5Mld/ZNtI0aMwIknnoiHHnoI1113HYBMW1CPx9PhBMzOjBs3rsPcyWHDhuHtt9/O27999923w3aF7B8REVG5YyGQiKjE2n9RkbqaUdFVKi33S+Jg7I9pmgAycz3q6+s7bO/xDN5bzM6dOwua6VFZWYnKysq8677yla9g5syZPd439+zc/mCaJk466SRcfvnlnd6+3377FfxYY8aMwYwZM7B06VL87W9/w5/+9Kf+2s1++f9toP+fJSKirGg0isMOOwznnntuQYurnfnZz36GZ599Fv/93/+NQw45BM3NzWhubu7nPSWi/lTMdwp+n+ioL98nClXI7/3iiy/Gvffei0suuQQNDQ2oqamBoig488wz7d9XsY8JAAcddBBaWlrwv//7v/jxj3/c4STHUaNGYePGjXjmmWfwl7/8BX/5y19w77334uyzz8bvf//7Yv+pnTrzzDNxzjnnYOPGjZg6dSoeeughnHjiiRgxYkSP9+X3CSIior5hIZCIqMSGDRuGlpaWDtf3Z9vEiRMnAsicdZvbEnLnzp0dzhaVZ5G2tLSgtra2y/2RbW1GjRpVUCGtt/vb3qZNmzpc99WvfrWg39dVV12Fq6++us/715Vifs/77rsvIpFIv/3uvv/97+P8889HbW0tTjnllE63GTlyJCoqKjr9HX744YdQVRXjx48v+u/uarGHiIgG3+zZszF79uwub08mk/g//+f/4I9//CNaWlpw8MEH47/+678wY8YMAMAHH3yAO+64A++++66dIC8kFU9EpTXQ3yn4fSJjoL9PPPLII5g3bx6WLl1qX5dIJDo9tsUYMWIEHnnkERxzzDE48cQT8fLLL2Ps2LF52/h8PnzrW9/Ct771LZimiZ/85Cf43e9+hyuvvBKTJ0/GxIkT8fHHH3d47M6u68zcuXPx4x//2G4P+s9//hOLFi3q078r18SJE/H+++9DCJH3/aTQ/SMiIipnLAQSEZXYvvvui9bWVrz99ts49NBDAcBu5dVfZs6cCa/Xi1tvvRWzZs2yvxjdfPPNne4PkGktJucrRKPRDmeCNjY2orq6Gr/+9a9xwgknwOv15t2+c+fOLtte9mTMmDGYOnUqfv/73+NXv/qVPddjzZo1eP/99+0v9tL999+PeDze4+PmLloMhGJ+z//+7/+Oq6++Gs888wwaGxvzbmtpaUFlZWVRZ0F/5zvfwdatW7H//vvD5/N1uo2maZg1axYef/xxfPrpp9h7770BANu3b8fKlStxzDHH9KoFUygU6vPiBBERDY4FCxbg/fffxwMPPICxY8fi0Ucfxcknn4x33nkHX/nKV/Dkk09in332wVNPPYWTTz4ZQgjMnDkTN9xwA+rq6kq9+0TUhYH+TsHvExkD/X1C07QOKbdbb721oLRiT8aNG4fnnnsOxx57LE466SS89NJLGD58OABg9+7d9p8BQFVV+/+jZDIJIHO8li1bZif6AKC5uRn3339/QX9/bW0tGhsb8dBDD0EIAZ/PV3Tr6u40NjZizZo1eOKJJ3DqqacCyBRR/+d//qff/g4iIiK3YiGQiKjEzjzzTPzyl7/Et7/9bfz0pz9FLBbDHXfcgf3226/TgfC9MXLkSPziF7/AkiVL8M1vfhOnnHIK3nrrLfzlL3/p0Ipl1qxZmDBhAs477zxcdtll0DQN99xzD0aOHIktW7bY21VXV+OOO+7AD37wAxxxxBE488wz7W1WrVqFr3/967jtttt6vc9LlizBnDlzcMwxx+Dcc89Fc3Mzbr31Vhx00EGIRCJ52w7GTI9CFPN7vuyyy/DEE0/gm9/8Jn74wx9i2rRpiEajeOedd/DII4/g008/LahNjlRTU1PQ2cnXX3891qxZg2OOOQY/+clP4PF48Lvf/Q7JZBI33HBDsf9kAMC0adNwxx134Prrr8fkyZMxatSoLme9EBFR6WzZsgX33nsvtmzZYidBfvGLX2D16tW499578etf/xqffPIJPvvsMzz88MO47777YBgGLr30UnznO9/BunXrSvwvIKKuDPR3Cn6fGBzf/OY38b//+7+oqanBlClTsH79ejz33HN5Rbq+mDx5Mp599lnMmDEDjY2NWLduHaqrq3H++eejubkZ3/jGNzBu3Dh89tlnuPXWWzF16lQceOCBAIDLL78cf/jDH3DSSSfh4osvRigUwl133YUJEyagubm5oC4hZ5xxBv7jP/4Dt99+OxobG/MSo3314x//GLfddhu+973v4Wc/+xnGjBmD+++/H4FAAAC7mBAR0dDGQiARUYkNHz4cjz76KBYuXIjLL78ckyZNwpIlS/DRRx/1WyEQyBSAAoEAli9fjueffx7Tp0/Hs88+izlz5uRt5/V68eijj+InP/kJrrzyStTX1+OSSy7BsGHDcM455+Rt+/3vfx9jx47F//t//w+/+c1vkEwmsddee+HYY4/tsG2xTj75ZDz88MO44oorsGjRIuy7776499578fjjj+OFF17o02MPpEJ/zxUVFXjxxRfx61//2l5sra6uxn777YdrrrnGPmu5vx100EH461//ikWLFmHJkiUwTRPTp0/HH/7wB0yfPr1Xj7l48WJ89tlnuOGGG9DW1objjz+ehUAiIgd65513YBhGhzm0yWTSXmQ2TRPJZBL33Xefvd3dd9+NadOmYdOmTXa7UCJylsH4TsHvEwPvlltugaZpuP/++5FIJPD1r38dzz33XIcOIn1xyCGH4C9/+QtmzpyJb33rW1i9ejX+4z/+A3feeSduv/12tLS0oL6+HmeccQauvvpqqKoKABg/fjyef/55/PSnP8Wvf/1rjBw5EvPnz0coFMJPf/pTu+DWnX/7t39DMBhEW1sbzjjjjH77NwGZ+Y3r1q3DxRdfjFtuuQWVlZU4++yzcfTRR+P0008vaP+IiIjKlSI4WZeIaEjbe++9MWPGDKxYsaLUu0JERET9SFEUPProo3brtQcffBBnnXUW3nvvPWialrdtZWUl6uvrcdVVV+HXv/410um0fVs8HkdFRQWeffZZnHTSSYP5TyAiF+D3iaHtkksuwe9+9ztEIpEO7y1OcPPNN+PSSy/F559/jr322qvUu0NERFQSTAQSERERERENAYcffjgMw8COHTtw7LHHdrrN17/+dei6jn/961/2nK9//vOfANBhphYREQ0t8XgcwWDQ/nn37t343//9XxxzzDGOKAK2379EIoHf/e53+MpXvsIiIBERDWksBBIR0YBJpVJobm7udpuampq8L2tERETUe5FIBB9//LH98+bNm7Fx40bU1dVhv/32w1lnnYWzzz4bS5cuxeGHH46dO3di7dq1OPTQQzFnzhzMnDkTRxxxBM4991zcfPPNME0T8+fPx0knndShpSgR0UDj9wlnaWhowIwZM3DggQdi+/btuPvuuxEOh3HllVeWetcAAKeddhomTJiAqVOnorW1FX/4wx/w4Ycf4v777y/1rhEREZUUC4FERDRgXnnlFZxwwgndbnPvvffihz/84eDsEBERUZl788038957Fy5cCACYN28eVqxYgXvvvRfXX389fv7zn+OLL77AiBEjcNRRR+Gb3/wmAEBVVTz55JO4+OKLcdxxxyEUCmH27NlYunRpSf49RDS08fuEs5xyyil45JFHcOedd0JRFBxxxBG4++67cdxxx5V61wAAjY2NuOuuu3D//ffDMAxMmTIFDzzwQL/PIyQiInIbzggkIqIBs2fPHmzYsKHbbQ466CCMGTNmkPaIiIiIiIjcgt8niIiIiPqOhUAiIiIiIiIiIiIiIiKiMqSWegeIiIiIiIiIiIiIiIiIqP+VdEbgHXfcgTvuuAOffvopgEw7h8WLF2P27NkAgEQigZ///Od44IEHkEwm0djYiNtvvx2jR4+2H2PLli246KKL8Pzzz6OyshLz5s3DkiVL4PFk/2kvvPACFi5ciPfeew/jx4/HFVdc0aF//LJly/Cb3/wGTU1NOOyww3Drrbfia1/7mn17IfvSE9M08eWXX6KqqgqKovTiN0ZEREREVL6EEGhra8PYsWOhqjxnsVD8nkFERERE1DV+z6AhT5TQE088IVatWiX++c9/ik2bNon//M//FF6vV7z77rtCCCEuvPBCMX78eLF27Vrx5ptviqOOOkocffTR9v11XRcHH3ywmDlzpnjrrbfE008/LUaMGCEWLVpkb/PJJ5+IiooKsXDhQvH++++LW2+9VWiaJlavXm1v88ADDwifzyfuuece8d5774kLLrhA1NbWiu3bt9vb9LQvhdi6dasAwAsvvPDCCy+88MILL7x0c9m6dWtvv2IMSfyewQsvvPDCCy+88MILLz1f+D2DhirHzQisq6vDb37zG3znO9/ByJEjsXLlSnznO98BAHz44Yc48MADsX79ehx11FH4y1/+gm9+85v48ssv7WTe8uXL8ctf/hI7d+6Ez+fDL3/5S6xatQrvvvuu/XeceeaZaGlpwerVqwEA06dPx1e/+lXcdtttADJn1I4fPx4XX3wxfvWrX6G1tbXHfSlEa2sramtrsXXrVlRXV/fb74yIiIiIqByEw2GMHz8eLS0tqKmpKfXuuAa/ZxARERERdY3fM2ioK2lr0FyGYeDhhx9GNBpFQ0MDNmzYgHQ6jZkzZ9rbHHDAAZgwYYJdfFu/fj0OOeSQvPacjY2NuOiii/Dee+/h8MMPx/r16/MeQ25zySWXAABSqRQ2bNiARYsW2berqoqZM2di/fr1AFDQvnQmmUwimUzaP7e1tQEAqqur+QWdiIiIiKgLbG9ZHPn74vcMIiIiIqKu8XsGDVUlb4j7zjvvoLKyEn6/HxdeeCEeffRRTJkyBU1NTfD5fKitrc3bfvTo0WhqagIANDU1dZjRJ3/uaZtwOIx4PI5du3bBMIxOt8l9jJ72pTNLlixBTU2NfRk/fnxhvxQiIiIiIiIiIiIiIiKiPip5IXD//ffHxo0b8dprr+Giiy7CvHnz8P7775d6t/rFokWL0Nraal+2bt1a6l0iIiIiIiIiIiIiIiKiIaLkrUF9Ph8mT54MAJg2bRreeOMN3HLLLTjjjDOQSqXQ0tKSl8Tbvn076uvrAQD19fV4/fXX8x5v+/bt9m3yv/K63G2qq6sRDAahaRo0Tet0m9zH6GlfOuP3++H3+4v4bRARERERERERERERERH1j5InAtszTRPJZBLTpk2D1+vF2rVr7ds2bdqELVu2oKGhAQDQ0NCAd955Bzt27LC3WbNmDaqrqzFlyhR7m9zHkNvIx/D5fJg2bVreNqZpYu3atfY2hewLERERERERERERERERkZOUNBG4aNEizJ49GxMmTEBbWxtWrlyJF154Ac888wxqampw3nnnYeHChairq0N1dTUuvvhiNDQ04KijjgIAzJo1C1OmTMEPfvAD3HDDDWhqasIVV1yB+fPn20m8Cy+8ELfddhsuv/xynHvuuVi3bh0eeughrFq1yt6PhQsXYt68eTjyyCPxta99DTfffDOi0SjOOeccAChoX4iIiIiIiIiIiIiIiIicpKSFwB07duDss8/Gtm3bUFNTg0MPPRTPPPMMTjrpJADATTfdBFVVcfrppyOZTKKxsRG33367fX9N0/DUU0/hoosuQkNDA0KhEObNm4drr73W3mbSpElYtWoVLr30Utxyyy0YN24c7rrrLjQ2NtrbnHHGGdi5cycWL16MpqYmTJ06FatXr8bo0aPtbXraFyIiIiIiIiIiIiIiIiInUYQQotQ7MVSEw2HU1NSgtbUV1dXVpd4dIiIiIiJH4efl3uHvjYiIiIioa/y8TEOd42YEEhEREREREREREREREVHfsRBIREREHQghcMF9b+J7d74K02TzACIiIiIiIipfQgiYbJxHRGWqpDMCiYiIyJmSuok1728HAOyKJDGqOlDiPSIiIiIiIiIaGNuSaTQl0ziiJlTqXSEi6ndMBBIREVEHkaRu/zmWMkq4J0REREREREQDK2kKtBn87ktE5YmFQCIiIuoglsx+AYqm9G62JCIiIiIiInI3XQgkTQHB9qBEVIZYCCQiIqIOmAgkIiIiIiKiocKAQNoU0FkHJKIyxEIgERERdZCbAowmmQgkIiIiIiKi8qWbAmkhoDMRSERliIVAIiIi6iA3ERhnIpCIiIiIiIjKWNoUMISAyUIgEZUhFgKJiIiog/wZgSwEEhERERERUflKmgKmABOBRFSWWAgkIiKiDqJ5MwLZGpSIiIiIiIjKVxomDHBGIBGVJxYCiYiIqIPc1qDRJBOBRESFWLJkCb761a+iqqoKo0aNwty5c7Fp06Ye7/fwww/jgAMOQCAQwCGHHIKnn356EPaWiIiIiKS0CRgi0x6UiKjcsBBIREREHeSmAJkIJCIqzIsvvoj58+fj1VdfxZo1a5BOpzFr1ixEo9Eu7/PKK6/ge9/7Hs477zy89dZbmDt3LubOnYt33313EPeciIiIaGhLmyZbgxJR2fKUegeIiIjIeSI5KcAYZwQSERVk9erVeT+vWLECo0aNwoYNG3Dcccd1ep9bbrkFJ598Mi677DIAwHXXXYc1a9bgtttuw/Llywd8n4mIiIiGOlNkWoIaLAQSUZliIpCIiIg64IxAIqK+a21tBQDU1dV1uc369esxc+bMvOsaGxuxfv36Lu+TTCYRDofzLkRERETUO4YADAiYEDBYBySiMsRCIBEREXUQTXFGIBFRX5imiUsuuQRf//rXcfDBB3e5XVNTE0aPHp133ejRo9HU1NTlfZYsWYKamhr7Mn78+H7bbyIiIqKhxhACpsj8l4lAIipHLAQSERFRB0wEEhH1zfz58/Huu+/igQce6PfHXrRoEVpbW+3L1q1b+/3vICIiIhoqDCFgCAFAYSGQiMoSZwQSERFRB1HOCCQi6rUFCxbgqaeewksvvYRx48Z1u219fT22b9+ed9327dtRX1/f5X38fj/8fn+/7CsRERHRUGcAEAA0BdBNFgKJqPwwEUhEREQd5LUGZSGQiKggQggsWLAAjz76KNatW4dJkyb1eJ+GhgasXbs277o1a9agoaFhoHaTiIiIiHLoViLQqyhIMhFIRGWIiUAiIiLqIK81aJKtQYmICjF//nysXLkSjz/+OKqqquw5fzU1NQgGgwCAs88+G3vttReWLFkCAPjZz36G448/HkuXLsWcOXPwwAMP4M0338Sdd95Zsn8HERER0VBiCAETgFdVkGIikIjKEBOBRERE1AFbgxIRFe+OO+5Aa2srZsyYgTFjxtiXBx980N5my5Yt2LZtm/3z0UcfjZUrV+LOO+/EYYcdhkceeQSPPfYYDj744FL8E4iIiIiGHEPATgSmTbPUu0NE1O+YCCQiIqIO8luDMhFIRFQIUUArqRdeeKHDdd/97nfx3e9+dwD2iIiIiIh6Ylif4TS2BiWiMsVEIBEREXWQ1xqUiUAiIiIiIiIqU7oQABRoCpA2RUEndxERuQkLgURERJQnqRtIG9kvPindRNpgexQiIiIiIiIqP6YAFAioigIDAjrrgERUZlgIJCIiojyxZMcEIFOBREREREREVI50ISBEZqHcFDIhSERUPlgIJCIiojwRqy2o36PCqykAgBjnBBIREREREVEZMiBbgyowhLBnBhIRlQsWAomIiChP1Cr6Vfo9qPB5Mtd1khIkIiIiIiIicjvdFIAioClMBBJReWIhkIiIiPJErURgyO9BhU8DAMTZGpSIiIiIiIjKUNoU0BQFKjIzAg3WAYmozHhKvQNERETkLDL9V+HTkDYyrUGjbA1KREREREREZShpCqgANAVsDUpEZYmFQCIiIsojE4GVfg9ShgmAMwKJiIiIiIioPKVhZhKBigLB1qBEVIZYCCQiIqI8kZzWoB49kw7kjEAiIiIiIiIqR2kzf34WC4FEVG5YCCQiIqI8MWseYMivwaMq1nVMBBIREREREVH5SZuZRCAAKAo4I5CIyg4LgURERJTHTgT6PFCVTFFQFgeJiIiIiIiIyoUpBHQBWOfAsjUoEZUltedNBs6SJUvw1a9+FVVVVRg1ahTmzp2LTZs25W0zY8YMKIqSd7nwwgvzttmyZQvmzJmDiooKjBo1Cpdddhl0PT+58MILL+CII46A3+/H5MmTsWLFig77s2zZMuy9994IBAKYPn06Xn/99bzbE4kE5s+fj+HDh6OyshKnn346tm/f3j+/DCIiIoeI5rQGDfky5wyxEEhERERERETlxhCAAQHVSgQKsBBIROWnpIXAF198EfPnz8err76KNWvWIJ1OY9asWYhGo3nbXXDBBdi2bZt9ueGGG+zbDMPAnDlzkEql8Morr+D3v/89VqxYgcWLF9vbbN68GXPmzMEJJ5yAjRs34pJLLsH555+PZ555xt7mwQcfxMKFC3HVVVfh73//Ow477DA0NjZix44d9jaXXnopnnzySTz88MN48cUX8eWXX+K0004bwN8QERHR4MttDVrh1wBki4NERERERERE5cIQAqbILpKrCqCbLAQSUXkpaWvQ1atX5/28YsUKjBo1Chs2bMBxxx1nX19RUYH6+vpOH+PZZ5/F+++/j+eeew6jR4/G1KlTcd111+GXv/wlrr76avh8PixfvhyTJk3C0qVLAQAHHnggXn75Zdx0001obGwEANx444244IILcM455wAAli9fjlWrVuGee+7Br371K7S2tuLuu+/GypUr8Y1vfAMAcO+99+LAAw/Eq6++iqOOOqrffz9ERESlEMlJBCqQMwKZCCQiIiIiIqLyYggBQwhoSqYUqCkKkkwEElGZKWkisL3W1lYAQF1dXd71999/P0aMGIGDDz4YixYtQiwWs29bv349DjnkEIwePdq+rrGxEeFwGO+99569zcyZM/Mes7GxEevXrwcApFIpbNiwIW8bVVUxc+ZMe5sNGzYgnU7nbXPAAQdgwoQJ9jbtJZNJhMPhvAsREZHTyfRfpd/DRCARERERERGVLQOZdqBykVxTgJRplnCPiIj6X0kTgblM08Qll1yCr3/96zj44IPt67///e9j4sSJGDt2LN5++2388pe/xKZNm/DnP/8ZANDU1JRXBARg/9zU1NTtNuFwGPF4HHv27IFhGJ1u8+GHH9qP4fP5UFtb22Eb+fe0t2TJElxzzTVF/iaIiIhKKypbg/o8MK2WKLE0E4FERERERERUXnQ7EZjphqNCQYqtQYmozDimEDh//ny8++67ePnll/Ou/9GPfmT/+ZBDDsGYMWNw4okn4l//+hf23Xffwd7NoixatAgLFy60fw6Hwxg/fnwJ94iIiKhnUbs1qAbDaokSYyKQiIiIiIiIyowhBExkZgMCmdagKbYGJaIy44jWoAsWLMBTTz2F559/HuPGjet22+nTpwMAPv74YwBAfX09tm/fnreN/FnOFexqm+rqagSDQYwYMQKapnW6Te5jpFIptLS0dLlNe36/H9XV1XkXIiIip4vmzAgM+TLnDEU5I5CIiIiIiIjKjCEyxcDc1qBpU0CwGEhEZaSkhUAhBBYsWIBHH30U69atw6RJk3q8z8aNGwEAY8aMAQA0NDTgnXfewY4dO+xt1qxZg+rqakyZMsXeZu3atXmPs2bNGjQ0NAAAfD4fpk2blreNaZpYu3atvc20adPg9Xrzttm0aRO2bNlib0NERFQOoqlsIVDOCIylmAgkIiIiIiKi8iK74CiyNaiiwICAzjogEZWRkrYGnT9/PlauXInHH38cVVVV9qy9mpoaBINB/Otf/8LKlStxyimnYPjw4Xj77bdx6aWX4rjjjsOhhx4KAJg1axamTJmCH/zgB7jhhhvQ1NSEK664AvPnz4ff7wcAXHjhhbjttttw+eWX49xzz8W6devw0EMPYdWqVfa+LFy4EPPmzcORRx6Jr33ta7j55psRjUZxzjnn2Pt03nnnYeHChairq0N1dTUuvvhiNDQ04Kijjhrk3xwREdHAiSazMwJ1Q7YGZSKQiIiIiIiIyosuBADF/lkFkBKZ67051xMRuVlJC4F33HEHAGDGjBl5199777344Q9/CJ/Ph+eee84uyo0fPx6nn346rrjiCntbTdPw1FNP4aKLLkJDQwNCoRDmzZuHa6+91t5m0qRJWLVqFS699FLccsstGDduHO666y40Njba25xxxhnYuXMnFi9ejKamJkydOhWrV6/G6NGj7W1uuukmqKqK008/HclkEo2Njbj99tsH6LdDRERUGpGcGYFpwwQAxNgalMhx/vrRTjyx8Utc9W8HodLvmNHfRERERESuYQpAQTb+51EUmMK0k4JEROVAEWx4PGjC4TBqamrQ2trKeYFERORIacPEV/7PXwAAGxefhOZoCt9Y+iKqAh68c3VjD/cmosF0xu/W47XNzbjt+4fjm4eOLfXu9At+Xu4d/t6IiIiIeuejaAKvtUawdzDTWS5pmmhOGThpRDVqvTzZrlzw8zINdXw1IyIiIltuC9AKnwdJPZsIFELYcxOIqPRa42kAQDjOGZ5ERERERL1hQAAitzVoZkagwegMEZURtdQ7QERERM4RSWUKCj5Nhc+josKnAQAMU9hFQSJyhrZE5vkaSaZLvCdERERERO6kmwJQslU/TQEMIdgalIjKCguBREREZIvmzAcEMqlAiXMCiZylLZEpAEaSfG4SEREREfVG2hTQcjrfqIoCIQCdhUAiKiMsBBIREZFNFgJlAVBTFfg9mY8LsRTbDxI5hRACEev5Kp+3RERERERUnKQpOi6QKwoLgURUVlgIJCIiIlvUShZV+rNJwJD1ZyYCiZwjljJgWmsTkQQLgUREREREvZGGmZcIBACFMwKJqMywEEhERES2SLvWoADsOYFMHRE5RyTn+RhhWpeIiIiIqFfSZscFcrYGJaJyw0IgERER2WT7z1BuItDHRCCR07TlpABZpCciIiIi6p202TERKMBCIBGVFxYCiYiIyCYLCrL4BwAVfiYCiZymLZG2/8zWoERERERExTOFgC4ANb8OCFUBdJOFQCIqHywEEhERkS1izQjMTQTK1qDxNBOBRE6R1xqURXoiIiIioqIZAjAgoLZLBGqKgiQTgURURlgIJCIiIptsDVqZNyMwUxSMJlkIJHKKvNagnBFIRERERFQ0QwiYouMCuaYAKdMsyT4REQ0EFgKJiIjIJpNFFXkzAjNFwRiLDUSOkdsOlK1BiYiIiIiKZwgBQ4gOMwJVKEixNSgRlREWAomIiMgm5wBW5rYG9TMRSOQ04ZwZgXxuEhEREREVzwAg0FkiUEGKrUGJqIywEEhERES2aMqaEejLtga1E4Fppo6InCJ3LmDKMJHS2bqIiIiIiKgYeheJQE0B0qaAYDGQiMoEC4FERERki3bSGjRozQiMMXVE5Bht7dqBRpMs1BMRERERFcMQAiYANb8OCFVRYEBAZx2QiMoEC4FERERk66w1qEwERjkjkMgx2s8FjLAQSERERERUFENkioEdWoNat+lMBBJRmWAhkIiIiGwRK/UX6mRGIBOBRM7Rlkzn/cxCIBERERFRcQyr0Kd0aA2qwLTahhIRlQMWAomIiMgWs1J/nc0IZCKQyDnYGpSIiIiIqG8yiT+lw/WqAphMBBJRGWEhkIiIiGyymJCXCLRmBMZTTAQSOUX7QmAbC4FERESOtT2cwF1//QSt8XTPGxPRoDEFoKBjsU8FZwQSUXnx9LwJERERDRWRTmYEVtiJQBYCiZxCPlcVBRCCiUAiIiInu+OFf2HFK58CAM4/dp/S7gwR2XQhOikDApqSaRvK1qBEVC6YCCQiIiIAgGEKJNImgGzxDwBC/syfY2wNSuQYESsROKrKD4CFQCIiIifb0ZYAAOxsS5Z4T4golwEBiM5agyoQAiwEElHZYCGQiIiIAOTPAOysNWg0yUQgkVO0JTKtxeqrA9bPLAQSERE5VTieeZ9mK28iZ9FNAUXpotinKJwRSERlg4VAIiIiApBNFHlUBX5P9iNCyCoEMhFI5AyGKexWvfU1mUIgC/VERETOJU/gifDEHSJHSZsCqtIxEQhkZgcarAMSUZlgIZCIiIgAZAsJIb8HSs6XoaDVJjSeNmCa/CZEVGqRnDSBTARGWagnIiJyrLBVAIwwEVgW0oaJU5f9DQsf2ljqXaE+Spqiy8VxATARSERlg4VAIiIiApBNBIZy5gMC2RmBQgAJnakjolKTi4g+j4phIR8AtgYlIiJysnCcicBy8umuKP6xtQVPbPwSgoUiV0vDhNZFIhCChUAiKh8sBBIRERGAnEJgznxAAAh4NMjvRmw/SFR6sr1Yld+DSr+c4cmFRSIiIicSQtgn7ISt93ByN5nw1E2BRNos8d5QX6TNrhfHFSXTOpSIqBywEEhEREQAYM8ca18IVFUFFd5MKpBzAolKT6YJqgIsBBIRETldUjeRMjLFIrYGLQ+5Bd02FnddLW12nQjUFAUpJgKJqEywEEhEREQAchOBWofbKuxiAxOBRKUmUwWVAY9duG/jwiIREZEj5RaNWAgsD7LVK8CUp5uZQkAXgNpFZ1BNAVImE59EVB5YCCQiIiIA2YWJkM/T4bYKa25gPM3FC6JSk0W/Kr+XiUAiIiKHC8ez79GRhM6ZcmUgnDPrMcy5j65lCMCAgNpFIlCFghRbgxJRmWAhkIiIiABk235W+jsrBDIRSOQUsgVVZcCDygALgU7z0ksv4Vvf+hbGjh0LRVHw2GOPdbv9Cy+8AEVROlyampoGZ4eJiGhA5SbGOFOuPOQlAuNMBLqVIQRM0fXiuKYoSDIRSERlgoVAIiIiAgBErCJfRSetQUM+zggkcorcGYEywctWY84RjUZx2GGHYdmyZUXdb9OmTdi2bZt9GTVq1ADtIRERDaa2domxtiQLR26XPyOQn8HcyhAChhDdzAgEdAGmeImoLHQ85Z+IiIiGpOyMwE4SgZwRSOQYEbs1qMdO8LIQ6ByzZ8/G7Nmzi77fqFGjUFtbW9C2yWQSyWTS/jkcDhf99xER0eBonxiLJHSMqirRzlC/yG33ykKgexkABLpOyaiKAsOaI+jtYo4gEZFbMBFIREREAHJag3YyI5CJQCLnaLMTgV67NWgibUI32LrIzaZOnYoxY8bgpJNOwt/+9rdut12yZAlqamrsy/jx4wdpL4mIqFjtC0U8ecf9chOBuX8md9F7SgQiM0dQZyKQiMpASQuBS5YswVe/+lVUVVVh1KhRmDt3LjZt2pS3TSKRwPz58zF8+HBUVlbi9NNPx/bt2/O22bJlC+bMmYOKigqMGjUKl112GXQ9/4PVCy+8gCOOOAJ+vx+TJ0/GihUrOuzPsmXLsPfeeyMQCGD69Ol4/fXXi94XIiIit8q2Bu1YCAzahUAmAolKTS4oVgY8COW08o3y+elKY8aMwfLly/GnP/0Jf/rTnzB+/HjMmDEDf//737u8z6JFi9Da2mpftm7dOoh7TERExWhfKIowQeZ6uSnPNhYCXcsQAiYAtYu0n6YoMK1iIRGR25W0EPjiiy9i/vz5ePXVV7FmzRqk02nMmjUL0WjU3ubSSy/Fk08+iYcffhgvvvgivvzyS5x22mn27YZhYM6cOUilUnjllVfw+9//HitWrMDixYvtbTZv3ow5c+bghBNOwMaNG3HJJZfg/PPPxzPPPGNv8+CDD2LhwoW46qqr8Pe//x2HHXYYGhsbsWPHjoL3hYiIyM1ka9DKTmcEWq1BWWggKjm54FTp98Dv0eDVMqsXTBi40/77748f//jHmDZtGo4++mjcc889OProo3HTTTd1eR+/34/q6uq8CxEROVP71qBhFgJdL/cY5rYJJXcxRKYY2HVrUCYCiah8lHRG4OrVq/N+XrFiBUaNGoUNGzbguOOOQ2trK+6++26sXLkS3/jGNwAA9957Lw488EC8+uqrOOqoo/Dss8/i/fffx3PPPYfRo0dj6tSpuO666/DLX/4SV199NXw+H5YvX45JkyZh6dKlAIADDzwQL7/8Mm666SY0NjYCAG688UZccMEFOOeccwAAy5cvx6pVq3DPPffgV7/6VUH7QkRE5GaRbmcEWolAFhqISs6eEWi1Ba30e7AnlraL+eR+X/va1/Dyyy+XejeIiKgfsDVo+clNATIR6F4y6ad01RpUUWAgMyOQiMjtHDUjsLW1FQBQV1cHANiwYQPS6TRmzpxpb3PAAQdgwoQJWL9+PQBg/fr1OOSQQzB69Gh7m8bGRoTDYbz33nv2NrmPIbeRj5FKpbBhw4a8bVRVxcyZM+1tCtmX9pLJJMLhcN6FiIjIqeT8v84KgUwEEjlHdkZg5nkpn7NcWCwfGzduxJgxY0q9G0RE1A86tgZl4cjtclOA7Qu95B6ZpF8XfUGRWTRna1AiKhclTQTmMk0Tl1xyCb7+9a/j4IMPBgA0NTXB5/OhtrY2b9vRo0ejqanJ3ia3CChvl7d1t004HEY8HseePXtgGEan23z44YcF70t7S5YswTXXXFPgb4CIiKi0otaMQFn0y1VhzwjkF12iUssmAr0AMolAgDOHnCISieDjjz+2f968eTM2btyIuro6TJgwAYsWLcIXX3yB++67DwBw8803Y9KkSTjooIOQSCRw1113Yd26dXj22WdL9U8gIqJ+JAtFHlWBbgqeuFMGcou77Qu95B6mABR0XeRTFQVCgIVAIioLjikEzp8/H++++25ZtcBZtGgRFi5caP8cDocxfvz4Eu4RERFR17KtQTvOCKywioMxJgKJSi53RmDuf9ka1BnefPNNnHDCCfbP8vvAvHnzsGLFCmzbtg1btmyxb0+lUvj5z3+OL774AhUVFTj00EPx3HPP5T0GERG5l5wROLo6gC9a4mjj+7WrJdIGUrpp/8xEoHvpQnRTBrQoCtIsBBJRGXBEIXDBggV46qmn8NJLL2HcuHH29fX19UilUmhpaclL4m3fvh319fX2Nq+//nre423fvt2+Tf5XXpe7TXV1NYLBIDRNg6ZpnW6T+xg97Ut7fr8ffr+/iN8EERFR6cj5f5WdtQb1MxFI5BRsDepsM2bMgOhmwWjFihV5P19++eW4/PLLB3iviIioVOT79l61wUwhkIUjV2ufAJSFXnIfAwIQXbcGBTKJQZN1QCIqAyWdESiEwIIFC/Doo49i3bp1mDRpUt7t06ZNg9frxdq1a+3rNm3ahC1btqChoQEA0NDQgHfeeQc7duywt1mzZg2qq6sxZcoUe5vcx5DbyMfw+XyYNm1a3jamaWLt2rX2NoXsCxERkVuZprDn/1V02hpUJo6YCHSzHeEEEmkeQzdL6SaS1lnoVf52rUFZCCQiInIcWTgaUxsAwFbebpc7HxBgItDNdFNAUbqv8gnIWYJERO5W0kTg/PnzsXLlSjz++OOoqqqyZ+3V1NQgGAyipqYG5513HhYuXIi6ujpUV1fj4osvRkNDA4466igAwKxZszBlyhT84Ac/wA033ICmpiZcccUVmD9/vp3Gu/DCC3Hbbbfh8ssvx7nnnot169bhoYcewqpVq+x9WbhwIebNm4cjjzwSX/va13DzzTcjGo3inHPOsfepp30hIiJyq1hOcajTRCBnBLrettY4jv2v53HUPsPxh/Onl3p3qJdyi32VAbYGJSIicjqZGBtbGwTAE3fcThZ2g14N8bSBSEqHaQqoavfJMnKetCmgKj0cN8FCIBGVh5IWAu+44w4AmfY5ue6991788Ic/BADcdNNNUFUVp59+OpLJJBobG3H77bfb22qahqeeegoXXXQRGhoaEAqFMG/ePFx77bX2NpMmTcKqVatw6aWX4pZbbsG4ceNw1113obGx0d7mjDPOwM6dO7F48WI0NTVh6tSpWL16NUaPHm1v09O+EBERuZVsC6oqQMDbsWFAhZ+JQLfb1NQG3RT4YFu41LtCfSDnA1b4NGjWglO2NSifn0RERE6iG6bddcMuBDJB5mqysLvXsCA+3hGBEEBbUkdN0FviPaNiJU3RY6s8RckUDImI3K6khcDuZmdIgUAAy5Ytw7Jly7rcZuLEiXj66ae7fZwZM2bgrbfe6nabBQsWYMGCBX3aFyIiIjeSZyaHfB4onZwVWWElAuNsK+lae2IpAEBLPA0hRKfHmZyv/XxAAKi0ZnhGkpxRQ0RE5CS56b+xNZnWoO1nzJG7hK3PYiMqfdjarCKpm2hLpFkIdKE0TGjWd6K4YeIP23bj6NpKHFQZtLfRFAVJYZZqF4mI+k1JZwQSERGRM8ikX6iTtqBAthDI1oPutTuSKQQaOfMgyX3kgmJuC1/ZIpSJXSIiImeRJ/AEvRqGhXwA2BrU7WQisDrgRVXAa13HY+pGaTO7ML4hHMUzu8J4uGlP3jaaAqSYCCSiMsBCIBERESFqzf4LWcmi9kK+TKEhqZvQDZ4R6UYyEQgALTl/JnfJJgKzZ51nW4NyEYpoqDJMgfe+bIXBxUoiR2m1ikZVAQ+q+H5dFuRnseqgF9XWyVhtTHm6UtrMJgLDeuY7bpuef2KdCoWtQYmoLLAQSERERHbSr8tEYE6BMMb2oK7UHM0W/+SiFLmPbP+Z3xrUWljkzCGiIWvFK59izm9fxv+u/7TUu0JEOWQb0Oqg107wRxJ6QaNyyJnsYxrwospqB9rGz2CuYwoBXQDWyG1EDcP6b/5Jr5qiIGnyRFgicj8WAomIiChvRmBnfJoKj/UtKcb2g64kW4MCQGuMhUC3kgtNua1B5fNWJnuJaOj5eEcbAOCjHZES7wkR5cqd7SvT/LopkNRZWHAruzVo0GMnAjn30X0MARgQUK1EYMR6TkaM/O+6mgLoAizeE5HrsRBIREREiKW6nxGoKAqC1pzAGIsNrpTbGpSJQPfKXVCU7IQBW40RDVnydZ2v70TOkjtPrsKrwao5sHDkYmHZGjTgRXWAiUC3MoSAKbIL47IAmDAFjJyin6ooMJBJDxIRuRkLgURERGS3Bq3sYkYgkE0dyaIhucvunNagLVwodq1sIjA7I5CtQYmoJcZCIJET5c6TU1UFlT6+Z7tdOHfuo0wE8rXXdQyRKfjJGYG5LUFz/6whkx7UmQgkIpdjIZCIiIjsJFFFF4nAzG2ZImGUqSNXyp0R2MLWoK7V2YxAmeTlc5No6JIFQC5GEzmLTP7J922m+N0vd+6jPK5tPJ6uYwAQyE0E5hYCsye+aooCU+SnBImI3IiFQCIiIspJBHZdCGQi0L10w8xLiTAx4l6dtgaVhcCUAdPkIgXRUMREIJEzhePZNpJA9v2biUD3ym33mm0Nytdet9HbJQJzZwNGcmZ4qgoTgURUHlgIJCIiIkTljEBfN4lAe0YgC4Fu0xJPI/e7a2s81fXG5GiRbgqBABBL8/lJNBSFOSOQyJHa2icCrffsMAuBrmXPCAzmtgbl8XQbQwiYyBT6ACCqd9EalDMCiahMdL3al+O0004r+oGXL1+OUaNGFX0/IiIiGnwyERjqZkagLARGU/yi6zZ7ovmFPy4Uu1dnMwIDXhWqApgiUyjsLtlLROVHN0y7LV1rPA3TFFDlyiYRlVRuG0kAqLQSZGwN6l55iUDruIaZCHQdQ2SKgTIh09WMQBVga1AiKgsFrRI89thj+Pd//3cEg8GCHnTlypWIRCIsBBIREblEthDY3YxAqzUoFy5cZ3e7QiBnBLqXXOzPTQQqioJKvwfhhM6FRaIhKDdZZAogktLtdnVEVFryBJ5q6327yi9bg/KzmBsldQNJKzmWmREoC4H8/OU2srCnKAqSpolUTqEvt02oqigQbA1KRGWg4NOFf/vb3xZc2HvkkUd6vUNEREQ0+KJJqzVotzMCZSKQrQfdppmJwLIRSWaOXWUg/7kqC4FRFgKJhpz2r+mtsTQLgUQOYScCreekTO3zxB13koVdRckUdeWJWZwR6D6Zwl4mPZ+bAASAWLufhaKwEEhErlfQjMDnn38edXV1BT/oX/7yF+y111693ikiIiIaXLLdpyz2dabCmh8YY2tQ15GFwFFVfgBMBLpZ+2SBFOLCItGQ1RLjyR5ETiVnx1UHrUSgLBzx/dqVZFvQSr8HqqrYBd42JgJdxxSAgkxxL3c+IABE2hUCVQiYrAMSkcsVVAg8/vjj4fEUPmvkmGOOgd/v7/VOERER0eCKFNIa1CoSxpgIdB1ZCJw0IgSAi8RuJYRApJMZgUA2IchCINHQ0/41PczXeCLHkEkx2UKy0k6Q8f3ajcL2CVmZ4ykLu3zddR9dCMjaXm4rUACItvtZgK1Bicj9CioE5jr++ONx3333IR6PD8T+EBERUQnErNagld21BrVnBLIQ6DayELjPyEwhMJLUkW53pis5XyJtQrdOR+6sNSgAtgYlGoI6tAblgjSRIwghOhSO7NagLAS6kiz4VQe9ef9N6iaSOr8juYkBAYhMa9D2CcBIu4QgOCOQiMpA0YXAww8/HL/4xS9QX1+PCy64AK+++upA7BcRERENIlk8qOi2NaicEciFC7eRhcC9h4fs63jmsvu0WfMBFaVjG9+Qj4lAoqGKhUAiZ4qnDRjWCTztW4Py/dqdsjMfM8cx9yRKpjzdRTcFFMVqDdouAdh+RqCqAGn2BiUilyu6EHjzzTfjyy+/xL333osdO3bguOOOw5QpU/Df//3f2L59+0DsIxEREQ0gIYRd3Os2EWjPCOTZrm4jC4Ejq/z2AhQXit2nLZF9niqKkncbW4MSDV3t577y9Z3IGeR8QE1VEPRmTuCRrb2ZCHQneUxlq1dNVezvTywEukvaFFCtz9MyARhUO08IaoqCpGA3FSJyt6ILgQDg8Xhw2mmn4fHHH8fnn3+O73//+7jyyisxfvx4zJ07F+vWrevv/SQiIqIBkkib9vDzbmcE+q1EIAsNriMLgcNCPtRYLYxauFDsOpF27cVysTUo0dDFRCCRM+Wmx+QJPPKErDa+X7uSfUyD2e9M1fbcR772uknSFJD9NWThb7RVqG+fEFQVBSkmAonI5XpVCJRef/11XHXVVVi6dClGjRqFRYsWYcSIEfjmN7+JX/ziF/21j0RERDSAchNE8mzlzsjWoPE0E4FuIwuBw0M+1FZkvuC2xrhY4Ta5icD2QlahngkDoqFHFv4CXjXvZyIqLVkYqso5gaeSRSNXs2cE5hxTeXxlWpDcIQ3TTgTKwt9onywEtmsNCrYGJSL3K7oQuGPHDixduhQHH3wwjj32WOzcuRN//OMf8emnn+Kaa67BXXfdhWeffRbLly8fiP0lIiKifiYTRCGfBlVVutyuwsfEkRsJIexCYF1OIpALxe4TScoFxY6FQLvVWJKFeqKhRrYGnVBXkfmZr+9EjiALQ7npsSo/W3m7WTYRmC0EyuPL4q67pM3soridCJSjMAwTpsgW/jRFQdJka1Aicreu+391Ydy4cdh3331x7rnn4oc//CFGjhzZYZtDDz0UX/3qV/tlB4mIiGhgyfmA3bUFBTgj0K2iKQMp68ttXciH2qAPANASS5Vyt6gXwjIR2GkhkK17iYYqmVCZUFeBf26P2D8TUWllW4N2TARGEjqEEB1m/pKz2cXdnM9idiKQhUBXSZsmNDsRmN8a1AQQN02EtMzna00BdAGYIjtXkIjIbYouBK5duxbHHntst9tUV1fj+eef7/VOERER0eCJWgmiztoN5uKMQHdqjmQKfgGvigqfxz6DuZXti1xHtv2s6mRGYIgJA6IhqyWeeZ2fUBcCwMQ3kVOE7fftjkUj3RRI6iYC3bTlJ+dp6yQRaM99ZHt21zCFgC4A2Qwnome+D9d6NPgUBSkhENWzhUBVUWAIASPnPkREblN0a9CeioBERETkLrKwJwt9XWEi0J2areRfXUUmCShnBMqFY3KP7mcEshBINFS12onAYN7PRFRabZ0kAiu8GmSgiAky95HF3dxjWm0nAvkZzC0MARjIpvtka9CQpiGkZZbKc+cEatZ9dME5gUTkXgUVAo844gjs2bOn4Ac95phj8MUXX/R6p4iIiGjw2K1Bfd0nAoO+TKFQNwVSOmckuEVzNAkAqKu0CoGcEehackZgdSetQeXMISZ2iYYeOSNw4nAmAomcRLaRzE3yq6qCSl+2PSi5i2y9nDf30fpcxrbM7mEIAVNkF8Vl0a/So3ZeCFQUmELAYCGQiFysoNagGzduxD/+8Q/U1dUV9KAbN25EMpns044RERHR4JCFgx5bg/qyicFYSofP4xvQ/aL+sdtqDVoX8gMAamQhMMbFCreJdPNcZSKQaGhKpA0krZNzxtdVAMgsRpumgMr+ZUQlZc8IDOa/b1cGPGhL6nzPdqHO5j7KNqFsDeoehlXU0xQVQgi7NWilpiHk0YBkGhEj2wVHVZgIJCL3K3hG4IknnghR4Asehx0TERG5R8SaEVjRQyHQq6nweVSkdBPRlIHaisHYO+qrPXZr0MwiRbY1KAuBbiNbTlV2kghkIZBoaJIJFFUBxg3LtAY1BRBJ6XkL1UQ0+No6aSMJZE/oYSLQfWTKs6aTGYFs9eoeBgCBTCIwYQrIkl9I6zoRaCAzV5CIyK0KKgRu3ry56AceN25c0fchIiKiwZdNBHY/IxAAQj4NKd1EjMUG19gdzU8EVrM1qGvJBcPcFmP/iiVQ5/XYi1DRpA4hBE/MIxoiWuw2dV4EvBr8HhVJ3URrLM1CoMste/5jVPg0nPP1SaXeFeolWaivancCj/y5jZ+nXSWlm4inMyWj3GMqP5e1sRDoGrqdCFTQaqUBPQoQUBVUdjEjkK1BicjtCioETpw4caD3g4iIiEqk0BmBAFDh82BPLI1oyuhxW3KGPXYh0EoEBjMtXVvYGtR15AKTTBLEDRMfROLYJ+jHBH/muJoCSKRNe6YnEZU3eVKHnP9aE/RiR1sSrfE0xpdyx6hPdkWS+M0zm6AqwPenT4Dfw9d0N2pLZAv1uSoDbCXpRrmFvtw27XJ2M4+nexhCwEQmTS9bgIY0DYqi5CQCs993FUWBYGtQInI5tedNiIiIqJzJRGBPrUGB7JzAWIpfdN2iuV0isMZqDRqOpwtu+07OINt+ygWn5rSOFt3AtpSOoCf7sb4tySIv0VAhT+qQbepk+2emvt1tZ1sSQObkDp64415hO8nfLhFotwblsXUTu0W73wOPlv3cJROBbA3qHobIFANVABFrzq4sAIa0zPfdSE4iEACEorAQSESuxkIgERHREBe1ZgQW0hpUFgtjSSYC3SLbGjSTGJOpkZSRbW9E7tDWbkbgzlQaScNES1pHTAj77PQon59EQ4Ys+NVUZF7ja9j+uSzIk3ja/5ncRbYG7XJGIFuDukr2eOYXdmuCTAS6jWzxqSiKnfyrtAuBHVuDAoAKAYN1QCJyMRYCiYiIhjiZCAwVkAgMWYnAKBOBrrGnXSGwwqfBq2XmxzFl4C65MwLTpsAXiTRG+LyImyb2pHWErGJ+lAuLRENGSyzzGl+T0xoUYCHQ7XZFkvaf97AQ6FqyMFTToTUoZwS6UbiLVq9VOa1e2W3DHTLJvsz3IZn8q7RaMNuFQL1dIhBsDUpE7sZCIBER0RBX7IxAAIhxRqBrtE8EKorChWIXMk2BSCrbkqo5rSNsGKj2aFAAqxDIM9KJhhqZUJGJlGq+vpeF3ZGcRGCMhUA3Sud0XujQGjQgW4Py/dpN5Oer9glPeTwNU/A7kkuYAlCQKerJQqAsAFZarUFzZwQCAEQ2SUhE5EZFFwL32Wcf7N69u8P1LS0t2GeffYp6rJdeegnf+ta3MHbsWCiKgsceeyzv9h/+8IdQFCXvcvLJJ+dt09zcjLPOOgvV1dWora3Feeedh0gkkrfN22+/jWOPPRaBQADjx4/HDTfc0GFfHn74YRxwwAEIBAI45JBD8PTTT+fdLoTA4sWLMWbMGASDQcycORMfffRRUf9eIiIiJ4pYbQQLSgQyceQqKd20Fy2GW4VAIHtmOhOB7hFN6ZBrD1UBD3am0jCEgFdVUKlp2JZM57QG5fOTaKiQBb/aIFuDlpPcdqBMBLpT7kk5le0+Y1fyxB1XsluDBvOPZ9CrwaNm0mU8pu6gCwFZ0uvQGtTTRWtQBUibLAQSkXsVXQj89NNPYbQ/KwJAMpnEF198UdRjRaNRHHbYYVi2bFmX25x88snYtm2bffnjH/+Yd/tZZ52F9957D2vWrMFTTz2Fl156CT/60Y/s28PhMGbNmoWJEydiw4YN+M1vfoOrr74ad955p73NK6+8gu9973s477zz8NZbb2Hu3LmYO3cu3n33XXubG264Ab/97W+xfPlyvPbaawiFQmhsbEQikSjq30xEROQ0Mbs1aAEzAq3WoHGe7eoKsmWcquS3peJCsfvIhSWvpsCjKfg8kbLPXA5pKsK6iQBb9xINOS12IpCtQcvJ7mi2NWhzlMfSjWTRKOTT4NHyl97sRCBP3HEVuzVou0Sgoij2MZXbkLMZEIDIFG9lC1CZBOxqRqCmKEiK/OuIiNyk51P/LU888YT952eeeQY1NTX2z4ZhYO3atdh7772L+stnz56N2bNnd7uN3+9HfX19p7d98MEHWL16Nd544w0ceeSRAIBbb70Vp5xyCv77v/8bY8eOxf33349UKoV77rkHPp8PBx10EDZu3Igbb7zRLhjecsstOPnkk3HZZZcBAK677jqsWbMGt912G5YvXw4hBG6++WZcccUVOPXUUwEA9913H0aPHo3HHnsMZ555ZlH/biIiIieR6aH2Zyt3RrYGjbIQ6AqyLeiwCh9U60xlAKityCRHWuNMGbiFXCysCnixRzfQohsYaT0fA5qKZDINrzezgMGz0YmGDlnwq6lgIbCc5LYG3cPWoK7U1Tw5AKj0Z65ja1B3Ccet1qCdHNPqoBd7Ymm0sRDoCropoCiZdF9bu9ag8r8Rw4AQAoqS+Q6lKgpSTAQSkYsVXAicO3cugMyZLvPmzcu7zev1Yu+998bSpUv7decA4IUXXsCoUaMwbNgwfOMb38D111+P4cOHAwDWr1+P2tpauwgIADNnzoSqqnjttdfw7W9/G+vXr8dxxx0Hny/bDquxsRH/9V//hT179mDYsGFYv349Fi5cmPf3NjY22q1KN2/ejKamJsycOdO+vaamBtOnT8f69eu7LAQmk0kkk9kz+cLhcJ9/H0RERP1NFhgqCpgRGLISRzEmjlxBthMbltMWFABquVDsOrK4V+n3YHdKR9oU8KvZhIFXVaDJVkZMGBANGbLFc/tEYJiv7662O6cdaDNbg7pSV/PkgGwisI3v166STQR2/M5kJwLjPKZukDYFVKvAZ7cG9eTPCNQFkBICflkIBFgIJCJXK7gQaJqZMyQmTZqEN954AyNGjBiwnZJOPvlknHbaaZg0aRL+9a9/4T//8z8xe/ZsrF+/HpqmoampCaNGjcq7j8fjQV1dHZqamgAATU1NmDRpUt42o0ePtm8bNmwYmpqa7Otyt8l9jNz7dbZNZ5YsWYJrrrmmF/9yIiKiwSFEdqh9QYlAewYZE4FuIBcS69oVAqs5I9B15BnmlX4PvkimUdGuzVhIUyE81oIGFxaJhoywPSOQicBysjuSPaGYiUB3ks/Nqk6KRpWyEMj0mKtkj2knxV0r5cnWoO6QNAXkUIyonQjMXBNQFagATOs2eeKdR1GQMtkalIjcq+BCoLR582b7z4lEAoFAoF93KFdu0u6QQw7BoYcein333RcvvPACTjzxxAH7e/vLokWL8pKG4XAY48ePL+EeERER5UvqJnTrzMZCZgQyEeguMkUwvH0i0Goh18KFYteQyd2gX0NzSketN//5WqlpUK0zmZkwIBo6WtgatCwxEeh+diKwkzaSVX7OCHSjsH1MOy6lyuvYnt0d0jDtRGDEnhGY+RytKApCmoo2w0RUN1FnPYVVJZMSNEU2TUhE5CZqz5vkM00T1113Hfbaay9UVlbik08+AQBceeWVuPvuu/t9B3Pts88+GDFiBD7++GMAQH19PXbs2JG3ja7raG5utucK1tfXY/v27XnbyJ972ib39tz7dbZNZ/x+P6qrq/MuRERETpKbHCqkNWjQ2ibGGYGu0NxFa1AuFLuPXFjy+TQkTBPBdolAr6rA62VrUKKhRAhhv47XBjOv8/aJHkx8u1ZSN/KKCXtYCHQlmQzrLhEYSegQgq0G3UImAjtv98pEoJukTUCzankR2RpUy55kJ9OB8jYgMyPQgIDBpywRuVTRhcDrr78eK1aswA033JA3d+/ggw/GXXfd1a87197nn3+O3bt3Y8yYMQCAhoYGtLS0YMOGDfY269atg2mamD59ur3NSy+9hHQ6+2a8Zs0a7L///hg2bJi9zdq1a/P+rjVr1qChoQFAph1qfX193jbhcBivvfaavQ0REZEbyYJe0KtBU3s+s5GJQHfpKRHYyoVi14hYi8KKR0VA6/y5GgqwdS/RUBJNGTCsVL88wUOmj8KJNEzOMnKlPdH89+ZmtgZ1pe6KRrIdv24KJHW2GnQLe0ZgJylPeZyZCHSHtGlChQJTCMRka1BPdolczguUbUMBQANgCEBn8Z6IXKroQuB9992HO++8E2eddRa0nLMlDjvsMHz44YdFPVYkEsHGjRuxceNGAJm2oxs3bsSWLVsQiURw2WWX4dVXX8Wnn36KtWvX4tRTT8XkyZPR2NgIADjwwANx8skn44ILLsDrr7+Ov/3tb1iwYAHOPPNMjB07FgDw/e9/Hz6fD+eddx7ee+89PPjgg7jlllvyWnb+7Gc/w+rVq7F06VJ8+OGHuPrqq/Hmm29iwYIFADKx8EsuuQTXX389nnjiCbzzzjs4++yzMXbsWMydO7fYXyEREZFjyJZEoQLmAwKcEeg2zV3MCGQi0H3sOUIeBdVa5218a6znZyvPRicaElqsApFPUxGwEsHy9V0Itgl2q13WfMAK6+SrRNpEnJ0YXEe2kewsERjyeSA7C7Jw5B7huNUatNNEoMfahp/BnM4UArrItPqMmyZkqS+U021D/jmvEKhkCocGC4FE5FJFFwK/+OILTJ48ucP1pmnmpe4K8eabb+Lwww/H4YcfDgBYuHAhDj/8cCxevBiapuHtt9/Gv/3bv2G//fbDeeedh2nTpuGvf/0r/H6//Rj3338/DjjgAJx44ok45ZRTcMwxx+DOO++0b6+pqcGzzz6LzZs3Y9q0afj5z3+OxYsX40c/+pG9zdFHH42VK1fizjvvxGGHHYZHHnkEjz32GA4++GB7m8svvxwXX3wxfvSjH+GrX/0qIpEIVq9ePaAzEomIiAZa1C4E9jwfEGAi0G26LgRmfm6JM2XgFnJB3+PVUKF1/hHeLvCyEEg0JLTmzAdUrKqC36PZRUEuSLuTfO+eUFcBr5UA38NUoOt0lx5TVQWVPjlTjs9Tt2izj2nH4q4sBLKw63yGAAxk5vzJ+YA+RYFf7VgIzG8NykQgEblbYaf/55gyZQr++te/YuLEiXnXP/LII3ZBr1AzZszoth/6M8880+Nj1NXVYeXKld1uc+ihh+Kvf/1rt9t897vfxXe/+90ub1cUBddeey2uvfbaHveJiIjILexEYAHzAYHsHMEoz0x3ha4KgWwN6j5yYanCr9kL/u3J5ydTQERDg3wNr2lXaKgJepFIJ9EaT2N8KXaM+mR3NJMIHF7pQ3PUhx1tSTRHUxhbGyzxnlEx5Pt2Z+kxIDMnsC2p25/Fydl0w7S//3R2TGXBl4Vd59OFgCkAr5JN/IXanWQnZwS2TwQayKQJiYjcqOhC4OLFizFv3jx88cUXME0Tf/7zn7Fp0ybcd999eOqppwZiH4mIiGiAyBmBlYW2BrUSgWxR5Q5yrtCwis5bg4YTOgxTFDQfkkqrxVpYqu0kWSAFrednJKFDCNFlwZCIyoNMBLZ/XagJerE9nGT7Z5faHZHzff3YHUphR1uSiUAXkonczlqDAtnP3hEmyFwhN+nX2TGtlq1BeTwdT7b31BTVTvyFPCqEEPhgaysmjAyhsrPWoDn3JSJyo6Jbg5566ql48skn8dxzzyEUCmHx4sX44IMP8OSTT+Kkk04aiH0kIiKiASLPQq4osDWo3C6a0rtN9VPpCSGwx0oEDq/svBAIsHWcW+yxkj+1XSQLACBgt+410JazcEFE5akl3nUiEOAcWLfanfPeLU/kkQl/cg9ZEOqsNSiQSQQCTPG7hWz1GvJp8HTSol2mBJkIdD5dCAhkFsRloa9S0/DeZy349R/fxj3PfGS34Y/q2c/TiqJAsDUoEblY0YVAADj22GOxZs0a7NixA7FYDC+//DJmzZrV3/tGREREAyw7I7CwRKBsISoEkEiz0OBk4bgO3cx8UW2fCPRqqj3vkQvF7iATgaEukgUAELQK9cmUgT1pLiyWyksvvYRvfetbGDt2LBRFwWOPPdbjfV544QUcccQR8Pv9mDx5MlasWDHg+0nulzsjMBcLge62O2K1Bg357Nbee1gIdB1ZEOoqEVhlF474fu0G4Xj3hV15POV25FwGYCUCszMCKzUVX+yKAQC+3B1DpdUaNHdGIAAIRWEhkIhcq1eFQCIiIioPdmvQAmcEBr3Z5GA0xS+6TibbgoZ8GgLejonPWqs42MKFYsdLGKa9UBjsJr0bsJ7HhimwnW3kSiYajeKwww7DsmXLCtp+8+bNmDNnDk444QRs3LgRl1xyCc4///yC5qXT0NbaRSKwmoVAV2u2E4F+DAtljmUzZ/q6juy40NWMwCq7NSiPrRuEeyzsWglPHk/HM4SACUBVsoW+kKaixXrtbY2mEfJklstj7TpsKBAwWAckIpcqekbgsGHDOp03oigKAoEAJk+ejB/+8Ic455xz+mUHiYiIaOBEikwEqqqCCp+GWMrgnECHa45mEgV17dqCStVBL75oiXOh2AWa0zpi1nM12E3RXrYGBYDNbQlMq6uExjmBg2727NmYPXt2wdsvX74ckyZNwtKlSwEABx54IF5++WXcdNNNaGxsHKjdpDLQEuu+NWgLi0eutMuaEVgXyrYGZSLQXUxT2J+xq4M9zAhka1BX6KmwK0/AiKYM6IbZaftQcgZDZIqBea1BPRparNfetngaQevzc6STVvtMBBKRWxX9zrR48WKoqoo5c+bgmmuuwTXXXIM5c+ZAVVXMnz8f++23Hy666CL8z//8z0DsLxEREfWjbGvQwmYEAkCFLzsnkJyrOZpZsKir6LwQWGsvFHNx0el2ptJIWoX37hKBmqrA7818vG9OpNCqs1jvBuvXr8fMmTPzrmtsbMT69eu7vE8ymUQ4HM670NAjF6ZrOSOwrOy2TuQZkTsjkO/VrhJN6bC6s3dZOOKMQHeRicCuW4NmC74s7jqbYRXyFEWxE4GVmmoXAgHATGUKgNF2rUEhsvcnInKbohOBL7/8Mq6//npceOGFedf/7ne/w7PPPos//elPOPTQQ/Hb3/4WF1xwQb/tKBEREfW/aNJqh1JgIhAAKnweACn7vuRMdiIw1EUhsIILxW6QNgW2RJNIWzNMgj08VwM+Dcl0ppVoS9pAnbfoj/s0yJqamjB69Oi860aPHo1wOIx4PI5gMNjhPkuWLME111wzWLtIDtUSzyxatp8RKAuDYb6+u1KztRg9POTnjECXku28fZoKv6fz8+9l4SjCGYGuYM8I7KI1qFdTEfRqiKcNtCV0uwU/OU8m0Wcl/qzP1yFNwx5rPisAmNbzMtouEagqmc/mRERuVHQi8JlnnulwxioAnHjiifYci1NOOQWffPJJ3/eOiIiIBlS0yNagQDYRGGMi0NF2R2VrMX+nt9uJEbaOc7Q9aR07cubNBH3dp3dle1BTN7EjxWNbrhYtWoTW1lb7snXr1lLvEpVAq50IzF9wruGJHq6VSBuIWgnwukofhlmFwGYWAl0ld55cZ6N1gGxr0DYWAl2hp0QgkC3u8rXX2UyRmfUH5LQGzZkRCABp63mZMEVeK1BNUZAUHduFEhG5QdGFwLq6Ojz55JMdrn/yySdRV1cHAIhGo6iqqur73hEREdGAku09Qz0UF3LJoiETgc62xy4Edr5gIReKW7hY4Wi7UmlErcUnn0ftceaMnCGo6AI7UmkkTS5WOF19fT22b9+ed9327dtRXV3daRoQAPx+P6qrq/MuNPTIGYDtF6bZGtS95Ek8Pk1Fld9jt/few9agrmKnxwooGrGNpDvIgm1XrV6B7DFlcdfZdCEgS3uy9WdQURCJZ49bPJp9/8xNBaqKghQTgUTkUkX3Crryyitx0UUX4fnnn8fXvvY1AMAbb7yBp59+GsuXLwcArFmzBscff3z/7ikRERH1u74kAuNpfsl1soITgVwodixDCGxNpKAamQWHntqCAtlEIAyBiGGgNW1glL/oc/9oEDU0NODpp5/Ou27NmjVoaGgo0R6RW9iJwAoWAsvF7ki2rbeiKBhmncyzJ5qGEKLLdBk5S5tMj3XRRhIAKv2ZY8vWoO4gWy1XB7s+prLwG07wtdfJDAhAWK1BrSKfSOef4BqOplFRpSJmmojqBmo8mc/XGsBCIBG5VtGFwAsuuABTpkzBbbfdhj//+c8AgP333x8vvvgijj76aADAz3/+8/7dSyIiIhoQMtVX2YtCIBOBzibbiA3vakag1Uquha1BHWtP2kCLbkDVZSGw5+SubB2aShkwTGCPbmCUv+uz16n/RSIRfPzxx/bPmzdvxsaNG1FXV4cJEyZg0aJF+OKLL3DfffcBAC688ELcdtttuPzyy3Huuedi3bp1eOihh7Bq1apS/RPIBQxT2KmTGiYCy8ZuOR+wMvMeLWcEpgwT0ZRR1Oc1Kp1sa9Cu338rZXqMiUBXsFuDdpsIzNzGRKCz6aaAomQ+W8sZgXoi/3ttazSFUK0vUwjMSQRqioIUu20QkUsV9SkynU7jxz/+Ma688kr88Y9/HKh9IiIiokEi2xFVFNMa1Go9yBmBziZbgw7rohAoF4rDXCh2rN1pHSlTwEhnFhwqClgAlsXCeMpAQFPRlEhh/1BgQPeT8r355ps44YQT7J8XLlwIAJg3bx5WrFiBbdu2YcuWLfbtkyZNwqpVq3DppZfilltuwbhx43DXXXehsbFx0Ped3CP3tbt9ITA3lWKaAqrKFJlbyDT/8MpMmj/o1eD3qEjqJvZEUywEuoTdRrKb9Fi2NSg/h7lBIe1eq+3WoDymTpY2BVRFgSEEYlZRLx3P/17bEk0h5AlgZ7p9a1AgLQRMkXkMIiI3KepTpNfrxZ/+9CdceeWVA7U/RERENIhkMa+oRKCfiUA3yLYG7SIRaM8I5NwhJxJC4PNEChWaii+tgn2wgIJ9wCrUJ1IGKjUVzbqBqGEgpBVe7Ke+mTFjBoToum3UihUrOr3PW2+9NYB7ReVGpv1CPg3edrNDZWFQiEzaqH2hkJxLtgaVaX5FUVAX8mFbawJ7YimMr6so5e5RgWShvqqbRH6Vn/Pk3KSYRGA4zmPqZElTQAMQyynwyZmAmqrAMAVaI2mErPfWiJH9zisLiLoQ8LEQSEQuU/TAkLlz5+Kxxx4bgF0hIiKiwSaLecXMCGQi0B329FAIlAvDbA3qTK26gT1pHdUeDfFU5nlaSCJQzgiMp3SENBUxw0RLmkV7onLTYhUaOivy+T0aAt7MV/1Wvsa7SmdtvYdV+PJuI+cLF5AIlK1BIwm925NHyBns4m43cx+ZCHSHNEyoimLPBwyoCtoimWO214jMyRYt0ZR9El1ea1AAhgB0PmWJyIWK7ivxla98Bddeey3+9re/Ydq0aQiFQnm3//SnP+23nSMiIqKBk9JNpKwvNrK4VwiZSoqlWFxwqkTaQNQ6Pj0VAjlDynlMIfBRNImYYaLe70XMSgQGCkgEyudnImVAVRQIATSndewV6Pz/AyJyJ/naXVPR9Wt8Ip3ka7zL7LJmBNZVZo+rfB/fE2Mh0C3aCkiPyW4cuimQ1E0EvEzuO1m2uNtNa9CctszkXGkT0JTMSXcAUKlpaIlm0th7j67Elh1RtERTmGwlAtvPCDSFCZPFeyJyoaILgXfffTdqa2uxYcMGbNiwIe82RVFYCCQiInKJaDKb6Av5ezMjkIVAp5KpAY+q2GcntydbgyZ1E4m0wQUoB/komsCmaBxjrJZi8WThicCgLzsjEABCHgXbkmkcVMlZJkTlpMUqCtV0kTiqCXqxPcxCoNvsthajR4T89nVy1m9zlMfSLWRryO7SYyGfB4pitfBN6Pwc5mC6Ydpz1bv6XA1kjzfbvTpb2jShQkFEt06I1VS0WCdh7D26Ei+9sx1p3YR8FW4/IzCTCGQhkIjcp+hC4ObNmwdiP4iIiGiQRa3Wnn6PCo9WeLfw7IxAfsl1KlkIHBbyQemi+FPp92TnYMTTXIByiG3JFN6JxFHj1RC0npcJq6gXLKBgb7cGTWbPcg7rBtp0AzXeoj/6E5FDyTZ1tcEu5sBa17MQ6C7NnbT1rrNO3NnD1qCuYc+T6yY9pqoKKn0etCV1tCXSGFnl73JbKq1Izneeqm5SnjIBykKgc5lCQBeZgp6c/RfSVLRYr68jawMI+jJt+TWr/2dEz578qikKDAi2BiUiVyp6RiARERGVh97MBwSYCHSDzmYMtacoCucEOkxrWsdbrTGYQmBYTtFOtgYNFtIa1Ho+J6xCf0BVEDdMtOh8vhKVk9ZuZgQC2QIEC4HusttKpQzPaQ1qJwLZGtQ1ZBvJ7opGQM6cQJ5c52gy4Rn0avB5ul5GlYlAtgZ1LkMABjJdMmTSr9Kj2YnA2pAPNdbrr2JV+9rPCDSFgMFEIBG5UK9OC/7888/xxBNPYMuWLUil8j+M3njjjf2yY0RERDSw5KJDMW1BAaDCKkbIRCE5j5wj1NV8QKk26EVzNMWFYgdImiY2tsWwO61j73YJn2JagwZyZgQCmYKvqgC7UzomBpk2ICoX8gSOmorOCw2cA+s+Qohsa9DKnNag1hxIJgLdoy0uZwR2/74t5wRGmCBztGzCs/vjWcVEoOPpQsAUgFcBIlaBL6SqCFvfnWorfagN+dDUHIdpff7OLQQqigIBtgYlIncquhC4du1a/Nu//Rv22WcffPjhhzj44IPx6aefQgiBI444YiD2kYiIiAZAzCrkyYRfoSqs7eNMBDqWTBQM66EQWG0nArm4WEqmEHivLY4t8RTGBTq2c7UTgQUU7dvPCAQyZzo3JdPQTQGPyjmBROWgp0QgC4HuE0sZSKQzC865J/JkZwTyvdotZCKwu9agQDYR2MZEoKPZhcAeEp6yUBjm665jyTSfpqh2y0+vKSAEoChATUWmEAgARlIHPEDUyP/OK6CwEEhErlR0a9BFixbhF7/4Bd555x0EAgH86U9/wtatW3H88cfju9/97kDsIxEREQ0AOeOvssjWoPaMQCYCHauQ1qAAUGslSVq4YFFSn8ST+DCawGi/F95OCnVxe0Zg8YlAIDP7JGwY2JnmcSYqFy0sBJYdeRJPwKva3RcAoE4mAnnSjmvIwlFVD4lAmSBjItDZZGvQngq7TAQ6ny4EBDKL4TLppxqZol5NyAdVVVBjfX9KxTOfpSM5iUAAUCBgsA5IRC5UdCHwgw8+wNlnnw0A8Hg8iMfjqKysxLXXXov/+q//6vcdJCIiooERKaLdYC57RmCSiUCnknOEZDuxrsiFYp65XDpNyTT+EY6h0qOiQuv8o3m8FzMCcxOBfjXzuG+0RrE9yWNNVA5kga+2y9agTKa4jWwLOjzkz0uGDwtljnFzlMfSDRJpAyk9UzjosXBkvWe3caaco2UTgd1/Z5K3pwwTiTS/JzmRAViJQCVb4LOS2DIJWGvNCExY36di7QqBAFuDEpE7FV0IDIVC9lzAMWPG4F//+pd9265du/pvz4iIiGhAydaglZwRWHaarVTB8MqeZwQC2VlTNLjadANvhaPQhUCdt+vFpd7MCEzrJvSchYu9/F7EDROvtkbwZYKpEiK3a431kAisYCLQbXZ38d4t24TuiaUguPjseDINpihAZQ/t9+0ZgWwN6mjyhIqeCrshnweyhh9mcdeRDCFgAlCVbMtPOQtQFgBrrJMv4m2ZYxg1TJg5r71CZB6HiMhtCi4EXnvttYhGozjqqKPw8ssvAwBOOeUU/PznP8f//b//F+eeey6OOuqoAdtRIiIi6l9y0aHYGYEha9EikTZhmPwS5ESyNWhdD61B2TqudFKmibfCMexK6xjj73phSQjRqxmBQH57UEVRsFfAh5Qp8FprFFtZDCRyNTsRGOz8dV6+vrfE+Vx3i67aest0v2EKe/YcOZcsAFX6PVB7mMvLGYHuIJ93PbV6VVXFLu6yPagzGVYRTwUQsZK7aetY2YlA67+RtsxrsgAQzzm5TlMyn+OJiNym4ELgNddcg2g0ihtvvBHTp0+3rzvxxBPx4IMPYu+998bdd989YDtKRERE/UvOCAwVOyMwp9AQZ9sbR5KtQet6ag1q3c4ZgYNLCIH3I3F8Fk9inN8HVel6oTBtCLvgXsiMQI+mwqtlHi+3ECiN8XthCoHXWyL4LJ7s5b+AiEqtlTMCy84uqzVoXcifd33Aq9mfvfZEWdh1OlkAqg50nx4DchKBLBo5mp0ILOCYym3YltmZZJJPURR7RmAqahUCK/Nbg4YjKfisz+iRvEKgghRPhiUiFyp45U+2oNhnn33s60KhEJYvX97/e0VEREQDLmq1QQkV2RrU71GhKoApgFhStxcxyDnsRGDBrUG5sDiYNsdTeD+SwCifB94e0gJyPqCCbNvPngR8HqTj6bw5gblG+73YmUrj9ZYoDAHsU+HvdDsicqakbtgn4tR0OSPQKgSy9bNryNagIzp57x5W4UMsFUdzLIW9ERrsXaMiyAJQT+mx3G3YGtTZ7BmBPbQGBbLHlIlAZ8rM9pPFvcz7aNyavzrMbg2a+W9bLI2QpiKlG3bREABURUGKrUGJyIWKmhGodHO2MhEREblLbxOBiqLY7USjXRQaqHQMU9iFvR4TgUGetTyYooaBDyNxvBWOIqSpCHl6LuzJ+YABn9ZtcjCXLBjGu1lYHOnzwqcqeKM1go+iCc6dInIRmfJTFKCqi/fwGqtlaFtSh8nkgit019ZbXscTd5zPTgSyaFQ2wvHCU57yuPOYOpMpAAUCuhBIWO+NsgWoTAJWBb1QlUxL0ID12VvOEwQADWAikIhcqaiVv/3226/HYmBzc3OfdoiIiIgGRzTVuxmBAFDh19CW1O1iIjlHazwN+d10WA8zAmsr5AwpFgIHUmtax5ZECp/EkwinDVR7NAwv8HkXTxU+H1CS23bWGjTXcJ8He9I63gxHYQiB/UMBnvhH5AIy5Vcd8HY5g0ye6CFEZkG6q+QgOceuSKY16PDKjilt+X7eHOX7tdPZ6bECEoGV1oxgtgZ1tmwisOdjKo+7vA85iy4EBIConv2M3NaaAJCdDaiqCqpDPrREUvBDFgLbtwbljEAicp+iVv6uueYa1NTUDNS+EBER0SDKtgYtvhCYKR4mEWMi0HGarRlD1QEPvFr3zR84Q2rgCCGwK61jSzyFT+NJRA0Tw7wa9g76iiq2xaxie7CIgr1MBPZUCASAYV4PVOj4ezgGXQhMqQwWnDwkotKQr9m13RT3fB4VQa+GeNpAazzNQqALyETg8E5ag9ZZx48zAp2vmHlylTIRyBPrHK2YuY9VAZkI5GdrJzIgAKHYM/8qVBVh6wSL2pzX3lqrEOixzq7Mbw0KpIWAKQQ/MxORqxS18nfmmWdi1KhRA7UvRERENIhkmq+yyBmBABC0Cg2xFBcunEamBTprLdaeXBhujadhmqLLZAkVzhQC21NpfBJL4otEGilTYLhPw2h/7xbhZWvQiiIK9vL52dWMwPZqvB6oioF/tMVhCuDgKhYDiZysxUoE1vTQerAm6LULgeR8ckbg8E7ev+1EIFuDOl4xrUHlnO1Iks9RJ7OLuwUcUzsRGOd3JCfSTQFFEYgamQJfhaogYhX7anJee+WfNWu7SLtEoC4y7UV9/LxMRC5S8IoC2wQRERGVl4hVCKzoRWtQ2U6UiUDnkYnAggqBua3jknqPi8rUvc8TKXwcTWBbKg0hBEb6vAj2kMrsiUwEBoppDWo9PwstBAJAlUeDAPDPWAITgj7Ueot/XSCiwSELe4UUApvCCRYCXUAIkZMI7NgaVM78ZSLQ+WRLyKoCWoNWc0agKxTT7pWJQGdLm5kUX8TIPOf8ioIIMnMBPTmf2WtD1vtrWgDe/BmBKgBDALoAev62RUTkHAV/wxeCg1CJiIjKiSzi9aY1aIVVlOCMQOfZbS0S1oU6LiS25/do2dZxsTQLgX3wWTyJ11uiMCEwyueBX+1bAVCS7T2LSQRmW4MW9/wMqAoiemZ2ChE5V0sRhUCA7Z/doC2pI2UlTrpNBLIQ6HjFtJGUrUEjCR1CCJ6A70CmKeyTJwtKBAZZ3HWypCmgAYjomddbrxX0q23Xkln+LFIG4FUQ1fMTgaYwYXCdnIhcpuAVCtM0+70t6EsvvYRvfetbGDt2LBRFwWOPPZZ3uxACixcvxpgxYxAMBjFz5kx89NFHeds0NzfjrLPOQnV1NWpra3HeeechEonkbfP222/j2GOPRSAQwPjx43HDDTd02JeHH34YBxxwAAKBAA455BA8/fTTRe8LERGRm2RbgzIRWE722IXAwop6csZUS5yLi731RSKFN1uj8KjAXgFfvxUBgdwZgYUnAmUhULYVJaLyUsiMQCC7aM3Xd+eTbUFDPg0Bb8fX+2EyEcjWoI4n20gWkgiUn8F1UyCZU2gg52hL6pD1nkKOqUwEhpkIdKQ0TKiKYs/881itP9sXAmVrUD2R+SzdfkagYbUGJSJyk/5bpeiFaDSKww47DMuWLev09htuuAG//e1vsXz5crz22msIhUJobGxEIpGwtznrrLPw3nvvYc2aNXjqqafw0ksv4Uc/+pF9ezgcxqxZszBx4kRs2LABv/nNb3D11VfjzjvvtLd55ZVX8L3vfQ/nnXce3nrrLcydOxdz587Fu+++W9S+EBERuYk8uzXUixmBFVahIcoZgY5TTCIQYGKkr3Yk03gzHIUJYKSv/xOVvZoR6JeJQBYCicpRmInAsiPbenfWFhQAhlkn9zAR6HzFzAgM+TyQIUAmyJxJvt76PSr8np6/M8liYZjH05HSJqApQES2+rQK8LXtktjy55R1/CM5rUE1RYGBTHtQIiI3KWkhcPbs2bj++uvx7W9/u8NtQgjcfPPNuOKKK3Dqqafi0EMPxX333Ycvv/zSTg5+8MEHWL16Ne666y5Mnz4dxxxzDG699VY88MAD+PLLLwEA999/P1KpFO655x4cdNBBOPPMM/HTn/4UN954o/133XLLLTj55JNx2WWX4cADD8R1112HI444ArfddlvB+0JEROQmumHaZx6HejEjUBYCi5lBRoOj2ESgXChuiXGhuFi7UzreaI0iYZgY4x+Ytqp2InCAZwQSkXu0WKkwFgLLx66IfO/ufOKUvH4P36sdLztPrufPBaqqoNJ6z46w3b4j2cezwPb58riH+brrSGnThAoFESvhJ1JWIbCL1qAJ6zU3NxGoATCFYGtQInKdkhYCu7N582Y0NTVh5syZ9nU1NTWYPn061q9fDwBYv349amtrceSRR9rbzJw5E6qq4rXXXrO3Oe644+DzZV/UGxsbsWnTJuzZs8feJvfvkdvIv6eQfelMMplEOBzOuxARETlBNKdA0LsZgZn7RNl60HGYCBwcrWkdb7RG0KLrGDtARUAgW8wL9mJGYJyJXaKyZLcGDXZeNJLk6zsXpJ1PJv1GVHZRCLRag7bEUjBMLj47WTGtQYHsnMA2tpJ0pHBcznws7HhWBTgj0KlMIaCLTGtPOfPPsFp/DuuiNWg80rEQqCgKBMDWoETkOo4tBDY1NQEARo8enXf96NGj7duampo6zC30eDyoq6vL26azx8j9O7raJvf2nvalM0uWLEFNTY19GT9+fA//aiIiosEh5wP6NBU+T/EfB0JWoSHGQoPjyMXE4V2kCtqTM6ZYCCxcRDfwZjiGXSkD4wM+KLKv1wCI92JGoNyWrUGJylNLvLCESk0wsyDN13fn2x3JtAbtKhFYaxUCTcHCrtMV0xoUyM4JjLBw5EhFJwKt7VjYdR5DAAYEVEWxW32mrUJv+9agshAob88tBAKAgMJCIBG5jmMLgeVg0aJFaG1ttS9bt24t9S4REREByBYCK3oxHxAAKqw2RlEWGhxHtgYdVmAhkInA4sQME2+2RvFlMoXxQS/UASwCAr2bERjgjECismYnAiu6X5iWxSO+vjufbA3a1YxAn0dFlfU+0BzjnECnMkyBNuszdtGJQLYGdSRZeC+k1SuQkwhM6jCZ3nUUXQiYItPaU7YGTUSt99N2icCAT0PAp0HRM8cwahgQOYU/BYIzAonIdRxbCKyvrwcAbN++Pe/67du327fV19djx44debfruo7m5ua8bTp7jNy/o6ttcm/vaV864/f7UV1dnXchIiJyAlnA6818QAAIWYWGGBctHEUIYbcGLTwRmG03Rt1Lmib+3hrFlkQK4wM+aANcBAR6OyOQMzyJylmrNbOIMwLLRyFpfnmCjzzhh5wnd85fwYVAJgIdrdiEpywYCgFE2TnFUeRcP1VRELUSgTHrJIz2hUDASgmmMwVDXQDJdoVdJgKJyG0cWwicNGkS6uvrsXbtWvu6cDiM1157DQ0NDQCAhoYGtLS0YMOGDfY269atg2mamD59ur3NSy+9hHQ6++VnzZo12H///TFs2DB7m9y/R24j/55C9oWIiMhNZCKwshfzAQEgaBUQYyw0OEo8bSBpzbzoqr1Ye3KhuCXGheLupE2BjeEYNseTGB/wwTMIRUAgZ0ZgUa1BM8/POGd4EpUdIUTBicBqFgJdY3c00xp0eBczAoFsIbCZhUDHkukxv0eF31PY+7YsHEV4cp0j2a1BCyzs+j0qfJpq3ZfH1El0ISCQWQiXrT7ljMD2rUEBoCbkBQxhL5zntgcVAjBYCCQilylpITASiWDjxo3YuHEjAGDz5s3YuHEjtmzZAkVRcMkll+D666/HE088gXfeeQdnn302xo4di7lz5wIADjzwQJx88sm44IIL8Prrr+Nvf/sbFixYgDPPPBNjx44FAHz/+9+Hz+fDeeedh/feew8PPvggbrnlFixcuNDej5/97GdYvXo1li5dig8//BBXX3013nzzTSxYsAAACtoXIiIiN4n0sTUoZwQ6027rrFafR0VFgYUjJkZ6ZgiBt9ti2BRNYGzAC686OEVAIFvMCxbTGtSeEcjnJ1G5iaUM6FYqoeBEIE/0cDz5/j081HlrUACoq+CJO05X7Dw5IHtSHmfKOVM4XlwiUFGUbHtQHlNHMZD5TK8pCiLWiZPQTVT4PfB5O35vqgn5oADwWfU+mSIEAE0BUqbZ4T5ERE7WuxhAP3nzzTdxwgkn2D/L4ty8efOwYsUKXH755YhGo/jRj36ElpYWHHPMMVi9ejUCgYB9n/vvvx8LFizAiSeeCFVVcfrpp+O3v/2tfXtNTQ2effZZzJ8/H9OmTcOIESOwePFi/OhHP7K3Ofroo7Fy5UpcccUV+M///E985StfwWOPPYaDDz7Y3qaQfSEiInILWcDrbSKQMwKdKbe1mFJgYk0mSlgI7FzUMLApksAH0TjG+L3wq4N3Hp0QAvFU8a1BZSEwmTZhmgLqIBYuiWhgtViv1V5NQbCThctcshDYltRhmAIaXwscS7b17i7NbycC2crbsew2kgWmxwDOCHS6bCKw8OJuddCL3dGU/f8DOYMhBEwAujCRstJ8StpEbU2w0+1lu1CPCUDLzhUEAE1REOeQQCJymZIWAmfMmJE3bLU9RVFw7bXX4tprr+1ym7q6OqxcubLbv+fQQw/FX//61263+e53v4vvfve7fdoXIiIit4gkOSOwHMnFwWEVhbUFBZgI7IohBLbEU3g/EsfutI7Rfg+C2uA200imTciPyhVFFO1z24gm0kZR9yUiZ8vOB+z5hA/5+i5EJplSW8R7Aw0e0xT2iTwjKrtLBHJGoNPJ1qBVRRSNOCPQ2eQxrQ4W/llKJgLD/GztKIbVzjNuFfQUANBFp/MBgWy7UNUQgKYgllMI9KkKWnUdQoiCT74kIio1x84IJCIiooET7WNrUNl2kolAZ2mWrcW6mTHUXm0wsy1bjWXtTKXx8p4I/ranDSlhYu+gDyGtd8+VvpCFdlXJtHstlNej2skfzgkkKi8t8czrfE0Bi9I+j2qnBnmyh3OFE2kYVrvXYaGuC0icEeh8diKwiNagsmjEGYHOJBOBxRR3s61BeUydRLfOrotaST6fyBQDO5sPCGRagwIA0pkCYG4iMKCqSAiBpMlUIBG5B08PJiIiGoJkgaGvrUHjLAQ6SnMBrcXaq7Fag8bTBpK6Ab9n8AteThE1DHwUTeCjaBIpYWJswAvfILYCbU8W8Sr8nqLONlYUBQGfhmhCR4LPUaKyIhMmhab7aoJexNMGC4EOtss6iacq4On2PVi+t+9ha1DHyhaNik+PsWjkTPaMwCKOqWwjGuaMQEcxhACgIGLN+vOYmbmBXSYCretFygBCWt6MQJ+qoC1lIG6aCAxyxxAiot7iqxUREdEQZLcG7WUhULYUTRkmUjoHpTtFb1qDVvk9kDWmobpQrJsCm2NJvLC7DW+3xVHpUTEx6C9pERAA4sni5wNKck6gnDFIROWhxW4NWlg6he2fna+QtqBA9r2diUDnyhaNimkNmtmWrUGdyZ4R2IuUJ4u7zmIKQIFA1Er2qdZ32GE9tAbVreMYyfnO61MUpMxsm1EiIjdgIZCIiGgIivYxEZg7g4ypQOewW4MWkQhUVSW7UDwE24PuSun4W0sb/taSbQNa5ZBUpCziBXvxPJXPUSYCicqLLOjVshBYNnZHkgB6TvMPsxL8e4bge7VbtCWKnydXKYtGbA3qSPaMwCKKu0wEOpMuBARyWnxaLT97ag2ajmc+S+fOCFQUBVAUxEwWAonIPVgIJCIiGoKiVoGhwte7gofPo8JntUGJMnHkGHYisIhCIDB0F4p3ptJ4tSWCrYkUxvq9GOnzQi2iBedAi1nJ3WAvnqdBtu8lKkvydbrQdIps/zzUXt/dZFe0sJN46jgj0PHs9FhRiUA5I5DPUacxTWEXaIsp7sp5gjIhSs5gQABCQUTPfDY2rM/ZXbUGra7wZrqm2DMC8z9TqxCI6vycTUTuwUIgERHRECQTgb1tDQpkixMxFhoco7nAxcT2ZLKkZQilDHandLzREkWbYWBiwFfyNqCdka1BK3rxPLVbgzJhQFRWWuJsDVpu7DR/F4vRkjzJpzWehs52dI4kW0EWM09OtpFka1DniaZ0CJH5czHF3WxrUL7uOoluCihKtjWonui+EKiqCqorfIDVEjTa7nXXr6poSfN7MBG5h/NWPIiIiGjARa0zIHvbGhQAQnYhkAsXTiELgT21F2uveogtFO9J63ijNYI9uo5xfm+mvY8D2YnAXswIlPdha1Ci8mK3Bq1gIbBc7I5mWoMOD3U/IzC3HWwLj6cjyURgVa+KRjqErDqRI4St4qzPoyLgLfyzmPxcHWZx11HSpoCqKHZrUEMWArv53lQb8kJJd14I9KkK2gwDusnnLRG5AwuBREREQ1Ak2bfWoEA2pSSLilR6vS0E1lZkth8KC4utaR1vtEaxO61jfMDn2CIgkDMj0Nf7RCALgUTlRc5yLTYRGB4Cr+9utTtaWCLQo6n28dzD9qCOJFtBFjUj0Po8rZsCSZ1JTyfpzXxAgIlAp0qaAhqyLT4V3YTfq3Y7i7sm5APSmUJf+0JgQFWRNAUSnBNIRC7BQiAREdEQJFN8TASWj7Rh2omPoguBMjESK++FxYhu4I3WKHYkM0VAJ80D7EzcTgT2oTUoC4FEZaW3icCh1PrZbXZHMonAQt67OSfQ2dp6MSMwlHOyTxsTZI5iFwKLKOwC2ePP4+ksaZhQFSVb0EubXbYFlWorfVD0zmcE+lQFSWEixlbNROQSLAQSERENQRGrwNCXGYEV1sJFlIUGR5CLvIqSTfgVaii0jotaRcBtqTTGB72OLwIC2fl+vWoNaj0/mQgkKi8t8UwBiDMCy8dua0bgiMruW4MCwDCrALynzE/ccSvZCrKY1qCqqtgn5kU419dRwvbMx94lApnEdpa0CWhK5sRAAFDSJob18LqbSQR23hpUUxQYAogzEUhELsFCIBER0RAUtRYaQr1oOShV2IkjLlo4gUwH1Aa90NTiilwyWVKurUFjhok3w1FsTaQwIeCD5oIiIJBN81X0omAvi4d8fhKVl2xr0MJO+GAh0PmKaeudTQTyeDqNECKbCCwyQcZWks6UTQQWVwhkItCZ0qYJFe0SgT287taGfPaMwKQpkG43D1ARChOBROQaLAQSERENMYYpEE/LRCBnBJaL3dHCW4u1V13GC8UJw8SG1ig+i6cwIeieIiAAxGQisBezPO3WoHx+EpUNwxRos14XCk0ElvPrezkwTIHmWGEzAgFgmJX4ZyLQeRJpE2kjUyQoJhEIZFv1R1g4cpSwVZiVhdpCyUJwPG0gzSKRI5hCQBeAqgAR65goemGtQaFni3+xdu1BvSrQkuZnbSJyBxYCiYiIhpjcmX59aQ3KGYHOsifau/mAQHZGYLnNkEqaJjaEo/g0nsT4gA8eFxUBgb7NCJTFQ7YGJSofbYk0hLUeydag5aEllrKP6bAC2nrL9/g9nBHoOLJopCrZz8iFqpSJQLYGdZRwvHetQXNnsDMV6AxpIWBAQAUQNWRrUNFjIbAm5IMC5MwJzC/sBlQVYV2HEKKTexMROQsLgUREREOMTPBpqgK/p/cfBTgj0Fma+5AIlAvF5TTLJGWaeCscxSexJPYKeOEtsl2qE/RlRmCAMwKJyo4s5lX4NPgKfP+Wr+9tCR2GyYVKp9kt23pXeOHVej6mw2RrUCYCHSfbFtQLpcgTj5gIdKZwL1u9ejTVLgaz3aszRA0TccOEouQE/ApsDQrAbg/afk6gT1UQMwUSfH8lIhdgIZCIiGiIiabkfECt6IWKXLKtaIxnLzvCbnvGUPdD7ztTa6UQymVGoG4K/CMcx0fRJMYGvPCp7vzI26cZgfYMTxYCicpFiz0fsPB0Su62XJB2nl2RzEk8wws8iaeugolAp2q10mPFtpHMvU+En6kdxZ4RWGQiEMi2h5WpQiqtiG4gLQRSso5nCsDoOREobxddFAL9qoKUaSJusgUsETmfO1dFiIiIqNei1iJDZR/aggLZQkOMhQZH2GMXAotfrKityLaOc3trG1MIvBeJ4cNoHPV+L/wuLQICfZsRKFOEcS4qEpUNmQgsphDo86iosF5D2B7UeZqt9+7hBZ7Ek00E8lg6jZ0I7E3RyC+TuzyuTiLbelYX8ZoryeIuj6kzRHQDEAoisi2oLqAAPSYCAz4Nfq8KJZ35fhRtPyNQUZAWAjHOgiQiF3DvyggRERH1ijzbuDcpo1whq/UgC4HO0JdEoFxUNkzh6rPRhRDYFInj3UgCo3weBAtos+ZUpimQtM4+7s1zNcAZgURlp6UXhcDc7VkIdJ7dEasQ2EMqRZIn+zAR6DzhRO8TgZwR6Ex2a9BeHFNZPAyzEOgIzboBv5aT6LM+Hw+r6vm1tybkA7qYEagoCiCAOAuBROQC7l0dISIiol6JWTMCQ30sBMqEgWw1SqW1JyZTBcXPCAx4NXteZIuLUwb/iiexMRLHMK+GkKf4FJ2TxHOeV4FeJAJzC4FuT3kSUYYs5MkUd6FkIdDNr+/lKnsST2Hv3bVsDepYfUkEckagM4Vz5j4WSxaEwzymJaebAi1pHQFVRdQq6EEX8GpKQSfb1YZ8Xc4IBABNUTokBYmInIiFQCIioiFGFu4q/X0rlMhCoiwsUmnJVMGwXhQCAfcnRj6LJ/FWawwhTUW1y4uAABC3nldeTYHXU/xH9qCV2BWAnSwkIncL9zIRWO3y1/dytlvOCKwsLM0vZwS2JXWkdL62O4mcBdeXopGbuzKUI/uY9qK4K+/TxkJgyUUNAwlTIKiqaJOtQdMmait9mURfD2orfYAsBOodv/f6VAV70vw+TETOx0IgERHRECMXGWRrz95iItBZsnOGelcIzJ0T6DbbkilsCMegKUCdt2//XztF3GpZFOxlctfvVSGXNuJ8jg66ZcuWYe+990YgEMD06dPx+uuvd7ntihUroChK3iUQCAzi3pJbtFjJb5kKK5TbT/QoZ/K9e0SBrUGrg16o1ou7/P+BnEGmx3rVGpSJQEeSx7QmWPwxtROBfN0tuYhhImGY8KtKNtGXNlFb4DiFmpAPit51ItCvZmYPpk124CAiZ2MhkIiIaIjpv9agmfvHOYOs5IQQdmvQviYC3dY6bldKxxutUeimiVH+4s/YdqqYVbAP9jK5qygK5wSWyIMPPoiFCxfiqquuwt///nccdthhaGxsxI4dO7q8T3V1NbZt22ZfPvvss0HcY3KLVs4ILDsyzV9oa1BNVexCcDMLgY7Sl9agVUyPOY4Qwi7i8Zi6myzeKTktPGUisBC1IR+QFnmPlcuvqkiZAnGTKW0icjYWAomIiIYYOxHYx9agTAQ6R1tSR9rIfEHtbSKwJpi5n5sWilvSOt5ojSCqmxhTRkVAINsatJDZJV2RhcA42/cOqhtvvBEXXHABzjnnHEyZMgXLly9HRUUF7rnnni7voygK6uvr7cvo0aMHcY/JLeSJGsW2HpSFQCZTnGdX1GoNWmAyBQCGWQn+Zs4JdBTZRrJXiUDrPm1sDeoY0ZQBGfCq6k1r0KCcEcjX3VLbk9bhtaLUEXtGYBGFwMpsIjDSSSHQpypImCbindxGROQkLAQSERENMVG7ENi3RCBnBDpHs5UoqPBpCHh7V+CVrUFb4u5YWIzqBjaEY9id0rFXwFvQjA83sROBvt4X7GVbUSYCB08qlcKGDRswc+ZM+zpVVTFz5kysX7++y/tFIhFMnDgR48ePx6mnnor33nuv278nmUwiHA7nXaj8yRM1apkILBt2W+8CF6SBbHpwT5TH00nsRGAvZgTarUGTPKZOIU+c8GoKAt7il06ziUAe01IyhUBzWkdAzRxDWchT0mYm6VeAmlDOjECj42dqTVEgBJgIJCLHYyGQiIhoiNm6JwYAGFHE2eedCeUkAoXgTIRSku3BhhU5NyqXmxaK44aJN8NRfJlIYXzQB7XMioBAdq5fb2cEAtkiItv3Dp5du3bBMIwOib7Ro0ejqamp0/vsv//+uOeee/D444/jD3/4A0zTxNFHH43PP/+8y79nyZIlqKmpsS/jx4/v138HORNbg5aXtGHaKc9i0vzD2BrUkcJWC8jetZHkjECnCee0eu3NyWbVMuXJY1pSMcNEzDAR0DLHMNsaVBScCKwJeaGku54RKEV1ft4mImdjIZCIiGgIEUJgw2d7AACHT6jt02PJloWmAJI6z4AsJZkILCZR0J5MmLQ6fEZgyjTx93AUn8VTGBfwQSvDIiCQbefZ2xmBQE5rULbvdbSGhgacffbZmDp1Ko4//nj8+c9/xsiRI/G73/2uy/ssWrQIra2t9mXr1q2DuMdUKnYisIKFwHIgZ/uqCuy5f4XIJgJZCHSS7Dy54k/gqcopGvHkOmeQrV57k/AEsgVhtgYtrahhImGaHRKBKGZGYKUP0LueEQhk2oO2shBIRA7Xt55gRERE5CpbmmPYFUnBp6k4eK+aPj1WMKcFZSxl9LolJfVdvyQCK5y9UJwyTXyRSOOjWAJNyTT2CnjteR/lKG61Bu3LjEBZRGRr0MEzYsQIaJqG7du3512/fft21NfXF/QYXq8Xhx9+OD7++OMut/H7/fD7+5bqJvfpdSLQ4a/vQ9XuSPa9Wyvi/WyYLAQyEegoMvnVl9aguimQ1E1+pnYAu9VrLwq7QH5xl0onYhgQgH3ioJwRqBRRCKyu8EG1EoExw4QpRIduJH5VRatuQAhRduMKiKh8MBFIREQ0hLz5aSYNePBe1X1eZNDU7MwMOXeQSsOeMVREa7H25MJyi8MSgQnDxMexBNbtDuNvLW1o0w1MCPrgV8v7Y6ycvdmXGYEyEchC4ODx+XyYNm0a1q5da19nmibWrl2LhoaGgh7DMAy88847GDNmzEDtJrlQSjcRs57LtcHiXuuZCHSm3b1M89dVMBHoRDL5VdWLwlHIl70PC0fOEO7DzMfc+4X5ultS4bQBDdnCnD3jr4gZgZqqoMr63iyQKQa251cVJEyBuMlELxE5FxOBREREQ8ibVlvQI/eu65fHC/k8SKRT9uIklYYsBNb1oRAo25K1OGTBImaY2BpP4uNYEs1pHSFNxfgybgXaXv/MCMzcN85C/aBauHAh5s2bhyOPPBJf+9rXcPPNNyMajeKcc84BAJx99tnYa6+9sGTJEgDAtddei6OOOgqTJ09GS0sLfvOb3+Czzz7D+eefX8p/BjmMLOIpSvGFhhqXtH4eanZHkwCKf++WicBmHk/H0I1sob43MwJVVUGl34NIUkckqWNkFRPfpWa3Bu3F8QQ6tntlSmzwCSGwK63b8wFNIezWoJopUNVJm+2kaSJhCtR48k/EGxbyYaduAh4VUcNEZbvb/aqKFj2NuGGiQivvkxWJyL1YCCQiIhpC/m4VAqdNHNYvj1fh17A7CkQ5g6ykZCFwWD8kAkt95nJUN7AlnsTH8SRa0gaqPBomBIdOAVDq3xmBLNQPpjPOOAM7d+7E4sWL0dTUhKlTp2L16tUYPXo0AGDLli1QcxKte/bswQUXXICmpiYMGzYM06ZNwyuvvIIpU6aU6p9ADtQaz7zOV/k9UItsiyxf39uSOgxTFNWGkgZONhFYXNGnLpQ5nkwEOkduiq83iUAA2UIgE4GOYM98DPbueMoCom4KxNMGKnxcfh1scTNT+JPzAeOmCZnXq/FqHdp7AsCulI6YYaJaU/OKtzUha06gp/M5gV5VgS4EYqaJ4QPyryEi6ju+ExEREQ0RrfE0/rmjDQBwxIT+KQTKVkayjSGVRn+0Bq21W4MOzsKiKQSSpkDCNO3/htMGNieSCKcNVHs0TAz6Ov2SPhTYMwL7sHAUZGvQklmwYAEWLFjQ6W0vvPBC3s833XQTbrrppkHYK3IzmQis7cUs2NyZguF4uk8njVD/ke/dI4pNBFr/DzSzEOgYso1khU+Dp5dpoKqAB03h7Gw6Ki27NWgvE4EVPg2aqsAwBdoSOguBJRA1DCRME8O8mWMYteYDwhCoC3V+AkZaANUeDQlTIKhlv4PUhnxQ0iZEQEPE6PpzdbyTIiERkVPwnYiIiGiI+PuWPRAC2Ht4Rb+1HJKFhhgTgSX1ZUscQN9ag8qF4mjKQNow4e3HtjbNaR1tuoGEKRDTDYR1AxHDREoIpE0TaQEICEAoqPGq2DvoG/ItlOwZgX1oDWonAlmoJ3I9Ob+1phfzqryaigqfhljKQCsLgY6RbQ1abCLQmhE4SCfuUM9kIrC3RSMAqJStJNnO2xHs1qC9nBGoKJl2r63xNNoSaYyuDvTn7lEBooYJXQh4rO8Usi1oV/MBdSGgKgIBVUPMMBHM+S6USQTG7cftjKYoaNP5mZuInIuFQCIioiFiw6eyLWj/zAcEchKBTByVzCc7I/iwqQ2aquCIPrR8zV3oaI2nMaLIVmVdEULgzdYotifTUBRAgwKfqsCrKgiqCqo9HvgUZcgX/trLzgjsfWtQWURkIpDI/bKJwN4tStcEvXYhkJxhl90atLjCrEyFxlIGEmkDAW/v3yeof8g2kr1tCwpkWoMCYGtQh5CJwL4c0+pgphDYGucxLYU23UDut4uoleRTdBO1nbzuxgwTIU1DjVfD54n8Ey1qK31QmqMQ6LoQ6FcUtLAQSEQO5ugJpldffTUUa2FIXg444AD79kQigfnz52P48OGorKzE6aefju3bt+c9xpYtWzBnzhxUVFRg1KhRuOyyy6Dr+W/CL7zwAo444gj4/X5MnjwZK1as6LAvy5Ytw957741AIIDp06fj9ddfH5B/MxER0UDZ0M/zAYFM2xuAMwJL6bGNXwIAjv3KiD4V7zRVsRc7+nuhOG0K1Ho17B30Y3zQh9F+L+q8HlR6NPhVlUXATsgUX0U/JAJZCCRyv1Z7XlXvC4G5j0Ol19u23tUBjz3nkalAZwgn+pYeA7IFpwgTgY7Q19agAFDlt+azst1rSexO6QjmzGTuKREYM0zUahrq/V6khci7rTbkzfQNRbag2J5fUxE1DKRN0entRESl5uhCIAAcdNBB2LZtm315+eWX7dsuvfRSPPnkk3j44Yfx4osv4ssvv8Rpp51m324YBubMmYNUKoVXXnkFv//977FixQosXrzY3mbz5s2YM2cOTjjhBGzcuBGXXHIJzj//fDzzzDP2Ng8++CAWLlyIq666Cn//+99x2GGHobGxETt27BicXwIREVEfpQ0TG7e2AACO3Lv/CoEhP2cElpIQAo+99QUA4NuH79Xnx5NJE9mCjkpHzgiU7Xd7Q943zkI9kevJ1+XaXhYaqlkIdJzdkUxr0OFFnsSjKArnBDpMtmjUD4lAFgIdIdsatG+JQCBbKKbBkzJNhA0DAa1jIVBJd54ITJgmRvk8qNY0aApg5BQDa0I+KNaMwYjedSIwZQrEupkhSERUSo4vBHo8HtTX19uXESNGAABaW1tx991348Ybb8Q3vvENTJs2Dffeey9eeeUVvPrqqwCAZ599Fu+//z7+8Ic/YOrUqZg9ezauu+46LFu2DKlU5gPz8uXLMWnSJCxduhQHHnggFixYgO985zu46aab7H248cYbccEFF+Ccc87BlClTsHz5clRUVOCee+4Z/F8IERFRL3ywLYx42kB1wIPJIyv77XGZCCytt7a2YEtzDBU+DSdNGd3nx6sNZr4Ut8a5sFhKad1E2sgsPvRlRmC2EMgFCSK3kwW83swIzL0fC4HOsdsq4vVmvm9dKHM890R5PJ0g2xq0L4nAzH3DTI85Qr8kAgNMBJZKxDCRMEwE1GzXkahs25kWHQqBphBQoKDG6lgStOYESrWVPiCd+TnWRWtQn6ogaQrEmQgkIodyfCHwo48+wtixY7HPPvvgrLPOwpYtWwAAGzZsQDqdxsyZM+1tDzjgAEyYMAHr168HAKxfvx6HHHIIRo/OLow1NjYiHA7jvffes7fJfQy5jXyMVCqFDRs25G2jqipmzpxpb9OVZDKJcDicdyEiIioF2Rb0iInDoKr914axgoWGknrcSgPOmjIaFb6+j37mQrEz5Cb4+pIIDPg4I5CoXPS1EFjL13dHSeoG2qyU0IgiZwQCyCYC2RrUEdoSfU+PcUags7T1Y7vXNh7TQRc1TKSEgL+T1qCK3rE1aNwqGlZ7NGuGuYZ4TsEvNxHYmu78c7WqKBBC5N2PiMhJHF0InD59OlasWIHVq1fjjjvuwObNm3Hssceira0NTU1N8Pl8qK2tzbvP6NGj0dTUBABoamrKKwLK2+Vt3W0TDocRj8exa9cuGIbR6TbyMbqyZMkS1NTU2Jfx48cX/TsgIiLqD29ahcAj+3E+IAC7+MRE4OBLGyaeensbAGBuP7QFBYAatgZ1BDkfMODT+lS4z50RKATPTiZyM1nAky2ci8UTPZxFtvT0qEqvEkcyRbiHrUEdQabH+pYIZGtQpxBC2CnPviQC5X3DfN0ddBHdQPuPvhErEaikTQxrdwJGzDRR7dEQ0jKzy0d6PYiZ2YJe0KfBY9X/wt1971W6niFIRFRqfT91fADNnj3b/vOhhx6K6dOnY+LEiXjooYcQDAZLuGeFWbRoERYuXGj/HA6HWQwkIqJBJ4TAhk8zhcBpE+v69bFD/kyhgTMCB9/LH+3C7mgKIyp9OGbyiH55TC4UO0OsH+YDAkDQen4apkBaN+Hz9u3xiKh0WqzkV59bg/JED0fYHckcz2EhX69O+BgW4oxAJ7HTY30oGjER6BzxtAHdau/YpxmBTASWzO60joCW/9raYhXwlLSJ6naJwJhhYt9gAIqSuU+NV8srJCqKgkqPigSAsN71916/qqKlm9uJiErJ0YnA9mpra7Hffvvh448/Rn19PVKpFFpaWvK22b59O+rr6wEA9fX12L59e4fb5W3dbVNdXY1gMIgRI0ZA07ROt5GP0RW/34/q6uq8CxER0WD7sjWBpnACmqrgsPE1/frYTASWzmMbM21Bv3noWHi0/vlIJ1vHMRFYWrLVbl/mAwLZRGDuYxKRO2VbgxbfRhLIJr55ooczyPmAw3sxHxAA6qzWoHvYGtQRsjMCe/++nZ0nx8/UpRaOZ46BR1UQ7MNJVLKtKOc+Di5DCLSkdQTU/O9HrfLztapAyzkBQwgBgUzxT6rUNPhUBamcVGC11/re203rT7+qIJw2YLITBxE5kKsKgZFIBP/6178wZswYTJs2DV6vF2vXrrVv37RpE7Zs2YKGhgYAQENDA9555x3s2LHD3mbNmjWorq7GlClT7G1yH0NuIx/D5/Nh2rRpeduYpom1a9fa2xARETnZm582AwAOGlvdL3PkcskZgTEWGQZVNKnj2fcyJymdOnVsvz0uE4HOELYWiPuaCFQVBX5v5uM+5wQSuVurtTDd50QgX98doTmaBAAM78V8QCCbCNzDE3ccQRZ6+jJPrlKmx9gatORyj6dMiPUGZwSWRkQ3kDBFh0Jgm5XUq/Lkf75OmgJ+RUVNzvXVHg1BTUUsp+hXa32PjpvdFAIVBQkhut2GiKhUHF0I/MUvfoEXX3wRn376KV555RV8+9vfhqZp+N73voeamhqcd955WLhwIZ5//nls2LAB55xzDhoaGnDUUUcBAGbNmoUpU6bgBz/4Af7xj3/gmWeewRVXXIH58+fD7/cDAC688EJ88sknuPzyy/Hhhx/i9ttvx0MPPYRLL73U3o+FCxfif/7nf/D73/8eH3zwAS666CJEo1Gcc845Jfm9EBERFWPDZ7ItaP/OBwSyiUAWAgfXs+83IZ42sPfwCkwdX9tvj1vLxIgjvPrhTgDA5LF97yYRkIsWfI4SuZYQAq3xzAkCvZ0RWM1CoKPI1qDDQ/5e3b8ulDmenBHoDNnWoL0/4c5uDZrkc7TUsvMB+3YCZTblyWM6mKKGiaQpEGjXdlnO/Ktpd2Js1DAR0tS8AqFXVVDn9eQV9IZZ/z8kgS5nb/s1FUnTRNxgIpCInMfRMwI///xzfO9738Pu3bsxcuRIHHPMMXj11VcxcuRIAMBNN90EVVVx+umnI5lMorGxEbfffrt9f03T8NRTT+Giiy5CQ0MDQqEQ5s2bh2uvvdbeZtKkSVi1ahUuvfRS3HLLLRg3bhzuuusuNDY22tucccYZ2LlzJxYvXoympiZMnToVq1evxujRowfvl0FERNRLshB4ZD/PBwSyMwKjPHt5UD321pcAgFOn7tWnM5Xbky3nWthqrGT2RJL4+0e7AQAnHNZ9G/pCBP0aWqNAgu17iVwrnjaQthYVmQgsD7tkIbC3icAKzgh0Epkgq+rDjECZHuOMwNLrj+MJZGdGylajNDgihgkhRIfvSAkhAAUY1q71fsw08ZWKALR224/wefBpPGn/PLLCC8CAUDIpwvYzCAHAoyjQTYGYYcDhS+5ENAQ5+lXpgQce6Pb2QCCAZcuWYdmyZV1uM3HiRDz99NPdPs6MGTPw1ltvdbvNggULsGDBgm63ISIicppIUscH28IAmAgsFzvbknj5410AgLmH79Wvj82F4tJ76Z3tMAWw317VGDcy1OfHk+1FmQgkci85t9WrKXZL7mLJ1/cwX98dwW4N2tsZgSHOCHQSmQisCfZHIlDvtIhBg0cW7qr7cDyB3NagfN0dTK1pHd52aUBDCKSsq0a0O6HGMAXqvB2PdZWmAQL287GuwgeYMUBVEDVMBLqY0a4oQNxkIpCInMfRrUGJiIiobzZuaYEpgL1qg6ivCfT748tEYIxpo0Hz1NtfwjAFDhtXg0kj+l4oysXWoKVlCoEX/tEEADhh6ph+ecyALAQmWQgkciv5mlzTh3lVshDYltRhcIGy5OzWoJW9aw2amwjsqkUdDQ4hhF0I7I9EYNoQSOqcL1ZK9ozAPiYC5TENM+U5aEwhsCutd5gPmDvrb2ROS+aUacKjKqj2dDzJpsqaE5iw3jOHVfqBdOZxIkbXn6s9ioKwzmNORM7DQiAREVEZs9uC7t3/aUAACFmJwNZ4msWjQfLYxkxb0P5OAwL5iUAuLA6+9z5twc7WBCr8Hkzff0S/PGbQeo4mmAgkci2ZCKzuZVtQIL+lKFOBpbfbaulZ18dEYFI3EU/z9b2UYinDLq73pXAUyplb1sbCUUllZwT2sTWo9bob4QkYgyZumIgZZoe2nVFZCNTNvBMwYtZ8wGpPx+XxSk1FUFXtImJtpQ+KVaSPGl0X6/2qgha+LhORA7EQSEREVMbe/KwZwMC0BQUyScP9RlcibQj8z0ufDMjfQVmbd0Xxj60t0FQF3zx0bL8/vkwEpg3Bdq8l8Pw/tgEAvn7QKPi8vWv/155MBLIQSORe8kSb2j4UAr2aipD1etDCQmDJ7bZag47o5YzACp8Gn9WWjnMCS0umx7yagoC390tsqqrktQel0pGF2P5qDQrwmA6WiGEiYZodEoF2gi9tYljOCRgxw8Rwrwc+teNzV1UUjPR5ETMzRb+akA9IZwq6/7+9+w5zo7r3x/+eUS/bq+1de90bbriATbEhtECcGBJKCGA7l95CSC4k+eUCvuQbkkAI5EIgpiYkBFPtJMSADQaDMbjggntZ29u8vWjVNTPn98dI2l17XXatlXZn36/n0aORVhod6exI58znnM/xKsduV9tkGQFNQ0jjzF4i6l0YCCQiIjIoVRPYVNYMoOcCgbIs4ScXjQYAvLjmAOpaQyd4Bp2KZZsrAQBnjchFXlr30okdj8NigiU6gpYnipOrxRfGxr0NAIDzE5QWFGi3RiBPQBH1WZ52qUFPBdeB7T3iqUFd3fstlyQJWS69Ppt8rM9UOljvB3BqqXtj4oFAzghMqUSlBrWZTbBFZ5pxJnZyeFUVAoDpiGMxFriTFIHMdgMwwppArvXY9ZxlNUGNZklJd1riMwIbjlOfNllCSBUIHGfWIBFRKjAQSEREZFC7q1vhDSlwWU0YU5jeY69z0bgCTCrOhD+s4k8f7+ux1+nvhBBYukkPBF4+JfGzAQH9xGKGQ+8ct/h5wiKZVn9dA1UTGDEwDcV5iVv70RFdxzPAGYFEfVZzQA8aZTq7N3ssJp2BwF4hEFbjs+6zuzkjEGi3TqCfMwJT6aU1BwAA54/JP+V9uaMzyFqDPEZTyROIzQg8tUAg0LZuJNO9JocnonZ6ors+9rsX0fSZfQBUISBJQEYn6wPGpJtMkCX9sWaTDIsW29+xv3etkoSQEAhwRiAR9TIMBBIRERnUxjJ9fcApg7Ngkk9thPLxSJKE+y7WZwX+/YsyVDYHeuy1+rMtFS042OCHw2LCReMKe+x1YulBm4/TwaXE0oTAx1v1tKDnTUrcbECAqUGJjKCFMwINJZYW1GqSkWbrfurB2DqBTUwNmjL7ar1YsbMGAHDzucNPeX+xVJKtnMWfMoGwii9K9QwNAzMdp7y/9Gidehjc7XFCCDREFDhMR5/qjgUCLZqAJTpLU18f0IS04wQC3WYTHLIpvk6gPTrTsPk4x6g+M1jEn0NE1FswEEhERGRQGw/27PqA7Z01IhezhucgrGp4cuWeHn+9/ig2G/DCcQVwncKJwxOJnShmCqPk2VnWjJqmIBxWE84Yk5fQfdut+v8KA4FEfVezn4FAI4mt6Zftsp5SKsnYOldcIzB1nltdCiH0ttmIfPcp74+pQVPvH+vK0OALozjbgfNGn3qbLM3BGYHJEtQEvOrR6wMCQGP0d8+Gtu9cv6oh02yCs5PAYYxDlpBuNsXTfDqig2tbTqJd7VMYCCSi3oWBQCIiIoPacEifETitpOcDgQDw0+iswDc3VmB/nTcpr9lfKKqGf2+tAgDM66G0oDGZ0RMWzUwNmjSrNlcDAGaNz4/P4EuU+BqBYZ6AIuqrEj0jkAM9Uiu+PuAppAUFgOxoatAmpgZNiRpPEO9EB2ndOvvUZwMCbTMCvZwRmBIhRcXi1aUA9Do1HydAdLLSme41aXyqhoDWeSCwOdoOdrb7m1/VkG89/uBKSZKQZzHDH03z6Tbp7WqPcvxAoF2W0azwOCai3oWBQCIiIgOq8QRR0RSALAGTizOT8pqnD87CBWMLoAng8RWcFZhIn+2rR703jGyXFeeMTOyMsSNxxkhyefxhrN9TDwA4P8FpQYH2gUDOCCTqq5ga1FjqvXpq0By37ZT2wxmBqfXimgMIqxqml2QlLPtGfEYgA4Ep8fZXlaj2BFGQbsP3phYlZJ/pdg7ASBafqkIRApZOlsTwRPRjyh0N7mpCQAKQYTlxlpUMiwlCRLej7WrfCdJ+2mQJHkWFGnsiEVEvwEAgERGRAW2MzgYcXZgeX6Q+GX568ShIEvDu1sPYVtmStNc1umWb9dmA35o4AJYEjE4+noz4GoE8YZEMn35dA1UTGDYgDUMKTj6t2MFACH+trMfjB2uw2eOHOMaJBq4RSNT3xQJ3sTVcuyseCOSM75SKBe5yXKc6I1CvT84ITD5PMIJXvygDkLjZgADibXauJ5d8iqrhmY/3AwBuOmcYbMdZN64r4us+MjVoj2tV1GOe5PZGA3fp0cBfUBNwmGSkn0Q9p5lNsMoSQpqGjFjKfe34gUD98QJBrhNIRL1Izy0wQ0RERCmz4WA0LWgS1gdsb0xhOr4zaSCWbq7C7z/YjZcWzkjq6xuRP6zg/e166sjvTB7U46+X6dBPTDI1aM8TQmDVVr1uz5tUeMLHN4QVfNrUitVNXpQF2078ft7sxRiXHVcXZmFCmrPDcxzR2QWBEAOBRH1VwmYEOjkjsDdoSFAgkDMCU+fvX5ShNaRgVIEb543OT9h+uUZg6vx762GUNfqR7bLi2jMGJ2y/sUAgg7s9ryGsdJoWFAACmgAgITN6jPlUFWlmU3yG4PGkmfR1BAOqhmy7BVAUhHD8mX42WUajUOHXNLiQ2LT/RETdxUAgERGRAW0sS+76gO3dc8Eo/HvrYazaXYf1BxsxvSQ76WUwkhU7auAPqxic7cTpgzN7/PUyHNETFjxR3ON2lbegujEAu9WEmWM7P5EYUDV80ezF6iYvtnkD8dMOZgmYmu5ClsWEjxpascsXxKL9hzHebcfVhdkY53YA4IxAIiOIDcxI2IxAfr+n1KEGHwAg+1TXCHRx4E4qhBQVL645AAC4+dzhkDtJQ9hdXCMwNTRN4OlV+wAAPzyrBM4TrBvXFbHUoJwR2LPCmoYWVYX9GMdjLHCXHa0Pn6phmMMGSTrx8WuRJWRZzDgcCiPXaQU8AUROcNybJQmK0NchJCLqLRgIJCIiMphAWMX2aFrO0wcnPxBYkuvCVdOL8eqXZfjde7vw+i0zT6qTRZ1buqkSADBv8sCkfI6ZTv3E4u6aVgQjKuwWjmLtKau2HAYAzBqXD7vVBCEEvKqGhoiC6lAEa5t9WN/iQ7hd2s+xLjvOzUrDzEwX3NF0RlcUZOGdmiasaPBguzeIB/ZVYWKaA9cUZiM7HgjkCSiivkjTRHwmSfopzgiMPZ+pn1NnR5UHH+yoAQCcPSL3lPaV5eSMwFR456tK1LWGMCDDjm9PGpjQfXNGYGp8sKMGe2u9SLOZcf3MkoTum6lBk8OnagiqGnI6CeJqmoZItDuTF/sdFUDmSawPGJNrNeNgIIQClxXwAOrJdI+EQOAEKUSJiJKJgUAiIiKD2VLRDEUTKEi3oSjLkZIy3H3+SLy5sQLrDzbhkz11mJPAtEn9SYM3hNV76wEA35nS82lBAeDMYTlIs5mxr9aLn7y+Bf/3/SkJHe3eHwkhENQEWhQVHkVFY0TBYX8Yn6ohqBOysKvIhjt3lKExonQI+sUMtFkwOysNZ2e5UWA7OhCQbTHjv4ry8O38TLxd04yPGjzY2hrA1tZKTHLZoaVbEPFEoKgazD28xiQRJVZrUEHsa+FUU4NmRp/PGd+p88jynRBCX/N3YlHmKe0rNiOwyR+GEIKDrpJA0wQWry4FAPzX2UNhNSf2N9UdCxpxRmDSCNE2G/CGWUNO+Xv2SLEBGEwN2rO8qoawELB28j34ys5qqFYToAqMzXUhpGmwyie3PmBMmskECCDfZdPvMMnwhxQ4bcc+rW6VJXgizMhBRL0HA4FEREQGs/FQbH3A7JSdFCrMsGP+zCF47tMDePT93Th3ZB6DSV0QjKj4urIFb2woh6oJTBiUgeF57qS8dmGGHX++firmv7QO7359GAMy7Pjlt8Yl5bUTQRUCflWDT9UQUDUENQ1BTejXarttTUNQ1bdVASgQ0ISAIvR96Bd9WwNglSRYZAlWWYJF0q+tkqzfF70NAB5FjQf89IuGFkVFpJMAH0rSAAClkY4nh9JNMrItZox1OzA7243hJ5m6KM9qwS3Febg8PxNv1jTh48ZWbPEFgZn5kOuD+GtlA4a5bRhks2Kg3QKXibM9iXq71XvrAOhpQW1dOGnZGaYGTa1P9tTh0731sJpk3H/JmFPeX2xGYEQV8IYUpNkTG8Cgo32wowal9T6k2824Zkbi1pGLSWMayaRbvbceX1e2wGEx4YdnDU34/mN16mGd9iifqkIIHNVebvSH8a7XC9hMOC0iY1C6A40RBW5TFwOBZhMcJhkui4ToC6HKG8QI27H7Z1ZZQrOicqAGEfUaDAQSEREZTCwQePqQ5KcFbe+2OSPw6pdl2F7lwXvbq3HphAEpLU9vJYTAwQY/Npc3YVNZMzaVNWPnYQ8UrS1wdHmSZgPGzBqRi8eunIQfvbYZz392AAMyHfivs7t3cmRVowdfeXyQJCDdbIIMCSYJkCUJJujXsgTI0DvIYSEQ1jRENIGIEAi3u479LRbo86oafKoKn9K2HdA6Cbj1ElZJQobZhEyLCVUVrQi2hjF9SCbOHJKNbIsZORYzsiwmWOVTm2GQb7Pg9sH5uLwgC29WN+KTxlZouXb8p9EDNLY9LstswiC7FYPsFgyyWVFgNcMuSxCdBS2JKOlCiorfvb8LALBw1qmfoI4FAr0hhTOEk0zVBH797k4AwA0zh6A423nK+3RYTbBbZAQjGpp8EQYCe5gQAs9+sh8AcP3MIfE0nokUTw0aYrA+WZ7+SJ8N+P0Zg5HjtiV8//lp+j53VnnwRWkDzhyWk/DXIKAxrMDWyaDTR7eUQ3OYYA6q+OkU/XfUr2oY7rDB1IXgnNskwyHLCAkBSRUQZgk13jBGHKc67bKMgKYhpAnYTQwEElHqMRBIRERkIJom2s0ITG0gMNtlxY3nDMOTH+7FYx/sxkXjCvr8SccWfwT1vhACYRWBiAp/WEUgrLTb1i+KJvQl6aMBFRHdjN4LIfSTgntqWrG5vBlN/qNP+OSl2TClOBMzhmbjB2cmftT5iXxn8iBUNQfx2/d24Vfv7sCADHu3grk/31OJQ8Hkr19klyU4ZBl2kwy7LMEuy/rF1G5blmCTZZglwCRJ0Yu+Hb8PEiQJHQKTYSEQ0QTCQote6/cDQFp0hHGG2YT06CW2bY/+/+8qb8Gv1pfCbZFx+yXjj5tW6FQMsFlw15ACfL3iEDwuE2ZMHQCPLFAZjKBJUfWLN4Bt3kCH541Pc+JsK08oE6XaK2sPobwxgPw0G24699QDge3XGPQElXhqSep5b24sx+6aVmQ4LLjz/BEJ22+204qqliAa/WEMzjn14CId27oDjdhc3gyrWcaCBATmOxNbT45rBCbHugONWHewEVaTjJvPHdYjrzGxKAMXjy/A+9trcNNfN+DNW2dhdGFaj7xWf6UKgcaIAscR/cx1lc3YaxMAJHw3Kx3uaHp9RRPI7mQtweORJQl5Vgv2BYIwa0AEQJ3/+P0bqyyhNawioGnxPgARUSoxEEhERGQg++u8aAlEYLfIGDcwPdXFwY3nDMVf1x5EaZ0Pb2+qxFXTilNdpG4RQuDPq0vx2Pu7O8zUSxSrWcZpA9MxZXAWpgzOxJTBWRiYYU95GplbZw/D4ZYA/rr2EO5Zshl5aTZML8nu0j4mpjlgliRoEJAgQYum2lTbXwtAiwZJrZIcT7/ZPu2mpV1KTqcsw2U2wW2S4TLJcJtMcEW3XWZ925ygz04TAo2tIeRknFx6zpPx8ZbDAICZY/N7LAjYXhZk+Mt8KG8px39dMgqnnZYFn6qiKhhBZSiMymAElaEIyoNh1IYiGOpI/Ih4IuqaZn8Yf/xwLwDgpxeNhrOLJy07YzHJcFlN8IVVtAQiDAQmiT+s4Pcf7AEA3HX+CGQ6E/e5Z7n0QGCTL/kDbvqb2GzAK6cWIS+tZ34n22YEKkwnmARPRdcG/O7UIhRm2HvkNSRJwpPXTMF1z3+JDYeaMP/FdXj79lkYmJmaddyNyKfqs+7ap/pUNQ1PH6gB3GZk+1VcObkQgD6wzyRLXUoLGpNtNUH1C1iFHghsOEGabaskIawJBFQNWRxfR0S9AAOBREREBhKbDTipKBOWXjDyMM1uwe1zRuD//Wcnnly5F9+ZPPCU1zhKNlUTePCf2/C3L8oA6KO1XVYzHFYTHBYTHFYTnO22HRZT/LOXJCB2Cid2Mid2TkeChOJsB04fnIWxA9JhNae+vo4kSRIenDseh1uCWLGjBjf+ZQPeum0WRuSf/HqFi8eX4D91LdAgkGXpW03P6sYAnvn3Luw/3IpBOU6cNT4fs8bnIze9+yeLvIEIvtylr/l13qTCRBX1uBZePBLP/nsX6lpC+M2SrzFnYiGuPX8YRrrsGOlqey9hTUNNKAJnL/juIOrv/u+jffAEFYwpTMN3pxYlbL8ZDks8EEjJ8dzqA6htDaE424HrZw5J6L5jwdxGBgJ71K5qD1btroMsATed0zMzxwDAHZ0RGFEFQooGu6VvtZn7kq0VzVi9pw4mWcJts4f36GvZLSY8P38avvfsWuyr9WLBS+vwxi2zkOFkdCgRvIq+NEBeu9SgL2ythM9tBlSBn4xpW2LBr6pwdXF9wJg0kwmyBNghwQeg6QQpfCVJAiQJfk3r8msREfWEvnU2hoiIiI5rQywtaElq04K2d/3MIXj+s1JUNgfw8pqDuKWHO9uJFAiruOsfm7ByZw0kCfjlZeO6vVZeX2WSJfzxmim49vkvsKmsGfNfXId37piF/LSeGTndGwghsGpLNf7+0X6EInrnvbLBj9dXH8Trqw9iTHEGzh6fjxlj8ro8o2/N9lpEVIHB+S4MG5Cc1FBjijPwyA+n4vXVB7Hiqyp8vLUaW0ob8cNLRmLK8I6Lm3RlvRQi6hmHGnz469qDAIBfXDoWpk7WPequdIcFVS1BBgKTpLY1iD+v1meS3X/JmIQPhsqKzi5sOkGKOjo1iz8pBQB887QBKMl19djruNvN/G0NKgwE9qCno7MBvz1pYFLS6mY6rfjLD2fgij+twZ4aL256ZQP++sMZrOME8KkahBCQo23YmtYgVgYDgN2EKTBjdHbbMevXNAywWWHrxnrcbrMJDtkEe/Q3ucYbOuFzbLKEPd4gsi1mZPexAZFEZDwc7ktERGQgbesDdi19Y0+yW0y4+xsjAQCPLN+FHzz/BTYeakxxqU6s3hvCNc99gZU7a2Azy/jTtaf3uyBgjMNqwgvzp2NorguVzQEsfGk9vCFjrl/T4gvj8be348X39yIU0TBucAZ+88OpuPGSkRg7OAOAvsbf8+/txR3/txZ/XLoDX+1rgKJ2Pto3omho8IRwsMaLrw804cNNVQCA8yYNSGrKL4fNjPkXjsAvr52Igiw7mrxh/P7N7Xjm37vQyoAAUa/yu/d2I6IKnDsqD+eOykvovjOi6wQyEJgcf1ixF/6wisnFmbisG+vsnghnBPa8yuYA/rlF/+2+ZXbPzQYEAFmWOqQHpZ6xp6YV72+vAQDcPid5AxQHZTrw8sIZSLOZse5AI+59fTPUHlhyoL9pjiiwtBsw8+jmMmh2EywhFfdO6rgsRUgVyOvmOtiOaErRHJeeGri8OYDPov9Hx1JoNaNJUbC+2YuWCI9pIkotDkcgIiIyiAZvCAfqfQCAKYMzU1uYI1w9rRj7a3145YuDWLOvAWv2rcXsUXn48YWjMLk4M9XFO0ppnRcLXlqPskY/Mp0WvDB/Gqb2ouBqKmS7rHh54XR895nPsb3Kg9v//hVemD+tV6SgTZRN+xrw3PI98PgjMJskXHXuUFwyfRBkSUJRngtzJg1AvSeIz7fX4rPttahq8GPd7nqs210Pt8OM8UOyEAyr8AYi8PgjaA1EEAyrR72O1SzjrPH5KXiHwJjiTPx64VS89dkhLF9fgTXba/H1gSYsuHAEJo/KOfEOiKhHbTzUhHe/PgxZAn5x6ZiE7z8zmopua3kzvj1pYML3T2321LRiyXo9rfgvLxvbI4M/OCOw573w6QEomsCs4TmYWJTZ46/ntpnhDSnwBhk06Cl/is4GvGR8IUYWJCc7Q8zYAen48w1TseDF9fjP19XIT9uBB+eO43qQp6BZUWGLBgJXH2jAQZfeN/l+fhYc7dcNjM4azOjmzGxJkpBnMSPLZQHCIQizjJfe34vhA9IwILvzWaWSJKHYbkVZIIL1LT6ckelGWh9bJoOIjIOBQCIiol6s3hvCss1VeGdTBaqag7CaZFjMkn5tkmE1y/HtQEQPOIzMdyMzemKotzCbZDwwdxwWnlWCp1ftwxsbK/DJnjp8sqcOF4zNxz0XjMJpgzJSXUwAwMZDjbjxLxvQ5I+gOFsfuTs87+TXxDOyITkuvDB/Oq5Z/AVW76nDL97+Gr/73sQ+f/IiGFbxj1Wl+HDzYQBAUa4Tt88dg8GdrIWYm27Ht2cOxtwzi3Gwxos122uxdmctWnxta/8dSZaANKcFaQ4L0p0WnDOhsMspRRPJZjHh2vOG4YzRuXhu+R5U1Pvxx2U7MXVUDi49dwiQm7KiEfVrQgj8v3d3AACunFqMMYXpCX+NSycMwPvba/D8ZwcwqTgTcxkM7DGP/GcnNKEHG6aV9MxgomyXHtjljMCe0ewP47VoMDdZqe3ddjPgAVpPsP4Ydc+hBl98hucd541ISRlmDc/F76+ahLv+sQkvf34QhRl23NqHlk7obTQAMiREFBXPldUBGRbkhwS+PbTjjHq/qsFhkpF2CuuyZ1hMcETTiloHOBE86MVTy3biweunHHO9d1mSUOywoDwYxoYWH2ZkuuAyMRhIRMnHQCAREVEvE1Y0rNpdizc3VmDVrlooXUwZc9aI3nsWvzjbid98dyJumzMcT364F0s3VWLlzlqs3FmLS8YX4p4LR57wxKcQAv6wCgHE0yclynvbqvGj1zYhpGiYWJSBF+ZPR16aLaGv0ddNKs7E0z+Yghv/sgFvbKzA5vJmTC7OxMTiTEwqysDowrSEr4HUk/YfbsUz/96F6sYAAOCb0wfhynOHHrMzHyNJEoYWpmFoYRq+f94wbDvYhPI6H1x2M9KjQb80px74c9rMvTJYOnxgOh6efzqWrS3Dv74ox8Y9DdhxqBnDrp+K80YkNh0hEZ3Y8m3V+KqsGQ6LCfdeNKpHXuM7kwdha0ULXvjsAH7yxhYMzHRg6pDes66wUazZV49Vu+tgliXc/83Ez+yMyYqmBm3yMWjUE15Zewj+sIpxA9Jx7sjktK/T7HrbtpUzAnvEs5+UQhPA7FF5mFCUukGIcycNRI0niF+9uxO/Wb4L+Wk2XHF6UcrKYwTPbixHIMMCaAI/HXv0IBe/qiHLYj6lIFya2YQp6U6samxFwG6CPCsfBzY34h+rSjH/wmMHlk3RmYGHAmHILcCMDDccBsqqQkR9AwOBREREvYAQAturPHhzYwX+uaWqw8juSUUZ+N7UIkwryYaqCYQUDRFVv4Sj2/p9ArIEXDiuIIXv5OQMyXHh8asm447zRuDJlXvxr61VeG97Nd7fUY1vjMmPpkVS4Qsp8IUVeEOKvh1S4QsrENHYaKbTgiHZTgzOcUWvnRiS7cSQHBfy02yQ5ZMPvry05gD+9987IATwjTH5+L9rp8BpZVOpM+ePKcAjV0zA//fONuyt9WJvrRdvbKwAAFhNMsYMSMPEogxMHJSJCUXpiAgNrYqCcEgFBCCEpg/f1QBV06CoAoomYLfIyMt0nDAId6o0TWD7oSZ8tr0WX+ysg6oJZLmtuOWy0TitpOsnxE2yhEnDsjFpWN9LH2sxy/jeOSWYPioXf/7PbjR5wxjWyUxIIupZYUXDb5bvAgDcfO4wFKTbe+y1fnHpWBxq8GHlzlrc/NcNWHrHWSg+Rloz6jpNE/h/7+4EAFx35hAMzXX12GtlRzNA1PtCPfYa/dWW8ma8sOYAAH1twGQN6InV6ZMr92JYrivpqSuNrLoliLei7dU7z0/NbMD2bjxnGGo8QTz36QHc9+ZW5KXZcM5IDsTqjsNNAawWYQAmnGG2Ylj60b9pAVVgjOvU+nZpJhOGOW34/4YV4s8V9agEEJ6ei+V7PBi7qw4zxhy7/toHA03wYVqGC3YGA4koiSQhBFemTRKPx4OMjAy0tLQgPT3xaV6IiKjvafCG8M6mSry5sQK7qlvj9+en2XD56YPwvdOL+sUJgN3VrXjywz34z9fVCdunzSxjcLYT2S4r7BYT7BZZvza3bdui9x+s9+H1DfqJgevOHIyH5o6HmR2zE6prDWFzeTO2VjRjS0ULtlY0o9l/arMSJABZ6TbkZ9lRkOXAgGwHBmU7MSDbibwMO0xdCO4e6VCtF2u21eLznbVo9rYF288Yk4eFF42A22E5pbL3df6Igj11PvxgVCGyLKkJgrO93D383Pq+Fz47gIf/vQN5aTZ8/NM5cPVw+mBfSMGVz67FjsMejMx3463bZyHd3r+/AxPlrY0V+MkbW5BmM+OT+85Dtqvn0rWXNfhx7qOrAAC3nDsM918ypkuDoOhoQgi8tr4cDy7bjrCqYeyAdPzrzrOS1i78qqwJ//XyejT5I7CZZfzi0rG4YeaQXplZoC9Zu78BD/1zO3bXtGLG0Gy8fsvMVBcJgD5w4J4lm/HPLVVwWU14aeEMzBja9waWpdJ7dc24/5M9qMmxwhrW8OLUYbAfMesvpGk4HIpgTnY6iuyn9p38WVMrDofCyDSb8efyOnzW7AUAWOqC+O20oRicdfyBNRFNoCIYxgiXDVPTXbDK7HMmC9vL1N8xEJhE/MIhIqKYfbVevPBZKd76qhJhRQOgz6S6cHwBvje1COeMyO2XgagdVR6s2l0Lm1mGy2aG02qC22aGy2aOX7ts+n2aAMob/TjU4EdZoy96rd+ubA5A7WJKVQC475LRuG32cJ5s6SYhBCqaAthS0YytFS3YUt6MbZUt8IXVDo8zyRLMJglmWYZZlmAySTDJErxBBYEjHtueLEvITrchN8uOvCwH8qLBwrwsB9KcFsiSBAlArPokSGj2hvDVrnqs31mHw/X++L6cdjOmjMrBtLH5GDrADZMsQZYkyIB+kSTIkr7miCzpAUp938b93whrGurDCi7MzWAgsI/h59a3tfgjOPfRVWgJRPCbKybgmhmDk/K6h1sC+M5Ta1DbGsI5I3Px0oLp/bLtkUiBsIrzf/8xDrcE8bNvjknKul9/+ngffvfebgDAtycNxKNXTuxTKbp7k2BExQPLtsUHh100rgCPXTUp6UHyWk8QP31zK1bv0dcenj0qD49+byLye3CmsFFVNQfw//6zE+9u1deBznRa8NcfzsDEoszUFqydkKJi4Uvr8fn+BgDABWPz8aNvjEpp6tK+5L7P9uKvIS8gS7gxNwuXFLUFUoUQqI8o8CkahjpsmJqAWXi7fAFsaPGhxGGDEALL61rwUkU9hCzBGtLwv+OLMMLtOO4+QpqGqmAEo10OnJ7uhJkDOJKC7WXq7xgITCJ+4RAR9W9CCKwtbcDznx7AR7tq4/dPGJSBq6YX49sTByLDydH4iRBRNVQ1B3CowQ9PMIJgREMwora7RG8r+raiarhs4sA+kVa1r1E1AW9IgSUa+LOYpGMG04QQqPeGcbDBh/11Xuyv86G03qsHeRv88aB5Z5w2EwqyHCjMdqIg2wGHzYRNexuwu6wFscau2SRhwrBsnDkuHxOGZcVPeKtCQBVCz1Yq9KylQghoAlAhIABoQkT3IwFC6FHB2G0ISCK+CRH9mykaRIwHGI8ILMaeHYtcdrgvKlYWES+bgBDQb0f/ZpIkWGUJ5ui1RdKDml3FQGDfxc+tb/v1f3Zi8epSjC5Iw39+dM4pzXzuqq8rWnDVn9ciEFFx3ZmD8fB3TjP0gIee9vSqfXj0/d0YlOnAhz+ZDbslOQG5NzdW4GdvbYWiCcwcloM/3zCVMzy7qLzRj9v+vhHbKj2QJeCnF4/GrecOT9kMSyEE/vL5QTyyfBdCioYspwWPXDERtPgb0gAANbJJREFUl5xWmJLy9DXBiIrnPy3F06v2IxBRIUvAD84Ygp9cNAqZzp6bpdtdrcEIHvzndizdVInYWEYGBE+sNRjB+P9sQjjLigER4I/T2tL4BlQN1aEIsixmjHc7MNhhhSkBv2+VwTBWNXgw2GGNt7fX13rwaGk1NLsJsgBuGZyHb+Qcvz0WVPVZiuPcDkxIc8AcH9DYd3+DFU0gEu1XRYSAIgQiWtu2JoAhDmvKZkGyvUz9HQOBScQvHCKi/imianh362E892kptld5AOjn/S8cW4Cbzh2GaUOy+nSDnygZNE2g2hNEaZ0PB+pjQUIfSuu8qGwO4Hgt2mlDsnD56YPwrQnHDrZrQkAV0aAgokHAaHBQFXrwTQMg0H67LUinb+uBw9h+IpqGcLTzG+sExzrHMeKI6yO3JegzFKVoANEk6QE/c3RbgoSwpsGnaggLfa3FsNDin4ckARZJgkWWYJVl2KLbnZ0IYSCw7+Ln1neVN/rxjd9/grCq4eWF0zFndH7Sy/D+9mrc+reNEAJ44Fvj8MOzhya9DEZQ1xrCeY99DG9IwRNXT8a8KYOS+vqr99Thtr9thC+sYkxhGl5aOB0DMo4/K4V0n+ypw49e24RmfwTZLiv+eM0UnD0yN9XFAgDsqWnFPa9txo7Deh/i6mnFeGDuuB5PH9xXCSHw4c5a/O+/d6CsUc8EMb0kCw99ezzGD+z9AbXSOi+e+mgflm5mQPBEDtb7cOeqXdiQawI0gcdHFWGw2w5NCNSGFUSEwHCHHWPddqQlcJa0R1Gxor4F6WYTHO1mF67eVYunyuqg5eszd8/LTsONRbmwHSfoFVA1VIcjyDCb4u39WBtfv0S3IcEsS7BKEmwmGZZoX8ASHQgYa+tbov2E7gwIPJKI9oPa92EimkA4fq0hpGoIqAIBTUNQ06AIAUXE+lUCCgQ0DRCSPlrSKkk4PycdedbUDFRhe5n6OwYCk4hfOERtDrcEsGR9OVqDCr55WiGmMhBCBlTXGsI7myrw0pqDONwSBADYLTKunFqMH549FENzXSkuIZExBCMqDjX4UVrnRWm9Ppuw1hPC9JJsXD5lEAbnHH+tjmRrm12IeMCuLSAoOtyOzSCUcfwRwpoQCGkCoWjwMahpCGkCAVWDV9XgVVUEo38LaRo0AJKQYJEBazRIKANoVVQGAvsgfm59113/2IR/banCOSNz8dcfzkhZe3jx6v349X92QZKA566fhgs4Q/6kBSMq/vbFITzz8X40+MKYMCgDy+44KyUzybZVtmDhy+tR1xrCgAw7Xl44A6MLjb/WdHdpmsBTq/bhDyv3QAhgUlEG/nTdVAzK7F0B1JCi4vEVe7B4dSmEAIbkOPGHqyfj9MFZqS5ar1Ja58Wif+3AJ9GUqgXpNvzi0rH49qSBfe5cQ+cBwQLcc8FInDaoLSCoagL+sAJ/WIUvpF/rFwWDMh0Yke/uc+/9RLZVtuCZT/bjP9urETgrH3CYMcNsxX2nFcOrqKgLK8izmjHO7UCx3Zrw968JgffrWxDWBHKsHdvLL6/Yh/eaPFBGpgOShMF2K2ZmupBrMSPHao5ftw8OhjQNQU3E+wcimgFE0wSCQsCnavArKiIAMqPBRwlSvK9gkgAz9GUWzJKekUSSABP0IKIsSTABkGXABL29b5L1PoYaDdyp0KBpgIJ2mVKE3i9RogMcleilfR/GJCE6QFGKDlbUM6GY2wcxo5+/KgSqQhFcwEAgUcowEJhE/MKh/k4IgfUHm/CXzw/ive3VHdbvKs52YN7kQfjO5EEYke9OYSmpv4qoGtbub8DXlS0oTLejJNeJITku5LhOrvPgDSnYVqmvibalohlbyltQ2RyI/z3XbcOCWUPwgzOGIMvV+9LREJHxhTUNAVU/2RDUNAQ0Da0RFS2KCr+mIaIJWGUJ52SlIZOBwD6Fn1vftKmsCZf/6XNIEvDuXedg3MDU1Z0QAr9452v8Y105nFYT3rh1Zp+YPZNKYUXDkg3leOqjvajxhADoAZpnr5uKsQNSV5fljX4seGkd9tf5kGY3Y/H10zBzeE7KytNbtQQiuHfJZnwYTdd/7RmD8eDccb16fcUvShvwk9e3oLI5AJMs4b/OHorpJdkYnO1EcbYDTmv/mSUYjKiobA6grNGPikY/dhxuxZsbyxFRBSwmCf919jDcef4IuPv4zMn90YDgsnYBwYEZdgQVDb6QgtBx0uYDQK7bijOG5WDmsBzMHJ6DYbmuPhkYFEJg7f4GPPPJfny6t16/D8CoaQVoyLfhv0cMiK8VPsplxyiXA84eXPN2fbMPu/0BDLBZYJXalj0IKxoWvbIJpUoEYkoOFHPnZUgzyfHAYIbZhIAm4FdVeFU9y4dPUeFTNXS2crrbJKPAakGhzYJCqxkFNgtyrWbkWExwm0zxrCWqJhASGkJqdLCgEAhpKkKaQDj6z6QPBpRgkfRZhja5bXahTZYgQ0JA02f9+TUNvmgZWxUVHkW/blVVBFQNUvTz1wcv6oFGSWrLbCIBCAkNvx9djMnpqRkQzfYy9XcMBCYRv3CovwpGVCzbXImXPz+EndGUJgAwY2g2irIceH9bNXzhtibOxKIMzJs8CHMnDURemi0VRaZuaPCGcLDBh+IsZ59ZyD4W/PvP14fx/vZqNPkjRz3GbTNjSI4zenGhJHrtsJjwdbvA395a71GpCSUJGDcgHfNnluA7Uwb26hMLRNS/RTQ9rU9EE8i2mFJ2kojt5e7h59a31HiCWLmzBi9+dgD763y4cmoRHr1yUqqLhYiqYcFL67BmXwMGZNix9I6zUNBH2nTJpKga3tlUiSc/3IuKJn3Q18AMO+7+xkh8d2oRLD148vlkNfvDuPEvG7DhUBOsJhm/v2oS5k4amOpipZwQAgcb/Fh/oBFPf7wPhxr8sJpl/GreabhqWnGqi3dSWgIRPLhsG5Zurjrqb7luG4qzHRic7YwGB53IS7PFZwXJkp5dQJYAWW5/W4LbZkZRliNp61oei6YJtIYUeAIRtEQv1S1BlDf5o0E/PfhX7Ql2+vw5o/PwwLfGYViesQYXdxYQbE+WAJfNDKfVBJfVDKtZxoF631GBwoJ0G85sFxgcnO3s1YFBTRP4YEc1nvl4P7ZUtAAATLKEuRMH4JbZwzF2QDreq2tGVSiCwXYrxqc5UGi19Ph7OhQIYWurHwFVT5EJ6Kn4HSYZLc0h/OqVTQhKwOhZg5A7wIX6iIKGsIKGiIJgZxV4HCYALrMMGRKalc5Cg23s0fShoWimkN7o7cnDMSsrNTPV2V6m/o6BwC56+umn8eijj6K6uhqTJk3C//3f/2HGjBkn9Vx+4VB/U9HkxytfHMKS9eVojgZY7BYZl08ZhBtmlsRHygbCKlbsrMGyTZX4ZE8dlGiDRZaAs0fm4fIpA3HuyDxkn+TMLOpZmiZwsMGHHYc92FHlwc7DHuw47ImPhAb0DsaEQZmYMCgDE4syMKEoA7nu3hHUjQX/3t16GO/vqI7/bwJAjsuKmcNz0OgL41CDH1Utx1937EgDM+yYVJyJScWZ+vselIE0e2rSXhAR9UVsL3dPf/zcFFWDognYzHKvbx8KIbC7phUrttdg5c6a+MlMAEi3m/HBj2ejMKN3BNxaAhFc8ac12F/nw5jCNFw1rTg+IKooy5nyIEEqaZrAu18fxh9W7kFpnQ+AHni587zh+P4Zg3vdgK9gRMU9r23Ge9urAQC/vGwsbjxnWIpLlVyKqmHn4VasP9gYvTSh3tvWZynKcuDZ66Z2SLXYVyz/+jD+tbUK5dHAWEvg6AGN3ZGfZkNxthPFWY7otRNF2Q4UZzkxIMOOkKKhwRtGvS+EBm8Yjb4Q6r1hNHjDaPCF0OgLo8kf1tMRyhIssqynLDTpa5yZTXL8WlG1eLDPE4ygxR9Ba0g56f6Xy2rSyxgt57mjcjF7VF6v/004FVXNAdR4gvGgn9OqX3f2WxhSVGwua8ba0gas3d+ATWXNCKtHBwaLspzIT7OhIN2OvDRbfDs/3Yb8NDuynD0fWIvRNIF6bwgVzQHsqPLgxTUH4t+3NrOMa6YX48ZzhqE4uy3t/7pmH5wmCSNd9uOux5dosTW6Y5fGsIKmiIKApuGLHbV444P9kCRg6pg8DCl0o6TQjeI8FzQT0BzW0KSoaIoo8KoaHCYJLpMJLpOsX2QZ4aCChoYAqut9KK/1o9kXRlaGDc4sO2S3Bapdht8soVHTUBOOoC6s4FiHjjU6288my7BFZwEKtFv/L7p0QEQTOPKbRALglmVkWExIN5uQZo5dy0gz6dsOWYaIrpOuRdda19qvtQ5AiaY5vWtIAUY4U9Pm6Y/tZaL2GAjsgiVLluCGG27As88+izPOOANPPPEE3njjDezevRv5+Sde1J1fOCcn9sNf3hRARZMfFe2uq1uCyHBYMDDTgYGZDgzKcmBQpj1+O50n3LtM0wQimoaIKuKpOiVJ/7GPTe1vu0+/5QsraA0q8AYVtAYj8AQVeEP6dmt0u7TOi4921cZHqxVlOXDDzCG4aloxMp3HTovY4A3h3a8P451NldhU1tzhbxaThFy3Ld44zUuzIc9tQ166Xb9Os8EkS/CHFQSiufED0fz4/oi+7QupCCkqTHI0h3q7zkjstkmWYYl2VBxWE+wWExwWExzWzq/NnYz67ayZLBBdF0pEF16ONY7i9+m3zbIEi0mGxayXwyLLx11jpH0dhhUNEVWLX5/MF7yqCYQiGoKKilBEQ0hREVI0BCP6dSiiIqhoqGjyY0eVB7uqW+EPHz0STZKAgjQ7aluDnY5SHJhhx2nRwODYAelw2cxHdAYlmKOfvSn6GZhl/T5ZBsyxTqQsdfp5aJpAUNHrORBREYzo7yEQrfvWoILVe+o6Df5dclohLpswADOGZneoz2BERUVTAIcafDjY4MehBh8ORa+9IQXjBmZgUlEGJhVlYmJxBvLTesdJPCKivort5e5J9ef22royvLe9GnazKdp2kmG36G0o/T45vg1Jb3uo0fVwFFW/VjUBRdPXxFE0AV9Ib2+2hvT2ZWuwra3ZGlQQiOhtEbMswW03w23TL2mxbbslfjvNZkam04IMpxWZDou+7bAg02FFmt3cI2u5RVQN6w82YsUOPfhX3tiWLlySgMnFmbhwXAG+PWkgirJ61zqmZQ1+zPvTGjT6wh3ulySgMN2OwdltmRIK0u04mY/PJEvxE9YOqyk+ayW27UjiTGQhBDxBBU2+MBr9YfhDqr4mkqZB1RC/VjQt/j8ajKj4+5dl2FXdCgDIdFpw6+zhmD+zBA5r7woAtqdqAg//ewde/vwgAGB0QRoKMuzIdVvj/adcd/SSZkWu23bSMxrjfaloP+pE9SeE0PsrqoaIoiEc7bOEVQ0SEO9z2S16UONkjktF1eL9vNi6aE2+CL4qa8L6g4346lBTh8wzAGA1yZhUnIEzh+Xgh2cNNUzK/hZ/JD5rrrxRvy5r9KPRF473M8UR/U8tthaYpg8C8IaUVL+NOLtFRobDgnS7BXlptvgMx1iQcnC2kwOFuygYUfHVoaZ4YHBLRTMi6onPGFhNMvLTbSjOcsbT0BZHZ52ebD0IIRBSNHhD+nmkak8QFU0BVDYFUNnsR2Wzvl3VEkT4iFmM6XYz5s8qwfxZJb1mcPGxaELAH12fe9HSbVi+qePMXVmWMCDHiaICFwbmuzAg34XsDBsamoM4XO9HTb0f1fUBVDf4EQie3PFos8jIy7AjN9MBd44dFqsMWQVkIWDSBCSt7VyTGm1nqZqAJxBBszeMZm8YLdHvCSC6TrkEfWS+BEARkAA47WYMKXSjuNCNokI3BuS74LCb40+SpLbzhqGQgsaWEBqag2hsCaKuKYiGliDqm4NYetdZGJ7F1KBEqcBAYBecccYZmD59Op566ikAgKZpKC4uxl133YWf/exnJ3x+qr9w3txYgQ0HG/XgjqR/p8dyaMfSQbS/H+3+HksjgVgaiXYBothitvq26PjjAf0HX4n+0MQ6+oqmxW/HOv1N/jAqmwKoaA4c9cN/stJsZgzMdKAgww67WdYDCaZ2I9FMeq5rU7tgQ6zTIkcXspXl6MK67T4TIHrCQsR+NBHfVrS2kxdCdPwMYu+//WK6sb+3fW7tPrMj/g50/Gzbf7Cxv2tCIKLqQaCIqkGJdq6UdvdFjtjWg0TRx/dwuoCzR+Ri/qwSnD8mH6YunmQ5WO/D0s2V+OfmKpTW+3qohH1DPDho0q8VTcTrsqfrsDN2i4zRhekYNyAd4wbq12MK0+CymeEPK9hR5cHWihZ8Xalf9tcdnTbzVMSO0dgJCEUTJ1wfob3jBf+IiCh1Ut1e7qtS/bkt+td2vLTmYNJfNxEkCchw6IFBu9kEq7mtvWU1y7Ca5PgALWu0LRYLYISUaCBD0QdShVUNoYge2Gj0htHa7qS6zSzj7BG5uHBcAc4fm9/rBw+V1nmxZEM5DtX7cajRj7IG31EBlUSSJMBhMUGWJMROURyrPyRBigcQ3TZzfGZMbNtlNcFlM0OSgEZfJB7wa/aH0eiLoNkf7nb7Oc1mxo3nDMMPzy7pM1kfhBB4/tMD+PXynQltjx+pw0DL6GA/APFj5MiZSCdiM8v6wILoAAObWUZY0eIBv0BEPakgRprdjGlDsjB9aDaml2RjwqCMfj2z9ViEEGjuEEwMoLxJDyrGAjaxOrRbZOS4bMh1W5HjtiHbZUWO24pclw05bisynfqxERtsHFHbzv/o54b08xEmWYp//6bHr83IcFh63QxbI/KHFeyMZvap9QRR2xrSt1uDqGsNobY1dNSAkM60n5lpNcl6sC+kxAf0+MJ68O9kv3fl6KCToiwnLhiXj2vPGNIn13rUNIFP9tZhU1kzvq5oxtaKFjScxOcZY5IlDMl1YmRBGkYWpqEg3Y6q5gAORdfFrGoKoMETOqnB3ydDlgC3y4p0lwXpbivSXVaYZAmVtT5U1HihdPJ9W5zjxPjiDAzKdKC6OYjyBr1sx/u/efPWmZhWkp2gUndNqtvLRKnGQOBJCofDcDqdePPNNzFv3rz4/fPnz0dzczOWLVt21HNCoRBCoba0Ex6PB8XFxSn7wrn/za1YsqE86a/bHbIEDMhwoCjLgaIsZ/TagcIMO1oCEVQ1B1DVHERlcyC6Heh0bS/qOS6rCWl2iz7q2m6Ob6dHR2FnOq24eHwBRuQnJvd3SFHR4A3HG6R10Uv7Rmpdq368tR9Z7LSa4LSZ4YxuO6xm2C0yNKGP9m3rjOgB6va3w0q7GWXRkabtZ5idbOfzRNqv1SBBio5I7v5+Y0FDs0kPZp+ISZZgN8uwRUffxq/NMmxmfVS/zWxCXpotHvQbmuvqUmDXG1KwvbItMLi3xouQokY7hm2DAyKqiKf6itVDd8ROHMRGFesjjGWMHZDO4B8RUS/GDnr3pPpz21rRjN3VrQhGZ+TrM/M7ztCP3Zagtz1kSYq3VWIBBFO7bZdNn8mX1q6d2dbetMBtN8NikuALqfCG2rJSeIMKWqPXsZORLX499VxzIIyWgIIWfxjNgUinGQ4SKdtlxTfG5OOCcQU4Z2QunNa+dyIzRgiBhmjq9LJGPUNCWYMf9Sd5UlNRtbZsHREF/lA0e0ekZ+vgeFxWE7JcVris5njqwiP/H9vfN35gep+eQVbe6Me+Oi/qW/VUjvVevf9U741dwid10j9RTLIEazTgrgkRD6J3hywBzugM0zSbGeMHZWB6SRaml2RjVEFalwek0tE0TaDeF4LbZu7T32XUNWFFQ503hOqWQDwNbexSHl2rsatnlZ1WE/LTbNEMXw4MynRiUPSc36BM/bxfb1hrNdGEEDjcEsTWihZsrWjG15Ut2FrRgpZABNkuK8YOSMPYwnSMiQ6yHlngPmFAPKSoONDox/46L0ob9HrxR9RoeyqaVUmSYDJJMEttM7hNsoQsl1XPspVmQ16aHVkua3wmtmgXXjRJEmRNoLTWi6/Lm7G5vAWbyppwsMF/3LLluq0YkuNCSY4LQ3P1LAJDc10Yke9O2WCMVLeXiVKNgcCTVFVVhUGDBuHzzz/HzJkz4/ffd999+OSTT/Dll18e9ZyHHnoIixYtOur+VH3hfLSrBjuqPNEp4foXuxZNUdiWIqJtBpumiQ6pDLVOHtcWY2ibORedOBi7F5Kk//jEZuaZYx1/OfpjFJ2hl2Yzx3PPd+eH3x9WUNUcRFVzANWeYHx2nKK1CyxEAw7t7+swRT76vjpsC30avNzu5IR8xImK2MmMWP8iNh2+/WcSuyEd4+9SNBgU/0Q720e7+9vtElazHE+pGAsAtZ89ZpbbjWg2R0c4R0c3tx/1bJKlo2Y1djZL0WExsTMVFRvdeCKiXaoE+YjF2jsTGznZfjZnLN1nRBUwm6RO6zBWj0YROx5jQUFVCKhqx9uKqsFskvV0rV1IJURERL2PUTroXV1X/I033sD//M//4ODBgxg5ciR++9vf4tJLLz3p1zPK55ZsIUXV16eKBgpD7dIVxtthiuhwn6Lpadyt0QFTVrMc3W67tpllOK1mBiBOQiy1uy+kBwnbz/oDgCObypKkt6sDERXekB5QjM088YcVeEMqfCF9BooQQJbTimyXBVkuK7Kc1uhtfcYSZ4UdLZay90RifWhFi7XNtXibXWl3WwDxYF+s32IzH7vPomqi3SAC9ajBBTZz2xINzugllkqUKSKJki8YUVHZHEB5NDCoakIfyGPXZ2jH0na77bEZ22b+LrYjhEBrSEGazdznvsMafWFsLm/CprJm1HiC0bTherBvcI6zVy7dxPYy9XccxtODfv7zn+Pee++N347NCEyV88cU4PwxBSl7/Z7mtJoxIt+NEfnuVBeF+hE9+Jb4/eoBZlO/P0EhRUdiMzMMERH1FUuWLMG9997bYV3xiy+++Jjrin/++ef4/ve/j0ceeQTf+ta38Oqrr2LevHn46quvcNppp6XgHfQfNrMJ+WmmXp+m08jk+NqBPDXRG5hkCaZOVztP3uu7oileiaj3s1tMGJ7nxvA8nofrDkmSemXA7GRku6yGP89MZDTGm2vdQ3Jzc2EymVBTU9Ph/pqaGhQWFnb6HJvNhvT09A4XIiIiIiIyrscffxw33XQTFi5ciHHjxuHZZ5+F0+nEiy++2Onjn3zySVxyySX47//+b4wdOxYPP/wwTj/99Pi65ERERERERESngoHAk2S1WjF16lR8+OGH8fs0TcOHH37YIVUoERERERH1T+FwGBs3bsQFF1wQv0+WZVxwwQVYu3Ztp89Zu3Zth8cDwMUXX3zMxwP6WuQej6fDhYiIiIiIiKgzDAR2wb333ovnnnsOf/nLX7Bz507cdttt8Pl8WLhwYaqLRkREREREKVZfXw9VVVFQ0DFNUkFBAaqrqzt9TnV1dZceDwCPPPIIMjIy4pdULj9AREREREREvRsTr3fB1Vdfjbq6OjzwwAOorq7G5MmT8d577x3VcSciIiIiIuopvW0tciIiIiIiIuq9GAjsojvvvBN33nlnqotBRERERES9THfWFS8sLOzS4wF9LXKbzXbqBSYiIiIiIiLDY2pQIiIiIiKiBOjOuuIzZ87s8HgAWLFiBdchJyIiIiIiooTgjEAiIiIiIqIEuffeezF//nxMmzYNM2bMwBNPPNFhXfEbbrgBgwYNwiOPPAIA+NGPfoTZs2fj97//PS677DK89tpr2LBhAxYvXpzKt0FEREREREQGwUAgERERERFRgpxoXfGysjLIcltillmzZuHVV1/FL3/5S/ziF7/AyJEjsXTpUpx22mmpegtERERERERkIJIQQqS6EP2Fx+NBRkYGWlpakJ6enuriEBERERH1Kmwvdw8/NyIiIiKiY2N7mfo7zghMoljM1ePxpLgkRERERES9T6ydzLGKXcN+BhERERHRsbGfQf0dA4FJ1NraCgAoLi5OcUmIiIiIiHqv1tZWZGRkpLoYfQb7GUREREREJ8Z+BvVXTA2aRJqmoaqqCmlpaZAkKaH79ng8KC4uRnl5Oac3GwTr1FhYn8bDOjUW1qfxsE77JiEEWltbMXDgwA7r6NHxsZ9BXcE6NRbWp/GwTo2F9Wk8rNO+if0M6u84IzCJZFlGUVFRj75Geno6f4QMhnVqLKxP42GdGgvr03hYp30PR+h2HfsZ1B2sU2NhfRoP69RYWJ/Gwzrte9jPoP6M4W8iIiIiIiIiIiIiIiIiA2IgkIiIiIiIiIiIiIiIiMiAGAg0CJvNhgcffBA2my3VRaEEYZ0aC+vTeFinxsL6NB7WKVFi8FgyHtapsbA+jYd1aiysT+NhnRJRXyQJIUSqC0FEREREREREREREREREicUZgUREREREREREREREREQGxEAgERERERERERERERERkQExEEhERERERERERERERERkQAwEEhERERERERERERERERkQA4FEREREREREREREREREBsRAYD8TCARSXQQiOg5FUVJdBEogr9eb6iJQgh06dAgVFRUAAFVVU1waSoRt27bh008/TXUxiPo89jOIejf2M4yF/QzjYT/DeNjPIKLehIHAfiISieC2227DFVdcgRtuuAFffPEFhBCpLhYlCOuy7wuHw7jvvvtw8803495770VpaWmqi0SnIBwO46677sK8efNwxRVXYMmSJTxODWDZsmUYOnQo7rzzTgCAyWRKcYnoVITDYdx4442YOHEiPvroo1QXh6jPYj/D2FiXfR/7GcbCfoYxsZ9hLOxnEFFvxEBgP1BdXY0zzjgDW7duxdy5c7F161bceuutePTRRwEAmqaluITUVZFIBI899hjeeecdAIAkSSkuEZ2KN954A0OHDsWGDRtQVFSEJUuW4NZbb8Xnn3+e6qJRN7zyyisoKSnBtm3bMH/+fLS2tuLJJ5/E+++/n+qi0Slat24dzjjjDJSXl+Ott94CwNG6fdVTTz2F7Oxs7Ny5E5s2bcKDDz6Y6iIR9UnsZxgP+xnGwn6GsbCfYVzsZxgH+xlE1FsxENgPrFmzBuFwGK+//jpuv/12fPLJJ7j88svx4IMPYvv27ZBlmSPI+pDly5dj0qRJuO+++/DWW2+hqqoKAEfr9lWbN2/GSy+9hLvuugsfffQR/vd//xdffvkl9u3bh4MHD6a6eNRFe/bswT//+U/cd999WLVqFa6//nq88MILKC0thdlsTnXxqJtiJ7JbWlowffp0TJkyBU8++SQikQhMJhO/f/uY3bt347777sNll12GNWvWYNKkSdi/fz/q6+sRDodTXTyiPoX9DGNhP8NY2M8wFvYzjIn9DGNhP4OIejMGAg0s1qCoq6tDU1MTBg0aBADIyMjALbfcgrPPPhu33HILAI707Ct8Ph/eeecdXHjhhfj1r3+N3bt3Y9myZQBYh31VOBzGuHHjcMMNNwDQR2EXFRUhKysLO3fuTHHpqKvy8vLw3//931iwYEH8voaGBkyaNAlutxuhUCh1haNui53I3rdvH6677jpcfvnlaGhowDPPPANAP26p7ygpKcH999+Pzz77DLt27cL3v/99XHbZZZg1axbmzZuHlStXprqIRL0e+xnGw36G8bCfYSzsZxgT+xnGwn4GEfVmDAQazJtvvomVK1fi8OHDkGW9ek0mEwoLCzssUFtYWIif/exnWL9+PVasWAGAIz37AqfTiQULFuD222/Hz372MwwePBjLly/H1q1bATD9Ul8QO0ZjI6xnzJiBxx57DAMHDgQAWCwWtLS0wOfz4ayzzkplUekktP/OBYCsrCzMmDEDmZmZAIA777wTM2bMQG1tLebOnYsrrriCi4X3ckfWKaCn5ZEkCSaTCaFQCGeeeSYuv/xyvPDCC7juuuvw+OOP8+RLL3ZkndpsNixYsAButxvjxo2D0+nEE088gYceegjhcBj3338/1q9fn+JSE/U+7GcYG/sZfR/7GcbCfobxsJ9hPOxnEFGfIsgQ/vrXv4r8/HwxY8YMkZeXJ8466yzx1ltvCSGE+Oqrr8S4cePEb37zGxEKheLPqa6uFt/+9rfF9ddfn6pi0wm88cYbYsWKFaKqqqrTv3/wwQdiypQp4qGHHhKapiW5dNQVnR2j77zzjhBCCE3ThKqq8ccePHhQjBw5Uuzbty9FpaUTOV59tq/La665Rrz33nvC6/WKNWvWiCuvvFLMnDkzRaWm4zlenQohRGNjoygsLIz/jv74xz8WdrtdOBwOsWHDhhSVmo6nszp9++23hRBChEIhsXTpUvHwww+LlpaW+HPWrVsnzj//fHHHHXekqthEvQ77GcbEfoZxsJ9hLOxnGA/7GcbDfgYR9UWcEdjHKYqCJ598Eo888gh+/etf49NPP8XSpUsxfPhwPP/88wgEApgyZQrOPvtsvP322x0WBS8oKIDFYomP6KXe45VXXkFBQQEeffRRXHvttbjyyiuxdOlSAPpoXBEdVX3hhRdi5syZWLVqFT766CMAHHHd2xzvGF28eDFCoRAkSeqwhs7HH38MAPHRuwDQ2NiYiuLTEU6mPmVZhqIoAIBXX30VF198MVwuF2bNmoXRo0cjGAzGR2pT6p1MnQJAIBDA7Nmz8fbbb2PixIl45ZVXcMEFF2DIkCHxWRKqqqbyrVDU8er0ueeeQzAYhNVqxfnnn4977rkH6enp8edOnz4dqqoiGAym8B0Q9Q7sZxgT+xnGwX6GsbCfYTzsZxgP+xlE1JexZ9bH+Xw+1NXVYf78+Vi4cCGsVitmzZqFcePGwePxxBejXbRoESKRCBYvXozKysr48wOBALKzs1NVfDrCyTb+JUmKNwjvuusuBINBLFu2DD6fD0II7NmzJ8XvhGJOdIzGOnJA2/orS5cuxWWXXQaHw4HNmzfjoosuwsMPP8yTL73Aydan2WyGEKLDmjqqqmL//v2YNm1ah5MvlFonqtPYuhyqquL111/HDTfcgHPPPRd79+7Fb3/7W5SUlODee+8FoKfIo9Q72eM0LS0Nbre7w3MbGhrg8XgwYsSIVBSdqFdhP8NY2M8wHvYzjIX9DONhP8N42M8gor7MnOoCUNft3bsXI0aMgCRJyMjIwPe+9z1MmDABsixD0zTIsozi4mL4fD44HA4A+lodv/jFL/DHP/4RZ511Fu6++25s3rwZGzZswM9//vMUvyOKObJRIcsyZs2ahU8//RT/+te/oCgKbDYbgLZFpceMGYPLL78cy5Ytw69+9St88MEHkGUZX3zxBRuLKdKVY9RisXR4rs/ng8fjwRlnnIHbb78dixcvxjXXXIPf/e53HTp7lDzdrc9YfQUCATQ2NuKhhx7CV199hWeffRYAjurAU/J0pU6tVisAoLi4GP/4xz8wdOhQzJgxAwCQmZmJefPmobW1NX4CjXWaGt2p0/aCwSCamprwy1/+EgDw3e9+N9lvgahXYD/DuNjPMAb2M4yF/QzjYT/DeNjPICLDSHYuUuq+JUuWiJKSEjF69GgxY8YM8fzzz3f4e/t88ddee61YsGCBEEJ0WK+joqJC3HzzzWLevHni0ksvFbt27UpO4emY9uzZ02HdjU2bNglFUYQQbXX697//XUyePLlDXbb/+/r164XFYhGSJImbb775qMdRcnT3GI1EIvH7N2/eLCRJEpIkiTPPPFPs2LEjOYWno3S3PmPHrxBCvPXWW+Luu+8WBQUFYs6cOWLv3r3JKTx1qrt1Gg6Hj9pX7Hu7fX1T8iXiOF2yZIm49dZbRU5OjpgzZ47Yv39/cgpP1Iuwn2FM7GcYB/sZxsJ+hvGwn2E87GcQkdEwENhHfPDBB6KkpEQ8/fTT4r333hP33nuvsFgsYvHixSIQCAgh9MaCpmkiEAiIiRMnildeeeWY+4s9h1InEZ05IYR45plnhCRJ4qKLLmKjIoUSdYyuXr1azJkzR6xYsSLZb4HaSVR9bt++XTz22GNi5cqVyX4LdIRE1Sk75L1Houp069at4uGHHxbvv/9+st8CUa/AfobxsJ9hLOxnGAv7GcbDfobxsJ9BREbEQGAvFxsJtGjRIjF16tQOo4Vuv/12MW3aNPH22293eE5lZaUoKSkRe/bsEULoI0F//OMfJ6/QdEKJPOGyZcsWsWTJkmQWn9pJ1DF6zz33JK/QdEysT+Ph76jx8DglSgx+PxoT+xnGwd87Y2F9Gg9/R42HxykRGZmc6tSkdHyxHOA7duzA8OHDYbFY4gsK/+pXv4LdbseyZctQXV0df87KlStRXFyMAQMG4Ec/+hHGjRuHQ4cOIRKJcBHwFIt9/mvXrkVOTg5uuukmXHzxxfj973+Pm266CYsXL8by5csB6HUvSRIaGxvjazkAen7y2ILRADBx4kRcddVVyX8zBCBxx2hZWRkikQg0TUvJ+yBdouuT37mpx99R4+FxSpQY/H40FvYzjIf9DGNh+8V4+DtqPDxOicjIGAjsZVasWIG7774bTzzxBNatWxe//xvf+AaWL18OVVXjP0RZWVm44YYbsHbtWuzatQuA3gH897//jW3btqGkpAQffvgh1q5di7feegsWi4WLC6cYG4p9X08fo7LMr+Vk4neu8bBOjYd1SpQYPJaMjf2Mvo/9DGPhd67xsE6Nh3VKRP0JW4K9xOHDhzF37lxcd911aGxsxIsvvoiLLroo/kM0e/ZspKenY9GiRQDaRnzedNNN8Hg82Lx5MwAgEAggEAjA5XLh6aefxrZt2zBt2rSUvCdio8JIeIwaC+vTeFinxsM6JUoMHkvGxH6GcfAYNRbWp/GwTo2HdUpE/VJP5x6lE/P5fGL+/Pni6quvFqWlpfH7Z8yYEV+43ePxiF/96lfC4XCIsrIyIURb7urZs2eLG2+8Mf68DRs2JLH01JmqqirxrW99S+Tn54sf/OAHYsKECSIjI0N8+eWXQgghdu/eLQYNGiT+53/+RwghRCgUij+3sLBQ/OEPfxBC6P8b3/rWt0RRUZF47bXXkv4+SMdj1FhYn8bDOjUe1ilRYvBYMh72M4yFx6ixsD6Nh3VqPKxTIuqvOCOwF3A6nbDZbFiwYAGGDh0KRVEAAJdeeil27twJIQTS0tJw7bXX4vTTT8dVV12FQ4cOQZIklJWVoba2FvPmzYvvb+rUqSl6JwQAfr8fP//5z+FyufDFF1/gb3/7G7Zu3YrRo0fjmWeeAQAMGDAAt912Gx577DGUl5fDarXGRxiNHj0a27dvB6D/bzz00EMoLy/H1VdfnbL31N/xGDUW1qfxsE6Nh3VKlBg8loyF/Qzj4TFqLKxP42GdGg/rlIj6K0kIJv/vDSKRCCwWCwBA0zTIsowf/OAHcLlcWLx4cfxxlZWVmDNnDhRFwbRp0/D5559jzJgxePXVV1FQUJCq4tMRbrnlFlx++eW45JJLoCgKzGYzFi1ahOXLl2Pt2rWQJAkHDhzA9ddfD1VV8dprr2HIkCEoKyvDJZdcgkcffRSXXXZZqt8GtcNj1FhYn8bDOjUe1ilRYvBYMhb2M4yHx6ixsD6Nh3VqPKxTIuqPGAjsxc4++2zcdNNNmD9/PjRNAwDIsox9+/Zh48aN+PLLLzFp0iTMnz8/xSWlI7FR0T/wGDUW1qfxsE6Nh3VKlBg8lvou9jP6Bx6jxsL6NB7WqfGwTonI6BgI7KVKS0sxa9YsvPvuu/Fp5uFwGFarNcUlo+5io8JYeIwaC+vTeFinxsM6JUoMHkvGw36GsfAYNRbWp/GwTo2HdUpE/QHXCOxlYnHZzz77DG63O/4DtGjRIvzoRz9CbW1tKotH3VRaWop9+/bhtNNOA6B3zGN5yEeMGIGrr74ajz/+ODvnfQCPUWNhfRoP69R4WKdEicFjyZjYzzAOHqPGwvo0Htap8bBOiag/Mae6ANSRJEkAgHXr1uG73/0uVqxYgZtvvhl+vx+vvPIK8vPzU1xC6gohBCRJ6rRRUV1djUWLFrFO+xgeo8bC+jQe1qnxsE6JEoPHkrGwn2E8PEaNhfVpPKxT42GdElF/wtSgvVAwGMSECROwf/9+WK1WLFq0CPfff3+qi0Wn4M4774TL5cIFF1zQoVFx0UUXpbpo1A08Ro2F9Wk8rFPjYZ0SJQaPJeNhP8NYeIwaC+vTeFinxsM6JaL+goHAXurCCy/EyJEj8fjjj8Nut6e6OHQK2KgwJh6jxsL6NB7WqfGwTokSg8eScbCfYUw8Ro2F9Wk8rFPjYZ0SUX/AQGAvpaoqTCZTqotBCcJGhfHwGDUW1qfxsE6Nh3VKlBg8loyF/Qzj4TFqLKxP42GdGg/rlIj6AwYCiZKAjQoiIiIiIko09jOIiIiIiOhEGAgkIiIiIiIiIiIiIiIiMiA51QUgIiIiIiIiIiIiIiIiosRjIJCIiIiIiIiIiIiIiIjIgBgIJCIiIiIiIiIiIiIiIjIgBgKJiIiIiIiIiIiIiIiIDIiBQCIiIiIiIiIiIiIiIiIDYiCQiIiIiIiIiIiIiIiIyIAYCCQiol5twYIFmDdvXtJf9+WXX4YkSZAkCffcc89xH1tSUoInnnjipPY7Z86c+H43b958yuUkIiIiIqKuYz+DiIiI+gtzqgtARET9lyRJx/37gw8+iCeffBJCiCSVqKP09HTs3r0bLpcrYft8++23sX//fsyYMSNh+yQiIiIiojbsZxARERG1YSCQiIhS5vDhw/HtJUuW4IEHHsDu3bvj97ndbrjd7lQUDYB+AqGwsDCh+8zOzobH40noPomIiIiIqA37GURERERtmBqUiIhSprCwMH7JyMiId4hjF7fbfVTKnjlz5uCuu+7CPffcg6ysLBQUFOC5556Dz+fDwoULkZaWhhEjRmD58uUdXmvbtm345je/CbfbjYKCAlx//fWor6/vcplra2sxd+5cOBwODB06FH//+987/F0IgYceegiDBw+GzWbDwIEDcffdd3fr8yEiIiIioq5jP4OIiIioDQOBRETU5/zlL39Bbm4u1q1bh7vuugu33XYbrrzySsyaNQtfffUVLrroIlx//fXw+/0AgObmZpx//vmYMmUKNmzYgPfeew81NTW46qqruvzaCxYsQHl5OVatWoU333wTf/rTn1BbWxv/+1tvvYU//OEP+POf/4y9e/di6dKlmDBhQsLeOxERERER9Qz2M4iIiMiImBqUiIj6nEmTJuGXv/wlAODnP/85fvOb3yA3Nxc33XQTAOCBBx7AM888g61bt+LMM8/EU089hSlTpuDXv/51fB8vvvgiiouLsWfPHowaNeqkXnfPnj1Yvnw51q1bh+nTpwMAXnjhBYwdOzb+mLKyMhQWFuKCCy6AxWLB4MGDuU4HEREREVEfwH4GERERGRFnBBIRUZ8zceLE+LbJZEJOTk6H0bAFBQUAEB9Bu2XLFqxatSq+Fojb7caYMWMAAPv37z/p1925cyfMZjOmTp0av2/MmDHIzMyM377yyisRCAQwbNgw3HTTTXjnnXegKEq33icRERERESUP+xlERERkRJwRSEREfY7FYulwW5KkDvdJkgQA0DQNAOD1ejF37lz89re/PWpfAwYMSGjZiouLsXv3bqxcuRIrVqzA7bffjkcffRSffPLJUeUmIiIiIqLeg/0MIiIiMiIGAomIyPBOP/10vPXWWygpKYHZ3P2fvjFjxkBRFGzcuDGesmf37t1obm7u8DiHw4G5c+di7ty5uOOOOzBmzBh8/fXXOP3000/lbRARERERUS/CfgYRERH1BUwNSkREhnfHHXegsbER3//+97F+/Xrs378f77//PhYuXAhVVU96P6NHj8Yll1yCW265BV9++SU2btyIG2+8EQ6HI/6Yl19+GS+88AK2bduG0tJS/O1vf4PD4cCQIUN64q0REREREVGKsJ9BREREfQEDgUREZHgDBw7EmjVroKoqLrroIkyYMAH33HMPMjMzIctd+yl86aWXMHDgQMyePRtXXHEFbr75ZuTn58f/npmZieeeew5nnXUWJk6ciJUrV+Jf//oXcnJyEv22iIiIiIgohdjPICIior5AEkKIVBeCiIiot3n55Zdxzz33HJWOJxEOHjyIoUOHYtOmTZg8eXLC909ERERERL0T+xlERESUbJwRSEREdAwtLS1wu924//77E7bPb37zmxg/fnzC9kdERERERH0L+xlERESUTJwRSERE1InW1lbU1NQA0NPw5ObmJmS/lZWVCAQCAIDBgwfDarUmZL9ERERERNT7sZ9BREREycZAIBEREREREREREREREZEBMTUoERERERERERERERERkQExEEhERERERERERERERERkQAwEEhERERERERERERERERkQA4FEREREREREREREREREBsRAIBEREREREREREREREZEBMRBIREREREREREREREREZEAMBBIREREREREREREREREZEAOBRERERERERERERERERAb0/wPjXkr9mciadgAAAABJRU5ErkJggg==\n"
+     },
+     "metadata": {},
+     "execution_count": 14
+    }
+   ],
+   "source": [
+    "ff.plot(df, cv_df.drop(columns=[\"cutoff\", \"y\"]), level=[80])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "92a90a1f",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 206
     },
+    "id": "92a90a1f",
+    "outputId": "ef7f5908-1ae5-4aca-f45e-99ffc12a3103"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ff.plot(df=df, forecasts_df=fcst_df)\n"
-      ]
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "      unique_id         ds     cutoff      y         Tabby  Tabby-lo-70  \\\n",
+       "0  Black Friday 2024-09-30 2024-08-31   2607   2049.376953  1885.861084   \n",
+       "1  Black Friday 2024-10-31 2024-08-31   2470   2799.265625  2112.763916   \n",
+       "2  Black Friday 2024-11-30 2024-08-31  11058  17316.138672  6185.125000   \n",
+       "3  Black Friday 2024-12-31 2024-08-31   3548   2613.249512  1982.492188   \n",
+       "4  Black Friday 2025-01-31 2024-08-31   1724   1995.891602  1795.692383   \n",
+       "\n",
+       "    Tabby-hi-70  Tabby-lo-80   Tabby-hi-80  Tabby-lo-90   Tabby-hi-90  \n",
+       "0   2417.204590  1829.213135   3157.957520  1635.378662   4907.942383  \n",
+       "1   6688.913086  1944.557129  10753.810547  1658.874023  15823.072266  \n",
+       "2  30406.574219  4700.687988  31946.658203  3869.626221  36169.101562  \n",
+       "3   9025.923828  1853.736572  11381.388672  1626.874023  17560.091797  \n",
+       "4   2534.376953  1729.608887   3263.395996  1518.588623   5472.529785  "
+      ],
+      "text/html": [
+       "\n",
+       "  <div id=\"df-447285fd-f9b1-4d0d-9a41-b4a31a8f9bfa\" class=\"colab-df-container\">\n",
+       "    <div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>unique_id</th>\n",
+       "      <th>ds</th>\n",
+       "      <th>cutoff</th>\n",
+       "      <th>y</th>\n",
+       "      <th>Tabby</th>\n",
+       "      <th>Tabby-lo-70</th>\n",
+       "      <th>Tabby-hi-70</th>\n",
+       "      <th>Tabby-lo-80</th>\n",
+       "      <th>Tabby-hi-80</th>\n",
+       "      <th>Tabby-lo-90</th>\n",
+       "      <th>Tabby-hi-90</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Black Friday</td>\n",
+       "      <td>2024-09-30</td>\n",
+       "      <td>2024-08-31</td>\n",
+       "      <td>2607</td>\n",
+       "      <td>2049.376953</td>\n",
+       "      <td>1885.861084</td>\n",
+       "      <td>2417.204590</td>\n",
+       "      <td>1829.213135</td>\n",
+       "      <td>3157.957520</td>\n",
+       "      <td>1635.378662</td>\n",
+       "      <td>4907.942383</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Black Friday</td>\n",
+       "      <td>2024-10-31</td>\n",
+       "      <td>2024-08-31</td>\n",
+       "      <td>2470</td>\n",
+       "      <td>2799.265625</td>\n",
+       "      <td>2112.763916</td>\n",
+       "      <td>6688.913086</td>\n",
+       "      <td>1944.557129</td>\n",
+       "      <td>10753.810547</td>\n",
+       "      <td>1658.874023</td>\n",
+       "      <td>15823.072266</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Black Friday</td>\n",
+       "      <td>2024-11-30</td>\n",
+       "      <td>2024-08-31</td>\n",
+       "      <td>11058</td>\n",
+       "      <td>17316.138672</td>\n",
+       "      <td>6185.125000</td>\n",
+       "      <td>30406.574219</td>\n",
+       "      <td>4700.687988</td>\n",
+       "      <td>31946.658203</td>\n",
+       "      <td>3869.626221</td>\n",
+       "      <td>36169.101562</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Black Friday</td>\n",
+       "      <td>2024-12-31</td>\n",
+       "      <td>2024-08-31</td>\n",
+       "      <td>3548</td>\n",
+       "      <td>2613.249512</td>\n",
+       "      <td>1982.492188</td>\n",
+       "      <td>9025.923828</td>\n",
+       "      <td>1853.736572</td>\n",
+       "      <td>11381.388672</td>\n",
+       "      <td>1626.874023</td>\n",
+       "      <td>17560.091797</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Black Friday</td>\n",
+       "      <td>2025-01-31</td>\n",
+       "      <td>2024-08-31</td>\n",
+       "      <td>1724</td>\n",
+       "      <td>1995.891602</td>\n",
+       "      <td>1795.692383</td>\n",
+       "      <td>2534.376953</td>\n",
+       "      <td>1729.608887</td>\n",
+       "      <td>3263.395996</td>\n",
+       "      <td>1518.588623</td>\n",
+       "      <td>5472.529785</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>\n",
+       "    <div class=\"colab-df-buttons\">\n",
+       "\n",
+       "  <div class=\"colab-df-container\">\n",
+       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-447285fd-f9b1-4d0d-9a41-b4a31a8f9bfa')\"\n",
+       "            title=\"Convert this dataframe to an interactive table.\"\n",
+       "            style=\"display:none;\">\n",
+       "\n",
+       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+       "  </svg>\n",
+       "    </button>\n",
+       "\n",
+       "  <style>\n",
+       "    .colab-df-container {\n",
+       "      display:flex;\n",
+       "      gap: 12px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert {\n",
+       "      background-color: #E8F0FE;\n",
+       "      border: none;\n",
+       "      border-radius: 50%;\n",
+       "      cursor: pointer;\n",
+       "      display: none;\n",
+       "      fill: #1967D2;\n",
+       "      height: 32px;\n",
+       "      padding: 0 0 0 0;\n",
+       "      width: 32px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert:hover {\n",
+       "      background-color: #E2EBFA;\n",
+       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+       "      fill: #174EA6;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-buttons div {\n",
+       "      margin-bottom: 4px;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert {\n",
+       "      background-color: #3B4455;\n",
+       "      fill: #D2E3FC;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert:hover {\n",
+       "      background-color: #434B5C;\n",
+       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+       "      fill: #FFFFFF;\n",
+       "    }\n",
+       "  </style>\n",
+       "\n",
+       "    <script>\n",
+       "      const buttonEl =\n",
+       "        document.querySelector('#df-447285fd-f9b1-4d0d-9a41-b4a31a8f9bfa button.colab-df-convert');\n",
+       "      buttonEl.style.display =\n",
+       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+       "\n",
+       "      async function convertToInteractive(key) {\n",
+       "        const element = document.querySelector('#df-447285fd-f9b1-4d0d-9a41-b4a31a8f9bfa');\n",
+       "        const dataTable =\n",
+       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+       "                                                    [key], {});\n",
+       "        if (!dataTable) return;\n",
+       "\n",
+       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+       "          + ' to learn more about interactive tables.';\n",
+       "        element.innerHTML = '';\n",
+       "        dataTable['output_type'] = 'display_data';\n",
+       "        await google.colab.output.renderOutput(dataTable, element);\n",
+       "        const docLink = document.createElement('div');\n",
+       "        docLink.innerHTML = docLinkHtml;\n",
+       "        element.appendChild(docLink);\n",
+       "      }\n",
+       "    </script>\n",
+       "  </div>\n",
+       "\n",
+       "\n",
+       "    </div>\n",
+       "  </div>\n"
+      ],
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "dataframe",
+       "variable_name": "cv_df",
+       "summary": "{\n  \"name\": \"cv_df\",\n  \"rows\": 72,\n  \"fields\": [\n    {\n      \"column\": \"unique_id\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Black Friday\",\n          \"Cyber Monday\",\n          \"Thanksgiving\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"ds\",\n      \"properties\": {\n        \"dtype\": \"date\",\n        \"min\": \"2024-09-30 00:00:00\",\n        \"max\": \"2025-08-31 00:00:00\",\n        \"num_unique_values\": 12,\n        \"samples\": [\n          \"2025-07-31 00:00:00\",\n          \"2025-06-30 00:00:00\",\n          \"2024-09-30 00:00:00\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"cutoff\",\n      \"properties\": {\n        \"dtype\": \"date\",\n        \"min\": \"2024-08-31 00:00:00\",\n        \"max\": \"2024-08-31 00:00:00\",\n        \"num_unique_values\": 1,\n        \"samples\": [\n          \"2024-08-31 00:00:00\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 202403,\n        \"min\": 1108,\n        \"max\": 1338038,\n        \"num_unique_values\": 72,\n        \"samples\": [\n          1724\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          1995.8916015625\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-lo-70\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          1795.6923828125\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-hi-70\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          2534.376953125\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-lo-80\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          1729.60888671875\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-hi-80\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          3263.39599609375\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-lo-90\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          1518.588623046875\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tabby-hi-90\",\n      \"properties\": {\n        \"dtype\": \"float32\",\n        \"num_unique_values\": 72,\n        \"samples\": [\n          5472.52978515625\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+      }
+     },
+     "metadata": {},
+     "execution_count": 15
     }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
+   ],
+   "source": [
+    "cv_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1360b77b",
+   "metadata": {
+    "id": "1360b77b"
+   },
+   "source": [
+    "## Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "a89e2a2a",
+   "metadata": {
+    "id": "a89e2a2a"
+   },
+   "outputs": [],
+   "source": [
+    "from functools import partial\n",
+    "\n",
+    "from utilsforecast.evaluation import evaluate\n",
+    "from utilsforecast.losses import mase, scaled_crps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "e4e806a6",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 81
     },
-    "language_info": {
-      "name": "python",
-      "pygments_lexer": "ipython3"
+    "id": "e4e806a6",
+    "outputId": "cd79717f-1dad-40fd-a410-0636135ed7c5"
+   },
+   "outputs": [
+    {
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": [
+       "metric   mase  scaled_crps\n",
+       "Tabby   1.541        0.214"
+      ],
+      "text/html": [
+       "\n",
+       "  <div id=\"df-b4ac7713-aa8e-4d62-8cc0-07b732687e57\" class=\"colab-df-container\">\n",
+       "    <div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th>metric</th>\n",
+       "      <th>mase</th>\n",
+       "      <th>scaled_crps</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Tabby</th>\n",
+       "      <td>1.541</td>\n",
+       "      <td>0.214</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>\n",
+       "    <div class=\"colab-df-buttons\">\n",
+       "\n",
+       "  <div class=\"colab-df-container\">\n",
+       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b4ac7713-aa8e-4d62-8cc0-07b732687e57')\"\n",
+       "            title=\"Convert this dataframe to an interactive table.\"\n",
+       "            style=\"display:none;\">\n",
+       "\n",
+       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+       "  </svg>\n",
+       "    </button>\n",
+       "\n",
+       "  <style>\n",
+       "    .colab-df-container {\n",
+       "      display:flex;\n",
+       "      gap: 12px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert {\n",
+       "      background-color: #E8F0FE;\n",
+       "      border: none;\n",
+       "      border-radius: 50%;\n",
+       "      cursor: pointer;\n",
+       "      display: none;\n",
+       "      fill: #1967D2;\n",
+       "      height: 32px;\n",
+       "      padding: 0 0 0 0;\n",
+       "      width: 32px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert:hover {\n",
+       "      background-color: #E2EBFA;\n",
+       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+       "      fill: #174EA6;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-buttons div {\n",
+       "      margin-bottom: 4px;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert {\n",
+       "      background-color: #3B4455;\n",
+       "      fill: #D2E3FC;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert:hover {\n",
+       "      background-color: #434B5C;\n",
+       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+       "      fill: #FFFFFF;\n",
+       "    }\n",
+       "  </style>\n",
+       "\n",
+       "    <script>\n",
+       "      const buttonEl =\n",
+       "        document.querySelector('#df-b4ac7713-aa8e-4d62-8cc0-07b732687e57 button.colab-df-convert');\n",
+       "      buttonEl.style.display =\n",
+       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+       "\n",
+       "      async function convertToInteractive(key) {\n",
+       "        const element = document.querySelector('#df-b4ac7713-aa8e-4d62-8cc0-07b732687e57');\n",
+       "        const dataTable =\n",
+       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+       "                                                    [key], {});\n",
+       "        if (!dataTable) return;\n",
+       "\n",
+       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+       "          + ' to learn more about interactive tables.';\n",
+       "        element.innerHTML = '';\n",
+       "        dataTable['output_type'] = 'display_data';\n",
+       "        await google.colab.output.renderOutput(dataTable, element);\n",
+       "        const docLink = document.createElement('div');\n",
+       "        docLink.innerHTML = docLinkHtml;\n",
+       "        element.appendChild(docLink);\n",
+       "      }\n",
+       "    </script>\n",
+       "  </div>\n",
+       "\n",
+       "\n",
+       "    </div>\n",
+       "  </div>\n"
+      ],
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "dataframe",
+       "summary": "{\n  \"name\": \")\",\n  \"rows\": 1,\n  \"fields\": [\n    {\n      \"column\": \"mase\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": null,\n        \"min\": 1.541,\n        \"max\": 1.541,\n        \"num_unique_values\": 1,\n        \"samples\": [\n          1.541\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"scaled_crps\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": null,\n        \"min\": 0.214,\n        \"max\": 0.214,\n        \"num_unique_values\": 1,\n        \"samples\": [\n          0.214\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+      }
+     },
+     "metadata": {},
+     "execution_count": 17
     }
+   ],
+   "source": [
+    "eval_df = evaluate(\n",
+    "    cv_df.drop(columns=[\"cutoff\"]),\n",
+    "    train_df=df.query(\"ds <= '2024-08-31'\"),\n",
+    "    metrics=[partial(mase, seasonality=12), scaled_crps],\n",
+    "    level=level,\n",
+    ")\n",
+    "eval_df.groupby(\"metric\").mean(numeric_only=True).T.sort_values(\n",
+    "    by=\"scaled_crps\"\n",
+    ").round(3)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  },
+  "colab": {
+   "provenance": [],
+   "gpuType": "T4"
   },
-  "nbformat": 4,
-  "nbformat_minor": 5
+  "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
 }

From a1d7a3ff1ca4e4e6d9693028257c8e0494b79cc8 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:44:20 -0600
Subject: [PATCH 09/10] docs(readme): add Huawei Noah's Ark Lab logo for Tabby

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ed503a3..830cb75 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ Pass any Hugging Face `repo_id` (or local checkpoint path) supported by the unde
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/ibm.png" width="28" alt="IBM"> | [PatchTST-FM](https://arxiv.org/abs/2602.06909) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-SA-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/thuml.png" width="28" alt="THUML"> | [Sundial](https://arxiv.org/abs/2502.00816) | ✓ | ✓ | ✓ | ✓ | | | Apache-2.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tfc.png" width="28" alt="The Forecasting Company"> | [T0](https://huggingface.co/theforecastingcompany/t0-alpha) | ✓ | ✓ | ✓ | ✓ | ✓ | | Apache-2.0† |
-| Huawei Paris Noah | [Tabby](https://arxiv.org/abs/2609.13956) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-4.0 |
+| <img src="https://cdn-avatars.huggingface.co/v1/production/uploads/66f4159b7b9d607cb86a290e/tEnZ8EK_a91sBIVH9x5M6.png" width="28" alt="Huawei Paris Noah's Ark Lab"> | [Tabby](https://arxiv.org/abs/2609.13956) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/priorlabs.png" width="28" alt="Prior Labs"> | [TabPFN](https://arxiv.org/abs/2501.02945) | ✓ | ✓ | ✓ | ✓ | | | TabPFN NC‡ |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tafsut.png" width="28" alt="Tafsut"> | [Tafsut](https://github.com/Tafsut-FM/tafsut) | ✓ | ✓ | ✓ | ✓ | | | MIT |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/nx-ai.png" width="28" alt="NX-AI"> | [TiRex](https://arxiv.org/abs/2505.23719) | ✓ | ✓ | ✓ | ✓ | ✓¶ | | Community / Apache-2.0 |

From 0ed95e04979eb26bb9e65792d24366a0a6353835 Mon Sep 17 00:00:00 2001
From: AzulGarza <fede.garza.ramirez@gmail.com>
Date: Mon, 26 Oct 2026 15:45:44 -0600
Subject: [PATCH 10/10] docs(readme): host Tabby logo on S3

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 830cb75..8b3f17e 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ Pass any Hugging Face `repo_id` (or local checkpoint path) supported by the unde
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/ibm.png" width="28" alt="IBM"> | [PatchTST-FM](https://arxiv.org/abs/2602.06909) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-SA-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/thuml.png" width="28" alt="THUML"> | [Sundial](https://arxiv.org/abs/2502.00816) | ✓ | ✓ | ✓ | ✓ | | | Apache-2.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tfc.png" width="28" alt="The Forecasting Company"> | [T0](https://huggingface.co/theforecastingcompany/t0-alpha) | ✓ | ✓ | ✓ | ✓ | ✓ | | Apache-2.0† |
-| <img src="https://cdn-avatars.huggingface.co/v1/production/uploads/66f4159b7b9d607cb86a290e/tEnZ8EK_a91sBIVH9x5M6.png" width="28" alt="Huawei Paris Noah's Ark Lab"> | [Tabby](https://arxiv.org/abs/2609.13956) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-4.0 |
+| <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/huawei-noah.png" width="28" alt="Huawei Paris Noah's Ark Lab"> | [Tabby](https://arxiv.org/abs/2609.13956) | ✓ | ✓ | ✓ | ✓ | | | CC-BY-NC-4.0 |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/priorlabs.png" width="28" alt="Prior Labs"> | [TabPFN](https://arxiv.org/abs/2501.02945) | ✓ | ✓ | ✓ | ✓ | | | TabPFN NC‡ |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/tafsut.png" width="28" alt="Tafsut"> | [Tafsut](https://github.com/Tafsut-FM/tafsut) | ✓ | ✓ | ✓ | ✓ | | | MIT |
 | <img src="https://timecopilot.s3.amazonaws.com/public/data/images/logos/nx-ai.png" width="28" alt="NX-AI"> | [TiRex](https://arxiv.org/abs/2505.23719) | ✓ | ✓ | ✓ | ✓ | ✓¶ | | Community / Apache-2.0 |