CNN_Torch_24.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "V28",
      "mount_file_id": "12jUwDXwtT7eKYVmfwfLDYlXcpZbv5ajP",
      "authorship_tag": "ABX9TyOvO7cjxkIELwFUdVga+LOX"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# IMPORT PACKAGES/LIBRARIES\n",
        "import torch\n",
        "import torch.optim as optim\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler, TensorDataset\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.transforms import Normalize\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import csv\n",
        "import os\n",
        "import math\n",
        "from sklearn.preprocessing import Normalizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn import metrics\n",
        "from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix,\n",
        "                             classification_report)\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from imblearn.over_sampling import SMOTE\n",
        "\n",
        "# Data Imports and Preprocess\n",
        "dir_list = os.listdir(NPY_FILEPATH)\n",
        "npy_arrays = [np.load(os.path.join(NPY_FILEPATH, each)) for each in dir_list]\n",
        "alls = np.concatenate(npy_arrays, axis=1)  # alls.shape  (3750, 63600)\n",
        "\n",
        "alls_df = pd.DataFrame(alls)\n",
        "labels_sorted = pd.read_csv(LABELS_SORTED_DF)\n",
        "labels_sorted.drop(columns=['ecg_id'], inplace=True)\n",
        "labels_sorted.set_index('Unnamed: 0', inplace=True)\n",
        "\n",
        "\n",
        "ALL_DATA = pd.concat([alls_df, labels_sorted], axis=1)\n",
        "print(f\"ALL_DATA shape: {ALL_DATA.shape}\")\n",
        "\n",
        "\n",
        "X = ALL_DATA.iloc[:, :-1].values  # Features\n",
        "y = ALL_DATA.iloc[:, -1].values   # Labels\n",
        "\n",
        "# Splitting & scaling\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.2)\n",
        "scaler = StandardScaler()\n",
        "X_train_scaled = scaler.fit_transform(X_train)\n",
        "X_test_scaled = scaler.transform(X_test)\n",
        "\n",
        "# Data-augmentation\n",
        "def augment_data(X):\n",
        "    noise = np.random.normal(0, 0.1, X.shape)\n",
        "    return X + noise\n",
        "\n",
        "X_train_augmented = augment_data(X_train_scaled)\n",
        "\n",
        "# Class Balancing\n",
        "smote = SMOTE()\n",
        "X_train_resampled, y_train_resampled = smote.fit_resample(X_train_augmented, y_train)\n",
        "\n",
        "# Reshaping\n",
        "X_train = X_train_resampled.reshape(-1, 5300, 12)\n",
        "X_test = X_test_scaled.reshape(-1, 5300, 12)\n",
        "y_train = y_train_resampled.reshape(-1, 1)\n",
        "y_test = y_test.reshape(-1, 1)\n",
        "\n",
        "# torch tensors\n",
        "X_train_tensor = torch.tensor(X_train, dtype=torch.float32)\n",
        "X_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n",
        "y_train_tensor = torch.tensor(y_train, dtype=torch.float32)\n",
        "y_test_tensor = torch.tensor(y_test, dtype=torch.float32)\n",
        "\n",
        "expected_features = 12 * 5300\n",
        "X_train_trimmed = X_train_tensor[:, :expected_features]\n",
        "X_test_trimmed = X_test_tensor[:, :expected_features]\n",
        "X_train_tensor = X_train_trimmed.view(-1, 12, 5300)\n",
        "X_test_tensor = X_test_trimmed.view(-1, 12, 5300)\n",
        "\n",
        "## my model\n",
        "class ECGCNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(ECGCNN, self).__init__()\n",
        "        self.conv1 = nn.Conv1d(in_channels=12, out_channels=64, kernel_size=5, stride=1, padding=2)\n",
        "        self.conv2 = nn.Conv1d(in_channels=64, out_channels=128, kernel_size=5, stride=1, padding=2)\n",
        "        self.conv3 = nn.Conv1d(in_channels=128, out_channels=256, kernel_size=5, stride=1, padding=2)\n",
        "\n",
        "        self.fc1 = nn.Linear(256 * (5300 // 8), 1024)\n",
        "        self.fc2 = nn.Linear(1024, 1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.conv1(x))\n",
        "        x = F.max_pool1d(x, kernel_size=2, stride=2)\n",
        "        x = F.relu(self.conv2(x))\n",
        "        x = F.max_pool1d(x, kernel_size=2, stride=2)\n",
        "        x = F.relu(self.conv3(x))\n",
        "        x = F.max_pool1d(x, kernel_size=2, stride=2)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x\n",
        "\n",
        "# Init. model\n",
        "model_cnn = ECGCNN()\n",
        "\n",
        "#TensorDataset\n",
        "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
        "test_dataset = TensorDataset(X_test_tensor, y_test_tensor)\n",
        "\n",
        "#DataLoader\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n",
        "\n",
        "# loss fnc. and opt.\n",
        "criterion = nn.BCEWithLogitsLoss()  # Binary Cross Entropy with Logits\n",
        "optimizer = optim.Adam(model_cnn.parameters(), lr=0.001)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ko2bmfLGByPR",
        "outputId": "658d6bd6-4815-4577-c554-583fc93a1666"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ALL_DATA shape: (3750, 63601)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# needed for later plotting\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "train_accuracies = []\n",
        "val_accuracies = []\n",
        "auroc_scores = []\n",
        "\n",
        "## Training loop\n",
        "def train_model(model, train_loader, criterion, optimizer, num_epochs=10):\n",
        "    model.train()\n",
        "    for epoch in range(num_epochs):\n",
        "        epoch_loss = 0\n",
        "        all_preds = []\n",
        "        all_labels = []\n",
        "        for inputs, labels in train_loader:\n",
        "            optimizer.zero_grad()\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            epoch_loss += loss.item()\n",
        "            preds = torch.sigmoid(outputs.squeeze()).round().detach()\n",
        "            all_preds.extend(preds.cpu().numpy())\n",
        "            all_labels.extend(labels.cpu().numpy())\n",
        "        train_loss = epoch_loss / len(train_loader)\n",
        "        train_accuracy = accuracy_score(all_labels, all_preds)\n",
        "        # AUROC score\n",
        "        all_preds_proba = torch.sigmoid(torch.tensor(all_preds)).cpu().numpy()\n",
        "        auroc_score = roc_auc_score(all_labels, all_preds_proba)\n",
        "        auroc_scores.append(auroc_score)\n",
        "\n",
        "        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {train_loss:.4f}, Accuracy: {train_accuracy:.4f}, AUROC: {auroc_score:.4f}')\n",
        "\n",
        "        train_losses.append(train_loss)\n",
        "        train_accuracies.append(train_accuracy)\n"
      ],
      "metadata": {
        "id": "KMFlALiKJnXG"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "## Eval. loop\n",
        "def evaluate_model(model, test_loader):\n",
        "    model.eval()\n",
        "    all_preds = []\n",
        "    all_labels = []\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in test_loader:\n",
        "            outputs = model(inputs)\n",
        "\n",
        "            preds = torch.sigmoid(outputs.squeeze()).round().detach()\n",
        "            all_preds.extend(preds.cpu().numpy())\n",
        "            all_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    test_accuracy = accuracy_score(all_labels, all_preds)\n",
        "    return test_accuracy\n"
      ],
      "metadata": {
        "id": "XndyNZ7zKJmj"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "## Model training\n",
        "train_model(model_cnn, train_loader, criterion, optimizer)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yCUkQZ6aKYAQ",
        "outputId": "aa5653e8-8c76-4b55-8946-d15f8a0a3ceb"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10, Loss: 0.5882, Accuracy: 0.6773, AUROC: 0.6773\n",
            "Epoch 2/10, Loss: 0.3240, Accuracy: 0.8542, AUROC: 0.8542\n",
            "Epoch 3/10, Loss: 0.1284, Accuracy: 0.9549, AUROC: 0.9549\n",
            "Epoch 4/10, Loss: 0.0588, Accuracy: 0.9800, AUROC: 0.9800\n",
            "Epoch 5/10, Loss: 0.0479, Accuracy: 0.9875, AUROC: 0.9875\n",
            "Epoch 6/10, Loss: 0.0562, Accuracy: 0.9833, AUROC: 0.9833\n",
            "Epoch 7/10, Loss: 0.0143, Accuracy: 0.9947, AUROC: 0.9947\n",
            "Epoch 8/10, Loss: 0.0092, Accuracy: 0.9985, AUROC: 0.9985\n",
            "Epoch 9/10, Loss: 0.0487, Accuracy: 0.9879, AUROC: 0.9879\n",
            "Epoch 10/10, Loss: 0.0317, Accuracy: 0.9917, AUROC: 0.9917\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "## Evaluating the model\n",
        "test_accuracy = evaluate_model(model_cnn, test_loader)\n",
        "print(f'Test Accuracy: {test_accuracy:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l1KwZahxNafk",
        "outputId": "9370fbb1-bee8-4df7-a7fe-2c1862830e8c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy: 0.8640\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_metrics():\n",
        "    epochs = range(1, len(train_losses) + 1)\n",
        "    plt.figure(figsize=(14, 6))\n",
        "\n",
        "    # Loss Plot\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.plot(epochs, train_losses, 'b', label='Training loss')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.title('Training Loss')\n",
        "    plt.legend()\n",
        "\n",
        "    # Accuracy Plot\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.plot(epochs, train_accuracies, 'g', label='Training Accuracy')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Accuracy')\n",
        "    plt.title('Training Accuracy')\n",
        "    plt.legend()\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "    # AUROC Plot\n",
        "    plt.figure(figsize=(7, 6))\n",
        "    plt.plot(epochs, auroc_scores, 'r', label='AUROC')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('AUROC')\n",
        "    plt.title('AUROC Score')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "plot_metrics()\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 991
        },
        "id": "O8PyOD8ANqQ8",
        "outputId": "f9c717fc-86c2-4b3d-86d3-5273c3bd962e"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 700x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAIjCAYAAAC6bpehAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUoUlEQVR4nO3dd3wVVf7/8fdNIBUSQEJCMBCQEmrokeIqS6S5UayAqIht8QsWouuCUmQVsSIWiu4vyLqCoGtdC4oRUBCIgNKrVJWEIuSGAAnJnd8fs/fCJYUEkswtr+fjMY9M5s7M/dxkl7w9Z845NsMwDAEAAMDjBVhdAAAAAMqG4AYAAOAlCG4AAABeguAGAADgJQhuAAAAXoLgBgAA4CUIbgAAAF6C4AYAAOAlCG4AAABeguAGAADgJQhuACw3Y8YM2Ww2JSUlFfv6nj17ZLPZ9OKLLxb7+osvviibzaY9e/a4jl111VWy2WyuLTQ0VO3atdO0adPkcDiKvc+RI0f0t7/9TS1atFBISIjq1Kmjvn376rPPPiuxdrvdrkmTJikxMVE1atRQaGio2rRpo7///e/6/fffz/vZN2zYoJtuukmNGjVSSEiIGjRooKuvvlqvvfbaea8F4H+qWV0AAMydO1fx8fHKyMjQzp071bRp0wq576WXXqopU6ZIkg4fPqx58+Zp9OjROnTokCZPnux27rZt29S7d28dOnRIw4cPV+fOnXXs2DHNnTtXKSkpevTRR/XCCy+4XbNr1y4lJydr3759uvnmm3XfffcpKChI69evV1pamj766CNt3769xPp++OEH9erVSw0bNtS9996rmJgY7d+/XytXrtQrr7yiBx54oEJ+DgB8iAEAFtq1a5chyfjwww+NqKgo48knnyxyzu7duw1JxgsvvFDsPV544QVDkrF7927XsSuvvNJo3bq123knT540GjVqZNSsWdMoKChwHc/PzzfatGljhIWFGStXrnS7pqCgwBg0aJAhyZg/f77r+OnTp43ExEQjLCzM+P7774vUlJ2dbTz++OOlfvYBAwYYUVFRxtGjR4u8lpWVVeq1FS03N7dK3w/AhaGrFICl5s6dq9q1a+uaa67RTTfdpLlz51bae4WEhKhLly7KycnRwYMHXcc/+OADbdy4UWPGjCnSXRsYGKg33nhDtWrV0pNPPul2zbp16/TEE0+oZ8+eRd4rIiKiSKveuX755Re1bt1atWrVKvJavXr1ihx755131LVrV4WFhal27dr605/+pK+//trtnBkzZqh169YKDg5WbGysRo4cqWPHjrmdc9VVV6lNmzZas2aN/vSnPyksLEyPP/64JCkvL08TJ05U06ZNFRwcrLi4OD322GPKy8sr9bMAqBoENwCWmjt3rm644QYFBQVpyJAh2rFjh3788cdKez/n83Jnh6X//ve/kqQ77rij2GsiIyN13XXXaevWrdq5c6ck6dNPP5Uk3X777RdcS6NGjbRmzRpt3LjxvOdOmjRJt99+u6pXr65//OMfmjRpkuLi4vTtt9+6znnyySc1cuRIxcbG6qWXXtKNN96oN954Q3369NHp06fd7nfkyBH1799f7du317Rp09SrVy85HA5de+21evHFF5WSkqLXXntNAwcO1Msvv6xBgwZd8OcEUHF4xg2AZdasWaOtW7e6HsTv2bOnLr30Us2dO1ddunS56PsXFhbq8OHDksygkpaWptWrV+uaa65RaGio67zNmzcrMjJSjRo1KvFeiYmJkqQtW7aoadOm2rJliyIjIxUXF3fB9T366KOu8NS1a1ddccUV6t27t3r16qXq1au7ztu5c6f+8Y9/6Prrr9d//vMfBQSc+W9uwzAkSYcOHdKUKVPUp08fffnll65zEhISNGrUKL3zzjsaPny467rMzEzNmjVLf/3rX13H3nnnHX3zzTdaunSpWytimzZtNGLECP3www/q3r37BX9eABePFjcAlpk7d66io6PVq1cvSZLNZtOgQYM0f/58FRYWXvT9t27dqqioKEVFRSkhIUEvvPCCrr32Ws2ZM8ftvJycHNWsWbPUezlft9vtrq/nu+Z8rr76aq1YsULXXnut1q1bp+eff159+/ZVgwYNXC16kvTxxx/L4XBowoQJbqFNMn9mkvTNN98oPz9fDz/8sNs59957ryIiIvT555+7XRccHOwW5CTp/fffV8uWLZWQkKDDhw+7tj//+c+SpMWLF1/U5wVw8QhuACxRWFio+fPnq1evXtq9e7d27typnTt3KikpSVlZWUpPTy/3PZ0hxik+Pl6LFi3SV199pRkzZqhBgwY6dOiQQkJC3M6rWbOmcnJySr2383VnWIuIiDjvNWXRpUsXffjhhzp69KgyMjI0duxY5eTk6KabbtLmzZslmc/CBQQEqFWrViXeZ+/evZKkFi1auB0PCgpSkyZNXK87NWjQQEFBQW7HduzYoU2bNrnCrnNr3ry5JLk9FwjAGnSVArDEt99+qwMHDmj+/PmaP39+kdfnzp2rPn36SJIraJ08ebLYe504ccLtPKfw8HAlJye7vu/Ro4c6duyoxx9/XK+++qrreMuWLfXzzz9r3759atiwYbHvsX79eklyhaeEhAT99NNP2r9//0V1lzoFBQWpS5cu6tKli5o3b67hw4fr/fff18SJEy/63sU5u6vYyeFwqG3btpo6dWqx11TE5wRwcWhxA2CJuXPnql69enr//feLbEOGDNFHH33kCmpRUVEKCwvTtm3bir3Xtm3bFBYWprp165b6nu3atdNtt92mN954Q/v27XMd/8tf/iJJevvtt4u9zm6365NPPlFCQoJrjrmUlBRJ5nNhFa1z586SpAMHDkiSLrvsMjkcDlcLXHGcz+ed+zPKz8/X7t27S31+z+myyy7TH3/8od69eys5ObnIdm5rHgALWD0fCQD/c+LECaNmzZrGXXfdVezry5cvLzJv2sCBA42IiAhj7969bufu3bvXqFmzpjFw4EC348XN42YYhrFp0ybDZrMZDz30kOtYXl6e0apVKyM8PNz48ccf3c4vLCw0br31VkOS8e6777qO5+fnG23btjXCw8ONH374ocj72O32887j9u233xoOh6PI8eeee86QZEydOtUwDMPYsWOHERAQYFx//fVGYWGh27nO6w8ePGgEBQUZ/fr1c7vnjBkzDEnG7NmzXcdK+tnMmTPHkGS88cYbRV47ceKEcfz48VI/D4DKZzOM/w1JAoAqsmDBAg0ePFgff/yxrrvuuiKvOxwOxcTE6PLLL3c9pL9lyxZdfvnlql69uu677z7Fx8drz549evPNN3X69GmtXLlSLVu2dN3jqquu0uHDh4udauMvf/mLlixZor179+qSSy5x3b937976448/3FZOmDdvntauXatHHnmkyJJbO3fuVHJysn777Tfdcsst6tGjh6pXr65NmzZp3rx5ql27domthJI5WvPEiRO6/vrrlZCQoPz8fP3www9asGCB4uLi9NNPP7mmLZkwYYKeeuopde/eXTfccIOCg4P1448/KjY21rU6xJNPPqlJkyapT58+uvbaa7Vt2zbNmDFDHTt21PLly10jVUv62TgcDqWkpOjLL7/UoEGD1KNHDxUWFmrr1q1677339NVXX7laAwFYxOrkCMD/pKSkGCEhIaXO1n/nnXca1atXNw4fPuw6tmXLFmPQoEFGvXr1jGrVqhn16tUzBg8ebGzZsqXI9SW1KhmGYSxZssSQZEycONHt+MGDB43U1FSjadOmRnBwsFGrVi0jOTnZ+PTTT0us8+jRo8aECROMtm3bGmFhYUZISIjRpk0bY+zYscaBAwdK/Tl8+eWXxl133WUkJCQYNWrUMIKCgoymTZsaDzzwQLErJ8yePdvo0KGDERwcbNSuXdu48sorjUWLFrmd8/rrrxsJCQlG9erVjejoaOP+++8vsjJDaT+b/Px847nnnjNat27tep9OnToZkyZNMrKzs0v9PAAqHy1uAAAAXoLBCQAAAF6C4AYAAOAlCG4AAABeguAGAADgJQhuAAAAXoLgBgAA4CVYq7QYDodDv//+u2rWrFlk0WoAAICKZhiGcnJyFBsbq4CAktvVCG7F+P3331lMGQAAVLn9+/fr0ksvLfF1glsxatasKcn84UVERFhcDQAA8HV2u11xcXGuDFISglsxnN2jERERBDcAAFBlzveIFoMTAAAAvATBDQAAwEsQ3AAAALwEz7hdIMMwVFBQoMLCQqtL8VuBgYGqVq0aU7YAAPwGwe0C5Ofn68CBAzpx4oTVpfi9sLAw1a9fX0FBQVaXAgBApSO4lZPD4dDu3bsVGBio2NhYBQUF0eJjAcMwlJ+fr0OHDmn37t1q1qxZqRMWAgDgCwhu5ZSfny+Hw6G4uDiFhYVZXY5fCw0NVfXq1bV3717l5+crJCTE6pIAAKhUNFFcIFp3PAO/BwCAP+GvHgAAgJcguAEAAHgJghsAAICXILj5oRUrVigwMFDXXHON2/ElS5bIZrPp2LFjRa6Jj4/XtGnTXN/bbDbXFhERoS5duuiTTz4pct3Jkyc1ceJENW/eXMHBwapbt65uvvlmbdq0qci5drtdTzzxhBISEhQSEqKYmBglJyfrww8/lGEYF/25AQDwdpYGt++++04pKSmKjY2VzWbTxx9/fN5rlixZoo4dOyo4OFhNmzbVnDlzipwzffp0xcfHKyQkRElJScrIyKj44r1YWlqaHnjgAX333Xf6/fffL/g+b731lg4cOKDVq1erR48euummm7RhwwbX63l5eUpOTtbs2bP19NNPa/v27friiy9UUFCgpKQkrVy50nXusWPH1L17d7399tsaO3as1q5dq++++06DBg3SY489puzs7Iv6zAAA+AJLpwPJzc1VYmKi7rrrLt1www3nPX/37t265pprNGLECM2dO1fp6em65557VL9+ffXt21eStGDBAqWmpmrWrFlKSkrStGnT1LdvX23btk316tWrnA9iGJIVk/GGhUnlnEPu+PHjWrBggVavXq3MzEzNmTNHjz/++AW9fa1atRQTE6OYmBg99dRTeuWVV7R48WK1bdtWkjRt2jStWLFCP/30kxITEyVJjRo10gcffKCkpCTdfffd2rhxo2w2mx5//HHt2bNH27dvV2xsrOs9mjdvriFDhjDVBwAAsji49e/fX/379y/z+bNmzVLjxo310ksvSZJatmypZcuW6eWXX3YFt6lTp+ree+/V8OHDXdd8/vnnmj17tsaMGVPxH0IyQ1uNGpVz79IcPy6Fh5frkvfee08JCQlq0aKFbrvtNj388MMaO3bsRU0iXFBQoLS0NElyW8Fg3rx5uvrqq12hzSkgIECjR4/W0KFDtW7dOrVr107z58/X0KFD3UKbUw0rfrYAAHggr3rGbcWKFUpOTnY71rdvX61YsUKSOTnumjVr3M4JCAhQcnKy65zi5OXlyW63u22+Ki0tTbfddpskqV+/fsrOztbSpUsv6F5DhgxRjRo1FBwcrNGjRys+Pl633HKL6/Xt27erZcuWxV7rPL59+3YdPnxYR48eVUJCwgXVAQCAv/CqlRMyMzMVHR3tdiw6Olp2u10nT57U0aNHVVhYWOw5W7duLfG+U6ZM0aRJky68sLAws/WrqpVz5YZt27YpIyNDH330kSSpWrVqGjRokNLS0nTVVVeV++1ffvllJScna9euXRo9erReffVV1alTx+2csgwqYOABAJ9mGNIff0hZWVJmplRQICUlSZGRVlcGL+RVwa2yjB07Vqmpqa7v7Xa74uLiyn4Dm63cXZZWSEtLU0FBgVt3pGEYCg4O1uuvv66IiAhJUnZ2tmrVquV27bFjxxR5zj8yMTExatq0qZo2baq33npLAwYM0ObNm13PEjZv3lxbtmwpthbn8ebNmysqKkq1atUqNVwDgEcxDCk72wxizkBW0teDB6XTp92vDwiQOnaUevUyt549pZo1rfks8CpeFdxiYmKUlZXldiwrK0sREREKDQ1VYGCgAgMDiz0nJiamxPsGBwcrODi4Umr2FAUFBXr77bf10ksvqU+fPm6vDRw4UO+++66GDh2qgIAArVmzRo0aNXK9vmvXLmVnZ6t58+Yl3r9r167q1KmTJk+erFdeeUWSNHjwYD3xxBNat26d23NuDodDL7/8slq1aqXExETZbDYNHjxY//73vzVx4sQiz7kdP35cISEhqlbNq/7nCsDbGIbZe1JaCHPuZ2VJeXnlu3/t2lJ0tJSfL+3aJa1ebW4vvCAFBkpdupwJcj16lLtXBf7Bq/4SduvWTV988YXbsUWLFqlbt26SzAfjO3XqpPT0dA0cOFCSGRLS09M1atSoqi7Xo3z22Wc6evSo7r777iItZzfeeKPS0tI0YsQI3XPPPXrkkUdUrVo1tW3bVvv379ff//53XX755erevXup7/Hwww/r+uuv12OPPaYGDRpo9OjR+uSTT5SSkqKXXnpJSUlJysrK0jPPPKMtW7bom2++cQ2KmDx5spYsWaKkpCRNnjxZnTt3VvXq1fX9999rypQp+vHHH4u0AgJAmeTmnr9VzPn15Mny3TsiwgxjMTElf42JkerVk85uINi/X1qyRFq82Nz27JFWrjS3KVOk6tXN7lRnkOvWTWJ0PSTZDAsfMDp+/Lh27twpSerQoYOmTp2qXr16qU6dOmrYsKHGjh2r3377TW+//bYkczqQNm3aaOTIkbrrrrv07bff6sEHH9Tnn3/uNh3IsGHD9MYbb6hr166aNm2a3nvvPW3durXIs28lsdvtioyMVHZ2tqv70OnUqVPavXu3Gjdu7FVTVKSkpMjhcOjzzz8v8lpGRoaSkpK0bt06NW/eXM8++6wWLFigvXv3KiYmRldffbUmT56sunXruq6x2Wz66KOPXAFZMrtdW7VqpV69emnGjBmSpBMnTuiZZ55x3a9mzZrq1auXnnzySbVp08atjuzsbD377LP64IMPtHfvXtWuXVtt27bVyJEjdd111xU78tVbfx8ALtKpU+cPYc798j6DHB5eehA7+2toaMV8nj17zoS4xYulX391fz042AxvziCXlCSdNYof3q+07HE2S4PbkiVL1KtXryLHhw0bpjlz5ujOO+/Unj17tGTJErdrRo8erc2bN+vSSy/V+PHjdeedd7pd//rrr+uFF15QZmam2rdvr1dffVVJSUllrssXg5uv4vcB+KA//pBWrZJ+/73kYFbeSblDQs60fpUWxKKjrZne6WyGIf3yi3uQy8x0Pyc01OxOdQa5zp3NVjp4La8Ibp6K4OY9+H0APiA/X/rhB2nRIunrr6U1a8zwcj5BQWVvGatZs9wTlnsMw5C2bTMDnLN79dAh93PCw6UrrjgT5Dp0kHgu2KuUNbjxWwUAVC3DkLZsORPUli41n0M7W0KC1KRJ6YEsMtJ7w1h52GzmzyMhQbr/fvPnt3nzmda4JUvMVsqFC81NMp+9+9OfzgS5xERzJCu8HsENAFD5Dh6UvvnGDGuLFkm//eb+er160tVXm1tystSggTV1egObTWrd2txGjZIcDmnDhjNBbulSsyv5s8/MTTJHtJ4d5Nq0Ich5KYIbAKDinTolLVt2plXt55/dXw8JMbv2+vQxw1rbtgSJCxUQYLaoJSZKDz8sFRaaP29nkPv+e+noUemTT8xNkurWla688kyQa9nSP1ovy8IwpJycos9WSmZQthjPuBWjLM+4xcfHK7SiRhPhgp08eVJ79uzhGTfAaoZhtvp8/bUZ1r77zgxvZ0tMPBPUevasuBGZKF1BgfncoDPILVtmrrF9tuho6aqrzgS5Zs18L8jl5pZtSpisrOKnhYmOLjpIpALxjFslqf6/UTsnTpwguHmAE//7x6c6o6mAqnfgwJmuz0WLzD94Z4uNNUNanz5S797mHz5UvWrVzOlDkpKkMWPMwSA//njm+bjly83f3YIF5iaZXdVnB7nGjT0zyJ08eWZC5LOngCnu67nPUZ5PjRruz1SeMzm8VWhxK8b5Uu+BAwd07Ngx1atXT2FhYcXOL4bKZRiGTpw4oYMHD6pWrVqqX7++1SUBvu/ECbMlzdmqtnGj++thYWb3m7NVrVUrz/xjD3d5eeb0K84WuRUrzHB3toYNz4S4Xr3M7yuznoMHy9Y6ZreX796hoWWfFqaKl7JkOpCLcL4fnmEYyszM1LFjx6q+OLipVauWYmJiCM9AZXA4zGelnEFt2TL3P+g2m9Sp05lBBd27u68OAO908qQZ3pxBbtUqs7v1bE2auAe587VGnT5thrGydFMePVq+eoODyz4tTI0aHvsfEwS3i1DWH15hYaFOn7twMKpM9erVFRgYaHUZgG/Zv//MgIL0dOnwYffXGzY80/355z+bD7nDt+Xmmt2pziC3erU5AOJszZuf6VI9t7UsM1M6cqR871m9etmCWEyMOfWJh4ax8iC4XYSy/vAAeJjTp6Xt26X1689szu68+vXNVgHndu73der4xD/+5ZaTY04f4WxV27rV/fUaNcyA5mxVa97cP39OOMNuN1tfnUHup5/M1tnzCQw0p30pSxirXdvv/ndGcLsIBDfAC2RluQe09evNSUnPfTanrIKC3MNcSUHP2/+gFBaaLSbOVrUVK9y7wQICpK5dz7SqJSWxlBJKd+yY+ezjkiVmC21JgeySS5jypRQEt4tAcAM8yKlTZiA7N6Sdu+SPU82aUrt25rxgzq/Vq5sjIH///cx29vfndgeWJji49GDn3DxpVv/du88EtW+/LfoMUZMmZ4Jar15mOAVQpZgOBIB3MQzz+apzA9r27UWfp5HM/3Jv1swMZ2dvjRqVPzDl5ZnP4ZQW7n7/3VxWKC/PDEK7d5d+z5CQ0oOd8/vKeD7n2DGzC8sZ1n75xf31yEhzeg5n9+dll1Xs+wOoNAQ3AFUvJ8d89uzsgLZhg7lMT3EuuaRoQGvVypx+oiIEB5uBr1Gj0s87dcoMeCUFO+f3R4+a5+7aZW6lCQsrWwtezZol3+P0aSkj48xzahkZ7mG3WjXp8svPtKp17swC5ICX4v+5ACpPYaEZXM5tRSspzFSvbi69c25Ii4nxjG7HkBApPt7cSnPypBnizg1254a97GxzbrSdO82tNOHhRYNdnTrmRKrffmuG4bM1b35mPrWrrjJb9gB4PYIbgIpx5IjZanZ2QNu0qejSOk6xsUUDWosW5iABbxcaaj431qRJ6eedOHH+7tkDB8xRfLm50o4d5lacOnXMxdmd3Z/naz0E4JUIbgDK5/Rpadu2oq1ov/1W/PmhoVKbNu4BrW1bs/vT34WFmc+Xne8Zs+PHzwS6s4PdwYNmC+XVV0sdOpjTLQDwaQQ3AMUzDPN5rnOfQ9u82QxvxWncuGgr2mWXESguVo0a5kCMZs2srgSAxQhuAMy5z87t5ly/vuRpMiIiiga0Nm1Kf4AeAHDRCG6APzMM6T//kVJTpV9/Lfp6QID5kPu5Ia1hQ88YLAAAfobgBvirLVukBx4w16OUzElXO3Y8M3Gtc8qN0FBr6wQAuBDcAH9z/Lj01FPS1KnmUkchIdKYMdJjjxHSAMDDEdwAf2EY0vvvm92izhGgKSnStGnnn7YCAOARCG6AP9iyRRo1ypyoVTKD2quvStdcY21dAIByCbC6AACVKCfH7AJt184MbSEh0qRJ5sS4hDYA8Dq0uAG+yDCkBQukRx4xJ2qVpGuvNbtFGze2tDQAwIUjuAG+ZvNms1t08WLze7pFAcBn0FUK+IqcHOlvf5MSE83QFhIi/eMfdIsCgA+hxQ3wdsV1i153nfTyy3SLAoCPIbgB3mzTJnMSXWe36GWXmd2iAwZYWxcAoFLQVQp4o5wc6dFHpfbtzdAWGmpOqrtxI6ENAHwYLW6ANzEMaf58s1v0wAHz2MCBZrdofLyVlQEAqgDBDfAWmzZJI0dKS5ea3zdtanaL9u9vbV0AgCpDVyng6ex2s4UtMdEMbaGh0tNPSxs2ENoAwM/Q4gZ4KsOQ3n3XfJbN2S16/fVmt2ijRtbWBgCwBMEN8EQbN5qT6J7dLfraa1K/ftbWBQCwFF2lgCex26XUVHO0qLNbdPJkM8gR2gDA79HiBngCw5DmzTO7RTMzzWM33CBNnUq3KADAheAGWG3DBrNb9LvvzO+bNTO7Rfv2tbYuAIDHoasUsEp2tjR6tNShgxnaQkOlZ54xgxyhDQBQDFrcgKpmGNLcueaC8M5u0RtvNLtFGza0tjYAgEcjuAFVaf16s1v0++/N75s3N7tF+/Sxti4AgFegqxSoCtnZ0sMPSx07mqEtLEyaMsUMcoQ2AEAZ0eIGVCbDkN55x+wWzcoyj910k/TSS3SLAgDKjeAGVJb16821RZctM79v3lx6/XXp6qutrQsA4LXoKgUqWna29NBDZrfosmXu3aKENgDARaDFDagohiH9+9/SY4+5d4tOnSrFxVlbGwDAJxDcgIqwbp3ZLbp8ufl9ixbmaFFa2AAAFYiuUuBiHDsmPfig2S26fLkUHi49+yzdogCASkGLG3AhHI4z3aIHD5rHbrnFHC166aXW1gYA8FkEN6C8zu0WTUgwu0WTk62tCwDg8+gqBcoqO7tot+hzz5lBjtAGAKgCtLgBZTV0qPT55+Y+3aIAAAsQ3ICy2LrVDG0BAdKXX7JMFQDAEnSVAmUxc6b59S9/IbQBACxjeXCbPn264uPjFRISoqSkJGVkZJR47unTp/WPf/xDl112mUJCQpSYmKiFCxe6nfPkk0/KZrO5bQkJCZX9MeDLjh+X5swx9//v/ywtBQDg3ywNbgsWLFBqaqomTpyotWvXKjExUX379tVB5/QK5xg3bpzeeOMNvfbaa9q8ebNGjBih66+/Xj/99JPbea1bt9aBAwdc2zLnWpHAhZg3T7LbpaZNmZsNAGApS4Pb1KlTde+992r48OFq1aqVZs2apbCwMM2ePbvY8//973/r8ccf14ABA9SkSRPdf//9GjBggF566SW386pVq6aYmBjXVrdu3ar4OPBFhiFNn27u33+/+YwbAAAWseyvUH5+vtasWaPks6ZRCAgIUHJyslasWFHsNXl5eQoJCXE7FhoaWqRFbceOHYqNjVWTJk00dOhQ7du3r9Ra8vLyZLfb3TZAkjntx/r1UmioNHy41dUAAPycZcHt8OHDKiwsVHR0tNvx6OhoZWZmFntN3759NXXqVO3YsUMOh0OLFi3Shx9+qAMHDrjOSUpK0pw5c7Rw4ULNnDlTu3fv1hVXXKGcnJwSa5kyZYoiIyNdWxwLgsNpxgzz6623SrVrW1sLAMDveVW/zyuvvKJmzZopISFBQUFBGjVqlIYPH66As7qv+vfvr5tvvlnt2rVT37599cUXX+jYsWN67733Srzv2LFjlZ2d7dr2799fFR8Hni4rS/rPf8x9BiUAADyAZcGtbt26CgwMVFZWltvxrKwsxcTEFHtNVFSUPv74Y+Xm5mrv3r3aunWratSooSZNmpT4PrVq1VLz5s21c+fOEs8JDg5WRESE2wbo//0/6fRp6fLLzdUSAACwmGXBLSgoSJ06dVJ6errrmMPhUHp6urp161bqtSEhIWrQoIEKCgr0wQcf6Lrrrivx3OPHj+uXX35R/fr1K6x2+IGCAmnWLHOf1jYAgIewtKs0NTVV//znP/Wvf/1LW7Zs0f3336/c3FwN/99D4HfccYfGjh3rOn/VqlX68MMPtWvXLn3//ffq16+fHA6HHnvsMdc5jz76qJYuXao9e/bohx9+0PXXX6/AwEANGTKkyj8fvNh//yv9+qtUt650881WVwMAgCSLl7waNGiQDh06pAkTJigzM1Pt27fXwoULXQMW9u3b5/b82qlTpzRu3Djt2rVLNWrU0IABA/Tvf/9btWrVcp3z66+/asiQITpy5IiioqLUs2dPrVy5UlFRUVX98eDNnIMS7rlHOmckMwAAVrEZhmFYXYSnsdvtioyMVHZ2Ns+7+aNt26SEBMlmk3btkuLjra4IAODjypo9vGpUKVAlzl6XlNAGAPAgBDfgbLm5rEsKAPBYBDfgbHPnStnZ0mWXSX36WF0NAABuCG6AE+uSAgA8HH+ZAKcffjDXJQ0JYV1SAIBHIrgBTmevS1qnjrW1AABQDIIbIJnrkr7/vrnPoAQAgIciuAGSlJZmrkualCR16mR1NQAAFIvgBrAuKQDASxDcgM8+k/bvN9clveUWq6sBAKBEBDfAOSjh7rtZlxQA4NEIbvBv27dLixaZ65L+9a9WVwMAQKkIbvBvznVJr7lGatzY2loAADgPghv8V26u9NZb5j6DEgAAXoDgBv81b96ZdUn79rW6GgAAzovgBv9kGGcGJbAuKQDAS/DXCv5pxQrp559ZlxQA4FUIbvBPzta2IUNYlxQA4DUIbvA/Bw+yLikAwCsR3OB//t//k/Lzpa5dpc6dra4GAIAyI7jBvxQWsi4pAMBrEdzgX5zrkl5yiTRokNXVAABQLgQ3+BfWJQUAeDGCG/zH9u3S11+b65KOGGF1NQAAlBvBDf7D+WzbgAGsSwoA8EoEN/iHEydYlxQA4PUIbvAP8+ZJx45JTZpI/fpZXQ0AABeE4AbfZxjS9OnmPuuSAgC8GH/B4PtWrmRdUgCATyC4wfc5pwAZPNicvw0AAC9FcINvO3hQeu89c59BCQAAL0dwg29LSzPXJe3SxdwAAPBiBDf4rrPXJR050tpaAACoAAQ3+K7PP5f27ZPq1JFuucXqagAAuGgEN/ius9clDQ21thYAACoAwQ2+accO6auvWJcUAOBTCG7wTTNnml/79zdXSwAAwAcQ3OB7WJcUAOCjCG7wPe++a65L2rgx65ICAHwKwQ2+5dx1SQMDra0HAIAKRHCDb1m1SvrpJyk4mHVJAQA+h+AG33L2uqR161pbCwAAFYzgBt9x6JC0YIG5z6AEAIAPIrjBdzjXJe3cWera1epqAACocAQ3+AbWJQUA+AGCG3zDF19Ie/ea65IOGmR1NQAAVAqCG3yDc1DCXXexLikAwGcR3OD9du6UFi5kXVIAgM8juMH7Odcl7ddPuuwya2sBAKASEdzg3c5el5RBCQAAH0dwg3ebP186elSKj2ddUgCAzyO4wXuxLikAwM8Q3OC9MjKktWvNdUnvusvqagAAqHQEN3gvZ2vboEGsSwoA8AsEN3inw4dZlxQA4HcsD27Tp09XfHy8QkJClJSUpIyMjBLPPX36tP7xj3/osssuU0hIiBITE7Vw4cKLuie8lHNd0k6dWJcUAOA3LA1uCxYsUGpqqiZOnKi1a9cqMTFRffv21cGDB4s9f9y4cXrjjTf02muvafPmzRoxYoSuv/56/fTTTxd8T3ihc9cltdmsrQcAgCpiMwzDsOrNk5KS1KVLF73++uuSJIfDobi4OD3wwAMaM2ZMkfNjY2P1xBNPaORZ83XdeOONCg0N1TvvvHNB9yyO3W5XZGSksrOzFRERcbEfExXts8+klBSpdm3p11+lsDCrKwIA4KKUNXtY1uKWn5+vNWvWKDk5+UwxAQFKTk7WihUrir0mLy9PISEhbsdCQ0O1bNmyC76n8752u91tgwc7e11SQhsAwI9YFtwOHz6swsJCRUdHux2Pjo5WZmZmsdf07dtXU6dO1Y4dO+RwOLRo0SJ9+OGHOnDgwAXfU5KmTJmiyMhI1xYXF3eRnw6V5pdfzHVJJdYlBQD4HcsHJ5THK6+8ombNmikhIUFBQUEaNWqUhg8froCAi/sYY8eOVXZ2tmvbv39/BVWMCjdzpjnxbr9+UtOmVlcDAECVsiy41a1bV4GBgcrKynI7npWVpZiYmGKviYqK0scff6zc3Fzt3btXW7duVY0aNdSkSZMLvqckBQcHKyIiwm2DBzp5Upo929xnXVIAgB+yLLgFBQWpU6dOSk9Pdx1zOBxKT09Xt27dSr02JCREDRo0UEFBgT744ANdd911F31PeAHnuqSNGkn9+1tdDQAAVa6alW+empqqYcOGqXPnzurataumTZum3NxcDR8+XJJ0xx13qEGDBpoyZYokadWqVfrtt9/Uvn17/fbbb3ryySflcDj02GOPlfme8GLOQQmsSwoA8FOWBrdBgwbp0KFDmjBhgjIzM9W+fXstXLjQNbhg3759bs+vnTp1SuPGjdOuXbtUo0YNDRgwQP/+979Vq1atMt8TXiojQ1q9WgoKYl1SAIDfsnQeN0/FPG4eaNgw6e23pdtvN78CAOBDPH4eN6DMzl6XlEEJAAA/RnCD55s9W8rLkzp2ZF1SAIBfI7jBs7EuKQAALgQ3eLaFC6Xdu811SQcPtroaAAAsRXCDZ5s+3fw6fDjrkgIA/B7BDZ6LdUkBAHBDcIPnmjXLXJe0b1+pWTOrqwEAwHIEN3gm1iUFAKAIghs804IF0h9/mOuSDhhgdTUAAHgEghs8k3Nd0hEjWJcUAID/IbjB8/z4o7kFBUl33211NQAAeAyCGzyPcwqQW26RoqKsrQUAAA9CcINnOXJEmj/f3GdQAgAAbghu8CzOdUk7dJCSkqyuBgAAj0Jwg+dwOKSZM8191iUFAKAIghs8h3Nd0lq1pCFDrK4GAACPQ3CD52BdUgAASkVwg2fYtUv68ktz//77ra0FAAAPRXCDZ3CuS9qnD+uSAgBQAoIbrHfypJSWZu4zBQgAACUiuMF6771nrkvasKF0zTVWVwMAgMciuMF6zkEJrEsKAECpCG6wFuuSAgBQZgQ3WGvGDPPrzTdL9epZWwsAAB6O4AbrsC4pAADlQnCDdd56Szp1SmrfXrr8cqurAQDA4xHcYA3WJQUAoNwIbrDGV1+ZqyVERrIuKQAAZURwgzXOXpc0PNzaWgAA8BIEN1S93bulL74w91mXFACAMiO4oeo51yW9+mqpeXOrqwEAwGsQ3FC1Tp1iXVIAAC4QwQ1V6733zPnb4uJYlxQAgHIiuKFqnb0uabVq1tYCAICXIbih6qxeLWVkSNWrS/fcY3U1AAB4HYIbqg7rkgIAcFEIbqgaf/whvfuuuc+gBAAALgjBDVXDuS5pYqLUrZvV1QAA4JUIbqh8rEsKAECFILih8n39tfTLL+a6pLfeanU1AAB4LYIbKp9zCpA772RdUgAALgLBDZVrzx7p88/NfdYlBQDgohDcULmc65ImJ0stWlhdDQAAXo3ghsrDuqQAAFQoghsqz/vvS4cPm+uS/uUvVlcDAIDXI7ih8jgHJfz1r6xLCgBABSC4oXKsWSOtWsW6pAAAVCCCGyqHc13Sm26SoqOtrQUAAB9BcEPFO3pUmjfP3GdQAgAAFYbghornXJe0XTupe3erqwEAwGcQ3FCxHI4z3aSsSwoAQIUqV3Cz2+1yOBxFjhcWFsput1dYUfBiixaZ65JGREhDh1pdDQAAPqXMwe2jjz5S586dderUqSKvnTp1Sl26dNF///vfCi0OXui998yvd9zBuqQAAFSwMge3mTNn6rHHHlNYWFiR18LDw/X3v/9dr7/+eoUWBy/0/ffm1379rK0DAAAfVObgtnHjRl111VUlvv6nP/1JGzZsKHcB06dPV3x8vEJCQpSUlKSMjIxSz582bZpatGih0NBQxcXFafTo0W6tgE8++aRsNpvblpCQUO66cAGysqQdO8zn2nr0sLoaAAB8Tpmnsz969KgKCgpKfP306dM6evRoud58wYIFSk1N1axZs5SUlKRp06apb9++2rZtm+rVq1fk/Hnz5mnMmDGaPXu2unfvru3bt+vOO++UzWbT1KlTXee1bt1a33zzjev7aszaXzWWLTO/tm0r1aplaSkAAPiiMre4xcfHa/Xq1SW+vnr1ajVq1Khcbz516lTde++9Gj58uFq1aqVZs2YpLCxMs2fPLvb8H374QT169NCtt96q+Ph49enTR0OGDCnSSletWjXFxMS4trp165arLlwgZzdpz57W1gEAgI8qc3C74YYb9MQTTygrK6vIa5mZmRo3bpxuvPHGMr9xfn6+1qxZo+Tk5DPFBAQoOTlZK1asKPaa7t27a82aNa6gtmvXLn3xxRcaMGCA23k7duxQbGysmjRpoqFDh2rfvn2l1pKXlye73e624QI4W9yuuMLaOgAA8FFl7kMcM2aMPvnkEzVr1ky33XabWrRoIUnaunWr5s6dq7i4OI0ZM6bMb3z48GEVFhYq+pzlkKKjo7V169Zir7n11lt1+PBh9ezZU4ZhqKCgQCNGjNDjjz/uOicpKUlz5sxRixYtdODAAU2aNElXXHGFNm7cqJo1axZ73ylTpmjSpEllrh3FyMmRfvrJ3KfFDQCASlHm4FazZk0tX75cY8eO1YIFC1zPs9WqVUu33XabJk+eXGIwqihLlizRM888oxkzZigpKUk7d+7UQw89pKeeekrjx4+XJPXv3991frt27ZSUlKRGjRrpvffe0913313sfceOHavU1FTX93a7XXFxcZX6WXzOihXm5Lvx8dKll1pdDQAAPqlcT+1HRkZqxowZmj59ug4fPizDMBQVFSXbBcyOX7duXQUGBhbpes3KylJMTEyx14wfP16333677rnnHklS27ZtlZubq/vuu09PPPGEAgKK9vzWqlVLzZs3186dO0usJTg4WMHBweX+DDgL3aQAAFS6C1ryasOGDVq6dKm+++47bdy48YLeOCgoSJ06dVJ6errrmMPhUHp6urp161bsNSdOnCgSzgIDAyVJhmEUe83x48f1yy+/qH79+hdUJ8qIgQkAAFS6crW4ZWRk6O6779bmzZtdQclms6l169ZKS0tTly5dyvXmqampGjZsmDp37qyuXbtq2rRpys3N1fDhwyVJd9xxhxo0aKApU6ZIklJSUjR16lR16NDB1VU6fvx4paSkuALco48+qpSUFDVq1Ei///67Jk6cqMDAQA0ZMqRctaEc8vOllSvNfVrcAACoNGUObps3b1bv3r3VsmVLvfPOO2rZsqXr+Msvv6zevXtr5cqVatWqVZnffNCgQTp06JAmTJigzMxMtW/fXgsXLnQNWNi3b59bC9u4ceNks9k0btw4/fbbb4qKilJKSoomT57sOufXX3/VkCFDdOTIEUVFRalnz55auXKloqKiylwXymntWunUKemSSyQmOwYAoNLYjJL6GM9xyy23qKCgQB988EGRZ9oMw9ANN9yg6tWr6z3nWpVezG63KzIyUtnZ2YqIiLC6HM/3wgvSY49J110nffyx1dUAAOB1ypo9ytzitnjxYn355ZfFDkSw2Wx6/PHHi8ynBj/BwAQAAKpEmQcn5OTkFJlz7WwxMTHKycmpkKLgRRwOghsAAFWkzMGtUaNGpS4Av2rVqnIveQUfsGWL9McfUliY1KGD1dUAAODTyhzcBg8erNTU1GKn/9iwYYMeffRRDRo0qEKLgxdwtrZdfrlUvbq1tQAA4OPK/Izb2LFj9c0336h9+/a6+uqr1bJlSxmGoS1btuibb75R165d3Zaegp9wzt9GNykAAJWuzMEtJCREixcv1ssvv6x3331XS5culSQ1b95cTz/9tEaPHs3qA/6IiXcBAKgyZZ4OxJ8wHUgZ7dsnNWokBQZKx45JNWpYXREAAF6prNnjgpa8Ks6BAwc0atSoirodvIHz+bYOHQhtAABUgXItebVp0yYtXrxYQUFBuuWWW1SrVi0dPnxYTz/9tN544w01adKksuqEJ+L5NgAAqlSZW9w+/fRTdejQQQ8++KBGjBihzp07a/HixWrZsqW2bt2qjz76SJs2barMWuFpmL8NAIAqVebg9vTTT2vkyJGy2+2aOnWqdu3apQcffFBffPGFFi5cqH79+lVmnfA0f/whOaeG6dHD2loAAPATZQ5u27Zt08iRI1WjRg098MADCggI0Msvv6wuXbpUZn3wVMuXm19btJDq1bO2FgAA/ES5lrxyjnIIDAxUaGgoz7T5M7pJAQCocuUanPDVV18pMjJSkuRwOJSenl5kJYVrr7224qqD52L+NgAAqlyZ53ELCDh/45zNZlNhYeFFF2U15nE7j5MnpchI6fRp6ZdfJFpeAQC4KGXNHmVucXM4HBVSGHxARoYZ2mJjpcaNra4GAAC/UWET8MKPnN1NarNZWwsAAH6kzC1ur776arHHIyMj1bx5c3Xr1q3CioKHY2ACAACWKHNwe/nll4s9fuzYMWVnZ6t79+769NNPVadOnQorDh6osFD64Qdzn4EJAABUqTJ3le7evbvY7ejRo9q5c6ccDofGjRtXmbXCE6xbJ+XkSBERUtu2VlcDAIBfqZBn3Jo0aaJnn31WX3/9dUXcDp7M2U3ao4cUGGhtLQAA+JkKG5zQsGFDZWZmVtTt4KmYvw0AAMtUWHDbsGGDGjVqVFG3gycyjDPBjYEJAABUuTIPTrDb7cUez87O1po1a/TII49o2LBhFVYYPNAvv0hZWVJQkMQatQAAVLkyB7datWrJVsKcXTabTffcc4/GjBlTYYXBAzlb27p0kUJCrK0FAAA/VObgtnjx4mKPR0REqFmzZqpRo4Y2btyoNm3aVFhx8DB0kwIAYKkyB7crr7yy2OM5OTmaN2+e0tLStHr1ap9YqxQlYOJdAAAsdcGDE7777jsNGzZM9evX14svvqhevXpp5cqVFVkbPElmprRjh7nEVffuVlcDAIBfKnOLmyRlZmZqzpw5SktLk91u1y233KK8vDx9/PHHatWqVWXVCE+wfLn5tW1bqVYtS0sBAMBflbnFLSUlRS1atND69es1bdo0/f7773rttdcqszZ4Ep5vAwDAcmVucfvyyy/14IMP6v7771ezZs0qsyZ4IibeBQDAcmVucVu2bJlycnLUqVMnJSUl6fXXX9fhw4crszZ4ipwc6eefzX2CGwAAlilzcLv88sv1z3/+UwcOHNBf//pXzZ8/X7GxsXI4HFq0aJFycnIqs05YacUKyeGQ4uOlSy+1uhoAAPxWuUeVhoeH66677tKyZcu0YcMGPfLII3r22WdVr149XXvttZVRI6zG820AAHiEi1qrtEWLFnr++ef166+/6t13362omuBpmL8NAACPYDMMw7C6CE9jt9sVGRmp7OxsRUREWF2OtfLzpchI6dQpafNmqWVLqysCAMDnlDV7XFSLG/zAmjVmaKtbV0pIsLoaAAD8GsENpXN2k/bsaa6aAAAALENwQ+mYvw0AAI9BcEPJHA4GJgAA4EEIbijZli3S0aNSWJjUoYPV1QAA4PcIbiiZs5v08sul6tWtrQUAABDcUAq6SQEA8CgEN5SMFRMAAPAoBDcUb98+cwsMlJKSrK4GAACI4IaSOLtJO3aUatSwthYAACCJ4IaSMH8bAAAeh+CG4vF8GwAAHofghqL++EPatMncp8UNAACPQXBDUcuXm19btJCioqytBQAAuBDcUBTdpAAAeCSCG4pi4l0AADwSwQ3uTp6UVq8293m+DQAAj0Jwg7tVq6TTp6XYWKlxY6urAQAAZ7E8uE2fPl3x8fEKCQlRUlKSMjIySj1/2rRpatGihUJDQxUXF6fRo0fr1KlTF3VPnOXsblKbzdpaAACAG0uD24IFC5SamqqJEydq7dq1SkxMVN++fXXw4MFiz583b57GjBmjiRMnasuWLUpLS9OCBQv0+OOPX/A9cQ4m3gUAwGPZDMMwrHrzpKQkdenSRa+//rokyeFwKC4uTg888IDGjBlT5PxRo0Zpy5YtSk9Pdx175JFHtGrVKi37X0tRee9ZHLvdrsjISGVnZysiIuJiP6b3KCiQateWjh+Xfv5ZSky0uiIAAPxCWbOHZS1u+fn5WrNmjZKTk88UExCg5ORkrVixothrunfvrjVr1ri6Pnft2qUvvvhCAwYMuOB7SlJeXp7sdrvb5pfWrzdDW0SE1KaN1dUAAIBzVLPqjQ8fPqzCwkJFR0e7HY+OjtbWrVuLvebWW2/V4cOH1bNnTxmGoYKCAo0YMcLVVXoh95SkKVOmaNKkSRf5iXyAs5u0Rw8pMNDaWgAAQBGWD04ojyVLluiZZ57RjBkztHbtWn344Yf6/PPP9dRTT13UfceOHavs7GzXtn///gqq2MswfxsAAB7Nsha3unXrKjAwUFlZWW7Hs7KyFBMTU+w148eP1+2336577rlHktS2bVvl5ubqvvvu0xNPPHFB95Sk4OBgBQcHX+Qn8nKGwcAEAAA8nGUtbkFBQerUqZPbQAOHw6H09HR169at2GtOnDihgAD3kgP/16VnGMYF3RP/s3OnlJUlBQVJXbpYXQ0AACiGZS1ukpSamqphw4apc+fO6tq1q6ZNm6bc3FwNHz5cknTHHXeoQYMGmjJliiQpJSVFU6dOVYcOHZSUlKSdO3dq/PjxSklJcQW4890TJXB2k3btKoWEWFsLAAAolqXBbdCgQTp06JAmTJigzMxMtW/fXgsXLnQNLti3b59bC9u4ceNks9k0btw4/fbbb4qKilJKSoomT55c5nuiBHSTAgDg8Sydx81T+eU8bs2amd2ln38u/W96FQAAUDU8fh43eJDMTDO02WxS9+5WVwMAAEpAcMOZ59vatpVq1bK0FAAAUDKCG5i/DQAAL0Fww5mBCQQ3AAA8GsHN39nt5oLyEiNKAQDwcAQ3f7dypeRwSI0bSw0aWF0NAAAoBcHN3zF/GwAAXoPg5u94vg0AAK9BcPNn+fnSqlXmPsENAACPR3DzZ2vWSKdOSXXrSi1aWF0NAAA4D4KbPzv7+TabzdpaAADAeRHc/BkT7wIA4FUIbv7K4TgT3BhRCgCAVyC4+avNm6WjR6WwMKlDB6urAQAAZUBw81fO1rZu3aTq1a2tBQAAlAnBzV8x8S4AAF6H4OavGJgAAIDXIbj5o337zC0wUEpKsroaAABQRgQ3f+TsJu3YUapRw9paAABAmRHc/BHdpAAAeCWCmz9iYAIAAF6J4OZvjhyRNm0y9wluAAB4FYKbv/nhB/NrQoIUFWVtLQAAoFwIbv6GblIAALwWwc3fOIMbAxMAAPA6BDd/cuKEtGaNuU9wAwDA6xDc/ElGhnT6tBQbK8XHW10NAAAoJ4KbPzm7m9Rms7YWAABQbgQ3f8LEuwAAeDWCm78oKDgzFQgjSgEA8EoEN3+xfr10/LgUGSm1aWN1NQAA4AIQ3PyF8/m27t2lwEBrawEAABeE4OYvmL8NAACvR3DzB4bBwAQAAHwAwc0f7NwpZWVJQUFS585WVwMAAC4Qwc0fOLtJu3aVQkKsrQUAAFwwgps/oJsUAACfQHDzB84WN+ZvAwDAqxHcfF1mpvmMm81mTgUCAAC8FsHN1zm7Sdu1k2rVsrQUAABwcQhuvo5uUgAAfAbBzdcx8S4AAD6D4ObL7HZp3TpznxY3AAC8HsHNl61YITkcUuPGUoMGVlcDAAAuEsHNlzF/GwAAPoXg5ssYmAAAgE8huPmqvDxp1SpznxY3AAB8AsHNV61dK506JdWtK7VoYXU1AACgAhDcfNXZ3aQ2m7W1AACACkFw81XM3wYAgM8huPkih0NavtzcJ7gBAOAzCG6+aPNm6ehRKSxMat/e6moAAEAFIbj5Imc3abduUvXq1tYCAAAqDMHNFzHxLgAAPong5ouYeBcAAJ/kEcFt+vTpio+PV0hIiJKSkpSRkVHiuVdddZVsNluR7ZprrnGdc+eddxZ5vV+/flXxUay3d6+0f78UGChdfrnV1QAAgApUzeoCFixYoNTUVM2aNUtJSUmaNm2a+vbtq23btqlevXpFzv/www+Vn5/v+v7IkSNKTEzUzTff7HZev3799NZbb7m+Dw4OrrwP4Umc3aQdO0rh4dbWAgAAKpTlLW5Tp07Vvffeq+HDh6tVq1aaNWuWwsLCNHv27GLPr1OnjmJiYlzbokWLFBYWViS4BQcHu51Xu3btqvg41mP+NgAAfJalwS0/P19r1qxRcnKy61hAQICSk5O1YsWKMt0jLS1NgwcPVvg5rUtLlixRvXr11KJFC91///06cuRIiffIy8uT3W5327wWAxMAAPBZlga3w4cPq7CwUNHR0W7Ho6OjlZmZed7rMzIytHHjRt1zzz1ux/v166e3335b6enpeu6557R06VL1799fhYWFxd5nypQpioyMdG1xcXEX/qGsdOSItGmTud+jh7W1AACACmf5M24XIy0tTW3btlXXrl3djg8ePNi137ZtW7Vr106XXXaZlixZot69exe5z9ixY5Wamur63m63e2d4c66WkJAgRUVZWwsAAKhwlra41a1bV4GBgcrKynI7npWVpZiYmFKvzc3N1fz583X33Xef932aNGmiunXraufOncW+HhwcrIiICLfNK9FNCgCAT7M0uAUFBalTp05KT093HXM4HEpPT1e3bt1Kvfb9999XXl6ebrvttvO+z6+//qojR46ofv36F12zR2P+NgAAfJrlo0pTU1P1z3/+U//617+0ZcsW3X///crNzdXw4cMlSXfccYfGjh1b5Lq0tDQNHDhQl1xyidvx48eP629/+5tWrlypPXv2KD09Xdddd52aNm2qvn37VslnssSJE9Lq1eY+LW4AAPgky59xGzRokA4dOqQJEyYoMzNT7du318KFC10DFvbt26eAAPd8uW3bNi1btkxff/11kfsFBgZq/fr1+te//qVjx44pNjZWffr00VNPPeXbc7llZEgFBVKDBlJ8vNXVAACASmAzDMOwughPY7fbFRkZqezsbO953u2pp6QJE6RBg6T5862uBgAAlENZs4flXaWoIEy8CwCAzyO4+YKCAsk5YTHBDQAAn0Vw8wXr1knHj0uRkVLr1lZXAwAAKgnBzRc452/r0UMKDLS2FgAAUGkIbr6A+dsAAPALBDdvZxgMTAAAwE8Q3Lzdzp3SwYNScLDUpYvV1QAAgEpEcPN2zta2Ll3M8AYAAHwWwc3b0U0KAIDfILh5O+eIUoIbAAA+j+DmzTIzzWfcbDapWzerqwEAAJWM4ObNnN2k7dpJtWpZWgoAAKh8BDdvRjcpAAB+heDmzZh4FwAAv0Jw81Z2u7lGqUSLGwAAfoLg5q1WrJAcDqlJEyk21upqAABAFSC4eSu6SQEA8DsEN2/FwAQAAPwOwc0b5eVJq1aZ+7S4AQDgNwhu3mjNGunUKSkqSmrRwupqAABAFSG4eSNnN2nPnuaqCQAAwC8Q3LwRAxMAAPBLBDdv43BIy5eb+wxMAADArxDcvM3mzdLRo1J4uNShg9XVAACAKkRw8zbObtLLL5eqVbO2FgAAUKUIbt7GGdzoJgUAwO8Q3LwNE+8CAOC3CG7eZO9eaf9+s4s0KcnqagAAQBUjuHkTZzdpx47m4AQAAOBXCG7e5OyJdwEAgN8huHkTBiYAAODXCG7e4sgRcw43SerRw9paAACAJQhu3sK5WkJCgrm4PAAA8DsEN29BNykAAH6P4OYtmL8NAAC/R3DzBidOSKtXm/uMKAUAwG8R3LzBqlVSQYHUoIEUH291NQAAwCIEN29wdjepzWZtLQAAwDIEN2/gHJhANykAAH6N4ObpCgqkFSvMfQYmAADg1whunm7dOun4cSkyUmrTxupqAACAhQhuns7ZTdqjhxTArwsAAH9GEvB0TLwLAAD+h+DmyQzjzIhSBiYAAOD3CG6ebMcO6eBBKThY6tLF6moAAIDFCG6ezNna1rWrGd4AAIBfI7h5MuZvAwAAZyG4eTIGJgAAgLMQ3DzVgQPSL7+YS1x17251NQAAwAMQ3DyV8/m2du3MyXcBAIDfI7h5KrpJAQDAOQhunsrZ4kZwAwAA/0Nw80R2u7lGqcSIUgAA4EJw80Q//CA5HFKTJlJsrNXVAAAAD+ERwW369OmKj49XSEiIkpKSlJGRUeK5V111lWw2W5HtmmuucZ1jGIYmTJig+vXrKzQ0VMnJydqxY0dVfJSKwTJXAACgGJYHtwULFig1NVUTJ07U2rVrlZiYqL59++rgwYPFnv/hhx/qwIEDrm3jxo0KDAzUzTff7Drn+eef16uvvqpZs2Zp1apVCg8PV9++fXXq1Kmq+lgXh4EJAACgGDbDMAwrC0hKSlKXLl30+uuvS5IcDofi4uL0wAMPaMyYMee9ftq0aZowYYIOHDig8PBwGYah2NhYPfLII3r00UclSdnZ2YqOjtacOXM0ePDg897TbrcrMjJS2dnZioiIuLgPWF55eeb0H3l50tatUosWVfv+AACgypU1e1ja4pafn681a9YoOTnZdSwgIEDJyclasWJFme6RlpamwYMHKzw8XJK0e/duZWZmut0zMjJSSUlJJd4zLy9PdrvdbbPMmjVmaIuKkpo3t64OAADgcSwNbocPH1ZhYaGio6PdjkdHRyszM/O812dkZGjjxo265557XMec15XnnlOmTFFkZKRri4uLK+9HqThnr09qs1lXBwAA8DiWP+N2MdLS0tS2bVt17dr1ou4zduxYZWdnu7b9+/dXUIUXgPnbAABACSwNbnXr1lVgYKCysrLcjmdlZSkmJqbUa3NzczV//nzdfffdbsed15XnnsHBwYqIiHDbLOFwSMuXm/uMKAUAAOewNLgFBQWpU6dOSk9Pdx1zOBxKT09Xt27dSr32/fffV15enm677Ta3440bN1ZMTIzbPe12u1atWnXee1pu0ybp6FEpPFzq0MHqagAAgIepZnUBqampGjZsmDp37qyuXbtq2rRpys3N1fDhwyVJd9xxhxo0aKApU6a4XZeWlqaBAwfqkksucTtus9n08MMP6+mnn1azZs3UuHFjjR8/XrGxsRo4cGBVfawL4+wm7dZNqmb5rwYAAHgYy9PBoEGDdOjQIU2YMEGZmZlq3769Fi5c6BpcsG/fPgUEuDcMbtu2TcuWLdPXX39d7D0fe+wx5ebm6r777tOxY8fUs2dPLVy4UCEhIZX+eS7K2QMTAAAAzmH5PG6eyJJ53AxDathQ+vVXKT1d+vOfq+Z9AQCA5bxiHjecZd8+M7RVqyYlJVldDQAA8EAEN0/h7Cbt2NEcnAAAAHAOgpunYH1SAABwHgQ3T+EcUcrABAAAUAKCmyc4ckTavNncJ7gBAIASENw8gbO1rWVLqW5da2sBAAAei+DmCegmBQAAZUBw8wQMTAAAAGVAcLPaiRPSmjXmPsENAACUguBmtVWrpIICqUEDqVEjq6sBAAAejOBmtbO7SW02a2sBAAAejeBmNefABLpJAQDAeRDcrFRQIK1YYe4zohQAAJwHwc1KP/8sHT8u1aoltWljdTUAAMDDEdys5Owm7dFDCuBXAQAASkdasJJzYALdpAAAoAwIblYxDCbeBQAA5UJws8qOHdKhQ1JwsNS5s9XVAAAAL0Bws4qzta1rVzO8AQAAnAfBzSrM3wYAAMqJ4GYVBiYAAIByIrhZ4cAB6ZdfzCWuune3uhoAAOAlCG5WcHaTJiZKkZHW1gIAALxGNasL8EthYdKVV5oDEwAAAMqI4GaFa64xNwAAgHKgqxQAAMBLENwAAAC8BMENAADASxDcAAAAvATBDQAAwEsQ3AAAALwEwQ0AAMBLENwAAAC8BMENAADASxDcAAAAvATBDQAAwEsQ3AAAALwEwQ0AAMBLENwAAAC8BMENAADASxDcAAAAvATBDQAAwEsQ3AAAALxENasL8ESGYUiS7Ha7xZUAAAB/4MwczgxSEoJbMXJyciRJcXFxFlcCAAD8SU5OjiIjI0t83WacL9r5IYfDod9//101a9aUzWazuhyvYrfbFRcXp/379ysiIsLqclBG/N68E78378PvzDtVxe/NMAzl5OQoNjZWAQElP8lGi1sxAgICdOmll1pdhleLiIjgHyUvxO/NO/F78z78zrxTZf/eSmtpc2JwAgAAgJcguAEAAHgJghsqVHBwsCZOnKjg4GCrS0E58HvzTvzevA+/M+/kSb83BicAAAB4CVrcAAAAvATBDQAAwEsQ3AAAALwEwQ0AAMBLENxQIaZMmaIuXbqoZs2aqlevngYOHKht27ZZXRbK4dlnn5XNZtPDDz9sdSk4j99++0233XabLrnkEoWGhqpt27ZavXq11WWhFIWFhRo/frwaN26s0NBQXXbZZXrqqafOuy4lqtZ3332nlJQUxcbGymaz6eOPP3Z73TAMTZgwQfXr11doaKiSk5O1Y8eOKq2R4IYKsXTpUo0cOVIrV67UokWLdPr0afXp00e5ublWl4Yy+PHHH/XGG2+oXbt2VpeC8zh69Kh69Oih6tWr68svv9TmzZv10ksvqXbt2laXhlI899xzmjlzpl5//XVt2bJFzz33nJ5//nm99tprVpeGs+Tm5ioxMVHTp08v9vXnn39er776qmbNmqVVq1YpPDxcffv21alTp6qsRqYDQaU4dOiQ6tWrp6VLl+pPf/qT1eWgFMePH1fHjh01Y8YMPf3002rfvr2mTZtmdVkowZgxY7R8+XJ9//33VpeCcvjLX/6i6OhopaWluY7deOONCg0N1TvvvGNhZSiJzWbTRx99pIEDB0oyW9tiY2P1yCOP6NFHH5UkZWdnKzo6WnPmzNHgwYOrpC5a3FApsrOzJUl16tSxuBKcz8iRI3XNNdcoOTnZ6lJQBp9++qk6d+6sm2++WfXq1VOHDh30z3/+0+qycB7du3dXenq6tm/fLklat26dli1bpv79+1tcGcpq9+7dyszMdPu3MjIyUklJSVqxYkWV1cEi86hwDodDDz/8sHr06KE2bdpYXQ5KMX/+fK1du1Y//vij1aWgjHbt2qWZM2cqNTVVjz/+uH788Uc9+OCDCgoK0rBhw6wuDyUYM2aM7Ha7EhISFBgYqMLCQk2ePFlDhw61ujSUUWZmpiQpOjra7Xh0dLTrtapAcEOFGzlypDZu3Khly5ZZXQpKsX//fj300ENatGiRQkJCrC4HZeRwONS5c2c988wzkqQOHTpo48aNmjVrFsHNg7333nuaO3eu5s2bp9atW+vnn3/Www8/rNjYWH5vKBe6SlGhRo0apc8++0yLFy/WpZdeanU5KMWaNWt08OBBdezYUdWqVVO1atW0dOlSvfrqq6pWrZoKCwutLhHFqF+/vlq1auV2rGXLltq3b59FFaEs/va3v2nMmDEaPHiw2rZtq9tvv12jR4/WlClTrC4NZRQTEyNJysrKcjuelZXleq0qENxQIQzD0KhRo/TRRx/p22+/VePGja0uCefRu3dvbdiwQT///LNr69y5s4YOHaqff/5ZgYGBVpeIYvTo0aPIVDvbt29Xo0aNLKoIZXHixAkFBLj/yQ0MDJTD4bCoIpRX48aNFRMTo/T0dNcxu92uVatWqVu3blVWB12lqBAjR47UvHnz9Mknn6hmzZqu/v7IyEiFhoZaXB2KU7NmzSLPIIaHh+uSSy7h2UQPNnr0aHXv3l3PPPOMbrnlFmVkZOjNN9/Um2++aXVpKEVKSoomT56shg0bqnXr1vrpp580depU3XXXXVaXhrMcP35cO3fudH2/e/du/fzzz6pTp44aNmyohx9+WE8//bSaNWumxo0ba/z48YqNjXWNPK0SBlABJBW7vfXWW1aXhnK48sorjYceesjqMnAe//3vf402bdoYwcHBRkJCgvHmm29aXRLOw263Gw899JDRsGFDIyQkxGjSpInxxBNPGHl5eVaXhrMsXry42L9lw4YNMwzDMBwOhzF+/HgjOjraCA4ONnr37m1s27atSmtkHjcAAAAvwTNuAAAAXoLgBgAA4CUIbgAAAF6C4AYAAOAlCG4AAABeguAGAADgJQhuAAAAXoLgBgAA4CUIbgBgAZvNpo8//tjqMgB4GYIbAL9z5513ymazFdn69etndWkAUCoWmQfgl/r166e33nrL7VhwcLBF1QBA2dDiBsAvBQcHKyYmxm2rXbu2JLMbc+bMmerfv79CQ0PVpEkT/ec//3G7fsOGDfrzn/+s0NBQXXLJJbrvvvt0/Phxt3Nmz56t1q1bKzg4WPXr19eoUaPcXj98+LCuv/56hYWFqVmzZvr0009drx09elRDhw5VVFSUQkND1axZsyJBE4D/IbgBQDHGjx+vG2+8UevWrdPQoUM1ePBgbdmyRZKUm5urvn37qnbt2vrxxx/1/vvv65tvvnELZjNnztTIkSN13333acOGDfr000/VtGlTt/eYNGmSbrnlFq1fv14DBgzQ0KFD9ccff7jef/Pmzfryyy+1ZcsWzZw5U3Xr1q26HwAAz2QAgJ8ZNmyYERgYaISHh7ttkydPNgzDMCQZI0aMcLsmKSnJuP/++w3DMIw333zTqF27tnH8+HHX659//rkREBBgZGZmGoZhGLGxscYTTzxRYg2SjHHjxrm+P378uCHJ+PLLLw3DMIyUlBRj+PDhFfOBAfgMnnED4Jd69eqlmTNnuh2rU6eOa79bt25ur3Xr1k0///yzJGnLli1KTExUeHi46/UePXrI4XBo27Ztstls+v3339W7d+9Sa2jXrp1rPzw8XBERETp48KAk6f7779eNN96otWvXqk+fPho4cKC6d+9+QZ8VgO8guAHwS+Hh4UW6LitKaGhomc6rXr262/c2m00Oh0OS1L9/f+3du1dffPGFFi1apN69e2vkyJF68cUXK7xeAN6DZ9wAoBgrV64s8n3Lli0lSS1bttS6deuUm5vren358uUKCAhQixYtVLNmTcXHxys9Pf2iaoiKitKwYcP0zjvvaNq0aXrzzTcv6n4AvB8tbgD8Ul5enjIzM92OVatWzTUA4P3331fnzp3Vs2dPzZ07VxkZGUpLS5MkDR06VBMnTtSwYcP05JNP6tChQ3rggQd0++23Kzo6WpL05JNPasSIEapXr5769++vnJwcLV++XA888ECZ6pswYYI6deqk1q1bKy8vT5999pkrOALwXwQ3AH5p4cKFql+/vtuxFi1aaOvWrZLMEZ/z58/X//3f/6l+/fp699131apVK0lSWFiYvvrqKz300EPq0qWLwsLCdOONN2rq1Kmuew0bNkynTp3Syy+/rEcffVR169bVTTfdVOb6goKCNHbsWO3Zs0ehoaG64oorNH/+/Ar45AC8mc0wDMPqIgDAk9hsNn300UcaOHCg1aUAgBuecQMAAPASBDcAAAAvwTNuAHAOniAB4KlocQMAAPASBDcAAAAvQXADAADwEgQ3AAAAL0FwAwAA8BIENwAAAC9BcAMAAPASBDcAAAAv8f8BAUuy9+On2zcAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}