diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 622590d..9a62df5 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -41,7 +41,7 @@ source .venv/bin/activate Install the project together with development dependencies: ```bash -uv sync --all-groups +uv sync --all-extras ``` --- @@ -63,8 +63,8 @@ We use **Ruff** for linting and formatting. Before committing, run: ```bash -ruff check . -ruff format . +ruff check bensemble/ tests/ benchmarks/ +ruff format bensemble/ tests/ benchmarks/ ``` --- diff --git a/README.md b/README.md index afc1c61..ef16f3e 100644 --- a/README.md +++ b/README.md @@ -128,14 +128,14 @@ print(f"Prediction: {mean[0].item():.2f} ± {std[0].item():.2f}") ## Algorithms & Demos -We implement a wide range of Bayesian and Ensembling approaches. Check out the interactive demos in the `notebooks/` directory: +We implement a wide range of Bayesian and Ensembling approaches. Check out the interactive demos in the `examples/` directory: | Method | Description | | :--- | :--- | | **Deep Ensembles** | Naive yet powerful ensembling of independent networks with explicit uncertainty decomposition. | | **Monte Carlo Dropout** | Implicit ensembling by keeping dropout active at test time. | | **Neural Ensemble Search (NES)** | Automatically searches for diverse architectures (NES-RS/NES-RE). | -| **NES via Bayesian Sampling** | Extracts diverse subnetworks from a Supernet using Stein Variational Gradient Descent (SVGD). | +| **NES via Bayesian Sampling** | Selects a diverse ensemble from a pool of trained candidates using a validation-loss posterior and SVGD-inspired repulsion. | | **Variational Inference** | Approximates posterior using Gaussian distributions with the *Local Reparameterization Trick*. | | **Variational Rényi** | Generalization of VI minimizing $\alpha$-divergence (VR-VI) for better robustness. | | **Laplace Approximation** | Fits a Gaussian around the MAP estimate using Kronecker-Factored Curvature (K-FAC). | diff --git a/blog/bensemble-blogpost.md b/blog/bensemble-blogpost.md index 73d099a..a4042b0 100644 --- a/blog/bensemble-blogpost.md +++ b/blog/bensemble-blogpost.md @@ -265,7 +265,7 @@ This is approximated by Monte Carlo using samples $\boldsymbol{\theta}^{(k)}$ dr Qualitatively, this gives a knob that controls how aggressive or conservative the variational approximation is. Once trained, sampling networks is as simple as drawing from the Gaussian $q(\boldsymbol{\theta})$ and plugging the sampled weights into the base model, just as in PVI. -Variational Rényi inference is implemented in the `VariationalRenyi` class in Bensemble. Visit our [variational Rényi demo](https://github.com/intsystems/bensemble/blob/master/notebooks/variatinal_renyi_demo.ipynb) for an example on how to use it. +Variational Rényi inference is available in Bensemble by passing `alpha` to `VariationalLoss` on top of the same Bayesian layers. See the [Variational Rényi page](https://intsystems.github.io/bensemble/algorithms/variational-renyi/) for details. ### Laplace approximation [Laplace approximation (LA)](https://openreview.net/pdf?id=Skdvd2xAZ) starts from a different point. Instead of designing a Bayesian method from scratch, you begin with a network that has already been trained in the usual deterministic way, with weight decay capturing the prior. Let @@ -329,7 +329,7 @@ $$ The end result is a factorized Gaussian over weights plus Gamma distributions over hyperparameters. From that, sampling full networks is straightforward: draw weights from the Gaussians, plug them into a standard multilayer perceptron, and you have a concrete ensemble member. -PBP is implemented in the `ProbabilisticBackpropagation` class in Bensemble. For an example on how to use it, check out our [probabilistic backpropagation demo](https://github.com/intsystems/bensemble/blob/master/notebooks/pbp_probabilistic_backpropagation_test.ipynb). +PBP is implemented in the `PBPEngine` class in Bensemble. For an example on how to use it, see the [Probabilistic Backpropagation page](https://intsystems.github.io/bensemble/algorithms/pbp/). ### Neural Ensemble Search diff --git a/docs/docs/algorithms/laplace.md b/docs/docs/algorithms/laplace.md index 3ef673a..d9722b2 100644 --- a/docs/docs/algorithms/laplace.md +++ b/docs/docs/algorithms/laplace.md @@ -4,13 +4,13 @@ A scalable Laplace approximation using Kronecker-Factored Approximate Curvature. Since this is a post-hoc method, a standard deterministic network is first trained to find the MAP estimate $W^{\text{MAP}}_l$. We then capture the covariance of activations ($A_l$) and pre-activation gradients ($G_l$). -The posterior for layer $l$ is then approximated as a matrix normal distribution $\mathcal{MN}(W^{\text{MAP}}_l, A_l, G_l)$. Samples are generated efficiently using the Cholesky decomposition of Kronecker factors: +The posterior for layer $l$ is then approximated as a matrix normal distribution $\mathcal{MN}(W^{\text{MAP}}_l, A_l, G_l)$. Samples are generated from the two Kronecker factors independently: $$ W_{\text{sample}} = W_{\text{MAP}} + L_V Z L_U^T $$ -where $L_V, L_U$ are Cholesky factors of the inverse regularized covariances and $Z$ is sampled from the standard matrix normal distribution. +where $L_V, L_U$ are symmetric square roots of the inverse regularized covariances, computed by eigendecomposition with the eigenvalues clamped from below for stability, and $Z$ is sampled from the standard matrix normal distribution. --- diff --git a/docs/docs/algorithms/nesbs.md b/docs/docs/algorithms/nesbs.md index 71f9ebc..dc1be0e 100644 --- a/docs/docs/algorithms/nesbs.md +++ b/docs/docs/algorithms/nesbs.md @@ -2,18 +2,24 @@ To reduce the prohibitive computational cost of standard NES, one can use Neural Ensemble Search via Bayesian Sampling. -It utilizes training a Supernet with uniform path sampling to share weights across different model architectures. A variational posterior over architectures $p_\alpha(\mathcal{A}) \approx p(\mathcal{A}|\mathcal{D})$ is learned via ELBO minimization. +The original method trains a Supernet with weight sharing and learns a variational posterior over architectures. `bensemble` implements a discrete, pool-based version of that idea instead: `NESBayesianSampler` draws `pool_size` architectures from the `SearchSpace`, trains each one independently with the user's `train_fn`, and scores it on a validation set. The scores define a posterior over the pool, -Ensemble member architectures can then be sampled from the variational posterior using two methods: +$$ +p(\mathcal{A}_i \mid \mathcal{D}) \propto \exp\!\left(-\frac{s_i - \min_j s_j}{T}\right), +$$ + +where $s_i$ is the validation loss of candidate $i$ and $T$ is the `temperature`. + +Ensemble members are then selected from the pool in one of two ways: -- **Monte-Carlo Sampling**: Simple random sampling from the posterior. -- **SVGD-RD**: Stein Variational Gradient Descent with Regularized Diversity. This uses controlled optimization of the set of architectures with the following objective: +- **Monte-Carlo Sampling** (`sample_mc`): draw `ensemble_size` candidates from the posterior. +- **SVGD-inspired sampling** (`sample_svgd`): a greedy, particle-style selection over the pool. Each candidate's posterior probability is traded off against a repulsion term measuring how similar its validation predictions are to those of the members already chosen, so the selected set is pushed towards architectures that disagree with each other. $$ q^* = \arg\min_{q\in\mathcal{Q}} \text{KL}(q\|p) + n\delta\mathbb{E}_{x, x' \sim q}[k(x, x')] $$ -This repulsive force mathematically ensures that the sampled architectures are highly diverse. +The objective above is the one the original paper optimizes with Stein Variational Gradient Descent; here it motivates the repulsion heuristic rather than being solved exactly. --- diff --git a/docs/docs/algorithms/variational-renyi.md b/docs/docs/algorithms/variational-renyi.md index f9d9a80..f5d0d6a 100644 --- a/docs/docs/algorithms/variational-renyi.md +++ b/docs/docs/algorithms/variational-renyi.md @@ -2,7 +2,7 @@ This method generalizes the standard ELBO using $\alpha$-Rényi divergence. -Unlike VI implementation with LRT, here explicit weights $w \sim \mathcal{N}(\mu, \text{softplus}(\rho))$ are sampled using weight perturbation during the forward pass. The objective is defined as: +It uses the same Bayesian layers as [Variational Inference](variational-inference.md), so weights are still sampled with the Local Reparameterization Trick; only the objective changes. Pass `alpha` to `VariationalLoss` and feed it $K$ stochastic forward passes stacked along the first dimension. The objective is defined as: $$ \mathcal{L}_{\text{VR}}(\theta, \alpha) = -\frac{1}{1-\alpha} \log \frac{1}{K} \sum_{k=1}^K \left( \frac{p(\mathcal{D}, w_k)}{q_\theta(w_k)} \right)^{1-\alpha} diff --git a/docs/docs/index.md b/docs/docs/index.md index 7712c86..95e5e10 100644 --- a/docs/docs/index.md +++ b/docs/docs/index.md @@ -51,6 +51,6 @@ hide: --- - Algorithms to automatically search for diverse architectures using NNI and Stein Variational Gradient Descent. + Algorithms to automatically search for diverse architectures, including random search, regularized evolution and SVGD-inspired Bayesian sampling. diff --git a/docs/docs/user-guide/basic-concepts.md b/docs/docs/user-guide/basic-concepts.md index 093f358..d964855 100644 --- a/docs/docs/user-guide/basic-concepts.md +++ b/docs/docs/user-guide/basic-concepts.md @@ -9,4 +9,4 @@ Everything revolves around the `Ensemble` class. It acts as a manager for multip - **Explicit Ensembles**: A collection of different models (e.g., from NAS or Deep Ensembles). - **Implicit Ensembles**: A single model that behaves like an ensemble (e.g., MC Dropout or Bayesian layers). -Regardless of the source, an `Ensemble` always returns a tensor of shape `[M, Batch, Output]`, where `M` is the number of ensemble members. +Regardless of the source, `ensemble.predict_members(x)` returns a tensor of shape `[M, Batch, Output]`, where `M` is the number of ensemble members, and calling `ensemble(x)` returns the combined prediction of shape `[Batch, Output]` (the mean by default). diff --git a/docs/docs/user-guide/calibration-and-metrics.md b/docs/docs/user-guide/calibration-and-metrics.md index 400b9c8..2af453c 100644 --- a/docs/docs/user-guide/calibration-and-metrics.md +++ b/docs/docs/user-guide/calibration-and-metrics.md @@ -27,7 +27,7 @@ scaler = VectorScaling(num_classes=3).fit(val_logits, val_labels) probs = torch.softmax(scaler(test_logits), dim=-1) ``` -For an ensemble, fit the scaler on the logits you actually evaluate, whether that is the per-member output of `predict_members` or its mean. +Both scalers expect a 2-D `[N, num_classes]` tensor. For an ensemble, fit the scaler on the logits you actually evaluate — typically the member average, `ensemble.predict_members(x).mean(0)` or simply `ensemble(x)` — rather than on the stacked `[M, N, num_classes]` member outputs. ## Scoring rules diff --git a/examples/pbp_probabilistic_backpropagation_test.ipynb b/examples/pbp_probabilistic_backpropagation_test.ipynb deleted file mode 100644 index 6971176..0000000 --- a/examples/pbp_probabilistic_backpropagation_test.ipynb +++ /dev/null @@ -1,305 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "50e23394", - "metadata": {}, - "source": [ - "# Probabilistic Backpropagation Demo on Housing Benchmark\n", - "This is a demo of the Probabilistic Backpropogation algorithm implemented in the `ProbabilisticBackpropagation` class in Bensemble. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b8dbb7b2-18a6-4a44-a595-d73946d1ad9c", - "metadata": {}, - "outputs": [], - "source": [ - "!pip install scikit-learn pandas" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "497e8cd9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running on cuda with seed 7\n" - ] - } - ], - "source": [ - "import math\n", - "import pathlib\n", - "import sys\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "from torch.utils.data import DataLoader, TensorDataset\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.preprocessing import StandardScaler\n", - "\n", - "sys.path.append(str(pathlib.Path(\"../..\").resolve()))\n", - "from bensemble.methods.probabilistic_backpropagation import ProbabilisticBackpropagation\n", - "\n", - "torch.set_default_dtype(torch.float64)\n", - "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "SEED = 7\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "if torch.cuda.is_available():\n", - " torch.cuda.manual_seed_all(SEED)\n", - "\n", - "print(f\"Running on {DEVICE} with seed {SEED}\")" - ] - }, - { - "cell_type": "markdown", - "id": "dc9158d8-859f-4f40-89e2-dc64e1e7e04c", - "metadata": {}, - "source": [ - "## Testing" - ] - }, - { - "cell_type": "markdown", - "id": "27322600-d9f8-4c30-b813-90c8a5ee5841", - "metadata": {}, - "source": [ - "We will test the `ProbabilisticBackpropagation` implementation using the Boston housing-style dataset from our [benchmark demo](https://github.com/intsystems/bensemble/blob/master/notebooks/benchmark.ipynb) `benchmark.ipynb`." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "8473ca31", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(506, 14)\n", - "Train size: 404, Test size: 102\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "<>:10: SyntaxWarning: invalid escape sequence '\\s'\n", - "<>:10: SyntaxWarning: invalid escape sequence '\\s'\n", - "C:\\Users\\jommm\\AppData\\Local\\Temp\\ipykernel_20760\\3803673090.py:10: SyntaxWarning: invalid escape sequence '\\s'\n", - " df = pd.read_csv(DATA_PATH, sep='\\s+', header=None, names=COLUMN_NAMES)\n" - ] - } - ], - "source": [ - "DATA_CANDIDATES = [\n", - " pathlib.Path(\"data/housing.data\"),\n", - " pathlib.Path(\"../data/housing.data\"),\n", - " pathlib.Path(\"../../benchmark/data/housing.data\"),\n", - "]\n", - "DATA_PATH = next((p for p in DATA_CANDIDATES if p.exists()), None)\n", - "if DATA_PATH is None:\n", - " raise FileNotFoundError(\"housing.data not found in known locations\")\n", - "COLUMN_NAMES = [\n", - " \"CRIM\",\n", - " \"ZN\",\n", - " \"INDUS\",\n", - " \"CHAS\",\n", - " \"NOX\",\n", - " \"RM\",\n", - " \"AGE\",\n", - " \"DIS\",\n", - " \"RAD\",\n", - " \"TAX\",\n", - " \"PTRATIO\",\n", - " \"B\",\n", - " \"LSTAT\",\n", - " \"MEDV\",\n", - "]\n", - "\n", - "df = pd.read_csv(DATA_PATH, sep=\"\\s+\", header=None, names=COLUMN_NAMES)\n", - "print(df.shape)\n", - "\n", - "TARGET_COL = \"MEDV\"\n", - "TEST_SIZE = 0.2\n", - "X = df.drop(columns=[TARGET_COL]).values.astype(np.float32)\n", - "y = df[TARGET_COL].values.astype(np.float32).reshape(-1, 1)\n", - "\n", - "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y, test_size=TEST_SIZE, random_state=SEED\n", - ")\n", - "\n", - "x_scaler = StandardScaler()\n", - "y_scaler = StandardScaler()\n", - "X_train_scaled = x_scaler.fit_transform(X_train).astype(np.float32)\n", - "X_test_scaled = x_scaler.transform(X_test).astype(np.float32)\n", - "y_train_scaled = y_scaler.fit_transform(y_train).astype(np.float32)\n", - "y_test_scaled = y_scaler.transform(y_test).astype(np.float32)\n", - "\n", - "train_tensor_x = torch.from_numpy(X_train_scaled)\n", - "train_tensor_y = torch.from_numpy(y_train_scaled)\n", - "test_tensor_x = torch.from_numpy(X_test_scaled)\n", - "test_tensor_y = torch.from_numpy(y_test_scaled)\n", - "\n", - "BATCH_SIZE = 64\n", - "train_loader = DataLoader(\n", - " TensorDataset(train_tensor_x, train_tensor_y), batch_size=BATCH_SIZE, shuffle=True\n", - ")\n", - "test_loader = DataLoader(\n", - " TensorDataset(test_tensor_x, test_tensor_y),\n", - " batch_size=len(test_tensor_x),\n", - " shuffle=False,\n", - ")\n", - "\n", - "Y_SCALE = float(y_scaler.scale_[0])\n", - "Y_MEAN = float(y_scaler.mean_[0])\n", - "y_test_true = y_test.reshape(-1)\n", - "print(f\"Train size: {len(train_tensor_x)}, Test size: {len(test_tensor_x)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "649d871a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.3682809469879644, 0.36836619896285056, 0.36872475628900075]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pbp = ProbabilisticBackpropagation(\n", - " layer_sizes=[train_tensor_x.shape[1], 64, 1], device=DEVICE\n", - ")\n", - "history = pbp.fit(train_loader, num_epochs=80, step_clip=2.0, prior_refresh=1)\n", - "history[\"train_rmse\"][-3:]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "8fff3071", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Test RMSE (original scale): 5.5321\n", - "Test NLPD (original scale): 3.4671\n", - "Estimated noise variance (scaled): 0.1332\n" - ] - } - ], - "source": [ - "with torch.no_grad():\n", - " # Predict on the full test set (scaled)\n", - " test_batch = next(iter(test_loader))[0].to(DEVICE, dtype=torch.float64)\n", - " mean_scaled, samples_scaled = pbp.predict(test_batch, n_samples=200)\n", - " _, var_scaled = pbp._predictive_mean_var(test_batch)\n", - "\n", - "# Convert predictions back to original scale\n", - "mean_np = y_scaler.inverse_transform(mean_scaled.cpu().numpy()).reshape(-1)\n", - "var_np = var_scaled.cpu().numpy().reshape(-1) * (Y_SCALE**2)\n", - "samples_np = y_scaler.inverse_transform(\n", - " samples_scaled.cpu().numpy().reshape(samples_scaled.shape[0], -1)\n", - ")\n", - "rmse = float(np.sqrt(np.mean((mean_np - y_test_true) ** 2)))\n", - "nlpd = float(\n", - " 0.5\n", - " * np.mean(np.log(2 * math.pi * var_np) + ((y_test_true - mean_np) ** 2) / var_np)\n", - ")\n", - "assert rmse < 6.0, f\"RMSE too high: {rmse}\"\n", - "assert float(np.var(samples_np)) > 0.0\n", - "print(f\"Test RMSE (original scale): {rmse:.4f}\")\n", - "print(f\"Test NLPD (original scale): {nlpd:.4f}\")\n", - "print(f\"Estimated noise variance (scaled): {pbp.noise_variance().item():.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "119ba99f", - "metadata": {}, - "source": [ - "## Sampling concrete models\n", - "We can sample deterministic networks from the posterior approximation to inspect epistemic uncertainty." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "02952542", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sampled-model RMSE: 5.5416\n", - "Epistemic variance (mean over test): 0.0742\n" - ] - } - ], - "source": [ - "with torch.no_grad():\n", - " test_x = test_tensor_x.to(DEVICE, dtype=torch.float64)\n", - " sampled_models = pbp.sample_models(n_models=20)\n", - " sampled_preds = []\n", - " for sm in sampled_models:\n", - " sm = sm.to(DEVICE)\n", - " outputs = sm(test_x).cpu().numpy() # scaled space\n", - " sampled_preds.append(outputs)\n", - "\n", - "# Back to original scale for metrics\n", - "sampled_preds = np.stack(sampled_preds, axis=0) # (S, N, 1)\n", - "sampled_preds_orig = np.stack(\n", - " [y_scaler.inverse_transform(p.reshape(-1, 1)).reshape(-1) for p in sampled_preds],\n", - " axis=0,\n", - ")\n", - "mean_pred = sampled_preds_orig.mean(axis=0)\n", - "epistemic_var = sampled_preds_orig.var(axis=0)\n", - "rmse_samples = float(np.sqrt(np.mean((mean_pred - y_test_true) ** 2)))\n", - "print(f\"Sampled-model RMSE: {rmse_samples:.4f}\")\n", - "print(f\"Epistemic variance (mean over test): {float(epistemic_var.mean()):.4f}\")\n", - "assert float(epistemic_var.mean()) > 0.0" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "windows_env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/variatinal_renyi_demo.ipynb b/examples/variatinal_renyi_demo.ipynb deleted file mode 100644 index 6140dbe..0000000 --- a/examples/variatinal_renyi_demo.ipynb +++ /dev/null @@ -1,455 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "38c63afb-afb6-40b7-8db2-a8b4ae63859d", - "metadata": {}, - "source": [ - "# Variational Inference with Renyi Divergence" - ] - }, - { - "cell_type": "markdown", - "id": "18046012-20d5-4897-9847-b03b36547211", - "metadata": {}, - "source": [ - "This is a demo of a modification of the variational inference algorithm that uses Renyi divergence, implemented in the `VariationalRenyi` class in Bensemble. For more information about this method, please check out the original paper about this method, [\"Rényi Divergence Variational Inference\"](https://arxiv.org/abs/1602.02311) by Yingzhen Li and Richard E. Turner (2016)." - ] - }, - { - "cell_type": "markdown", - "id": "f6ccd032-1bbb-46f8-90d7-93620b946807", - "metadata": {}, - "source": [ - "## Prerequisites" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "f40284f0", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import matplotlib.pyplot as plt\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "\n", - "from bensemble.methods.variational_renyi import VariationalRenyi" - ] - }, - { - "cell_type": "markdown", - "id": "9f600f93", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Synthetic data generation\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4d442279", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def make_synthetic(n=300, noise=0.1):\n", - " X = torch.linspace(-3, 3, n).unsqueeze(1)\n", - " y = torch.sin(X) + noise * torch.randn_like(X)\n", - " return X, y\n", - "\n", - "\n", - "X, y = make_synthetic()\n", - "\n", - "plt.figure(figsize=(7, 4))\n", - "plt.scatter(X, y, s=10)\n", - "plt.title(\"Synthetic dataset: sin(x) + noise\")\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d94a1efc", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Model\n", - "------------------------------------------------------------\n", - "We'll use a simple NN model as the base for our ensemble." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fea594d5", - "metadata": {}, - "outputs": [], - "source": [ - "class SimpleNet(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.net = nn.Sequential(\n", - " nn.Linear(1, 64),\n", - " nn.ReLU(),\n", - " nn.Linear(64, 64),\n", - " nn.ReLU(),\n", - " nn.Linear(64, 1),\n", - " )\n", - "\n", - " def forward(self, x):\n", - " return self.net(x)" - ] - }, - { - "cell_type": "markdown", - "id": "94ad3d85", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Basic VR training (α = 1, 0.5, 2.0)\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8419b12b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "=== Training VR with α = 1.0 ===\n", - "\n", - "=== Training VR with α = 0.5 ===\n", - "\n", - "=== Training VR with α = 2.0 ===\n" - ] - } - ], - "source": [ - "train_loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)\n", - "\n", - "alphas = [1.0, 0.5, 2.0] # VI, \"fat tail\", conservative\n", - "models = {}\n", - "histories = {}\n", - "\n", - "for alpha in alphas:\n", - " print(f\"\\n=== Training VR with α = {alpha} ===\")\n", - "\n", - " model = SimpleNet()\n", - " vr = VariationalRenyi(model, alpha=alpha, initial_rho=-3.0)\n", - "\n", - " hist = vr.fit(train_loader, num_epochs=250, lr=5e-4, n_samples=5)\n", - "\n", - " models[alpha] = vr\n", - " histories[alpha] = hist" - ] - }, - { - "cell_type": "markdown", - "id": "cec218c7", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Visualization of uncertainty distribution\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "80cb781a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/QAAAIjCAYAAACtaVBBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYW+WV/l/1Nr15Zuxx7x2b3gkQIEAC6ZBsaGGz2TTCZrNh978JpG7JpmxClk0hhASyhAQICSW00I3B2IBtcC9jT2/q7V7p/p/zaTSeGWu6ZiTNvD8/nyVdXUlXV1ea+37nnPeYDMMwQAghhBBCCCGEkILCnOsNIIQQQgghhBBCyNihoCeEEEIIIYQQQgoQCnpCCCGEEEIIIaQAoaAnhBBCCCGEEEIKEAp6QgghhBBCCCGkAKGgJ4QQQgghhBBCChAKekIIIYQQQgghpAChoCeEEEIIIYQQQgoQCnpCCCGEEEIIIaQAoaAnhBCSNebPn49rr7227/azzz4Lk8mkLrOFPN+tt96atecj+U0+ft579+7Fu9/9bpSWlqrte+ihh6Z8GzJ9t+S7J9/B/gSDQXzyk59EbW2tWv+mm25Sy9va2vDBD34QlZWVavkPfvCDKX8PhBBCJg4FPSGETBPuuusudWKeHk6nE0uXLsVnP/tZdfJeSDz66KN5J+KmmnPPPRerV6/OeF9nZ2deCt3B3HvvvTkVit/+9rcnRWxfc8012L59O771rW/h17/+NU488UTkK7IP5Lfh05/+tNrWv/mbv1HLv/jFL+Ivf/kLbrnlFrX84osvRr7yk5/8RL0HQgghx2PNsIwQQkgB8/Wvfx0LFixANBrFiy++iP/5n/9RAnnHjh1wu91Tui1nn302IpEI7Hb7mB4n23v77bdnFKzyfFYr/3wVAiLo5bhLR4XHw0Q+bxGzEoW+4oorxv36mbZn06ZN+Jd/+Rc1WZZP/OxnP0MymRyw7JlnnsGpp56Kr33ta8ctf9/73ocvfelLyHdE0FdVVQ3I/iGEEJKCEXpCCJlmXHLJJfj4xz+u0mwlqiVi6uDBg/jjH/845GNCodCkbIvZbFaZAnKZLeT5CkXQHzp0KOslB4VANo+nfPu8Ozo61GVZWVne7S+bzQaHwzFgWXt7e8ZtHWr5eNF1HfF4PGvPRwghZHRQ0BNCyDTnXe96l7oUUS9IlKuoqAj79+/He97zHhQXF+NjH/uYuk+ie5IivWrVKiWkZs2ahU996lPo6ekZ8JyGYeCb3/wm5syZo6L+5513Hnbu3Hncaw9VQ79582b12uXl5fB4PFi7di1++MMf9m2fROeF/iUEaTKlmm/btk1NZJSUlKj3dv755+OVV17JWJLw0ksv4eabb0Z1dbV67SuvvLJPpKXZsmULLrroIhUVdLlcKuPh+uuvRz4j+0Te3759+9Q+FLEmNd7XXXcdwuHwcev/5je/wcknn6w+P/kcJJviiSeeGLDOY489hrPOOkvtJzlOLr300uM+56GOJykZeOSRR3D48OG+zzBd3y3C76tf/So2btyotlGeX17nr3/963HbOfjzHu37lHVEKP/qV7/qe31ZX15Drj/44IMZMwrkPonAD7WP582bp67/4z/+44D3NNbj8LnnnsPf//3fo6amRn2PhuPo0aMqy0D2k6wv6fKxWOy49frX0Ke/e/K9l88hvQ/Sry/fYfmeDf5+eb1eNQnY0NCgJgcWL16Mf//3fx8Q+U9PVH33u99VvxeLFi1S67799tvq/l27dqnMiIqKCvU7IiUJDz/88Li+j/J+5JiT/ZXeVjm2hqO7u1t9X+W4lnHVVVep3zApv5DtEV8BQgiZLuTPlDchhJBJQYSWIOZX/aNpIljPPPNMdVKeTsUX8S4n2iKOPv/5zysx8OMf/1gJFTnxlgigIGJMBL0IOBlbt25VJmGjidA9+eSTuOyyy1BXV4cvfOELyqzrnXfewZ///Gd1W7ahublZrSe1vSMhJ/siBkVEffnLX1bb+L//+7/qpF9EwCmnnDJg/c997nPqJF9SkEWYiCCR1On77ruvL3Ip70UExle+8hUlGGW9Bx54AIXAhz/8YTUB8Z3vfEd9Lj//+c+VCBRRlua2225T4vT0009XJRpSEiGTLJKGLe9dkH0vteJynMhjRSxL+YYcM3I89BeymY4n+Vx9Pp8So9///vfVeiJyBb/fr7ZLhNaNN96IQCCAX/ziF+o5Xn31Vaxfv37C71O2X7JUZNLib//2b9UyEZ6Sfi5i9Z577lHisT+yTNY57bTTMr7m+9//fnU8iKCWbZdjP/2exnocipiXY0y+S8NF6CXFXyYGGhsb1Xeyvr5evTf5rIZjxYoVaj3ZVpkw+Id/+Ae1/IQTTuirpb/wwgvxiU98ou8x8hmfc845aGpqUt/DuXPn4uWXX1Z19i0tLcf5Ifzyl79UpT2yf0XQi4CX/XDGGWdg9uzZ6vsjIv13v/udmpD4wx/+cNw+H+n7KLdlHdnPUuYgyETjUMhvkLyv3bt3930OcozI/pbjXD6P9GdGCCHTAoMQQsi04Je//KUhP+tPPfWU0dHRYRw5csT4v//7P6OystJwuVzG0aNH1XrXXHONWu8rX/nKgMe/8MILavk999wzYPnjjz8+YHl7e7tht9uNSy+91Egmk33r/fM//7NaT54/zV//+le1TC4FXdeNBQsWGPPmzTN6enoGvE7/5/rMZz6jHpcJWf61r32t7/YVV1yhtmf//v19y5qbm43i4mLj7LPPPm7/XHDBBQNe64tf/KJhsVgMr9erbj/44INqvddee82YKAcPHhzw/sfCOeecY6xatSrjffL5Dt4Pcl2WXX/99QPWvfLKK9UxkGbv3r2G2WxWyxOJxIB10/slEAgYZWVlxo033jjg/tbWVqO0tHTA8qGOJ0GOEfmsByPHQSwWG7BMjodZs2Ydt/3jfZ+Cx+MZcDymueWWWwyHw9H3maePa6vVOuC1hvtM//M//3PA8rEeh2eeeabaDyPxgx/8QK3/u9/9rm9ZKBQyFi9efNyxJe918P6W2/I5DEYeK9+z/nzjG99Q+2zPnj0DlstnK9+RxsbGAfugpKRE7bf+nH/++caaNWuMaDQ64Lg6/fTTjSVLloz5+yjI90C+D6Ph7rvvVs/7s5/9rG/Z97//ffV5l5eXGz/+8Y9H9TyEEFIoMOWeEEKmGRdccIGK/EkU8qMf/aiKRkl6sUTM+iOu1/25//77VeqyRLfERT09JC1aniOdDv3UU0+pKJhEzfqn6o7G+EwiuxL1l3UH1+/2f67RkkgkVJq4RP8WLlzYt1yi/1dffbUyBZRocH8kmtj/tSSqKs8jqeFCerskY0DTtDFtj6Ty9t936VIFiVT3Xy63J4u/+7u/G3Bb3l9XV1fffpC0Y0mflsjwYG+D9H6R7AhJvZYodP/ttlgsKtKcKTV+8PE0HPI8aaNE2RZJkZYov6RmS7Q9G+9zOCQqLSnrv//97/uWSURYtkH8J6biOJTMBNkPozGIlOeRFPY0kgGRzjrIJvIbIPtRIub9P3f5TZH3+Pzzzw9Y/wMf+ID6rUkjn6NkDkj2hGRdpB8vn4tkX0i7P4n+j+X7OFbk9cVzQY7dNJdffrn6vOX7KNcJIWQ6wZR7QgiZZkhdrLSrk5NaSU1dtmzZccJN7htctysn2yI0JW05E5KKLqRPtJcsWTLgfjmxFyEwmvT/odqxjRWptZU0YXmPmVKORSweOXJEeQKkkTTi/qS3OS2+JeVYhIqkpUuquKToilATYTbYcGwwkiosNduDGeyyLq+RDaO8TJMgw70/SQeXz0COh5UrVw75vHIs9PdfGIw8z0jH00jIfvqv//ovVW/df+JE0uhHw0jvcziWL1+Ok046SaXY33DDDWqZXJd0fKkZn4rjcLTvU75vsk2DP+tMrzVR5HN/6623Boj0TL8BQ70H8TWQ4P+//uu/qjHUc/SfXBzp+zhWpFxHyhIk1T+NTLLIMSFlIoNfjxBCCh0KekIImWZIzfBIfbFFmA4W+SI6RMyLsMnEUCf5hcZQUdFUFnJKJEvkVszM/vSnP6le3WKwJeJTlg1Xfys1u/0jvG1tbeq21JWvW7eub/lIEx+CmHdJ/XQm0uZvss5Y399oSBugSa211MIPZrDrfKbjaTjEkE8M3GSiQ8zl5LiT7ZZa5/Skz0hM9H1KlF48G6TGX6K38tmKX8RUIWaL+YZ87pKhI8dxJmSicLj3kD5upBWeROQzMXjCJBvHa3/kOzF48kNuS/aRGD8SQsh0g4KeEEKIQszAJJ1eDK2GExtpl2+J5vVPL5Yo5UhRNXkNQXqTSxrvUIw2/V4mGST9WAywBiORXxGZUnowHiRaK+Nb3/qWcj8X5/b/+7//U0ZrQyFR7/6RbzH5EqRsYSRn7kz7WdKHRdQP/jzS7zf9WYwF+QxEeIkj+VDmc+nPSYT2cJ/TSAz1OcqEiRw7YjTYf53BvdInynDHkZSjiLv6b3/7W7WPxTztIx/5yLheZzKPQ/mM5fsiArf/+8n0WhNFPncpGxnvZ57+PZB9OZHjZjBjKceR/SyTcJL1kTbxfPPNN1WGxOB0f0IImQ6whp4QQohC6l6ldvUb3/jGcXtEaoulplqQE3U5Uf7Rj340IIo22AE7Exs2bFBpurJu+vnS9H+udLrs4HUGI9E9cWX/4x//2Cee05FxEeHiuj5S+vVgZFJicHQwLXwztQqbLMRBXUSJOKX3R8S4uM1LDbq4n48ViYqLwBR3+/6tyIT0+5boquy3b3/72xl9BAa3+RsK+Rwz+QWko7L997O47A/VLm68yOsPdQxJS0JpMSfZApKVcvHFF6tl42EyjsP+x4Gkkfev95cMjZ/+9KeYjN8A+QxEEA9G9qP8DgyHTADJxJUcs+KKP97jZiyf42CknEW+pzL5lib9HZJ2lIOPeUIIKXQYoSeEENJ3IiytqiTt+Y033lACRYS7ROLFLEv6xIsxl0QjJaVW1pP2cyI4xOxOepaPJIhESIoYFWMqEcnSHk8MvySKKe2u0kJCItqCtOkScSmCSSKqmZD2eWLiJqJJWlNJOricwMtJ/X/8x3+M+dOV2u6f/OQnqr2WRCzF3OtnP/uZEmTyXqcK2UfyGUjbMWnlJi3mRMhJP29pISjvezxlEJLyLO2/ZOJGDMikFZukzL/22muq9lg+V3mv8jlJazOZhJF9L68lrdOkp7lkcYwmPV0+RzGbk0i41KxLuYK8LzluJDov+1h624tR4h133KGyG7LZI1xeX7JOvve976n3JpNJ/dvHSdp92mwu00TWWMj2cdjfPE/2tWzr66+/rr4vUgqRbjWZTaT8QY4v+XykJEL2n7TU2759u5pQkMmKkb7j4uEh+2DNmjVq2yVqLxMbMlEg5Q0SLR8rsh1yPMo+luNXJg6G8neQ41n8PcQ0Uco3ZBJCPgfxxZC2efJ9Et+EtWvXjnk7CCEkL8m1zT4hhJDskG4DNVK7NWltJa2phuKnP/2psXHjRtXqTlpuSQuqL3/5y6oFVxppd3bbbbcZdXV1ar1zzz3X2LFjh2qRNVzbujQvvviiceGFF6rnl21Zu3at8aMf/ajvfmnn9bnPfc6orq42TCbTgBZ2g9uYCVu3bjUuuugio6ioyHC73cZ5551nvPzyy6PaP4O3UZ7rqquuMubOnataXdXU1BiXXXaZsWXLFmMq29YJ0vrr1ltvNZYvX662RfbVqaeeavzmN785bt10OzdpaZfpfcu29OfOO+80TjjhhL52XtIW7Mknnxywjmy37FdpVed0Oo1FixYZ11577YB9MdzxFAwGjauvvlq1wJNtSLdUkzZl3/72t9VteX3Zjj//+c8Z264N1bZuNO9z165dqmWcHKODWyoK0jpP3ru8v0gkYoyGodrWTfQ4HI7Dhw8b733ve9VzVlVVGV/4whf62klms21dumWhtPWTtnjShk9eT1rOffe73zXi8fiI+0CQ1n2f+MQnjNraWsNmsxmzZ89W36Hf//73I+6HTL8Z0i5R3oP8Xsh9I7Wwk9e//PLL+z4H2S/ym/Iv//Iv6lgdqTUhIYQUEib5L9eTCoQQQgghU41EbyVyL1kDv/jFL/gBEEIIKThYQ08IIYSQGclDDz2k6rolnZ0QQggpRBihJ4QQQsiMQgz4pN+61M1LTfjWrVtzvUmEEELIuGCEnhBCCCEzCjFY+/SnP63M1e6+++5cbw4hhBAybhihJ4QQQgghhBBCChBG6AkhhBBCCCGEkAKEgp4QQgghhBBCCClArLnegHwnmUyiubkZxcXFMJlMud4cQgghhBBCCCHTHMMwEAgEVHtVs3noODwF/QiImG9oaMj250MIIYQQQgghhAzLkSNHMGfOnCHvp6AfAYnMp3dkSUkJ8hVN0/DEE0/g3e9+N2w2W643hxQAPGYIjxnC3xmSb/BvE+ExQ/g7k8Lv96vAclqPDgUF/Qik0+xFzOe7oHe73WobKegJjxnC3xmSD/BvE+ExQ/g7Q/INrcB000hl3zTFI4QQQgghhBBCChAKekIIIYQQQgghpAChoCeEEEIIIYQQQgoQ1tBnqaWArutIJBLIZS2I1WpFNBrN6XZMJhaLRb1Htg8khBBCCCGEEAr6CROPx9HS0oJwOJzzSYXa2lrlxj+dBa8YWNTV1cFut+d6UwghhBBCCCEkpzBCPwGSySQOHjyoIsf19fVKZOZKTMu2BINBFBUVwWyefpUUMmEhkycdHR1qny9ZsmRavk9CCCGEEEIIGS0U9BNABKYIaekPKJHjXCLbIdvjdDqnrdB1uVyqtcThw4f73ishhBBCCCGEzFSmp/KbYqargM5HuK8JIYQQQgghJAWVKCGEEEIIIYQQUoBQ0BNCCCGEEEIIIQUIBT2ZMPPnz8cPfvAD7klCCCGEEEIImUJoijdDOffcc7F+/fqsCPHXXnsNHo8nK9tFCCGEEEIIIWR0UNCTIdvEJRIJWK0jHyLV1dXci4QQQgghhBAyxTDlfgZy7bXX4rnnnsMPf/hDmEwmNe666y51+dhjj2Hjxo1wOBx48cUXsX//frzvfe/DrFmzVI/7k046CU899dSwKffyPD//+c9x5ZVXqnZ+0jP+4YcfzsE7JYQQQgghhJDpCwV9nuD3+9Ha2qouJxsR8qeddhpuvPFGtLS0qNHQ0KDu+8pXvoJ/+7d/wzvvvIO1a9ciGAziPe95D55++mls27YNF198MS6//HI0NjYO+xq33XYbPvzhD+Ott95Sj//Yxz6G7u7uSX9vhBBCCCGEEDJTYMp9HiBR8J07dyIajcLpdGLVqlVYtGjRpL1eaWkp7Ha7ip7X1taqZbt27VKXX//613HhhRf2rVtRUYF169b13f7GN76BBx98UEXcP/vZzw6bBXDVVVep69/+9rfx3//933j11VfVhAAhhBBCCCGEkInDCH2OkYi8iHmpWa+qqlKXcnsqIvWZOPHEEwfclgj9l770JaxYsQJlZWUq7V6i9yNF6CW6n0YM80pKStDe3j5p200IIYQQQgghMw1G6HNMOBxWkXkR82azGcXFxejs7FTLRQRPNYPd6kXMP/nkk/jud7+LxYsXw+Vy4YMf/CDi8fiwz2Oz2Qbclrr6ZDI5KdtMCCGEEELyGMNIDaQv1cJj9x1bMcOy4ZYD0LTUZTwMGCJtTAPvN/W/bRq0zJTher9lAx5LSH5CQZ9jJO1d0uwDgYAS83Ipt2X5ZCIp9+JiPxIvvfSSSp8Xg7t0xP7QoUOTum2EEEIIISRPEBGdTABGYtBlMjX6X+8/0uI9kwjPJnrv+WygFbBasv/8A8S9aXSXJnOGZSPcry7NQzwfJxbI0FDQ5xiJwkvNvKTZS2Q+XUM/2dF5cabfvHmzEueSRj9U9Fwc6h944AFlhCdR9n/9139lpJ0QQgghZFoIdX3Q6BXr6dtKvM/wDMv0hMRkT0yMxOBJgeMmB8xD3E5fNw+6r9/6fRMJpBChoM8DxABPerlLmr1E5qci1V5S6a+55hqsXLkSkUgEv/zlLzOu973vfQ/XX389Tj/9dFUW8E//9E85q+8nhBBCCCGjRIR5QusV5xqQSIv29LIZLtQLjanIdjCNdpKgX4bBiOv0nzzgpMFkQEGfJ4iIn8qa+aVLl2LTpk0DlklqfaZI/jPPPDNg2Wc+85kBtwen4Iux32C8Xu8Et5gQQgghhAxARHoi3ivYe0f6eq4jyqSAJw0mabKnr3xhlBMF/UsOhsswQO+leWb6vVPQE0IIIYQQks+IyNJjQCIG6PHUpRLyjLKTQixfGNnHKzulCebjr6vLgebdhQ4FPSGEEEIIIfmCiHQl3KMp8S6XEnEnhIyxNCGReR2La1rtSQp6QgghhBBCchl5V+K995LinRAyBijoCSGEEEIImaqadz2SEu9aJJU2z1p3QsgEoKAnhBBCCCFkMkgLd4m8y6U4zxNCSBahoCeEEEIIISRb6fNa+JiAZ/SdEDLJUNATQgghhBAyHtICXsQ7BTwhJAdQ0BNCCCGEEDIaJGU+HuoV8WG2jSOE5BwKekIIIYQQQoaLwouIlyHXCSEkj6CgJ4QQQgghpD8i3GNBIB5IOdMTQkieYs71BpDpwU9/+lOce+65KCkpgclkgtfrHdXjbr/9dsyfPx9OpxOnnHIKXn311UnfVkIIIYSQ49DjQLgb6DkMeI8AkR6KeUJI3kNBT7JCOBzGxRdfjH/+538e9WPuu+8+3Hzzzfja176GrVu3Yt26dbjooovQ3t7OT4UQQgghk08yCUR9KQHvbUwJ+oTGPU8IKRiYcp9FDMNARMtNf1GHxTSm9YPBID73uc/h97//PdxuN770pS/h6quvxpIlS5SgLioqGtPz3XTTTery2WefHfVjvve97+HGG2/Eddddp27fcccdeOSRR3DnnXfiK1/5yphenxBCCCFk1MTDQCwAxINsLUcIKWgo6LOIiPmVX/0LcsGOWy8c0/rXXnsttm/frgR4W1sb3v/+92PHjh244IILlJi/55578KlPfWrY53jsscdw1llnjWt74/E4Xn/9ddxyyy19y8xms3r9TZs2jes5CSGEEEKGdaiP+YGon1F4Qsi0gYJ+BtLZ2YkHHnhAifaNGzeqZVdeeSXuvvtu/OIXv1C33/ve96qa9uGYPXv2hLYhkUhg1qxZA5bL7V27do37eQkhhBBCjjO4i3gZjSeETEso6LOIy2bB21+/CLlKuQ9ER7fuvn37VHnAaaed1rfs5JNPxv3336+EvFBcXKwGIYQQQkhBIm3mRMhrkVxvCSGETBoU9FlE3N3d9tzs0qSYuowSh8OhLu12e9+y6upqLF26FFVVVer2ZKfcy+tYLBaV7t8fuV1bWzuu5ySEEELIDMcwUmn1IuRpbkcImQFQ0M9AFixYoOrV9+7di/r6erXs4YcfRmNjo4rcy8TEZKfcy2SCpPs//fTTuOKKK/omJeT2Zz/72XE/LyGEEEJmqJAXt3ppNSe18oQQMkOgoJ+BlJWVKRO8b33rWyrVfs+ePXj88cfhcrnwzDPP4Pzzzx9zyn1ra6saks4viOGePH7u3LmoqKhQy+R5pVY/LdilZd0111yDE088UW3HD37wA4RCoT7Xe0IIIYSQkYW8NxWRp5AnhMxAKOhnKLfffjs++clPqii7pL6LmJZU/I997GNK6N9www1jej5pOXfbbbf13T777LPV5S9/+UvlqC/s379fmeGl+chHPoKOjg589atfVZMB69evVxMLg43yCCGEEEIGwIg8IYQoKOhnKDU1NSrNfjAi6MfDrbfeqsZwHDp06LhlEq1nij0hhBBCxlQjH+5mRJ4QQijoCSGEEEJIQSD94yPdQELP9ZYQQkjewAg9IYQQQgjJX2KBVEServWEEHIcFPSEEEIIISQ/+8iHuwA9nustIYSQvIWCnhBCCCGE5Bf+FsCgkCeEkJEwj7gGIYQQQgghk42k1AfbUte1CPc3IYSMAkboCSGEEEJI7kgmU2Z3UR+g0fCOEELGAgU9IYQQQgjJDRFvSsyLqCeEEDJmKOgJIYQQQsjUEg8DoQ461xNCyEyqoX/++edx+eWXo76+HiaTCQ899NCw6z/77LNqvcGjtbV1yraZEEIIIYT0q5MXwzt/M8U8IYTMtAh9KBTCunXrcP311+P973//qB+3e/dulJSU9N2uqamZpC0khBBCCCHHYRhApCc15DohhJCZF6G/5JJL8M1vfhNXXnnlmB4nAr62trZvmM0F9bYLgmg0is985jOorKxEUVERPvCBD6Ctrdepdgiuvfba47InLr744inbZkIIIYRMAVoU8B0Bwt0U84QQMpMj9ONl/fr1iMViWL16NW699VacccYZQ64r68lI4/f71aWmaWr0R24bhoFkMqlGLpHtSF/mYltuuukmPProo7jvvvtQWlqKz3/+8yqL4oUXXhjyMbKtF110Ee68886+ZQ6HY9jtl/vkcbLvLRZL1t/HTCJ9PA8+rgnhMUP4O0OyF5XvBiK+UT9E0xMDLgnhMUOyjWYkCuIceLTbZzLSSrDAkGjugw8+iCuuuGLYVHupoz/xxBOVSP/5z3+OX//619i8eTM2bNiQ8TEi+G+77bbjlt97771wu90DllmtVhXxb2hogN1uT/3h0nPUN9Xqkp0y6tWDwSD+6Z/+CQ8//DBcLhc++9nP4oMf/KDaV3v27FFR9tHi8/mwZMkS/OxnP8P73vc+tUye45RTTsETTzyBk046KePj/v7v/1499p577hn1a8XjcRw5ckT5IOg6W9sQQgghhBBCph/hcBhXX3210kv9y8dnlKDPxDnnnIO5c+cqYT/aCL0I9s7OzuN2pKSZi7icP38+nE4nEA/B/G9zkAsS/3QEgVgSxcXFat+MxIc+9CHs2LEDv/nNb1RqvIj5D3/4w+jp6cEf//hHJbI//elPD/scjzzyCM466yw888wzuPDCC9HV1YWysrK++xcsWIAvfOELKnqfieuuu069lkyGlJeX47zzzsM3vvENlbY/FLLPDx06pD4Ttc/JhGb9nnzySfXZ2Ww27knCY4ZkHf7OzORaee+4Hi6R+Sdf34sLNy6BzcpMPMJjhmQfzeLCky9vy/tzYNGhVVVVIwr6GZFy35+TTz4ZL7744pD3S8q3jMHIhz34A08kEko8S02+qsvPYW1+WsSnt2c4ZHJCJkNEtKej5+JLIJMcv/jFL9TjZaLktNNOG/Z5Zs+erdZtb29XoryiomLA/bNmzVKTBUNtj3giSK29CP/9+/fjn//5n3HppZdi06ZNQ6bTy3PJe8z0eZDxwX1JeMyQyYa/MzMEPQ6EWlOXExTjIuYp6AmPGTIpWCwF8bdptNs24wT9G2+8gbq6usl5cpsb+Odm5ASLE4gGRrXqvn37VB16f8EuEx33338/3vve96rbEumXMZl89KMf7bu+Zs0arF27FosWLVJlEueff/6kvjYhhBBCsohE5MNdNL0jhJAppqAEvdR9ixhNc/DgQSXQJTIsafS33HILmpqacPfdd6v7f/CDH6jo76pVq1SqttTQS3q41HVPChIlt3uQE8ZghJfOQFB1/71UV1dj6dKlKq1DkOj9pz71qWGf57HHHlMp9+IjILXtXq93QMq9ROflvtGycOFC9fryGVPQE0IIIQVAMgEE21XZISGEkKmnoAT9li1bVJ11mptvvlldXnPNNbjrrrvQ0tKCxsbGvvtFZP7DP/yDEvliaCcR4KeeemrAc8xEZJJDUtf37t2L+vp6tUzM8WTfSeReUtolUi+mdiOl3AsbN25UKSFPP/20SqFPGxLK842Utt+fo0ePqjr8ScugIIQQQkj20CJAoDUl6gkhhOSEghL05557bl97tkyIqO/Pl7/8ZTXIQCSKLi3lvvWtb6lUe3Gkf/zxx5XbvWQwSHR8LCn30qbuhhtuUBMski0hpg2f+9znlJg/9dRT+9Zbvnw5vvOd76h6fcm2kG4CMgEgUXypoZfPavHixaqVHSGEEELyGOkpL+Z3hemtnDMMGEgaQNIw1Dmt7D415J+6TGE2ASb5J5cmuW2CxayW5PgdEELyjYIS9CR73H777fjkJz+pouxiQCflCZKK/7GPfUwJfRHoY+H73/++ivqLQJcuASLKf/KTnwxYR6L24tIoyGu+9dZb+NWvfqVS9SVT4N3vfrdyuc9kSkgIIYSQfEmxbwPi4VxvSd6RMAzoiST0pIFE0lCXItzlerJ3mfybCCLsrRYzrGYR+GblPWhTl2ZYxtC+mBAyfaCgn6HU1NSoNPvBiKAfD9JCTiYJZAxF/+wKyQb4y1/+Mq7XIoQQQkgOYIp9HyLU43oSMT2JeCIJTU8iYYzez2hir5tAfBixb7OYYbealNC3W82M6hMyzaGgJ4QQQgghwyPp9ZJmP0NT7EVIR7WEEvAxPQEtMfnifdxiX08gFEsvNcFmMcFuscBuk8uU4GfqPiHTBwp6QgghhBAydBcdlWI/81zsJfIuIj6iiUgWAV+IkxkGtISMJEJ9YX2TitynI/lK7FvMud1MQsi4oaAnhBBCCCHHo8eBQAuQ0GbM3pHoezieUEJeH0NL4MLi+Ei+ROztNjMcIu6tJjisFpXCTwjJfyjoCSGEEELIQGLBVGR+BqTYxxMi4pOIxPVpLOKHR8z6YlJSoB1rQWg1m5WwT6XqM4pPSL5CQU8IIYQQQo4R6krVzE9zR/pwTEcorudlPXw+IJMbevxYqr5E7B02CxwqVT8l9gkhuYeCnhBCCCGEzIh6+XBcRHwqpb4wa+Jza7onWQwRHEvTVwJfiXs66hOSKyjoCSGEEEJmOlInL/XyUjc/DSPNoZjUi+tT0lpuJqXpRzUdUS2zwGcEn5CpgYKeEEIIIQQzvb98SypCP80M7oIxXZncMRqfO4HvFHFvM6s6fEJI9qGgJ4QQQgiZqUT9QKhjWpnfSTq9P6YNMHgjORb4kVQNvlMi+DYzXDYrLHTRJyQrUNATQgghhMxEQp1AxIvpJOR9UU21YyP5WYMvHgbhONCDOOxWC1wSwWf0npAJYZ7YwwkBuru78bnPfQ7Lli2Dy+XC3Llz8fnPfx4+n2/Y3WMYBr761a+irq5OPe6CCy7A3r17uUsJIYSQyURS6/3N00bMS2p9WyCKjmCUYr6AkIkXXySONn8ULb4IesJx9VkSQsYGBT2ZMM3NzWp897vfxY4dO3DXXXfh8ccfxw033DDs4/7jP/4D//3f/4077rgDmzdvhsfjwUUXXYRoNMpPhRBCCJkMEjrgPwrEw9Oif3xHMIb2AIX8dDAuDMY09Vk2ecPoDsUR0XSVtk8IGR6m3GcRiThH9HQzj6nFYXaMaf1gMKii6r///e/hdrvxpS99CVdffTWWLFmC9vZ2FBUVjfq5Vq9ejT/84Q99txctWoRvfetb+PjHPw5d12G1WjPuqx/84Af4f//v/+F973ufWnb33Xdj1qxZeOihh/DRj350TO+HEEIIISOgRXvN7xIF30PeF9YQive6r5Fpl5ovn20onjLWc9lTqflyKbcJIQOhoM8iIuZPufcU5IJNH900pvWvvfZabN++Hc8++yza2trw/ve/X0XXJe1dxPw999yDT33qU8M+x2OPPYazzjor432Sbl9SUpJRzAsHDx5Ea2urer00paWlOOWUU7Bp0yYKekIIISSbxIKpHvMFbH4n0dpgVIcvojFyO0OQzzxVd6/DFKK4JyQTFPQzkM7OTjzwwANKtG/cuFEtu/LKK1WE/Be/+IW6/d73vleJ6+GYPXv2kM//jW98A3/7t3875GNFzAsSke+P3E7fRwghhJAsEOkBQl0FvSultlpqrLVE4bfWkyxFddmbTp6eYukfe05Hok10gh9R3FtZQExmOBT0WcRldWHz1ZuRq5T7AAKjWnffvn3qj8lpp53Wt+zkk0/G/fffr4S8UFxcrMZY8fv9uPTSS7Fy5UrceuutY348IYQQQrJIsAOIDm9Sm+/p1948Tq9PGAnoyQTUv2QCSSSRMJJIGnLdUOdbskwuRbiPpybc1CvvU+K+9zrMkJvm9K2++45dV/eZUpfy2P7ryi2zydx3XyGL+2QitU+l5t5qVe8o15tHyJRCQZ9F5AfRbXMjFyTFsXaUOBypenu73d63rLq6GkuXLkVVVZW6PZ6U+0AggIsvvlhNBDz44IOw2WxDPra2tlZdSrq/uNynkdvr168f9XshhBBCSAbkvCDYWtDmd6G4rmrlRSDnEnl9LSnbkYBu6NCSeu/1xJSk/hvpVxlQLpE4FtqfIKlJgGPiXq6J6FdLZHnvfanL3tsmMyym/AiNpz8DMdLzRxOsuSczDgr6GciCBQtgNptVi7j6+nq17OGHH0ZjY6OaQZYf87Gm3EtkXhzqZbJAnsvpdI64DSLqn3766T4BL88hbvef/vSns/I+CSGEkBmJmN5JWzo9hkKlKwfp9XIOpBmaEuwi4DVDVwI+1xMKUyGIZYJCWSWOcZLAMkjkDxD86UmAQcsnE9bck5kIBf0MpKysTJngiRO9pNrv2bNHtZmTXvDPPPMMzj///DGl3IsQf/e7341wOIzf/OY36raMdOTfYrGo68uXL8d3vvMdVa8vkwY33XQTvvnNbypnfRH4//qv/6omGK644opJff+EEELItEWPA4HmVHu6AiSkpVLro3EdFsvkij8R7bFkHPFkr4g38jOtP5+RyQ4pLhjtRMCxbACJ8B8f9T9237Hr4y0JyCTunTYL3HTLJ9MMCvoZyu23345PfvKTKsougltayEl0/WMf+5gS+iP1kO/P1q1bVWRdWLx48XFu9vPnz1fXd+/erdzv03z5y19GKBRS5nlerxdnnnmmmlgYKbpPCCGEkAxokd62dMmC7EPeI7XyUW3Sou8p8Z4emqpxJ7nKBkhAG+XuT6f7W0yW4wW/RPwTKcGfNJKwwDyiuO8OmZSoF3EvpnopzwFCChcK+hlKTU2NSo0fjAj6sXLuuef2ObYOx+B1ZMb161//uhqEEEIImZlt6YJxDd5Q9lvRiXCPJeKIJWOIJdnqrlCRiZdkr2dBxvuTqeOmJdYOq5au77f0lQP0Xe+bFLAgHE8JfMkZUMLebobLZlVZA4QUGhT0hBBCCCGFTMQLhDpRaCQMQ7WiiyhhlY3nSyKWiCKqBHx82te+k7GL/4yp/7G06Bdhb0Oxw4YimwN2S2oZIfkOBT0hhBBCSKEi/eWlz3yBIdFREfPSlm4iiGiPJCKIJqKMwpMJp/77daBNNYYwwW6VqL0FHpsNDotNRflF4FvNVlj7sgBS0f9CbP1Hpg8U9IQQQgghhYYI4WA7EAugkBABL0I+le48PqSET0R8WIn4+JS0jst3IpEotHgcNrsdLhe9iCaOgbieUMMXiatovdNmhsNmgTWDeLeYZXmqxl+J/kGCn8KfTCYU9IQQQgghhUSB9piP6QnVK1wM8MaDROFFxMslDe2O0d7eieamo9A0DTabDfWz56CmpiprnxsB4omEGohqsJrNqu5eBL7NnDLhSyRT0f6RSIt7Ef59EwD9JgPSEwGT3d6PTC8o6LPAaAzhSHbgviaEEDKjKdAe876IBn80Pq7WcmEVjY9Mq5r4bEXU5XlEzAvSbjgaTd0uLi4a8/Myyj86ZEIqGJMBJe4lau+0mmEfRZtF1eZvFMexpPD3j+73F/vHIv5M9ycpKOgngMyCCtJ/XXq4k8lH9nX/fU8IIYTMGBJaSszLZYGgJZMqKi+py2MhoIcQ02LTsjd8NiPqMikgzyNi3mQ2qda/gUBALR+LoGeUf/ziXo8lEUqLe2sqej8acT9SAEs3dIymMCXl4J8S90NF/dOlAGR6QkE/AaR/e1lZGdrb29Vtt9udM1OMZDKJeDyuZmbNvek/0wn5YRMxL/ta9rnse0IIIWTGIBF5EfMSoS8QQmJ8Fxp9jXs0EUNQC6nrfj0As3n6GY1lM6IuSIRfJgXkeUTMy6XcluW52qYZLe7jSXXci7h22MxwWi3KXG8yj+R01H+kqS/RKANS/QfU+jPqX8hQ0E+Q2tpadZkW9blCGcREIipTYDo7bYqYT+9zQgghZEagRVJivkBK/ETA94Q0hOLa6CbsExEE9bCKxqd7ik9XshVRTyOPkQi/CHB5nnTEfyzPle1tIimRHY7L0GE2mfoi9w6rZVLF/UjftbSz/0j0CXyz5TiTP5kQsJgZ8c8nKOgniIjnuro61NTUqB/DXCGv/fzzz+Pss8+etuno8r4YmSeEEDKjiAWBYFvBiPl4IomuYGxE4zsRFiLiw4nwtKqNn4qI+mAkXV+i6eOtyZ+MbSIDOztEtIQaJphSbvnWlLjP1ySUvlr/pDaqiH86yt93XSYCIKn/FP5TAQV9lhChmUuxKa+t67r6IZ6ugp4QQgiZUUS8QKgT0ynFXkvqCOohFZWfie3mshFRH+p5x/sck7VN5HjkmE+Le+l1n4rcS2q+NW/F/UQj/kOl+kvdf//6frl/OmcZTyYU9IQQQggh+UaoC4j0oGBS7MMaQjFtWLd6vx5EJBHFTGeiEfWZsk3TH0O1cpThg65q7V0FKu6zleqfFveplP9B9f3K6I8Gf5mgoCeEEEIIySeC7UDUj0JAUuu7hnGxjyXiCOhBRJOF1WZvsplIRH0mbdPMwVDfIRk+aLBbU63wpO7eMoOi1kkjqcZYDP4sgx3+e6P96n7zzDDRpqAnhBBCCMkHpE4+0ArEU07v+U5US6ArFFM1wpmFfADR5Nh7z5OZAfveD01a3PujGuwWi3LMl5p723QK3U+VwZ85Xc/fT/zbpldHMAp6QgghhJBcIyZygWZAK4yU9EBUgzdyvFinkCejgX3vR088kVAjAC2rve5nColkr/DvZ/DnNE0vw0cKekIIIYSQXJLQU2Jez/9otkTje8Jx1Y6rPxTyZLSw7312et33tcNTve7z1zGfTD4U9IQQQgghuSKhAf6mlKgvwJZ0Ynbn0yS1njXy+Z5Oni/bxL732W+HJ475Yqondfci7pmaP7OgoCeEEEIIyQV6DPA3A8mR60BzjUTku/u1pNOTunKtl/ZzJP/TyfNpm9j3fnJN9dCbmi8C32FJCXxG76c3LL4ghBBCCJlqpFZeIvMFIOa9EU2Z34mYTxhJ+DQ/2mKdFPOjSCcX5LYsL6Rtkvv8Pv+kbHe6770gfe8F9r3PLpJFI5NwPZE42gJR1YkiENNVls3xFpak0GGEnhBCCCFkKomHgUBLytU+z1N6RQhENV25SgcTYQS0AKajJMhWOno+ppOPdZumIprPvvdTidFnrBeMSXJ+Kj1f6u+Znj89oKAnhBBCCJkqYkEg2Jb3Yr5/vbyk1fu1AHQj/7MJxkM2BWw+ppOPZZum0rCOfe9zg2TaxPSEGpKeL23c7FYx2LOowfT8woMp94QQQgghU0HUl+ozn+diXlJ12/1RhPUoOmJd6I57p62Yz2aKfDrKX1VdnVfp5GNJcU9H80X4p6P5cluWk+mJlNGIsZ60oWwLRNAZjMEf1RDVE0jm908V6YURekIIIYSQySbSA4S68n4/y4l8dziq6uRnguFdtlLkB0f5K6uqUFpSknNH+bGmuOdjhgGZWrRkEppqjSe3TKrfva3PYM8MdsfLPyjoCSGEEEImk1AnEPHmfb18dyiG9oh/2tbJT5aAzZSm3tXZiaqqqqyJ+WzU+I8mxT0dzZf3IxMb6RKEfJiUGIloJAZdz31bvulafx9St/vV34vAtzDZOx+goCeEEEIImSyC7UDUn/cRuSafH51RLzRDR74yGX3UsyFgJ9sIL9smdSPtx0I1rNu7Zw/iWiznbflmTnu8gQZ7Ngr8nEFBTwghhBCSbaROXurl46m4Vr4Sisex39uBkJ7f6fWT6bw+UQE7mWnqg6P/wWAQhw4egM1mRXl52aTtx0zR/MmYUMlWZF6k5VQY+ZHhDPaOCXw1JFXfwhT9qaCg8iSef/55XH755aivr4fJZMJDDz004mOeffZZbNiwAQ6HA4sXL8Zdd901JdtKCCGEkBlKMpnqMZ/nYr4l5MWOzqN5L+anore7CL+S0pJxCcDJ7Kve36QuFI4gFArB6/WqaLSI86naj/Jau3ftwu7du9XlWF97MtG0lGGfw+mgkV+eCPxAVENXKIZWfxRd4TgCMZ0me5NIQQl6+RFbt24dbr/99lGtf/DgQVx66aU477zz8MYbb+Cmm27CJz/5SfzlL3+Z9G0lhBBCyAwkmQD8RwEte2Iz28QScezqbsYhXyeSSCLfKQTndYlyL1u+HMuWLVOX2coeSEf/JTIfDPih6boKUpktljFPaox3P/b0eFVWgJ5ITNqEykSw2VKZELFoDEbSoJFfHqboB2MaesLHXPR9EQ1hTYdGG/2Zl3J/ySWXqDFa7rjjDixYsAD/9V//pW6vWLECL774Ir7//e/joosumsQtJYQQQsiMI6GlIvOJ/KxDTxpJdMd9OOr3qjZVhUKhOK+n09RjuoG2gIGeCOCNAr6IgYgOxHpHtPdSzyBmJHHcZjHBbQPcdsBlsyNhLETQ34ZkJIkyp4EajxNFHseY6/THsx8lEi9iXrICZCLBZDLD43bB6/Ohp7sHqCgf8vWnKkXf6XIgiNSkRNoHQboMpCcqmHafhy76ksWkqVswm0wqNT9dgy+XZlrpT19BP1Y2bdqECy64YMAyEfISqR+KWCymRhq/P2Vko2YwNXXk5SXpbcvnbST5BY8ZwmOG8Hcmi+hxINCSitDnIdJTvivuQ1coqhyr85Vkr8hNXwoiJOvr56CluRnBYAg2qw119fVqef/1ppJgzEBLAGj2A62B1HUZXWEgMuFTscHvyQNgYeqqnJa2A3ZzAkVWHTVeG+pKEqgtNmFWMTCrKDUc1uMV0Vj3o9SmtzQ1w2KxwuV0q+yAcDCEeDSKSDSOo01N6GjvUM9RVV054LGdHV3qdTRd63sdWUeeU1LkJaouQjwbpLd98eKl0BNxBAJB1WWgrbVtwGuT/EQ6auiJJPoX/ljNZtjMJtUuTwS+3M6mxtcTyYLQTaPdPpNhiGtL4SE19A8++CCuuOKKIddZunQprrvuOtxyyy19yx599FGVhh8Oh+FyuY57zK233orbbrvtuOX33nsv3G53Ft8BIYQQQgjJZ+Qs2RcHjoRMOKpG6rovPry8sJkNlNiAEjtQYjPgtAB2GWbAYTHUpdWcisgbg15PSwLRhAnRBBBJpCL6kYQJ/jjg06RkYmRpU+EwUO82MNsN1Hvk0kClE4x8ElJAiF69+uqr4fP5UFJSMjMj9ONBxP/NN988IELf0NCAd7/73cPuyHyYwXnyySdx4YUXqlQjQnjMEP7OkFwzI/42xcNAsC2lxPKMoB6GNx5AWNNUzaoYVuU7Em3tPqKhosEGc5bzboeKGg9+/b1tcbzTnsR+rw37us3wH0vcHECdM47FRSEs8ITQ4Ayh3hFChS2OYqsOh0mH2dAR9vsR9PVAlxRjiw3FZRXwlJTBMFuQNNuQsDqRsLoQTliwv7EFcbMDJncJorFUZG7J0qUDItkS4Q5E4ggl7IgYdnSGgLaggbYg0BaQ60AwDnTHTGrs6Dm2vQ4r0FAKzC0D5pWbsLgyddsyxH6W1xLzPfVYp0N5WcXjqZ1RXl6h6vClZl3q+5csWYLiklR9fcAfwN69e1FUVNS3js/vV6nVdptdPZfUu2d6fxM9ZkLB4HGvPXj7yPRAHPVVqr7ZBKtcWs2wmkb3m+FwVOD11w/m/d+mdKb4SExrQV9bW4u2trYBy+S2CPNM0XlB0o5kDEbVGOXxB15o20nyBx4zhMcM4e/MOIkFgGinKKK8Ooi0pI6umBfRRAxhXYc/psGkosGFU5gqYj6bgl45vDenHN6Lijyp1mbNR1FUXISuuAPbmg283WZgV7uBWMIGJ2JYaGrEmaZWzLZ2YbGjG/NtPagzdaMi2Q2X5oMlqQFBmTkZw4Z0DX3Xqb2XBkyIWtwIm5yAtwqGpwKaoxSao6T3shRxVyVi7irokmcvH24/AjEDR33AjsYg9rZF0R51oDPuQkw3Y18X1EjnBYjIX1RpYEmlCUuqTFhaDRQ7Uvvd7XGibna9MsALBPzqfGFOQ4NKZ49GI311+FarBXaHve/zkuuyrP86JhhIGgYcTrvaXLmUenddj8Nsdmal3l5eP9NrD96+bJGvbfxmErqRhOqYJ2VEcclA6RX3vUJ/KJEv6xTCOfBot21aC/rTTjtNpdj3RyIFspwQQgghZNxEvEAof1p3pfFrIXjjfmWA54tqCMfz06Bvqkk7vItLuwYzGmOV2Nlpwy8PGqiOHcA6835caTqCheYWLLI2Y7ZpkPJWouH45zVMZug2D3R7kbpMWh0wTFYkzVbEEwZ8wTAsdocStOZkAkkthhKPSxnfmRNxWPQoLHoEZi0MsxaB1dDVuq5ECC6EgJ4uoF+UfTAS5Rdhnxo1iBTVoby4HiXWCmjmbiyptyhhG45E0R13wFKxEK1hGw50G9jflar3f7tNhtE7lQDMLQdWzTKpsbymEsuKiwYIV4fD2SvyUwZ0g1v0pdv49V+nqroanR0dCIZCKPJ4BhjyifGerCufT/r5xtslINNrZ6uFYH+yuc0keySNlKu+jAGRfGs6ki9RfQum2/RLQQl6SZnZt2/fgLZ00o6uoqICc+fOVenyTU1NuPvuu9X9f/d3f4cf//jH+PKXv4zrr78ezzzzDH73u9/hkUceyeG7IIQQQkhBE+5OjTxCTybQGetRUXnxCPNG4qofNOndPyY79oar0NmSxKzoUawxHcQHzPux2nQQTkdm46moxYUeSzlQPhtGSS1irnIVGQ+YihAyuwF3OezFZWLsNGQEV3q2C+losSBt7TIJTBGJrUcPwxwLoMQcx5xyN6pdJthiPthi/r5Le7QH9nAX7DEvzEkNrmCLGoM5GSYE7BXw2yvhs1eiLVkET30UpoUrkLQ6Vap6kx/Y02lgbyewt9NQJn+He2QYeHSXoWruF1bYsLbOjg2zTVggLvs1VSjuJ/IFv88/IFLdfx1/IKDEfDyuIRoLIhaNwuPxKBEsiDAWZLJFZU40HVWPHa8IH7x92RbzKtsjy9tMJg+jt3XeseaMGvR+t6YDBSXot2zZonrKp0nXul9zzTW466670NLSgsbGxr77pWWdiPcvfvGL+OEPf4g5c+bg5z//OVvWEUIIIWR8BDuAqC+v9l5QC6t2dBKV1w0DPaF4qmZ7hhPVDOw8HEDk4E7UeXfiJtMOLDK3AIOyWHWrG8GKxfB55uBAAPDaKlWk26dbjhPgxyKzXbDZ/KifnRgyMjs4Wmwym1FVVTVqIWp2OYfL0IcpocEe6YIj0glHuAvOUBucwWa4Ai3q0pKIozTepUYDgNXyoC1PplL6i2oRKp2POWXzsKZ0PkKz50Nzlqk2exKt39kG7GxL1ean0vQNPLDDQKkTWF9vwgn1DqypcyDQ0zVkpDq9z0TMC1VVlSo4l0wmMW/+fJSXl6mJgHTmhNS8y8THWNvxDbXvMz0+G2ny/bM9srnNhMwIQX/uuediOFN+EfWZHrNt27ZJ3jJCCCGETGvk/CPYnqqbzxMSRgJdMR/CeqrhUzyRRE84rtJOZypGMomOQweR2Pc6Fvu34e9NB2E2GUBKmyMJE7rccxGtWoJozTIEyxcrcZuuQ/dLlFwEakQEqmVAuvZ4IrNpkd7a2oquri50tLfD29MzZIr2UEI043u12BArqlXj+DsN+I/uQ+zIThRFO1CZ9KHWHER5pEVF9tNR/aqmTX0PkRr9UOkCrK5YjOC8JQiuX4xWvQjbWw280WxgewvgiwLPHTDUsJgMzHHZsKioEisr47AhcNz+GCx+xaxOxK/F3FvDbLeriQDZl+kshnQqfrbJVpr8VG4zIdNO0BNCCCGETDkikKXHvDja5wmRREyl2Cd6+95HtQR6VAP0mSfmVS360beQ2L8VC71bcXq66LzXK67VNhv+mtVIzlkNf/UqJOzS133s6doTicz6vF5YpXa3t3580lO0TSaUNCxBpKpBbV+X3Y5w72vZol64fYfh8R2Co+sAiuR6uFWl85e1v6lGmoinFqeKwK9fDO+KJdgan4fXWyzKRLAlYMLhcJEaz7QD1c4YFrh6YK7QsWauoVpMjyR+p6rmPZtp8hPdZprpkWxDQU8IIYQQMhSSuh5oBrRU/XOukUzFnrgffu2YtXoorsMfzVwHPh3IJIBExJe2boNt/yuY3fm6cqVPEzIc2OVai9jcjbAvXAvNPbA13UgMFSXPJE4ljT4ai8MWiQ4p6KY6RXvw/hr8GpJa73OWYa9pNppD86BZNLiqgaVlJjSgC8U9e1HUvS8VxQ+1qlF95EX12HVmGz5Uvgj+hSuw17YI9zeWYWeoGkdCReiIOtARrcWrLwEVW5M4cY4JJzY4MKtuDtpahha/o6nJH+69xmNSDz1867tsfwbjrdOnmR6ZDCjoCSGEEEIyIdFvfxOg54eBUjyhqah8XNql9ZINJ/t8jhj2F0AOqwnrXX7MD+xAWfPrcCSPTbI0GZV43b4B/tp1KJ2/EJ4ij3ov2ZzmGByZ1aVVFoDDhw4Om8Kdj2nlmSLWb/uBxPJz4Fp0kVpujQfh6dmH4u6UwC/q2QdbPIiSrl1qiKXdOTCj016Dw5Vz8IZpBZ41NmKLtxrdEROe2Guo4bGVY01tKdZVx7FutgXlxccfY+mJh7EI3vS6up7A3KrV6OzoQs2szOtOxmcwlvIIgWZ6ZLKgoCeEEEIIGUxCT4n5hJY37eh64r4+LyH5X5zsJdV+IgwnoKZa6A+OtioBdPQIamLNWBl5B/P92+EaJOIfT56KlrpTsXTVYji0bgSajqL74IFJayWWjsyKoBcjZpVG3ysQh0rhHilFO1v7eSyCcTQRa2nF55u1Xg2FYcAZbFFivrjzHZR07oIz3I6aeKsaJ2ELbsSv0emqwtu2ZdhkOQkPBNeiLerEK0fMeOWIE7Y3gDW1CZwy16Qi+G67aVzb339dqcsXWpqbUVySeV15X+nWeaMxKJwMaKZHJgsKekIIIYSQ/khEXsR8b316ro3vOmNeRPRjQlba0on5Xbw3QjxehhNQgUBwSvtsD462Bo/uw4KeLVh/9HlU6MdaBLYa5XgkcSqet52K2csW49zFFixIxhAIdPUJ7MluJaYi//G4MuCTmvjRpHAPlaKdzQmVsQjGcUWsTSZEi+vVaJ//LrXIHu5UAt/VugPu1u2o0DpRpXfibBl4Cf9osqC9ZileM6/GQ4FVeDa0CFubLdjabMBmNrCuHjhtrgkb5pjGtP2D11XLdO24dQfv38qqKui6PiqDwmxDMz0yWVDQE0IIIYSk0WO9Yj6Zd8Z3Qjbb0g0loGQ0NzVNWZ/t9MSCyUhipXEEq/c/jhr/W0jHbsOGA48nT8IDibNw0L4Al5/gxCcX2WE1m/oEWzgcRigcRkVFxZTUqY9HnA1O0c72hMpYtilbZnRxdxU63WfCX7IWu43dqHKZURc5hPrgftQG9qI04Uet/x1cDhn3I+5xYY9zFR6JrsMfQ+uw5WgVthw1YLcYWFfrwmxUYqElgGK3Y9jtH/heXall1oHrZtq/bW1t6nZ/g8LGxsO962T/+B48KTMVBoBk5kFBTwghhBAiiPGdGODlWMxLWr1XC8AXH9giT0sm0RPSkDBGv33DRXmHEoCAaUpN3Cy+Fmzs/CtWR3bCrR97z5sSK/CH5Nl4LHEyKlw6Tq/rwAeXaJg1q/R4wVZSgnAkip4eL+x2OxK6PqmtxLIhzrI9oTLWbRqvsVsm0seSTwdixauwy7YIKH831jeUo8a/B2Xt21HasQN2LYTVoS1YjS34JyfQbG/AU9p6PBJdj9ebluA1zIPdnMAijxcrSwM4fWlpxu3q/16lt32FE6irrx+xK0F3dyrbo6h34ich36meHsRjMbjd7qxG64fKvhjNPs9nXwuSf1DQE0IIIYRISzppTZfjHu56MoGOWDdiiYFGfDE91WPeGENbupEMxoYSgCI4xhp9HrMAMQyUdmxH3b7HUNa6Dabe9+VFMX6rn4vfJt6FRmMWTqgHvrBYx7ziJGz2hmEFW3l5mRJsAb+/T5xNphiaqCCe6IRKpn0+1m0aq7HbcM+T6VhCVRXaq+ahfeGFgJGEx3sQZW1vqs9czPbq40fwCRzBJxx/QsTkwkvGGvxFW49nA+vxh8B8PN4GnDw3iTPnm7C8BjCbjtXcp9+r+C7EeoCq6soR96/dkfJnkOsWq1VNAJlMZjUhJJNA2cpEGckPYLjnpxM+GSsU9IQQQgiZ2cSCQLAt52I+rEfQFfMeF4GPaAl4x9hjfrQGY0MJwLFEesciQEyJOKqOvIS6fY/C42/sW77DthJ3hM7HX5InQYMVa6ri+PaJZiyoEAFnydiWbLBgs5jNKC8vx9y58yYkyiRDIm5oiCQiiCSiCPdeRhMxaEkNupFQ3gaaoatLWd8cNcMSsMBsMsOihgV2sx1OswMui0NdOi1OuCxOuC0utd5EJlSG2+fZEuljZcTJBJMZofJFajQtfz+ssQBK299Cees2lLW9AVc8gAvwKi6wvQrYgJ1YgKf09Xj2wHp8a/8ilLnNOGOeCWcuMGFuWUrYy2s4HA7Eeo7vRJFp/8qxIahlfj8MI6nKNOx2GwyrNWuZKJmyA7w+H3q6e4CK8mEj86M1BiQkDQU9IYQQQmYuUT8Q6sipmM/UW36iPebHYjCWSQCOJTV4NALEGvOj9sBfMOvAk7DHfGpZwuLAC+5z8K2ui7A3WqeWrazScXGdjo2rnDD3mp0NxVCCbbiUaS2pozveg67e0aN54dMC8OsBtf/lUm7rxsRaAQ6HCSYUWz0othahxFYMd4kLbrhQ6ihB0BJHuVYKW40LkfbAkK74+Sr6xjKZoDuK0dVwhhoSvS/q2a8i9yLwi7wHsAoHscp6EF+wPogeowjPauvwzO4T8M131qO8zI0z5pvUKB/m5YY6jvt3KpCJICNpZLWd4ODJJknrD4UjOHL0CNrb24ac9KITPhkPFPSEEEIImZlEvECoMy9T7AUR8iLoc+WoPZI4E2EpEcdYPI7SkpKMEwci5Ov3/hm1+x+HJRFTj4s6K/DX4otwW+t5aA2lWo5JOvVH1pqxtMqOzsPH74uxCLakkUR33ItD/iNoDreiI9GNTr1LCXiv5h+T8HaZnSq6LlF1t80Fm8kKi8kKq9kCq0mGnEqbkDQSSCIJ3Uiq65JlEUvGEZXIfjLWdxlPaqpswq/L5EEQTdHWYbehyOlBha0M1aFKVDaVo9JeDpfuRFDzob6odko8DqYEkxnBiiVqHF35YejeNmhv/QVzIwfQEDmI8mQQV1peUiNuWPBKaCWe2r4B33ljI0prqrC2yIR31RkodppGdRwfW2aaFJO6/pNNEpkXMe9xu9T3ZKgJGPk+RWMx1VJvIt9bMvOgoCeEEELIzCPcnRq53AQ9ii5xsR+UYi+5Ar5IXKXaj5fJdtROp3yLAAkGQ0gmEirdPS1AXIijYcdvUXfgcVh6W+75iubimbLL8G/Np6LtSOoUdF4ZcPUJZqypla5oJiSlJ98YsxtC5jD2Jw7jQOdhHAgfRnOkDZoxdFaD3WxDpb1CiWMRy6W2YhUpL7WmLkusxSiyuuHrDKCluQlarDetvWrihml6UkcwEVLZAIFeUR/ozQxQt7UgejSfmnyIJWNqXRmN0ZRJXh82wBwzo8xUglKjGGW2YoQjOhqs9ZjlqIbH6kYhEza5sNu5AoerT0ZC1+Bs3YEFsQNYaTShXOvC2Zbtanzd9ivs9M7Dk90bcfvhE+Gsm4czFliwvh6wWYbP8Mi2MeBQzy2TXhKZH2rSa3AJhZ5IqMv+5RQFO1FDpgQKekIIIYTMLEJdQKQnp5vgjfvhHeRiL4ie9UbiiOkT6zE/mWKlf8p3WWmp6scuEUiz9IC3JHFW8m0seu77fULe62nAH61n4yfec9DWmYrIV7iAD68z4az5phFT6wcL+OZoG97sfht7g/vRGGtGIHF8qYIZZpShBFXmcpQmi9T1tfPWoL6kFkUWt5o8GOk9ipjPdlq71WxFmbkUZbbSEd+n1O6nSwPSQ8oFOuJdaIt2qBr+bsOLbnjVY7a1vA20pB4v6fy1jmrUOmtQ55yF2a5azHbWocSW2v/5Tv8ME6EZ1ThaVI+3q6pQofegpustrEYTynz7scp8WI2b8ACaOirxVOsG/Nq8EaaGVThtgQ1Lqwea6Q1mMj0H1PNWlKs0+6Gi7plKKETUT9QLgswcKOgJIYQQMnMIdgDRVA13LhATtY5ojzJYyyTmxck+npi4mJ9MsXK8u3w5rKYkzrHsx8qWJ2HTQmq9UOl8vFr3Pnxz73LsD6UErLQkO7WyA1edWomy4qG3KxqJQddTExExaxzv+Pfg7cBevBPYq6LZ/bHAjAb3bCzyzMNCzzxU6KXoPNiO0uJStX1SHy0R0TpLtapdH897nOq0dplwkCi7jLnu2cfdL2UFLYF2NIda0JX0ojvZg9ZoB1pjHfBqPhXtl7E3dHDA4+T9i7CvVwK/Vgn9eucsZdiXT/TPMFFp6Cazakco/ePbtSK0V5wObflyFJvjKGt+HZ4Dr6EmsAOzk124xvokrsGT8B914bnGdXjUuhH6vA04cZEHc0pNOX0vmbJlhjrWnA62rCOjg4KeEEIIITODQBsQOz4qPlVInXxHrEelXQ9GF2O8UBx6cvQ95nPFgPp8hx0NXVtxcs/zKNFTEyXh4jnYs/TDuL3tRDz1hlSMSzW6gROrfThnVjeSUS/MyWIAmUWkiNWX9ryC/YlDaLS0oBMDsymssKAONZhvnYMqvQzVqMCquasHmMYFbL4J1SEP9iCQXucSNZe+5fmAuOTPLqlVYzBSr98W60wJ/GibymiQWv2OWBcCegi7gvvU6E+VvQL1vQI/JfTrMMtZrXwCckX/DBN/IIDOjo7jBLEOJ9rnnYtOnI6aOUBZ5w6UN29BSfPrKNF8uNzyCi43XkH8oAUv7V+N552nQJt/Ik5YVIIK99SJ++GyZSbqd8Ge9YSCnhBCCCHTG3Gwl7Z00p4uRwS1MLriXiUKB6Mlk+gJacfV0ucr6Yijad+LOPXo06jR2tXyuLMch5d/CL/VzsbvXjMjqLztTJhr78BJRQexoMIBS8IMSwaxIpMcEn3f0vUWdvh3I4BAqltdLw3O2VhdugxzzfWIN0ZQXlyWir5bjeMi59nwD+j/HJ2dXSpK7HI6cPjQIWjaxGvpJxOJts9zz1GjP2LS1yICP9KKJhnR1KVP96Mz3q3GW/63+9YXw785rjrMdc1WzyWZAiL6beapkw/pDJOS0hJUVlYOWz6StNjhrduoBjaIa/4+lB7dAs/R11AZbcZ5ljdxnvYm9D0/xyu7VmCr52ToC0/G6oXlcNsnX9wPlS0zkeOVPeuJQEFPCCGEkOmLCOhACxAP5+jlDXTHfQj0pqEPJp5IojsUV87n+crgCKAj2Iqz9v8aFa1b1P261YWmZe/DX4svwS/esOFIqqQb1Y4Izp/VgjmuAHp6IujuDvX1iU+70e8JHsBrPW9gq3c7Qoljn5ENVsy3zMFCUwOqI+VYv3CdEnWyLbttu0aMZmbDP0Cew2azYu+ePXC6nCjyePKqRdxYcZjtmO9uUKM/QT3UJ/CV2I+2oCnShmgyikPhI2qgK7WuxWRREXwR90rku2Yr0W8z26ZMEMsx4Pf5h/9clWv+UjWw9mq4/EfhadyM4sbNqI0expmWnTgzuhPJnXfh9R3LsKP4JBiLTsHiBVWjMtPLdsR8uON1qOfL5/aFZGqhoCeEEELI9ETSo0XMa5G8q5cXoloCPRFxY89fMd8/AuiyGDgnsR2Lm5+BOanDMJnRuvDdeGve+3HnjmJsfj31PorswOVLYpgVfQelJVIX7FH1zwG/Hw0NDQgXRXDf0T9iS89bKjqcRtzl13hWYJG+HK6QDo/NlTJFs6XSkscazRyTABwC6VEu9ewi5qdNi7hBFFk9WFa8SI3+E1FivtcYblLjcOQoDoePKqO+xkiTGi92vdpnQFjvmoUF7rlqsmCBp0EZ8Yn4zzaZItJVVZUjPi5SMgeR1XPQufoDaA62wnlwM4qObMbc6H6cZNqFk0K7gLd+jbfeXIR3Sk+BackpmD131rBmeqPdvtFmc2SK4A/3fLn2eSD5AwU9IYQQQqYfyQTgbwb0zGJ6stGSGtqi3Rnr5QXpLy995vOZvgigYWB98gA2tjwBT6+jvLdmLfav/gQeaJmN3z9hIKYbEO1z4WITPrjWBGvSjN27jtUFh/QQ9rkb8UTXy2hubut7DenvvqFsDU4uPwFLixYChkn1oW/B7iEF+1ii7xNNSZ5ofXOhIpMYNY4qNU4sX9cn8sVpX8R9SugfxeFIk4rwH420qPFC1+a+1oDzXHMw39PQJ/SlTeBI3QWGY6iIdJFHnPtH/7yxolrE1rwPvjXvQ3uoA6b9r6L0yGYsjO3BWtN+rPXvB16/F7ten4ddxRuRXHwq6hbMG/f2DRcxHy6aP9LzzdRjkxwPBT0hhBBCphcJHfA3AYncCGaJyHdEu4esiffHdIRi+S3mBREaFaFGnBd4DjWRlLDwWUqxf9XH8VbJmfjFywaOeFNR+aVVwPUnmTGvPC2snKitn43XmrdgZ3gvDpmbkEQSiKVqszeUrVYifmXxUtXKLU2y12NgydKlfS73w0XfhyMbKcnZqMefLogYr3JUqLGxbG2fyO/RfDgcPoKDkp4fSqXoR5Mx5bDf32VfHPbnu+digaT9e1Kp/5IdMFqGjEhrYtbgGNd70jzVwNpL0bH2UnSHe6DteRVlR1/FstjbWG46jOWBw8C2B7Br23wcqDoN1hWnobh61ti2b4iI+UiTTSM9H49NkoaCnhBCCCHTBxHxSsxnjoxPNiE9gs5YT0bzO1nii8QR0bLXlm6ysEZ9WLvrbtS1v6huayY7Xi87Ha94TsWW1tV48dXe9HoHcPV6E85ZaOpLT44kotjUvQXPdL2EdnRKTraiwTUbZ1aepIS8tGMbDqfLAbN5YqI5WynJ2ajHn84iv8JepsYJZWvUMvFGaIt14KAS941K6Ev0Xhz2t/vfUSNNtb2yr93gIs985bIvDv6ZGDIibbPLPNGESbjLYV5/EdqWnYOXt29DUU8jloZ3YV1yF5abDmF55yHghd/ibfNiHKo6DfaVp8JTcUyAjyViPprJptE8H49NIlDQE0IIIWR6oMdTYl7S7XOATwuiJ5a5x730mPdG4ojpeS7mDQPVh5/F/O2/hrXXyG930Wq8UHQmtkQX4vnD9QhrKcF13iITrlpvQrEjJeTboh34a+dLeKlrC2LJlMRymp04teIEnFF58nGu65NNNlOSR5MRQFKIIJcaehmnV57YV4JyJNKSEvi9UXwR/VKnL+OVnq1qPYfZoSL4KZE/Hws9c/smf4aKSMvkTxCqpUJWkImbCKywzl2H7eb1eKW7C862fVif3IsTjL1YmdyHle37gPZfY6dlKRprToN9xWlwl5WPOptjNJNNo43A89gkFPSEEEIIKXy0KBBoThnh5YCumHdIJ3sR8z3hOOKJ/BbzzkAzFm77GUo7U63LQqXzceCEG7AtPhf3bjXjgDdlcja3DLjhJDOWVptUJsKuwD480f4cdvh39T1XraMG76o+A6dWbITTMr506InClOT8QVzwRZzLQHVqWUgP42C4EQdCh7E/dBgHQ40qVX9XcJ8aaeqcNSp6r6L4JfOwpGgpEprely2RlC/YJE0EWaxWdIeiQNEcJGZtwOZQEGXdB7Em/jbWJPdgVWIPVrXsQbL5buywrYB91qlYsPAEmOypGvehJoFGO9nECDwZDRT0hBBCCClspCWduNlnSHOfbJQbeKwHYT2zk76WNOANx6HnaKJhNJgSGmbv+SNm735QudcnLA4cWfEhHFlwCR56x4yH3jaQSAJOK3DFigTOnhOF3WHFlp69+Ev7s8r9XD0PTFhTskIJ+RXFSyZkgJYtKIjyF4m8ry5ZrkY6Vb852ob9oUN9Ir891omWaLsaaVd9MVIUcS+TA4v0+ZjnlMyPzGn6E54I8vthGElUVFTAbrfBZi1Dp3kxmpddijY9jvg7r2B+5yYVtV+rv421TW9DP2rGDtsqtNRLzf3JsHmKh3+NUXZrIGQoKOgJIYQQUrjEgkCwLSdiXgRIe7R7yLZ00mNeIvNpo7d8pLhzFxZu+yncgSZ1u2fWehxcfwPejlbjf59M9pnenTgHuHy+F/6ug3h4/15st+yBHynHe5vJhjMqT8IFNWcpV/TJ6NM9EYYSRFO9HWTkVH3paS/jnKrT1LKAFsSBcGOfyJd0fWmdJ9kg6YwQmUiqs9RhedNCLClaoEaJ7XgRPZ6JIBHbjY2Nqn2hkTQGRNJdpSXwnHkZfLgMfzpyBMm9r2K571UswyGs17djfeN2aId/gbcca9E++wwUrTgRVqfruNfI1THI43/6QEFPCCGEkMIk6gdCHTkR83oygfZoF+LJzG71YnznzeMe85Z4EPN23ItZh55Wt+OOUhxaew1aak/D73cAf96VVLu12AFcd6IJKypD+OPeJ7ENOxG2RNVjHLDjvMozcGHd2Si2SeuwkZloG7lskS/bQYZHjqt1pSvVEHQjgaZIixL4+4OHcSB8WLXSa040o7mzGc90pkwcZWJpsScl7mWI+d5YM0aOTQSZho2kq2Opswta0Vw0ly/CVqcTpW07saT7FSwxNWJjfBtwcBvCBxx4w7UR3Q1noHT5OlhttnFH3ycqxnn8Ty8o6AkhhBBSeES8QKgzJy8tBl+t0S4khjDfC8R0BPO4LV15y+uqVt4e7VG32+a/C42rP4YdXg/+9/EkWgOp9U6fZ8LVJ+h4M/Qqvnng6b6IfImpCBstazAvUofVpatGLeaz0UYuG+TLdpCxYzVZlLmijHdVn6mWdUV7sO3wPrS5jiih3xRtVan6Ml7ufk2tU2ItxmIR970iX7IAMrnpZxLKw0XSMx1L3mgUs065FB3O92P30SZY976EVd6X0GBqw+nRl4G9L6NnTxG2eU5FYMEZqFy8DBZLyp9iKsQ4j//pBwU9IYQQQgqLcHdq5FmP+XxvS2eNBzH/zbtQfeQFdTtSVI/9G25ER+kK/PZNA0/uSar3UOYCrj0xibDzVfz7gb/Cq6Wc+4vgxkasxnr7SmgyYWFLmXtNdRu5iZIv20GyQ7m9DGvta1E150SYzSZltif19/tCB7E3eBCHw0fg1wPY6n1LDcFpdign/cVFC7HYMx8LPHPh7fQNKZSHiqSPdCxVNswBGj6CI8kP4a1D++Hc/yLWBTahyuTDu8JPATufQsuOSmwrPh2hBWeidsFcWK3mSRXjPP6nHxT0hBBCCCkcgh1ANHNruMlGjO86hugxn+9O9uXNW1JR+ZgXhqQQL7kMR1d+GDu7bPifR5Po6DXoP3thAovmb8EDnc+gpzO1n8ttpXhP7flYkliA9uZWhIPhYU28pqKN3ETIl+0gk2e2t7Z0hRrpjBppkyfifl/oEPYFDyGajGJnYI8agsVkQbVRjjrUYJ57Niq00iGFcv8o/miPJZPZjIqFS4CFS7Bb/xu8tn8nSg6+hHWhV1Fn6kJd8E/A9j9h31uzsbXkTEQWnoH582tgt5jGJMaHSsUfzzaTwoGCnhBCCCH5j4joYDsQ680Hn2KkJZ20pis0J/tUVP6XqD6Sqi0OF9dj/8ZPo6d0CX73loFH3klF5Ss9SZy15g1sCz+BbS2p91lmK8Els96FMytPgc2cOmUsLykbd+1uvrSRy5ftIFPXMm9JkRjmLewzs5Q6/L1K3Kei+D7dj1Z0qrFNS7VtrDBKsax5F1aVL1Np+pIJkCndfazHktlqRdmydcCydXhTuwHhPdtQ0fgS1kS2YrGpCYsD9wFv3odtbyzBG8VnILboNCybWwqnzTSsGB8qFT8b20zyGwp6QgghhOS/mJe2dNKeLgf44gH0xP0F52Rf3vxab1Tep6LyjQsuwZ55l6E57sHP/yIO9rKWgRMW70Go6DE87WtVjyu1luCS2vNwlhLytqy20Bpcjyz4ff4pd/nOtcM4yR1SO9/gnq2GtFiUjJuj/ha8dOAVtKAdraZO9Bg+dJt82OR/XQ2hwlqGKr1MRfHnexpgjVuVKF62fLka4zmWzDYHiladiviqU7E1GoS29zVUHXkRS6M7cYJpL04I7oX+xt14edtqbCk5HYmFJ2FWTQO87UcGiHEhUyq+zWbNuHwi20zyDwp6QgghhOQvEvUONANayll9qumO+eDXUmZwgwlrOnwRPe+c7FNR+TtRfeQldTtcPBtbFl6F7T4bXnkthJe6SiC5BMXFR1G/4DHs0/YDMcBlcaqIvJiN2QcJ+Ww6cKcnBTJFDquqKjFVsL83EcT9vqG0Hu+afXbqeIxr0GwJxCoS6LB0YW/oII6Em9Gte9ENL/bgEJ6LvwoXnKhJVuJIezvWVK1AQ0m9St0fL4azCNY158G75jxsjXQDuzeh5uhLmBffj7NNb+Hs4FuIvvkLPJ3cgD2e0xGrW4H1DQ7UVDnVpFimVPxIODJkin5JaQmF/DSBgp4QQggh+Ym4yPubAD2ek5fvjPYgqIcLysm+tO1NLH79f5SDvaqVX/pe7J1/GTbtPIJHmhtwNOKBydaFqvo/I+Z+B81ayjn8vOozlJgvsnom9PqjdeAeytyryCOO+WNrL0bIZGdtiBnmOz178dqR19GMDrShExFEcdjchMPdTfhT95NwmO1Y6JmnnPTFUV+M9mTZeNBdFcD6S9G8/lJ0BZph2/syappewiytGZdaNuPS6Gb4DrjxyN5TcI/7LJhrF6FcL4Y1ElXbnU7Fd7ldrJefAVDQE0IIIST/SGgpMZ+QCPjUIim4Yn4nJniF4mRv1mOYu+Me1B34i7odKarDvhM/i0D5IjyzM4LfHlgC3RyBq/aPsJVtRsyUVLL5lPINeF/9xai0l094G8biwD2kuZcmkzeOCW8LIdnM2nBaHDihajVmJ2vVMR3VovDaAgiVxNGCNmW2F05E8E5grxqCROvnuWan2uX1uumLYd9YiRXXI7bhgwie8AG0eQ/CdeBFzGp6GaV6D662/hVXx/+KI4eq8VDyDDyOk2HyeLC0JIhTl5ShvLwMmsZ6+ekOBT0hhBBC8gs9BvibUxH6HIj5tmiXisgVgpO9iGhX5x6sfvtOeEItalnLwotUX/ke3Y6fv5DElqNW2Mo3oajmScAcU5MSDajDVfOvxOLyBcc933jrasfSDmtIcy+bXbL/CSmoKL4Y7TVH25TJXrpdXo/mw4FwoxpPtD+n1qt31iqDPYnip432Ro3JhFD5QoQ2LkTnho+jpONtlB56AdXNm9GADnzO/BA+h4fwZmQhHgyeie+1nIY59UmcUF+BZfOL4DazXn66QkFPCCGEkPxBi6TEfA5M5uSkvD3anVHM56OTfUdbG2p33o+N3pdgQRJReykOnPT38M1ajy1HDfxscxIh6x54Fv4ZZke7ekylUYYzTBtx8uwTUVNeNa50+aEYSzusoZzmnS4HgshNiQUh443ii9HeHFedGudWn64mBrviPar+Pu2k3xprR3O0VY3nOjepx0lmTErcL1SR/FpHtarpHxGTGf6a1Wo06dejvPV1VB5+HuVtb2Kd+YAa/8/4DZ5vWYsHj56Ju5IbUV/hwfp6E06oN7CwUraZpS3TBQp6QgghhOQHsSAQbMuJmE8YCSXmY4njxWRUT8Ab1mDkk/ld5yGcsuWHmBVrVjf3eZbj+cqLUedejt+/msQzhzvhmPVnuIvfUfdLbfylVRdgo2s1HI7jBclY0uWz1Q4uU7QzKWkQhBQ4IsqrHBVqnFaxUS0LaMG+6H3aaE9Ev4xXeraqdYqtHizurcGXCH6Da2SjvaTVga45p6thjfpQ1fQyqhpfQHHPfrzL8oYaAcOFx/0n4UHvmfjajpUocpixrs6EE2YDa+pMKLJT3BcyFPSEEEIIyT0RLxDqzMlLi5hvi3Qhnjze5C4U1+GP5pH5nWGg5tDTmPfmr2BNxhEzO7G57lLsL16DA10J3PFMEl7XE/AsfBYmcwJmmJXh3eW1F8JtdWUlXT6b7eDoNE9mCsW2IpxQtkYNIZqI4kCoUYl7EfkHQ4cR0EPY5tuhhuAwO7DQM3fURnu6sxStiy5RwxloRnXjC6g68gKKwx34kPV5fAjPo9WowEOJM/Dg4TPw34fmwmwysKgiidVVOtbPNmHJLMfosgRI3kBBTwghhJDcEuoCIj05eWk9mVA189ogMS9xYn9EU63p8qkd3cKtd6Cy+TV1+6hzHp6pvgy6pwYvNBfhhZAfjtr/hsPepe5fWbwUH5nzXtQ5Z2U1XX4kKNIJGRmnxYmVJUvVEPSkjsORo0rcp2rxJ2a0Fy2ux5FVH8GRlR9CcdceVDc+j8qmV1CrdePvrH9SY69pHn4XPwN/7DoDD3aV48HdQJlDx4Y5FqytM2FVLRi9LwAo6AkhhBCSGyS1PtgOxAI5eXktqSsxLyfSuTC/G4sBnRhgLd7yYzgiXUiaLGhcfRXeLDkFbYfb8fA+DzpKnoVr7pupda0l+EDNJVjpWAK74ZiUdHlCSHaxmq1Y5JmvBmadN8BoL52m7x2P0Z7JjEDVcjUOrrsO5a1bVdS+vGUrlhiH8S+2w7jF9lu8YVqOe+Ln4NHYyXhmvxPP7DfEhw+LKqDE/ZpaExZXyXYyep9vUNATQgghZOoRc7lgKxDP3Od9spGIfGu0C4lBTvpaMomekIaEMbnmd6M2oEsm0PDO7zF794MwwVDt6Pae9Hnldt14JIFfefcA9ffBZomq/u1nlpyEM2wbEWj2Y4+2Z8jnzjSZMNZ0eULI5JHJaK/J34o9gX04HG/CgWgj2mIdYzLaMyw2dM8+RQ3J+HHvfQblB59FfbwJG4x3sMH2Dr5luxNbXKfgXv1cPBZYhn1dZuzrMvDADgMuK1TUXsS9jNrilF8AyS0U9IQQQgiZWqS3fKAZ0HPjZh5PaGiLdh4n2qNaAt7I5JvfjdaAzhFqx5LXfoTi7j3qdvu8c1WELQoHfv5aB7bE7oe1+qC6r8ZSi3MSJ6C4w4ODwUPwuF0oLy/P+NzDTSYwXZ6Q/KSjowudTW0o1pw4wbYcl86+AM5yZ5/RnkTyGyNNozba0+1FaFv4bjwfn4tirQeroruwyPsGSnQvzoy8gDPxAkLlNdhachZ+r5+FpztrEIwBW47KkN9IA9WeY9F7pufnDgp6QgghhEwdIuJFzIuozwHSkk7c7CWdtT+BmI5gbGrM70ZjQFd55CUs3PYzWPUIdKsLB064EV0NZ+BQdwL/9dbziBb/BVaPBrNhx3trLkRtR4kywIMD6rni8Tj0ROK4586Gmz0hZGoZ6nu7rHg5NpStUSNttLc/dDiVph8So73GoY32VJr+QlTXz0JHM/ACTsQrc07FmuIolvrfREXTK/BE2nFW5A84C3+Ar2o53q46B48lTsaWdhd2dwIdIeDpfYYa6fT81SLuZ5mwtAqwWxm9nwoo6AkhhBAydT3mAy2pdPscENaj6Ih1q9TVNHLNF4kjok1uvfxoDejMehQL3rgTNY2p+thAxVLsPelziLqr8Yd32vF49/0wlx6CnCbPti/CZxZ/GPaoFbubd8Nd7FYi3m6zIa5pSOg69N4ofNrcLltu9mSsmNRnlik7WQ7H1BHJln0kM6P93orR3qqSZWqoxyV1NIaP9jnp7x/CaE+i9vNL52BJ8SJEy9dhv/U0lQ1U0fyqMtMrbd+O0q5dOK1rF062/BLd9SejaeXZ2JRcjTfbTNjeIuUAwL4uGQYe2mnAZgaWVAOrZ6UE/sJK1t9PFhT0hBBCCJl8xPhODPBy0GNeCOsRdMR6Boj5hGGgJxRXdfNTyVAGdFXRZix54b/hCrbAgAlNy67EkRUfhDcG/Mem59Dh+AvMbh0mw44r6y7Fu2tPVXW2kWR0wASB3W6HpicQjcXgsNsHmNtl081+pmM2mWAxmWA2H7sUv7D0daktlusi4kcTp1RJzAaQhIFk0khdNww1EiL6ZRlS1+X+9H1k+jPe761NjPaK5qtxcZ/RXmvKZE856YvRnh+HIkfUeNa3CTjaz2hPxsmfwSxdV0Z6NYefhyvYjOojL6qxwlWJjoaz0HHOOWgy12FHm4EdrVCX3gjwdpuMVHq+1N8vr4ES9xLFbyhLfYfIxKGgn274m4GyesBiy/WWEEIIISmiXiDmy9neCGphdMYGtsWLJ5LKyT5XgmiAAZ3NioVNT2Pujt/CbCQQc1Vi34mfhb96JV5qasPdjb+D4WpUorDGvBg3Lf8QqhwVQ04QuFwuzGloQGlJyXHmdnSzHz0iNqxmMyxmwJK+NJlhsfQK9SwfE+kIvlmuWUb37EbvxJQI/IQMEf8JA3rv5WSbO5KpIVvf25TRXr0a51WfoSY4O+PdfeJeLoc12tvwEaxNmLGu+U1UH92kum7M2fOQGovLF2PlvHPwrhNPh27zoNkP7Gwz1BBhH4wD25plpAR+kQNYJQK/1qSi+DTYGz8U9NMNLQp4GwF3BeAqz/XWEEIIIUCoG7BacrIn/FoI3THvgGXSW94XkRr+3EY35WS82Kxh8es/Uq2khK76k3Bgw98hanHhv998Du/oj8Pk1IGkA++pvgzvazglo6v0WBzq6WY/GBPsFjOsFhNslpSIl1EI3blkE62m3gmADF8xacGoJ5OpIUI/aahLCv3CYzK+t/JbUu2oVOP0yhPVsrZAJ/b69+Ow1oSD0UYciTQfZ7TnsbixZOWZWJOw4PSuIzi5dSeKe/apMf+tX6G77kSUzz0Hsxevw7uXWtTE6eGeXoHfauCdDiiDvc1HZKQEfoU7Fb1fNQtYWWNClYcO+qOFgn46ItGGUBcQDwGeGsDKNDpCCCE5+FsUbMvpbvfFA+iJ+49tkgj8qIZwXM+L3vJFXXuw9NUfpHrLm204tPYTaFtwIQ4GvPjernsQs+2TFtIo0pfgSys/iHrPsah8JsbiUD+T3exFrItwt1vl0gyb2YzpikxKyGSFDNgGCv24nkA8aUDTkypjJdcTXCT331vpgNHSdBQOzYxVtoW4cPbZKK4swoE+o71DOBg6jFAijDf87+ANAL92AvYF87HM7MGJAR9O8bdjXfNmrGh6BXFHKTobzkTHvHOwoGIeFlSYcNkKmWQysL8LStyLyN/TCXSHgRcOGnhBNe4wUOmWFH0TVtQAK2pMqGOLvOkj6G+//Xb853/+J1pbW7Fu3Tr86Ec/wsknn5xx3bvuugvXXXfdgGUOh0PVncyYaL3vCKP1hBBCphapSRcn+1goZ3tehLwI+r5NMqBS7OOJRO57yxsG6vb9uS/FPuKpxZ5Tvohw2Xz8/sAbeKL7D4AtCiNpw6LwqbioqAHWUBLwTNqmT2skTd4h4t1qgsNqUenyMx0R+k6bBUoaOlJSPq4nEUskewX+1JlEkvx10m9sPIy5mIeFxfOwqj5ltKeL0V6kqU/gy6UI/O0JH7a7gV+6a6TfBpbEdWyIRLCh5a/YcPBxuIsalLAXgQ9HCZZVA8uqTXj/GiCmp0T9Donetxs40AV0hYGXDhl46ZC8qoESJ7CiOiXuReizBr9ABf19992Hm2++GXfccQdOOeUU/OAHP8BFF12E3bt3o6amJuNjSkpK1P1pMqWpzYhofSwIFM1itJ4QQsjkIu3o/E1AYmpawGWiK+ZFQDs2mSDRR29Ym9Q049G2g7PGg1i05SeoaH1d3e6cfRoObPhbSFHAf2y7F23YplKnTdF6XGI+FSuqMveSJ0Mj1e0OWyoqbbdaYCuE3PkcI3tIJj1kiMCXCbCoriuRH9XEpo/R+5nmpJ9IJtHT04N4LAa32903QWk1W7HQM0+NdyupYaA11qGEfboOX+ryd9ut2G0vxm9RrJ5/thbHhuY/Y/3BB7C4eBHcc86Dt/5EGGYrHFbpZQ/Vz16I6gb2dUKJexly3R8dmKLvsQPLq9NRfBPml4vXxcz8rheUoP/e976HG2+8sS/qLsL+kUcewZ133omvfOUrGR8jAr62tnaKtzQP0WOpaL3U1cuYaRMbhBBCpuZvjZizJnMX3euM9iCoh6e8Xn40baWKuvdg6eYfwhHpRNJsxaG116gU+61dh/GzQ/cgYfHCMEyo08/BRaZqVJaUsLXcGNLoRYxK1FnS6HmWMzFEF7ltVrhtgOECYloCUemcQHE/I5z0LVYrenq8MJnMKC4pUS0wh5pUFK1V56xR46yqU9Qyr+bDvuChXoF/CEcjzWiyWdX4U7GkGnWjrPV3WNf4WyxxzcGc2tNRU3MyrL2m3k6rCYtKo5jriuOyJXZY7Q6Voi/ifle7gd2dQCgOvN4kIyXwnVZgcVUq6i9jSaVkocyMX4KCEfTxeByvv/46brnllr5lZrMZF1xwATZtSjkwZiIYDGLevHlIJpPYsGEDvv3tb2PVqlVDrh+LxdRI4/enau/kj7SMfCW9bdKmZvgVO4Cwj7X15Ngxk8fHNckveMyQYYlHgGDrgLZ06b9JI/5tygIpt2YvInqqrE62IhDRENYnr16+P1arHXabA7FoHA5n6lJuy/JkIon6/Y9i3s57e1PsZ2H3STchUDoPd+15FptDj8NkScLQKnBZxUdwVkUF9u/bh1A4Ao/bPfC5JHQ6jUm/v9G8T7vFokT84Ch8Uvq6kawiPgM2uxlFdiCqJRATca/nR939WI4ZMjRSllxfPwctzc0IBoIq06W8vFy1wTSsNqWp4rG4Wm8kSiwl2FC6Vg0hkojiYLhRCfyDvt04EG2C12LBcy4LnkM70PoQHC0PYrGlFAvKVqMCs2HvNsOsm2Cz2lBXX4+l1ZVYWmXC+1aaVA2+mOzt6oAS+HIZ1iRlP5W2L8el/CTMKwOWSmp/lUldlrtSvxMJ5RmR/+fAo90+k9G/IWse09zcjNmzZ+Pll1/Gaaed1rf8y1/+Mp577jls3rz5uMeI0N+7dy/Wrl0Ln8+H7373u3j++eexc+dOzJkzJ+Pr3HrrrbjtttuOW37vvfeqdBNCCCGEkNFiTYRxwuGfod6XSrFvKjsZb8y9AV1GEv/b8wD8tlRZoD28Fp8sfy/qmVJPCJnm6IaOVr0JneFX0RTbjV2WEHosA9s0mAyg1jILc63zMc86D/Ot81FiLsn4fEkDaAkDBwMmHJDhN6Enfnx0vtJhYGGxgQUlBhYVG6jNc2kXDodx9dVXKx0rZeQzUtBnmuVYsWIFrrrqKnzjG98YdYS+oaEBnZ2dw+7IXCPv7cknn8SFG5fANpbWQJLaIk74tpFn28j0ou+YufBClWJFCI8ZMu4e89KWLtPvjJ7Ak6/vHfvfpjGQMBKqx3yst2Zf6uV9kdHVy3d2dKlolKZrfVGgqurKCW1PNBKDpklveTsq4m1Y/ur34Aq1ImmyYs/yq9G19BJs7jiIXx29F0mLH0bSiiW4HJ9acgJikSCOHD0Kq9miovyhUEhlGC5avBhlZaWYCUiUtfuIhooGG8wq6m6CU0XhzXBarQXRSm4mkjAMFbmPaAnVIi+3xwwZ/FvkdI39PH8yfh+Heu451aUoimzD0fbNeCfhxTanA0cynJtW2sux2LMAizzzsdgzH7WOGpilFUgGukIpo709nQZ2dwCNvgEJZFhcksTDN52f1+fAokOrqqpGFPQFk3Ivb8ZisaCtbWALHLk92hp5+cBOOOEE7Nu3b8h1JI0kUyqJPDafP/A0csI0tpOmJBBuBVxlgLuStfUzkEI5tkn+wGOG9BHqBGK+EXvMj/1v0+jQkwl0R73QocNiMaXq5aO6Cu2YR/CKUSZ2zSkTu6IiT8p4rvkoiksmZjzn9shjnahqfAELt/4UlmQcfksJHq28HN3Revz1zUfwDl5MpdjHq/Hh2o9jncuOg/t3q2hMKBxGRUUFnGYHPB63qsO3WswzTqi4pH7baaGILxAsSLUBLHHZoCWTiMRT4l76j08V8h2Zad+TCXfcGIaaWVXq9zBTG850e04xzrOocoyR23QO99t7pKMHy5ZfjEVLrsCizkO48q0/oiK8E3utcWxzOrHV6cBuuw1d8R41NvdsVY/3WNwpcV80H0s8CzDXPQc2c0reVhebUF0MnLEg9bphLWWut7vDwP5uG+ZYInl/PjPabSsYQS/1Gxs3bsTTTz+NK664Qi2TWWu5/dnPfnZUz5FIJLB9+3a85z3vmeStLUAiXiDe64Rvc+V6awghhBRCj3npoJIjtKSOtmiXaqGk+stLvbymZ9XEbjyYEhrmb78btQeeULf3W2bjQdf50BzleCD6IqLORmXYZguuwafnXohFNeXYvWuXWlfMp8KRqDKjkvMeMaJSJ5x2O2YCUhNvt5nQiTjK3XY1SUMKtN7eaUax05aqtVeR+/yot58JjLbjxnj73qcnC4LBEKKxGFxOmXz0jGrSQLatp7sHsXgcpUOZflbNR9Pqj+G1o0cwK3gAV0bfxpe8exAzNLzpcChx/1pJJXZYDNUu7y3/22oIVpMVC9wNWFy0QEXwxYnfY03l1bttJqytA9bWmVBWVIk9249gulAwgl6QlnXXXHMNTjzxRNV7XtrWSTpa2vX+E5/4hErL/853vqNuf/3rX8epp56KxYsXw+v1qv71hw8fxic/+ckcv5M8bjXkawKcpalovTlzCgshhJCZ3mO+BdAiOduEeEJDW7RTpdVLqq+0pBtr3+z+js5yQimXExXP9nAnlm7+Pop7UpmAm4tPxVOmNThsDWMTngCcIdVbfk7wPFxWXAW9uw0BiWj2m1goLy9Dd3c3An5/X6uo6dyqTjIpXDYLXHYxtjMjQUO7aYNMxzitkmVhUT3EpQ1eJM4e95PNZE1W9p8s0HUdCdENMNR1PZEYcdIgPREgkwAyGZBMJJTpXqbfXpkYkOfS4ovQZL8UXquByqZXsLrxOZze+Q7g9UGKrHa6i/FSzRK87vZgl9aJgB7CXnHWDx3se656Z60S9xLFl3R9SdufbhSUoP/IRz6Cjo4OfPWrX0VrayvWr1+Pxx9/HLNmzVL3NzY2Kuf7NNI7UdrcybpywEiEX2rwV65cmcN3UQBEfb3R+hrALq0lCCGEkN6J30AzoMdztjsiiRg6ot1IGiIMkugJx8eV1isnnSKW5QRTTnbTaanjPeEtbX8LS179b9jiAWhWNx4rvQgt5auw2bsDB4regMmURDJWjY2BU3FWXSWsFot6XTkh7j+xIOmrcs4yd+68ad13Xpzp3TaLajPHOPzMaoOnJQ2Vjh+NJ0bldUGQ88nKwZMF8nziFO90OFUnMpvVqi6HmjTonzVQVloKI5lUXTzM0qnCbs/429s/O0COko7556nhCLaiuvF5NdaHO7D+UCr9PlxUhzfmnIxXymZht9aJfaFDaI91ojnaqsbzXa+kXt9WguWly1AXm4P3YHpkbReUoBckvX6oFPtnn312wO3vf//7apBxID2E/S2AoxjwVDNaTwghM5086DEf1MLoikuvdgOhuA6/1MtPII33WBTo+BrRwbWiQ9aIGknM3v1HNLx9H0wwECydj7fWfxb7D7fiD+GX4SvepwSr2b8aF0bnYU6xTYn59Em2RNEGTyyImB9rvWvBROPtVrjtFlhH8Dgg0xdpMWhzWFHisCKmJxHRdKbkZ5FsT1ZmmiyQqLzFYkY0FlViXhuhPGhw1oBMWprMZjTMaYDL7VITmfJbO5ptjBXV4ujKD+Poig+ipPMdVB9+TkXv3cEWnL7rjzgNJvhq1qBj3jk4uGAF9sWalbjfFzyExkgTvJofr3S+hhW23JWMYaYLejLFxAKAFk6JekcRdz8hhMxE4uFUmn0OG+P44gH0xP2qPZE/GlcRvmyQqUZ0tMZSlngIi7fcjorWVEu69nnn4eD667Ev2I27E89Ad3TCMCyo9p2Ha+cug9thQ2dHx3En2TJGmlgoZKYyGm8xmWE2WdSlyWSCWbppy7LeV5ZlQ21D+uiWCaPUP7meRFKuG4bKCkkgqS4LpElU3uOwmuGw2pmSn2VGM1k50ckCi0WEfAJWq1VNUg43aZApa8DpcKjv0uFDh8Zn3mcyw1+9So2D665DZfNmJe5LO99GWftbaiywurBuzmlK3AfqL0Pc0HEofARH4x0wd0wfbxIKejIyEo0JtALxot5o/eS0HiKEEJKnE7vB9pyK+c6YF0EtpFJ1veH4lLTFGslYyu09hGWbvwdnqA1Js02dULYvOB9/bnwTD3f8DrDGYWgleJfrw7ji1Hl9J7qVlZUZT7KHm1goREQ2S128225VEdlsIS2qxMXaZpLntcIqQwl4i2r3N1UocW8koMtlUi511XVBNxLQDF0tI+NLydcNQ7nkR3PQAm86MVm/Kf0nC0bjcp/Ocqqqrh4woVlZVaVuZ8O8L2lzoWPeuWo4Qu2obnwO1YefhzPcjlmHnlEj4qlVwr5o7tk4ee6p2OOjKR6ZiYibcV+0vjjXW0MIIWSyCXenRo4Q0dQR60FEj6qTe29E642b5tZYak7n61i09Q5YEnFE3dXYc8rN8JfOw/e3P4I9+rOAGbBEF+ILSz+O5ZUD/15ON+E+GDG2czuy025OxLvdbIPDYleXMtItqXKNbJuaXJAbGeYRJIIvnRhE3EsnhvR1uZTjmgyNlGMUO6xqiE9GOK4jqqk8Ce62PGG0v2ODs5xExIu7vUwAyG9pa0tL1s37Yp4aHF3xIRxd/gGUdO5C9eFnVUq+K9SKuW/fh4a3f4dw7QkIOU4BWENPZq67cW+rIhH2lvz4w0oIISTLSFQ+6s/ZbpVoZ3u0C/GkBn9MRygmnsZTR6YUUUkdX37gAcw7+Jhax1uzDntP/jw6kmZ8c+tdCFhS7ecq42fjnzdegmJ79v5GjljLn1PEqd6sovF2y/g75Ei03WmSfeZDnasKbnu+vc/RI6n9dosN9pTkP+7YluNaCfyE1nedafzHI8eT3WVHki75BfVbIq8h4lwMyyUdPx2B7+rsRFVVVd/rTpZ537GU/JVqSClURdNm1DQ+h9KOnfC0bkVD8ejbnOY7VGNkfMRDgB4B3FWAs4R7kRBCptPEbVDKrMK5bUsX64KWSKAnEkdcT+TcWKrIrOMy/+Oo8aZEe9PS96Fx1UfxZmcn/ufgXUjaOmAkrTjJ8UHcuH6DEnTZYqRa/lyb3HnskvI+9vdrMVvgsjjhNNvhtDhUyrzU5AKtsJmPF8LTBXmffeUBtoERfRH3sWRcXcqgyM+ckh+WlHy65Oflb0n6NcLhMELhMCoqKjJG4CfTvG8wSasTnfPOUUNS8htaX8eBQCUqMD2goCcTPOlrT7W489QwWk8IIYVOHrWlk57V0l8+W22tRhOVGrxOulbU0X0AG976CVyRDiQsDuzf+Gl0zTkNv9v7Dp703QuTLQroJfib+mtw9uy5Wdne0dby5zKt3mWzjsnkTiY5RLiLiHdZ7NNatI87om+xoQhutUzEvIj6qAh8Ke9ISs0ya/MlJb+kn0t+KDq12TuFykR/S0b7G9r3GiUlCEei6Onxwm63I5HBCX+yzPtGSsnvXHcN2rezhp6QY0gURzsMeCRaX8o9QwghhUgetKXzayH0xH0IxrQJt6Qba1RqqHVmd7+BxVt+Aksihqi7BrtP+xK8ngb855Znccj8KEwWAw5tHr688hNoKCqZklp+r8+Hnu4eoKJ8SkW9lBwU2a3KmXy0iNu8CHi3VUS8M6uZC9Md2VfiHyAjHcmXKH5MxH0ihkgyNuMFvhyLVpcdRxBBicOGWCIJjUZ6Y/YFGel3ZLSR/ePb05Whu7sbAb8fbrd7xH7zZHwwQk+yg7gfBztStfVFEq3nrDshhBQMOXayl0hkd9wHXzyU1ZZ0o41KZVqn5Wgj1rU8jvn7/6SWe6tXY+/JN6FJc+Fbr/4BUderKjpdj5Nwy4Yr4bDapqSWv6enB6FwBEeOHkF7e9uUpN9Lu7kih7jKj07Ii1mcW4l4F1wWB0V8FlEO/2YrimzuPoEv4j49spXRUoiIh0OxxaQEvUrJ1xJIsr3gsL4go6lZH0tkf/BriAO+9JyfO3deTrOKpjsU9CS7aBHA2wi4KwBXOfcuIYTkO3ngZN8e7UZAi6gU+2y3qRpNVGrwOiU2A6c3/g7zowfV/c1LLsPhVVfjteY4fnr4Tpjce2EYJpxRfBmuWXzWpArW/nWmEpkXMe9xu5RT9GSn37tsFngc4iw/uvfnsjpRZHUrMc9I/NQK/GKbR93ui973CvyZiEw8lTrNKHHaENF0ROJJxBMsVRhvzfpYIvuZXkPE/GRMOua3UejUQkFPso/Mhoa6UsZ5UltvzZJbJSGEkCxnVvV2LckRWlJDe7QHvlgEvkj2UuzHGpXqv84sUwDvarwHZXoPEmYbDmz4FNrnnIl7tvfg2fAvYXG3AoYNH6+/GufUrsZUkK4zlTR7icyLmM9mm6eJCHmpg5doscfimtI+8CQz6RT9UhQjYSQQTcRV28dIIjrjovdy9KaN9LSkoTJ/InFpGzhz29+Np2Z9rJH9qaiLz1ej0FxBQU8mDy0K+I6kIvUSsSeEEJIf5In5XXukGz2RaFZT7McTlUqvY9/zDM7v+BPsRhwhexneXPdZdBQvwU9eaMRR169gcQZgM4px85LrsKi4YdK2eaj3ITXzkmY/WW2eUqn1Iwt5ib6LgJeosKrvJnmJxWSBx+pSIx29F2Ev3z25PpOQY9rW29s+piUQ1hKI5aB7Rj4w1pr18UT2J7MuPh+NQnMNBT2ZXGQWVFI5JVovtfVWB/c4IYTkujQq0JLqVJIjfFoQ7ZGeSUmxH1fEyDBwQvdzmNv+B3WzvXgRHi2/FLsOmvFI4B0YtffDbNZQapqFz879CGqs1TlJ95ysNk8OMbtzjNxDXvrEi4gvtrpVnTwpzOh9mczpzdDoval34kqGtL+LxCVqn5gx73+85MKNfjLM/aYrFPRk6tyTfUdT0XoZdLklhJCpJ+oDQp05Nb/rivvQHvZNWor9WCNG5kQci17/H1QdfVndPjLvAjyCDdjircHz2kHY6/4Mk8nAbPM8XJw8Ge37W9GcaFLrWi2WKU/3zOaJtd2SEvIjudZLq7kSm0eZ3JHpHb0P61HVKm+mtL+TiL2MqJ5QmUJRTYT9zE3JH458caMfr7nfdIaCnuQgWi9O+LMYrSeEkKn8/RUhL4I+R0hEUMzv2oLBSU2xHwu2SDeWv/JdFPXsR9JkwcH112NHycl44KUIDntehmNWSuQv1hfi7OQJcNjtsLisaGtrV8tnzapRvZWnOt1zoifWVrNZiRiJUo6UVl9iK1K90ckMid7bS6AnEwgrcR9BLBlXE3HTHafVokbSiV4jvQTb3+Upk5WpVMhQ0JOpR2o2JVrvLEvV1jNaTwghk4f0lQ+0plLtc0Q8oaEt0o3uUDRvTpI9PfuxfNN/wh7tgWYvwp5Tbsbb9pX4r+ei8JY+AHvJTrXeqcZ6rEouVsm6Eg2KxeN9f7aSyWRBpXtKT/gip0UZhQ2FpNKLU70IeZrczUzkcy8xe1RWhnShkJr7kB5Rrvlyezoj9hEeu1UNtr+bekZbypRPJQD5AAU9yQ0y2xvp6Y3W1wA2pvERQsikTKCK+Z2Y4OWQg4F2BOMajHGmsma7Xr3y6MtYvOUnMCc1hIvnYNfpX8YzHdX42XMhmOt+BZv7EMyGGeclTsEy60JU1lehq7NTpXZarNa+igWz2VwQ6Z4mmFDstKo+3UPZ3VlExNmKWB9PjpvgSafmS6Q+nZYvEfzpLu77t7+TnvaRGWykNxUM51yf6W9AvpQA5AMU9CS3JDTA1wQ4SwF3pZwd8RMhhJBsIO3opC1dDtNlezS/uvRFYzCPspf5pLYnMpKY887v0bArZX7XWb0Ou0/6Au7a7sJTB71wNdwJi7MNTrMTN865GvOss/tOIB0Op9qOaCQCj8etHi/XZZsqq6rUyaaQXyeYJnjsKef6oXa/tJ2TSKxE5dk7ngx7NJlMykfB3SfuY0rYR/TItDaVM/W2cpSRMNLt7xJTYug5UxjOuT4QCLJF3QhQ0JP8QOo6td6+9fbUiRIhhJBxIn4lMnJYL98S7kazLyXo86E9kVmPqqh8ZfNmdXtr0Yl40n4xHn3KiiPRNrjn/wJmmw+l1mJ8YfEnMcdVP2yKpyDX/YEAOjs60NrSklf9kEV8FDltyvgrE3azDaX24j5TNELGLu6dasBR1peWP93FvcVkQpHdqkY8kew10kvM6N72k+lcL6O5KWVCyhZ1Q0NBT/IHSQn1NwPOEsBdxWg9IYSMFYkYBVuBeDin9fKHgu2qXj4xwQhWttoT2cOdWLbpP1HkO4QEzHiu6hI87TgXfzg0C3F7E9zz74LJEsEsRzVuWnwjKu3lGZ8nU4qniPl8OtkU53pJrx+qBZ0I+TJ7MR3rSVZxWRxqzCRxL98xGZKSL73tIzpd8rPtXC/5EWxRNzIU9CT/iPqP9a23e3K9NYQQUjjtQaW/fA7r5QNaCAe8HQhret60Jyrq3qvEvD3mQ8xWjIdKL8Mj+ul4/mgFLEW74Jl9j4TvscA9F59ddD2KrZ6C7Icshnci5CUynwlJrS+nkCe5EPdaeFrX3PfvbZ92yZf2d/EE6+0n6lwvk6NsUTcyFPQkf12Z/S2AowjwVAPmoVvrEELIjEcmQkMdOe0v3xrpwVG/N6t1pRNtT1R15EUsev0OZX4XKpmLl1Z9Hv/zajEOhYphLX0NrroHAJOBlZ6l+PSia1TbrkLrhyyGd0XOlCt3puR6q9mKcnsJU+tJTsV92lBPIvci7qdrK7xjLvmAljRUOr4M1tuPzFDO9YP/BuSvZ0nuoKAn+W/qpIVTot5RnOutIYSQPOwv35HKbMoRWlLHoUA7OkPSFi/7J+njak9kGJiz6w9oeOd+dbO77kQ8vvCz+O4mO7rDBpxVT8NW/aS67wT3aty45OOwmiwF1g/ZBLfdguIhDO/Etb7MVkyzO5J3hnoSqRen/FBC0vKjmK7YzCbYHFYUO3rr7eMJRHXW2w9HprKm/n8D8tWzJNdQ0JP8R6I9gTYgFkiZ5ll42BJCiGpJJ/XycpkjgloY+1WKvTaprzNUe6JMrYxMCQ2Ltv0vqhtfULebllyOn9k+il//1aRq+isa/gStaJO674LKs/Ghhssm5O6ei37IDqvUyduUYMjUZkxc60ttxXStJ3mJHKNFNrcaYqAZlKi9HkEskbvfsimpt3eZUYLpW2+f7fai/Uk/X755luQLVEakcBCTJ+1wqr2dqyzXW0MIIblDJjiD7TlNsW+L9OBIllPsJ9rOrr7UgWWb/wslne/AMJmxe80NuK31XdjUaAAmDfVLfoeAdbtKU//InPfiXdVnZmVbpqofsvTFFiHvsGY2vCuyeVSdvGUc2QaE5AI5VkttRWpoSU2Je0nL15O58wKZynr7qK4jIvX2emGL+6y2Fy0Az5J8g4KeFGB6aScQD6ai9dapq1MkhJCckwcp9noygf2+dnRHwjk7Ac3Uzi506C2s6n4I7nAbdKsLTy/6O9z69oloCRqwWKKYu/xudCYPqNT66+ddhRPL16FQMJtMyvDObct82ua0OFBhL4XdIq7QRCFZFyYzIPvEbAVkkkP8eOS6XMp9skxlZ/TPdDB6J8rkMpny9JFLI5HKGFSXemp5UkstI1khZdwoowTRRKwvcj9dzfQkwUa+024bkDQKV9xns71ovnuW5CsU9KQw0aKA7wjgKk+NCaRLEkJIQZAHKfb+eCrFPqpPbor9WCM185JtOK/5XriSUYQdFfi+4xr88q0N0A0TStxeVC3+FTq0FjjNDvz9wmuxvHgxCgMTPI5Uz+uh6uRFyM/YXvLyt18Eu5gZyhCxrgS8LJuiU1wR/wkR9hogKeNyXTpOyPVpavw2FcgklQzDXqpM9IJ6eFrX22cS95KSHysAcT9VkfPcepbkNxT0pHCRP5Th7mPRehu/0ISQaUoeuNgfDXWjye+FkQcnl/0jNStju3Fm8x9hQQI9xfNxs3Yj/tq+QK03p+Qw9Pq70aGFUGItxhcW3YAG92wUAtJ+rshpgzXDhLXU/JfYipTp3UTq/wsKiapbnYDVkRpKxOdBRoLsf5UtKGNQy0OZfBMRKkOLpMQ+GePuNakJKxmSHSRGetIGLy4TKDNE3Mek3j6Pa+6nMnKeC8+SQoCCfpoR0qMoG0MP3WmB/MH0HQWcpan6enPm2kJCCCk4RMBLrbzUzOeIaELDfm87/DFxsc8PVKSmfjbqd/4fTvK+qJYdKjsBnwp/Brv9bnV74+wdaCy5H1HEUGWrwM1LPoUqRwXyHamTL3HZlIlWJiRqWekoVenJ0xqZpHcW9Qp4Z2Ea4orQV2K/JHU7oQN6pNcTKMR0/bHuTrMFpeZUvX08oSGgh1RKfgKJaS3uZXLP1VtzL+JeCXwtmReTq7mInE+VZ0khUYC/jmQ4dnY2o8zpQZ27HMVOhzoxmDFEfalofVENYJ9hkxqEkOk5WRloyWlUrysSwAFvJ3SpG84jxMn+9Mb7UN0r5rfMuhTXtVyFQNwMp1nHKXNfxluuJ6BDRw0q8YV5N+a9mB+pTt5iMqPCUTY90+tVlNsJ2OS9yUTFLqCkHrBNs0kLmZSwFB9rwyup+fFQ6twlh6U0hYj4RVRaylTJSSAmfh6+aZ+t0l/cG65eca8l86IVHiPnuYWCfhoiNY4yPBY3Kp0lKLI74LKbYbfMANdbManxtwCOIsBdVZgz+oQQIhOUYgCao5M0ae92wNeBzkjuMgOGwhoLYNkr30VJ1y7lZH9/1fX4p8PvUrGqhRXACQs34cnQYyp61YA6XFv3UVQXVyJ/McFjt6BoiH7yaff6CnuJavc1bZB0eZl8t7lTQj4txia5BWJekS4fcFekJu5E2MdE3MdyvWUFg4h4l0wGAah3VSMODUEtNK1T8vvc8q0WNUqlFZ6eEvYi8BM5MhHMl8h5ZBLb5+UrVDvTmFAijHAogqKYB8VWD+wWq2qT4bZbVA/baY38QZRZb09VKhWfEEIKAXHMDkmKfTBnmyCp9ft6OhBLxvPupMwZbMHyl/8drmALNKsLtzpuwj1H1qj7zl2go7r2GTzufUbd3li0Bh+b/QEUufM3Y8tutaBkiH7ygqTVS3q9pNlPmzR6EfH2ovyof88nZH+kjX5F3EuZDSP3Y9uFJgtKrHaU2DwqJV+M9EJ6OGcCdyqRVpaqnaUTiCdE3CdVv/tctRWdzu3z8hEK+mmORCgCehDhRBjF1iJ4Em4EYyaVutcn7m1m1ZN3etaedqT+KLLFHSEk35GoXKA1Zyn2krJ51O9Dc6gr57WZmU7KFpnbseyV/4ItHkTQUYVrY1/GluAcOCzAh5YFcdC4H497d6vHn1l0Mj6++AN5G9GWv8GSXi+ps0MhpnfSvqvg04glAi1Zc/ZiZs2NRdxL1F6G/C7IeYwMyUIko07Jr7CUqu9QRLXACyOSiCqDz+mO+G8oDw6HFVrSSNXcxxPQprG4j0Siqn6/sbERVotlUtvn5SMU9DMEmZ30an4E9RBKbMVwW1wIxZMIxTVVtyfiXtXl2C3TT9yzxR0hJN+JeIFwV85S7IOxOA76OtVJbz72NPbsfhwrOx+F2Uig0bEQH/R/Ce1GGepLgBtPjODhll9jHw6rx5yBDVgbXIJYNJVhkF+plyOn10tUvspRBoe4uBeyIJU6cYnEK1M4MuG0fMk4lMxD6XihhdkSb5TIhJjb6lQjYSSUebRE7WPSVnAGINk/Nnuq9aVuGCpqL4Z68cT0mRxq750ADofDCIXDqKiomNT2efkIBf0MQ4yNuuNeBM0hlFpL1AmDRGXCcV0NhExK1DttZrhsVlgKPTIwuMWditZXA/aUCzIhhOQUibiJi72cqOcAScdsD4bQFMof47sBPY1NwKmBTTih81l138vWE3G97zOIwoEVJV5cvT6KB71/VGLeDDMutp+D5eaF6iSutbUVPq83b1IvxcemxGUd1qy2WNXKlxZmVF7el0ThRcizjezkoMoVPKnfjZg/Je7ZCm9sKfk2z4xMyRekBabVboXHLoG+3sh9gfS6H9UEcEkJwpEoenq8sNvtSOj6pLXPyzco6GcoYhbSEe+Cy+JUvXlt5vShYCAS1xGJAz3QVDq+pOVPG3Evf/j8zakTDpntlr62hBCSC6R1VbAtJ2m0qhwrqqPJ3wOfHsh5in2mnsbxSBAXdP8Fi/xvqeW/wmW4NfhRlUN2yZx2LCo6hDs7/opO9MAGKy7G2VhiXqAi+iazGV1dXXmReilZb5Je77EPfcplMVtQ5SiHqxBr5WWC3FGSEprT4TyhEJBzl3S9vfS3F2Ev9fYzIJ18clLyowjqkRmTki/IOX3/Xvfx3l73Iu5z7Zg/7glgswnl5WXo7u5GwO+H2+2e1PZ5+QQF/QxHfrxkiCO+1OvJ7OUxUqk5MnoQV+Y9KXFvgbXQ2+FJpF56wErfeprmEUJykTEU6cnJfpeoTEcwgvZod86N7zIhJ1/za8qw/o0foS52FAmY8a/69bhXfxeKrXF8eGErPJ4O/CH2BPxGEEUWD/6m4oMwdeh9PZCrqqrQ0d4Op8eT09RLKWcT07vhJsSlDV2Fo3TQ3988RzrIiIiXwW4yuUU6BMhIVjFqPw5SKfkuNSQlX4R9SAtPe5f8/kj5j/xWyRDSpnpxLf/r7tMTwNFoVP3OW8xmlJeXY+7ceTOidj4NBT055oifiKDImnLEz2QkJLN3Mry9zrwi7t32Ao7cy48UTfMIIVOJ9JqWqHwO2lJJiqU3HEdXJAiv5svbNFNnoBnn7fgenLE2hExu/G3sC3gpuQarZyXxrpJ98Fna8Nvos4gihlIU4/PzPomG0npEKo+54gvenp6+kzy5nMrUS/GmESE/nOmd/J2V9PoiadtWCMjfeonCq2h8gWzzTI3aS/aPtL7MUSlPoSKTaqW2IjVmYkp+JlO9fE/NF8FeP3uOysBKT+iKmE+XV82UFnYU9GRoR3yLe8g6vj5xH47D0euWL6k7chJTsKZ5zrKUo2whvgdCSP6Tw97ygZgGbyiOHs2nJnDzleLOt7F803dh1UJoMVXjb6L/iP3GHHxojQlXrLbixcYQHu5+CjoSqEElrq+9Son5TD2QB5/kTVXqpUS5Sp32IU3vBPGvkRT7Y+VuBRCNl2w2lqkVBjLhIkPKDOV3R0YBpVHnAzPZJX+o1Hx553Fph9ebmp8vLfFqaqpUNH6wcJ9JLewK4C8JyQdH/OE4lpavKUM9dyG65csPtKS/xtOmefnbt5gQUmDk0PhOnIx7whpC8Si64z5oRv6mkVY1Po9Fr9+hnOzfNBbjhug/IOYoxS1nmLGm1oQXOjfjnu4H1OTzctdiXN/wUZR5Ssd8kjdZyIS21MrLye9wFEw7OknjFhEvLedI4XYbEL8gV0VvOr4XSOi53qqCYqa75PfH1L/fvTLa7i3NlfR8PZlTLxbXoAndTN1SpnMLOwp6MiZH/OFJG+rpMIVMKh1fIvfpmpyCQP7Q+VtSgl6EPWsDCSETQUS8Mr6b2kiGnFj5IjoCUUkbDcKn5Zfx3QAMA3PeuR8Nu/6gbv45cQr+Qfs0GiqsuOlsMypcwMMtT+DPrU+q+8+oOAkfm/sBWEdRcz74JG+ycFgtKHUNXysvvecrHeVKGOQtsv1iGisZa2w3N30Q3yNXWWqIh5AEMKT8h4zbJV9Lym9rREXuEzkwNs031/x8i95rg8zypnsLOwp6MiZH/FJrMayjSBGUE0fpcS9DTmIkYu9xWFTbnoI5CZc+r5KCL/VohBAyFuRkJtyZcp+eYqKSMRWOI5bQVa28pInmK6ZEHIu23oHqIy+p2z/R34v/1D+MDWUdOK+mHfFAPX7d+Rxe7HpV3X9p7QV4b+278ya6LZlo0opupKi80+JQKfbWfE1ZV/XXZYBD0uoL3PSWDI9M2MiQ8xwR9lJ2SMaMzWxDuV1GCcK9UfvwDEzJH030Phe197ZBZnlT7aMy1VDQk1EjJ4XRRAweiwvFtmIl1Eebwh+MydBgs5hV6x4R+HnvlC8/yqGu3t71NeyrSwgZHdJGSqLyU5zamja9C8d1lQ7arXlVimi+Yo35seyV76Kkazc0WPAv2vV4yDgb75t9BOtq4qqt3p3N9+IwmpRwvrrhSpxTdRryBXtvVF6iVEMhEw9l9hJlspWXSBReJq3tRfSPmak97eX3SrpuyCUZF+mU/KSRRKg3aj8TU/KHi96nI/fxKYreuzKY5U3nFnYU9GRMSOQ92OuIL8Z54oo/lkiJlkjCG4nDG0HhmOlJWprvKOAsSbW5y9cICyEkD9rRdQER6QUytQTjGnxhTfUP9msB+PUg8hlxsl/+8r/BFWqD33Dj77SbcNizEh8rfwdzK+0ImSJ42PQ02oxOWE1W/O38j2F92WrkB+JgP3xf+XQEr8pRNopytRzVxyshT7f6GY8cC6WzKeyzgHSuKLZ51JCU/IA2M13yByNn+E6rRQ1BSxq9fe9TAn+yovc1U+yjkkso6Mm4EOsLnx5Qbskl1iK4rWM/KUib6Xl7zfQ8dmt+19tL6mw8CLirUuKeEELSSBs61Y5uaqMy0iNYpddrCehJXbnY52Nv+f6UdLyNJa98F3YthCPJalyn/SPmLWrAv66M4+DeJJqiLXgUzyGAEJxw4O8aPoGVZUuRD0jZWInLBttwFvYAimweVNhLMraAzSlicCf18bbpe2JLxgmFfVaRCb0KR9olP6rq7WeiS34m5PfT1hu9Txqpzlnp1PxsT364pshHJddQ0JOJG+dpPhW1L7EWqzrB8UT9JUVUxrF6e2uqB2Ze9q5vT7nFimmedezvlxAyzZA6VElZncITNZUtFdXhjYhrvaGyprxxn5pszWeqDj+HhVv/FxYjga3Jxfhc8h/w/tPKcPp8+b13IlQZxwNdT0CDjjKU4LpZH8WKyiXIB4ocNhQ5rMP2bxEBX+kog8c6fHeYqe8fX5SKyNPojoxW2Esv+4ik4rPGfuIu+S419KS45IeVuJcIPpHfzFSrz3RATyap0+J+MqP3mOmC/pprrsENN9yAs88+e3K2iBSscV5nvBtOswOltpJx99bNVG/vdliHdQ7OXe96ScMvTbWDyXc/AEJI9pEezxKVn+ITXqlFlKi8lDAle9uMiqDPFdIeaMSURsNA/c77MW/3MSf7H3k+jS+d5URtcer3/bnOTfht10NIIolFznm4oeFqVBVVINeI34vUyo80yZx3veWVY31JSsizYwsZby97Mc+TUiK64k8YMcUstRerIZ5UIuzDekT9jpMUNrMZNrsZRYOi9/FE7p3z85kx/9Xx+Xy44IILMG/ePFx33XVK4M+ePXtyto6MGjF8EKKRGNye3KWWRJMxRGMd8FjcqteutPgYL8fq7fO0v73qXe/tNc2rSrnGEkJmBlKCE+qY0qi81Mf7Ipqa8BTEdKlH86pMqVzR3t6pTIekPVDadEjqFvtjTsZR/+LtmNe1Wd2+XX8vdiz4CP5lgwU2i0mdzN7X+DD+2p1yuj+tYiP+puGDo+qoMtm4bBaUOO0qijQccoJeZivOD/d92QaZbJbUegp5ki3zPDnXEWHPPvZZQTJaZSR7XfLFSE9EPhkuep+92vtIKNKnnyoqcj9xPFHGHFZ86KGH0NTUhE9/+tO47777MH/+fFxyySX4/e9/r/6gTza33367ek1pQXDKKafg1VdTrWyG4v7778fy5cvV+mvWrMGjjz6K6cb+/fvxwgsvqOt79+xRJ1i5Rmrr26Idypxp4jOPqf72XaEYmr0RdIfjiCfyyLlZ+o8G2gBfE2ewCZnuyPfd35IqvZlCMR/RdLT6okrMSw2mT/OrdqK5FPMSmRcxL0ivX0Fuy/I0/ubDWLvrP7CgazM0w4L/l/gkEqddjU+cZFViXiYlfrjr531i/mSsw3uc5+eBmDepqHyZa3gxL2ViNc5KVSebczEvry+t58rmpSaZKeZJNpGgRfrYYlZi1pAynSKbG7WuKsx2z1KTgxaaLw9Ze++xW1HptqO2xIkKt0Pdto3yeJS/TX6fH0ePNuGt7W+pZaKfREcVOuPKE66ursbNN9+MN998E5s3b8bixYvxN3/zN6ivr8cXv/hF7N27N/tbCqgJBHndr33ta9i6dSvWrVuHiy66CO3t7RnXf/nll3HVVVepEoFt27bhiiuuUGPHjh2YLvj9fuzcuXPAssEnVLlCajnFabkt1qlqhrLynIaBUExDmz+KVn8EgaimWjXlBdLyxXck1eouX7aJEJI9YkHAeziVgjpFSIphZyiGzmBMlSRJ3WV7rAsBfeq2YSgkzV4m8mXC3GQ2qUu5LcvVtrcdwvrX/hPzYnuUk/3Npi+gaF49VlelolBSKvAfe36Cd6J7YYEZ77GdixOxGi3NTTn9GyYnh1VFjhF7y0uKfZ2rRrWryikU8mTKj7X5gLuCrQ6zjJTryORgg7tWTRSKF0fOJwrzvO99idOmfq9nFbvUJKxkVWVqqy3Bzt27duHtd97Brl27EQof0yWio0RPFTITKvxtaWnBk08+qYbFYsF73vMebN++HStXrsT3v/99ZJvvfe97uPHGG1Wqv7zGHXfcAbfbjTvvvDPj+j/84Q9x8cUX4x//8R+xYsUKfOMb38CGDRvw4x//GNOFcDiMaDSKoqJUj1uH0zHghCofkD7I4rwsEftoInsnaemUfInadwRjylRPjKJyn4bfA/QcSp38E0IKH6nbkyycQGvq+hQRiGkqKi8ZShKVl4wnEfOakR9mSlIzL2n28jfISBrqUm7L8vjht7Hupa+jzuhUTvbfLL4Z65aXwo2w+vt0OHwU39n9IxyJNsFpOPBB+3uwwrb4uEmBqUZEfGWRY1Qu9rXOKlUTmzMo5EmukIioCHqJ2EvXH4rOrCMThdXOCsxxz0KFowx2sy37LzKNMJtSv9+SVVVT7EBVkVOJfYfVgli/bDKnwwHDSCIWTekR0U/yt0v0VCEz5pw2+UP78MMP45e//CWeeOIJrF27FjfddBOuvvpqlJSkWnk9+OCDuP7661W0PlvE43G8/vrruOWWW/qWmc1mVc+/adOmjI+R5RLR749E9KVsYChisZgaadIzNuoEYwpKCsaK3W6Hw+FAMJgSj/GoBrvNAavVjqS4SeQRMWj4/+39B3hc53Un/n/vzNzpDb2DYC+iKFKkSInq3V3uduTEZRMnm43zjzf5JXHyOMXZlM0mm3XiZBOn2XJiWc66KYltWb1TFEmJkljFDoAA0YHp/f6f814MCILoGGBmgO/Hz+sBIJTBcHDnnnvOe05vVhrn2VVHfBnpUSjRbBbRhPxBa+Z+e7tVjRcqniyQumg2lJGmeSXYWTj/fC7F5zWVphX5nEnFgWivWWq/VD8ym8VwPIN0xvyZkpUfzoRU89FSIq89jY3N6O7qQiQShW7T0dDYiNjR/bjvwldh17J4I7cWz63679jsHVInUPL69EbsBB7p+T7SRga1ejXuS9+CQMoHwwIkE6mivIZJbxY5+ZPsTi479c+VbJlk0LxWNzLZXBGb3fku75GXx6nEnhsLsSKPM+XMIU0XPWYyYwmrl8YbO1aO3i43Ls0Jl92JVDatpkrFM4kVP9t+JhbVp8CqVjZmwIkMHB4/kukMnHYnMumM+jyJn+S1TOKpUjzmzPY+zTmgb2hoQC6XU6Xssn99+/btV33OnXfeiWAwiELq7+9HNptFXV3dFR+X90+cODHp11y6dGnSz5ePT+VP/uRP8KUvfemqj8vFC6kGKHX1QXO8j2zvjKB0svRXkvvF7HWpkAobIj5naH58aAhuVG8lMwbSB36AB1LfV/WQz1n2oHPzZ7HKKRc0/cg5cng88ThevPSi+vwNtg34iOsjcHnGjXgbrV4vxmtYH2bbkGp4ke8JCb420Vw9cWhxtvxSubOgMnitesujA5Wta6/6jHwvslIz28qBOQf0Ukr/kY98RJXFTUWC+XPnzqEcSQXA+Ky+ZOhbWlpw3333jVUglKKhoSFVkeCpNuDyzG42en/fgMqspDPpscxKdU0VlpJkRSTT4bV5VGOQxfopara93apKb4pGSjM9VeY84BK56icnTPfee68qkyXicyb/x5EEoj1L2s1Zmt6NxDJjWZdSzcpPpX0ghcqXvor7cy+r958Kvg/2Wz+GVs2CwY40Mr5hPDLwKE4kzRPud9TeiffV3z923JcJLel0Crpuh9M1u9ewQvDYZ54tL+wWG6odlcUrsS/haq9C42vTMpCKALHBJTuGSmZegvl7d66HXszzvCJta41mE4ilY0jllu41q9xc6rmE9vZ2VfEt2fimxo0YGgJuuukmVFRUoFTNdm//nAN6aX5XDNXV1Wqffk9PzxUfl/fr6+sn/Rr5+Fw+X0jZhayJ1L7AEg568k9GCeYtM83XyXcn7jL3k3i9HrV/RN73+b1TzxFeJFEjhkQmAa/Nq4L7xWgAIvMrU/EcrFpWzbX3OKyz7opZUHGZ5RoFPDWAbelOWqdT6s9tKj3L9jkjPTDkJFRKR+UwtAQnhulcDsOxNBJS/mcBLIaGcCaimt5JT5DZHM+LSfb2P3d0BPec+AvcYDmJNKzYt/Zn4b7ubvXfpWy+N9uLb/V8U3Xl1zUdn1r1UeyuuLK6zxy3unSvPbI9SxooOWfxbyyNqaocwUW86DwNeZ2QruL6uCqGFWLZHmdWAr0CcAfNY6msJWoULMH8SgvodchYNzuqnH5Vki+vHTLbPn9xmExNjQ2oqAggkUjC6XSgMtiC/a+eUfFTKR9nZnvfivDqND9yNWXnzp146qmnxj4mpf/yvlxdmYx8fPznC8lITvX5K8lM3YmXmhx4ZAxTT7IP8QI2zpvs54QTKVwaiaM3kkAklV76RnrpBDDcYdaULuG+XCKaRiZpTqmQk88lIMed4bjZ9E4F83LhMZdSTe9kOkjRG3zO4qJwZ28IDz3RgY+f+F0VzEc1Nw7v/gL00WBevDFyFF8Nf1UF85V6EL+54ZeuCuaXmt1mVV2RZxPMB+0+1ZhqyYN52RvvqwOCLSsymKdlQJIz0jivos1snEeLzm7V1cXHZtUlvxKuYk/gKDFulxuVFRXqdrkp9qDXOZFS+E996lPYtWsXdu/ejS9/+cuIRqOq67345Cc/iaamJrUPXvzKr/wKbr/9dvzv//2/8e53vxuPPPIIDh48iL//+7/HSje+O7EE8+O7ExeTzFQeSA3BYbEjoPtgtyze/Umms2oNR9Nw282s/ZKW5CdCQDJsvuBJcyN2iSUq3mSKJcwiyUSOkXhajaQTOSOnOthLs6NiB+lyUVdeB6ar1JLxPy+eHMal7gj+yvoVVFgiGNJrcP6230TYXoP0SAiZbBbPhl7GY0PPqq9Z71mN/7r6k/Dpxd1y5HPq8NpnPvWRAL7aEYTb5ipOEMTXBFouZJuKtxZwBoBovznilxaVVLrKsUtWJpdVo6MjmbjaykXLU1kF9B/72MfQ19eH3/3d31WN7aQh32OPPTbW+E72Rkjn+7y9e/fi4Ycfxhe/+EX89m//NtavX6863G/duhUrnZysNTY1qzEO4XBYBfPy/lKX208lOZqpcludCOh+WLXFC7QlExZNpdWyWSxqP6WU5VuXIsCWAELm1ktwL2X4sk+SiJYuKx/pATJLU5kkW38kkM9n5IWM8hxKh9Q+yGKSIF1eD6RSK/96UFtbfdXnhSIJ/OtrGTQPd+Kf9L9Xnew79Sacu/U3MZi0ouvsCQxGhvCC/RAu2s0tb3vse/DJte+HLlnnIpG5xEG3Drt15ky71WJFnaNKZbuWtnO93wzmizkKj2gxt48EmsyRvrH+Je1RspJJ34+A3adWMptCOBNTJflyIZmWj7IK6MXnPvc5tSbz7LNmJmA8aeAni64mJ2s+n3dWGZliiWUTiGeTqmmeb1Eb55kkYyaz7aUUNt9Iz6UvwZ9JNg2EusyA3l29IhofEa2UrHxOZsgnMggnJDtijNtmNKKOccUWHzej1+fzmT1VLnaq14fxrwtdIQN/+ZyGD8afw+ft31MfO+u9Bj8O3IPmlEV9TU+mDz9xvYiINQaLYcEtxi7c534v0okMdE9xTjmk8kpmE8+mHYHT6kCNs2JRLyJfhcd9WkkcXsDuWfLKKAIcVrtahj2AaCaOSCaGRHa20z2olJVdQE+FJSdrpRjIT8ygS5OoWDam5td7bEuRxTYQT2XUsmppeFTWfgka6aViQLrDLE2TjsbFaNxHtOyz8r3m7RKQPh2hcd3rhZQ/Ss+QXInsk8/3VJFgPt9TRSq35OPy+iCN7549a+Dhgyn8D8vf4wO2l9TXvVl1C17y3aIazEkXwSOZt/GS7TVkkYUn58Le8A5sDK4zf0ZaqiCW+rVGZsvb4JlFib3w2txq/+liNGadlFy4lQu4rMyilSa/tUSqUmID5vZDWsKHX4NXd6uVzmXUa5Jk7rPs61S2GNBT2ZAT4qH0iLqiKPvrJZOyVD83lEghlAAcumTtbXDbrWrk3uJlD4eBZAhwV5nBPREV4O9q6TJCyUxWVfqkMpdL6eXESbLyiVxxmo9OlZ1PJJPQLJZJe6pEUwb+8VUDb7eP4J/t/we7LSeRgwXPV9+PN53XQNc01DTW4T8jT+IV2yH1PRvTNbghfK2aWpIeLauVcXRLSbZPSRf72ZTYiwpHAIGl2t8vF2p5bCe63PxR7a/vW7ILrXSZbrEhaPerJRWxkXRUVY7JhVwqHwzoqeykjTT6U4NwWhwqsNctS7fPcayRXkxm29vgdVhhty5SaaY0zIr0AYkRc389Ox0Tlfxeedm2I/vkpfFdnpwYjR9FVyrG75uXJnZq0sm4PfTtEQf++uUcKmKd+IHjz9Cq9SFjc+HtPb+KnH8DNqZSGEEE/9z9bXTEL6pLnDdgGzYmVyNppGCz2cbmti/lbHmXboXfObsSe7P5XQXcS9UNWgIXCeZZfUV0me40JzpIPyHZXz/aMJSWlsvqUEv21+dL8mXfPZU+BvRUthK5pMoseaxu+HWfanq0VGRPbDSZVktGIEmHfLduGy09LTAJQkYumnvOZB7xUjZqIipnS5iVn2yfvJCToeH0CNJGaTWAmmzfvAT1ra2r4PF68dgZO757JIfbtcP4a8dX4EUcCU8dTtz0G4j7myG930+mzuBrFx5Ro0alz8nPrXoQq/VWVaqfzeVgtVhgs9nVDoelIbPlbepYPBtL2vxOGoJJp2+5JaLJyXg7uxeID5rJDGaJi0IudPp0j1rSGT8yGtyzJL90MaCnshfNxhDPxuGzedVJ5ZLtfxwlJbWyhrHI4+9SUSAd4/56otlIJ4Co7JVf3OyCZNwjyQxC8bQK6q/YqpMOq+NTKZpq33wo48Bfv6jjVH8On7E+ht/R/xUWGAhVb8bJPb+KjMOvxov+e/dP8FjPM+p7rfGswi+0/TQq7EH1/vi+LLmcgQhSS1JiL13sZ9vnRBpD1TgqxyoIFo28HsmFWG6dIpod+RuWvxnZXy9l+BxzV1RSBVthl+VHLJNQ++1Zkl96GNDTsiDNpUYy5hzngM0L95I0zpt6/J1utcDrtBU+az9+f700zXOZJ9BENO5vJDZoZuWXeJ782Mel6V0mfEUjvFIj++OltD6/b14y9kcjdXj2BRey2Qz+p/0hfNzylPrc3lV34uyOn4NhsWEgNYR/PP9NnIleUP/t7ppb8KHGd8NmsRV01v1ildirz7c5UeOoWPSpKaqbt2yX4hg6ovk1jcyPuZPAng3bik62JsnKl+TLYpf80sCAnpYVmeU8mB5R3TqXsnHeROlsDkPR1OJl7SWAiPaP7q+XLsmewn1vonIlmRyp75YxkEvc8K5Um95NRYJp2ScvZffdQ3E82deGs1E/AojgIc9fYnv2KAxouLD1E+he/x6VaX5t+C18o/3/IZaNw2lx4pOtH8auiusKPut+sbrYCykhlU72i97oy1PL7vVEhRxzJxdqE8Mswy8BLMkvPQzoaQU0zvOrLp7FMD5rvyh77dX8+m6zYZ40WpLGMkQrjVzgktFHcoFrEaVzOVVaP77hXSk3vZspSy5z5sO+zfjmaSuiaQ3rLd34lvfPUJ26hKzNiVM3/P/QFbwGseEh/HD4Kbw4/Kr6+jZ3C36+7adR7aic9c9MxJOzmnW/WCX2S9bJXqqm5Fi8xFu/iJY1tXWlCnD4WIZfwiX50iU/mo4hmo2zS/4SY0BPi1oKWQqN85LJfritriVvnLeke+0lMznSaV7JlpNJNs6jlUJ6S0hWfhHLMadqeCek3FCa3sm+8nKQz5KHEzk8N9iKoyMV6uPv9x/Fn+a+DEcqiqSrGif2/gbOJz04emI/fmK8gEHNvFhyf+0deKDxHbBpczt2yRz66Wbdz4VTtyIwhxJ76asiJfZum7TyW8TyYG8dm94RLUkZftisUmQZfkl2ya80AizJX2IM6Je52QbphS+FLB0qSz7aOE+a5sla9L2Txcray14zCXCkAZOrgns3afmSEznZVynP+SVueJff3jOSDqnmQOUi39n+QtSDH3W3IJTWocHAHzU+iY8PfQMWI4tw5XqcvPH/w0jOgafP/gjP4wAyWhYuOHA39uLeyrvmHMzn59CP37Mvt5rFgkQyBT2emGVQP/cSe7mIW+usUk3wFoUct+VYK4tZeaKlIZl63bMklVm00JL8jOqQzy75i4sB/TI22yB9svFFCymFLOXGeaFMRJUC+aVxntW15B3xp83aO2SuvQ12q6UwjfPkRY4nmrQcyXNbTuQWcVbxVA3vhJTWh9NhdUwpJ9F4Ck901eK1kTr1frU9ji+7/x63DO5X7/e13IIz1/8C4sjhG2f/Da/hLfXxVksj3qHfDiOSnVdGPT+HPr9nXzLzMiJPXDh/blYXkSUwlxL7uRwfpRS01lm5eFuu1Cg6ycov0sUCIpqabLfx1pij7oa7+UiVKDn+Sjk+S/IXFwP6ZWouQfpU44vme+JW6iSzNpQeQSQThU83A/tiU1n70bn2Dt2qMlBuuxUatIV3+5bgR8rw5UWPqJzJCLpFHmM0VcM7kcqlMJQKqR4d5ebcoIGvvORGd9hsoHl7ZRf+R+5v0Jo4p95v3/IxXNz4AVyIX8Q/nP8mepP96vhzA7Zhr349UsmUnJmpaq/5koBd7dsPh9He3g6b1TqWrZ/uIrJsTQq6Zl9iL6Qhao2zAtZ5VBPMSC4Eu2XKiLldgYiKSC6sSRk+3jCDfCqLknwZgSdZe3bJLwwG9MvUXIL0ieOL5FbeX8iJWzlIGxkMpoYRsUThtxWvI/5EyXRWrZGYBR6HuddeGkAtqDRZ9hhLd1gZdSf77InKiao6GTLXhNL3QgbyI4m0+tubSEb0jJTwTPnpZHMGHj1m4HtvGcgaGvz2HH6m6gA+G3oIwewwMhY7ztzwOQw07sbTfS/iO10/VBc9K/QgPhR4N+z9QDQSHcuiL/Qir3y9vA4ZuRycHs8Mr09zL7EXHpsL1Y6KxanAksaj0sGeWXmi0hNoAVIj5h57KumSfK/uVktK8mW2fSQTRyZ3ZcNZmj0G9MvUXIL08eOL5KSqUCdu5SKVG98R36fKNEuBzLAOJVIIJTSVrZdy/AU10ZPsZvgSkHCaGXv++VM5SMXMrPwijaKTQF4a3iXSk59IyIg22StfzJny821Y2h0y8H/35XB6wHx/Twvwm62Hse3wV2HLJhB3VePtvb+BS+4qfP3sP+NI6IT6vOsC1+DTrR+Fx+ZGvLrwzVJn8/o0nxJ7EbD7VGlnwTErT1T6LFbAV2dWJC7BCFMqTEl+0O5XK98lX3rTyIV0mj0G9MvUXIP0fCnkcutyP9eO+Ilk0uyIb/PCVqRRd1cz1H5eWbrVAu9oxmre5fjpBDByEbCURkUC0aSyGSDWv2hN72YK5EtlpvxceqHkj99OpwNPnjbwzdcMJLOAWwc+vdPAx5M/QOuh/6c+f6TmGry9+/M4nOzC10/8b9VfxKbZ8OGmd+PO6pvHstvyWlDo14OZXp/mU2IvZL68NGEqOO6VJyovMso32LrolV20OCX5EsyzJH9uSiVioUUw1yB9MU7cypFk5OLZBDxWF3xFHnU3UTqbw1A0hZFYGh6HDu9CyvEl8ykiPYCPJaRUIuTES7aHSP+HRTgJmymQL6WZ8rPthTI+6E/AhWeG1uH4gFlpdE0d8LldKew+/reo6jKb33WvuR+ntz6I7156HE/1vaA+1uCsw2fbHkSzq7Gor09ehw6fY26nJuZYukq4bQV+/WIHe6Lyla+qkY74kq1fxN4rtLgl+bFMHOFMjCX502BAv8wtVpC+HGfWXzWuKitlP6Ux6m4iGaEVTqQQLkQ5fjIKZNvNFz158eMMe1qG5fUzBfJCmvNIeb301yiXXij5oF+ufZxPN+JHHdVI5GzQLQZ+arsF72vuw+ZX/hyeUDtymhXntv8sDtdvxT+e/r/ojJudoe+o3osPN70H9iXebjT+9UnGdkpW3mGb23F20cbSyXFQOtjLnnkiKl/ytzw2u75vUaej0OKU5MtWKlnyGi177SXAZ0n+lRjQryCFCsKX88z6qUfdxeC1eeG1uos+6m6qcnyZaS+BvWeODaTGyItdKgI4/GZgL3vRiMq8vH42gbzsjzdnysdL6ng8m73m8j1GEgaeG1qN48M+9bE6RxT/dY+G3fYL2PDsl6Gnwkg5Ajix51fxIwzh305+WV20kAuVsld+W2DLvO5focixK+jSYZ3jsVW2RdU5qwo/ls4VNPuMlNSxnogWPrvePTq7PsQHswxJ82pZhj2g9tlLl/x4JlHsu1USGNCvEIUKwlfKzPqpTvhl1F1AZtjb3Cg1MmZrUDp1x9LmPnuHbc4nyGa5s3SIDQHOoHliy8CeyrB7fSKdRSg5edf68aS7bigTXtKmd7M9Hs+mF8pb/Q58o30LYlkbLDCwt7oXN1b14OZwJ9afeBiakUMkuAYHd/03/GP/U3hj5Kj6ui2+Dfj0qo8hqPuLetF2PiX2QqoJ6lxVhR1LJ8c6ycrbS+/4TkSF+huvvVyGz6Z5ZUkSazLNRFYml0U0G1fN9KTJ9UrFgH4FKGQQvtJm1k8k45wG0yNqf22pzLCf9OJDPIWRuOyzt6ms/Vw7RY8FWmrUXYUZ3HO+KxWSVIRIpkSy8wUk1SrhZGbSOfLjyb684fQIkkvc9G6ux+Op9ppHUwYeOmjghfPmy3i1I4H7a86h1ZvAO+IvYdWFl9XH+1puxQ/X341/vPB1jGRCKgD+YOM7cXfNrZNuI1qqi7ZSKh9w6XMusReSoal1VhZ2G5SM8/TU8AIm0UrApnnLhs1iRcDiRUD3IpVNq6y9XKgv5mSaYmBAvwIUMghfqTPrp59h74XTWooXMwxEk2m1nLpNZcGcunXugb00J5PAXoJ6Bva0UDJlQcrr5baAPS+iEsjHM8jMsD9Smt7JNppIkZrezXQ8nqzUfWIvlDe7DXz1lRwG42ZV+Hs3a3j3OiucUS+2H/kmAiNnYUDD8Y0fwT8HnXj83NfU71rvqMXPtT2IVnfTvO9fIcy3i73w2tyqm33Btj7J95FAXsZcEdHKa5pn9wJRaZrH0u1yZ7fqqLQGUOkIqC75EthLab687i93DOhXgEIG4TOVgC73ZnmTz7AfgsNih9/mK3xjpgKR/cOyxo+9mxMJkvKBfT5jz/2lNBdS2igZ+QLuk5fmkNFkBuFEZlZX42V6hWydyRjTZ++LdTyeqdQ9kTbwzdcNNZJO1HuBX7zJgg01Gvy9p7HhgLlfPmFx4qHqu/BI6iT6e4fU595WdSM+0vxedaya7/1bOA3++Rx/Rvl1rzpRK+g4Ol89G4ESrWQ2OxBoNrcbRvs54m6ZcNucaknzvGgmrpY01VuuGNCvAHOdST+TqUpAV1KzvImkbLcvNQCnBPa6D/YZTppLYezdfEpdVWAfHQDi+cA+wMCeZnjOZEe3b4wU7EQpncshksioYH42WfaMKq8PIZFLluTxuKq6Wr3d3t4Om9U6aan78V4Df/dKDr2j10Pu36Dh49s1OK1A49uPovXIt6DBQI+9Dn9cvx3PWY8jiywcsOMTTR/CjbXXF+X1Ik/Ga1Z67dDnuXWn0hGEv5Az5iUzJ8cwXpgkIiHnM3KMkU74qSgfk2XColng0z1qyVY7ydpLp/zlhgH9CjE+CM/mcrBaLCqbPt+TtIkloCu1Wd5EiVwKieQAXFanKsXXl3gM1Fwym5GE2TxkMJZC0C3joqxzC9LkSrYEamrOq58nxjThOZIzKzoK2PBOOtZHkuZUh9kopZnyUx2PQ+Ew+vv6EIvFEI3FUFlZeUWpezSewneO2/HjE+ZvUO0GfuFGC7bWa7CmY1i7//+iquuA+r6vN+zGF+wZdFmOq/fbLM24ObkDWxzr5lQ9NdVF24VUYFV5HLDNo8benDFfAbetQP1KrLbRcXSl1/+EiIpMjg/+BrOSTI24K141FxWebrEhaPerFdccy+ohZkC/DE110iVvh8ORBWXRp/reK71Z3mSlvbLcVid8Nl/hxyoVUDyVQSqbGxt7J3PtNczyxFte7CJ9Zjk+A3saPylBAvkCnQzNttHdeIlsQmXli1leP538cVGCeeHz+xGLJzA0NAy73Y5sJoP+jB/fesmN7rB5MeKONRp+5noNbrsGV6gT6/f9GTzRS8hqVnxt8/34avKUqkKwwYo7bDdifWYVNF0bu2gwl+P+xIu286nAkuNIwKmjH6nZHlGuapxX46xUTfAK1/iulg0+iWjmY4UacdfPEXfLlG2ZNXou3SiD5qW/bwBdXZOfdC00iz7dCR2b5U1OmnHEyiSwvzz2zmJ2x3fOYexdPrCXIE7KWJmxX5mBvIw7lIs7BQjk1f74VEaV1s/U6G7iJAoJ5OWCWqmbeCG0oiKIwcFBDI+EcTi2Cq8M1CJnaAg6gc/useD6JvPvsapzH9Yc/L+w5VLo0P34tYZ1OB4/ov5bi96I29K74I47VTAv5fxjFw3mWT01n9cOu9WKgFuHNs9Gw+aM+crCVDmpxnfVZkktEdFsSMDHEXdUJko3uqB56e7qmvKkayFZ9JlO6BZr3+VyUU6BvTQXCyVSCCXSKlsvWftZl+PLCDIG9itLPpCXizkFGEEnwXskmVXTGSSon/3dMFTneimxz5VQef10Jl4Ila1QGXcDHh1Yh4sR8xhx0yoNn9mlwefQ1IWSVUe+icbTP1T/7QeBVvzPSiei6IcFGt5ZfRfe03wvUon0WCWV3F7q7l5Q9dRcXzs8o7Pl5fJDdh7/FjJjvtZZpcYRLZhVB3wNZuMrIqL5jrjLNwZeAR3TqfyUblRB85LOpOH1eiY96VpIFn02J3RT7bukyQJ7F3xqj30p/wkaqtRZlpTjexxW1Z16VuX4+cBeXgBdQUA6Uy+z8qYVr8Cl9Zf3x8v3mtsJk5TXj6TDapxkORl/IXQkFMZroUa81F+HrKHB6wD+yy4NN60y/270xDDWv/qXCPQfQ0zT8Jt1G/CsSxr7JFCpBXF76gbc7L9RzZl3uaxjI/ASySQ0i2VBXetn+9qxkNnyY4+Jzan2zBdkxryMopORdGx8R0QLrvKpMkvxI71ApvgNVonGK+VoguZBt0190rWQLPpsT+gm7rukycWycbXKI7A3y/FlSXd8yb5JcD+rbtWqeZ50xR8anWMvgX0Bsm5UXPLvmYmYje8WQNq8SQAfmeP++FLsXj9fciE0ZHjxyEELLoyYfxvXN5ol9kGXefHMO3ASG/f/H9gTQ3jN7cVvNLSgJ2d2Yb7eeg12ZbfCptuuOB6P3yKVyWbV7fjtUnM5Ts/mtcOlW+F3zm+2fJ5X96DKHlj4jHn5+nypLBFRIUddBlvM10BJWDBbTyWitKMImrOGxka1h36qk675ZtGnO6FbabPnFyewL/1SfCEl0OFECuEE4NRt8DqscOm22c+xlxdBOcmW4J4lsOVFLs7Iv6GIDQFzmYowQXZ0fnxklvPjr7orRk51ro+UWPf6ucrmDPzHcQPffUtHJgd4dOCTOzXculozg1rDQN3Zx9H25kNII4v/VdeMf3VbYeSiCFh9uD27G3WJKhXMjz/WT7ZFSoL61tZV8548MvVrh4aAywb3bI4D06iw+xGwFyAAZ4k9ES026RVkl2x9D5Au/X4ttPyVdvRAc1ZdUwWff/qAfb5Z9MlO6Fby7PnF22NfuuPuxkukM2rZLGm1z14a6VlmyqypMu2Quewesxyf46NKWzZtXohJhmVPT9HK6vNkhmwoE57XhYBS0jFszpU/O3qNZEcj8HO7Lah0m39DlkwSa17/B9R0vIAjdju+0LAKFyzy+BvY6b0WH254r6rwmcvUEadjYRddJ752SJVOwC2z5eefUZcLF9WOCngKMZZOLhZKZp4l9kS02OTiYaDZ3HomY3yZraciYkC/DC1m2fv4783Z84sX2Jf6HPuJTcyG4ymMxKWJnnTHt6oO1zNKRc0lmXrJ2MvJOE/ES4dkHaQBkMzjLUC3esnIp7PzD8IT2eToPvk0StVsqpUuZ+WNybPyEpdGLmHj/v8NfaQdf1URxD8F/cghA6/Fg1tzO9E8VI+OyIUpL6AuxdQR+Vv3O/V5jaMbv+demt85rAu8X/K4uavMC4REREtJthLqHiDaC6RifOypKBjQLxOD0RRyS1x5ytnziz/H3mlxwK97YbeUfodmKX2OptJqzWmmfSZlNpmRea8qsPcDVh6aikYCeAnkF1hGmM/Gx1PS53z+B6d0Lq0C+VLfJz+baqWZsvIi2H0I6w/+NU5pafx2cxNO66P76v3XYntoI5xwwOlzTjs6bjGnjkgVjsyWd47er/kqWCd7+XrpYq9zuxcRFYmcs/gbzepDOZdZYH8ZorniWfMy8SvffgNHO63Y0ZPD9kYN1zZo8NoX2FhoBgvNAnHv/cwkiJEu1U6LHV6bF06rA+Vg4kx7aaJnm6mJ3vh99rrbvOptdy/VXV7ZZH+8lA3K+LkFjJ7L742XNZfZ8VM1vAtlIqrHRKmbqVppNll5GDk0H/8O6k98F/8Q9OOrwWpkNcBn8+DBlg9ivdaGkwMnVTA/m9FxizF1JD9b3rbAShq3zaU62S+4+Z1s1/HVs9EmEZUGmawh2wklSSEViERLhAH9MiCZsGORx5HwZvD8hR14/pwTFs3A+mqo4P66Bg1tFeZexUJaSBaIe+/nJpFLIZEaVFkt2WMvJfnl4PJM+zk00ZN9aPlyfLnqLRl7Zu0Xsax+BEhFFrT/L57OIJrKqmz8fPfG52WNLMLpCKLZeNk0vJuuWqk/6ZgxK29LRbDuwFfQO3gUDzbW44TDvCh6fXAbPtH8Afh0r7poMNcLqIXcfuWx2+BbYIl9QZvfSVMqGSNFRFRKpGrI32D2nYn2MVtPS4IB/TJgseRQ2fwsBhIDcNf9CNbYdRju3YOTfc042Qd8+w0DQRdUYK+y9/VyclaY4H4+WSDuvZ+/VC6NgdQQdM2mMncuq6vgF2oWu4meVUvDPVqOb7fOkLWXbLFk7WVJtl66ysriTPv5k8x5KmyWBi5glm46l0MsmVXZ+EI0qJPvESlA5/piVP5MVq1ktel4/JwTj57ITZ2Vl0B56CzW7P8LPKwn8bdN9choGjxWNx5s+QBuqNi+JGX0M5bYu3Q4FzDVwPw+sl++Em6bswAj6erMedBERKVK+gJJtaEE9QvsRUM0Ewb0y4CMcPrMls/gocMPoS/Xh5znIDyrDyJoaYQe3Y2LF7djOO7Ec2cNtaQh8YZq4LpGM8BfFVxY9n6uWSDuvV+4tJHBYHoE1kwEXpsHHqtLnTCXAwnc8qPvZK+9BPbSYMs603NQms3I0vrMkjYV3HvYSG+20nEziF9ANl4a3IneSHLs7UIcv/KBfG6BGfliVf5MDLaHs148MbAGHSHrlFl5NZLu3BNIH/8mfq4qgKMOs6HbdYFr8NMtH0RA9y9JGf1MJfZBtz7z3+Ys1Dmr4JYZzgvBkXREVE5Uj496wB4ZzdZLFRtR4TGgXwYcVgce3PQgAmcCGKnuwguD+3Fo+E0M57oA1w/g3fAjbHdshz26B2e6m9AVAk70yTJU9r7CJSecGq5v0rC1HnDYSnvvPV1ZnjySDiGSicBtdavgXjpHlwvZay9rOJZWTbYkuHfp1unH30kgKVe7Zcnn5QN7BveTNxyUAH4Be+MlWy6l9PF0FuG42WE+ncnCOlN1xSwCeRlBF8lGC5LhL3bljwTbTrcXjx4z8JPzOrKGNmVW3pJJoPn1r+J74aP454YalZWXkZU/1fwB7K7YMe0F1sWcYjKex6HD57AtuMTezMiPQLcs8HRDKnS8sl++fI5vRESKVBRJzw8Zbyel+EQFxoB+GZGTwHXe1djgX4OPZx7AvsFDeL7/FVxK9uJY/FXA8ipa1zXhTt8eWKLbcbTLjqM9wFAcePqMoZY0Lr62Dri+WVNB/hUZpQIKBIMYGBhY0tLR5UxlvTMRleWU2dQS2C/4BHpJGWMl+dIV36Wy9lYV5E/bJV8F92FzSRAk5W354H6h3bPLeW68PB7Sg2CeJfUSxCfSWTUv/sou9QvPyhc6kC+Vyp/jvQb+8VVdXTAVu5qBz+yakJWXgDzUicShv8B/c+dwtiKgPrYjsBU/1fJ+BHXz/WIqVIm9vB4F7X64NZkv37OwO8X98kS0LLL1o9uFpGkes/VUQOV0xk9z4LG5cU/trbi75hacip7DC/2v4NDwW2iPX0R7/HtwWH6I3Wu24wM79yAabsZrFw21+mPAa12y5MTdwKpgDrtarNjZVJjGeuNLYjWLBTW1tairq2MwX8jRcdmYWjLyzmtzw1kmDfTG/w6xVEYtCS6kiV4+uJ91Mz0h5b0S2EuQL2+XSa+BeTe3k987LUF8akFBfDyVU03uClVSP7G0Xp6bhQzki135E0sZePiwgadOm49X0Ak8uC2DbdVJ2DX52Zf//jwXnsF/XvgOHgm4YGhWBCwufHzVh7EzuA2lQLbABF0LL7G3Wqyqi71M5ZBqjoXtl68196ISES0Hcl4SbGW2ngqKAf0yJwH4Bu8atT6WiWLf4EE8378fPck+vDCwX61VrmbctvpGfHzHdegNO/DC21EV3HcnXLgwbMGFYXPcUqWU5jeNlubXycmftuCS2OGhIRXQ0yKNvEslVQM9ucDjLqN99nkSVOZn288puBeSnVYZ6sHR7L1rdI0G+OVMruynR3sKyO08r/TL4yul9GYgv7B58dNtC1GBfCa24D3y01mMpnEzNdg70GHgnw/mMDw6We+utRrubR7CcG8H3h68vI+/rsqPvjf+Br+XbUe3zxzFeEvgOnyo9YPqb7MUSIm937HwUwIJ4qsdFQufLy8TLmS+fLn/rRIRTZWtl+Cee+upABjQryBShn1v7e24p+Y2vB05ixcGXsFrw2/hQrwT/9LxHfzbxf/ATv82NNmr8cnVlchYPTg2YMfpsA8X4n4MxjWVhZLlsELtt7+hRVPZe69DK/mS2JXcQG84HUIoHVZBvQQQukVHuZksuHfZLTOX5Y9l70cDYAyYAb7s7VXLYS5puFXSAXwcyCTMAH6eWXiRykoAn0Mik0UyLZnyxQmy07mMCuRjSzh+rpBN46ZrsDcYM/D1gzkcMK9Pot4HfHa3Bav9SZw80XHFRcu+84fw4tkn8ZjEpTYbqrNW7LXcit3ePSURzMvfUtBlh8O28It9ft2rxtJxvjwR0Sxwbz0VCAP6FUhOtjb61qoVlqz9wEGVqZes/cvDB9Tn1GnV2GbdhO11a7DZ04s16zaiI+HDodHS/MEYcOiiLOmab2BLHbC7RcMNzXJyOHlwxWZ4xSXZ0UhW9i7H4LDY4UT5Zr4uB/cY23Mvgb2sWZULS4AvAbKsPBXkS2Bvv7ykD4EE+ktZri/N67Kj1QXZ1Oit2YxuPjK5y8G7ZOILXUo/USKbVIG8VIgUQyGaxk3VYM/j9WLfRbsqsZf+gFYNeO8WDR/YqsFu1RAauXzRUq4xRTIH8B+WExjSLbAYBm7KNOJ6773IJrNL2rBvsbvYS+VPlSMIj032yy+QMwB4qpf3Fhkiokmz9bK3vvBb0mj5Y0C/wsks8/vqbse9tWbW/pmel3A4fBQ9Rj+eSL2IZ/EKNuirUaFVY3ujX425+y+7DFwYBg52GqrktH0YOHJJloGvHTCwoeZycF/j1eZcEluMOdIrTTKXQnw04JLMvVcrtyZ6k++5F7rVAofNqjKOjtkG+GNBvmTAE5O/4Mrjo9bo27J9Qd7WZFmuXCL/c1UAbZi3sndcrayZdc/fSsCeS5u3Cwy48wF8Km0gmcmq9xebIaX72TjCmRjSxvwvPpSKyaqJLgyk8N3nLTg9aP77rK0ys/KrKrSrLloOxvvwZuZxvKbLc8mCtgxwY2YvGoNb1PcznEbRq5M8dht8Tn3BXeztFh01zoqFV/3I34sE8hLQExGt2Gw959bT3JXnGTwtatb+XHc7nr30Io4apxDSIjiKUzh6/hTW9K3C7VU3YmfFdWir0NFWoeHD1wKXwgZe7TCD+9MDwMk+WQb+5TUDqyuA3a1mcN8U0GYsiS3WHOmVLJyNIpqUJnp2uG1uuCzOhZfMFlE6m1MrMpogtlnMAN+ua+pWn8/YKwm61T714mSdp7uYIb9rMpNDanQtRQB/5f74GGKL1OiuWMZXE+l2J57r8uHl/lpkDXkuAR/bpuH+DRosFu2KC5AOpx09ngv4cfgFxHQNNsPAh7NV2L35v+H0qXMlMapTKlqki72Mh1wor+5BlT2w8OOF/E3KSDoZTUdEhJU+tz48urd++byu0uJiQE9XWd3QivrgB5FMJnEhc1GV4b8RPoaz0QtqyV77vZW7cFv1jahz1qDep+F9W2QBAzEzsJd1vA84NyTLnHff5B/N3Lc40FbhuOoksNhzpFe6RC6FRCql5tjLXnuZa1+uWfvxJMDNpHKqPD+/Z1gy9xLYS2NHyehL0F8OUtmc2gOfzhjm25nF2wM/U1l9IptAPDtJNcMykK8mOnB6AD8+04SBlFlKvrUmg09eb6ClynnVBciIHschy8t4OzcgTzJcm0zjp6vvQ8W6d6nPLXTDvvmQ53zAbYduWXiJfaU9AK80mFwo2dLibyztHhZEREtJJnvI8VXG2+Un9xBNo/zP1mlR96GmetO4KXwdtqRX47TejpPWcxjOhvBE3/NqbfKuw+3VN+G64DWwaVZUuTW8Y6MsYCRh4FCnmb0/0gNcDAHfP2qoVecF9rRquLH18jg8Ns0rpZn2UbWknNZjdcNldZZdh/xpO7unMhi3e14F+brNogIem1Ubuy1GoJ81DGSykmmXW0NdkDCrDkZL94v8vBAD6SGVnS53U23viacN/Ki9Eo+fD8KABo+ew101nVjn6sdAuw5HtlldaJQAPYssjjjfxoHMYcj1FVcuh/8at2Lbdb+BtK9xURr2zYdk5AMue+mU2AspL5VO9mVyQY2IaEmz9f4GIBEys/WL3P+GyhsDeprS+Ix5na8WgYQfO7JbkGu24ZXQQbwVOoETkdNq+W0+3Fq1G7dU70GVvUJ9TcCp4a51soBoysDrF83g/o1uoCcC/PsxQ6360eB+R50dNtvSz5GmqaVyaaRyI6pLvgT1krmXsVTLjQT5yXQWSUwc/yZBvQarVVN78SXAl9hDLgDI+1JkIhej8rHtxKoT2VuuwnC1hd5Qt/KzpEGhVNJlc4Z6X4L4bNZQ7y9VR/i5ZOOlpD6eTSK7jMr/ptreIxchv3YwhwEZiAANe1ty2Ok8AbctC6fzcuWQfL5UMO2zHcJgNqya4N0ci+NnrWuRu+mXkJamiovQsG/upMTeBre+8Jd7n+5RmfmCbMmRvfLemoV/HyKi5czpH83W91zZyJeoHAP6wcFB/PIv/zL+4z/+AxaLBR/60Ifwl3/5l/B6vVN+zR133IHnnnvuio/9wi/8Av7u7/5uCe5x+ZsqY77Rvg671m7DQGoIL/Tvx4sD+xHKhPHDnqfwo56nca1/M26vvhHX+DeOZXU9dg23rJYFJNIGXu8y8Eq73AKXIsCjxww8ekxHjXsL1rkGsM49gAYP0NS89GWpNEXjuWxcLatmHS3Jd5bl+Lu5kQy5LKwoMnJO/q2l0V1GGvctM5Nt7zl+rgdfOxLA4UvmMavWA/zsbgva3FGcPCkXGS8fB/vC/fju0A/xuu2I+tzqTBb/32AIDtdtCF//UbgmCebncx8Xms2XC1DSxX5efSPGkW04VY4KuGXMYyFI8ztXsDDfi4houbPagEATkBgBov3M1lP5BvSf+MQn0N3djSeeeEIFmZ/5zGfw8z//83j44Yen/brPfvaz+IM/+IOx993uZdp0p/9t6KoctnDZ7JnGzEkm/v2N78B7Gu7F4eEjeL7/FZWtfzN0TC3577dV3Yibq26AX/eNfV+nruGmVbLM4F7G4Elwf7gb6ItZ0Rerxb6BWtR5Dey1WrBHN9AavDr7ScUhjdDCmYhauqarwN6pgvuyOZzQJDK5jNoTH88lVGXGSrlYmYWGA8MNeP5SJTKGRY2ie/dmcxSd0yZN7y4fBx0OB95IHsfLtteQiCWhGQY+Go7gZ0Ia9tV+DJnVO1BbgAuQhWgOKiX2fqd9rHpkvqQip9pRAZuUfy6UHMNVwyfPwr8XEdFKI5VNY9n65dnDhuanLM7Ajx8/jsceewwHDhzArl271Me+8pWv4F3vehf+/M//HI2Nl/cpTiQBfH19PZY7649+Ffd3HkL/yF70rrkPkYq1C57jO9sxc7J3flfFdWpdSvSqwP7lwYMqg//97h/j37sfx47gVrXXfoN3zRWBuQT3e9tkmftW88H9G11Slq+N7bmvl+C+zaIuBDQHGNiXChlRNpKRFYau2VRg77I6YLdwm0S5ZOITyzSIny7Dnb9YeXLAiid7mtGfNJ+vG6tz+Lk9tiuOMfnj4LGLx/BMfD+6Lb2qvH59KoXf7R9EXdUuHN37U6h1+wtSTbTQ5qDSxd5foBL7oN2HoN2PwmWYWgAbjw1ERPM/lupAoBmIDwGxQWbrqXwC+n379iEYDI4F8+Kee+5Rpff79+/HBz7wgSm/9pvf/Cb+9V//VQX1733ve/E7v/M702bppbO7rLxQKKRuJVMiqyQlw7AmQrAaadS1P6dWJLAal1bfi77mvcgtoEyyuroKXo8X6XQKum6H0+VALjf1Ht9aew0+3Phe3Gy7AS92v4K3jJPo1QZwcPgNteodtbi16kbcVLlTlW2P57ACN7VqasXSBp4/EcYrF3I4G/XiUsSC7x0x1JJs/d5V0lAPqPFcPvFOxJNX3E+aXv7fcbp/z7lIIo1kNo0RhFWJrsPigMNih9PiWDYN9cqd7ONP5lJIyUSDXBJpI1PU58xi6e8bQHdXF9KZNHSbjobGRlTXVI3993jOjieHNuDQJfM44bZm8MGNSbzjWq+6Djr+95OLHvszr+FH2tPIWrJw5Az8t+FhPBhJomPbf8HZ1tvhGr1IWYjHJZVMIZPJqu1kZom/C5FIRH1cKgSmY7da4XfpsGma6skwX1aLBdX2CvX3m84sbMtF/uvT7jrA0OTFdEHfj5a//LlWyZ5zUclZkc8Zmxdw282GeZnSGqlbDtKj2wlL/Tkz2/unGXKGV+L++I//GA899BBOnjx5xcdra2vxpS99Cb/4i7846df9/d//PVatWqUy+G+++SZ+8zd/E7t378b3vve9KX/W7//+76vvOZGU9pd0ub5hoCJ6Gqv7n0Lj8Kuwjp6op61udFTejPNVdyHsairKXevKdOFA6gDeSL2BFMzZYTp0XGu/Frvtu9FkbZq2nD6RAY4MaXh9QMPxYQ1ZOSkctcZnYGd1DturDHiX+3ZuIloQibdfvKThhx0WJLKSyzZwc52Bd7fm4J7k8va5zDk8GnsU/bl+9b40vfviwCD8tnocbPtc0Y6pREREtPzFYjE8+OCDGBkZgd/vL82A/gtf+AL+9E//dMZyewnA5xPQT/T000/j7rvvxunTp7F27dpZZ+hbWlrQ398/7QNZCldwpL9AZYsOezpsZurPPwlXtGfsc0aqNqus/UDjbhiLuN85HArj1KlTYxkmI2eoDFPL2lYcy5zC8wP7cDFxaezzW11Naq/9DcEdcIw2k5r4PaKRGIaGhmBxeNGersfpRA3ODOtj/cAtMLDaE8G26ihWO4dgQRotzS3q68dn65nFv0yyiYMdafWcWcoRZNJUTzJ/5nKobD4VRs7IqdL5tGThjYzKxEtH/XJ/zhTi+GOr2YhvH3fh/JD5eWsqgc/s0rCm8srfQ44Rw4lh/Gj4Gbwaek19rDKn4bf6+3B/NIbe1jtwdttnkLM5ilZhMJ5MXPA7dThtC9vjLhdVK+x+eG0FvHDtqUTa6lGvTffee6/a5kA02/MZPmdotvickUY4KSDaa97SjNJWF554+fWSP85IHFpdXT1jQF/Ukvtf+7Vfw6c//elpP2fNmjWqXL63t/eKj2cyGdX5fi774/fs2aNupwvopaRxsrJG1QyuhP/B8+QkO+cKoHvj+9C94T0I9L6F+rNPoKL7IAIDx9VKOQLoXXUnelffjaSntuD3we6Q8XNWJBLxsWZ68r7f5cOdrr24o+YmnI1ewLP9+3Bo+E20xy/iXzu/i+90/VCV4t9WfSMqHcGx72G12TA4NKi+d3XQhYrMAK7DAGpu3ITXe+x44UwG7SErzkR9atm0WrTY+3DNYC82VV1ES3OTaihViEZTy5E8Z5YyOJOhbQkjofZuy5Q4aazntJoBvuy9Z3n+LB9Hw1A9DMzRghLEp68uoZcRewuePF7858xCjj+DkTRe6GvBG6ec6tKGWwc+vl3D3Wuv/h0u9fThma7nsc94HQktqR65D0eT+Hx/LzyaHad3fQ79rbeqz13My1C1ddXw+WeeWW+3WRF06WqEYsnMlh9rftcA2N1jJfbl8hpKpYPPGeJzZk5/MICzzdxXL/vraXpWa1kcZ2Z734oa0NfU1Kg1k5tuugnDw8M4dOgQdu7cOZZtz+VyY0H6bBw+fFjdNjQ0YEXQLBipu04te2wAteefQt35p2FPDKH57R+g6e1HMVy/Q2Xth+u3q88vhJma6UkmaK23Ta2PZt6HfQMH8fzAK+hN9uOZ/pfUWudZjR0VW1E55EEsFINh5FBZWQm7XYdhs6nv67Om8J7NTtzdlsPLb5zG8VAQx0IVGErZcS5Zh3N9dXhyIIONl0K4c0MY9lCneZ45j0ZTtHgkKJVMZBjRseAiH9zL25LRX+mkA33GyKg9XypwH32/1GbWl4L88aezsxMvdDjw8uBqJHLmS92tbRoe3KEh6Lo6AD41dBbf6Pp/6EG/anrXnNHxJ70d2J5MIRpoxZu7/zsSvsYl/T2mPjZp8Dlt8NoX/hLu170qM1+wKSLSsEmCeTa/IyJaWnIc91SZk0SkE362tPeH0wprird582a84x3vUCPoZIa8ZFg/97nP4eMf//hYh/uLFy+qcvpvfOMbap/8mTNn1L536YRfVVWl9tD/9//+33Hbbbdh27ZtWGlS7ip0bvkoLm76ICq6D6Hu7OMI9h1BxaXX1Eq4a9Cz+m70rroLGRmLsUCS+ZZgeaYMk8/mwX11t+Oe2ltxInwaz/Xvwxsjx3A6ek4tj9WN62u3ommkRjVqkvLZiePz5Htfu6YWVRc7scN9XmXrL2qrcDJSgUjahjeGK/HGq4DXuhHXVkVxbVUE9Q4gEgmr+ycWOu+ZCiefccZogG+W6MssbbvqpC9B/nLM4ku5vIwElCz7WACfyyJrZApaNr8SDKAKj3QH0TFiBqnSSPPTuyzYXHt10BrNxPBo90/UsUcukNhhw2fCGfxC/xnIdfGOptvQteuzyBVgtnwhyBYVmS1vt5bYbHkhGXlvvZRwFO57EhHR3OhOINgKxAaA+DAfvRWgLAL6fLd6CeIlaJfu9h/60IfwV3/1V2P/XYJ82WMvzQOE3W7Hk08+iS9/+cuIRqNqH7x8zRe/+EWsZLJ3frBpj1rOcBfqzj2J2gvPwhnrw6qjj6Dl2P9T/+3SmnsRrtq8oNF302eYriQB2hb/BrWG0yN4sf9VPD+wX739QuRVwAq0oAGbImuw1taK5qbWK753/gKCZO4d7e3YbL2EdzmGcWrQimMjQZyKViCSsWNfr6wKVNoT2OIfga03Bi1ylmX4JUyC3Fg2C0iJ/rhRiVIebNd0WC1WFejbNFvhsoxLELRnc1lkDFkSvEvgvrBu4gQMxAw8/LqBly/IBRANHjvw0W0a7l6nwTqhvF7+LfYNHsL3un6IcMa8eHRdpgp/fOlttKajSGl2PF79Tti2fRCuEgnmnboVgQLMlnfZnKh2BAtb/eIKAh5uYSIiKp1sffW4bP3cptpQeSmbgF7KrSXjPpW2tja1pzRPAvjnnntuie5deZLy0QvbPomOaz6Oqs6XUXf2CfiGTqO682W1Yr5m9Ky5F32ttyGrL12H/6AewHsa7sU76+/CWyPH8Vz/KzgWfhsd6EaHrRuv2t7Crdk9uDW1BxX2wCQXEDRVTh+NhLHKo+OmDRWoqLLiueMhvHgug9MRPwZTTrzYLwuod3qwrSqKdTD32LMMv/SpQDibRRyXg3whAYoE+9axZVEXi+R/+belt/liZPglQDQD9hyy8j/1fnYsWDdXDsvVdHPfF1s6a+CHJwz84KiBZEZVzOOudZoK5v3Oq6PfC7FOfKvj+zgba1fvNzhq8fm0D+/qeEa936vX4Ym698Pbtg21JVG1I7+HDZ4Fltibje8C8OueAp801gDO0m0aS0S0YukuIDCarU+MFPve0EoP6GnxSClp36o71PIMnVVZ++qOF+EOd2L1G19D65GH0d9yM3pW34toxZol+6eQgGx7cKtafckBvNC/Hy8NvoqRTAj/eekJ/OjSU9gW2Izbq2/CZt/6sSBtqnL/e7YGcPPaBELROI4MOLCvHTjWZ8WlhBuXLrrxOKrR4grjDlsOt2004LWXdraXrpYPnGfDDOzl/0f/N/b26H+dJNtvXjQ0d67L/8v7Ofmfod5bsf8kxWo4KY//wU7g4ddzuBQxP7ah2iyvXz2he/3l8vrH1EVC+feSKQsfrLwR/+30SwgOHVSf07HqXhxf8wE0OD0lsQXHZjFL7PUFlrHLBBHJyhes8Z2wWM398lLeSUREpUleP7w1l7P1OVYELjcM6OkKErCfrfh5XLj2p1HT/rzK2ktgL830ZIUr1qms/UDz3jntKZ0pezfTf69xVOGDTe/Cexvuw+sjR9R+11ORszg8clStKr0Ct9fchL2VN6gmT1OV++c/XlcN7G1N4LUjx3EyFMCJSCU6oi50xP34l7eAbx3NYXsjcHObBdc3AXYrg/vlRgK67PipnSs3Hl8Q+duVYF4sZcPJMwMG/vW1HE70me8HXcCD2zXc0nb1xRipnHh58CC+1/UjREbL63dXbMfPoxY7X/8mbJk40jY3jmz+FIaab4SvBAJ54dZt8Lv0Bc0pkMcioHsR0H2F3ZIiY/skmLfyNIKIqCxIn5PgKiDaByTDxb43VEB8JaZJSYn9pbXvwKU198M3cFyNvqu8uF+V5PsOnUbbm99A76o70LP6nhk7P8+UvZtLdk+32NSJuKwjF0/gmd4XcdI4i4H0kDpZl+ZW1weuVcH9es/qaU9gJdhYv6oBnouduNbXg5jhRqfWijf63egYhsr8HezMqTFXN63ScOtqTWX/Sn2fNtFSkgtx8rcrwbzMfZdRcdLLQj6+GAF9X9TAtw8beEntkwd0K/DuTRret0WDS7/6b1NGZH67899xLl9e76zDJ+rfhXedeRo17f+uPtbvX4sfB+7H0JAbeuRE0UdaSuVIQGbLyy+3AJKNl6y8ZOcLyuEDvLUL6rFCRERFytb76sxsvcytzy3frYArCQN6mp6mIVy9RS09MYyaC8+g7txTqole4+kfqjVcsxU9a+7DUMNO1XRvLtm7+Wb35OsyvQncil24w3kjjiRP4ihOodcYwIHhw2o1OGtxW9VNara92+aa9PtMLM+/3eXEJwC0Dxt46by5BmLAU6cNteq8wC2rzeC+zsuTWSL5u5ELcfK3K8H8xCkUhRJLmXvkHztpIJ0z98nL3+LHrtNQ5b76b3EwNawu8r069Lp6X8rr39dwL95jrceWV/8GzmgPDGg4t+79eDyzAYZmgW/0/s90DFrMfgF2q1WV2C90tnzBx9HluSvNRURE5cvhNffXR3qBlFm5RuWLAT3NWtoZRNfGD6BrwwMIXjqM+nNPIHjpdTX+TlbKWYGetrvQ23a3GpM3m+zdfLN7E79uh/MarAu3wtPmx6HEW+okvjvRi29ffFSd1N9QsR23V9+INnfLVSe4k5XntwY1tG6XYMHA8V7ghXMG9rcb6IkA333LUGtjDVRgf2OrdNNmcE8re+67BMHyt5uvsilUoJvJGXjqlIHvHjEQTpof21IH/PSOyffJJ7Mp/KT3Gfyk5zmkjbTqinBz1Q14oP4+bD7/LFqOfhUWI4ukqxqnbvhlXNQbkTp5Ej6fe1bHoMXsF+B16PA5FvaybLPYVFbeaXWgoOS46as3szpERFT+pA+KvwFIhMwy/PHbEKmsMKCnudMsGG64Xi1HtBe1559Wy54YQsuJ76L55PcxVL8Tl9bcg7hvw7TZu/lm96b6utW+VdhSuxEfano3Xh18Hc/270NX4hJeHjygVqurSTXRkwB/Nie8Uvp6TR1wTZ2GT+8ycLDDUMH9Wz3AyT5ZBh46aOD6Zg23rdawrUFOqBnc08oyVSPKhTa8O3TRbHjXPbrVr8kPPLjDgh2NmHSfvFzI+17Xj9W4SyHbbj7a/D6s0zxY9+pXEOx9S328v+lGnN3xWWTtXujxxKyPQYvVL6BQs+V9ugeV9kDhs/JW3dwvbyuN8X1ERFRAMqVEZet7gPSV04OoPDCgpwVJemrV2LvOzR9GZderqoleoP8YKrsPqLXGU4e6mpvwam4VwuHLGa38ye98s3szfZ3b6sIdNXtV8C57aKWJ3sHhN9Eev4h/6fgO/t/F/8CNldfjtuqb0OxqmFVZrdOmqRLfW1YDgzGzHF+C+44RqOy9LL8D2NtmBvdtFdxvTyvHVI0o59vw7puv51R1jPDZDbx/Sw73b9LH5smP//vszvVcsU++yl6BDze+B9cHr0XFpdex7tD/hZ4KI2t14Py2T6G37a6x/d9zOQbNp6JopvJ8h82KoGths+UXLSufb6LkrTf3XRIR0fIkF24DzUBsEIgPMVtfZhjQU0HI3nnpfC/LFepE3bknUHPhObVP9ZroD7BZs+FS3U50N9+DVI1Zjr/Q7N5svk4yVWu9bWp9JPM+7Bs4iOcHXkFvsl9l72WtdrXijtq92BXcNjbSaaay2kq3hvdu0fCezQYuDAMvnDXw4gUDoQTUHl9ZzQGzJF+6bsvnl9rsbqJSc3HEwL+9mcOrHeb7usXAroo+XB/ogjdpxUC/+XeY//uUZpgH9SM4g/axffLvqrsL99TeCrthYNWbD6HhzI/Vf4sGVuHt3b+ChK/pqp8722PQXCuKpj+OFGa2/KJl5YWrAvBcebwmIqJlTHqk5MfbZVLFvjc0SwzoqeDi/macv+4zaL/mp1Dd+bLK2nuHz6Lx0n61ov5W1R2/v/VW1U1/Idm9uXydz+bBfXW3q5P9/R2v4fmBfThrdOBcvB3nLrTj3zr/HXurdmG393oMXeybVVmtnERLJr5tp4YHdxh4s9vcb3+w00DnCPCtwwYeOWxgaz1U1v6GFg0Om1bU2d1ES2W2F6z6owa+85aB588ZagufxKZ7W3LYZn8bfj0Np9Mz9neo6zacuXgaB3EER/VTyMHs0LsncD0+1PJuBHU/3CPtWHfgK/CEzEC/e+07cWHrgzCm6fY+m2PJXLL505Xn+zxuBFwLK7Ff1Ky8/ANIF3vpZk9ERCuLjCUNtACxASA+XOx7Q7PAgJ4WTc7mVKWtsjyDp1F/7klUdb6kTrLXvPHPWHXkm+hvuQWX1tyHWLBtyf4lkokUXAM23I9bkXHmcDh5FMdwGpFsDE/0Pq9WY64W1zu2Yp3WNutGfVIKvKMJ2NGkIZoyS/AluJc52W9dkmXAdcDAnlYNe5rSMPo6zT5TSzi7m6gQwqEw7I7pg/TpLljlA/24YcdjZ+x48pSBzOjknBuagY9eZ4EfUZw8GYPTebm8fSg8hMf7nsPzxn6ktbT6/DZLM65PbsHeqj3w27xoOPUfaD36CCy5DNIOP05f/4uq30ehzDabP1V5vpZLo8rjWFCJvVdl5f2waJZFapLUaJ7QERHRyiQnqJ5qQBJvkq3PZYt9j2gaDOhpSUQr1+FM5Tqcv/anUdP+AurOPQ53uAt1559SK1yxTo2+G2i+CblZzExeSKn6xBPtW5w34NrwBhjNVhyIv4kjoRPosvSiK/003GkXNmI1Nutr5zSGS7re37VOFtATMQN7Wb0R4NmzBp49a4PftgHbqyO4riqCSicWdXY3USH09w1IvhmnTp2CzWadsqpkuux0OBzBufYuvNJXiddGapHKGWOd63/qOgvWVef3yF8ub5eLB28mj2O//iai0ZiaWVeNCtyu70FdugrQAW82jC0vfhmBvqPq6wfrr8fZ639BTecotNlk8ycrz/e7ddQFvfMO5q0WK6rsQbhti3SM0J1m8zsJ6omIiKSPSnCVObM+GeHjUaIY0NOSkq7Sl9a9E5fWvgP+/mNqr33lxVfhGzoN36HTaHvzIfSuukOV5Cd8jZN+j4WWqk92ou3QHdhYsQk3Nu7CQGoIj7U/g1fDryOGOF7HMbUOdBzBLVW7cX3FNjgs9llfVJB59R++VsOHthqqM76UFe+7kEMo48Dzl2RVockVxdbAENZo7CJNpUme791dXWgIboTX60UiEZ+yqmSq7HTfUBg/PJrCgcGNiGfNl596Zwyf2GnHzlb7FfvA5Xs2NDbhla5XsS/xOgY1s3N9pR7EXd5bUDPkRyaWUcH8DXo3tr/0l7ClY6ON7z6pxmfmG98Vw/jy/GgkjKBLx9o1bXC7zG1Gc+WxuVDpCMCqWRevy7GnpqiPGRERlSBpiqrGlobNufUcb1dyGNBTcWgaQjXXqKUnhlFz4RnUnXsKzlgfGk//UK2Rmq24tOZeDDXsUk33CjU2aqZ9sNIh+xPrPogHYvfjjeGjOBB5A8ejp3Aqek6tb3U+imudm7AqVo9g2ge7bp/VRQUJVjbVAptqNXxqp4anj4VU1v581IuLcY9aT/8Y2NWUw21rNFxbb5bxE5UCFaRnzDL3mTq8T7xoNhxN4dBwE147H0QsY5aJVzlSuKthAM3WbmwIboSmOa4YWXcichqPjvwEZ3FBZeRdFifeXX837qy5WTWvjNclYESHsPXUt1B3br/6Oqn0OX3D55DwTj65YqnJMaG2MgA7Muoxmk8wLyPtKh1BFdAvGimrdBW+koGIiJYR6atiy4+3ixf73tA4DOip6KQktmvjB9C14QEEe95A3dnH1aipQN8RtVKOoNqH37P6boTS9jmPjZrvPliv24Ob3btxM3ZjKDWClwcP4qWBV9GfGsSB2GEcAFBtr8QmYw0SF5NzuqggjfHeuS2AO9Yn0BeK4+AlB17utOLiCLCv3VAr6IQakyed8luDDOypuFSQbjOnQBg5Y9oO7/mLZmfbu/DceS9eH6lFMmdmlivtCeyt7sOO2gRSSZl3e+X3OBU5h0e7f4K3I2fMn6vpuLNmL95Zdxc8tssBcV34tBpH54gPwNAs6Nz0QXRu/GDJlItr0sXeZYNbZvvOk8vmVCX2tsX6nVQTjwZzNB0REdFMrDYg0GSOtpMRd8zWlwQG9FQ6NAuG63eoZY/1qYx97fmnYU8Oo/nk99B08vvor70OGW0DOuKr4XC5ZxwbVagO+RX2gMoOvrPuTrze8xaevPg8zlsuot8YxIsYxD7jNWzrOI47Gm7GRu/aWTerkp/fKqsO+MA2A+eGgOfPGnjpgoHhBPCfxw21pJO+dMm/uU1GXTG4p6VnlsA3AjEgEomM7aGf7G8onDTwbHclHjsbRDxjPl+bAsAHr9GwxhXHpa5hRCOXt8zI9zgf7cCj3Y/haPht9fk2zYrbqm/EO+ruUp3r87RsSjW9kyoeEffUq6x8pHL9lPd9qcdD6hYLAm479HlW2Mjxo8LuVyPpFnXmsATzNm7zISKieYw1lYZ54UtA1qzeo+JhQE8lKeWuQcc1H0fn5g+jsuuA2msvza5qeg/j3TiMkC2At9zbcCq4AxWtG5eskZycaK9xrMKdmT1IWTPocFzCm5kTGNCG8Hr0KF4/fVRl7W+uugF7K3ehwj77MlYpyV9TCayp1PDTOwy83iX77XPq9vyQLAPffN3AdQ1m5n5nkwb76Ag8oqVQXVOF/gsprF+/ftIu94MxAz8+aaiu9YmMelajJQh8aKsFN7TI3488X6sR8F+ujpGLYn9z9mt4Y+SY+h4WWNTfz7vr70HlhL8f98gFrD/wFbhD5qD6S6vvwYVrf0ZN1JjKUo+HdNtt8Dt12SUwLzKGrsoRhD66zWhRSNWAan63CF3yiYhoZZBpKMFWINoPJMw+N1Skfwo+8FTKZO+8dL6X5QxfRN25J1F74Tn40yO4OfQCbgq/jMHcHlyy3Itw1eYFN3SaKZOXDw5SqTQSySRanXXY5FkN1Og4ZpzE/sHDqiRfSob/vftxXOPfqIKTbf4tczpBt1llZj1wQ4sVoYQ00TNndJ8dBF7rkmXAZTOwu1XDLW0attTKuTmDe1oaPr/viudbx7CBH54w8OJ5A9nR8XOrKsxAfmdzPpC/TP62unO9+HH3U2OBvJSo31h5Pd5Tfy9qHFVX/kAjh4ZTP0TrMXMcXcoRUB3shxp2Tns/C9FzY7bkdww4dTj1+ZXHywW9oN2PgO7FopK98rJnnoiIaKHk9d1bY27dkoZ5HG9XFAzoqWwkfE24sO1T6NjycVR1vqyCe+mOX935sloxXzN61tyDvtbbkZUyoDmaKZM3Pjiorq5SZce5XA5tbatRURHEDmzFh5vei/29r+HloQM4m2hXI/Bkeaxu3FBxHW6q3IU2d8sV3bxnIiX292+UBXSOGHjpvBk49UeB584aalW4oMrxJbhvDZrBAdFiksZ1x3tlW4hZRZK3uRZ4z2YLdjRe/TyUrzkZOYMfXXpKNb3LB/K7gtfhvQ33ot5Ze9XPscf6se7g3yDQbwb+vdXX4eS2n4MtePXnTjRVt/1Cj4e026yqi711nn93douOGmeFava3uDOFa8xu9kRERIVk95jZegnqU1E+tkuMAT2VnZzNgb62O9XyDJ1VgX11x4twhzux+o2vo/XIt9DfvFfNtY9WrJnV95xNJm9icCCjuyQ4sI4rWx3pD8Hf7cTd6Rtxo34dOry9eCt5HMPpEJ7t36dWvaMWN1XuxJ7K668qKZ5Jc0DDx67T8JFtBt7ugwrsX7lgYCh+eb99S8Asyb95lYYqDwN7KiwZG7+/w8zIn5Gx9Cool2oS4L2bL8+RnxjIvxU6rgL5s7H2sdJ6ycjfEdiLSi0A3bBfWSkjFTC9r2D9iW/BlokjY7HjxYq78aZjC/RzXWhsssxYOj/ZiErNYkEimYIeTxQgqNfgc9rgtc/vpVQueEhGPqD7FvcinDTVkxJ7mTNPRES0WK81/gaz/F7K8Nkwb8kwoKeyJgH72Yqfx4VrfxrV7S+g/tzjcIc6USdj8C48g0jFWlxafS8GmveqCwELyeRNFhzkG/JJACKf397eDpvVqr6PntARjPjxwY3vwvlMB14ZPITXho/gUrIX3+/+MX7Q/ZhqoHdT1S5cH7gWDqt9TlsCNtU6R0fgGTjcJcF9Dq9dBDpGgG8dNvDIYUNlSyW4392iwWNncE+zf35NDHajKQPPnDbw2HErBpKG+TdhMXBTcwbv3Ai01VwdLOaMHA4Nv4kfX3oanYlu9TGbZsMtVbtxf90dyA5n0XWuE33pS2NVMWLkwjHc1vtDtCXPm+8H1+E/vXcjpFfCN/q3N5vS+YkjKjPZrPr4hfPnFryf3iaN71w67FbLvLPy1Y4K2KU53WKSIF7tly+N7v9ERLTMOQOXG+ZlksW+NysCA3paFqTEvmft/Sor7xs4oZroVV3cD+/QGawbOoO2t76hSvF7Vt+DuN8MGsabLlifaX59OBxRH4vFYojGYqisrLziokA2ncE1gY1qP/2D2YQKcCS4fztyVpUdy3rY8j1cH7xWleRv8K6ZtEv+VFsC9HH77SMpA6+2myX5Ug59TC0DXztgYEcTcNMqsxRaxuYRzeb51T5s4PG3Dbx4zkBSxcMavHbg5qY41tvOwW4kMNypo9e4HBwnskk15vGp3hfQlzLT+A6LA3dU34R7am9FQPeriwcnL564oiqm/cJ5bI4ewTuGn4Yjl0RGs+LVitvRt/kDGLhwQQXzcy2dz4+oHH/BLf83Pt/99C7dCr/Tjvm0rViyrHz+pEr2y3MLDhERLSW5WB1ovjzejhYVA3paXjQN4erNap3fFkKtZOrPPQVntAcNZ36s1kj1FvSsuReDjbtV073pgvWJJ/oT59eLkydGgxK/H7F4AkNDw7Db7chmMldcFMhnP3e6t6kMZX9yEK8MHcK+gUMq6Nk3eEitSj2IGyt3qrL8OmfNnJp7ee0a7lonC+iPmvvtXzhvqPn2r3bIysFhA3Y1abixFWgcbWBGy8tcx7RNfH7J8/iZ4yGcOBzAif7LF5dkO8feqixu35zDhbPmHnin8/LzMevMYV/4IJ4feAWxbFz9d+kfcVfNzbir5pYr5shPrIqptKZww8XvYk3KzMr3uZrxQsP70ZlyYpWmzXjBbTryGMjPM3I5OD2eee+nvzxb3lbaWXnulyciomKT1yJ3pZmtj8h4OzX+hhYBA3patjIOP7o2PICu9e9FoPdN1J99AhXdh1RzLVnSKbtv1R3obbsLCW/9VcH6VCf54+fXh0ZCVwQl0hxvcHAQ4VAIbrcbVdXV6vsNDAygv6/vquyndPR+d909OBM9r4L5g8NvYDA9jB/1PKWWNNDbXbEDm6xr59zcq9qj4YFrNLxvi4ELw1Cd8mX1RaHm3L90AXBZrdjdm8PeNguuqQOs7JRf9uYzpi0fXGvOIF7oCeBgnx+htBl0ylPihmbg/o0WbKgyMNBuwGJcGYyH7BG8kjiMs2c6kIN5lajWUY17am5VVSeTbScZq4qJx3FN8iT29PwYjlwCWUhW/jacrLsV8aT8DuZFhukuuM3mAsZsqnCmY7daEXDrsM0j272kWXnulyciolIiW78CMt6uD0iGi31vliUG9LT8aRaM1G1XSzpm155/GnXnn4Y9MYSmtx9Va7hmK3pX343BhhtguK7uAj1VwDAxSJAGeRUVFWhtXYVUKqmC+IsXLyISicLjdqn/NjG7Lif467yr1fpY8wN4c+SYKlc+Fnob52MdaklmsEmvw4bEamx2rIORzM06GJHv31YBtFVo+Ph1ZiOzly8YeKVdmulpeO4c8Ny5HHwOqNn2N7Ro2FovAQzL8svNfMa05XIGjg868KOetTgd9iM3OkHdbc2oao93bNZR5TY/lhut6NB1O6y6FScSp/GW5W105Lqly52y1tWGW/27cV3wGnjcU0+bkPuzusaHTUf+GW0xM9s/5F2F1zf8DE4OZZGOxK4I3GVNdsFtthcwZluFMxmPQ4fPYZvXbHm5mFFlDy5+Vj5/0uStB6x8aSciohIiDaR9dWY3/KiMt2OJaCHxVZ9WlJS7Gp1bPoqLmz6osvUS3Ad73kCw74haabsPfatuR0/b3Uj4GmcMGCYLEiSYl8Dj5AkzsHI6HOq/pVIp1ZRruuy6lOTuqrhOrVA6ojL2rw69jrPRC+jEJbWeS7yKNq0JN1bugi7183OgLh5UQ3Uif3B7Dq8eSeN40ob9HUA4CTx71lBLvu32BmBXs4YdTWyoVy7mMqZNtmQ8e8b89x6IyfMooD7e4Ijg+qoh3LXJi8b6qwPjaC6KQ+E38Kz1JQxlRyAJebngdK1rM2727oLWl0U6lMapnrenrg4wDDWZ4oY3vgZbOoqcZsO59R9A75YPwGWxYmPd5BfQxlfHzOcCxmyrcPKsmgVB9/wa36m58roPAbsPS0LG0clYOu6XJyKiUuXwAjYnEOkB0ubWPFo4BvS0Isne+cGmPWrZY32oO/8Mas4/A0diEI2n/lMt2Wvf2Xgr3hrxAxbblAHDZEHC+FJ8CeLtuo5UOq321WdGLwzMlF33697Rvcc3oy85oAL7VwYOoSfVjzNox5nBdnx/5MfYGdymRuCt87RN2kxvKhYJ7v3Ajass+PQuqCZ6BzoNHOw0MBiT0WTmeDKrZmBLnTTd01QGv3I0W0ulZ6ay8kzOUJMQnj6dw5vdgNmrHvDYgVtXa9jbnEKdU4Nur78i2JWxc+diHXim7yUcCr2JTMjcB+eyOLHbtwN3Vt+MCj1wuZ/ENMG1Hh/EmsP/hMrug+r9SHANTu/8RcSlHG+KwL2Qc+Zn+70X0vjOaXWgyhFY3LnyV+xRrAJccxuBSUREVBRSRRZoAuLDQGyA4+0KgAE9rXgpdw06tnwUHZs+hIqew6g99yQqLr0+ttd+jcWJs4HtOFW5C0POmkkDholBwsTASprkpTNZJJJJOOz2GUt9J5b41ziq8O76e/CuurvRHr+IVwdfx6tDhzGSCeGFgf1qBWx+1Sl/Z8W2OQf3sndeyuy31mv49E4DZwehAnsJ8KWh3luXZBn45wMG1lWZmXsJ8Bv9DO5LyWQVIw2NzeiIOPDSkZzaZhEaN0FGLtTctdb8tzS3WMhz8vLzMplL4cDQYTzd8xI6k11jH291NeGOmr24oWI7HBb7pP0kJgbX8VhMNajceOa7aq58TrOic/OH0bXhfWPNKedqofviJ6chMM/Gdyorb/er/fJLV8Io8+VdS/PziIiICkUuROcb5mVSfFwXgAE9LXuz7vhtsWKoYada9tiA6pBfc+4puBKDuGboFbW6Hc047rsOFuuGOQVWLpcLzS0tCPj9M96P6Ur8JWBY5W5W60NN71aj7/YPvobXRt5Swf0z/S+p5bf5cH1wK64PbptyDN5U5GesrQLWVmn42HVAd8gM7A92GDg1AJxWy8Ajbxho9EvDNA3bG81Sfhub6hVdvmLkwkAaBy858M+vWNEXvbxXLeAEbl+j4Y41GhomuSAj2Xi5aLRv8CBeGXxtrFu91bBgvdaGO7z34bo1q2GdUIY+XXAdO38Um49+DY3JjrG98u17PofYuKz8fCxkX/xkdJkt77ZDn8fz2MzKB6HP8+LEnNnsgGwL4n55IiIqV/JaFmgxM/WSsad5YUBPy9p8On6LlLtKZQ87N30QOPkC6s4/ibbYKTQkO9XKPPMM+ltuRc/quxELrJr0e8x1v+5c9wRLkL7Jt06tT+Q+iOPhU2rG/eGRowhlwni2f59aPpv3iuDeqlkn/blT3U8J+t63RRYwFDdL8mUd7QG6QsCjxwy1XDqwtQ7Y1qDhugYNNV5m75eSBOLnh4ADHQZe7dRxceRyubfTZl542dtmVmJMduFlJB3C/sHXVUPGrsSlsY/7DA+2ahuw3bkFlqQFDbZmJBMpuD3OGYPrpoZ6tJ1+FKtOPQorskhrduyvuA1H/DuxwV6LQuSV5/N3NhmP3QafU59z4zvZZ19hD8ArWYal3IPoreN+eSIiKn9q1Gr1aLa+B8hli32Pyg4Delq25tPx+yqS2d50O86v2oML4V609u5HU6gHgukAAD1nSURBVOfzcMZ6UX/2J2pFKtaid9Wd6G+5GdkJJ/Wz3a+7kD3Bwmax4drAZrUyuQxORE7j0JAZ3IczETzX/4paXpsHOwJbsT2wFRs8a9TX9vcNoKtrdhc9Klwa7l0vC4imDBzuMnDoolmOH0nKHnxzH77szm7wmcG9rC21gFNngF9o0qFeqiYkiN/fnkN/7PJjLAl0aWx4c5uG65s0OGxXP/7pXEZNVZBs/JHQybGRczZY0YZmrE40IRDxoqqyCm6rC8boUzCdltK46ZvOVcU6sOXIn8MdMrPynZ712Nf4XkRsAaTmOP99JnP9O5vYSyLg0uG0XX2hayYemwuVjsCkF8kWjcz0lUVERLSc2N1AsBWI9AKpaLHvTVlhQE/L1nyD48moz3e1ore2Fb3XfAiB3iOoPf8UKrsOwDt0Rq1Vb31DNdmT4D5UvWVe2bNC7AmW4H6rf5NanzCyOBk+jdeG31IrkomO7bmXvc9rrGtRPxzEKjSg0nf1SL3peOyaChZvbjMDy3NDwBvdBt7sNnCqH+gOyzLwk7elsZ6U8MuebU2tDdWYNMBclls5Cmw4bqjH+Y0u4M1LBqJj28402LQc1njD2NNqw+2bferfaKKckcOZ6AUcGDL7MORL6sUazyrs8l4HX48DDthh9drQE+3F0NCw6gORy+RUHC9j66bi0YHWt7+H+jOPQYOBlO7Dc8E7cdqzBU6bq0D73AvDYbMi6Jp74zurxapG0bmlU+9SkeOJT+ZJepbuZxIRES0lixXwNwCJESDaz4Z5s8SAnpatxWmYlZ9rv00tWzKEmvbnUXv+GbjDnahpf0GthKdOBfYyAi/lqizanmCbZsU1/o1qPdjyAbXn/rXhN/HGyHEMp0dwPHccx0c/tyFVgzW2VtTFq7A6uXpOP9Niubzv/oNbgVjKLMnPB/h9UeDtflkGfnDUUNljaa63oVq+TlNvV7rN/fvLeSvHfMTTBk72yRQCA291mxdOxnPrBla7hrHBF8Lm6jSyqbgaJWfJbhrLoks5/oVYp2pwJ6MQh9IjY18f1AO4qXKnWvXOWtXc7mT6JJw+p7oQVlERxODgIMKhEDxus9mb0+W4+o4aBiq79qPtjYfUtAj1OLXehgvX/gxiIymgQM/pwtDgd9pUmf1c+XQPKuz+OfWlWDCZYS/N72SvIRER0XLnDJgl+GFpmDeumy9NigE9LVuFDo4nk3H40b3+Pehe9254h06rwL6q82U4oz1oPfYIWo59G8N129Hbdqdqtjebbt6F2hM8kZQFb/atV+vBZgMXop14peMI3kocRh8G0Z3rUws68GzHq9gW3oLrAluwwbt2zo2+3HbpnG6OupNgUgL6Yz0GjvWatwMxqCD1ZJ9Zni+CTjOLLwG+rDVVgHeSDPOy2MoxjXDSrHCQAF7WuUHJql/5OasrpZzebEZYYwvj9KlzY5UohsWsREkmk+jKXcIbw8dUEN+fMoNs4bQ4sSN4DXZX7FDPh/HB6cQLYVaLBRUVFWhtXQWvx6sq4SZyRrqx+vDXEOx9Q70vF7TObv85ddFL1NZiUZ7T8298p6vbuX2drkbRSfO7JS9B9NabHe2JiIhWCrmYHWgGYoNAfEI2g67AgJ6WtcUKjq+iaYhUrlfr/LZPouriftSefxr+gROo6HldrbTDj76WW1VwH/e3LNqe4NndXQ2t7ma4nbW4q/IGnOp6G2cy7eiwXcJF9GAwM4xn+19WS0rzJai/xr8B1/g2otZRPadMunxurReo9Wq4Y62ZLe6NAsd7DNUx/8yAgfZhYDgBtR//0MXLQX69F2itAFYFNbRWaFgVBKo9xc3kF3Irh1QySMb97IA5KlBu5bGZqNYDbK7TcM1o08GA8/LvH49fDsBtDhtOJy/gnN6BR9p/hHA2MvZ5douObf4tatTcVv/GK2akT9w+MPFCmATz8rckWysiuDxaxpJNofHkD9D09qOw5DLIWXRc3PAAujY+gJzVvqTP6dnwzKPxnRpFp/vg171L/7yTkT7SKIiIiGjFNsyrMi9uS8O8bKbY96gkMaCnZW+pA4mczalK7WU5w12ovfCsKsu3J4bQePqHaoUr1qG37S4MNN90VSO9pd6rXV1TBZ//elyb2qp+hsVhwYnwadUs7c2R42oc3luh42qJKnuFCuy3+DeoDvvSLG0uJCiq8wJ1owG+SGYMXBgyx+Hlg/zeCHBpdL3acTnIl276zX6g3q+psXkNPhm/Zgb/9iXYlz/dVo7J/q3kAkY4afYU6BwxcHEEuCi3IahKhclIQ8FNtRo21wJbajVUeSb/veR7h7Qw2gM9eGvkOC4mepDRRl/ssmYm/lr/JmwPXqOCeceEIHu67QPTXggzDFR0HUTbW/+iqlHEcO11OLf9M0h4G1BqpBO9NL5z2CylPYruihOYGsDpX9qfS0REVIp0FyCjbqN9QDJc7HtTchjQEy2ihK8R7VsfRPuWjyHYcxh1559B8NJr8A2dVqvtzYcw0HQjetvuQLhq81WN9JZqr/bEix5Sai9LAsbOeDeOhk/iWOhtnI6ew0BqCM8PvKKWBRas9rRik3ct1nvXqKZq8ylJlgZ5G2qADTWXf/9QwhzD1j5soH0IuDBsBsHxNFRn91MD+Tr0y/Xofoe5F19WlVtTtxUuwOfQ4JWx3Q5zue1md/P5Plb5DPZwKIK05oSnqgkHzifQ0TOMUFJDJOdEwmoglLar7QbJaS4o13iANZXAGtlmUKmpcvrJmtnlxbMJdcHlWPgkjobevqKUXlLPQZtfBfBqkoF3jWqSON/tA5NdQPLFO3DNSw8j2H9UvZ90VuL8dZ/CYOOekhyj5tKt8Dvn1vhOLgBUOoKqi31RGgLJfnm9uNUMREREJUW2nvnqRrP1vWyYNw4DeqKlYLFiuGGnWnpiGNXtL6D2wtNwSwa//Tm14t4G9K66Q823T7mrFn2v9myz6S3uRrXeUXcnktkUTkbOjAWTPck+nImeVws9T6kAv9XdpALJdd7VWONuhV/3zetn+50y8s4sMc/LZM2gXnXQDxnoVm+bt9E0EEqaSy4EjA/0r3zbjDtlNrvdCjisktk339atEuiruFh9jvrJmrmHPZUBklkzOE9lKpDIBJHIjN630/nvPPXvWuUGmgNAU0BDk1/e1tAYmLlPQDKXwvloB05Fz+J46JTqUJ8fL5fvjbDW04ZrfBtU88MWV+OsS8Pnsn1AGkA2H/026s8/pbrXS3l91/r34OLG96uqlEIoZDWKJo3vXDa4dVvpN73Ls8kVpwbAypdmIiKiSTl8gFxwlxL89OVJPSsZzxqIlljaGcTZlntxsvY2VMXa0dL9Eqo7X4Yr0o1VR7+F1qOPYKR2K9qrd+NE0gNXoGrBe7ULRUq2twU2qyX6k4M4Hj6FU5GzODWavT8f61Dr8d7n1OdU6kG0eVqx2t2isvmtrqZ5NxazWTWskj31FfLe5aBVKgkiKWAwZpaxD8YM9fZgHBiKG4gkpdkc1G08Y17UlUy/rPkzf75cAPDac7AbSfjsBjx6FkF7Gs5cGNesrsWqWo/a96/L7L5ZCKUjOBu7gNORc2pdiF9E1she8TnSx2DLaADfam2CNavNKwiezSQILZdB/ZmfoPnEd2BLm3sE+htvRPu1n0DSU4tCKWQ1it1qVY3vbHOoGJDnZKU9ALs04SnWCYq3tiSrHIiIiEqKXPgONF1umGdM6B68wjCgJ1piEwOXiy0fRv11n0ZV5z61314a6QV731Jrk2bH2dBGnKvcifOW+iuCrWLNQR+v2lGJWx17cGv1HvW+BPQS3Mt4vLPRC+hO9GIwPYzB4WE1Li+fOW101qngvtnViCZnPRpd9fDZ5j9fWzLS+XL6icH+ROmsuaddZdqz5sq/nc6auXy5QJDvLJ9MppHLZuB22uBz28cy+nLrdUh5PJBMpHHyhJmmzwfGYmNTI1yuqe9LLBPHhXinysDLRRAZLSeP10RB3Y91ntWq8kGC+BpH1dhz6cLFc/MOgqedBGEYCF56HW1vfUNdbBKRQBsO1z4I7ZptalRhoRSuGkWDz2mDdw7j6GSmvATyRSmvz3NXmouIiIjm9vpp95jj7bILytKUNQb0yw6zO6Vs6sBlE3Jtd6Kv7U44oj2qiZ7Ms5eGY5sib6kVsgXQ3XATYtk6tPfqSzYHfarfY7KLCdIwr6pyJ26s3KneT2QTuBC7iHOxdpyLtqugVWagX0xcUms8v82HJlc9Gp316lYC/QZnLZzWwl6skEy57K2fzd+RuvgyNPo4J3XUeZtRW1M95xGJsWwc3YkedMV70JXoMd9O9GB43Dz4yz9ZQ52jBuu8bVjvWa16E8jjOrGMvlBB8GQN8DxDZ9F69FsI9poXYVKOADqu+TgutdyOgfYMqktwcoDNYkFwDuPo5PEM6F4EdF/xpibIz/XVmycjRERENL/takFpmNcPJK4+r1oJGNAvM3U+J3IwkMzkkMrmkMrIXtuVXYZSSmYTuCQ9dejc/BF0bvowfAMnUXHuadR2vQp/ZgT+jseAjsfQ4GjCSe9WdFbtQCiNsUAu/zMWM2s/l9JoCcY3+taqlSdBrGSkz8U6cDF+CV2JS6qxWygTRigcViX843mtHtQ5q1Fjr1KZ6bFlr1ZZ/fkEY7OpbphrwOyv8iKkB9Eb70WfMYjjyfPoOd03ZeCeV22vRJu7BW3uZqxyt6geBK5ZXMQo5Pi8fAM8Z+QSWl59BNWd+9THc5oV3evehYubPmhOY8iXLRTYbEr/p+OZ4zg6ycZX2AOwSQO6YpYL+hoB2+x+RyIiIpqCJvsfay6Pt8td7jW0EjCgX2bkhNZutagl5PQ7nc0xwC8RcwpcNA3h6k1qdWZ/DhXdB1Fz4TkEe95AffKiWtnBJ9Hu3Yi37BvR2+XFkHRdX8SsfSGywkE9gO1BWVvHPpbIJlXWWmXu45dwPtSOrmQP4kggko0iEo2qZnATOS0OBHQ//DYvfLrXvB1dDqtD/XeHxa4uLMjbMot9eHAEfZd6kE1n4dAdaG5sUaP7ckYOWWTVrayh2DB60v3QPXakjQGk9DRC8RDae3uQsqUxkg6bFyHSYQynQ4hmYzP+3rLVoMFZp24bXebbcx37V6gg+IrvlRhG84nvovbcU7AYWRjQ0N9yCzq2fLSg++SnMlOFw3RZeRlHlz/ezaYHhDS8m28Ph4KO35HMfDEvKBARES03dg8QXGUG9anpz8uWEwb0KzDAl6x9MptDWmXxr2y2RaUZuOSsdgw071UrO3QJljcexcbwW6hK92F1+BhW4xjiQz/GOc8mtFdch/NGPdrbzQB4YrCdz07bVGZwbtntQmaFx5MAS/bUy5L7d7LvhPq45rCgN9mPEYRhr3GiO9qL7lgPRowwoloMiVwSiWSf6rY/Z/neZ12ja6rPSU04Yo6bEjeRx+pW1QOSdZf+AlJVoAJ3Rx3cBd6jPdvn0nTVCBLIN5z6T9SffRzWbFJ9bKhuO9qv+SnEgm1YSpOV/k/HLVl5hz6rcXSyT75C98MrVQbF5gwAnmo2vyMiIloMFivgbwTiw0BsYEU0zGNAv8wEHX5kkVEZT8kyTiTnvg6bRS048uO4smMZ/MwKK1EphrkGLhNZK+rRu+VDeOPiHgSiF3FN4jg2xI7DlYlgS/iwWlGrB0csbTgb3oKuwFo0Nreonzu+XN6uO9AQ3Fi0rPBsLxq0OBvhGxlBXboOjeFq2KzXwulyom+oH32JQVi8VmT0DOwBJwyXdIkPI5KJqnFvKuDPJpEcvU3l0sjkMjC0mQ/uNs0Ku2aHNWeBbtjU2z6HF5XuoNrvL+P4ZAXU215U2StnVSq/lM+lidsjqqqrEfD74cnFsKbjcdSdewLWrHnFIlyxDu1bH0So5hoUS770f6asvN+pm8ewGcjoOb/uKe4++Tz5+RLIS0BPREREi8sVBORCfuQSkBmfnVl+GNAvM36bB7rNLONMZdOI5wOabGrSAF+yW07dqpbIGAaS6awK7pNp2Y2//K9qlWrgMrtAbg0G7Hdjn5FD5PDjWBc9jjXRE/Bko9iTPYo9Q0cRDvlxemgzYuvuQteAoQILCZaTCfPglogn4fY4F7XCYCEXDYaGhhCNxZHNXEQsHkdlZSUy2SxyqSx8WTdq7TWqKz1GgI0Nm6a9Lyr7f+KEel7bHXbEkjEpssfG9RvhdrthhUUFgeNnkBdzmsD4ny0mux9TPZcmbo+Qx7Hr+GtYbxzDtbE3YRsdhTcSWIOuLR/BcP2Oks8azzYrL8G71+ZG0O6DVSuBsnZp1Cfz5aXUnoiIiJaGzQ4EWsxMvWTslykG9MuYzFOWJZ2cJeCR7KQE93GVsUyZQdAEMrfZZrdBei5LtnNs/z3L8xfdXAPHiYFceN0teO5iG37iugV14VO43tKJNfHT8GVD2DGyHzi0H9dafejwX4P2wBb0OFvV16XTEtg7Z30/FlJhMJvfcfxFg+GRERXMe9wueH0+xBNJDA0No6IiiJSqMtBhtdlgs1pnVfo//nvHIjF14WBVUzMqvMFZP85LZXx2XS5gCPk9Z9sfYXylgz/WhV2Dz2JL6hSsMC/sdVjrcCB4C3p869FobUFtCQfzc8nKS8O7oN0P3WIrnZMJCeaLNd+eiIhoJdNGK+T0fMO85bfduETOeGixScZKGkLJCsCngvmElCSPZu8nC/Cv2H8/Wp6fyGTMPfgZaRzG7H0xOsdPJR9oS2Db3u7GM9br8arditqhY1gXPYa2xDn4s2FcM/SKWnGLGz0VuzGsXY+E73oYVn3KEu3ZZoUL9Tvmf5ehwSF0dHao+yDl9xLIDw4OIh6LQ9MssNvtKsidS+n/Qrc8LDa56GH+G7ar383pcqGnp1f9t7q6WmQzmVk1IpTHY3W6A9vP7UdL4vzYxy86W/G8vh2njFrUBmrV3rL5zXwvray8y+ZU++TlImZJNefx1pkZeiIiIioeu9scbxfpBbLLa4sxA/oVHOC7rA61hJTjJ7JmgJ/fazyRnFC7dRvco+fLqiyf2fsFK9Q88SsDbc3McEcTiHo2IrnhbgxU+YG3X0Sg42W0RU/BlYuhbeBZYOBZZN50ob9mO0LZethca+D0+VWJ9smTb6v74bDb53SRYWImfj6/o/p4ZQV6e3vGyu+tFgsqKirQ2roKqVQS/X198yr9L1bWfaYqhfxFj1gshmgsprYXaLncWCV8LpebsRGhJZNAdefLqD/9Y3hC7ebXQcNx2xocDtyAkH81+vr7YbfPrbphqc22g700VJTS+qJ3rp/IVQF4qop9L4iIiOiKhnkNQDyK5aRsAvo/+qM/wg9/+EMcPnxYZeWGh2feByEZ59/7vd/DP/zDP6jPv/nmm/G3f/u3WL9+/ZLc53Iie4bdNqdaImtkVYCvyvOzKaQnCfCZvS+MxegcP1kWWl2L3HwXutr2oj0RQ3X4HCrOH0JT5DXYE0Oo796HeumjoNnQ6V6DY0YjTmiNcDqq1N/SVF3zZ5OJdzrsV/2OUk4vGXgJ2mdTfp8P3CWYz19YqKqqKtlM+1yrFK646OH3IxZPqO0F1VWVYw1aLRbLlNUI7pF21J17EtXtz8OWiauPZa0OXGy5Heca70RvxoFQXx8SyeS8qxuWhgavw6bWdEl5GUEopfX5Y1ZpzcKtBRy+Yt8TIiIimoya9LR8lE1An0ql8JGPfAQ33XQT/umf/mlWX/O//tf/wl/91V/hoYcewurVq/E7v/M7uP/++3Hs2DEVUNDUpJGU7EWVJTK57Fj2Xkr1pVP4TNn7hGTv01mk2Tm/KJ3jp8pCq49J1jxQgY7sVnS1/iz8w2fgb38ZwY59CGSG0RZ9G214G+8C0HexAeecq/FmuganEwm4PZ6rAtHxjdsmy8SvamubtNGdlNN3dXehuroadXV1c96zP9nvWMwmdnOtUhh/kWTihZ389gLJ1ns85ri1RDx+RTWCJZNEZdd+Fcj7B05e/tmeevSsvge9bXcia/dC/mWax10ACYXD865uWEx2qxV+lw59mvp6m8WmZsnnj00ld+VfNb8r/mNJREREK0PZBPRf+tKX1O3Xv/71WX2+ZBS//OUv44tf/CIeeOAB9bFvfOMbKmj4wQ9+gI9//OOLen+XG5vFCq/FPTbHOZ3LXBHgZyc0mLicvbchK53zR0fjsXN+cTrHT0uzIFK1Qa3Dje9G8txraA6fQGvsNJqyvahJdqu1G0As6cGF2Fq0R9ci5bwPw4ncWMZZs1jg9XiQTKXG9rznqw2kVH6yRnc2m01loSXA7+/vvyL7PvExms3jUYheBIUwmyqFbC6nfu9UMqk67Eu/gvEXPcZvL5CAX6gLBLoNtbHzqD30HVRefGUsG5/TrBhq2IWeNfdgpGar+ned6nH0B/wlVd1gkckLTrkgaJt2lnxQ96nu9UUfQTcZm2O0+V3ZvKwSERHRMrBszzzOnTuHS5cu4Z577hn7WCAQwJ49e7Bv374pA/pkMqlWXigUUrdyIi6rVOXvWzqzVJ0bNTg1J5yj5a5Skp8Y7aKfyqaQnTAiz2GxwmG3wrDL3Hvpmp9FknPvx1RXV8Hr8aqO87puh9PlQE66EC6i/Pcf/3Oqa6qR8N6OUPom7AtHEOs5j7rh4yq4X5fthDsbxebIm2oZT/4APY5GXHS1od3RhpNxL4aHhlVZuJEzEAwG1Wg8mXdvs9lR7fOp33F4aAidXRfhdrkxNDQIh25XXdzla7ovdqnPkd9/rmT8nny9Bgt8Pj+SieSCvt98TXU/Wla1qsdCHhPZuz4yLBc6dPj9QdXorre3TwX7cgEkEolCt+lobWlWzw3hjFxCTecLqO14Ac5Y7+Wf565Fz6o70LPqTqSdFeYH5Z90hqaVDodDLTHb59pkz5mFctms8Dntqsonm736+1o1C3x2L3xWM5DPlGIjG4cXcNeYnUMn2Z60ko29NpXw6yeVFj5niM8Z4nEGc3rt1IzJZpeVMMnQf/7zn59xD/3LL7+s9sx3dXWhoaFh7OMf/ehH1Unht7/97Um/7vd///fHqgHGe/jhh1UWjWil0nIZVEVPom7kMOpDh+FN9lzx3zMWOwY8m9Dnu0atkKt50iwxzZ4n0Y3G4QNoHH4VwbjZ4E6kLU50VexBe+UtGPSs5+NMREREtMzItssHH3wQIyMj8Pv9pZmh/8IXvoA//dM/nfZzjh8/jk2bNi3Zffqt3/ot/Oqv/uoVGfqWlhbcd9990z6QpXAF54knnsC9O9dDt1lRSuSaUVJl8KXBnqzJrzZJcktK8/PZe47Fm1l/3wC6u7qQzqRVRrehsRHVNbPrrC1Z1sGONCpbdFhmmAkmP0cujl3IGNC9u9Cw4X2osiaRPvY0GqJn1Fg0Ty6OuvCbaomkzYNQxQZEazcjVLkRkeAaNRov//1k/7xk9KVBWzAYUCXmYv2GDfPO0J96+231tsMpmfDknL6ffL1USITDEQz098/rMZ3N/ZD/HomE0dHZqbaySLZesvOitqYawdhFrIqdwubMWfgi5p57YWgWDNdci96WWzHYcANyNgfkEVvKDQVzec5MRYMGn8MGl33ypnfSoNOnu+GzedTbJUuer546wF6Ce/lL8bXp3nvVlhIiPmeIxxkqtnSZvDblK8VnUtSA/td+7dfw6U9/etrPWbNmzby+d3299OsGenp6rsjQy/vbt2+fVRnqeKpJWQn/g+dJMF9qAb2wwwYfXONG5CVVB/3EuA76cq91mzwlbapi2Jx3b+69z7Cx3lVUk7UuM+Dzej1mA7quTvj8cxt3J4HZTMFZbV21+r4T91wPbHonjrRfwNDgIOqMYWyxD6I1cQGNiXY4MlHU9L2ulvp3t+iIVKxBuGoTqqo2omLdKnQOVmBgYADZbBoWi7nX3O2Z335u+bqGpsbRXgShsb3rs/l++T3v0gFeyt1lf7/sX5/PYzrT/ZBb9bZmjhZMD3djU/IUrrH2ofX8ebgzkbHvJfviR2qvxWDTHhXEZ8Z1Ti9mqDub58xkXLqU1+uwTrIH3gzkPfDrHtWUs+S746r98qX/mlAqyuU1lEoHnzPE5wyt9OOMPsv7VtSAvqamRq3FIF3tJah/6qmnxgJ4ucqxf/9+/OIv/uKi/Eyay4g8l1r5DvrxbGKsyZ7sv5fTfYfNopaQTvmJtDTVY9f8xRx3N53JGtPlO9BLvwoJzF/PteFIcA+aGuqx2h6Cb+Ak/P0n4Rs8CT0ZUp3Y893YN412Yw/5V2HY04Jo5TqEnRaERkLzbtQ2XUf8qYzvPu90ONRjKFM1ZF//fB/T6e6HHh9Uj8uqwbfhHTgGX+gCNHUJy5TWdFx0rUJs7R2IrroJGbvZEK+c6RaL6l4/2Ux561gg7y3tjHye3QN468wMPREREVGRlU1TvPb2djXCSW6z2ayaRy/WrVsHr9c84ZXS/D/5kz/BBz7wAbVPXvba/+Ef/qGaO58fW9fY2Ij3v//9Rf5taDwpO/ZZPOqkXqSyacRzScQzCSRzKVWyLwGB7rCoUt10brRrfjqHVHapmgCunHF3cyXB6urVbeoC2vgANoJ6RCo3oHv9e1WDNmf0kgpkff0nVIDvDnfBFb2kVh32j32/YWsQQ44apCtXQ6vfgJi/GQlfE3LW2f1es+2IP9mFEQni7bqOVDqtGtVlRrvUz+cxlfvgs6TgHjkF/dxZ+IZOIxg6C1e8/6rPHXE34azegnN6K/q8q1Df3FaU7vyFJt3rZZ68x26btGu9BPE+m7s8AnnhrjQXERERUYkom4D+d3/3d9U8+bwdO3ao22eeeQZ33HGHevvkyZOqaUDeb/zGbyAajeLnf/7nVRO9W265BY899hhn0Jc4u1UyeToCund0/31qNHufUm/rFglmbfDaoUbiJdJZc+b9knX4Lw1FH3c3yf2Z8mdrGhLeBrX6Vpl/r7ZkGJ7hc/AMn4Wr/xScA6fgz4wgmB1GMDYMxE4BnY+rzzWgIempRczfgrivCXFvA5LuGiQ9NUi5qmBYJj+UzWYm/cQLI3a7XU2LkPJ7h90+42MqzQIdsX44oj1wRnvhjHTDHWqHe6Qd9uTl41Ge/C6xwCqEqzYiXLkeIzXXIO2qVPfVk0ohWAJj5BZOg9tuhc+hq+714+nS2V/3lO74ucnI/ZSsvHSzJyIiIiohtnLqbj/TDPqJDfvlZPEP/uAP1KLyJP+GTqtDrcv77/MBfhKpXFpl/zx2s6leIpMxS/MzMtqqrAY4zMt8SswnCofCsDuWPoiU/eAjddvUCtWH1AW5apcVlakeBBO9cEcuolmPwRfrhp6KwKkC5h6g++BVAXLKVYmkuxppR0CtjMOPwZQF4XAKMUOHobuRqqyFK1ANzeWD3RdUTeYk8LziwkgopDLKa+sbUeHW4bDk4LYOwnapA3piGHpyGPbEiLrVEyNwxPpUMD++ZH7ifQvZAhiw12LY3YROWz16HQ1Ys+W6qx7vuVYWlCqnboXXoUOfEMk7rHZ1kS6/1aZsyD552S8v++aJiIiISkzZBPREl/ffO9USWSOrAnyzwV5SZQPd+uWO+bIkwDeWcXA/m0Bwsky1dJoHfDh16hRsNqsKaotV5p3Pko9kgKR7Nc5ZGgD3ddi4aRNcTgf05Ahc4U64Q51whTpVJtwe74Mz2gdLLg1HfECt8ZoBbBv/ge6pf74E3nkqOL8wt/uftdpVBUHCXTdWSSBZ+B4EcOz0+bE+B0bOQGwR+xwUk90qDe9sV+2Td9mcqrTeNXpRrqzY3YC3nvvliYiIqGQxoKeyJt2wPTaXWiKdy4xl73VLUnXVNlyjwX06h0Qmu+LG4eU7uMs+8XxZvmT1ZdxdQ3Cj6kGRSMTV58jHixFozrR9IO0MqhWq2XrlF0p/haSZKbfH+lXjPVlGuB/JwS54tRTsmRismQR0IwUHMrAZmat+/mQZ9qzVgazNiZzNiYzNZd4HqQBwBpFySiVAUFUFJD116uOqLHsCSzxREn0OFpPNYva2kMz8+Moaj9WlAnnZPlOWXBWAZ/bjComIiIiKgQE9LSu6xabWxAZ7CVsSCT1p7snPmIG9BPjSUX85G9/BXbLEagzbxU4VLMucdbHYHfJns4993tsHNG0s2Efl+it+5skTJ8be7+vvV83uqqqrVQ+GRGgQG9augc/vUxcFVEAvF3o0TQXyMuMdBWjUtlh9Dmb7mC52IO9xWOHWbVd0rPfqHjVDXppdliXulyciIqIywoCeVlSDvcRYg70kktkUUlkZh7d8Z91PNdpOisx1m5k5lTLwxcocT1YdMF1Zf6H2kY8PpKW5naZZVLM7m9WKeCIByDx3bxUyDmdZ9DlYyGO6GPwOHV6XPrZRwWaxqWy81+Yqn471k+F+eSIiIiozDOhpxZAyYNnHm9/LO3H/fTyTQnx01v1yCe6nGm0nAT4aNSAGRCKRsT30hcz2TlUdsFRl/eMD6VA4jP6+vqJNAyjUhYpiPqb5EXT9SMFtt6lgXhrdSSCf3/JS1jhfnoiIiMoQA3pasabbfx9KxxFLScf88g7upyv5djgc6L+Qwvr16xely/1U1QFL2RAuH0j7A35UVVVNmiUvhfL1Un5M84G8BPG5rNlrQJpSVjr9KqBfFjhfnoiIiMoUA3qiSfbf1zgv77+PpOIYTiQQS6fLMrifqeRb9pFbJg4LX8TqgGI1hJssS14K5eul+pjKfni1R340Gy/vO+1y8WsE1Y4K6NYy3SM/nsVidrGXbvZEREREZYgBPdEs9t83eaD23IdSMQwlEgglY0iXUXBfjBnni9UQbrlsCSjVx3RiIC9ZeGlyJ5UsmWz5POdnJHPlZb58uXbhJyIiImJATzR7EtjUuGRJQ3QDoVQcQ4k4RhJxtQ9/Oc+6L5WGcMttS0ApPab5rvUu3abK7D02N/w2T/mOnZuOaopYO+moQSIiIqJywgw90Twb7AUcbrUQABLpjMrcDyeiKrhP5dIM8ItYHVCOWwKK9ZiOD+TtFh1e3a261UuPiWVHAnhPNeAMFPueEBERERUEA3qiAnDqNjToXjT4vKqRXjSZwXAyphrspXIpJBngL6r5NLYr9S0BSzlH3m1zqd4R+QkQy5LFapbY6yvj35eIiIhWBgb0RAXm1K1qVXrtKriPpbKIJTNIqsCeAX6hLaSxXSlvCVgsusWiutZ7HLI3XrLxHtgk2F3OdBfgqzeDeiIiIqJlhAE90SLRoKkyZlmVHjtiKQfiaTfiqSwMI4e0kVaN9iTQlyx+jnvwi9LYrlS3BBSa3WaFx25FhdOjAnnJyq8IrgrAU1Xse0FERES0KBjQEy1RcO+x29TKuQ3E0hnEUjbY03b4Rj8nnUuPBfdSop81svy3WaaN7ZaOXFSywOe0o9Lhg9fmVqMZVwQ1kq4OsHuKfU+IiIiIFs0KObMjKh3SQdxr19XKGgZiqQzi6SyQlnJo6ShuBiCZXGYsuJfbtJEp9l3HSm9sN5+9+sUgo+fcDisqnW4E7F64rU7VyHHFsDnMEvvl2KGfiIiIaBwG9ERFZNU0+By6WhLcx9MZxFM5tffeZrGp5R793KyU6Y8L8NlJf2kb2y1kr/5SltUHHHZUu3xq7NyKycaP5/QDnhqOpCMiIqIVYQWe7RGVbnBvZu6BnArusyqwV3vuYaisq9XqhNNqBquGYaig3sziSwZfyvRzWGmWorFdIfbqL2o23q6jyu1G0O5d3p3qZxxJV2MG9EREREQrBAN6ohIty/eM7rk3PMZoYJ9TGXwJ9oWUUDusdrUu78PPjMvip1WQvxIsdmO7mfbqL30pvrk3vsLpRpVTsvGulVVSP5GU1stIOtvibLUgIiIiKlUM6InKplu+vGdHMpNFPJ1DPJVBJndlRl5KrPVxZfo5IzeWxc+X6bObfmH36i9lKb5ZUu9EtcsLn+6GVeMYNjh8ZmZemuARERERrTAM6InKjMNmVSvo0pHO5VSAn0jnkBgtzR/PolngtDrUwrhu+hLYJzIp9CNVhN9g+ezVF4tdim+3WuF3OlEl4+b0FbovfsoS+2rAGSj2PSEiIiIqGp4ZEpUx3WKBbreoffdSmp/KSFm+GeSnMpOPvZNO+rKcmhMXMIxGRx2yWlaV56syfVWqz476s9mrHxoJLcrYPMnEB+0uVLrMIN5mYSb+6hL7erObPREREdEKxoCeaBmV5uez94DZNV/23idHA/yJ5fljX5ffi4/L+4+l4d7lAD+j3pbbiRUAK83EvfqFG5unwaPbEXQ6UeH0wGNzquoKmoTDC3hqWWJPRERExICeaHl3zfeoxnrm+6msGdgnMzkk01lMnr+/HOTbNTvslisD03zTPcng5zP5K7GzfiHG5jmtdvgdTrWCDpbSz4gl9kRERERXYYaeaIWwWy1q+UarlKNJc/+8y25DNmfOuZ9JvuneeFkjawb34zL5GePq/fwreWyertngtNnh1R3wOhzw252wW3n4nTV5rFQXe5bYExEREY3HM0qiFUqarYlKtx26zapK8mUPfiprqEx+OpObVVAundatViuc47Z5S8m+BPUZwwzuMznJ5EvAn1UXAJZrKb7MhJfg3abZ4LI54NEd8Dh0uHUdNnZhnx+W2BMRERFNiQE9EZkHA4sFNrtldOSdmpGHVDarSvVTaUO9nZZU/ixIyb4EtvokhxgJ9iWol0A/pwL8HOR/2fzbhvl2qY7Xk6DdAqtqVCeBu02zwmGxwyXZeZsNdpvZy8CykufCF4I8fu4qwBUs9j0hIiIiKlkM6Ilo2iy+yuSPbqWXjL3K4qtMfk4F+OmsBN6zD74l2FeB8AyHn3zgr8L9fKAPQ90a6iKA+bb8bFVLYBhj9/HyvRn9mDHxI9KG7vL9kfcs0lZQk1uLakhnBu6jt1KFoJZsW5Cg3QLdKktTt8y+FxhL7ImIiIhmhQE9Ec2zk75JwmcJ6jPZHDI5uZVy+xyycpubW7A/WeBfDBK4W60abBZZFthU4G4G7/IY0CJiiT0RERHRrDGgJ6IFkQDXbpU1+Zg12ZuflUA/ZyCXvzUuvy//beka6Gmq+79sZ7daJPuuwWrRIEUItnFBPIP2ImCJPREREdGcMaAnokWlMtwWYLr+5BLQSzJfBfeGLKig3yylN5P86saYPA5URfOj1xMkGLeoj0kJ/eh/lyBegnfuay9NLLEnIiIimhcG9ERUdBJ8WzWoDDmtMCyxJyIiIpo3BvRERLT0pFrCUw04A3z0iYiIiOaJAT0RES0tqw746gHbdBsxiIiIiGgmDOiJiGjpOHyApwaqMyERERERLQgDeiIiWqIS+xrA6eejTURERFQgDOiJiGhx2eyAV0rs7XykiYiIiAqIAT0RES0eaXonze84MpCIiIio4BjQExFR4ckeeU+tOZaOiIiIiBYFA3oiIios3WmW2Fv5EkNERES0mHi2RUREhSFl9a4KwF3JR5SIiIhoCTCgJyKihZNsvLcO0F18NImIiIiWCAN6IiJaGNknL/vlOVueiIiIaEkxoCciovnhbHkiIiKiomJAT0REcyel9VJiz8Z3REREREXDgJ6IiObGUwn4avioERERERWZpdh3gIiIyoTNbt46g8W+J0RERETEgJ6IiGa1V15G0fmb+GARERERlRCW3BMR0TSvEnZzr7zNAaTTfKSIiIiISkjZlNz/0R/9Efbu3Qu3241gcHblnp/+9KehadoV6x3veMei31ciomWTlQ+0mME8EREREZWcssnQp1IpfOQjH8FNN92Ef/qnf5r110kA/7WvfW3sfYeDJ6ZERNOSAF5l5Uf3zBMRERFRSSqbgP5LX/qSuv36178+p6+TAL6+vn6R7hUR0XLLylcBLja9IyIiIioHZRPQz9ezzz6L2tpaVFRU4K677sIf/uEfoqqqasrPTyaTauWFQiF1m06n1SpV+fuWzmSLfVeoTOSfK3zOkGL3mMG8zJWf4lg3dpwp4WMhlRY+Z4jPGeJxhkpNukzOZ2Z7/zTDMAyUEcnQf/7zn8fw8PCMn/vII4+oPferV6/GmTNn8Nu//dvwer3Yt28frFbrpF/z+7//+2PVAOM9/PDD6nsRERERERERLaZYLIYHH3wQIyMj8Pv9pRnQf+ELX8Cf/umfTvs5x48fx6ZNm+YV0E909uxZrF27Fk8++STuvvvuWWfoW1pa0N/fP+0DWQpXcJ544gncu3M9dNvkFyuIrnjOZLJ44tApPmdWcnm9lNbLTHl5ey7HmXvvha7ri34XqfzxOUN8zhCPM1Rq0mVyPiNxaHV19YwBfVFL7n/t135NdaKfzpo1awr28+R7yYNy+vTpKQN62XM/WeM8+ccu5X/wPAnmGdATnzM0LYfvcnn9fI4zZXI8pNLB5wzxOUM8zlCp0Uv8fGa2962oAX1NTY1aS6WzsxMDAwNoaGhYsp9JRFQydCfgrjZviYiIiKjslc0c+vb2dhw+fFjdZrNZ9basSCQy9jlSmv/9739fvS0f//Vf/3W88sorOH/+PJ566ik88MADWLduHe6//34sW3Kibimbf1YiWgoyfs7fAASaGcwTERERLSNl0+X+d3/3d/HQQw+Nvb9jxw51+8wzz+COO+5Qb588eVLtMRDS9O7NN99UXyP77RsbG3Hffffhf/yP/7G8Z9H7G6U+A8hlgWxqdKXHvZ0p9j0koqVisZql9c7S7f9BRERERCsgoJdmeDPNoB/f38/lcuEnP/kJVvSJvMUF6K4rPy6P0aSBftr8b0RU/qRKx1Uxp4Z3RERERFR+yiagpwKRk3ubw1wT5QP8TPLKYJ+BPlH5BPISxMvi1hsiIiKiZY8BPV1m1c1l91z5qIwP7jP5jD4DfaKSwUCeiIiIaEViQE+zD/ThmSGjP3rLjD7R0m2tUaX1AZbWExEREa1ADOhp/qbK6I/P4nOPPlHhyd+dKwg4/AzkiYiIiFYwBvS0CM8qu7kmYqBPtMC/LYeZkXd4+UgSEREREQN6KnKgr7rujyvXV+X7o133ichkd5uN7uSWiIiIiGgUM/RUAl33pwr0x43UY6BPK/Fvw+EzA/nJKl6IiIiIaMVjQE/lNV4vH+iPb8Qnb+eyxbqnRIVvdCdN7mTJ20REREREU2BAT8sj0M/lLgf34wN9dtynstofL2X1Xja6IyIiIqJZYUBPy2cOt8UF6K4rP57NjAv0x2X2iUqqrD5w9UUqIiIiIqIZMKCn5c1qM9f40XqStVeBvQT6skef2XxaYrInXkbOyZKLUURERERE88CAnlZmVlR3mmu88c338gG/ZPiJCvW8U0G87+rnHhERERHRPDCgJ8qz6uaabG++CvJTl9+WjxPN6uKRywziuTeeiIiIiAqMAT3RvPfm5wP8cZl9NuEjoYJ4rxnEs1M9ERERES0SBvREC9mbD/eVHx8f3OdL93MZBvorJYiXXg2SjWcQT0RERERLgAE90WKX7UvWfnyH/XwTvlyWj/1yKKeXIJ6ZeCIiIiIqAgb0REsR+MlIsoljySSgn9htXwJ+lu2XLsm8SwCvu83FDvVEREREVEQM6ImKGhy6ryzbz2fzJzbhY7f9Iv0bWQDbaA8FCeBl3BwRERERUYlgQE9Uqtl8x8Ru+6MBvgr0RxfL9gtL+iKoAN5p3jKAJyIiIqISxoCeqGy67Tuvnl8+FuinRvfnS5Avtyzdn/HCiep3YDeXTQJ4B5vZEREREVFZYUBPtBwDfSFl+vngXjrtq9v8+9kV9PjkA/dxAby8LUE9EREREVEZY0BPtNxH68n+74lkr34yDuAE4KsFLKNN+iTwH1vZ0m7QJwG59CHQrIDFZi75fVUAr5u3bFpHRERERMsYA3qilVxyLmTkmj5h1N74kn4jOxrc529zo0uCfePKt8XYRYDZXAzQRjPlcmsZXaMfG3t/qsUMOxERERGtbAzoiWhqKsNtuRz8ExERERFRyZCzdSIiIiIiIiIqMwzoiYiIiIiIiMoQA3oiIiIiIiKiMsSAnoiIiIiIiKgMMaAnIiIiIiIiKkMM6ImIiIiIiIjKEAN6IiIiIiIiojLEgJ6IiIiIiIioDDGgJyIiIiIiIipDDOiJiIiIiIiIyhADeiIiIiIiIqIyxICeiIiIiIiIqAwxoCciIiIiIiIqQwzoiYiIiIiIiMoQA3oiIiIiIiKiMsSAnoiIiIiIiKgMMaAnIiIiIiIiKkMM6ImIiIiIiIjKEAN6IiIiIiIiojJkK/YdKHWGYajbUCiEUpZOpxGLxdT91HW92HeHygCfM8TnDPE4Q6WGr03E5wzxOIMr4s98PDoVBvQzCIfD6ralpWWmTyUiIiIiIiIqaDwaCASm/O+aMVPIv8Llcjl0dXXB5/NB0zSU8hUcuejQ0dEBv99f7LtDZYDPGeJzhnicoVLD1ybic4Z4nDFJmC7BfGNjIyyWqXfKM0M/A3nwmpubUS4kmGdAT3zOEI8zVEr42kR8zhCPM1Rq/GUQN02Xmc9jUzwiIiIiIiKiMsSAnoiIiIiIiKgMMaBfJhwOB37v935P3RLxOUM8zlAp4GsT8TlDPM5QqXEss7iJTfGIiIiIiIiIyhAz9ERERERERERliAE9ERERERERURliQE9ERERERERUhhjQExEREREREZUhBvTL0Pve9z60trbC6XSioaEBP/MzP4Ourq5i3y0qUefPn8fP/uzPYvXq1XC5XFi7dq3q/JlKpYp916iE/dEf/RH27t0Lt9uNYDBY7LtDJehv/uZv0NbWpl6L9uzZg1dffbXYd4lK2PPPP4/3vve9aGxshKZp+MEPflDsu0Ql7E/+5E9www03wOfzoba2Fu9///tx8uTJYt8tKmF/+7d/i23btsHv96t100034cc//jGWAwb0y9Cdd96Jf/u3f1MHtu9+97s4c+YMPvzhDxf7blGJOnHiBHK5HL761a/i6NGj+D//5//g7/7u7/Dbv/3bxb5rVMLkgs9HPvIR/OIv/mKx7wqVoG9/+9v41V/9VXVx8LXXXsN1112H+++/H729vcW+a1SiotGoep7IhSCimTz33HP4pV/6Jbzyyit44oknkE6ncd9996nnEdFkmpub8T//5//EoUOHcPDgQdx111144IEH1LlvuePYuhXg3//939WVy2QyCV3Xi313qAz82Z/9mbqSefbs2WLfFSpxX//61/H5z38ew8PDxb4rVEIkIy/Zs7/+679W78tFw5aWFvzyL/8yvvCFLxT77lGJkwz997//fXXuQjQbfX19KlMvgf5tt93GB41mpbKyUp3zSqVqOWOGfpkbHBzEN7/5TVUay2CeZmtkZEQd5IiI5lO9IRmQe+65Z+xjFotFvb9v3z4+oES0KOctgucuNBvZbBaPPPKIquiQ0vtyx4B+mfrN3/xNeDweVFVVob29HY8++mix7xKVidOnT+MrX/kKfuEXfqHYd4WIylB/f786Waqrq7vi4/L+pUuXina/iGh5kgogqRS7+eabsXXr1mLfHSphb731FrxeLxwOB/7rf/2vqhJoy5YtKHcM6MuElChKCdp0S/ZC5/36r/86Xn/9dTz++OOwWq345Cc/CcMwivo7UGk/Z8TFixfxjne8Q+2N/uxnP8t/shVmPs8ZIiKiYpK99EeOHFEZV6LpbNy4EYcPH8b+/ftVD6BPfepTOHbsGMod99CX0d6ggYGBaT9nzZo1sNvtV328s7NT7V18+eWXl0VZCS3Oc0YmIdxxxx248cYb1b5oKZGllWU+xxnuoafJSu5l+sF3vvOdK/ZAy4mT9FpgxRjNhHvoabY+97nPqWOKTEmQaT1EcyFbwWS6kzSGLme2Yt8Bmp2amhq15luKJKQpHq0cc3nOSGZepiPs3LkTX/va1xjMr1ALOc4Q5ckFHzmWPPXUU2MBvbwOyfty8k1EtFBSdSpNNqVk+tlnn2UwT/Mir03LIT5iQL/MSAnJgQMHcMstt6CiokKNrPud3/kddfWJ2XmaKpiXzPyqVavw53/+5ypLm1dfX88HjSYlvTmk6abcyn5pKWET69atU/vTaGWTkXWSkd+1axd2796NL3/5y6r50Gc+85li3zUqUZFIRPVwyTt37pw6rkiTs9bW1qLeNyrNMvuHH35YZedlFn2+P0cgEIDL5Sr23aMS9Fu/9Vt45zvfqY4n4XBYPX/kYtBPfvITlDuW3C/DZg+/8iu/gjfeeEOdPDU0NKg90V/84hfR1NRU7LtHJUhKpqc6yWbfBZrKpz/9aTz00ENXffyZZ55RF4iIZGSdjAOSE+3t27fjr/7qr9Q4O6LJyIm1VIpNJBeG5HWKaOK2jMlIlaG8PhFNJKPppFKsu7tbXfjZtm2baiJ+7733otwxoCciIiIiIiIqQ+x6RURERERERFSGGNATERERERERlSEG9ERERERERERliAE9ERERERERURliQE9ERERERERUhhjQExEREREREZUhBvREREREREREZYgBPREREREREVEZYkBPREREREREVIYY0BMRERERERGVIQb0RERERERERGWIAT0REREVTF9fH+rr6/HHf/zHYx97+eWXYbfb8dRTT/GRJiIiKiDNMAyjkN+QiIiIVrYf/ehHeP/7368C+Y0bN2L79u144IEH8Bd/8RfFvmtERETLCgN6IiIiKrhf+qVfwpNPPoldu3bhrbfewoEDB+BwOPhIExERFRADeiIiIiq4eDyOrVu3oqOjA4cOHcK1117LR5mIiKjAuIeeiIiICu7MmTPo6upCLpfD+fPn+QgTEREtAmboiYiIqKBSqRR2796t9s7LHvovf/nLquy+traWjzQREVEBMaAnIiKigvr1X/91fOc738Ebb7wBr9eL22+/HYFAAP/5n//JR5qIiKiAWHJPREREBfPss8+qjPy//Mu/wO/3w2KxqLdfeOEF/O3f/i0faSIiogJihp6IiIiIiIioDDFDT0RERERERFSGGNATERERERERlSEG9ERERERERERliAE9ERERERERURliQE9ERERERERUhhjQExEREREREZUhBvREREREREREZYgBPREREREREVEZYkBPREREREREVIYY0BMRERERERGVIQb0RERERERERCg//39jCPd8spRbgQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "X_test = torch.linspace(-3, 3, 300).unsqueeze(1)\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.scatter(X.numpy(), y.numpy(), s=10, color=\"gray\", alpha=0.5, label=\"train\")\n", - "\n", - "for alpha, vr in models.items():\n", - " mean_pred, samples = vr.predict(X_test, n_samples=100)\n", - " std = samples.std(dim=0)\n", - "\n", - " X_1d = X_test.squeeze().detach().numpy()\n", - " mean_1d = mean_pred.squeeze().detach().numpy()\n", - " std_1d = std.squeeze().detach().numpy()\n", - "\n", - " plt.plot(X_1d, mean_1d, label=f\"α={alpha}\")\n", - " plt.fill_between(X_1d, mean_1d - 2 * std_1d, mean_1d + 2 * std_1d, alpha=0.15)\n", - "\n", - "plt.title(\"Predictions + Uncertainty for different α\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "28243768", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Loss curves\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "575858f2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 4))\n", - "\n", - "for alpha, hist in histories.items():\n", - " plt.plot(hist[\"train_loss\"], label=f\"α={alpha}\")\n", - "\n", - "plt.title(\"Training loss for different α\")\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "aedd2017", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Model Sampling\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "dc9ecc68", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "alpha = 0.5\n", - "vr = models[alpha]\n", - "\n", - "sampled_models = vr.sample_models(n_models=5)\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.scatter(X, y, color=\"gray\", s=10)\n", - "\n", - "for m in sampled_models:\n", - " with torch.no_grad():\n", - " pred = m(X_test).detach().numpy()\n", - " plt.plot(X_test.numpy(), pred, alpha=0.6)\n", - "\n", - "plt.title(f\"Posterior model samples (α={alpha})\")\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a1210aa4", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "Noise stress test\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "b73e8a98", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "=== Retraining VR with HIGH noise, α=1.0 ===\n", - "\n", - "=== Retraining VR with HIGH noise, α=0.5 ===\n", - "\n", - "=== Retraining VR with HIGH noise, α=2.0 ===\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Xn, yn = make_synthetic(noise=0.5)\n", - "train_loader_noisy = DataLoader(TensorDataset(Xn, yn), batch_size=32, shuffle=True)\n", - "\n", - "models_noisy = {}\n", - "\n", - "for alpha in alphas:\n", - " print(f\"\\n=== Retraining VR with HIGH noise, α={alpha} ===\")\n", - "\n", - " model = SimpleNet()\n", - " vr = VariationalRenyi(model, alpha=alpha)\n", - "\n", - " vr.fit(train_loader_noisy, num_epochs=100, lr=1e-3, n_samples=4)\n", - " models_noisy[alpha] = vr\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.scatter(Xn.numpy(), yn.numpy(), s=10, alpha=0.5, label=\"noisy data\")\n", - "\n", - "for alpha, vr in models_noisy.items():\n", - " mean_pred, samples = vr.predict(X_test, n_samples=50)\n", - "\n", - " mean_pred_1d = mean_pred.detach().cpu().numpy().reshape(-1)\n", - " std_1d = samples.detach().cpu().numpy().std(axis=0).reshape(-1)\n", - " X_test_1d = X_test.detach().cpu().numpy().reshape(-1)\n", - "\n", - " plt.plot(X_test_1d, mean_pred_1d, label=f\"α={alpha}\")\n", - "\n", - " # доверительный интервал ±2σ\n", - " plt.fill_between(\n", - " X_test_1d, mean_pred_1d - 2 * std_1d, mean_pred_1d + 2 * std_1d, alpha=0.13\n", - " )\n", - "\n", - "plt.title(\"VR robustness under heavy noise\")\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "b90ad6c4", - "metadata": {}, - "source": [ - "------------------------------------------------------------\n", - "VR for out-of-distribution detection (OOD)\n", - "------------------------------------------------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "a71f953b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "X_ood = torch.linspace(5, 8, 200).unsqueeze(1)\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.scatter(X.numpy(), y.numpy(), s=10, label=\"train data\")\n", - "plt.scatter(X_ood.numpy(), torch.zeros_like(X_ood).numpy(), s=10, label=\"OOD region\")\n", - "\n", - "for alpha, vr in models.items():\n", - " mean_pred, samples = vr.predict(X_ood, n_samples=100)\n", - "\n", - " # Явно приводим к 1D numpy\n", - " X_ood_1d = X_ood.detach().cpu().numpy().reshape(-1)\n", - " mean_pred_1d = mean_pred.detach().cpu().numpy().reshape(-1)\n", - " std_1d = samples.detach().cpu().numpy().std(axis=0).reshape(-1)\n", - "\n", - " plt.plot(X_ood_1d, mean_pred_1d, label=f\"α={alpha}\")\n", - " plt.fill_between(\n", - " X_ood_1d, mean_pred_1d - 2 * std_1d, mean_pred_1d + 2 * std_1d, alpha=0.15\n", - " )\n", - "\n", - "plt.title(\"Out-of-Distribution behavior for different α\")\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.19" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}