predict_region.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ECE 110/210 - Brain-Inpired ML\n",
    "# Final Presentation of ML model\n",
    "### Written by Hunter Schweiger, Sebastian Hernandez, Daniel Solis\n",
    "\n",
    "What you will learn: Cell type regional classification with a hybrid convolutional and fully-connected network (FCN) model using neuronal electrophysiology data\n",
    "\n",
    "In order to use the notebook with data please go to the github and download the test and training data csv: https://github.com/hschweiger15/Final_presentation_ECE210"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/daniel/miniconda3/envs/genephys2/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"
     ]
    }
   ],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import roc_curve, auc, confusion_matrix\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "import os\n",
    "from IPython.display import clear_output\n",
    "import shap\n",
    "from tqdm import tqdm\n",
    "from scipy.spatial.distance import pdist, squareform\n",
    "from pathlib import Path "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Training a Hybrid Model\n",
    "Let's train a hybrid model on the neuronal electrophysiology data. The reason we are using a hybrid model is that different features perform best when used with different architectures. For instance, static features calculated from waveforms such as mean firing rate or spike time tiling coefficient (STTC) are best fed into a FCN layer or other means of classification such as XgBoost. In contrast, the waveform is similar to image classification where we would want the model to focus on and pick out the most important elements of its shape which is why it is fed into convolutional layers. Here the model consists of 5 static features being fed into 3 FCN layers and 100 interpolated waveform points fed into 3 convolutional layers. The 2 paths converge and are fed into 2 more FCN layers before making the final classification. \n",
    "\n",
    "For this dataset we have 14,259 number of putative neuronal units taken from dorsal and ventral mouse forebrain stem cell derived tissue also known as organoids. 11,573 number of units from dorsal and 2,686 number of units from ventral. The reasoning behind this project was that these brain regions are similar in identity but have differing excitatory to inhibitory ratios of neurons. The goal is to use this model to predict whether the unit is from dorsal or ventral forebrain tissue.  \n",
    "\n",
    "If there are lines of code you don't understand, then copy-paste them into ChatGPT and query what they do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Device detection with M1/M2 support\n",
    "def get_device():\n",
    "    if torch.backends.mps.is_available():\n",
    "        return torch.device(\"mps\")\n",
    "    elif torch.cuda.is_available():\n",
    "        return torch.device(\"cuda\")\n",
    "    else:\n",
    "        return torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class PredictModel(nn.Module):\n",
    "    def __init__(self, input_size=105, hidden_size=64, output_size=1):\n",
    "        super().__init__()\n",
    "        \n",
    "        # Static features pathway with residual connections\n",
    "        self.static_block1 = nn.Sequential(\n",
    "            nn.Linear(input_size-100, hidden_size),\n",
    "            nn.BatchNorm1d(hidden_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2)\n",
    "        )\n",
    "        \n",
    "        self.static_block2 = nn.Sequential(\n",
    "            nn.Linear(hidden_size, hidden_size),\n",
    "            nn.BatchNorm1d(hidden_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2)\n",
    "        )\n",
    "        \n",
    "        self.static_block3 = nn.Sequential(\n",
    "            nn.Linear(hidden_size, hidden_size//2),\n",
    "            nn.BatchNorm1d(hidden_size//2),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # Improved waveform pathway\n",
    "        self.waveform_cnn = nn.Sequential(\n",
    "            nn.Conv1d(1, 32, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm1d(32),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.MaxPool1d(2),\n",
    "            \n",
    "            nn.Conv1d(32, 64, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm1d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.MaxPool1d(2),\n",
    "            \n",
    "            nn.Conv1d(64, 64, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm1d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.MaxPool1d(2),\n",
    "            \n",
    "            nn.Flatten()\n",
    "        )\n",
    "        \n",
    "        cnn_output_size = 64 * 12  # Adjusted for additional pooling\n",
    "        \n",
    "        self.waveform_fcn = nn.Sequential(\n",
    "            nn.Linear(cnn_output_size, hidden_size),\n",
    "            nn.BatchNorm1d(hidden_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(hidden_size, hidden_size//2),\n",
    "            nn.BatchNorm1d(hidden_size//2),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(hidden_size, hidden_size//2),\n",
    "            nn.BatchNorm1d(hidden_size//2),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(hidden_size//2, output_size),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        static_features = x[:, :5]\n",
    "        waveform = x[:, 5:].unsqueeze(1)\n",
    "        \n",
    "        static_out1 = self.static_block1(static_features)\n",
    "        static_out2 = self.static_block2(static_out1) + static_out1\n",
    "        static_out = self.static_block3(static_out2)\n",
    "        \n",
    "        waveform_cnn = self.waveform_cnn(waveform)\n",
    "        waveform_out = self.waveform_fcn(waveform_cnn)\n",
    "        \n",
    "        combined = torch.cat((static_out, waveform_out), dim=1)\n",
    "        return self.classifier(combined)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Create the Training Plots\n",
    "We need to create the plots for tracking how well our model is doing. The 4 plots will be \"Training and Validation Loss\", \"Training and Validation Accuracy\", \"Learning Rate Schedule\", and \"Epoch Training Time\"\n",
    "\n",
    "We will go more in depth into what each plot is showing after we run the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImprovedTrainingManager:\n",
    "    def __init__(self, model, criterion, optimizer, scheduler=None):\n",
    "        self.device = get_device()\n",
    "        print(f\"Using device: {self.device}\")\n",
    "        \n",
    "        self.model = model\n",
    "        self.criterion = criterion\n",
    "        self.optimizer = optimizer\n",
    "        self.scheduler = scheduler\n",
    "        self.model.to(self.device)\n",
    "        \n",
    "        self.history = {\n",
    "            'train_loss': [],\n",
    "            'val_loss': [],\n",
    "            'train_acc': [],\n",
    "            'val_acc': [],\n",
    "            'epoch_times': [],\n",
    "            'learning_rates': []\n",
    "        }\n",
    "        \n",
    "        self.smoothing = 0.1\n",
    "        \n",
    "    def plot_training_progress(self):\n",
    "        \"\"\"Create an interactive visualization of training progress.\"\"\"\n",
    "        clear_output(wait=True)\n",
    "        \n",
    "        fig = plt.figure(figsize=(15, 10))\n",
    "        \n",
    "        # Plot 1: Loss\n",
    "        ax1 = plt.subplot(2, 2, 1)\n",
    "        ax1.plot(self.history['train_loss'], label='Train Loss', color='blue')\n",
    "        ax1.plot(self.history['val_loss'], label='Val Loss', color='red')\n",
    "        ax1.set_xlabel('Epoch')\n",
    "        ax1.set_ylabel('Loss')\n",
    "        ax1.set_title('Training and Validation Loss')\n",
    "        ax1.legend()\n",
    "        ax1.grid(True)\n",
    "        \n",
    "        # Plot 2: Accuracy\n",
    "        ax2 = plt.subplot(2, 2, 2)\n",
    "        ax2.plot(self.history['train_acc'], label='Train Acc', color='blue')\n",
    "        ax2.plot(self.history['val_acc'], label='Val Acc', color='red')\n",
    "        ax2.set_xlabel('Epoch')\n",
    "        ax2.set_ylabel('Accuracy')\n",
    "        ax2.set_title('Training and Validation Accuracy')\n",
    "        ax2.legend()\n",
    "        ax2.grid(True)\n",
    "        \n",
    "        # Plot 3: Learning Rate\n",
    "        ax3 = plt.subplot(2, 2, 3)\n",
    "        ax3.plot(self.history['learning_rates'], color='green')\n",
    "        ax3.set_xlabel('Epoch')\n",
    "        ax3.set_ylabel('Learning Rate')\n",
    "        ax3.set_title('Learning Rate Schedule')\n",
    "        ax3.grid(True)\n",
    "        ax3.set_yscale('log')\n",
    "        \n",
    "        # Plot 4: Epoch Time\n",
    "        ax4 = plt.subplot(2, 2, 4)\n",
    "        ax4.plot(self.history['epoch_times'], color='purple')\n",
    "        ax4.set_xlabel('Epoch')\n",
    "        ax4.set_ylabel('Time (seconds)')\n",
    "        ax4.set_title('Epoch Training Time')\n",
    "        ax4.grid(True)\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    def criterion_with_smoothing(self, outputs, targets):\n",
    "        smooth_targets = targets * (1 - self.smoothing) + 0.5 * self.smoothing\n",
    "        return self.criterion(outputs, smooth_targets)\n",
    "    \n",
    "    def train_epoch(self, train_loader, accumulation_steps):\n",
    "        self.model.train()\n",
    "        total_loss = 0\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        \n",
    "        self.optimizer.zero_grad()\n",
    "        \n",
    "        progress_bar = tqdm(train_loader, desc='Training', leave=False)\n",
    "        for i, (batch_X, batch_y) in enumerate(progress_bar):\n",
    "            batch_X, batch_y = batch_X.to(self.device), batch_y.to(self.device)\n",
    "            \n",
    "            outputs = self.model(batch_X)\n",
    "            loss = self.criterion_with_smoothing(outputs, batch_y)\n",
    "            \n",
    "            loss = loss / accumulation_steps\n",
    "            loss.backward()\n",
    "            \n",
    "            if (i + 1) % accumulation_steps == 0:\n",
    "                torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)\n",
    "                self.optimizer.step()\n",
    "                self.optimizer.zero_grad()\n",
    "            \n",
    "            total_loss += loss.item() * accumulation_steps\n",
    "            predicted = (outputs > 0.5).float()\n",
    "            total += batch_y.size(0)\n",
    "            correct += (predicted == batch_y).sum().item()\n",
    "            \n",
    "            progress_bar.set_postfix({\n",
    "                'loss': f'{loss.item() * accumulation_steps:.4f}',\n",
    "                'acc': f'{(correct/total)*100:.2f}%'\n",
    "            })\n",
    "        \n",
    "        return total_loss / len(train_loader), correct / total\n",
    "\n",
    "    def validate(self, val_loader):\n",
    "        self.model.eval()\n",
    "        total_loss = 0\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            for batch_X, batch_y in val_loader:\n",
    "                batch_X, batch_y = batch_X.to(self.device), batch_y.to(self.device)\n",
    "                outputs = self.model(batch_X)\n",
    "                loss = self.criterion_with_smoothing(outputs, batch_y)\n",
    "                \n",
    "                total_loss += loss.item()\n",
    "                predicted = (outputs > 0.5).float()\n",
    "                total += batch_y.size(0)\n",
    "                correct += (predicted == batch_y).sum().item()\n",
    "        \n",
    "        return total_loss / len(val_loader), correct / total\n",
    "\n",
    "    def train(self, train_loader, val_loader, epochs=100, early_stopping_patience=10, accumulation_steps=4):\n",
    "        best_val_loss = float('inf')\n",
    "        patience_counter = 0\n",
    "        \n",
    "        for epoch in range(epochs):\n",
    "            epoch_start_time = time.time()\n",
    "            \n",
    "            # Training phase\n",
    "            train_loss, train_acc = self.train_epoch(train_loader, accumulation_steps)\n",
    "            \n",
    "            # Validation phase\n",
    "            val_loss, val_acc = self.validate(val_loader)\n",
    "            \n",
    "            # Record time and learning rate\n",
    "            epoch_time = time.time() - epoch_start_time\n",
    "            current_lr = self.optimizer.param_groups[0]['lr']\n",
    "            \n",
    "            # Update history\n",
    "            self.history['train_loss'].append(train_loss)\n",
    "            self.history['val_loss'].append(val_loss)\n",
    "            self.history['train_acc'].append(train_acc)\n",
    "            self.history['val_acc'].append(val_acc)\n",
    "            self.history['epoch_times'].append(epoch_time)\n",
    "            self.history['learning_rates'].append(current_lr)\n",
    "            \n",
    "            # Plot progress every 2 epochs\n",
    "            if epoch % 2 == 0:\n",
    "                self.plot_training_progress()\n",
    "            \n",
    "            print(f'\\nEpoch [{epoch+1}/{epochs}]')\n",
    "            print(f'Train Loss: {train_loss:.4f}, Train Acc: {train_acc*100:.2f}%')\n",
    "            print(f'Val Loss: {val_loss:.4f}, Val Acc: {val_acc*100:.2f}%')\n",
    "            print(f'Learning Rate: {current_lr:.6f}')\n",
    "            print(f'Time: {epoch_time:.2f}s')\n",
    "            \n",
    "            # Early stopping check\n",
    "            if val_loss < best_val_loss:\n",
    "                best_val_loss = val_loss\n",
    "                patience_counter = 0\n",
    "                torch.save({\n",
    "                    'epoch': epoch,\n",
    "                    'model_state_dict': self.model.state_dict(),\n",
    "                    'optimizer_state_dict': self.optimizer.state_dict(),\n",
    "                    'val_loss': val_loss,\n",
    "                    'val_acc': val_acc\n",
    "                }, 'best_model.pth')\n",
    "                print(\"✓ Saved new best model\")\n",
    "            else:\n",
    "                patience_counter += 1\n",
    "                print(f\"! Validation loss didn't improve for {patience_counter} epochs\")\n",
    "            \n",
    "            # Learning rate scheduling\n",
    "            if self.scheduler is not None:\n",
    "                if isinstance(self.scheduler, optim.lr_scheduler.ReduceLROnPlateau):\n",
    "                    self.scheduler.step(val_loss)\n",
    "                else:\n",
    "                    self.scheduler.step()\n",
    "            \n",
    "            # Early stopping\n",
    "            if patience_counter >= early_stopping_patience:\n",
    "                print(f'\\nEarly stopping triggered after epoch {epoch+1}')\n",
    "                break\n",
    "        \n",
    "        # Load best model\n",
    "        checkpoint = torch.load('best_model.pth')\n",
    "        self.model.load_state_dict(checkpoint['model_state_dict'])\n",
    "        print(f\"\\nTraining completed. Best validation loss: {checkpoint['val_loss']:.4f}\")\n",
    "        print(f\"Best validation accuracy: {checkpoint['val_acc']*100:.2f}%\")\n",
    "        \n",
    "        # Final plot\n",
    "        self.plot_training_progress()\n",
    "        \n",
    "        return self.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def train_model(X_train, y_train, X_test, y_test, save_path=\"save_plots\", batch_size=64):\n",
    "    device = get_device()\n",
    "    \n",
    "    # Initialize improved model and training components\n",
    "    model = PredictModel()\n",
    "    criterion = nn.BCELoss()\n",
    "    optimizer = optim.AdamW(\n",
    "        model.parameters(),\n",
    "        lr=0.0005,\n",
    "        weight_decay=0.01\n",
    "    )\n",
    "    \n",
    "    scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(\n",
    "        optimizer,\n",
    "        T_0=10,\n",
    "        T_mult=2,\n",
    "        eta_min=1e-6\n",
    "    )\n",
    "    \n",
    "    # Prepare data with larger batch size\n",
    "    train_size = int(0.8 * len(X_train))\n",
    "    train_dataset = TensorDataset(X_train[:train_size], y_train[:train_size])\n",
    "    val_dataset = TensorDataset(X_train[train_size:], y_train[train_size:])\n",
    "    \n",
    "    # For M1/M2 Macs, we'll adjust num_workers based on system\n",
    "    import platform\n",
    "    if platform.processor() == 'arm':\n",
    "        num_workers = 0  # M1/M2 Macs sometimes work better with 0 workers\n",
    "    else:\n",
    "        num_workers = 4\n",
    "    \n",
    "    train_loader = DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=batch_size,\n",
    "        shuffle=True,\n",
    "        num_workers=num_workers,\n",
    "        pin_memory=True if device != \"cpu\" else False\n",
    "    )\n",
    "    \n",
    "    val_loader = DataLoader(\n",
    "        val_dataset,\n",
    "        batch_size=batch_size,\n",
    "        num_workers=num_workers,\n",
    "        pin_memory=True if device != \"cpu\" else False\n",
    "    )\n",
    "    \n",
    "    trainer = ImprovedTrainingManager(model, criterion, optimizer, scheduler)\n",
    "    \n",
    "    # Add gradient accumulation for larger effective batch size\n",
    "    accumulation_steps = 4\n",
    "    effective_batch_size = batch_size * accumulation_steps\n",
    "    \n",
    "    print(f\"Training with effective batch size: {effective_batch_size}\")\n",
    "    \n",
    "    return trainer.train(\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epochs=100,\n",
    "        early_stopping_patience=10,\n",
    "        accumulation_steps=accumulation_steps\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Run the Model\n",
    "Let's run the model and see how well we do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAPeCAYAAADj01PlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hTZxsG8DtsEBEFFRBFwL23rduKC/fWume1VWsdravu1n6ts3ZoW/eu27buvffeAyeKA0UUZOZ8fzwmEFkBAknw/l1XrpycnPEmbwInz3nO86oURVFAREREREREREREREQJWBi7AUREREREREREREREpopBdCIiIiIiIiIiIiKiJDCITkRERERERERERESUBAbRiYiIiIiIiIiIiIiSwCA6EREREREREREREVESGEQnIiIiIiIiIiIiIkoCg+hERERERERERERERElgEJ2IiIiIiIiIiIiIKAkMohMRERERERERERERJYFBdCL6YPTo0QMFCxZM07oTJkyASqUybINMzN27d6FSqbBo0aJM37dKpcKECRO0jxctWgSVSoW7d++muG7BggXRo0cPg7YnPZ8VIiIioqyGx9HJ43F0HB5HE1FWxSA6ERmdSqXS67Zv3z5jN/WDN3jwYKhUKty6dSvJZcaMGQOVSoULFy5kYstS79GjR5gwYQLOnTtn7KZoaX6ATZs2zdhNISIiIjPA42jzwePozHP16lWoVCrY2dkhJCTE2M0hoizCytgNICJaunSpzuMlS5Zg586dCeYXL148Xfv5888/oVar07Tu2LFjMXLkyHTtPyvo3Lkz5syZgxUrVmDcuHGJLrNy5UqULl0aZcqUSfN+unbtio4dO8LW1jbN20jJo0ePMHHiRBQsWBDlypXTeS49nxUiIiKizMLjaPPB4+jMs2zZMri5ueHly5dYu3Yt+vTpY9T2EFHWwCA6ERldly5ddB4fO3YMO3fuTDD/feHh4XBwcNB7P9bW1mlqHwBYWVnByop/MqtWrYpChQph5cqViR78Hz16FHfu3MEPP/yQrv1YWlrC0tIyXdtIj/R8VoiIiIgyC4+jzQePozOHoihYsWIFPv30U9y5cwfLly832SB6WFgYsmXLZuxmEJGeWM6FiMxCnTp1UKpUKZw+fRq1atWCg4MDRo8eDQDYtGkTmjRpAg8PD9ja2sLX1xeTJ09GbGyszjber88Xv3TGH3/8AV9fX9ja2qJy5co4efKkzrqJ1XJUqVQYOHAgNm7ciFKlSsHW1hYlS5bEtm3bErR/3759qFSpEuzs7ODr64t58+bpXR/y4MGDaNeuHQoUKABbW1vkz58fX331Fd6+fZvg9Tk6OiIwMBAtW7aEo6MjcufOjeHDhyd4L0JCQtCjRw/kyJEDzs7O6N69u96XOnbu3BnXrl3DmTNnEjy3YsUKqFQqdOrUCVFRURg3bhwqVqyIHDlyIFu2bKhZsyb27t2b4j4Sq+WoKAqmTJkCT09PODg4oG7durh8+XKCdV+8eIHhw4ejdOnScHR0hJOTExo3bozz589rl9m3bx8qV64MAOjZs6f2UmdNHcvEajmGhYVh2LBhyJ8/P2xtbVG0aFFMmzYNiqLoLJeaz0VaPX36FL1790bevHlhZ2eHsmXLYvHixQmWW7VqFSpWrIjs2bPDyckJpUuXxuzZs7XPR0dHY+LEiShcuDDs7Ozg4uKCGjVqYOfOnQZrKxERERkXj6N5HP0hHUcfPnwYd+/eRceOHdGxY0ccOHAADx8+TLCcWq3G7NmzUbp0adjZ2SF37txo1KgRTp06pbPcsmXLUKVKFTg4OCBnzpyoVasWduzYodPm+DXpNd6vN6/pl/379+Pzzz9Hnjx54OnpCQC4d+8ePv/8cxQtWhT29vZwcXFBu3btEq1rHxISgq+++goFCxaEra0tPD090a1bNzx//hxv3rxBtmzZ8OWXXyZY7+HDh7C0tMTUqVP1fCeJ6H08HUxEZiM4OBiNGzdGx44d0aVLF+TNmxeAHJA4Ojpi6NChcHR0xJ49ezBu3DiEhobip59+SnG7K1aswOvXr/HZZ59BpVLhxx9/ROvWrREQEJBiJsWhQ4ewfv16fP7558iePTt+/vlntGnTBvfv34eLiwsA4OzZs2jUqBHc3d0xceJExMbGYtKkScidO7der3vNmjUIDw/HgAED4OLighMnTmDOnDl4+PAh1qxZo7NsbGwsGjZsiKpVq2LatGnYtWsXpk+fDl9fXwwYMACAHES3aNEChw4dQv/+/VG8eHFs2LAB3bt316s9nTt3xsSJE7FixQpUqFBBZ99///03atasiQIFCuD58+f466+/0KlTJ/Tt2xevX7/G/Pnz0bBhQ5w4cSLBpZ8pGTduHKZMmQJ/f3/4+/vjzJkzaNCgAaKionSWCwgIwMaNG9GuXTt4e3vjyZMnmDdvHmrXro0rV67Aw8MDxYsXx6RJkzBu3Dj069cPNWvWBABUq1Yt0X0rioLmzZtj79696N27N8qVK4ft27djxIgRCAwMxMyZM3WW1+dzkVZv375FnTp1cOvWLQwcOBDe3t5Ys2YNevTogZCQEO1B886dO9GpUyfUq1cP//vf/wBIfcjDhw9rl5kwYQKmTp2KPn36oEqVKggNDcWpU6dw5swZ1K9fP13tJCIiItPB42geR38ox9HLly+Hr68vKleujFKlSsHBwQErV67EiBEjdJbr3bs3Fi1ahMaNG6NPnz6IiYnBwYMHcezYMVSqVAkAMHHiREyYMAHVqlXDpEmTYGNjg+PHj2PPnj1o0KCB3u9/fJ9//jly586NcePGISwsDABw8uRJHDlyBB07doSnpyfu3r2L33//HXXq1MGVK1e0V428efMGNWvWxNWrV9GrVy9UqFABz58/x+bNm/Hw4UOUK1cOrVq1wurVqzFjxgydKxJWrlwJRVHQuXPnNLWbiAAoREQm5osvvlDe//NUu3ZtBYAyd+7cBMuHh4cnmPfZZ58pDg4OSkREhHZe9+7dFS8vL+3jO3fuKAAUFxcX5cWLF9r5mzZtUgAo//zzj3be+PHjE7QJgGJjY6PcunVLO+/8+fMKAGXOnDnaec2aNVMcHByUwMBA7bybN28qVlZWCbaZmMRe39SpUxWVSqXcu3dP5/UBUCZNmqSzbPny5ZWKFStqH2/cuFEBoPz444/aeTExMUrNmjUVAMrChQtTbFPlypUVT09PJTY2Vjtv27ZtCgBl3rx52m1GRkbqrPfy5Uslb968Sq9evXTmA1DGjx+vfbxw4UIFgHLnzh1FURTl6dOnio2NjdKkSRNFrVZrlxs9erQCQOnevbt2XkREhE67FEX62tbWVue9OXnyZJKv9/3PiuY9mzJlis5ybdu2VVQqlc5nQN/PRWI0n8mffvopyWVmzZqlAFCWLVumnRcVFaV8/PHHiqOjoxIaGqooiqJ8+eWXipOTkxITE5PktsqWLas0adIk2TYRERGR+eBxdMqvj8fRIqsdRyuKHBO7uLgoY8aM0c779NNPlbJly+ost2fPHgWAMnjw4ATb0LxHN2/eVCwsLJRWrVoleE/iv4/vv/8aXl5eOu+tpl9q1KiR4Pg8sc/p0aNHFQDKkiVLtPPGjRunAFDWr1+fZLu3b9+uAFC2bt2q83yZMmWU2rVrJ1iPiPTHci5EZDZsbW3Rs2fPBPPt7e21069fv8bz589Rs2ZNhIeH49q1aylut0OHDsiZM6f2sSabIiAgIMV1/fz84Ovrq31cpkwZODk5adeNjY3Frl270LJlS3h4eGiXK1SoEBo3bpzi9gHd1xcWFobnz5+jWrVqUBQFZ8+eTbB8//79dR7XrFlT57Vs2bIFVlZW2owaQGonDho0SK/2AFJ/8+HDhzhw4IB23ooVK2BjY4N27dppt2ljYwNALpd88eIFYmJiUKlSpUQvYU3Orl27EBUVhUGDBulcujtkyJAEy9ra2sLCQv69xcbGIjg4GI6OjihatGiq96uxZcsWWFpaYvDgwTrzhw0bBkVRsHXrVp35KX0u0mPLli1wc3NDp06dtPOsra0xePBgvHnzBvv37wcAODs7IywsLNnSLM7Ozrh8+TJu3ryZ7nYRERGR6eJxNI+jP4Tj6K1btyI4OFjnOLlTp044f/68TvmadevWQaVSYfz48Qm2oXmPNm7cCLVajXHjxmnfk/eXSYu+ffsmqFkf/3MaHR2N4OBgFCpUCM7Ozjrv+7p161C2bFm0atUqyXb7+fnBw8MDy5cv1z536dIlXLhwIcWxEogoeQyiE5HZyJcvn/ZgMr7Lly+jVatWyJEjB5ycnJA7d27tAcKrV69S3G6BAgV0Hmt+CLx8+TLV62rW16z79OlTvH37FoUKFUqwXGLzEnP//n306NEDuXLl0tZnrF27NoCEr09Tzy+p9gBSc8/d3R2Ojo46yxUtWlSv9gBAx44dYWlpiRUrVgAAIiIisGHDBjRu3Fjnh9TixYtRpkwZbb3t3Llz47///tOrX+K7d+8eAKBw4cI683Pnzq2zP0B+aMycOROFCxeGra0tXF1dkTt3bly4cCHV+42/fw8PD2TPnl1nfvHixXXap5HS5yI97t27h8KFCyc4mH+/LZ9//jmKFCmCxo0bw9PTE7169UpQT3LSpEkICQlBkSJFULp0aYwYMQIXLlxIdxuJiIjItPA4msfRH8Jx9LJly+Dt7Q1bW1vcunULt27dgq+vLxwcHHSCyrdv34aHhwdy5cqV5LZu374NCwsLlChRIsX9poa3t3eCeW/fvsW4ceO0NeM173tISIjO+3779m2UKlUq2e1bWFigc+fO2LhxI8LDwwFIiRs7OzvtSRoiShsG0YnIbMQ/Q68REhKC2rVr4/z585g0aRL++ecf7Ny5U1sDWq1Wp7jdpEavV94b6MbQ6+ojNjYW9evXx3///YdvvvkGGzduxM6dO7UD97z/+pJqj6HlyZMH9evXx7p16xAdHY1//vkHr1+/1qmxt2zZMvTo0QO+vr6YP38+tm3bhp07d+KTTz7Rq1/S6vvvv8fQoUNRq1YtLFu2DNu3b8fOnTtRsmTJDN1vfBn9udBHnjx5cO7cOWzevFlbh7Jx48Y6NTtr1aqF27dvY8GCBShVqhT++usvVKhQAX/99VemtZOIiIgyHo+jeRytD3M+jg4NDcU///yDO3fuoHDhwtpbiRIlEB4ejhUrVmTqsfj7A9JqJPZdHDRoEL777ju0b98ef//9N3bs2IGdO3fCxcUlTe97t27d8ObNG2zcuBGKomDFihVo2rQpcuTIkeptEVEcDixKRGZt3759CA4Oxvr161GrVi3t/Dt37hixVXHy5MkDOzs73Lp1K8Fzic1738WLF3Hjxg0sXrwY3bp1085PrkRHSry8vLB79268efNGJ4vm+vXrqdpO586dsW3bNmzduhUrVqyAk5MTmjVrpn1+7dq18PHxwfr163UueUzsskl92gwAN2/ehI+Pj3b+s2fPEmSlrF27FnXr1sX8+fN15oeEhMDV1VX7ODWXYXp5eWHXrl14/fq1ThaN5jJnTfsyg5eXFy5cuAC1Wq2TjZ5YW2xsbNCsWTM0a9YMarUan3/+OebNm4dvv/1Wm8GVK1cu9OzZEz179sSbN29Qq1YtTJgwAX369Mm010RERESZj8fRqcfjaGGKx9Hr169HREQEfv/9d522AtI/Y8eOxeHDh1GjRg34+vpi+/btePHiRZLZ6L6+vlCr1bhy5UqyA7nmzJkTISEhOvOioqLw+PFjvdu+du1adO/eHdOnT9fOi4iISLBdX19fXLp0KcXtlSpVCuXLl8fy5cvh6emJ+/fvY86cOXq3h4gSx0x0IjJrmkyF+FkFUVFR+O2334zVJB2Wlpbw8/PDxo0b8ejRI+38W7duJaj/l9T6gO7rUxQFs2fPTnOb/P39ERMTg99//107LzY2NtUHVi1btoSDgwN+++03bN26Fa1bt4adnV2ybT9+/DiOHj2a6jb7+fnB2toac+bM0dnerFmzEixraWmZIMtkzZo1CAwM1JmXLVs2AEhwcJoYf39/xMbG4pdfftGZP3PmTKhUKr3rchqCv78/goKCsHr1au28mJgYzJkzB46OjtpLlIODg3XWs7CwQJkyZQAAkZGRiS7j6OiIQoUKaZ8nIiKirIvH0anH42hhisfRy5Ytg4+PD/r374+2bdvq3IYPHw5HR0dtSZc2bdpAURRMnDgxwXY0r79ly5awsLDApEmTEmSDx3+PfH19derbA8Aff/yRZCZ6YhJ73+fMmZNgG23atMH58+exYcOGJNut0bVrV+zYsQOzZs2Ci4tLpv5eIcqqmIlORGatWrVqyJkzJ7p3747BgwdDpVJh6dKlmXqpXkomTJiAHTt2oHr16hgwYID2ILJUqVI4d+5csusWK1YMvr6+GD58OAIDA+Hk5IR169alq7Z2s2bNUL16dYwcORJ3795FiRIlsH79+lTXOXR0dETLli219RzjX4IKAE2bNsX69evRqlUrNGnSBHfu3MHcuXNRokQJvHnzJlX7yp07N4YPH46pU6eiadOm8Pf3x9mzZ7F169YEmSZNmzbFpEmT0LNnT1SrVg0XL17E8uXLdTJvADngdXZ2xty5c5E9e3Zky5YNVatWTbROYbNmzVC3bl2MGTMGd+/eRdmyZbFjxw5s2rQJQ4YM0Rn8yBB2796NiIiIBPNbtmyJfv36Yd68eejRowdOnz6NggULYu3atTh8+DBmzZqlzfDp06cPXrx4gU8++QSenp64d+8e5syZg3LlymlrUJYoUQJ16tRBxYoVkStXLpw6dQpr167FwIEDDfp6iIiIyPTwODr1eBwtTO04+tGjR9i7d2+CwUs1bG1t0bBhQ6xZswY///wz6tati65du+Lnn3/GzZs30ahRI6jVahw8eBB169bFwIEDUahQIYwZMwaTJ09GzZo10bp1a9ja2uLkyZPw8PDA1KlTAcgxd//+/dGmTRvUr18f58+fx/bt2xO8t8lp2rQpli5dihw5cqBEiRI4evQodu3aBRcXF53lRowYgbVr16Jdu3bo1asXKlasiBcvXmDz5s2YO3cuypYtq132008/xddff40NGzZgwIABsLa2TsM7S0TxMYhORGbNxcUF//77L4YNG4axY8ciZ86c6NKlC+rVq4eGDRsau3kAgIoVK2Lr1q0YPnw4vv32W+TPnx+TJk3C1atXtZcxJsXa2hr//PMPBg8ejKlTp8LOzg6tWrXCwIEDdQ6SUsPCwgKbN2/GkCFDsGzZMqhUKjRv3hzTp09H+fLlU7Wtzp07Y8WKFXB3d8cnn3yi81yPHj0QFBSEefPmYfv27ShRogSWLVuGNWvWYN++falu95QpU2BnZ4e5c+di7969qFq1Knbs2IEmTZroLDd69GiEhYVhxYoVWL16NSpUqID//vsPI0eO1FnO2toaixcvxqhRo9C/f3/ExMRg4cKFiR78a96zcePGYfXq1Vi4cCEKFiyIn376CcOGDUv1a0nJtm3bEgwCCgAFCxZEqVKlsG/fPowcORKLFy9GaGgoihYtioULF6JHjx7aZbt06YI//vgDv/32G0JCQuDm5oYOHTpgwoQJ2jIwgwcPxubNm7Fjxw5ERkbCy8sLU6ZMwYgRIwz+moiIiMi08Dg69XgcLUztOHrVqlVQq9U6JXHe16xZM6xbtw5bt25F8+bNsXDhQpQpUwbz58/HiBEjkCNHDlSqVAnVqlXTrjNp0iR4e3tjzpw5GDNmDBwcHFCmTBl07dpVu0zfvn1x584dbe36mjVrYufOnahXr57e7Z89ezYsLS2xfPlyREREoHr16ti1a1eC76GjoyMOHjyI8ePHY8OGDVi8eDHy5MmDevXqwdPTU2fZvHnzokGDBtiyZYtOe4ko7VSKKZ1mJiL6gLRs2RKXL1/GzZs3jd0UIiIiIiKzweNoopS1atUKFy9e1GsMASJKGWuiExFlgrdv3+o8vnnzJrZs2YI6deoYp0FERERERGaAx9FEqff48WP8999/zEInMiBmohMRZQJ3d3f06NEDPj4+uHfvHn7//XdERkbi7NmzKFy4sLGbR0RERERkkngcTaS/O3fu4PDhw/jrr79w8uRJ3L59G25ubsZuFlGWwJroRESZoFGjRli5ciWCgoJga2uLjz/+GN9//z0P/ImIiIiIksHjaCL97d+/Hz179kSBAgWwePFiBtCJDIiZ6ERERERERERERERESWBNdCIiIiIiIiIiIiKiJDCITkRERERERERERESUBNZET4FarcajR4+QPXt2qFQqYzeHiIiIiLIIRVHw+vVreHh4wMKCuS3J4TE5EREREWUEfY/JGURPwaNHj5A/f35jN4OIiIiIsqgHDx7A09PT2M0waTwmJyIiIqKMlNIxOYPoKciePTsAeSOdnJwybb/R0dHYsWMHGjRoAGtr60zbL6WMfWOa2C+mi31jutg3pon9YroM3TehoaHInz+/9niTksZjcnof+8Y0sV9MF/vGdLFvTBP7xXQZ65icQfQUaC4XdXJyyvQDdgcHBzg5OfHLamLYN6aJ/WK62Demi31jmtgvpiuj+oblSVLGY3J6H/vGNLFfTBf7xnSxb0wT+8V0GeuYnMUXiYiIiIiIiIiIiIiSwCA6EREREREREREREVESGEQnIiIiIiIiIiIiIkoCa6ITERERmRiVSoXIyEjExsYauykUT3R0NKysrBAREaFX31hbW8PS0jITWkYasbGxiI6ONtj2UtvnlDr8jhAREZG5YBCdiIiIyEQoioInT57A3d0d9+/f54CTJkZRFLi5ueHBgwd6942zszPc3NzYlxlMURQEBQUhJCTE4NtNbZ9T6vA7QkREROaAQXQiIiIiExEUFITQ0FC4ubkhV65czNA0MWq1Gm/evIGjoyMsLJKviqgoCsLDw/H06VMAgLu7e2Y08YOlCaDnyZMHDg4OBgvIpqbPKXX4HSEiIiJzwiA6ERERkQmIjY1FSEgIcufODWtra9jb2zNoZ2LUajWioqJgZ2enV9/Y29sDAJ4+fYo8efLwpEgG0Xx38uTJAxcXF4NuO7V9TqnD7wgRERGZCx4JEhEREZkATR1nBwcHI7eEDEnTn4as0026+N0xb/yOEBERkTlgEJ2IiIjIhLAucNbC/sw8fK/NE/uNiIiIzAGD6ERERERERERERERESWAQnYiIiIhMSsGCBTFr1ixjN4PI7PC7Q0RERJQxGEQnIiIiojRRqVTJ3iZMmJCm7Z48eRL9+vVLV9vq1KmDIUOGpGsbRBnFlL87GitXroSlpSW++OILg2yPiIiIyJxZGbsBRERERGSeHj9+rJ1evXo1xo0bh+vXr2vnOTo6aqcVRUFsbCysrFI+/MydO7dhG0pkYszhuzN//nx8/fXXmDdvHqZPnw47OzuDbZuIiIjI3DATnYiIiIjSxM3NTXvLkSMHVCqV9vG1a9eQPXt2bN26FRUrVoStrS0OHTqE27dvo0WLFsibNy8cHR1RuXJl7Nq1S2e775ekUKlU+Ouvv9CqVSs4ODigcOHC2Lx5c7ravm7dOpQsWRK2trYoWLAgpk+frvP8b7/9hsKFC8POzg558+ZF27Zttc+tXbsWpUuXhr29PVxcXODn54ewsLB0tYc+LKb+3blz5w6OHDmCkSNHokiRIli/fn2CZRYsWKD9Drm7u2PgwIHa50JCQvDZZ58hb968sLOzQ6lSpfDvv/+m/Q0jIiIiMjJmopuw8HB2DxER0YdKUQBjxWUdHACVyjDbGjlyJKZNmwYfHx/kzJkTDx48gL+/P7777jvY2tpiyZIlaNasGa5fv44CBQokuZ2JEyfixx9/xE8//YQ5c+agc+fOuHfvHnLlypXqNp0+fRrt27fHhAkT0KFDBxw5cgSff/45XFxc0KNHD5w6dQqDBw/G0qVLUa1aNbx48QIHDx4EAAQFBaFz58748ccf0apVK7x+/RoHDx6Eoihpfo/IsBQFCA83zLbUavkeWloCFnqkH2WV787ChQvRpEkT5MiRA126dMH8+fPx6aefap///fffMXToUPzwww9o3LgxXr16hcOHDwMA1Go1GjdujNevX2PZsmXw9fXFlStXYGlpaZg3hoiIiMgIGKU1Qa9eAT4+VnjxogmaNo2GtbWxW0RERESZLTwccHIyzr7fvAGyZTPMtiZNmoT69etrH+fKlQtly5bVPp48eTI2bNiAzZs362Syvq9Hjx7o1KkTAOD777/Hzz//jBMnTqBRo0apbtOMGTNQr149fPvttwCAIkWK4MqVK/jpp5/Qo0cP3L9/H9myZUPTpk2RPXt2eHl5oXz58lCr1Xjy5AliYmLQunVreHl5AQBKly6d6jZQxgkPB+JVQ0knCwDOei+dFb47arUaixYtwpw5cwAAHTt2xLBhw3Dnzh14e3sDAKZMmYJhw4bhyy+/1K5XuXJlAMCuXbtw4sQJXL16FUWKFAEA+Pj4pOUtICIioveo1cC5c8CWLcDWrcDVq0C1akCLFkDTpoC7u7FbmHWxnIsJcnICYmJk+s4d47aFiIiIKD0qVaqk8/jNmzcYPnw4ihcvDmdnZzg6OuLq1au4f/9+stspU6aMdjpbtmxwcnLC06dP09Smq1evonr16jrzqlevjps3byI2Nhb169eHl5cXfHx80LVrVyxfvhzh71KbS5UqhXr16qF06dJo164d/vzzT7x8+TJN7SBKjrG+Ozt37kRYWBj8/f0BAK6urqhfvz4WLFgAAHj69CkePXqEevXqJbr+uXPn4OnpqQ2gExERUfqEhABr1gA9ewIeHkDFisC33wJHjgAvXwL//Qf06yfPffQRMHUqcPmyXJ1HhsNMdBOkUgE+PnJmKSBAhXjHvURERPSBcHCQrFZj7dtQsr2Xljt8+HDs3LkT06ZNQ6FChWBvb4+2bdsiKioq2e1Yv3dpnkqlglqtNlxD48mePTvOnDmDffv2YceOHRg3bhwmTJiA48ePw9LSEtu3b8exY8ewY8cOzJkzB2PGjMHx48e1WbpkXIb87qjVaoSGhsLJyQkWetRzyQrfnfnz5+PFixewt7fXzlOr1bhw4QImTpyoMz8xKT1PRERESVOrgeho4No1yTTfskWC5bGxccs4OgJ+fkDjxkCZMsDu3cDmzcCJE8Dx43IbPRrw9QWaN5cs9erVAT3GKE83RQFevwYePwaCguQ+JATw8gKKFpV7c63wxiC6ifL2VnDunAoBAQYqqkhERERmRaUyXFkIU3L48GH06NEDrVq1AiDZtXfv3s3UNhQvXlxbvzl+u4oUKaKt22xlZQU/Pz/4+flh/PjxcHZ2xp49e+Dn5weVSoXq1aujevXqGDduHLy8vLBhwwYMHTo0U18HJc6Q3x21Wn60ZsumX030jJQZ353g4GBs2rQJq1atQsmSJbXzY2NjUaNGDezYsQONGjVCwYIFsXv3btStWzfBNsqUKYOHDx/ixo0bzEYnIqIs79UrYNUq4Nkz4O1bKSunuSX2ODJSguRJ3ZI6z128OODvL7caNQAbm7jnPvoIGDMGePQI+OcfCajv3g3cvg3MnCm3XLmA+vXjbskMp5Kip0+Bw4cl210TKA8Kipt++zbpdW1tgcKFJaBerJjca245cqS9TZmBQXQT5eMj11wEBBi5IUREREQGVLhwYaxfvx7NmjWDSqXCt99+m2EZ5c+ePcO5c+d05rm7u2PYsGGoXLkyJk+ejA4dOuDo0aP45Zdf8NtvvwEA/v33XwQEBKBWrVrImTMntmzZArVajaJFi+LUqVM4fvw4GjZsiDx58uD48eN49uwZihcvniGvgUgjM747S5cuhYuLC9q3bw/VeyOk+vv7Y/78+WjUqBEmTJiA/v37I0+ePNpBRA8fPoxBgwahdu3aqFWrFtq0aYMZM2agUKFCuHbtGlQqVZrGMCAiIjJF0dHAvHnAxInA8+eG376DA/DJJxI0b9wYKFgw5XU8PIDPPpPbmzfAjh3Apk3Av/8CL14Aq1fLDQCKFJFgup8fULdu0gFstVqy4g8fjrvdupVyW7Jnl/rsbm5StvrOHeDmTTmJcOmS3N7n5gbUqQOsXJny9o2BQXQT5eurCaIzE52IiIiyjhkzZqBXr16oVq0aXF1d8c033yA0NDRD9rVixQqsWLFCZ97kyZMxduxY/P333xg3bhwmT54Md3d3TJo0CT169AAAODs7Y/369ZgwYQIiIiJQuHBhrFy5EiVLlkR4eDgOHDiA2bNnIzQ0FF5eXpg+fToaN26cIa+BSCMzvjsLFixAq1atEgTQAaBNmzbo2rUrnj9/ju7duyMiIgIzZ87E8OHD4erqirZt22qXXbduHYYPH45OnTohLCwMhQoVwg8//GDQthJlaYoCnDwJVKiQOfUXiEhviiKZ3l9/Ddy4IfOKFZPscAeHuJu9ve5jzTxbW8DaOuVbtmzp+/o7OgKtW8stJgY4ehTYuRPYtUvKvty4Ibdff5XyKlWqSEC9fn15jZqAuabu+vtKlgQqVQLy5YsLlmvu3dwSvyowNha4d0+C8tevx92uXYvLZA8OTvtrzmgqRWGZ+eSEhoYiR44cePXqFZycnDJtv9u3x6BRIysUKaLg+nUG0k1JdHQ0tmzZAn9//wQ1Jsl42C+mi31jutg3piUiIgJ37tyBl5cXoqKi9K7BTJkntfWxgbh+9fb2hp2dnc5zxjrONEfJvVfJvcfplZY+p9RJa//xf5hpYr8YyIwZwLBhMorgu0F904t9k8levpR02h49Uhwwg31jeLGxuqVU3i+rkiOHnKOKXxLlfYn1y6lT8tU8cECWyZ0bmDQJ6NPHvM53vXoF7N0rAfWdO+NOBiTF3h6oWlXqqlevLuVjcuY0fJs07ahcOfllDf2d0feY3Iy6+MOiKedy9658+c216D4RERERERER6Sk6WoLoALBwIdC1q9RaIPPyxRcSRH/wAJg61dityRSKAkybJoNIjholmdCG3v7Ll/KW3r8v9+9Pv3olQfLIyKS30xd/wBMP0cB+HD6qYYXataWESOXKSQfV792TmuPLl8tjOztg6FDgm2+kVIm5yZEDaNlSboC8h5qA+t69EoPUBMyrVQPKlZPs+IxuU0rBc2NjEN1E5c8PWFmpERVlgcDA9BX8JyIiIiIiIiIzsG4dEBgY97h/f+DCBakBkdWNGAGcPy+1Mgx8ZVGmev5c+hGQESe//15Gvc7i/vc/CZ4D8vJXrZLga3rs2yeB+du3JUgeFpb6bdjZxZVTaR27BrMffwYAsH0biZE7/4edO2U5e3sJGtepI7dy5YCwMCuMHm2BOXPiAvNduwLffSdxu6yiQAGgVy+5UdIYRDdRlpZAnjzhePTIEbdvM4hORERERERElOXNni33X30lmcw3bkh0ctw447YrowUFAdOnS7rxoUNSnNlcLVkCREXJ9N27UgPE1FNsU3LsGODtDeTNm+jT69fHBdCdnaXOddWqwE8/AYMGpf4cwosXck4lsWpGuXNLALtAAbmPP50rl24Ncjs7QFuN7d49oGxf7Xa+wY8o3a8aFr5ogX375NzHrl1yAwB7eytYWNRHWJiUhqhTRz6iFSqk7rVQ1sHCfibMzU1OsQUEGLkhRERERERERJSxjh+XYKWNjdSJmDlT5n//PXDzpnHbltE2bZIAOiDZ6OZKUYA//pBpZ2e5//tvozXHIP77D/j4Y6B580SfPnNGsrMBYOBA+ag2by7nEb78UqafP9dvV4oi546KF48LoH/2mQS2b9yQUi1PnwKnTwMbNgA//yzB9g4dpOxIsWISUHd1lSC6NoAeEwN07iz1XqpWlcg+AP/V3bHmh9t4+hS4fFkG2WzXTgL1b9+qEBZmgyJFFGzeDOzZwwD6h45BdBOmCaLfvm3khhARERERERFRxtJkoXfqJBm/HToADRpIHYkBA+KCzFnRhg1x0+YcRD90SNKws2UDZs2SeWvWmG/fKQrw7bcyfeIEcPGiztOBgUCzZhLcbthQzvu4ugIbNwJz5kgVon//BcqUkVrbybl7F/D3Bz79VALl5Yq+xc3h8zD3XmPUi9qKwoWl5EqaTJ4MHD4MZM8OrFghKeXVqklQvW1bqCLeokQJ4PPP5ZzHkyfA+fPRmDTpMM6ejUGzZh9ERR5KAYPoJoxBdCIiIiIiIqIPQGCgBFsBSd8FJGr3229Sk2L3bgn+ZUUhIfL6NMw5iP7nn3LfsSPQvr0E0+/dA06eNG670mrzZuDs2bjHy5ZpJ8PDgRYtgEePgBIlgNWrAat3RaNVKslKP35cssMfPwbq1QPGjpWk8PhiYiSmXbIksG0bkNf6BfZ8MgVnXnih0LT+MrNFC7laIS0OHACmTJHpefMAHx8ZJXP1aon4nzsHDB6ss4pKJdnwZco8z/ABNbO8BQvkpOCIEcCbN8ZuTbowiG7C8uYNB8AgOhEREREREVGW9ttvEk2sVQsoXz5uvq+vRB4BYOhQ4OVL47QvI/33n7z2PHnk8dWrcTXFzcnLl3EnQvr2lbTpZs3ksTmWdFEUYMIEma5YUe6XLwdiY6FWA926SVkVV1fgn3+AHDkSbqJsWSkJ37u3bO677+QjfveuPH/6NFClCjB8OJA7/C7W5PsSj6wLoO6eb6F69kxqs3zyCRAdLXVWUhtIf/FCyrio1UD37nKVh4anp9SOUamAv/4CFi1K5RtkBhQFePhQTlLNn687aHFmOHtWrqJ5+lRGiC1RQq46MdMrMxhEN2HMRCciIiIiIiLK4t6+lQxZIC4LPb4RIyQt9ulTYOTIzG1bZli/Xu779pU64tHREkg3N8uXAxERQOnSEhkGJPALmFRJl9hYGXtvyxaJGz9+nMSCmzZJlrajo2Sk58wpQdh9+zBuHLBunSR0r18vyd1JyZZNYtSrVgFOTsDRo0C5chLTrlIFUJ89h79tOiPAohDaBv4Mi/Awib4vXw7cugVs3y6Z/dHRQNu2+gfSFQXo00eCyIULS32Z9/n5ARMnyvSAAcCFC/pt29SEh0tfrV4tr+fTT+XER/bsMuKqn5+8F9Wry/uRGcLC5KRFVBRQowZQsCDw4AHQurWcXLpzJ3PaYUBWxm4AJc3NTTLRQ0Lk5FmuXMZtDxEREREREREZ2IoVQHAw4OUlZSveZ2MDzJ0L1K4tg1Z27y71nLOC8HAp1wFIcO3gQSm/cf68BFLNRfwBRfv2jSug3bixRJHv35ea4lWr6qx2/jzw5ZeWsLAoD0tLFRo2hMHKh4SESHl2ze3aNbm/dUvK7GvY2gK9egFffy1xTu3r0QSXBw8GPDykPM28ebg9YSm+O1QPgFSvqVlTv/Z06CBB808/BY4dUxC4ZDe24Cc0xA5Ac+GBn5+cNKpfX7cI+dKl8njlSgmkr1kDtGyZ/A7/+EOynq2tZb3s2RNfbswY4MgR+Ry2aSOp84ml1Wem2Fg5afb8ufxtiH///rzHjyU4nRRLSznL8eaNlBZq0EC+Y66uGfsavvxSPnAeHtIPDg5yKcJPP8nVJ3v2yFU2w4fL3zgzwCC6CbO1jYW7u4LHj1W4fZtBdCIiIsqa6tSpg3LlymGWZgAuItILvztEWYCixA1AOWiQBLwSU6sW0LMnsHAh8NlnwJkzhou2GtOOHRJI9/KSMjZly8YF0c2JZtBNOzugS5e4+fb2QPPmEsRds0YniP7PP5KoGxZmAaAA9u6VuGbbtpJ4XbMmYKFn/YiYGElE3r8f2LdPSrA/eZL08ra2kpxtZSXr/f67xJw7dwZGjQKKXd0oT2TPLmWEAKBrV2DePOQ5tA72+A1fjnRA9+6pepfg7S3de7LmMFQ7PlNmWlhIgH7ECKBChcRXtLICliyRQPqKFZLh//ffQKtWiS9/+TIwZIhMT50aV44mMRYWUuu9fHk5w9CrF7B2bepeWFrpe6ZDHy4uQNGicitWLG7ax0eC1PfuSUb41atAo0YSxHZyypCXhb//lvIxKpW8t5qA/Xffyffj88/lgzpmjJwg+f13oE6djGmLATGIbuJ8fOKC6JUrG7s1RERERHGaNWuG6OhobNNkkMVz8OBB1KpVC+fPn0eZMmXStZ9FixZhyJAhCAkJSdd2iExFZn13NN6+fYt8+fLBwsICgYGBsLW1Nch2icgA9u4FLl2SbOXevZNf9scfpazGpUvAzJmSOmzuNmyQ+1atJOCmyT7PzCC6okhtExcX4KOP0rYNzYCi7dpJ2ZP42rWTIPrffwM//QQFKsycKQm4igLUrauGvf1dnDrljadPVZg7Vy488PCQ7O2OHSUeFD8xWxM037dPbgcPAqGhCZvl4REXS40fXy1QQM7XKIoE3r//Hti5U+LUy5aocSvHRHgDkoXu4gIAuONeDSoLbxRU38GUSpsw5LtOCXeoB+tH91Dt9LvSKl98AQwbJtH1lFhZAYsXy/SKFRJ4X71armCI7+1bOTsREQE0bAh89VXK23ZxkcB5jRpSn2bWLBkZ1ZDCwqTdJ0/GBc2TO9NhYSHtcnGRIPT795rp3LnljEhKmeVeXtLJNWtKMfrmzYGtW+VEjyHdvQv06yfTo0cDdevqPl+8uATwly+Xvr92TZbp0kXqpufNa9j2GBCD6CbOxwc4fJh10YmIiMj09O7dG23atMHDhw/h6emp89zChQtRqVIlgwUBibKSzP7urFu3DiVLloSiKNi4cSM6dOhgsG0TUTrNni333btLPfDkuLpKkKlnTxnwsX37ePU3MtmTJ5JF2r8/UKlS2rYRHS0nBYC4QGj8ILqi6EaOM4JaLdHsmTMls//UKSC1f39fv5aC34CUcnlfo0ZSV/zBA8QcPo7Pl3ykjbl/9hkwY0Ysdu68iLVr8+PwYWusXCn1xh89kmbNnCmxoY4d5SOiCZq/fq27mxw55IKFOnWk9HXx4iknGqtUsnydOpJM//33gMWmjfB+dR6hyI4+x4biy8NS5r1ZcxXaq7tgHCZjcK6lsLBIWxAdM2bIWYBPPgF++SV168bPSF++XM4yrFolZVg0RoyQqwLy5JGgu77p/FWqyJs9cCDw9ddQJZUVn1rPnsnr/OUXqdX8vvhnOuJnkGvOdBhSsWJStqZuXTl70qFDXHF7Q4iJkcsZXr2SE1Ljxye+nEolQfMmTaSky++/S8b6v//Kh7BfP8O/dgPgwKImzsdHBp5gEJ2IiIhMTdOmTZE7d24sWrRIZ/6bN2+wZs0a9O7dG8HBwejUqRPy5csHBwcHlC5dGitXrjRoO+7fv48WLVrA0dERTk5OaN++PZ7Ey+w5f/486tati+zZs8PJyQkVK1bEqVOnAAD37t1Ds2bNkDNnTmTLlg0lS5bEli1bDNo+ovdl9ndn/vz56NKlC7p06YL58+cneP7y5cto2rQpnJyckD17dtSsWRO34/0AWbBgAUqWLAlbW1u4u7tjoKGz84iSEhkpNcK7dTOZQRkN6vZtqekBSMavPrp3l9rob99KsM9Y78u330q5hu7dJRCdFvv3SzmL3LnjaryXLClBz+fPJYqckaKjgR49JHCqedy1a+rLaKxcKVnGxYpJJvP7NCVdAGz4dA3+/FNe4syZEjvUxC+trKQk+Pz5co5i0yZJqHZwkIFAv/9eLj7YskUC6M7OstkZM6S6T3CwnJMYOlSqxqS2UkeVKsDG9WosLyK10H/Gl1izOxdq1AAKFZIKKdtzd5W27t6RfBZ1UoKDZZRRAPjmm9SvD0hwdfFiCcLGxMQFggF5A379VaYXL059VvPnn8vZipgYWH76KWzScxXk7duyvQIFgEmTJIDu4yMnn5Ytk4z0V69ksNY9e+TD8OWXctLF2zvjgsgVK8rfHTs7ue/VK+3f4fdNmiT15Z2cJOs+peB8zpzSX8ePSymfkBB5bKj2GBiD6CZOE0QPCDByQ4iIiChzKYr8IDPGTc8f5FZWVujWrRsWLVoEJd46a9asQWxsLDp16oSIiAhUrFgR//33Hy5duoR+/fqha9euOHHihEHeJrVajRYtWuDFixfYv38/du7ciYCAAJ1M286dO8PT0xMnT57E6dOnMXLkSFi/O6j/4osvEBkZiQMHDuDixYv43//+B0dHR4O0jYyE3x0dt2/fxtGjR9G+fXu0b98eBw8exL1797TPBwYGolatWrC1tcWePXtw+vRp9OrVCzExMQCA33//HV988QX69euHixcvYvPmzShUqFCq2mAWQkPlRzyZFk35kqVLpYRJVjNnjvzdaNxYMk/1oVJJrQ9raxmcb/36jG1jYoKDpU8A4MoVaUdaaNresmVcwNDePu69yMiSLm/fSvb70qWy75kzJdP/wgXJ8k8NTVp5nz5JZs4/qt4OAFD1wRpkz6bG5s1SsjupRHtbWwmQr1gh40uuWiW10lu2jAuaP38ugfavvpJy3gaJuW7cCPsbFwAnJ3x68iv06SMftWfPpGtmbyksEfrYWDl5kFq//CI18MuXl8FD08rSEli0SALpsbESSP/lF7lKA5AzCY0apX67KpX0Z7FiUD16hErTp8vnMDxc/22cPClXiRQpIoHxiAipx7NmDXDjBjBlimRrV6qUcTXJU1K7trTHykoC+l9+mf4Tcvv3S81zAJg3T78SPRqVK8ulEHPmxP19M0UKJevVq1cKAOXVq1eZut+oqChl48aNyqFD0QqgKJ6embp7Soamb6KioozdFIqH/WK62Demi31jWt6+fatcuXJFCQsLU16+fKnEhoYqihzOZv7tzRu923316lUFgLJ3717tvJo1aypdunRJcp0mTZoow4YN0z6uXbu28uWXXya5/MKFC5UcOXIk+tyOHTsUS0tL5f79+9p5ly9fVgAoJ06cUBRFUbJnz64sWrQo0fVLly6tTJgwIcl9xxcbGyt9Exur1/KKEtevb9++TfCcsY4zzVFy71WC9/jNG3534hk9erTSsmVL7eMWLVoo48eP1z4eNWqU4u3tneT/Ag8PD2XMmDHJv5h0SO47khyD/w/r3Vv6cNkyw2zvA2XQfrlxQ1FsbeO+X1OmpH+bpuTVK0XJnl1e27ZtqV9/7FhZ18NDtpUCg/bN99/r/u2rXj3124iNVRR3d1l/yxbd5zp2lPnff5/+tibm5UtFqVFDUQBFbWennJ3yj/K//ynKga/Wy34tLBTl8GH9tnXmjKxjba0oT58musjevYri5vxWCYWjogDKzSVHdJ43mWPy2FhFKV1aXs+332pnP3ggX7+DB9/NmDNHlqlYMXXbf/NGUVxcZN1VqwzT5pgYRenaVffzWKGCokREpG+7ly8ragcH3e16eSlKgwaKMmiQovzyi6Ls2iVvjlotty1bFKVuXd11/P3lA6BWG+LVGt7y5YqiUiXo81QLDpbAJaAoPXsarn1JMPR3Rt9jcmaimzhNJnpgoJy8IiIiIjIlxYoVQ7Vq1bBgwQIAwK1bt3Dw4EH0fjc4WmxsLCZPnozSpUsjV65ccHR0xPbt23H//n2D7P/q1avInz8/8ufPr51XokQJODs74+rVqwCAoUOHok+fPvDz88MPP/ygU6Zi8ODBmDJlCqpXr47x48fjwoULBmkXUUoy47sTGxuLxYsXo0uXLtp5Xbp0waJFi6B+d6n0uXPnULNmTe3VGfE9ffoUjx49Qr169dLzUs3DyZNyr6lPTcalKFIGITJSCj0DcWVPsoqFC6UmR/HiQIMGqV9/9GjA11dKnowaZfj2JSU6Oq5cxtSpgI2NDOR26FDqtnP8OPD4sWTifvKJ7nMZNLhoZCRwdmsQnpeqDRw6hFCLHKgVsQPlxzbFN98AtWa2wnrHboBaDaVbN+DNm5Q3qslCb91aytK8Z/58SbgOCrHDERcp6VLo7BpDvizD2bBBaok7OekMxunpKRVItJVqOnaUDObTp4F3x1p6mT9frmLw8dGtYZ4elpbyXerWTR5nyyYZ8ukdQLtECcSuXYvg4sWh5Mol8+7dA3bskGzpgQOl9k7+/ED27FKyxd9fBgq2spL2XLggV2nUqZPxtf3T6tNP4+rST54cV9ooNRRFrsJ4+FCy73/+2bBtNCEMops4Fxf5PioKcOeOsVtDREREmcbBQX68GePm4JCqpvbu3Rvr1q3D69evsXDhQvj6+qJ27doAgJ9++gmzZ8/GN998g7179+LcuXNo2LAhoqKiMuJdS9SECRNw+fJlNGnSBHv27EGJEiWwYcMGAECfPn0QEBCArl274uLFi6hUqRLmzJmTaW2jDGDA7446NBQhDx9CHRpqlt+d7du3IzAwEB06dICVlRWsrKzQsWNH3Lt3D7t37wYA2NvbJ7l+cs9lKfF/bJ08KYEhMq6VK4FduyQQpgmeHz8OBAUZt12GEhsrgThAaqGnJcBmby+lIgDgt9+AP/4wXPuSs369ZPnlzSuBVk3w8n//S9123v0fRpMmCQOeBgqi37sn1VoGDZIKJGWzB8DJvzpcAy/gMdxQU70fh1AT3t5xMfBeb2bjATyhun0bV5t9jejoZHYQFiaDWwIJBhSNjpb65X36SNnujh2BOr+1lyfXrDG9ms9qdVwZmyFDpFZ1UlxdpQQREFfWJyXR0cD06TI9fLgEmg3F0hJYsEBqoB84IIFcA1D8/HBo6lTEBAVJPZuDB6We+4gRUmunSBHZd1iYBJAdHaWMTECAtKV0aYO0I8N9/rmUmAGk/QsXpm79efPk+2xtLX+7s3BZRAbRTZxKJSeXAQ4uSkRE9EFRqSSbxhi3VP6Yb9++PSwsLLBixQosWbIEvXr1gurdNg4fPowWLVqgS5cuKFu2LHx8fHDjxg2DvU3FixfHgwcP8ODBA+28K1euICQkBCVKlNDOK1KkCL766ivs2LEDrVu3xsJ4PxDy58+P/v37Y/369Rg2bBj+1GSVkXnid0dr/vz56NixI86dO6dz69ixo3aA0TJlyuDgwYOITiRSlD17dhQsWFAbcM+yXryQjGCNuXON1xYCXr6My4IdOxaoWVPq5QLAv/8ar12GtGWL/MB3dpaBLNOqfn1g/HiZ/vxzYOtWgzQvWbNmyX3//hL8HjFC/vb9+6/+desVJS6I3rp1wuc1QfQbN6R2uZ7u3ZPYZc+eUo65YEGJ8f/yC/D2xAXsja4OXwTgsb0P/h50CFP/K4unTyXmuW6dnEsb+5MzhjrLMULxfb+jT/7tWLAAiQfT16yR8RR8fKDUqYtr1+TcSPPmkhD500+y2IQJUtvctnlDyZJ8+ND0xmBYv176L0cOCaKnRPO5Xb5cvxMCq1cD9+8DefLIYK6GZmkpnV2hguG3DciJgxo1gN69ZayGTZuA69fl83ntGrBzp7y+6dMlO93cjB4tAXRAzvzMnq1fLfjLl+P+Xv/vfxn3/psIA576oYzi6wucO8cgOhEREZkmR0dHdOjQAaNGjUJoaCh6xPtxVLhwYaxduxZHjhxBzpw5MWPGDDx58kQnwK2P2NhYnDt3Tmeera0t/Pz8ULp0aXTu3BmzZs1CTEwMPv/8c9SuXRuVKlXC27dvMWLECLRt2xbe3t54+PAhTp48iTbvLiMeMmQIGjdujCJFiuDly5fYu3cvihcvnt63hEgvGfndefbsGf755x9s3rwZpUqV0nmuW7duaNWqFV68eIGBAwdizpw56NixI0aNGoUcOXLg2LFjqFKlCooWLYoJEyagf//+yJMnDxo3bozXr1/j8OHDGDRokCHfCuPSZKFbWEgwaMUKYNq0uDIilLlGjZKRFIsVkwAtADRrJlcJ/POPBHgym6LI1SbPn0s5iufPE07nzSuDHOoz8K4mEN2vn5yAS4/x4+UzvGSJDGZ48CBQrlz6tpmUEyeAY8ekhEv//jKvSBEJhK9bJ1HjxYtT3s6lS8CtWxKEjzf446VLElvO7uiOljlcYfPqOe78cwk21SsjR46E5yrv3gX27Yu7xRszGYDEVStVAjp7HcJn/zaFTfgrKGXKwH3bNnzp7p6gWdmySZJ02AA/nGk0CBUOzcH3T3qhVO9LmDIlJ8aMkTitpvpV1G9/wgbAWuc++KqgBR4+1N1e7twSi+zU6d0MOzuJsC9fDvz9N/Dxxym/V5lBrQYmTpTplLLQNZo2lbIv9+9L9nedOkkvqyhxVyp8+aVcRZFVWFvLQLj6DgxsqlQq+b8XEiJZ/fFPpBQoIH+PNa9TM50rl1xiEREh3+MvvzRW6zMNg+hmgJnoREREZOp69+6N+fPnw9/fHx4eHtr5Y8eORUBAABo2bAgHBwf069cPLVu2xKtXr1K1/Tdv3qB8+fI683x9fXHr1i1s2rQJgwYNQq1atWBhYYFGjRppS7JYWloiODgY3bp1w5MnT+Dq6orWrVtj4rsfi7Gxsfjiiy/w8OFDODk5oVGjRpiZlnqQRGmUUd+dJUuWIFu2bInWM69Xrx7s7e2xbNkyDB48GHv27MGIESNQu3ZtWFpaoly5cqhevToAoHv37oiIiMDMmTMxfPhwuLq6om3btoZ58abi7l25r1JFMtIvX5YSBQMHGrVZH6SjR6U0ACBXBGjKfDRvDowbJ9me4eGpLp2UJi9eAG3bSpZpcDCgTymliROBWrUkW7VNm8QD5BcvAnv2SIT3iy/S306VSupyP3wo223SRALdGZENqxkzoGNHwM0tbv4330gQfcUKqatcoEDy29FkoTdoADg6IjJSsrV//FGT1KzCTpSFH3bjuw7nMR9yJYKlpcRtnZykREpgoO5mrawkaF6njtyqVQOyH/hP+jEiAqhRA6p//pErAJKRLRtQYfsPUJfbjnw3b+Avu4Foe2c5+vSRqhdNmgCPdl7G+htHEANLDDrTA0GQj2uNGlIqu359oHx5OTeno317CaKvWSNZywkWMBBF0f/qqHXrUpeFDkggvF07qXO+bFnyQfQtW2T7jo7AgAH6bZ8yn0olf389PeVv7bVrcmXQ/fty27FDd3lra7lEI29eYNGijPssmxAG0c0Ag+hERERk6j7++GMoipJgfq5cubBx48Zk1923b1+yz/fo0UMnQ/d9BQoUwKZNmxJ9zsbGBitXrkxyXdY/J2PLqO/OsGHDMGzYsESfs7GxwcuXL7WPy5Qpg+3btye5rc8++wyfffZZsm0xa5pMdG9viboNGiQB3C++MN3B4LKi6GhA8znr0QN4Nz4AAKBMGQnM3r8P7N4tmekZbd48GSQwPjs7Kevg6ir1OlxdEWbngh2ncqHA01Oo8Hw7VAcOSGbuwIESbO7VSwpyaz5LmkH3WrVKOdisLxsbCYTWqCEngZo0kYx0Q15NERgo2dNAwozTypWBunXl/Zo5M+XBCdevl/vWrXHqlHT35csyq3p1icU9ulYWeLYbVWzPY2G0BNdjYyWmp/nzZWUlu44fNNcpx3zqFNCihazYtKmUFNH3BIyDAyyWLQWqVUObiBX4t1sL9N7eHnfvyriqMyGl3w7kaIau/dzh5ydvf4qbb9BASroEBsrJjmrV9GtPagwdKn/DateWE1DNmwP58iW+bPws9K++SvEEg46uXSWIvmaN1LFJKsNck4Xev79+We5kPFZW8nmYOFFOxDx/LmVr4t+uXZMaSNHR8mVdskQC6R+ArH+aIAtgEJ2IiIiIiCiDxA+id+0qUbDLl4FDh4zbrg/NrFmSpR2/mLSGShUXONcMNJqR1GoZQBCQtty7J4MHvn0LPHgAnD0LZecuLG+2Cvk3/4rWlyej0rOtKKDcw6/uU/Amj49c1fDnn1Kyo2RJKZVw5Ypk7QL6Z/zqy9kZ+O8/yRC/eFGyhJMdFTOVfv9d0r9r1Ei87vE338j9H39I5n5SAgKA8+ehWFri+4vN8NFH8nXLk0di64cOyTmIbtOkLnq/KucREyPVdAID5S08dkyWCwkBjhwBvv9em9Sua9kyCaA3biwbT+0VDFWqSK1oAE3+HYCAw4/x88/AkP4RGOAoA2p+srIffvxR9q/X5u3sJLAPxJ2UMKTISDkB9PYtsG2b1Mr39JSzDZMnAxcuSHBUY+1a6YAcOVJfjqNmTTkRFBqa9Pfy6FE5oWNtbfjPPGUslUpqEiVWCz48XILp16/Lh/8DwSC6GdAE0e/ckb//REREREREZCDxg+g5csQVMOYAo5nn3j2p5wFI0NrVNeEyzZvL/T//6DeQYXrs2SPB3hw5JAhZoIBOhPTJEykD3qWLZEVXqCCLBdvnx8DHY+D09CY6uu3DtSrdoNjbA1evSn33kiWlrEjFihmTgezlJYH0bNmkHEP//roB07SKiIgrs5NUILRBA6nFHh4uqdpJeVfK5YR9bYyZ4YLYWKBDB4njtmoVbznN4KIXLkAFBdmyAR4eQPHikthfvboe5eQ1V9j07h1XyDy1xo6VuiwvXsBhcB8MGqhgZs31sH3zQj4XaQkgtm8v92vWGP6zfPSo9EHu3MDUqXISR6WSrPxx4+R99fGRgPnu3XFZ6EOHpi4LHZAs5M6dZXrp0sSX0WShd+2adDY8mR9NLXh9xoDIQhhENwP588vnMyoKePTI2K0hIiIiIiLKQjQ10QsWlHtNzd61a4Fnz4zRItOjVkvN7QcPUrzZpHLMCyiKlD4JD5d64kmV76pdW8pgBAVJQDAj/SmlOtC5s07wXFGkIkjJksDGjfI7ffJkyYz+9VepNjNxIuDiaoHVQbVR/MRi+Ng9xuamfyC6YtW47Q8blnGlgipUAFatkgDnggXAd9+lf5srVkhZhwIF4rKo36dSxWWjz5kj/fme6Gjg/mwJoi990wqurhJHXrUqkfMmxYvLG/zqVcIRQ/Vx/75kylpaAomMDaE3GxsJENvaSm3vv/6K+3z06iXbT60GDaSw+6NHEvQ2pJ075b5+fWDkSEnVf/xY2t2smWTC370rZYX8/CS139k57YNCdu0q99u2Jfx7eeWKZC6rVHGDBBOZMZMKov/6668oWLAg7OzsULVqVZw4cSLJZRctWgSVSqVzs7Oz01mmR48eCZZpFG/kZ3NhaRl3PMeSLkRERERERAaiKHFBdG9vua9YUUYnjIoCFi40WtNMSvPmkt1VoECyN2tfXzTu3h2WDRtKFrA+WdAbNgD//isB07lzkw4u29oCDRvK9HulI2JigN9+k5Lqa9dKJYs0e/YsbuDLvn11ZrdvL2XOg4Ml6frkSUlU1iQ5u7pKsu+9e9IeHx/g7sscaPFvX+S4cgxTOl1GwNwduFauI86ckZIkO3ZIQH7FColz/vwz8MMPEpxfu1ZiwalOJm/aFPjlF5n+9tu4EjJpoShSageQkx1WyQyt17atfI+eP5cAfjwXLgCNywfB88ERAEBU45a4fFlWSZSNDVCihEyfP5/6dmuy0KtWTX2G9ftKlow7GTFkCLBvn5yk6NUrbduztc24ki6awR/jZ8jnzSvZ+Js3y4d340Zpe+7c8vzYsWmvn1+8uPzNjImRM0zxacoytWwJFCuWtu0TmRCTCaKvXr0aQ4cOxfjx43HmzBmULVsWDRs2xNOnT5Ncx8nJCY8fP9be7iVydrJRo0Y6yyQ3sJQpY110IiIiIiIiAwsKklIVFhYSJNbo31/u583L+NIhpu7aNSkRAkjwL5mbYmsLRaWCxd69QKNGEmletizp2tyvXwODB8v0119LQC45mpIumzdrZ+3bJ9U2vvhCynG3ayf1tbt2lWZHRaXy9S5ZIu2tXFnaDwlmlywp91ZWwPjxwPHjcRVH3ufgIBc03LghMdKKFSWw/+3KEvDtXx/FS6hQsaKUlG7YUMqYdO4sMfsvvwRGjZJgfLt2UqHF3V1e+pQpEiONNy5w0gYMiMv+7dULqv37U/lGvLNvn9RYd3AA+vRJflkrq7h9TpsGREfjzh2J41eqBPhe3gQLKAj2rYJ5/3kiT54U9q15g9MTRNeceEmvIUPkSglNhn2jRrp/M1JLU9Jl7VrD/Y0JDgZOn5bp+vUTX8bBQQL48+dLhvr9+1LKJT002ejxS7o8fAgsXy7TmisUiMxcMqcQM9eMGTPQt29f9OzZEwAwd+5c/Pfff1iwYAFGjhyZ6DoqlQpubm7JbtfW1jbFZcyBj4/cM4hORESUtak/9GBNFsP+zDx8r82T0ftNUw89Xz7JfNXo2FFKbgQEALt2fVADpyWgyShu3lxKMyQjJjoaexctQr1Ll2A5f76kH3ftKoMzDh0qQdj4oz9++62MFunrC4wZk3Jb/P3lhMeFC3h87B6GzvbCqlXylIuLZDVv3SpxwWXL5JYrF9CmjXRp7dopVN9QlLhSHX374vlzSb7WJNiWLg0sXixBe31YWkogvG1biUX/+KOMsWhrK7FMzc3eXvexpoLM+fPyFj55Isn38RPwCxeWcS8rVwZy5pTYrub29u27+7Af0LPAXVS9vwZvG7fDyhKbcOiQBUqUkHLGxYrJ+5Os2bPlvnt32VFKevRAzLcTYHXvHsYW+Rvf3e2sfap/nvXAU8Clb2tAn2o2aQ2ix8TI9xYwXBDd0hJYtAgoU0ZGOe3XL33bq19fW9JFZaiSLrt3y2e4ZEkpIJ8SS8v0nQjQ0Py9PHFCBposWhSYOVNORtWuLVcDEGUBJhFEj4qKwunTpzFq1CjtPAsLC/j5+eFoMn9M3rx5Ay8vL6jValSoUAHff/89SpYsqbPMvn37kCdPHuTMmROffPIJpkyZAhcXlwx7LRmFmehERERZm42NDSwsLPD48WNky5YN1tbWsExLnU3KMGq1GlFRUYiIiICFRfIXdCqKgqioKDx79gwWFhawiR+cI4PSfHcePXqE3Llzw8bGBioD1RpOTZ9T6pjMd+T9Ui4a2bIB3bpJbefff/9wg+jR0ZKZDehduuJtnjxQT5sGywkT5L2bPVvqpX/1lRQM//xzyT4PDJT3F5DaJ/b2KW/cxQXqatVhceggptX+B6uiBkKlkgsHpkyRgLCiSI3ylSslC/zJE4mL//kn4OYmCcCtWkksPjhYKo88fy7TuS4dxOjr1xFukQ3VfuiIG19KQNrSUrLDv/1W91yLvlQqoG5duaXW27fAuXMSn9Tcbt0Cbt6UmybZN3EWWIQl2I1AVI85gh8vdEHzC5sxDeW0S7i6SsxTE1QvWlQC9B4egNOz21Bpsv41VwwkQlGAS5eAdeuAdevs0Tx4ML7DWLS7+yOmqj5FnboqDOoagnJ998gKOiOIJiOtQfQTJ6SWeq5ckgJvKN7eUnP84sW4qyLSytZWypwsWQLV2rVJZ46nhqYeemb/vcqbV/a5daucufrqK7ksBJC67ERZhEkE0Z8/f47Y2FjkzZtXZ37evHlx7dq1RNcpWrQoFixYgDJlyuDVq1eYNm0aqlWrhsuXL8PT0xOAlHJp3bo1vL29cfv2bYwePRqNGzfG0aNHk/xRGhkZicjISO3j0NBQAEB0dDSik7oELQNo9qW59/JSAbDCrVtqREfHZlo7KKH3+4ZMA/vFdLFvTBf7xvTkz58fjx8/xqNHj/Dy5UuDBQLJMBRFQUREBOzs7PTuG3t7e3h4eCA2NhaxsbrHcPzuGYaFhQW8vb213x1DUhQFb9++hb29Pb+PGcTBwQEFChQw3kkKTSb6+0F0QApsz5kj6b8PHwLvfmca3OXLwJkzEvBzcZGopouL1Cg29smbrVslCp0nj2SBp0bOnHEZ6EuWSHmPmzeB778Hpk+X16hWSxarnkG/7duBc9ea4xscRMOozTj68UD88ouMpamhUgEffyy3mTOB/fsloL5unVTv+flnuSVmCSQLfbm6E84HZAcgSb2LFhk2Fpsa9vZxr0cjOFjGVj1xQu6johJms8c9tsMN9SaUnF4dBZ7cwEnLjzC7yK+Y/bo3Hj6MO4lw+HDCff9s+QsGKQqOOTfEtLHF4OYmpWU09w4OUl5m3TopXaPxxOpzjFF+QNnYC3ixYhtydGwMLPtXMsRLlgSKFNHvxWuC6LdvS+mf7Nn1W09TysXPL20Dfybno4/kZgjt2gFLlsBi/fr0DX4KyJkMTT10QwTkU6tr17gguo2NZOuXLWu4KwGITIBJBNHT4uOPP8bH8f6LVKtWDcWLF8e8efMwefJkAEDHjh21z5cuXRplypSBr68v9u3bh3pJ/IGaOnUqJk6cmGD+jh074BBvVO7MsvPdmcTAwOwAPsH16zHYsmVrpreDEtL0DZkW9ovpYt+YLvaN6bGwsGDWaxagVquTLVURrqmrSulmY2ODAgUKICYmJsHJivSIjo7GgQMHUKtWLVhrRg4kg7G0tISVlZVxT1AkF0QvWVJqIB84IPWDx4837L5DQmRAv99+S3zkSEtLCTTHD6wXLiyZnSnW4DAQTSmXbt3iRs9MLTs7KX2hGdjwxx8lVfzRIzlRMHNmipu4e1eSWzduBAqjOb7BCNSz3Ae/LaGwcHZKcj1LS+CTT+T266+SqLtqFbB3rwSAXV3j3tr8ji/Rce5aIAYo/L++OFhNnitc2PBx2PRycZHYpP7xSVdEdzuAoKZN4XbqFIZf7YPhPQ/jzQ+/4MZDB1y/Du3t2jWJWSuvX6NbrPT/hJAh2L4u+T1oxn1t0wZo1iwnHL77DJg+HTnm/g/o2DhusFZ9s9AB6QAPD/msXLwIVKum33qGroeeUerXB3LkgOrxY+S6elUGhE2rGzekjpGNjfzdymwtWkipprt34wZh/frrpAcKJjJDJhFEd3V1haWlJZ48eaIz/8mTJ3rXM7e2tkb58uVx69atJJfx8fGBq6srbt26lWQQfdSoURgab1CF0NBQ5M+fHw0aNICTU9L/nA0tOjoaO3fuRP369WFtbY3wcBlgJCzMBh995J9px0yU0Pt9Q6aB/WK62Demi31jmjT9Uq9ePfaLiTH0d0ZzxSMZhkqlgrW1tUG/N5aWloiJiYGdnR2/j1mVJohesGDiz/fvL0H0P/+Umt1WBvgJrSiSGj10qGR5A5JmHBUVV1/kzRsgNhZ4+lRu8Z0/LxmfGX2yNSgI+PdfmdazlEuyLC0lgNqypaQ9L1smEddkfvMHBQG//CKJ6xERsommg4sg9p8isLx1A9i5XbJ59WBjAzRpIrdEzVkGxEQAZcuizojK+tXsNie5cuH46NFoevkyLMePBxYuhOPp06iwdi0qdCqcYPHIaYtgOyIU4QWKos9PDdD0qYxDGRQUdx8cLDXZ27aV91UnUfyrryTlf/9+YM8e+cwCqQuiA5LN/OiRfO71CaK/eAGcPCnTpl6GSVPSZfFi5Dt8OG5Q1rTQJMXUqCHlqDKbg4N8nxcvBiIj5W+qZvBUoizCJILoNjY2qFixInbv3o2WLVsCkMyd3bt3Y+DAgXptIzY2FhcvXoR/MpeYPXz4EMHBwXB3d09yGVtbW9ja2iaYb+gDcn1p9psjh1wuJYMnW+O9yjdkBMb6TFDy2C+mi31jutg3pon9YroM1TfsXyITkFRNdI3WrYHcuaV+97//SsArPa5fB774QgYABKQA9W+/Sap0fJGRCQt2P34sWeg7dgAzZgDDh6evLSlZulQC+R9/DBQvbrjtqlQS6KtRI9GnFQU4elSC52vXSll2QOqJz5kjFwjAsrmUh9m8We8gerLeG1A0y2bPWlhA/c03sKxWDejUSUYtrVgRWLhQAqAaajVs50nNG4dvBqNt+zScsMmXD+jSRbbdubMUd/fy0n9UVo2yZSUAr29d9F27pExQyZIZV4LJkNq3jwuiR0en/YoPY5Zy0ejaVYLogPx9MsRJRyITYjLXCQ8dOhR//vknFi9ejKtXr2LAgAEICwtDz549AQDdunXTGXh00qRJ2LFjBwICAnDmzBl06dIF9+7dQ58+fQDIoKMjRozAsWPHcPfuXezevRstWrRAoUKF0NDUL+lJAgcXJSIiIiIiMpDYWCl/ACQdRLe1jcvCnjs37ft6+1ZGpSxTRgLodnYyEub58wkD6Jr9enjI8p98IoHiwYPjSp+MHi3FsDOKosSVcjFEFroe3r6VXVasCFSvLsn60dGSfLx2rbxtJUu+W1gzqON//0md7fQ6flzKhdjbS8A3q/vkE+DsWTmR8fq1pJIPHRp3xmLLFhm91NlZSvmk1YgRckIiKEget2qV+hMUqR1cdNs2uTeXuE/9+lDy5oXtq1dQadqeWtHRUqMIMG72fZ068pkqUwZ4F8sjykpM5rRQhw4d8OzZM4wbNw5BQUEoV64ctm3bph1s9P79+zq1QV++fIm+ffsiKCgIOXPmRMWKFXHkyBGUKFECgFx6eeHCBSxevBghISHw8PBAgwYNMHny5EQzzc2Bry9w6BAQEGDslhAREREREZm5hw8lAGttLQHrpPTrB/zvf1Jn+fbtuOwmfW3ZAgwcGFc6xt9fUqp9fFLf5n79JON0/XrJJD5zRv/BFlPj2DEpju3gALRvD7VakuFfvYq7hYYmnH750hK3b1fA0aMWKFxY3iofH0lKTqqu+J07wO+/S9n5Fy9knp0d8OmnkrQff9BQrY8/lrrwL14AR46kvwa0Jgu9XTsJHH8IPDykzMqYMcBPP8kJmuPHgb//BmbPlmX69JE612lVvLjUyt64UR63bp36bWiC6BcvSoZ5cmWMFMV86qFrWFtD3akTLGfNgsXSpWl7j44dkxJQrq5AuXIGb6LeLC2BgweNt3+iDGYyQXQAGDhwYJLlW/bt26fzeObMmZiZzAAk9vb22K7545lFMBOdiIiIiIjIQDSlXAoUSH7kSB8fCcht3w788YcE1PXx8CEwZAiw7t2IjJ6eEpxMSzauhkolAd+TJyVTeNAgYNGitG0rGTF/LIAVgAvF2mH0p044ejQuwJ08CwD58d7Pd9jYSIlkHx+5+fpKlZw1a6RKjmZc1YIFgc8/l+R3F5dkdmNlJUW4ly6Vki7pCaKHhspoo4CUcvmQWFvLQK/VqgHdu8sJiTJlpLMtLOTkT3qNHAls2iRnUvQdGDS+woXlrEpYmARDCies3651+bLUT7e3N87gmmmk7tIFlrNmQfXff3K2KtkPfyI09dD9/DJ+rASiD5hJBdEpeQyiExERERERGYgmMzypUi7xDRggQfQFC4BJk6TcSmLUaqk7smABsGGD1Da3tAS+/BKYMMEwWeO5cgHLl0vphMWLpXzDp5+ma5NBQTLW55EjwJkDb7D51CpkBzDwTC/EzyvNlg3IkUP35uQUN+3oGIuAgOvIlq0o7tyxRECAnKuIigJu3JBbYho0kHitv3/y5zN0NG8eF0SfNi3tL37lSiA8XLKmq1dP+3bMWcuWclVD27bAuXMyr1UrqWGeXlWryiX1uXOnonPjsbICSpWS8kXnzycfRNckUtauLYF3c1GmDEJ8fOAcECCfx9SevNDUQzf1gVSJzByD6GZEc7Ufg+hERERERETplJogepMmkkkbGCiZ5e8Hre/elQEUFy2Kq7MOSFD2t98ku9eQataUGusTJwL9+wMffZTq8jCRkVJafeNG3ZKh3bEW2fEGAZaFkKdFTcyoIS+jXDnJKE9OdLQaW7bchL9/YVhbS8A0Nlbettu3ZT8BATL94AFQqZJknhctmrqXD0AChtbWwM2bMmBrmjaCD2NAUX34+spZlGHD5ETQ+PGG23ZaMtDjK1s2Lojetm3Sy5lbKZd4HnzyiQTRFy9OXRD95Uu5MgUw7qCiRB8ABtHNiCYTPTAQiIgwrxOrREREREREJiU1QXQrKwmyTpggA4x++qmMhLlhg2Sd794dt6yzswxO2asXUL58xgVmx44Fdu2SFPJOnSTb19par1XDwiTRWFMFQqWSZN/q1YEJexcA1wHvSb2wdnT6225pKRVzChQA6tZN9+biODnJBnfskGz0ESNSv40zZ4DTp+XsQNeuBmycmbK3l5M+pkafwUXDw4EDB2TaDIPoD2vWRKlFi6A6dUrK0mhH0U3Bnj1yBUzx4lIyiogyDIslmRFXV7n6T1HijveIiIiIiIgoDTQ10QsW1G/5Pn3iBs7r1g1wd5dg+e7dEoWuX19KMTx+DPzyi4yImZGZzVZWUtbF2Rk4cULvzOGQEGnqzp1SnmXFCimBfeEC8PtXN5D3+kHAwgKq7t0yru2G0ry53P/zT9rW12Sht24tP7jJNOkTRD9wQC6vyJ8fKFYsc9plQFE5ckBp3FgeLF6s/4qaUi7MQifKcAyimxGVinXRiYiIiIjIRJw7F1dGwBylJhMdkHIumqDt0qXAq1dSM3rCBNnWjh1Ax46Ze8mwl1dcIPiHHyQrNRlPnkgp9aNHJfa+a5cksTs7v1tAM0hpo0byek1d06Zyf/gw8Px56tYNC5OTEMCHN6CoudGUQ7p/X8qXJCZ+KRczLcuj7vbuxNXSpUBMTMorKArroRNlIgbRzQyD6EREREREZFRqNTB5smRaV6kiRa3DwtK/3WvXgFGjpC5zRouMlDqZgP5BdECyvUuXlnIuu3ZJge/x4w0zAGNatW0rQWBFAbp0STKYfP8+UKuWJPPmzQvs3y+l1LViYuKC6L16ZXizDcLLS7KU1Wpgy5bUrfv338Dr1/Iju06dDGkeGYizc9x37MKFxJcx43roGkrjxoCLi4z0q6m1lJzbt+WKGmtrGUyViDIUg+hmhkF0IiIiIiIymuBgGWRz3DgJ2gLA77/LqJPHjqVtm+HhwJgxkm36ww9SmLtlS+DKFUO1OqH796X99vZAnjz6r1e2rATxli8H6tUDLEzkJ/XMmVLC4vFjCYBr+uadGzeAGjXkvkABqUiTYKzT7dtlfVdXoFmzzGt7eqW1pEv8AUVNpR8pacmVdHnwALh6VfqxXr3MbZch2dhIiSgg7oRWcjSB9mrVAEfHDGsWEQn+pzAzmiB6/NHTiYiIiIiIMtzx4zJQ5rZtUrJk4UIJ4nh6ArduSfB77FggKkr/bf73nwyg9/33QHS0bN/CAti0STK+e/WSAJmhxa+HbqalH3RkywasWiVBuH/+AX79VfvU+fNAzZryNhYtKuOPFi6cyDYWLJD7rl1lO+ZCE/Dftk2uMNDHpUtS08bKCujRI8OaRgakCaKfO5fwOU0WetWqQM6cmdakDNG9u9xv2pR06RoNlnIhylQMopuiyEiotm5FwUQuR2MmOhERERERZSpFkYEyNZHYQoUkoN6jB+DnB1y8KGVE1Grgu++kRsjly8lv88EDGcyxaVMJaHt6Ahs2AKdPS4CzZUvZ3sKFEvEdMUJGvzSU1NZDNwdlywLTpsn08OHA2bM4ckQqlTx9KhcLHDgg4y4m8OwZsHmzTJtLKReNihVlkNc3b4B9+/RbR5OF3ry51LYh05dcJnoWKOWiVb48UKqUnBD6+++kl4uJiRsDgYOKEmUKBtFNUWwsrFq0QNk//pDLJePRBNHv3JFjSiIiIiIiogzz+rXU/x40SDLF27QBTp3SrQXi7CwD4a1ZA+TKBZw9K4HN6dMT/miJjpZAb/HiEjS3tJSA79WrEjhXqeKeO3JEinhHRso6Pj5S7iU8PP2vKysG0QFg4EA5MREZiZhqNbGi7h8ICVFQvTqwd28ylWs0AxlWriwBPHNiYRGXja5PSZeICHm9AAcUNSeaIPrly7qDbsbEyPgEQNYIoqtUcVdHJFfS5cQJIDRU/uZWqJAZLSP64DGIboocHKC8GwlddeuWzlP588sVZ/HHwSEiIiIiIjK4y5dl4NBVq+RHyMyZEijPkSPx5du2lSxyf3/5wTJ8OPDJJ3GlUw4flmDPiBEyEGn16hJw/+mnxOv5fvyxZBb/95+Udnn1SgYeLVwYqvnzoYqNTftry6pBdJUKWLQIz0rVgVVEGH6J+gzHXJtix+LHcHZOYh1FAebPl2lzy0LX0ATRN2+Wch+7dwOrVwO//QZMmgQMHiy1phs2lBM8L19KcXhm8JoPHx/5OxEZCVy/Hjf/5EkgJETKuFSubLTmGVTnznKC8dgx3dcan6aUi5+fLEtEGY5BdBOlFCokE+8F0S0tpWwfwJIuRERERESUQZYvlwD6tWtAvnzA/v3AkCEp1w93dwf+/ReYN0/qdO/fL1nrrVvLyJaXLgEuLhK0PXBAguPJUakkKH/2LLBkCeDlBTx6BKsBA1B+zpy0v774NdGzkNevga//5wKPK7sxFNMRZWGLqs+3wKFqaWDt2sRXOnlSBnG1swM6dszcBhtKvXoySOyDB1IOw89PXssXXwDjxwNz5gArVkjgUTNg7aBBDD6aEwuLuL8X8Uu6aEq5ZKVgspsb0KiRTC9enPgymkFFeSKIKNMwiG6q3tVteT8TPd5TDKITERERkcH9+uuvKFiwIOzs7FC1alWcOHEiyWWjo6MxadIk+Pr6ws7ODmXLlsW2bdt0lpkwYQJUKpXOrVixYhn9MiitXr0C+veXGufh4RKYOnMGqFZN/22oVEC/fhLoqlZNIrsbNshzvXtLZmWvXhIU05elpQx4ef068L//AQA8Dh3SfyDJ92WxTHRFkRhx0aKS2B+jtkBo76GwOHNagsrBwUC7dtKvISG6K2sGFG3bFkmnq5s4e3sJitvZSY3zkiWB2rXl5E2/fnIFw/TpEpD891/5TA8bZuxWU2qVKyf38YPomv85WaGUS3yaAUaXLgXev+rm1SsZlwJgEJ0oE1kZuwGUOE0muiqRSDmD6ERERESUEVavXo2hQ4di7ty5qFq1KmbNmoWGDRvi+vXryJNIMeWxY8di2bJl+PPPP1GsWDFs374drVq1wpEjR1C+fHntciVLlsQuTc1aAFZW/BliciIipPTF999LwFWlAr79Fhg3Lu3Znb6+km0+c6ZkpI8cKSVc0sPWFhgxAsqPP8IyOBjKxYtS9iU1wsJkpE0gSwTRL1yQUugHD8pjX19g9mygSRMAKCklISZNAqZOlSsM9u+XAVv9/OREycqVsqK5lnLR+N//tCdYKIt6f3DRFy/kSgog6wXRmzWTk1oPH8qABn5+cc/t3SuB9SJF5OocIsoUzEQ3UUmVcwEYRCciIiKijDFjxgz07dsXPXv2RIkSJTB37lw4ODhggSZT9T1Lly7F6NGj4e/vDx8fHwwYMAD+/v6YPn26znJWVlZwc3PT3lxdXTPj5ZA+YmMlO7doUcnMDQ4GihWTEgkTJ6a/PIJm4NB//kl/AF1DpYLyrvaxKpkrJZKkKeWSI4fUUTZTISFS6rt8eQmg29sD330nFXMkgP6OjQ0wZYrUpC9USIJy9evLysuWyeCE3t6SuU1kyt4Pou/aJYMXlygBeHoar10Zwc4O6NRJpt8fYFRTD71Bg0xtEtGHjkF0E6XEL+eiKDrPMYhORERERIYWFRWF06dPwy9etpuFhQX8/Pxw9OjRRNeJjIyEnZ2dzjx7e3scOnRIZ97Nmzfh4eEBHx8fdO7cGffv3zf8C6DUURQpa1GuHNCjB3D/vtQ+/+sv4OJFky8RoFSqBCCdQXQzrYeuVksFliJFpNS3Wi2VWK5dA0aPlthboj76SAbdHDBAHs+ZA3z2mUz37Jm68jpExlC6tFwlExQkV5No6qFntSx0DU1Jl/Xr5WSXBoPoREbB6yhNlSaIHhIilyi5uLz/FIPoRERERGQwz58/R2xsLPLmzaszP2/evLh27Vqi6zRs2BAzZsxArVq14Ovri927d2P9+vWIjVe/tWrVqli0aBGKFi2Kx48fY+LEiahZsyYuXbqE7NmzJ7rdyMhIRMardR36LngQHR2N6Ojo9L5UvWn2lZn7zAyqo0dhMXo0LA4fBgAozs5Qf/011F98IenMigKY+GuOrVABlgBw8mSq+8fi1i1YAlB7eSHWxF/n+06fVmHwYAucPCkB76JFFcyaFYt69STxKsWXY2MDzJ4NVZMmsOzbF6rHj6GoVIj59FOD9HlW/c5kBVmib2xsYOXrC9WtW4g5fRqW27dDBSCmXj0oZvy6kuyb8uVhVbQoVNevI2bVKig9ewIBAbC+fRuKlRViqlc3+b/V5ixLfGeyKEP3jb7bYRDdVDk44K2LC+yDg4GbN3WC6D4+ch8SArx8adZXIBIRERGRGZs9ezb69u2LYsWKQaVSwdfXFz179tQp/9K4cWPtdJkyZVC1alV4eXnh77//Ru/evRPd7tSpUzFx4sQE83fs2AEHBwfDv5AU7Ny5M9P3mRGyP3iA4kuXwv1d9nasjQ0CmjTBzTZtEO3oKHV2zYT1mzfwB2Bx8ya2/f23tF9PJffsQSEAAQAub9mSUU00mKdP7XHihBtOnHDHxYuuUBQV7Oxi0LHjNTRpEoDISAVpeRnWP/6IwuvXI8zdHfcuXZI6MAaSVb4zWZG5902lPHmQ79YtBE6fDq/AQMTa2GBrWBjUZvBdTklifVO4ShWUuH4dIbNn43DevPDavh3lAAQXKYLDmoEQKEOZ+3cmKzNU34SHh+u1HIPoJuyNu7sE0W/dkkvv3nFwANzdgcePJRv93ZWMRERERERp5urqCktLSzx58kRn/pMnT+Dm5pboOrlz58bGjRsRERGB4OBgeHh4YOTIkfDRZH0kwtnZGUWKFMGtRMb+0Rg1ahSGDh2qfRwaGor8+fOjQYMGcHJySuUrS7vo6Gjs3LkT9evXh7W1dabtN10UBXj8GKobN6C6cQO4cQOq69dl+u5dqBQFioUFlB49oB47FgU9PVHQ2G1Og+joaLz55hs4Pn6MBs7OUFJR1sDyXX1h77p14eXvn0EtTDtFAc6eBTZvtsC//1rgwgWVzvOffqrG1KkK3N2LAiiavp116AAAKJm+rWiZ5XfmA5FV+sbi3DngyBEUOHAAAKCqUweNWrUyapvSK9m+KVsWyvLlcL1yBf5Fi8Jy8WIAQM527eBvgn+/spKs8p3JigzdN6HxyyUlg0F0Exbm7o7cly5JJvp7fH0ZRCciIiIiw7GxsUHFihWxe/dutGzZEgCgVquxe/duDBw4MNl17ezskC9fPkRHR2PdunVo3759ksu+efMGt2/fRteuXZNcxtbWFra2tgnmW1tbG+WHrLH2q5fbt4GVK6Ug9vXrcnv9OunlW7WC6rvvoCpe3OwHyAoqXBiOjx/D6vTp90bSTMG9ewAAS19fWJpIv0ZGyoUAmzfLLTAw7jkLC6BGDaB5c6BFC6BQIQuY+vBmJv2d+cCZfd9UqAAAUL0rv2DRqBEszPn1xJNo3xQsCPj5ATt2wHrZMu0VQ5aNG5vM36+szuy/M1mYofpG320wiG7CwtzdZSKJIPqhQ6yLTkRERESGM3ToUHTv3h2VKlVClSpVMGvWLISFhaFnz54AgG7duiFfvnyYOnUqAOD48eMIDAxEuXLlEBgYiAkTJkCtVuPrr7/WbnP48OFo1qwZvLy88OjRI4wfPx6Wlpbo1KmTUV5jltOlC3DsmO48CwupAVm0qNyKFZP74sWB3LmN084MEFKkCPIfOACkdnDRO3fk3tvb8I1KpSdPgPHjgRUrdM99ZMsmYyW2aAH4+wOursZrI5FJKVtW93FWHVQ0vu7dZTDRGTOAt28BZ2dmUxIZAYPoJizMw0MmErnUVXOFLIPoRERERGQoHTp0wLNnzzBu3DgEBQWhXLly2LZtm3aw0fv378PCIi4DNiIiAmPHjkVAQAAcHR3h7++PpUuXwtnZWbvMw4cP0alTJwQHByN37tyoUaMGjh07htxZKJhrNJGRwKlTMj1uHFCunATLfX2BRDL5s5qXRYrIxPHjUgNFpUp+BUAGlgoJkemCBTOoZSmLjARmzwamTIkLnru7S7Z58+bAJ58AdnZGax6R6cqfX4LIISGAp6ecHMzqWrYEnJwATcmJevUAS0ujNonoQ8Qgugl7o6k9efNmgoNCX1+5ZxCdiIiIiAxp4MCBSZZv2bdvn87j2rVr48qVK8lub9WqVYZqGr3v0iUgJgZwcQEmTNAviJyFvPL2hmJtDdXz55Jdnkwtfq27d+Xe1RVIxWCkhqIoUq5l2LC433KVKgE//QTUqiUXERBRMlQqyUbfv1+y0D+Ev3sODkD79sBff8njVIwBQUSGw3/RJixcU84lJAQIDtZ5jkF0IiIiIqIP3Nmzcl+hwocRSHqP2toaiqa0w/Hj+q1kxFIuly4B9etLUunt25J5vmiRNL1OHQbQifTWqxfg4QH072/slmSeHj3ipuvXN1oziD5k/DdtwmJtbaF4esqD90q6aILogYFAREQmN4yIiIiIiIzvzBm5L1/euO0wIqVKFZnQty66EYLoz58Dn38uybO7d0ulndGjgRs3pNQxg+dEqdStmwRDPqS64NWqySUsY8eaxHgORB8ilnMxcYqvL1QPH0pJl48+0s53dQWyZ5f6eXfufBhlwIiIiIiIKB5NEL1CBeO2w4iUypVlwgQz0aOjgd9+k0o7mjLsbdpI6RbGwIgoVVQqYNo0Y7eC6IPGc96mrlAhuX8vE12lYkkXIiIiIqIPVkwMcP68TH/IQXRNJvqZM0BUVMoraGqiZ+CgotevAxMnSqLTkCESQC9bFti7F1i7lgF0IiIic8RMdBOnaCLlN28meM7XFzh3DggIyNw2ERERERGRkV27JnUds2ePy675EBUqBOTMCbx8CVy4kHJ5hwzKRL93D1i9Gli5Un6jaeTODUyZAvTuDVhaGnSXRERElIkYRDdxiiYTPYkgOsBMdCIiIiKiD078eugfclFtlQqoUgXYvl3qoicXRFcUgwbRg4KANWuAVauAI0fi5ltZAQ0aAB07yiCi2bOne1dERERkZAyimzidILqiyEHiOwyiExERERF9oFgPPU7VqhJEP35cRvBMyrNnQHi4THt5pWlX4eGSbb5ypZRnUatlvkoF1KkjgfPWrWUMKyIiIso6GEQ3dT4+cv/qFRAcrHM0xiA6EREREdEH6uxZuS9f3rjtMAVVq8p9SoOLauqhe3gAtrap2sWrVzJI6MyZEovX+OgjCZy3ayebJSIioqyJQXRT5+AAeHoCDx/K4KLxguia+PqdO5IB8SFfxUlERERE9MFQq+OC6MxEBypXlvvr12UUT2fnxJdLQymX58+BWbOAX36RQDogY5L26yfBcw4SSkRE9GFg2NUcJFEXPX9+qbcXGQkEBhqhXURERERElPlu3wZevwbs7IBixYzdGuPLnTsuw+jkyaSXS0UQPTAQ+Oorqfry3XcSQC9eHFiyRH6WjRrFADoREdGHhEF0c1C4sNy/F0S3spIsCIAlXYiIiIiIPhiaeuhly8qPAtKvpIseQfTbt4HPPpOY/KxZUgO9QgVg3Trg0iWga1e+5URERB8iBtHNgSaIfutWgqeSSFInIiIiIqKsioOKJqRPEF1TE12TiRTPzZtAly5AkSLAH38AUVFAzZrAtm3AqVMyWCjLZxIREX24eBhgDpKJlBcvLvdXr2Zie4iIiIiIyHg0QXQOKhqnShW5P3ECUJTEl0kkEz0sDBg9GihVCli+XMrNN2oEHDggt4YNAZUqg9tOREREJo8XopmD+OVcFEXnKI5BdCIiIiKiD4iiMBM9MeXLA9bWwNOnwL17CbPN1WqZDwDe3lAUYO1aYOhQ4OFDmd2oETBlClCxYqa2nIiIiMwAM9HNgWaQnFevgOBgnadKlJD7K1cyuU1ERERERJT5HjwAXryQwtylShm7NabDzk5qxAOJl3R5/FhqtFha4kqoJ/z8gPbtJYDu7Q1s2gRs2cIAOhERESWOQXRz4OAAeHrK9HslXTSZ6PfvA2/eZHK7iIiIiIgoc2my0EuVAmxtjdsWU5NcXfR3pVyCs+VH2YpW2LNH4u4TJwKXLwPNm7NsCxERESWNQXRzkcTgorlyAXnzyvS1a5ncJiIiIiIiylws5ZK0+HXR41EU4NAyCaKfD/VGTAzQqpWUxBw3DrC3z+yGEhERkblhEN1ccHBRIiIiIiJiED1pmkz006eB6GgAwMWLQM2awI557zLRnbyxbRuwfn3CsulERERESWEQ3VwkkYkOsC46EREREdEHQxNEL1/euO0wRYULA87OQEQEcPEinj0DatcGDh8GClndBQC0+sobDRsatZVERERkhhhENxfMRCciIiIi+rA9fiw3lSpuEE2KY2GhU9Ll22+Bly+B0qWB9pUlE92qUEHjtY+IiIjMFoPo5kKTiX7zphT1i4eZ6EREREREH4CzZ+W+WDEgWzbjtsVUvQuiB289jj/+kFm//QbYPZIgOry9jdQwIiIiMmcmFUT/9ddfUbBgQdjZ2aFq1ao48d6AMPEtWrQIKpVK52ZnZ6ezjKIoGDduHNzd3WFvbw8/Pz/cTCST2yz4+sr9q1dAcLDOU5pM9Nu3gcjITG4XERERERFlDk0QnfXQk/auLvrrXcehKEDHjkCNqtHAgwfyPIPoRERElAYmE0RfvXo1hg4divHjx+PMmTMoW7YsGjZsiKdPnya5jpOTEx4/fqy93bt3T+f5H3/8ET///DPmzp2L48ePI1u2bGjYsCEiIiIy+uUYnr094Okp0++dCHBzA3LkANRq4MYNI7SNiIiIiIgyHgcVTdm7IHqB8GvIa/cKP/4I4OFD+bFkays/noiIiIhSyWSC6DNmzEDfvn3Rs2dPlChRAnPnzoWDgwMWLFiQ5DoqlQpubm7aW968ebXPKYqCWbNmYezYsWjRogXKlCmDJUuW4NGjR9i4cWMmvKIMEL+kSzwqVVxJF9ZFJyIiIiLKohhET1F4tty4b+kNCyj4qcMp5M8P4M67Ui5eXlI3nYiIiCiVTOIIIioqCqdPn4afn592noWFBfz8/HD06NEk13vz5g28vLyQP39+tGjRApcvX9Y+d+fOHQQFBelsM0eOHKhatWqy2zRpmsFFb91K8JSmpAvrohMRERERZUEvXgB378p0uXLGbIlJmzYNOBIrddE7eB+XmXdYD52IiIjSx8rYDQCA58+fIzY2VieTHADy5s2La9euJbpO0aJFsWDBApQpUwavXr3CtGnTUK1aNVy+fBmenp4ICgrSbuP9bWqeS0xkZCQi4xUWDw0NBQBER0cjOjo6Ta8vLTT7ir9PCx8fWAJQX7+O2PfaUrSoBQBLXL6sRnR0bKa180OUWN+Q8bFfTBf7xnSxb0wT+8V0Gbpv2MeUKpp66D4+gLOzUZtiqh48AH74AfgMVdERq2FzhkF0IiIiMgyTCKKnxccff4yPP/5Y+7hatWooXrw45s2bh8mTJ6d5u1OnTsXEiRMTzN+xYwccHBzSvN202rlzp3ba7dUrVAXw6swZHNiyRWe516/zAPgYJ0++xpYt+zK1jR+q+H1DpoP9YrrYN6aLfWOa2C+my1B9Ex4ebpDt0AeCpVxS9PXXwNu3QGTZqsB5AMePA4oSl8HPIDoRERGlkUkE0V1dXWFpaYknT57ozH/y5Anc9Bz4xdraGuXLl8etd6VONOs9efIE7u7uOtssl8zlj6NGjcLQoUO1j0NDQ5E/f340aNAATk5O+r6kdIuOjsbOnTtRv359WFtby8wCBYAffoDzs2fwb9xYiqG/U6IEMGUK8PixExo08IeVSfRs1pRo35DRsV9MF/vGdLFvTBP7xXQZum80VzwS6YVB9GQdPAisWiU/kT6bWx6oaQU8eSLp6ZpM9IIFjdpGIiIiMl8mEWq1sbFBxYoVsXv3brRs2RIAoFarsXv3bgwcOFCvbcTGxuLixYvw9/cHAHh7e8PNzQ27d+/WBs1DQ0Nx/PhxDBgwIMnt2NrawtbWNsF8a2tro/yQ1dlvsWIAANWrV7B+9QrInVu7nK8v4OAAhIer8PChtXYMUso4xvpMUPLYL6aLfWO62Demif1iugzVN+xfShVNORczC6KHhgKjRgH79wMVKwL16wN+foCeuVJ6iY0FvvxSpvv2Bcp+ZA+UKSMnHo4fZzkXIiIiSjeTCKIDwNChQ9G9e3dUqlQJVapUwaxZsxAWFoaePXsCALp164Z8+fJh6tSpAIBJkybho48+QqFChRASEoKffvoJ9+7dQ58+fQAAKpUKQ4YMwZQpU1C4cGF4e3vj22+/hYeHhzZQb3bs7QFPT+DhQxlcNF4Q3cJCYuxnzsjgogyiExERERFlEa9fAzduyHT58sZtSyrs2gX07g3cvy+PL18GliyR6VKlJKBevz5QqxaQLVva97NwoZxjyJFDrs4FAFStKj+O9u8HHj+WeQyiExERURqZTBC9Q4cOePbsGcaNG4egoCCUK1cO27Zt0w4Mev/+fVhYWGiXf/nyJfr27YugoCDkzJkTFStWxJEjR1CiRAntMl9//TXCwsLQr18/hISEoEaNGti2bRvs7Owy/fUZTOHCEkS/eROIVxMeAIoXl+PEq1eBFi2M1D4iIiIiIjKs8+eltne+fECePMZuTYpev5b65HPnymMfH2D8eEn22bVLfrNcuiS3mTMBa2ugWjXJUG/QAKhUSZKE9PHqFTB6tExPmBAvz6hqVeD334F16+RxtmyAi4shXyYRERF9QEwmiA4AAwcOTLJ8y759+3Qez5w5EzNnzkx2eyqVCpMmTcKkSZMM1UTjK1wY2LtXMtHfozl/cOVKJreJiIiIiIgyjhnVQ9+7F+jVK24sz4EDgR9+0M00f/4c2LMH2LlTbvfuScL4/v3At9/KFbZDhgBdu0rJyuR8950Fnj2Tdb74It4TVavKfVCQ3Ht764wpRURERJQaep7fJ5NRqJDc37yZ4KnixeX+6tVMbA8REREREWUsMwiiv3kjAfNPPpEAesGCEiifMydhqRZXV6B9e+DPP6Vc+c2bwG+/Aa1aAY6OwLVrQP/+QIECwJgxwKNHie8zMNARv/wiP2k1Ge1aRYpIfRcNlnIhIiKidGAQ3dxoip0nEkTXZKJfvQqo1ZnYJiIiIiIiyjgmHkQ/cAAoWxb49Vd53L8/cOECULduyuuqVJInNGAAsH49EBgIzJghQfjgYOD772W6a9e4t0Fj/vxSiIlRoWlToFGj9zZsYQFUrhz3mEF0IiIiSgcG0c2NJhP91i2pixiPr69kX4SFSdl0IiIiIiIyc2/fxtVrNLEgelgY8OWXQO3aQECAZI7v3CmlyLNnT9s2nZyAr76Snzvr1gE1agDR0cCyZUDFirKvjRuBf/9V4cyZvLC2VjB9ehIb05R0ASQST0RERJRGDKKbG19fuX/1SooJxmNlFZeozrroRERERERZwKVLQGysjJiZL5+xWwNAssxHjJD8np9/lnl9+wIXL8rgoIZgaQm0bg0cPAicPAl8+qn83jlwQMq+tGljCQAYNEiNIkWS2Ej8IDoz0YmIiCgdGEQ3N/b2QP78Mp3M4KKsi05ERERElAVoapiUL2/UgTEfPQKmTZOyLWXLynRQEODpCWzbBvzxh2SRZ4RKlYDly6V++siRQM6cgKKo4OwcgdGjk6ljWaVK3DSD6ERERJQOVsZuAKVBoULAgwdSF/3jj3We4uCiRERERERZiBHroYeFARs2AEuXArt2xY27ZGMDNG0qdcr9/eVxZvD0BKZOBcaOBTZtikFIyGE4OdVKeoW8eYE2bWSkU80PJSIiIqI0YBDdHBUuDOzdm+zgoiznQkRERESUBRghiH7wIPDXX1KTPCwsbn61akC3bkC7dkCuXJnWnASyZQPatVOwZcublBdeuzbjG0RERERZHoPo5ij+4KLv0SRYXLki444a8YpPIiIiIiJKj+hoKUAOZFoQff58oE+fuMe+vpJx3qVL3PBMRERERB8aBtHNkWb00EQy0YsUASwsgJcvgadP5QpGIiIiIiIyQ1euAFFRQI4cgI9Phu/uwAFgwACZ7tQJGDQI+OgjJuYQERERcWBRc6QJot+6Jenm8djbx42Zw7roRERERERmLBMHFb1zR8qHR0cD7dvLQJ4ff8wAOhERERHAILp50mShvHoFPH+e4GnWRSciIiIiygLOnpX78uUzdDevXwPNm8tPiwoVgIULGTwnIiIiio9BdHNkbw/kzy/TiZR00dRFZyY6EREREZEZy4RBRWNjgc6dgUuXADc3YNMmwMEhw3ZHREREZJYYRDdXyQwuykx0IiIiIiIzFxsLnDsn0xkYRB87FvjnH8DWFti4EfD0zLBdEREREZktBtHNVTKDizITnYiIiIjIzN28CYSFyVWoRYtmyC6WLQN++EGm588HqlbNkN0QERERmT0G0c2VHkH0x4+BkJDMaxIRERERERmIppRLuXKApaXBN3/sGNCnj0yPGiUlXYiIiIgocQyim6tkyrlkzx53GSaz0YmIiIiIzFAG1kN/8ABo2RKIjARatACmTDH4LoiIiIiyFAbRzVX8THRFSfC0JhudddGJiIiIiMyQJohevrxBNxsWJoHzJ0+A0qWBpUsBC/4qJCIiIkoWD5fMla8voFIBoaHA8+cJntYMLspMdCIiIiIiM6IowJEjwOnT8tiAmehqNdCjB3D2LODqCmzeLFexEhEREVHyGEQ3V3Z2cTVbOLgoEREREZF5e/wY+PFHOZCvXl2SZbJnB0qWNNguJk8G1q4FrK2B9euBggUNtmkiIiKiLI1BdHOWzOCimkx0lnMhIiIiIjJR0dHAxo1A8+ZA/vzAN98A168DDg6SMn7gAGBjY5BdrV8PTJgg07//DtSsaZDNEhEREX0QrIzdAEqHQoWAPXsSHVxUk4l+757UPcyWLZPbRkREREREibtyBViwQAqSP30aN79aNaBXL6B9e4PWWbl7VzYLAEOGAL17G2zTRERERB8EBtHNWTKZ6K6uQO7cwLNnksxiwFKKRERERESUFs+eAW3aAAcPxs3Lmxfo3h3o2RMoVszgu4yOBjp1Al69Aj76SCrGEBEREVHqMIhuzjRB9EQy0QHJRn/2TOqiM4hORERERGRkW7dKAN3KCmjaVNLDGzWSIuUZZNw44NgxIEcOYOXKDN0VERERUZbFILo5K1RI7m/eBBQFUKl0ni5RQsoosi46EREREZEJCAyU+08/BRYvzvDd7dgB/PCDTP/1FwcSJSIiIkorDixqznx9JXAeGiop5+/R1EW/ejWT20VERERERAk9eiT3+fJl+K6CgoCuXWW6f3+gbdsM3yURERFRlsUgujmzswM8PWU6kZIuJUrIPTPRiYiIiIhMQCYF0dVqCaA/fQqULg3MmJGhuyMiIiLK8hhEN3fJDC6qyUS/dQuIisrENhERERERUUKaILqHR4bu5scfgV27AAcHYPVqwN4+Q3dHRERElOUxiG7ufHzk/s6dBE95eADZswOxsYnG2ImIiIiIKDNlQhD96FFg7FiZnjMnLrGGiIiIiNKOQXRz5+0t94kE0VWquJIurItORERERGREajXw+LFMZ1AQ/eVLoFMnSaLp1Ano2TNDdkNERET0wWEQ3dwlE0QH4jJPWBediIiIiMiIgoOB6GiZdnMz+OYVBejbF7h3Ty5WnTtXkmqIiIiIKP0YRDd3KQTRmYlORERERGQCNKVc8uQBrK0Nvvl584B162TTq1cDTk4G3wURERHRB4tBdHOnqYkeGAhERiZ4WpOJziA6EREREZERZWA99AsXgCFDZPqHH4BKlQy+CyIiIqIPGoPo5i53bsDBQa7fvHcvwdOaTPRr16Q2IhERERERGUEGBdHDwoCOHSWfxt8/LphORERERIbDILq5U6mSLeni5QXY2clB9d27mds0IiIiIiJ6J4OC6MOHy1Wn7u7AokWABX/hERERERkcD7GyAk1Jl4CABE9ZWgLFisk0BxclIiIiIjKSwEC5N2AQ/coV4I8/ZHrZMrlIlYiIiIgMj0H0rCCFwUVZF52IiIiIyMgyIBN97FhArQZatQI++cRgmyUiIiKi9zCInhWkEETX1EVnJjoRERERkZFoguj58hlkcydOABs2SPmWKVMMskkiIiIiSgKD6FkBM9GJiIiIiEybgTPRx4yR+65d45JmiIiIiChjMIieFSRTEx2IO6i+ehVQlExqExERERERiZgY4MkTmTZAEH3PHmDXLsDaGpgwId2bIyIiIqIUMIieFWgy0V++BF69SvB0oUKAlRXw+nXceEZERERERJRJnj6V4uWWluke/VNRgFGjZPqzz4CCBdPfPCIiIiJKHoPoWYGjI+DqKtOJlHSxtpZAOsC66EREREREmU5TysXNTQLp6bBpk9RDd3CQgUWJiIiIKOMxiJ5VpKKkCxERERERZSID1UOPjY2rhT5kCJA3b/qaRURERET6YRA9q9BzcNHLlzOpPUREREREJAwURF++XK4szZkTGDHCAO0iIiIiIr0wiJ5VpBBEL1dO7s+cyZzmEBERERHROwYIokdFAePHy/Q33wDOzulvFhERERHpx6SC6L/++isKFiwIOzs7VK1aFSdOnNBrvVWrVkGlUqFly5Y683v06AGVSqVza9SoUQa03ASkEESvXFnuL1wAIiMzqU1ERERERGSQIPqffwJ37wLu7sCgQYZpFhERERHpx2SC6KtXr8bQoUMxfvx4nDlzBmXLlkXDhg3x9OnTZNe7e/cuhg8fjpo1ayb6fKNGjfD48WPtbeXKlRnRfONLoSZ6gQIy9mh0tATSiYiIiIgokwQGyn0ag+hhYcDkyTL97bcyqCgRERERZR6TCaLPmDEDffv2Rc+ePVGiRAnMnTsXDg4OWLBgQZLrxMbGonPnzpg4cSJ8NEHk99ja2sLNzU17y5kzZ0a9BOPSZKLfvQsoSoKnVSqgUiWZPnUq85pFRERERPTBS2cm+s8/A0+eSN5M794GbBcRERER6cXK2A0AgKioKJw+fRqjRo3SzrOwsICfnx+OHj2a5HqTJk1Cnjx50Lt3bxw8eDDRZfbt24c8efIgZ86c+OSTTzBlyhS4uLgkuc3IyEhExqt3EhoaCgCIjo5GdHR0al9ammn2pfc+3d1hZWEBVUQEoh88kOs831OhggW2bbPE8eNq9OkTa8jmflBS3TeUKdgvpot9Y7rYN6aJ/WK6DN03ptrHv/76K3766ScEBQWhbNmymDNnDqpUqZLostHR0Zg6dSoWL16MwMBAFC1aFP/73/8SlFBMzTazJE0QPV++VK/68iXw448yPWkSYGNjwHYRERERkV5MIoj+/PlzxMbGIm/evDrz8+bNi2vXriW6zqFDhzB//nycO3cuye02atQIrVu3hre3N27fvo3Ro0ejcePGOHr0KCwtLRNdZ+rUqZg4cWKC+Tt27ICDEa6b3Llzp97L1ndxgcOzZzi2YgVeFC+eyBJuAKpi377X2LJln6Ga+MFKTd9Q5mG/mC72jeli35gm9ovpMlTfhIeHG2Q7hqQpsTh37lxUrVoVs2bNQsOGDXH9+nXkyZMnwfJjx47FsmXL8Oeff6JYsWLYvn07WrVqhSNHjqB8+fJp2maWExkJPH8u02nIRP/xRyAkBChdGujUybBNIyIiIiL9mEQQPbVev36Nrl274s8//4Srq2uSy3Xs2FE7Xbp0aZQpUwa+vr7Yt28f6tWrl+g6o0aNwtChQ7WPQ0NDkT9/fjRo0ABOTk6GexEpiI6Oxs6dO1G/fn1YW1vrtY5liRLA/v342M0Nir9/gufLlQO+/x548MAJder4s5ZiGqWlbyjjsV9MF/vGdLFvTBP7xXQZum80VzyakvglFgFg7ty5+O+//7BgwQKMHDkywfJLly7FmDFj4P/u2HPAgAHYtWsXpk+fjmXLlqVpm1lOUJDc29gAuXKlatXHj4HZs2V6yhTAwmSKcRIRERF9WEwiiO7q6gpLS0s8efJEZ/6TJ0/g5uaWYPnbt2/j7t27aNasmXaeWq0GAFhZWeH69evw9fVNsJ6Pjw9cXV1x69atJIPotra2sLW1TTDf2traKD9kU7VfHx9g/35YPXgAJLKOl5ckvzx6pMKlS9aoXt3Ajf3AGOszQcljv5gu9o3pYt+YJvaL6TJU35ha/6alxGJkZCTs7Ox05tnb2+PQoUNp3maWE78eukqVqlWnTAHevgU+/hiI99OHiIiIiDKZSQTRbWxsULFiRezevRstW7YEIEHx3bt3Y+DAgQmWL1asGC5evKgzb+zYsXj9+jVmz56N/PnzJ7qfhw8fIjg4GO6J1AvPEjSDi965k+QilSoBmzfL4KIMohMRERGRRlpKLDZs2BAzZsxArVq14Ovri927d2P9+vWIjY1N8zYBMx6nKBGq+/dhBUDt7o7YVGwnIAD44w8rACpMmhSDmBglzW3Iijh+hGliv5gu9o3pYt+YJvaL6TLWOEUmEUQHgKFDh6J79+6oVKkSqlSpglmzZiEsLEx72We3bt2QL18+TJ06FXZ2dihVqpTO+s7OzgCgnf/mzRtMnDgRbdq0gZubG27fvo2vv/4ahQoVQsOGDTP1tWUaHx+5DwhIcpH4QXQiIiIiovSYPXs2+vbti2LFikGlUsHX1xc9e/bEggUL0rVdcx6n6H3eu3ahDIDHKhVObdmi93qzZlVATEx+lCv3FGFhR5GKVT8oHD/CNLFfTBf7xnSxb0wT+8V0ZfY4RSYTRO/QoQOePXuGcePGISgoCOXKlcO2bdu0WSv379+HRSqKAFpaWuLChQtYvHgxQkJC4OHhgQYNGmDy5MmJlmvJEvTIRK9cWe5PnsyE9hARERGR2UhtiUUAyJ07NzZu3IiIiAgEBwfDw8MDI0eOhM+75I60bBMw73GK3mdx+DAAwK1CBW3t+JS8fAm0bi0/1ebOzYkKFfRb70PC8SNME/vFdLFvTBf7xjSxX0yXscYpMpkgOgAMHDgw0fItALBv375k1120aJHOY3t7e2zfvt1ALTMTmiD6w4dAVJQMXvSeihXl/vp1IDQUyMTfIERERERkwlJbYjE+Ozs75MuXD9HR0Vi3bh3at2+frm2a9ThF73t3AsHS0xOWem7jzh1ArQby5QOqVuUP9+Rw/AjTxH4xXewb08W+MU3sF9OV2eMUcXz3rMTNDbCzkyPu+/cTXSR3bhlgFADOnMnEthERERGRyRs6dCj+/PNPLF68GFevXsWAAQMSlFiMP0jo8ePHsX79egQEBODgwYNo1KgR1Go1vv76a723meXFH1hUTzdvyn3hwhnQHiIiIiJKNZPKRKd0UqkkG/3qVUlfKVQo0cUqVQLu3ZOSLnXqZG4TiYiIiMh0pbbEYkREBMaOHYuAgAA4OjrC398fS5cu1Y5XpM82s7w0BNFv3ZL7JA7niYiIiCiTMYie1cQPoiehcmVg3ToOLkpERERECaWmxGLt2rVx5cqVdG0zywsMlHtmohMRERGZLZZzyWr0GFy0UiW5ZxCdiIiIiCgDhYUBr17JNDPRiYiIiMwWg+hZjY+P3AcEJLmIZnDRgAAgODgT2kRERERE9CF6/Fjus2UDnJz0Xo2Z6ERERESmhUH0rEaPTHRn57gD8tOnM75JREREREQfpPj10FUqvVZ58QJ4+VKmfX0zqF1ERERElCoMomc1egTRAZZ0ISIiIiLKcGkYVFSThZ4vH+DgkAFtIiIiIqJUYxA9q9EE0Z8/B16/TnIxTRD95MlMaBMRERERZZiCBQti0qRJuH//vrGbQu9LQxCd9dCJiIiITA+D6FlNjhxArlwynUw2euXKcs9MdCIiIiLzNmTIEKxfvx4+Pj6oX78+Vq1ahcjISGM3i4B0BdFZD52IiIjIdDCInhXpUdKlfHkpy/jwIRAUlEntIiIiIiKDGzJkCM6dO4cTJ06gePHiGDRoENzd3TFw4ECcOXPG2M37sKWjnAsz0YmIiIhMB4PoWZEeQXRHR6B4cZlmNjoRERGR+atQoQJ+/vlnPHr0COPHj8dff/2FypUro1y5cliwYAEURTF2Ez88zEQnIiIiyhIYRM+KfHzkPiAg2cVY0oWIiIgo64iOjsbff/+N5s2bY9iwYahUqRL++usvtGnTBqNHj0bnzp2N3cQPDzPRiYiIiLIEK2M3gDKAHpnogAwuungxg+hERERE5uzMmTNYuHAhVq5cCQsLC3Tr1g0zZ85EsWLFtMu0atUKlTUZFJQ5FCXVQfQXL+QGAL6+GdQuIiIiIko1BtGzolQE0QHg5Ek5xlepMrhdRERERGRwlStXRv369fH777+jZcuWsLa2TrCMt7c3OnbsaITWfcBCQ4GwMJl2d9drFU0pFw8PIFu2DGoXEREREaUag+hZkaacy507yUbHy5b9P3v3HR5F1cVx/LvphU4gCS0JRYo0AYlIlQ5KVxFRigUbiiIqIFVQEAUBRXhFAcUC9ooUg6EXBanSewsdAgFCkt33j+smBBJI2WQ3ye/zPPPsZHZ25mxuApMzZ88FDw84ccJMMFq6dDbGKCIiIiIOsXfvXkJCQm66j7+/PzNnzsymiARIqkIvWDDNGXF7El2tXERERERci3qi50ZlypjE+aVLJkOeCl9fqFrVrKuli4iIiEjOdOLECdasWXPD9jVr1vC3LvKcx55EL1kyzS+x90PXpKIiIiIirkVJ9NzI2zvpYj0dLV1EREREJOd57rnnOHTo0A3bjxw5wnPPPeeEiATI0KSiqkQXERERcU1KoudW6eyLriIlERERkZzp33//pVatWjdsv+OOO/j333+dEJEAGUqiqxJdRERExDUpiZ5b2fui7917093uvNM8/v23aZ8uIiIiIjmLt7c3x48fv2H7sWPH8PDQFEhOo0p0ERERkVxDSfTcKo2V6FWrgpcXnD17y3y7iIiIiLigli1bMmjQIM6fP5+47dy5cwwePJgWLVo4MbI8Lp1J9LNn4fRps64kuoiIiIhrURI9t0pjEt3LC2rUMOtq6SIiIiKS87z77rscOnSIkJAQ7rnnHu655x7CwsKIiopi/Pjxzg4v70pnEt1ehR4cDP7+WRSTiIiIiGSIkui5lb2dyy2S6JC8pYuIiIiI5CwlS5Zk06ZNjBs3jipVqlC7dm0mTZrE5s2bKV26tLPDy7vSmURXP3QRERER16UmibmVvRL94EGIj4eb9MO0Ty7611/ZEJeIiIiIOJy/vz99+vRxdhhiZ7NluBJdrVxEREREXI+S6LlVcDB4e0NsLBw6lJRUT4E9ib5uHVit4KbPJ4iIiIjkOP/++y8HDx7k6tWryba3b9/eSRHlYWfOgH0cgoLS9BJVoouIiIi4rkwn0Q8dOoTFYqFUqVIArF27li+//JIqVaqoGsaZ3NwgJAR27jQtXW6SRK9cGfz84OJFs3ulStkYp4iIiIhkyt69e+nUqRObN2/GYrFgs9kAsFgsACQkJDgzvLzpyBHzGBBgClvSQJXoIiIiIq4r0zXHDz/8MH/++ScAUVFRtGjRgrVr1/L666/zxhtvZDpAyQR7X/S9e2+6m4cH3HGHWVdLFxEREZGcpV+/foSFhXHixAn8/PzYunUrS5cupU6dOkRGRjo7vLwpna1cQJXoIiIiIq4s00n0LVu2ULduXQC+/vprqlatysqVK/niiy+YNWtWZg8vmWGvPk/D5KL2li6aXFREREQkZ1m1ahVvvPEGAQEBuLm54ebmRoMGDRgzZgwvvPCCs8PLm9KZRD97Fk6fNuvlymVRTCIiIiKSYZlOosfFxeH930cU//jjj8Sei5UqVeLYsWOZPbxkRjqS6HfeaR6VRBcRERHJWRISEsifPz8AAQEBHP0vgRsSEsKOHTucGVreZU+ilyyZpt3trVyCgyFfviyKSUREREQyLNNJ9Ntvv51p06axbNkyFi1aROvWrQE4evQoRYsWzXSAkgn2di7pqET/5x+Ij8/CmERERETEoapWrcrGjRsBCA8PZ9y4caxYsYI33niDsvbrQcle6axEVz90EREREdeW6ST622+/zf/+9z+aNGlCt27dqFGjBgA///xzYpsXcRJ7JfoteqKD6b2YPz9cvgz//pvFcYmIiIiIwwwZMgSr1QrAG2+8wb59+2jYsCHz5s1j8uTJTo4uj0pnEl390EVERERcm0dmD9CkSRNOnTpFdHQ0hQsXTtzep08f/Pz8Mnt4yQx7Ev3ECYiJAX//VHd1c4PatSEy0rR0qV49e0IUERERkcxp1apV4nr58uXZvn07Z86coXDhwlgsFidGloepEl1EREQkV8l0Jfrly5eJjY1NTKAfOHCAiRMnsmPHDooXL57pACUTCheGQoXM+v79t9zd3hf9r7+yLCIRERERcaC4uDg8PDzYsmVLsu1FihRRAt2ZMliJriS6iIiIiGvKdBK9Q4cOfPbZZwCcO3eO8PBwxo8fT8eOHZk6dWqmA5RMSkdLF3tfdE0uKiIiIpIzeHp6UqZMGRISEpwditglJEBUlFlPZyW62rmIiIiIuKZMJ9HXr19Pw4YNAfj2228JDAzkwIEDfPbZZ+rB6ArsSfR0TC66cSPExmZhTCIiIiLiMK+//jqDBw/mzJkzzg5FAE6eNIl0NzdIwydzz52DU6fMerlyWRuaiIiIiGRMpnuiX7p0ifz58wOwcOFCOnfujJubG3fddRcHDhzIdICSSelIooeFQZEicOYMbN6clFQXEREREdf1wQcfsHv3bkqUKEFISAj+182Ds379eidFlkfZW7kEBoLHrf/cslehBwXBf39WiYiIiIiLyXQSvXz58vz444906tSJBQsW8NJLLwFw4sQJChQokOkAJZPKljWPaUiiWywmcb5woWnpoiS6iIiIiOvr2LGjs0OQa6kfuoiIiEiuk+kk+rBhw3j44Yd56aWXaNq0KfXq1QNMVfodd9yR6QAlk9LREx2SJ9FFRERExPUNHz7c2SHItY4cMY/qhy4iIiKSa2Q6iX7//ffToEEDjh07Ro0aNRK3N2vWjE6dOmX28JJZ17ZzsdlMuflN3HmneVyzJovjEhERERHJjVSJLiIiIpLrZDqJDhAUFERQUBCHDx8GoFSpUtStW9cRh5bMCg01jxcvwunTEBBw093r1wd3d9iyBXbuhNtuy/oQRURERCTj3NzcsNykUCIhISEbo5HEJHrJkmnaXZXoIiIiIq7PLbMHsFqtvPHGGxQsWJCQkBBCQkIoVKgQo0aNwmq1OiJGyQwfn6QqmDS0dClWDFq2NOtffJGFcYmIiIiIQ/zwww98//33icvcuXMZOHAgwcHBfPTRR84OL+9RJbqIiIhIrpPpSvTXX3+dTz75hLFjx1K/fn0Ali9fzogRI7hy5QpvvvlmpoOUTAoLMxfz+/ZBGj4h0L07/P67SaKPGHHLDjAiIiIi4kQdOnS4Ydv999/P7bffzty5c3n88cedEFUelo4k+rlzcOqUWVcSXURERMR1ZTqJ/umnn/Lxxx/Tvn37xG3Vq1enZMmSPPvss0qiu4KwMFixwiTR06BDB/Dzgz17YO1aCA/P4vhERERExOHuuusu+vTp4+ww8p50JNHtrVwCAyF//iyMSUREREQyJdPtXM6cOUOlSpVu2F6pUiXOnDmT2cOLI5Qtax7TmETPlw86djTraukiIiIikvNcvnyZyZMnUzKNfbnFQeLi4MQJs56OJLr6oYuIiIi4tkwn0WvUqMEHH3xww/YPPviA6tWrZ/bw4ghhYeYxDT3R7bp3N49z50J8fBbEJCIiIiIOUbhwYYoUKZK4FC5cmPz58zNjxgzeeecdZ4eXt0RFmUdPTyha9Ja7qx+6iIiISM6Q6XYu48aN49577+WPP/6gXr16AKxatYpDhw4xb968dB1rypQpvPPOO0RFRVGjRg3ef/996qahh/ecOXPo1q0bHTp04Mcff0zcbrPZGD58ONOnT+fcuXPUr1+fqVOnUiGvlXrYk+hprEQHaNECAgJMIc0ff0Dr1lkUm4iIiIhkynvvvYflmkls3NzcKFasGOHh4RQuXNiJkeVB9lYuwcHgdut6JVWii4iIiOQMma5Eb9y4MTt37qRTp06cO3eOc+fO0blzZ7Zu3crs2bPTfJy5c+fSv39/hg8fzvr166lRowatWrXihP3jkKnYv38/AwYMoGHDhjc8N27cOCZPnsy0adNYs2YN/v7+tGrViitXrqT7feZo9nYuBw9CQkKaXuLpCV27mnW1dBERERFxXb169aJnz56Jy6OPPkrr1q2VQHeGdPRDB1Wii4iIiOQUmU6iA5QoUYI333yT7777ju+++47Ro0dz9uxZPvnkkzQfY8KECTz55JP07t2bKlWqMG3aNPz8/JgxY0aqr0lISKB79+6MHDmSsvZE8X9sNhsTJ05kyJAhdOjQgerVq/PZZ59x9OjRZNXqeUKJEiYrHhcHR46k+WX2li4//AAxMVkUm4iIiIhkysyZM/nmm29u2P7NN9/w6aefOiGiPCydSXRVoouIiIjkDJlu5+IIV69eZd26dQwaNChxm5ubG82bN2fVqlWpvu6NN96gePHiPP744yxbtizZc/v27SMqKormzZsnbitYsCDh4eGsWrWKhx56KMVjxsbGEhsbm/h1dHQ0AHFxccTFxWXo/WWE/VyOOqdHSAiW3buJ37kTW3Bwml5TuzaULevB3r0Wvv8+nocesjkklpzO0WMjjqFxcV0aG9elsXFNGhfX5eixcdRxxowZw//+978bthcvXpw+ffrQs2dPh5xH0sBesJKGJPr583DypFkvVy4LYxIRERGRTHOJJPqpU6dISEggMDAw2fbAwEC2b9+e4muWL1/OJ598woYNG1J8Puq/SX1SOqb9uZSMGTOGkSNH3rB94cKF+Pn53extZIlFixY55Dj1/P0pDmz++WcOpqOsvHbtSuzdW5HJk09RoMAah8SSWzhqbMSxNC6uS2PjujQ2rknj4rocNTaXLl1yyHEOHjxImH0OnGuEhIRw8OBBh5xD0igdlej2KvTixaFAgSyMSUREREQyzSWS6Ol14cIFHn30UaZPn05AQIBDjz1o0CD69++f+HV0dDSlS5emZcuWFMjGq9u4uDgWLVpEixYt8PT0zPTx3H77DTZupHr+/FRt2zbNrytbFr75BjZsCKRu3bY4+NudIzl6bMQxNC6uS2PjujQ2rknj4rocPTb2TzxmVvHixdm0aROhoaHJtm/cuJGiRYs65BySRulIotv7oauVi4iIiIjry3ASvXPnzjd9/ty5c2k+VkBAAO7u7hw/fjzZ9uPHjxMUFHTD/nv27GH//v20a9cucZvVagXAw8ODHTt2JL7u+PHjBF/TvuT48ePUrFkz1Vi8vb3x9va+Ybunp6dT/pB12Hlvuw0A923bcE/H8apVg1q1YP16Cz/84Mmzz2Y+lNzCWT8TcnMaF9elsXFdGhvXpHFxXY4aG0eNb7du3XjhhRfInz8/jRo1AmDJkiX069cv1RaGkkXsSfSSJW+5q70SXZOKioiIiLi+DE8sWrBgwZsuISEh9OjRI03H8vLyonbt2kRERCRus1qtREREUK9evRv2r1SpEps3b2bDhg2JS/v27bnnnnvYsGEDpUuXJiwsjKCgoGTHjI6OZs2aNSkeM9erX988Ll0K/91wSCv7BKNffOHgmEREREQk00aNGkV4eDjNmjXD19cXX19fWrZsSdOmTXnrrbecHV7eokp0ERERkVwpw5XoM2fOdGQc9O/fn549e1KnTh3q1q3LxIkTiYmJoXfv3gD06NGDkiVLMmbMGHx8fKhatWqy1xcqVAgg2fYXX3yR0aNHU6FCBcLCwhg6dCglSpSgY8eODo09R6hTB/z84PRp2LrVlJin0UMPwYABsHIl7NsHKbTcFBEREREn8fLyYu7cuYwePZoNGzbg6+tLtWrVCAkJcXZoecvly3D2rFlPR090VaKLiIiIuD6X6YnetWtXTp48ybBhw4iKiqJmzZrMnz8/cWLQgwcP4uaWvsL5V199lZiYGPr06cO5c+do0KAB8+fPx8fHJyvegmvz9IQGDWDhQoiMTFcSvUQJaNoUIiLgyy/h9dezLkwRERERyZgKFSpQQWXNznPsmHn09YWCBW+5uyrRRURERHKODLdzyQp9+/blwIEDxMbGsmbNGsLDwxOfi4yMZNasWam+dtasWfz444/JtlksFt544w2ioqK4cuUKf/zxB7f91xs8T2rSxDxGRqb7pde2dLHZHBaRiIiIiGRSly5dePvtt2/YPm7cOB544AEnRJRHXdvKxWK56a7nz8PJk2ZdlegiIiIirs+lkuiSxe65xzxGRqa7L3rnzuDtDdu2wYYNDo9MRERERDJo6dKltG3b9obtbdq0YenSpU6IKI9KRz90eyuX4sWhQIEsjElEREREHEJJ9Lykdm3w94czZ2DLlnS9tGBBaNfOrGuCURERERHXcfHiRby8vG7Y7unpSXR0tBMiyqMykERXFbqIiIhIzqAkel5i74sOGWrp8sgj5vGrryAhwXFhiYiIiEjGVatWjblz596wfc6cOVSpUsUJEeVR6Uiiqx+6iIiISM7iMhOLSjZp0gQWLDBJ9BdeSNdL27SBwoXN3wdLlpjJRkVERETEuYYOHUrnzp3Zs2cPTf+7QIuIiODLL7/k22+/dXJ0eYgq0UVERERyLVWi5zX2vuhLlqS7L7qXF9jnplJLFxERERHX0K5dO3788Ud2797Ns88+y8svv8yRI0dYvHgx5ZWlzT5HjpjHdCTRVYkuIiIikjMoiZ7X1KoF+fKZvuibN6f75d27m8dvv4UrVxwcm4iIiIhkyL333suKFSuIiYlh7969PPjggwwYMIAaNWo4O7S8IwPtXHSPQ0RERCRnUBI9r8lkX/QGDaB0aYiOht9+c2xoIiIiIpJxS5cupWfPnpQoUYLx48fTtGlTVq9e7eyw8g57Er1kyZvuFh0NJ06YdSXRRURERHIGJdHzoiZNzGMGkuhubvDww2ZdLV1EREREnCsqKoqxY8dSoUIFHnjgAQoUKEBsbCw//vgjY8eO5c4773R2iHnDhQtw8aJZDw6+6a72Vi7FikHBglkcl4iIiIg4hJLoeZE9iZ6BvuiQ1NLlt9/g7FnHhSUiIiIiadeuXTsqVqzIpk2bmDhxIkePHuX99993dlh5k70KvUAB0zrxJtQPXURERCTnURI9L6pd21zcnz0Lmzal++XVqpnl6lXTG11EREREst/vv//O448/zsiRI7n33ntxd3d3dkh5l/qhi4iIiORqSqLnRR4e0LChWc9ASxdIqkZXSxcRERER51i+fDkXLlygdu3ahIeH88EHH3Dq1Clnh5U3pSOJrkp0ERERkZxHSfS8KhN90QG6dTOPS5bA5s0OiUhERERE0uGuu+5i+vTpHDt2jKeeeoo5c+ZQokQJrFYrixYt4sKFC84OMe9QJbqIiIhIrqYkel5lT6IvXZqhvuhlykDnzmb9ySchIcFxoYmIiIhI2vn7+/PYY4+xfPlyNm/ezMsvv8zYsWMpXrw47du3d3Z4eUMGKtGVRBcRERHJOZREz6tq1YL8+U1f9I0bM3SIyZPN3Elr1sCUKQ6OT0RERETSrWLFiowbN47Dhw/z1VdfOTucvOPgQfNYqtRNd4uOhuPHzbqS6CIiIiI5h5LoeZUD+qKXLAlvv23WBw+GAwccE5qIiIiIZI67uzsdO3bk559/dnYoecP+/eYxLOymu+3ZYx4DAqBQoSyNSEREREQcSEn0vCyTfdEB+vSBBg0gJgaeeQZsNodEJiIiIiKSc9iT6KGhN91N/dBFREREciYl0fOya/uiZ7CpuZsbTJ8OXl7w+++gTw2LiIiISJ4SHQ1nzpj1kJCb7rp3r3lUEl1EREQkZ1ESPS+74w7TF/3cOdi0KcOHqVQJhg416/36walTjglPRERERMTl2avQixY119Y3YW/nUrZs1oYkIiIiIo6lJHpe5uEBjRqZ9T//zNShXn0VqlY1CfT+/R0Qm4iIiIhITpDGVi6QVIlerlyWRSMiIiIiWUBJ9LzOAX3RwbRz+fhjsFhg9mxYsCDTkYmIiIiIuL50JNFViS4iIiKSMymJntc5oC+6XXg4vPCCWX/qKbh4MXOhiYiIiIi4vDQm0a9ehUOHzLoq0UVERERyFiXR87qaNaFAATh/HjZuzPThRo+GMmXgwAEYNizz4YmIiIiIuLQ0JtEPHACrFXx9ISgoy6MSEREREQdSEj2vc2BfdIB8+WDaNLM+aRL89VemDykiIiIi4rrsSfSwsJvuZu+HXrasaYEoIiIiIjmHkujisL7odm3aQPfuptLmiScgLs4hhxURERERcT1prERXP3QRERGRnEtJdHFoX3S7996DokVh0yZ4912HHFJERERExLWcPw9nz5r1kJCb7mqvRFc/dBEREZGcR0l0SeqLHh0NGzY45JDFisHEiWZ95EjYudMhhxURERERcR32KvSAANPX8CZUiS4iIiKScymJLuDuntQX3UEtXcC0dGnVCmJjoU8f095FRERERCTXSGMrF1AluoiIiEhOpiS6GPfcYx4dMLmoncViJhn184MlS2DyZIcdWkRERESyyJQpUwgNDcXHx4fw8HDWrl170/0nTpxIxYoV8fX1pXTp0rz00ktcuXIl8fkRI0ZgsViSLZUqVcrqt5E90phEt9mSKtGVRBcRERHJeZREF8PeF33ZMoiPd9hhQ0Nh3Diz/sorsGqVww4tIiIiIg42d+5c+vfvz/Dhw1m/fj01atSgVatWnDhxIsX9v/zySwYOHMjw4cPZtm0bn3zyCXPnzmXw4MHJ9rv99ts5duxY4rJ8+fLseDtZL41J9JMnISbGFJmkoWhdRERERFyMkuhi1KgBBQs6tC+63bPPwoMPmtz8gw+aPyJERERExPVMmDCBJ598kt69e1OlShWmTZuGn58fM2bMSHH/lStXUr9+fR5++GFCQ0Np2bIl3bp1u6F63cPDg6CgoMQlICAgO95O1ktjEt1ehV6qFHh7Z2lEIiIiIpIFPJwdgLgIe1/0X34xfdHr1HHYoS0W+Phj2LgRduyARx6BefPMKUVERETENVy9epV169YxaNCgxG1ubm40b96cVal8nPDuu+/m888/Z+3atdStW5e9e/cyb948Hn300WT77dq1ixIlSuDj40O9evUYM2YMZcqUSTWW2NhYYmNjE7+Ojo4GIC4ujri4uMy8zXSxnyu1c3rs24cFiC9VCttN4tq50wJ4EBZmJS4uIQsizXtuNTbiHBoX16WxcV0aG9ekcXFdjh6btB5HSXRJcs89Jon+558wYIBDD50/P3z7LdStCwsXwujRMHy4Q08hIiIiIplw6tQpEhISCAwMTLY9MDCQ7du3p/iahx9+mFOnTtGgQQNsNhvx8fE8/fTTydq5hIeHM2vWLCpWrMixY8cYOXIkDRs2ZMuWLeTPnz/F444ZM4aRI0fesH3hwoX4+fll4l1mzKJFi1Lc3mb3bryApYcOcWHevFRfv2DBbUBlPD0PMW/ehiyJMa9KbWzEuTQurktj47o0Nq5J4+K6HDU2ly5dStN+SqJLkuv7ons49sejalX43/+gRw8YORLuugtatXLoKUREREQkG0VGRvLWW2/x4YcfEh4ezu7du+nXrx+jRo1i6NChALRp0yZx/+rVqxMeHk5ISAhff/01jz/+eIrHHTRoEP3790/8Ojo6mtKlS9OyZUsKFCiQtW/qGnFxcSxatIgWLVrg6emZ/Mlz5/CMiQGg4SOPgL9/qsf57jvzEcxGjUrRtm2JLIs3L7np2IjTaFxcl8bGdWlsXJPGxXU5emzsn3i8FSXRJUn16lCoEJw7B//8A3fe6fBTPPooLF8OH30E3bub05Qu7fDTiIiIiEg6BQQE4O7uzvHjx5NtP378OEFBQSm+ZujQoTz66KM88cQTAFSrVo2YmBj69OnD66+/jpvbjVMwFSpUiNtuu43du3enGou3tzfeKTQP9/T0dMofsime9+hR81isGJ6FCt309fv2mcfbbnPH01M9DR3JWT8TcnMaF9elsXFdGhvXpHFxXY4am7QeQxOLShJ7X3QwfdGzyKRJUKsWnD5tJhq9ejXLTiUiIiIiaeTl5UXt2rWJiIhI3Ga1WomIiKBevXopvubSpUs3JMrd/5v4xmazpfiaixcvsmfPHoKDgx0UuZOkcVJRgL17zWPZslkWjYiIiIhkISXRJTl7S5c//8yyU/j4mP7ohQrB6tXwyitZdioRERERSYf+/fszffp0Pv30U7Zt28YzzzxDTEwMvXv3BqBHjx7JJh5t164dU6dOZc6cOezbt49FixYxdOhQ2rVrl5hMHzBgAEuWLGH//v2sXLmSTp064e7uTrdu3ZzyHh3GXl5+iyT65ctJRevlymVtSCIiIiKSNdTORZJr3tw8/vEHHDkCJUtmyWnCwuCzz6B9e5g8GerXN1XpIiIiIuI8Xbt25eTJkwwbNoyoqChq1qzJ/PnzEycbPXjwYLLK8yFDhmCxWBgyZAhHjhyhWLFitGvXjjfffDNxn8OHD9OtWzdOnz5NsWLFaNCgAatXr6ZYsWLZ/v4cKo2V6PZce4ECUKRIlkYkIiIiIllESXRJrlo1aNjQTC46cSK8806WnapdOxg4EMaOhccfhxo1oGLFLDudiIiIiKRB37596du3b4rPRV7X8s/Dw4Phw4czfPjwVI83Z84cR4bnOtKYRN+zxzyWKwcWS5ZGJCIiIiJZRO1c5EavvWYep02Ds2ez9FSjRkHjxnDxInTpAjExWXo6ERERERHHSGMSXf3QRURERHI+JdHlRm3bQtWqJrM9dWqWnsrDA+bMgaAg2LoVnnkGUpmDSkRERETEdWSgEl1EREREciYl0eVGFktSNfqkSWY2pCwUFARz54K7O8yebdq7KJEuIiIiIi7r3Dk4f96sqxJdREREJNdTEl1S1rUrhITAiRMwa1aWn65RIxgzxqwPHgzduplCeBERERERl2OvQi9eHPz8brqrKtFFREREcj4l0SVlnp7w8stm/Z13ID4+y085YABMnmxavMydC+HhsGNHlp9WRERERCR90tjKxWqFffvMuirRRURERHIuJdEldY8/DgEB5sr/22+z/HQWCzz/PERGQnAw/Psv3Hkn/PBDlp9aRERERCTt0phEP3oUYmNN28IyZbI8KhERERHJIi6VRJ8yZQqhoaH4+PgQHh7O2rVrU933+++/p06dOhQqVAh/f39q1qzJ7Nmzk+3Tq1cvLBZLsqV169ZZ/TZyDz8/k9WGbG1UXr8+rF9vWrxcuACdO8PAgdlSDC8iIiIicmv28vI09kMPCTGfthQRERGRnMllkuhz586lf//+DB8+nPXr11OjRg1atWrFiRMnUty/SJEivP7666xatYpNmzbRu3dvevfuzYIFC5Lt17p1a44dO5a4fPXVV9nxdnKP554Df3/YuBEWLsy20wYFwR9/QP/+5uu334aWLU2LdhERERERp0pjJbr6oYuIiIjkDi6TRJ8wYQJPPvkkvXv3pkqVKkybNg0/Pz9mzJiR4v5NmjShU6dOVK5cmXLlytGvXz+qV6/O8uXLk+3n7e1NUFBQ4lK4cOHseDu5R9Gi0KePWR87NltP7ekJ48eb/uj+/vDnn1CrFqxena1hiIiIiIgkl8Ykur0SXf3QRURERHI2l/hQ4dWrV1m3bh2DBg1K3Obm5kbz5s1ZtWrVLV9vs9lYvHgxO3bs4O233072XGRkJMWLF6dw4cI0bdqU0aNHU7Ro0VSPFRsbS2xsbOLX0dHRAMTFxREXF5fet5Zh9nNl5zlT1bcvHu+/jyUykvgVK7DVrZutp+/UCSpVggcf9GDHDguNGtkYP97KU09ZsViyNRTAxcZGEmlcXJfGxnVpbFyTxsV1OXpsNMY5lM2mSnQRERGRPMYlkuinTp0iISGBwMDAZNsDAwPZvn17qq87f/48JUuWJDY2Fnd3dz788ENatGiR+Hzr1q3p3LkzYWFh7Nmzh8GDB9OmTRtWrVqFu7t7isccM2YMI0eOvGH7woUL8fPzy+A7zLhFixZl+zlTckejRpRZvJgTAwbw18CBTolhxAgP3n+/JitXluSFF9yZOzeKxx/fTJEisbd+cRZwlbGR5DQurktj47o0Nq5J4+K6HDU2ly5dcshxJJudOwf/FdoQEnLTXVWJLiIiIpI7uEQSPaPy58/Phg0buHjxIhEREfTv35+yZcvSpEkTAB566KHEfatVq0b16tUpV64ckZGRNGvWLMVjDho0iP72RtyYSvTSpUvTsmVLChQokKXv51pxcXEsWrSIFi1a4OnpmW3nTVVYGNSoQfCaNbQtW9aUhjtB584wcWICgwe7sWJFSTZuLMGQIVb69rXi5ZU9Mbjc2AigcXFlGhvXpbFxTRoX1+XosbF/4lFyGHsVemAg3KLIRpXoIiIiIrmDSyTRAwICcHd35/jx48m2Hz9+nKCgoFRf5+bmRvny5QGoWbMm27ZtY8yYMYlJ9OuVLVuWgIAAdu/enWoS3dvbG29v7xu2e3p6OuUPWWed9wbVq0OHDlh++gnPiRPhk0+cFsqrr0LTptC3L6xZY2HgQHdmznRn8mQz+Wh2cZmxkWQ0Lq5LY+O6NDauSePiuhw1NhrfHCqNrVyio+HUKbOuSnQRERGRnM0lJhb18vKidu3aREREJG6zWq1ERERQr169NB/HarUm62d+vcOHD3P69GmCg4MzFW+e9dpr5nH2bDh82Kmh1KkDK1fCjBlQvDjs2AGtWplKdfvfNSIiIiIiDpfOSUUDAiAbP9AqIiIiIlnAJZLoAP3792f69Ol8+umnbNu2jWeeeYaYmBh69+4NQI8ePZJNPDpmzBgWLVrE3r172bZtG+PHj2f27Nk88sgjAFy8eJFXXnmF1atXs3//fiIiIujQoQPly5enVatWTnmPOV69etCoEcTFwcSJzo4GNzfo3dsk0Pv1A3d3+OEHqFwZRo6Ey5edHaGIiIiI5DrpTKKrCl1EREQk53OZJHrXrl159913GTZsGDVr1mTDhg3Mnz8/cbLRgwcPcuzYscT9Y2JiePbZZ7n99tupX78+3333HZ9//jlPPPEEAO7u7mzatIn27dtz22238fjjj1O7dm2WLVuWYrsWSSN7Nfr//gdnzzo3lv8UKmRy+hs2QJMmcOUKjBgBVarAjz+CzZb6a202iI2F8+fNHFEiIiIiIje1b595vEUSXf3QRURERHIPl+iJbte3b1/69u2b4nORkZHJvh49ejSjR49O9Vi+vr4sWLDAkeEJQJs2UK0abN4MH34Ir7/u7IgSVa0KixfDN9/Ayy+bIqFOncx2Ly+TXL9yxVSo29evXEmeZC9ZEu680yx16pilSBGnvSURERERcTWqRBcRERHJc1wqiS45gMViqtEfeQQmTYL+/cHX19lRJbJY4MEH4d574a234N13YcuWtL/+yBGz/Phj0rZy5ZIS63feaZLyIiIiIpIH2WxpTqKrEl1EREQk91ASXdKva1cYMsT8ATFzJjz7rLMjuoG/P7z5Jjz1FKxbB97eJtfv42MW+/q1265ehX/+gb//hr/+MsuePUnLnDnm2O7uHvTsWZa2bZ37HkVEREQkm509CxcumPWQkJvuqkp0ERERkdxDSXRJPw8PGDAA+vaFd96BPn3MNhdUpoxZ0sLb28yb2qhR0rYzZ0wS3p5U/+svOHLEwmefVWHQICvly2dN3CIiIiLiguxV6IGBN/00Znw8HDhg1lWJLiIiIpLzuczEopLD9O4NAQHmD4mffnJ2NFmmSBFo0QIGD4YffoDDh6FpUyvx8e688Ya7s8MTERERkexkT6KHhd10t0OHTCLd2xtKlMj6sEREREQkaymJLhnj52d6pQBMnuzcWLLZ6NFWAD7/3JKufusiIiIiksOlsx96WBi46S8uERERkRxPl3SScU8/De7usHQpbNzo7GiyTZ06NurVO4rNZmHIEGdHIyIiIiLZJo1JdHs/dLVyEREREckdlESXjCtVCrp0Mevvv+/cWLJZ9+7bcHOz8dNPsGqVs6MRERERkWyRzkp0TSoqIiIikjsoiS6Z8/zz5vGLL+D0aefGko1KlbpIz542AAYOBJvNyQGJiIiISNZTJbqIiIhInqQkumRO/fpwxx1w5Qp8/LGzo8lWQ4Yk4O1tutksWODsaEREREQkS9lssG+fWVcluoiIiEieoiS6ZI7FklSN/uGHEB/v3HiyUenSSW990CCwWp0bj4iIiIhkoTNn4OJFs16mTKq72WxJSXRVoouIiIjkDkqiS+Z16wYBAXDwIPz8s7OjyVYDB0KBArBhA8yd6+xoRERERCTL2Fu5BAWBr2+qu505A9HRZj0sLOvDEhEREZGspyS6ZJ6PDzz5pFnPYxOMFi0Kr75q1ocMgatXnRuPiIiIiGSRdPZDL1Hiprl2EREREclBlEQXx3jmGXB3h8hI2LTJ2dFkq379IDDQ/MH0ySfOjkZEREREskQak+jqhy4iIiKS+yiJLo5RujR06mTWP/jAubFks3z5YOhQs/7GGxAT49x4RERERCQL2JPot+jRYq9EVz90ERERkdxDSXRxnBdeMI+ff26aQeYhTz5pqo2iomDyZGdHIyIiIiIOp0p0ERERkTxLSXRxnAYNoEYNuHw5z/U18fKCUaPM+ttv57l7CCIiIiK5Xzp7oqsSXURERCT3UBJdHMdiSapGnzIFEhKcG082e+ghqF4dzp83iXQRERERySVsNlWii4iIiORhSqKLY3XrBkWLwoED8Msvzo4mW7m5wZgxZn3yZDhyxLnxiIiIiIiDnD4NFy+a9TJlUt0tNhYOHzbrqkQXERERyT2URBfH8vU1DcIhTzYHb9MGGjaEK1dg5EhnRyMiIiIijmA5cMCsBAeDj0+q++3fb4rW/f2hWLHsiU1EREREsp6S6OJ4zzxjyrL//BO2bHF2NNnKYkmqRp8xA3bscG48IiIiIuIAGeiHbrFkaUQiIiIiko2URBfHK1MGOnUy6++/79xYnKB+fWjXzrSEf+01sFqdHZGIiIiIZEZiJbr6oYuIiIjkSUqiS9Z4/nnzOHs2nD3r3Fic4M03TTH+Tz9Br14QF+fsiEREREQkw9KYRL+2El1EREREcg8l0SVrNGoE1avD5cvwySfOjibbVatm2rm4u5v7CO3aJc1FJSIiIiI5S2IleljYTfdTJbqIiIhI7qQkumQNiyWpGn3KFNPbJI/p2RN+/hn8/GDBArjnHjhxwtlRiYiIiEh6WTLQE11EREREcg8l0SXrPPwwFCliJmL69VdnR+MUbdvC4sVQtCj8/bfpl27/40pEREREcgCbLU3tXGy2pOs8VaKLiIiI5C5KokvW8fODJ54w63lwglG78HBYudL8zbV7N9SrB+vXOzsqEREREUkLrwsXsMTEmC/KlEl1v+PH4dIlMy9OSEg2BSciIiIi2cLD2QFILvfss/DuuxARYfqkWyxJz6W07usLr74KTZpka5hZ7bbbTCK9bVvYsAEaN4bvv4cWLZwdmYiIiIjcjN/x42alRAnw9k51P3s/9NKlwcsrGwITERERkWyjJLpkrZAQuP9++PprWLYsba9ZtgzWroXKlbM2tmwWHAxLlkCnTqbFS9u2MGsWdO/u7MhEREREJDV+9klt1A9dREREJM9SEl2y3scfQ7duEBeXfLvNduO+U6bA0qXQpYtJpOfLlz0xZpMCBWDePDPp6Ny58MgjEBUFL7/s7MhEREREJCVpTaLbK9HVD11EREQk91ESXbJe/vzQsWPa9m3cGGrVgm3b4PHHYc6c5G1fcgFvb/jySwgKgkmTYMAAOHoU3nnH9NAUEREREdehSnQRERERUcpOXEtgIHzzDXh4mBYwkyY5O6Is4eYG770H48aZrydMMPcM4uOdG5eIiIiIJOerSnQRERGRPE9JdHE9d99tssoAr7wCy5c7N54sYrGYt/fpp+DubvqjP/ggxMY6OzIRERERsUusRA8Lu+l+qkQXERERyb2URBfX1Lev6aMeH28yy1FRzo4oy/ToAd9+C15e8MMP0K4dXLzo7KhEREREBJstTe1cYmKSLldViS4iIiKS+yiJLq7JYoHp0+H22+HYMejaNVf3OunY0Uw46u8PixZBixZw9qyzoxIRERHJ406dwiM2FpvFAqVLp7rbvn3msXBhs4iIiIhI7qIkurguf3/47jszMenSpTBokLMjylLNmsEff5g/vFavhiZNcnUBvoiIiIjLsxw4YFZKlDCzw6dC/dBFREREcjcl0cW1VawIM2ea9XffNUn1nOKbb2DhwnS95K67YMkSCAqCTZugYUOw/+0mIiIiItls/34AbCEhN91N/dBFREREcjcl0cX1dekCAwaY9d69YccO58aTFn/+aXq5d+hgmmSmQ7VqsGwZhITA7t3QoAFs355FcYqIiIhIqiz/JdFJYxJdlegiIiIiuZOS6JIzjBkDjRvDhQvQubNjZ968dAl+/RUmTDDHzyyrNSnpf+WK6c2STuXLw4oVULkyHD5sKtLXr898aCIiIiKSDv99JPBWlej2di6qRBcRERHJnZREl5zBwwPmzIHgYPj3X3jySbDZMn68vXvhgw+gTRsoUgTatYOXX4bnnst8rF9+mTzjvXRphg5TsqR5ae3acOoU3HOPqVAXERERkexh74luCw296X6qRBcRERHJ3TycHYBImgUFmT7jTZqYhHqBAlC3rkms25dixcDd/cbXXr1qMtDz5pnl+v4opUubku/Zs6FnTzPLZ0ZcvgyDB5v1qlVhy5ZMZb4DAmDxYpPjX7oUWraEl14yXW0qVMjwYUVEREQkDdLSzsVqhX37zLqS6CIiIiK5kyrRJWepX99MMArw0UfwxBNw771Qq5ZJont7Q4kSpnz7vvtMxXrnzlC0KDRvblq2bN9uEu2NG8Pbb5tE94EDSVXozzxj2rBkxKRJcOiQScp/9pnZtmqVSeJnUIECMH++eZtXrpjONrfdZlq8zJjhmA40IiIiInIjW+nSXC5a9KaV6EePmks9Dw9zCSgiIiIiuY8q0SXneeEFKFjQlGYfO2aWqCg4cQISEpK2Xa94cWjb1iwtWkChQsmfHz0avvsOdu0ymeqRI9MX18mT8NZbZv2tt6BmTVNKfuoU/P033H13Rt4tAL6+8NNP8P33MHMmLFgAy5eb5YUX4IEHTHV6w4ZgsWT4NCIiIiJyjYTffmPhvHm0vUmzc3s/9NDQlD8QKSIiIiI5n5LokvNYLNCrl1muFR9vEun2JLp98fAwfVBq1QK3m3z4omBBmDzZZKTHjoVu3aBSpbTHNXKkKQuvXRseftjE2aiRyXwvW5apJDqYP8oeeMAsR46YzjMzZpic/6xZZilXziTTe/RQJZSIiIhIdlA/dBEREZHcT+1cJPfw8LixlcuwYaZHeZ06N0+g23XpYvqmXL0KTz+d9slLt2+HadPM+rvvJp2rYUPzmMHJRVNTsiQMHAg7dphq9Mceg3z5TCXUkCGmbedDD4G9jaeIiIiIZA0l0UVERERyP5dKok+ZMoXQ0FB8fHwIDw9n7dq1qe77/fffU6dOHQoVKoS/vz81a9Zk9uzZyfax2WwMGzaM4OBgfH19ad68Obt27crqtyE5mcUCH3xg+qcsWQKffpq21732mmkl0769mfjUrlEj87hihXk+C8KtXx8++cQU3c+aZU5ps8HcuaaQ/vXX1TddREREJKvYk+g36fgiIiIiIjmcyyTR586dS//+/Rk+fDjr16+nRo0atGrVihMnTqS4f5EiRXj99ddZtWoVmzZtonfv3vTu3ZsFCxYk7jNu3DgmT57MtGnTWLNmDf7+/rRq1YorGZ00UvKG0NCkfugDBpie5jcTGQk//2z6rbz9dvLnatSA/Pnh/HnYvDkrok2ULx/07Gly///8Y3L5sbGmPfttt5le6lZrloYgIiIikufYe6KrEl1EREQk93KZJPqECRN48skn6d27N1WqVGHatGn4+fkxY8aMFPdv0qQJnTp1onLlypQrV45+/fpRvXp1li9fDpgq9IkTJzJkyBA6dOhA9erV+eyzzzh69Cg//vhjNr4zyZFefBGqV4fTp+GVV1Lfz2o1iXaAp566sYe6u7spFQeHt3S5mZo1YfFi+OEHUxUVFWVavtx5Z7aGISIiIpLrqZ2LiIiISO7nEhOLXr16lXXr1jFo0KDEbW5ubjRv3pxVq1bd8vU2m43FixezY8cO3v6vEnjfvn1ERUXRvHnzxP0KFixIeHg4q1at4qGHHkrxWLGxscTGxiZ+HR0dDUBcXBxxcXEZen8ZYT9Xdp5TkrNMmYJ7o0ZYZs0ivnt3bI0bA8nHxvLll3isW4ctf37iBw+GFMbLrX593OfPx7pkCQnPPJOt7+Hee6F5c/jwQzfefNON9estNG4MnTpZGTMmIVf9saffGdelsXFdGhvXpHFxXY4eG41xznfhApw8adbDwpwbi4iIiIhkHZdIop86dYqEhAQCAwOTbQ8MDGT79u2pvu78+fOULFmS2NhY3N3d+fDDD2nRogUAUVFRice4/pj251IyZswYRtpbeVxj4cKF+Pn5pfk9OcqiRYuy/ZySpHqrVoTNn8/lXr2InDgRq6dn4nMRv/5Ks1dewQPY1qEDu/7+O8VjFHF3pyFwNSKCBb/9ZhqZZ7OKFWHyZC/mzKnEwoWh/PCDG7/8YqN9+73cf/9O/Pzisz2mrKLfGdelsXFdGhvXpHFxXY4am0uXLjnkOOI8+/aZx6JFoWBB58YiIiIiIlnHJZLoGZU/f342bNjAxYsXiYiIoH///pQtW5Ym107smE6DBg2if//+iV9HR0dTunRpWrZsSYECBRwQddrExcWxaNEiWrRogec1iVvJZnffja16dfIfOULbzZuxDhmSODatduzA6+RJbKVKUWHKFCr4+qZ8jGbNsI0cic/587QtX95ktJ3k4Ydh8+Z4Xn3VnYgId77/vgLLl5dn2DArjz1mxSMH/4ug3xnXpbFxXRob16RxcV2OHhv7Jx4l57L3Q9ekoiIiIiK5m0ukzAICAnB3d+f48ePJth8/fpygoKBUX+fm5kb58uUBqFmzJtu2bWPMmDE0adIk8XXHjx8nODg42TFr1qyZ6jG9vb3x9va+Ybunp6dT/pB11nnlP8WKwcSJ8NBDuI8di3v37hAWhtf583i++y4AlrfewvNmN1g8PeGuu2DJEjxXr4aqVbMn9lTUqgWLFsFvv8HLL8POnRb69nXngw/cGTcO7rvPKcXyDqPfGdelsXFdGhvXpHFxXY4aG41vzqd+6CIiIiJ5g0tMLOrl5UXt2rWJiIhI3Ga1WomIiKBevXppPo7Vak3sZx4WFkZQUFCyY0ZHR7NmzZp0HVOEBx+E1q3h6lV45hmw2ag4dy6W6Gi44w7o3v3Wx2jY0Dy6yKyeFotJlm/ZAu+/DwEBsH07tG8PTZvCunXOjlBERETE9SmJLiIiIpI3uEQSHaB///5Mnz6dTz/9lG3btvHMM88QExND7969AejRo0eyiUfHjBnDokWL2Lt3L9u2bWP8+PHMnj2bRx55BACLxcKLL77I6NGj+fnnn9m8eTM9evSgRIkSdOzY0RlvUXIqiwWmTAEfH1i8GLcRIwhdsMA89+674JaGX6NGjcyjiyTR7Tw9oW9f2L0bBg4Eb2+IjIQ6deCRR+DAAWdHKCIiIuK6lEQXERERyRtcop0LQNeuXTl58iTDhg0jKiqKmjVrMn/+/MSJQQ8ePIjbNcnKmJgYnn32WQ4fPoyvry+VKlXi888/p2vXron7vPrqq8TExNCnTx/OnTtHgwYNmD9/Pj4+Ptn+/iSHK1sWhg+HQYNwHzMGAGvbtrg1bZq219erB+7uJit98CCUKZOFwaZfwYIwZowptB8yBGbPhi++gG+/hX79YNAgKFTI2VGKiIiIuBb1RBcRERHJG1ymEh2gb9++HDhwgNjYWNasWUN4eHjic5GRkcyaNSvx69GjR7Nr1y4uX77MmTNnWLlyZbIEOphq9DfeeIOoqCiuXLnCH3/8wW233ZZdb0dym5dfTuxnbnVzI+G/ZHqa5MtnmpEDLFuWBcE5Rpky8Nlnpp3LPfdAbCyMGwfly5u2LwkJzo5QRERExDUkJMD+/WZdlegiIiIiuZtLJdFFXJqnJ3zyCbZixdjVpQtUrpy+17toS5eU1KoFERHw669QpQqcPg0vvGD6pR886OzoRERERJzvyBGIizOXiCVLOjsaEREREclKSqKLpEfdusQfOcL2tEwmej17Et2FK9GvZbHAvffCxo0wdaoppl+6FGrUgK+/dnZ0IiIiIs5l74ceGmq69omIiIhI7qUkukh2qV/fPG7bBidOODeWdPDwgKefhg0bIDwczp2Drl3hscfg4kVnRyciIiLiHOqHLiIiIpJ3KIkukl2KFk3sqc7y5c6NJQPKlTNF9K+/bqrUZ86EO+6Av/5ydmQiIiIi2c9eia5+6CIiIiK5n5LoItmpYUPzmENaulzP0xNGj4bISChdGnbvhrvvhrFjNemoiIiI5C1KoouIiIjkHUqii2SnHDS56M00amR6pT/4IMTHw6BB0Lw5HD7s7MhEREREsoeS6CIiIiJ5h5LoItnJXom+YQNERzs1lMwqXBjmzIEZM8Df31SnV68O33/v7MhEREREsp6S6CIiIiJ5h5LoItmpZEnzl5bVCitXOjuaTLNYoHdv+OcfqFMHzp6FLl3g8cfhwgVnRyciIiIZMWXKFEJDQ/Hx8SE8PJy1a9fedP+JEydSsWJFfH19KV26NC+99BJXrlzJ1DFdXXQ0nDpl1pVEFxEREcn9lEQXyW65pKXLtSpUMPcEBg0yifUZM6BGjRw5f6qIiEieNnfuXPr378/w4cNZv349NWrUoFWrVpw4cSLF/b/88ksGDhzI8OHD2bZtG5988glz585l8ODBGT5mTmCvQi9WDPLnd24sIiIiIpL1lEQXyW72JHoOnVw0NZ6e8NZbpq1LaCjs22fe6sCBEBvr7OhEJMNsNvjkk1x1409EUjdhwgSefPJJevfuTZUqVZg2bRp+fn7MmDEjxf1XrlxJ/fr1efjhhwkNDaVly5Z069YtWaV5eo+ZE6iVi4iIiEje4uHsAETyHHtf9LVr4fJl8PV1bjwOZp909MUXYeZMePttmD8fPv8cqlZ1dnQikm6RkfDEE1CkCBw/Dh66dBDJra5evcq6desYNGhQ4jY3NzeaN2/OqlWrUnzN3Xffzeeff87atWupW7cue/fuZd68eTz66KMZPiZAbGwssdfchY/+by6ZuLg44uLiMvU+08N+ruvPuWuXG+BOaKiVuLiEbItHkqQ2NuJcGhfXpbFxXRob16RxcV2OHpu0Hkd/CYtkt3LlIDgYjh0zifTGjZ0dkcMVKGBaurRvD08+aZLqtWubSvWXXgI3fQZGJOeYO9c8njkDq1Yl3QgUkVzn1KlTJCQkEBgYmGx7YGAg27dvT/E1Dz/8MKdOnaJBgwbYbDbi4+N5+umnE9u5ZOSYAGPGjGHkyJE3bF+4cCF+fn7pfWuZtmjRomRfR0ZWB8KwWncxb17q70Oy3vVjI65B4+K6NDauS2PjmjQurstRY3Pp0qU07ackukh2s1hMufbcuaalSy5Mott17Aj16pki1l9/hQED4Jdf4NNPISTE2dGJyC3Fx8P33yd9PW+ekugikkxkZCRvvfUWH374IeHh4ezevZt+/foxatQohg4dmuHjDho0iP79+yd+HR0dTenSpWnZsiUFChRwROhpEhcXx6JFi2jRogWenp6J26dMcQegZctytG2rni7OkNrYiHNpXFyXxsZ1aWxck8bFdTl6bOyfeLwVJdFFnKFhQ5NEzwM9hgMD4eefTUvlF1+EJUugenV4/3145BE4fx5OnzbLmTMpr3t6mslLK1SA224zj5rESyQbLF0KJ08mff3bbzBmjPPiEZEsFRAQgLu7O8ePH0+2/fjx4wQFBaX4mqFDh/Loo4/yxBNPAFCtWjViYmLo06cPr7/+eoaOCeDt7Y23t/cN2z09PZ3yh+z15923zzxWqOCB/q52Lmf9TMjNaVxcl8bGdWlsXJPGxXU5amzSegwl0UWcwT656MqVptIzl/cYtlhMNfo998Cjj5qOED17Qq9eZs7CjAgKSp5YDwuzcPx4fq5eRX/MStb56y9YuBBefTVv/KB984157NgRfvoJNm+GQ4egdGmnhiUiWcPLy4vatWsTERFBx44dAbBarURERNC3b98UX3Pp0iXcruvT5u5uqrRtNluGjunqEhJg/36zrolFRURERPKG3J25E3FVt98OhQvD2bPwzz9w553OjihblCtnClvHjYMRI8A+d4O/PxQtmrQUKZJ8/coV2LULdu40jydOQFSUWZYtsx/dA2jKyy/bqFjRTGJarZp5rFoVQkPVi10c4LHHYMsW84P5zDPOjiZrJSQktXJ5+mkzqeiqVfD779Cnj3NjE5Es079/f3r27EmdOnWoW7cuEydOJCYmht69ewPQo0cPSpYsyZj/PpXSrl07JkyYwB133JHYzmXo0KG0a9cuMZl+q2PmNIcOmRoILy8oUcLZ0YiIiIhIdlASXcQZ3NygQQPTIHzp0jyTRAdTdD94MDz3HFy6ZHKRKXxa+6bOn0+eVN+5E3butLJ1awKXL3uyZYvJc86Zk/Qaf39z76JqVdNO5sEHzfyuIml26JD5wQKYOTP3J9GXLTN3rIoUgaZNTRX+qlWmpYuS6CK5VteuXTl58iTDhg0jKiqKmjVrMn/+/MSJQQ8ePJis8nzIkCFYLBaGDBnCkSNHKFasGO3atePNN99M8zFzmr17zWNYGPx3n0BEREREcjkl0UWcpVGjpCT6yy87O5psV7CgWTL62jp1zGIXF5fAb7/No1q1tmzfbhLpmzebnOe2bRATA2vXmgVMIv/FF01XjozGIXnMggVJ63/9BVu3mjszudW1rVw8PeHee2HoUPjjD4iNTf/dLxHJMfr27Ztqq5XIyMhkX3t4eDB8+HCGDx+e4WPmNPYkulq5iIiIiOQdam4g4iwNG5rH5cvBanVuLNlt3TpT2fr22w49rMUCZcqYXN9rr8Hnn8OGDXDxIvz7r5nLdehQU/h/6RK89Zb5A3jCBNMyRuSm7El0e9nhp586L5aslpAA331n1h94wDzWrGk+vnHpUp6YFFlEJDVKoouIiIjkPUqiizhLrVrg5wdnzpgM781cvWqq1keMMO0UciqbDaZNg7vvhj//hIEDk0rDs5CnJ1SubFq4vPEGrFkDP/xgtp05Yz4IcNttMGuWyR2K3CA+3lRgA7zyinmcPdtsz42WLzc90AsXhmbNzDaLBdq0Meu//ea82EREnGzPHvOoJLqIiIhI3qEkuoizeHqaZDJcOztmEqvVJLKeecZUf7ZvDyNHmtfcfbepEs1JGd+LF+HRR837uXoVAgLM9r59s70S32IxHSo2bYKPP4aSJU276969oUYN+Plnk+8XSbR2LZw7Z5LKw4dDsWJmZttrW7zkJte3crG7917zOG9etockIuIq7JXo5co5Nw4RERERyT5Koos4k72ly7WtEbZuNQ27y5Y1z0+bZsqlg4JMIt3Ly1Sj338/VKgAkyebBLUr27YN6taFL74wrTDGjTMZ7Pz5TW/pmTOdEpaHBzz+uJmcdNw4kx/duhU6dDDf+hUrMnZcqxWOHIHISJOkHzjQDFfNmuYP7tdfh2PHHPlOcj+bzfwabN1qCsK/+y6bv4f2ZHnz5uDjA488Yr6eNSsbg8gm17Zyuf/+5M81b25+cXbtMouISB6kdi4iIiIieY8mFhVxpkaNzGNkJLzzjkkyb9yY9Hz+/NC5M3TvDvfcY5JXUVHwwQcwdSrs2wf9+pnK2KeeguefN2XVruTLL6FPHzOzZ3CwaUxuv3kwYoTppTJokHmfhQs7JURfX9Oh44knTDJ94kSTQG/QAEqXhnz5TOcdf3+zXLtu//rSJdi92yx79sDly6mf76234N13TR725ZehSpVse6vZymqFo0fh338trF4dTGysBQ+PpCp/my35Opjv47FjZjl6NPljbOyN5wgPN8XSHTpApUrmUwZZwp5Eb93aPPbqBe+9Zz62cPo0FC2aRSd2ghUrzL8zhQqZpPm1ChQwv79//mmq0fv1c0qIIiLOcu6cuakLEBbm1FBEREREJBspiS7iTOHhplVCVBS8+qrZ5ulp+g537w7t2pkM77WCgmD0aFOt/umnJpG3a5eZpHP8eHjoIZOZrVkz299OMrGx8NJLJtkPZiLRL7+EwMCkfZ5/3pRqb9tmbgRMnuycWP9TuDCMGWM6zIwcCTNmmDYvGeHuDqEhNmqFnuGO4keoUuAwYV5HiL8cR/+tj7NktTczZphztG0LAwZAkyZZmATOIjabySHv3Jm07NqV9GhuJngAdR1yviJFzL0YT08zaeyaNWYZNMh8MMOeUL/rrqT5PzPt9GnziQmAli3NY/XqcMcd8M8/8NVX5ocmt7C3cunQwXzy5Xr33qskuojkWfYq9OLFzU12EREREckblEQXcSZfX+jUCb7+2lR3du9u2iekparVz8/0F3/qKTPp6Pjxprf655+bpWlTk0xv3Rrcsrlz07598MADsG6dyQoPGWKS5NdnNT09TeK8RQv48EN48kmoVi17Y01ByZLw0UcmkX7okCmiv3TJPKa0nu/wdqoeXUio52GCE45QOOYwPmeOYDlyBPZeueH4ka/sZ+X4cYwfbyY4nTfPLLVqmWT6/fcnb0PtKi5fhs2bTd74n39MEnvHDlOVlxoPDwgNteHufpYiRQrh5uaWeKPAYuGGdS8vkyQvUeLGx6Ag00nF7uhR86P/008QEWGS9u+8Y5bixc09qA4dTN7b2zsTb/yPP0xZ/e23Q6lSSdt79zbfiFmzck8S3WpNauXywAMp72O/6xMZaX4J/P2zLTwREWdTP3QRERGRvElJdBFn+/JLmD7dtEnICDc3kyns0MFUy06YYCpJFy82S+XKpiL8kUdurGrPCr/8Aj16mMxq0aImoW9vgZGS5s2hSxeTuHv+eVPh6iLl2MHBZrmpCxegbEM4dSr1fQICTPK1cGHz/iZN4u6nn+bu78qye7dpHzNjBqxfDw8/bHqo9+sH9eqZb2HRoqazRlorq69cMT3Z7cvhw+bx0iVzrICApMdr1wsWTLrfcvasSZLbE+b//APbt6c+l22ZMqYS/LbbzGJfDw0FiGfevGW0bdsWT0/H3dApUcLcQ3rqKTMM8+fDjz/Cb7/BiRPwySdmCQoyvwJPPWXeY7rZW7m0apV8e7du5kbVunXm7oIL3ADKtBUrTO+cggXNza2UVKpkehjs22fuXrRvn70xiog4kfqhi4iIiORNSqKLOJu7e8YT6Ne7807TWuLtt02F90cfmVYpffqY2SyffdYsxYs75nxgJjVdutQk0yIiknq633WXqbAvXfrWxxg/3pRiL1lieqY/9JDj4stqH35oEuglS5rK3VKlzHrJkma9RImkMmibzSRiFy0y7Xu+/Zby5U2L+5EjTeeb99+HgwdNbvZaFotJpBctalqaXPt46VLypPnp0xl7K+7u5pheXuY4KSlWzHQxsS9VqphqPD+/1I8bF5exeNIjf37z7X/gAXO+pUtNQt0+Aelrr8Gbb5oPb7z4okmsp4nNdmM/dLuAAFPu/v33php9/HjHvSFnuVUrFzA/jG3bwpQp5vdWSXQRyUOURBcRERHJm5REF8mNypQxM1cOG2ZKcSdONJnZkSNh7FhTKf7SS6ZKPb2uXjVNqO1J89WrIT4+6XmLBV54wczQmVoS7nohIaap9bBhpk3EfffljEajMTHm+wymmfqjj958f4vFfFKgRg2T3V26NHFy2aJFTdebAQNM8f7MmaZdyenTpsraZjPV4WfPpi00X9+kXL49n+/vb453+rTJ+1/7eOGCqTI/eTLpGGFhyRPmNWuaewJZ9kGB+fNNRfeLL2aqn42nJzRrZpbx45PuK23bZh4nToSePc1ksuXL3+JgW7aYgfD1TZoQ91q9e5sk+uefm98tV+zDk1ZpaeVid20S3WZzmU+PiIhktT17zKOS6CIiIiJ5i5LoIrlZgQImWf788yY5Nn68afkyfbpZ2rY1Pdnd3ZOaUl/fpNq+HDtmkuZLl5rk8bVCQ01blmbNTC/2jFS6v/KKyRzv2wdvvWUWVzdtmslClytnWnukRdWq5pMB06aZsfnrr2Q963184IknzGIXFwdnzpjl9OkbH729kxfAlyxpOsekJ68ZG5uUYI+JMR07ChVK++szxWYzN10GDjRf+/nBc8855NBeXiZh/uij8OuvJs+9apX5kMbHH5v+86+9ZvrRp8hehd64cfKG7HatWpnJco8fh99/z9lV2StXmhsGBQqk3srF7p57zPfj0CFzoyE3tLIREUkDVaKLiIiI5E1KoovkBR4e0LUrPPig6Xk8fryZjdE+o2V6BQQklfo2a+aYvyR9fOC996BjR1Pd3bu3aaztqi5dMjNYAgwebL7HafXGG6YX/vr18Nln0KvXTXf39DR52sDAjId7K97epsq8RImsO0eKEhLMJxc+/DBp29tvm0lm0/pJhjRwczP57XbtYPlyk0yfN890HPr6a5MzfuABM4zX3jtqMWsBwcDfAa3Z+aXZFhBg7hW5u2MG55FHzO/UrFk5O4l+bSuXW83E6utrvgn2f0OURBeRPCA+Hg4cMOuaWFREREQkb1ESXSQvsVigQQOz7N5t2jHs2mUqgVNbwDzmy2faWTRvbhJmbo6bIDJR+/am7/T8+aalx2+/Of4cjjJ9uqk+Dgm5dRuX6xUrZnq3vPqqaWNz//05o32No126ZGZS/ekn87P59tum3c2hQ+bmwrXl+A5isZgf44YNYdMmUwA/Z45pU79oUfJ9/YjhDEsBeOTzVuz4POm5228390I6dQJLr14mif7LL6YfTrFiDo87y1mt8O23Zv1WrVzs2rZNSqK/9lrWxSYi4iIOHTL3fr290zDxuIiIiIjkKkqii+RV5cubym9XYrHApEmm5cm8eab/xn33OTuqG125YrKvYKrQM9IH+4UXTEuXvXtN8njUKMfG6OpOnjRl4WvWmGzEF19Aly6mvPvll02P+V690lfhn07Vq5tW5qNHmwldd+xIfv+ozokleK+/ynGfMpSuX5FSmO3r18PWrSbcWrVg9OiqtK5TB8vff5tPGPTrl2UxZxXL6tVJrVxatkzbi9q2NY8rVphm/YULZ12AIiIuwN7KJSwsa2oJRERERMR16fJPRFzLbbeZXuFgkpFXrjg3npTMmGESjqVLm4bbGeHtndQO5t13zcSvecXu3VCvnkmgFylieu136WKee+op0y9l714zI2g2CA01heS//mo+/DBvnmlvPqqB6Yce2KM1i/6w8McfJtR9+8wHCfLlMwn1tm3hvTO9zMFmzcqWmB3NYp9QtH37W7dysQsLM5MTJyTcWMYvIpILaVJRERERkbxLSXQRcT1Dhpjm3Hv3muxmWthsWOLjszYuMDNwjhlj1gcOTHvCMSWdOpkJK69cSZpUM7dbvdok0PfsMdnrlSuhfv2k5/39TSU6wJtvmgSts9gnFW3VKtnmQoXMBwf27jWh+vjA6L3diMULNmxg8+wN2R5qplituH3/vVlPaysXO3s1ekbmVhARyWHslejqhy4iIiKS9yiJLiKuJ3/+pCrtN99MXqV94YIp/50712QyH30UwsPxCAyk/f3341GhArRpA/37w0cfwbJlpnWIo3z6KRw+bJqhPvZY5o5lsZiWOhaLqbpetcoxMbooy88/m8koT52C2rXN+61Y8cYdn33WtAbZsQPsFdLZbf9+c353dzN5bgqKFTMfItizB7o9W4RfLB0AiOgxi/btYePGrA3RajUfiFi2zBTADx0K3bvDXXeZJSIibccpvHMnliNHzO9dWlu52N17r3n8/XcTkIhILmZPoqsSXURERCTvUU90EXFN3bqZnuHLlpkWE4UKwc6dcOxYirtb7I8HDsCBA2Zy0msVLQqVKpn2E7ffbpLvRYumL6a4OHjrLbP+2mumBDmz7rjD9P6eOdO0sVm5Mlc2Wg2bNw/3jz82ida2bc1NkNQmUy1QwLTyGTHCNCy///7s/57Yq9DvugsKFrzpriVKmDl6j9fpBY99Q3e+4NVfxvHLL16ULg1VqpgfuypVktaLFLl1CAkJZu7aQ4fMfZvDh00rmb17TeJ+796bdztq2dL8uL76qrlPk2r8K1ealfbt0/8zXb++Sb6fOAHr1sGdd6bv9SIiOYiS6CIiIiJ5l5LoIuKaLBYz22OtWjeW9BYvbnqnX7PEhYYSsWEDzUND8di9G7Ztg+3bzeOBA3D6tJkAccUKc4wPP4TFi6FUqbTHNHu2OVZgIDz5pOPe65tvwtdfmx7hc+bAww877tjOlpCA26BBVP/oI/P1k0+a7/2tJgx94QXTymfzZvjlF+jQIetjvZY9id66dZpfEvhoS3g9mGLHjjGmwTxeWdGRQ4dMEtx+uMR9A5Mn1ePiTJL82oT50aNwqw5F7u5QpoxpLVC2rHksV858yz791HQJWrPGVKoXKJDCAazWpCR6elu5AHh5mWz9d9+Zli5KootILqae6CIiIiJ5l5LoIuK6atSA77+Hf/6BChVMwrxCBVOVfr24OGIPHsTWoAHcc0/y5y5dMlXs9qT6rFmwaxc0amQS6aGht44lPj6pCv2VV8DPL5Nv7hrBwTBokOkF/9pr0LGjY4/vLKdPQ/fuuP+XQU4YORL3oUNvXhZtV7gw9O1r+s+PGmWqpNPyumsdPGja+tx3n6n2T6u4uKReKNf1Q78pDw/zCYdx43i5yEweP9ORf/8lcdm2zTwePGgqzI8fhz//vPkh3d1NpXupUlC6lI3Q0gmEVfBITJiXKQOenje+rnNn03r++efhhx9g61bzWKVK8v0sf/2F36lT2PLnx5Ke93qttm1NEv2332D48IwdI7POnTO/zyVKmBlib3WTRkQknc6eNf/UgJlXWURERETyFv2VKSKurUOHzFch+/lBzZpmAXj8cdPnevduaNjQJNIrVLj5Mb76ypSgBQTA009nLp6U2Hu4HzxoKrCHDnXMcWNiYNEi+PlncyNgyhTTfiOrrV8PXbrA/v3YfH1Z9/TT1Bg0CPf0JMJfegkmTTJtQhYsSFdVOKdOmQT49u0mexwWZiZxTYvVqyE62rT7qVUr7ecEk6wfNw5++41Csce5++5A7r47+S4XLpiw7In17dvN/LSlSkHp0skfg4JMIp19+8zNlY1XzKcpAgJuGobFAk89ZX7k77/f3EOqWxdmzIAHH7xmv/96ztvuvRfLTVq5xMebjjopdtVp08Y8/vWXuTMQGHir75Ljvfee+dTC5s2mUX1emahXRLLNvn3mMSjIzIEtIiIiInlL7mu8KyJyK2XKwJIlpkf64cOmgvXff1PfPyHB9OYGGDAga/569vWFt98262PHwpEjGT/W8ePw8cemejsgADp1Mj3XZ8+GHj2yfgLImTPh7rvN5JzlyhG/bBlH0prAvlaxYkk3LEaNApstba+LiTHV59u3m6yv1Wpm3Dx9Om2vt/deadnyvwx2OlSuDOHh5mfmyy9T3CV/ftP1pGdPM9Q//mhaxI8fDy++aJLe4eFQsuR/p9+0yXw/N20y2fDXX09zOOHh5h5E06bm29K1q7lfExcH2Gy4ff89ANYuXW547alT5kMbHTuaVjAFC5pflZdeMj9KW7eat0lwcNLNhuvnIsgOZ86YJLrd8OE3/30WEcmAvXvNTWC1chERERHJm5REF5G8qUQJk0ivXh2iokyV8vW91+2+/tokL4sUgWefzbqYunY1PTguXUpXohSbzZQ0jx1rkq3Bwab3+C+/mJknQ0OhTx/Tv/rHH01COivExpqk92OPmfX77oO//zbf44waMMCUaa9ceeveJ2Cyww88YBqBFyliHitWNDclHnssbYl4exI9o+1N7K1jZs5Me+I/NcuWmcx1VFRS5mb6dPN9TaPixc1beu018/V770Hz5nD697VYDh4k3scHW8uWgKm0nDgRmjQxBeW9e8NPP8Hly3Dxogln4kRzL6ZqVZNcv/tu+N2tLQDnvpxnEvS3cvWqaQDvCOPHm/L+GjVMVfzVqybwWzWUFxFJByXRRURERPI2tXMRkbyreHGTmG3Z0pTr3nOPyTZeOzmi1ZqUdH7ppaxthWKxmAxleLiZFbJCBfDxMUnBuLgbl6tXTbJ6xQrT4/1adeqYNjjt20O1aubYd91lEskjRpiEY8eOjov90CFTQr12rTnXyJHmRoCbG2nLqqYiOBieeMK0oRk92pRUp8ZqNe/v999NC5/ffjPfhzlzzPf055/Ncfr2Tf0YJ0+anwUwPxcZ0bWrKSnfvNm0taldO2PH+eUX03vlyhWoX998/cIL8Pnn8NxzsGpVKv1VbuThYe6x1K1rcvzLllrZsfo17gZ2VanPF+P8+fXXG+8j3XGH+THp0MFUxa9fb74969ebqQpiYkwYb9CWNoyGhQsICoin0wMePPqo6ZaULMStW01Pmdmzzfd65syb9qu32cwHK4oXT+WtnjxpWv4AvPGGqYi//Xbzc/jee2b+AhERB9i3T0l0ERERkbxMSXQRyduKFDGTSLZpY7KBzZvDvHkmaQlmwsRt20wvi+efz/p46tY1rUe++MJMNJpWXl4mwdy+vVlKlrxxn969Tebz/ffNBJhr1tw402RGLF4MDz1kEpqFC5vY7X2yHeG110y/+D//NDcM7GNzLZvNJEw//9xkjL/91tw0ANMY/J13oF8/U9nesKG5iZCSRYvMsapXNwn8jChc2LTQmTPHTLo5YoS5EZDSDKCpmTXLvCYhwVT0z51rbgyMG2dKw9euNcnoJ55IV2idO5sh/7nxe9x9YgkX8ee+9f9j73rTtsbd3RS+2xPnISHJX1+1qqlCBxParl0mob7+r7qc/6AoheJPc3v0Sj75pBGffGI6Jz12fzR9Cs4leN4n5mfuWi+9ZHrdBwUlbjp1ygzDggWwcCEcO2aGY8oUaNDgujf0zjsmk1+nDrRrZ27gvPeemfdg6FCzrVKldH2PRERSYu+JXq6cc+MQEREREedQEl1EpGBBk7G77z5YutS08fj1V5NNtPdCf/FFs192eO8908IkJsYkXu2Ll1fyr+3LbbeZqukCBW597PHjYcsWk5Du0MEkYwsXzlicNlvSJI5Wq0lWf/ed48v0Spc21crTp5vx+P33G/d55x2YMMGsz5x5YxL/+efhjz9MNXfXrqacOqXe9vZWLumZxDQlo0aZ7PLOnaYF0KRJphS8QweT6L2Zd96BV1816z17mvdtT8AHB5sq//79zfe9c2dzIygdKsVtpuK5wQC8yEQOe4XQvrWVzp3duO8+M59qWri7m/x0pUrw8MPucLI1fPEFn3ebx0ifhhyeu4KHDn7CgxO+xp9LACS4eRDXqh0+z/Q2NxfWr8fa7yVW9P2KBQvMt3/duhu74GzaZO599Ohh7iMEBmJa3HzwgdnhjTeSvq+9e5sWTAsWmE8mLFuWrLf9pUvmV6tYsXR928RV2GymPZOfX7p/9kUyQ5XoIiIiInmbS/VEnzJlCqGhofj4+BAeHs7atWtT3Xf69Ok0bNiQwoULU7hwYZo3b37D/r169cJisSRbWmc2MSIiuVP+/CY526KFybC1aWOqljdtMs/165d9sRQrBp98YiqZZ882Fcf/+5+pIJ8wwUxAOnq0mUBx8GDTRiUtCXQwydi5c02J8e7d8PDD/80OmU5nzphWI6++ahLoPXuavuVZlV0YONAkQufPh7/+Sv7crFlJDb/Hj4dHHrnx9RaL+T6WKAE7dpi2KNezWjPfD92ufHlzs2LKFDOeO3aY6vRGjWD16pRfY7Waanp7Av2VV8wNgesr2Pv2NS1LTp821dbpERsLjzyC5epVbO3a0Xd9D2bPns+33ybQs2faE+gpuvdeAMpEfsYnKyuz4FJDejMLfy6xjUoM4B1KWA+Tb+H3tPmwHZ82mE4Cbrh9PYc3G83nzTdNq3ebzXQgGjDAVKQfPmxa+lss8Nln5p7R+++Ddczbpln7XXclv+lhsZhPLuTPbz5d8l+7l02b4JlnTAK+eHHzgYZp08yPsrigM2fM78pnn5lP5Tz4oLlRly+fubEWFpauuQFEMiM+3sLBg2ZdSXQRERGRvMllkuhz586lf//+DB8+nPXr11OjRg1atWrFiRMnUtw/MjKSbt268eeff7Jq1SpKly5Ny5YtOXLkSLL9WrduzbFjxxKXr776KjvejojkRH5+pm/2ffeZPtTvvWe2v/BCxqu1XVGxYmaCUV9fk5QePDjtr7XZ4KuvoHJl0zLF0xM+/NAke319syxkypY1bW4A3nwzafsvvyS1NHnlFVOhnZqAANNqxp5QnzMn+fObNpkG3H5+KbeMSS9PT1OFvnu36Q/v6wvLl5vJYx98EPbsSdo3Ls5UTb/7rvl63DizpFS17umZVIE9bZpp0ZNWw4aZ91msGJbp07m9qgVv7wzcRElJy5amcfmxY+amgb+/eU8rVhBw/F9C3x9AWHggCQnmx67X5FpMwtyc+p/bM/S8P4aZM02R8aZNpiC/eXPTmeh//zP51Dp1IDoaxr5whLj3p5rzXluFblemTOL3Mn7g6zx4xy5q1DDfrosXzS4rV5qkenAwdOlifiWuXnXMt0IyICrK/Ftbr565m1O0qFnv2dP8zn/zjWnaf8l8qoHoaHOzc+dO58YtecLJk74kJFjw8UnWfUpERERE8hCXSaJPmDCBJ598kt69e1OlShWmTZuGn58fM2bMSHH/L774gmeffZaaNWtSqVIlPv74Y6xWKxEREcn28/b2JigoKHEpnJsSYSLieD4+piVJly7ma39/08olt6lZ0yS+wSRrr08op2TfPpO0evhhOHHCJNKXLTOZyFu1KHGEQYPMeX76yWRZV6wwyeiEBJNoe/vtWx+jSZOkXvN9+sDevUnP2avQmzY17XQcpUAB88mBXbtMUtliMQnBypXNJxwOHjRtWT791FTbz5x56wkxmzQxfeitVjPJqNV66ziWLjWZaTAtYgIDM/3Wkila1LSaadkSPv7YJNM/+QTuvptixS307WsS4Tt2mFx+u3YQN+QNYgNLE2Ldz6ywkfTqZT4skJK6dc3rp02DEd5j8LbFspSG9Pq8Odffb9+5E17e/iSRHs3xiLvC8xsew9PdyoMPmk5GR46YHHuNGiZx/v335oMCwcHmvseqVTe2lHE5R46Ym0Evvmh+ni5fdnZEGWO1mp+XypXNRwxWr076eECpUub38emnzadwfvnF/ACdOmUmkT11yvy8HT3q3Pcgud7x46b9V9myaZ7PWURERERyGZfoiX716lXWrVvHoEGDEre5ubnRvHlzVq1alaZjXLp0ibi4OIpc1x8zMjKS4sWLU7hwYZo2bcro0aMpepPPq8fGxhIbG5v4dXR0NABxcXHExcWl521liv1c2XlOSRuNjWty6LhYLDB7Nm533YXt9tuxFSxoKoVzm86dcRswAPd338X22GPEly0Ld9xx437x8bhNmoTbG29guXwZm5cX1kGDsA4YYJLNt/jeOGxsypXD/f77cfvmG6zPPYdlyxYsV65gbduWhA8/hPj4tB1n0CDcIyJwW7kS60MPkRAZCZ6euM+fjxuQ0Lw51qwY7+LFTQb4uedwHzwYtwULYPJkswA2Hx8SvvwS2333pe3nbcwYPH79FcuqVcTPnInNPuNnSqKj8ejRA4vNhrV3bxLatoVr/l9z2L9nr72W1FrHHPiGXcLCrp0z1xtLrUnQuTO2CROIf/DB1Cd9/c9jzQ/iYZsOwDDeYMlnFn78ycbIkVYCA2189JEbf/7pBlj4julssVSjoW05x4dOIt/gvonHeeEFs2zaBF9+6cZXX7lx7JiFqVNh6lQoX95Gt25WunWzUr58Jr8v6ZTiuMTGYlm5EsuCBbgtXIhly5ak5yZNwpYvH7YOHbB27YqtWbP0TWTrLNu34/7ss7gtXw6AtVYtrP37Y6tUybRE8vNL/bU//4xHkyZYdu/G1rIl8YsXZ8snhhz9O6NriZzh+HHzs6hWLiIiIiJ5l0sk0U+dOkVCQgKB11XFBQYGsn379jQd47XXXqNEiRI0b948cVvr1q3p3LkzYWFh7Nmzh8GDB9OmTRtWrVqF+zWTjF1rzJgxjBw58obtCxcuxO9mf8xlkUWLFmX7OSVtNDauyaHjUqGCKVOdN89xx3Q19epxV61aBK5fT9x997Hk3Xe5es0EqoV27aLGhx9SaN8+AE7dfjsbn32WiyVLwnWf/LkVR4xN/vr1afrNN4lJt9OVKrGqZ08S0nls3169aLJxI15//cWeRx9lxwMP0Pa/Y/7p5UVMVo/5M89Q7O67qTJrFoX27SPOz4/VQ4Zwxs0tXT9v5bt04fZPPyXh5Zf5w8eH+Hz5UtzvjsmTKXPgADGBgUS2bEn8dedw6r9nbm7cWa8eJVat4uLDD7N07NhkE4Fer8aHHxJ69Sonq1Wj7SNuHPrfOfbuLcSLLya9xmKxUbv2cVq3Psau4925Y/r/yP/WQP4M9OVScPANx2zUyHTw2by5GJGRpVm1Kpjduz0YNcqdUaPcqVDhLI0aHaZBgyMULhx7w+uzyorPPiPwn38ovn49AVu24HHlSuJzNouFsxUqEB0aSvF//sHv5EksX3yB2xdfEFugAEfvvpvDDRtypnJllyuddYuLo8J331Hh229xi48n3seHbQ8/zN577zVjf/iwWW7B75VXaDhwID5btxLdpAmrRowgwZGfIrkJR/3OXLK3pxGXduxYUiW6iIiIiORNLpFEz6yxY8cyZ84cIiMj8fHxSdz+0EMPJa5Xq1aN6tWrU65cOSIjI2nWrFmKxxo0aBD9r+mpGx0dndhvvUBaJ+5zgLi4OBYtWkSLFi3wzAnVZHmIxsY1aVwyoUEDbPXr47d7N61mzCBh3jy4cgW3ESNwmzIFi9WKrXBhEt5+m4I9e9Iona1bHD021sWLcfv5Z2yVK1Pgzz9pdd0nkNLKUrAgdO1Khe+/p2yJErjFx2MrW5bGjz+ePe1p2raF114jPiICbruNu0JC0n+M5s2xrV6N944dtF69GuuECTfsYvnhBzwWL8bm5ob33Lm0vPvuxOdc5vemZk1s1atTeNcu7jt0COuzz6a83759eCxeDEDh99/npbvr8cIL8PHHCYwa5YabG/TubeWxx6yEhBQFioK1FtZdO/CIjKTZV1+RsHBhqknldu3MFAEXL9r48cd4vvrKjYgIC7t2FWbXrsLMnFmVe+6x8dBDVjp2tHHN/aZbio2F/fvh/HkLsbHm/tz1j3FxEHsFKi/+gBpLJlD8/KFkx7AFBmJr2RJry5bYmjcnf9Gi5AewWolfvRrL3Lm4ffst3idPEjZ/PmHz52MrXRrrAw9g7drVtHHKjp/tm7AsX477M89g2bEDAGvbttgmTaJMsRDW/WChUCFo2dKW9kL62rWxNWtG0W3baPvppyR8802WVuE7+nfG/olHcW3XtnMRERERkbzJJZLoAQEBuLu7c/z48WTbjx8/TtAtZu959913GTt2LH/88QfVq1e/6b5ly5YlICCA3bt3p5pE9/b2xjuFKiZPT0+nJBicdV65NY2Na9K4ZEDx4qbPeHg4bkuW4Na9O6xbB4f+S+B1745lwgQ8ihfP1GkcNjYffQR33YWld288M9PX294ge9o03P+bqNPSqhWeXl6ZjzE92rbN+Gvtk4y2aIH7hx/i/uSTcO3/hVFRpsk3YHntNTwaN07lME7+vQkJgTFjTKuboUNxv/9+M6Po9caONW17WrVKfC+entC3r1lsNrBY3IHrKtlnzIBq1XBbuhS3jz82feRvonBh6N3bLMePw9dfw5dfwurVFiIiLEREuNG3L9x7LzzRfD8ttryHe8tmnLirPXv3kuJy5Mit+6z7comPeYIWmEnQ4/DgL6/6HKrSGu8OrbmjZ3VCwtxSntCmcWOzTJ4MixebCYC//x7LoUO4T5iA+4QJ5ntq369xY7jttuxLqp87Z1r9fPSR+TowECZPJq79A0z/2MKbb5ofVzBzAHfrBj16QO3atwixdm3TK71lS9zmzcPtuefMeKf3fSUkmJ+tNFayO+p3Rv9f5Qxq5yIiIiIiLvH5Xi8vL2rXrp1sUlD7JKH16tVL9XXjxo1j1KhRzJ8/nzp16tzyPIcPH+b06dMEp/BRbhGRPK1KFfj8c7P+448mgR4WBvPnm+2ZTKA7VGCgmWT0FjdZ02TCBKhaNenrVq0yf8zs1rw53H9/0iSj9kytzQaPPw6nT5sK5BEjnBnlrT39NNx1F1y4AM8/f+Pzu3bBZ5+Z9RTarsFN8qZhYSYBDyaR+197orQIDDThrFoFe/aYOWIrV4a42ARKfz+RRs/ejseHk7F07MD8oJ60vvs8jzxiJk+dNcvM53r4sBkOf38IDYWKFaFaNZP/vftuM0/sow32saXA3TzMV8RbPHgnaCQlvU9R/2okD20YSKeRNQkt60a5cmZO3DlzuGFCVYB4PDh7Z0sOjpzJ1sXH2f7md0Q1uJ8ETx+Tyf/yS3jqKahUyczi2rUrfPghbN2aNbOpWq1JE+naE+hPPkn85m3MjHmQipUsPP+8SaCHhJjv96lTZo7RO+80/zSNGWPm301Vw4Ywd65pBTNrFgwcmPb49u41gxUWBlOmZOadSi5ls0FUlKlEL1fOycGIiIiIiNO4RBIdoH///kyfPp1PP/2Ubdu28cwzzxATE0Pv3r0B6NGjR7KJR99++22GDh3KjBkzCA0NJSoqiqioKC5evAjAxYsXeeWVV1i9ejX79+8nIiKCDh06UL58eVrlxCSJiEhW69AB3nkHChaEV1+FLVtyZlI5PXx9TTbSzw8KFYJ77nF2RBkzYYJ5D8uXwxdfmG0ffWT6q3t7mxsh2V1hn15ubiZmDw/44Qfz6YhrvfGGqRa+914ID0//8Z991jQ/j4kxJeanTqX7EGXLwuuvw9Y5m4muejcTeQl/LrGZqiTgRk8+Y6t7dfrViOSxx2DUKDMcq1aZivYLF0z+fvt2M6Hp33/DihXw5+BFfPZvHcpGbzQ3rCIWctu0Guw56cfixeac9eqZHPHevTB9uqnUDgw0xeQVK0JwsEnSe3pCkSImIV21jg+VX+9M8PJvyB93mqZEMNptGOvyNSbO3dtkrr/+2tx8qVrVnLtLF1PNvn592ifrvV5MDPz8s8n2lyplPvURFQUVK2L9cwnftPiIqg0L89hjcOCAif3DD2HnTnPDYd488/58fMz3avBgc/OhaVOTI79wIYVztm9vvjEA48bBu++mHt+lSzB7tjlguXJmoA4dgu++y9j7lVztzBm4dMl8YiA01LmxiIiIiIjzuEQ7F4CuXbty8uRJhg0bRlRUFDVr1mT+/PmJk40ePHgQt2t6mE6dOpWrV69y//33JzvO8OHDGTFiBO7u7mzatIlPP/2Uc+fOUaJECVq2bMmoUaNSbNciIiLAgAHw8stO75ucrW6/HTZvNhWz2Tj3hUOVLg1Dhphs4yuvmKpf+/weY8ea95gTVKtmfgbHjjX9WZo2hfz5Yds2U0ENJpmeEW5uiW1dWLLEfM8efRReeCH5pxFuJjYWRo/GMnYs/vHxUKAA1rffwRr+BEd3rKLU4B6U2reXiZuaQrOXYMCbJhOcGpvNJHsHDjQ/f3XrwnffYQsMhHnz8PEx93Xs93aio2HZMtOtJSICNm40Bfop8fY2P87585tHPz8/Nu9syp+nmjL0InhzhbqspTFLaOYeyV22VficOgXff28WMC+uVw8aNDBLeLi5WZOSQ4fg11/NsngxXDMJKv7+2Pq/zILagxn0kjcbNpjNRYuat/7cc+Z+ll2bNmaJjoZvvzX57shI033pzz/N/ZBWreCOO0z3oho1THLT0rs3nDxpPm3wyivmpkCPHknf6zVrYOZMc+PM3ovcYsHWvDnRXR7jcquOOODzLZLL7Ntn/j8MDrbh55eH/m8UERERkWRcJokO0LdvX/r27Zvic5GRkcm+3r9//02P5evry4IFCxwUmYhIHpKXEuh2uaHRbf/+JkG4a5dJeF65YpLQL7zg7MjSZ+hQUx29d6+5MTBpkkmcW63QsSPUqpXxY5crZ/pnv/qqqbSeQOE5cgAA8a5JREFUPt0szZrBiy+a/vSpTDrKihXwxBOmNBrMJzemTMGtZElqANxRH+7baMZh+nTz6YAFC0wG+I47bjxeTAw89ph5r2DWp0wxSfe4uBRDKFDAFOLfe6/5+tQp+Ocf8xJ7styeOE+pXsBmM5Ob/vUXrF3rw19/NeK9dY0YHTMUT65yJ3/RmCU0ZBn1LSspcCEaFi40C5hPCdSqZX6+GjaEYsXg999N4nzjxuQnCwmBdu242vI+Vng2Ycgob1aOMk/lz2/u1b300s3vWxUoYL4t9or1zz83HX127jRdp378MWnf/PlNQr16tVfo0/wENf8Yj+2xx7C4uRF/OArrxzPw2rMtcf+T+cL4rXhvZtl6smZZGa4sMh2Fpk5NPR7Jm/buNY9hYTYgD/7/KCIiIiKAiyXRRUREJIO8vU0j6datTQK9YEHT+yK1pLCr8vMzmcxWrcz7qVnT9LuGVHuhp0uzZkl9VCZNMlXXERFmKV/e3HTo1ctkZcFULA8aZPqNgOmh8sEHpu3J9Tec8uUzLWnatzcJ961bTfX2yJEmce/+34Sne/ZAp07mExCenqZ9ylNPpfsGVkAAtGiR9v0tFtP6OyzMdFgB0yFn2zZYu9aLv/6qz4K19XlnE1jjE6jKFhqwnAYspyHLKBV/BNauNcuECcmObbW4caRMPdYF3cci33asOleFQ3MsnPogaR8fH9Nf/rXXTBV6eoSEmLY2gweb4Vu2zOTtN22Cf/81LV5WrIAVKyxMYxyzOEGPhNnw6KOJF7uX8OVb7mcGj7H0YiNsF5N+NyyWVNrESJ5nr0TPDfdaRURERCTjlEQXERHJLVq1goceMknnadNMy5KcqGVLePhh08LlscfMtgceMKXGjmCxJLUoOXDAVIBPnw67d5sk+pAhZlLW2rVNv5HDh83rHnvMtF8pXPjmx7/vPpMgf+op09998GBTrf3ZZ+Yc3brB2bMmIf/dd1C/vmPeVwa4u5tuNlWrJn2rL1+Gf/5xZ82aGqxZU4PBa55j/34bZTiYmFRvwHKCiGIxTfmV+/jd1obTBwLgwI3nyJfPdM4ZMsTMZZoZFouZcPTOO5O2xcXBjh0moW4S624M3fgJBY+dpwM/s4q7+NzzMdaGPkiRsIJUKAPNypjEfJkyZilVyvWnDRDn2LvXJNFNJbqIiIiI5FVKoouIiOQms2ebRG/Jks6OJHPee8+0Cjl71mROR4zImvOEhJiJKIcNM0nuyZNNRva995L2KVvWVJg3a5b24xYrZhLkn31myq9XrjQ3Aa5cMa1p7rrLNPx2wXHy9YW77zaL3YkTFtauDWHNmhB+WNOdQWvh/HnzwYHSpaFmKZOILl3aPJa65uvChbO2S5SnZ9KNgIcfTtzKyRM/smXrKSpUK8YHRfNmpyrJvH37zKOS6CIiIiJ5m5LoIiIiuYmHh0smZtOteHGYOBF69oTevaFKlaw9X758ZsbKp582PcAnTjQTkPbta9qxpDah5s1YLCb+xo1Ni5glS8z2J580rWpy0ETnxYubAvv77jNfW61w8aLpeuOqyelixS0UK17M2WFIDqd2LiIiIiICSqKLiIiIq+rRwySgM9sDJD3c3Exf+datTabYET3lQ0Nh8WLzKYF8+Uw/9RzOze3mk4KK5BbPPmtl8eKDVKhQytmhiIiIiIgTKYkuIiIiriskxHnnduSkrG5upipdRHKUl16yUrHiJooVUxJdREREJC9z4F+HIiIiIiIiIiIiIiK5i5LoIiIiIiIiIiIiIiKpUBJdRERERERERERERCQVSqKLiIiIiIiIiIiIiKRCSXQRERERERERERERkVQoiS4iIiIiIiIiIiIikgol0UVEREREREREREREUqEkuoiIiIiIiIiIiIhIKpREFxERERERERERERFJhZLoIiIiIiIiIiIiIiKpUBJdRERERERERERERCQVSqKLiIiIiIiIiIiIiKRCSXQRERERERERERERkVQoiS4iIiIiIiIiIiIikgol0UVEREREREREREREUuHh7ABcnc1mAyA6OjpbzxsXF8elS5eIjo7G09MzW88tN6excU0aF9elsXFdGhvXpHFxXY4eG/v1pf16U1Kna3K5nsbGNWlcXJfGxnVpbFyTxsV1OeuaXEn0W7hw4QIApUuXdnIkIiIiIpIbXbhwgYIFCzo7DJema3IRERERyUq3uia32FT6clNWq5WjR4+SP39+LBZLtp03Ojqa0qVLc+jQIQoUKJBt55Vb09i4Jo2L69LYuC6NjWvSuLguR4+NzWbjwoULlChRAjc3dVm8GV2Ty/U0Nq5J4+K6NDauS2PjmjQurstZ1+SqRL8FNzc3SpUq5bTzFyhQQL+sLkpj45o0Lq5LY+O6NDauSePiuhw5NqpATxtdk0tqNDauSePiujQ2rktj45o0Lq4ru6/JVfIiIiIiIiIiIiIiIpIKJdFFRERERERERERERFKhJLqL8vb2Zvjw4Xh7ezs7FLmOxsY1aVxcl8bGdWlsXJPGxXVpbPIejbnr0ti4Jo2L69LYuC6NjWvSuLguZ42NJhYVEREREREREREREUmFKtFFRERERERERERERFKhJLqIiIiIiIiIiIiISCqURBcRERERERERERERSYWS6CIiIiIiIiIiIiIiqVAS3UVNmTKF0NBQfHx8CA8PZ+3atc4OKU9ZunQp7dq1o0SJElgsFn788cdkz9tsNoYNG0ZwcDC+vr40b96cXbt2OSfYPGbMmDHceeed5M+fn+LFi9OxY0d27NiRbJ8rV67w3HPPUbRoUfLly0eXLl04fvy4kyLOG6ZOnUr16tUpUKAABQoUoF69evz++++Jz2tMXMfYsWOxWCy8+OKLids0Ps4xYsQILBZLsqVSpUqJz2tcnOfIkSM88sgjFC1aFF9fX6pVq8bff/+d+LyuA/IOXZM7n67LXZOuyV2TrslzDl2Tuw5dk7suV7smVxLdBc2dO5f+/fszfPhw1q9fT40aNWjVqhUnTpxwdmh5RkxMDDVq1GDKlCkpPj9u3DgmT57MtGnTWLNmDf7+/rRq1YorV65kc6R5z5IlS3juuedYvXo1ixYtIi4ujpYtWxITE5O4z0svvcQvv/zCN998w5IlSzh69CidO3d2YtS5X6lSpRg7dizr1q3j77//pmnTpnTo0IGtW7cCGhNX8ddff/G///2P6tWrJ9uu8XGe22+/nWPHjiUuy5cvT3xO4+IcZ8+epX79+nh6evL777/z77//Mn78eAoXLpy4j64D8gZdk7sGXZe7Jl2TuyZdk+cMuiZ3Pbomdz0ueU1uE5dTt25d23PPPZf4dUJCgq1EiRK2MWPGODGqvAuw/fDDD4lfW61WW1BQkO2dd95J3Hbu3Dmbt7e37auvvnJChHnbiRMnbIBtyZIlNpvNjIWnp6ftm2++Sdxn27ZtNsC2atUqZ4WZJxUuXNj28ccfa0xcxIULF2wVKlSwLVq0yNa4cWNbv379bDabfmecafjw4bYaNWqk+JzGxXlee+01W4MGDVJ9XtcBeYeuyV2Prstdl67JXZeuyV2Lrsldj67JXZMrXpOrEt3FXL16lXXr1tG8efPEbW5ubjRv3pxVq1Y5MTKx27dvH1FRUcnGqGDBgoSHh2uMnOD8+fMAFClSBIB169YRFxeXbHwqVapEmTJlND7ZJCEhgTlz5hATE0O9evU0Ji7iueee49577002DqDfGWfbtWsXJUqUoGzZsnTv3p2DBw8CGhdn+vnnn6lTpw4PPPAAxYsX54477mD69OmJz+s6IG/QNXnOoN9H16Frcteja3LXpGty16RrctfjitfkSqK7mFOnTpGQkEBgYGCy7YGBgURFRTkpKrmWfRw0Rs5ntVp58cUXqV+/PlWrVgXM+Hh5eVGoUKFk+2p8st7mzZvJly8f3t7ePP300/zwww9UqVJFY+IC5syZw/r16xkzZswNz2l8nCc8PJxZs2Yxf/58pk6dyr59+2jYsCEXLlzQuDjR3r17mTp1KhUqVGDBggU888wzvPDCC3z66aeArgPyCl2T5wz6fXQNuiZ3Lbomd126JndNuiZ3Ta54Te6RJUcVEckGzz33HFu2bEnWr0ycp2LFimzYsIHz58/z7bff0rNnT5YsWeLssPK8Q4cO0a9fPxYtWoSPj4+zw5FrtGnTJnG9evXqhIeHExISwtdff42vr68TI8vbrFYrderU4a233gLgjjvuYMuWLUybNo2ePXs6OToREdeja3LXomty16Rrctela3LX5IrX5KpEdzEBAQG4u7vfMNPv8ePHCQoKclJUci37OGiMnKtv3778+uuv/Pnnn5QqVSpxe1BQEFevXuXcuXPJ9tf4ZD0vLy/Kly9P7dq1GTNmDDVq1GDSpEkaEydbt24dJ06coFatWnh4eODh4cGSJUuYPHkyHh4eBAYGanxcRKFChbjtttvYvXu3fm+cKDg4mCpVqiTbVrly5cSP9eo6IG/QNXnOoN9H59M1uevRNblr0jV5zqFrctfgitfkSqK7GC8vL2rXrk1ERETiNqvVSkREBPXq1XNiZGIXFhZGUFBQsjGKjo5mzZo1GqNsYLPZ6Nu3Lz/88AOLFy8mLCws2fO1a9fG09Mz2fjs2LGDgwcPanyymdVqJTY2VmPiZM2aNWPz5s1s2LAhcalTpw7du3dPXNf4uIaLFy+yZ88egoOD9XvjRPXr12fHjh3Jtu3cuZOQkBBA1wF5ha7Jcwb9PjqPrslzDl2TuwZdk+ccuiZ3DS55TZ4l05VKpsyZM8fm7e1tmzVrlu3ff/+19enTx1aoUCFbVFSUs0PLMy5cuGD7559/bP/8848NsE2YMMH2zz//2A4cOGCz2Wy2sWPH2goVKmT76aefbJs2bbJ16NDBFhYWZrt8+bKTI8/9nnnmGVvBggVtkZGRtmPHjiUuly5dStzn6aeftpUpU8a2ePFi299//22rV6+erV69ek6MOvcbOHCgbcmSJbZ9+/bZNm3aZBs4cKDNYrHYFi5caLPZNCaupnHjxrZ+/folfq3xcY6XX37ZFhkZadu3b59txYoVtubNm9sCAgJsJ06csNlsGhdnWbt2rc3Dw8P25ptv2nbt2mX74osvbH5+frbPP/88cR9dB+QNuiZ3Dboud026JndNuibPWXRN7hp0Te6aXPGaXEl0F/X+++/bypQpY/Py8rLVrVvXtnr1ameHlKf8+eefNuCGpWfPnjabzWazWq22oUOH2gIDA23e3t62Zs2a2Xbs2OHcoPOIlMYFsM2cOTNxn8uXL9ueffZZW+HChW1+fn62Tp062Y4dO+a8oPOAxx57zBYSEmLz8vKyFStWzNasWbPEi3WbTWPiaq6/YNf4OEfXrl1twcHBNi8vL1vJkiVtXbt2te3evTvxeY2L8/zyyy+2qlWr2ry9vW2VKlWyffTRR8me13VA3qFrcufTdblr0jW5a9I1ec6ia3LXoGty1+Vq1+QWm81my5oadxERERERERERERGRnE090UVEREREREREREREUqEkuoiIiIiIiIiIiIhIKpREFxERERERERERERFJhZLoIiIiIiIiIiIiIiKpUBJdRERERERERERERCQVSqKLiIiIiIiIiIiIiKRCSXQRERERERERERERkVQoiS4iIiIiIiIiIiIikgol0UVExOksFgs//vijs8MQEREREcmzdE0uIpI6JdFFRPK4Xr16YbFYblhat27t7NBERERERPIEXZOLiLg2D2cHICIizte6dWtmzpyZbJu3t7eTohERERERyXt0TS4i4rpUiS4iInh7exMUFJRsKVy4MGA+1jl16lTatGmDr68vZcuW5dtvv032+s2bN9O0aVN8fX0pWrQoffr04eLFi8n2mTFjBrfffjve3t4EBwfTt2/fZM+fOnWKTp064efnR4UKFfj555+z9k2LiIiIiLgQXZOLiLguJdFFROSWhg4dSpcuXdi4cSPdu3fnoYceYtu2bQDExMTQqlUrChcuzF9//cU333zDH3/8keyCfOrUqTz33HP06dOHzZs38/PPP1O+fPlk5xg5ciQPPvggmzZtom3btnTv3p0zZ85k6/sUEREREXFVuiYXEXEei81mszk7CBERcZ5evXrx+eef4+Pjk2z74MGDGTx4MBaLhaeffpqpU6cmPnfXXXdRq1YtPvzwQ6ZPn85rr73GoUOH8Pf3B2DevHm0a9eOo0ePEhgYSMmSJenduzejR49OMQaLxcKQIUMYNWoUYP4IyJcvH7///rv6QIqIiIhIrqdrchER16ae6CIiwj333JPsghygSJEiiev16tVL9ly9evXYsGEDANu2baNGjRqJF+sA9evXx2q1smPHDiwWC0ePHqVZs2Y3jaF69eqJ6/7+/hQoUIATJ05k9C2JiIiIiOQouiYXEXFdSqKLiAj+/v43fJTTUXx9fdO0n6enZ7KvLRYLVqs1K0ISEREREXE5uiYXEXFd6okuIiK3tHr16hu+rly5MgCVK1dm48aNxMTEJD6/YsUK3NzcqFixIvnz5yc0NJSIiIhsjVlEREREJDfRNbmIiPOoEl1ERIiNjSUqKirZNg8PDwICAgD45ptvqFOnDg0aNOCLL75g7dq1fPLJJwB0796d4cOH07NnT0aMGMHJkyd5/vnnefTRRwkMDARgxIgRPP300xQvXpw2bdpw4cIFVqxYwfPPP5+9b1RERERExEXpmlxExHUpiS4iIsyfP5/g4OBk2ypWrMj27dsBGDlyJHPmzOHZZ58lODiYr776iipVqgDg5+fHggUL6NevH3feeSd+fn506dKFCRMmJB6rZ8+eXLlyhffee48BAwYQEBDA/fffn31vUERERETExemaXETEdVlsNpvN2UGIiIjrslgs/PDDD3Ts2NHZoYiIiIiI5Em6JhcRcS71RBcRERERERERERERSYWS6CIiIiIiIiIiIiIiqVA7FxERERERERERERGRVKgSXUREREREREREREQkFUqii4iIiIiIiIiIiIikQkl0EREREREREREREZFUKIkuIiIiIiIiIiIiIpIKJdFFRERERERERERERFKhJLqIiIiIiIiIiIiISCqURBcRERERERERERERSYWS6CIiIiIiIiIiIiIiqVASXUREREREREREREQkFUqii4iIiIiIiIiIiIikQkl0EREREREREREREZFUKIkuIiIiIiIiIiIiIpIKJdFFRERERERERERERFKhJLqIiAsIDQ2lV69ezg4jT9m/fz8Wi4V33303y881a9YsLBYL+/fvT/drIyMjsVgsREZGOjwuEREREUk7+zXd33//7exQUtWkSROaNGmSodf26tWL0NBQh8bjaBaLhREjRjg7DBHJg5REF5FcIydc1Loii8WSbClQoACNGzfmt99+y/Axv/zySyZOnOi4IK/xyy+/0LhxY4oXL46fnx9ly5blwQcfZP78+VlyPhERERHJHvbr+dSW1atXOzvEDLEXb6RlyUjRRU52qzG3L66e3BeR3M/D2QGIiAjs2LEDNzfn3dds0aIFPXr0wGazceDAAaZOnUq7du34/fffadWqVbqP9+WXX7JlyxZefPFFh8b57rvv8sorr9C4cWMGDRqEn58fu3fv5o8//mDOnDm0bt3aoecTERERkez3xhtvEBYWdsP28uXLOyGazCtWrBizZ89Otm38+PEcPnyY995774Z9M2PhwoUZfu306dOxWq2ZOn96NWrU6IbvzRNPPEHdunXp06dP4rZ8+fIBcPnyZTw8lMoSkeynf3lERBwsPj4eq9WKl5dXml/j7e2dhRHd2m233cYjjzyS+HWXLl2oUqUKkyZNylASPSvEx8czatQoWrRokeIfBydOnHBCVCIiIiLiaG3atKFOnTrODsNh/P39k11rA8yZM4ezZ8/esP1aNpuNK1eu4Ovrm+ZzpedvkOt5enpm+LUZVbZsWcqWLZts29NPP03ZsmVT/N74+PhkV2giIsmonYuI5DlHjhzhscceIzAwEG9vb26//XZmzJiRbJ+rV68ybNgwateuTcGCBfH396dhw4b8+eefyfa7tq/2xIkTKVeuHN7e3vz777+MGDECi8XC7t276dWrF4UKFaJgwYL07t2bS5cuJTvO9T3R7R9rXLFiBf3796dYsWL4+/vTqVMnTp48mey1VquVESNGUKJECfz8/Ljnnnv4999/M9VnvXLlygQEBLBnz55k23/66SfuvfdeSpQogbe3N+XKlWPUqFEkJCQk7tOkSRN+++03Dhw4kOLHL2NjYxk+fDjly5fH29ub0qVL8+qrrxIbG3vTmE6dOkV0dDT169dP8fnixYsn+/rKlSuMGDGC2267DR8fH4KDg+ncufMN7wngo48+Shy7O++8k7/++uuGfbZv3879999PkSJF8PHxoU6dOvz888837Ld161aaNm2Kr68vpUqVYvTo0SlW9KTWzzGt47ZmzRpat25NwYIF8fPzo3HjxqxYseKWrxMRERHJ6a69Bn/vvfcICQnB19eXxo0bs2XLlhv2X7x4MQ0bNsTf359ChQrRoUMHtm3bdsN+R44c4fHHH0+81g0LC+OZZ57h6tWryfaLjY295TV6RoSGhnLfffexYMEC6tSpg6+vL//73/8AmDlzJk2bNqV48eJ4e3tTpUoVpk6desMxru+Jbp9f5+uvv+bNN9+kVKlS+Pj40KxZM3bv3p3stdf3RL/2+5yW6+VvvvmGKlWq4OPjQ9WqVfnhhx8c3mf9+mto+99cO3fu5JFHHqFgwYIUK1aMoUOHYrPZOHToEB06dKBAgQIEBQUxfvz4G46Z0b9PRCRvUSW6iOQpx48f56677sJisdC3b1+KFSvG77//zuOPP050dHRi+5Ho6Gg+/vhjunXrxpNPPsmFCxf45JNPaNWqFWvXrqVmzZrJjjtz5kyuXLlCnz598Pb2pkiRIonPPfjgg4SFhTFmzBjWr1/Pxx9/TPHixXn77bdvGe/zzz9P4cKFGT58OPv372fixIn07duXuXPnJu4zaNAgxo0bR7t27WjVqhUbN26kVatWXLlyJcPfp/Pnz3P27FnKlSuXbPusWbPIly8f/fv3J1++fCxevJhhw4YRHR3NO++8A8Drr7/O+fPnk3081f7xS6vVSvv27Vm+fDl9+vShcuXKbN68mffee4+dO3fy448/phpT8eLF8fX15ZdffuH5559P9j2+XkJCAvfddx8RERE89NBD9OvXjwsXLrBo0SK2bNmS7H19+eWXXLhwgaeeegqLxcK4cePo3Lkze/fuTazG2bp1K/Xr16dkyZIMHDgQf39/vv76azp27Mh3331Hp06dAIiKiuKee+4hPj4+cb+PPvooXdVDabF48WLatGlD7dq1GT58OG5ubol/WC1btoy6des69HwiIiIi2en8+fOcOnUq2TaLxULRokWTbfvss8+4cOECzz33HFeuXGHSpEk0bdqUzZs3ExgYCMAff/xBmzZtKFu2LCNGjODy5cu8//771K9fn/Xr1ycmeI8ePUrdunU5d+4cffr0oVKl/7N353E2Ff4fx9/33rmzMTPGMhjLhOwzdsmebCFFikqJ0KaQ1K9VKUVaqKiQ0kJFlnY7WbOGsRPZGQwz1jEz9/7+mO+9mRhmuDPn3ntez8djHsydu3xmjuXez7znfSrpwIED+uGHH3T27NlMCe/sPEe/Vtu2bdN9992nRx99VL1791bFihUlSZ988omqVq2qO+64QwEBAfr555/1xBNPyOFwqE+fPle932HDhslqtWrgwIFKSkrS8OHD1bVrV61YseKqt83O8+Vff/1VXbp0UVxcnIYOHaoTJ06oZ8+eKlGixPV9QbKpS5cuqly5soYNG6Zff/1VQ4YMUcGCBTVmzBjdeuutevvttzVx4kQNHDhQdevWVZMmTSRd3+sTACbjBAA/8cUXXzglOVetWpXldXr27OksXry489ixY5kuv/fee50RERHOs2fPOp1OpzMtLc2ZkpKS6TonTpxwFi1a1Pnwww+7L9u9e7dTkjM8PNyZkJCQ6fqvvvqqU1Km6zudTmfHjh2dhQoVynRZTEyM86GHHrrkc2nRooXT4XC4L3/66aedNpvNefLkSafT6XQePnzYGRAQ4OzQoUOm+3vttdeckjLdZ1YkOXv27Ok8evSoMyEhwbl69Wrnbbfd5pTkfOeddzJd1/X1udijjz7qDA0NdZ4/f959Wbt27ZwxMTGXXPfrr792Wq1W5+LFizNd/umnnzolOZcuXXrFWQcNGuSU5MyXL5+zTZs2zjfffNO5Zs2aS673+eefOyU533///Us+5vp6uo5doUKFnImJie6P//jjj05Jzp9//tl9WfPmzZ1xcXGZPkeHw+Fs0KCBs3z58u7L+vfv75TkXLFihfuyhIQEZ0REhFOSc/fu3e7LJTlfffXVS+b775+FBQsWOCU5FyxY4H7c8uXLO1u3bp3pz8bZs2edZcqUcbZs2fIyXzkAAADv53oOfLm3oKAg9/Vcz+NCQkKc+/fvd1++YsUKpyTn008/7b6sRo0azqioKOfx48fdl61fv95ptVqd3bp1c1/WrVs3p9VqvexrCddzruw+R8+Oyz1fjomJcUpyzpw585LrX+55eOvWrZ1ly5bNdFnTpk2dTZs2db/vei5ZuXLlTK9vPvjgA6ckZ3x8vPuyhx56KNNMOXm+HBcX5yxZsqTz1KlT7ssWLlzolHTZ1wVXki9fvixfx/z3ObTrNdcjjzziviwtLc1ZsmRJp8VicQ4bNsx9+YkTJ5whISGZ7vt6X58AMA/qXACYhtPp1NSpU9W+fXs5nU4dO3bM/da6dWslJSVp7dq1kiSbzeZOmzgcDiUmJiotLU116tRxX+dinTp1yvIkQI899lim9xs3bqzjx48rOTn5qjM/8sgjslgsmW6bnp6uPXv2SJLmzZuntLQ0PfHEE5lu99RTT131vi82fvx4FSlSRFFRUapTp47mzZun5557TgMGDMh0vYsT1adOndKxY8fUuHFjnT17Vlu3br3q40yZMkWVK1dWpUqVMn39b731Vkm6pC7nvwYPHqxJkyapZs2amjVrll566SXVrl1btWrVyvQjuVOnTlXhwoUv+3W4+OspZaRWIiMj3e83btxYkrRr1y5JUmJioubPn6/OnTu7P+djx47p+PHjat26tXbs2KEDBw5Ikn777TfdfPPNmZLgRYoUUdeuXa/6tcmudevWaceOHbr//vt1/Phx9zxnzpxR8+bNtWjRojw/IRQAAIAnjR49WnPmzMn09vvvv19yvQ4dOmRKOt90002qV6+efvvtN0nSoUOHtG7dOnXv3j3TTzFWq1ZNLVu2dF/P4XBoxowZat++/WW72P/7/PFqz9GvR5kyZS57TqKLn4e7kvpNmzbVrl27lJSUdNX77dGjR6Y0/X+f817J1Z4vHzx4UPHx8erWrZv7J1AlqWnTpoqLi7vq/XtCr1693L+32WyqU6eOnE6nevbs6b68QIECqlixYqbP+XpfnwAwD+pcAJjG0aNHdfLkSY0dO1Zjx4697HUuPjnll19+qffee09bt25Vamqq+/IyZcpccrvLXeZSunTpTO+7noCeOHFC4eHhV5z5SreV5H6ifuONN2a6XsGCBTM90b2aO++8U08++aQuXLigVatW6a233tLZs2dltWb+XuumTZv08ssva/78+Zd8EyA7T9537NihLVu2ZPkNh+ycHPS+++7Tfffdp+TkZK1YsUITJkzQpEmT1L59e23cuFHBwcH6+++/VbFiRQUEXP2/uat9jXfu3Cmn06lXXnlFr7zySpZzlyhRQnv27FG9evUu+bjrx3A9YceOHZKkhx56KMvrJCUl5ej4AwAAeJObbropWycWLV++/CWXVahQQZMnT5b073Plyz0Xq1y5smbNmqUzZ87o9OnTSk5OVmxsbLbmu9rzx+uR1euKpUuX6tVXX9Xy5csvOb9SUlKSIiIirni/1zPztb4mcV12uRCSp/13xoiICAUHB6tw4cKXXH78+HH3+554fQLAHFiiAzANVzr3gQceyHIBWa1aNUnSN998o+7du6tDhw569tlnFRUVJZvNpqFDh172xJRX6ry22WyXvdzpdF515uu5bU6ULFlSLVq0kCS1bdtWhQsX1pNPPqlmzZrprrvukiSdPHlSTZs2VXh4uF5//XWVK1dOwcHBWrt2rf7v//4vW+lnh8OhuLg4vf/++5f9eKlSpbI9c3h4uFq2bKmWLVvKbrfryy+/1IoVK9S0adNs34d09a+x6/MaOHDgZVNB0uVfMFyri0/Sejmued55551LuvldLk4AAQAAwLNy8zn65V5X/P3332revLkqVaqk999/X6VKlVJgYKB+++03jRgxIlvPw33hNcn1uNyM2Znbk69PAPg3lugATKNIkSIKCwtTenq6e2GclR9++EFly5bVtGnTMv2o5quvvprbY+ZITEyMpIy09MWplePHj19XEubRRx/ViBEj9PLLL6tjx46yWCxauHChjh8/rmnTprlPxCNJu3fvvuT2//2RV5dy5cpp/fr1at68eZbXuRZ16tTRl19+qUOHDrkfZ8WKFUpNTXWf7OhalS1bVpJkt9uv+ucmJibGnRS/2LZt2y65LDIyUidPnsx02YULF9yfQ1ZcJ0UNDw+/6jwAAAD+7HLPu7Zv3+4+WajrufLlnott3bpVhQsXVr58+RQSEqLw8HBt3LgxV+e9Vj///LNSUlL0008/ZUpce0vVyMWvSf7rcpd5k9x6fQLA/9CJDsA0bDabOnXqpKlTp172CfLRo0czXVfKnFJYsWKFli9fnvuD5kDz5s0VEBCgTz75JNPlo0aNuq77DQgI0DPPPKMtW7boxx9/lHT5r8mFCxf08ccfX3L7fPnyXbbepXPnzjpw4IDGjRt3ycfOnTunM2fOZDnT2bNns/z6uzoyXT+q26lTJx07duyyX4ecJmaioqJ0yy23aMyYMZddcF/856Zt27b6888/tXLlykwfnzhx4iW3K1eunBYtWpTpsrFjx141iV67dm2VK1dO7777rk6fPn3FeQAAAPzZjBkz3OemkaSVK1dqxYoVatOmjSSpePHiqlGjhr788stM4YWNGzdq9uzZatu2rSTJarWqQ4cO+vnnn7V69epLHsfoxPXlnocnJSXpiy++MGqkTKKjoxUbG6uvvvoq0/PTP/74Q/Hx8QZOdnXX8/oEgLmQRAfgdz7//HPNnDnzksv79eunYcOGacGCBapXr5569+6tKlWqKDExUWvXrtXcuXOVmJgoSbr99ts1bdo0dezYUe3atdPu3bv16aefqkqVKpddXBqlaNGi6tevn9577z3dcccduu2227R+/Xr9/vvvKly48HWlKbp3765Bgwbp7bffVocOHdSgQQNFRkbqoYceUt++fWWxWPT1119f9kVF7dq19f3332vAgAGqW7eu8ufPr/bt2+vBBx/U5MmT9dhjj2nBggVq2LCh0tPTtXXrVk2ePFmzZs3Ksv/y7NmzatCggW6++WbddtttKlWqlE6ePKkZM2Zo8eLF6tChg2rWrClJ6tatm7766isNGDBAK1euVOPGjXXmzBnNnTtXTzzxhO68884cfS1Gjx6tRo0aKS4uTr1791bZsmV15MgRLV++XPv379f69eslSc8995y+/vpr3XbbberXr5/y5cunsWPHKiYmRhs2bMh0n7169dJjjz2mTp06qWXLllq/fr1mzZp1SW/jf1mtVn322Wdq06aNqlatqh49eqhEiRI6cOCAFixYoPDwcP388885+vwAAAC8ye+//37Zk9Y3aNDA/VOCUkalXqNGjfT4448rJSVFI0eOVKFChfTcc8+5r/POO++oTZs2ql+/vnr27Klz587po48+UkREhF577TX39d566y3Nnj1bTZs21SOPPKLKlSvr0KFDmjJlipYsWaICBQrk5qd8Ra1atVJgYKDat2+vRx99VKdPn9a4ceMUFRV11Z9izCtvvfWW7rzzTjVs2FA9evTQiRMnNGrUKMXGxnrV66f/up7XJwDMhSU6AL/z31S2S/fu3VWyZEmtXLlSr7/+uqZNm6aPP/5YhQoVUtWqVfX2229nuu7hw4c1ZswYzZo1S1WqVNE333yjKVOmaOHChXn0mWTP22+/rdDQUI0bN05z585V/fr1NXv2bDVq1EjBwcHXfL8hISF68skn9dprr2nhwoW65ZZb9Msvv+iZZ57Ryy+/rMjISD3wwANq3rz5JV3hTzzxhNatW6cvvvhCI0aMUExMjNq3by+r1aoZM2ZoxIgR+uqrrzR9+nSFhoaqbNmy6tevnypUqJDlPAUKFNC4ceP066+/6osvvtDhw4dls9lUsWJFvfPOO+rbt6/7ujabTb/99pvefPNNTZo0SVOnTlWhQoXci/CcqlKlilavXq3BgwdrwoQJOn78uKKiolSzZk0NGjTIfb3ixYtrwYIFeuqppzRs2DAVKlRIjz32mKKjo9WzZ89M99m7d2/t3r1b48eP18yZM9W4cWPNmTNHzZs3v+o8t9xyi5YvX6433nhDo0aN0unTp1WsWDHVq1dPjz76aI4/PwAAAG9y8fOri33xxReZlujdunWT1WrVyJEjlZCQoJtuukmjRo1S8eLF3ddp0aKFZs6cqVdffVWDBg2S3W5X06ZN9fbbb2eqQyxRooRWrFihV155RRMnTlRycrJKlCihNm3aKDQ0NPc+2WyoWLGifvjhB7388ssaOHCgihUrpscff1xFihTRww8/bOhsLu3bt9e3336r1157Tc8//7zKly+vCRMm6Msvv9SmTZuMHi9L1/P6BIC5WJxG/1wSAMDjTp48qcjISA0ZMkQvvfSS0eMAAAAAHvPPP/+oTJkyeueddzRw4ECjx8EV1KhRQ0WKFNGcOXOMHgUArgud6ADg486dO3fJZSNHjpSUkVgGAAAAgNyUmpqqtLS0TJctXLhQ69ev5zUJAL9AnQsA+Ljvv/9eEyZMUNu2bZU/f34tWbJE3377rVq1aqWGDRsaPR4AAAAAP3fgwAG1aNFCDzzwgKKjo7V161Z9+umnKlasmB577DGjxwOA68YSHQB8XLVq1RQQEKDhw4crOTnZfbLRIUOGGD0aAAAAABOIjIxU7dq19dlnn+no0aPKly+f2rVr5z5PEAD4OjrRAQAAAAAAAADIAp3oAAAAAAAAAABkgSU6AAAAAAAAAABZYIkOAAAAAAAAAEAWOLHoVTgcDh08eFBhYWGyWCxGjwMAAAA/4XQ6derUKUVHR8tqJdtyJTwnBwAAQG7I7nNyluhXcfDgQZUqVcroMQAAAOCn9u3bp5IlSxo9hlfjOTkAAABy09Wek7NEv4qwsDBJGV/I8PDwPHvc1NRUzZ49W61atZLdbs+zx8XVcWy8E8fFe3FsvBfHxjtxXLyXp49NcnKySpUq5X6+iazxnBz/xbHxThwX78Wx8V4cG+/EcfFeRj0nZ4l+Fa4fFw0PD8/zJ+yhoaEKDw/nL6uX4dh4J46L9+LYeC+OjXfiuHiv3Do21JNcHc/J8V8cG+/EcfFeHBvvxbHxThwX72XUc3LKFwEAAAAAAAAAyAJL9CyMHj1aVapUUd26dY0eBQAAAAAAAABgEJboWejTp482b96sVatWGT0KAAAAAAAAAMAgLNEBAAAAAAAAAMgCS3QAAAAAAAAAALLAEh0AAAAAAAAAgCywRAcAAAAAAAAAIAss0QEAAAAAAAAAyAJLdAAAAAAAAAAAssASHQAAAAAAAACALLBEBwAAAAAAAAAgCyzRAQAAAAAAAADIAkt0AAAAAAAAAACywBIdAAAAAAAAAIAsBBg9AC5v8KLBSjiaoIh9EapVopbCg8KNHgmS0hxp+mLdF1qesFwH1h5QREiE8gfmz/It0BYoi8Vi9NiAoWbvmq0ph6do47KNsgfYZbPYZLPaLvur3WZXcECwQgJCFGIPUag91P37//5qtfB9YABA7lr9yWodWnZIp2qcUsGYgkaPAwAAAIOwRPdCF9IvaPiy4Up1pGrc1+MkSeUiy6lGsRqZ3kqElWBBm8d+3/G7Hv3tUUnShIMTrnr98KBw3Vjwxoy3yBv//X3BG1UsfzGOH/xeckqyOk7uqFRHqnTYs/edPzC/woPCFREUoYjgiMy/XvT7QqGFVCS0iIrkK+L+NdAW6NlhAAB+aeXIlTq5+6SSn0xmiQ4AAGBiLNGzMHr0aI0ePVrp6el5/tjn087r2frPanb8bB12Htb+U/v194m/9feJvzV1y1T39QqFFFKNYjV0U4mb9NRNT6l4WPE8n9VsDp/O2AIWshdSozKNdDbtrE5fOH3J27m0c5IyFohrD63V2kNrL7mvfPZ8KlewnMoXLK9KhSupQakGalCqgQoEF8jLTwnIVSfPn1SqI1VWWfVgtQfltDiV7khXujP9sr+mOlJ1LvWczqed17m0czqXei7TrxfSL7jv2/X37eCpgzmeKzwoPPNiPbSIiuUvphLhJVQirIRKhpdUifASisoXReIdAEwsIDjj5VLquVSDJwEAAICRWKJnoU+fPurTp4+Sk5MVERGRp48dHhSu15q+ppvO3KS2bdsqKTVJ6w+v17rD67TuyDqtO7xOW45u0fFzxzVv9zzN2z1PH638SC82elFP139awQHBeTqvmbiW45XzVdaUu6fIbrdf9nrpjnSdvnBaB04d0M7EnZe87UnaozOpZ7ThyAZtOLLBfTuLLIorGqfGpRurUelGaly6sUqEl8iTzw3IDSlpKZKkIGuQxt0+Lsu/M9mV7kjX+bTzOpt6VskpyUpKSVLS+aQsfz2ZclLHzx7X0bNHdfTMUR07e0zpznQlpyQrOSVZf5/4+4qPF2ANUPH8xVUi/H+L9f8t2MsUKKOykWVVJrIM3/gCAD8WEJLxcintXJrBkwAAAMBILNF9QOHQwmpetrmal23uvux82nltStikvw7/pXFrx2nlgZV6cf6LGrt2rN5p+Y46Ve5EVUguOJt6VpIUaL1yFYTNasuokgiOUJUiVS75+IX0C/rn5D/upfq6w+u0eO9i7Uzc6V6sj141WpJUpkAZ90K9cUxjVSxUkWMLn5GSnrFEt1uub3nuYrPalC8wn/IF5lORfEVyfHuH06GT50/q6Jmj7sW669dDpw/pwKkDOpB8QPuT9+vw6cNKc6RpX/I+7Uvel+V9FggukLFQdy3W//dr2ciyuqHADbLbPPO5AwDyHkt0AAAASCzRfVZwQLBqR9dW7ejaerjmw5oUP0nPz31e/5z8R/dMuUdNYppoZOuRqlm8ptGj+pVzqRlJ9CBr0HXdT6AtUBUKVVCFQhUyXX749GEt2btES/Yu0eK9i7Xu8DrtPrlbu0/u1tcbvpYkVShUQZ2rdFbnqp0VGxXLQh1ezZVEt1u9Y5FstVhVMKSgCoYUVEVVvOJ10xxpOnz6sPYn79eB5APuBfve5L3afSLj72XCmQSdPH8yy9qmAGuAykWWU6XClVSpcCVVLFTR/fvIkMjc+jQBAB5iD8n4/4slOgAAgLmxRPcDVotVD1R7QB0rddTwpcM1fNlwLdqzSLXH1laPGj30ZvM3VSx/MaPH9AuuOpdAS+6clLBY/mK6u8rdurvK3ZKkUymntHz/cvdSffm+5dp+fLuGLB6iIYuHqFLhSrqnyj3qXLWzqhapykIdXseVRA+w+N5/NwHWAJUML6mS4SWzvM7pC6f1z8l/tOvELvdifdeJXe5fz6ae1bbj27Tt+Db9uO3HTLctElrEvVCvWqSqqhWtpmpFq6lQaKHc/tQAANnk7kQ/Tyc6AACAmfneVgNZyheYT4ObDVbPWj31/Nzn9e3Gb/X5us81efNkvdT4JfW/uT996dfJlUS/Wp2Lp4QFhalVuVZqVa6VpIyl+i/bf9HkzZP1+47ftfXYVr2x6A29segNVS5cWZ2rZiTUL1chAxjBnUT3UJ2Lt8kfmF+xUbGKjYq95GMOp0MHkg9o67Gt2nZ8W6Zf9yfvz6iR2XtUi/cuznS76LBoVS9a3b1Ur1a0mioWqkgtDAAYgDoXAAAASCzR/VLpiNKa1GmSnrzpSfWf2V+rDq7SC/Ne0Ng1Y/VVx6/UqHQjo0f0Wa5O9Outc7lWYUFhui/uPt0Xd5+SU5L187afNXnzZM3cOVNbjm3R4D8Ga/Afg1WlSBX1qNFDvWr14qSHMJS7E91L6lzyktViVamIUioVUUoty7XM9LHTF05r+/Ht2npsq7Yc3aKNRzdqw5EN2nVilw6eOqiDpw7q952/u69vt9pVpUgV1ShWQ3Wi66hudF1VL1adb4wCQC6jzgUAAAASS3S/1qBUA/3Z609N3DBRz897XrtP7lbrb1rrl/t+UbMyzYwezyfldp1LToQHhatrta7qWq2rks4n6adtP2ny5smatXOWNh/drGfnPKvXFr6mHjV6qG+9vipfqLzRI8OE/D2Jfq3yB+ZXreK1VKt4rUyXn0o5pfiEePcJhl1vpy6c0voj67X+yHp9uf5LSRmL9biicaobXde9WK8aVVUBVv5rBwBPcSXRU89R5wIAAGBmvNL2c1aLVQ9Wf1AdK3fUPVPu0cydM9VuUjv9dN9PalG2hdHj+RzXEt2oJHpWIoIj9GD1B/Vg9Qd18vxJ/bD5B3244kPFJ8Rr1KpRGr1qtNpVaKf+9frr1jK30p2OPONOorNEz5awoDA1KNVADUo1cF/mdDr1z8l/tP7Ieq09tFarD67WqoOrdOzsMfcJTcesGSNJCgkIUc3iNVU3uq4almqohqUbKjos2qhPBwB8HnUuAAAAkFiim0b+wPya3mW67p58t37d8avaf9teP977o7trG9njqnPJq070a1EguIB61eqlnjV7av7u+Rq5YqR+2f6L+y0uKk79b+6v++PupwoCuc6VRCcdfe0sFovKRJZRmcgy6lCpg6SMxfqepD1adWCVe6m+5tAaJacka9m+ZVq2b5k+WPGBJKlMgTJqVLqRGpZqqEalG6lykcqyWqwGfkYA4DtcJxZNO88SHQAAwMzYaphIcECwpnaeqnum3KOft/+sO769Q9O7TFeb8m2MHs1nuE4s6m1J9MuxWCxqXra5mpdtru3Ht+vDFR/qi3VfKD4hXj1/yjj57GN1HtMTdZ9QsfzFjB4Xfookeu6wWCy6ocANuqHADbqn6j2SMk5kuuP4Dq06uEp/7v9TS/ct1YYjG7T75G7tPrlbX2/4WpIUGRypBqUaqFHpRqpXvJ5SHVQUAEBW6EQHAACAxBLddIICgvRD5x/U5YcumrF1hjp830FTO0/V7RVuN3o0n+BNneg5UaFQBY1qO0pvNHtD4/8ar49WfqS9SXv1xqI39O6ydzWg/gA91/A5hQeFGz0q/Ayd6HnHarGqYuGKqli4oh6o9oAkKTklWX/u/1NL9i7R0n1L9ef+P3Xi/An9uuNX/brjV0kZ/541OdUk45tuZZqrVvFaslltRn4qAOA16EQHAACAJPHz3CYUaAvU5Lsnq1PlTrqQfkF3fX+Xftr2k9Fj+QRXEt2b61yuJDIkUgMbDNTfff/W5Lsnq16JejqXdk5vLn5TN354o0avHK3UdF4kwnPcSXQrS3QjhAeFq1W5Vnq92eua122eTv7fSa3stVIjWo9Qp8qdFBUapQvOC5q7e65emPeCbvrsJhUaXkgdvuugj1Z8pE0Jm+R0Oo3+NADAMHSiAwAAQGKJblp2m13fdvpW91S5R6mOVHWa3EnTt0w3eiyv5+pE94U6lysJsAbonqr3aHnP5ZreZboqFKqgo2eP6snfn1TVj6tq2pZpLM7gESTRvYvdZlfdEnXV/+b++qHzD9rXb58+rPih3m/5vu6seKcigiKUlJKkH7f9qL4z+yr2k1gVf6+47p96vyasm6DDpw8b/SkAQJ5y17nQiQ4AAGBqLNFNzG6za1KnSbo39l6lOdLU+YfOmrp5qtFjeTV3nYuPJtH/y2KxqEOlDtr4+EZ93PZjReWL0o7EHeo0uZMaft5Qy/YtM3pE+Dg60b2bxWJR6ZDSerLuk5px7wwde+6YVvZaqaHNh6pl2ZYKCQjRkTNH9O3Gb9Xjxx4q/l5x1R5bW6/Mf0XL9y1XuiPd6E8BAHKV68Si1LkAAACYG0t0kwuwBujrjl+ra1xXpTnS1OWHLpq8abLRY3ktd52Lj3WiX43dZtfjdR/Xzqd26pUmryjUHqrl+5er4ecN1WlyJ20/vt3oEeGjXEn0AAun4PAFAdYA1S1RV883el6zH5ytE/93QgsfWqiXG7+sOtF1JElrD63VkMVD1ODzBop6N0pdp3XVNxu+0dEzRw2eHgA8jzoXAAAASCzRoYylyZcdvlS36t2U7kzXfVPv03cbvzN6LK/kqnPxlyT6f4UFhen1Zq9rx1M71LtWb1ktVk3bMk1VP66qJ397UifPnzR6RPgYVxLdX//O+LuggCA1vaGp3rj1Da3qvUqHnzmsLzt8qS5Vu6hAcAElnkvUpPhJenD6gyr6blHd/NnNeuOPNxR/JJ5KKAB+wV3nwhIdAADA1FiiZ2H06NGqUqWK6tata/QoecJmtenzOz5Xjxo95HA61OPHHtp6bKvRY3mVdEe6Uh0ZP8rr653oVxMdFq2x7cdqw2MbdHuF25XmSNPoVaMV+3Gsft/xu9HjwYfQie5fiuYvqm7Vu+m7u7/T0WePanGPxXqx0YuqUayGnHJqxYEVGrRwkKp9Wk0VRlXQc3Oe0/J9y+VwOoweHQCuCUl0AAAASCzRs9SnTx9t3rxZq1atMnqUPGOz2vTZHZ+pVblWOp92Xg/NeEhpDl4wuLj60CX/X6K7VI2qqp/v+1nzu81X+YLldeDUAbWd1FYP//gwqXRkiyuJHmClzsXfBFgD1Kh0I73Z/E399ehfOjDggD5r/5nuqHiHgmxB2pm4U+8se0cNPm+gku+X1BO/PqE5f89Rajq9wgB8h2uJnnqef7sAAADMjCU6MrFarBp/x3hFBEVo5YGVGrZkmNEjeQ1XlYtkvlRtszLNtO6xdRpw8wBZZNEX675Q7Mex+m3Hb0aPBi/HiUXNIzosWj1r9dSP9/6oY88d05R7pui+2PsUHhSuQ6cP6ZPVn6jVN60U9W6Uuk3vpulbput82nmjxwaAK3KdWJQkOgAAgLmxRMclSoaX1Oi2oyVJg/8YrLWH1ho8kXdwnVQ0OCBYVov5/uqE2kP1Xuv3tLjHYncqvd2kdurxYw9S6cgSdS7mlD8wv+6ucrcmdZqkhIEJ+u3+39S7Vm9F5YvSyfMn9fWGr3XX5LtU9N2i6j6ju2btnMVPPgHwSnSiAwAAQGKJjizcH3e/OlXupDRHmrpN70ZaUP/WuYQEhBg8ibEalm6YKZU+Yd0EVf24Kql0XJY7iW5liW5WQQFBalO+jca2H6uDAw5qUfdFevrmp1UqvJSSU5L15fovddvE2xT9XrT6/NpHS/YuoUMdgNdw17mcS+WEyQAAACbGEh2XZbFY9Em7TxSVL0qbjm7SoAWDjB7JcK4kutmX6NK/qfQlDy9RhUIVdPDUQbWb1E7dZ3TXiXMnjB4PXoQkOi5ms9rUOKax3m/9vv7p/48W91isJ+o8oSKhRXT07FF9vPpjNf6iscp8UEb/N+f/tO7wOpZWAAzlWqLLKaVfSDd2GAAAABiGJTqyVCRfEY1rP06S9O6yd7V4z2KDJzKWqxM9xM4S3aVBqQZa9+g6PVP/GVlk0Zfrv1TsJ7Gav3u+0aPBS9CJjqxYLVY1Kt1Io9uN1sFnDmpm15l6qPpDCgsM096kvRq+bLhqjqmpKh9X0VuL39L+5P1GjwzAhFx1LpKUepaTiwIAAJgVS3Rc0R0V71CPGj3klFPdf+yu0xdOGz2SYahzubwQe4jebfVuplR6y69b6t1l75IghTuJHmAJMHgSeLMAa4Ba39haEzpM0JGBR/TDPT+oU+VOCrIFaeuxrXpp/kuKGRmjNhPbaPKmye4/VwCQ26x2q/sVE73oAAAA5sUSHVc18raRKh1RWrtO7NLA2QONHscw7joXkuiX5Uqld6/RXQ6nQ8/OeVb3Tb1PZy6cMXo0GIhOdORUiD1Enap00g+df1DCswn64s4v1CSmiRxOh2bunKkuP3RR8feK66nfntLaQ2v5Zh2AXGWxWGQNzHjJlHqOJDoAAIBZsUTHVYUHhWvCnRMkSWPWjNHvO343diCDuOtcSKJnKcQeos/v+Fyj245WgDVA32/6XvXH19ffiX8bPRoMQic6rkd4ULi61+iuP7r/oR1P7dBLjV9SyfCSOnH+hEatGqXaY2urxpga+uDPD3Ts7DGjxwXgpyyBFkkk0QEAAMyMJTqypVmZZupXr58kqedPPZV4LtHgifKeq84l1B5q8CTezWKx6Im6T2jBQwtULH8xxSfEq864Oqb95ovZ0YkOT7mx4I0acusQ/dPvH83sOlNdqnZRkC1IG45sUP9Z/RX9XrQ6T+mshf8sJJ0OwKNIogMAAIAlOrJtaPOhqlS4kg6dPqQnf3vS6HHynKvOJTgg2OBJfEOj0o205pE1ql+yvk6eP6l2k9rpzUVvyuF0GD0a8pA7iU6dCzzEZrWp9Y2t9d3d3+ngMwc1qs0o1S5eW6mOVE3ZPEXNvmymqh9X1aiVo5R0PsnocQH4AdcSnSQ6AACAebFER7aF2EP0VYevZLPY9O3GbzV502SjR8pTnFg056LDorXgoQV6tPajcsqplxe8rE6TOyk5Jdno0ZBHXEl0TiyK3FAwpKD63NRHqx9ZrXWPrtNjtR9TPns+bTm2RU/9/pRKvF9Cj/3ymNYfXm/0qAB8mKvOhSQ6AACAebFER47ULVFXLzZ+UZL0+K+P69CpQwZPlHfcneicWDRHggKC9Ontn2pc+3EKtAVqxtYZqvdZPW09ttXo0ZAH6ERHXqlerLo+uf0Tdzq9SpEqOpN6RmPWjFGNMTXU6PNGmhQ/yf1nEgCyyxpEEh0AAMDsWKIjx15u8rJqFa+lxHOJ6v1zb9N0z7rqXEID6ES/Fr1q9dKi7otUIqyEth7bqpvG3aSft/1s9FjIZe5OdOpckEfCg8LV56Y+2vj4Ri18aKE6V+2sAGuAlu5bqq7TuqrUiFJ6cd6LOnjqoNGjAvARdKIDAACAJTpyLNAWqK86fKUgW5B+3fGrZv09y+iR8oSrziXYTif6tapXsp7WPLJGjUs31qkLp9Tx+476av1XRo+FXOJ0OkmiwzAWi0VNb2iq7+/+Xnv779Xrt7yuEmEldPTsUQ1dMlQ3jLxBD814SBuObDB6VABejk50AAAAsETHNakaVVV96vaRJL3+x+umSKO761zoRL8uRfMX1bxu89S9RnelO9P10IyH9NGKj4weC7kgzZEmpzL+bWCJDiMVDyuuV5q+on/6/6NpnaepSUwTpTpS9dX6r1T90+pq+XVLzdw50xT/lwHIOTrRAQAAwBId12xgg4EKDgjW8v3LNX/3fKPHyXWuJHqonTqX62W32TX+jvHqX6+/JKnvzL564483WGD5GVeVi0SdC7xDgDVAHSt31B/d/9DKXivVpWoX2Sw2zd01V20mtlHcJ3H6/K/P6U0HkAlJdAAAALBExzUrHlZcj9R6RJL0+qLXDZ4m97k60Umie4bVYtX7rd/X4FsGS5IGLRykgbMHskj3IxcvIgMsAQZOAlyqbom6+u7u7/R337/19M1PK39gfm06ukk9f+qpmJExGrJoiI6fPW70mAC8AJ3oAAAAYImO6/Jcw+cUaAvUoj2L9Mc/fxg9Tq5yJdFZonuOxWLRoKaDNLL1SEnS+3++r94/91a6I93YweARriS6zWKTzWIzeBrg8mIKxOj91u9r/9P79U7Ld1QyvKSOnDmiVxa8olIjSqn/zP46kHzA6DEBGMgSlFHnQhIdAADAvFii47qUCC+hnjV7SvL/NLqrE50Ti3pev5v7acKdE2S1WDX+r/G6d+q91Cn4gfNp5yVJQQFBBk8CXF1EcIQGNhioXX13aeJdE1WzWE2dSzunD1Z8oLIfltUTvz6hPSf3GD0mAAOQRAcAAABLdFy35xs9L7vVrvm752vp3qVGj5NrXHUuoQF0oueGh2o8pCn3TFGgLVA/bP5Bd353p85cOGP0WLgOrm+EBNlYosN32G123R93v9Y8skazH5itxqUb60L6BX2y+hPd+NGN6vljT+1M3Gn0mADyEJ3oAAAAYImehdGjR6tKlSqqW7eu0aN4vdIRpdW9RndJ0huL3jB2mFzkrnOxU+eSW+6qfJd+ue8XhdpDNevvWWr9TWudPH/S6LFwjVx1LizR4YssFotalmupRT0WaeFDC9W8THOlOdL0+brPVXFURT04/UFtObrF6DEB5AFLIHUuAAAAZscSPQt9+vTR5s2btWrVKqNH8QkvNHpBNotNs/6epRX7Vxg9Tq5w1bnQiZ67WpZrqbkPzlWB4AJaum+pmn3ZTAlnEoweC9fAnUSnzgU+rukNTTW321wte3iZ2pZvK4fToW82fKOqH1dV5ymdteHIBqNHBAwzbNgwWSwW9e/fP8vrTJgwQRaLJdNbcLDv1ONR5wIAAACW6PCIMpFl9GD1ByX5bxrdXedip84lt9UvVV8LH1qoqHxRWnd4nZp80YRFug9yJdEDbYEGTwJ4Rv1S9fXr/b9qde/V6lCpg5xyasrmKar+aXV1mtyJZDpMZ9WqVRozZoyqVat21euGh4fr0KFD7rc9e3znHAPWIOpcAAAAzI4lOjzmxUYvymqx6tcdv2rNwTVGj+NxrjqX4ADfSU75surFqmtJjyUqHVFa245vU9uJbXUq5ZTRYyEH6ESHv6odXVvTu0zX+sfWq3PVzrLIomlbpin2k1j1+LEHJyCFKZw+fVpdu3bVuHHjFBkZedXrWywWFStWzP1WtGjRPJjSM1x1LiTRAQAAzCvA6AHgP8oXKq/74+7XNxu+0RuL3tCMe2cYPZJHuZLo1LnknfKFymvOg3PU8POGWnNojTp+31G/3v8r9SA+wt2JzvGCn6pWtJq+v/t7DWoySC8veFkzts7QhHUTNCl+kh6r/ZheavKSovJFGT0mkCv69Omjdu3aqUWLFhoyZMhVr3/69GnFxMTI4XCoVq1aeuutt1S1atUsr5+SkqKUlBT3+8nJyZKk1NRUpabm3TI7NTX13zqXs3n72Lgy17HgmHgXjov34th4L46Nd+K4eC9PH5vs3g9LdHjUS41f0sQNE/Xjth+1/vB6VS9W3eiRPMLpdP7bic6JRfNUhUIV9HvX39Xsy2aat3ueus3opkl3TZLNajN6NFwFSXSYRdWoqpreZbpW7F+hF+a9oAX/LNCHKz/U+L/G6+mbn9bABgMVERxh9JiAx3z33Xdau3Ztts8dVLFiRX3++eeqVq2akpKS9O6776pBgwbatGmTSpYsednbDB06VIMHD77k8tmzZys0NG+r9VxL9ONHjuu3337L08fG1c2ZM8foEXAZHBfvxbHxXhwb78Rx8V6eOjZnz57N1vVYosOjKhWupM5VO+v7Td9ryOIhmnLPFKNH8ogL6RfklFOSFBpAJ3peqxNdR9O7TFfbiW01edNkFQktoo/afCSLxWL0aLgCdxKdJTpMol7JeprXbZ7m7Z6nF+a9oNUHV2vI4iH6ePXHer7h83rypif5Rix83r59+9SvXz/NmTMn2ycHrV+/vurXr+9+v0GDBqpcubLGjBmjN964/Ll0XnjhBQ0YMMD9fnJyskqVKqVWrVopPDz8+j6JHEhNTdW0+GmSMs6L07Zt2zx7bFxZamqq5syZo5YtW8putxs9Dv6H4+K9ODbei2PjnTgu3svTx8b1E49XwxIdHvdyk5f1/abv9cPmH7QxYaNio2KNHum6ufrQJZLoRmlRtoW+uesb3fvDvRq9arSK5iuqV5q+YvRYuAJ3Ep06F5iIxWJRi7It1LxMc03fOl0vz39ZW45t0XNzn9PIFSP1WtPX9HDNh/lpGvisNWvWKCEhQbVq1XJflp6erkWLFmnUqFFKSUmRzXblP992u101a9bUzp07s7xOUFCQgoIu/f/Dbrfn+QtZ94lFz6fxItoLGfFnAlfHcfFeHBvvxbHxThwX7+WpY5Pd++DEovC42KhYdarcSZL05uI3DZ7GM1xVLlaLVXYr/3gapXPVzvqozUeSpEELB2nM6jEGT4QrcSXRA22BBk8C5D2LxaK7Kt+lDY9v0Od3fK7SEaV18NRBPfLLI6o1tpbm755v9IjANWnevLni4+O1bt0691udOnXUtWtXrVu37qoLdClj6R4fH6/ixYvnwcTXz1XnknYuzeBJAAAAYBSW6MgVLzd5WZL0/cbvtfXYVoOnuX6uk4qG2kOpEDFYn5v66JUmGQn0J357QtO2TDN4ImSFTnRACrAGqEfNHtr+5HaNaD1CBYILaMORDWr+VXN1/L6jdiZmncQFvFFYWJhiY2MzveXLl0+FChVSbGzGTx9269ZNL7zwgvs2r7/+umbPnq1du3Zp7dq1euCBB7Rnzx716tXLqE8jR9wnFj3HicUAAADMiiU6ckWNYjV0R8U75JRTby1+y+hxrpurziUkgCoXbzD4lsF6pNYjcjgdum/qfVr4z0KjR8JluDvRqXMBFBQQpP4399fOp3bqybpPymaxacbWGaoyuoqenf2sks4nGT0i4DF79+7VoUOH3O+fOHFCvXv3VuXKldW2bVslJydr2bJlqlKlioFTZp8lMCNAQRIdAADAvFiiI9e40sIT4yf6fNLOVedCH7p3sFgs+rjdx7qr8l26kH5Bd353p9YdWWf0WPgPkujApQqFFtJHbT/Shsc3qHW51kp1pOrd5e+q/EflNWb1GKU5WNLB9yxcuFAjR47M9P6ECRPc748YMUJ79uxRSkqKDh8+rF9//VU1a9bM+0GvkSuJ7khzyJHmMHgaAAAAGIElOnJNneg6alu+rRxOh8+n0V11LiTRvYfNatPEuybqlhtuUXJKstp/116HUg5d/YbIM+4kOkt04BJVilTRzAdm6rf7f1OlwpV09OxRPfbrY6o1hr50wNu4TiwqUekCAABgVizRkatcafSv1n+l3Sd2GzzNtXPVuYTaQw2eBBcLDgjWjC4zVL1odR05c0SD/x6shDMJRo+F/3En0alzAbLUpnwbbXhsgz647QNFBkcqPiFet317m97a9ZZ2n/Td/zcBf2Kx/3s+HCpdAAAAzIklOnLVzSVvVouyLZTuTNfYNWONHueauZPo1Ll4nYjgCM18YKbKFiirwxcO64EZD1CH4CVcSfRAW6DBkwDezW6zq2+9vtrx1A49ddNTsllsWpm8UjXG1tCwJcN0If2C0SMCpmaxWmQLskkiiQ4AAGBWLNGR6x6p9YgkadLGSXI4fbNH0t2JTp2LVyqWv5imd56uYGuwFu5ZqJfnv2z0SBCd6EBOFQotpA/bfKg1vdYoNn+szqWd0wvzXlDNMTW1eM9io8cDTM0eYpdEEh0AAMCsWKIj191e4XaFB4Vrb9JeLdm7xOhxrgl1Lt6vcuHKeqr0U5Kkt5e+rRlbZxg7EP7tRKfOBciRKkWq6I1yb+jz9p+rSGgRbT66WU0mNNHDPz6sY2ePGT0eYEoBIQGSSKIDAACYFUt05LoQe4jurny3JGnihokGT3NtqHPxDQ0LNFT/m/pLkh6a8ZC2H99u7EAmx4lFgWtnsVj0QNwD2vrkVvdPdH2x7gtVHFVRn//1uc/+ZBfgq1xLdJLoAAAA5sQSHXnigWoPSJImb57srnjwJdS5+I43m72pxqUbKzklWZ0md9KZC2eMHsm0qHMBrl/BkIIa036Mlj68VHFRcUo8l6ieP/VU0wlNtTFho9HjAaYREEwSHQAAwMxYoiNPNL2hqUqEldDJ8yf1247fjB4nx1x1LizRvZ/dZtf3d3+vYvmLaWPCRj3yyyNyOp1Gj2VK1LkAntOgVAOteWSN3m35rvLZ82nJ3iWqOaam/m/O/7m/0Qsg99CJDgAAYG4s0ZEnrBar7o+7X5L0Tfw3Bk+Tc646FzrRfUPxsOKafPdk2Sw2TYqfpNGrRhs9kim5kuiBtkCDJwH8g91m1zMNntHmPpvVoVIHpTnSNHzZcFX/tLrPnnME8BV0ogMAAJgbS3TkGVelyy/bf9GJcycMniZn3El0OtF9RuOYxnqn5TuSpKdnPa1l+5YZPJH50IkO5I7SEaU1vct0/XTvTyoRVkI7E3eqyRdN9PTMp0mlA7mETnQAAABzY4mOPFOtaDXFRcXpQvoFTd0y1ehxcoROdN/U/+b+6ly1s9Icabpnyj06cvqI0SOZirsTnToXIFe0r9heG5/YqIdrPCynnBq5YqRqfFpDS/cuNXo0wO/YgzPqXEiiAwAAmBNLdOQpVxr9mw2+VeniSqJT5+JbLBaLxt8xXpULV9bBUwd179R7leYgQZZXSKIDua9AcAGNv3O8frv/N5UIK6EdiTvU+IvGGjBrAKl0wINIogMAAJgbS3Tkqfti75NFFv2x5w/tTdpr9DjZ5upEp87F9+QPzK9pXaYpf2B+LfxnoV6c96LRI5mGO4nOEh3IdW3Kt9HGJzaqR40ecsqpEX+OIJUOeBCd6AAAAObGEh15qlREKTW9oakkaVL8JIOnyT7qXHxbpcKV9MWdX0iS3ln2jqZtmWbwRObgTqJT5wLkiQLBBfT5nZ/r1/t/VXRYtDuV/sysZ9zfDAZwbUiiAwAAmBtLdOS5B+L+rXRxOp0GT5M9nFjU991d5W49U/8ZSVL3Gd217dg2gyfyf64keqAt0OBJAHNpW76tNj2xSd1rdJdTTr3/5/uqMaaGlu9bbvRogM+yh9CJDgAAYGYs0ZHnOlXppCBbkDYd3aQNRzYYPU62uBJ8dKL7tmEthqlJTBOdunBKD0x/gH70XEYnOmCcAsEF9MWdX+iX+35RdFi0th/frsZfNNYbf7yhdEe60eMBPicgmCQ6AACAmbFER54rEFxAt1e4XZLvnGDUnUSnzsWnBVgD9G2nb1UguIBWH1ytd5a+Y/RIfs3diU6dC2CYdhXaaePjG3V/3P1Kd6Zr0MJBav5Vc+1L2mf0aIBPoRMdAADA3FiiwxAPVMuodJm0cZJPJOLcnejUufi86LBofXDbB5Kk1/54TZsSNhk8kf8iiQ54h8iQSH3T8Rt92eFL5Q/Mrz/2/KHqn1bX9C3TjR4N8BmuOheS6AAAAObEEh2GaHNjG0UGR+rgqYNa+M9Co8e5Kupc/MuD1R5Uu/LtdCH9gnr82INal1zgcDrcX1eW6IDxLBaLulXvpr8e/Ut1ouvoxPkTumvyXXrsl8fc3ygGkDVOLAoAAGBuLNFhiKCAIHWu2lmSNDF+osHTXB11Lv7FYrFozO1jFBEUoVUHV+m9Ze8ZPZLfcVW5SNS5AN7kxoI3aunDS/Vcg+ckSWPWjFGdsXW0/vB6gycDvJurE506FwAAAHNiiZ6F0aNHq0qVKqpbt67Ro/gtV6XLD5t/cCe9vRV1Lv6nRHgJjbxtpCRp0MJB2nx0s7ED+RlXlYtEEh3wNoG2QL3d8m3NeXCOiucvri3HtqjeZ/X00YqP5HQ6jR4P8Eok0QEAAMyNJXoW+vTpo82bN2vVqlVGj+K3GpRqoJiIGJ26cEo/b//Z6HGylO5I14X0C5JIovubh6o/pLbl21LrkgsuTqIH2gINnARAVlqUbaH1j63X7RVuV0p6ivrO7Kv237bX0TNHjR4N8DquTnSS6AAAAObEEh2GsVqs6hrXVZL0zYZvDJ4ma+fTzrt/Tye6f7FYLBp7+1hFBEVo5YGVGrF8hNEj+Q1XEj3QFiiLxWLwNACyUiRfEf1070/6qM1HCrIF6dcdv6r6p9W1dO9So0cDvEpAKEl0AAAAM2OJDkN1rZaxRP995+86dvaYwdNc3sUnXKPOxf+UCC+hEa0zluevLHhFW49tNXgi/+BKolPlAng/i8WiJ296Uit7r1TlwpV16PQh3fLlLdS7ABchiQ4AAGBuLNFhqCpFqqhW8VpKc6RpyqYpRo9zWa6TigbaAmW18FfGH3Wv0V233XibUtJT1OPHHkp3pBs9ks9zJdE5qSjgO6oVraaVvVeqS9UuSnOkqe/Mvnpw+oM6c+GM0aMBhnOdWJQkOgAAgDmxEYThHojLOMHoN/HeWeniOukpVS7+y1XrEh4Urj/3/6mRf440eiSfRxId8E35A/Pr207fakTrEbJZbJoYP1H1x9fXzsSdRo8GGMp1YlGS6AAAAObEEh2Guzf2XlktVi3bt0y7TuwyepxLuJLonFTUv5WKKKX3W70vSXp5wcvadmybwRP5NpLogO+yWCzqf3N/zX9ovormK6r4hHjVGVtHP2/z3pOAA7nNVedCEh0AAMCcWKLDcMXDiqt5meaSpIkbJho8zaVcnej0ofu/h2s+rFblWul82nk9/NPD1LpcB1cSPTgg2OBJAFyrJjFNtPbRtWpQqoGSUpJ0x3d36JX5r/BvI0zJlURPO5/GuQIAAABMiCU6vMID1TIqXSbGT/S6FybUuZiHxWLRuPbjFBYYpmX7lunDFR8aPZLPcifRqXMBfFp0WLQWPLRAfW/qK0kasniI2k5qq+Nnjxs8GZC3XEt0KWORDgAAAHNhiQ6v0LFSR4UEhGjb8W1ac2iN0eNkQp2LuZSOKK33Wr0nSXpx/ovacXyHwRP5JncnOnUugM8LtAXqgzYf6JuO3ygkIESz/56t2mNra81B7/r/GshNrjoXiUoXAAAAM2KJDq8QFhSmDpU6SPK+ShfqXMynV61ealG2hc6nnVfPn3p63U9H+AKS6ID/6Vqtq/7s9afKRZbTnqQ9avh5Q30b/63RYwF5whpglTUg46UTJxcFAAAwH5bo8Br3VLlHkjTz75kGT5KZq86FJLp5WCwWfdb+M4XaQ7V472JN3TLV6JF8Dkl0wD9VK1pNqx9ZrfYV2islPUX3T7tfgxcO5puNMAV3LzpJdAAAANNhiQ6vccsNt8gii7Ye26pDpw4ZPY6bq86FTnRziSkQo2cbPCtJem7Oczqfdt7giXwLSXTAfxUILqAZ985w/xv52h+v6cHpD/LvJPyeq9KFJDoAAID5sESH14gMiVSt4rUkSQv+WWDwNP9yJ9GpczGdZxs8q+iwaO0+uVsfrfjI6HF8Ckl0wL9ZLVYNbzlcY28fqwBrgCbGT1SLr1ro6JmjRo8G5BqS6AAAAObFEh1epdkNzSRJ83fPN3iSf7k70alzMZ18gfn01q1vSZKGLB7CcigHSKID5tC7dm/N7DpTEUERWrpvqW4ef7O2HN1i9FhAriCJDgAAYF4s0eFVbi1zqyTvWqJT52JuD1Z/ULWK11JySrJeW/ia0eP4DHcSnSU64Peal22u5T2Xq2xkWe06sUv1x9fX3F1zjR4L8DiS6AAAAObFEh1epVHpRgqwBmj3yd3afWK30eNI4sSiZme1WPV+q/clSWPWjNHmo5sNnsg3uJPo1LkAplC5SGWt6LVCDUs1VFJKkm775jaNWzPO6LEAjyKJDgAAYF4s0eFVwoLCdFOJmyR5Ty+6u86FTnTTanpDU3Ws1FHpznQNnD3Q6HF8Akl0wHwKhxbWvG7z1DWuq9Kd6Xrkl0f07Oxnle5IN3o0wCNIogMAAJgXS3R4nVtvyKh08ZYluqvOhSS6ub3d4m3ZrXb9vvN3zdo5y+hxvB5JdMCcggKC9HXHrzX4lsGSpHeXv6tOkzvpzIUzBk8GXD+S6AAAAObFEh1e5+JedKfTafA0dKIjQ/lC5fXkTU9Kkp6Z/YzSHKTQroQkOmBeFotFg5oO0qS7JinIFqQft/2o5l811/Gzx40eDbguJNEBAADMiyU6vE79UvUVZAvSwVMHtf34dqPH+bcTnToX03ulySsqGFJQm45u0vi1440ex6uRRAdwX9x9mv/QfBUMKagVB1aoyYQmOpB8wOixgGtGEh0AAMC8WKLD6wQHBKtBqQaSMtLoRnN3olPnYnqRIZF6relrkqRXFryi5JRkYwfyYufTzksiiQ6YXYNSDbSo+yJFh0Vr89HNavh5Q+04vsPosYBrQhIdAADAvFiiwyu5K13+MX6JTp0LLvZYncdUoVAFHT17VEMXDzV6HK9FEh2AS9Woqlr68FKVL1hee5L2qNEXjbTu8DqjxwJyzLVEJ4kOAABgPizR4ZVcS/QFuxfI4XQYOgt1LriY3WbXuy3flSSN+HOE/jn5j7EDeSk60QFc7IYCN2hxj8WqUayGEs4kqOmEplq8Z7HRYwE54qpzIYkOAABgPizR4ZXqRtdVPns+HT93XBsTNho6C3Uu+K/bK9yu5mWaKyU9Rc/Pfd7ocbwSSXQA/1U0f1EtfGihmsQ0UXJKslp900q/bP/F6LGAbCOJDgAAYF4s0eGV7Da7msQ0kWR8L7qrzoUkOlwsFovea/WeLLLo+03fa/m+5UaP5HVIogO4nIjgCM3sOlPtK7TX+bTz6vBdB32z4RujxwKyhSQ6AACAebFEh9dqdkMzSV6wRE+lEx2Xql6suh6u+bAk6elZTxteO+RtSKIDyEqIPURTO0/Vg9UeVLozXQ9Of1AfrvjQ6LGAq+LEogAAAObFEh1ey9WL/seeP5TmMO7FCnUuyMobzd5QPns+rTiwQt9v/N7ocbwKSXQAV2K32TWhwwT1r9dfktRvZj+9tvA1OZ1OYwcDrsCVRKfOBQAAwHxYosNr1ShWQwWCCyg5JVlrD601ZAan00mdC7JUPKy4Xmj0giTp+XnP63zaeYMn8h4k0QFcjdVi1fut39cbzd6QJA3+Y7D6z+zPIh1eiyQ6AACAebFEh9eyWW265YZbJBlX6ZLqSHXXdFDngssZUH+ASoaX1N6kvZqwboLR43gNkugAssNisejlJi/r47YfyyKLPlz5IYt0eC2S6AAAAObFEh1e7dYbMipdFvyzwJDHd/WhS9S54PJC7CF6tsGzkqThS4cbWj3kTUiiA8iJx+s+rvF3jHcv0p+e9TSLdHgdkugAAADmxRIdXq1ZmYyTiy7es1gX0i/k+eO7+tAtsijQFpjnjw/f0KtWLxUOLazdJ3dr8qbJRo/jFUiiA8ipHjV7aFz7cZKkD1Z8oGdmP8MiHV6FJDoAAIB5sUSHV6tapKqKhBbRubRzWrF/RZ4//sV96BaLJc8fH74h1B6qfvX6SZKGLRnG0kck0QFcm561emrs7WMlSSP+HKHn5jzHv6nwGiTRAQAAzIslOryaxWLRrWUyKl2M6EV31bnQh46r6VO3j/IH5ld8Qrx+3fGr0eMYjiQ6gGvVu3ZvfdruU0nSu8vf1fNzn2eRDq9AEh0AAMC8WKLD67mX6P/k/RLdVedCHzquJjIkUo/XeVySNHTJUFMvfJxOJ0l0ANfl0TqP6uO2H0uShi8brhfnvWjqf1fhHUiiAwAAmBdLdHg91xJ9+b7l7qV2Xrm4zgW4mqdvflpBtiAt27dMi/cuNnocw6Q6/k3okUQHcK0er/u4RrUZJUkatnSYXp7/Mot0GIokOgAAgHmxRIfXKxdZTqXCSynVkaqle5fm6WNT54KcKB5WXD1q9JCUkUY3K1eVi0QSHcD16XNTH31w2weSpLeWvKVBCwaxSIdhXEl0Z7pT6anpBk8DAACAvMQSHV7PYrGoWZlmkqQF/yzI08d2J9Gpc0E2PdvwWVktVs3cOVNrD601ehxDuKpcJJLoAK5f33p9NaL1CEnSkMVDNPiPwQZPBLNyJdElKfUsaXQAAAAzYYkOn3DrDcacXNTdiU6dC7KpbGRZ3Rt7ryRp2JJhBk9jDFcS3WaxyWa1GTwNAH/Q/+b+eq/Ve5KkwX8M1ut/vG7wRDAjW5BNsmT8nl50AAAAc2GJDp/gSqKvOrhKSeeT8uxxXXUuJNGRE883fF6S9MPmH7T9+HaDp8l7nFQUQG4YUH+A3mn5jiTp1YWv6qMVHxk8EczGYrEoIDij0oVedAAAAHNhiQ6fUDqitG4seKMcTkeenrDRVedCJzpyIq5onG6vcLuccmr40uFGj5PnXEl0qlwAeNrABgP1RrM3JEn9ZvbT9xu/N3gimI2r0oUkOgAAgLmwRIfPMKLShToXXKsXGr0gSfpq/Vfan7zf4GnyFkl0ALnppcYvqU/dPnLKqQenP6i5u+YaPRJMxHVyUZLoAAAA5sISHT7DVemSl0t06lxwrRqUaqCmMU2V6kjV+8vfN3qcPEUSHUBuslgs+uC2D3RPlXuU6khVx+87mvZEzsh7JNEBAADMiSU6fEazGzKW6OuPrNfxs8fz5DGpc8H1cKXRx6wZk2d/Zr0BSXQAuc1mtenrjl/r1jK36vSF02ozsY3+Tvzb6LFgAiTRAQAAzIklOnxG0fxFVbVIVUnSwn8W5sljkkTH9WhVrpVqFqups6ln9eGKD40eJ8+QRAeQF4ICgjS9y3TVKFZDCWcS1OqbVjpy+ojRY8HPkUQHAAAwJ5bo8Cm3lsnbXnQ60XE9LBaLO43+0cqPdCrllMET5Q2S6ADySnhQuH7v+rvKFCijXSd2qc3ENkpOSTZ6LPgxkugAAADmxBIdPsW9RP8nb5borjoXkui4VndVvksVClXQifMnNHbNWKPHyRMk0QHkpWL5i2n2g7NVJLSI/jr8lzp+39H97xDgaSTRAQAAzIklOnxK05imssiirce26uCpg7n+eHSi43rZrDY91+A5SdL7f75visUOSXQAee3Ggjfq966/K39gfs3fPV/dZnSTw+kweiz4IZLoAAAA5mSaJfrZs2cVExOjgQMHGj0KrkNkSKRqFq8pSVqwe0GuPx51LvCEB6s/qBJhJXTw1EF9tf4ro8fJdSTRARihdnRtTes8TXarXZM3TVa/3/vJ6XQaPRb8DEl0AAAAczLNEv3NN9/UzTffbPQY8IBbb8iodFnwT+4v0TmxKDwh0BaoZ+o/I0kavmy40h3pBk+Uu0iiAzBKy3It9VXHjG9Wjlo1SkOXDDV4IvgbkugAAADmZIol+o4dO7R161a1adPG6FHgAXl5clHqXOApvWv3VqGQQtqZuFPTtkwzepxcRRIdgJHujb1XI1uPlCS9NP8lfb3+a2MHgl9xLdFJogMAAJiL4Uv0RYsWqX379oqOjpbFYtGMGTMuuc7o0aN1ww03KDg4WPXq1dPKlStz9BgDBw7U0KEkkfxF/VL1JUm7T+7WyfMnc/WxqHOBp+QPzK/H6zwuSRq3dpzB0+QukugAjNbv5n7u81H0/rm3VuxfYfBE8BeuOheS6AAAAOZi+BL9zJkzql69ukaPHn3Zj3///fcaMGCAXn31Va1du1bVq1dX69atlZCQ4L5OjRo1FBsbe8nbwYMH9eOPP6pChQqqUKFCXn1KyGUFgguoZHhJSdKmhE25+ljUucCTetbqKYssmrNrjnaf2G30OLmGJDoAbzC0xVDdUfEOpaSnqOP3HXUg+YDRI8EPkEQHAAAwpwCjB2jTps0Va1bef/999e7dWz169JAkffrpp/r111/1+eef6/nnn5ckrVu3Lsvb//nnn/ruu+80ZcoUnT59WqmpqQoPD9egQYMue/2UlBSlpKS4309OTpYkpaamKjU17xInrsfKy8f0JVULV9X+5P1ad2idbip+U649jmuJbrfYLzkmHBvv4gvHpUS+Empeprnm7p6rz9Z8pteavmb0SLni7IWMn+Bw/b3xhWNjVhwb78Rx8Zwvbv9CjY831uZjm3Xnd3dq/gPzr+unyzx9bDjGvocTiwIAAJiT4Uv0K7lw4YLWrFmjF154wX2Z1WpVixYttHz58mzdx9ChQ91VLhMmTNDGjRuzXKC7rj948OBLLp89e7ZCQ/O+F3vOnDl5/pi+IOR0xgvg31b/ppKHS+ba4ySfy/gmyqplq3Qo+FCmj3FsvJO3H5cajhqaq7kas3KMap+uLZvFZvRIHrf1wFZJ0oG9B/Tbb7+5L/f2Y2NmHBvvxHHxjL5F+urZE89qzaE1un3c7RoQM0AWi+W67tNTx+bs2bMeuR/kHU4sCgAAYE5evUQ/duyY0tPTVbRo0UyXFy1aVFu3bs2Vx3zhhRc0YMAA9/vJyckqVaqUWrVqpfDw8Fx5zMtJTU3VnDlz1LJlS9nt9jx7XF+RGJ+oGT/P0KmQU2rbtm2uPU5qfMYLpNbNWysmIibjMo6NV/KV49I8rbm++OgLHT93XAEVA9TmRv874fGc2XOko1Kl8pXU9pa2PnNszIhj4504Lp5Xbk85tfm2jRafXKzWNVq7+9JzytPHxvUTj/AdJNEBAADMyauX6J7WvXv3q14nKChIQUGX9vja7XZDXsga9bjerkbxGpKkTcc2KSAg4LoTZZfjcDrcJ0gMDwm/5DhwbLyTtx8Xu92ubtW7acSfIzRhwwTdUfkOo0fyuFRHxjefQgNDMx0Lbz82Zsax8U4cF89pcWMLfXjbh3rityf0ysJXVK1YNbWv2P6a789Tx4bj63tIogMAAJiT4ScWvZLChQvLZrPpyJEjmS4/cuSIihUrZtBU8AaVi1SW1WJV4rlEHTp96Oo3uAbn0867fx9qz/sqH/ivnjV7SpJ+3v6zDp8+bPA0nuf65hMnFgXgTR6v+7ger/O4nHLq/mn35/rJyeGfSKIDAACYk1cv0QMDA1W7dm3NmzfPfZnD4dC8efNUv359AyeD0YIDglW+YHlJ0saEjbnyGGdT/+0pDQm49pOQAf9VNaqqbi55s9Icafpq/VdGj+Nx7iV6AEt0AN7lg9s+0C033KLTF07rju/u0PGzx40eCT6GJDoAAIA5Gb5EP336tNatW6d169ZJknbv3q1169Zp7969kqQBAwZo3Lhx+vLLL7VlyxY9/vjjOnPmjHr06GHg1PAGcUXjJEnxR+Jz5f7PpZ6TJNmtdtms/nfyRxirV81ekqTP1n4mp9Np8DSelZJGEh2Ad7Lb7JpyzxSVKVBGu07s0j1T7lFqOstQZB9JdAAAAHMyfIm+evVq1axZUzVr1pSUsTSvWbOmBg0aJEnq0qWL3n33XQ0aNEg1atTQunXrNHPmzEtONgrziS0SK0naeDR3kujn0jKW6CF2UujwvC6xXZQ/ML92JO7Q4r2LjR7Ho0iiA/BmhUML66f7flL+wPxa8M8C9Z/Z3+iRfNqwYcNksVjUv3//K15vypQpqlSpkoKDgxUXF6fffvstbwb0MJLoAAAA5mT4Ev2WW26R0+m85G3ChAnu6zz55JPas2ePUlJStGLFCtWrV8+4geE18iqJTh86ckP+wPy6t+q9kjLS6P6EJDoAbxcbFauJd02URRZ9vPpjfbr6U6NH8kmrVq3SmDFjVK1atSteb9myZbrvvvvUs2dP/fXXX+rQoYM6dOigjRtzJwiRm0iiAwAAmJPhS3RvNXr0aFWpUkV169Y1ehRkITYqI4m++ehmpTvSPX7/rk50+tCRW3rVyqh0+WHzDzp5/qSxw3gQSXQAvuCOinfozVvflCQ99ftTWvjPQmMH8jGnT59W165dNW7cOEVGRl7xuh988IFuu+02Pfvss6pcubLeeOMN1apVS6NGjcqjaT2HJDoAAIA5BRg9gLfq06eP+vTpo+TkZEVERBg9Di6jXGQ5BQcE61zaOe06sUvlC5X36P1T54LcdlOJmxQbFauNCRv1bfy3erzu40aP5BEk0QH4iucbPa/4hHh9u/FbPT3raa15ZI2sFjIm2dGnTx+1a9dOLVq00JAhQ6543eXLl2vAgAGZLmvdurVmzJiR5W1SUlKUkpLifj85OVmSlJqaqtTUvFtgux7L/Zj/e/WUdi4tT+fApS45NvAKHBfvxbHxXhwb78Rx8V6ePjbZvR+W6PBZNqtNVYpU0dpDa7UxYaPnl+jUuSCXWSwW9arZS/1n9ddnf33mP0t0kugAfITFYtH4O8YrPChcr93yGgv0bPruu++0du1arVq1KlvXP3z48CXnMypatKgOHz6c5W2GDh2qwYMHX3L57NmzFRqa98/N5syZI0lKS8qocUm/kK5ff/5VFpslz2dBZq5jA+/CcfFeHBvvxbHxThwX7+WpY3P27NlsXY8lOnxaXFSc1h5aq/iEeHWs3NGj902dC/LCA9Ue0HNzn9PaQ2u19tBa1Spey+iRrhtJdAC+JMQeok9v9/9O9N27d2vx4sXas2ePzp49qyJFiqhmzZqqX7++goODs30/+/btU79+/TRnzpwc3S6nXnjhhUzp9eTkZJUqVUqtWrVSeHh4rj3uf6WmpmrOnDlq2bKl7Ha7Lpy+oI3K6HJveWtLBeYLzLNZkNl/jw28A8fFe3FsvBfHxjtxXLyXp4+N6ycer4YlOnyaqxd9Y4LnT0xFnQvyQqHQQrqr8l36buN3Gr92vGq184MlOkl0APAaEydO1AcffKDVq1eraNGiio6OVkhIiBITE/X3338rODhYXbt21f/93/8pJibmqve3Zs0aJSQkqFatf/+/Sk9P16JFizRq1CilpKTIZrNluk2xYsV05MiRTJcdOXJExYoVy/JxgoKCFBR06f8jdrvdkBeyrse1hf/7uVnSLLyo9gJG/ZnAlXFcvBfHxntxbLwTx8V7eerYZPc++JlV+LS4qDhJUnxCvMfv21XnQhIdua1XzYwTjE6Mn+j+CQhfRhIdALxDzZo19eGHH6p79+7as2ePDh06pDVr1mjJkiXavHmzkpOT9eOPP8rhcKhOnTqaMmXKVe+zefPmio+P17p169xvderUUdeuXbVu3bpLFuiSVL9+fc2bNy/TZXPmzFH9+vU99rnmFavNKqs94yUUJxcFAAAwj+tKop8/fz5Xf4wTuBpXEn3H8R06n3ZewQGe+/PoSqLTiY7c1qxMM5UpUEa7T+7W1M1T9WD1B40e6bq4kuie/PsIAMi5YcOGqXXr1ll+PCgoSLfccotuueUWvfnmm/rnn3+uep9hYWGKjY3NdFm+fPlUqFAh9+XdunVTiRIlNHToUElSv3791LRpU7333ntq166dvvvuO61evVpjx4699k/OQPYQu1JSU5R2Ls3oUQAAAJBHcpxEdzgceuONN1SiRAnlz59fu3btkiS98sorGj9+vMcHBK4kOixakcGRSnema+uxrR69bzrRkVesFqt61uwpSfrsr88Mnub6uZPo1LkAgKGutED/r0KFCql27doeedy9e/fq0KFD7vcbNGigSZMmaezYsapevbp++OEHzZgx45JlvK8ICMnIIZFEBwAAMI8cL9GHDBmiCRMmaPjw4QoM/PdEOrGxsfrsM99f/sC3WCyWXOtFd9e50ImOPNC9RndZLVYt2rNI249vN3qc6+LuRKfOBQC8xtq1axUf/2/93Y8//qgOHTroxRdf1IULF67rvhcuXKiRI0dmen/ChAmZrnPPPfdo27ZtSklJ0caNG9W2bdvrekwj2UMyejNJogMAAJhHjpfoX331lcaOHauuXbtm6jysXr26tm71bBLYSKNHj1aVKlVUt25do0fBVbh70Y94thedOhfkpRLhJdTmxjaSpPFrffenehxOh9IcGUsFkugA4D0effRRbd+e8U3aXbt26d5771VoaKimTJmi5557zuDpfAtJdAAAAPPJ8RL9wIEDuvHGGy+53OFwKDXVf55I9unTR5s3b9aqVauMHgVX4U6iH/VsEp06F+S1XrUyTjA6Yf0Epab75r+nrioXiSQ6AHiT7du3q0aNGpKkKVOmqEmTJpo0aZImTJigqVOnGjucjyGJDgAAYD45XqJXqVJFixcvvuTyH374QTVr1vTIUEBOxBXN3SQ6dS7IK+3Kt1PRfEWVcCZBv+741ehxromrykUiiQ4A3sTpdMrhcEiS5s6d665TKVWqlI4dO2bkaD6HJDoAAID5BOT0BoMGDdJDDz2kAwcOyOFwaNq0adq2bZu++uor/fLLL7kxI3BFVYtUlSTtS96nk+dPqkBwAY/cr7sTnSQ68ojdZlf3Gt319tK39dnaz9ShUgejR8qxi5PodqvdwEkAABerU6eOhgwZohYtWuiPP/7QJ598IknavXu3ihYtavB0voUkOgAAgPnkOIl+55136ueff9bcuXOVL18+DRo0SFu2bNHPP/+sli1b5saMwBVFhkSqZHhJSdKmhE0eu19XnQud6MhLPWv2lCT9vvN37U/eb/A0OXc+7bykjCoXi8Vi8DQAAJeRI0dq7dq1evLJJ/XSSy+56xl/+OEHNWjQwODpfAtJdAAAAPPJcRJdkho3bqw5c+Z4ehbgmsVGxWp/8n7FJ8SrYemGHrlP6lxghPKFyqtpTFP9secPffHXF3ql6StGj5QjrjoXqlwAwLtUq1ZN8fGXVt+98847stlsBkzku0iiAwAAmE+Ok+hly5bV8ePHL7n85MmTKlu2rEeGAnIqLiqjF31jgudOLkqdC4zycM2HJUmTN082eJKcc9W5cFJRAPANwcHBstup38oJkugAAADmk+Mk+j///KP09PRLLk9JSdGBAwc8MhSQU7FRsZKk+ATPnVzUlUSnzgV5rX2F9gqwBmhjwkbtTNypGwveaPRI2UYSHQC8R2RkZLartRITE3N5Gv/hWqKTRAcAADCPbC/Rf/rpJ/fvZ82apYiICPf76enpmjdvnm644QaPDgdk18VJdKfT6ZEuZlcnOnUuyGuRIZG65YZbNHfXXM3YOkMDGww0eqRsI4kOAN5j5MiR7t8fP35cQ4YMUevWrVW/fn1J0vLlyzVr1iy98opvVYcZzVXnQhIdAADAPLK9RO/QoYMkyWKx6KGHHsr0MbvdrhtuuEHvvfeeR4cDsqtS4UqyWqxKPJeoQ6cPKTos+rrvkzoXGKlDxQ6+uUQniQ4AXuPi5+ydOnXS66+/rieffNJ9Wd++fTVq1CjNnTtXTz/9tBEj+iSS6AAAAOaT7U50h8Mhh8Oh0qVLKyEhwf2+w+FQSkqKtm3bpttvvz03ZwWyFGIPUfmC5SV5rhedE4vCSHdWulOStGzfMh05fcTgabKPJDoAeKdZs2bptttuu+Ty2267TXPnzjVgIt9lDyWJDgAAYDY5PrHo7t27Vbhw4dyYxauMHj1aVapUUd26dY0eBdnk7kU/4pledFedC53oMELJ8JKqG11XTjn107afrn4DL0ESHQC8U6FChfTjjz9ecvmPP/6oQoUKGTCR73LVuZBEBwAAMI8cn1hUks6cOaM//vhDe/fu1YULFzJ9rG/fvh4ZzGh9+vRRnz59lJycnKn/Hd4rLipOU7dM1cajHkqiU+cCg3Wo1EGrDq7SjG0z1Lt2b6PHyRaS6ADgnQYPHqxevXpp4cKFqlevniRpxYoVmjlzpsaNG2fwdL6FOhcAAADzyfES/a+//lLbtm119uxZnTlzRgULFtSxY8cUGhqqqKgov1miw/d4Momemp6qdGe6JOpcYJyOlTrqpfkvae6uuTqVckphQWFGj3RVJNEBwDt1795dlStX1ocffqhp06ZJkipXrqwlS5a4l+rIHk4sCgAAYD45XqI//fTTat++vT799FNFRETozz//lN1u1wMPPKB+/frlxoxAtsQVjZMkbT66WemOdNmstmu+L1cfukSdC4xTqXAlVShUQduPb9fvO39X56qdjR7pqkiiA4D3qlevniZOnGj0GD6PJDoAAID55LgTfd26dXrmmWdktVpls9mUkpKiUqVKafjw4XrxxRdzY0YgW8pFllNwQLDOpZ3TrhO7ruu+XH3oFllYBsIwFotFHSp2kCTN2DrD0FmyiyQ6AHgvh8Oh7du3a8mSJVq0aFGmN2QfSXQAAADzyXES3W63y2rN2L1HRUVp7969qly5siIiIrRv3z6PDwhkl81qU5UiVbT20FptTNio8oXKX/N9ufrQgwOCZbFYPDUikGMdKnXQ8GXD9euOX3Uh/YICbYFGj3RFJNEBwDv9+eefuv/++7Vnzx45nc5MH7NYLEpPTzdoMt9DEh0AAMB8cpxEr1mzplatWiVJatq0qQYNGqSJEyeqf//+io2N9fiAQE7ERWVUusQnXF8vuqvOhSoXGK1eyXoqlr+YklOStWD3AqPHuSp3Ep0lOgB4lccee0x16tTRxo0blZiYqBMnTrjfEhMTjR7Pp5BEBwAAMJ8cL9HfeustFS9eXJL05ptvKjIyUo8//riOHj2qMWPGeHxAICdcJxfdmLDxuu7HVefCSUVhNKvFqjsr3inJNypd3El06lwAwKvs2LFDb731lipXrqwCBQooIiIi0xuyjyQ6AACA+eR4iV6nTh01a9ZMUkady8yZM5WcnKw1a9aoRo0anp4PyBGPJdH/V+cSEsASHcbrUKmDJOnHbT/K4XQYO8xVkEQHAO9Ur1497dy50+gx/AJJdAAAAPPJcSd6VtauXatBgwbpl19+8dRdAjnmSqLvOL5D59POKzgg+Jrux1XnQhId3qDZDc0UFhimQ6cPadWBVapXsp7RI2WJJDoAeKennnpKzzzzjA4fPqy4uDjZ7fZMH69WrZpBk/kekugAAADmk6Ml+qxZszRnzhwFBgaqV69eKlu2rLZu3arnn39eP//8s1q3bp1bcwLZEh0WrcjgSJ04f0Jbj21VjWI1rul+XEl0OtHhDYICgtSuQjt9t/E7Td863buX6CTRAcArderUSZL08MMPuy+zWCxyOp2cWDSHLk6iu75+AAAA8G/ZrnMZP3682rRpowkTJujtt9/WzTffrG+++Ub169dXsWLFtHHjRv3222+5OStwVRaLxSO96O5OdOpc4CU6VOwgyft70UmiA4B32r179yVvu3btcv+K7HMl0eWU0i/wzQcAAAAzyHYS/YMPPtDbb7+tZ599VlOnTtU999yjjz/+WPHx8SpZsmRuzmiI0aNHa/To0aRyfFBcVJwW712s+CPX3otOnQu8TZvybRRoC9S249u09dhWVSpcyeiRLoskOgB4p5iYGKNH8BuuJLqUUekSEOSxhkwAAAB4qWwn0f/++2/dc889kqS77rpLAQEBeuedd/xygS5Jffr00ebNm7Vq1SqjR0EOuZPoR689iU6dC7xNeFC4mpdpLkmavmW6wdNkzb1EJ4kOAF7n77//1lNPPaUWLVqoRYsW6tu3r/7++2+jx/I5VrtVFmtGhQsnFwUAADCHbC/Rz507p9DQjIWixWJRUFCQihcvnmuDAdcqrmicJF1XEp06F3ijDpU6SJJmbJth6BxX4q5zIYkOAF5l1qxZqlKlilauXKlq1aqpWrVqWrFihapWrao5c+YYPZ5PsVgsnFwUAADAZHL0s4efffaZ8ufPL0lKS0vThAkTVLhw4UzX6du3r+emA65B1SJVJUn7kvcp6XySIoIjcnwf7joXlujwIndUvEOP/fKYVh5YqQPJB1QivITRI12CJDoAeKfnn39eTz/9tIYNG3bJ5f/3f/+nli1bGjSZb7KH2JV6JpUkOgAAgElke4leunRpjRs3zv1+sWLF9PXXX2e6jsViYYkOw0WGRKpkeEntT96vjQkb1bB0wxzfh6vOhU50eJNi+Yvp5pI3a/n+5fpp2096vO7jRo90CZLoAOCdtmzZosmTJ19y+cMPP6yRI0fm/UA+jiQ6AACAuWR7if7PP//k4hiAZ8VGxV7XEt1V50InOrxNx0odtXz/ck3fOt07l+gk0QHAKxUpUkTr1q1T+fLlM12+bt06RUVFGTSV73KdXJQkOgAAgDlwKnn4pbioOM3cOVPxCdfWi06dC7xVh0od9Nzc57TgnwU6ef6kCgQXMHqkTEiiA4B36t27tx555BHt2rVLDRo0kCQtXbpUb7/9tgYMGGDwdL6HJDoAAIC5sESHX4qNipUkbUzYeE23dy/RqXOBlylfqLyqFKmizUc367cdv+n+uPuNHikTkugA4J1eeeUVhYWF6b333tMLL7wgSYqOjtZrr71GHeM1IIkOAABgLlajBwByQ1xUnCQpPiFeTqczx7d3daJT5wJv1LFSR0nS9K3TDZ7kUiTRAcA7WSwWPf3009q/f7+SkpKUlJSk/fv3q1+/frJYLEaP53NIogMAAJgLS3T4pUqFK8lqsSrxXKIOnz6c49u7OtGpc4E36lCpgyTp9x2/63zaeWOH+Q+S6ADgnXbv3q0dO3ZIksLCwhQWFiZJ2rFjB+c+ugYk0QEAAMyFJTr8Uog9ROULZpw461p60alzgTerXby2SoSV0JnUM5q3a57R42RCEh0AvFP37t21bNmySy5fsWKFunfvnvcD+TiS6AAAAOaS4yV6cnLyZd9OnTqlCxcu5MaMwDVx9aLHH7mGJXoqJxaF97JYLO40urdVupBEBwDv9Ndff6lhw4aXXH7zzTdr3bp1eT+QjyOJDgAAYC45XqIXKFBAkZGRl7wVKFBAISEhiomJ0auvviqHw5Eb8wLZ5upF33g05ycXddW50IkOb+XqRf9p209Kd6QbPM2/SKIDgHeyWCw6derUJZcnJSUpPd17/h/xFSTRAQAAzCXHS/QJEyYoOjpaL774ombMmKEZM2boxRdfVIkSJfTJJ5/okUce0Ycffqhhw4blxrxAtl1XEp06F3i5JjFNVCC4gI6eParl+5cbPY4kyel0kkQHAC/VpEkTDR06NNPCPD09XUOHDlWjRo0MnMw3uZboJNEBAADMISCnN/jyyy/13nvvqXPnzu7L2rdvr7i4OI0ZM0bz5s1T6dKl9eabb+rFF1/06LB5afTo0Ro9ejTJHB8WVzQjib756GalO9Jls9qyfVvqXODt7Da7bq9wu77Z8I1mbJ2hRqWNX4CkOv5dJJBEBwDv8vbbb6tJkyaqWLGiGjduLElavHixkpOTNX/+fIOn8z2uOheS6AAAAOaQ4yT6smXLVLNmzUsur1mzppYvz0hDNmrUSHv37r3+6QzUp08fbd68WatWrTJ6FFyjcpHlFBwQrHNp57TrxK4c3daVRKfOBd7MVekyY+sMYwf5H1eVi0QSHQC8TZUqVbRhwwZ17txZCQkJOnXqlLp166atW7cqNjbW6PF8Dkl0AAAAc8lxEr1UqVIaP378JXUt48ePV6lSpSRJx48fV2RkpGcmBK6RzWpT2ciy2nx0s/Ym7VX5QuWzfVtXJzp1LvBmLcu2lM1i098n/tbepL0qHVHa0HlcVS4SSXQA8EbR0dF66623jB7DL5BEBwAAMJccJ9HfffddjRgxQtWrV1evXr3Uq1cv1ahRQyNHjtR7770nSVq1apW6dOni8WGBnIoOi5YkHTx1MNu3cTqdOp92XhJ1LvBuYUFhqlW8liRp8Z7FBk/zbxLdZrHlqD4JAJA3Fi9erAceeEANGjTQgQMHJElff/21lixZYvBkvocTiwIAAJhLjpfod9xxh7Zu3ao2bdooMTFRiYmJatOmjbZu3arbb79dkvT444/r/fff9/iwQE5dyxLdtUCXSKLD+zWJaSJJWrRnkcGTiJOKAoAXmzp1qlq3bq2QkBCtXbtWKSkZ/2YnJSWRTr8GriQ6dS4AAADmkOM6F0kqU6bMJXUugDeKzp/zJbqrykUiiQ7v1ySmid5b/p4W7fWCJfr/kuhUuQCA9xkyZIg+/fRTdevWTd9995378oYNG2rIkCEGTuabSKIDAACYyzUt0U+ePKmVK1cqISFBDocj08e6devmkcEATygeVlySdPB09pforpOKBlgDZLfZc2UuwFMalW4kSdp6bKsSziQoKl+UYbOQRAcA77Vt2zY1adLkkssjIiJ08uTJvB/Ix5FEBwAAMJccL9F//vlnde3aVadPn1Z4eLgsFov7YxaLhSU6vMq11LmcS81YopNChy8oGFJQcVFxik+I15K9S3RX5bsMm4UkOgB4r2LFimnnzp264YYbMl2+ZMkSlS1b1pihfBhJdAAAAHPJcSf6M888o4cfflinT5/WyZMndeLECfdbYmJibswIXLNrWqL/L4keag/NlZkAT2tcurEk43vRSaIDgPfq3bu3+vXrpxUrVshisejgwYOaOHGiBg4cqMcff9zo8XwOSXQAAABzyXES/cCBA+rbt69CQ1kwwvtdvER3Op2ZfnIiK65OdE4qCl/RJKaJPl79sfFLdJLoAOC1nn/+eTkcDjVv3lxnz55VkyZNFBQUpIEDB+qpp54yejyfQxIdAADAXHKcRG/durVWr16dG7MAHlc8f0Yn+oX0Czpx/kS2bkOdC3xN45iMJPq6w+uUdD7JsDlIogOA97JYLHrppZeUmJiojRs36s8//9TRo0f1xhtvGD2aTyKJDgAAYC45TqK3a9dOzz77rDZv3qy4uDjZ7ZlPvHjHHXd4bDjgegUFBKlQSCEdP3dcB08dVMGQgle9javOhSQ6fEV0WLRuLHijdibu1NJ9S9W2fFtD5iCJDgDeLzAwUFWqVFFycrLmzp2rihUrqnLlykaP5XNIogMAAJhLjpfovXv3liS9/vrrl3zMYrEoPT39+qcCPCg6LNq9RI+Nir3q9V11LnSiw5c0Kd1EOxN3atGeRcYt0UmiA4DX6ty5s5o0aaInn3xS586dU926dbV79245nU5999136tSpk9Ej+hSS6AAAAOaS4zoXh8OR5RsLdHijnJ5clDoX+KImMU0kSYv3LjZsBpLoAOC9Fi1apMaNM+q/pk+fLofDoZMnT+rDDz/UkCFDDJ7O97iS6I5UhxxpDoOnAQAAQG7L8RId8DU5XqJT5wIf5Fqirzqwyv3TFHmNJDoAeK+kpCQVLJhRazdz5kx16tRJoaGhateunXbs2GHwdL7HlUSXSKMDAACYQbbqXD788EM98sgjCg4O1ocffnjF6/bt29cjgwGektMlOnUu8EU3FLhBJcNLan/yfq3Yv0LNyjTL8xlIogOA9ypVqpSWL1+uggULaubMmfruu+8kSSdOnFBwcLDB0/megOB/X0alnUtTUBj/9wEAAPizbC3RR4wYoa5duyo4OFgjRozI8noWi4UlOrxO8fzFJVHnAv9msVjUuHRjfbvxWy3as8iYJTpJdADwWv3791fXrl2VP39+xcTE6JZbbpGUUfMSFxdn7HA+yGK1yBZkU3pKOkl0AAAAE8jWEn337t2X/b0/Gz16tEaPHk3Pux+45joXlujwMU1immQs0fcuMuTxSaIDgPd64oknVK9ePe3du1ctW7aU1ZrR6li2bFk60a+RPcSu9JR0pZ1LM3oUAAAA5LJsLdHNqE+fPurTp4+Sk5MVERFh9Di4Dtd8YlE60eFjXL3oy/ct14X0Cwq0Bebp47uT6CzRAcAr1a5dW7Vr1850Wbt27QyaxvcFhARIJ+lEBwAAMIMcL9HT09M1YcIEzZs3TwkJCXI4Mp+Nfv78+R4bDvAE1xL98OnDcjgdslqufD5dOtHhqyoXrqzCoYV17OwxrTm4RvVL1c/Tx3cn0alzAQCvMGzYMPXr108hIVcPBqxYsULHjh1jqZ4DrpOLkkQHAADwf1feJl5Gv3791K9fP6Wnpys2NlbVq1fP9AZ4m2L5i0mSUh2pOn72+FWvT50LfJWrF12SFu9dnOePTxIdALzL5s2bVbp0aT3xxBP6/fffdfToUffH0tLStGHDBn388cdq0KCBunTporCwMAOn9T0BIRl5JJLoAAAA/i/HSfTvvvtOkydPVtu2bXNjHsDj7Da7ovJFKeFMgg6eOqgi+Ypc8fruJTp1LvBBTWKaaPrW6Vq0Z5Gea/hcnj72+bTzkkiiA4C3+Oqrr7R+/XqNGjVK999/v5KTk2Wz2RQUFKSzZzN+8q5mzZrq1auXunfvruDgYIMn9i0k0QEAAMwjx0v0wMBA3XjjjbkxC5BrosOi3Uv06sWu/BMT1LnAl7l60ZfsXaJ0R7psVluePbYriR4cwBIGALxF9erVNW7cOI0ZM0YbNmzQnj17dO7cORUuXFg1atRQ4cKFjR7RZ5FEBwAAMI8cL9GfeeYZffDBBxo1apQsFktuzAR4XHRYtNYdXpetk4u6TyxKnQt8UPWi1RUWGKaklCTFJ8SrRrEaefbY7k506lwAwOtYrVbVqFFDNWrUMHoUv0ESHQAAwDxyvERfsmSJFixYoN9//11Vq1aV3W7P9PFp06Z5bDjAU6LzZ5xcNFtLdOpc4MNsVpsalm6omTtnatGeRXm7RE/nxKIAAPMgiQ4AAGAeOT6xaIECBdSxY0c1bdpUhQsXVkRERKY3wBtFh+VgiU4SHT6uSemMSpdFexbl6eOSRAcAmAlJdAAAAPPIURI9LS1NzZo1U6tWrVSsWLHcmgnwuOJhxSVJB09ffYlOJzp8nasXfdGeRXI6nXlWvUUSHQBgJiTRAQAAzCNHSfSAgAA99thjSklJya15gFyRoyQ6dS7wcXWi6yg4IFhHzx7V9uPb8+xxSaIDAMzEtUQniQ4AAOD/clznctNNN+mvv/7KjVmAXONaoh86deiq16XOBb4uKCBIN5e8WVLeVrqQRAcA77dz507NmjVL585lPN9xOp0GT+S7XHUuJNEBAAD8X45PLPrEE0/omWee0f79+1W7dm3ly5cv08erVavmseEAT3Et0Q+fPqx0R7psVluW16XOBf6gSekmWvjPQi3au0i9a/fOk8ckiQ4A3uv48ePq0qWL5s+fL4vFoh07dqhs2bLq2bOnIiMj9d577xk9os8hiQ4AAGAeOV6i33vvvZKkvn37ui+zWCzu3t309HTPTQd4SFS+KFktVqU703X07FEVy591pz91LvAHF/ei5xWS6ADgvZ5++mkFBARo7969qly5svvyLl26aMCAASzRrwFJdAAAAPPI8RJ99+7duTEHkKsCrAEqmq+oDp0+pIOnDma5RE9zpCnNkZEmos4FvuzmkjcrwBqgvUl7tefkHsUUiMn1xySJDgDea/bs2Zo1a5ZKliyZ6fLy5ctrz549Bk3l20iiAwAAmEeOl+gxMbm/iAFyQ3RYtHuJXqt4rctex9WHLpFEh2/LF5hPtYvX1ooDK7RozyI9WODBXH9MkugA4L3OnDmj0NBLq+oSExMVFMS/29fClURniQ4AAOD/cnxiUZfNmzdr5syZ+umnnzK9Ad7K1Yt+8NTBLK/j6kOXpOCA4FyfCchNeV3pQhIdALxX48aN9dVXX7nft1gscjgcGj58uJo1a2bgZL7LlUSnzgUAAMD/5TiJvmvXLnXs2FHx8fHuLnQp44m4JDrR4bWys0R39aEHBwTLarnm7zEBXqFJTBO9s+wdLdqbR0t0kugA4LWGDx+u5s2ba/Xq1bpw4YKee+45bdq0SYmJiVq6dKnR4/kkkugAAADmkeMtYb9+/VSmTBklJCQoNDRUmzZt0qJFi1SnTh0tXLgwF0YEPCNbS/T/1bnQhw5/0LBUQ1lk0fbj23Xk9JFcfzyS6ADgvWJjY7V9+3Y1atRId955p86cOaO77rpLf/31l8qVK2f0eD6JJDoAAIB55DiJvnz5cs2fP1+FCxeW1WqV1WpVo0aNNHToUPXt21d//fVXbswJXLfi+YtLyl6dS6j90s5QwNdEhkSqWtFqWn9kvRbvXay7q9yda4+V7khXujPjJ5FIogOAd4qIiNBLL71k9Bh+gyQ6AACAeeR4iZ6enq6wsDBJUuHChXXw4EFVrFhRMTEx2rZtm8cHBDzFlUQ/dPpQltdx1blwUlH4iyYxTbT+yHot2rMoV5forioXiSQ6AHir8+fPa8OGDUpISJDD4cj0sTvuuMOgqXwXSXQAAADzyPESPTY2VuvXr1eZMmVUr149DR8+XIGBgRo7dqzKli2bGzMCHkGdC8yocenG+mjlR7l+clFXlYtEEh0AvNHMmTPVrVs3HTt27JKPWSwWzmt0DUiiAwAAmEeOO9Fffvlld3Ll9ddf1+7du9W4cWP99ttv+vDDDz0+IOApriX6kdNHlOa4/IsdV50LSXT4i8YxjSVJG45s0IlzJ3LtcS5Ootut9lx7HADAtXnqqad0zz336NChQ3I4HJneWKBfG5LoAAAA5pHjJHrr1q3dv7/xxhu1detWJSYmKjIyUhaLxaPDGWn06NEaPXo0Lyr8SJF8RWSz2JTuTNeR00dUIrzEJddx1bnQiQ5/USx/MVUoVEHbj2/X0n1LdXuF23PlcS4+qag//V8AAP7iyJEjGjBggIoWLWr0KH6DJDoAAIB55DiJ7rJz507NmjVL586dU8GCBT05k1fo06ePNm/erFWrVhk9CjzEarGqeNiVTy5KnQv8UZPSTSQpVytdXEl0qlwAwDvdfffdWrhwodFj+BVXEj3tfJqcTqfB0wAAACA35TiJfvz4cXXu3FkLFiyQxWLRjh07VLZsWfXs2VORkZF67733cmNOwCOiw6K1P3l/1kt0TiwKP9Qkpok+++szLd67ONce4+IkOgDA+4waNUr33HOPFi9erLi4ONntmau3+vbta9BkvsuVRJcyFukXvw8AAAD/kuMk+tNPPy273a69e/cqNPTfyosuXbpo5syZHh0O8LSrnVzU1YlOnQv8SZOYjCT66oOrdebCmVx5DJLoAODdvv32W82ePVtTp07VRx99pBEjRrjfRo4cme37+eSTT1StWjWFh4crPDxc9evX1++//57l9SdMmCCLxZLpLTg42AOfkfFcSXSJShcAAAB/l+Mk+uzZszVr1iyVLFky0+Xly5fXnj17PDYYkBui8195iU6dC/xRTIEYlQwvqf3J+7Xm0Br3Ut2TSKIDgHd76aWXNHjwYD3//POyWq+50VElS5bUsGHDVL58eTmdTn355Ze688479ddff6lq1aqXvU14eLi2bdvmft9fzp1hs9tksVnkTHcq9VyqQsTzRwAAAH+V4yX6mTNnMiXQXRITExUUxPIE3u1qSXR3nQtLdPiZGsVqaH/yfm1M2Jg7S3SS6ADg1S5cuKAuXbpc1wJdktq3b5/p/TfffFOffPKJ/vzzzyyX6BaLRcWKFbuux/VW9hC7Lpy+QBIdAADAz+X4WXTjxo311Vdfud+3WCxyOBwaPny4mjVr5tHhAE9znVj00OlDl/24q86FTnT4m9gisZKk+CPxuXL/JNEBwLs99NBD+v777z16n+np6fruu+905swZ1a9fP8vrnT59WjExMSpVqpTuvPNObdq0yaNzGMlV6ZJ6LtXgSQAAAJCbcpxEHz58uJo3b67Vq1frwoULeu6557Rp0yYlJiZq6dKluTEj4DFXTaL/r86FTnT4m7iicZKkjUc35sr9k0QHAO+Wnp6u4cOHa9asWapWrdolJxZ9//33s31f8fHxql+/vs6fP6/8+fNr+vTpqlKlymWvW7FiRX3++eeqVq2akpKS9O6776pBgwbatGnTJfWQF0tJSVFKSor7/eTkZElSamqqUlPzbmHteqysHtO1RD9/6nyezoWrHxsYg+PivTg23otj4504Lt7L08cmu/eT4yV6bGystm/frlGjRiksLEynT5/WXXfdpT59+qh48eI5HhTIS9S5wKxio/5NojudTo/30ZJEBwDvFh8fr5o1a0qSNm7M/A3VnP6fULFiRa1bt05JSUn64Ycf9NBDD+mPP/647CK9fv36mVLqDRo0UOXKlTVmzBi98cYbWT7G0KFDNXjw4Esunz179mWrJXPbnDlzLnu565vISxYsUf6j+fNyJPxPVscGxuK4eC+Ojffi2Hgnjov38tSxOXv2bLaul+MluiRFRETopZdeynTZ/v379cgjj2js2LHXcpdAnnAt0Y+ePaoL6RcUaAvM9HH3Ep06F/iZSoUrKcAaoKSUJB04dUAlw7NO/10LkugA4N0WLFjgsfsKDAzUjTfeKEmqXbu2Vq1apQ8++EBjxoy56m3tdrtq1qypnTt3XvF6L7zwggYMGOB+Pzk5WaVKlVKrVq0UHh5+fZ9ADqSmpmrOnDlq2bLlJel9STpU+JCOHDii2tVrq1zrcnk2F65+bGAMjov34th4L46Nd+K4eC9PHxvXTzxezTUt0S/n+PHjGj9+PEt0eLVCIYVkt9qV6kjV4dOHVTqidKaPuzrRqXOBvwm0BapCoQrafHSz4o/Ee36JThIdAEzL4XBkql65kvT0dMXHx6tt27ZXvF5QUJCCgi79P8VutxvyQjarx7WHZlzmTHXyAtsgRv2ZwJVxXLwXx8Z7cWy8E8fFe3nq2GT3Pjy2RAd8gcViUXRYtPYk7dHBUwcvWaK7OtGpc4E/iouK0+ajm7UxYaPalG/j0fsmiQ4A3ueuu+7ShAkTFB4errvuuuuK1502bVq27vOFF15QmzZtVLp0aZ06dUqTJk3SwoULNWvWLElSt27dVKJECQ0dOlSS9Prrr+vmm2/WjTfeqJMnT+qdd97Rnj171KtXr+v75LyEa4medi7N4EkAAACQm1iiw3QuXqL/F3Uu8GexUbH6ftP3ik+I9/h9k0QHAO8TERHh7juPiIjwyH0mJCSoW7duOnTokCIiIlStWjXNmjVLLVu2lCTt3btXVqvVff0TJ06od+/eOnz4sCIjI1W7dm0tW7YsyxOR+hp7SMYSPfUcJx0DAADwZyzRYTpXOrmoq86FJDr8UVxUnCRpY8LGq1wz59xJdJboAOA1vvjiC73++usaOHCgvvjiC4/c5/jx46/48YULF2Z6f8SIERoxYoRHHtsbBYRkvJwiiQ4AAODfsr1Ev9qPgJ48efJ6ZwHyxJWW6K46FzrR4Y9io2IlSZuPblaaI00BVs99H9WdRKfOBQC8yuDBg/XYY48pNJTnNrmBJDoAAIA5ZHuDcrUfAY2IiFC3bt2ueyAgt7mW6IdOH7rkY9S5wJ+ViSyjUHuozqae1c7EnapUuJLH7pskOgB4J6fTafQIfo0kOgAAgDlke4nuqR8BBYxWPH9xSVdOolPnAn9ktVhVtUhVrTq4ShsTNnp2iU4SHQC8lqsXHZ7nWqKTRAcAAPBvdKLDdLLTiU6dC/xVXFScVh1cpfgj8bq7yt0eu1+S6ADgvSpUqHDVRXpiYmIeTeNfXHUuJNEBAAD8G0t0mE5WS3Sn00mdC/yeqxd941HPnlyUJDoAeK/BgwdftZoR14YkOgAAgDmwRIfpuJboiecSdT7tvIIDgiX9m6SVqHOB/4orGidJij8S79H7JYkOAN7r3nvvVVRUlNFj+CWS6AAAAOZgNXoAIK8VCC7gXpwfOvXvyUVdVS4SdS7wX64k+s7Ene5zAHiCe4lOEh0AvAp96LmLE4sCAACYA0t0mI7FYrlspYtroWiz2GS32Q2ZDchtRfMVVeHQwnLKqc1HN3vsft11LiTRAcCrOJ1Oo0fwa64kOnUuAAAA/o0lOkzpskt0+tBhAhaL5d9e9ATP9aKTRAcA7+RwOKhyyUUk0QEAAMyBJTpM6XJLdFedC33o8HdxUf/rRU/wXC86SXQAgBmRRAcAADAHlugwpej8GUv0Q6f/7UR31bnQhw5/51qik0QHAOD6kEQHAAAwB5boMCXqXGBmrjoXkugAAFwfkugAAADmwBIdplQ8rLiky59YlDoX+LuqUVUlZfz5TzyX6JH7JIkOADAjkugAAADmwBIdpnSlTnTqXODvwoPCFRMRI8lzlS4k0QEAZkQSHQAAwBxYosOUqHOB2cUV/d/JRY94ptKFJDoAwIxIogMAAJgDS3SYkmuJnpSSpDMXzkiizgXmElskoxedJDoAANeOJDoAAIA5sESHKYUFhimfPZ8k6dDpQ5L+rXMhiQ4zcCfRPXRyUZLoAAAzciXRnelOpaemGzwNAAAAcgtL9CyMHj1aVapUUd26dY0eBbnAYrFcUuniqnOhEx1mEBv1bxLd6XRe9/2RRAcAmJEriS5R6QIAAODPWKJnoU+fPtq8ebNWrVpl9CjIJZcs0alzgYlUKlxJAdYAJaUkaX/y/uu6L6fTSRIdAGBKtiCbZMn4PZUuAAAA/oslOkzLtUQ/dCqjzsV9YlGW6DCBQFugKhSqIOn6e9FTHf8uDUiiAwDMxGKxKCCYk4sCAAD4O5boMK3/JtFdnejUucAs4qI804vuqnKRSKIDAMyHk4sCAAD4P5boMC33Ev30f+pcOLEoTOLiXvTrcT7tvPv3JNEBAGbjOrkoSXQAAAD/xRIdplU8f3FJl55YlDoXmIXHkuj/60O3WWyyWW3XPRcAAL6EJDoAAID/Y4kO08qqzoUkOszClUTfcnSL0hzXnp5z1blQ5QIAMCOS6AAAAP6PJTpM679LdFcSnU50mEWZyDIKtYcqJT1FOxN3XvP9uJLoVLkAAMyIJDoAAID/Y4kO0yoellHncvrCaZ1KOfVvJzp1LjAJq8WqqkWqSrq+XnSS6AAAMyOJDgAA4P9YosO08gfmV3hQuKSMNLq7E506F5iIuxf9yLX3opNEBwCYGUl0AAAA/8cSHaZ2caWLqxOdOheYiasX/XpOLkoSHQBgZiTRAQAA/B9LdJiaa4l+6PQh6lxgSnFFM5Lo11XnQhIdAGBiJNEBAAD8H0t0mNrFSXTqXGBGriT6zsSd7p/GyClXEj04INhjcwEA4CtIogMAAPg/lugwtej8l9a5kESHmRTNV1SFQwvLKae2HN1yTffhTqJT5wIAMCHXEp0kOgAAgP9iiQ5Ty5RE/1+dC53oMBOLxXLdvejuTnTqXAAAJuSqcyGJDgAA4L9YosPUiocVlyTtTdqrVEdGeog6F5hNXNT19aKTRAcAmBlJdAAAAP/HEh2m5kqi/33ib/dl1LnAbFxLdJLoAADkHEl0AAAA/8cSHabmWqInnElwX0YSHWbjqnMhiQ4AQM5xYlEAAAD/xxIdplY8f/FM7wfZgmS18NcC5lI1qqqkjHMDJJ5LzPHtSaIDAMzMlUSnzgUAAMB/sS2EqYXYQxQZHJnpfcBswoPCFRMRI+na0ujuJDpLdACACZFEBwAA8H8s0WF6rkoXiT50mFdc0f/1oh/JeS+6O4lOnQsAwIRIogMAAPg/lugwvYuX6KH2UAMnAYwTW+Tae9FJogMAzIwkOgAAgP9jiQ7Ty5REp84FJuVOoieQRAcAICdIogMAAPg/lugwPepcACk26t8kutPpzNFtSaIDAMyMJDoAAID/Y4kO06POBZAqFa6kAGuAklKStD95f45u616ik0QHAJgQSXQAAAD/xxIdplc8f3H376lzgVkF2gJVoVAFSTmvdHHXuZBEBwCYEEl0AAAA/8cSHaZHnQuQIS4qoxc9pycXJYkOADAzkugAAAD+jyU6TI8TiwIZXL3oJNEBAMg+VxI9PSVdjnSHwdMAAAAgN7BEh+kVy1/M/fvQADrRYV4k0QEAyDlXEl2S0s5T6QIAAOCPWKLD9IICglQ4tLAkkugwN1cSfcvRLUpzZH8JQBIdAGBmriS6RC86AACAv2KJDujfShc60WFmZSLLKNQeqpT0FO1M3Jnt25FEBwCYmdVmldWe8bKKXnQAAAD/xBId0L9L9FA7dS4wL6vFqqpFqkqS4o9kvxedJDoAwOxclS4k0QEAAPwTS3RAUsVCFSVlPskoYEZVozKW6FuPbc32bUiiAwDMzlXpQhIdAADAPwVc/SqA/3u16atqXLqxbq9wu9GjAIaKiYiRJO1L3pft25BEBwCYHUl0AAAA/8YSHZAUGRKpTlU6GT0GYLhS4aUk5XCJThIdAGByJNEBAAD8G3UuAAC3kuElJUn7k/dn+zYk0QEAZkcSHQAAwL+xRAcAuJWK+F8SPYkkOgAA2UUSHQAAwL+xRAcAuLnqXJJSknQq5VS2bkMSHQBgdiTRAQAA/BtLdACAW1hQmMKDwiVlr9Il3ZGudGe6JJLoAADzIokOAADg31iiAwAyycnJRV1VLhJJdACAeZFEBwAA8G8s0QEAmeSkF91V5SKRRAcAmBdJdAAAAP/GEh0AkEnJsJKSslfncnES3W6159pMAAB4s3xR+SRJSXuSDJ4EAAAAuYElOgAgE3cSPTt1LhedVNRiseTqXAAAeKvitYpLkg6tOWTwJAAAAMgNLNEBAJlcSyc6VS4AADOLrhMtSTq8/rDSU9MNngYAAACexhIdAJBJyfAc1LlclEQHAMCsIstFKigiSOkp6Tq6+ajR4wAAAMDDWKIDADLJ0YlFSaIDACCLxeKudDm4+qDB0wAAAMDTWKIDADJx1bmcunBKSeevfII0kugAAGRwVbrQiw4AAPzdvmX7tHLUSjmdTqNHyTMBRg8AAPAu+QLzKTI4UifOn9D+5P2KCI7I8rok0QEAyFC8NicXBQAA5jC923Sd+PuEilYrqpgmMUaPkydMkUS/4YYbVK1aNdWoUUPNmjUzehwA8HquXvSrnVyUJDr+v737Do+yzPo4/p30hBQIKaTSW6ihGpEivSyiCCqiguLasK/uqru2dwuubVddxLKKuIoIKAgISKRKh0AgtNAChPRASCV1nvePMaMRAkkImQn5fa4rF8nMM/OcySFw58x5zi0iIhbBPbW5qIiIiFz7CrMLyTqWBVjWPQ1Fg+lE37x5M56enrYOQ0SkXgjzCSMuPe6yc9HViS4iImJRvrloUXYRGfszaNa9ma1DEhEREal1aXvTrJ9n7G84G6o3iE50ERGpnvK56KdzTl/yOHWii4iIWJhMJms3enKMNhcVERGRa1OFIvoBFdHrzIYNGxg7dizBwcGYTCYWL158wTEzZ86kRYsWuLm50bdvX7Zv316tc5hMJgYOHEjv3r358ssvaylyEZFrV5XHuagTXURExEpz0UVERORa99tO9IayuajNx7nk5+fTrVs37rvvPsaPH3/B/V9//TVPP/00H3zwAX379uXf//43I0aMID4+noCAAAC6d+9OaWnpBY9dtWoVwcHBbNy4kZCQEFJSUhg6dChdunSha9euV/21iYjUV+Wd6JqJLiIiUnXlRfTknepEFxERkWtT2p5fiujnz54nPz0fz8Brf4S2zYvoo0aNYtSoUZXe//bbb/P73/+ee++9F4APPviA77//nk8//ZTnnnsOgNjY2EueIyQkBICgoCBGjx7Nrl27Ki2iFxUVUVRUZP06JycHgJKSEkpKSqr8uq5U+bnq8pxSNcqNfVJealdQI0sRIDE78ZLf04LiAgCcHZwrPU65sV/KjX1SXuxXbedGOb72lI9zSdubRllJGY7OjjaOSERERKT2GGaD9Lh0AJzcnCgtLCVjf4aK6LZWXFxMTEwMzz//vPU2BwcHhg4dypYtW6r0HPn5+ZjNZry8vMjLy2PNmjXcdtttlR4/Y8YMXn311QtuX7VqFR4eHtV/EVcoOjq6zs8pVaPc2CflpXYkFSYBcDLrJN9//z0mk+mix8WmxwJwJu0My5cvv+RzKjf2S7mxT8qL/aqt3BQUFNTK84j90OaiIiIici3LOp5FSUEJTm5OtBzSkiPfHyHjQAYtB7e0dWhXnV0X0TMzMykrKyMwMLDC7YGBgRw6dKhKz5GWlsYtt9wCQFlZGb///e/p3bt3pcc///zzPP3009avc3JyCAsLY/jw4Xh7e9fgVdRMSUkJ0dHRDBs2DGdn5zo7r1yecmOflJfaVVBSwPRD0yk0F3L94Otp4t7kosft3bQXkqFleEtGjx590WOUG/ul3Ngn5cV+1XZuyq94lGtH+eaiCWsSSI5JVhFdRERErinl89D9O/kT2DWQI98fIX1/uo2jqht2XUSvDa1atWLPnj1VPt7V1RVX1wtn+zo7O9vkF1lbnVcuT7mxT8pL7fBx9qGpe1POnD9D2vk0ArwDLnpcqWHZj8Ld2f2y33flxn4pN/ZJebFftZUb5ffaFNQzyFJE35lMj2k9bB2OiIiISK1J3ZMKQGC3QPwj/AHIPJBpy5DqjIOtA7gUPz8/HB0dSUtLq3B7WloazZqpq0NE5GoK9Q4FLr25aFGZNhYVERH5teBelrnoKTEpNo5EREREpHal77V0nQd2DcS/k6WInr4/HcMwbBlWnbDrIrqLiws9e/Zk9erV1tvMZjOrV68mKirKhpGJiFz7wnzCAMvmopUpLC0EwNVJRXQRERGwdKLDz5uLFpfZOBoRERGR2lM+ziWwayB+7f3ABOfPnKcg49rf68fmRfS8vDxiY2OJjY0FICEhgdjYWE6dOgXA008/zccff8ycOXM4ePAgDz/8MPn5+dx77702jFpE5NoX5m0pop/OOV3pMUWl6kQXERH5tSatmuDW2I2yorIGMyNURERErn1FOUVkHc8CLEV0Zw9nmrSy7J/WENY8Ni+i79y5k8jISCIjIwFL0TwyMpKXXnoJgNtvv50333yTl156ie7duxMbG8vKlSsv2GxURERqV7XGuagTXUREBLBsLhrUw9KNrpEuIiIicq1I32cplHuFeOHR1APAOhc940CGzeKqKzYvog8aNAjDMC74+Oyzz6zHPProo5w8eZKioiK2bdtG3759bRewiEgDUd6JrpnoIiIi1RPUy1JET45JtnEkIiIiIrXj16NcypXPRc/YryJ6gzVz5kwiIiLo3bu3rUMREbGJ8pnoVRrnok50ERERq+Ce2lxUREREri0XLaKrE12mT5/OgQMH2LFjh61DERGxCes4l+zESnfaVie6iEjDMmvWLLp27Yq3tzfe3t5ERUWxYsWKSz5mwYIFdOjQATc3N7p06cLy5cvrKFrbsW4uukebi4qIiMi1IW3Pz0X0br8U0QM6BQDqRBcRkQasvIh+vvQ8Z8+fvegx6kQXEWlYQkNDee2114iJiWHnzp0MHjyYcePGsX///osev3nzZiZNmsS0adPYvXs3N998MzfffDP79u2r48jrlnVz0WJtLioiIiL1n2E2SIu7sBPdr4MfmKAgs4D8jHxbhVcnVEQXEZGLcnNyw9/DcmlWZSNd1IkuItKwjB07ltGjR9O2bVvatWvH3//+dzw9Pdm6detFj3/nnXcYOXIkzz77LB07duSvf/0rPXr04D//+U8dR163TCaTtRtdI11ERESkvjt38hzFucU4ujjStF1T6+3OHs40adkEuPa70VVEFxGRSllHulSyuag60UVEGq6ysjLmzZtHfn4+UVFRFz1my5YtDB06tMJtI0aMYMuWLXURok2VF9GTd2pzUREREanfyke5+Ef44+jsWOG+hjIX3cnWAYiIiP0K8wljd+puErMrKaKrE11EpMGJi4sjKiqKwsJCPD09WbRoERERERc9NjU1lcDAwAq3BQYGkpqaeslzFBUVUVRUZP06JycHgJKSEkpKSq7wFVRd+blqcs6AbpYZock7k+s05obiSnIjV4/yYr+UG/ul3Ngn5aWi5N2WpgD/Lv4XfE+admgKyyA1LrVOvl+1nZuqPo+K6CIiUqkw7zDgEuNc1IkuItLgtG/fntjYWLKzs1m4cCFTpkxh/fr1lRbSa2LGjBm8+uqrF9y+atUqPDw8au08VRUdHV3txxTlWv6PTN2TyrLvluHgrIuAr4aa5EauPuXFfik39ku5sU/Ki0VCdAIAZ5zOXLBJ/NkSyx5qhzcexrzcXGcx1VZuCgoKqnSciugiIlKp8iJ6peNc1IkuItLguLi40KZNGwB69uzJjh07eOedd/jwww8vOLZZs2akpaVVuC0tLY1mzZpd8hzPP/88Tz/9tPXrnJwcwsLCGD58ON7e3rXwKqqmpKSE6Ohohg0bhrOzc7UeaxgGCc8nUJhVSK/wXjSLvPRrluq5ktzI1aO82C/lxn4pN/ZJeanog2c+AGDgbQNpOaRlhftSmqUw+53ZmNPMjB49ukbPf/boWb657RvajGzDjf+48ZLH1nZuyq94vBwV0UVEpFKaiS4iIpdjNpsrjF75taioKFavXs2TTz5pvS06OrrSGerlXF1dcXW98P8WZ2dnm/wiW9PzBvUIImF1Aul70gnrE3YVIhNb/Z2QS1Ne7JdyY7+UG/ukvEBxfjFnj1m6zUN6hlzw/WjW2dIoUJBRQPG5Yhr5N6r2ORLXJ5KxLwMPX48qf79rKzdVfQ5dU1iJmTNnEhERQe/evW0dioiIzYT5XGacizrRRUQalOeff54NGzZw4sQJ4uLieP7551m3bh2TJ08G4J577uH555+3Hv/EE0+wcuVK3nrrLQ4dOsQrr7zCzp07efTRR231EupU+eaiKTEpNo5EREREpGbS96WDAZ7NPC9aIHdp5ELjlo2Bmm8umrDaMi6m5dCWlznSdlREr8T06dM5cOAAO3bssHUoIiI28+uZ6IZhXHC/OtFFRBqW9PR07rnnHtq3b8+QIUPYsWMHP/zwA8OGDQPg1KlTpKT8UjC+/vrrmTt3Lh999BHdunVj4cKFLF68mM6dO9vqJdSp4F7BgIroIiIiUn+l7bWM5gvsGljpMf4R/kDNiuiG2SBhjaWI3mpIqxpEWDc0zkVERCoV7GX55b+wtJDMgkz8G/lXuF+d6CIiDcsnn3xyyfvXrVt3wW0TJ05k4sSJVyki+xbc0/L/aNreNMqKy3B0cbRxRCIiIiLVk7bHUkQP6BpQ6TH+nfw58v0RMvZXv4ieGpvK+bPncfFyIbh3cI3jvNrUiS4iIpVydXIlsJHl3ebfjnQxDIPismIA3Jzc6jw2ERERe9e4ZWPcmrhRVlxmuRRaREREpJ4p70Rv1q3yTdKvpBP9+I/HAWgxsAWOzvbbcKAiuoiIXFL5XPTfbi5aXkAHjXMRERG5GJPJRFAPy1z05JhkG0cjIiIiUj2GYVRpnEtAJ0uXek060evDPHRQEV1ERC4j1DsUgMTsikX08lEuoHEuIiIildFcdBEREamvchJzKMouwsHZAb8OfpUeV35ffno+BZkFVX7+0qJSTv50ErDveeigIrqIiFzGrzcX/bXyTUVBnegiIiKVCer5cyf6Ttt3optLzbYOQUREROqR1D2pAPh39L/k3i4uni40btEYqN5Il9NbTlN6vpRGgY3w7+R/+QfYkIroIiJySeVF9N+OcynvRHdycMLBpP9ORERELqZ8c9H0uHTKistsFsdPM37i7x5/J25unM1iEBERkfqlKqNcytVkLvrx1ZZ56K2GtMJkMtUgwrqjqoeIiFySdZzLb4voP3eia5SLiIhI5exhc9Ft721jzQtrMJeY2fTPTRiGYZM4REREpH5J32tZuwR0DbjsseWd5On7q77eSfixfsxDBxXRRUTkMqwbi1YyE12jXERERCpnMpms3ei22Fx07xd7Wfn4SuvXaXvTNJ9dREREqqQmneiZBzKr9NyF2YUk7UgC7H8eOqiILiIil1E+ziUpNwmz8cssVXWii4iIVI2t5qLHL41n8dTFAPR5vA+dJ3UGYPenu+s0DhEREal/Ss6XcObwGQCadWt22eOr24l+cv1JjDID37a++IT71DzQOqIieiVmzpxJREQEvXv3tnUoIiI2FewVjAkTxWXFZOT/MttMnegiIiJVU15Er8sO8BPrT7DwtoUYZQZd7+rKyH+NJHJaJABxc+MoOV9SZ7GIiIhI/ZOxPwPDbODh70GjwEaXPd6/o6WInp+WT8GZgsseXz4PveUQ+x/lAiqiV2r69OkcOHCAHTt22DoUERGbcnZ0ppmn5V3nX89FVye6iIhI1QT3soxzSdubRmlR6VU/X8quFL4a+xWlhaW0G9uOmz69CZODiZY3tqRxi8YUZRdx8JuDVz0OERERqb9+PcqlKpt+uni64NPc0lFelc1FE1Zb5qHXh1EuoCK6iIhUQflc9NM5p623qRNdRESkahq3sGwuai4xX/XNRTMPZfLFiC8ozi2m+cDmTPh6Ao7OjgCYHEx0v7c7oJEuIiIicmmpe1IBCOx2+Xno5crnol+uiJ6bkkvG/gwwQYsbW9Q4xrqkIrqIiFxWqHcoUHFzUXWii4iIVM2vNxe9miNdsk9l87/h/6Mgs4CgHkFMWjIJZ3fnCsd0n9odTHBi7QnOHjt71WIRERGR+i19r+WN/6psKlqufC765YroCWssXehBkUF4NPWoYYR1S0V0ERG5rPLNRSuMc1EnuoiISJVZNxeNuTqbi+Zn5PO/4f8jJzGHpu2bMnnlZFy9L/w/2ifch9bDWgMQOzv2qsQiIiIi9ZthGBXGuVSVtRN9/2WK6D9aiugth9aPeegATrYOQERE7F95Eb3COBd1oouIiFRZ+Vz0y3Wim0vNHFlxhD2f7aEopwj/zv4EdgkkoEsA/hH+uDRyueAxRTlFfDnyS87En8E7zJu7V91NI//KNwCLnBbJsVXHiP0slkGvDsLBUb1VIiIi8ovc5FzOnz2PydFk3TC0KgI6BQCX7kQ3DMO6qWh9mYcOKqKLiEgVlM9EVye6iIhIzZR3opdvLurkWvFXsexT2ez6ZBe7P9lNblKu9fbjPx7/5SATNGnVhIDOAQR0CSCgcwD+Hf1Z8fgKUnal4OHnwd3Rd+MT7nPJWNqPa4+7rzu5SbkcW3WMtqPa1t4LFRERkXovbY+lC92vgx9OblUvH/t19AMgLyWP81nncW/ifsExZ4+cJScxB0cXR8JvCK+dgOuAiugiInJZmokuIiJyZco3Fy3MKiR9XzrBPYMtXefLjxDzUQxHVxzFMBsAuDd1p/vU7vh18CN9X7rlIy6d/PR8so5lkXUsi/jv4is8v4uXC3f9cBd+7f0uG4uTqxNd7urC9ne3s/uT3Sqii4iISAU1GeUC4Orlik+4D9mnssk4kEF4vwuL5OVd6GHXh+Hs4XzB/fZKRXQREbms8nEuSblJmA0zDiYHdaKLiIhUg8lkIrhXMMejjxO/JJ747+ItXefJv3Sdt7ixBT0f6EmHWzpc0KkOkJ+eT/p+S0G9vLCevi8dTDBp6SSCegRVOZ4e03qw/d3txC+JJz8j/5LjX0RERKRhqWkRHSxz0bNPZZOx/+JF9Po4Dx1URBcRkSoI8grCweRAqbmUtLw0gryC1IkuIiJSTUE9gzgefZwN/7fBepuHnwfd7+1Oj/t70LRd00s+vlFAI1oGtKTljb/80mkYBuZSM47OjtWKJbBrIMG9gknemczeL/YS9VRU9V6MiIiIXLPKx7kEdqtBEb2TP0dXHr3oXHRzmZmEtZYien2ahw6gHWREROSynBycCPK0dLeVz0W3dqKriC4iIlIlLQe3rPD5hK8n8NTppxj2+rDLFtArYzKZql1AL9f9vu4A7P5kN4Zh1Og5RERE5NpSWlhKZnwmUPNOdICM/RcW0VNjUynMKsTV29W66Xp9oU50ERGpkjCfMJJykzidc5o+IX1+6UTXOBcREZEqaT2sNVPXT8Ur2AvfNr62Docuk7qw6ulVZOzPIHlHMiF9QmwdkoiIiNhYxsEMjDIDd193vIK9qv14/04/F9Ev0olevmF6i0EtcHCqX73d9SvaOjRz5kwiIiLo3bu3rUMREbEL5XPRyzcXVSe6iIhI9TUf0NwuCugAbo3diJgQAcCuT3bZOBoRERGxB7+eh24ymar9eP+OliJ6bnIuhecKK9yXsLp+zkMHFdErNX36dA4cOMCOHTtsHYqIiF0I9Q4FfjXORZ3oIiIi9V75SJd9X+2jOL/YtsGIiIiIzV3JPHQAV29XvMO8gYrd6KWFpZz66RRQ/+ahg4roIiJSReWd6KdzTgPqRBcREbkWtBjYgiatmlCcW8zBbw7aOhwRERGxsV93otdU+Vz09P3p1tsStyRSWliKZ5Anfh39rixIG1ARXUREqiTM5+dxLr/dWFSd6CIiIvWWycFUYYNREbm6tImviNgzwzB+6US/kiL6Reail89DbzWkVY3GxNiaiugiIlIl1nEu2b8Z56JOdBERkXqt+5TumBxMnNxwkjNHztg6HBG7kHU8iw+6f8CS+5dQWlh6xc9Xcr6ERfcs4p0W75AWl1YLEYqI1L681DwKMgswOZishfCaKO9Ez9j/SxHdOg99SP2bhw4qoouISBWVj3NJzk2mzFymTnQREZFrhHeoN61HtAYgdnasbYMRsQOGYbD0gaWk7Ulj9ye7+XzI5xRkFtT4+fIz8vl8yOfs/d9esk9lE/1MdC1GKyJSe8pHuTRt1xRnd+caP09ApwDgl070wuxCknckAyqii4jINa6ZZzMcTY6UGWWk5qWqE11EROQaEjktEoDYz2Ixl5ptHI2Ibe39314SVifg5OaEq48riZsT+STqkxpdqXHmyBk+ifqE01tO49bYDQdnB46tOsaJdSdqP/AGoji/mCMrjnD+7HlbhyJSb+Sn51fpqpramIcOWGee5yblUniukBPrTmCYDZq2a4pPmM8VPbetqIguIiJV4ujgSLBXMGCZi65OdBERkWtH+7Ht8fDzIC8lj6Mrj9o6HBGbKcgs4IenfwBg4MsDmbZlGo1bNObs0bN8EvUJpzaeqvJzlRffs45l0bhFY6ZtmUbPB3oCsPqF1ZqPXgPmUjNzx8xl7ui5vBn4Jv8b9j92zNpBbkqurUMToKy4jLKSMluHIb9xeNlh3gp6i9d8XuOT6z9h1TOrOPjtQfJS8y44Nn2vZSPQgK4BV3RONx83vEO9Acg4mPHLKJeh9bMLHVREFxGRaijfXPR0zml1oouIiFxDHF0c6Xp3VwB2f6oNRqXhWvXMKs6fOU9AlwCi/hCFf0d/pm2dRnDvYM6fOc/nQz5n37x9l32e/Qv2M2fwHM6fOU9w72CmbZ2GXwc/+v+5P07uTpzecprDyw7XwSu6tqx5cQ0n15/E5GDCXGrm+I/HWf7Ict4OeZtP+33K5jc3k3U8y9ZhUlZcRsKaBDIPZTaYonJBZgHvd36fN/zfYMu/tlBW3DBet70rLSplxeMrMMwGZcVlnN5ymi1vbWH+rfN5K+gt3mn1Dt/e9S073t9BamwqqbGpADTr1uyKz/3ruei/3lS0vnKydQAiIlJ/lM9FT8xWJ7qIiMi1JvK+SLb+ayuHlx4mLy0Pz0BPW4ckUqcS1iSwZ84eMMHYj8bi6OwIgGegJ1PXTeXbyd9yaPEhvpn0DVkJWdzw3A2YTKYKz2EYBlve3mKde97+pvaMnzsel0YuAHgFedH3ib5sem0Ta/68hnZj2mFyqPgccnHxS+PZ9NomAG796laaRTbj0KJDHPz2IEnbkkjcnEji5kSin40msFsgHcd3pMMtHQjoHHBBnq627x/5nt2fWN6QdHB2wLeNL/4d/fHr6IdfRz/L5x38cPao+cxpe2KYDRbds4izR84CsOrpVcR8EMOIf42g7ei2No6uYdv6762cSziHV7AXd626i9TdqdaflfS4dM4lnONcwjnivoyr8LgrHecC4N/Jn2OrjnH8x+NkHswEE7S4scUVP6+tqIguIiJVFuodCvw8zkWd6CIiIteUgM4BhPQJIWl7Euv/bz3dp3bHt40v7k3cbR2ayFVXcr6EZQ8uA6D3I70JvS60wv3OHs5MXDiRVc+sYtu/t7HmhTVkHctizKwx1mK7uczMyidWsmPmDgD6PNaHEf8agYNjxSEA/f7Yj52zdpIel86+efvocmeXOniF9VtWQhaL71kMQJ/H+9Dptk6A5XvZ74/9yDmdw6HFhzi06BAn1p8gbU8aaXvSWPfyOjyDPAm/IZzw/uGE3xBOYNfAC3JSmxK3JFoL6M4ezpQUlJB5MNNSRPwNn+Y+ltnR1wGjr1pIV93G1zZydMVRnNyc6P+X/mx/dztnDp9h7pi5tBnZhuFvD8e/o7+tw2xw8lLz+OlvPwEw5LUhBHQKIKBTAF3vslx5VpRTRNL2JE5tOsXpzac5vfU0RTlF+Lb1xTvM+4rPX96JfvCbgwAE9wyu12sKFdFFRKTKyjvRT+ecVie6iIjINShyWiRJ25PY+f5Odr6/EwD3pu40bdsU37a++Lb1/eXzNr64+bjZOGKR2vHT33/i7NGzeAV7MeQfQy56jIOjAyP/NRLf1r6sfGIluz/ZTfapbG5beBsmRxPfTPqGw0sPgwmGvzWc65687qId0O5N3On3x36s+fMa1r60loiJEdZCvFyotLCUBRMWUHiukJC+IQx/Y/gFx3iHetPn0T70ebQPBZkFxC+N59CiQxxbdYy8lDwOLDjAgQUHAHD1diXs+jBrUT2kTwhObrVTHjOXmVk+fTkA3e/tzk3/vYnsxGwyD2aScTDDWkzPOJjB+TPnyT6ZTfbJbEw/mjhx/QnaDqt/Xdsn1p1g7YtrARj9/mgi742k72N92fC3DWz991aOrjzKsehj9Hm0DwNfHlivi6j1zeo/r6Y4r5iQPiF0ndz1gvtdvV1pNbQVrYZaRqyYy8ycOXwGz2aetXL1hn8nSxG9fMPy+jwPHVREFxGRaiifia5OdBERkWtTtyndyIzPJGVnCmeOnCEvJY/zZ85z+oylQ+23gnsFM37ueJq2bWqDaOteaWEpe/63B+8Qb0KjQlUMukak709n0z8tY0JGvTcKV+9Lr2/7PNoHn+Y+fHPHNxyPPs6nN3yKk6sTyTuTcXJz4pYvbiHi1ohLPkffx/uy7Z1tZB3LYvenu+n1YK9aez3XmpVPrSRlVwruTd2ZOH8iji6XfsPBw8+DyHsjibw3kpLzJZZO242nOPXTKRI3J1KUU8TRlUetmyg7ujgS3DuYng/0pNs93a4o1l0f7yJ1dyquPq4MfW0oJgcTjZs3pnHzxrQZ2abCsfkZ+WQezGTzm5s5vPQw30z4hqkbptbKLOq6kpeaxzeTvsEwG3Sf2p3IeyMBS3F22OvD6PH7HkQ/E038kni2vbONvV/s5cb/u5GeD/TEweniVwOYy8zkJudy7sQ5sk9mU5RbRMStETQKaFSXL63eS9mVQuzsWABGvjOySmOjHBwdavWKgd8+V32ehw4qoouISDX8eiZ6mWHZKEad6CIiItcOJ1cnRrw1wvp1cV4xZ4+d5eyRs5w5coazR375PD8tn+SdyXzc+2PGfzmedmPa2TDyurHyqZXEfBBj/TqgcwBh/cIIvyGcsH5hNG7RuM5nL8uVMcwGyx5YhrnUTPtx7elwS4cqPa792PZM3TCVr373Felx6YCleHvHkjsIiwq77ONdPF3o/5f+rHx8JRv+bwPd7umGs/u1MR+7Nu39Yq/lZ84E478Yj0+4T7Ue7+zuTIuBLWgxsAVg6YhNi0vj1E+WovrJn06Sn5ZP4qZEEjcl4urjSodxVfs78FsFmQWsfmE1ADf+9cbLFn0b+TeikX8jAiIDmBk1k/z9+Xw56kumbZ5G4xaNaxRDXTKXmfnmzm/IS80joHMAo2deOI+madum3PHdHRyLPsYPT/5AxoEMlk9fzs5ZO+n/5/6UFpZy7uQ5sk9kc+7kOc6dOEdOYo61c7nc5jc2M3Xd1Grnv6EyDIOVT64EA7rc2eWC8VR1xa2xG14hXuQm5eLo6khYv8v/22jPVESvxMyZM5k5cyZlZdpNWESkXPlM9JS8FDxdLJuNqRNdRETk2uXi6UKzbs0u2hmZk5TDwtsXkrgpka/GfsWgVwcx4M8DrtlNEk9tPGUtoDdp1YSs41mk70snfV86MR9abvcK9qpQVG/WrVml3ZZiH2I+iiFxcyIuni6Mem9Utd4ECe4ZzP3b7mfh7QspLSpl4vyJ+LbxrfLjez7Qky1vbSH7ZDY7Zu7g+meur8lLuGal70+3zqkf8OKACzq5a8LByYGgyCCCIoPo+3hfDMMg61gWG1/byO5PdvPd1O8I3BVIk5ZNqv3cq/+8msKsQgK7BtL74d5VfpyTmxMtn29J2ow0MvZn8MXIL7hv4314+HlUO4a6tP7V9ZxYewLnRs5MXDDxkpukth7Wmof2PMTOD3ey7qV1pO9L55tJ31R6vIOTAz7hPjRu0ZizR89yLuEcnw36jClrp9C4eeOr8GquLQcWHuDUT6dwcndiyGsXH09VV/wj/MlNyiW8X3i9f6NQRfRKTJ8+nenTp5OTk4OPj97pEhEBCPQMxNnBmRJzCTlFOYA60UVERBoq7xBvpqyZwsqnVrLzfUthJCUmhVs+v+Wy4zDqm9KiUpY+sBSA7vd1Z9wn48hLyyNxcyKnNp4icVMiKTEp5CbnVpi97NbYjVbDWtFmZBtaj2iNd8iVb9QmtSc3JZcfn/sRgMF/H4xPWPV/9/cJ92HalmkYhlHtqxCcXJ0Y9Mogvrv3OzbO2EjPB3ra/GfnfNZ5Tm89TethrW36BlBRbhHzb51PSUEJrYa2YuBLA6/KeUwmE75tfBnz/hjS96WTtC2Jhbcv5N6f7sXJteols+Sdyez6eBcAo/4zqtrfOydPJ+5YdgdzBszhTPwZ5v5uLvesvgeXRi7Vep66cvSHo2z42wYAxn40Fr8Ofpd9jIOTA32m96HLpC6s/7/1JKxJwLOZJ41bNManuaVg3rh5Yxq3aIxnkKd189ec0zl8Nugzso5lMWfQHKasUyH9UkrOlxD9bDQA/f7Ur0b/rtWmFoNacDz6OB1v7WjTOGqDiugiIlJlDiYHQrxDOHHuhPU2daKLiIg0XI4ujoyZOYbgnsF8//D3xH8Xz3/7/pfbF91epaJKfbHxtY1kHsykUUAj66aGnoGedLylIx1vsRQGSgpKSNqRZC2qJ25OpPBcYYWiekCXANqMbEObkW0I6xdWrSKd1L6VT6ykKLuI4N7B9J5e9c7hi6npGJ+ud3dl0+ubLLOx39rMja/eeEVxXInCc4V8ev2nZB7KpPmA5kz4egKezTzrPA7DsIzYORN/Bq8QL8bPHW8tqF4tji6OTJw/kQ8jPyR5RzLRz0Yz6t1RVYvXbFg2EzWg611dad6/eY1i8Arx4q4f7uLTfp9aivm3LeT2xbfb3aazOadzWHTXIjCg50M96XJnl2o93t3XnZH/Hlnl471DvZm6bipzbpzD2aNnLYX0tVPqxcgbW9jytuXqFu8wb/o928/W4XD9M9fTenhrgnoG2TqUK6brykREpFrKR7qUUye6iIiIRN4Xyb0/3YtXiBeZhzL5uM/HxC+Jt3VYtSLjYAYb/7ERgJHvjsTd9+KbiTp7WGYvD/jzACYvn8wfz/yRaVumMfDlgYT0DQETpMels/mNzXw+5HNeb/o6X930FTve30F2YnZdviQBDi87zIEFBzA5mhj78dirXqStjIOjAzf+1VI43/r2VvIz8qv1+PyMfMqKr3wMbVlxGfNvnU/moUwATm44yYc9PuTUplNX9LxHVhzhwx4fMqvrLH587kdObTx1wbzr39rx/g72zduHg5MDE76eQCP/utlQ0ifch5s/vxmA7e9tZ/+C/VV63O7Zu0nanoSLlwtDXx96RTH4d/TnzmV34uTuxJHlR1j24DIMw7ii56xNZSVlLLxjIQWZBTSLbMbIf1W9GH4lvEO9mbJuCr5tfTl3wjLa5dyJc3VyblsoLSyl4ExBtR+Xm5zLxhmW/6+G/nPoJUfs1BVHF0eCewVfE/uFqIguIiLVUr65aDl1oouIiAhASJ8QHoh5gOYDmlOcW8y8cfNY+/JaDLP9FICqyzAbLP39UsqKy2g7ui2dbutU5cc6ODoQel0og14ZxP1b7+fZjGe59atb6TalG40CG1GSX8LhpYdZPn0577V9jyMrjlzFVyK/VpxXbOkcBqKejrrozP+61HF8R4J6BlGcV2wtgF1ObkouS36/hLeavcUH3T8gJymnxuc3DINlDy8jYU0CLp4uTFwwEf8If/JS8pgzaA5b39la7UJufkY+307+lrmj55K6O5X0uHQ2/XMTs/vP5s3AN/l28rfEfRXH+bPnKzwuaXsSPzz1AwBDXx9KeL/wGr+ummg3ph39nrN07y6ZtoQzR85c8vjzWedZ/ZxlM9FBrwzCK8jrimMIuz6MCV9PwORgInZ2LGtfXHvFz1lb1vx5jWUDVm9XJi6YiJNb3V1N4x3izZS1lkJ69snsa7KQbhgGcXPj+HeLf/N28Nv8NOOny77p9Gurn19NSX4JoVGhdL6j81WMtGFSEV1ERKrlgiK6OtFFRETkZ56Bntz94930ebwPABv+bwPzxs2j8FyhjSOrmZiPY0jclIhzI2fGzBpzRZ10Hk096HxHZ27+7Gb+kPwHHtz9IENmDCGoZxBlRWV8fcvXHF15tBajl8qsfWkt2aeyadyiMQNfvjqztqvDZDIx5B+Wzf8ud2VCcV4x615dx3tt3mP3f3djmA0yD2Yyu/9sso5n1ej8G1/bSOynsZgcTEz4egIREyK4f9v9dL6jM+ZSMz88+QPf3vktxXnFl30uwzDY8789zOw4k7i5cZgcTET9IYrxc8fTZXIX3H3dOX/2PHFz4/j2zm95w/8NZg+YzcZ/biRxSyILJi7AXGKm4/iOXPfkdTV6PVdq8F8HE94/nOLcYhbetpCS8yWVHrv2xbUUZBbgH+FPn8f61FoM7ce253cf/g6An/7+E9tnbq+1566p+CXxbH5jMwDjZo/Dt3XVN9GtLd4hltEuTds1tRTSB35GVkLV/97npeax67+72PvFXspKrvwKjtqUcTCDz4d8zreTvyU/zXKFyZoX1vBpv0/JOJhx2ccn7Uhiz+d7ABj5zshrovPb3mgAm4iIVMtvx7k4O9j+EjERERGxH47Ojox6ZxTBPYNZ9uAyDi87zEe9PuL6Z66n0+2dcG9y8XEo9iY3OZcf//irTSfDa29zNpODiWbdm9GsezOi/hDFwtsXcmjRIebdPI87vruDNiPa1Nq5rlT6vnRWPLaCpB1JNG3XlIDOAZaPLpY/vUO960WxpvBcIUk7kkjclMi2d7YBMGbWGLvZuLHVsFa0GNSCE+tOsP7/1nPTxzdVuN9cZrZ2Jeel5gEQ0jeEfn/sx49/+pGzR88yu/9s7v7xbvw7+lf5vPvn72fNC2sAy7iitqPbAuDi6cL4ueMJjQpl1R9WsW/ePtL2pnHbt7fh1/7i+x1kJWSx7MFlHI8+DkBgt0Bu+u9NBPcKBqDLpC6Yy8yc3nqaw8sOc+T7I6THpXPqp1Oc+umXsTG+bXy56dObbPb3ysHJgVu/upUPIz8kNTaVlU+uZOyHYy84LjU2lZ2zdgIw6r1RtT67vMf9PchNyWXdS+tY8dgKPAM9iZgQUavnqKpzJ86xeMpiAPo+2ZeO4223SaRXsBdT1k5hzo1zOHP4DJ8N/Iyp66bSpFWTix6flZDFoUWHOPjtQRI3J8LPF1VseXsLN/33JoJ62HZWd0lBCRv+toHNb27GXGLGyc2JAS8OwCvYi5VPriRpexIfRn7I4L8N5rqnrrvo6CnDMPjhScsVHN3u6UZI75C6fhkNgoroIiJSLWE+v3Siuzq61otfmkRERKTudbunG/6d/Jk/fj5Zx7L4/uHvWfnkSjrc3IHuU7vTalgrm82hrooVj62gKKeIkD4h9Hm09jpMf8vR2ZEJX0/4pZA+zj4K6aWFpWz42wY2/XOTdZxA6u5UUnenVjjO1cfVWlhv2rEpefl5lA0tw9nZdo0WZSVlpO1NI2lbEknbkji97TRn4iuO5eg8qTNtRtrPmxUmk4nB/xjMp9d/SuzsWPo924+m7ZpiGAZHVx7lxz/+SPq+dAAat2zM0NeGEjExApPJRGhUKP8b9j8y9mfw2YDPuDv6bpp1v/yImsQtiSy6ZxFgKYz2mV7x77nJZKLv430J6hnEgokLyDiQwce9P2bc7HFE3PpLMddcambbu9tY++JaSgpKcHJzYuArA4l6OuqCwrKDowPh/cIJ7xfO0BlDOXfyHEe+P8KR749wfPVxywafCyfi5uN2pd/SK+Id4s34L8fzxYgv2PXRLpr3b07Xu7pa7zcMg+WPLscwG3S6rRMtB7e8KnEM+MsAcpNzifkghm8nf4uHvwctBra4Kue6GMMwSNqexPLpyyk8V0hI3xCG/XNYnZ2/Ml7BXkxZ93MhPf4Mnw36zDLqpbUvhmGQvi/dWjhP25NW4bHBvYI5e+wsqbtT+bjPx1z/zPUMfHkgzu51/29W/JJ4Vjy+guyTlqtP2v2uHSPfHUmTlpY3BFoNa8XS3y/l6IqjRD8bzcFvD3LzZzfTtF3TCs+zb94+Ejcn4uzhzJAZQ+r8dTQUKqKLiEi1/Hqci0a5iIiIyKUE9wzmwdgHif0sltjZsaTHpbP/6/3s/3o/XsFedL27K92mdKtW52xdOLTYUnxxcHKok00nHZ0dmTDv50L6YkshfdKSSbQe3rpaz2OYLaM0Yj+NxbetL30e7VOlYupvJaxJYNmDyzh79CwA7W9qz4AXB5CTlEN6XDrp+ywfZ+LPUJRdROKmRBI3JVof/+9//pu2Y9rS4eYOtBnVBlevq79mTI5JJm5uHElbk0jZlUJpYekFxzRp1YSQviGE3xBO5LTIqx5TdYVFhdFubDsOLz3M2pfWcsNzNxD9bDTHf7R0drs1cWPAiwPo/UhvnFx/Ked4BXkxdf1UvhjxBSkxKcy5cQ53Lr+TsKiwyk5F1vEs5o2bR1lRGe1vas/wN4dXemx4v3Ae3PUgC+9YyMn1J1kwYQHXP3s9Q/4xhPT96Sy9fynJO5MBaDGoBb/76Hc0bdu00uf7tcbNG9P7kd70fqQ3JQUlmEvNuHrbx+8YrYe1ZuBLA1n/6nqWPbiMoB5B+EdY/q3a+8Vey6gnD2eGv1X59+5KmUwmRv9nNPmp+RxafIgvR33JsDeG0fuR3letmckwDFJjU63/VpfPHXf3dWfi/Ik4utRux31NeQVZOtI/H/w5mYcymTNoDp1u70T8d/HWf7vAcuVP84HN6XBLBzrc3AGfMB/y0vJY8dgKDiw4wKZ/buLgNwcZ+/FYWgxqUSexZyVksfKJlRxeehiwbGo76r1RtL+pfYXjvEO8ufP7O4mdHcvKJ1dyestpPuj+AUNmDKHvY30xOZgoKSixXjV1w/M34BV85XP55eJURBcRkWr59TgXbSoqIiIil+PexJ2op6K47snrSI1NJfazWOK+jCM3OZdN/9zEpn9uIqRvCN2ndr/icS+G2SDjQAYnfzrJqZ9OWeeZD/jLADrf0RmTw+WLTkU5Rb9sOvlMFIFdA2scT3U4ulg60hfctoD47+KtHelVLaQnbU9ixeMrSNqWBMDJDSfZ/cluwvqF0efRPnQc3/Gyxa+CMwVEPxNN7GexAHgGeTL6P6PpcEsHTCYTwb2C6TCug/X4suIyMuMzrUX1tD1pJGxKoOhcEfu+2se+r/bh6OJIq6GtaH9ze9rf1B7PQM+afYMqUZRTxOo/r2bHzB3WMQ0Abo3dCOkTQkjfnz/6hNDIv1GtnvtqGPy3wRxedthSwJy/HwzL340+j/Wh/5/7V/rz4dHUg3tW38NXv/uKUxtP8b9h/2PSkkkX7ZA+n3WeuWPmUpBRQFCPIMbPHX/ZN4o8m3lyz4/38OPzP7LlzS1sfmMzR1ccJeNgBkaZgVtjN4a9OYzI+yJrXNx19rC/MZEDXhzAqY2nSFidwIKJC7h/+/2YS81EPxttvd871PuqxuDg6MD4ueOZf+t8jq44yopHVxD/XTzjPh1Xq+fOOJDBvnn72P/1fs4c/uXKDedGzrS/qT39/tSvVsda1YbyQvqcwXPIPJjJlre2AODo6kjr4a3pcEsH2o9tj4efR4XHeQZ6MnH+RA59d4jljyzn7NGzzLlxDj1+34Nhrw/DrXH1roQoOW95A8jByQEHRwccnBwu+v9NaVEpW97awoa/baD0fCkOTg5EPRPFgL8MqHS0lMlkIvK+SFoNbcWSaUs4/uNxfnjyBw5+c5Bxs8ex94u95JzOwae5D1F/iKpW3FI9KqKLiEi1+Dfyx8XRheKyYnWii4iISJWZTCaCIoMIigxi+BvDOfz9YfZ8tofD3x+2jt1Y+cRKfNv64tvalyatm1g+WjXBt7UvjVs0vqAIXFZcRurOVE5tPGUtmp8/e/6Cc387+Vu2vL2F4W8Ov2yn4Y/P/0huci6+bXwZ+FLdbjrp6OLIxPkTKxbSl9xB62GVF9LzUvNY/fxqa+HbxdOFqD9EcSb+DAcWHrB2iXsGedLzwZ70fKAnXkEVOxUNwyDuyzh+eOoHCjILwAS9Hu7FkH8MueRYDUcXRwK7BBLYxfJGQ0lJCd8v+55uft04uuwohxYd4uyRsxxZfoQjy4+w7MFlhF0fRoebLR2hvm1qvjGhYRgcWnSIFY+tIDc5F4CIiRG0G9uO0L6h+Lb1rZdjBwO7BtJlUhfi5saBAZ3v6Mzgfwy2jne4FDcfNyavnMzXt3zN8ejjfDn6S2775jbajWlnPaasuIz5t84n81Am3qHeTFo6qcpz4R2cHBj+xnBC+4by3b3fWcfLREyMYNS7o/BsVrtvkNgDB0cHxn85ng8jPyTjQAbLH1mOm68b+Wn5NG3XlOueqpvNT53dnblz2Z3seH8H0X+M5nj0cWZ1mcXomaPpPKlzjf+unzlyxtpxXp5PACc3J9qOaUvnOzrTdnRbu3yDo5xnM0+mrJ3CsgeX4ezhTIdbOtBmZNWugOkwrgMtBrUg+o/R7PpoF7s+3sXhZYcZ8/4YWo+5+L+7JedLSI1NJWl7Esk7kknansTZI2cveqyDkwMmR5O1uG4uM1OSb9motsWgFoyeOdp6dcPl+IT7cNequ4j5KIZVf1jFqZ9O8UHXDzDMlncPh70+zCYjaRoSFdFFRKRaHEwOhHqHcjzruDrRRUREpEYcXRzpeEtHOt7Skby0POLmxlnHvWTszyBjf8YFjzE5mPAO86ZJqyZ4h3tzPOY4+ybto/R8xbEdzh7OhEaFEt4/nPAbwknansTGGRutYy7a/a4dQ18fetERMombE60bBf7uw9/ZpCBhLaRPXED8knjm3TSPSUsn0WpoqwrHlRWXsfWdrWz46waKc4sB6DalG0NmDLEWyYe/PZyYD2OI+TCGvJQ81r+ynp/+9hMREyLo/Whvwq4PI+u4ZV59+WaQAZ0D+N1Hv7vkKJBLMTmYCL0ulJb9WzL0taFkHsrk0OJDHFp0iOQdydaifvSz0QT1DKLH/T3oPKlztWZgZ5/KZvmjy62jEHzb+DJm1pgLvkf11aj/jMKvox+thrUitG/o5R/wKy6NXJi0dBILb19I/HfxfH3z14yfO552N7fDMAxWTF/BibUncPF04c7v76zR6IeICREEdA5gy9tbaPe7dheMoLjWeAZ6MmHeBObcOIc9n++x3j7y3ZEVxupcbSYHE30e7UOrYa1YfM9ikrYn8e3kb4n/Lp7R74/Go6nH5Z8Ey9Ub+77eR+zsWE5vOW293cHZgTYj29D5js60G9uuTsYw1RbPQE/uWHxHjR7r5uPG2A/H0uXOLiy9fylnj57l61u+psP4DjiMcSB9bzppu9NI2pFE8vZk0velW/eJuBxzqRlKoayozHpbo8BGDH9rOF3u7FLtNz9MJhO9HuxF6+GtWXLfEk6sOwFA+A3hREy0zaazDYmK6CIiUm3WIro60UVEROQKeQZ6Wse9nEs4x5nDZzh77CxZx7PIOvbzx/EsSgpKyD6Zbd2ArZx7U3fCbwgnvH84zfs3p1lkswqbGbYa0ooe03qw/v/Ws/ODnRxedpgjK47Q4/4eDHplkLV7trSolKW/XwoGdL+3+1XbKLAqHF0cmbjgl0L6V2O/qlBIP/z9YX546gdr92NInxBGvjvygoKrV5AXg14ZRP8X+nPw24Ns/892Ejclsm/ePvbN20dA5wDOHj1LaWEpjq6ODHxpINc/c32tzTw2mUz4d/THv6M//Z/vT87pHOKXxHNo8SFOrD1BSkwK38d8zw9P/0CniZ2InBZJeP/wSgtL5lIz2977eQPL/BIcnB3o96d+9H+h/zXVgenexJ0BfxlQ48c7uToxccFEvpv6HXFz4/jmjm8Y/eFo0telk/JlCiYHExPmT7iiUUV+HfwY+9HYGj++vmk+oDk3/u1G1rywBsDS7WyjzX/92vtx36b7+GnGT2z4vw3sn7+fkz+d5KZPbqLtqLYXfYxhNji54SSxs2PZv2C/9c1Hk6OJVkNb0fmOznS4uUO1x5hcS1oMbMFDex9i/avr2fzmZg59ewi+hQMcuODYRoGNCOkdQnCfYEJ6hxDUMwiXRi6Yy8yYS80YZQbmUvNFv27SsglObldWjm3Ssgn3rL6HHbN2cHTFUYa/NbxeXnlT36iILiIi1Va+uag60UVERKS2mEwmmrSyjG/5LcMwyEvNsxbWzxw9Q0JmAqMeHEVQl6DLzjpvFNCI0f8ZTZ/H+rD6udUcWnyImA9j2PvFXvr9qR9RT0ex5e0tZBzIwMPf45KbLNaV8kL6/AnzObz0MF+N/Yoxs8awf/5+jq44ClgKOUP/OZRud3e75PfA0cWRznd0pvMdnUnZlcL2mdvZN3efdXxDy8EtGfPBmCpvBllT3qHe1k0kCzIL2PvFXnb9dxcZ+zPY8/ke9ny+B9+2vkTeF0m3Kd0qjJ1Jjklm2QPLSNmVAkBYvzDGfjS2yqMQGhpHZ0du/vxmnDyc2P3f3Xz/+++t9436z6hKi61SuRv+dAPpcemc3nqaEf8aYdNYHJwcGPjiQNqOasuiexaReTCTuaPn0vPBngx/czgunpYRPdmJ2eyZs4fY2bFkHc+yPt6vox+R90XS9a6u1+QYnppydndm6GtD6XRbJ76b9h1psWm4eLkQ3CuY4N7Bln0WeofgHeZt86K1ycFEn+l96DO9j03jaEhURBcRkWqzFtHViS4iIiJ1wGQy4RXkhVeQF+H9wikpKSF3eS7+Ef5V2iy0nF97P25fdDsnfzpJ9DPRJG1PYt1L64j5IMYyCxwY+c5I3H1rvrlpbbJ2pE9YwOFlh/nu3u8Ay9iF6568jgF/GYCrd/XWY0E9ghj3yTiGvT6MuC/jaBTYiE63darzgpCHnwfXPXkdfZ/oS9L2JHb9dxf75+3n7JGzrH5+NWv+soZ2Y9rR/d7unFh3gu3vbccw/7yB5Rs/b2BZjdw3RA6ODoz9aCyuXq5s/ddWAPo80YfeD/e2cWT1k8nBxK1zb7V1GBUE9wrmgZgHWP3Carb9exsxH8Zw/MfjXPfUdRxecphj0cesG+66eLnQeVJnIu+NJKRviM2LwPYsqEcQ9229jyVzl3DTnTfh4lq1fQPk2qYiuoiIVFuot+VSYXWii4iISH3UvH9zpm2dxv75+1n9/GrOJZwDoM0oyzxge+Lk6sTEhRNZeNtC4pfE03ZMW0a8PYKm7a6sa9yjqQd9H+9bS1HWnMlkIrRvKKF9Qxn5r5Hsn7+f3Z/sJnFzIvFL4olfEm89tsudXRj+9nA8A9U5W1Umk4nhbw3Ht4MvuzfuZvBrg20dktQyZ3dnRv5rJO1vas/iKYvJOpbFikdXWO9vcWMLut/bnYhbI+x6g1B7Y3Iw4ezrrDfrxEpFdBERqbahrYbi6+7LiNa2vYxRREREpKZMJhOdb7fMAd7x/g5SdqYw7I1hdtmd6eTqxO2Lbyc3ORfvEG9bh3PVuHi6EHlfJJH3RZJxMIPdn+wmbm4c7r7uDH9ruM1mUNd3JpOJ7vd2JzkwGQdHB1uHI1dJyxtb8nDcw6z6wyoSNyUSMTGC7lO7X3RElohUn4rolZg5cyYzZ86krKzs8geLiDQw7f3ak/lspl3+kikiIiJSHU6uTkQ9FWXrMC7LZDJd0wX03/Lv6M/wN4fbxXx6kfrCzceNm/57k63DELkm6S3ISkyfPp0DBw6wY8cOW4ciImKXVEAXERERERERkYZARXQRERERERERERERkUqoiC4iIiIiIiIiIiIiUgkV0UVEREREREREREREKqEiuoiIiIiIiIiIiIhIJVREFxERERERERERERGphIroIiIiIiIiIiIiIiKVUBFdRERERERERERERKQSKqKLiIiIiIiIiIiIiFRCRXQRERERERERERERkUqoiC4iIiIiIiIiIiIiUgkV0UVEREREREREREREKqEiuoiIiIiIiIiIiIhIJVREFxERERERERERERGphIroIiIiIiIiIiIiIiKVUBFdRERERERERERERKQSTrYOwN4ZhgFATk5OnZ63pKSEgoICcnJycHZ2rtNzy6UpN/ZJebFfyo39Um7sk/Jiv2o7N+Xry/L1plROa3L5LeXGPikv9ku5sV/KjX1SXuyXrdbkKqJfRm5uLgBhYWE2jkRERERErkW5ubn4+PjYOgy7pjW5iIiIiFxNl1uTmwy1vlyS2WwmOTkZLy8vTCZTnZ03JyeHsLAwEhMT8fb2rrPzyuUpN/ZJebFfyo39Um7sk/Jiv2o7N4ZhkJubS3BwMA4OmrJ4KVqTy28pN/ZJebFfyo39Um7sk/Jiv2y1Jlcn+mU4ODgQGhpqs/N7e3vrh9VOKTf2SXmxX8qN/VJu7JPyYr9qMzfqQK8arcmlMsqNfVJe7JdyY7+UG/ukvNivul6Tq+VFRERERERERERERKQSKqKLiIiIiIiIiIiIiFRCRXQ75erqyssvv4yrq6utQ5HfUG7sk/Jiv5Qb+6Xc2CflxX4pNw2Pcm6/lBv7pLzYL+XGfik39kl5sV+2yo02FhURERERERERERERqYQ60UVEREREREREREREKqEiuoiIiIiIiIiIiIhIJVREFxERERERERERERGphIrodmrmzJm0aNECNzc3+vbty/bt220dUoOyYcMGxo4dS3BwMCaTicWLF1e43zAMXnrpJYKCgnB3d2fo0KEcOXLENsE2MDNmzKB37954eXkREBDAzTffTHx8fIVjCgsLmT59Ok2bNsXT05Nbb72VtLQ0G0XcMMyaNYuuXbvi7e2Nt7c3UVFRrFixwnq/cmI/XnvtNUwmE08++aT1NuXHNl555RVMJlOFjw4dOljvV15sJykpibvuuoumTZvi7u5Oly5d2Llzp/V+rQMaDq3JbU/rcvukNbl90pq8/tCa3H5oTW6/7G1NriK6Hfr66695+umnefnll9m1axfdunVjxIgRpKen2zq0BiM/P59u3boxc+bMi97/+uuv8+677/LBBx+wbds2GjVqxIgRIygsLKzjSBue9evXM336dLZu3Up0dDQlJSUMHz6c/Px86zFPPfUUS5cuZcGCBaxfv57k5GTGjx9vw6ivfaGhobz22mvExMSwc+dOBg8ezLhx49i/fz+gnNiLHTt28OGHH9K1a9cKtys/ttOpUydSUlKsHxs3brTep7zYRlZWFv369cPZ2ZkVK1Zw4MAB3nrrLZo0aWI9RuuAhkFrcvugdbl90prcPmlNXj9oTW5/tCa3P3a5JjfE7vTp08eYPn269euysjIjODjYmDFjhg2jargAY9GiRdavzWaz0axZM+ONN96w3nbu3DnD1dXV+Oqrr2wQYcOWnp5uAMb69esNw7DkwtnZ2ViwYIH1mIMHDxqAsWXLFluF2SA1adLE+O9//6uc2Inc3Fyjbdu2RnR0tDFw4EDjiSeeMAxDPzO29PLLLxvdunW76H3Ki+386U9/Mm644YZK79c6oOHQmtz+aF1uv7Qmt19ak9sXrcntj9bk9ske1+TqRLczxcXFxMTEMHToUOttDg4ODB06lC1bttgwMimXkJBAampqhRz5+PjQt29f5cgGsrOzAfD19QUgJiaGkpKSCvnp0KED4eHhyk8dKSsrY968eeTn5xMVFaWc2Inp06czZsyYCnkA/czY2pEjRwgODqZVq1ZMnjyZU6dOAcqLLS1ZsoRevXoxceJEAgICiIyM5OOPP7ber3VAw6A1ef2gn0f7oTW5/dGa3D5pTW6ftCa3P/a4JlcR3c5kZmZSVlZGYGBghdsDAwNJTU21UVTya+V5UI5sz2w28+STT9KvXz86d+4MWPLj4uJC48aNKxyr/Fx9cXFxeHp64urqykMPPcSiRYuIiIhQTuzAvHnz2LVrFzNmzLjgPuXHdvr27ctnn33GypUrmTVrFgkJCfTv35/c3FzlxYaOHz/OrFmzaNu2LT/88AMPP/wwjz/+OHPmzAG0DmgotCavH/TzaB+0JrcvWpPbL63J7ZPW5PbJHtfkTlflWUVE6sD06dPZt29fhXllYjvt27cnNjaW7OxsFi5cyJQpU1i/fr2tw2rwEhMTeeKJJ4iOjsbNzc3W4civjBo1yvp5165d6du3L82bN2f+/Pm4u7vbMLKGzWw206tXL/7xj38AEBkZyb59+/jggw+YMmWKjaMTEbE/WpPbF63J7ZPW5PZLa3L7ZI9rcnWi2xk/Pz8cHR0v2Ok3LS2NZs2a2Sgq+bXyPChHtvXoo4+ybNky1q5dS2hoqPX2Zs2aUVxczLlz5yocr/xcfS4uLrRp04aePXsyY8YMunXrxjvvvKOc2FhMTAzp6en06NEDJycnnJycWL9+Pe+++y5OTk4EBgYqP3aicePGtGvXjqNHj+rnxoaCgoKIiIiocFvHjh2tl/VqHdAwaE1eP+jn0fa0Jrc/WpPbJ63J6w+tye2DPa7JVUS3My4uLvTs2ZPVq1dbbzObzaxevZqoqCgbRiblWrZsSbNmzSrkKCcnh23btilHdcAwDB599FEWLVrEmjVraNmyZYX7e/bsibOzc4X8xMfHc+rUKeWnjpnNZoqKipQTGxsyZAhxcXHExsZaP3r16sXkyZOtnys/9iEvL49jx44RFBSknxsb6tevH/Hx8RVuO3z4MM2bNwe0DmgotCavH/TzaDtak9cfWpPbB63J6w+tye2DXa7Jr8p2pXJF5s2bZ7i6uhqfffaZceDAAeOBBx4wGjdubKSmpto6tAYjNzfX2L17t7F7924DMN5++21j9+7dxsmTJw3DMIzXXnvNaNy4sfHdd98Ze/fuNcaNG2e0bNnSOH/+vI0jv/Y9/PDDho+Pj7Fu3TojJSXF+lFQUGA95qGHHjLCw8ONNWvWGDt37jSioqKMqKgoG0Z97XvuueeM9evXGwkJCcbevXuN5557zjCZTMaqVasMw1BO7M3AgQONJ554wvq18mMbf/jDH4x169YZCQkJxqZNm4yhQ4cafn5+Rnp6umEYyoutbN++3XBycjL+/ve/G0eOHDG+/PJLw8PDw/jiiy+sx2gd0DBoTW4ftC63T1qT2yetyesXrcntg9bk9ske1+Qqotup9957zwgPDzdcXFyMPn36GFu3brV1SA3K2rVrDeCCjylTphiGYRhms9l48cUXjcDAQMPV1dUYMmSIER8fb9ugG4iL5QUwZs+ebT3m/PnzxiOPPGI0adLE8PDwMG655RYjJSXFdkE3APfdd5/RvHlzw8XFxfD39zeGDBliXawbhnJib367YFd+bOP22283goKCDBcXFyMkJMS4/fbbjaNHj1rvV15sZ+nSpUbnzp0NV1dXo0OHDsZHH31U4X6tAxoOrcltT+ty+6Q1uX3Smrx+0ZrcPmhNbr/sbU1uMgzDuDo97iIiIiIiIiIiIiIi9ZtmoouIiIiIiIiIiIiIVEJFdBERERERERERERGRSqiILiIiIiIiIiIiIiJSCRXRRUREREREREREREQqoSK6iIiIiIiIiIiIiEglVEQXEREREREREREREamEiugiIiIiIiIiIiIiIpVQEV1EREREREREREREpBIqoouIiM2ZTCYWL15s6zBERERERBosrclFRCqnIrqISAM3depUTCbTBR8jR460dWgiIiIiIg2C1uQiIvbNydYBiIiI7Y0cOZLZs2dXuM3V1dVG0YiIiIiINDxak4uI2C91oouICK6urjRr1qzCR5MmTQDLZZ2zZs1i1KhRuLu706pVKxYuXFjh8XFxcQwePBh3d3eaNm3KAw88QF5eXoVjPv30Uzp16oSrqytBQUE8+uijFe7PzMzklltuwcPDg7Zt27JkyZKr+6JFREREROyI1uQiIvZLRXQREbmsF198kVtvvZU9e/YwefJk7rjjDg4ePAhAfn4+I0aMoEmTJuzYsYMFCxbw448/VliQz5o1i+nTp/PAAw8QFxfHkiVLaNOmTYVzvPrqq9x2223s3buX0aNHM3nyZM6ePVunr1NERERExF5pTS4iYjsmwzAMWwchIiK2M3XqVL744gvc3Nwq3P7CCy/wwgsvYDKZeOihh5g1a5b1vuuuu44ePXrw/vvv8/HHH/OnP/2JxMREGjVqBMDy5csZO3YsycnJBAYGEhISwr333svf/va3i8ZgMpn4y1/+wl//+lfA8kuAp6cnK1as0BxIEREREbnmaU0uImLfNBNdRES48cYbKyzIAXx9fa2fR0VFVbgvKiqK2NhYAA4ePEi3bt2si3WAfv36YTabiY+Px2QykZyczJAhQy4ZQ9euXa2fN2rUCG9vb9LT02v6kkRERERE6hWtyUVE7JeK6CIiQqNGjS64lLO2uLu7V+k4Z2fnCl+bTCbMZvPVCElERERExO5oTS4iYr80E11ERC5r69atF3zdsWNHADp27MiePXvIz8+33r9p0yYcHBxo3749Xl5etGjRgtWrV9dpzCIiIiIi1xKtyUVEbEed6CIiQlFREampqRVuc3Jyws/PD4AFCxbQq1cvbrjhBr788ku2b9/OJ598AsDkyZN5+eWXmTJlCq+88goZGRk89thj3H333QQGBgLwyiuv8NBDDxEQEMCoUaPIzc1l06ZNPPbYY3X7QkVERERE7JTW5CIi9ktFdBERYeXKlQQFBVW4rX379hw6dAiAV199lXnz5vHII48QFBTEV199RUREBAAeHh788MMPPPHEE/Tu3RsPDw9uvfVW3n77betzTZkyhcLCQv71r3/xzDPP4Ofnx4QJE+ruBYqIiIiI2DmtyUVE7JfJMAzD1kGIiIj9MplMLFq0iJtvvtnWoYiIiIiINEhak4uI2JZmoouIiIiIiIiIiIiIVEJFdBERERERERERERGRSmici4iIiIiIiIiIiIhIJdSJLiIiIiIiIiIiIiJSCRXRRUREREREREREREQqoSK6iIiIiIiIiIiIiEglVEQXEREREREREREREamEiugiIiIiIiIiIiIiIpVQEV1EREREREREREREpBIqoouIiIiIiIiIiIiIVEJFdBERERERERERERGRSqiILiIiIiIiIiIiIiJSif8He2FHFxOfznEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "device = get_device()\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Load and prepare data\n",
    "train_data = pd.read_csv('./training_data.csv')\n",
    "test_data = pd.read_csv('./test_data.csv')\n",
    "\n",
    "X_train = torch.FloatTensor(train_data.drop('label', axis=1).values)\n",
    "y_train = torch.FloatTensor(train_data['label'].values).reshape(-1, 1)\n",
    "X_test = torch.FloatTensor(test_data.drop('label', axis=1).values)\n",
    "y_test = torch.FloatTensor(test_data['label'].values).reshape(-1, 1)\n",
    "\n",
    "# Train model with improvements\n",
    "trainer = train_model(\n",
    "    X_train, y_train,\n",
    "    X_test, y_test,\n",
    "    # save_path='./improved_training_plots/',\n",
    "    batch_size=64\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Analyzing the Model\n",
    "How did it do? Use the explanations below to evaluate how the model did.\n",
    "\n",
    "1. Training and Validation Loss: This plot shows the training loss (blue) and validation loss (red). Training loss is a measurement of how well the model is fitting to the training data while validation loss is the error when fitting to unseen data. Should see them both drasticly be reduced and converge!\n",
    "\n",
    "2. Traing and Validation Accuracy: This plot shows how accurate the model is on the training and validation accuracy. Should be inversely correlated with loss.\n",
    "\n",
    "3. Learning Rate Schedule: This plot shows the learning rate of the model. The reason for the jumps is a \"restart\" initialized by \"CosineAnnealingWarmRestarts\". What this does is help to escape local minima by restarting the learning rate except we are keeping the model's learned parameters. In short, this helps to get around stalls in learning from suboptimal solutions.\n",
    "\n",
    "4. Epoch Training Time: This plot shows how long each epoch takes to train before entering the next monitoring efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Feature importance and SHAP values\n",
    "Let's try to explain how our model makes decitions. This section of the notebook demonstrates how to use SHAP (SHapley Additive exPlanations) to interpret neural network decisions. We'll analyze a binary classification model that distinguishes between dorsal and ventral neurons based on their firing patterns and waveform characteristics. \n",
    "\n",
    "Think of each SHAP value as telling us how much each feature (like firing rate or burst index) pushes the model's decision toward one type of neuron or the other. For example, SHAP might tell us that a high firing rate strongly pushes the model toward classifying a neuron as dorsal, while a particular waveform shape pushes it toward ventral. We then create various visualizations - like waterfall plots that show how features stack up to reach a final decision, and summary plots that show which features are most important overall - to help us understand and explain the model's decision-making process in an intuitive way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The BinaryShapAnalyzer class handles all aspects of SHAP analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BinaryShapAnalyzer:\n",
    "    def __init__(self, model, background_data, feature_names=None, device='cpu', \n",
    "                 class_names=['Dorsal', 'Ventral'], n_background_samples=100):\n",
    "        \"\"\"\n",
    "        Initialize the SHAP analyzer for binary classification.\n",
    "        \n",
    "        Parameters:\n",
    "        -----------\n",
    "        model : torch.nn.Module\n",
    "            The trained PyTorch model\n",
    "        background_data : numpy.ndarray\n",
    "            Full background dataset\n",
    "        feature_names : list, optional\n",
    "            Names of the features\n",
    "        device : str, default='cpu'\n",
    "            Device to run the model on ('cpu' or 'cuda')\n",
    "        class_names : list, default=['Dorsal', 'Ventral']\n",
    "            Names of the classes\n",
    "        n_background_samples : int, default=100\n",
    "            Number of background samples to use for SHAP analysis\n",
    "        \"\"\"\n",
    "        self.model = model.to(device)\n",
    "        self.model.eval()\n",
    "        self.device = device\n",
    "        self.class_names = class_names\n",
    "        self.n_background_samples = n_background_samples\n",
    "        \n",
    "        # Randomly sample background data if needed\n",
    "        if len(background_data) > n_background_samples:\n",
    "            indices = np.random.choice(len(background_data), n_background_samples, replace=False)\n",
    "            background_data = background_data[indices]\n",
    "            \n",
    "        if feature_names is None:\n",
    "            self.feature_names = np.array([f'static_{i+1}' for i in range(5)] + ['waveform'])\n",
    "        else:\n",
    "            self.feature_names = np.array(feature_names)\n",
    "            \n",
    "        self.background_data = self.collapse_waveform(background_data)\n",
    "        print(f\"Initialized analyzer with:\")\n",
    "        print(f\"- Background data shape: {self.background_data.shape}\")\n",
    "        print(f\"- Number of features: {len(self.feature_names)}\")\n",
    "        print(f\"- Number of background samples: {n_background_samples}\")\n",
    "    \n",
    "    def collapse_waveform(self, X):\n",
    "        \"\"\"Collapse waveform into a single feature.\"\"\"\n",
    "        print(f\"Collapsing data of shape: {X.shape}\")\n",
    "        static_features = X[:, :5].astype(np.float32)\n",
    "        waveform = X[:, 5:].astype(np.float32)\n",
    "        waveform_mean = np.mean(waveform, axis=1, keepdims=True).astype(np.float32)\n",
    "        collapsed = np.hstack([static_features, waveform_mean])\n",
    "        print(f\"Collapsed shape: {collapsed.shape}\")\n",
    "        return collapsed\n",
    "    \n",
    "    def predict(self, X_collapsed):\n",
    "        \"\"\"Model prediction wrapper that returns probabilities for both classes.\"\"\"\n",
    "        X_collapsed = np.array(X_collapsed, dtype=np.float32)\n",
    "        batch_size = X_collapsed.shape[0]\n",
    "        \n",
    "        X_full = np.zeros((batch_size, 105), dtype=np.float32)\n",
    "        X_full[:, :5] = X_collapsed[:, :5]\n",
    "        X_full[:, 5:] = np.repeat(X_collapsed[:, -1:], 100, axis=1)\n",
    "        \n",
    "        # Process in batches to handle large datasets\n",
    "        batch_size = 128\n",
    "        n_batches = (len(X_full) + batch_size - 1) // batch_size\n",
    "        all_probs = []\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            for i in range(n_batches):\n",
    "                start_idx = i * batch_size\n",
    "                end_idx = min((i + 1) * batch_size, len(X_full))\n",
    "                batch = torch.FloatTensor(X_full[start_idx:end_idx]).to(self.device)\n",
    "                probs = self.model(batch).cpu().numpy()\n",
    "                all_probs.append(probs)\n",
    "        \n",
    "        probs = np.concatenate(all_probs)\n",
    "        probs = np.squeeze(probs)\n",
    "        return np.vstack((1 - probs, probs)).T\n",
    "    \n",
    "    def compute_shap_values(self, X, n_samples=100):\n",
    "        \"\"\"\n",
    "        Compute SHAP values for both classes.\n",
    "        \n",
    "        Parameters:\n",
    "        -----------\n",
    "        X : numpy.ndarray\n",
    "            Input data\n",
    "        n_samples : int, default=100\n",
    "            Number of samples to use for SHAP analysis\n",
    "        \"\"\"\n",
    "        print(\"\\nComputing SHAP values...\")\n",
    "        print(f\"Using {n_samples} samples for SHAP analysis\")\n",
    "        \n",
    "        # Randomly sample data if needed\n",
    "        if len(X) > n_samples:\n",
    "            indices = np.random.choice(len(X), n_samples, replace=False)\n",
    "            X = X[indices]\n",
    "        \n",
    "        X_collapsed = self.collapse_waveform(X)\n",
    "        \n",
    "        explainer = shap.KernelExplainer(\n",
    "            self.predict,\n",
    "            self.background_data,\n",
    "            n_samples=min(n_samples * 2, 1000)  # Scale with input size\n",
    "        )\n",
    "        \n",
    "        # Use progress bar for SHAP computation\n",
    "        with tqdm(total=1, desc=\"Computing SHAP values\") as pbar:\n",
    "            shap_values = explainer.shap_values(\n",
    "                X_collapsed,\n",
    "                nsamples=min(n_samples * 10, 1000),  # Scale with input size\n",
    "                l1_reg=\"num_features(10)\"  # Regularization to handle many features\n",
    "            )\n",
    "            pbar.update(1)\n",
    "        \n",
    "        # Print shapes for debugging\n",
    "        if isinstance(shap_values, list):\n",
    "            print(\"\\nSHAP values shapes:\")\n",
    "            for i, sv in enumerate(shap_values):\n",
    "                print(f\"Class {self.class_names[i]}: {sv.shape}\")\n",
    "        \n",
    "        return shap_values, X_collapsed\n",
    "    \n",
    "    def plot_summary(self, shap_values, features, max_display=20):\n",
    "        \"\"\"Create SHAP summary plots for both classes with configurable display.\"\"\"\n",
    "        print(\"\\nCreating summary plots...\")\n",
    "        \n",
    "        for class_idx, class_name in enumerate(self.class_names):\n",
    "            sv = shap_values[:, :, class_idx]\n",
    "            \n",
    "            plt.figure(figsize=(12, 8))\n",
    "            shap.summary_plot(\n",
    "                sv,\n",
    "                features,\n",
    "                feature_names=self.feature_names,\n",
    "                max_display=max_display,\n",
    "                show=False,\n",
    "                plot_size=(12, 8),\n",
    "                title=f'Impact on {class_name} Prediction'\n",
    "            )\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(f'shap_summary_violin_{class_name.lower()}.png', dpi=300, bbox_inches='tight')\n",
    "            plt.close()\n",
    "            \n",
    "            plt.figure(figsize=(12, 8))\n",
    "            shap.summary_plot(\n",
    "                sv,\n",
    "                features,\n",
    "                feature_names=self.feature_names,\n",
    "                max_display=max_display,\n",
    "                plot_type=\"bar\",\n",
    "                show=False,\n",
    "                plot_size=(12, 8),\n",
    "                title=f'Feature Importance for {class_name}'\n",
    "            )\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(f'shap_summary_bar_{class_name.lower()}.png', dpi=300, bbox_inches='tight')\n",
    "            plt.close()\n",
    "\n",
    "    def create_waterfall_plots(self, shap_values, features, n_examples=5):\n",
    "        \"\"\"\n",
    "        Create waterfall plots using SHAP's built-in waterfall plot function.\n",
    "        Shows how each feature contributes to pushing the model output from the base value\n",
    "        to the final prediction.\n",
    "    \n",
    "        Parameters:\n",
    "        -----------\n",
    "        shap_values : numpy.ndarray\n",
    "            SHAP values array of shape (n_samples, n_features, n_classes)\n",
    "        features : numpy.ndarray\n",
    "            Feature values array\n",
    "        n_examples : int, default=5\n",
    "            Number of example predictions to plot for each class\n",
    "        \"\"\"\n",
    "        print(\"\\nCreating waterfall plots...\")\n",
    "    \n",
    "        # For each class\n",
    "        for class_idx, class_name in enumerate(self.class_names):\n",
    "            print(f\"\\nGenerating waterfall plots for {class_name} class...\")\n",
    "        \n",
    "            # Create directory for waterfall plots\n",
    "            output_dir = Path(f'waterfall_plots_{class_name.lower()}')\n",
    "            output_dir.mkdir(exist_ok=True)\n",
    "        \n",
    "            # Generate plots for n_examples\n",
    "            for i in range(min(n_examples, len(features))):\n",
    "                try:\n",
    "                    # Create an Explanation object expected by the waterfall plot\n",
    "                    exp = shap.Explanation(\n",
    "                        values=shap_values[i, :, class_idx],\n",
    "                        base_values=np.mean(shap_values[:, :, class_idx]),\n",
    "                        data=features[i],\n",
    "                        feature_names=self.feature_names\n",
    "                    )\n",
    "                \n",
    "                    # Create the plot\n",
    "                    plt.figure(figsize=(12, 6))\n",
    "                    shap.waterfall_plot(exp, show=False)\n",
    "                \n",
    "                    # Add title\n",
    "                    plt.title(f'{class_name} Prediction Explanation - Example {i+1}')\n",
    "                \n",
    "                    # Save the plot\n",
    "                    plt.tight_layout()\n",
    "                    plt.savefig(\n",
    "                        output_dir / f'waterfall_plot_example_{i+1}.png',\n",
    "                        dpi=300,\n",
    "                        bbox_inches='tight'\n",
    "                    )\n",
    "                    plt.close()\n",
    "                \n",
    "                except Exception as e:\n",
    "                    print(f\"Error creating waterfall plot for example {i+1}: {str(e)}\")\n",
    "                    continue\n",
    "            \n",
    "            print(f\"Saved {n_examples} waterfall plots for {class_name} class\")\n",
    "            \n",
    "    \n",
    "            \n",
    "    def create_force_plot(self, shap_values, features, max_samples=100):\n",
    "        \"\"\"\n",
    "        Create stacked force plots showing SHAP values across multiple samples.\n",
    "        \n",
    "        Parameters:\n",
    "        -----------\n",
    "        shap_values : numpy.ndarray\n",
    "            SHAP values array of shape (n_samples, n_features, n_classes)\n",
    "        features : numpy.ndarray\n",
    "            Feature values array\n",
    "        max_samples : int, default=100\n",
    "            Maximum number of samples to include in the force plot\n",
    "        \"\"\"\n",
    "        print(\"\\nCreating stacked force plots...\")\n",
    "        n_samples = min(max_samples, len(features))\n",
    "        \n",
    "        # For each class\n",
    "        for class_idx, class_name in enumerate(self.class_names):\n",
    "            # Take the appropriate slice for this class\n",
    "            sv = shap_values[:n_samples, :, class_idx]\n",
    "            expected_value = float(np.mean(sv))\n",
    "            \n",
    "            print(f\"\\nForce plot dimensions for {class_name}:\")\n",
    "            print(f\"SHAP values shape: {sv.shape}\")\n",
    "            print(f\"Features shape: {features[:n_samples].shape}\")\n",
    "            \n",
    "            try:\n",
    "                # Create single sample plots\n",
    "                for i in range(min(5, n_samples)):  # Show first 5 samples\n",
    "                    plt.figure(figsize=(15, 3))\n",
    "                    shap.force_plot(\n",
    "                        expected_value,\n",
    "                        sv[i:i+1],  # Single sample\n",
    "                        features[i:i+1],\n",
    "                        feature_names=list(self.feature_names),\n",
    "                        show=False,\n",
    "                        matplotlib=True\n",
    "                    )\n",
    "                    plt.title(f'{class_name} Force Plot - Sample {i+1}')\n",
    "                    plt.tight_layout()\n",
    "                    plt.savefig(f'shap_force_plot_{class_name.lower()}_sample_{i+1}.png', \n",
    "                              dpi=300, \n",
    "                              bbox_inches='tight')\n",
    "                    plt.close()\n",
    "                \n",
    "                # Create and save HTML version with all samples\n",
    "                force_plot = shap.force_plot(\n",
    "                    expected_value,\n",
    "                    sv,\n",
    "                    features[:n_samples],\n",
    "                    feature_names=list(self.feature_names),\n",
    "                    show=False\n",
    "                )\n",
    "                \n",
    "                shap.save_html(\n",
    "                    f'shap_force_plot_{class_name.lower()}_all.html',\n",
    "                    force_plot\n",
    "                )\n",
    "                \n",
    "                print(f\"Saved force plots for {class_name}\")\n",
    "                \n",
    "            except Exception as e:\n",
    "                print(f\"Error creating force plot for {class_name}: {str(e)}\")\n",
    "                print(f\"Shapes - SHAP values: {sv.shape}, Features: {features[:n_samples].shape}\")\n",
    "\n",
    "    def plot_feature_importances(self, shap_values, features):\n",
    "        \"\"\"\n",
    "        Plot and compare feature importances for both classes.\n",
    "        \n",
    "        Parameters:\n",
    "        -----------\n",
    "        shap_values : numpy.ndarray\n",
    "            SHAP values array of shape (n_samples, n_features, n_classes)\n",
    "        features : numpy.ndarray\n",
    "            Feature values array\n",
    "        \n",
    "        Returns:\n",
    "        --------\n",
    "        pandas.DataFrame\n",
    "            DataFrame containing feature importance values for each class\n",
    "        \"\"\"\n",
    "        print(\"\\nCreating feature importance plots...\")\n",
    "        \n",
    "        # Calculate mean absolute SHAP values for each class\n",
    "        mean_abs_shap = []\n",
    "        for class_idx in range(2):\n",
    "            class_shap = shap_values[:, :, class_idx]\n",
    "            mean_abs_shap.append(np.abs(class_shap).mean(axis=0))\n",
    "        \n",
    "        # Create DataFrame for plotting\n",
    "        importance_data = []\n",
    "        for i, abs_shap in enumerate(mean_abs_shap):\n",
    "            for feat_idx, feat_name in enumerate(self.feature_names):\n",
    "                importance_data.append({\n",
    "                    'Feature': feat_name,\n",
    "                    'Importance': abs_shap[feat_idx],\n",
    "                    'Class': self.class_names[i]\n",
    "                })\n",
    "        \n",
    "        importance_df = pd.DataFrame(importance_data)\n",
    "        \n",
    "        # Create comparison plot\n",
    "        plt.figure(figsize=(12, 6))\n",
    "        sns.barplot(\n",
    "            data=importance_df,\n",
    "            x='Feature',\n",
    "            y='Importance',\n",
    "            hue='Class',\n",
    "            palette=['#2ecc71', '#e74c3c']  # Green for Dorsal, Red for Ventral\n",
    "        )\n",
    "        plt.xticks(rotation=45, ha='right')\n",
    "        plt.title('Feature Importance Comparison by Class')\n",
    "        plt.tight_layout()\n",
    "        plt.savefig('feature_importance_by_class.png', dpi=300, bbox_inches='tight')\n",
    "        plt.close()\n",
    "        \n",
    "        # Create individual class plots\n",
    "        for class_name in self.class_names:\n",
    "            plt.figure(figsize=(10, 5))\n",
    "            class_data = importance_df[importance_df['Class'] == class_name]\n",
    "            sns.barplot(\n",
    "                data=class_data,\n",
    "                x='Feature',\n",
    "                y='Importance',\n",
    "                color='#2ecc71' if class_name == 'Dorsal' else '#e74c3c'\n",
    "            )\n",
    "            plt.xticks(rotation=45, ha='right')\n",
    "            plt.title(f'Feature Importance - {class_name}')\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(f'feature_importance_{class_name.lower()}.png', dpi=300, bbox_inches='tight')\n",
    "            plt.close()\n",
    "        \n",
    "        return importance_df\n",
    "    def analyze(self, X, n_samples=100, max_display=20, n_waterfall_examples=5):\n",
    "        \"\"\"\n",
    "        Run complete SHAP analysis pipeline.\n",
    "    \n",
    "        Parameters:\n",
    "        -----------\n",
    "            X : numpy.ndarray\n",
    "            Input data\n",
    "        n_samples : int, default=100\n",
    "            Number of samples to use for SHAP analysis\n",
    "        max_display : int, default=20\n",
    "            Maximum number of features to display in summary plots\n",
    "        n_waterfall_examples : int, default=5\n",
    "            Number of examples to use for waterfall plots\n",
    "        \"\"\"\n",
    "        print(f\"\\nStarting analysis with:\")\n",
    "        print(f\"- Input data shape: {X.shape}\")\n",
    "        print(f\"- Number of samples: {n_samples}\")\n",
    "        print(f\"- Maximum features to display: {max_display}\")\n",
    "        print(f\"- Number of waterfall examples: {n_waterfall_examples}\")\n",
    "    \n",
    "        shap_values, features = self.compute_shap_values(X, n_samples)\n",
    "    \n",
    "        try:\n",
    "            # Generate plots\n",
    "            self.plot_summary(shap_values, features, max_display)\n",
    "            print(\"Created summary plots\")\n",
    "        \n",
    "            self.create_force_plot(shap_values, features, max_samples=min(100, n_samples))\n",
    "            print(\"Created force plots\")\n",
    "        \n",
    "            importance_df = self.plot_feature_importances(shap_values, features)\n",
    "            print(\"Created feature importance comparison plot\")\n",
    "        \n",
    "            self.create_waterfall_plots(shap_values, features, n_examples=n_waterfall_examples)\n",
    "            print(\"Created waterfall plots\")\n",
    "        \n",
    "            return shap_values, importance_df\n",
    "        \n",
    "        except Exception as e:\n",
    "            print(\"\\nError occurred during plotting:\")\n",
    "            print(f\"- Exception: {str(e)}\")\n",
    "            print(f\"- Features shape: {features.shape}\")\n",
    "            print(f\"- Feature names: {self.feature_names}\")\n",
    "            if isinstance(shap_values, list):\n",
    "                for i, sv in enumerate(shap_values):\n",
    "                    print(f\"- SHAP values shape for {self.class_names[i]}: {sv.shape}\")\n",
    "            else:\n",
    "                print(f\"- SHAP values shape: {shap_values.shape}\")\n",
    "            raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the main cell to compute your SHAPs and generate a bunch of cool plots. Here's what each of these plots actually tell you:\n",
    "\n",
    "1. Summary Plots show the overall impact of each feature on model predictions.\n",
    "\n",
    "2. Violin plots show the distribution of SHAP values\n",
    "3. Bar plots show the average magnitude of feature importance\n",
    "4. Force plots demonstrate how each feature pushes the prediction toward or away from each class.\n",
    "5. Waterfall plots show how features contribute to individual predictions, starting from the base value.\n",
    "6. The feature importance comparison shows how different features contribute to each class prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n",
      "Loading data...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using 200 background data samples could cause slower run times. Consider using shap.sample(data, K) or shap.kmeans(data, K) to summarize the background as K samples.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading trained model...\n",
      "Collapsing data of shape: (200, 105)\n",
      "Collapsed shape: (200, 6)\n",
      "Initialized analyzer with:\n",
      "- Background data shape: (200, 6)\n",
      "- Number of features: 6\n",
      "- Number of background samples: 200\n",
      "\n",
      "Starting analysis with:\n",
      "- Input data shape: (300, 105)\n",
      "- Number of samples: 500\n",
      "- Maximum features to display: 20\n",
      "- Number of waterfall examples: 5\n",
      "\n",
      "Computing SHAP values...\n",
      "Using 500 samples for SHAP analysis\n",
      "Collapsing data of shape: (300, 105)\n",
      "Collapsed shape: (300, 6)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 300/300 [09:30<00:00,  1.90s/it]0<?, ?it/s]\n",
      "Computing SHAP values: 100%|██████████| 1/1 [09:30<00:00, 570.80s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Creating summary plots...\n",
      "Created summary plots\n",
      "\n",
      "Creating stacked force plots...\n",
      "\n",
      "Force plot dimensions for Dorsal:\n",
      "SHAP values shape: (100, 6)\n",
      "Features shape: (100, 6)\n",
      "Saved force plots for Dorsal\n",
      "\n",
      "Force plot dimensions for Ventral:\n",
      "SHAP values shape: (100, 6)\n",
      "Features shape: (100, 6)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/daniel/miniconda3/envs/genephys2/lib/python3.12/site-packages/shap/plots/_force_matplotlib.py:347: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  fig, ax = plt.subplots(figsize=figsize)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved force plots for Ventral\n",
      "Created force plots\n",
      "\n",
      "Creating feature importance plots...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:322: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:338: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(10, 5))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:338: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(10, 5))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created feature importance comparison plot\n",
      "\n",
      "Creating waterfall plots...\n",
      "\n",
      "Generating waterfall plots for Dorsal class...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved 5 waterfall plots for Dorsal class\n",
      "\n",
      "Generating waterfall plots for Ventral class...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n",
      "/var/folders/h4/4tmspc0j5jj75v6h6j83r1hc0000gn/T/ipykernel_84011/3839530540.py:197: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
      "  plt.figure(figsize=(12, 6))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved 5 waterfall plots for Ventral class\n",
      "Created waterfall plots\n",
      "\n",
      "Analysis complete! Plots have been saved as:\n",
      "- shap_summary_violin_dorsal.png\n",
      "- shap_summary_violin_ventral.png\n",
      "- shap_summary_bar_dorsal.png\n",
      "- shap_summary_bar_ventral.png\n",
      "- shap_force_plot_dorsal.png\n",
      "- shap_force_plot_ventral.png\n",
      "- feature_importance_by_class.png\n",
      "- waterfall_plots_dorsal/ (5 examples)\n",
      "- waterfall_plots_ventral/ (5 examples)\n",
      "Initial data shapes:\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    # Set device\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    print(f\"Using device: {device}\")\n",
    "    \n",
    "    # Load data\n",
    "    print(\"Loading data...\")\n",
    "    train_data = pd.read_csv('./training_data.csv')\n",
    "    test_data = pd.read_csv('./test_data.csv')\n",
    "    \n",
    "    X_train = train_data.drop('label', axis=1).values\n",
    "    X_test = test_data.drop('label', axis=1).values\n",
    "    \n",
    "    # Load model\n",
    "    print(\"Loading trained model...\")\n",
    "    model = PredictModel()  # Make sure this is defined\n",
    "    checkpoint = torch.load('best_model.pth', map_location=device)\n",
    "    model.load_state_dict(checkpoint['model_state_dict'])\n",
    "    model.eval()\n",
    "    \n",
    "    # Prepare background data\n",
    "    n_background = 200  # Configurable\n",
    "    background_indices = np.random.choice(len(X_train), n_background, replace=False)\n",
    "    background_data = X_train[background_indices]\n",
    "    \n",
    "    # Prepare test samples\n",
    "    n_test_samples = 300  # Configurable\n",
    "    test_indices = np.random.choice(len(X_test), n_test_samples, replace=False)\n",
    "    test_samples = X_test[test_indices]\n",
    "    \n",
    "    # Initialize analyzer\n",
    "    feature_names = [\n",
    "        'Firing Rate',\n",
    "        'STTC',\n",
    "        'Through_to_Peak',\n",
    "        'FWHM',\n",
    "        'Amplitude',\n",
    "        'Waveform'\n",
    "    ]\n",
    "    \n",
    "    analyzer = BinaryShapAnalyzer(\n",
    "        model,\n",
    "        background_data,\n",
    "        feature_names=feature_names,\n",
    "        device=device,\n",
    "        class_names=['Dorsal', 'Ventral'],\n",
    "        n_background_samples=200  # Configurable\n",
    "    )\n",
    "    \n",
    "    # Run analysis with desired number of samples\n",
    "    shap_values, importance_df = analyzer.analyze(\n",
    "        test_samples, \n",
    "        n_samples=500,  # Configurable\n",
    "        max_display=20,  # Configurable\n",
    "        n_waterfall_examples=5  # Configurable\n",
    "    )\n",
    "    \n",
    "    print(\"\\nAnalysis complete! Plots have been saved as:\")\n",
    "    print(\"- shap_summary_violin_dorsal.png\")\n",
    "    print(\"- shap_summary_violin_ventral.png\")\n",
    "    print(\"- shap_summary_bar_dorsal.png\")\n",
    "    print(\"- shap_summary_bar_ventral.png\")\n",
    "    print(\"- shap_force_plot_dorsal.png\")\n",
    "    print(\"- shap_force_plot_ventral.png\")\n",
    "    print(\"- feature_importance_by_class.png\")\n",
    "    print(\"- waterfall_plots_dorsal/ (5 examples)\")\n",
    "    print(\"- waterfall_plots_ventral/ (5 examples)\")\n",
    "    print(f\"Initial data shapes:\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "genephys2",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}