Tutorial5_(FCN).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMAWRqeLdyQRKHlNbDB+AAW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Mrezakhodashenas/PhD-NN/blob/main/Tutorial5_(FCN).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "6IpELtBIep7Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9cb1c3cd-4dab-4022-810a-b1ec7603001e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: snntorch in /usr/local/lib/python3.8/dist-packages (0.5.3)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.8/dist-packages (from snntorch) (1.3.5)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (from snntorch) (3.2.2)\n",
            "Requirement already satisfied: torch>=1.1.0 in /usr/local/lib/python3.8/dist-packages (from snntorch) (1.13.0+cu116)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.8/dist-packages (from snntorch) (1.21.6)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch>=1.1.0->snntorch) (4.4.0)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib->snntorch) (0.11.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->snntorch) (1.4.4)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->snntorch) (3.0.9)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib->snntorch) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas->snntorch) (2022.7)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib->snntorch) (1.15.0)\n"
          ]
        }
      ],
      "source": [
        "# 1. Learning how spiking neurons are implemented as a recurrent network\n",
        "# 2. Understanding backpropagation through time, and the associated challenges in SNNs such as the non-differentiability of spikes\n",
        "# 3. Training a fully-connected network on the static MNIST dataset\n",
        "\n",
        "!pip install snntorch"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# imports\n",
        "import snntorch as snn\n",
        "from snntorch import spikeplot as splt\n",
        "from snntorch import spikegen\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import itertools"
      ],
      "metadata": {
        "id": "_3To8ZAFfCAG"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Leaky neuron model, overriding the backward pass with a custom function\n",
        "class LeakySurrogate(nn.Module):\n",
        "  def __init__(self, beta, threshold=1.0):\n",
        "      super(LeakySurrogate, self).__init__()\n",
        "\n",
        "      # initialize decay rate beta and threshold\n",
        "      self.beta = beta\n",
        "      self.threshold = threshold\n",
        "      self.spike_op = self.SpikeOperator.apply\n",
        "  \n",
        "  # the forward function is called each time we call Leaky\n",
        "  def forward(self, input_, mem):\n",
        "    spk = self.spike_op((mem-self.threshold))  # call the Heaviside function\n",
        "    reset = (spk * self.threshold).detach() # removes spike_op gradient from reset\n",
        "    mem = self.beta * mem + input_ - reset # Eq (1)\n",
        "    return spk, mem\n",
        "\n",
        "  # Forward pass: Heaviside function\n",
        "  # Backward pass: Override Dirac Delta with the Spike itself\n",
        "  @staticmethod\n",
        "\n",
        "\n",
        "  class SpikeOperator(torch.autograd.Function):\n",
        "      @staticmethod\n",
        "      def forward(ctx, mem):\n",
        "          spk = (mem > 0).float() # Heaviside on the forward pass: Eq(2)\n",
        "          ctx.save_for_backward(spk)  # store the spike for use in the backward pass\n",
        "          return spk\n",
        "\n",
        "      @staticmethod\n",
        "      def backward(ctx, grad_output):\n",
        "          (spk,) = ctx.saved_tensors  # retrieve the spike \n",
        "          grad = grad_output * spk # scale the gradient by the spike: 1/0\n",
        "          return grad\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# ------------------------------------------------------------- Lapicque -----------------------\n",
        "\n",
        "# # Lapicque neuron model, overriding the backward pass with a custom function\n",
        "# class Lapicque(nn.Module):\n",
        "#   def __init__(self, beta, R=5.1, C=5e-3, time_step=1e-3, threshold=0.5):\n",
        "#       super(Lapicque, self).__init__()\n",
        "\n",
        "#       # initialize decay rate beta and threshold and R, C, time_step\n",
        "#       self.beta = beta\n",
        "#       self.R = R \n",
        "#       self.C = C\n",
        "#       self.time_step = time_step     \n",
        "#       self.threshold = threshold\n",
        "#       self.spike_op = self.SpikeOperator.apply\n",
        "  \n",
        "#   # the forward function is called each time we call Leaky\n",
        "#   def forward(self, input_, mem):\n",
        "#     spk = self.spike_op((mem-self.threshold))  # call the Heaviside function\n",
        "#     reset = (spk * self.threshold).detach() # removes spike_op gradient from reset\n",
        "#     mem = self.beta * mem + ((2*(self.time_step/(self.R*self.C)))*input_*self.R) - reset\n",
        "#     return spk, mem\n",
        "\n",
        "#   # Forward pass: Heaviside function\n",
        "#   # Backward pass: Override Dirac Delta with the Spike itself\n",
        "#   @staticmethod\n",
        "\n",
        "\n",
        "#   class SpikeOperator(torch.autograd.Function):\n",
        "#       @staticmethod\n",
        "#       def forward(ctx, mem):\n",
        "#           spk = (mem > 0).float() # Heaviside on the forward pass: Eq(2)\n",
        "#           ctx.save_for_backward(spk)  # store the spike for use in the backward pass\n",
        "#           return spk\n",
        "\n",
        "#       @staticmethod\n",
        "#       def backward(ctx, grad_output):\n",
        "#           (spk,) = ctx.saved_tensors  # retrieve the spike \n",
        "#           grad = grad_output * spk # scale the gradient by the spike: 1/0\n",
        "#           return grad\n"
      ],
      "metadata": {
        "id": "aMIBRZA5fCcW"
      },
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lif1 = snn.Leaky(beta=0.9)\n",
        "# lif1 = snn.Lapicque(R=5.1, C=5e-3, time_step=1e-3, threshold=0.5)"
      ],
      "metadata": {
        "id": "Lgte-94BhGpB"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# dataloader arguments\n",
        "batch_size = 128\n",
        "data_path='/data/mnist'\n",
        "\n",
        "dtype = torch.float\n",
        "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")"
      ],
      "metadata": {
        "id": "3GAt9ODAj6yB"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a transform\n",
        "transform = transforms.Compose([\n",
        "            transforms.Resize((28, 28)),\n",
        "            transforms.Grayscale(),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize((0,), (1,))])\n",
        "\n",
        "mnist_train = datasets.MNIST(data_path, train=True, download=True, transform=transform)\n",
        "mnist_test = datasets.MNIST(data_path, train=False, download=True, transform=transform)"
      ],
      "metadata": {
        "id": "SLoO8ctIj7xT"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create DataLoaders\n",
        "train_loader = DataLoader(mnist_train, batch_size=batch_size, shuffle=True, drop_last=True)\n",
        "test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=True, drop_last=True)"
      ],
      "metadata": {
        "id": "SBou9MMzj-NN"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#                   /////////////////////// Network Architecture\n",
        "num_inputs = 28*28\n",
        "num_hidden = 1000\n",
        "num_outputs = 10\n",
        "\n",
        "# Temporal Dynamics\n",
        "num_steps = 25\n",
        "beta = 0.95\n",
        "# R=1\n",
        "# C=5e-3\n",
        "# time_step=1e-3\n",
        "# threshold=0.5"
      ],
      "metadata": {
        "id": "X5pxKaZRkDgU"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ///////////////////////////////// / ////  Define Network\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "        # ------------------ Initialize layers\n",
        "\n",
        "        self.fc1 = nn.Linear(num_inputs, num_hidden)\n",
        "        self.lif1 = snn.Leaky(beta=beta)\n",
        "        self.fc2 = nn.Linear(num_hidden, num_outputs)\n",
        "        self.lif2 = snn.Leaky(beta=beta)\n",
        "        # ----------\n",
        "        # self.fc1 = nn.Linear(num_inputs, num_hidden)\n",
        "        # self.lif1 = snn.Lapicque(R=R, C=C, time_step=time_step, threshold=threshold)\n",
        "        # self.fc2 = nn.Linear(num_hidden, num_outputs)\n",
        "        # self.lif2 = snn.Lapicque(R=R, C=C, time_step=time_step, threshold=threshold)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "\n",
        "        # -------Initialize hidden states at t=0\n",
        "        mem1 = self.lif1.init_leaky()\n",
        "        mem2 = self.lif2.init_leaky()\n",
        "        # mem1 = self.lif1.init_Lapicque()\n",
        "        # mem2 = self.lif2.init_Lapicque()\n",
        "\n",
        "\n",
        "        # Record the final layer\n",
        "        spk2_rec = []\n",
        "        mem2_rec = []\n",
        "\n",
        "        for step in range(num_steps):\n",
        "            cur1 = self.fc1(x)\n",
        "            spk1, mem1 = self.lif1(cur1, mem1)\n",
        "            cur2 = self.fc2(spk1)\n",
        "            spk2, mem2 = self.lif2(cur2, mem2)\n",
        "            spk2_rec.append(spk2)\n",
        "            mem2_rec.append(mem2)\n",
        "\n",
        "        return torch.stack(spk2_rec, dim=0), torch.stack(mem2_rec, dim=0)\n",
        "        \n",
        "# Load the network onto CUDA if available\n",
        "net = Net().to(device)"
      ],
      "metadata": {
        "id": "r_SWICQEkMx6"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#----------------------------------------  Training the SNN -------------------------------------\n",
        "# ------------ 7.1 Accuracy Metric\n",
        "# Below is a function that takes a batch of data, counts up all the spikes from each neuron (i.e., a rate code over the simulation time), \n",
        "#  and compares the index of the highest count with the actual target. If they match, then the network correctly predicted the target.\n",
        "\n",
        "# pass data into the network, sum the spikes over time\n",
        "# and compare the neuron with the highest number of spikes\n",
        "# with the target\n",
        "\n",
        "def print_batch_accuracy(data, targets, train=False):\n",
        "    output, _ = net(data.view(batch_size, -1))\n",
        "    _, idx = output.sum(dim=0).max(1)\n",
        "    acc = np.mean((targets == idx).detach().cpu().numpy())\n",
        "\n",
        "    if train:\n",
        "        print(f\"Train set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
        "    else:\n",
        "        print(f\"Test set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
        "\n",
        "def train_printer(\n",
        "    data, targets, epoch,\n",
        "    counter, iter_counter,\n",
        "        loss_hist, test_loss_hist, test_data, test_targets):\n",
        "    print(f\"Epoch {epoch}, Iteration {iter_counter}\")\n",
        "    print(f\"Train Set Loss: {loss_hist[counter]:.2f}\")\n",
        "    print(f\"Test Set Loss: {test_loss_hist[counter]:.2f}\")\n",
        "    print_batch_accuracy(data, targets, train=True)\n",
        "    print_batch_accuracy(test_data, test_targets, train=False)\n",
        "    print(\"\\n\")"
      ],
      "metadata": {
        "id": "BIFaqzOQlDFd"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.2 Loss Definition\n",
        "# The nn.CrossEntropyLoss function in PyTorch automatically handles taking the softmax of the output layer as well as generating a loss at the output.\n",
        "loss = nn.CrossEntropyLoss()"
      ],
      "metadata": {
        "id": "YgIdNC9xlxSU"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.3 Optimizer\n",
        "# Adam is a robust optimizer that performs well on recurrent networks, so let's use that with a learning rate of 5×10−4\n",
        "optimizer = torch.optim.Adam(net.parameters(), lr=5e-4, betas=(0.9, 0.999))"
      ],
      "metadata": {
        "id": "-TetxV9JmnLz"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.4 One Iteration of Training\n",
        "\n",
        "# Take the first batch of data and load it onto CUDA if available.\n",
        "data, targets = next(iter(train_loader))\n",
        "data = data.to(device)\n",
        "targets = targets.to(device)\n",
        "\n",
        "\n",
        "# Flatten the input data to a vector of size 784 and pass it into the network.\n",
        "spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
        "print(mem_rec.size())\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-s-L8VhBm6A8",
        "outputId": "5ce58894-be6d-45e6-b406-195e71ad0759"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([25, 128, 10])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The recording of the membrane potential is taken across:\n",
        "# 25 time steps\n",
        "# 128 samples of data\n",
        "# 10 output neurons\n",
        "# We wish to calculate the loss at every time step, and sum these up together, as per Equation (10):\n",
        "\n",
        "# initialize the total loss value\n",
        "loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
        "\n",
        "# sum loss at every step\n",
        "for step in range(num_steps):\n",
        "  loss_val += loss(mem_rec[step], targets)\n",
        "\n",
        "print(f\"Training loss: {loss_val.item():.3f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aXq7Bxo7nBBF",
        "outputId": "a7f9721a-4e29-4cd8-d7e4-425b7223635b"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training loss: 61.397\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print_batch_accuracy(data, targets, train=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UjbxzdYqpvr7",
        "outputId": "7daa739e-9a39-4d10-d86e-4ea184f3696b"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train set accuracy for a single minibatch: 5.47%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# A single weight update is applied to the network as follows:\n",
        "\n",
        "# clear previously stored gradients\n",
        "optimizer.zero_grad()\n",
        "\n",
        "# calculate the gradients\n",
        "loss_val.backward()\n",
        "\n",
        "# weight update\n",
        "optimizer.step()"
      ],
      "metadata": {
        "id": "d_ffVPNWp2YB"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# calculate new network outputs using the same data\n",
        "spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
        "\n",
        "# initialize the total loss value\n",
        "loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
        "\n",
        "# sum loss at every step\n",
        "for step in range(num_steps):\n",
        "  loss_val += loss(mem_rec[step], targets)\n",
        "\n",
        "print(f\"Training loss: {loss_val.item():.3f}\")\n",
        "print_batch_accuracy(data, targets, train=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "snhD04Hnp9ZC",
        "outputId": "39c5e7ce-e85c-4dfd-edea-0cafdd53b9bd"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training loss: 49.003\n",
            "Train set accuracy for a single minibatch: 29.69%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num_epochs = 1\n",
        "loss_hist = []\n",
        "test_loss_hist = []\n",
        "counter = 0\n",
        "\n",
        "# Outer training loop\n",
        "for epoch in range(num_epochs):\n",
        "    iter_counter = 0\n",
        "    train_batch = iter(train_loader)\n",
        "\n",
        "    # Minibatch training loop\n",
        "    for data, targets in train_batch:\n",
        "        data = data.to(device)\n",
        "        targets = targets.to(device)\n",
        "\n",
        "        # forward pass\n",
        "        net.train()\n",
        "        spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
        "\n",
        "        # initialize the loss & sum over time\n",
        "        loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
        "        for step in range(num_steps):\n",
        "            loss_val += loss(mem_rec[step], targets)\n",
        "\n",
        "        # Gradient calculation + weight update\n",
        "        optimizer.zero_grad()\n",
        "        loss_val.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # Store loss history for future plotting\n",
        "        loss_hist.append(loss_val.item())\n",
        "\n",
        "        # Test set\n",
        "        with torch.no_grad():\n",
        "            net.eval()\n",
        "            test_data, test_targets = next(iter(test_loader))\n",
        "            test_data = test_data.to(device)\n",
        "            test_targets = test_targets.to(device)\n",
        "\n",
        "            # Test set forward pass\n",
        "            test_spk, test_mem = net(test_data.view(batch_size, -1))\n",
        "\n",
        "            # Test set loss\n",
        "            test_loss = torch.zeros((1), dtype=dtype, device=device)\n",
        "            for step in range(num_steps):\n",
        "                test_loss += loss(test_mem[step], test_targets)\n",
        "            test_loss_hist.append(test_loss.item())\n",
        "\n",
        "            # Print train/test loss/accuracy\n",
        "            if counter % 50 == 0:\n",
        "                train_printer(\n",
        "                    data, targets, epoch,\n",
        "                    counter, iter_counter,\n",
        "                    loss_hist, test_loss_hist,\n",
        "                    test_data, test_targets)\n",
        "            counter += 1\n",
        "            iter_counter +=1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C7mumg7BqPLq",
        "outputId": "b8dba20a-1ec4-4ef1-d974-e62a8d32252b"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Iteration 0\n",
            "Train Set Loss: 53.77\n",
            "Test Set Loss: 48.08\n",
            "Train set accuracy for a single minibatch: 43.75%\n",
            "Test set accuracy for a single minibatch: 40.62%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 50\n",
            "Train Set Loss: 20.80\n",
            "Test Set Loss: 18.26\n",
            "Train set accuracy for a single minibatch: 85.94%\n",
            "Test set accuracy for a single minibatch: 87.50%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 100\n",
            "Train Set Loss: 11.01\n",
            "Test Set Loss: 16.14\n",
            "Train set accuracy for a single minibatch: 89.84%\n",
            "Test set accuracy for a single minibatch: 85.94%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 150\n",
            "Train Set Loss: 14.95\n",
            "Test Set Loss: 6.52\n",
            "Train set accuracy for a single minibatch: 90.62%\n",
            "Test set accuracy for a single minibatch: 90.62%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 200\n",
            "Train Set Loss: 6.89\n",
            "Test Set Loss: 8.17\n",
            "Train set accuracy for a single minibatch: 95.31%\n",
            "Test set accuracy for a single minibatch: 90.62%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 250\n",
            "Train Set Loss: 8.31\n",
            "Test Set Loss: 11.23\n",
            "Train set accuracy for a single minibatch: 96.09%\n",
            "Test set accuracy for a single minibatch: 88.28%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 300\n",
            "Train Set Loss: 13.37\n",
            "Test Set Loss: 8.00\n",
            "Train set accuracy for a single minibatch: 89.84%\n",
            "Test set accuracy for a single minibatch: 92.97%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 350\n",
            "Train Set Loss: 7.67\n",
            "Test Set Loss: 4.82\n",
            "Train set accuracy for a single minibatch: 95.31%\n",
            "Test set accuracy for a single minibatch: 96.09%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 400\n",
            "Train Set Loss: 6.69\n",
            "Test Set Loss: 7.18\n",
            "Train set accuracy for a single minibatch: 91.41%\n",
            "Test set accuracy for a single minibatch: 92.97%\n",
            "\n",
            "\n",
            "Epoch 0, Iteration 450\n",
            "Train Set Loss: 5.92\n",
            "Test Set Loss: 5.31\n",
            "Train set accuracy for a single minibatch: 95.31%\n",
            "Test set accuracy for a single minibatch: 97.66%\n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot Loss\n",
        "fig = plt.figure(facecolor=\"w\", figsize=(10, 5))\n",
        "plt.plot(loss_hist)\n",
        "plt.plot(test_loss_hist)\n",
        "plt.title(\"Loss Curves\")\n",
        "plt.legend([\"Train Loss\", \"Test Loss\"])\n",
        "plt.xlabel(\"Iteration\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        },
        "id": "InxrPnEkqljs",
        "outputId": "373071c1-3357-465a-ef07-c7a386dae0b6"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAFNCAYAAADRi2EuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxU9b3/8deZPXtCwh4FcQURUVHqLlq9raVavdaq1WJrr91u1S4uvdpq++tCN6/W9pZra5VSey21ivtWUSuKIiqgIAjIFggh+zL7cn5/nDkzk30CmUwI7+fj4SPJZJZvFnPefD6f8z2GaZomIiIiIpJzjnwvQERERORAoeAlIiIiMkQUvERERESGiIKXiIiIyBBR8BIREREZIgpeIiIiIkNEwUtERERkiCh4iciQmjx5Mv/85z/z8torVqzg/PPPp7y8nFGjRnHSSSdx//3352UtInJgUvASkQPC8uXLOfvssznzzDPZtGkTjY2N/P73v+eZZ57Zq+eLx+ODvEIRORAoeInIsBAOh7nhhhuYMGECEyZM4IYbbiAcDgPQ0NDA3LlzU5Wq008/nUQiAcDPf/5zJk6cSElJCUceeSQvvvhij89/4403Mm/ePG6++WaqqqowDIMTTjiBxYsXA/DAAw9w2mmndXqMYRhs2rQJgKuvvpqvfe1rnH/++RQVFfGrX/2KcePGdQpgjz76KDNmzAAgkUgwf/58Dj30UCorK7n00ktpamoCIBQKceWVV1JZWUl5eTknnngidXV1g/jdFJHhSsFLRIaFn/zkJ7zxxhusWrWK1atXs2LFCn784x8D8Otf/5rq6mrq6+upq6vjpz/9KYZhsGHDBn7729/y1ltv0d7eznPPPcfkyZO7PXcgEGD58uVccskl+7TGv/71r9x66620t7dz/fXXU1RUxNKlSzt9/oorrgDgnnvuYcmSJbzyyivs2rWLiooKvvGNbwCwcOFCWltb2bFjB42NjSxYsICCgoJ9WpuI7B8UvERkWHjwwQf5wQ9+wJgxYxg9ejS33347ixYtAsDtdlNbW8u2bdtwu92cfvrpGIaB0+kkHA6zbt06otEokydP5tBDD+323M3NzSQSCcaPH79Pa7zwwgs59dRTcTgc+Hw+Lr/8cv7v//4PgPb2dp5++mkuv/xyABYsWMBPfvITqqur8Xq93HHHHTz88MPEYjHcbjeNjY1s2rQJp9PJCSecQGlp6T6tTUT2DwpeIjIs7Nq1i0mTJqU+njRpErt27QKsNuFhhx3Geeedx5QpU5g/fz4Ahx12GHfddRd33HEHY8aM4bLLLks9JlNFRQUOh4Pa2tp9WuNBBx3U6eMrrriCRx55hHA4zCOPPMLxxx+f+hq2bdvGRRddRHl5OeXl5UydOhWn00ldXR1XXXUV//Zv/8Zll13GhAkTuOmmm4hGo/u0NhHZPyh4iciwMGHCBLZt25b6ePv27UyYMAGAkpISfv3rX/PRRx/x+OOPc+edd6Zmua644gqWLVvGtm3bMAyDm2++udtzFxYWcvLJJ/OPf/yj19cvKioiEAikPt69e3e3+xiG0enjadOmMWnSJJ555plObUawQtozzzxDS0tL6r9QKMTEiRNxu93cfvvtrFu3jtdff50nn3ySP//5z1l+p0Rkf6bgJSJDLhqNEgqFUv/FYjEuv/xyfvzjH1NfX09DQwM/+tGPuPLKKwF48skn2bRpE6ZpUlZWhtPpxOFwsGHDBpYuXUo4HMbn81FQUIDD0fOftV/84hc88MAD/PKXv6SxsRGA1atXc9lllwFw7LHHsnbtWlatWkUoFOKOO+7I6mu54ooruPvuu/nXv/7FZz/72dTtX/3qV7n11ltTYbK+vp7HHnsMgJdeeon33nuPeDxOaWkpbre713WLyMii/9NFZMidf/75FBQUpP674447uO2225g1axYzZszgmGOO4fjjj+e2224DYOPGjXz84x+nuLiYk08+ma9//evMmTOHcDjMLbfcQlVVFePGjWPPnj387Gc/6/E1TznlFJYuXcrSpUuZMmUKo0aN4tprr+X8888H4IgjjuAHP/gBH//4xzn88MO7neHYm8svv5xXXnmFs88+m6qqqtTt119/PRdccAHnnXceJSUlfOxjH+PNN98ErGraJZdcQmlpKVOnTuXMM8/kqquu2pdvqYjsJwzTNM18L0JERETkQKCKl4iIiMgQUfASERERGSIKXiIiIiJDRMFLREREZIgoeImIiIgMEVe+F5CNqqqqHq+/JiIiIjLcbN26lYaGhh4/t18Er8mTJ7Ny5cp8L0NERESkX7Nmzer1c2o1ioiIiAwRBS8RERGRIaLgJSIiIjJE9osZLxEREdl30WiUmpoaQqFQvpcyIvh8Pqqrq3G73Vk/RsFLRETkAFFTU0NJSQmTJ0/GMIx8L2e/ZpomjY2N1NTUcMghh2T9OLUaRUREDhChUIjKykqFrkFgGAaVlZUDrh4qeImIiBxAFLoGz958LxW8REREZEg0NjYyc+ZMZs6cybhx45g4cWLq40gk0udjV65cyXXXXTeg15s8eXKvG5nmi2a8REREZEhUVlayatUqAO644w6Ki4v57ne/m/p8LBbD5eo5msyaNavPjUn3F6p4AW9va+bvK3fkexkiIiIHnKuvvpqvfvWrzJ49m5tuuokVK1Zw8sknc9xxx3HKKaewYcMGAF5++WXmzp0LWKHtS1/6EmeddRZTpkzhN7/5Tdavt3XrVs4++2xmzJjBOeecw/bt2wH4+9//zvTp0zn22GM544wzAFi7di0nnXQSM2fOZMaMGWzcuHGfv15VvICn1tSyeOUOPjvroHwvRURE5IBTU1PD66+/jtPppK2tjVdffRWXy8U///lP/uu//ot//OMf3R6zfv16XnrpJdrb2znyyCP52te+ltW2Dt/85jeZN28e8+bN409/+hPXXXcdS5Ys4Uc/+hHPPfccEydOpKWlBYAFCxZw/fXX8/nPf55IJEI8Ht/nr1XBCyj0OAlEYpimqaFDERE5IPzwibWs29U2qM85bUIpt3/66AE/7rOf/SxOpxOA1tZW5s2bx8aNGzEMg2g02uNjPvWpT+H1evF6vYwZM4a6ujqqq6v7fa3ly5fzyCOPAHDVVVdx0003AXDqqady9dVXc+mll3LxxRcDcPLJJ/OTn/yEmpoaLr74Yg4//PABf21dqdUIFHicJEwIxxL5XoqIiMgBp6ioKPX+97//febMmcP777/PE0880et2DV6vN/W+0+kkFovt0xoWLFjAj3/8Y3bs2MEJJ5xAY2MjV1xxBY8//jgFBQWcf/75LF26dJ9eA1TxAqyKF0AgEsfnduZ5NSIiIrm3N5WpodDa2srEiRMBeOCBBwb9+U855RQeeughrrrqKh588EFOP/10ADZv3szs2bOZPXs2zzzzDDt27KC1tZUpU6Zw3XXXsX37dtasWcPZZ5+9T6+viheZwWvf0rKIiIjsm5tuuonvfe97HHfccftcxQKYMWMG1dXVVFdX8+1vf5t77rmH+++/nxkzZrBo0SLuvvtuAG688UaOOeYYpk+fzimnnMKxxx7L4sWLmT59OjNnzuT999/nC1/4wj6vxzBN09znZ8mxWbNmsXLlypw9/+Ord3Hd/73LC986g8PHluTsdURERPLpgw8+YOrUqflexojS0/e0r9yiihdQlNFqFBEREckVBS+s4XpQ8BIREZHcUvACCj3WOQbBqGa8REREJHcUvOh8VqOIiIhIrih4AQVuBS8RERHJPQUv0hWvoIKXiIiI5JA2UCU946WKl4iISO40NjZyzjnnALB7926cTiejR48GYMWKFXg8nj4f//LLL+PxeDjllFO6fe6BBx5g5cqV/Pa3vx38hQ8iBS/A53ZgGNpAVUREJJcqKytZtWoVAHfccQfFxcV897vfzfrxL7/8MsXFxT0Gr/2FWo2AYRgUup2qeImIiAyxt99+mzPPPJMTTjiBf/u3f6O2thaA3/zmN0ybNo0ZM2Zw2WWXsXXrVhYsWMB///d/M3PmTF599dWsnv/OO+9k+vTpTJ8+nbvuugsAv9/Ppz71KY499limT5/O3/72NwBuueWW1GsOJBAORE4rXpMnT6akpASn04nL5WLlypU0NTXxuc99jq1btzJ58mQWL15MRUVFLpeRlQKPS8FLRERkCJmmyTe/+U0ee+wxRo8ezd/+9jduvfVW/vSnPzF//ny2bNmC1+ulpaWF8vJyvvrVrw6oSvb2229z//338+abb2KaJrNnz+bMM8/ko48+YsKECTz11FOAdX3IxsZGHn30UdavX49hGLS0tOTka855q/Gll16iqqoq9fH8+fM555xzuOWWW5g/fz7z58/n5z//ea6X0a9Cj5OgWo0iInKgeOYW2P3e4D7nuGPgk/Ozvns4HOb999/n3HPPBSAejzN+/HjAusbi5z//eT7zmc/wmc98Zq+Ws2zZMi666CKKiooAuPjii3n11Vf5xCc+wXe+8x1uvvlm5s6dy+mnn04sFsPn83HNNdcwd+5c5s6du1ev2Z8hbzU+9thjzJs3D4B58+axZMmSoV5Cjwo9ajWKiIgMJdM0Ofroo1m1ahWrVq3ivffe4/nnnwfgqaee4hvf+AbvvPMOJ5544qBcMNt2xBFH8M4773DMMcdw22238aMf/QiXy8WKFSu45JJLePLJJ/nEJz4xaK+XKacVL8MwOO+88zAMg6985Stce+211NXVpdLsuHHjqKury+USslbgcRKMKniJiMgBYgCVqVzxer3U19ezfPlyTj75ZKLRKB9++CFTp05lx44dzJkzh9NOO42HHnqIjo4OSkpKaGtry/r5Tz/9dK6++mpuueUWTNPk0UcfZdGiRezatYtRo0Zx5ZVXUl5ezh//+Ec6OjoIBAKcf/75nHrqqUyZMiUnX3NOg9eyZcuYOHEie/bs4dxzz+Woo47q9HnDMDAMo8fH3nvvvdx7770A1NfX53KZgCpeIiIiQ83hcPDwww9z3XXX0draSiwW44YbbuCII47gyiuvpLW1FdM0ue666ygvL+fTn/40l1xyCY899hj33HMPp59+eqfne+CBBzp10t544w2uvvpqTjrpJAC+/OUvc9xxx/Hcc89x44034nA4cLvd/P73v6e9vZ0LL7yQUCiEaZrceeedOfmaDdM0zZw8cxf2aaN/+MMfePnllxk/fjy1tbWcddZZbNiwoc/Hzpo1i5UrV+Z0fV9euJKdLUGeuf70/u8sIiKyH/rggw+YOnVqvpcxovT0Pe0rt+Rsxsvv99Pe3p56//nnn2f69OlccMEFLFy4EICFCxdy4YUX5moJA1Lk1XC9iIiI5FbOWo11dXVcdNFFAMRiMa644go+8YlPcOKJJ3LppZdy3333MWnSJBYvXpyrJQxIoceJX61GERERyaGcBa8pU6awevXqbrdXVlby4osv5upl91qB26VrNYqIiEhOaef6JGu4PsYQjbyJiIjkhY5zg2dvvpcKXkmFXicJE8KxRL6XIiIikhM+n4/GxkaFr0FgmiaNjY34fL4BPU4XyU4qclsZNBCJ43M787waERGRwVddXU1NTc2QbNN0IPD5fFRXVw/oMQpeAM9+j8ve/iu38z/4wzFGFXnyvSIREZFB53a7OeSQQ/K9jAOaWo0ALi/uWAdg4teWEiIiIpIjCl4A3hIcZgwvUfxhBS8RERHJDQUvAG8pAMUE8Ye1pYSIiIjkhoIXgLcEgGIjqIqXiIiI5IyCF4CnGIBiQtq9XkRERHJGwQvSFS9U8RIREZHcUfCCjFZjQGc1ioiISM4oeEFquL7UEVLFS0RERHJGwQvAa814VbjCOqtRREREckbBC1KtxlHOMAG1GkVERCRHFLwA3IVgOCh3hlTxEhERkZzRtRoBDAO8JZQR1nC9iIiI5IwqXjZvKSXaQFVERERySMHL5immxFCrUURERHJHwcvmLaEY7eMlIiIiuaPgZfOWUKCLZIuIiEgOKXjZvCUUJAKa8RIREZGcUfCyeYvxJQIEo3HiCTPfqxEREZERSMHL5i3FGw8AaBNVERERyQkFL5u3BHfcj0GCDrUbRUREJAcUvGylEzEwOcioZ09bON+rERERkRFIwcs2/lgAphtbqG0N5nkxIiIiMhIpeNnGTMV0uDnGsYVdLaF8r0ZERERGIAUvm8sLY6dxjGMru9sUvERERGTwKXhlMMYfyzGOrexqDuR7KSIiIjICKXhlGjeDMtoJN+/M90pERERkBFLwylQ6AYBY6+48L0RERERGIgWvTEWjATACDdq9XkRERAadglemoioAKsxW6tu1l5eIiIgMLgWvTMmKV6XRyvYmDdiLiIjI4FLwyuQpJuHyUWm08WFde75XIyIiIiOMglcmw8AoGs04Z7uCl4iIiAw6Ba8ujKLRHOT1s2G3gpeIiIgMLgWvropGMzZZ8TJNndkoIiIig0fBq6ui0ZQnWmkORKnv0JmNIiIiMnhyHrzi8TjHHXccc+fOBWDLli3Mnj2bww47jM997nNEIpFcL2FgiqooiDYDJpvqOvK9GhERERlBch687r77bqZOnZr6+Oabb+Zb3/oWmzZtoqKigvvuuy/XSxiYotE4EhFKCNLoH2ahUERERPZrOQ1eNTU1PPXUU3z5y18GwDRNli5dyiWXXALAvHnzWLJkSS6XMHAZe3m1BqN5XoyIiIiMJDkNXjfccAO/+MUvcDisl2lsbKS8vByXywVAdXU1O3cOswtSl44HYILRqOAlIiIigypnwevJJ59kzJgxnHDCCXv1+HvvvZdZs2Yxa9Ys6uvrB3l1fag4BIBDnXsUvERERGRQuXL1xK+99hqPP/44Tz/9NKFQiLa2Nq6//npaWlqIxWK4XC5qamqYOHFij4+/9tprufbaawGYNWtWrpbZXekEcHo43NHA2oCCl4iIiAyenFW8fvazn1FTU8PWrVt56KGHOPvss3nwwQeZM2cODz/8MAALFy7kwgsvzNUS9o7DCeWTOMShipeIiIgMriHfx+vnP/85d955J4cddhiNjY1cc801Q72E/o06hGp2K3iJiIjIoMpZqzHTWWedxVlnnQXAlClTWLFixVC87N4bNYXxm16lNaDtJERERGTwaOf6nlQcgs8MYgQb8r0SERERGUEUvHoyyjqzsSJUk+eFiIiIyEii4NWT8kkAjIrWEYsn8rwYERERGSkUvHpSVg3ARKOBtlAsz4sRERGRkULBqyfeYiLuMiYYDTqzUURERAaNglcvwkUTdNkgERERGVQKXr2Il0xkgtFAi7aUEBERkUGi4NWb8momquIlIiIig0jBqxe+qsmUGgEaGobwAt0iIiIyoil49cJXaW0p0V63Jc8rERERkZFCwas3ZQcBUFL/Nr96dj0rtjTleUEiIiKyv1Pw6s2Yo2hyjeWalnvY8q8HefTdnflekYiIiOznFLx64y3hL7MeJmh6mOnYxO7WYL5XJCIiIvs5Ba8+TBw9ilpzFOONJmpbQ/lejoiIiOznFLz6MKmykN3mKMYZTexuU/ASERGRfaPg1YdJlUXUYgWvlkCUYCSe7yWJiIjIfkzBqw+jS7xMO+IoxjuaMUio6iUiIiL7RMGrH1OPPAqnGaeKNmo1YC8iIiL7QMGrP6UTAKw5Lw3Yi4iIyD5Q8OpPMniNNxp1ZqOIiIjsEwWv/pROBOAQb6tajSIiIrJPFLz6U1gFTg/TClpZu6st36sRERGR/ZiCV38cDhh7NDNdW3mvppVAJJbvFYmIiMh+SsErG9UnMjHwAYlEnFXbW/K9GhEREdlPKXhlo/pEXLEARzpqWLG1Kd+rERERkf2Uglc2qmcB8Mmy7byjipeIiIjsJQWvbFQcAgWjmOXZxpaGjnyvRkRERPZTCl7ZMAwoncAYZwc7m4OEY7pmo4iIiAycgle2CiooNzpImLCjKZDv1YiIiMh+SMErWwXlFMXbAdjSoOAlIiIiA6fglS1fOd5oK4DmvERERGSvKHhlq6ACR7iVikK3Kl4iIiKyVxS8slVQAbEQR1a6VPESERGRvaLgla2CcgCmj0qwaY+Cl4iIiAycgle2CioAOLoiQUNHhPr2cJ4XJCIiIvsbBa9sJYPX4aXWRbLX1LRoWwkREREZEFe+F7Df8FmtxkmFEcDNNQtXArB1/qfyuCgRERHZn6jila1kxask0c7YUm/q5lBUu9iLiIhIdhS8spUMXoRaOGpcaermjnAsTwsSERGR/U3OglcoFOKkk07i2GOP5eijj+b2228HYMuWLcyePZvDDjuMz33uc0QikVwtYXB5S8Bwwmt3c2vFixw8qhCA9pCCl4iIiGQnZ8HL6/WydOlSVq9ezapVq3j22Wd54403uPnmm/nWt77Fpk2bqKio4L777svVEgaXYVhv/fUcseH3fP9TRwHQoeAlIiIiWcpZ8DIMg+LiYgCi0SjRaBTDMFi6dCmXXHIJAPPmzWPJkiW5WsLgM5PzXKFWxoQ+AqA9HM3jgkRERGR/ktMZr3g8zsyZMxkzZgznnnsuhx56KOXl5bhc1smU1dXV7Ny5M5dLGFyTTgNvGQCjm94F1GoUERGR7GUVvPx+P4lEAoAPP/yQxx9/nGi0/0qP0+lk1apV1NTUsGLFCtavX5/1wu69915mzZrFrFmzqK+vz/pxOTXvCbjpIygeR1m9tZ2EWo0iIiKSrayC1xlnnEEoFGLnzp2cd955LFq0iKuvvjrrFykvL2fOnDksX76clpYWYjErrNTU1DBx4sQeH3PttdeycuVKVq5cyejRo7N+rZxyOMDpgoNn46t7G9BZjSIiIpK9rIKXaZoUFhbyyCOP8PWvf52///3vrF27ts/H1NfX09LSAkAwGOSFF15g6tSpzJkzh4cffhiAhQsXcuGFF+7jl5AHY6bhaN2BlwjtIc14iYiISHay2rneNE2WL1/Ogw8+mDoLMR7ve+PQ2tpa5s2bRzweJ5FIcOmllzJ37lymTZvGZZddxm233cZxxx3HNddcs+9fxVAbdSgGJoe56mlXxUtERESylFXwuuuuu/jZz37GRRddxNFHH81HH33EnDlz+nzMjBkzePfdd7vdPmXKFFasWLF3qx0uKg8FYKpnj4brRUREJGtZBa8zzzyTM888E4BEIkFVVRW/+c1vcrqwYS0ZvA5z1rFOwUtERESylNWM1xVXXEFbWxt+v5/p06czbdo0fvnLX+Z6bcOXrwwKqzjEUafhehEREclaVsFr3bp1lJaWsmTJEj75yU+yZcsWFi1alOu1DW+Vh3GQWavhehEREclaVsHL3nl+yZIlXHDBBbjdbgz7EjoHqspDmRDfSXsoxvs7W5lxx3PsbAnme1UiIiIyjGUVvL7yla8wefJk/H4/Z5xxBtu2baO0tDTXaxveyqopjzfiD4a584UPaQvFeH1TQ75XJSIiIsNYVsHruuuuY+fOnTz99NMYhsGkSZN46aWXcr224a2gwnobbmN9bRsAsYSZxwWJiIjIcJdV8GptbeXb3/526hI+3/nOd/D7/ble2/CWDF6OcAu7WkMA1LeH87kiERERGeayCl5f+tKXKCkpYfHixSxevJjS0lK++MUv5nptw1syeJXTkbpJwUtERET6ktU+Xps3b+Yf//hH6uPbb7+dmTNn5mxR+wVfOQCXzyjlooOnseiNbQpeIiIi0qesKl4FBQUsW7Ys9fFrr71GQUFBzha1X0hWvC6bXsLVpx7C2FIf9R0KXiIiItK7rCpeCxYs4Atf+AKtra0AVFRUsHDhwpwubNizh+uDzQCMLvHy7vaWPC5IREREhrusgtexxx7L6tWraWuzzt4rLS3lrrvuYsaMGTld3LBWYLUaU8Gr2Et9exjTNLXHmYiIiPQoq1ajrbS0NLV/15133pmTBe03nG7wFEPQqnKNLvESjMbxR+J5XpiIiIgMVwMKXplMU3tWUVDRqdUIOrNRREREerfXwUvtNKwzG7sErz1toXyuSERERIaxPme8SkpKegxYpmkSDOq6hBSUQ8hqNU4ZXcxkRz3f/tsq/vIfH+OQqqI8L05ERESGmz4rXu3t7bS1tXX7r729nVgsNlRrHL7sVqNpMnH5D3nZcz2HdbzFw2/vyPfKREREZBjK6qxG6UVBBbTVwqNfhTUPAXBceZA3t2lbCREREelur2e8BKvVGG6FNX+D2V8F4Mhyk1U7WojFE3lenMjQME2THzz2Pm9va873UkREhj0Fr31hJL99Z3wXzvsJAJNL4gSjcdbvbs/jwkSGTixh8ufl23jlw/p8L0VEZNhTq3FfnPgfUDIBTvwyOBzgLqK6IArAu9ubmT6xLM8LFMm9aLK6G0+oyisi0h8Fr31RNhFmX5v+2FdKMQEKPU62Ngbyty6RIRSNW3v6xRLa209EpD9qNQ4mbylGuI2xpT7qtJ+XHCBSFa+4gpeISH8UvAaTrxRCbYwp8bKnTTvYy4HBDl6qeImI9E/BazB5SyFZ8dqtipccIKIxu9WoGS8Rkf4oeA2mZMVrXJnVatT1LOVAEE3Yw/X6fRcR6Y+C12BKVrzGlHgJxxK0BbW7v4x8qVajZrxERPql4DWYkhWvsaU+AOra1W6Ukc9uNariJSLSPwWvweQtg1iQccVOAHa3jvDgFY/BttfzvQrJs4iG60VEsqbgNZh8pQAc/uEfmGTsHvlbSrx4B9z/Sahdne+VSB7F4prxEhHJloLXYPJawav8zV9yj/se9rSP8C0lalZab8O6PNKBLL2Bqs5qFBHpj4LXYEpWvABwuEZ+xSvit966C/O7DskrDdeLiGRPwWswedPBq8k9buTPeEXtyyLpgHsg04yXiEj2FLwGU0bFq9QZpW6ktxojyeCViOd3HZJXdqVLM14iIv1T8BpM7qLUu+WOAHtGeqsxmmw1xqP5XYfkVfqSQZrxEhHpj4LXYKqYBEfNhbKDKCbAnvYwiZFcBUhVvBS8DmQRndUoIpI1Ba/B5HTDZQ/C5NMpTPiJJ0wa/ZF8ryp37MAV1w79BzJdJFtEJHsKXrngK8Mbs7ZY6OnMxkTCZNWOlqFeVe4khlfwisYTvLqxPt/LOGBoxktEJHsKXrngK8MV82OQoK4tRLM/Qm1rMPXpVzbW85nfvX8wq/0AACAASURBVMbm+o6BP3e4A+4+Nqsd42PxBA++uS21wWXODLNW40vr93DVfSvY2uDP91IOCNpOQkQkezkLXjt27GDOnDlMmzaNo48+mrvvvhuApqYmzj33XA4//HDOPfdcmpubc7WE/PGVYmBSQpC6tjDfe+Q9vvTAytSnG5JnO+7VPl8dddC8Ffas6/eu97+2lVsffZ+/rdwx8Nfpj5lxkB1mw/X+iFWB6wgPr0rcSBXRcL2ISNZyFrxcLhe//vWvWbduHW+88Qa/+93vWLduHfPnz+ecc85h48aNnHPOOcyfPz9XS8gfXxkApUaA2tYgr21u4KP6DsxkWAlErO0X2oJ7EQziyZmxWP+zYzXN1vB7ONr7AXHRG9u4+H9eG/g6IhnVpOHWakxetDmS60qfAOlKl2a8RET6l7PgNX78eI4//ngASkpKmDp1Kjt37uSxxx5j3rx5AMybN48lS5bkagn5kwxeBxfFeGnDHtpDMcKxBPXJSpddiWkL7kWlKJasksX73yOsPfk6xT5Xr/fZsLuN93a2DnwdoYzHDLPgZQeuSEzBayhEdVajiEjWhmTGa+vWrbz77rvMnj2buro6xo8fD8C4ceOoq6sbiiUMreQO9sePMXh/Z1vq5h3N1pxXINkKawsNPHh1+JNbOGRR8eoIWa9T5Ok9eIWjCaJxM3XwzFpm8BpmrUb7axnw1yR7JaIZLxGRrOU8eHV0dPDv//7v3HXXXZSWlnb6nGEYGIbR4+PuvfdeZs2axaxZs6iv38/OUEtWvK6aWY7H5cDjsr7NduvPH7Zaja0DrHi9v7OV/7g/2RbMouJlV9bMPi7pE0pWhez2Z9Y6VbyGZ/BSxWto2K1dVbxERPqX0+AVjUb593//dz7/+c9z8cUXAzB27Fhqa2sBqK2tZcyYMT0+9tprr2XlypWsXLmS0aNH53KZgy8ZvMZ6Itz1uZn88pIZANQkK17+vWw1bq7vwIs945V98OqrEhGOWoEr2F/weuuPsDajLRxOV/KG2z5e0eTXq4rX0LCH6jXjJSLSv5wFL9M0ueaaa5g6dSrf/va3U7dfcMEFLFy4EICFCxdy4YUX5moJ+ZMMXoRaOf+Y8Vw4cyJVxZ5UxcuuLg204lXkceElGXIGELz6CiDhVMWrj/C09TV46jvw93np24bzjFfyawqr4jUk0jNe+n6LiPSn9+GfffTaa6+xaNEijjnmGGbOnAnAT3/6U2655RYuvfRS7rvvPiZNmsTixYtztYT8Sc54ZYaTiRWFqYqXHYgGGrwMA7zYu8VnEbySM159VSLCMSsE9tlqfP426+2E49K37QetxqhmjoZEJNlq1IyXiEj/cha8TjvttNT2CV29+OKLuXrZ4cHpAk8xhNK701dXFLA2efZgeri+/0rRW1ub+MO/PuL3V55AOJbAYyRDTjbD9alWYzYVrz6CV9tO663Dnb4tGki/P+xajZrxGkq6ZJCISPa0c32uVBwC9etTH04bX8rWxgA7W4J0DGC4/vVNjTy/ro7mQIRwLJ6ueMX633zVDlN9VX7sPb76bDVG7S0sMsJe5vvDruKlGa+hZM94abheRKR/Cl65Uj0Lat6G5EHp0zMmAPD4ql3pilcWwSvzvuFoAk+q1dh3xSuzytXXjuJ2q7HP4fpY8nJHmdtG2O8bzvSMl2nCoovhw+f6XFuuaR+voZVqNWrGS0SkXwpeuVJ9IoRboXEjAAdXFnL8weU8tmpn6qzG1mCUjnCs15YspC9/05bchDVd8cqY8WrcDE1bOj2uJRnqDjbq+qx4haL9tBoT8XTIy5wri4XB6QGnOx3Cwu2w+UXY/kavrzcUosnApZ3rh4ZdWUyY1gXgRUSkdwpeuVI9y3pbk75G4zlTx7J+dzvNASuohGMJpt/+HM+8v7vzYxs2QZ11LcZARlsyFI3jSZ7VmMgMXk9cD0/f2OkpWgIRTnW8x7+832LK7md6XWZqxivaS/DKbGl2ajVGreDlcKcrXvbAfeb8Vx5oxmtoZbZ04338I0L2TUNHmFBv/5+KyH5DwStXKg8HbxnUvJW6qbqiALBmYaqKPanb1+7qcsmeZ26Ex78JZFS8glGr4mVY4SceCabvH2qFQGOnp2gORBmN9bxH7Hm212WmW429zHhFM4NXZqsxkqx4udK32ycTZF7HMQ/sCp8qXkMj82xGzXnlzkX/8xoLXtmc72WIyD5S8MoVhwNGHwlNm2Hn2/Dhc4wvK0h9OvP9Ep+782NbtkOHdSml1AW1Q9FOw/WxSJe2X6Sj01M0+yMksK4KUOXf1Osy+z2r0Z7vcnq6VLzCw7biZQeuqCpevevYAzve6v9+WcgMuDqhIXca2iM0dPS/jYyIDG8KXrlUVg2tNfDST+GxbzC+1Jv6VIHHmXq/PfOajaYJbbXgbwA67/llDdfbrcbMSlQYwp2DV0c4RrFh3acssrvHLR9M00y14+zh+vZQlBseepdG+w+8XfHylXXewiLVanSlz2oM2hWvYdJqVAjo3fLfwl8vHZSn6tRqVMUrZ2KJROryTCKy/1LwyqXyg6zg1bgJ/PWMdbRgX5ry7KPGMKbECmLtmft5hdsg6rcqTRF/asarLdh5uN6M9l3x8kfiFJHRjtyzttvyMnd2t1uaf16+jSWrdnH/a1uTz518Dm9p9+0kXHarsWvFa2hajXc8vpYH39zW7XZdJDsLEf+gtYSjnc6gHaRgsO11mD8pHeYPcKZp7t3F7EVk2FHwyqWyg6yA0rwVAM+e96gqtsLWoaOLWXHrx6muKEjtMA9Y1S5boDEViFqDVqux2GUFMTOz+hQLWcErY7A5EI5RZGRUxRo2dluevYcXpFuNdiujtCC5t26q4pUMXvZrxDJbjV1nvIam4vXCujpe29TQ7XZ7xqs1GOXaP69kR1N+K3DDUjza+ee5D3Iy49W4yfp98nf/+R6I7O9rVBVFkf2eglculVV3/rh2FRPKfAAUJVuNJT535x3s23el3/c3pAJRezDMQa1vU+y07mvEM0JVLAxmgm/95fXUTYFInCIy79N9w1V7sB7SrcYmvxXoyguSw/+ZFS9Ma3sJSLYa3clWY3L9dnUi2xmvRMI6I3P3e9ndv4tQNN4pPNrsqsD63e08v66Ot7c179Xzj2iJGJ1+nvsgkouKl11dHWab8+aL/X3V3KLI/k/BK5fKDsr4wIDa1amh+iKvVVEq8bk6zXj567enHxJoTO35ddqe/+ObO77Fx+JvA+CwD0immQpVy9ZuTW2cGojEKHOEUgP2RDPajkmZrcZAl+CV2hYgc8YLMvb0ioDTm9zHq0urMdsWVrAJ3n4APuz9rMu+hKLxHi+EbQev1tS2HToFv5tBDDbReAK30/o9iw/W9RpjGb9nkj5hRK1Gkf2eglcuZVa8Jp0KtWsYZ1e8vMmKl9eVGqAH+P0Ty1Lvx9vrU8HiGP9yALxYByKXaR84Y2Ba95nrXE7T0/8PsGa8Sp0RWrAu2F3T0NJtD6BuFa9AE5ftuQsvkfR97YqXL3nhb3sTVXs7iczh+tAAK152QAu19n2/XoRiiR73NbIHkO1NZHsKZwe8eHZXQMhGNG7ic1u/z4O2e30q4A+v64Dmi93OVatRZP+n4JVLBeVWi87lg4NOgo7dTEwFr8yKl3Vw2dMWYpzRRNi0tpeItNcDJj7CTIjXdHpqDzFCkVinFuIVzqWUrfkjYAWpEiNEq8OqVD30+oc88s7OTs8RypzxisZg66t8Kvw0Rxtb02HFrnh57YpXxgHb6e68c32q4pVl8LKrcHsxQB2NJ4gnzD4rXvZcTDiaoCUQ6fNi4Qccuz08CMEmGk9Q6LGD12C1GpO/UyOs1RiJJTh1/lKeW7u7/ztniGmLFJERQ8Er18qqoWIyFI2GRIyLphXzg7nTGFdqBbASnzvVanxtcwNjjWa2mOPA4SbeUc+lzpdZ7/siFWb3qtCuxpZOWzwcZOzBGbNCjz8co9gI4zeKiePAQ4Qmf+c9gOzQcr5vDT9tuQkz3A5AoRFOz051q3hltIBc3t5nvLIZ2rYrY6GBBy/HH+ZwtfPZHtuIXbeRCEXjzPzRC1z/t1UDfp0Ra1ArXgkK7IpXH61G0zR5acOe7C4rlKqsjqzg5Q/H2NkSZNOejv7vnMGudKnVKLL/U/DKtRO+CLOugaIqAKqMdr502iEYhgGmSbHPlbpe47KNjYw1mml1j4bCSuIdDZxobOj1qWsaWjtVvHxGFJcZg1iEYDROkREk5CgkghsfUfyRnluNH3NvZkZ8HaEWa9PWIkLpQNPbjFcs0n24PtUyNHucKetmbytepomj7j2OMrb3WfGy2a3cp9bUdrvvfivYvG/bQSRy02rs66zGZ9/fzRfvf4sHXt/a4+cXv7WD7y95v/O6RljFy/7dHGj7O1XxUqtRZL+n4JVrs6+1/iustD4OJE+P37MefjqBg+PbicZNapqDvLi+jgo6aEwUW/cPNBLA2n4ibLq6PXVtQ0uPZysS9eMPxygiRMhRQBgPPiKpQX2bXdUa5bKqC4Fmq/1RSCh9YOh0ViOdh567XiQ7s3KVMecVjSesql7TR/Ds96yzGSEdvHqreH34PCw4vXvVIxbCMOOUGIFezmrsfHBqDY6sgzcAf7kEXrh97x+fauXtW6sxkTCJJ7Kb8bJ/Dh/UtvX4+Vc21vPCurrO6xthM152NTY8wGsu2r/TajWK7P8UvIZKsuKFv956u/F5iAYYH7Nmt77+4DsEI3FGOQM0xguhqBIj0ECpEaDBPZ5Z4QXUmeWdnrK1w29tJdFVxE8gEsdnBgk7CgmZbrxEOw3xQ7riVe6wAlCkzVpbkdFDxctbYr1NtRqj1lmNnfbxaoWCitQabD98Yi3H3PE8kXVPwRv/k94yI7nRaiLQ0nMLZfca679Ak/VxIg7P3Qr16wEoIUgoFica7zxk3/Xg1BJIB69Ab9ek3N+07oCOgc0JdTJIrcZoMmgVZFHxKi2wZhd7C8LBSDz9exDLOIljBLED1IArXgmd1SgyUih4DZVCO3glK17b3wCg1LTCx3s7W/nqGZMpMv00JgpJFFTiDDZRSoC4u5R2Cmkzi6zHuq23oVCwx4pXPNRBIBKnwAwScRQQNN34jB4qXsk//qUO6znMZCgsIpQevI8FrYDl8iWf3D5ghzNajXGrEhYNQOlE6/MZFa8nky2+dZuTW2XYB9Vkxcvf1siflm3p/j2zD7rB5D5cLdusS9289zAAxUaQcDTBD59YyzUL09cd7DrjlXmgH+hsDQCbX4Jty1MfxuIJdrVk0UrNpXBH50s4DVSq1dh3NfC/Hn2Pnz3zQa+ft4NEQRbD9S6HteVEW6jn1/SHY6lLWI30VmNPZ+P2xZ6dG7STF0QkbxS8hopd8Qo0WIPn260DeTHpgHLKRKud2GoWEfVV4g43UWIEoMCar2olGbyS1adIKNBjxSsUaCUQjuJJBIk4iwjjwUu024Ww7TZdiWE9h5Fsg1Z6op3PanT7rJAFXfbxsi8ZFE3Pd5WMt95mnNlon0iwaXvyzMxU8LLuU0KAnU09BCI7VNqtyOTwP601yccFCcfibGsMsLEu/fiuVYHM4LVhd3v31+nPC9+Hl3+W+vDRd3dy9q9fzkn1rDUQZWd/oS4Rt6qF8X24YHI8u+C1ansLa3b0vt2HXV30ua0/JX1VvOyQ1hbs+fsWiMTToXm4tBpr3oaPXh60p7OD5UArXqnrj6rVKLLfU/AaKi4veErA3wgNH1qbhwJFZrolN608ufGnWUTYU44n2kYlbbgKrRZjm1lo3TF5hmEkHOqx4hUJdmBGAzgwiToLCOHGR6TXVqMd/jxha02V7ijhaJx3tzcTiwTAVcBzG5JVp8yzzVwZrcZwcm6nZJz1NtlGNE1rfg3AGUkewO01ZwzgxwI9zHnZFZ1gl+DVZrUqi40gCRPaglGa/BFM05o36nrszwxeH9btRfAKNHW6Fuae9jChaKJTC3Ow/Or5DXzx/hV938leyz5VvOztJPp+jkg80ecGtHYgSM949R68IvHkdUd7q3hFYunQbP+e5bvi9a9fwnO3DdrT7XXFS2c1iowYCl5DqajSqnhtT7etfPH0Ab0E6/0Wigm6rVmpaqMeX7H1fhvJ4OW1g1egxwNnxN+OIzljFXEWpipevbUaC0wreBXFrIBT7AjTEojy2QXL2VLbAG4fT61ttB5kVyJi4Yx9vGK9Vrxag9Zs2eTKQsrpSD824z4AZg9nNu5osG5ra07OxYWTj08Gr5JkYGwKRIglTNqCsR4PTJnBq7FjL8JKoDH92qQvr5SLild9ezh19YBe2Wvp6cSKbGXZyovEEn1WZ+zPFXmsam1fe6XZG9u29TLjFQjHSZjJ58iyIpdz0UD6BJPBeLq9nPGyf6/VahTZ/yl4DaXCKmvGa/sb1vulEzsFL3uWqdUswu+yqlxeI4avdBRAesYrWfGK9VLxCrQ3c5CxB4Coq4hwasYrDosugld+QWsgyu5W67GeuBXSfMld8YsIUd8RJpYwCQetildTOPkH376wciKa3LneaVVPUhWvsdbbZFXGrnYdMbaEMiNZ3YuHCUXjPLvqo9SaewpetY1WmHt2pTVMn6p4tVszY8VGCAcJWvzWwbnRH061qpzJeSKgU6Wva9WvX5FA+iLkSXa1wh8e/EsR+SOxThvb9rym5Fr2ZfA8y+F6R7SDRB8b4trf72w2ULXv2+napBnsIBuNmwOb8drxlnXSRS7Ewj2fwLKX9rbipbMaRUYOBa+hVFRlVby2vQ4Hfwx8ZXhiVpj49LETUi21ForpcJalHuYsKKfA7cyY8UoGr0godVDwm97U/atW/Y5HvHcAEHcWErK3k4jEYPNSeOknfPfh1fxx2RYMA1zRzvNVhYRo6LCeNx4JYLp9NNn5Lh5JH7SdnoxWYzIU2RWv5PyWHbyOHFdCGVbw+u3za1m9o4Vd9U3przHcfY7Ia1ivs7O2lnW72njirQ+tT5jpg1YxQdqTYarJH0kdmOyLkGcqcDu7zbn1K9kSzqx4hWJ28Br8ilcgEu//oBzuUjncG6lWY9/B5uXolTzg/1qvn4/EOrca+5rxypxP6rqJqmmaqZ9NJJ7IOKsxi+C14SnrpIt9ab32JhYc1OAV2cd9vLqeOCIy3CQSZuof9dIzBa+hVFgFu9+3zs6bdAr4ynCHmlh/8M/578PfT1W82swiWpPXWATAV0axz5We8UoO10cjIbbvsYJBk1lKIvnjLGnbmHpozFVEGDeeLq3GLXusoGOYCRzRzhtxViSaWZS4henGR5jREAmnD388GWTi0fT8TeY+XqEuM14RO3hZb48YW0JpsuL1/vY9vLqxAR/pA5oj0j14JaLW58sMP//z8ibe+2hHt/vc7l7Idc5HAGj0RzBr13CP+zeUebrdlcpiz8ArXoFkizXSntqNPxixDn5dN6QdDIFInFjC7PvyRpFkyB2C4XqAsWZjr5+LDqDildkGbunSbozEE6nHRmIDbDXas4KRvThjtT+DXfGK7VvFS61GGe6eXbubM37xEq05mIEdKRS8hlJRJZD8w5mseFG3Ft+e1bie/E/Y+ipgnb3YbHQOXiVeF212xSu5i3wiFuIfb24GoJESQgVju71kzFVIyPTgMyKdDmLFbZusJdH9XyYHRzYx0/ERsx0fYMSCRA0v0eQGrvFoqIeKV0arsbjzcH1Nc5Aij5MJZb5UxavKaOXMNTdRbTQQSl6X0hPtYVPN5AGvwhHg2fd3U2R0X+tFjte40Pma9T3oiOD66J982vkGh7obut23stg78CqVvYeYmUgd4HNb8bKes8+KiF1dHJTtJPp4jiwuXm5XsezgFe9jA9XM4NXY0TnMBDLattF4YmDD9faeceG9OHGiP7Ge2/l7a1/38YonTBIJk/nPrOdrf3l70NaVU9leu1VGhD1tISLxxMjcuHqQKHgNpWmfgamfho99A8bPtFqGkYyDxbrHMN3WJX6aEsXp231lFHkzKl7J4GXEIoSC1kHnD7G57DzuO912uI96SgljbaBakBGyjoxbVbFiug8OO7EOgmONFjxmBH/CRRTreUOhUPpg7cqc8Up+HUWjASP1x3ZnS5DqikJKnBE8hvW8Jzg+5ET/y5ziWMtu05pf80bbMbtc39FIHnwneEPEEiYlPazVYZgcbOzBRYwmfxgjuRfZJGf3Kk1VkWfgYSmYbofaB3h713GzdQf88Vxo34eNTLuw222haNyqIr7/SPc72a3GbCpeiQQ8/k3Y8mrn2+1tGvrYuT7R+FGvn7PZwasgNVyfXauxvmvwinYNXva2JVn8vHJd8YqHs7v2aDZPl9i3fbzA2rR2TU3L3m2NMtRqVsL8g1NbwMjIF05tmTL4HYGRQsFrKE08Hj73F/jET63A4kvPcVF2kPU2eVtHlE4zXcVeV7d9vLxGFKdp/aviucQsjJmXEUxeYujNxFG8/+mnaC08JDXjVZjR2ptpJCteRu9nbI0zmvASoTniJJIMXomat9NhoFOrsRVcBVYY8xSxYu2H/O8rm6lpDlJdUUBxIn2QsM9udBkJmikhbLoppT09VN6yHXa+g5E8+I5xW4FxvK/nf0G5jTgHG3to9EdSwWui0Tl4FRCiqsi5F63GzOBlfQ32Oitrl0HNCtj22sCes6+XS64vFEvAfefCw1+kZtP7ne8UGcCM14an4J0/d9qHDOi8H1svYg2bU++be9bDxn92u0843rXi1ddwffpzXc8uDWT8XDq1GrOpeNnBKzxIwaujPn3FBrvaNUg76O/rPl7W+ybNgeiAn2OgXlhXx99XZrT3w+3w5r0DC6FNW6yfYfJMZBn5whm/46Zp8sBrW1T96kLBK598Ge3EI88HwPAU4XE6aOiI0JBIfj5Z8dplVmJiQPkkADzE8BpR4qZBDCejirz4sTYrrTfLMMYfg9tppCpehUb6QD3ZqOP2T0/jF3Mn97q8sUYzPiNCY9iRCl4lHzwEz33PuoPTQ1sEMOME2pvSX8+Uszih6Uma3llCTXOAjxtvMvr5b6Set8JIHyADppc9ZjmjjRbaw8n/OV/+OTz8JRwJ62BX4bAqTUeOSp+p2NUUo5YmfwRHchPY8UZmq9HkZe+3OafjKQKReLfKWl/q92RcWDt5YI9Fgkw3PqK0Nbmje8OmHh/7QW0br2/q3vLsjbnpRU6LW1c0YNvrqUsjXX/f8zy3NqOqlmo19hO8TBOW/bf1ftXhnT+XRasx0WhdTSBkuom/9htY0n3IPl3xsoJXXxdxzgwPwS7zcZnzcgMerrevkhAZpArQvWfC8nus9+11DFK70W417u0+XmDNibUEIjkftH/wzW388dWMK0pseAaeuREaNvb+oK7sfyRER3a7cXdriNrWPF/NYpiIZFS8tjUGuOOJdTy/dvC6AiOBglc+2RWvglHWsD1A2y6KvE4213fQREnqfiU+F1vN8Tx1zgtwyBkAeIjiJUoENwVuF4UeJwHTCl6NZimFHhcup0HI9OA24pQm972KOQsYbzRyzlFjOX5s94tv28bSjI8IdQEj1WrsxOmhzm8dQJob9rDd72TZxga46H9Zb07iP1ruhlAbp7U+iXvnm6mHlZGxJxYempyjGEsz7fY2A6EWzHAbzmQ4KI3U8YvxL1HtTf9h63BVdFrKFGMXTf4IzqBV8RqbsLbTMAwroI41Whgf3WoNrq9cCCv+0OvXnelfqzekP0geRD7Z/g8e93yfyU3LrNsbez4Q/ebFjdy6xKpWJRJmv//qSyy7m/90PgqAZ+vLqdsrjTYeeSejVWMfzMy4tYt9bwJNsDM5BxQL88TqXby6sd5qP5r2RqW9VwDNJqvVmMCBGWyzTjToElpTw/X2WY19hIHMVmOoSxui14rXQILXYFS8Eglo2wlttdbXageubAfsn7gelnyj10/b36+eLu7el8yTLaKJBE3+yKDsYt8eivKff32H+vbuX184muj8c7LnOLucjNOnVCge2cHrpn+s4aaH1+R7GUOuyR+hvcuGyHaLMfP3p72XLWQOVApe+ZTcFoLSiTDhOOv9aIBin4uP6v00memK14xqK6QVjZ4E7gJMw0mZ4cdLlDBuirxOvC4HgWSrsckspdDjxOVwEMYaYC83rIpAY8FkxhtNjCnxpKonMcO6T9yRPh1wnNFEEWFqgw5idN+eAaeHUNyqQgVb62mK+1i7q5WYq5CbI9cwijaucz3CuPa1nR5WbqT/cIfxEvaNYazRQof9P2ekA6JBPFj/QzsiHVza/Ac8O9ItvRZXVer9DtPH4c5aGjoiuIJWhakqbgWvsgJ36uzJknhyWHzVg7Dqrz3/TLrwRTMGzJMH9uMjK3EYJuWR5L/ieqoA+BuIt9enNgtd9MY2jv3h8+xo6v0AlAh34LO/5o50a2aU0c6qHRn7nGUGjD4CQUtbxgkLkQ7uWbqRP7y6pXP7ro+Kl9GyFYBCI4wZbrOCXpeB+/RwfXLGq5+Kl92S7Bo8Mrf5GPA+XqmD+yAEL/u5YiFr/s0OqNkGr7p1ULu696fP2Bai65YafS4ro03bFowRjiUGJXi9V9PKk2tqWbEl2VJ/9U7YYV05IRyLd65M2icxRAdQ2Uk9JjfB65UP6zl1/tJuFdShVtMUoDkwsi7ono2vLFrJ/3tyXafbMluN9v/nuTgRaX+m4JVPdsWrbCKUH2y9X3UERR4XO1uCNJklVmvRW8rVp0xm8VdOZs5RY8DhJFI8kYONPXiJEMZNoceFYRiEjAIAGimlvNCN22kQwgpTo7BCVq3rILxGFF+kORW8/B4ryMQLRqeXZ0TxGlE+SBwMGN0G93F6CMSsXyFHqJF2s5C2UJT2UIz3zSk8njiZec7ncHc5Y9E+uxHg5KMOYsJBhzDWyKh4RQIY0QBeuh907cpbq2MUcdOgzSxkrTmZqa5aWjsCuMPWlhyjonXW2yIPBfbGsMmd+c1QR9ato5JEGyEjQ01j6gAAIABJREFUuUdapB1CbUyNr0/fwVsGjZu6z7388lB+veea1Ne0Yqt1YHt9c+fW44otTak908yIP7WJrbO9FsYdY30NtFHXFqYlYF0WKRJIh59gMNjr3FpDS2bw8hOMxmkJdD67ta9g42zNmO+xt9XIPNmA7q3Gvme8EpT4rJ9f18Fbf8ZVAJau30O7395sN2rNXPVlMGe8MltjGb8jP3z0neweHwumry0KVgUtlP45ZLYHBzKjFcs4W9SuTg1Gq7ExeZWEVGh45eewZnFqfZ1aovsUvAanDbf4rR08/Ha6+ruxrt36W5nn0FPfEe5/4+MRqKEj0q1amtlqtH/HO3JwlY/9mYJXPtkzUaUTrJ7YN9+BLz1Hsdc6OC1PHE1syjngcGAYBicdMir10ET5ZCYZdZS44oTxpCsJDit4hT0VeF1OXE4H4WTwsmertjLBepK2mlTwivis4GUmL+aduSHrSvMIygvdRJKVsxSXh2Cy4lWSaKODAtpDsdS1+P4Wn5M6k9EWMx04jPTBeVR5Oe7yCZQaATw7llkVg+Qf6xKj+7+S6w1rfQHDh98oZKdZxcrEEUxNbKQqtA2AFrOIkugeHCSoKPRQkJxt80WS15uMtGd1IIgnTMpop86wtuloaGxk/RtP4yLBK/EZ1p2mzrUO1plnNjZaQ+klZgeRuHXwmlJlnRixdlf6ILyjKcCl/7uc7z3yXnJdAWvbD8AdqIVRU4g4ChmVrFSu3NrMWb96mRdXp4fef/X0Gr688K0e19/cljHzFPETiiasA2xmlatLK+/1TQ2pUOQINRM3rZ+vI5AMP4HmTvcf0M71sQSFHhdOI8EZ63/UqTKUWfFa8MpmnGbyD3XTZvj1EbBtedenS0ud1TgIM16ZQSGaDl6rt9Zl9/hoKH1t0eZtcOdU+OWhqT367MsmQTJ8rlkM65/u/2kzKl572q11xRNmn0G3V5EA1FlVaPvyVC2BSLq1GrZPIolbJ3mkHpf/itfC5VtZ9Ma21MfhvdwXbTCFonHaQ7G8V93yoadLimVWvOwQ1tFDq/F3L23iqvve7Ha77ck1u0bsRqwKXvnksy4LROlE623loVA4ioMrrW0jHk+cguuqh3t+7KhDmGTUUeZOEHd4KEqGtUgyeJlFVuXK5TBSe2VVJA/gayPJ/b7adqX+yBZXVQPgKbP24VprTgYg6B1NjTmacaW+7mtwegjErANzBR1WxSsYpS1o/U/2RmIqNeZoTG8pXPg71jsOp9meW7O5C3CVWbvdn/SvefD7k1NVh1ICtE08HY69HIqtNTe5rK/LbxYQMIrYaVbyVPxjOElwifk8AGsSU3CacY4ytvMxY21qrzJvxKrWGJHsKl6BSIxyOtiFFfaWrdvGW/96mrDp5rrof/L78u/CMZ+17tzwYfqBybM+7a+1IxxLBZR3t6erIX9JHkDsvbvSVT4Tr383lE7E7ypPBa9tTQG2NQY67b22q6nF+uMUbLYunZOhtd16XAIHRAKEInGa/dHOW0hkhLAdTQGu+OObPLWmFuIxnNEOaqkEwNlPxavPsxojftj0T6LxBB6ng3GuADP2PG5dRSEpsxXhdTlwk/y4ZYfV7mve2v15bYM549VLxSseCfa9qa0tFrYCYDwGqx+Cjt0Qj/CJHz3ER/UdnU4wCEUTsOwueHNBv0+b+bjMCkMklrB+7n/+TPbt0HcXwb1zIBLIqHhF0yE8+TfBPnCmWqKpkzoGcDC0fzaDFLxaAtFOe8DZgSuXoaeuLcTC17f2+nn7e5jP8Jcv0XhPwSs54xVLpN7vqdX41tYmlm9u7PFvRjSe4Jv/927ns2pHEAWvfEqGI0Yd0unmH8ydhs/t4JCqIgyj5zP53FVTKDf8jHW04vT4mFxpVVSiTit4OYut53Y7HalWY0VyqP3VluRgeutOa2DWVUBB8kLcRnJN7yWmABCZcCJgUF7o7nRWpPUi7lTwchkJ2imkLRRLDZGbOPjfwq9gnPtDOO5Kbqm8m5DZZUt5dyHeiomdbvJ3WFUhh2FiVk2FixbAmKnWkt1jAOjAx19Kv8zvYxewzpxEk+8gvuB6AbACa9xTytPe/+LG3d9lrtM6U9AdacEggTPakdW/2oOROIVGmN0JqyUcCbRSGdvNTqpopZhnXXNg9FHWnTOD14anAGgyreCV+a/hdf+fvTePs6Qsz7+/tZ06e+/b7DADA8MmAirKIgFccEvMihqNxp/xdXvNZozJ7zWbiVtMTEyImkSNRqKYiLiByqYgIAM4DDDALAwz09N7n/3UXvX+8Ty1nO7TA8RgTJz785nPdJ8+p+qpp+rUc9V1X/d1zzTpOKKZ97/dLW4qpi5Ai+p1MHGp0kUPulBdR0sbYFQCr2nZfqmcsQDpdgWTxV0fh0+/pEds32gLtqGrD4DbxvYDAQLdzHnMMF6HZZeB5Y6baLlinzUlZqC6vcArvunGLYP6Ml4P/Ad87ucpOEsYusKwLvefYZSyjNdgXsOImdJY0G2v7uWZhPtfqPGKwZvX2yooh79mj8meiBtq242e5trDSpNv7J7pAVCOH8j09TGOLd5shvFaCbyW7r0WDtyMt/RYv4+uju6y8CbrLrHcEduqdzMdKeScZ5kLsbMV7FUUwRd+FfatthlJB5iZz2OEF4RPyum81nV7msj/OBivr+46ynuve5CFlkMURXzrwdme87goz4f1Uwq8Vs591jIlSTX26Ws72xD+jHPN1UBeWFE8QXcQ34WHvvJf5rH344zjwOu/M4Y2wxtvFMaqmRgs5tj13hfw5bc8d82P6qNbAdjgP87GsWE+9Asi9eVpgi0zBwRDpEs7CYBJQ9w4D4djhGpOpBqtOhSGICfNWSVguz88gbo6RPGMl6GrCoOFHBornvg1k46faUZNQTBeMtX40jOnmDjvZ+HcNwBQMrVkLEkYBfJD63peUjJPx7m8ZNqkhUY7L46rFeV5cPAS7om2AwoH1788+cw94cnMvvLfk4KFDYpIkylRyDh11NB7UuxAxw3I41IL8kR6ntBus45FjoSCAWs7PlQm8c0BormMwFSaRZpSr9WyvaShdhBG7Jtv07C8BKAud1wIQ7TAwlR81sdWGNV1NJUqE7oEXnUxLyVsAvnVtbqWqBxqHBELZ2bu2jHw0gaI3E6Srmp2M+xD4BGGEbfvW0xo/abtJ6mxGHglsYLxihegnKaiq0p/VkiCONOrk9NUBjQxL9+5/yDX7RJFBF034ETlKOerD2I5mUVa6qP6NVEHBNBMAMOPkGqMIuF3Jhuw4/U61puK9+S8iGIwadd7rrERmkzX7R5dVtPyiZx2mpo81mYzGq/5DPBygoDmEXHtzR95YsNbID0uaznxU6t33bQTggRe8YKaLKwrU42eBXuug8e+u/a+ElC8uhIyawL7dzfv4/kfvnltEfY/Xob3/avouoH8568Y49Onr4ofmtqOz/6FNm/67D3cuCdNPccaTdt7alY1/xuiX6pxsvso/2L8BZ5jHZPxOloX11G/gqMn1Vpr7w3wxdcmtjv/k+I48Prvjg3nCjPVFWHqGoPFPg0H4xgSLFkpaKLoJqoqAFArNyY0TkMCHBhqqvHaXhULR75YQRlYJxgvaxmKw2BI4LXlAg6c8ia+E57DH5z47xhnX8lrnrOZS08dXz0GLUc7831qRgWatpdU8r3nilN528+k/lHFnL4aeOVK6IMZ4FUY6mHWTLMgj3cLAHZ+kq8qz+dO5RkUcho5XVzCS6e9PvnMYjQghOmv/QoAo6S6qs2KvGH6Vv8npcCDr7wVPnUF0eEfUMChG+UgVwa3zXplgelI6szcgH0LHe6xpnhsz07x+TBMhOhxcUDb9rG8dKLqlke3a/Nx4yM8Q9kndFcZwLQpHmN1AzWlyjAtCobGtLxRVVWbFqKzgeNYonKoI8Fapmy/0xVsQ1ut9Cx8zXbmCTP0uP7BWV79j3dx/QNCp9ayvYSFmY16bTtWMl6uH6KrCqqqoKlK/1SjZH4Mv42hqQxKxuvIwjLvuPo+OZc+b9Ov5SPGVYReRoMmxf9z8/Ortwu9TMqPkmqsPy4c/u/7nNxuN+mDCgJENyyPKIoSjVXfSEBNXfysiOtzRGkyXbd6mJKXfew2AvupM17Z/TteSLVzEIDm/KEn3A6QppetWq+4fgWATdikuBAiw149ttghtFs97+8bx9CF/eG1D/CB68Wi+f39S9S6Hl+7v4/RahjAkZ14M2l1dAwY46q5p5Ntirfdtn0aUkax3ElBeAy8wugJCh6iCL78Zrw93zxmRavjB/zp1x4SYPgnPLwgWlUoc4L1ABdpu9E7c8n5WVkA1HFSBvlIbfW1kTaTP8Z5jR9YnsSDy09aHAde/1NDAhEA9FQI/72hV3K580HGqwJI6ZqCIzVeU0aXbmTy/FMmUarrhcarK4FXLu4DOcThZ76LDgXKeQMUhT96+Wn84rkbV49BM2h7KePVVUo0rTTVOFDoBVllU08F+ooEm0YB8oNJOjRbAQagGpLxGhKMl1Ko8tvem7kn2k7eEBYaOV2lMjjMH3qvZ1/+DFoUMDQFDHFMo0paBbhZzYik+7Fey4+Jxffx28kfvAldCbEiE18vMhDWGVOaTEej5DSVjuOz3HF5NNzASGcfR2tdwRRJC4IYeDVtn64bMJrzeKP2dUZ3XQWHbuOF2k7+NP85wXhlgNcJihTqV9exFFWpRk0qeT1JNVYViyWpHzMiD9sPiDoSmGTSbV3JbDXVARSvgyIZy6RiECBwE6uK7+8XgLGVYbxmnoDxcv0wAb+6qvRPNcpF1/Rb5HSVAVUsKHEFZxhGdJyAUaXFME1yrH46dtprNOrOLuhPUVwfhhHzcZojvu7qh5Ltvvc/0krGHOK6/u7eRZ77FzcJdnD/TULLdegucfMPg7RK1K4JBqk8SYjKsNIUGq+MuN7AR49kg/lj9LiEXh+vnlSj5zFgiZS1vfwk9TAxOOwuZ8T1Xvq6I9p3uQnr0JtqPDi7yCUfvoWb7t+fvH/N8NYGXi3bp2V7+EHI7iPiO3r1D/ocg90AIlw7/Y7E445B4dOZakyAl+Mn+8l6Vy1mujDYrtDE9R3P9L2w62pu+Pxf8Xb5wLEqOkt0Pv96vnDbg9y+b+3m9E9bHLkHjv6w97UoguXVbGoURbhBuMoaRgvEuQ49OwHvKxmv2Ux6sS/wWnnt9YsY1PdhU3/S4zjw+p8aZjmxG+jRopgFFhhioirAmJ7ReGn2MmaxzP/3sh1QmYT2nGBnChnGyyhgyoU0FuyvFe/80h4aTrqQnLRpvWC8bA9NVRLBdRzFXCbVOHkGbLsMNj4bFIX7zPPoKkXhFZWNGFSO7wAgKE/h+qIBa97QyBsaxZxGJa/zueByfm/gg4AifKU0nUDL9wCvjUqGOfH76E6cDPCTLJJNDkspcJIyDcB0NMpwKUfHDWg7Ho9GGxhQuvzyX36Z+x4Wnl7zymgCvFq2R9cNeGXpfv7Q+FdOe/AvGbnzAwAsmJto2T5uN128tiizwkakMsliWMGMHMbzAbWuRxGbUtThYCAYyJziC+IutlzI3IQs2cezpQiQFttqtLuZ4w68ZNGLn0pbtpc8Rc5GIz3TE3TkYhBFcPgHuH6QAi9N7WW8Fh6BB69lqS62r7kdcppKVRM33YKs4HxkrkXX9RnWupiKnxSBZENZAciTyJh5hvZTY7y+vWeOCz5wMzMNi0/fLNsyxT0FvS6+m86TiUg1zjYs/DCisf8u+OzPwdfeCZ96Mdz8vl5wETNeRoGOPsAoTY7UrB6vp1LSezQC59gNybMdAbKpxqj2uABvQNSYfnIHHqcUrRR41bKpRrvZkz5KhOvy2np0WlxrrYascH1SjNfqdFLX9ek4AXvn21hewLbxMj88XF9tjyIZZN9Jt7EktWk/DsbLzgCveC6yhqBZIGx5AV+65wgXfOCm1Wn33dcAcKZygK/vnqFvHL6L4QNf4XT1YP9jevDLcOdVP8LRPEF8813wnff2vnbbX8HfnA0Lj/a8HD9krUw16n4MvLppVeNK4JWpVoy1pdmIGa9jFk3E3/2no0fr0xzHgdf/5HjZ34j/M+mfghQ5j1UEU2SoqcaL7hKaWRJMVHkC2vNpqjGXAq9YKF3OHxt4ffdAg9l2+sVwNl1E1w1Y7rhU8/qqwoCyqSfsG6VReM2/J61svnLy+7mKX1y9E00yYeOnwtvvpT3xbEDc+MqmjqmrlHI61bzY7v6FNgVDoyRBX2iUeloUnaCmwCvqJ/jNGISq0ozVwqQd5dmmijTIdDTKSDlHEEYstV0eDQUbuI1DPLRPCJwPBcOYiqhQbDs+XdfnFEOwbbZepbQorBSiggA2rVZKl0+pNSytzA8OtZjzRUrxz+33sY7FRP/1WCSqT3OyCpLOauBlW+L46oqwLYmrIdvd9KYXBR4PTItjVgl5j/6vaO3ZjMarN9UYxMzT49+Hf7qc9Y17uSH8Ddj3HfKGmmhvAFGtd907+O5DgsXotJYxNJWK0st4/eCxZdqOn5yncWV16kBz1wAm8hwGkYJvNZNjeTIx2xCaq+88NMctD8gnepluizyLvJKyGqbi0Wm3KC6JdJfTkfu577PiYeGh63qBly2Bl27SVNPK1KydSFnJpCyfIF2SXcTrGRG6uizaVQWRgt5Z2/IiCKN0G5LZCjvL1LouigINyyOM9WmBg2Olx5KmGsW1tVQTYzUCea0dK8Xrrl3VGGu1Ysb1opOEvtRyfAHakzeKay7IpNFjlunpYrw+fut+/vDa3XLbMXjwEjCUZbyyDd8tL+DgUofFttvrLRaG8OB/ECoam9QFJo015kyCiAIOVj/vq/v+Fe7+xx/l0I4d1vLqa/H+L4j/nd6HnzhtvnLujVBcR5Frr6nxivVdo2WTI/2A18o0d784znitjje84Q2Mj49z+umnJ68tLy9z+eWXc9JJJ3H55ZdTq9WOsYXj8YSx/pnwqmvg59P2N7GRZQ/jFVcShn6SfqM8LlIz3WUojohekRf+DgxuThivstnHrT4THnpa9r/lQvIVsUgfqVmr0oywQuNlFHr+tnWszJzbR9OWSaMyspVqRve2bayMqasUcloCvOpdj7GKmYC+MD5eGZvV1Izzsg/cwBs/s7N3f5mbi26JG74V5agFqZ2GAF5iXHNNmz3RRiJF40LjERTpdxWn6Ew8WpaH4zhsiGaZZow91QuSbQ3l5NN0KwUMo0qLmp/jVz5xB/tsAbzO9Hbxx8ank0KBA9E6uX2fIg5KzN7Jm1DH8VEkiKhJPVhRLvTtzKLasbq0HB9dVdiszPEm/euc2r4j0R3NkaYa/UgljEG+bHo8Zu1ngmWY3c1QMSe0L1Zd/LOb4LYTgFuKOhi6SkUVv8fAa/d0g4blUZXGuuOsvi/o3lqMl6zEpEKrWeelf3vbkwZf8SJ6pG5RojftrAQOhSijNcRl6uC1XHHXa6jQxe2s2Ed7lofvzPhxWXWhpdJNGsoAI4oY/2zTRsoxM4wXT6jzymq8ADS5Eb0m0n27oxMp2WsDr3d96X7e+nmZOpXAy2ktEkWwYahAGIlrIQ7XSo8vFdcL8KjIz3tdeU6cNc4NHFPjZbkBHTdg93SDal5n+6S4To2dH4e/e5ZI4UICvMJMFezyCguH/2rg9RfffJjP3XkoGSfEWs3VjNdihvGyvSCp0O1pBN9ZgPYce4cuBOCSyhpNwyV7WMTpz3jZ9Z5q4P/ysJurGcya9E0Le8FTtnoxW1Sgh2mD+STV6AY9uraY8Tpvy9ATpBp75+Da+6b5rS/KVKh7nPFaFb/2a7/G9ddf3/Pa+9//fi699FL27t3LpZdeyvvf//6na/c/PXHyC2DitOTXSl5HUWCsEgOv1LkeyFQvSi8vIpFqrK6DS/8vqGoGeK0GT9lw0bkz3MGeyZfDL346AT9HahbVPsCrp6pxBSDaOl6iFRVX70Qze36N9wFw0kQZUxfsVpadi48dIMqV0w+bVTaRGp1qocNND8/1Cl3jlJZRwnAEyLAw+Wb0vOQtswwzWhJzOtu0aVIm2HIxL+Z2FJmePCpTdDl8th2+hn9r/zobvIPMqFPsyp+XbGtAFzezditdvIaVJp0oTxjBLf7p/Mf2v+Qbw6/jcu1efsX4HpAyXiYeI5lUaky/L7ScJNVZk7YWRQkuulZ64251LMao8enhTzOK2I7iCa2aqxVpZs7JLMMokgmLGbGiG/t71Rkp54Q9wbVvgS+/WSzIUUA5ig1xLXKaSik2tJXM13LHpdFxKIXiBjqhrAZe5prAS9y0F6OBhIFpPpnqQ9IFdbpmUVJW3/yrmdZWRTVA7S6iRT7DSpOgk7LM/ugO3EjDvf/f0w8njFeeZSpMaGIxC8IoMUjO+rFh1Y9ZFu+FEVkCeVxe42pnDheDh8LNDAZrN2R/bLHNA9NyDqW43muJ928dE9+RdicFXl4GWDpeKMYmF7o4RfyE4vooymi85LabM+CLPpN+GGG5AbWOy0Q1nzLtO/9OvlemTiXwigF8TlMTL694Ybfcp6eqMQyjFGxlNV4ZBqfWdZNMg+WlFZdZ2wu6Yq6/7Yrq863eGo3GJYgoKnb/Y7Jq/SUSTxRPttrSaa4GMvH+VrCW2UKC7M9GGLPGdk8aMtudYqZpM1zKsXmkxGzDXlUNmrJpvXNw08PzSRHQceDVJy666CKGh3uFuV/5yld43eteB8DrXvc6rr322qdr9z+18apnb+IfXnNO4g1lqCpLVHE0CXRiLVc5U6VY7D1PG4aKvPLs9TxvW6++Z2V46DQos/OsP4XSaAK2Di93ewBSHGesH8DMpynNbGwbq9CiD/DSe1mwSgZgnTRRoWzqVAsGmqokC9pYOQPWJPDyVBOq6xkkXSTyuIQRNNttHvvhrTzv/TfRqMdWDlOYEnjZ5PhE4zx+wGk8HG4kQGNMMoozdRtFAfXMX2QqmufkhgBGsQ1D1fDZUPsBI9RZZ+9jIbeBO9RncmTiEnE8mgAJ3U4KLIZo0kUwbBEq8+su4Y51r8WODC5X7iJUcxyRlZU5xWOMDPCSN6P5lpOI1JfCGHiJhT4LvJqdLn+d/wQXtG/gEk08SapeB6w6jl7FIp3L6WgU3VoQOigpsi95MfCqMVwyxWJTf1yI1OWCHGu2KnTJ6UoCOPK45HSV5Y6LZzVQpfg/TjUGmduTGaxxc5WL8UI0KLcbHVPvc92uo3z0O2LRixfR6brVC4JkDGaauVeNgNBJjX3DDCN0r3ku8wwxaKcaK69TE9pLLcdCWGWYJnkcPmL8PdtzYs6yfmx843eFVmyN8IMwWdwBxqWhseI06ahlZqNhRmjQ6fRPu3ScgLmmLR4yJGMV6/Vi4NXppMfry7ZUb9au48wbXyPAmmQ8kqIIJwVetzwyz67DK1i7zGdwu4I5+ehZ8LFzcI6IVPurgmt54dwnKed1TF1jkiX0rmTu4vS5BF6KZ1M2dcYqZsIm2WtovP7+ln3HZj49C77/MQgDZhpW8vD1sZv28s2M/mqp4/ZUNaYarxTc217IsHwQs92U8VrMpCCdujim7y0NMB2NMOlnmt5nw0lTjV1vdarR7ywTuE8ReN34J/Dplz7x+zxbnLMskM42N1/BWma7KWQBVi4S15fiWziZ8xJb6rDr31g3cyPjFZNKXscPo6TDx1W37McLwjUZr4WWQzdmz46nGp9czM3NMTUlXMonJyeZm3uSbTiOx5OOqYECLzxtMvld1xRAoVYSvl9J9WLCeCFSjZnI6Sof+eVnsHmkl5Xi7ffCm2/HkqnLUF4+MeCq5tNGyf1Sjc8+cYQXnLmpdxwy1g8VsNXSqs+sYrwy2y2bOu99+Q7+4CWn9ux/vJr5jCkWFV8tpP0w489r4sbm33c1J1z7cl7Ruprp2TlAgdI4eV/cuK3IxA0i/m/1ffyq9kEApuTCd6RmUc7pqKe+FA+Dc7x7aURF2ghgubGiMWWlotRafgOzjsENZ/wVu8MtlGSFn5MBXnlc2lGa2iybOsVSiV3RVlQigsr6JH2cw0/SWEByE1poOZiSmVgMxbyWFAESbVveQFWDTtfi2TyQ7BdA97tEdg1br+Ch4UfiPP+rf5nwf/vUi0VhBlDxJfNj1RguGgJ4WXWhlZPsYdwjtKJ0MTQ1SbHlcdkwWGCh5aA56aIdM16Oks5BIeyKCsKVER8vA2hKRAGnJw20Mq7ZeZh/vUukThLgVVsDeGW0gVU9QJHszYDSSbSAV/kv45roMtpRgZKfMnVuezlhvOaDMuWozc9r3+OV2m28gS8DKxivpb0wv6dn/0tth0dmRYVhtsE4wETMeDktOhSZlSnhuaMH+x532/Hxw0iAASmij9nLE0ZLjNLAyvi7+fLcPVPdy9DiPT2LcQFHPOTE2i6nxc5//wi3fe3TvTvNLoheV2j+ogBac6g/FLYdV6h3cmbnDip5A9NQeZ6aWkYkbbgk8FIDm6GSwWg5l9hgOH00Xn4Q8sHrH+Gru9ZI5wHsvxm+9QcsPnoHF33wZr71kNjXZ+98nK9lgNdc00623XH8BFRlrzHbCxgsivuSlUk1ZhkvuyG+L887aztGvowaOP09v+SclXCwVwrLwxDVrgtZwVPxC1vcC7O7n/h9ccrYy3zXFjNau5XAKwO2spWNOcl4KX6vb10isL/tr7iofi3VvEExp3GCMkN4459xx/5FPnD9w9x3qI4TpGnMbMR6uq4XHAde/5lQFGVNV3aAT3ziE5x77rmce+65LCw8QZPc47FmGJqY40ZF+mkZK1ONiFTjk4mRrTB5Oq/JfYR3um9JXo5ZqCwoqhbWEObrcjFdwXhpqsLgUJ9xrGC8VjJpp60b4JTJqhyH+FuW8dLygu2J9HxiSRHHtiFx+bs1If5+l/FF1NndYFYTwAZgyVTt6RuGKRXFuCcHxP+Ha11R/ZmvcrAgAOBSVMWRwGhjrsWYly4AneIm6l0Xy/WxMMnj8ovaLYzM3t4CpFyzAAAgAElEQVQztpjxEscligd2hicDoAxuTGw5cng9VZsx7T7fsjHx8DBo+mIsRRzGKyaWI8XVRpGCV0dH3OCv3CHmLR/ZRN0allZBV1VsyXrdFZ7CzpN/S7BZM/eLsflp6nG4ZNK0fSKrJoCJXKyHE8ZLpBoLGcZr/VCBow2LwUzj9Jjxis2Ak+inJcqkGgHK2ImBb784uNThbPsuuO4diXh5oe1QUvoBr3hMCmU9TFItVTqoTh0/V+UD/pXcNCeA9kCYgsegI+0kdJNZWSDxXFUYnXYM8aBTXpnedJrJgnrP4zXOfd93eOFff5fv7V3EC6JEvwmwvqxQwEZzm7QoYlXEtd08/CA3PzyfMAZxxGmemUZqDKvZ4txtK1ncbr6dgYOpRi1m9MaVOmrk97RsMhWP8aqJGtt3BA6/417FW+dWVMPFC6KqC/bq3n+B014J1alEK7hOWSYXdqmYOnldS9PmZjUB93HxkBY4DBVzjJTNpJIwXvCzwCte4LvHqoiTYzs0M48XRBxeFuei4wQ9gGeuaacsV4+dxLGAl2SaMxovvyXWsBM3b0Yx8hiR279JupzTgmKvHr/bQiVEJUq6UqwZh+8W7bZA9t9spFWrcTgt+Ogzkj6on7s1BWfv/rfvix8WjgG8etpfibFGUYQZayMDB8cLuUK9kzxOCry6y+RCi3xOo5TTuUK9i8IdH8FvisInywsSUPf59hvhxj9N9hOf947jp6nP46nGY8fExAQzM+JpYmZmhvHxPqacMt70pjexc+dOdu7cydjY2I9riP/rQlfFKW4NiEU7WbyKI4m5I8WhPp9cO+r5jVwbXpBoTmLAkwVezzlxjTRlLJY3VqcVx8b6mbSuZLwEoNsysvrzMQDMaryMgrRSKFUS9/s4Ng/IysdWCuwn2w+K5uWZ8cXptmefOMyAFPdPDQhg1HWDRF92qHIOAC4GDuK1MyPBdu0JBdvmVDdT73p03AAHE823eLfxBU5d6G2UHDNmIBival7n7nC7mJKhTYSqmGtT8RhJDGKVHsYrr/gEao5aIMZcwmZyoIDtSLZAMTlVTU03C45Is5YUm8enj/Jo0yCnq1iKOP4ueeY1cY4iyc4MBJLxsusMl3Po+IIZcluJDiyuVqxgYegqhUjcwAuKy4ahAlHUyy7F4vpQ7wXn8fZ6Qt585yPR97SidGnZPruPNFaZVLp+yHTN4kPqx+DezzDYEcL04ajRl/Ea1eTiZlYoaz5ahvFS3Sa+IQD/UselHRUSALsYVRM7iVAzmfbF+y7UBFgtSaZ11T6jMFlEvrF7JiE1Hplt4Ye9qcZfmP8on8p9CM1r0YgKKJOiiGn2kbt5/afv5pp7ev2w4qqymYaVaLwMVwDFDeoypuJTaKXNp0NLXFNjcYXpYqpJKkgAr3l9Fv9auo1kYSyNiZ/dNpz2s+Le013CwGeUBmZkU8nrmIbKsNIW1/bI1tXAK3QYLOY4abzMvvk2thf0ZbxiUNRZURW4f6GdGLTOLgoW7cGD4ve65RKGcQVyFng5vanGPlWNjh8yWJCpRi9MgNpShvEK2wui8rQ8TKTnyeP2f0CQLGI/cX1zOa3I3nd0bT0fAF/8Vfjeh8XPMWDqrvhMcwZqj8GcYLy/fnfqAL97v0yFtjP2OyuAl9vT/kr87AVRYoCt+jZDnQP8fe5v+LDxcXENRpE496FNwVApmXry3Y/BuO0FybanWEiOw/GDxCOy7fgp4Pqv6NH6Y44fK/B6+ctfzmc+8xkAPvOZz/CKV7zix7n7n8rQJePVHRSLdnJjVLW0V2Tx2FqulRFrqU4aF0/yCeOV0V+95IypNQYUM16rgdPUeMrCJYuu3tucu5jT+dsrz+aLv3H+qs/HwC8LvMgJ4KUYq1ONGyvi8g+aszQjsb/BqEGQqyTaMEgZr+ecMJKkUCcHelOBALPD5wJwonI0KSLYEQiA8gfeG3h4y2vwh0+iaXu0bR9XNcGzKLNas9FZkWqs5A3uDU/CVwyUsZPphmKfryrezZX6TXhGVbrrpxqvuIF6PWa8FJupah5HMl6dcEUVqVzoitgUgyaLvvB0cyTw7JBnTjbNTtJuQcx41Rku5hjIMFcrDU3jVGM+SlON6wfFvMefC1CZkIt9tCIdnbX6SCLReImHhwpddh9p8LKP3cYND6aFFHz9d2h/5wOEETwcCfuP0+q38kzlUX5gvoXT1bTPYVce74hmCTsTo0BJ8zGkMWSVLobXwjXShu9ZoLwYDaC4LfAdPMXg1vAs2uYkVSRjFop5mSrIVHeumnw2nH8EZ+dnuenheS4+eYzBosHBJdHuqZhLv1/ruo9yojKD7raohwXGR8c5FI2jzYtF9PsZ803HDxI9TpbxMv0WmhIyqoq5j4EYQOQ0gYgxYuAlmA9PFaBhvJJH9/sAr33fTn+OF8bSaPra0Bbc3BBKd4kJZRlViSjK1GVe1xiihWsOQ3kSWjHwEsdiRC4jpRznbB7CDUJ2Tzf6arxiQNNd0R/wA998mHdcfR+LbYcZCbx+uF/o8mpdLwFqlhckad3Zpo3thWxVpnnH9G8TWuLctWyfKIqIoogdwSOJ1YzlBUl/wbgPJkDUWaRGhYJpouh5TMXrnxJ3M8BrBeN16GiaAj0wc4wsUBQJwBR/X2LA1FkBvDI+WI2ulzKYgG81xP5XpouzQ82mGpPG2AF5WcSjBjb44jOXqfcIsGQ3IArIRQ7FnE7R1JIHs0g+WNlegOuHieFzHFmj2o7j921H9Y/fO8CemWNU2f6ExNMGvK688krOP/98HnnkETZs2MA//dM/8e53v5tvf/vbnHTSSXznO9/h3e9+99O1++MhY6xiikqyTWet/mN5XKQBzOrqvx0jYmPV1zxnM2943glsk+Lcsqlz3pYh3v/KM9C1NS6thPEqrPrTlskRvEgjjJRU8K+vtph42VnrEnFxNvoxXomWzCgmqcZYo7a+LECp35xlT5SyYR2lmFZ/AnYktrdxuMCgBF6VvJ4Arvj/1ugzAJiLhimXxJxs8A6yHJW5NzqZh896DwOlPFEkbui+mge7kfR0zEaHfHIc5bxOtaDTpMzfn/IZeNabeNEZGwhR2ezuwyDggbP+rzjWDONVlcBr2RdjLmEzNZjHdcX+GpIJQ5ULuny6LWEzQIc6ZXK6iquYWFGOEJVpf7BnnEkza6vGcCnXw1ytjApdTF0lH4obpilTjZAyXnPKWPLErJkC2IRIarWf5YJcDCY3bAFgKu+yZ1bceA/NL6damEevR90vmjm7kTjeszvfZZMyj6ZE7FBSpmYpFN+HIaUjgL9uUlR9DDnuAaWD6bew9RR4taL0el6OKqh+F3xbsp85HtjxW+k8RE0O/PkVvPyUKk6k4+ZTYDJ9/V9ifu1tLC/Ocemp42weLnJouYsvNV4aARoBFeswQ7QwvCa1oEjJ1DlobOXEQADIOw8sJRqiTgaACOAlNThEXGV+DLMjwEfOywBbp8UgbXLx+ZWMV8cYoqi4DBaN1McrG/tuTH+OF8ZiBngNbuLbBz26jQWmkAUaikPZVCXj1cIxBqEyAe1ejVcucpio5nne7Gf5c/2T7DxYSxZ8K6Mx6sd4dRyfWx9dIIzgpj3zdGUhQZwWa3S9JBVmuUFi3zHXEBqvZ6sPc7rzw4Ql9cMI2wtx7C5fNt/LW/a9CRDiequPnYRiLbEUVSnlNBRDgNe+wCsW1yu9jNdc0+bAoZTFPDh7DFd7WU2ceqitwXhlgMuh5S6VzAPgqNJgZnZagLM46+D3MrT9xPWOHyZGzVrgJKxoXvHo2F5yLvORTd4QqcYBWcQSaw4tN8AL0u3EkTWq7TirNV6NrseffX0PX7j7SXZw+G+MYztk/ghx9dVX9339xhtv7Pv68Xh6YrySZ9d7XyD0IS/9K9hyUfrH8oQQsB5Da9cvYuB1ymSV156/JXldURSuefPajb2B9Eu8ks0Ato6XaVEgh08pZpxWpBqPFbH+qwd4xVoto5CkGhejATYqC4wVRJ/BvL3IkWg7zzSHMJwaXaVMNcPIveH5OwiMEoqiJIxXXtcYLBq0HT+1ByiVeZX7Hg5FE3zypevhG1AJ6sxF4ljFU7QAO0frlgBe7f4FJp0ozwXbRvnKD6cZLZtJ+sMd3AZGgb979TPhz0zwLb4f7iCYuoKzD1zVw3hVdJ8wFKApQqGgOIwMFLBktWPN08Wj1+AmWYUoxfBKi7zi0YxK5HQVJyjQDvOMlnPMuzlhBbIyzeS2GSkovYzXihCMl4IZyhZCis9EScxn/LkZbYp1vpiT6sAALEDXGKbsLRFajVVPiqHTwY80Nq3fAPMwabp8a7lLlQ6vvf0FMP5ROP3nobOArGMQ4nhgk/cY6xS5ECgeYaSgKhFLVNnIAlVa4kFBM8njE4Q2qGKsBb+Fraap8SzjtUwVwz8Aip70SW1sewXveLzClQt/y3jYQlUVCpFFhzxolaSeN/bl2mB2uezUCXYerHHf4RpDxRw5XeXzufcxGw2je21QQHeXaFGkZGoslE7mAu9OitgsdeDRuTbbJyu0Mwt8Arw2PIu5+Vle4N4J+8Vx5P0MQ+m0eo1sF0XKvK0NkleOUsnrAkBnTkg9KjHQPEpyN4kXxphZV1QcrciMV6SkN5hSUvAwlAsxdZUhpYVtDDNQnhQMTeCnwEsJWFc1KB28m8uM+/m9x5bwg4AqFraX6kPj482adt7yyAKOH5LTVL710Cyv6sZ+WQJM1C03eX/b8XkzX2Jcr/Ht5ruxvCDRUeadRUCwqy3Ho7T3mwCYEoSuZSehdRdZjqpUcxpqroCJx1w/2xM39fHKpjxf8jff49ndh3m5fFY6kukjuipir72YofJTxuveQzV+70v38+W3Po+c1SIHLNdqHK51e+xT3qv/CxNfugZOvgjMCrjKKsYrq/GKtXauH1KIH5xCBy3LitYfh26qIy3mRNcRVT50KXYdGMf2AjRVoZD11guDFcArk2qU/8cPXFlX/J/UOO5c/1MQiSj33DfA6Lb0DydeAtsuf8rbq0igMVI+RhPvteIYjNeJo2XaFLCVvEgNQl/Ga60YKgpbiZHSajsJjCIUBgnNAZaQYnzVZ6hoMEqdhjaMUhHVoB2lyFEr1dO85QVn8PZLRXHCjnVVThovo6pKIqgtZ4oLvh+ezjRjbF8vnvKLfiNZlIs5PfnM0bpFoOfTxsQrokue1z13C9/6zYuZqOYTNi9rpxE3Vz8cjQuH5xWMV0kLRBUiCo5aoKw4jFXMRIvUlUwe5cme1Gq8INYRPmmeatKN8qwfKtKwfeH51idGtG4CavpFGQtDVcgF6Q18pCBu2INKm8goUdfStLciwW+nIPbn71390OY5XSxMtKI4pyO6QxjB6epjFMI2HLlbiIh9G6M7B0Q9Qv6kITkwj2DzFiPp9B+2JOMlUkNxUUBV6VCI2nTUdM7aGcarrQ2IknrPwo7S81YrbaVGmXIoFggz7NKJCjQKGxNwMmSLp/Xr3rCDdYMFtowUma5ZWG6ArqqcrBzhCvWudI6IaEUFijmd7vCpqErEC0cFs3H3QbEAZ9u1zDYsCbzO5WNjfyQPXKTDYzsPR8mjOs1U3wUJ8GqqgxRwRUUaVo9P3oFoisjOgDdvBfAqjtJxAmpRhRI2WzJzP6i55A2RauwaA4LxIoLWUbDrifRgqgR4XYZosfPgMm/UvsH9+f9D0U61SC1HphozwOXmR+YZKhr8yrM28t29i9gdMc4SNhMsU++kDFS96/Iz2r2crz7E9HIbPXQS0X/RTVN8LdtH3y0IhsWB0zE0BTuTaszaSRjOMktUKOZ09FwhYby+dv9RPnh9qq2KGa8yFq9t/gPUDjLXtFlsuz1s8tzyMczHYy1kpqk5AJ1Fdh2us3e+zZFal6W6eN/80pJkvNLv5cnqNLnOUcGK5Yrie3AMjZedpBp7GS8jA7yqC/ckILqAQ0GXGi/JeMXFHpYXiu0o6fxdd/u9vcDLzYrrxT4enklNin/S4zjw+mmO574Nfu6p9/2KGa/R0pNno5I4hsarkNOw1bKwEYj//hQYr9ecv5lP/dp5Se9AQDytQQL0lPXn8HC0BRAGnhuLnmjtU55AGxAL/HKQ55/uEouCh5EAHIArn7WJb//WxQAMSaF9zHjFjFvZ1FEzwLItTUgLOS0BhbWuR6CtBp9xwUObAuMVk21SRzdaNtFUpUdbFt9YD0Xj/MOt+/nBUZfQaeP7ASd2d1HSfEI5f7ZaZFC1RIpIMl5J5WRlIp0nYERWITaiEgpgqWXaSpmRUk7oZ6r99XsDtNdkvHw0ckpAQfUwAkukk4FhQ9ywh5QOFIZoaZlCD7moO6V1fMJ/Cbldn01SWX938z4++d0DBJ0lmlEJoyhA07AuFoczFKnZWtyb+EEVFJcR3WZA6dAtCJC9KdO7s2mK1+IKSS30xIOCbmLiJcavA3QoRx3aSgo6/IwhsBJrJqMgAV7VvEHZ1KlHZYqBmF8j6NAhz4sO/AJ/PPg+gCQNGy9CpxRqhFHE48tdTDVkSGmn6d143JQomRrqhOhnevloDVVJn/zjlNtYxeRo3RZgXzc5LEX/LO/v3Z42hOa2GJf6ruw5aagDmLhU8gZlbIJyei0ciNYR9XhAxcBLzkdpjI7jU5MN3neoaXq3qrmYukg1drVB8TAAMCfsJbrF9QBMFQGvixG5BE6H56vCD2ydnR5Dv1Tj40sdXjx0lCu9L+P6Ic22WKQvX+dwe/6dnN2+NQGoHTdgg7JIWbG4uPEVbjV/k3FVAK+Su9yzH2P6BwAYoQCOHccXjeM1labtJzqonLPMUlQV6WKzKDVeHl/ddZQv7kxTY5Gcs5PVw7zSuQ72fI17HhfXwqvPTL+joWMlQvNVETey75NqbFo+Eywz8dVfxa8LzVhgtzm03GVgRZWtEXTFQ0uuLO7HT8JOIqvxMsJe4JXrziTAS1dCSkZEKacxIAFlrDG0PKFJLGYYr10PPtQDvLpWWiQSuW0+f9chDjy6GwP/OON1PP53xkTVpCp1R085jgG8AJR8FV8vpoyY/uSB13glz0Unr6iATTReEni9+ho+VnwLPiqKb7MlJxaK/OBUwnhNW4ZIAQGuulpLFsfgSuBVyACwzLhTxktjajDd3qqqPQD5WjcyexjF0bLJDe+8sG/RwpFojMPLFt0oT7fdoLXnO3wx9ydsbN5LJMfRVKqMqi2GirmE8UpYxRWMVxwNSjQsjy8NvZEPmW+jmtfFzb7Sn/HSnQaTZv+bXkMu3sWwixF0kjZGAxJ4jWttlMIgt5cyDKzU2SlGkQ/5v0xglNl725d48GiDT93+GF/ZNY3SnGaGYXIlqctSxf7PiMXyS3uJMpVZn/q5KapKV7BMwKZM786Tt59ONHYq90YnZw5KMF45vCQtNay0KGHTIgVbpUqqfSsOpUUi3SDVBJZMnTplin4DogjNE8DLIcc3M8WAgFg85/dwxY0v5Hz1IVw/ZIAW/SJmvAamTsSODLapRxkpmwnj0nZ8tiuHeOHwHLONjliwNJNZO4er5EQ1pQw30lhWh8nb80mq8ah5ovhjZYoFZQydgAEzooyFlRdpyuWozFJUEUUFyTFI5qUqQBPlMVq2z7LspLBDOZi8taq55LWIATq0tapkvIAZAazqprjmJkokAGBYaTEjiz2G/bSQIgZeWXH9kZrF29t/zakPfJjTlMfIS5PP0/ML6PhsdvclKcoiNqNKk4piszE6yqRS43RZ/VvxlhLWutW1UV0B4PTQomBoSSXjppEiG5U5gn+4EBrTmF6DZQm8DDNlvBbbbgL4rn9gFqstAN5Y7M3XnuWex2vkdJXtA+nx5BWX6T6tdgBuvFcyaN4K4NVZoGF5nKM+ytD0LeRmRLu0yGlzeLnLppJPEK2QnXTmxb3aKPRlvJ6t7OFU5fFEa+e6TqIL1CInScEC4HRSUAhUVJdSTksYaEP2Y3WkuD4LvHLdWRbadvJQ7chUMYpGaLf5wJfv4A8Ovp5Xat9jvmWvblD+ExbHgdfxeMrx6xecyNffceExfdjWjFg0n610ysTmi1/H1IWvS4GX9p9IZ2Yjm2oE0HQmBou4mODZbJTAqzK2HiTweryjJ2k4m7WB39DKVGM+XWSzwKspgVcppzNSyqWMnN4H1BnitY1T40n3gTi2jVf6Fi0cCsXi18HE7rZwHhc3VD2wk/lbpsoITYaKOQwJvJJenJWJvpq7elSibnn4Q1vpjuxgoGDQtHyiigB/tUjMbRSreqxlJo3+i0FLFwtkKWighS7LMp2XCx0GTJVn8ChMnM5c4UTmpDVEzMJpZgEPHWtgKwsH7ue3v7iLxbbLXNNBbc0wE41QMnOQqzAg+0CeJhmvqH4Ye/FgMo4dunjKX8ptAGAdGZFyfhDlrXey6aLXpq/pJug5jNBJFoK4X+ain2eiajJSyjElrXF8VNZNpgbG+5ZdKqbORDVP2dSpRWU0AnDbKG47qV5d9FdcC91lmBa9Fbcos7xEvZNN7oHMG9LvXpMSpZzOuVvGOKpvYFN4mNEM8Oo4PjeY7+bP5t6CHvnJcbWcIDkvcbgYLCojFJx5xpQ6FnlqqmS8Xv63NOV4B1WbkmJxw2FxDc1FQ7SjAqpvpeabnQXxICFF/vNBheWOS12C7k3qAk4kv0Oqg+7UUZWIw06BK/9NsEDdg3eLz2oCiA3nwoRJG6ZJQ+on1/lHoDENHziBwfk7GaaJ6wpw5fqhMEItiuv2/+RuSBf1higsmApnqcnm43Ej+iJ2kjrfKFuNlb3FpF2T1U5TsbrfpZDTEkH9z529njeaN1JYfABu/2sAlqhSzOkYZjGxk1hsO9heiB+EfPvB6aSwJIn2PPc8XuOsDQM9JsN5XKbrfaqhHZ/v7pKGzW6b9157fypn6CzRtD2qigBkcVN1xetweLnLhOmyrK6wFmrPiQegfoxXEPIF80/5pvn7ibjet1OgZYQOuaBLiEqbogCC3fT7dv6Bj1L81MUJgxsXd1hegBsEPanGoj3LQsth07C4j3tWXDE7hup32a4cxlR8NiiigCKpgDx0J+z6AntmmvzFN/asspj574rjwOt4POUo5DQ2DvdnrJ4wtv4MvPk24dPTJ3LP+XVyF70zBUpPgfHqGytSjQC/96JTMMwC+BZTmvQrmtqUpDfmXTPx7uqEa/erXM14xQ7+Rg+oivU/hZyGoiisk+nCaKXObeKM5HPvetk5T/oQl3XB8lnkCZ0283vTxt+R3N5SVGWIJkOlNNU4rMsbW3myxzA2jgYlXD/kj15+Gle9+plsGRUM2J6OeO+0bFvUMSSYvvpX+DX3alEVqvSCxqW8sPIYbQkT0Vhnx75v88vm7ULIfvILyGkqlzof5sCL/xXyIuWnS+ZrMb+FE5VpHp4VYHmxbWN0ZpiJhhMT2zJdJlniBHWOPeFGFCLcg3cm49CXBBswp4lFWFUyN2IJPt/2gtPT12LGy2sm742NVWfsHNW8wa3vuoQXnCM0gC45tqxLGa/7Zmx+9uz15A1NpBol6KC7DE47YUN9dLwsu2otw4LQXm3T5/m73N/wosVPpX8fOyX5sRUVKZoakwN5TjzlbPL1/YyWc0lqJtsiKu7fiZ6naXl0cr0PQA4GcwxRcuaZUOrU1SGurv46XPkFOOly2tKC5Hn/8SyGlTaL0QBBpDAfDdGJCwxi1quzKB6wZOr1b/aN8sWdhxPGC+BuaQpcVhwUKQq/YwbuXNDw0Ok+JlJ5hyMxp1pg9zBesQB7U3gEHvkGWMucMvt17s2/md+O/oUgjJht2IQR5HUBVl+ifD/VIrYEEN+szDJdF4BkYyb9PLmiYftAWGO8ItnwtgARi1EV3e+S1zVqXbHgrxvMc8I2kfr1HvoaADPqBJqqoOh58opHy/KSBtsdy+IZudVO+1Frlr1zLU5bNyC84aR0II/HdK276v2Ha9201ZXb5aEjGduJ7iINy0vkADlLHKfqdTlSsxjRbNTCUK9xcWtOphrzq3pEen763XE9cV35djqmXORihl0ctYit5FFXAK+x+i6UubRTQUF2CrFlqjErrq+68yy0HCareQqGhi9tPSiPoxDxvJIA0M9bp/Cl3B8R3io6jHDnVfDNd3HNziN8/LsHONxnzv474jjwOh4/3lAUmDzjid/3X8Z4rehRCTzrhGEMswiezYZI3OzWbzghYbxaUTFJNY4M9donZCO2loiBV+rgr6+ZagTR1glAzaZb37kb3nRLCtj6pP7WPERDjKMTmRiBRbn2UPI3RY5j1i8zSJOyqZNTA8JIYVA++VJZI9UoGa2BgsFI2eTKZ21i43CBt99V5fbgNB6MTgCgZU6u+FwpAU1eJI756MDZOJHBxOx3gVTAzg3v4T3u3xKgwdafIacrtCkSnnAxSJNYXfb3PKBsYFKpJSLgoaiFGrrMRsOUcsIWZcyd5svme7HJ8Un/JWIM+29LByeF5NNK75iBFHwqSqotNCugmxiuWICbGRH9YcukLG1FimVxnXhKjpHB9JrpBjpXPkuAzpLUeAEiDWfVkibkQ0WDlpJhHbvLyVifaYg013pbWDpcM/L/wIs/gC0rJlsUxPEDjG2H+iHWldKnfr22Lz1ECbzuOtym5fg4+d7UvIvBbDRMLrQ5Qz3Igj7BTDQE218EQCfolRd0I5MWRdq5UVryOt97WPpNxcDrpMvZc8WX+FxwGY8tdhKmFOBORTSNLilOsijXogoRKjPhEKMy5bbfl8yclwFeNCnKjgMnMA2P3gDA2bXrAXi+uouu63NELrZl2YTdwGcqZjojwbZsVuY5sizeFzOaAJNKr23DuFJnnZQLWE0BFGejYbTAomAoSaqxYOhsHRXzYbSPEqLwqC7BsmS1l5utRIiv3fjH/Oqu1yRzGkfYmqXjBoyWc+Kakfeoiu5ypE+q8fGlbirCDxyCTLPzONUYVy/mZUGCEXS5nDvZaD3EyMgoRnEg/UzgHDPVGOc0pSsAACAASURBVEehvpfrdh3lfdfek7xm4mEGHVythKvm0YJuWnEJFOy0uCJEpeCLc2154apU40iwyEzDZqxiUjJ1AlmEEMmewxeWxHdka8nhDOUA6px04bdqYNc5PC0MYR86+pPh8XUceB2Pn8wwigJ0/WfSmdlIUo0r2CUjD4uPcP7s53mk+EzWT07CiKj4nI5GEuF7qVRhrRgq9QKvgqGhq4pw8s8UBZy3fTOGpiTO47HOS8l4hVEcAU1Px/lkgFdxBPKD5A3xNd4wMcaQ0maLmt7QYuA145cpRV2UwKWsiwbnlUjehMq94noQ6cMWvXOWNzT+7GfPYH+0nld7f4An/ae6+Yme95WiDmFeVggibuKROcAPo61MTH8LgIfCLT2f0bY8FwpDGDKVmjc00KR1R0HMxT0dcZPdpkyjKjCliJu4SDVqkK+yrvlDppRl/nnjn/PN8FkAjHb3sRyVhTGuBDOHvGri55ZEds7j9MzpvwCaieY0kn3FsadTTs69Ir3wPNXs2c75J0+xY534Wzmvp6BjcS905nnJpZdwzx9expkbBln0VjBecqwnhSJtakRiUT/9RW+EEy+mroi5bVJK+ziOngxEvG7+Q9CeJYoiysspq5BXBdv5pV0CXLiF3m4RbqRzNBDnbosyw1xuc0+j42bQywBvH9Vpv/Cv2P7K9yTM7u9ffbtwku8siIpGReFI+UxA4dBylzrptfZDXfgL5kmB16wvAGis32pERXbHFlS+lVRLDiutZHFerywSHbgZzGpSnXkoGqfrBhyRKbl8kOrP4n6gcVSVLnXpDL8xA7ziawxEan2UBsNFg2pep9MQ452JBOM7oHssyfRuydQY1lM7iRlzK6EpAY3UcR5ZSMegHb07+XkhygCf1ix/oX+SM5q3ChAhK4onCvSkGruuz6996gfctGc+aUoPoEhNVaQXRKrR8hIjXyMUoLWk2FyV+ygFe140NV9xLyBXkqnGXrYo8FJgNFS7n6tu2Y9tpZWXecUlH1l4ehFXLaL5FnSXEmmC4aXjXDYmk6ITyw16qhqPRKOM0EyAV9nUCBxxDbR1MffbPPFQUuoewVR8ohjgyeN354QB8EM/Ieaqx4HX8fjJjNNfCRe960ffTmkMxnesZtn0Akzfg6ZEbH/TZ1BVBSZ28PFnfJl7ou3kpVi7n+1FHKOyJ+SA1HopisIJoyW2jJQEiJLGpM/avpm977tC7AMSt3bVlMBLUVenVvuk/lbFb+2B33lUgBTS9kgqaQpAkQxawjB1FikbER4auiGBR2k0ZQblmJXCIBFqb4UocPHJY/ztlWdzxvoBBgeFHsQ3yvC7++GtYvEYULp4RgVfyyfGorpZ4gfhKShRgDW8g9vCTDrv8j+BX/hnAHISeBVz6fwViiUGCgY3zIsF6c07fH7zspMT24uZaFgAoIwRcGXrc3jtxTt4IBLC8KVoQKRUZQXfwW4uSfslDEM/sHvaz4oWUjJi9vLBcDMPRptTpik2e9XyPXq5n392mlIvm1qaanzsVjHOzWczUja58KRRWmSA+PJj0BTpk9h+QoTCqSduAaCliHE1o0JSaRxf5zuWv82r+SZN22eokTKgW6ri2oi1VWFpBfDC4HCQ6nwW8psTd3jIsBwbn8PBCz7EZW/4EzY895eZ2nZ2MjeR3eIbu2egs0gk04x1mYJrWB5exj6ykxN/N0M7AV5xKtItiXTwQjRI3ZXXod1MigEE8ErTqErow8W/l/w+rLToOD5HahaqArrbgCHB0prKavPSzcvfp4Ddw3jllbRy8KFwM4YSMKy0WTdYwGrG1584hkHdJZYQFXNaIuAH2Js/LbX1kd/xIwspqLNk1SbAAiljqjkNrtRv5sTl2yTjJeZkMu/TXE4LCnYfaXDLIwt8YedhhkjBT05WYYaVKXAatLt2ovGKY5QMK2YU+wOvPnYSSqZ36obDX6UwuzOxkgjQyONSxsLVy/haQXR+6C6tAvsAs/o6yrKjg+i0ECapxsPheOKjNlYWjFckGa9lRVyr1a6oTtGWBADT7BptxyfsCnA74gjGyztwO/zlqTCdMnP/HXEceB2Pn8zY+Cy4+Hd/9O0YeXjLHbD1ktWvA2w6v6eVkDayBYByOQZea2vZnrt1lI/+yjM4Z1O6UH317Rfw1kvkYhunDVd0BohTjVrMeJmVlNmLKx37iN1XRWx1IMGRkZefyVVgWIxBidMasa6ms0BRj/DR8H7pc/DiD4oOBjHoiBfi/CDfeMeF3PI7z1+125edtY6vvv0CctI7y1ELAryNCp3TnnAjXbWMrZWT9jtGocgdodC8NM56Y6KhA2DTc8UYAEMeSyHDeClGga1jJQ74oziRweXjdX7pvI1MJozXMEWp8QJYiioMDY/w+y8+ldn1LxDbVQLUwQ3JLg92cknar1PZsnrOX/IRePWXxBjkYg1wY/BM6sXNvMN/O6CkgEcuViMD1Z7tKJnK1bJpUI/PwwEBvGKg9NIz1yVpx6CyHmbvl2NasQgWhgSoB5qaAKJtihnG6yR4823UB07lPPVhFtsOY+3UJ+rkkgADcUurOHUVSE2ei84hL2Vclgon8Mhci+t2iZT8UlwEcM7r2HLZmzAHBNtZzGkJ41VWbD59+2P47Xk+vatDreNS7/ZaH+wKT+Tr+ZeiyutO8TrQPEqAyjKi+u/Cc84GYHzdZt73S+eJD2aq4sbUFiXF4dHyeVzsfISlN9wBz3kLnzN/hTvDHYwrdcF41bpMVkwUqw7DJ7BW/EnwUX5Hv4YtyiyNaPX3/uFI3CeGomUmB/L4HSF2n5WM17BmJVYKBUNP2moBPKifnp4j+TCXI52T0EtBWg/jJaMUNHsYryva/87Hlt7E2X/0DbrTD9JxfXR8/tn4IBfLnqAAw7IS1iuI8xQ6rVWWL4k9yXPeAj/3D6uBlxGL63srlhUnBWwnW7v4sPEPCUtlGwMCeCkWgV7E1wvkQgusOlZhdZr/qDpFiS46PpYrqxrltg5HY4woDS5R7+Pc5a9yFvt4/eKHAGhowz3bUaQOzfTqvPLvb6fbEFTpFnWW9YMF1MU9whuu3MvS/7jjOPA6Hj+dIT1g2PScnpeHS1IwX5E3v2MwXpqq8IpnrE+YLBApsqTyMGav8iuAl0w16jFQygKzGBAaTwJ4ZfYJsHTCy+D574H/dxcMC6ZHNcQYlmLGq7tISQ8IFJ3K5Enw7N+QY5DASwIgCoPsWFdl3eDax6+aYoxJX0lFYfqNu/lF973cvVzgMbuCL1O2uXyR74ense8l1+Cc9svYZFJWQ2m7ppjxMnU10XhhFNg2XiZEZVYdR20cZqSUY52yhBdpLDJA0dCSeTwcTbB9Qiwe9jah89qizKJs/ZlkP493U+A1tv25gnXMNlE/79fhJGltIecS4K7wFL51ydexqwLYJpWhcQVmrtDLnGUMgEumxhIVWoX10DgEAxuTKt/JgTxNaU+hjMV2Fko6hmQjqRi+rQ7QigoYup6Ab7GxM2ivu4AzlQMs1RqM2IdwJct0YlGwHa6cf70qFsGuOZG8Ph2kjIs3LMD0O66+j0bX40bvdD511r/BM17VMyxFURLG68JNJvun59BDl6NemZ2P1xLReRyvcP+Mfxl6W8r6ul1YfIRZdRIXQ+glBwQLVB1dz46NcqHMaIQm9A5FbEKjxOPRJJ3SFlBV/p5f4mHjNEZoYB19iP37HuH0cV3ouYZWA6+wPEVdVkdeqN7PNuUoO2VD+mxMS1uNwbDB1ECeUNplxKnG3z762zycfz0g9Zxuh5o2yp8W3sX39OemwEuPBfLpnKh2mnY87zSx75iVBKmH8m1xvagG5aDBkNLmMu9mip98LtbcPrYpR/kZ7YdimiSLG6cdu1LLp7mNHof6nth2GQxsgI3PgZNemL6eK0mNVy9TpkrPtnfwu3zOv5QJrZkck5sbxFQ8Stj4eplQL2JGNtgNOuYKyx/gMOI6HKCD7QvgNaiLbhJHGWFYafMb+tfY8ehVvMi5noFQgL7Hi6fxYCi/t1NpW7yS3+CxuTrlWAOozPJzZ69n0n6MMFf5/9s78zAp6jv/v6r6Pqane46eG4aZ4ZiDmeEYblRAPNDgAVEMG9fIBqMmUbNxzbG7ebKbJTyu2cTE/SVhYza6q9HETUxWgz+SqBsjEPGAXwwxIoLhZhhgYC5mprt+f3yrqqvnYIZrjuXzeh4epruqq79V3+qqd33OVImTYUKEl3BxclA1E6ZkZtrbMVN4RTLNm89pLF4D4gzQdmClRPuD5vtO4eX2K9GlD/6n6TfLTgSzi+CyB1TBStPF4/Kqm6GdRdh6hEm5AQL+HuULLMuK9SQY6JFW3ge6KdbsQqxAvKCYFoLcf+ImHsn7RyrHqAtqSTyb/EiAaOWl+L1uOpzxVaHUhTgW9JIV8iox60oJr3KzH+gxdxya9+DWYKrnAw4RI+j1qPVNgVtbW894U3gVlE/mF4kZfDPjPqhaan9PF26OW3W4iqfDZ9+D4n4ySR3Cqw0/Po/OuBz1WauUCLpLzZs73dXozG4N+9wY6Lxbrm7OPd3fs6tMsZxjCq+COohXpo/F0ffwteAlPJFYRFluuHdpl9K5yp2262UyEsfZ6VJCcUGRWs/tNeMMC2ohZyJHc1SD907cdOKhWYvQooW44+pZrL1RjfP1D46SSEJbdHyfh8myeN1QFeFvL1PjPK5l8sYHx+xSDYBdByvodeEzS4XQ1QqNf2K/R1mVMvweiJgWynBe6oHEkRWXo6sYL+s8PNCsrB0nO7rpCubi0gwmrL+Zr3Ss4Y4ZpmWkD4uXlpHHUu+j/KD7Cibo+/BoCbY4hNemRBVdudU0BdX8hIxW8iMB3J3NJDS3HccY7lJjK9EOEfS5oLOFbk+YJ1umcaLT0eTctII6hZe7IyUoc/JVjbkdRkoc+E6YdekCsfREIU1ZM7uP72OCttd+37IWZaPcgW8cNcMiaLVjvHph/Q4XfB5ueiz1vi280l2NLjNG65QrQyW4GG22Na3bF8NnWryS3jCGJ0jEOAmJU7R4Ha7GsfPYGprH/qS63sS143avxoirm3a8HDVdr9XabrwdjYStQq/5k3nfVcq1XV8l8cXDUH1j6njSzUR/qvxGjf8Is8qymaDvpSVSce6xw+eICC/h4sTMZqIo/WabbQqvWGYE0E5r8RoQd9/Cqzw3zA8+1sDsScW9l7v9g4vvcuAzg+utSvqAbUlxmRavo44Yr3jIRdDfo0yHJRbC5sXX3382p4XuV+M8mUxtywqObybMX141m5Dpsi0ryGXzFxaRE/bhd7vS66M5LoKr5o/jp3eZ/T4t4eVOCa/WQAE074Vf/T2zjG38uPtSxmSnWw51x811Ql6Yu7ru5e3cayFWmjZ+O8PQn5mqrt4XDotcKyqd3eogYLsaQc2bRzXVtstpOLJbc8I+NA2axt8EuZW9rFnxyrnK7WrNxdg59s1wv8ccg8Pi9fuMeazt/gjlub2to8HyOSQNjfjO/wLgA58SS4UeFRszvULFCoWyi+CTr9GWVQ2krCyHtFz2uscS8nu4prYATYONO812L570UiEWlsUr5urglmolDjKy8nnzg2N2jBeoOB2/RyfodfMXs8ZgeILQ0QxNOznoVfvptHgRjqdc8Jar0e0nZmY15uVkkeF3853/2cn3Xnmfk6e6McwHiMxkM5P13UzrMNssZZak5sbsEqEFokwtz+cPZkcLgNeSqXIdzydn0rHqf9BMa3DIaKUg00+ENjr0cMria3KZvk2JrM5W8IZo71Luzp4xXis9L3ObWyWbeDqP8wvP5TxU/IhtufljMhUCoVtuy0AsJUKBGn03AJ0njzJe30sCnWPxmfzYp0RIlpkV+toRdW3I1FqJ6QMIL/P4JlDjfWrbUZJus5yEkYofdZllQ450++1uBKVuNT+ecDZ+ugjTTtITwvCE7FiyZrejhMnUW/nP0jXs7FbHtlQ7SEdXks5EkkxXJ2347OOeobWjJbsp6XyfN7Rq+MRvaerQiPg96joXTHc7FiWVe/yYlkmpsY+qaBcTtD3s9/bvbh4qRHgJFyeL/1HVFOshcoqiAXxunUkFEZWan13RzwYGgR3j1Tsz8rKJcXymcElbXnWd6ql5BliFVtN6VJoXIbdp8TpBEEP3QMtB2P1q7/3y9YjxGoTFa2qFEo6zK0vT3rduzLPLslMuU4flJzPo4b6ra/vcZtjnZqwlpGxXo99undQZLlJFHbc9zWbvLB5O3MjXPmy6GMwSFk53UobfQ11JlMlF5rJVv+Tted8ClDhUnxtAZDrEU7vhw+9x2Y3YuxOOOmD+qBJNmpZyNzqyWwujAf77k/NYWFMCd2/uPc/1H4Hb16e7wc2bYWHlLGXpcMSmGOZN0Do2TqJZcd6jiOJGVb5jv9+0opntk1ZdOoln755r1+Nzm5mjVuzXl5Or+M/sTwHqGI6Ph23hZbvMemCVYNE7W+zvKSgaw7a9x9PavYR8bkqzQxRk+rmqpgBvIEO1Bkp2cdhXan8n2ePVb7TsMofFy3TJZZaQmTxOiA78oQi3zh7LS39q5CvPq0xQb7RHh4ffqJggAjEImPNtWQ/9UWaVZbPddFm1Gb40EXbSCOD3uPCHzd9ERzP5mX4ytVZOEEqz+IISXgGPCzrbcPnVb/tERzehHjFeN+u/ZrVnPWDg62zmUCJCY7TOtmi9axSzRytkl+GIiQrE0n5LFZpKwOhqPU6d9wCu7HJid23gndyrAZVgAHAgqa4HEdrIcMR4WeJKHQ/Hw4emkTTP4Vd2t9Hc5VFJDQmHlc60eB3q9NkxpKsmm03vs/Ps4HrDG0bzBu06eM3Oor2BKCGvi+2d6rpTph2goytBTcur5GjNdBg+9HC6azK3cw8HkmoOj7V12RZUAunCqzChjk3m5Z9FS5wi6+UvkKW18MfE8LoZAUd6iSBcTMz9tPrXg+ywjzf+brG6SE76XR8fPANsi1ek7+WWNS1NeC1Nc4kNBquchFXeArAvQparETS0UA78/hlVNPKqr6ZvpJercWCLVySmLoh58fQspV//9aUYqLifni2bLG6/ZAK8NMAXeFOWrJKsIDNKs4gXl8N+oPUwk+auZn3NJVQWROz1gF7upJ/dPTf1omQGGcFq+NXLqdIO/t7BzP3Ril8JLzOj1Sko+NA3UiLOG4JTzb0KANcUDeK7Lvmsss5N+hDsM4vhZhTAiifTCg9b5QQsa6ATXdc4HKlhwknlfvIUT4Gj2ILI7Q1Qn5eaY4/5ENCtqXPo1Y5S4rHUDaq+JMqPXlfbCvQjvDZ+fjHJR0Iq9qdVBTWXjS3l1FsH2LY35fbJ8Lt57GMzbEstnqBdpf9IsNReB48fPvpTtU7StFBbFq9YKcGmHaBBty/M6lnltHUmWDK5gF2NrczJbgGlwTiSP5+cg6+oF4GoEi9tTUrUth6GQJTZ5dn8vVFMl+HiHaOEbt2H4fKiJTrxhaJ4XDp5ubkk39VwdZ6gINOPQSvHkgG6evRcnae/jau9CTpb8AdTv42Uq1GdEzoG+RwhV29BJ0Fjd0i5rs3z/rARZXH3v/Bxz//lr5Nm8dxALO23ZAXGG+3HKdf2QFxZ8HOyY7A3FVx/yEi58pxB/W3uKBndTeq8daeXV/EEItDZTBs+/nwySQx4ZfufmV+rrKeeLmU9PWEEOGqGMmScUpmWWjDLHlvCk4Gupa5NzVqETsONV+sGf5SQz83hU24O+LIo0w9Q0vU+Dxz7MgDvasWqVtcR0tiXiJJIGhxv67QLWacJR5T1DEAvnQdTb4U3fgDA5pY8bmB4EYuXIPQg7HOfXTuknpzG4gWkYjX6Wz5I/B4XXpdu15QC0lyNDaUx/vG6amXlOnlA3cQnLknfiDWGzCKV5ZlXw4DkToKb/iM9EBdl2bFKZlj9Fnu1R9I0lVH5id/SL6Xz4JanoHAKLl3jR5+YTXVltb04Om5KSnSBylydcUcv93FPrLEdNGKqplC4d3p7f7TjJeBxsahSfebqyQ5rxNg5YDaqtkVjX22hBiIQgxkfV3F+lhCOFKn9c2Tg7jELfvZl8QKIVMwGVCmRRTPr1Zum8OopCL2mxUt3vG9Z9QCmOjJ3/f24GvMz/ei+DFW53vye8eNKAehKGHhc6jcV9rnJDHpS2/EGIanEQHNAieaIv4dNQHcpC6gVXO9w/7r8YTKDHr70oWoaSrO4qaGEeKFafsDIwjPJcX76oylxHEpZvMZkBZk5voADJdfwXGI2freOZlp81tyiXN93LhhPlztEZUzta0Rr40giQMKdirl6r3QFPq0LXv936GwlEM4k0yy0nHI1poSTbiSY6lXtkQ52h9RvOF5Jx8Qb2JSspqMrSZfPYcnpYfGy8HUcpiBxULmwgfwcJUKyTVfjIdT8WVX5T5nN29utbYd6B7xb14Q2w8/GP6tz7bNPbuZrG/6EYRh4utS2Wwhy1KrNduRdNU8O61O7FrATcUDVZbNDDQIx213/frKACtdBZiXfstft0gNkZPXuT3vIyOJ4m8qWtVq3Wde8FrOg8zhTeBGIwZVrYPoqmgKlbDiWr+rMDSMivAThQuH2qSKw/bU9cnnURcrfj0VskEzKz2DKmGi6WLSe/tx+fvyJOXx0dqkSMTf/p/rf1ePGVjQNrviKymy69/eqjtpAaJqyzrlP010gVqou6n3Fys284/RdDHQXTLw6PRA2syT1d16Pz4bjsOTBAdtMWVmnzydncWjFerukwmm54zesL7gLAx2/R2dsdojda69hTnnfPUdTwuscW17FxsJ1/wdqb+q1qMt0c1qB/j2ZMG0RAMf9xRTmmQKuP+EVtLIyUzf1HEeT9rkVqf3sz9UIqJu1ZfHyZlASj9kdHaykkrQHBEi5o+NVYFreMvx9tOryBNIsXhZaH/XXvP4gzUaQt5PjiIxzCHHL4gUpseHPRNM0/mPVTEpWPc5jxhIlCk3h4Q4qoeb3uPCFs3B1niDD7yGqtdJshEg6hFdFw1VQvgi2/BucOonmDVFlPhwEPb3j/gCmulXg/DEy1LHyhvCt+HeSZguzpN/h9vdH+/wtjT21QxWOzVVJAQWW8NKVxeuYkUGX4bKLw+43a491+nLSj0XaQVTHtcvl592jSqhcV5PFt158j5+8uQ9vooVWAozNyaDLa4rZ4x+oc9aRADC5vBi3PzVHzUaQds0SXlH7PNtl5DOOA1yibbPXLS+K8/HFdSR061xU14JDRoym1k6OtXWmYlvNa16rmXGcJry8Ibj2X/jdkhc4lgzy3uFUrbPhQISXIFwo3P7+3YygBMUN3znjmK6e/NX8Mp6+Y3b6m5alxBnD5gtD5YegsL73RlxumPOpc0sm6Ispt8I9/0+JqPNBpBDQ1I0i49xq8XTjxl08dXArF9SxbcxfAv1bfNKwxMC5Ci+AKSv7dP3+8/JaFk2K9zsef2EVCU+YovIa8yHAZ7sAe1pNAmaHBnea8EqN3dmbtb/gesAhvBohlIOmabbwGJejjkm4pzXL6hIwcYldFiOjpzizxmxlNToTJfqpefd3XR/jm903oDnFvTcjJbwcpVMsNE11mHAKrzSLtD9TJQIc2k6x1sgJI2TGn5kPB6FcmHCVikNsPQzeMOPzzFpl1vNDj99YDaqo7zEjI9UJQdOYOc60GlkPUZo5Jk8qfMBibFK1zLHqfJXkK0GVZWY1tuOlVQ/bwqvJbTZ1D1jCq4/kEnO/MyJRu8vD5y8fQ37Ez0t/Ooyvu4U2LcSG+y5hwxeuT30uNi4tAcATiODxp47hsWSQU5q53B9lgpmBvMsoIEILc1ypgr/+QJhIwIsrHFdWNHPODhoxmlqUxcuO8fJHAY3OWAVJQ6NEb8TQ9LRr8PSxMdbcMJm8yFlYos8jIrwE4ULh8Q/sRpy8PK1cwXkjdyKs+KG6CQwnup5yN54P3D4lKvOqB173NFhur0GJKBPLcjM44WWKAdd5EF798OHpJTx6W0P/K+guXH/xDIHFf6te+zKg03zS79EDNWR2aigvSN2Ana5GSGX89uxmkIYlvNqO2FaU6kIV12ZlX/YSVVYV8UlL7GOb0VOcgfo9mVXr02qu9SO8wg23cMv116X/BnXdYfFKuRqdBLwuFTdpCy/Hw5M/E46+D9+ejYdumgnh83hSYwjlQsThGvOGGG+6gt8/Yga19xC9k5Kq2voxwmmitKFUjbMxaW47EFPqzXJVOq4bcc2MoTOttwWZQdoMHy6SJNBxe7xEYjlM9CuLoTurFHA0uO/T1ajGnRWN2n1Bta4O7s3ayJ927sKXaKFVD+Jx6Xh9vlSsZNa4NHcq8Sq8wdQD4NHuAJ26X1nF3F679Mt2IzWnVrFl+9oRzoVoiV25/xAxDp3ooOVUd8ri5XLDjes4UXs7zWapGMMXTSvNE4/4+cjMMb3O7aFGhJcgXChmf1K574aLSUvOj8VlpLHkn2HBF89pE8/ePZePzx+XyjQbBLPKslgwMTcVU3I6vCFloejp0h1qxs5OxUM5Xdo944TMG1w0I3WDdFq8AP7mKuXGimecxlrgy1BtfVpTwqumyBR18TAuXbOLFNtYDwcFU1IWr75cjU6B5Ih16094rblhMh+Zaa7nzOK1hFfRdJUxWZwuXgMel4rHsqyWPYVXo+r7t99fzn8l5iuxaLnWQrm2OLDGdvXkAuIZPm6dXare63Hss5Op5uDO8iQNpsXrj81W1p45bsualK/iMLsNx23cdE/quqbEDZB0B7hpegl6IGqXgKgyYyXLxpWlxt0TM+EmNysr1XLs9z9ixcGH+ETn90l2nKBNc1jULctcbFxK7NSugKxx+ExXdkLzcKLbRacesPfHsvJtSlbxcNl3qez4PhsSpnvYqpY//7OqHZRp0TtsxHi/UT1EpP0ea28ilD/eTpzRzqAe4lAiWY2CcKEomTHcI/jfyRlmffZFdWGmbYkZLNPGZvHvHxvknHqDZxdYfyFxCghXmhtlrAAAENlJREFUD2Fjxll5+nE1AtzcMIYbphSf3uIVjsMHryqLWpFy486ryGHqmChzK3J45hOzmZjfwwp80+OqOKeun97ilVVmtlLSlACy3H6DaSh/xyspl6blWowUwq0/67Vq0OtSRYl9GUpQOcWzPwJmL9RfTfoHdm7WmO7WlfhrdytxmCa8wuSEfbz2xctT7znPC7P59CnDzQmCadbASfkRrq0tYOWMMfBDb0p4uQOqBlm8Crb/jA+MPMq1A3R5I3gc1uVQOAInm/H4gvzDdTXwH+Z+6x68BcqiFIgVql6pk67tfcxMi19eTjbbjVK6PBl43lCFVQ10fN0n6Qg4YhyD2coamDUOxl0C134d6leqTZkW1WYjyB8PnqTTFYBAylWqa5A0NNpy62jnffYYphu4VSUDUGmOb8/vMA6NpfOgh52NyoIYDaYL+WjQw7cTC/i8/kO0c7SMXyhGphwUBEEYzeTVnLM79LxjWbzc/t6Vu02rkctsY6Vr9LZMMYCbEZQLsP0YtBy2rSjxiJ+f3DWXomiAKWNiqbIKFm6fLYZOa/GySmm4vGr8Vs25wXSX8AYdlq5pqkZYRu9sOVD7nRXyKqua06UJaaVHgrlqmd9jWseCOalMVLM4a5/WOF1PuXprltHiyuRzXR8HtDRXo0vXeOQjU5ldkaPim6zxZ5er82vsHBqDFbxtqExQV48kEU/A6jcbSB970VTIKDTHF4a596SVKbHJLodIEQ0VeRRnhUmWzrfFq8vlJoM2OnTH/jktXt6Qil212iOZWbPHkkHcus7O6k+pTEMTK/HCEp57DNMC15JqWA7AZZ9H+6tfEw167AD5WA/hFfF7+Lfkh/iQ93uw/Pu992sEIBYvQRCE882sO9W/kcQpM76rL0HoC8OHH8M9Zjb6+tfJCvlw6Vrv9QbCLvNg9O2+GgCrGHDfFi9THFiWq3AcmnYMrqG8k5IZ8KnX+138tZvq1L77a2DevekLLfHiCZGdHQf+rMSiFgTM/XW5lShsOdj/2NwBVYz0qq/ykHYnP924W+1SX0kFoJJizCb0zP8MzLsPNI1nZ/0YY4OK4dMjPYRk+QI4/IeUeLGsnGPnKvF11Vq1Tn9MXwVTb6XW7eM3f7MAtuyEHb8AoNjXRmZHK7tcDuulVZA2NrbXpqy2TuHMLDZ9ZmGvcj2r5pfxd8++TXFMCTDb4pXTo9CzJwCeANkhL7uOWBavdJGu6xqZAQ+JUH5ap4eRhAgvQRCEi4HqG5Ql5pan+ll+PRoqxumsg4+dsVdnIbyKYgG8bt1uyZRGT6uMlZU4GFfjGVCQ6QgM9/QYhyW8MosoMOvB+T0uqPowJLtT60UKlPDqr9m92wfdXvCGmVeRww9M4dWnpQ/gmofSX5vCxevWaTRMi19PC97su2HTI6rVD9ixaZTOVVnGAz0Y6DrojvNgwlXw4j9BZytF+lGytBaaPY45rlikWrH1lRltWiXzcuN99kn86KyxLJtaxLuH1MNBG35+XPs9Pnz15b3WBdWlY2djK25d67OOXSzoTS8oPcIQ4SUIgnAx0E+3hp4EvO60Gl5nRLQ09XewjxIFA3DJ+By2fPFyu+hoGlk9hJflajxTi9e5YMXJZRZTEFECw+fWVcFbJxkFwFv9j83jBz0bNI3Lq/L4xafns+Pwyb73+zSsmFHC+42V8Ba969FFCmHRl1Kvq6+HA1t7JRMMmsxieGAX/Phj5G3/bwD2JR0JDzU39l//zzoOp+kSEfS6KY6lRFtT9tR+W5dlm+dnVWGkzyzjj80bR/QMj+VQIsJLEARBsCmOBRgfP8tuCsEsZYHqbDkri5emaf2Lj55uo9J5cOjtoc3ctYRDpIhIwK0C8fvKjLWsT/26GtNr/FUVRqgqPPNCyj63i8pxY0zh1UfM2vzPpP6eey/MvLO3Fe9MCeXgMlSngT+cHOR5MgjhBSqho6E0xpbdx3CdpnuIFX/o7Kjg5KOzers7RxIivARBEASbJz8+8+ziu0C5kaJjVWzRWQivAbft5Cz6mp4ztquxBE3TWLus1q7TlUZkAOHlCZxRj9BBjWmggsKadu6iC1KxXMC77YN08+ou9bnIwA2ql08rZsvuY+xvbu93nWwz43bKmIF7yo5ERHgJgiAINr2yDs+UmCm8zsLVOCB3/S6VMTgcOGK8AJbWFfa93pjZqnZYf+2oFvzt+esSUVALhVPP3oV4pjiq3JeVjR/851a/lCba+mPZ1GL2H+/g5oaSftcpzPSjaTBtbN8Wr5GOCC9BEATh/FE4BY7suDDFY+OTzv82z4S8GlXIc9I1p1+vdB586o3+l0+44vyNKSNfiZqhwhRPSV+Eb912yeA/50y8OA1ul859iyecdp3rpxRRU5RpZ0GONkR4CYIgCOeP+X8NcwYO4h+VuNyw4AvDPYrhxYy10yNFZ9Ry63zi97ioKTpPrtphQISXIAiCcP7QXeevKbow8rDchZF+3KzCgEjlekEQBEEQBkdIhNe5IsJLEARBEITBEYipFkbxquEeyahFXI2CIAiCIAwO3aUSB3xnXndMUIjwEgRBEARh8ASzhnsEoxpxNQqCIAiCIAwRIrwEQRAEQRCGCBFegiAIgiAIQ4QIL0EQBEEQhCFChJcgCIIgCMIQIcJLEARBEARhiBgW4fXCCy8wceJEKioqWLt27XAMQRAEQRAEYcgZcuGVSCS4++67Wb9+Pdu3b+eHP/wh27dvH+phCIIgCIIgDDlDLrxee+01KioqKCsrw+v1smLFCn72s58N9TAEQRAEQRCGnCEXXvv27aOkpMR+XVxczL59+3qtt27dOqZPn8706dNpbGwcyiEKgiAIgiBcEEZsy6DVq1ezevVqAHJycpg+ffoF/b7GxkZyc3Mv6HcI5xeZs9GFzNfoQ+Zs9CFzNjLYvXt3v8uGXHgVFRWxZ88e+/XevXspKio67WeOHDlyoYfF9OnTef311y/49wjnD5mz0YXM1+hD5mz0IXM28hlyV2NDQwM7duxg165ddHZ28tRTT7F06dKhHoYgCIIgCMKQM+QWL7fbzSOPPMKVV15JIpHg9ttvp7q6eqiHIQiCIAiCMOQMS4zXkiVLWLJkyXB8db9Y8WTC6EHmbHQh8zX6kDkbfcicjXw0wzCM4R6EIAiCIAjCxYC0DBIEQRAEQRgiRHghLYxGIrfffjvxeJyamhr7vaNHj7J48WLGjx/P4sWLOXbsGACGYfDpT3+aiooKamtrefPNN4dr2Bc1e/bsYcGCBVRVVVFdXc3DDz8MyLyNVDo6OpgxYwZ1dXVUV1fzpS99CYBdu3Yxc+ZMKioquPnmm+ns7ATg1KlT3HzzzVRUVDBz5szTpssLF5ZEIsGUKVO49tprAZmz0cZFL7ykhdHI5LbbbuOFF15Ie2/t2rUsWrSIHTt2sGjRIlskr1+/nh07drBjxw7WrVvHnXfeORxDvuhxu9187WtfY/v27WzevJl//dd/Zfv27TJvIxSfz8eLL77Itm3b2Lp1Ky+88AKbN2/mgQce4L777uO9994jFovx6KOPAvDoo48Si8V47733uO+++3jggQeGeQ8uXh5++GEqKyvt1zJnowzjImfjxo3GFVdcYb9es2aNsWbNmmEckWCxa9cuo7q62n49YcIEY//+/YZhGMb+/fuNCRMmGIZhGKtXrzaefPLJPtcTho+lS5caGzZskHkbBbS2thpTpkwxNm/ebGRnZxtdXV2GYaRfH6+44gpj48aNhmEYRldXl5GdnW0kk8lhG/PFyp49e4yFCxcav/71r41rrrnGSCaTMmejjIve4jXYFkbC8HPo0CEKCgoAyM/P59ChQ4DM4Uhk9+7dvPXWW8ycOVPmbQSTSCSor68nHo+zePFiysvLiUajuN0q4d05J875crvdZGZm0tTUNGxjv1i59957efDBB9F1dftuamqSORtlXPTCSxidaJqGpmnDPQyhD1paWli2bBnf+MY3iEQiactk3kYWLpeLrVu3snfvXl577TXeeeed4R6ScBqee+454vE406ZNG+6hCOfARS+8zqaFkTA85OXlceDAAQAOHDhAPB4HZA5HEl1dXSxbtoyVK1dy4403AjJvo4FoNMqCBQvYtGkTx48fp7u7G0ifE+d8dXd309zcTHZ29rCN+WLk1Vdf5ec//zmlpaWsWLGCF198kXvuuUfmbJRx0QsvaWE0eli6dCmPPfYYAI899hjXXXed/f7jjz+OYRhs3ryZzMxM27UlDB2GYbBq1SoqKyv5zGc+Y78v8zYyaWxs5Pjx4wC0t7fzy1/+ksrKShYsWMAzzzwD9J4vax6feeYZFi5cKNbLIearX/0qe/fuZffu3Tz11FMsXLiQJ554QuZstDHMMWYjgueff94YP368UVZWZnzlK18Z7uEIhmGsWLHCyM/PN9xut1FUVGR873vfM44cOWIsXLjQqKioMBYtWmQ0NTUZhmEYyWTSuOuuu4yysjKjpqbG2LJlyzCP/uLklVdeMQBj8uTJRl1dnVFXV2c8//zzMm8jlG3bthn19fXG5MmTjerqauPLX/6yYRiGsXPnTqOhocEoLy83li9fbnR0dBiGYRjt7e3G8uXLjfLycqOhocHYuXPncA7/ouell14yrrnmGsMwZM5GG1K5XhAEQRAEYYi46F2NgiAIgiAIQ4UIL0EQBEEQhCFChJcgCIIgCMIQIcJLEARBEARhiBDhJQiCIAiCMESI8BIEYdQQDocB1ZLoySefPK/bXrNmTdrrOXPmnNftC4IggAgvQRBGIWcjvKzK3v3RU3ht3LjxjMclCIIwECK8BEEYdXzuc5/jlVdeob6+nq9//eskEgnuv/9+GhoaqK2t5bvf/S4AL7/8MvPnz2fp0qVUVVUBcP311zNt2jSqq6tZt26dvb329nbq6+tZuXIlkLKuGYbB/fffT01NDZMnT+bpp5+2t33ZZZexfPlyJk2axMqVK5GyiIIgDIR7uAcgCIJwpqxdu5aHHnqI5557DoB169aRmZnJli1bOHXqFHPnzuWKK64A4M033+Ttt99m3LhxAHz/+98nKyuL9vZ2GhoaWLZsGWvXruWRRx5h69atvb7rJz/5CVu3bmXbtm0cOXKEhoYGLrnkEgDeeust/vCHP1BYWMjcuXN59dVXmTdv3hAdBUEQRiNi8RIEYdSzYcMGHn/8cerr65k5cyZNTU3s2LEDgBkzZtiiC+Cb3/wmdXV1zJo1iz179tjr9cdvf/tbbrnlFlwuF3l5eVx66aVs2bLF3nZxcTG6rlNfX8/u3bsv2D4KgvC/A7F4CYIw6jEMg29961tceeWVae+//PLLhEKhtNe/+tWv2LRpE8FgkMsuu4yOjo6z/l6fz2f/7XK5BowjEwRBEIuXIAijjoyMDE6ePGm/vvLKK/n2t79NV1cXAO+++y6tra29Ptfc3EwsFiMYDPLOO++wefNme5nH47E/72T+/Pk8/fTTJBIJGhsb+c1vfsOMGTMuwF4JgnAxIBYvQRBGHbW1tbhcLurq6rjtttu455572L17N1OnTsUwDHJzc3n22Wd7fe6qq67iO9/5DpWVlUycOJFZs2bZy1avXk1tbS1Tp07liSeesN+/4YYb2LRpE3V1dWiaxoMPPkh+fj7vvPPOkOyrIAj/u9AMScMRBEEQBEEYEsTVKAiCIAiCMESI8BIEQRAEQRgiRHgJgiAIgiAMESK8BEEQBEEQhggRXoIgCIIgCEOECC9BEARBEIQhQoSXIAiCIAjCECHCSxAEQRAEYYj4/3c7RA/oGBnbAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "total = 0\n",
        "correct = 0\n",
        "\n",
        "# drop_last switched to False to keep all samples\n",
        "test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=True, drop_last=False)\n",
        "\n",
        "with torch.no_grad():\n",
        "  net.eval()\n",
        "  for data, targets in test_loader:\n",
        "    data = data.to(device)\n",
        "    targets = targets.to(device)\n",
        "    \n",
        "    # forward pass\n",
        "    test_spk, _ = net(data.view(data.size(0), -1))\n",
        "\n",
        "    # calculate total accuracy\n",
        "    _, predicted = test_spk.sum(dim=0).max(1)\n",
        "    total += targets.size(0)\n",
        "    correct += (predicted == targets).sum().item()\n",
        "\n",
        "print(f\"Total correctly classified test set images: {correct}/{total}\")\n",
        "print(f\"Test Set Accuracy: {100 * correct / total:.2f}%\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ocKsKGMbq09_",
        "outputId": "2f06977d-629f-4d71-95f6-5b1cc61059e1"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total correctly classified test set images: 9434/10000\n",
            "Test Set Accuracy: 94.34%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RVM_CqEmq3FK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}