pt1_mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import random"
      ],
      "metadata": {
        "id": "Dh7ZJJohQEgf"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "JtIy6iuaQ994"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix"
      ],
      "metadata": {
        "id": "b-cMREoEIVbe"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision"
      ],
      "metadata": {
        "id": "Hskloav_RglK"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from torch import nn\n",
        "from torchvision import datasets, transforms"
      ],
      "metadata": {
        "id": "rhr8J9oSRiYm"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import Dataset, DataLoader"
      ],
      "metadata": {
        "id": "Y3aqV1R6Rxtd"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aZXV25tXCHk0"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Device configuration:\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jAT_KtlKCqVB",
        "outputId": "132fcac3-ded7-48f5-ff02-913a7f4e7fa7"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose([\n",
        "    # Convert the images from PIL format to tensors;\n",
        "    # and scale the pixel values from [0, 255] to [0, 1]\n",
        "    transforms.ToTensor(),\n",
        "    # Normalize the images using the mean and standard deviation of the MNIST dataset.\n",
        "    transforms.Normalize((0.1307,), (0.3081,))\n",
        "])"
      ],
      "metadata": {
        "id": "DKLtKJ6oCGUB"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trn_data = datasets.MNIST(\n",
        "    root= 'data',\n",
        "    train= True,\n",
        "    download= True,\n",
        "    transform= transform\n",
        ")\n",
        "\n",
        "tst_data = datasets.MNIST(\n",
        "    root= 'data',\n",
        "    train= False,\n",
        "    download= True,\n",
        "    transform= transform\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KQSbluGcR9Y1",
        "outputId": "e26090c6-5c49-4ced-cded-99cfae773e9d"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:01<00:00, 5383486.23it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/train-images-idx3-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 155198.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/train-labels-idx1-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:03<00:00, 500913.54it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/t10k-images-idx3-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Failed to download (trying next):\n",
            "HTTP Error 403: Forbidden\n",
            "\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 7788441.85it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/t10k-labels-idx1-ubyte.gz to data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'Training data contains {len(trn_data.data)} samples.')\n",
        "print(f'Test data contains {len(tst_data.data)} samples.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nNMZhQQtVO5w",
        "outputId": "d78247ff-700c-4f63-be57-6a7e2d597258"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training data contains 60000 samples.\n",
            "Test data contains 10000 samples.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def show_images(dataset, n=5):\n",
        "    cols = 5\n",
        "    rows = (n + cols - 1) // cols  # Calculate the number of rows needed\n",
        "\n",
        "    fig, axes = plt.subplots(rows, cols, figsize=(10, 2 * rows))\n",
        "    axes = axes.flatten()  # Flatten the axes array for easy indexing\n",
        "\n",
        "    for i in range(n):\n",
        "        image, label = dataset[i]\n",
        "        axes[i].imshow(image.squeeze(), cmap='gray')\n",
        "        axes[i].set_title(f'Label: {label}')\n",
        "        axes[i].axis('off')\n",
        "\n",
        "    # Hide any unused subplots\n",
        "    for i in range(n, rows * cols):\n",
        "        axes[i].axis('off')\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n"
      ],
      "metadata": {
        "id": "AewIKzJXWFpJ"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "show_images(trn_data, 14)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 608
        },
        "id": "A4VJYEK4W5IQ",
        "outputId": "92f78c67-52bc-4664-aca4-deca9a4b1263"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 15 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "BATCH_SIZE = 32\n",
        "trn_loader = DataLoader(trn_data, batch_size= BATCH_SIZE, shuffle= True)\n",
        "tst_loader = DataLoader(tst_data, batch_size= BATCH_SIZE, shuffle= False)"
      ],
      "metadata": {
        "id": "hTsVEel3XBOo"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trn_loader.dataset.classes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9NbDG2pOXsFm",
        "outputId": "e5e94b4c-529a-4fa0-f5f9-846b3f85365e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['0 - zero',\n",
              " '1 - one',\n",
              " '2 - two',\n",
              " '3 - three',\n",
              " '4 - four',\n",
              " '5 - five',\n",
              " '6 - six',\n",
              " '7 - seven',\n",
              " '8 - eight',\n",
              " '9 - nine']"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dvIm_8F9Qh0N"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class SimpleNet(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(SimpleNet, self).__init__()\n",
        "        self.fc1 = nn.Linear(28 * 28, 128)\n",
        "        self.fc2 = nn.Linear(128, 64)\n",
        "        self.fc3 = nn.Linear(64, 10) # 10 digits\n",
        "        self.dropout = nn.Dropout(.33)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.view(-1, 28 * 28)\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        x = self.dropout(x) # kill 1/3 of the weights\n",
        "        x = torch.relu(self.fc2(x))\n",
        "        x = self.dropout(x) # kill 1/3 of the weights\n",
        "        return torch.softmax(self.fc3(x), dim= 1) # return probability"
      ],
      "metadata": {
        "id": "W5zRKiwoXwNo"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_model(model, loader_trn, loader_tst, criterion, optimizer, epochs):\n",
        "    model.train()\n",
        "    losses_trn, losses_tst = [], []\n",
        "    for epoch in range(1, epochs+1):\n",
        "        running_loss = 0.0\n",
        "        for images, labels in loader_trn:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            optimizer.zero_grad()\n",
        "            preds = model(images)\n",
        "            loss = criterion(preds, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            running_loss += loss.item()\n",
        "\n",
        "        this_loss = running_loss / len(loader_trn)\n",
        "        losses_trn.append(this_loss)\n",
        "\n",
        "        model.eval()\n",
        "        running_loss_tst = 0.0\n",
        "        with torch.inference_mode():\n",
        "            for images, labels in loader_tst:\n",
        "                images, labels = images.to(device), labels.to(device)\n",
        "                preds = model(images)\n",
        "                loss = criterion(preds, labels)\n",
        "                running_loss_tst += loss.item()\n",
        "\n",
        "            this_loss_tst = running_loss_tst / len(loader_tst)\n",
        "            losses_tst.append(this_loss_tst)\n",
        "\n",
        "        print(f'Epoch [{epoch}/{epochs}] => Trn Loss: {this_loss:.4f} | Tst Loss: {this_loss_tst:.4f}')\n",
        "    return losses_trn, losses_tst"
      ],
      "metadata": {
        "id": "GMUotQIAeg0G"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_and_get_misclassified(model, data_loader):\n",
        "    model.eval()\n",
        "    correct, total = 0, 0\n",
        "    misclassified_images = []\n",
        "    with torch.inference_mode():\n",
        "        for images, labels in data_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            _, preds = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (preds == labels).sum().item()\n",
        "            misclassified_images.extend([(img.cpu(), label.cpu(), pred.cpu()) for img, label, pred in zip(images, labels, preds) if label != pred])\n",
        "    acc = correct / total\n",
        "    print(f'Accuracy: {acc*100:.2f}%')\n",
        "    return misclassified_images"
      ],
      "metadata": {
        "id": "UTNsGGhugBWk"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_confusion_matrix(model, data_loader):\n",
        "    model.eval()\n",
        "    preds_all, labels_all = [], []\n",
        "    with torch.inference_mode():\n",
        "        for images, labels in data_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            _, preds = torch.max(outputs.data, 1)\n",
        "            preds_all.extend(preds.cpu().numpy())\n",
        "            labels_all.extend(labels.cpu().numpy())\n",
        "    cm = confusion_matrix(labels_all, preds_all)\n",
        "    plt.figure(figsize= (10, 8))\n",
        "    sns.heatmap(cm, annot= True, fmt= 'd', cmap= 'Blues', xticklabels= range(10), yticklabels= range(10))\n",
        "    plt.xlabel('Predicted')\n",
        "    plt.ylabel('True')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "juXkjRjWG136"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_misclassified(misclassified, n= 5):\n",
        "    \"\"\"\n",
        "    Plot misclassified examples\n",
        "    \"\"\"\n",
        "    cols = 5\n",
        "    rows = (n + cols - 1) // cols\n",
        "    fig, axes = plt.subplots(rows, cols, figsize= (12, 2 * rows))\n",
        "    axes = axes.flatten()\n",
        "    images_labels_preds = random.sample(misclassified, len(misclassified))\n",
        "    for i in range(n):\n",
        "        img, label, pred = images_labels_preds[i]\n",
        "        img = img.squeeze().numpy()\n",
        "        axes[i].imshow(img, cmap= 'gray')\n",
        "        axes[i].set_title(f'True: {label}, Pred: {pred}')\n",
        "        axes[i].axis(False)\n",
        "    for i in range(n, rows * cols):\n",
        "        axes[i].axis(False)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "edkaj1qNPNVh"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize model, criterion, optimizer & learning rate scheduler.\n",
        "model = SimpleNet().to(device)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr= .001)\n",
        "lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size= 5, gamma= .1)"
      ],
      "metadata": {
        "id": "Uk6PPSmehJ-a"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model:\n",
        "EPOCHS = 5\n",
        "trn_losses, tst_losses = train_model(model, trn_loader, tst_loader, criterion, optimizer, EPOCHS)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m2o53pFyhjbE",
        "outputId": "74690018-a98d-4ef3-efaa-5f6bb2b41aa4"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/5] => Trn Loss: 1.6092 | Tst Loss: 1.5257\n",
            "Epoch [2/5] => Trn Loss: 1.5172 | Tst Loss: 1.5050\n",
            "Epoch [3/5] => Trn Loss: 1.5053 | Tst Loss: 1.5178\n",
            "Epoch [4/5] => Trn Loss: 1.4987 | Tst Loss: 1.4973\n",
            "Epoch [5/5] => Trn Loss: 1.4958 | Tst Loss: 1.4989\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Evaluate model on training data:')\n",
        "_ = evaluate_and_get_misclassified(model, trn_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OwGtVmdJmgzB",
        "outputId": "1c97ae62-9d39-41fb-c302-dd049521e160"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Evaluate model on training data:\n",
            "Accuracy: 96.90%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Evaluate model on test data:')\n",
        "missed_images_tst = evaluate_and_get_misclassified(model, tst_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jWgIabkJhyKl",
        "outputId": "0d15f1a9-35f2-49c1-b19c-c4871236a752"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Evaluate model on test data:\n",
            "Accuracy: 96.26%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Although some examples are tough to recognize, few mistakes are really not that hard.\n",
        "plot_misclassified(missed_images_tst, 10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 407
        },
        "id": "_mVlPiTnRj3z",
        "outputId": "91ee54a6-665b-473a-d3ba-0e86cd4b9243"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x400 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Confusion Matrix on Test Data:')\n",
        "plot_confusion_matrix(model, tst_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 713
        },
        "id": "gk7Nesr6Idy6",
        "outputId": "c13a898c-d9f6-4276-9880-f3a819c65f36"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix on Test Data:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1X5rJlrERHkT"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Show the validation curve:\n",
        "plt.plot(range(1, EPOCHS+1), trn_losses, label= 'Training Loss')\n",
        "plt.plot(range(1, EPOCHS+1), tst_losses, label= 'Test Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training Loss Curve')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "aXGROeAgjOYX",
        "outputId": "6f22fcc4-d73f-4ac4-da01-0ed79fdb358d"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABocUlEQVR4nO3dd3hUZf7+8fek94QAaZDQa2iRJrAKLl1EQV1Q0UXd4iq2xcp3fyLouujaWMvaWEEBKwrLqkgVUKRDkBqKIaGkUNP7nN8fQyYEEghpZyZzv65rLjKnzefkoHPznOc5j8UwDAMRERERF+JmdgEiIiIi9U0BSERERFyOApCIiIi4HAUgERERcTkKQCIiIuJyFIBERETE5SgAiYiIiMtRABIRERGXowAkIiIiLkcBSEQqdPfdd9OyZctq7Ttt2jQsFkvtFiQiUosUgEScjMViqdJr9erVZpdqirvvvpuAgACzy6iyhQsXMnLkSJo0aYKXlxdRUVGMGzeOVatWmV2aSINm0VxgIs5l3rx55d5//PHHLF++nLlz55ZbPnToUMLDw6v9OUVFRVitVry9va943+LiYoqLi/Hx8an251fX3XffzYIFC8jOzq73z74ShmFw7733MmfOHOLi4rj11luJiIggJSWFhQsXsnXrVtatW0f//v3NLlWkQfIwuwARuTJ33nlnufcbNmxg+fLlFy2/UG5uLn5+flX+HE9Pz2rVB+Dh4YGHh/73cimvvvoqc+bM4dFHH+W1114rd8vwb3/7G3Pnzq2V36FhGOTn5+Pr61vjY4k0JLoFJtIADRo0iC5durB161auvfZa/Pz8+L//+z8A/vvf/zJq1CiioqLw9vamTZs2PP/885SUlJQ7xoV9gA4fPozFYuGVV17h/fffp02bNnh7e9O7d282b95cbt+K+gBZLBYefPBBFi1aRJcuXfD29iY2Npbvv//+ovpXr15Nr1698PHxoU2bNrz33nu13q/oyy+/pGfPnvj6+tKkSRPuvPNOjh07Vm6b1NRU7rnnHpo3b463tzeRkZHcdNNNHD582L7Nli1bGD58OE2aNMHX15dWrVpx7733XvKz8/LymDFjBh07duSVV16p8Lzuuusu+vTpA1Tep2rOnDlYLJZy9bRs2ZIbbriBpUuX0qtXL3x9fXnvvffo0qUL11133UXHsFqtNGvWjFtvvbXcspkzZxIbG4uPjw/h4eHcd999nDlz5pLnJeJM9E80kQbq1KlTjBw5kttuu40777zTfjtszpw5BAQEMHnyZAICAli1ahVTp04lMzOTl19++bLH/eSTT8jKyuK+++7DYrHwz3/+k5tvvplff/31sq1GP/30E19//TUPPPAAgYGBvPHGG9xyyy0kJyfTuHFjALZv386IESOIjIxk+vTplJSU8Nxzz9G0adOa/1LOmTNnDvfccw+9e/dmxowZpKWl8a9//Yt169axfft2QkJCALjlllvYvXs3Dz30EC1btiQ9PZ3ly5eTnJxsfz9s2DCaNm3K008/TUhICIcPH+brr7++7O/h9OnTPProo7i7u9faeZVKSEjg9ttv57777uNPf/oTHTp0YPz48UybNo3U1FQiIiLK1XL8+HFuu+02+7L77rvP/jt6+OGHSUxM5K233mL79u2sW7euRq2DIg7DEBGnNmnSJOPC/5QHDhxoAMa777570fa5ubkXLbvvvvsMPz8/Iz8/375s4sSJRosWLezvExMTDcBo3Lixcfr0afvy//73vwZg/O9//7Mve/bZZy+qCTC8vLyMgwcP2pft2LHDAIw333zTvmz06NGGn5+fcezYMfuyAwcOGB4eHhcdsyITJ040/P39K11fWFhohIWFGV26dDHy8vLsy7/55hsDMKZOnWoYhmGcOXPGAIyXX3650mMtXLjQAIzNmzdftq7z/etf/zIAY+HChVXavqLfp2EYxuzZsw3ASExMtC9r0aKFARjff/99uW0TEhIu+l0bhmE88MADRkBAgP3vxY8//mgAxvz588tt9/3331e4XMRZ6RaYSAPl7e3NPffcc9Hy8/uCZGVlcfLkSa655hpyc3PZt2/fZY87fvx4GjVqZH9/zTXXAPDrr79edt8hQ4bQpk0b+/tu3boRFBRk37ekpIQVK1YwZswYoqKi7Nu1bduWkSNHXvb4VbFlyxbS09N54IEHynXSHjVqFB07duTbb78FbL8nLy8vVq9eXemtn9KWom+++YaioqIq15CZmQlAYGBgNc/i0lq1asXw4cPLLWvfvj09evTg888/ty8rKSlhwYIFjB492v734ssvvyQ4OJihQ4dy8uRJ+6tnz54EBATwww8/1EnNIvVNAUikgWrWrBleXl4XLd+9ezdjx44lODiYoKAgmjZtau9AnZGRcdnjxsTElHtfGoaq0j/kwn1L9y/dNz09nby8PNq2bXvRdhUtq46kpCQAOnTocNG6jh072td7e3vz0ksvsWTJEsLDw7n22mv55z//SWpqqn37gQMHcssttzB9+nSaNGnCTTfdxOzZsykoKLhkDUFBQYAtgNaFVq1aVbh8/PjxrFu3zt7XafXq1aSnpzN+/Hj7NgcOHCAjI4OwsDCaNm1a7pWdnU16enqd1CxS3xSARBqoikb9nD17loEDB7Jjxw6ee+45/ve//7F8+XJeeuklwNb59XIq67NiVOGJGjXZ1wyPPvoo+/fvZ8aMGfj4+PDMM8/QqVMntm/fDtg6di9YsID169fz4IMPcuzYMe6991569ux5yWH4HTt2BGDnzp1VqqOyzt8XdlwvVdmIr/Hjx2MYBl9++SUAX3zxBcHBwYwYMcK+jdVqJSwsjOXLl1f4eu6556pUs4ijUwAScSGrV6/m1KlTzJkzh0ceeYQbbriBIUOGlLulZaawsDB8fHw4ePDgResqWlYdLVq0AGwdhS+UkJBgX1+qTZs2PPbYYyxbtoxdu3ZRWFjIq6++Wm6bq6++mhdeeIEtW7Ywf/58du/ezWeffVZpDb/5zW9o1KgRn376aaUh5nyl1+fs2bPllpe2VlVVq1at6NOnD59//jnFxcV8/fXXjBkzptyzntq0acOpU6cYMGAAQ4YMuejVvXv3K/pMEUelACTiQkpbYM5vcSksLOTf//63WSWV4+7uzpAhQ1i0aBHHjx+3Lz948CBLliyplc/o1asXYWFhvPvuu+VuVS1ZsoS9e/cyatQowPbcpPz8/HL7tmnThsDAQPt+Z86cuaj1qkePHgCXvA3m5+fHU089xd69e3nqqacqbAGbN28emzZtsn8uwNq1a+3rc3Jy+Oijj6p62nbjx49nw4YNfPjhh5w8ebLc7S+AcePGUVJSwvPPP3/RvsXFxReFMBFnpWHwIi6kf//+NGrUiIkTJ/Lwww9jsViYO3euQ92CmjZtGsuWLWPAgAHcf//9lJSU8NZbb9GlSxfi4+OrdIyioiL+/ve/X7Q8NDSUBx54gJdeeol77rmHgQMHcvvtt9uHwbds2ZK//vWvAOzfv5/Bgwczbtw4OnfujIeHBwsXLiQtLc0+ZPyjjz7i3//+N2PHjqVNmzZkZWXxwQcfEBQUxPXXX3/JGp944gl2797Nq6++yg8//GB/EnRqaiqLFi1i06ZN/PzzzwAMGzaMmJgY/vCHP/DEE0/g7u7Ohx9+SNOmTUlOTr6C364t4Dz++OM8/vjjhIaGMmTIkHLrBw4cyH333ceMGTOIj49n2LBheHp6cuDAAb788kv+9a9/lXtmkIjTMnEEmojUgsqGwcfGxla4/bp164yrr77a8PX1NaKioownn3zSWLp0qQEYP/zwg327yobBVzQsHDCeffZZ+/vKhsFPmjTpon1btGhhTJw4sdyylStXGnFxcYaXl5fRpk0bY9asWcZjjz1m+Pj4VPJbKDNx4kQDqPDVpk0b+3aff/65ERcXZ3h7exuhoaHGhAkTjKNHj9rXnzx50pg0aZLRsWNHw9/f3wgODjb69u1rfPHFF/Zttm3bZtx+++1GTEyM4e3tbYSFhRk33HCDsWXLlsvWWWrBggXGsGHDjNDQUMPDw8OIjIw0xo8fb6xevbrcdlu3bjX69u1reHl5GTExMcZrr71W6TD4UaNGXfIzBwwYYADGH//4x0q3ef/9942ePXsavr6+RmBgoNG1a1fjySefNI4fP17lcxNxZJoLTEScwpgxY9i9ezcHDhwwuxQRaQDUB0hEHE5eXl659wcOHOC7775j0KBB5hQkIg2OWoBExOFERkZy991307p1a5KSknjnnXcoKChg+/bttGvXzuzyRKQBUCdoEXE4I0aM4NNPPyU1NRVvb2/69evHP/7xD4UfEak1agESERERl6M+QCIiIuJyFIBERETE5agPUAWsVivHjx8nMDCw0jl4RERExLEYhkFWVhZRUVG4uV26jUcBqALHjx8nOjra7DJERESkGo4cOULz5s0vuY0CUAUCAwMB2y8wKCjI5GpERESkKjIzM4mOjrZ/j1+KAlAFSm97BQUFKQCJiIg4map0X1EnaBEREXE5CkAiIiLichSARERExOWoD5CIiDgMq9VKYWGh2WWIg/L09MTd3b1WjqUAJCIiDqGwsJDExESsVqvZpYgDCwkJISIiosbP6VMAEhER0xmGQUpKCu7u7kRHR1/2IXbiegzDIDc3l/T0dAAiIyNrdDwFIBERMV1xcTG5ublERUXh5+dndjnioHx9fQFIT08nLCysRrfDFLFFRMR0JSUlAHh5eZlciTi60oBcVFRUo+MoAImIiMPQ/ItyObX1d0QBSERERFyOApCIiIgDadmyJTNnzqzy9qtXr8ZisXD27Nk6q6khUgASERGpBovFcsnXtGnTqnXczZs38+c//7nK2/fv35+UlBSCg4Or9XlV1dCClkaB1bPkU7lYDYOWTfzNLkVERGogJSXF/vPnn3/O1KlTSUhIsC8LCAiw/2wYBiUlJXh4XP5rt2nTpldUh5eXFxEREVe0j6gFqF7956dEBr7yA68t3292KSIiUkMRERH2V3BwMBaLxf5+3759BAYGsmTJEnr27Im3tzc//fQThw4d4qabbiI8PJyAgAB69+7NihUryh33wltgFouFWbNmMXbsWPz8/GjXrh2LFy+2r7+wZWbOnDmEhISwdOlSOnXqREBAACNGjCgX2IqLi3n44YcJCQmhcePGPPXUU0ycOJExY8ZU+/dx5swZfv/739OoUSP8/PwYOXIkBw4csK9PSkpi9OjRNGrUCH9/f2JjY/nuu+/s+06YMIGmTZvi6+tLu3btmD17drVrqQoFoHrUt1UohgFLdqVwIqvA7HJERByWYRjkFhab8jIMo9bO4+mnn+bFF19k7969dOvWjezsbK6//npWrlzJ9u3bGTFiBKNHjyY5OfmSx5k+fTrjxo3jl19+4frrr2fChAmcPn260u1zc3N55ZVXmDt3LmvXriU5OZnHH3/cvv6ll15i/vz5zJ49m3Xr1pGZmcmiRYtqdK533303W7ZsYfHixaxfvx7DMLj++uvtw9UnTZpEQUEBa9euZefOnbz00kv2VrJnnnmGPXv2sGTJEvbu3cs777xDkyZNalTP5egWWD3q0iyYHtEhxB85yxdbjjDpurZmlyQi4pDyikroPHWpKZ+957nh+HnVztfjc889x9ChQ+3vQ0ND6d69u/39888/z8KFC1m8eDEPPvhgpce5++67uf322wH4xz/+wRtvvMGmTZsYMWJEhdsXFRXx7rvv0qZNGwAefPBBnnvuOfv6N998kylTpjB27FgA3nrrLXtrTHUcOHCAxYsXs27dOvr37w/A/PnziY6OZtGiRfzud78jOTmZW265ha5duwLQunVr+/7JycnExcXRq1cvwNYKVtfUAlTP7rq6BQCfbEymxFp7/8oQERHHU/qFXio7O5vHH3+cTp06ERISQkBAAHv37r1sC1C3bt3sP/v7+xMUFGSfEqIifn5+9vADtmkjSrfPyMggLS2NPn362Ne7u7vTs2fPKzq38+3duxcPDw/69u1rX9a4cWM6dOjA3r17AXj44Yf5+9//zoABA3j22Wf55Zdf7Nvef//9fPbZZ/To0YMnn3ySn3/+udq1VJVagOrZqG6RPP/tHo6dzeOHfekM6RxudkkiIg7H19OdPc8NN+2za4u/f/kBL48//jjLly/nlVdeoW3btvj6+nLrrbdSWFh4yeN4enqWe2+xWC45aWxF29fmrb3q+OMf/8jw4cP59ttvWbZsGTNmzODVV1/loYceYuTIkSQlJfHdd9+xfPlyBg8ezKRJk3jllVfqrB61ANUzH093xveKBmDuhiSTqxERcUwWiwU/Lw9TXnX5NOp169Zx9913M3bsWLp27UpERASHDx+us8+rSHBwMOHh4WzevNm+rKSkhG3btlX7mJ06daK4uJiNGzfal506dYqEhAQ6d+5sXxYdHc1f/vIXvv76ax577DE++OAD+7qmTZsyceJE5s2bx8yZM3n//ferXU9VqAXIBHf0jeH9H39lzf4TJJ3KoUVjDYkXEXEF7dq14+uvv2b06NFYLBaeeeaZS7bk1JWHHnqIGTNm0LZtWzp27Mibb77JmTNnqhT+du7cSWBgoP29xWKhe/fu3HTTTfzpT3/ivffeIzAwkKeffppmzZpx0003AfDoo48ycuRI2rdvz5kzZ/jhhx/o1KkTAFOnTqVnz57ExsZSUFDAN998Y19XVxSATNCisT8D2zdldcIJ5m9M5v+ur9uLLCIijuG1117j3nvvpX///jRp0oSnnnqKzMzMeq/jqaeeIjU1ld///ve4u7vz5z//meHDh1dpdvVrr7223Ht3d3eKi4uZPXs2jzzyCDfccAOFhYVce+21fPfdd/bbcSUlJUyaNImjR48SFBTEiBEjeP311wHbs4ymTJnC4cOH8fX15ZprruGzzz6r/RM/j8Uw+6agA8rMzCQ4OJiMjAyCgoLq5DNW7k3jDx9tIcTPkw1TBuNTi/ecRUScTX5+PomJibRq1QofHx+zy3E5VquVTp06MW7cOJ5//nmzy7mkS/1duZLvb/UBMsmgDmE0C/HlbG4R3/yScvkdREREaklSUhIffPAB+/fvZ+fOndx///0kJiZyxx13mF1avVEAMom7m4U7+sYA6gwtIiL1y83NjTlz5tC7d28GDBjAzp07WbFiRZ33u3Ek6gNkovG9o5m5Yj87jpzll6Nn6dY8xOySRETEBURHR7Nu3TqzyzCVWoBM1CTAm+u7RgIwT61AIiIi9UYByGSlT4ZevOM4GblFJlcjIiLiGhSATNazRSM6RgSSX2RlwbajZpcjIiLiEhSATGaxWLirn60VaN6GJKyaH0xERKTOKQA5gDE9mhHg7UHiyRx+PnTK7HJEREQaPAUgB+Dv7cEtVzUDYO6Gw+YWIyIi4gIUgBzEnec6Qy/fk0ZKRp7J1YiIiDRsCkAOol14IH1bhWI14NONyWaXIyIil2GxWC75mjZtWo2OvWjRolrbTi6mAORASjtDf7r5CIXF9T87sIiIVF1KSor9NXPmTIKCgsote/zxx80uUS5BAciBDOscQdNAb05kFbBsT6rZ5YiIyCVERETYX8HBwVgslnLLPvvsMzp16oSPjw8dO3bk3//+t33fwsJCHnzwQSIjI/Hx8aFFixbMmDEDgJYtWwIwduxYLBaL/f2VslqtPPfcczRv3hxvb2969OjB999/X6UaDMNg2rRpxMTE4O3tTVRUFA8//HD1flEOSlNhOBAvDzdu7x3NG6sOMnd9Ejd0izK7JBERcxgGFOWa89mefmCx1OgQ8+fPZ+rUqbz11lvExcWxfft2/vSnP+Hv78/EiRN54403WLx4MV988QUxMTEcOXKEI0eOALB582bCwsKYPXs2I0aMwN3dvVo1/Otf/+LVV1/lvffeIy4ujg8//JAbb7yR3bt3065du0vW8NVXX/H666/z2WefERsbS2pqKjt27KjR78TRKAA5mNv7xvD26kNsTDzNgbQs2oUHml2SiEj9K8qFf5j0j8D/Ow5e/jU6xLPPPsurr77KzTffDECrVq3Ys2cP7733HhMnTiQ5OZl27drxm9/8BovFQosWLez7Nm3aFICQkBAiIiKqXcMrr7zCU089xW233QbASy+9xA8//MDMmTN5++23L1lDcnIyERERDBkyBE9PT2JiYujTp0+1a3FEpt4CW7t2LaNHjyYqKqrKHbkKCgr429/+RosWLfD29qZly5Z8+OGH5bb58ssv6dixIz4+PnTt2pXvvvuujs6g9kUG+zKkUxig+cFERJxRTk4Ohw4d4g9/+AMBAQH219///ncOHToEwN133018fDwdOnTg4YcfZtmyZbVaQ2ZmJsePH2fAgAHllg8YMIC9e/detobf/e535OXl0bp1a/70pz+xcOFCiouLa7VGs5naApSTk0P37t2599577Sn5csaNG0daWhr/+c9/aNu2LSkpKVitZR2Gf/75Z26//XZmzJjBDTfcwCeffMKYMWPYtm0bXbp0qatTqVV3Xd2SpbvT+GrbMZ4c0RF/bzXUiYiL8fSztcSY9dk1kJ2dDcAHH3xA3759y60rvZ111VVXkZiYyJIlS1ixYgXjxo1jyJAhLFiwoEaffSUuVUN0dDQJCQmsWLGC5cuX88ADD/Dyyy+zZs0aPD09663GOmU4CMBYuHDhJbdZsmSJERwcbJw6darSbcaNG2eMGjWq3LK+ffsa9913X5VrycjIMAAjIyOjyvvUppISq3Hdyz8YLZ76xpi34bApNYiI1Ke8vDxjz549Rl5entmlVMvs2bON4OBg+/uoqCjjueeeq/L+33//vQHYv988PT2NBQsWXHa/S313RkVFGS+88EK5Zb179zYmTZpUpRrOt2/fPgMwtm7detma6tql/q5cyfe3UzUtLF68mF69evHPf/6TuXPn4u/vz4033sjzzz+Pr68vAOvXr2fy5Mnl9hs+fPglb68VFBRQUFBgf5+ZmVkn9VeVm5uFCVe34Plv9jB3fRJ39InBUsMOeSIiUn+mT5/Oww8/THBwMCNGjKCgoIAtW7Zw5swZJk+ezGuvvUZkZCRxcXG4ubnx5ZdfEhERQUhICGAbCbZy5UoGDBiAt7c3jRo1qvSzEhMTiY+PL7esXbt2PPHEEzz77LO0adOGHj16MHv2bOLj45k/fz7AJWuYM2cOJSUl9O3bFz8/P+bNm4evr2+5fkLOzqkC0K+//spPP/2Ej48PCxcu5OTJkzzwwAOcOnWK2bNnA5Camkp4eHi5/cLDw0lNrXxY+YwZM5g+fXqd1n6lbr2qOS8v3ce+1Cy2Jp2hV8tQs0sSEZEq+uMf/4ifnx8vv/wyTzzxBP7+/nTt2pVHH30UgMDAQP75z39y4MAB3N3d6d27N9999x1ubrauua+++iqTJ0/mgw8+oFmzZhw+fLjSz7rwH/0AP/74Iw8//DAZGRk89thjpKen07lzZxYvXky7du0uW0NISAgvvvgikydPpqSkhK5du/K///2Pxo0b1/rvyiwWwzAcYvpxi8XCwoULGTNmTKXbDBs2jB9//JHU1FSCg4MB+Prrr7n11lvJycnB19cXLy8vPvroI26//Xb7fv/+97+ZPn06aWlpFR63ohag6OhoMjIyCAoKqp0TrIYnF+zgiy1HualHFP+6Lc60OkRE6lp+fj6JiYm0atUKHx8fs8sRB3apvyuZmZkEBwdX6fvbqR6EGBkZSbNmzezhB6BTp04YhsHRo0cB24OpLgw6aWlplxxK6O3tTVBQULmXI7jr6pYAfLczhZPZBZfeWERERKrMqQLQgAEDOH78uL2HPcD+/ftxc3OjefPmAPTr14+VK1eW22/58uX069evXmutDV2bB9M9OoSiEoPPNx8xuxwREZEGw9QAlJ2dTXx8vL3zVmlHruRk22SgU6ZM4fe//719+zvuuIPGjRtzzz33sGfPHtauXcsTTzzBvffea+8E/cgjj/D999/z6quvsm/fPqZNm8aWLVt48MEH6/38asNd52aJ/2RjMiVWh7hbKSIi4vRMDUBbtmwhLi6OuDhb/5bJkycTFxfH1KlTAdtEc6VhCCAgIIDly5dz9uxZevXqxYQJExg9ejRvvPGGfZv+/fvzySef8P7779O9e3cWLFjAokWLnOYZQBe6oVskIX6eHDubx+qEdLPLERERaRAcphO0I7mSTlT14R/f7eX9tb8yqENT5tzTsB5FLiICZR1bW7ZsaW/RF6lIXl4ehw8fdq1O0K5qQt8YANbsP0HSqRyTqxERqX2lT0guLCw0uRJxdLm5tklya/pEaqd6DpCratHYn4Htm7Jm/wk+2ZjMlOs7mV2SiEit8vDwwM/PjxMnTuDp6Wl/Ho5IKcMwyM3NJT09nZCQEHtori4FICdx19UtWLP/BJ9vOcJfh7bHx7NmF15ExJFYLBYiIyNJTEwkKUkTQUvlQkJCLvlom6pSAHIS13UMo1mIL8fO5vHtLync0rO52SWJiNQqLy8v2rVrp9tgUilPT88at/yUUgByEu5uFu7oG8PLSxOYuyFJAUhEGiQ3Nzc9CVrqhW6yOpFxvaLxdLcQf+QsO49mmF2OiIiI01IAciJNA70Z2SUSgHkbdI9cRESkuhSAnMxd/WxPhv7vjmNk5BaZXI2IiIhzUgByMr1aNKJjRCD5RVa+2nbU7HJERESckgKQk7FYLNx5bn6weRuS0IO8RURErpwCkBMaE9eMAG8Pfj2Zw8+HTpldjoiIiNNRAHJCAd4e3HxVMwDmrldnaBERkSulAOSkSm+DLd+bRkpGnsnViIiIOBcFICfVPjyQvq1CKbEafLrpiNnliIiIOBUFICdW2gr06aZkikqsJlcjIiLiPBSAnNjw2AiaBHhzIquAZbvTzC5HRETEaSgAOTEvDzdu7xMNwNwNh80tRkRExIkoADm52/vE4GaBDb+e5kBaltnliIiIOAUFICcXFeLLkE7hAMzfmGxyNSIiIs5BAagBKJ0f7KutR8kpKDa5GhEREcenANQADGjThFZN/MkqKOa/8cfNLkdERMThKQA1AG5uFib0jQHg4/WHNT+YiIjIZSgANRC/6xmNj6cb+1Kz2JZ8xuxyREREHJoCUAMR7OfJjd2jAM0PJiIicjkKQA1I6ZOhv9uZysnsApOrERERcVwKQA1It+YhdG8eTGGJlS+2aH4wERGRyigANTClrUDzNyRTYlVnaBERkYooADUwo7tHEezrybGzeazZn252OSIiIg5JAaiB8fF0Z1yv5oA6Q4uIiFRGAagBmtDXdhts9f4TJJ/KNbkaERERx6MA1AC1bOLPte2bYhgwf5NagURERC6kANRA3XWuM/QXm4+QX1RicjUiIiKORQGogfptxzCahfhyJreI73ammF2OiIiIQ1EAaqDc3SzccW5+sLkbdBtMRETkfApADdi4XtF4ulvYnnyWXccyzC5HRETEYSgANWBNA70Z0SUSgHlqBRIREbFTAGrgSjtDL4o/RkZekcnViIiIOAYFoAaud8tGdAgPJL/IytfbjppdjoiIiENQAGrgLBYLd/aztQLN3ZCEYWh+MBEREQUgFzA2rhn+Xu78eiKH9YdOmV2OiIiI6RSAXECAtwc3X3VufjB1hhYREVEAchV3nusMvWxPGqkZ+SZXIyIiYi4FIBfRISKQPq1CKbEafLop2exyRERETKUA5EJKW4E+3ZRMUYnV5GpERETMowDkQkbERtAkwIv0rAKW70kzuxwRERHTKAC5EC8PN27rfW5+sPXqDC0iIq5LAcjF3N43BjcLrP/1FAfTs8wuR0RExBQKQC6mWYgvgzuFAzBvgzpDi4iIazI1AK1du5bRo0cTFRWFxWJh0aJFl9x+9erVWCyWi16pqan2bUpKSnjmmWdo1aoVvr6+tGnThueff15PQD5P6fxgX209Sm5hscnViIiI1D8PMz88JyeH7t27c++993LzzTdXeb+EhASCgoLs78PCwuw/v/TSS7zzzjt89NFHxMbGsmXLFu655x6Cg4N5+OGHa7V+Z/Wbtk1o2diPw6dy+W/8cW7vE2N2SSIiIvXK1AA0cuRIRo4cecX7hYWFERISUuG6n3/+mZtuuolRo0YB0LJlSz799FM2bdpUk1IbFDc3C3de3YK/f7uXueuTuK13NBaLxeyyRERE6o1T9gHq0aMHkZGRDB06lHXr1pVb179/f1auXMn+/fsB2LFjBz/99FO1glZDdmvP5nh7uLEnJZNtyWfNLkdERKRemdoCdKUiIyN599136dWrFwUFBcyaNYtBgwaxceNGrrrqKgCefvppMjMz6dixI+7u7pSUlPDCCy8wYcKESo9bUFBAQUGB/X1mZmadn4vZQvy8uLF7FF9uPcq8DUn0bNHI7JJERETqjVO1AHXo0IH77ruPnj170r9/fz788EP69+/P66+/bt/miy++YP78+XzyySds27aNjz76iFdeeYWPPvqo0uPOmDGD4OBg+ys6Oro+Tsd0pU+G/vaXFE5lF1xmaxERkYbDqQJQRfr06cPBgwft75944gmefvppbrvtNrp27cpdd93FX//6V2bMmFHpMaZMmUJGRob9deTIkfoo3XTdo0Po1jyYwhIrX2w5anY5IiIi9cbpA1B8fDyRkZH297m5ubi5lT8td3d3rNbK577y9vYmKCio3MtVlLYCzd+YRIlVjwoQERHXYGofoOzs7HKtN4mJicTHxxMaGkpMTAxTpkzh2LFjfPzxxwDMnDmTVq1aERsbS35+PrNmzWLVqlUsW7bMfozRo0fzwgsvEBMTQ2xsLNu3b+e1117j3nvvrffzcwaju0Xxwrd7OXomjzX70/ltx3CzSxIREalzpgagLVu2cN1119nfT548GYCJEycyZ84cUlJSSE4ue1pxYWEhjz32GMeOHcPPz49u3bqxYsWKcsd48803eeaZZ3jggQdIT08nKiqK++67j6lTp9bfiTkRXy93ftezObN+SmTehmQFIBERcQkWQ49IvkhmZibBwcFkZGS4xO2wxJM5XPfKaiwWWPvEdUSH+pldkoiIyBW7ku9vp+8DJDXXqok/17RrgmHA/I2aH0xERBo+BSAByuYH+2LLEfKLSkyuRkREpG4pAAkAv+0YRlSwD6dzClmyK8XsckREROqUApAA4OHuxh19bZOizl2fZHI1IiIidUsBSOzG9Y7Gw83CtuSz7DqWYXY5IiIidUYBSOzCAn0Y0SUCsD0YUUREpKFSAJJySjtDL9p+nIy8IpOrERERqRsKQFJOn1ahtA8PIK+ohK+3aX4wERFpmBSApByLxWJvBZq3IQk9J1NERBoiBSC5yJi4Zvh7uXPoRA7rfz1ldjkiIiK1TgFILhLo48nYq5oBtlYgERGRhkYBSCp057nbYEt3p5GWmW9yNSIiIrVLAUgq1DEiiD4tQymxGny6SfODiYhIw6IAJJW6s5+tFejTTckUlVhNrkZERKT2KABJpUbERtAkwIu0zAJW7EkzuxwREZFaowAklfLycGN872gA5qoztIiINCAKQHJJt/eJwc0CPx86xcH0bLPLERERqRUKQHJJzRv58duO4YDmBxMRkYZDAUgu665znaEXbD1KbmGxydWIiIjUnAKQXNY1bZvQorEfWfnFLI4/bnY5IiIiNaYAJJfl5mbhzr62VqCP12t+MBERcX4KQFIlt/ZsjreHG3tSMtl+5KzZ5YiIiNSIApBUSSN/L0Z3jwJg3np1hhYREeemACRVdte5+cG++SWF0zmFJlcjIiJSfQpAUmXdo0Po2iyYwhIrX2w5YnY5IiIi1aYAJFektBVo/sYkSqzqDC0iIs5JAUiuyOjuUQT5eHDkdB5r958wuxwREZFqUQCSK+Lr5c7vetnmB5un+cFERMRJKQDJFZvQNwaAVQnpHDmda3I1IiIiV04BSK5Y66YBXNOuCYYBn2xKNrscERGRK6YAJNVy57nO0J9vPkJBcYnJ1YiIiFwZBSCplsEdw4gM9uF0TiFLdqaaXY6IiMgVUQCSavFwd+OOPra+QHPVGVpERJyMApBU2/g+0Xi4WdiadIbdxzPMLkdERKTKFICk2sICfRjeJQKAeRvUGVpERJyHApDUSOmToRdtP0ZmfpHJ1YiIiFSNApDUSN9WobQLCyCvqISvtx41uxwREZEqUQCSGrFYLNzVz9YKNG9jMoah+cFERMTxKQBJjY2Na4aflzsH07PZ8Otps8sRERG5LAUgqbFAH0/GxjUDND+YiIg4BwUgqRWlT4ZeujuVtMx8k6sRERG5NAUgqRWdIoPo3bIRxVaDzzYdMbscERGRS1IAklpT2gr0yaYkikqsJlcjIiJSOQUgqTUjukTQJMCLtMwCVu5NM7scERGRSikASa3x9nBnXK9oQPODiYiIY1MAklp1R98YLBZYd/AUB9OzzS5HRESkQgpAUquaN/JjcMcwAOZvVCuQiIg4JgUgqXWlnaEXbD1KbmGxydWIiIhczNQAtHbtWkaPHk1UVBQWi4VFixZdcvvVq1djsVgueqWmppbb7tixY9x55500btwYX19funbtypYtW+rwTOR817ZrSkyoH1n5xfxvx3GzyxEREbmIqQEoJyeH7t278/bbb1/RfgkJCaSkpNhfYWFh9nVnzpxhwIABeHp6smTJEvbs2cOrr75Ko0aNart8qYSbm4U7r44B4OP1SZofTEREHI6HmR8+cuRIRo4cecX7hYWFERISUuG6l156iejoaGbPnm1f1qpVq+qWKNX0u57RvLJsP7uPZxJ/5CxxMQqgIiLiOJyyD1CPHj2IjIxk6NChrFu3rty6xYsX06tXL373u98RFhZGXFwcH3zwgUmVuq5G/l6M7hYFaEi8iIg4HqcKQJGRkbz77rt89dVXfPXVV0RHRzNo0CC2bdtm3+bXX3/lnXfeoV27dixdupT777+fhx9+mI8++qjS4xYUFJCZmVnuJTV3Vz9bZ+hvfknhdE6hydWIiIiUsRgO0kHDYrGwcOFCxowZc0X7DRw4kJiYGObOnQuAl5cXvXr14ueff7Zv8/DDD7N582bWr19f4TGmTZvG9OnTL1qekZFBUFDQFdUjZQzD4Ma31rHzWAZTRnbkvoFtzC5JREQasMzMTIKDg6v0/e1ULUAV6dOnDwcPHrS/j4yMpHPnzuW26dSpE8nJyZUeY8qUKWRkZNhfR45oMs/aYLGUdYaetzEJq9UhsraIiIjzB6D4+HgiIyPt7wcMGEBCQkK5bfbv30+LFi0qPYa3tzdBQUHlXlI7buzejEAfD46czmPNgRNmlyMiIgKYPAosOzu7XOtNYmIi8fHxhIaGEhMTw5QpUzh27Bgff/wxADNnzqRVq1bExsaSn5/PrFmzWLVqFcuWLbMf469//Sv9+/fnH//4B+PGjWPTpk28//77vP/++/V+fgK+Xu78rmc0H65LZN76JK7rEHb5nUREROqYqS1AW7ZsIS4ujri4OAAmT55MXFwcU6dOBSAlJaXcravCwkIee+wxunbtysCBA9mxYwcrVqxg8ODB9m169+7NwoUL+fTTT+nSpQvPP/88M2fOZMKECfV7cmI34dxtsFUJ6Rw5nWtyNSIiIg7UCdqRXEknKqmaO2dt5KeDJ3lgUBueHNHR7HJERKQBcqlO0OIcSucH+3zzEQqKS0yuRkREXJ0CkNSLIZ3CiAjy4VROId/vSr38DiIiInVIAUjqhYe7G3f0tfUFmrteT4YWERFzKQBJvbmtdzQebha2JJ1hz3E9bVtERMxTrQB05MgRjh49an+/adMmHn30UQ01l0sKC/JheJcIwPZgRBEREbNUKwDdcccd/PDDDwCkpqYydOhQNm3axN/+9jeee+65Wi1QGpY7+9o6Qy/afozM/CKTqxEREVdVrQC0a9cu+vTpA8AXX3xBly5d+Pnnn5k/fz5z5sypzfqkgbm6dShtwwLILSxh4bZjZpcjIiIuqloBqKioCG9vbwBWrFjBjTfeCEDHjh1JSUmpveqkwbFYLNx1bkj8vA1J6DFUIiJihmoFoNjYWN59911+/PFHli9fzogRIwA4fvw4jRs3rtUCpeEZe1Uz/LzcOZCezcbE02aXIyIiLqhaAeill17ivffeY9CgQdx+++10794dgMWLF9tvjYlUJsjHkzFxzQCYu0GdoUVEpP5VazLUQYMGcfLkSTIzM2nUqJF9+Z///Gf8/PxqrThpuO7s24JPNiazdFcq6Zn5hAX5mF2SiIi4kGq1AOXl5VFQUGAPP0lJScycOZOEhATCwjTbt1xe56ggerVoRLHV4LPNR8wuR0REXEy1AtBNN93Exx9/DMDZs2fp27cvr776KmPGjOGdd96p1QKl4bqrn60z9CcbkykusZpcjYiIuJJqBaBt27ZxzTXXALBgwQLCw8NJSkri448/5o033qjVAqXhGtElgsb+XqRm5rNib7rZ5YiIiAupVgDKzc0lMDAQgGXLlnHzzTfj5ubG1VdfTVKSOrVK1Xh7uDO+dzRgGxIvIiJSX6oVgNq2bcuiRYs4cuQIS5cuZdiwYQCkp6cTFBRUqwVKw3Z7nxgsFvjp4EkOncg2uxwREXER1QpAU6dO5fHHH6dly5b06dOHfv36AbbWoLi4uFotUBq26FA/ftvB1nF+/oZkk6sRERFXUa0AdOutt5KcnMyWLVtYunSpffngwYN5/fXXa604cQ13nusMvWDrEfIKS0yuRkREXEG1AhBAREQEcXFxHD9+3D4zfJ8+fejYsWOtFSeuYWC7pkSH+pKZX8z/dhw3uxwREXEB1QpAVquV5557juDgYFq0aEGLFi0ICQnh+eefx2rVcGa5Mm5uFvss8R9vOKz5wUREpM5VKwD97W9/46233uLFF19k+/btbN++nX/84x+8+eabPPPMM7Vdo7iA3/WKxsvDjV3HMtlxNMPsckREpIGr1lQYH330EbNmzbLPAg/QrVs3mjVrxgMPPMALL7xQawWKawj19+KGbpF8ve0Yc9cn0SM6xOySRESkAatWC9Dp06cr7OvTsWNHTp/W7N5SPXddbbsN9r9fjnMmp9DkakREpCGrVgDq3r07b7311kXL33rrLbp161bjosQ19YgOoUuzIAqLrXy5VfODiYhI3anWLbB//vOfjBo1ihUrVtifAbR+/XqOHDnCd999V6sFiuuwWCzcdXULnvpqJ/M2JPPH37TGzc1idlkiItIAVasFaODAgezfv5+xY8dy9uxZzp49y80338zu3buZO3dubdcoLmR09ygCfTxIPp3L2gMnzC5HREQaKItRi2OOd+zYwVVXXUVJiXM/zC4zM5Pg4GAyMjI0tYcJpv9vN7PXHWZIpzBmTextdjkiIuIkruT7u9oPQhSpK3ee6wy9al86R8/kmlyNiIg0RApA4nDaNA1gQNvGWA34dJPmBxMRkdqnACQOqXRI/Oebj1BQ7Ny3VEVExPFc0Siwm2+++ZLrz549W5NaROyGdAonPMibtMwCvt+Vyk09mpldkoiINCBX1AIUHBx8yVeLFi34/e9/X1e1igvxcHfjjj62VqB5G5JMrkZERBqaK2oBmj17dl3VIXKR2/pE8+aqA2w+fIa9KZl0itSIPBERqR3qAyQOKzzIh+GxEYBagUREpHYpAIlDKx0Sv3D7MbLyi0yuRkREGgoFIHFoV7cOpW1YALmFJSzcfszsckREpIFQABKHZrFYuLNvDABz1ydRiw8uFxERF6YAJA7v5p7N8fV050B6NpsST5tdjoiINAAKQOLwgnw8GRNnew7QXHWGFhGRWqAAJE7hzqttt8G+35VKela+ydWIiIizUwASpxAbFUzPFo0othp8vumI2eWIiIiTUwASp1E6P9gnm5IpLrGaXI2IiDgzBSBxGiO7RhDq70VKRj4r96WbXY6IiDgxBSBxGt4e7ozvHQ3oydAiIlIzCkDiVO7oE4PFAj8eOMmvJ7LNLkdERJyUApA4lehQP67rEAbA/I3JJlcjIiLOSgFInE5pZ+gFW4+SV1hicjUiIuKMFIDE6VzbvinRob5k5BXxv1+Om12OiIg4IQUgcTrubhYm9LW1AqkztIiIVIepAWjt2rWMHj2aqKgoLBYLixYtuuT2q1evxmKxXPRKTU2tcPsXX3wRi8XCo48+WvvFi6nG9YrGy8ONX45msOPIWbPLERERJ2NqAMrJyaF79+68/fbbV7RfQkICKSkp9ldYWNhF22zevJn33nuPbt261Va54kBC/b24oWskoPnBRETkypkagEaOHMnf//53xo4de0X7hYWFERERYX+5uZU/jezsbCZMmMAHH3xAo0aNarNkcSB39rPdBvvfjuOcySk0uRoREXEmTtkHqEePHkRGRjJ06FDWrVt30fpJkyYxatQohgwZUqXjFRQUkJmZWe4lji8uOoTYqCAKiq0s2HrU7HJERMSJOFUAioyM5N133+Wrr77iq6++Ijo6mkGDBrFt2zb7Np999hnbtm1jxowZVT7ujBkzCA4Otr+io6PronypZRaLxT4kft7GJKxWw+SKRETEWThVAOrQoQP33XcfPXv2pH///nz44Yf079+f119/HYAjR47wyCOPMH/+fHx8fKp83ClTppCRkWF/HTmi2cadxY09ogj08SDpVC4/HjxpdjkiIuIknCoAVaRPnz4cPHgQgK1bt5Kens5VV12Fh4cHHh4erFmzhjfeeAMPDw9KSip+aJ63tzdBQUHlXuIc/Lw8uOWq5gDMXa/O0CIiUjVOH4Di4+OJjLSNBho8eDA7d+4kPj7e/urVqxcTJkwgPj4ed3d3k6uVunDnudtgq/alcexsnsnViIiIM/Aw88Ozs7PtrTcAiYmJxMfHExoaSkxMDFOmTOHYsWN8/PHHAMycOZNWrVoRGxtLfn4+s2bNYtWqVSxbtgyAwMBAunTpUu4z/P39ady48UXLpeFoGxZA/zaN+fnQKT7dmMzjwzuYXZKIiDg4U1uAtmzZQlxcHHFxcQBMnjyZuLg4pk6dCkBKSgrJyWUTXhYWFvLYY4/RtWtXBg4cyI4dO1ixYgWDBw82pX5xHKWdoT/bnExhsdXkakRExNFZDMPQ0JkLZGZmEhwcTEZGhvoDOYmiEiu/eWkVaZkFvHF7HDd2jzK7JBERqWdX8v3t9H2ARAA83d24vU8MAPPUGVpERC5DAUgajNv7xODuZmHT4dPsS9XDLEVEpHIKQNJghAf5MDw2HNAs8SIicmkKQNKglA6JX7jtGFn5RSZXIyIijkoBSBqUfq0b06apPzmFJSzafszsckRExEEpAEmDYrFY7K1AczckoUGOIiJSEQUgaXBuvqo5vp7u7E/LZvPhM2aXIyIiDkgBSBqcYF9PxsTZngM0V52hRUSkAgpA0iCV3gb7flcK6Vn5JlcjIiKORgFIGqTYqGCuigmhqMTgi81HzC5HREQcjAKQNFh39bO1An2yMZniEs0PJiIiZRSApMEa2SWSUH8vjmfks2pfutnliIiIA1EAkgbLx9Odcb2iAXWGFhGR8hSApEGb0DcGiwV+PHCSxJM5ZpcjIiIOQgFIGrToUD+u6xAGwHy1AomIyDkKQNLg3Xl1DABfbj1KflGJydWIiIgjUACSBm9g+zCaN/IlI6+I/+04bnY5IiLiABSApMFzd7Mwoa9tSPw83QYTEREUgMRFjOvVHC93N3YczWDHkbNmlyMiIiZTABKX0DjAm1HdIgG1AomIiAKQuJDS+cEW7zjO2dxCk6sREREzKQCJy7gqJoTOkUEUFFtZsPWo2eWIiIiJFIDEZVgsFvv8YPM2JGG1GiZXJCIiZlEAEpdyU48oAr09OHwql58OnjS7HBERMYkCkLgUPy8PbunZHND8YCIirkwBSFxO6ZOhV+5N49jZPJOrERERMygAictpGxZIv9aNsRrw2aZks8sRERETKACJSyrtDP3ppiMUFltNrkZEROqbApC4pKGdwwkL9OZkdgFLd6eaXY6IiNQzBSBxSZ7ubtzex9YXSJ2hRURcjwKQuKzb+8Tg7mZhU+JpElKzzC5HRETqkQKQuKyIYB+GdQ4HND+YiIirUQASl3bXufnBvt52lOyCYpOrERGR+qIAVN8MTb/gSPq1aUzrpv7kFJawcPsxs8sREZF6ogBUn3JPw7vXwI7PwKqh147AYrFwZ99z84OtT8JQQBURcQkKQPVpwzuQthMW3gfvXQsHV6hFyAHc0rM5Pp5uJKRlsSXpjNnliIhIPVAAqk+/+SsMfha8g2xBaN4t8PFNcDze7MpcWrCvJ2N6NANg7np1hhYRcQUKQPXJyw+umQyP7ICrJ4G7FySugfcHwoI/wJnDZlfosu481xl6ya4UTmQVmFyNiIjUNQUgM/iFwoh/wIOboevvbMt2LYA3e8H3UyDnlLn1uaAuzYKJiwmhqMTgiy1HzC5HRETqmAKQmRq1hFtmwZ/XQOtBYC2CDf+GN3rAj69CYa7JBbqW0iHx8zckUWJV3ywRkYZMAcgRRPWA3/8X7vwawrtCQSasfA7e7AnbPgZridkVuoTru0bSyM+T4xn5rNqXbnY5IiJShxSAHEnbwXDfWhj7PgTHQNZxWPwQvNMfEr7XiLE65uPpzrje0YDmBxMRaegUgByNmxt0H2/rHzTs7+ATAif2wafjYc4oOLrF7AobtAl9WmCxwNr9Jzh8MsfsckREpI4oADkqTx/o/xA8Eg8DHgF3b0haB7MGwxe/h1OHzK6wQYpp7Meg9k0BmL9RrUAiIg2VApCj820EQ5+Dh7dBjwmABfb8F97uA98+Btnqq1LbSofEf7HlKPlF6n8lItIQKQA5i+DmMObfcP86aDcMrMWweRa8EQerX4SCbLMrbDAGdQijWYgvGXlFfPNLitnliIhIHVAAcjbhsTDhS5j4DURdBYXZsHqGLQhtngUlRWZX6PTc3SxMuDoGUGdoEZGGSgHIWbW6Bv60Cm6dDY1aQU667ZbYv6+GPYs1YqyGxvWKxsvdjR1HzvLL0bNmlyMiIrXM1AC0du1aRo8eTVRUFBaLhUWLFl1y+9WrV2OxWC56paam2reZMWMGvXv3JjAwkLCwMMaMGUNCQkIdn4lJLBbocjNM2gQj/wl+jeHUQfjiLvjPMEhab3aFTqtJgDfXd40AYJ5agUREGhxTA1BOTg7du3fn7bffvqL9EhISSElJsb/CwsLs69asWcOkSZPYsGEDy5cvp6ioiGHDhpGT04CHNHt4Qd/74OF4uPYJ8PSDo5tg9gj49HY40UADYB27q5+tM/R/44+TkatbiyIiDYnFMBzjXonFYmHhwoWMGTOm0m1Wr17Nddddx5kzZwgJCanScU+cOEFYWBhr1qzh2muvrdI+mZmZBAcHk5GRQVBQUJX2cShZqbZ+QdvmglECFjeIuxMG/R8ERZpdndMwDIPr3/iJvSmZ/L9RnfjjNa3NLklERC7hSr6/nbIPUI8ePYiMjGTo0KGsW7fukttmZGQAEBoaWuk2BQUFZGZmlns5tcAIGP0veGADdLwBDKttSo034mDl85Dv5OdXTywWS9n8YBuTsWp+MBGRBsOpAlBkZCTvvvsuX331FV999RXR0dEMGjSIbdu2Vbi91Wrl0UcfZcCAAXTp0qXS486YMYPg4GD7Kzo6uq5OoX41bQ+3zYd7l0J0XyjOgx9fsU22uuFdKC40u0KHd1OPKAK9PUg8mcO6QyfNLkdERGqJU90Cq8jAgQOJiYlh7ty5F627//77WbJkCT/99BPNmzev9BgFBQUUFBTY32dmZhIdHe28t8AqYhiw71tYMQ1OHbAta9QSfvsMxN5sm4JDKjRt8W7m/HyYYZ3Def/3vcwuR0REKtHgb4Gdr0+fPhw8ePCi5Q8++CDffPMNP/zwwyXDD4C3tzdBQUHlXg2OxQKdbrDdFrvhdQgIhzOH4as/wAfXwa9rzK7QYU3oa3sm0Iq9aRw/m2dyNSIiUhucPgDFx8cTGVnWsdcwDB588EEWLlzIqlWraNWqlYnVOSB3D+h1Lzy8Ha77G3gFQEo8fHwjzLsVUneZXaHDaRceyNWtQ7Ea8NmmZLPLERGRWmBqAMrOziY+Pp74+HgAEhMTiY+PJznZ9iUzZcoUfv/739u3nzlzJv/97385ePAgu3bt4tFHH2XVqlVMmjTJvs2kSZOYN28en3zyCYGBgaSmppKamkpenv7lXo6XPwx80jZ0vs+fwc0DDi6Hd38DC++Hs0fMrtCh3HV1SwA+3XyEwmKrucWIiEiNmRqAtmzZQlxcHHFxcQBMnjyZuLg4pk6dCkBKSoo9DAEUFhby2GOP0bVrVwYOHMiOHTtYsWIFgwcPtm/zzjvvkJGRwaBBg4iMjLS/Pv/88/o9OWcR0BSuf9n2MMXOYwADdnwCb/aEZc9A3hmzK3QIw2LDaRrozYmsApbtSb38DuKYigsg4XvbhMIaBCDi0hymE7QjcfrnANXE0a2wfCok/WR77xMC1zxmayXy9DG1NLO9tnw/b6w8QN9WoXx+Xz+zy5GqKi6EX1fD7oW2gQAFtkdj0KgVDH4GOo/VIACRBuJKvr8VgCrg0gEIbCPGDiyD5c/Cib22ZcHRtj5D3caBm7u59ZkkJSOP37z0AyVWg9fGdWdElwj8vDzMLksqUlIEiWtsoWfvN5B/tmxdQITtAaE5J2zvI3vA0OnQepAJhYpIbVIAqiGXD0ClrCWw41NY9QJkHbctC+8CQ6ZD28G2kWUu5oH5W/lup+0WmLeHG9e0a8qw2HCGdAon1N/L5OpcXEmxreVy19ew93+Qd7psnX8YdL7JNnde9NVQlAvr34af34DCbNs2bX4LQ6ZBZHdTyheRmlMAqiEFoAsU5cHGd+HH18tuH7QaaPtXc1ScubXVs8z8It5ceYDvd6dy5HRZx3o3C/RuGcqw2AiGdQ4nOtTPxCpdiLUEkn4+19KzuKxVB8CvCXS+EWLHQosBFbdcZp+wPRx083/Aem6+ty63wm//H4RqBKmIs1EAqiEFoErknoYfX4VN70PJuQ6kXW619aNo1NLU0uqbYRgkpGWxdFcay/aksvt4+elFOkcGMSw2nGGdI+gUGYjFBVvL6ozVCkc22ELPnv9CdlrZOt9G0Olc6Gl5je2xD1VxOhF+eAF2fml77+Zpe1zEtU/YBgqIiFNQAKohBaDLOJMEq/4OO7+wvXfzhN5/tH1Z+Dc2tzaTHD2Ty7LdtjC0KfE0508bFh3qy7DOtpahXi1DcXdTGLpiVisc22K7vbVnEWSllK3zCYaOo6HLWFvLpLtn9T8nZYftaemHVtneewVA/4eh3yTwDqjJGYhIPVAAqiEFoCpK2WHrKP3rD7b33kEw4BG4+gHwct1bQKdzClm5N41le9JYu/8EBec9NyjU34shncIY1jmC37Rrgo+na3YorxLDgGPbYPfXsHsRZB4tW+cdBB1H2Vp6Wl8HHrXc/+rX1ba/2ynxtvf+TWHgU3DVxNr/LBGpNQpANaQAdIUOrbINnU/daXsfGAnX/R90v6PqtyAaqNzCYtbuP8myPams3JtORl6RfZ2flzsD29s6Uf+2QzjBfjVouWgoDMMWrHd/bbvFdfa8J297BUCHkba569r8tu4fy2C12lqbVj4HZxJtyzR0XsShKQDVkAJQNVitsGsBrHweMs59aTXtaBtV036ES44Yu1BRiZXNiadZtieNZbtTOZ6Rb1/n4Wbh6taNGRYbztDO4UQG+5pYaT0zDEjbZQs8uxfC6V/L1nn62f7+dLkZ2g4BTxN+L8WFsO0jWPOShs6LODgFoBpSAKqB4gLY9IFtZE3pU6Rj+sOw56G5ZlIvZRgGu49nsnR3Kst2p5GQllVufffmwfYRZW3DAhpmJ+q0PWWh59SBsuUevtB+mO32VrvhjnM7tSBbQ+dFHJwCUA0pANWCvLPw0+u24fPF51o6Ot0Ig5+FJm1NLc0RHT6Zw7I9tjC0NfkM5/9X2aqJv31EWVx0CG7O3In6xP6y21sn9pUtd/eGdkNtoaf9CMfucFzR0Pmuv7M9KFRD50VMpQBUQwpAtSjjKPwwA+LnA4Zt0tWrJsKgpyEgzOzqHNKJrAJW7LXdJlt38BSFJWWdqJsGejO0czjDOofTr01jvD2coBP1qUO20LNrIaTvLlvu7gVtBttub7UfAT5O9t+ahs6LOBwFoBpSAKoDaXtsw4sPLLW99/SH/g/ZXo78r32TZRcUszohnWW70/hhXzpZBcX2dQHeHgzq0JThsREM6tCUQB8H6kR9OrHs9lbqL2XL3Txst41ix0KH68E3xLQSa42Gzos4DAWgGlIAqkOHf7LNMn98m+29fxgMOje8uCbPb3EBhcVW1v96imW7U1m+J430rAL7Ok93C/3bNGF4bARDOocRFmjCxLVnk8tCz/HtZcst7rbOwrFjbUPX/ULrv7b6cOgHWxC6cOh8z7v1d1uknigA1ZACUB0zjLLhxaUjfhq3hcFTbf2EGmKH31pmtRrEHz1re/ji7lR+PZljX2exQFx0CMNjIxgWG0GrJv51V0jGUdszenYvtD2o0F6Em+1JzF1utj2k0FUekFnR0PnQ1rapNTR0XqTOKQDVkAJQPSkuhK1zbMOLc0/aljXvDUOfgxb9TS3N2RxMz7aNKNuTxo4jZ8utaxcWwLDYcIbHRtC1WXDNR5RlptimoNj9NRzZeN4KC7T8DcSOgU43uXY/GA2dFzGFAlANKQDVs/xM+PlNWP+WbZZugPYjbcOLwzqaWpozSs3IZ/keWxhaf+gUxefNyxEZ7MPQzrYw1KdVKJ7uVWyRyE4/F3oW2iYf5bz/bcT0sz2csPONEBhRuyfj7DR0XqReKQDVkAKQSbJSYfWLsO1jMEpst1Hi7oRB/wdBkWZX55Qy8opYnZDO0t2prE44QW5hiX1dkI8HgzvZRpQN7NAUP68Lntqdc9I2w/quryFpHRhlo9Fo3sfWpyd2DARF1c/JOLPsE7D2ZdjyoYbOi9QhBaAaUgAy2Yn9sHI67PvG9t7DF/o9YJtnzCfY3NqcWH5RCT8fOsnSXWms2JvGqZxC+zpvDzeuadeEG9r6MMSyiYCD/4PEtbYgWqpZT1vo6TwGQqLr/wQagoqGzvf+w7mJhJuYW5tIA6AAVEMKQA4ieYNtjrHSfia+oTDwSej1B01IWUMlVoNtyWdYuiuVn3cfIjZzLaPcNjLAbReelrLQUxjWDa9ut9haehq1NK3eBkdD50XqhAJQDSkAORDDgH3f2r4sSqdLCGlhGzEWe7NG1VRXfgYkLIFdX2McWoXFWjZJ6x5rC74puZpvrX1JMiLoFBnEsHP9hjpFBjbMaTnMctHQ+TBbyNfQeZFqUQCqIQUgB1RSDNvnwuoZkJ1mWxbZwzZirPVAU0tzGgVZkPC9rSPzweVQUnYLjLDO5/r0jOWoezOW70lj6e5UNiWe5rw+1DRv5MuwzhEMiw2nV4tGeFS1E7VUrtKh88/Ybjcq5ItUmQJQDSkAObDCHFj/b1j3Lyg8N4Fo2yEwZDpEdDG3NkdUmAP7z4WeA8vL5mUDaNLe1ooWO7bS0XancwpZtc/WiXrt/hMUFJd1hA7192JwxzCGxUZwTbsm+Hg6wbQcjqyiofNRcbYRYxo6L1IlCkA1pADkBHJOwpp/wpb/gLUYsED322yjaly9g25hrq2FZ9fXsH8pFOeVrQttY3s4YexYW6vPFdzOyi0s5scDJ1m6O5WVe9PJyCu7bebr6c7A9k0ZFhvObzuGEeKnPlrVpqHzItWmAFRDCkBO5PSvsPJ520P5wDareN8/wzWPgW8jc2urT0X5cHCF7feQ8D0UlT0ZmkYtz93euhkiutbKk7aLS6xsOnza/iTq4xllLUvubhaubh3KsM4RDO0cTlSIb40/zyVp6LzIFVMAqiEFICd0bCssfxYO/2h77xNsC0F97gNPE+bFqg/FBbZRRLsXwr7vym4JAgTH2EZuxY613Uapw47LhmGw+3gmy3ansnR3GglpWeXWd2sezLDO4QyLjaBdWIA6UV8pDZ0XqTIFoBpSAHJShmHr57LiWUjfY1sW1Nw2D1O3ceDWAPqoFBdC4hrb7a1930JBRtm6oGa2TrNdbrY9s8ekoHH4ZI69E/XW5DOc/3+YVk38z4WhcOKiG+HmpjBUZRo6L3JZCkA1pADk5KwlsOMz27+aM4/ZloV3sXWUbjvY+SZbLSmyPZRw90LY+z/IP1u2LiDiXEvPzbZ51BxsxNCJrAJW7rWFoXUHT1FYUtaJukmAN0PPhaH+bRrj7dEAAmp90NB5kUopANWQAlADUZQHG9+DH18raylpda1t6HxUnLm1XU5JMST9ZAs9exZD3umydf5h0Pkm2+2tmH4OF3oqk11QzJqEEyzdncoP+9LJKii2rwvw9mBQh6YMi41gUIemBPnoi/ySrFbYs9DW/01D50XsFIBqSAGogck9DT++CpveL3v2TZdbbF8WjtSZ1FoCyettt7f2Li4bCg3g17gs9LQY4PS38wqLrWz49RRLd6eyfE8a6VkF9nWe7hb6tWnC8NhwhnYKJyyogfbhqg2VDp2frudjiUtSAKohBaAG6kyS7bbYL18AxrnOpH8815m0sTk1Wa22qT52L7TNtp6dWrbOtxF0Gm27vdXyGnD3qPw4TsxqNdhx9CxLz40o+/VkTrn1cTEhDI+NYFjncFo3VV+XCmnovAigAFRjCkANXMovto7SpZ1JvYNsE61e/QB4+dX95xsGHN1iG7K+exFkHS9b5xMMHUfbWnpaD3TJPh0H07NZtsc2omzHkbPl1rUNC2B4bDjDOkfQrXmwRpRdSEPnxcUpANWQApCLOPSDbbLV1F9s7wMjYdAU6DGh9ltbDAOOb7Pd3trzX8g4UrbOOwg6XG8bvdX6Ok30ep7UjHyW77W1DK0/dIri8+bliAjyYdi5MNS3dSiempajzOlfYdULsGuB7b2GzouLUACqIQUgF2K1wq6vYNVzcDbZtqxpRxj8LHQYWbMRY4ZhG7q8e6HtdTapbJ1XgO34sTfbblU01GcV1aKMvCJWJ9im5VidcILcwrJZ64N8PPhtxzCGx0Zwbfum+Hs3zNuFV+x4PKycft7Q+UAY8LCttVND56UBUgCqIQUgF1RcAJv/A2v/CXlnbMti+ttGjEX3rvpxDAPSdp+7vbXQ9i/xUp5+0H6E7fZWu6HgqSckV1d+UQk/HzrJ0l1prNibxqmcsoldvTzcuKZtE4bFhjOkUziNA7xNrNRBaOi8uAgFoBpSAHJheWdh3UzY8E7ZxKGdbrS1CDVpW/l+6Xttt7d2L4RTB8qWe/hAu2G221vthoGXf11W75JKrAbbks+wdFcqy/akkXw6177OzQK9WoTab5XFNK6HPl6O6lJD52PHOt/zsUQqoABUQwpAQsYxWP0PiP8EDCtY3G3/Wh70NASE2bY5sf/c7a2v4cS+sn3dvW0tPLFjbS0+utVQbwzDICEti2W7bQ9f3H08s9z6jhGBDIuN4LoOTekQEYiflwveKtPQeWnAFIBqSAFI7NL22PpQ7P/e9t7TH7reapt7LG1X2XZuntB2iC30dBgJPvp74wiOnsm1T8uxKfE05/WhxmKBmFA/2ocH0iE8kPYRtj9bNfHHy8MFOlRXOHR+8Lmh891MLU2kuhSAakgBSC5y+CfbiLFjW8uWuXnYOjDHjrWN4vINMa08ubzTOYWs2mfrRL016Qynz+s3dD5PdwutmwScC0QBtoAUEUh0I7+GOXdZhUPnx8Fv/waNWppamsiVUgCqIQUgqZBhwJ5Ftg6lzXtBxxvAL9TsqqSaTmYXsD81i4S0LPanZZGQmsX+tGyyz5ui43y+nu60Kw1E57UYhQd5N4znEWnovDQACkA1pAAk4poMw+B4Rn5ZMDr354H0bAqLrRXuE+TjQYeIQHtLUWlAauTvpM9z0tB5cWIKQDWkACQi5ysusZJ8OpeEC1qMDp/KpcRa8f9CwwK9ywWi9hGBtAsLcJ5nFGnovDghBaAaUgASkarILyrh1xM5tkB0XovR0TN5le4THeprC0TntRi1buqPt4cDTnCrofPiZBSAakgBSERqIrugmAP2lqJse0A6cd6s9+dzd7PQqol/uWDUISKQmFA/3B2h47WGzouTUACqIQUgEakLp7IL2J+WfVGLUVZ+xR2vvT3cKux4HRnsY07Haw2dFwenAFRDCkAiUl8MwyA1M//cKLSyFqP9aVkUVNLxOtDbg/b2/kUB9mBUb9N+aOi8OCgFoBpSABIRs5VYDY6czi3XUpSQmkXiyRyKK+l43STAq+wW2nkdrwN96qjTcoVD5/8I1z6uofNiCgWgGlIAEhFHVVBcQuLJnItajM6fA+1CzUJ8zxuqb7ul1qZpAD6etdTxWkPnxUEoANWQApCIOJucgmIOpmeXazHan5ZFWmbFHa/dLNCygo7XLUL98HCv5lQgFQ2dH/QUXDVRQ+elXjhNAFq7di0vv/wyW7duJSUlhYULFzJmzJhKt1+9ejXXXXfdRctTUlKIiIiwv3/77bd5+eWXSU1NpXv37rz55pv06dOnynUpAIlIQ3E2t5D9adkkpGaeC0e2kJSRV1Th9l4ebrRtGnBRi1GzEN+qdbyubOj84KnQeYyGzkudupLvb1OfyJWTk0P37t259957ufnmm6u8X0JCQrkTCwsLs//8+eefM3nyZN5991369u3LzJkzGT58OAkJCeW2ExFxBSF+XvRpFUqfVmXTthiGQXpWwXm30bLOdbzOJq+ohD0pmexJySx3nABvD9qFB1z0DKMmAV7lg5GbG3S5BTqOLhs6f/pX+PJuiLrKNmJMQ+fFATjMLTCLxVLlFqAzZ84QEhJS4TZ9+/ald+/evPXWWwBYrVaio6N56KGHePrpp6tUi1qARMQVWa0GR8/kXTA/WhaHTmRTVFLxV0WovxftzwWjDhFBdIgIoF14IEGlHa81dF7qkdO0AFVXjx49KCgooEuXLkybNo0BAwYAUFhYyNatW5kyZYp9Wzc3N4YMGcL69esrPV5BQQEFBWX3yTMzMyvdVkSkoXJzsxDT2I+Yxn4M7RxuX15UYr2g47Xtz6TTuZzOKWTDr6fZ8OvpcseKCvaxD89vHz6BzuNupd2+d/HYNhsOrbS9NHReTORUASgyMpJ3332XXr16UVBQwKxZsxg0aBAbN27kqquu4uTJk5SUlBAeHl5uv/DwcPbt21fpcWfMmMH06dPrunwREafk6e5G+3O3vs6XV1hS1vH6vGCUkpHP8XOv1Qkn7Nu7WQbRr9FVPOL2BX2yV8HOLzB2L8Ta6w+4D9Ss81K/nOoWWEUGDhxITEwMc+fO5fjx4zRr1oyff/6Zfv362bd58sknWbNmDRs3bqzwGBW1AEVHR+sWmIhINWTkFXHggqddJ6RmcSa3rON1rCWRpzw+41r3nQDk4MvqJrdztOO9tIkKo0OEreO1myNMBSJOo8HfAjtfnz59+OmnnwBo0qQJ7u7upKWlldsmLS2t3CixC3l7e+PtXU9PUBURaeCCfT3p1TKUXi3Ld7w+kV1gH4W2PzWa19Li+ChtHY/wCd3cEhl18kNO/PgV/yq+mb+UXIeXlzftSp92fd4DHpsGepszFYhcmZJiKMo975UHhef9HBAGza4yrTynD0Dx8fFERkYC4OXlRc+ePVm5cqW9JclqtbJy5UoefPBBE6sUEXFtFouFsEAfwgJ9+E27sltdVmt/jp15gJ1bviBm+6s0zT/K3z1n80ePJfyzaBzfHenLjiNnyx0rxM+T5o18aeTnRai/F438vM797Ekjfy9C/bxoVLrc3xNvj1p64GNDYi2xhZDKwklRTtn6wtwLti19nweFOWU/X7iPteJHLdh1HQe3fFA/51sBUwNQdnY2Bw8etL9PTEwkPj6e0NBQYmJimDJlCseOHePjjz8GYObMmbRq1YrY2Fjy8/OZNWsWq1atYtmyZfZjTJ48mYkTJ9KrVy/69OnDzJkzycnJ4Z577qn38xMRkUtzc7MQ3TiA6OH3wuA77UPnW+ak8m+vNzjbqCvLox5gVUEHEtKyOHwyh7O5RZzNvcyX63n8vdxtwcgelsoHpVB/L0L8PAk9tyzEzwsvj2o+DLI2WK1QnH9BOLlE0KgonJQLMxf8XJgLJRU/ILNuWMDLHzx9z73O/dyoRT3WcDFTA9CWLVvKPdhw8uTJAEycOJE5c+aQkpJCcnKyfX1hYSGPPfYYx44dw8/Pj27durFixYpyxxg/fjwnTpxg6tSppKam0qNHD77//vuLOkaLiIiD8fCCPn+C7redGzr/JiFndvK7M/fzuzaD4Y5p5De5hoPp2ZzIKuB0TiFncgsv+LOIM+fen8ktosRqkFNYQk5hHkfP5FW5lEBvD0L8PctCkv1PT0J9DJp6FRPqXUIjzxJCPIoIdC/EoyT/4qBRUQipMMyct09x1eusFZ5+54KJX/mfvS5cfu691/nbnRds7CHnguN4eDvkAzAdphO0I9FzgEREHMCVzjpvGFBSaA8a1oJccrIzyc7OJDs7i9ycTPJysinIy6YoL5ui/BxKCnIwCnMxinKxFOfhUZyHDwX4WgrxpeDcqxBfS9nPbpZ6/Nr08LlEOKkguFQYTi4RZjx9HTKcVJfTTIXhqBSAREQcSEWzzkd0LbtNdP5tIKOk3soqxIN8vMkxvMkzvMjHmzy8yDW8y/2chzf5lfzs5uWHp28Anj7++PgG4OMfiH9AIP7+QQQHBRDs72u/dRfq70WwryfuGhlXKQWgGlIAEhFxQBfOOn8pFvdzt2TOb/moxu2bylpaPP3A3daLpMRqkJFXxOmcQs6WuyVXZLsVd8EtutM5hZXOxXbZ07LYRtmd39E71N/zXIfv8/s1eRLiZ3sf7OvpMo8TUACqIQUgEREHdmwrZKVd4jaQv8PPPl9cYiUjr8gelE7b+y3ZAlNpeDo/VGXmF1frs9wstjnhGp3r6F0ajEqDUukoutIO4aF+XgT6eDhlaHKp5wCJiIiLadbT7ApqzMPdjcYB3jQOqPoz6IpKrJzNvTAYlb23tzSVdgTPKSSroBirAadzbNscOpFTpc9yd7MQ4nv+aDnPco8cOD88lYaqIB8Pp3o+kwKQiIiIE/B0d6NpoDdNA6semgqLrZzNK+TMea1MFYYn+/IisguKKbEanMop5FROYZU/y8PNYmtduqhVybP8M5vOharGAV74e5sXQxSAREREGigvDzf7AyirqqC4hLPn+iqdKe23ZL81V/aIgfPf5xaWUGw1OJldwMnsqj1jaFjncN7/fa/qnlqNKQCJiIiInbeHO+FB7oQHVT005ReVnOu/VHGrUrlnNeUUcjq3kFB/rzo8i8tTABIREZEa8fF0JzLYl8hg3yrvU1xircOKLs/EZ32LiIiIq/JwNzeCKACJiIiIy1EAEhEREZejACQiIiIuRwFIREREXI4CkIiIiLgcBSARERFxOQpAIiIi4nIUgERERMTlKACJiIiIy1EAEhEREZejACQiIiIuRwFIREREXI4CkIiIiLgcD7MLcESGYQCQmZlpciUiIiJSVaXf26Xf45eiAFSBrKwsAKKjo02uRERERK5UVlYWwcHBl9zGYlQlJrkYq9XK8ePHCQwMxGKx1OqxMzMziY6O5siRIwQFBdXqsR2Bzs/5NfRzbOjnBw3/HHV+zq+uztEwDLKysoiKisLN7dK9fNQCVAE3NzeaN29ep58RFBTUYP9ig86vIWjo59jQzw8a/jnq/JxfXZzj5Vp+SqkTtIiIiLgcBSARERFxOQpA9czb25tnn30Wb29vs0upEzo/59fQz7Ghnx80/HPU+Tk/RzhHdYIWERERl6MWIBEREXE5CkAiIiLichSARERExOUoAImIiIjLUQCqRWvXrmX06NFERUVhsVhYtGjRZfdZvXo1V111Fd7e3rRt25Y5c+bUeZ01caXnuHr1aiwWy0Wv1NTU+in4CsyYMYPevXsTGBhIWFgYY8aMISEh4bL7ffnll3Ts2BEfHx+6du3Kd999Vw/VVk91znHOnDkXXT8fH596qvjKvPPOO3Tr1s3+cLV+/fqxZMmSS+7jTNcPrvwcnen6VeTFF1/EYrHw6KOPXnI7Z7uOpapyfs52DadNm3ZRvR07drzkPmZcPwWgWpSTk0P37t15++23q7R9YmIio0aN4rrrriM+Pp5HH32UP/7xjyxdurSOK62+Kz3HUgkJCaSkpNhfYWFhdVRh9a1Zs4ZJkyaxYcMGli9fTlFREcOGDSMnJ6fSfX7++Wduv/12/vCHP7B9+3bGjBnDmDFj2LVrVz1WXnXVOUewPa31/OuXlJRUTxVfmebNm/Piiy+ydetWtmzZwm9/+1tuuukmdu/eXeH2znb94MrPEZzn+l1o8+bNvPfee3Tr1u2S2znjdYSqnx843zWMjY0tV+9PP/1U6bamXT9D6gRgLFy48JLbPPnkk0ZsbGy5ZePHjzeGDx9eh5XVnqqc4w8//GAAxpkzZ+qlptqUnp5uAMaaNWsq3WbcuHHGqFGjyi3r27evcd9999V1ebWiKuc4e/ZsIzg4uP6KqmWNGjUyZs2aVeE6Z79+pS51js56/bKysox27doZy5cvNwYOHGg88sgjlW7rjNfxSs7P2a7hs88+a3Tv3r3K25t1/dQCZKL169czZMiQcsuGDx/O+vXrTaqo7vTo0YPIyEiGDh3KunXrzC6nSjIyMgAIDQ2tdBtnv4ZVOUeA7OxsWrRoQXR09GVbGxxFSUkJn332GTk5OfTr16/CbZz9+lXlHME5r9+kSZMYNWrURdenIs54Ha/k/MD5ruGBAweIioqidevWTJgwgeTk5Eq3Nev6aTJUE6WmphIeHl5uWXh4OJmZmeTl5eHr62tSZbUnMjKSd999l169elFQUMCsWbMYNGgQGzdu5KqrrjK7vEpZrVYeffRRBgwYQJcuXSrdrrJr6Ih9nC5U1XPs0KEDH374Id26dSMjI4NXXnmF/v37s3v37jqfNLg6du7cSb9+/cjPzycgIICFCxfSuXPnCrd11ut3JefobNcP4LPPPmPbtm1s3ry5Sts723W80vNztmvYt29f5syZQ4cOHUhJSWH69Olcc8017Nq1i8DAwIu2N+v6KQBJnerQoQMdOnSwv+/fvz+HDh3i9ddfZ+7cuSZWdmmTJk1i165dl7xv7eyqeo79+vUr17rQv39/OnXqxHvvvcfzzz9f12VesQ4dOhAfH09GRgYLFixg4sSJrFmzptKA4Iyu5Byd7fodOXKERx55hOXLlzt0R9/qqs75Ods1HDlypP3nbt260bdvX1q0aMEXX3zBH/7wBxMrK08ByEQRERGkpaWVW5aWlkZQUFCDaP2pTJ8+fRw6WDz44IN88803rF279rL/uqrsGkZERNRliTV2Jed4IU9PT+Li4jh48GAdVVczXl5etG3bFoCePXuyefNm/vWvf/Hee+9dtK2zXr8rOccLOfr127p1K+np6eVaiEtKSli7di1vvfUWBQUFuLu7l9vHma5jdc7vQo5+DS8UEhJC+/btK63XrOunPkAm6tevHytXriy3bPny5Ze8l98QxMfHExkZaXYZFzEMgwcffJCFCxeyatUqWrVqddl9nO0aVuccL1RSUsLOnTsd8hpWxGq1UlBQUOE6Z7t+lbnUOV7I0a/f4MGD2blzJ/Hx8fZXr169mDBhAvHx8RWGA2e6jtU5vws5+jW8UHZ2NocOHaq0XtOuX512sXYxWVlZxvbt243t27cbgPHaa68Z27dvN5KSkgzDMIynn37auOuuu+zb//rrr4afn5/xxBNPGHv37jXefvttw93d3fj+++/NOoXLutJzfP31141FixYZBw4cMHbu3Gk88sgjhpubm7FixQqzTqFS999/vxEcHGysXr3aSElJsb9yc3Pt29x1113G008/bX+/bt06w8PDw3jllVeMvXv3Gs8++6zh6elp7Ny504xTuKzqnOP06dONpUuXGocOHTK2bt1q3HbbbYaPj4+xe/duM07hkp5++mljzZo1RmJiovHLL78YTz/9tGGxWIxly5YZhuH8188wrvwcnen6VebCUVIN4Tqe73Ln52zX8LHHHjNWr15tJCYmGuvWrTOGDBliNGnSxEhPTzcMw3GunwJQLSod8n3ha+LEiYZhGMbEiRONgQMHXrRPjx49DC8vL6N169bG7Nmz673uK3Gl5/jSSy8Zbdq0MXx8fIzQ0FBj0KBBxqpVq8wp/jIqOi+g3DUZOHCg/VxLffHFF0b79u0NLy8vIzY21vj222/rt/ArUJ1zfPTRR42YmBjDy8vLCA8PN66//npj27Zt9V98Fdx7771GixYtDC8vL6Np06bG4MGD7cHAMJz/+hnGlZ+jM12/ylwYEBrCdTzf5c7P2a7h+PHjjcjISMPLy8to1qyZMX78eOPgwYP29Y5y/SyGYRh128YkIiIi4ljUB0hERERcjgKQiIiIuBwFIBEREXE5CkAiIiLichSARERExOUoAImIiIjLUQASERERl6MAJCJSCYvFwqJFi8wuQ0TqgAKQiDiku+++G4vFctFrxIgRZpcmIg2AZoMXEYc1YsQIZs+eXW6Zt7e3SdWISEOiFiARcVje3t5ERESUezVq1Aiw3Z565513GDlyJL6+vrRu3ZoFCxaU23/nzp389re/xdfXl8aNG/PnP/+Z7Ozsctt8+OGHxMbG4u3tTWRkJA8++GC59SdPnmTs2LH4+fnRrl07Fi9ebF935swZJkyYQNOmTfH19aVdu3YXBTYRcUwKQCLitJ555hluueUWduzYwYQJE7jtttvYu3cvADk5OQwfPpxGjRqxefNmvvzyS1asWFEu4LzzzjtMmjSJP//5z+zcuZPFixfTtm3bcp8xffp0xo0bxy+//ML111/PhAkTOH36tP3z9+zZw5IlS9i7dy/vvPMOTZo0qb9fgIhUX51PtyoiUg0TJ0403N3dDX9//3KvF154wTAM28z2f/nLX8rt07dvX+P+++83DMMw3n//faNRo0ZGdna2ff23335ruLm5GampqYZhGEZUVJTxt7/9rdIaAOP//b//Z3+fnZ1tAMaSJUsMwzCM0aNHG/fcc0/tnLCI1Cv1ARIRh3XdddfxzjvvlFsWGhpq/7lfv37l1vXr14/4+HgA9u7dS/fu3fH397evHzBgAFarlYSEBCwWC8ePH2fw4MGXrKFbt272n/39/QkKCiI9PR2A+++/n1tuuYVt27YxbNgwxowZQ//+/at1riJSvxSARMRh+fv7X3RLqrb4+vpWaTtPT89y7y0WC1arFYCRI0eSlJTEd999x/Llyxk8eDCTJk3ilVdeqfV6RaR2qQ+QiDitDRs2XPS+U6dOAHTq1IkdO3aQk5NjX79u3Trc3Nzo0KEDgYGBtGzZkpUrV9aohqZNmzJx4kTmzZvHzJkzef/992t0PBGpH2oBEhGHVVBQQGpqarllHh4e9o7GX375Jb169eI3v/kN8+fPZ9OmTfznP/8BYMKECTz77LNMnDiRadOmceLECR566CHuuusuwsPDAZg2bRp/+ctfCAsLY+TIkWRlZbFu3ToeeuihKtU3depUevbsSWxsLAUFBXzzzTf2ACYijk0BSEQc1vfff09kZGS5ZR06dGDfvn2AbYTWZ599xgMPPEBkZCSffvopnTt3BsDPz4+lS5fyyCOP0Lt3b/z8/Ljlllt47bXX7MeaOHEi+fn5vP766zz++OM0adKEW2+9tcr1eXl5MWXKFA4fPoyvry/XXHMNn332WS2cuYjUNYthGIbZRYiIXCmLxcLChQsZM2aM2aWIiBNSHyARERFxOQpAIiIi4nLUB0hEnJLu3otITagFSERERFyOApCIiIi4HAUgERERcTkKQCIiIuJyFIBERETE5SgAiYiIiMtRABIRERGXowAkIiIiLkcBSERERFzO/weO9icmbIxqYAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the model:\n",
        "torch.save(model.state_dict(), 'mnist_model.ph')"
      ],
      "metadata": {
        "id": "-7eVEKcajpkC"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "B6LQHCupZ8X6"
      },
      "execution_count": 27,
      "outputs": []
    }
  ]
}