Pytorch/SelfNormalizingNetworks_CNN_CIFAR10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tutorial on self-normalizing networks on the CIFAR10 data set: convolutional neural networks\n",
    "\n",
    "*Author:* Kajetan Schweighofer, 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "50000 10000\n"
     ]
    }
   ],
   "source": [
    "# load data and preprocess\n",
    "\n",
    "path = os.path.join(\".\", \"dataset\", \"cifar10\")\n",
    "os.makedirs(path, exist_ok=True)\n",
    "\n",
    "# convert PIL image to tensor\n",
    "transform = transform=transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\n",
    "])\n",
    "\n",
    "train = torchvision.datasets.CIFAR10(path, download=True, train=True, transform=transform)\n",
    "test = torchvision.datasets.CIFAR10(path, download=True, train=False, transform=transform)\n",
    "\n",
    "print(len(train), len(test))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Functions"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "\n",
    "    def __init__(self, out_features: int, use_selu: bool=False):\n",
    "        super(CNN, self).__init__()\n",
    "\n",
    "        activation = nn.SELU() if use_selu else nn.ReLU()\n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=128, kernel_size=5),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            activation,\n",
    "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            activation,\n",
    "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3),\n",
    "            activation,\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=128*4*4, out_features=2048),\n",
    "            activation,\n",
    "            nn.Linear(in_features=2048, out_features=1024),\n",
    "            activation,\n",
    "            nn.Linear(in_features=1024, out_features=out_features)\n",
    "        )\n",
    "\n",
    "        if use_selu:\n",
    "            for param in self.net.parameters():\n",
    "                # biases zero\n",
    "                if len(param.shape) == 1:\n",
    "                    nn.init.constant_(param, 0.1)\n",
    "                # others using lecun-normal initialization\n",
    "                else:\n",
    "                    nn.init.kaiming_normal_(param, mode='fan_in', nonlinearity='linear')\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net(x)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Accuracy metric"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "class Accuracy(nn.Module):\n",
    "\n",
    "    def forward(self, x, y):\n",
    "\n",
    "        y_pred = F.softmax(x, dim=1).argmax(dim=1).cpu().numpy()\n",
    "        y = y.cpu().numpy()\n",
    "\n",
    "        return accuracy_score(y_true=y, y_pred=y_pred)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Training / Evaluation methods"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "def _forward(network: nn.Module, data: DataLoader, metric: callable):\n",
    "\n",
    "    for x, y in data:\n",
    "\n",
    "        x = x.to(next(network.parameters()).device)\n",
    "\n",
    "        y_hat = network.forward(x).cpu()\n",
    "        loss = metric(y_hat, y)\n",
    "        yield loss\n",
    "\n",
    "@torch.enable_grad()\n",
    "def update(network: nn.Module, data: DataLoader, loss: nn.Module,\n",
    "           opt: torch.optim.Optimizer) -> list:\n",
    "\n",
    "    network.train()\n",
    "\n",
    "    errs = []\n",
    "    for err in _forward(network, data, loss):\n",
    "        errs.append(err.item())\n",
    "        opt.zero_grad()\n",
    "        try:\n",
    "            err.backward()\n",
    "            opt.step()\n",
    "        except:\n",
    "            print('error in update step')\n",
    "    return errs\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluate(network: nn.Module, data: DataLoader, metric: callable) -> float:\n",
    "\n",
    "    network.eval()\n",
    "\n",
    "    performance = []\n",
    "    for p in _forward(network, data, metric):\n",
    "        performance.append(p.item())\n",
    "    return np.mean(performance).item()\n",
    "\n",
    "\n",
    "def fit(network: nn.Module, trainloader: DataLoader, valloader: DataLoader,\n",
    "          testloader: DataLoader, epochs: int, lr: float):\n",
    "    optimizer = torch.optim.SGD(params=network.parameters(), lr=lr)\n",
    "    ce = nn.CrossEntropyLoss()\n",
    "    accuracy = Accuracy()\n",
    "\n",
    "    train_losses, val_losses, accuracies = [], [], []\n",
    "\n",
    "    # performance before training\n",
    "    val_losses.append(evaluate(network=network, data=valloader, metric=ce))\n",
    "\n",
    "    pbar = tqdm(range(epochs))\n",
    "    for ep in pbar:\n",
    "        # update network\n",
    "        tl = update(network=network, data=trainloader, loss=ce, opt=optimizer)\n",
    "        train_losses.extend(tl)\n",
    "        vl = evaluate(network=network, data=valloader, metric=ce)\n",
    "        val_losses.append(vl)\n",
    "        ac = evaluate(network=network, data=valloader, metric=accuracy)\n",
    "\n",
    "        if len(accuracies) == 0 or ac > max(accuracies):\n",
    "            # here we would store the model on disc for early stopping\n",
    "            best_model = copy.deepcopy(network)\n",
    "\n",
    "        accuracies.append(ac)\n",
    "\n",
    "        print(f\"train loss: {round(np.mean(tl), 4):.4f}, \"\n",
    "              f\"val loss: {round(vl, 4):.4f}, \"\n",
    "              f\"accuracy: {round(ac * 100, 2):.2f}%\")\n",
    "\n",
    "        pbar.set_description_str(desc=f\"Epoch {ep+1}\")\n",
    "\n",
    "    # evaluate on best model obtained throughout training\n",
    "    acc = evaluate(network=best_model, data=testloader, metric=accuracy)\n",
    "\n",
    "    print(f\"Final accuracy on testset: {round(acc*100, 2):.2f}%\")\n",
    "\n",
    "    return train_losses, val_losses, accuracies, acc"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Training\n",
    "\n",
    "### Hyperparameters"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "epochs = 20\n",
    "lr = 1e-2\n",
    "batch_size = 128\n",
    "num_workers = 4"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Dataloaders"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# obtain validation set (1/5 of train data to be equal to size of test data)\n",
    "rng = np.random.default_rng(seed=42)\n",
    "val_inds = rng.choice(np.arange(len(train)), size=len(train)//5, replace=False)\n",
    "train_inds = np.delete(np.arange(len(train)), val_inds)\n",
    "\n",
    "trainloader = DataLoader(Subset(train, indices=train_inds),\n",
    "                         batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "valloader = DataLoader(Subset(train, indices=val_inds),\n",
    "                       batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "testloader = DataLoader(test, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=num_workers)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Train Networks"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [02:29<00:00,  7.46s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.2949, val loss: 2.2783, accuracy: 18.43%\n",
      "train loss: 2.1617, val loss: 1.9853, accuracy: 29.23%\n",
      "train loss: 1.8864, val loss: 1.7999, accuracy: 35.42%\n",
      "train loss: 1.7385, val loss: 1.6512, accuracy: 39.29%\n",
      "train loss: 1.6325, val loss: 1.5824, accuracy: 41.91%\n",
      "train loss: 1.5549, val loss: 1.5021, accuracy: 45.39%\n",
      "train loss: 1.4945, val loss: 1.4551, accuracy: 47.13%\n",
      "train loss: 1.4380, val loss: 1.4170, accuracy: 48.19%\n",
      "train loss: 1.3916, val loss: 1.3848, accuracy: 49.69%\n",
      "train loss: 1.3478, val loss: 1.3297, accuracy: 51.63%\n",
      "train loss: 1.3051, val loss: 1.2884, accuracy: 53.42%\n",
      "train loss: 1.2661, val loss: 1.2543, accuracy: 54.84%\n",
      "train loss: 1.2277, val loss: 1.2502, accuracy: 55.30%\n",
      "train loss: 1.1865, val loss: 1.2425, accuracy: 56.32%\n",
      "train loss: 1.1552, val loss: 1.1720, accuracy: 58.10%\n",
      "train loss: 1.1163, val loss: 1.1182, accuracy: 60.43%\n",
      "train loss: 1.0817, val loss: 1.1070, accuracy: 60.69%\n",
      "train loss: 1.0451, val loss: 1.1049, accuracy: 60.52%\n",
      "train loss: 1.0169, val loss: 1.0809, accuracy: 62.12%\n",
      "train loss: 0.9802, val loss: 1.0306, accuracy: 63.12%\n",
      "Final accuracy on testset: 63.45%\n"
     ]
    }
   ],
   "source": [
    "# ReLU training\n",
    "\n",
    "# 28x28 = 784 input images for 10 classes\n",
    "network = CNN(out_features=10, use_selu=False).to(device)\n",
    "rtl, rvl, raccs, racc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [02:26<00:00,  7.32s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 1.6133, val loss: 1.4079, accuracy: 49.98%\n",
      "train loss: 1.2576, val loss: 1.2348, accuracy: 55.82%\n",
      "train loss: 1.1133, val loss: 1.1990, accuracy: 58.06%\n",
      "train loss: 1.0085, val loss: 1.1313, accuracy: 59.89%\n",
      "train loss: 0.9308, val loss: 1.1019, accuracy: 60.87%\n",
      "train loss: 0.8601, val loss: 1.0384, accuracy: 63.41%\n",
      "train loss: 0.7988, val loss: 1.0254, accuracy: 64.15%\n",
      "train loss: 0.7419, val loss: 1.0031, accuracy: 65.77%\n",
      "train loss: 0.6818, val loss: 1.0368, accuracy: 64.32%\n",
      "train loss: 0.6287, val loss: 1.0225, accuracy: 65.02%\n",
      "train loss: 0.5744, val loss: 1.0178, accuracy: 66.04%\n",
      "train loss: 0.5304, val loss: 1.0631, accuracy: 64.61%\n",
      "train loss: 0.4790, val loss: 1.0301, accuracy: 66.08%\n",
      "train loss: 0.4301, val loss: 1.0217, accuracy: 67.11%\n",
      "train loss: 0.3826, val loss: 1.0237, accuracy: 67.50%\n",
      "train loss: 0.3422, val loss: 1.0612, accuracy: 67.22%\n",
      "train loss: 0.2963, val loss: 1.0604, accuracy: 67.65%\n",
      "train loss: 0.2549, val loss: 1.0907, accuracy: 67.37%\n",
      "train loss: 0.2192, val loss: 1.1121, accuracy: 67.36%\n",
      "train loss: 0.1830, val loss: 1.1725, accuracy: 66.84%\n",
      "Final accuracy on testset: 67.78%\n"
     ]
    }
   ],
   "source": [
    "# SELU training\n",
    "network = CNN(out_features=10, use_selu=True).to(device)\n",
    "stl, svl, saccs, sacc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Plot results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABeoElEQVR4nO29d3xj1Zn//z4qlmRL7mVcxuOpnj6eQgsBhg2dUBJIICGNZMOmbpJtyXfLd5Nd8ttswne/uyTs8iVZkpCFQIBAgABJIBAg1JnB0/uMZ8Ye997Vzu+PcyVdyZIs27Llct6vl6zb79GVfJ97zvM8n0dIKdFoNBqNJhGWTDdAo9FoNLMbbSg0Go1GkxRtKDQajUaTFG0oNBqNRpMUbSg0Go1GkxRtKDQajUaTFG0oFjBCiOeEEJ+cBe34phDif6bhuJ8SQrxmmh8QQixLZdtJnGtarqUQ4idCiDvTfVwNCCEahBCXZbodcwFtKOYYxs0u9AoKIYZN87dN5FhSyqullD+drrZOFSFEpRDCL4RYHmfdE0KIuyZyPCmlW0p5Ig3tGmPYZvu1nO0IIV4WQozE/L6fznS7NAptKOYYxs3OLaV0A6eB60zLHgxtJ4SwZa6V6UFK2QS8CHzcvFwIUQhcA+gb8xxECGFNsOpL5t+3lPK6GW2YJiHaUMwThBDbhRCNQoivCyFagB8LIQqEEM8IIdqFEN3GdJVpn5eFEH9qTH9KCPGaEOIuY9uTQoirk5zvG0KI40KIfiHEASHEB0zrkh5LCLFUCPEHY9/fAcVJPtpPiTEUwK3Afinl3mTtiNNmKYRYYUwXCSGeEkL0CSHeBpbHbPsfQogzxvqdQoiLjOVXAX8L3GI89e6Ocy0tQoi/F0KcEkK0CSEeEELkGetqjHZ8UghxWgjRIYT4uySfP/YzfFYIcUwI0WW0v8JYLoQQ/9c4X68QYo8QYr2x7hrj2vQLIZqEEH+V4NjJ2v28EOJLMdvvFkJ80JheLYT4ndGuw0KID5u2+4kQ4r+EEM8KIQaBS1P9vMb+od/23xrXq0GYes9CiDyjre1G2/9eCGExrf+sEOKg6TeyxXT4OuNa9QohHhFCOI19io3/lx7jM71qPuaCQ0qpX3P0BTQAlxnT2wE/8K+AA3ABRcBNQDbgAR4FnjTt/zLwp8b0pwAf8FnACnweOAuIBOf+EFCBeti4BRgEylM5FvAG8G9GOy8G+oH/SXAeF9ALvNe07A3gqym24zXTfhJYYUw/DPwCyAHWA00x237MuH424C+BFsBprPtmbHtjruWngWPAMsAN/BL4mbGuxmjHD43PtgkYBdYk+Pw/Ae40pv8E6AC2GNfu+8ArxrorgZ1APiCANabr0AxcZEwXAFsSnCtZuz8B/NG07Vqgx2hHDnAGuN24XluMdq4zfYZe4ELje3LGOXf4+sVZtx312w79Zi4xvudaY/0DwK9Qv/Ea4AjwGdPvowk4x7guK4Alpv+ft1G/n0LgIPA5Y92/APcCduN1EQn+FxbCK+MN0K8pfHljDYU33j+hafs6oNs0H/7nRN1Uj5nWZRs3tEUptqUeuGG8YwHVxj99jmn9QyQwFMb6HwH3GdMrjc9ZmmI7xhgKlPHyAatN6/4/87ZxjtsNbDKmvxnb3phr+SLwBdO6WuN8NiKGosq0/m3g1gTn/QkRQ/HfwHdN69zGcWtQRuQIcD5giTnGaeDPgNxxvsNk7fagbs5LjHXfBu43pm8BXo051v8D/tH0GR4Y59wvA0Mo4xN6/bPptx37m/kF8A/GdzkKrDWt+zPgZWP6N8BXkvz/fMw0/13gXmP6n1DGZ8VU/0/nw2vhdqXmJ+1SypHQjBAiWwjx/4zueB/wCpAvEo8Rt4QmpJRDxqQ73oZCiE8IIeqNrnkP6qncPISU6FgVKGM1aNr21Dif66fAh41hgY8Dz0sp21JsRzxKUDe/M4naIIT4S2O4otc4bl4Kxw1REXO8U8b5ykzLWkzTQyS4zsmOK6UcADqBSinl74EfAPcArUKI+4QQucamN6F8OqeEGvK7YKLtllL2A79GDfthvId8YkuA80LfgXG9bkM9GIQwX+tE/LmUMt/0+gfTuni/mQrUd5IVp92VxvRi4HiScyb6Hr6H6l39VghxQgjxjRTaP2/RhmJ+ESsF/Jeop8LzpJS5qGEeUF3wSSOEWIIaOvkSUCSlzAf2pXjcZqBACJFjWladbAcp5auoG+INqCGhB6bYjnbUE+rieG0w/BFfBz4MFBjH7TUddzzJ5bOom6f52H6gdZz9xiPquMY1LEINrSClvFtKuRVYB6wC/tpY/o6U8gagFHgS9TQ+mXb/HPiIYWhcwEvG8jPAH2Ju8m4p5edNx5qqTHW838xZ1BCXL067m0xtGxM1Nx5Syn4p5V9KKZcB1wF/IYR436RaPg/QhmJ+4wGGgR6hIoX+MU3HzUH947cDCCFuRz3Jj4uU8hSwA/iWECJLCPFe1D/ieDyA8r/kA6GwyUm1Q0oZQI2/f9Poda0FzDkQHtQNsh2wCSH+N5BrWt8K1CRxbv4c+JpQTns3aljrESmlP4XPmYyHgNuFEHVCCIdx3LeklA1CiHOEEOcJIeyoIaIRIGBc49uEEHlSSh/QBwQm2e5nUTfkfzKWB43lzwCrhBAfF0LYjdc5Qog1U/y8sYR+MxcB7wceNb7LXwDfFkJ4jIeHvwBC4cs/Av5KCLFVKFYY2yRFCPF+Y1tB5Jolum7zHm0o5jf/jnry6wDeBJ5Px0GllAeA/4NyKrcCG4A/TuAQHwXOA7pQxuuBFPZ5APWk+IiUcjQN7fgSapihBTWG/mPTut8Az6HG/E+hbrrmoZNHjfdOIcSuOMe+H/gZaqjvpLH/l1NsV0KklC+ixuUfR/XMlhMZCspF9a66jTZ3AqE8k48DDcbw4+dQvbJ4JG23cd1/CVyGMlqh5f3AFUZbzqKuaSioYiL8QETnUew0rWsxPttZ1JDX56SUh4x1X0YZxxPAa0bb7jfa9ijKn/IQKmjiSZTjejxWAi8AA6jf139KKV+e4OeZN4SiUDQajWZWIoTYjgoeqBpnU800oXsUGo1Go0mKNhQajUajSYoeetJoNBpNUnSPQqPRaDRJmfPCcfEoLi6WNTU1mW6GRqPRzBl27tzZIaUsibduXhqKmpoaduzYkelmaDQazZxBCJFQIUEPPWk0Go0mKdpQaDQajSYp2lBoNBqNJinaUGg0Go0mKdpQaDQajSYp2lBoNBqNJinaUGg0Go0mKdpQhJASDj0Lh9OixK3RaDTzhnmVcCeEuA64bsWKFZM7wFNfhuxCqL0qre3SaDSaucy86lFIKZ+WUt6Rl5c38Z2FgMot0HEUBtrS3ziNRqOZo8wrQzFlKjYDEg78KtMt0Wg0mlmDNhRmPOXqte/xTLdEo9FoZg3aUMRSsRlOvwG9jZluiUaj0cwKtKEwU7Qcat6rpvc/kdm2aDQazSxBG4ooBOSUql6FHn7SaDQaQBuKaIQFZBDW3wRn34WuE5lukUaj0WQcbSjMCAFIWPcBNb/vlxltjkaj0cwGtKGIQqgM7bwqqL5AGwqNRqNBG4pohAD/iJpefxO07Ye2g5ltk0aj0WQYbSjMdJ1U78M9sPYG5bPQvQqNRrPA0YbCTKg3MdoP7lKouUhFP0mZ2XZpNBpNBtGGIhnrb4Ku49C8O9Mt0Wg0mowxr9Rjp8rPjwoGvJLh5kYsOSOsyj2Hy4SNlj8+SN97l+Fx2fH6A9gsFoJSkuey43aoS2i1CIQQGf4EGo1Gk360oTDx/cN5nB3JArqMF/y3fQO1+37J1TsvRhodMKtFkGW1kGWzYLeqabvNQqnHwfZVpRTkZAFw6zmL8QclWTbdcdNoNHMXbShM/GJ7D92j0Fm0hT5bMUIIsk98iKrdf8v3zhvlhGs97QOj+AOS5t4RfIEgXn8w/P7u6R52ne7h/KWFbK8t5eF3zkQd/4a6CnIc+pJrNJq5hb5rmahyqxfL86GgUi2s/Tjs/ydudrwNV92cdP93T3fz7y8c5ZUj7ew41c3Fq0q4cHlxuEfxq/qzbFqcx+pFuVgtephKo9HMDfSYSDxG+yPTzlxYeYUSCQwGku62ubqAn376XH73Fxdz0cpifneglf/zu8O8fbKLQFBFTu0+08sj75zhTNcQXn9wOj+FRqPRpAVtKOLR+E70/PqbYLANGl5LafcVpR5+9MlzeOxzF7C0OIcn65v4jxePsK+pF2mE2r56tIPHdjbS1j+S7tZrNBpNWtGGIhVWXgFZ7gkrym6rKeRXX7yQH35iG3arhYfePs29fzjOyY7B8DYvHGijY2CUYW+Ah946zc5TXeluvUaj0UwJIedhMtm2bdvkjh07Jr7jkd9A31njILdHr3v8s3Dsd/BXR8Fqn/Ch/YEgP3r1JP/58jH6RvzUlnm4ct0iFuU5k+537tIClha7GfL6OdLaz5bqAh2Gq9Fo0o4QYqeUclu8dbpHYaZ0beJ162+C4W448fKkDm2zWvjc9uU899WLuXLdIk51DfL93x/lsZ1n6BnyJtzv7ZPdPPLOGZ7e3czhlgHaB0YndX6NRqOZLNpQmAn1JiCi+xRi+Z+AM2/KBY0q81189bKV/NUVtbx3RTF7Gnv5t98d4dd7ztKZghHwByQPvXWaM11DDIz62XW6Oxye++zeZvY29uIPBHnordMcbO5LqU1vHO/kobdOT+lzaTSa+cu8Co8VQlwHXLdixYrJHUCaopBOvAyFSyPztixYcz3sfxLePwL25ENGyVhTnkux20F2lo0LlhfxwsFWXj/eyR+Pd1JTlMO2mgLWV+TFTdR7+XA7oJzhNqvAH5Acao5EafUM9bKi1A3AoZY+GjoGqS7KZl1FXsL2mH0mGo1GE8u86lFIKZ+WUt6Rl5f4ppgUV0H85T1nVGjs+pvA2698FVOkxOMAID87i5u3LubrV63mirVl9I/4eGxnI//y3EGeeLeJM11DJPIj+QPxl792rAOAYBC6h3zsPtNLICgzEo7b2D3E6c6hGT+vRqNJH/OqRzFlckqi50MS4yO9ULJaqclmF6vhpzXXTfl05y4t5O2TKsop12Vne20pl6wqoaFziJ2nuqg/0807DV2UehxsW1JAXXVBWFsqGe39agjLbEYeMbLEb9xcwcCInxcOtnHFujKK3Y6ofQNBiUWQNof5K0eU0fpoUXVajqfRaGYebSiSMdIbmR7th4AXVl8Le34BvU0Q9EPBkkkffkWpmxWlbs50DfHqUXVDFUKwtDiHpcU5vH9jBXubetnR0MWz+1p4fn8Lqxflsq2mgJWlnnGzu+P1IE51DnG4RQ1VtfSORBkKKSWPvHOGpcU5XLC8KO4x3zzRSd+wjyvWLZrsx9ZoNHMMbSjM5MS/OYbZ8wg4csE/DC//C1RuHRtGOwkWF2Zz0crisLEI4bRbOaemkHNqCmntG2HnqW7ePd3NgeY+PE4bW6oL2LqkYEyvIBnvnu6JfJzGXpYW54Tne4Z8gPJZJDIUJ9qT+zN6h3wEpQwLI8Yy4gvw3L5mLq0tJT87/jYajWZ2Ma98FDNC4VLwVMDZd9N62Mp8F3muxPkZZblOrtlQzjeuXsPHzqumMt/Fq0fb+bffHeG+V47z1slOBkb9Ez7vr+ojkV7P7WsJT3cMjBIMSkZ8Srakd8gX1UN56K3TYd9D77CP9n6VNPjrvc1Rx4mlqWeYYW+QgyYHvEajmd3oHkWq9DWpd2GB9R+EN/8LvOlz0losgms3lhMMyjGqs2asFsHaijzWVuTRN+zj3TM97DrVza/qz/L07rMsK3azoTKPdRW5ZE9Bqfa3+1vD05euLuGlQ+0U5kQbstNdQ+S57Px6b/Okz6PRaGY/2lBMhvUfhDd+AK17035oi8nv8MEtlXQNesMhsbHkuuxcsqqEi1cW09I3wt6mXvY29vJEfRO/2t3E8hI3G6vyWFuehyvLOuk2vXRInb9r0Be1vG/ER++wL94uHDjbx9qK3PB8c+8w+5v6aOsfmyvSP+JDCBHXUT/iC9Az5Bs3g12j0Uwf2lDEsmz7+NnXA+2QXQRnd01LEy5eVUyey47TbqUi30Vhjn3MTdqMEILyPBfleS4uX1NGc+8Iexp72dvUw+O7mnhSnGVFqZsNVXmsLc/FaZ+80TDTM+QLh+LGcqgl2lCEjE08nt6teiQfPW9sZNTLh9voGvRx6zmLo4woqAgtAWOWazSa9KINRSyFS8c3FP3NULEFjr+ojIa7JPn2E6SqIDtqfnttKX0jPhw2K4GgxGoR/HpP/OEeIQQV+S4q8l1cua6Mpp5h9jb2srepl8M7+7FaBKsMo7FmUS6ONBmNWEZ8waTZ3g2dg6wp99A3HPGr+AJBDrf0M+QNcO7SQkZ8gbCB/M3+FtZX5rG4MHJtHnnnDNlZVm7cXDktn0Gj0Si0oZgsFZtV4t2eR2DbpyEre/x9JonTbh3TC7iktoRAQHK4tT+cNxGLEIKqgmyqCrK5av0iznQPs7exh71NvRxs6cdmEawq87C0OIeyXCelHgcep21GRAelhGf3Rju9h30B9jSqkOR1Fbm8dLgtvK57yMfrxzu4Ka+Ksz0j4Z7MkDeAlJKfv638OluXFFCYkxVOaAQ1tOWyW7FZdeyGRjMZtKGYLJ5ycC+CHfdDVk5awmQnQmW+C4DDralFDwkhqC7Mprowm6s3lHOma4g9jb3sP9vLAZMmlNNuoczjpNQwHGW5TkpzHXgc029Antkd6SWZo7FCBILwix2NcZZHUgt3nuoGooexnt7dTHmek0tXlwIQDEqGfQF6h30UZGdNyX+j0SwEtKGYLEKoXsWR52G4J2PNsFsjN++PnLs4/GRttagbazwsQrCkKIclRTm8f2M5A6N+2vpHae0boa1vlLb+EfY19TLsi1T0c9mtlHoclOY6Kct1UOqZOQMyHnubescse/jt06yryGNNuQeA5t5IgahXj3XQ1D0MgMdpo7LAhctuZU15LlJK3j7ZRZHbgT8YZPWiXNr61XVZXzm+NMywN4A3EEwa6pwO/IEgO091s2lx/oR8Tj1DXn67v5X3byonO0v/+2tSQ/9S4pFdBEOd429XsRmOPAfN9dPepEScv6yIX+5SobtCCM5dWojXH2RFqZuXDrfROZBYwjy0j8dpx+O0s7zEHV4upYw2IP2jtPUpA/JOQ8SA5GRZqSxwUZmfTVWBi8p8F7nTfJOMJV5ORlAqAxLPiISMBED/iD8sqvju6R42VuVxvH2Q40Zi4a5TPeFtV5a5eelQG0PeAOctK8Jhs7CnsYftq0rDDvUn65uQMtKj6RwYxW6zkOtM7zVp6BwKt/G8ZeMkipo40jqAPyg52zPMilJPWtukmb9oQzEV3KWQV6WS7wK+SEGj7lOAhIKa6O39o2o7R+SGTDCoMr2zcpgMoafJmiLlIwkpxwJcuW4Rh1v62XmqmyJ31rhGw0yqBqS5d4Sm7mGOtbURGgHKddqozHeFDUhlgSsljarpprVvhJcOtSXdJuQjicfjO5vC038whSzvaeqlvX8UXyBISL9xyOsnO8vGb4x8lHgRXYkY9Qfw+oPkZNmSRHTJqO0dtrG9ipD8/IuH2vA4bVxaW5pQYFKjSUbm/3tnI6n2KEBFPx18Cv74H1C1DXKroOFVtW7LJ8Bi+gfe8wulD2X2ZzS+A20HYNNHJi1dnuwmVLvIw8pSNxaLwBcI8micMf6JkMiAeP1BmnuHaeoZpql7mMaeYQ619IdvZ/nZdirzXVTlu6gsyKYy3zXjvoEXDyY3EpPleNsAozG6Wk++e5b3byofs62UkuPtAywtdmO1CDoHRnnxUBtXrl1EXrZ60AgZpGJ3VlhTa29jL0da+7lq/SJyTEa3e8jL4zubeM/yIqoKXLT2j4b9Vy8ebA1HjQ2M+Kk/05P2zz5Rdp/pYXmpe1Y8OGhSR39b8ag+H4pXwaFnxt+2vE4ZirPvKgNjLnjUtBMWnwvtR1RUVNAIBZVS+TgAeo0s7IB3SjUukhF6KrVZBAXZdoQQdA16+eCWyvCwVYilxTmTqk+RZbOE/R4hRnwBzvYqw9HUM0xj9zD7z0Yc5/nZdgqys4yXms7PUe+5Tvu4ooezhVgjEWLQJKnyTkMX59QUcrpriLdPdvPu6R7ys7PCEWuHWvrGDCF1DHgJBiUvH2mjpVdtd6J9kA1VeeGeS8gQNPeO8Ppx9XBzxboyCrKzxuTeHDjbR3mSxMXuQS8vH2nj6vXlacu1MdM77GP/2T6aeoa5ZsNYI6qZvWhDEQ+LNfXciOxCNcR0dhesuCx6nXcA+lvh1B+jlw91xREgnP4hASEEVxv/oP5AEJvVwmVrS3nhQORJu8TjCBuKDZV5uLIsvH2yO7y+MCeLrsHUhrCcdivLit0sK470PIa8fs72jNDUPURL3wg9Qz6OtfXTP+KPugIWAXkuO/mGEcmPMSi5rtlvSMxJhkdbB1hSlM3gqPLv+AIyKqy5d9hHMCjHDDWd7BwMGwkAbyBI77APb0ykwqg/4jdq6h7GleBGL+P8zt4+2UVNcTbHWgcY9gZp7h2JEouEyO9lShinDurhrzmHNhTpoGIz7H8C+lvAY5Lf9o3A4WfHbt+yB7oboPaaSM9ihgn905d6nHx4WxWgDInVIqg/04PXH6TYk0V5nitsKJaX5LCqzJNU9G88srNsYXl1M37jBtg95KN7yEv3kJeeIR/dg16OtQ2MMSQCcDtt5Drt5Dpt5Lrs6hVa5rKT67TjtFsyHpUVYsQbTDj80zHgZefpbs6pKYxaHmuUD7f0h2XizZztiUR17T/bF9VzMxN7jw4GJcfaBjjePsASI5mxJcZQHG3t552Gbm6oq4ga9koHvkAQm0XMmu9IEx9tKJJRuUXlSpx+A4a7E29XXqdKpJ59F2qvjiwfaI2/fXeDej/8LDgNmYsMPmXFPilevraMXae6KTHky6/bpEJoyzzOsLZTfradS2tLeeLdpjHHm2wbitwOihJIppsNSY9hSPpG/PQN++ga8tLQORQVzhvCbhXkGj6VXJeNPKcdj8uOx2HD7bThdqiXK8uKZZpvVonkTkIcbR1gTXnumGXpJNHPTIT/KJn56qJsKvKcHGzuDxu3gVF/lKFo6xsh15CaiaVvxEdDxyAbq/LjnEudKBCUPLqjkdpFbrYuKRyznWb2oA1FMso3qfea98LBpxNv58yDohXKiZ3lhuoLwJrqpY25OQUDsOsBVeuifGP8XbxDYHdNW28kz2UPJ6cBYed1LGZn9NqKXA4YT7Ehtdl0Mp4hAfV02j/ip3fYR9+Ij/5hnzImIz76hn00dg9zYLgPf3Ds3dIiIMdhG2NA3OF5e3g6J8s6bU/AT8VJNJwOjrYOsKLUQ7/hR4m9JMNeP7/c1RTlf3nxYBuXrSmlNNeJlJIXDrZRmGPnqvVj/Q2vHGmnb9jP8hJ32LjEDnv5g+rYJ9oHp2QovP4gQSmnxa+iUWhDkQo5xeNvs/4m2Pso7H9caUCtvFI5si3j/HhHYsIxR41hhaadULYeLDHjwt4hJRuyaIOKspphQv/0a40nX3PEVXmek3cauihxO6jId0YNh8wEdquFwpwsChMUTQIVdTTsCzAw4mdgNPLqD80b7619owyM+qOyvkNkWS2UeByRl9tBqcdBoTsLW+z3NUvpNopUmTXDGjqiZfPjOelfONjGR8+rjnKme/1BsmzRnzu03h+UjPoDtPaOkutSvx0h4Lm9zeE2CCF46VAbedl2tlQnqFufhKd2n8XrD04oBFkzMbShSBeeRXDBl6DjiBpS2vsIHH8BVl0JldtUHYtkjPaDb1hleocY7h7r9PYbN9/exowYiiybJeE/ZFmuk/dvrADgvSuKOdjcHzfhLZbaRW4Ot6R3iCURQgiys2xkZ9koHWdbKSUjvmCMQfHRNeilvX+Ukx2DUT4Hi4DCHGU0Qkak1DAk0yW+OFHMMu89Q4mDEswBDLHUn+nhVGckMu6xnY1Rv4lAUNI/onoqUkpeP95Jc88IF69SD1y+QDDs1A/R3KtyciZjKOKV/B3xBXjrZBfnLS2M29MY9gbCPeIRX4DOQW84rFgzFm0oUqVi8/hV7YSAkloVWtt2AA4/B/UPwbEXYNVVypeRyGAMdcDZ+piFpqfZ1v0wOgDFK9X8cLdK4LOlXgYVUMcY6hxb6zvNw1k2q4UNVXnUFGfjdtiQEt462TUm9HZRnoPNiws43DJAeZ6TxYUujrYOhJ82M4kQAleWFVeWNUpk0MyoP0BHv5e2/hHaB0Zp7x+lrX+UQy19UcM5uU4bpR4nRW4VvRUKDc7PVkNamXDmxooypsqBOI7yh946zQXLiyjLdUT1UsznePtkF8AYIxHvRm9mT2MPgaCkqiA74fdg5lhbf9jQHc0eYEOVkl4Z8QVw2Cyc6RrmtWMdvG9NKVlWC2+d7KJr0MuHtlVh18KRcdGGIlVsE8hxEALK1kHpWhXhdOQ55XfwvAC1V0HZhrE35DFGgmjP45m31XvRCtOyt2Dpxam3C1TOh380OunPP6qGs8rWqeGyNBLybQgBFywv4rylhQz7AmOiZz68rQqrEf2yotQTV6I8mX5VpnDYDAmTguin0UBQGj0PJX/S3j9K+8Aoexp7xzjd7VZBnsuUSxLz7nbapt3Rng7eOJ48SXXEl/qXN+wN0Nw7zLISN/ualGE62NzPxauKqSrIpq1vhFF/kHcausbsa+4NhS7bkNfPk++eZWNVXnhIbUdDd1ThrUBQYrcqJ33fiC9K4uTht09T4nHwvjVlCdu863Q3Pn+Q85YVqTLC/sC80dOaH59iJgj1BPKrYbQvNSFAIZRDfNEG1Rs58rxSm81brKKjStYkf4Lva1JP/wHTEEEoYgqUHEgyAn7VbvO4uT+OJHloWc/ptBuKWCwWETfEMlGM/hXrysJlWW/cXMm+pl76Rvw0G/6PrUsKKM938taJrqi8hGJ3Fh0TkCxJN1aLCA8/rY1ZF6rap0KAveGQ4J4hH009vQx5A2OOle+yk59tj4T+uuzkhcKCnfY5Y0xS4bf7W8Lf3Zsnog3BK0c6+Oh51byQIMu+pTfaL9baN8La8tzwUFhTzzDFRkBEbHXG0HNZ6NhmQxGU0NoXX84/REgz7LxlRbzT0MXx9kE2VuWxvjKPYW+ALJsFq0XQPeilIIkfbTaiDUWqhP4JrVkqsmkiirHCYkQx1UHTDjjyG3j7PihYqnIpQsNJscQb6mrZE5nuOQ19zZAbJ8s15PSG1CXQR8fG52eK6+sqGPUFoqKcHDYrW5cU0tQzTHPPCNduLA+rtC4vyYkyFKsX5YbDUd1OGwMjfmYLTruVRXnWhOVdvf5glBExv5/oGKR/xDcmSskiwO2IGI5cV3Q+icdpw2YRWITAYhEIoVSELaghNotFzYeWC2P5TJOs2NV49Ax5+X2Mlldr32hUDfrOAW/YUMQSmwg4MOrHZhFRPo7BUT+/qj/LRSuLGfIGKMixU+oZ+z029SjhyT2NvayvzOOJd5uoLHCxqszNS4faOXdpwZwSZdSGIlVCkU/5i6Hj6OSOYbHC4vOU0TjzFhz9Lbx5DxStVFnduRXKCE3kH/TI8/ENwclXku8XDMSPyAr4k4f2JtovzYRCU0HVDjdnYVfmu8Y41GNjk8yZyytL3bx7ugeAHIc1PEZ+fV3FjIWjToQsm4WyXCdlufENSVBKBkf99A37w3XLVQiwmu8YGOVEx8CEhnriYRGGERGqV2M1EjJtVkt42moR2CyR6eh59QSd57KzpCibxQXZY6KjJkMwTiQawPH2VAMi4u8vUUNUIZ6qP4vNKvjwtsXhZaEEyAPNfWGRzY+eV03fyPg+tabu4bCESsgH19AxSFBKlpW4CQQlnQOjFLsds668rzYUqeIqgC2fVMM4wqKijrJywDtxXSQsNlhyIVSdC6deV5Xy3vqvyDpnvjqfy3h3mqZdBak5sPtjSqW27Itu664HJl5sye+F+geVY7+ibmL7ToFU4uMr8114nDbqFuez41RX3AiW2kUeti4pCD+1jqekekNdRdwCSpnGYhJmrCRxpI7XHwznkPQbob5SSoJSGZugJDIfWodaJ41lkW0l/qAkEPPyB4PhaZ8vaCwzr1dqw6rdUJ7noroomyWF2SwpyplU3Q5zD8FMqpFz/kD87z1oRLnFbjti8imd6VIhxGYl5hFfIKroViwvH04sRhnS51pW4uYR43OtKnNT7HawpCgbX0AiBEmd7KHvuaV3hIbOwXDkYTrRhmIiWEx+itBNdsePJ388qx2WXaJECDuOqEim4W4Y6VHvHUeNPIuYH7Y9O9qYjPSoYa3cCvVyxOnSNr4z+XaGCIXmdh6bUUORCk67les2qX+QUF3t1eUeDjX3j9tBM/cyPrytKlxFL8dh46PnVSccDvmT1aUcaumb8XyRVMmyWSh2OxIOtcwUw94Ap7uGONU1yKnOIXY0dIUd3/kue5ThKMt1TruGV6iORywvHWqLq5FlFs5s7BlOuh7gmT1nowxOvN/H0dYBNpmy1vtNPZIjrQMcaR2gsXuY011D2CyCD5+zOGr/QFAZsByHjVePto/rP5kq2lDMBmwO5fCORzCgjEXIeAx3K//IiDHdfdIkOiggt1JFVvlGoHApuJJkvPY2Kb+EWZ9qnjhEAbZUF7CluoBDLaFwTmVwt9UU0DfsCyfH5bnsRu3t5OPym6vzw0NYoaEvm1VwtmeERXkOLllVyqDXn/Tpcjqy1mc7riwrtYs81C5SDzCBoKS5d5hTnUOc7hqioWMwXAcky2ZhcYGLJUU5VBeq4aqZkqMfHA2MCd2NJVFvxEzfcGJ/2OnOSFLjYzsjkv9/PDY2Yuy00XuJpyTwmlGl8aPnVYd7NyLowzN0Bkh/4qE2FLMdi1Up1GYnueH7hsBTAbt/rgzH7oeVci2AI1f5QmxZynmeV6WGt0AtByhcNr2fIcOIGJmUVWWRHtelq0soynHwZH1TwpvAFevKcNgseJz2sKEIUex28MEtlWRZLVgsSlcqWS9EC6cqf0dVQTZVBdlciBr+6hn2cboz0ut46VBbuB9dkG1nUZ6L8jwni3KdVOS7yM+2z8koL3PCo5nxFJmllLT0jeCwWeke8tLUNUjuYAMdf3yJTUfepKh3H/l9h7HIAFzcqHKi0og2FPMBe7bqcYQECdfeCG/8QIXSdp+E1r3KpwLKSORXK2n0gmXqPRDnR9p+RCXlJfKHDHXBgV+pXJHq89L+kdJJKLrIXCsjRHme+oe6Ym0Zjd3DWC2C8nxnOPwWiBq62ViVR3bME24yH8rNW6vIslkifpHJf4x5ixAiXJdk0+J8AEZ9Ac50D9PYPURz7wgtvSMcau4LXz+HzcKiXCeL8pyUG0akLNeZFmf5rENKjhw+QNuhNyjq3Udh735u7jtAll89DOZZXXTnruFo9S105a3nwlj9uDQg5mNpxG3btskdO3bMzMmad0PTLuUb6Jt9jk8AiparNoYMR9dJZTik0c3Ociu/hjMPSlarZSGnevV5yumeXQRI2Pe42tYcSjtRp/gcQEo5pfDQtv4RXHZrOOGwZ8iLzWohKGXSoSlXloVhrxrfdtotOO1WemZBlvpswOsP0tqnjEZz33DYgIQS6ARQ5HZQnuekPM9JqUdJp2RZLditFuxWgd1mCc/P1nomjtFOinr3G0ZhH0W9+3F6VT5JQNjoya2lM289XXnr6MxbT597GVJEHlYmq3klhNgppYyrC6QNRbrwjaihn7lCwKeq63U3KCd1X7PyhYz2KiMgY0MrhaoRbnWoYbAst5JIzymFS/9XtJ+jvwVOvwlrrpuRUNq5htcfxB8M8sdjnVG5HwCLC12c6VJhlBetLMZmtXDgbN+sKGM6G5FS0j3ko6V3mLOG4WjuHU5JAsYilE/EbhiOrJAxMeZD4cFChGTYQ/kl5lwTgMg2oe2dNgs5Dht59iAl1kGKLIMUin7y6Mfl78Xh7cHh68bh7cXh6ybL24vD243D10uWXz2ESQS97uV05q2jK289nXnr6fGsImhNnqw3HYZCDz2lC3MZ07U3qGGZ2YzVrnwT8fwTMqiMxUgvjPSpYa3RPjXA3ntG1dkYOaJ8IwC7fqKGsKovUHkiviEleTLSm9y3skDJslnIwsLKUjft/aMsKcrmlOHkDD23rSh1h7PV11bksqLUzdme4XA4pUYhhAgrBq+tyAsvH/EF6BgYxRsI4vNLfIEgvkDQmA/iDUSWqZfE64/MD4z6w2HCEuNdqqFDKSVW6adYdlFKB2Wyi1I6WUQHpbKTMroooJcC+nGLxBFxQzjpt+QyYM2jy5rLiH013ux8RnMqGC2to69gHX5b9gxcxfHRhmI6cE1cAXNWISxqGMqZF728cBl0nVDTIb9I31klAdJzGo7+LtKrsmermuM1F6mILndZ4voaC5RQQt3KMjfrK/OwWwUtvSM0dg+Tlx2dX5Bls8QNSDPnetxQV8FrxzqiYvyRkuyRZjxDZxjJKmDQWYHf7h57oHmGh0HKbK0IaxDpEETqvggkIiq6LzIvAAsSKwKJc7SD7JFW49USNe0c7UTEeJx81myGnIsYcpYy4ljNKWsufZZcevHQJT10Sg8dwRza/Dk0+3Lo9QoGRv0MjvrHyLZYjkKxu9EYRnNRnq/e3WmuMJgq2lCkE5tTDeMIAauvVWP5ux+OrLfax9dnms2EjAQoY2LNUj0JgOV/Arf8j5Id2XG/yrXoboDjv1frLVao2KJqbKy8Qu3XXA8bPqSuy0RQcazjbyNltM7VoWdV1NcsMViuLOuYYYJlJW6WFOUkHT835304Qs5bKcnxdlDe8QbFzftZEjwNrQfJGziGPRBTZ8Key6CrkkFXBcPZFYzkVOEqqeGot5BBVwU+u6o1ctma0oSaSmbsVoEvhbDRtCIlWb5ePEOn8Qyexj10xjR9GqevJ62n89rcDDnLGHaW0e1ZxbCzjCFnmWEY1LTPllxVoch41cZZFwhKhrxKyr5zwGvIrg/T0DnE7saIVL/HaYsYjzwnFXkuCt1Z0x4BNut9FEKIHOA/AS/wspTywfH2yYiPAtQwzUBrtHaTOSEvZEjmK+WblHM/alkdvPsz5UDvPgE9ZyJOdGe+8ns481WWu8MNWR7TtPGKnT72ogr1XXeD2tZMwK+KPg20qMgss6M99F2k4nwPBlV2e88p6D4V/S6D6iEg6pU7/jJ7zthCVBOgpXeE3x9qY2NhgPX2Jmg7CG0HGTm7D2vHYezenshlcBXR7lpOr2cFtRvOZc9QIX1drazL7qW98Sju4Sayh5txD5/FFohOIvPa3Ay6KigoXw751ezq8+C1eQhasvBbnQQtWQSsDgIW9Xrvmip+f6xXzRvLg5asiefkSAlIhAwa7xK7vx+PYQTcg6eVMTAMQmgsH7U1g65yBrIX059dTX92NUOuRcrJG77HyahegDDOFzpXaJsQI1lFYSOQyV7Y0Kif5j5Vr6O5Rznx2/pHwnpfdqtgUa6T8nxlPL7zwY2Tyj2Zdc5sIcT9wPuBNinletPyq4D/AKzAj6SU3xFCfBzokVI+LYR4REp5y3jHz5ihiIfZUBSvUhnY8xV3WeI64SECXjUU9ea9Sh3XVQBBn6qT4R1U+R+j/eo9mIKQnz1b6XDllKiXsCpj7PAow7Lhpsi6g8+ons3mj6moruHuGEPQEJnuOR0TNixUZFt+teoBjfZHv3xDiVoYfQy7Cyx21Q6rXbXDYjNN25XWVmg6vJ0d/MMEWg9hHTI95TvyoHQNlK6G0rXs9pZzTC7m3PW1vHpUiSJ+9LxqXjnSTmP3MBetLKYs10nPkFeVMs22c9WyLOg5xas73iVn+Cw5w03kDDdTRbu6Dt7JiUUGLFkELA6ksBC6GSsjEFTTBEEG1WCQ8Z6MIBYGXRUM5FTTbxiEgexq+nOqGXBVErRmNgN9JvEHgrT1j4Z7HqF3rz/IwX++CoctvYYiU0NPPwF+ADwQWiCEsAL3AJcDjcA7QoingCpgr7FZ8rTJ2YjFFrnhVV+gnqAbXstsm6aL8YwEqOGqjqOw/FI1X3sNeOJo/LcfgRN/gMCoun5V58DR3yh/iH9UVQMsXQOD7TDYod77mlT01nBXJGqr/n+ij2vPhtfvhsFOFeFlxpmvhsTK1ql2FdSoXJL8GiUGmUxjK+BXN9RYAzLaN9agBPzqMwV9xrRPzQeMd/N0wKc+a9AHFjvWVZerz12yRr3nVkQ9uVf0j3L4cBslHoeRlKaWm2/BIblrQO2bUwQ5RXS1l3FmNMD7N5WTG6qRLiW7jjQw2NfDRUs9PPvuSbKkl4uWeXjzSBObyp1kSR+7T7ZgDXqxBkaxBkexBr2sL80iMDrEqfZ+pLAgsYAQ4WkplE9gTUUe/d4gp7pGwv4Ctd6C3+pSvYScagZdlQQtE9eGmo/YrBYq8l1U5LsA5ROVUlUWnIyRGPd8aT9iCkgpXxFC1MQsPhc4JqU8ASCEeBi4AWU0qoB6IGG/XQhxB3AHQHX1LKqdu/EWdYPwj6hhh/Ec3fO91wFjQ297zijpEfOwzEiPerIOKdl2HFHDTWbiDSGdrVc5I75hdeNeerEyIr2NSlF3dEBFYrnLlBEoqIH8JWo61nk/Eay2iGhjBinxOMJqp9dsiMjPb6zMo3/El1CRFuCGusqxC4VgS23kuq/atIjSXAcOp51LjBpavcM+TvqaY3djw7nVZAHLAsGwflY81p1XjTso2ZtA7E+TGkIIcichspgKs8mZXQmYfymNwHnA3cAPhBDXAk8n2llKeR9wH6ihp2ls58SwZYHNVPc6p1hJih97Qc3XXqNqbIeouXD+GwozvY2qxkblFuXjCDMF55wQkJWtXpXb1FP8/idUOVqATR+JDmdOhH/UGAKa+7kgBTlZaVEVXVEaZ6x+nP82m9VC7SIPh1tSG8Iqy3WkTeQuI472echsynePd2eQUspBKeXtUsrPp+LInhPkm5QgPWWw7sbJHcc+O2Ksp4TPUPLsbVT+nCGjotmYhL9JcuR5ZSSiSPHGUf9QtBHXTJqNVXlsrErcYzPXX9heWzrl84VkVsy9Ks3kmU2GohEwa+lWAbNUEyMNlK5R0hqghisqt6ixcVDDVTUXKfXXeJLhIWounP52Tjedx9X7gOGg7T6p/BNtB1Lb3zuk/A3D3crQDHdHrx+Kk6A2kQCOwY7Ut12opND5s1strK9MbWhvPGmNslzlK1pXkRt3fU1xNtJ4GBACNi2ewpCiBphdhuIdYKUQYqkQIgu4FXgqw22aPqrPV+PnIco3RepVZ2VD8QpYtj16n7L10fPJJMTnMmHZ9BTY/wQcfEpF50B0TfFEHH8xMh3wK/kVzaSJva9bLfCe5UXxNzY4p2Z8X05VgRJszM+2c/X6iETM+9aUcdHKYjYkMDzrKqKXry3PxW6dnbpOc4WM+CiEED8HtgPFQohG4B+llP8thPgS8BtUeOz9Usr9mWjfrMVdCqHAImuWMijzjeY9428Twu+NhLBOtpdw4MmIwGHNe+PXL/d7la8p4FMJhNUXKJ2rOUx+dhZluQ7qDLXWqeBx2jl3aQH1Z3rx+oNctb583Mp1K8s87G7sxZag9xBKRAyVPY0tDRoqThXi8rVlDHn9vH2yi5wsK9tXlXKsfQCX3YoQgpu2VCWsjJdOQsWy5huZinr6SILlzwKTHhQWQlwHXLdixYrJHmL24SqI3MgKlqhM5qBfJe8tdOrT4LIyq+B2HotvKOofVBFWHUeUZEnTzkh47xzFahG8b02csORJsqLUQyAIO091x60SF6I8zxnOJr9pS3SU1U1bK8fY+1RqR9usghKPA3CEpeQLcrI4JyfS4zYfZ2NVHo3dQ+Q67TSYCgnVLnKHy6nGSs2nSlaSkqVzmXn1qaSUT0sp78jLm0djkksvVpIXWz6h5h1uVf40lagdzcTxDRsS7DF3LO8gnHk7M22aI9Qu8vDR86qT1oS4dHUp71lRDISUViM3cIfNmlJ9dDPXbizn+k2pRXPlG/pZxW4HV60vpyAnWoW1KCeSJ3NpbWlUb+eKdfGN6sWriifU3rnKbAqP1cTDaoe8OPHtiShbD637VAZxaNxeM5bGHWMLNnkH4fBzRp3yGCbjxzj+e5XpDSok2hztppkwFgGxVUHHG+Iyc82GcgZG/QmF9WqKc+Kq8+a6bHF7SSUeB1UF0UNgpbmJkzK315bw8uHkZXDzs+2zsv6INhRznW23R8uELD5H1YbwLIJ3/yfxfvONs+9ObPuWvWOXjaZ5bDlkJEDlzczDAk8zyfs3VdA/MrWbqNlIpCpFdeW6RXj90eHaV61fRGFMjwSg1OMMD6ENjPo52zPMvqa+lM93aW0pT7zblFrD4rAthSCByaANxXxEP7lOL+k2KJqUcDtsaZXZXlHiZnA0EJUIeENdxRijACRVZ11V5qZ/1M+Fy9UwVEhCw2m3Uux2hA1FqnicNvpHUtA5i+GytaWUeqZnSHpe+SgWPCLm69z0EVVIKIR76olMGuLnZoTob1HvgYn/o2tmFpvVwtYl0U/gOQ7bGN8FKEn4C1cUkeMYOwS1raaQS2tL01Kv26xis6Y8kkMV77yxTJeRAN2jmF9sujV63u5Uzu/wvGtm27OQqH9ISX6ACp/1DmS2PekgGIShDv2AYbCkKIeDzX3hWiATJbY3dNHK4rDC7yW1JWRZLThs1rBuwPJSN1aLmHCPZDqYVz0KIcR1Qoj7envjOCMXAvHUTfOrIxng1iylwgoqE1yTOv1xRAJGB5TjW8qIkQC1bDIFqoLBqfVEjr+kFHfTRdMOOPTriKzKAmNJkXJUp6MoUKnHgcdp531rSjl3aQFXrCuLygVxO2xGiC9sqc7HYbOQk2VjWUnyOhgf2lYFTMypPxnmVY9CSvk08PS2bds+m+m2zCqWXgzZRUqZ1mpXUiFCKJXVeNTdlp4chflEY5z6JnsfVe/rPxi9PFQzfCK0HYLTb6jpyTq9Q1npyy6Z3P6xhAyEPz0CfXONc2oKqavOj5IUOX9ZEbsbe8mfwI355q1V4VDbslxnXAVf842+qiCbqq3jJ9Our8zFbrVw4+YK7NOcvzGvDMWCZdVVqgZDMkI6UpA8/KJyq8pC1iTHbwqt3ffL6HXdDVCyemLHCxmJEN5BdYPOzqRMy8JWXbVYBI4Y5eD87CwuWVUyoeMk8118cEslvkBiAczQf6pFCM6pKWBg1M9BI/M71APJzpr+27g2FPOB3HL1Sgex9aQLl0XXytYoYm/sqdB5HIIBKFmVfLtgEPb8Qk3rkNpp5+JVxbT2ZUbvy2lPnmSY47CxvjKXpcU5eIxiUv6g5GjrQNIM+HSjDYUmQl6csNqlF6dmKFIpgzqfGO+adB4du+zkK+o91lD4omtWc/S3kendj6gyp8W1ibPxm/eAR8tpT5aqguwxiXOziY1V+VHzW6oLqC7MJj975nr+2lBoVPGknOKx4bWghqlK10DbweTHyKuClZerYZf5Wup1IgQnEBnT+E70fL+pWpxvSPmSuhtg7Q3x92/aGT0/0jfnRQs1ibFaRNJKhdNBSh4QIcRyIYTDmN4uhPhzIUT+tLZMM3N4ylQVN7PvYtHGiEO2+nxY/ieRdXELJknlKI8nqqeJxu+FflPvKxXl26GuiHO5tzG5gzkUmtt1QmXte4cSb6vRpECqrvLHgYAQYgXw38BS4KFpa5Um81RthTqTyG/BElj3AVVUKV5UzURkvhc6x3+vKucNd8fXlUrEgV8pzamjv1OhsOPRbpTUHemZVDM1mhCpGoqglNIPfAD4dynl14BZNyi64PMoJsqqq2D9Talv78pXNTAS9SiSEfJ/mDPFFyqhoaX9T6qIqe6Tqe8bNPIzQjIiZ+vHP0/Xyan1LLqOR0d5aRYcqRoKnxDiI8AngWeMZdOb4TEJ5qXM+HSSWz65sews91g9KXOPwly5L0ROkYrgKVs78fPNdybSGwttK4RKzosnhhhbb7xjij2LjqPQ8Mrk9tXMC1I1FLcDFwDfllKeFEIsBRaQNKkmCotFyWZv/VRkWY5Jlz+eU7xsw/jHrTonUncDYPW1k27ivOX0m+pdiLEGIURrgsKQ/tGJDXWZ0X6OBU1KUU9SygPAnwMIIQoAj5TyO9PZMM0cwOz8zq+OTOfEKeZiTeGnVrxKOdVDaI2hsfQZEtQjSfR/vIPxl594Wb2Pl5sRDKpeiPY7aQxSjXp6WQiRK4QoBHYDPxZC/Nv0Nk0zZ3F4xt8mlpWXJ88IL1w2+fbMWxLcyEd6Iz2PVBloixRnaj+oEgoXUl6MJimpDj3lSSn7gA8CP5ZSbgUum75maeY8RUnqllviZJTmVSU/3rJLlKihJkKyJ/7x8l5CtB9WCX+Hfg1HnlNChxPJxI8VRDQz0K4iuzRznlQNhU0IUQ58mIgzW6NR5MapWbz0osTb1yRZF8vaGyLhuJtvU450jSJelb5U8I9C4041fHXqdRWuCzDco0JwBztSP1bjO0piPZ5a7qFnVGSXZs6Tamb2PwG/Af4opXxHCLEMiKNRoFlwbP54fOc1wKork0tUW2wQHEdWO7twYsJ4q66CI8+nvv1cpvPY5PY79UdVptVnOKjNEiKxdcTDJOi9dJ2M7Ge1qx6JxZZYbkQzJ0nVmf0o8Khp/gQwgQB8zbwlmZM6tyJ+b8Ndpt5XXq4MRWz0Tt5i6D0zufZkF01uv7mIf5JCdqFa3iFDM9njxCMkvV57TfqOqck4KRkKIUQV8H3gQtSjxWvAV6SUjdPYNs18JSs7eeTNivfpiJuZZDJFlsbj8LPpP6YmY6Tqo/gx8BRQAVQCTxvLZhU6M3ueIER08eDYdZqZJ9ZwH35eyabr72NBkKqhKJFS/lhK6TdePwEmVr1jBtCZ2QuAlZfDoiTJe+aIqpLVSvlWk17ajyh5kJNpztYeHdCJfbOUVA1FhxDiY0IIq/H6GNA5nQ3TaOLizIOqbSqLO7dy7HqzoVhygVK+deVHa0zp8fOpceqPU9s/4IuvHbX3UdjzyNSOrZkWUjUUn0aFxrYAzcDNKFkPjSYzLFoPFXXx1+VXQ/UFkfl1H4jWmNIROZOjv1WJC5oJRU5NxKdU/9D4NdmlTB4xp5lRUjIUUsrTUsrrpZQlUspSKeWNGJIeGk3GcJcqp7hN1Q5mhZEDuuJ9qiqcJn34hqH90NjlZgPRfji1YyXSqDLTXG/kdOiBi9lAqj2KeHw4ba3QaKbCkgvVkFS8oSgzOcVjVW9TQdetTi2E9tTr6TtfyED4EuhWaWaUqZRC1eEOmtlBwRL1Go8116n3ySqoahIzkZoa4xHwR+4uqQxpjQ6AI40Z+36vkm+v2hZfbmYBkrRHIYQoTPAqQhsKzXwgnTeCZPpWoSTD+Urjjonv4/fGV7r1DigF21Tob1VO8NNvJVbNnSgte6DtQOpDaQuA8YaedgI7jHfzawcwDVk6Gs0MY3NFpl35kemcSUR/JzI6nkXKbzLXGU9uJRlDXdAW4+M48CTs+cXYbfc/YZJT70l+3JDoYNuB+MeaDMGAMaGTPkMkHXqSUi6dqYZoNDOOw6O0ofpbjDKvbtj984kfR1iUg7ZoZfynUFdhxOE+lwmVX50oUirHNEQHGZh7AJ3H4+/btAvKN03uvFNGD5qEGG/o6WOm6Qtj1n1puho1WXRmtiYlQjW/y9arse3iFcrRHS9sNtlwUohNtyqHdyJxxIzd6NLMZCXDQ+q0CY/bo3oE6cRcX0MzZcYbevoL0/T3Y9Z9Os1tmTI6M1uTEla7urGnEkJbUjv+NskcrvZsnbfRczr5+v1PJJc23/FjeDdB5eWhOOGzZ96J1NdIhZG+8du4wBnPUIgE0/HmNZq5z7oPwMYJRn7H60ksvTg97ZlvpOqkjiXgUz4O76CS+RgdUMs7jozdtnWfeh/uSe3Y+x6HYy+aFmjfRCzjhcfKBNPx5jWauY/ZoR0PIaJ7ELXXjC3hml0EnvKx+5asjp+0tpBoeHXy+55+Q12/0BCYzm+ZMcYzFKuFEHtQvYflxjTGvC5irFk4eMqVEN6mj6iomJAmkWcCYa9la7WhmEiZ1XgkLKxkECsxokkL4xmKTUAZEFtFZglwdlpapNHMRmqvip63WE1hlCGMnoYQkfreZo2pVLBnR/STNMmZ7nrcWkI9zHg+iv8L9EkpT5lfwJCxTqOZn7hL1bstgSN6462qd2EmPCQlVOW/bbcnl0SPxZkLm25RGcGamcc/qt510awxjGcoaqSUe2IXSil3ADXT0iKNZjZQuQ3W3qBu3vGwZcWJZjL1KMajdA0s2qhyOWLJqxq7bDwdq4WC+Sbe8NrUj2euF17/0NSPN08Zz1Aki+tzJVmn0cxtLBbILpzYPuYeRdL1QOFyqNoanc1dGhqmMvZ3msK8S1ZNrC0LgWQhtaly5Pno+WAgNXXbBcZ4huIdIcRnYxcKIT6DkvLQaDQhsnLUeyKF2lCiH6jIKIgYj3U3RqrxWQzXYVRvQ4+XA+n13wSDY0Nodz1gCrnV1zzEeM7srwJPCCFuI2IYtgFZwAemsV0azdzD4VZ+i0QJdrassSGddpdSs7XYo4+z/E9UpFWowI92rKafoJarS5XxtJ5agfcIIS4F1huLfy2lHCcnX6NZoEw0C3vZdug7O1YmO1Y2Pbt4cu2p+6gee9dMmZTqUUgpXwJemua2aDQLD7sLipaPv11W9vjbVG5RInpm5oMYYboJBtSQUzprWMxzplLhTqPRzAYqNqv3kN9Dk5jBTuWHOPiUzleZAFOpcDfrEEJcB1y3YkUKip8azVxgzfXjj6VX1EHhMhXKW75RRem2jIlq14AyECECU6ivscCYVz0KrR6rmXfkFKnCR+MRyveo3DpW8XbJhWO314xPKIDg4DNw4g+ZbUuGmVeGQqOZ16SqahuKmlpnBCYu5ByMgG/qEuKD7VPXqJrjaEOh0cwVzCG0+dXJty1YMr4SbjJqLpr8vrOJhteUhHiqkuOTxTcC+59UtS3mIdpQaDRzBXMW97JLJ7ZvqFJfPHmQeOSlQTKk9uqpH2OqhAobNe+e+L6nXo+e3/Fj6G2MXtZ+BOp/Dt0nlUhh6/7JtXOWow2FRjNXMBsKywT/dUNyIJaY+JXilWO3XXyuCtudKolKw84koTrfXSfGOq8b3xl//9NvRc/3xAhpn/oj+Od/ydV5FfWk0WgSULJaRU/lVkJ3Q2S5PSY/o/aaidXYSMosyyY/+XL0/EDr+PskquUdDMJpU4/j9JuTblZaaNqlIt+mMtyYBG0oNJq5ysZbUn9qt2WpiKiB9uTbmY1E3JobE2C2yY70t6TvWLt+mr5jgbrOrfuhbP3Ee4u+ETW01nFUydRPA7Ogb6jRaCZFVvbEJUNiKagZf5vZMISUDtJRZ0II6D419ePE0rofmnYm7sGkwjSq3s6TX4BGo0mJ2PoXSaXUjR6B1Z54k6TZ4LOsRxFMQ4JdbyMcn6DUXcA/fjW+UNsm0saAf6zPZJrQhkKjWUjYnRH9p3iO7HgkehLf+ilYe33i/Wbb0FM6CDnHE9F+CHb9DFr2RZadeFmFzsY60wc7YXRA9SSYRG/nzJtw7IXpLwmL9lFoNHOPROVZU6X2GhUFFNKImizz0RCkg6BfRVQtMgS3+5uNFSZj4BuJlhPJmYQ6cChnIzA6qWZOBG0oNJq5xIYPJR8KSgVXvlKaHY+wIRjnabdwWfzMZW1IEhM7xBSq1mcuzTqL0ENPGs1cwuGeeenw8ZzANe9VEVVj0IZiwrQfmsRO03+dtaHQaBY6zgQimhVGr8Oc6BcPi1Wp1lqzxi7XmJjuG3oaoroSoIeeNJqFztobYbBtrO+jbK167X54cseNzQLXqKGlw89B9fmZbsmE0N+kRrPQsViSS5nbXdFj58Wr4ofV2p0Q8Ebvt9AZ6or2R3Q3qBrprVPIl8gA82roSQhxnRDivt7e3kw3RaOZP3jKo+drLoTSNWO3W3klVJ2jpmOHoRYi/a1w4Ffx1/VOMf9hz6OpSZCkiXllKHThIo0mgzjcEQMyjVnCc4bY/IbRvvRpQnkH0nOcFNFDTxqNJn1YrLBoY2rSIPOd2BDYg09nph1pYMEYCp/PR2NjIyMj818SeL7gdDqpqqrCbp9i3oBmZqmKFyq7EImJQprDvawFYygaGxvxeDzU1NQgdCLQrEdKSWdnJ42NjSxdujTTzVnYlK5VyquhIkCamef0m6qXlizowD+qnOdJ9bsmx7zyUSRjZGSEoqIibSTmCEIIioqKdA9wNuBwJ9d0SkZuxeT2q3nv5PabTYynC5WIEVMwTkgfqu2gCquNh3cwMp3IeT5FFoyhALSRmGPo72sesOrKyPTq96ta3qlQuHx62jOTtB+e3H7Ne9S7bwTe/ZkqwZqMM28lX58GFpSh0Gg0GcRdAp6YHkYiMbyJFu+Zj/hnj+6T/jZmEKvVSl1dHevXr+e6666jp6cn6fbf/OY3ueuuu6KWfepTn+Kxxx6LWuZ2u8fs29PTw3/+539Oqp3XXHPNuG0br50aTVxCgoaLNsCWT0L5puj1nnJY94GpnaOkdmr7Z5pwT3r29Ki1oZhBXC4X9fX17Nu3j8LCQu65555pO1cyQxEIJC9v+eyzz5Kfnz8NrdIseAqXweLzlMS5xTJWcNCZm4a6z7PnBjtfWDBRT2Z2nuqie9CX1mMW5NjZuiT1aIMLLriAPXvUWOTx48f54he/SHt7O9nZ2fzwhz9k9erVU2rPN77xDY4fP05dXR2XX3451157Ld/61rcoLy+nvr6eAwcOcOONN3LmzBlGRkb4yle+wh133AFATU0NO3bsYGBggKuvvpr3vve9vP7661RWVvKrX/0KlyuxNEN9fT2f+9znGBoaYvny5dx///0UFBRw9913c++992Kz2Vi7di0PP/wwf/jDH/jKV74CKH/EK6+8gsfjSXhszRwmt1K9C6H0o0LEVtwzI8TkypfOed+W0f54n8M/OvPqwegeRUYIBAK8+OKLXH+9iiS54447+P73v8/OnTu56667+MIXvjDlc3znO99h+fLl1NfX873vfQ+At99+m29/+9scOKB0Zu6//3527tzJjh07uPvuu+nsHBv+ePToUb74xS+yf/9+8vPzefzxx5Oe9xOf+AT/+q//yp49e9iwYQPf+ta3wu1599132bNnD/feey8Ad911F/fccw/19fW8+uqrSQ2QZhbgWTS5+tnbbodVV8Rfl10I626MzJdM7QFJMdcNRYg4n+Pg0xCc+XyMBdmjmMiTfzoZHh6mrq6OhoYGtm7dyuWXX87AwACvv/46H/rQh8LbjY4mrlgVLxIo1eigc889Nyon4e677+aJJ54A4MyZMxw9epSiougayEuXLqWurg6ArVu30tDQkPD4vb299PT0cMkllwDwyU9+Mvy5Nm7cyG233caNN97IjTfeCMCFF17IX/zFX3DbbbfxwQ9+kKqqqpQ+hyZD1F49Pcd1FcCS9yi12WnIAZhzdBxRelrx/q9H+6Hh1Rlvku5RzCAhH8WpU6fwer3cc889BINB8vPzqa+vD78OHjyY8BhFRUV0d0c0ZLq6uiguTq2MYk5OTnj65Zdf5oUXXuCNN95g9+7dbN68OW7OgsMR6eZarVb8/skVqP/1r3/NF7/4RXbu3MnWrVvx+/184xvf4Ec/+hHDw8Ocf/75HDo0maItmnlBSS0UpSkktnBZeo6TafY+Fn95vGqC04w2FBkgLy+Pu+++m7vuuguXy8XSpUt59NFHAZWRvHv37oT7bt++nUceeQSvV8k5/+QnP+HSSy8ds53H46G/P3HCT29vLwUFBWRnZ3Po0CHefHPqYmV5eXkUFBTw6qvqiednP/sZl1xyCcFgkDNnznDppZfy3e9+l56eHgYGBjh+/DgbNmzg61//Otu2bdOGQhNDCj3leHUd3CXpb8oCZ0EOPc0GNm/ezKZNm3j44Yd58MEH+fznP8+dd96Jz+fj1ltvZdMmFTZ455138u///u/h/RobG8NP5VarleXLl4fH/M0UFRVx4YUXsn79eq6++mquvfbaqPVXXXUV9957Lxs3bqS2tpbzz09PIZWf/vSnYWf2smXL+PGPf0wgEOBjH/sYvb29SCn52te+Rn5+Pv/wD//ASy+9hNVqZe3atVx99TQNbWjmL1ljQ8MnjcMz+WzqeY6Qk4kqmOVs27ZN7tixI2rZwYMHWbMmjoa+Zlajv7cFzM6fxhfSW3kFHP2tml7xPjj2YvT6bbePn80cj+yi2aNnNdnPENp3Egghdkopt8Vbp4eeNBrN3CDke8irjNS9sDpgzfWw4UOJ99NMGT30pNFoZidCKKVuTzn0N0PNRSo6ClQlPc8i8JRltIkLBW0oNBrN7GbFZWAN3aqMQRCLVRdHmkG0odBoNPMDTznkzJOIp10PZLoFUWgfhUajmR/UXhWprmdPIct/7Q3R86Vr42+XCYLJ9dhmGm0oNBrN/KNs/fjbxGaBZ+XE306jDcVM8u1vf5t169axceNG6urqeOstVXBk+/bt1NbWUldXR11dHTfffDOgZcY1C50paDblL1bvyUQHNSkzr3wUQojrgOtWrFiR6aaM4Y033uCZZ55h165dOBwOOjo6wtnVAA8++CDbtsUNYZ4UIUMRT2AwEAhgtVoT7vvss8+mrR0azdSZjIKsfgZOJ/PKUEgpnwae3rZt22eTbnj6LRjuSu/JXYVQfV7C1c3NzRQXF4e1k1LVZ5osWmZcs6CxGb/R0jVw5u3U9ytcqvZtOxB/vcUGwTh6Z1Y7BNJbumA2oc3uDHHFFVdw5swZVq1axRe+8AX+8Ic/RK2/7bbbwkNPf/3Xfz3l82mZcc2CxmpTGcpl6yLL1t4QXcM7Hsu2Q14SFWPz8cxsvHXCTZxLzKseRcokefKfLtxuNzt37uTVV1/lpZde4pZbbuE73/kOn/rUp4DUh560zLhGM0HW3qDyLpx5Y9eVb4LmxCKcSbFng29ITVvn961U9yhmEKvVyvbt2/nWt77FD37wg3GfzuOhZcY1C4Z0VarLLoxvJAAqt6j8i8mQgUpzmUIbihni8OHDHD16NDxfX1/PkiVLJnwcLTOuWXCkW7i0ZHXMENL8E0ZNN/O7vzSLGBgY4Mtf/jI9PT3YbDZWrFjBfffdF15/2223hcfoi4uLeeGFFwAtM67RpJ0lF6TnOA4PDHdHLwvpUs0ztMy4Zlajv7cFzO6HwTcMdbeBLWv6znP4OehvgVVXQW459DZFZMzNlKyG4pWqbjVA3Ueh/iE1ve128A4qNdt3fzZ9bU2FaZAZ1z0KjUYzO1l1FXQ3TK+RmAjWLMgx+QNjfRTzOLNbGwqNRjM7ceWDqy7TrTAx/0ZfUkUbCo1Go0mFojiKD5s/viCywLWh0Gg0mvEQFtXDiWWe50+EmP+mUKPRaDRTQhsKjUajmSjpSgacI2hDMYNYrVbq6upYv34911133bhS3lORGZ8MiY6TruNrNLOapDd/kyN76cWw9sbpbs2sQhuKGcTlclFfX8++ffsoLCzknnvuyXSTNBqNq0C9W5OF4ZqMSNHy+P6KyWBJs4+jfFN6j2ewMDwxMXzr6f0cONuX1mOurcjlH69LoCwZhwsuuIA9e/YAcPz4cb74xS/S3t5OdnY2P/zhD1m9evWU2vP1r3+dJUuWhOtRfPOb38Tj8fBnf/Zn3HDDDXR3d+Pz+bjzzju54YYbxjmaQkrJ3/zN3/Dcc88hhODv//7vueWWW2hubuaWW26hr68Pv9/Pf/3Xf/Ge97yHz3zmM+zYsQMhBJ/+9Kf52te+NqXPpNFMC1XnQsHSSMW7rOzIusJl0HVCaUJNB64CpVi799H0HK+gJj3HiWFBGopMEwgEePHFF/nMZz4DwB133MG9997LypUreeutt/jCF77A73//+ymd49Zbb+WrX/1q2FD84he/4Pnnn8fpdPLEE0+Qm5tLR0cH559/Ptdff31KCrS//OUvqa+vZ/fu3XR0dHDOOedw8cUX89BDD3HllVfyd3/3dwQCAYaGhqivr6epqYl9+/YBTKhinkYzo1gs4CmLzId6GBB54rdOowCgI41Du7HlXdPEgjQUE3nyTyfDw8PU1dXR0NDA1q1bufzyyxkYGOD1118Py3EDjI6OJjxGqjLjmzdvpq2tjbNnz9Le3k5BQQHV1dX4fD7+9m//lldeeQWLxUJTUxOtra0sWrRo3Pa/9tprfOQjH8FqtVJWVsYll1zCO++8wznnnMOnP/1pfD4fN954I3V1dSxbtowTJ07w5S9/mWuvvZYrrrgixauk0cxjlrwHTr2upotWQPnGzLYnRbSPYgYJ+ShOnTqF1+vlnnvuIRgMkp+fT319ffh18ODBhMeYiMz4zTffzGOPPcYjjzzCrbeqwioPPvgg7e3t7Ny5k/r6esrKyuLKi8cjkS7YxRdfzCuvvEJlZSUf//jHeeCBBygoKGD37t1s376de+65hz/90z9N6RwazbympDYyvfSixPLnswxtKDJAXl4ed999N3fddRcul4ulS5fy6KNqjFJKye7diQuppCozDmr46eGHH+axxx7j5ptvBpS8eGlpKXa7nZdeeolTp06l3O6LL76YRx55hEAgQHt7O6+88grnnnsup06dorS0lM9+9rN85jOfYdeuXXR0dBAMBrnpppv453/+Z3bt2pXyeTSaeYW7dALblo2/TQZYkENPs4HNmzezadMmHn74YR588EE+//nPc+edd+Lz+bj11lvZtElFL0xWZhxg3bp19Pf3U1lZSXm5Ks5y2223cd1117Ft2zbq6uom5DT/wAc+wBtvvMGmTZsQQvDd736XRYsW8dOf/pTvfe972O123G43DzzwAE1NTdx+++0Eg0EA/uVf/mWSV0qjmaNUnaMc4auvhR0/Tr5t3Ueh87hynu/++cy0bwJomXHNrEZ/b5qMELqxb/gQNLwKy9+XuoptaF+z3Ld5Wbz18fafDJOUGActM67RaDSTw+GG2jQU1LJmQcA79eNkCG0oNBqNZrrZeAvIYKZbMWm0odBoNJp0sub6sUWN5rjK7NxuvUaj0cw2cooy3YK0ow2FRqPRzCQFNZBbmdq2lVthqAO6Uw9jnw50HoVGo9HMJMsvhZJVqW1btp6wIKHDM21NGg9tKGaQb3/726xbt46NGzdSV1fHW2+9BagkutraWurq6qirqwsnx2mZcY0mQ6z7gPI1ZBqL6RZduTVjzdBDTzPEG2+8wTPPPMOuXbtwOBx0dHSEs6tBSWts2xY3hFmj0cw06ZIRnycsTEPx3DegZW96j7loA1z9nYSrm5ubKS4uxuFQ0RCJ9JnShZYZ12g06WJhGooMcMUVV/BP//RPrFq1issuu4xbbrmFSy65JLz+tttuw+VyAXD55Zfzve99b0rn0zLjGs0cp+qc1LYrWQ3th6a1KQvTUCR58p8u3G43O3fu5NVXX+Wll17illtu4Tvf+Q6f+tSngNSHnrTMuEazQChLUg5h8Xkq27vzGCy5YNoNhXZmzyBWq5Xt27fzrW99ix/84Ac8/vjjEz6GlhnXaBYIYx4AJax+P6y6EsrWQvEKqL1qRpqiDcUMcfjwYY4ePRqer6+vZ8mSJRM+jpYZ12jmOes+oAxCPNwlkFsxdvnaG2Dl9PXaF+bQUwYYGBjgy1/+Mj09PdhsNlasWMF9990XXm/2URQXF/PCCy8AWmZco1lwxEZchcqxksSPOE0lUENomXHNrEZ/b5oFj38UWvZBxebovIo0k0xmfNYPPQkhlgkh/lsI8dj4W2s0Gs08w+aAqq3TaiTGY1rPLIS4XwjRJoTYF7P8KiHEYSHEMSHEN5IdQ0p5Qkr5melsp0aj0WgSM90+ip8APwAeCC0QQliBe4DLgUbgHSHEU4AViB3I/rSUsi1djZFSppQvoJkdzMdhUY1mLjKthkJK+YoQoiZm8bnAMSnlCQAhxMPADVLKfwESuPrHRwhxB3AHQHV19Zj1TqeTzs5OioqKtLGYA0gp6ezsxOl0ZropGs2CJxNRT5XAGdN8I3Beoo2FEEXAt4HNQoj/ZRiUMUgp7wPuA+XMjl1fVVVFY2Mj7e3tU2m7ZgZxOp1UVVVluhkazYInE4Yi3uN8wjEGKWUn8LmpntRut7N06dKpHkaj0WgWHJlwozcCi03zVcDZDLRDo9FoNCmQCUPxDrBSCLFUCJEF3Ao8lYF2aDQajSYFpjs89ufAG0CtEKJRCPEZKaUf+BLwG+Ag8Asp5f7pbIdGo9FoJs+8zMwWQrQDky0yWwx0pLE56UK3a2Lodk0M3a6JMR/btURKWRJvxbw0FFNBCLEjURp7JtHtmhi6XRNDt2tiLLR2zXoJD41Go9FkFm0oNBqNRpMUbSjGct/4m2QE3a6Jods1MXS7JsaCapf2UWg0Go0mKbpHodFoNJqkaEOh0Wg0mqQsWEMxXk0MobjbWL9HCLFlBtq0WAjxkhDioBBivxDiK3G22S6E6BVC1Buv/z3d7TLO2yCE2Gucc0ec9Zm4XrWm61AvhOgTQnw1ZpsZuV7xaq8IIQqFEL8TQhw13gsS7JtyfZY0tet7QohDxvf0hBAiP8G+Sb/zaWjXN4UQTabv6poE+8709XrE1KYGIUR9gn2n83rFvTfM2G9MSrngXqjaF8eBZUAWsBtYG7PNNcBzKBHD84G3ZqBd5cAWY9oDHInTru3AMxm4Zg1AcZL1M3694nynLaikoRm/XsDFwBZgn2nZd4FvGNPfAP51Mr/FaWjXFYDNmP7XeO1K5TufhnZ9E/irFL7nGb1eMev/D/C/M3C94t4bZuo3tlB7FOGaGFJKL/AwcEPMNjcAD0jFm0C+EKJ8OhslpWyWUu4ypvtREieV03nONDLj1yuG9wHHpZSTzcifElLKV4CumMU3AD81pn8K3Bhn11R+i2ltl5Tyt1JJ6QC8iRLmnFESXK9UmPHrFUIIIYAPAz9P1/lSJcm9YUZ+YwvVUMSriRF7Q05lm2lDqIJPm4G34qy+QAixWwjxnBBi3Qw1SQK/FULsFKpIVCwZvV4occlE/8CZuF4AZVLKZlD/6EBpnG0yfd0+jeoJxmO873w6+JIxJHZ/gmGUTF6vi4BWKeXRBOtn5HrF3Btm5De2UA1FKjUxJlQ3I50IIdzA48BXpZR9Mat3oYZXNgHfB56ciTYBF0optwBXA18UQlwcsz6T1ysLuB54NM7qTF2vVMnkdfs7wA88mGCT8b7zdPNfwHKgDmhGDfPEkrHrBXyE5L2Jab9e49wbEu4WZ9mErtlCNRSp1MTISN0MIYQd9UN4UEr5y9j1Uso+KeWAMf0sYBdCFE93u6SUZ433NuAJVHfWTCbrjFwN7JJStsauyNT1MmgNDb8Z7/Hqv2fqd/ZJVOnh26QxkB1LCt95WpFStkopA1LKIPDDBOfL1PWyAR8EHkm0zXRfrwT3hhn5jS1UQ5FKTYyngE8Y0TznA72hLt50YYyB/jdwUEr5bwm2WWRshxDiXNR32DnN7coRQnhC0yhn6L6YzWb8eplI+KSXietl4ingk8b0J4FfxdlmxuuzCCGuAr4OXC+lHEqwTSrfebrbZfZpfSDB+TJVz+Yy4JCUsjHeyum+XknuDTPzG5sOD/1ceKGidI6gogH+zlj2OeBzxrQA7jHW7wW2zUCb3ovqEu4B6o3XNTHt+hKwHxW58Cbwnhlo1zLjfLuNc8+K62WcNxt1488zLZvx64UyVM2AD/UE9xmgCHgROGq8FxrbVgDPJvstTnO7jqHGrEO/sXtj25XoO5/mdv3M+O3sQd3IymfD9TKW/yT0mzJtO5PXK9G9YUZ+Y1rCQ6PRaDRJWahDTxqNRqNJEW0oNBqNRpMUbSg0Go1GkxRtKDQajUaTFG0oNBqNRpMUbSg0mhQRQgREtFpt2pRLhRA1ZsVSjWY2Yct0AzSaOcSwlLIu043QaGYa3aPQaKaIUYfgX4UQbxuvFcbyJUKIFw2RuxeFENXG8jKh6kDsNl7vMQ5lFUL80Kg38FshhMvY/s+FEAeM4zycoY+pWcBoQ6HRpI4rZujpFtO6PinlucAPgH83lv0AJb2+ESW8d7ex/G7gD1IJFW5BZfICrATukVKuA3qAm4zl3wA2G8f53PR8NI0mMTozW6NJESHEgJTSHWd5A/AnUsoThnBbi5SySAjRgZKh8BnLm6WUxUKIdqBKSjlqOkYN8Dsp5Upj/uuAXUp5pxDieWAApXz7pDREDjWamUL3KDSa9CATTCfaJh6jpukAER/itSgdra3ATkPJVKOZMbSh0GjSwy2m9zeM6ddRSp0AtwGvGdMvAp8HEEJYhRC5iQ4qhLAAi6WULwF/A+QDY3o1Gs10op9MNJrUcQkh6k3zz0spQyGyDiHEW6iHr48Yy/4cuF8I8ddAO3C7sfwrwH1CiM+geg6fRymWxsMK/I8QIg+l0Pt/pZQ9afo8Gk1KaB+FRjNFDB/FNillR6bbotFMB3roSaPRaDRJ0T0KjUaj0SRF9yg0Go1GkxRtKDQajUaTFG0oNBqNRpMUbSg0Go1GkxRtKDQajUaTlP8fY00qlVAqUt4AAAAASUVORK5CYII=\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(np.asarray(range(len(rtl))) / len(trainloader), rtl, alpha=0.4, label=\"ReLU train loss\")\n",
    "plt.plot(np.asarray(range(len(stl))) / len(trainloader), stl, alpha=0.4, label=\"SELU train loss\")\n",
    "plt.plot(range(len(rvl)), rvl, color=\"C0\", label=\"ReLU val loss\")\n",
    "plt.plot(range(len(svl)), svl, color=\"C1\", label=\"SELU val loss\")\n",
    "plt.title(\"Train and Validation loss over Epochs\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"CELoss\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(range(1, len(raccs)+1), [a*100 for a in raccs], label=\"ReLU val accuracy\")\n",
    "plt.hlines(y=racc*100, xmin=0, xmax=len(raccs), colors=\"C0\", linestyles=\"dashed\", label=\"ReLU test accuracy\")\n",
    "plt.plot(range(1, len(saccs)+1), [a*100 for a in saccs], label=\"SELU val accuracy\")\n",
    "plt.hlines(y=sacc*100, xmin=0, xmax=len(saccs), colors=\"C1\", linestyles=\"dashed\", label=\"SELU test accuracy\")\n",
    "plt.title(\"Validation Accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "pycharm-91bfdd0f",
   "language": "python",
   "display_name": "PyCharm (SNNs)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}