From 8ccbab2a8fd96007257297bae118b0fb81c24123 Mon Sep 17 00:00:00 2001 From: Blazej Banaszewski Date: Tue, 13 Aug 2024 15:08:54 +0000 Subject: [PATCH] training models with shared weightd --- notebooks/downstream_adaptation.ipynb | 843 ++++++++++++++---- ...shared_weights_downstream_adaptation.ipnyb | 820 +++++++++++++++++ 2 files changed, 1504 insertions(+), 159 deletions(-) create mode 100644 notebooks/shared_weights_downstream_adaptation.ipnyb diff --git a/notebooks/downstream_adaptation.ipynb b/notebooks/downstream_adaptation.ipynb index 4a5126b..67acc7c 100644 --- a/notebooks/downstream_adaptation.ipynb +++ b/notebooks/downstream_adaptation.ipynb @@ -1,59 +1,254 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Downstream adaption with MiniMol\n", + "\n", + "This example shows how MiniMol can featurise small molecules that will then serve as an input to another model trained on a small downstream dataset from TDC ADMET. This allows to transfer the knowledge from the pre-trained MiniMol to another task. \n", + "\n", + "Before we start, let's make sure that the TDC package is installed in the environment. The package is quite large, and we assume that a user wouldn't necesserily need it in their work, that's why we don't include it in the dependencies." + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "# change cuXXX to the cuda driver version installed on your machine\n", + "%pip install torch-sparse torch-cluster torch-scatter -f https://pytorch-geometric.com/whl/torch-2.3.0+cu121.html\n", + "%pip install hydra-core\n", + "%pip install graphium==2.4.7\n", + "%pip install minimol\n", + "%pip install pytdc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Getting the data\n", + "Next, we will build a predictor for the `HIA Hou` dataset, one of the binary classification benchmarks from TDC ADMET group. HIA stands for human intestinal absorption (HIA), which is related to the ability to absorb a substance through the gastrointestinal system into the bloodstream of the human body.\n", + "\n", + "We then split the data based on molecular scaffolds into training, validation and test sets. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/blazejb/minimol/.minimol/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" + "Found local copy...\n", + "generating training, validation splits...\n", + "generating training, validation splits...\n", + "100%|██████████| 461/461 [00:00<00:00, 3648.38it/s]\n" + ] + } + ], + "source": [ + "from tdc.benchmark_group import admet_group\n", + "\n", + "DATASET_NAME = 'HIA_Hou'\n", + "\n", + "admet = admet_group(path=\"admet-data/\")\n", + "\n", + "mols_test = admet.get(DATASET_NAME)['test']\n", + "mols_train, mols_val = admet.get_train_valid_split(benchmark=DATASET_NAME, split_type='scaffold', seed=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset - HIA_Hou\n", + "\n", + "Val split (58 mols): \n", + " Drug_ID Drug Y\n", + "0 Atracurium.mol COc1ccc(C[C@H]2c3cc(OC)c(OC)cc3CC[N@@+]2(C)CCC... 0\n", + "1 Succinylsulfathiazole O=C(O)CCC(=O)Nc1ccc(S(=O)(=O)Nc2nccs2)cc1 0\n", + "2 Ticarcillin CC1(C)S[C@H]2[C@@H](NC(=O)[C@@H](C(=O)O)c3ccsc... 0\n", + "3 Raffinose.mol OC[C@@H]1O[C@@H](OC[C@@H]2O[C@@H](O[C@]3(CO)O[... 0\n", + "4 Triamcinolone C[C@@]12C=CC(=O)C=C1CC[C@@H]1[C@H]3C[C@@H](O)[... 1\n", + "\n", + "Test split (117 mols): \n", + " Drug_ID Drug Y\n", + "0 Trazodone.mol O=c1n(CCCN2CCN(c3cccc(Cl)c3)CC2)nc2ccccn12 1\n", + "1 Lisuride.mol CCN(CC)C(=O)N[C@H]1C=C2c3cccc4[nH]cc(c34)C[C@@... 1\n", + "2 Methylergonovine.mol CC[C@H](CO)NC(=O)[C@H]1C=C2c3cccc4[nH]cc(c34)C... 1\n", + "3 Methysergide.mol CC[C@H](CO)NC(=O)[C@H]1C=C2c3cccc4c3c(cn4C)C[C... 1\n", + "4 Moclobemide.mol O=C(NCCN1CCOCC1)c1ccc(Cl)cc1 1\n", + "\n", + "Train split (403 mols): \n", + " Drug_ID Drug Y\n", + "0 Guanadrel N=C(N)NC[C@@H]1COC2(CCCCC2)O1 1\n", + "1 Cefmetazole CO[C@@]1(NC(=O)CSCC#N)C(=O)N2C(C(=O)O)=C(CSc3n... 0\n", + "2 Zonisamide.mol NS(=O)(=O)Cc1noc2ccccc12 1\n", + "3 Furosemide.mol NS(=O)(=O)c1cc(Cl)cc(NCc2ccco2)c1C(=O)O 1\n", + "4 Telmisartan.mol CCCc1nc2c(n1Cc1ccc(-c3ccccc3C(=O)O)cc1)=C[C@H]... 1\n", + "\n" ] } ], + "source": [ + "print(f\"Dataset - {DATASET_NAME}\\n\")\n", + "print(f\"Val split ({len(mols_val)} mols): \\n{mols_val.head()}\\n\")\n", + "print(f\"Test split ({len(mols_test)} mols): \\n{mols_test.head()}\\n\")\n", + "print(f\"Train split ({len(mols_train)} mols): \\n{mols_train.head()}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Generating molecular fingerprints\n", + "Now that we have the splits, we will use MiniMol to embed all molecules. The embedding will be added as an extra column in the dataframe returned by TDC." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from minimol import Minimol\n", "\n", - "import os\n", - "import math\n", + "featuriser = Minimol()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 12/12 [00:25<00:00, 2.14s/it]\n", + "100%|██████████| 24/24 [00:01<00:00, 14.06it/s]\n", + "100%|██████████| 81/81 [00:05<00:00, 13.51it/s]\n" + ] + } + ], + "source": [ + "mols_val['Embedding'] = featuriser(list(mols_val['Drug']))\n", + "mols_test['Embedding'] = featuriser(list(mols_test['Drug']))\n", + "mols_train['Embedding'] = featuriser(list(mols_train['Drug']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model is small, so it took us 6.6 seconds to generate the embeddings for almost 600 molecules. Here is a preview after the new column has been added:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Drug_ID Drug Y \\\n", + "0 Guanadrel N=C(N)NC[C@@H]1COC2(CCCCC2)O1 1 \n", + "1 Cefmetazole CO[C@@]1(NC(=O)CSCC#N)C(=O)N2C(C(=O)O)=C(CSc3n... 0 \n", + "2 Zonisamide.mol NS(=O)(=O)Cc1noc2ccccc12 1 \n", + "3 Furosemide.mol NS(=O)(=O)c1cc(Cl)cc(NCc2ccco2)c1C(=O)O 1 \n", + "4 Telmisartan.mol CCCc1nc2c(n1Cc1ccc(-c3ccccc3C(=O)O)cc1)=C[C@H]... 1 \n", + "\n", + " Embedding \n", + "0 [tensor(0.2477), tensor(0.1814), tensor(0.4020... \n", + "1 [tensor(0.7070), tensor(0.4123), tensor(1.0127... \n", + "2 [tensor(0.1878), tensor(-0.1408), tensor(0.891... \n", + "3 [tensor(0.1206), tensor(0.3858), tensor(1.5851... \n", + "4 [tensor(1.0168), tensor(1.1367), tensor(2.2483... \n" + ] + } + ], + "source": [ + "print(mols_train.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Training a model\n", + "Now that the molecules are featurised leverging the representation MiniMol learned during its pre-training, we will set up a training and evaluation loop of a simple Multi-Layer Perceptron model using PyTorch.\n", "\n", - "import torch\n", + "Let's start by defining a new class for the dataset and then creating a separate dataloader for each split." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader, Dataset\n", + " \n", + "class AdmetDataset(Dataset):\n", + " def __init__(self, samples):\n", + " self.samples = samples['Embedding'].tolist()\n", + " self.targets = [float(target) for target in samples['Y'].tolist()]\n", + "\n", + " def __len__(self):\n", + " return len(self.samples)\n", + "\n", + " def __getitem__(self, idx):\n", + " sample = torch.tensor(self.samples[idx])\n", + " target = torch.tensor(self.targets[idx])\n", + " return sample, target\n", + "\n", + "val_loader = DataLoader(AdmetDataset(mols_val), batch_size=128, shuffle=False)\n", + "test_loader = DataLoader(AdmetDataset(mols_test), batch_size=128, shuffle=False)\n", + "train_loader = DataLoader(AdmetDataset(mols_train), batch_size=32, shuffle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our model is a simple 3-layer perceptron with batch normalisation and dropout. We also add a residual connection that before the last layer concatates the the input features with the output from the second to last layer." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ "import torch.nn as nn\n", - "import torch.optim as optim\n", "import torch.nn.functional as F\n", - "from torch.optim.lr_scheduler import LambdaLR\n", - "from torch.utils.data import DataLoader, Dataset\n", "\n", - "from tdc.benchmark_group import admet_group\n", "\n", - "from contextlib import redirect_stdout, redirect_stderr\n", + "class TaskHead(nn.Module):\n", + " def __init__(self):\n", + " super(TaskHead, self).__init__()\n", + " self.dense1 = nn.Linear(512, 512)\n", + " self.dense2 = nn.Linear(512, 512)\n", + " self.final_dense = nn.Linear(1024, 1)\n", + " self.bn1 = nn.BatchNorm1d(512)\n", + " self.bn2 = nn.BatchNorm1d(512)\n", + " self.dropout = nn.Dropout(0.10)\n", "\n", + " def forward(self, x):\n", + " original_x = x\n", "\n", - "class MultiTaskModel(nn.Module):\n", - " def __init__(self, hidden_dim=512, input_dim=512, head_hidden_dim=256, dropout=0.1, task_names=None):\n", - " super(MultiTaskModel, self).__init__()\n", - " \n", - " self.dense1 = nn.Linear(input_dim, hidden_dim)\n", - " self.dense2 = nn.Linear(hidden_dim, hidden_dim)\n", - " self.bn1 = nn.BatchNorm1d(hidden_dim)\n", - " self.bn2 = nn.BatchNorm1d(hidden_dim)\n", - " self.dropout = nn.Dropout(dropout)\n", - "\n", - " self.heads = nn.ModuleDict({\n", - " task_name: nn.Sequential(\n", - " nn.Linear(hidden_dim, head_hidden_dim),\n", - " nn.ReLU(),\n", - " nn.Dropout(dropout),\n", - " nn.Linear(head_hidden_dim, 1)\n", - " ) for task_name in task_names\n", - " })\n", - "\n", - " self.trunk_frozen = False\n", - "\n", - " def forward(self, x, task_name):\n", " x = self.dense1(x)\n", " x = self.bn1(x)\n", " x = F.relu(x)\n", @@ -64,183 +259,513 @@ " x = F.relu(x)\n", " x = self.dropout(x)\n", "\n", - " x = self.heads[task_name](x)\n", - " return x\n", - "\n", - " def freeze_trunk(self):\n", - " self.trunk_frozen = True\n", - " for param in self.dense1.parameters():\n", - " param.requires_grad = False\n", - " for param in self.dense2.parameters():\n", - " param.requires_grad = False\n", - " for param in self.bn1.parameters():\n", - " param.requires_grad = False\n", - " for param in self.bn2.parameters():\n", - " param.requires_grad = False\n", - "\n", - " def unfreeze_trunk(self):\n", - " self.trunk_frozen = False\n", - " for param in self.dense1.parameters():\n", - " param.requires_grad = True\n", - " for param in self.dense2.parameters():\n", - " param.requires_grad = True\n", - " for param in self.bn1.parameters():\n", - " param.requires_grad = True\n", - " for param in self.bn2.parameters():\n", - " param.requires_grad = True\n", - "\n", - "\n", - "\n", - "def model_factory(lr=3e-3, epochs=25, warmup=5, weight_decay=1e-4):\n", - " model = MultiTaskModel()\n", - " optimiser = optim.adam(model.parameters(), lr=lr, weight_decay=weight_decay)\n", + " x = torch.cat((x, original_x), dim=1)\n", + " x = self.final_dense(x)\n", + " \n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we declare the basic hyperparamters, optimiser, loss function and learning rate scheduler. We build a model factory that allows us to instatiate a fresh copy of everything, which will become useful later." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.optim.lr_scheduler import LambdaLR\n", + "\n", + "lr = 0.0003\n", + "epochs = 25\n", + "warmup = 5\n", + "\n", + "loss_fn = nn.BCELoss()\n", "\n", + "def model_factory():\n", + " model = TaskHead()\n", + " optimiser = optim.Adam(model.parameters(), lr=lr, weight_decay=0.0001)\n", + " \n", " def lr_fn(epoch):\n", " if epoch < warmup: return epoch / warmup\n", " else: return (1 + math.cos(math.pi * (epoch - warmup) / (epochs - warmup))) / 2\n", "\n", " lr_scheduler = LambdaLR(optimiser, lr_lambda=lr_fn)\n", - " return model, optimiser, lr_scheduler\n", - "\n", + " return model, optimiser, lr_scheduler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For evaluation we will use both AUROC and Average Precision metrics. The reported loss would be an average across all samples in the epoch." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from sklearn.metrics import roc_auc_score, average_precision_score\n", "\n", - "def evaluate(predictor, task, eval_type='val'):\n", + "def evaluate(predictor, dataloader, loss_fn):\n", " predictor.eval()\n", " total_loss = 0\n", - "\n", - " dataloader = task.val_dataloader if eval_type == 'val' else task.test_dataloader\n", + " all_probs = []\n", + " all_targets = []\n", "\n", " with torch.no_grad():\n", " for inputs, targets in dataloader:\n", - " logits = predictor(inputs, task_name=task.name).squeeze()\n", - " loss = task.get_loss(logits, targets)\n", + " probs = torch.sigmoid(predictor(inputs).squeeze())\n", + " loss = loss_fn(probs, targets)\n", " total_loss += loss.item()\n", + " all_probs.extend(probs.tolist())\n", + " all_targets.extend(targets.tolist())\n", "\n", - " loss = total_loss / len(dataloader)\n", + " loss = total_loss / len(all_probs)\n", " \n", - " return loss\n", - "\n", - "\n", - "def evaluate_ensemble(predictors, dataloader, task):\n", - " predictions = []\n", - " with torch.no_grad():\n", - " \n", - " for inputs, _ in dataloader:\n", - " ensemble_logits = [predictor(inputs).squeeze() for predictor in predictors]\n", - " averaged_logits = torch.mean(torch.stack(ensemble_logits), dim=0)\n", - " if task == 'classification':\n", - " predictions += torch.sigmoid(averaged_logits)\n", - " else:\n", - " predictions += averaged_logits\n", - "\n", - " return predictions\n", - "\n", - "\n", - "def train_one_epoch(predictor, task, optimiser):\n", + " return (\n", + " loss,\n", + " roc_auc_score(all_targets, all_probs),\n", + " average_precision_score(all_targets, all_probs)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training is a rather standard boilerplate loop: " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def train_one_epoch(predictor, train_loader, val_loader, optimiser, lr_scheduler, loss_fn, epoch, eval=True):\n", + " predictor.train() \n", " train_loss = 0\n", - " \n", - " for inputs, targets in task.train_loader:\n", + " \n", + " lr_scheduler.step(epoch)\n", + " \n", + " for inputs, targets in train_loader:\n", " optimiser.zero_grad()\n", - " logits = predictor(inputs, task_name=task.name).squeeze()\n", - " loss = task.get_loss(logits, targets)\n", + " probs = torch.sigmoid(predictor(inputs).squeeze())\n", + " loss = loss_fn(probs, targets)\n", " loss.backward()\n", " optimiser.step()\n", " train_loss += loss.item()\n", "\n", - " return predictor, train_loss / len(task.train_loader)\n", - "\n", + " train_loss /= (len(train_loader) * train_loader.batch_size)\n", + "\n", + " if eval:\n", + " val_loss, auroc, avpr = evaluate(predictor, val_loader, loss_fn)\n", + " print(\n", + " f\"## Epoch {epoch+1}\\t\"\n", + " f\"train_loss: {train_loss:.4f}\\t\"\n", + " f\"val_loss: {val_loss:.4f}\\t\"\n", + " f\"val_auroc: {auroc:.4f}\\t\"\n", + " f\"val_avpr: {avpr:.4f}\"\n", + " )\n", + " return predictor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now, let's see how good our model gets after training... 🚀" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "## Epoch 0\ttrain_loss: ------\tval_loss: 0.0132\tval_auroc: 0.6979\tval_avpr: 0.9076\n", + "## Epoch 1\ttrain_loss: 0.0208\tval_loss: 0.0131\tval_auroc: 0.6479\tval_avpr: 0.8884\n", + "## Epoch 2\ttrain_loss: 0.0183\tval_loss: 0.0102\tval_auroc: 0.7792\tval_avpr: 0.9384\n", + "## Epoch 3\ttrain_loss: 0.0126\tval_loss: 0.0069\tval_auroc: 0.9208\tval_avpr: 0.9792\n", + "## Epoch 4\ttrain_loss: 0.0077\tval_loss: 0.0052\tval_auroc: 0.9542\tval_avpr: 0.9893\n", + "## Epoch 5\ttrain_loss: 0.0052\tval_loss: 0.0042\tval_auroc: 0.9667\tval_avpr: 0.9927\n", + "## Epoch 6\ttrain_loss: 0.0037\tval_loss: 0.0038\tval_auroc: 0.9708\tval_avpr: 0.9938\n", + "## Epoch 7\ttrain_loss: 0.0026\tval_loss: 0.0037\tval_auroc: 0.9562\tval_avpr: 0.9899\n", + "## Epoch 8\ttrain_loss: 0.0022\tval_loss: 0.0034\tval_auroc: 0.9604\tval_avpr: 0.9909\n", + "## Epoch 9\ttrain_loss: 0.0015\tval_loss: 0.0037\tval_auroc: 0.9542\tval_avpr: 0.9887\n", + "## Epoch 10\ttrain_loss: 0.0011\tval_loss: 0.0029\tval_auroc: 0.9771\tval_avpr: 0.9951\n", + "## Epoch 11\ttrain_loss: 0.0010\tval_loss: 0.0027\tval_auroc: 0.9833\tval_avpr: 0.9965\n", + "## Epoch 12\ttrain_loss: 0.0007\tval_loss: 0.0026\tval_auroc: 0.9833\tval_avpr: 0.9966\n", + "## Epoch 13\ttrain_loss: 0.0006\tval_loss: 0.0030\tval_auroc: 0.9792\tval_avpr: 0.9955\n", + "## Epoch 14\ttrain_loss: 0.0008\tval_loss: 0.0031\tval_auroc: 0.9771\tval_avpr: 0.9951\n", + "## Epoch 15\ttrain_loss: 0.0005\tval_loss: 0.0027\tval_auroc: 0.9771\tval_avpr: 0.9951\n", + "## Epoch 16\ttrain_loss: 0.0006\tval_loss: 0.0026\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "## Epoch 17\ttrain_loss: 0.0006\tval_loss: 0.0028\tval_auroc: 0.9792\tval_avpr: 0.9955\n", + "## Epoch 18\ttrain_loss: 0.0005\tval_loss: 0.0026\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "## Epoch 19\ttrain_loss: 0.0005\tval_loss: 0.0025\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "## Epoch 20\ttrain_loss: 0.0005\tval_loss: 0.0026\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "## Epoch 21\ttrain_loss: 0.0004\tval_loss: 0.0027\tval_auroc: 0.9792\tval_avpr: 0.9955\n", + "## Epoch 22\ttrain_loss: 0.0004\tval_loss: 0.0027\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "## Epoch 23\ttrain_loss: 0.0004\tval_loss: 0.0028\tval_auroc: 0.9750\tval_avpr: 0.9946\n", + "## Epoch 24\ttrain_loss: 0.0004\tval_loss: 0.0027\tval_auroc: 0.9792\tval_avpr: 0.9955\n", + "## Epoch 25\ttrain_loss: 0.0004\tval_loss: 0.0026\tval_auroc: 0.9813\tval_avpr: 0.9960\n", + "test_loss: 0.0015\n", + "test_auroc: 0.9951\n", + "test_avpr: 0.9986\n" + ] + } + ], + "source": [ + "model, optimiser, lr_scheduler = model_factory()\n", "\n", - "class AdmetDataset(Dataset):\n", - " def __init__(self, samples):\n", - " self.samples = samples['Embedding'].tolist()\n", - " self.targets = [float(target) for target in samples['Y'].tolist()]\n", + "val_loss, val_auroc, val_avpr = evaluate(model, val_loader, loss_fn)\n", + "print(\n", + " f\"## Epoch 0\\t\"\n", + " f\"train_loss: ------\\t\"\n", + " f\"val_loss: {val_loss:.4f}\\t\"\n", + " f\"val_auroc: {val_auroc:.4f}\\t\"\n", + " f\"val_avpr: {val_avpr:.4f}\"\n", + ")\n", + "\n", + "for epoch in range(epochs):\n", + " model = train_one_epoch(model, train_loader, val_loader, optimiser, lr_scheduler, loss_fn, epoch)\n", + "\n", + "test_loss, test_auroc, test_avpr = evaluate(model, test_loader, loss_fn)\n", + "print(\n", + " f\"test_loss: {test_loss:.4f}\\n\"\n", + " f\"test_auroc: {test_auroc:.4f}\\n\"\n", + " f\"test_avpr: {test_avpr:.4f}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running on a server-grade machine with 128 CPUs, the training took just 1.6s, reaching AUROC on the test set of 0.9951. As for the summer 2024, this is better than SoTA of 0.989. Pretty good!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Improvements\n", "\n", - " def __len__(self):\n", - " return len(self.samples)\n", + "The result can be further improved. One problem is that the accuracy is quite sensitive to both the train-val splitting (reminder - we use scaffold splitting strategy) and the weight initialisation. Let's visualise the distribution of validation scores by training a few models:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def dataloader_factory(seed):\n", + " mols_train, mols_val = admet.get_train_valid_split(benchmark=DATASET_NAME, split_type='scaffold', seed=seed)\n", "\n", - " def __getitem__(self, idx):\n", - " sample = torch.tensor(self.samples[idx])\n", - " target = torch.tensor(self.targets[idx])\n", - " return sample, target\n", + " mols_val['Embedding'] = featuriser(list(mols_val['Drug']))\n", + " mols_train['Embedding'] = featuriser(list(mols_train['Drug']))\n", "\n", + " val_loader = DataLoader(AdmetDataset(mols_val), batch_size=128, shuffle=False)\n", + " train_loader = DataLoader(AdmetDataset(mols_train), batch_size=32, shuffle=True)\n", "\n", - "class Task:\n", - " def __init__(self, dataset_name, featuriser):\n", - " benchmark = group.get(dataset_name)\n", - " with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull): # suppress output\n", - " mols_test = benchmark['test']\n", - " mols_train, mols_valid = group.get_train_valid_split(benchmark=dataset_name, seed=42)\n", - " mols_test['Embedding'] = featuriser(list(mols_test['Drug']))\n", - " mols_train['Embedding'] = featuriser(list(mols_train['Drug']))\n", - " mols_valid['Embedding'] = featuriser(list(mols_valid['Drug']))\n", - " self.name = dataset_name\n", - " self.test_loader = DataLoader(AdmetDataset(mols_test), batch_size=128, shuffle=False)\n", - " self.val_loader = DataLoader(AdmetDataset(mols_valid), batch_size=128, shuffle=False)\n", - " self.train_loader = DataLoader(AdmetDataset(mols_train), batch_size=32, shuffle=True)\n", - " self.task = 'classification' if len(benchmark['test']['Y'].unique()) == 2 else 'regression'\n", - " self.loss_fn = nn.BCELoss() if self.task == 'classification' else nn.MSELoss() \n", - "\n", - " def get_loss(self, logits, targets):\n", - " if self.task == 'classification':\n", - " return self.loss_fn(torch.sigmoid(logits), targets)\n", - " else:\n", - " return self.loss_fn(logits, targets)" + " return val_loader, train_loader" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 31, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Found local copy...\n" - ] - }, + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/jUlEQVR4nO3dd3gU5f7//9eSkA0t1IQQSkJJgBCkCnpA6b0LGhCkq0dBQEAUvA6CStMDggUQD4QuvfgBBEM/Khw6KkivSglSEmogyf39g1/255IEkiXJDvB8XNdeMLP3zLzn3vbKzD27NmOMEQAAgAVlcXcBAAAAKSGoAAAAyyKoAAAAyyKoAAAAyyKoAAAAyyKoAAAAyyKoAAAAyyKoAAAAyyKoAAAAyyKoPMKGDRsmm82WKduqXbu2ateu7ZjeuHGjbDabFi1alCnb79q1q4KCgjJlW666du2aevbsKX9/f9lsNvXr18/dJSENgoKC1LVrV3eXYUn39k3i63/jxo0PXPbe9470kJnvfRnp3r45ceKEbDabpk+f7raarIigYhHTp0+XzWZz3Ly9vRUQEKBGjRrp888/19WrV9NlO2fOnNGwYcO0Z8+edFlferJybakxcuRITZ8+XW+88YZmzZqlV1555YHLxMfHKyAgQDabTd9//32ybbp27aqcOXOmuI6cOXMm+yGSePPw8JCfn5/atWun33//PcX1rFixQo0bN1b+/Pnl7e2tkJAQDRw4UBcvXkxxmY0bN+qFF16Qv7+/vLy85OfnpxYtWmjJkiUP3Her279/v4YNG6YTJ064u5Qn0o0bNzRs2LBUhaHH2apVqzRs2DB3l+FeBpYQERFhJJkPP/zQzJo1y0ybNs2MHDnSNGzY0NhsNhMYGGj27t3rtMydO3fMzZs307Sd7du3G0kmIiIiTcvFxsaa2NhYx/SGDRuMJLNw4cI0rcfV2m7fvm1u3bqVbtvKCNWrVzc1atRI0zI//PCDkWSCgoJMx44dk23TpUsXkyNHjhTXkSNHDtOlSxfHdOJj06dPH8dzqV+/fsbb29vkz5/fnD17Nsk6BgwYYCSZChUqmDFjxphvvvnGvPHGG8Zut5vChQubAwcOJFlm6NChRpIJDg42Q4cONVOnTjWffPKJqV27tpFk5syZk6a+cLfAwECnfly4cKGRZDZs2OC2mqzi3r6Jj483N2/eNPHx8Q9ctlatWqZWrVpp3uaFCxeMJPPBBx8kuc+V9z4rurdvEhISzM2bN01cXJxjXq9evcyT/lHt6Z54hJQ0adJEVatWdUwPHjxY69evV/PmzdWyZUv9/vvvypYtmyTJ09NTnp4Z+xDeuHFD2bNnl5eXV4Zu50GyZs3q1u2nRlRUlEJDQ9O0zOzZs1W5cmV16dJFQ4YM0fXr15UjR450qee5555Tu3btHNOlS5fWG2+8oZkzZ2rQoEGO+d9++63Gjh2r8PBwzZkzRx4eHo77unbtqjp16ujFF1/Url27HM+3RYsW6cMPP1S7du00d+5cp8fnnXfe0Zo1a3Tnzp001ZuQkKDbt2/L29vb1V1GJsmSJYtbH6fMeO9zh8Sj6XDGqZ9HQN26dfWvf/1LJ0+e1OzZsx3zkztPGxkZqZo1aypPnjzKmTOnSpcurSFDhki6e5j+6aefliR169bNcWog8Xxo7dq1FRYWpp07d+r5559X9uzZHcumdJ45Pj5eQ4YMkb+/v3LkyKGWLVvq9OnTTm1SOvf/93U+qLbkxqhcv35dAwYMUNGiRWW321W6dGn9+9//lrnnB8FtNpt69+6tZcuWKSwsTHa7XeXKldPq1auT7/B7REVFqUePHipYsKC8vb1VoUIFzZgxw3F/4qmW48ePa+XKlY7aH3TK4ObNm1q6dKnat2+vl156STdv3tTy5ctTVZMrnnvuOUnS0aNHneYPHz5cefPm1ZQpU5xCiiRVq1ZN7777rn799Ven8Uj/+te/lC9fPk2bNi3ZENmoUSM1b978vvUkPi5z5sxRuXLlZLfbHY/Jn3/+qe7du6tgwYKOx2vatGlJ1vHFF1+oXLlyyp49u/LmzauqVatq7ty5jvtTGtv0oDEO06dP14svvihJqlOnjuMxTTwNsWPHDjVq1EgFChRQtmzZVLx4cXXv3v2++5to4sSJjv0NCAhQr169dOXKFac2ia/F/fv3q06dOsqePbsKFy6sTz755IHrDwsLU506dZLMT0hIUOHChZ3C67///W/94x//UP78+ZUtWzZVqVIlVePOUhqjMmXKFJUsWVLZsmVTtWrV9N///jfJsrdv39bQoUNVpUoV5c6dWzly5NBzzz2nDRs2ONqcOHFCvr6+ku4+PxP7P/EUSHKPX1xcnD766COVLFlSdrtdQUFBGjJkiGJjY53aBQUFqXnz5vrxxx9VrVo1eXt7q0SJEpo5c+YD91uS5s2bpypVqihXrlzy8fFR+fLlNWHCBMf9iafxN2/erNdff1358+eXj4+POnfurMuXL9933feOUenatau++uorSXI6nfukIag8IhLHO/zwww8pttm3b5+aN2+u2NhYffjhhxo7dqxatmypn376SZJUtmxZffjhh5Kk1157TbNmzdKsWbP0/PPPO9Zx8eJFNWnSRBUrVtT48eOTfcP7uxEjRmjlypV699131adPH0VGRqp+/fq6efNmmvYvNbX9nTFGLVu21GeffabGjRtr3LhxKl26tN555x31798/Sfsff/xRb775ptq3b69PPvlEt27dUtu2be87/kK6GyZq166tWbNmqWPHjvr000+VO3dude3a1fHmVLZsWc2aNUsFChRQxYoVHbUnvtGm5LvvvtO1a9fUvn17+fv7q3bt2pozZ05qusslicEpb968jnmHDx/WwYMH1apVK/n4+CS7XOfOnSXdHcOSuMyBAwfUunVr5cqV66FqWr9+vd5++22Fh4drwoQJCgoK0vnz5/XMM89o7dq16t27tyZMmKBSpUqpR48eGj9+vGPZb775Rn369FFoaKjGjx+v4cOHq2LFivrf//73UDVJ0vPPP68+ffpIkoYMGeJ4TMuWLauoqCg1bNhQJ06c0HvvvacvvvhCHTt21NatWx+43mHDhqlXr14KCAjQ2LFj1bZtW3399ddq2LBhkiNQly9fVuPGjVWhQgWNHTtWZcqU0bvvvpviWKZE4eHh2rx5s86dO+c0/8cff9SZM2fUvn17x7wJEyaoUqVK+vDDDzVy5Eh5enrqxRdf1MqVK1PbVQ5Tp07V66+/Ln9/f33yySeqUaNGsn+4xMTE6D//+Y9q166tMWPGaNiwYbpw4YIaNWrkGJ/m6+urSZMmSZLatGnj6P8XXnghxe337NlTQ4cOVeXKlfXZZ5+pVq1aGjVqlNP+Jjpy5IjatWunBg0aaOzYscqbN6+6du2qffv23XcfIyMj1aFDB+XNm1djxozR6NGjVbt2bcd77N/17t1bv//+u4YNG6bOnTtrzpw5at26dZI/pO7n9ddfV4MGDSTJ0QezZs1K9fKPDTefesL/J3GMyvbt21Nskzt3blOpUiXH9AcffOB07vKzzz4zksyFCxdSXMf9xoHUqlXLSDKTJ09O9r6/n0tNHAdRuHBhExMT45i/YMECI8lMmDDBMe/e89sprfN+tXXp0sUEBgY6ppctW2YkmY8//tipXbt27YzNZjNHjhxxzJNkvLy8nObt3bvXSDJffPFFkm393fjx440kM3v2bMe827dvm2effdbkzJnTad8DAwNNs2bN7ru+v2vevLnTmJYpU6YYT09PExUV5dTO1TEq06ZNMxcuXDBnzpwxq1evNqVKlTI2m81s27bN0TaxHz/77LP71urj42MqV65sjDFm+fLlqVrmQSSZLFmymH379jnN79GjhylUqJD566+/nOa3b9/e5M6d29y4ccMYY0yrVq1MuXLl7ruNe583ie597RiT+jEqS5cufeBrNTlRUVHGy8vLNGzY0Glsx5dfful4vBIlvhZnzpzpmBcbG2v8/f1N27Zt77udgwcPJvvcfvPNN03OnDkd/WeMcfq/MXef22FhYaZu3bpO8+/tm8TnWGLf3L592/j5+ZmKFSs6jWWbMmWKkeT0Oo+Li3NqY4wxly9fNgULFjTdu3d3zLvfGJV7H789e/YYSaZnz55O7QYOHGgkmfXr1zvtiySzefNmx7yoqChjt9vNgAEDkmzr7/r27Wt8fHycxpDcK/G9vEqVKub27duO+Z988omRZJYvX+6Yd+974PHjx5O8BzJGxRiOqDxCcubMed+rf/LkySNJWr58uRISElzaht1uV7du3VLdvnPnzk5/Vbdr106FChXSqlWrXNp+aq1atUoeHh6Ov3oTDRgwQMaYJH911q9fXyVLlnRMP/XUU/Lx8dGxY8ceuB1/f3916NDBMS9r1qzq06ePrl27pk2bNrlU/8WLF7VmzRqn9bZt21Y2m00LFixwaZ336t69u3x9fRUQEKDGjRsrOjpas2bNcpxik+R4Pj3oyEiuXLkUExMjSY5/H/ZoiiTVqlXLaVyPMUaLFy9WixYtZIzRX3/95bg1atRI0dHR2rVrl6S7z/c//vhD27dvf+g60iLxdbZixYo0jcNZu3atbt++rX79+ilLlv//rffVV1+Vj49PkqMYOXPmVKdOnRzTXl5eqlat2gOfsyEhIapYsaLmz5/vmBcfH69FixapRYsWjjFukpz+f/nyZUVHR+u5555z9HFq7dixQ1FRUfrnP//pNJ6ta9euyp07t1NbDw8PR5uEhARdunRJcXFxqlq1apq3myjx/ebeo6kDBgyQpCR9Gxoa6jgVKt09glO6dOkH9m2ePHl0/fp1RUZGPrCm1157zem06BtvvCFPT88Mf298HBFUHiHXrl2774dDeHi4atSooZ49e6pgwYJq3769FixYkKbQUrhw4TQNnA0ODnaattlsKlWqVIZf0nny5EkFBAQk6Y+yZcs67v+7YsWKJVlH3rx5H3jO+OTJkwoODnb6YLnfdlJr/vz5unPnjipVqqQjR47oyJEjunTpkqpXr+7S6Z/kzlsPHTpUkZGRWrp0qTp37qzo6Ogk+5HYfw+6/P3q1auOtomniNLjkvnixYs7TV+4cEFXrlzRlClT5Ovr63RLDNBRUVGSpHfffVc5c+ZUtWrVFBwcrF69eiV7CD691apVS23bttXw4cNVoEABtWrVShEREUnGQtwr8blSunRpp/leXl4qUaJEkudSkSJFkjyuqXnOSnffC3766Sf9+eefku6OKYmKilJ4eLhTuxUrVuiZZ56Rt7e38uXL5zjlEh0d/cBtJLdv974fZM2aVSVKlEjSfsaMGXrqqafk7e2t/Pnzy9fXVytXrkzzdv++/SxZsqhUqVJO8/39/ZUnT550ez948803FRISoiZNmqhIkSLq3r17imPd7u2LnDlzqlChQlzu7gKCyiPijz/+UHR0dJIX4t9ly5ZNmzdv1tq1a/XKK6/ol19+UXh4uBo0aKD4+PhUbefvf2Gll5QGf6W2pvRw7yDRRCYN54vTU2IYqVGjhoKDgx23H3/8UVu2bHH6y87b21uxsbHJ1mqM0a1bt5K9UqB8+fKqX7++WrdurRkzZqhly5Z69dVXncYMJAauX375JcVaT548qZiYGMeRjzJlykiSfv31Vxf23Nm9z7fEUN2pUydFRkYme6tRo4aj9oMHD2revHmqWbOmFi9erJo1a+qDDz5wrC8jnnuJX3S4ZcsW9e7d2zHwt0qVKrp27ZrL673Xwzxnw8PDZYzRwoULJUkLFixQ7ty51bhxY0eb//73v2rZsqW8vb01ceJErVq1SpGRkXr55Zcz9HUxe/Zsde3aVSVLltTUqVO1evVqRUZGqm7dui4fCU6U2oGmrvatn5+f9uzZo++++04tW7bUhg0b1KRJE3Xp0iXNtSL1CCqPiMQBVI0aNbpvuyxZsqhevXoaN26c9u/frxEjRmj9+vWOEfXpPWL88OHDTtPGGB05csTpSou8efMmuapBSno0Ii21BQYG6syZM0n+qj9w4IDj/vQQGBiow4cPJ3kDfZjtHD9+XD///LN69+6thQsXOt3mz58vLy8vpytXAgMDFRcXl+RqHenuoMD4+PhU1TF69GjdunVLI0aMcMwLCQlRSEiIli1bluIRksSrIRKv4gkJCVHp0qW1fPnydP1glu4egs+VK5fi4+NVv379ZG9+fn6O9jly5FB4eLgiIiJ06tQpNWvWTCNGjNCtW7ckpf65l5wHPR+feeYZjRgxQjt27NCcOXO0b98+zZs3L8X2iY/RwYMHnebfvn1bx48fT7fnrHT3SFW1atU0f/58xcXFacmSJWrdurXsdrujzeLFi+Xt7a01a9aoe/fuatKkierXr+/S9hJrv/f94M6dOzp+/LjTvEWLFqlEiRJasmSJXnnlFTVq1Ej169d3PGaJ0vp+kJCQkGT758+f15UrV9K1b728vNSiRQtNnDhRR48e1euvv66ZM2fqyJEjTu3ureXatWs6e/Zsmr9h+0m8yudeBJVHwPr16/XRRx+pePHi6tixY4rtLl26lGRexYoVJclxWDrxOzqSe/N2xcyZM50+4BYtWqSzZ8+qSZMmjnklS5bU1q1bdfv2bce8FStWJLkaIC21NW3aVPHx8fryyy+d5n/22Wey2WxO238YTZs21blz55zO98fFxemLL75Qzpw5VatWrTSvM/FoyqBBg9SuXTun20svvaRatWo5nf5J3Jd791WS49LF1OxvyZIl1bZtW02fPt3pipChQ4fq8uXL+uc//5nkSMPOnTs1ZswYhYWFqW3bto75w4cP18WLF9WzZ0/FxcUl2dYPP/zguEooLTw8PNS2bVstXrxYv/32W5L7L1y44Pj/vVdseXl5KTQ0VMYYx9iRkiVLKjo62umI0dmzZ7V06dIH1pLS8/Hy5ctJ/vK+93WWnPr168vLy0uff/650/JTp05VdHS0mjVr9sCa0iI8PFxbt27VtGnT9NdffyU57ePh4SGbzeb0mJ84cULLli1L87aqVq0qX19fTZ482el1Pn369CT9l3g04+998L///U9btmxxapc9e3ZJqX8/kOR0VZgkjRs3TpLSrW/vfc5lyZJFTz31lKSkj/2UKVOcxjBNmjRJcXFxaX5vSu/37EfR4/eNOY+477//XgcOHFBcXJzOnz+v9evXKzIyUoGBgfruu+/u+2VAH374oTZv3qxmzZopMDBQUVFRmjhxoooUKaKaNWtKuvvGnSdPHk2ePFm5cuVSjhw5VL169SRjBVIrX758qlmzprp166bz589r/PjxKlWqlF599VVHm549e2rRokVq3LixXnrpJR09elSzZ892Gtya1tpatGihOnXq6P3339eJEydUoUIF/fDDD1q+fLn69euXZN2ueu211/T111+ra9eu2rlzp4KCgrRo0SL99NNPGj9+vEsDSufMmaOKFSuqaNGiyd7fsmVLvfXWW9q1a5cqV66sihUrqmfPnpowYYIOHz7suFwxMjJSq1atUs+ePVWhQoVUbfudd97RggULNH78eI0ePVqS1LFjR23fvl0TJkzQ/v371bFjR+XNm1e7du3StGnTlD9/fi1atMhpYGB4eLh+/fVXjRgxQrt371aHDh0UGBioixcvavXq1Vq3bp3TUaG0GD16tDZs2KDq1avr1VdfVWhoqC5duqRdu3Zp7dq1jkDesGFD+fv7q0aNGipYsKB+//13ffnll2rWrJnjcWnfvr3effddtWnTRn369NGNGzc0adIkhYSEPHDgZsWKFeXh4aExY8YoOjpadrtddevW1dy5czVx4kS1adNGJUuW1NWrV/XNN9/Ix8fH8YGZHF9fXw0ePFjDhw9X48aN1bJlSx08eFATJ07U008/7TRwNj289NJLGjhwoAYOHKh8+fIlOVrSrFkzjRs3To0bN9bLL7+sqKgoffXVVypVqtR9TwUmJ2vWrPr444/1+uuvq27dugoPD9fx48cVERGRZIxK8+bNtWTJErVp00bNmjXT8ePHNXnyZIWGhjodocuWLZtCQ0M1f/58hYSEKF++fAoLC1NYWFiS7VeoUEFdunTRlClTdOXKFdWqVUvbtm3TjBkz1Lp16wd+zUJq9ezZU5cuXVLdunVVpEgRnTx5Ul988YUqVqzoOI2a6Pbt26pXr55eeuklx+Ncs2ZNtWzZMk3brFKliiSpT58+atSokTw8PJK95Pqx5oYrjZCMxEvaEm9eXl7G39/fNGjQwEyYMMHpMthE916it27dOtOqVSsTEBBgvLy8TEBAgOnQoYM5dOiQ03LLly83oaGhxtPT0+lSuFq1aqV4uWdKlyd/++23ZvDgwcbPz89ky5bNNGvWzJw8eTLJ8mPHjjWFCxc2drvd1KhRw+zYsSPZr9ZOqbbkLjO9evWqefvtt01AQIDJmjWrCQ4ONp9++qlJSEhwaifJ9OrVK0lNKV02fa/z58+bbt26mQIFChgvLy9Tvnz5ZC+hTs3lyTt37jSSzL/+9a8U25w4ccJIMm+//bZjXnx8vJkwYYKpUKGC8fb2Nt7e3qZChQrm888/T/I15g/6eYPatWsbHx8fc+XKFaf5y5YtMw0aNDB58+Y1drvdlCpVygwYMOC+l7snPuf8/PyMp6en8fX1NS1atHC6BDMlKT0uxtzt8169epmiRYuarFmzGn9/f1OvXj0zZcoUR5uvv/7aPP/88yZ//vzGbrebkiVLmnfeecdER0c7reuHH34wYWFhxsvLy5QuXdrMnj07VZcnG2PMN998Y0qUKGE8PDwcl+Pu2rXLdOjQwRQrVszY7Xbj5+dnmjdvbnbs2PHAfTbm7uXIZcqUMVmzZjUFCxY0b7zxhrl8+bJTm5Reiyldbp2SGjVqJHvZbqKpU6ea4OBgY7fbTZkyZUxERESq+ubey5MTTZw40RQvXtzY7XZTtWpVs3nz5mS/Jn7kyJEmMDDQ2O12U6lSJbNixYpk9+3nn382VapUMV5eXk6XKidX4507d8zw4cNN8eLFTdasWU3RokXN4MGDk/z0Rkqv09R81f+iRYtMw4YNjZ+fn/Hy8jLFihUzr7/+utPPUiS+l2/atMm89tprJm/evCZnzpymY8eO5uLFi/fdZnKXJ8fFxZm33nrL+Pr6GpvN9kReqmwzxk2jCQEAeMxMnz5d3bp10/bt251+DgWuY4wKAACwLIIKAACwLIIKAACwLMaoAAAAy+KICgAAsCyCCgAAsKxH+gvfEhISdObMGeXKlYuvGQYA4BFhjNHVq1cVEBCQ5MdS7/VIB5UzZ86k+O2eAADA2k6fPq0iRYrct80jHVQSvyb79OnTjp+eBwAA1hYTE6OiRYum6mdIHumgkni6x8fHh6ACAMAjJjXDNhhMCwAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALMutQSUoKEg2my3JrVevXu4sCwAAWIRbf+tn+/btio+Pd0z/9ttvatCggV588UU3VgUAAKzCrUHF19fXaXr06NEqWbKkatWq5aaKAACAlVhmjMrt27c1e/Zsde/ePVW/pggAAB5/bj2i8nfLli3TlStX1LVr1xTbxMbGKjY21jEdExOTCZUBAAB3sUxQmTp1qpo0aaKAgIAU24waNUrDhw/PxKoAALCuoPdWZvg2ToxuluHbuB9LnPo5efKk1q5dq549e9633eDBgxUdHe24nT59OpMqBAAA7mCJIyoRERHy8/NTs2b3T212u112uz2TqgIAAO7m9iMqCQkJioiIUJcuXeTpaYncBAAALMLtQWXt2rU6deqUunfv7u5SAACAxbj9EEbDhg1ljHF3GQAAwILcfkQFAAAgJQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWQQVAABgWW4PKn/++ac6deqk/PnzK1u2bCpfvrx27Njh7rIAAIAFeLpz45cvX1aNGjVUp04dff/99/L19dXhw4eVN29ed5YFAAAswq1BZcyYMSpatKgiIiIc84oXL+7GigAAgJW49dTPd999p6pVq+rFF1+Un5+fKlWqpG+++SbF9rGxsYqJiXG6AQCAx5dbj6gcO3ZMkyZNUv/+/TVkyBBt375dffr0kZeXl7p06ZKk/ahRozR8+HA3VAoAeFwEvbfS3SUgDWzGGOOujXt5ealq1ar6+eefHfP69Omj7du3a8uWLUnax8bGKjY21jEdExOjokWLKjo6Wj4+PplSMwDg0UZQSZsTo5ul+zpjYmKUO3fuVH1+u/XUT6FChRQaGuo0r2zZsjp16lSy7e12u3x8fJxuAADg8eXWoFKjRg0dPHjQad6hQ4cUGBjopooAAICVuDWovP3229q6datGjhypI0eOaO7cuZoyZYp69erlzrIAAIBFuDWoPP3001q6dKm+/fZbhYWF6aOPPtL48ePVsWNHd5YFAAAswq1X/UhS8+bN1bx5c3eXAQAALMjtX6EPAACQEoIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLIIKAACwLLcGlWHDhslmszndypQp486SAACAhXi6u4By5cpp7dq1jmlPT7eXBAAALMLtqcDT01P+/v7uLgMAAFiQ28eoHD58WAEBASpRooQ6duyoU6dOpdg2NjZWMTExTjcAAPD4cmtQqV69uqZPn67Vq1dr0qRJOn78uJ577jldvXo12fajRo1S7ty5HbeiRYtmcsUAACAz2Ywxxt1FJLpy5YoCAwM1btw49ejRI8n9sbGxio2NdUzHxMSoaNGiio6Olo+PT2aWCgB4RAW9t9LdJTxSToxulu7rjImJUe7cuVP1+e32MSp/lydPHoWEhOjIkSPJ3m+322W32zO5KgAA4C5uH6Pyd9euXdPRo0dVqFAhd5cCAAAswK1BZeDAgdq0aZNOnDihn3/+WW3atJGHh4c6dOjgzrIAAIBFuPXUzx9//KEOHTro4sWL8vX1Vc2aNbV161b5+vq6sywAAGARbg0q8+bNc+fmAQCAxVlqjAoAAMDfEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBluRRUjh07lt51AAAAJOFSUClVqpTq1Kmj2bNn69atW+ldEwAAgCQXg8quXbv01FNPqX///vL399frr7+ubdu2pXdtAADgCedSUKlYsaImTJigM2fOaNq0aTp79qxq1qypsLAwjRs3ThcuXEjvOgEAwBPooQbTenp66oUXXtDChQs1ZswYHTlyRAMHDlTRokXVuXNnnT17Nr3qBAAAT6CHCio7duzQm2++qUKFCmncuHEaOHCgjh49qsjISJ05c0atWrVKrzoBAMATyNOVhcaNG6eIiAgdPHhQTZs21cyZM9W0aVNlyXI39xQvXlzTp09XUFBQetYKAACeMC4FlUmTJql79+7q2rWrChUqlGwbPz8/TZ069aGKAwAATzaXgsrhw4cf2MbLy0tdunRxZfUAAACSXByjEhERoYULFyaZv3DhQs2YMeOhiwIAAJBcDCqjRo1SgQIFksz38/PTyJEjH7ooAAAAycWgcurUKRUvXjzJ/MDAQJ06deqhiwIAAJBcDCp+fn765Zdfkszfu3ev8ufP71Iho0ePls1mU79+/VxaHgAAPH5cCiodOnRQnz59tGHDBsXHxys+Pl7r169X37591b59+zSvb/v27fr666/11FNPuVIOAAB4TLkUVD766CNVr15d9erVU7Zs2ZQtWzY1bNhQdevWTfMYlWvXrqljx4765ptvlDdvXlfKAQAAjymXgoqXl5fmz5+vAwcOaM6cOVqyZImOHj2qadOmycvLK03r6tWrl5o1a6b69eu7UgoAAHiMufQ9KolCQkIUEhLi8vLz5s3Trl27tH379lS1j42NVWxsrGM6JibG5W0DAADrcymoxMfHa/r06Vq3bp2ioqKUkJDgdP/69esfuI7Tp0+rb9++ioyMlLe3d6q2O2rUKA0fPtyVkl0S9N7KDN/GidHNMnwbAB5/vF/hceVSUOnbt6+mT5+uZs2aKSwsTDabLc3r2Llzp6KiolS5cmXHvPj4eG3evFlffvmlYmNj5eHh4bTM4MGD1b9/f8d0TEyMihYt6souAACAR4BLQWXevHlasGCBmjZt6vKG69Wrp19//dVpXrdu3VSmTBm9++67SUKKJNntdtntdpe3CQAAHi0uBRUvLy+VKlXqoTacK1cuhYWFOc3LkSOH8ufPn2Q+AAB4Mrl01c+AAQM0YcIEGWPSux4AAAAHl46o/Pjjj9qwYYO+//57lStXTlmzZnW6f8mSJS4Vs3HjRpeWAwAAjyeXgkqePHnUpk2b9K4FAADAiUtBJSIiIr3rAAAASMKlMSqSFBcXp7Vr1+rrr7/W1atXJUlnzpzRtWvX0q04AADwZHPpiMrJkyfVuHFjnTp1SrGxsWrQoIFy5cqlMWPGKDY2VpMnT07vOgEAwBPIpSMqffv2VdWqVXX58mVly5bNMb9NmzZat25duhUHAACebC4dUfnvf/+rn3/+OckPEAYFBenPP/9Ml8IAAABcOqKSkJCg+Pj4JPP/+OMP5cqV66GLAgAAkFwMKg0bNtT48eMd0zabTdeuXdMHH3zwUF+rDwAA8HcunfoZO3asGjVqpNDQUN26dUsvv/yyDh8+rAIFCujbb79N7xoBAMATyqWgUqRIEe3du1fz5s3TL7/8omvXrqlHjx7q2LGj0+BaAACAh+FSUJEkT09PderUKT1rAQAAcOJSUJk5c+Z97+/cubNLxQAAAPydS0Glb9++TtN37tzRjRs35OXlpezZsxNUAABAunDpqp/Lly873a5du6aDBw+qZs2aDKYFAADpxuXf+rlXcHCwRo8eneRoCwAAgKvSLahIdwfYnjlzJj1XCQAAnmAujVH57rvvnKaNMTp79qy+/PJL1ahRI10KAwAAcCmotG7d2mnaZrPJ19dXdevW1dixY9OjLgAAANeCSkJCQnrXAQAAkES6jlEBAABITy4dUenfv3+q244bN86VTQAAALgWVHbv3q3du3frzp07Kl26tCTp0KFD8vDwUOXKlR3tbDZb+lQJAACeSC4FlRYtWihXrlyaMWOG8ubNK+nul8B169ZNzz33nAYMGJCuRQIAgCeTS2NUxo4dq1GjRjlCiiTlzZtXH3/8MVf9AACAdONSUImJidGFCxeSzL9w4YKuXr360EUBAABILgaVNm3aqFu3blqyZIn++OMP/fHHH1q8eLF69OihF154Ib1rBAAATyiXxqhMnjxZAwcO1Msvv6w7d+7cXZGnp3r06KFPP/00XQsEAABPLpeCSvbs2TVx4kR9+umnOnr0qCSpZMmSypEjR7oWBwAAnmwP9YVvZ8+e1dmzZxUcHKwcOXLIGJNedQEAALgWVC5evKh69eopJCRETZs21dmzZyVJPXr04NJkAACQblwKKm+//bayZs2qU6dOKXv27I754eHhWr16dboVBwAAnmwujVH54YcftGbNGhUpUsRpfnBwsE6ePJkuhQEAALh0ROX69etOR1ISXbp0SXa7/aGLAgAAkFwMKs8995xmzpzpmLbZbEpISNAnn3yiOnXqpFtxAADgyebSqZ9PPvlE9erV044dO3T79m0NGjRI+/bt06VLl/TTTz+ld40AAOAJ5dIRlbCwMB06dEg1a9ZUq1atdP36db3wwgvavXu3SpYsmd41AgCAJ1Saj6jcuXNHjRs31uTJk/X+++9nRE0AAACSXDiikjVrVv3yyy8ZUQsAAIATl079dOrUSVOnTk3vWgAAAJy4NJg2Li5O06ZN09q1a1WlSpUkv/Ezbty4dCkOAAA82dIUVI4dO6agoCD99ttvqly5siTp0KFDTm1sNluq1zdp0iRNmjRJJ06ckCSVK1dOQ4cOVZMmTdJSFgAAeEylKagEBwfr7Nmz2rBhg6S7X5n/+eefq2DBgi5tvEiRIho9erSCg4NljNGMGTPUqlUr7d69W+XKlXNpnQAA4PGRpqBy768jf//997p+/brLG2/RooXT9IgRIzRp0iRt3bqVoAIAAFwbo5Lo3uDyMOLj47Vw4UJdv35dzz77bLJtYmNjFRsb65iOiYlJt+0DAADrSVNQsdlsScagpGVMSnJ+/fVXPfvss7p165Zy5syppUuXKjQ0NNm2o0aN0vDhwx9qe3h0Bb230t0lpIsTo5u5uwTAsh6X1znST5pP/XTt2tXxw4O3bt3SP//5zyRX/SxZsiTV6yxdurT27Nmj6OhoLVq0SF26dNGmTZuSDSuDBw9W//79HdMxMTEqWrRoWnYBAAA8QtIUVLp06eI03alTp4cuwMvLS6VKlZIkValSRdu3b9eECRP09ddfJ2lrt9v5dWYAAJ4gaQoqERERGVWHQ0JCgtM4FAAA8OR6qMG0D2vw4MFq0qSJihUrpqtXr2ru3LnauHGj1qxZ486yAACARbg1qERFRalz5846e/ascufOraeeekpr1qxRgwYN3FkWAACwCLcGFX4vCAAA3I9LP0oIAACQGQgqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAsggqAADAstwaVEaNGqWnn35auXLlkp+fn1q3bq2DBw+6syQAAGAhbg0qmzZtUq9evbR161ZFRkbqzp07atiwoa5fv+7OsgAAgEV4unPjq1evdpqePn26/Pz8tHPnTj3//PNuqgoAAFiFW4PKvaKjoyVJ+fLlS/b+2NhYxcbGOqZjYmIypS4AAOAelgkqCQkJ6tevn2rUqKGwsLBk24waNUrDhw/P5MoefUHvrXR3CXgM8bxKvROjm7m7hHTBYw53sMxVP7169dJvv/2mefPmpdhm8ODBio6OdtxOnz6diRUCAIDMZokjKr1799aKFSu0efNmFSlSJMV2drtddrs9EysDAADu5NagYozRW2+9paVLl2rjxo0qXry4O8sBAAAW49ag0qtXL82dO1fLly9Xrly5dO7cOUlS7ty5lS1bNneWBgAALMCtY1QmTZqk6Oho1a5dW4UKFXLc5s+f786yAACARbj91A8AAEBKLHPVDwAAwL0IKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLIIKgAAwLLcGlQ2b96sFi1aKCAgQDabTcuWLXNnOQAAwGLcGlSuX7+uChUq6KuvvnJnGQAAwKI83bnxJk2aqEmTJu4sAQAAWJhbg0paxcbGKjY21jEdExPjxmoAAEBGe6SCyqhRozR8+HB3lwE8lKD3Vrq7BAB4ZDxSV/0MHjxY0dHRjtvp06fdXRIAAMhAj9QRFbvdLrvd7u4yAABAJnmkjqgAAIAni1uPqFy7dk1HjhxxTB8/flx79uxRvnz5VKxYMTdWBgAArMCtQWXHjh2qU6eOY7p///6SpC5dumj69OluqgoAAFiFW4NK7dq1ZYxxZwkAAMDCGKMCAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsyxJB5auvvlJQUJC8vb1VvXp1bdu2zd0lAQAAC3B7UJk/f7769++vDz74QLt27VKFChXUqFEjRUVFubs0AADgZm4PKuPGjdOrr76qbt26KTQ0VJMnT1b27Nk1bdo0d5cGAADczK1B5fbt29q5c6fq16/vmJclSxbVr19fW7ZscWNlAADACjzdufG//vpL8fHxKliwoNP8ggUL6sCBA0nax8bGKjY21jEdHR0tSYqJicmQ+hJib2TIev8uo2r/u8zYDwAp43WOR1lGPH8T12mMeWBbtwaVtBo1apSGDx+eZH7RokXdUE36yD3e3RUAyGi8zvEoy8jn79WrV5U7d+77tnFrUClQoIA8PDx0/vx5p/nnz5+Xv79/kvaDBw9W//79HdMJCQm6dOmS8ufPL5vNluH1WlFMTIyKFi2q06dPy8fHx93lPJLow/RBP6YP+jF90I/pI6P60Rijq1evKiAg4IFt3RpUvLy8VKVKFa1bt06tW7eWdDd8rFu3Tr17907S3m63y263O83LkydPJlRqfT4+PrwYHxJ9mD7ox/RBP6YP+jF9ZEQ/PuhISiK3n/rp37+/unTpoqpVq6patWoaP368rl+/rm7durm7NAAA4GZuDyrh4eG6cOGChg4dqnPnzqlixYpavXp1kgG2AADgyeP2oCJJvXv3TvZUDx7Mbrfrgw8+SHJKDKlHH6YP+jF90I/pg35MH1boR5tJzbVBAAAAbuD2b6YFAABICUEFAABYFkEFAABYFkEFAABYFkHFYr766isFBQXJ29tb1atX17Zt21Jse+fOHX344YcqWbKkvL29VaFCBa1evfqh1vm4SO9+HDVqlJ5++mnlypVLfn5+at26tQ4ePJjRu+F2GfF8TDR69GjZbDb169cvAyq3jozowz///FOdOnVS/vz5lS1bNpUvX147duzIyN1wu/Tux/j4eP3rX/9S8eLFlS1bNpUsWVIfffRRqn575lG1efNmtWjRQgEBAbLZbFq2bNkDl9m4caMqV64su92uUqVKafr06UnaZPhnjIFlzJs3z3h5eZlp06aZffv2mVdffdXkyZPHnD9/Ptn2gwYNMgEBAWblypXm6NGjZuLEicbb29vs2rXL5XU+DjKiHxs1amQiIiLMb7/9Zvbs2WOaNm1qihUrZq5du5ZZu5XpMqIfE23bts0EBQWZp556yvTt2zeD98R9MqIPL126ZAIDA03Xrl3N//73P3Ps2DGzZs0ac+TIkczarUyXEf04YsQIkz9/frNixQpz/Phxs3DhQpMzZ04zYcKEzNqtTLdq1Srz/vvvmyVLlhhJZunSpfdtf+zYMZM9e3bTv39/s3//fvPFF18YDw8Ps3r1akebzPiMIahYSLVq1UyvXr0c0/Hx8SYgIMCMGjUq2faFChUyX375pdO8F154wXTs2NHldT4OMqIf7xUVFWUkmU2bNqVP0RaUUf149epVExwcbCIjI02tWrUe66CSEX347rvvmpo1a2ZMwRaVEf3YrFkz07179/u2eZylJqgMGjTIlCtXzmleeHi4adSokWM6Mz5jOPVjEbdv39bOnTtVv359x7wsWbKofv362rJlS7LLxMbGytvb22letmzZ9OOPP7q8zkddRvRjcqKjoyVJ+fLlS4eqrScj+7FXr15q1qyZ07ofRxnVh999952qVq2qF198UX5+fqpUqZK++eabjNkJC8iofvzHP/6hdevW6dChQ5KkvXv36scff1STJk0yYC8eTVu2bEnyOm3UqJGj3zPrM4agYhF//fWX4uPjk/x0QMGCBXXu3Llkl2nUqJHGjRunw4cPKyEhQZGRkVqyZInOnj3r8jofdRnRj/dKSEhQv379VKNGDYWFhaX7PlhBRvXjvHnztGvXLo0aNSpD67eCjOrDY8eOadKkSQoODtaaNWv0xhtvqE+fPpoxY0aG7o+7ZFQ/vvfee2rfvr3KlCmjrFmzqlKlSurXr586duyYofvzKDl37lyy/R4TE6ObN29m2mcMQeURNmHCBAUHB6tMmTLy8vJS79691a1bN2XJwsOaFmntx169eum3337TvHnzMrlSa3tQP54+fVp9+/bVnDlzkvy1i7tS81xMSEhQ5cqVNXLkSFWqVEmvvfaaXn31VU2ePNmNlVtLavpxwYIFmjNnjubOnatdu3ZpxowZ+ve///3YBr5HGZ9oFlGgQAF5eHjo/PnzTvPPnz8vf3//ZJfx9fXVsmXLdP36dZ08eVIHDhxQzpw5VaJECZfX+ajLiH78u969e2vFihXasGGDihQpkiH7YAUZ0Y87d+5UVFSUKleuLE9PT3l6emrTpk36/PPP5enpqfj4+Azfr8yUUc/FQoUKKTQ01Gm5smXL6tSpU+m/ExaQUf34zjvvOI6qlC9fXq+88orefvvtJ+JoX2r5+/sn2+8+Pj7Kli1bpn3GEFQswsvLS1WqVNG6desc8xISErRu3To9++yz913W29tbhQsXVlxcnBYvXqxWrVo99DofVRnRj5JkjFHv3r21dOlSrV+/XsWLF8+wfbCCjOjHevXq6ddff9WePXsct6pVq6pjx47as2ePPDw8MnSfMltGPRdr1KiR5NL4Q4cOKTAwMH13wCIyqh9v3LiR5Kiph4eHEhIS0ncHHmHPPvusU79LUmRkpKPfM+0zJt2G5eKhzZs3z9jtdjN9+nSzf/9+89prr5k8efKYc+fOGWOMeeWVV8x7773naL9161azePFic/ToUbN582ZTt25dU7x4cXP58uVUr/NxlBH9+MYbb5jcuXObjRs3mrNnzzpuN27cyOzdyzQZ0Y/3etyv+smIPty2bZvx9PQ0I0aMMIcPHzZz5swx2bNnN7Nnz87s3cs0GdGPXbp0MYULF3ZcnrxkyRJToEABM2jQoMzevUxz9epVs3v3brN7924jyYwbN87s3r3bnDx50hhjzHvvvWdeeeUVR/vEy5Pfeecd8/vvv5uvvvoq2cuTM/ozhqBiMV988YUpVqyY8fLyMtWqVTNbt2513FerVi3TpUsXx/TGjRtN2bJljd1uN/nz5zevvPKK+fPPP9O0zsdVevejpGRvERERmbRH7pERz8e/e9yDijEZ04f/93//Z8LCwozdbjdlypQxU6ZMyYxdcav07seYmBjTt29fU6xYMePt7W1KlChh3n//fRMbG5tZu5TpNmzYkOz7WGLfdenSxdSqVSvJMhUrVjReXl6mRIkSyb7nZfRnjM2Yx/hr+AAAwCONMSoAAMCyCCoAAMCyCCoAAMCyCCoAAMCyCCoAAMCyCCoAAMCyCCoAAMCyCCoAAMCyCCoAHtqWLVvk4eGhZs2aOc3fuHGjbDabrly5kmSZoKAgjR8/3jFts9kcNx8fHz399NNavnx5kuVu3rypDz74QCEhIbLb7SpQoIBefPFF7du3L0nbmJgYvf/++ypTpoy8vb3l7++v+vXra8mSJeK7LoFHA0EFwEObOnWq3nrrLW3evFlnzpxxeT0RERE6e/asduzYoRo1aqhdu3b69ddfHffHxsaqfv36mjZtmj7++GMdOnRIq1atUlxcnKpXr66tW7c62l65ckX/+Mc/NHPmTA0ePFi7du3S5s2bFR4erkGDBik6Ovqh9hlA5vB0dwEAHm3Xrl3T/PnztWPHDp07d07Tp0/XkCFDXFpXnjx55O/vL39/f3300UeaMGGCNmzYoPLly0uSxo8fry1btmj37t2qUKGCJCkwMFCLFy9W9erV1aNHD/3222+y2WwaMmSITpw4oUOHDikgIMCxjZCQEHXo0EHe3t4Pv/MAMhxHVAA8lAULFqhMmTIqXbq0OnXqpGnTpj30aZW4uDhNnTpV0t2fkk80d+5cNWjQwBFSEmXJkkVvv/229u/fr7179yohIUHz5s1Tx44dnUJKopw5c8rTk7/TgEcBr1QAD2Xq1Knq1KmTJKlx48aKjo7Wpk2bVLt27TSvq0OHDvLw8NDNmzeVkJCgoKAgvfTSS477Dx06pDp16iS7bNmyZR1tAgICdPnyZZUpUybtOwTAUjiiAsBlBw8e1LZt29ShQwdJkqenp8LDwx1HQ9Lqs88+0549e/T9998rNDRU//nPf5QvXz6nNqk5WsNAWeDxwREVAC6bOnWq4uLinE6vGGNkt9v15ZdfysfHR5IUHR2tPHnyOC175coV5c6d22mev7+/SpUqpVKlSikiIkJNmzbV/v375efnJ+nu+JLff/892VoS54eEhMjX11d58uTRgQMH0mtXAbgJR1QAuCQuLk4zZ87U2LFjtWfPHsdt7969CggI0Lfffqvg4GBlyZJFO3fudFr22LFjio6OVkhISIrrr1atmqpUqaIRI0Y45rVv315r167V3r17ndomJCTos88+U2hoqCpUqKAsWbKoffv2mjNnTrJXIV27dk1xcXEP2QMAMoUBABcsXbrUeHl5mStXriS5b9CgQaZq1arGGGNee+01ExQUZJYvX26OHTtmNm3aZJ555hnzzDPPmISEBMcykszSpUud1rNq1Spjt9vNH3/8YYwx5ubNm6Z69eqmaNGiZsGCBebkyZNm27ZtpnXr1iZHjhxmy5YtjmUvXrxoypQpY4oUKWJmzJhh9u3bZw4dOmSmTp1qSpUqZS5fvpz+nQIg3dmM4WQugLRr0aKFEhIStHLlyiT3bdu2TdWrV9fevXsVEhKi0aNHa/78+Tp58qT8/f3VoEEDjRgxQgUKFHAsY7PZtHTpUrVu3doxzxij0NBQ1alTRxMnTpQk3bhxQyNHjnSsL1euXKpTp46GDRumsLAwpzqio6M1evRoLV68WCdPnlTevHlVvnx59erVS61atZLNZsuYzgGQbggqAADAshijAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALOv/AXmr4ymYI038AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from contextlib import redirect_stdout, redirect_stderr# suppress some stdout for better readability\n", + "import matplotlib.pyplot as plt\n", + "from random import randint\n", + "import os\n", + "\n", + "results = []\n", + "repeats = 50\n", + "\n", + "for _ in range(repeats):\n", + " with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull): # suppress output\n", + " val_loader, train_loader = dataloader_factory(randint(0, 9999))\n", + " model, optimiser, lr_scheduler = model_factory()\n", + " for epoch in range(epochs):\n", + " model = train_one_epoch(model, train_loader, val_loader, optimiser, lr_scheduler, loss_fn, epoch, eval=False)\n", + " _, auroc, _ = evaluate(model, val_loader, loss_fn)\n", + " results.append(auroc)\n", + "\n", + "plt.hist(results, bins=18)\n", + "plt.xlabel('AUROC')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Distribution of AUROC results on validation split')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see, the scores can vary quite significantly, ranging from <0.9 to a perfect score.\n", + "\n", + "To make the prediction more robust, we adapt two techniques:\n", + "\n", + "- Ensembling models trained on different folds of train-val data. Since the training is so fast, fitting a few addtional models is not a big deal. The train-val splitting method is provided by TDC.\n", + "\n", + "- Rather than choosing the model at the last epoch, we will use best validation loss to decide which one to choose.\n", + "\n", + "We already implemented a `dataloader_factory()` method that creates a new training and validation dataloader for each fold. Now, we will also build a method for ensemble-based evaluation, that uses a list of models to caculate the average logits for the prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from sklearn.metrics import roc_auc_score, average_precision_score\n", + "\n", + "def evaluate_ensemble(predictors, dataloader, loss_fn):\n", + " total_loss = 0\n", + " all_probs = []\n", + " all_targets = []\n", + "\n", + " with torch.no_grad():\n", + " \n", + " for inputs, targets in dataloader:\n", + " model_outputs = [predictor(inputs).squeeze() for predictor in predictors]\n", + " averaged_output = torch.sigmoid(torch.mean(torch.stack(model_outputs), dim=0))\n", + "\n", + " loss = loss_fn(averaged_output, targets)\n", + " total_loss += loss.item()\n", + "\n", + " all_probs.extend(averaged_output.tolist())\n", + " all_targets.extend(targets.tolist())\n", + "\n", + " loss = total_loss / len(all_probs)\n", + " return loss, roc_auc_score(all_targets, all_probs), average_precision_score(all_targets, all_probs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's see how much better our model gets!" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "featurising datasets\n", - "dataset=1 / 22\n", - "dataset=2 / 22\n", - "dataset=3 / 22\n", - "dataset=4 / 22\n", - "dataset=5 / 22\n" + "# Fold 1 / 5\n", + "## Epoch 1\ttrain_loss: 0.0195\tval_loss: 0.0112\tval_auroc: 0.3277\tval_avpr: 0.8480\n", + "## Epoch 2\ttrain_loss: 0.0172\tval_loss: 0.0091\tval_auroc: 0.7815\tval_avpr: 0.9616\n", + "## Epoch 3\ttrain_loss: 0.0117\tval_loss: 0.0059\tval_auroc: 0.9160\tval_avpr: 0.9873\n", + "## Epoch 4\ttrain_loss: 0.0073\tval_loss: 0.0041\tval_auroc: 0.9524\tval_avpr: 0.9931\n", + "## Epoch 5\ttrain_loss: 0.0049\tval_loss: 0.0033\tval_auroc: 0.9636\tval_avpr: 0.9951\n", + "## Epoch 6\ttrain_loss: 0.0036\tval_loss: 0.0033\tval_auroc: 0.9580\tval_avpr: 0.9943\n", + "## Epoch 7\ttrain_loss: 0.0023\tval_loss: 0.0028\tval_auroc: 0.9720\tval_avpr: 0.9964\n", + "## Epoch 8\ttrain_loss: 0.0021\tval_loss: 0.0026\tval_auroc: 0.9776\tval_avpr: 0.9971\n", + "## Epoch 9\ttrain_loss: 0.0016\tval_loss: 0.0027\tval_auroc: 0.9720\tval_avpr: 0.9963\n", + "## Epoch 10\ttrain_loss: 0.0010\tval_loss: 0.0025\tval_auroc: 0.9748\tval_avpr: 0.9967\n", + "## Epoch 11\ttrain_loss: 0.0008\tval_loss: 0.0022\tval_auroc: 0.9776\tval_avpr: 0.9971\n", + "## Epoch 12\ttrain_loss: 0.0007\tval_loss: 0.0022\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 13\ttrain_loss: 0.0007\tval_loss: 0.0026\tval_auroc: 0.9888\tval_avpr: 0.9986\n", + "## Epoch 14\ttrain_loss: 0.0006\tval_loss: 0.0022\tval_auroc: 0.9776\tval_avpr: 0.9971\n", + "## Epoch 15\ttrain_loss: 0.0006\tval_loss: 0.0022\tval_auroc: 0.9776\tval_avpr: 0.9971\n", + "## Epoch 16\ttrain_loss: 0.0005\tval_loss: 0.0021\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 17\ttrain_loss: 0.0005\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 18\ttrain_loss: 0.0005\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 19\ttrain_loss: 0.0004\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 20\ttrain_loss: 0.0004\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 21\ttrain_loss: 0.0004\tval_loss: 0.0020\tval_auroc: 0.9832\tval_avpr: 0.9978\n", + "## Epoch 22\ttrain_loss: 0.0003\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 23\ttrain_loss: 0.0004\tval_loss: 0.0020\tval_auroc: 0.9832\tval_avpr: 0.9978\n", + "## Epoch 24\ttrain_loss: 0.0006\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "## Epoch 25\ttrain_loss: 0.0004\tval_loss: 0.0020\tval_auroc: 0.9804\tval_avpr: 0.9974\n", + "# Fold 2 / 5\n", + "## Epoch 1\ttrain_loss: 0.0196\tval_loss: 0.0098\tval_auroc: 0.3132\tval_avpr: 0.8523\n", + "## Epoch 2\ttrain_loss: 0.0169\tval_loss: 0.0084\tval_auroc: 0.4151\tval_avpr: 0.9037\n", + "## Epoch 3\ttrain_loss: 0.0117\tval_loss: 0.0059\tval_auroc: 0.8830\tval_avpr: 0.9878\n", + "## Epoch 4\ttrain_loss: 0.0076\tval_loss: 0.0037\tval_auroc: 0.9358\tval_avpr: 0.9937\n", + "## Epoch 5\ttrain_loss: 0.0055\tval_loss: 0.0030\tval_auroc: 0.9509\tval_avpr: 0.9951\n", + "## Epoch 6\ttrain_loss: 0.0038\tval_loss: 0.0026\tval_auroc: 0.9660\tval_avpr: 0.9968\n", + "## Epoch 7\ttrain_loss: 0.0028\tval_loss: 0.0024\tval_auroc: 0.9698\tval_avpr: 0.9972\n", + "## Epoch 8\ttrain_loss: 0.0020\tval_loss: 0.0021\tval_auroc: 0.9811\tval_avpr: 0.9982\n", + "## Epoch 9\ttrain_loss: 0.0013\tval_loss: 0.0021\tval_auroc: 0.9736\tval_avpr: 0.9976\n", + "## Epoch 10\ttrain_loss: 0.0012\tval_loss: 0.0019\tval_auroc: 0.9811\tval_avpr: 0.9983\n", + "## Epoch 11\ttrain_loss: 0.0009\tval_loss: 0.0018\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 12\ttrain_loss: 0.0009\tval_loss: 0.0018\tval_auroc: 0.9811\tval_avpr: 0.9983\n", + "## Epoch 13\ttrain_loss: 0.0008\tval_loss: 0.0017\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 14\ttrain_loss: 0.0006\tval_loss: 0.0017\tval_auroc: 0.9887\tval_avpr: 0.9990\n", + "## Epoch 15\ttrain_loss: 0.0005\tval_loss: 0.0017\tval_auroc: 0.9887\tval_avpr: 0.9990\n", + "## Epoch 16\ttrain_loss: 0.0006\tval_loss: 0.0019\tval_auroc: 0.9887\tval_avpr: 0.9990\n", + "## Epoch 17\ttrain_loss: 0.0005\tval_loss: 0.0017\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 18\ttrain_loss: 0.0005\tval_loss: 0.0018\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 19\ttrain_loss: 0.0004\tval_loss: 0.0018\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 20\ttrain_loss: 0.0004\tval_loss: 0.0017\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 21\ttrain_loss: 0.0004\tval_loss: 0.0018\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 22\ttrain_loss: 0.0004\tval_loss: 0.0018\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 23\ttrain_loss: 0.0005\tval_loss: 0.0017\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 24\ttrain_loss: 0.0004\tval_loss: 0.0017\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "## Epoch 25\ttrain_loss: 0.0004\tval_loss: 0.0016\tval_auroc: 0.9849\tval_avpr: 0.9986\n", + "# Fold 3 / 5\n", + "## Epoch 1\ttrain_loss: 0.0241\tval_loss: 0.0135\tval_auroc: 0.5641\tval_avpr: 0.9059\n", + "## Epoch 2\ttrain_loss: 0.0212\tval_loss: 0.0112\tval_auroc: 0.7853\tval_avpr: 0.9595\n", + "## Epoch 3\ttrain_loss: 0.0142\tval_loss: 0.0072\tval_auroc: 0.9199\tval_avpr: 0.9890\n", + "## Epoch 4\ttrain_loss: 0.0087\tval_loss: 0.0042\tval_auroc: 0.9712\tval_avpr: 0.9966\n", + "## Epoch 5\ttrain_loss: 0.0057\tval_loss: 0.0030\tval_auroc: 0.9840\tval_avpr: 0.9982\n", + "## Epoch 6\ttrain_loss: 0.0040\tval_loss: 0.0028\tval_auroc: 0.9808\tval_avpr: 0.9979\n", + "## Epoch 7\ttrain_loss: 0.0028\tval_loss: 0.0024\tval_auroc: 0.9872\tval_avpr: 0.9986\n", + "## Epoch 8\ttrain_loss: 0.0021\tval_loss: 0.0022\tval_auroc: 0.9808\tval_avpr: 0.9978\n", + "## Epoch 9\ttrain_loss: 0.0016\tval_loss: 0.0021\tval_auroc: 0.9872\tval_avpr: 0.9985\n", + "## Epoch 10\ttrain_loss: 0.0013\tval_loss: 0.0021\tval_auroc: 0.9840\tval_avpr: 0.9982\n", + "## Epoch 11\ttrain_loss: 0.0011\tval_loss: 0.0019\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 12\ttrain_loss: 0.0016\tval_loss: 0.0017\tval_auroc: 0.9808\tval_avpr: 0.9978\n", + "## Epoch 13\ttrain_loss: 0.0007\tval_loss: 0.0016\tval_auroc: 0.9872\tval_avpr: 0.9986\n", + "## Epoch 14\ttrain_loss: 0.0009\tval_loss: 0.0016\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 15\ttrain_loss: 0.0008\tval_loss: 0.0017\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 16\ttrain_loss: 0.0007\tval_loss: 0.0017\tval_auroc: 0.9840\tval_avpr: 0.9982\n", + "## Epoch 17\ttrain_loss: 0.0006\tval_loss: 0.0015\tval_auroc: 0.9872\tval_avpr: 0.9985\n", + "## Epoch 18\ttrain_loss: 0.0005\tval_loss: 0.0015\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 19\ttrain_loss: 0.0007\tval_loss: 0.0014\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 20\ttrain_loss: 0.0005\tval_loss: 0.0015\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 21\ttrain_loss: 0.0006\tval_loss: 0.0014\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 22\ttrain_loss: 0.0005\tval_loss: 0.0014\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 23\ttrain_loss: 0.0009\tval_loss: 0.0014\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 24\ttrain_loss: 0.0004\tval_loss: 0.0015\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "## Epoch 25\ttrain_loss: 0.0004\tval_loss: 0.0014\tval_auroc: 0.9904\tval_avpr: 0.9989\n", + "# Fold 4 / 5\n", + "## Epoch 1\ttrain_loss: 0.0242\tval_loss: 0.0124\tval_auroc: 0.5370\tval_avpr: 0.9192\n", + "## Epoch 2\ttrain_loss: 0.0212\tval_loss: 0.0105\tval_auroc: 0.5880\tval_avpr: 0.9397\n", + "## Epoch 3\ttrain_loss: 0.0140\tval_loss: 0.0069\tval_auroc: 0.8148\tval_avpr: 0.9805\n", + "## Epoch 4\ttrain_loss: 0.0088\tval_loss: 0.0041\tval_auroc: 0.8565\tval_avpr: 0.9864\n", + "## Epoch 5\ttrain_loss: 0.0058\tval_loss: 0.0032\tval_auroc: 0.9213\tval_avpr: 0.9938\n", + "## Epoch 6\ttrain_loss: 0.0040\tval_loss: 0.0025\tval_auroc: 0.9583\tval_avpr: 0.9969\n", + "## Epoch 7\ttrain_loss: 0.0028\tval_loss: 0.0024\tval_auroc: 0.9722\tval_avpr: 0.9980\n", + "## Epoch 8\ttrain_loss: 0.0021\tval_loss: 0.0024\tval_auroc: 0.9722\tval_avpr: 0.9980\n", + "## Epoch 9\ttrain_loss: 0.0016\tval_loss: 0.0022\tval_auroc: 0.9722\tval_avpr: 0.9980\n", + "## Epoch 10\ttrain_loss: 0.0015\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 11\ttrain_loss: 0.0011\tval_loss: 0.0022\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 12\ttrain_loss: 0.0010\tval_loss: 0.0023\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 13\ttrain_loss: 0.0007\tval_loss: 0.0023\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 14\ttrain_loss: 0.0007\tval_loss: 0.0022\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 15\ttrain_loss: 0.0006\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 16\ttrain_loss: 0.0006\tval_loss: 0.0021\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 17\ttrain_loss: 0.0007\tval_loss: 0.0021\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 18\ttrain_loss: 0.0007\tval_loss: 0.0021\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 19\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 20\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 21\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 22\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9769\tval_avpr: 0.9983\n", + "## Epoch 23\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 24\ttrain_loss: 0.0004\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "## Epoch 25\ttrain_loss: 0.0005\tval_loss: 0.0021\tval_auroc: 0.9815\tval_avpr: 0.9987\n", + "# Fold 5 / 5\n", + "## Epoch 1\ttrain_loss: 0.0236\tval_loss: 0.0113\tval_auroc: 0.3108\tval_avpr: 0.8229\n", + "## Epoch 2\ttrain_loss: 0.0205\tval_loss: 0.0093\tval_auroc: 0.4486\tval_avpr: 0.8574\n", + "## Epoch 3\ttrain_loss: 0.0136\tval_loss: 0.0060\tval_auroc: 0.6466\tval_avpr: 0.9016\n", + "## Epoch 4\ttrain_loss: 0.0080\tval_loss: 0.0043\tval_auroc: 0.7619\tval_avpr: 0.9576\n", + "## Epoch 5\ttrain_loss: 0.0052\tval_loss: 0.0037\tval_auroc: 0.8396\tval_avpr: 0.9763\n", + "## Epoch 6\ttrain_loss: 0.0038\tval_loss: 0.0033\tval_auroc: 0.9148\tval_avpr: 0.9889\n", + "## Epoch 7\ttrain_loss: 0.0027\tval_loss: 0.0031\tval_auroc: 0.9273\tval_avpr: 0.9904\n", + "## Epoch 8\ttrain_loss: 0.0023\tval_loss: 0.0030\tval_auroc: 0.9223\tval_avpr: 0.9895\n", + "## Epoch 9\ttrain_loss: 0.0017\tval_loss: 0.0029\tval_auroc: 0.9424\tval_avpr: 0.9926\n", + "## Epoch 10\ttrain_loss: 0.0014\tval_loss: 0.0028\tval_auroc: 0.9424\tval_avpr: 0.9925\n", + "## Epoch 11\ttrain_loss: 0.0011\tval_loss: 0.0027\tval_auroc: 0.9424\tval_avpr: 0.9924\n", + "## Epoch 12\ttrain_loss: 0.0008\tval_loss: 0.0027\tval_auroc: 0.9549\tval_avpr: 0.9943\n", + "## Epoch 13\ttrain_loss: 0.0007\tval_loss: 0.0026\tval_auroc: 0.9524\tval_avpr: 0.9938\n", + "## Epoch 14\ttrain_loss: 0.0007\tval_loss: 0.0026\tval_auroc: 0.9398\tval_avpr: 0.9921\n", + "## Epoch 15\ttrain_loss: 0.0007\tval_loss: 0.0028\tval_auroc: 0.9499\tval_avpr: 0.9934\n", + "## Epoch 16\ttrain_loss: 0.0007\tval_loss: 0.0026\tval_auroc: 0.9524\tval_avpr: 0.9938\n", + "## Epoch 17\ttrain_loss: 0.0008\tval_loss: 0.0025\tval_auroc: 0.9699\tval_avpr: 0.9963\n", + "## Epoch 18\ttrain_loss: 0.0008\tval_loss: 0.0024\tval_auroc: 0.9649\tval_avpr: 0.9956\n", + "## Epoch 19\ttrain_loss: 0.0007\tval_loss: 0.0025\tval_auroc: 0.9649\tval_avpr: 0.9956\n", + "## Epoch 20\ttrain_loss: 0.0005\tval_loss: 0.0027\tval_auroc: 0.9649\tval_avpr: 0.9956\n", + "## Epoch 21\ttrain_loss: 0.0006\tval_loss: 0.0029\tval_auroc: 0.9649\tval_avpr: 0.9957\n", + "## Epoch 22\ttrain_loss: 0.0005\tval_loss: 0.0028\tval_auroc: 0.9624\tval_avpr: 0.9953\n", + "## Epoch 23\ttrain_loss: 0.0005\tval_loss: 0.0028\tval_auroc: 0.9599\tval_avpr: 0.9950\n", + "## Epoch 24\ttrain_loss: 0.0005\tval_loss: 0.0029\tval_auroc: 0.9599\tval_avpr: 0.9950\n", + "## Epoch 25\ttrain_loss: 0.0004\tval_loss: 0.0028\tval_auroc: 0.9574\tval_avpr: 0.9946\n", + "test_loss: 0.0012\n", + "test_auroc: 0.9975\n", + "test_avpr: 0.9993\n" ] } ], "source": [ - "EPOCHS = 25\n", + "from copy import deepcopy\n", "\n", - "group = admet_group(path='admet_data/')\n", - "featuriser = Minimol()\n", - "tasks = {}\n", + "seeds = [1, 2, 3, 4, 5]\n", "\n", - "print('featurising datasets')\n", - "for dataset_i, dataset_name in enumerate(group.dataset_names):\n", - " print(f'dataset={dataset_i + 1} / {len(group.dataset_names)}')\n", - " tasks[dataset_name] = Task(dataset_name, featuriser) \n", + "best_models = []\n", "\n", - "del featuriser" + "for fold_i, seed in enumerate(seeds):\n", + " print(f\"# Fold {fold_i +1} / {len(seeds)}\")\n", + " with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull): # suppress output\n", + " val_loader, train_loader = dataloader_factory(seed)\n", + " model, optimiser, lr_scheduler = model_factory()\n", + "\n", + " best_epoch = {\"model\": None, \"result\": None}\n", + " for epoch in range(epochs):\n", + " model = train_one_epoch(model, train_loader, val_loader, optimiser, lr_scheduler, loss_fn, epoch)\n", + " val_loss, _, _ = evaluate(model, val_loader, loss_fn)\n", + "\n", + " if best_epoch['model'] is None:\n", + " best_epoch['model'] = deepcopy(model)\n", + " best_epoch['result'] = deepcopy(val_loss)\n", + " else:\n", + " best_epoch['model'] = best_epoch['model'] if best_epoch['result'] <= val_loss else deepcopy(model)\n", + " best_epoch['result'] = best_epoch['result'] if best_epoch['result'] <= val_loss else deepcopy(val_loss)\n", + "\n", + " best_models.append(deepcopy(best_epoch['model']))\n", + "\n", + "test_loss, test_auroc, test_avpr = evaluate_ensemble(best_models, test_loader, loss_fn)\n", + "print(\n", + " f\"test_loss: {test_loss:.4f}\\n\"\n", + " f\"test_auroc: {test_auroc:.4f}\\n\"\n", + " f\"test_avpr: {test_avpr:.4f}\"\n", + ")" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "model, optimiser, lr_scheduler = model_factory()\n", + "In about 15s an ensemble was build reaching the performance of 0.9975 in AUROC on the test set. This is slightly better than the performance we achieved with a single model, but more importantly, the ensemble is not senstitive to which part of the data is used for validation, and is less sensitive to the intialisation because we intialise n models getting somewhere close to an average performance.\n", "\n", - "model.unfreeze_trunk()\n", - "for epoch in range(EPOCHS):\n", - " for task_i, (task_name, task) in enumerate(tasks.items()):\n", - " #lr_scheduler.step(epoch)\n", - " model, train_loss = train_one_epoch(model, task, optimiser, lr_scheduler)\n", - " val_loss = evaluate(model, task, eval_type='val')\n", - " print(f'epoch={epoch+1} / {EPOCHS} | {task_name=} | {train_loss:.4f=} | {val_loss:.4f=}')" + "This score is better than the SoTA, showcasing how powerful MiniMol is in featurising molecules for downstream biological tasks." ] } ], diff --git a/notebooks/shared_weights_downstream_adaptation.ipnyb b/notebooks/shared_weights_downstream_adaptation.ipnyb new file mode 100644 index 0000000..bebbd26 --- /dev/null +++ b/notebooks/shared_weights_downstream_adaptation.ipnyb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found local copy...\n" + ] + } + ], + "source": [ + "from minimol import Minimol\n", + "\n", + "import os\n", + "import math\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch.nn.functional as F\n", + "from torch.optim.lr_scheduler import LambdaLR\n", + "from torch.utils.data import DataLoader, Dataset\n", + "\n", + "from tdc.benchmark_group import admet_group\n", + "\n", + "from contextlib import redirect_stdout, redirect_stderr\n", + "\n", + "\n", + "group = admet_group(path='admet_data/')\n", + "\n", + "\n", + "class MultiTaskModel(nn.Module):\n", + " def __init__(self, hidden_dim=512, input_dim=512, head_hidden_dim=256, dropout=0.1, task_names=None):\n", + " super(MultiTaskModel, self).__init__()\n", + " \n", + " self.dense1 = nn.Linear(input_dim, hidden_dim)\n", + " self.dense2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.dense3 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.bn1 = nn.BatchNorm1d(hidden_dim)\n", + " self.bn2 = nn.BatchNorm1d(hidden_dim)\n", + " self.bn3 = nn.BatchNorm1d(hidden_dim)\n", + " self.dropout = nn.Dropout(dropout)\n", + "\n", + " self.heads = nn.ModuleDict({\n", + " task_name: nn.Sequential(\n", + " nn.Linear(hidden_dim + input_dim, head_hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Dropout(dropout),\n", + " nn.Linear(head_hidden_dim, 1)\n", + " ) for task_name in task_names\n", + " })\n", + "\n", + " self.trunk_frozen = False\n", + "\n", + " def forward(self, x, task_name):\n", + " original_x = x\n", + "\n", + " x = self.dense1(x)\n", + " x = self.bn1(x)\n", + " x = self.dropout(x)\n", + " x = F.relu(x)\n", + "\n", + " x = self.dense2(x)\n", + " x = self.bn2(x)\n", + " x = self.dropout(x)\n", + " x = F.relu(x)\n", + "\n", + " x = self.dense3(x)\n", + " x = self.bn3(x)\n", + " x = self.dropout(x)\n", + " x = F.relu(x)\n", + "\n", + " x = self.heads[task_name](torch.cat([x, original_x], dim=1))\n", + " return x\n", + "\n", + " def freeze_trunk(self):\n", + " self.trunk_frozen = True\n", + " for param in self.dense1.parameters():\n", + " param.requires_grad = False\n", + " for param in self.dense2.parameters():\n", + " param.requires_grad = False\n", + " for param in self.bn1.parameters():\n", + " param.requires_grad = False\n", + " for param in self.bn2.parameters():\n", + " param.requires_grad = False\n", + "\n", + " def unfreeze_trunk(self):\n", + " self.trunk_frozen = False\n", + " for param in self.dense1.parameters():\n", + " param.requires_grad = True\n", + " for param in self.dense2.parameters():\n", + " param.requires_grad = True\n", + " for param in self.bn1.parameters():\n", + " param.requires_grad = True\n", + " for param in self.bn2.parameters():\n", + " param.requires_grad = True\n", + "\n", + "\n", + "\n", + "def model_factory(task_names, lr=3e-4, epochs=25, warmup=5, weight_decay=1e-4):\n", + " model = MultiTaskModel(task_names=task_names)\n", + " optimiser = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)\n", + "\n", + " def lr_fn(epoch):\n", + " if epoch < warmup: return epoch / warmup\n", + " else: return (1 + math.cos(math.pi * (epoch - warmup) / (epochs - warmup))) / 2\n", + "\n", + " lr_scheduler = LambdaLR(optimiser, lr_lambda=lr_fn)\n", + " return model, optimiser, lr_scheduler\n", + "\n", + "\n", + "def evaluate(predictor, task, eval_type='val'):\n", + " predictor.eval()\n", + " total_loss = 0\n", + "\n", + " dataloader = task.val_loader if eval_type == 'val' else task.test_loader\n", + "\n", + " with torch.no_grad():\n", + " for inputs, targets in dataloader:\n", + " logits = predictor(inputs, task_name=task.name).squeeze()\n", + " loss = task.get_loss(logits, targets)\n", + " total_loss += loss.item()\n", + "\n", + " loss = total_loss / len(dataloader)\n", + " \n", + " return loss\n", + "\n", + "\n", + "def evaluate_ensemble(predictors, dataloader, task):\n", + " predictions = []\n", + " with torch.no_grad():\n", + " \n", + " for inputs, _ in dataloader:\n", + " ensemble_logits = [predictor(inputs).squeeze() for predictor in predictors]\n", + " averaged_logits = torch.mean(torch.stack(ensemble_logits), dim=0)\n", + " if task == 'classification':\n", + " predictions += torch.sigmoid(averaged_logits)\n", + " else:\n", + " predictions += averaged_logits\n", + "\n", + " return predictions\n", + "\n", + "\n", + "def train_one_epoch(predictor, task, optimiser):\n", + " train_loss = 0\n", + " \n", + " for inputs, targets in task.train_loader:\n", + " optimiser.zero_grad()\n", + " logits = predictor(inputs, task_name=task.name).squeeze()\n", + " loss = task.get_loss(logits, targets)\n", + " loss.backward()\n", + " optimiser.step()\n", + " train_loss += loss.item()\n", + "\n", + " return predictor, train_loss / len(task.train_loader)\n", + "\n", + "\n", + "class AdmetDataset(Dataset):\n", + " def __init__(self, samples):\n", + " self.samples = samples['Embedding'].tolist()\n", + " self.targets = [float(target) for target in samples['Y'].tolist()]\n", + "\n", + " def __len__(self):\n", + " return len(self.samples)\n", + "\n", + " def __getitem__(self, idx):\n", + " sample = torch.tensor(self.samples[idx])\n", + " target = torch.tensor(self.targets[idx])\n", + " return sample, target\n", + "\n", + "\n", + "class Task:\n", + " def __init__(self, dataset_name, featuriser):\n", + " benchmark = group.get(dataset_name)\n", + " with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull): # suppress output\n", + " mols_test = benchmark['test']\n", + " mols_train, mols_valid = group.get_train_valid_split(benchmark=dataset_name, seed=42)\n", + " mols_test['Embedding'] = featuriser(list(mols_test['Drug']))\n", + " mols_train['Embedding'] = featuriser(list(mols_train['Drug']))\n", + " mols_valid['Embedding'] = featuriser(list(mols_valid['Drug']))\n", + " self.name = dataset_name\n", + " self.test_loader = DataLoader(AdmetDataset(mols_test), batch_size=128, shuffle=False)\n", + " self.val_loader = DataLoader(AdmetDataset(mols_valid), batch_size=128, shuffle=False)\n", + " self.train_loader = DataLoader(AdmetDataset(mols_train), batch_size=32, shuffle=True)\n", + " self.task = 'classification' if len(benchmark['test']['Y'].unique()) == 2 else 'regression'\n", + " self.loss_fn = nn.BCELoss() if self.task == 'classification' else nn.MSELoss() \n", + "\n", + " def get_loss(self, logits, targets):\n", + " if self.task == 'classification':\n", + " return self.loss_fn(torch.sigmoid(logits), targets)\n", + " else:\n", + " return self.loss_fn(logits, targets)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found local copy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "featurising datasets\n", + "dataset=1 / 22\n", + "dataset=2 / 22\n", + "dataset=3 / 22\n", + "dataset=4 / 22\n", + "dataset=5 / 22\n", + "dataset=6 / 22\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:25] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] [13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:26] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:27] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:28] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:28] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:28] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:29] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:30] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:30] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:30] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:31] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:32] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:33] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:34] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:35] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:35] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:35] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:36] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:37] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:38] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:39] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:39] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:39] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:41] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:41] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:41] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:42] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:42] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:42] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:43] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:43] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:43] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:44] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:44] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:44] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:46] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:47] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:48] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:48] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:48] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:49] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:49] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:49] WARNING: not removing hydrogen atom without neighbors\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dataset=7 / 22\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[13:58:51] [13:58:51] WARNING: not removing hydrogen atom without neighborsWARNING: not removing hydrogen atom without neighbors\n", + "\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:51] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:52] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:53] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:54] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:55] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:56] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n", + "[13:58:57] WARNING: not removing hydrogen atom without neighbors\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dataset=8 / 22\n", + "dataset=9 / 22\n", + "dataset=10 / 22\n", + "dataset=11 / 22\n", + "dataset=12 / 22\n", + "dataset=13 / 22\n", + "dataset=14 / 22\n", + "dataset=15 / 22\n", + "dataset=16 / 22\n", + "dataset=17 / 22\n", + "dataset=18 / 22\n", + "dataset=19 / 22\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n", + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n", + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n", + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n", + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n", + "[14:01:27] WARNING: not removing hydrogen atom without neighbors\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dataset=20 / 22\n", + "dataset=21 / 22\n", + "dataset=22 / 22\n" + ] + } + ], + "source": [ + "featuriser = Minimol()\n", + "tasks = {}\n", + "\n", + "print('featurising datasets')\n", + "for dataset_i, dataset_name in enumerate(group.dataset_names):\n", + " print(f'dataset={dataset_i + 1} / {len(group.dataset_names)}')\n", + " tasks[dataset_name] = Task(dataset_name, featuriser) \n", + "\n", + "del featuriser" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB70AAAPeCAYAAABwZA7aAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hTZfvA8W/Ske69GW3ZewiCgAgoCggoAg70leEWEAX1fcXBfAXHKz8cKIoKqKgIoqIoCAiKMkQQBdl7ttC9V3J+f5wkbTrTNkmb9P5cV6+2JycnTwq58+Tc574fjaIoCkIIIYQQQgghhBBCCCGEEEIIIYQT0tb1AIQQQgghhBBCCCGEEEIIIYQQQoiakqS3EEIIIYQQQgghhBBCCCGEEEIIpyVJbyGEEEIIIYQQQgghhBBCCCGEEE5Lkt5CCCGEEEIIIYQQQgghhBBCCCGcliS9hRBCCCGEEEIIIYQQQgghhBBCOC1JegshhBBCCCGEEEIIIYQQQgghhHBakvQWQgghhBBCCCGEEEIIIYQQQgjhtCTpLYQQQgghhBBCCCGEEEIIIYQQwmlJ0lsIIYQQQgghhBBCCCGEEEIIIYTTkqS3EEIIUY/MmjULjUZDUlJSpfvFxcUxfvx4u4whLi6OYcOG2eXYQgjhSOPHj8fPz6+uh1Fvbd26FY1Gw9atW83bxo8fT1xcnMV+Go2GWbNmOXRsQjiL+jB3s5fSr/1ly5ah0Wg4ffp0tY/Vv39/OnToUOV+p0+fRqPRsGzZMvM209+4JGf8ewpRX5V+bffv35/+/fvX6ZhMTDHhf//7X5X7WhMrypv7WKO8YwshhLOpTSyzds4L1sXe8j53NnTWvv+W9/e0dq7dEEjSWziNnJwcFi1axE033UR0dDT+/v507dqVd955B71eX9fDE0IIIYQQwmFycnKYNWtWtU/aCiGEKzp48CCzZs2qUUJeCCFqYt68eXz99dd1PQyrSIwUQtR38vlW2Ip7XQ9ACGudPHmSxx57jBtuuIFp06YREBDAhg0bmDhxIjt37mT58uV1PUQhhHCYI0eOoNXKtWtCCNFQ5eTkMHv2bAC7V2Pl5ubi7i4fHYWoDWecu9XFaz82Npbc3Fw8PDwq3a/03/PgwYPMnj2b/v37S9WQELX0448/1vUQauT555/nmWeeqXSf6667jtzcXDw9PWt97Hnz5jF69GhGjBhR3aE6nMRIIYQjWTPvXbJkCQaDwfy7Iz/fCtcmZy6E04iKimL//v20b9/evO3hhx/mvvvuY+nSpbzwwgu0aNGiDkcohBCOo9Pp6noIQgjh0oqKijAYDNU+KeqKvLy86noIQjg9Z5y71cVrX6PRWPW4zvj3FMJZOOvcx93dvcoLdbRabY1imzXHdhWKopCXl4e3t3ddD0UI4aSsmadVdYGjEDXlXJcZC4e6cOEC999/PzExMeh0OuLj43n00UcpKCggJSWFp556io4dO+Ln50dAQABDhgzhr7/+KnOcvLw8Zs2aRatWrfDy8iI6OpqRI0dy4sQJ8z7Z2dk8+eSTNGnSBJ1OR+vWrfnf//6HoijmfcLCwiwS3ia33XYbAIcOHbL6uY0cOZKrrrrKYtvw4cPRaDSsXbvWvG3Xrl1oNBp++OEHAKuft2ldhS+++IIXX3yRxo0b4+XlxQ033MDx48fLjGfRokU0a9YMb29vevTowbZt2+rVGkpCCMdLS0tj/PjxBAUFERgYyIQJE8jJyTHfXnp9nOrEZWv9+uuv9OjRAy8vL5o1a8ZHH31UZp+TJ09y++23ExISgo+PD9dccw3r1q2z2Kei9R9rup6aEKJ+Ma3tdfjwYe644w4CAgIIDQ3l8ccfJy8vz7xfbm4uU6ZMISwsDH9/f2655RYuXLhQZs1Ya49XHSdPnmTQoEH4+voSExPDnDlzLOaZJdeLXLhwIc2bN0en03Hw4EEAfvrpJ/r27Yuvry9BQUHceuut5c49K5s/m6SlpTF16lTi4uLQ6XQ0btyYsWPHmtdGKygoYMaMGXTr1o3AwEB8fX3p27cvW7ZssRhveHg4ALNnz0aj0ZT5Ox4+fJjRo0cTEhKCl5cX3bt3t5jnVoes6S1E1ZKSkiqNWeWtQW3NPMqamFBYWEhISAgTJkwoM66MjAy8vLx46qmnrD6eiTWv/W+++YahQ4ea417z5s2ZO3duhUuQ7dmzh969e+Pt7U18fDyLFy+2uL28Nb3LU/LvuWzZMm6//XYABgwYYI6JW7duZdy4cYSFhVFYWFjmGDfddBOtW7eu9HFKGj9+PH5+fpw9e5Zhw4bh5+dHo0aNWLRoEQD79+/n+uuvx9fXl9jYWD799FOL+9tjvi6EPZQ+H2X63LZy5UqeffZZoqKi8PX15ZZbbuHcuXNl7r9q1Sq6deuGt7c3YWFh/Otf/+LChQsW+5heT1XN0Up67733zHO0q6++mt27d1vcbs1atRV9Bt21axc333wzwcHB+Pr60qlTJ15//fUKj63RaMjOzmb58uXmmDN+/Hi2bNmCRqPhq6++KvPYn376KRqNhh07dlQ6RpPqxOvPP/+cbt264e/vT0BAAB07djSPv7IYCWo8HTZsGBs2bKB79+54e3vz7rvvArB06VKuv/56IiIi0Ol0tGvXjnfeecfisU1/m/K+Sr7vGQwGFi5cSPv27fHy8iIyMpKHH36Y1NRUi+OZxmPN+Yi0tDSeeOIJ8/nkFi1a8PLLL1tUj5oe+/XXX6djx454eXkRHh7O4MGD+eOPP8z7WPNchagrmZmZPPHEE+bPkBEREdx4443s3bvXvI81sbe0yuZdFc0Dq5rzQvnz3tJKruld2efbpUuXotFo+PPPP8scY968ebi5uVX5PE2qMxc7f/48I0aMwNfXl4iICKZOncqGDRvKvIccO3aMUaNGERUVhZeXF40bN+auu+4iPT3dvE9RURFz5841v4fFxcXx7LPPkp+fX+WYyxtHZferaq7dEDSMS9REtV28eJEePXqQlpbGQw89RJs2bbhw4QKrV68mJyeHkydP8vXXX3P77bcTHx9PYmIi7777Lv369ePgwYPExMQAoNfrGTZsGJs3b+auu+7i8ccfJzMzk40bN3LgwAGaN2+OoijccsstbNmyhfvvv58uXbqwYcMGnn76aS5cuMD//d//VTrWhIQEQE2KW6tv37588803ZGRkEBAQgKIo/Pbbb2i1WrZt28Ytt9wCwLZt29BqtfTp0wfA6udt8tJLL6HVannqqadIT0/nlVde4Z577mHXrl3mfd555x0mT55M3759mTp1KqdPn2bEiBEEBwfTuHFjq5+TEMK13HHHHcTHxzN//nz27t3L+++/T0REBC+//HK5+1c3PlXl+PHjjB49mvvvv59x48bx4YcfMn78eLp162a+ACkxMZHevXuTk5PDlClTCA0NZfny5dxyyy2sXr3afFGSEKJhuOOOO4iLi2P+/Pns3LmTN954g9TUVPMJqvHjx/PFF19w7733cs011/Dzzz8zdOjQGh/PWnq9nsGDB3PNNdfwyiuvsH79embOnElRURFz5syx2Hfp0qXk5eXx0EMPodPpCAkJYdOmTQwZMoRmzZoxa9YscnNzefPNN+nTpw979+41f1Cvav7s6elJVlYWffv25dChQ9x3331cddVVJCUlsXbtWs6fP09YWBgZGRm8//77jBkzhgcffJDMzEw++OADBg0axO+//06XLl0IDw/nnXfe4dFHH+W2225j5MiRAHTq1AmAf/75hz59+tCoUSOeeeYZfH19+eKLLxgxYgRffvmlxGch7KC6McvaeZQ1McHDw4PbbruNNWvW8O6771pUaX799dfk5+dz1113WX286li2bBl+fn5MmzYNPz8/fvrpJ2bMmEFGRgavvvqqxb6pqancfPPN3HHHHYwZM4YvvviCRx99FE9PT+67775qPW5J1113HVOmTOGNN97g2WefpW3btgC0bduWe++9l48++ogNGzYwbNgw830SEhL46aefmDlzZrUeS6/XM2TIEK677jpeeeUVVqxYweTJk/H19eW5557jnnvuYeTIkSxevJixY8fSq1cv4uPjAdvP14VwtBdffBGNRsN//vMfLl++zMKFCxk4cCD79u0zVwUvW7aMCRMmcPXVVzN//nwSExN5/fXX+e233/jzzz8JCgoyH686c7RPP/2UzMxMHn74YTQaDa+88gojR47k5MmTta4W3LhxI8OGDSM6OprHH3+cqKgoDh06xHfffcfjjz9e7n0+/vhjHnjgAXr06MFDDz0EQPPmzbnmmmto0qQJK1asKDPfWrFiBc2bN6dXr15WjcvaeL1x40bGjBnDDTfcYD5fcOjQIX777Tcef/zxSmOkyZEjRxgzZgwPP/wwDz74oPmCoHfeeYf27dtzyy234O7uzrfffsvEiRMxGAxMmjQJUAuLSnfe3LNnDwsXLiQiIsK87eGHHzb//5gyZQqnTp3irbfe4s8//+S3336z+He05nxETk4O/fr148KFCzz88MM0bdqU7du3M336dC5dusTChQvNx7v//vtZtmwZQ4YM4YEHHqCoqIht27axc+dOunfvbvVzFaKuPPLII6xevZrJkyfTrl07kpOT+fXXXzl06BBXXXVVtWJvbdnqc3pJlX2+jY+PZ9KkSaxYsYKuXbta3G/FihX079+fRo0aWfU41s7FcnNzueGGGzh79ixTpkwhJiaGjz/+mJ9++snieAUFBQwaNIj8/Hwee+wxoqKiuHDhAt999x1paWkEBgYC8MADD7B8+XJGjx7Nk08+ya5du5g/fz6HDh0q9yIpE2vHYWKvubbTUYQox9ixYxWtVqvs3r27zG0Gg0HJy8tT9Hq9xfZTp04pOp1OmTNnjnnbhx9+qADKggULyj2OoijK119/rQDKf//7X4vbR48erWg0GuX48eMVjjM/P19p166dEh8frxQWFlr9/Hbv3q0Ayvfff68oiqL8/fffCqDcfvvtSs+ePc373XLLLUrXrl3Nv1v7vLds2aIAStu2bZX8/Hzz9tdff10BlP3795vHHxoaqlx99dUW41+2bJkCKP369bP6OQkhXMPMmTMVQLnvvvsstt92221KaGio+ffY2Fhl3Lhx5t+tjU/WiI2NVQDll19+MW+7fPmyotPplCeffNK87YknnlAAZdu2beZtmZmZSnx8vBIXF2cez9KlSxVAOXXqlMXjmGLlli1bqjU+IUT9Yopbt9xyi8X2iRMnKoDy119/KXv27FEA5YknnrDYZ/z48QqgzJw5s1rHs9a4ceMUQHnsscfM2wwGgzJ06FDF09NTuXLliqIoarwElICAAOXy5csWx+jSpYsSERGhJCcnm7f99ddfilarVcaOHWveVtX8WVEUZcaMGQqgrFmzpsJ9ioqKLOaPiqIoqampSmRkpMV7w5UrV8r87UxuuOEGpWPHjkpeXp7F8Xv37q20bNnSvK28ODxu3DglNjbW4ngVPY4QwvqYVXruZu08ytqYsGHDBgVQvv32W4t9b775ZqVZs2bm3609nqKUfe2XN6fLyckp8zd5+OGHFR8fH4sY1K9fPwVQXnvtNfO2/Px8c4wtKChQFKU4Hi9dutS8n+lvXFLpv+eqVavKnVfq9XqlcePGyp133mmxfcGCBYpGo1FOnjxZZvwVMb2nzJs3z7wtNTVV8fb2VjQajfL555+btx8+fLjM38+W83UhbKn0a7tfv34W56NM84VGjRopGRkZ5u1ffPGFAiivv/66oiiKUlBQoERERCgdOnRQcnNzzft99913CqDMmDHDvK26c7TQ0FAlJSXFvO8333xTJuZZEytKz32KioqU+Ph4JTY2VklNTbW4r2luVtGxfX19LY5tMn36dEWn0ylpaWnmbZcvX1bc3d2rNZ+yNl4//vjjSkBAgFJUVFThsSqKkYpS/Pl//fr1ZW4rL8YPGjTI4n2ltCtXrihNmzZVOnbsqGRlZSmKoijbtm1TAGXFihUW+65fv77MdmvPR8ydO1fx9fVVjh49anHMZ555RnFzc1POnj2rKIqi/PTTTwqgTJkypcxYS/4b1+S5CuEogYGByqRJk8q9rTqxt3QsK2/eZVKbz+lVxV5FKfu5s7LPt2PGjFFiYmIs5lF79+6tcOwVsXYutnDhQgVQvvjiC/O27OxspUWLFhbP488//1QAZdWqVRU+5r59+xRAeeCBByy2P/XUUwqg/PTTT+Ztpd9/rR2H6b7WzLUbAmlvLsowGAx8/fXXDB8+3Hy1W0kajQadTodWq/730ev1JCcn4+fnR+vWrS3aanz55ZeEhYXx2GOPlXscgO+//x43NzemTJlicfuTTz6Joijm1uLlmTx5MgcPHuStt96q1to6Xbt2xc/Pj19++QVQK7pNrSX37t1LTk4OiqLw66+/0rdvX/P9rH3eJhMmTLC4yt50rJMnTwLwxx9/kJyczIMPPmgx/nvuuYfg4GCrn48QwvU88sgjFr/37duX5ORkMjIyyt2/uvGpKu3atbOIf+Hh4bRu3docv0CN3z169ODaa681b/Pz8+Ohhx7i9OnT5rbAQoiGoXQFhGn+9/3337N+/XoAJk6cWO4+1T1edU2ePNn8s0ajYfLkyRQUFLBp0yaL/UaNGmVuqwZw6dIl9u3bx/jx4wkJCTFv79SpEzfeeKN5LNbMn0GdG3fu3LncSmvTPm5ubub5o8FgICUlhaKiIrp3725VPE9JSeGnn37ijjvuIDMzk6SkJJKSkkhOTmbQoEEcO3bM6vZvQgjrVTdmWTuPsjYmXH/99YSFhbFy5UrzttTUVDZu3Midd95p3lbbGFNayTVfTTGnb9++5OTkcPjwYYt93d3defjhh82/e3p68vDDD3P58mX27NlT7ce2hlar5Z577mHt2rVkZmaat69YsYLevXubq7Cr44EHHjD/HBQUROvWrfH19eWOO+4wb2/dujVBQUEWc2dbz9eFcLSxY8fi7+9v/n306NFER0eb49wff/zB5cuXmThxosW62UOHDqVNmzZllm8A6+dod955p8V5stLn12rqzz//5NSpUzzxxBNlKiGrapVekbFjx5Kfn8/q1avN21auXElRURH/+te/rD6OtfE6KCiI7OxsNm7cWKPxAsTHxzNo0KAy20vG+PT0dJKSkujXrx8nT560aN1rotfrGTNmDJmZmXz11Vf4+voCatvlwMBAbrzxRvPcNCkpiW7duuHn51emZbs15yNWrVpF3759CQ4OtjjmwIED0ev15nO+X375JRqNptzOHiX/jav7XIVwpKCgIHbt2sXFixfL3FaT2Fsbtvycbq2xY8dy8eJFi1ixYsUKvL29GTVqlNXHsXYu9v333xMdHc3o0aPN23x8fMydPUxMldwbNmywWJKyJNPfZdq0aRbbn3zySYBK/32sHYdJXcy16yNJeosyrly5QkZGBh06dKhwH4PBwP/93//RsmVLdDodYWFhhIeH8/fff1tMBE6cOEHr1q0rTUifOXOGmJgYi4kzFLfZOXPmTLn3e/XVV1myZAlz587l5ptvrs5TxM3NjV69erFt2zZATXr37duXa6+9Fr1ez86dOzl48CApKSkWkyxrn7dJ06ZNLX43TdBN69WYnlvpNkDu7u7mVplCiIapqvhRWnXjU3Uf3zSGko9/5syZctdBrCp+CyFcU8uWLS1+b968OVqtltOnT3PmzBm0Wm2Z5ELpOZC1x6sOrVZLs2bNLLa1atUKoMyxSo/PFMcqinVJSUlkZ2dbNX8GdW5c1T4Ay5cvp1OnTnh5eREaGkp4eDjr1q2zKp4fP34cRVF44YUXCA8Pt/gyney7fPlylccRQlRPdWNWdeZR1sQEd3d3Ro0axTfffGNe52/NmjUUFhZaJL2tPZ61/vnnH2677TYCAwMJCAggPDzcnNQpfbyYmBhzAsSkonhsS2PHjiU3N9fcPvLIkSPs2bOHe++9t9rHMq0FW1JgYCCNGzcukyALDAy0mDvber4uhKOVjnMajYYWLVqYX7+VzZvatGlT5vNhdeZo1f18bK0TJ04AWDU/s1abNm24+uqrWbFihXnbihUruOaaayqd+5bHmng9ceJEWrVqxZAhQ2jcuDH33Xef+YJTa1V0AdBvv/3GwIED8fX1JSgoiPDwcJ599lmgbIwHeP755/npp5/49NNPad68uXn7sWPHSE9PJyIiosz8NCsrq8zc1JrzEceOHWP9+vVljjdw4ECgeL574sQJYmJiLC5gtcVzFcKRXnnlFQ4cOECTJk3o0aMHs2bNMl8EUt3YW1u2+pxeHTfeeCPR0dHmuGowGPjss8+49dZby+SUKmPtXOzMmTO0aNGizNyu9N84Pj6eadOm8f777xMWFsagQYNYtGhRmWNptdoy8T8qKoqgoKBK/32sHYdJXc216xtJeosamTdvHtOmTeO6667jk08+YcOGDWzcuJH27dtjMBjs/vjLli3jP//5D4888gjPP/98jY5x7bXXsnv3bvLy8sxJ76CgIDp06MC2bdvMCfGSSe/qPm83N7dyH1tRlBqNWQjRcFQ3ftg6LtsyflV0hbxer6/2sYQQzqOm1TGOOl55SlZ41JVPPvmE8ePH07x5cz744APWr1/Pxo0buf76662K56Z9nnrqKTZu3FjuV3VPuAohqs9WMas6MeGuu+4iMzPT3C3tiy++oE2bNnTu3LlGx6tKWloa/fr146+//mLOnDl8++23bNy40bymrCPODVijXbt2dOvWjU8++QRQ/waenp4WldnWqmiObM3cua7PowjhzJzt/NrYsWP5+eefOX/+PCdOnGDnzp3VqvIG6+N1REQE+/btY+3atdxyyy1s2bKFIUOGMG7cOKsfq7w58IkTJ7jhhhtISkpiwYIFrFu3jo0bNzJ16lSgbIz/+uuvefnll5kzZw6DBw+2uM1gMBAREVHh3LT0Gu7W/HsbDAZuvPHGCo9ZnerP6j5XIRztjjvu4OTJk7z55pvExMTw6quv0r59+0o75FrDFufrHPE53c3Njbvvvpsvv/ySvLw8tmzZwsWLF6sdV+0xF3vttdf4+++/efbZZ8nNzWXKlCm0b9+e8+fPW+zniL+TUFnfD1o0GOHh4QQEBHDgwIEK91m9ejUDBgzggw8+sNielpZGWFiY+ffmzZuza9cuCgsL8fDwKPdYsbGxbNq0iczMTIsrc0yt0GJjYy32/+abb3jggQcYOXIkixYtqvbzM+nbty8FBQV89tlnXLhwwZzcvu6669i2bRuRkZG0atWKyMjIaj9va5me2/HjxxkwYIB5e1FREadPn6ZTp041eWpCiAbI1vHJGrGxsRw5cqTM9tLx23QVflpamsV+UgkuhGs5duyYRZXI8ePHMRgMxMXFYTAYMBgMnDp1yuLK8OPHj9foeNVhMBg4efKk+QpngKNHjwJUeSxTHKso1oWFheHr64u3t3eV82dQ58ZV7bN69WqaNWvGmjVrLD4Yl27JWNGHZlPFlIeHh7nSRQhhf9WNWdbOo6yNCaB+lo2OjmblypVce+21/PTTTzz33HMW+1TneFXZunUrycnJrFmzhuuuu868/dSpU+Xuf/HiRbKzsy0qUKyNx1Wp6kTi2LFjmTZtGpcuXeLTTz9l6NChDl9SrC7m60LY0rFjxyx+VxSF48ePm89dlZw3XX/99Rb7HjlypMz5vdrM0WzFVI184MCBas+bKos7d911F9OmTeOzzz4jNzcXDw+PMl03qlKdeO3p6cnw4cMZPnw4BoOBiRMn8u677/LCCy+UWyVojW+//Zb8/HzWrl1rUXlduhU5qP9u48aNY8SIEebq6JKaN2/Opk2b6NOnj80uMm3evDlZWVlV/rs1b96cDRs2kJKSUmG1d3WeqxB1JTo6mokTJzJx4kQuX77MVVddxYsvvsirr74KWB97S6rJ+TpbfU4vzZq53Guvvca3337LDz/8QHh4eLnLMlTG2rlYbGwsBw4cQFEUi3GVN3cH6NixIx07duT5559n+/bt9OnTh8WLF/Pf//6X2NhYDAYDx44dM3d0AkhMTCQtLa3Sf5/qjsOec21nIpXeogytVsuIESP49ttv+eOPP8rcrigKbm5uZa6mXLVqVZn1AUeNGkVSUhJvvfVWuccBuPnmm9Hr9WX2+b//+z80Gg1Dhgwxb/vll1+46667uO6661ixYoV5DYaa6NmzJx4eHrz88suEhITQvn17QE2G79y5k59//tmiyhuw+nlbq3v37oSGhrJkyRKKiorM21esWFHrFk1CiIbF1vHJGjfffDO///47O3bsMG/Lzs7mvffeIy4ujnbt2gHFJxJMa2qBetXoe++9Z7exCSEcr/TFiG+++SYAQ4YMMX8Yffvtt8vdp7rHq66S80xFUXjrrbfw8PDghhtuqPR+0dHRdOnSheXLl1ucCDhw4AA//vijeYkda+bPoM6N//rrL3OL3fL2MVW2lIzpu3btsoi1oK7lBWVPUERERNC/f3/effddLl26VOZxrly5UulzFkLUTHVjlrXzKGtjAqixaPTo0Xz77bd8/PHHFBUVlUmyVOd4VSnvWAUFBWVivUlRURHvvvuuxb7vvvsu4eHhdOvWrdqPX5Lp5F7pmGgyZswYNBoNjz/+OCdPnqx2ZZAt1MV8XQhb+uijj8jMzDT/vnr1ai5dumSOc927dyciIoLFixebl1kA+OGHHzh06BBDhw4tc8yaztFs5aqrriI+Pp6FCxeWiR9VVZH7+vpWGHPCwsIYMmQIn3zyCStWrGDw4MHVvrjF2nidnJxs8btWqzVfiGD6d6gqRlr7+Onp6SxdutRiv6ysLG677TYaNWrE8uXLy01c3XHHHej1eubOnVvmtqKiomqNq+Qxd+zYwYYNG8rclpaWZj7POmrUKBRFYfbs2WX2q2z+Xd5zFaIu6PX6Mi32IyIiiImJIT8/v0ax1yQgIICwsDCL83VQ9nN7Sbb8nF5SRZ9vTTp16kSnTp14//33+fLLL7nrrrsqXVK3PNbOxW6++WYuXrzI6tWrzdtycnLKnMfMyMiwyOmAmgDXarXmfwvTOYOFCxda7LdgwQKASv99rB2HiT3n2s5EKr1FuebNm8ePP/5Iv379eOihh2jbti2XLl1i1apV/PrrrwwbNow5c+YwYcIEevfuzf79+1mxYkWZtXjGjh3LRx99xLRp0/j999/p27cv2dnZbNq0iYkTJ3LrrbcyfPhwBgwYwHPPPcfp06fp3LkzP/74I9988w1PPPGEOVly5swZbrnlFjQaDaNHj2bVqlUWj2UKfNby8fGhW7du7Ny5k+HDh5snZddddx3Z2dlkZ2eXSXpb+7yt5enpyaxZs3jssce4/vrrueOOOzh9+jTLli2jefPm0vZCCGE1W8cnazzzzDN89tlnDBkyhClTphASEsLy5cs5deoUX375pfnCpPbt23PNNdcwffp089XVn3/+eZmJoRDCuZ06dYpbbrmFwYMHs2PHDj755BPuvvtuc1vdUaNGsXDhQpKTk7nmmmv4+eefzVcdlzfnqep41vLy8mL9+vWMGzeOnj178sMPP7Bu3TqeffbZMuuylufVV19lyJAh9OrVi/vvv5/c3FzefPNNAgMDmTVrlnm/qubPQUFBPP3006xevZrbb7+d++67j27dupGSksLatWtZvHgxnTt3ZtiwYaxZs4bbbruNoUOHcurUKRYvXky7du3IysoyP563tzft2rVj5cqVtGrVipCQEDp06ECHDh1YtGgR1157LR07duTBBx+kWbNmJCYmsmPHDs6fP89ff/1Vrb+hEKJq1Y1Z1s6jrI0JJnfeeSdvvvkmM2fOpGPHjhYVJTU5XmV69+5NcHAw48aNY8qUKWg0Gj7++OMKE0UxMTG8/PLLnD59mlatWrFy5Ur27dvHe++9V2FnOGt16dIFNzc3Xn75ZdLT09HpdFx//fVEREQAake7wYMHs2rVKoKCgio9wWgvdTFfF8KWQkJCuPbaa5kwYQKJiYksXLiQFi1a8OCDDwKYC0smTJhAv379GDNmDImJibz++uvExcWZW0Wb1HaOZgtarZZ33nmH4cOH06VLFyZMmEB0dDSHDx/mn3/+KTehatKtWzc2bdrEggULiImJIT4+np49e5pvHzt2LKNHjwYoN9lbFWvj9QMPPEBKSgrXX389jRs35syZM7z55pt06dLF/B5QVYwsz0033WSuIH/44YfJyspiyZIlREREWFxYOXv2bA4ePMjzzz/PN998Y3GM5s2b06tXL/r168fDDz/M/Pnz2bdvHzfddBMeHh4cO3aMVatW8frrr5v/VtZ6+umnWbt2LcOGDWP8+PF069aN7Oxs9u/fz+rVqzl9+jRhYWEMGDCAe++9lzfeeINjx44xePBgDAYD27ZtY8CAAUyePNnq5ypEXcjMzKRx48aMHj2azp074+fnx6ZNm9i9ezevvfZatWNvaQ888AAvvfQSDzzwAN27d+eXX34xf04vj60+p5dW2edbk7Fjx/LUU08B1OgCRmvnYg8++CBvvfUWY8eOZc+ePURHR/Pxxx+bE/MmP/30E5MnT+b222+nVatWFBUV8fHHH+Pm5mZeYqFz586MGzeO9957z7w00O+//87y5csZMWKERfff0qwdh4k959pORRGiAmfOnFHGjh2rhIeHKzqdTmnWrJkyadIkJT8/X8nLy1OefPJJJTo6WvH29lb69Omj7NixQ+nXr5/Sr18/i+Pk5OQozz33nBIfH694eHgoUVFRyujRo5UTJ06Y98nMzFSmTp2qxMTEKB4eHkrLli2VV199VTEYDOZ9tmzZogAVfs2cObPaz/Hpp59WAOXll1+22N6iRQsFsBijoihWP2/TWFetWmVx/1OnTimAsnTpUovtb7zxhhIbG6vodDqlR48eym+//aZ069ZNGTx4cLWfkxDCuc2cOVMBlCtXrlhsX7p0qQIop06dUhRFUWJjY5Vx48aZb69OXK5KbGysMnTo0DLbyzvWiRMnlNGjRytBQUGKl5eX0qNHD+W7774rc98TJ04oAwcOVHQ6nRIZGak8++yzysaNGxVA2bJlS7XGJ4SoX0xx6+DBg8ro0aMVf39/JTg4WJk8ebKSm5tr3i87O1uZNGmSEhISovj5+SkjRoxQjhw5ogDKSy+9VO3jWWPcuHGKr6+vcuLECeWmm25SfHx8lMjISGXmzJmKXq8372eao7366qvlHmfTpk1Knz59FG9vbyUgIEAZPny4cvDgwTL7VTZ/NklOTlYmT56sNGrUSPH09FQaN26sjBs3TklKSlIURVEMBoMyb94889ywa9euynfffaeMGzdOiY2NtXi87du3K926dVM8PT3LzIdPnDihjB07VomKilI8PDyURo0aKcOGDVNWr15t3sc0Zy0Zh8t7nJrOtYVoCKyNWaXnbopi3TyqOjHBtH+TJk0UQPnvf/9b7u3WHq/0a7/0fFRRFOW3335TrrnmGsXb21uJiYlR/v3vfysbNmwoE1v69euntG/fXvnjjz+UXr16KV5eXkpsbKzy1ltvWTxmeZ+ZTX/jksr7ey5ZskRp1qyZ4ubmVu4c84svvlAA5aGHHirzd7GG6T2lNNNzK630nNqW83UhbKn0a7uic1yfffaZMn36dCUiIkLx9vZWhg4dqpw5c6bM8VauXKl07dpV0el0SkhIiHLPPfco58+ft9jHFnO00jHKmlhR3txHURTl119/VW688UbF399f8fX1VTp16qS8+eablR778OHDynXXXad4e3srQJmYlJ+frwQHByuBgYHVnsMqivXxevXq1cpNN92kREREKJ6enkrTpk2Vhx9+WLl06ZLF8SqKkRV9/lcURVm7dq3SqVMnxcvLS4mLi1Nefvll5cMPP7T4/zJu3LgKz9WW/pu89957Srdu3RRvb2/F399f6dixo/Lvf/9buXjxonmf6pyPyMzMVKZPn660aNFC8fT0VMLCwpTevXsr//vf/5SCggLzfkVFRcqrr76qtGnTRvH09FTCw8OVIUOGKHv27KnWcxWiLuTn5ytPP/200rlzZ3OM6ty5s/L2229b7GdN7C0vluXk5Cj333+/EhgYqPj7+yt33HGHcvny5QpjrDWf062JvdX9fKsoinLp0iXFzc1NadWqlXV/vFKqMxc7c+aMcssttyg+Pj5KWFiY8vjjjyvr16+3eB4nT55U7rvvPqV58+aKl5eXEhISogwYMEDZtGmTxbEKCwuV2bNnm/NjTZo0UaZPn67k5eVZ7FfTcZjua81cuyHQKEoVvVqEEA5nMBgIDw9n5MiRLFmypK6HI4QQQghRoVmzZjF79myuXLlS7baN+/bto2vXrnzyySfcc889tT6eEEIIUZFvvvmGESNG8Msvv5Tp6iaEqNjWrVsZMGAAq1atqnY1bkXGjx/P6tWrq91hwpkUFRURExPD8OHDy6wfK4QQovqSkpKIjo5mxowZvPDCCw5/fNP74ZYtW+jfv7/DH19YR9b0FqKO5eXllWn/9tFHH5GSkiLBUwghhBAuIzc3t8y2hQsXotVque666+pgREIIIRqSJUuW0KxZM6699tq6HooQogH4+uuvuXLlCmPHjq3roQghhEtYtmwZer2ee++9t66HIuoxWdNbuJyEhIRKb/f29iYwMNBBo6nazp07mTp1KrfffjuhoaHs3buXDz74gA4dOnD77bfX9fCEEC7kypUr6PX6Cm/39PQkJCTEgSMSQjQkr7zyCnv27GHAgAG4u7vzww8/8MMPP/DQQw/RpEmTah0rPT293CR6SVFRUbUZrhBCCBfx+eef8/fff7Nu3Tpef/11NBqNxe3yniKEsKVdu3bx999/M3fuXLp27Uq/fv0sbi8oKCAlJaXSYwQGBuLt7W3PYQohhNP46aefOHjwIC+++CIjRowgLi7O4vbc3FzS09MrPUZISAienp52HKWoLyTpLVxOdHR0pbePGzeOZcuWOWYwVoiLi6NJkya88cYbpKSkEBISwtixY3nppZckEAshbOrqq6/mzJkzFd7er18/tm7d6rgBCSEalN69e7Nx40bmzp1LVlYWTZs2ZdasWTz33HPVPtbjjz/O8uXLK91HVnESQggBMGbMGPz8/Lj//vuZOHFimdvlPUUIYUvvvPMOn3zyCV26dCn3/OP27dsZMGBApcdYunQp48ePt88AhRDCycyZM4ft27fTp08f3nzzzTK3r1y5kgkTJlR6DGlJ3nDImt7C5WzatKnS22NiYmjXrp2DRiOEEPXHb7/9VmkVS3BwMN26dXPgiIQQomYOHjzIxYsXK91n4MCBDhqNEEIIZybvKUIIR0pNTWXPnj2V7tO+ffsqi3qEEEKoLl26xD///FPpPt26dSM4ONhBIxJ1SZLeQgghhBBCCCGEEEIIIYQQQgghnJa2rgcghBBCCCGEEEIIIYQQQgghhBBC1FSDW9PbYDBw8eJF/P390Wg0dT0cIUQtKYpCZmYmMTExaLVyHY+tScwUwrVIzLQviZlCuBaJmfYlMVMI1yIx074kZgrhWiRm2pfETCFcS3ViZoNLel+8eJEmTZrU9TCEEDZ27tw5GjduXNfDcDkSM4VwTRIz7UNiphCuSWKmfUjMFMI1Scy0D4mZQrgmiZn2ITFTCNdkTcxscElvf39/QP3jBAQE1PFohBC1lZGRQZMmTcyvbWFbEjOFcC0SM+1LYqYQrkVipn1JzBTCtUjMtC+JmUK4FomZ9iUxUwjXUp2Y2eCS3qZ2FgEBARLwhHAh0qrGPiRmCuGaJGbah8RMIVyTxEz7kJgphGuSmGkfEjOFcE0NNWb+8ssvvPrqq+zZs4dLly7x1VdfMWLECPPt48ePZ/ny5Rb3GTRoEOvXr7fq+BIzhXBN1sRMWTBCCCGEEEIIIYQQQgghhBBC2F12djadO3dm0aJFFe4zePBgLl26ZP767LPPHDhCIYSzanCV3kIIIYQQQgghhBBCCCGEEMLxhgwZwpAhQyrdR6fTERUV5aARCSFchVR6CyGEEEIIIYQQQgghhBBCiHph69atRERE0Lp1ax599FGSk5Mr3Dc/P5+MjAyLLyFEwySV3g6SlV+Eu1aDl4dbXQ+lwdDr9RQWFtb1MEQteXh44OYmr5v6Tl5vrsPT0xOttoJr4gqyjTv5Om5AQghhI0V6A1n5RQT5eNb6WPK+5xpknikarPwscPMAd51DHk5ipmuQmOk8UrILuJSeS7CPJzFB3nU9HFFNEjNdR6XnV0SlBg8ezMiRI4mPj+fEiRM8++yzDBkyhB07dpT7XjR//nxmz55do8dKyS4gIT2PIB8PiZlOSGKm67BVzJSktwPkF+m5/n9b8fdyZ9O0flYtti5qTlEUEhISSEtLq+uhCBsJCgoiKipKXjv1kLzeXI9WqyU+Ph5Pz1JJIYMe3u4FigGm7AM3mUIIIZzLxBV72XrkClue7k+jGp7MkPc91yPzTNHg5KXD273BOxge2QZ2/L8vMdP1SMx0Dgs2HuGTnWeZcn0Lpt3Uuq6HI6wkMdP1VHh+RVTprrvuMv/csWNHOnXqRPPmzdm6dSs33HBDmf2nT5/OtGnTzL9nZGTQpEkTqx7rrZ+O8+Fvp3ikX3OeGdKm9oMXDiEx0/XYKmbKGWsHSEzP53Km+pVbqMfHU/7s9mQKdhEREfj4+MiHMSemKAo5OTlcvnwZgOjo6DoekShNXm+uxWAwcPHiRS5dukTTpk0t/z1zUyHtjPpzTjL4R9bNIIUQoob+Op9Ggd7A4UsZNU56y/ue65B5pmiwjqyHjPPqV24q+ITY7aEkZroOiZnOJcTY1SY1RyrfnInETNdS6fkVUW3NmjUjLCyM48ePl5v01ul06HQ162AT6O0BQHquxExnIjHTtdgyZkr21QFKBsyM3CJJetuRXq83B7vQ0NC6Ho6wAW9v9aT05cuXiYiIkHZq9Yi83lxTeHg4Fy9epKioCA8Pj+IbclOLf85Lk6S3EMKpKIpCarY6J6/pCWB533M9Ms8UDdLBr4t/Tj9vt6S3xEzXIzHTeZiWcknJKajjkQhrScx0TRWeXxHVdv78eZKTk+1y0VWQjynpLTHTWUjMdE22ipmyqIQDpJUImBl5csWQPZnWb/Dx8anjkQhbMv17yvoc9Yu83lyTqYWMXq+3vKFk0rvkz0II4QRyCvQU6A0ApNXwBLC877kmmWeKBiUvA45vLv49/bzdHkpipmuSmOkcgn3VE8U1nfMIx5OY6ZoqPL8iyMrKYt++fezbtw+AU6dOsW/fPs6ePUtWVhZPP/00O3fu5PTp02zevJlbb72VFi1aMGjQIJuPRSq9nY/ETNdkq5gpJccOYFnpLcHTEaSdhWuRf8/6Tf59XEuF/54WSe80h4xFCCFsJSW7+KRvai1PAMv7nmuRf0/RoBzdAPr84t/tmPQ2kdeYa5F/T+dgqvQ2dbkRzkNeY65F/j0r9scffzBgwADz76b1uMeNG8c777zD33//zfLly0lLSyMmJoabbrqJuXPn1riFeWUCfUwXCknMdDbyGnMttvr3lKS3A5QMmFLpLYQQwinlpBT/nJdWZ8MQQoiaKJnolvUthRANlqm1udYDDIXqut5CCJcTbEx6S6W3EKK+6t+/P4qiVHj7hg0bHDYWqfQWwrVIe3MHKL2mtxCOEhcXx8KFC+t6GEI0CC7/epNKbyGEEyuZ6JYTwLbh8u97Qria/Cw4vkn9ucMo9bsDKr2FSmKmcKRgY9WiXOgnnJXETOFIQaakt8RM4aQkZlqSpLcDlGxpLlcMifJoNJpKv2bNmlWj4+7evZuHHnqoVmPr378/TzzxRK2OIUR9Iq+3GpI1vYUQTiy1ZHvzBtbqU973hBAAHNsARXkQ0gxaD1a3SdK7DImZwhWY2pvnFurJK5S1hIX9SMwUrsBU6Z2ZX0SR3lDHoxGuTGKmY0h7cwewaG8uSW9RjkuXLpl/XrlyJTNmzODIkSPmbX5+fuafFUVBr9fj7l71yzc8PNy2AxXCBcjrrYZKJrqlvbkQwsnYck1vZyPve0IIAA5+o35vdysENlV/lqR3GRIzhSsI8HLHTatBb1BIyykkKtCtrockXJTETOEKTElvgIy8IkJ8PetwNMKVScx0DKn0dgCL9uayprcoR1RUlPkrMDAQjUZj/v3w4cP4+/vzww8/0K1bN3Q6Hb/++isnTpzg1ltvJTIyEj8/P66++mo2bdpkcdzSrS00Gg3vv/8+t912Gz4+PrRs2ZK1a9fWauxffvkl7du3R6fTERcXx2uvvWZx+9tvv03Lli3x8vIiMjKS0aNHm29bvXo1HTt2xNvbm9DQUAYOHEh2dnatxiNEVeT1VsPXm7Q3F0I4sZKJ7rQG1rZO3vdknikEBdlw9Ef153YjILCx+nPmJdDLEmwlScyUmOkKNBpNiRbnDetiP+FYEjMlZroCdzctfjo1sShdeoU9Scx0TMyUSm8HSMstnmDKmt6OpygKuXXQzsnbww2NRmOz4z3zzDP873//o1mzZgQHB3Pu3DluvvlmXnzxRXQ6HR999BHDhw/nyJEjNG3atMLjzJ49m1deeYVXX32VN998k3vuuYczZ84QEhJS7THt2bOHO+64g1mzZnHnnXeyfft2Jk6cSGhoKOPHj+ePP/5gypQpfPzxx/Tu3ZuUlBS2bdsGqFc2jRkzhldeeYXbbruNzMxMtm3bhqIoNf4bibpXV683sO1rTl5v5ZD25kIIJ1byhG9qTgGKotjkPUPmmZZc6n1PCFdybCMU5UJQLER3BkUBrQcYCtXEd1AThwxDYqYliZnCnoJ8PEnKKrBY4kU4F4mZliRmCnsK9PYgK7+ItJwCwLeuhyNqQM5JW2rIMVOS3g6QXiLRLZXejpdbqKfdjA0Of9yDcwbh42m7l9icOXO48cYbzb+HhITQuXNn8+9z587lq6++Yu3atUyePLnC44wfP54xY8YAMG/ePN544w1+//13Bg8eXO0xLViwgBtuuIEXXngBgFatWnHw4EFeffVVxo8fz9mzZ/H19WXYsGH4+/sTGxtL165dATXgFRUVMXLkSGJjYwHo2LFjtccg6pe6er2BbV9z8norh7Q3F0I4sZLreOcXGcgt1NvkPUPmmZZc6n1PCFdy8Gv1e7tbQaNRvwIbQepptcW5g5LeEjMtScwU9lRc6S3nIZ2VxExLEjOFPQV6e3AhLVcqvZ2YnJO21JBjprQ3d4AMaW8ubKB79+4Wv2dlZfHUU0/Rtm1bgoKC8PPz49ChQ5w9e7bS43Tq1Mn8s6+vLwEBAVy+fLlGYzp06BB9+vSx2NanTx+OHTuGXq/nxhtvJDY2lmbNmnHvvfeyYsUKcnJyAOjcuTM33HADHTt25Pbbb2fJkiWkpjbc6tFffvmF4cOHExMTg0aj4euvv67yPlu3buWqq65Cp9PRokULli1bVmafRYsWERcXh5eXFz179uT333+3/eBdkLzeyiHtzYUQTiylVJWTnAC2JO97Qriwgpzi1ubtRxRvDzQmumVd72qTmCnqvUt/M1j/M+01p6S9uahzEjOFMwgyXigkSW9R1yRm1p5UejtAWo60N69L3h5uHJwzqE4e15Z8fS1bqzz11FNs3LiR//3vf7Ro0QJvb29Gjx5NQUHlH2g8PDwsftdoNBgMBpuO1cTf35+9e/eydetWfvzxR2bMmMGsWbPYvXs3QUFBbNy4ke3bt/Pjjz/y5ptv8txzz7Fr1y7i4+PtMp76LDs7m86dO3PfffcxcuTIKvc/deoUQ4cO5ZFHHmHFihVs3ryZBx54gOjoaAYNUv+/r1y5kmnTprF48WJ69uzJwoULGTRoEEeOHCEiIsIuz6OuXm+mx7YVeb2VQyq9hRBOrPQJ39TsAhoFedf6uDLPtORS73tCuIrjm6AwGwKbQsxVxdtN63qnn3PYUCqNmZmJYCiCgBi1Et3Gj2tLEjNFvffnx9x/5T3y3G4hLaduPp+L2pN5piWJmcKeAr0l6e3s5Jy0pYYcMyXpbWeFegPZBcVrCUilt+NpNBqbtuWpL3777TfGjx/PbbfdBqhX/Zw+fdqhY2jbti2//fZbmXG1atUKNzc12Lu7uzNw4EAGDhzIzJkzCQoK4qeffmLkyJFoNBr69OlDnz59mDFjBrGxsXz11VdMmzbNoc+jPhgyZAhDhgyxev/FixcTHx/Pa6+9Bqj/Fr/++iv/93//Z056L1iwgAcffJAJEyaY77Nu3To+/PBDnnnmGds/CeT1Zk91+noz6CEvvfj33FR1LUgbn5AUQgh7MSW9NRo1fKXZqNJb3vfsR+aZwm4yE0HRq8nVhuDgN+r3drdYzt3MSW/HVXpXGDMNesg3Vp4YAsA72GFjsgWJmaLe8QkDIJhMTkh3G6cl80z7kZgpSjNVetvqc6JwPImZ9uNsMdP1/hfUM6WvDsqQq4WEjbRs2ZI1a9YwfPhwNBoNL7zwgt2u1rly5Qr79u2z2BYdHc2TTz7J1Vdfzdy5c7nzzjvZsWMHb731Fm+//TYA3333HSdPnuS6664jODiY77//HoPBQOvWrdm1axebN2/mpptuIiIigl27dnHlyhXatm1rl+fganbs2MHAgQMttg0aNIgnnngCgIKCAvbs2cP06dPNt2u1WgYOHMiOHTscOVSX0OBfb3npgFL8u74ACnPB08c2T1oIIexIURTzmt6Ngrw5n5orrT6r0ODf94TrOrYRvhgL7jqYdhg8vOp6RPZVmAdH16s/txtheVtAI/V7fWhvri8RkzMTwSvIqS6ulJgp6h3fUABCNZn8IXMeUc9IzBT1UYBUeot6SmJm9UnS287KJL3zilAUBY0TfYAT9dOCBQu477776N27N2FhYfznP/8hIyPDLo/16aef8umnn1psmzt3Ls8//zxffPEFM2bMYO7cuURHRzNnzhzGjx8PQFBQEGvWrGHWrFnk5eXRsmVLPvvsM9q3b8+hQ4f45ZdfWLhwIRkZGcTGxvLaa69Vq9q5IUtISCAyMtJiW2RkJBkZGeTm5pKamopery93n8OHD1d43Pz8fPLz882/2+v/lLNp8K83U2tzTz812a3o1RbnkvQWQjiB7AI9BXr1Q2F8mC/nU3Mtlh8SZTX49z3hmv76HL6ZpLbQLsyBtLMQ3qquR2VfJzZDQRYENIbGlusDmtf0zrjg+HGVVpRf4udcyMsA78C6G081ScwU9Y6x0jtEkyFVi6LekZgp6qMgb09AKr1F/SMxs/o0iqIoVe/mOjIyMggMDCQ9PZ2AgAC7P97es6mMfHs7YX6eJGWpJ9cOzB6En06uN7CHvLw8Tp06RXx8PF5eLn7VfgNS2b+ro1/TjqDRaPjqq68YMWJEhfu0atWKCRMmWFRyf//99wwdOpScnBxSU1Np1KgR27dvp1evXuZ9/v3vf/Pzzz+za9euco87a9YsZs+eXWZ7eX9feb25pnL/Xc/vgfevV9eCLMyGnGR4dDtEtq/bwYpqc8WYWZ/I37d+OpeSQ99XtqBz13Jb10Z8vvsc025sxZQbWlbrOPK+55oa2jyzPnHo3/e3N2DjC5bb/rUGWtxg38eta2segr9XwjUTYfB8y9suH4a3e4JXIDxz1uYPXa2YmZUIGReLf/fwgbBWTlXt3VBIzKw71fr7nv4Vlg3lhCGap6I+4KuJfRwzSFFjMs90TRIz6051/76f7jrLs1/tZ2DbSN4f173K/UXdkpjpmmwVM7X2HKSAdOPVQZEBXni4qR/YpMW5EKK2oqKiSExMtNiWmJhIQEAA3t7ehIWF4ebmVu4+UVFRFR53+vTppKenm7/OnTtnl/ELJ2Oq9PYOUttNAuSm1dFghBCiekytzIN9PAn29bTYJoRwcQYDbHiuOOHdazK0uFH9Od3F57lF+XDkB/Xn0q3NAQKN7c3z0tXK6rpUZIzJPqGAVq3Ez8+s0yEJ4dSMld6hmgxSs2XOI4QQVTGt6Z2eKzFTCGcnSW87M7U3D/LxIMBLDZ4ZeZL0FkLUTq9evdi8ebPFto0bN5qruj09PenWrZvFPgaDgc2bN1tUfpem0+kICAiw+BKiOOkdrH6B2t5cCCGcQIrxZG+wryfBxpMZ0rZOiAZAXwhfPwI73lJ/v3EuDHoRgpqqv6e5eNL7xBbIzwD/aGh8ddnbdf7FFzPWdYtzvbG9uYePeS1ishKgYTUmFMJ2fNWkd5Amm8zs3DoejBBC1H+Bsqa3EC5Dkt52ZlovMNDbgwBj8MzILarLIQkh6qGsrCz27dvHvn37ADh16hT79u3j7Fm11eD06dMZO3asef9HHnmEkydP8u9//5vDhw/z9ttv88UXXzB16lTzPtOmTWPJkiUsX76cQ4cO8eijj5Kdnc2ECRMc+tyEC7BIegcZt6XV1WiEsNqiRYuIi4vDy8uLnj178vvvv1e6/8KFC2ndujXe3t40adKEqVOnkpeX56DRCnsxJbhDfD0I8pFKbyEahPws+PROtbW31h1uexf6TFFvCzKuZZ1+vu7G5wgHv1a/t70FtBWc+glsrH6v67+FaU1vdx34RQAaKMhW1yMXQlSfdzAKardJbX4qeoNcQCKEEJUxJb3l4mghnJ8sLG1n6cYEd6C3JwFe6p9b2psLIUr7448/GDBggPn3adOmATBu3DiWLVvGpUuXzAlwgPj4eNatW8fUqVN5/fXXady4Me+//z6DBg0y73PnnXdy5coVZsyYQUJCAl26dGH9+vVERkY67okJ11Ay6a11t9wmRD21cuVKpk2bxuLFi+nZsycLFy5k0KBBHDlyhIiIiDL7f/rppzzzzDN8+OGH9O7dm6NHjzJ+/Hg0Gg0LFiyog2cgbMVc6e3jSbAp6S2tPoVwXdlJsOJ2uLhXrRy+4yNoeWPx7YGmpLcLV3oXFcDh79Wf24+oeL/AxpB4oG6T3oqiVuUDuOnAzVNtc56TBJmJakW6EKJ6tG7qZ7fcFELIID23kBDjEi9CCCHKkkpvIVyHJL3tzBQoLSq9pb25EKKU/v37o1TSvm/ZsmXl3ufPP/+s9LiTJ09m8uTJtR2eaOjKS3pLe3NRzy1YsIAHH3zQ3N1i8eLFrFu3jg8//JBnnnmmzP7bt2+nT58+3H333QDExcUxZswYdu3a5dBxC9uzWNPb2N48Va7gF8I1pZ6Bj2+DlBPgHQL3rILG3S33aQhJ75NbIT8d/CKhSc+K96sPld76AkABNOCmxmj8IiAnGQoy1YpvT9+6G58QNnThwgX+85//8MMPP5CTk0OLFi1YunQp3bt3r/rO1aTxDVOT3ppMUnMKJOkthBCVMK3pnV9kIK9Qj5eHWx2PSAhRU9Le3M7Scku0Nzet6S1XDAkhhHAm0t5cOJmCggL27NnDwIEDzdu0Wi0DBw5kx44d5d6nd+/e7Nmzx9wC/eTJk3z//ffcfPPNFT5Ofn4+GRkZFl+i/im5pre0NxfChWUnwwc3qQnvwCZw/49lE95Q3N484yIY9I4do6Mc/Eb93vYWteKzIvUh6W1ube4JGo3xZ5067wTITKibcQlhY6mpqfTp0wcPDw9++OEHDh48yGuvvUZwcLB9HtBHXdc7lAzz0otCCCHK56dzx02rzkOk2lsI5yaV3nZmSnAH+XgQ4G1sb54na3oLIYRwIiWT3hqt5TYh6qGkpCT0en2Z5RwiIyM5fPhwufe5++67SUpK4tprr0VRFIqKinjkkUd49tlnK3yc+fPnM3v2bJuOXdieeU1vHw9zpXdmXhFFegPubnINsBAu4+gPkJUAQbFw33oIiCl/P79ItXONoUhNqAY2cuw47U1fCIe/U39ud2vl+wbWg/XN9cakt5vOcrt/JOSmQH4GFOSAp4/jxyaEDb388ss0adKEpUuXmrfFx8fb7wF9QwEI0WSQmi0JHCGEqIxGoyHQ24OU7ALScgqJDPCq6yEJIWpIzvLYmekkm1R6CyGEcFrlVXpLe3PhYrZu3cq8efN4++232bt3L2vWrGHdunXMnTu3wvtMnz6d9PR089e5cy7cKteJlaz0Nq3VBpAmc3IhXEvCAfV7m6EVJ7xBrXwOMCa6XbHF+amf1XmabzjE9q583/rwdygyVqC6l0p6u3sVV3tnSbW3cH5r166le/fu3H777URERNC1a1eWLFlS4f617ihkrPQ2tTcXQghROVnXWwjXIElvOzMFyaASa3pL4BRCCOFULJLexpOP0t5c1GNhYWG4ubmRmJhosT0xMZGoqKhy7/PCCy9w77338sADD9CxY0duu+025s2bx/z58zEYDOXeR6fTERAQYPEl6p+Sa3q7u2kJ8FK7L0mrTyFcTKIx6R3Zoep960OFs72YW5sPr7y1ORS3N8+4CBW819mdudK7nPWG/YwdW/LSoTDXcWMSwg5OnjzJO++8Q8uWLdmwYQOPPvooU6ZMYfny5eXuP3/+fAIDA81fTZo0qd4D+hqT3kjSWwghrGFKesvnRCGcW71Lel+4cIF//etfhIaG4u3tTceOHfnjjz/MtyuKwowZM4iOjsbb25uBAwdy7NixOhxx5UwJ7oASSe+MPEl6C/vo378/TzzxRF0PQ4gGoUG93komvb2C1J+l0lvUY56ennTr1o3NmzebtxkMBjZv3kyvXr3KvU9OTg5areXU2M1NTRYoimK/wQq7M53oDfH1tPiemiNz8upoUO97wvkoCiT8rf4c1bHq/U3reqedtd+Y6oK+EA5Z2docwD9aXbrGUAjZl+07topUVOkN4OENXoHqz1mJZW+vxyRmitIMBgNXXXUV8+bNo2vXrjz00EM8+OCDLF68uNz9a91RyFzpnSFzHlHvScwU9YFUegtnITGzcvUq6Z2amkqfPn3w8PDghx9+4ODBg7z22msEBweb93nllVd44403WLx4Mbt27cLX15dBgwaRl5dXhyOvmKltotre3Limd66s6S0sDR8+nMGDB5d727Zt29BoNPz999+1fpxly5YRFBRU6+MI4czk9VZNilJ+e3NZ01vUc9OmTWPJkiUsX76cQ4cO8eijj5Kdnc2ECRMAGDt2LNOnTzfvP3z4cN555x0+//xzTp06xcaNG3nhhRcYPny4OfktnI+iKOZ1LIONye4gH2PSO7thXMEv73uiQUg/r1YDa90hvHXV+5sqnF2tvfmZ39R1sH1CIfbaqvd3cwd/Yyv4uqh6V5SK1/Q28TN2aMlNhSL7n/eRmCnsJTo6mnbt2llsa9u2LWfPln/xTa07ChkrvUPJlKpFYTcSM4UrCfKRpLewL4mZjuFe1wMo6eWXX6ZJkyYsXbrUvC0+Pt78s6IoLFy4kOeff55bb1WvWv7oo4+IjIzk66+/5q677nL4mCuTV6inoEhtERbkI5XeomL3338/o0aN4vz58zRu3NjitqVLl9K9e3c6depUR6MTwrXI662a8jNB0as/ewcBxorX3DT1RKVGU0cDE6Jyd955J1euXGHGjBkkJCTQpUsX1q9fT2Sk2ir17NmzFpXdzz//PBqNhueff54LFy4QHh7O8OHDefHFF+vqKQgbyC7QU6BX5+PBxpMYpu9pDaTqSd73RINgam0e1rr8iuHSXLW9+SXjSbL469SEtjUCG0PGefUCgMbd7Te28hiKQDG2VS+vvTmApw/oAiA/AzITITjWrkOSmCnspU+fPhw5csRi29GjR4mNtdP/aZ9QwFjpnd0w5jzC8SRmClcild7C3iRmOka9qvReu3Yt3bt35/bbbyciIoKuXbuyZMkS8+2nTp0iISGBgQMHmrcFBgbSs2dPduzYURdDrpQpQLppNfjp3AnwkqS3KN+wYcMIDw9n2bJlFtuzsrJYtWoV999/P8nJyYwZM4ZGjRrh4+NDx44d+eyzz2w6jrNnz3Lrrbfi5+dHQEAAd9xxh8V6qH/99RcDBgzA39+fgIAAunXrZl5+4MyZMwwfPpzg4GB8fX1p374933//vU3HJ4QtyOutmkwV3e7exhaTQervih4KsuzzmELYyOTJkzlz5gz5+fns2rWLnj17mm/bunWrRRxwd3dn5syZHD9+nNzcXM6ePcuiRYsa9NWxrsBUza1z1+LtoVbsB5sqvRtI1ZO874kGIWG/+t2a1uZQXOmd5mKV3ikn1e+hLay/T2Aj9XtdXACgN8ZhrQdoKzk95V+y2jvfrkOSmCnsZerUqezcuZN58+Zx/PhxPv30U9577z0mTZpknwf0LdnevGHMeYTjScwUriTIu2FdHC0cT2KmY9SrSu+TJ0/yzjvvMG3aNJ599ll2797NlClT8PT0ZNy4cSQkJACYK3RMIiMjzbeVlp+fT35+8YeijIwM+z2BUkwBMtDbA41GQ6C3tDevE4oChTmOf1wPH6srIN3d3Rk7dizLli3jueeeQ2O836pVq9Dr9YwZM4asrCy6devGf/7zHwICAli3bh333nsvzZs3p0ePHrUersFgMAe7n3/+maKiIiZNmsSdd97J1q1bAbjnnnvo2rUr77zzDm5ubuzbtw8PD3VCMGnSJAoKCvjll1/w9fXl4MGD+Pn51XpcwsnU1esNrH7NyeutmnJT1O/exqVGPLzVShx9gXriUedvn8cVQggbKLmetynem9qbp9jiBLDMM63iVO97wjmZk94drNs/qKn6Pf2ca3WuMSW9Q5pZfx9zq/cLth9PaaVjZk4qFOaCpxsUZFd+X407FGRC6uniMVtLYqbEzHrg6quv5quvvmL69OnMmTOH+Ph4Fi5cyD333GOfBzSu6R1MFunZ9r1YRNiJzDOtIjFT2EqAVHo7NzknbZWGEDPrVdLbYDDQvXt35s2bB0DXrl05cOAAixcvZty4cTU65vz585k9e7Yth2m19BLreQPmSu/MvEIMBgWt1kU+WNd3hTkwL8bxj/vsRfD0tXr3++67j1dffZWff/6Z/v37A2pbi1GjRhEYGEhgYCBPPfWUef/HHnuMDRs28MUXX9gk4G3evJn9+/dz6tQpmjRR2/199NFHtG/fnt27d3P11Vdz9uxZnn76adq0aQNAy5Ytzfc/e/Yso0aNomNHtbqiWbNqnGgRrqOuXm9QrdecvN6qoeR63qBO4ryCIPuy2uLcdNJYCCHqoRRjpbcp0Q0l2pvbotWnzDOt4lTve8I5mdqbR1qZ9A4wVjcXZEFeWvE8x9mlnFK/VyvpbWr17oCqd4mZVpGY6bqGDRvGsGHDHPNgxvbm7hoD+pxUxzymsC2JmVaRmClsxfSZMU2S3s5JzklbpSHEzHrV3jw6Opp27dpZbGvbti1nz54FICpKbWlVstTe9LvpttKmT59Oenq6+evcOce1L0szVo+YrhIyfTcokF0g1d7CUps2bejduzcffvghAMePH2fbtm3cf//9AOj1eubOnUvHjh0JCQnBz8+PDRs2mF8ftXXo0CGaNGliDnYA7dq1IygoiEOHDgEwbdo0HnjgAQYOHMhLL73EiRMnzPtOmTKF//73v/Tp04eZM2fy999/22RcQtiDvN6qoXTSu+TPeWn2e1whhLCB4kpvD/O2IN+G1d4c5H1PuLj8zOIKZ2vbm3v6mKsgXWZd76J8dW1uqGGlt4v8HWxAYqZwCe6eGDzVrlxuuckoilLHAxKuSmKmcBWyprdwBImZ9levKr379OnDkSNHLLYdPXqU2NhYAOLj44mKimLz5s106dIFUNuV79q1i0cffbTcY+p0OnQ6nV3HXRFTgDStB6Fz1+LppqVAbyAjrwh/L4/K7i5sxcNHvdqmLh63mu6//34ee+wxFi1axNKlS2nevDn9+vUD4NVXX+X1119n4cKFdOzYEV9fX5544gkKChx3wnbWrFncfffdrFu3jh9++IGZM2fy+eefc9ttt/HAAw8waNAg1q1bx48//sj8+fN57bXXeOyxxxw2PlEP1NXrzfTY1SCvNyuZk95BxdtMP+em2f7xhBDChlKN1dzB5VV622KtNpln2ky9ed8TzifxoPrdP9q8hq1VgppATpK6rre1yfL6LO0sKAbw8AXfcOvv58ikd+mYmXQcCrMhKNZyrlmRzEuQdRl8Qoor1K193GqSmClcgm8YFGTib0gnp0CPr65enQYWVZF5ps1IzBTWCDJ+TkxvQBdHuxQ5J20zzh4z61Wl99SpU9m5cyfz5s3j+PHjfPrpp7z33ntMmjQJAI1GwxNPPMF///tf1q5dy/79+xk7diwxMTGMGDGibgdfjtLtzTUajbnaO0OuGHIcjUZtL+HorxqsC3fHHXeg1Wr59NNP+eijj7jvvvvMazv89ttv3HrrrfzrX/+ic+fONGvWjKNHj9rsz9S2bVvOnTtn0Q3h4MGDpKWlWXRgaNWqFVOnTuXHH39k5MiRLF261HxbkyZNeOSRR1izZg1PPvkkS5Yssdn4hJOoq9dbDV5z8nqzUnmV3l5BlrcJIUQ9VXJNbxNTAtwmld4yz7SKU73vCeeTaFzP29rW5iauVuFccj3v6sQI098hJ0ldX9ueSsdMrRY8vNWEtzWxzztE3R+txEwkZoqqaYwXAoVoMsxLvggnIvNMq0jMFLYild5OTs5JW6UhxMx6dYnf1VdfzVdffcX06dOZM2cO8fHxLFy4kHvuuce8z7///W+ys7N56KGHSEtL49prr2X9+vV4eXnV4cjLZ6709imu6A7wdicpK1+CpyiXn58fd955J9OnTycjI4Px48ebb2vZsiWrV69m+/btBAcHs2DBAhITE8ssCVAVvV7Pvn37LLbpdDoGDhxIx44dueeee1i4cCFFRUVMnDiRfv360b17d3Jzc3n66acZPXo08fHxnD9/nt27dzNq1CgAnnjiCYYMGUKrVq1ITU1ly5YttG3btrZ/EiHsRl5vVjJVc1u0Nw9Sv0t7cyFEPVfemt6muXmqLSq9nYi87wmXlWBMele3Wjuwqfo93TatAuucOekdX737eQWp1eGF2ZB+AcJa2Hxo5TLowWBc9s3dyu58Ht7q96JcUJQaJWasJTFTuAKNjynpnUlaTiFNQup4QMJlScwUriCoRNLbYFDQau03zxANm8RM+6pXSW+AYcOGMWzYsApv12g0zJkzhzlz5jhwVDVTutIbIMBLKr1F5e6//34++OADbr75ZmJiYszbn3/+eU6ePMmgQYPw8fHhoYceYsSIEaSnp1fr+FlZWXTt2tViW/PmzTl+/DjffPMNjz32GNdddx1arZbBgwfz5ptvAuDm5kZycjJjx44lMTGRsLAwRo4cyezZswE1kE6aNInz588TEBDA4MGD+b//+79a/jWEsC95vVmhsjW9pb25EKKeM1d6l7gI1VTpnZZTgKIo5iuqGwJ53xMuKeGA+j2qhpXeaecq389ZlKz0rg6NRv1bJB1R1wR3VNJbb6w61biB1spTU+5egEZt464vsD5ZXkMSM4XT8w0FIIRM23S4EaISEjOFszN16DUokFVQZM7jCGEPEjPtR6MoilLXg3CkjIwMAgMDSU9PJyAgwK6PNeWzP1n710WeH9qWB/qqHzzHfvg7vxy9wv9u78zobo3t+vgNUV5eHqdOnSI+Pr5eVv+Lmqns39WRr+mGqLK/r7zeXFOZf9fPxsCR72HYQug+Qd1py3z4+SXoNgGGL6zL4YpqkphpX/L3rX/GvLeTHSeTef2uLtzapREAuQV62s5YD8D+WTfhb+XJDHnfc00yz6w7Nvn7GvQwvzEU5sCk3RDeyvr7HvoWVv4LGnWHBzfX7PHrk09GwfFNMPwN6Dauevf9eCSc2Ay3LoKu/7LJcKqMmblpkHpKXQMxvLX1B758WK30Do63bh1wYVMSM+tOjf6+G2fCbwv5sGgwoaMXmOdCov6ReaZrkphZd2r6923zwg/kFRrY9u8BNAmp/vr2wjEkZromW8XMerWmt6spv9JbvYJZKr2FEEI4hXIrvYPU79LeXAhRz5mqmoJLtDf39nTDy0P9GJTWwFqcC1GZRYsWERcXh5eXFz179uT333+vdP+FCxfSunVrvL29adKkCVOnTiUvL89BozVKOakmvN29IbR59e5rXtO7gVd6Q92sb67PV7+7eVa+X2mmFuf2Xn9cCFdQYk1vmfMIIUTVZF1vIZyfJL3tqNykt/HnjDwJnEIIIZyAtDcXQjgx05reIb6WSRVTElxafQqhWrlyJdOmTWPmzJns3buXzp07M2jQIC5fvlzu/p9++inPPPMMM2fO5NChQ3zwwQesXLmSZ5991rEDN63nHdkOtG7Vu69pTe+sRCjKt+24HE1fBGnGtclrlPRuon535AUARcb4W90W5SXX9RZCVM60pre0NxdCCKsEeZuWwpLcjRDOSpLedmRKegeVqCwpXtO7qE7GJIQQQlRLeUlvryD1u1R6CyHqMUVRzCcrgkslvYPMSW85mSEEwIIFC3jwwQeZMGEC7dq1Y/Hixfj4+PDhhx+Wu//27dvp06cPd999N3Fxcdx0002MGTOmyupwm0s0rucdWc31vAF8QtQKcXBshbM9pJ8DQxG46cA/uvr3DzS2PJZKbyFci7HSO1QqvYUQwipS6S2E85Oktx2VX+ltbG8uld5CCCHqO0WpvL256TYhhKiHsgv0FOgNAIT4lK70VufnqdlS9SREQUEBe/bsYeDAgeZtWq2WgQMHsmPHjnLv07t3b/bs2WNOcp88eZLvv/+em2++ucLHyc/PJyMjw+Kr1kyV3lEdq39fjQaCTBXOTp70Nrc2jwdtDU7zmNubX7DdmKpiqq6vbqW3u3F9P32Buqa7EKJiPqEAhGik0lsIIawRaPycmJYrMVMIZ+Ve1wNwVYqilJv0Nv0sa3oLIYSo9wpz1BOKUH6lt7Q3F0LUY6aEts5di7enZdtjaW8uRLGkpCT0ej2RkZEW2yMjIzl8+HC597n77rtJSkri2muvRVEUioqKeOSRRyptbz5//nxmz55t07GTYKz0rknSG9Rkb9JR51/XuzbreYPlmt6Kol4QYE+KAnrjORG3aia93TxA6wGGQijKA09f249PCFdhWtObDFKynHwZByGEcACp9BbC+Umlt51k5RehNygABPmUqPT2kjW9HcFgMNT1EIQNyb9n/Sb/Pq5FUZTiX0yV3FoPyxOKpgR4XjrIv78Qop6qaD1vKJ6f16S9ubzvuRb596yZrVu3Mm/ePN5++2327t3LmjVrWLduHXPnzq3wPtOnTyc9Pd38de5cLRPNOSmQeVH9ObJ9zY4R6CqV3qfU7zVNegcY25sX5ap/Vxsq9zWmLwAUQKMmsavLw1jtXZhTm6GJGpCY6WSMa3rrNEXkZ9ugu4awO3mNuRaL8yvCKQSZkt6yJIRTkJjpWmwVM6XS205MVwN5umvx8iiuLAkwXy0ka3rbg6enJ1qtlosXLxIeHo6npycae1+lLuxGURQKCgq4cuUKWq0WT89qrvcm7Epeb65HURSuXLmCRqPBw8MD0kq0Ni/5b2tqb44C+emWVeBCCFFPmKq4g33Kzh9M29KqUekt73uuReaZxcLCwnBzcyMxMdFie2JiIlFRUeXe54UXXuDee+/lgQceAKBjx45kZ2fz0EMP8dxzz6Etp8W2TqdDp6tmVW9lTK3Ng+NB51+zY5iS3mmuUukdX7P7u+vALxKyEtWqd9/QWg+p0piZnwVFiprwzq9B9aniod4/OwvcavhvL6pFYqaT8vTB4OaFVp8HOVfqejSiEjLPdD1lzq8IpyCV3s5BYqbrsWXMlKS3naTllG1tDhDgZVzTWwKnXWi1WuLj47l06RIXL16s6+EIG/Hx8aFp06blnjwTdUdeb65Jo9HQuHFj3Nzciiu9fUIsd3LXgbu3Wg2UmyZJbyFEvWRKetuq0lve91yTzDPVk0bdunVj8+bNjBgxAlCrJjZv3szkyZPLvU9OTk6Zv5mbm3qxt8OqmszreXeo+THMa3qfrf146lJqLSu9Qa32zkpUq95jutR6SJXGzPwsyE0BD2/IOFX9gxdkQ04yuGeAX16txyqsJzHT+ei9Q9FmXcA9z7ZdHIRtyTzTNVmcXxFOwfQ5MU0qves1iZmuyVYxU5LedmJKageVTnp7S3tze/P09KRp06YUFRWh1+vrejiiltzc3HB3d5erteopeb25Hg8Pj+LJRW6JSu/SvIMhMxfy0hw2NiGEqI6UbON83KfsVcI1qfQGed9zNTLPLDZt2jTGjRtH9+7d6dGjBwsXLiQ7O5sJEyYAMHbsWBo1asT8+fMBGD58OAsWLKBr16707NmT48eP88ILLzB8+HDHndhNNK7nHVnD9bzBNdqbGwy1b28O6rreF/dCxgXbjItKYuavr8O+j6HTXdDhqeofOOk4bHwSPHzhwS0gCViHkJjpnDS+YZB1Aa/CNAqKDHi6y+ulvpJ5puuxOL8inEKAVHo7DYmZrsdWMVOS3naSlltRpbf6e1Z+EQaDglYrHxbswdQGQdrHCGF/8npzYZUmvYPUdTRz0xw5IiGEsFpaJZXewb6mSu/qJb1B3veEa7rzzju5cuUKM2bMICEhgS5durB+/XoiIyMBOHv2rEVl5/PPP49Go+H555/nwoULhIeHM3z4cF588UXHDTrBmPSOqk3Su7H6Pf28mjx2xuRp5kXQ54PWHQIa1/w45gsAbNvqvdyYmbwfss5BQCh4eVX/oNGtITcRsgog/zIEx9lsvEK4Gje/cEiEUE0GabkFRPjX4DUnHEbmmULUrSDTxdGS9HYKEjNFeZzwE51zMF0NVLqyxN/Y3lxRIDNf1vUWQghRj1WW9PYKstxHCFEtvxy9wpzVO/jruJO31K3HUrKrXtM7NVtOZghhMnnyZM6cOUN+fj67du2iZ8+e5tu2bt3KsmXLzL+7u7szc+ZMjh8/Tm5uLmfPnmXRokUEBQU5ZrBFBXDlsPpzbdqbB8SARgv6Ash20vVuTet5B8WCWy3qGkpeAGBvKafV78E1XIPczQPCW6s/my5+EEKUS+MbBkAImdKuVwhRb/zyyy8MHz6cmJgYNBoNX3/9tcXtiqIwY8YMoqOj8fb2ZuDAgRw7dszu4zIVMMrStEI4L0l624kp6R1QqtLby8MNnbGVkARPIYQQ9VpVld4g7c2FqCHdusnMODCYhF8/ruuhuCxTFXewDdubCyHqiaQjYCgEr8DiCuWacPMA/2j1ZxtXODuMKeldm9bm4Likt6KUWIO8hklvgEjjxQ6J/9R+TEK4MlPSW5NBarbMe4QQ9UN2djadO3dm0aJF5d7+yiuv8MYbb7B48WJ27dqFr68vgwYNIi8vz67jMi1VK58ThXBe0t7cTkxXT5Zubw5qIvxKZr6s6y2EEKJ+Mye9g8reZkqES3tzIWokKKIJpIPh4l91PRSXZa70Lq+9uTHpnV2gJ79Ij85d1toTwqkklFjPu7brCwc2UdexTj8HjbvXfmyOZrOkdyP1u72T3tlJUJAFaNTq9JqKbK9+T5RKbyEq5RMKQKgms0bLugghhD0MGTKEIUOGlHuboigsXLiQ559/nltvvRWAjz76iMjISL7++mvuuusuu43LlMvJLtBTqDfg4SY1o0I4G3nV2om5vbl32ZNsxW0ypL25EEKIekzamwthNzFt1LbBMXnHSMyw79XqDZXpItTy1vT293JHq7HcTwjhRBL2q99r09rcxFThnOasld6mqunaJr2NFfOZCaC3Y1xMPa1+D4gBj1qsLWyu9JaktxCVMrc3zyBV5jxCCCdw6tQpEhISGDhwoHlbYGAgPXv2ZMeOHeXeJz8/n4yMDIuvmijZtTdduvQK4ZQk6W0n6bnq1ZOB3mWL6QOM63pLpbcQorRFixYRFxeHl5cXPXv25Pfff69w3/79+6PRaMp8DR061LzP+PHjy9w+ePBgRzwV4QpMVdzS3lwIm/OP7wZAG81Zfjl8sY5H45oqW9Nbq9UQZFrXW6qehHA+icakd6QNkt5BxmSvI9aytgdbJb19wsBNByiQYcf3JVNr85qu521i+rdPOQX5WbU7lhCuzKdEe3OZ8wghnEBCQgIAkZGRFtsjIyPNt5U2f/58AgMDzV9NmtRs+Rs3rQZ/Y+5Gkt5COCdJetuJudK7nJNspiuGJHAKIUpauXIl06ZNY+bMmezdu5fOnTszaNAgLl++XO7+a9as4dKlS+avAwcO4Obmxu23326x3+DBgy32++yzzxzxdIQrqHRNb2lvLkStBMWR7+aLTlPE0QN76no0LkdRlOI1vcup9AYIMq71nZotc3IhnIqiFLc3j+pY++OZ17J2wkpvRSnR3ryWSWSt1jEtzs1J+rjaHccvHHwjAAUuH6rtqIRwXcZK71AypbuNEMJlTZ8+nfT0dPPXuXM1n9eZPidKzBTCOUnS205MCe1y1/T2MrU3l8AphCi2YMECHnzwQSZMmEC7du1YvHgxPj4+fPjhh+XuHxISQlRUlPlr48aN+Pj4lEl663Q6i/2Cg8tJYApRnlJJ74T0PC6l56rbTO3NpdJbiJrRaikIU9cjzT27lyK9oY4H5FrUNdgUAELKuQgViivA06TqSQjnknERclNA4wbhbWp/vMCm6ndnbG+edRkKs0GjhaCmtT+e+QIAOya9bVXpDcXt7aXFuRAVM67pHaLJIDVb5jxCiPovKioKgMTERIvtiYmJ5ttK0+l0BAQEWHzVVPHStJK7EcIZSdLbTkxXAgWUl/T2NrU3lzW9hRCqgoIC9uzZY7FejVarZeDAgRWuV1PaBx98wF133YWvr6/F9q1btxIREUHr1q159NFHSU5OtunYhQvLSVG/ewdTqDcw9I1t3Pz6NvKL9MXtzWVNbyFqzDfuKgCaFZ1k37m0uh2MizGd1PXy0OLt6VbuPsGmSm+5gl8I52JKcIa1qt2a0CbOXOltqvIObAzuutofz7Sutz3/FuZKbxskvSPVi8dI/Kf2xxLCVRkrvX01+WRlyVIAQoj6Lz4+nqioKDZv3mzelpGRwa5du+jVq5fdHz/I23hxdK5cKCSEMyq74LSwieL25lLpLYSoWlJSEnq9vtz1ag4fPlzl/X///XcOHDjABx98YLF98ODBjBw5kvj4eE6cOMGzzz7LkCFD2LFjB25uZZMA+fn55Ofnm3/PyMio4TMSTq8wF4qMVd3ewVzOzCfZmEQ6m5xDS1Old2563YxPCBegje4MQHvtaX4+eoXucSF1PCLXUdl63iayprcQTirBuJ63LVqbQ/Ga3nlpkJ8JOn/bHNcRzK3Na7met0mAA9qb27LSO9L4f0AqvYWomC4Ag8YDrVKIkn2lrkcjhBAAZGVlcfz4cfPvp06dYt++fYSEhNC0aVOeeOIJ/vvf/9KyZUvi4+N54YUXiImJYcSIEXYfm6nSO10ujhbCKUnS2w70BoVMYxV3ue3NTS0y8iRwCiFs44MPPqBjx4706NHDYvtdd91l/rljx4506tSJ5s2bs3XrVm644YYyx5k/fz6zZ8+2+3iFEzCt1a1xA10AiZfTzDedTs6hZYSxTb60Nxei5qI6AdBWc4YXDyfy5E2t63hAriMlp+qkd7B5rTZJegvhVMxJ7w62OZ7OX122JS9NTfZGtLXNcR3BlEC2VdLbVPWeccE2xyutIBuyjK1Kg+Nqf7ySld6KAhpN7Y8phKvRaCjyCsYz9zLkSNc3IUT98McffzBgwADz79OmTQNg3LhxLFu2jH//+99kZ2fz0EMPkZaWxrXXXsv69evx8rJBl58qBJo+J0rBohBOSdqb20HJCu7K1/SW9uZCCFVYWBhubm7VWq/GJDs7m88//5z777+/ysdp1qwZYWFhFldTljR9+nTS09PNX+fOOWGbR2Eb5vW8g0Cj4XJGnvmm00nZxe3N8zNAL+9nQtRIeGsUNx0BmlzSLh0nKSu/6vsIq5gS2SG+lSS9fU2V3nIyQwinYqrqjbRR0huK23o727retq70tvea3qmn1e9egeBjg+4mYa1A66HOR52xPb0QDmIwruvtnpdSxyMRQghV//79URSlzNeyZcsA0Gg0zJkzh4SEBPLy8ti0aROtWrVyyNjMld6S9BbCKUnS2w5MAdHX0w0Pt7J/4uI1vSVwCiFUnp6edOvWzWK9GoPBwObNm6tcr2bVqlXk5+fzr3/9q8rHOX/+PMnJyURHR5d7u06nIyAgwOJLNFDmpLda0Z2QXiLpnZytnqw0yZMW50LUiJsHGmNFYXvNaX45Ki0nbSUlW51nB1eW9DZWgUultxBOpCAbkk+oP9uqvTkUtzh3tsSpzZPepr+DnZLeKTZsbQ7g7gnhxi4pCdLiXIiKaIzrenvkp2AwKHU8GiGEqGf2LIflw2HvRwAESXtzIZyaJL3twNT6orwq75LbZU1vIURJ06ZNY8mSJSxfvpxDhw7x6KOPkp2dzYQJEwAYO3Ys06dPL3O/Dz74gBEjRhAaGmqxPSsri6effpqdO3dy+vRpNm/ezK233kqLFi0YNGiQQ56TcGKlkt6JmcUVqKeTs8HNAzyNa15Ki3Mhai5abXFuWtdb2EaqeU3v8ufjJW+TSm8hnEjiQUABv0jwi7Ddcc0Vzk6U9FYUSDYmvW2VRA40rumdn2GfixrN7dhtNF6wbHEuhCiXu184ACFkmJdjFEIIYZR2Fk79Ahf/BKTSWwhnJ2t624EpIAZWsIagqb25TDSFECXdeeedXLlyhRkzZpCQkECXLl1Yv349kZGRAJw9exat1vJapSNHjvDrr7/y448/ljmem5sbf//9N8uXLyctLY2YmBhuuukm5s6di06nc8hzEk6sdNLbor15jvG2ICjILF7/WwhRfcZ1vdtrTvPB0SvoDQpuWlmTtLZSrVjTO8h4mylBLoRwAonG9bxt2doc7F/hbA+5qZBvTEzbYn1sAE9fde6Xm6r+LUp29rEFU3tzWyXpoUTSe7/tjimEi3EzJb01GaTmFJjXqxVCCEFxxxxjB50gWdNbCKcmSW87MCe9vcv/8wZIpbcQogKTJ09m8uTJ5d62devWMttat26NopTfnszb25sNGzbYcniiISmV9L6cUVzpfTE9l/wiPTqvILUiyrSvEKL6orsA0EF7htScQvZfSKdLk6A6HZIrSLVmTW9T0lvamwvhPEwtrKNsnfQ2Vno705reptbm/jHg6WO74wY2Nia9LxQnlG0lxR6V3sb/C1LpLUTFjO3NQ8gkNaeAOHzreEBCCFGPhDZXvxvnVgFS6S2EU7NZe/Nz585x/nzxVdG///47TzzxBO+9956tHsJppBtPnAV5V1TprSbDM/OL0MtaOkI4PYl/wiWVXtO7RKW3osC5lBy10hukvbmwqQYXUyPbg0ZLuCaNcFLZeuRyXY/IJaQYq7eDrGhvnp5bKOtbCqfV4GJmgrGa19glw2aCmqrfnam9ua3X8zYJtOP65qk2XtMbipPeySegIMd2xxWiBKePtT7qUmihmgzSZFkXIUQtOH08LI9pLpV+HoryzTkdiZdCOCebJb3vvvtutmzZAkBCQgI33ngjv//+O8899xxz5syx1cM4hfQq1vT29yrenpknwVMIZyfxT7ikCtqb+3q6AcYW56akt1R6CxuyZUxdtGgRcXFxeHl50bNnT37//fdK909LS2PSpElER0ej0+lo1aoV33//fY2fi1U8fSC0JSDrettSarY6x66s0tvU3tygQIbMyYWTalDzUIOhuJrX5u3NjZXemZdA7yTxwB5V01BifXMbt3rXF6lrZoJtx+wfCb7hgAKXD9nuuEKU4PSx1lTprcmUDjdCiFpx+nhYHt9w8PQDxQCpZ8xLQGTkFlbYXVMIUX/ZLOl94MABevToAcAXX3xBhw4d2L59OytWrGDZsmW2ehinYLoKqKI1cjzdtXh7qEmDjFxZ11sIZyfxT7ikEknvnIIiMvPU96vucSEAnE7OBq8gdR+p9BY2ZKuYunLlSqZNm8bMmTPZu3cvnTt3ZtCgQVy+XH4ldUFBATfeeCOnT59m9erVHDlyhCVLltCoUSNbPK3KRZvW9T7DvnNp9X+N6cI8teVDPWbNmt6e7lrzhTypchW/cFINah6aegoKs8FNB6EtbHts3whw81RPdmZctO2x7cVuld52SnpnnAdDkfrv5x9j22Ob1/U+YNvjCmHk9LHWx9TePEPmPEKIWnH6eFgejab4gryUkwQZCxkL9AZyC/V1ODAhRE3YLOldWFiITqcDYNOmTdxyyy0AtGnThkuXLtXomC+99BIajYYnnnjCvC0vL49JkyYRGhqKn58fo0aNIjExsdbjt6WqKr0BAozrfUtViRDOzx7xT4g6VyLpbVrP28fTjfYxAYAx6W2u9E5z/PiEy7JVTF2wYAEPPvggEyZMoF27dixevBgfHx8+/PDDcvf/8MMPSUlJ4euvv6ZPnz7ExcXRr18/OnfuXPsnVRVjm95rvM+jKLDteJL9H7Omko7Dgjaw8l91PZIKKYpi1ZreUFztLVVPwlk1qHmoKaEZ2Q7c3G17bK0WAowXOdk62Wsv9kp62+vvYKpMD45V/962JOt6Cztz1DlPuzFWeqvtzWXOI4SoOZede5rmUykn8fF0w12rAWRdbyGckc0+abRv357Fixezbds2Nm7cyODBgwG4ePEioaGh1T7e7t27effdd+nUyXKtrqlTp/Ltt9+yatUqfv75Zy5evMjIkSNt8hxsxaqkt1dxmwwhhHOzdfwTol4okfQ2recdGeBFXJgvAGeSc8ytzyXpLWzJFjG1oKCAPXv2MHDgQPM2rVbLwIED2bFjR7n3Wbt2Lb169WLSpElERkbSoUMH5s2bh15f8ZXd+fn5ZGRkWHzViLHSu4PbGYD6va735tlqfDjyQ71dOzUrv4hCvVqJXlmlN0CwrzonlxPAwlk1qHmoaT1vW7c2Nwmy41rW9mBOetu6vbnx75Bh46S3eT3vONseF0okvaXSW9iHo8552o2x0jtQk0NaVv2cvwkhnIPLzj1DmqvfU06i0WgI8jF9TpTcjRDOxmZJ75dffpl3332X/v37M2bMGHNVzNq1a80tL6yVlZXFPffcw5IlSwgODjZvT09P54MPPmDBggVcf/31dOvWjaVLl7J9+3Z27txpq6dSa2lWJL1Nt0mltxDOz5bxz5mdSc5m/c59nErKruuhCFswJbK9g83reUcG6Ig3Jr1PJUl7c2EftoipSUlJ6PV6IiMjLbZHRkaSkJBQ7n1OnjzJ6tWr0ev1fP/997zwwgu89tpr/Pe//63wcebPn09gYKD5q0mTJlY+y1KMld7B+RfwJ4dfjiZhMNTD9uHn/4BDa9WfFT1c2lenw6mI6cSEl4cWb2P78oqYkuKmNcCFcDYNah6aYExoRnW0z/EDm6rfnSHpnZcOOcauIMF2WtM74yIYbNjS01zpbePxgmV783q+/IZwTo4452lX3kEoqFWLRZnJjnlMIYRLctm5p7nS+wQAAcbcjVR6C+F8bNYTrH///iQlJZGRkWExaXvooYfw8fGp1rEmTZrE0KFDGThwoMWJxj179lBYWGhRtdOmTRuaNm3Kjh07uOaaa2r/RGzAVL0dVMGa3lAcOGVNbyGcny3jnzPb+tkCbr/yJluvWkj8rXfX9XBEbZXT3jwywIvYUPX/9MW0XAo9A/Aoua8QNlBXMdVgMBAREcF7772Hm5sb3bp148KFC7z66qvMnDmz3PtMnz6dadOmmX/PyMioWeLbJ0StrEs/R1fPc/yS5cPBSxl0aBRY06dje4oCG0v9Hc7vhtjedTOeSqQY10QPqaLKG0okvaXSWzipBjUPTbR30tuY7E1zgqS3KYHsGw5eAbY9tn8UaNzU9bezEiHARutvmyq9bV2ZDhDeGrTu6sUA6eeLq/aFsBFHnPMsLT8/n/z8fPPvNe4oBKB1o8AzCF1BKobsKzU/jhCiwXPZuWeJ9uaAeV1vqfQWwvnYrNI7NzeX/Px8c7A7c+YMCxcu5MiRI0RERFh9nM8//5y9e/cyf/78MrclJCTg6elJUFCQxfbKqnZs1nayGkzBsPL25rKmtxCuwlbxz6kpCn2V3fho8hm473E4saWuRyRqQ18IBZnqz6Xam4f76fD1dMOgwJUi4wcaaW8ubMgWMTUsLAw3NzcSExMtticmJhIVFVXufaKjo2nVqhVubsWVwW3btiUhIYGCgvITojqdjoCAAIuvGjNWe98cpp6IrHctzo9vgjO/gpsOejysbjv3e92OqQIpxgR2kFVJbzmZIZxbg5mH5qQUV2Cbqnptzdze3AnW9DYnkG28njeA1s28rnd6wknbHTf1tPq9gkrv7PyimldTuesgrJX6s6zrLezAEec8S7NZRyGjIq8QADQ5UukthKg5l517muZUaWehqKC4S69UegvhdGyW9L711lv56KOPAEhLS6Nnz5689tprjBgxgnfeeceqY5w7d47HH3+cFStW4OXlZZNx2XqSaA3TB7Ug74pPtAVI4BTCZdgi/jk9jYazNyxio/4qPJUC+OwuSXw7s5JJbK9Ac3vzCH8dGo2G2FC1xfn5PJ26j7Q3FzZki5jq6elJt27d2Lx5s3mbwWBg8+bN9OrVq9z79OnTh+PHj2MwGMzbjh49SnR0NJ6eVSdPa824rvfVXmpS5+ej9agKx6AvrvLu+TC0H6H+fH53vWwjm2qq9Pat+t8tSCq9hZNrKPPQj7/5HoBsn0bgZacuGKZKb2dob25ez9sOSW9A769Wd7/w0QbbLF2kKJByWv25nEpvRVEY9uavXP+/reQU1LAbXskW50LYWF2c85w+fTrp6enmr3PnahebFOO63u55kvQWQtScy849/aPAwwcUA6SfM39OTMuVz4lCOBubJb337t1L3759AVi9ejWRkZGcOXOGjz76iDfeeMOqY+zZs4fLly9z1VVX4e7ujru7Oz///DNvvPEG7u7uREZGUlBQQFpamsX9KqvasfUksSr5RXpyC9V1ryqv9JZ1IYRwFbaIf66gQ9MIJhU+zib9VVCUJ4lvZ2ZqV+4VCFo3c3vzqED15ExcmFrhfTrbmFCSSm9hQ7aKqdOmTWPJkiUsX76cQ4cO8eijj5Kdnc2ECRMAGDt2LNOnTzfv/+ijj5KSksLjjz/O0aNHWbduHfPmzWPSpEm2fYIViVbXQmuSfxyAvWfT6s88cf8quPyPGhOunQrRXdQ2slmJ9bIiMtVYtR1sRdLbVOktSW/hrBrKPLRpoZrk3V/U1H4PElii0rseXtBjwY5J70K9gV0p6lwvSrnC7lMpld/BmnlgTrKxi5AGgmLL3JyYkc+ppGySsws4nJBZ/UEDRHYwHsyKpLfBAH9+ol7Q9fMrsGMR/LEU/l4Fh9epn2HO7VarxvPSazYe4VIccc5Tr9db7G/TjkKA1ldNeusKqnhNCyFEJVx27qnRWLQ4D5Q1vYVwWjZb0zsnJwd/f38AfvzxR0aOHIlWq+Waa67hzJkzVh3jhhtuYP/+/RbbJkyYQJs2bfjPf/5DkyZN8PDwYPPmzYwaNQqAI0eOcPbs2QqrdnQ6HTqdrhbPrHpMgVCjAX+viv+8Ad6m9uayprcQzs4W8c8VhPnpCAv0Z2L64+yK/Yjg85vVxPeYz6H5gLoeXu0l/gP5mdD0mroeif2VWM8bIDGzuL05QJyx0vt4hvF9rjAbigrA3QHVsKUd+FJd17Lvk+qbr3B6toqpd955J1euXGHGjBkkJCTQpUsX1q9fT2RkJABnz55Fqy2+/rNJkyZs2LCBqVOn0qlTJxo1asTjjz/Of/7zH9s+wYoY25t7phylTZgHh5MK+e14Ejd3jHbM41ekMA9+Mq43ee1Udf1xUJMLl/ap1d71bO1Uc6W3T8UXoJqYEuOp2XIyQzinhjIP7el9AYCdOdH4nE+jU+Mg2z+IsaU3hTlqO3XfUNs/hq2Y1vSuoFV4TSmKwvNfHSA2w4/e7hCtSeH4lazyd04+AT/8B45vhM53w7AF4OFd+XgDYsCjbIXryRKPcSwxk6uaBpfZp0rmpHcV7c0VBX58Dna+bd1x3b3gxrnQ40GZazZgjjjnWXKJHXtwDwgHIMCQQV6hHi8P+z6eEMI1ufTcMyRevXgu+QSB3upFerIMlhDOx2aV3i1atODrr7/m3LlzbNiwgZtuugmAy5cvW301or+/Px06dLD48vX1JTQ0lA4dOhAYGMj999/PtGnT2LJlC3v27GHChAn06tWLa66pH0kIU7vyAC8PtNqKPxCZKr2lvbkQzs8W8c9VdGgUSAEefNVyHrQa4joV3/oiWH4LLBsKaU7Q8rK2SiS9FUUhId2Y9Pa3THofTitxn7pocW4wwNop8NNcuHzI8Y8v7MKWMXXy5MmcOXOG/Px8du3aRc+ePc23bd26lWXLllns36tXL3bu3EleXh4nTpzg2WeftfsJSLOAGPAJBUXPqMZqlVu9WNf7jw/UVr/+MdDzkeLtja9Wv5/fXTfjqkR11vSW9ubC2TWUeahX38msipzKRn13PtphpxOqHl7gp14YRfpZ+zyGrdip0nvRluOs/OMclxQ14d9Ik8SJy6WS3oW58NOL8PY1asIb4K9P4cNBFc+TUytP0p8o0UL9aGIFSfaqmNqbJx9Xx1iRba8VJ7y73gvdxkPH26H1UIjvp76/RbRXK9K9Q9TPMz88DStGQ2ZizcYmnJ4jznnam4e/mvQOIUPmPUKIGnPpuadUegvhEmyW9J4xYwZPPfUUcXFx9OjRw1x5/eOPP9K1a1dbPQz/93//x7Bhwxg1ahTXXXcdUVFRrFmzxmbHry3T1T+VtTaHEmt650ngFMLZOSr+OYOOjdQ1Fv+6lAt3LHedxPflfyAnCQxFcOqXuh6N/ZVIemfkFpFfpK5xHBGgdk6JDTW2N0/JL15Xsy5anGdeggLjidGkI45/fGEXDTamajTmau9+ARcBdV1vpS5b7Oalwy//U38eMN2ygq8eJ73Tcqxf09vU3lyu4BfOqsHEzKiONB/6OP8ocaz96yLJWfn2eRzzut71b+kGs4IcdQ4E5a6PXVNf/Xme//14FIABPa8CIEaTbFnpfeQHWNQDfnkF9AXQbACMWKwmhy/9Be/1K3+ubKr0Dokr97FPXSmZ9K5he3P/KOPFY4aKL4bc/YF6sSTA4Jfg1rdg+Osw6n0Y8ymMWwsPbIKJ2+GJv+HfJ2HIq2q19/FN8E4vtf15XUo7C39/Aae2qf9PDYa6HU8D4QqxVuNrTHprMkjJlqS3EKJmXCEeVqhE0jvIR5LeQjgrm7U3Hz16NNdeey2XLl2ic+fO5u033HADt912W42Pu3XrVovfvby8WLRoEYsWLarxMe3JFAiDqminWFzpLe3NhXB29op/zqhDYzUBuv9COrjr1MT3F+Pg6A/O3er83O/FP5/+FbreY/eHvJKZj6eblkAr2vPanDnpHWJubR7k42FugRcfplZ6n0/NQYkMQpOXXnwfR0o5Ufxz8nHHP76wiwYdU6M7wcktNCs6gZdHCxIz8jmckEnb6Dq6Yv63NyA3BcJaq61rS2rcXf1+6S8oyldjfj1hOpFr3ZreUuktnFtDipldmwTRsVEg+y+ks/KPc0zs38L2DxLYBC7sqd+dfVJPq9+9goqXnKil7ceT+PfqvwF4uF8zru8aC3shRpPEuZQc8i+fQLfpWTi6Xr1DQCMYNA/a3apetBXXBz6/BxL+ho9GwE3/hWseLW4Hbq70jiv38U8mFSfWa5z01mjUau9Tv6gtzhtdZXn7gTWw7kn15+v+rY7PmmP2fAjir4M1D0DCfvj8brhqLAyaDzq/mo21pg6sgbWPFV/0CeCmU/+uIfFqJX1IM/XnkGbqdq20sLYFR53ztCsftYNDqCZTLvYTQtSYS889Q5qr36XSWwinZrOkN0BUVBRRUVGcP69eFd24cWN69Ohhy4eo90yBsKpK70Cp9BbCpUj8U5kqvU8lZZOVX4SfzkUS3+d2Ff98+le7P1xqdgEDF/xMdKAXPzzeF42j1w8sUemdmGHZ2hwg3F+Ht4cbuYV6CjwC0EHdtDcvmehOkqS3K2mwMdVY6e2euJ9eze5my5Er/Hz0St0kvTMTYIfxItOBM8Gt1MeGkGbqydOcZDUJYEqC1wOm9blDrGpvrs7J84sM5Bbo8faU5IBwPg0lZmo0Gsb1juOpVX+xYudZHurbDHc3mzWvUzlDpbeNW5sfScjk4U/2UKhXGNYpmv8MagP56epDaLKY6vYFHu/+APp80LpDr8lw3dOWCd+gpnD/j/Dt4/D3StgwHS7+qVZRe/pUuQb5yRKV3okZ+aTnFNbsws/Ijsak9wHL7cc3w5qHAAW63w8Dnq3ecSPawAObYcuL6gVhez9SPxOMXOKY9z99IWycUdyWPayV2oEq7az675J0pPyuR+7e6oUAUR2LvyLaOT5Z7yKcPtb6hgFqe/OjcrGfEKIWnD4eVsQ0t0o7Q5CXeh5OLhISwvnY7BOiwWBgzpw5BAYGEhsbS2xsLEFBQcydOxdDA2q3ZAqEAVW2N1dPHMqa3kI4P4l/xcL8dEQHeqEo8M8F9WSZueK7ZKtzZ2sRXjLpnX4WUu20lqTRX+fTSM8t5HBCJieu1HBdw9ookfQ2redtam0O6klnU4vzbK2/8T5pjhyhKlkqvV1Rg46p0cYr5RP/oX9LtXqvztb13voSFOVCk57Q+uayt2s09bbFefGa3lUnTPx07rhr1RMaUu0tnFFDi5nDOkUT7OPBhbRcNh+uWXw8lZTN8dLrVJsENVW/1+c1vW2Y9E7MyGPC0t/JzCuiR1wI/7u9M1qtRl2+xlOd4z3m/jVafb5a7fzodrhxdvlJUw9vuO1dGPwyaNxg/xfw4U3qvNlU6V1OO/b8Ij3nU3MA8DVeeHT0cg2rvU3reif+U7zt3G5Y+S8wFEL7kXDzq8UV6NXhroMb58C4byGgsfrv8MFNsPVl0Nuxg1/GRVg2rDjhfe1UeHQHTPkTnkuEKfvg3q9g6AL1goQ2w9Q1yd291ffxC3/AnqWwbhp8cCPMbwxvdoNV49X1zf/5Gs7vUS92c8GYYSsuEWt9jElvTSapksQRQtSQS8TDivhHq0uaGIoILUoEpNJbCGdks0rv5557jg8++ICXXnqJPn36APDrr78ya9Ys8vLyePHFF231UPWaub15VUlvY3vz7AI9RXqD7a9QF0I4jMQ/Sx0aBXIpPY/9F9Lp2UxtoVam1fk3k+GxvWUrB+ujzAS1ikKjhfA2cPmgWtkRHGu3hzycUHyib/uJZFpE+NvtscpVIul9OVNdMzMqwMtil/gwXw4nZJKu+BICdVPpbTrpC5B8DBSlZicxRb3SoGNqSHPw8IXCbAZGZDIT+ON0qrFzhgPjZdIxtYoNYOCsil9XjburrW7P/W5dm1gHUBSlWmt6azQagn09uZKZT2pOATFB3lXeR4j6pKHFTC8PN+7q0ZR3tp5g+fbTDGofVa37n07K5ubXt+Gm1bBj+vX4e5X63N6AKr2z8ouYsHQ3F9PzaBbuy3tju5mXskGjgdBmcOkvEpRg9rZ5mpvvmlj1PEujgWsegagO6rw/Yb+6zrdpbllOpffZ5BwMinoRUrfYYH4+eoWjiZlcHVeD1u3mpPcBdV545TB8ejsU5kDz69WkfG3bfcf3hUd/VVulH/gSts5T1/se8CzE9wOtDc/tnPoFVt8H2VdAFwC3LYY2Q4tvd3M3tjKPh+al7mvQq/9XEv5W/x0S9kPCAchKUC8WTT4O/3xleR+tBwTEqG3+Axupr4eARurvsb1A5+DPJPWIS8RaY6V3MJmkZeXV8WCEEM7KJeJhRbRada5y5RBBeepcMCOvEINBUS8KFEI4BZudPVu+fDnvv/8+t9xyi3lbp06daNSoERMnTnTugFcN1rY39/cq/tNn5hVZteagEKJ+kvhnqWOjQDYeTOSAqdLbxF0Hoz+EhR0g7Qwc/Bo6jq6TMVaLaT3viPbQ8sbipLcd1/U+fCnD/POOE8mM7RVnt8cqV8n25peN7c1LJb1jQ9V1vZP1PsSXvI8jlazuzktX2ywbT+YI59WgY6pWqyYKzu2iUd4xYkPDOZOcw2/Hk6qd2KmVzXNA0asdOmJ7V7yfudL7D8eMywpZ+UUU6hWgeL3uqgT7eHAlM19a1wmn1BBj5j09m/LuzyfYfiKZY4mZtIy0LhGnKArPrPmb3EI9AH+dS+falqXmDYFN1O/1eU1vc9K7/Fbh1ijUG5i4Yi8HL2UQ5ufJsvE9CCodM4e/zm8/fcdDB9pyPc25uToXFsZdCw//rFZYX/xT3eYVWO4a5CeMrc3jw3xpHeXPz0evcCyxhp2OwtuoVea5qWqnplXj1Z8bXw13fgLuNjrv4h2sfq5pNVhNfp//HT4eoXYK6DoWutytJo1rSlHgt9dh82xQDBDZAe74CEJLZ7YroXWDsJbqV4dRxduzLhcnwRMPqJX4GRcg85JaDZ92Rv0qbfKeBp30dolY662+/tw0CnmZKXU8GCGEs3KJeFiZ0OZw5RB+2WeBxiiKmrup0bIrQog6YbNLUFNSUmjTpk2Z7W3atCElpeFMpsyV3lUEQnc3rbl1l6zrLYRzk/hnybSu9/7SSW9Q1/TraawG/PX/1BM69Z2ptXmTHhCnXsXKGfuu612y0nvnyWQMBgf/nXKN/29Lruldor05QHyY2t48odCYDHd0e3ODHlJPqz+7G8eQdMyxYxB20eBjqnFdby79Rf9W4YCDW5yf/wMOrVW7W9wwo/J9G3UDNGob4MwEhwyvKqb1vL08tFavz21K9Eh7c+GMGmLMbBzsw43tIgH4aIf1S858vvscO08W/032ni3ngr0gY9I7JwkKc2s1TrsxrY9di0rvGd8c4JejV/Dy0PLBuKtpaly2xkJMV3KueohsvDlRUTv4ygQ2hgnroYvxQlHTEh6lnExSj90s3JeWEWrb9CMJNWxv7uGlJnkBPh6pJnLD28LdX4Cnb82OWZlOd8Cjv6nrhOsC1e5QW/6rXuS74g449J26Hnd15KWrFwtsmqkmvDuPgfs3Vi/hXRm/CGhxA1z7BIx6Hx7YCNMOwvOX4YkD6r/ZqA/UTi9XP6heABfZUa0Ab8BcIta6e5Lvrr7G9Jl1tHyOEMLpuUQ8rIzxokL3tNP4GD9PpuXK50QhnInNkt6dO3fmrbfeKrP9rbfeolOnTrZ6mHrP2kpvKF73W9aGEMK5Sfyz1MGY9D6ZlE1Wfjnr2/V4ADz91MqC45scPLoaMFV6N+kJTa5Rq0fS7Leud0GRwbzOpLtWQ2pOoUUS3CFKrumdobY3j6ig0vt8rjEZ7uj25unnQF8Abjr1ggSQdb1dRIOPqaakQMLf3NBWTeqs2XuBcyk59n9sRYGNM9WfO4+ByHYV7Ga8EEfnDxHGfepJtbcpcR1iZZU3qJXeAKnZcjJDOJ+GGjPHGbvgfLn3vFUXkSek5zFv3SEA2kSp1ap/lpf09gpS56lQP1ucF+WrcyCocdJ7/YEEPvv9HFoNvDnmKjo3Capw3xbGJPTJpKyaXYTp4QW3LoL7foRRH5a7yyljpXezMD9aG/9tjtV0TW8obnFemA2BTeHeNeVWmNtMUFMYtgCePKy2T4/toyarj22AlffAgnbqe2vyCfWizYIc9WLRrMtqR4HkE3D5EFz6S/1s9F5/OPwduHnCsIUw4h31wmF7c/NQL/qI7aV247p2Kgz9H9z9udrO3RFjqMdcJdYWeKqvBUN2Uh2PRAjhrFwlHlbINL9KPmHO70juRgjnYrP25q+88gpDhw5l06ZN9OrVC4AdO3Zw7tw5vv/+e1s9TL1nWkPQqqS3lweX0vPIyC0nKSSEcBoS/yyF++uIDvTiUnoeBy9m0CO+1Ekm72DoNh52vKVWe7e8sU7GaZXCPLi0T/25SQ/Q+UGjq+D8bjjzm13W9T5xJYsig0KAlztdm6rrGu44mUy7mACbP1aFSq7pnaGeWC29pnecMel9NtdTnU04ur158gn1e0g8hLVW1zxMlkpvV9DgY2q0qdL7b/q2COWaZiHsPJnC7G8P8v647vZ97OOb1U4WbjroP73cXc6l5HDb29vpGR/ConuuUtf1vvyP2tq17TD7js8KKca5eHWWDgo2V3rLyQzhfBpqzOzVPJSWEX4cu5zFl3vOM6FPxa2+FUXh+a8PkJlfRJcmQcwY3o6Rb2/nz3NpKIqCpmTbbo1GbXF+5ZB6kaOpari+SDsLKGpi3je82nfPyCtkxjcHAHi0f3NzxXxFmgR74+mmJa/QwIW0XJqE1CDxqdFA054V3nwyyZj0Dvc1J9mTsgpIzson1E9X4f0qFN1FXWvbJwzGfu24CmVPH+h8l/qVdBz+/Bj2fQrZl+G3heqXtQKbwh3L1c8dol5wlVir9w6FnLNocpPreihCCCflKvGwQqakd8pJAr3V3I0sgyWEc7FZpXe/fv04evQot912G2lpaaSlpTFy5Ej++ecfPv74Y1s9TL1XXOld9Ym2AG/1mgNpby6Ec5P4V1aHylqcA/SaBFoPNXF8dpcDR1ZNl/5Sq4l9IyA4Tt0Wd636/bR9WpwfTlDX824THUCv5qGAuq63wxj0altFwOAVxOVMtdK79JrekQE6vDy0pBqMrSId3d7cnPRuXnxC2rRNOLUGH1PD26rxMS8NTcZ55tzaAXethk2HEvnpcKJ9H3v3EvX71fcXt/gt5X8/HiEpK591+y+pXSnq2brepmrtkPKS3ukX4MyOMpulvblwZg01Zmo0Gsb2jgPg4x1nKq1CXrf/EpsOJeLhpuGV0Z3oEBOIp7uWtJxCThkTrhYCG6vf62Old8n1vKuzxrbRK+sPczkzn/gwXx67vuqEvrubljjjkjbHr9Rwne0qnDQeNz7MFx9Pd5qEeANwtKbrencbDwOeg/vW264leHWFtYAbZ6ttw+9coa79rSnn9JubDjz9wScU/KMhKBY6jFbXQ5eEd73iKrFW8VE/X3rkuUALYiFEnXCVeFghU9I79TRBXup7t1R6C+FcbFbpDRATE8OLL75ose2vv/7igw8+4L333rPlQ9Vb6caqbWsrvQEyJHAK4fQk/lnq2CiQjQcT2X8+rfwdAmLUKog/P1arHpp+5sjhWa/ket6mE4tx16oV6qe32eUhD19S2zm2jfKntzHpvetUMnqDgpu2+ic3qy2v+EKFZL0PeoOCRgNhfpYJJI1GQ1yoL2mXjS1AHd3ePMWY4A5tXnxCU9b0dhkNOqa6e0JEG0jYD5f+plXbYdx3bTzv/XKSWWsP0rt5GF4e1q1VXS2ZiXBso/pztwnl7nLgQjrf7Lto/v2LP87x7NXG5QUu7AV9EbjZ9ONFtaUYk95BpdubKwp8MhKuHFbXK43tZb7J1N5cruAXzqqhxsyRXRvxyg+HOZmUzbbjSfRrVbbyOTW7gJnf/APApAEtaBWpts/u2CiQPWdS2Xs2jWbhfpZ3Ml30Y2ojXp+Yk97Vb23+x+kUPtl5FoB5t3W0+r2kRYQfRxOzOHE5iwGtI6r9uJVJzS4wd9loFq5eSNk60p9zKbkcu5xpvgC0WrwCoN+/bTnMmnPzULugtB0G+Znq+t5unsYvjxpduCDqjivEWq1fGAC6Akl6CyFqzhXiYYUCGqsXpenzaeaZxk40pEnuRginYrNKb6G2TUvPNbY396k66W1KjEultxDC1XSsqtIboM/jgAaOfA+JBx0zsOoqmfQ2sfO63oeM63e3iQ6gfUwg/l7uZOYV8c/FSv6WtmRqU+7pT2K2HoAwPx3ubmWnDLGhPmQodVzpHdocQo2VSikn1Up1IZxdVPG63gBTbmhJZICOsyk5vPvzSfs85t8rQdGrldvhrcrd5eX1hwH1tQ/w5Z7zFAQ1B10gFOWqbc7rmClxHVJ6Ln5ul5rwBvj7c4ubgqXSWwin5KtzZ1Q3tSr7o+2ny91n7ncHSc4uoHWkPxP7tzBvv6ppEFDBut51UemdnWxx4WGFapj0zi/SM33NfgDu6N64Wsnk5saLAo5ftn2lt6m1eXSgFz6e6kVTLY0XJhxNrMW63vWRzl9dW1znp17gJglvUQc8/NULV/yK0ijSG+p4NEIIUQ9pteZOj3FatdOaFCwK4Vwk6W1DuYV6CvVqW7Ugayq9TUlvWdNbCOFiTO3NTyZlk5VfQYwLawlth6s///a6g0ZWDYqirt0N0KTEOoQ6P4jpqv585jebP+zhS8b25lH+uGk19DSuib7dUS3OS6znnZiRB5Rdz9skLsyXdHwt7+coycfV7yHN1ZPTbjowFEKa7S9EEMLhSqzrDeCnc+f5oe0AeHvrcc6l5Nj28RRFXXcUoMvd5e7y2/Ekth1LwsNNw9LxVxPhryM5u4BNh69A427qTud+t+24aqDCNb33rSj++eA3UFSc4A4yJshlTW8hnM/YXrEA/HTkMmeTLWPj1iOXWfPnBbQaeHl0Jzzdi09/dG0aDMCfZ9PKHjSwqfo9zY6V3pmJ6rrT302DRT3h1WbwSnPY9praNaMipqR3cMVrmJfn3Z9PcuxyFmF+njx7c9tq3de0zvYJO7Q3L9na3KRVpPp4RxPs005diIZMF6gmvUM0mdKuVwghKmK8uLCpcgmANLk4WginIklvGzJVlrhrNfh4Vt0qLMBL1vQWQrimcH8dUQFeKAocvJhR8Y7XTlW/71+lVk7XJ2lnICtRXVs3uovlbeZ1vW2b9E7OyudyZj4aDeb2m72aqy3oHLautznpHURihmk9b125u8aF+pJuqvTW50NhriNGqLaGNP1/CW0BWrfiFueyrrdwBVGmpPdf5k3DOkXTu3ko+UUGZn9r4+4YF/+EK4fA3Qvajyxzs8Gg8NIPapX0PT1jaRbux2hjdeXnu8/Vq3W9TWt6B5dsb16QAwe+Un9281Tj3Mkt5ptNCXI5mSGE82kW7sd1rcJRFPh452nz9qz8Ip776gAAE/rE06VJkMX9rjImvQ8nZJBd+gJNc6W3DZPeGRfh71Wwdgq82Q1eawWr74M/PijuQmEohM1zYOmQiuczNaj0Pn45i7d+Ui8WnDG8fdnlH6rgiEpvU2tzKJ4DH72ciaJUvFa7EKL63PzUZSBCyJCL/YQQoiLGeVaUXl3aSy4SEsK51HrRvZEjy54YKyktLa22D+E0TAEwyMcDjRWtqoorvSVwCuGMJP5VrkOjQBIy8th/IZ0exmrlMhpdBc36w8mtsP0tuPkVRw6xcqaKxZgu4FGq0jmur7oWuY3X9T5sbG0eG+KDr059i+7VTG0/uft0CoV6Ax7ltBm3qXIqvSMqqvQO9SUTb/RoceP/2bvv8LbK64Hj36vtvbed2Nl7D5KwCYRNgAKllFWgK4FC2vIro6y2pC0toxRKCwVKy947jEBCQhbZezmOHe+9bcmS7u+PV5LteNvyzPk8z30kXV9J1zfR66t73nOOW5U4Nwf07v6BKiuvu8AcBCHxal3UKCjcq/p6jz679/dB+J2MqU3ETwI0qMqFmmIIikbTNB68eCLnPbGGL/cVsHJfAWeNj/PP+3mzvMddCAHhLX78ye48duVUEGw1ceuZqjzwVbNTeHpVOmsOFVE0fQox0Fgdox+VtZbpvf9jcFRB+HAYswg2/UtlWI5ZpLb1ZnrXSNBbDB4yZja6ft5wvjlYxOvfHWPZ2WMJsBh5ZMV+csrrSIkM4JfntGzZEB9mIyHMRl5FPTuzK5qX+/b29K7MUW1TDMdNaHe7VKD62CbI36V6NTvrmyyeiYBOu2r94KiF2uLj9kBTY/3wkyF1AQybD4c+h0/vhOxN8MzJcPZDMPvmxjLYLmfjpL9OBr3dbp2739mFw+Xm9LExXDQloVPPa8obkC6rbaC0xkHk8ZU0eiCjyBP0jm7sqz4yJhiDppIKiqrtxIa0fh4qRF8YcmNtoJpQHaVVyWQ/IUSXDLnxsD1R6jwrypEDNCY6CiEGhx4HvcPCwjr8+XXXXdfTtxkUvEHv0E6UNgcItXl7ekt5cyEGIxn/2jc5KYwv9xWwu72+3qCyvY+sgq0vwWl3QlB0n+xfh3z9vOe2/NmwuZ6+3pnq4mP4ML+85T5fafNQ37px8SFEBJopq21gZ3Y5M4e3MYHAX1oJese1cbExNToQ0KjQA4nUqtVzQ7t+MbXLfKXNRzReCI4a1fxnYtCRMbUJa4j6/12arrK9R50FqD6nN52cxj+/OcIDH+5hwahobOaOqwu1q6FeVduAVkubN7jcPPLZAQB+fOoIooJV5YfhUUHMHxnFuvQS3syL4+eg9re2VPUs7SdlNd6e3k2CMt7S5tN+ACPPVEHv/R+rQJQl0JcVXlnvxOlyY+rtyUVC+IGMmY1OHxtLSmQAx0rreH97DqNig3lpg2p38sfLpvh6RR9vxrAIPt6Vx9assuZB7+B4dZ7ndqqqP+YAVcni2CYVkM7eoibSdIVmgISpMHyBqhg07CQIiGi+zbSr1c/e/zlkfAOf/AoOfAIX/x3CklTmudupqnKEdO586/XNx9h0tJQAs5HfL57Uqcn5xwu0mEgKDyCnvI7DhdVtT2bthiPFKnu8aaa3zWxkeFQQGcU1HMyvlqC36FdDbqwNUmNdhFZFjgRxhBBdMOTGw/Z4JheG16mqP5LpLcTg0uOg9wsvvOCP/RgSvLN+wjob9A5Qh18GTiEGJxn/2jc5WQVud3UU9E47TfXIzt0GG/8JZ97TB3vXCb6g95yWP7OGqH3O2axKnE/zT9Dbm+k9LiHEt85g0DhpRBSf7s5nfXpJ3wa9iz09vcNaL28eF2LDajJQoQepoHd9ee/um1epp+RnVJMsp+jR6rbkUN/sg/A7GVOPkzBF/V/P3+kLegPcetZo3t+ey7HSOp5Znc7tC1tmMHbJwU/VZzc0SVXeOM5rm7LILKklOtjKTSc37yF71ewU1qWX8N8dlfwsajRaySGV7e3JoO4PjT29PefjFdlqYhXA1O+rbO+wYVCRBYc+g4mXNjt3r6hr8AX2hRjIemPMfOqpp3jkkUfIz89n6tSpPPnkk8yZ08p5kEd5eTn33HMP77zzDqWlpQwfPpzHH3+c888/3+/71h6jQePak4bz8Cf7eeHbozjdbnQdrpyVzIJRbU+mnD4snI935bXs6200qTGxIgueW6gyvo9nCVYVi5JmqsxJk1UFx022Jot3nVWNPbbQlq9zvPAUuPZ9NTnny/sh/Sv4xzw4/68Q6AmSR6SBoePJOYWV9Tz8yT4AfnnOGJIjAjt+/zaMig32e9Db5dY56unD3jTTG1Rf74ziGg4WVHHy6AEyIVackIbc+WmgCnpHUklZjb2fd0YIMZgMufGwPZ6gd1DNMTTcErsRYpCRNAY/8pYpD+9qprcMnEKIIWhSkpoFml5U3bJXYlOa1tjbe9O/VInI/mavgoI96n5yGxd7fX291/rtbffnt8z0BnzZR+uP9EFf72aZ3upCSFvlzQ0GTfX1xnOhsq689/cPGvtcerO7m96Xnt5iqEiYqm7zdjZbHWw1ce+F4wF4elU6WZ6AQbd5S5tP/X6LEr41didPrFQTSX5x1ihf2wWvRRPjCQ80k1dRT37oJLWyH0uc67resqf3jtcAXZUQjkhVf3MmeUrz7X4bAJPRQKhN/W7S31KcqF5//XWWLVvG/fffz9atW5k6dSqLFi2isLCw1e0dDgdnn302R48e5a233uLAgQM8++yzJCUl9fGeK1fOSsFmNnCgoIr0ohpiQqzcc/6Edp8z3dPXe1tWWcve0dGe8wpvwDtyJEy9Gi54FH66Fn6TBdd/CAsfgPlLYc4tMP2HMPl7MP5CGL0Q0k6B5FkQP7lzAW8vgwFO+in8ZI2aZFlfAe/cDB95zpc7Wdr8wQ/3UlXvZEpyGDcuSOv4Ce3w9vVOL/JfX++csjocTjcWk4GkiObtcXx9vQsGwPcCIYYST3lzq+akurKsn3dGCCEGqNBkMJgxuB0kUCpBbyEGGQl6+1F5nbrI1vlMb295cxk4hRBDT2yIjfhQG7oOez1lu9s07kIVtKwvhy0v9sXutS9nC+hulQ3YVrluX9DbP329nS43BwvUhcTxTTK9AeZ7gt6bj5Zhd7r88n5tahL0Lqxqv7w5wPCoQCp0T0nKvsr09pU3H9m4LqrJxWlHTd/shxC9KX6Kus3f2eJHF0xOYMGoKBxONw99tKf771GZB4e/VPentixt/tyaDIqrHaRGBfL9OS0rWtjMRi6drgJcK6uGq5X9GPSutjtxulXgKiLQAroOO15VP2xaun3y99Ttwc9VMInGHuBl0t9SnKAeffRRbrnlFm688UYmTJjAM888Q2BgIM8//3yr2z///POUlpby3nvvsWDBAlJTUznttNOYOnVqH++5Eh5oYfG0xoD77y6ZRFhg+9/LJyaGYjZqlNQ4OFZa1/yH5/0ZFj4IV78Ovz4Ct22FS5+B2TepIPbxfb57Q8wYuOkLOP1uMJia9PPuOID95d4CPt6Vh9Gg8fClkzEaul7WvKlRsSrofbjQf0Fvb2nz1KjAFvs3WoLeQvQOSyAOg/pu56gs6uedEUKIAcpoggj1/Xa4oUB6egsxyEjQ24+8s37Cm/YQbIc3OF5ZJz29hRDKU089RWpqKjabjblz57Jp06Y2t33xxRfRNK3ZYrM1D07qus59991HQkICAQEBLFy4kEOH+q78szfbe1d2ByXODUZY8At1f/1T4OznUmvHPMe9tdLmXilN+3of6/FbHi2pweF0E2gxknJc+cmRMcHEhFixO90tS3D6myfo7bSGU1ytgj9xoW2X+k2NDqKCoGbP7XWlR9RtVJOgd2AkBHjKbUq2txgKvJneJelgbx5k0DSNBy+eiMmg8eW+Qr7cW9C999j5uprgk3JSY1ajR3G1nX99oz5Lv1o0FnMbfa6/P1sFw1/Li1crsreAu5cn57TB2887wGwkwGJUAfiSw2AOggmXNG4YNwmix4DLDvs/ARrP372Z4kKcSBwOB1u2bGHhwoW+dQaDgYULF7J+/fpWn/PBBx8wb948lixZQlxcHJMmTeLhhx/G5eqfzz/ALaeOIDzQzFWzUjh3UnyH29vMRiYmqnPVrVnHncNEj4aTb4ex5/p64PYLoxlO/z8V/I4eq9YlzWz3KdV2J/e9vxuAm09O852P98RIT89tf2Z6HylSkxSPL20OMNYT9D5UUN0yC18I0SP1ZlXlwlUtQW8hhGiTJ8kiVcunrsHV+wkoQgi/kaB3exy1kL0Zqjp3IdEb9A7tYnnzugYXDqe7e/sohBgyulpWEiA0NJS8vDzfkpmZ2eznf/7zn/nb3/7GM888w8aNGwkKCmLRokXU19f39q8DwGTPRbbdHfX1BphyFYQkQlWeCsT0J1/Qe27b29hCIXGaup/5bY/fcl+eymQZGx+C4bhsF01Tfb0B1qX3colzT+DaW7LcbNSIDGp7MldqVFBjpndflDdvqFc9eqF5eXOQvt5iaAmKVmMiOhTsbvHjUbEh3HSKyvZ78KM91Dd08Uu4rjeWNp/WMsv7718dpsbhYkpyGOdPaqPiBWrMmj4snH2uJBqMAeCoguKDXdsXP/H18/Zmd25/Wd1OuASsTYIqmgaTPNneu99q9hyZxS9ORMXFxbhcLuLi4pqtj4uLIz8/v9XnHDlyhLfeeguXy8Unn3zCb3/7W/7617/y+9//vs33sdvtVFZWNlv8aWRMMNt+ezZ/vHxyp58zfVg4oEqcD2hJM+Cna+DnG2Dipe1u+pfPDpBbUU9KZAC3Lxzjl7f3ZnrnlNdR5/DPRV9vpneaJ6DeVFp0ECaDRpXdSV5F33xvEeJE4bB6JgrXSNBbCCHa5Gknk6qpuJCUOBdi8JCgd3tevwaeOwsOfNKpzb0XyTpb3jzY1tgXsUpKnAtxwutqWUlQwdD4+Hjf0vRipa7rPP7449x7771ccsklTJkyhZdeeonc3Fzee++9PviNYHKy6l+4szNBb5MV5i1R9799ot8yBXG7IbsTmd7g1xLn3n7e4xNa7/noLXG+oY+C3iVulW0eG2JD09ouiZkaFUi5t6d3X5Q3L8sAdLCGQeBxmVfS11sMNQmeEud5LUucA9x25mjiQ20cK63jH6u6+P8+ZwsUHwBTQIsASmZJDS9vVJOofnPuuBYTcY73/dkpuDCyC89n8FjbVUp6k7c0eUSQBRrqYPc76gfTrm658aTL1W3611BT7OsBLuXNhegct9tNbGws//rXv5g5cyZXXXUV99xzD88880ybz1m+fDlhYWG+JSUlxe/75a1+1Fm+vt7Hyv2+L35nskLseDVxpxW6rvPapiz+s/4oAA9fOllVvfCDqGArEYFmdN1/2d6Nmd4tg94Wk4FUz3opcS6Ef7k81bEMdaX9vCdCCDGAeYLeo0wqEalSgt5CDBoS9G6HHqdmiNuzd3Rqe195804GvY0GjRCrCnxX1kuJcyFOZN0pKwlQXV3N8OHDSUlJ4ZJLLmHPnsberhkZGeTn5zd7zbCwMObOndvma/o7A8dbTjG9qJoaeyfGuZnXgy1claPd/1GP3rvbig+qHq/mQFUCtz2pp6jbo2t7/Lb7PZne4+NDWv35PE+m97ZjZX7LsGmVJ+hd4AgA2i9tDp7y5p5Mb3dtH1w48fbzjhrR8qKvN+hdLJneYojw9vXO3dbqj4OsJn574QQAnlmdTmlXSnP7sqAvVpUrmvjr5wdpcOmcOiaG+aOiO3ypC6ckEmQxst7u6TPbT329vaXJI4MssP9jsFdC2DAYfnLLjaNHqRLyugv2vk+4J9O7TDK9xQkoOjoao9FIQUHzCmcFBQXEx7deJjwhIYExY8ZgNDYGVcePH09+fj4OR+tj0V133UVFRYVvOXas5+1hemqGJ9N7b25l1ytmDCCFVfXc/J/N/OadXeg6XDkrmVNGx/j1PUbGqEmO/gp6ZxR7gt4xLcubQ/MS50II/9GC1Lmd2S5BbyGEaJMn6J2mqapHUhFMiMFDgt7teOagynKrzmz9QuPxvEHvzmZ6Q2MpdJktJMSJrTtlJceOHcvzzz/P+++/z//+9z/cbjfz588nO1uVfvY+ryuv6e8MnNgQG3GhVnQd9uZ1IoBuDYE5P1b31zyqsq772rGN6jZpJhhN7W/r7etddrTHfb3356ug97g2Mr2HRwWSEGajwaWzObOXLlC43b6gd65d9YePC7W19wziQ23UGNTFSntVXwS9Pdmsx5c2b7rOGxgXYrDzVpvY+Rpsf7XVTc6fHM/kpDDsTjdvbu7kONRQD7veVvePK22+O6eCD3bkAvB/547t1MsFWU1cPC2RbW5Pi4HszZ3bDz/zBv0jAi1NSrdfDYY2vvL4Spy/7cv0LpdMb3ECslgszJw5k5UrV/rWud1uVq5cybx581p9zoIFCzh8+DDuJudqBw8eJCEhAYul9bYoVquV0NDQZkt/SwoPICbEitOts6szlYkGoE925bHosW9Yub8Qi9HA3eePY/llU/z+Pt4S5+mFPQ9C1zoay5aPbKW8OcDoOPV+ByTTWwi/MgSrCTE2xwBv6yCEEP0pSgW9k/QCNNxS3lyIQUSC3u0wJ00FILjiQKfK7PoyvQM7H/QOsXkzvWXgFEJ0zbx587juuuuYNm0ap512Gu+88w4xMTH885//7PZr9kYGjrev967sTl5InPsTMAdB3nbY/r8ev3+Xdaaft5ctVGUKQo/6elfUNZBTXgeo/rit0TSNeZ4S5+t7q8S5owp0dfE6264yvDsKehsMGpZgtV8N1X0Q9C71BL0jR7b8ma+n92HVr1iIwW7kWTD9WvW5fO+n8N1zLTbRNI0fnjQMgFc2ZeF2d+L//v6PwF4BYSmQemqzH/1pxX4AFk9LZGJiWKd39arZw9jmVhNP9KL9qmJGH/OWJh9mKocjX6uVU7/f9hO8Zd0z15FkKG32GkKcaJYtW8azzz7Lf/7zH/bt28fPfvYzampquPHGGwG47rrruOuuu3zb/+xnP6O0tJRf/OIXHDx4kI8//piHH36YJUuW9Nev0C2apvmyvbdmDq4AUEVtA7e/to2fv7yVstoGJiSE8uGtJ/PjU0di7KAtRXf4gt6esuQ94S1tHhFoJjyw9UkSY3yZ3hL0FsKfLCEq6B3oLEOX70xCCNG6sGFgMGHFTizlkuktxCAiQe92jB4/nTrdgtVdB6UZHW7fk0xvmS0kxImtO2Ulj2c2m5k+fTqHD6ssV+/zuvKavZGB4y1xvruz2TNB0XCG56LqF/dBTXGP96FLvJneHfXz9vL19e5+ifMDnizvpPAAQm1t/w3xljhff6SXgt6eLG9MAeR4kng6CnoDBIerEnl6X/T09mV6txL0jkgDNFXSuKao9/dFiN5mMMBFf4O5P1WPP/4lrHuyxWYXTU0kxGYis6SWNYc7MWZ6s6CnNs+C/vZwMWsOFWM2avzynM5leXtNTQ4jJj6ZTHcsGrrqGd7HvKXJT6r+Qk0UGL7AV5auVeEpMGweoDOuZGWz1xDiRHPVVVfxl7/8hfvuu49p06axfft2VqxY4asYlJWVRV5enm/7lJQUPvvsM7777jumTJnCbbfdxi9+8Qt+85vf9Nev0G2+vt5Z5f27I12w5lARix7/hve252LQYOkZo3hvyYI2J0/6g7e8+WE/ZHp3VNocmgS9C6s7N6FLCNEptnA1rkfolVR3pgWZEEKciIwmCFeTy1O1AondCDGISNC7HTPTojmoq9K+pUfaL9PoduvdC3rbvOXN5URTiBNZd8pKHs/lcrFr1y4SEhIASEtLIz4+vtlrVlZWsnHjxk6/pj/4Mr27UjJy7s8gbrIKwn5+by/tWStqS6HE0w86eXbnnuOHvt7781Xp9/EJ7V+o9GZ678yu6J0LFN6gd0AEBZWq5GRHPb0BwiNVtoDJ3geZne0Fvc0235cS6esthgyDAc79I5y8TD3+/F5Y9cdm1QwCLSYun5EMwP82ZLb/epW5jVnQ0672rdZ1nce/PAjANXOHkxIZ2KXd1DSN789OYZvuyfY+1vd9vVVPb53JxR+rFVOvbnd7ACZdDsCw3E8AKW8uTmxLly4lMzMTu93Oxo0bmTu3serNqlWrePHFF5ttP2/ePDZs2EB9fT3p6encfffdzXp8DxYzPEHvrVkDP+ux1uHkvvd3c+2/N5FfWU9adBBv/Ww+v1o0Foupdy/veDO9M4prcLp61oLIm+k9Irr10uYAqVGBWIwGah0uX0UkIUTPWUJjAYjQqiRzUQgxYD3wwANomtZsGTduXN/uhGcC9XBDPuUS9BZi0JCgdzuCrSYKAlWp1KJD7Qe9q+xO37XH0C5lekt5cyGE0tWykg899BCff/45R44cYevWrfzwhz8kMzOTm2++GVABiNtvv53f//73fPDBB+zatYvrrruOxMREFi9e3Ge/lzfonV5UTa2jk4FaowkuegLQYMercGR17+1gU9meIE30GAiM7Nxzhp0EmgHKMqAiu1tvu8/T73xcfPuZ9ckRgQyLDMTl1vkuoxdKiTcLetsB1bO7I1HRKlvA6qzs3bLi9mqo9vSjb628OUhfbzE0aRosvB/O/K16vGq5qoTR5PPmLXG+cl8Bue0FB3a8qrKgh81vlgW9MaOU746WYTEa+NnpbXy+OrB4ehK7GANAVfr6br1GT5TWOJiuHSas5iiYA2Hi4o6fNGExaEZCSncxXMuXTG8hTkCTk8IwGTQKq+zkevpMD0QH8qu44G9reWm9mtx03bzhfHzbyb6gfW9LDA/AajLgcLnJLutZEPpIscoWT2ujnzeAyWhghOfnB6XEuRD+E6iqdEVRJW1dhBAD2sSJE8nLy/Mta9d2P9mkWzzfl9O0fCol6C3EoCFB7w7o8ZPUbd6udrer8Fwgs5kN2Mydn93uzQqXgVMI0dWykmVlZdxyyy2MHz+e888/n8rKStatW8eECRN829x5553ceuut/PjHP2b27NlUV1ezYsUKbLaOA5n+EhtqIy7UiluHvbmVnX9i8kyYfZO6//EyaOiDi5BdLW0Onr7e09T9o93r670vT13IG9dBpjc0ljhfl94LZd9byfSO7UTQ21tdwIQLHD3v89gmbz/vwCgICG99G19fb8n0FkPQqb+CRcvV/XV/g09+BW6VbTcqNoSTRkTi1uG1TVmtP1/XG0ubT7+m2Y/+/pWaKHLl7OROtTVoTXighcARJwFgyt3Su5NgWlFe28Dlxm/Ug/EXg7UTZX6DY2DEaQBcZFhPWY1jwGd6CiH8K8BiZHyCmng4UPt61ze4+On/tpBRXEN8qI2XfjSHhy6ZRKDF1Gf7YDRovnLkPS1x3pjp3XZ5c2gscX6woOcl1YUQHp7J3ZFapUz2E0IMaCaTifj4eN8SHR3dtzvgSbYYrhVIRTAhBhEJencgepQqbxtdc6Dd7bylzcMDLF16fV95c8n0FkLQtbKSjz32mG/b/Px8Pv74Y6ZPn97s9TRN46GHHiI/P5/6+nq+/PJLxowZ01e/jk+3SpwDnHUfBMeprN21j/XCnh3n2CZ1mzK3/e2Ol7pA3R5d0+W3dLt1X0/vjjK9AeaP6sW+3p6gt9MaRlW9ysrvTHnzlNgoHLqa8OWq7YUMdC9fafNRbW/jy/RO7739EKI/zft5YyWM756D95eAS31ef3jScABe++4YDa2Vns3+To2n5kCYcIlv9dasMtYeLsZk0PjJqd3L8vZasOB06nUzga5KavPaP3/2t+qaai42ejLMp/2g80+c9D0ALjauw+l2S39LIU5A04eFAwO3r/ejXxwko7iGuFArn/ziFE4dE9Mv++EtcX64qPtBaF3XfT29R7aT6Q0wJk69n2R6C+FHQSpoFKTZqazqwqR0IYToY4cOHSIxMZERI0ZwzTXXkJXVxuTu3uLJ9Jae3kIMLhL07sCYyXNw6xrRehmFecfa3K47/byhsRS69PQWQgxlk7ob9LaFqV62AGsf7d0+za4GyNmi7nc56N39vt5ZpbXUNbiwmgykRnXcQ9eb6b0nt9JXZcRvPEHvOpMKvgdajARbO84gSggPpBJ1UbKosMC/+9SUN9O7rdLm0Bj0lp7eYiibeQNc9i/QjLDjFXj7JnA6OGdCPNHBVgqr7Hyxt5XP4rb/qdsJlzTLgn7Kk+V96fSkLvfyPt7c0fEcMqrP4a5NX/botbpC13Vm1q8nVKvFGZLUOC53xrgLwGhhjCGHsdoxv/W3fHPzMV7/ro8vzAghusVbInzbsYGX6b0tq4zn1hwB4OFLJxMZ1LWJ9v7kDVKn9yDTu6jKTrXdiUGDYR2c+472ZXpL0FsIv7GG4kR9x6sv68XvbkII0QNz587lxRdfZMWKFfzjH/8gIyODU045haqq1s8J7HY7lZWVzZYe8/b01vIl01uIQWRABb2XL1/O7NmzCQkJITY2lsWLF3PgQPMMkfr6epYsWUJUVBTBwcFcfvnlFBT03klaSFgkeUZVtvXwrg1tbldepwa+Lge9bdLTWwgx9HkzvXd3NegNMPFSGLUQXA746I7eK5dbsBsaasEWDlGju/bcZn29c7r01P356kR8TFwIJmPHf5ZjQ22MiAlC12FDhp+zvWvVhd4qTV1gjA+1oWlah08zGjRqjOo5hUX5/t2npkrUBV+iRrS9jTfoXZbhy34VYkiaciVc+R8wmGHve/DcWVi+uIuHh21mpnaAd9btab69oxb2vKvuT2ssbb47p4KV+wsxaPDzM9qpotBJmqbhSpwJQNmBdX1WKrzK7uQybbV6MOX7YOjC15yAcBh9DqCyvf3R3/LjnXn8+q2d/N/buzhWWtvj1xNC9C5vpveenErsTlf/7kwTdqeLX7+1E7euJiadNT6uX/fHH5ne6Z7S5skRgVhN7beGG+sJeh8urMblltYTQviFplFrCgfAUVXUv/sihBBtOO+887jiiiuYMmUKixYt4pNPPqG8vJw33nij1e2XL19OWFiYb0lJSen5ToQPQ9cMBGl2DLUyXgoxWAyooPfq1atZsmQJGzZs4IsvvqChoYFzzjmHmprG/qB33HEHH374IW+++SarV68mNzeXyy67rFf3qyJsHADlR7a0vY030zuwu5neEvQWQgxd3qD34cJqah1dDERqGlzwVzAFqPLhO17rhT2ksbR58uyuBUtAZaQnTFX3M7vW19vXzzu+E71nPeaP9JQ4T/dz0NuT6V2mqwuasZ0obe7VYFbZ4aUlvfhFoERlo7Zb3jw0Sf1fcTuhPLP39kWIgWD8RXD1a2CyQf5O2PgM5xxZztvWB3ku73Kcj4yFlxbDirvgi9+CvRLCh8HwBb6XeOpr9bm6aGoiadHtl5ntrLTppwOQXLOHJa9spaTarnqPN9RDXTlUF0J5FhQfhjL/fE6rCo5ximEnAKYZ13SwdSsmqe8T3r7ePXGstJbfvL3T99jvY7UQwu+GRQYSFWTB4XKzJ3fglPv928pDHC6sJjrYyv0XTejv3WGkp6d3emF1tyc1HSlWAfMRHZQ2B0iJDMRqMmB3usmSCURC+E29RVW3cFdLEEcIMTiEh4czZswYDh8+3OrP77rrLioqKnzLsWNtV+ztNJOFhuBk9f51UsFLiMFiQAW9V6xYwQ033MDEiROZOnUqL774IllZWWzZooLNFRUV/Pvf/+bRRx/lzDPPZObMmbzwwgusW7eODRvazsLuKUuyCmRYive0uY23DGLXM729Pb0lG00IMXTFhtqIDbHi1mFvBxcSy2sd3PveLh75bH/jxbSIVDjtTnX/83ugN/pGH9uobrta2twr9WR128W+3t5M73EJHffz9po3QvVh2+Dvvt6eoHeJS12EjAu1dfqpui0cgKrSQv/uU1OdKW9uMECU5+clrX8ZEmJIGb0QlmyCi/8O85bCyLMoNaper6aafDjyNWx4WvX/Bpj6A9/EnoMFVXy6W1VnWOKHLG+vsNEqqD7JcJQ/HbyAkL8kwkMR8Ic4+NNw+MtoeHwy/H0mPDEFXrgA0r/qUSUPbfcbGDWdHdr4xjGgK8acR71mY5ihCC1nc7f3o8HlZumr26iyOzEZVKWMdenF3X49IUTf0DTNl+29NXNglDjfnVPBM6tVlZvfL55IeGD/lTX3SosOwqCp6xdF1fZuvUaGJ9N7RHRwh9saDZovu1xKnAvhPw22SAD0GpmYJ4QYHKqrq0lPTychIaHVn1utVkJDQ5st/qB7SpxHO3L6rIqZEKJnBlTQ+3gVFaoMbmSkOhnbsmULDQ0NLFy40LfNuHHjGDZsGOvXr++1/UgYOweAYY50CivrW92msts9vU3Nni+EEEPV5E709d6aVcYFf1vL/zZk8dTX6Xy1v0kAdf6tEDMeaktUxqK/HftO3abM6d7zu9nXe3++uoA3vguZ3ieNiPQ9t6SbFxxb5Ql6FzgDgK4FvY2BKlugrqqXLpzUlal/e/D1VWqT9PUWTTz11FOkpqZis9mYO3cumzZt6tTzXnvtNTRNY/Hixb27g/4QMRxmXAuL/gDXvsOOK9cxuf45fsjvcZz/BJy0BEaeCWmnweybfU972pPlfe7EeMbEdX4M6lBoIsRPASBEq8NCK5M7TTawhqm+5Jlr4b+XwrNnwL4PVVZ4Z7ndcOw7wve9AsCqwLO7t8+WQHYGq2B99NEPW99G16EkXVUc+fQ38OHt8PGvVCb95/fClw+y8flfcWru89xu+4i3p27hdMN21h0ulgskQgwC0319vcv7d0cAh9PNr97cgcutc8GUBM6d1PoF3r5mMxtJiVR9uA93s6/3kWJP0LsTmd7QWOL8kAS9hfAbV4CqHGasl4l5QoiB6Ve/+hWrV6/m6NGjrFu3jksvvRSj0cjVV1/dp/th9EyoTiGfGsfAaYEjhGibqb93oC1ut5vbb7+dBQsWMGnSJADy8/OxWCyEh4c32zYuLo78/NZ7iNrtduz2xoBAZWXXS5UFDZsOwEgtl08P53LhjJYX273lzcO7meldIUFvIcQQNykpjJX7C1sNeuu6znNrMvjTiv043ToWkwGH082fVuzn9LGxGA0aGM1w0ePw/CLY9j+VrZi6oOUbdUdlLlRkqb7cSTO79xrevt6lR1Rf77CkDp9SY3eSWaJKNY7tQtA7KtjKuPgQ9udXseFIKRdM8dOFUE/QO9eugt1dCXpbQ6MgDxqqeyELHxr7eYckgLWDzCBv0FsyvU94r7/+OsuWLeOZZ55h7ty5PP744yxatIgDBw4QGxvb5vOOHj3Kr371K0455ZQ+3Fv/OW10DOGRUawtDeQ9wxSuPPeGFttkFNfwwY5cAJae6b8sb5+bvoDSI9g1M/9en8vzG3Kp102EhQTzh8tncPo4T1/aihxY/3fY/ALkboPXfwjRY+GUZTDpcjX2H6+hHjJWw/6P4eAKqC4gEKjWbewOP6Pbu7w/6mzmVK1kWN7n4HZBfQXkbIXs7yBnM+Rs8Y2TbTkZONm7y/vgRQtsdowhZ7eF5MmndXvfhBC9z5vpvW0AZHr/Y1U6+/OriAyy8ODFE/t7d5oZGRNMZkkt6UU1zB8Z3eXnH/H0Ax/RyZYaoz1B7wMF3e8jLoRoTgtSn11LfS99dxNCiB7Kzs7m6quvpqSkhJiYGE4++WQ2bNhATExMn+6HMVrFgVK1AirqGgi2DthwmhDCY8Bmei9ZsoTdu3fz2ms96926fPlywsLCfEtKSkrXXyQknhpTBEZNJ2tf6+UOfeXNu9nT2+50U98gs4WEEEOXN9N793FB7/JaB7e8tJk/fLIPpyeb5etfnU5YgJmDBdW8szW7ceNhJ8GM69X9j+4AZ8/6rvp4+3nHTeo4oNoWW5gvs5GnT4I3rlPB+aqCNp9ywJOxEhtiJSq48/2zAU4aoWbn+7VsrieYk13nDXp3fp+Cw9SFE62uHJe7FzIaO1Pa3Ct6tLqVoPcJ79FHH+WWW27hxhtvZMKECTzzzDMEBgby/PPPt/kcl8vFNddcw4MPPsiIER1UFRigDAaNH8wZDsDLG1rvmf2PVYdx63DG2BgmecZnvzLbIG4C1tjR/PyS0/jXz84lNjqGnCo3N7y4mbve2Um13akmCJ27HO7YDaf+WmV/Fx+Ad38CT86A7/6tgty1pbD9VRUU//MIeOVK2PofqC4AayjpsefwA8c9BARHdHuXi+NOoVwPIrihGJ6YCn9Og5cvh9V/hMNfqjHSaIXkOTD3Z3D63XDqnXDyHdTO/BmvaBfwkvNsvou6BKb9ECZdTr1mZZbhIMlvXwxv3gClGf47xkIIv5qaHI5Bg9yKevIrWq/w1hf251fy969VtZoHLp5IdBfPEXubt9x4ejcyvR1ON8fK6gAYEdO5c+6x8Wo7yfQWg93y5cuZPXs2ISEhxMbGsnjxYg4cONAv+2IMVkEjW0N5v7y/EEJ05LXXXiM3Nxe73U52djavvfYaI0d2o41VD2meTO9ULZ/yWj9dgxRC9KoBOTVl6dKlfPTRR3zzzTckJyf71sfHx+NwOCgvL2+W7V1QUEB8fHyrr3XXXXexbNky3+PKysquB741jfrI8QQVrqMuaztwZYtNKrpZ3jzEakLTVLXEqnonNrOxa/smhBCDxORkFVQ5XFhNrcNJoMXE1qwybn1lGznldVhMBu67cALXzB2GpmksOWMkD3+yn0e/OMhFUxMbx8eFD6jsvuIDsO4JFSTpKW/Qu7v9vL1OvgM+XqbKcO99Xy0ACdNg9DlqSZoBBvW77M/zlDbvQj9vr/kjo3hx3VHW+6uvt677gt4ZtepvWVcyvUPCVdA7hGryKupIjgj0z355lXiC3lGdCEJKprcAHA4HW7Zs4a677vKtMxgMLFy4sN22OA899BCxsbHcdNNNrFmzpt338EdFod5y5axkHvviIDuyK9iVXeEbgwGyy2p5Z2sOAEvPHN0n+zNjWAQf33YKf/5sPy98e5RXNx1jzaFiHvneVOaNjIKgaDjzXtXK4rt/w/qnoDxLjakrHwJ7FehNJoiGJMK482Hs+ZB6Cu+sPMLOrHRmBHW/521ocCAfu07iGtNKqDimVkaOhORZkDxbVQKJmwSm5u/hcuvc/O+NrKsrYVx8CO/9dAF4/ma9EvgtQev+zBWm1Rj2vAv7PoK5P4FTfgmBke3vkL1KtcxI/wqObQRXg6ooomnqFs9t0yVhKsz5MUT3Qva+EENckNXE2PhQ9uVVsi2rjPMm931JcafLza/f3EmDS+fsCXFc5K9qPn40yhOsTi/qetA7q7QWl1snyGLs9OTK0bEq0/tIUQ0NLjdm44DN3RCiXatXr2bJkiXMnj0bp9PJ3XffzTnnnMPevXsJCupc5QN/sYSqikeBzvI+fV8hhBh0PIkXw7UCdknQW4hBYUAFvXVd59Zbb+Xdd99l1apVpKWlNfv5zJkzMZvNrFy5kssvvxyAAwcOkJWVxbx581p9TavVitXa85nRQcOnQ+E6YmoOUlRlJyak+Wt2N+htMGiEWE1U1juprG9o8bpCCDFUxIXaiA2xUlhlZ29uJduyyn3lzFOjAvn7D2Y0yza8bl4qL357lNyKev6z7ig/Oc0zozMwUmUFvnMLrH4EJl4GUT2c7Xlso7rtbj9vr4mLYfzFqkTvoc/h0Gfqft52tXzzZwiIhFEL4eQ72J+v+taOS+h6L925aVFomroAWFBZ36UAdascNeBWf8sOV3mC3iGdf02Dp6d3GDUcLa7thaC3J4DdmUxv7/+HqjwVNLL6sVexGDSKi4txuVzExcU1Wx8XF8f+/ftbfc7atWv597//zfbt2zv1HsuXL+fBBx/s6a72iqhgK+dNjuf97bn8b0Mmf/reFN/P/rn6CE63zoJRUcwc3v3M6K4KsBi5/6KJnDMhnl+/tYPssjqufnYDL988lwWjPCVybWGqtPncn8K2/8K3f4NKT8WPuEkqyD3ufDWZSNN8r11a42k11MWqS01FBFp40Pl9GqLHc8MFZ6hJSh0FplFZ8+vSSwgwG/n7D2Y0m8Q6deJ4Lv/mx7xtvpDX0z5GO/K1Kue+7X9w2p2qx7rJc/7vdqm/FelfQfrX6m+Tu5V+6O05tgE2/RNGL4KTfgYjTm92nIQQ7Zs+LFwFvY+V90vQ+19rjrArp4JQm4k/LJ6ENgA/vyNjVXCuOz29vaXN02KCOv27JYUHEGgxUutwkVlSw6hYOa8Tg9OKFSuaPX7xxReJjY1ly5YtnHrqqX26LwHhKugdplficLqxmGQyiRBCtCpiOG40QrQ66soKgL4try6E6LoBFfResmQJr7zyCu+//z4hISG+Pt1hYWEEBAQQFhbGTTfdxLJly4iMjCQ0NJRbb72VefPmcdJJJ/XqvtlSpsF3MN6QycaMEi6cktjs590NeoMqcV5Z76RS+noLIYa4yZ6+3ktf2UZ+pSobeeGUBJZfNpkQW/Px02Y2suycsfzqzR089fVhvj97WGMLiclXwPZX4MjX8N7P4MZPfdnTXdZQB3k71P2eBr0BDAZInqmWM+6C6kJVFvfQ53D4K6grhV1vwIFPMQbdC6QwPr7rmd5hgWamJIez41g5X+4r4Jq5w3u2354sb91oobxeHefYLpQ3J0AFzkK1GnaX1HDy6K73eGyXt7x5VCeyFwMiIDAaaotVhnjiNP/uixiSqqqquPbaa3n22WeJju7c/1+/VBTqRT88aTjvb8/l/R053H3BeMICzBRU1vP6ZpXFvPSMvsnyPt68kVGsuP1Ulr2+nc/3FvDf9ZmNQW8vS6DKiJ55owrkhg+DiNQ2X9Nbai6yB5neEUFmKgniLeO53DC6c/3cvztaymNfqjLEv1s8yVf212tKcjiBFiOb6hLZf/ZLjK/ZBJ//Fgr3wmd3w6Z/wcwbIG8nHFml/kY026k0GHkmjDgNbOGguz2L3ngfz/2GOtj1pupzfugztcROUMHvyVeAOaDbx0aIE8WMYRG8sjGLbVl939f7cGEVj3vGk/sumkhsTyc09pKRnkzvvIp6qu3OLvW2PFJcA0BadOfbCRkMGqPjQthxrJyDBdUS9BZDRkWFavsVGdnxBDt/CwhTk0IjqaS81jFgxxshhOh3JiulxliiXQW4S48Ak/p7j4QQHRhQQe9//OMfAJx++unN1r/wwgvccMMNADz22GMYDAYuv/xy7HY7ixYt4umnn+79nYufDMB4LYsP04vbDHqHB3b9QluozQzUUVnfxUwOIYQYZCZ5gt75lfUtypm35tLpSTz7zREOFFTx9OrD3HXeePUDTYOL/wZPz1eZcOufggW3dW+ntr+sMpyD4yC8h4Hj1gTHwrQfqMXVANnfwVd/gMy13OW4hzzDUsYldC64crxFE+PYcaycFbvz/Rb0dlnDoUYjPNDctZYbtnAAwqkhs6SmZ/tyPF2HkiPqfmez+qNHQ1axyhCXoPcJKTo6GqPRSEFBQbP1bbXFSU9P5+jRo1x00UW+dW63qsZgMpk4cOBAix5i/qoo1FtmDY9gbFwIBwqqeGdrNjcuSONf3xzB4XQza3gEJ43o+4usXsFWE7cvHMPnewv46kAhVfUNLSY/AaqUeFrH2U+lNSroHdGNc3Ev73l8WU3nJqKW1zr4xavbcLl1Lp2exOUzklpsYzYamJ0ayeqDRaxLL2H8yQthxBkq0/vrP0DZUfjygcYnWEPV7zvyTBh5BkR2sa/85O9B8WGV7b3tZRVc/+BW9R6zfqQyy0NabwslhFCZ3gA7syv6NPvR5db59Vs7cTjdnD42ptXxZKAID7QQHWyhuNrBkaJqpiSHd/q5GUXqHHFEdNdKOY+JDfYEvas4vx8y8IXwN7fbze23386CBQuYNKn1AEpvttExBKvJhlFaJfm1DRL0FkKIdpTakomuKcBYntHfuyKE6IQBFfTWdb3DbWw2G0899RRPPfVUH+xRE1GjcRksBLvryUrfAzSWiGxwuam2q4B19zK91T+DZHoLIYa6k0dH88TKQ6RGBfLUNTOYmBjW7vZGg8b/nTeWH724mRe+Pcr181JJDPdkqoUPg0V/gA9vg69+r/plx47r2g7lbocVnn6/82/t/RKwRjMMnw8/fJva124kMP0TnjY/gTszBeJv7vLLXTAqgFe1Atana5TXOro18crHE/S2m1XWeVdKmwMQEA5AmFZDRnFt9/ejNTXFYK8ANJX12BlRIyFrvfT1PoFZLBZmzpzJypUrWbx4MaAuMK5cuZKlS5e22H7cuHHs2rWr2bp7772XqqoqnnjiiQGVwd1Zmqbxw5OG8dv39/DyxiwumprIyxszAVh65qh+L5s7PiGEUbHBHC6s5vM9BVw+M7nbr1Xmj0xvzxha3olebbquAlS5FfWkRQfxu3bKEM8fGcXqg0WsTy/mppPTVGWSmdfDpMvVpK3sTapf+MgzIWkWGHv4FS16FJz/CJxxjyoRv/FfUJEF3zwCax+HtFNU2wejVZVWN1k99y3Nb40W9XfLaPEspsb7Bs99a4ga/21hKmA/AEsxC9EVI6KDCAswU1HXwP78yi4FdLsrp7yO/6w7yrascoKtJh6+dHK/j88dGRkTTHF1KYcLuxb0PlKsypuPiOli0DtOZXcfLKjq0vOEGKiWLFnC7t27Wbt2bZvb9GobnUAV9A7TatlXVQPxUkFBCCHaUhmQAjVbsFVK0FuIwWBABb0HNKMJPXYC5G8noHQfJdV2ooJVZk/TYHWoreuHNNST1VJZL0FvIcTQNjs1klW/Op34MFuns4jPGBvLnLRINmWU8tgXB3nkiqmNP5xxHez7EA5/ocqc3/RF54MFdeXw5vXgcsCY8+CkJV3/hbrLbGPd9L9ScMDONaaVGD79JdQVw2n/17mAgaMWNjzN8LWPs9pazZ0NP+aLvZO5YlYPgnKeoHetUQW9u1TaHBrLm1NDVrGfL0h6S5uHpYC5eTB++af7OFxQzWPfn+b7ewpAlKdsc/Eh/+6LGFSWLVvG9ddfz6xZs5gzZw6PP/44NTU13HjjjQBcd911JCUlsXz5cmw2W4tMm/DwcIA2M3AGg8XTk1j+6X4OF1az9JWt1De4mZIcxmlj+r8XmaZpXDQlkce+PMgHO3J7GPT2R09v9dwah6vDDM+X1mfyxd4CLEYDT149vd3yvvNHqgvLG4+U4nS5MRk9r2sNhtP/r9v726GAcDWha+7P4MDHsOEfajJQ+le9836aQQW/bWGq+octTO2D0Yoqwa63fest1e52qT7mustz3+W572xy//j17ubbaJral2ZLK+tu+ASC+/9zIAYWTdOYPiycVQeK2JpZ1itB7+JqO+vTS1iXXsK69GIySxonC95zwfjGCZ4D2KjYYDZmlJJe1LW+3kd8md6dL28OMCbeG/Tueh9xIQaapUuX8tFHH/HNN9+QnNz2uU+vttEJiMCFASNuassKAKkCI4QQbakNToViCKrO6u9dEUJ0ggS9u8CUOAXytzPBkMmmjFLO85TV8pY2D7GaGi9idUGoJzu8sk7Kmwshhr7ULpYz1DSNu84bx6VPr+PtrdncfMoIxnpnovvKnJ8EuVvh28fg1F93/KK6Du8vUWVlw4bB4qdVL+4+tL+whr84f0R0fDKLiv8Dq5ZDTRGc9+e2+5O73bDzdfjqd1CZA4AB+LPpX7y4PhRm3dv9HfIEvas1dWzju1rizlPe3KjplJSV4HbrGAx+ylIq8fbzbl7m92hxDf9crcqe3/Hadp69blbje0Z7gt6S6X1Cu+qqqygqKuK+++4jPz+fadOmsWLFCuLiVB/DrKwsDH382e9rITYzi6cn8crGLDYcUf2il57R/1neXhdPU0HvtYeLm00q7Qpd1ymr6Xmmd6jNjEEDt06b/S3rHC6e/zaDJzx9d+86fxyTktqvWjIhMZRQm4nKeie7cyuZlhLe7X3sFqMJJlyiltztkLdDTfhy2sFlV7dOe+M673pXg2dxqDYg3vu+9XawV6lJZC67ClrXlfn+ngx4uru/90AMUDOGRbDqQBHbjpVzgx9er7K+gU1HSvk2vZj16SXsz28+OdBo0JiaHMaFUxL5/uzBUVXE29f7cGHng9AVtQ2UeMbqtC5neqv3O1pcg93pwmrqQgseIQYIXde59dZbeffdd1m1ahVpae1XsOrVNjoGAzWGUELd5dRXFPbOewghxBDREKbaCYbXZ/fzngghOkOC3l0Rr0qaT9Ay+eZIiS/oXe4Jeod2o7Q5NGZ6V0h5cyGEaNX0YRGcNymeT3fn88hn+3nu+tmNPwxNVIHid38Cq/4EY86F+Mntv+CGp2H/R6o065UvQmDf97Xdl18FaByd/AsImAyf/Bq+e06V8r7sX6rcbFNHVsHn90K+p/xyWAqcdR/lB9cSvvs/3FD8F+o2DSNgznXd2yFPkKJMVxch47oa9Dbb0E02NGc9Aa4q8irrSfJXppI30zuyeT/lt7Y0fuFYub+QJ1Ye4o6zx6gVUaPUbclhNclhgAT4RN9bunRpq+XMAVatWtXuc1988UX/71A/+OHc4byyUc1KHxcfwsLxcf28R43SooOYnBTGrpwKPt2dzw9PGt7l16iyO3G6VZuknvT0Nhg0wgLMlNU2UHZcf0u3W+fdbTn85fMD5FXUA3DB5ARumJ/a4esaDRpzR0Txxd4C1qeX9H3Qu6nEaWrxt4Z6qC+H+goVBG963+XwjMGecdh7v+mtpqmS6ZpRTfwymFQ2tsHU5LFRTVBrsZ33vlHdh8bMcd+it1znqVAixPG8fb23ZnV9Aoeu62SV1rIls4zNmWVszSzjQEEVx3dyG58QyvyRUSwYFcXs1EhCbN2vUtEfRsV2PejtLW0eF2pttzpGa+JDbYRYTVTZnWQU1zAuPrRLzxdiIFiyZAmvvPIK77//PiEhIeTn5wMQFhZGQEDfV3ioNYcTai+noaqoz99bCCEGlUiVgBHtyB6615dcDSoxyBKsrpEef01SiEFEgt5d4QmiTDBk8khGqW+1N1jd3XKK3j7gUt5cCCHa9qtFY/l8bwFf7itkU0Ypc9KaBKqnXAV7P1DlW9/9GdzylepJ2pqsjfDFfer+oodVH9V+sD+vEoBxCaEw5hYIjIJ3fgx734O6UrjqZbCFQuE+tb+HPldPtIbBKctg7k/BbCNs0vd470Ahixs+xfbJbWAxwbQfdH2HPEHvElcgoC5IdpVmC4fqfMKo4UhRtf+C3t5sbW8gG3C5dV/Q+/zJ8XyyK58nVh5iUlIYZ0+IU72/NQM4qqG6AEKkZJ84cU1IDGVuWiQbM0r5xVmj/VeFwU8umprArpwKPtiR262g90ZPBntkkKXTrTPaEhFo8QS9G/t6r0sv5g8f72NPrhq3k8IDuPPcsVw0JbHTGfPzR6qg97r0Yn52+siOnzDYmG1gjpexVgwJU1PC0TQ4VlrHV/sLCA+0YDUZsJqM2Mzq1mo2YDUZ0HXYnVPBlswytmSWsTWrjOJqR4vXTI0KZP6oaOaPjGLeiKhuVbUYSEZ6gt6ZJbU0uNyYO1HxrrulzUFVfhoTH8KWzDIOFlRL0FsMSv/4xz8AOP3005utf+GFF7jhhhv6fH/slgiwH8VdLUFvIYRoj8lTdTBIr1HXzvohcaZVVflw4BMViI+fAnETwNLJajpuNxTshozVcGQ1ZK6DhprGn1uCISASAiPU9cqASPV7B0ap621xEyB6jATH29JQryZamwOG5iSJAU6C3l0RNxGABK2UwvwcymocRARZqPD0EAzrbqZ3gPpnqJRMbyGEaNPImGCump3CKxuz+OOn+3j7Z/Mbgw2aBhc9rnqVFuyCbx6BM+9p+SI1JfDWjarv58RLYfbNffo7eNU3uMgoVieT472l2iddpk4gX7sGMr6B/1wICdNg23/ViZLBpPb31DshKMr3WprBwKGZ9/PSWifXmb6A936uftDVwLcn6F3QoILerZX17VBAhAp6azV8sbeAU0b7qVdqiSphTlRjoGjNoSLyK+sJDzTz2FXTiA3Zz4vrjnLH69t5b8kClYEUPhzKMlRfbwnEiBPcP6+dyZHiGmYMG3jZrRdOSeThT/bz3dFS8irqSAjr2oSZZ79RY8SVs3peFtg7ibW81sHhwiqWf7KflftV2c8Qq4klZ47ihvmpXQ6ue/t6f3e0tMN+4UKI/hVqMzM6NpiDBdX86MXNXX6+xWhgcnIYM4aFM3N4BDOGRXTvvGoASwyzEWgxUutwkVlS68v8bo8307urpc29xsQFsyWzjEMFVR1vLMQApB9f8qGfNVgjoQqoLenvXRFCiAEtJDSEHD2KJK1Etd/rz6B3TQnsex92vwNH1wJN/7ZoKlkkfjIkTFG38VMgOFYFxkuPqCqSGd/A0TUtx39zoGp1pbtUAomjGira6WOuGdX7xU2AWM8SNwHCU5u3kHS7wVkHDXXQUNt4CxCaBEExgzMw7LSr7PiSdFWh0nd7xNOSUgeDGQLCwRbmWTz3m66zhoAlRN22tphsfXt8hkA1Awl6d4U1RJWzKD3CeEMmGzNKOXdSfI8zvb3lzSvrpae3EEK05/azRvPu1hy2ZpXz2Z4Czp3UJJAZHAsX/FUFtdf8FcaeB0kzGn/udsM7t6gTj6hRcPGT/fZH/FBBNW5dZSXGhDSZFTnidLjhI/jf91TP1bwdav34i2Dhg82Cvk2dNzmRC1fdgMkAPzB0M/DtCXrnOtRF2S739AZ10gaEU83723O5+/zxPc66VCfmLcubv+nJ8l48LQmrycg9F4xnb14lmzJK+fF/N/P+kgWERI9WQe+Sw5B2Ss/2Q4hBLjzQwoxh3S/93ZsSwwOYkxrJpqOlfLQjj1tOHdHp527LKmPT0VLMRo0bF6T2eF+8PcH/tvIwBwqqcLl1TAaNa+YO4xcLx3S7Z/iYuGCigiyU1DjYfqy8ebUSIcSAc/vCMfxjVTp1DS7sThf2Bjd2pxu700V9Q/N+8NHBVmYNj1AB7uERTEoKHfI9pzVNY2RMMLtyKjhcWN2poLd3wueI6O4FvUfHqomiB/Il6C2EP+iBakKeqV6C3kII0Z6wADOZ7jiSjCUqcJwyu+Mn+VN9Bez/GHa/Delfq6C0V/JsFTjN2wk1hVBySC173mncJjhOBV8rj+tJbg6C1AWQdiqknQZxk9R6ewXUlqrrhLUl6n5tiapKWVOkEksK9qrtig+oZc+7TV43UGWGewPczrr2fz+jFcKSPUsKhKc0Pg5NVgk21pC2K3q2xu327H+xaiNZW6ySieImqgSZrl4PriuHnM1wbBPkbIHig1CRrZKU2t2PBnXManpQVcVgVte8Q+Ih2FNdzbsEx0NInLo1WdTvrbvV/xFvWy93k/v2KqguVBUxqwua3G9y66hW13cDIhoz/JvdRqjgve72/Pva1b+x097ysdvZch987cearLvoCfXv7ScS9O6quElQeoQJWiYbM0qaBb27n+ntCXpLprcQQrQrNtTGzaek8eRXh/nzZ/tZOD4WU9NyipMug30fwJ53qXrtFv426jkOlTYwf2QU1zreJCB9JZgC4MqX1AlTP9mX7yltHh/SsjRu4nS46XN48wZVTuis+2D4vHZfb2JiKMkRgdxddgMLJkQz/MirXQ9815UDkF2vgt1d7ukN6qQHGBbo4JPqBr7cV8CFUxK7/jpNVeWpE2XNCBGq7HFZjYMv9hQA8L2Z6qTIbDTw1A9mcPHf13KkqIZlb+zgXzEjVQdZb3l0IcSAddHUBDYdLeXDnbldCno/u0ZleV8yLal749Zxwj09wfd6WlCcMyGO/ztvHCNjul6OtylN0zhpZBQf78xjfXqJBL2FGODOn5zA+ZMTWv2Zrus0uHTsThdOl054oLnTrQ6GkpExQezKqSC9qHN9vb3lzbs7no71VEc61IU+4kKItmme6mF6TQlOl7v592ohhBA+4QFmNupxzGcv7pJ0mo2WVQUqYSV/hwo85+8EpwNix6slbqLKgI4Zp1pCdcTtUoHHylx1LWvfB6rdoatJ+5z4KTDpclXBMqJJe7CqAsjfpfYhf5daSg6rYCaA0QLJc1SQe8Rpqt2jsZV4VkCEWtqj62ofC/eqpWAvFO6BooOeYHdt688z2VTJb3Og53ctAJddJbt4E17aYrJ5sp9D1a0ttPF+Q63KgvcGuetK2w5IW8PUv0v8ZIifpG5jxjf+++i6Cuxnb4JjG+HYd1C0n+ZZ9R6WYJUkGzVSJeo0vTVZ1YSFunJ1W18B9eUt1zmqVDDat1SrW4dnoqe7QSVwVea0f3z8qa7Mkxx1pG/ez+7f83sJendV/BTY9wHjDVk86+kfWO4pbx7a3aC3zVPeXHp6CyFEh3586gj+tyGTI0U1vLklm6tmpZBeVM13R8vYnFnKoYxLeV5fSUzVYaK++yvPOq/GfmgVN5n/CBpkzfsdwzztKvrL/jx14tJmP8KokfDTNZ1+PU3TOG9SPM+uyeBR0y08MSsQNv/bE/jWYNrVHb+IJ9O71B2EpkF0cDeyGT0nxfMTjTxzEN7cnN3zoHeJ56Q3YrjvZPz97Tk4XG4mJIQyKSnMt2lMiJVnfjiTK/65ni/2FvD1pDDOBAl6CzEInD85gQc+3MvO7AoyimtI60QmYGZJDSt25wNwyymdD5S3Z3yCGpenJIdx9/njOWlEVAfP6Lz5nqD3uvRifrFwtN9eVwjRtzRNw2LSTvg2Bd7s7vROBKHdbr0x07ub5c1Hx3n7iNdQ3+DqeTUhIU5w0XFJsA+M9SXc8+5u/nj55BNyAo8QQnQkNMBMpq4qTbrTv8aguzyB7p2NAeXjVeVC+srGx5pBBUPjJkDsRJXNXF2oEj0qc9VSlaf6dDfN5PaKHgOTvqeSfaLb+C4ZEqeW0Qsb1zlqoGAPOOshaRZYArt5FI6jaRCWpJbRZzeudzlVNryjSmWSmwNUn3FzgEpCMhx3/ux0qGNVkQ3lx9RtxTHPkg0VOY29xp31aulK1rQtTJVPD4xWr1O4X2WoZ61Ti+/3MapjHBKn/m0910ibiUiDlLkq0z92gvr3DI5tP2vcGtL9DGa3W+1zXXnj/5XqfPV/xLt4H9cU0yworxmaLEZ1azCqyQYhcSr7PzgWgmIb7wd71luD1XvWlXoy/o+/LVPBeoPJM4nBpm59i9Xz721VWepN98VgaH3f/NySUoLeXRU/GYAJWib78yupqG1oLG8e0L1yh42Z3lLeXAghOhJiM3PrmaN56KO9/OHjffzx0/2+cVgxcY/xZv5lfpQfmz5mxLRTmb3nKYy6zhvO07jzi0Sm7FvLD08azsVTE/vlgtl+b6Z3gv+yzc+dlMCzazJYeaAY+71/wooOm5+H936mNugo8O05oSvXg4gOtnZvpr+nvPnUaOCgp+92RT3xYT3IvmyntPmVs1qeOE5NCef3iydx51s7eW6vkTMtqBmaQogBLSrYyoJR0XxzsIgPd+Ry21kdB4X/vTYDtw6nj43xZQD21I8WpHLWuFiGRQZiMPj3wq+3r/e2rHLqHC4CLBKwEUIMXr6gdycyvXPK67A73ZiNGknhAd16v5hgK+GBZsprGzhcWN1s4qMQouvCo1U1izitnNc3HyMmxMqvFo3t570SQoiBx2w0UGBSCR2mnE2Qs6nJTzUVLE2YAglTVcKkydYyA7qurLH0+N73239DzaDKVYcmqozsiZepzOTuTEyyBEHKnK4/r7uMJogZ0/ntTRaISFVLW1xOsFd6sqA9t/XexxXq1hwIgVEQFK0C3EHR6vHxmexOhypNnr8LCnY3ZsXXlUHRPrWA+jdMnKEC3ClzVYZ8cExXj0bPGAyNfb3DU9rf1uUEdE8QWet5O08/B6H7mgS9u8oT9B5tyMGiO9h0tJSKOlVeosflzSXTWwghOuWak4bxwroMjpWqvjA2s4FpKeHMTo1kVmok04edA5/kYtj5Gufs/jUAdRHj2BJ7N5bdZezMruDOt3byh4/3ceWsZK6ZO5zUbvYX7Cpd19nnKZs7vq1M726YnhJOXKiVgko7aw+Xctb5f1U/8Aa+s7+DBbe1fSLpDXoT3L1+3uArbx5Gta8/79tbs1lyxqjuvR40ZmlHqdfYnVPBntxKLEYDl0xLavUpV85KYXdOBZ+tVxVZ9LKjaK6G1ss2CSEGjIunJvLNwSI+2JHLrWeOajfbqLTGwRubjwHwYz9leYPK4OytvwepUYEkhNnIq6hnS2YZJ4+O7pX3EUKIvuAtU55eVIOu6+2O2d4s7+FRQd0uoaxpGmPjQtiYUcobm49J0FuInopWQYlZhoNcbviGv3+tqn3dsCCtn3dMCCEGnj22GWypG834GCuBw6arAHfCVBWMtrTy/XHY3Mb7uq4ywgv2eILh+1Sp6uA4CElQwe3QRAhJhNAElX1rlLCdj9Gk+kkH+qFFmMniKWk+qXGdt1R7/i6VTZ0wBeImd62HeH+T/y/NyNHoqtBECIjEWFfKaC2bDUdKet7T21Pe3OF0S5kuIYToBKvJyEs/msu69GImJoYxMTEU8/EX0M77I2SsVicslmACrnmZP0WP4s5qO29szubljZlkl9Xx7JoMnl2TQVyolUCLiQCzkQCLkUCLkQCz59azfkRMEJfPSO5Rdl5RlZ2y2gYMWmOZRn8wGDTOm5TAi+uO8smufM4aHwfn/1XNEP3uOVXufMuLMPkKOPkOiB3X+OSGOnCqCQQVejDjQq3d2wlPpjf15XxvVjKbjpby1pZsfn76yO6Xyivx9I+JUpneb3myvM+eEEdEUNsnoPdeMIF9uRXU5FsJwk5NwWGCEsd3bx+EEH3inIlxWN41cLiwmv35Vb5S463534ZM6hvcTEoKZd5I/5Ug702apjFvRBTvbMth/ZFiCXoLIQa14VFBGA0a1XYn+ZX1JIS1ncF9xJMNPqKHk4p+fOoINmaU8tL6TCYlhXHlrA6yXoQQbYufrL4Xrn2MP1ufJc8eyYMfqeo7F03tYYsqIYQYYsyBYVxe8SAvnjOb08fGdu3JmqYyZ0PiYdRZvbODovualmoXQ8KJ3YSqOzStscS5IZONGY1B7/DA7gW9gywmvNUTJdtbCCE6Jy06iGvmDmdaSnjLgDeo/tKXP6fG7Mv/DdEqUzgq2MrPTh/J6l+fwfM3zOKMsTFoGhRU2skormFvXiVbMstYc6iYz/cW8N72XF7dlMXz32Zw73u7OeXPX/PcmiPUN7TSY6cDDS43723PAWBETLDfJzmdO0mVn/lyXwENLrcqhXP+X+D6j2Dkmaov0M7X4Om58No1kLNFPbGuHAA3RqoIILa7md6ent7UlXPB5AQCLUYyimvYnNlKL5zO8pU3H4Hd6fIdvytaKW3elMVk4KkfzuSYQV2wefGDL3C79XafI4ToX6E2M2eMVSXDPtiR2+Z29Q0u/rPuKKB6eQ+m/pPeAP269JJ+3hMhhOgZi8nA8EjVFzK9sKbdbY/4+nn3bMLnWePjuH2han9x77u72ZbVg3NMIQSceR9Muhyj7uJ52xOM5hjL3tjO2kPF/b1nQggxoHiTHZu3VxRCDESS6d0d8ZMhYzUTtEzezK0k2KIOY3czvQ0GjdAA1Zuqsq6B2JAe9D4VQgjRKPVk+OnaVn9kNGicOS6OM8fFUVhVT2GlnboGF7UOF3UOp7ptcFHnUOtq7E4+3pVHdlkdv/94H//85gg/O20kP5g7rMPgdX5FPa9uyuLVTVkUVtkBmJLs/5KMs1MjiQ62UFztYH16CaeOiVGTtdJOUUvOVljzV9j/UeMy4gwYfyEAtcZgQOtxeXPqygiymjh/cgJvbcnmzc3HmJ3ajTJEbheUZqj7UaP4cm8h5bUNxIfaOGV0x710YkNsmFInQkYG5cf28dL6o1KuT4gB7uKpSXy2p4APd+Ry56KxrQa039maQ0mNg6TwAC6YnNAPe9l93qD3zuwKquobCLFJ2wUhxOA1MjaYI8U1vLlF9QMeExfc6rjtLW/e00xvgNvOHM3e3Eo+31vAT/+3hQ+Xntz9CZtCnOgMBlj8D6jMw5a1jteCHmVR9X385L+bef0n8zrdRmB3TgUZxTWcNym+2y0MhBBiIPMmO0rQW4iBT85EuiN+CgAzLNnoOlTZnUD3g96gMlsAKuqcPd8/IYQQXRIbYmNSUhizUyM5bUwM505K4LIZqtf3zaeM4LazRnPX+eP56pen88fLJpMUHkBRlZ2HPtrLqX/+mhe+zWiR+a3rOusOF/Oz/21hwZ++4omVhyisshMdbGXpGaO478IJfv89jAaNsyeobO9Pd+e33CBpBnz/Zfj5Rph6NWhGOPI1fPxLAKq0EADi/FDeHPCVnPx4Zx61juP+vumdyLquyAaXHYwWCEv29e/93sxkjIbOZXZGDpsIQJqWx58/O0BOeV2nnieE6B9njoslyGIku6yOrVnlLX7udus8t0a1PfjRyWmD7sJqckQgw6MCcbl1vjta2t+7I4QQPTLFExB7f3suix7/htMeWcXvPtrL+vQSnC63b7sjRd5M754HvQ0GjUevmsbo2GAKKu389H9bsDu7XoFJCOFhsqrviFGjiHQW8EbIY+iOGm54YRNHi9uu4lBZ38B/1x/lgr+t4cIn13Lrq9v47ft70DvzPU8IIQYZX6Z3rQS9hRjoBtdVooHCU958DEfRaPwiF9bN8uYAoQEqW1zKmwshxMBlMRn4/pxhfP2r01nuCX4XVtl58EMV/H7x2wwKq+p5fm0GZz26mh88t5FPd+fjcuvMSYvkyauns+43Z/KrRWMJD2y7H3VPnOcpcf7FXvW+rYodB5c+A7dtg9k3g1EFuQtR5cl7Xt68AoDZqRGkRgVS43DxyS5PEL66CD66Ax5OhPd+DrXtBH28pc0j0sitdPDNoSJABb07LUqVtZ8WUEStw8V97+2WCzFCDGABFiNnT4gD4MNWSpx/ua+AI8U1hNpMXDV7cPZyne/J9l4vJc6FEIPcT04byZ8un8xZ42KxmAxkldby77UZXP3sBmb94UuWvb6dD3bk+iYd9rS8uVew1cS/rptFqM3E1qxyHvhAAm1C9EhgJFzzFgRGk9ZwmBdD/kFZdR3XPr+Rwqp632a6ribt/fKNHcz5w5f89v097MmtxGI0oGnw6qYs/r02ox9/ESGE6B3euE+5ZHoLMeBJ0Ls7okeD0YrNXUuKpi7AGzR8Zc67w5vpXSkDpxBCDHgWk4GrPcHvhy9tDH4/8OFe5vxhJQ99tJcjRTUEWYxce9JwPrv9VN74yTwumpqIxdS7f3rnjYwiLMBMcbWj4yzCiOFwwV/h9l1wzh942H0DAHHdbbPhLW9urwC3C03TfAHqd79Lh7WPw5MzYPPz0FAL21+Gp+bC3vdbf70ST9A7aiTvbFXVVeakRZLaldKYnqD3GHMhFqOBlfsL+XhXXvd+PyFEn7h4WiIAH+/KazF551/fqCzva04aTrB1cHZqOmmE9PUWQgwNFpOBq2YP4983zGb7fWfzzA9ncvmMZCICVfu2d7blcNur2wBVFjQyyH+TPtOig/jb1dM9gbZjvLwxy2+vLcQJKTINfvA6mGzMafiOvwS/zLHSWq5//jsyS2p4bs0Rzn7sG654Zj1vb82mvsHNmLhg7rtwAhvvPot7zh8PwB8+2ceXewv6+ZcRQgj/kp7eQgweEvTuDqNZZckB47VMQA18hk6WWm2NL+hdL+XNhRBisLCYDPxgrgp+/+HSSSSGqWDx2LgQfrd4EhvvWcjvFk9ibHxIn+2T2Whg4XiVJbmitRLnrQmJwzHn52ysVb1x48O6m+kd3ni/XmV7XzY9ifONG1meexN8eT/YKyFhKlz8d4geAzWF8MZ18No1UHXc/nqC3nrkSN7ckg00lkzvNE/Q21RbyO2nqOPywAd7+68klatB/V6Hv4RtL8PBz6FgL9RX9s/+CDEAnTwqhrAAM0VVdjYcaQwMb8ksY3NmGWajxo3zU/tvB3vI29d7b14lZTWOft4bIYTwj0CLiXMnxfPXK6fy3T0Lef3HJ3HzyWkMjwoEYMGoaL+/5+ljY7lzkbo288AHe9iUIW0jhOiR5Flw+XOAxqXOFdwRuIJ9eZWc9sgqfv/xPg4XVhNgNnLlrGTe+fl8Prv9VH50choRQRZuOjmNq+cMQ9fhtte2sTdXvt8IIYaO8AA1ca/cT9eSjm+RKITwn8GZHjEQxE+GvB3MD8rls6qe9fOGJuXNZbaQEEIMOhaTgWvmDueKmSkUV9tJCLOhad2fCNVT502K5+2t2azYnc99F07o1KSsomo7AGajRkR323UYzWAOgoYaqCuDsgwSP7uHp83rAai2xBB8/kMw5ftgMMCUK+Gbv8DaR2H/R3B0DZzzB5j+Q9A0X3nzDD2ezJJagixGzp8c37V9soVCcBxUF3DzBDfv7A3mcGE1D3+yjz99b0r3fs+OOGqgLBPKMqD0CJRmNN4vPwZ6G19urGEQltxysQSDwehZTKoXu8HUcl3MODDKqZ0Y/CwmA+dPjufVTcf4YHuuL1Di7eW9eFpS99swDACxITZGxwZzqLCajRklnDspob93SQgh/MpkNDB3RBRzR0RxzwXjKai0+zXLu6mfnjaCPbkVfLQzj5+/vIUPlp5MYnhAr7yXECeE8RfBoofhs7v4hfu/ZFqjecc+mynJYXx/9jAumppAiK3l90VN03jokolkltSwLr2Em//zHe8tWTCoz9mEEMLLG/vpaeymxu7k9te3s/pAEb85bxw/OjnNH7snhGhCrox2V7y6UD7blg1VENbD3qyNmd4S9BbiRPbUU0/xyCOPkJ+fz9SpU3nyySeZM2dOq9s+++yzvPTSS+zevRuAmTNn8vDDDzfb/oYbbuA///lPs+ctWrSIFStW9N4vcQKzmAwD4iLbyaOjCbaayK+sZ9uxcmYOj+jwOQWVqldbbEgPA/YBESro/cFtkLkWAKfRxt/t5/Oh9Qq+mHJeYxDeZIUz74EJl8D7SyBvO3ywFHa/BRc+7sv0XpGnyplfOCWRwO60EokaBdUFWN69iTciJ/CfkgAObk1m+4g6pk2doYL1XVFfoYLX5VlQ4bn1LhXHoLaDksUmG0SkQWgC1BRBRbaaJGCvgMIKKNzT9d8R4NfpEOT/LCoh+sNFUxN5ddMxPt2dx+8WTyK3vI4Ve1Q1iFtOHdHPe9dz80dGcaiwmvXpEvQWQgxtmqZ1v4pQJ1//z9+bQnpRDfvyKvnJf7fw5k/nYTMbe+09hRjy5v0cyjNh4zP81fQ0v1z8X5KmLVATk9thNhr4xzUzufQf33KkqIZbXtrM6z/p2ucxp7yOEJvJd51UCCEGgrhQKwDbjpXx8sZMrpk7vMuvUVhZz4/+8x27c1QljIc+2suxslruvWACxh5UEBZCNCdB7+6KnwxAmjMDgOQeBjlCfbOFpLy5ECeq119/nWXLlvHMM88wd+5cHn/8cRYtWsSBAweIjY1tsf2qVau4+uqrmT9/PjabjT/96U+cc8457Nmzh6SkJN925557Li+88ILvsdVq7ZPfR/Qfm9nImeNi+WBHLit253Uu6F2hgt7eE/luCwiHymxfwJupV+M89W6ef3IflRVO1qWXcPLo4wKz8ZPg5pWw4Wn4+g9wZBX8Yz441T69fkTt05Wzk7u3T2MWQea3UHaUyLKj3OG9fvLBE+gfmdGiRqm2JdFj1Xp7pVrqPbf2Ks/9KvW4obbj97SFqcB25AjVH6/p/eB4lenelL0aKnNU0LwiRwXCK7LVY2c9uJ2exa1udZfnscuzOFXGtxBDxNy0KGJDrBRW2fnmYBGrDxah63DG2BjGxPVdy4jeMm9kFP9Znyl9vYUQwg8CLSb+de1MLv77WnblVHD3O7v465VT+7XykhCD3qKHofwY2oGPSXr/SvjY5qlElQLhKerWdz8ZQpPAaCYs0Mzz189m8dPfsiO7gl++sYMnr57eYfWxw4XVPP7lQT7elUdYgJn7L5rA4mlJ/f85dtRA0QH1/S5qZM9eq6EOCvepCl2WQP/snxCiT8wcHsGFUxL4aGce97y7mz25lTxw0UQsps51Dz5UUMUNL3xHTnkdkUEWLpmWyAvfHuWFb4+SW17H41dNJ8AiE/aE8Ae5OtpdcRMBCKjL47nvpTFlbM8yTkJtnvLmkuktxAnr0Ucf5ZZbbuHGG28E4JlnnuHjjz/m+eef5ze/+U2L7V9++eVmj5977jnefvttVq5cyXXXXedbb7VaiY/vYkloMeidNymeD3bk8unufO4+f3yHFwu8md49zsSJGgUFu2HYPHWhJGkGNuDiaRX8b0MWb2451jLoDaos94LbYNwFx2WJB5BZH8qImCBmDOs4eN+qBb+AiZepCwxF+3Dk7+PQ7u9IdR8jyG2HIrW+SwKjPBd5hqnFd99z8adpf/POsAZDzFi1CCEwGjQumJLAC98e5T/rj/LdUdWn9cen9vBi4wAxNy0KTYNDhdUUVtUTGyKlP4UQoidSIgN56gczuPb5TbyzLYcgq4k7zx3bahnmzsguq2X5p/vJK6/jd4snMTExzM97LMQAZzCq/t5v3gCHPlcTcUsOq6U1mkEFvyPSSI1M44NpsTyyycGR3bE8tULn1vNnNt/e7YK6cnJyj/Hu2h3sOXyECKr4uaEKi8NJxlsG3l0dwsKJiYQG2tT+aJ72TppBBaGjx0D0aDD7odqa2wVlR9V32YK96rZwr2pVha62iZ0AExbDxMWd/97mqIXDX8Ce9+DgZ6oqmiUYxl+s2n2lnap+JyHEgKZpGk9ePZ3xCaH85fMDvLIxi4P5VTz9wxkdfpdbl17MT/67hap6J2nRQbx442yGR6lrXL98Ywef7Sng6mc38Nz1s4gOlkQlIXpKgt7dZQuDiFQoO8rCyCIImdCjlwsL9E9fCCHE4ORwONiyZQt33XWXb53BYGDhwoWsX7++U69RW1tLQ0MDkZGRzdavWrWK2NhYIiIiOPPMM/n9739PVFRUq69ht9ux2+2+x5WVld34bcRAcNrYGGxmA9lldezJrWRSUvsX6gqq1L97jwMvi59WQebE6c3K310xM4X/bchixe58KuoafP2QWogaCdd/CFv/A18+wHqmARpXzkrp2Sz/cE8WwphzsADHxuZz4f++I8VQysuXhJHizFQXcAxmsIaoXuBWz2ILVeusntugGBWkFkL0qounqtnvaw4VAzA5KYyTRkR28KzBISLIwoSEUPbkVrI+vYRLpiV1/CQhhBDtmj8qmt9eMJ4HPtzLfzdk8tmefO69cAIXTUno9Hmk3eniuTUZPPnVIeob3ABc+vQ67r1gPNeeNLz/s06F6EuWQLjmDXA6GqtSlR/zVKTKanI/G1z2xpZPGasZBjxpQl153gT27RFYo4arbOfaYvS6MjTdTRKwFKC1r4flwLcd7aSmrs/GjvdMIh6nbqPHNmZTO2qgphhqi6GmxHNbpNbVFEHRfijcD8661t8iMBrqy1UQvHAvrHq4/QC4o1ZNFNj7Hhz8XAW6vUwB4KiGHa+oJTgeJn8PplylqorKGCPEgKVpGkvOGMWEhFBue20bmzPLuPjJb/nntTOZmhLe6nPe3ZbNnW/tpMGlM3N4BM9eN4vIINUm96KpicSF2rjlpc1sP1bOZU+v48UbZzMiRq43CdETEvTuifjJahZg/i4YcVqPXsrX01uC3kKckIqLi3G5XMTFxTVbHxcXx/79+zv1Gv/3f/9HYmIiCxcu9K0799xzueyyy0hLSyM9PZ27776b8847j/Xr12M0tpxNvHz5ch588MGe/TJiQAi0mDh9TCwr9uTz6e68joPeld7y5j0MeluCIGlGi9VTksMYExfMwYJqPtqZ237/I4MBZt3I4eTLuPbxNRgNGpdN929A6NxJ8ZwzMYHP9hi4dXM4b//sEumhJMQAMy0lnJTIAI6VqguQPz51xJAKNswfGcWe3Eo2HJGgtxBC+MsNC9JIiwnm/vd3c7Skltte3cbr32Xx0CWTGNnBReQ1h4q4//09HClWAaq5aZEEW02s3F/Ife/vYd3hEv70vSltT94UYqgyWVSbpsi01n/udkNNocqKLstodltbcJhAZzlWRxnklfme4j2jq9ADqTNHEBIZT1BEPARGgslKRU09G48UUV5dj1FzEx9sYnpyKIFmVFZ2bYmq5FVfrt6rLAMOfNJkpzQIjlVtqtoKZrf4PW0qeB47EeImQNxEasLH8ti6MiwNldwUs4+ozE8g/evmAfCY8TDxUtXOav9HKuDdtCVW2DCYeAlMuFRNDj+2EXa+Dnvehep8WP93tcSMV9nfk69QE7Z7wu0CVwOgq99rCJ1DC9HfzhgXy/tLFnDLS5tJL6rhin+u5+FLJ/O9mY0t+XRd56mvD/OXzw8CcP7keB69cho2c/NrsXPSInnn5/O54YVNZJXWctk/1vHcdbOYlTo0JnsL0R8k6N0T8VNg34cq6N1Dvp7e9X3X07usxoHD5e55gEMI0e/++Mc/8tprr7Fq1SpstsbP9Pe//33f/cmTJzNlyhRGjhzJqlWrOOuss1q8zl133cWyZct8jysrK0lJ6eGXLdFvzpsc7wl65/Orc8a2GyxqDHr3TiklTdO4YmYKf/hkH29uzm4/6O3x1rY8QOP0MTHE9sLfqgcvnsS6wyVsP1bOf9cf5YYFbVzEEUL0C03TuGhKIk+vSicpPIDzJg2tVh3zR0bz7JqMPu3rnVlSQ2mNg6nJ4R321hRCiMHqtDExrLj9VP71zRGe+vow3x4u4dzHv+GWU0Zw65mjW/TMzKuo4/cf7ePjXXkARAdbufeC8VwyLRGA5789yh8/3ceKPfnsyqngyR9M737bHSGGIoMBQuLVMnxesx/Z3Dq3/3cNh/bvYoS1nEqXhXxnMKV6KONGDOf2RROYObxlcCcMOMut88K3Gfzl8wPUl7kJqDbyf+eO5bp5qeo8RtcbM7WLDjRmbBftV9nc1QWNL2i0qopdQVEqczso2nMbpVp0xU5UQf0mpcb35Faw9PltZHgmwvzTEMfFU+9hyQ2PMqrkG5XJnf61apW16rh2WeHDGjPBE2c0DzoPn6eW8/4Eh75QAfCDn6nXWfmgWmxhqoy75inn7i3vrhnU8daMgK4C264GcDnUrdtzX3c3+d0tEBDRuNjCmz8O8Dy2hXl+Ft5432Tp6v8GIU4II2KCeW/JAu54fQdf7ivgV2/uYE9uBXefPx6A3763m9e+Owaoydu/OXdcm9+/RsYE8+7PF3DTfzaz41g5P3huI49dOY0LpiT02e8jxFAiQe+eiJ+sbv0R9O7jTO+Pd+bxf2/vxOF08/tLJ3HlLAlqCdGfoqOjMRqNFBQUNFtfUFDQYT/uv/zlL/zxj3/kyy+/ZMqUKe1uO2LECKKjozl8+HCrQW+r1YrVKv1jhoozx8ViMRo4UlTD3rzKdnsRFlSq8ubxvTgRavH0JP60Yj/bj5VzqKCK0XEhrW6n6zq7cyp5e2s2AFf00t+o+DAbd543jt++t5tHPjvAORPjSQz3Qz84IYTf3HzKCPIr67liZgomo6G/d8evZqdFYjRoZJbUsi69mHkjonotk/1IUTVPrDzEBzty0XUYERPEjfNTuWxGMkFW+UoohBh6bGYjt501msXTknjgwz18tb+Qp1el8/72XO6/aAJnT4ijwaUCak+sPEStw4VBg+vnp3LH2WN812gAbjo5jdmpESx9ZRtZpbVc+cx6fr1oLLecMkImEAnRAYNB4+Gr53PVPw18mFMBwOzUCB44eyzzRrbeds3LaNC4+ZQRLBwfx/+9vZONGaU88OFePt6Vx/LLJjMqNkRlcwfHqt7YTdUUq7LrtjAV4LYEdzrbWdd1XlqfyR8+3ofD5SYhzMbImGDWHi7m3W05vLsth4Xjx/LzM/7FjMuAA5+qrO3KXBh1lgp2H9fuq1UmK4y/UC115bDvA9j5BhxdA/UVndrXTnE51ASA6oKOtz2eObAxAG40qax+3aUyyd1Oz33vOk8il8HU2H/dYGqyGBtvvbn+vmPU9LHnvu7JVnc7GxdXg+e9Gxoz2dt6ftP76GoigK577je5bW1da7demkEtaI33tePW3/xl25URxJARYjPzr2tn8sTKQzyx8hAvfHuU/XlVmE0GvjlYhEGDBy6eyHXzUjt8rehgK6/dchK3vbaNL/YWsOSVreSUj+OWU4ZWtTMh+oKm67re8WZDR2VlJWFhYVRUVBAaGtqzF6vIhscmqj/Yd+eqk5VuyquoY97yrzAbNQ7+/rxeG8zsThd/+HgfL63PbLb+xgWp3HP++CF3MVEMfX79TPezuXPnMmfOHJ588kkA3G43w4YNY+nSpfzmN79p9Tl//vOf+cMf/sBnn33GSSed1OF7ZGdnM2zYMN577z0uvvjiDrcfSsf3RHXTi9+xcn8hFqOBhRNiuWJmCqeMjm4x3k9+4DOq6p18uew0RsX2Xv+gW17azBd7C/jxqSN8M2AB3G6dbcfK+XRXHiv25JNdpkrQRQdbWfebM7GYeufvk9utc+U/17M5s4yzxsXy3PWzhvQXCvlM9y45vqKrLv/HOrZkqlKfCWE2zp4QxzkT4pk7IhKzH87Ls0pq+dtXh3hnazZuz7e+ALORugYXACE2E9+fncJ181JJiQzs8fsNNfKZ7l1yfEVf0XWdL/YW8OCHe8kpV+eYp4+NIbusjsOF1QDMHB7B7y6ZxITEtv8vVtY3cNc7u/h4Z57vNf56xVSigmXSMMhnurcN9uNbVGXn+W8zOGlEFKeOju7ydy63W+flTVn88ZN91DjUeUxCmI3JSWFMTQlnSnIYU5LCCQvsWfuBitoG7nx7B5/tUQHihePjeOR7U4gIsrAru4KnVx1mxZ58vFfTTxoRyc9PH8Up3fid2lRTDHVlKkjrdnmCtZ5As66r+95MbqNZZXIbLer6tNHSZJ1ZbV9foV6vvlzdtrqUq5/XV0BdBdj9GHQ/Ed22TZW7b8dg/0wPdH19fFfszueXb2z3jU82s4Enr57B2RPiOnhmcy63zu8+2suL644CEB5oJj7URkKYjYTwABJCbcSH2UgIC/Dc2gbdJGaH0823h4vJq6jn7AlxxITIeZToWFc+0xL07gldhz+nqZODn3wDCVO7/VI18RfIOAABAABJREFUdicT7/8MgH0Pndui3JY/ZJXUsuSVrezyzKz8+ekjMRsNPLHyEKD6Cj71gxlEBEnpGjF4DKWTxNdff53rr7+ef/7zn8yZM4fHH3+cN954g/379xMXF8d1111HUlISy5cvB+BPf/oT9913H6+88goLFizwvU5wcDDBwcFUV1fz4IMPcvnllxMfH096ejp33nknVVVV7Nq1q1MZ3UPp+J6ojhRVc+ur29iTW+lbFxti5dIZSVwxM5lRsSHUOpxMuE/9Ddr1wDmE2HqvT+Hne/L58X+3EB1s5dvfnMHWzHJW7FaBbm+2OaigzBnjYlh6xuh2Lz76w6GCKs7/2xoaXDp3LBzD9fOHEx44NP8Wyme6d8nxFV21J7eCp74+zKoDRdR6LpAAhNpMnDkulnMmxnPamJguX8jIKa/j718d4s3N2Tg90e6zxsVyx9ljSI0O4q3Nx3hx3VGOlqh+kwZNXdT90clpzE2LHNKTf7pCPtO9S46v6Gu1Did//+owz645QoNLjY1RQRZ+c944Lp+R3KmsbV3XeWVTFg99uBe7001cqJXHrpzGxMQw7E4Xdqcbu9ONw+nG4XJjb3DhcLlxunSmJIcN6QC5fKZ7lxxfJbuslvve38PXBwpp7Yp2alQgk5PDmZrcGAy3mjp3jXVLZim3vbqdnPI6zEaNu84bz40LUlucFx0urOafq9N5d1uO7zxrclIYPzltBGdPiOv0+w1obpcKgNdXeILl5WqdwdhYat2bta0ZmmRw05gF7rt1tnwMNMue9v1j6o2PvRniRm+muLnlY83Q/Dlt3fdmfWuGJvdbu6WV9U2e0zRjXHcflz3ublyiRnWYHCef6d7VH8f3YEEVP395KzV2J8/8cCZTU8K7/Vr/XpvBnz7dj8Pl7nDb1KhAzhofx8LxccxKjfDL5Gl/sztdrD1UzMe78vhibwFVnha/ZqPGeZMSuHbecGYNj5DvoaJNEvRuh98HvBcvVGVnLnkKpv9QlXSpyoWyTCjPbLwtz4LQJJi3BBKntXgZXdcZdc+nuNw6G+8+y+99tlfszufXb+2gqt5JeKCZx66cxhnjYn0/W/bGdmodLlIiA3j2ulmMi5c/tmJwGGoniX//+9955JFHyM/PZ9q0afztb39j7ty5AJx++umkpqby4osvApCamkpmZmaL17j//vt54IEHqKurY/HixWzbto3y8nISExM555xz+N3vfkdcXOdmGg6143si25NbwVtbsnl/ey6lNQ7f+mkp4Zw2JoYnVh4i0GJkz4OLevUks8HlZt7ylRRXOwi2mqi2O30/C7aaWDg+lnMnJXDamJhemQDWlse+OOibBGYxGjh7Qhzfm5XMqaNjMA6hspXyme5dcnxFd9U3uFiXXsznewr4cl8BxdWN47TFZGDByCjGxIeQ2GRGf3yYjegga7MgTUFlPU99fZjXNh3zXSA5dUwMdywczfTj+s+63TqrDhbywrdHWXOo2Ld+fEIoN8wfzjkT4k/4ybDyme5dcnxFfzlcWM1jXx4kLsTGL84a3a3M0P35lSx5eSvpRTWdfo7FaOCCKerC7vSU8CF3YVc+071Ljm9zNXYnu3Mq2JldwY7scnblVJDpmczXlNVkYObwCOaNiOKkkVFMTQ5vUUXM7db5x+p0Hv3iIC63TmpUIE9ePYPJyW23BwPILa/j2TVHeHVTFvUN6rwrxGZi0cR4LpySwIJR0QMy+CQGBvlM967+Or66ruNy636pplttd5JTVkdeRR35FfXkVdSr28p68ivqyKuo9wWPvUJtJs4YF8vC8XGcNjamWbuWvmZ3ulhzsJhPduXxxb6CZvsaG2IlLtTmS84EGBcfwrXzhrN4WtKgy14XvU+C3u3w+4C34m7Y8BSEpajSMRXHVK+U9ow8E06+A1JPadbfZfpDn1NW28AXd5zaZp/TrnI43Sz/dB8vfHsUgBnDwvn7D2a06Fm6P7+SH7+0hazSWgItRv56xVTOm5zQqfeorG9gd3YFqdFB0gtV9Dk5SexdcnyHHofTzVf7C3hrSzZfHyjC5W48DRgRHcRXvzq91/fh4U/28a9vjgAQFmDmnAlxnDc5ngWjovttVrzLrfPKxkxe3XSMvXmNWfFxoVYunZ7MFbOSGRnTe2Xf+4p8pnuXHF/hDy63zrasMr7YW8Bne/J92ditMRs14jzl7sIDLXxzsAi7U110nTciimXnjGF2amSH73mooIoX1h3lna3Zvou2mqaylk4dHcMpo6OZPiyi11pNDFQn4mf6qaee8k3AnDp1Kk8++SRz5szp8HmvvfYaV199NZdccgnvvfdep97rRDy+YmipdTh54IM9vLVFtZDQNBVgsxgNWM1GdWsyYDEZcLjcHGkSIJ+UFMp1J6Vy8bREbOYhkBWKfKZ7mxzfjpXXOtiZXcHO7HJ2ZFewLaus2URCUBXFZqVGcNKIKE4aEUViuI0739rpmwB4ybREfr94Upeqn5VU23lx3VHe2HysWfWyiEAz505K4KKpCcxNi/LLZOr6BheHCqrZl19Jg8vNuPhQxsWHSIBoEJLPdO86UY5vRV0D69NL+HJfAV/tL2yW5GIyaMwdEcnC8XHMGxlFTLCV8EBLryV21De4OFJUw6HCKlYfKFIZ3fbmge7zJydw/uQEZg2PwGDQ2J1Twf82ZPLe9hzf99Bgq4nLZyRx7bzhjIr1T4xMDH4S9G6H3we83e/AWzc2X2cwQVgyhA+HiOHqNiwFDn8Ju99WvVcAkmaq4PfYC8Bg4PRHvuZoSS0zhoWTHBFIeKCZ8AAz4YEWdT/QTFiAhYhAMzEhVoKtpnZnBmeX1bLklW3sOFYOwC2npHHnuePanGVYXutg6SvbWHtYnejddtZobj9rdIsSX263zu7cCr45WMTqg0VszSr3BU1SowKZNzKa+SOjmDcyimg/l+6qqGtgW1YZmSW1jE8IZWpK58sUiaHpRDmJ6S9yfIe2wqp63tuWw5ubszlUWM0VM5N55Irut+rorFqHk1c2ZjE2PoSTRkQNuNnve3IreHNzNu9vz6GstsG3fsawcL43M4XzJg3e7Ef5TPcuOb7C33Rd53BhNasPFpFT3nyGf2FVPe5WvsnNGh7BsnPGMH9kdJffr7zWwevfHePdbTnsz69q9rMgi5F5I6M4xRMET4sOGnJZisc70T7Tr7/+Otdddx3PPPMMc+fO5fHHH+fNN9/kwIEDxMbGtvm8o0ePcvLJJzNixAgiIyMl6C1OOHanC4OmYTJo7Y6LO46V89L6TD7cmYvDM0EpPNDMlbNS+OHc4QyLCuyrXe4V8pnuXXJ8u07XddKLqlmfXsL6IyVsOFLaLCDUlM1s4KGLJ3HFrORun9+43TqbM8v4cEcun+zKo6TJe8WEWLlgcgLnTYonKSKAQIuJQIsRq8nQ5vsVVtWzL6+KfXmVviW9qKbZxHVQE25So4IYnxDC+PhQJiSGMj4hlIQw25A/VxvM5DPdu07E4+ubPL2vgJX7CjlcWN1iG02D8AAzEUEWIgMtzW4jAs2EBpgJtpoIsXmXxsdBFhMGg0ZFbQOHi6o4XFjduBRVk11W16LtRFyolfMmJXDBlARmDotos5VMRW0Db23N5n8bMskobpwkOCc1krgwGy63G5dbx+UGtyeb3q3rOF3q1mo2EmI1EWw1EWwz+fa56ePQADPRQVYigy0EWYwyPg4yJ0TQu7sz0P0+4LldsP0Vz4jhCXKHJKr+Iq0pOwrr/g7b/gvOerUuegws+AU/3j6Czw+UdfqtA8xGYkKsxIZYiQ21Ehti8z12unX++Ol+KuoaCLWZ+OuV0zh7wnHljBvqVB8Va+OMGafLzcOf7Of5bzMAOHtCHI9dNY06h4s1h4r45mARaw4VNztxA0gIs1FQ2fLC29i4EOaNjGL+yCjmjogiLKDzMyV1XedIcQ1bMsvYmlnG1qwyDhY0H6wtJgPTU8KZOyKKk9IimT4sok/L4Yr+dyKexPQlOb4nBl3XyauoJyrYIhOJmvBmxb+5OZtVB5tnxSdHBDA5KYxJ3iUx1G89GnVdp7y2gdyKOgoq64kKsjI2PsQvWUDyme5dcnxFX3K63BRV28mrqCevvJ6CynrGxatzb398gS+orGftoWLWHGr9/D8pPIAJiaEMiwz0LSmRgSRHBEjW4iA1d+5cZs+ezd///ncA3G43KSkp3HrrrfzmN79p9Tkul4tTTz2VH/3oR6xZs4by8nIJegvRgdIaB29sPsb/NmSSXVYHqEtKp4+J4dxJ8UQHW4kMshA1yC7Myme6d8nx7Tm3W+dQYTXr04tZf6SEjRmllNc2MDYuhKeume7XjEKny82GI6V8uCOXFXvyqahraHU7g6au7wZ4guCBFiNWs5GcstoWWepeEYFmxieEYjYa2JdXSWGVvdXtwgLMjIkLJiLQQmiAmVCbmbAAM6EBJkJtZs86FQiymY2YjRoWowGz0YDZZMBs1DAbDK0GqdxunQZPEMrpVoEnp9uNxWggLMA8KMas/iaf6d4lxxcyimtYua+AL/YWsDevskUp9K7SPONVrcPV5jZhAWZGxQYzJTmMCyYnMKOdQHdr3G6ddeklvLT+KF/uK2h1krc/WEwGooMsRAZbiAyyqvtBFqKCrUQFW4gOVudh6r61S99v3W6dugYXDqebBpcbh8tNg0tX9z3rvI+NBs3XwuxEq6rWVUM+6N3dGegwgAa86iLY+AxsehbsqneBOySRzGGXUkkI1Q1Q49SoaYCqBp0qh0aVQ6fCARX1bqqcBhy6mQaMODDhwEwDJhowYddNODESoVWzIMbO7XOCiHIVQ2UOVOZ6bnOgzhNgNwdBSLxaguMgJIGdFTZe2l1PjischyWCSrvbt+s6EGgxMT0ljFlpUcwaHkFCWADVDhe7ssvZdqyCrVnlvt5Wjf/BNGKCLQRbjYRYjQRbDAT5bg2EWIwEWQxU213sLHCwLbeOwjoNO2bqseDECGikRgWSGh3E7pyKFieAZqPGlORw5qRGMDc1jJjQQMwmI0aDOlEzGjXMBg2jQcNkNGDy3Ddo3lvkxGyQGTCf6SFKjq8QSmFlPe9uy+GdrTkcKKhqdZvEMBsTk8KYnBTGiJggTAYDBg0MmobBoP6+GDTNt87p1imorCe3vI688npyK+rI8dyva2j+JcKgwciYYMYnNM7cn5AQSkxI1wLt8pnuXXJ8xVDlduvszatkjScIvvloma9neGviQ22+IHiw1Uhdg4v6Bjf1DS7qnW7qHS7qnS71uMGNW9cJsakLryG2JhdjPRdiQ21mlV3QZKZ+kNVEsMVEkNXol555rTmRPtMOh4PAwEDeeustFi9e7Ft//fXXU15ezvvvv9/q8+6//3527tzJu+++yw033CBBbyG6wOXW+Xp/IS9tyOSbg0VtbmcxGYgM9F6MVcErk8F7XqlhNHDcdQ0Ns1EjPFBdtI0OthIVbPXd762JSfKZ7l1yfP3P7dbJr6wnLtTWa+V+QU2mXnu4iI925PHNoWKq6ht87Wjao2mQFh3k++43IUF9D4wLtTa7dllSbWdfXhV78yp8meGHC6tx+ilaZDJovupsTrcbp1tvkc3ZVJDFSFJEAEnhAZ7bQN/j5IgAYoKtXQqCDVXyme5dcnxbanC5Ka9toKzWQWmNg7IaB6W1ntsatb6q3klVfQPVdidV9U7PbQMNruYf+oQwG6NigxkZE8yo2MYlKsjit9hKbnkdK/cV0ODS1fmNQcPoqaxjMKjzH++5T32Dm2rvftudVHv2vbq+8XFFXQMlNXZfGfWuCLIYiQ6xEuUJjjvdOrUO9X221uGizuGi1uH0fe/tKk1T5d8TwwNIDFfjZWKYjcRwFRC3mRvjWyajOgYmY5P7BsOQj20N+aB3d2agew24Aa++Era8COufgur8/t6bAU3HAGYbmskGJiu67sbtbMDlbMDtdoHbiaa7MeHCqDX+t3bqBpwYfUsDRpyYcOrqvo6Ghu5ZwKC50QANHYNnnQa4NAMujI2LZsSNwXdfx4hBc2PEjREdA+q+b53uxoAbNA0XRtyaAbd3K89ruzGo9bpncNLd6OigNy6+xx6aZlCt4TUNg1qBpnnLqmlomtp/PL+TpoGmq19K4/iPv+Y51k1+onmPTNOtmq9pcyjVWt9Kb/UJLVcm/+w9bEHtf04H3Gd6iJHjK0RLFXUN7MmtYHdOBbtzKtmdU8GRJuWX/CU62EJsiKqkcnyGpVdMiNV3EeSmk9M6DILLZ7p3yfEVJ4pah5MtmWUcLa4hq7TWs9SRVVJDTTsz/3uLzWzwBcJtJiNmk8pUsphUtpK3p643e8liMvDrRWMJD2y/VcWJ9JnOzc0lKSmJdevWMW/ePN/6O++8k9WrV7Nx48YWz1m7di3f//732b59O9HR0R0Gve12O3Z7YzZaZWUlKSkpJ8TxFaIjGcU1vLYpi/35VZTWqIvR3b0w25Fgq4moYAtRQRYCLSaVFOBLDtB8pdqNBk+igFHjV+eMJbKD9j4n0pjZH+T4Di0ut64CJA4VMKl1uKhrcPrux4aoal+Blu716rY7Ve/vjOIaKusbqKhroLLOSWV9A5V1nsf1TqrqGqj0BOG92YfHl0/vLINGp7IyvZPAdVSVM8Bzv+V2JqMBsye4YzaqwI7JqILw3nFL07yBHtBQ9/GuQwWAPKvQvNcefT/zPjx+/GtcvAE272Sj47UWX/rlOWM7bPkpn+neJcfXf3Rdx+50U1XvpMbuJNrTdnewqnU4Kal2UFLjoLTGTkm1w3fuVVytzr9Kqh2UVNsprna0O9m7I0aDmohoNhqaVNJofGx3usktr+vURKjO0jQwepNuDE3vN45rZs/5nTdYbjpuvOtM2Nw70bKtsdPoSQTyjcOeMVjT8Kz3rNPg9oVjiAu1tft+XflMD7r/nQ6Hgy1btnDXXXf51hkMBhYuXMj69etbbN/aF+sBxRYKC26DuT+BHa9B1npwOVTZcZdT3bobmj/2/dyhFqfn1tUALjs47YAOlhAIS4LQRM+SdNxtIhjMUF0AVflQldfkfj5U5+OsyMdVU6zK2WjQNG+7+dmI3mSd3mRV43q37vaFlt2ecLIbVKBX13Cj4dbBgI5Na8Cs2zG4Gv/tNNzQUKsW1AfG6FmabNSCSXNjwg0cV0qop5NeWvn1+8Wgm7bSeZVOJ+0Pd0II0ffCAszMHxndrF9uVX0De3Mr2ZVTwZ7cSnLK6nDrumdRXxLcOs0eA8SG2nyzNxNbmckJatuiKjt7PH3c9uZWsjevkoziGoqq7BRVqfYjN5+S1i/HQwhx4gm0mDy9vWOardd1ndIahy8Qfqy0FrvTjc2selbazEYCzEZsZiM2s8F3q2maL6ugss5z2+y+k8o6NXO/xuGkxu6iut7puwChssgdbZYBbc0vzhrt12NyoqmqquLaa6/l2WefJTq6c/3jly9fzoMPPtjLeybE4JQWHcRd549vsb7W4WwSBHdQWu2gsr7B18vS29vS7dZxNbltcKnx2HvBtumF22q7yn7KLKnt9P4tOWOUP39dIU54RoNGiM1MiK3zbSC7wmoy+lpxdZXLrTeW5HWqQLjD6VaBFM/kGJOheYahN1BS3+Ait1xVMMspa7zN9tzmV9b7xq+OuHWVJa/O7vp+UmVP/OTUkR0GvYUYLDRN83xvM3a52uBAFGgxERhpIiUysMNtdV2nyu5sFgQvrXFgMmoEWoye9hRG9ZrNHhuxeqoPd+Y9Smoc5JbXecbPenLK1H1v28MGl47T5W7WTqKtSUa6Dk5vjG6QDJ03nZzWYdC7KwZd0Lu4uBiXy0VcXPP+1HFxcezfv7/F9oPmi7XJCjOvV4s/uF1g6GTJKmswRI1sfbfw33+SbhUd1HUVxHfWNy4N9Sq4rxnV72gwgWZQt77Hnp95MsBxN6hJAW41ccDtdOByNuByOnC73Srorqv4sQuVVa6CExq6Di4ddLcT3eXE7W4Al0vd97ym7naiu124dM2T/e3N4tZw6gbfOqfumV2ou5os7haP0d0YjQYMmirJbtAManaMQcNgMHpmMhpwuVU5SKfLre673bg8A6BbV/d11O/g9hxO7+xJ72O37pmV6DnhbJKP3eyxpnLMAfWlGh10TfO8pt5m8F3Xm+WN01pxibaG/9OsHf/xEUKIgSDEZmbuiCjmjojy+2trmkZsqI3YUBtnjG1s41LrcHIgv4p9eVUcLamRL9VCiH6naZqnD5qV6cMiev39HE43NZ7gTY1Dla2zO1WvNIenZ1rTXmpN1/fWRebBKjo6GqPRSEFBQbP1BQUFxMfHt9g+PT2do0ePctFFF/nWud1qEoLJZOLAgQOMHNn8O+Zdd93FsmXLfI+9md5CiLapi6gmkiN6/t246YXb4mo7JdV27E43Tk9mp9Ot4/KULm58rJZQ26C7fCiE6CaVoWfsVisEm9nIiJhgRsQEt/pzp8tNaY3Dd5XQdz2wSca1pnmvV6rguzfAo4I+qpe40xMAcum6b1tv5rj3Wqd34jnovuuhgO86pvfypPd56vqq59atJhE1HQdbKxffVgHd8EA5zxRiKNA0zdN2y0xadFCvvUd0sJXoYCtTksM7/TzvGOUdH93eCZG6jtszKdLlaUfh0nXf48bzPnez8z3feaCrjSBPE7rn/V168zHSu09Nx1NoHHfdevMx2DtmRwb593rmkD9rPWG/WHc24D3QaRqYbWrxI4NnkVMQIYQQg1WgxcT0YRF9ElgSQoiByGIyYDFZiOig5K7omMViYebMmaxcudLX09vtdrNy5UqWLl3aYvtx48axa9euZuvuvfdeqqqqeOKJJ1r9zm21WrFaZYKWEP2lLy7cCiFEe0xGA7F+zOYTQogTlcGgYTFoWLqXajqkDbqgd1dnoMsXayGEEEIIIYQQon3Lli3j+uuvZ9asWcyZM4fHH3+cmpoabrzxRgCuu+46kpKSWL58OTabjUmTJjV7fnh4OECL9UIIIYQQQgghRF8YdEHvrs5AF0IIIYQQQgghRPuuuuoqioqKuO+++8jPz2fatGmsWLHC11osKysLg0EyCYQQQgghhBBCDEyDLugNHc9AF0IIIYQQQgghRNcsXbq0zcnkq1atave5L774ov93SAghhBBCCCGE6KRBGfTuaAa6EEIIIYQQQgghhBBCCCGEEEKIE8OgDHpD+zPQ26PrOgCVlZX+3iUhRD/wfpa9n23hXzJmCjG0yJjZu2TMFGJokTGzd8mYKcTQImNm75IxU4ihRcbM3iVjphBDS1fGzEEb9O6uqqoqAFJSUvp5T4QQ/lRVVUVYWFh/78aQI2OmEEOTjJm9Q8ZMIYYmGTN7h4yZQgxNMmb2DhkzhRiaZMzsHTJmCjE0dWbM1PQTbDqR2+0mNzeXkJAQNE1rd9vKykpSUlI4duwYoaGhfbSHJzY55n1vsB9zXdepqqoiMTERg8HQ37sz5MiYObDJMe97g/2Yy5jZu2TMHNjkmPe9wX7MZczsXTJmDmxyzPveYD/mMmb2LhkzBzY55n1vsB9zGTN7V1fGTBj8/58GGznefW+wH/OujJknXKa3wWAgOTm5S88JDQ0dlP8RBjM55n1vMB9zmRHZe2TMHBzkmPe9wXzMZczsPTJmDg5yzPveYD7mMmb2HhkzBwc55n1vMB9zGTN7j4yZg4Mc8743mI+5jJm9pztjJgzu/0+DkRzvvjeYj3lnx0yZRiSEEEIIIYQQQgghhBBCCCGEEGLQkqC3EEIIIYQQQgghhBBCCCGEEEKIQUuC3u2wWq3cf//9WK3W/t6VE4Yc874nx1z4i/xf6ntyzPueHHPhL/J/qe/JMe97csyFv8j/pb4nx7zvyTEX/iL/l/qeHPO+J8dc+JP8f+pbcrz73ol0zDVd1/X+3gkhhBBCCCGEEEIIIYQQQgghhBCiOyTTWwghhBBCCCGEEEIIIYQQQgghxKAlQW8hhBBCCCGEEEIIIYQQQgghhBCDlgS9hRBCCCGEEEIIIYQQQgghhBBCDFoS9BZCCCGEEEIIIYQQQgghhBBCCDFoSdC7HU899RSpqanYbDbmzp3Lpk2b+nuXhoxvvvmGiy66iMTERDRN47333mv2c13Xue+++0hISCAgIICFCxdy6NCh/tnZIWD58uXMnj2bkJAQYmNjWbx4MQcOHGi2TX19PUuWLCEqKorg4GAuv/xyCgoK+mmPxWAkY2bvkTGzb8mYKfqCjJm9R8bMviVjpugLMmb2Hhkz+5aMmaIvyJjZe2TM7FsyZoq+IGNm75Exs2/JmKlI0LsNr7/+OsuWLeP+++9n69atTJ06lUWLFlFYWNjfuzYk1NTUMHXqVJ566qlWf/7nP/+Zv/3tbzzzzDNs3LiRoKAgFi1aRH19fR/v6dCwevVqlixZwoYNG/jiiy9oaGjgnHPOoaamxrfNHXfcwYcffsibb77J6tWryc3N5bLLLuvHvRaDiYyZvUvGzL4lY6bobTJm9i4ZM/uWjJmit8mY2btkzOxbMmaK3iZjZu+SMbNvyZgpepuMmb1Lxsy+JWOmhy5aNWfOHH3JkiW+xy6XS09MTNSXL1/ej3s1NAH6u+++63vsdrv1+Ph4/ZFHHvGtKy8v161Wq/7qq6/2wx4OPYWFhTqgr169Wtd1dXzNZrP+5ptv+rbZt2+fDujr16/vr90Ug4iMmX1Hxsy+J2Om8DcZM/uOjJl9T8ZM4W8yZvYdGTP7noyZwt9kzOw7Mmb2PRkzhb/JmNl3ZMzseyfqmCmZ3q1wOBxs2bKFhQsX+tYZDAYWLlzI+vXr+3HPTgwZGRnk5+c3O/5hYWHMnTtXjr+fVFRUABAZGQnAli1baGhoaHbMx40bx7Bhw+SYiw7JmNm/ZMzsfTJmCn+SMbN/yZjZ+2TMFP4kY2b/kjGz98mYKfxJxsz+JWNm75MxU/iTjJn9S8bM3neijpkS9G5FcXExLpeLuLi4Zuvj4uLIz8/vp706cXiPsRz/3uF2u7n99ttZsGABkyZNAtQxt1gshIeHN9tWjrnoDBkz+5eMmb1LxkzhbzJm9i8ZM3uXjJnC32TM7F8yZvYuGTOFv8mY2b9kzOxdMmYKf5Mxs3/JmNm7TuQx09TfOyCE6FtLlixh9+7drF27tr93RQghBjwZM4UQovNkzBRCiM6TMVMIITpPxkwhhOi8E3nMlEzvVkRHR2M0GikoKGi2vqCggPj4+H7aqxOH9xjL8fe/pUuX8tFHH/H111+TnJzsWx8fH4/D4aC8vLzZ9nLMRWfImNm/ZMzsPTJmit4gY2b/kjGz98iYKXqDjJn9S8bM3iNjpugNMmb2Lxkze4+MmaI3yJjZv2TM7D0n+pgpQe9WWCwWZs6cycqVK33r3G43K1euZN68ef24ZyeGtLQ04uPjmx3/yspKNm7cKMe/m3RdZ+nSpbz77rt89dVXpKWlNfv5zJkzMZvNzY75gQMHyMrKkmMuOiRjZv+SMdP/ZMwUvUnGzP4lY6b/yZgpepOMmf1Lxkz/kzFT9CYZM/uXjJn+J2Om6E0yZvYvGTP9T8ZMRcqbt2HZsmVcf/31zJo1izlz5vD4449TU1PDjTfe2N+7NiRUV1dz+PBh3+OMjAy2b99OZGQkw4YN4/bbb+f3v/89o0ePJi0tjd/+9rckJiayePHi/tvpQWzJkiW88sorvP/++4SEhPh6NISFhREQEEBYWBg33XQT/8/efYdHVaZ9HP/OTHrvBQgQeuhIE3AFBQVU1oICygoiiqtUWRsqCOjC2hDFgrgi+i4oio1dFUEUGx1EVHoLoSQkpJFe5rx/TDIwJGASkkzK73NdcyVz5jln7hnM7Zm5z3M/U6dOJSgoCD8/PyZOnEivXr24/PLLnRy91AbKmVVLObN6KWdKVVPOrFrKmdVLOVOqmnJm1VLOrF7KmVLVlDOrlnJm9VLOlKqmnFm1lDOrl3JmEUMuaMGCBUbjxo0NNzc3o0ePHsbGjRudHVKd8d133xlAidvo0aMNwzAMq9VqTJ8+3QgPDzfc3d2N/v37G3v37nVu0LVYae81YLzzzjv2MdnZ2cYDDzxgBAYGGl5eXsbNN99snDx50nlBS62jnFl1lDOrl3KmVAflzKqjnFm9lDOlOihnVh3lzOqlnCnVQTmz6ihnVi/lTKkOyplVRzmzeiln2pgMwzAutXAuIiIiIiIiIiIiIiIiIiLiDFrTW0REREREREREREREREREai0VvUVEREREREREREREREREpNZS0VtERERERERERERERERERGotFb1FRERERERERERERERERKTWUtFbRERERERERERERERERERqLRW9RURERERERERERERERESk1lLRW0REREREREREREREREREai0VvUXOYzKZ+Oyzz5wdhohIraCcKSJSdsqZIiJlp5wpIlJ2ypkiImWnnFl3qegtNcpdd92FyWQqcRs0aJCzQxMRqXGUM0VEyk45U0Sk7JQzRUTKTjlTRKTslDOlKrk4OwCR8w0aNIh33nnHYZu7u7uTohERqdmUM0VEyk45U0Sk7JQzRUTKTjlTRKTslDOlqmimt9Q47u7uREREONwCAwMBW9uJN954g8GDB+Pp6UmzZs1YsWKFw/6//fYbV199NZ6engQHBzNu3DgyMjIcxixevJh27drh7u5OZGQkEyZMcHg8KSmJm2++GS8vL1q2bMnKlSur9kWLiFSQcqaISNkpZ4qIlJ1ypohI2SlnioiUnXKmVBUVvaXWmT59OkOHDuXXX39l5MiRjBgxgt27dwOQmZnJwIEDCQwMZMuWLXz00Ud88803DgntjTfeYPz48YwbN47ffvuNlStX0qJFC4fnmDVrFsOGDWPnzp1cd911jBw5kuTk5Gp9nSIilUE5U0Sk7JQzRUTKTjlTRKTslDNFRMpOOVMqzBCpQUaPHm1YLBbD29vb4fbPf/7TMAzDAIy///3vDvv07NnTuP/++w3DMIxFixYZgYGBRkZGhv3xL774wjCbzUZ8fLxhGIbRoEED44knnrhgDIDx5JNP2u9nZGQYgPHVV19V2usUEakMypkiImWnnCkiUnbKmSIiZaecKSJSdsqZUpW0prfUOFdddRVvvPGGw7agoCD777169XJ4rFevXuzYsQOA3bt306lTJ7y9ve2P9+nTB6vVyt69ezGZTJw4cYL+/ftfNIaOHTvaf/f29sbPz49Tp05V9CWJiFQZ5UwRkbJTzhQRKTvlTBGRslPOFBEpO+VMqSoqekuN4+3tXaLVRGXx9PQs0zhXV1eH+yaTCavVWhUhiYhcEuVMEZGyU84UESk75UwRkbJTzhQRKTvlTKkqWtNbap2NGzeWuB8TEwNATEwMv/76K5mZmfbHf/75Z8xmM61bt8bX15emTZuydu3aao1ZRMRZlDNFRMpOOVNEpOyUM0VEyk45U0Sk7JQzpaI001tqnNzcXOLj4x22ubi4EBISAsBHH31Et27duOKKK1i6dCmbN2/m7bffBmDkyJE89dRTjB49mpkzZ5KYmMjEiRO58847CQ8PB2DmzJn8/e9/JywsjMGDB3PmzBl+/vlnJk6cWL0vVESkEihnioiUnXKmiEjZKWeKiJSdcqaISNkpZ0pVUdFbapxVq1YRGRnpsK1169bs2bMHgFmzZvHBBx/wwAMPEBkZyfvvv0/btm0B8PLy4uuvv2by5Ml0794dLy8vhg4dyrx58+zHGj16NDk5Obz00ks89NBDhISEcOutt1bfCxQRqUTKmSIiZaecKSJSdsqZIiJlp5wpIlJ2yplSVUyGYRjODkKkrEwmE59++ik33XSTs0MREanxlDNFRMpOOVNEpOyUM0VEyk45U0Sk7JQz5VJoTW8REREREREREREREREREam1VPQWEREREREREREREREREZFaS+3NRURERERERERERERERESk1tJMbxERERERERERERERERERqbVU9BYRERERERERERERERERkVpLRW8REREREREREREREREREam1VPQWEREREREREREREREREZFaS0VvERERERERERERERERERGptVT0FhERERERERERERERERGRWktFbxERERERERERERERERERqbVU9BYRERERERERERERERERkVpLRW8REREREREREREREREREam1VPQWEREREREREREREREREZFaS0VvERERERERERERERERERGptVT0FhERERERERERERERERGRWktFbxERERERERERERERERERqbVU9BYRERERERERERERERERkVpLRW8REREREREREREREREREam1VPSWEmbOnInJZCIpKemi40wmExMmTKi049UF/fr1o1+/fs4OQ0QEqF/5V0Rqr7vuuoumTZtW+/MeOXIEk8nEkiVLqv25161bh8lkYsWKFdX+3OcymUzMnDnTqTGISO23ZMkSTCYTR44ccXYoZVKez+39+vWjffv2VRuQiEgNVZ7z5eKxL7zwQtUHJiJSAyln1gwqeouU065du5g5c2at+UAvIiIiIiIiUpqsrCxee+01rr32WiIjI/H19aVLly688cYbFBYWXtKxrVYrb7zxBp07d8bT05Pg4GCuvvpqfv3110qKvnKcOHGCmTNnsmPHDmeHIiK1wJw5c7j88ssJDQ3Fw8ODli1bMmXKFBITEyvl+D/99BMmk6nGXsD+5Zdf6qJJESmzqjjXTEhIYMyYMYSFheHp6clll13GRx99VMmRVw7lzOrn4uwARGqbXbt2MWvWLPr161diVtLq1audE5SIiIiIiIhIOR06dIiJEyfSv39/pk6dip+fH19//TUPPPAAGzdu5N13363wse+++26WLl3KqFGjmDBhApmZmfzyyy+cOnWqEl9B+Z3/uf3EiRPMmjWLpk2b0rlzZ+cEJSK1xrZt2+jcuTMjRozA19eX3bt389Zbb/HFF1+wY8cOvL29K3xsq9XKxIkT8fb2JjMzsxKjrpgmTZqQnZ2Nq6urfduXX37Ja6+9piKOiJRJZZ9rpqenc8UVV5CQkMDkyZOJiIjgww8/ZNiwYSxdupQ77rijil7Jn1POrBlU9BYpo5ycHNzc3C465s8eFxGpLaxWK3l5eXh4eDg7FBERqaDMzMxL+uJVROq+iIgIfvvtN9q1a2ffdt9993H33XfzzjvvMH36dFq0aFHu43744Ye8++67fPLJJ9x8882VGfIl0+d2EbkUH3/8cYltvXr14tZbb+W///0vI0aMqPCxFy1aRFxcHPfccw8vv/zypYRZKUwmk74TEJFLUtnnmm+++SYHDhxg7dq1XH311QDcf//9XH755fzjH//g1ltvddq5nnJmzaD25nJBSUlJDBs2DD8/P4KDg5k8eTI5OTklxi1dupTWrVvj4eFB165d+eGHHy7peBdz11134ePjw9GjR7nhhhvw8fGhYcOGvPbaawD89ttvXH311Xh7e9OkSROWLVvmsH9ycjIPPfQQHTp0wMfHBz8/PwYPHlyivVrxOosffPABTz75JA0bNsTLy4tXXnmF2267DYCrrrrK3m5o3bp1QMm1wYqP8+GHH/LPf/6TRo0a4eHhQf/+/Tlw4IDDc+7fv5+hQ4cSERGBh4cHjRo1YsSIEaSlpZXrPRKR2qt4De49e/ZcNF+aTCYmTJhQqfn33GO2a9cOd3d3Vq1aVaa4f/zxR2677TYaN26Mu7s7UVFRPPjgg2RnZ9vHFOfD0m7OWMtXRCrPihUrMJlMfP/99yUee/PNNzGZTPz+++8AfPbZZ7Rv3x4PDw/at2/Pp59+WuoxP/jgA7p27Yqvry9+fn506NDB4Yu//Px8Zs2aRcuWLfHw8CA4OJgrrriCNWvWXPLr+fbbb/nLX/6Ct7c3AQEB3HjjjezevdthTHG+3rdvH3/729/w9/cnNDSU6dOnYxgGcXFx3Hjjjfj5+REREcGLL75Y6nMVFhby+OOPExERgbe3N3/961+Ji4tzGFOWHAtnz5MPHjzIddddh6+vLyNHjgQgNzeXBx98kNDQUHx9ffnrX//KsWPHSo3pl19+YfDgwfj5+eHj40P//v3ZuHFjRd9OEamA48ePM3bsWBo0aIC7uzvR0dHcf//97Nu3D5PJxEsvvVRin/Xr12MymXj//feBsp9XhoSEOHwJWay4UH1+/vvjjz+4+uqr8fT0pFGjRjzzzDNYrdYS+8+bN48ePXpw8803Y7VaKzxjsX379lx11VUltlutVho2bMitt97qsG3+/Pm0a9cODw8PwsPDue+++0hJSXHY99zP7evWraN79+4AjBkzxn5+ev5ajLt27eKqq67Cy8uLhg0b8txzz1Xo9YhI5avOnHkhxZ9pU1NT7dvK+h3kueOffPJJZs+eTUBAQLnfh61bt2IymUqdNfn1119jMpn43//+Z992/Phx7r77bsLDw3F3d6ddu3YsXrzYYb/z16e966677N/BnvuZ/nyLFi2iefPmuLu70717d7Zs2VLu1yMiVacmn2umpqby4IMP0rRpU9zd3WnUqBGjRo2yL/fw448/Ehoaai94A5jNZoYNG0Z8fHyp30uURjmz7tJMb7mgYcOG0bRpU+bOncvGjRt55ZVXSElJ4b333rOP+f7771m+fDmTJk3C3d2d119/nUGDBrF582bat29f7uOVRWFhIYMHD+bKK6/kueeeY+nSpUyYMAFvb2+eeOIJRo4cyS233MLChQsZNWoUvXr1Ijo6GrC10/jss8+47bbbiI6OJiEhgTfffJO+ffuya9cuGjRo4PBcTz/9NG5ubjz00EPk5uZy7bXXMmnSJF555RUef/xxYmJiAOw/L+Rf//oXZrOZhx56iLS0NJ577jlGjhzJpk2bAMjLy2PgwIHk5uYyceJEIiIiOH78OP/73/9ITU3F39+/XO+RiNRuzsq/3377LR9++CETJkwgJCSkzMXojz76iKysLO6//36Cg4PZvHkzCxYs4NixY/Y1dWJiYvi///s/h/1SU1OZOnUqYWFhFXiXRKSmuP766/Hx8eHDDz+kb9++Do8tX76cdu3a0b59e1avXs3QoUNp27Ytc+fO5fTp04wZM4ZGjRo57LNmzRpuv/12+vfvz7PPPgvYPgj//PPPTJ48GbB9wJ47dy733HMPPXr0ID09na1bt7J9+3auueaaCr+Wb775hsGDB9OsWTNmzpxJdnY2CxYsoE+fPmzfvr1EXhw+fDgxMTH861//4osvvuCZZ54hKCiIN998k6uvvppnn32WpUuX8tBDD9G9e3euvPJKh/3/+c9/YjKZePTRRzl16hTz589nwIAB7NixA09PT6BsObZYQUEBAwcO5IorruCFF17Ay8sLgHvuuYf//Oc/3HHHHfTu3Ztvv/2W66+/vsTr/+OPP/jLX/6Cn58fjzzyCK6urrz55pv069eP77//np49e1b4vRWRsjlx4gQ9evQgNTWVcePG0aZNG44fP86KFSuYO3cuffr0YenSpTz44IMO+y1duhRfX19uvPFGh+0V/RweHx8P2L6oPHfbVVddRUFBAY899hje3t4sWrTInq+Kpaens3nzZh544AEef/xxFixYQEZGBtHR0fzrX/9i2LBhZX4/hg8fzsyZM4mPjyciIsK+/aeffuLEiRMOMyrvu+8+lixZwpgxY5g0aRKHDx/m1Vdf5ZdffuHnn392aDVZLCYmhtmzZzNjxgzGjRvHX/7yFwB69+5tH5OSksKgQYO45ZZbGDZsGCtWrODRRx+lQ4cODB48uMyvRUQqn7NypmEYnD59moKCAvbv389jjz2GxWJxmAhT3u8gp0+fTkREBPfddx9PP/10ud+Lbt260axZMz788ENGjx7t8Njy5csJDAxk4MCBgG093Msvv9x+8XtoaChfffUVY8eOJT09nSlTppT6HPfddx8nTpxgzZo1JT7fF1u2bBlnzpzhvvvuw2Qy8dxzz3HLLbdw6NChUvOwiFSvmnyumZGRwV/+8hd2797N3XffzWWXXUZSUhIrV67k2LFjhISEkJubW+LcE7B/9t22bVuZvhNQzqzDDJHzPPXUUwZg/PWvf3XY/sADDxiA8euvvxqGYRiAARhbt261j4mNjTU8PDyMm2++udzHK4vRo0cbgDFnzhz7tpSUFMPT09MwmUzGBx98YN++Z88eAzCeeuop+7acnByjsLDQ4ZiHDx823N3djdmzZ9u3fffddwZgNGvWzMjKynIY/9FHHxmA8d1335WIr2/fvkbfvn1LHCcmJsbIzc21b3/55ZcNwPjtt98MwzCMX375xQCMjz76qMzvhYjUPc7Mv4BhNpuNP/74o9xxn58nDcMw5s6da5hMJiM2NrbUfaxWq3HDDTcYPj4+FXpOEalZbr/9diMsLMwoKCiwbzt58qRhNpvt51idO3c2IiMjjdTUVPuY1atXG4DRpEkT+7bJkycbfn5+Dsc6X6dOnYzrr7/+kmI+fPiwARjvvPOOfVvnzp2NsLAw4/Tp0/Ztv/76q2E2m41Ro0bZtxXn13Hjxtm3FRQUGI0aNTJMJpPxr3/9y769+Fx19OjR9m3F54gNGzY00tPT7ds//PBDAzBefvll+7ay5tji8+THHnvMYeyOHTsMwHjggQcctt9xxx0lzpVvuukmw83NzTh48KB924kTJwxfX1/jyiuvLBGHiFS+UaNGGWaz2diyZUuJx6xWq/Hmm28agLF792779ry8PCMkJMQhz1zK5/Dc3Fyjbdu2RnR0tJGfn2/fPmXKFAMwNm3aZN926tQpw9/f3wCMw4cPG4ZhGNu3bzcAIzg42AgPDzdef/11Y+nSpUaPHj0Mk8lkfPXVV2V+P/bu3WsAxoIFC0q8Dh8fH3uO/PHHHw3AWLp0qcO4VatWldh+/uf2LVu2lPj/wbljAeO9995zeH8iIiKMoUOHlvl1iEjVcFbOPHnypP1zOWA0atTIWL58ucOYsn4HaRi2802LxWJ8/fXXDvEkJiaW/c0wDGPatGmGq6urkZycbN+Wm5trBAQEGHfffbd929ixY43IyEgjKSnJYf8RI0YY/v7+9txa2vny+PHjjdJKCsVjg4ODHZ7/888/NwDjv//9b7lei4hUjZp8rjljxgwDMD755JNSYzMMw5g4caJhNpuNI0eOODw+YsQIAzAmTJhw8TfgHMqZdZPam8sFjR8/3uH+xIkTAfjyyy/t23r16kXXrl3t9xs3bsyNN97I119/TWFhYbmPV1b33HOP/feAgABat26Nt7e3wxXjrVu3JiAggEOHDtm3ubu7Yzbb/rMvLCzk9OnT+Pj40Lp1a7Zv317ieUaPHl3qlUPlNWbMGIe1JIqvHi+OrXgm99dff01WVtYlP5+I1G7Oyr99+/albdu25Y733DyZmZlJUlISvXv3xjAMfvnll1L3efrpp/nf//7HkiVLKvScIlKzDB8+nFOnTtmXfAFb23Or1crw4cM5efIkO3bsYPTo0Q4dbK655poSOSAgIIDMzMyLtioPCAjgjz/+YP/+/ZX2GopjvOuuuwgKCrJv79ixI9dcc02p56znnpNaLBa6deuGYRiMHTvWIdbWrVs7nJMWGzVqFL6+vvb7t956K5GRkQ7PVd4ce//99zvcLz7WpEmTHLaffzV6YWEhq1ev5qabbqJZs2b27ZGRkdxxxx389NNPpKenl3g+Eak8VquVzz77jCFDhtCtW7cSj5tMJoYNG4aHhwdLly61b//6669JSkrib3/7W4l9KvI5fMKECezatYtXX30VF5ezDQK//PJLLr/8cnr06GHfFhoaal9KoVhGRgYAp0+f5vPPP+f+++/njjvuYO3atQQHB/PMM89c7G1w0KpVKzp37szy5cvt2woLC1mxYgVDhgxx6Irh7+/PNddcQ1JSkv3WtWtXfHx8+O6778r8nOfz8fFxeG/d3Nzo0aNHqXldRKqPM3NmUFAQa9as4b///S+zZ88mJCTEnvuKlec7yEmTJjF48GCuvfbacrwDJQ0fPpz8/Hw++eQT+7bVq1eTmprK8OHDAdss9Y8//pghQ4ZgGIZDzhw4cCBpaWmlfkdanhgCAwPt98//DlREnKemn2t+/PHHdOrUyd76/PzYwPYZ3GKxMGzYMNavX8/BgweZO3eufem085cBuxjlzLpJRW+5oJYtWzrcb968OWazmSNHjlxwDNg+lGZlZZGYmFju45WFh4cHoaGhDtv8/f1p1KhRiTUR/P39HdbvslqtvPTSS7Rs2RJ3d3dCQkIIDQ1l586dpa6dXdwW/VI1btzY4X5xIiuOLTo6mqlTp/Lvf/+bkJAQBg4cyGuvvab1vEXqKWfl34rmvKNHj9qLRD4+PoSGhtpbHJeWx1atWsWsWbOYNm0aQ4cOrdBzikjNMmjQIPz9/R2KEsuXL6dz5860atWK2NhYoPTc1bp1a4f7DzzwAK1atWLw4ME0atSIu+++m1WrVjmMmT17NqmpqbRq1YoOHTrw8MMPs3Pnzkt6DcUxnh8P2NrfJiUllViT9vxzPH9/fzw8PBxatBVvP39NWSj5fphMJlq0aOGQn8uTY11cXEq0i4+NjcVsNtO8eXOH7ee/zsTERLKysi74+q1Wa4n1xkWkciUmJpKenl5iqZpzBQQEMGTIEJYtW2bftnTpUho2bOiwtmGx8n4Of/7553nrrbd4+umnue666xwei42NLVMeLy5ER0dHOyyL4OPjw5AhQ9i8eTMFBQUXfI3nGz58OD///DPHjx8HbOtwnzp1yv5lJMD+/ftJS0sjLCyM0NBQh1tGRganTp0q8/Odr7TvGgIDA0vN6yJSfZyZM93c3BgwYAA33HAD06dP57XXXmPs2LEO67+W9TvI5cuXs379el588cXyvgUldOrUiTZt2pQ4Jw8JCbG/3sTERFJTU1m0aFGJfDlmzBiAS8qZf/YdqIg4T00/1zx48OBFYwPbRenLli3j4MGD9OnThxYtWvDKK68wf/58wHa+WVbKmXWTit5SZud/yHPW8SwWS7m2G4Zh/33OnDlMnTqVK6+8kv/85z98/fXXrFmzhnbt2mG1WkvsWxmzvMsa24svvsjOnTt5/PHHyc7OZtKkSbRr145jx45VSgwiUntVV/6tSM4rLCzkmmuu4YsvvuDRRx/ls88+Y82aNSxZsgSgRG49fPgwI0eO5JprrinXLB8Rqdnc3d256aab+PTTTykoKOD48eP8/PPPDgWJsgoLC2PHjh2sXLmSv/71r3z33XcMHjzYYZ2tK6+8koMHD7J48WLat2/Pv//9by677DL+/e9/V+bL+lOlneOV5byvrMqbY8+dUSQiddeoUaM4dOgQ69ev58yZM6xcuZLbb7+9TH//FzuvXLJkCY8++ih///vfefLJJyscX/E6teHh4SUeCwsLIz8/v8RFRBczfPhwDMPgo48+AuDDDz/E39+fQYMG2cdYrVbCwsJYs2ZNqbfZs2dX+PVUZl4XkepXVTnzXL179yYyMtJhZmRZv4N8+OGHue2223Bzc+PIkSMcOXKE1NRUAOLi4jhx4kS5Xu/w4cP57rvvSEpKIjc3l5UrVzJ06FD7bMri5/7b3/52wZzZp0+fcj3nuZQzRWq/mn6ueeutt3LixAk2b97Mhg0biI2NtXcra9WqVbmOpZxZ97j8+RCpr/bv3+8w6+/AgQNYrVaaNm3qMOZ8+/btw8vLq8Rs7LIcr6qtWLGCq666irffftthe2pqaokZORdS2cWnc3Xo0IEOHTrw5JNPsn79evr06cPChQtVGBKpZ2pT/v3tt9/Yt28f7777LqNGjbJvL60tcXZ2NrfccgsBAQG8//77KsyI1DHDhw/n3XffZe3atezevRvDMOxF7yZNmgCl5669e/eW2Obm5saQIUMYMmQIVquVBx54gDfffJPp06fTokULwNZWcsyYMYwZM4aMjAyuvPJKZs6c6dByvDyKYywtnj179hASEoK3t3eFjn0h578fhmFw4MABOnbsCJQvx15IkyZNsFqtHDx40GE25vmvMzQ0FC8vrwu+frPZTFRUVJmfV0TKLzQ0FD8/P37//feLjhs0aBChoaEsXbqUnj17kpWVxZ133lnq2LKeB37++efcc8893HLLLbz22mulHqtJkyZlyuMNGjQgIiLCPjP7XCdOnMDDw8NhaYc/Ex0dTY8ePVi+fDkTJkzgk08+4aabbsLd3d0+pnnz5nzzzTf06dOn3BdyVuVnfBGpOs7MmaXJyclxmMFd1u8g4+LiWLZsmcOsymKXXXYZnTp1YseOHX/6/MWGDx/OrFmz+PjjjwkPDyc9PZ0RI0bYHw8NDcXX15fCwkIGDBhQ5uMWU84Uqb1q+rlm8+bN/zS2Ym5ubnTv3t1+/5tvvgEod15Tzqx79G2zXND5yWfBggUADB482L5tw4YNDmsWxMXF8fnnn3PttdeWuEqlLMerahaLpcRVMh999FGpH8YvpPjLzuKrLitDenp6ifZuHTp0wGw2k5ubW2nPIyK1Q23Kv8XPdW5uNQyDl19+ucTYv//97+zbt49PP/3UYb0aEakbBgwYQFBQEMuXL2f58uX06NHD/uE3MjKSzp078+677zp8GbhmzRp27drlcJzTp0873DebzfYicPF50fljfHx8aNGixSWdN50b47nneb///jurV68u0XqtMrz33nucOXPGfn/FihWcPHnSnp/Lk2MvpPhYr7zyisP24vZvxSwWC9deey2ff/65Qyu6hIQEli1bxhVXXIGfn1+Zn1dEys9sNnPTTTfx3//+l61bt5Z4vDgXuLi4cPvtt/Phhx+yZMkSOnToYM+T5yvLeeAPP/zAiBEjuPLKK1m6dOkFL0y87rrr2LhxI5s3b7ZvS0xMdJjZWGz48OHExcU5XKSTlJTE559/ztVXX13uix+HDx/Oxo0bWbx4MUlJSSU6iQwbNozCwkKefvrpEvsWFBRc9PN7VXzGF5Gq54ycmZmZSVZWVon9Pv74Y1JSUhzWyC3rd5CffvppiVtxjnvvvfd46aWXLvo+nC8mJoYOHTrYz8kjIyO58sorHeIaOnQoH3/8canFpfOXSzufcqZI7VXTzzWHDh3Kr7/+al+fu7TYSrN//34WLlzIDTfcUO6Z3sqZdY9messFHT58mL/+9a8MGjSIDRs28J///Ic77riDTp062ce0b9+egQMHMmnSJNzd3Xn99dcBmDVrVoWOV9VuuOEGZs+ezZgxY+jduze//fYbS5cutbe/KIvOnTtjsVh49tlnSUtLw93dnauvvpqwsLAKx/Xtt98yYcIEbrvtNlq1akVBQQH/93//Z0+qIlK/1Kb826ZNG5o3b85DDz3E8ePH8fPzs3/gP9cXX3zBe++9x9ChQ9m5c6fD2rs+Pj7cdNNNlxyLiDiXq6srt9xyCx988AGZmZm88MILDo/PnTuX66+/niuuuIK7776b5ORkFixYQLt27cjIyLCPu+eee0hOTubqq6+mUaNGxMbGsmDBAjp37kxMTAwAbdu2pV+/fnTt2pWgoCC2bt3KihUrmDBhwiW9hueff57BgwfTq1cvxo4dS3Z2NgsWLMDf35+ZM2de0rFLExQUxBVXXMGYMWNISEhg/vz5tGjRgnvvvRcoe469mM6dO3P77bfz+uuvk5aWRu/evVm7di0HDhwoMfaZZ55hzZo1XHHFFTzwwAO4uLjw5ptvkpuby3PPPVdpr1tELmzOnDmsXr2avn37Mm7cOGJiYjh58iQfffQRP/30EwEBAYCt7eQrr7zCd999x7PPPnvB4/3ZeWBsbCx//etfMZlM3HrrrfYW4sU6duxo/5LzkUce4f/+7/8YNGgQkydPxtvbm0WLFtGkSROHczuAadOm8eGHHzJ06FCmTp2Kv78/CxcuJD8/nzlz5pT7fRk2bBgPPfQQDz30EEFBQSVm2vTt25f77ruPuXPnsmPHDq699lpcXV3Zv38/H330ES+//DK33nprqcdu3rw5AQEBLFy4EF9fX7y9venZs6fDrCURqZmqO2fu37+fAQMGMHz4cNq0aYPZbGbr1q385z//oWnTpkyePNl+rLJ+B1naZ+Himd2DBw8uc2fKcw0fPpwZM2bg4eHB2LFjSxSY/vWvf/Hdd9/Rs2dP7r33Xtq2bUtycjLbt2/nm2++ITk5+YLH7tq1KwCTJk1i4MCBWCwWh1mRIlKz1eRzzYcffpgVK1Zw2223cffdd9O1a1eSk5NZuXIlCxcutB+zbdu23HbbbTRu3JjDhw/zxhtvEBQUxMKFCyv0nihn1jGGyHmeeuopAzB27dpl3HrrrYavr68RGBhoTJgwwcjOzraPA4zx48cb//nPf4yWLVsa7u7uRpcuXYzvvvuuQscri9GjRxve3t4ltvft29do165die1NmjQxrr/+evv9nJwc4x//+IcRGRlpeHp6Gn369DE2bNhg9O3b1+jbt6993HfffWcAxkcffVRqHG+99ZbRrFkzw2KxGID9NZf1OIcPHzYA45133jEMwzAOHTpk3H333Ubz5s0NDw8PIygoyLjqqquMb775pozvjIjUBc7Mv8XHrIhdu3YZAwYMMHx8fIyQkBDj3nvvNX799VeHPPfOO+8YQKm3Jk2aVOh5RaTmWbNmjQEYJpPJiIuLK/H4xx9/bMTExBju7u5G27ZtjU8++cQYPXq0Qx5YsWKFce211xphYWGGm5ub0bhxY+O+++4zTp48aR/zzDPPGD169DACAgIMT09Po02bNsY///lPIy8vr8yxnn8+Vuybb74x+vTpY3h6ehp+fn7GkCFDjF27djmMKc6viYmJDtvLeq5afI74/vvvG9OmTTPCwsIMT09P4/rrrzdiY2Md9i1Ljr3YcxuGYWRnZxuTJk0ygoODDW9vb2PIkCFGXFycARhPPfWUw9jt27cbAwcONHx8fAwvLy/jqquuMtavX3+ht1FEqkBsbKwxatQoIzQ01HB3dzeaNWtmjB8/3sjNzXUY165dO8NsNhvHjh0rcYyyngcW56ML3c7PETt37jT69u1reHh4GA0bNjSefvpp4+233zYA4/Dhww5jDx48aNx8882Gn5+f4enpaVx99dXG5s2bK/y+9OnTxwCMe+6554JjFi1aZHTt2tXw9PQ0fH19jQ4dOhiPPPKIceLECfuY8z+3G4ZhfP7550bbtm0NFxcXh/x6oe8azv9/l4g4T3XmzMTERGPcuHFGmzZtDG9vb8PNzc1o2bKlMWXKlBLnhWX9DrI0FzrXLKv9+/fb8/hPP/1U6piEhARj/PjxRlRUlOHq6mpEREQY/fv3NxYtWmQfU9r5ckFBgTFx4kQjNDTUMJlMRnF5oXjs888/X+K5Svv/iYg4T00+1zx9+rQxYcIEo2HDhoabm5vRqFEjY/To0UZSUpJ9zIgRI4yoqCjDzc3NaNCggfH3v//dSEhIqPD7oZxZt5gMQyuii4iI1AQzZ85k1qxZJCYmXvRqbpPJxPjx43n11VerMToRERERqUm6dOlCUFAQa9euLfFYWc8rRUTqC+VMEZHyUd6U2khreouIiIiIiIiI1CJbt25lx44djBo1ytmhiIjUeMqZIiLlo7wptZXW9JYaIS0tjezs7IuOiYiIqKZoREQEIDk5mby8vAs+brFYCA0NrcaIRET+XF5e3kXX1ALw9/fH09OzmiISEak8v//+O9u2bePFF18kMjKS4cOHOzukCouPj7/o456envj7+1dTNCJSF9WVnJmdnU1aWtpFxwQFBeHm5lZNEYlIXVUX8qZyZv2morfUCJMnT+bdd9+96Bh14hcRqV633HIL33///QUfb9KkCUeOHKm+gEREymD9+vVcddVVFx3zzjvvcNddd1VPQCIilWjFihXMnj2b1q1b8/777+Ph4eHskCosMjLyoo+PHj2aJUuWVE8wIlIn1ZWcuXz5csaMGXPRMd999x39+vWrnoBEpM6qC3lTObN+05reUiPs2rWLEydOXHTMgAEDqikaEREB2LZtGykpKRd83NPTkz59+lRjRCIify4lJYVt27ZddEy7du3+tNgiIiJV65tvvrno4w0aNKBt27bVFI2ISM118uRJ/vjjj4uO6dq1K4GBgdUUkYhIzaWcWb+p6C0iIiIiIiIiIiIiIiIiIrWW2dkBiIiIiIiIiIiIiIiIiIiIVFS9W9PbarVy4sQJfH19MZlMzg5HRC6RYRicOXOGBg0aYDbrOp7KppwpUrcoZ1Yt5UyRukU5s2opZ4rULcqZVUs5U6RuUc6sWsqZInVLeXJmvSt6nzhxgqioKGeHISKVLC4ujkaNGjk7jDpHOVOkblLOrBrKmSJ1k3Jm1VDOFKmblDOrhnKmSN2knFk1lDNF6qay5Mx6V/T29fUFbG+On5+fk6MRkUuVnp5OVFSU/W+7NigsLGTmzJn85z//IT4+ngYNGnDXXXfx5JNP2q8+NAyDp556irfeeovU1FT69OnDG2+8QcuWLe3HSU5OZuLEifz3v//FbDYzdOhQXn75ZXx8fOxjdu7cyfjx49myZQuhoaFMnDiRRx55pMyxKmeK1C21MWfWJsqZInWLcmbVUs4UqVuUM6uWcqZI3aKcWbWUM0XqlvLkzHpX9C4uKPn5+SnhidQhtalVzbPPPssbb7zBu+++S7t27di6dStjxozB39+fSZMmAfDcc8/xyiuv8O677xIdHc306dMZOHAgu3btwsPDA4CRI0dy8uRJ1qxZQ35+PmPGjGHcuHEsW7YMsP3P4Nprr2XAgAEsXLiQ3377jbvvvpuAgADGjRtXpliVM0XqptqUM2sT5UyRukk5s2ooZ4rUTfUpZ7722ms8//zzxMfH06lTJxYsWECPHj1KHduvXz++//77Etuvu+46vvjiiz99LuVMkbqpPuXM6qScKVI3lSVn1ruit4iIs61fv54bb7yR66+/HoCmTZvy/vvvs3nzZsA2y3v+/Pk8+eST3HjjjQC89957hIeH89lnnzFixAh2797NqlWr2LJlC926dQNgwYIFXHfddbzwwgs0aNCApUuXkpeXx+LFi3Fzc6Ndu3bs2LGDefPmlbnoLSIiIiIiIiKOli9fztSpU1m4cCE9e/Zk/vz5DBw4kL179xIWFlZi/CeffEJeXp79/unTp+nUqRO33XZbdYYtIiIiUqddfMVvERGpdL1792bt2rXs27cPgF9//ZWffvqJwYMHA3D48GHi4+MZMGCAfR9/f3969uzJhg0bANiwYQMBAQH2gjfAgAEDMJvNbNq0yT7myiuvxM3NzT6m+EN4SkpKqbHl5uaSnp7ucBMRERERERGRs+bNm8e9997LmDFjaNu2LQsXLsTLy4vFixeXOj4oKIiIiAj7bc2aNXh5eanoLSIiIlKJVPQWEalmjz32GCNGjKBNmza4urrSpUsXpkyZwsiRIwGIj48HIDw83GG/8PBw+2Px8fElrh53cXEhKCjIYUxpxzj3Oc43d+5c/P397beoqKhLfLUiIiIiIpXEMJwdgYgIeXl5bNu2zeFCdbPZzIABA+wXqv+Zt99+mxEjRuDt7V01QVqtUJBbNccWEaljCq0GOfmFzg5DRCqB2ptLjfL813vYcPA0y+69HA9XS4WPYxgGBQUFFBbqf1a1ncViwcXFpU6tcfPhhx+ydOlSli1bZm85PmXKFBo0aMDo0aOdGtu0adOYOnWq/X56enqZC98zPv+dT385zj+uacVdfaKrKkSpAsqZdUddzJn12akzOdz73jaGXtaQUb2aOjscKaKcWXcoZ9Yiq6fDtnfhL1PhiinOjkbKQTmz7lDOPCspKYnCwsJSLzLfs2fPn+6/efNmfv/9d95+++0LjsnNzSU392zRulxd2L6ZBZvfgqseh14PlH0/cTrlzLrF1dUVi6Xi329L9Zi3ei+Lfz7Cg9e0YuwV+j6zNlHOrFsqK2eq6C01ygeb4zidmcdvx9Po3jSoQsfIy8vj5MmTZGVlVXJ04ixeXl5ERkY6tOmuzR5++GH7bG+ADh06EBsby9y5cxk9ejQREREAJCQkEBkZad8vISGBzp07AxAREcGpU6ccjltQUEBycrJ9/4iICBISEhzGFN8vHnM+d3d33N3dK/S6Cq0GZ3IKSMnKr9D+4hzKmXVPXcuZ9dlnvxzn17hUEtNzVPSuIZQz6x7lzNrh9+OptM9NY9+hw7S6wtnRSFkpZ9Y9ypmV4+2336ZDhw706NHjgmPmzp3LrFmzKvYEFjfIOwMJf1QwQnEG5cy6x2Qy0ahRI3x8fJwdilxEVM5ehhesInlXD1DRu9ZQzqx7KitnqugtNYZhGKRm24plqRUsmlmtVg4fPozFYqFBgwa4ubnpKuRazDAM8vLySExM5PDhw7Rs2RKzufavypCVlVXidVgsFqxWKwDR0dFERESwdu1ae5E7PT2dTZs2cf/99wPQq1cvUlNT2bZtG127dgXg22+/xWq10rNnT/uYJ554gvz8fFxdXQFYs2YNrVu3JjAwsNJfV4CX7TlSs/Iq/dhSNZQz65a6mjPrs42HkgE4kZbD8dRsGgZ4Ojmi+k05s25Rzqxd4gt8aQ/kpiX86VipGZQz6xblTEchISFYLJZSLzK/0AXmxTIzM/nggw+YPXv2RcddShc2wtsBUBj/G5pjWjsoZ9Y9hmGQmJjIsWPHaNmypWZ812BXZq/lNtel/OdkOoYxWn97tYByZt1TmTlTRW+pMTJyCyi02tZoS6lg0SwvLw+r1UpUVBReXl6VGZ44iaenJ66ursTGxpKXl4eHh4ezQ7pkQ4YM4Z///CeNGzemXbt2/PLLL8ybN4+7774bsF3VNGXKFJ555hlatmxJdHQ006dPp0GDBtx0000AxMTEMGjQIO69914WLlxIfn4+EyZMYMSIETRo0ACAO+64g1mzZjF27FgeffRRfv/9d15++WVeeumlKnldgV62q/2LL16Rmk85s+6pizmzviootLL5cLL9/pbDyTTs0tCJEYlyZt2jnFl7uPqFwXGwZCc5OxQpI+XMukc58yw3Nze6du3K2rVr7Z/RrVYra9euZcKECRfd96OPPiI3N5e//e1vFx13KV3Y3tjjwf0Ap3ZDYQFY9PVvTaecWTeFhoZy5MgR8vPzVfSuwYKiO8JuiCqI5VBSJs1DNTO/plPOrJsqK2fqrEdqjHNnd1/qTNH6fMVxXVTX/j0XLFjA9OnTeeCBBzh16hQNGjTgvvvuY8aMGfYxjzzyCJmZmYwbN47U1FSuuOIKVq1a5fDFwtKlS5kwYQL9+/fHbDYzdOhQXnnlFfvj/v7+rF69mvHjx9O1a1dCQkKYMWMG48aNq5LX5e9ZPNNbRe/apq79jdV3+vesG34/kU5GboH9/pYjydykoneNoL+xukX/nrWDV6Bt3Vz3vBQnRyLlpb+xukX/nmdNnTqV0aNH061bN3r06MH8+fPJzMxkzJgxAIwaNYqGDRsyd+5ch/3efvttbrrpJoKDg6sstkL/JmQa7nhbcyH5IIS2rrLnksqlv7G6RTNPawfXCFt3jJbmY/xwOFlF71pEObNuqaycqaK31Bhp58wO1ZrAUpf5+voyf/585s+ff8ExJpOJ2bNnX7TlWVBQEMuWLbvoc3Xs2JEff/yxoqGWi32mt9qbi4hcso2HTgPg6+7CmdwCth5RoUdE6i+/EFsnI58C5UIRqRmGDx9OYmIiM2bMID4+ns6dO7Nq1SrCw20X6Rw9erTEl/F79+7lp59+YvXq1VUaW68Woez9PorLTAewxv+OWUVvEZELC20DQANTMr8djGNEj8ZODkhELoUuhZAaw3Gmt4relaFp06YXLayKVCb7mt5qby61lHKm1CQbDtqK3nf2agLA3oQzpOn8SGoQ5UypTsGhkQAEGGkUFBQ6ORqR8lPOrJsmTJhAbGwsubm5bNq0iZ49e9ofW7duHUuWLHEY37p1awzD4JprrqnSuDo2CuCAyXYOmXxoe5U+l0hVUM6UauUZQK6n7YKl5CM7nRyMSPkpZzpS0VtqjNTss7ND69tMUZPJdNHbzJkzK3TcLVu2XHIr6379+jFlypRLOobUD/ait4oyUsWUM6Wuyy+0suWIbT3vGzo2oFmINwBbY5MvtptIqZQzpS4ICrXN9HY3FXDq9GknRyN1mXKm1AWuFjPZQTEAZMf96uRopC5TzpS6whJuy5l+GQdJSM9xcjRSVylnVg+1N5caw7G9ef0qep88edL++/Lly5kxYwZ79+61b/PxObuWiGEYFBYW4uLy53++oaGhlRuoyEUEFLU3T8/Jp9BqYDFr7SKpGsqZUtftPJZGVl4hgV6utInwpXvTIA4lZbLlSAr9Y8KdHZ7UMsqZUheYPXzIwgMvckhKOEaD8DBnhyR1lHKm1BV+TTpDCnin7P3TsSIVpZwpdYVLRFs4so5WpmNsPpzMkE4NnB2S1EHKmdVDM72lxqjP7c0jIiLsN39/f0wmk/3+nj178PX15auvvqJr1664u7vz008/cfDgQW688UbCw8Px8fGhe/fufPPNNw7HPb+1hclk4t///jc333wzXl5etGzZkpUrV15S7B9//DHt2rXD3d2dpk2b8uKLLzo8/vrrr9OyZUs8PDwIDw/n1ltvtT+2YsUKOnTogKenJ8HBwQwYMIDMzMxLikecx9/TNtPbMCBdLc6lCilnKmfWdcXrefeMDsZsNtGtaSAAW49opreUn3KmcmZdkWHxByA18YSTI5G6TDlTObOuaNa+BwBBhaewZqY4ORqpq5QzlTPrjKJ1vVuajtm7rolUNuXM6smZmuktNUZVzfQ2DIPs/Opf983T1YLJVHkzXR977DFeeOEFmjVrRmBgIHFxcVx33XX885//xN3dnffee48hQ4awd+9eGjdufMHjzJo1i+eee47nn3+eBQsWMHLkSGJjYwkKCip3TNu2bWPYsGHMnDmT4cOHs379eh544AGCg4O566672Lp1K5MmTeL//u//6N27N8nJyfz444+A7cqm22+/neeee46bb76ZM2fO8OOPP2IYRoXfI3EuV4sZH3cXMnILSM3OJ9DbzdkhSQUoZzpSzhRnKC56X97M9t9Z96a2nzuPpZGTX4iHq8VpsYkj5UxHyplSlbJdg6AwgcyUBGeHIhWknOlIOVOqUrvoKI4boTQ0JXJk9xaadbvW2SFJOSlnOlLOlCoVZmtv3sp8jDmHVfSujZyVM6Fy86Zy5qVT0VtqjHPX8a7Mmd7Z+YW0nfF1pR2vrHbNHoiXW+X9ic2ePZtrrrnGfj8oKIhOnTrZ7z/99NN8+umnrFy5kgkTJlzwOHfddRe33347AHPmzOGVV15h8+bNDBo0qNwxzZs3j/79+zN9+nQAWrVqxa5du3j++ee56667OHr0KN7e3txwww34+vrSpEkTunTpAtgSXkFBAbfccgtNmjQBoEOHDuWOQWqWAC9XMnILSMnKIxpvZ4cjFaCc6Ug5U6pbXoGVrUdss3F6NQ8BoEmwFyE+7iRl5LLzWBo9osv/IUWqhnKmI+VMqUr5nsGQA3lpKnrXVsqZjpQzpSq5WMyc8mpOw+xE4vdtVdG7FlLOdKScKVUqtDUAEaYUTiTEk5adb+9oKbWDs3ImVG7eVM68dGpvLjXGuYXu3AIr2XnOuTKnpurWrZvD/YyMDB566CFiYmIICAjAx8eH3bt3c/To0Ysep2PHjvbfvb298fPz49SpUxWKaffu3fTp08dhW58+fdi/fz+FhYVcc801NGnShGbNmnHnnXeydOlSsrKyAOjUqRP9+/enQ4cO3Hbbbbz11lukpKjlVq321aN8kTOaOy2rSatnSxRIzaOcKbXVr8dSyc4vJMjbjVbhtvWcTCYTPaJtLc7Vak2qgnKm1AYmL9uFQIUZiU6OROo75UypLYywdgAUnNjp5EikPlPOlFrBwx/8GgHQkmNsi9XnbnEO5cxLp5neUmOknrcGcEpWHp5unpd8XE9XC7tmD7zk41TkeSuTt7fjrNmHHnqINWvW8MILL9CiRQs8PT259dZbycu7eGt4V1fHq9RMJhNWq7VSYy3m6+vL9u3bWbduHatXr2bGjBnMnDmTLVu2EBAQwJo1a1i/fj2rV69mwYIFPPHEE2zatIno6OgqiUeqWEEu/kY6waZ0UrMrb4kCqV7KmY6UM6W6bTx4trX5ue2xujUJ4svf4rWudw2jnOlIOVOqkotfGBwHc1aSs0ORClLOdKScKVUtuPllEPs2ARn7KbQaWMyV17Jaqp5ypiPlTKlyYW0g/RitzMfYfDiFq9uEOzsiKQdn5czi564sypmXTjO9pcY4f2ZoZa3rbTKZ8HJzqfZbZa5/U5qff/6Zu+66i5tvvpkOHToQERHBkSNHqvQ5zxcTE8PPP/9cIq5WrVphsdiSvYuLCwMGDOC5555j586dHDlyhG+//Raw/dv06dOHWbNm8csvv+Dm5sann35ara9BKpFnAAD+ZJKSqZnetZVyZtVRzpSy2FC0nnevZsEO24vX9d4am4LVqvXiagrlzKqjnCnn8wyIAMA997STI5GKUs6sOsqZUppGbXoA0MKI449junCytlHOrDrKmVKq0DYAtDId08XmtZCzcmZV503lzPLTTG+pMc6fGar2yBfXsmVLPvnkE4YMGYLJZGL69OlVdrVOYmIiO3bscNgWGRnJP/7xD7p3787TTz/N8OHD2bBhA6+++iqvv/46AP/73/84dOgQV155JYGBgXz55ZdYrVZat27Npk2bWLt2Lddeey1hYWFs2rSJxMREYmJiquQ1SDXwtLXe9TdlciRbf79SsyhnSm2QW1DIttji9bwdi94xkb54u1k4k1PA3oQzxET6OSNEqSeUM6Um8g22Fb19CtPIyivAy01fZ0jNoJwpNZUlpDl5Jje8yGXXrp10bHyVs0MSUc6UmivM9m/Y0nSMncfSyMkvxKOSOx+IlJdyZvnpU6LUGMVrejfw9+BEWg4pKnpf1Lx587j77rvp3bs3ISEhPProo6Snp1fJcy1btoxly5Y5bHv66ad58skn+fDDD5kxYwZPP/00kZGRzJ49m7vuuguAgIAAPvnkE2bOnElOTg4tW7bk/fffp127duzevZsffviB+fPnk56eTpMmTXjxxRcZPHhwlbwGqQZFRe8AMkitpE4NIpVFOVNqgx1HU8ktsBLi407zUB+Hx1wsZi5rEsiP+5PYeiRZRW+pUsqZUhN5BthaTIaY0jmRmkOLMJ8/2UOkeihnSo1ltpDm04LQM7tIOrAdUNFbnE85U2qsUFsRro3lOHn5Vn6NS6XneR3YRKqbcmb5mQzDcGp/xNdee43nn3+e+Ph4OnXqxIIFC+jRo8cFx8+fP5833niDo0ePEhISwq233srcuXPx8PAo0/Olp6fj7+9PWloafn76srCmyMkvpM30VYCtneeGQ6d55qb2/O3yJuU7Tk4Ohw8fJjo6usz/TUjNd7F/V/1NV61yvb+7VsKHd7LN2pJ3Y97ildu7VE+QUmHKmXWTcqbzXOr7O/+bfcz/Zj83dIzk1TsuK/H4y9/s56Vv9vHXTg2UY51AObNuUs50nnK/vyd/hTev5JQRwJ6RW7myVWjVBykVppxZNylnOk9F39+UZeMI3LecN4yh3Dvj37hYtNJlTaScWTcpZzpPhd7f3AyY2xCAzjlvcs+1XZlwdcsqjFIqSjmzbqqsnOnUM53ly5czdepUnnrqKbZv306nTp0YOHAgp06dKnX8smXLeOyxx3jqqafYvXs3b7/9NsuXL+fxxx+v5silshXP8raYTTQK9CzappmiIrXKuTO91d5cRKTcNhwsWs+7eelXk3dvasuzWl9MROolrxAAAjnDydRMJwcjIlI7+Ed3BqC59Qi/HU9zbjAiIjWZuw/4NwZs63pvPpLi5IBEpCKcWvSeN28e9957L2PGjKFt27YsXLgQLy8vFi9eXOr49evX06dPH+644w6aNm3Ktddey+23387mzZurOXKpbMXreQd4uhLk7Qag9uYitU1R0dvPlKmLVkSkWhUWFjJ9+nSio6Px9PSkefPmPP3005zb0MgwDGbMmEFkZCSenp4MGDCA/fv3OxwnOTmZkSNH4ufnR0BAAGPHjiUjI6NaXkNOfiG/HE0FbF1vStO5cQAWs4kTaTkcT82ulrhERGoMb1vR29VUyOmkRCcHIyJSO5gjOgDQxnSUDYdOOzkaEZEaLqwNAK3Mx9gem0Kh1alNkkWkApxW9M7Ly2Pbtm0MGDDgbDBmMwMGDGDDhg2l7tO7d2+2bdtmL3IfOnSIL7/8kuuuu65aYpaqUzzT29/LlQAvN4dtIlJLeAYAEEAmqZkqeotI9Xn22Wd54403ePXVV9m9ezfPPvsszz33HAsWLLCPee6553jllVdYuHAhmzZtwtvbm4EDB5KTk2MfM3LkSP744w/WrFnD//73P3744QfGjRtXLa9h+9EU8gqthPm6Ex3iXeoYLzcX2jewtXHaclizvUWknnFxJ9diW8c7I/mkk4MREaklwtsB0NicyI4DcU4ORkSkhgu1Fb3buZwgI7eA3SerZu1kEak6Tit6JyUlUVhYSHh4uMP28PBw4uPjS93njjvuYPbs2VxxxRW4urrSvHlz+vXrd9H25rm5uaSnpzvcpOYpLnAHeLoS6OVatE1FM5FapWimt6upkLxs5VoRqT7r16/nxhtv5Prrr6dp06bceuutXHvttfYLJQ3DYP78+Tz55JPceOONdOzYkffee48TJ07w2WefAbB7925WrVrFv//9b3r27MkVV1zBggUL+OCDDzhx4kSVv4aN57Q2N5lMFxzXvWkQAFvU4lxE6qF8D1sOzElLcHIkIiK1hFcQ+d4RAGQc3Ul+odXJAYmI1GBhMQB09rDVpzbrYnORWsep7c3La926dcyZM4fXX3+d7du388knn/DFF1/w9NNPX3CfuXPn4u/vb79FRUVVY8RSVmnF7c293AgoKnqnqOgtUru4emGYbX+/5pw0CvRhWkSqSe/evVm7di379u0D4Ndff+Wnn35i8ODBABw+fJj4+HiHDkP+/v707NnT3mFow4YNBAQE0K1bN/uYAQMGYDab2bRpU6nPW5kXVxa3m7xQa/Ni3YqK3lu1vpiI1ENWr1AACs+ovbmISFm5RNpanDcrPMzOY6nODUZEpCYrmundxHoU0MXmIrWR04reISEhWCwWEhIcr9BOSEggIiKi1H2mT5/OnXfeyT333EOHDh24+eabmTNnDnPnzsVqLb24Mm3aNNLS0uy3uDi18qmJzp3prfbmIrWUyWSf7R1gyiA9p8DJAYlIffHYY48xYsQI2rRpg6urK126dGHKlCmMHDkSwN5F6GIdhuLj4wkLC3N43MXFhaCgoAt2Iaqsiyuz8wrZEZcK2GZ6X0y3prY8uzfhDGk6VxKResbF11b0NmUmYhhaY1FEpCxMRS3O25iOsuGg1vUWEed47bXXaNq0KR4eHvTs2dPeme1CUlNTGT9+PJGRkbi7u9OqVSu+/PLLqg0ytDUAXvkpBJHOliPJOucUqWWcVvR2c3Oja9eurF271r7NarWydu1aevXqVeo+WVlZmM2OIVssFoALJh93d3f8/PwcblLzpGafXdM7sLjona0vckVqG1NR0dvflKklCkSk2nz44YcsXbqUZcuWsX37dt59911eeOEF3n333Sp93sq6uHJbbAr5hQaR/h40DvK66NgQH3eaFa35vTVWV52LSP3i7m+7OMnPmk6KLvwRESmbCNtM7zbmODYe0vmjiFS/5cuXM3XqVJ566im2b99Op06dGDhwIKdOnSp1fF5eHtdccw1HjhxhxYoV7N27l7feeouGDRtWbaBu3hDQBIC2LsdJysjjyOmsqn1OEalULs588qlTpzJ69Gi6detGjx49mD9/PpmZmYwZMwaAUaNG0bBhQ+bOnQvAkCFDmDdvHl26dKFnz54cOHCA6dOnM2TIEHvxW2qnszO93RzW9LZaDczmC69rKSI1jGcAAP5k6otIEak2Dz/8sH22N0CHDh2IjY1l7ty5jB492t5FKCEhgcjISPt+CQkJdO7cGYCIiIgSH7gLCgpITk6+YBcid3d33N3dLzn+DYeSAFtr84ut512se9MgDiVlsuVICv1jwv90vIhIXWHxsRW9g01pnEjNJsjbzckRiYjUAkUzvVub4tgWm0RuQSHuLvoeVUSqz7x587j33nvtdZ+FCxfyxRdfsHjxYh577LES4xcvXkxycjLr16/H1dVWK2jatGn1BBsWA6mx9As8zU+JsOVwMtFFF56LSM3n1DW9hw8fzgsvvMCMGTPo3LkzO3bsYNWqVfbWk0ePHuXkyZP28U8++ST/+Mc/ePLJJ2nbti1jx45l4MCBvPnmm856CVJJzq7p7Yp/UdHbasAZtUcWqV3OaW9e/HctIlLVLtQNqHj5m+joaCIiIhw6DKWnp7Np0yZ7h6FevXqRmprKtm3b7GO+/fZbrFYrPXv2rNL4i9tMXv4nrc2LFbc436r1xUSkvvEOASDYlM6J1GwnByMiUksEt8CwuOFryia44BS/xqU5OyIRqUfy8vLYtm0bAwYMsG8zm80MGDCADRs2lLrPypUr6dWrF+PHjyc8PJz27dszZ84cCgsLSx2fm5tLenq6w63Citb17uplW5Z3sz53i9QqTi16A0yYMIHY2Fhyc3PZtGmTw5eK69atY8mSJfb7Li4uPPXUUxw4cIDs7GyOHj3Ka6+9RkBAQPUHLpXKPtPbyxV3FwtebrYrTlPUHrlc+vXrx5QpU5wdhtRnxe3NybT/XYvUVMqZdceQIUP45z//yRdffMGRI0f49NNPmTdvHjfffDMAJpOJKVOm8Mwzz7By5Up+++03Ro0aRYMGDbjpppsAiImJYdCgQdx7771s3ryZn3/+mQkTJjBixAgaNGhQZbFn5haw85jti8dezcpW9O7eNAiAncfSyMkv/UO/SGVTzpQawdu2pncwZ1T0lhpNOVNqFIsrpqJ1amPKu6538mFI3FdFgYnYKGfWbUlJSRQWFtonOhYLDw8nPj6+1H0OHTrEihUrKCws5Msvv2T69Om8+OKLPPPMM6WOnzt3Lv7+/vZbVFRUxQMOiwEg2noUgC0qeksNo5x5cU4veovA2aK3v6dtlnfxut71peg9ZMgQBg0aVOpjP/74IyaTiZ07d17y8yxZskQXiUjV8ggAbDO91d5cqopyppxvwYIF3HrrrTzwwAPExMTw0EMPcd999/H000/bxzzyyCNMnDiRcePG0b17dzIyMli1ahUeHh72MUuXLqVNmzb079+f6667jiuuuIJFixZVaexbY1MosBo0DPAk6k/W8y7WJNiLEB938gqt9oK5yIUoZ0qdYp/pncbJtBwnByN1kXKm1Fnh7QFb0XvjoTIWvXPS4a2r4N/9IfdMFQYntZVyplQVq9VKWFgYixYtomvXrgwfPpwnnniChQsXljp+2rRppKWl2W9xcXEVf/Kimd5+GQcxmQxiT2dxKl3nnXLplDOrh4reUiOkZRfP9HYr+lm0rnd2/SiajR07ljVr1nDs2LESj73zzjt069aNjh07OiEykXKyz/TOIK2eXLQi1U85U87n6+vL/PnziY2NJTs7m4MHD/LMM8/g5nZ2rVeTycTs2bOJj48nJyeHb775hlatWjkcJygoiGXLlnHmzBnS0tJYvHgxPj4+VRp78UybXmVsbQ6219Ij2pZvddW5/BnlTKlTvGxF7yDTGY5rprdUAeVMqbOKit5tzEfZdjSlbN2Cfv8YslMgNx1OH6ziAKU2Us6UsggJCcFisZCQkOCwPSEhgYiIiFL3iYyMpFWrVlgsFvu2mJgY4uPjycsr+X2ju7s7fn5+DreKB9wKMGHOTubyMNuSaWpxLpVBObN6qOgtNYK96F0009te9K4nRbMbbriB0NBQh3b+ABkZGXz00UeMHTuW06dPc/vtt9OwYUO8vLzo0KED77//fqXGcfToUW688UZ8fHzw8/Nj2LBhDickv/76K1dddRW+vr74+fnRtWtXtm7dCkBsbCxDhgwhMDAQb29v2rVrx5dfflmp8Ukt4BkAgL8ps95ctCLVTzlT6pINRTNtytravFi3JrYW51rXW/6McqbUKUXtzYM4Q0JqppODkbpIOVPqrPB2ALSzxJFXYOWXo6l/vs8v/3f299TYqolLajXlTCkLNzc3unbtytq1a+3brFYra9eupVevXqXu06dPHw4cOIDVarVv27dvH5GRkQ4Xt1dNwF4Q2BSAgaEpAGw5rM/dcumUM6uHi7MDEMkvtJKRWwCcLXYXz/hOyayEoplhQH7WpR+nvFy9wGQq01AXFxdGjRrFkiVLeOKJJzAV7ffRRx9RWFjI7bffTkZGBl27duXRRx/Fz8+PL774gjvvvJPmzZvTo0ePSw7XarXak933339PQUEB48ePZ/jw4axbtw6AkSNH0qVLF9544w0sFgs7duzA1dX2bzZ+/Hjy8vL44Ycf8Pb2ZteuXVU+O05qoKKZ3gFkqr15baWcWSbKmVIZzuTk8/txW3vyy8sx0xvOruu9NTYFq9XAbC7b349UMuXMMlHOlErjZcuVZpNBZuopJwcj5aacWSbKmVIlimZ6RxGPJzlsOHT64p2G4n+H49vO3k89WsUBSgnKmWWinFk7TJ06ldGjR9OtWzd69OjB/PnzyczMZMyYMQCMGjWKhg0bMnfuXADuv/9+Xn31VSZPnszEiRPZv38/c+bMYdKkSdUTcFgMpBymm3cCEMLmIynV87xScc7KmVDmvKmcWT1U9BanK57lbTKBr0fxmt6VONM7PwvmNLj045TX4yfAzbvMw++++26ef/55vv/+e/r16wfY2loMHToUf39//P39eeihh+zjJ06cyNdff82HH35YKQlv7dq1/Pbbbxw+fJioqCgA3nvvPdq1a8eWLVvo3r07R48e5eGHH6ZNG9vaJi1btrTvf/ToUYYOHUqHDh0AaNas2SXHJLVQcdHblFFvOjXUOcqZZaKcKZVh65EUCq0GjYO8aBjgWa59YyJ98XazcCangH2nztAm4hLat0nFKWeWiXKmVBqLC1aPQMw5KRRmJFFQaMXFogZ2tYZyZpkoZ0qV8AkF7zDMmadoZTrGxkN/8rd47ixvgBTN9K52ypllopxZOwwfPpzExERmzJhBfHw8nTt3ZtWqVYSHhwO2fwez+ew5XVRUFF9//TUPPvggHTt2pGHDhkyePJlHH320egIOi4G9X9LciAPasSc+nbTsfPyLutRKDeSsnAnlypvKmVVPnw7F6VKLZoP6urtgKZqlFFg007s+tUdu06YNvXv3ZvHixQAcOHCAH3/8kbFjxwJQWFjI008/TYcOHQgKCsLHx4evv/6ao0cr52rb3bt3ExUVZU92AG3btiUgIIDdu3cDtqvy7rnnHgYMGMC//vUvDh48u6bTpEmTeOaZZ+jTpw9PPfUUO3furJS4pJbxCACK2ptrprdUIeVMqQsq2tocwMVi5rImRet6q9Wa/AnlTKlLTD7FLc7TSDiT6+RopC5SzpQ6q6jFeYz5KDuOpl54Xe/8HNi53PZ7mxtsP9XeXC5AOVPKasKECcTGxpKbm8umTZvo2bOn/bF169aVaPncq1cvNm7cSE5ODgcPHuTxxx93WOO7SoXGAOCZup8mwV4YBmw/qtnecumUM6ueZnqL06Vl22aDFrc0P/f3SmmP7Oplu9qmurl6lXuXsWPHMnHiRF577TXeeecdmjdvTt++fQF4/vnnefnll5k/fz4dOnTA29ubKVOmkJdXfbNpZ86cyR133MEXX3zBV199xVNPPcUHH3zAzTffzD333MPAgQP54osvWL16NXPnzuXFF19k4sSJ1RZfbXL8+HEeffRRvvrqK7KysmjRogXvvPMO3bp1A8AwDJ566ineeustUlNT6dOnD2+88YbDlVXJyclMnDiR//73v5jNZoYOHcrLL7/s0FJk586djB8/ni1bthAaGsrEiRN55JFHqu6FFc309ieT1GzN9K6VlDMrjXKm/JmNxUXvcrY2L9atSRA/7k9iy5EU7uzVtBIjkzJTzqw0yplSVibvUEjaRzDpnEjNLnenDHEi5cxKo5wpFRLRHg59R1f343yQZWVbbAp9WoSUHLfnf5CdAn4NoesY2321N69+ypmVRjlTyi3MNsOVU7vp3iyQ2NNZbDmczFWtw5wbl1yYs3Jm8XOXg3Jm1dJMb3G64tmgxet5AwR4VmJ7c5PJ1l6ium9lXP/mXMOGDcNsNrNs2TLee+897r77bvvaDj///DM33ngjf/vb3+jUqRPNmjVj3759l/7+FImJiSEuLo64uDj7tl27dpGamkrbtm3t21q1asWDDz7I6tWrueWWW3jnnXfsj0VFRfH3v/+dTz75hH/84x+89dZblRZfXZKSkkKfPn1wdXXlq6++YteuXbz44osEBgbaxzz33HO88sorLFy4kE2bNuHt7c3AgQPJycmxjxk5ciR//PEHa9as4X//+x8//PAD48aNsz+enp7OtddeS5MmTdi2bRvPP/88M2fOZNGiRVX34oqK3r6mbDKysqvueaTqKGeWiXKmXKr0c9fzrsBMb4DuTW05d+sRzfR2GuXMMlHOlEpVtK53kMlW9JZaRDmzTJQzpcoUrevdxcNWFNhw8HTp44pbm3ceCUHRtt9Tj9rWS5Xqo5xZJsqZUiWCW4LJDDmpXBlpBWCLPnfXbM7KmRXIm8qZVUszvcXpiove566JEeht+z2lnq0J7OPjw/Dhw5k2bRrp6encdddd9sdatmzJihUrWL9+PYGBgcybN4+EhASHZFQWhYWF7Nixw2Gbu7s7AwYMoEOHDowcOZL58+dTUFDAAw88QN++fenWrRvZ2dk8/PDD3HrrrURHR3Ps2DG2bNnC0KFDAZgyZQqDBw+mVatWpKSk8N133xETE3Opb0md9OyzzxIVFeXwP4vo6Gj774ZhMH/+fJ588kluvPFGwLa2Rnh4OJ999hkjRoxg9+7drFq1ii1btthnhy9YsIDrrruOF154gQYNGrB06VLy8vJYvHgxbm5utGvXjh07djBv3jyH4nil8vC3/2rKSdc6i1KllDOlNtt8KBmrAdEh3kT4e1ToGJ0bB2AxmziRlsNxzXaUP6GcKXWGt629ebApnROpOX8yWKRilDOlTipqb9447zBg2LsOOUg5AofWASbo8jfwjbT9np8FmYngo1mOUpJyptQ5rh4Q1AxOH6C7dzwAv8alkZNfiIdrNbVYlzpLObNqqRIhTle8bndp7c3r45rAY8eOJSUlhYEDB9KgQQP79ieffJLLLruMgQMH0q9fPyIiIrjpppvKffyMjAy6dOnicBsyZAgmk4nPP/+cwMBArrzySgYMGECzZs1Yvty2jpPFYuH06dOMGjWKVq1aMWzYMAYPHsysWbMAWyIdP348MTExDBo0iFatWvH6669XyntS16xcuZJu3bpx2223ERYWRpcuXRyuiDp8+DDx8fEMGDDAvs3f35+ePXuyYcMGADZs2EBAQIC94A0wYMAAzGYzmzZtso+58sorcXM7+7c1cOBA9u7dS0pK6evQ5Obmkp6e7nArF4sLhrsvAAGmDNKy69/fsFQv5UyprYrX867oLG8ALzcX2jfwA7Sut5SNcqbUCUVF7xDSOZmmmd5SdZQz5c+89tprNG3aFA8PD3r27MnmzZsvOj41NZXx48cTGRmJu7s7rVq14ssvv6ymaIGQVmB2wa0gnUiS+fVYKll5BY5jfvmP7WezfhDYBFzcwK/ov3+1OJeLUM6UOifU1uI8IvcwIT5u5BVa2XkszclBSV2hnFl1NNNbnC6taDZ3wLkzvetx0btXr14YpbSMCgoK4rPPPrvovuvWrbvo43fddZfDlUPna9y4MZ9//nmpj7m5ufH+++9fcN8FCxZc9LnlrEOHDvHGG28wdepUHn/8cbZs2cKkSZNwc3Nj9OjRxMfbriAMDw932C88PNz+WHx8PGFhjldYu7i4EBQU5DDm3Bnk5x4zPj7eoZ16sblz59r/J1ZRJo9AyD1TtK53PsE+7pd0PJGLUc6U2srH3YUIPw8ubxZ0Scfp3jSIX4+lseVIMjd1aVhJ0UldpZwpdYK3bf1ZtTeXqqacKRezfPlypk6dysKFC+nZsyfz58+3X2R+/md1gLy8PK655hrCwsJYsWIFDRs2JDY2loCAgOoL2sXdVvg+tYsrfE/y0Zlgth5J4cpWtouJsBbCL0ttv19259n9AppA+nHbLPBG3UocVgSUM6UOCouBPf/DlLiH7k0v56vf49lyJJke0Zf2GV4ElDOrkmZ6i9Odneldck3vjNwC8gqsTolLpKpYrVYuu+wy5syZQ5cuXRg3bhz33nsvCxcudHZoTJs2jbS0NPvt3PU9yswzAAB/Uwap9WyJAhGRsnrwmlZsmHY1N3Rs8OeDL6JbU9sH7nV7E1m6KZb/7TzBj/sT2XksldjTmaRm5VFo1fqLIlKHFBW91d5cRJxp3rx53HvvvYwZM4a2bduycOFCvLy8WLx4canjFy9eTHJyMp999hl9+vShadOm9O3bl06dOlVv4EXrel8VkAic7T4EwIG1cOYEeAZCmxvObg9sYvuZGltdUYqIOF/RTG9O7aF70efuzeqwJlLjaaa3OF1pa3r7ebpiMoFhQGp2HmG+FVvrUqQmioyMLLEOR0xMDB9//DEAERERACQkJBAZGWkfk5CQQOfOne1jTp065XCMgoICkpOT7ftHRESQkJDgMKb4fvGY87m7u+Pufokzsz1tM8gDyKyX3RpERMrKZDJhMV3aMbo1DcRkguOp2Tzx6e8XeB7bzPIgbzeiAr2ICvIiKsiTxkFeRAV60TjIiwAvV0ymSwxGRKQ6FK/pTTon1N5cRJwgLy+Pbdu2MW3aNPs2s9nMgAED7EuSnW/lypX06tWL8ePH8/nnnxMaGsodd9zBo48+isVSjevDhreD36CD6zEA1h88p+j9y3u2n51ut80KLxbQ2PZT7c1FpD4JK1qnOHEPPQbZvuvcFptCQaEVF4vmkorUVCp6i9OVtqa3xWzC39OV1Kx8UrPyVfSWOqVPnz7s3bvXYdu+ffto0sR29XR0dDQRERGsXbvWXuROT09n06ZN3H///YCtBUpqairbtm2ja9euAHz77bdYrVZ69uxpH/PEE0+Qn5+Pq6vtopI1a9bQunXrUlubVxr7TG8VvUVEqlqIjzvzhnXip/2nScvOJz07n7Rzbtn5hRgGnMkp4ExOAbGns0o9jq+7C42CvGgc5EnTEG+ah/jQLNSb6BBvgrzdVBAXkZrD6+xM79SsfLLyCvBy01cbIlJ9kpKSKCwsLHVJsj179pS6z6FDh/j2228ZOXIkX375JQcOHOCBBx4gPz+fp556qsT43NxccnNz7ffT09MrJ/iimd6ROQcB2HkslZTMPAKNVNj7lW1Mlzsd9wkomumdopneIlKPBLcAkwVy04nxycDXw4UzOQXsOplOx0YBzo5ORC5AnwzF6Upb0xts63oXF71F6pIHH3yQ3r17M2fOHIYNG8bmzZtZtGgRixYtAmwz/6ZMmcIzzzxDy5YtiY6OZvr06TRo0ICbbroJsM0MHzRokL0ten5+PhMmTGDEiBE0aGBrlXvHHXcwa9Ysxo4dy6OPPsrvv//Oyy+/zEsvvVS1L9A+0zuDFLU3FxGpcjd3acTNXRqV+lhegdVeAD+dkUtcSjZHk7OIK7odTc7i1JlczuQWsPtkOrtPlvxC1d/TlWah3jQrKoQ3KyqEe7haim5m3F1sPz1cLbi7mFUkF5GqUzTTO8CUiSsFnEjNoUWYj5ODEhG5OKvVSlhYGIsWLcJisdC1a1eOHz/O888/X2rRe+7cucyaNavyAwlvB4BLygE6hLvzW0IuP+xP5MbMFWAtgIbdINyxM53am4tIveTiDsHNIWkflqQ99GgaxNo9p9h46LSK3iI1mIre4nSlrekNZ9udq2gmdU337t359NNPmTZtGrNnzyY6Opr58+czcuRI+5hHHnmEzMxMxo0bR2pqKldccQWrVq3Cw+Ns14OlS5cyYcIE+vfvj9lsZujQobzyyiv2x/39/Vm9ejXjx4+na9euhISEMGPGDMaNG1e1L7Co6O1vyiQlWxetiIg4k5uLmVBfd0J93WkR5kPPUsbk5BdyLMVWAI89ncXhpEwOJWZyOCmT46nZpGXn88vRVH45mlrm53V3MePuYrYXxot/P7vNVij383ShR3QQf2kZSojPJS6vISL1g2cgmMxgWAnkDCfTslX0FpFqFRISgsViKXU5sQstJRYZGYmrq6tDK/OYmBji4+PJy8vDzc3NYfy0adOYOnWq/X56ejpRUVGXHrxvBHgGQXYyt0Sd4bcEN77fc4obE//P9vhlo0ruY29vHgfWQjBXYzt2ERFnCm0DSfvg1B56NhvM2j2n2HQomXFXNnd2ZCJyASp6i9MVz+Q+v+gdWHQ/tQJFb8MwLj0wqTHq4r/nDTfcwA033HDBx00mE7Nnz2b27NkXHBMUFMSyZcsu+jwdO3bkxx9/rHCcFeIRAIC/KYPD6tRQK9TFv7H6TP+eUl4erhZahPnSIsy3xGPZeYUcTsosKoRncCgpk0NJmZzJzicnv5CcAiu5RT8LrWf/28stsJJbYCU9p+BPn//9zXEAtGvgx5WtQrmyZShdmwTi5lIz10nT31jdon/PWshsBq9gyEwk2JTOiVSt612T6W+sbtG/p42bmxtdu3Zl7dq19m5sVquVtWvXMmHChFL36dOnD8uWLcNqtWI2285x9u3bR2RkZImCN4C7uzvu7lVwQaDJBBHt4fAP/MU3AYgibd+PYN0Prt7Q/paS+/g1BLMLWPPhTDz4N6z8uATQ31hdo3/POiAsBnavhMTdXN71bwBsPpJModXAYlZ3M2fT31jdUln/nip6i1MVWg3Sc2xFMX9Px5P8wKI1vlPKUTQrXrc4KysLT0/PSopSnC0ry7b+aPG/r9Rw9vbmmerUUMMpZ9ZNyplSmTzdLLRt4EfbBn5/Oja/0FbozskvLLpZyS04+zM33/bYuWNOpufw0/4k/jiRbr+9se4g3m4WejUPthfBmwR7VbhlekZuAT8fSOL7fYlk5xUysmdjujUNKvdxlDPrJuXMWso79Jyid46zo5FSKGfWTcqZZ02dOpXRo0fTrVs3evTowfz588nMzGTMmDEAjBo1ioYNGzJ37lwA7r//fl599VUmT57MxIkT2b9/P3PmzGHSpEnVH3y4regdbT2Cj3s0g/LW2L4hbn8zuJe8CBKzBfwbQcoRW4tzFb0rnXJm3ZSXZ/tO7NwOD1LLhLax/Ty1h7aRfvi429b13n0ynfYN/Z0bWz2mnFk3VVbOVNFbnOpMTj7FF3D4n7emd0BR0bs8a3pbLBYCAgI4deoUAF5eFf+CVJzPMAyysrI4deoUAQEBOkmsLTwDAFt78zS1N6/RlDPrFuVMcTZXixlXixkf93J+xBgMiWdy+elAIt/vTeTH/Umczszjm92n+Ga3LT+F+rrTqZE/nRoF0DEqgE6N/O3niuczDIO9CWdYt9d2vK2xyeQXnr1i+NNfjnNFixAmD2hJ93IUv5Uz6xblzJJee+01nn/+eeLj4+nUqRMLFiygR48eFxyfmprKE088wSeffEJycjJNmjRh/vz5XHfddVUfrFcwAEFopndNpZxZtyhnljR8+HASExOZMWMG8fHxdO7cmVWrVhEeHg7A0aNH7TO6AaKiovj666958MEH6dixIw0bNmTy5Mk8+uij1R980brellN/0D96ENcf3mTbftnoC+8T0NhW9E6JhSa9qz7GekY5s+6xWq0kJibi5eWFi4tKMLVWWIztZ+JeXMwmujUNZN3eRDYeOq2itxMpZ9Y9lZkzlXHFqYoL2t5ulhItLCva3rx4/aTipCe1X0BAwAXXxZIayD7TO6NcF62Icyhn1j3KmVIbhfq6c3OXRtzcpRFWq8Guk+l8vy+RH/Ylsi02hcQzuQ5FcICmwV50bBRAp6IieFJGrq3QvS+Rk2mOMz+bBnvRt1UouQVWVmw7xk8HkvjpQBK9mwczuX9LejYLLlOcypl1j3KmzfLly5k6dSoLFy6kZ8+ezJ8/n4EDB7J3717CwsJKjM/Ly+Oaa64hLCyMFStW0LBhQ2JjYwkICKiegL1DAQgxpbMvTTO9ayrlzLpHOdPRhAkTLtjOfN26dSW29erVi40bN1ZxVGVQVPQm/ndGNtuKlymXOEsUUY26X3ifgCa2n6lHqz6+eko5s+4xm800btxYxbjaLKi5bXmHvDOQdozLmwWzbm8imw4nc89fmjk7unpNObPuqaycqaK3OFVqdvF63iVn6hSv8V3e9sgmk4nIyEjCwsLIz1fBrbZzdXXVVeS1TVHR29+UofbmtYByZt2inCl1gdlson1Df9o39Gf8VS3Izitk18k0dsSlsfNYKr/GpXLkdJb9tvLXEyWO4e5iplfzYPq1CqVf6zCahnjbH5twdQteX3eQj7bGsf7gadYfPE2vZsFMHtCSy/+k+K2cWbcoZ541b9487r33Xntb3oULF/LFF1+wePFiHnvssRLjFy9eTHJyMuvXr7e3F2zatGn1BVxU9A42pWmmdw2mnFm3KGfWIaFtwGSG7GQuO/YeAO/lXsn47PwLdtIhsLjoHVtNQdY/ypl1j5ubm0PHB6mFXNwguAUk7oHEPfSM7gbA5sPJWK0GZq3r7TTKmXVPZeVMFb3FqYpncZ/f2hzOFsLLs6b3uSwWiz6QiTiDRwAA/mSSpqJ3raGcKSI1laebha5Nguja5Gwr8tSsPHYesxXBd8Sl8fvxNLzcLfQtKnL3jA7Cw7X0nNYo0Is5N3dg/FUteP27A3y4NY4Nh06zYdFpekYHMam/re35+V2IzvVnOTMjt4AjSZn4e7oSFeRV8RcvUg3y8vLYtm0b06ZNs28zm80MGDCADRs2lLrPypUr6dWrF+PHj+fzzz8nNDSUO+64g0cffbR6zie8QwAI4gwn0rIxDEOzqGownWeK1DCunhDcEpL24pIWSz4ufFzwFzruT2JIpwal71M80ztFRe+qppwpUsOEtrEVvU/tpv3l/fFys5CWnc+e+DO0beDn7OjqPeVMOZ+K3uJUafaZ3iWL3oH2Nb1VNBOpVYpmeruZCinMySS/0IqrRVe2iohI5QnwcuPKVqFc2Sq0wsdoGODJP2/uwANXteCNdQf4cMsxNh1OZuS/N2EyQQN/T6KCPGkc5GW7BXvbfw/0ciW3wMrR5CwOJWZy5HQmhxMzOXw6k8NJmSSeybU/z19ahnBX76b0ax2GRTMBpAZKSkqisLDQvg5tsfDwcPbs2VPqPocOHeLbb79l5MiRfPnllxw4cIAHHniA/Px8nnrqqVL3yc3NJTf37N9Genp6xYMuKnqHmNLJybeSkpVPkPcFZieKiEhJ4e0gaS8ABwKvJPmkH+v2Jv550VvtzUWkvgmLgV2fQeIeXC1mujUN4od9iWw6fFpFb5EaSEVvcari9X4dit5WK5jN9m1aE1iklnHzxjC7YrLm22Z7Z+cT4uPu7KhERERK1TDAk2du6sAD/Vqw8PuDfLztGJl5hRxPzeZ4ajYbDyWX2MfLzUJ2fiGGceHjBnq5kpqdz4/7k/hxfxJRQZ7ceXkThnWLunDrUJFawmq1EhYWxqJFi7BYLHTt2pXjx4/z/PPPX7DoPXfuXGbNmlU5ARS1Nw+3nIF8OJGaraK3iEh5hLeDPz4BwOhyJ5yE7/clXrhdb3F78/RjUJgPlpKTV0RE6qSwGNvPU7sB6BltK3pvPHSaMX2inRiYiJRGU+8uZutiWH4nHPzO2ZHUWcUFbX/Poi8oPv07zG8PWckORW/jYt8oikjNYjJh8gwAIMCUoQtXRKRaHD9+nL/97W8EBwfj6elJhw4d2Lp1q/1xwzCYMWMGkZGReHp6MmDAAPbv3+9wjOTkZEaOHImfnx8BAQGMHTuWjIyM6n4p4iQNAjyZfWN7fp81kC1PDODj+3vx0vBOPDigFUMva0SPpkFE+HkAkJVnK3j7urvQsZE/f+3UgMn9WzJ/eGc+H9+HX5+6ll9mXMsPD1/FfVc2w9/TlbjkbOZ8uYfL567lsY93suvEJcxyFalEISEhWCwWEhISHLYnJCQQERFR6j6RkZG0atXKoZVgTEwM8fHx5OWV3qlr2rRppKWl2W9xcXEVD9rLNtM71HwGQOt6i4iUV4Mutp/+UbS4fAhebhaSMnLZdfIC5yc+4eDiAYYV0o5VX5wiIs4WWlT0TtwLViuXN7Mtu1W8rreI1Cya6X0R+Uc24rp7JWeC2+Pb/Cpnh1MnObQ3NwzY9TnkZ8HRDQRGDwQgr9BKVl4h3u76z1Wk1vAMhMzEoqK3ligQkaqVkpJCnz59uOqqq/jqq68IDQ1l//79BAYG2sc899xzvPLKK7z77rtER0czffp0Bg4cyK5du/DwsBUyR44cycmTJ1mzZg35+fmMGTOGcePGsWzZMme9NHECk8lEqK87ob7uDuuIF8vJt80C9/d0Jdjb7aLrCEcFeTHtuhimDGjFyl+Ps2R9LLtPpvPBljg+2BJHj6ZBDO8eRYswHyL9PQj2cVcLdKl2bm5udO3albVr13LTTTcBtpnca9euZcKECaXu06dPH5YtW4bVasVstl1Lv2/fPiIjI3FzK33Gtbu7O+7uldT9p2imd4CRBsDJtJzKOa6ISH3R/Gq44SVo1B03N1d6Nw/hm90JrNt7ivYN/UuON5nAPwpO77e1OA/S7EYRqSeCmoHFDfIzIS2ODg2j8HS1kJKVz/5TGbSO8HV2hCJyDlURL+KzOE9uA04d/gOlrqqRmm0rhvl7ukJmoq3gDZDwB16tr8PNYiav0EpKVp6K3iK1SdG63n5kaqa3iFS5Z599lqioKN555x37tujos1/EGYbB/PnzefLJJ7nxxhsBeO+99wgPD+ezzz5jxIgR7N69m1WrVrFlyxa6desGwIIFC7juuut44YUXaNDgAusbSr3j4WqheahPufbxdLMwvHtjhnWLYmtsCkvWH2HV7/FsPpLM5iNn26e7mE2E+3kQ4W+7RRb9Hu7ngbuLGReLCYvZjMVkwmJ2vLmYTTQJ9sLXQ+1GpfymTp3K6NGj6datGz169GD+/PlkZmYyZswYAEaNGkXDhg2ZO3cuAPfffz+vvvoqkydPZuLEiezfv585c+YwadKk6gm4aE1vTyMLd/I001tEpLxMJuh2t/1uv9ahfLM7ge/3JTLh6pal7xPYpKjoHVtNQYqI1AAWFwhuCaf+gMQ9uAU2oWuTQH46kMTGQ6dV9BapYVRFvAj38FaQBpaUg84Opc5KK17T29MVUo6cfSDhd0wmEwFerpw6k0tqVj6NAks/hojUQB4BAASYMknNVtFbRKrWypUrGThwILfddhvff/89DRs25IEHHuDee+8F4PDhw8THxzNgwAD7Pv7+/vTs2ZMNGzYwYsQINmzYQEBAgL3gDTBgwADMZjObNm3i5ptvrvbXJXWPyWSie9MgujcNIj4th2WbYvlhfxLxaTmcOpNDgdWwryVeEe4uZga1j+C2rlH0ah6sWeNSZsOHDycxMZEZM2YQHx9P586dWbVqFeHh4QAcPXrUPqMbICoqiq+//poHH3yQjh070rBhQyZPnsyjjz5aPQF7+IPZFaz5BHGmwn8zIiJi06+1rYPG9qOppGXn2yannC+gaF3vFBW9RaSeCWtjK3qf2gWtBtIzOoifDiSx6fBpRvdu6uzoROQcKnpfREiTdrAPArKPOjuUOiv13PbmDkXvP+zbi4veIlKLFM30DkDtzUWk6h06dIg33niDqVOn8vjjj7NlyxYmTZqEm5sbo0ePJj4+HsBevCkWHh5ufyw+Pp6wsDCHx11cXAgKCrKPOV9ubi65ubn2++npWqNZyi7C34Op17Zm6rWtASgotJKYkUt8Wg7xaTmcTMshPt3281R6DnmFVgqtRsmbYVBQaJBbUEhSRh6f7zjB5ztO0MDfg1sua8TQro2IDvF28quV2mDChAkXbGe+bt26Ett69erFxo0bqziqCzCZbLO9z5wk2JSm9uYiIpeoUaAXLcJ8OHAqg5/2J3F9x8iSgwIa236m6ntSEalnitf1PrUHgMubB8Ma2HQoGcMwLrrklYhULxW9L6JFmw6wBgKMdDJTE/EOCHV2SHVOcTHM39MNjh05+8Dpg5CXRYCXbT24FBXNRGoXzwAA/E1qby4iVc9qtdKtWzfmzJkDQJcuXfj9999ZuHAho0ePrrLnnTt3LrNmzaqy40v94mIxE+nvSaS/Z4X2NwyDncfSWLHtGJ/vOM6JtBxe/e4Ar353gG5NArmtWyOu6xCp9udSdxQVvUNM6ezVTG8RkUvWr1UoB05lsG7vqdKL3oFFM73V3lxE6puwNrafibsB6NjIH3cXM6cz8zhwKoOW4WpxLlJTqOh9EWHBwZwiiDCSObx3J+179nd2SHVOmsNM73NPmg1I3E2gl+1LOc0UFallzpnpfSJbf78iUrUiIyNp27atw7aYmBg+/vhjACIiIgBISEggMvLsF3gJCQl07tzZPubUqVMOxygoKCA5Odm+//mmTZvG1KlT7ffT09OJioq65NcjUhEmk4lOUQF0igrgietjWLv7FB9ti+OHfYlsjU1ha2wKT638g97NQwjydsPf07XEza/oZ6CXK0HebpqxIDWbl21d7yDSSUjPoaDQiovF/Cc7iYjIhfRrHca/fzrM9/sSS5+5qPbmIlJfhbez/Ty1BwrzcXdx5bLGgWw4dJqNh5NV9BapQVT0/hPJHo0Jy0km8cjvoKJ3pTIMwz4D1LG9uQkwIOEPAr06A2imqEhtU1T09jNlkqK/XxGpYn369GHv3r0O2/bt20eTJrYv5qKjo4mIiGDt2rX2Ind6ejqbNm3i/vvvB2xtelNTU9m2bRtdu3YF4Ntvv8VqtdKzZ89Sn9fd3R13d/cqelUiFefhauH6jpFc3zGShPQcPv3lOB9tjeNgYibf7jn15wcAPF0tRAV5EhXoRVRQ0S3Q0/67j7s+SoqTeds6sYVZzmDNh4QzuTQMqFinBBERge7RgXi6Wjh1JpddJ9Np18DfcUBx0TsjHvKzwVU5V0TqiYCm4O4HuemQtA/C23F5s2A2HDrNpkOnufPyJs6OUESK6JuKP1EY2BxO7iAnYb+zQ6lzMvMKKbAaAAR4up0tejfqDsc2Q8IfBHj1AFDRTKS28QgAbDO90/T3KyJV7MEHH6R3797MmTOHYcOGsXnzZhYtWsSiRYsA2wzYKVOm8Mwzz9CyZUuio6OZPn06DRo04KabbgJsM8MHDRrEvffey8KFC8nPz2fChAmMGDGCBg0aOPHViVyacD8P/t63Ofdd2Yxfj6Xx+/E00rLzSc/OJ+28W3pOPmlZ+aTnFJCdX8i+hAz2JWSUetwgbzcCvVzx8XDF190FH3cXfDxsP309zt73dnPBw9WMu6sFDxcLHq5mPFwteLpa8HC13fd0s+DuYqnmd0ZqvaKid5R7FuTDydRsFb1FRC6Bu4uF3s2DWbvnFOv2JpYsensFgZsP5GVA2jEIaemcQEVEqpvZDOHt4eh6OLkTwtvRs1kQAJsOa11vkZpERe8/4dWgNZwEt9RDzg6lziluWe7mYsbDlA/px20PtLn+bNE7Wu3NRWql4vbmpkxS1d5cRKpY9+7d+fTTT5k2bRqzZ88mOjqa+fPnM3LkSPuYRx55hMzMTMaNG0dqaipXXHEFq1atwsPDwz5m6dKlTJgwgf79+2M2mxk6dCivvPKKM16SSKUzmUx0jgqgc1TAn47NLSjkRGoOcclZxKVkcTQ5i2PJ2cSlZBGXnEVKVj7JmXkkZ1be/+PdLGZ70by4YO57TiG9+L6fpyu+Hi74utt+2u8XFd/NZn3ZVG94BwPQwNV2Ycbx1Gy6OTMeEZE6oF/rUNbuOcX3+xIZf1ULxwdNJtts71N/2Fqcq+gtIvVJZEdb0Tv+N+B2OkcF4OZiJvFMLoeSMmke6uPsCEUEFb3/VHh0O9gGEQXHSDyTS6ivWlhWFntrc09XTGnHAANcvaFZP9uAhN8JbGv7TzRFRW+R2qWo6O1PJimZmuktIlXvhhtu4IYbbrjg4yaTidmzZzN79uwLjgkKCmLZsmVVEZ5IreLuYiE6xJvoEO9SHz+Tk8+xlGzSs/PJyC0gI7eA9JwCMnIKyMjNJyOngDO5BZzJKSAnv5DsvEJyCgrJybeSk19YdLOSnV9IYVHnp7xCa6UU0t1czLhZzLhYTLhazLiaTbi6mHExF923mHG1mFg0qhshPvpsV6sVzfQON58B4GRajjOjERGpE/q1DgP+YFtsCuk5+fh5uDoOCGhsK3qnHnFGeCIizhPRwfYzfidgW1Kqc1QAmw8ns+lQsoreIjWEit5/wiuiDQDRpng2xKXQv22EkyOqO9KyS1nPO7AphLYBkwWyUwg3pwJqby5S63gGAOBvyrD/rYuIiEjd4OvhSkyk658PLIP8QitZeYVkFhXPz+TYfhYX0Ivvn8kp4ExOftFP2+/p5/zMK7ACkFdgtf9+MYZRKeGLMxUVvQNJB+BEarYzoxERqROigrxoFurNocRMft6fxOAOkY4DAovWrU09Wv3BiYg4U0RH28/4nbYPEyYTlzcLthW9D5/mjp6NnRufiAAqev+5wCYUYsHLlMvBQwdU9K5EZ2d6u0HKPtvGwKbg6mFrkZS4h8jsg4C7imYitU3RTG8/UzbZObnkF1pxtZidHJSIiIjUNK4WM/6eZvw9L62InltQyJmcAnILrBQUWskvtJJfaBT9PPt7QaFBXqEVP099FK71vEIA8C1MBeBEqmZ6i4hUhn6twjiUeJh1exNLFr0DioreKbHVH5iIiDOFtgGzK+Sk2S78CWzC5dFBvAJsPHRa63qL1BAVqkDExcVx7Ngx+/3NmzczZcoUFi1aVO5jvfbaazRt2hQPDw969uzJ5s2bLzo+NTWV8ePHExkZibu7O61ateLLL78s9/OWmcWVTK+GAJw+uqvqnqceKl7n19/LFVKLTpYDm9p+hrcDICjTVgxXe3OpKSoz/9VpHv72X/3ItF/kIiJyPuVVEakM7i4WQnzcaRjgSZNgb1qE+RIT6UfHRgF0bRLE5c2C+UvLUK5qE8bAdhG4u1icHXKlqNc51NtW9PbMTwY001tE/ly9zpnl0K+1rZPG9/sSMc5vjWKf6a2it0hdp5x5Hhc3CLN1Bbat6w1dGgfiajGRkJ5L7OksJwYnIsUqVPS+4447+O677wCIj4/nmmuuYfPmzTzxxBMXXSfxfMuXL2fq1Kk89dRTbN++nU6dOjFw4EBOnTpV6vi8vDyuueYajhw5wooVK9i7dy9vvfUWDRs2rMjLKLvgFgAUJO4vebInFXbumt4O7c3BXvT2Td0L2FqhF6/3J+JMlZX/6jyLK7j5AhBgyiQtWxeuiEjplFdFRCquXufQoqK3pTAHT3I4maait4hcXL3OmeXQIzoID1cz8ek57Ik/4/hgQFH7XrU3F6nzlDNLcW6Lc8DTzbauN8Cmw6edFJSInKtCRe/ff/+dHj16APDhhx/Svn171q9fz9KlS1myZEmZjzNv3jzuvfdexowZQ9u2bVm4cCFeXl4sXry41PGLFy8mOTmZzz77jD59+tC0aVP69u1Lp06dKvIyysy7ge0Knoj8YxxN1hU7laX0Nb2LrhgNbw+A2+ndgG2ZjHS1OJcaoLLyX71Q1OLcn0xSNNNbRC5AeVVEpOLqdQ518wEXDwCCTemkZOWTnVfo5KBEpCar1zmzHDxcLfRqFgzYZns7KG5vnnUacjOqOTIRqU6VnTPL0/F3yZIlmEwmh5uHh0dFX0rlsRe9f7Nv6hlty5cbDyU7IyIROU+Fit75+fm4u7sD8M033/DXv/4VgDZt2nDy5MkyHSMvL49t27YxYMCAs8GYzQwYMIANGzaUus/KlSvp1asX48ePJzw8nPbt2zNnzhwKC6v2g60lxDbTO9p0kh1xqVX6XPVJalHLcttM79Lbm5tP7yfQ3TbDO1VFb6kBKiP/1RuethbnAaYMtTcXkQtSXhURqbh6nUNNJvC2teCNcssE4IRme4vIRdTrnFlO/VqHAbBu73ndOD387Be4q8W5SN1WmTmzvB1/Afz8/Dh58qT9FhtbA3JORAfbz5M77Zt6NgsCYFPRut4i4lwVKnq3a9eOhQsX8uOPP7JmzRoGDRoEwIkTJwgODi7TMZKSkigsLCQ8PNxhe3h4OPHx8aXuc+jQIVasWEFhYSFffvkl06dP58UXX+SZZ5654PPk5uaSnp7ucCu34OKidzw7j6WVf38pVXERLNQlC3KL/l2K2yT5NbStCWwtoJNHAqB1vaVmqIz8V2/YZ3pn2C9yERE5n/KqiEjF1fsc6mV7jS28cwCt6y0iF1fvc2Y5FK/rvfVICmdyzruIXS3OReqFysyZ5e34C2AymYiIiLDfzq8jOUWErTst6ccgyzazu2uTQFzMJk6k5XAsReeiIs5WoaL3s88+y5tvvkm/fv24/fbb7e3FV65caW95URWsVithYWEsWrSIrl27Mnz4cJ544gkWLlx4wX3mzp2Lv7+//RYVFVX+Jy4qejc2neL3o0kVDV/OUzxzO9JadJGDbyS4etp+N5nsLc47uB6zjVfRTGoAZ+W/Wqm46G3K1ExvEbkg5VURkYqr9zm0aKZ3Ew/bMmQnU3OcGY2I1HD1PmeWQ5Ngb6JDvCmwGvx84Lx1aotbnKfUgFmXIlJlKitnVqTjL0BGRgZNmjQhKiqKG2+8kT/++KPiL6ayePif7VRbtK63l5sLHRvZul1uOKR1vUWczaUiO/Xr14+kpCTS09MJDAy0bx83bhxeXl5lOkZISAgWi4WEhASH7QkJCURERJS6T2RkJK6urlgsFvu2mJgY4uPjycvLw83NrcQ+06ZNY+rUqfb76enp5S98+0ZidfHEtSCb1JMHyC+8AldLha4XkHOkFc/0zi9qh1L8P4xi4e0g9mfamI4C3UjJVNFMnK8y8l+94REAQACZpGbrohURKZ3yqohIxdX7HFpU9G7kZltX9rhmeovIRdT7nFlOfVuFcjgpk+/3nWJQ+3O+qw0sKnqrvblInVZZOfNiHX/37NlT6j6tW7dm8eLFdOzYkbS0NF544QV69+7NH3/8QaNGjUqMz83NJTc3136/Qt1+yyqiI6Qcsa3r3awfAD2bBbP9aCqbDiUzrFsFJl2KSKWpUOU2Ozub3Nxce7KLjY1l/vz57N27l7CwsDIdw83Nja5du7J27Vr7NqvVytq1a+nVq1ep+/Tp04cDBw5gtVrt2/bt20dkZGSpBW8Ad3d3/Pz8HG7lZjZjCm4OQIPCE+xLOFP+Y0gJxUWwgLwTtg2lFb2BZoW2k2i1N5eaoDLyX71RNNNba3qLyMUor4qIVFy9z6Hettaa4RZb0fuk1vQWkYuo9zmznPoWtThftzfRcZ3a4pneam8uUqc5M2f26tWLUaNG0blzZ/r27csnn3xCaGgob775ZqnjK6Xbb1lFdLT9PGdd78ub2c5JNx3WTG8RZ6tQ0fvGG2/kvffeAyA1NZWePXvy4osvctNNN/HGG2+U+ThTp07lrbfe4t1332X37t3cf//9ZGZmMmbMGABGjRrFtGnT7OPvv/9+kpOTmTx5Mvv27eOLL75gzpw5jB8/viIvo1xMRS3Om5lO8muc1vWuDMVFMJ8sW/ty+0lzsaL25o3yDgGQlq2imThfZeW/c/3rX//CZDIxZcoU+7acnBzGjx9PcHAwPj4+DB06tERnjKNHj3L99dfj5eVFWFgYDz/8MAUFBQ5j1q1bx2WXXYa7uzstWrRgyZIlFYqxQjwDALU3F5GLq4q8KiJSX9T7HFo00zsI22yeE2pvLiIXUe9zZjn1ahaMp6uFk2k5bDyUfPYBtTcXqRcqK2dWpOPv+VxdXenSpQsHDhwo9fFp06aRlpZmv8XFxZU5vnKLLCp6x/9m39S1SSAWs4ljKdkcS8mquucWkT9VoaL39u3b+ctf/gLAihUrCA8PJzY2lvfee49XXnmlzMcZPnw4L7zwAjNmzKBz587s2LGDVatW2VtdHD16lJMnT9rHR0VF8fXXX7NlyxY6duzIpEmTmDx5Mo899lhFXkb5FBW9o00n+TUuteqfr47LyS8kt8A2Y98jo+h/QufP9A5tA5jwLThNMGma6S01QmXlv2JbtmzhzTffpGPHjg7bH3zwQf773//y0Ucf8f3333PixAluueUW++OFhYVcf/315OXlsX79et59912WLFnCjBkz7GMOHz7M9ddfz1VXXcWOHTuYMmUK99xzD19//XUFX305Fa/pTYbam4vIBVV2XhURqU/qfQ4tKnr7WVMBOKH25iJyEfU+Z5aTh6uFoV0bAvD2T4fPPnBue/NzZ4CLSJ1SWTmzIh1/z1dYWMhvv/1GZGRkqY9XSrffsoroYPuZtA/ybeeePu4utG9oW9d707kXCYlItatQ0TsrKwtfX18AVq9ezS233ILZbObyyy8nNrZ8V/lNmDCB2NhYcnNz2bRpEz179rQ/tm7duhKzEnv16sXGjRvJycnh4MGDPP744w5rfFcZe9E7nl+PpVb989VxxbO2LWYTlrSi/2bOL3q7+0BQNACtzXGkaKao1ACVmf8yMjIYOXIkb731lsPaOGlpabz99tvMmzePq6++mq5du/LOO++wfv16Nm7caH/uXbt28Z///IfOnTszePBgnn76aV577TXy8mwF5oULFxIdHc2LL75ITEwMEyZM4NZbb+Wll16qpHfjTxQXvTXTW0QuojLzqohIfVPvc6hXiO1HQQoAJ9KyHVvwioico97nzAoY08f2vdzaPQkcTsq0bfQvahucmw7ZKU6KTESqWmXmzPJ2/J09ezarV6/m0KFDbN++nb/97W/ExsZyzz33VN4LrCjfSNs5qFEIp3bZN1/eLAhQi3MRZ6tQ0btFixZ89tlnxMXF8fXXX3PttdcCcOrUqaq9isaZiove5pPsSzhDVl7Bn+wgF1NcAAv2MGFKK2pvfn7RG+zreseYjpKqmd5SA1Rm/hs/fjzXX389AwYMcNi+bds28vPzHba3adOGxo0bs2HDBgA2bNhAhw4d7J0xAAYOHEh6ejp//PGHfcz5xx44cKD9GKXJzc0lPT3d4VZhHgEABKCit4hcWL08rxQRqST1Pod624rebjm2Lxdz8q26WFpELqje58wKaB7qw9VtwjAMeOfnotnebl7gXbSer9b1FqmzKjNnlrfjb0pKCvfeey8xMTFcd911pKens379etq2bVt5L7CiTKazs73PXdc72rau90bN9BZxqgoVvWfMmMFDDz1E06ZN6dGjh70NxerVq+nSpUulBlhjBDcHoIEpGXcjh9+PX0IhSOwF7JYeabarolw8wCe85MCidb3bmI6qaCY1QmXlvw8++IDt27czd+7cEo/Fx8fj5uZGQECAw/bw8HDi4+PtY84teBc/XvzYxcakp6eTnV1668e5c+fi7+9vv0VFRZX5NZVQNNM7wJShi1ZE5ILq5XmliEglqfc5tKi9uSnrNCHeboBanIvIhdX7nFlBY6+wzfb+aOsx0oq/mzu3xbmI1EmVnTPL0/H3pZdeso+Nj4/niy++qFl5upR1vbs1ta3rfTQ5i7W7Ey6wo4hUtQoVvW+99VaOHj3K1q1bHdaG7d+/f/W1za1uXkHgaWtR0dSUoHW9L1FqUXvzFm5Jtg0BTcBcyn+ORTO925hV9JaaoTLyX1xcHJMnT2bp0qV4eHhUVagVMm3aNNLS0uy3uLi4ih+sqOjtRyaZeQXkFVgrKUoRqUvq5XmliEglqfc5tGimN4V5tPC3nWuq6C0iF1LZOfO1116jadOmeHh40LNnTzZv3nzBsUuWLMFkMjncatr3ARfSu3kwbSJ8yc4v5P0tRTO7Axrbfqao6C1SV9X788yLiSguep+d6e3r4cqdl9suCJr64a/EJWc5IzKReq9CRW+AiIgIunTpwokTJzh2zNaeukePHrRp06bSgqtx7Ot6n2SH1vW+JMVXhkabE20bSmttDvaidyvTcdKz9OWF1AyXmv+2bdvG/7N33+FRVekDx79T03uFNDoB6T2CKIKgYkGxF7Cv/sBVsbKr7qprWXXt2MXeuwIWREB6L6Ek1JDee5/M3N8fZzJJIKTOkEDez/PcZ2bu3HvnzNV7cpn3vO/Jzs5mxIgRGI1GjEYjK1eu5JVXXsFoNBIWFkZ1dTWFhYUN9svKyiI8PNzRhqysrGPer32vqW18fX3x8PBotG1ubm74+vo2WNrMw18dU1eDB1UUVki2txCicV3yvlIIIZykS/ehJg8wewPQz6sSgIyiyo5skRCik3NWn/nll18yb948/vWvf7F161aGDh3KtGnTyM7OPu4+vr6+ZGRkOJaTZR5xnU7nyPb+cG0SFqtNJa+AlDd3tvJ8ePssWPZ4R7dECKCL32c2pTbonbUbbFbH6vnnxzI0yp+iCgtzPttKVY31OAcQQrhKm4LeNpuNxx9/HD8/P2JiYoiJicHf358nnngCm+0UzuRzBL0zJdO7nWqDX5G62qB3TOMb+vdAM3nhprMQakmTPxSiwzmj/5s8eTLx8fFs377dsYwaNYprr73W8dxkMrFs2TLHPomJiSQnJztKCcXFxREfH9/gH9RLly7F19fXMb9NXFxcg2PUblN7DJcze4PeCKh5vYukWoMQohFd9r5SCCGcQPpQHNnePTzVIGnJ9BZCHI8z+8wXXniBW2+9lRtvvJGBAwfy5ptv4unpycKFC4+7j06nIzw83LEcPR1ZZ3bRsO4Ee7uRUVTJL7sypby5qyQshvRtsPolKMns6NaILk7uM5sQ1BtMnmAph7yDjtVuRgMLrhmOv6eJnalF/GfR3g5spBBdk7EtO/3zn//kvffe45lnnmH8+PEArF69mn//+99UVlby5JNPOrWRnYZ9Xu9e+gxSCyrIK60iyNutgxt1cqotVR5utd/AHS/TW6+H0IGQtokB9nm9w3wNJ6aRQjTCGf2fj48PgwYNarDOy8uLoKAgx/qbb76ZefPmERgYiK+vL3feeSdxcXGMGzcOgKlTpzJw4ECuv/56nn32WTIzM3n44YeZM2cObm6qX7r99tt57bXXeOCBB7jpppv4888/+eqrr1i8eLEzT8nx6XTg7g/lufjpyhzTGgghRH1d9r5SCCGcQPpQwDMYCpKIcisDfEiXTG8hxHE4q8+srq5my5YtzJ8/37FOr9czZcoU1q1bd9z9SktLiYmJwWazMWLECJ566ilOO+20RretqqqiqqrK8bq4uLhFbXMVN6OB68fF8OIf+3hv9WEuPDcGHUh5c2dLWqUeNSts+wQm3tex7RFdmtxnNkFvUBVqUzepEuch/RxvRQZ48uKVw7jx/U18vP4Io3oEcPGwiA5srBBdS5uC3h9++CHvvvsuF110kWPdkCFDiIiI4P/+7/9O3Q7PHvQeYMoGC+xMLWJSbGgHN+rkVBv8Cq5JVyuOF/QGdOGnQdomx7zeYb4nx5xH4tR0ovq/F198Eb1ez8yZM6mqqmLatGm8/vrrjvcNBgOLFi3ijjvuIC4uDi8vL2bPns3jj9eVwOrZsyeLFy/mnnvu4eWXXyYyMpJ3332XadOmOaWNLeIRAOW5+OtKKSiT8uZCiGN12ftKIYRwAulDAa8QALoZSoBwtqcUUGmx4m6SwdJCiIac1Wfm5uZitVqPydQOCwsjISGh0X369+/PwoULGTJkCEVFRTz//POcfvrp7N69m8jIyGO2f/rpp3nsscda8e1c79px0SxYcYAdKYXsLu/GIFDlzTVNDXoX7aNpkLS67vXWj2DCPJUQJEQHkPvMZoQPrgt6D76swVuT+ocyd1IfXlt+gPnfxXNad1/6hPp0UEOF6FraFPTOz89vdN6G2NhY8vPz292oTste3jxGlwHA9pRCCXq3UW2ZY/+q5oPehKnM11hdMgXlEjQTHctV/d+KFSsavHZ3d2fBggUsWLDguPvExMSwZMmSJo971llnsW3btja3q908AgDwQzK9hRCN67L3lUII4QTSh+Iob97Hu4oQHzdS8it4/rdEHr5gYAc3TAjR2XRknxkXF9dgqrHTTz+dAQMG8NZbb/HEE08cs/38+fOZN2+e43VxcTFRUVEubWNzgr3duGRYBF9uTuHN7dW8hg5qKqAsB7zl99F2KzgMxWmgN4HJQ5WOP7wSek/q6JaJLkruM5tRO693Znyjb99zTj+2Jhew9mAet3+ylR/njMfLrU3hOCFEK7RpqNjQoUN57bXXjln/2muvMWTIkHY3qtMK7AWAl7UYf0rYkVrYse05iRVWVONLGe6WIrXC/zhzeoMqFQLE6lMolKC36GBdtv9rKw9/APx0pXL9CiEaJf2qEEK0nfShOILe7tX5/HfmYADeW3OY9YfyOrJVQohOyFl9ZnBwMAaDgaysrAbrs7KyCA8Pb9ExTCYTw4cP58CBA42+7+bmhq+vb4OlM7hpQk8AluzJo8a7m1opJc6dozbLO3IUDLlCPd/yQYc1Rwi5z2xGbdA7Y6eq1HAUg17Hy1cNJ9THjQPZpfzz+3i0RrYTQjhXm4aWPPvss0yfPp0//vjDMUpx3bp1pKSkNJt1eFIze4FvBBSn0VOXyY6UQDRNQyclfFqtsNxClC5HvfAKATfv428cqkboR+pyWV+UB3RzfQOFOI4u2/+1lT3T259SCssl01sIcSzpV4UQou2kD8VR3pyyHM6ODePKUVF8uTmF+77ewa93T8RbMmqEEHbO6jPNZjMjR45k2bJlzJgxAwCbzcayZcuYO3dui45htVqJj4/n/PPPb/X36Ej9w304o28wq/bnkkYoMaSrjOSo0R3dtJNfbdC7xwQYeDFsehcSFkNZrmOAlxAnktxnNiNsIOj0UJ4LJZnge2zMIsTHjdeuGcHV76znh+3pjO4ZyLVjm0j+E0K0W5syvc8880z27dvHJZdcQmFhIYWFhVx66aXs3r2bjz/+2Nlt7Fzs83r3MWRSUG4htaCigxt0clJB72z1oqnS5gAe/uSb1DxJxpw9rm2YEM3o0v1fW9SWN9dJeXMhRONc0a8+88wz6HQ67r77bse6yspK5syZQ1BQEN7e3sycOfOY7Jzk5GSmT5+Op6cnoaGh3H///dTU1LTn6wkhhEvJvSngaQ8ElOUC8PAFA4jw9yC1oIInF8u/H4UQdZzZZ86bN4933nmHDz/8kL1793LHHXdQVlbGjTfeCMCsWbOYP3++Y/vHH3+c33//nUOHDrF161auu+46jhw5wi233OLU73gi1GZ7by+xZ58XSqZ3u9Wfz7vHBDVXcPcRYLPA9s86tm2iy5L7zGaYPCC4n3qeufO4m43pGcgD0/oD8NhPe4hPLToRrROiy2rzkOfu3bvz5JNPNli3Y8cO3nvvPd5+++12N6zTCuoDh/9itE8+Xxeoeb2jAj07ulUnnaKKekHvpkqb2+V69iGwKAvPggQXt0yI5nXZ/q8t3P0B8KeM3VLeXAhxHM7sVzdt2sRbb711TLm1e+65h8WLF/P111/j5+fH3LlzufTSS1mzZg2gsm2mT59OeHg4a9euJSMjg1mzZmEymXjqqafa9wWFEMKFuvy9qVfDoLePu4n/XTGUq99Zz+cbUzhnYBhnx4Z1YAOFEJ2Js/rMK6+8kpycHB599FEyMzMZNmwYv/76K2Fhqr9JTk5Gr6/LNSooKODWW28lMzOTgIAARo4cydq1axk4cKBzvtgJdGbfEHqHeHG4IFj9sizlzduv/nzekWPUupGzIX0rbP0ITr8TpNKo6ABd/j6zOeFDICdBBb37TTvuZrdN7MXmIwUs3ZPFHZ9uYfGdZ+DnaTqBDRWi62hTpneXFtQHgIFuqjT3jpTCDmzMyclitVFaVUN0SzO9gWJfNWrKr3ifC1smhHA6R6a3lDcXQrheaWkp1157Le+88w4BAQGO9UVFRbz33nu88MILnH322YwcOZL333+ftWvXsn79egB+//139uzZwyeffMKwYcM477zzeOKJJ1iwYAHV1TJoRwghOq165c1rjesVxE3jVSbig9/GU1Am/bgQwvnmzp3LkSNHqKqqYsOGDYwdO9bx3ooVK/jggw8cr1988UXHtpmZmSxevJjhw4d3QKvbT6/XcdOEnqRqqv/VCpM7uEWngPrzeZvtyVWDZoLJC/L2w5G1Hdc2IcTxhQ9WjxnHz/QG0Ol0PH/5UKICVTWie7/ejs0m83sL4QoS9G4te9A70pYGwI7Uwg5szMmpyF7iuDVB74rAAQCElB9wVbOEEK7g4Q+AH2US9BZCuNycOXOYPn06U6ZMabB+y5YtWCyWButjY2OJjo5m3bp1gJqbbPDgwY7sHIBp06ZRXFzM7t27G/28qqoqiouLGyxCCCFOsNpM7/I8sNkcq++f1p8+od7klFTxyI+7OqhxQghxarp0eCSFZjV/bXn2oQ5uzSng8Cr12GNC3To3Hxg8Uz3f8sEJb5IQogW62SvMZcY3u6mfh4k3rh2J2ajnj73ZfLM11cWNE6JrkqB3a9mD3r7lyeiwEZ9WRI3V1sxOor7awFeMwT4SvwVBb1vIaQB0rz7U4IcMIUQnZ8/09teVUijlzYUQLvTFF1+wdetWnn766WPey8zMxGw24+/v32B9WFgYmZmZjm3qB7xr3699rzFPP/00fn5+jiUqKsoJ30QIIUSr1M7prVmhstCx2t1k4IUrhmLQ61i0M4OfdqR3TPuEEOIU5GE2MHr4CADcStPAZu3gFp3Ejp7Pu76RN6jHPT9Cef4JbZYQogXC7UHvgsNQ2fxc3YMi/Jh3jqpo+/If+6mukTiHEM7Wqjm9L7300ibfLywsbE9bTg7+0aA3oq+poJdbCQer/NiXVcrA7r4d3bKTRlFFNXpsRNDyoLcxtA9Vmgl3qtQfkaDerm2kEEeR/q+NasubU0ZhhWR6CyHqOLNfTUlJ4a677mLp0qW4u7u3s2UtN3/+fObNm+d4XVxcLIFvIcQJIfem9RjN4O6nfmgsywXPQMdbQyL9mTupDy8v288jP+xibM9AwnxP3N8JIUTnIH2ma1wycRSWLQZMuhr2JCYycMDJNz95p5B/CErSwWCum8+7VvcREDYYsuJh51cw7vaOaaPoUqTPbAXPQPCNhOJUyNoNMac3u8vsuB4sXH2YtMIKvtycwvXjYk5AQ4XoOloV9Pbz82v2/VmzZrWrQZ2ewaSCtHkHmBRSzMFUP3amFkrQuxUKyy2Ek4+JGtCbwLd7s/v4e3uwT4tgsC5J/QGRoLc4waT/ayN3fwD8dWWUV1mpqrHiZjR0bJuEEJ2CM/vVLVu2kJ2dzYgRIxzrrFYrf/31F6+99hq//fYb1dXVFBYWNsj2zsrKIjw8HIDw8HA2btzY4LhZWVmO9xrj5uaGm5tbi9oohBDOJPemR/EMtge9cyCkX4O35p7dhz8TsolPK+LBb3fy/g2j0el0HdRQIURHkD7TNUL9vcg1hxFsSef3tZsk6N1WtVneEfXm866l08HI2bDkPtj6IYz9m1onhAtJn9lK4YNV0DtjZ4uC3h5mA3Mm9eFfP+1mwZ8HuHxkJO6mrvVb6S/xGfy+J4t/X3Qafh6mjm6OOMW0Kuj9/vvvu6odJ5egPpB3gNE++bxLFDtSC7lqTHRHt+qkUVhuIVpvn8/bPwr0zXfqAZ5m1tiiGaxPQsvahW7gRc5pzLrX1UCGMbc653jilCX9XxvZM719deXosVFUbiHUt2vdyAkhGufMfnXy5MnExzecQ+vGG28kNjaWBx98kKioKEwmE8uWLWPmTDUvXmJiIsnJycTFxQEQFxfHk08+SXZ2NqGhoQAsXboUX19fBg6UH/CEEJ2L3JsexSsE8g+qoPdRTAY9L1wxlOmvrmZFYg5fbErhavn3uxBdivSZruMe0hPS00k9vJeMogq6+Xl0dJNOPscrbV5r8OXw+yOQvQdSN0HUmMa3E8JJpM9spW5DYN8vLZrXu9ZVY6J4a+VB0osq+WxDMjdN6OnCBnYumqbxxKI9pBdVEhXo6Sj3LoSztCroLezs83r3N6rsn+0pzc/XIOoUVliI0tmD3i0obQ4q6J2gqR8majJ24ZTxPxk74bf56nnvsyV7XAhX8PB3PPW1lzgPlZKSQggn8/HxYdCgQQ3WeXl5ERQU5Fh/8803M2/ePAIDA/H19eXOO+8kLi6OcePGATB16lQGDhzI9ddfz7PPPktmZiYPP/wwc+bMkWxuIYTo7Lzs83qX5zb6dt8wH+6f2p8nl+zliUV7GN87mOggz0a3FUII0XLeYb0gfQ0RWjbv/HWYRy+UwaKt0tR83rU8/OG0GbDjc9jyoQS9hehswgerx8wdLd7FzWjgzsl9mf9dPK+vOMBVY6LwNHeNUN3h3DLSiyoB+GzDEeZM6t32qqCapqpg5O6HmkqwVNQtNRUNX4f0h8s/UAmQ4pSm7+gGnJTswdHwmlQA9mWVUF5d05EtOqkUlVe3OujtYTZwQG+f3yJrt3Masv3Tuue7vjvuZlabRqXF6pzPFKKrMZjA7A2Av66UwnKZ11sI0TFefPFFLrjgAmbOnMnEiRMJDw/nu+/q/v4bDAYWLVqEwWAgLi6O6667jlmzZvH44493YKuFEEK0SG3Qu6zxoDfATRN6MqZnIOXVVu79ejsWq+0ENU4IIU5hAeq3ukhdDp9uOEJ2SWUHN+gk02A+79HH327kDepx93dQWXxCmiaEaKHwIeoxOwFqqlu822UjI4kO9CS3tJqP1h1xUeM6nzUH6u7Xc0ur+XlHRtsPtu83+PkuWPcabHpXxXt2f6cy7w+tgJQNkLkT8vZDwiI4tLL9X0B0ehL0bgt7prdb0WFCfdyw2jR2p8sNR0sVVliIbmXQGyDTXQ02MBUlQVVp+xpRUw07v6p7vfv4Qe9HftzF0Md+52BOOz9TiK7KXuLcnzIKylt+8yeEEO2xYsUKXnrpJcdrd3d3FixYQH5+PmVlZXz33XfHzNUdExPDkiVLKC8vJycnh+effx6jsWuMthZCiJOaV4h6bKS8eS2DXsf/Lh+Kl9nApqQCHvx2J5qmnaAGCiHEKcq/BwADPAqoqrHx7qrDHduek01T83nXFzUWgvuDpRzivz4xbRNCtIx/NLj7gc0COQkt3s1k0HPX5L4AvLXyICWVXSNRaNV+FfTu7qcqgb6/5nDb78k3L1SPPSfCmQ/C5H/Buf+FC1+GS9+BKz+Ba7+FgTPUdgmL2tl6cTKQoHdb2IPeuoIkRkSqDMYdKYUd2KCTS1Ebg946rxCyNX/1Intv+xqx71eoyFc/jhjMal6crD3HbFZVY+X7rWlU1dhYnpDdvs8Uoqty9wfAT1dGkWR6CyGEEEIIZ3MEvY+f6Q0QFejJa9eOwKDX8d3WNJ7/PfEENE4IIU5h9kzvPqY8AD5ed4S80qqObNHJJWmVejxeafNaOh2MnK2eb/nApU0SQrSSTleX7d2Keb0BZgyPoFeIFwXlFt5fk+T8tnUyNVYb6w6pvxdPXToYd5Oe3enFbEoqaP3BCpNh/+/q+QUvwaR/wBnzYNztqjrGkCtgwIXQdwqMmKW2S1wCNqn2dKqToHdb+HQDkydoViYElwGwKSm/gxt18igsb/2c3gD+niYSbFHqRdau9jVi+2fqcdg10GeKet5Itve25EIq7KXNd6TK3O1CtIl9Xm8/SimskExvIYQQQgjhZJ5B6rGZoDfApP6hPH2JmntxwfKDfLK+65STFEIIp/OPBsCtIpNh3b2osFh5b7Vke7dIS+bzrm/IVSpxJ3MnpG9zbduEEK3jmNd7Z6t2M+h13D2lHwDvrDp0yicLxacVUVJZg6+7kTP6hnDJ8AhAZXu32pYPAQ16numYjvi4epwBbr5QmgVpm1v/WeKkIkHvttDpHBfSGQGFACzdk8Xh3LIObNTJo7K8mBCdvRx8K4LeAZ5m9mrqZrpd83qXZNWNAhp2LQyaqZ7v+lbdcNazen/djybxqYVt/0whujJ7eXM/XRkFp/jNmxBCCCGE6AAtKG9e3xWjo7h7iion+eiPu/h9d6arWiaEEKc27zAwuqPTbNw3zguAD9cmUShTmzUv/xCUZKhAdtSY5rf3CoIBF6nnWz50bduEEK3TxkxvgAsGd6N/mA8llTW8u/qQkxvWudTGWk7vHYxBr+OG03sC8NvuTFILylt+IKsFtn2sno+6qfntjWboO1U9lxLnpzwJereVvcR5DBmcHRuKTYNXlu3v4EadHDzLUgCoMfup+S5aSGV6OyHoHf8VaFY1X05If+h3Lhg91M1mxvYGm64+UBf0TsorP+VHWwnhEvZMb39KKZRrSAghhBBCOFtt0Lu8+UzvWndN7stVo6OwafD3L7axNbleWcXlT8H/YiH3gJMbKoQQpxidzpHtPT6whAHdfCmrtrJQsr2bV1vaPHI0mDxatk9tifP4b6Cq1DXtEkK0niPTO77V5bP1eh33nKOyvReuPkx+2ak7aKg21jK+bzAA/cN9GN8nCJumpsdoscQlKmvbOwxip7dsn9rt9i46JvFRnFok6N1W9qA3eQe4x16C4sftaRzMkRuO5vhWpgNQ4xfTqv38Pc0k1M/0bkvnpGmw7VP1fPi16tHNG/pNU8931ZU4Lyq3sNOe3e3vaQJUCQ4hRCvZM739dWUy2lsIIYQQQjifl/rhjPJ8sNa0aBedTsd/ZgxiUv8QKi02bv5gE4dySqEgCVb9T2XfbfvIdW0WQohTRehAAHS//5N5E9QgpPfXJlFUIYPem9Sa0ua1epwBgb2guqTRaRqFEB0kpL+q2lBVDIVJrd592mlhDIpQg4beWnnQ+e3rBMqqahyDTM/oE+xYf6M92/vzjcmUV7fsPp7NC9Xj8OvAYGrZPn2mqP9G+Qchd1+L2y1OPhL0bqt6Qe/BkX5MGRAm2d4tYLNpBFky1ItWlDYHCPA0cVDrjhUDVBVBUWrrG5C+FXL2gtEdTru0bn1tifPd3ztGY607lItNg94hXpzRV92075AS50K0Xr3y5pLpLYQQQgghnM4jENABGlTkt3g3o0HPa9eMYEikHwXlFma/v5GKP58Dm/0HN8kEEUKI5p3zGHiHQ/Yepmy/i8GhJkoqa/hwbVJHt6zzau183rV0OhgxSz3f8oH8jRKiszCYIHSAet6GEuc6nY57z+kPwIfrksguqXRm6zqFjUn5WKwaEf4exAR5OtafHRtKTJAnxZU1fLc1rfkD5R2EQysAHYyY3fIGuPuq+b9BSpyf4iTo3VaOoLcaeVM7H9hPO9I5kF3SUa3q9Eoqa4giGwBjcM9W7evvaaYaE+mmKLWiLSXOt3+mHmMvcJRcBqDvOWD2gaIUSN0E1JXbOKNvCEMiVBn2+FTJ9Bai1dz9AfCjlEIZ6S2EEEIIIZzNYHQMtKSs5SXOAbzcjCy8YTQxQZ5oBcmY4j9Xb+j0KhMkJ9HJjRVCiFNMQA+4/jtw90OXsp53PV7FSA3vrT5MSWUn/g2gMBl++D/44zEVgK45gZXp6s/nHTm6dfsOuxb0RkjbAovvBZvVNW0UQrRO7bzeGTvbtPtZ/UMYHu1PpcXGGytOvWzv2vm8z+gbjE6nc6zX63XMjusBwAdrk9CaG8yz5X312PccCGhdJWFHifOExa3bT5xUJOjdVoG91GNJOlSVMijCj6kDw9A0eOkPyfY+nsKKaqJ19qB3YCuD3h6qVMVBvX2/PT+27sMtlRD/tXpeW9q8lsmjrtPb9S1Q1xGP7xPM4EgV9N4pmd5CtF6DTG8pby6EEEIIIVygdl7vspxW7xrs7caHN45hnvvPGLGyy30Ett6T1ZuSCSKEEM0LOw2u+QqMHoRl/cUb3gsprqjio9bM0XoiJa2Bt8+C7Z/C6hfgg+nwbE/47CrY+I5KcnJlFnVb5vOu5R0K5/0X0MHm9+DL66G63OlNFEK0Um3Quw2Z3tAw2/vT9clkFFU4q2WdwpoDdbGWo10+KhJvNyMHsktZtb+JAaw1VXVT1468sfWN6H8+oFODhorTW7+/OClI0LutPAPBM0g9zz8EwN32ub0Xx2ewL0uyvRtTWG5xBL1bXd7cywzA17qpasWOz+ylLFoocQlUFoFvRF0pi/oG2cud7/mBlNwSkvLKMeh1jOsVyKAIP3Q6SC+qJKekqlXtFqLLs1dV8KdUypsLIYQQQgjXaEfQG6CHIZdLWAHAv4su4Nvy4eoNyQQRQoiWiR4HV3wIOgPn1KzgYeOnvLfqEGVVLZyj9UTZ9C58dBGU50H4YBh8ufqNt7oU9v0CS+6DV0fAy0Nh0T2w92eoKnVuGw7bg96tKW1e3+hb4PIPwOAGiYvV9ynLc1rzhBBt0M0e9E7fqgKzm96DdQtg1f/gzyfh90dgyQPw053wy0NQUXjMIcb3CWJsz0CqrTZe+/PAiW2/C2WXVJKQqeJljQW9fdxNXDYyEoD31xw+/oH2/KSmMvKNgL5TW98Qn7C66hqJS1q/vzgpSNC7PQJ7q8c81QEN7O7LeYPC0TR4WbK9G1VYXkVUW4PenirTe1Vlbxh9q1r509+huqxlB9huHwU09GrQG459v9ckVYa5NIv9m34DYFiUPz7uJrzdjPQO8QYgPq2wVe0WosuzZ3r768qosFiptEjpLSGEEEII4WRe9kHp5W380X/1C+i0GvLD4thKLP891BMNnfrhsqgF8wsKIYSAftNgxhsA3Gz8hauqvubTDZ0k27umGn6+214SvAYGzYSbfoeZ78J9B+C2lTD5UYiZoMqHFx6BzQvhy+vgtdGQs8857WjrfN5HO20GzPoB3P3UVI0Lp0JBkhMaKIRok7DTAJ0agPnj/8HiefDbP2DZ4/DXs7D2Fdj4Fmz9CDa8AT///ZiKEjqdjnunqmzvrzankJJ/alRxWHtA3Z+f1t2XQHti49FuOL0HOh0sT8zhUM5xBhptXqgeR8xW0xu1RW21371SzelUJUHv9jhqXm+Au+xzey+OzyAhs7gjWtWpVean466zYEMPfpGt2tffU3WIxZU11Ex6BHwj1Q3o8qea37k4HQ7+qZ4Pu6bxbYxmGHgRAOaE7wGYUG/k0RBHiXOZ11uIVqktb04ZoFEk83oLIYQQQghna0+md2EybPsEgMDzH+X+abHk4scO1I+OkgkihBCtMPRKmPY0AA+YviJnxVtUVHfw4PfSHPjoYvtcsDqY/C+Y+R6YPdX7ej10HwZn3As3LoYHk+DqL2DMbeDTXU1v+cF0yE5of1vyDkJpZtvm8z5azOkqcO8bqZKy3j0H0re1v41CiNZz84FzHoMeZ0CfKRB7AQy6DIZfp6ozxM2FM+6DifergTV7foSdXx1zmDE9AzmjbzAWq8a/f9qNzebCqRZOkNX20uYTGsnyrtUj2Iuz+4cC8OHapGM3yE6A5LWgM8CI69vemAEXqsekVY1m24uTnwS92yOoYaY3QGy4L9OHdAPgpaWS7X00m33EYb4xFAymVu1bO6c3QLHmARe8qF6sfx1SNze9844vQLNBdFzdf7fGDJqpHopWYKSGM/rWC3pHqKB3vAS9hWgdd38A3HQW3KmWEudCCCGEEML5HEHvJuYBPJ5VL6isv54TIeZ0bp7Qk94hXiyyjFTv7/3Zee0UQoiuIO7/sI6fB8BD1rdZ+/PCjmtLxg41f3fyWnDzhWu+hDPmgU53/H3cfKD/eXD+c3D7KggbBGXZ8OEFkLWnfe1pz3zejQmNhVv+qGvj+9Nh/x/tP64QovXG3wU3LILrvoWrPoXL3oOLF8D0/8G0J2HyI3D2w3DmQ2r7JfdDYcoxh3novFjMRj3LErJ5YamTqkx0EE3TWG2fp3tC3+MHvQFuHN8TgG+2pFJcedTvx1veV4/9zwPf7m1vUFBvCIlV9/77l7b9OKLTkqB3ezgyvRvOr3D35L7odPDr7kx2p0uAtD5DoSppVOje+o7JaNDj46bKVhSUV0O/qTDkShXM/ulOVaaoMZpWV9r8eFnetXqcgcUjBH9KmeK2l6FR/o63htif70gtQtNO/hFWQpwwbj5qFB6183of51oVQgghhBCirTzt5c1bm+ldmOLI8q79AdJs1PPvi05jqU0FvbWk1VBR4KyWCiFEl2CY8igHoi7DoNM4I/4hqvcvP/GN2PUtvDcNilPV77i3LFMl2FvDKxhm/6zm/y7LUYHvzF1tb5OjtPkZbT/G0Xy7wY1LoOeZYCmDz69UcwoLITqnCfeogS9VRfDDHWCzNXj7tO5+PHPpYABeW36An3ekd0QrneJgThmZxZWYjXpG9whsctvxfYLoF+ZNWbWVrzbVGwxQXQ7bP1fPR93Y/kbVljhPkBLnpyIJereHI+i9v8H8C33DfLhgiArqytzeDZlLVGdV6hHVpv39vVS2tyNoNu1p9eNG9h5Y/WLjO6VuUgMTTJ5w2iVNf4DeQGLgJABm+WzGZKi7RAZ288Wo15FbWkVmcWWb2i9El6TT1ZU415VRIJneQgghhBCd0oIFC+jRowfu7u6MHTuWjRs3tmi/L774Ap1Ox4wZM1zbwKbUZnqnbVXTW7XU6hfAZlFZ3j3GO1af0TeEAQOHkWCLQqdZ0fb95uQGCyHEKU6nI/r6N1muH4eZGnRfXAMJi4+Zw9bpbDYoz4c/HoNvboKaClVq+JZlENKvbcf0DIRZP0G3YVCeBx9eCBk7HW9/sTGZ2z7aTF5pVdPHcdZ83o1x94Nrv4HBV6gMxh//D1Y+5/rzLYRoPYMRLnlLxSuSVsGGN4/Z5NIRkfxtYi8A7vt6x0lbfXaNvbT56B4BuJsMTW6r0+m44XSV7f3huiSstaXdd3+nBgj4x0Cvs9vfqNqg94E/wCJxnlONBL3bI1B1OlQWqZupeu6a3AedDn7fk8WutE7WIdmsai6brD1QknVCP9qrXAW9q3zaFvQOsM/rXVBmD5p5BcF5z6rnfz0H2XuP3al21P7Ai1XGaTO+qx4HwKjKdQ06PXeTgX5hav8dKZ3sv6k46Tz99NOMHj0aHx8fQkNDmTFjBomJiQ22qaysZM6cOQQFBeHt7c3MmTPJymp4zSYnJzN9+nQ8PT0JDQ3l/vvvp6ampsE2K1asYMSIEbi5udGnTx8++OADV3+9Y3n4A+BPGUUVkukthBBCCNHZfPnll8ybN49//etfbN26laFDhzJt2jSys7Ob3C8pKYn77ruPM85wYsZaW/SepOY0LUmHheeCfWqtJhWmwNaP1fPaMpP1/HP6AJah5lvN3PCNExsrhBBdg9lsIn3yq6yxnobJWg5fXANvnK6mIbS2YUC8pkHWbpXxt+Zl+P1h+O5v8PEl8OYEeL4//CcEnu2pBjUBnP53uOYrx+8SbeYZCLN+hO4joCJfBb7Tt5NWWMGjP+7m9z1ZPP1LM3N+O+bzdmv/fN6NMZpVIG383er18v+oucizdjv/s4QQ7RPUG6b+Rz3/49+NxjUeODeWSf1DqKqxcetHm8kuOfkCtKvspc3HNzGfd32XDI/A39NESn4Fy/bafwffbC9tPvIG0DshpNltOPh0h+pSOPxX+48nOhUJereH2VP9oxqOKXHeJ9SHi4eqbO+X/jjB8y7YrGrOsVUvwK/z4dtb4MOL4PXT4bk+8EQwPN8H3oiDV0ec0Bsfv8o0AGp8Y9q0v7896F1YUe/GeNBM6HeuGp3/41z1/WtVl8Pu79Xz5kqbA5UWK59mhJOuBWKuKVWjfeoZEmmf1zutsE3tF6LWypUrmTNnDuvXr2fp0qVYLBamTp1KWVmZY5t77rmHn3/+ma+//pqVK1eSnp7OpZde6njfarUyffp0qqurWbt2LR9++CEffPABjz76qGObw4cPM336dCZNmsT27du5++67ueWWW/jttxOcqeLI9C6VOb2FEEIIITqhF154gVtvvZUbb7yRgQMH8uabb+Lp6cnChcefh9VqtXLttdfy2GOP0atXrxPY2ka4+8FNv0BATyg8AgvPg5xm/i1em+Xd44wGWd61ogI9CRih7r/90/+ivKzEFS0XQohT2swxvfmn+3zeqplOtd5TVWv8/m/wynBY/yZUlzV9AE1T83IvexxeG6WC5j/cDksfhbWvws4v4OCfkBmvAso2eyKATze49B2Y+gTom84ubDEPf5j1gwpYVxbCRxfxzU8/Um1VpYm/2ZLK5qT84+/fYD5vd+e06Wh6PZzzmJpD2OgBR9bAm2fALw9CRaFrPrM+SwUUpUL6dvW76s6vYN3rsOwJ+Pku+P52NWihstj1bWmJ6nJI3aL+/ylMVsltR5WaFs5xUlcUcpVRN0Gfc8BaBd/ddsz0rQa9jpevHk6fUG8yiyv528dbqLRYj3OwzqfGamP9oTwAzugT0qJ9PMwGrhodDcD7a5JU/5+2GfQmGH6dcxqm10Ps+eq5lDg/5Rg7ugGgOrznnnuOzMxMhg4dyquvvsqYMWOa3e+LL77g6quv5uKLL+aHH35wfUMbE9RbzQuTdwCixzZ46++T+/LTjnT+2JvNztRChkT6u749B5fDb/+E7OYC2TowuqvRLF9cC7etaP+IxxYIsmQAoA9sY9Db46jy5qBKJ09/AZLWqA5w49sw7g71XsIiqCoG/2iIab5s0OakAqpqYLl5AtfaflJz/wy4wPH+4Eg/vtiUws6TtJyI6Dx+/fXXBq8/+OADQkND2bJlCxMnTqSoqIj33nuPzz77jLPPVmVb3n//fQYMGMD69esZN24cv//+O3v27OGPP/4gLCyMYcOG8cQTT/Dggw/y73//G7PZzJtvvknPnj353//+B8CAAQNYvXo1L774ItOmtXIeq/Zw9wekvLkQQgghRGdUXV3Nli1bmD9/vmOdXq9nypQprFu37rj7Pf7444SGhnLzzTezatWqE9HUpvlHw02/wkcXQ04CvH+eCk6EDz5226LUuizvs47N8q516fnnkbkjhHAth+9++oJLr77VNW0XQohTlLvJwM2Th/DID3oW1FzMP0PXclnNIgxFKfDrg7DyvzDmNrV4BamdNA3St8KeH9VSv3qHwQ2ixqigtneomt7CK6Thc68QlfXski/kB9d9B59eBikbuOng3SzXzcccM4aNSfk88uNufp47HqOhkVyz2qC3s0ubN2b0LdB3qvqdeO9Pqnzyrm9hymMw9GrnZEuCythPXAKbF0LKJjWneHN2fK5+l+43DQZdptrZ0kEANivkJKrfgG01EDoQQmJb/rt2TZWaCvPwKvXfI3UTWI+uSKgDd1/139rdT/2m5e4Hvt3V4LrAXhDYU5VadtXghVNMbUWhN998k7Fjx/LSSy8xbdo0EhMTCQ0NPe5+naaikKvodHDxa/B6HGTuhJXPwORHG2zi627i3VmjuHjBGrYlF/LP73fx/OVD0Ol0HdToltuRWkhpVQ3+niYGdvdt8X6z4mJ4Z9Uh1h3Ko+CvJQQADLhQ9fPOEjsdNr2r+i/bi84bHCU6XIcHvU/6Di+oDxxeeUymN0CvEG9mDIvgu21pvPTHfhbe4IKyNbVyEuH3R2C/PXvT3Q/6nac6gmNuAEPVPNhVxfDWmVBwWI2wvOpz593wNMZSQZBNjewxBPVs0yECPFXQu6D8qJsRvwiY+jgsukeN/Ox/HgT0gO2fqveHXtOi77bqQA4AOTHT4fBPsO9XNeLU7KUOYx+4sDO1CE3TOvcfF2uNGlEZNUaVYBKdWlGRGkgRGKj+W23ZsgWLxcKUKVMc28TGxhIdHc26desYN24c69atY/DgwYSFhTm2mTZtGnfccQe7d+9m+PDhrFu3rsExare5++67Xf+l6rNnevtTKuXNhRBCCCE6mdzcXKxWa4P7SoCwsDASEhov1bp69Wree+89tm/f3qLPqKqqoqqqbq7T4mIXZXj5hMMNS+DjGerHww+mq+BE5KiG262qn+V9/OCDu9lIVe9z4cDH2PYuIin3GnoEe7mm7UIIcYq6bmw0mqbx1JK9PJg9lefcp/DukH0MTfkYXcFhFehZ+woMvx4MJhXoLkqpO4DRHfqeAwNnqACpe8uDJy7h7gvXfcu+F86jX1U8n7s/Q/Wkr5j4hYm9GcV8sv4IN4w/6rdPV87nfTz+0XDlxyoTfskDkLdfzfW95X04/znoPrztxy5KhS0fwtaPVIZ9fXoTeAWr359rF69g8AxWAeY9P6q21A5qcPOF2Atg8EzoeZaa77hWWS6kblbB6dRNkLYVqhupvOIbAaED7MtA9RjcX/3/lLYVkv5Sge6UDVBzVIlorxDQ6VWWd00loKnnlc0lPenU5wb2VEttQLzXWSckuexkUr+iEMCbb77J4sWLWbhwIQ891Pjgw/oVhVatWkVhYeEJbPEJ5BMOF74EX82C1S9C32nHJFf2CPZiwTUjmP3+Rr7dmkpsuA+3TuzgKkstsHq/igWN7x2MQd/yOEp3fw/OPS2cFfGHcE/4Vq0cdaNzGxczAdz8oCxH9S3R45x7fNFhOjzofdJ3eEF91OOOz9UIw2FXN5g3+s7JfflxRzp/JmSzPaWQYVH+zv38sjxY8bQaTadZQW+E0bfCmQ80H+j0DFQ3Pu9NVcHdVc+r/VylUN2slmgeePuHNbNx42rLmzeaKTriBoj/RpXt+fluuOgVOLRSvTfs6hYdf7V9jokegydAYQ81knTfr6qEOtAvzAezQU9RhYXk/HJigjrpjx2aBj/OUSWeAnrAjb+o0YiiU7LZbNx9992MHz+eQYMGAZCZmYnZbMbf37/BtmFhYWRmZjq2aeyHydr3mtqmuLiYiooKPDw8Grznsh8jHeXNy0iVTG8hhBBCiJNaSUkJ119/Pe+88w7BwS2bn+/pp5/msccec3HL7LyCYPbP8OnlkLpRZX5f82VdkKEoFbbVzuX9YLOHiz79cjjwMWfrNvPAz/G8e6P8KCaEEK2h0+mYFdeD8X2CmffVDnakFDJjYywXDHqHZyYcxnvza6qE7ca36nYyeUG/qTDwYlX+1827475AIzZnWLi+6B4Wmp8nTr8Hjy8uZrV7N3Zbfcj+PYSy4pF4hcSAXxT4RUJNBZRmuW4+76b0PhvuWKuyvVf+VwV43p6k5sed/GjLk2VsNhVA37wQ9v0Cmr0MuFcIjJgFgy9Xvz+6+aoM1uM5+2E1MC3+G9j1naqiuuMztXgGq4zO6jLVzoLDx+5v8oKIEWB0g+wEtX9xmloaTFWpU9scE+QOhZ5nqIFvPSeqQHVtey2VdQFvx1KolqJUyD8E+YfVUl1i/+zUuix+gDvWSdC7nlOmopArDbwYhlylfsv//ja4fc0xfd6EvsE8Mn0A//55D//7ZSdxVasYlL8U/KJh0vwGManOYs2B1s3nXd895/QjbN9neGgVZJmiCIme4Ny5mo1m9Tcm/mtVLViC3qeMDg16nxIdXp/JsNIfSjLgl/tVlvGwa1RJnuA+9Az24pLhEXyzJZX//Z7IRzeNcU52cE2VKuO98jmoso866z8dznkcgvu0/Djdh8EFL6pRfsufUiP8+p7T/vY1Qis4jA5I0ULx92pbiaHaTO/CozO9QWVyX/gKvDkeDi1Xo6PQ1A1MQI9mj51fVs3udBXgG983BApmwqr/qZsve9DbbNQzoLsvO1IK2Zla1HmD3sufUn8kQQXuP7wIblzi3BIgwmnmzJnDrl27WL16dUc3xXU/Rtpv9v0pPbZSgxBCCCGE6FDBwcEYDAaysrIarM/KyiI8PPyY7Q8ePEhSUhIXXnihY53NPv+l0WgkMTGR3r17N9hn/vz5zJs3z/G6uLiYqKgoZ36Nhjz84frv4Yur4fBf8MlMuPJT6DtFZdFYq1WGR8/mq8fpYsZjdfMnsKqQkn2rWba3J5MHtG0gtxBCdGW9Q7z59vY4Fiw/yCt/7mfRrmw2Hgnk2Zlfc5Zpj8pANrjBwIug92Qwe3Z0kxulaRr//TWBCtxZMvhl4qqehQNL8alIZZweYC9s+KvxnV05n3dTjGYY/3cVmF76KMR/pc73nh8gcoz6u+kRoEp5ewSo17XP3bxh/1K1ff1S8z3OUHMSx17QunLyOh10G6qWKY+p7Otd38DuH6A8V31OfcH91XmLHKUeQwc0LEVcWaSC39m7IXuvWrJ2Q0W+Cnh7BNQFuHucASH9jx+UN7mrxaeZv/OaBuV59YLgh1SAPv9Qi36H7kpOqYpCrnT+syqZryAJfv8nXPjyMZvM7lVM34jvGJD7K4FrSuve2POj2r7vlGP2aZHidDiyVpX8Nnk0v30LlFbVsDW5AIAJbQh69wnxYl7gaiiAt8vPxG3pPh44N9YpbXOIna6C3nsXwTlPND1YR5w0OjTofUp0eCH94Z5dsOMLFYTO3adGJW58C/pMgTF/485JcfywLY1V+3N58Y/9zDunX9s/T9PUPCxLH627yQgfDNOeUn+422L4tWoelM0L4dub4baVqiRLS9lskLYFQmObHFFUnXMINyBZC6WHPXjdWgH2YHnh8TJFg/uo+dj++Dekb1Prhl3bomPXjjyKDfchxMdNBbpX/Q/2/65untz9ABgS4WcPehdy4dBOmD299WP461n1fNLDsOUDVTLooxlwwyIpdd7JzJ07l0WLFvHXX38RGRnpWB8eHk51dTWFhYUNsr3r//AYHh7Oxo0bGxyv9ofK+ts09uOlr6/vMVne4MIfI2vLm+vKjn/9CiGEEEKIDmE2mxk5ciTLli1jxowZgApiL1u2jLlz5x6zfWxsLPHx8Q3WPfzww5SUlPDyyy83ev/o5uaGm5ubS9p/XG7ecM1X8NVsNRXY51fBuU+rUqzQ5FzeDRiMGGLPhx2fMdWwmccXjWR8n2DcTafw3H+WCvXvYJ9jBz0IIUR7GA167prSl0mxIdzz5XYO5pRxwwebuXZsNP+csRBPc4cXJm3WnwnZbEoqwM2oZ87UIeD7tcoCLkol6XAiX/yxju7kcVEPK/6WbFWqvbZU9mkzOrTt+HaDme+oLO9fHoCsXXXTZbaEm5+qqDnqJvW7eHvp9RATp5Zz/wuHV8C+31VJ9MhREDGy+axpdz9VDrp+SWhNU2WLKwpVpVZnT+mp06mS7V7BampJ4TSdvqKQq7j7wYzX4cML1e/5/c9X896X56vA7LZP0GXuZDyADjK1AFaZz2Cm5w70RUfg05lqitdpT7b89//iDDUYdMsHYK1SVSGu/rJ1g1iOY+PhPGpsGtGBnkQHHTWAqaIAjqwDS7m656yprHusqVQVFyoK8C7Yi1Vv5hvrRIpWHCQq0JOrx0S3u20OfaaogVYFhyEnQQ2oESe9zn8XUU+n7fDcfGDMrTD6FpVhvOEt2PebKqdy4A9iAnvx1dDLmL2tH68s209kgAdXjGplEEnT4NAK+PMJFWAG8A6HyY/A0Ksbjm5ri3OfgYydKvj95fVw8+8tG02ZvRd+vkuNyHP3VxnuY29X5eSOUp2rgt5phOLRxh8H/Dxq5/RuImgWdyfs/l6VRTJ7q9GhLVAb9HaMPAodqEYS5iZCwmKVwQ8MiVTB752pzc3r0gEOLFP/PQAm3g9n3g+DLoX3z1OjHT++BGb/5Ajgi46jaRp33nkn33//PStWrKBnz4YDTUaOHInJZGLZsmXMnKkqDSQmJpKcnExcXBwAcXFxPPnkk2RnZxMaqrL4ly5diq+vLwMHDnRss2TJkgbHXrp0qeMYR3PZj5H2oLcvEvQWQgghhOiM5s2bx+zZsxk1ahRjxozhpZdeoqyszDEV2axZs4iIiODpp5/G3d3dMS1PrdqBmkev73AmD7jyE/juFpUFs+Q+tT5mfIuyvB1ip8OOzzjPuIUn8sp4b/Vh5kxqRZW1k4mmUfDOJfjmbMR62ceYT5ve0S0SQpyChkT6s/jvZ/DMLwl8sDaJTzcks+ZALi9eOYzh0QEd3bzjsto0nv01EYAbxvcg3M+ete0fBf5R9IiJoyh/BG9uTOGzUh8W3TkBo0EPlcWqZHdnGUzUY7xKfDq0QlUwrShQJbwrClSg+OjXQX1UoHzQTNdl4BuMKgjVp43ZqvXpdKripVS97HCnZEUhV+k5EeLmwrrX4Me5EHM6JC5RFYoADGbofz5FsVdy+WITKUXVfOB2LU92/4Gh6V+g2/GZiklNf16VTD+ekixY85JKgqwt/6/Tq+kLvv8bzHy33fGmVfuPU9p8/x/ww+1qUEoLGAbPZLb3cF5Ztp+Hf9hFNz93zurvpOvazQd6naUG/iQskqD3KcLJQ5xapz0dntFoxGg08tFHH/HTTz9hNBo5ePDgMfvMnz+foqIix5KSkuKy74NOp0bDXPMl/H2r6qDc/CD/ECP2PssWzzt5yvgOn3z/E3/ta9lFDUDyBjXC5+MZKuBt8oSJD8CdW2D4de0PeIOa3+SKj9QcLFnxsOhuFWg/Hksl/PkfePMMFfAGdSP017Pw0iD45SE1wrEeLT8JgFxT9zaXeA/wrM30bqI8ssEIM96AgJ4w4R4wN1+CXNM0R0c8oa+9I9bpHGXN2fWtY9shkf6AxqG0TKx5hyFtq+qs9/wIZblt+VrOkRmvMhg0Kwy5Eib9U60P6g2zflIjJDO2q3ntqkqbPJRwvTlz5vDJJ5/w2Wef4ePjQ2ZmJpmZmVRUVADg5+fHzTffzLx581i+fDlbtmzhxhtvJC4ujnHj1BwjU6dOZeDAgVx//fXs2LGD3377jYcffpg5c+Y4Ate33347hw4d4oEHHiAhIYHXX3+dr776invuuefEfmF3fwD8daUUVkh5cyGEcz399NOMHj0aHx8fQkNDmTFjBomJiQ22qaysZM6cOQQFBeHt7c3MmTOPuQdNTk5m+vTpeHp6Ehoayv33309NTc2J/CpCCNFhrrzySp5//nkeffRRhg0bxvbt2/n1118dldmSk5PJyMjo4Fa2kdEMMxeq7JdaLc3yrtX7bDB60J1sBuqO8NqfB0gvrHBuOzuJ4j1LCcheh0Gzon17C+QkNr+TEF3QggUL6NGjB+7u7owdO/aYSmzH88UXX6DT6RyVNboyd5OBf190Gp/cPJZufu4k5ZVz1dvrWZ6Q3dFNO64ftqWRmFWCr7uR/zuz8cFP90+Lxd/TREJmCR+vP6JWuvuqLOvOVD7XYFTlkEdcr0qfT35UTYN5+fsw6we4bQXctQMeOgK3LlPbddKS86Lzql9RqFZtRaHGknJqKwpt377dsVx00UVMmjSJ7du3H7eikK+vb4PlpHX2IxAyAMqy1fQD1moIHwLnPQv3JsIVH+I35Hzemj0WH3cju3OtzDh0ITOr/sURXaTa76tZaF9er4Lb9ZXmwO8Pw8tDYf3rKuAdNRZm/QjXfgN6E+z+TlWBaCo21AK1CYZn1MZaaqrg13+ojPSyHDUXec+J0HcaDLhIxTNGzIYxf4Pxd8GZD6nqxtOe4p4pfbl0eARWm8acT7eyJ92J1Zxj7YM7ExY775iiQ+k0rZ3/97bT2LFjGTNmDK+++iqgOrzo6Gjmzp3LQw81/EdoZWUlBw4caLCufgm1fv36YTY3XXqhuLgYPz8/ioqKTkznV10GO7+EDW9Dzl7H6h1aX4LPup2ICdcef56EjJ0qsFxbYsZgVqVjJsxrfl6RtkpareZ/1qxw3nMw9rZjtzn8F/x8N+TbBxn0Px/O+68K/q5+QWVYg+okh1wJE+6G4L6UvTQGr8JE/uHxL556cN6xx22B5LxyJj63HHeTnoQnzmvTMRpzOLeMSc+vwGzQs/1f59SVUsrdD6+NAp1Bjawqz0crz8NSkoNZZz32QHqT6ihHzoaeZzm/dM7xFKXBu1OgJF3NTXPdd8eWIcnYCR9eoMop9TgDrv3aaXN0dKQTfk07yfEGfrz//vvccMMNgOrz7r33Xj7//HOqqqqYNm0ar7/+eoNBQUeOHOGOO+5gxYoVeHl5MXv2bJ555hmMxrpCHitWrOCee+5hz549REZG8sgjjzg+ozlOO7/JG2DhVI7YQjmz+iUSnjj31C4HKUQndbL2mc0599xzueqqqxg9ejQ1NTX84x//YNeuXezZswcvLzX47Y477mDx4sV88MEH+Pn5MXfuXPR6PWvWrAHAarUybNgwwsPDee6558jIyGDWrFnceuutPPXUUy1qx6l6foXoquSadq0OOb82G6x9GdCpH9NaG3j44lpIWMTXXtdyf950pg/pxoJrRrikqR3pyPMTiSndQaVmwl1nodK3J+53rGi+vKzo0rpan/nll18ya9Ys3nzzTcaOHctLL73E119/TWJioqMSW2OSkpKYMGECvXr1IjAwkB9++KFFn9cVzm9RhYV5X25nWUI2Rr2OF68c1ummFayqsXL28ytJK6zgwXNjueOs3sfd9rMNyfzj+3h83Iwsu+9MQn06YB5v0Wl1hWu6vi+//JLZs2fz1ltvOSoKffXVVyQkJBAWFtagolBjbrjhBgoLC7tOn5m9F5bcD2Gnqalbuw1pdLO80iqW7sni9z1ZrD6Qi66mkrnGH7jD8BNGnY1ygw8HRzxMzLgZeG95Hf2md1RJcYCIUTDpH2pgZ+098a5v4ZubAU0FnSfNb1Pzs4orGfvUMnQ62PrwOQSUJ8G3N6mkPVDVgs95vFWxieoaG7MXbmTdoTzCfd35fs7pdPNzQmyjNBue7wdocM9u8Itsdhdx4rXmmu7woHeX6fA0DY6sxbrxXbQ9P2FEZQ3Z3PzRD79WBbOD7aMDc/bBiqdUiW5QAdfh16rsbv8TUJZj7Wvw+z9Bb4TZi9ScKqDmj/j9Edj+iXrt002NMBpwYV3HqGmqDMbqFyFplf2AOhhwITX7lmK0VnBX8Du8PPeKNjWtuNLCkH//DuDUoNnH64/wyA+7GNcrkC9uO2qE2duTIH1ro/tZ9W4YvEPAMwBsVsjeU/emfzQMn6XKovtFOKWdjaosVuXLs3ZBSCzc9KujlPQxUrfARxdDdYkqFXTVZyrL/yR20t/EdHJOO785ibBgDEWaF0Or3mH9/Ml1JcCEECdMV+kzc3JyCA0NZeXKlUycOJGioiJCQkL47LPPuOyyywBISEhgwIABrFu3jnHjxvHLL79wwQUXkJ6e7shqfPPNN3nwwQfJyclpdmAldJ3zK0RXIde0a52U53f7Z/DDHVQGDmBgxiPYNPjopjFM7BfS0S1zmuydfxD63UyqNCMP+L/AA4WPEaHLw9rnHAzXfOmcSnPilHRSXtPtMHbsWEaPHs1rr70GqCSeqKgo7rzzzmOSeGpZrVYmTpzITTfdxKpVq06O3zNPMIvVxr1f7eCnHenodPD0JYO5ypnzt7bTe6sP88SiPYT5urHivkl4mI/fJ1ptGpe+voYdqUVcOjyCF64cduIaKjq9rnJN1/faa6/x3HPPkZmZybBhw3jllVcYO1bNw37WWWfRo0cPPvjgg0b3PWliQB2orKqGv/bl8PueLNL3buBR2wJO06tKExbNgMmewLdT682buivZbByB2WTAzajHbDTg72HiljN6Mrnkp7rpgI6XFNmM77amMu+rHQyJ8OWn0w/Brw+pYLtHoJq3vH/bkhmLKixc9sZa9meXEhvuw9e3x+HjbmrTsRp4bxqkrIfzn1fTGItOpzXXdIeWN4dTvIRafTod9BiP4Yr3KZ+zk/fcridVC0ZfVQjrF8BrI1UJ8+9ug9fH2gPeOhh0GczdBBe9emIC3gBxc+C0S8FWA1/PhpJM2PkVvDbaHvDWqfnL52xQ82XXHx2v00GfyXDDIrj5D5UFjgZ7f8JorcCm6ajyavtoGR83Iwa9+jxnzgu8er8qNz/h6DkmAC7/QJX2mfkeXP8D/O0vXhr8A7GV7/PEsOUwbzfcvhr+b516HHObmjO7MBmW/0eVe//sSlUiw+rkuYytFvhqlgp4e4ep7O3jBbwBIkfaM7w91fwe39zk/DYJ0Rj7/5d+ujL02KTEuRDCpYqKigAIDAwEYMuWLVgsFqZMqZsbLjY2lujoaNatWwfAunXrGDx4sOMeFGDatGkUFxeze/fuRj+nqqqK4uLiBosQQohTWL9zQWfAPX8vdw5XlZX+9vEWlid23jK8rVX465MArPI+l8f+djUPGB+iUjNhOLBUVaITQlBdXc2WLVsa3Fvq9XqmTJniuLdszOOPP05oaCg333xzs5/RVe8zTQY9L145jGvGRqNp8NB38by76lBHNwuAkkoLC5arCqR3T+nXZMAbwKDX8fjFg9Dp4LttaWw4lHcimilEpzV37lyOHDlCVVUVGzZscAS8QVWpPF7AG+CDDz5occC7q/JyM3Le4G68eOUwPnnkVoqv+40/ut9ONUZMOivxth7cVH0fF1U9zpLKQWSXVpNaUMHBnDL2ZhSz7lAeN3+4mbsOjaL89PvVQX+5H+K/aXVbVh/IxZdSntVegJ//rgLevc6CO9a2OeAN4OdhYuENown2diMhs4T/+3QrFqutzcdzcJQ4X9T+Y4kOZ2x+E9ebO3cuc+fObfS9FStWNLlvU51hZ+UbEsG0259l5oILGVi+ib/7/sWwyo3oDv9Vt1H/6XD2P1UJixNNp1NB9uy9qiT7a2OgSv14TMgAuOgViBrT/HGiRsPVn0PWHljzErad37BT64G3d/NzbB+/aTr8PUzklVVTUF7tlExRq01j7UF14zmhbyMj9ANiVCZ+PT17p1G5aTs7Uwsbbhs+GM5/TpXn2PMTbP0IjqyGfb+qxTsMep6pssD9o9VABv8YVTajtRnXmqbKzB9aDiYvNZe8fwtGv8bEqf8un16hOvLv/waXvtP+Efs1VVBRCNWl6g+ZpUKV97eUQ3U5WMrsj+Xq/zGDWS16o/25SS16k/21EXpMPLZMuzg52ef0BvCh3KmDVoQQoj6bzcbdd9/N+PHjGTRoEACZmZmYzWb8/f0bbBsWFkZmZqZjm/oB79r3a99rzNNPP81jjz3m5G8ghBCi0/IMVNNeJa1iTvd9bCsdy1/7crj1w838d+YQZo48ucshHtr6B/3Kt2LRDERd+A/8Pc1cf8mFPPBZEq+YF6jpzMIHw6BLO7qpQnSo3NxcrFZro/eOCQkJje6zevVq3nvvPbZv396iz+jK95kGvY4nZwzCx93IWysP8Z/FeymurOGeKX2PO1XcifDOX4fIL6umV4gXl7ewvx8a5c/VY6L5bEMyj/64m0V/n4DJ0OE5aEKIU5zJoCeuXzfo91+0/NupzDtCVPc4nrFqVNXY7IuVavvz6hobq/bn8N7qw/y4PZ1VnmP4pte19Dr0qYoduPtD3ynNfi6ApmmUJv7FL24vEZGfp377n/woxN3plKlgowI9WXjDKK58az2r9ufyyA+7ePrSwe37+xA7HZY+oqb+Lc9X9/zipNUpgt5dUWSAJ+/eMI4r39a4pHA4tw02MD98E7rSLBh5o8rIPUp1jY2dqYUkZJbQJ9SboZH+zY4qbDM3b7jqU3j7LBXwNrjBmQ/A6X9vfRAybCBc+javGG7izXXpXOfRvpIT/p51QW9n2JlaSEllDb7uRgZH+LVon9rtdqcXY7Hajr1hNXnA0CvVknsAtn2kSuGVZkH8V40f1KebClr7Raly6J7B4BUCXsFqqX1tsgf6/3pOZd7r9Cobvfvwln/pXmfBlZ/AF9eouTpyElVA3uypAuhmTzB71T03ear9KgpUx1+ep5aK2ucFqmS6sz14RILepwqjWf3/ZCnDX1dKoZOuXyGEONqcOXPYtWsXq1evdvlnzZ8/n3nz5jleFxcXExV1girzCCGE6BixF0DSKsz7lvDe7Dk8+M1OvtuWxr1f7yCntIq/TezVoUGZ9ij9XU0rt8n/XE6PVQPwzx3UjZ9Pu4y39ibxN+NitB/noAvuq4LfQogWKSkp4frrr+edd94hOLiRCoON6Or3mTqdjofOjcXX3cRzvyXyyrL9lFRaeGT6QPT6pvtYm01jd3oxyfnlTOwX7JTStzklVby7+jAA90/tj7EVgev7p/bnl/gMErNK+GjdEW6e0LPd7RFCiJbSBfbEPbAnzaUOTuwXwgVDuvPgtztJyCxh8p7z+CIonbFly+Gr62HWj00nQlaVQsp6irb/zBs1H2LQadgCeqG/7D2IGOHU7zQk0p9Xrx7ObR9v5otNKfi4G7l3av+2T4Ub1Fsle+bshRdPU9+zxwSImaDa3tJkxcpiyN2nFjdf6DG+6aq8wiUk6N2BBkf6seCaEdz84SbejrfiFXYVd13c1/G+xWpjZ2oR6w/lsf5QHpuTCqiwWB3vmww6BkX4MbpHIKNiAhgZE0CQtxPnZw7qDdd9C7u+U3MZBPVu1+EyLJ5U4oa/Z/tuNgM8zUCZ0zJFV+/PBeD03sGO0unN6RHkhY+7kZLKGvZnlTKwexPzCAT3UZnfZz+i5jvP3gtFKar8ee1iKYeSDLWkbGj6w80+arRRoZqTg/Ofh35TW9TuBvpNhcvfh69mq/LoWbtaf4xj6OzBcg8VKDd72R/rBdONHmpTmwWs1aq8utX+3FbTcJ1BAt6nFI8AFfSmVDK9hRAuMXfuXBYtWsRff/1FZGRd9kV4eDjV1dUUFhY2yPbOysoiPDzcsc3GjRsbHC8rK8vxXmPc3Nxwc3PivZcQQojOL3Y6/PogpKzHVJHH85cPJcTHjbf+OsQzvySQXVzFw9MHNBuU6Wx2bljGkMrN1Gh6Yi5+uMF7j118GtMOXM+AmmQmEq8GT9+6AryCOqaxQnSw4OBgDAaD416xVv17y/oOHjxIUlISF154oWOdzabKsRqNRhITE+ndu+FvbnKfqQLfcyb1wdvNyL9+2s37a5IorazhmZlDjvn9rqyqhtUHclmekM2fCdlkl1QBEOLjxoPnxnLp8Ih29cuv/rmf8morQ6P8OXdQ4/82OJ4ALzMPnhvLQ9/F8+LSfZzZL4Q+od5tbosQQrjK0Ch/fpo7gTdWHOS15fu5Lu9G3nfLZ4JlB9qnl6O76VcIHaA2riyC5PUqO/rIGkjfDpoVfwAd/OU5lYm3LwQ3H5e0dcrAMP590Wk8+uNu3ll1mN/3ZPHoBQOZPCCs+Z0bc+YDsPheleR3aIVaAIzuEDkaepyhgtgRo1Sl25wElUiYkwi5iZCzD0rSGx5Tp4duQ1Xl354TITpOxUeES0nQu4NNig3liRmD+Of3u3jxj324mfRoGqw7lMfmpHzKq60Ntg/0MnNad1/2ZZWQVVzFtuRCtiUX8rb9/V4hXoyOCWRUjwDOHRTe/tGMUWNaVsq8BWrn8PXzbF8gszZo7rSg9wEV9J7Qt2WjbQH0eh2DI/xYezCPnamFTQe9axlM0G+aWurTNJUtXXgEClPUY0kmlOVCWQ6U59Y9t9WojOrarOrxd8Ho5ueCOq4BF6o54zPj7WXIjy5HXlb3XNNUsN0zCDzsj55B9dYFqFInTihTIk5RHgFQnIqfrozCCgl6CyGcR9M07rzzTr7//ntWrFhBz54NsydGjhyJyWRi2bJlzJw5E4DExESSk5OJi4sDIC4ujieffJLs7GxCQ0MBWLp0Kb6+vgwcOPDEfiEhhBCdl3+U+vEqYwfs+wX9iFnMP38AIT5u/GfxXhauOUxuaRXPXz4Us1EPNpua3qkTZ39rmkblH88AEB80jeG9Gv7dC/Z249GLh3DnF3fys/5hoguT4Zsb4Lrv1bRUQnQxZrOZkSNHsmzZMmbMmAGoIPayZcsanb4xNjaW+Pj4BusefvhhSkpKePnll7tUBndbzD69B95uRu7/Zgdfb0mlvNrKi1cOI7Ookj8TsliWkM2GQ/lU15vX1dNswM/DREZRJfd9vYNP1h/hsYtOY2iUf6s/PzmvnM82JAPw4Ln921TN44pRUXy+KYUdKYVMeWElgyJ8Ofe0cM4d1E0C4EKITsVs1HPXlL6cNzicB77Zya0pd/Gp+SlGVB6g5sMZGAfPVEHuzJ2gNZxP2+YXzdqa/rxXMIxxk65moosC3rVmxfXAz8PEk4v3ciSvnJs/3Myk/iE8euFp9Axu5RS7gy6FgTNUtnfSGjVlbdIaFZtJWqUWUIFsrYl5xL3DIbiviu/k7Yf0bWpZ85JK8IscowLgvc6EiJEqZiScSv510glcOzaGlPwK3lx5kGd+aTj3j7+niXE9g4jrHcS4XkH0DfVGr9ehaRqpBRVsPpLPpqQCNiflsy+rlEM5ZRzKKePLzSm8u+owP84d3/ayDk5WG6T2b2d582B7NvufCVlcNTqqXSM1y6pq2JpcAMAZrQh6gyqjsfZgHjvTiriqzS1A/fhRW8I84tiy9g6apkZQleWqzlazqdFB7RXUu91Z/EK0iIc/AP6UOW16AiGEAFXS/LPPPuPHH3/Ex8fHMQe3n58fHh4e+Pn5cfPNNzNv3jwCAwPx9fXlzjvvJC4ujnHjxgEwdepUBg4cyPXXX8+zzz5LZmYmDz/8MHPmzOnyWTZCCCGOEnuBCnonLIYRswC45YxeBHu7cd/X29m9cxNfZn7J1UH7MSavge7D4IqPwTukY9t9HGtWLWOCZSNWTUfMxY82us1FQ7vz847e3JJwLz+6/QuPw3+puQ/PffoEt1aIzmHevHnMnj2bUaNGMWbMGF566SXKysq48cYbAZg1axYRERE8/fTTuLu7M2jQoAb711YfOnq9aNzMkZF4uRn5++fbWByfwdqDuRQclQwTHejJ2bGhTB4QypiegejQ8f6aw7yybD/bUwq5eMEaLh8ZyQPnxhLi07L7+5T8ch5ftJsam8bEfiGc3rt1vx3W0ut1vHLVMP7xfTzrDuaxK62YXWnFPP/7PvqEenPeoHDOHRTOwG6+J+0UGUKIU0u/MB++veN03l9zmDt+f4iPbf+iX1karF/g2CaFbmxiAOttsayxxJKWVddH3tunbf1la108LILJA8J4ddl+Fq45zPLEHNYc+ItbzujJnEl98HJrRQhUr4ew09Qy9jYVj8lJrAuAJ62GsmxAp6apDemvluDax36O378BKEpTwfJDK+HwSihOU8c6shpWPKUq+vadAv2nQ99zGu57opXlwuG/oCAJAmLUdwns3brM9KoSVdo9Zx/kHVDfJ2IkdBt2QjPcJejdSTwwrT9FFdUs3ZPNiGh/xvVSge7+YT6NBnV1Oh1RgZ5EBXpyyXBVvrOwvJotRwrYlFTAV5tTSMwq4fnfEnn4gs6RnVRkz+xsb3nzq8dE893WNP7Ym83Ly/Zzzzn92nysjUn5WKwakQEeRAe27sIbEqnm9d6ZWtjmz28VnU51FB7+QJ8T85lCOJP9D7evrowiKW8uhHCiN954A4Czzjqrwfr333+fG264AYAXX3wRvV7PzJkzqaqqYtq0abz++uuObQ0GA4sWLeKOO+4gLi4OLy8vZs+ezeOPP36ivoYQQoiTRewFsPxJOLhczV9oq4HDK5mRsoxz/ZfiXp4ORagFIHkdvDcFrv1GZX50IharDdvK5wDYFzKVATGN/36g0+l48pJBTHkhj7ur7+At84uw/nUIHwLDrj6RTRaiU7jyyivJycnh0UcfJTMzk2HDhvHrr78SFqbKqiYnJ6OXSnhOde6gcN67YRS3fbSFgnILBr2OUTEBTB4QytmxYfQO8TomYPy3M3tzyfAInvk1ge+2pvH1llR+3ZXJXVP6Miuuh6rIUU9RuYW1B3NZfUAtR/LKHe89MK1/u9ofE+TFp7eMI6+0ij/2ZvHLrkzWHMjlQHYpr/55gFf/PEB0oFICIxkAAQAASURBVCfnDgonrlcQfcO8ifD3kCC4EKLDGPQ6bjmjF1MHhvPfrz04P+1lijRv1tsGsME2gCwCG91vTM9ABnZrQWVcJ/F2MzL//AFcMTqKx37ew1/7cnh9xUG+25rGP6YP4MIh3drWl+p0EBqrltG3qCB4cbqqZtqSIK5fBAy9Si2aBvmHVNn0w3+ppSIfdn+vFr0RYsarqZT6n6+qS7lSVQkcWVsXkD/e1Ld+URDURwXBg/uq5/7R6jzUlnXPTYTc/Sqo3xidAUIHqvnRI0epQHhILOhdk6yr0zRNc8mRO6ni4mL8/PwoKirC1/fEXXgn2p8JWdz0wWZ0Ovj81nGM69Xxc22Ne2oZmcWV/Dx3AoPtAeO2+mpzCg98sxOAN64dwXmDu7XpOE8s2sN7qw9z9Zgonr50SKv2TS0oZ8J/l2My6Ij/97ROk1Hf1XSVa7qjOPX8/jgXtn3M85bLSex/O+/MGuWcRgohWkz6TNeS8yvEqUWuadc6qc+vpsErw6HgMAT1VT9gaXVTk9n0ZjbaYllmGUSBd1+edvsAU/ERNR3U1Z9DzOkd1/ajLF66lOlrLsOGjopbVuMV2XTWae2/xe8zf8tc/bdgcIMbFjltWjRx8jqpr+mTgJzfOgeySziQXUZc7yD8WlFNcsuRAv79027i09SIpF4hXjwyfSBuJj1rDuSyen8u8WlF2Or9Um7U6xge7c9142K4eFiEs78KRRUWlidk88uuDFbuy6HS0rBkrrebkb5h3vQP86FfmA/9w9VjsLdZguEnObmmXUvOr/NpmsaGw/mUVtbgbjLgbtI7Ht2MBtxqXxsNmAy6DuujNE1j6Z4snli8h5T8CgDG9gxk3jn96BPqTaBXJ+k/bTZI36oqRyUuUXOE1xc+uC4D3OylBtnaasBmrfe83jqdQZVKN5jti6neaxPoTZB/sC7InbZF7Vtf2CAVjC5MVqXZKwpa/728QlXWe1BvlT2euhlKM4/dzuQF3YerQPjomyGgR5OHbc01LZnep6izY8O4clQUX25O4f5vdvDLXRPxbk0pBxeondO7vZneoObCScgoYeGaw8z7agcxQV4tm1e7Hk3TWL3fPp93n9aXmYvw9yDQy0x+WTUJmSUMa8O8QEJ0KR4BAPjrSlm6J4v53+3kofMGtOofqUIIIYQQQnQ4nQ4GXABrX1U/CIHKfug9GfpMRh8znrBijV8XbiAlv4IVuof4wudl+lQmoH10MboZb8Dgy1r3mVWlkLpJPTeYVDaI3qQyJByvjWB0B9/uLZpDvLy6BvPaFwA4EnYOPZsJeANcPjKSRTsz+N++Sxjjl8aYqvXw8aVw3bcQPbZ130kIIdqgT6gPfUJbP0/syJgAfpwznm+2pPLfXxM4lFPGjR9sauT43kzoE8wZfYMZ2yvIpb+n+nmYmDE8ghnDIyivrmFlYg5L92SxO72YgzmllFbVsC25kG3JhQ32C/QyMyzKn5kjIpkyMBQ3oyTiCCFcS6fTdYrEyubodDqmnhbOxH4hvP3XIV5fcYANh/O58u31ALgZ9XTzc6ebnwfd/T3o7q+ed/N3JyrAk17BXu2aTrfF9HqV9Rw5Cqb8C/IOquB3whJIWQ+Z8WpZ+Yzr2hDQA3qeqeYX7zHx2KmYyvJUufK8/SqTO++AeixMBt9u9rLu/dRjcD/13P77fwPF6Sr4nbZFLenboLq0rtT7UOdWjZKg9yns4QsGsPpALin5FTy5eC9PXzq4w9pSabE6Riv6OSHoDfCP82PZn13Cqv253PrRZn6aO54g75bNyVNpsTL/u3gSs0ow6HXE9W59h63T6Rgc4cfKfTnEpxZK0FuI5tj/6I0I1UE6fL4xhWV7s3n84tM4d1DbqjUIIYQQQgjRIc64F3R6COgJfSarMn/19AyGb+84nXu/2sGq/TC9+CFeMi3gPDbBtzeTdHAvURf+E4OhmfLHpdmw4S3Y9C5UFrasbZGj4YKXILzpIPYPvy/nKts60EHkcebyPppOp+PpSwcz9YV8Zhfdxp/dauhWsBk+uVSVb4+Ja1kb69M02PkVWMpgxA3qR0BXslpg55dQWWSfizEWfCNaNFBACHFy0+t1XDE6immDwnll2X4+XncEP08TE/oEM75PMBP6BBPu594hbfM0GzlvcDdHNcvqGhtJeWUkZpawL6t2KSUpr4z8smr+TMjmz4RsAjxNXDI8kitHR9E/vPWDAYQQ4lTkbjLw98l9uXREBM/9lsjag3nklFRRVWMjKa+cpHrTV9Tn72lidI9AxvYMZFyvIAZ088VwIoLgQb3h9DvVUpYL+35TQfBkFax3DHDVG+o9r31tAM2m7nGt1fbF0vCxpgq8Q6HnRPtyppq7uyleQeAV17b7+/p8u8PAi9QCKjM9d589AL5d3Y87kZQ3P8WtO5jH1e+oC+P9G0czqX9oh7Qjq7iSsU8tw6DXceDJ85xWQqKo3MLFC1aTlFfOmJ6BfHLz2GPm4zlaWmEFf/t4M7vSijHodTx+8WlcO7aZC/w4Xvg9kVf+PMBlIyN5/vKhbTqGaJ+udk2faE49v5sXwqJ7oP/5bBj7GvO/i+dQbhkAUweG8fjFgzrsH5dCdBXSZ7qWnF8hTi1yTbtWVzq/KfnlfL8tje+3JHN18XvcZlwMwI/6Kewf9RgzRsUcm7WYdxDWvQbbPgVrlVrnG6FKpNtqwGYBa43juWarQbNa0Fkq0GlW9SNY3Fw488FG5xzML6tm7bOXcIFuNendptD9b9+26jt9sv4ID/+wiwBTDcu6v0Fg1jpVpvDar6HH+JYfqKIQfpoLe39Wr/udB5e+De4u+n8idz98d6vKMKnP7KOyU0IG1AXCQ/qreQxlXuYW6UrXdEeQ8+saVpuGXkfnKHXbQhXVVvZnl/Db7ky+2ZJKVnGV472hkX5cMTqKC4d2x9ddqup1ZnJNu5acX9GYqhorWUVVpBdVkFFUQXphJemFFWQUqccjeeVUWKwN9vFxMzKqRwBjewUxpmcggyP8MDU3aFU4XWuuaQl6dwGP/byb99ckEerjxu/3TMTf03zC2/D0L3t5a+UhIvw9WPPQ2U499oHsEi5ZsJaSqhquHhPNU5cMOu7N6rqDecz5bCv5ZdUEeplZcM2INmV511q6J4tbP9pM/zAffrtnYpuPI9quK17TJ5JTz+/u7+HrGyA6Dm76lUqLlQXLD/DGioPU2DR83Iw8eF4s14yJPjFlZITogqTPdC05v0KcWuSadq2ueH41TWNrciFpv7/M9LSXMKDxl3Uw/2e5i6CgYAK9zAzRHeLi8m8YVvIXelS1tFy/wSTF3kJB1FRyy2vILq4iq6SS7OJKsoqryCquJLe0CpsGYeTzmPkjztVvBKDGNxrjhS9C3ykN2rLgm9+4Pf5KDDoN260r0UcMa9V3sdk0rnl3PesP5eNGNQvdX2Q8O6gxeFBz5ee495vU/EHSt8PXs6EgSZVq1+lVgD+4v5r7PKh3q9rUTINVtvzSR6GmAtz9oMcZKgief/DYOQ1reYXAyBvVXIM+4c5rzymoK17TJ5KcX9GYGquNVftz+XJTCn/szaLGPiG5u0nP+YO7ceWoKMb0DDypgvpdhVzTriXnV7SFxWpjV1oRGw7ns/FwPpsO51NS1fAe0dNs4Nqx0cw7pz8eZpla4kSRoHcTumKHV2mxcv4rqziUU8ZFQ7vzytXDT+jn/747k9s+3gLA69eO4PzBzi9jvDwhm5s+3ISmwRMXn8b1cT0avK9pGh+sTeI/i/ditWkMivDlretHEeHv0a7Prc1g1+tg12PT8DTLjAEnWle8pk8kp57fQyvgo4tV9sSc9Y7VCZnFPPRtPNtTCgEY3SOApy8dQp9Q7/Z9nhDiGNJnupacXyFOLXJNu1ZXP7/Ve5ag//YmjNYKEmxRvFpzCdca/uB0wx7HNn9ah/FWzYVs0GKB5gMWBr0OL7OB4soaJuu38LjpAyJ0eQAkBE+FaU/Rv08f0gor2PDiVczUrySv+ySCbvuhTd8hr7SKF//Yx6+7sigpLeEt04ucZdhBhWbmze7/IWb0dCbHhh07xZmmqQD0b/9Q5Rb9o+GyD9RX/OI6KElXQenLFkKfKY19dOsUp8MP/weHlqvXvSbBxQvAL0K9rqmG/EOQkwA5iXWPeftV+0AF5QdfBmNvh+7D2t+mU1BXv6ZdTc6vaE5uaRU/bEvjy00p7M8udayPDffhpgk9uXhYd5n7uxORa9q15PwKZ7DaNPZmFLPhcD4bDuWxMSmfwnILANGBnjwzczCn9w7u4FZ2DRL0bkJX7fC2pxQy8421WG0aC64ZwfQhJ2b+3OS8cqa/uoqSyhpuGt+TRy8c6LLPenPlQZ75JQGDXsfHN49xdDiVFiv/+D6e77amAXDJ8AievnQw7ibn3OiNfeoPsoqr+Pr2OEb3CHTKMUXLddVr+kRx6vlN3w5vnwne4XBfYoO3rDaNj9Yl8dxviZRXWzEb9Nw4oQeXjYikb5jMSSWEs0if6VpyfoU4tcg17VpyflEltj+7EkqzHKtsOiOHws5lXbdrOaSPobiihuJKC8UVFiotVoK93Qj1dSfM140wX3dCfeyPvm4Eebmh18H+7FL+2JvFmt1HmJTxDjcafsWg0yjSPHndOIt9niN4p/h2jDob2i3L0EWOatfXsNo0tiUXsHRnMmdun8fpti1UaiZus8xjLcOI6x3E0Eh/wv3cifSsYfj2R/E7tEjt3H86zFgAHgHqdUkWfHkdpG5Umd/nPK7KtLc1SzH+G1g8T83fbXSHc56A0be0rGS51QIJi2H9G5BSN2iXmPEw7g7of76aQ1EAck27mpxf0VKaprEtpZCvNqXw4/Z0R6neYG8z142L4bpxMQR7u3VwK4Vc064l51e4gs2msTwxm0d+2EV6USUAV4+J4qHzBuDnIVNKuJIEvZvQlTu8//2eyKt/HiDA08Rv90wk1Me1c+dWWqzMfGMtu9OLGRHtzxe3xTU733Z7aJrGPV9u54ft6QR4mvhxzgSMBh1/+3gL8WlFGPQ6/nH+AG4a38OpZX1u/WgzS/dk8cgFA7l5Qk+nHVe0TFe+pk8Ep57fgiPw8hD1Y9PDWY1uklpQzsM/7GJFYo5jXWy4DxcM6cYFQ7rTI9irfW0QoouTPtO15PwKcWqRa9q15PzaFSbD51dD/mEYORvG/R/4Rznt8LmlVWxbv5x+Gx8mpno/AMWaJ766coojzsT31p+c9lkAmqWSkk+uw/fIUqoxcVv1PaywDQNgoC6J10yv0EufiUUz8LztGpZ4X0K4nwfhfh70C/Xm3EHh9A0yw+J7YdvH6qBDroQLXwZTKyq1lefDkvtgl32u8u7D4ZK31bzdbZG2RQW/d39fVwrdP0Zlfg+/znVzkJ9E5Jp2LTm/oi2Kyi18vimZD9cmkWEP0JiNemYM685NE3oSGy7/L3UUuaZdS86vcKWSSgvP/prIx+uPABDm68Z/ZgzmnIFhHdyyU5cEvZvQlTu86hobl7y+ht3pxUyODeXd2aNcOqfL/O928vnGFAK9zCz++wS6+bWvlHhLVFqsXPnWOnakFtErxIuicgt5ZdUEeJpYcM0ITu/j/HITry7bz/+W7uPiYd15+aoTUzo+IbOYP/ZkcfWYaIK6+OjMrnxNnwhOPb+VRfBMtHr+z8zj/milaRq/78ni680prNyXg8Va92dqcIQfFw7txvQh3ds9PYEQXZH0ma4l51eIU4tc064l57cem1UtRrPrPsNag2X9m+iXP4mhplytu+l3iB7r/M+qqYZvboSERWh6M78Pfo7KvDTOT3sRk2Yhk2DuqL6Tbba+je7eO8SL804L51r9b4SvewydZlVB6ys/rStJfjw2KxxcDj/NhZIM0Blg4v0w8T4wOCEDpzhdlWbfvBAqCtQ6sw8MvxbG3Nb2ecg1DTJ3qgHCIf3b384OINe0a8n5Fe1hsdr4ZVcm760+zA771HIA4/sEcdP4ngyPDsDPw4RBL3N/nyhyTbuWnF9xImw4lMdD38VzOLcMgAuGdOPfF50m1TRcQILeTejqHV5iZgkXvrqaaquNZ2cO4YrRzhtBXt83W1K57+sd6HTw0U1jOKNviEs+pzGZRZVc9NpqskuqABjYzZe3rh9JVKCnSz5vRWI2N7y/iV7BXvx531ku+Yz61h3M45YPN1FWbSUywIN3Zo1iQLeu9/9yra5+TbuaU8+vpsHjQaBZYd5e8O3e7C5F5RZ+25PJzzvSWXswD6ut7k/WyJgAzh/cjYl9g+kT6u3SQTxCnCqkz3QtOb9CnFrkmnYtOb8dpDAF/noWfCPhrAdd9zlWC3x7M+z5ETVZt/0+vu80uORNqs3+ZJdUklVcSUZRJRmFlaw/lMeq/blUW22Ow8zwP8hTNc/jWVOE5hWKbuY74BEIxWlQlFq3FKdBUZqaD7w2Ezuoj8rujhzp/O9XXQ47v1TZ37m1UzfpoO9UGHe7mje8Jf8+KUiCnV/Bji8g/6BaF326Okb/6WAwOr/tLiLXtGvJ+RXOsuVIAQtXH+aXXRnU+4kFnQ78PUwEeJkJ9DQ3fPQyMai7H+N6BaGXwLhTyDXtWnJ+xYlSabHy8rL9vP3XIaw2DX9PE/+6cCAzhkXIb9VOJEHvJkiHVzf3tbebkV/uOoOoQE80TaO4ooYs+z86M4sqyS6pIqu4Epumce3YmBYHVhMyi5mxYA2VFhv3TOnHXVMaH73tSttTCrnri22M7RnIYxcNwsPsunm28suqGfHEUgB2/Gtqo/M35JVWsS+rlKS8MoZG+jOwe9v+31u2N4s7Pt1KdY0Nk0GHxarhaTbwwhVDOXfQiZmnvbORa9q1nH5+n+0F5XlwxzoIG9iqXfNKq/hllwqAb0zKp/5fr1AfN07vHcTpfYIZ3ydYssCFOA7pM11Lzq8Qpxa5pl1Lzm8XYK2B729TJcZ1Bpj8KJz+9ybn0y6ptPBnQjZL4jNYkZhDVY2NSF0275heYIA+uWWfqzfBqBthymNgds3gdwdNg4N/woa3YP9vdeuD+8PYv8HQq8B81BRNlUWw+wcVND+ypm69yROs1XVBe78oGHMrDL8ePANd+z2cQK5p15LzK5wttaCcj9Yd4butaeSWVrVonwh/Dy4bGcllIyNdllzUVcg17VpyfsWJtiutiAe+2cmejGIAogI9CPF2w9/TjL+niQBPMwGeJvw9zY7nkQGeRAdJX9oSEvRugnR4YLVpXPnWOjYfKSDc1x03k56s4koqLbbj7qPTwcwRkcw7px/dmwgmlVRauOi1NRzOLWNivxA+uGF0lxgBOOG/f5JaUMGb140gyNuNfVkl7MssYV9WKfuzS8gtrXZsa9DruPPsPsyd1AejoeVznP+0I515X26nxqYxZUAYT14yiHlfbWfNgTwA7pnSjzvP7tMlznd9ck27ltPP7ysjVAbDDUugx/g2HyaruJJFOzP4MyGLzUkFVNU07L96BHlyep9gJvQJJq5XEAFeLiwVKcRJRPpM15LzK8SpRa5p15Lz20VYa1RwN2ygKlHeCmVVNaxIzGHJrgw2JCTzsPYW0/UbKMSLTC2IMvdwjIFRBHXrRURMH8yB0eAXCd5hHZMhnXcQNr4N2z6F6hK1zt0PRsyCkTeq93d8DolLoKbSvpMOep0JQ66CARdCVTFseg+2vK8GC4MKhg+5Us0fHhp77Odqmiq7nncA8varzylMBjcflRXvGQCeQfbngQ2fG51XflOuadeS8ytcyWK1UVhuoaC8mvyyagrKqskvtz+WWcguqWTlvhxKKmsc+5zeO4grRkVx7qBw3E2uSzY6Vck17VpyfkVHsFhtvP3XIV5etp/qmuPH2uqLDffhwqHduWBIN2KCvJrfoYuSoHcTpMNTknLLOP+VVZRXWxus9/c0EebjTpifO2E+boT5unMot5Ql8ZkAuBn13DShJ3ec1Rtf94YZzZqmMeezrSyJz6S7nzuL/n4GgV0k0DTn060sjs847vs6HUQFeBLoZWa7fe6ckTEBvHTlsBaNjPx8YzL/+D4eTYOLh3Xn+cuHYjLoqbHa+M/ivXywNgmA8waF878rhuJpPnlKoLWXXNOu5fTz+85kSNus5uMbcEH7j4cqI7P1SAFrDuay9mAeO1OLGpRB1+ngzH4hXD8uhrP6h8ocVaJLkz7TteT8CnFqkWvateT8itaotFhZuS+H5XsyWXu4gOT88gbvmw16hkX7q+pPvYMZHu2PqRWDzJ3b2GLY/hlsfAvyDzW+TUisygIffEXj85RbKmHXN7D+TciKr1vfaxIMvAiKM+wB7gMqyG0pP/YYLaIDvUFl4jse9aDTN1x3y1I1oKAJck27lpxf0dEqLVZ+253JV5tTHAk4AD7uRi4c2p0rRkUxNNJPyvm2kFzTriXnV3SknJIqDuWUUlBuobC8ut5jdYN1Sbll1NT7DXtwhB8XDOnG9CHdiAyQDPD6JOjdBOnw6uzLKmFfVglhvu6E+7oT4uN23JF525ILeHpJAhuT8gEI8DTx98l9uXZsDGaj+ofkwtWHeXzRHkwGHV/+LY4R0QEn7Lt0tG+3pHLv1zsA6O7nTr9wH/qF1S7e9An1dgSif9iWxiM/7KKkqgYfNyNPzBjEjOGN/CPX7p2/DvHkkr0AXDs2micuHnRMNvdXm1L45w/xWKwaA7r58s6skV2mY5Rr2rWcfn4/uQwOLIWLF8Dw69p/vEYUV1rYeChfBcEP5JGYVeJ4L8Lfg2vHRXPFqCiCvZ2X1SDEyUL6TNeS8yvEqUWuadeS8yvaI7WgnHUH81h3MI+1B/PILK5s8L6Pu5Gz+ocyZUAoZ/ULxc/z2GnIXM5mU//2Wf8GHFoOXiEw+HKVtd1taMvm/NY0VQJ9/RsqQ1w7TtaQzgCBPdU85kF9wD9GBcIr8lXGeHlBvef5UFEAmrXxYzXm7l3gH9XkJnJNu5acX9GZpOSX8+3WVL7ZkkpqQYVjfWSAB31DvYkJ8qJHkCcxwV70CPIiMsCj4wYidVJyTbuWnF9xMigsr+a33Zks2pnB2oN5DZK4RkT7c8GQ7kwf0o0wX/cObGXnIEHvJkiH13aapvHH3mye+WUvB3PKAIgO9OSBc/vTzc+dK99aT41N498XDuSG8T07uLUnlqZppBZU4OdpOiYDvjEp+eXc/eV2thwpAGDGsO48PmNQg301TePFpft45c8DAPztzF48dG7scUdMbk7K5/ZPtpBbWk2Ql5k3rhvJmJ6df96v9pJr2rWcfn6/vQXiv4ap/4HT72z/8VogKbeMzzYm89XmFArLLYDKBDl/cDjXx8UwIjpARiKLLkP6TNeS89vJ5R9W2XC9z25yPlkhask17VpyfoWzaJpGUl65PQCuqj/llzWcYmx0jwCmDAhj8oAwegZ3QOnIikI1t7ehHcH3giOw6V3I3KmC2sF97UHuvhAQ07pj22xQVQQ11Sr4bbPWe7Sppf660IFgbLqSn1zTriXnV3RGNpvG+kN5fL0llSXxGcdMPVfLoNcR4e9BTJCnWgK9iAr0ICrQk+hAT3xa8FvqqUauadeS8ytONnmlVfyyK5Ofd6SzMSmf+lHbXsFeDIvyZ3i0P8OiAojt5tPlBhJJ0LsJ0uG1X43VxlebU3nxj33klFQB6ubFatOYPqQbr109XAJILVBjtfHa8gO8smw/Nk2NhnzpymGM6hGIzabx+KI9jrLl90/rz5xJfZo9ZlphBbd9tJnd6cUY9TqemDGIq8dEu/ibdCy5pl3L6ed3yf1qnrsz7oPJj7T/eK1QabGyaGcGH68/wg77NAMAA7r5cv24GC4a1h1vt64zNYDomqTPdC05v52UpsH2T2HxfVBTATHj4cKXVbBAiCbINe1acn6Fq1htGttTCvljbxbL9maxL6u0wfu9Q7yYMiCMgd198TIb8XQz4GU24uVmwMNsxMtswNNsdFS1Ey0j17RryfkVnV1xpYVdqUUk5ZVzJK+MpLwyjuSVk5RXRqWl6bltAzxNRAd6OoLg0YGeDOjmy8DuvqdsYEeuadeS8ytOZlnFlSyJz2DRzgxH0mR9bkY9gyP87IHwAIZG+WEy6Mkvq6agrJr88mryy6rrvbZQUFZNgJeZ8waFM6l/KB7mxis+d1YS9G6CdHjOU1ZVw7urDvPWXwcpr7bSK8SLn+ZOkKBRK205ks/dX24nJb8CvQ7uPLsv6YUVfL0lFYDHLz6NWXE9Wny8imor932zg8U71RzjgyP8GN8nmNN7BzGqR8ApN9+3XNOu5fTz++eT8NezMOpmuOCF9h+vjXamFvLJ+iP8uD3dMRLZzajnzH4hnD+4G2cPCG1R1QYhTjbSZ7qWnN9OqKoUFt8LO7+wr9ABGhjMMPF+GH93s5lrouuSa9q15PyKEyU5r1wFwBOy2HAov8HciU0xGXS4mwy4GfWYDXrMxnqL47UBT5OBmGBP+oSoqc16h3p3yX9LyDXtWnJ+xclK0zSyS6pIyq0LgqcUVJCcX05KfnmDyhxHczPqGRLpx4joAIZHBzAixp9Qn1OjzK9c064l51ecKgrKqtmeWsi25EK2pxSyPbmA4sqadh3Tw2Tg7AGhXDC4G2edJAFwCXo3QTo858suqeTXXZlMHRhOuN+pceNxopVUWvjXj7v5bluaY51eB89dNpSZIyNbfTxN01iw/AAvLN1H/X/Pmww6hkcFENc7iNN7BzE8OuCkH70u17RrOf38rnsdfpsPA2fA5R+0bB47Fyoqt/DN1lQ+3XCEQ/ZpG0CVP5/QN5jzBoVzzsAw/D0lICJODdJnupac304mazd8fQPk7gOdHib9EwbNhCX3wYE/1DYhA+CiVyBqTIc29Rg2K2TGQ9IqOLwKMnao0rWRoyFipHr0i+zwv6OnOrmmXUvOr+gIxZUWVibmsDwxm8yiSsqqrVRU11BWZaW8uoayaivVxynP2xqhPm4qAG4PhPcJ9aZHsBfhvu4Y9Kdm3y3XtGvJ+RWnqpJKCyn5KgieWlBOcn45h3PL2JlaRFGF5ZjtIwM8GBEdwIhofwZF+BEV6EmItxv6k6xvlWvateT8ilOVzaZxOK+M7cmFbEspYHtKIXszSgBVNSPA00ygl1oCvMwEeqrHAE8T+7JKWRyfTkp+heN4nmYDkweEMX1wOGf1D8Xd1DkD4BL0boJ0eKIz+3F7Gg9/v4uqGhuvXD2ccweFt+t4WcWVrDmg5jRbeyCX9KLKBu+7m/SM7hHIuF5B9jkh/E+6THC5pl3L6ed3++fww+3qubu/fQ663nWPgb3Vo5tPy4+paWCpgIp8qCiAcvtj7euqEjB7g2cQeAaqR49A9dwjEIxmNE0jMauEJfGZ/BKfwf7suhKIRr2O0/sEc/6gcMb1CsLLzYi7SY+HyYDxFC2zJU5d0me6VqvOr9UCemPnCVqW50PqJshJgNDToMd4MHl0dKvaRtNg64fwy4NQUwk+3WDme+o71b4f/w38+hCU5wI6GHMrTH60dX9/nMlmg+w9dUHuI6uhsqjpfbzDIXKUWiJGQffh4OZ9YtrbRUif6VpyfkVnZbHaKK9WQfByexC8usZGtdXmeF5V73VJpYVDOWUczCnlQHYp2fZp4BpjNuiJDFDz2MYE1ZXxjbY/P9n+PV6fXNOuJedXdDU2m8ah3DK2JhewLbmArUcK2ZddQmORDLNRT5S9b40K8FTzhQfYy6UHeXbK6htyTbuWnF/RlVisNgw6XYsG/2iaRnxaEYt3ZrA4PoPUgroAuJfZwFmxoYyKCWBIpD+ndfftNEFwCXo3QTo80dkVlVuorLES5uvcrHlN00jOL1cB8IN5rDuYS25pwxJCBr2OAd18GBEdwMiYAEZEBxAZ4NGp52iXa9q1nH5+i9Lg08vUD/tN8Q5XwWnNBmjqUbOpQEX9dVaLCtRYj//DUrPMPuAZoD7TLwJ8I8jRBbMp353fUo2sz3UnB39sHBvgri156GEy4GFWj15uRiL8PezzUXk45qTq5ufR7qyOSouV5PxyDuWUcTi3jKTcMiosVmK7+TDQPt9Vs6W+NA1Ks6HgMBQkQf5h9bwwBTz8IbBXw8UvEvSd4wZHtJ/0ma7VqvO79F+w8R3wjwK/qHqP0XWvvcNB74LBNZoGeQcgeT2kbICUjZCb2HAbowf0mAB9z4E+U9SAJGerKoWyHPWdndXPVJXAonsg/mv1us8UuOQt8Ao+dtvyfPjtn7DjM/XaNwKm/w/6n9e+NmiaGnRVnKYeLRX1lnIViLeU219XQlEKHFkD5XkNj2P2gZjToedEFdguSILUzWpwQtYusB1V0kynh6C+EBqrMthD7UtgLzB0vh/6TgbSZ7qWnF9xqiqqsHDIHgA/mFNmfywltaAci7Xpn+C83Yzq3xdmvf3fGEY8THrHvzfcTQb8PczEdvPhtO6+9A316TTV2+Sadi05v0Koah07UgrZeqSQrckFHMwpJaOoEmsz01YEe7vRO8SLXiHe9A7xoneIN71CvIgM8Oyw6htyTbuWnF8hmqdpGjtTi1gcn8HinRmkFVY0eN+o1xHbzYehkf5qifKnT6h3h/SbEvRugnR4QiiaprE/u5Q1B3LZfKSAbUcKjskEBwjxcWNEtD9DIv2JDPAgMsCTyACPNpUOqqi2kl9ejYfJgL+HySmlh+Sadi2Xnd/qchVozTsAeQftywHIP6gCIG2hN9bL4A5Qzz0CVNZeVYnK/C7PV0GF2ixwrWWlC20YyNUHkm/1QKfZ0KOhx4YBG3ps6HWa4zlAmeZOGe6Uap6U4k4pHpTjgd7dG6OHH+7efhiMbhgMBnQGE3qDEYPRhN5oRK9Xzw1GI+VlJZQWZFNRnIetLA9DVSH+lOKvKyXA/mjGQgVulGnuVOBGtd4Tvbs3bh7eePr44efnj4+HG/qiVBUwKUgCS1mT37cBgxkCetQFwT0D6wYfaDZVgtcxKMFqf09T2at6gwrC6PSgq/dcb3+02fexWY96VOs1+7F1juPbGn527YIG6OzHtz86XlOvDfZ26A32x3qv9Ub1XDuqTZrt2HbCUZ9R/zPtS+1zZ2tw23bULdxZ88Hs1eTu0me6VqvO7zc3wa5vm95Gb1KDcUyezX+43qiqWpi97Ev95/bXljJI2aQC3RX5xx6jNmCaugVK0hu+F9gL+tgD4D0mgLkFbQJ1/RSnqhLjuQcgb3/d89rPMHlC2CDoNrRuCR3Q+kBtZrwqZ553QF3Pkx+B0+9qfuDAweWw6G7VPwIMuBAix4DRHUzu6tHo1vDRYFZ/U4pT1YCu4vR6z9NUULu1TJ4QHQc9z4AeE9V5MBwn489SoUqe1wbBUzerz2+M3gTBfdU5DRkAPuGqfdVlarGUQ3Wp+ttc+7ymWv03NnuDm6/KIHfzsb+2rzN7q/NjcFPnxWCu9+he91yz1QX86wf/6z9aq5ru5x39ff0+trH+V1+vn7T/PWrsEWDUTdJndjA5v6Krsdo0MopUCd/kPFXC94h9TtsjeeWNlvFtjsmgo2+oDwO7+3Jad18GdvNlQHffDslqlGvateT8CtE4i9VGRmElKQWqP00pKCc5v4IUe7n0oxN+6jMb9fQI8qRXsDdRgR509/cgwr/u0d/T5LJEILmmXUvOrxCto2kaO1KLWJmYw87UQnakFjbaf3qaDQyK8KNnkJfqKwNUfxnh70G4n7vLBmNK0LsJ0uEJcXwZRRVsPVLIliMFbEkuYE960XFHopsNerr5uzs6tYgAD0J93CmptJBXVk1eaTX5ZVX1nldTYbE69tfrINDLTJCXG0HeZoK83QjyMqvF241ALzNn9Q9ptoSGXNMts2DBAp577jkyMzMZOnQor776KmPGND9/aYec38oiFbCoKmkisGh/rTfWBbnN3q0LMtpsUFmogt9luVCaWResKLYHMIrSoCSjLtB5irChI4sg0nThpOnCydCHk6kPxY9SIrVMImwZRGoZhNsyMVPT/AFFp1A1bz9uvqFNbiN9pmu16vxaKqAoFQqTVaZvYUrDx+J01/Y9RnfoPgKix0LUWBXk9QpS72maqshx4A/Yv1RlhNssDff16ab6YMegEf1Rrw11/XlNReNtABWQtTXyI7/BDGGnqcBv+GDVx9cfIGOrqTfwxqoGNK17XQVPfSPgsoUQPa7l56O6HFY+A2tfc9559wxWVUvMnipz3nT04qnOpUeAamv3EWA0t/3zSjLVPObZeyFnr/0xUQWxxbHuTVQDAJogfaZryfkVoqGicgsF5erfzeXVViotViqqrVRY1FL7Oqu4ir0ZxexOL6K4svF79Qh/D3zcjbgZ9ZgMesxG+2LQYzLqcau3zvG+/dGtkXVnx4bi5dZ06XW5pl1Lzq8QbVNSaeFwrpqConYqikM5ZRzKLaO6pulECE+zge6OILg7vu4mjAYdJoPevjT+/Kz+Ifg0M/hIrmnXkvMrRPtomkZaYQU7U4vYkVLI9pRC4tOKKK8+/u8lOh2E+bgTEaD6TT8PI2aDwXHP6Vbv3rL+/emZ/ULw83BenylBbyHEcVVarMSnFbHlSAGJmSWkFVSQVlhBRlEFzVQOOi6TQddsSbda2x45hwCvpn/8lWu6eV9++SWzZs3izTffZOzYsbz00kt8/fXXJCYmEhoqAbJm2axQmqUC4FXF9bKEazOXj8oY1jSVOVdVAtUlUFWCrbKEsuICSksKqSgpxFJRjGa1qKCNzYZOqwFbjcpotj/qNQtWgwd4BGD0DsLDLxifgFC8/ELQedbLZDd5OLL1KitKSM/OJTMnl9z8fAoKCyktKcJgs5CuBZKshXFECyNNC6aa5rM/9NjoRh499Jn00GXRQ5eJNxX2nHadfdEf8xpAh9YgI772tcGxleZ4ZrUfw9rYc01fbw+d/Ug6x+dp9T4P+2eoLaj3XLMfVUOvU+2pzcyv/9yIDRu6Y9qg2dfVtgdAp6t/7PqP2FvWNrqjsrd1aPaj1qn/uv7Wl9+7gMCAgCaPL9e0azn1/FprVCZ0URpYj5+dULe9xZ6ta8/ebey5Tg8RIyBqnAoktzTAWlUCh1aqIPiBP1RQvjX0JpUpHtzXvvRTWeXBfVTGcN5BlbWcsd3+uBOqmpnP+nj6nQsz3lADotoiYyds/Uh955rKektV3aOlQj16BDimxVCPkXWvfSNUFnRHs9nUf6+cBDWQITtBZfmb7FncZk+V7WyqrQhgX28wqYEA1aXqXFSVNP68pkot1iqVHV77WFN51OABnfrM2mC/yUOdn9rnBjf739XagW2NLI6+T6vLCG/see12DapuNLLuvP+q/4ZNkD7TteT8CtE+tT9G7k4vZnd6MXvSi9mTXtRoBbf2WvXAJKICm67yIte0a8n5FcK5rDaN9MIKDuSUcjinjLTCCtLtS1phJbmlbZ9Gb/l9Z9EzWCoKdSQ5v0I4n9WmcTCnlPjUIlILavvLuqW5gUTHs/SeifQN82lym9Zc000P0xRCdGnuJgOjewQyukfDH45rrDYyiysdQfDUggrSCirILa3C18NEkJeZQG971raXW91zbze8zAZqbBoFZdXkllaTV1ZFfu3z0iry6q1rboSPaJkXXniBW2+9lRtvvBGAN998k8WLF7Nw4UIeeuihDm7dSUBvAN/uamnrIQAf++JK7kCvWOhVb11tGcUaq4ZV09A0DasNbJqG1aahaWC1PwcNm6b2sWnqPZum1tk0DZtNPde0ukeNum20evscnXSvayQM7OYY6WfAzaRv+Nr+XNNUubLapbpGq3tutWGxalhqbNTY1HOrTb1fY9Oosb9f+57NplFj07DYH2vs21nrva79PtT77vXXWW3HfrfGqM01+2Nt1XfN/rzuuHXbNz4YqDVDE6/28G75xqJJba2O4VQGo5rr2j/6xH5uY9x8YMAFatE0FaSuyLcP3KmxZ17XZl9b69abvFSQ2z/m+GW6AUL6qWXI5eq1pqkpMDJ2qCVrj8oGb256guhxMGJW+6YW6DYEpj/f9v07G70eAmLU0m/aif1sm1UFxPUGlbnvotKQQgjRVel0Ovv0Y55MO62uckVBWTUHckqpqLba75/VfXP9R8f6GhtVVhuWGo1qq9Wxrtp+360erc1meQshxMnGoNcRFehJVKAnk/of+36lxUpGUaUjqJNeWEFZVY36DcJqo8b+WN3Icy9z01UrhRDiZGTQ6+gX5kO/RgLUmqaRW1rt6C/TCiooqao55r6z9l60yvHcire7c+8z5a5VCNFqRoPe8Y/rtjAZdIT6uhPq2wkyoE5x1dXVbNmyhfnz5zvW6fV6pkyZwrp16zqwZeJEMeh1bb5WheiKvvzyS+bNm9egOsa0adNaVB2jS9DpVIa2qz8jsJdaTrvEtZ8lXEdvaPnc70IIIZwmwMvMaK82VjwRQggBqESgnsFezWZsCyGEUIMxQ3zcCPFxY1iUf4e2xTWzigshhOgUcnNzsVqthIWFNVgfFhZGZmbmMdtXVVVRXFzcYBFCiK6kfnWMgQMH8uabb+Lp6cnChQs7umlCCCGEEEIIIYQQQojjkKC3EEIIh6effho/Pz/HEhUV1dFNEkKIE6a2OsaUKVMc66Q6hhBCCCGEEEIIIYQQnZ8EvYUQ4hQWHByMwWAgKyurwfqsrCzCw8OP2X7+/PkUFRU5lpSUlBPVVCGE6HBSHUMIIYQQQgghhBBCiJOTBL2FEOIUZjabGTlyJMuWLXOss9lsLFu2jLi4uGO2d3Nzw9fXt8EihBCicVIdQwghhBBCCCGEEEKIzsHY0Q040TRNA5BMHCFOEbXXcu21LY41b948Zs+ezahRoxgzZgwvvfQSZWVl3Hjjjc3uK32mEKcW6TP/n737Dm+qetwA/qYrnemeFNqyVwFBgYJspCAgGxk/KEtkKqCoKDJVvoIIiAwVBUVQliCCyt5LVgHZIJvu0r2b8/vjNqHpTNukadL38zx52tzc3JzcJG9O7rnnnKKVZnSMadOmqa/Hx8ejWrVqzEwiE8HM1C/WM4lMCzNTv5iZRKaFmalfzEwi01KSzKx0jd6JiYkAwJ44RCYmMTERjo6Ohi5GhfT6668jKioKs2bNQnh4OJo0aYK///473/C9BWFmEpkmZmbBco+O0bt3bwDPR8eYNGlSvvXlcjnkcrn6uqoSzswkMi3MTP1gPZPINDEz9YOZSWSamJn6wcwkMk3aZKZMVLLTiZRKJZ4+fQoHBwfIZLIi101ISEDVqlXx6NEjDvFbTrjPy5+x73MhBBITE+Hj4wMzM87YoGvMzIqN+7z8Gfs+Z2YWb9OmTQgJCcE333yjHh1j8+bNuHHjRrEnCzEzKzbu8/Jn7PucmalfzMyKjfu8/Bn7Pmdm6hczs2LjPi9/xr7PmZn6VZLMBIz//WRsuL/Ln7Hv85JkZqXr6W1mZgZfX98S3Yfz2pY/7vPyZ8z7nGdE6g8z0zhwn5c/Y97nzMyilWV0DGamceA+L3/GvM+ZmfrDzDQO3Oflz5j3OTNTf5iZxoH7vPwZ8z5nZupPaTITMO73kzHi/i5/xrzPtc3MStfoTURERERUlEmTJhU4nDkRERERERERERFVTBw7g4iIiIiIiIiIiIiIiIiIjBYbvYsgl8sxe/ZsyOVyQxel0uA+L3/c56QrfC+VP+7z8sd9TrrC91L54z4vf9znpCt8L5U/7vPyx31OusL3UvnjPi9/3OekS3w/lS/u7/JXmfa5TAghDF0IIiIiIiIiIiIiIiIiIiKi0mBPbyIiIiIiIiIiIiIiIiIiMlps9CYiIiIiIiIiIiIiIiIiIqPFRm8iIiIiIiIiIiIiIiIiIjJabPQmIiIiIiIiIiIiIiIiIiKjxUbvIqxYsQL+/v6wtrZGixYt8M8//xi6SCbj6NGj6NmzJ3x8fCCTybBjxw6N24UQmDVrFry9vWFjY4POnTvj9u3bhimsCViwYAFeeuklODg4wMPDA71798bNmzc11klLS8PEiRPh6uoKe3t79OvXDxEREQYqMRkjZqb+MDPLFzOTygMzU3+YmeWLmUnlgZmpP8zM8sXMpPLAzNQfZmb5YmZSeWBm6g8zs3wxMyVs9C7Epk2bMG3aNMyePRsXLlxA48aNERwcjMjISEMXzSQkJyejcePGWLFiRYG3L1y4EF999RVWr16NM2fOwM7ODsHBwUhLSyvnkpqGI0eOYOLEiTh9+jT27duHzMxMdOnSBcnJyep1pk6dij/++ANbtmzBkSNH8PTpU/Tt29eApSZjwszUL2Zm+WJmkr4xM/WLmVm+mJmkb8xM/WJmli9mJukbM1O/mJnli5lJ+sbM1C9mZvliZuYQVKDmzZuLiRMnqq9nZ2cLHx8fsWDBAgOWyjQBENu3b1dfVyqVwsvLSyxatEi9LC4uTsjlcvHLL78YoISmJzIyUgAQR44cEUJI+9fS0lJs2bJFvc7169cFAHHq1ClDFZOMCDOz/DAzyx8zk3SNmVl+mJnlj5lJusbMLD/MzPLHzCRdY2aWH2Zm+WNmkq4xM8sPM7P8VdbMZE/vAmRkZOD8+fPo3LmzepmZmRk6d+6MU6dOGbBklcO9e/cQHh6usf8dHR3RokUL7n8diY+PBwC4uLgAAM6fP4/MzEyNfV63bl1Uq1aN+5yKxcw0LGam/jEzSZeYmYbFzNQ/ZibpEjPTsJiZ+sfMJF1iZhoWM1P/mJmkS8xMw2Jm6l9lzUw2ehcgOjoa2dnZ8PT01Fju6emJ8PBwA5Wq8lDtY+5//VAqlZgyZQpat26Nhg0bApD2uZWVFZycnDTW5T4nbTAzDYuZqV/MTNI1ZqZhMTP1i5lJusbMNCxmpn4xM0nXmJmGxczUL2Ym6Roz07CYmfpVmTPTwtAFIKLyNXHiRPz77784fvy4oYtCRFThMTOJiLTHzCQi0h4zk4hIe8xMIiLtVebMZE/vAri5ucHc3BwREREayyMiIuDl5WWgUlUeqn3M/a97kyZNwq5du3Do0CH4+vqql3t5eSEjIwNxcXEa63OfkzaYmYbFzNQfZibpAzPTsJiZ+sPMJH1gZhoWM1N/mJmkD8xMw2Jm6g8zk/SBmWlYzEz9qeyZyUbvAlhZWaFZs2Y4cOCAeplSqcSBAwcQFBRkwJJVDgEBAfDy8tLY/wkJCThz5gz3fykJITBp0iRs374dBw8eREBAgMbtzZo1g6WlpcY+v3nzJh4+fMh9TsViZhoWM1P3mJmkT8xMw2Jm6h4zk/SJmWlYzEzdY2aSPjEzDYuZqXvMTNInZqZhMTN1j5kp4fDmhZg2bRpCQkLw4osvonnz5li6dCmSk5MxcuRIQxfNJCQlJeHOnTvq6/fu3UNoaChcXFxQrVo1TJkyBZ988glq1aqFgIAAfPzxx/Dx8UHv3r0NV2gjNnHiRGzcuBG///47HBwc1HM0ODo6wsbGBo6Ojhg9ejSmTZsGFxcXKBQKTJ48GUFBQWjZsqWBS0/GgJmpX8zM8sXMJH1jZuoXM7N8MTNJ35iZ+sXMLF/MTNI3ZqZ+MTPLFzOT9I2ZqV/MzPLFzMwhqFDLly8X1apVE1ZWVqJ58+bi9OnThi6SyTh06JAAkO8SEhIihBBCqVSKjz/+WHh6egq5XC46deokbt68adhCG7GC9jUAsXbtWvU6qampYsKECcLZ2VnY2tqKPn36iLCwMMMVmowOM1N/mJnli5lJ5YGZqT/MzPLFzKTywMzUH2Zm+WJmUnlgZuoPM7N8MTOpPDAz9YeZWb6YmRKZEEKUteGciIiIiIiIiIiIiIiIiIjIEDinNxERERERERERERERERERGS02ehMRERERERERERERERERkdFiozcRERERERERERERERERERktNnoTEREREREREREREREREZHRYqM3EREREREREREREREREREZLTZ6ExERERERERERERERERGR0WKjNxERERERERERERERERERGS02ehPlIZPJsGPHDkMXg4jIKDAziYi0x8wkItIeM5OISHvMTCIi7TEzTRcbvalCGTFiBGQyWb5L165dDV00IqIKh5lJRKQ9ZiYRkfaYmURE2mNmEhFpj5lJ+mRh6AIQ5dW1a1esXbtWY5lcLjdQaYiIKjZmJhGR9piZRETaY2YSEWmPmUlEpD1mJukLe3pThSOXy+Hl5aVxcXZ2BiANO7Fq1Sp069YNNjY2qF69OrZu3apx/ytXrqBjx46wsbGBq6srxo4di6SkJI11fvjhBzRo0AByuRze3t6YNGmSxu3R0dHo06cPbG1tUatWLezcuVO/T5qIqJSYmURE2mNmEhFpj5lJRKQ9ZiYRkfaYmaQvbPQmo/Pxxx+jX79+uHTpEoYOHYpBgwbh+vXrAIDk5GQEBwfD2dkZZ8+exZYtW7B//36NQFu1ahUmTpyIsWPH4sqVK9i5cydq1qyp8Rhz587FwIEDcfnyZbz66qsYOnQoYmNjy/V5EhHpAjOTiEh7zEwiIu0xM4mItMfMJCLSHjOTSk0QVSAhISHC3Nxc2NnZaVw+/fRTIYQQAMS4ceM07tOiRQsxfvx4IYQQ3377rXB2dhZJSUnq23fv3i3MzMxEeHi4EEIIHx8f8dFHHxVaBgBi5syZ6utJSUkCgPjrr7909jyJiHSBmUlEpD1mJhGR9piZRETaY2YSEWmPmUn6xDm9qcLp0KEDVq1apbHMxcVF/X9QUJDGbUFBQQgNDQUAXL9+HY0bN4adnZ369tatW0OpVOLmzZuQyWR4+vQpOnXqVGQZGjVqpP7fzs4OCoUCkZGRpX1KRER6w8wkItIeM5OISHvMTCIi7TEziYi0x8wkfWGjN1U4dnZ2+Yaa0BUbGxut1rO0tNS4LpPJoFQq9VEkIqIyYWYSEWmPmUlEpD1mJhGR9piZRETaY2aSvnBObzI6p0+fzne9Xr16AIB69erh0qVLSE5OVt9+4sQJmJmZoU6dOnBwcIC/vz8OHDhQrmUmIjIUZiYRkfaYmURE2mNmEhFpj5lJRKQ9ZiaVFnt6U4WTnp6O8PBwjWUWFhZwc3MDAGzZsgUvvvgiXn75ZWzYsAH//PMPvv/+ewDA0KFDMXv2bISEhGDOnDmIiorC5MmTMWzYMHh6egIA5syZg3HjxsHDwwPdunVDYmIiTpw4gcmTJ5fvEyUi0gFmJhGR9piZRETaY2YSEWmPmUlEpD1mJukLG72pwvn777/h7e2tsaxOnTq4ceMGAGDu3Ln49ddfMWHCBHh7e+OXX35B/fr1AQC2trbYs2cP3n77bbz00kuwtbVFv3798OWXX6q3FRISgrS0NCxZsgTvvvsu3Nzc0L9///J7gkREOsTMJCLSHjOTiEh7zEwiIu0xM4mItMfMJH2RCSGEoQtBpC2ZTIbt27ejd+/ehi4KEVGFx8wkItIeM5OISHvMTCIi7TEziYi0x8yksuCc3kREREREREREREREREREZLTY6E1EREREREREREREREREREaLw5sTEREREREREREREREREZHRYk9vIiIiIiIiIiIiIiIiIiIyWmz0JiIiIiIiIiIiIiIiIiIio8VGbyIiIiIiIiIiIiIiIiIiMlps9CYiIiIiIiIiIiIiIiIiIqPFRm8iIiIiIiIiIiIiIiIiIjJabPQmIiIiIiIiIiIiIiIiIiKjxUZvIiIiIiIiIiIiIiIiIiIyWmz0JiIiIiIiIiIiIiIiIiIio8VGbyIiIiIiIiIiIiIiIiIiMlps9CYiIiIiIiIiIiIiIiIiIqPFRm8iIiIiIiIiIiIiIiIiIjJabPQmIiIiIiIiIiIiIiIiIiKjxUZvIiIiIiIiIiIiIiIiIiIyWmz0JiIiIiIiIiIiIiIiIiIio8VGbyIiIiIiIiIiIiIiIiIiMlps9NazdevWQSaT4f79+4YuSrHat2+Phg0bGroYlQ73u/75+/tjxIgRhi4GmZD79+9DJpPhiy++MHRRKhXud/07fPgwZDIZDh8+bOiikAnhZ9cwuN/1j5lJpTVnzhzIZDJER0frZHvt27dH+/btNZZFRESgf//+cHV1hUwmw9KlS7XaVt7fToW9z9evX4+6devC0tISTk5OZSp/aRkq51THec6dO1euj0tU3vg9Z3gF5TsRVUzMzLLh71fSFTZ6FyElJQUrVqxAly5d4O3tDQcHB7zwwgtYtWoVsrOzy7RtpVKJVatWoUmTJrCxsYGrqys6duyIS5cu6aj0hnXy5EnMmTMHcXFxetn+Z599hh07duhl20RUep999hlatmwJd3d3WFtbo1atWpgyZQqioqJ0sv3jx49DJpPp9CBhRbBy5UqsW7dOL9u+du0a5syZYxQnXxFVNvqoa0ZERGDkyJHw8PCAjY0NmjZtii1btui45IbFzCQiKt7UqVOxZ88ezJgxA+vXr0fXrl11tu0bN25gxIgRqFGjBr777jt8++23Ots2EREREVFFtXHjRq1PJtW3lJQUzJkzhyda5GFh6AJUZP/99x8mT56MTp06Ydq0aVAoFNizZw8mTJiA06dP48cffyz1tkeNGoUNGzZg+PDhmDRpEpKTk3Hx4kVERkbq8BkYzsmTJzF37lyMGDFCL2d9f/bZZ+jfvz969+6t820TUemdP38eTZo0waBBg+Dg4IDr16/ju+++w+7duxEaGgo7O7tSb1upVGLy5Mmws7NDcnKyDktteCtXroSbm5teRiS4du0a5s6di/bt28Pf31/n2yei0tN1XTMhIQEvv/wyIiIi8Pbbb8PLywubN2/GwIEDsWHDBgwZMkRPz6R8MTOJiIp38OBB9OrVC++++26ZttO2bVukpqbCyspKvezw4cNQKpVYtmwZatasWdaiEhFRIfbu3WvoIhARUS4bN27Ev//+iylTphi6KEhJScHcuXMBgKOC5MJG7yJ4eXnhypUraNCggXrZm2++iVGjRmHt2rX4+OOPS/UDb/Pmzfjxxx/x22+/oU+fProsslFSKpXIyMiAtbW1oYtSrpKTk8vUAEhUEW3bti3fsqCgIPTv3x9//PEHBg0aVOptf/vtt3j06BHGjBmDZcuWlaWYRq0yZofqe4LI1Oi6rvnNN9/gzp07OHDgADp27AgAGD9+PFq2bIl33nkH/fv312i0qAyYmURUWUVGRurkBHQzM7N8v9VVJ+sbalhzIjJtlbH+Vhhd1d2zsrKgVCor3W8BosqAmUmkyeiGN3/y5AlGjx4NHx8fyOVyBAQEYPz48bh16xZkMhmWLFmS7z4nT56ETCbDL7/8AuD5/Fk3btzAwIEDoVAo4OrqirfffhtpaWnq+7m5uWkchFRRNVRfv35dY/nVq1fRsWNH2NjYwNfXF5988gmUSmW++3/55Zdo3rw5+vTpA6VSWaYei/v27cPLL78MJycn2Nvbo06dOvjwww/Vtxc2p3hRc0ycP38erVq1go2NDQICArB69ep86yxfvhwNGjSAra0tnJ2d8eKLL2Ljxo0ApP07ffp0AEBAQIB6KGJVGWQyGSZNmoQNGzagQYMGkMvl+PvvvwEAX3zxBVq1agVXV1fY2NigWbNm2Lp1q8Zjy2QyJCcn48cff1RvO3dPnydPnmDUqFHw9PSEXC5HgwYN8MMPP5R01wIA/vrrL7Rr1w4ODg5QKBR46aWX1M8TAI4dO4YBAwagWrVqkMvlqFq1KqZOnYrU1FSN7YwYMQL29va4e/cuXn31VTg4OGDo0KEl3u+RkZEYPXo0PD09YW1tjcaNG+frBZZ7/otvv/0WNWrUgFwux0svvYSzZ88WWK6HDx+iR48esLe3R5UqVbBixQoAwJUrV9CxY0fY2dnBz89P47kDQGxsLN59910EBgbC3t4eCoUC3bp1yzdMv+r9tnnzZnz66afw9fWFtbU1OnXqhDt37uR7nitWrED16tVhY2OD5s2b49ixYwXOY5Seno7Zs2ejZs2a6v3/3nvvIT09Pd82c8vMzMTcuXNRq1YtWFtbw9XVFS+//DL27dtX5P2MUXlmZmFUPeVyT3eg7Xsn9/ozZ87EvHnzSn1wTZvXvbD5skaMGFFoj78lS5bAz88PNjY2aNeuHf7991+N28PDwzFy5Ej4+vpCLpfD29sbvXr1Umeiv78/rl69iiNHjqgzTVUGVYYfOXIEEyZMgIeHB3x9fQEADx48wIQJE1CnTh31NBkDBgzQyPt169ZhwIABAIAOHTqot587+//66y+0adMGdnZ2cHBwQPfu3XH16tWS7VwAaWlpmDNnDmrXrg1ra2t4e3ujb9++uHv3rnodbTIeKPp7Qtv9Dkg9nFTPzcnJCb169cr33a16f9+5c0c9OomjoyNGjhyJlJSUAsu1ZcsW1K9fHzY2NggKCsKVK1cASA2ONWvWhLW1Ndq3b5/vu7ek3xlPnjxB7969YW9vD3d3d7z77rv5hryOiYnBsGHDoFAo4OTkhJCQEFy6dAkymSzf8M83btxA//794eLiAmtra7z44ovYuXNnvv2W1+3bt9GvXz94eXnB2toavr6+GDRoEOLj44u9rzGqyHXNuLg4TJ06Ff7+/pDL5fD19cXw4cPV0z0cO3YM7u7u6gZvQGqsGDhwIMLDw3HkyBGt9wMzk5nJzGRmkv7FxcUV+Vlau3YtOnbsCA8PD8jlctSvXx+rVq0qcpuqLBRCYMWKFeosK628xw78/f0xe/ZsAIC7uztkMhnmzJmjXl9XOanNb9/cisu5y5cvY8SIEahevTqsra3h5eWFUaNGISYmJt+2CqsL5D2hKD09HdOmTYO7uzvs7OzQp08fnU3rRFRetH2/53bmzBl07doVjo6OsLW1Rbt27XDixAmNdbSpewFlr7/l3saJEye0+kwWd6xP2+dYnNzH51THuWxtbdGlSxc8evQIQgjMnz8fvr6+sLGxQa9evRAbG6uxjYLq28XVI3M/7tKlS9XHBa9duwZAuzpfYmIipkyZov7d4eHhgVdeeQUXLlzQWG/Lli1o1qwZbGxs4Obmhv/7v//DkydPNNYp67FHQPq+nDJlCqpWrQq5XI6aNWvi888/L/C4e1G0qV+qvvcKunAkKGJm6i8zcyuuTQPQ7vea6rkePXoUb775JlxdXaFQKDB8+HA8e/ZMY93ff/8d3bt3V7+2NWrUwPz58zV+U7Zv3x67d+/GgwcPCswFbeuvqhGTAgMDYW1tDXd3d3Tt2hXnzp0DALRr1w6NGzcucN/UqVMHwcHBuH//Ptzd3QEAc+fOVZcnd728tL9p89LmN4nqWEFBF32M0lcUo+rp/fTpUzRv3hxxcXEYO3Ys6tatiydPnmDr1q1YsGABWrdujQ0bNmDq1Kka99uwYQMcHBzQq1cvjeUDBw6Ev78/FixYgNOnT+Orr77Cs2fP8NNPPxVZjvDwcADSgcrcyzp06ICsrCx88MEHsLOzw7fffgsbGxuN+yYkJOCff/7BhAkT8OGHH2L58uVISkpCQEAA/ve//2HgwIFa74+rV6+iR48eaNSoEebNmwe5XI47d+6UKVCePXuGV199FQMHDsTgwYOxefNmjB8/HlZWVhg1ahQA4LvvvsNbb72F/v37qw/eXr58GWfOnMGQIUPQt29f3Lp1C7/88guWLFmi3k+qDyEgVbA2b96MSZMmwc3NTR0Oy5Ytw2uvvYahQ4ciIyMDv/76KwYMGIBdu3ahe/fuAID169djzJgxaN68OcaOHQsAqFGjBgBpHsuWLVuqD7K5u7vjr7/+wujRo5GQkFCiYSfWrVuHUaNGoUGDBpgxYwacnJxw8eJF/P333+rhQbds2YKUlBSMHz8erq6u+Oeff7B8+XI8fvw43/yZWVlZCA4Oxssvv4wvvvgCtra2JdrvqampaN++Pe7cuYNJkyYhICAAW7ZswYgRIxAXF4e3335b4/E2btyIxMREvPnmm5DJZFi4cCH69u2L//77D5aWlur1srOz0a1bN7Rt2xYLFy7Ehg0bMGnSJNjZ2eGjjz7C0KFD0bdvX6xevRrDhw9HUFAQAgICAEjDsu7YsQMDBgxAQEAAIiIi8M0336Bdu3a4du0afHx8NMr0v//9D2ZmZnj33XcRHx+PhQsXYujQoThz5ox6nVWrVmHSpElo06YNpk6divv376N3795wdnZWf4kD0pfDa6+9huPHj2Ps2LGoV68erly5giVLluDWrVtFzvk+Z84cLFiwQP0+SkhIwLlz53DhwgW88sor2rw9jIKhMlMIgZiYGGRlZeH27dv44IMPYG5urvFDraTvnY8//hheXl548803MX/+/FLtD3287j/99BMSExMxceJEpKWlYdmyZejYsSOuXLkCT09PAEC/fv1w9epVTJ48Gf7+/oiMjMS+ffvw8OFD+Pv7Y+nSpZg8eTLs7e3x0UcfAYD6vioTJkyAu7s7Zs2apT5R6uzZszh58iQGDRoEX19f3L9/H6tWrUL79u1x7do12Nraom3btnjrrbfw1Vdf4cMPP0S9evUAQP13/fr1CAkJQXBwMD7//HOkpKRg1apVePnll3Hx4kWtf9BlZ2ejR48eOHDgAAYNGoS3334biYmJ2LdvH/799191RmuT8SqFfU9ou9/379+Pbt26oXr16pgzZw5SU1OxfPlytG7dGhcuXMj33AYOHIiAgAAsWLAAFy5cwJo1a+Dh4YHPP/9cY71jx45h586dmDhxIgBgwYIF6NGjB9577z2sXLkSEyZMwLNnz7Bw4UKMGjUKBw8eVN+3JN8Z2dnZCA4ORosWLfDFF19g//79WLx4MWrUqIHx48cDkHKwZ8+e+OeffzB+/HjUrVsXv//+O0JCQvK9RlevXkXr1q1RpUoVdT1l8+bN6N27N7Zt21boyDMZGRkIDg5Geno6Jk+eDC8vLzx58gS7du1CXFwcHB0dC3tbGKWKXNdMSkpCmzZtcP36dYwaNQpNmzZFdHQ0du7cicePH8PNzQ3p6en56p4A1HWO8+fPa513zExmJjOTmUn6V9xnadWqVWjQoAFee+01WFhY4I8//sCECROgVCrVn6u82rZti/Xr12PYsGF45ZVXMHz4cJ2WeenSpfjpp5+wfft2rFq1Cvb29mjUqBEA3eVkSX/7apNz+/btw3///YeRI0fCy8sLV69exbfffourV6/i9OnT6hMDiqoLpKSkaPSSnDx5MpydnTF79mzcv38fS5cuxaRJk7Bp0yYd7Gki/Svu/V6QgwcPolu3bmjWrBlmz54NMzMz9cHwY8eOoXnz5gC0q3vlVtr6W27afCa1Odan7XPU1oYNG5CRkYHJkycjNjYWCxcuxMCBA9GxY0ccPnwY77//Pu7cuYPly5fj3XffLbLjjrb1SEBqpEhLS8PYsWMhl8vh4uKidZ1v3Lhx2Lp1KyZNmoT69esjJiYGx48fx/Xr19G0aVP1vhw5ciReeuklLFiwABEREVi2bBlOnDiBixcvanRYKMuxx5SUFLRr1w5PnjzBm2++iWrVquHkyZOYMWMGwsLCSjS3rjb1y3r16mH9+vUa94uLi8O0adPg4eGh9WOR6WFmlk9matOmUdLfa5MmTYKTkxPmzJmDmzdvYtWqVXjw4IH6JBfVc7W3t8e0adNgb2+PgwcPYtasWUhISMCiRYsAAB999BHi4+Px+PFjdYcIe3t7ACWrv44ePRrr1q1Dt27dMGbMGGRlZeHYsWM4ffo0XnzxRQwbNgxvvPEG/v33XzRs2FB9v7Nnz+LWrVuYOXMm3N3dsWrVKowfPx59+vRB3759AUBdLy/tb9qCaPObpG/fvvlGKjx//jyWLl1a/tkpjMjw4cOFmZmZOHv2bL7blEql+OabbwQAcf36dfXyjIwM4ebmJkJCQtTLZs+eLQCI1157TWMbEyZMEADEpUuXCi1Denq6qF+/vggICBCZmZnq5VOmTBEAxJkzZ9TLIiMjhaOjowAg7t27J4QQ4sKFCwKAcHV1FZ6enmLlypViw4YNonnz5kImk4m//vpL6/2xZMkSAUBERUUVus7atWs1Hl/l0KFDAoA4dOiQelm7du0EALF48WKN59ukSRPh4eEhMjIyhBBC9OrVSzRo0KDIsi1atKjAxxVCCADCzMxMXL16Nd9tKSkpGtczMjJEw4YNRceOHTWW29nZabymKqNHjxbe3t4iOjpaY/mgQYOEo6Njvu0XJi4uTjg4OIgWLVqI1NRUjduUSmWh5RVCiAULFgiZTCYePHigXhYSEiIAiA8++CDf+tru96VLlwoA4ueff1avl5GRIYKCgoS9vb1ISEgQQghx79499XssNjZWve7vv/8uAIg//vgjX7k+++wz9bJnz54JGxsbIZPJxK+//qpefuPGDQFAzJ49W70sLS1NZGdnazyfe/fuCblcLubNm6depnq/1atXT6Snp6uXL1u2TAAQV65cUT9vV1dX8dJLL2l8vtatWycAiHbt2qmXrV+/XpiZmYljx45pPP7q1asFAHHixAn1Mj8/P433S+PGjUX37t2FqTNUZoaFhQkA6ouvr6/YtGmTxjravneEEOLSpUvC3Nxc7NmzR6M8RWVfQbR53du1a6fxPlMJCQkRfn5+GmUFIGxsbMTjx4/Vy8+cOSMAiKlTpwohpM8TALFo0aIiH7dBgwYFPq4qw19++WWRlZWlcVtB+XPq1CkBQPz000/qZVu2bMmX90IIkZiYKJycnMQbb7yhsTw8PFw4OjrmW16UH374QQAQX375Zb7bisrMwjK+sO8Jbfe7EEKdoTExMeplly5dEmZmZmL48OHqZar306hRozQeq0+fPsLV1TVfueRyucZ3m+pz5OXlpc5hIYSYMWNGvu/Bkn5n5P0svPDCC6JZs2bq69u2bRMAxNKlS9XLsrOzRceOHQUAsXbtWvXyTp06icDAQJGWlqZeplQqRatWrUStWrXUy/LWDy5evCgAiC1btuQruymqyHXNWbNmCQDit99+K7BsQggxefJkYWZmJu7fv69x+6BBgwQAMWnSpKJ3QC7MzEMa6zIzJcxMZibphrafpYI+B8HBwaJ69eoaywrKYwBi4sSJJS5b3t9OBR07KKg+rsucLOlvX21yrqB9+csvvwgA4ujRo+plxdUFhHj+fdO5c2eN3J46daowNzcXcXFxWj9XIkMq7v2e9/OvVCpFrVq1RHBwcL46S0BAgHjllVc0luVVUN1LF/U3bT+T2hzrK8lzLI4qo9zd3TVyQVXvady4sUZ9f/DgwcLKykqj/pE337WpR6oeV6FQiMjISI11tK3zOTo6FvkdkpGRITw8PETDhg019uWuXbsEADFr1iz1srIee5w/f76ws7MTt27d0ijDBx98IMzNzcXDhw8LLWde2tYvc1MqlaJHjx7C3t6+wGPZVHkwMzWfb0mfY3FK0qah7e811XNt1qyZuo1FCCEWLlwoAIjff/9do8x5vfnmm8LW1lbjcbp3765xvENF2/rrwYMHBQDx1ltv5duGah/GxcUJa2tr8f7772vc/tZbbwk7OzuRlJQkhBAiKioqX2aWdB9pQ9vfJLlFRUWJatWqicDAQHV5y4vRDG+uVCqxY8cO9OzZEy+++GK+22UyGQYOHAhra2ts2LBBvXzPnj2Ijo7G//3f/+W7T94zoydPngwA+PPPPwstx6RJk3Dt2jV8/fXXsLB43lH+zz//RMuWLTXOXHF3d883hHVSUhIAaWi933//HePHj8eQIUNw4MABuLq64pNPPilqN2hQnTH3+++/l3g4l8JYWFjgzTffVF+3srLCm2++icjISJw/f179uI8fPy5wWAlttWvXDvXr18+3PHfvpGfPniE+Ph5t2rTJN3xOQYQQ2LZtG3r27AkhBKKjo9WX4OBgxMfHa7UdQDoLPDExER988EG++ctyDw2Xu7zJycmIjo5Gq1atIITAxYsX821X1dMkL232+59//gkvLy8MHjxYvZ6lpSXeeustJCUl5Ruy9PXXX4ezs7P6eps2bQBIPWzzGjNmjPp/Jycn1KlTB3Z2dhojD9SpUwdOTk4a95fL5TAzk2IkOzsbMTEx6mH2C9rXI0eO1DgzPm+Zzp07h5iYGLzxxhsan6+hQ4dqPBdAOjuzXr16qFu3rsZrrRrS9dChQ/keP/dzvHr1Km7fvl3oOsbOkJnp4uKCffv24Y8//sC8efPg5uamzj6Vkrx33nrrLXTr1g1dunQpwR7ITx+ve+/evVGlShX19ebNm6NFixbqfWJjYwMrKyscPnw437A5JfHGG2/A3NxcY1nu/MnMzERMTAxq1qwJJycnrbJu3759iIuLw+DBgzU+Q+bm5mjRokWRn6G8tm3bBjc3N/V7IrfCMrO4jC/sewIofr+HhYUhNDQUI0aMgIuLi3q9Ro0a4ZVXXinwe37cuHEa19u0aYOYmBgkJCRoLO/UqZNGL6UWLVoAkHqnOjg45FueOzNL+p1RUJlyb+/vv/+GpaUl3njjDfUyMzOzfJ/V2NhYHDx4EAMHDkRiYqL6tY6JiUFwcDBu376dbwg6FVWvxD179hR65rKpqOh1zW3btqFx48YFno2r+pyNGTMG5ubmGDhwIE6ePIm7d+9iwYIF2L59OwDkGxa6KMxMTcxMTcxMZibpRnGfpdyfg/j4eERHR6Ndu3b477//KtyQ+brMyZL+9i0u5wDNfZmWlobo6Gi0bNkSANS5qk1dILexY8dqLGvTpg2ys7Px4MEDrZ8rkaGU9P0OAKGhobh9+zaGDBmCmJgY9ec8OTkZnTp1wtGjR9XHJ0ta99JF/a24z6Q2x/pK8hy1NWDAAI3RXlT1nv/7v//TqO+3aNECGRkZhdYzAO3rkYBU38o96mZJ6nxOTk44c+YMnj59WmA5zp07h8jISEyYMEFjX3bv3h1169bF7t27892ntMcet2zZgjZt2sDZ2Vnj+6Vz587Izs7G0aNHCyxjQUpavwSA+fPnY9euXVi3bl2h9W0yfczM8svM4to0SvN7bezYsRoj344fPx4WFhaF1hVV223Tpg1SUlJw48aNYsutbf1127ZtkMlk6umCclPtV0dHR/Tq1Qu//PILhBAApOPnmzZtQu/evYudw70sv2kLUtLfJNnZ2Rg8eDASExOxffv2cp9z3mgavaOiopCQkKDRnT8vJycn9OzZU2NOgQ0bNqBKlSoacxuq1KpVS+N6jRo1YGZmlm+eA5VFixbhu+++w/z58/Hqq69q3PbgwYN82wOkL+vcVG+QgIAAdSUHkIZBUA23l5WVVehzzO31119H69atMWbMGHh6emLQoEHYvHlzmRrAfXx88r0Ja9euDQDq/fL+++/D3t4ezZs3R61atTBx4sQSD6muGqImr127dqFly5awtraGi4uLepgGbX7QR0VFIS4uDt9++y3c3d01LiNHjgQgzaugDdU8OEW93wDg4cOH6sqiav7Adu3aAUC+MltYWGgMz52bNvtd9R5TNRSqqIbczPvDulq1ahrXVV8WeQ8iq+aNyM3R0RG+vr75vrAdHR017q9UKrFkyRLUqlULcrkcbm5ucHd3x+XLlwt8zYork+o55B0Kw8LCIt9QeLdv38bVq1fzvdaq/VbUaz1v3jzExcWhdu3aCAwMxPTp03H58uVC1zdGhsxMKysrdO7cGT169MDHH3+MFStWYPTo0di1a5d6HW3fO5s2bcLJkyexePHiku6CfPTxuheU+7Vr11bvE7lcjs8//xx//fUXPD091UN5qYYu1lZBmZmamopZs2ap57RS7cO4uDitMlPVkNWxY8d8n6O9e/dqnZeAlJl16tTR+MFekJJkfGHfE0Dx+12VJXm/gwEpM1UV8Ny0zcy866kOXlStWrXA5bnvX5LvjIKy2dnZWWN7Dx48gLe3d74hqvJm6J07dyCEwMcff5zvtVZVsgt7vQMCAjBt2jSsWbMGbm5uCA4OxooVKyrcgXZdqOh1zbt37xZbL2nUqBE2btyIu3fvonXr1qhZsya++uor9ZB/qmG3tMHM1MTMZGYyM0kfivssnThxAp07d1bPu+ru7o4PP/wQQP7PgaHpMidL+tu3uJwDpIN/b7/9Njw9PWFjYwN3d3d1dqr2pTZ1gdy0zUKiiqik73fg+ec8JCQk3+d8zZo1SE9PV3+eSlr30kX9rbjPpDbH+kryHLVVlvpQXtrWI4H8+7Qkdb6FCxfi33//RdWqVdG8eXPMmTNHoyG6qG3VrVs3X06X5djj7du38ffff+d7PTp37gxA+2O9QMnql4B00uTcuXMxY8YM9OvXT+vHIdPDzCz7c9RWceUqze+1vHVFe3t7eHt7a9QVr169ij59+sDR0REKhQLu7u7qzg3aPAdt6693796Fj4+PxslHBRk+fDgePnyIY8eOAZCmJIuIiMCwYcOKLUtZftMWpKS/SWbOnImDBw9i48aNGtNulBejmtNbG8OHD8eWLVtw8uRJBAYGYufOnZgwYUK+N1tBCjojR2XdunV4//33MW7cOMycObPU5VPNU5t37kEA8PDwQGZmJpKTk7Wa783GxgZHjx7FoUOHsHv3bvz999/YtGkTOnbsiL1798Lc3LzQ55SdnV3q51CvXj3cvHkTu3btwt9//41t27Zh5cqVmDVrFubOnavVNgqab/LYsWN47bXX0LZtW6xcuRLe3t6wtLTE2rVrNQ4uF0bV2P9///d/Bc7NBzyf00AXsrOz8corryA2Nhbvv/8+6tatCzs7Ozx58gQjRozId/JB7p6t5SHv2V4qqrODiltPm/t/9tln+PjjjzFq1CjMnz8fLi4uMDMzw5QpUwo8+ULbMmlDqVQiMDAQX375ZYG35/3xkFvbtm1x9+5d/P7779i7dy/WrFmDJUuWYPXq1RpnnlYG+srM3Fq1agVvb29s2LABPXr0AKD9e2f69OkYMGAArKys1BWRuLg4AMCjR4+QkZGRb/7vwmjzustksgLfj2XJzClTpqBnz57YsWMH9uzZg48//hgLFizAwYMH8cILL2i1jYIyc/LkyVi7di2mTJmCoKAgODo6QiaTYdCgQVqd/KRaZ/369fDy8sp3uzY/okuipBlf0HPWJ31nZkm/MwrbXmmotv3uu+8iODi4wHXyNvrktnjxYowYMUL92XnrrbfUc1QXdjKXKavodc3+/fvjtddew6VLl5CdnY2mTZvi8OHDAJ6fUKcNZqYmZqYmZiYzk3SjqM/C3bt30alTJ9StWxdffvklqlatCisrK/z5559YsmSJzkZ705XyzsmSUo2CMn36dDRp0gT29vZQKpXo2rVrqfelLn/fEhkD1Wdl0aJFaNKkSYHrqE6yLGndSxf1N118JkvyHLVVluNuZVGW+uHAgQPRpk0bbN++HXv37sWiRYvw+eef47fffkO3bt1KvL2y7AOlUolXXnkF7733XoHravsbp6T1y3v37mHo0KF45ZVXSjQyK5EKM1Oiq8xUlausv9cKEhcXh3bt2kGhUGDevHmoUaMGrK2tceHCBbz//vsGqXcHBwfD09MTP//8M9q2bYuff/4ZXl5e6hN+iqLLfVTS3yQ7duzA559/jvnz56Nr165aPYauGU2jt7u7OxQKBf79998i1+vatSvc3d2xYcMGtGjRAikpKYWe/XD79m2Ns2Lu3LkDpVKZr0fp77//jjFjxqBv375YsWJFgdvy8/MrcPjHmzdvalz38fGBl5dXgcMHPH36FNbW1hpD/RXHzMwMnTp1QqdOnfDll1/is88+w0cffYRDhw6hc+fO6jNhVI1EKoUNt/X06VMkJydr9Dq+desWAGjsFzs7O7z++ut4/fXXkZGRgb59++LTTz/FjBkzYG1trXVjWG7btm2DtbU19uzZA7lcrl6+du3afOsWtH13d3c4ODggOztbqw9/UVRnoPz777+FBsCVK1dw69Yt/Pjjjxg+fLh6+b59+0r8eNrsdz8/P1y+fBlKpVLjwLpqeA0/P78SP25Zbd26FR06dMD333+vsTwuLg5ubm4l3p7qOdy5cwcdOnRQL8/KysL9+/c1TlqoUaMGLl26hE6dOpXq/ebi4oKRI0di5MiRSEpKQtu2bTFnzhyTafQ2ZGYWJC0tTePML23fO48ePcLGjRsLPMDftGlTNG7cGKGhocU+vkpxr7uzs3OBUwAUlpkF5f6tW7fy7ZMaNWrgnXfewTvvvIPbt2+jSZMmWLx4MX7++WcA2p9AkNvWrVsREhKi0Qs+LS0tX94Xtm1Vznl4eOgkM8+cOYPMzEyN4YJyK0nGF6e4/a7KkrzfwYCUmW5ubuU+tI4uvzNU/Pz8cOjQIaSkpGj0XLxz547GetWrVwcgDatU2tc6MDAQgYGBmDlzJk6ePInWrVtj9erVJvXjv6LXNWvUqFFs2VSsrKzw0ksvqa/v378fAEr8+jMzNcsEMDPLCzOTCPjjjz+Qnp6OnTt3avR4Kckw4eVJlzlZ0t++xeXcs2fPcODAAcydOxezZs0q9H7a1gWITEFp3u+qz7lCoSj2c65t3Uvf28hNm2N9JXmOhqBNPbIwJa3zeXt7Y8KECZgwYQIiIyPRtGlTfPrpp+jWrZvGtvKOeHXz5k2dHqOsUaMGkpKSyvx6lKR+mZqair59+8LJyQm//PJLuXZiooqJmVlxMrM0v9du376t0daQlJSEsLAw9Qh7hw8fRkxMDH777Te0bdtWvd69e/fybauwYwba1l9r1KiBPXv2IDY2tsje3ubm5hgyZAjWrVuHzz//HDt27Mg3rH1hZdHFb1qVkvwmuXXrFkJCQtC7d291T3BDMJrENjMzQ+/evfHHH3/g3Llz+W5XnelhYWGBwYMHY/PmzVi3bh0CAwML7d2b96Di8uXLAUDjjLWjR49i0KBBaNu2LTZs2FDol9yrr76K06dP459//lEvi4qK0pjzUeX111/Ho0ePNL5Uo6Oj8fvvv6Njx45af5HGxsbmW6Y6oyY9PR3A8+DJPb9JdnY2vv322wK3mZWVhW+++UZ9PSMjA9988w3c3d3RrFkzANJ85LlZWVmhfv36EEIgMzMTANSVpJKEqqpneu7eQffv38eOHTvyrWtnZ5dv2+bm5ujXrx+2bdtW4BdQVFSU1mXp0qULHBwcsGDBAqSlpWncpnqvqQIm99lPQggsW7ZM68dR0Wa/v/rqqwgPD8emTZs07rd8+XLY29urh+MpT+bm5vnO/tqyZUuJ5oTI7cUXX4Srqyu+++47jWH+N2zYkG94p4EDB+LJkyf47rvv8m0nNTU13zCcueV9D9vb26NmzZrqz40pMERmJicnFzh/5bZt2/Ds2TONOW+0fe9s37493+X1118HAPz0009YsmRJkfshN21e9xo1auDGjRsaeXHp0qVCp3DYsWOHRpn/+ecfnDlzRr1PUlJS8mVIjRo14ODgoPG4BWVacQrah8uXL8/Xw7KwPA4ODoZCocBnn32mzu7cSpKZ/fr1Q3R0NL7++ut8t+XOTG0zvjjF7Xdvb280adIEP/74o8bz/vfff7F37958w0aXB11+Z6gEBwcjMzNTIweVSmW+z6qHhwfat2+Pb775BmFhYfm2U9RrnZCQkG/alcDAQJiZmZlUZgIVv67Zr18/XLp0ST0/d0FlK8jt27exevVq9OjRo0Q9vZmZmttnZpYvZiZRwZ+D+Pj4Up38Uh50mZMl/e1bXM4VtC8BqKf/UNG2LkBkCkrzfm/WrBlq1KiBL774AklJSfluz/0517buVRRdbCM3bY71leQ5GoI29cjCaFvny87OzjdcrYeHB3x8fNT1mRdffBEeHh5YvXq1Rh3nr7/+wvXr19G9e/fSPsV8Bg4ciFOnTmHPnj35bouLi9N6mtCS1C/HjRuHW7duYfv27RpzC1PlxcysOJlZmt9r3377rUb9dNWqVcjKyiqyrpiRkYGVK1fm25adnV2BQ3prW3/t168fhBAFjpic9/UbNmwYnj17hjfffBNJSUnq4dZVVCdz5z1+UZbftHlp+5skKSkJffr0QZUqVfDjjz+WqrOCrhhNT29AGg537969aNeuHcaOHYt69eohLCwMW7ZswfHjx+Hk5ARAGnbyq6++wqFDh/D5558Xur179+7htddeQ9euXXHq1Cn8/PPPGDJkCBo3bgxA6qXy2muvQSaToX///tiyZYvG/Rs1aqQ+yPnee+9h/fr16Nq1K95++23Y2dnh22+/VZ/hkduMGTOwefNm9OvXD9OmTYOjoyNWr16NzMxMfPbZZ1rvj3nz5uHo0aPo3r07/Pz8EBkZiZUrV8LX1xcvv/wyAKBBgwZo2bIlZsyYoT575Ndffy20QuDj44PPP/8c9+/fR+3atbFp0yaEhobi22+/VZ9B2KVLF3h5eaF169bw9PTE9evX8fXXX6N79+7qXuqqhtqPPvoIgwYNgqWlJXr27FlkL5Hu3bvjyy+/RNeuXTFkyBBERkZixYoVqFmzZr592KxZM+zfvx9ffvklfHx81HOk/+9//8OhQ4fQokULvPHGG6hfvz5iY2Nx4cIF7N+/v8ATBQqiUCiwZMkSjBkzBi+99BKGDBkCZ2dnXLp0CSkpKfjxxx9Rt25d1KhRA++++y6ePHkChUKhbtwrKW32+9ixY/HNN99gxIgROH/+PPz9/bF161acOHECS5cuLdEIAbrSo0cPzJs3DyNHjkSrVq1w5coVbNiwQX02UUlZWVlhzpw5mDx5Mjp27IiBAwfi/v37WLduHWrUqKERlsOGDcPmzZsxbtw4HDp0CK1bt0Z2djZu3LiBzZs3Y8+ePRqNrLnVr18f7du3R7NmzeDi4oJz585h69atmDRpUqnKXVGVd2bevn0bnTt3xuuvv466devCzMwM586dw88//wx/f3+8/fbb6m1p+97p3bt3vnKoenZ369atRCMKaPO6jxo1Cl9++SWCg4MxevRoREZGYvXq1WjQoAESEhLybbNmzZp4+eWXMX78eKSnp2Pp0qVwdXVVD7t169YtdOrUCQMHDkT9+vVhYWGB7du3IyIiAoMGDVJvp1mzZli1ahU++eQT1KxZEx4eHgXOD5xbjx49sH79ejg6OqJ+/fo4deoU9u/fD1dXV431mjRpAnNzc3z++eeIj4+HXC5Hx44d4eHhgVWrVmHYsGFo2rQpBg0aBHd3dzx8+BC7d+9G69atC/whXZDhw4fjp59+wrRp0/DPP/+gTZs2SE5Oxv79+zFhwgT06tWrRBlfnOL2OyANrdStWzcEBQVh9OjRSE1NxfLly+Ho6Ig5c+aU6PF0QZffGSq9e/dG8+bN8c477+DOnTuoW7cudu7cqf6uy52ZK1aswMsvv4zAwEC88cYbqF69OiIiInDq1Ck8fvwYly5dKvAxDh48iEmTJmHAgAGoXbs2srKysH79evWJZqamItc1p0+fjq1bt2LAgAEYNWoUmjVrhtjYWOzcuROrV69Wb7N+/foYMGAAqlWrhnv37mHVqlVwcXHB6tWrS7QvmJnMTGYmM5MMq0uXLrCyskLPnj3VB7q+++47eHh4FHjwytAUCoXOcrKkv32LyzmFQoG2bdti4cKFyMzMRJUqVbB3794Ce+9oWxcgMgXFvd/zMjMzw5o1a9CtWzc0aNAAI0eORJUqVfDkyRMcOnQICoUCf/zxBwDt615F0cU2ctPmWF9JnqMhaFOPLIo2db7ExET4+vqif//+aNy4Mezt7bF//36cPXtW3YPU0tISn3/+OUaOHIl27dph8ODBiIiIwLJly+Dv74+pU6fq7DlPnz4dO3fuRI8ePTBixAg0a9YMycnJuHLlCrZu3Yr79+9rdWxI2/rl7t278dNPP6Ffv364fPmyRt3b3t6+wONUVDkwMytOZpb091pGRob6WMPNmzexcuVKvPzyy3jttdcASFNzOjs7IyQkBG+99RZkMhnWr19f6MkMmzZtwrRp0/DSSy/B3t4ePXv21Lr+2qFDBwwbNgxfffUVbt++rZ5q59ixY+jQoYPGMZcXXngBDRs2xJYtW1CvXj00bdpUoyw2NjaoX78+Nm3ahNq1a8PFxQUNGzZEw4YNS/2bNi9tf5PMnTsX165dw8yZM/H7779rbKNGjRoICgrS6vF0QhiZBw8eiOHDhwt3d3chl8tF9erVxcSJE0V6errGeg0aNBBmZmbi8ePH+bYxe/ZsAUBcu3ZN9O/fXzg4OAhnZ2cxadIkkZqaql7v0KFDAkChl9mzZ2ts9/Lly6Jdu3bC2tpaVKlSRcyfP198//33AoC4d++exrp3794Vffr0EQqFQtjY2IiOHTuKf/75p0T74sCBA6JXr17Cx8dHWFlZCR8fHzF48GBx69atfI/VuXNnIZfLhaenp/jwww/Fvn37BABx6NAh9Xrt2rUTDRo0EOfOnRNBQUHC2tpa+Pn5ia+//lpje998841o27atcHV1FXK5XNSoUUNMnz5dxMfHa6w3f/58UaVKFWFmZqaxDwCIiRMnFvicvv/+e1GrVi0hl8tF3bp1xdq1a9WvV243btwQbdu2FTY2NgKACAkJUd8WEREhJk6cKKpWrSosLS2Fl5eX6NSpk/j2229LtH+FEGLnzp2iVatWwsbGRigUCtG8eXPxyy+/qG+/du2a6Ny5s7C3txdubm7ijTfeEJcuXRIAxNq1a9XrhYSECDs7uwIfQ9v9rnpuI0eOFG5ubsLKykoEBgZqPI4QQty7d08AEIsWLcp3/7zv28LKpSpTXn5+fqJ79+7q62lpaeKdd94R3t7ewsbGRrRu3VqcOnVKtGvXTrRr1069nuqztGXLlgLLmvc5fPXVV8LPz0/I5XLRvHlzceLECdGsWTPRtWtXjfUyMjLE559/Lho0aCDkcrlwdnYWzZo1E3PnztV4P/r5+Wm8Rz755BPRvHlz4eTkJGxsbETdunXFp59+KjIyMvI9Z2NXnpkZFRUlxo4dK+rWrSvs7OyElZWVqFWrlpgyZYqIiorS2Ka2752CqMqTd5vF0fZ1//nnn0X16tWFlZWVaNKkidizZ48ICQkRfn5+6nVyf84WL14sqlatKuRyuWjTpo24dOmSer3o6GgxceJE9T5xdHQULVq0EJs3b9Z4zPDwcNG9e3fh4OAgAKj3wdq1awUAcfbs2XzP59mzZ+o8sLe3F8HBweLGjRv53u9CCPHdd9+J6tWrC3Nz83zZf+jQIREcHCwcHR2FtbW1qFGjhhgxYoQ4d+5cifZvSkqK+Oijj0RAQIA6e/v37y/u3r2rXkfbjC/se0Lb/a6yf/9+0bp1a3WG9+zZU1y7dk1jncLeT6p9n/v7u6ByFZa5BeVeWb8zCtpXUVFRYsiQIcLBwUE4OjqKESNGiBMnTggA4tdff9VY9+7du2L48OHCy8tLWFpaiipVqogePXqIrVu35iu36j3y33//iVGjRokaNWoIa2tr4eLiIjp06CD279+fr3ymoiLXNWNiYsSkSZNElSpVhJWVlfD19RUhISEiOjpavc6gQYNE1apV1XXDcePGiYiIiBLvB2YmM5OZycwk/dH2s7Rz507RqFEjYW1tLfz9/cXnn38ufvjhh3yft4Lq0EX97i5K3lzM+z4vqvyq9XWRkyX97Vtczj1+/Fj06dNHODk5CUdHRzFgwADx9OnTAr9vi6sLFPZ9U9C+Iqroinq/F/aevnjxoujbt6/6uKCfn58YOHCgOHDggHodbeteuqi/lfQzWdyxPm2fY3FKUu8p7HkUlO/F1SOLOi4oRPF1vvT0dDF9+nTRuHFj4eDgIOzs7ETjxo3FypUr821r06ZN4oUXXhByuVy4uLiIoUOH5vt9VNZjj0IIkZiYKGbMmCFq1qwprKyshJubm2jVqpX44osvSnQsT5v6pep1KOiS+zcOVU7MzPLPTCHyt2kIod3vNdVzPXLkiBg7dqxwdnYW9vb2YujQoSImJkZjeydOnBAtW7YUNjY2wsfHR7z33ntiz549+fZJUlKSGDJkiHBycsqXC9rUX4UQIisrSyxatEjUrVtXWFlZCXd3d9GtWzdx/vz5fOsuXLhQABCfffZZgfvt5MmTolmzZsLKyirfftJmH2lDm98kISEhhWZn3mMu+iYTwjTHZ3rhhRfg4uKCAwcO5Lttzpw5mDt3LqKioko17zARlS+lUgl3d3f07du3wOHMqeyYmUSmY8eOHejTpw+OHz+O1q1bG7o4Jou5SWQamJlERERERESmZ926dRg5ciTOnj1b6IiwFd2yZcswdepU3L9/X2NObSqc0czpXRLnzp1DaGgohg8fbuiiEFEJpaWl5Rs65KeffkJsbCzat29vmEKZOGYmkfFKTU3VuJ6dnY3ly5dDoVDkG/aIdIe5SWScmJlERERERERkDIQQ+P7779GuXTs2eJeAUc3pXZx///0X58+fx+LFi+Ht7Y3XX3/d0EUqtfDw8CJvt7GxgaOjYzmVxrRERUUhOzu70NutrKzg4uJSjiWi3E6fPo2pU6diwIABcHV1xYULF/D999+jYcOGGDBggKGLZ1JMJTNTU1MRHx9f5DouLi6wsrIqpxKZjoyMDPVcp4VxdHSEjY1NOZWI8po8eTJSU1MRFBSE9PR0/Pbbbzh58iQ+++wzvi56YAq5yczUH2ZmxcfMpMqsIhxjYE4SkSnIzs5GVFRUkevY29vD3t6+nEpEsbGxyMjIKPR2c3NzuLu7l2OJiEiFmVlyycnJ2LlzJw4dOoQrV67kmyNbVyrC7wN9MKlG761bt2LevHmoU6cOfvnlF1hbWxu6SKXm7e1d5O0hISFYt25d+RTGxLz00kt48OBBobe3a9cOhw8fLr8CkQZ/f39UrVoVX331FWJjY+Hi4oLhw4fjf//7Hw/A65ipZOamTZswcuTIItc5dOgQRwoohZMnT6JDhw5FrrN27VqMGDGifApE+XTs2BGLFy/Grl27kJaWhpo1a2L58uWYNGmSoYtmkkwhN5mZ+sPMrPiYmVSZVYRjDMxJIjIFjx49QkBAQJHrzJ49G3PmzCmfAhH69u2LI0eOFHq7n58f7t+/X34FIiI1ZmbJRUVFYciQIXBycsKHH36I1157TS+PUxF+H+iDyc7pbez2799f5O0+Pj6oX79+OZXGtJw4cSLf0Ia5OTs7o1mzZuVYIiIqi7CwMFy9erXIdZo1awZnZ+dyKpHpePbsGc6fP1/kOg0aNCi2kkREFQczU3+YmURUkVWEYwzMSSIyBWlpaTh+/HiR61SvXh3Vq1cvpxLR+fPn8ezZs0Jvt7GxQevWrcuxRESkwsysuCrC7wN9YKM3EREREREREREREREREREZLTNDF4CIiIiIiIiIiIiIiIiIiKi0TGpOb20olUo8ffoUDg4OkMlkhi4OEZWREAKJiYnw8fGBmRnP49E1ZiaRaWFm6hczk8i0MDP1i5lJZFqYmfrFzCQyLcxM/WJmEpmWkmRmpWv0fvr0KapWrWroYhCRjj169Ai+vr6GLobJYWYSmSZmpn4wM4lMEzNTP5iZRKaJmakfzEwi08TM1A9mJpFp0iYzK12jt4ODAwBp5ygUCgOXhojKKiEhAVWrVlV/tkm3mJlEpoWZqV/MTCLTwszUL2YmkWlhZuoXM5PItDAz9YuZSWRaSpKZla7RWzWchUKhYOARmRAOVaMfzEwi08TM1A9mJpFpYmbqBzOTyDQxM/WDmUlkmpiZ+sHMJDJN2mQmJ4wgIiIiIiIiIiIiIiIiIiKjxUZvIiIiIiIiIiIiIiIiIiIyWmz0JiIiIiIiIqKKTak0dAmIiIiIiIioAqt0c3pTxfb3v2G49Dge07vUgZlZ2eY0yc7ORmZmpo5KRoZiaWkJc3NzQxeDdCQlIwsL/76Jbg290KK6q6GLQ7kwM00DM5OocAeuR+DMvVi8F1wHFuZlO/eXmWkamJlG5O5B4K8PgP7fA16Bhi4NEVGFtuXcI+y5Go6ejX3Qq0kVQxeHSoj1TNNhZWUFMzP2OazwLv0KXP8DqNsDaDLY0KWhEmJmmg5dZSYbvalCmb/rOp7EpaJrAy80rupUqm0IIRAeHo64uDidlo0Mx8nJCV5eXpDJynYiBBnegeuRWHfyPq6FJWDzm0GGLg6BmWmKmJlEBVvw1w3ciUxC21rueLmWW6m2wcw0PcxMI3F+HRB9E9j9DjDyb4AHkImICnU7Mgn7r0fC19mWjd5GhPVM02NmZoaAgABYWVkZuihUlKibwI1dgMKHjd5GhJlpenSVmWz0pgolJjkdABCekIbGpdyGKuw8PDxga2vLA1hGTAiBlJQUREZGAgC8vb0NXCIqq4iENADA07hUA5eEVJiZpoOZSVS02OQMAMC96KRSN3ozM00HM9PIBC8Abu8HHp0BQjcATYcZukRERBWWv6sdAOB+TLKBS0IlwXqmaVEqlXj69CnCwsJQrVo1vp4VmcJH+pvw1LDloBJhZpoWXWYmG72pwkjPykZapjRPW1Rieqm2kZ2drQ47V1cOnWwKbGxsAACRkZHw8PDgEJRGLianwSEyIR1CCFZIDIyZaXqYmUQFE0IgPlUa8ux+TEqptsHMND3MTCPiWAVo/wGw72Ng3yygbnfA1sXQpSIiqpD83WwBAPej2ehtLFjPNE3u7u54+vQpsrKyYGlpaejiUGEUOSNiJDwxbDlIa8xM06SrzOSYYFRhqA5EAkB0UukavVXzN9ja2uqkTFQxqF5Pzs9h/KJzTmjJyFbiWQpfT0NjZpomZiZRfskZ2chWCgClPwDMzDRNzEwj0nI84F4PSI0FDsw1dGmIiCqsADepp/ejZ6nIzFYauDSkDdYzTZNqiN7s7GwDl4SKxJ7eRoeZaZp0lZls9KYKIyFXo3dpe3qrsPeoaeHraTpUPb0BIDw+zYAlodz4GTMtfD2J8st9cmVZh/rkZ8y08PU0IuaWQI8vpf/P/wg8OmvY8hARVVCeDtawtjRDtlLg8TNOLWZMWC8xLXw9jYSqp3dSJJCVUfS6VKHwM2ZadPV6stGbKoz41Cz1/2Vt9CaJv78/li5dauhiEKnF5BrFQTW/N1FFwcwkMl3xuUYXeRSbqu71TaXHzCSD8GsFNB4CQAC7pwHZWcXehYiosjEzkz2f15tDnJMRYj2z4pozZw5kMpnGpW7duurb09LSMHHiRLi6usLe3h79+vVDRESExjYePnyI7t27w9bWFh4eHpg+fTqysjTrdIcPH0bTpk0hl8tRs2ZNrFu3Tn9PytYVMLcCIICkcP09DpGeMDM1sdGbKgyNnt6lHN7cWOWtLOS9zJkzp1TbPXv2LMaOHVumsrVv3x5Tpkwp0zaIVKKTnp8xyUZvKi1mJhGVVO6e3hnZSoTFV55eT8xMMjmvzAOsHYHwy8C57w1dGiKiCknV6H2Pjd6kR6xnVk4NGjRAWFiY+nL8+HH1bVOnTsUff/yBLVu24MiRI3j69Cn69u2rvj07Oxvdu3dHRkYGTp48iR9//BHr1q3DrFmz1Ovcu3cP3bt3R4cOHRAaGoopU6ZgzJgx2LNnj36ekJkZ4OAt/c8hzkmPmJnlw8LQBSBS0cWc3sYqLCxM/f+mTZswa9Ys3Lx5U73M3t5e/b8QAtnZ2bCwKP7j6+7urtuCEpWBEELjsx3ORu8yO3QjEhcePsPUzrVhZlZ5hvRhZhJRSSWkac7X/CAmBb7OlWP+L2YmmRx7d6DTLGD3O8DBT4D6vQEHT0OXioioQvHPmde7rNO6EBWF9czKycLCAl5eXvmWx8fH4/vvv8fGjRvRsWNHAMDatWtRr149nD59Gi1btsTevXtx7do17N+/H56enmjSpAnmz5+P999/H3PmzIGVlRVWr16NgIAALF68GABQr149HD9+HEuWLEFwcLB+npSiChD3AEh4op/tE4GZWV7Y05sqjPg8c3oLUXmGnfTy8lJfHB0dIZPJ1Ndv3LgBBwcH/PXXX2jWrBnkcjmOHz+Ou3fvolevXvD09IS9vT1eeukl7N+/X2O7eYe2kMlkWLNmDfr06QNbW1vUqlULO3fuLFPZt23bhgYNGkAul8Pf319dIVFZuXIlatWqBWtra3h6eqJ///7q27Zu3YrAwEDY2NjA1dUVnTt3RnIyf5CZquSMbKRnKdXXIxIq18kt+jD3j6tYfvAOLj6KM3RRyhUzk5lJVFK565lA5er1xMxkZpqkZiMBnxeA9ARg70xDl4aIqMIJcJNO7qtMdR4qf6xnVs565u3bt+Hj44Pq1atj6NChePjwIQDg/PnzyMzMROfOndXr1q1bF9WqVcOpU6cAAKdOnUJgYCA8PZ+fsBgcHIyEhARcvXpVvU7ubajWUW2jIOnp6UhISNC4lIjCR/rLnt6kR8zM8slM9vSmCiP3wci0TCWS0rPgYG1Z5u0KIZCamV3m7ZSUjaU5ZDLd9bz84IMP8MUXX6B69epwdnbGo0eP8Oqrr+LTTz+FXC7HTz/9hJ49e+LmzZuoVq1aoduZO3cuFi5ciEWLFmH58uUYOnQoHjx4ABcXlxKX6fz58xg4cCDmzJmD119/HSdPnsSECRPg6uqKESNG4Ny5c3jrrbewfv16tGrVCrGxsTh27BgA6cymwYMHY+HChejTpw8SExNx7NixSnWyQ2UTk2cEBw5vXnZRidI+1eW+ZGZqYmYSmYaE1Lw9vXXzA4uZqYmZSeXGzBzo/iXwXUfgymag6TAgoK3uHyc7E0hLANLici7x0iU15//0RMDSBpArALlDnkuuZVaVY2QJIqo41HN6s6e30WI9UxPrmRVDixYtsG7dOtSpUwdhYWGYO3cu2rRpg3///Rfh4eGwsrKCk5OTxn08PT0RHi7NlR0eHq7R4K26XXVbUeskJCQgNTUVNjY2+cq1YMECzJ07t/RPjI3eRs9QmQnoNjeZmWXHRm+qMPIejIxKTNdJo3dqZjbqz9LTnB9FuDYvGLZWuvuIzZs3D6+88or6uouLCxo3bqy+Pn/+fGzfvh07d+7EpEmTCt3OiBEjMHjwYADAZ599hq+++gr//PMPunbtWuIyffnll+jUqRM+/vhjAEDt2rVx7do1LFq0CCNGjMDDhw9hZ2eHHj16wMHBAX5+fnjhhRcASIGXlZWFvn37ws/PDwAQGBhY4jKQ8cg7bUF4PBu9yyI9KxvJGVJlTpdTQjAzNTEziUyD6uRKK3MzZGQrcT8mRSfbZWZqYmZSuarSFHhpNHB2jTTU+bgTgIVV2bf7+BxwYhlw9xCQkVj27QGAVyOg3ftA3e6ADhsSiIgKE5AzvPmTZ6nIyFLCyoKDfRob1jM1sZ5ZMXTr1k39f6NGjdCiRQv4+flh8+bNBTZGl5cZM2Zg2rRp6usJCQmoWrWq9htw9M25I4c3N1aGykxAt7nJzCw71niowsg77GR0UoaBSlIxvfjiixrXk5KS8O6776JevXpwcnKCvb09rl+/rh5SpjCNGjVS/29nZweFQoHIyMhSlen69eto3bq1xrLWrVvj9u3byM7OxiuvvAI/Pz9Ur14dw4YNw4YNG5CSIh1kbty4MTp16oTAwEAMGDAA3333HZ49e1aqcpBxUH2mbSzNAQCRiWz0Lou4FM0pIUgTM5OIclPVM+t5OwDQXU9vU8HMJKPVcSZg6wZE3wJOryj9dpRK4NYeYO2rwJpOwPWdmg3eVg6AwhfwaAD4tQbqvAo0HgI0Hwu8MEyaV7xGJ8C3OeBeT1pX7gggp4E7/DKwaSjwTRvg+i6gkvQGIyLDcXeQw87KHEoBPIzVzcl+RKXBeqZpc3JyQu3atXHnzh14eXkhIyMDcXFxGutERESo5wD38vJCREREvttVtxW1jkKhKLRhXS6XQ6FQaFxKhD29qYJgZpYde3pThZG30VtXjTg2lua4Ni9YJ9sq6ePqkp2dncb1d999F/v27cMXX3yBmjVrwsbGBv3790dGRtEnC1haavael8lkUCqVhaxdNg4ODrhw4QIOHz6MvXv3YtasWZgzZw7Onj0LJycn7Nu3DydPnsTevXuxfPlyfPTRRzhz5gwCAgL0Uh4yrJicRu963g648DAO0UkZPOO8DJ6lPP+s67KnNzNTEzOTyDSo6pmNfJ1w6XE8HsSkQKkUMDMrW49LZqYmZiaVOxtnoMsnwI5xwJGFQMN+gFPhw/zlk5UB/LsVOPEVEHVdWmZmCTQaCLw0BnD2l4YpNy/loROlEkiJBs58A5xZDYRfkRq/vQKBdh+w5zcR6Y1MJoO/mx2uPk3Avehk1PSwN3SRqIRYz9TEembFlJSUhLt372LYsGFo1qwZLC0tceDAAfTr1w8AcPPmTTx8+BBBQUEAgKCgIHz66aeIjIyEh4cHAGDfvn1QKBSoX7++ep0///xT43H27dun3oZesNHb6BkqM1WPrSvMzLJjSwNVGKqDkeY5Bx+jdNQLVCaTwdbKotwvupz/piAnTpzAiBEj0KdPHwQGBsLLywv379/X62PmVa9ePZw4cSJfuWrXrg1zcynsLSws0LlzZyxcuBCXL1/G/fv3cfDgQQDSa9O6dWvMnTsXFy9ehJWVFbZv316uz4HKj6phtqaHPSzNpc8He3uXXmzy88qNLnt6MzP1h5lJZDjPe3orYGEmQ3qWEuEJZf8OYmbqDzOTtNZ4EFCtFZCZAvw9Q7v7pCUAJ5cDyxoDO8ZLDd5WDkCrt4Apl4HeK6Xh021dSt/gDQBmZoC9B9DpY2DKFaDNu4CV/fPGb/b8JiI98s8Z4vx+NEe4MUasZ+oP65ml9+677+LIkSO4f/8+Tp48iT59+sDc3ByDBw+Go6MjRo8ejWnTpuHQoUM4f/48Ro4ciaCgILRs2RIA0KVLF9SvXx/Dhg3DpUuXsGfPHsycORMTJ06EXC4HAIwbNw7//fcf3nvvPdy4cQMrV67E5s2bMXXqVP09MUUV6W9iOJCdpb/HIb0xVGbqOzeZmSXHnt5UYagORlZzscW96GRE6bDnoimqVasWfvvtN/Ts2RMymQwff/yx3s7WiYqKQmhoqMYyb29vvPPOO3jppZcwf/58vP766zh16hS+/vprrFy5EgCwa9cu/Pfff2jbti2cnZ3x559/QqlUok6dOjhz5gwOHDiALl26wMPDA2fOnEFUVBTq1aunl+dAhheT85l2d5DDw8EaT+JSEZGQDl9nWwOXzDhpDG/O6SCKxcwkqtwScuqZLnZWqJpT17wfkwwfJ8PNO1eRMTPJqMhkQPfFUgPyjV3A3pmAtSOQnQlkpUt/szOeXzJTpfm60+Ol+9t7AS3HAy+OlO6nL7YuUuN30ETg1Ir8Pb9fGCatl5kqlTsr56/6ehpgZgHU6yENr25uWfTjEVGlF+AqNXrf47QuVIGwnmncHj9+jMGDByMmJgbu7u54+eWXcfr0abi7uwMAlixZAjMzM/Tr1w/p6ekIDg5W71cAMDc3x65duzB+/HgEBQXBzs4OISEhmDdvnnqdgIAA7N69G1OnTsWyZcvg6+uLNWvWIDhYj7147dylepYyC0iOfN7zm8jAmJklx0ZvqjAS06SzqGq42+NedDKiE9mIU5Qvv/wSo0aNQqtWreDm5ob3338fCQkJenmsjRs3YuPGjRrL5s+fj5kzZ2Lz5s2YNWsW5s+fD29vb8ybNw8jRowAIM3r8ttvv2HOnDlIS0tDrVq18Msvv6BBgwa4fv06jh49iqVLlyIhIQF+fn5YvHgxunXrppfnQIYXndMz2c1eDi9HVaM3e3qXlsbw5pzTu1jMTKLKTXVypaONJfxcpUbvBzEpaFXDwAWroJiZZHQ860sN1yeXSxdtuNWWenY3GghYyPVbvtwKa/z+6z3t7n9ls3RgtslQoOlwwJVBRkQFY09vqohYzzRuv/76a5G3W1tbY8WKFVixYkWh6/j5+eUbvjyv9u3b4+LFi6UqY6mYmQMO3kD8I2mIczZ6UwXBzCw5mRCGG0fr6NGjWLRoEc6fP4+wsDBs374dvXv3LnT9w4cPo0OHDvmWh4WFwcvLS6vHTEhIgKOjI+Lj46FQKEpbdNKDhrP3ICk9C2+2q45vjvyHjnU98MOIl0q0jbS0NNy7dw8BAQGwtrbWU0mpvBX1uvIzrV+63L+vf3MKZ+7F4qvBL+Dvf8Pw55VwzO5ZHyNbV745j3Th64O38cXeWwAAKwsz3JzftcTD6TAzTRMz03C4fyuuFz/Zj+ikdPz5VhtsPvcI607ex5vtqmNGN+3PLmZmmiZmpuHofP9mpAAHPwFSY6Ve0OZywNxK+t9CnrPMSlruWhOo0VEaftzQUmKlOb/Dr0jltLCW/lra5Fy3eb48MQy49AuQFPH8/gHtgGYjgLo9AAsrgz0NImamfpVm/55/EIt+q07Bx9EaJ2d00nMJqSxYzzRNrGcaTqn27/ddgEdngIE/AfV76beAVCbMTNOkq8w0aE/v5ORkNG7cGKNGjULfvn21vt/Nmzc1npiHh4c+ikflKCtbiaT05z29Ad3OUUtEhhej6ultZwVPhfTFpYv5VCurZ7mGN8/IUiIxPQsKaw5zSUSUlxBCPby5o60l/F2laTUeRKcYslhEpGtWtkDXzwxdipKzdQE6aDkXOQB0nAnc2gOcXwfc2Q/cOyJdbN2AJoOBpiMAt5r6Ki0RGRH/nOHNn8anIS0zG9aW5gYuERFRBabq3Z3w1LDlIKIyMWijd7du3UrVjd3DwwNOTk66LxAZTELO0OYAG72JTJVqTm83Bzm8chq9I+LZ6F1az5I1p4CISkxnozcRUQHSMpXIyJbmvFJYW8BPNdQn57ckImNkbinN612vBxD3ELiwHri4XuoFrhre3ecFad7v2l2l+cJLOBoQEZkGFzsrOFhbIDEtCw9iUlDHy8HQRSIiqrgUVaS/CU8MWw4iKpMKMJZXyTVp0gTe3t545ZVXcOLEiSLXTU9PR0JCgsaFKh7VPIt2VubwcZIaw2KS06FUGmz0fSLSoaxspbpnsmuunt4RCTy5pbRyz+kNcF5vIqLCqOqZ5mYy2Mst1L2e7sckw4AzPRERlZ1TNaDjR8CUf4FBv0iN3DIz4OlF4NCnwDdtgCUNgd3vSr3Cs1hfJKpMZDIZAnJO9rvHeb2JiIrGnt5EJsGoGr29vb2xevVqbNu2Ddu2bUPVqlXRvn17XLhwodD7LFiwAI6OjupL1apVy7HEpC31kJM2lnC1kwMAMrOF+iAlERm32JxeyWYywMk2d6M3e3qXVu7hzQEgOimjkDWJiCo3VX1SYW0BmUwGX2cbmJvJkJapRCRPGCIiU2BuAdR9FRiyCZh2A3htOVCnuzQfeMJj4Ox3wM/9gIXVgU3DgNBfpLnEicjk5T7Zj4iIisBGbyKTYFSN3nXq1MGbb76JZs2aoVWrVvjhhx/QqlUrLFmypND7zJgxA/Hx8erLo0ePyrHEpC31wUgbS1hZmMHJVhqiNyqJByKJVI4ePYqePXvCx8cHMpkMO3bsKPY+hw8fRtOmTSGXy1GzZk2sW7dO7+UsiKpB1sVODnMzGbwcn8/pzV52paPq6e3hIJ0oFJXIEwiIiAoSn+vkSgCwNDeDr7MNAOA+ez0Rkalx8ASaDgcGbwTevwcM2Qw0GwHYewEZScD1ncCOccDiOsCWkcDdg4BSaehSE5Ge+KumdWGdh4ioaBzenMgkGFWjd0GaN2+OO3fuFHq7XC6HQqHQuFDFk7vRGwDc7VWNOGz0JlJJTk5G48aNsWLFCq3Wv3fvHrp3744OHTogNDQUU6ZMwZgxY7Bnzx49lzS/mOSc+bztrQAAngrpM56SkY2k9KxyL48pUM3pXcvTHgB7ehMRFSYhT6M3APjl9Hp6EJNikDIREZULSxugdjDQcxkw7TrwxiGg7XuAZ0MgOwO4+huwvg/wVWPg8OdA/GNDl5iIdCzAzRYAhzcnIiqWuqd3GE8IJDJiFoYuQFmFhobC29vb0MWgMsrbA8fdQY7bkUmIZk9vIrVu3bqhW7duWq+/evVqBAQEYPHixQCAevXq4fjx41iyZAmCg4P1VcwCqT7LrjmN3rZWFnCwtkBiWhYiEtLgYG1Z1N0pj6xsJRLSpJMFank44MSdGJ4kRERUiLwnVwKAv6stjoJDfRJRJWJmBlRpKl06fgSEXQIurAcubwbiHgKHPwMOLwBqdgJeGAbUeRWwsDJ0qYmojDi8ORGRluw9AZkZoMwEUqIBew9Dl4iISsGgjd5JSUkavbTv3buH0NBQuLi4oFq1apgxYwaePHmCn376CQCwdOlSBAQEoEGDBkhLS8OaNWtw8OBB7N2711BPgXQkb6O3G3t6E5XZqVOn0LlzZ41lwcHBmDJlSrmXJSanF7KXjQD2zgTq9oSnwhqJaUmISEhHTQ+Hci+TMYvLyUyZDKjpoerpzbwkIipI3nom8LynNw8AE1Gl5d0Y6N4Y6DIfuP4HcOEn4P4x4M5+6WLrJvUSN7MAlNmAyAaUWbkuOddl5kCNDkCDvoC9u6GfFRHlEZAzvHlEQjpSMrJga2X0/Z+IiPTD3FJq+E4Mk4Y4Z6M3kVEyaE3n3Llz6NChg/r6tGnTAAAhISFYt24dwsLC8PDhQ/XtGRkZeOedd/DkyRPY2tqiUaNG2L9/v8Y2yDglpOXv6Q2w0ZuoLMLDw+Hp6amxzNPTEwkJCUhNTYWNjU2++6SnpyM9/fnnLiEhQSdlUQ293SrrH+DkcuDJRXgpZuFOZBLC4zkXdUnF5czn7WhjCU+FND86G72JiApWWE9vALgfzeHNiaiSs7QBGg2ULjF3gdANwMUNQFK49L82bv0F/D0DqNlZ2k6dVwErW/2Wm4i04mRrBSdbS8SlZOJ+dArq+3DaRyKiQil8chq9nwI+Lxi6NERUCgZt9G7fvj2EEIXevm7dOo3r7733Ht577z09l4oMIe9ci2z0Lp327dujSZMmWLp0qaGLQkZqwYIFmDt3rs63q2qQ9UGEtCD+ETx9pMba8AQ2epdUbLKUmc62Vup50pmXJcfMNG1Hjx7FokWLcP78eYSFhWH79u3o3bt3kfc5fPgwpk2bhqtXr6Jq1aqYOXMmRowYUS7lJf0pqKe3v5tqTu9kCCEgk8kMUjZjwswkqgRcawCdZgHtP5R6e4eFSj25zcylHt/qS65lKbHA1e3A0wvA7T3SxcoBqP+a1ADu30Zal4gMxt/VDqEpcbgfk8xGb6qQWM+kCkPhAzw5LzV6E1VQzMyimRm6AERArh441tJ5GO6q4c0rSc/Fnj17omvXrgXeduzYMchkMly+fLnMj7Nu3To4OTmVeTtkHLy8vBAREaGxLCIiAgqFosBe3gAwY8YMxMfHqy+PHj3SSVlicj7L7tnR0oLEcHg6SI21kWz0LrFnOT29nWwt1ScJRSdlFHkimSlhZpI2kpOT0bhxY6xYsUKr9e/du4fu3bujQ4cOCA0NxZQpUzBmzBjs2bNHzyUlfct7ciUA+DrbwEwGJGdkq0cjMVXMTCIqMXMLoE5XoP0HQLvpQJtpQOu3gKAJQIuxwEujgWYjgBf+T1o+9hAw8SzQdjrgVA3ISJR6if/UC1jSQJre6GJOD/LQjUDoL8ClX3Mum6R5xS9vkXqaE5HOVc852e9eNKd1Id1iPZNMjqKK9DfhiWHLQSaJmVk+OJELVQjqHji2OXN6V7Ke3qNHj0a/fv3w+PFj+Pr6aty2du1avPjii2jUqJGBSkfGKigoCH/++afGsn379iEoKKjQ+8jlcsjlcp2XJSY5ZzjurChpQXY6qtlKy9jTu+Se5exPF1sruOWcJJSRrURCapY6R00ZM5O00a1bN3Tr1k3r9VevXo2AgAAsXrwYAFCvXj0cP34cS5YsQXBwsL6KSeWgoJ7ecgtz+DjZ4PGzVDyISVafQGSKmJlEVC7cawMdZ0q9xB+dAS5vknqAJ4ZJ0xtpw8wCGPkXULW5fstKVMn4s9Gb9IT1TDI5Ch/pbzwbvUn3mJnlgz29qULIezBS1dO7ssxR26NHD7i7u+cb0j8pKQlbtmzB6NGjERMTg8GDB6NKlSqwtbVFYGAgfvnlF52W4+HDh+jVqxfs7e2hUCgwcOBAjZ7Cly5dQocOHeDg4ACFQoFmzZrh3LlzAIAHDx6gZ8+ecHZ2hp2dHRo0aJCvwZXKJikpCaGhoQgNDQUg9UoMDQ3Fw4cPAUi9tIcPH65ef9y4cfjvv//w3nvv4caNG1i5ciU2b96MqVOnlnvZY3J60dmlhauXVbWMBwCEJ1SOz7kuPUuRMtPJ1grWluZwyBklo7KMjsHMJH04deoUOnfurLEsODgYp06dMlCJSFcS0vI3egPSUJ+A6R8AZmYSUbkyMwP8goCeS4F3bwGv/wwEDgRqdQFqviLN+12jE1Cjo3Sp3gGo3h5wqwMos4Cto4HUZ4Z+FkQmRdXofd/E6zxU/ljPJJOj7unN4c1J95iZ5YM9valCSEjNApB/Tu+Y5AxkZSthYV6G8zOEADJTylzGErO0BbScH9LCwgLDhw/HunXr8NFHH6nnldyyZQuys7MxePBgJCUloVmzZnj//fehUCiwe/duDBs2DDVq1EDz5mU/E16pVKrD7siRI8jKysLEiRPx+uuv4/DhwwCAoUOH4oUXXsCqVatgbm6O0NBQWFpKr9nEiRORkZGBo0ePws7ODteuXYO9vX2Zy0XPnTt3Dh06dFBfnzZtGgAgJCQE69atQ1hYmLoBHAACAgKwe/duTJ06FcuWLYOvry/WrFlT7j0WhRDqxlh5Sph6uZcsDoA5hzcvhbic4c1d7J6fKJSYloXopHTU9Cjj546ZqRVmpukJDw+Hp6enxjJPT08kJCQgNTW1wGkh0tPTkZ7+/GSThIQEvZeTSq6gnt4A4Odqi+N3gAcxZcg8ZqZWmJlElZSFHKjXU7oUJy0B+KYt8OwesHMyMHC91jlHREULyDnR734MG72NCuuZWmE9k3RK1dObw5sbH0NlJqB1bjIzywcbvalCUB+MlJsB6YlwsbOHmQxQCiA2JQMeDtal33hmCvCZj45KWgIfPgWs7LRefdSoUVi0aBGOHDmC9u3bA5CGtejXrx8cHR3h6OiId999V73+5MmTsWfPHmzevFkngXfgwAFcuXIF9+7dQ9WqVQEAP/30Exo0aICzZ8/ipZdewsOHDzF9+nTUrVsXAFCrVi31/R8+fIh+/fohMDAQAFC9evUyl4k0tW/fvsg5m/OeJaa6z8WLF/VYquIlpWchI0sJOTJgnva814abiAHggcjEdGQrBczNeFBLW7HJqjm9pXnR3ezl+C86WTdTQjAztcLMJABYsGAB5s6da+hiUDEKa/QOcNPBAWBmplaYmURULGsF0P8H4PsuwPU/gLNrgOZvGLpURCbB380WABCdlIHEtEw4WJv+lFgmgfVMrbCeSWV17n4sTt6NwYv+zmjlomr0fio1ovIEPONhqMwESpSbzEz94/DmZHBKpVAPO1l1z2hgcV2Yp8bAxa5yzetdt25dtGrVCj/88AMA4M6dOzh27BhGjx4NAMjOzsb8+fMRGBgIFxcX2NvbY8+ePRo9e8vi+vXrqFq1qjrsAKB+/fpwcnLC9evXAUg9i8eMGYPOnTvjf//7H+7evate96233sInn3yC1q1bY/bs2bh8+bJOykXGTzW0eXWrOI3l9hlRMJMB2UqBmEoyLLeuqIY3d85p9FaNjlFZpoQAmJmke15eXhrDOQFAREQEFApFgb28AWlaifj4ePXl0aNH5VFUKiFVo7fCOm9Pb+lHaZl6ehsJZiYRGYUqTYFX5kn/7/kICONnnUgXHKwt4WYv/Xa8H2369R4qX6xnkrH780o4vtx3C/uvRQIO3tLC7HQgJdawBSOTxMzUP/b0JoNLTM+CqvOqVdhZICMJiLgKdwc5opPSy97obWkrnW1T3ixtS3yX0aNHY/LkyVixYgXWrl2LGjVqoF27dgCARYsWYdmyZVi6dCkCAwNhZ2eHKVOmICMjQ9clL9ScOXMwZMgQ7N69G3/99Rdmz56NX3/9FX369MGYMWMQHByM3bt3Y+/evViwYAEWL16MyZMnl1v5qGJSNcTWsUkAcn2czZMj4GbfFJGJ6YhISIeHogwjOlQyz/IMb646gKGTk4SYmTrDzDQuQUFB+eYh2rdvH4KCggq9j1wuh1wu13fRqAzSs7KRlqkEUNCc3lLu3I9JhhBCPbRYiTAzdYaZSUQAgJbjgXtHgVt/AVtHAmOPAPKKNWQikTHyd7VDdFIG7sUkI9DX0dDFIW2wnqkzrGdSUep4SfWMWxGJ0tQsdu5AcpQ0xLmdq4FLR1ozVGaqHrsEmJn6xZ7eZHAJOb1v7CyUkKXFSwtTotU9F8vciCOTScNLlPelFAdOBw4cCDMzM2zcuBE//fQTRo0apT4Ae+LECfTq1Qv/93//h8aNG6N69eq4detW2fZNLvXq1cOjR480eqldu3YNcXFxqF+/vnpZ7dq1MXXqVOzduxd9+/bF2rVr1bdVrVoV48aNw2+//YZ33nkH3333nc7KR8YrWt3TO17zhsRweDlKDd3hnNe7RFSN3k766OnNzNQKM7PiS0pKQmhoKEJDQwEA9+7dQ2hoqPrs2BkzZmD48OHq9ceNG4f//vsP7733Hm7cuIGVK1di8+bNmDp1qiGKTzqi6uUtkwEO1prn+1Z1sYVMBiSmZamnjSgxZqZWmJlEpDWZDOi9ElBUAWLuAH++W/x9iKhY/qppXaI5r7fRYD1TK6xnUlnV9nQAANyMSJQWKHINcU7Gw1CZWYrcZGbqF3t6k8GpDkZWs04DsnIWJsfA3b4mgOcNZpWBvb09Xn/9dcyYMQMJCQkYMWKE+rZatWph69atOHnyJJydnfHll18iIiJCI4y0kZ2drW4AUJHL5ejcuTMCAwMxdOhQLF26FFlZWZgwYQLatWuHF198EampqZg+fTr69++PgIAAPH78GGfPnkW/fv0AAFOmTEG3bt1Qu3ZtPHv2DIcOHUK9evXKukvIBMQkSw2xVS1y5vO2dgLS4oDEMHg4WAOIRwQbvUskLmd4cxe753N6A5UrLwFmJhXt3Llz6NChg/r6tGnTAAAhISFYt24dwsLCNIaHCggIwO7duzF16lQsW7YMvr6+WLNmDYKDg8u97KQ7qpMrHeQWMDPT/CFqbWkOb4U1nsan4X5MClztTbvXPjOTiIyGrQvQbw2wrjtw6RcgoB3QZLChS0Vk1ALY6E16xHomGTNVo3dUYjpikzPgoqgChF2SenoT6QEzU7/Y05sMTnUw0lee+nxhchTcHHQ4XK8RGT16NJ49e4bg4GD4+Piol8+cORNNmzZFcHAw2rdvDy8vL/Tu3bvE209KSsILL7ygcenZsydkMhl+//13ODs7o23btujcuTOqV6+OTZs2AQDMzc0RExOD4cOHo3bt2hg4cCC6deuGuXPnApCCdOLEiahXrx66du2K2rVrY+XKlTrZJ2TcohOlhlgfWYy0wPdF6W9CGLwcpQYGNnprT6kUiFP39JaG6tXZyBhGiJlJhWnfvj2EEPku69atAwCsW7cOhw8fznefixcvIj09HXfv3tX44UHGKT5VOqPS0daywNtVvZ4exFSOA8DMTON39OhR9OzZEz4+PpDJZNixY4fG7SNGjIBMJtO4dO3aVWOd2NhYDB06FAqFAk5OThg9ejSSkpI01rl8+TLatGkDa2trVK1aFQsXLsxXli1btqBu3bqwtrZGYGBgvikiiMrErxXQ/kPp/93vANG3DVseMlmrVq1Co0aNoFAooFAoEBQUhL/++kt9e1paGiZOnAhXV1fY29ujX79+iIiI0NjGw4cP0b17d9ja2sLDwwPTp09HVlaWxjqHDx9G06ZNIZfLUbNmTXWdtLz4u0p1nnuVpM5D5Y/1TDJWdnILVHWxAQDcDE9kT28qF8xM/WFPbzI4VU9vb6sUQFX3TomGe05jWJQuhus1IkFBQRCqSc5zcXFxyXdQK6+8B+/zGjFiRJEH8KtVq4bff/+9wNusrKzwyy+/FHrf5cuXF/nYVHmpenq7KaOlBVVeBO7sB5Ii4O0gNUKEx7PRW1sJaZlQ5kSEk03ent6VKy8BZiYRFU11cmXe+bxV/FztcPJuDO7HpJRnsQyGmWn8kpOT0bhxY4waNQp9+/YtcJ2uXbtqDD8nl2uOYjB06FCEhYVh3759yMzMxMiRIzF27Fhs3LgRAJCQkIAuXbqgc+fOWL16Na5cuYJRo0bByckJY8eOBQCcPHkSgwcPxoIFC9CjRw9s3LgRvXv3xoULF9CwYUM9PXuqdNpMA+4fleb43jICGHMAsLQ2dKnIxPj6+uJ///sfatWqBSEEfvzxR/Tq1QsXL15EgwYNMHXqVOzevRtbtmyBo6MjJk2ahL59++LEiRMApIO/3bt3h5eXF06ePImwsDAMHz4clpaW+OyzzwBI0+x0794d48aNw4YNG3DgwAGMGTMG3t7e5TaqkL+bNN8oe3qTvrCeScasjqcDHsWm4lZEIoLY6E3lgJmpP2z0JoNTNXp7WuSqeCdHw91X1XORjWFExiwmZ8ht56woaYHPCwBkgMhG1ZwRHiIqYQ/l0lLNO+sgt4CVhTRgi1uuOb2FEOp5YIiIKrv4Yhq9/V2lA8CVpac3Gb9u3bqhW7duRa4jl8vh5eVV4G3Xr1/H33//jbNnz+LFF6XRd5YvX45XX30VX3zxBXx8fLBhwwZkZGTghx9+gJWVFRo0aIDQ0FB8+eWX6kbvZcuWoWvXrpg+fToAYP78+di3bx++/vprrF69WofPmCo1M3Og73fAqtZAxL/A3o+A7osNXSoyMT179tS4/umnn2LVqlU4ffo0fH198f3332Pjxo3o2LEjAGDt2rWoV68eTp8+jZYtW2Lv3r24du0a9u/fD09PTzRp0gTz58/H+++/jzlz5sDKygqrV69GQEAAFi+W3r/16tXD8ePHsWTJkvJr9M7p6f0sJRPxKZmFjoJDRFQZ1fZ0wP7rkdK83tWrSAs5vDmRUeLw5mRwqoORHua5htRLiVEP11vZ5qglMjWq0Rrs03OGgHOqBth7AAB8LeIAABHs6a21ZznzeTvZPT9I4WYv9fjOzBbqTCUiouIbvf1cOb8lmZ7Dhw/Dw8MDderUwfjx4xETE6O+7dSpU3ByclI3eANA586dYWZmhjNnzqjXadu2LaysrNTrBAcH4+bNm3j27Jl6nc6dO2s8bnBwME6dOqXPp0aVkYMX0Pcb6f+za4BrBfdKIdKF7Oxs/Prrr0hOTkZQUBDOnz+PzMxMjbyrW7cuqlWrps67U6dOITAwEJ6enup1goODkZCQgKtXr6rXMXRm2skt4JFznI1DnBMRaarjJc3rfSs8EVCoGr3Z05vIGLHRmwwuIU06GOkqS3y+MDkK7vaVd45aIlMSk5QOG6TBKjNeWuBYRTp4BcBTFgcACOec3lpTzeftYvv8QLTcwhwKa2nwlso4xDkRUWFUjd4K68Lm9M4Z6rOSDG9Opq9r16746aefcODAAXz++ec4cuQIunXrhuzsbABAeHg4PDw8NO5jYWEBFxcXhIeHq9fJ3XgDQH29uHVUtxckPT0dCQkJGhcirdTsDLSeIv3/+2QgdCOQxTov6c6VK1dgb28PuVyOcePGYfv27ahfvz7Cw8NhZWUFJycnjfVz511ZMjMhIQGpqakFlkkfmenvxpP9iIgKomr0vhmRCJF7ePMChp8mooqNjd5kcKqDkU7I3egdre7pHZ+aifSsbEMUjYh0ICY5A96yWOmKlQNg7Qg4eAMAXLKleb7jUzORlsnPuTZUw5s75Wr0BqDOzEieKEREpFZsT28XO/V6qpOKiIzZoEGD8NprryEwMBC9e/fGrl27cPbs2WLnfSsPCxYsgKOjo/pStWpVQxeJjEnHmUDVFkB6PLBjPLCkAXDwUyCx8BMtCpSVAdw9BOybBZxfB2Rn6aW4ZFzq1KmD0NBQnDlzBuPHj0dISAiuXbtm0DLpIzMDcka4ucdGbyIiDdXd7GFhJkNiWhbChLO0MDMZSIs3bMGIqMTY6E0GF58q/chUiFxnraY+g6PcDJbm0ry0HOKcyDhlZisRl5IJb1nOsJqqsyVzGr2t0yJhbSl9FUWwt7dW4nKGN3fOMwebmz2nhCAiykvd07uQRm8bK3N4KawBsLc3mabq1avDzc0Nd+7cAQB4eXkhMjJSY52srCzExsaq5wH38vJCRESExjqq68WtU9hc4gAwY8YMxMfHqy+PHj0q25OjysXcEvi/bUCn2dKwo8lRwNGFwJKGwLY3gMfnC79vWgLw7zZg62hgUU1gfW/gxDLgj7eBNR2BJxfK7WlQxWRlZYWaNWuiWbNmWLBgARo3boxly5bBy8sLGRkZiIuL01g/d96VJTMVCgVsbGwKLFOZMvOf74AfugEXN2gsVvf05vDmREQarCzMEJCTkTdjsgAbF+kGDnFOZHTY6E0GpzoYaZ8dl2upgCz1mXqI8+gS9lwUHHrEpPD1NF6qXslVzKT5H+GYMy9OTqO3LClc3dgQkcAeytqIzemJ6Gyn2dPbzaF0eQnwM2Zq+HoSPZdQTE9vAPBzlYY4f6DlAWB+xkyLqb+ejx8/RkxMDLy9pbpXUFAQ4uLicP788wbCgwcPQqlUokWLFup1jh49iszMTPU6+/btQ506deDs7Kxe58CBAxqPtW/fPgQFBRVaFrlcDoVCoXEhKhG5A9BmGvD2JWDAOqBqS0CZCVzZLDVer+kMXNkKZGcC8Y+lhr/1fYCF1YGto4B/t0o9xe3cgcAB0ghUYZeANZ2AP9+TGseJACiVSqSnp6NZs2awtLTUyLubN2/i4cOH6rwLCgrClStXNE4o2rdvHxQKBerXr69ep1wzM/4R8PAkEBaqsVjVoMOe3hWXqddLKhu+nsaF83obH37GTIuuXk82epPBqQ5G2mbmGS4kOUrdiKPtvN6WltIBzZQU9tQxJarXU/X6kvFQzS9d3SpOWqCqNObM6Y3EcHjkNHpzXm/tqIbfdba1Ao4slM7gT09SnyQUVYI5vZmZpomZSfRcccObA4C/lkN9MjNNk7FlZlJSEkJDQxEaGgoAuHfvHkJDQ/Hw4UMkJSVh+vTpOH36NO7fv48DBw6gV69eqFmzJoKDgwEA9erVQ9euXfHGG2/gn3/+wYkTJzBp0iQMGjQIPj7SiDxDhgyBlZUVRo8ejatXr2LTpk1YtmwZpk2bpi7H22+/jb///huLFy/GjRs3MGfOHJw7dw6TJk0q931ClZC5JdCgDzB6DzD2MNB4MGBuBTw+C2wbDSysIQ1//ue7wN2DUsO4ay2g9dvAqL3AOzeBfmuASeeAwIGAUAL/fAOsaA5c3cH5OyuZGTNm4OjRo7h//z6uXLmCGTNm4PDhwxg6dCgcHR0xevRoTJs2DYcOHcL58+cxcuRIBAUFoWXLlgCALl26oH79+hg2bBguXbqEPXv2YObMmZg4cSLkcuk32rhx4/Dff//hvffew40bN7By5Ups3rwZU6dO1c+Tcq0p/Y2+rbE4d6M3GwoqFtYzTVNGhnT8xtzc3MAl0Y///e9/kMlkmDJlinpZWloaJk6cCFdXV9jb26Nfv375Rrp4+PAhunfvDltbW3h4eGD69OnIytKcbuTw4cNo2rQp5HI5atasiXXr1un9+dTxzJnXOzzx+UiVCU/0/rhUcsxM06SrzLTQRWGIykLV6C3PfKZ5Q0o03O2lYZ60bcQxNzeHk5OT+gxbW1tbyGQy3RWWypUQAikpKYiMjISTk5PJVhJNWUzOUNvVLJ4BGcjV6C31NkJiGLwcc3p6x7PRWxvPknOGN7ezAo6sAlJjgQcn4O5QA0DJenozM00LM5MoP20avf3cVD29i/7BzMw0LcaamefOnUOHDh3U11UN0SEhIVi1ahUuX76MH3/8EXFxcfDx8UGXLl0wf/58dcMLAGzYsAGTJk1Cp06dYGZmhn79+uGrr75S3+7o6Ii9e/di4sSJaNasGdzc3DBr1iyMHTtWvU6rVq2wceNGzJw5Ex9++CFq1aqFHTt2oGHDhuWwF4hy8XkB6LMaeGUecG4tcO57ICkCgAyo2hyo8ypQtzvgViv/fe09gH7fAU2GALunAbH/AVtCgFpdgFe/AJz9yv3pUPmLjIzE8OHDERYWBkdHRzRq1Ah79uzBK6+8AgBYsmSJOivT09MRHByMlStXqu9vbm6OXbt2Yfz48QgKCoKdnR1CQkIwb9489ToBAQHYvXs3pk6dimXLlsHX1xdr1qxRn5Ckc6457/eYOxqLVaPbJKZlITY5A6728rz3JANhPdP0KJVKREVFwdbWFhYWptcEc/bsWXzzzTdo1KiRxvKpU6di9+7d2LJlCxwdHTFp0iT07dsXJ06cAABkZ2eje/fu8PLywsmTJxEWFobhw4fD0tISn332GQDppM7u3btj3Lhx2LBhAw4cOIAxY8bA29tbf7kJoHZOT++bEYlAgKrRmz29KyJmpunRZWaaXuKS0VEdjLRMz2n0dvABEp8CydFwd5DOTtW2pzfwfM6kvHPVkfFycnIqcn5AqrhUPb19zGKlBY55enonhMGzqvRDm3N6a0c1vLm7RarU4A0AUTfgbi8NnVeSnt4AM9MUMTOJntNmeHNVT29t5rdkZpoeY8vM9u3bF9k7b8+ePcVuw8XFBRs3bixynUaNGuHYsWNFrjNgwAAMGDCg2McjKhf2HkD794GXpwJPzgOuNaRl2qjRARh/Cji2GDi+BLi9F1jRAmj/ARA0UepZTibr+++/L/J2a2trrFixAitWrCh0HT8/P/z5559Fbqd9+/a4ePFiqcpYYqqTPOIfAZmpgKXUocTa0hw+jtZ4Gp+G+zHJbPSuYFjPND1mZmaoVq2ayTXGJSUlYejQofjuu+/wySefqJfHx8fj+++/x8aNG9GxY0cAwNq1a1GvXj2cPn0aLVu2xN69e3Ht2jXs378fnp6eaNKkCebPn4/3338fc+bMgZWVFVavXo2AgAAsXrwYgDRS0fHjx7FkyRK9NnqrenrfjkyCspGPNEQye3pXWMxM06OrzGSjNxmUEALxqZmwRjrMslKlhe61czV6NwDwvOFMGzKZDN7e3vDw8NCYh46Mk6WlpdH0vKH8VD29PUS0tEDV01s1TFBKNLztpdeXw5trRzW8uVd22POFUbfgVlea47skeQkwM00NM5NIk+rkSoUWjd7F9fQGmJmmhplJZIIsrAC/wudJLpSlNdDxIyCwP7BrGvDgOLB/NnB+HVC9PVC1hdRz3KU6YGKNF2SCbF2lOevT4oGYu4DX81E4/N3s8DQ+DfeiU9DMz8WAhaS8WM80PVZWVjAzM73ZZSdOnIju3bujc+fOGo3e58+fR2ZmJjp37qxeVrduXVSrVg2nTp1Cy5YtcerUKQQGBsLT01O9TnBwMMaPH4+rV6/ihRdewKlTpzS2oVon9zDqeaWnpyM9/fnxsISEhBI/r2outrC2NENaphLRZq7wANjTuwJjZpoeXWUmG73JoFIyspGlFHBHkrTAzBJwDgBwGEiJhpt9yeb0zs3c3JwHsYgMLDpZ+uy6ZEVJC1SN3jYu0uddmYlq8kQA7Omtrdic4c3dMnJVvKNvqvMyOjGjVNtlZhKRqcnMViI5IxtAMcOb5wz1GZucgfjUzCLXVWFmEhGZKPc6wIhdQOhGYO9M4Nk94Pw94Pxa6XZbt+cN4FVbAD5N1L1oiSoMmUwa4vzJOSDmdr5G75N3Y3A/uvgRbsgwWM+kiuzXX3/FhQsXcPbs2Xy3hYeHw8rKCk5OThrLPT09ER4erl4nd4O36nbVbUWtk5CQgNTUVNjY5P/eXbBgAebOnVvq5wUAZmYy1PZ0wOXH8bif4cRGbyPBzKS82OhNBpWQJjXeuJtLjV6wdX0+BFlyNNzdSt/oTUSGF52YATukwjo758QW1fDmZmbSEOfxj+BjFg8AiEjg57w4Qgh1T29F2uPnN0Tdgrv9857eSqWAmRl7oBBR5aYa2hwAFNaF/+yxk1vA3UGOqMR0PIhJRiNfp3IoHRERVVgyGfDCUKBeD+DeUeDRGeDRP8DTi0BKNHBzt3QBpBN5PesDdu6AXAHIHQBrBSB3zPmrWuYIuNUGHDyLfmwiXXFTNXprzusdkDPCzT0tpnUhIsrt0aNHePvtt7Fv3z5YW1sbujgaZsyYgWnTpqmvJyQkoGrVqiXejqrR+3qKA5oDbPQmMkJs9CaDUg056StPBZSQGr1t3aQbU6Lh7pDT6F3C4XqJqGKISU6Hlyxn3mm5o3TARyWn0dsDsQBsEZ6QBiGEyc11pEuJ6VnIUkrzeNomPXx+Q3o8XMUzAECWUpo2wtnOyhBFJCKqMFT1THu5BSzMix4iy9/VFlGJ6bgfk8JGbyIiklg7AvV6ShcAyEoHwi7lNILnNIQnRUjLtOVYFajSDPB9EajyIuDdGLCy1U/5qXJzrSH9jdZs9PZ3kxq92dObiErq/PnziIyMRNOmTdXLsrOzcfToUXz99dfYs2cPMjIyEBcXp9HbOyIiQj3/speXF/755x+N7UZERKhvU/1VLcu9jkKhKLCXNwDI5XLI5fIyP0fVvN6h8TYIAYD0eCA9UfN4JhFVaGz0JoOKT5EORvpYpgDpAGxdADtX6cbkaLirh+tlozeRMYpJyoCPLEa6oprHW8XBGwDgmB0NoBoyspSIT82Eky0bawsTlzO0uY2lOSziH2jcZvXsNpxsLRGXkomopHQ2ehNRpZeQlgWg6KHNVfxc7XD2/jM84AFgIiIqjIU8Z1jz5gAmA0IAcQ+B8CvS3MnpCUBagvRX4/9EICUWiP0PiH8kXa7tkLYpM5d6ild5UWoI928DOPsZ8lmSqXCtJf3N29PbTTrJ4n50Mk86J6IS6dSpE65cuaKxbOTIkahbty7ef/99VK1aFZaWljhw4AD69esHALh58yYePnyIoKAgAEBQUBA+/fRTREZGwsNDGu113759UCgUqF+/vnqdP//8U+Nx9u3bp96GPtXxkhq3L0dmS5130uOBhDDAnY3eRMaCjd5kUKoeOB6WyTmN3rl6eidHwy2np3dyRjaS07NgJ+dblsiYxCSlo66qp7dqaHOVnEZvy+QIONvWwLOUTIQnpLHRuwjPcoY2d7a1BGLvSQvt3IHkKCDqFtzs6yAuJRPRiemo7ckKORFVbqp6pkKLRu8AVa+nmBS9lomIKK/s7GxkZmYWvyJVTDaeQIA0ZLm5uTksLCwKb0RMT5SGSH98DnhyXvqbFC41modfeT5veLUgoNHrQIPegI1z+TwPMj1uqkbv29IJGjnvy6outjCTScfZopLS4eFQsYYoJqKKy8HBAQ0bNtRYZmdnB1dXV/Xy0aNHY9q0aXBxcYFCocDkyZMRFBSEli1bAgC6dOmC+vXrY9iwYVi4cCHCw8Mxc+ZMTJw4Ud1Te9y4cfj666/x3nvvYdSoUTh48CA2b96M3bt36/05qhq978ekQFnFG2ZR8UDCE8C9tt4fm4h0gy2IZFDqRm+zXHN627lL/6dEw87KHDaW5kjNzEZ0UjobvYmMiBAC0UkZ8IGqp3feRm9p2CIkhsNTYS01esenoa6XonwLakRicxq93W1lwLMn0sJawUDoz0D0TbjZB+JOJKeEICICntczHW2Krz/6uUq9nh5wfksiKkdJSUl4/PgxhBCGLgrpiK2tLby9vWFlVcCJvHIHIKCtdAGkhsiEJzmN4OeAR2elYdMfnpIuf70P1OkKNBoE1OwMWPDkYCoBl+oAZNIoBMnRgL10rE1uYQ4fJxs8fpaK+9EpbPQmIp1asmQJzMzM0K9fP6SnpyM4OBgrV65U325ubo5du3Zh/PjxCAoKgp2dHUJCQjBv3jz1OgEBAdi9ezemTp2KZcuWwdfXF2vWrEFwcLDey+/hIIejjSXiUzORLPeEA25wXm8iI8MWRDIo1bCTrmZJ0gJbV8BONad3LGRCCXcHOR7GpiAqMR1+rnYGKikRlVRiehYyspXwtiis0ds7Z8UweDla40Z4IiIT2FhblLicRu/aVjEABGBpB/i3lhq9o27CPeeARRSnhCAiet7T27r4nt7+rqqe3mz0JqLykZ2djcePH8PW1hbu7u4cYtjICSGQkZGBqKgo3Lt3D7Vq1YKZmVnRd5LJAEdf6dKgt7Qs4SlwZQtw6Vcg8hpw7XfpYusKNOwHNB4E+DQFsjOkBvP4x7kuj57/nxghDcduZVfAxf75/5a2gKUNYGEj/bW0ASysn/+vus2lOhvdjY2ljTSHfPxDaYjznEZvQBrhRmr0TkbzABcDFpKIjN3hw4c1rltbW2PFihVYsWJFoffx8/PLN3x5Xu3bt8fFixd1UcQSkclkqOPpgH/uxyLGzA0OABu9iYwMG73JoFQHI52QIC2wdQVsVBVuAaTEqhu9o9lzkcioxCRJDbS+5s+kBfmGN8/V09tTaqwNT0grr+IZpdicOb1rWERJC1yqA+51pP+jbsKtrnQgKjpn3xMRVWYJ6p7exTd6V8vp6R2dlIHEtEw4aNFQTkRUFpmZmRBCwN3dHTY2NoYuDumAjY0NLC0t8eDBA2RkZMDauhQ9aBU+QOu3gVZvSUOeX94kNYInRQD/fCtdVHOMFicdgK7O5XorFHAJ0NHGqNy41shp9L4N+D2fC9ff1Q7HbkfjHk/2IyLKp46X1Oj9ONsZ/oB0khkRGQ02epNBqQ5GKpS5Gr3NLaSG79RYICUabvZSIw57LhIZF9WJKlXMYgGB/D29FT7S34QweNZmo7c2VD29qyJCWuDiD7jlzCuUHAlfa2mfMy+JiHIPb158A7bC2hKudlaISc7Ag5gUNKziqO/iEREBAHt4m5hie3drSyYDvBtJl85zgf8OA5d/Ba7vet7gbWHzvKe4o6/Uq9epqvS/vRegzAQykoGMpJy/ef5PTwIyU4CsNOlvZhqQlQpkpkr/q29LlXqEk/FxqwX8dwiIvq2x2N8tZ4SbaDZ6ExHlVTtnXu/bqQ54GWBPbyIjw0ZvMijVwUj77JwfbbY5vbzt3KRG7+RouDs4AWAjDpGxiclp9PYobk7v9Hj42GYDACLZ6F2kZzmN3t7KMGmBc4A0N6CiCpDwBP7iMQBzjoxBRAQgPkX7Rm9AOgDMRm8iIqpwzC2AWp2lS3oi8OyBNFWUrYvUOE5UGNda0t+YuxqLA9ykkxjusdGbiCifOp5So/eVRHtpARu9iYyKjk5BJSodVaO3bVZOo7dqPm/bnL/JUXC3z5mjlo04REYlOikD9kiBnUiRFuQd3lyuUPcYqGaZCIA9vYvzLGd4c/fMnAq3aojBnCHOq2Q+AgA2ehMRAUhIy2n0ttWu0dsvZ4hzzutNRFS+/P39sXTpUkMXwzjIHQCvhoCdKxu8qXiuNaS/MXl6ertKPb0fxKRAqRTlXSoiogpN1ej9b5Kq0fuxAUtDRCXFRm8yKGl4cwF5Rpy0wNZV+muX8zclBu4OcgBAVCLnqCUyJtFJ6fCWxUpXrJ0AKzvNFWQydW9vL7M4AEB4PBtri6Lq6e2UljOfkHNOo7eb1OjtlnYPAEfGoP9n77zDo6jeNnzvbrLpvRdCAiEhQOgdC0gJVWkWUIpiB38ilk8UsIMNRQXFgmIBVBQbIBBAeqihE2oCIZDes+nZ/f44u5sE0tkQkpz7uuba2dkzM2cWcnbmPO/7vBKJBGpnbw6lE8DS6lMikUgqRqFQVLm8/vrrdTrugQMHePzxx2+ob/3792fmzJk3dAyJpMnhqs/0TouBkmLj5hbO1qiUCvKKSkjMloHnEolEUhYHa3M87S1J0OkdafPSoTC3YTslkUhqjBS9JQ1KZl4RtuSh1IlJSawM9uZu4lVTpqa3zFyUSBoVqTmFeCkqsTY3YOcFgKtWtEvVFFBUor0Z3WuUpGkKUaDFJlcfZWrM9BZ1ve2yowFI1RTKiH2JRNLsMYje9jUUvQ2Z3pdS5YSGRCKRVER8fLxxWbRoEfb29uW2vfDCC8a2Op2O4uLiKo5WipubG9bWsma0RGJy7H3BzFLUd8+4ZNxsrlLSwskKkBbnEolEUhFBnnZkYU2RSoyVZMc3bIckEkmNkaK3pEHJzCvCSSFsjTG3BrX+Qbesvbk+0ztFZi5KJI2KVE2ZTO9rrc0N6EVv26JkzFUKdDqZpVwVGblFeJKOUlsISjMxiQHGTG91hrCtK9HqjFnhEolE0lwxit6Wtcz0lvbmEolEUiGenp7GxcHBAYVCYXx/+vRp7Ozs+Pfff+nWrRsWFhbs2rWLCxcucM899+Dh4YGtrS09evRg8+bN5Y57rb25QqHgm2++YcyYMVhbW9OmTRv+/vvvG+r777//Tvv27bGwsMDf35+FCxeW+/zzzz+nTZs2WFpa4uHhwfjx442f/fbbb4SGhmJlZYWLiwuDBg1Co5G/FZJGgFIJzgaL8/PlPvJ3NTjcyGA/iUQiuZZgD1tAQaaZPjEv60qD9kcikdQcKXpLGpTMvCJc0IveBmtzKK3tnZtSxt68AJ1OZi5KJI2FlJxCvKvN9Bb25sqcRNztLAFIlHW9K0SnE0K2vzJBbHD0A5WZWNfX9FZkXMbLqgQQ379EIpE0Z+pqb56UXUBuYc2yEyUSicRU6HQ6cguLG2Qx5XP2yy+/zLvvvktUVBQdO3YkJyeH4cOHs2XLFg4fPszQoUMZNWoUsbGxVR7njTfe4L777uPYsWMMHz6cBx98kLS0tDr16dChQ9x333088MADHD9+nNdff525c+eyfPlyAA4ePMj//vc/3nzzTc6cOcOGDRu44447AJHdPmHCBB555BGioqLYtm0bY8eOlXMTksaDa6B4vVb0lsF+EolEUilB+rre8QaL86yrDdgbiURSG8waugOS5kt+UQkFxVqclAbR27n0Q4MArknF1VaI3oUlWrLyi2s8cSmRSBqWlJwCPNFPTFVjb052PO72FlzJyJOidyXk6cdMP1WS2GCo5w0iUMjaBXJT6WydQnyeByk5BQRj1zCdlUgkkgamRKsjO18I1zW9d3SwNsfJ2pz03CIupeYS4mVfn12USCSScuQVldBu3sYGOfepN8OwVptmeujNN99k8ODBxvfOzs506tTJ+P6tt97ijz/+4O+//2bGjBmVHmfq1KlMmDABgPnz5/Ppp5+yf/9+hg4dWus+ffTRRwwcOJC5c+cCEBQUxKlTp/jggw+YOnUqsbGx2NjYMHLkSOzs7GjZsiVdunQBhOhdXFzM2LFjadmyJQChoaG17oNE0mC46Ot6p5wrtzlAn+kt7c0lEonketp6imfBi0WOhILM9JZIGhF1yvS+fPkycXFxxvf79+9n5syZfPXVVybrmKTpk5Uvsm+cFRVleuutQ3JTsDRXYWcpHsCl7bGkMdJcx8xyNb0rtTcXmd5kJ+BpLzK9EzKl6F0R6blizGyl1IvezgHlG+gtzjuoRSa4HC8ljZXmOmZKTEu2/j4Tai56A7Q0ZD3JCWBJPSDHN0lzoHv37uXe5+Tk8MILLxASEoKjoyO2trZERUVVm+ndsWNH47qNjQ329vYkJSXVqU9RUVH069ev3LZ+/fpx7tw5SkpKGDx4MC1btqRVq1ZMmjSJFStWkJsrLJ87derEwIEDCQ0N5d577+Xrr78mPT29Tv2QmBY5ptYQl4ozvVu72QJw4kqmdC6QSJoBcsysHYHutigUQvQGZKa3RNKIqFMo78SJE3n88ceZNGkSCQkJDB48mPbt27NixQoSEhKYN2+eqfspaYJk6S0nvc319YMqsjfXJAPgZmdBdn4xydkFBLrb3sxuSiQ3THMcMwuLtWTmFeGtrs7eXJ/pnXUVjwC9vbkUayskXSPsylubJYGO8pneAG5BELuHQMUVoBMpOfJ7lDROTDlmLlmyhA8++ICEhAQ6derEZ599Rs+ePSttv2jRIr744gtiY2NxdXVl/PjxLFiwAEtLS1NcmuQmkpUnsrytzFWozWoe5+vvYs2RyxnESKtPST3QHO8JJTXHylzFqTfDGuzcpsLGxqbc+xdeeIHw8HA+/PBDAgMDsbKyYvz48RQWVl2Kx9y8fMCSQqFAq9WarJ9lsbOzIzIykm3btrFp0ybmzZvH66+/zoEDB3B0dCQ8PJw9e/awadMmPvvsM1599VX27dtHQEBA9QeX1BtyTK0hrvpM72tE7+7+TliaK4nPzOdUfBbtvR0aoHMSieRmIcfM2mGlVtHS2ZqEDGlvLpE0NuqU6X3ixAnjhOGvv/5Khw4d2LNnDytWrDDWRJJIqsNQZ9HDTD+pWFb0tjbU9E4DbQlueovzZCniSBohzXHMTNMUArrSTO/KRG97g715Ah524u88UWZ6V0h6rpgYbFlNprefVkTuykxvSWPFVGPmL7/8wqxZs3jttdeIjIykU6dOhIWFVZoltnLlSl5++WVee+01oqKiWLZsGb/88guvvPKKKS5LcpOpbT1vA630WU8XkqToLTE9zfGeUFJzFAoF1mqzBlkUCkW9Xdfu3buZOnUqY8aMITQ0FE9PTy5evFhv56uIkJAQdu/efV2/goKCUKmE4G9mZsagQYN4//33OXbsGBcvXmTr1q2A+Lfp168fb7zxBocPH0atVvPHH3/c1GuQXI8cU2uIS2vxmh0PBdnGzZbmKm5vI1wWN5+qm4uCRCJpPMgxs/YEediVqekt7c0lksZCnTK9i4qKsLAQ4sTmzZu5++67AWjbti3x8fGm652kSWOYjHRTZUMxpUI3lBHAdZCXjpteDEuRIo6kEdIcx8yUnALsycVGof+btfeuuKGt3t68OI8WNkLUTZA1vStE2Jvr8NYK+/LrM72F6O1ZeBGQQUKSxoupxsyPPvqIxx57jIcffhiApUuXsm7dOr799ltefvnl69rv2bOHfv36MXHiRAD8/f2ZMGEC+/btu9FLkjQAdRW9gzyE6H02MbualhJJ7WmO94QSSZs2bVizZg2jRo1CoVAwd+7cesvYTk5O5siRI+W2eXl58fzzz9OjRw/eeust7r//fiIiIli8eDGff/45AGvXriU6Opo77rgDJycn1q9fj1arJTg4mH379rFlyxaGDBmCu7s7+/btIzk5mZCQkHq5BknNkWNqDbFyEvNtuSmQegG8Oxs/GtzOg/BTiWyOSuTZQW0aro8SiaTekWNm7WnraUd4lF6jkJneEkmjoU6Z3u3bt2fp0qXs3LmT8PBwhg4dCsDVq1dxcXGpZm+JRGCYjHRW5IgN1s6lH6rMxI05gCYZV5npLWnENMcxM1VTpp63lTOorStuqLYGS2Gj5qPMBCBRit4Vkq4pxJEcbHT67EMn//IN9KK3Q14cZhSTklO1ZaREcqtiijGzsLCQQ4cOMWjQIOM2pVLJoEGDiIiIqHCfvn37cujQIfbv3w9AdHQ069evZ/jw4Td4RZKGwHCfaW9VuxjfNh52AJxPykGrlfUtJaalOd4TSiQfffQRTk5O9O3bl1GjRhEWFkbXrl3r5VwrV66kS5cu5Zavv/6arl278uuvv/Lzzz/ToUMH5s2bx5tvvsnUqVMBcHR0ZM2aNdx1112EhISwdOlSVq1aRfv27bG3t2fHjh0MHz6coKAg5syZw8KFCxk2bFi9XIOk5sgxtRZUYnF+V1t3FAo4fiWT+My8BuiYRCK5Wcgxs/YEeZbJ9NYkQ7HUJSSSxkCdMr3fe+89xowZwwcffMCUKVPo1KkTAH///XeVdRIlkrIYai06oc+ksb7mB9baFfLSQZOCm77ur7TrlTRGmuOYmZJdgJciTbypzNrcgJ0X5GfioUwHIDFL/p1XRHpuIS0VieKNndf1gQT2PqC2RVmYQ0tFIsnZztcfRCJpBJhizExJSaGkpAQPD49y2z08PDh9+nSF+0ycOJGUlBRuu+02dDodxcXFPPnkk1XamxcUFFBQUDpmZWVl1ah/kvqnrpneLZ2tUZspySsqIS49Dz+XSoK2JJI60BzvCSVNl6lTpxpFY4D+/fuj010fLOTv72+0CTcwffr0cu+vtTuv6DgZGRlV9mfbtm1Vfj5u3DjGjRtX4We33XZbpfuHhISwYcOGKo8taRjkmFoLXAIhNgJSzpXb7GprQVc/Jw5dSmdzVBKTerdsoA5KJJL6Ro6ZtSfYw44MbMnXmWOpKBJlIq5NQJFIJLccdRK9+/fvT0pKCllZWTg5ORm3P/7441hby4khSc0wZuDo9BPE14reNq6Qeg5yU3Cz8wek6C1pnDTHMTNVU1Ca6e1QnejtCcmncS5JBZzJKSgmp6AYW4s6/UQ1WdI1hbRU6GutXWttDqBQiAj+q4cJVFwhMqfVze2gRGIiGmrM3LZtG/Pnz+fzzz+nV69enD9/nmeffZa33nqLuXPnVrjPggULeOONN+qtT5K6U5rpXTvR20ylpLWbLVHxWZxNzJait8SkNMd7QolEIqkv5JhaC1wCxes1md4Ag0I8hOh9KlGK3hJJE0aOmbXH39UGc5WSeJ0zAYpEYXEuRW+J5JanTvbmeXl5FBQUGAfIS5cusWjRIs6cOYO7u7tJOyhpuhgmI21LhKVxhaI36DO99TW9pb25pBHSHMfM1Jwy9ubVZnqLet+W+UlGoVtanF9Pem4RfoZMb+cKRG8At7YABCqukppTQIm05pU0QkwxZrq6uqJSqUhMTCy3PTExEU9Pzwr3mTt3LpMmTeLRRx8lNDSUMWPGMH/+fBYsWFBp7dHZs2eTmZlpXC5fvlyLK5XUJ3XN9IbSut5nZF1viYlpjveEEolEUl/IMbUWGO3Nz1330eB24ruKuJBKTkHxzeyVRCK5icgxs/aY6wOiE3SyrrdE0piok+h9zz338MMPPwDCYqpXr14sXLiQ0aNH88UXX5i0g5KmS2ZeEUq0WBVXInpblxG9DTW9Zaa3pBHSHMfM5JwCvDDYm3tX3dhOL0BlJ+BhL/7WEzOl6H0t5ezNK8r0BnANAqCNMg6tTuwjkTQ2TDFmqtVqunXrxpYtW4zbtFotW7ZsoU+fPhXuk5ubi1JZ/tZYpVIBFdusAlhYWGBvb19ukdwaZOXfiOgt6nqfk6K3xMQ0x3tCiUQiqS/kmFoLjJneF+Ca+9rWbrYEuNpQWKJl59nkBuicRCK5Gcgxs24Ee9oRj758YNaVhu2MRCKpEXUSvSMjI7n99tsB+O233/Dw8ODSpUv88MMPfPrppybtoKTpkplXhAM5KNDfcFtfU3/WkOmdW5rpnaoplJmLkkZHcxwzy2V6O/hW3djOS7xmx+PpYAlAYrYUva8lPbcQP6Xe3rzSTO9gAIJV8YB0x5A0Tkw1Zs6aNYuvv/6a77//nqioKJ566ik0Gg0PP/wwAJMnT2b27NnG9qNGjeKLL77g559/JiYmhvDwcObOncuoUaOM4rek8XBjmd5C9D6bmGPSPkkkzfGeUCKRSOoLOabWAqcAUKigMAeyE8p9pFAoGBQisjzDoxIr2lsikTQB5JhZN4I87EjQGURvmektkTQG6iR65+bmYmcnJoM2bdrE2LFjUSqV9O7dm0uXLtX4ODt27GDUqFF4e3ujUCj4888/q91n27ZtdO3aFQsLCwIDA1m+fHldLkFyC5CVV4SzQp9BY+EAqmsmJW3cxKsmBWcbNQoFlGh1MnNR0ugw1ZjZmBA1vQ2Z3jWo6Q0i09tOiN4JmVKsvZZ0TVENMr2F6B3AFRRopTuGpFFiqjHz/vvv58MPP2TevHl07tyZI0eOsGHDBjw8PACIjY0lPj7e2H7OnDk8//zzzJkzh3bt2jFt2jTCwsL48ssvTXuBkptCVkWid1oMnN1U7b4Ge/MLyTky2FJiUprjPaFEIpHUF3JMrQVmanDS1+uuwOJ8UIi4P956OonikorL+kgkksaNHDPrRrCHHfE6mektkTQm6iR6BwYG8ueff3L58mU2btzIkCFDAEhKSqqVraNGo6FTp04sWbKkRu1jYmIYMWIEAwYM4MiRI8ycOZNHH32UjRs31uUyJA1MZl4RTuhF72uzvKHU7lyTgrlKibO1GpCZi5LGh6nGzMZEanZZ0bs6e3N9pndWPB6GTG9Z0/s6cnNz8FSkizeVZXo7+YNKjSWF+ChS5XgpaZSYcsycMWMGly5doqCggH379tGrVy/jZ9u2bSsXPGlmZsZrr73G+fPnycvLIzY2liVLluDo6GiKy5LcZCrM9F49FVbeC1ePVLlvCydrLM2VFBRriU3Lrb9OSpodzfGeUCKRSOoLOabWEqPF+fnrPurW0glHa3Mycos4dCn9JndMIpHcDOSYWTeCPUszvbWZMtNbImkM1En0njdvHi+88AL+/v707NnTWBtx06ZNdOnSpcbHGTZsGG+//TZjxoypUfulS5cSEBDAwoULCQkJYcaMGYwfP56PP/64LpchaWDKZXobrMzLUsbeHMBV1vWWNFJMNWYCLFmyBH9/fywtLenVqxf79++vsv2iRYsIDg7GysqKFi1a8Nxzz5GfX7+Csk6no1iTjrVC/7daXaa3vV70zknA004Et0jRuzwFxSW4FomMVJ2FPVg5VdxQZWaczAhUxJGSLZ0xJI0PU46ZkuaLQfS2N4jexQWQcFysxx+pcl+lUkGgu8j2PpMg63pLTIcc3yQSicR0yDG1lri0Ea8p14veZiold7UVFuebpcW5RNIkkWNm3fBxtCLDTLjRajPjGrg3EomkJtRJ9B4/fjyxsbEcPHiwXJb1wIED61WAjoiIYNCgQeW2hYWFERERUW/nlNQfmXlFOCn0tRINWd1lsdaL3hohehvqekvRW9LYMNWY+csvvzBr1ixee+01IiMj6dSpE2FhYSQlJVXYfuXKlbz88su89tprREVFsWzZMn755RdeeeWVG76mqsjKL8ZVmwyAztoVzC2r3sFWWKmhLaaFhcioS5CidzkycstYmzsHgEJReWPXIAACFVdJlpnekkZIQ91nSpoW12V6p54HXYlYT7ne1vNagtyF9d+5RCl6S0yHHN8kEonEdMgxtZa4GjK9K74PGqy3OA8/lYhOJ8u7SCRNDTlm1g2lUoG1mx8AKk0SlBQ1cI8kEkl1mNV1R09PTzw9PYmLExEuvr6+9OzZ02Qdq4iEhARjHUYDHh4eZGVlkZeXh5WV1XX7FBQUUFBQOumflZVVr32U1IyiEi2awhKcVQZ78wpEb0NN77w00JZI0VvSqDHFmPnRRx/x2GOP8fDDDwPC/WLdunV8++23vPzyy9e137NnD/369WPixIkA+Pv7M2HCBPbt23eDV1M1qTkFeOqtzRXVWZsDqMzF37smGW9VBgCJmVL0LkuaptAoeisqq+dtwE3U9Q5UXGG/HC8ljZSGuM9srOh0OhZvPY+ZSslT/Vs3dHduCbRa3fU1vZOiShuknK32GEGeQvQ+m5Rj8v5JmjdyfJNIJBLTIcfUWlCFvTnA7UFuqFVKLqbmciE5h0B9AKBEImk6yDGzbnh5+lKYokKtKIGcRHDwbeguSSSSKqhTprdWq+XNN9/EwcGBli1b0rJlSxwdHXnrrbfQarWm7uMNsWDBAhwcHIxLixYtGrpLEiA7vxgAJ0VVNb3123RayEs3it6yRq2ksWGKMbOwsJBDhw6Vc7tQKpUMGjSoUreLvn37cujQIaMFenR0NOvXr2f48OGVnqegoICsrKxyS21JySnEW5Eq3tT0RtDOEwA3RP2wpOwCtFoZXW4gPbewfKZ3VRgyvZUy01vSOGlM95m3AuuOx7Mw/CzvbTjNWZmVDEBOYTGGn5AKRe/kM9UeI8hD2JvLTG+JKZHjm0Qi6N+/PzNnzmzobkgaOXJMrSUGe/P0S1B8fRksWwsz+rQWCSnhpyp2k5NIJI0XOWbWnSAvBxL1db3JknW9JZJbnTqJ3q+++iqLFy/m3Xff5fDhwxw+fJj58+fz2WefMXfuXFP30YinpyeJieVryyQmJmJvb19hljfA7NmzyczMNC6XL1+ut/5Jao7BctJdVYW9ucocLB3FuiYFV1tR61dmeksaG6YYM1NSUigpKanQ7SIhIaHCfSZOnMibb77Jbbfdhrm5Oa1bt6Z///5V2pubIlAoNacAL4PoXZNMbwA70c6hOAWFAoq1OlI1sh61gXRNGXvzajO92wLQRhFHsrSJlzRCGuo+szGSnV/Em/+cMr7/56h8AAeMWd5qMyWW5iqxMfl0aYOMWCjKq/IYbfTZTReScygqkZNAEtMgxzdJY2fUqFEMHTq0ws927tyJQqHg2LFjN3ye5cuX4+joeMPHkTRt5JhaS+w8QW0ryr2kx1TYZFA7Md8g63pLJE0POWbWnWBPO+IxiN5XGrYzEomkWupkb/7999/zzTffcPfddxu3dezYER8fH55++mneeecdk3WwLH369GH9+vXltoWHh9OnT59K97GwsMDCwqJe+iOpO+VEby0Vi94gLI/zMyA3BTc7fwCZuShpdDTUmLlt2zbmz5/P559/Tq9evTh//jzPPvssb731VqU3tLNnz2bWrFnG91lZWbUWvlM0hXjp7c2x96nZTvpMbzNNIq62LUjOLiAxK9/o8NDcSc8tpJ0x07tV1Y1dAtEplDiQiy5HRuhLGh8NNWY2Rj4OP0dSdgFqMyWFxVr+PnqVWYODUCgUDd21BuW6et5QPtMbHaReAM8OlR7Dx9EKa7WK3MISLqVqpMWnxCTI8U3S2Jk2bRrjxo0jLi4OX9/yjk7fffcd3bt3p2PHjg3UO0lzQ46ptUShAJfWEH9UWJzry2KVZVCIO3P/hMjYdFJyCnC1lc/jEklTQY6ZdSfIw44IfaZ3YXoc6gbuj0QiqZo6ZXqnpaXRtm3b67a3bduWtLS0Gh8nJyeHI0eOcOTIEQBiYmI4cuQIsbGxgBBfJk+ebGz/5JNPEh0dzUsvvcTp06f5/PPP+fXXX3nuuefqchmSBsQwGemsqKKmN4CNq3jVpOBmawnITG9J48MUY6arqysqlapCtwtPT88K95k7dy6TJk3i0UcfJTQ0lDFjxjB//nwWLFhQqXWRhYUF9vb25ZbakpJdgBe1tTf3Eq/Z8XjYiwfrRJmlbCRTk4uvIkW8qc7e3NySEgc/AFzyYiiRNvGSRoap7jObOievZrJ8j8jS+fSBzliaK7mUmsvxK5kN3LOG5zrRuygP0qLFusEtI6Vqi3OlUkEbD31d70RZ11tiGuT4JmnsjBw5Ejc3N5YvX15ue05ODqtXr2batGmkpqYyYcIEfHx8sLa2JjQ0lFWrVpm0H7Gxsdxzzz3Y2tpib2/PfffdV+456ejRowwYMAA7Ozvs7e3p1q0bBw8eBODSpUuMGjUKJycnbGxsaN++/XXJFZLGgRxT64DB4jzlXIUfezlYEerjgE4HW0/LAGqJpCkhx8y642qrJsPMDYDMhEsN3BuJRFIddRK9O3XqxOLFi6/bvnjx4lpF9R48eJAuXbrQpUsXAGbNmkWXLl2YN28eAPHx8UYBHCAgIIB169YRHh5Op06dWLhwId988w1hYWF1uQxJA2KYjHSkGtHbsF2TjKudiKNKyZGWx5LGhSnGTLVaTbdu3diyZYtxm1arZcuWLZW6XeTm5qJUlh/mVSph86rT1Z8Qmqqpi725XrjPTsDTXgS4JEjR20hJ+hXMFSUUK9RGK/iqUOqj9lsprpImbeIljQxT3Wc2ZbRaHXP/PIFWByNCvRjawYtBIcKO8u8j0uLcYG9ub6k3tUo5C+jAyhla9tNvq3iytyxB7qKut6yVLjEVcnyTVIlOB4Wahllq+GxgZmbG5MmTWb58ebnnidWrV1NSUsKECRPIz8+nW7durFu3jhMnTvD4448zadIk9u/fb5KvSavVcs8995CWlsb27dsJDw8nOjqa+++/39jmwQcfxNfXlwMHDnDo0CFefvllzM1FINT06dMpKChgx44dHD9+nPfeew9bW1uT9E1yc5Fjah1w1YveqecrbWK4pww/JS3OJZKmhKnGzC+++IKOHTsaE2X69OnDv//+a/w8Pz+f6dOn4+Ligq2tLePGjbsugSc2NpYRI0ZgbW2Nu7s7L774IsXFxeXabNu2ja5du2JhYUFgYOB1AXc3E4VCgU4/F5efJkvnSiS3OnWyN3///fcZMWIEmzdvNootERERXL58uVYRsv37969SeKloMOvfvz+HDx+udZ8ltxaGyUgHbZbYUF2md24qbnpbpTRNIUUlWsxVdYrZkEhuOqYaM2fNmsWUKVPo3r07PXv2ZNGiRWg0Gh5++GEAJk+ejI+PDwsWLABEzb2PPvqILl26GO3N586dy6hRo4zid32Qml1QB3vzMpne7kL0TsySrg4GzLMuApBt5Y2TsvqxT+neFs5tJFBxheTsAmkTL2lUmGrMbMr8cvAykbEZ2KhVzB3ZDoC7O3mz9lg8a4/F88rwEJTK5mtxfl2md5K+nrd7CLgFifWUs9UeJ8iY6S1Fb4lpkOObpEqKcmF+DQNGTc0rV0FtU6OmjzzyCB988AHbt2+nf//+gLA2HzduHA4ODjg4OPDCCy8Y2z/zzDNs3LiRX3/9lZ49e95wV7ds2cLx48eJiYkxlmH64YcfaN++PQcOHKBHjx7Exsby4osvGjPa2rRpY9w/NjaWcePGERoaCkCrVtWUDpLcssgxtQ64BIrXqkTvdu58vPksO88lk19UgqV5/c0dSCSSm4epxkxfX1/effdd2rRpg06n4/vvv+eee+7h8OHDtG/fnueee45169axevVqHBwcmDFjBmPHjmX37t0AlJSUMGLECDw9PdmzZw/x8fFMnjwZc3Nz5s+fDwg34BEjRvDkk0+yYsUKtmzZwqOPPoqXl1eDJT9aurSALFBmStFbIrnVqZNqeOedd3L27FnGjBlDRkYGGRkZjB07lpMnT/Ljjz+auo+SJkhmXhHmFGOl04gNVdX0BtCk4GStRqWfwE2V2d6SRoSpxsz777+fDz/8kHnz5tG5c2eOHDnChg0b8PAQkdixsbHEx8cb28+ZM4fnn3+eOXPm0K5dO6ZNm0ZYWBhffvmlya+xLIXZKVgqhOBQ40xve73onRWPhz7TOzFTZnobsMoRrid5tn4128FVZHq3UVwhJUcGD0gaF/I+s2pScwp4918h4s4aEoyngxgz7wx2w87SjISsfA5cbN72dNeL3qfEq3uIcXwkuXrRu42HIdNb2ptLTIMc3yRNgbZt29K3b1++/fZbAM6fP8/OnTuZNm0aICaz33rrLUJDQ3F2dsbW1paNGzeWc/G7EaKiomjRooVR8AZo164djo6OREVFASJY+NFHH2XQoEG8++67XLhwwdj2f//7H2+//Tb9+vXjtdde49ixYybpl+TmI8fUOmAQvatwvGnnZY+PoxX5RVp2n0+5SR2TSCT1janGzFGjRjF8+HDatGlDUFAQ77zzDra2tuzdu5fMzEyWLVvGRx99xF133UW3bt347rvv2LNnD3v37gVg06ZNnDp1ip9++onOnTszbNgw3nrrLZYsWUJhoZjvX7p0KQEBASxcuJCQkBBmzJjB+PHj+fjjj+vlu6kJVi06A+ClOVUj1zCJRNJw1CnTG8Db25t33nmn3LajR4+ybNkyvvrqqxvumKRpk5VXVGptrlCCpWPFDa0NNb2TUSoVuNqqScwqIDm7wDjJK5E0Bkw1Zs6YMYMZM2ZU+Nm2bdvKvTczM+O1117jtddeq3V/bwRVtrDWLbR0QW1WwwxjQ6a3JhkvWxFJLu3NS7HPiwOg2MG/Zjvo7c0DlVfYLUVvSSOkOdxnXkrV8P7GM7x5d3tcbGvuxvDuv6fJzCsixMueKX1aGrdbmKkY2t6T1Yfi+PvoVXq1qiSgsBlwneidrM/0dmtbxtbzHGi1UIV7RrCnyPS+mKKhsFiL2ky6DElunOYwvknqiLm1yLhuqHPXgmnTpvHMM8+wZMkSvvvuO1q3bs2dd94JwAcffMAnn3zCokWLCA0NxcbGhpkzZxonsm8Gr7/+OhMnTmTdunX8+++/vPbaa/z888+MGTOGRx99lLCwMNatW8emTZtYsGABCxcu5Jlnnrlp/ZOYDjmm1hKD6J2bAnnpYOV0XROFQsGgEHe+j7jE5qhEBurtzqsiMSuf43GZDGjrbkxWkUgktx6mHjNLSkpYvXo1Go2GPn36cOjQIYqKihg0aJCxTdu2bfHz8yMiIoLevXsTERFBaGioMYEHICwsjKeeeoqTJ0/SpUsXIiIiyh3D0GbmzJmV9qWgoICCgtL5r6ysrFpfT1W0Cg4l/L9uDFYdQrP1Q2zuq9+EIolEUnfkzI2kQcjMK8JZoRe9rZwrn3AsY28O4KqfFJaZixLJrYtFnsg219rV0NocRICLQgXo8LUQGXWJUvQ24lJ4Raw4+ddsB72o46HIIDNdRudLJLcaOp2OTd8vYGLUDBYs+oj9MTXLzD5wMY3Vh0QQzNujO2B2TamXuzsLd431x+MpKtGattONiKw8UQ+uwkxvx5agUkNxPlRjTedpb4mdhRnFWh0xKZr67LJEIpGAQiEsxhtiUdROpLrvvvtQKpWsXLmSH374gUceeQSF/hi7d+/mnnvu4aGHHqJTp060atWKs2erd9eoKSEhIVy+fJnLl0vH8FOnTpGRkUG7du2M24KCgnjuuefYtGkTY8eO5bvvvjN+1qJFC5588knWrFnD888/z9dff22y/kkktzQWtqUB56kXKm02qJ0QozZHJaHVVl6WEmDr6USGfLyDR384yP9+Ptys70ElkubC8ePHsbW1xcLCgieffJI//viDdu3akZCQgFqtxtHRsVx7Dw8PEhISAEhISCgneBs+N3xWVZusrCzy8vIq7NOCBQuMZVYcHBzKOcKYgg4+DuzwmASA5anVkCFtziWSWxUpeksahHKid2XW5lAqemuEaGOoS5ucLUVvieRWpLBYi0NRMgBKR9+a76hUgp0nAF6KdADiM/PJKywxeR8bIx4lIpDA3K11zXawdCDbXD9+1qBurUQiubkoFArGt8ikn+okwfnHeOCrCJb8d77KScWiEi1z/jgBwISeLejW8vrMnD6tXHC1VZOeW9Ss7SgNmd72VuZQkAMZektdtxBQmZWx9qx6fFQoFEaL8zOyrrdEIpEYsbW15f7772f27NnEx8czdepU42dt2rQhPDycPXv2EBUVxRNPPEFiYmKtz1FSUsKRI0fKLVFRUQwaNIjQ0FAefPBBIiMj2b9/P5MnT+bOO++ke/fu5OXlMWPGDLZt28alS5fYvXs3Bw4cICQkBICZM2eyceNGYmJiiIyM5L///jN+JpE0C2pgcd4rwAVbCzOSsws4GpdRYZsSrY4PN57hkeUHjfde647F8/SKSAqK5XO8RNKUCQ4O5siRI+zbt4+nnnqKKVOmcOrUqQbt0+zZs8nMzDQuZYPjTMWoEfewu6Q9KkrI/q/hrNYlEknVSNFb0iBk5RfhRA1Eb4O9ea5e9NZneifLTG+J5JYkVVOAt0I4M5g71iLTG4yitxsZKBRCtOi9YAsL/o3iSkbFkZzNgaLiEnx1YqLQyqNNjffLtBUCuWW6rDUkkdyKOLXpA8BAu8todfDBxjNM+W5/pW423+2O4UxiNs42al4Ka1thGzOVkuGhInvn76MNZJF7C1DO3jzljNho4w42+ntOg8V5DYKCgjyExfk5KXpLbhF27NjBqFGj8Pb2RqFQ8Oeff5b7XKfTMW/ePLy8vLCysmLQoEGcO1f+XiAtLY0HH3wQe3t7HB0dmTZtGjk55WvXHzt2jNtvvx1LS0tatGjB+++/f11fVq9eTdu2bbG0tCQ0NJT169eb/Holty7Tpk0jPT2dsLAwvL29jdvnzJlD165dCQsLo3///nh6ejJ69OhaHz8nJ4cuXbqUW0aNGoVCoeCvv/7CycmJO+64g0GDBtGqVSt++eUXAFQqFampqUyePJmgoCDuu+8+hg0bxhtvvAEIMX369OmEhIQwdOhQgoKC+Pzzz03ynUgkjQKD6J16vtImajMldwa7AbA56vqglZScAiYt28fi/8QxpvRpyZeTuqE2UxJ+KpEnfjxEfpEUviWSpoparSYwMJBu3bqxYMECOnXqxCeffIKnpyeFhYVkZGSUa5+YmIinp5jz8/T0vC4YzvC+ujb29vZYWVlV2CcLCwvs7e3LLaamZ4CzMdvb4thPkJNs8nNIJJIbp1Y1vceOHVvl59cOaBJJZWTmFRFgzPR2rrxhWXtzrVZmeksaFc1xzEzNKcRTIWx6FQ61yPQGo82aTUES740bymdbz3E5LY8vt0fz9Y5owtp78nC/AHr4OxntE5sDmanxuCry0eoU2HnWMNMbyHcMhPR92OdE12PvJBLT0ezGTJ9uALQqOs+HY9sx55/T7DyXwvBPdvLphC70LlOT+2pGHos2C9Hq5WFtcbJRV3rYuzt580PEJTadTCS/qARLc1X9XsctSLlM76QosdG9TBafa5B4TT5T7bEMovdZKXpLbgBTjm8ajYZOnTrxyCOPVHjc999/n08//ZTvv/+egIAA5s6dS1hYGKdOncLS0hKABx98kPj4eMLDwykqKuLhhx/m8ccfZ+XKlYCogThkyBAGDRrE0qVLOX78OI888giOjo48/vjjAOzZs4cJEyawYMECRo4cycqVKxk9ejSRkZF06NChxtcjabz06dMHne56hxJnZ+frgjGuZdu2bVV+PnXq1HLZ49fi5+fHX3/9VeFnarWaVatWVbrvZ599VuW5Jbc+ze6e0dQYgv9Sqw6OHtLOg3XH4tl8KokXywRcHryYxvSVkSRmFWCtVvHuuI7c3UkEvnw7pQeP/nCAbWeSmfb9Ab6e3B1rda2mniUSiYm5GWOmVquloKCAbt26YW5uzpYtWxg3bhwAZ86cITY2lj59RNB3nz59eOedd0hKSsLd3R2A8PBw7O3tjWVK+vTpc10wZXh4uPEYDcmQkfdx5Nuv6KyMJnPbpziMfKuhuySRSK6hVnceDg4O1X4+efLkG+pQU2X1wcvYWJgZs2+aO5l5RTjXKNNb/5lOC3npxpreMtNb0hhojmNmSk5ppjd1FL3Jjue+gS0Y19WXLVGJLN9zkT0XUvn3RAL/nkigvbc9U/v6M6qTd7MQc/ISRPR8osIZL7VlzXd0DYIYcM2/WD8dk0hMTLMbM13agIU9FGQxvkU2HWfcxtMrIjmflMPEr/fy3KAgnh4QiEqp4M1/TpFbWEL3lk6M71r12NrVzwlvB0uuZuaz7UwSQzs0v3vPrLKZ3nEVid7B4rUKW08DpZneOdW0lEgqx5Tj27Bhwxg2bFiFn+l0OhYtWsScOXO45557APjhhx/w8PDgzz//5IEHHiAqKooNGzZw4MABunfvDggRcPjw4Xz44Yd4e3uzYsUKCgsL+fbbb1Gr1bRv354jR47w0UcfGUXvTz75hKFDh/Liiy8C8NZbbxEeHs7ixYtZunRpja5FIpFI6kKzu2c0NS4G0bvymt4A/YPcUSkVnEnMJjY1lxbOVizbFcO7/56mWKsj0N2WLx7sShv9vRLAbW1c+f7hnjyy/AC7z6cy9dsDfPtwD2wtpPAtkTQUph4zZ8+ezbBhw/Dz8yM7O5uVK1eybds2Nm7ciIODA9OmTWPWrFk4Oztjb2/PM888Q58+fejduzcAQ4YMoV27dkyaNIn333+fhIQE5syZw/Tp07GwEPP+Tz75JIsXL+all17ikUceYevWrfz666+sW7eu7l+Eiejm78Ii98l0TnkddeQyGPQCWFb9HUskkptLre46vvvuu/rqR5PmXGI2L/52DJVSQb9AVzEB18zJzC3CqSY1vVXmYOkI+RmQm4KbnbiZlpneksZAcxwzU3IK6YFe9Lb3rrrxtejtzclOAEClVDCkvSdD2ntyOiGL7/dcZE3kFU5ezeLF347x7r+nebifP0/3D0SpbLqZ34XJYjIiQeVFbaQrc08h8PgUm76OkURSHzS7MVOpBO8uELMdrhwiqHtH/p7Rj3l/neS3Q3EsDD/Lvpg07unszYaTCaiUCt4e06Ha8U6pVDCqkzdf7ojm76NXm6XoXc7ePPm02OhWxhK+Vvbmoqb3xVRNs82cl9w4N2t8i4mJISEhgUGDBhm3OTg40KtXLyIiInjggQeIiIjA0dHRKHgDDBo0CKVSyb59+xgzZgwRERHccccdqNWlrhJhYWG89957pKen4+TkREREBLNmzSp3/rCwsGozfCUSieRGMfWYumDBAtasWcPp06exsrKib9++vPfeewQHBxvb5Ofn8/zzz/Pzzz9TUFBAWFgYn3/+OR4eHsY2sbGxPPXUU/z333/Y2toyZcoUFixYgJlZ6dTrtm3bmDVrFidPnqRFixbMmTOnSleDesFF7x6WegG0WnFPWgEO1ub09HcmIjqVP49c4XRCFuuPi2f1UZ28eXdsKDYViNm9Wrnww7ReTP12P/svpjFp2T6WP9xTzoVKJA2EqcfMpKQkJk+eTHx8PA4ODnTs2JGNGzcyePBgAD7++GOUSiXjxo0rN14aUKlUrF27lqeeeoo+ffpgY2PDlClTePPNN41tAgICWLduHc899xyffPIJvr6+fPPNN4SFhZn0WurKnaMmc3bZ1wRxhfTtX+AU9nJDd0kikZRB1vS+CWw4IW4KS7Q6Dl1Ka+DeNDxarY7sgmKcayJ6Q6nFuSbZaG+eIkVvieSWJDU732hvjn1ta3qXZnpfS1tPexaM7cje2QP5v6Ft8XawJFVTyIebzvLnkSs32OtbG21aDACp5rULIrD1bQ+Aty6J4nyNyfslkUhMgK9edLpyEABrtRkf3tuJD+/thJW5il3nU3jxt2MATLstgLaeNatLNkpvMbklKomcgmLT9/sWRqfTlRe9jfbm7UobGUTv3BTIrfre3M3OAgcrc7Q6uJAss70ltzYJCeK5s6wIY3hv+CwhIcFoJWnAzMwMZ2fncm0qOkbZc1TWxvB5RRQUFJCVlVVukUgkkoZm+/btTJ8+nb179xrLPgwZMgSNpvQZ6rnnnuOff/5h9erVbN++natXr5azDC4pKWHEiBEUFhayZ88evv/+e5YvX868efOMbWJiYhgxYgQDBgzgyJEjzJw5k0cffZSNGzfe1OvFsSUozaE4D7Liqmw6qJ0Y5z8KP8v64wmYqxS8cXd7Pn2gc4WCt4FuLZ1Y+VhvHKzMORybwYPf7CVdU2jSy5BIJA3DsmXLuHjxIgUFBSQlJbF582aj4A1gaWnJkiVLSEtLQ6PRsGbNGmOtbgMtW7Zk/fr15ObmkpyczIcfflguQAigf//+HD58mIKCAi5cuHDzA4SqoEtLF7a5PQiA2f4voDC3gXskkUjKIkXvm8CGk6UP/vtipOidXVCMTgdOBntzg6hdGdYG0TultKa3tDeXSG5J8jITsVAUo0NRKmLXFEOmd9b1orcBJxs1T/VvzY6XBjDttgAAVu2PrWt3GwVmmRcByLBsUav9HF29SdfZolToyDLY+0okklsLfV1vrkSW2zy+my9/z+hnzDL2crDk2YFtanzY9t72tHK1oaBYS/ipygWopkheUQnFWlFj1kGRB1n6wCi30mwt1DbgoB9Tq8n2VigUBEuLc4nEJCxYsAAHBwfj0qJF7e5tJBKJpD7YsGEDU6dOpX379nTq1Inly5cTGxvLoUOHAMjMzGTZsmV89NFH3HXXXXTr1o3vvvuOPXv2sHfvXgA2bdrEqVOn+Omnn+jcuTPDhg3jrbfeYsmSJRQWCrF36dKlBAQEsHDhQkJCQpgxYwbjx4/n448/vrkXrDID51ZiPfV8lU0Hh5QGN3k7WPLLE32Y0tcfhaJ6p7VQXwdWPdYbFxs1J65kMeHrvaTIuTyJRNJE6HX341zWumFXkkHKzmUN3R2JRFIGKXrXM5fTcjl5tTSC/YAUvY11Fl2Utcz0zk0x1vTOzi8mv6ikvrookUjqiDZDRIrnql3ATF1N62sw2KFXkOl9LWYqJY/f0QqVUsGBi+mcS8yubVcbDZbZQtTX2PrVaj+VSsklhaj9q7l6yuT9kkgkJsAgeidFQUH5cayNhx1/Tb+Nd8Z0YMWjvarMprkWhUJhzPb++8hVk3W3MWDI8jZTKrDO1Avadt5g5Vi+YS0sztvogw/ONuHfGknTwJBFk5iYWG57YmKi8TNPT0+SkpLKfV5cXExaWlq5NhUdo+w5KmtzbSZPWWbPnk1mZqZxuXxZlmCRSCS3HpmZmQA4OzsDcOjQIYqKisqVjmjbti1+fn5EREQAEBERQWhoaDkHjLCwMLKysjh58qSxTdljGNoYjnEt9eqO4RIoXlOqFr39XKx54s5WjOniw9r/3U5XP6danaadtz0/P94bdzsLTidkc/+XESRm5de11xKJRHLL0KmlG9tcJwCgjPgMSooauEcSicSAFL3rmY36LO8AVxsAjsVlklfYvMVaw2Ski0KfLWPtXPUORnvzVOwtzVCbif+2sq63RHLrodQL1gVWlU94Vooh0zs/A4ryqm3uYW/JXW2FPefPB5rupKl9rhC9i+1b1nrfeLUQyrVJZ0zaJ4lEYiLsPMHeF9DB1SPXfWylVvFgr5a0crOt9aENovfOcynNyk6yrLW5wlDP2z3k+oauQeI1ufrxMUif6S1Fb8mtTkBAAJ6enmzZssW4LSsri3379tGnTx8A+vTpQ0ZGhjGDEWDr1q1otVp69eplbLNjxw6Kikon78LDwwkODsbJycnYpux5DG0M56kICwsL7O3tyy015XhcJu9vOM2JK5k13qexoNPpGroLEhMi/z0bN1qtlpkzZ9KvXz86dOgAiHIOarUaR0fHcm2vLR1R17IQWVlZ5OVd//xbr+4YrnrRO/VctU1nDwvh4/s742xTy6B2PW087PjliT54OVhyIVnD0ysiKdHKvxOJRNL46XrPDJJ1DjgXJ5K4+8eG7o5EItEjRe96xlDPe2pff7wcLCnW6jgcm97AvWpYDJORjuijVKvL9LYuremtUChws5UW5xLJrYpFrsgoLLarXf1pACwdwcxSrGfXzI53Yk8h6v4eGdc03R8KsrEpFr8ZWif/Wu+eZi0s4FWp1WcySiSSBsKnq3i9cqjqdrUk0N2Wdl72FGt1/Hui+VicZ+aK+0x7K3NIqoHonVL9ZG9ppre0N5c0PDk5ORw5coQjR44AokbskSNHiI2NRaFQMHPmTN5++23+/vtvjh8/zuTJk/H29mb06NEAhISEMHToUB577DH279/P7t27mTFjBg888ADe3uL+beLEiajVaqZNm8bJkyf55Zdf+OSTT5g1a5axH88++ywbNmxg4cKFnD59mtdff52DBw8yY8aMernur3dG8/m2C/xzrOm4V6hUKgCj9bGkaZCbK+p6mpubN3BPJHVh+vTpnDhxgp9//rmhu1K/7hguesebauzNTUWAqw0/P94bWwszDl1K58sdF27KeSUSiaQ+ad/Sg+0u94k3uz4CbROcl5RIGiE190mU1JqkrHwO6QXusPaeRMam89eRq+yLSaNvYDV1rJswmXlFWFKAJfqH+1rYmwO42VlwJSOPFJnpLZHcctjmC5tLpYNP7XdWKETWY/pFIXo7B1S7yx1Bbng7WHI1M5+NJxO4p3MdztsQ5GeBhZ245qpIvwhAms4WW4dqxsoK0Ni3hgywzrw5kxkSiaQO+HaHqL/hykGTH/ruzt6cis/i76NXmNirdiUSGiuG4EoheutLO1QpelcfFGSo6X05PZe8whKs1CqT9FUiqQsHDx5kwIABxvcGIXrKlCksX76cl156CY1Gw+OPP05GRga33XYbGzZswNLS0rjPihUrmDFjBgMHDkSpVDJu3Dg+/fRT4+cODg5s2rSJ6dOn061bN1xdXZk3bx6PP/64sU3fvn1ZuXIlc+bM4ZVXXqFNmzb8+eefxsxIUzO4nQd/H71K+KlEZg+r4G+6EWJmZoa1tTXJycmYm5ujVMqchMaMTqcjNzeXpKQkHB0djUENksbDjBkzWLt2LTt27MDX19e43dPTk8LCQjIyMsple19bOmL//v3ljlfTshD29vZYWVld1x8LCwssLCxMcm3XUUN7c1PS0sWGeaPa8dJvx/g4/Cz9g9xp511zxw+JRCK5FWl/90wyv1uBR+Flru5djXffBxq6SxJJs0eK3vXIxlOJ6HTQxc8RTwdLevg789eRq+xv5nW9s/KKcEZvD6lSg7oay04bN/GqEaK3q8z0lkhuSXQ6HQ7FyaAEc+c6Wq/ZeelF75pl8aiUCu7r0YJFm8+xan9s4xC9z26CVfdD90dgxMKq26bFABCr88DJuvbZIkVObSAWHPJioaQYVPJnXyK55TDU9b4SafJDj+zoxbv/nmZfTBqJWfl42FtWv1Mjp6y9OQZ7c7cqRO+MS1CUD+aVfzcutha42KhJ1RRyPimHUF8HU3dbIqkx/fv3r9I+WaFQ8Oabb/Lmm29W2sbZ2ZmVK1dWeZ6OHTuyc+fOKtvce++93HvvvVV32ETcGeyGuUpBdLKGC8k5tK5D2YdbDYVCgZeXFzExMVy6dKmhuyMxEY6OjlXWtpfceuh0Op555hn++OMPtm3bRkBA+eDrbt26YW5uzpYtWxg3bhwAZ86cITY2tlzpiHfeeYekpCTc3UUJrvDwcOzt7WnXrp2xzfr168sdu7qyEPWGqz7TO/OyKC1mfr3oXh/c282X8FOJhJ9KZNavR/hrRj8szGSAiEQiabyE+PuyznkcI9J/pGj7Quhzf/UJLhKJpF6Rs9/1yEa9leTQ9uKBp1eAqF0dGZtOYbHWWJu6uZGZV4Szooy1eXU/BIZMcL3o7e0oJiWjkzX11UWJRFIHsvKK8SAVAGvXOmYU2nmJ1xramwPc170Fn245x97oNKKTc+pU+/amodXC5tdBp4UD30DLftBhbOXt04XofUnngYd17WuoqZ39yNVZYE2BOJZhckMikdw6eHUGhRKyrkBWPNh7mezQvk7WdGvpxKFL6aw9Fs+026p30GjsGERvL3Uu5OizqdyCr29o6w6WDpCfCWkXwKN9lcdt42FLanQaZxKzpegtkTQA9pbm9G7lws5zKWw+lUjrO2/h+71aoFaradOmjbQ4byKYm5vLDO9GyPTp01m5ciV//fUXdnZ2xhrcDg4OWFlZ4eDgwLRp05g1axbOzs7Y29vzzDPP0KdPH3r37g3AkCFDaNeuHZMmTeL9998nISGBOXPmMH36dGO29pNPPsnixYt56aWXeOSRR9i6dSu//vor69atu/kXbe0iyovlZ0BadLX3QaZCoVCwYGwokZfSOZ2QzUfhZ5uMe4dEImm+tBn1Arnf/0rLgrPEHlyLX49RDd0liaRZ0zxV15tARm4hEdFC/AnTi96B7rY426gpKNZy/EpmQ3avQRGitz7Tuzprc7jO3rxbSycA9sWk1kf3JBJJHUnRFOCtF73NnW4g0xsgO77Gu3g7WtE/WETT/3LAhHXO6oMz6yDpZOn7f2ZCRhV9TjOI3u4429Re9Hazt+KCTv+dJp+p9f4SieQmYGFbmols4rreAHd3EjV6/z7adOrgVkVWfjEAbdCPrY5+4ju+FoWiVhbnQXqL83OJ2Sbpp0QiqT2D23kAEH4qsZqWjQulUomlpaVcmsAiBe/GyRdffEFmZib9+/fHy8vLuPzyyy/GNh9//DEjR45k3Lhx3HHHHXh6erJmzRrj5yqVirVr16JSqejTpw8PPfQQkydPLue6ERAQwLp16wgPD6dTp04sXLiQb775hrCwsJt6vYC4DzJanJ+7qad2tbVgwdhQAL7aEd3s3TAlEknjJ6iVP3udhNCdv+WDBu6NRCKRonc9sTkqiRKtjraedvi72gAiorGHvxBsm/NNXWZeEU7URvTW25vnpoFWS+9WYp+TV7OM2TwSiaThScnKw0OhH9vs62gzbqe3AqxFpjfAhJ4is/y3Q3EUFmvrdu76RqeD7e+J9X4zwac7FGTCmsdBW1LxLmXszR3rYG/GUzCmAAEAAElEQVTuamvBOZ2+Hl1sRF16LZFIbga+Botz09f1Hh7qhVIBRy9nEJuaa/Lj32pk6e8NW5bEig0VWZsbMIjeydWL3m30ovdZKXpLJA3GwBAheh+KTSdVlrqSSCQmQqfTVbhMnTrV2MbS0pIlS5aQlpaGRqNhzZo119nYt2zZkvXr15Obm0tycjIffvghZmblDTb79+/P4cOHKSgo4MKFC+XOcdMxuICl3ry63gaGtPfk3m6+6HTw/Ooj5BQU3/Q+SCQSiSnxH/UShToVQflHiY7c0tDdkUiaNVL0ric2nBBZisM6lLeo7BkgBNv9zThLudaZ3oY2uhLIz8DD3pJWrjbodHCgGQcPSCS3Gtlp8agVJWhRlorXtaUO9uYAA4Ld8LC3IFVTeOtm/5z5FxKOg9oW+j0L474W67F7YOdHFe6iNWR6az1wqoO9uZudBetLeok3B76BzCt17r5EIqlHjHW9TZ/p7WZnQd/WwjXnn2NNP9vbEBDpXXhRbHBvW3njWmR6BxtF75wb6Z5EIrkBfBytaO9tj04HW04nNXR3JBKJpHHTQJneBuaNaoePoxWX0/J4e+2pBumDRCKRmIpWrYM56CicO3I2v9fAvZFImjdS9K4HcgqK2XFOWHEP7VBe+DHU9T54MZ0Sre6m9+1WICu/GKfaiN4qc1FzEUCTDEAvfbb33ujmGzwgkdxqFKaKrLoslZP4u60LBrE8q3bCjJlKyX3dhaX6qv2xdTt3fVImy7uo26N8dTCdWJ0njFgoPt+2AC4fKL9PSRHKrDgAUtXemKtq/5Ptaqtms7Yr+7RtoTgftr59Q5chkTQ2lixZgr+/P5aWlvTq1Yv9+/dX2T4jI4Pp06fj5eWFhYUFQUFBrF+/vv47ahS9D4PW9G4VRovzI81H9HbLixYb3NtV3rhW9ubCIv1KRp7MRpJIGpCmanEukUgkNx2D6H3sZ/hqAOxceFNLYtlZmrPwvk4oFPDzgctsrmpcLymC+KNw8Fv4azp83ge+GQz5zbd0pEQiufXwGfEyJToFHXP3EfvTDCiRz40SSUMgRe96YNuZJAqLtQS42hgnyAyEeNlja2FGdkExUfFZDdTDhiUzrwjn2tibA1jr63prRDBB71YieGBvM86Yl0huNYozRBZxloVH3Q9iL4QZshOEUFwL7uveAoUCdp1PufUsfM+FQ/wRMLfm09whzF9/mpd+Pwod74fQe4WTxe/TIL/M70JGLApdCXk6NUXW7nU6rZO1GpVSyfyiiWLD0VViskAiaQb88ssvzJo1i9dee43IyEg6depEWFgYSUkVZwcWFhYyePBgLl68yG+//caZM2f4+uuv8fGpY7mG2uAWAubWUJhdIwG2toS198RcpeBMYjZnEpq2PbcQvXU45uitOt2qyPR2CxavKeeqDTZwtFbjZmcByLreEklDMkhvcb7zXDL5RRWXh5FIJBJJDWh9FwTcCSjgaiRseROW9ITPukP4axB3sF6CMcvSu5ULj94WAMDLa46J0hU6HaRFw/HfYMNsWDYEFvjCl3fA2ufg8E+QdAri9sOBZfXaP4lEIqkNLYM6saXFMwD4nf+R/B/vLT/PJ5FIbgpS9K4HNpwQtrxh7T1RKBTlPlMpFXRrKep6H7jYPK25s/KKapfpDWXqehtEb1nXWyK51VBmCdE738qrmpZVYKsXzIs0UFA7UaGFszW3txFjxc8HbqFs7zJZ3jkdp/DlIXHDuzc6jbiMPJHt7egHGZdg/Qul+6Ub6nm742xjUadTK5UKXGzUHNUFktH6HkAHm+bUOqBAImmMfPTRRzz22GM8/PDDtGvXjqVLl2Jtbc23335bYftvv/2WtLQ0/vzzT/r164e/vz933nknnTp1qv/OqszAq7NYrweLcwdrcwYEi+CZXw9eNvnxbyUy84pwJQt1YQagKM3mrgjHlqA0h+I80DtrVIUhmPWctDiXSBqM9t72+DhakV+kZZfeXU3ScByOTWfs57s5cjmjobsikUhqi6U9TPkbnj8DIxdB4CBxX5R6DnYvgm8GwsftYO0suLi73p4hnx8STJCHLSk5hby/ehu6z3vDp11EUPjez+HyPuFaZukArQbA7S9A3/+JnfctheKCeumXRCKR1IX+U99ggd0r5OnUWF7cim7ZEMi4heYoJZJmgBS9TUx+UQn/6euLXWttbqCn3uJ8fzOtRy0yvfWThdbONdvJxpDpLezNZV1vieTWw6VE/H1q7W5A9LawBQt7sV7Lut4AE3sKi/NfD8ZRVFK/Uek15sJWuHIQzKz4JHcohcWl/frryFXx8D72G1Ao4dgvcOxX8aGhnrfOA8c61PM24GorBPOodjNBpYaYHSLzXCJpwhQWFnLo0CEGDRpk3KZUKhk0aBAREREV7vP333/Tp08fpk+fjoeHBx06dGD+/PmUlNykTEJfg8X5wXo5/AP68fH3yLgmnR2ZmVdEG6VewHYOALV15Y1VZuDSWqzXyOLcUNdbZnpLJA2FQqFgUIgI4pEW5w3Ph5vOEBmbwWdbGqYmsEQiMQF2HtD9YXjod3gpGsYtg/ZjQG0L2fFwcBksHw5f3wUn/wStae8jLc1VfHRfZyxVWsbEvIYi+bR4bvXpDj2fgDFfwYxD8NJFmPwnDJwLd80FO2/ISSx9fpZIJJJbALWZkgenPsNU3iBJ54giOUqMn9eWNJRIJPWGFL1NzO7zKWgKS/BysKSjj0OFbXqVEb11zSzbTqfTkVmXTG9DO02pnbms6y2R3Fr0cRMR1m2DQm7sQIa63tnxtd51YIgHrrYWpOQUsCWqYgvjm0qZLO/M9pP49qiwXX+gR6n4pNPpwK8X3Pl/Yp+1syD9olgQorezTd1Fb4Mdb5zODXo9KTaGz5W1hSRNmpSUFEpKSvDwKF9uwcPDg4SEigNqoqOj+e233ygpKWH9+vXMnTuXhQsX8vbbb1d6noKCArKyssotdcZY19v0md4Adwa54+VgSUZuERtP1j6oqLGQlVdEkEIvervV4PfIkAmeXHPR+4wUvWuGtgRO/QV7l8LJP+BShAjoKspr6J5JGjmD9HW9t5xORKttXs/TtxJx6bnsuSCexXeeSyErXzqwSSSNHkt7CB0P9y4XAvjE1dDlITCzFBboq6fA4h5w8DsoyjfZaTv4OPBj6//orYxCo7Mk4aFt8NgWGP4+dLofXANBWWYK20wNvZ8S63s+q7sNe+YVWDUBDnxzw9cgkUgkBvxcrJk0bjT3FLzFSW1LkcS3fIQo2yCRSOodKXqbmH/LWJsrlYoK24T6OmBhpiRVU8iFZM3N7F6Dk1tYQolWh4tCPylcY3tzfaZ3bqmFnazrLZHcYtw1Bx78DdqOuLHj3IDoba5Scm93XwBW7b8F7INitgs7NpUFH2rCKNHqGBDsxpyR7bA0VxKdrOFoXKZoe/sL0KK3qOn7+2OixiyGTG/zOnfBkOkdn5kPtz8PVk6QfBqO/HTDl1dnzm6CTzrJG37JLYVWq8Xd3Z2vvvqKbt26cf/99/Pqq6+ydOnSSvdZsGABDg4OxqVFixZ174BPd/GaeLJeREGVUsH9+oCbW2J8rAfyi0ooKNYSrNBbuLvXQvSuUaa3tDevETodnNsMS2+HXyfDhv+D1VPhu6HwaWd4xxPe9YPFPeH7u2HN46L0xo4PYf/X4rfhXLjIhkg+CzlJ0rpUUo5eAS7YWZiRklPIYWmr3WD8EXnF6HZcWKJl660QcCqRSEyHmQUEDYF7lsBzJ+GOl8DSEdIuwNqZsCgUdi6EvIwbP9f5LXSPFSWIXi56lFmbs6tPEuo2VbjEpZyB83V0Mtvwf3BmPax7Hra8JcuASSQSkzGyozcDenXh3sLX2KHoDiUFomzDtvfkWCOR1DNmDd2BpkRRiZbNUcJiLax9xdbmABZmKrr4ObI3Oo39MWkEutverC42OKL+tg4n6ljTW1NW9C5f19vBqu6ikEQiMQHOrcRyo9h5i9c6iN4gsqi/2HaBHeeSiUvPxdepCmvb+mb7+wCkhUzkp0Niwv75IcHYWpgxtL0nfx65yprIODq3cBQ2u2O/gqW3Qdx+4yFide50vwF7804tHPg9Mo51x+J55q5AFHf+H2x4Gba+Ax3GC0v5m0niSfjtYSjMEVnt/rcLSz2JxIS4urqiUqlITCxvfZuYmIinZ8X3aF5eXpibm6NSqYzbQkJCSEhIoLCwELX6+r/D2bNnM2vWLOP7rKysugvfDr5g4w6aJIg/JhwgTMx93Vvw6ZZz7I1OIzo5h1ZuTeseNCtPZBkGGezNayV6V2/NG+guMr0TsvKb7r1nSbHIyr68D1r2gaBhVVvEX8vVIxA+TwR9gSjhEXAH5CRDToIoXVKcD/mZYkk5U/NjqyzA3FK8mlkI61Mzw7qFyPpSWYBOCyWFUFJU5rXgmm2F8ExkaWCtpFGhNlPSv607/xy9SvipRLq1dGroLjU7dDodv0WKsbaVmw3RyRrWH49ndBefBu6ZRCKpF2xc4a5Xod+zEPkDRCyBrDjY8ibs/Bi6T4XeT4O9d+2PnRUPax5HgY6sDpMJP3ob+RdSWX0ojvu6V3FfbWkP3aaITO/dn0JQWO3OG7MTov4BFIAOdn4onlHDFpTPKpdIJJI6Mm9kOyIvpTM1YSaLXdcwPGcNbJsPqefh7s/Es01laEvEM4u51c3rsETSRJCitwnZH5NGRm4RLjZqY93uyugZ4KIXvVOZ2MvvJvWw4cnMK8KeXMwUeuuhGtubl6/pDaV1vaNTNByISTPa3EkkkkaOMdO7bva7LZ2tecAvE4crO9B+txDyToO1Mzi0AMcW4OinX/fTr/uKCXNTc3EXXNoNKjULMsPQ6bSM6OhFB33pi7FdffnzyFX+PnqVOSPaoTZTglNLGPmxiP7Uc0nnweAbsDe/p7MP76yL4kxiNpGxGXTrPg32fQnpMbDnUxjwyg1fao3RpMKqB8RkAgooyISNs2H8tzevD5JmgVqtplu3bmzZsoXRo0cDIpN7y5YtzJgxo8J9+vXrx8qVK9FqtSj1E11nz57Fy8urQsEbwMLCAgsLE40fCoWwOD/7r7A4rwfR29vRigHB7mw5ncTPBy7zyvAbLEdxi2EIrgxSXhEb3NpWv5ObQfSuXnx1sDLHy8GS+Mx8zidl061l1ff7jYrCXDj8E0R8Bhl6J4ADX4O5jXBwCb0XWg8AVSVCf/pF2Po2HF8t3qvU0OsJuG2W+A02oNMJsTs7oVQEz04Q9/j5GeKzPP2r4X1+FqDTC9cmzPiW2eONmkEhQvTeHJXIy8Nq8LcuMSkHL6VzKTUXG7WKD8Z3ZNwXEWw/m4ymoBgbCznNJJE0WSxsoc/T0PMxOPE77P4Ekk4J4XnflzDsfVEfvKaUFMPvjwpXR49Q7O/5gFnuV5i//jTvrItiQLC7sVxXhfR6CvZ+AZd2iftnQ7mg6tCWwIbZABzxHIdbq0747JkL+5aKZ9VRn4JSVc1BJBKJpGoszVUsntiVUZ/t4umU8XwX2pYBF96H479CUhQ4B0ChRr/kiKUgR7wv1ru/3TUH7nixYS9EImlkyKcRE7JBb20+uJ0HqkqszQ0Y6nofuJhe7/26lShXz1ttW3VEU1ls9OJ4bnkr816tXIhO0bA3OlWK3hJJU8HOS7zWJtM7Nw2it8H5LXBhC+9mx4M5YCivm6mBzMtQmaOvrad4cL/jhbr3+1r0tbyT29zH6iNalAqYNTjI+HG/QFfc7SxIyi7gvzNJpQ4hoePh/GY4ugotSq7oXHG6AXtzBytzRnb05vfIOFbtj6XbvZ1g8BvCcnb3p8IWri4R+bWluFCcMyMWnPxh5CL4aayYLOn8IAQOrP8+SJoVs2bNYsqUKXTv3p2ePXuyaNEiNBoNDz8sJuImT56Mj48PCxYsAOCpp55i8eLFPPvsszzzzDOcO3eO+fPn87///e/mddrXIHofrLdTTOjpx5bTSfx2KI7nhwRhYdZ0JvQy84rwIB17NKBQgWub6ndy0bfRJIvfEuuqhew2HnbEZ+ZzJiGnaYjeuWmijuW+paX32dYuEDxcZGtnxIpJmeO/gpUztB8jfqda9BZZULlpwtp0/1ciEwGg4/0w4FURyHUtCgVYOYrFvYZCpVYLBVliKS4QmeLFhUIAL9ZncJfdplAJcV6l1meDq0vXjdstwNbdFN+gpIHoH+yOmVLB+aQcYlI0BLjaNHSXmhW/HxJZ3sNDvejq54S/izUXU3P570wSIzvehPtKiUTSsKjModMD4jf/3CbY+RFc3itsz+OPCvHbrAaB29vfFYK12hbu+x7MLXmkXwB/HbnKyatZvLn2FJ9N6FL5/g4+IjDv6CrxbHvf9zXr/+GfIPE4GoUtD18chGOOF1vu+Rzl3zPEZ4UaGPNVza5BIpFIqiDQ3Za3RnfghdVHmXaiA+tHLaft9umQeFws1bH9A+g0QSTs1Dc6nXhek0gaOVL0rgpNKiVHVqHq/EC11ndarY6NJ/X1vDtUbm1uoIufI2ZKBVcy8hrefvcmkplXhLPR2rwWE4UV2JuDqOu9an+srOstkTQlqsv0LikSk/Bp0XAlUgjEVw4KO1M9OjMrdhWHEF4UyrAR4+nTwlLsk3lZvGZcLn1flCuyzba+Jc7d5aEbv4ZLERCzA5TmvJkubNbGd/OldRkrYZVSwZguPny5I5o1kXHly2IM/wDyMlh90YrifDOcb8DeHGBiLz9+j4xj7bGrzB3ZDoeQu6FFL2Ff+987ok5bfaLTwb8v6Sc07GDCz8J2uNeTsPdzWDcLnt4rbZskJuX+++8nOTmZefPmkZCQQOfOndmwYQMeHiJILjY21pjRDdCiRQs2btzIc889R8eOHfHx8eHZZ5/l//7v/25epw3ZKVcO1dsp+ge74WFvQWJWAZtOJjKqU9MRJzLzikqtzV1a18zFw8IW7H0g64qwmbPuWWXzIHdbdpxN5mxitgl63IBkxglr0kPfQ5FGbHP0g77/E4FIamsxdscdFNnbJ9eIwICDy8Ri7wut+8Opf4RrB0DAnTD4TfDubNq+KpWlQrlEosfBypzerVzYdT6F8FMJPH5H64buUrMhr7CEtcdEcOr4br4oFAqGhXrxxbYL/Hs8QYreEklzQqEQtuJthsCuj4Xd+aHvRPb3fT+UPttXxIWtsONDsT7qE3HvBpiplLw7tiP3LNnFP0evMraLDwPaVhGo1vcZIXpH/Q1pMSJzsirys9BtfQsFsLBwDOnYk56iYYf1YPqP/05knp/8A4ry4N7va56sI5FIJJUwvpsve86nsObwFR7ebs2GyVtwiA0XAURqW1DbiMXCTr9uK5ZfJwkHyW0L6n/ebu8XInho1KLal4uQSG4xpOhdBRnfjsMx9TBxmXn4Dq/aRuLw5QySsguwszCjb+vqLbut1WZ08HHgyOUM9sekNRvRO6tspndNrc2h1N48N1Vke+gnqWVdb4mkCWLIOs6IhXPhQtxOvQBpF8R6Rixoi6/fzy1EZAsHDkLh14ed4TH8sCOaK2et6NO3B7SoQMjQ6USW2t7PRQ2vtbPAvR34dL2xa9BneSe0Gsc/J1SoVUr+N/D6jMOxXX35ckc0W08nka4pxMlgY25hBxN/5oO3NwMFON6g6N3Vz5FgDzvOJGbz5+ErTOnrD0PegWWD4PAKYQvn2eGGzlElB74Rkx8oYNw3pXV2B7wCp/4Strg7PoCB8+qvD5JmyYwZMyq1M9+2bdt12/r06cPevXvruVdV4K0fe9IvikC/eqg3bKZScn/3Fny69Tyr9sc2PdFboRe9a2JtbsA1SIjeyWcq/q0oQ5CHqOt9LqkRid6G37rsq5B1VUzkHl9d+lvqEQq3zYR2o0FV5vFQoYAWPcQSNh8u7oDjv4n6l1lxIhMKwKODcBBpPVBmBkhuKoNC3Nl1PoXNp5Kk6H0T2XgygZyCYlo4W9HDXwSyD+8gRO+tp5PIKyzBSt10XEQkEkkNUCjg9lngGQq/TRPB1V/1h/t/At/u17fPioffHwN00O1h4SJThlBfB6bdFsDXO2OY8+cJNj13R+WlEzzaQ+AgEQwfsQRGfFh1X3d+iEKTzAWtFyt1Q+jdypm90Wks33OR/g+PFoLTLw/B2Q2w8l54YJUIkpRIJJIb4K3RHThyOYPoFA2zwjP4ZspTKKp7dhr0hpi3O7IS+jxTc6es2nJiDWx4Waz/+TRM31cvcxESyc1CWX2T5olOp2NFfh8ANHuX89Y/J8ktrEBk0bPhhIh0vivEvcY2kQaL8/0xaTfY28ZDZl4RznUSvfVtdSWivp8eQ11vnQ4OXmw+36NE0qQxZnrHw4rxIkN4/5fiITYtWkzSm1kKcbr9GFFv67mTMH0vhL0jao6aW3J/jxYA/HcmifjMvIrPpVCI8gkDXhVWriUF8MskyEmue/8v74fo/9ApzZibJqIjJ/byqzC4KdjTjnZe9hSV6Fh7vLydu06nIyNXWMU62dxYQI9CoWBiLz8AVu6LRafTCRGj/RhAB+GmE5t1Oh2agjK/l9Hb4F99puyg1yB4aOlnFnbC+g5ERGnSaZP1QyJplFg5ltptX4mst9Pc16MFCgXsuZDKxRRNvZ3nZlNO9HZvV/MdXQ11vc9W2zTIU4jeZxNzatu9+kVbIgLF9nwGG16B1VNhWRgs6ghve8AHrWDpbbDyPpENpS0G/9vhod/hyZ1isllVRTy0ygxa3wWjP4cXzsF9P0KPx2D0Unhih5hsloK35CZjKG918FIaaZrCBu5N8+E3vbX5uK6+KPVl3Tr42OPrZEVeUQnbzyY1ZPckEklD0mYwPP6fCD7MjofvhkHkj+XbXFPHm6ELKjzUc4OD8HWy4kpGHgs3VXOP1ldfjujwT6CpwgkyLZqSPZ8D8HbxQyy4tyvvju2IQgHbziQTk6IR1/DQ7yLLMmYH/Dga8ppXaUqJRGJ6bCzMWDyxK2ozJVtOJ7FsV0z1O7XoAW1HCmfLLW/W6bxpmkJe+eM4T/x4kOz8ousbxB2CP58S62ZWYmz+9ya63Ukk9YAUvStBoVAw8ZFZFCnUBCvjOLRnM2GLdrDrXMp1bXU6HRv01uZD21dvbW6gZzMUvbPyinCiDqK3mRosHMT6NRbnvfTZ3nujpcW5RNIksPcRtULNrIRo0XakeIgd9QlMWQvPnYJX4uHpCLh3OXSbUmFtm9ZutvQKcEargxkrD3Pqatb15zKgVMKYpeASKLLXfntYPIzXhe1CxL3idw/hVy2wMlcxfUBgpc3HdvUBYE1kXLnt2QXFFGt1ADjdYKY3wOguPliYKTmTmE1kbIbYOPA1UJrDhS0iqOAGOZ+UzajFu+j2drj4bUu9AL9OEQFLHe+HfjOv3ylkpAg40BbB2ueEm4dE0pwxZMPUo8W5r5M1dwaJ0jE/H7hcb+epltQLwgqzwDRZ01l5xaX25rWJgjfU/k45V23TNu4i0yc5u4D0qkQ2bYlw0tj4qvhd2PclHFkFp9fDxV2QcBzSL0Fexo2NewXZworu0y4iUGzTHNi7RGRzX94LGZdEQBcI5ySPUAi9Dx7bClPX1k2sNreEdneLTKrOE0ApMzolDYOvkzXtvOzR6mBLVGJDd6dZcDUjj90XxPP4uK6l998KhYLhoV4ArD9eSYkiiUTSPHBpDY9uFs/xJYXw9wxY94IoUwbCFc1Qx/ve5ZWWuLJWm/HOmFAAlu+J4ejljMrPGXAHeHWC4jzhMlYJ8atfRKUrYkdJKL2GPMCYLr74u9owIFjYp3+/56Jo6H8bTP4bLB0h7gB8P+rGAuMlEokEaOdtz9yRIjj7vQ2neWfdKaKTqwmmHvgaKJRwZh3E1tyVTqfTsfrgZQYu3MbKfbFsPJnI59sulG+UcRlWPQDF+dAmDKauA4UKTvwGp9fV9vIkklsGKXpXgZOLG+ahYwCYar2Ly2l5PLRsHy+uPkpmbmlkzKn4LC6n5WFpruTOYLcaH797S2cUCohO0ZCUnW/y/t+K1DnTG0ptNXKvr+sNsDe6+QQPSCRNGqUKpm2EV/XC9gMrYMhb0G0qBNwODj7GEgfVMXNQEBZmSg5dSmfkZzuZveY4qTkFFTe2dIAHVoqH74s765b9fOUQnA9Hp1AxJ0VkeT9ymz9udpXXlb27szcqpYLDsRnlbnYNYoqVuQpL8xsXFByszI01FlftjxUbnQOg5+NifdM8IdLUAZ1Ox097LzHys12cuJJFfpGW9//aj27VBOHO4dNNZORXJqwMex/MbSB2DxxZUac+SCRNBmNd74P1epoJPYX7w2+HLlNY3ADBJtoS4ayx+XX440lhwX2DZOYW0qYumd5uweI15Uy1TW0szPBxFJOzldb1Tj4L3w6Fv56GiMXw3zvCteTPJ+HnCbB8hMi6/qQjvNcS5nvDivvgwDJRa7smpF8SgvpH7YQVXcYlsHKCDuNEbcuwBWIi+ZGN8OwxmJMEL12Ap3bBuK9L/59JJI0cQ7b3Zil63xT+OHwFnU48g7dwLu9iNKyDSADYEpVIflHd7iklEkkTwcJOuMIMeFW8P/A1fH83HFstylqBCGp3rTw4HODOIDdGd/ZGq4OX1xynqKSSe1aFojTbe/9Xoh73NZzY9Q9e8Zsp1ik53uH/eOLO0rIYU/v6A8LJIsfgWubbDR5eDzbuIljx+1FQmFvjr0AikUgq4qFeftzdyZuiEh1f74zhroXbmfj1XtYdi6/4udwtCLpMEuubX6/Rc/OF5Bwe+GovL/52jPTcIuPz67e7YriaoR8fC7KF4K1JAvf2MH6ZGPf66cfStbOky4Wk0SJF7+rQDyr3qPbwaE93FApYfSiOgR9tZ/3xeHQ6HRtPiEjmO4PcsFbXvEy6g7U5bT3tATh4sXkMIpnlMr2da7ezQfTWlI+uLK3rnUlmXgU2HRKJpHFiApvUPq1d2PL8nYzs6IVWJ8Te/h9u45ud0ZXcTAbD6C/E+t4l4qFcz9WMPOLSq3jIPfMvrJoIwGXfUWxLscXe0ozHb6+6xqS7nSV3tBHj2x+Hrxi3p+uDq5xtbjzL24DB4nztsaul4+UdLwjBP+mkyLQ+vAKit4sMzAomC64lNaeAx344yJw/T5BfpOW2QFccLJU8nboARcoZsPMWwQTmlpUfxLEFDJgt1sPnXufoIZE0K3z0db2vHDKJEFwZd7V1x93OgpScwoYRiyJ/EOMOwOm1YoLyBlFmxWGryKdEYQbOrWq+o8HePP0iFFcSGFWGIA+R7X026Zqo/JJi2PmRELTj9oPaTliAd50i6mW3vkuIzS5txASqSh8QVZwH5zbCulnwcXv4oh9sfkNE8l8bjHR5P/w6GT7tLAT1gixxvBEfCSeU8d/CkLehz9OihIVfb3BqCWaVB19JJI2ZIXrRe8fZFCm01jM6nc5obT6+W4vrPu/k64iXgyWawhJ2VuCQd7PIzi9i0eazXEptOuU7JJJGiVIJd74EE34W90Sxe2DNo4g63lOvq+NdGXNGtsPR2pyo+Cy+2VmFHXC70eDoJxJljq4q99GpuHTMw4UAv9vxbp66d2S5Wrq3BbrSys2GnIJifj9UJgDRoz08/C/YekByVJ3thSUSicSAQqHg4/s7s2xKdwa2dTeWHZu+MpK+727h/Q2nuZx2zdxj/5dFmcfYCDi7odJjFxSX8HH4WYYt2sm+mDQszZXMHtaWbS/2p6e/MwXFWj7cdEY8Y/42DRJPiOfSib+IYCWAO18Wz5c5CbBxTj1+ExJJ/SFF7+rwvw2cAlAU5jCn1Tl+e7IPrd1sSMkp4OkVkTzx4yH+OSbqsA7tUHNrcwPNra53Vn4xLnXN9LY2iN7lH6ANdb21sq63RCKpAF8naxZP7MqvT/Shvbc92fnFvL0uiqGLdrD1dKKob12WdnfDbbMAKPlrBp+sWMOdH/xH33e3ctt7/zF6yW5+3HvJWG+b3DRY84SIkMxJQOccyKyUEQA8cWdrHKyrr8c9Vm8PuSbyClq9pXm6/viONdi/pnT1cyTYw478Ii1/GgR2a2e44yWxHvm9yEz84W74rCu84wnvt4Yv74CfH4T1Lwkr4sMr4OwmDkZsZfLHf7Aj6gpqlZI5I0L44ZGefN9iPXepjpCPmvzxP5TWaa+KXk8J2928dGHPK5E0VzxCQaUWfwtp0fV2GnOVknu7i7HH6P5ws8jPEtnPAH59xeumOXD18A0d1i77PADZNv6gqsXYaesBFvaiVloNvnNDXe9zZTO9E07ANwNhyxvCTjxwMEzfKyzA7/4U7vseJv0hbMWfOQgvnoO5SfBqIjy5GwbOE6U9FEox+bDrI/g2DD4IhN8fExbmXw+EZYPh1F+ir636w8TVMH0/9JgGauuKOyyRNGHae9vj5WBJXlEJu8/LoLn6JDI2nZgUDdZqlTGruyxKpcI4J/Lv8fib3T0j7/57mkWbz/Hy78cbrA8SiaQMwcPE/Y+LvpyMRwcY+m6Nd3e1tWDOCOHgU2VAi8oMek8X63sWGwMH49Jz+fO7BQQrLpGjsKXXIx+iVJYPsFcqFcZs7+/3XDQ+k4sOBMI9og44+74Qdb4lEonkBlApFQwM8WDZ1B7sfGkAz9wViJs+IP3zbRe444P/mPLtfjaeTCA1pwCdnRf01tfd3vx6hS6NERdSGbZoJ59sOUdhiZb+wW6EP3cnT9zZGnOVkldGhAAi2SZ1zYsi6NrMUgQmOZYJZjS3hHuWAAo48hOcu/FSiBLJzUaK3tWhUECXB8V65I90a+nM+mdv5393BWKmVLDpVCIxKRrMlAruautR68P38Bei975mInpn5hXhZBS9XWu3s9He/Pra3bKut0QiqY6eAc78PeM23hsXiqutmugUDY8sP8iU7w5wPikbTUEx/51O4u21pxhx4k62l3REVZLPmDMvkZGahEqpQKVUcORyBnP/PEGPdzbz+dJPKfi0Jxz7WQgVfZ/h1+6rOJhug6ut2vjgXB2D23lgZ2HGlYw89uuDdwz25qao521AoVAYs71X7Y8tFfx7PQlh84W7Seu7RNajuV48yU2B+KP6TMwvxQ32X0/DynvpvnEM60qe4KzlFKJsnuDRI/ei/HYwnS//AMALhU+w9JxDzTqnMhMWdyhEZL6cTJA0V8zU4NlRrF+JrNdTPdBDjAc7z6UQm3oT7Rp3LhTOPS6BMPmv0pqPqx8WgngdcdGIGmUax6Da7ahQlGZ7J1dvcR7kLkTvo5czoLgQ/psPX90J8UdE7cfRS+HB1eDgW9VhBOaW4NkBbn9elPZ48QKM/VrYlFs6QF4aHP9VWJhfOSgCIjo/JITyyX9B0JAal/yQSJoiCoWCQSHiOTz8lLQ4r08MWd7DOnhhY1Gxw52hrnd4VCIFxTc/8/5qRh6/HrwMQER0KhdTZLa3RHJL4BYEj20RQsrkvyqt410Z47r60C/QhYJiLa/8cfz6wHUDXR4S92JpF+DMejJyC3l62X88Xiwyv1V3zcbSoeKylGO7+mJrYUZ0ioad1wZRtRkknHsA/poubIElEonEBPg6WfP8kGD2vHwXSx/qyu1tXNHpYPvZZJ748RDd3t5Mu3kbuftId3KUdpB8mi2/fMJfR65w8GIaF5JzeP7Xo0z4ei/RKRrc7CxYMrEr303tUa4UTecWjozs6MVE5WZcTiwTG0d/ISzNr8WvV6nI/s+zN/SMLpE0BHKGpCZ0flCIGbF7IOU8FmYqZg0J5p9nbqOTr5jMHxjijoNV7bPxegQ4AXA6IatcnfCmSnl78zrW9K7A9lbW9ZZIJDVBpVRwfw8//nuhP0/c0QpzlYIdZ5MJW7STTm9s4uHlB/hmVwwnEzT8r2gG8QoP/JTJbPX/kSNz7mLv7IHMGRFCLw94X7mYpxPmYpGfTAw+fBO0lEPBs/h4m5homz4gsNIJwWuxNFcxoqOYJFwTKSYUDfbmTia0NwcY3cUHCzMlpxOyiYzN0H8xZtBnOtyzWGQizjgAr1yFl2LgyV0i8nP4h9BvJplB4zlo1pWT2pYk6JwoQdQbVxVmQup5iDsAwLngJ1ir7cOX26NJzMqvWed8u4lsRRBW6zWwGa43iguExXv0Noj8Ef5bAH8+LWq5/TAa/poB29+HI6vg4i5hi1zS9H/HJTcJ3+7itZ7rerdwtuZ2fXmFnw/cpGzv9IuwV58tM+RtIfLfsxgc/CA9RjxU19HW3aNAWF4WOQfXfmeD6J1yrtqmfQNdMFcp0F2JRLO4H2x/D7TFQryfvh86T6h7iQ5rZ+h4n7ApfzFaWGr2exYC7hBWc8+dhNFLhFAukUgAETwIsDkqqXx2nsRk5BeVsPaoyN4e363ygJ5ufk6421mQnV/MnvM3PyB96fYLFJWU/h/4+cDlm94HiURSCZYOQpS2qWUCDCLA6Z3RoViYKdl9PpXfI69U3NDC1vg8WbzzEx79/iDDM1biqsii2CkQq75PVHoOWwszowvS8t0V2KiHvSPs0zNipTOZpFmzYMECevTogZ2dHe7u7owePZozZ8oHDufn5zN9+nRcXFywtbVl3LhxJCaWD06MjY1lxIgRWFtb4+7uzosvvkhxcXG5Ntu2baNr165YWFgQGBjI8uXL6/vyGgxzlZKhHbz4cVovtr3QnyfubGWsxZ1XVMKxFAWLCu4GIOT0Z7z0837GL41g4MLt/B4Zh0IBk3q3ZPOsOxnR0atcCQcD80ISecNsOQAxoTOhw9jKO3TXHHDyh6w42Pyaia8W0GohL8P0x5VIgJoXoG7O2HtD4CA4t0nYOgx6HYAQL3vWPN2PQ5fSaetlV6dDu9sJa+7oFA0HL6UxMKT22eKNicy8Ipxv2N48+bqPrq3rXZcABIlE0nywszRn9vAQJvT04531UcbMIF8nK/q1dqVvoAt9W7vipmkH3wzGJWEnRLyP3cB5POp6kkeLZ4EqCS1KflTezfzc0RQcVcPRCAC8HSyNGdU1ZWxXX34+cJn1xxN4854OZTK9TTueOViZM7KjN79HxrFqfyzdWjpV3FChEOKLtTN4hgLw495LvLX9FIXFWlxt1bw/viN3BblBfoYYm3OSxKvKnMDg4XRN30tkbAYfbjzDB/d2qlkHB86DqH+EgL7rY1G7qCq0WijMEVmixQXCVri4ULy/dltRrn7JE6+F177PgayrkHEZchKBWk6cK5Rg5yWyOx39rllaiu2yrq6kJvjoo62vHKr3U03s6cfOcyn8ejCO5wYHYa6q55jY8Hnib7NVfwgaKrZZOQmR97uhcHKNEHi7P1zrQ/sWXxIr7m1r3y9XveVmytlqm3rZmvOtz1r6Jq5ElaFDZ+2KYsSHopZkXcXuilCZQcu+YpFIJJXSu5ULthZmpOQUcCQug65+ldzbSOrMxpMJZBcU4+tkZSzRVhEGi/MfIi7x74l4BrR1v2l9TMjM5+f9QuSe2tef5Xsu8tuhOJ4fchN+2yQSSb3j72rDzEFBvLfhNG+vO8WAYDdcbMWzVbqmkBNXMzl+JZPLcX15g09QXz2AX+FfTFP/C4DZsAXVlr+Z0keMHf+dSSYmRUOAq03phxZ2wub8+5FwaDm0HSUywCWSZsb27duZPn06PXr0oLi4mFdeeYUhQ4Zw6tQpbGzE38xzzz3HunXrWL16NQ4ODsyYMYOxY8eye/duAEpKShgxYgSenp7s2bOH+Ph4Jk+ejLm5OfPnzwcgJiaGESNG8OSTT7JixQq2bNnCo48+ipeXF2FhYQ12/TcDf1cbZg8LYfawEAqKS4jPyOdKRh7xKcFkbd2Md2Eic9x28WXxCOIz8wnxsuONuztUPr8HkHwG9w1PgELLmpLb+PLSXazX6lApK3l+VdvA3YvFmHfwW2g/Rjynm4KcZFEiMv6ISLCpw7O/RFIVUvSuKV0m6UXvVTBgjpiEQmQN9qzioa8m9AxwJjpFw/6Ypi965+Tl46DSW4zVNdM79/pMb0Nd7+gUDQcvNv3vUSKRmAZ/Vxu+ntydC8k5mCuV+LlcUw/VLhTu/gzWPCrseOMOlNpuuwajHP0FD3p1oeX5FNZEXmHjyQQKirW8ODQYCzNVrfrSvaUTvk5WxKXnselUorGmtyntzQ1M7OXH75FxrD12lbkj29UoUOirHReYv/40AP2D3fhgfCfc7PQCrkEcdyvNrlQAc0a2Y+zne/gtMo6p/fxp710Dq3NLB1Hj7beHxXfeaoAQk7OuCEHa+KpfsuNBW08Z1mZWoraRQwv9q6/IRtWVCGE8MxYy4/TrcUJcz7oilsv7KjigQtQ3N4rgPqCyAKVKXKNSBQrVNa/K60W0yrJgO0+stVWg5BbFIHrHHxMBG2amHwcMDGrngautBSk5BWyJSjLWY60XLu0R9agVSlFSoez/7RY9YOBrED5XWHn79qhdNrNWi7/2MijA3Kt97ftmGL9Sqrc3Z+Nsbk9aAQr4o6Qf7kM/pl/7OmSXSyQSk6A2U3JnsBvrjsUTfipRit71gMHafFxX3+tq4V7LsA5e/BBxiU2nEnmnRHvTBOel2y9QWKKlp78zr44IYe2xeP1vWyJDO3jdlD5IJJL65dHbA/j76FWi4rN4akUkztZqTlzNJC49r1y7jma3M8HsPz5Uf4kSHbQeCG0GV3t8f1cb+ge58d+ZZH6IuMhro665pwy4HXo9JWp7/z0Dno4QwZsSSTNiw4YN5d4vX74cd3d3Dh06xB133EFmZibLli1j5cqV3HXXXQB89913hISEsHfvXnr37s2mTZs4deoUmzdvxsPDg86dO/PWW2/xf//3f7z++uuo1WqWLl1KQEAACxcuBCAkJIRdu3bx8ccfN3nRuywWZir8XW3wd7WBQFeweA3+eppJRb8x6dm5aC0cqr03Q5MKK++DgkyKfXryzpWnSE3K4fdDcdzXo0Xl+wXcDt2nwcFl8Pcz8NQeIYbfCKkX4KdxwuUNYO1MofXc/oJpA8glzRopeteUoKEi0zgnAc6HQ/Awkx26Z4AzPx+4bKzj2lTJLyrBqjgbpZl+sr62N4ZGe/OKbdJ6tXIhOkXD3uhUKXpLJJJa0drNtvIPO94LVw/D3iVC8FYood9MuPP/wNwSM6B/sDv9g93Jyi8iMTOfNh61d/9QKhWM7eLDp1vPsyYyDhu1+Ik2daY3QFc/R4I97DiTmM2fh68wpZra49/vuWgUvP83sA3PDWpToVXS9edxYmRHL9Yei+eddVGseLRXjfaj/Rg4sgLOb4Zvh9TkkgRKMyEim6mvebUQdXDNrUFtLYRhc2v9YlVmu7UQpR1aCGHa2qXmN91archyz4wTYnhGrBDDMwzrl0Q2eXa8WCoUxW+QdqOl6N1UcG4l6hHmZ0DiCfDpeuPHTL8k7NKDhpZ7UDVXKbm3uy9fbLvAqv2x9Sd6a7WwYbZY7zoZPCoQpvvMEOUCzm2E1VPh8W3CprIGFKXGYKUoJF9njo1HYO37V9beXKutvE72vi9h/1eAgj8CXuO5qCA67Ujmz9Cgmo1vEomkXhjSzoN1x+LZfCqR/xtaB7cHSaXEZ+axS1/fdlzXyq3NDfQMcMbFRk2qppC90anc3qbi+rmmJCkrn1X7RZmOZwe1KffbtnL/ZSl6SyRNBHOVknfHhjLm893sjyk/h9rSxZoOPg6E+jgQZDMb1v4nBG+F6vpgyyqY2i+A/84ks/pgHM8PCcb22pJlA+eJeeHU8/Dv/8HYr0x1eRJJoyQzMxMAZ2eRFHjo0CGKiooYNKjUCaFt27b4+fkRERFB7969iYiIIDQ0FA+P0vn7sLAwnnrqKU6ePEmXLl2IiIgodwxDm5kzZ9b/Rd3KdHoA9nwGyVGwexFKvSNxhRTlw9FVsPsTUWbMyR+ziat48lAW76yPYmH4GUZ28sJaXYVEOPgNkQiafhG2vg1DF9S973GHhPiemyISQYLCxLP11reF3hM2v/LncImkFkjRu6aYqcWgErFY1PY0segNcDwuk9zC4qoHmkZMVl4RTnprc52lIwpVLa+zCntzEHW9V+2PlXW9JRKJ6Rn8JmiSIPMKhL1dmoV5DfaW5thb1l2kHtPVl0+3nmfH2WRa6YV4U9f0BlETbWIvP177+ySr9scyuU/LSsWaVftjee3vkwBMH9CaWYODanWu/xvalk2nEtlzIZWtp5NqFpSkUMCIhfDNIMhLBztvUWrE3gvsffTr3mLdzksERaksGvbmWKkEOw+x+Fbw/0Ong9xUIX4bhPCsq6IOuK4EtCWg0+pfS8q/1pRq7PokjQiFQowzF7YIi/MbFb3Pb4bVj0BBphDTezwKPR8X/1+BB3q04IttF9hxLpnLabm0cLau+nh14dgvwr5MbQcDXq24jVIJo7+ApbdB6jlY/wKMWVqjw+ddOYE5cEHnTVtry9r3z8kflOb64JSrwtnhWs5uElnoAIPf4PZOT2L13n8cjctkc1SSsa6wRCK5+fQPcsdMqeBcUg4XUzQiG0ZiEtZEXkGnE/MW17kiVYBKqSCsgycr98Wy/njCTRG9l26PpqBYS7eWTvRtLRzlDL9tO+vzt00ikdx0OrVw5N1xHYm4kEqIlx0dvB1o7+NwjXtZazg/Ek6vFTW+a1H65vZAV1q52RCdrGFNZByT+/iXb6C2htFLRXD2sV8gZJRYJJJmiFarZebMmfTr148OHYRLV0JCAmq1GkdHx3JtPTw8SEhIMLYpK3gbPjd8VlWbrKws8vLysLIqH/BfUFBAQUGB8X1WVtaNX+CtiFIlSu+uuh/2fiGe6+29y7fJTYMD3whB2aCj2LjBhF/AxpXJfZ34PuIicel5LNsZwzMD21R+Pgs7GLVIZGfv/UIkW/j1qn2/z+oD24tywasTTFwt5iOcW4ln7H1fQF4a3LNEzm1Jbpimqa7WF10mCdH77AbITjROFN4ovk7WeDtYcjUzn8OxGfQLdDXJcW81MvOKcEaI3oraWptDGXvz1AozcGRdb4lEUm+ozGDcN/V+mgBXG7r6ORIZm8H5pBygfuzNAUZ38WH++ihOJ2QTGZtRYe2fNZFxvPLHcQAevS2AF4bU3r63hbM1D/fz58vt0cxfH8UdQW41s7l08ofnzwCKphHpqVCI3zEb10qDJiSScvh2LxW9eaxux9DpYN9S2PiKCKowtxbZ4zs/hD2fQsf7oe8ztHQLpl+gC7vPp/Lrwcs8X4e/9Sop1MCWN8T6Hc+DbRU1Xm1cYPwyWD5SRKX73w5dHqz2FEXxIjgnWuFH++rs3SpCZS4euFPOQPKZ60XvxJPw2yPie+wyCfr+D1eFgqn9/Pli2wU+Cj/LwLbu1VvLSSSSesHB2pyeAc7suZDK6kOXeaRfAM426npxYCjR6kjKzicuPY+EzHzMVQqs1WZYq1Wlrxb6dXNVox4XdDodv0cKa/Px3arP8jYwvIMXK/fFsulkAm/d0x6zerQ4T8rOZ8W+SwA8O7DUjailiw19W7uI/xMHLzPL1L9tEomkwbivewvu616FJS+IMmVtR0CHcbU6tlKpYEoff177+yTL91zkoV4trx/HW/SAfs/Cro/hn5ng16d0zrI5otUKd7wz60WpL8eW4r7auRW4tBZOn9IRqUkyffp0Tpw4wa5duxq6KyxYsIA33nijobtxcwgKA7++ELsHti0Q4x2IbOyIJXD4JyEug3Ay7P00dJ0kBGyEZfqLYcE8+/MRlm6/wAM9/UrLF1ZE4CDo/BAc+Qn+mg5P7qydy2DkD2Ks1JWIchP3fW/sC72fAitn+OtpEUiUlwH3LhcBRhJJHZGid21wbyvqC8YdEJNwt8002aF7Bjjz55Gr7ItJa9qitz7Tu9b1vKE001tXIiZsrcvXUpd1vSUSSVNgbFdfImMzjO/rS/R2sDJnZEdvfo+MY9X+2OtE77XHrvLC6qPodDCpd0teHRFS54nj6QMCWX0wjgvJGn1muX/NdlTWri66RNKkMARHXDlUt/2LC2H98+IBE8RD6ogP4Vy4ELzjDsDhH8USNJTpARPYfd6MXw5c5tmBbUwrUOz+RNj6O7YUdRCro2VfGPAKbH1LZHv7dKs2Q0eRLEowxJm3rHs/XdsI0TvlHAQOLN2enQgr74fCbCHCj/jIOHH3xB2t+CniElHxWfx7IoERHaWFrkTSUAxu58GeC6ks+e8CS/67gIWZEm9HK7wdLfF2sCpdd7TCwcocBVXf1+QVlXAlI5e4tDzi0vOIy8glLj2Pqxl5FJXoatwvK3MV9lZmuNhY4GKrxtlGLC42apxtLMS6frujlTkOVub1KhLXhsOXM4hO1mBlrmJ4aM3Ht16tnHGyNidVU8j+i2n0bV1/cxxf7xBZ3l38HLm9TfnzPNDTjz0XUvn1YBz/M/Vvm0QiubWxdobOE+u067huvnyw8QzRyRp2nU/hjqAKHCv6zxaZi0mnRE3a+368tYRdnU7UzM2KF1mVNSwZVGOK8iFmuxC6z2wQ5UArw9KhVAR3bgUugdCilwh0v5W+M0mtmDFjBmvXrmXHjh34+pYGxnl6elJYWEhGRka5bO/ExEQ8PT2Nbfbv31/ueImJicbPDK+GbWXb2NvbX5flDTB79mxmzZplfJ+VlUWLFtUExzRWFAphO75ssBC4W/WHqH/g1F8iSBvAMxT6PgvtR1eYOT2qozfLdsVwLC6TT7ac5e3RoVWfM+xt4SCXeg5+Gi8C04OHVV2+VqeD7e/DtvnifacJQqC/tj+d7hfH+XWyKHX242iY+EvtS+NKJHqk6F1bukzSTxL+JKL6TPTj3DPAhT+PXGV/TMX1qpsCQvTWW4vURfQ2U4OFg7DmzE29TvQGWddbIpE0fkZ29OLNf05RWCJuVJ1s6s+1YmIvP36PjGPtsavMHdnO6JCx8WQCz/58BK0O7u/egjfubn9DmVL2luY8N6gNc/86yaLN5xjdxeeGbOAlkmaBQfROOSuina0ca76vJgV+mSQivxVKGPK2iO5WKKDd3WKJ3SfE79Pr4OwG+p7dwDrL1izVDGPRv64M6xpAW097VDeaoZh5BXZ/KtYHvwnmNbQev22WqO8d/Z+wQXt4vbBmr8T5QZ12BoBEi1Z176tbsLDBTDlbuq0oD36eAJmXxQTd/T+Ke1I9jtZqHrktgE+2nOPjzWcZ2sHzxr8ziURSJ8Z28WXr6SROJ2STnF1AQbGWmBQNMSkak5/LTKnA29EKTwdLtFodmsIS8gqL9a8laAqL0el18byiEvKKSkjMKqj6oGWwszTD0docJ2s1DlbmOFqrcbIWZXQszJSYmykxVylRqxSo9euGxcJMiY+TFf4uNqjNbkzk/e2QyPIeFup5fV3bKjBXKRnSzpNfDl7m3+MJ9SZ6p+QU8ONekeX9vzJZ3gbC2nvgZG1OQlY+288myzkCiURSI2wtzLi3uy/f7b7I8j0XKxa9zSxEGZ6v7xJi0/HfoOO9lR80L0PMJyedElmNDj5g7ytsiU0hSBdq4EokxO2HuIPiXAZbY6UZ+PYUwlirO8VzRl3sgzWpQpA6vQ4ubC3NJAVRwqjNIPBoL0p5pcVAWrTI/M7PFJngVw+XP55DCxFQGnC7eHVsogJlE0On0/HMM8/wxx9/sG3bNgICAsp93q1bN8zNzdmyZQvjxgmnhTNnzhAbG0ufPn0A6NOnD++88w5JSUm4uwsXsPDwcOzt7WnXrp2xzfr168sdOzw83HiMa7GwsMDCoops5aZGi57QVl/G4bdHSre3Hgj9/gcBd1apWymVCl4ZHsIDX+1l1f7LTO0bQKB7FWORlROM+gR+ngiXdolFaSb+dtvdDcEjyrsilxTDulkQ+b14f/vzcNfcyvsUNAQm/ylqfl/eB98Nh4fWiDKHEkktkaJ3bekwVtQZSD0n/gD9epvksIa63odjM1h/PJ703ELSNYWk5xZdt15UrOX+Hn482b8VFmaNJwsuK78IJ729OTZ1EL0N+xVkihs31+vrTci63hKJpLHjaK1mYIg7/54QkdL1lekN0NXPkWAPO84kZvPn4StM6evPf2eSmLEykhKtjjFdfJg/NtQktpwTevqxfM9FLiRrWPLfeWYPCzHBFUgkTRgbV5EZnXFJTBC1HlCz/RJPwsoHIDMWLOxh/HdiAupa/HqB3wpIvSAs0I6soH3xBT5TL6bwwBcc3d+aZcoOZHn0wjH4NroG+hDq41Cz8gRl2fIGFOcJ+7V299R8P6USxn4l6nsnR8H7+skUMytQ2wi7M3Mb47p15nkA0mxa165/ZXENEq8G0VurhT+eFNn2Vk4w8dcKo82n3R7A8j0XOZ+Uwz9HrzK6i0/d+yCRSOqMg7U5P04TNQYLiktIzCzgSkYe8ZkiO/tqZr54zcgjJ7+42uOZmynxcbTC18kKXyfrcq8e9pZVBrjodDoKirVoCorJLSwhI7eIVE0BaZpCUnMKSdUUkmZ4rykkTVNIWk4h2QWiX9n5xWTnF3M5La/O34dKqaClszWt3W0JdLcl0E28tna3rZGAnV9Uwj9HrwIwvmvNrc0NDA0VoveGkwm8fnf7egkI+npnNPlFWjr5OtC/AlHKwkzF2K6+LNsVw6r9l6XoLZFIaszkPv58t/si/51J4mKKBn9Xm+sbeXWCO/8P/ntHOCz53yYEGp1OCL6X90HsXri8X9zPVoalgxDAHXzA3ke8WtgLQUmlFgK1yhyU5vr3+u1ZV8Wx4/ZD4inhjFkWpbl4psiOF8GwsXtExqXaVvS1VX+xuLUVQlShRhzTsGQb1uNFAGjiidIsUhB9DR4GwcPF8cwqEByL8oTlclq0WFIvCOH/yiFxzKMrxQIi89v/dgi4QxzPzqtmyWY6HZQUiv4X5YpzGtYLc6E439CwtH3pzqWrCpX+e1aJ715prn81E9+50qzM/jrxXej0r+jEoQzrnh1rHuzbyJg+fTorV67kr7/+ws7OzliD28HBASsrKxwcHJg2bRqzZs3C2dkZe3t7nnnmGfr06UPv3kJHGTJkCO3atWPSpEm8//77JCQkMGfOHKZPn24Urp988kkWL17MSy+9xCOPPMLWrVv59ddfWbduXYNd+y3HwHlwfgtoi6DDeOj7DHh2qPHuvVu5MCjEnc1RSby34TRfT+5e9Q7BQ+HpCDj5B5z6G5JOiiD16P9g7SxR6iFklLBDD58rSgQrlDD8A+jxaPUd8usND/8LP44V48S3Q2DSn6JMgkRSC6ToXVss7KD9GDiyAiJ/NJno3drNBhcbNamaQp5eEVlt+483n2Xtsau8Oy6Ubi2vz3i+FcnMvUF7cxAW52nRIoOpAmRdb0lTZ8mSJXzwwQckJCTQqVMnPvvsM3r27Flp+4yMDF599VXWrFlDWloaLVu2ZNGiRQwfPvwm9lpSW8Z29eXfEwmozZRYq+svuEmhUDCxlx+v/X2SVftjCXS35ckfD1FUomNEqBcfjO9osglKM5WSV4aHMO37g3y3S9RGa+Esa/RIJFXi212I3lcO1Uz0Pr0e1jwGhTnCOnDCzyJ7uSpcWsPIj2DAKxTu/ZqC/cuxK0igh+IsPTgLiWsoSlBxdFtrvqUd6e49sW9zG51a+9DR1wG7qlwb4g6JulwAYe/U3iHJ1l2I9r89DDl6a7viPLHklm+qBFJ09hTZ3oDgbAioNIje/70Dp/4UE173r6j0Ydve0pzH72jFBxvPsGjzWUZ29JIWuhJJA2NhpsLPxRo/l4a511AoFFiaq7A0V+ECtKjhI3txiZbMvCIy8orIyC0kI7eIDH3we2ZeEZl5RRSVaCks1lFUojUuBcWGdR15hSXEpuWSU1BMdIqG6BQN4afK24N6OVji62SFk7WwVXeyUeNsrX+1ERnmx69kkp1fjI+jlfE5uzb0a+2KnaUZydkFHLqUbgz0NxVpmkJ+jKg8y9vAhJ4tWLYrhq2nE0nIzMfToWmKEBKJxLQEuNowINiN/84k80PEJeaNaldxw9ueExbfVw/DLw+BrYcQu3MrmLd0biXE0MIc4YaUdQUKskQmdH6mEJBuBHsf8fzg21NkgRqE17QYYUUevQ2it0NemhCjzm4Q+1m7iKzMgszqz+ERCm2HC6Hbq1P19/fmVuAeIpayFGpEQMDFnRCzU3x/6RfFcvjH8m0VKiGcKfWvCpUIkFUoRb+Lcq8X/BuaZyKbrFD3xRdfANC/f/9y27/77jumTp0KwMcff4xSqWTcuHEUFBQQFhbG559/bmyrUqlYu3YtTz31FH369MHGxoYpU6bw5ptvGtsEBASwbt06nnvuOT755BN8fX355ptvCAsLq/drbDS4BcOMAyLgxNa9Tod4eVhb/juTTPipRPbHpFV/v+YWDP1fFkvqBYj6WwjgVyNLg2s2zhZtzSxh3DIIGVnzDnm0h2mbhMV5WjQsGwJthuiDfyoKAtK/V9uKAHUrJ+GSZ+UknOIs7GQZhWaIFL3rQpdJQvQ++QcMe1f88VRHkT5C2/z6mhMgHopnDmrDT3tjsbM0w8lG2Jc56R88nayFpZmzjZrY1Fzmr4/iXFIO45dG8FCvlrw0NLjqScdbgMy8YnxvVPS20UdvV3TziKjrHeBqQ4ys6y1pgvzyyy/MmjWLpUuX0qtXLxYtWkRYWBhnzpwx2gGVpbCwkMGDB+Pu7s5vv/2Gj48Ply5dKldTR3JrMiDYjYm9/PB3sb4hW/GaMLqLD/PXR3E6IZup3+2nqETHoBAPFj3Q2eSizV1t3ekX6MLu86m8t+E0iyd2NenxJZImh083OPE7bHsXjv0qJk6cW+lf9ev2PuIhbtdHsOUtQCeszO5dXmEpmEqxcUU9cDbqu16G9IuUxOwk6/Q2zC7vxi4/ge6Ks3TnLKT8SVGyirO7fdmoa0myTRuUnqG4BnanXeuWBHnYiWAZna70YbfTBPCp49+7fz94/oy4ly7KFZOEhbnXrW89FsO7J+zoYn0DlnaGTO+cRNi7FHZ+KN7f/anoRxVM7evPt7tiuJiay5rIK9zXQ9ozSiSS2mOmUuJia4GL7Y3Zc+p0OhKzCjiflMP5pGzOJ+fo13NIySkkPjOf+Mz86g8EjOvqUyfXH7WZksHtPFgTeYX1x+NNLnp/vTOa3MISQn0cuKtt5RO9ge529PB34sDFdFYfvMwzA693jJNIJJKKmNovgP/OJLP64GWeHxKETUUuGSpzGL0UvrwDrhwss90CvLsI8blFL7HYVmCTnp8lxO+sK6VCeNYVIQqXFIlFW1S6XlJY+t7SAXy6Q4seQuh2qCT40zlALN2mCiejxON6AXwbXNojSkgaUNsKy3U7L/GcYe+lf+8tMkgd/W7gGy2D2gYCB4rF8D3E7oWLO4QIHn+U0szsErFoi6o/rtK8jCOUNZhbC0FQUXZuo8xvmmG+RafTn6NYLCXFpevGbUWl+yiU4jgKpf4YhnX98ZVNV3LRlcuUrxhLS0uWLFnCkiVLKm3TsmXL6+zLr6V///4cPny4yjbNnhssCxDobsf9PVqwcl8s76yP4s+n+9Z8HtKltQj8ue05yLgsrNaj/hHjipXj/7N33+FRlen/x98zk957gwChSgdpIoq6ohTlZ1cUpdkFFNFVWZViY3dZXdRVUVdl96ui4mIFRUUBlSqI0muo6QnpPTO/P04yEFNIQiaTST6v65rrzJzznJlnDjk3M3Of537g5g+NCnP1FdwepnwD714LSb+fqgbRECbLqSS4p79ROc7N08jRuXlWfWx2P1UxoiT/VMWIkgIoyStfFhjtPf2NmOnpb1Tn8PSvfHP3Mf6PcPMsT9CX39wq7nsaF/NYK2JcWXkFiTIjVlesAyNmegWUv06AUX2iLkqLoCjHuLCqKMeIZRUxrOKCokoXFZXfLO6nKl5UVLowl19g8Me/D5utPE6e9j6spZUrg1TE3er+tkym8uomjTfoq+VGYEdqdx6EdjFKnO9YBgMm1tzWWgab3oTvnzYSvXesqv5DDnDb0A7cNrTDGV9+UIcQLu0ewbPLd7N0y3H+b8MRvt2VzFNX9eTynlENfFOOl1VQQh/ONuldvl8NI73BKHEer3m9pQV64YUXuPPOO5k8eTIAixYtYvny5bz99ts89thjVdq//fbbZGRksG7dOtzdjYtiOnTo0JRdlgZys5h57preTfJagd7uXNknhv9tPU5JmY2Luobzyvj+9S9hXAcmk4nHx/Tgipd/5MvfE+kXe4jhXcPpHO7XKCXURVqcbqNh7T+M0Rhpe43bH7l5GVd1Zx41Hg+6E0bNb9g8fWB84QiJwxISR/CACca6k0ewxv9Izt7VWI7+jF9BAj1NR+jJEShcC4eBw5DwbQg/0oGT/l2JDPDi/ISN2Nx9MF06u2F9Ob1PHj7Gzbf6eWHXH93FPls8F/ucxUWgnv7GD3o5CfD1o8a6C2ZCv1vOuKuvpxv3XtyJZ5bv5sVV+7m6f5uznktXRKShTCYTUYFeRAV6cUGXynEzM7+YAym5JGcXkVE+lVpGXjGZ+cVk5JfYH5/MLybAy51xgxue4BjTK5plW0+wcmcSs6/s0Wif907mFfPfdYeB2kd5Vxg3qB2bD5/kw1+OMfWSzvrcKSJ1cmHnMDqG+XIoLY9lW4/X/JttxDlw3ZtGsie6r5Hgju5bfbnvP/IKMG5/HAntKGaz0bfovjDsASgpNKZH8vA1ktteAU3Tjz/yCjDm9O16ufG4uDy5ZLNWTgTZH5eXFTdbjMRSRYK7od+BRFqxGSO68OmvJ/jtWCaDnl1Fm2Bv2gZ5ExPkRUyQN22CvIkpn/In0Nu9+s9dQbFw3r3GLT/DODe9AhveKb9wmLzCyL0VnDztAqDiyhcBVSyLcqAw02hbUL4sKzLiRn565Yt7WgJ3n1PJdq/yhHtZiVE9pCjn1K2suPFf22Q2kuAV8ZgzXwhzRlM3nblKYT00i6R3fcr1Ll682J7wqeDp6UlhYd2uUm4UJhP0vxW+m2OUXKkp6Z20HT6/3yjvAMZolP/dDrd9ctZXLgT5eLDghr5c078Nsz7ZzpH0fO76vy2M7hXFvP/Xk4iAOpTsOvyT8cffbfRZ9aWusgpKCG6M8uZwhqR3KEs2HdO83tKiFBcXs2XLFmbNmmVfZzabGTFiBOvXr692n88//5yhQ4cydepUPvvsM8LDw7nlllt49NFHsVgcVzJbXM+UCzrwxW8JDOkYwuu3DcDTzXF/Hz1iArhhQFs++uU4zyzfDct3E+DlxoD2wQzsEMKA9sH0bRuEtwPLuou4jJCO8OcDxnx36Qcrz4WXcdAo/1daaCS8TRYY8/e6zZVVX8HtMQe3J/DcW43Hmccg8Tfyjm4j9+g2PNN2ElSUQIwpgxgyIHcr5BpN/1V0Bds/TeCyHmVc2j2SEF+Pxu8fxudMgACvs/x6E9bFSHqDMQf5n56s8663nteeN9Ye4kRmAR/+cozbzmt/dn0REXGAIB8PBnao26hrm812VlWHLugShp+nG4lZhWw7nsm57YIb/Fyne+unePKKy+gRHcCI7mcu5zmmdzRzv9jJ8ZMF/HQgjeHVzP8tIvJHZrOJied3YM7nO/n713v5bncKnSP86BTuR+cI42b/bNvjKuPmaty9oO0AZ/eiKg9f43aW3t94lK92JPL8DX3r9lu5SCsU4e/FzMu68szy3aTlFpGWW8RvxzKrbevrYeGyHpHMGNGVDmE1nKP1qThXG0//2geb1sZmMy6cOT0RXpRj/H5SWlQ+bVqR8bik8NT6smJjFLeHr7F0L7+g5vR1bt7G/qcnl6vcso3XLysxku9lxVBafFqivnydtaya6RssladxAONCoMJs43Xh1Cj0imngzsSjfPS5xf1UZYtqLyqynqp6UVZCtQltm9UxyfRG5PSkd33L9QIEBASwd++pkS6OLv1arb43w6qn4PhmSNljXNVXoTgf1vwN1r1s/JF4BsD50+GnfxpzqKyeD396olG6cX7nMFbOGM6Lq/bzxtpDfLUjiZ8OpDFrdHfGDYqt+QrmXZ/DRxMAG1z7b+hzQ6P0pzbZhSWEnPVI79rLmwMMidO83tLypKWlUVZWRmRk5eoFkZGR7Nmzp9p9Dh06xPfff8/48eNZsWIFBw4c4L777qOkpIQ5c+ZUu09RURFFRUX2x9nZ2Y33JqTZ6hkTyLY5l+HtbmmS/1OfuqoXscE+rDuYzrZjmWQXlvLD3lR+2JsKgJvZRM82gQxsH8x157alR4yTrjYXaQ7MFgjuYNy4tPK2slIjIZ5xqLxsYcem6VNQLATF4tv9SuxfcwuzKUvaQdqBLeQe+RX3tF0cL/LmlcIxFO5K5ptdyZhNMLBDCJf3iOSyHpG0Dz37H7IqVCS9z/pzX1Rv4/N6zLlGqUpz3Udre7lbmPanzsz+bCf/+n4/Nwxoi5e7LuAREdd1tp8LvdwtXNo9gs+2JbDwu/2M6RVFZIBX+c2TYB+Peo+6zswvZnE9RnkDeHtYuKZ/G/67/ggfbD6qpLeI1Nl1A9ryyg8HSMkpYs2+VNbsS620PcTXg87hfnSK8KVP2yCuH9DWIVXTpP4OpuYy5/MdlJTZeG7FbhaO6+/sLok0W3dc2JHrzm3L8ZMFnMgsICGz6jItt5i84jI+3ZbAF78ncsOAtky/tAttgqqfztepTq8WFxDj7N40nrKSyuXKi7KNZHhRjlE2vVKp9YBTJdjr8btGJVarMcK+IgluLTv12J6kdytP0Jcn7M1upyXvy6e+g1NL40HldY1Y2hyaQdK7vuV6obxUV5STy3j7R0LXkbB3hTHae+SzxvoDq+DLByHziPG4x1Uw6m/GHCjBcbDsDli7wCh10+WyRumKl7uFR0edw9g+Mcxa9ju/Hc/iL59s572NR7jzwo5c0Se68geuoxtg2Z3Y/7i+eMAoaxPetVH6UxNjpHf5sJ8GJ73PPNI7KlDzeosAWK1WIiIieOONN7BYLAwYMIATJ06wYMGCGpPe8+fPZ968eU3cU2kOfDya7iOBl7uF6Zd2YfqlXSgps7I7MZtfDp9ky5GTbD6cQUqOcVXpb8cyeW/jEd6aOIhhnasvaSzSqlncTs3R52xeAVg6nE9kh/Op+OQVa7PxcUI23+5K5ttdyexKzGZTfAab4jN4Zvluukb6MbxLOD7VzY94GovJxMXdwukbG1RjG/tI77NNel/wIAS1h97XG1+Q6+mmQbEsWn2QhKxC3tt4lNsvqPnfJj23iA2HMkjPK+LGgbFKkItIizSmdzSfbUtg7b5U1v4hWeRuMRHhbyTAIwO8aBfiQ4+YAHpEB9Ax3A9LNQnxt38+TG5RKedE+XN5j7p/1x83qB3/XX+Eb3Ymk5pTRLj/2c2bLiKtg5+nGz88fDG7ErM5kJLLgZRcDqYay+MnC8jIK2ZTXgabDmewZNMxPth8jJfH9addaP0/R0rjsdlszP18JyVlxm/fn25LYNKwOPrV8n1CpLUL9vUg2NeD3m2rL0teWFLGrsRsXl61nx/2pvLB5mMs23qCW4a0Y+olnfXZqilY3I2R9I01mv5MzGYwewJn8W9bcYFqEw5cdmrSuyHlegFyc3Np3749VquVc889l+eee46ePXtW29ahoxb732YkvX/7AIZOhe/mwu8fGtsC2sCYf8A5Y06173MDHNsAm/9tJJ3vXgtBDZ8f6496xASw7L5hLF53mOe/2cvOhGxmfLiNv361h0nDOnDz4HYE5h2GJeOMkg3dxhhXgRz+EZZONOYbb8CPe3VVkJ+Pv6m8BENDT8yKZHktSW84Na/3J7+eoG9sEGF+Crri2sLCwrBYLCQnVy5bkpycXONFQNHR0bi7u1cqZd69e3eSkpIoLi7Gw6NqidlZs2Yxc+ZM++Ps7GxiY2Mb6V2IVOVuMdOnbRB92gYx5YI4bDYbx08W8MuRDD7cbExVMWXxZv49cSAXdtGoHBFXYjKZ6NUmkF5tAnnwsq4cy8jnu91GAnxjfAb7knPZl5xbp+f653f7+NM5ETxwaZdqk99ZBaVAI4z09g2DIXc1eHdPN+OinlnLtvPa6gPcPDjWflFRdmEJmw5lsO5gOusOprEnKce+37e7knnjtoGa2kFEWpzLukcyd2wP9ibnkJxdRFJWISk5haTlFlNSZuNE+QiiP/JyN3NOVAA9YgLoGRNAz5hAYgK9eOfneMAY5V2fUeI9YgLoGxvEb8cy+d/W49xzUadGe48i0rL5eroxqEMIg/4wNURBcRkHU40k+P7kXP67/jC/HctkzEs/8uw1vbiqXxsn9VhW7kzix/1peFjMDOkYwo/703j6y118fM9Q51SMFWkBvNwtnNsumHcmD+aXwxn845u9bDiUweJ1h/lw8zEmDevA3cM7EuTjmCnNROrKqUnvhpTr7datG2+//TZ9+vQhKyuLf/zjH5x//vns3LmTtm3bVmnv0FGLXS4Hv0ijdv6L/Yxa/JhgyD3wp8eN8gF/NPI5OLHVmOf7o4kw5Wtwa7yErMVs4vYL4rimfxve23CE/6w/QlJ2IX/9ag9LVm3mU6+5BBefhDYD4bq3jKT3ogsgZRes+DNc/Uqj9aWKAmOObZvJgsmz+iuGzqhipHct5c0Bzu8UxpJNx/jy90SWb09kYPtgRvaMYmTPKGJDdLWluB4PDw8GDBjAqlWruPrqqwFjJPeqVauYNm1atfsMGzaM999/H6vVirm8jMm+ffuIjo6uNuEN4OnpiaenLhIR5zGZTMSG+BAb4sOY3tHc9+5WVu1J4fb//MKbEwZykcpRiris2BAfJg+LY/KwODLzi/lhbwq/HcvCaqtmnqjTpOUW8fWOJL7fk8L3e1KqTX5nN1Z580Zw/YC2vLb6IEcz8nl2+W4CvN1ZdzCd7cczsf7hrZ4T5c/RjHx+3J/GpHc28dakQfidYeS7iIgrMZtNTBpWtepFcamV1NwikrMLSc4qJCm7kEOpeexMyGJ3Yg4FJWVsO5bJtmrmlOwa6ceonvWv/nfzoFh+O5bJh5uPcffwjkp8iMhZ8faw2C/wBLh5SDtmfPArmw+f5IEPtrF2Xxrzruqpz3ZNrKC4jKe/3A3A3Rd1ZPyQ9lzyj9VsOXKS5dsTubJPCyp1LOIkAzuEsOTO8/j5QDoLvtnLb8cyeW31Qd5df4Q7h3dkygVxin3iNCab7Qy/MjlQQkICbdq0Yd26dQwdOtS+/pFHHmHNmjVs3LjxjM9RUlJC9+7dufnmm3n66aerbK9upHdsbCxZWVkEBDTCHKHfzoGfFxr3I3vD2Beh7YDa98k8CosuhMJMGHQnXPGPs+9HDYpKy/hsWwLvrd3FM5mP0Nt8mMPWSF7t9BrjLjmXc9sFU3ZwDeZ3r8Zks3Jg6N/YFfX/SMspIj2viPTcYopKrXSN9Kd3m0B6tQlo8NU618xexCfmRynzCcfyyIGGvaHsBHihuzE3wBOpNc5HUFJm5e2f4vny90S2n8iqtK17dAAje0YyupMnXTc8hslkNkblB0Q3rE/iVNnZ2QQGBjbeOd2Mffjhh0ycOJHXX3+dwYMHs3DhQj766CP27NlDZGQkEyZMoE2bNsyfPx+AY8eO0bNnTyZOnMj06dPZv38/U6ZM4f777+fxxx+v02u2puMrzVNRaRlT3/uV73Yn4+Fm5vXbBnBJtwhnd8tl6Zx2LB1fx4lPy+Nf3x/gk1+P2xPHpye/e89ZSU5RKd8/dBEdw/2c21ngf1uO89DS36qs7xjmy9BOoZzfKYzzOoYQ6ufJliMZTHp7MzlFpZzbLojFUwYT4OX85L3onHY0HV+pSZnVxuH0PHYmZLMrIZudCVnsSsgmPa8YgEW3DmBUr/onvfOKShn87HfkFZex5M7zGNqpgdOuSbV0TjuWjq9rKC2z8q8fDvDSqv1YbRAX5stL4/rXWC5YGt8/Vu7lXz8coE2QN9/NvAhvDwsLv9vHwu/20zbYWNccphXSOe1YOr5Nx2az8d3uFJ7/Zq+9mpmHxUy/2CDO6xjCeR1DObd9cLM478R11eecdurlFg0p1/tH7u7u9O/fnwMHqk+iOnzU4vn3Q9YxiOlvjPC21OEHqqB2cO2b8P4NsPlNY37vPjc4pHuebhZu7B/FDXtmYMo+TLY5kAlFj3F0dyEf7V5HkI872QUl3Ge+jofdl9Jm3ZPcVwz7bDWXM44N8aZ3m0B6xgTSu41xC/atPRFeUmbFuzQLPGj4fN6ctq+11LhooIYy6e4WM3df1Im7L+rEicwCvtmZxMqdSWyKz2B3YjbpiUcYtfavmMzHACg69DPZo18hrN8YXe0tzdZNN91Eamoqs2fPJikpiX79+vH111/bq2UcPXrUPqIbIDY2lpUrV/Lggw/Sp08f2rRpwwMPPMCjjz7qrLcgUm+ebhZeHX8u05dsZeXOZO7+7xZeu/VcLu1e9zkcRcT1xYX58vyNfZn2p8725HfFyO9LuoWTU9RI5c0bydX92/DF7wkcSMllSFwowzqHMrRTKNGB3lXaDmgfwnt3DuG2tzax9Wgm49/cyH+nDD7j52sRkZbKYjbRKdyPTuF+/L++xog8m81GSk4ROYWldI5o2MVNvp5u/L9+MeXz7h5V0ltEGp2bxcyMEV05v1MYMz74lfi0PK597WceGXkOt18QV69pGaT+4tPyeGPtIQBmj+1hnzroruEd+WDTMY6fLODtn+O57+LOzuymSItiMpm4rEckl54TwZfbE3nxu30cTM1j0+EMNh3O4KXvDygJLk3KqSO9AYYMGcLgwYN5+eWXAaNcb7t27Zg2bRqPPfbYGfcvKyujZ8+ejBkzhhdeeOGM7ZvVVT6rnoYf/wHuvnDn9xBxTuO/hs0Gn0+DX98Fdx+Y+CV73Lrw1o/xfLYtgeIyKwBmk5V3Pf/B+WzjhFtbnu/wBv7+gYT6eWIxm9iVkM32E1kczciv9mXaBHkT5ueBn5cbvh5u+Hm54edp3Hw93bCYTexY+Q7/8ngZW/thmCavaPh7mh8LRdkw7RcI61KvXTPyitnwy2YG/Xg74aWJJNmCybAF0MN8BIB3zNeyqcM99G0fxrntgunTNlABuJlrVud0C6TjK81FSZmV+5f8ylc7knC3mHh1/AAu66HEd33pnHYsHd+mE5+Wx8vf7+fTX09UKhm+/9nRuFuqrwTU3O1KyObWtzaSkVfMOVH+vHvHEML8NOWIM+mcdiwdX3GG349n8v/+9TMebmY2/eVSzTvZiHROO5aOr+vJzC/msf9t5+udSQAM7xrO8zf0Jdxfn+8cwWazMemdzazZl8pFXcNZPHlQpYFNy7YeZ+ZHv+Hn6cYPD1/s9H8HndOOpePrPDabjSPp+Ww4lF5+yyApu7BSGw+LmUFxwcwa3d0+RYRIbepzTjs96V3fcr1PPfUU5513Hp07dyYzM5MFCxbw6aefsmXLFnr06HHG12tWAc9aBv93NcSvhbBuRuLbs5HLMa7+K6yeDyYzjFsC3UbZN2XkFZOcXUionwchPh64FWYYZddzEqD3DcZo9D+Mes7KL2FHQhY7TmSx/YSxPJxefSL8j26zfMPT7ouh+/+Dm/6v4e/ppf6QcQgmfw3th565/emSd8L/XQO5yViD4/jxvDf5MdHCuXv+wZjC5QBssnbj/uJpJBGKm9lEj5gA+rYNomO4Lx1CfWkfasw166o/qLY0zeqcboF0fKU5KSmzMuODbSzfnoi7xcS/bjmXkQ2Yz7E10zntWDq+Te/05HeHMF++f+hiZ3fprOxPzuGWf28kNaeIzhF+vHfHECIDvJzdrVZL57Rj6fiKM9hsNq546Sd2JWYz+8oeTLmg6nzj0jA6px1Lx9c12Ww23t90lKe+2EVRqZUwPw9uGdyOC7uG0y82SL8tNqKVO5O4+/+24GExs/LB4cSF+VbabrXauPrVn/n9eBY3D45l/rV9nNRTg85px9LxbT5OT4JvjM9g/cF0exLczWzivks6M+2Szni4KR5KzVymvDnUv1zvyZMnufPOO0lKSiI4OJgBAwawbt26OiW8mx2zBa57G16/ENL2whcPwHX/rpJobrCt/zUS3gBXPF8p4Q0Q4utByOllE33D4IZ34J0xsH0ptD8fBk6ptE+gjzvDOocxrHOYfV1WQQn7knPIyi8hr7iU3KJScgtLySsqJafIWOYWlXJuihWyOLvy5gA+YUbSOz+tfvsd2wTvXQ+FWRDZC/Oty7jIP5KLAHif4t8+xvLlAwwu2ct3Po/zuGk6n+X15PfjWfx+vPK84BaziTZB3nQI86VDqA/tQ41luL8noX6ehPp6aIS4iEgjc7eYeXFcP0wm+PL3RKa+t5V/3dKfUb2ia9yntMxKel4xhSVltAvx0RQWIi1MXJgvL9zYj8dGn4Onm+t/9uoS6c9Hdw/lljc3cCAll5teX897d55Hm6CqZdFFajJ37lzmzZtXaV23bt3Ys2cPAIWFhTz00EN88MEHFBUVMXLkSF599VX7d3Awvoffe++9/PDDD/j5+TFx4kTmz5+Pm9upnxBWr17NzJkz2blzJ7GxsTzxxBNMmjSpSd6jSEOZTCZuHhzLk5/t5LkVu/l02wnObRdM/3ZBnNsumLbB3vq8KCKNxmQyMX5IewZ1CGH6+7+yNzmHl74/wEvfH8Df042hnUK5sGs4w7uE0T7U98xPKNUqKC7jqS92AXDn8LgqCW8As9nEk1f24IZF6/lw8zEmDO1A92glQ0UczWQyGTmUMF/GDW6HzWbjcHo+C1buYcX2JF5atZ9vdyXzjxv60DNGo77l7Dl9pHdTa5ZX+RzdYCSabWUw5h8w+M6zf87938L7NxnPeeHDcOmTdd/35xfh29lg8YQ7voXovmffH4AVf4ZNb9S/P3+05GbYu8J4notngaUO124cWAUf3gol+cYc6rd8CN7BVdulH4SPJ0PibwBkD5jG6jZ3sjOpgCPp+RxOz+Nweh6FJdYzvqSPh8UYRe9rJMFDfT0I8fMAG+QVl5JXVEZeUSn5xWXkFpWSX7GuuBR3i5l2IT60D/GhXagP7UN9aBdijDIP9fU4qy/h6blF7E7MYXdiNrsTs9mTlIO7xUTXSH+6RfnTJdKfbpH+RAZ4usSX/WZ5TrcgOr7SHJWWWXlo6W98ti0Bi9nEo6O64eVuISW7iJScQlJyisrvF5GeV0TFJ502Qd6M6hXF6F5RnNsuuFXOp9Yaz+lXXnmFBQsWkJSURN++fXn55ZcZPHjwGff74IMPuPnmm7nqqqv49NNP6/RarfH4imMcy8jn5jc3cPxkAW2CvFly53m0C/VxdrdaHVc9p+fOncvHH3/Md999Z1/n5uZGWJhx4fK9997L8uXLWbx4MYGBgUybNg2z2czPP/8MGFOI9evXj6ioKBYsWEBiYiITJkzgzjvv5LnnngMgPj6eXr16cc8993DHHXewatUqZsyYwfLlyxk5cmSd+umqx1dcX05hCde9to59yblVtoX5eXJuuyD6twvm3HZB9GkbZJ8TVmqnc9qxdHxdX2FJGV/8lsCafan8dCCNzPySStvbh/pwYZcwLugcToivBzmFJWQXlpBTWEpOYSnZBSVkF5ba1wV4uTGieySXnBNBoLe7k95V8/DCN3t56fsDxAR68d1DF+HjUfNvxfe9t4UV25MY1jmUd28f4rTfPnVOO5aOr2v48vcEnvx0ByfzS3Azm5j2p85MvaSzqmBIFS5V3rypNduAt+5f8M3jxv3AWAjrCuHnQHhXo/R5eDfwCam6X2EWpB2AtH2n3fZD+gEj4d33Zrj6tfqNHrda4YNbYN9XEBwHd68Br0a4yubjKbDjfzByPgy9r+HPU5E8B/CNgF7XQZ8bIaZ/9e9z56fwvzvAWgKdLjVKq3vUcvVkaRF888Sp14gdAte/DYFtAaMkR0pOEYfT8sqT4PkcSc/jSHo+6bnFZOQV2+dKry8TVgaY9hFgyucXazeyqdpPXw8L7UJ9aRvsTaC3O36ebgR4Vcyj7o6flxv+Xm74e7rh6WYhPj3PnuDenZhNcnZRnfoS4OVGtyh/zg/M4NqTbxNWfBxrl1H4DroVc0TXBr0/R2i253QLoeMrzVWZ1cbDS3/jk19PnLGt2QRuZnOl2Bzu78nlPSIZ1SuK8zqG1viB2mazkZhVyKHUPA6l5XIoNY8ALzcu7BpO/9gg3Fzsg3hrO6c//PBDJkyYwKJFixgyZAgLFy5k6dKl7N27l4iIiBr3O3z4MBdccAEdO3YkJCRESW9xioTMAsb/eyPxaXlEBXhx3yWd6BDqS1yYLzFB3ljqcOFOcamV+LQ89iXnsD85h33JuZRabQyJC2Fop1C6RwfU6XlaK1c9p+fOncunn37Ktm3bqmzLysoiPDyc999/n+uvvx6APXv20L17d9avX895553HV199xZVXXklCQoJ99PeiRYt49NFHSU1NxcPDg0cffZTly5ezY8cO+3OPGzeOzMxMvv766zr101WPr7QMNpuNE5kFbD2aydYjJ/n16El2JmRTaq38E5nZBJ0j/OgVE0iPmAB6tTGWAV6tO8FUHZ3TjqXj27KUWW3sTMjix/1prNmXytYjJ6vEn7pyt5g4r2MoI3tGcXmPSCJa2dQ4R9LzuOyfaykutfLa+HMZ3bvmSnAAR9PzGfHCGorLrLw1cSCXdo+stb2j6Jx2LB1f15GaU8STn+7g651JAPSIDuAfN/SlR4z+3eQUJb1r0WwDns0GX9xvlCSviW+4kQAPagfZx43kdk5ize27XQE3LAY3j5rb1CQ/A16/CLKOwjlXwuXPQECbhj1Xhf9eBYdWwzVvQN+bGv48OcmwdgHsXAb56afWh3aBPjdB7+shpHxeri3/gS9ngM0KPa8xXruu72Hnp/D5dCjKBouHcfw9/cEzoHzpD14B5Y8DjAsDYvphi+lPTqmZjNxi0vOKSc8tIiOv4n4xFjP4eLjh5+mGj6cFX3cLUQX7iD2+nPAjX+KRbwR4G2aSAnqxw3MAP1p78UNOO47nlFDXM9aDEiJMmSTaQiij8pXp7UN96B4VQPfoALpH+1NqtbE3KYf9KTnsTcrhcHo+gdYsZrj9j1ssq3AzVU7i77F05dfgkSS3u5KoqBg6hBk/wEb4Vx0dbrPZsNrAarNRZrVhs4Gnm7nRRlg223O6hdDxleaszGrjxe/2se5gOmF+nkQEeBLh70mEvxfhAZ6El68L9fWkuNTKmn2prNyZxHe7k8kpLLU/T6C3OyO6R3JZjwiKy2wcSjWS2wdTc4lPyyO/uKza1/f3cmNYpzAu6hbO8K7hLlF+uLWd00OGDGHQoEH861//AsBqtRIbG8v06dN57LHHqt2nrKyM4cOHM2XKFH788UcyMzOV9BanScku5JZ/b+RASuXRiO4WE7EhPsSF+tI+1Je4MGO6nZzCUiPBnWIkuA+n5dX6A2qAlxtDOoYytGMoQzuF0i3S/4yf0cqsNk7mF5OZX4zNBm4WM25mE+4WM24WE+5mM+5uJtzMZtwtJpeoHFQTVz2n586dy4IFCwgMDMTLy4uhQ4cyf/582rVrx/fff8+ll17KyZMnCQoKsu/Tvn17ZsyYwYMPPsjs2bP5/PPPKyXN4+Pj6dixI1u3bqV///4MHz6cc889l4ULF9rbvPPOO8yYMYOsrMpTQ1UoKiqiqOjUBbjZ2dnExsa63PGVlquwpIwdJ7LYevQkvx7NZOvRkzVeNN4+1IdeMYH0bBNAz5hAukf5E17N9+HWxFVjpqvQ8W3ZcotK2XAwnR/3p7L+UDolZTb8vdwI8HKvvPQ2lv5e7sSn5bJyZ3KVz4n92wUxsmcUI3tGVVvmu7HkFJZwLKOAYyfzOZaRz/GTBZSUWekebVwgdE6Uf72nfiwsKeNASi5H0vPpFOFLt0j/M8bVKYs38/2eFC7sEsZ/pwyuUxye/9VuXl9ziI7hvqycMbxRR5WWllnrdHG8zmnH0vF1LTabjS9+T2T2ZzvIzC/B3WJi+p+6cO/FneznZ1FpGUfT8zmcns/htDzi0/M4nGYMRPRwMxPh70lUoBeRAcYtKsCLyABPIgO8iAjwbBHTobVmSnrXotkHvPwMY7R26h5I3WfM9Z26F7KO1byPXxSEdTFGh4d1NUaHh3YxRiafzReu41vg7ZHGCGkATOAfDUGxxmj0oFgjAR/YzliGdgZzLf+pL7oAkrbD+P9BlxEN71eFshI4+D38/iHsWQ6lhae2xQ6BiO6wZbHxeMAkuOIFYx71+sg4ZIxQT/i17vu4eUPsYOhwIXQYBm0GgJtn1XbpB2H7x8b86en7T633DDTmV884WLm9ZwBl7S8kPep8DvoP5kBpBIX5ubhlxuOVexS/vKMEFBwjtOgE4aUJhFtTMWMjwxzMztCRZHa9npiuA+gWFYCfZy0l4UsKKVn/GuYfn8dSkgPArz5DWVk2mMEFaxlu+s2eBC+2Wfjeei7Lyi7gB2t/TBYPzGajWIDVZqPMZrMn6S2UEUAegaY8LFjxdHfD28O4eXm44e3uho+HG16e7nh7GPenjBmGn1ftFyk0+3Paxen4SktUXGpl3cE0Vu5M4pudyaTnFdfa3s1sol2oDx3D/OgY7ktCZkG15eg6hftyUdcIhncNY0hcaLMshdmazuni4mJ8fHz4+OOPufrqq+3rJ06cSGZmJp999lm1+82ZM4fff/+dTz75hEmTJtWa9FYCR5pCRl4xb/8Uz56kHA6n53E0Pb9eVYX8PN3oEulH1wh/ukT6YbXZ2HAog03xGeQWlVZqG+LrwZC4EPrFBpFfXEZ6XvnFm+UXc2bkFXOyPNldVwFebrQN9qFtsPdpS29iQ4z7/s14tKSrxsyvvvqK3NxcunXrRmJiIvPmzePEiRPs2LGDL774gsmTJ1eKXQCDBw/mkksu4W9/+xt33XUXR44cYeXKlfbt+fn5+Pr6smLFCkaPHk3Xrl2ZPHkys2bNsrdZsWIFV1xxBfn5+Xh7V70QrLq5xgGXO77SelRUeduZkMWOE9nsOJHFzoRsTmQWVNs+2MedblH+nBMVQLcoY/qwrpH+tX//bkFcNWa6Ch1fqcnB1Fy+2ZnMyp1JbDuWWWlb22BvPNzMlFltlJYZg1HKygellJZZsdqMCxp9PCzlFSSNm3/F/fKqkv5ebmQXlJQnuI1E9x+/D/+RxWyiS4QfPWMC6dWmvFJGdAC+nm725Pb+lBz2J+eyL9m4fzQjv9LnzLgwX0b3imJM72h6xgRUSWh/tyuZO/77C+4WE1/PGE6ncL86HbOcwhIuXrCa9Lxi5oztweRhcXXaryY2m40tR06yZNMxNh/OYNVDF50xka5z2rF0fF1TSk4hT3yyg292JQNwTpQ/YX6exKflkZBVUK/voX/UPtSHUb2iuLJ3DL3aVI0n0rwp6V0Llw14RbmnypdnHjMS2mFdIaxz45Qer8mOZbB6PmQerZxUro5fFPT4f9DjKmg3tGqC+fnukJMAd602SpE3psJs2PMl/P4RxK8xRnZXGDYDRsxt+AUAViucjDdGfBdmQ1FO+S278rrcFDi2ofLocwA3L2g7CDpcYCTjU3YZie7TE+luXtB1lDFKvfNl4O5lHPODP8ChH4wR8gUnKz+vZyAUVT+Kws5krnwsonpD31ug9w3gF165rc1mjJ7/bq7x2gBRfWDksxA3HICSMiuJJ45S9OuHhBz4H6E5e+27Z9j8+KZsIGVYCDTlEkQugaY8gsgj0JRLgKn6HwZqkz3jEAFBobW3cdVz2kXo+EpLV2a18cvhDL7akcTPB9II8HanU7gvHcP96BjmS6cIP9qF+FT5wlpmtbH9RBZr9qaydn8qvx49yR8HU/p7uRHm50morwehfh6EVtz3Ne6H+3vSMyagSRM+remcTkhIoE2bNqxbt46hQ4fa1z/yyCOsWbOGjRs3Vtnnp59+Yty4cWzbto2wsLAzJr2VwBFnKLPaSMwq4HBavjHVTvmUO0fS8/HxdKNrhB9dI40Ed9dIf6IDvar9Ql9aZmVHQjbrD6az/lA6vxzOqLGyRXUCvNwwm02UltkoKbNSajV+QK2vQG93eyK8uuS4M5PiLSVmZmZm0r59e1544QW8vb2dlvTWhULSUpzMK2ZnQjY7ErLYcSKLXQnZHE7Pq/JZsELbYG/OifInMsCLQG93gnzcCfR2J9Db4w+P3fHxsLjsj7CuGjPXrl3LggUL2LJlC4mJiXzyySeVLpi02WzMmTOHN998k8zMTIYNG8Zrr71Gly5d7G0yMjKYPn06X3zxBWazmeuuu44XX3wRP79TCbjff/+dqVOnsnnzZsLDw5k+fTqPPPJInfvpqsdXmlZSViHf7krim13JrD+Y3uCS6XUV7ONObIgPscE+tA3xxmwyGfHxRBYZ1VxcbjJBhL8nKTlFNSavgnzcaRfiw56kHIpLT/2mGRvizZhe0YzuHU3ftoEUlVq57J9rOJZRwD0XdeKx0efUq+/vbTzC45/sINDbnTV/vpggn/pXN83ML2bZ1hMs2XSU/aeNuF88eRAXd6t5Oi3QOe1oOr6uy2az8flvCcz+bCdZBZUvrvHzdKNDmI992q8Oob50CPOhpMxGcnYhydmFJGUVkZxTSHJWIUnZhaRkF1W5aLxdiA9jekdzZZ/qL6iR5qc+53TruNy0JfD0gzbnGrem1Ota42azQV6qkXDPOlq+PGYsM48aSeHcJGMe7E1vGKXAz7nSSIB3uNBIgFckg31qT2I2iFcA9LvFuGUnGnOH7/sauo+FIXef3XObzRDaqW5tbTZjlP7hn4zbkZ+N43b4R+N2OpMFOl1iJKC7jTHew+mC2sGAicbNWgaJvxkj2w+thqMbTiW8vYMhpKNxC447dT+ko3FBxIHv4Lf3Ye/Xxkj7pFnw7ZNGcr3vOOg22njulX+B45uN5/SPhktnQ59xlUbvu1vMtGvXAdo9CjwKSTvg9w/g948IyU1mnNvqMx8iDz9sZndsNhvYrPal8WnXZixtVsCGbyu5Il5EnMdiNjGkYyhDOtbv/yaL2US/2CD6xQbxwIguZOWX8PPBNNbuS2XtvlQSsgrJKSwlp7CU+LS8Gp/HbIJuUQEMbB/MwA7BDOwQUucy6RWJr2MZBSRmFXDtuW3r9R6kspycHG677TbefPNNwsLC6rTPrFmzmDlzpv1xRQJHxJEsZlN5UtiHC7rU7W+1Om4Wsz2O3XtxJ0rKrPx+PJP1B9PZm5xLgJcbob4ehPh6EOLnSZivByF+xuNgH49qR69YrTZKrTZKrVZKyowRRBl5xRw7aZS8NG6n7mfkFZNVUEJWQQk7E7Kr7efpSfGYIG9iAsuXQV7EBHkT7ufZaNPmtFRBQUF07dqVAwcOcNlll1FcXExmZmal8ubJyclERUUBEBUVxaZNmyo9R3Jysn1bxbJi3eltAgICqk14A3h6euLpWU0FLBEXE+zrwQVdwirF4MKSMvYn57InKZu9STnsTTamDkvJKbLHvLrwcDMT7udpXDBZfqFkmJ8nYX7lF1H6Go/D/T0J8fXAovh31vLy8ujbty9Tpkzh2muvrbL973//Oy+99BL/+c9/iIuL48knn2TkyJHs2rULLy9j7uTx48eTmJjIt99+S0lJCZMnT+auu+7i/fffB4zPiJdffjkjRoxg0aJFbN++nSlTphAUFMRdd93VpO9XWraoQC9uG9qB24Z2ICu/hN1J2ZhNJixmsJiNKWksZhNuZhPmiqXJREFJGTmFJeQUlpJbVEpu+bLiO21uUQk+Hm7lCW6jYk9siE+NlSxsNhtJ2YWnVckwKmYkZRfap40I8nG3VyLqYr9o058wPw9MJhO5RaV8vyeFr7Yn8sPeFI5lFPD62kO8vvYQbYK8iQ3x5lhGAdGBXkz/U+d6H6ubBsby33VH2Jucw4ur9jNnbM867Wez2dgUn8GSTUdZsSPJnpj3cjcztk8MNw9pR//YoHr3R0QMJpOJq/q1YWinUL78LRF/LzcjwR3mS6ivR70T1DabjYy8YjbGZ7B8eyLf707haEY+i9YcZNGag7QP9eGK3tHVVpQoLbNSUFJm3IqNZV5RGVkFxWTklXAyr5iM/GJOlk9te/pjfy93ukb60y3Kr3zpT8cwPzzcGm86hTOxWm0kZhdyqHz6xuJSK+H+pz5Lhvl5EuTt3uK+T2uktzSO0iIjGbvrc2PEdWHmqW3eIcYo5t+MD/v8JQE8HDenTLNisxlzrx8pT4If3wz+McaI7p7XGGXMG6Io17jQIKAN+ITUbZ/8DONigN+WwIktp9Z7+EOxUcYcdx9jZPz50+r3b1RWavz7H14L7r7gHWQk4ytuXuWPvQLB0riJbJ3TjqXjK1J/NpuNrIIS0nKLSc81SgOn5Rn3jRLBRaTlFnPiZEG15TFjAr0Y0CGEge2DGdA+mDKrjWMn8zmaYZSSO15+PyGzgJKyUx/jts+9/IwjIlvTOV3f8ubbtm2jf//+WCynKtVYrcYPGGazmb1799KpU+0XwbWm4yvSGPKKSjmRWcCxjHz78vTk+MkzlM0EY37zyACv8oS4F8G+Hvh7uuFrL8lplOj09TAe+3u64+tpIdjH44xf7lvKOZ2bm0u7du2YO3cuEydOJDw8nCVLlnDdddcBsHfvXs455xzWr1/Peeedx1dffcWVV15JYmIiERHGKKU33niDP//5z6SkpODp6cmjjz7KihUr2L59u/11brnlFjIyMvj666/r1K+WcnxFapORV8zepBz2p+SQnnvqQp+KW2Z+MVkFpWQVFFf6XFcXFrOJUF8Pwv2NHy4jypdG0twTd4sJMGE2GT8gmzBGWZpOe2wkv8y4W0y4WYyEmLvFjJvFhLvZWLpZTIT6ep4xwd4SzmmTyVRppLfNZiMmJoaHHnqIhx9+GDAq+kRGRrJ48WLGjRvH7t276dGjB5s3b2bgwIEAfP3114wZM4bjx48TExPDa6+9xuOPP05SUhIeHsZo0scee4xPP/2UPXv21KlvLeH4iqTmFHHsZD6xwT725HZd5BeXsmZvKit2JLFqd3Kl6kT/uqU/V/aJaVB/ftyfym1vbcLNbOKx0ecQ4OWOl4cFb/fym4cZTzcL3h4WLCYT3+5KZsnmoxxKPXVhe4/oAG4e0o6r+sUQUI8KRTqnHUvHV2qSX1zKD3tSWb49ge/3pFBYcmoUeIS/J2aTifziUgpLrPWaVqwu3MwmOob7GknwSH/ahnhjtRqDWozKadbT7htLm82Gl7sRh7zdLfh4WIwpY+33LXi6mUnOLuRQah7xaZVvRaW1vwc3s4kQXw/jIkt/T0J83LGYzeUXS5nKL5wylhUXTpnNxudIs8lU6XOl/THYv2tXpJ8rstC2SveNO7ed155Qv9ovjlZ581oo4DWBshKIXwu7PjMS4KeX+3bzgseTzm6ucTl7qXuN5PdvHxol5zFB//FwyRMQEO3s3tWLzmnH0vEVcayU7EJ+OXKSXw6f5JcjGexMyK5XeWB3i6n8KncfFlzfl6hAr1rbt7ZzesiQIQwePJiXX34ZMJLY7dq1Y9q0aTz22GOV2hYWFnLgwIFK65544glycnJ48cUX6dq1q/1Hypq0tuMr4mi5RaWcKE+AH8vIJzGrkISsQhIyC0jMLCApu7DGcsJn8tOjl9A22KfWNq56Tj/88MOMHTuW9u3bk5CQwJw5c9i2bRu7du0iPDyce++9lxUrVrB48WICAgKYPn06AOvWrQOgrKyMfv36ERMTw9///neSkpK47bbbuOOOO3juuecAiI+Pp1evXkydOpUpU6bw/fffc//997N8+XJGjhxZp3666vEVcQSbzUZBSZlxsWTuqYslUytdNFm+LqeIjPzis5rXsr5+fOQSYkNaZsw83R+T3ocOHaJTp078+uuv9OvXz97uoosuol+/frz44ou8/fbbPPTQQ5w8eWpKutLSUry8vFi6dCnXXHMNEyZMIDs7u9KUOT/88AN/+tOfyMjIIDg4uEpfNCWESPUKS8pYuy+Vb3YlEx3oxczLup5VaeLJ72zih72p9drHx8PCVf1iuHlwO3q3CWzQ67eEmNmc6fhKXeQVlfLD3hSW/57I93tSakwQm0zYk8xe7haCfNwJ8TUSxMG+HoT4eBBcPp1hcHlltIy8YvYlG9V/9iUZFYByikqb+B0avxu2C/EhLswPL3czabnGQJy03CIy63CReVP4buZwOkf419pG5c3FuSzu0PlS43bFC0aJ712fGWW2O49Qwrs5CO9mzHP+pyeNUd8+oXUv4S4iIo0mIsCLMeVllMC44nTbsczyJPhJfjuWiaebmXbl5eNOLyfXLsSHyAAvlbWsxcyZM5k4cSIDBw5k8ODBLFy4kLy8PCZPngzAhAkTaNOmDfPnz8fLy4tevXpV2r+i9O8f14tI0/DzdKNblFEKrjqlZVZScopIyCywJ8OzCkrIKy/LmVO+zCs+9TivqJT84rIay3G2BMePH+fmm28mPT2d8PBwLrjgAjZs2EB4eDgA//znP+1zzhYVFTFy5EheffVV+/4Wi4Uvv/ySe++9l6FDh+Lr68vEiRN56qmn7G3i4uJYvnw5Dz74IC+++CJt27bl3//+d50T3iJSmclkwsfDDR8PtzNekANG/EvPMxLgFbeUnELjfvmPmVarrXw0jQ2rzRhZg81mH2FjtZ0aRVRaVj4thdVKaZmNkjJr+XobJVYrbpbW+XkzKSkJgMjIyErrIyMj7duSkpLsVTEquLm5ERISUqlNXFxcleeo2FZd0nv+/PnMmzevcd6ISAvi5W7h8p5RXN4zqlGe77lre/PSqgNkFRTbyxcXllgpLKm4b5Q1Liy10j3Kn3GD2zG2b0yL/iwp0lr4erpxZZ8YruwTQ15RKXuScvB0M+NVMYra/dRI6oZc3DK006mpFG02G4lZhfYpcPaVT4NTMdWEpcrSqMBjMhkX++QXnyqzXvm+MSo93N+TuDDfU7dwXzqG+dImyBu3aqYmAygutZZfcFlk/wyZlV9CWflnRKvVRpnt1LK0Yp3VGKVtsxnvy4bxudL4fAlgw2o9lQY8dehOHUP7NqhXlYy6UHQWx7K4QceLjJs0P2YLxA52di9ERKScj4cb53cK4/xODZ+nV0656aabSE1NZfbs2SQlJdGvXz++/vpr+4+MR48exWxuuvmURKRxuVnM5fN7Vz+HdE1Ky6wt+oKhDz74oNbtXl5evPLKK7zyyis1tmnfvj0rVqyo9Xkuvvhifv311wb1UUTOjpvFTGSAF5EBtVf5aSytrEhkszBr1ixmzpxpf1wx0ltEGld0oDfzr+3t7G6IiJP5eroxoH3Vi9Aai8lksn93vaRbxJl3aAIebmaiAr3OWDXS1SjpLSIiIiIt1rRp05g2bVq121avXl3rvosXL278DomI09V0pbuIiFTvbEoHu7KoKGMkaXJyMtHRp6aCS05Otpc7j4qKIiUlpdJ+paWlZGRk2PePiooiOTm5UpuKxxVt/sjT0xNPz9rntxQRERGRyvRtX0REREREREREROQ0cXFxREVFsWrVKvu67OxsNm7cyNChQwEYOnQomZmZbNmyxd7m+++/x2q1MmTIEHubtWvXUlJyau7Mb7/9lm7dulVb2lxEREREGkZJbxEREREREREREWl1cnNz2bZtG9u2bQMgPj6ebdu2cfToUUwmEzNmzOCZZ57h888/Z/v27UyYMIGYmBiuvvpqALp3786oUaO488472bRpEz///DPTpk1j3LhxxMTEAHDLLbfg4eHB7bffzs6dO/nwww958cUXK5UvFxEREZGzp/LmIiIiIiIiIiIi0ur88ssvXHLJJfbHFYnoiRMnsnjxYh555BHy8vK46667yMzM5IILLuDrr7/Gy+vU/Jfvvfce06ZN49JLL8VsNnPdddfx0ksv2bcHBgbyzTffMHXqVAYMGEBYWBizZ8/mrrvuaro3KiIiItIKtLqkt81mA4xyRCLi+irO5YpzWxqXYqZIy6KY6ViKmSIti2KmYylmirQsrhozL7744lr7bDKZeOqpp3jqqadqbBMSEsL7779f6+v06dOHH3/8scH9VMwUaVlcNWa6CsVMkZalPjGz1SW9c3JyAIiNjXVyT0SkMeXk5BAYGOjsbrQ4ipkiLZNipmMoZoq0TIqZjqGYKdIyKWY6hmKmSMukmOkYipkiLVNdYqbJ1souJ7JarSQkJODv74/JZKq1bXZ2NrGxsRw7doyAgIAm6mHrpmPe9Fz9mNtsNnJycoiJicFsNju7Oy2OYmbzpmPe9Fz9mCtmOpZiZvOmY970XP2YK2Y6lmJm86Zj3vRc/ZgrZjqWYmbzpmPe9Fz9mCtmOlZ9Yia4/t+Tq9HxbnqufszrEzNb3Uhvs9lM27Zt67VPQECAS/4huDId86bnysdcV0Q6jmKma9Axb3qufMwVMx1HMdM16Jg3PVc+5oqZjqOY6Rp0zJueKx9zxUzHUcx0DTrmTc+Vj7lipuM0JGaCa/89uSId76bnyse8rjFTlxGJiIiIiIiIiIiIiIiIiIjLUtJbRERERERERERERERERERclpLetfD09GTOnDl4eno6uyutho5509Mxl8aiv6Wmp2Pe9HTMpbHob6np6Zg3PR1zaSz6W2p6OuZNT8dcGov+lpqejnnT0zGXxqS/p6al4930WtMxN9lsNpuzOyEiIiIiIiIiIiIiIiIiItIQGuktIiIiIiIiIiIiIiIiIiIuS0lvERERERERERERERERERFxWUp6i4iIiIiIiIiIiIiIiIiIy1LSW0REREREREREREREREREXJaS3rV45ZVX6NChA15eXgwZMoRNmzY5u0stxtq1axk7diwxMTGYTCY+/fTTStttNhuzZ88mOjoab29vRowYwf79+53T2RZg/vz5DBo0CH9/fyIiIrj66qvZu3dvpTaFhYVMnTqV0NBQ/Pz8uO6660hOTnZSj8UVKWY6jmJm01LMlKagmOk4iplNSzFTmoJipuMoZjYtxUxpCoqZjqOY2bQUM6UpKGY6jmJm01LMNCjpXYMPP/yQmTNnMmfOHLZu3Urfvn0ZOXIkKSkpzu5ai5CXl0ffvn155ZVXqt3+97//nZdeeolFixaxceNGfH19GTlyJIWFhU3c05ZhzZo1TJ06lQ0bNvDtt99SUlLC5ZdfTl5enr3Ngw8+yBdffMHSpUtZs2YNCQkJXHvttU7stbgSxUzHUsxsWoqZ4miKmY6lmNm0FDPF0RQzHUsxs2kpZoqjKWY6lmJm01LMFEdTzHQsxcympZhZzibVGjx4sG3q1Kn2x2VlZbaYmBjb/PnzndirlgmwffLJJ/bHVqvVFhUVZVuwYIF9XWZmps3T09O2ZMkSJ/Sw5UlJSbEBtjVr1thsNuP4uru725YuXWpvs3v3bhtgW79+vbO6KS5EMbPpKGY2PcVMaWyKmU1HMbPpKWZKY1PMbDqKmU1PMVMam2Jm01HMbHqKmdLYFDObjmJm02utMVMjvatRXFzMli1bGDFihH2d2WxmxIgRrF+/3ok9ax3i4+NJSkqqdPwDAwMZMmSIjn8jycrKAiAkJASALVu2UFJSUumYn3POObRr107HXM5IMdO5FDMdTzFTGpNipnMpZjqeYqY0JsVM51LMdDzFTGlMipnOpZjpeIqZ0pgUM51LMdPxWmvMVNK7GmlpaZSVlREZGVlpfWRkJElJSU7qVetRcYx1/B3DarUyY8YMhg0bRq9evQDjmHt4eBAUFFSprY651IVipnMpZjqWYqY0NsVM51LMdCzFTGlsipnOpZjpWIqZ0tgUM51LMdOxFDOlsSlmOpdipmO15pjp5uwOiEjTmjp1Kjt27OCnn35ydldERJo9xUwRkbpTzBQRqTvFTBGRulPMFBGpu9YcMzXSuxphYWFYLBaSk5MrrU9OTiYqKspJvWo9Ko6xjn/jmzZtGl9++SU//PADbdu2ta+PioqiuLiYzMzMSu11zKUuFDOdSzHTcRQzxREUM51LMdNxFDPFERQznUsx03EUM8URFDOdSzHTcRQzxREUM51LMdNxWnvMVNK7Gh4eHgwYMIBVq1bZ11mtVlatWsXQoUOd2LPWIS4ujqioqErHPzs7m40bN+r4N5DNZmPatGl88sknfP/998TFxVXaPmDAANzd3Ssd871793L06FEdczkjxUznUsxsfIqZ4kiKmc6lmNn4FDPFkRQznUsxs/EpZoojKWY6l2Jm41PMFEdSzHQuxczGp5hpUHnzGsycOZOJEycycOBABg8ezMKFC8nLy2Py5MnO7lqLkJuby4EDB+yP4+Pj2bZtGyEhIbRr144ZM2bwzDPP0KVLF+Li4njyySeJiYnh6quvdl6nXdjUqVN5//33+eyzz/D397fP0RAYGIi3tzeBgYHcfvvtzJw5k5CQEAICApg+fTpDhw7lvPPOc3LvxRUoZjqWYmbTUswUR1PMdCzFzKalmCmOppjpWIqZTUsxUxxNMdOxFDOblmKmOJpipmMpZjYtxcxyNqnRyy+/bGvXrp3Nw8PDNnjwYNuGDRuc3aUW44cffrABVW4TJ0602Ww2m9VqtT355JO2yMhIm6enp+3SSy+17d2717mddmHVHWvA9s4779jbFBQU2O677z5bcHCwzcfHx3bNNdfYEhMTnddpcTmKmY6jmNm0FDOlKShmOo5iZtNSzJSmoJjpOIqZTUsxU5qCYqbjKGY2LcVMaQqKmY6jmNm0FDMNJpvNZjvbxLmIiIiIiIiIiIiIiIiIiIgzaE5vERERERERERERERERERFxWUp6i4iIiIiIiIiIiIiIiIiIy1LSW0REREREREREREREREREXJaS3iIiIiIiIiIiIiIiIiIi4rKU9BYREREREREREREREREREZelpLeIiIiIiIiIiIiIiIiIiLgsJb1FRERERERERERERERERMRlKektIiIiIiIiIiIiIiIiIiIuS0lvkT8wmUx8+umnzu6GiIhLUMwUEak7xUwRkbpTzBQRqTvFTBGRulPMbLmU9JZmZdKkSZhMpiq3UaNGObtrIiLNjmKmiEjdKWaKiNSdYqaISN0pZoqI1J1ipjiSm7M7IPJHo0aN4p133qm0ztPT00m9ERFp3hQzRUTqTjFTRKTuFDNFROpOMVNEpO4UM8VRNNJbmh1PT0+ioqIq3YKDgwGj7MRrr73G6NGj8fb2pmPHjnz88ceV9t++fTt/+tOf8Pb2JjQ0lLvuuovc3NxKbd5++2169uyJp6cn0dHRTJs2rdL2tLQ0rrnmGnx8fOjSpQuff/65Y9+0iEgDKWaKiNSdYqaISN0pZoqI1J1ipohI3SlmiqMo6S0u58knn+S6667jt99+Y/z48YwbN47du3cDkJeXx8iRIwkODmbz5s0sXbqU7777rlJAe+2115g6dSp33XUX27dv5/PPP6dz586VXmPevHnceOON/P7774wZM4bx48eTkZHRpO9TRKQxKGaKiNSdYqaISN0pZoqI1J1ipohI3SlmSoPZRJqRiRMn2iwWi83X17fS7dlnn7XZbDYbYLvnnnsq7TNkyBDbvffea7PZbLY33njDFhwcbMvNzbVvX758uc1sNtuSkpJsNpvNFhMTY3v88cdr7ANge+KJJ+yPc3NzbYDtq6++arT3KSLSGBQzRUTqTjFTRKTuFDNFROpOMVNEpO4UM8WRNKe3NDuXXHIJr732WqV1ISEh9vtDhw6ttG3o0KFs27YNgN27d9O3b198fX3t24cNG4bVamXv3r2YTCYSEhK49NJLa+1Dnz597Pd9fX0JCAggJSWloW9JRMRhFDNFROpOMVNEpO4UM0VE6k4xU0Sk7hQzxVGU9JZmx9fXt0qpicbi7e1dp3bu7u6VHptMJqxWqyO6JCJyVhQzRUTqTjFTRKTuFDNFROpOMVNEpO4UM8VRNKe3uJwNGzZUedy9e3cAunfvzm+//UZeXp59+88//4zZbKZbt274+/vToUMHVq1a1aR9FhFxFsVMEZG6U8wUEak7xUwRkbpTzBQRqTvFTGkojfSWZqeoqIikpKRK69zc3AgLCwNg6dKlDBw4kAsuuID33nuPTZs28dZbbwEwfvx45syZw8SJE5k7dy6pqalMnz6d2267jcjISADmzp3LPffcQ0REBKNHjyYnJ4eff/6Z6dOnN+0bFRFpBIqZIiJ1p5gpIlJ3ipkiInWnmCkiUneKmeIoSnpLs/P1118THR1daV23bt3Ys2cPAPPmzeODDz7gvvvuIzo6miVLltCjRw8AfHx8WLlyJQ888ACDBg3Cx8eH6667jhdeeMH+XBMnTqSwsJB//vOfPPzww4SFhXH99dc33RsUEWlEipkiInWnmCkiUneKmSIidaeYKSJSd4qZ4igmm81mc3YnROrKZDLxySefcPXVVzu7KyIizZ5ipohI3SlmiojUnWKmiEjdKWaKiNSdYqacDc3pLSIiIiIiIiIiIiIiIiIiLktJbxERERERERERERERERERcVkqby4iIiIiIiIiIiIiIiIiIi5LI71FRERERERERERERERERMRlKektIiIiIiIiIiIiIiIiIiIuS0lvERERERERERERERERERFxWUp6i4iIiIiIiIiIiIiIiIiIy1LSW0REREREREREREREREREXJaS3iIiIiIiIiIiIiIiIiIi4rKU9BYREREREREREREREREREZelpLeIiIiIiIiIiIiIiIiIiLgsJb1FRERERERERERERERERMRlKektIiIiIiIiIiIiIiIiIiIuS0lvERERERERERERERERERFxWUp6i4iIiIiIiIiIiIiIiIiIy1LSW0REREREREREREREREREXJaS3iIiIiIiIiIiIiIiIiIi4rKU9JZmae7cuZhMJtLS0pzdFRERERFp5So+m1bo0KEDkyZNsj9evXo1JpOJ1atX29dNmjSJDh06NF0nRUROs3jxYkwmE4cPH6613R/jWXNVEWc//vhjZ3dFRERERESaKSW9RURERERERESEw4cPYzKZqr198MEHVdrv3r2bUaNG4efnR0hICLfddhupqalO6LmIiIiIiLR2bs7ugIiIiIiIiCvZu3cvZnPt1w+/+eabWK3WJuqRiEjjuvnmmxkzZkyldUOHDq30+Pjx4wwfPpzAwECee+45cnNz+cc//sH27dvZtGkTHh4eTdllERERERFp5ZT0llYrPz8fHx8fZ3dDRERERFyMp6fnGdu4u7s3QU9ERBzj3HPP5dZbb621zXPPPUdeXh5btmyhXbt2AAwePJjLLruMxYsXc9dddzVFV0VERERERACVN5dmLjMzk0mTJhEUFERgYCCTJ08mPz+/Upt3332XAQMG4O3tTUhICOPGjePYsWOV2lx88cX06tWLLVu2MHz4cHx8fPjLX/4CQHp6OrfddhsBAQEEBQUxceJEfvvtN0wmE4sXL26qtyoiUmdHjhzhvvvuo1u3bnh7exMaGsoNN9xQZc7Girkcf/rpJ+6//37Cw8MJCgri7rvvpri4mMzMTCZMmEBwcDDBwcE88sgj2Gy2Ss9htVpZuHAhPXv2xMvLi8jISO6++25OnjxZqd0vv/zCyJEjCQsLw9vbm7i4OKZMmeLoQyEi0uh++uknBg0ahJeXF506deL111+v0qYuc+BqTm8RaU5sNhvPPPMMbdu2xcfHh0suuYSdO3fWuk9eXh7FxcU1bv/f//7HlVdeaU94A4wYMYKuXbvy0Ucf1blvkyZNqrGk+ty5cyu1tVqtPPvss7Rt2xYvLy8uvfRSDhw4UKlNTTH64osv5uKLL65zv0RERERExLVopLc0azfeeCNxcXHMnz+frVu38u9//5uIiAj+9re/AfDss8/y5JNPcuONN3LHHXeQmprKyy+/zPDhw/n1118JCgqyP1d6ejqjR49m3Lhx3HrrrURGRmK1Whk7diybNm3i3nvv5ZxzzuGzzz5j4sSJTnrHIiJntnnzZtatW8e4ceNo27Ythw8f5rXXXuPiiy9m165dVapYTJ8+naioKObNm8eGDRt44403CAoKYt26dbRr147nnnuOFStWsGDBAnr16sWECRPs+959990sXryYyZMnc//99xMfH8+//vUvfv31V37++Wfc3d1JSUnh8ssvJzw8nMcee4ygoCAOHz7MsmXLmvrQiIicle3bt9vj2dy5cyktLWXOnDlERkY6u2siImdl9uzZPPPMM4wZM4YxY8awdetWLr/88hqT2vPmzePPf/4zJpOJAQMG8Oyzz3L55Zfbt584cYKUlBQGDhxYZd/BgwezYsWKOvft7rvvZsSIEZXWff3117z33ntERERUWv/Xv/4Vs9nMww8/TFZWFn//+98ZP348GzdurPPriYiIiIhIy6SktzRr/fv356233rI/Tk9P56233uJvf/sbR44cYc6cOTzzzDP2UdsA1157Lf379+fVV1+ttD4pKYlFixZx991329ctW7aM9evXs3DhQh544AEA7r33Xi677LImeHciIg1zxRVXcP3111daN3bsWIYOHcr//vc/brvttkrbIiMjWbFiBSaTifvuu48DBw6wYMEC7r77bl577TUA7rrrLjp06MDbb79tT3r/9NNP/Pvf/+a9997jlltusT/fJZdcwqhRo1i6dCm33HIL69at4+TJk3zzzTeVfvh85plnHHUIREQcYvbs2dhsNn788Uf7yMXrrruO3r17O7lnIiINl5qayt///neuuOIKvvjiC0wmEwCPP/44zz33XKW2ZrOZyy+/nGuuuYY2bdpw6NAhXnjhBUaPHs3nn3/OFVdcAUBiYiIA0dHRVV4vOjqajIwMioqK6jQdxNChQyvNF37gwAGmTZvGZZddVun7O0BhYSHbtm2zzxceHBzMAw88wI4dO+jVq1c9joqIiIiIiLQ0Km8uzdo999xT6fGFF15Ieno62dnZLFu2DKvVyo033khaWpr9FhUVRZcuXfjhhx8q7evp6cnkyZMrrfv6669xd3fnzjvvtK8zm81MnTrVcW9KROQseXt72++XlJSQnp5O586dCQoKYuvWrVXa33777fYfNwGGDBmCzWbj9ttvt6+zWCwMHDiQQ4cO2dctXbqUwMBALrvsskpxdsCAAfj5+dnjbEVVjS+//JKSkpLGfrsiIk2irKyMlStXcvXVV1cq1du9e3dGjhzpxJ6JiJyd7777juLiYqZPn17pM+GMGTOqtG3Xrh0rV67knnvuYezYsTzwwAP8+uuvhIeH89BDD9nbFRQUAFSb1Pby8qrUpj7y8vK45pprCA4OZsmSJVgslkrbJ0+ebE94g/EbAVDpM6yIiIiIiLROSnpLs3b6D45gXMUNcPLkSfbv34/NZqNLly6Eh4dXuu3evZuUlJRK+7Zp06bSl2Mw5sWNjo6uUgq4c+fODng3IiKNo6CggNmzZxMbG4unpydhYWGEh4eTmZlJVlZWlfZ/jKWBgYEAxMbGVll/+lzd+/fvJysri4iIiCpxNjc31x5nL7roIq677jrmzZtHWFgYV111Fe+88w5FRUWN/dZFRBwmNTWVgoICunTpUmVbt27dnNAjEZHGceTIEYAq8S08PNz+Hbs2ISEhTJ48mb1793L8+HHg1EWY1X3eKywsrNSmPu68804OHjzIJ598QmhoaJXttf1GICIiIiIirZvKm0uz9seruivYbDasVismk4mvvvqq2nZ+fn6VHjfkC7eISHM0ffp03nnnHWbMmMHQoUMJDAzEZDIxbtw4rFZrlfY1xdLq1ttsNvt9q9VKREQE7733XrX7h4eHA2Aymfj444/ZsGEDX3zxBStXrmTKlCk8//zzbNiwoUo8FhERERHXUnGxZEZGBm3btrWXNa8oc366xMREQkJC6lTa/HQvvvgiS5Ys4d1336Vfv37VtqntN4IKp49mP11ZWVmN+4uIiIiIiOtT0ltcVqdOnbDZbMTFxdG1a9cGPUf79u354YcfyM/PrzTa+8CBA43VTRGRRvfxxx8zceJEnn/+efu6wsJCMjMzG/V1OnXqxHfffcewYcPqdOHQeeedx3nnncezzz7L+++/z/jx4/nggw+44447GrVfIiKOEB4ejre3N/v376+ybe/evU7okYhI42jfvj1gVPHp2LGjfX1qamqdR0hXlA+vuOixTZs2hIeH88svv1Rpu2nTphqT1jX58ccfefjhh5kxYwbjx4+v175/FBwcXO3n4iNHjlR6/yIiIiIi0rKovLm4rGuvvRaLxcK8efMqXdUNxlXe6enpZ3yOkSNHUlJSwptvvmlfZ7VaeeWVVxq9vyIijcVisVSJey+//DJlZWWN+jo33ngjZWVlPP3001W2lZaW2n9MPHnyZJX+VPzQqRLnIuIqLBYLI0eO5NNPP+Xo0aP29bt372blypVO7JmIyNkZMWIE7u7uvPzyy5U+sy1cuLBK29TU1CrrTpw4wdtvv02fPn3sI7wBrrvuOr788kuOHTtmX7dq1Sr27dvHDTfcUOf+JSYmcuONN3LBBRewYMGCOu9Xk06dOrFhwwaKi4vt6/7YTxERERERaXk00ltcVqdOnXjmmWeYNWsWhw8f5uqrr8bf35/4+Hg++eQT7rrrLh5++OFan+Pqq69m8ODBPPTQQxw4cIBzzjmHzz//nIyMDKDmsmgiIs505ZVX8n//938EBgbSo0cP1q9fz3fffVftvIdn46KLLuLuu+9m/vz5bNu2jcsvvxx3d3f279/P0qVLefHFF7n++uv5z3/+w6uvvso111xDp06dyMnJ4c033yQgIIAxY8Y0ap9ERBxp3rx5fP3111x44YXcd999lJaW8vLLL9OzZ09+//13Z3dPRKRBwsPDefjhh5k/fz5XXnklY8aM4ddff+Wrr74iLCysUttHHnmEgwcPcumllxITE8Phw4d5/fXXycvL48UXX6zU9i9/+QtLly7lkksu4YEHHiA3N5cFCxbQu3dvJk+eXOf+3X///aSmpvLII4/wwQcfVNrWp08f+vTpU6/3e8cdd/Dxxx8zatQobrzxRg4ePMi7775Lp06d6vU8IiIiIiLiWpT0Fpf22GOP0bVrV/75z38yb948wJhr7PLLL+f//b//d8b9LRYLy5cv54EHHuA///kPZrOZa665hjlz5jBs2DC8vLwc/RZEROrtxRdfxGKx8N5771FYWMiwYcP47rvvGDlyZKO/1qJFixgwYACvv/46f/nLX3Bzc6NDhw7ceuutDBs2DDCS45s2beKDDz4gOTmZwMBABg8ezHvvvUdcXFyj90lExFH69OnDypUrmTlzJrNnz6Zt27bMmzePxMREJb1FxKU988wzeHl5sWjRIn744QeGDBnCN998wxVXXFGp3eWXX86iRYt45ZVXOHnyJEFBQQwfPpwnnniCc889t1Lb2NhY1qxZw8yZM3nsscfw8PDgiiuu4Pnnn6/XfN6pqamUlZUxc+bMKtvmzJlT76T3yJEjef7553nhhReYMWMGAwcO5Msvv+Shhx6q1/OIiIiIiIhrMdn+WI9URPj000+55ppr+Omnn+xJHRERERERERERERERERFpfpT0llavoKAAb29v++OysjIuv/xyfvnlF5KSkiptExEREREREREREREREZHmReXNpdWbPn06BQUFDB06lKKiIpYtW8a6det47rnnlPAWERERERERaaCkpKRat3t7exMYGNhEvRERERERkZZMI72l1Xv//fd5/vnnOXDgAIWFhXTu3Jl7772XadOmObtrIiIiIiIiIi7LZDLVun3ixIksXry4aTojIiIiIiItmpLeIiIiIiIiIiLS6L777rtat8fExNCjR48m6o2IiIiIiLRkSnqLiIiIiIiIiIiIiIiIiIjLMju7AyIiIiIiIiIiIiIiIiIiIg3l5uwONDWr1UpCQgL+/v5nnFtKRJo/m81GTk4OMTExmM26jqexKWaKtCyKmY6lmCnSsihmOpZipkjLopgpIiIiIs7W6pLeCQkJxMbGOrsbItLIjh07Rtu2bZ3djRZHMVOkZVLMdAzFTJGWSTHTMRQzRVomxUwRERERcZZWl/T29/cHjA/hAQEBTu6NiJyt7OxsYmNj7ee2NC7FTJGWRTHTsRQzRVoWxUzHUswUaVkUM0VERETE2Vpd0ruibFpAQIC+WIu0ICqJ6BiKmSItk2KmYyhmirRMipmOoZgp0jIpZoqIiIiIs2iSHRERERERERERERERERERcVlKeouIiIiIiIiIiIiIiIiIiMtS0ltERERERERERERERERERFxWq5vTu7GVWW2s3JnEgPbBRAZ4Obs7cpqysjJKSkqc3Q05S+7u7lgsFmd3Q1q6fSshtDOEdnJ2T5xGMbNlUMyUGmUdh4Rf4ZwrQXNtnjXFzJZBMdN1bDyUzo6EbPrFBjGgfbCzuyP1pJjZMihmioiIiEhzp6T3Wfp2VzL3vbeVy3pE8uaEgc7ujgA2m42kpCQyMzOd3RVpJEFBQURFRWHSj/TiCEnb4f0bIbof3L3G2b1pcoqZLY9iplTrixlw4Fu47RPo9Cdn98ZlKWa2PIqZruGL3xN4d8NR7r+0i5LeLkQxs+VRzBQRERGR5kxJ77O0KzEbgK1HTmKz2fTBvxmo+FIdERGBj4+P/k1cmM1mIz8/n5SUFACio6Od3CNpkVL3GsuU3WC1grl1zfyhmNlyKGZKrTIOGcvE35T0PguKmS2HYqZrCfL2ACArv9jJPZH6UMxsORQzRURERMQVKOl9lg6n5QGQnldMUnYh0YHeTu5R61ZWVmb/Uh0aGurs7kgj8PY2zqmUlBQiIiJUTk0aX/YJY1lWBLlJEBDj3P40IcXMlkcxU2qUl2os0/Y7tx8uTDGz5VHMdB1BPu4AZBaoRLarUMxseRQzRURERKS5a13D2RwgvjzpDbDzRLYTeyKAfZ4wHx8fJ/dEGlPFv6fmgROHyE44df/kYad1wxkUM1smxUypoqQQiso/p6btc25fXJhiZsukmOkaAryNpHeWkt4uQzGzZVLMFBEREZHmTEnvs2Cz2ewjvQF2Jijp3VyobFrLon9Pcais46fut7KkdwWdYy2L/j2liryUU/fT9oPN5ry+tAA6x1oW/Xu6hqDypHdmvhJtrkbnWMuif08RERERac6U9D4LabnF5BSV2h/vSMhyYm9ERKRBWvFIbxFpJXJTT90vzIS8NKd1RUSkIYJ8yuf01khvERERERERqYGS3mfhcHpepce7NNJbmpkOHTqwcOFCZ3dDpHmrmNMblPRu5RQzpcU6faQ3qMS5NArFTGlKgSpvLi5OMVNERERExPGU9D4L8alG0rtvbBAAJzILOJlX7MQeiasymUy13ubOndug5928eTN33XXXWfXt4osvZsaMGWf1HCLNVmkx5J6WDDp5xHl9kTpTzJS1a9cyduxYYmJiMJlMfPrpp7W2X7ZsGZdddhnh4eEEBAQwdOhQVq5cWanN3Llzq/wtnXPOOQ58F00o9w9J7/T9zumHOIViprQEQT4V5c2LsVo1RYM4jmKmiIiIiIjrcnN2B1xZfPlI7z5tAsnML+ZIej67ErMZ1jnMyT0TV5OYmGi//+GHHzJ79mz27t1rX+fn52e/b7PZKCsrw83tzKdveHh443ZUpKXJSQRO++FUI71dgmKm5OXl0bdvX6ZMmcK11157xvZr167lsssu47nnniMoKIh33nmHsWPHsnHjRvr3729v17NnT7777jv747r83biEKiO9lfRuTRQzpSWoGOlttUFucSkBXu5O7pG0VIqZIiIiIiKuSyO9z8LhNCPpHRfmS8+YAAB2nNC83lJ/UVFR9ltgYCAmk8n+eM+ePfj7+/PVV18xYMAAPD09+emnnzh48CBXXXUVkZGR+Pn5MWjQoEo/1EPVEmomk4l///vfXHPNNfj4+NClSxc+//zzs+r7//73P3r27ImnpycdOnTg+eefr7T91VdfpUuXLnh5eREZGcn1119v3/bxxx/Tu3dvvL29CQ0NZcSIEeTl5f3xJUQcp2I+b+9gY5mbBMX5zuuP1IlipmLm6NGjeeaZZ7jmmmvq1H7hwoU88sgjDBo0iC5duvDcc8/RpUsXvvjii0rt3NzcKv19hYW1kAsZK+b0roh1Km/eqihmKma2BF7uFjzdjJ8vsvJV4lwcRzFTMVNEREREXJeS3mchvlLSOxCAnZrXu9mx2WzkF5c2+c1ma9yye4899hh//etf2b17N3369CE3N5cxY8awatUqfv31V0aNGsXYsWM5evRorc8zb948brzxRn7//XfGjBnD+PHjycjIaFCftmzZwo033si4cePYvn07c+fO5cknn2Tx4sUA/PLLL9x///089dRT7N27l6+//prhw4cDxhX0N998M1OmTGH37t2sXr2aa6+9ttGPm0itKubzjugBnkYcJ7P2c6ilU8ysTDGzZbJareTk5BASElJp/f79+4mJiaFjx46MHz/+jH8fRUVFZGdnV7o1SxUjvdsPM5Ya6d1oFDMrU8xsfU6cOMGtt95KaGgo3t7e9O7dm19++cUhr1VR4lzzersuxczKFDNFRERERBpXC6nZ2PSsVhuH008lvTEZ63cmaKR3c1NQUkaP2SvP3LCR7XpqJD4ejXeKPfXUU1x22WX2xyEhIfTt29f++Omnn+aTTz7h888/Z9q0aTU+z6RJk7j55psBeO6553jppZfYtGkTo0aNqnefXnjhBS699FKefPJJALp27cquXbtYsGABkyZN4ujRo/j6+nLllVfi7+9P+/bt7WVkExMTKS0t5dprr6V9+/YA9O7du959EDkrFUnvgDZQlANJvxslziNayDy+DaCYWZliZsv0j3/8g9zcXG688Ub7uiFDhrB48WK6detGYmIi8+bN48ILL2THjh34+/tX+zzz589n3rx5TdXthqsY6d1+GOz5EjKPQEkhuHs5t18tgGJmZYqZrcvJkycZNmwYl1xyCV999RXh4eHs37+f4OBgh7xekLcHydlFZGqkt8tSzKxMMVNEREREpHFppHcDJWUXUlhixc1som2wN73KR3ofSssjv7jUyb2TlmjgwIGVHufm5vLwww/TvXt3goKC8PPzY/fu3We8mrxPnz72+76+vgQEBJCSklLLHjXbvXs3w4YNq7Ru2LBh7N+/n7KyMi677DLat29Px44due2223jvvffIzzdKR/ft25dLL72U3r17c8MNN/Dmm29y8uTJBvVDpMGyypPegW0g2PiBR/N6twyKmVKT999/n3nz5vHRRx8RERFhXz969GhuuOEG+vTpw8iRI1mxYgWZmZl89NFHNT7XrFmzyMrKst+OHTvWFG+h/vLKk96R5VUtbFbIOOTcPkmzopgpDfG3v/2N2NhY3nnnHQYPHkxcXByXX345nTp1csjrVczrrZHe4myKmSIiIiIizZNGejdQxXze7UJ8cLOYCff3JMLfk5ScInYnZjOgfcgZnkGaire7hV1PjXTK6zYmX1/fSo8ffvhhvv32W/7xj3/QuXNnvL29uf766ykuLq71edzd3Ss9NplMWK3WRu1rBX9/f7Zu3crq1av55ptvmD17NnPnzmXz5s0EBQXx7bffsm7dOr755htefvllHn/8cTZu3EhcXJxD+iNSxekjva3lFyy18qS3YmZlipktywcffMAdd9zB0qVLGTFiRK1tg4KC6Nq1KwcOHKixjaenJ56eno3dzcZXUd7cNwLCusCJXyB9v5EEl7OimFmZYmbr8vnnnzNy5EhuuOEG1qxZQ5s2bbjvvvu48847q21fVFREUVGR/XF9p4QILC9vnllQ+9+hNF+KmZUpZoqIiIiINC6N9G6gQ+VJ7w5hp77s9IwJADSvd3NjMpnw8XBr8pvJZHLo+/r555+ZNGkS11xzDb179yYqKorDhw879DX/qHv37vz8889V+tW1a1csFuOHBTc3N0aMGMHf//53fv/9dw4fPsz3338PGP82w4YNY968efz66694eHjwySefNOl7kFbu9KR3cAfjfitPeitmOo5ipnMtWbKEyZMns2TJEq644oozts/NzeXgwYNER0c3Qe8cqKwECspHa/lFQFhX437aPuf1qQVRzHQcxczm79ChQ7z22mt06dKFlStXcu+993L//ffzn//8p9r28+fPJzAw0H6LjY2t1+sFlY/0Vnlz16WY6TiKmSIiIiIiGundYBUjvTuEnkp692oTyA97U9l5QklvcbwuXbqwbNkyxo4di8lk4sknn3TYVeGpqals27at0rro6GgeeughBg0axNNPP81NN93E+vXr+de//sWrr74KwJdffsmhQ4cYPnw4wcHBrFixAqvVSrdu3di4cSOrVq3i8ssvJyIigo0bN5Kamkr37t0d8h5EqlVR3jwgBtw8jPuZR5zXH3EYxcyWJTc3t9II7Pj4eLZt20ZISAjt2rVj1qxZnDhxgv/+97+AUdJ84sSJvPjiiwwZMoSkpCQAvL29CQw0pqh5+OGHGTt2LO3btychIYE5c+ZgsVjsc226rIrS5iYLeIdAWGfjcdp+5/VJmj3FTKkLq9XKwIEDee655wDo378/O3bsYNGiRUycOLFK+1mzZjFz5kz74+zs7HolvivKm2ervLk0M4qZIiIiIiLNg5LeDRRfnvSOC6860ntHQpZT+iStywsvvMCUKVM4//zzCQsL49FHH613icC6ev/993n//fcrrXv66ad54okn+Oijj5g9ezZPP/000dHRPPXUU0yaNAkwSsMuW7aMuXPnUlhYSJcuXViyZAk9e/Zk9+7drF27loULF5KdnU379u15/vnnGT16tEPeg0gVpcWnSv4GtgVPf+P+ycNgs4GDR4RI01LMbFl++eUXLrnkEvvjiiTKxIkTWbx4MYmJiZXm0XzjjTcoLS1l6tSpTJ061b6+oj3A8ePHufnmm0lPTyc8PJwLLriADRs2EB4e3jRvylFyK0qbh4HZrJHeUieKmVIX0dHR9OhReZqE7t2787///a/a9mc7JUSQj0Z6S/OkmCkiIiIi0jyYbDabzdmdaErZ2dkEBgaSlZVFQEBAg5/nT8+v5lBqHu/ePoQLuoQBcCwjnwv//gPuFhM7543Cw03V45taYWEh8fHxxMXF4eXl5ezuSCOp7d+1sc5pqV6LPr4nD8OLfcHiCU8kGyWAn4kAbPDwfqMMcAunmNkyKWY6T7M8vvu/hfeuh8jecO9PkLoXXhkMHv4w65gu8KkHxcyWSTGz4W655RaOHTvGjz/+aF/34IMPsnHjRtatW3fG/et7fP9vwxGe/HQHI3tG8vptA8+q7+J4ipktk2KmiIiIiDRnyso2QGmZlaPp+UDlkd5tg70J8HKjpMzG/pQcZ3VPRETqIjvBWAbEGEkfNw9jxDe0+nm9RaQFqRjp7Vc+Yj04zih1XpwDOUnO65eIuLwHH3yQDRs28Nxzz3HgwAHef/993njjjUoVNRpTRXnzLJU3FxERERERkWoo6d0AJzILKLXa8HQzEx1w6spWk8lEzxhjXsidCZrXW0SkWbPP593m1LrgDsZSSW8RaSkqpnHwLa9e4eZxKtapxLmInIVBgwbxySefsGTJEnr16sXTTz/NwoULGT9+vENeL8hb5c1FRERERESkZkp6N8Ch8vm8O4T6YjZXLglZMa/3zhOa11tEpFnLLk96B56W9A5qbyyV9BaRliI31Vj6nTY3ecW83un7m74/ItKiXHnllWzfvp3CwkJ2797NnXfe6bDXqpjTWyO9RUREREREpDpKejfA4Yqkd5hPlW0925QnvTXSW0SkehnxUFLo7F6cSnoHxJxap5HeItLS/HGkN0BYZ2OZpqS3iLiIPcvp8MtzDDf/pqS3iIiIiIiIVEtJ7waIL096x4X5VdnWq7y8+a7EbKxWW5P2S0Sk2fvlbXipH3w5w9k9OW1Ob5U3F5EWzD6n9+lJ7/KR3ipvLiKu4uAPBGx7nUHmveQXl1FUWubsHomIiIiIiEgzo6R3A5xKelcd6d0x3A8vdzP5xWXEp+c1dddERJqv+B9hxZ+N+4dWO7UrAGQdN5ZKeotIS5aXZix9qylvnnag6fsjItIQPqEABJtyAJU4FxERERERkaqU9G6A2kZ6W8wmzolSiXMRkUpOHoaPJoC11Hick3gqEeMsFSO9A6tJemcnQGlRk3dJRKTR5VUz0ju0i7HMOgrF+U3fJxGR+ipPekdYjO/i2Up6i4iIiIiIyB8o6V1PRaVlJGQWANXP6Q3QM6Yi6Z3VZP0SEWm2inJgyc1QkAHR/SCwnbE+abvz+lRadCoRdPpIb98wcPcFbJB5zCldExFpNNYyyE837p8+0ts3FLxDjPvpGu0tIi7Ax4hZ4eZcADLzlfQWERERERGRypT0rqdjGflYbeDn6Ua4n2e1bXq1KZ/XWyO9RaS1s1rhk3sgZRf4RcK49yGmr7EteYfz+pWTaCwtnvaRQwCYTCpxLiItR3462KyACXzCKm+rKHGevr/JuyUiUm/lSe+K8uZKeouIiIiIiMgfKeldT4dSjXJqHcJ8MJlM1bapGOm940QWNputyfomcvHFFzNjxgxnd0Mc7JVXXqFDhw54eXkxZMgQNm3aVGPbiy++GJPJVOV2xRVXNE1nV8+HPV+CxQNues8oJR7Z29iW5MSkd9YJYxkQYyS6T2dPesc3aZek6SlmSouXW17RwicELG6Vt4V1NpZpSnpL3ShmilOVX6QYaNOc3uIaFDNFRERERJqekt71dDi95vm8K3SN9MdiNnEyv4TErMKm6pq4sLFjxzJq1Khqt/3444+YTCZ+//33s36dxYsXExQUdNbPI87z4YcfMnPmTObMmcPWrVvp27cvI0eOJCUlpdr2y5YtIzEx0X7bsWMHFouFG264wfGd3bEM1v7duD/2RYgdZNyPKk96O3Okt30+77ZVtwW3N5Ya6d1sKWaK1FHFNA6+EVW3VYz0TtvXdP0Rp1DMlBahfEoGf2s2YCNTSW9xEMVMERERERHXpaR3PcWnlSe9Q6ufzxvAy91ClwgjKb5TJc6lDm6//Xa+/fZbjh8/XmXbO++8w8CBA+nTp48TeibNzQsvvMCdd97J5MmT6dGjB4sWLcLHx4e333672vYhISFERUXZb99++y0+Pj6OT3on/gaf3mfcHzoN+t1yaltUL2OZuseYW9sZssvPtYCYqttU3rzZU8wUqaPcVGPpF151mz3pfWqk986ELK58+UdW763+QipxTYqZ0iKUj/R2oxQ/CsjKL3Zyh6SlUswUEREREXFdTk9616dML8DChQvp1q0b3t7exMbG8uCDD1JY2HSjqe1J73DfWtv1jDHm9d5xIsvhfRLXd+WVVxIeHs7ixYsrrc/NzWXp0qXcfvvtpKenc/PNN9OmTRt8fHzo3bs3S5YsadR+HD16lKuuugo/Pz8CAgK48cYbSU5Otm//7bffuOSSS/D39ycgIIABAwbwyy+/AHDkyBHGjh1LcHAwvr6+9OzZkxUrVjRq/1q74uJitmzZwogRI+zrzGYzI0aMYP369XV6jrfeeotx48bh61t7DDsruSmw5BYoLYDOI+CypypvD4wFr0CwlkLqXsf1ozYVI70D2lTdZk96H2my7kj9KGaK1FFtI71DuxjL9ANgtQLwvy0n2HEim1nLtlNYUtZEnRRHU8yUFsHDB9y8AQgy5aq8uTiMYqaIiIiIiOtyO3MTx6ko07to0SKGDBnCwoULGTlyJHv37iUiouqPc++//z6PPfYYb7/9Nueffz779u1j0qRJmEwmXnjhhSbpc0XSu0PomZLeAfxvq0Z6Nws2G5TkN/3ruvtUnSu4Bm5ubkyYMIHFixfz+OOP2+eLX7p0KWVlZdx8883k5uYyYMAAHn30UQICAli+fDm33XYbnTp1YvDgwWfdXavVav9SvWbNGkpLS5k6dSo33XQTq1evBmD8+PH079+f1157DYvFwrZt23B3dwdg6tSpFBcXs3btWnx9fdm1axd+fjVPAyD1l5aWRllZGZGRkZXWR0ZGsmfPnjPuv2nTJnbs2MFbb71VY5uioiKKik6Nvs7OrmcMKy2CD281RlKHdobr3gKzpXIbk8mY1/vIT0aJ82gnjJQ4fU7vPzp9pLfNVufzuMVQzKwTxUxxCRVzevtVk/QObg9md+N8zz4BQbEcSssFIDGrkP9bf4Q7h3dsws66KMXMOlHMlEbhEwLZJwghR+XNXZViZp0oZoqIiIiINIxTk96nl+kFWLRoEcuXL+ftt9/mscceq9J+3bp1DBs2jFtuMcrkdujQgZtvvpmNGzc2SX/zikpJzjaSQXFhZ056A+xK0EhvpyvJh+eqSWw52l8SwKPuo2mnTJnCggULWLNmDRdffDFglE+77rrrCAwMJDAwkIcfftjefvr06axcuZKPPvqoUb5Yr1q1iu3btxMfH09sbCwA//3vf+nZsyebN29m0KBBHD16lD//+c+cc845AHTp0sW+/9GjR7nuuuvo3duYr7ljR/1Q3ty89dZb9O7du9a/l/nz5zNv3ryGvYDNBstnwrGN4BkIN38A3kHVt43qZSS9k5w0r3d2edK7ujm9g9oZy+IcKDhp/MDamihm1olipriEvPLy5r7VlDe3uENIR0jbC+n7ISjWfnEnwCurD3DT4FgCvNybqLMuSjGzThQzpVFUJL1NOWTmK+ntkhQz60QxU0RERESkYZxW3rwhZXrPP/98tmzZYi+BfujQIVasWMGYMWOapM+H040fAoN93Any8ai1bY/ypHdCViEZeZpvTM7snHPO4fzzz7fPzXzgwAF+/PFHbr/9dgDKysp4+umn6d27NyEhIfj5+bFy5UqOHj3aKK+/e/duYmNj7V+qAXr06EFQUBC7d+8GYObMmdxxxx2MGDGCv/71rxw8eNDe9v777+eZZ55h2LBhzJkzh99//71R+iWnhIWFYbFYKpW1A0hOTiYqKqrWffPy8vjggw/sf081mTVrFllZWfbbsWPH6t7Bja/Dr++CyQw3vA1hXWpuG1k+r3eSk/5OsmsZ6e3uDf7Rxv2T8U3XJ6kXxUyROqhtpDecitNp+ykutXIswxh9Fx3oRWZ+CW+sOdQEnZSmoJgpLUL5vN5BqLy5OJZipoiIiIiIa3LaSO+GlOm95ZZbSEtL44ILLsBms1FaWso999zDX/7ylxpf56xL9Z7mcJrxQ2CHM4zyBvD3cqdDqA+H0/PZmZDFhV2qGWEjTcPdx7iy2xmvW0+3334706dP55VXXuGdd96hU6dOXHTRRQAsWLCAF198kYULF9K7d298fX2ZMWMGxcVNd1HF3LlzueWWW1i+fDlfffUVc+bM4YMPPuCaa67hjjvuYOTIkSxfvpxvvvmG+fPn8/zzzzN9+vQm619L5+HhwYABA1i1ahVXX301YJS+W7VqFdOmTat136VLl1JUVMStt95aaztPT088PT3r3zmbDY6WX7B02dPGXN61iSpPeifvaPoS4qVFp0Y/BlQz0huMEuc5iUaJ8zYDmqpnzYNiZqNRzBSns4/0PlPSex9HM/Kw2sDXw8KcsT25590tvPVTPBPOb0+Ev1fT9NcVKWY2GsVMOaPypHeIKYfflPR2TYqZjUYxU0RERESkKqeN9G6I1atX89xzz/Hqq6+ydetWli1bxvLly3n66adr3Gf+/Pn28lOBgYGVrpStr/jyeQ7PVNq8Qs+YQEDzejudyWSUMmvqWwOSeDfeeCNms5n333+f//73v0yZMsU+h9jPP//MVVddxa233krfvn3p2LEj+/bta7TD1L17d44dO1ZpZO+uXbvIzMykR48e9nVdu3blwQcf5JtvvuHaa6/lnXfesW+LjY3lnnvuYdmyZTz00EO8+eabjdY/McycOZM333yT//znP+zevZt7772XvLw8+zQREyZMYNasWVX2e+utt7j66qsJDQ11TMdMJrj+HbjpXRg69cztw7uDyWKUD89u4h++Kl7Pzavm0uWnz+vd2ihm1olipriEiqS3Xw0XX4Z1NZZp+ziUalQ0igv3ZWTPSPrFBlFQUsbLqw40QUddmGJmnShmSqPwNj63BZtyyMxXNTWXpJhZJ4qZIiIiIiIN47SR3g0p0/vkk09y2223cccddwDQu3dv8vLyuOuuu3j88ccxm6vm8GfNmsXMmTPtj7Ozsxuc+I4vH+kdF1rHpHebAJZvT1TSW+rMz8+Pm266iVmzZpGdnc2kSZPs27p06cLHH3/MunXrCA4O5oUXXiA5ObnSl966KCsrY9u2bZXWeXp6MmLECHr37s348eNZuHAhpaWl3HfffVx00UUMHDiQgoIC/vznP3P99dcTFxfH8ePH2bx5M9dddx0AM2bMYPTo0XTt2pWTJ0/yww8/0L1797M9JPIHN910E6mpqcyePZukpCT69evH119/ba+acfTo0SqxcO/evfz000988803Du1bal4J/3esKxNiiwnzO8NocXcvI9mSutsY7R3YxqF9q6Qi6R0QU/MPYEHtjWVrTHq7EMVMkVpYrbXP6Q0QWjHS+4B9Pu+4MD9MJhOPjjqHm9/cwJJNR7njwjja1/HzrzRfipni8spHegeTQ1ZBCVarDbO5CasFSauimCkiIiIi4nqclvRuSJne/Pz8Kskci8UCgM1mq3afBpfqrYZ9pHd4PUd6n8hqlNeX1uH222/nrbfeYsyYMcTEnJpv+IknnuDQoUOMHDkSHx8f7rrrLq6++mqysur395Wbm0v//v0rrevUqRMHDhzgs88+Y/r06QwfPhyz2cyoUaN4+eWXAeNcS09PZ8KECSQnJxMWFsa1117LvHnzAOML+9SpUzl+/DgBAQGMGjWKf/7zn2d5NKQ606ZNqzFOrl69usq6bt261RgjG9O9727hlyMnMZtNzBjR9cw7RPUykt5Jv0PXkQ7vn519Pu9aEu2teaS3i1HMFKlBYSZYS437NSW9wzoby5wEjicZCfKO5RWNhnYK5aKu4azZl8oL3+7jxXH9q38OcSmKmeLSKpLephysNsgtLiXAy93JnZKWTDFTRERERMS1mGxNkQmpwYcffsjEiRN5/fXXGTx4MAsXLuSjjz5iz549REZGMmHCBNq0acP8+fMBY86iF154gTfeeIMhQ4Zw4MAB7r33XgYMGMCHH35Yp9fMzs4mMDCQrKwsAgIC6tXfc5/+loy8Yr6cfgG92gSesX1abhEDn/kOkwl2zB2Jr6fTrjFoNQoLC4mPjycuLg4vL80/2VLU9u96Nue0nFl9ju/nvyVw/5JfCfH1YN1jf8LL3VL7k//8Inw7G3pcDTf+p/E6fSY//RO+mwt9xsG1r1ff5sh6eGcUBLWDGdubrm9NTDGzZVLMdJ5mdXxT9sCrQ8ArEB47WnO7BV0gL4XHQl/igxNhvDiuH1f1My4K2nEiiytf/gmA5fdfYL+gs7VSzGyZFDOdp97Hd/vH8L/b2WjrwU1FT/DjI5cQG1L/uZqlaShmtkyKmSIiIiLSnDk1C1vfMr1PPPEEJpOJJ554ghMnThAeHs7YsWN59tlnHd7XrPwSMvKMecPqOqd3mJ8nkQGeJGcXsTsxm4Edapg7VkSkBRjTK4q/BXlzIrOAZVtPcMuQdrXvENnLWCbvcHznTpdVPtK7tpLqFSO9s45DWQlYNIpIRFxMXoqx9I2ovV2YkfR2O3kQCKv0ObdXm0DG9o3hi98SWLByL4snD3Zcf0VEzsTH+D4dajYqsGUVlNCwictERERERESkJao6CXYTmzZtGkeOHKGoqIiNGzcyZMgQ+7bVq1ezePFi+2M3NzfmzJnDgQMHKCgo4OjRo7zyyisEBQU5vJ/x6cY8hxH+nvUasd2rosS55vUWkRbOzWJm8rAOAPz7p0NYrWcoJBLV21imH4TiPMd27nSnz+ldE79IcPMCm9VIfIuIuJrc8qS3Xx2S3kBE8RGg6sWdD13WFTezidV7U9lwKL3RuykiUmf2Ob2NpHdmfokzeyMiIiIiIiLNjNOT3q7icJqRkKnrKO8KPWOMkk47NK+3iLQCNw2Kxd/TjUOpefywN6X2xn4R5SMQbZC8q0n6B0B2eRI7oG3NbcxmCGpv3Ne83iLiivKMObprnM+7QlhXADqZEgj398T/D/PjdgjzZdxgYyzl37/egxNnRhKR1s7bGOkdaMsGbGQWFDu3PyIiIiIiItKsKOldR4camPTuoZHeItKK+Hu5c3N5WfM3fzx05h0qRnsn13/e7BPJKazbuKHe+9VppDecKnGupLeIuKK6jvQONUZ6dzQl1vg59/4/dcHL3czWo5l8uyu5MXspIlJ35SO93SjFjwKyCjTSW0RERERERE5R0ruOGjrSu1cbY6T3/pQcikrLGr1f1SorhZWPw75vmub1miGNQmpZ9O/pWiad3wE3s4kNhzLYfvwMVS6iyuf1Tqr/vN6Jb49nyIpR/Lbp+7rvVFp0avRjYC0jvaFVJb11jrUs+vcUoH5zegMdTUl0DvOqtklEgBdThsUBsGDlXsrONH1FC6dzrGXRv6cL8fABN28Agky5Km/uInSOtSz69xQRERGR5kxJ7zqKL096d6hn0rtNkDeB3u6UlNnYn5zriK5VdWg1rP8XfPN407xeM+LubpTkzM/Pd3JPpDFV/HtW/PtK8xYT5M2VfaKBOoz2jqwY6V2/pHdeRgLnFm7GYrJRtPPruu9YMcrbzQu8g2tvG9zyy5srZrZMipkCQG75BT5+ZyhvHtSOEpM7nqYSevvVXJno7os6Eejtzv6UXD759UQjdtR1KGa2TIqZLsbHKHEeQo5Gejdzipktk2KmiIiIiDRnbs7ugCuw2Wz2kd4d65n0NplM9IwJYN3BdHYmZNGrTaAjulhZ2j5jefIwWK3G3LSthMViISgoiJQUY3STj48PJpPJyb2ShrLZbOTn55OSkkJQUBAWi8XZXZI6uuPCjny6LYHl2xN5dPQ5tAnyrr5hRXnzpB31ileJG5fR2WSMMvBP3VL3jmWXJ2oC2sCZYkMrGOmtmNmytKaYuXbtWhYsWMCWLVtITEzkk08+4eqrr651n9WrVzNz5kx27txJbGwsTzzxBJMmTarU5pVXXmHBggUkJSXRt29fXn75ZQYPHuy4N+JIdR3pbbZw3NyGuLLDdHOruXR5oLc7913ciflf7eGf3+7jyj7ReLm33L+x6ihmtiytKWa2KD4hkH2CEFMOWRrp3awpZrYsipkiIiIi4gqU9K6DtNxicopKMZkgNsSn3vv3ahNYnvRuonm9Mw4ay7JiyE2GgOimed1mIioqCsD+5VpcX1BQkP3fVVxDrzaBDO0YyvpD6Sz+OZ7Hr+hRfcPQzmDxhJI8OBkPoZ3q9PyWfcvt99vl7wRrGZjr8MNLXefzhlaR9AbFzJaoNcTMvLw8+vbty5QpU7j22mvP2D4+Pp4rrriCe+65h/fee49Vq1Zxxx13EB0dzciRIwH48MMPmTlzJosWLWLIkCEsXLiQkSNHsnfvXiIizpA4bo7y0ozlGeb0ttls7CuNJM50mHbW47W2nXh+B975+TAnMgt4b+NRbr8grrF66zIUM1ue1hAzW5Tyeb2DyCWzoNjJnZEzUcxseRQzRURERKQ5U9K7Dg6nG6O8YwK9GzSipWeMMa93kyW90w+eup95pNUlvU0mE9HR0URERFBSoqv/XZ27u7uuIndRdw6PY/2hdJZsOsb0S7sQ4FVNCTyLG0R0h8RtRonzuiS9C7Npe3IzAMU2C76mAooTtuPRtt+Z980qT+icaT5vgKDy8uaFmVCQCd5BZ97HBSlmtiytJWaOHj2a0aNH17n9okWLiIuL4/nnnwege/fu/PTTT/zzn/+0J71feOEF7rzzTiZPnmzfZ/ny5bz99ts89thjjf8mHMlmg9yKkd61lzdPzi5ib1k0I90gOP9wrW293C08MKILs5Zt570NR1pl0lsxs2VpLTGzRSlPeoeYctipkd7NnmJmy6KYKSIiIiLNnZLedRCfWl7aPLx+pc0rVCS9t5/IYndiNt2jAxqtb9XKOD3pfRTanefY12umLBaLvpCJONHFXSPoHOHHgZRcPtx0jDuHd6y+YVQvI+mdtB16XHXG5y3buxJ3SjhojeYEYQw3bSd991qi65L0rs9Ib08/I1mUl2pcQNRCk94VFDOlJVu/fj0jRoyotG7kyJHMmDEDgOLiYrZs2cKsWbPs281mMyNGjGD9+vU1Pm9RURFFRUX2x9nZTXSB45kUZUNZeb/OkPQ+lJbLQasREy2nf4aswcXdjOc7mpFPmdWGxdw6S9UqZoo4ibcxp3ewSXN6uxLFTBERERERaQqtZ7LnsxBfPtK7Q2jDkt6dwv0YEhdCcamVCW9v4kj58zlEadGpkYwAJ4847rVERGphNpu4o3wU4Ds/x1NSZq2+YVQfY5m0o07Pm/vbpwD8YB5CYkBfAEoPr6tbp06f07suWkmJc5GWLikpicjIyErrIiMjyc7OpqCggLS0NMrKyqptk5SUVOPzzp8/n8DAQPstNjbWIf2vt9xUY+nhBx61T80Tn5bHIVv5hUBp+8741BH+XriZTZRabSRnF55tT0VE6qd8pHcwSnqLiIiIiIhIZUp610HFSO+4sIYlvU0mE2/cNpBzovxJzSnitrc2keKoHwlPHgbbaYmlTCW9RcR5ru7fhjA/DxKyClmxPbH6RpG9jGVyHZLeJYX4HPkegISoSymIGgxAQOrWunVISW8RaUSzZs0iKyvLfjt27Jizu2TIq1tpc4BDqXkcskWf2q/gZK3tLWYTMUHeAJzILDirboqI1FtF0tuUQ6bKm4uIiIiIiMhplPSug4o5vRua9AYI9HHnv1MG0y7Eh6MZ+Ux4exNZjviSnv6HspRKeouIE3m5W7jtvA4A/PvHeGw2W9VGkT2NZdaxMyZbiF+De1k+ibYQQrueh3fcEEptZgKLkytXuahJVnnSO1BJb5HWJCoqiuTk5ErrkpOTCQgIwNvbm7CwMCwWS7VtoqKianxeT09PAgICKt2ahYr5vP0iztg0Pi2PPLzJ8yxvm3bgjPu0KU96Hz+Z3+Auiog0iI9R3jyEXApKyigqLXNyh0RERERERKS5UNL7DKxWG/FpZ5/0BogI8OLd24cQ7u/JnqQcpvxnM/nFpY3RzVPSy3+o9C8vU5l5tHGfX0Sknm49rx2ebma2n8hiY3xG1QbeQRDUzrh/hhLntl2fA/BN2QAGdgilS2wku2ztjY1HN9TekZJCyE8z7td1pHdQ+XMr6S3i0oYOHcqqVasqrfv2228ZOnQoAB4eHgwYMKBSG6vVyqpVq+xtXEpeeXnzOoz0rvicWxLcyViRvv+M+7QNLh/pfVIjvUWkifmcmtMbUIlzERERERERsVPS+wySsgspKrXiZjbZf+A7G+1CffjvlMEEeLmx5chJ7n13K8WlNcxz2xAZ5SO9O11iLLOOg1VXv4uI84T6eXL9gLYA/PvHQ9U3iuxtLGsrcV5WinXPCgBWMZi+sUF0jfRni7UrAIWHzjCvd06CsXTzBu/gunVeI71FmqXc3Fy2bdvGtm3bAIiPj2fbtm0cPWpc7Ddr1iwmTJhgb3/PPfdw6NAhHnnkEfbs2cOrr77KRx99xIMPPmhvM3PmTN58803+85//sHv3bu69917y8vKYPHlyk763RlHHkd7FpVaOZhijtd0jzzFW1mFe7zbBFSO9lfQWkSZWXt48xJwL4JjqaSIiIiIiIuKSlPQ+g4rRL+1CfHCzNM7h6h4dwNuTBuHlbmbNvlQeXvobVms1JX8boqK8efthYHYHaylkJzTOc4uINNDtF8RhMsF3u1M4kJJbtUFU+bzetY30PrYBS2EGmTZfCqKH4OVuwc/TjXgfI2Feenh97Z2oiIUBMWAy2VfbbDb+/f/Zu+/wqMrsgePfOzW99xAINQFC7yJFQcEKVqwoKu6qWBZdV3RXf+u6smtfy4oNe1dUVBZQBESk914SCOm9t0lm5vfHOzNJIAlJSCHJ+TzPfe7MnVveGZ2by5x7zlmXwKaEnFO3cQa980/IDURCnEW2bt3KsGHDGDZsGKAC1sOGDePxxx8HIC0tzRUAB+jZsyc//vgjP/30E0OGDOH555/n7bffZtq0aa51Zs2axXPPPcfjjz/O0KFD2blzJ8uXLyc0NLRt31xLcPX0bjjonZRXitVmx8OkxyPcGfRuTKa3ByA9vYUQ7cDdkelNEWCXTG8hhBBCCCGEEC6G9h7A2c4Z9I4+w9LmJxsZHcCim0Zwx/tbWborFT8PI3+/fCBajUBMs+Q6siiD+oFflHqen6geCyFEO+kV7MWU2FB+PpDBO78dY+GVg2qvEOoIemfsqX8nB34A4GfbCIb1rA7klIWNhBPgkXcQKorA7F339vX08153JJunfjxAVIA76x4+v/Y2PhGOG4gqoTClugy7EKJdTZ48Gbu9/hsG33vvvTq32bFjR4P7nTdvHvPmzTvT4bW/Ykd5c6+Gy5sfy6pu4aMF9VULGxH0ru7pLUFvIUQbc2R6G6nCizLyJdNbCCGEEEIIIYSDZHqfRkv1867L5JgQnr92CJoGH2xI5MWfT/8jY4MspSooAxDYuzo4I329hRBngbkTegKwZHsyOcUVtV8McwTBMw+AtY4fL+12OKiC3iusIxnZo7o8eVi3XiTZgtFhg+Qt9Q/AeX48qZ/3Zkef8aTcslNLZOr01efSvMQG3p0QQpxFGpnpnZCtKm/0DPJUN0yCumGyrvNwDa6e3vllLVetSAghGsPkoVrVAH5aMfmS6S2EEEIIIYQQwkGC3qdxvJUyvZ1mDI3kycsHAvDyqiO8u/5Y83eW59jWzQ88AsCvh2O5BGqEEO1vdM8AhnTzpaLKxocbTzov+fUAkzdYLXVnGabtgoIkSu1mfrUNZkSNoHdsmA9b7Y5gzYlN9Q+gnqD31sRc1+MD6YWnbid9vYUQHU2JM9O74aC38+bOXkGe6txo9FCVLU5z7Rjm64ZOUz3Bs0++iUkIIVqbhypxHkCRlDcXQgghhBBCCOEiQe/TOJZT48fAVnLzuGjmX6ACNn//fj8H0uoIujSGs593YG81l0xvIcRZRNM0bp/QC4DPNidhrZkdqNNBqLoBiIw6+no7srzX2gbTLdifQC+z66WYMG+22dQ51H5iY/0DqNnT26HSamNnUn71Yeo6/0rQWwjR0TjLm3s2XN48wVHevFewlzoPO68hcxquPmTU6wj3dZQ4l77eQoi25gx6a0UUlFraeTBCCCGEEEIIIc4WEvRuQJXVxomcUqD1Mr2d7j2/DxP6BgHwe3xO83aS6wh6Bzh+sHQGavIl01sIcXaYNjAUX3cj6YXl/B6fXfvFMEdf7/Q6+nofcJY2H8XIHgG1XooO9GC3FguAPXkzWKvqPnhBspr7dnMt2p9aSHmlrfowaUWnbidBbyFER2IpgUoVzD5t0PvkNj7OEufZh097GOnrLYQ42b/+9S80TeOBBx5o3QM5+nr7IeXNhRBCCCGEEEJUk6B3A1Lyy6iy2TEbdIT7uLXqsTRNY0xPFcjZVSPrsElyjqq5ZHoLIc5SZoOey4aEA7Bke0rtF519vU8OemcfhawDVKHnF9tQRkb713rZoNdBSCyFdnd0laV1Z4pDnZneWxPzHONSfw4P1lne3Nkq4njDb04IIc4GxY5+3gY3MHvXu1pReSVZRao0ec9gZ9A7Rs3ruvnoJK6+3hL0FkIAW7Zs4Y033mDw4MGtfzD3GpneEvQWQgghhBBCCOEgQe8GOLNfogM90em0Vj/e4G5+AOxKzm/eDnIS1NyZ6e3s6V2YAlb5MUAIcXa4arjKtF6+N53iihpZ2aGOoPfJQeuD3wOw0TaAQrwYFV070xugX7g/2x0lzkmqo693ZTmUOjLLa/T03u4Iel82RAXCD2UU1S67DpLpLYToWJz9vD1DQKv/+vV4tqpmFORlxsfNqBZ2H+t48Tew2+vZUon0d2Z6l57ZeIUQHV5xcTE33ngjb731Fv7+/qff4Ew5Mr39tSLyS+XfuUIIIYQQQgghFAl6N+D4ySUfW9ngbr4AJOaUklfSjN5kuSf19PYKUVk+dlt1WV8hhGhnQ6P86BXkSVmllWV70qpfCOkPmk4FbIoyqpc7Spsvt44kyMtMj0CPU/YZG+bNVmfQu66+3kWOLG+DO7irH2PtdjtbE3MBuHJ4JO5GPeWVNo45zv0uzqB3aTZU1FH+XAghzibOTG+v05U2LwagV83r3KjRoDdBURrkxDe4vSvTW3p6C9Hl3XPPPVxyySVMnTq1bQ7oDHpTJOXNhRBCCCGEEEK4SNC7AeUntnOT/if6+rd+ljeAn4fJFWDfnVLQtI0riqDYESRyBr01rUaJc+nrLYQ4O2iaxlUjVLb319tq3JBj8oDAPupxhqO0bmEqpGzFjsYK60hGRfuj1ZG5GBvmwzZ7jaD3yRmKBY5S6r6RrszH5LwyMgorMOg0hkX50y9MlQE+pcS5m68rUE6enEuFEGe5EkfQ2zOkwdUSsuq4udPoDt1Gq8fH1ja4faSfugFJenoL0bV99tlnbN++nYULF5523YqKCgoLC2tNzVIj07tQgt5CCCGEEEIIIRyaFfROSkoiObk6ULF582YeeOAB3nzzzRYb2NlgVOpHPGV8l3t3Xg7LH4XcY61+zCGObO8m9/XOdZQ29whSARon6estRLvrKufMprhiWCSaBpuO5ZKUW6M0bmicmjv7yR78EYB4c3+y8GdEj7pLZsaEebPT1psqu05ldRck1V6hjn7e2xylzQdG+uJu0jMgXAW9D6TV1dc7Ws3b8gaiqgqwWdvueEK0ETkntrJiR3nz02R6O6ta9Ao+qaJRz4lqfnxdg9vX7OltP00pdCHE2aclzsVJSUncf//9fPzxx7i5uZ12/YULF+Lr6+uaoqKimjV2PBw9vSkmv7QZFdKEEEIIIYQQQnRKzQp633DDDaxevRqA9PR0LrjgAjZv3sxjjz3Gk08+2aIDbE8jJ16KLaA3pqoi2PgavDwMPr0eEtacts9hc7n6ejc16J1zUmlzJ2dfb8lOFKLddJVzZlNE+LlzTm+VpbNke0r1C2HOoLejr/dBVdr8e8twgDr7eQMEe5vx9PJhnz1aLThxUl/vQsePuj7dXIucpc1HdFeB9P7hPgAcSKujhHlb9/XOT4KXBsE7F4LN1jbHFKKNyDmxlTU209tR3vyUNj49J6j5sXUNXu+G+6kAV1mlldzmtOURQrSrljgXb9u2jczMTIYPH47BYMBgMLB27VpefvllDAYDVmvtm/cWLFhAQUGBa0pKSqpnz6fhCHr7a0UUlFVis8mNN0IIIYQQQgghmhn03rt3L6NHq9KHX3zxBXFxcfz+++98/PHHvPfeey05vvY16nZ087bCjV9Bn6mAHQ4tgw9mwH/HwtbFYCk57W4a7fh6Lij4Cg0bu5ILmpY14+znHXBy0FsyvYVob13mnNlEVw1XAeglO5Krz3ehg9Q8Yy+U5cHx3wD4tnw47kY9AyJ86t1fTJg3W20x6knSSX2968j03npcZXqPjFZB79gwte+DDWV6t0XQ226HpfNUy4qUrXD059Y/phBtSM6JrczV07v+oLfdbudYVj2Z3pEjweAOpdmQeaDefZgNekJ9zEAXLHFeVQHLF0D8L+09EiGarSXOxVOmTGHPnj3s3LnTNY0cOZIbb7yRnTt3otfra61vNpvx8fGpNTVLjfLmNjsUW6qatx8hhBBCCCGEEJ1Ks4LelZWVmM3qR66ff/6Zyy+/HIDY2FjS0tJabnRnA50O+l4AN30N87bCqLlg9ISsg/DDn+CFAbDyb1CU3vxj2O2w7nl47xKitjzFVP0usosrSC0ob/w+XJnevWov93dkektPbyHaTUueM1977TWio6Nxc3NjzJgxbN68ucH18/PzueeeewgPD8dsNtOvXz+WLVvWvDfSwqbHheFh0pOYU+oqNU6YI+idfQT2fQu2KvK9+pBoD2NYdz+M+vr/bMWG+bDV5uzrfVKmd82e3kBheSWHMlRG90hHyfRYR3nz1ILyU0tltmXQe9u7qqKI06bXW/+YjWGthA9mqknKrosz0KWuI9tDiaO8uWf95c2ziioosVjRadA94KSgt8EE3ceqx6cpcR7p5yhxnt/Fgt5Hf4aN/4WfnmjvkQjRbC1xLvb29iYuLq7W5OnpSWBgIHFxca02dtwdmd4UAXYKSqWvtxBCCCGEEEKIZga9Bw4cyKJFi1i3bh0//fQT06dPByA1NZXAwMAWHeBZJagvXPIcPHgApj2tgiDl+fD7y/DaaNj1WdPLnlcUwRezYdWTgNp2mrfqz92kEuc5kuktxNmqpc6Zn3/+OfPnz+eJJ55g+/btDBkyhGnTppGZmVnn+haLhQsuuIDjx4/z1VdfcejQId566y0iIyNb5H2dKQ+TgYviwgH4eruj/Lh3mMresVvhtxcB2Ox2DlAdnK6PyvR2BL0z90F5QfWLhY6gt4967ztP5GO3Q1SAOyE+qkSvj5vR1aP2lBLnrlYRx5v6NpsmL1HdSAUw5i7QdCqTMOtQ6x63MXZ8CAmr1XRsbXuPRnRgXfY6sq04g94NZHrHO7K8owI8MBnq+OeAq8T5rw0eqpu/BwDJeaVNH2dHlquu1SloZmlmIc4CHfpc7Mj0NmlWvCijoEyC3kIIIYQQQgghmhn0/ve//80bb7zB5MmTuf766xkyZAgAS5cudZVI69TcfGHcPXDvdrj+MwgfooIr3/wBPruh8VnfOfHw9lQ4sBR0Roi5GICR+iNAE4PezvLmgX0AyCwqp7zSCn7RanlRGlQ2IXNcCNFiWuqc+cILLzB37lzmzJnDgAEDWLRoER4eHixevLjO9RcvXkxubi7ffvst48ePJzo6mkmTJrmOfza4aoQKQv+wK02dszQNQh2ZQY4KFZ8XDwVgZD39vJ36h/mQhT/JhIDdBslbql88Kei91ZFZPrJH7X26Spynn1Ti3JXpndh6Pbbtdlh6L1iKIWosTPun6+8Cmxa1zjEbq7IM1j5T/Xz3l+03FtHhdfnryNZW7Mz0rj/ofSxbBb1P6eft1HOSmh//rcFzXqTjRqGUrlbe3HkDVFkeWLpYwF90Gq11Ll6zZg0vvfRSC42yHiYP1YYB8NOKyZdMbyGEEEIIIYQQgKE5G02ePJns7GwKCwvx96/OvLvzzjvx8PBoscGd9XR6iLlI9fte/xKs+bfq+Z34O1z8LAy6RgVw6nJ4JXx9B1QUgFcYzPpQlWk7tIyosoMYqWJXcn7jxlGWD6U56nFAL45kFHHpK78xqV8wb948QpVjryyBgmQI6tMCb1wI0RQtcc60WCxs27aNBQsWuJbpdDqmTp3Khg0b6txm6dKljBs3jnvuuYfvvvuO4OBgbrjhBv7yl7+c0mPRqaKigoqKCtfzwsI6+lu3oLE9A4n0cyclv4yV+zO4fEiEKnHuyCS2+kSxKjMUnQbDuvs1uK++oV7oNNhs7Uc3faYqcd5nqgrYOs+RjvLm2xJzARhxUvb4gHBvfj6QwYGT+3r7dgOdAawVKovcWYa9JW1drN63wR1m/lf9jRnzRzj4g6okcv7fwKPhwH+r2fyWunnK5A2WInWz1iXPqx+dhWgiuY5sRZXl6toSwKv+8ubHsosB6BXkVfcK4UPV9708HzL2qBs86+CsjtHlenrn1WgbVJgq19eiQ+rw52KPAChMIYAi8sssp19fCCGEEEIIIUSn16xM77KyMioqKlz/OE5MTOSll17i0KFDhITUn1XSaemNMPHP8Ie1jqzvfFgyFz67EYoyaq9rt8Ovz8In16ofJaPGqO2iRkNgb3APQG+zMFA7zp7kAqy2RpRLd2Z5e4WB2Ysf96RRUWVj7eEsqmz2Gn29j7fkuxZCNFJLnDOzs7OxWq2EhobWWh4aGkp6et3VJRISEvjqq6+wWq0sW7aMv/3tbzz//PM89dRT9R5n4cKF+Pr6uqaoqKhGvsvm0ek0rhyuAtFLnCXOawSUE0POBzT6h/vg7WZscF9uRj3RQZ5stcWoBUkb1bwwVc2NHuDmR5XVxo4T+cCpQe/YcJXpfUp5c71R3eQEtTOeW0peIvz0uHo85XH19wAg+lyV+V5ZCts/aPnjNkZ5Ifz2gno8faEq9W4pVjd5CdEMch3ZipylzXVGcPOrd7UER3nznsH1ZHrrDdBDtZZoqMR5l+3pXbPVhbOSiBAdTIc/FztuBAzQiqS8uRBCCCGEEEIIoJlB7xkzZvDBB+rH9/z8fMaMGcPzzz/PzJkzef3111t0gB1K6EC4YxWc91f1Y+OhH+G/Y2DPVyrYXVEEX9wMvzwF2GHkbXDLD6qHLais8KgxAIw1HqXEYiU+q/j0x81x9BV0BElWH1I/eFZU2VTPRunrLUS7aq9zps1mIyQkhDfffJMRI0Ywa9YsHnvsMRYtqr9U9oIFCygoKHBNSUmt36/0yuHdAPj1cBaZheXV5c2BNTp1TjxdP2+n2Jp9vZO3gbWqdmlzTeNgehGlFiveZgP9Qr1rbd/fEfQ+nFFElfWkkr7nPQZoKss5dUcT32UDbDZYOk8FkruPU9ndTppW/XzzW+r9tLUNr6oSvkH9YMj1MPhatXyPlDgXzSPXka2oJFPNPYPrrzZEdXnzXvWVN4cafb3X1btKdU/vMuz2Rtyo2RnYbLWvqZ03VgnRwXT4c7Gjr7cfUt5cCCGEEEIIIYTSrKD39u3bmTBB/RD21VdfERoaSmJiIh988AEvv/xyiw6ww9EbYdKf4c41KluxLA++vh0+vwnemgIHvge9CS57GS59EQym2ttHqf5pkzxUILtRfb2dmd4BvcgurmB3jbLoe1MKVFYe1C7FKIRoMy1xzgwKCkKv15ORUbt6REZGBmFhYXVuEx4eTr9+/WqVMu/fvz/p6elYLHWXgTSbzfj4+NSaWlvPIE+Gd/fDZodvd6ZAcCxEDINuo/guWwXET9fP2yk2zIcj9khKdV6qrUPGnuqAhE8EAFuPq9Lmw3r4o9fVDgr1CPDA3ainosrG8ZyS2jsP6V8d8P2l/mz5Jtu2WGVSGtxhxmugO+lP86Br1A+7hcmq1HlbKsmGDa+px+c9prI/Bzk+g6M/Q0lO245HdApyHdmKnP28GyhtXmm1cSJX9aHuVV+mN0DPiWqe+Hu9N9w4M72LK6ooLGuHm3LaQ3G6anXhVJjcfmMR4gx0+HOxu2R6CyGEEEIIIYSorVlB79LSUry9VXbcypUrufLKK9HpdIwdO5bERAmsAhAWB3NXw+RHVR/Ygz9A9iHwDodbl8GIW+rezpHpHWc9CNgb19c7xxH0DuzNr4ezqJlosy+1UDK9hWhnLXHONJlMjBgxglWrVrmW2Ww2Vq1axbhx4+rcZvz48Rw9ehSbrTpj+fDhw4SHh2Mymercpr1cNUIFt7/eloJdp4c711B883L2pKlqFyOjG5fpHRPmjR0d+3SOEucnNkKBIyDhq46xNTFP7bOO7HGdTiMmTP232n9yiXOAyY+oc/rRnyGx7l7qTZJ3HFY6yppP/b/qsuY1Gd1gxBz1eFP9Wfqt4rcXVQZ6+BDof7laFtxP9fu1VcG+JW07HtEpyHVkK3Jletdfmjgpt5Qqmx13o55Qb7f69xU6SJVItxRB2s46V3E36QnyUn9PkvJKmznoDubkm0gl01t0UB3+XOzI9PbXiiiQTG8hhBBCCCGEEDQz6N2nTx++/fZbkpKSWLFiBRdeeCEAmZmZbZIV2GHojTD5Lyr43f0c6HMB3LkWokbVv03EMNAZ8K7MppuWza6kgtMfJ+eomgf0Zo2jtLkz82ZvakGNnt4d4McLITqhljpnzp8/n7feeov333+fAwcOcNddd1FSUsKcOSogOnv2bBYsWOBa/6677iI3N5f777+fw4cP8+OPP/L0009zzz33tOwbbAGXDo7AZNBxKKNI3awD7DyRj80O3fzdCfd1b9R++oepz3NdRR+14MTGUzK9tzcQ9IbqEucH0wpPfTGgFwy7ST3+5R9wJuV8bTb4bp7KSO8xHkbfWf+6o+5QwfYTGyB1Z/OP2RQFyaqkOqg+4zUz0J0Z77u/aJuxiE5FriNbUbEj6O1Vf9DbWdo8OsgTna7+EujodBB9rmOjtfWu1uX6etfs5w0S9BYdVoc/FzuD3hSRX1Z3BSMhhBBCCCGEEF1Ls4Lejz/+OA899BDR0dGMHj3alWW4cuVKhg0b1qR9vfbaa0RHR+Pm5saYMWPYvHlzg+vn5+dzzz33EB4ejtlspl+/fixbtqw5b6PthA+G2/4HN30F3qENr2vyUBl1wHDtMAfSCimvtNa/vt3uKm9uDejN2sMq6P3HySpbcH9qITafKLWuZHoL0S5a6pw5a9YsnnvuOR5//HGGDh3Kzp07Wb58OaGh6rxy4sQJ0tLSXOtHRUWxYsUKtmzZwuDBg7nvvvu4//77eeSRR1r2DbYAX3cjFwxQ7+Pr7Soze4ujDPmoRpY2BxUg9zDp2WztqxYkbarV0zs1v4zUgnL0Oo2h3f3q3MeAcJX1dKCuoDfAxIdBb4bE9RD/S6PHdoqt78DxdWD0gBmvnlrWvCafcBgwUz1uq2zvtc+oEr49xkPvKbVfi7sKNB0kb4bcY20zHtFptOR1pDhJiaO8uWf95c1d/bwbKm3u5Cxx3si+3l2C4ybSdLu6ccqan9SeoxGi2Tr8ubhGprf09BZCCCGEEEIIAc0Mel999dWcOHGCrVu3smLFCtfyKVOm8OKLLzZ6P59//jnz58/niSeeYPv27QwZMoRp06aRmZlZ5/oWi4ULLriA48eP89VXX3Ho0CHeeustIiMjm/M2zl6OEufjzfFU2ez1B14ASnOhXGWD7yrxp6CsEl93I9eM6IbJoKO4oopkHNk+JVlgKal/X0KIVtFS50yAefPmkZiYSEVFBZs2bWLMmDGu19asWcN7771Xa/1x48axceNGysvLiY+P59FHH63V4/tscvVwVX586c5UKq02tjkyskfUk5FdF2d58p223tg0AxSlQfIW9aJPpKu0+YBwHzxMhjr3EevI9D5QV3lzAN9IlXkNzc/2zjsOPz2hHk/9P5VBfjpj71LzvV9XZ3O2luyjsOMj9XjK46CdlA3qHQY9J6nHe75s3bG0FUsJbHm7umWIaDUteU7sCixVNuyNPc80ItM7PssR9A5qRNA7WvX75cRGqKo7kzLS35Hp3VWC3o5M7822WABsBZLpLTqmDn8u9nD09KZYenoLIYQQQgghhACaGfQGCAsLY9iwYaSmppKcrLLyRo8eTWxsbKP38cILLzB37lzmzJnDgAEDWLRoER4eHixevLjO9RcvXkxubi7ffvst48ePJzo6mkmTJjFkyJDmvo2zU9RoAMYaVdnyXUn59a/ryPLGpxur41WAZkLfINyMevo7+tLuzgHMvmo9yUYRol20xDmzs5vQN4ggLzM5JRZWHchg+wkVoG5KpjdAbJg35ZhJ93T09S7NUXPfSLY5sscbCqTHOs6d6YXl5JXUUy7z3D+B0RNSd8DBH5o0vtplzc+FUXMbt123kdBtFFgtsLXuv5MtZs3TYLdC32nQfWzd6wyepea7vzizMu9ng/JC+PBK+PFBeHsqZOxv7xF1enJObJw9yQUMfXIlj3+3r3EbuDK9GypvXgxAz8YEvUP6g0cQVJVBytY6V+nmCHond5Ge3rbc40B10NtYkQeVXSTgLzqdDn0udgS9/bUiCXoLIYQQQgghhACaGfS22Ww8+eST+Pr60qNHD3r06IGfnx//+Mc/sNlsjdqHxWJh27ZtTJ06tXowOh1Tp05lw4YNdW6zdOlSxo0bxz333ENoaChxcXE8/fTTWK0NlP/uiLqpoHeUJQFPytiV3EBfb2dGWmAvVh9S2T3nxagfOgdEqED33pRC8O+u1pO+3kK0uZY4Z3YFBr2OmUNV3+1nlh+i1GLFx81A3xCvJu0n1tHXe6/upB9sfSJcmd4NBb293YxEBaggzoH0eipteAVXZ17/8k+wNfLvkM0GKxY0vqz5ycb8Uc23vANVFY3bJnUnLH+08b3A03arbHKA8/9a/3r9LwWDO+QcUcH/jqosDz6cCUkbHc9z4YMZkH2kXYfVmck5sfGeXanOhZ9vSWpcUMcZ9PZqTHnzRpxbNQ16OrK96ylx3tV6elflqJYO+2zRlNjNaqH09RYdUIc/F0t5cyGEEEIIIYQQJ2lW0Puxxx7j1Vdf5V//+hc7duxgx44dPP3007zyyiv87W9/a9Q+srOzsVqtrl60TqGhoaSnp9e5TUJCAl999RVWq5Vly5bxt7/9jeeff56nnnqq3uNUVFRQWFhYazrr+UaCbxQ6bAzRxbMrOb/+dR2Z3mXe0Sq4DUyKUT90xkWqwM++1ALw66HWl77eQrS5ljhndhVXjVAlzhMcQZmR0QHodFpDm5wixpGpvbasd/VCoyfFmperXcTI6IZLpjsD5/WWOAc4515w84WsA9VB4oZYq2DpvOqe3Bc/BwE9T79dTQNmgHcElGTCvm8aXtduh42LVObyxtfgzcnw7T1QVPffWJdfHH9T466C8MH1r2f2htiL1eOOWuK8NBfevxxStoG7P8z+DsIGqc/3/csgN6G9R9gpyTmxcXacyOPXwyqIbbHa+N+etNNv5CxvXk+md3FFFRmF6oaZnoGNyPSG6hLnx36t8+Uu1dO7qgJjaQYAJ+whpNsdlUgKU9pxUEI0T4c/F7s7Mr0poqyyioqqTnYjvBBCCCGEEEKIJmtW0Pv999/n7bff5q677mLw4MEMHjyYu+++m7feeuuUfrItyWazERISwptvvsmIESOYNWsWjz32GIsWLap3m4ULF+Lr6+uaoqKiWm18LcpR4nyEdpiErJL6s3scmd6HKtWPm4O7+RLkpbJO4hyZ3vtSC7H7OTK9HX0IhRBtp73OmR1R/3AfBjh6akPT+nk7OcuTryyKrl7oE8Gu5AJsdpWVGO7rftpxABxMa+BGKXc/OOc+9Xj102BtIMuoqgK+mgM7PwZND1e8AcNubMS7OYneCKNuV483vl5/WfHSXPj8Jlj+F7BVQnB/wA47P4JXRsC656Gy/NTtTmyEIyvUGM977PTjGXStmu/5SgX1O5LiLHjvUkjfrco33/oj9JoMN3+rPq+iNBUQl5vFWpycExvn5VWq2oCPmwGAb3eeJrBqrVSVCqDent7HHTcUBXqa8PUwNm4gPSepefLmOst4O3t6F5RVUlTeybMt85PQsFNiN9O7RzSpdpVpKpneoiPq8OdiR6a3SbPiRZmUOBdCCCGEEEII0bygd25ubp19vmJjY8nNzW3UPoKCgtDr9WRkZNRanpGRQVhYWJ3bhIeH069fP/R6vWtZ//79SU9Px2Kpu+/qggULKCgocE1JSR2kp3WU6qE63qyC2nvqK3Geo/p+b8z3A2ByTPWPnDFh3uh1GrklFgrNqmSw/HgvRNtriXNmV+LM9oam9/MG8PMwEebjRhZ+lHs7qlz4RrL1+OlLmzsNCFeB83rLmzuN+SN4BkPeMRXQroulBD69Dg4sBb0Jrn0fhlzX6PdzihFzwOAGaTshadOprydthjcmql7jehNc9CzcvQFu/xkiR4ClGFY9Ca+Ngn3fVgfO7Xb4+e/q8bCbILD3qfs+WZ8pKtOqJBOOrW3+e2prRenw3iWQuQ+8wmDOMggdqF7zDFIZ34F9oCBJZXwXSBZnS5Jz4untTs5n9aEsdBosumkEABsTckltqIR4SbaaazpVuaAOzioajern7RTYG7zDwWpR55eTeJkN+DkC6J2+xLnj5tEkewgzhke6Mr0rcuX6WnQ8Hf5cbPJQbVYAP62YAilxLoQQQgghhBBdXrOC3kOGDOHVV189Zfmrr77K4MENlEKtwWQyMWLECFatWuVaZrPZWLVqFePGjatzm/Hjx3P06NFaPcYOHz5MeHg4JpOpzm3MZjM+Pj61pg7Bkek9mMNo2OoucW63u0qvLktTP16eF1Pdw9HNqHf1wk2wBqmF0tNbiDbXEufMrmTG0Ag8THr8PYwM7ubbrH3EOoLWKd6Oz9cnkq2J6gfc05U2h+ry5ocziqmyNtDX0uwFEx5Uj9c+c2r2dFk+fHglxP+ienjf8AX0v6xJ7+UUnoEw6Br1eOPr1cttNvjtJVg8XQVr/XvC7SthzJ2qL2/UKBX4vuJNVSI9/wR8eYsK/qbuhKOr4MTvoDfDpL80bix6I8RdqR7v/uLM3ldbKUiBdy+G7EPgE6kC3sExtdfxDoVbvgf/aBXk+uDy05eFF43WkufE1157jejoaNzc3BgzZgybN58alHWaPHkymqadMl1yySWudW699dZTXp8+fXqTxtQSXl6lbmqcOTSSc/oEMbqnCq4u3dVARnGJo7S5RxDo9HWukpBVDECv4CYEvTUNek5Uj+stce7o693JS5xbc1U/7yR7CON7B1FoUjebFmXI9bXoeDrF9amHOjcGUCSZ3kIIIYQQQgghMDRno2eeeYZLLrmEn3/+2RWg3rBhA0lJSSxbtqzR+5k/fz633HILI0eOZPTo0bz00kuUlJQwZ84cAGbPnk1kZCQLFy4E4K677uLVV1/l/vvv59577+XIkSM8/fTT3Hfffc15G2e30DgweuBRWUIfLZVdSeGnrlOcCZZi7JqOA2WBBHiaGNzNr9YqAyN8OZhexJ5iX4aBZHoL0Q5a6pzZVQR5mVk671z0Og03Y92Bm9OJCfNmzaEsVnlcRO/go1gHXs2Oj/IBGN799EHv7gEeeJj0lFqsHMsuoW+od/0rj5gDv7+ierpuXQzj7lbLi7PgoysgfY/q/X3jV64bms7Y2Ltgx4dw4HsoSFaZ39/8EY7+pF4feCVc9h9wO+lGL50OhsyC/pfC+pdh/X8gcb3q9+3MDB09F3wjGz+WwbNgy9tqLJYXwNSEYFpby0tUmdv5ieDbHW51BLbr4hOhAt/vXqyqqnwwQ5VA9wxq0yF3Ri11Tvz888+ZP38+ixYtYsyYMbz00ktMmzaNQ4cOERJyannvJUuW1KoMlJOTw5AhQ7jmmmtqrTd9+nTeffdd13Oz2dzUt3hG9qYU8POBDHQa3HN+H0AFvzcfy+XbHSn8cVI9VRiKVf/v+kqbAxxzZXp7NW1Q0RNg9+dwfF2dL0f6ubM3pbDT9/XOTzlCIJCuC2VKgAd2nwjIB0tecnsPTYgm6xTXpx4BUJhCgFZEvmR6CyGEEEIIIUSX16xM70mTJnH48GGuuOIK8vPzyc/P58orr2Tfvn18+OGHjd7PrFmzeO6553j88ccZOnQoO3fuZPny5YSGhgJw4sQJ0tLSXOtHRUWxYsUKtmzZwuDBg7nvvvu4//77eeSRR5rzNs5ueoMqQwuM1B2qO9M7V5U+LzCFUYmBiX2D0Ou0WqsMjFABj015jh83y/Kg/DTleoUQLaqlzpldSZ8Qr6aV3z1Jf0em9k/FPeGejRzyHElxRRWeJr2r53dDdDqNGMd6+xvq6w1gdINJD6vH656HimIViH73IhXw9gxWwdKWCniDKsUdPQHsVlj2MCw6VwW8DW4q2H314lMD3jWZPOG8BXDvVkfWuF31AjZ5wbl/atpYuo1SgePKEjj0vzN5V60rJ15ltecnqiz4OcvqD3g7+XWHW5aqzPisg/DBTNUvvSFVFZB1GNL3gs3aUqOvm82qMtBTd8DhFa17rBbUUufEF154gblz5zJnzhwGDBjAokWL8PDwYPHixXWuHxAQQFhYmGv66aef8PDwOCXobTaba63n73/6G2Va0iu/qF7elw2JoHewun67ZFA4Jr2Og+lFHKjvnOTM9PYMrvt1aga9m3h+7TlBzVO2qXPcSbr5e6iXO3l587JMVWHJ6tsdnU7DHBAFgK4oraHNhDgrdYrrU0dfbz+KyZdMbyGEEEIIIYTo8pqV6Q0QERHBP//5z1rLdu3axTvvvMObb77Z6P3MmzePefPm1fnamjVrTlk2btw4Nm7c2KSxdlhRY+D4OkbojvBpYQXpBeWE+bpVv56jgt7xVnWTwHmxp2b2xEWq0sDb0ytV39WyXJXtHRbX+uMXQri01DlTNI4zYH0wvQi73c42R2nzYd39Megbd79X/3AfdpzI52B6ETNOt/LQG1XWdG4CrPwrHP1ZlRj36ab6Qwf1OYN3U4+xd6msy0M/qudB/eCa96p7UzeGbze46m0YfSdsegMGXN70TGZNg0HXwq/PqEzQQVc3bfvWZrfD8d9gyVwoSoPAviqD26eOCip1CeilAt/vXgwZe+DDK+C6T6A0G3KPqX7uuQmOx8fVDQ84+qS7+aqbE3pOgl6T1H8jTWvoaNVsNihMhuzDUJiqgttFabXnxRlgr1F+f0EymE9/U8fZ4EzPiRaLhW3btrFgwQLXMp1Ox9SpU9mwYUOjxvDOO+9w3XXX4elZOwC8Zs0aQkJC8Pf35/zzz+epp54iMDCwUfs8UwfSClmxLwNNg3nnOc4becfx9Y5gckwwK/dn8O3OFPqH13FTS7Ej6F1PprfdbichSwW9ezelvDmoG0T8uqtryBMboe/UWi9H+qny5sl5pU3bbwejL1BlzN2CewHgFxYNCeBZLu0PRMfU4a9P3R3lzTUpby6EEEIIIYQQ4gyC3qINRI0BYKzxKFTCruR8wnzDql93ZHrvLQ9C02Bi31MzewY4Mr3TCsqp6tEdQ1muynKToLcQohPrHeyFQadRVF5FakE5WxPzABjRo/EZm86gUr1ZlTXpjTD5UVhyB2xzlEUO6K0C3n5RTR5/o/SbDkExqjf1kBvg4mdVj/HmiBp9Zpnogx1B76OroCT7zEqAWyshYx+kbIW0XeAZot5r5PB6+xTXqSgddn4COz5y/b0kuL8KYDdQ/rlOQX3Vdu9dAmk74cUBDa9v9FTB7fICOPiDmgC8wlRv5F6T1NyvO1RZVNA8+5DKEM8+pALd2UegshEBRE2nPiPvMKgo6jBB7zOVnZ2N1Wp1VQdyCg0N5eDBg6fdfvPmzezdu5d33nmn1vLp06dz5ZVX0rNnT+Lj43n00Ue56KKL2LBhA3r9qf//VVRUUFFR4XpeWHhm1XRe/UX18r54UDh9/TT47h71/3Cv87hi6H9ZuT+DpTtT+cu0WHQnVfehxFHevJ5M76ziCoorqtA06B7o0fTBRU+EnR/B8V9PCXp3lZ7e3uWqp3pQVD8AwrqpUvPetgKoLFeVP4QQbceR6e2vFVFQajnNykIIIYQQQgghOjsJep/NokYB0M2WSgCF7ErKZ9rAGkFvR6b3cXsYQ6P88Pc0nbILL7OBXkGeJGSXkGcKIxikr7cQotMzGXT0DvbiUEYRB9MK2eYIeo+MbkLQ25Et3qigN0DcVfDbC5C5H0IHwc1Lmh5cbQqdXpVNL0qF8CGtd5zGCOoLEcNUme29S2DMnY3bzm5Xf5NStkLytupAd1V57fXWPQceQdD3Aug3DXqfr7KoT2athCMrYfuHam53lBc3ean/PlOeAM9mZuyG9Fc3MXwwA0pz1A/tAb1UqfSAno55L/XYM1iVHk/bCcfWQsJaSNoExemw5ws1gQpWl+ZUj/NkOiME9lbBce8w8A6vnnuFqrlnsGqJIprknXfeYdCgQYweXftmj+uuu871eNCgQQwePJjevXuzZs0apkyZcsp+Fi5cyN///vcWGdPhjCKW7VVlsv8cVwpvTKy+YSNhNVOGbcHbzY20gnI2HctlXO+T/l8+Tab3MUeWdzd/d8yGJtxA4tTTEfQ+9uspL0X6OzO9O2/Q21aSh5ddlXbv0Ufd+BLdLZJSuxkPrYKKvGTMIa1Q1UMIUT9n0JsiDkumtxBCCCGEEEJ0efIr6dnM3R+CYyHrIMN1R9iV3LP267mqr+AxexjnxdQfWBkQ4UNCdgnJHcA3pgAAZjZJREFUhKigd15i641ZCCHOErHh3hzKKOLXw1kk55Wh02BolF8TtleZ3hmFFeSWWAio48aiWnQ6uOFzOPADDL0B3Bt/rGbzClbT2WDQtSroveeLhoPeleUq83nv15C8pTo7tSazr8rsjhimSoYfXaXKie/6VE06A/Q4R2WA95uuSnzv+BB2flrd1xhUxZRhN8PAK5qfBV9T2CB4YC/YKusOutekN0C3kWqa8KB638mbVQD82K+qN7JzrCYvVfo8OEbdQBAUox77R6sqAuIUQUFB6PV6MjIyai3PyMggLCysnq2UkpISPvvsM5588snTHqdXr14EBQVx9OjROoPeCxYsYP78+a7nhYWFREU1r7rDK78cBbuNFyJ/JfrbxWCrAp9IVYVh3zeYfnmCywa8zSfbM/huZ8qpQW9XT++6rwkTHP28ewU187vg7OudtgvK8mud45w9vXNKLJRaqvAwdb5/YqQkHiQKyLb70jNcnXeDvM0kagFEk0baiXiiJegtRNvyUOXN/aW8uRBCCCGEEEIImhj0vvLKKxt8PT8//0zGIuoSNRqyDjJSd5jXksdgs9lVOUubDXtOPBpwzB7Ogw0EveMifflhdxqHyv0ZBpLpLUQbkXNm+3L29V6yPcXx3Advt8YHEL3MBroHeHAit5SDaYWc06cRJbv9usO4u5s13g4v7ipY+ZgKZOfEqwzlmjIPwLb3YfdnUJZXvVxnUMHkyBEQ6QgSB/RWNxE4WStVH+HDy+HwCsg5ogLHx36FFY/WPo5nMAy5TgW7g2Na/n2amlEWGlTZ454T1QRQXghZB1VQ0yei8b2+O7CWPCeaTCZGjBjBqlWrmDlzJgA2m41Vq1Yxb968Brf98ssvqaio4KabbjrtcZKTk8nJySE8vO4e8GazGbPZ3Ohx1+doZjFbdu/lI+PrjM/ZpxYOmAGXvgR6EyT+DnnHmNtrFZ8Qx4970vi/ywfiZqyRsV3suIGknhthjjmC3j2DmtjP28knAgL7QM5RNZ7Yi10v+bob8TYbKKqoIjW/jD4hna/MftqxA0QBOcZwgvTq/KRpGkWmELCkkZOWQHS7jlCIxulU16eOTO8AiskvlaC3EEIIIYQQQnR1TQp6+/o2nNXk6+vL7Nmzz2hA4iRRY2D7B4zUH6aovIpjOSX0DvaCojS0qjIq7XrKPSIZ6OjdXZe4CPXfbXuhD9eB6ukthGh1cs5sX/3D1HmxqKIKgJFN6OftFBvmzYncUvY3NujdQgrKKpn1xga6B3jw5uyRbXbcM+IdCr0mQ/wvsOcrmPwXqCiGfd/A9vdVMNzJpxsMuxH6TIWwwafvg6s3qizTnhNg2j9VUP3wChUET1yvMr37XADDb1aZ3x0hO9rN58z6qHdALX1OnD9/PrfccgsjR45k9OjRvPTSS5SUlDBnzhwAZs+eTWRkJAsXLqy13TvvvMPMmTMJDKydKV1cXMzf//53rrrqKsLCwoiPj+fhhx+mT58+TJs2rdHjao613y3mf6Z/468Vg9EDLvq3unHDeTPE+X+FpfcSvfdVYn1e5mAhrDmUyfS4GsF4V0/vum+EPJheBECv4GYGvQGiJ6ig9/F1tYLeoEqcH0wvIimvcwa9i9NVqflyr261lls8w8Gyi9KspPYYlhBN1qmuT2tkeudLprcQQgghhBBCdHlNCnq/++67rTUOUZ+oMQAM1hIwUsWupHwV9Hb0eEyyB3NuTLjK/q6HMyC+rdAHzKhMb7u9S2SVCdGe5JzZvpyZ3k5N6eft1D/ch5X7M1zBorby0cZEDqYXOaZCYsPqv7HprDJ4lgp67/xY9Rrf8zVYHJ+dzqAC0iNuVT25dc3oKewU2Ftl1I+7GyqKVBlo96b/9xVtq6XPibNmzSIrK4vHH3+c9PR0hg4dyvLlywkNDQXgxIkT6GpWDAAOHTrEb7/9xsqVK0/Zn16vZ/fu3bz//vvk5+cTERHBhRdeyD/+8Y8Wyeauk6WEwm//zO0pH4MGZUFxuF/3nipzX9PQG2HTm2gZe3gq9EeuLryCb3akVAe9bVbVAgDq7Om9cl86vx5WQfHh3c/gu9JzAmx7F46tO+Wlbo6gd0on7ettyz0GgCGwdrshvW83yANbQXJ7DEuIJutU16fOnt5aEYUS9BZCCCGEEEKILq/zNdzrbAL7gHsAprJcBmrH2ZXUmyuHd1NZbsBxexjnxTbcz9Xf00SknzvJ+Y71KgpVaVnHnfFCCNEZhfu64eNmoLBcZXqPaEamd39HX+8DaYUtOraGlFdaWfzbMdfzpTtTiZ3eQYLesZeAwV1VFNn2nloW0AuGz4YhN6hs8JZm7nwZpaLx5s2bV2858zVr1pyyLCYmBrvdXuf67u7urFixoiWH17C0XfD1HfhkHwbgfz6zuOiPr4LBdOq6Oj1Mewo+mMGIzCX01kaz+qCOgtJKfD2MUJqrKh6AKwjkOkxBGQ9/vRuAOyf2Ii7yNP3oGxLt6OudsQdKcsCz+ljOvt7JnTDobbfbcS9RQW2/iNo3JHgEd4fjYCxJa4eRCdHFuTsyvSkiv6SinQcjhBBCCCGEEKK96U6/imhXmubK9h6hO8yu5AIAClMPAZBoD2NCn4aD3qCyvSswUWpy/Dgpfb2FEJ2cpmmuDOkwHzci/dybvI/+4SqgeiSjmEqrrUXHV58vtiaRU2LB4Kjg8f3u1HqDdGcdszeMvQtM3jDoGrjlB7h3O5z7p9YJeAvRUdntsPxRyD5Mht2PGy0LiLjmmboD3k69JkO/i9DsVv7p+QUWq41lex2B1pJMNXcPqFXe32qz86fPd5JfWsmgSF8euvAM+9x7hUBwf/U48bdaLznPsSn5nS/onZxXRrgtA4DgHrU/w8AIlfntY8lqs78TQggHx00+Js2KtbwQm62DXC8JIYQQQgghhGgVEvTuCBw9P4frDrM/tRBLlY2C5IMAWP17qQyf0xjo6OudqXcEHaSvtxCiC4h1BK1HRPujNaOlQ5S/B54mPRarjWPZJS09vFNUWm28sTYBgIenx+Bp0pOUW8aOpPxWP3aLmfoEPJoMV72tSiFLKw0hTqVpMONVdvhOZXrFvzD2PZ8hUX6n3+7Cf4DOwNiqLYzX7eHbHSlqebEj6H1SafPX1xxlY0IuHiY9L18/DJOhBS79e05U82O/1lrczV8FvZPzSs/8GGeZfSm5RGqqfLzppPLmAWHRAIRpOSTmtP7fCSFEDSYP7AZ17vGhmGJLVTsPSAghhBBCCCFEe5Kgd0fgyPQepT+CxWrlYHohujwVFAmJHtCoXcRFqmzHY1VBaoFkegshuoA543syJTaEeyb3adb2Op1GbBuWOP9hdyop+WUEeZmYPS6aCwaoG5WW7kxt9WMLIdpWEqFck3U7efhw35S+p98AVK/vUXcA8FfDx2w5lq0yq0tUv248q6v/bEvM48WfjwDw5Iw4egZ5tszAezpKnMevVhnrDpGOoHdn7Ol94ngCZq0KK3rwiaz1mubbDYAgrZD41Jz2GJ4QXZrmaNkVQBEFpdLXWwghhBBCCCG6Mgl6dwQRw0BnIIQ8umnZbEnIItiiMnti44Y1ahfO/o0HyvzUgjzJ9BZCdH49gzx559ZRDIhofk/s2DCVLb6/lYPeNpud19fEAypY72bUc/nQCAB+3JOGVUp2CtGp/HdNPFU2OxP6BjG8u3/jN5z0F3Dzpb/uBNfo16qbYk7K9C4oq+S+T3dgtdmZMTSCq4ZHNrDDJuo5CQxukBuv+pI7OHt6ZxZVUF5pbbnjnQVyklXf9VL3cNAbar/o7o9FMwOQnnysrYcmhHAGvbUi8iXoLYQQQgghhBBdmgS9OwKTB4QNBmC4dphlv23DpFVhwUDfPrGN2kWIt5kgLxNJdkcGkGR6CyFEo/R3ZHofTCtq1eOsOpjJ4YxivMwGbhrbA4Bz+wTj52Ekq6iCjQmSQShEZzIwwodQHzP3NzbL28kjQAW+gYcMX7Byx5Hqnt6eIdjtdh77Zg8p+WVEBbjz1My4ZrV3qJebD/Sbrh7v+dK12N/DiLtRD0BaQXnLHe8sUJGtgtl2/+hTX9Q0St1UVY6CjONtNyghhOLo6+1HMQVlEvQWQgghhBBCiK5Mgt4dhaPE+QjdYdyLjwOQZ45EOznbpB6apjEwwpcku6PXo/T0FkKIRunv6AvemuXN7XY7/11zFICbxvbA190IgMmg46K4cEBKnAvR2dw0tgfrHj6fkdEBTd941Fysfj0J1go4P+dT8rMcvb29gvlyWzI/7E7DoNN4+bpheLsZW3bgAIOvVfO9X4NNZXVrmtYp+3pnFpbjX6HOvx4hvepcx+atqnKU5yS12biEEA7uNTK9yyztPBghhBBCCCGEEO1Jgt4dRXdn0PsI0Vq6WhbQu0m7iIv0Idleo6e3XUrlCiHE6cSEqUzvzKIKcoorWuUYm47lsuNEPiaDjtvOja712uVDVDDlf3vTqKjqXCWDhejqTIZmXoobTOinPQXAXP2PWJJ2AJBp8+WJ7/YBMP/CfgxrStn0pugzFdx8oSgNjv/mWtwZ+3rvTS2gm6Yy6Q2BPetcxxQQBYCuKFVaUQjR1hyZ3v5S3lwIIYQQQgghujwJencU3UYD0F93goHacQD8oxpX2txpYIQvqfYgbGhQWQol2S09SiGE6HS8zAZ6BKpetQfTW6fE+X8dvbyvGdGNEG+3Wq+N7hlAqI+ZwvIqfj0s520hhEPsJeQGjcJNqySkTJ1DXttSSFmllXN6B/LHiU27ObJJDGYYMFM9rlHivDrTu/MEvfelFNLdEfTGv0ed63gEdQcg2J7dqbLchegQnEFviqS8uRBCCCGEEEJ0cRL07ih8I8E3Cj02LtZvAsAU0rQekHERvlgwkml3ZP1IX28hhGiU2LDWK3G+N6WAXw9nodPgD3UEqfQ6jUsHq2zvpbukxLkQwkHT8Lz8GXUzo8P2HCP+HkZenDUUna4F+3jXxVnifP9SqFQ9vCP91A1CKfmdJ+i9N7WAKC1LPamrpzeg81Xn6HAtl6OZxW00MiEEAB6qvLm/JkFvIYQQQgghhOjqJOjdkUSpbG9fzZFB0sTy5lEB7ni7GThhD1YL8o+34OCEEKLz6h+uSpwfSGv5TO/X16oMzcuGRNDdkVF+MmeJ85/3Z1BqqWrxMQghOiZz9+Fs95/uep5t9+XZq4cQ6uPWwFYtpPs54BMJFQVw9CeATtnT+3ByFmFannriF133Sj7dAAjTcjkiQW8h2pYj0zuAYvJLpae3EEIIIYQQQnRlEvTuSKLG1H4e2KdJm2uaxsAIH5JdQe+zMNO7IBmSt7b3KIQQopbqoHfLZnofyy7hf3vSAPjjpPpvZBrczZcegR6UVVr5aX9Gi45BCNHBnf84BXYPsuy+XDx2MFMHhLbNcXU6iLtKPd79BdD5enrnlVjQFSYBYDd5uTJKT+HjzPTO4UiGBL2FaFOS6S2EEEIIIYQQwkGC3h2JI9MbAIM7eIc3eRdxEb4kOYPeeYktNLAWkr4H/jsO3p4Ch1e092iEEMKlf5gKeh/NLKaiytpi+33z13hsdjg/NsQVWK+LpmmubO/vpcS5EKKG4QP783T0YhZGvcGfLxnUtgcfdI2aH14B5QWuTO/0wnIqrba2HcveryH+lxbd5f60QqIc/bw1/2jQ6ikZ7xMJQLBWyPHMvBYdgxDiNJw9vbUi8ksl6C2EEEIIIYQQXZkEvTuS0DgwOkrfBvRSGTZNFBfpe3Zmeucdh4+uggpHFuWyh8DSeUpjCtGSXnvtNaKjo3Fzc2PMmDFs3ry53nXfe+89NE2rNbm5tUHZ206mm787QV5mLFYbC5bswW63n/E+MwrL+XpbCgB3Tz59uwpn0Hvt4Swp3ymEcNHpNP495yJeuOMi3Iz6tj142CAIjgVrBRz4niBPMyaDDpsd0gvK224cmQfgq9vgk+ugvKDFdrs35fT9vAHwCMCmNwNQlHmiRf5GCCEayd2R6U0RBS14fWSpspFTXNFi+xNCCCGEEEII0fok6N2R6I0QOUI9DuzVrF3ULG9uzz9LMr2Ls+DDK6A4A0IGqmyZ/BOw7vn2Hlnj5SfBjw9CTnx7j0R0cp9//jnz58/niSeeYPv27QwZMoRp06aRmZlZ7zY+Pj6kpaW5psTEs+S734HodBrPXjMYvU5jyfYUXvz5yBnv8+11CVisNkZF+zMyup6SuTX0DfUmNsybSqud5XvTz/j4QghxxjQNBl2tHu/5Ep1Oo5ufyvZOasu+3gd/VHNrBRz6X4vtdm9qId0dmd749ah/RU1D81XZ3r6VWaS1ZcBfiK7Okelt0qxUlrVcG5onlu5j9NOr2JmU32L7FEIIIYQQQgjRuiTo3dH0m6bmJ/f3bqRewV5k6lWvR3t+EtjauPTkySqK4JNrIDcBfLvDTV/D9H+p19b/B7LPPLDU6ux2WHInbHkbfnq8vUcjOrkXXniBuXPnMmfOHAYMGMCiRYvw8PBg8eLF9W6jaRphYWGuKTS0jfq9djLnxYTwjxlxALy86ghfbElq9r7ySy18sklV27h7cp9Gb3f5UJXtvVRKnAshzhbOEufHfoWi9Pbp631oWfXjfd+02G731cr0biDoDWiOEufhWg5HM6Wvt+gaFi5cyKhRo/D29iYkJISZM2dy6NChth2EyQObQVUx0spapr2AzWbnx92pWG12fpBrLiGEEEIIIYToMCTo3dGMvRtuWwlj/tiszfU6Df+wnlTZdeisFSq7ur1UWeDzmyB1h7pD/+ZvwCcc+l8GfS8EW6XKnj7bS0Tu+RJO/K4eH/lJBfKFaAUWi4Vt27YxdepU1zKdTsfUqVPZsGFDvdsVFxfTo0cPoqKimDFjBvv27at33YqKCgoLC2tNotoNY7pzz3mqFPmCb/aw9nBWs/bzwYZESixWYsO8mRwT3OjtLhusgt4bEnLILJRMQiHEWcA/Wt2MabfB3iWuvt7JbRX0LkqHlG3Vz+N/gbL8M95tcUUVCdkl1ZneDZU3B/BR5+dwLZcjEvQWXcTatWu555572LhxIz/99BOVlZVceOGFlJSUtO1AHCXOParyqaiynvHuDqYXUVheBcBvR7PPeH9CCCGEEEIIIdqGBL07Gp0euo9Rpc6bqX9kAOk4Sum2cV9vV49Dmw2+/SMkrAGjJ9z4JQQ5sh01DS56BgxucGwt7P26TcfYJOWFsPKvjieaKqt5eEW7Dkl0XtnZ2Vit1lMytUNDQ0lPr7vcdUxMDIsXL+a7777jo48+wmazcc4555CcnFzn+gsXLsTX19c1RUVFtfj76OgeujCGK4ZFYrXZufujbexLbVr/2FJLFe+uPwbAXZN7o2lao7eNCvBgeHc/7Hb4YXdak44rhBCtxpntvecLIh3lzVPy2yjo7SxnHjnS0V/c0iIlzg+kFQJ2uuscNzc1VN4cVHseIEzL5Wim3AApuobly5dz6623MnDgQIYMGcJ7773HiRMn2LZt2+k3bkGapypxHqAVUVBWecb723Qsx/X4YHoRmUVyo6EQQgghhBBCdAQS9O6C4iJ9SLKFqCdt1Nc7p7iCc//9Cze9s4mqKiusWKCC2ToDzPqwule5U0BPmPCgerziUShvWlCpzaz9t8qWD+gN4+5Ry1qwrKYQZ2rcuHHMnj2boUOHMmnSJJYsWUJwcDBvvPFGnesvWLCAgoIC15SU1PwS3p2Vpmn8+6rBjOsVSInFym3vbSG1EcEdu93Oyn3pXPryb+SVVtI9wINLBoU3+fiXD5ES50KIs8zAK0DTQ+oOYowqMzq5rXp6OwPcMRfBgJnq8f5vz3i3e1MK8KMYLxzvw697wxs4Mr0jpLy56MIKCtS/2QICAtr0uJqjr7cfxRSUnnnQe/Ox3FrPfz+aU8+aQgghhBBCCCHOJhL07oIGRviSbA8CwJ7XNkHv19fEk5xXxvqjOWz5+G+waZF6YeYi6DOl7o3G36+CycUZsPrpNhlnk2Tsh42vq8cXPQODZ6nHUuJctJKgoCD0ej0ZGbXbEmRkZBAWFtaofRiNRoYNG8bRo0frfN1sNuPj41NrEqcyGXQsunkE/UK9yCis4NZ3NzeYWbQ3pYDr39rInR9uIyG7hEBPE/+6chAGfdP/DF8yOAKdBjuT8jmR00ZBJSGEaIhnEPQ+H4AB2ariTZuUN68oVlWDAGIvgYEz1eMWKHG+N6Wwup+3VyiYPBreoEam9+GM4urqRkJ0ETabjQceeIDx48cTFxdX5zqt1kbHUd48QCsi/wwzve12uyvoPbKHPyAlzoUQQgghhBCio5CgdxfUL9SbVE1lepdmJrT68dILyvlgowquX6tfzbhjr6kXpv8LBl9T/4YGM1zynHq8+U1I29XKI20Cux2W/RnsVoi9FPpOhbBBKkgvJc5FKzGZTIwYMYJVq1a5ltlsNlatWsW4ceMatQ+r1cqePXsID296hrGozdfdyLtzRhPibeZwRjF3fbQNS5Wt1jrpBeU89OUuLnv1NzYm5GIy6Lh7cm/W/Hky5/QJatZxg73NnNNbbfv9bsn2FkKcJQZfC0Bo4veAnfSCcqqstoa3OVMJq9V1l3+0Km0e0r/FSpzvSy1ofD9vAF8V9A7XcikoqyS72HJGxxeio7nnnnvYu3cvn332Wb3rtFobHUemt79WdMaZ3vFZxeSUWDAbdNx9Xm8AfjuSLTeyCCGEEEIIIUQHIEHvLshk0FHlo35gKMs61urHe3X1ESxVNu4KO8S/jO8A8IXb1VSO+sPpN+59Pgy8Euw2+GG+6gV+Ntj7NST+BgZ3mL5QLdO06gwjKXEuWsn8+fN56623eP/99zlw4AB33XUXJSUlzJkzB4DZs2ezYMEC1/pPPvkkK1euJCEhge3bt3PTTTeRmJjIHXfc0V5voVOJ9HNn8a2j8DTp+T0+h0e+3o3dbqfUUsWLPx3mvOfW8NW2ZOx2VZb8lwcn8fD0WLzdjGd0XFeJ850S9BZCnCViLgajB4b8BIbpj1Fls5NRVNG6xzy4zHHsS9R1GKhS63BGJc7LK60cySwmyhn0Pl0/b3BlegdpBRipkhLnokuZN28eP/zwA6tXr6Zbt271rtdqbXScQW/OPNN7Y4LK8h7e3Z9zegdhMuhILywnPqvkjIcphBBCCCGEEKJ1Gdp7AKJ9eIT0hmNgKDjRqsdJyi3l8y1JXKDbyp+LXkOHjW85j4fzryBtdTz3T+17+p1Me1qVDE/ZCtvfh5FzWnXMp1VRBCseU48nPFi7x+PAK2Dd89Ulzs3e7TNG0WnNmjWLrKwsHn/8cdLT0xk6dCjLly8nNDQUgBMnTqDTVd/PlJeXx9y5c0lPT8ff358RI0bw+++/M2DAgPZ6C51OXKQv/71pBLe9t4UlO1KosNrYejyXjEIV7BnRw5+/XtKfYd39W+yY0+LC+Ou3ezmUUcSh9CJiwuRcI4RoZ2YvFfje+xU3uG9kR3EvUvLKiPRzP6PdFpRWsj4+mzKLFb1OQ9NAp2noNRtTDyzDBGxzG0vBwQwGhPsSNmAmrFkIR1epEufufk0+5qH0Iqw2O33cc8BO4zK9PQJBb0ZnrSBUy+NoZhHjegc2+dhCdCR2u517772Xb775hjVr1tCzZ88G1zebzZjN5pYfiIcqb+6vFZFWemZVFjY5SpuP6RWAm1HPqGh/1h/N4bcjWfQJ8TrjoQohhBBCCCGEaD0S9O6igqP6wjHwqkgHmxV0+lY5zn9WHeFqfuafpnfRWW0Qeyn6mIXw+R5e+eUIUweEMDDCt+Gd+ITD+Y/B8kfg5/+D/pep3pHtZc2/oDgdAnrBOffWfi00TpU4z42HQ8sbLt8uRDPNmzePefPm1fnamjVraj1/8cUXefHFF9tgVF3bpH7BPH1FHH/5eg8/7k4DICrAnUem9+fiQWFozgzEFuLrbmRSTDA/7c9g6a4U/hwW26L7F0KIZhl0Dez9igts69FxHcl5pYzuGdDk3RRXVPHz/gy+35XKr0eyqLSeWlZ4lHaQi8355Ns9uXY5WNlKoKeJn+dPwj+4P2QdUCXOh17f5OPvTS0AIMacA+WAfyMyvTUNfCIg7xhh5HBEMr1FF3DPPffwySef8N133+Ht7U16ejoAvr6+uLuf2Q0vTeLI9A6gmENnkOmt+nnnALjOXef2CVZB76M53Dq+4aC+EEIIIYQQQoj2JeXNu6iePftQZHfHgBX76qdb5RjxmUV02/UfFhrfQYcNht0M17zPpUOjuCgujCqbnQe/2HVKD9w6jZoLoYOgPB9+erxVxtsomQdh0yL1+KJnwOhW+/WaJc7PoKymEKLjmTWqOwsuiqV7gAePXhzLz/Mnccng8BYPeDu5SpzvSqW80toqxxBCiCbpMwXcA/Cz5XGObh8peWWN3rTMYmXZnjTu+mgbI/7xEw98vpNVBzOptNrpG+LFxH7BnNsniHN6BzK2VwCz/fcBsNNtNHFRgQR4msgpsfDMioNn3G5mb0ohAJE0oac3uEqcR2i5Ut5cdAmvv/46BQUFTJ48mfDwcNf0+eeft+1AamR6n0l588ScUjIKKzDpdQx3VOg5t4+62XpjQg6V1ua12tqVlE9KfuPPh0IIIYQQQgghmkcyvbuo/pF+/MN6MwsNb6Kte45DpV70u/SBlgvO2KykffxHHjD8oJ5PfBjOexQ0DQ34x8w4Nh3L5WB6Ea/+coT5F8Y0vD+9AS59Ad65AHZ+DMNugh7ntMxYG8tuh2UPga1K9Y7se0Hd69UscV5eCG4+bTtOIUS7+cOk3vxhUu82OdbU/qF4mPQk5ZYx7MmfmNQvmAsGhHJ+bAj+nqY2GYMQQtSiN6rroK3vMEO3nq15Fze4ekWVlXWHs/l+dyo/7c+g1FJ9A0/PIE8uGxzOpUMi6Bd6UgsHux1euRtKYfLltzJ54Hi2HM/lmkUb+HRzEjddfz4DWQjxvzSrxPm+1AJ02PCryFALGtPTG1SmNxCm5bBBgt6iC7DbT63C0C7cawS9S5sf9N7sKG0+JMoXN6OqhDYwwgc/DyP5pZXsTs5nRI+mVa/Yk1zAFf9dT49AT355cFKr3QwphBBCCCGEEEIyvbssD5OBuMvm8YpNld/uu/XvPPPis6w7knXmP15UllH0wfWcW/ADNrtG2rn/VOXJa/wDP8jLzD9mxAHw2pp49iQXnH6/UaNh+C3q8Y8PgrX5P2g0y74lcHwdGNxg+sL613OWOLdWwOEVbTc+IUSX4m7S88zVg4nwdaOs0sryfek8+OUuRv7zZ65/cyOLfztGUm5pew9TCNHVDFLXltP1W8jMyz/l5fJKKyv3pfOnz3cy8h8/c8cHW/luZyqlFiuRfu78cVJvfrj3XH55cBLzL4w5NeANkH0YchNAb1LZ5cCo6ACuHtENgIfWVGAPjgVbpSpx3gSVVhsH04oIIxedvRJ0Rlcw+7R8VaZ3uJZLVlEFBWcQfBNCNIGjvLk/RRScQU/vjSeVNgfQ6TTG91bZ3uuOZDd5n59sTsRmh2PZJexuzL95hRBCCCGEEEI0m2R6d2E3julBzoBX2f5BFcOzvuGBgme4abGeV3qcw/wL+zG2V2DTd1qaC59ej3fSRirsRj6I+Ctzp9bde/iSweH8b284P+xO48Evd/L9vediNpymt/jU/4MD30PmfnjnQpjyN+h1Xq2AequoKIIVj6nHEx5suLejpjmyvZ9TZTWlr7cQopVcOjiCSwaFsy+1kJX70lm5P4OD6UVsSMhhQ0IOT/6wnwHhPkzpH0Kknzt+Hib8PYz4e5rw8zDi527CZJD734QQLShqDOWekXiXpNA9ex0wkfJKK2sOZbJsTzqrDmRQZSkjWktnvJZOuGcV+iGzuGRoFEOj/BqXBXlomZr3nAjm6qD4goti+Wl/BgfSCtkxYDLDsw6qa7Em9PU+mlmMxWojxk0Fv/CLAt1prk+dHOXNe5ryoQqOZhU1OStUCNEMjqC3SbNSUVrY7N04M73H9Kz97+Bz+wbx45401h/N5oGp/Rq9v5KKKpbuTHU9X7EvnSFRfs0enxBCCCGEEEKIhknQu4sL9HYj8K53qPikHPPR//G26XmuSfTkujdzOad3IA9e2K/xP9YVJMNHV0HWQQrtHsytfJB/XnFHg5s8OSOOjQk5HM4o5j8/H+Hh6bENH8MjAC5/BZbMhdTt8OEV0ONcFfzuPraR77oZ1j4DRWng3xPOue/06w+cqYLeR3+WEudCiFalaRpxkb7ERfoy/8IYTuSUsnJ/Oj/tz2DL8Vz2pxWyP63+H4A9TXr8PEwEeJoY0cOfK4ZFMribr5TfFEI0j06HJfYK3La9ypSy5bz2VgAFSQfoZkvlGi2Nh3XpdHOrkS1pBdz10P3Jxh/joCPoHXNRrcWBXmb+Mj2WR7/Zw/8d7ctSHU0ucb43RWVijvYrgnwa388bXBnhUYZ8AI5kFEvQW4i2YPLAqndDby2H0pxm7SIlv4zkvDL0Oo3hPfxrvebs673jRD7FFVV4mRv3M8qPe9IosVjR6zSsNjvL96bz52kxco0lhBBCCCGEEK3krEjveu2114iOjsbNzY0xY8awefPmRm332WefoWkaM2fObN0BdnY6PeZZ70LUWHy1Er70eo4ofS6/x+dw1esbuGXxZhJzShreR+YBePsCyDpIrj6IayyPEzXsAvqEeDW4WYCniadmDgJg0dp4dibln368/S+F+3fBmLtUWcvE32DxNPjoakjd2bj33BRZh2Djf9Xji/4NRrfTbxMaB4F9pMS5EKLNdQ/04I4Jvfj8D+PY+tcLePbqwVw9ohvnx4YwrLsfPYM88fcwugpklFispOSXsSelgPd+P86M19Yz5YW1vLLqiJRHF2e9plxDvvfee2iaVmtyc6v9N91ut/P4448THh6Ou7s7U6dO5ciRI639Njodj5Eqs3qibjf3pDzCo7r3mW34iQn6vXTTHAFvN18IU9eAbHgNMvY3bufFmZC8RT3ud9EpL183SmWM77aEk2qKdpQ4X9aoXWcXV/DmrwkADHJXGZ+N7ucNrkzvELsKuh2Rvt5CtBmbmwpU68tzm7X9pgT1vY2L9D0lqB0V4EGPQA+qbHbXeo3x+ZYkAO6c2AuTXkdCdglH5bwghBBCCCGEEK2m3YPen3/+OfPnz+eJJ55g+/btDBkyhGnTppGZmdngdsePH+ehhx5iwoQJbTTSTs7oDtd/CkEx+FZm8Uvof5gzzBe9TmPt4Swu/s86vtiadGq/74JklQW9eBoUpVLq24dLSx4nXuvB/VP6NurQ0+PCmDE0ApsdHvxiJ+WV1tqHKKtkY0IO764/xsNf7eLSV9Yx5uXdLI+6H+7bofp8a3o4+hO8OQk+vxkyD7bM51JeAEvuBFuV+mG137TGbadpMGCmerzvm6Yd89ivsOtzONPe6kKILi/A08Q1I6N47pohLL51FN/cPZ7VD01mx+MXEv/Pi9n5+AWsfmgyS+4+h//eOJzLh0TgZtSRkFXC8z8dZsIzq7n69d/5eFMi+WfQI1OI1tCca0gfHx/S0tJcU2JiYq3Xn3nmGV5++WUWLVrEpk2b8PT0ZNq0aZSXl7f22+lUDOFxHPCdRDlmMjz6kB99EfZz58OM/8JtK+HPCfCXRPjjbxBzibrO+vHBxl37HF4O2CF8qKuHdk06ncZTM+PQafB5yQi1cN+3p91tTnEFN7y1kSOZxYT6mBnm46iQ0aRMbzUer8ocjFRJcEuItuQscW7Jw2Zr+r+jqkub112dYXyfpvX1PppZxLbEPPQ6jVvPiWZ8HzW+FfvSmzw2IYQQQgghhBCN0+7lzV944QXmzp3LnDlzAFi0aBE//vgjixcv5pFHHqlzG6vVyo033sjf//531q1bR35+fhuOuBPzCICbvoZ3LsSYe4QnPP/Brfd9zJ+/O8LmY7k8/NVuVh/M5OnL+uGf/DNs/1CVjET9qGDvNpp7LH8mlUpuHBVFVIBHow/9f5cN5Pf4HOKzSliwZA9RAR7sTy3kQFohKflldW5z76c7eGv2SCZf/jKMvx/W/Av2fAkHlsLBH2DQtarsuW+35n0eFUUqezxtJ7j7w0X/atr2zr7eTSlxnrBWlWy3W+HISpjxWuMyy4UQool0Og0/DxN+HiZ64gnAxYPCKa6oYsXedL7ZkcL6+Gy2JuaxNTGP/1u6j/NiQrhudBTnxYRIaU7R7ppzDalpGmFhYXW+Zrfbeemll/jrX//KjBkzAPjggw8IDQ3l22+/5brrrmudN9JJ9f/TUrDbcTvdueKif0PCajjxO+z8BIbd2PD6h/6n5rGX1LtKXKQvt5wTzY+/j+FPfI09/he0Bkqc5xRXcOPbmzicUUyIt5nP7hyH57f/Vi/6NyHT2yMQ9CY0q4UQ8jia6X36bYQQLULnFQhZ4GsvpqiiCl93Y5O233SaoPeEPkF8sukE6482LujtzPI+LyaYUB83pg0MY/WhLJbvS2fe+Y27OVwIIYQQQgghRNO0a6a3xWJh27ZtTJ061bVMp9MxdepUNmzYUO92Tz75JCEhIdx+++1tMcyuxS9KBb7NvpC0kR6r7+PT20fy8PQYBupPMOrgM2gv9ocvb4X4VYAdoifAFW+wbvx7rD5Ricmg494m/kPe39PE01eoEpff7Ejh5VVH+PlAhivgHennztT+Idx3fh9ev3E4lwwOp9Jq548fbVMl5gJ7w1VvwV2/Q+ylYLfB7s/gjYlwfH3TPwdLCXx8LSRvVuU3Z3/XtEwfgNCBNUqcLz/9+vkn4Ks5KuANsPcr+GAGlDSvL50QQjSHl9nAVSO68dEdY9jwyBQevTiW/uE+VFrtrNyfwW3vbeXaNzaw40Reew9VdGHNvYYsLi6mR48eREVFMWPGDPbt2+d67dixY6Snp9fap6+vL2PGjKl3nxUVFRQWFtaaRA2NuTnGLwomO25SWPlXKG2gNLGlFOJXq8cxp5Y2r2n+Bf0o9OrNIVs3tAZKnOeWWLjx7U0cTC8ixNvMp3eOpWeQJ+Q7qgA05fpPp3P19Q7TcknJL6Okoqrx2wshmk3vyPQO0IooLKts0raZheUcyy5B02BkdN1B73G9A9E01bYgvaDh6h+WKhtLtqcAMGtUdwCmDghFp8HelEKS86R9jBBCCCGEEEK0hnYNemdnZ2O1WgkNDa21PDQ0lPT0ust+/fbbb7zzzju89dZbjTqG/BjZDKED4PpPQG+GQz+i/+Jm7j58Bz8aH+E2w3L8KCLNHsBv4bdScfc2uPUH7INn8dyqYwDcPLYHYb5Nz06+YEAo953fhyHdfLlmRDcev3QAn84dy67HL2T9I+fz9i2jmH9hDBcNCufFa4dyfmwI5ZU2bn9/K7uT86vHft3HMHc1hA+B0hwVON7+QeMHYimFT2apjCOzD9z8rdpXU2mayvaG05fVrCyDz29S4w0fAjd86brxgLenQPbRph9fCCHOUJivG3dO7M3/7p/A8gcmcMe5PTEbdGw5nscV//2dez7ZTmJOSXsPU3RBzbmGjImJYfHixXz33Xd89NFH2Gw2zjnnHJKTkwFc2zVlnwsXLsTX19c1RUVFnelb65rG3g0hA6AsF35+ov71EtZAVRn4dofQuAZ36e1m5G+XDuBH61gASnd8fco6eTUC3sHeZj6ZO5bewV7qWrA4Q63UlJ7e4CpxHuOu/s0RnyUlzoVoE46gt79WRH5p04Lezizv/mE+9WaI+3mYGBzpC3DabO9VBzLIKbEQ4m3mvJhgAIK8zIxyBNRX7Mto0viEEEIIIYQQQjROu/f0boqioiJuvvlm3nrrLYKCghq1jfwY2UzR56rMaTQ4/D9I3QE6I1Uxl/F+z2cZX/EyNx27kBmfpHIovYiV+zPYnVyAh0nPXZN7N/uw8y+M4bt55/LsNUO47dyejOsdiK/HqT88mAw6/nvjcMb2CqC4oorZizdzOKOoeoXI4TBnuQo62yph6b2wfAFYT5NtU1kOn90Ax9eByRtuWqL21VzOvt7OEud1sdvhhz9B2i71Y82sj6DfhXDHT+DXHfKOwTtTm5exLoQQLSQ2zIe/XjqANX+ezNUjuqFp8OPuNKa+sJa/f7+PvBLp+S3ObuPGjWP27NkMHTqUSZMmsWTJEoKDg3njjTeavc8FCxZQUFDgmpKSklpwxF2I3giXvKAeb/8ATmyqe71DP6p57MWNyiK/dHA4GVHTATAlrsFeVl2hIr9UBbwPpBUS5GXm07lj6BPi5XjxhJqbfVWLm6ZwZHoP8FLXpUcyJOgtRJtwBr0pIr+sadckrn7everO8nZy9vX+7TRB788cpc2vGtENg776J5dpA1V7jRV7pa+3EEIIIYQQQrSGdg16BwUFodfryciofadzRkZGnf0W4+PjOX78OJdddhkGgwGDwcAHH3zA0qVLMRgMxMfHn7KN/Bh5BgbMgJmvq/Ll056GBw9iuP4jbrnlTt6cPZpATxMH04u47NXfePy7vQDMGR9NkJe5TYbnZtTz9i2jGBLlR35pJTe9val2xqHJA65+F857TD3f+F/4dBaUF9S9w6oK+OJm1VfS6Ak3fglRo85skKEDIbBvwyXON78Fuz4FTQ/XvKcC3QDBMXDHLxA5EsryVMb6rs/PbDxCCHGGwn3dee6aIfx47wQm9A2i0mrn3fXHmfjsahatjae80treQxRdQFOvIetiNBoZNmwYR4+qairO7ZqyT7PZjI+PT61JNFOPcTD0JvX4x/mn3qhos8Ihx7XUaUqbO2maxh+uuohD9igMVLF71adAdcB7f1ohQV4mR8C7Rv/tvONq7t+9cSXaa3IEvXuZ1PXmUcn0FqJteKiAtb9WREETy5tvOqbaSdXXz9vp3L7VQW+73V7nOqn5Zfx6JAuAa0fWvuF+Wpz6W7IlMZesooomjVEIIYQQQgghxOm1a9DbZDIxYsQIVq1a5Vpms9lYtWoV48aNO2X92NhY9uzZw86dO13T5ZdfznnnncfOnTvrzOKWHyPP0NDr4dYfYNw94FmdXT91QCjLH5jIeTHBWKpsZBRW4O1m4M4Jzc/ybg4vs4H354wiNsybzKIKbnx7E2kFZdUraBpMehiueR8M7irj+u2pkHPSDRJVFtWn/MhKtd6NX6gfX8+UpsHAmerxvm9Off34elixQD2+4EnoOfGkNxisPv8BM1TG+jd3wpp/qexwIYRoRwMifPjw9jF8cNtoYsO8KSqv4l//O8iU59eyZHsylVZbew9RdGJNvYasi9VqZc+ePYSHhwPQs2dPwsLCau2zsLCQTZs2NXqf4gxd8KTKrM7YC5sW1X4teSuUZqvs6x7jG73LXsFe5HRXQfLibV+Sml/Gze9sZl9qIYGeJj6dO5a+od61N2pOP28nn24AROpU5qhkegvRRpw9vSluUnnz3BILhx3f09E9Axtcd0QPf9yMOrKKKjiSWfd3+8utydjtMLZXAD2DPGu9FunnzqBIX+x2+PmAlDgXQgghhBBCiJbW7uXN58+fz1tvvcX777/PgQMHuOuuuygpKWHOnDkAzJ49mwULVFDQzc2NuLi4WpOfnx/e3t7ExcVhMpna8610OcHeZhbfOop/zBhIj0APnrhsYJ2lyFubn4eJD24fTXSgB8l5Zdz09iZyik+6c37gTLhtueqzmH0Y3jofEtaq16yV8PXtcGgZGNzghs9UefeW4ipxvqp2ifOCFPjyFrBVQdzV6saCuhjd4er3YPz96vmahfDNH1VmuhBCtLOJ/YL58b4JPHv1YMJ83EjJL2P+F7sY/69feOGnw7VvRBKiBTXlGhLgySefZOXKlSQkJLB9+3ZuuukmEhMTueOOOwCVFfzAAw/w1FNPsXTpUvbs2cPs2bOJiIhg5syZ7fEWux7PQJj6d/V4zUJ1reTkLG3e9wJVDr0JRlys/p8YZdvFlS/8yJ6UAgI9TXxSV8AbqjO9m9rPG1yZ3gFWVf74aGZRQ2u3ufVHs/l4UyKWKrkxSXQyzcz0dpY27xfqRYBnw78nmA16V2B83ZFTS5zbbHa+2Koqy80aVXdbtemObO8V+6TEuRBCCCGEEEK0tHYPes+aNYvnnnuOxx9/nKFDh7Jz506WL19OaGgoACdOnCAtLa2dRynqo2kaN4+LZu2fz+PqEd3abRwh3m58dMcYInzdiM8qYfbizaf+2BExFOY6yoWX58OHV6jS4t/8AQ4sBb0JrvsYek1u8vEtVTYSc0rqLnNXV4lzZyn1kiwIHQSXv9Jw+UydTmU/XfqSKoO++zM1/iM/gaW0yeMVQoiWpNdpXDMyitUPTebP02II8jKRWVTBy6uOcO6/V3PnB1v59XAWNptUqRAtp6nXkHl5ecydO5f+/ftz8cUXU1hYyO+//86AAQNc6zz88MPce++93HnnnYwaNYri4mKWL1+Om5tbm7+/LmvYzRA1BizFsPyR6uWH/qfmsRc3eZfm8AEU+/bDpFk517qZAE8TH88dQ0xYHQFvgLwzyfRWQW+PCpXFeSK3lG2JuU3fTyv4flcqN7+zice+2ctlr/zGrqT89h6SEC3HvXlBb2dp89GnKW3udG4fFfReX0df7/Xx2aTkl+HtZuCiuPA6t3f29V5/NJvC8qaVYRdCCCGEEEII0TDNXl8zqk6qsLAQX19fCgoKpNR5J5SQVcy1b2wgu9jCiB7+PH/NEIwGHXpNQ6epIL3OWo73yvmY9n9VvaHOCLM+gpjpjTpOZmE520/ksf1EPtsT89iTUkBFlY07zu3JXy8dcOoGvzwFvz4LMRfDdZ/A0nthx4eqhOeda5r2o+rRVfDFLWBxZA7pzdDjHOgzBXpPgZD+Te8/2YHJd7p1yecrmsNSZWP5vnQ+2pjoyqACiA704MYxPbh6RDf8T5NNJVqHfKdbl3y+LSR9L7wxEexWuPEr8O8Jr45Q12sPx4Obb9P3uebfsOZpNhtG4n37N/QPb+C/z+vjVYn1G79SmeVNUZwJz/XFjsatkT+yNj4fN6OOV64fzgUDQps+7haycl86d328HavNjkmvw2K1odNg7oRe/OmCfrgZ9e02trOZfKdbV4t+vvlJ8FIcFruev8b9wjPXDG3UZpe8vI59qYW8cv0wLhsScdr196cWcvHL6/Aw6dn5+IWYDNV5BPd8sp0fd6cxe1wPnpwRV+8+pjy/hvisEv5z3VBmDI1s1DiF6AjknCmEEEIIIdqbob0HIERL6hXsxYe3j2HWGxvYlpjH5OfW1LPmFdylN/Bnw+dY0fEIf+LgCk9Cft9MqI8bId5mQmrM7XY7O5PyXUHulPy6y/W+/dsxxvcN4ryYkNovDLxCBb2P/gy/v6wC3poOrnqn6VlEfabA3FWw4TWI/wUKkiBhtZr4K3hHQJ/zVQC812RXqT8hhGgrJoOOy4dEcPmQCA5nFPHxxkSWbE/heE4p/1x2gGdXHuLSweFMiQ1lRA9/wnwli1YIUUNYHIy9Cza8CssegqE3quXR5zYv4A2q1c2apxlt2wWF6yF0mqqkczK7/czKm3sEgc6IZqtk0cxI7v7ByOpDWfzhw63884pBXD+6e7OGb7PZ0emad1PjmkOZzPtkB1abnZlDI/jrpQN46of9fLszlTd+TWDl/gz+fdXgRme6CnFWcvT0NmlWyksKGrVJQVkl+9NU+6kxjfz/PzbMm0BPEzklFnYm5bu+N7klFn7apyo8XDuy7tLmTtPjwnhtdTwr9qVL0FsIIYQQQgghWpAEvUWn0z/ch/duG81DX+wiraAcq92O3W7HZgerq7SuxuvWy/nVNhgrOg7au0NpIfsaeQydBv1CvRnW3Z/h3f0Y3sOfDzck8t7vx/nzl7v43/0TCfY2V28QMkCVOM85Aj89rpZNeVwFsJsjOAYuf1n9MJt9RAXT41fB8d+gKBV2fKQmTQfhQ6DnJOg5EbqPA5NH449js6r9p25XfTU1DXR6VWJdp1f71/TqR2NNDzqD6rOpN6psLL0J9AbH3ORYZqyxD0ONbfUnzXXg5telstaF6Iz6hXrz9xlxPDw9lqW7UvloYyL7UgtZsj2FJdtVv95IP3eG9/BnRHc/RvQIIDbcG6O+3TuwCCHa0+QFsO8bFYBe+2+1LKbppc1dgmOg2yhI3gKfXqeyx0ffCcNurB1IL81VpdUB/JoRoNbpwCcc8k/gXpbBm7NH8eiSPXy5LZkFS/aQUVjO/VP6ojXy+ia7uIKXfj7Ml1uTuXhQOI9fOqBJlTJ+P5rNHz7chsVq4+JBYTx3zRAMeh0vXaeyWh/9Zg/Hsku49o0N3DKuBw9Pj8XTLP9EFB2QyQOr3g29tZzivEzsdvtpv2fbEnOx26FnkCchPo27AU+n0xjfJ4ilu1L57UiWK+j9zY4ULFYbcZE+xEU2fHPOtIEq6L36YBbllVaptCCEEEIIIYQQLUR+0RCd0vDu/vzy0OQ6X3MGwG12O1abnaLyKjIKy8kqqiCjsJzMGvNMx7zSamNQpC/Du/szvIc/Q6L88DrpB8FHLoplQ3wOhzKKePirXSy+dVT1Dy2a5sj2fkY9HzADxj9w5m9U0yC4n5rG3Q2V5XDid1UC/egqyDoAqTvUtP4lFXSOGl0dBI8cAQaT84OB/ERI2a6C3Ck7IG1n9Q+/7eEvieDu137HF0K0GE+zgetHd+e6UVHsTMrnmx0pbD2ex8H0QlLyy0jJL+P7XakAuBv1DInyZUQPf86LCWFED/9GB4iEEJ2E2Qum/wu+uBlsVWpZzEVnts/rPlUVd7a/D3nHYMUCWP1PGHoDjP4DBPWpzvL2DgdjM6tQ+HSD/BNQmIKx+xieuXowoT5uvLr6KC/9fISMwgr+MWMghgZu7imvtPLu+uP8d/VRiirU+/9mRwrrjmTxjxlxXDSo7n7BNW05nsvt72+losrG1P4h/Oe6YbWOOaV/KCujA1i47ACfbUni/Q2J/Hwgk39dNYgJfYOb996FaEd2d38oTiM7M40XfjrMgxfGNLj+pgTVgmV0dNOqHJzrDHofzWb+hTHY7Xa+2JIEwKzTZHkDDIr0JcLXjdSCctYdyW7X1gdCCCGEEEII0ZlI0Ft0OZqmoddAj4ZRD25Gfe2s7GZyM+r5z/VDufzV9aw+lMUHGxK55Zzo6hUGz4L1/4GgfjDjv62TwWx0g97nq2naP6EwFY79Cglr4dhaKEyBxPVqWvM0GD2hxzgV8E7dAWW5dezTQ2WLB/ZRz+02lQFut1bP7Taw2dSP0rZKsDoni5rbajy2Wmpsb6u9H+fcSSdZD0J0NpqmMay7P8O6+wNQXFHF7qR8tiXmse1EHtsT8ygsr2JjQi4bE3J5bXU8vYI9mTUyiiuHd2uR87UQooPofxn0vRCOrISwQeB3+mBSg7yC4cJ/wORHYPfnsOkNyDoIm99UU98Lq693mtp+piYfR1/gQlXNQtM0HpoWQ6iPmceX7uPTzSfILq7gleuHnZLhabfb+WF3Gv/630FXO51Bkb7MHteDN39N4EhmMXd9vJ2LB4Xx98vj6j0n7kzKZ867WyirtDKhbxCv3jC8zgoavu5G/nXVYC4dHMEjS3aTnFfGze9s5tqR3Xj04v74eTQ+q1yI9mbwCoLiNAK0Il755ShRAR4NlhrfeEz922dMr6YFvcf3DQJgV3IBheWVxGcWcyijCLNBx+WNKFeuaRoXDgzjvd+Ps3xvugS9hRBCCCGEEKKFSNBbiBYUG+bDgoti+fv3+/nnsgOM7RVITJi3ejGoD/xpL5h9mp851FQ+ETDkOjXZ7ZCboILfx35VU2mOKo3upDOqPpoRwyFyuJoHx7R98NkZDNfJKUqIzs7LbOCcPkGc00f9gGyz2YnPKmZbYh6bjuWyYl86CVklLPzfQZ5dcYjzY0O4bnQUE/sGN5glKYToBDQNLvsPrPwbDL+55fZr8oSRt8GIOZCwWgW/D69QwfUjK9U6zenn7eQKeqfWWnzzuGiCvc3c99lOftqfwY1vb+KdW0a6AsvbT+Txjx/2s+NEPgBhPm48PD2GmUMj0ek0Lh8awau/HOW/a+JZtiedDfE5/N/lA7l8SEStahj7UguY/c4miiuqGNsrgDdvHlkdXE/eqrLQB15R6wbMc/sGseKBiTy74hDvbzjOF1uT+Wl/Bn+ZHsu1I6Oa3U9ciDbl6Ot9zQAP1uyFR5fsIdLPnfGOa4yaSiqq2Juien+P6RXYpMNE+rnTK8iThOwSNsbn8MvBTAAuGRSOr7uxUfuYHqeC3j8fyKDSapO2LkIIIYQQQgjRAiSiJEQLu/WcaNYezmLNoSzu+3QH380bX/1Do1dI+w1M0yCwt5pG3qYCy5n7Vda3plNB7tA4MJwFWZQ6HSA//AjRFel0Gn1Dvekb6s11o7tTXFHFD7tS+XxrEjtO5LNyfwYr92cQ6mPmmhFRXDsyiu6BHu09bCFEa/GJgKvfaZ19a1p1hZyceJXtveNjsBRBt5HN369vNzV3ZHrXND0unI9uN3PH+1vYlpjHVa//zsIrB/PhxkRXiwcPk54/TurN3Am9cDdV33hoNuh58MIYpg0M489f7eZAWiH3f7aT73el8s8rBhHq48bhjCJufmczheVVDO/uxzu3jKrex56vYMmd6sbCIyvhsper29yg2lD83+UDuWRwOI99s4fDGcU8smQPn21J4h8z4hjUreE+xUK0O3eVsX1RLxOX6SP4flcqf/xoG0vuOoe+od61Vt2WmIfVZifSz51IP/cmH+rcvkEkZJewYl8Gy/emAXDtqMZXoxgVHUCgp4mcEgubj+XWGZgXQgghhBBCCNE0ElUSooVpmsazVw8hyMvEoYwi/r38YHsPqW46ncrqHvMHGD3X0d/7LAh4CyFEDV5mA9eN7s43d49n5Z8mcvu5PfH3MJJRWMGrq48y8dnV3Pj2Rn45mIHNZm/v4QohOqrA3nDRv2H+frj9Z3WDYHM5M70LTg16A4zuGcCXfzyHMB834rNKuPaNDXy/KxVNU/2A1zw0mfum9K0V8K4pLtKXpfPGM/+Cfhj1Gj8fyGTqC2t589d4bnx7E7klFgZ38+W920bjaXbc47z9Q/j6juo2Mrs+hU+ugfKCU/Y/KjqAH++bwF8v6Y+X2cDOpHwuf+03HvtmD/mlluZ/LkK0Nkemt64sl2evHszIHv4UlVdx67tbyCwqr7Xq5maWNndyBqmX7EimxGIlOtCDMT0bvy+9TmNqf1XWfPne9GaNQQghhBBCCCFEbRL0FqIVBHubefbqIQC8u/44aw5ltvOIhBCi4+sX6s3fLh3Axken8NoNw5nYLxhNg/VHc7jtva1c8OJaPt18gvJKa3sPVQjRUbn5QNSoM2vtUk9585piwrxZcvc59A3xAuCc3oH8cO+5/PvqwYT4nL4NjlGv474pffnh3gkM6eZLUXkVTy87SFZRBbFh3nxw22h83Bxllje9AUvnAXYVzL/hSzB6QsIaePfiOoPzRr2OOyb04pcHJzFzaAR2O3y86QTnPbeGzzafkJuMxNnJEfSmLBc3o543Z48kOtCDlPwy5r6/lTJL9fXBpmM5AE0KVNc0rncgOk11kAKYNap7rTYDjTE9LgyAlfvT5TslhBBCCCGEEC1Agt5CtJLzYkO4ZZzqB/nQl7vJLq5ocP2Siio+3XyCma+tZ8arv7F8bzp2u/z4IYQQJzMb9FwyOJwPbhvNuofP486JvfA2G4jPKmHBkj2M/9cvvPTzYXJOc94VQohW4eMob16cDtaqeleL8HPn+3vPZcUDE/n4jjEMjGh6+fCYMG++vuscFlwUi9mgIybUm4/uGOPqE8665+F/D6vH4+bBJS9AvwthzjLwCoWMvfD2VMjYV+f+Q3zceOm6YXx251j6hXqRV1rJI0v2cOXrv7Mn+dQscSHalYcjgF2qAtoBnibenTMafw8ju5ILuP+zHVhtdsorrexKcvTz7tlAP+8G/i3m42ZkSJQfoLK2rxoR2eThntMnEC+zgYzCCnYm5zd5eyGEEEIIIYQQtWn2LhZVKywsxNfXl4KCAnx8fNp7OKKTK6+0MuPV9RzKKOK8mGAW3zrqlAyA/amFfLI5kW93pFJcUfuH0dE9A/jbJQOkh2ID5DvduuTzFR1FUXkln29J4t31x0nJLwPAbNBx5fBu3DGhJ72Dvdp5hGcH+U63Lvl8BQA2GzwVDLYq+NO+6h7fraykogqzQYdBr1PBul/+oYLeAJP+ApMXqD7mTnmJ8PE1kH0IzD4w60PoNbne/Vdabbz/+3Fe+vkIxRVVaBr0D/OhR6AHPQI91TzAg+6BHoR7m9Cn74KEX1QJdTc/cPdTc9dj3+rHemMrfSpnRr7TravFP989X8HXt4O7P/S/HLqNhMgRbCkJ4cZ3tmKx2rj93J5M7R/K9W9tJMTbzKZHp6h/n1VVQNpuSN4MyVsgeSsUpUFIfwgfChFDIWIYhAwEo6rG8J+fj/Diz4e5cEAob84eWT2OKgvkJkDWAcg6BNmHwegOQTEQ1A+C+4FfD9DpuffTHXy/K5U/TOzFgov7n/lnIEQ7knOmEEIIIYRobxL0FqKVHUwv5PJX12OpsvHkjIHMHhdNeaWVH3an8fGmRHacyHet2yvIkxvGdKegrJK31iVQXmkD4MphkTw0LYYIP/dGHdNut3Mks5gdJ/IYGOFLXGTnDZrLd7p1yecrOpoqq41le9N5e10Cu2tkIU7sF0zvYE8CPEz4e5oI8DTh7+GYexrx9zBh1Hf+AjjynW5d8vkKlxcHQcEJuP0niBrdtse222H5Atj0uno+9e9w7gN1r1uWB5/dCInrQWeEGa/CkOsa3H1mYTlPLzvAtztrl28PJo9J+t1M1O1mgm4P/lpx48ds9HQEwWtMrsC4YzL7gNFDBRwNNSajGxjcwWBWgUWtjnN5XWWnzb6ga/i8L9/p1tXin2/WYVh0LlhPqvRi9CTbpz9fZ4Syy9aboqAhxGeWMLdnNnN6ZKsgd9ousDaiZ73OACEDIGIolpAhrMjyZ1K4FZ+io5B1UAW5c46qm14aojdDYB9SjVF8mehBgWdP/nb9FLS6/v+tdXw9eAaBVxiYPE4/3pZks4KlGCwlaqooUnNrBXiGqBt83P3r/r6JLkHOmUIIIYQQor1J0FuINvDu+mP8/fv9mA06rh7Rje93pVJYrn4IMeg0psWFceOY7ozrFejKBE/NL+O5FYdYskP1WTQbdNw5sRd/nNQbT7PhlGOUWaxsSMjml4OZrD6Y5cp0BBjSzZfrR3fnsiERdW7bkcl3unXJ5ys6KrvdzuZjuby17hirDmY0VKHUxdvNQKAjIB7oZSbIy/HY00ygV/W8e4BHhz2Xyne6dcnnK1wWT4cTG+Ca92DgFfWvl3kQUndAz4ng2/TyyKewWeGHB2D7B+r5xc/B6LkNb1NVAd/eBXu/Vs/P/ytMeOi0gasTmXlk7VuL8fhqQjJ+I6z8aK3XC+3urLfFkWwPxodSAvQldHOvJMRYhg8lGCyFaBWFzXyjLeDBQ+Ad1uAq8p1uXa3y+RZnQtImSNmmsrVTd6hAbWN4BEG3URA1Ss19u6nS/6k7IHWnmpflNm5fJi8IjoHgWJXdXVmmqipkH1HTyYH55jD7qDYF3mE15iEqAG2tgLJ8KM+vf26tUjd+aDrQ9Cqg7ppr6rHdVh3kriqrfyxOBnfwiVDnM59ujnmk+iyNNYL0rvOLVvu5plM3FugMqgKEzqjG43psAL2hep2a420uu90x2dREjcd2mxqj83hneqxOTs6ZQgghhBCivUnQW4g2YLfbufXdLaw9nOVa1s3fnRvGdOeaEVEEe5vr3XZ3cj5P/XiAzcfUDyzB3mYevKAf14yMIjW/jNWHMvnlYCYb4nOoqLK5tjMZdAyM8GFvSgGVVvU19zIbmDE0ghvGdG9W38izUVf8Tr/22ms8++yzpKenM2TIEF555RVGjz59Ftlnn33G9ddfz4wZM/j2228bdayu+PmKzic+q5jVBzPJKbGQV2Iht8RCXqlzXkleqaVRQXEnvU5jUKQvY3oFMLZnICOj/fF2OztL855MvtOtSz5f4fLVbSqIfOE/4Zx5p75eXghrFsKmN8BuBTToNQmG3AD9LwWTZ9OPaa2Cb/8Ie75UgaPLX4VhNzZuW5sNVv0frP+Pej7keogYrjLBy/PVvK6pVjarBhFDsfWeQnboucSbYknIs7D1eB7rjmSRXVw7izbSz52Jffw5v6cbY8J0+Ghl6ljlBdVT2UnPq8pUkL7SMXc9L4eq8qYFEiXo3e7a5PO1WVWQOWUb9uStpOz7jdCyeACsIQNx6zlWBbi7jQT/ng0HNO12KEiqDoCn7VTZ5T7hKrjtmmJUkLe+fdmskH9ClT3PPsy639fjXhhPH48y/DxMtdc9eR9WCxRnNS4A3Vo0PZi9VGDf5KUC0sUZUJJ1+m1bc0zOoLTOUF3xwX5yAPuk53Zbg7tt+FgnBeBdy0yOIH2NwL3zea0bC3TV85o3HaiBnzpO1+QI0muaY9u6Jq121YtaF7p1XfRqjv/XNMd9CDWfO+ZTHgePgAY/GjlnCiGEEEKI9iZBbyHaSFZRBfd9ugNvNwM3jOnOxL7B6HSNu0vcbrezYl8GC/93gMScUgB83Y0UlFXWWi/Sz53zYoM5LyaEc3oH4W7Sk11cwdfbkvl08wmOO7YFGBLlx42ju3PpkHA8TB0zYxG63nf6888/Z/bs2SxatIgxY8bw0ksv8eWXX3Lo0CFCQkLq3e748eOce+659OrVi4CAAAl6C1GD1WansKySHEdAPLekguxiCznFjsclFnKKK8gtsZBVVEFeae1zr06DuEhfxvQMYGyvQEZGB+DrfnYGweU73brk8xUuK/8Kv78CY++B6U9XL7fbVTB8xWNQnK6WBfVTwS8nkxcMmKECzz3GN1yCuzQXMvdD5gE4+AMkrFGBlSvfhLirmj7uzW/B/x5ufCDIMwT6TIE+U6HXeeAZWOdqNpudg+lF/Hoki3VHsthyLA+LtfYxIv3cGRDhQ/9wHwY4pqgAd1cVpJP3l5xXxv60AvanFrI/rZD9qYWkFZQ680bR6zQ8jDrcjXo8THrcjTo8THo8TAbcTXqeunIoQd5uDb49+U63rvb4fCutNp78Zjt6HTxxxYg6//9qa19sTeLhr3bTO9iTP13QjzKLlfJKK2WVVsosNkorqyi3OJ5X2qiwVKFVFuNRkYWnJRuvyhx8qnLxtebgb8vFz5aPBSPFmhfFOi+KNS9KdF6U6nwo0XlTZvCmXO8NehPuBg13A7gZUHO9hpvBjpsezHowG/UY3X1w8/TGzdMXdy9fvDw88HI34uNmxGzQVX+GleVQlAoFKVCYAgXJjrnjeZXzppQaP0Gd/HOU3apu4LFVga2y9mNbVfOC1KJlPLAH/Lo3uIqcM4UQQgghRHuToLcQHYilysaHGxN5edURCsoq0es0Rvbw57zYEM6PDaFviFe9P9zYbHY2JuTw8eYTrNyX7sr+9jYbVK/bEC96B3vSO9iLnkGe7Va6NyW/jDWHMknIKuFvlw447fpd7Ts9ZswYRo0axauvvgqAzWYjKiqKe++9l0ceeaTObaxWKxMnTuS2225j3bp15OfnS9BbiDOQnFfKpoRcNh3LYdOxXNfNSE6aBjGh3vQN9aZPsBe9QzzpE+JFdKAnbkZ9PXttG/Kdbl3y+QqXja/D8kdgwEy49n21LOsQLHsIjv2qngf0goufVQHj3GOw+3PY9SnkHa/ej293GDILBl6pygtnHVABbmeguzij9nH1ZnW8mIuaP/YjP8GWd8BgUv153f3Bza/6cc3JO/y0fbHrUmaxsulYDr8ezubXI1kczay7/LS32UBsuDf9w33oEejJiZwS9qcVciCtiOKK0/RMPo3Nj00hRILe7Uo+XyW3xMKof/6M1dbxfpox6DR83I1E+rnTPdCD7gFq6hHgQVSABxF+7ugbeaN3o9hsjgC41REMdwTCnY9tVY7XrDUyoZ1ZzydnRp/0HE5djgbYaxzPWsexnAF6R2DeWlkjYF9Z+7ndMTbX3JG9XXOZaxx1ZW/XyOB2ZbE3kBV+chl5qGOZI3O8znmN18f+EdwarhYn32khhBBCCNHeJOgtRAdUUFrJ/rRCBkT4NCubMLu4gq8c2d8nB2ucwn3d6B3sRS9HILxHoAdhvm6Eervh52FssawIS5WNrcdzWXM4izWHMjmcUf2jp/wYWZvFYsHDw4OvvvqKmTNnupbfcsst5Ofn891339W53RNPPMHu3bv55ptvuPXWWyXoLUQLSysocwXBNybkciy7pM71dBpEBXjQO9iLPiHqBqNATxN+Hib8PIz4uRvxcTe2amBcvtOtSz5f4bJ/KXxxsyqbPPs7+PVZ+P1VFfgwuMGEB+Gc+8B40nWO3Q4nNsKuT2Dft9CYntd+3SFkAIT0V/3Dw4e0yltqTQWllRxIV9naB9JU5vaRjOJTssFrMul19AvzcmWFD4jwJTbcGw+jntJKK2UWK6UWK6WWqhqPrZRVVlFqsXL1iG6YDQ2fb+U73brk86323zVHWbE3HTejHneTHnejYzJVz92MzkmHm0GPuebcqHc9Nht02OxQZbVRZbNTZbVTabNRZbVTVWNuqbJRVmmlvNLmyix3PnZOJRYrxeVVFFdUUVReSXF5FUXlVRRbqhrVGsag0+jm705UgAc+bkYMeg29TsOo06HXaxh0GgadDoPzsV6HSa9hMugw6tVkMugwOeZqmXrdbKj9ulGvljnXczPqWzbgLk5LvtNCCCGEEKK9ddyaxkJ0Yb4eRsb1rrt8ZGMEeZn546Te3DmhF5uP57InuYD4rGLis4pJyCohp8RCWkE5aQXl/HY0+5TtTXodwd5mQn3MhPq4EerjRrC3mRBvMz7uRrzNBrzdjHi5GfAyG/B2M9QqfZeaX8aaQyrIvf5oNiUWq2vfOg2Gdfdncr9g9GdBucGzSXZ2NlarldDQ0FrLQ0NDOXjwYJ3b/Pbbb7zzzjvs3LmzUceoqKigoqK6H2ZhYSN+bBeiiwv3dWfmsEhmDosEIKOw3HVePZpZ7JoXlleRmFNKYk4pvxzMrHd/bkYdfu4mfN2N+HoYCfIyEeKtzrPBXmY1d5xzAzxNGPRNz7IUQrQyH3U+IOsQvDZG9QEG6DcdLvo3+EfXvZ2mQY9xarroGTj4o8r+jl8NnsEqsO0McIcMUL2DzV5t8pZak6+HkbG9Ahnbq/r6ttJqIz6r2BUIT8wppUegBwMifBgQ7kuvYE+M9Zz/fPQ6fNzOzjYTQtTl7sl9uHtyn/YeRqPZbHZKK60UlVeSX1pJcl4ZiTklJOWWciK3lMTcUpJzy7BYbRzPKa3VZqstGXQaZoMOs1GP2aAC4WZHwNxsqA6Ku5Ko0VyJ0M5/u+o10OtUsN2g12HUqcC9wRGANzhecx6n5o0JbjWO62bUoddp6DS1vaaBTnM+V8fTaRp6TXPdEKDX1Zyr7dU+OCtK8wshhBBCCHG2kaC3EF2YTqed8gMjQF6JhYTsYuKzSlQwPFP9gJFZVE5eaSUWq42U/DJS8ssafSyjXsPLbMBs0JNeWF7rtSAvExP7qV7kE/oG4edhapH319UVFRVx880389ZbbxEUFNSobRYuXMjf//73Vh6ZEJ1bqI8boQPcmEr1DSp2u53sYkutIHhiTgl5pZUUllWSX1ZJfqkFmx3KK22kV5afcq6si06DAE8VBH/31lGE+TZcHUMI0UZ8ItS8olBNvt1VsDv24sbvw+gOg65Wk83WrDLiHZlRryM2zIfYMMkWFOJso9Opf9t5mQ2E+7rTP/zU76nNZiejqJzEHBUIL7NYHZnn1RnoVpuNSpsdqzMj3Wqj0mrDYlWZ6JWuud21zLXcaqOySs0raqxbs0p8lc1OlcVa6ybrzkLnCJprmjNgXh1EVwF8XEF25+vVz3EF30Fdp0J1t/WaWfx2x9Iv/3COXGcKIYQQQoizngS9hRCn8Pc0McIzgBE9Ak55raLKSlZRBRmFFWQWlpNZVEFGYTkZhRVkFVe4yt6pEnhVrn6LlVY7eaWVQCU6DYZG+TE5JoTzYkIYGOGDTkrPnVZQUBB6vZ6MjNr9OzMyMggLCztl/fj4eI4fP85ll13mWmazqTKhBoOBQ4cO0bt371rbLFiwgPnz57ueFxYWEhUV1ZJvQ4guSdM0V4Z2fZU6bDY7xZYqCkorKShTmVN5pRZyitX5NdNxns0qqiCzqIKc4gpsdtWyIrv4/9u7/9C66vMP4M+9bXKbxCSmLc2P1dKOibqJHbS2K933j82y6mBQ7XCDMjMRpDPppsX/tFZho7DB5jakY7C5fzY3OqhzG1O2TDsUq6KoHdSygeCgpq2IaxKW/sj9fP+ITXfX6q7unntyktcLLjfnx7157sPNmyTPPeecio5KvtcLB/7NJcumj/YePx6x8esR/3d3RGv7h3++eTbwBoqvXC5Ff3db9He3XfAh6yyd/beh+eSZapw6OxWnzk6ftv3U2Wqcenfd5JlqTKV0fuD77qA3RZq+TPa7y1Pp3FB+evh+tnp+aH92anpof+bs9OD93PNOnpmKyXPf88z57z+V0vRlyVOKakoxVZ0eOE8vT/8uOJVSnK2mqFan799LNU0/z7mqszY1v66MCABAQRl6Ax9IZeGCWN7THst76vvHbbWaYuL0+SH4xKmzsXJJR/R0OJr7g2ptbY01a9bEyMjIzDW9q9VqjIyMxPDw8AX7X3nllXHo0KGadffee2+MjY3F97///YsOsyuVSlQqlUzqB95fuVyKrkUt0bWoJer5qMlUNcXbE6fj+NhknBg7FZdU/FoHs0Z5QcT2pyOqZ6cH4AA0xcIF5Vi4oBxz4eRh6d1h+NlqdXrwXk0xNTV9f244X00X3ldnls9/PVWt3T5VnR62//tHz8+fMb10wbqll8yBhgIAMOf57yiQqXK5FJ2LWqJzUUv0d+ddTfHt3LkzBgcHY+3atbFu3bp48MEHY2JiIm699daIiLjlllviIx/5SOzZsycWLVoUV199dc3jL7300oiIC9YDxbOgfP7ocWAWar/wjDkAUK9SqfTuNcWdzQcAAOph6A1QIF/60pfixIkTcd9998Xo6Gh88pOfjMcffzx6e6evHfzGG29E2SlQAQAAAACAecTQG6BghoeHL3o684iIp5566n0f+7Of/azxBQEAAAAAAOTI4YAAAAAAAAAAFJahNwAAAAAAAACFNe9Ob55SioiIkydP5lwJ0AjnfpbP/WzTWDIT5haZmS2ZCXOLzMyWzIS5RWYCAJC3eTf0Hhsbi4iIyy67LOdKgEYaGxuL7u7uvMuYc2QmzE0yMxsyE+YmmZkNmQlzk8wEACAvpTTPPoJZrVbj6NGj0dnZGaVS6X33PXnyZFx22WXxj3/8I7q6uppU4fym581X9J6nlGJsbCwGBgaiXHbFhkaTmbObnjdf0XsuM7MlM2c3PW++ovdcZmZLZs5uet58Re+5zAQAIG/z7kjvcrkcy5cv/0CP6erqKuQfHEWm581X5J77FHl2ZGYx6HnzFbnnMjM7MrMY9Lz5itxzmZkdmVkMet58Re65zAQAIE8+egkAAAAAAABAYRl6AwAAAAAAAFBYht7vo1KpxO7du6NSqeRdyryh582n5zSK91Lz6Xnz6TmN4r3UfHrefHpOo3gvNZ+eN5+eAwDA/6aUUkp5FwEAAAAAAAAAH4YjvQEAAAAAAAAoLENvAAAAAAAAAArL0BsAAAAAAACAwjL0fh8PPfRQrFy5MhYtWhTr16+P559/Pu+S5oy//OUv8YUvfCEGBgaiVCrFo48+WrM9pRT33Xdf9Pf3R1tbW2zatCn+9re/5VPsHLBnz5649tpro7OzM5YtWxZbtmyJI0eO1OwzOTkZQ0NDsWTJkrjkkkti69atcezYsZwqpohkZnZkZnPJTJpBZmZHZjaXzKQZZGZ2ZGZzyUwAAMiOofd7+NWvfhU7d+6M3bt3x0svvRSrV6+OzZs3x/Hjx/MubU6YmJiI1atXx0MPPXTR7d/+9rfjBz/4QfzoRz+K5557Ljo6OmLz5s0xOTnZ5ErnhgMHDsTQ0FAcPHgw/vjHP8aZM2fic5/7XExMTMzsc9ddd8Vvf/vb2LdvXxw4cCCOHj0aN910U45VUyQyM1sys7lkJlmTmdmSmc0lM8mazMyWzGwumQkAABlKXNS6devS0NDQzPLU1FQaGBhIe/bsybGquSki0v79+2eWq9Vq6uvrS9/5zndm1r3zzjupUqmkRx55JIcK557jx4+niEgHDhxIKU33t6WlJe3bt29mn8OHD6eISM8++2xeZVIgMrN5ZGbzyUwaTWY2j8xsPplJo8nM5pGZzSczAQCgcRzpfRGnT5+OF198MTZt2jSzrlwux6ZNm+LZZ5/NsbL54fXXX4/R0dGa/nd3d8f69ev1v0H++c9/RkTE4sWLIyLixRdfjDNnztT0/Morr4wVK1boOf+VzMyXzMyezKSRZGa+ZGb2ZCaNJDPzJTOzJzMBAKBxDL0v4q233oqpqano7e2tWd/b2xujo6M5VTV/nOux/mejWq3GnXfeGRs3boyrr746IqZ73traGpdeemnNvnpOPWRmvmRmtmQmjSYz8yUzsyUzaTSZmS+ZmS2ZCQAAjbUw7wKA5hoaGoq//vWv8fTTT+ddCsCsJzMB6iczAeonMwEAoLEc6X0RS5cujQULFsSxY8dq1h87diz6+vpyqmr+ONdj/W+84eHh+N3vfhdPPvlkLF++fGZ9X19fnD59Ot55552a/fWcesjMfMnM7MhMsiAz8yUzsyMzyYLMzJfMzI7MBACAxjP0vojW1tZYs2ZNjIyMzKyrVqsxMjISGzZsyLGy+WHVqlXR19dX0/+TJ0/Gc889p/8fUkophoeHY//+/fHnP/85Vq1aVbN9zZo10dLSUtPzI0eOxBtvvKHn/FcyM18ys/FkJlmSmfmSmY0nM8mSzMyXzGw8mQkAANlxevP3sHPnzhgcHIy1a9fGunXr4sEHH4yJiYm49dZb8y5tThgfH4+///3vM8uvv/56vPzyy7F48eJYsWJF3HnnnfHNb34zLr/88li1alXs2rUrBgYGYsuWLfkVXWBDQ0Pxi1/8In7zm99EZ2fnzLXAuru7o62tLbq7u+O2226LnTt3xuLFi6Orqyt27NgRGzZsiE996lM5V08RyMxsyczmkplkTWZmS2Y2l8wkazIzWzKzuWQmAABkKPGefvjDH6YVK1ak1tbWtG7dunTw4MG8S5oznnzyyRQRF9wGBwdTSilVq9W0a9eu1NvbmyqVSrruuuvSkSNH8i26wC7W64hIDz/88Mw+//rXv9Idd9yRenp6Unt7e7rxxhvTm2++mV/RFI7MzI7MbC6ZSTPIzOzIzOaSmTSDzMyOzGwumQkAANkppZRSNuN0AAAAAAAAAMiWa3oDAAAAAAAAUFiG3gAAAAAAAAAUlqE3AAAAAAAAAIVl6A0AAAAAAABAYRl6AwAAAAAAAFBYht4AAAAAAAAAFJahNwAAAAAAAACFZegNAAAAAAAAQGEZesN/KJVK8eijj+ZdBkAhyEyA+slMgPrJTAAA4IMw9GZW+epXvxqlUumC2/XXX593aQCzjswEqJ/MBKifzAQAAIpmYd4FwH+6/vrr4+GHH65ZV6lUcqoGYHaTmQD1k5kA9ZOZAABAkTjSm1mnUqlEX19fza2npycipk9vtnfv3rjhhhuira0tPvrRj8avf/3rmscfOnQoPvvZz0ZbW1ssWbIkbr/99hgfH6/Z56c//Wl84hOfiEqlEv39/TE8PFyz/a233oobb7wx2tvb4/LLL4/HHnss2xcN8CHJTID6yUyA+slMAACgSAy9KZxdu3bF1q1b45VXXolt27bFl7/85Th8+HBERExMTMTmzZujp6cnXnjhhdi3b1/86U9/qvnDee/evTE0NBS33357HDp0KB577LH42Mc+VvM9Hnjggbj55pvj1Vdfjc9//vOxbdu2ePvtt5v6OgEaQWYC1E9mAtRPZgIAALNKgllkcHAwLViwIHV0dNTcvvWtb6WUUoqItH379prHrF+/Pn3ta19LKaX04x//OPX09KTx8fGZ7b///e9TuVxOo6OjKaWUBgYG0j333POeNUREuvfee2eWx8fHU0SkP/zhDw17nQCNIDMB6iczAeonMwEAgKJxTW9mnc985jOxd+/emnWLFy+e+XrDhg012zZs2BAvv/xyREQcPnw4Vq9eHR0dHTPbN27cGNVqNY4cORKlUimOHj0a11133fvWcM0118x83dHREV1dXXH8+PEP+5IAMiMzAeonMwHqJzMBAIAiMfRm1uno6LjglGaN0tbWVtd+LS0tNculUimq1WoWJQH8T2QmQP1kJkD9ZCYAAFAkrulN4Rw8ePCC5auuuioiIq666qp45ZVXYmJiYmb7M888E+VyOa644oro7OyMlStXxsjISFNrBsiLzASon8wEqJ/MBAAAZhNHejPrnDp1KkZHR2vWLVy4MJYuXRoREfv27Yu1a9fGpz/96fj5z38ezz//fPzkJz+JiIht27bF7t27Y3BwMO6///44ceJE7NixI77yla9Eb29vRETcf//9sX379li2bFnccMMNMTY2Fs8880zs2LGjuS8UoAFkJkD9ZCZA/WQmAABQJIbezDqPP/549Pf316y74oor4rXXXouIiAceeCB++ctfxh133BH9/f3xyCOPxMc//vGIiGhvb48nnngivvGNb8S1114b7e3tsXXr1vjud78781yDg4MxOTkZ3/ve9+Luu++OpUuXxhe/+MXmvUCABpKZAPWTmQD1k5kAAECRlFJKKe8ioF6lUin2798fW7ZsybsUgFlPZgLUT2YC1E9mAgAAs41regMAAAAAAABQWIbeAAAAAAAAABSW05sDAAAAAAAAUFiO9AYAAAAAAACgsAy9AQAAAAAAACgsQ28AAAAAAAAACsvQGwAAAAAAAIDCMvQGAAAAAAAAoLAMvQEAAAAAAAAoLENvAAAAAAAAAArL0BsAAAAAAACAwjL0BgAAAAAAAKCw/h8xavhgvMu12wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from IPython.display import clear_output, display\n", + "\n", + "\n", + "SHARED_EPOCHS = 10\n", + "SOLO_EPOCHS = 15\n", + "\n", + "\n", + "train_losses = {task_name: [] for task_name in tasks.keys()}\n", + "val_losses = {task_name: [] for task_name in tasks.keys()}\n", + "\n", + "\n", + "model, optimiser, lr_scheduler = model_factory(\n", + " task_names=tasks.keys(),\n", + " epochs=SOLO_EPOCHS+SHARED_EPOCHS\n", + ")\n", + "\n", + "print('beginning shared weights training')\n", + "model.unfreeze_trunk()\n", + "for epoch in range(SHARED_EPOCHS):\n", + " lr_scheduler.step(epoch)\n", + " for task_i, (task_name, task) in enumerate(tasks.items()):\n", + " model, train_loss = train_one_epoch(model, task, optimiser)\n", + " val_loss = evaluate(model, task, eval_type='val')\n", + " \n", + " train_losses[task_name].append(train_loss)\n", + " val_losses[task_name].append(val_loss)\n", + "\n", + " clear_output(wait=True)\n", + " plt.figure(figsize=(20, 10))\n", + "\n", + " for i, (task_name, _) in enumerate(tasks.items()):\n", + " plt.subplot(4, 6, i+1) # Assuming 22 tasks, this creates a 4x6 grid\n", + " plt.plot(train_losses[task_name], label='Train Loss')\n", + " plt.plot(val_losses[task_name], label='Val Loss')\n", + " plt.title(task_name)\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " display(plt.gcf())\n", + " plt.close()\n", + "\n", + "\n", + "print('beginning solo-task post-training')\n", + "model.freeze_trunk()\n", + "for epoch in range(SOLO_EPOCHS):\n", + " lr_scheduler.step(SHARED_EPOCHS + epoch)\n", + " for task_i, (task_name, task) in enumerate(tasks.items()):\n", + " model, train_loss = train_one_epoch(model, task, optimiser)\n", + " val_loss = evaluate(model, task, eval_type='val')\n", + " \n", + " train_losses[task_name].append(train_loss)\n", + " val_losses[task_name].append(val_loss)\n", + "\n", + " clear_output(wait=True)\n", + " plt.figure(figsize=(20, 10))\n", + "\n", + " for i, (task_name, _) in enumerate(tasks.items()):\n", + " plt.subplot(4, 6, i+1)\n", + " plt.plot(train_losses[task_name], label='Train Loss')\n", + " plt.plot(val_losses[task_name], label='Val Loss')\n", + " plt.title(task_name)\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " display(plt.gcf())\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'caco2_wang': [0.668, 0.0], 'hia_hou': [0.969, 0.0], 'pgp_broccatelli': [0.936, 0.0], 'bioavailability_ma': [0.648, 0.0], 'lipophilicity_astrazeneca': [0.562, 0.0], 'solubility_aqsoldb': [0.821, 0.0], 'bbb_martins': [0.92, 0.0], 'ppbr_az': [9.884, 0.0], 'vdss_lombardo': [0.421, 0.0], 'cyp2d6_veith': [0.69, 0.0], 'cyp3a4_veith': [0.858, 0.0], 'cyp2c9_veith': [0.808, 0.0], 'cyp2d6_substrate_carbonmangels': [0.654, 0.0], 'cyp3a4_substrate_carbonmangels': [0.629, 0.0], 'cyp2c9_substrate_carbonmangels': [0.471, 0.0], 'half_life_obach': [0.374, 0.0], 'clearance_microsome_az': [0.618, 0.0], 'clearance_hepatocyte_az': [0.438, 0.0], 'herg': [0.825, 0.0], 'ames': [0.833, 0.0], 'dili': [0.956, 0.0], 'ld50_zhu': [0.704, 0.0]}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'caco2_wang': [0.35, 0.018],\n", + " 'hia_hou': [0.993, 0.005],\n", + " 'pgp_broccatelli': [0.942, 0.002],\n", + " 'bioavailability_ma': [0.689, 0.02],\n", + " 'lipophilicity_astrazeneca': [0.456, 0.008],\n", + " 'solubility_aqsoldb': [0.741, 0.013],\n", + " 'bbb_martins': [0.924, 0.003],\n", + " 'ppbr_az': [7.696, 0.125],\n", + " 'vdss_lombardo': [0.535, 0.027],\n", + " 'cyp2d6_veith': [0.719, 0.004],\n", + " 'cyp3a4_veith': [0.877, 0.001],\n", + " 'cyp2c9_veith': [0.823, 0.006],\n", + " 'cyp2d6_substrate_carbonmangels': [0.695, 0.032],\n", + " 'cyp3a4_substrate_carbonmangels': [0.663, 0.008],\n", + " 'cyp2c9_substrate_carbonmangels': [0.474, 0.025],\n", + " 'half_life_obach': [0.495, 0.042],\n", + " 'clearance_microsome_az': [0.628, 0.005],\n", + " 'clearance_hepatocyte_az': [0.446, 0.029],\n", + " 'herg': [0.846, 0.016],\n", + " 'ames': [0.849, 0.004],\n", + " 'dili': [0.956, 0.006],\n", + " 'ld50_zhu': [0.585, 0.008]}" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictions = {}\n", + "for task_i, (task_name, task) in enumerate(tasks.items()):\n", + "\n", + " with torch.no_grad():\n", + " y_pred_test = []\n", + " for inputs, _ in task.test_loader:\n", + " logits = model(inputs, task_name=task_name).squeeze()\n", + " if task.task == 'classification':\n", + " y_pred_test += torch.sigmoid(logits)\n", + " else:\n", + " y_pred_test += logits\n", + "\n", + " predictions[task_name] = y_pred_test\n", + "\n", + "predictions_list = [predictions] * 5\n", + "results = group.evaluate_many(predictions_list)\n", + "print(results)\n", + "\n", + "\n", + "{\n", + " 'caco2_wang': [0.35, 0.018],\n", + " 'hia_hou': [0.993, 0.005],\n", + " 'pgp_broccatelli': [0.942, 0.002],\n", + " 'bioavailability_ma': [0.689, 0.02],\n", + " 'lipophilicity_astrazeneca': [0.456, 0.008],\n", + " 'solubility_aqsoldb': [0.741, 0.013],\n", + " 'bbb_martins': [0.924, 0.003],\n", + " 'ppbr_az': [7.696, 0.125],\n", + " 'vdss_lombardo': [0.535, 0.027],\n", + " 'cyp2d6_veith': [0.719, 0.004],\n", + " 'cyp3a4_veith': [0.877, 0.001],\n", + " 'cyp2c9_veith': [0.823, 0.006],\n", + " 'cyp2d6_substrate_carbonmangels': [0.695, 0.032],\n", + " 'cyp3a4_substrate_carbonmangels': [0.663, 0.008],\n", + " 'cyp2c9_substrate_carbonmangels': [0.474, 0.025],\n", + " 'half_life_obach': [0.495, 0.042],\n", + " 'clearance_microsome_az': [0.628, 0.005],\n", + " 'clearance_hepatocyte_az': [0.446, 0.029],\n", + " 'herg': [0.846, 0.016],\n", + " 'ames': [0.849, 0.004],\n", + " 'dili': [0.956, 0.006],\n", + " 'ld50_zhu': [0.585, 0.008]\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "minimol", + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}