{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "54e1ciQlt6qc"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9cct1hM0t6qe"
      },
      "source": [
        "# Tutorial 2: How to use the Pytorch to train the neural networks for classification?\n",
        "\n",
        "## What is the classfication problem?\n",
        "\n",
        "A classification problem involves predicting whether something is one thing or another. For example,\n",
        "\n",
        "| Problem type               | What is it?                                      | Example                                                                                                     |\n",
        "| -------------------------- | ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |\n",
        "| Binary classification      | Target can be one of two options, e.g. yes or no | Predict whether or not someone has heart disease based on their health parameters.                          |\n",
        "| Multi-class classification | Target can be one of more than two options       | Decide whether a photo of is of food, a person or a dog.                                                    |\n",
        "| Multi-label classification | Target can be assigned more than one option      | Predict what categories should be assigned to a Wikipedia article (e.g. mathematics, science & philosohpy). |\n",
        "\n",
        "\n",
        "In this tutorial, we're going to work through the multi-class classification classification problem with PyTorch.\n",
        "\n",
        "## What is the data format commonly used for classification?\n",
        "\n",
        "Generally, there are **image**, **text**, **audio** or **video** data.\n",
        "\n",
        "We can use standard python packages that load data into a **``numpy array``**, and then convert this array into a **``torch.Tensor``**.\n",
        "\n",
        "-  For images, packages such as Pillow, OpenCV\n",
        "-  For audio, packages such as scipy and librosa\n",
        "-  For text, either raw Python or Cython based loading, or NLTK and\n",
        "   SpaCy\n",
        "\n",
        "Specifically for vision, we have created a package called\n",
        "**``torchvision``**, that has data loaders for common datasets such as\n",
        "ImageNet, CIFAR10, MNIST, etc. and data transformers for images, such as,\n",
        "**``torchvision.datasets``** and **``torch.utils.data.DataLoader``**.\n",
        "\n",
        "\n",
        "In this tutorial, we will use the **CIFAR10** dataset.\n",
        "It has the classes: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’,\n",
        "‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’. The images in CIFAR-10 are of\n",
        "size 3x32x32, i.e. 3-channel color images of 32x32 pixels in size.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "## The workflow of training an image classifier using pytorch\n",
        "\n",
        "\n",
        "1. Load and normalize the CIFAR10 training and test datasets using\n",
        "   ``torchvision``\n",
        "2. Define a Convolutional Neural Network\n",
        "3. Define a loss function and optimizer\n",
        "4. Train the network on the training data\n",
        "5. Test the network on the test data\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bykSkJRNt6qg"
      },
      "source": [
        "### Import the related packages"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "HxF69pNrt6qg"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b2RLirzAt6qg"
      },
      "source": [
        "### 1. Load and normalize CIFAR10\n",
        "\n",
        "torchvision.datasets.CIFAR10 [Cource Code](https://pytorch.org/vision/stable/_modules/torchvision/datasets/cifar.html#CIFAR10)\n",
        "\n",
        "\n",
        "The output of torchvision datasets are PILImage images of range [0, 1].\n",
        "We transform them to Tensors of normalized range [-1, 1].\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "La2lMbkyt6qg"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ],
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "batch_size = 4\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
        "\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n",
        "\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gf_PhJcEt6qg"
      },
      "source": [
        "Show some of the training images for verification!\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "77mukym1t6qh"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "frog  horse plane cat  \n"
          ]
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# functions to show an image\n",
        "\n",
        "\n",
        "def imshow(img):\n",
        "    img = img / 2 + 0.5     # unnormalize\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# get some random training images\n",
        "dataiter = iter(trainloader)\n",
        "images, labels = next(dataiter)\n",
        "\n",
        "# show images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "# print labels\n",
        "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OK5FQ3ent6qh"
      },
      "source": [
        "### 2. Define a Convolutional Neural Network\n",
        "The neural network should satisfy the inputs with 3-dimension.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "kzweh3t9t6qh"
      },
      "outputs": [],
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # import pdb\n",
        "        # pdb.set_trace()\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "net = Net()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tsvrK52pt6qh"
      },
      "source": [
        "### 3. Define a Loss function and optimizer\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "v8DzbDyct6qh"
      },
      "outputs": [],
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "\n",
        "# SGD with momentum.\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# You can also use the Adam optimizer.\n",
        "# optimizer = optim.Adam([var1, var2], lr=0.001)\n",
        "\n",
        "\n",
        "# 定义学习率调度器\n",
        "# scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\n",
        "\n",
        "# 更新学习率\n",
        "# scheduler.step()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NZcn4w6ut6qh"
      },
      "source": [
        "### 4. Train the network\n",
        "\n",
        "Here, we have to loop over our data iterator, and feed the inputs to the\n",
        "network and optimize.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "HRHToWRft6qi",
        "outputId": "6d65a525-4052-4d4a-b657-db3f53304b77"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1,     1] loss: 2.286\n",
            "[1,  2001] loss: 2.091\n",
            "[1,  4001] loss: 1.747\n",
            "[1,  6001] loss: 1.431\n",
            "[1,  8001] loss: 1.637\n",
            "[1, 10001] loss: 1.620\n",
            "[1, 12001] loss: 1.018\n",
            "[2,     1] loss: 1.035\n",
            "[2,  2001] loss: 1.051\n",
            "[2,  4001] loss: 1.663\n",
            "[2,  6001] loss: 1.609\n",
            "[2,  8001] loss: 0.938\n",
            "[2, 10001] loss: 1.332\n",
            "[2, 12001] loss: 0.877\n",
            "Finished Training\n"
          ]
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Classification Cross-Entropy loss \n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "losses = []\n",
        "\n",
        "for epoch in range(2):  # loop over the dataset multiple times\n",
        "\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        if i % 2000 == 0:    # print every 2000 mini-batches\n",
        "            print(f'[{epoch + 1}, {i + 1:5d}] loss: {loss:.3f}')\n",
        "            losses.append(loss.item())\n",
        "\n",
        "print('Finished Training')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAIjCAYAAAA0vUuxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACcEUlEQVR4nOzdd3iT5f4G8PvNbNO9BxTooi3TsvcsS0QRNyrgHjhRj3LOT444j7iPuAc4wCMq4EKg7CEbigi0tNABpXvPNE3e3x9pIrUtncmbcX+uq5cmfZPczZOWfPM8z/cVRFEUQURERERERC2SSR2AiIiIiIjI1rFwIiIiIiIiagULJyIiIiIiolawcCIiIiIiImoFCyciIiIiIqJWsHAiIiIiIiJqBQsnIiIiIiKiVrBwIiIiIiIiagULJyIiIiIiolawcCIishELFixAr169OnTb5557DoIgdG0gog5YuXIlBEFARkaG1FGIiLoUCyciolYIgtCmrx07dkgdVRILFiyAu7u71DHaRBRFfPXVVxg3bhy8vb2h0WjQv39/PP/886iqqpI6XhOmgriwsNB83erVq/H2229LF6rByy+/jPXr10sdg4jIagRRFEWpQxAR2bKvv/660eUvv/wSiYmJ+OqrrxpdP2XKFAQFBXX4cXQ6HQwGA9RqdbtvW19fj/r6eri4uHT48TtqwYIF+P7771FZWWn1x24PvV6PuXPnYs2aNRg7dizmzJkDjUaD3bt3Y/Xq1ejTpw+2bNnSqTHsas899xyWLl2KgoIC+Pv7AwCuuuoq/Pnnn5LP6Li7u+P666/HypUrG12v1+uh0+mgVqs5C0pEDkUhdQAiIlt32223Nbq8f/9+JCYmNrn+76qrq6HRaNr8OEqlskP5AEChUECh4J/0y1m2bBnWrFmDJ598Eq+99pr5+nvvvRc33ngjZs+ejQULFuC3336zaq72vk4swWAwoK6urksKb7lcDrlc3gWpiIhsC5fqERF1gQkTJqBfv344cuQIxo0bB41Gg3/+858AgB9//BEzZ85EaGgo1Go1IiMj8cILL0Cv1ze6j7/vccrIyIAgCHj99dfx8ccfIzIyEmq1GkOHDsWhQ4ca3ba5PU6CIOChhx7C+vXr0a9fP6jVavTt2xcbN25skn/Hjh0YMmQIXFxcEBkZiY8++qjL90199913GDx4MFxdXeHv74/bbrsN2dnZjY7Jzc3FHXfcge7du0OtViMkJATXXHNNo9mVw4cPY9q0afD394erqyvCw8Nx5513Xvaxa2pq8Nprr6F379545ZVXmnx/1qxZmD9/PjZu3Ij9+/cDMM7sRERENHt/I0eOxJAhQxpd9/XXX5t/Pl9fX9x88804f/58o2Mu9zppiwkTJuDXX39FZmameYnopa8ZrVaLf//734iKioJarUZYWBj+8Y9/QKvVNrof02tj1apV6Nu3L9Rqtfl18frrr2PUqFHw8/ODq6srBg8ejO+//77J7auqqvDFF1+YcyxYsABAy3uc3n//ffNjhYaGYuHChSgtLW32+Tl16hQmTpwIjUaDbt26YdmyZU2ei3fffRd9+/aFRqOBj48PhgwZgtWrV7f5uSQiai9+PElE1EWKioowY8YM3HzzzbjtttvMS75WrlwJd3d3LFq0CO7u7ti2bRuWLFmC8vLyRjMfLVm9ejUqKipw3333QRAELFu2DHPmzMG5c+danaXas2cP1q5diwcffBAeHh7473//i+uuuw5ZWVnw8/MDABw7dgzTp09HSEgIli5dCr1ej+effx4BAQGdf1IarFy5EnfccQeGDh2KV155BXl5eXjnnXewd+9eHDt2DN7e3gCA6667DidPnsTDDz+MXr16IT8/H4mJicjKyjJfnjp1KgICAvDMM8/A29sbGRkZWLt2bavPQ0lJCR599NEWZ+bmzZuHFStW4JdffsGIESNw0003Yd68eTh06BCGDh1qPi4zMxP79+9vNHYvvfQSnn32Wdx44424++67UVBQgHfffRfjxo1r9PMBLb9O2uJf//oXysrKcOHCBbz11lsAYN5fZjAYcPXVV2PPnj249957ERcXhxMnTuCtt97CmTNnmuxH2rZtG9asWYOHHnoI/v7+5gLsnXfewdVXX41bb70VdXV1+N///ocbbrgBv/zyC2bOnAkA+Oqrr3D33Xdj2LBhuPfeewEAkZGRLeY2LTlMSEjAAw88gJSUFHzwwQc4dOgQ9u7d2+h1XFJSgunTp2POnDm48cYb8f333+Ppp59G//79MWPGDADAJ598gkceeQTXX389Hn30UdTW1uKPP/7AgQMHMHfu3DY/n0RE7SISEVG7LFy4UPz7n8/x48eLAMQPP/ywyfHV1dVNrrvvvvtEjUYj1tbWmq+bP3++2LNnT/Pl9PR0EYDo5+cnFhcXm6//8ccfRQDizz//bL7u3//+d5NMAESVSiWmpaWZrzt+/LgIQHz33XfN182aNUvUaDRidna2+brU1FRRoVA0uc/mzJ8/X3Rzc2vx+3V1dWJgYKDYr18/saamxnz9L7/8IgIQlyxZIoqiKJaUlIgAxNdee63F+1q3bp0IQDx06FCruS719ttviwDEdevWtXhMcXGxCECcM2eOKIqiWFZWJqrVavGJJ55odNyyZctEQRDEzMxMURRFMSMjQ5TL5eJLL73U6LgTJ06ICoWi0fWXe500xzSuBQUF5utmzpzZ6HVi8tVXX4kymUzcvXt3o+s//PBDEYC4d+9e83UARJlMJp48ebLJ/fz99VpXVyf269dPnDRpUqPr3dzcxPnz5ze5/YoVK0QAYnp6uiiKopifny+qVCpx6tSpol6vNx+3fPlyEYD4+eefm68zPT9ffvml+TqtVisGBweL1113nfm6a665Ruzbt2+TxyYisiQu1SMi6iJqtRp33HFHk+tdXV3N/19RUYHCwkKMHTsW1dXVSE5ObvV+b7rpJvj4+Jgvjx07FgBw7ty5Vm+bkJDQaCZgwIAB8PT0NN9Wr9djy5YtmD17NkJDQ83HRUVFmT/d76zDhw8jPz8fDz74YKM9NDNnzkRsbCx+/fVXAMbnSaVSYceOHSgpKWn2vkwzN7/88gt0Ol2bM1RUVAAAPDw8WjzG9L3y8nIAgKenJ2bMmIE1a9ZAvKSP0rfffosRI0agR48eAIC1a9fCYDDgxhtvRGFhofkrODgY0dHR2L59e6PHael10lnfffcd4uLiEBsb2yjHpEmTAKBJjvHjx6NPnz5N7ufS12tJSQnKysowduxYHD16tEO5tmzZgrq6Ojz22GOQyf5623HPPffA09PTPP4m7u7ujfYPqlQqDBs2rNHr3dvbGxcuXGiyZJWIyJJYOBERdZFu3bpBpVI1uf7kyZO49tpr4eXlBU9PTwQEBJjfGJaVlbV6v6Y36CamIqql4uJytzXd3nTb/Px81NTUICoqqslxzV3XEZmZmQCAmJiYJt+LjY01f1+tVuPVV1/Fb7/9hqCgIIwbNw7Lli1Dbm6u+fjx48fjuuuuw9KlS+Hv749rrrkGK1asaLKH5+9MRZGpgGpOc8XVTTfdhPPnz2Pfvn0AgLNnz+LIkSO46aabzMekpqZCFEVER0cjICCg0dfp06eRn5/f6HFaep10VmpqKk6ePNkkQ+/evQGgSY7w8PBm78e0VNHFxQW+vr4ICAjABx980KbXanNaGn+VSoWIiAjz9026d+/eZG/dpa9ZAHj66afh7u6OYcOGITo6GgsXLsTevXs7lI+IqK24x4mIqItc+km9SWlpKcaPHw9PT088//zziIyMhIuLC44ePYqnn34aBoOh1fttqUOZ2IazSXTmtlJ47LHHMGvWLKxfvx6bNm3Cs88+i1deeQXbtm1DfHw8BEHA999/j/379+Pnn3/Gpk2bcOedd+KNN97A/v37WzyfVFxcHADgjz/+wOzZs5s95o8//gCARrMws2bNgkajwZo1azBq1CisWbMGMpkMN9xwg/kYg8EAQRDw22+/Nft8/z1Tc6+TrmAwGNC/f3+8+eabzX4/LCys1Ry7d+/G1VdfjXHjxuH9999HSEgIlEolVqxYYbXGC215zcbFxSElJQW//PILNm7ciB9++AHvv/8+lixZgqVLl1olJxE5HxZOREQWtGPHDhQVFWHt2rUYN26c+fr09HQJU/0lMDAQLi4uSEtLa/K95q7riJ49ewIAUlJSzMvGTFJSUszfN4mMjMQTTzyBJ554AqmpqbjiiivwxhtvNDqf1ogRIzBixAi89NJLWL16NW699Vb873//w913391shjFjxsDb2xurV6/Gv/71r2bfnH/55ZcAjN30TNzc3HDVVVfhu+++w5tvvolvv/0WY8eObbSsMTIyEqIoIjw83Dy7Y0ktdTqMjIzE8ePHMXny5A53Q/zhhx/g4uKCTZs2NTqf2IoVK9qc4+8uHf9LuxTW1dUhPT0dCQkJHcrq5uaGm266CTfddBPq6uowZ84cvPTSS1i8eLEk5zMjIsfHpXpERBZkeoN+6afldXV1eP/996WK1IhcLkdCQgLWr1+Pixcvmq9PS0vrsvMZDRkyBIGBgfjwww8bLan77bffcPr0aXOnturqatTW1ja6bWRkJDw8PMy3KykpaTJbdsUVVwDAZZfraTQaPPnkk0hJScG//vWvJt//9ddfsXLlSkybNg0jRoxo9L2bbroJFy9exKefforjx483WqYHAHPmzIFcLsfSpUubZBNFEUVFRS3m6gg3N7dml83deOONyM7OxieffNLkezU1Naiqqmr1vuVyOQRBaNQqPyMjo0lHPlOOv7cTb05CQgJUKhX++9//Nnp+PvvsM5SVlZnHvz3+/pyqVCr06dMHoii2a+8bEVF7cMaJiMiCRo0aBR8fH8yfPx+PPPIIBEHAV199ZVNL5Z577jls3rwZo0ePxgMPPAC9Xo/ly5ejX79+SEpKatN96HQ6vPjii02u9/X1xYMPPohXX30Vd9xxB8aPH49bbrnF3I68V69eePzxxwEAZ86cweTJk3HjjTeiT58+UCgUWLduHfLy8nDzzTcDAL744gu8//77uPbaaxEZGYmKigp88skn8PT0xJVXXnnZjM888wyOHTuGV199Ffv27cN1110HV1dX7NmzB19//TXi4uLwxRdfNLndlVdeCQ8PDzz55JOQy+W47rrrGn0/MjISL774IhYvXoyMjAzMnj0bHh4eSE9Px7p163DvvffiySefbNPz2BaDBw/Gt99+i0WLFmHo0KFwd3fHrFmzcPvtt2PNmjW4//77sX37dowePRp6vR7JyclYs2YNNm3a1OTcU383c+ZMvPnmm5g+fTrmzp2L/Px8vPfee4iKijIvZbw0x5YtW/Dmm28iNDQU4eHhGD58eJP7DAgIwOLFi7F06VJMnz4dV199NVJSUvD+++9j6NChrZ5IujlTp05FcHAwRo8ejaCgIJw+fRrLly/HzJkzL9sAhIioUyTp5UdEZMdaakfeUnvkvXv3iiNGjBBdXV3F0NBQ8R//+Ie4adMmEYC4fft283EttSNvrj03APHf//63+XJL7cgXLlzY5LY9e/Zs0kZ669atYnx8vKhSqcTIyEjx008/FZ944gnRxcWlhWfhL/PnzxcBNPsVGRlpPu7bb78V4+PjRbVaLfr6+oq33nqreOHCBfP3CwsLxYULF4qxsbGim5ub6OXlJQ4fPlxcs2aN+ZijR4+Kt9xyi9ijRw9RrVaLgYGB4lVXXSUePny41ZyiKIp6vV5csWKFOHr0aNHT01N0cXER+/btKy5dulSsrKxs8Xa33nqrCEBMSEho8ZgffvhBHDNmjOjm5ia6ubmJsbGx4sKFC8WUlBTzMZd7nTSnuXbklZWV4ty5c0Vvb28RQKPXTF1dnfjqq6+Kffv2FdVqtejj4yMOHjxYXLp0qVhWVmY+rqXXhiiK4meffSZGR0eLarVajI2NFVesWNHs6ys5OVkcN26c6OrqKgIwv6b+3o7cZPny5WJsbKyoVCrFoKAg8YEHHhBLSkoaHdPS8/P3342PPvpIHDdunOjn5yeq1WoxMjJSfOqppxr9jEREXU0QRRv62JOIiGzG7NmzcfLkSaSmpkodhYiISHLc40RERKipqWl0OTU1FRs2bMCECROkCURERGRjOONEREQICQnBggULzOfV+eCDD6DVanHs2DFER0dLHY+IiEhybA5BRESYPn06vvnmG+Tm5kKtVmPkyJF4+eWXWTQRERE14IwTERERERFRK7jHiYiIiIiIqBUsnIiIiIiIiFrhdHucDAYDLl68CA8PDwiCIHUcIiIiIiKSiCiKqKioQGhoKGSyy88pOV3hdPHiRYSFhUkdg4iIiIiIbMT58+fRvXv3yx7jdIWTh4cHAOOT4+npKXEaQKfTYfPmzZg6dSqUSqXUcagVHC/7wvGyPxwz+8Lxsj8cM/vC8bK88vJyhIWFmWuEy3G6wsm0PM/T09NmCieNRgNPT0/+QtgBjpd94XjZH46ZfeF42R+OmX3heFlPW7bwsDkEERERERFRK1g4ERERERERtYKFExERERERUSucbo8TERERETkOURRRX18PvV4vdZQup9PpoFAoUFtb65A/n7UolUrI5fJO3w8LJyIiIiKyS3V1dcjJyUF1dbXUUSxCFEUEBwfj/PnzPP9oJwiCgO7du8Pd3b1T98PCiYiIiIjsjsFgQHp6OuRyOUJDQ6FSqRyuuDAYDKisrIS7u3urJ2el5omiiIKCAly4cAHR0dGdmnli4UREREREdqeurg4GgwFhYWHQaDRSx7EIg8GAuro6uLi4sHDqhICAAGRkZECn03WqcOIIEBEREZHdYkFBremqmUi+0oiIiIiIiFrBwomIiIiIiKgVLJyIiIiIiOxYr1698Pbbb7f5+B07dkAQBJSWlloskyNi4UREREREZAWCIFz267nnnuvQ/R46dAj33ntvm48fNWoUcnJy4OXl1aHHaytHK9DYVY+IiIiIyApycnLM///tt99iyZIlSElJMV936XmGTCf2bYuAgIB25VCpVAgODm7XbYgzTkRERETkAERRRHVdvSRfoii2KWNwcLD5y8vLC4IgmC8nJyfDw8MDv/32GwYPHgy1Wo09e/YgPT0ds2fPRlBQENzd3TF06FBs2bKl0f3+fameIAj49NNPce2110Kj0SA6Oho//fST+ft/nwlauXIlvL29sWnTJsTFxcHd3R3Tp09vVOjV19fjkUcegbe3N/z8/PD0009j/vz5mD17dofHrKSkBPPmzYOPjw80Gg1mzJiB1NRU8/czMzMxa9Ys+Pj4wM3NDX379sWGDRvMt7311lsREBAAV1dXREdHY8WKFR3O0haccSIiIiIiu1ej06PPkk2SPPap56dBo+qat9XPPPMMXn/9dURERMDLywunT5/GjBkz8PLLL0OtVuPLL7/ErFmzkJKSgh49erR4P0uXLsWyZcvw2muv4d1338Wtt96KzMxM+Pr6Nnt8dXU1Xn/9dXz11VeQyWS47bbb8OSTT2LVqlUAgFdffRWrVq3CihUrEBcXh3feeQfr16/HxIkTO/yzLliwAKmpqfjpp5/g6emJp59+GldeeSVOnToFpVKJhQsXoq6uDrt27YKbmxtOnTplnpV79tlncerUKfz222/w9/dHWloaampqOpylLVg4ERERERHZiOeffx5TpkwBYDwBbv/+/TF69Gjz+apeeOEFrFu3Dj/99BMeeuihFu9nwYIFuOWWWwAAL7/8Mv773//i4MGDmD59erPH63Q6fPjhh4iMjAQAPPTQQ3j++efN33/33XexePFiXHvttQCA5cuXm2d/OsJUMO3duxejRo0CAKxatQphYWFYv349brjhBmRlZeG6665D//79AQARERHm22dlZSE+Ph5DhgwBYJx1szQWThIyGES8t+McAnRSJyEiIiKyb65KOU49P02yx+4qpkLApLKyEi+88AI2bNiAnJwc1NfXo6amBllZWZe9nwEDBpj/383NDZ6ensjPz2/xeI1GYy6aACAkJMR8fFlZGfLy8jBs2DDz9+VyOQYPHgyDwdCun8/k9OnTUCgUGD58uPk6Pz8/xMTE4PTp0wCARx55BA888AA2b96MhIQEXHfddeaf64EHHsB1112Ho0ePYurUqZg9e7a5ALMU7nGS0EsbTuPtrWn48LQcFbVt2/xHRERERE0JggCNSiHJlyAIXfZzuLm5Nbr87LPPYv369Xj55Zexe/duJCUloX///qirq7vs/SiVyibPz+WKnOaOb+veLUu5++67ce7cOdx+++04ceIEhgwZgnfffRcAMGPGDGRmZuLxxx/HxYsXMXnyZDz55JMWzcPCSUK3DOsBH40S56sE3L/qGGp1eqkjEREREZENOXDgAObPn49rr70W/fv3R3BwMDIyMqyawcvLC0FBQTh06JD5Or1ej6NHj3b4PuPi4lBfX48DBw6YrysqKkJKSgr69Oljvi4sLAz3338/1q5diyeeeAKffPKJ+XsBAQGYP38+vv76a7z99tv4+OOPO5ynLbhUT0JRge74fN5g3PzJPhzMKMHCVUfx4e2DoZSzniUiIiIiIDIyEuvWrcPVV18NQRDw7LPPdnh5XGc8/PDDeOWVVxAVFYXY2Fi8++67KCkpadNs24kTJ+Dh4WG+LAgCBg4ciGuuuQb33HMPPvroI3h4eOCZZ55Bt27dcM011wAAHnvsMcyYMQO9e/dGSUkJtm/fjri4OADAkiVLMHjwYPTt2xdarRa//PKL+XuWwsJJYv26eeLeWD0+TlFha3I+nvzuON668QrIZF035UtERERE9umll17CY489hlGjRsHf3x9PP/00ysvLrZ7j6aefRm5uLubNmwe5XI57770X06ZNg1ze+v6ucePGNbosl8tRX1+PFStW4NFHH8VVV12Furo6jBs3Dhs2bDAvG9Tr9Vi4cCEuXLgAT09PTJ8+HW+99RYA47moFi9ejIyMDLi6umLs2LH43//+1/U/+CUEUerFi1ZWXl4OLy8vlJWVwdPTU+o40Ol02LBhA1wjh+LB1UmoN4i4fURPPH9N3y5dL0tdwzReV155ZZO1wGR7OF72h2NmXzhe9seRxqy2thbp6ekIDw+Hi4uL1HEswmAwoLy8HJ6enuauerbCYDAgLi4ON954I1544QWp41zW5V4r7akNbGsEnNjEmAC8edMVEATgq/2ZeH1zSus3IiIiIiKygszMTHzyySc4c+YMTpw4gQceeADp6emYO3eu1NGshoWTDbl6YChenN0PAPDe9rP4eNdZiRMREREREQEymQwrV67E0KFDMXr0aJw4cQJbtmyx+L4iW8I9Tjbm1uE9UVajw7KNKXh5QzI8XZS4eVjLZ4UmIiIiIrK0sLAw7N27V+oYkuKMkw16cEIU7htvPDPy4nUn8OsfORInIiIiIiJybiycbNQz02Nxy7AeEEXgsW+PYUdKy2d6JiIiInJWTtbnjDqgq14jLJxslCAIeHF2P1w1IAQ6vYj7vz6CwxnFUsciIiIisgmmroDV1dUSJyFbV1dXBwBtap1+OdzjZMPkMgFv3ngFKrX12JFSgDtWHsL/7h2BvqFeUkcjIiIikpRcLoe3tzfy842rcjQajcOdysVgMKCurg61tbU2147cXhgMBhQUFECj0UCh6Fzpw8LJxqkUMnxw62DM//wgDmYUY95nB/Hd/SMREeAudTQiIiIiSQUHBwOAuXhyNKIooqamBq6urg5XFFqTTCZDjx49Ov0csnCyA64qOT5dMAS3fLwfJy+W47ZPD+D7B0Yh1NtV6mhEREREkhEEASEhIQgMDIROp5M6TpfT6XTYtWsXxo0bZ/cnLJaSSqXqkhk7Fk52wtNFiS/uHIYbP9yHc4VVuO2zA1hz30j4u6uljkZEREQkKblc3un9K7ZILpejvr4eLi4uLJxsABdL2hF/dzW+uns4Qr1ccK6gCvM/P4jyWsf7dIWIiIiIyNawcLIz3bxd8fXdw+HnpsLJi+W4e+Vh1NTppY5FREREROTQWDjZoYgAd3xx5zB4qBU4mFGMB1cdQV29QepYREREREQOi4WTnerXzQuf3zEULkoZtqcUYNGaJOgNPAEcEREREZElsHCyY0N7+eLD2wZDKRfwyx85+L/1f/Ls2UREREREFsDCyc5NiAnEWzddAUEAvjmYhVc3pkgdiYiIiIjI4bBwcgBXDQjFy9f2BwB8uPMsPthxVuJERERERESORdLC6ZVXXsHQoUPh4eGBwMBAzJ49Gykpl58x+eSTTzB27Fj4+PjAx8cHCQkJOHjwoJUS265bhvXA4hmxAIBXNyZj1YFMiRMRERERETkOSQunnTt3YuHChdi/fz8SExOh0+kwdepUVFVVtXibHTt24JZbbsH27duxb98+hIWFYerUqcjOzrZictt03/hIPDghEgDwf+v/xE/HL0qciIiIiIjIMSikfPCNGzc2urxy5UoEBgbiyJEjGDduXLO3WbVqVaPLn376KX744Qds3boV8+bNs1hWe/HUtBiU1+rw9f4sLPo2CR5qBSbGBkodi4iIiIjIrklaOP1dWVkZAMDX17fNt6muroZOp2vxNlqtFlqt1ny5vLwcAKDT6aDT6TqRtmuYMnRllmdnxKCsug4//5GL+78+ghXzB2NoL58uu39nZonxIsvheNkfjpl94XjZH46ZfeF4WV57nltBtJH+1QaDAVdffTVKS0uxZ8+eNt/uwQcfxKZNm3Dy5Em4uLg0+f5zzz2HpUuXNrl+9erV0Gg0ncpsy/QG4LMzMpwskcFFLuKhPnqEuUudioiIiIjIdlRXV2Pu3LkoKyuDp6fnZY+1mcLpgQcewG+//YY9e/age/fubbrNf/7zHyxbtgw7duzAgAEDmj2muRmnsLAwFBYWtvrkWINOp0NiYiKmTJkCpVLZpfddq9Pjri+P4mBGCXw0Snxz9zBEBrh16WM4G0uOF3U9jpf94ZjZF46X/eGY2ReOl+WVl5fD39+/TYWTTSzVe+ihh/DLL79g165dbS6aXn/9dfznP//Bli1bWiyaAECtVkOtVje5XqlU2tQL0BJ5lEolPlswFHM/OYAT2WW444sj+O7+keju47gzbdZia68fujyOl/3hmNkXjpf94ZjZF46X5bTneZW0q54oinjooYewbt06bNu2DeHh4W263bJly/DCCy9g48aNGDJkiIVT2jcPFyW+uNM405RTVovbPzuIggpt6zckIiIiIiIzSQunhQsX4uuvv8bq1avh4eGB3Nxc5ObmoqamxnzMvHnzsHjxYvPlV199Fc8++yw+//xz9OrVy3ybyspKKX4Eu+DrpsLXdw9HN29XpBdWYd7nB1FWw02GRERERERtJWnh9MEHH6CsrAwTJkxASEiI+evbb781H5OVlYWcnJxGt6mrq8P111/f6Davv/66FD+C3QjxcsXXdw+Hv7sap3PKcdfKQ6ip00sdi4iIiIjILki6x6ktfSl27NjR6HJGRoZlwjiBcH83fHXXMNz00T4czizB/V8fwSfzhkClkLR+JiIiIiKyeXzH7GTiQjyx4o5hcFXKsfNMAR7/Ngl6g000ViQiIiIislksnJzQ4J4++HjeYCjlAn49kYN/rj3Rptk/IiIiIiJnxcLJSY2NDsB/b46HTAC+PXwer/yWzOKJiIiIiKgFLJyc2Iz+IfjPHOM5sD7edQ7v7zgrcSIiIiIiItvEwsnJ3Tg0DP83Mw4A8NqmFHy1P1PiREREREREtoeFE+HusRF4eFIUAGDJj3/ix6RsiRMREREREdkWFk4EAFg0pTfmj+wJUQQWrTmOrafzpI5ERERERGQzWDgRAEAQBPx7Vl/Mie8GvUHEg6uOYt/ZIqljERERERHZBBZOZCaTCXj1+gFIiAuCtt6Au784hD8ulEodi4iIiIhIciycqBGlXIblc+MxMsIPVXV6zP/8IFLzKqSORUREREQkKRZO1ISLUo5P5g/BwO5eKKnW4fbPDuJ8cbXUsYiIiIiIJMPCiZrlrlZg5R3DEB3ojtzyWtz22QHkV9RKHYuIiIiISBIsnKhFPm4qfHXXcHT3cUVmUTXmfXYQZdU6qWMREREREVkdCye6rGAvF6y6ezgCPNRIzq3AHSsPorquXupYRERERERWxcKJWtXTzw1f3zUcXq5KHM0qxX1fHYG2Xi91LCIiIiIiq2HhRG0SE+yBlXcMhUYlx+7UQjz6TRLq9QapYxERERERWQULJ2qz+B4++GTeEKjkMmw8mYvFa0/AYBCljkVEREREZHEsnKhdRkf547+3xEMmAN8duYCXNpyGKLJ4IiIiIiLHxsKJ2m16v2Asu34gAOCzPel4d1uaxImIiIiIiCyLhRN1yPWDu2PJVX0AAG8mnsHKvekSJyIiIiIishwWTtRhd44Jx2MJ0QCA534+hbVHL0iciIiIiIjIMlg4Uac8Ojkad4zuBQB46vs/sPlkrrSBiIiIiIgsgIUTdYogCHh2Zh9cP7g79AYRD60+ht/TCqWORURERETUpVg4UafJZAL+M6c/pvUNQp3egLu/PIyk86VSxyIiIiIi6jIsnKhLKOQyvHNzPEZH+aG6To8FKw4iJbdC6lhERERERF2ChRN1GRelHB/fPgRXhHmjtFqH+746DJ3eIHUsIiIiIqJOY+FEXcpNrcDKO4bC312FjKJqfHvovNSRiIiIiIg6jYUTdTlvjQoPTYwCAPx3aypq6vQSJyIiIiIi6hwWTmQRtwzvgW7ersiv0OKLfRlSxyEiIiIi6hQWTmQRaoUcj0/pDQD4YMdZlNXoJE5ERERERNRxLJzIYq6N74boQHeU1ejwya5zUschIiIiIuowFk5kMXKZgCemxgAAPt+bjoIKrcSJiIiIiIg6hoUTWdS0vkEYGOaN6jo93tueJnUcIiIiIqIOYeFEFiUIAv4xzTjrtOpAJs4XV0uciIiIiIio/Vg4kcWNjvLH6Cg/6PQi3t6SKnUcIiIiIqJ2Y+FEVvHUtFgAwLpjF5CaVyFxGiIiIiKi9mHhRFZxRZg3pvUNgkEEXt+cInUcIiIiIqJ2YeFEVvPk1BjIBGDTyTwknS+VOg4RERERUZuxcCKriQ7ywLXx3QEAr21KljgNEREREVHbsXAiq3osIRpKuYC9aUXYm1YodRwiIiIiojZh4URWFearwa3DewIAlm1KgSiKEiciIiIiImodCyeyuoUTo6BRyXH8fCk2ncyTOg4RERERUatYOJHVBXiocefocADAG5tToDdw1omIiIiIbBsLJ5LEPeMi4OWqRGp+JdYdy5Y6DhERERHRZbFwIkl4uSrxwIRIAMBbiWegrddLnIiIiIiIqGUsnEgy80f2QqCHGtmlNfjmQJbUcYiIiIiIWsTCiSTjqpLjkcnRAIDl29NQpa2XOBERERERUfNYOJGkbhoahp5+GhRW1mHF3nSp4xARERERNYuFE0lKKZdh0ZTeAICPdp1DaXWdxImIiIiIiJqStHB65ZVXMHToUHh4eCAwMBCzZ89GSkpKq7f77rvvEBsbCxcXF/Tv3x8bNmywQlqylFkDQhEb7IGK2np8sPOs1HGIiIiIiJqQtHDauXMnFi5ciP379yMxMRE6nQ5Tp05FVVVVi7f5/fffccstt+Cuu+7CsWPHMHv2bMyePRt//vmnFZNTV5LJBDw1LQYAsHJvBvLKayVORERERETUmKSF08aNG7FgwQL07dsXAwcOxMqVK5GVlYUjR460eJt33nkH06dPx1NPPYW4uDi88MILGDRoEJYvX27F5NTVJsUGYnBPH2jrDfjv1lSp4xARERERNaKQOsClysrKAAC+vr4tHrNv3z4sWrSo0XXTpk3D+vXrmz1eq9VCq9WaL5eXlwMAdDoddDpdJxN3nimDLWSR2qKESNz62WF8e+g87hjVAz19NVJHaoLjZV84XvaHY2ZfOF72h2NmXzheltee51YQRVG0YJY2MxgMuPrqq1FaWoo9e/a0eJxKpcIXX3yBW265xXzd+++/j6VLlyIvL6/J8c899xyWLl3a5PrVq1dDo7G9N+bO7sPTMpwulWGwvwHzog1SxyEiIiIiB1ZdXY25c+eirKwMnp6elz3WZmacFi5ciD///POyRVNHLF68uNEMVXl5OcLCwjB16tRWnxxr0Ol0SExMxJQpU6BUKqWOI7meV5Rj9gf7cbRIhuduGo3YYA+pIzXC8bIvHC/7wzGzLxwv+8Mxsy8cL8szrUZrC5sonB566CH88ssv2LVrF7p3737ZY4ODg5vMLOXl5SE4OLjZ49VqNdRqdZPrlUqlTb0AbS2PVK7o6YeZA0Lw6x85eHvrWXy2YKjUkZrF8bIvHC/7wzGzLxwv+8Mxsy8cL8tpz/MqaXMIURTx0EMPYd26ddi2bRvCw8Nbvc3IkSOxdevWRtclJiZi5MiRlopJVvbElN6QywRsTc7H4YxiqeMQEREREUlbOC1cuBBff/01Vq9eDQ8PD+Tm5iI3Nxc1NTXmY+bNm4fFixebLz/66KPYuHEj3njjDSQnJ+O5557D4cOH8dBDD0nxI5AFRAS444bBxpnHZZtSYCPb8IiIiIjIiUlaOH3wwQcoKyvDhAkTEBISYv769ttvzcdkZWUhJyfHfHnUqFFYvXo1Pv74YwwcOBDff/891q9fj379+knxI5CFPJoQDZVChoPpxdh5pkDqOERERETk5CTd49SWmYQdO3Y0ue6GG27ADTfcYIFEZCtCvFwxb0RPfLonHa9tSsG46ADIZILUsYiIiIjISUk640R0OQ9OjIK7WoGTF8ux4c+c1m9ARERERGQhLJzIZvm6qXD3WGPDkDc3n0G9nud1IiIiIiJpsHAim3b32Aj4uqlwrrAK3x+5IHUcIiIiInJSLJzIprmrFXhwQiQA4J2tqajV6SVORERERETOiIUT2bzbRvREqJcLcspq8fX+TKnjEBEREZETYuFENs9FKcejCdEAgPe2p6GiVidxIiIiIiJyNiycyC5cN6g7IgLcUFKtw6e706WOQ0REREROhoUT2QWFXIYnpsQAAD7dfQ5FlVqJExERERGRM2HhRHZjRr9g9Ovmiao6Pd7fcVbqOERERETkRFg4kd2QyQQ8NS0WAPDV/kxcLK2ROBEREREROQsWTmRXxkX7Y3i4L+rqDXhnS6rUcYiIiIjISbBwIrsiCAL+Md046/TdkfM4W1ApcSIiIiIicgYsnMjuDO7pg4S4QBhE4M3NZ6SOQ0REREROgIUT2aUnp8VAEIBfT+Tgz+wyqeMQERERkYNj4UR2KTbYE9cMDAUALNuUInEaIiIiInJ0LJzIbj0+pTcUMgG7zhRg/7kiqeMQERERkQNj4UR2q6efG24eFgYAWLYxGaIoSpyIiIiIiBwVCyeya49MioaLUoajWaXYejpf6jhERERE5KBYOJFdC/R0wYJR4QCA1zenwGDgrBMRERERdT0WTmT3HhgfCQ8XBZJzK/DT8YtSxyEiIiIiB8TCieyel0aJ+8dHAgDeTDyDunqDxImIiIiIyNGwcCKHcMfoXvB3VyOruBrfHj4vdRwiIiIicjAsnMghaFQKPDwpCgDw7tZU1NTpJU5ERERERI6EhRM5jFuG9UB3H1fkV2ix8vcMqeMQERERkQNh4UQOQ6WQ4fGE3gCAD3eeRVmNTuJEREREROQoWDiRQ5kd3w29g9xRVqPDx7vOSh2HiIiIiBwECydyKHKZgCemxgAAPt+TgfyKWokTEREREZEjYOFEDmdqnyBcEeaNGp0e721LkzoOERERETkAFk7kcARBwD+mGWedVh/MwvniaokTEREREZG9Y+FEDmlUlD/GRPlDpxfx1pYzUschIiIiIjvHwokc1lMNs07rjmXjTF6FxGmIiIiIyJ6xcCKHNTDMG9P7BkMUgdc3pUgdh4iIiIjsGAsncmhPTusNmQBsPpWHY1klUschIiIiIjvFwokcWlSgB+YM6g4AeI2zTkRERETUQSycyOE9lhANlVyG388WYU9qodRxiIiIiMgOsXAih9fdR4O5w3sAAF7blAxRFCVORERERET2hoUTOYWHJkVBo5Lj+IUybDqZK3UcIiIiIrIzLJzIKfi7q3HXmHAAwOubz0Bv4KwTEREREbUdCydyGveMi4C3Rom0/EqsPXpB6jhEREREZEdYOJHT8HRR4oHxkQCAt7ekQluvlzgREREREdkLFk7kVOaP6oUgTzWyS2uw+kCW1HGIiIiIyE6wcCKn4qKU45HJ0QCA5dvSUKWtlzgREREREdkDFk7kdG4cEoZefhoUVdXh8z3pUschIiIiIjvAwomcjlIuw+NTegMAPt51DiVVdRInIiIiIiJbx8KJnNKsAaGIC/FEhbYeH+48K3UcIiIiIrJxLJzIKclkAp6aZpx1Wvl7BnLLaiVORERERES2jIUTOa2JMYEY0tMH2noD/rstVeo4RERERGTDWDiR0xIEAf+YHgsAWHPoPDIKqyRORERERES2ioUTObVh4b6YEBOAeoOINxPPSB2HiIiIiGyUpIXTrl27MGvWLISGhkIQBKxfv77V26xatQoDBw6ERqNBSEgI7rzzThQVFVk+LDmsJ6fGAAB+On4Rpy6WS5yGiIiIiGyRpIVTVVUVBg4ciPfee69Nx+/duxfz5s3DXXfdhZMnT+K7777DwYMHcc8991g4KTmyft28cNWAEADAG5tTJE5DRERERLZIIeWDz5gxAzNmzGjz8fv27UOvXr3wyCOPAADCw8Nx33334dVXX7VURHIST0yNwW9/5mJrcj4OZxRjSC9fqSMRERERkQ2RtHBqr5EjR+Kf//wnNmzYgBkzZiA/Px/ff/89rrzyyhZvo9VqodVqzZfLy41LsXQ6HXQ6ncUzt8aUwRayOLPuXipcPygU3x7Oxqsbk7HqziEQBKHJcRwv+8Lxsj8cM/vC8bI/HDP7wvGyvPY8t4IoiqIFs7SZIAhYt24dZs+efdnjvvvuO9x5552ora1FfX09Zs2ahR9++AFKpbLZ45977jksXbq0yfWrV6+GRqPpiujkIEq1wAvH5KgXBdwfq0ecj038ahARERGRhVRXV2Pu3LkoKyuDp6fnZY+1q8Lp1KlTSEhIwOOPP45p06YhJycHTz31FIYOHYrPPvus2ds0N+MUFhaGwsLCVp8ca9DpdEhMTMSUKVNaLP7Iev6zMQWf7c1EnxAPrLt/BGSyxrNOHC/7wvGyPxwz+8Lxsj8cM/vC8bK88vJy+Pv7t6lwsquleq+88gpGjx6Np556CgAwYMAAuLm5YezYsXjxxRcREhLS5DZqtRpqtbrJ9Uql0qZegLaWx1ktnNQb3x7OxqmcCiSmFOKqAaHNHsfxsi8cL/vDMbMvHC/7wzGzLxwvy2nP82pX53Gqrq6GTNY4slwuBwDYyMQZ2TlfNxXuGRsBAHhz8xnU6w0SJyIiIiIiWyBp4VRZWYmkpCQkJSUBANLT05GUlISsrCwAwOLFizFv3jzz8bNmzcLatWvxwQcf4Ny5c9i7dy8eeeQRDBs2DKGhzc8MELXXXWPD4eemwrnCKnx/5ILUcYiIiIjIBkhaOB0+fBjx8fGIj48HACxatAjx8fFYsmQJACAnJ8dcRAHAggUL8Oabb2L58uXo168fbrjhBsTExGDt2rWS5CfH5K5W4MGJUQCAd7amolanlzgREREREUlN0j1OEyZMuOwSu5UrVza57uGHH8bDDz9swVREwK3De+Cz3edwsawWX+/PxN0Ny/eIiIiIyDnZ1R4nImtxUcrxWEJvAMB729NQUcvzJxARERE5MxZORC2YM6gbIgPcUFKtw6e706WOQ0REREQSYuFE1AKFXIYnpsYAAD7dfQ5FldpWbkFEREREjoqFE9FlzOgXjP7dvFBVp8f7O85KHYeIiIiIJMLCiegyBEHAU9OMs05f7c9ETlmtxImIiIiISAosnIhaMTbaHyMifFFXb8C72znrREREROSMWDgRtUIQBPxjeiwA4Iej2cirkTgQEREREVkdCyeiNhjUwwcJcUEwiMCG8/y1ISIiInI2fAdI1EZPTYuBIABJRTIcyyqVOg4RERERWRELJ6I2ign2wHXx3QAAL25IhsEgSpyIiIiIiKyFhRNROyxKiIJaLuKP7HKsPZYtdRwiIiIishIWTkTtEOChxrRuBgDAso3JqNTWS5yIiIiIiKyBhRNRO40PEdHD1xX5FVq8vz1N6jhEREREZAUsnIjaSSED/jndeFLcT/ekI6uoWuJERERERGRpLJyIOmBSbADGRPmjrt6AlzecljoOEREREVkYCyeiDhAEAc9e1QdymYCNJ3Px+9lCqSMRERERkQWxcCLqoJhgD9w2vAcA4PmfT6Feb5A4ERERERFZCgsnok54LKE3vFyVSM6twP8OnZc6DhERERFZCAsnok7wcVNh0ZTeAIA3NqegrFoncSIiIiIisgQWTkSddOvwHogOdEdJtQ7vbE2VOg4RERERWQALJ6JOUshlWDKrDwDgy30ZSMuvlDgREREREXU1Fk5EXWBsdAAS4oJQbxDx4q+npI5DRERERF2MhRNRF/nXzDgo5QJ2pBRge3K+1HGIiIiIqAuxcCLqIuH+brhzdDgA4IVfTqGunu3JiYiIiBwFCyeiLvTQpCj4u6twrrAKX+7LkDoOEREREXURFk5EXcjDRYmnpsUAAN7ZmoqiSq3EiYiIiIioK7BwIupi1w8OQ79unqiorccbiWekjkNEREREXYCFE1EXk8sELLmqLwDgm4NZOHmxTOJERERERNRZLJyILGBYuC+uGhACUQSe//kURFGUOhIRERERdQILJyILWXxlHNQKGQ6kF2Pjn7lSxyEiIiKiTmDhRGQh3bxdcd/4SADASxtOo1anlzgREREREXUUCyciC7p/fARCvFxwoaQGn+1JlzoOEREREXUQCyciC9KoFHhmRiwA4L3tacgtq5U4ERERtSa/vBZf7svA0awS6A3co0pERgqpAxA5uqsHhuLLfZk4klmCZRuT8eZNV0gdiYiILuO5n09iwwnj3lRfNxUm9A7AhNhAjI8OgJdGKXE6IpIKCyciCxMEAf+e1QdXL9+LtceycfvInojv4SN1LCIiakatTo8dKQUAAI1KjuKqOqw9lo21x7IhlwkY3MMHE2MDMTE2ADFBHhAEQeLERGQtLJyIrGBAd29cP7g7vj9yAUt/PoW1D4yCTMZ/bImIbM2B9GJU1+kR5KnG7n9MwtGsEmxPzsf2lHycyavEwYxiHMwoxqsbk9HN2xUTYgIwMSYQo6L8oFHxbRWRI+NvOJGV/GNaDH47kYOk86X48Xg2ro3vLnUkIiL6m22n8wAAk2KDoFLIMCLCDyMi/LD4yjicL67GjpR8bEvOx+9ni5BdWoNVB7Kw6kAWVAoZRkb4YWJMACbFBqGHn0bin4SIuhoLJyIrCfR0wcJJUVi2MQX/+S0ZU/sEw03NX0EiIlshiiK2JucDACbHBjb5fpivBreP7IXbR/ZCrU6PfWeLsC3ZWEhll9Zg55kC7DxTgOd+PoXIADdMig3ExJhADOnlC5WC/biI7B3ftRFZ0Z2jw/G/g+eRVVyND3acxZPTYqSOREREDVLzK3GhpAZqhQyjo/wve6yLUt6w1ykQz4si0vIrzUXU4cwSnC2owtmCdHyyOx3uagXGRvtjYmwgJsQEINDDxUo/ERF1JRZORFbkopTjXzPjcN9XR/Dx7nO4aWgYwny5nIOIyBZsPW2cbRod5Q9XlbzNtxMEAdFBHogO8sB94yNRVqPDntRCbEvOx84z+SisrMNvf+bitz+Nnfr6d/MyFl0xARjY3Zt7XonsBAsnIiub2icIoyL98PvZIrzy22m8f+tgqSM5rMRT+XjzhBzfFxxBoKcrAj3VCHBXI8Djr69ADzXc1Qp2xiIibDXvb2q6TK89vFyVmDkgBDMHhMBgEHEiuwzbGhpM/HGhDCeyjV//3ZoKPzcVxjc0mBjXOwBermx3TmSrWDgRWZkgCFgyqw+ufGc3NpzIxf5zRRgR4Sd1LIez72wRHl1zHDq9gMy0osse66KUGQsp90sLKpcm1/m7q7lPgchBFVfV4WhWCYDOF06XkskEDAzzxsAwbzw+pTcKKrTYkWIsonafKURRVR3WHs3G2qMN7c57+mBiTCAmxQaid5A7P9QhsiEsnIgkEBvsibnDe+Dr/VlY+vMp/PLwGMi5VKPLpORW4N6vDkOnF9Hfx4BbJ/RHUXU9Ciq0KKjUoqBCi8IKLfIrtKjU1qNWZ8D54hqcL65p9b59NMq/ZqyaK7QarvfWKPmGh8iO7DyTD4MIxIV4ItTb1WKPE+Chxg1DwnDDkDDo9AYczijB9oZOfWn5lTiYXoyD6X+1O58Y29DuPLJ9yweJqOuxcCKSyKIpMfgp6SJO55Tj20PnMXd4D6kjOYTcslosWHEQFbX1GNzDGzcHF2L2oG5QKptf/lJdV4/CijoUVNaioKGYKrj0q/Kv/683iCip1qGkWoczeZWXzaGUC02WBf512cW8TDDAQw0XJd8MEUnNtL+puW56lqKUyzAy0g8jI/3wz4Z256Yial9Du/Ov92fh6/1ZUCuMx5o69XF/LJH1sXAikoivmwqPT+mNpT+fwhubUzBzQAjXtndSea0OC1YcRE5ZLSID3PDhrfH4fUfiZW+jUSnQw0/R6jlXDAYRpTW6SwqqWuSXNy2uCiq1KK3WQacXcbGsFhfLalvN7aFWNC6w/lZomWazfN1UnJkksgCd3oCdZwoAAJPirFc4/V2YrwbzRvbCvJG9UFOnx75zxgYT25MLkF1agx0pBdiRUgDgJKIC3S9pd+4DpZzLiIksjYUTkYRuG9ETqw5kIS2/Eu9uTcX/XdVH6kh2q67egPu/OoLk3AoEeKix8o5h8NZ0XSEqkwnwdVPB102FmGCPyx6rrdejsLKu0cxVfkVtk1ms/Aot6uoNqNDWo0Jbj3OFVZfPIAB+7saCKsTLBQ9PjsYVYd5d9jMSOavDGSWoqK2Hn5sKA7t7Sx0HAOCqkmNSbBAmxQZBFEWkXtLu/EhmCdLyK5GWX4mPd52Dh1qBsb39MTEmEBNiAhHgoZY6PpFD6lDhdP78eQiCgO7duwMADh48iNWrV6NPnz649957uzQgkSNTymV49qo+mP/5Qaz8PQO3DO+ByAB3qWPZHVEU8Y/vj+P3s0VwU8mxYsFQhPlqoNPpJMmjVsjRzdsV3VrZJyGKIspr65spqGobFV2FlVoUVdXBIMJ83amcclTX6fHNvSOs9FMROa5tycZuehNiAm1yVlcQBPQO8kDvIA/cPz4SZdU67E4rMLY7TylAUVUdNpzIxYYTxnbnA7p7YWKM8RxTA7p5sd05URfpUOE0d+5c3Hvvvbj99tuRm5uLKVOmoG/fvli1ahVyc3OxZMmSrs5J5LDG9w7A5NhAbE3Ox0u/nsbnC4ZKHcnuLNuUgvVJFyGXCXj/tsHo181L6khtIggCvFyV8HJVIirw8gWzTm9AcZVxFutsQSUe/V8SDmYUo6xaB68unFkjckam/U0JEi7Taw8vjRJXDQjFVQNCYTCI+MPU7jw5Hyeyy/DHBePXO1tT4e+uwvjegZgYG4Cx0QHQcK0RUYd1aEHsn3/+iWHDhgEA1qxZg379+uH333/HqlWrsHLlyjbfz65duzBr1iyEhoZCEASsX7++1dtotVr861//Qs+ePaFWq9GrVy98/vnnHfkxiGzGv2bGQSkXsC05HztS8qWOY1e+2peBD3acBQD8Z05/jO8dIHEiy1DKZQjydEG/bl645opuiAp0h94gYscZvl6IOuNcQSXOFVZBKRcwJtpf6jjtJpMJuCLMG4um9MbPD4/BwX9OxrLrB2BGv2C4qxUorKzDD0cv4KHVxzDohUTc9vkhnL98bxsiakGHPnfQ6XRQq43rZ7ds2YKrr74aABAbG4ucnJw2309VVRUGDhyIO++8E3PmzGnTbW688Ubk5eXhs88+Q1RUFHJycmAwGNr/QxDZkIgAdywY1Quf7E7HC7+cwugof270bYPNJ3Px759OAgAWTemNG4aESZzIehLigpCWX4mtp/NxzRXdpI5DZLe2JRs/fBge7gcPF/ufvQ30dMGNQ8Jw45Aw1NUbcDizGNsb9kadLajCgfQSVHjLcJ/UQYnsUIcKp759++LDDz/EzJkzkZiYiBdeeAEAcPHiRfj5tf1EnjNmzMCMGTPafPzGjRuxc+dOnDt3Dr6+vgCAXr16tSs7ka16eHI01h7NxtmCKny1LxN3jgmXOpJNO5JZgoe/OQaDCNwyLAwPT4qSOpJVJcQF4sOdZ7EjJR86vYGFNlEHmQqnrjzpra1QKWQYFemPUZH++NfMPth3tgi3fLIfaeUC6uoNaOEsDUTUgg4VTq+++iquvfZavPbaa5g/fz4GDhwIAPjpp5/MS/gs4aeffsKQIUOwbNkyfPXVV3Bzc8PVV1+NF154Aa6uzW/C1mq10Gq15svl5eUAjLNmUm0cv5Qpgy1kodZZcrxc5cDjCVH4vx9P4e0tZzCzXyB83VRd/jiOIL2wCnd/cQjaegPG9/bHkitjUF9f3+Q4R/796hfiDh+NEiXVOuxPK8CICF+pI3UJRx4zR2Tv41VRq8PB9GIAwLhoX7v9OdpqUHcP+GqUKK7W4XB6IUZFO16x6Gjs/XfMHrTnuRVEURQ78iB6vR7l5eXw8fExX5eRkQGNRoPAwPb/IgqCgHXr1mH27NktHjN9+nTs2LEDCQkJWLJkCQoLC/Hggw9i4sSJWLFiRbO3ee6557B06dIm169evRoaDU8eR7bFIAKv/yFHdrWA0UEG3BjBZah/V14HvP2nHEVaAWFuIh7uq4faSc8fuypNhoMFMkwIMeDaXnytELXXsSIBK8/IEeQq4p9X6KWOYxVfpspwpFCGqd0MmNmDfzeIqqurMXfuXJSVlcHT0/Oyx3ZoxqmmpgaiKJqLpszMTKxbtw5xcXGYNm1aR+6yTQwGAwRBwKpVq+DlZeya9eabb+L666/H+++/3+ys0+LFi7Fo0SLz5fLycoSFhWHq1KmtPjnWoNPpkJiYiClTpkDJOXObZ43xCuxbjFs/O4x9+TI8c/1oxLZyziBnUl1Xj9s+P4wibTnCfFyx5t5h8Hdv+Xwljv77JTuZh4P/O45zWjfMmDEGgmD/LYcdfcwcjb2P144fTgDIwVWDeuHK6TFSx7GKykNZOPJTMnJEL1x55Uip41Ar7P13zB6YVqO1RYcKp2uuuQZz5szB/fffj9LSUgwfPhxKpRKFhYV488038cADD3TkblsVEhKCbt26mYsmAIiLi4Moirhw4QKio6Ob3EatVpsbWVxKqVTa1AvQ1vLQ5VlyvEZHB2Fm/xD8eiIHL/92BqvvGe4Qb4g7q15vwGNrjuFEdjl8NEp8cecwhPi07ZxXjvr7NTEuGCr5CWQV1yCrVIuoQMcpsh11zByVPY6X3iBiZ2oRAGBq3xC7y99R42ICASTjZE4FqnQivDVcEm4P7PF3zF6053nt0G7io0ePYuzYsQCA77//HkFBQcjMzMSXX36J//73vx25yzYZPXo0Ll68iMrKv/ponjlzBjKZzHwyXiJH8MyMWKgUMuw7V4RNJ/OkjiM5URTx7I9/YntKAdQKGT6dPxQRPFEw3NUKjIg0NuTZcpptyYnaI+l8CYqr6uDposDgnj6t38BBBHu6IMhVhEEEfj9bJHUcIrvSocKpuroaHh7GTzY3b96MOXPmQCaTYcSIEcjMzGzz/VRWViIpKQlJSUkAgPT0dCQlJSErKwuAcZndvHnzzMfPnTsXfn5+uOOOO3Dq1Cns2rULTz31FO68884Wm0MQ2aMwXw3uGxcBAHhpwynU6pxj7X1Llm9LwzcHz0MmAO/eEu9Ub3JaYzph59bTLLCJ2sN00tsJMYFQOFlXylgv4/b23amFEichsi8d+ksRFRWF9evX4/z589i0aROmTp0KAMjPz2/XvqHDhw8jPj4e8fHxAIBFixYhPj4eS5YsAQDk5OSYiygAcHd3R2JiIkpLSzFkyBDceuutmDVrlkVnuYik8sCESAR7uuB8cQ0+35sudRzJfHf4PN5IPAMAWHp1X0ztGyxxItsyOS4IgLE9e3FVncRpiOyHqQ355Djn6ywX420qnArQwR5hRE6pQ3uclixZgrlz5+Lxxx/HpEmTMHKkcXPh5s2bzUVQW0yYMOGyv7ArV65scl1sbCwSExPbnZnI3mhUCjw9IwaPf3scy7el4bpB3RHk6SJ1LKvaeaYAi9eeAGAsJG8f2UvaQDaom7cr4kI8cTqnHNuT83HdYC5bJmrNhZJqJOdWQCYA43sHSB3H6qI8RSjlAi6U1CCzqBq9/N2kjkRkFzo043T99dcjKysLhw8fxqZNm8zXT548GW+99VaXhSNydtcM7Ib4Ht6ortNj2cYUqeNY1Z/ZZXjw6yOoN4iYfUUonprqHB2vOsK8XC+Zy/WI2mJ7w2zTkJ6+TtkcQS0H4sO8AQC707hcj6itOryoNzg4GPHx8bh48SIuXLgAABg2bBhiY2O7LByRs5PJBPx7Vl8AwA9HL+D4+VJpA1nJ+eJq3LHyEKrq9Bgd5Ydl1w+ETMbOgi1JaFiutzOlANp6594PR9QWWxsKp0lOuEzPZHRDY5k9qQUSJyGyHx0qnAwGA55//nl4eXmhZ8+e6NmzJ7y9vfHCCy/AYODJ1Ii60hVh3pgzqBsAYOnPJx1+PXppdR0WrDiIggotYoM98MFtg6FSONfG7fbq380LAR5qVNXpceBcsdRxiGxadV29uZtcgjMXTlHGwun3s0Wo1/O9G1FbdOjdyL/+9S8sX74c//nPf3Ds2DEcO3YML7/8Mt599108++yzXZ2RyOk9PT0WGpUcR7NK8dPxi1LHsZhanR73fHkYZwuqEOLlgpV3DIOnC89b0RqZTMDkWHbXI2qLPamFqKs3oIevBpFOfFqDfqGe8HJVoqK2HscvlEkdh8gudKhw+uKLL/Dpp5/igQcewIABAzBgwAA8+OCD+OSTT5pt6EBEnRPk6YKFE6MAAK9sSEZ1Xb3EibqewSDi8W+TcCijBB4uCqy8YxiCvZyrGUZnmJbrbTmd7/CzkkSdYeqmNyk20KlPLi6XCeZZpz1sS07UJh0qnIqLi5vdyxQbG4viYi4TIbKEu8aEo7uPK3LLa/HhjrNSx+lSoijihV9P4bc/c6GSy/Dx7UMQE+whdSy7MjrKH2qFDNmlNUjOrZA6DpFNMhhEp25D/ndjoowdBfekcZ8TUVt0qHAaOHAgli9f3uT65cuXY8CAAZ0ORURNuSjl+NeVcQCAj3adw4WSaokTdZ3P9qRjxd4MAMDrNw7EyIZNy9R2rio5xkT5AwC2nOJyPaLmnLxYjvwKLdxUcgwL95U6juTGRhv/ZhzNKkVFrU7iNES2r0OF07Jly/D555+jT58+uOuuu3DXXXehT58+WLlyJV5//fWuzkhEDab3C8aICF9o6w145bdkqeN0iZ+PX8SLv54GAPzzylhcPTBU4kT2K6FPw3K9hk/UiagxU8v+sdEBUCvkEqeRXpivBr38NNAbROxnYxmiVnWocBo/fjzOnDmDa6+9FqWlpSgtLcWcOXNw8uRJfPXVV12dkYgaCIKAJVf1hUwAfv0jBwfT7fsfuv3nivDEmuMAgAWjeuGesRESJ7JvpgYRx8+XIr+iVuI0RLZnG9uQNzGmYdaJbcmJWtfhHr+hoaF46aWX8MMPP+CHH37Aiy++iJKSEnz22WddmY+I/qZPqCduHtYDgLE9ud5gn40AzuRV4N4vD6NOb8D0vsF49qo+Tr1RuysEerpgQHcvAMC205x1IrpUXnkt/rhQBkEAJsawcDIx7XPiiXCJWseToxDZoSem9IaHiwInL5bju8PnpY7TbrlltVjw+UGU19ZjSE8fvH3zFZDzBLdd4tLuekT0l+0Ns00Du3sjwEMtcRrbMTLSDzIBOFdQhezSGqnjENk0Fk5EdsjPXY3HEnoDAF7fnIJyO9rUW1Grw4IVB3GxrBYRAW74ZN4QuCi516CrmDqF7UkrQK1OL3EaItux1dRNL5azTZfyclXiijBvAFyuR9QaFk5EdmreyJ6ICHBDYWUdlm9LkzpOm9TVG3D/10eQnFsBf3c1vrhjGHzcVFLHcih9QjwR6uWCWp0Be7n0hgiA8eTapnMVcX9TU2OiG5br8XxORJelaM/Bc+bMuez3S0tLO5OFiNpBKZfh2av64I4Vh7BibzpuGdYD4f5uUsdqkSiKePqHP7A3rQgalRwr7xiKMF+N1LEcjiAImBwXhK/2Z2LL6XxMbli6R+TM9p8rQo1Oj2BPF/QJ8ZQ6js0ZG+2P/25Nxd60QhgMImRcOk3UrHbNOHl5eV32q2fPnpg3b56lshLR30yMCcSEmADo9CJe+vWU1HEu6/XNKVh3LBtymYD3bx2Eft28pI7ksEzL9bYl58Fgp81DiLrSpd302ISmqSvCvOGuVqCkWoeTF8uljkNks9o147RixQpL5SCiDvq/mX2wJ3UXtpzOx64zBRjXO0DqSE18vT8T720/CwB4ZU5/TGBHK4saGekHN5UceeVa/HmxDAO6e0sdiUgyoihi62nub7ocpVyGERF+2HI6D7vTCtC/Oz/YImoO9zgR2bmoQHfMH9ULAPDCL6eg0xukDfQ3iafysOTHPwEAjyf0xo1DwiRO5PjUCjnGNuxZYHc9cnZn8iqRXVoDtUKGUZH+UsexWWPN53PiPieilrBwInIAj0yOhq+bCqn5lVi1P1PqOGZHs0rw8DdHYRCBm4eG4ZHJUVJHchqm5XpbT+dJnIRIWlsafgfGRPnDVcUOni0xnQj3cEYJaurYkZOoOSyciByAl6sST0w1tid/a0sqSqrqJE4EpBdW4e4vDqNWZ8DEmAC8OLsf9xZY0aTYQAgCcPJiOS7y3CzkxC7d30Qti/B3QzdvV9TpDTiQXiR1HCKbxMKJyEHcPLQHYoM9UFajw1tbzkiapbBSiwUrDqK4qg79u3lh+dxBUMj558aa/NzVGNTDB8Bf568hcjbFVXU4mlUCwPhhArVMEASMieJyPaLL4TsZIgchlwlYMqsPAGMzhpTcCklyVNfV466Vh5BZVI0wX1d8vmAo3NTt6kNDXYTL9cjZ7UjJhygaz28W4uUqdRybZ1qux/M5ETWPhRORAxkV6Y8Z/YJhEIHnfzkJUbRuK+p6vQEPrz6G4xfK4KNR4os7hiHAQ23VDPSXKQ3ncPo9rQhV2nqJ0xBZn2m2dTKX6bXJ6Ch/CAKQkleB/PJaqeMQ2RwWTkQO5p9XxkGlkGFvWhEST1lvpkEURTz740lsTc6HWiHDp/OHIiLA3WqPT01FBbqjh68GdXoDP0Emp6PTG7ArpQAAl+m1la+bCv1Cja3I96TxbwbR37FwInIwYb4a3DM2HADw0obT0NZbpzvSe9vT8M3BLMgE4L+3xGNwTx+rPC61TBAELtcjp3UooxgV2nr4uakwkOcya7MxbEtO1CIWTkQO6MEJUQj0UCOzqBor9mZY/PG+P3IBr282NqR47uq+mNY32OKPSW1jWq63LTkfeoN1l24SScl00tuJsYGQydjRs63GNjSI2J1WaPXl3kS2joUTkQNyUyvw9PRYAMC7W1ORX2G5teq7zhTgmR/+AADcPz4S80b2sthjUfsNDfeFh4sCRVV1SDpfKnUcIqsxtSFP4P6mdhncywcuShkKKrRIyZOmyRCRrWLhROSgro3vhoFh3qiq0+P1TSkWeYyTF8vwwNdHUG8QMfuKUPxjWoxFHoc6TimXYUIMl+uRczlXUIn0wioo5QLGRAdIHceuqBVyDA/3A8DlekR/x8KJyEHJZAL+3dCe/LsjF/DHhdIuvf8LJdVYsOIQqur0GBXph2XXD+RyGBtl+sR9CwsnchKm2aYREX5w5+kQ2m1swz6nXSyciBph4UTkwAb18MG18d0gisDzP5/qsvXqpdV1WLDiEAoqtIgN9sCHtw+GSsE/J7ZqQu9AyGUCzuRVIquoWuo4RBZn2t/EbnodM7Zhlu5gehFqddZpMERkD/hOh8jBPT09Fq5KOQ5nluDnP3I6fX+1Oj3u/fII0vIrEeLlghV3DIWni7ILkpKleGmUGNrL2OWQs07k6MpqdDiUUQyAhVNH9Q5yR6CHGrU6A45mlkgdh8hmsHAicnDBXi54cEIkAOCVDadRU9fxTw8NBhGL1iThYEYxPFwUWHnHMIR4uXZVVLKghIbueluTWTiRY9udWoB6g4ioQHf09HOTOo5dEgQBYy7prkdERiyciJzAPeMi0M3bFTlltfhw59kO389LG05jw4lcqOQyfHz7EMQEe3RhSrKkyQ2F04FzxSiv1UmchshyTMv0JnO2qVNM53PanVogcRIi28HCicgJuCjl+OeVcQCAj3adRXZpTbvv49Pd5/DZnnQAwOs3DsTISL8uzUiWFe7vhsgAN9QbROxM4Rshckx6g4jtKQ2FU8OHBdQxphmnkxfLUVxVJ3EaItvAwonISVzZPxjDwn1RqzPgP78lt+u2v/xxES/+ehoA8M8rY3H1wFBLRCQLMy/X4z4nclDHskpQWq2Dl6sSg3p4Sx3HrgV6uiA22AOiCOzlcj0iACyciJyGIBjbkwsC8PPxi+bN0605cK4Ii749DgBYMKoX7hkbYcmYZEGmT+C3pxSgXm+QOA1R19va0IZ8QkwAFHK+xeks8z4nLtcjAsDCicip9A31ws1DwwAAS38+CYPh8u3JU/MqcM+Xh1GnN2Ba3yA8e1UfCALP1WSvBvXwho9GibIaHQ6zUxY5oG1sQ96lxvY2tiXfk1rYZaezILJnLJyInMwTU2PgoVbgz+xyfH/kQovH5ZXXYsGKQyivrcfgnj545+Z4yHmCW7umkMswMcb4hpLL9cjRnC+uRkpeBeQyAeMb3vBT5wzr5QuVXIaLZbU4V1gldRwiybFwInIy/u5qPDI5GgCwbFMKKprpsFZRq8OCFYeQXVqDiAA3fDpvCFyUcmtHJQuYbN7nlC9xEqKuZWoKMbinD7w1KonTOAZXlRxDGs4BtyeV+5yIWDgROaH5o3oh3N8NhZVaLN+e1uh7dfUGPPD1UZzOKYe/uxpf3DEMPm58E+IoxvX2h1Iu4FxhFc4WVEodh6jLbGEbcotgW3Kiv7BwInJCKoUMz15lbE++Yk8GMhqWYIiiiGfW/oE9aYXQqORYsWAownw1UkalLubhosSICGMreS7XI0dRpa3H/rNFANiGvKuNizYue9x/rhg6NpUhJ8fCichJTYwJxLjeAajTG/DSBmOr8Tc2n8Hao9mQywS8f+sg9O/uJXFKsgTTJ/JbuFyPHMSetELU6Q3o6adBZICb1HEcSp8QT/i6qVCprUfS+VKp4xBJioUTkZMSBAFLroqDXCYg8VQe/vH9cfOyvVeu7Y8JMVzu4qhMn8gfzihGCU9sSQ7g0m567PzZtWQyAaMaTni++wyX65FzY+FE5MSiAj1w+4ieAIA1h40d9h5LiMaNDS3LyTGF+WoQG+wBgwjsOMNZJ7JvBoOIbSmm/U1cpmcJpuV6u3kiXHJyLJyInNzjCb3ho1ECAG4aEoZHGzrukWNLaJh14nI9snd/XixDQYUWbio5hoX7Sh3HIZkaRBw/X4qymqadWImcBQsnIifnpVFixR3DsPTqvnjx2n5c5uIkJscZl2LuTClAXT03fJP9MrXWH9c7ACoF39ZYQqi3KyIC3GAQgX0NTTiInBH/whARrgjzxvxRvaCU80+CsxjY3Rv+7mpUautxML1Y6jhEHbY12dgdchLbkFvU2Ci2JSfiuyQiIickkwmXdNdjW3KyT7lltfgzuxyCAExk4WRRYxv2Oe3hPidyYiyciIiclGm53pbTeRBFUeI0RO23vaEpxBVhxhlUspwRkX5QyARkFlUjq6ha6jhEkmDhRETkpMZE+0OlkOFCSQ3O5FVKHYeo3Uz7myZztsni3NUKxPfwBgDsTuNyPXJOkhZOu3btwqxZsxAaGgpBELB+/fo233bv3r1QKBS44oorLJaPiMiRaVQKjGnYt8DlemRvanV67G1YNjaJbcitwrxcL5XL9cg5SVo4VVVVYeDAgXjvvffadbvS0lLMmzcPkydPtlAyIiLncOlyPSJ7su9cEWp0eoR4uSAuxEPqOE7B1JZ8b1oh9AYu7yXno5DywWfMmIEZM2a0+3b3338/5s6dC7lc3q5ZKiIiamxybBD+hT+RdL4UBRVaBHhwnwjZh20Ny/QmxQbyNApWMqCbFzxcFCivrccfF0oR38NH6khEViVp4dQRK1aswLlz5/D111/jxRdfbPV4rVYLrVZrvlxeXg4A0Ol00OmkP4mbKYMtZKHWcbzsC8erdX4aOfqFeuLPi+VIPJmDGwZ3kzQPx8y+SDVeoiiaZ0nHR/vx9dIOnR2zkRG+2HwqHztT8tEvxL0ro1Ez+DfR8trz3NpV4ZSamopnnnkGu3fvhkLRtuivvPIKli5d2uT6zZs3Q6PRdHXEDktMTJQ6ArUDx8u+cLwur7tMwJ+Q45udJ+CWd1zqOAA4ZvbG2uOVXQXklCmglIkoO3MIG85a9eEdQkfHzKtGACDHzwdTEV6d3LWhqEX8m2g51dVt7xJpN4WTXq/H3LlzsXTpUvTu3bvNt1u8eDEWLVpkvlxeXo6wsDBMnToVnp6elojaLjqdDomJiZgyZQqUSqXUcagVHC/7wvFqm54Xy7Hxg/1Iq1Rg8pSJUCvlkmXhmNkXqcbrg53nAKRhbHQgZs+Kt9rjOoLOjlnf4mp899YeZFXLMG7yZLir7eatpF3i30TLM61Gawu7ebVXVFTg8OHDOHbsGB566CEAgMFggCiKUCgU2Lx5MyZNmtTkdmq1Gmp10zX7SqXSpl6AtpaHLo/jZV84Xpc3sIcvgj1dkFtei0NZ5TZxIlGOmX2x9njtOGPs6pbQJ5ivkw7q6JhFBXkhzNcV54trcPR8OSbHsaOhNfBvouW053m1m/M4eXp64sSJE0hKSjJ/3X///YiJiUFSUhKGDx8udUQiIrskCAK765HdKKrU4tj5UgDGxhBkfaa25LvZlpycjKSFU2VlpbkIAoD09HQkJSUhKysLgHGZ3bx58wAAMpkM/fr1a/QVGBgIFxcX9OvXD25ublL9GEREdi+h4VPjrafzIYpsM0y2a0dKAUQR6BvqiWAvF6njOKWxDed/25PGwomci6SF0+HDhxEfH4/4eOP65EWLFiE+Ph5LliwBAOTk5JiLKCIispyRkX5wVcqRW16Lkxfbvt6byNq2JRvbkE/mbJNkRkX6QyYAafmVyCmrkToOkdVIWjhNmDABoig2+Vq5ciUAYOXKldixY0eLt3/uuefMs1VERNRxLko5xjac3JLL9chW1dUbsPNMAQBgEvfWSMZLo8SA7t4AuFyPnIvd7HEiIiLLSujz13I9Ilt0KKMYldp6+LurMKCbl9RxnJrpg5Y9LJzIibBwIiIiAMaN9oIAnMguQ25ZrdRxiJowFfUTYwIhkwkSp3FuYxr2Oe1NK4TBwH2R5BxYOBEREQDA312NK8K8AQBbk7lcj2yLKIrm1yVbYEsvvocPNCo5iqrqcCqH+yLJObBwIiIis0u76xHZknOFVcgsqoZKLsOYhmViJB2VQoaREX4A2F2PnAcLJyIiMjMVTnvSClFdVy9xGqK/bGso5odH+MJdrZA4DQEwF7Dc50TOgoUTERGZ9Q5yR3cfV9TVG/hmiGyKeZke25DbDFODiIMZxajV6SVOQ2R5LJyIiMhMEAQu1yObU1ajw6GMEgDApFjub7IVkQHuCPFyQV29AQfTi6WOQ2RxLJyIiKgRc+GUnM9uWWQTdp4pgN4gIjrQHT38NFLHoQaCIJi763GfEzkDFk5ERNTIsHBfeKgVKKzU4viFUqnjEGFbw0mZJ8VxmZ6tMe1z4olwyRmwcCIiokZUChnGxQQA4HI9kl693oAdZwoA/DUbSrZjdMOM0+mcchRUaCVOQ2RZLJyIiKiJhIZP9rec5vmcSFrHzpeitFoHb40S8Q3nGSPb4e+uRt9QTwDGk+ESOTIWTkRE1MSE3oGQCUBybgXOF1dLHYecmGnWc0LvACjkfNtii7hcj5wF/wIREVETPm4qDOnlCwDYylknktC2ZNP+Ji7Ts1Vjo4xLe3enFkAU2VCmqxgMIv7vx5P4IV3G59VGsHAiIqJmmZbrbU3mPieSxvniapzJq4RcJmB8dIDUcagFQ3r5QK2QIb9Ci9T8SqnjOIwtp/Pw7eFs7MqVIelCmdRxCCyciIioBZMbPuHff64IFbU6idOQMzLNdg7p6QMvjVLiNNQSF6Ucw8KNM9Rcrtd1Ptp1zvz/3x6+IGESMmHhREREzYoMcEeEvxt0ehG7zvDNEFmfabZzMtuQ27yxDfuc9qQWSJzEMRzOKMaRzBLIBOPlX0/koqyGH2BJjYUTERG1yPSGlfucyNoqtfU4cK4YwF+zn2S7xjTsc9p/rhjaer3EaezfhzuNs003DO6GEFcRtToDfkzKljgVsXAiIqIWmc6bsz0lH/V6g8RpyJnsSS1End6AXn4aRPi7SR2HWhEb7AF/dzVqdHoczSyVOo5dS82rwJbTeRAE4K7RvTAqyPi3d/WBLDaJkBgLJyIiatHgnj7wclWipFqHo1mlUschJ2LuphcbBEEQJE5DrZHJBIyJ8gMA7Enjcr3O+Lhhb9O0PsEI93fDkAARaoUMybkVOHa+VNpwTo6FExERtUghl2FijHEJDpfrkbUYDCK2JRvffHN/k/0YE21qS849kR2VW1aL9Q1L8u4bHwEA0CiAK/sHAwC+OZAlWTZi4URERK1I6GNcrreFhRNZyYnsMhRWauGuVmBow/nEyPaZGkScyC5DSVWdxGns04q96dDpRQwL90V8Dx/z9TcP6Q4A+PmPi2wSISEWTkREdFnjegdAIRNwtqAK6YVVUschJ2Ca3RzX2x8qBd+q2IsgTxf0DnKHKAK/ny2SOo7dKa/VYVXDjNL9DbNNJvFhXogJ8mCTCInxrxEREV2Wp4sSwyOMn/pzuR5Zg6kN+aRYdtOzN6buetzn1H6rD2ShUluP3kHumNC78RJVQRBwy7Aw83FsEiENFk5ERNQqU3c9LtcjS8stq8XJi+UQBGBCw/46sh+m5Xq7zhTyzX07aOv1+HxPOgDgvnGRkMmaNkS5Nr47m0RIjIUTERG1ylQ4HcooQVk119eT5WxrmG2KD/OGv7ta4jTUXsMjfKGUC8gurUFGUbXUcezG+mPZyK/QIsTLBbMGhjZ7jJdGiasGGL/HJhHSYOFEREStCvPVoHeQO/QGETvO5EsdhxyYqQ05T3prnzQqBQb3NDY12JPK5XptYTCI+KihBfldY8Ivu69v7nDjcj02iZAGCyciImqTv5brsXAiy6jV6bEnzdjKelIs25Dbq7ENbcl3sS15m2w5nYdzBVXwcFHg5mE9LnvsoB4+6B3kziYREmHhREREbWKaAdiRkg+d3iBxGnJE+84WoVZnQKiXC2KDPaSOQx1k2ue0/2wR6vm3olWm2abbR/SEu1px2WMFQcDchuKKTSKsj4UTERG1yRVh3vBzU6Gith6H0ouljkMOyNR8ZFJcIASh6eZ4sg99Q73grVGiQluP4xdKpY5j0w5lFONIZglUChkWjO7VptuwSYR0WDgREVGbyGWCefkUl+tRVxNF0dwYYjLbkNs1uUzA6EjjrNNuLte7rI92ngUAXDeoOwI9XNp0GzaJkA4LJyIiarPJl7Ql5xIR6kqncyqQU1YLF6UMIyP9pI5DnTQmmoVTa1LzKrDldD4EAbhnbHi7bssmEdJg4URERG02NtofKrkMWcXVSMuvlDoOORBTN70xUQFwUcolTkOdNSbKWDglnS9FeS3f2Dfn44a9TdP6BCMiwL1dt2WTCGmwcCIiojZzUyswKso4G5DIk+FSF9pqWqYXx256jiDMV4NwfzfoDSL2ny2SOo7NyS2rxfqGgue+8RHtvj2bREiDhRMREbWLabneVu5zoi5SWKlFUsMm94kxLJwchWnWicv1mlqxNx06vYhh4b6I7+HToftgkwjrY+FERETtktAwI3A0qwRFlVqJ05Aj2JFSAFEE+nXzRLBX2zbIk+0ztSU3nZuLjMpqdFjV0NTh/g7MNpl4aZSYOSAEAJtEWAsLJyIiapcQL1f0DfWEKMLcBY2oM7aa2pCzm55DGRHpB7lMQHphFS6UVEsdx2asPpCFSm09YoI8Oj3Deutw43K9n/+4yL1kVsDCiYiI2o3L9air1NUbsOtMAQBgciyX6TkSTxclrgjzBgDs4XI9AIC2Xo/P96YDAO4dF9Hp85Vd2iRi/TE2ibA0Fk5ERNRuUxoKp12pBajV6SVOQ/bsYHoxqur08HdXo383L6njUBfjPqfG1h/LRkGFFiFeLpg1MLTT98cmEdbFwomIiNqtXzdPBHmqUV2nx/5z7JhFHbc12bRMLwAyWec+fSfbM663sXDae7YQeoNzv6k3GER81NCC/K4x4VApuuZtOJtEWA8LJyIiajdBEMz7UbhcjzpKFEXz68e0/JMcy8Du3vBQK1BarcPJi2VSx5HUltN5OFdQBQ8XBW5umCXqCmwSYT0snIiIqEOm9DHuR9l6Oo/LQ6hDzhZUIau4Giq5zLykixyLQi7DiEjjud+cebmeKIr4cOdZAMDtI3rCXa3o0vtnkwjrYOFEREQdMirSHy5KGS6W1eJUTrnUccgObWtYpjci0g9uXfxGkmzHuGjTPqcCiZNI53BmCY5mlUKlkGHB6F5dfv9sEmEdLJyIiKhDXJRyjIkKAMDletQxW0zL9NhNz6GNiTb+nTiSWYLqunqJ00jjo4bZpusGdUegR9efq0wQBNzCJhEWx8KJiIg67NLlekTtUVpdhyOZJQCASSycHFovPw26ebtCpxdxIL1Y6jhWl5pXgS2n8yEIwD1jwy32OHPYJMLiWDgREVGHTWx4w3v8QhnyymslTkP2ZOeZAugNInoHuSPMVyN1HLIgQRAw1rRc74zz7XP6uKGT3rQ+wYgIcLfY47BJhOWxcCIiog4L9HDBwIYTXG5L5nI9ajvT68XUnZEc29iG5Xp70pxrn1NOWQ3WJxn3HN03PsLij2c6pxObRFgGCyciIuqUKXFcrkftU683YEeK8Q10QhyX6TmDUZF+EATgTF6lU81Or9ibAZ1exLBwX8T38LH44w3uySYRlsTCiYiIOsV0/p3dqYWoqdNLnIbswdGsUpTV6OCtUVrlzSRJz8dNhf7dvAA4T1vyshodVjcsmXtgfKRVHpNNIiyLhRMREXVKbLAHunm7QltvwN4053hDRJ2ztaEN+cSYQMhlgsRpyFpM+5z2OElb8tUHslCprUdMkAcmxARY7XEvbRKRxCYRXUrSwmnXrl2YNWsWQkNDIQgC1q9ff9nj165diylTpiAgIACenp4YOXIkNm3aZJ2wRETULEEQzMutTG+IiS7H1L6e3fSci+n0BXvSihx+JkRbr8fne9MBAPeOi4AgWO8DgkubRKxmk4guJWnhVFVVhYEDB+K9995r0/G7du3ClClTsGHDBhw5cgQTJ07ErFmzcOzYMQsnJSKiyzEt19tyOh8Gg2O/IaLOySyqQlp+JeQyAeN6W+9TeJLeoJ7ecFXKUVipRXJuhdRxLGr9sWwUVGgR4uWCWQNDrf74bBJhGZKepnvGjBmYMWNGm49/++23G11++eWX8eOPP+Lnn39GfHx8s7fRarXQarXmy+XlxrPb63Q66HTSv5BMGWwhC7WO42VfOF7WMyjME25qOQoqtDiWWYQB3b06dD8cM/vSkfFKPJkDABjS0xsaBcfa2qT8HZMBGNbLBztTC7EjOQ9R/q5Wz2ANBoNoPuHtgpE9IIh66HQd2//Z0fEaEOqO6EA3pOZX4YfDWbhteI8OPb4zaM9zK2nh1FkGgwEVFRXw9fVt8ZhXXnkFS5cubXL95s2bodHYznkjEhMTpY5A7cDxsi8cL+uIdpMhSSvDx7/sw5U9DJ26L46ZfWnPeH13SgZAhmBDITZs2GC5UHRZUv2O+eoEAHL8uD8ZoeWnJMlgaX8UCzhXKIerXIR38Sls2ND5n7Mj49VfIyAVcny87TR8Cv+EFVcL2pXq6uo2H2vXhdPrr7+OyspK3HjjjS0es3jxYixatMh8uby8HGFhYZg6dSo8PT2tEfOydDodEhMTMWXKFCiVSqnjUCs4XvaF42Vd2pCLSFr7JzL1XrjyypEdug+OmX1p73hVauvx5MHtAEQ8eM04RAS4WT4kNSL171h0XiXWLf8d6VUKTJ4yEWql3OoZLEkURaz45CCAMiwYHYE5U6I7dX+dGa/RNTr8umwncqoN6DZgFK5oOOceNWZajdYWdls4rV69GkuXLsWPP/6IwMCWN5eq1Wqo1eom1yuVSpv6R9nW8tDlcbzsC8fLOhL6hkC27k8k51Ygv6oe3bw7vgyHY2Zf2jpeB1IKodOLCPd3Q0yot+WDUYuk+h2L6+aNIE818sq1SMquxJiGTnuO4lBGMZLOl0GlkOGOsRFd9hx3ZLz8lcYmEWuPZmPNkYsYGsE9hc1pz/Nql+3I//e//+Huu+/GmjVrkJCQIHUcIiIC4OumwuCexnPy8GS41Bx20yNBEMzd9XanOV5bctPepusGdUegh4vEadgkoqvZXeH0zTff4I477sA333yDmTNnSh2HiIgucWl3PaJLGQwitqcYXxeTWTg5tb/O5+RY5307k1eBLafzIQjAPWPDpY4DABjc0we9g9xRqzNg/bFsqePYPUkLp8rKSiQlJSEpKQkAkJ6ejqSkJGRlGXvOL168GPPmzTMfv3r1asybNw9vvPEGhg8fjtzcXOTm5qKsrEyK+ERE9DcJDYXT/rNFqNTWS5yGbMnxC6UorKyDh1qBIb1abupEjm90lLFwOnmxHEWV2laOth8f7zoHAJjWJxgRAe4SpzESBAG3NMw6rT6Q5fDnz7I0SQunw4cPIz4+3txKfNGiRYiPj8eSJUsAADk5OeYiCgA+/vhj1NfXY+HChQgJCTF/Pfroo5LkJyKixiID3NDLT4M6vQG7zzjeMhzquG3Jxtmmcb0DoFLY3YIX6kIBHmrEBnsAAPakOcasU05ZDX5MMs7o3Dc+QuI0jc2J7w61Qobk3AoknS+VOo5dk/Qv14QJEyCKYpOvlStXAgBWrlyJHTt2mI/fsWPHZY8nIiJpCYLA5XrULO5vokuZTn7sKMv1VuzNgE4vYni4L+J7+EgdpxEvjbFJBGCcdaKO40c+RETUpUzL9ban5ENv4LIQMn4afyqnHIIATIhhZy8CxjQs19uTVmj3y8fKanTmguT+8ZESp2kem0R0DRZORETUpYb08oGniwLFVXU4llUidRyyAaZleoN6+MDPvekpQsj5DAv3hUohQ05ZLc4WVEodp1NWH8hCpbYeMUEeNvvBwOCePogONDaJ+JFNIjqMhRMREXUppVyGCTHG5VhcrkcAsI3L9OhvXJRyDGtoErLbjpfr1er0+HxvOgDg3nEREARB4kTNEwQBc4cbZ51WsUlEh7FwIiKiLpfQx7hcj+dzopo6vbkBwOQ4Fk70lzEO0JZ8/bFsFFRoEeLlglkDQ6WOc1lsEtF5LJyIiKjLje8dAIVMQGp+JTKLqqSOQxL6/WwhtPUGdPN2RUyQh9RxyIaY9jntP1eEunqDxGnaz2AQzS3I7xoTbvPdItkkovNse4SJiMguebkqMbRhGQ6X6zm3rcl/LdOz1WVMJI0+IZ7wc1Ohqk5vl/shE0/n4VxhFTxdFLi5ofmCrWOTiM5h4URERBbB5XokiuJf+5u4TI/+RiYTzCfDtbfzOYmiiA93ngUA3D6yJ9zVCokTtQ2bRHQOCyciIrKIhIY3ygfTi1FWw082ndGpnHLkltfCVSnHyAg/qeOQDTLtc7K3BhGHM0twLKsUKoUM80f1kjpOm7FJROewcCIiIovo6eeG6EB31BtE7DxTIHUckoBptmlMtD9clHKJ05AtGttQOP1xoRRl1fbzAcuHO4yzTdcN6o5ADxeJ07TPtfHd2CSig1g4ERGRxUyO43I9Z2ba3zSZbcipBSFerogKdIdBNDYSsQdn8iqwNTkfggDcMzZc6jjt5q1RYWZ/Y5OIbw6ySUR7sHAiIiKLMS3X256cD53e/rpmUccVVGhx/EIpAGAiCye6DFN3vd12ss/J1Elvet9gRAS4S5ymY0zL9X4+nsMmEe3AwomIiCwmvocPfN1UKK+tx+EM++uaRR23PSUfogj07+aFIE/7WspE1jXWjs7nlFNWgx+TjE0V7h0XIXGajjM1iajR6dkkoh1YOBERkcXIZQImxhhnG7hcz7mYu+lxtolaMTzCDwqZgKziaps/79uKvRnQ6UUMD/dFfA8fqeN0GJtEdAwLJyIisijTcr0tp/P4j7OT0NbrsTvV2BBkMtuQUyvc1QoM6mksQmy5u15Zjc584tj7x0dKnKbz2CSi/Vg4ERGRRY3tHQCVXIaMomqcLbDtT5OpaxxML0ZVnR4BHmr0C/WSOg7ZgbFRtr9cb9WBTFRq6xET5IEJMQFSx+k0NoloPxZORERkUe5qBUZEGs/hs4XL9ZzCVtMyvZhAyGSCxGnIHpjO57T3bCHqbbCRTK1OjxV7MwAY9zYJgmO8rtkkon1YOBERkcWZlutxn5PjE0URW5ON48xletRWA7p7w9NFgYraevyRXSZ1nCbWH8tGQYUWoV4uuPqKUKnjdBk2iWgfFk5ERGRxpvM5HcksQXFVncRpyJLOFlTifHENVAoZRjcsvyJqjVwmmF8vtrZcz2AQzS3I7xwTDqXccd4+C4KAW4axSURbOc7IExGRzerm7Yq4EE8YROM5nchxbWlYpjcywg9uaoXEaciejLHRtuSJp/NwrrAKni4K3NxQZDiSOYPYJKKtWDgREZFVmJfrJXO5niMztSHnMj1qr3HRxoYLR7NKUKmtlziNkSiK+HDnWQDA7SN7wt0BPwxgk4i2Y+FERERWkdCwXG/XmUJo6/USpyFLKK2uw+HMYgAwn7+LqK3CfDXo6adBvUHE/rNFUscBABzKKMGxrFKoFDLMH9VL6jgWcwubRLQJCyciIrKK/t28EOChRqW2HgfOFUsdhyxg55kCGEQgJsgDYb4aqeOQHRpj2ueUZhvL9T5qmG26blB3BHq4SJzGcoawSUSbsHAiIiKrkMkEdtdzcOY25FymRx00tmGf066GEyhL6UxeBbYm50MQjC3IHRmbRLQNCyciIrKaybHG5XpbTufzH2YHU683YEeKsXBKYOFEHTQy0h8yAThXUIWLpTWSZjF10pveNxjh/m6SZrEGNoloHQsnIiKymtFR/lArZMgurUFyboXUcagLHcksQXltPXw0SlwR5iN1HLJTXq5KDAzzBiBtd72cshr8mGRcsubos00mbBLROhZORERkNa4quXkpDpfrOZatDW3mJ8YEQi4TJE5D9mxswz6n3RLuc/p8Tzp0ehHDw30R38N5Pghgk4jLY+FERERWZToZrul8P+QYTIUw9zdRZ43tbWxLvjetEAaD9Zf0ltXosPqAccbl/vGRVn98KbFJxOWxcCIiIquaHGt8Y510vhT5FbUSp6GukFlUjbMFVVDIBIxtOBcPUUddEeYNd7UCxVV1OJVTbvXHX3UgE1V1esQEeWBCjHO9ntkk4vJYOBERkVUFerpgYHcvAMD2ZM46OYLtZ4wd0Ib28oWXq1LiNGTvlHIZRkT4AgB2W3mfU61OjxV7MwAA942PgCA437LTOYO6QcUmEc1i4URERFbH5XqOZXuKsXCazGV61EVM53PabeW25OuPZaOgQotQLxfMGhhq1ce2Fd4aFa5ik4hmsXAiIiKrM73B3p1agFqdXuI01Bm19cChjBIAwKRYFk7UNUz7nA5nlKCmzjp/I/QG0dyC/M4x4VDKnfdtMptENM95XxFERCSZPiGeCPVyQa3OgN/PStc5izovuUyATi8iwt8NEQHuUschBxHh74ZQLxfU6Q04mFFslcdMPJWHc4VV8HRR4OaGfT7Oik0imsfCiYiIrE4QBC7XcxAnS4x7QDjbRF1JEASMaTh1wR4rLNcTRREf7jwLALh9ZE+4qxUWf0xbxiYRzWPhREREkjAt19t6Oo//KNspvUHEKVPhxP1N1MVMHRqt0SDiUEYJks6XQqWQYcGocIs/nj1gk4imWDgREZEkRkb6wU0lR165Fn9mW7/lMHXeH9llqKwX4K5WYGgvX6njkIMZHeUPQQCScyssfuqCjxpmm64f3B0BHmqLPpa9YJOIplg4ERGRJNQKufkT5S0NJ08l+1BTp8f54mqsT7oIABgX7efUG+nJMnzdVOgb6gnAeDJcSzmTV4GtyfkQBOCesREWexx7xCYRjTn3Ak4iIpLU5LhAbDyZiy2n8/D4lN5Sx3FaoiiiUluPwso6FFVqUVipRUFlHQorjP9v/Koz/rdCi6q/dTmb6GQnCSXrGRMVgD+zy7H7TCGuje9ukcf4aKexk970vsEI93ezyGPYqyE9fRAV6I60/Er8eCwbt4/sJXUkSbFwIiIiyUyKDYQgACcvliOnrAb+Gv6z1FVEUURZja5J0WP+/78VR9p6Q7vuX6WQwd9NBR9ZNab24f4msoxx0f74cOdZ7EkrhCiKXX5C2pyyGvyYZOwad+84zjb9nSAImDusB57/5RRWHcjCbSN6OuVJgU34LxQREUnGz12NQT18cCSzBFtO5+Pmwc55wsm20htElFSbiqA6FFVpUfC3YujS7+n07Wu6oVHJ4e+uhr+7yvhfDzX83dUIaLjsZ/qehxoeagXq6+uxYcMGaFR8O0GWMbiXD1yUMuRXaHEmrxIxwR5dev+f70lHvUHE8HBfxPfw6dL7dhRzBnXDfzYmm5tEOPPzxL90REQkqYS4IBzJLMHW03lOWTjp9AYUV9U1FEDaRsvlTAWRqTgqrtLC0M4GhB4uCgS4qxsKoYaCyPxlLIL83YzfYwFEtkatkGNYuB92nSnA7tSCLi2cymp0WH3A2PTg/vGRXXa/jsbUJGLtsWx8czCLhRMREZFUEuIC8erGZPx+tghV2nqp43SJer0BRQ3FkPnr0mLokr1DJdXt33Dto1H+Vfx4/DVDFPC34sjXTQUXpdwCPyGR9YyL9m8onApxdxc2b1h1IBNVdXrEBHlgAvfpXdYtw3tg7bFs/Hw8B/93VR94uiiljiQJFk5ERCSpqEB39PDVIKu4GnvPFkkdp0WiKKK8ph4FlbXI/1tBdGmBVFipRVFVHdpzaiqZAPi6GQugAA914+VylxRHAQ3FkIId7MiJmE6EeyC9CNp6PdSKzn8YUKvT4/M9GQCA+8ZHOPW+nbZgkwgjFk5ERCQpQRCQEBeEz/emY1tKAcZZ+RQqtTp9swVQc5fr2tFAQSbAOAvkob6kGPp7cWS87KNRQSbjGzei5sQEeSDAQ42CCi2OZJZgVKR/p+9z3bFsFFZqEerlglkDnW+JcHuxSYQRCyciIpJcQlwgPt+bju0pBRjTv/P3pzeI5n1DzRdEf80aVdS2b3mgp4vCXAwFeLgg4JLiKMBDjcCG//poVJCzGCLqNEEQMCbKH+uOZWN3amGnCye9QcQnu4wtyO8cE85zkLXRpU0ijl8owxVh3lJHsjoWTkREJLmh4b7wcFGguEqHzMrmjzGda+hyM0L55cb/FlW2r4mCSiFrUgBdejnwklkj7hkisr6x0cbCaU9qIZ6e3rn7SjyVh3OFVfB0UeDmYT26JqAT8NaoMLN/CNYdy8bqA5ksnIiIiKSglMswISYQPx+/iK3ZMojbz6K4uh75FbWNiqRaXduXygkC4OemarRcrmlB5IIADzU8XRROueyEyF6MiTLOMv15sQzFVXXwdVN16H5EUcSHO88CAG4f2RPuar4Vbo+5w3tgnRM3ieCrhYiIbEJCnLFwOlEiw4ltZ1s8zl2taFIANTdDxCYKRI4j0NMFMUEeSMmrwN60wg7vSzqUUYKk86VQKWRYMCq8i1M6PmdvEsHCiYiIbMK0vsG4Nj4UZzIuoG9EGIK8XBsVRIEeLjzXEJETGxvtj5S8CuxJ7XjhZJptun5wdwR4WLkTjQNw9iYRkn4Ut2vXLsyaNQuhoaEQBAHr169v9TY7duzAoEGDoFarERUVhZUrV1o8JxERWZ6LUo5lc/rh3lgDXprdF09MjcG8kb0wo38IhvTyRQ8/DYsmIidmaku+J60QYnv6/TdIya3AtuR8CAJwTxeeD8rZzBnUDSqFzNwkwplIWjhVVVVh4MCBeO+999p0fHp6OmbOnImJEyciKSkJjz32GO6++25s2rTJwkmJiIiISErDw/2gksuQXVqD9MKqdt/+44ZOetP7BiPc362r4zkNU5MIAFh9IFPiNNYl6Ud3M2bMwIwZM9p8/Icffojw8HC88cYbAIC4uDjs2bMHb731FqZNm2apmEREREQkMVeVHIN7+mDfuSLsTi1ERIB7m2+bU1aDH5OyAQD3juNsU2c5a5MIu1rzsG/fPiQkJDS6btq0aXjsscdavI1Wq4VWqzVfLi8vBwDodDrodDqL5GwPUwZbyEKt43jZF46X/eGY2ReOl/2x9zEbHemLfeeKsOtMPuYO7dbm23266yzqDSKG9fJBvxB3u/n5bXW8Boa6IzLADWcLqrD2cBZuHW6/bd3b89zaVeGUm5uLoKCgRtcFBQWhvLwcNTU1cHV1bXKbV155BUuXLm1y/ebNm6HRaCyWtb0SExOljkDtwPGyLxwv+8Mxsy8cL/tjt2NWCQAK7EnNx8+/bEBbGmdW1wNfH5EDEBDvUogNGzZYOGTXs8XxGuAm4GyBHB9vOw3vwj9hrz0iqqur23ysXRVOHbF48WIsWrTIfLm8vBxhYWGYOnUqPD09JUxmpNPpkJiYiClTpkCpdI5pTnvG8bIvHC/7wzGzLxwv+2PvY2YwiPjs7A6UVOsQ0n8khvT0afU2H+48B60hDb0D3fHE3JF21QXOlsdrVLUOv762ExerDeg+cDQGdveSOlKHmFajtYVdFU7BwcHIy8trdF1eXh48PT2bnW0CALVaDbW6abtJpVJpUy9AW8tDl8fxsi8cL/vDMbMvHC/7Y89jNjrKH7/8kYN96aUYGRV42WNrdXp8sf88AOD+CZFQqTp24lyp2eJ4BXgpMbN/CNYdy8aaI9kYEu4vdaQOac/zaldnBhw5ciS2bt3a6LrExESMHDlSokREREREZE1jTW3JUwtaPXbdsWwUVmoR6uXS4XM/UctuGWbc2/Tz8RyU19rWPixLkLRwqqysRFJSEpKSkgAY240nJSUhKysLgHGZ3bx588zH33///Th37hz+8Y9/IDk5Ge+//z7WrFmDxx9/XIr4RERERGRlY6IDAADHL5ShrKblN+t6g4hPGlqQ3zkmHMq2bIiidhnaywdRge6o0enxY9JFqeNYnKSvoMOHDyM+Ph7x8fEAgEWLFiE+Ph5LliwBAOTk5JiLKAAIDw/Hr7/+isTERAwcOBBvvPEGPv30U7YiJyIiInIS3bxdEeHvBr1BxL6zRS0el3gqD+cKq+DlqjTPjFDXEgTB/NyuPpDVoRMT2xNJ9zhNmDDhsk/wypUrm73NsWPHLJiKiIiIiGzZ2Gh/nCuswp60AkzvF9zk+6Io4sOdZwEAt4/oCTe1XW3rtyvXDeqGVzcm43ROOY5fKMMVYd5SR7IYzlkSERERkV0xLdfbk1rY7PcPphcj6XwpVAoZ5o/qZcVkzsdbo8LM/iEAgNUHMiVOY1ksnIiIiIjIroyI8IVcJiCjqBrni5ueh+ejhr1N1w/ujgCPpt2VqWs5S5MIFk5EREREZFc8XJQY1MMbALD7b7NOKbkV2JacD0EA7hkbIUE65+MsTSJYOBERERGR3RkT1bBcL61xW/KPG2abpvcNRri/m9VzOSNnaRLBwomIiIiI7M6YhvM57U0rgt5gfKOeU1aDH5OyAQD3j4+ULJszum5QN6gUMnOTCEfEwomIiIiI7M7A7l7wcFGgrEaHE9nGN+qf7U5HvUHEiAhfDHTg7m62yBmaRLBwIiIiIiK7o5DLMCrSDwCwJ7UAZdU6fHPQeP7P+zjbJAlHbxLBwomIiIiI7JKpLfnu1EJ8fSATVXV6xAR5YELvAImTOSdHbxLBwomIiIiI7NLYKOM+p6NZJVixNx0AcN/4CAiCIGUsp+XoTSJYOBERERGRXerpp0GYryt0ehGFlXUI9XLBrIGhUsdyao7cJIKFExERERHZJUEQzG3JAeCusRFQyvn2VkqXNon45kCWxGm6Fl9ZRERERGS3xjW0JfdyVeLmoWESpyHgryYRPx2/6FBNIlg4EREREZHdmto3GIum9Mb7tw6Cm1ohdRyC4zaJYOFERERERHZLLhPwyORojG5oFEHSc9QmESyciIiIiIioSzlikwgWTkRERERE1KUcsUkECyciIiIiIupyjtYkgoUTERERERF1OUdrEsHCiYiIiIiIupyjNYlg4URERERERBYxJ95xmkSwcCIiIiIiIovwcVPhyn7BAOy/SQQLJyIiIiIispi5w3sCsP8mESyciIiIiIjIYhylSQQLJyIiIiIishhHaRLBwomIiIiIiCzKEZpEsHAiIiIiIiKLcoQmESyciIiIiIjI4uy9SQQLJyIiIiIisrihvXwQGeBmt00iWDgREREREZHF2XuTCBZORERERERkFdcN6m63TSIUUgcgIiIiIiLn4OOmwlX9Q1BcXQe5IEgdp11YOBERERERkdW8dsNAyGX2VTQBXKpHRERERERWZI9FE8DCiYiIiIiIqFUsnIiIiIiIiFrBwomIiIiIiKgVLJyIiIiIiIhawcKJiIiIiIioFSyciIiIiIiIWsHCiYiIiIiIqBUsnIiIiIiIiFrBwomIiIiIiKgVLJyIiIiIiIhawcKJiIiIiIioFSyciIiIiIiIWsHCiYiIiIiIqBUsnIiIiIiIiFrBwomIiIiIiKgVLJyIiIiIiIhawcKJiIiIiIioFQqpA1ibKIoAgPLycomTGOl0OlRXV6O8vBxKpVLqONQKjpd94XjZH46ZfeF42R+OmX3heFmeqSYw1QiX43SFU0VFBQAgLCxM4iRERERERGQLKioq4OXlddljBLEt5ZUDMRgMuHjxIjw8PCAIgtRxUF5ejrCwMJw/fx6enp5Sx6FWcLzsC8fL/nDM7AvHy/5wzOwLx8vyRFFERUUFQkNDIZNdfheT0804yWQydO/eXeoYTXh6evIXwo5wvOwLx8v+cMzsC8fL/nDM7AvHy7Jam2kyYXMIIiIiIiKiVrBwIiIiIiIiagULJ4mp1Wr8+9//hlqtljoKtQHHy75wvOwPx8y+cLzsD8fMvnC8bIvTNYcgIiIiIiJqL844ERERERERtYKFExERERERUStYOBEREREREbWChRMREREREVErWDhJ6L333kOvXr3g4uKC4cOH4+DBg1JHoha88sorGDp0KDw8PBAYGIjZs2cjJSVF6ljURv/5z38gCAIee+wxqaNQC7Kzs3HbbbfBz88Prq6u6N+/Pw4fPix1LGqBXq/Hs88+i/DwcLi6uiIyMhIvvPAC2G/KNuzatQuzZs1CaGgoBEHA+vXrG31fFEUsWbIEISEhcHV1RUJCAlJTU6UJSwAuP2Y6nQ5PP/00+vfvDzc3N4SGhmLevHm4ePGidIGdFAsniXz77bdYtGgR/v3vf+Po0aMYOHAgpk2bhvz8fKmjUTN27tyJhQsXYv/+/UhMTIROp8PUqVNRVVUldTRqxaFDh/DRRx9hwIABUkehFpSUlGD06NFQKpX47bffcOrUKbzxxhvw8fGROhq14NVXX8UHH3yA5cuX4/Tp03j11VexbNn/t3fnQVVcaRvAH7h42cGArKMsMQiCiCzCoDUShREc1wrqhbkKcYmlwQjiEhMljqVi4sQFjMaSzIALCJJIVDQYREIUiRAQlEWIgmISURhHHCWIw32/P/zsstkuJDFtxvdXdavo0+f0eXpB+3j6tpuxY8cOqaMxAA8ePICbmxt27tzZ5frNmzcjPj4eu3fvxvnz56Gvr4/AwEC0trb+xknZEz2ds5aWFpSUlCAmJgYlJSU4fPgwqqurMWXKFAmSvtj4deQS8fHxwciRI/HRRx8BAFQqFQYNGoS33noLq1atkjgdU6exsRHm5ubIy8vDmDFjpI7DunH//n14eHhg165d2LBhA0aMGIHt27dLHYt1sGrVKuTn5+PMmTNSR2G9NGnSJFhYWOAf//iHUBYcHAxdXV0cOHBAwmSsIw0NDWRkZGDatGkAHs82WVtbY9myZVi+fDkAoLm5GRYWFkhKSkJISIiEaRnQ+Zx1paioCN7e3rh+/TpsbGx+u3AvOJ5xkkBbWxuKi4sREBAglGlqaiIgIAAFBQUSJmO91dzcDAAwMTGROAnrSUREBCZOnCj6XWPPn6NHj8LLywszZsyAubk53N3dkZCQIHUs1oNRo0YhJycHNTU1AICysjKcPXsWEyZMkDgZU6eurg4NDQ2iPxeNjY3h4+PD9yC/I83NzdDQ0ED//v2ljvJC0ZI6wIuoqakJ7e3tsLCwEJVbWFjg8uXLEqVivaVSqRAVFYXRo0dj2LBhUsdh3UhNTUVJSQmKioqkjsLUqK2txccff4zo6Gi8++67KCoqwpIlSyCXyxEeHi51PNaFVatW4d69e3BycoJMJkN7ezs2btwIpVIpdTSmRkNDAwB0eQ/yZB17vrW2tuLtt99GaGgojIyMpI7zQuGBE2N9FBERgfLycpw9e1bqKKwbN27cQGRkJLKzs6GjoyN1HKaGSqWCl5cXYmNjAQDu7u4oLy/H7t27eeD0nDp06BCSk5ORkpICFxcXlJaWIioqCtbW1nzOGHuGHj16hJkzZ4KI8PHHH0sd54XDj+pJYMCAAZDJZLh165ao/NatW7C0tJQoFeuNxYsXIzMzE7m5uRg4cKDUcVg3iouLcfv2bXh4eEBLSwtaWlrIy8tDfHw8tLS00N7eLnVE9hQrKys4OzuLyoYOHYr6+nqJEjF1VqxYgVWrViEkJASurq6YPXs2li5dik2bNkkdjanx5D6D70F+f54Mmq5fv47s7GyebZIAD5wkIJfL4enpiZycHKFMpVIhJycHvr6+EiZj3SEiLF68GBkZGTh9+jTs7e2ljsR64O/vj0uXLqG0tFT4eHl5QalUorS0FDKZTOqI7CmjR4/u9Hr/mpoa2NraSpSIqdPS0gJNTfEthEwmg0qlkigR6y17e3tYWlqK7kHu3buH8+fP8z3Ic+zJoOm7777DqVOnYGpqKnWkFxI/qieR6OhohIeHw8vLC97e3ti+fTsePHiAOXPmSB2NdSEiIgIpKSk4cuQIDA0NhefAjY2NoaurK3E61pGhoWGn75/p6+vD1NSUv5f2HFq6dClGjRqF2NhYzJw5E4WFhdizZw/27NkjdTTWjcmTJ2Pjxo2wsbGBi4sLLly4gK1bt2Lu3LlSR2N4/EbRK1euCMt1dXUoLS2FiYkJbGxsEBUVhQ0bNsDBwQH29vaIiYmBtbV1j29xY89WT+fMysoK06dPR0lJCTIzM9He3i7ch5iYmEAul0sV+8VDTDI7duwgGxsbksvl5O3tTd98843UkVg3AHT5SUxMlDoa6yU/Pz+KjIyUOgbrxrFjx2jYsGGkra1NTk5OtGfPHqkjsR7cu3ePIiMjycbGhnR0dOjll1+m1atX08OHD6WOxogoNze3y7+zwsPDiYhIpVJRTEwMWVhYkLa2Nvn7+1N1dbW0oV9wPZ2zurq6bu9DcnNzpY7+QuH/x4kxxhhjjDHG1ODvODHGGGOMMcaYGjxwYowxxhhjjDE1eODEGGOMMcYYY2rwwIkxxhhjjDHG1OCBE2OMMcYYY4ypwQMnxhhjjDHGGFODB06MMcYYY4wxpgYPnBhjjDHGGGNMDR44McbY74SdnR22b9/+m/Q1e/ZsxMbG/iZ9MfWSkpLQv3//PrV59dVXERUV1WMdDQ0NfP755z8718/1c/anL9ra2mBnZ4dvv/32mfXBGHvx8MCJMcY6eP311zFt2jRhuTc3oL+m7m4qi4qKsGDBgmfef1lZGU6cOIElS5Y8876ehbKyMoSGhmLQoEHQ1dXF0KFDERcX16neV199BQ8PD2hra+OVV15BUlJSpzo7d+6EnZ0ddHR04OPjg8LCQtH61tZWREREwNTUFAYGBggODsatW7d+9X1SKBSoqanpU5vDhw9j/fr1v3qWjv72t79hxIgRz7yfvpDL5Vi+fDnefvttqaMwxv6H8MCJMcZ+I21tbb+ovZmZGfT09H6lNN3bsWMHZsyYAQMDg2feV09+7vEqLi6Gubk5Dhw4gIqKCqxevRrvvPMOPvroI6FOXV0dJk6ciLFjx6K0tBRRUVGYP38+Tp48KdRJS0tDdHQ01q5di5KSEri5uSEwMBC3b98W6ixduhTHjh1Deno68vLy8OOPP+K11177+TvdDV1dXZibm/epjYmJCQwNDX/1LL8XSqUSZ8+eRUVFhdRRGGP/K4gxxphIeHg4TZ06VfgZgOhTV1dHRESXLl2ioKAg0tfXJ3Nzc5o1axY1NjYK2/Hz86OIiAiKjIwkU1NTevXVV4mIaMuWLTRs2DDS09OjgQMH0qJFi+g///kPERHl5uZ26m/t2rVERGRra0vbtm0Ttn/9+nWaMmUK6evrk6GhIc2YMYMaGhqE9WvXriU3Nzfat28f2drakpGRESkUCrp37163+/7f//6XjI2NKTMzU1Te2tpKy5YtI2tra9LT0yNvb2/Kzc0lIqLm5mbS0dGhEydOiNocPnyYDAwM6MGDB0REVF9fTzNmzCBjY2N66aWXaMqUKcKxfPq4b9iwgaysrMjOzo7WrVtHLi4unXK6ubnRmjVrut2Pjt58800aO3assLxy5cpO21UoFBQYGCgse3t7U0REhLDc3t5O1tbWtGnTJiIiunv3LvXr14/S09OFOlVVVQSACgoKus1ia2tL69evp9mzZ5O+vj7Z2NjQkSNH6Pbt28L5dHV1paKiIqFNYmIiGRsbC8u9Obd+fn4UGRnZ43EBQLt27aKgoCDS0dEhe3t70f48OVYODg6kq6tL9vb2tGbNGmpraxNydbxeExMTiYjo3//+Ny1YsIDMzc1JW1ubXFxc6NixY6L9ycrKIicnJ9LX16fAwED68ccfRX0nJCSQk5MTaWtrk6OjI+3cuVNY9/DhQ4qIiCBLS0vS1tYmGxsbio2NFbUfO3Zsn64TxhjrCc84McZYD+Li4uDr64s33ngDN2/exM2bNzFo0CDcvXsX48aNg7u7O7799ltkZWXh1q1bmDlzpqj93r17IZfLkZ+fj927dwMANDU1ER8fj4qKCuzduxenT5/GypUrAQCjRo3C9u3bYWRkJPS3fPnyTrlUKhWmTp2KO3fuIC8vD9nZ2aitrYVCoRDVu3r1Kj7//HNkZmYiMzMTeXl5eP/997vd34sXL6K5uRleXl6i8sWLF6OgoACpqam4ePEiZsyYgaCgIHz33XcwMjLCpEmTkJKSImqTnJyMadOmQU9PD48ePUJgYCAMDQ1x5swZ5Ofnw8DAAEFBQaKZpZycHFRXVyM7OxuZmZmYO3cuqqqqUFRUJNS5cOECLl68iDlz5vR06kSam5thYmIiLBcUFCAgIEBUJzAwEAUFBQAez3YVFxeL6mhqaiIgIECoU1xcjEePHonqODk5wcbGRqjTnW3btmH06NG4cOECJk6ciNmzZyMsLAyzZs1CSUkJBg8ejLCwMBBRt9vo67ntTkxMDIKDg1FWVgalUomQkBBUVVUJ6w0NDZGUlITKykrExcUhISEB27ZtA/D4EcJly5bBxcVFuF4VCgVUKhUmTJiA/Px8HDhwAJWVlXj//fchk8mE7ba0tODDDz/E/v378fXXX6O+vl50rScnJ+O9997Dxo0bUVVVhdjYWMTExGDv3r0AgPj4eBw9ehSHDh1CdXU1kpOTYWdnJ9o3b29vnDlzps/HhDHGuiT1yI0xxp43T884EXX9L/fr16+n8ePHi8pu3LhBAKi6ulpo5+7urra/9PR0MjU1FZY7zi488fSM05dffkkymYzq6+uF9RUVFQSACgsLiejxrISenp5oFmLFihXk4+PTbZaMjAySyWSkUqmEsuvXr5NMJqMffvhBVNff35/eeecdod3Ts0tPZqG++OILIiLav38/OTo6irb78OFD0tXVpZMnTxLR4+NuYWFBDx8+FPUzYcIEWrRokbD81ltvCbN3vZGfn09aWlpCP0REDg4OnWYnjh8/TgCopaWFfvjhBwJA586dE9VZsWIFeXt7ExFRcnIyyeXyTv2NHDmSVq5c2W0eW1tbmjVrlrB88+ZNAkAxMTFCWUFBAQGgmzdvElHXM07qzm1vZ5wWLlwoKvPx8REd747+/ve/k6enpyiLm5ubqM7JkydJU1NT+F3o6MlM1ZUrV4SynTt3koWFhbA8ePBgSklJEbVbv349+fr6EtHj62DcuHGia6qjuLg4srOz63Y9Y4z1Bc84McbYz1BWVobc3FwYGBgIHycnJwCPZwKe8PT07NT21KlT8Pf3xx/+8AcYGhpi9uzZ+Ne//oWWlpZe919VVYVBgwZh0KBBQpmzszP69+8vmi2ws7MTfc/FyspK9B2djn766Sdoa2tDQ0NDKLt06RLa29sxZMgQ0f7m5eUJ+/qXv/wF/fr1w9GjRwEAn332GYyMjITZmLKyMly5cgWGhoZCexMTE7S2toqOl6urK+RyuSjTG2+8gYMHD6K1tRVtbW1ISUnB3Llze3WcysvLMXXqVKxduxbjx4/vVZvfwvDhw4WfLSwsADze945lPZ2rvpzb2NhY0bmrr68X1vn6+orq+vr6iq6htLQ0jB49GpaWljAwMMCaNWtE7btSWlqKgQMHYsiQId3W0dPTw+DBg7vM/+DBA1y9ehXz5s0T5d6wYYNwvbz++usoLS2Fo6MjlixZgi+//LJTH7q6un36vWKMsZ5oSR2AMcZ+j+7fv4/Jkyfjgw8+6LTOyspK+FlfX1+07tq1a5g0aRIWLVqEjRs3wsTEBGfPnsW8efPQ1tb2q7/8oV+/fqJlDQ0NqFSqbusPGDAALS0taGtrEwYw9+/fh0wmQ3FxsehRKwDCCyTkcjmmT5+OlJQUhISEICUlBQqFAlpaWsI2PD09kZyc3KlPMzMz4eeOxwsAJk+eDG1tbWRkZEAul+PRo0eYPn262n2vrKyEv78/FixYgDVr1ojWWVpadnr73a1bt2BkZARdXV3IZDLIZLIu61haWgrbaGtrw927d0VvQXy6TneePi9PBqldlfV0rvpybhcuXCh6jNTa2rrHfE8UFBRAqVRi3bp1CAwMhLGxMVJTU7Fly5Ye2+nq6qrddlf56f8fTbx//z4AICEhAT4+PqJ6T65BDw8P1NXV4YsvvsCpU6cwc+ZMBAQE4NNPPxXq3rlzR3R9McbYL8EDJ8YYU0Mul6O9vV1U5uHhgc8++wx2dnbC4KA3iouLoVKpsGXLFmhqPp70P3TokNr+Oho6dChu3LiBGzduCLNOlZWVuHv3LpydnXudp6Mnr5WurKwUfnZ3d0d7eztu376NP/3pT922VSqV+POf/4yKigqcPn0aGzZsENZ5eHggLS0N5ubmMDIy6lMmLS0thIeHIzExEXK5HCEhIWpvzCsqKjBu3DiEh4dj48aNndb7+vrixIkTorLs7Gxh9kUul8PT0xM5OTnCq+lVKhVycnKwePFiAI9nE/v164ecnBwEBwcDAKqrq1FfX99pFkdqJiYmou94Pe2bb75BWFiYaNnd3R0AcO7cOdja2mL16tXC+uvXr4vad3W9Dh8+HN9//z1qamp6nHXqjoWFBaytrVFbWwulUtltPSMjIygUCigUCkyfPh1BQUG4c+eOsK/l5eXCvjDG2C/Fj+oxxpgadnZ2OH/+PK5du4ampiaoVCpERETgzp07CA0NRVFREa5evYqTJ09izpw5PQ56XnnlFTx69Ag7duxAbW0t9u/fL7w04un+7t+/j5ycHDQ1NXX5qFFAQABcXV2hVCpRUlKCwsJChIWFwc/Pr9OLHfrCzMwMHh4eOHv2rFA2ZMgQKJVKhIWF4fDhw6irq0NhYSE2bdqE48ePC/XGjBkDS0tLKJVK2Nvbi2YKlEolBgwYgKlTp+LMmTOoq6vDV199hSVLluD7779Xm2v+/Pk4ffo0srKy1D6mV15ejrFjx2L8+PGIjo5GQ0MDGhoa0NjYKNRZuHAhamtrsXLlSly+fBm7du3CoUOHsHTpUqFOdHQ0EhISsHfvXlRVVWHRokV48OCB8FIKY2NjzJs3D9HR0cjNzUVxcTHmzJkDX19f/PGPf1R/sJ8T6enp+Oc//4mamhqsXbsWhYWFwuDQwcEB9fX1SE1NxdWrVxEfH4+MjAxRezs7O9TV1aG0tBRNTU14+PAh/Pz8MGbMGAQHByM7O1uYGcrKyup1rnXr1mHTpk2Ij49HTU0NLl26hMTERGzduhUAsHXrVhw8eBCXL19GTU0N0tPTYWlpKZr9O3PmzHP1iCZj7PeNB06MMabG8uXLIZPJ4OzsDDMzM9TX18Pa2hr5+flob2/H+PHj4erqiqioKPTv31+YSeqKm5sbtm7dig8++ADDhg1DcnIyNm3aJKozatQoLFy4EAqFAmZmZti8eXOn7WhoaODIkSN46aWXMGbMGAQEBODll19GWlraL97f+fPnd3qkLjExEWFhYVi2bBkcHR0xbdo0FBUVwcbGRpQpNDRUeDvb0/T09PD111/DxsYGr732GoYOHYp58+ahtbW1VzNQDg4OGDVqFJycnDo9utXRp59+isbGRhw4cABWVlbCZ+TIkUIde3t7HD9+HNnZ2XBzc8OWLVvwySefIDAwUKijUCjw4Ycf4r333sOIESNQWlqKrKws4ftHwOO3402aNAnBwcHCwPHw4cNq9+d5sm7dOqSmpmL48OHYt28fDh48KMxaTpkyBUuXLsXixYsxYsQInDt3DjExMaL2wcHBCAoKwtixY2FmZoaDBw8CePw9t5EjRyI0NBTOzs5YuXKl2pnUp82fPx+ffPIJEhMT4erqCj8/PyQlJcHe3h7A47f9bd68GV5eXhg5ciSuXbuGEydOCL9/BQUFaG5u7tVjnYwx1hsaRD2865QxxtgL56effoKjoyPS0tKem0fOiAgODg548803ER0dLXUc9jugUCjg5uaGd999V+oojLH/EfwdJ8YYYyK6urrYt28fmpqapI4CAGhsbERqaioaGhr69H83sRdXW1sbXF1dRY9eMsbYL8UzTowxxp5rGhoaGDBgAOLi4vDXv/5V6jiMMcZeUDzjxBhj7LnG/77HGGPsecAvh2CMMcYYY4wxNXjgxBhjjDHGGGNq8MCJMcYYY4wxxtTggRNjjDHGGGOMqcEDJ8YYY4wxxhhTgwdOjDHGGGOMMaYGD5wYY4wxxhhjTA0eODHGGGOMMcaYGv8HfLp/urk6WrkAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(losses, label='Training Loss')\n",
        "plt.xlabel('Iteration (every 2000 mini-batches)')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training Loss Over Iterations')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1BlocxS1t6qi"
      },
      "source": [
        "Let's quickly save our trained model:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MWtwOiEYt6qi"
      },
      "outputs": [],
      "source": [
        "PATH = './cifar_net.pth'\n",
        "print(net.state_dict())\n",
        "torch.save(net.state_dict(), PATH)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqSo4Y-lt6qi"
      },
      "source": [
        "### 5. Test the network on the test data\n",
        "\n",
        "**We have trained the network for 2 passes over the training dataset.\n",
        "But we need to check if the network has learnt anything at all.**\n",
        "\n",
        "Generally, we will use the val/test datasets to evaluation the trained model.\n",
        "\n",
        "Again, show some of the testing images!\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g7_gI2zLt6qi"
      },
      "outputs": [],
      "source": [
        "dataiter = iter(testloader)\n",
        "images, labels = next(dataiter)\n",
        "\n",
        "# print images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h1GpdiECt6qi"
      },
      "source": [
        "Load our saved model\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NAFbPaQ8t6qi"
      },
      "outputs": [],
      "source": [
        "net = Net()\n",
        "net.load_state_dict(torch.load(PATH))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6PxK6JRt6qi"
      },
      "source": [
        "Let us see what the neural network thinks these examples above are:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oYgBTMpPt6qj"
      },
      "outputs": [],
      "source": [
        "outputs = net(images)\n",
        "# print(outputs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yDbZxu-ut6qj"
      },
      "source": [
        "The outputs are energies for the 10 classes.\n",
        "The higher the energy for a class, the more the network\n",
        "thinks that the image is of the particular class.\n",
        "So, let's get the index of the highest energy:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gK7oJVy4t6qj"
      },
      "outputs": [],
      "source": [
        "_, predicted = torch.max(outputs, 1)\n",
        "\n",
        "print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'\n",
        "                              for j in range(4)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CqF9F4M0t6qj"
      },
      "source": [
        "How the network performs on the whole testing dataset?\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ckGFasHit6qj"
      },
      "outputs": [],
      "source": [
        "correct = 0\n",
        "total = 0\n",
        "# since we're not training, we don't need to calculate the gradients for our outputs\n",
        "with torch.no_grad():\n",
        "    for data in testloader:\n",
        "        images, labels = data\n",
        "        # calculate outputs by running images through the network\n",
        "        outputs = net(images)\n",
        "        # the class with the highest energy is what we choose as prediction\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S31zUKPKt6qj"
      },
      "source": [
        "How the network performs on the whole testing dataset to each class?\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BMnamSCZt6qj"
      },
      "outputs": [],
      "source": [
        "# prepare to count predictions for each class\n",
        "correct_pred = {classname: 0 for classname in classes}\n",
        "total_pred = {classname: 0 for classname in classes}\n",
        "\n",
        "# again no gradients needed\n",
        "with torch.no_grad():\n",
        "    for data in testloader:\n",
        "        images, labels = data\n",
        "        outputs = net(images)\n",
        "        _, predictions = torch.max(outputs, 1)\n",
        "        # collect the correct predictions for each class\n",
        "        for label, prediction in zip(labels, predictions):\n",
        "            if label == prediction:\n",
        "                correct_pred[classes[label]] += 1\n",
        "            total_pred[classes[label]] += 1\n",
        "\n",
        "\n",
        "# print accuracy for each class\n",
        "for classname, correct_count in correct_pred.items():\n",
        "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
        "    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v9azFLBVt6qj"
      },
      "source": [
        "\n",
        "\n",
        "## Training on GPU\n",
        "How to transfer a Tensor and the neural\n",
        "net onto the GPU.\n",
        "\n",
        "Let's first define our device as the first visible cuda device if we have\n",
        "CUDA available:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hgU0tAYMt6qj"
      },
      "outputs": [],
      "source": [
        "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Assuming that we are on a CUDA machine, this should print a CUDA device:\n",
        "\n",
        "print(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fq9YK2-qt6qj"
      },
      "source": [
        "The rest of this section assumes that ``device`` is a CUDA device.\n",
        "\n",
        "Then these methods will recursively go over all modules and convert their\n",
        "parameters and buffers to CUDA tensors:\n",
        "\n",
        "    net.to(device)\n",
        "\n",
        "\n",
        "Remember that you will have to send the inputs and targets at every step\n",
        "to the GPU too:\n",
        "\n",
        "    inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ONQyo0pNt6qk"
      },
      "outputs": [],
      "source": [
        "del dataiter"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "dp3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.21"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}