08.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Notebooks/Chap08/8_1_MNIST_1D_Performance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L6chybAVFJW2"
   },
   "source": [
    "# **Notebook 8.1: MNIST_1D_Performance**\n",
    "\n",
    "This notebook runs a simple neural network on the MNIST1D dataset as in figure 8.2a. It uses code from https://github.com/greydanus/mnist1d to generate the data.\n",
    "\n",
    "Work through the cells below, running each cell in turn. In various places you will see the words \"TO DO\". Follow the instructions at these places and make predictions about what is going to happen or write code to complete the functions.\n",
    "\n",
    "Contact me at udlbookmail@gmail.com if you find any mistakes or have any suggestions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "ifVjS4cTOqKz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cloning into 'mnist1d'...\n",
      "remote: Enumerating objects: 204, done.\u001b[K\n",
      "remote: Counting objects: 100% (76/76), done.\u001b[K\n",
      "remote: Compressing objects: 100% (35/35), done.\u001b[K\n",
      "remote: Total 204 (delta 47), reused 60 (delta 41), pack-reused 128\u001b[K\n",
      "Receiving objects: 100% (204/204), 8.42 MiB | 16.72 MiB/s, done.\n",
      "Resolving deltas: 100% (73/73), done.\n"
     ]
    }
   ],
   "source": [
    "# Run this if you're in a Colab to make a local copy of the MNIST 1D repository\n",
    "!git clone https://github.com/greydanus/mnist1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "qyE7G1StPIqO"
   },
   "outputs": [],
   "source": [
    "import torch, torch.nn as nn\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import mnist1d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F7LNq72SP6jO"
   },
   "source": [
    "Let's generate a training and test dataset using the MNIST1D code.  The dataset gets saved as a .pkl file so it doesn't have to be regenerated each time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "YLxf7dJfPaqw"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Did or could not load data from ./sample_data/mnist1d_data.pkl. Rebuilding dataset...\n",
      "Examples in training set: 4000\n",
      "Examples in test set: 1000\n",
      "Length of each example: 40\n"
     ]
    }
   ],
   "source": [
    "!mkdir ./sample_data\n",
    "\n",
    "args = mnist1d.data.get_dataset_args()\n",
    "data = mnist1d.data.get_dataset(args, path='./sample_data/mnist1d_data.pkl', download=False, regenerate=False)\n",
    "\n",
    "# The training and test input and outputs are in\n",
    "# data['x'], data['y'], data['x_test'], and data['y_test']\n",
    "print(\"Examples in training set: {}\".format(len(data['y'])))\n",
    "print(\"Examples in test set: {}\".format(len(data['y_test'])))\n",
    "print(\"Length of each example: {}\".format(data['x'].shape[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "FxaB5vc0uevl"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Linear(in_features=40, out_features=100, bias=True)\n",
       "  (1): ReLU()\n",
       "  (2): Linear(in_features=100, out_features=100, bias=True)\n",
       "  (3): ReLU()\n",
       "  (4): Linear(in_features=100, out_features=100, bias=True)\n",
       "  (5): ReLU()\n",
       "  (6): Linear(in_features=100, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D_i = 40    # Input dimensions\n",
    "D_k = 100   # Hidden dimensions\n",
    "D_o = 10    # Output dimensions\n",
    "# TO DO:\n",
    "# Define a model with two hidden layers of size 100\n",
    "# And ReLU activations between them\n",
    "# Replace this line (see Figure 7.8 of book for help):\n",
    "model = nn.Sequential(\n",
    "nn.Linear(D_i, D_k),\n",
    "nn.ReLU(),\n",
    "nn.Linear(D_k, D_k),\n",
    "nn.ReLU(),\n",
    "nn.Linear(D_k, D_k),\n",
    "nn.ReLU(),\n",
    "nn.Linear(D_k, D_o))\n",
    "#here i was messing around for the last question\n",
    "def weights_init(layer_in):\n",
    "  # TO DO:\n",
    "  # Initialize the parameters with He initialization\n",
    "  # Replace this line (see figure 7.8 of book for help)\n",
    "  print(\"Initializing layer\")\n",
    "  if isinstance(layer_in, nn.Linear):\n",
    "      nn.init.kaiming_normal_(layer_in.weight)\n",
    "      layer_in.bias.data.fill_(0.0)\n",
    "\n",
    "# Call the function you just defined\n",
    "model.apply(weights_init)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "_rX6N3VyyQTY"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Initializing layer\n",
      "Epoch     0, train loss 1.544955, train error 59.60,  test loss 1.628351, test error 67.40\n",
      "Epoch     1, train loss 1.320650, train error 50.67,  test loss 1.495759, test error 59.40\n",
      "Epoch     2, train loss 1.120052, train error 40.58,  test loss 1.341626, test error 52.70\n",
      "Epoch     3, train loss 1.042543, train error 38.92,  test loss 1.326929, test error 50.50\n",
      "Epoch     4, train loss 0.818978, train error 29.38,  test loss 1.178335, test error 46.30\n",
      "Epoch     5, train loss 0.731128, train error 26.38,  test loss 1.164463, test error 43.50\n",
      "Epoch     6, train loss 0.635767, train error 22.55,  test loss 1.116958, test error 41.10\n",
      "Epoch     7, train loss 0.587713, train error 21.07,  test loss 1.200288, test error 41.60\n",
      "Epoch     8, train loss 0.484744, train error 16.40,  test loss 1.149335, test error 40.90\n",
      "Epoch     9, train loss 0.427434, train error 15.25,  test loss 1.177496, test error 38.50\n",
      "Epoch    10, train loss 0.260235, train error 7.40,  test loss 1.077545, test error 37.80\n",
      "Epoch    11, train loss 0.198762, train error 4.72,  test loss 1.118553, test error 35.40\n",
      "Epoch    12, train loss 0.165190, train error 3.38,  test loss 1.157071, test error 36.00\n",
      "Epoch    13, train loss 0.134904, train error 2.35,  test loss 1.198915, test error 36.50\n",
      "Epoch    14, train loss 0.107555, train error 1.05,  test loss 1.233249, test error 36.80\n",
      "Epoch    15, train loss 0.089909, train error 1.03,  test loss 1.276260, test error 36.10\n",
      "Epoch    16, train loss 0.073374, train error 0.55,  test loss 1.332932, test error 36.30\n",
      "Epoch    17, train loss 0.067759, train error 0.53,  test loss 1.366216, test error 37.30\n",
      "Epoch    18, train loss 0.052247, train error 0.20,  test loss 1.436343, test error 36.30\n",
      "Epoch    19, train loss 0.037094, train error 0.03,  test loss 1.453782, test error 36.10\n",
      "Epoch    20, train loss 0.030195, train error 0.00,  test loss 1.442081, test error 36.60\n",
      "Epoch    21, train loss 0.027046, train error 0.00,  test loss 1.479175, test error 36.70\n",
      "Epoch    22, train loss 0.025173, train error 0.00,  test loss 1.495339, test error 36.20\n",
      "Epoch    23, train loss 0.023158, train error 0.00,  test loss 1.516993, test error 36.70\n",
      "Epoch    24, train loss 0.021771, train error 0.00,  test loss 1.533653, test error 36.30\n",
      "Epoch    25, train loss 0.020533, train error 0.00,  test loss 1.549048, test error 36.20\n",
      "Epoch    26, train loss 0.019328, train error 0.00,  test loss 1.568169, test error 36.20\n",
      "Epoch    27, train loss 0.018251, train error 0.00,  test loss 1.582663, test error 36.30\n",
      "Epoch    28, train loss 0.017411, train error 0.00,  test loss 1.593979, test error 36.00\n",
      "Epoch    29, train loss 0.016427, train error 0.00,  test loss 1.611554, test error 36.40\n",
      "Epoch    30, train loss 0.015811, train error 0.00,  test loss 1.615677, test error 36.40\n",
      "Epoch    31, train loss 0.015447, train error 0.00,  test loss 1.620030, test error 36.20\n",
      "Epoch    32, train loss 0.015107, train error 0.00,  test loss 1.632490, test error 36.10\n",
      "Epoch    33, train loss 0.014716, train error 0.00,  test loss 1.634895, test error 36.10\n",
      "Epoch    34, train loss 0.014414, train error 0.00,  test loss 1.642980, test error 36.40\n",
      "Epoch    35, train loss 0.014056, train error 0.00,  test loss 1.647145, test error 36.30\n",
      "Epoch    36, train loss 0.013764, train error 0.00,  test loss 1.653095, test error 36.40\n",
      "Epoch    37, train loss 0.013465, train error 0.00,  test loss 1.659661, test error 36.30\n",
      "Epoch    38, train loss 0.013181, train error 0.00,  test loss 1.666339, test error 36.20\n",
      "Epoch    39, train loss 0.012905, train error 0.00,  test loss 1.670447, test error 36.40\n",
      "Epoch    40, train loss 0.012752, train error 0.00,  test loss 1.674701, test error 36.20\n",
      "Epoch    41, train loss 0.012622, train error 0.00,  test loss 1.676609, test error 36.40\n",
      "Epoch    42, train loss 0.012498, train error 0.00,  test loss 1.678957, test error 36.20\n",
      "Epoch    43, train loss 0.012370, train error 0.00,  test loss 1.682321, test error 36.20\n",
      "Epoch    44, train loss 0.012257, train error 0.00,  test loss 1.685901, test error 36.10\n",
      "Epoch    45, train loss 0.012135, train error 0.00,  test loss 1.688398, test error 36.20\n",
      "Epoch    46, train loss 0.012009, train error 0.00,  test loss 1.689366, test error 36.20\n",
      "Epoch    47, train loss 0.011897, train error 0.00,  test loss 1.693564, test error 36.20\n",
      "Epoch    48, train loss 0.011781, train error 0.00,  test loss 1.695703, test error 36.20\n",
      "Epoch    49, train loss 0.011668, train error 0.00,  test loss 1.698304, test error 36.00\n"
     ]
    }
   ],
   "source": [
    "# choose cross entropy loss function (equation 5.24)\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "# construct SGD optimizer and initialize learning rate and momentum\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = 0.05, momentum=0.9)\n",
    "# object that decreases learning rate by half every 10 epochs\n",
    "scheduler = StepLR(optimizer, step_size=10, gamma=0.5)\n",
    "x_train = torch.tensor(data['x'].astype('float32'))\n",
    "y_train = torch.tensor(data['y'].transpose().astype('long'))\n",
    "x_test= torch.tensor(data['x_test'].astype('float32'))\n",
    "y_test = torch.tensor(data['y_test'].astype('long'))\n",
    "\n",
    "# load the data into a class that creates the batches\n",
    "data_loader = DataLoader(TensorDataset(x_train,y_train), batch_size=100, shuffle=True, worker_init_fn=np.random.seed(1))\n",
    "\n",
    "# Initialize model weights\n",
    "model.apply(weights_init)\n",
    "\n",
    "# loop over the dataset n_epoch times\n",
    "n_epoch = 50\n",
    "# store the loss and the % correct at each epoch\n",
    "losses_train = np.zeros((n_epoch))\n",
    "errors_train = np.zeros((n_epoch))\n",
    "losses_test = np.zeros((n_epoch))\n",
    "errors_test = np.zeros((n_epoch))\n",
    "\n",
    "for epoch in range(n_epoch):\n",
    "  # loop over batches\n",
    "  for i, batch in enumerate(data_loader):\n",
    "    # retrieve inputs and labels for this batch\n",
    "    x_batch, y_batch = batch\n",
    "    # zero the parameter gradients\n",
    "    optimizer.zero_grad()\n",
    "    # forward pass -- calculate model output\n",
    "    pred = model(x_batch)\n",
    "    # compute the loss\n",
    "    loss = loss_function(pred, y_batch)\n",
    "    # backward pass\n",
    "    loss.backward()\n",
    "    # SGD update\n",
    "    optimizer.step()\n",
    "\n",
    "  # Run whole dataset to get statistics -- normally wouldn't do this\n",
    "  pred_train = model(x_train)\n",
    "  pred_test = model(x_test)\n",
    "  _, predicted_train_class = torch.max(pred_train.data, 1)\n",
    "  _, predicted_test_class = torch.max(pred_test.data, 1)\n",
    "  errors_train[epoch] = 100 - 100 * (predicted_train_class == y_train).float().sum() / len(y_train)\n",
    "  errors_test[epoch]= 100 - 100 * (predicted_test_class == y_test).float().sum() / len(y_test)\n",
    "  losses_train[epoch] = loss_function(pred_train, y_train).item()\n",
    "  losses_test[epoch]= loss_function(pred_test, y_test).item()\n",
    "  print(f'Epoch {epoch:5d}, train loss {losses_train[epoch]:.6f}, train error {errors_train[epoch]:3.2f},  test loss {losses_test[epoch]:.6f}, test error {errors_test[epoch]:3.2f}')\n",
    "\n",
    "  # tell scheduler to consider updating learning rate\n",
    "  scheduler.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "yI-l6kA_EH9G"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHFCAYAAADmGm0KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmyElEQVR4nO3dd1zU9R8H8NexlxygshLQXDhxM8yViuLIUWlaKmWZpaZZmaNcmWhZOTMtFf1ZauYsJ+YO3KLm3pBCuABBBYHP749Pd3BwIOPge8Dr+Xh8H/e9733ue++7L3BvPlMlhBAgIiIiIh0mSgdAREREZIyYJBERERHpwSSJiIiISA8mSURERER6MEkiIiIi0oNJEhEREZEeTJKIiIiI9GCSRERERKQHkyQiIiIiPZgkEWWhUqnyte3du7dIrzN58mSoVCrDBP0flUqFyZMnG/SchpCUlIRRo0bB3d0dVlZWaNSoEVavXp3v58fFxSE4OBiVKlWCjY0N/P398eeff+Yo98cff2DgwIFo0KABzM3Ni/T57t27N98/C4Zw7tw5TJ48GTdu3MhX+dDQUKhUqnyXLykHDx7E22+/jaZNm8LS0rJAMd64cSPPz7lz58465Z8+fYopU6agatWqsLS0hLe3N+bNm1cM74rKMzOlAyAyJhERETr3v/jiC+zZswe7d+/WOV63bt0ivc7bb7+d449+WdW7d28cPXoUM2bMQK1atfDLL7+gX79+yMjIQP/+/fN8bkpKCtq3b4/4+HjMmTMHzs7OWLBgATp37oxdu3ahTZs22rIbNmzAoUOH0LhxY1haWuL48eOFjrlJkyY5fhZ69eqF6tWrY9asWYU+b27OnTuHKVOmoG3btqhatarBz19S/vzzT+zatQuNGzeGvb19gf6ZcHNzy/GZA8DGjRsxc+ZM9OrVS+f4+++/j//973/44osv0Lx5c+zYsQMjR47Ew4cPMX78+KK+FSJJEFGuBg0aJGxtbZ9ZLjk5uQSiyRsAMWnSJKXD0LFlyxYBQPzyyy86xzt27Cjc3d1FWlpans9fsGCBACDCw8O1x54+fSrq1q0rWrRooVM2PT1duz9s2DBh6D9vXl5eomvXrgY9p8batWsFALFnz558lV+2bJkAIK5fv14s8RRW1mvw9ddfGyTGtm3bChsbG5GQkKA99vfffwuVSiWmT5+uU/add94R1tbW4t69e0V6TSINNrcRFVDbtm1Rv3597N+/HwEBAbCxscFbb70FAFizZg0CAwPh5uYGa2tr1KlTB2PHjkVycrLOOfQ1t1WtWhXdunXD9u3b0aRJE1hbW8Pb2xtLly4tdKx///03evToAUdHR21T1/Lly3XKZGRkYNq0aahduzasra3h4OCAhg0bYs6cOdoyd+7cwZAhQ+Dh4QFLS0tUrlwZLVu2xK5du/J8/Q0bNsDOzg6vvvqqzvE333wTt2/fxuHDh5/5/Nq1a8Pf3197zMzMDG+88QaOHDmCW7duaY+bmJT8n7PY2Fi8++67qFKlCiwsLFCtWjVMmTIFaWlpOuUWLlwIHx8f2NnZoUKFCvD29tbWdoSGhmo/n3bt2mmbl0JDQwscz9KlS+Hj4wMrKys4OTmhV69eOH/+vE6Za9eu4bXXXoO7uzssLS3h4uKC9u3bIzIyUltm9+7daNu2LSpWrAhra2t4enri5ZdfxqNHj/J8fUNfg6tXr2Lfvn3o06cP7O3ttcc3btwIIQTefPNNnfJvvvkmHj9+jO3btxs0Diq/2NxGVAgxMTF44403MGbMGEyfPl375XD58mV06dIFo0aNgq2tLS5cuICZM2fiyJEjOZrs9Dl16hQ++ugjjB07Fi4uLvjpp58wePBg1KhRA61bty5QjBcvXkRAQACcnZ0xd+5cVKxYEStXrkRwcDD+/fdfjBkzBgDw1VdfYfLkyfjss8/QunVrPH36FBcuXEB8fLz2XAMGDMCJEyfw5ZdfolatWoiPj8eJEydw7969PGP4+++/UadOHZiZ6f6padiwofbxgICAPJ/fqlWrHMc1zz979iyee+65fH0ehhYbG4sWLVrAxMQEEydORPXq1REREYFp06bhxo0bWLZsGQBg9erVeP/99zFixAjMmjULJiYmuHLlCs6dOwcA6Nq1K6ZPn47x48djwYIFaNKkCQCgevXqBYonJCQE48ePR79+/RASEoJ79+5h8uTJ8Pf3x9GjR1GzZk0AQJcuXZCeno6vvvoKnp6euHv3LsLDw7XX+8aNG+jatStatWqFpUuXwsHBAbdu3cL27duRmpoKGxsbA32Cz7Z06VIIIfD222/rHP/7779RuXJluLq66hzP+nNFZBBKV2URGTN9zW1t2rQRAMSff/6Z53MzMjLE06dPxb59+wQAcerUKe1jkyZNytEc5OXlJaysrMTNmze1xx4/fiycnJzEu++++8xYka257bXXXhOWlpYiKipKp1xQUJCwsbER8fHxQgghunXrJho1apTnue3s7MSoUaOeGUN2NWvWFJ06dcpx/Pbt2wJAjuaS7MzNzfW+9/DwcL3NeBol0dz27rvvCjs7O53rJYQQs2bNEgDE2bNnhRBCDB8+XDg4OOR57qI2tz148EBYW1uLLl266JSLiooSlpaWon///kIIIe7evSsAiNmzZ+d67t9++00AEJGRkfmKJTdFbW5LS0sTzz33nPD29s7xWMeOHUXt2rX1Ps/CwkIMGTKkUK9JlB2b24gKwdHRES+++GKO49euXUP//v3h6uoKU1NTmJubazsXZ2/20KdRo0bw9PTU3reyskKtWrVw8+bNAse4e/dutG/fHh4eHjrHg4OD8ejRI20n2RYtWuDUqVN4//33sWPHDiQmJuY4V4sWLRAaGopp06bh0KFDePr0ab7jyGsEWH5GhxX1+cXljz/+QLt27eDu7o60tDTtFhQUBADYt28fAPnZxcfHo1+/fti0aRPu3r1r8FgiIiLw+PFjBAcH6xz38PDAiy++qB0N6OTkhOrVq+Prr7/Gt99+i5MnTyIjI0PnOY0aNYKFhQWGDBmC5cuX49q1awaPNz+2b9+OW7duYfDgwXofN9afCypbmCQRFYKbm1uOY0lJSWjVqhUOHz6MadOmYe/evTh69CjWr18PAHj8+PEzz1uxYsUcxywtLfP13Ozu3bunN053d3ft4wAwbtw4zJo1C4cOHUJQUBAqVqyI9u3b49ixY9rnrFmzBoMGDcJPP/0Ef39/ODk5YeDAgYiNjX3m+9HXJHf//n0A8ku7OJ9fnP7991/8/vvvMDc319nq1asHANpkaMCAAVi6dClu3ryJl19+Gc7OzvD19UVYWJjBYtF8Rrldb83jKpUKf/75Jzp16oSvvvoKTZo0QeXKlfHBBx/g4cOHAGQz365du+Ds7Ixhw4ahevXqqF69uk4ftZKwZMkSmJubY+DAgTkey+3nIjk5GampqYr+XFDZwiSJqBD0/ae6e/du3L59G0uXLsXbb7+N1q1bo1mzZqhQoYICEcovkpiYmBzHb9++DQCoVKkSANkRevTo0Thx4gTu37+PVatWITo6Gp06ddJ21K1UqRJmz56NGzdu4ObNmwgJCcH69etz1Fxk16BBA5w/fz5HR+YzZ84AAOrXr//M52vKFub5xalSpUoIDAzE0aNH9W5Za0DefPNNhIeHIyEhAVu2bIEQAt26dStUDaE+muQ6t+utudYA4OXlhSVLliA2NhYXL17Ehx9+iO+//x6ffPKJtkyrVq3w+++/IyEhAYcOHYK/vz9GjRpVoPmtiiIuLg5//PEHXnrpJTg7O+d4vEGDBrhz506OJN0Yfi6obGGSRGQgmsTJ0tJS5/iiRYuUCAft27fXJm5ZrVixAjY2NvDz88vxHAcHB7zyyisYNmwY7t+/r3ciQE9PTwwfPhwdO3bEiRMn8oyhV69eSEpKwrp163SOL1++HO7u7vD19X3m8y9cuKAzCi4tLQ0rV66Er6+vtlZMCd26dcPff/+N6tWro1mzZjk2fbHZ2toiKCgIEyZMQGpqKs6ePQsg82emMDWGAODv7w9ra2usXLlS5/g///yjbXbVp1atWvjss8/QoEEDvdfS1NQUvr6+WLBgAQA883obyooVK/D06dNcm9p69OgBlUqVY6RmaGgorK2ty80cZFT8OLqNyEACAgLg6OiIoUOHYtKkSTA3N8fPP/+MU6dOKRLPpEmTtP1mJk6cCCcnJ/z888/YsmULvvrqK6jVagBA9+7dUb9+fTRr1gyVK1fGzZs3MXv2bHh5eaFmzZpISEhAu3bt0L9/f3h7e6NChQo4evQotm/fjt69e+cZQ1BQEDp27Ij33nsPiYmJqFGjBlatWoXt27dj5cqVMDU11ZYdPHgwli9fjqtXr8LLywsA8NZbb2HBggV49dVXMWPGDDg7O+P777/HxYsXc0w/cPPmTRw9ehSAHDoOAL/99hsAOb1Cs2bNtGU1EzYWZcbqqVOnIiwsDAEBAfjggw9Qu3ZtPHnyBDdu3MDWrVvxww8/oEqVKnjnnXdgbW2Nli1bws3NDbGxsQgJCYFarUbz5s0BZNZ8LF68GBUqVICVlRWqVaumt/lVHwcHB3z++ecYP348Bg4ciH79+uHevXuYMmUKrKysMGnSJADA6dOnMXz4cLz66quoWbMmLCwssHv3bpw+fRpjx44FAPzwww/YvXs3unbtCk9PTzx58kQ7DUWHDh3yjOPOnTvavliaWp1t27ahcuXKqFy5ss7kn2ZmZmjTpo3e2dOXLFkCDw8PdOrUSe/r1KtXD4MHD8akSZNgamqK5s2bY+fOnVi8eDGmTZvG5jYyHKV7jhMZs9xGt9WrV09v+fDwcOHv7y9sbGxE5cqVxdtvvy1OnDghAIhly5Zpy+U2uk3fZIVt2rQRbdq0eWas0DOZ5JkzZ0T37t2FWq0WFhYWwsfHRycOIYT45ptvREBAgKhUqZKwsLAQnp6eYvDgweLGjRtCCCGePHkihg4dKho2bCjs7e2FtbW1qF27tpg0aVK+JtF8+PCh+OCDD4Srq6uwsLAQDRs2FKtWrcpRbtCgQXpHQ8XGxoqBAwcKJycnYWVlJfz8/ERYWFiO52tGfOnbBg0apFO2UqVKws/P75mxZ6Xv+ty5c0d88MEHolq1asLc3Fw4OTmJpk2bigkTJoikpCQhhBDLly8X7dq1Ey4uLsLCwkK4u7uLPn36iNOnT+uca/bs2aJatWrC1NQ0x89Lbu81+2f1008/iYYNGwoLCwuhVqtFjx49tKPshBDi33//FcHBwcLb21vY2toKOzs70bBhQ/Hdd99pJ/aMiIgQvXr1El5eXsLS0lJUrFhRtGnTRmzevPmZn9GePXtyvQbZf4b1HRNCiL/++ksAEBMnTszztVJTU8WkSZOEp6ensLCwELVq1RJz5859ZoxEBaESQoiSTcuIiJRz7tw51KtXD3/88Qe6du2qdDhEZMTYJ4mIypU9e/bA39+fCRIRPRNrkoiIiIj0YE0SERERkR5MkoiIiIj0YJJEREREpAeTJCIiIiI9OJmkHhkZGbh9+zYqVKjAhRKJiIhKCSEEHj58CHd3d5iYFL0eiEmSHrdv386xcjoRERGVDtHR0ahSpUqRz8MkSQ/NgqTR0dGwt7dXOBoiIiLKj8TERHh4eBhsYXFFk6T9+/fj66+/xvHjxxETE4MNGzagZ8+euZYPDg7OsaAhANStW1e7UGRoaCjefPPNHGUeP34MKyurfMWlaWKzt7dnkkRERFTKGKqrjKIdt5OTk+Hj44P58+fnq/ycOXMQExOj3aKjo+Hk5IRXX31Vp5y9vb1OuZiYmHwnSERERESAwjVJQUFBCAoKynd5tVqtXbkcADZu3IgHDx7kqDlSqVRwdXU1WJxERERU/pTqKQCWLFmCDh06wMvLS+d4UlISvLy8UKVKFXTr1g0nT55UKEIiIiIqrUptx+2YmBhs27YNv/zyi85xb29vhIaGokGDBkhMTMScOXPQsmVLnDp1CjVr1tR7rpSUFKSkpGjvJyYmFmvsREREZPxKbU1SaGgoHBwccnT09vPzwxtvvAEfHx+0atUKv/76K2rVqoV58+bleq6QkBBtU55arebwfyIiIiqdSZIQAkuXLsWAAQNgYWGRZ1kTExM0b94cly9fzrXMuHHjkJCQoN2io6MNHTIRERGVMqWyuW3fvn24cuUKBg8e/MyyQghERkaiQYMGuZaxtLSEpaWlIUMkIiKiUk7RJCkpKQlXrlzR3r9+/ToiIyPh5OQET09PjBs3Drdu3cKKFSt0nrdkyRL4+vqifv36Oc45ZcoU+Pn5oWbNmkhMTMTcuXMRGRmJBQsWFPv7ISIiorJD0STp2LFjaNeunfb+6NGjAQCDBg1CaGgoYmJiEBUVpfOchIQErFu3DnPmzNF7zvj4eAwZMgSxsbFQq9Vo3Lgx9u/fjxYtWhTfGyEiIqIyRyWEEEoHYWwSExOhVquRkJDAGbeJiIhKCUN/f5fKjttERERExY1JEhEREZEepXJ0GxEREZUPKSnAw4dAYiJQsSKQZXWyYsckiYiIiAwmLQ24e1duDx8CycnP3hITZVlNMpR1/+nTzHMvXQpkW661WDFJIiIiKqeEAB49ApKS5JaSIpMSzZaaqntfc+zePSAuDrhzJ+ft/fvFE6uNjUzAShKTJCIiolJKCCAhQSYm9+7J26z7mtustTNJSbr7GRmGj8vEBHByAipUAGxtn73Z28uymtus+/b2gJ0dYGpq+DifhUkSERGRQtLSMmtxsm7x8cCDB3K7fz9zX9/99HTDxGJnB1haAubmeW8WFrJvUOXKgLOz/lsnJ2WSGkNjkkRERFQAjx9nNi9pmpji42Wzlb7t8ePM/eTkzETo4UPZvGUINjYyMalYUd5m31erZa2MnV1mTU3WzcZG1v6QLiZJRERUrqWkyEQna7+arFvWZCguTiY3hmZmlpnE2NrKpMbJCXB0zNyy3tfsa5IgKyvDx0RMkoiIqAxLSwOio4Fr14CrV+XttWtAVFRmElSYpMfCQjYtaZqXHB1lcmNjA1hby1vNlv2+JhnKunGNdePEJImIiEq1+PjM5CfrdvUqcPNm/vrsmJnJZEff5uKi2+fG2Vl2Jlapiv2tkcKYJBERkVFLTZU1P9ev6yZBmvsPHuT9fEtLoFo14PnngerV5a2Xl27io1Yz6aGcmCQREZGiEhJkjc/NmzIZynp78yYQGyuHuufF2VkmP9WqyURIkww9/zzg7s5OyVQ4TJKIiMighAD+/Vdu2TtDZ5948N9/5Rw+z2JtnVkbpEmGNPtVq8p+PUSGxiSJiIgKJSMDuHEDOH8eOHdO9zY/iU9WlSoBnp6yGczLK3Nfc1upEpvDqOQxSSIiImRkZM7ho5mJOeu+5jY+Hrh8WSZDFy/KOYD0MTHJ7Pis6fuT2+SDVarIkWFExoZJUh6KY6p2IiJjkJICHDkC7N0rt/Bw4MmTgp/H0hKoXRuoUweoWzfztmZNOUyeqDRjkpSHgweBbt2UjoKIqOjymxSZmGTO3ZN1huast88/LxOhunVl36CysPwEkT5MkvLw889MkoiodBBCDoWPi5OdoTW3MTHAoUP6kyJnZ6BtW7m1aSM7QFtbs+8PkQaTpDxs2iTb4StUUDoSIipvhJCdn7MvkZF9hFjWLS0t73NmTYratgW8vZkQEeWFSVIeHj8G1q4F3npL6UiIqKx78ABYvx5YvVqODrtzR06iWFBqdeYM0Zqtfn2gXTvZX4hJEVH+MUl6htBQJklEVDwePwb++AP45Rdg61b9SZGNje7osKybs3POhIhrgBEZDpOkPKhUwIEDwJUrQI0aSkdDRGVBWhqwe7dMjNav111ctUEDoH9/oH37zMTIxka5WInKOyZJeXjxReDPP4EVK4CpU5WOhohKq0ePgKNHZVK0Zo3sUK3h6SkTo/79ZZJERMaDSVIe+veXSdLy5cDkyVz7h4jy559/5GgyzXbypG6n6ooVgT59gNdfB/z9+beFyFgxScpD166yE2RUlJxX5MUXlY6IiIxNWhpw6pRuUhQVlbOcm5v8G9KvHxAYCJibl3ysRFQwTJLyYG0t/6D98IPswM0kiYgAOdx++3ZgyxZgxw65in1WJiaAjw8QECC3li1lsxpHlhGVLiohhFA6CGOTmJgItVqNhIQEnD9vDz8/mTDFxgL29kpHR0QlLSMDOHFCJkVbt8r+RVn/cqrVmQlRQADQogVXpSdSQtbvb3sDfGGzJukZWrSQE65duAD89hunAyAqLx4+lLVEW7YA27bpdrYGgMaNgS5dZLN8ixZcmoOoLGKS9AwqFRAcDIwdCyxbxiSJqCwTQq7ZuHQp8OuvclSahp0d0LGjTIqCggB3d+XiJKKSweY2PbJX1926JfsTZGQAly9zziSisiYmRo5iXbpU/o5rVK8OvPSSTIxateKq9kTGjs1tCnjuOTkaZft2+Yf0iy+UjoiIiio1VTalLV0qm9PS0+VxW1ugb19ZaxwQwM7WROUZZ+fIpzfflLfLl8saJSIqfYSQHbA//hioUgXo3VsuC5KeLkegLV0qB2gsWSLvM0EiKt9Yk5SXqCi5MiRklbuDAxAdDezZI5cNICLjl5oK7NsHbNoEbN4sf4c1XF2BQYPkP0G1aysXIxEZJyZJeTl0SJskWVnJOZMWLpRzJjFJIjJeCQmyCW3TJjlkPzEx8zFbW6BzZ5kcBQUBZvwrSES5YMdtPbQdv4YMgf2iRdrjR44Avr6cM4nIGN2+DWzcKLe9e4GnTzMfc3EBuncHevaU/+BYWSkTIxEVL3bcLklHjujcbd4cqFMHOH8eWLsWGDxYobiICIAclbZunRyuf/Cg7gSP3t5Ajx5y8/Xl+mhEVHBMkvJy5oycKMXGBkDmnEmffirnTGKSRFTyNInR2rXAgQO6iZGfH9Crl0yM2MeIiIqKzW16aKvrANjv3y8nSPlPTIwcFZORAVy6BNSsqVycROVFbGxmjVH2xMjfH3j1VeCVVwAPD+ViJCLlGbq5TdEK6P3796N79+5wd3eHSqXCxo0b8yy/d+9eqFSqHNuFCxd0yq1btw5169aFpaUl6tatiw0bNhQ+yIgInbtubrLTJyCnAyCi4iEEsHu3rBVydweGDwf275fH/fyAb74Bbt4EwsOBDz9kgkREhqdokpScnAwfHx/Mnz+/QM+7ePEiYmJitFvNLNU5ERER6Nu3LwYMGIBTp05hwIAB6NOnDw4fPly4ILMlSYBscgNkkqSZgI6IDOPxYzlPkY+P7GS9ebNMjHx9gVmzgBs35K/l6NFyJnwiouJiNM1tKpUKGzZsQM+ePXMts3fvXrRr1w4PHjyAg4OD3jJ9+/ZFYmIitm3bpj3WuXNnODo6YtWqVfmKRae5zcVFtrFlmVXuyRP5n+2DB0BYGNChQ75OS0R5uHUL+P57YNEi4N49eczGRg7V/+AD2RGbiCgvZaq5rbAaN24MNzc3tG/fHnv27NF5LCIiAoGBgTrHOnXqhPDw8FzPl5KSgsTERJ0NgFzW+99/5b+uWWjmTALknElEVHiHDwP9+wNVqwLTp8sEydMT+Ppr4J9/ZOLEBImIlFCqkiQ3NzcsXrwY69atw/r161G7dm20b98e+/fv15aJjY2Fi4uLzvNcXFwQGxub63lDQkKgVqu1m4emc4OPj7w9dCjHczRNbuvWyYnriCj/YmJk8uPvL/sXrVoFpKUBL7wA/PYbcPWqXDrE0VHpSImoPCtVUwDUrl0btbOM6/X390d0dDRmzZqF1q1ba4+rsi24JITIcSyrcePGYfTo0dr7iYmJMlFq3lwu9BQRkVl19J9mzYC6dYFz52SfiQEDivruiMq2qCj5T8W6dbKztaah38ICeO01YORIoEkTZWMkIsqqVNUk6ePn54fLly9r77u6uuaoNYqLi8tRu5SVpaUl7O3tdTYAQIsW8lZP522VSg45BuQffSLK6coVYOZM+avk5SU7W//1V2ZH7K++kiPUli9ngkRExqfUJ0knT56Em5ub9r6/vz/CwsJ0yuzcuRMBAQEFP7kmSYqMlENusnn5ZXm7YweQlFTw0xOVRYmJwLRpsrW6Zk1g7Fjg6FH5j0Xr1sCcObJW6dAh4JNP5CKzRETGSNHmtqSkJFy5ckV7//r164iMjISTkxM8PT0xbtw43Lp1CytWrAAAzJ49G1WrVkW9evWQmpqKlStXYt26dViXpSpn5MiRaN26NWbOnIkePXpg06ZN2LVrFw4ePFjwAD085F/w2Fjg2DGdSSUBoEEDoEYN+d/ytm1yQjui8uzECaBvX/k7AcixDy++KP+h6NlTrqFGRFRaKFqTdOzYMTRu3BiNGzcGAIwePRqNGzfGxIkTAQAxMTGIiorSlk9NTcXHH3+Mhg0bolWrVjh48CC2bNmC3r17a8sEBARg9erVWLZsGRo2bIjQ0FCsWbMGvr6+BQ9QpZI9S4Fcm9w0tUlscqPyTAhg/nz563LlihydtnQpEBcH7NwJvPsuEyQiKn2MZp4kY6Izz8KiRcCYMXJBqPXrc5Q9ckT2rbCzA+7c4eriVP7Ex8t1DDW/Hj16yATJyUnRsIioHOI8SSUta02SnnyyeXPZKpeUJCeWJCpPjhwBGjeWCZK5OTB7NrBhAxMkIiobmCQ9S9OmgJmZ7Jd082aOh1UqQNPaxyY3Ko3i4+XcRH/+mf8BCEIA330n5zW6cQOoVk2OWhs5UmdyeiKiUo1J0rNYW8t/lQG9/ZKAzCRp82bg6dMSiouoCB4/BtaulT+7Li5y0EGHDoCDg6wd/fBDmfT/+2/O596/Lzthjx4tf95ffll22G7evKTfBRFR8SpVk0kqxs9PjmHWM6kkALRsCTg7y06qe/YA2VZFITIKT5/K2qJffgE2bgQePsx8zNsbePRIDs0/dkxus2fLx2rUkAM7X3gBqFwZGDYMiI6Wk0B+9x3w3nusPSKisolJUn74+wPz5uldngSQw5x79ZILc65fzySJjEdGhsztf/lF1hzduZP5mJeXzPn79ZPTWahUMkn66y/g4EHgwAHg77/laLUrV4BlyzKfW6MG8OuvmZWsRERlEUe36ZGjd7ym04WZmZwpz9o6x3N27gQ6dZI1Srdvy8SJSEkxMUDHjsDZs5nHKlcG+vSRC8r6+z+7BujBA5lkHTwot7NngW7d5P8MBhg4QkRkUIYe3cYkSY8cH7IQgLu77Lx94IBsd8jm6VPZt+PBA2DfPjmzMJFSMjKALl3kbPAVKsiazv79gfbtZa5PRFQWcQoAJTxjUklADn9+6SW5z1FupLT582WCZGUlW4mXL5c1nUyQiIjyj0lSfj0jSQIyR7mtX693SiWiEnHmjJz/FAC++QaoW1fZeIiISismSfnl5ydvc5lUEpAdtu3sgH/+kYPhiErakyeyWS0lBejaVY48IyKiwmGSlF/NmmVOKpllPbmsrKzkFxPAJjdSxtixckSas7NcGoRD84mICo9JUn5ZWwONGsn9fDS5rVvHJjcqWTt2AHPmyP1ly2SiREREhcckqSDy0S+pSxdZo3T1quwbQlQS7twBgoPl/vDh8ueQiIiKhklSQeQjSbKzk6OIADa5UckQAnj7bdkSXLcu8NVXSkdERFQ2MEkqCE2SdPKkXPwqF1zwlkrS4sVy3UALCzmztp65TomIqBCYJBWEl5ecMTItTa7omYvu3WUf77NngYsXSzA+KncuXJCL0QLAjBmAj4+y8RARlSVMkgoiH5NKAoCjo5zZGJBzJhEVh9RU4PXXZaVmhw7AyJFKR0REVLYwSSqofCRJAJvcqPhNnCgrNJ2c5IzaJvxtJiIyKP5ZLaisSVIeY/x79pRfWsePy/VxiQxp797MDto//SSXFiQiIsNiklRQmkklY2JynVQSkHPUtGol99nkRoZ04ICcVVsI4J135OK1RERkeEySCiqfk0oCwMsvy1smSWQIjx4Bo0YBbdrIHL1OHeC775SOioio7GKSVBiaddwOHcqzmOY//PBw+aVGVFgHD8qRa3PmyBqkwYNljm5rq3RkRERlF5Okwshn5+0qVQBfX/mltmFDCcRFZc6jR3KIf+vWwJUrwHPPAVu3yn5IarXS0RERlW1Mkgoj66SST57kWVTT5MZRblRQf/0lW3Znz5aJ9ptvysVrg4KUjoyIqHxgklQYVavKSSWfPpXD1/KgmQpgzx6gWzdg4cI8+3sT4fFj4KOPZMf/y5flyLUtW4ClSwEHB6WjIyIqP5gkFUY+J5UEgOrV5QzcQsgvuvfflxN3+/gA48fL/krp6SUQM5UKhw7J2qNvv5U/M8HBcuZ2LlhLRFTymCQVVj6TJADYtAk4fRoICQFatpTzJ2W97+ICDBgArF4NJCQUc9xktA4cANq2BS5dkrVHf/wBLFvG2iMiIqWohMhjRsRyKjExEWq1GgkJCbC3t9dfaP9+ORbbzQ24dUvWLuXTvXvA9u3yS3D7diA+PvMxNzfZxMJRS+XL+fMyYX7wQNYarVwpl7chIqL8y9f3dwGwJqmwsk4qGR1doKdWrCjX3Fq1CrhzB9i3DxgzRn4pxsTIZjkqP2JjZWfsBw/k7BK//cYEiYjIGDBJKiwbm8xJJQ8cKPRpzMzk8O6ZM4F335XHfv216OFR6ZCUBHTtCty8CdSoAWzeLOcrJSIi5TFJKoq2beXtvn0GOV2fPvJ2yxb55UllW1oa0LevXKS2UiVg2zagcmWloyIiIg0mSUXRpo283bvXIKdr1EiOhnvyhE1uZZ0QcqTj1q2y5uiPP2RNEhERGQ8mSUXxwgtyqNrly8Dt20U+nUqVWZvEJreybfp04Mcf5Y/PqlVyZnYiIjIuTJKKwsEhs1+SgZvctm4FHj40yCnJyPzvf8Bnn8n9uXOBHj2UjYeIiPRjklRUBu6X5OMD1Kwpm9z++MMgpyQj8uefwFtvyf1PPgGGDVM2HiIiyh2TpKIycL8klQp49VW5v3atQU5JRuLMGblMTVoa8NprwIwZSkdERER5YZJUVK1ayczm4kU5yZEBsMmt7PnnHzkXUmKinPIhNFT2RyIiIuPFP9NF5ego28gAOQu3ATRsCNSqBaSkAL//bpBTkoKiooDAQDkxe506wMaNgKWl0lEREdGzMEkyBE2/JAM2uXGUW9lw/LgcuXb+vFyPbds2zqZNRFRaKJok7d+/H927d4e7uztUKhU2btyYZ/n169ejY8eOqFy5Muzt7eHv748dO3bolAkNDYVKpcqxPXnypPjeiKZfkoE6bwOZSdL27bKJhkqf33+XTWuxsUCDBsChQ4CXl9JRERFRfimaJCUnJ8PHxwfz58/PV/n9+/ejY8eO2Lp1K44fP4527dqhe/fuOHnypE45e3t7xMTE6GxWVlbF8Rak1q1l9c/588C//xrklPXrA7Vrs8mttJo3D+jZE3j0SDa1HTwIeHgoHRURERWEmZIvHhQUhKCgoHyXnz17ts796dOnY9OmTfj999/RuHFj7XGVSgVXV1dDhflsTk6yquD0adkvSTM8rQg0TW5ffCGb3F5/3QBxUrFLTwc++giYM0fef+cdYMECwNxc2biIiKjgSnWfpIyMDDx8+BBOTk46x5OSkuDl5YUqVaqgW7duOWqasktJSUFiYqLOVmAG7pcE6Da5JSQY7LRUTJKT5RB/TYI0YwawaBETJCKi0qpUJ0nffPMNkpOT0UeTTQDw9vZGaGgoNm/ejFWrVsHKygotW7bE5cuXcz1PSEgI1Gq1dvMoTLuIgSeVBIB69eRoqNRUuTo8Ga/YWNk1bfNmOXJtzRrg009ljSAREZVOKiGEUDoIQDaRbdiwAT179sxX+VWrVuHtt9/Gpk2b0KFDh1zLZWRkoEmTJmjdujXmzp2rt0xKSgpSUlK09xMTE+Hh4YGEhATY29vn7w3cvZu5hHtcnMGWc580CZg6FejenYmSsTp7FujSRQ71r1hRXqeAAKWjIiIqfxITE6FWqwv2/Z2HUlmTtGbNGgwePBi//vprngkSAJiYmKB58+Z51iRZWlrC3t5eZyuwSpVkvyTAYPMlAZlNbjt2APHxBjstGcjOnTIhioqSc1sdOsQEiYiorCh1SdKqVasQHByMX375BV27dn1meSEEIiMj4ebmVvzBGXiJEkA2udWtyyY3Y/P4MfDhh0CnTnKKhlatgPBwoEYNpSMjIiJDUTRJSkpKQmRkJCIjIwEA169fR2RkJKKiogAA48aNw8CBA7XlV61ahYEDB+Kbb76Bn58fYmNjERsbi4QsvZqnTJmCHTt24Nq1a4iMjMTgwYMRGRmJoUOHFv8bKobO2wAnljQ2x48DTZsCmsGW774LhIXJpjYiIio7FE2Sjh07hsaNG2uH748ePRqNGzfGxIkTAQAxMTHahAkAFi1ahLS0NAwbNgxubm7abeTIkdoy8fHxGDJkCOrUqYPAwEDcunUL+/fvR4sWLYr/DbVuLW///lv2UTIQzYwCO3eyyU1JaWmyf5ifn5wSy9UV2LIF+OEHLjNCRFQWGU3HbWNSpI5f9evLnrzr1snx4AaiOW1oKDBokMFOS/l08SIwcCBw5Ii8/8orwMKFsisaEREZB3bcNnbFsEQJwCY3pWRkAPPnA40bywRJrQZWrpTXgQkSEVHZxiTJ0IqpX5KmyS0sDHjwwKCnplz884/smD1ihOyo3aEDcOaMnP2c8x8REZV9TJIMTdMv6cwZ4P59g522Th05w8DTp8CmTQY7bb5duyZHcE2bBpSHBtrffpOf965dgLW1XIttxw6uv0ZEVJ4wSTI0FxeZ0Qhh0PmSgMzapJJuchMCeP99uUjr558D48aV3URJCGDyZPlZx8cDzZsDJ08Cw4cDJvxtISIqV/hnvzgUwxIlgG6TmwErqZ5p40ZZi2L233LIM2fKmcDLmsePgX79gClT5P3Ro4G//gJq11Y2LiIiUgaTpOJQDJNKAoC3N9CwoRyKvnGjQU+dq0ePgFGj5P6nn2Yu3vrFF3IrK2JjZW67Zo1MBn/8EfjmGy5OS0RUnjFJKg6aJOnUKYP3staMcvvpJ+DSpeJv9goJkUtueHoC48cDH3wAzJolH5s4UdYqFUZyspz3KcuSeYo5dQpo0UKOXnN0lHG9/bbSURERkdKYJBUHV1fZRiMEcOCAQU+tSZIiIuRLVK8OvPeerFlKTDToS+HKFeCrr+T+d98BNjZy/6OPgOnT5f7YsfKx/MrIAP73Pxl7p04ydiVt3gy0bAlER8u11w4fBtq1UzYmIiIyDkySiksxTQVQs6acUPLFF2VT0PXrcsbnXr3kshht2sgE5vhxmZAUlhDAyJFyzbjAQHn+rMaNkx2cAdl3Z/78Z5/z4EHA11dOynjrljy2fDmQx9rDxUYI4OuvgZ49Za1W+/ZycdqaNUs+FiIiMk5MkopLMU0qCcgZt//8U3be/v13OfKqRg3ZV2n/fmDCBKBZM1mhNXFi4ZKl338Htm6Vidi8efrnBZo4UTbBAXIuoUWL9J/r+nVZA9aqFXDsGFChgmzG69xZxjZtWsHjK4rUVNmcNmaMTJaGDgW2bZNNbURERFqCckhISBAAREJCQuFPcuuWEIAQKpUQDx4YLLa8XL0qxPffC9GjhxB2dvLlASGCg4VIS8v/eR49EqJqVfncsWPzLpuRIcQnn2S+1pIlmY8lJAgxZowQFhbyMRMTIYYMESI2Vj5+9Kg8bmoqxOXLBX67hXL3rhBt2mTGM2eOfA9ERFT6GeT7OwsmSXoY7EOuWVN+G//+u2ECK4CUFCF+/FEmIIAQffoIkZqav+dOmiSfU6WKEElJzy6fkSHEyJGZOeGyZUL88IMQlStnJk8dOghx+nTO53btKh8fNCj/762wjh4VwstLvl6FCkJs3Vr8r0lERCXH0EkSm9uKUzH1S8oPCwvZpPTrr7LJ7NdfgZdfBp48yft5164BM2bI/W+/BWxtn/1aKpXsvP3eezIlevNN2YR1547soP3773LEWIMGOZ+rmW9p5UrZUbw4CAEsXiw7aN+8KTu7h4cDQUHF83pERFQ2MEkqTsXYLym/eveWy5hYWclkpVs32VE5N6NGyWH57dvLle7zS6WSnbc1Q+ednIC5c+XqLN265b7WWfPmQJcuQHo68OWX+X+9/Hr0SCZt774r+yK99JLsF1W/vuFfi4iIyhaVEGV1gYnCS0xMhFqtRkJCAuzt7Qt/on/+kYt9mZjIXtZqteGCLKC9ezMTpJYtgS1bcoazZYssY2YGnD4tV1cpqIwMOT1B3br57wh95Igc9WZqCly8KGt6DOHKFVl7dvq0vATTpwOffMLlRYiIyiqDfX//h18XxalKFTnsLCNDrm+hoLZt5WKtarUMpX174O7dzMefPJETRQKyNqkwCRIgE5CWLQs2UqxFC9n0ZcjapE2bgKZNZYLk7Czf+6efMkEiIqL841dGcSumJUoKw88P2LMHqFRJzqPUtq1cjgOQcwZduwa4u8uh/SVN0zdpxQrg6tXCnyctTU5w2bOnnFwzIAA4cYITRBIRUcExSSpuCnbe1qdxYzmXkpsbcPasnLvowIHMGbRnzZLzGJU0X185b1JRapP+/Rfo2DFzqZRRo+TH/txzhoqSiIjKE/ZJ0sOgbZrR0XLhM1NTIC5O9mg2Alevyia3mzczj7VpI2uacutkXdwOHQL8/eVHdekS8Pzz+X9ueLjsaB4TA9jZAUuWZC7hQkRE5QP7JJU2Hh5Aw4ayimTcOKWj0apeXdYg1aol75uaytFpSiVIgGwO7NSp4LVJoaGyOS0mRvalOnKECRIRERUdk6SSMG+evF28WNHpALLz8JBNb8HBwNKlxjEsPmvfpGvX8i6blibXjXvzTTm8v3dvmSAVttM5ERFRVkySSkLr1nJ2RQB45x3g8WNl48nCxQVYtkwuOmsM/P1lbVJaWmY/KX3i4+V0Bd99J+9PnAisXSub2oiIiAyBSVJJmTFDDh27fBmYOlXpaIyapjZp+XK5OG52ly7JprkdOwBrazmb+JQpHN5PRESGxa+VkqJWAwsXyv2vvwYiIxUNx5j5+wOBgfprk3bulCPhLl6U01AdPAi8+qoycRIRUdnGJKkkvfSS/EZPTwcGD5ZZAOmlqU0KDQVu3JDrr82ZIyedjI+XidSxY0CTJgoGSUREZRqTpJI2b56cjvrECWD2bKWjMVoBAXLOo7Q0YPJk2ZVr1Cg5eXlwsJyqwMVF4SCJiKhM4zxJehh6noUcli0D3npLdqg5c8Zwi5WVMX/9BbzwQuZ9ExPZUvnhh8pOVUBERMaJ8ySVBcHBcibHx4+BIUNkWxLl0LIl0KGD3Le3B/74Qw75Z4JEREQlgUmSElQqYNEiWZO0e7esWSK9QkOBzz6T8x8FBSkdDRERlSdsbtOj2JvbNGbNAj75BHBwAM6fB1xdi++1iIiIyjg2t5Ulo0YBTZvK4VojRigdDREREWXBJElJZmbATz/JhdN++w3YuFHpiIiIiOg/TJKU1qgRMGaM3B82DEhIUDQcIiIikpgkGYPPPwdq1gRu385MmIiIiEhRTJKMgbU18OOPcv/HH4F//1U2HiIiImKSZDTatAEaNJBzJoWHKx0NERFRucckyZj4+8vbiAhl4yAiIiImSUaFSRIREZHRYJJkTDRJ0rFjQGqqsrEQERGVc4omSfv370f37t3h7u4OlUqFjfmYJ2jfvn1o2rQprKys8Pzzz+OHH37IUWbdunWoW7cuLC0tUbduXWzYsKEYoi8GtWoBTk7AkyfAqVNKR0NERFSuKZokJScnw8fHB/Pnz89X+evXr6NLly5o1aoVTp48ifHjx+ODDz7AunXrtGUiIiLQt29fDBgwAKdOncKAAQPQp08fHD58uLjehuGoVICfn9xnkxsREZGijGbtNpVKhQ0bNqBnz565lvn000+xefNmnD9/Xnts6NChOHXqFCL+Syr69u2LxMREbNu2TVumc+fOcHR0xKpVq/IVS4mt3abPtGly3qTXXgPyGS8RERGV87XbIiIiEBgYqHOsU6dOOHbsGJ4+fZpnmfA8htWnpKQgMTFRZ1MMO28TEREZhVKVJMXGxsLFxUXnmIuLC9LS0nD37t08y8TGxuZ63pCQEKjVau3m4eFh+ODzq0ULwMQEuHkTiIlRLg4iIqJyrlQlSYBslstK01qY9bi+MtmPZTVu3DgkJCRot+joaANGXEAVKgD168t91iYREREpplQlSa6urjlqhOLi4mBmZoaKFSvmWSZ77VJWlpaWsLe319kUxSY3IiIixZWqJMnf3x9hYWE6x3bu3IlmzZrB3Nw8zzIBAQElFmeRMUkiIiJSnJmSL56UlIQrV65o71+/fh2RkZFwcnKCp6cnxo0bh1u3bmHFihUA5Ei2+fPnY/To0XjnnXcQERGBJUuW6IxaGzlyJFq3bo2ZM2eiR48e2LRpE3bt2oWDBw+W+PsrtOyTSlpYKBsPERFROaRoTdKxY8fQuHFjNG7cGAAwevRoNG7cGBMnTgQAxMTEICoqSlu+WrVq2Lp1K/bu3YtGjRrhiy++wNy5c/Hyyy9rywQEBGD16tVYtmwZGjZsiNDQUKxZswa+vr4l++aKomZNoGJFICUFiIxUOhoiIqJyyWjmSTImis6TpNGtG7BlCzB7NjBypDIxEBERlSLlep6kcoX9koiIiBTFJMlYMUkiIiJSFJMkY6WZVDIqCrh9W+loiIiIyh0mScbKzg5o0EDuszaJiIioxDFJMmZsciMiIlIMkyRjxiSJiIhIMUySjJkmSTp+XE4qSURERCWGSZIxq1EDqFRJTip58qTS0RAREZUrTJKMmUoF+PnJfTa5ERERlSgmScaO/ZKIiIgUUagkKTo6Gv/884/2/pEjRzBq1CgsXrzYYIHRf5gkERERKaJQSVL//v2xZ88eAEBsbCw6duyII0eOYPz48Zg6dapBAyz3mjeXk0pGRwO3bikdDRERUblRqCTp77//RosWLQAAv/76K+rXr4/w8HD88ssvCA0NNWR8ZGcHNGwo91mbREREVGIKlSQ9ffoUlpaWAIBdu3bhpZdeAgB4e3sjJibGcNGRxCY3IiKiEleoJKlevXr44YcfcODAAYSFhaFz584AgNu3b6NixYoGDZDAJImIiEgBhUqSZs6ciUWLFqFt27bo168ffHx8AACbN2/WNsORAWWdVDIlRdlYiIiIygmVEEIU5onp6elITEyEo6Oj9tiNGzdgY2MDZ2dngwWohMTERKjVaiQkJMDe3l7pcAAhAGdn4O5dWZukmTuJiIiItAz9/V2omqTHjx8jJSVFmyDdvHkTs2fPxsWLF0t9gmSUVCo2uREREZWwQiVJPXr0wIoVKwAA8fHx8PX1xTfffIOePXti4cKFBg2Q/sMkiYiIqEQVKkk6ceIEWrVqBQD47bff4OLigps3b2LFihWYO3euQQOk/zBJIiIiKlGFSpIePXqEChUqAAB27tyJ3r17w8TEBH5+frh586ZBA6T/NG8OmJoC//wjNyIiIipWhUqSatSogY0bNyI6Oho7duxAYGAgACAuLs44OjqXRba2nFSSiIioBBUqSZo4cSI+/vhjVK1aFS1atID/f01BO3fuROPGjQ0aIGXBJjciIqISU6gk6ZVXXkFUVBSOHTuGHTt2aI+3b98e3333ncGCo2yYJBEREZWYQs+TpPHPP/9ApVLhueeeM1RMijO6eZI0rl4FatQALCyAxETgv6VhiIiIyEjmScrIyMDUqVOhVqvh5eUFT09PODg44IsvvkBGRkaRg6JcPP88ULkykJoKnDihdDRERERlWqGSpAkTJmD+/PmYMWMGTp48iRMnTmD69OmYN28ePv/8c0PHSBqcVJKIiKjEmBXmScuXL8dPP/2El156SXvMx8cHzz33HN5//318+eWXBguQsvH3BzZvZpJERERUzApVk3T//n14e3vnOO7t7Y379+8XOSjKg6Ym6a+/gPR0ZWMhIiIqwwqVJPn4+GD+/Pk5js+fPx8NNXP5UPFo0QJQq4GYGGD5cqWjISIiKrMKNbpt37596Nq1Kzw9PeHv7w+VSoXw8HBER0dj69at2iVLSiujHd2m8c03wMcfA66uwKVLwH+znxMREZVnRjG6rU2bNrh06RJ69eqF+Ph43L9/H71798bZs2exbNmyIgdFzzB8OFC9OhAbC8yYoXQ0REREZVKR50nK6tSpU2jSpAnSS3lfGaOvSQKADRuA3r3lXEkXLwJeXkpHREREpCijqEkiI9CzJ9C2LZCSAowdq3Q0REREZQ6TpNJKpQK++07erl7NKQGIiIgMjElSadaoEfDmm3L/ww8BznZORERkMAWaTLJ37955Ph4fH1+UWKgwpk0D1qwBDh+WNUr9+ysdERERUZlQoJoktVqd5+bl5YWBAwcWV6ykj5sbMG6c3B87Fnj0SNl4iIiIygiDjm4rK0rF6LasHj8GvL2BqCjgiy+Azz5TOiIiIqISV+ZGt33//feoVq0arKys0LRpUxw4cCDXssHBwVCpVDm2evXqacuEhobqLfPkyZOSeDvKsLbOnC9pxgzg9m1l4yEiIioDFE2S1qxZg1GjRmHChAk4efIkWrVqhaCgIERFRektP2fOHMTExGi36OhoODk54dVXX9UpZ29vr1MuJiYGVlZWJfGWlPPaa4CfH5CcDEyYoHQ0REREpZ6iSdK3336LwYMH4+2330adOnUwe/ZseHh4YOHChXrLq9VquLq6ardjx47hwYMHeFMzwus/KpVKp5yrq2tJvB1laaYEAOSabidOKBsPERFRKadYkpSamorjx48jMDBQ53hgYCDCw8PzdY4lS5agQ4cO8Mo223RSUhK8vLxQpUoVdOvWDSdPnszzPCkpKUhMTNTZSiU/P6BfP0AIOSUAu5sREREVmmJJ0t27d5Geng4XFxed4y4uLoiNjX3m82NiYrBt2za8/fbbOse9vb0RGhqKzZs3Y9WqVbCyskLLli1x+fLlXM8VEhKiM0rPw8OjcG/KGMyYAVhZAfv3y6VLiIiIqFAU77itUql07gshchzTJzQ0FA4ODujZs6fOcT8/P7zxxhvw8fFBq1at8Ouvv6JWrVqYN29erucaN24cEhIStFt0dHSh3otR8PQEPv5Y7n/yiVy2hIiIiApMsSSpUqVKMDU1zVFrFBcXl6N2KTshBJYuXYoBAwbAwsIiz7ImJiZo3rx5njVJlpaWsLe319lKtU8/lfMnXbsG5JEcEhERUe4US5IsLCzQtGlThIWF6RwPCwtDQEBAns/dt28frly5gsGDBz/zdYQQiIyMhJubW5HiLVXs7IAvv5T706YBDx4oGw8REVEppGhz2+jRo/HTTz9h6dKlOH/+PD788ENERUVh6NChAGQzmL4ZvJcsWQJfX1/Ur18/x2NTpkzBjh07cO3aNURGRmLw4MGIjIzUnrPcGDQIaNAASEgAvv5a6WiIiIhKnQKt3WZoffv2xb179zB16lTExMSgfv362Lp1q3a0WkxMTI45kxISErBu3TrMmTNH7znj4+MxZMgQxMbGQq1Wo3Hjxti/fz9atGhR7O/HqJiYyNm3e/YE5swBPvgAKA9TIRARERkIlyXRo9QtS5IbIeS0AEeOACNGAHPnKh0RERFRsSlzy5JQMVKpgOnT5f6iRcDNm8rGQ0REVIowSSrr2rcHXnwRSE0Fpk5VOhoiIqJSg0lSeaAZ6RYaCly8qGgoREREpQWTpPLAzw/o3h3IyAAmTVI6GiIiolKBSVJ5MW2avF2zBoiMVDQUIiKi0oBJUnnRsCHw2mty/7PPlI2FiIioFGCSVJ5MmQKYmgJbtgDh4UpHQ0REZNSYJJUntWoBb74p98ePl/MoERERkV5MksqbiRMBCwtg3z5g1y6loyEiIjJaTJLKGw8P4L335D5rk4iIiHLFJKk8GjcOsLUFjh0DNm1SOhoiIiKjxCSpPHJxAUaNkvuffQakpysaDhERkTFiklReffwx4OAAnD0LrFqldDRERERGh0lSeeXgAIwZI/cnTQKePlU0HCIiImPDJKk8++ADwNkZuHYNWLJE6WiIiIiMCpOk8szWNnP27Y8/BvbuVTQcIiIiY8Ikqbx7912gY0cgORkICgJ27FA6IiIiIqPAJKm8s7AANm8GunUDnjwBXnpJ3iciIirnmCQRYGUFrFsHvPwykJoqb9euVToqIiIiRTFJIsnCAli9GujfH0hLA157Dfjf/5SOioiISDFMkiiTmRmwYgUweDCQkQEMGgT8+KPSURERESmCSRLpMjUFFi8G3n9frus2ZAgwf77SUREREZU4JkmUk4mJTIw++kjeHzEC+PprZWMiIiIqYUySSD+VSiZGn38u748ZA0ydKmuXiIiIygEmSZQ7lUomRl9+Ke9PmgR89ZWyMREREZUQJkn0bOPHZza3TZ0K3LmjbDxEREQlgEkS5c9HHwFNmwKPHgGzZysdDRERUbFjkkT5o1JlrvM2fz4QH69oOERERMWNSRLl30svAfXqAYmJnBaAiIjKPCZJlH8mJsCECXL/u++ApCRl4yEiIipGTJKoYPr0AWrWBO7fB374QeloiIiIig2TJCoYU1Ng3Di5P2sW8PixsvEQEREVEyZJVHBvvAF4egL//gssXap0NERERMWCSRIVnLk58Omncn/mTCA1Vdl4iIiIigGTJCqct94CXF2B6Gjgf/9TOhoiIiKDY5JEhWNlBXzyidwPCQHS0pSNh4iIyMCYJFHhvfsuULEicPUqsGaN0tEQEREZFJMkKjxbW2D0aLk/fTqQkaFsPERERAakeJL0/fffo1q1arCyskLTpk1x4MCBXMvu3bsXKpUqx3bhwgWdcuvWrUPdunVhaWmJunXrYsOGDcX9NsqvYcMAtRo4dw7YuFHpaIiIiAxG0SRpzZo1GDVqFCZMmICTJ0+iVatWCAoKQlRUVJ7Pu3jxImJiYrRbzZo1tY9FRESgb9++GDBgAE6dOoUBAwagT58+OHz4cHG/nfJJrQZGjJD706YBQigbDxERkYGohFDuW83X1xdNmjTBwoULtcfq1KmDnj17IiQkJEf5vXv3ol27dnjw4AEcHBz0nrNv375ITEzEtm3btMc6d+4MR0dHrFq1Kl9xJSYmQq1WIyEhAfb29gV7U+XR3btA1apAcjKwZQvQpYvSERERUTlk6O9vxWqSUlNTcfz4cQQGBuocDwwMRHh4eJ7Pbdy4Mdzc3NC+fXvs2bNH57GIiIgc5+zUqdMzz0lFUKkS8N57cv+LL1ibREREZYJiSdLdu3eRnp4OFxcXneMuLi6IjY3V+xw3NzcsXrwY69atw/r161G7dm20b98e+/fv15aJjY0t0DkBICUlBYmJiTobFdBHHwGWlsChQ0C2xJWIiKg0MlM6AJVKpXNfCJHjmEbt2rVRu3Zt7X1/f39ER0dj1qxZaN26daHOCQAhISGYMmVKYcInDVdX4O23gQULgC+/BF58UemIiIiIikSxmqRKlSrB1NQ0Rw1PXFxcjpqgvPj5+eHy5cva+66urgU+57hx45CQkKDdoqOj8/36lMWYMYCZGbB7N8DmTSIiKuUUS5IsLCzQtGlThIWF6RwPCwtDQEBAvs9z8uRJuLm5ae/7+/vnOOfOnTvzPKelpSXs7e11NioET09g0CC5/957wMOHysZDRERUBIo2t40ePRoDBgxAs2bN4O/vj8WLFyMqKgpDhw4FIGt4bt26hRUrVgAAZs+ejapVq6JevXpITU3FypUrsW7dOqxbt057zpEjR6J169aYOXMmevTogU2bNmHXrl04ePCgIu+x3Jk8GfjjD+D0aaBPH2DzZrkgLhERUSmjaJLUt29f3Lt3D1OnTkVMTAzq16+PrVu3wsvLCwAQExOjM2dSamoqPv74Y9y6dQvW1taoV68etmzZgi5ZhpwHBARg9erV+Oyzz/D555+jevXqWLNmDXx9fUv8/ZVLVaoAv/8OtG0LbN8uJ5tctAjIo08YERGRMVJ0niRjxXmSDGDzZqBnTzkdQEgIMHas0hEREVEZV2bmSaIy7qWXgDlz5P64ccDq1crGQ0REVEBMkqj4jBgBfPih3B80CGC/MCIiKkWYJFHx+vproFcvIDUV6NEDuHhR6YiIiIjyhUkSFS9TU2DlSsDXF7h/X67rdueO0lERERE9E5MkKn42NrIjd7VqwLVrsr/S48dKR0VERJQnJklUMpydgW3bAEdHub7bG28AGRlKR0VERJQrJklUcmrXBjZuBCwsgPXr5TImRERERopJEpWs1q2B0FC5/803sr8SERGREWKSRCWvXz9gwgS5v2iRsrEQERHlgkkSKWPIEHkbHg7cu6dsLERERHowSSJleHoCPj6y8/b27UpHQ0RElAOTJFJOt27y9vfflY2DiIhIDyZJpBxNkrR9O/D0qbKxEBERZcMkiZTTvDlQuTKQkAD89ZfS0RAREelgkkTKMTWVy5QAbHIjIiKjwySJlNW9u7z94w9l4yAiIsqGSRIpq2NHwNwcuHRJbkREREaCSRIpy94eaNNG7m/ZomwsREREWTBJIuVxKgAiIjJCTJJIeZok6cABID5e0VCIiIg0mCSR8qpXB+rUAdLSgJ07lY6GiIgIAJMkMhaa2iSOciMiIiPBJImMgyZJ2roVSE9XNhYiIiIwSSJjERAAODoC9+4Bhw4pHQ0RERGTJDISZmZAUJDcZ5MbEREZASZJZDzYL4mIiIwIkyQyHp07y/Xc/v4buHFD6WiIiKicY5JExsPREXjhBbnP2iQiIlIYkyQyLmxyIyIiI8EkiYyLJknaswdISlI2FiIiKteYJJFxqV1bzsCdmgqEhSkdDRERlWNMksi4qFRA9+5yn01uRESkICZJZHw0TW5btgAZGcrGQkRE5RaTJDI+rVoBFSoA//4LHDumdDRERFROMUki42NhAXTqJPfZ5EZERAphkkTGiVMBEBGRwpgkkXHq0kV24j55Erh1S+loiIioHGKSRMapcmXAz0/uszaJiIgUwCSJjBeb3IiISEGKJ0nff/89qlWrBisrKzRt2hQHDhzItez69evRsWNHVK5cGfb29vD398eOHTt0yoSGhkKlUuXYnjx5UtxvhQxNkyTt2gU8eqRsLEREVO4omiStWbMGo0aNwoQJE3Dy5Em0atUKQUFBiIqK0lt+//796NixI7Zu3Yrjx4+jXbt26N69O06ePKlTzt7eHjExMTqblZVVSbwlMqQGDQBPT+DJE2D3bqWjISKickYlhBBKvbivry+aNGmChQsXao/VqVMHPXv2REhISL7OUa9ePfTt2xcTJ04EIGuSRo0ahfj4+ELHlZiYCLVajYSEBNjb2xf6PGQAI0YA8+cD3t7A4cMArwcREeXC0N/fitUkpaam4vjx4wgMDNQ5HhgYiPDw8HydIyMjAw8fPoSTk5PO8aSkJHh5eaFKlSro1q1bjpqm7FJSUpCYmKizkZH47DOgShXgwgXg9dc5AzcREZUYxZKku3fvIj09HS4uLjrHXVxcEBsbm69zfPPNN0hOTkafPn20x7y9vREaGorNmzdj1apVsLKyQsuWLXH58uVczxMSEgK1Wq3dPDw8CvemyPBcXIANGwArK9mB+78aQyIiouKmeMdtlUqlc18IkeOYPqtWrcLkyZOxZs0aODs7a4/7+fnhjTfegI+PD1q1aoVff/0VtWrVwrx583I917hx45CQkKDdoqOjC/+GyPCaNQN+/FHuf/klsHatsvEQEVG5oFiSVKlSJZiamuaoNYqLi8tRu5TdmjVrMHjwYPz666/o0KFDnmVNTEzQvHnzPGuSLC0tYW9vr7ORkXnjDeCjj+R+cDBw6pSi4RARUdmnWJJkYWGBpk2bIiwsTOd4WFgYAgICcn3eqlWrEBwcjF9++QVdu3Z95usIIRAZGQk3N7cix0wKmzED6NhRTgfQsydw967SERERURlmpuSLjx49GgMGDECzZs3g7++PxYsXIyoqCkOHDgUgm8Fu3bqFFStWAJAJ0sCBAzFnzhz4+flpa6Gsra2hVqsBAFOmTIGfnx9q1qyJxMREzJ07F5GRkViwYIEyb5IMx8wMWL0aaNECuHoV6NMH2LEDMDdXOjIiIiqDFO2T1LdvX8yePRtTp05Fo0aNsH//fmzduhVeXl4AgJiYGJ05kxYtWoS0tDQMGzYMbm5u2m3kyJHaMvHx8RgyZAjq1KmDwMBA3Lp1C/v370eLFi1K/P1RMXByAjZtAuzsgD17gI8/VjoiIiIqoxSdJ8lYcZ6kUmDjRqBXL7m/dCnw5puKhkNERMorM/MkERVJz57A5Mlyf+hQOdEkERGRATFJotLr889lspSaKmuVbt9WOiIiIipDmCRR6WViAqxYAdSrB8TEAL17A48fKx0VERGVEUySqHSrUEF25HZ0lE1uTZsCR48qHRUREZUBik4BUNqlp6fj6dOnSodRKpmbm8PU1NQwJ6teXSZKr74KnD8P+PsDY8fKJUwsLAzzGkREVO5wdJsez+odL4RAbGws4uPjSz64MsTBwQGurq75WoYmX+7dA4YPl3MpAUDDhsDy5UCjRoY5PxERGTVDj25jTVIhaBIkZ2dn2NjYGO5LvpwQQuDRo0eIi4sDAMPNhl6xIrBqFfDyy8B77wGnTwPNm8sO3uPGcdJJIiIqENYk6ZFXJpqeno5Lly7B2dkZFStWVCjCsuHevXuIi4tDrVq1DNf0phEXJxOl9evl/SZNZK1S/fqGfR0iIjIanCdJYZo+SDY2NgpHUvppPsNi6dfl7Az89hvwyy+yU/eJE7JTd0gIkJZm+NcjIqIyh0lSIbGJreiK/TNUqYB+/YCzZ4Fu3eR8SuPHAy1byqY4IiKiPDBJokKpWrUqZs+erXQY+ePmBmzeDISGAmo1cOSIbH4bPRp4+FDp6IiIyEgxSSpH2rZti1GjRhnkXEePHsWQIUMMcq4SoVIBgwYBf/8NvPIKkJ4OfPcd4O0N/PorwK55RESUDZMk0hJCIC2f/XUqV65cOvtlVakCrF0LbN8O1KghlzLp2xcIDAQuXVI6OiIiMiJMksqJ4OBg7Nu3D3PmzIFKpYJKpUJoaChUKhV27NiBZs2awdLSEgcOHMDVq1fRo0cPuLi4wM7ODs2bN8euXbt0zpe9uU2lUuGnn35Cr169YGNjg5o1a2Lz5s0l/C4LoFMn4MwZYMoUwNIS2LULaNBAThfw6JHS0RERkRFgkmQIQgDJycps+WwmmjNnDvz9/fHOO+8gJiYGMTEx8PDwAACMGTMGISEhOH/+PBo2bIikpCR06dIFu3btwsmTJ9GpUyd0794dUVFReb7GlClT0KdPH5w+fRpdunTB66+/jvv37xf54y02VlZyVu6zZ4GgINmxe9o0uRbcH38oHR0RESmMk0kawqNHgJ2dMq+dlATY2j6zmFqthoWFBWxsbODq6goAuHDhAgBg6tSp6Nixo7ZsxYoV4ePjo70/bdo0bNiwAZs3b8bw4cNzfY3g4GD069cPADB9+nTMmzcPR44cQefOnQv11kpM9erAli3Axo3AyJHAjRtA9+7ASy8Bs2YBNWsqHSERESmANUmEZs2a6dxPTk7GmDFjULduXTg4OMDOzg4XLlx4Zk1Sw4YNtfu2traoUKGCdlZto6dSAb16AefOAWPGAGZmckRc3brAiBHAnTtKR0hERCWMNUmGYGMja3SUeu0iss1WE/XJJ59gx44dmDVrFmrUqAFra2u88sorSE1NzfM85tmW/VCpVMjIyChyfCXKzg6YOVOOhPvkE2DrVmD+fDlb99ixwKhRBvnMiYjI+DFJMgSVKl9NXkqzsLBAenr6M8sdOHAAwcHB6NWrFwAgKSkJN27cKObojEzdurIJbvdumSydOAFMmAB8/z3wxRfAwIGAoZdSISIio8LmtnKkatWqOHz4MG7cuIG7d+/mWstTo0YNrF+/HpGRkTh16hT69+9f+mqEDOXFF4GjR4Gffwa8vIBbt4C33gIaN5bTCHB+JSKiMotJUjny8ccfw9TUFHXr1kXlypVz7WP03XffwdHREQEBAejevTs6deqEJk2alHC0RsTEBOjfH7hwAfj6a8DBQU4fEBQk51c6flzpCImIqBiohOC/wtnltYrwkydPcP36dVSrVg1WVlYKRVg2lNrP8v594MsvZV8lTT8tHx/g9dflWnFVqigbHxFROZXX93dhsCaJqKCcnIBvvpE1S6+/DpibA6dOyVFxnp5Au3bAjz8CDx4oHSkRERUBkySiwqpWDVi5EoiJAX74AWjdWvZR2rsXGDIEcHWV0wqsXQs8fqx0tEREVEBMkoiKqmJF4N13gX37gJs3gRkzgIYNZVPcxo1Anz4yYQoOliPmnjGVAhERGQcmSUSG5OkJfPqpbH47c0bOreTpCSQmyrmWunUDnJ3lPEx//AGkpCgdMRER5YJJElFxqV8fCAkBrl8H9u8Hhg8H3NyAhARgxQq59ImLi5xz6fffmTARERkZJklExc3EBGjVCpg3D/jnH5kwjRgBuLvLhOl//5PrxDk7AwMGyBqnPXuAK1eAJ0+Ujp6IqNzijNtEJUmTMLVqBcyeDYSHy47dv/0G3L4tO4KvXKn7nMqVAQ+PnFujRoC3t5zxnYiIDI5JEpFSTEyAF16Q23ffARERwLp1wOnTQHS03B4/lovr3rkjl0bJrmZNoGdPufn6cqkUIiIDYpJEZAxMTICWLeWmIYScuDI6WjbTaRKn6Gjgxg3gyBHg8mU5C/jXX8vmupdekglT+/ZAaZqgk4jICDFJIjJWKpWcXqBiRdm0lt3Dh3L9uI0b5dQCcXHATz/JzdYW6NxZJkxduwKOjiUcPBFR6ceO2+VI27ZtMWrUKIOdLzg4GD179jTY+aiAKlQAXn1VLr4bFweEhQHDhsllUZKTZdPdgAGyT1O7drJJ7+pVpaMmIio1mCQRlQUWFkCHDnI9uago4Ngx4LPP5DQE6elyFvDRo4EaNYB69YBx42QfqPR0pSMnIjJaTJLKieDgYOzbtw9z5syBSqWCSqXCjRs3cO7cOXTp0gV2dnZwcXHBgAEDcPfuXe3zfvvtNzRo0ADW1taoWLEiOnTogOTkZEyePBnLly/Hpk2btOfbu3evcm+QMqlUQNOmwBdfyAktr10D5syR/ZTMzIBz5+Ss4AEBct6mt96STXaxsbIfFBERAQBUQvCvYnZ5rSKsb+V6IYBHj5SIFLCxyd8I8ISEBAQFBaF+/fqYOnUqACA9PR2NGjXCO++8g4EDB+Lx48f49NNPkZaWht27dyMmJgaenp746quv0KtXLzx8+BAHDhzAwIEDAQCDBw9GYmIili1bBgBwcnKChYVFvmPX91lSMYuPl/2YNm8Gtm6V8zRlZWsLVK8utxo1dG89PDh6joiMWl7f34XBjtsG8OgRYGenzGsnJcnvtWdRq9WwsLCAjY0NXF1dAQATJ05EkyZNMH36dG25pUuXwsPDA5cuXUJSUhLS0tLQu3dveHl5AQAaNGigLWttbY2UlBTt+agUcHAAXntNbk+fAgcOZCZMV6/KvkynT8stO3Nzuaivs7M8T9bN0VH3vlotfymsrWUmb2MjR9uZsPKaiEoPJknl2PHjx7Fnzx7Y6cnwrl69isDAQLRv3x4NGjRAp06dEBgYiFdeeQWOHClVNpibAy++KLfZs+WyKDduyGTpyhV5q9m/fl0uzHvpktwKy8pKJkxZkyfNZmure5t939JSd7OyynnM0lL2z9LcavaZnBFRITBJMgAbG1mjo9RrF1ZGRga6d++OmTNn5njMzc0NpqamCAsLQ3h4OHbu3Il58+ZhwoQJOHz4MKpVq1aEqMkoWVoCtWvLLbv0dDlX07VrwL17stlO3/bgQeb+o0dyS03NPM+TJ8ostWJqmjNx0uw/6765ue6tvmPm5rK/l+b2WfvZN805NJuZmYw5+8bZ1YlKlOJJ0vfff4+vv/4aMTExqFevHmbPno1WrVrlWn7fvn0YPXo0zp49C3d3d4wZMwZDhw7VKbNu3Tp8/vnnuHr1KqpXr44vv/wSvXr1Krb3oFLlr8lLaRYWFkjPMpqpSZMmWLduHapWrQozM/0/CiqVCi1btkTLli0xceJEeHl5YcOGDRg9enSO81EZZmoKeHnJraDS0+XM4Y8eZd5q9pOTM281xzX72Y+lpORvS02VTYnZY9CcqzRTqXImUCYm8riJSd5b1jLZy+fn+bmd71m3hjqPIW4Lc0zfprkWeR3Lej+3x/SVye15BTnfs24LEm9BYzXEsbwec3KS05+UEEWTpDVr1mDUqFH4/vvv0bJlSyxatAhBQUE4d+4cPD09c5S/fv06unTpgnfeeQcrV67EX3/9hffffx+VK1fGyy+/DACIiIhA37598cUXX6BXr17YsGED+vTpg4MHD8LX17ek36JRqVq1Kg4fPowbN27Azs4Ow4YNw48//oh+/frhk08+QaVKlXDlyhWsXr0aP/74I44dO4Y///wTgYGBcHZ2xuHDh3Hnzh3UqVNHe74dO3bg4sWLqFixItRqNczNzRV+l2R0TE1l/6SS7LiXkSETJU3SpLnV7KekyMezP5Z9y1ruWbdpaZnb06e572s2zXOzbxkZub8vITLLEZVHixYBQ4aU2MspOrrN19cXTZo0wcKFC7XH6tSpg549eyIkJCRH+U8//RSbN2/G+fPntceGDh2KU6dOISIiAgDQt29fJCYmYtu2bdoynTt3hqOjI1atWpWvuAo6uq20uHTpEgYNGoRTp07h8ePHuH79Op4+fYpPP/0Ue/bsQUpKCry8vNC5c2d8++23uHDhAj788EOcOHECiYmJ8PLywogRIzB8+HAAwJ07d/D6668jIiICSUlJ2LNnD9q2bZvveErzZ0lUbDIyZEKVnq5/y/pYRkbmJoTufc2Wnp75WNYy+srndo6CnK8wr5H9uYW9zXq+/JTVlNNXJvu+5qvyWfv5fUxfmfycv6jnK8zrluSxZz02bx4weDByU2ZGt6WmpuL48eMYO3aszvHAwECEh4frfU5ERAQCAwN1jnXq1AlLlizB06dPYW5ujoiICHz44Yc5ysyePTvXWFJSUpCSkqK9n5iYWMB3UzrUqlVLm0xmtX79er3l69Spg+3bt+d6vsqVK2Pnzp0Gi4+IIJt5CjCVBhEVH8WGfNy9exfp6elwcXHROe7i4oLY2Fi9z4mNjdVbPi0tTTsBYm5lcjsnAISEhECtVms3Dw+PwrwlIiIiKkMUHxeryjZaQwiR49izymc/XtBzjhs3DgkJCdotOjo63/ETERFR2aRYc1ulSpVgamqao4YnLi4uR02Qhqurq97yZmZmqFixYp5lcjsnAFhaWsLS0rIwb4OIiIjKKMVqkiwsLNC0aVOEhYXpHA8LC0NAQIDe5/j7++cov3PnTjRr1kw7qiq3Mrmdk4iIiEgfRacAGD16NAYMGIBmzZrB398fixcvRlRUlHbeo3HjxuHWrVtYsWIFADmSbf78+Rg9ejTeeecdREREYMmSJTqj1kaOHInWrVtj5syZ6NGjBzZt2oRdu3bh4MGDirxHIiIiKp0UTZL69u2Le/fuYerUqYiJiUH9+vWxdetW7TphMTExiIqK0pavVq0atm7dig8//BALFiyAu7s75s6dq50jCQACAgKwevVqfPbZZ/j8889RvXp1rFmzxuBzJHFd4KLjZ0hERMZM0XmSjFVe8yykp6fj0qVLcHZ21vaDosK5d+8e4uLiUKtWLZhydXkiIiqiMjNPUmllamoKBwcHxMXFAQBsbGzyHDlHOQkh8OjRI8TFxcHBwYEJEhERGSUmSYXg6uoKANpEiQrHwcFB+1kSEREZGyZJhaBSqeDm5gZnZ2c85RpKhWJubs4aJCIiMmpMkorA1NSUX/RERERllOIzbhMREREZIyZJRERERHowSSIiIiLSg32S9NBMHZWYmKhwJERERJRfmu9tQ00BySRJj3v37gEAPDw8FI6EiIiICurevXtQq9VFPg+TJD2cnJwAAFFRUQb5kKnwEhMT4eHhgejoaIPMnkpFw+thPHgtjAevhfFISEiAp6en9nu8qJgk6WFiIrtqqdVq/sAbCXt7e14LI8LrYTx4LYwHr4Xx0HyPF/k8BjkLERERURnDJImIiIhIDyZJelhaWmLSpEmwtLRUOpRyj9fCuPB6GA9eC+PBa2E8DH0tVMJQ4+SIiIiIyhDWJBERERHpwSSJiIiISA8mSURERER6MEkiIiIi0oNJkh7ff/89qlWrBisrKzRt2hQHDhxQOqQyb//+/ejevTvc3d2hUqmwceNGnceFEJg8eTLc3d1hbW2Ntm3b4uzZs8oEW8aFhISgefPmqFChApydndGzZ09cvHhRpwyvR8lYuHAhGjZsqJ2k0N/fH9u2bdM+zuugnJCQEKhUKowaNUp7jNejZEyePBkqlUpnc3V11T5uyOvAJCmbNWvWYNSoUZgwYQJOnjyJVq1aISgoCFFRUUqHVqYlJyfDx8cH8+fP1/v4V199hW+//Rbz58/H0aNH4erqio4dO+Lhw4clHGnZt2/fPgwbNgyHDh1CWFgY0tLSEBgYiOTkZG0ZXo+SUaVKFcyYMQPHjh3DsWPH8OKLL6JHjx7aP/i8Dso4evQoFi9ejIYNG+oc5/UoOfXq1UNMTIx2O3PmjPYxg14HQTpatGghhg4dqnPM29tbjB07VqGIyh8AYsOGDdr7GRkZwtXVVcyYMUN77MmTJ0KtVosffvhBgQjLl7i4OAFA7Nu3TwjB66E0R0dH8dNPP/E6KOThw4eiZs2aIiwsTLRp00aMHDlSCMHfi5I0adIk4ePjo/cxQ18H1iRlkZqaiuPHjyMwMFDneGBgIMLDwxWKiq5fv47Y2Fid62JpaYk2bdrwupSAhIQEAJkLP/N6KCM9PR2rV69GcnIy/P39eR0UMmzYMHTt2hUdOnTQOc7rUbIuX74Md3d3VKtWDa+99hquXbsGwPDXgQvcZnH37l2kp6fDxcVF57iLiwtiY2MVioo0n72+63Lz5k0lQio3hBAYPXo0XnjhBdSvXx8Ar0dJO3PmDPz9/fHkyRPY2dlhw4YNqFu3rvYPPq9DyVm9ejVOnDiBo0eP5niMvxclx9fXFytWrECtWrXw77//Ytq0aQgICMDZs2cNfh2YJOmhUql07gshchyjksfrUvKGDx+O06dP4+DBgzke4/UoGbVr10ZkZCTi4+Oxbt06DBo0CPv27dM+zutQMqKjozFy5Ejs3LkTVlZWuZbj9Sh+QUFB2v0GDRrA398f1atXx/Lly+Hn5wfAcNeBzW1ZVKpUCaampjlqjeLi4nJkpVRyNKMWeF1K1ogRI7B582bs2bMHVapU0R7n9ShZFhYWqFGjBpo1a4aQkBD4+Phgzpw5vA4l7Pjx44iLi0PTpk1hZmYGMzMz7Nu3D3PnzoWZmZn2M+f1KHm2trZo0KABLl++bPDfCyZJWVhYWKBp06YICwvTOR4WFoaAgACFoqJq1arB1dVV57qkpqZi3759vC7FQAiB4cOHY/369di9ezeqVaum8zivh7KEEEhJSeF1KGHt27fHmTNnEBkZqd2aNWuG119/HZGRkXj++ed5PRSSkpKC8+fPw83NzfC/FwXu6l3GrV69Wpibm4slS5aIc+fOiVGjRglbW1tx48YNpUMr0x4+fChOnjwpTp48KQCIb7/9Vpw8eVLcvHlTCCHEjBkzhFqtFuvXrxdnzpwR/fr1E25ubiIxMVHhyMue9957T6jVarF3714RExOj3R49eqQtw+tRMsaNGyf2798vrl+/Lk6fPi3Gjx8vTExMxM6dO4UQvA5Kyzq6TQhej5Ly0Ucfib1794pr166JQ4cOiW7duokKFSpov6cNeR2YJOmxYMEC4eXlJSwsLESTJk20Q5+p+OzZs0cAyLENGjRICCGHdU6aNEm4uroKS0tL0bp1a3HmzBllgy6j9F0HAGLZsmXaMrweJeOtt97S/i2qXLmyaN++vTZBEoLXQWnZkyRej5LRt29f4ebmJszNzYW7u7vo3bu3OHv2rPZxQ14HlRBCFLGmi4iIiKjMYZ8kIiIiIj2YJBERERHpwSSJiIiISA8mSURERER6MEkiIiIi0oNJEhEREZEeTJKIiIiI9GCSRESUDyqVChs3blQ6DCIqQUySiMjoBQcHQ6VS5dg6d+6sdGhEVIaZKR0AEVF+dO7cGcuWLdM5ZmlpqVA0RFQesCaJiEoFS0tLuLq66myOjo4AZFPYwoULERQUBGtra1SrVg1r167Vef6ZM2fw4osvwtraGhUrVsSQIUOQlJSkU2bp0qWoV68eLC0t4ebmhuHDh+s8fvfuXfTq1Qs2NjaoWbMmNm/eXLxvmogUxSSJiMqEzz//HC+//DJOnTqFN954A/369cP58+cBAI8ePULnzp3h6OiIo0ePYu3atdi1a5dOErRw4UIMGzYMQ4YMwZkzZ7B582bUqFFD5zWmTJmCPn364PTp0+jSpQtef/113L9/v0TfJxGVIMOsyUtEVHwGDRokTE1Nha2trc42depUIYQQAMTQoUN1nuPr6yvee+89IYQQixcvFo6OjiIpKUn7+JYtW4SJiYmIjY0VQgjh7u4uJkyYkGsMAMRnn32mvZ+UlCRUKpXYtm2bwd4nERkX9kkiolKhXbt2WLhwoc4xJycn7b6/v7/OY/7+/oiMjAQAnD9/Hj4+PrC1tdU+3rJlS2RkZODixYtQqVS4ffs22rdvn2cMDRs21O7b2tqiQoUKiIuLK+xbIiIjxySJiEoFW1vbHM1fz6JSqQAAQgjtvr4y1tbW+Tqfubl5judmZGQUKCYiKj3YJ4mIyoRDhw7luO/t7Q0AqFu3LiIjI5GcnKx9/K+//oKJiQlq1aqFChUqoGrVqvjzzz9LNGYiMm6sSSKiUiElJQWxsbE6x8zMzFCpUiUAwNq1a9GsWTO88MIL+Pnnn3HkyBEsWbIEAPD6669j0qRJGDRoECZPnow7d+5gxIgRGDBgAFxcXAAAkydPxtChQ+Hs7IygoCA8fPgQf/31F0aMGFGyb5SIjAaTJCIqFbZv3w43NzedY7Vr18aFCxcAyJFnq1evxvvvvw9XV1f8/PPPqFu3LgDAxsYGO3bswMiRI9G8eXPY2Njg5Zdfxrfffqs916BBg/DkyRN89913+Pjjj1GpUiW88sorJfcGicjoqIQQQukgiIiKQqVSYcOGDejZs6fSoRBRGcI+SURERER6MEkiIiIi0oN9koio1GOvASIqDqxJIiIiItKDSRIRERGRHkySiIiIiPRgkkRERESkB5MkIiIiIj2YJBERERHpwSSJiIiISA8mSURERER6MEkiIiIi0uP/GkA9gniRO5cAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the results\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(errors_train,'r-',label='train')\n",
    "ax.plot(errors_test,'b-',label='test')\n",
    "ax.set_ylim(0,100); ax.set_xlim(0,n_epoch)\n",
    "ax.set_xlabel('Epoch'); ax.set_ylabel('Error')\n",
    "ax.set_title('TrainError %3.2f, Test Error %3.2f'%(errors_train[-1],errors_test[-1]))\n",
    "ax.legend()\n",
    "plt.show()\n",
    "\n",
    "# Plot the results\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(losses_train,'r-',label='train')\n",
    "ax.plot(losses_test,'b-',label='test')\n",
    "ax.set_xlim(0,n_epoch)\n",
    "ax.set_xlabel('Epoch'); ax.set_ylabel('Loss')\n",
    "ax.set_title('Train loss %3.2f, Test loss %3.2f'%(losses_train[-1],losses_test[-1]))\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q-yT6re6GZS4"
   },
   "source": [
    "**TO DO**\n",
    "\n",
    "Play with the model -- try changing the number of layers, hidden units, learning rate, batch size, momentum or anything else you like.  See if you can improve the test results.\n",
    "\n",
    "Is it a good idea to optimize the hyperparameters in this way?  Will the final result be a good estimate of the true test performance?"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "authorship_tag": "ABX9TyOuKMUcKfOIhIL2qTX9jJCy",
   "gpuType": "T4",
   "include_colab_link": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}