MNIST_Digits_CNN_classification_with_Pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Jn_f7ryHKLdN"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch import nn, save, load\n",
        "from torch.optim import Adam\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets\n",
        "from torchvision.transforms import ToTensor\n",
        "\n",
        "from time import time\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the dataset\n",
        "train = datasets.MNIST(root = '.', train = True, transform = ToTensor(), download = True)\n",
        "train_dataset = DataLoader(train, batch_size = 32, shuffle = True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h24P8U2PuIHo",
        "outputId": "97b7c36b-e214-4491-8c23-e63e9342bfd7"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:00<00:00, 89881380.75it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./MNIST/raw/train-images-idx3-ubyte.gz to ./MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 27221504.23it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./MNIST/raw/train-labels-idx1-ubyte.gz to ./MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:00<00:00, 24839690.24it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./MNIST/raw/t10k-images-idx3-ubyte.gz to ./MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 5226482.52it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./MNIST/raw/t10k-labels-idx1-ubyte.gz to ./MNIST/raw\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class DigitsClassifier(nn.Module):\n",
        "\n",
        "    def __init__(self) -> None:\n",
        "        super().__init__()\n",
        "\n",
        "        self.model = nn.Sequential()\n",
        "\n",
        "        # in_channels, out_channels, kernel_size,\n",
        "        self.model.add_module(\"conv2d_1\", nn.Conv2d(in_channels = 1, out_channels = 16, \n",
        "                                               kernel_size = 3, padding = 1))             # padding = (kernel_size - 1) // 2\n",
        "\n",
        "        self.model.add_module(\"ReLU_1\", nn.ReLU())\n",
        "        self.model.add_module(\"MaxPool2D_1\", nn.MaxPool2d(kernel_size = 2, padding=1))    # padding = (kernel_size - 1) // 2\n",
        "        self.model.add_module('BatchNorm_1', nn.BatchNorm2d(num_features = 16))           # num features = out_channels of the conv2d layer\n",
        "        self.model.add_module(\"Dropout2D_1\", nn.Dropout2d(p = 0.25))\n",
        "\n",
        "\n",
        "        self.model.add_module(\"conv2d_2\", nn.Conv2d(in_channels = 16, out_channels = 32,  # in_channels = out_channels of the previous layer\n",
        "                                               kernel_size = 3, padding = 1))             # padding = (kernel_size - 1) // 2\n",
        "\n",
        "        self.model.add_module(\"ReLU_2\", nn.ReLU())\n",
        "        self.model.add_module(\"MaxPool2D_2\", nn.MaxPool2d(kernel_size = 2, padding=1))    # padding = (kernel_size - 1) // 2\n",
        "        self.model.add_module('BatchNorm_2', nn.BatchNorm2d(num_features = 32))           # num features = out_channels of the conv2d layer\n",
        "        self.model.add_module(\"Dropout2D_2\", nn.Dropout2d(p = 0.25))\n",
        "\n",
        "\n",
        "        self.model.add_module(\"conv2d_3\", nn.Conv2d(in_channels = 32, out_channels = 64,  # in_channels = out_channels of the previous layer\n",
        "                                               kernel_size = 3, padding = 1))             # padding = (kernel_size - 1) // 2\n",
        "\n",
        "        self.model.add_module(\"ReLU_3\", nn.ReLU())\n",
        "        self.model.add_module(\"MaxPool2D_3\", nn.MaxPool2d(kernel_size = 2, padding=1))    # padding = (kernel_size - 1) // 2\n",
        "        self.model.add_module('BatchNorm_3', nn.BatchNorm2d(num_features = 64))           # num features = out_channels of the conv2d layer\n",
        "        self.model.add_module(\"Dropout2D_3\", nn.Dropout2d(p = 0.25))\n",
        "\n",
        "        \"\"\"self.model.add_module(\"Flatten\",nn.Flatten())\n",
        "        self.model.add_module(\"Dense\",nn.Linear(in_features = 64*(28-6)*(28-6)           # 64 2d channels/feature maps of size 22 x 22\n",
        "                                             , out_features = 10, bias=True))\"\"\"            # 10 output classes\n",
        "        self.model.add_module(\"Flatten\",nn.Flatten())\n",
        "        self.model.add_module(\"Dense\", nn.Linear(in_features = 64 * 5 * 5,  # x64 2d 5x5 channels/feature maps\n",
        "                                                 out_features=10))          # 10 output classes\n",
        "        self.model.add_module(\"softmax\", nn.LogSoftmax(dim=1) )\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n"
      ],
      "metadata": {
        "id": "YweN9Ov7u59z"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify the device (GPU or CPU)\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "digit_classifier = DigitsClassifier().to(device)  # CPU by default\n",
        "print(f\"Model running on {device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c8LX7ZDnFhwS",
        "outputId": "799a20bf-becc-47d2-c42e-7c799d92f136"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model running on cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torchsummary import summary\n",
        "summary(digit_classifier, input_size = (1, 28, 28))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zyon0RRfGsV_",
        "outputId": "dec50c36-45a6-42e0-984d-2bfdcc390879"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 16, 28, 28]             160\n",
            "              ReLU-2           [-1, 16, 28, 28]               0\n",
            "         MaxPool2d-3           [-1, 16, 15, 15]               0\n",
            "       BatchNorm2d-4           [-1, 16, 15, 15]              32\n",
            "         Dropout2d-5           [-1, 16, 15, 15]               0\n",
            "            Conv2d-6           [-1, 32, 15, 15]           4,640\n",
            "              ReLU-7           [-1, 32, 15, 15]               0\n",
            "         MaxPool2d-8             [-1, 32, 8, 8]               0\n",
            "       BatchNorm2d-9             [-1, 32, 8, 8]              64\n",
            "        Dropout2d-10             [-1, 32, 8, 8]               0\n",
            "           Conv2d-11             [-1, 64, 8, 8]          18,496\n",
            "             ReLU-12             [-1, 64, 8, 8]               0\n",
            "        MaxPool2d-13             [-1, 64, 5, 5]               0\n",
            "      BatchNorm2d-14             [-1, 64, 5, 5]             128\n",
            "        Dropout2d-15             [-1, 64, 5, 5]               0\n",
            "          Flatten-16                 [-1, 1600]               0\n",
            "           Linear-17                   [-1, 10]          16,010\n",
            "       LogSoftmax-18                   [-1, 10]               0\n",
            "================================================================\n",
            "Total params: 39,530\n",
            "Trainable params: 39,530\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.54\n",
            "Params size (MB): 0.15\n",
            "Estimated Total Size (MB): 0.70\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# hyperparameters\n",
        "EPOCHS = 25\n",
        "LR = 1e-3\n",
        "\n",
        "# optimizing model parameters with a leaerning rate of 1e-3\n",
        "opt = Adam(params = digit_classifier.parameters(), lr = LR)\n",
        "\n",
        "# specifying the loss function as cross entropy\n",
        "loss_fn = nn.CrossEntropyLoss()"
      ],
      "metadata": {
        "id": "ZWQAgqxnZHCt"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Training flow\n",
        "\n",
        "losses = []\n",
        "accuracies = []\n",
        "losses_per_batch = []\n",
        "\n",
        "\n",
        "beg = time()\n",
        "for epoch in range(EPOCHS):\n",
        "    for batch in train_dataset:\n",
        "        \n",
        "        # unpacking input features and labels\n",
        "        x, y = batch\n",
        "        # Move the input data and labels to the specified device\n",
        "        x, y = x.to(device), y.to(device)\n",
        "        # yhat == predicted label\n",
        "        yhat = digit_classifier(x)\n",
        "        loss = loss_fn(yhat, y)\n",
        "\n",
        "        # backpropagation\n",
        "        opt.zero_grad()     # zero out the gradient\n",
        "        loss.backward()     # Computes the gradient of current loss\n",
        "        opt.step()          # optimize i.e update model paramerters to reduce loss\n",
        "\n",
        "        #losses_per_batch.append(loss)\n",
        "\n",
        "    print(f\"Epoch {epoch} : train_loss : {loss:.4f}\")\n",
        "    #print(yhat.shape)\n",
        "    losses.append(loss.item())\n",
        "\n",
        "duration = int(time() - beg)\n",
        "print(f\"training on {device} lasted for {duration // 60 } min {duration % 60} sec\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bl2GrlBbcn89",
        "outputId": "33a221c2-61d6-4e53-eab5-4faa6a69ffc1"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0 : train_loss : 0.3084\n",
            "Epoch 1 : train_loss : 0.0768\n",
            "Epoch 2 : train_loss : 0.0189\n",
            "Epoch 3 : train_loss : 0.0241\n",
            "Epoch 4 : train_loss : 0.0188\n",
            "Epoch 5 : train_loss : 0.1134\n",
            "Epoch 6 : train_loss : 0.0054\n",
            "Epoch 7 : train_loss : 0.0078\n",
            "Epoch 8 : train_loss : 0.0134\n",
            "Epoch 9 : train_loss : 0.0103\n",
            "Epoch 10 : train_loss : 0.0013\n",
            "Epoch 11 : train_loss : 0.0099\n",
            "Epoch 12 : train_loss : 0.0006\n",
            "Epoch 13 : train_loss : 0.0220\n",
            "Epoch 14 : train_loss : 0.2354\n",
            "Epoch 15 : train_loss : 0.0643\n",
            "Epoch 16 : train_loss : 0.0025\n",
            "Epoch 17 : train_loss : 0.0175\n",
            "Epoch 18 : train_loss : 0.0020\n",
            "Epoch 19 : train_loss : 0.0010\n",
            "Epoch 20 : train_loss : 0.0064\n",
            "Epoch 21 : train_loss : 0.0014\n",
            "Epoch 22 : train_loss : 0.0376\n",
            "Epoch 23 : train_loss : 0.1635\n",
            "Epoch 24 : train_loss : 0.0303\n",
            "training on cpu lasted for 16 min 4 sec\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# saving the model\n",
        "with open('model_state.pt', 'wb') as f: \n",
        "    save(digit_classifier.state_dict(), f) \n"
      ],
      "metadata": {
        "id": "hnvPfmfUr-1Q"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# run predictions :\n",
        "\n",
        "# load model params\n",
        "with open('model_state.pt', 'rb') as f: \n",
        "    digit_classifier.load_state_dict(load(f)) \n",
        "\n",
        "fig = plt.figure(figsize=(8, 5))\n",
        "images = ['img_3.jpg', 'img_2.jpg', 'img_1.jpg']\n",
        "\n",
        "for i , image in enumerate(images):\n",
        "\n",
        "    fig.add_subplot(1, len(images), i+1)\n",
        "\n",
        "    img = Image.open(image) \n",
        "    plt.imshow(img)\n",
        "    plt.axis('off') \n",
        "\n",
        "    # preprocessing input   \n",
        "    img_tensor = ToTensor()(img).unsqueeze(0).to(device)\n",
        "    # running inference\n",
        "    label = torch.argmax(digit_classifier(img_tensor)).item()\n",
        "    plt.title(f\"Prediction = {str(label)}\")\n",
        "\n",
        "\n",
        "    #print(label)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "id": "7LoU_nZAAoPV",
        "outputId": "cbfeaf7a-fe7a-4edb-ae18-dca4cd32c6e6"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(losses)\n",
        "print(len(losses))\n",
        "#print(range(5))\n",
        "# Plot the loss curve\n",
        "plt.plot([i for i in range(EPOCHS)], losses)\n",
        "\n",
        "# Add labels and title\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('train loss')\n",
        "plt.title('train loss evolution through epochs')\n",
        "plt.legend(['train loss'], loc='upper left')\n",
        "# Display the plot\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        },
        "id": "KStmEaUfhZrp",
        "outputId": "1e70dc01-6ae9-46d7-a367-82a5a3e0bf15"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.30840766429901123, 0.07676935195922852, 0.018864046782255173, 0.02408142387866974, 0.018810711801052094, 0.1133894994854927, 0.00535312294960022, 0.0077715180814266205, 0.013366572558879852, 0.010342005640268326, 0.0012854983797296882, 0.00988083891570568, 0.000643374805804342, 0.021996933966875076, 0.23537445068359375, 0.06430727988481522, 0.0025265468284487724, 0.017534499987959862, 0.002014968078583479, 0.001032412750646472, 0.006389974150806665, 0.0014054448110982776, 0.03763658180832863, 0.1635209619998932, 0.030256349593400955]\n",
            "25\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHHCAYAAACx7iyPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9TklEQVR4nO3dd3yT5doH8F+SNuneGwotLaPMykaEqlSGiuAE5bxAnUfBVdFz8LwCiudUBREHylFfQc4RQdwTGVJUZCPKKKtQWkb3TnfyvH+kz9OmgyZtkifj9/188oEmT57cSZv2ynVf93UrBEEQQEREROTilHIPgIiIiMgeMCgiIiIiAoMiIiIiIgAMioiIiIgAMCgiIiIiAsCgiIiIiAgAgyIiIiIiAAyKiIiIiAAwKCIiIiICwKCIyEhMTAzmzp1rsfMtWbIECoXCYudzdNdeey2uvfZai54zKysLCoUCa9euteh5uyI9PR0KhQKffvqp3EPpFPE1Xb58udxDsYq1a9dCoVDgwIEDcg+F7AyDInIov/32G5YsWYLS0lK5h0I2tn79eqxcuVLuYRixxzERUee5yT0AInP89ttveP755zF37lwEBARY/PwnT56EUsnPCvZo/fr1OHr0KJ544gmj63v27Inq6mq4u7vbzZiIyDHxtz85Lb1ej5qaGrPuo9FoZPnjSp2nUCjg4eEBlUol91AspqqqSu4hELkkBkXkMJYsWYKnn34aABAbGwuFQgGFQoGsrCwAhj+O8+fPx0cffYQBAwZAo9Fg8+bNAIDly5fj6quvRnBwMDw9PTFs2LA26z1a1hSJtQe7du1CamoqQkND4e3tjVtvvRUFBQWdeh4NDQ1YunQp4uLioNFoEBMTg2effRa1tbVGxx04cACTJk1CSEgIPD09ERsbi3vvvdfomA0bNmDYsGHw9fWFn58fBg0ahNdff73DMej1eqxcuRIDBgyAh4cHwsPD8dBDD6GkpEQ65uabb0avXr3avP+YMWMwfPhws59TS+LrK34PRWJNTnp6OgBDLdJ3332H8+fPS9/3mJgYAO3XFP30008YN24cvL29ERAQgGnTpiEjI8PoGLHm68yZM1L20d/fHykpKR0GJlcak0iv1+Of//wnunfvDg8PD0yYMAFnzpxpdZ6BAwfi4MGDGD9+PLy8vPDss88CAPLz83HfffchPDwcHh4eGDJkCD788MMrvlai9l6XTZs2oX///vDw8MDAgQPxxRdfYO7cua3GLnr33Xel7+uIESOwf//+K74uotLSUjzxxBOIjo6GRqNBfHw8Xn75Zej1+lZjXL58OV577TX07NkTnp6eSEpKwtGjR1ud05TvKQBcvHgR9913H6KioqDRaBAbG4uHH34YdXV1RsfV1tZ2+L425X1IzoPTZ+QwbrvtNpw6dQoff/wxXnvtNYSEhAAAQkNDpWN++uknfPLJJ5g/fz5CQkKkX/Svv/46brnlFsyaNQt1dXXYsGED7rzzTnz77be46aabOnzsRx99FIGBgVi8eDGysrKwcuVKzJ8/Hxs3bjT7edx///348MMPcccdd+Cpp57C3r17kZaWhoyMDHzxxRcADH8MJ06ciNDQUPz9739HQEAAsrKy8Pnnn0vn2bp1K+6++25MmDABL7/8MgAgIyMDu3btwuOPP37FMTz00ENYu3YtUlJS8Nhjj+HcuXN466238Pvvv2PXrl1wd3fHjBkzMHv2bOzfvx8jRoyQ7nv+/Hns2bMHy5YtM+s5dcU//vEPlJWV4cKFC3jttdcAAD4+Pu0ev23bNkyZMgW9evXCkiVLUF1djTfffBNjx47FoUOHWgUAd911F2JjY5GWloZDhw7h/fffR1hYmPS6dnZML730EpRKJRYsWICysjK88sormDVrFvbu3Wt0XFFREaZMmYKZM2fiL3/5C8LDw1FdXY1rr70WZ86cwfz58xEbG4tNmzZh7ty5KC0t7fB73JbvvvsOM2bMwKBBg5CWloaSkhLcd9996NatW5vHr1+/HhUVFXjooYegUCjwyiuv4LbbbsPZs2evmFGtqqpCUlISLl68iIceegg9evTAb7/9hoULF+Ly5cut6rDWrVuHiooKzJs3DzU1NXj99ddx/fXX48iRIwgPDwdg+vf00qVLGDlyJEpLS/Hggw+iX79+uHjxIj799FNUVVVBrVZLj9vR+9qU9yE5GYHIgSxbtkwAIJw7d67VbQAEpVIpHDt2rNVtVVVVRl/X1dUJAwcOFK6//nqj63v27CnMmTNH+nrNmjUCACE5OVnQ6/XS9U8++aSgUqmE0tLSK4538eLFQvO32eHDhwUAwv3332903IIFCwQAwk8//SQIgiB88cUXAgBh//797Z778ccfF/z8/ISGhoYrjqGlX375RQAgfPTRR0bXb9682ej6srIyQaPRCE899ZTRca+88oqgUCiE8+fPm/WcBEEQkpKShKSkJOlr8fVt+f3csWOHAEDYsWOHdN1NN90k9OzZs9XzOXfunABAWLNmjXRdYmKiEBYWJhQVFUnX/fHHH4JSqRRmz54tXSd+f+69916jc956661CcHBwq8dqqb0xieNPSEgQamtrpetff/11AYBw5MgR6bqkpCQBgLB69Wqjc6xcuVIAIPz3v/+VrqurqxPGjBkj+Pj4COXl5UaP1fy1au91GTRokNC9e3ehoqJCui49PV0AYPQ8xPsGBwcLxcXF0vVfffWVAED45ptvrvi6LF26VPD29hZOnTpldP3f//53QaVSCdnZ2UaP4+npKVy4cEE6bu/evQIA4cknn5SuM/V7Onv2bEGpVLb53hHfw6a+r015H5Jz4fQZOZWkpCT079+/1fWenp7S/0tKSlBWVoZx48bh0KFDJp33wQcfNFpaP27cOOh0Opw/f96s8X3//fcAgNTUVKPrn3rqKQCGT/IApCLyb7/9FvX19W2eKyAgAFqtFlu3bjVrDJs2bYK/vz9uuOEGFBYWSpdhw4bBx8cHO3bsAAD4+flhypQp+OSTTyAIgnT/jRs3YvTo0ejRo4dZz8lWLl++jMOHD2Pu3LkICgqSrh88eDBuuOEGabzN/fWvfzX6ety4cSgqKkJ5eXmXxpKSkmKUmRg3bhwA4OzZs0bHaTQapKSkGF33/fffIyIiAnfffbd0nbu7Ox577DFUVlZi586dZo3l0qVLOHLkCGbPnm2U0UpKSsKgQYPavM+MGTMQGBjY4fhb2rRpE8aNG4fAwECjn7Hk5GTodDr8/PPPRsdPnz7dKFs1cuRIjBo1Svpemfo91ev1+PLLLzF16lSj6V1Ry/YYHb2vTXkfknNhUEROJTY2ts3rv/32W4wePRoeHh4ICgpCaGgo3nnnHZSVlZl0XjEAEIl/KJrX4Jji/PnzUCqViI+PN7o+IiICAQEB0i/jpKQk3H777Xj++ecREhKCadOmYc2aNUY1Oo888gj69OmDKVOmoHv37rj33nulGqorOX36NMrKyhAWFobQ0FCjS2VlJfLz86VjZ8yYgZycHOzevRsAkJmZiYMHD2LGjBlmPydbER+vb9++rW5LSEhAYWEhtFqt0fWW+v62ZOp5u3XrZhQ8AYbn0bt371arIRMSEqTbzSEe3/L71N51QOdfl9OnT2Pz5s2tfr6Sk5MBwOhnDAB69+7d6hx9+vSRas1M/Z4WFBSgvLwcAwcOvOL4TH1+prwPybmwpoicSvOMkOiXX37BLbfcgvHjx+Ptt99GZGQk3N3dsWbNGqxfv96k87a3sql5BsUcHTV0FBv/7dmzB9988w1+/PFH3HvvvXj11VexZ88e+Pj4ICwsDIcPH8aPP/6IH374AT/88APWrFmD2bNntyrGbU6v1yMsLAwfffRRm7c3r9GaOnUqvLy88Mknn+Dqq6/GJ598AqVSiTvvvNPs59Te82yLTqcz+1xdYenvr7nnbevn1lTWfA07+7ro9XrccMMNeOaZZ9q8vU+fPl0emyV09PxMeR+Sc2FQRA6lM394P/vsM3h4eODHH3+ERqORrl+zZo0lh2aSnj17Qq/X4/Tp09InfgDIy8tDaWkpevbsaXT86NGjMXr0aPzzn//E+vXrMWvWLGzYsAH3338/AECtVmPq1KmYOnUq9Ho9HnnkEfz73//Gc8891+6n/7i4OGzbtg1jx47t8I+xt7c3br75ZmzatAkrVqzAxo0bMW7cOERFRXX6OTUnfjJv2YyzrSyIqd978fFOnjzZ6rYTJ04gJCQE3t7eJp2rI9bsVt6zZ0/8+eef0Ov1RtmiEydOSLcDpr+G4vEtV7+1d11XxMXFobKyUsoMdeT06dOtrjt16pRUPG3q99TT0xN+fn5trlzrio7eh+Q8OH1GDkX8Y2ZOR2uVSgWFQmH0yTkrKwtffvmlhUfXsRtvvBEAWq2+WbFiBQBIK+FKSkpafRpPTEwEACl1X1RUZHS7UqnE4MGDjY5py1133QWdToelS5e2uq2hoaHVaztjxgxcunQJ77//Pv744w+jqTNznlNb4uLiAMCoxkSn0+Hdd99tday3t7dJ052RkZFITEzEhx9+aPRcjh49ii1btkjjtQRTx9QZN954I3Jzc41WODY0NODNN9+Ej48PkpKSABgCBpVK1apO5+233zb6OioqCgMHDsS6detQWVkpXb9z504cOXLEomO/6667sHv3bvz444+tbistLUVDQ4PRdV9++SUuXrwofb1v3z7s3bsXU6ZMAWD691SpVGL69On45ptv2tzCw9zMnynvQ3IuzBSRQxk2bBgAw3LomTNnwt3dHVOnTr3iJ/+bbroJK1aswOTJk3HPPfcgPz8fq1atQnx8PP78809bDR0AMGTIEMyZMwfvvvsuSktLkZSUhH379uHDDz/E9OnTcd111wEAPvzwQ7z99tu49dZbERcXh4qKCrz33nvw8/OT/gDcf//9KC4uxvXXX4/u3bvj/PnzePPNN5GYmGiUsWkpKSkJDz30ENLS0nD48GFMnDgR7u7uOH36NDZt2oTXX38dd9xxh3T8jTfeCF9fXyxYsAAqlQq33357p55TWwYMGIDRo0dj4cKFKC4uRlBQEDZs2NDqjyZg+N5v3LgRqampGDFiBHx8fDB16tQ2z7ts2TJMmTIFY8aMwX333Sct3/b398eSJUvaHY+5zBmTuR588EH8+9//xty5c3Hw4EHExMTg008/xa5du7By5Ur4+voCAPz9/XHnnXfizTffhEKhQFxcHL799ttWdTsA8K9//QvTpk3D2LFjkZKSgpKSErz11lsYOHCgUaDUVU8//TS+/vpr3HzzzZg7dy6GDRsGrVaLI0eO4NNPP0VWVpbUUgMw1DRdc801ePjhh1FbW4uVK1ciODjYaPrN1O/pv/71L2zZsgVJSUl48MEHkZCQgMuXL2PTpk349ddfzeqEb8r7kJyMbOveiDpp6dKlQrdu3QSlUmm0nBuAMG/evDbv83//939C7969BY1GI/Tr109Ys2ZNq+XygtD+kvyWS3LbWwbdUluPUV9fLzz//PNCbGys4O7uLkRHRwsLFy4UampqpGMOHTok3H333UKPHj0EjUYjhIWFCTfffLNw4MAB6ZhPP/1UmDhxohAWFiao1WqhR48ewkMPPSRcvnz5imMSvfvuu8KwYcMET09PwdfXVxg0aJDwzDPPCJcuXWp17KxZs6QlzG0x5TkJQusl+YIgCJmZmUJycrKg0WiE8PBw4dlnnxW2bt3a6vWtrKwU7rnnHiEgIMBoCXlbS88FQRC2bdsmjB07VvD09BT8/PyEqVOnCsePHzc6Rvz+FBQUGF3fXquAltobk/jzsWnTJqPj2xprUlKSMGDAgDbPn5eXJ6SkpAghISGCWq0WBg0a1Op5CoIgFBQUCLfffrvg5eUlBAYGCg899JBw9OjRNl+XDRs2CP369RM0Go0wcOBA4euvvxZuv/12oV+/fq3GuWzZslaPBUBYvHjxFV8XQRCEiooKYeHChUJ8fLygVquFkJAQ4eqrrxaWL18u1NXVtXqcV199VYiOjhY0Go0wbtw44Y8//mh1TlO+p4IgCOfPnxdmz54thIaGChqNRujVq5cwb948qT2Cqe9rU96H5FwUgtDFSkIiInJoiYmJCA0NNbu9Q1dlZWUhNjYWy5Ytw4IFC2z62ERtYU0REZGLqK+vbzU1mZ6ejj/++APXXnutPIMisiOsKSIichEXL15EcnIy/vKXvyAqKgonTpzA6tWrERER0aqBJZErYlBEROQiAgMDMWzYMLz//vsoKCiAt7c3brrpJrz00ksIDg6We3hEsmNNERERERFYU0REREQEgEEREREREQDWFLVJr9fj0qVL8PX1tWobfyIiIrIcQRBQUVGBqKioVpspm4JBURsuXbqE6OhouYdBREREnZCTk4Pu3bubfT8GRW0Q2+fn5OTAz89P5tEQERGRKcrLyxEdHS39HTcXg6I2iFNmfn5+DIqIiIgcTGdLX1hoTURERAQGRUREREQAGBQRERERAWBNUZfodDrU19fLPQwyk1qt7tRSTSIicm4MijpBEATk5uaitLRU7qFQJyiVSsTGxkKtVss9FCIisiMMijpBDIjCwsLg5eXFBo8ORGzMefnyZfTo0YPfOyIikjAoMpNOp5MCIu4q7ZhCQ0Nx6dIlNDQ0wN3dXe7hEBGRnWBhhZnEGiIvLy+ZR0KdJU6b6XQ6mUdCRET2hEFRJ3HaxXHxe0dERG1hUEREREQEBkXUSTExMVi5cqXs5yAiIrIUFlq7iGuvvRaJiYkWC0L2798Pb29vi5yLiIjIHjAosiG9XkCDXg+FQgF3lf0l6QRBgE6ng5tbxz8WoaGhNhgRERGR7djfX2Ynll9RixO5Fcgvr7Hp486dOxc7d+7E66+/DoVCAYVCgaysLKSnp0OhUOCHH37AsGHDoNFo8OuvvyIzMxPTpk1DeHg4fHx8MGLECGzbts3onC2nvhQKBd5//33ceuut8PLyQu/evfH111+bNc7s7GxMmzYNPj4+8PPzw1133YW8vDzp9j/++APXXXcdfH194efnh2HDhuHAgQMAgPPnz2Pq1KkIDAyEt7c3BgwYgO+//77zLxoREbkcZoosQBAEVNd3vLy7vkGPmnodKmoaUFXX0OXH9XRXmbSS6vXXX8epU6cwcOBAvPDCCwAMmZ6srCwAwN///ncsX74cvXr1QmBgIHJycnDjjTfin//8JzQaDdatW4epU6fi5MmT6NGjR7uP8/zzz+OVV17BsmXL8Oabb2LWrFk4f/48goKCOhyjXq+XAqKdO3eioaEB8+bNw4wZM5Ceng4AmDVrFq666iq88847UKlUOHz4sNRnaN68eairq8PPP/8Mb29vHD9+HD4+Ph0+LhERkYhBkQVU1+vQf9GPNn/c4y9Mgpe642+hv78/1Go1vLy8EBER0er2F154ATfccIP0dVBQEIYMGSJ9vXTpUnzxxRf4+uuvMX/+/HYfZ+7cubj77rsBAP/617/wxhtvYN++fZg8eXKHY9y+fTuOHDmCc+fOITo6GgCwbt06DBgwAPv378eIESOQnZ2Np59+Gv369QMA9O7dW7p/dnY2br/9dgwaNAgA0KtXrw4fk4iIqDlOnxGGDx9u9HVlZSUWLFiAhIQEBAQEwMfHBxkZGcjOzr7ieQYPHiz939vbG35+fsjPzzdpDBkZGYiOjpYCIgDo378/AgICkJGRAQBITU3F/fffj+TkZLz00kvIzMyUjn3sscfw4osvYuzYsVi8eDH+/PNPkx6XiIhIxEyRBXi6q3D8hUkdHldV14CzBVq4q5ToG+Frkce1hJaryBYsWICtW7di+fLliI+Ph6enJ+644w7U1dVd8Twtt8xQKBTQ6/UWGSMALFmyBPfccw++++47/PDDD1i8eDE2bNiAW2+9Fffffz8mTZqE7777Dlu2bEFaWhpeffVVPProoxZ7fCIicm4MiixAoVCYNI2lUirg4a6C0sTjLUmtVpu8rcWuXbswd+5c3HrrrQAMmSOx/shaEhISkJOTg5ycHClbdPz4cZSWlqJ///7ScX369EGfPn3w5JNP4u6778aaNWukcUZHR+Ovf/0r/vrXv2LhwoV47733GBQREZHJ7GL6bNWqVYiJiYGHhwdGjRqFffv2tXvs559/juHDhyMgIADe3t5ITEzEf/7zH6NjBEHAokWLEBkZCU9PTyQnJ+P06dPWfhodUikNRdF6QYBeL9j0sWNiYrB3715kZWWhsLDwihmc3r174/PPP8fhw4fxxx9/4J577rFoxqctycnJGDRoEGbNmoVDhw5h3759mD17NpKSkjB8+HBUV1dj/vz5SE9Px/nz57Fr1y7s378fCQkJAIAnnngCP/74I86dO4dDhw5hx44d0m1ERESmkD0o2rhxI1JTU7F48WIcOnQIQ4YMwaRJk9qtRQkKCsI//vEP7N69G3/++SdSUlKQkpKCH39sKnR+5ZVX8MYbb2D16tXYu3cvvL29MWnSJNTU2HYpfEsqhQIKGAIjnY2DogULFkClUqF///4IDQ29Yn3QihUrEBgYiKuvvhpTp07FpEmTMHToUKuOT6FQ4KuvvkJgYCDGjx+P5ORk9OrVCxs3bgQAqFQqFBUVYfbs2ejTpw/uuusuTJkyBc8//zwAw+au8+bNQ0JCAiZPnow+ffrg7bfftuqYiYjIuSgEQbDtX+cWRo0ahREjRuCtt94CYFiaHR0djUcffRR///vfTTrH0KFDcdNNN2Hp0qUQBAFRUVF46qmnsGDBAgBAWVkZwsPDsXbtWsycObPD85WXl8Pf3x9lZWXw8/Mzuq2mpgbnzp1DbGwsPDw8zHy2wPFL5WjQ69E7zBeeasvUBJF5uvo9JCIi+3Slv9+mkDVTVFdXh4MHDyI5OVm6TqlUIjk5Gbt37+7w/oIgYPv27Th58iTGjx8PADh37hxyc3ONzunv749Ro0a1e87a2lqUl5cbXaxFnELTWXk6ioiIiMwja1BUWFgInU6H8PBwo+vDw8ORm5vb7v3Kysrg4+MDtVqNm266CW+++abUZ0e8nznnTEtLg7+/v3Rpvizc0tyU8kyfERER0ZXJXlPUGb6+vjh8+DD279+Pf/7zn0hNTZW6HnfGwoULUVZWJl1ycnIsN9gWxExRA4MiIiIiuyLrkvyQkBCoVCqj/a0AIC8vr83OyyKlUon4+HgAQGJiIjIyMpCWloZrr71Wul9eXh4iIyONzpmYmNjm+TQaDTQaTRefjWmYKSIiIrJPsmaK1Go1hg0bhu3bt0vX6fV6bN++HWPGjDH5PHq9HrW1tQCA2NhYREREGJ2zvLwce/fuNeucHelsfbpKxUyR3GReW0BERHZK9uaNqampmDNnDoYPH46RI0di5cqV0Gq1SElJAQDMnj0b3bp1Q1paGgBD/c/w4cMRFxeH2tpafP/99/jPf/6Dd955B4BhafcTTzyBF198Eb1790ZsbCyee+45REVFYfr06V0er9i1uaqqCp6enmbfX8VMkezEztwqFVf/ERFRE9mDohkzZqCgoACLFi1Cbm4uEhMTsXnzZqlQOjs7G0plU0JLq9XikUcewYULF+Dp6Yl+/frhv//9L2bMmCEd88wzz0Cr1eLBBx9EaWkprrnmGmzevNkiy69VKhUCAgKkPkpeXl4m7VQv0tfXQWioQ12tHjU1DlnS5dD0ej0KCgrg5eUFNzfZf/yJiMiOyN6nyB511OdAEATk5uaitLTU7HNX1+lQpK2Dxk2JUF/b1DGRMaVSidjYWKjVarmHQkREFtTVPkX8qNwJCoUCkZGRCAsLQ319vVn3/SOnBEu+/QPdAr2w7t6RVhohXYlarTbKPhIREQEMirpEpVKZXZcS6OeDixU6aHU17KZMRERkR/hx2cYCvAyF2mXV9Sy2JiIisiMMimwswNNQxyIIQHm1eVNvREREZD0MimxM7aaEj8Ywa1lSVSfzaIiIiEjEoEgG4hRaSRUzRURERPaCQZEMAr0MU2ilzBQRERHZDQZFMmCmiIiIyP4wKJIBM0VERET2h0GRDAKlTBGDIiIiInvBoEgGAY2ZIk6fERER2Q8GRTIQM0WcPiMiIrIfDIpkEOjdmCnSMlNERERkLxgUyaBp+oyZIiIiInvBoEgGTdNnzBQRERHZCwZFMghkpoiIiMjuMCiSgdi8sbZBj+o6ncyjISIiIoBBkSx8NG5wUyoAMFtERERkLxgUyUChULDYmoiIyM4wKJIJi62JiIjsC4MimbDYmoiIyL4wKJJJgLT/GTNFRERE9oBBkUzETFGplpkiIiIie8CgSCYB3swUERER2RMGRTKRMkWsKSIiIrILDIpkEijVFDEoIiIisgcMimTS1KeI02dERET2gEGRTDh9RkREZF8YFMkkkEvyiYiI7AqDIpmI02flNfXQ6QWZR0NEREQMimQiNm8UBKCsmtkiIiIiuTEokom7SglfjRsArkAjIiKyBwyKZCQ2cGSxNRERkfwYFMlI2hRWy+kzIiIiuTEoklFTryJmioiIiOTGoEhG4rL8Ui7LJyIikh2DIhkFMlNERERkNxgUySiADRyJiIjsBoMiGXGrDyIiIvvBoEhGTZkiBkVERERyY1Ako6ZMEafPiIiI5MagSEYstCYiIrIfDIpkFOjdVGgtCNwUloiISE52ERStWrUKMTEx8PDwwKhRo7Bv3752j33vvfcwbtw4BAYGIjAwEMnJya2Onzt3LhQKhdFl8uTJ1n4aZhMzRXUNelTX62QeDRERkWuTPSjauHEjUlNTsXjxYhw6dAhDhgzBpEmTkJ+f3+bx6enpuPvuu7Fjxw7s3r0b0dHRmDhxIi5evGh03OTJk3H58mXp8vHHH9vi6ZjFS62CWmX4FnBZPhERkbxkD4pWrFiBBx54ACkpKejfvz9Wr14NLy8vfPDBB20e/9FHH+GRRx5BYmIi+vXrh/fffx96vR7bt283Ok6j0SAiIkK6BAYG2uLpmEWhUDStQNOyroiIiEhOsgZFdXV1OHjwIJKTk6XrlEolkpOTsXv3bpPOUVVVhfr6egQFBRldn56ejrCwMPTt2xcPP/wwioqKLDp2S+EKNCIiIvvgJueDFxYWQqfTITw83Oj68PBwnDhxwqRz/O1vf0NUVJRRYDV58mTcdtttiI2NRWZmJp599llMmTIFu3fvhkqlanWO2tpa1NbWSl+Xl5d38hmZj72KiIiI7IOsQVFXvfTSS9iwYQPS09Ph4eEhXT9z5kzp/4MGDcLgwYMRFxeH9PR0TJgwodV50tLS8Pzzz9tkzC2xqzUREZF9kHX6LCQkBCqVCnl5eUbX5+XlISIi4or3Xb58OV566SVs2bIFgwcPvuKxvXr1QkhICM6cOdPm7QsXLkRZWZl0ycnJMe+JdEHzZflEREQkH1mDIrVajWHDhhkVSYtF02PGjGn3fq+88gqWLl2KzZs3Y/jw4R0+zoULF1BUVITIyMg2b9doNPDz8zO62EoAGzgSERHZBdlXn6WmpuK9997Dhx9+iIyMDDz88MPQarVISUkBAMyePRsLFy6Ujn/55Zfx3HPP4YMPPkBMTAxyc3ORm5uLyspKAEBlZSWefvpp7NmzB1lZWdi+fTumTZuG+Ph4TJo0SZbneCWBjTVFLLQmIiKSl+w1RTNmzEBBQQEWLVqE3NxcJCYmYvPmzVLxdXZ2NpTKptjtnXfeQV1dHe644w6j8yxevBhLliyBSqXCn3/+iQ8//BClpaWIiorCxIkTsXTpUmg0Gps+N1MwU0RERGQfFAL3l2ilvLwc/v7+KCsrs/pU2tbjeXhg3QEMiQ7AV/PGWvWxiIiInFlX/37LPn3m6pqmz5gpIiIikhODIplJ02fsaE1ERCQrBkUyEzNF5TUNaNDpZR4NERGR62JQJDN/T3fp/6XVXIFGREQkFwZFMnNTKeHnYVgEyLoiIiIi+TAosgOB3uKyfGaKiIiI5MKgyA6w2JqIiEh+DIrsALtaExERyY9BkR0IZFdrIpdWr9Njx8l8lNfwgxGRnBgU2YGAxkwRa4qIXNM3f1xCypr9ePXHk3IPhcilMSiyA2KmiKvPiFzTuUItAOBMQaXMIyFybQyK7ECglCliUETkiooaF1nkldfKPBIi18agyA5Iq884fUbkkkqkoKhG5pEQuTYGRXaA02dErk3MFFXUNKC6TifzaIhcF4MiO8BCayLXVtysR1l+BbNFRHJhUGQHxI7WpVV1EARB5tEQka01b9zKuiIi+TAosgNioXW9ToCWqXMil6LXC0aLLFhXRCQfBkV2wNNdBbWb4VvBrT6IXEtpdT30zRLE+RXMFBHJhUGRHVAoFNzqg8hFFbf4IJTPTBGRbBgU2Qlu9UHkmloGRZw+I5IPgyI7EcAGjkQuqXVQxOkzIrkwKLITTb2KOH1G5ErEoMhH4waAS/KJ5MSgyE4EcPqMyCUVaw2ZoX4RvgCAfGaKiGTDoMhOsNCayDUVaw3v+YRIPwBARW0DtLUNcg6JyGUxKLITLLQmck1ipig6yBNeahUALssnkguDIjvBrT6IXJO471mQtwbhfh4AuCyfSC4MiuwEN4Ulck1idjjYW40wXw0AII+ZIiJZMCiyE4HeXJJP5IqKKw3v+UBvNTNFRDJjUGQnxNVnpVpOnxG5CkEQpOkzo0wRgyIiWTAoshPi9FlFbQPqdXqZR0NEtlBdr0Ntg+H9HtQ8U8TpMyJZMCiyE/6e7lAoDP/nsnwi11DUOHWmdlPCS61CmB8zRURyYlBkJ1RKBfw8xF5FrCsicgXFzabOFApFs5oiZoqI5MCgyI4Eclk+kUspbvwAJE6fs6aISF4MiuwIt/ogci3iyrNgn8agqDFTpK3ToZJdrYlsjkGRHWna6oNBEZErKJYaNxqCIh+NW9PGsMwWEdkcgyI70rTVB6fPiFxBy+kzAM2KrVlXRGRrDIrsSKA3p8+IXIk0febdLChqrCvKr2CmiMjWGBTZEWn6jA0ciVyCmCkK8mkKirgCjUg+DIrsCAutiVyLVFPk1Too4go0IttjUGRHmjaFZaaIyBW0LLQGwE1hiWTEoMiONPUpYqaIyBVIzRt9mhdaM1NEJBcGRXYkgKvPiFxGvU6PsmrDe7356rPwxkxRATNFRDbHoMiOBHo39SkSBEHm0RCRNYkZYYWi6QMRYFxTxN8DRLbFoMiOiJ8WG/QCu9kSObkSbVOWSKVUSNeLfYqq2NWayObsIihatWoVYmJi4OHhgVGjRmHfvn3tHvvee+9h3LhxCAwMRGBgIJKTk1sdLwgCFi1ahMjISHh6eiI5ORmnT5+29tPoMg93FTzcDd8SFlsTObcirWF6TKwlFHmp3eDb2NWaDRyJbEv2oGjjxo1ITU3F4sWLcejQIQwZMgSTJk1Cfn5+m8enp6fj7rvvxo4dO7B7925ER0dj4sSJuHjxonTMK6+8gjfeeAOrV6/G3r174e3tjUmTJqGmxv4LFwO5LJ/IJUhF1t6aVreJ2SI2cCSyLdmDohUrVuCBBx5ASkoK+vfvj9WrV8PLywsffPBBm8d/9NFHeOSRR5CYmIh+/frh/fffh16vx/bt2wEYskQrV67E//7v/2LatGkYPHgw1q1bh0uXLuHLL7+04TPrHBZbE7mGkjaW44vYwJFIHrIGRXV1dTh48CCSk5Ol65RKJZKTk7F7926TzlFVVYX6+noEBQUBAM6dO4fc3Fyjc/r7+2PUqFHtnrO2thbl5eVGF7lwU1gi11DUGBQFXiEo4rJ8ItuSNSgqLCyETqdDeHi40fXh4eHIzc016Rx/+9vfEBUVJQVB4v3MOWdaWhr8/f2lS3R0tLlPxWKk6TMtgyIiZ9Y0fdY6KJIaODJTRGRTsk+fdcVLL72EDRs24IsvvoCHh0enz7Nw4UKUlZVJl5ycHAuO0jwBUgNHTp8RObPiK2SKxAaOrCkisi03OR88JCQEKpUKeXl5Rtfn5eUhIiLiivddvnw5XnrpJWzbtg2DBw+Wrhfvl5eXh8jISKNzJiYmtnkujUYDjaZ1saMcmrb6YKaIyJldKVMULhZaM1NEZFOyZorUajWGDRsmFUkDkIqmx4wZ0+79XnnlFSxduhSbN2/G8OHDjW6LjY1FRESE0TnLy8uxd+/eK57TXjBTROQa2tr3TCTVFDFTRGRTsmaKACA1NRVz5szB8OHDMXLkSKxcuRJarRYpKSkAgNmzZ6Nbt25IS0sDALz88stYtGgR1q9fj5iYGKlOyMfHBz4+PlAoFHjiiSfw4osvonfv3oiNjcVzzz2HqKgoTJ8+Xa6naTIuySdyDVcKippqigxdrRUKRatjiMjyZA+KZsyYgYKCAixatAi5ublITEzE5s2bpULp7OxsKJVNCa133nkHdXV1uOOOO4zOs3jxYixZsgQA8Mwzz0Cr1eLBBx9EaWkprrnmGmzevLlLdUe20rTVBzNFRM5KEATpg0/bQZHhd1VNvR4VtQ3w83BvdQwRWZ7sQREAzJ8/H/Pnz2/ztvT0dKOvs7KyOjyfQqHACy+8gBdeeMECo7OtAGaKiJxeRW0D6nWGfc3aCoo81Sr4ebihvKYB+eU1DIqIbMShV585o6ZCa2aKiJxVcaXhQ4+XWgUPd1WbxzT1KmKxNZGtMCiyM2LzxsraBtQ16GUeDRFZQ9EV6olE4lYfbOBIZDsMiuyMn4c7xA2zS6s5hUbkjEqusBxfFO4r9ipipojIVhgU2RmlUgF/TxZbEzmzKzVuFIVxqw8im2NQZIfEuqJibvVB5JRMmT5jA0ci22NQZIcCuCkskVMTV5deafpMXJbPTBGR7TAoskNNDRw5fUbkjIoqO54+kzJFrCkishkGRXaIvYqInFux1hDoXLHQullNkSAINhkXkatjUGSHAr1YaE3kzIob39tB3u1vRB3auNVHbYMe5dUNNhkXkatjUGSHxJR6CQutiZySmCkK8m6/U7WHu0paicqNYYlsg0GRHRILrVlTROScxI7WV8oUAVyBRmRrDIrsUNNWH8wUETmbmnodtHU6AECQV/s1RYBxXRERWR+DIjvUlCliUETkbMT3tZtSAT/PK+/JLS3L5/QZkU2YHRRt3rwZv/76q/T1qlWrkJiYiHvuuQclJSUWHZyr4qawRM6reTdrhUJxxWPDOH1GZFNmB0VPP/00ysvLAQBHjhzBU089hRtvvBHnzp1DamqqxQfoiqSgqLqeS3GJnIwYFHU0dQYA4b5iryJmiohs4cq52zacO3cO/fv3BwB89tlnuPnmm/Gvf/0Lhw4dwo033mjxAboicfpMpxdQXtMgrUAhIsdXbMIWH6KmmiJmiohswexMkVqtRlVVFQBg27ZtmDhxIgAgKChIyiBR13i4q+DprgLAYmsiZyMFRT4dB0XcFJbItszOFF1zzTVITU3F2LFjsW/fPmzcuBEAcOrUKXTv3t3iA3RVgV7uqC7ToaSqHj2D5R4NEVmKOdNnYb5NNUWCIHRYg0REXWN2puitt96Cm5sbPv30U7zzzjvo1q0bAOCHH37A5MmTLT5AV8WtPoicU5EZ02dioXWdTo+yai68ILI2szNFPXr0wLffftvq+tdee80iAyKDQG9xqw8GRUTOROxUH2zC9JnGTYVAL3eUVNUjr7xW+rBERNZhdqbo0KFDOHLkiPT1V199henTp+PZZ59FXR3/gFuKlCnS8tMhkTMRM0WBJgY4bOBIZDtmB0UPPfQQTp06BQA4e/YsZs6cCS8vL2zatAnPPPOMxQfoqpo2hWWgSeRMxJqiYBOmz4CmjWEZFBFZn9lB0alTp5CYmAgA2LRpE8aPH4/169dj7dq1+Oyzzyw9PpcVKNUUMVNE5ExKzFh9BjRlivIruCyfyNrMDooEQYBerwdgWJIv9iaKjo5GYWGhZUfnwlhoTeR89HpBek+bsvoMaL4pLDNFRNZmdlA0fPhwvPjii/jPf/6DnTt34qabbgJgaOoYHh5u8QG6qqbpM2aKiJxFaXU99I1N6gNNnD5jA0ci2zE7KFq5ciUOHTqE+fPn4x//+Afi4+MBAJ9++imuvvpqiw/QVQUyU0TkdMR6Ij8PN7irTPv1y01hiWzH7CX5gwcPNlp9Jlq2bBlUKpVFBkVNW30wU0TkPMzZ4kPETWGJbMfsoEh08OBBZGRkAAD69++PoUOHWmxQxEwRkTMq1hoCG3OCoqZC6xp2tSayMrODovz8fMyYMQM7d+5EQEAAAKC0tBTXXXcdNmzYgNDQUEuP0SWJ9QZVdTrUNuigcWMWjsjRFTf2HTMnKAr1MWSK6nUCSqrqzbovEZnH7JqiRx99FJWVlTh27BiKi4tRXFyMo0ePory8HI899pg1xuiS/DzcoFIaPhFyCo3IOXQmU6R2U0o9jdiriMi6zA6KNm/ejLfffhsJCQnSdf3798eqVavwww8/WHRwrkyhUCDA01BXxCk0IufQlCnSmHU/sYEjexURWZfZQZFer4e7u3ur693d3aX+RWQZYrE1t/ogcg5NmaLWv0OvhFt9ENmG2UHR9ddfj8cffxyXLl2Srrt48SKefPJJTJgwwaKDc3VisTW3+iByDkXS6jPzMkVs4Ehyu1BSheQVO/Gf3VlyD8WqzA6K3nrrLZSXlyMmJgZxcXGIi4tDbGwsysvL8eabb1pjjC4rgFt9EDkVcSrc1H3PRGzgSHLbcSIfZ/Ir8cmBC3IPxarMXn0WHR2NQ4cOYdu2bThx4gQAICEhAcnJyRYfnKsTu1qzpojIORRXGt7LpnazFoVJNUXMFJE8zhdVAQBySqpkHol1dapPkUKhwA033IAbbrjB0uOhZsRfnJw+I3J8giBI02fmZorCmCkimZ0vNgRDpVX1qKiph6+HeXVxjsKkoOiNN94w+YRclm85UqE1p8+IHF51vQ61DYbFKOb2GpIaOLKmiGSSXdSUIcoprkb/KBcOil577TWTTqZQKBgUWRALrYmcR1Hj1JnaTQkvtXnNWKVC64pa6PUClEp2tSbbEQQB2cXNgqKSKvSP8pNxRNZjUlB07tw5a4+D2hDITBGR0yhuNnVm7lYdIT4aKBRAg15ASVUdgn3MW71G1BUFFbWortdJX+cUO29dkdmrz8h2Arj/GZHTKK4yfzNYkbuqeVdr1hWRbZ1vEQRdKKmWaSTWx6DIjjVNnzFTROToxJVnnd27LMy3sdiaK9DIxs4XGQdFzBSRLMTps9KqOuj1gsyjIaKuKNZ2LShiA0eSS3aRFgDQPdATgHMvy2dQZMfE6TO9AFTUNMg8GiLqiq5MnwFNmaJ8Tp+RjYnTZ9fEhwAwrD4TBOf8oM6gyI6p3ZTwblylwroiIscmTZ95dS1TxOkzsjVx+mxMXDAUCkN7CbHnlrPpVFBUWlqKLVu24L///S/WrVtndDHXqlWrEBMTAw8PD4waNQr79u1r99hjx47h9ttvR0xMDBQKBVauXNnqmCVLlkChUBhd+vXrZ/a47AWLrYmcg7TvmU8nM0Vs4EgyEZfjx4f5ILwxY+msdUVmd7T+5ptvMGvWLFRWVsLPz89oaalCocDs2bNNPtfGjRuRmpqK1atXY9SoUVi5ciUmTZqEkydPIiwsrNXxVVVV6NWrF+688048+eST7Z53wIAB2LZtm/S1m1unGnfbhUBvd1wsrWaxNZGDEz/YdD5TxAaOZHsVNfVSPVzPYG/0CPJCbnkNckqqcVWPQJlHZ3lmZ4qeeuop3HvvvaisrERpaSlKSkqkS3FxsVnnWrFiBR544AGkpKSgf//+WL16Nby8vPDBBx+0efyIESOwbNkyzJw5ExpN+3063NzcEBERIV1CQkLMGpc9CWSmiMgpdLXQumn/M2aKyHbEqbNgbzV8NG7oHtRYbO2kmSKzg6KLFy/iscceg5eXV5ceuK6uDgcPHjTaSFapVCI5ORm7d+/u0rlPnz6NqKgo9OrVC7NmzUJ2dvYVj6+trUV5ebnRxV40TZ8xU0TkyKTmjZ2cPpMyRY1drYlsQZw66xFs+JsfHWj494KTrkAzOyiaNGkSDhw40OUHLiwshE6nQ3h4uNH14eHhyM3N7fR5R40ahbVr12Lz5s145513cO7cOYwbNw4VFRXt3ictLQ3+/v7SJTo6utOPb2nNl+UTkWOq1+lRVm34YBPYyemzEB81FApApxectsiV7I+YKeoZ1BgUNf6bU+ycDRzNLra56aab8PTTT+P48eMYNGgQ3N2NN4W75ZZbLDa4zpgyZYr0/8GDB2PUqFHo2bMnPvnkE9x3331t3mfhwoVITU2Vvi4vL7ebwIiF1kSOT3z/KhRN72lzuamUCPHRoKCiFnnlNQj15VYfZH3ZxYYeRT2CvQEA0U7eq8jsoOiBBx4AALzwwgutblMoFNDpdK2ub0tISAhUKhXy8vKMrs/Ly0NERIS5w2pXQEAA+vTpgzNnzrR7jEajuWKNkpy4/xmR4yvRNmWJVF3YzDXM1xAUFbCuiGykvUzRxZJq6PRCl36e7ZHZ02d6vb7di6kBEQCo1WoMGzYM27dvNzr39u3bMWbMGHOH1a7KykpkZmYiMjLSYue0paatPpgpInJURVpDECN+yOmscGlZPlegkW1IQVFjTVG4nwfcVQo06AVcLnO+KTRZmzempqbivffew4cffoiMjAw8/PDD0Gq1SElJAQDMnj0bCxculI6vq6vD4cOHcfjwYdTV1eHixYs4fPiwURZowYIF2LlzJ7KysvDbb7/h1ltvhUqlwt13323z52cJAWKmSMtMEZGjkoqsvbuWkZYaOLJXEdlAXYNeCnzEQmuVUoFuAeIKNOcLikyaPnvjjTfw4IMPwsPDA2+88cYVj33sscdMfvAZM2agoKAAixYtQm5uLhITE7F582ap+Do7OxtKZVPcdunSJVx11VXS18uXL8fy5cuRlJSE9PR0AMCFCxdw9913o6ioCKGhobjmmmuwZ88ehIaGmjwue8JMEZHjK+nicnwRN4UlW7pQUgW9AHipVQj1aQroo4O8kFVUhZySKoxBsIwjtDyTgqLXXnsNs2bNgoeHB1577bV2j1MoFGYFRQAwf/58zJ8/v83bxEBHFBMT0+F+Kxs2bDDr8e1dIJfkEzk8cbVYYFeDImlTWGaKyPrEPc96BHkZNWruLi7Ld8JeRSYFRefOnWvz/2R9Ad6G6bPqeh1q6nXwcFfJPCIiMlfT9FnXgiJxi4V8ZorIBrKLmoKi5qLFBo4lzjd9xg1h7Zyvxg1ujdX93OqDyDF1tZu1iIXWZEsti6xFYgNHZ+xq3alNwS5cuICvv/4a2dnZqKszrnVZsWKFRQZGBgqFAgFe7iisrENJVR0i/D3kHhIRmclyQZFh+qygotYpl0OTfWnZo0gkNXB0wl5FZgdF27dvxy233IJevXrhxIkTGDhwILKysiAIAoYOHWqNMbq8AC+1FBQRkeOxVFAU7KOBUgHoBcMyf7HwmsgaWvYoEokNHPPKa52urMPs6bOFCxdiwYIFOHLkCDw8PPDZZ58hJycHSUlJuPPOO60xRpfXtNUHp8+IHJGlgiKVUoEQHxZbk/Xp9YK071nL6bMgbzW81IZA6GKpc9UVmR0UZWRkYPbs2QAMu9FXV1fDx8cHL7zwAl5++WWLD5CatgUo5n5HRA5HEAQpy9vVoAhgXRHZRn5FLWob9FApFYhq7EskUigUTltXZHZQ5O3tLdURRUZGIjMzU7qtsLDQciMjCTeFJXJcFbUNqNcZWolYJihiA0eyvvNFhnqibgGecFe1DhWcdQWa2TVFo0ePxq+//oqEhATceOONeOqpp3DkyBF8/vnnGD16tDXG6PLYq4jIcRVXGj7MeKlVFqm9COWyfLKB8+1MnYnEYmtn61VkdlC0YsUKVFZWAgCef/55VFZWYuPGjejduzdXnllJgBQUMVNE5GiKLFRPJGKmiGyhvR5FImn6zMlWoJkVFOl0Oly4cAGDBw8GYJhKW716tVUGRk1YaE3kuEos1LhRJNYU5bOmiKzI1EyRs+1/ZlZNkUqlwsSJE1FSUmKt8VAbmCkiclzFFtriQyRlijh9RlaU3VhT1CPIu83bm2qKnCtTZHah9cCBA3H27FlrjIXawUwRkeOy9PSZ2JuIS/LJmjrMFDVOn5VW1aO8xnn+NpkdFL344otYsGABvv32W1y+fBnl5eVGF7I88RMmM0VEjkd831pq+kzcFLawshYNOr1FzknUXFl1vfQhvL2aIm+NmxToO9OyfLMLrW+88UYAwC233GK0a64gCFAoFNDpdJYbHQEAAhozRWXV9WztT+RgiiotO30W7K2BSqmATi+gSFsn1RgRWYpYZB3io4G3pv0wITrQE8XaOuQUV2NAlL+thmdVZgdFO3bssMY46AoCPA2/TAUBKK+ut9gvVyKyvmKtYZrLUpkilVKBUB8NcstrkFdew6CILO58455n7U2diboHeeGPC2W44ER1RWYHRbGxsYiOjjbKEgGGTFFOTo7FBkZN1G5K+GjcUFnbgJKqOgZFRA6kuHEaIshbY7FzhvkZgiLWFZE1tLfnWUvO2NXa7Jqi2NhYFBQUtLq+uLgYsbGxFhkUtSZOobGBI5FjETNFQd7uFjunWGzNFWhkDVKPog4yRc7Y1drsoEisHWqpsrISHh5M41qL2NWaW30QORaxo7UlM0Vs4EjWZOr0mTNmikyePktNTQVg2Ajuueeeg5dX04ul0+mwd+9eJCYmWnyAZMBMEZHjqanXQVtnWHxiqSX5ABs4knU1dbNuu0eRSNrqo6S63YSJozE5KPr9998BGDJFR44cgVrd9AZXq9UYMmQIFixYYPkREgBmiogckbgc302pgJ+H2SWc7QrzNWSK8iuYKSLLqm3Q4XJjsN1RpigqwAMKBVBdr0NhZR1CfS2XDZWLye9ScdVZSkoKXn/9dfj5+VltUNRaoJQpYlBE5CiaL8e35KdoMVOUx0wRWVhOcTUEAfBWqzpcMalxUyHCzwOXy2qQU1LlFEGR2TVFa9asYUAkg6YGjpw+I3IU4oeYIC/LrhgNY00RWUl2Yz1Rj2BvkwJ5Z6srMjsoInlw+ozI8RRbeIsPkZgpKtKyqzVZlqnL8UXdG1egXXCSFWgMihyEVGitZaaIyFFIQZGPZYOiIC813JQKCAJQWMkPSmQ5UlDUQT2RSNwGhJkisikxU8SaIiLHIQVFFp4+UyoVUv0G64rIkrKLTetRJJKmz5ykqzWDIgfRNH3GTBGRoyiy0vQZAISx2Jqs4HxRY4+iDpbji6KlTBGnz8iGArj6jMjhlDQGRcEWnj4DgHAxU8Rl+WQher0gdac2dfpM7Gp9qbQaOr1gtbHZCoMiByGuPqtt0KO6sRkcEdk3MVMUaOHpM6BpBVoBM0VkIbnlNahr0MNNqUCkv2k7VIT7ekCtUqJBL+BymeNnixgUOQhvtQruKsPySGaLiByDWFPUUb+XzggX9z/jsnyyELHIunugJ9xUpoUHSqUC3QIN2aJsJyi2ZlDkIBQKBQJYbE3kUEqstPoMaNbAkZvCkoU071Fkju6NQdEFJ6grYlDkQMSu1iy2JrJ/er1gteaNABs4kuWZ26NIJBVbO8EKNAZFDoSZos4RBAEXSqogCI5fBEiOo7S6HmLdaaA1Vp81Tp8VMFNEFnK+2LweRSJn6mrNoMiBNO1/xkyROdbvy8Y1L+/Ah79lyT0UciFiPZGfhxvcTazPMEd4Y6aosLIO9exqTRaQ3Zgp6mF2psgwfZbjBF2tGRQ5EKlXkZaZInP8eroQALDnbLHMIyFXYq0tPkSBXmpp8UUBl+WTBUg9isysKWKmiGTRNH3GTJE5TuRWAADOFFTKPBJyJcVaQ6BiraBIqVRIU2hs4EhdVVpVh/KaBgCdyRQZjs+vqEVNvWO3jGFQ5ECaCq2ZKTJVVV0Dsho//Zwv0nKagWymuHGfwiBvjdUeQ9zqI5+ZIuoiscg6zFcDT7XKrPsGernDu/E+jr4xLIMiB8L9z8x3MrcCYn11vU5wij4a5BiaMkXuVnsMsa4on5ki6qLOFlkDhpYxzrICjUGRAwlgobXZMi5XGH19Jp9TaGQbTfueWS9TJPUq4rJ86qLsxox6DxP3PGupe2Nd0QUH/+DJoMiBiMt6OX1muozL5UZfMygiW5EaN1o1U8SaIrIMqUdRJzJFgPOsQGNQ5EC4JN98J3INQVFcqOHTTyaLrclGbJEpYk0RWUpXps8A51mBxqDIgYirz8pr6p1iN2JrEwQBJxqnz24eHAUAyGSmiGxErP2zxr5nImaKyFI626NI1IM1RWRrAZ6GTJEgAGXVzBZ15EJJNSpqG+CuUmDSgAgAQGaBlp2tySaKKw1BkTW6WYukQmtmiqgLaup1yG0MrM3tUSSSCq0dfP8zBkUOxE2lhK+HGwCuQDOFWE8UH+aL+DAfqJQKVNY2SG9+ImsRBEGaPrNqpqixT1Gxtg51DWw3QZ0jTnn5atykMg1ziZvCllXXo7zGcT+0yx4UrVq1CjExMfDw8MCoUaOwb9++do89duwYbr/9dsTExEChUGDlypVdPqejkbpaMyjqkNi0MSHSF2o3pTRXzmJrsrbqeh1qG4MUazVvBAwrUtWNW4gUVDJbRJ0jFln3CPaCQqHo1Dm8NW7SBwBHriuSNSjauHEjUlNTsXjxYhw6dAhDhgzBpEmTkJ+f3+bxVVVV6NWrF1566SVERERY5JyORiq21jpuJG4rYqYoIcIPABAX6gOAdUVkfUWNU2dqNyW8zGyEZw6FQiEVW7OuiDqrq0XWou5OMIUma1C0YsUKPPDAA0hJSUH//v2xevVqeHl54YMPPmjz+BEjRmDZsmWYOXMmNJq2V3SYe05HE8AGjiaTgqJIQ1AUH2YIirjdB1lbcbOps85+8jYVGzhSV3W1R5EounEKjZmiTqirq8PBgweRnJzcNBilEsnJydi9e7dNz1lbW4vy8nKji71q2uqDmaIr0dY2SJ9++kX6AgDiGzNFnD4jayuusu5msM2xgSN1laUyRc7Q1Vq2oKiwsBA6nQ7h4eFG14eHhyM3N9em50xLS4O/v790iY6O7tTj2wIzRaY5mWfY3iPUV4MQH8MnaSlTlK+Vc2jkAsSVZ7YIisKkXkXMFFHniMvxe3ZyOb7IGXoVyV5obQ8WLlyIsrIy6ZKTkyP3kNrVtP8ZM0VXIvYn6hfhK13Xq7GBY2FlLcr4+pEVFWttGBQxU0RdoNMLUmanR5czRY7f1Vq2oCgkJAQqlQp5eXlG1+fl5bVbRG2tc2o0Gvj5+Rld7FWgtzh9xkzRlYj1RP0jm76Xvh7uiGj8A8K6IrImeabPmCki810uq0a9ToC7SoFIf88unUvMFF0oqXLYfnCyBUVqtRrDhg3D9u3bpev0ej22b9+OMWPG2M057Q2nz0wjbu+REGkc4IpTaFyBRtYkTZ952SIoEgutmSki84lTZ9GBXlApu7YoICrAEwoFUFOvd9gWEW5yPnhqairmzJmD4cOHY+TIkVi5ciW0Wi1SUlIAALNnz0a3bt2QlpYGwFBIffz4cen/Fy9exOHDh+Hj44P4+HiTzunoWGjdsebbe4hF1qL4MB/8eqaQmSKyKmnfMx9b1BQZMkWsKaLOEIusuzp1BhhaUET6eeBSWQ1yiquln01HImtQNGPGDBQUFGDRokXIzc1FYmIiNm/eLBVKZ2dnQ6lsSmZdunQJV111lfT18uXLsXz5ciQlJSE9Pd2kczq6QGaKOtR8ew+xN5EoLowr0Mj6bLHvmUjMFJVU1aO2QQeNm/X6IpHzOW+hImtR9yAvXCqrwYWSKgzrGWiRc9qSrEERAMyfPx/z589v8zYx0BHFxMSYNE95pXM6ugCxeWNVPQRBsHoPFEfUfHsPd5XxDHFcY7F1JjNFZEVioXWgDabP/D3doXZToq5Bj/zyWmlZNJEpsosbexR1cs+zlqIDvbDvXLHDrkDj6jMHI/6SrWvQo7peJ/No7FPG5abtPVoSa4pyiqtQw9ePrERq3miD6TOFQtFsY1hOoZF5LJ0pklagOWhXawZFDsZLrZL2OuKy/LaJRdb9I1uvIgz10cDPww16AThXyH5FZHn1Oj3Kqg3vTVtkioBmdUUstiYzCILQ1KPIAjVFQLNeRQ7awJFBkYNRKBRNU2ha1hW1RZw+6xfROihSKBTNmjhyCo0sT6wnUiiaVotam5gp4rJ8MkdJVT0qahsAwGLTro7e1ZpBkQMSP31yBVprzbf3aGv6DGi2MSzrisgKxM2aA73UXV7ibCoxU5RXwUwRme58455nEX4e8HC3TIF+j8ag6FJpDRp0eouc05YYFDmgpmJrZopaar69R7BP25sGM1NE1lSkNQQmYvsMW2ADR+qMbAsuxxeF+WqgdlNCpxdwuczxfh4ZFDmgpkwRg6KWxKmzlk0bm2NQRNYkFVl7tx2UW4O4/1kBM0VkBksXWQOAUqlA9wBxuw/Hm0JjUOSAxK0+WGjdmti0MSGi7akzoCkoOluohU7vmK3oyX6V2HDfMxEzRdQZ5y1cZC3q3hhkXXDAFWgMihwQt/ponymZou6BXlJfl4sOvHEh2Sexm3WgTYMisdCamSIynaV7FImiA5kpIhsK5OqzNgmCgBO5Yo+i9oMilVKBXiGGXwJnCipsMjZyHU3TZ7YLisIaM0Vl1fXsv0Ums8b0GdC0Ai3bARs4MihyQE2ZIk6fNXehpBqVtQ1Qq5ToFXrlTz7c7oOspViG6TM/Dzdo3Ay/zllXRKaortMhv/FnxdLTZ1KvIgZFZAsstG7bcWl7D59W23u0FB/KoIisQ46gyNDVmnVFZDoxi+Pn4WbxflpSV2sHLE9gUOSAAr1YaN0Wsci6Xzv9iZrjCjSyFjmCIoB1RWQesUdRTwvXEwFNmaKCilqHm85lUOSAWGjdNrHIuq3tPVpqauCoNWmTYSJTyRUUhTFTRGawRo8iUYCXO3w0hv3mLzhYsTWDIgckZooqahocsmOotYh7nl2pyFrUK9QbCoWhMLWwksElWYYgCNKHFZsHRb7iprDMFFHHrFVkDRimc7sHOubGsAyKHJC/Z1On3NJqTqEBxtt79LtCjyKRh7tKSvFyCo0spbymAfU6Q+bR9tNn4qawzBRRx8Tfl5YushY56h5oDIockJtKKQVGLLY2ELf3CLvC9h4tSXVF3AONLERsk+GtVllsLylTSTVFFQyKqGPZjTVFPYIsX1MEOO4KNAZFDorF1sbEeqJ+JkydicSgKJOZIrIQORo3isLFTWFZaE0daNDpcaFxZZj1MkWcPiMbkoqt2cARQPNO1h1PnYniGnsZZTJTRBZSIkPjRlGYtPqMmSK6sstlNWjQC1C7KRHROO1qaVKmiNNnZAtipohFwgZNe56ZnyliTRFZSrGMmSJx9VlFTQOq6xxrGTTZllhkHR3oCaVSYZXHkGqKOH1GtiCusNpztkjmkchPrzdte4+W4kMNWaXLZTWorG2wytjItRTJtBwfAHw1bvBsrGPKZ10RXcH5Yuv1KBKJq8/KaxpQ5kALghgUOagJCWEAgPST+S6/LP9iqenbezTn7+WOkMaibNYVkSWIy/HlmD4zdLVmA0fqWHZjpqiHFZbji7w1bgjxMbwPHClbxKDIQSVGByLQyx3lNQ04cL5E7uHIypztPVpiXRFZUlGlfNNnABDmywaO1DGpR5GViqxF3RvrihypgSODIgelUipwXV9DtuinE/kyj0ZeTUXWpk+diVhXRJZUrDVkaOTIFAFNxdZs4EhXYu0eRaKmuiLHWYHGoMiBTUgIBwBsz8iTeSTykoqszVh5JmJQRJZU3NgiI8jbtF5ZlsYGjtQRQRCs3qNIFC12tWamiGxhXJ8QuCkVyCzQIqtQK/dwZJNhxvYeLbGBI1mSmCkK8nbv4EjrCOeyfOpAkbYO2jodFIqmXkLW4ogr0BgUOTA/D3eMjA0C4LpTaNraBml+3JTtPVoSg6LsoirUu3jBOnVdcaW4+kzeTBELrak94u/LSD8PaNys23Vd7FWUzaCIbOX6fq5dVyQuxTdne4/mIvw84K1WoUEv4HyR62bbqOtq6nXQNvYHkmNJPgCESpvCMlNEbctuXI7fw8r1REBTJupCSTUEQbD641kCgyIHJ9YV7T1XhIoax+kFYSknujB1BhiWMcexrogsQFyO76ZUwM/DTZYxNNUUMVNEbZNWnlm5nggAogI8oVQAtQ16FDhI8T+DIgcXG+KNXiHeqNcJ+PV0odzDsbmmPc/MnzoTxYcyKKKua74cX6GwTpfgjohBUUVtA7RsSEptkHoU2SBT5K5SItLfsYqtGRQ5AXEKbbsLTqFlNK4869/JTBEAZorIIuRs3Cjy0bjBWy12tXaMT+ZkW7Zaji8SO1s7yrJ8BkVO4PrG7tY7TuRDr3eMeVtL0OsFnGysKepnxp5nLcU1ZooyC1hTRJ0n7XvmJV9QBDTtgcZl+dQWW06fAY63Ao1BkRMYERMEX40birR1+ONCqdzDsZkLJZ3b3qMlcQVaZkGlSwWVZFni9FmQj8xBUWOxdR4zRdSCtrYBhZWGnwtbTJ8BTSvQOH1GNuOuUmJ831AArrUKTexP1Dvc/O09musZ7AU3pQJVdTpc5qdr6iRx+ixI5kxRVIBhuoL7+VFL4tL4AC93+HvappeWuAKN02dkUxPEuqIMFwqKxCLrLkydAYagMibEkGliXRF1VpFW7FEkb1A0qrF32S+nC2QdB9mfpqkz22SJgGbTZ8wUkS1d2zcMSoVhc9RLpY4RkXdVV7b3aElcgcZP19RZJY1BUbDM02fj+xiyxodzSlFW5XptOqh9TT2KbFNPBDRNn10uq0GDAzTIZVDkJIK81RjaIxCA60yhdWV7j5biwhozRdzugzqpyE4KraMCPBEf5gO9APx6xvXadFD75MgUhflqoHZTQqcXcLnM/ssTGBQ5EXEVmisERZXNtvewRFDEjWGpq8TVZ3IuyReN723IFv18ilNo1ESsKbJVkTUAKJUKdA8Q64rsfwqNQZETmdDP0N1615lCVDduN+CsxKX44X4ai9RwxIcapuA4fUadJU6fyb36DACSGhde/Hy6wGG2VyDrkyNTBDhWXRGDIifSJ9wH3QI8Udugx2+Zzp02t1SRtUhc0l+krZP+uBGZSq8X7Gb1GWAotta4KXG5rIbZTwIA1Ov0uNhYb9rThjVFgGOtQGNQ5EQUCgUmJLhGd+uu7nnWkrfGDVH+hqZ3mawrIjOVVtdDbHEVaAfTZx7uKoxsXIW2k1NoBOBSaTV0egEaN6XUy8pWHKlXEYMiJyNu+fFTRr5Tp80zLLjyTMTtPqizxHoiPw+3LvXMsqSkxlVoDIoIaJo66xHkBaXStnvzOVJXa/t495LFjO4VDE93FXLLa3C8cYrJ2ej1Ak5ctmymCGCxNXVesZ30KGpODIr2nStGTb1z1xhSx2y951lzYqYom9NnZGse7ipc0zsEgCFb5IwulFRDW6eDWqVEbIjl5saloIjTZ2SmYq1h6wR7Coriw3wQ6e+B2gY99pwtkns4JLPsosYeRTba86w5saaosLLW7hcBMShyQlJ3ayetKxIzYF3d3qMlqYEjgyIyU7HW0CQxyNu2tRpXolAopGzRz6ece+EFdUxaeSZDpsjf0x2+GjcAwAU7ryuyi6Bo1apViImJgYeHB0aNGoV9+/Zd8fhNmzahX79+8PDwwKBBg/D9998b3T537lwoFAqjy+TJk635FOzKdY1B0R8XSlHghJtCWrrIWiTWFF0oqeZ0A5mlKVNkm/2kTCV2t/6ZW364PDl6FIkUCgW6O8iyfNmDoo0bNyI1NRWLFy/GoUOHMGTIEEyaNAn5+W1nOX777TfcfffduO+++/D7779j+vTpmD59Oo4ePWp03OTJk3H58mXp8vHHH9vi6diFcD8PDOrmD0EA0k86X7aoaTm+5YqsAUPTvQAvdwgCs0VknqZ9z+wnUwQAY+NCoFQY6uQuusj2P9SaIAhSUGTrHkWi6EDHWJYve1C0YsUKPPDAA0hJSUH//v2xevVqeHl54YMPPmjz+Ndffx2TJ0/G008/jYSEBCxduhRDhw7FW2+9ZXScRqNBRESEdAkMDLTF07Eb0io0J5xCO9HYuLG/hTNFCoVCmkJjsTWZo8SOulk35+/ljqsat/9hd2vXVVBZi6o6HZQKoHugTEGRg6xAkzUoqqurw8GDB5GcnCxdp1QqkZycjN27d7d5n927dxsdDwCTJk1qdXx6ejrCwsLQt29fPPzwwygqar/QsLa2FuXl5UYXR5ecYOhu/fOpAtQ2OM9UUPPtPfpZOCgCmoqtMwu0Fj83OS9p3zM7C4oAbvlBQHbj78xIf0+o3eT5sy9lijh91r7CwkLodDqEh4cbXR8eHo7c3Nw275Obm9vh8ZMnT8a6deuwfft2vPzyy9i5cyemTJkCna7t4CAtLQ3+/v7SJTo6uovPTH4DovwQ5quBtk6HfeeK5R6OxZxsrCey1PYeLUlBETNFZAaxm7W9ZYoAYHwfw2rUX88UOsQu5WR5chZZi5oyRZw+s7mZM2filltuwaBBgzB9+nR8++232L9/P9LT09s8fuHChSgrK5MuOTk5th2wFSiVCmkKbbsTLc1vatpo+SwRAMRx+ow6objSfjNFg7sHIMDLHRU1DTicUyr3cEgGcvYoEjnK/meyBkUhISFQqVTIy8szuj4vLw8RERFt3iciIsKs4wGgV69eCAkJwZkzZ9q8XaPRwM/Pz+jiDKSg6ESe03S3tvSeZy2JmaJzhVp+qiaTCIIgTZ/ZY6ZIpVTgmnhDtohTaK5Jzh5Fou6N02cVNQ0oq6qXbRwdkTUoUqvVGDZsGLZv3y5dp9frsX37dowZM6bN+4wZM8boeADYunVru8cDwIULF1BUVITIyEjLDNxBjI0PgdpNiZziaqdZTSUWWVtye4/mugV4wsNdiTqdHjkl9p3mJftQXa9DbYMhgLan5o3NiUvzd55mvyJXZA+ZIi+1G0J8DO8Pe84WyT59lpqaivfeew8ffvghMjIy8PDDD0Or1SIlJQUAMHv2bCxcuFA6/vHHH8fmzZvx6quv4sSJE1iyZAkOHDiA+fPnAwAqKyvx9NNPY8+ePcjKysL27dsxbdo0xMfHY9KkSbI8R7l4a9wwplcwAOeYQrPW9h7NKZUK9AphXRGZrqhx6kztpoSXWiXzaNomFlv/eaFU2pKEXEd2s33P5CSufLPnFWiyB0UzZszA8uXLsWjRIiQmJuLw4cPYvHmzVEydnZ2Ny5cvS8dfffXVWL9+Pd59910MGTIEn376Kb788ksMHDgQAKBSqfDnn3/illtuQZ8+fXDfffdh2LBh+OWXX6DR2FcPEVuYkOA83a1zSqqk7T16WXB7j5biuN0HmaG42dSZQmHbjTZNFeHvgX4RvhAEQ8E1uY7K2gZpelfOTBHgGHVFbnIPAADmz58vZXpaaqs4+s4778Sdd97Z5vGenp748ccfLTk8h3Zd3zAAx3DwfAlKq+oQ4GWf6X1TiEXWvcN94GbFncjZq4jMUVxlf5vBtmV8n1CcyK3Az6cKcMuQKLmHQzZyvrGeKMhbDV8PeTuu9wiy/waOsmeKyLqig7zQN9wXOr2AnQ5eZJlh5akzkbQxLIMiMoG48szug6Jm/YqcZeEFdcxeps4AIDrQ/jNFDIpcwPUJztHd2lp7nrXU1MCxkn88qEPFWscIiobHBMLTXYX8ilppwQI5P3soshY5QldrBkUuYELj0vz0kwUOvcxc6lFk4T3PWooJ8YJSYVg66owb6pJlOcr0mYe7CqN7BQHg0nxXIjVutKNM0YWSauj19vmBk0GRC7iqRyACvdxRVl2PQ9mlcg+nUyprG6QNDa2xvUdzGjeVlGrmFBp1RJo+c4B6PWlpPoMil5Fd3NijKFi+HkWiyAAPKBVAbYMeBZX2+YGTQZELUCkVjQXXhkaOjsja23u0FM8VaGQicWVPkI/9B0VJjUHRgawSVNU1yDwasgV72OJD5K5SItJfLLa2zyk0BkUuQqorctB+RcetvL1HS3HcA41MZM/7nrUUG+KN7oGeqNPpseds+5tkk3Ooa9DjUqlhpZc9TJ8BQHSQfW8My6DIRYzrHQo3pQKn8yul1QiOxNpNG1uSluUzU0QdEAutAx1g+kyhUEhTaD+fYr8iZ3couwR6AfBSqxDqax99+qQVaHa6LJ9BkYvw93THiBhDkaUjTqE17Xlm3SJrURyX5ZOJihprI4IdYPoMaJpCY12R81u9MxMAMC0xym4ai9r7CjQGRS5kgoMuzdfrBZxsXELc31aZosagKK+8FuU19rt5IcmrXqdHeY2hNifI2z4+iXfk6rhguCkVOFeotds/TNR1xy6VIf1kAZQK4KHxcXIPR8LpM7Ib1zcuzd9ztgiVtY5TZClt7+GmRKwVt/dozs/DHWGN6WbWFVF7xHoihcKQjXUEvh7uGNojEACzRc7s7XRDlujmwVGIsdHvTVNw+ozsRq9QH8SGeKNeJ+DX047zy1DsT9THytt7tNTUxFFrs8ckx1KiNWQRA73UUCntY3rCFEl9OYXmzM4WVOL7I4Y9Qx++1n6yREDT9NnlsmrU22HfPAZFLkbMFm13oFVoTfVEtpk6E3G7D+pIkdZQTxTo5RhZIpG45cfuzCK7/MNEXfPvnWchCIbGvbZanGKqUB8N1G5K6AXgcmmN3MNphUGRixG7W+84mW+3HUVbstWeZy3FcWNY6oC48izYQeqJRAOi/BDsrUZlbQMOnS+RezhkQZfLqvH57xcAAI9cZ19ZIgBQKhXoHmi/dUUMilzM8Jgg+GrcUFhZhz8vlsk9HJOI+zQlRNpm5Zmo+R5oRG0pcZB9z1pSKhW4pncIAE6hOZv3fj6Hep2AUbFBGNYzSO7htKmprohBEclM7aaU+pT8lGH/S/Mrauql7T0SZJo+yy6uQm2DzqaPTY5B7GYd6GBBEdC0NP9nB6ovpCsr1tbh433ZAIB518XLPJr22fMKNAZFLkhcmr/dAZbmn8ozZIki/Dxs/ocnzFcDX40bdHpBapVP1FzT9JnjBUXjGuuKjl4sR6Gd7kNF5lm76xyq63UY2M0P4xozgfZoREwQpidGoX+kv9xDaYVBkQu6tm8YFArg2KVy5JbZX6Fbc+L2Hv1sPHUGGLr/9mKxNV1BsYNOnwFAqK9G6vv1C7NFDq+iph5rf8sCAMy7Nt5umjW2ZVpiN6yceRVuGhwp91BaYVDkgoK81VKfEntv5ChXkbUonsXWdAWOHBQBTUvzueWH41u/NxvlNQ3oFeqNSQMi5B6Ow2JQ5KLEpfk/2fmWH7be86wlLsunK3H0oEhcmv/L6QKHWY1KrdXU6/DeL+cAAA8nxUHpQD2z7A2DIhcl1hX9eqYQNfX2WUSs1wtNK89stOdZS1yBRlfi6EHRsJ6B8FarUFhZh+ONH0DI8Ww6eAGFlbXoFuCJ6Vd1k3s4Do1BkYvqG+6LbgGeqKnX47fMrqfOK2sb8MORy/j7Z39i0VdHkX4yv8srtnJKqlBl4+09WmoeFPGTNDUnCIK0zYejBkVqNyXGxHFpviNr0Onx78aNXx8YFwt3G3b9d0Zucg+A5KFQKHB9vzD8Z895bM/Ix/X9ws0+x6XSamzPyMPWjHzsySxCXbPOuOt2n4e3WoWkvqFITgjH9f3CEOBl3h8OsZ7I1tt7NBcd6Am1Somaej0ullZLLeqJymsaUK8zBMqOGhQBQFKfEGzLyMPPpwrsehk3te2bPy/hQkk1gr3VmDGih9zDcXgMilzY9QmGoOinE/kQBKHD1QqCIODoxXJszcjDtuN5rdLtPYO9kJwQjup6HbYdz0N+RS2+P5KL74/kQqVUYHjPQNzQPxw39A9Hz+COMz/inme27k/UnJtKiZgQL5zKq8SZgkoGRSQRGzd6q1XwcFfJPJrOE/uWHTxfgsraBvho+GfBUej1At5p3Pj13mti4al23J9De8Gffhc2plcwPN1VuFxWg4zLFegf1Tr4qKnXYXdmEbZm5GF7Rh7yypv6mSgUwLAegUjuH47khDDEhfpIgdWL0wbiyMUybD2eh20ZeTiRW4G954qx91wxXvwuA33CfZCcEI7k/uFI7B7QZmGgtOeZzHv3xIf54FReJTLzK3Fd3zBZx0L2Y+txwyKFUF/H2uKjpZ7B3ogJ9kJWURV+O1OIiVy55DC2ZeThVF4lfDVu+MvonnIPxykwKHJhHu4qjI03pM5/OpEnBUWFlbX46UQ+th3Pwy+nC1HdrBDbS63C+N6hSO4fjuv6hiLYp+0/CEqlAkOiAzAkOgALJvVFdlEVtmXkYevxPOzLKsapvEqcyqvE2+mZCPHRIDkhDDf0D8fY+BDpU3dGrrjyTJ4ia5G4LJ/F1iTadaYQL20+AQBIGRsr82i6bnyfUGTtPo+fTxcwKHIQgiBgVWOW6H/G9IS/p2NtSmyvGBS5uAkJYdiWkYfvjuRCqVRg2/E8/J5TCqFZTXGkvwcmJIQhOSEco3sFd2qqoEewF+69Jhb3XhOLsqp6pJ/Kx5bjedh5sgCFlbXYsD8HG/bnwNNdhXG9Q5DUNxQ5xdUA5J0+A4A4LsunZnKKqzB//SHo9AJuH9ods8c4/if08b1DsW73eew8VWDSVDrJb3dmEf7IKYXGTYl7r3H8wNxeMChycWK/oozL5dJ0FQAM6uYvBUIDovws+kvS38sd0xK7YVpiN9Q16LHnbBG2NdYpXSqrwZbjedjSODUhx/YeLcWxgSM1qqprwIP/OYiSqnoM6e6Pf9460CkCiDFxwXBXKZBTXI2soirZVnuS6ValnwEAzBwRjZB2MvZkPgZFLi7czwM3DorAtox8jI0LxoSEcExICEOkv6dNHl/coHZ8n1A8f8sAHLtULk2zHbtUjkkDzF8VZ2mGWimgpKoeRZW17U4ZknMTBAHPfPonMi6XI8RHg9X/M8yhC6yb89a4YXjPIOw+W4SfTxVYPCgSBAGfH7oIT7UKNw6yv60dHM3hnFLsOlMEN6UCD4zvJfdwnAqDIsLbs4ZBrxdk74KqUCgwsJs/BnbzxxPJfVBV1wBPO/ij46lWoVuAJy6UVCOzQMugyEWt3nkW3/55Ge4qBVb/ZajNPjjYyvg+oVJQNOfqGIudt65Bj4WfH8Fnhy4AAB4c3wt/n9xP9t83juztHYYs0bTEbugeyBWxlsQuTwQAdvkLykvtZjdTE9zuw7Wln8zHKz8aCquX3DIAw2OCZB6R5Y3vY2ji+FtmUZcbr4rKa+qRsnYfPjt0AeKvmHd/PounNv2B+mZ9zch0p/MqsOV4HhQK4OFrmSWyNAZFRCZgXZHrOleoxaMf/w5BAO4e2QOzRjl+YXVb+kf6IdRXg+p6HQ5mlXT5fJdKq3HnO7ux60wRvNQq/N+cEVh+5xColAp88ftF3PfhAWhrGywwctci9iWa1D8C8WHyrsx1RgyKiEwgZYq4LN+lVNY24IF1B1BR04DhPQPx/C0D5B6S1SgUCozr3bjlx+mubflx9GIZpq/ahZN5FQj11eCTh8bgun5huGNYd7w/Zzg83VX4+VQB7nlvD4oqazs+IQEwrHz86o9LAIBHrouTeTTOiTVFRCaQ9kCzo0xRbYMOu84U4ocjudje2JW8b4Qv+kX4oW+Er+ES7gtvdijuFL1eQOrGwziTX4lwPw3e/stQqN2c+3NkUp9QfH7oIn4+VYiFUzp3jh0n8zH/o0PQ1unQJ9wHa1JGoltAU/3VdX3DsP6BUbh37X78caEMd6zejXX3jmS3eBO8+/NZ6PQCxvUOweDuAXIPxynxtyWRCcQGjhdLq1FV1wAvtTxvneo6HXaeKsAPRy/jp4x8VLSYfthzthh7zhYbXRcd5Im+4X7o1xgo9YvwRWyIt2z7yTmKN346jS3H86BWKfHv/xmOMF8PuYdkddfEh0ChMLToyC+vQZifec95/d5sPPfVUej0Aq6OC8Y7fxnWZlPBq3oE4tOHr8bs/9uHc4Va3PbOb1ibMgIDovwt9VScTn5FDTYeyAEAPHIt96izFgZFRCYI9FYjyFuNYm0dzhZoMbCb7X55V9Y24KcT+dh89DJ2nCgw6jAe7qfB5AERmDwwEj4aN5zILcfJ3AqczKvAidwKFFTUIqe4GjnF1diWkSfdT61SIi7MBwliRqkxwxTup7Gb4nY5bTmWi5XbTgMA/nnrQCRGB8g7IBsJ9tFgUDd//HmhDD+fLsQdw7qbdD+9XsDyLSfxdmO9y21Du+Gl2wZfMbMWF+qDzx+5GnM+2IcTuRWY8e89ePd/huHq+BCLPBdn88GvWahr0OOqHgEY3cv5Cv3tBYMiIhPFh/pgn7YYZ/IrrR4UlVXVY1tGHn44ehk/ny5EXUPTSp3ugZ6YMtAQCF0Vbbxv3KDuxuMq1tY1BUq5hkDpVF4Fqup0rRp2AoC/pzv6RvhiWmIU7hoeDXc7ySZV1+lQpK21yfLj03kVeHLjYQDA3KtjcOfwaKs/pj0Z3zvUEBSdKjApKKpt0OHpTX/i68Zal8cm9MaTyb1NCq7D/Tyw8aExeHDdAew9V4y5a/ZjxYwhuHlwVJefhzMpq67Hf/ecBwDMuzaeH1ysiEERkYniwnywL6vYanugFVXWYsvxPPxwNBe/nSlEg75pr5VeId6YPDACUwZGYmA30zuMB3mrcXVcCK6Oa/r0rdcLuFBSLQVLJ/IMAdO5Qi3Kquux71wx9p0rxr93nkXqDX1wy5Ao2Vo2aGsb8J895/Huz2dRrK3DlIERWDCpr7Qa0NLKquvxwLoD0NbpMLpXEP5xU4JVHseeJfUNxVs7zuCX0wXQ6QWorvC9L62qw4P/OYh954rhplTgX7cNwl1mBpH+nu748N6ReHLjYfxwNBePfvw7iirrLNorydH9Z3cWKmsb0C/CV9qFgKyDQRGRiazRqyivvAY/HsvFD0dysfdcEZrFQegb7ovJAyNw46BI9An3sdinQ6VSgR7BXugR7GW0+WdNvQ6ZBZXYnVmE1TszkV1chSc2HsbqnZlYMLEvJiSE2ewTastgSPTD0VxsOZ6Hu4ZH44nk3gg3s+blSnR6AY9v+B1ZRVXoFuCJVfcMtZtMmS0lRgfAV+OGkqp6HL1YhiHtTB3mFFdh7pp9yCzQwkfjhnf+MhTjeod26jE93FV4656hWPL1Mfxnz3ks/voY8itqsGBiX5fPilTX6fDBriwAwMPXxtllTzlnwqCIyESdDYoadHpcLqtBVpEWWUVVOF9o+DerSIvMgkqjzXcHdfNvzAhFoJeVsiHt8XBXYUCUPwZE+ePukT2w9rcsrN6ZiRO5Fbh/3QEM7RGApyf1w5i4YKuNoa1gqGewFx69vjcSIn3x2tZT2JaRj4/3ZeOL3y/g3rGxeCgpziI7hC/fchLpJwvg4a7Ev/9nmMt2LndXKXF1fDB+PJaHn08VtBkU/ZFTivs+3I/CyjpE+HlgTcoIJER2beNmlVKBF6YNQLifBsu3nMKqHZnIL69F2m2DXHpRwIb92SjW1qFHkBdu4hYpVqcQhOa/kgkAysvL4e/vj7KyMvj5ybtDO9mPCyVVuOblHXBXKZDxwmSjX9T1Oj0ulFQjq0grBT3ni7Q4X1SFnJIq1Ovaf5sN7RGAKQMjMXlghN0tSy6tqsPqnWex9rdzqKk31DWN6x2CZyb1a1W/1BXa2gas230e7/3SFAzFNAZD0xKjjF7r/VnFeOmHEzh43tBg0N/THfOui8PsMTGd3ovs2z8vYf763wEAr89MxLTEbl18Ro5t/d5sPPvFEQzvaVgl1tzW43l47OPfUV2vQ0KkH9bMHYEIf8uuzNu4PxsLPz8CvWDYtHrVPUPhqZZ/y5/2CIKA45fLkVVYheExgRbLYNY16JG0bAcul9Xgn7cOdNrGoZbU1b/fDIrawKCI2qLXCxiw+EdU1+sw/7p4lFXXG4KgoipcLK2GTt/+W0mtUqJHsBdigr3QM9hb+rdfhK/Zy57lkF9egzd/OoOP92VLtU5TBkbgqYl9pQxaZ4jB0Ls/Z6Kkqh5A+8FQc4IgYOvxPCz78SRON2buovw98MQNfXD70O5XrINp6filctz+zm+ortfhofG9sPBG16sjakn8AKBSKvD7ohvg52HIxK3bnYUlXx+DXjDslbbqnqvg69H1LF1bth3Pw7z1h1DbuOLqgzkjEOittspjdUaDTo99WcXYcsywgfXF0mrptv6RfriuXyiu6xuGxOiATme6Ptmfg2c++xNhvhr8/Mx1TrMBsTUxKLICBkXUnpvf/AVHL5a3eZuHuxIxwd7oGezV+G9j8BPijQg/D7P+UNur7KIqvLbtFL48fBGCACgVwO1Du+Px5N5mrQzrbDDUkk4v4LNDF/Da1lO4XFYDAOgT7oOnJ/VDsgk1UMXaOtzy1q+4UFKNcb1DsDZlpFN8nyzh+lfTcbZAi9V/GYqJ/SOQ9kMG3vvlHABg5ohoLJ0+0Oo1VwfPF+PetQdQVl2PuFBvrLtvlFEjSFurqmvAz6cKsOVYHrafyEdZdb10m/j+P5lXYTQl7u/pjvF9QnF9v1CM7x1q8rSsTi/ghhU7cbZQi3/cmIAHxnOfM1MwKLICBkXUnu+PXMYHv55DuJ9Hs+DHCzEh3gjzdZ0ePydzK7B8y0lsPW7ofaRWKXHPqB6Yf308Qq7wS7+tYCg2xBuPXh+PW4aYHgy1VFOvw7rdWVi1I1P6QzW8ZyD+NqUfRrSzeWuDTo/ZH+zDb5lF6Bnsha/mjUWAl/1kIuT2/DfHsGZXFm67qhtqG/T47shlAMCCiX0w7zrbLQs/nVeB2R/sw+WyGoT7afDhvSPRL8J2v5cLK2uxPSMPW47l4Zczxu0xgrzVmNAvDBMHROCa+BB4qlUoqqzFz6cLsONEAXaeKjAKnBQKYEj3AFzXNwzX9QvFwCj/dgunv/vzMuatPwR/T3fs+vv18GFnepM4RVC0atUqLFu2DLm5uRgyZAjefPNNjBw5st3jN23ahOeeew5ZWVno3bs3Xn75Zdx4443S7YIgYPHixXjvvfdQWlqKsWPH4p133kHv3r1NGg+DIiLTHMouwbLNJ7H7bBEAwEutwn3XxOKB8b2kKRfA0IBy3e4svPfzWYsGQy2VVddj9c5MrNnVVAOVnBCGpyf1Q98I480zX/jmOD7YdQ5eahW+eGRsq9td3Y6T+UhZs1/62l2lwLI7hmD6Vbavt7pcVo05H+zDqbxK+Hq44f3ZwzGql/UK/rMKtdhyPBdbjuXhYHaJUeanR5AXJvYPx8QBERjWM/CKmcUGnR5/XCjFjhMF+OlEPo636AsW4qNGUp8wXN8vDNf0DpEWDAiCgJvf/BXHLpXj8Qm98eQNfazyPJ2RwwdFGzduxOzZs7F69WqMGjUKK1euxKZNm3Dy5EmEhbXux/Dbb79h/PjxSEtLw80334z169fj5ZdfxqFDhzBw4EAAwMsvv4y0tDR8+OGHiI2NxXPPPYcjR47g+PHj8PDouH6DQRGR6QRBwK4zRXjlxxP480IZACDAyx0PJ8Xh9mHd8cmBHKsHQy3lltXg9e2n8MmBC9DpBSgVwG1Du+PJG/qgW4AnPjt4AU9t+gMAsPovQzF5IFf1tFRdp8OQF7agrkEPPw83/Pt/hlt15WFHyqrqcf+6/difVQK1mxJ3DOuOAE93+Hq4w9fDTbr4aJp9rXGHj4dbh1Oier2AIxfLsOV4LrYez8OpPOMVpoO6+UuBUFfaY+SW1WDnqXzsOFGAX88UorLZNj0qpQLDegbiur5h8PFww3NfHoWXWoVdf7vermqp7J3DB0WjRo3CiBEj8NZbbwEA9Ho9oqOj8eijj+Lvf/97q+NnzJgBrVaLb7/9Vrpu9OjRSExMxOrVqyEIAqKiovDUU09hwYIFAICysjKEh4dj7dq1mDlzZodjYlBEZD5BEPDjsVws33KqzbYFsSHeeGxCPKYOtl4w1NKZ/Eos//EkNh/LBQCo3ZS4fWh3fHboAuoa9Hj0+ng8NbGvTcbiiFZsOYlfzhTildsHo3e4/Jm0mnodHv34d2na1lRealVjoOQOH42bUdCkFwT8croQueU10vFuSgVG9wrGxAHhSE4IR5QV6pjqGvQ4cL4YO07kY8fJgjbfM/dfE4v/vbm/xR/bmTl0UFRXVwcvLy98+umnmD59unT9nDlzUFpaiq+++qrVfXr06IHU1FQ88cQT0nWLFy/Gl19+iT/++ANnz55FXFwcfv/9dyQmJkrHJCUlITExEa+//nqH42JQRNR5Or2AL36/iNe2nsLF0mpZgqGWfs8uwUs/nMDec02b5U7oF4b3Zg9nMzwH06DT46vDl5BVpEVFTUPjpR6VtYb/G/6tR3lNg1H9T0e81Spc2zcMN/QPx3V9w+DvZZ1Vde3JKa5C+klDgPRbZiG81G74/rFxFm934Oy6+vdb1sqtwsJC6HQ6hIeHG10fHh6OEydOtHmf3NzcNo/Pzc2Vbheva++Ylmpra1FbWyt9XV7e9uoiIuqYSqnAHcO6Y+qQSJzMrUD/SD/Zm+9d1SMQGx4cjfRTBXh922mo3ZR4bWYiAyIH5KZS4nYTN6qtbdChsqYpWCqvqTf8v1kgVVOvx7CegRgTFyzrkvfoIC/8z5gY/M+YGNQ0bvrMJfi2x3J2AGlpaXj++eflHgaRU9G4qTC4e4Dcw5AoFArDqp++3DvKVWjcVND4qByuOzmDIfnI+vEtJCQEKpUKeXnG88N5eXmIiIho8z4RERFXPF7815xzLly4EGVlZdIlJyenU8+HiIiIHJesQZFarcawYcOwfft26Tq9Xo/t27djzJgxbd5nzJgxRscDwNatW6XjY2NjERERYXRMeXk59u7d2+45NRoN/Pz8jC5ERETkWmSfPktNTcWcOXMwfPhwjBw5EitXroRWq0VKSgoAYPbs2ejWrRvS0tIAAI8//jiSkpLw6quv4qabbsKGDRtw4MABvPvuuwAMKfInnngCL774Inr37i0tyY+KijIq5iYiIiJqTvagaMaMGSgoKMCiRYuQm5uLxMREbN68WSqUzs7OhlLZlNC6+uqrsX79evzv//4vnn32WfTu3Rtffvml1KMIAJ555hlotVo8+OCDKC0txTXXXIPNmzeb1KOIiIiIXJPsfYrsEZfkExEROZ6u/v2Wd50sERERkZ1gUEREREQEBkVEREREABgUEREREQFgUEREREQEgEEREREREQAGRUREREQAGBQRERERAWBQRERERATADrb5sEdik+/y8nKZR0JERESmEv9ud3azDgZFbaioqAAAREdHyzwSIiIiMldFRQX8/f3Nvh/3PmuDXq/HpUuX4OvrC4VCYdFzl5eXIzo6Gjk5OdxXzYb4utseX3N58HWXB193ebR83QVBQEVFBaKioow2kzcVM0VtUCqV6N69u1Ufw8/Pj28cGfB1tz2+5vLg6y4Pvu7yaP66dyZDJGKhNREREREYFBEREREBYFBkcxqNBosXL4ZGo5F7KC6Fr7vt8TWXB193efB1l4elX3cWWhMRERGBmSIiIiIiAAyKiIiIiAAwKCIiIiICwKCIiIiICACDIptatWoVYmJi4OHhgVGjRmHfvn1yD8mpLVmyBAqFwujSr18/uYfldH7++WdMnToVUVFRUCgU+PLLL41uFwQBixYtQmRkJDw9PZGcnIzTp0/LM1gn0tHrPnfu3FY//5MnT5ZnsE4kLS0NI0aMgK+vL8LCwjB9+nScPHnS6JiamhrMmzcPwcHB8PHxwe233468vDyZRuwcTHndr7322lY/83/961/NehwGRTayceNGpKamYvHixTh06BCGDBmCSZMmIT8/X+6hObUBAwbg8uXL0uXXX3+Ve0hOR6vVYsiQIVi1alWbt7/yyit44403sHr1auzduxfe3t6YNGkSampqbDxS59LR6w4AkydPNvr5//jjj204Que0c+dOzJs3D3v27MHWrVtRX1+PiRMnQqvVSsc8+eST+Oabb7Bp0ybs3LkTly5dwm233SbjqB2fKa87ADzwwANGP/OvvPKKeQ8kkE2MHDlSmDdvnvS1TqcToqKihLS0NBlH5dwWL14sDBkyRO5huBQAwhdffCF9rdfrhYiICGHZsmXSdaWlpYJGoxE+/vhjGUbonFq+7oIgCHPmzBGmTZsmy3hcSX5+vgBA2LlzpyAIhp9vd3d3YdOmTdIxGRkZAgBh9+7dcg3T6bR83QVBEJKSkoTHH3+8S+dlpsgG6urqcPDgQSQnJ0vXKZVKJCcnY/fu3TKOzPmdPn0aUVFR6NWrF2bNmoXs7Gy5h+RSzp07h9zcXKOffX9/f4waNYo/+zaQnp6OsLAw9O3bFw8//DCKiorkHpLTKSsrAwAEBQUBAA4ePIj6+nqjn/l+/fqhR48e/Jm3oJavu+ijjz5CSEgIBg4ciIULF6Kqqsqs83JDWBsoLCyETqdDeHi40fXh4eE4ceKETKNyfqNGjcLatWvRt29fXL58Gc8//zzGjRuHo0ePwtfXV+7huYTc3FwAaPNnX7yNrGPy5Mm47bbbEBsbi8zMTDz77LOYMmUKdu/eDZVKJffwnIJer8cTTzyBsWPHYuDAgQAMP/NqtRoBAQFGx/Jn3nLaet0B4J577kHPnj0RFRWFP//8E3/7299w8uRJfP755yafm0EROa0pU6ZI/x88eDBGjRqFnj174pNPPsF9990n48iIrG/mzJnS/wcNGoTBgwcjLi4O6enpmDBhgowjcx7z5s3D0aNHWatoY+297g8++KD0/0GDBiEyMhITJkxAZmYm4uLiTDo3p89sICQkBCqVqtXqg7y8PERERMg0KtcTEBCAPn364MyZM3IPxWWIP9/82Zdfr169EBISwp9/C5k/fz6+/fZb7NixA927d5euj4iIQF1dHUpLS42O58+8ZbT3urdl1KhRAGDWzzyDIhtQq9UYNmwYtm/fLl2n1+uxfft2jBkzRsaRuZbKykpkZmYiMjJS7qG4jNjYWERERBj97JeXl2Pv3r382bexCxcuoKioiD//XSQIAubPn48vvvgCP/30E2JjY41uHzZsGNzd3Y1+5k+ePIns7Gz+zHdBR697Ww4fPgwAZv3Mc/rMRlJTUzFnzhwMHz4cI0eOxMqVK6HVapGSkiL30JzWggULMHXqVPTs2ROXLl3C4sWLoVKpcPfdd8s9NKdSWVlp9Ens3LlzOHz4MIKCgtCjRw888cQTePHFF9G7d2/ExsbiueeeQ1RUFKZPny7foJ3AlV73oKAgPP/887j99tsRERGBzMxMPPPMM4iPj8ekSZNkHLXjmzdvHtavX4+vvvoKvr6+Up2Qv78/PD094e/vj/vuuw+pqakICgqCn58fHn30UYwZMwajR4+WefSOq6PXPTMzE+vXr8eNN96I4OBg/Pnnn3jyyScxfvx4DB482PQH6tLaNTLLm2++KfTo0UNQq9XCyJEjhT179sg9JKc2Y8YMITIyUlCr1UK3bt2EGTNmCGfOnJF7WE5nx44dAoBWlzlz5giCYFiW/9xzzwnh4eGCRqMRJkyYIJw8eVLeQTuBK73uVVVVwsSJE4XQ0FDB3d1d6Nmzp/DAAw8Iubm5cg/b4bX1mgMQ1qxZIx1TXV0tPPLII0JgYKDg5eUl3HrrrcLly5flG7QT6Oh1z87OFsaPHy8EBQUJGo1GiI+PF55++mmhrKzMrMdRND4YERERkUtjTRERERERGBQRERERAWBQRERERASAQRERERERAAZFRERERAAYFBEREREBYFBEREREBIBBERGRSdLT06FQKFrtaUVEzoNBEREREREYFBEREREBYFBERA5Cr9cjLS0NsbGx8PT0xJAhQ/Dpp58CaJra+u677zB48GB4eHhg9OjROHr0qNE5PvvsMwwYMAAajQYxMTF49dVXjW6vra3F3/72N0RHR0Oj0SA+Ph7/93//Z3TMwYMHMXz4cHh5eeHqq6/GyZMnrfvEichmGBQRkUNIS0vDunXrsHr1ahw7dgxPPvkk/vKXv2Dnzp3SMU8//TReffVV7N+/H6GhoZg6dSrq6+sBGIKZu+66CzNnzsSRI0ewZMkSPPfcc1i7dq10/9mzZ+Pjjz/GG2+8gYyMDPz73/+Gj4+P0Tj+8Y9/4NVXX8WBAwfg5uaGe++91ybPn4isjxvCEpHdq62tRVBQELZt24YxY8ZI199///2oqqrCgw8+iOuuuw4bNmzAjBkzAADFxcXo3r071q5di7vuuguzZs1CQUEBtmzZIt3/mWeewXfffYdjx47h1KlT6Nu3L7Zu3Yrk5ORWY0hPT8d1112Hbdu2YcKECQCA77//HjfddBOqq6vh4eFh5VeBiKyNmSIisntnzpxBVVUVbrjhBvj4+EiXdevWITMzUzquecAUFBSEvn37IiMjAwCQkZGBsWPHGp137NixOH36NHQ6HQ4fPgyVSoWkpKQrjmXw4MHS/yMjIwEA+fn5XX6ORCQ/N7kHQETUkcrKSgDAd999h27duhndptFojAKjzvL09DTpOHd3d+n/CoUCgKHeiYgcHzNFRGT3+vfvD41Gg+zsbMTHxxtdoqOjpeP27Nkj/b+kpASnTp1CQkICACAhIQG7du0yOu+uXbvQp08fqFQqDBo0CHq93qhGiYhcCzNFRGT3fH19sWDBAjz55JPQ6/W45pprUFZWhl27dsHPzw89e/YEALzwwgsIDg5GeHg4/vGPfyAkJATTp08HADz11FMYMWIEli5dihkzZmD37t1466238PbbbwMAYmJiMGfOHNx777144403MGTIEJw/fx75+fm466675HrqRGRDDIqIyCEsXboUoaGhSEtLw9mzZxEQEIChQ4fi2WeflaavXnrpJTz++OM4ffo0EhMT8c0330CtVgMAhg4dik8++QSLFi3C0qVLERkZiRdeeAFz586VHuOdd97Bs88+i0ceeQRFRUXo0aMHnn32WTmeLhHJgKvPiMjhiSvDSkpKEBAQIPdwiMhBsaaIiIiICAyKiIiIiABw+oyIiIgIADNFRERERAAYFBEREREBYFBEREREBIBBEREREREABkVEREREABgUEREREQFgUEREREQEgEEREREREQAGRUREREQAgP8HxxE6HM5FmPIAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}