17_deep_learning/03_how_to_use_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to use PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pytorch has been developed at the Facebook AI Research group led by Yann LeCunn and the first alpha version released in September 2016. It provides deep integration with Python libraries like Numpy that can be used to extend its functionality, strong GPU acceleration, and automatic differentiation using its autograd system. It provides more granular control than Keras through a lower-level API and is mainly used as a deep learning research platform but can also replace NumPy while enabling GPU computation.\n",
    "\n",
    "It employs eager execution, in contrast to the static computation graphs used by, e.g., Theano or TensorFlow. Rather than initially defining and compiling a network for fast but static execution, it relies on its autograd package for automatic differentiation of Tensor operations, i.e., it computes gradients ‘on the fly’ so that network structures can be partially modified more easily. This is called define-by-run, meaning that backpropagation is defined by how your code runs, which in turn implies that every single iteration can be different. The PyTorch documentation provides a detailed tutorial on this.\n",
    "\n",
    "- [PyTorch Documentation](https://pytorch.org/docs)\n",
    "- [PyTorch Tutorials](https://pytorch.org/tutorials)\n",
    "\n",
    "The resulting flexibility combined with an intuitive Python-first interface and speed of execution have contributed to its rapid rise in popularity and led to the development of numerous supporting libraries that extend its functionality."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports & Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:34.680345Z",
     "start_time": "2020-06-21T17:59:34.678631Z"
    }
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.500691Z",
     "start_time": "2020-06-21T17:59:34.681551Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "from pprint import pprint\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.datasets import make_circles\n",
    "\n",
    "import torch\n",
    "import torch.utils.data as utils\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "from livelossplot import PlotLosses\n",
    "\n",
    "from matplotlib.colors import ListedColormap\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.503505Z",
     "start_time": "2020-06-21T17:59:35.501675Z"
    }
   },
   "outputs": [],
   "source": [
    "sns.set_style('white')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.533497Z",
     "start_time": "2020-06-21T17:59:35.504619Z"
    }
   },
   "outputs": [],
   "source": [
    "input_size = 2         # Input data dimensionality\n",
    "hidden_size = 3        # The number of nodes at the hidden layer\n",
    "num_classes = 2        # The number of output classes\n",
    "num_epochs = 20         # The number of times entire dataset is trained\n",
    "batch_size = 20        # The size of input data for one iteration\n",
    "learning_rate = 0.01  # The speed of convergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Random Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.546293Z",
     "start_time": "2020-06-21T17:59:35.534625Z"
    }
   },
   "outputs": [],
   "source": [
    "# dataset params\n",
    "N = 50000\n",
    "factor = 0.1\n",
    "noise = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.558436Z",
     "start_time": "2020-06-21T17:59:35.548018Z"
    }
   },
   "outputs": [],
   "source": [
    "# generate data\n",
    "X, y = make_circles(\n",
    "    n_samples=N,\n",
    "    shuffle=False,\n",
    "    factor=factor,\n",
    "    noise=noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Torch Tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by converting the NumPy or pandas input data to torch Tensors. Conversion from and to Numpy is very straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.566152Z",
     "start_time": "2020-06-21T17:59:35.559430Z"
    }
   },
   "outputs": [],
   "source": [
    "X_tensor = torch.from_numpy(X)\n",
    "y_tensor = torch.from_numpy(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.576060Z",
     "start_time": "2020-06-21T17:59:35.567169Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([50000, 2]), torch.Size([50000]))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_tensor.shape, y_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Torch Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use these PyTorch Tensor to instantiate first a TensorDataset and, in a second step, a DataLoader that includes information about batch_size:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.585830Z",
     "start_time": "2020-06-21T17:59:35.577625Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset = utils.TensorDataset(X_tensor,y_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Torch DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.594021Z",
     "start_time": "2020-06-21T17:59:35.586761Z"
    }
   },
   "outputs": [],
   "source": [
    "dataloader = utils.DataLoader(dataset,\n",
    "                              batch_size=batch_size,\n",
    "                              shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch defines a NN architecture using the Net() class. The central element is the forward function. autograd automatically defines the corresponding backward function that computes the gradients. \n",
    "\n",
    "Any legal Tensor operation is fair game for the forward function, providing a log of design flexibility. In our simple case, we just link the Tensor through functional input-output relations after initializing their attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.605401Z",
     "start_time": "2020-06-21T17:59:35.595015Z"
    }
   },
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_classes):\n",
    "        super(Net, self).__init__()                    # Inherited from the parent class nn.Module\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)  \n",
    "        self.logistic = nn.LogSigmoid()                          \n",
    "        self.fc2 = nn.Linear(hidden_size, num_classes)\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        \"\"\"Forward pass: stacking each layer together\"\"\"\n",
    "        out = self.fc1(x)\n",
    "        out = self.logistic(out)\n",
    "        out = self.fc2(out)\n",
    "        out = self.softmax(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.615029Z",
     "start_time": "2020-06-21T17:59:35.606269Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (fc1): Linear(in_features=2, out_features=3, bias=True)\n",
       "  (logistic): LogSigmoid()\n",
       "  (fc2): Linear(in_features=3, out_features=2, bias=True)\n",
       "  (softmax): Softmax(dim=1)\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net = Net(input_size, hidden_size, num_classes)\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.629910Z",
     "start_time": "2020-06-21T17:59:35.616499Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([[-0.2076,  0.2368],\n",
      "        [-0.0387, -0.1712],\n",
      "        [ 0.1126, -0.0031]], requires_grad=True),\n",
      " Parameter containing:\n",
      "tensor([ 0.6205,  0.2236, -0.2600], requires_grad=True),\n",
      " Parameter containing:\n",
      "tensor([[-0.0197,  0.3641,  0.2366],\n",
      "        [-0.5317,  0.4601,  0.2530]], requires_grad=True),\n",
      " Parameter containing:\n",
      "tensor([0.0978, 0.2066], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "pprint(list(net.parameters()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.638374Z",
     "start_time": "2020-06-21T17:59:35.631436Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[-0.2076,  0.2368],\n",
       "        [-0.0387, -0.1712],\n",
       "        [ 0.1126, -0.0031]], requires_grad=True)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(net.parameters())[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enable GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To enable GPU processing, you can use net.cuda(). See Pytorch docs for placing Tensors on CPU and/or one or more GPU units."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.645676Z",
     "start_time": "2020-06-21T17:59:35.639719Z"
    }
   },
   "outputs": [],
   "source": [
    "# net.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Loss Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need to define a loss function and the optimizer, using some of the built-in options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.663995Z",
     "start_time": "2020-06-21T17:59:35.647061Z"
    }
   },
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T17:59:35.671374Z",
     "start_time": "2020-06-21T17:59:35.665546Z"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model training consists in an outer loop for each epoch, i.e., each pass over the training data, and an inner loop over the batches produced by the DataLoader. That executes the forward and backward passes of the learning algorithm. Some care needs to be taken to adjust data types to the requirements of the various objects and functions, e.g. labels need to be integers and the features should be of type floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:07.419060Z",
     "start_time": "2020-06-21T17:59:35.672407Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(num_epochs):\n",
    "    print(epoch)\n",
    "    for i, (features, label) in enumerate(dataloader):\n",
    "        \n",
    "        features = Variable(features.float())         \n",
    "        label = Variable(label.long())\n",
    "\n",
    "        # Initialize the hidden weights\n",
    "        optimizer.zero_grad()  \n",
    "        \n",
    "        # Forward pass: compute output given features\n",
    "        outputs = net(features)\n",
    "        \n",
    "        # Compute the loss\n",
    "        loss = criterion(outputs, label)\n",
    "        # Backward pass: compute the gradients\n",
    "        loss.backward()\n",
    "        # Update the weights\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting losses in real time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is an example that uses the `livelossplot` package to plot losses throughout the training process as provided by Keras out of the box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.453048Z",
     "start_time": "2020-06-21T18:00:07.420195Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEzCAYAAAAsM6IYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxU9bk/8M+ZPTOTbc6wJ5BMBNlBAjKxoNXaeu2mooJIsYpyraX6E1Hc0GJF1Ba3a12oVfFiAVGxvb563Xq1LpiJgIIUEUsmAcIW5sxkmUkyZ5bz+2NyJgnZZjlnzpnkef/TOmRmvoRJznm+32dhBEEQQAghhBBCCCEkbRqlF0AIIYQQQgghAwUFWIQQQgghhBAiEQqwCCGEEEIIIUQiFGARQgghhBBCiEQowCKEEEIIIYQQiVCARQghhBBCCCESoQCLEEIIIWQAqKqqwk9/+lPJXu/MM8+E1+uV7PUIGSwowCKEEEIIIYQQieiUXgAh2SAajWLt2rXYs2cPAoEABEHAmjVrMH78eKxZswZffvkltFotLrzwQixfvhwtLS09Pn733Xdj7NixuP766wEAd911V/y/L7jgAkydOhUHDhzAbbfdBp1Oh/Xr14PneXi9Xlx66aW49dZbAQBvvPEGXn75ZWg0GhQWFuLRRx/FM888A5ZlsXz5cgDA3/72N7z//vt45plnFPu+EUIIUUZzczMeeOABfPvtt2AYBnPnzo1fWz7++GOsW7cOGo0GEyZMwOeff45NmzahqKio19d75pln8Pe//x1arRalpaW47777MGTIELz//vt47rnnwDAMtFotVq5ciVmzZvX6OCGDAQVYhCRgz549qK+vx2uvvQaNRoM//elPeOGFFzBmzBgEg0H87//+LyKRCJYsWYIvvvgCH374YY+P92fs2LF48sknIQgCrrnmGjzyyCMoKSnByZMncf755+Oaa65BfX091q1bh7feegsjRozAhg0b8Nxzz2HRokVYunQpbr75Zuh0OmzduhW/+tWvMvDdIYQQojZr1qxBQUEB3n77bYRCIdx000146aWXcOWVV2LlypV45ZVXMH78eLz11lt46623+nytN998E59++ineeOMNmM1mPP3007jrrrvw4osv4ve//z3WrVuH6dOn47PPPkNVVRVmzZrV6+OEDAYZTxHcs2cPFi9enNJzL730UixevBiLFy/G3Xff3efXfvbZZ7j00kuxcOFCPPvss93+vKGhAUuXLsXChQtx0003geO4Pp+3Zs0azJs3D4sXL8aePXtSWj8AHDp0SNL8aJIZZ511Fm699VZs2bIFjz76KN59910EAgF8/vnnuOKKK6DVamEwGPDqq69i9uzZvT7en5kzZwIAGIbB888/j3379uGPf/wjHnnkEQiCgNbWVlRWVmLOnDkYMWIEAODaa6/F7373O0yYMAFFRUX45z//ierqatTX12POnDmyfl8IGSjSuTatX78eCxYswLx58/D666/3+bU7d+7ElVdeifnz5+OPf/xjr1/3wQcfYMWKFf0+79FHH8WCBQtw+eWXY+vWrQCAlpYWrFy5EldffTWuvPJKfP311yn9vQBgw4YNWLduXcrPJ8r55JNP8Itf/AIMw8BgMOCqq67CJ598gp07d6KsrAzjx48HAFx22WWwWq39vta8efNgNpsBANdccw1cLhd4nsdPfvIT/OY3v8G9996LpqYmLF26FAB6fZyQwSCjAdYLL7yAVatWIRgMJv1c8TkbN27Exo0b8fDDD/f6tdFoFKtWrcLTTz+NzZs3w+12Y+fOnV2+Zv369SgvL8fmzZuxePFiPP74470+76OPPkJNTQ3eeOMNPPXUU3jggQeSXj8A/PWvf8Xy5cvh8/lSej5Rzj//+U/ceOONAIAf/OAHWLhwIQBAp9OBYZj41x0/fhw+n6/XxxmGgSAI8cdDoVCX9xEvXi0tLbjsssuwb98+TJw4EStXroROp4MgCNBqtV1eu62tDdXV1QCARYsW4c0338Qbb7yB+fPnd/k6QkjP0rk2VVVV4auvvsLmzZuxceNGnDhxos+vX7t2LR5//HFs3boVVVVV+Oabb7p9zZo1a/DYY48hGo32+TyXy4XDhw/jtddew+bNm/HCCy+gsbERL774IsaOHYtNmzbhwQcfhNvtTvrv1dbWhttvvx2bNm1K+rlEHaLRaJdrQDQaRTgchlar7XIdAgCNpu/bwd5eCwCWL1+OTZs2YfLkydi2bRsWLVrU5+OEDAYZDbBGjx6Np59+Ov7fBw4ciJ9I3XzzzWhubu71ud9++y1aW1uxZMkSXHPNNdi9e3eXP7/gggviF0efz4e8vDwUFxcDAGbMmIEvv/yyy9cfPHgQ5557bvzPd+3a1evzDh48iLlz50Kj0cBms0Gr1eLUqVM4fvw4brjhBixevBg33HADjh8/3uffPz8/H6+++mqC3y2iJtu3b8f555+Pq6++GpMnT8Y//vEPRCIRVFRU4K233kI0GgXP87jllluwY8eOXh8vLCzEv/71LwDAyZMne00bPHToEPx+P2699VZccMEFqKqqAs/ziEajmD17NiorK1FfXw8A2LJlC/7whz8AAC666CLs378f7733Hi6//PLMfHMIyXLpXJs+++wzjBs3DsuWLcOvfvUrfP/73+/y552vTQCwdetWFBcXIxAIwO/3o6CgoNtrzpgxA6tXr+7yWE/PO+uss7B27dr410QiEeh0Onz22WfQ6/W4/vrr8eyzz2Lu3LkAgHfeeQcLFizAwoUL+z2VCgaDuPTSSynNOIvNmTMHr776KgRBAM/z2Lp1K8455xzMmDEDtbW1+PbbbwEA7733HpqamvrckJs7dy7efPNNtLS0AIhtds+aNQsajQYXXHABWltbsXDhQvz2t7/FgQMHwPN8r48TMhhktAbroosuQl1dXfy/77vvPqxduxZnnHEGXn/9dfz5z39GeXk5fv/733d53q233ori4mJcf/31uPLKK1FbW4ulS5fi3XffxX333Ye6ujqcOnUKS5YsgU6nw4YNG+K7+iUlJfjkk0/iR+GiCRMm4MMPP8TEiRPx4Ycfoq2tDTabrcfnzZw5Ey+//DIWLVqEEydO4ODBg2htbcXjjz+OxYsX47zzzkNlZSXWrVuHpUuX4vbbb+/yXgsXLsSiRYtw/vnny/fNJbK66qqrsGLFCvzsZz9DOBzG9773Pbz//vv485//jIceegiXXHIJIpEIfvzjH+NHP/oR5syZ0+PjU6ZMwe23346LLroIRUVFcDqdPb7fmWeeie9///u4+OKLYTAYMG7cOJxxxhk4dOgQ5s6dizvuuAM33HADAGDIkCHxmyyDwYCLLroIHo8HNpstY98fQrJZOtcmn8+HY8eO4fnnn0ddXR1uuukmvPvuu7jnnnu6XZteeeUV6HQ67N69G7fddhvKysp6/Dn98Y9/jKqqqi6P9fQ8o9EIo9GIUCiEu+66CwsWLIDFYoHP50NTUxNefPFF/PWvf8Wjjz6Ke+65B08//TTefPNN5OTk4I477sD27duxe/duvPPOO13e68UXX8SwYcMwZ84cbNu2TcLvNMmkVatWYc2aNfjZz36GUCiEuXPn4le/+hUMBgMef/xx3HnnndBoNJg8eTJ0Oh1ycnJ6fa0rrrgCx48fx5VXXoloNIoxY8Zg3bp10Ol0uOeee3D77bfHMzfWrl0Lg8HQ6+OEDAaMcPo5sczq6upw2223YevWrSgvL8fEiRMBxFKlSktLe039E3fvTSYTgNgP+9NPPx2vQ7ngggvwzjvvwGg0AgB2796Nxx57DHl5eRg9ejSGDx+OX/7yl/HX8/v9eOihh3D8+HHMnTsXH3zwAbZs2dLr85577jl8+umnGD9+PL777js8++yzuOqqq1BQUBA/btfr9Xj55Zf7/R5873vfw/bt29P6PhLSk5aWFvziF7/A/fffj+nTpyu9HEKyRqrXpnXr1sFms2HJkiUAgJ///Od4+eWXwbIsgO7Xps6eeOIJaLVa3HLLLd3+rKqqClu2bMETTzzR5/MaGxtxyy234Oyzz8ayZcsAAPPnz8f999+PyZMno7GxEQsXLsQjjzyC//zP/8TYsWMBAIFAAPPnz8dVV13V5/dl27ZtcLvd3TYOSfby+/149tlncfPNNyMnJwf79u3DjTfeiE8//ZTSygmRiKJdBEtLS/Hoo49i5MiR2LVrF06dOtXr177xxhv47rvvsHr1apw8eRJ+vx9Dhgzp9es/+eQTrF+/Hjk5OfjNb36DefPmdfnznTt34pJLLoHT6cR7772HGTNm9Pq8mpoasCyLTZs24fjx41i5ciXy8vLgcDiwZMkSzJgxA9XV1dixY4c03xhCUvDpp59ixYoVWLhwIQVXhKQhmWtTeXk5/vu//xvXXXcd6uvr0dra2mPaHwAIgoBFixbhueeeQ35+PiwWS0IpU709r62tDddeey2uu+46/PznP++ypo8//hiTJ0/Gjh07cMYZZ6CoqAgjRozASy+9BL1ej23btmHChAnJf3NI1rNardDr9bjiiiug0+mg0+nw5JNPUnBFiIQUDbBWr16NO++8E5FIBADw0EMP9fq1V1xxBe6++24sXLgwftSs03Us/8MPP+zy9cOHD8fChQthMpnws5/9LL5rt2TJEjz//PMoLS3FnXfeCQAYOnRoPMWqp+cFg8F4e1Kj0Yj7778fAHDnnXdi9erVCAaDaGtrw7333ivdN4eQJM2dOzehVvCEkL4lc206//zzsWPHDlxxxRUQBAH3338/tFpt/M87X5sYhsGSJUuwdOlSGAwGDBkyBGvWrAHQcW3qKYWqt+dt2bIFR44cweuvvx7vXrh27VrceOONWLVqFRYsWACdTodHH30UNpsN1157LRYvXoxIJIJRo0bh4osvluT7RbLP8uXL4zMTCSHSy3iKICGEEEIIIYQMVBmfg0UIIYQQQgghA1VGUgSvv/56mv1ECCEkJYWFhXjxxRdleW26PhFCCElVb9enjNVgUatXQgghqbj++utlfX26PhFCCElFb9enjKQI0u4gIYSQVMl5DaHrEyGEkFT1dg2hGixCCCGEEEIIkQgFWIQQQgghhBAiEQqwCCGEEEIIIUQiFGARQgghhBBCiEQowCKEEEIIIYQQiVCARQghhBBCCCESSSjA2rNnDxYvXgwAOHToEBYuXIirr74av/3tbxGNRmVdICGEEEIIIYRki34DrBdeeAGrVq1CMBgEADz88MO49dZbsWnTJgiCgP/7v/+TfZGEEEJIIniex4oVKzB//nwsWbIEtbW1Si+JEELIIKPr7wtGjx6Np59+GitXrgQA7Nu3D2effTYA4Nxzz8X27dvxwx/+UN5VtluwvhJHG1oleS2GAW7/0Zm4ZPooSV5PjT76th6r396HSFRQeindGHUaPLuoHGcOz1V6KV088PY+OIZYsdg5RumldPH2nmP4/XvfQpDon5K1GLBpqRMWY7+/AjKmLRTB0v/eiZsvGIuzS21KL6eLJz74Dka9Br/+/hlKL6WLz6s9uGfbXoQl+hm3GnX47+vPxtBckySvp4StW7fCbDZj69atcLvdePDBB/Hiiy8qvSxC0hKKRHHjxl1Ydn4Zyseo6/cjIaS7fu+uLrroItTV1cX/WxAEMAwDALBYLGhubpZvdaeZXWpDnUQB1qf/9mDrziMDOsB648s6NLSE8IMJQ5VeShfBUBR/33scXx32qS7A+p/dx8BaDaoLsLbuPIJWPopzx9nTfq2m1hD+sb8eLjeHH0wYJsHqpPHlIR8+/bcHI/NzVBVgRaICXtpegxLWoroAy1XN4ZC3BZedlf7vsWA4ir9/fRwffVuPBbNGS7A6ZRw8eBDnnnsuAMDhcKC6ulrhFRGSvhONbfjw23pMKyqgAIuQLJD09rVG05FVGAgEkJeXJ+mC+nLbj86U7LVW/88+bNlxGMFwBEadVrLXVQtBEFDl5nDB+KF4fP50pZfTRSsfwd/3HgcX4JVeSheRqABfCw8uwMPjD8JuNSq9JAAAH45iZ60P82cW4YFLJqf9em2hCKaufl91AZbLzcX+t4ZTeCVd7T/ehOa2MLwq+7wCABfgUWg2SPIzHvud4YXL7c3qAGvChAn46KOPcOGFF2LPnj04efIkIpEItNqB93ueDB7i7x8uEFR4JYSQRCTdRXDixImoqqoCAHzyySeYOXOm5IvKhIoyFm2hKPYcaVR6KbI4WO+Hx8+jwsEqvZRucgxaWAxacH513bA2tPAQM62q3F5lF9PJ13UNaA1FUFEmzb+lSa/FWaMLUOlWVyAjrucQ14JjEp1US6GyOrYujz8IQaocTYlwfh6sxSDJazEMA6fDhspqTnV/z2RcfvnlsFqtuOaaa/DRRx9h0qRJFFyRrCcGVmq7bhJCepZ0gHXnnXfi6aefxoIFCxAKhXDRRRfJsS7ZzS61gWE6bp4GGvFmVaqbcqnZrAZ4VbYT1/mEotLtUXAlXYmf0dml0v1bVpSx2HesCY0tIcleMx2tfAS7jzTg3HFDAKjr51L8WQqGo2jhIwqvpitvgIdNogALiH0uTjS1oZZrkew1M23v3r0oLy/Hxo0bceGFF6K4uFjpJRGSNjGw8vjVdd0khPQsoQCrqKgIW7duBQCUlpbi1VdfxWuvvYaHH344a3cGC8wGTBieF09LGmhcbg6jCnJQVJij9FJ6xFqMqksR9LRfwKxGHVwqOsFy1XAYPzwXhRLeSDsdLAQB+KJWHX/PXYd8CEUEXHdOCfJz9Kr5uQxHothR44W1vRmI2naPPQFpU1md7Sfeavn+p2LMmDHYvHkzFixYgKeeegp33XWX0ksiJG1cPEVQXb+DCCE9G9SDhivKWOw67ENbSF270umKRgW43F44HWy8IYnasBaD6m5WxROsH04choP1ftQ3tym8IiAYjmBnrU/yk8jpxQUw6jSqOSmqdHug1TCYVWrD7FKbatIX9x1rQnMwjB9OjNWqqa3+QeoTLIfdgqG5RtV8LlJhs9mwYcMGvPbaa/jzn/+MYcPUU2dISKo4f7DL/xJC1G1QB1hOBws+HMXuIw1KL0VS/673wxvg4XSot9MQazWo7mZVXM9PpowAoI46rD1HGhEMR+MnC1Ix6bWYMbpQNScVLrcXU4vyYTXqUFHGos7XiiNe5dPUxO/Pj9s/E2raFAhFomhoCYG1ShdgxeqwWLjc2V2HRchAI55c+VpCCEeiCq+GENKfQR1gnV1qg2YA1mFVVsfqh9RafwUANosR3gCvqps48eZ5zlg7rEadKk5RKqs5MAzglLD+SlRRxmL/iSY0tCgbNASCYew50hBvyCJ+btUQ/FW6OZQNsWB8+zgBNXUS9LX/u0nV5EJUUcaivjkItycg6esSQlLXeXPHq/DvbEJI/wZ1gJWfo8ekkfmquJGTUqWbQ7EtB0WFZqWX0iu71YBQREBTW1jppcRxgSAKzHqY9FqcXWqDSwWBt8vNYeKIPOSb9ZK/dkVZrA5L6XqzXYd8CEeF+CnduKG5KDTrFV9XqL3+qqKMjZ8SeVR06irecLESjxMQA92BtvFESDbrnPGhppN0QkjPBnWABQBOhw1fHW4YMHVY0aiAqhqvLCceUhLrRtSUT+4NdLS8rnCwcHsCONmkXB1WWyiCXYd9kqcHiqYW5cOk1yi+wVDp5qDTMJhZUggA0GjUkab2r6ONCPARVDjsMBt0yNFr4VXRjY14kyVlDRYAjGHNGJ5nUvxzQQjp4PXzKLbFmlZRgEWI+g36AKuijAUfieLLQz6llyKJb080o6ElpOr0QKBj111NKVcePw/WEluXGrqpfXW4AXw4KtssM6NOi5ljbIrfSFdWc5hWXACzoWPuudPB4mhDK454lZuHJaaIzm6vZbRZDKrq4CXuaNslrMECYnVYFWUsXG6vqlJ4CRmsBEGAJ8DjzGGxVGW11S8TQrob9AHWzJJYHZbSN5lSEf8ecp16SEU8KfKoaCeO8wfjqWATR+Yh16RT9HPhcnPQMMCsUvmalTgdNnx7olmxQNcfDGPv0cZuQaQa6rBcbi/GDbPG26DbrQZVzaCJpwhapE0RBGKfC48/iOpTfslfmxCSHH8wDD4cxbj2AEtN101CSM8GfYCVZ9Jjyqh8VTQ0kEKlm8MY1oyRBeqcfyUSAxk1nWB5A3x8XVoNE2sXrmAdSqWbw6SR+cjPkb7+SiQGMlUKff531HoR6VR/JRo71ArWYlDs5zIUiWJnrbfLulirUXWfV62GkeXzUeGwA6A6LELUQPy9U2q3QKdhVJVaTwjp2aAPsADAWcZi95EGtPLZXYcViQqocnOypZRJSW01WOFIFL6WEGydTgOcDha1XAuON2Y+Ta0tFMHuww2yp3pOLSpAjl6rWCDjcnPQaxmUjyns8rjS7cK/rmtACx/p8rNkU9nsNi4QRKHZAI1G+ll3xbYcjCrIUbzRCCGk48TKnmtU3e8hQkjPKMBC7EY6FBGwK8vrsPYfb0JTW1j16YFArP4n16hTTU2LryUEoGs9i5Jpal8e8oGPRGWfZabXajCzRLl5WK5qDmcVFyLHoO32Z84yFscb23CIy/w8LDGwmN3lBMugqtECnJ+XvEW7iGEYzHbYFG80QgjpOMGyW4xgrUaqwSIkC1CABWBWiQ1aDYNKt0fppaQlW+qvRLFhw+oIsMQLVueObBOG5yE/R69ImlS8/qpE/mHRFWUsvjvpz3h9UXNbCHuPNvYaRFa0P65E8FdZzWH88NwunwfWYgAfiaI5qI7RAlynlFY5VDhYcAEe352kOixClCRmetishvZaUHVcNwkhvaMAC4DVqMOUUflZnw7jcnMotVswPN+k9FISYrMY4FXJTpy3h4YBmvY6LCU+F5VuDlNG5SPXJF/9lUgMyKsy/PfcUetFVIidVPWkbIgVQ3KNGU9f5MNR7Dzk7bZRIX421NKq3RvgJW/R3pkaOmkSQhDfiGQtBrAWA51gEZIFKMBqV1HGYs+RBgRUsjudrIg4/ypLTq+AWNMAteSSe8QL2GknAk4Hi8PeFhxtyFwdVisfwe4jDb0GHlKbMiofFoM24ye4ldUcDFoNZowu7PHPxTqsyurMpqntqWtAWyja7WfJ1v7ZUMvNjccfjHc4lEOxzYyiwhxqdEGIwjg/D4tBC5Neq6rrJiGkdxRgtatwsAhHs7cOa9+xRjS3hWWv2ZESq6K5Qt72FIzTa1ridVgZvMncdciHUKR7Zz25xOqwMn9S53J7cdboApj03euvRE6HDfXNQdR4AplbVzUHhkG3nyV7+wmWGm5u+HAUzW1hWU+wgNgGQ1UNh2iU6rAIUQoXCMZnR7JWA1r4SNY35SJkoKMAq135mELoNEzWtmsX03iyoYOgSGwaoIabNy7Ag2GAAnPXG9Yzh+Wi0KzP6Oei0u2BVsNkpP5KVFHG4mC9H/XNbRl5v8bWEPYda+y3S6L4ec7s95/D+OF53T4LHSdYygdY3l5OXKVW4WDhawnhwMlmWd+HENI7zt9Rbxnf6FHJSTohpGcUYLWzGHWYVlyQtekwldUcyoZYMDQvO+qvgFhNSyQqoLE1pPRS4PHzsJkN0J7W8jpWh8Vm9HPhcnsxtSgfVqMuY+9ZEa+3ycwp1o6a9vqrfjYESu0WDM01ZmxdwXAEuw75etyoYFU0WsATP3GVL0UQ6KiPy9bfi4QMBFygo2OoGGip4SSdENI7CrA6cTps2Hu0Ef4sq8MKR6LYUevLqvoroNOFQhUnAsFeTwMqylgcbWjFEa/87cIDwTD2HGnI+L/lpJF5sBp1GWtoUOnmYNRpML24oM+vYxgGFWWZq8PafbgBwXC0x5M1k14Lq0pGC2TqBGtUQQ5G28zU6IIQBXH+YHwzRUwVpBMsQtSNAqxOKhx2RKICdtRmVzfBfx1rgj8Yln0ordTYeE2L8hcKzt97RzZnBtPUdh7yIRwVMp7qqdNqcHapLWO1ZpXVHGaMLuyz/kpU4WDh8QdRfUr+duGV7lj91dm9pGeqZcineHMl1xysziocLKpqvKpI5SVksBEEAd5OIxnEn3lq1U6IulGA1Un5mELotUzW7daK6TuzS7MrwBIDGq9KTgTYXjqyjRtmhc1iyMjnwuXmoNMwKB/Tc2c9OTkdNrg9AZxskrcOq6GFx/4TTQlvCHQEuPJvfLjcHCaNzEO+uef2+GLdoNK4HsYKyMVZZkNjawj7TzTJ/l6EkK6aWsMIR4X49ZJSBAnJDhRgdZJj0GJ6cUFGO8ZJweXmMHZobGZQNrG3Xyg8Krhh9fiDvZ4GxNqFx0535E5Tq6zmMK24AJYM1l+JKhx2APLPPaqq8UJIoP5KNIY1Y0S+Sfafy7ZQBF8eboCzj40K1mLI+EDmnnABHjoNg7wc+T8n4ueC6rAIyTxP+2m1OJLBbNDBbNCqIvODENI7CrBOU+FgsfdoI5rblG+8kIhQJIodtd6sSw8EgELxBEvhnTg+HEVTW7jP04AKB4tjjW04LGMdlj8Yxt6jjYp1gpw4Mg+5Jp3sN9IuNweTXoNpxfkJfb04D8vlljfA/fKwD3wv9Vci1mJUxQmWtz2llWGY/r84TcPzTSi1W7LuZJ+QgSB+Wt2p3pK1qmfECSGkZxRgncbpYBEVkDV1WHuPNqKFj2RdgwsgNn8pP0eveLGuryV2obL10TAgPg9LxpvMHbVeRKKZm391Oq2GwexSm+w30pXVHGaOscGo67/+SlThYMEFePy7Xr46LJfbCw0DzCrtvT2+rT1FMJODj3vSeS5OJjgdNlTVxD6fhJDM8bZfHzvXCLMWoypO0gkhvaMA6zQzxhTCoNVkTTpMR/1V9gwY7kwNw4bFHUJ7Hw0DyoZYYbcaZf1cuNwc9Fpl6q9ETgeLWq4FxxtbZXl9X4DHtyeakx6I7XTIH+C6qjlMHpWPPFPP9VdA7PMajgpoalW202jnts2Z4HSwaG4L45tjVIdFSCaJzSzsnTZU7FZ1NNshhPSOAqzTmPRanDW6IGNzd9LlcnM4c1huRnezpcRaDYrnknM97BCeLl6H5fbKdnrhquYwvbgAOYbET3akJncgU1XTPhA7yZTWYlsORhXkyBbgtvIR7D7S0G96JhuvG1T4M9tp8OkLopcAACAASURBVGgmVGQgwCWEdCemJBeau55gKZ35QQjpGwVYPXA6WOw71qiKAbh94cNR7Kz1ZWX9lUgNba87Zgr1HaQ6HSxONLWhlpO+DqupLaRo/ZVo4og85OfoZQtkKqs55Oi1mDKq7/lXp+tchyVHu/AvD/vAR6L9pmeKdXpK12Fx/mCfGwJSG5pngmOIJSOjCtIVCoWwYsUKXHXVVbj66qtRXV2t9JIISRnnDyLPpINB13G7xrafYCmdqkwI6R0FWD2oKGuvw6pR9ynW13UNaA1Fkk63UhPWqnzTgI4UjL5vWMVAVo7gY2etF9EkOuvJRaNhcHapTbYbaZfbi5klhV1uFhLldNjgawnhu/pmyddVWc1Bq2Ews6Tv9MyOFsnK7R63hSII8JEuKUOZ4HSw+KLGi3AkmtH3TdbHH3+McDiMLVu2YNmyZXjyySeVXhIhKfME+G4/66zVqIpUZUJI7yjA6sH04gIYdBrV79a62oeiZtv8q87sFgO8LbyixfOcPwithumz9gYAHHYLhuQaZUmTqqzmYNBqMEPB+itRhYPFEW8r6nzSntRx/iAOnGxOOYiMz8OSIcB1uWP1V7n9fAbEEywlh3yKNYuZrMECYp8LfzCMfSqvwyotLUUkEkE0GoXf74dOl/mRB4RIRewY2pldJanKhJDeUYDVA5Nei/LRhapvdFHp5jB+eF683Xk2slkMEITY8FmleAOxC5hG03fLa4ZhUOFgUSlDu3CX24uzRhfApFeu/krU0TFR2hPcqvYT4VRTWottZhQV5kge4LbwYeyp67/+ClDHcGxxrEEmUwSBzgOf1f170Ww24+jRo7j44otx3333YfHixUoviZCUxTqGdv1ZFzd6lE6vJ4T0jgKsXlSUsdh/oknRG/++BMMR7Kz1ZXV6INBR96RkJ0GPP/GObBVlLE41B+H2BCR7/8bWEPYda1Q8PVB05rBcFJr1kgcyldUcLAYtpoxKbP5VTyocLKpqvJLWYe065EMoIiQU+Bl0GuSadIqmCIq71plubDMk14gzhlpV3+hiw4YNmDNnDt577z387W9/w1133YVgkHb6SXaKNbQ5PUVQ+VRlQkjfKMDqhdPBQhA6dt3VZs+RRgTDUcWbIqRLDGyU3Inz9rBD2Bs50tS+qInVX6mlWYlGw2B2KSv5CW6lm8PMEhv02tR/7VSUsWhoCWH/CenS1CqrOeg0DGYmmJ5ptxoV3RAQT7AynSIIxALcHTVehFRch5WXl4fc3FwAQH5+PsLhMCKRiMKrIiR5kagAX0v3DcCObqbq3AAmhKQYYPE8jxUrVmD+/PlYsmQJamtrJV6W8qYV58Ok16h2t7ayOvvrr4DOJ1jK7cRxAR42S2KnASWsGcPzTJKmSbncHAw6DaYXJ9dZT05Ohw1HG1pxxCtNHdap5iAO1vvTDiI72shLt/FR6eYwtSgfFmNitTpKd77k4idYmQ+wnA4WAT6CvUcbM/7eibr22muxb98+XH311fjlL3+J5cuXw2w2K70sQpLW0MIjKnTfTLGZ6QSLELVLqfp369atMJvN2Lp1K9xuNx588EG8+OKLUq9NUUadFuVj1FuH5XJzsZba5r6L8tVOLTUtiZ4GiPOwPjvogSAIYJi+67YSUVnNoXx0oSrqr0QVZXYAseCj2Jb+zam4UZFuGuTIghyMYc2orOZw/ZzStNcVCIbxdV0jbjzXkfBzWIsBh2Ro1Z8oLsDDoNXAmmBAKCUxJdnl5jBjtPINWXpisVjw1FNPKb0MQtLG9TJCRKfVoNCspxosQlQspROsgwcP4txzzwUAOByOATtnpMLB4tsTzfCp7Bi+LRTBrsO+rE8PBIBCsx4Mo1xXtmA4guZgOKl0q4oyFh4/j4P1/rTfv6GFx/4TTapJDxSNG2aFzWKAS6INBpebg9Wow+SReWm/lrOUxRc1nCSdJ3fUehGJJlZ/JWKtBmVPXNuHDEsR3CeLtRpx5rBc1W48ETKQcH2kA7NWGjZMiJqlFGBNmDABH330EQRBwO7du3Hy5MkBmeMu3nRV1ajrZuKrww3gw/0PRc0GOq0GBTl6xVIdEh0y3FlHmlr6n4uqGi8EFcy/Op14UueSqGNipZvD2aU26NKovxJVlLFoagtj//H067Bcbi/0WgblSbTHZy2x2W1yDDxORKaHDJ/O6bBhZ61P1XVYhAwEXB8NbViLQdFxEYSQvqV0t3P55ZfDarXimmuuwUcffYRJkyZBq1VPepNUpowqQI5eq7rdWpebg4YBZpVmdwdBkZLDhuM7hEnUs4y2mTEyX5o6LJebg0mvwbTi1DvryaXCweJYYxsOp1mHVd/UBvepgGQdL6UMcCvdHKYVFcBsSDzdjrUaEBWAhtZQ2u+fCm+ge1exTKooY9EaiuDrugbF1kDIYNCxAdj9+mS3GqkGixAVSynA2rt3L8rLy7Fx40ZceOGFKC4ulnpdqmDQaTCzpFDyeUDpqnRzmDQyH/k52V1/JWIVbBqQytBWhmHgLGPhcqffLryymkP5mEIYderboJCqY6IYiFY47GmvCQCG55tQarekva7mthD+dbQx6fTMjrpBZW5uPH4edgVPsM4ulWdOGiGkK4+fB8MAheaeUgQNinYzJYT0LaUAa8yYMdi8eTMWLFiAp556CnfddZfU61INp4PFgZPNqtkpagtFsPtwg+pqdtKhZE2L+O+a7ImA08HCG+Dx7zTqsLwBHt+eaFZtLd0ZQ62wW41pnxS53BxyTTpMlKD+SuR0sPiixotwGmlqO2t9iESFpNMz7e2fFaXSc8TB2EqxWQwYP5zqsAiRG+cPotBsgFbTvd6StRjR0BKiVF1CVCqlNlQ2mw0bNmyQeCnq1FGH5cWPp4xQeDXAl4d84CPZP/+qM9ZiBBdQ5mZNPDlL9oa1In6648GZw3NTeu8v2mv71Bosi3VYle11WKk2VXC5vZhdauvxJiFVTocNm784jG+ON2FqUWrt7SvdHAxaTdLd8GwKzm5r4cNoDUUUTREEYp/ZzV8cRjAcUeXpKyEDQV+bKWLaoC/AY2ieKZPLIoQkgAYN92PKqHxYDOqpw6p0c9BqGMwsUWeL5FTYLAY0tITSOo1IFRfgodcyyDMlt9dQbDNjVEFOWmlSldUccvRaTBmlnvlXp3M6WJxsCqI2xbbkJxrbUOMJSN7Eo0KC9EWXm8P04gLkGJILEMQbGyVSBPvqKpZJTgeLtlAUX9epdx4WIdmO62OEiF0cNkyNLghRJQqw+qHXajCzxCbpYNl0uNwcJo/KR65pYNRfAR0XCm9L5i8UYke2VE5nKspYuGq4lOuwXG4vZpYUwqBT74+heLqWaiAj1fyr0w3NM6FsiCXl9MWm9vorZwqnh2I9hBI3NlwfRe+ZNLvUBoZJvz6PENI7TyAYT0k+nXiKTa3aCVEn9d7ZqUhFGYuD9X6calb2F1krH8HuIw2SdWNTC5sldqFQopOgN8CDtaSWblXhYNHQEsK3J5qTfi7nD+LAyWbVtWc/ncNuwZBcY8obDJXVHPJz9Jg4Qrr6K5HTwWJHrS+lk88v3F5EBaSUaqvXalBg1iv0eY39DlKyBgsACswGTBieJ0knR0JIz/pMEVQwVZkQ0j8KsBIgZVvodOw65EMoIgyo+iugYzdeiQuFJ8CnfBognn6k8rkQUwvVWn8lYhgGFQ425XlY4vwrjYT1V6KKMhb+YBh7jyafpuZyczDoNDhrdGrpmTaLMo1ZxFOz3na1M6mijMWuQz4EwwNvBiIhSgtFomhoCfV6fWLjzXboBIsQNaIAKwGTR+bBatQpHmBVuj3t9VcD6wRL3IlT4kLhDQRTrmcZVZCD0TZzSqc7LjcHs0GLKaPUN//qdE4Hi1PNQVSfCiT1vKMNrTjsbZFtQ2B2Gu3CK90cZowugEmfWoMGu8WoyIZAqk1Z5OB0sAiGo/jqMM3DIkRqvng6cM+bKXkmHfRahlq1E6JSFGAlQKfV4OxS5euwKqs5TC3Kh9WYUvNH1RIvIEqkXHF+Pp6imAqnw4YvapKfh1Xp5jCrxAa9Vv0/ghUpntS5quWpvxINyTVi7FBr0j+XjS0hfHO8Ka11xU6wlEkRNOk1MCfZmEMOZ5faoGGUP9knZCDqb0YjwzCxDrx0gkWIKqn/7k4lnA4b3KcCONnUpsj7B4JhfF3XOODSAwGgIEcPDZP5FMFWPoIWPpJWw4CKMhaNrbEb9kSdag7iYL1f9emBohLWjOF5pqQDGZebQ4FZj/EptrFPREUZi5213qRmwVTVcBBSrL8SsVaDYhsCrMWYcst8KeXn6DFpZD41uiBEBol0DGWtBqrBIkSlKMBKUIXDDkC53dqdh3wIpzAUNRtoNIwiJwJiDY09jQArlfo8uTrryUWch1WVZB1WpZvDbJnqr0ROB4sWPpJUu/BKNwejToPpKdZfAbFTV18Ln/HRAlwaNYNycDps+OpIA9pCVIdFiJTE61NfM+9YqxEeShEkRJUowErQxJF5yDUpV4flcnPQDbD5V50pkerQUc+SeorgiPwclLDmpAMsq1GHySOl76wnl4oyFh4/j4P1/oS+/oi3BXW+VtlPXGeXxuoRk/v+e1E+pjCtAbmsxQBBAHwtoZRfIxVcGjWDcqgoY8GHo/jysE/ppRAyoCRygmW3GChFkBCVogArQVoNg9mltrQGy6ajsprDtOICmA0Dq/5KZLNkPuXKK9FMoYoyFlU1XkQSrMOK1V8VQpcF9Vci8bQt0TRBMeCpKLPLtiYgtoN75rDchAMsX4DH/uNNaQd+HcOGM/yZTbNmUGozS9rrsChNkBBJcYEgtBoG+Tm9z7ykFEFC1Ct77vBUwOlgUeMJ4ERjZuuwxFbUA7H+SsRaM58iKHYtTPdEwOlg0dwWxjfH+q/DOtnUBvepQNbUX4lG28wYmW9KOJCpdHOwWQwYO9Qq88rEOiwf+HD/6XpVNbENklQGDHdmi8+gydzusSAI8AT4tFJapZZn0mPKqHzFNp4IGai8AR6FZkOfKdas1YjWUAQtfDiDKyOEJIICrCQoNQ9rR23sdCTbbsqTwSqQ6uDtpw1uojpOdzz9fm38ZMch78mO1BiGgbOMhcvdf8dEQRBQ5fbC6ZC3/krkdNjQGorg67r+24W73BxMeg2mFaVefwV0zKHK5KZAgI+AD0dV0aK9M2cZi6+O+NDKUx0WIVLx+PvfTKFhw4SoFwVYSZg4Ig/5OfqMd81yVXPQaxnMGD0w66+AWJDT1BZO6BRCKlyAh0GngSXNltfD8kxw2C0JfS5cbg65Jh0mZlH9lcjpYOEN8PiuvrnPrzvibcXRhtaMNfGYXcqCYZDQ97+ymsPMMTYYdOn96lPiBEt8r3Q3BKTmdLAIRQSqwyJEQpw/2G/6up2GDROiWhRgJUGjYRSZh+VycziruBA5Kph9IxfxhjWTNS2cn4fdYpCk5bWzjMWOWl+/XeVcbi9ml9qgzcDJjtTEFNX+6m06TukyE2AVWgwYPzwPrpq+18X5gzhwslmSk+BCswEMk9nPqyeBonclzCqJfZ6pXTsh0vEG+q+3FAMwOsEiRH0owEpShYPFYW8Ljja0ZuT9mtpC2Hu0EU6HLSPvpxQxFUJsTZsJXCAIm0T1LE4HC38wjH/1UYd1orENNZ5A1rRnP12xzYxRBTn9bjBUujnYrQackYH6K5HTYcPOWh+C4d7T1OL1VxL8LGk1DArNhoy2SJaqKYvUrEYdpozKV3wQOyEDSWzmXT8pgvFUZTrBIkRtKMBKkrj7namuWTtqvIgK6Rflq524U5fJnThvIDa0VQriTXtf9XlijVa2BlhAR8fE3uqwBEFAZTWH2Q42o8NwKxwsguEodh/uvQ7L5eZgNmgxNc36KxFrMcCbwc+rmCKothosIPa52HOkgYrtCZFAMBxBczCccA2Wh06wCFEdCrCSdOawXBSa9RlrdOFyczDoNAO6/gpQpu0155duaOvQXBPOGGrtM03KVe1Ffo4eE0dkX/2VqMLBoqElhG9P9FyHdYhrwYmmtox3vBTrsPrqZldZzWFmiQ16idrjxzpfZvLEVUwRVFcNFhD7XISjAnbWKl+HtW3bNixevBiLFy/G/PnzMWXKFDQ19d/hkxC1EK+D/aUImvRaWI06ShEkRIUowEqSRsNgdimbsXSYSjeHs4oLYNIP3PorALBbMlusKwiC5ENbnQ4bdtR6EeqlDqvSzeHs0sx01pOLeJLa2+dffDzTp3T55ljg2lsnx1PNQfy73i9pqi1rMWa0iyDn52ExaFVZi1k+phA6DaPYIPbO5s2bh40bN2Ljxo2YNGkSVq1ahby87N3UIINPfMhwAhuAmd7oIYQkhgKsFFSUsajzteKIt0XW92lsDWHfsaYB3Z5dlJejg07DZOwEq4WPoC0UlbQjW4XDjhY+gr1HG7v92dGGVhz2tmT9LLNRBTkYbTP3eiPtcnMYkmtE2RBLhlcWO0X58nAD2kLd67CqaqRvvJHpIZ9eCWsGpWYx6jCtuEBVdVh79+7FwYMHsWDBAqWXQkhSxI3GRGbexUac0AkWIWpDAVYKMjUP64saLwQhu2t2EsUwDGwZvFCI7yNlPcvs9tORntIExZq9gfBv6XTYUOXmEDmtDkusv3JmuP6qY10s+HAUX/VQh1VZzcFi0GLyqHzJ3s9mMaCxNdTriaXUOAlrBuXgdNjwdV0j/EF11GGtX78ey5YtU3oZhCQt0RRBINbogtq0E6I+FGClYNwwK2wWg+y7tZXVHIw6DaYXS1OUr3Y2iyFjKVdiSkUiO4SJsluNGDfM2mPg7XJzKDDrMX54rmTvp5SKMhZNbWHsP961rqXGE0B9c1CxU7pZpTZomJ43PlxuDrNKpau/Ajo6ePky9ZlNoKuYkiocdkSiAnbW9l4HlylNTU1wu91wOp1KL4WQpCWTImi3Zu66SQhJHAVYKWAYpn0X3wtB6LmbmhRcbg4zRhcO+Porkd1qzFgueccJlrQnAhUOFjtrfd0GJle6OczO8vorUW8nuOKGg1Iprfk5ekwa2b1deH1TG6pPBSQP/DLdwYsL9D94VEnlYwqh1zKqSBPcsWMHzjnnHKWXQUhKuAAPvZZBrlHX79eyFiO8Ab7Xzq6EEGVQgJWiCgeLow2tOOKVZx5WQwuP/ScGR/2VKJMpgvGZQhKfCDgdLFpDEew92pGmdsTbgjpfa9bXX4lG5OeghO1eh1VZzWFYnhElrFmhlcWCu92n1WG54vOv5AmwMlE3KAhCQoNHlZRj0GJ6cUGfnRwzpaamBkVFRUovg5CUcP4gWIsxoVRr1mpAJCqgsTWUgZURQhJFAVaKKuLd1HruWpauqvb6q8EUYLFWQ8aaXHjaT8qkPhGY3X4T37kOyxU/2bFL+l5KEudhiXVYgiDA5faiQqH6q/i6HCz4SBRfHupoF15ZzSHXqMOkkdJ2kmMzOBy7qS2MUESQNKVVDhUOFv862ojmNmVv9m644QZce+21iq6BkFRxgcRHiNCwYULUiQKsFJUNscJuNcq2W1tZzcGk12BqkXRF+WrHWgzwB8M9doGTmtfPI0evhdnQfwpGMmwWA8YPz+2SJlXp5mCzGDB2qFXS91KS08GiuS2MfcdiHROrT/nh8QcVb+Ixs6QQWk3XNDWx/konYf0V0DGPKhOnrmoeMtyZ08G212EpPw+LkGzFBfiEf9btNGyYEFWiACtFYh1WZTUnSx2Wy81h5hgbjLrBUX8FdOzEZeIUK5kdwmQ5HSx2HfIhGI5AEARUub1wOgZG/ZXo9DqsyvaNBqVPXHNNekwelR9f14nGNtR4pK+/AmI1X1oNk5Gd43hKq4RjBeQwY0whDFqNKuqwCMlWnD8Ie4I/6/ETLAqwCFEVCrDS4HSwONHUhkOctPOwvAEe355olnQoajYQa1oyciIQkK8jm9PBoi0UxZ4jjTjibcXRhlbFT3akNizPBIfdEk+FdFVzGJFvwmibcvVXIqfDht1HGtDKR+KBlhzff42GQaE5M2mt4u60mrsIAoBJr8X00QU9jioghCQmmY6hmUxVJoQkjgKsNHTUYUl7M1GlcDc2pWTyQsH5g7KdBjgdNjDt7cLj9VcDLMACAGcZix21PoQiUbjcnOL1V6IKB4tQRMCuQz643BzyTDpMlLj+SmS3GjKSmtNxgqXuAAuIff/3HWukontCUtDCh9EaiiQ8VLzQbADDUIogIWpDAVYaHHYLhuYaJR847HJzyNFrMbVocMy/EmWypsWbRI57sgrMBkwYnofKag6Vbg52qwFnDKD6K1GFg4U/GMZfvzoKLsDDqZINgVkltvY6LA8q3RzOLmWhlSk902bJzAlWttRgAbGNoagA7KhRvpsgIdlGvP7ZE+wYqtUwsJkN8d8RhBB1oAArDbE6LFbyOqxKN4eZJYWSDkXNBuKOndw3rIIgxFIwZDwNcDpY7Drsw/aDHsxWycmO1Ga3p7D+14f/BqCeUzqLUYepRfn4nz3HcIhrkTXVlrUaM3JjwwV45Bp1WVGTOb24AAadRvKNJ0IGAy6F02rWmrkRJ4SQxKR0Bx8KhbBixQpcddVVuPrqq1FdXS31urJGRRmL+uYg3J6AJK/n8Qfx3Un/oEsPBIBcow4GrSbeQl0uzcEw+EhU1nqWijIWfDiK+uagagIPqQ3NNeGMoVYc8bZiVEEOilVQfyWqcLDxGXVy/iyxGZrdJmdTFqmZ9FqUjy6kRheEpMAbSP60mrUYqQaLEJVJKcD6+OOPEQ6HsWXLFixbtgxPPvmk1OvKGqd3U0tXlVueoajZgGGYWMqVzDes3njDAPk6sp1dEqvDAgb2v6V4OqS2v6O4nvwcPSYMl6f+CogFWM3BMIJheUcLeAPBrEgPFDkdLL453oSGFtpVJyQZYi1Vol0EATrBIkSNUhoCVFpaikgkgmg0Cr/fD51O2llC2aSENWN4ngmr/2cf1v59f9qvx0eisBi0mDJq8My/6oy1GuIpEnIRd/oSLSJORb5Zj0kj83CyKYiyIRbZ3kdpFQ47XnUdVt2JayzFlsHsUnnb43dOax2RnyPb+3B+XlUnhP2pKGPxxD+Ar+sace64IUovh5CskUpDG7vVCA/VYBGiKilFRmazGUePHsXFF18Mn8+H559/Xup1ZQ2GYbB23mR8flC6dJjpowsGXf2VyGaRv1g32SLiVD3w80nwByMDsv5K9MOJw7DqJxPw06kjlF5KF2aDDk8uOEv25iKdG7PIGWB5/DymF2dP05uZYwrx8LwpmDbIGvUQki7OH4RJr4HZkPjtGWsxoKktDD4chUE3OO8dCFGblAKsDRs2YM6cOVixYgWOHz+OX/7yl3j77bdhNKp7CKZcLhg/DBeMH6b0MgYEu9WIGonq2XqTShFxKsrHDPw5ZgadBjfMdSi9jB79JANBnz0+WkC+U9doVICvJXtqsIDYjLCFZ49WehmEZJ3YDKzk7qXEkSPeAI/h+SY5lkUISVJKWx15eXnIzc0FAOTn5yMcDiMSkbcGgQwOtgw0DRBTMLKppoWok/gZ8spYYN7YGkIkKsAm84krIUR5qTS0Eb+e0gQJUY+UTrCuvfZa3HPPPbj66qsRCoWwfPlymM3ZUx9A1Iu1GtAaiqCFDyeVIpEMjz8Iq1EHk179La+Juok7x3JuCoinY/YsOsEihKSGCwQxJIkGF0BmTtIJIclJ6Q7WYrHgqaeeknothMTrojg/D7NNngBLziHDZHDJM+mg1zKy3tiINYlydr0khKgD5+cxPsnOpx21oHSCRYhaUDUkUZWOlCs5b1izq56FqJc4WkDOGxtKaSVkcBAEIZYimOTPung9o1bthKgHBVhEVeIXChlrWjz+oKxDhsngYrMYZb2x8VCKICGDgj8Y6wSY7Aag1aiDQaeBh4YNE6IaFGARVenc9lou3kDyXZoI6Y1d5tlt4mDsQtoUIGRAE697yV6fGIaBPQMNogghiaMAi6gKK3OxriAIsRosOg0gErFZDLKeuHKBIPJz9IN2Nh4hg4V43Uvl+sRajVSDRYiK0BWbqIrZoIVRp5HtQtHUGkY4KlCKIJEMazHGT5nkEJuLQ59XQgY68bpnTyHDgpX5JJ0QkhwKsIiqMAwDu9Uo24VCzFG3J9kGl5DesFYDAnwEbSF5ZgFygSA1ZSFkEBAb2qTy887KXAtKCEkOBVhEdeQcNkwd2YjUxNMluTYFOD+NFSBkMODSuD7ZrQZ4/EEIgiD1sgghKaAAi6gOazXI1qY9PlOITgSIRDqGDcuT1uoN8PH3IIQMXB5/EFajDia9NunnslYDguEoArw8J+mEkORQgEVUJ5bqIM/NqrhDSF0EiVRsMp5gRaICvC087HSCRciA5w2kflpNw4YJURcKsIjqiMW6cqQ6iKmHlHJFpGKXcchnQwsPQaDPa7LWr1+PBQsWYN68eXj99deVXg4hCeH8fMrZFeLzPFSHRYgqUIBFVIe1yJfq4A3wyDXFhjISIgUx+PHK0Ko9fuJKKYIJq6qqwldffYXNmzdj48aNOHHihNJLIiQhHn8w5ewKu8ypyoSQ5OiUXgAhp4vfsPp5WI3SfkQ9/iB1ECSSshpjAbscJ1gdg0fpBCtRn332GcaNG4dly5bB7/dj5cqVSi+JkIR4AzymFRWk9Fy5Z0gSQpJDARZRHTEA8gSCGM2aJX1t6shGpMYwDFiLQZbUHHGAMZ1gJc7n8+HYsWN4/vnnUVdXh5tuugnvvvsuGIZRemmE9CoaFdob2qR2fYrXgtIJFiGqQHlSRHU6LhTS37B6AzS0lUgv1vlShhRBqhlMWkFBAebMmQODwQCHwwGj0Qiv16v0sgjpU1NbCOGokPJmilGnRa5JRzVYhKgEBVhEdcQdPHlqWoJ0GkAkx1rkGY7NBXgwDFBo1kv+2gNVeXk5Pv30UwiCgJMnT6K1tRUFBamlXRGSKR0dblPfTLFb5fk9RAhJHqUIEtURi3yl3omLp2DQYEwPDAAAIABJREFUaQCRGGsx4GC9X/LX5fxBFOToodPSXliizj//fOzYsQNXXHEFBEHA/fffD602+blChGRSvN4yjRmNrMVAKYKEqAQFWER1cgxamA1ayYcNN7SGEBVoyDCRXmy0gPQ3NjRkODXU2IJkGzEwSmdGI2s1oNbTItWSCCFpoG1RokqsVfqdODHlkOpZiNRsFiPaQlG08GFJX5fz04krIYNBx0iGNE6wrEZZNnoIIcmjAIuokk2GmhYx5ZDatBOpsTING47VDFKARchAJ/7uKDSnUYNlMcAb4BGJClItixCSIgqwiCrZLQbJb1bFlEM6wSJSE0+ZpN4U4AJ8WilDhJDs4A0EkWeKzdRLFWs1IioADS3U6IIQpVGARVTJ1r4TJ6V4jjudCBCJiXVSUqa1hiNRNLSEaEOAkEHAE+DTzq6gYcOEqAcFWESVxFxyQZAu1cEjQQoGIT1hZZjd5m0RU1rp80rIQMf5008H7ujAS3VYhCiNAiyiSqzFgFBEQFObdE0DvAEeBWY99NTymkhMjp3jjiHDlCJIyEDnDfBpn1bbZaoFJYQkj+40iSp1DBuW8IY1EKSObEQWZoMOOXqtpCmCXgm6ihFCsgPnT38kgxypyoSQ1NAcLKJKtnjKVRCldoskrxlreU2nAUQevdUNhkIh1NXVoa2tLanXM/FhvPDzETC3nMD+/fVSLVPVTCYTioqKoNfrlV4KIRkTiQrwtvCwp7kBWJCjh4ahGiySnlSvWQNdstcnCrCIKonFvpKmXAV4jB1qlez1COnMbjXA08Pnta6uDrm5uSgpKQHDMAm/nscfhL6hFRNH5EE3CNJaBUEAx3Goq6tDaWmp0sshJGMaWngIQvodbjUaBjaLMV5vTEgqUr1mDWSpXJ8G/lWbZCWbHE0DJMhxJ6Q3sROs7qk5bW1tYFk26QtVOCKAAaDVDI4LHMMwYFmWdk3JoNMxZDj9DAu71UApgiQtqV6zBrJUrk8UYBFVEgOhnm5YUxGJCvC1pJ/jTkhvWKux1w2BVC5U4WgUWo1mUF3kBtPflRCRR8IRIqzVQCmCJG30u7i7ZL8nFGARVTLptcg16iRLdfC1p2BQkwsiF9YSu7GRarRAOCJAp6WLHCEDXbyhjQQ1wqzFSCdYhKgABVhEtWxW6YYNiycL1JGNyIW1GsCHo/AHpRktEIkK0A2S9EBCBjMpr0+s1UBt2klW27ZtG9atW5fy8+vq6jB//nwJV5SalJpcbNu2DW+99RYAIBgMYv/+/di+fTvy8vIkXRwZ3GInAtLsxImvQzVYRC7ivCpvgEeuKf0ueOGogBw97YERMtBxAR4MAxSa078+2a1GNAfDaAtFYNJrJVgdISQVKQVY8+bNw7x58wAADzzwAC6//HIKrojkbBYj6nwtkryWuKNnpxosIhNx99nj5zGG7Xm0wJu76rB155GEXq+FD0On0cCg6zvImj+zGJeXF/X6536/H/feey+am5vh8/lw5ZVXYtKkSXjooYcgCAKGDRuGdevW4cCBA90eW7p0KVavXo2ysjJs3rwZHo8Hl112GW666SYUFBTg3HPPxbRp0/DHP/4RQKw4+tFHH0VpaSmeffZZ/OMf/0AkEsHChQvBMAxqa2tx5513IhKJ4NJLL8Wbb74Jg4E2PcjgxvmDKDQbJGlow1o6ZkiOLMhJ+/XI4JbMNStR/V2zOnvppZfw97//HTqdDjNnzsQdd9wBr9eL22+/HTzPo7S0FC6XCx988EGPz9++fTuefPJJGI1GFBQUYO3atQiHw7j11lshCAJCoRAeeOABlJSU4P/9v/8Hv9+PtrY23HHHHZg9e3Zaf8+02rTv3bsXBw8exG9/+9u0FkFIT+xWA/bUNUjyWmJOOp1gEbmwnWa3SUEQACnqjA8dOoSf/OQn+NGPfoSTJ09i8eLFMJlMeOKJJ1BWVoa//OUvqK6uxn333dftsd6cOnUqHhz95S9/wR/+8AcMGzYMzz//PN59912cd955+OSTT/D666+D53k89thjuPXWWzFv3jzcfvvt+PTTTzF79mwKrgiBOKNRmp+FjmHDFGCR7HbgwAG888472LJlC3Q6HW6++WZ89NFHqKysxA9+8AMsWrQI27dvx/bt23t8viAIuO+++7B582YMGzYMr7zyCp577jnMnj0bubm5eOyxx3Dw4EH4/X4cPnwYHo8HGzZsAMdxqK2tTXv9aQVY69evx7Jly9JeBCE9EQe3RqMCNGnu7HklTMEgpCfijU1fdYOXlxcltHMXCkex/0QTRhXkpN350m6345VXXsH7778Pq9WKcDgMjuNQVlYGAFi0aBEA9PhYZ52bdxQVFcWDo2HDhuGhhx6C2WzGyZMnMWPGDNTU1GDq1KnQarXIycnBqlWrAACzZs3CZ599hm3btuHXv/51Wn8vQgYKKUeIxE/SJUqvJ4NbotcsObjdbkybNi0+2HfmzJn497//jerqalx22WXxx3rj8/lgtVoxbNgwALHrz+OPP4477rgDtbW1+PWvfw2dToebbroJY8eOxaJFi3DbbbchHA5j8eLFaa8/5QT/pqYmuN1uOJ3OtBdBSE9YqxGRqICmtlDar+UJ8LBJlIJBSE/iJ1gSNGYJR6MAIEkXwZdeegnTp0/HunXr8B//8R8QBAFDhw6N79D96U9/wgcffNDjYwaDAadOnQIAfPPNN/HX1Gg6Lh2rVq3C2rVr8cgjj2Do0KEQBAEOhwPffPMNotEoQqEQrrvuOvA8j/nz5+P1118Hx3EYP3582n83QgYCTyAoWfq63dJxgkVINnM4HPj6668RDochCAJ27NiB0tJSjBs3Dl999RUAYPfu3b0+v7CwEH6/H/X19QCAL774AiUlJaiqqsLQoUPx0ksv4aabbsLjjz+OAwcOIBAI4E9/+hMeeeQRPPjgg2mvP+UTrB07duCcc85JewGE9Ea8YfX4eRSkefLk9dOQYSIvk14Li0EryY1NOBo7LdJp0m9ycf7552P16tV4++23UVBQAK1Wi9WrV+Oee+6BRqPBkCFDcO2112LYsGHdHjMYDPjd736HESNGYOjQoT2+/iWXXIL58+cjLy8Pdrsd9fX1mDBhAubOnYuFCxciGo1i4cKFMBgMmDZtGg4dOtTjCRkhgxXn5yXrcCu+DrVqJ9nuzDPPxMUXXxy/jpSXl+PCCy9EeXk5Vq5ciXfeeQdDhw6FTtdzKMMwDNasWYObb74ZDMMgPz8fDz/8MBiGwfLly/HKK69Ao9Fg2bJlKCkpwTPPPIO//vWv0Ov1uOWWW9Jef8oBVk1NDYqKlDk2JIODeKGQolU7FwhSi3YiO9ZqlKTzpRhgSXHi6nQ68e6773Z7fNOmTV3+e+rUqd0eO++883Deeed1e+7WrVvj///uu+/G3Xff3e1rbrzxRtx4441dHotGozCbzfjpT3+a1N+BkIEqFImisTUk2Qag2aCFSa+hYcMka4lN9ADguuuuw3XXXdflz/fu3YtbbrkFU6dOxeeffx7PshAVFRXFr1HnnHNOj4dBGzZs6PbYf/3Xf0mw+g4pB1g33HCDlOsgpBs2nuqQ/g0rF+AxYTh1uiTyEusG0xWOiCdYAyel9ciRI/jNb36DBQsWwGq1Kr0cQlTBJw4ZlihFkGEYsBYjPHSCRQaooqIi3HPPPdBqtYhGo7j33nuVXlKP0mpyQYic4qkOUpxgSZiCQUhv7FYDjja0pf06kWgUDJgBVTNYXFyMv/3tb0ovgxBV8YgjRCRMYadhw2QgKysrw2uvvab0MvpFUyyJaokd/9K9UEidgkFIb2InWN13jjt34EtEOCJAp2XASNGnPYsk+30iJNuJJ95SXp9Yi0GSVGUyeNHv4u6S/Z7QCRZRLYNOgzyTrscb1mRInYJBSG9YqxHeAA9BEOLBkclkAsdxYFk24YApHBUG1OlVIgRBAMdxMJlMab/WpZdeitzcXACxdJKHH3447dckRA5iICTl9Ym1GvHtiWbJXo8MLqlcswa6VK5PFGARVbNbjfCkmSIophhKNciRkN78//buPL7JKv8X+CfbkzRJtyQtIi10YREVRAQXvGxueAXBi6yiqDD+1NFBmVEZebnAxUGdn6PXUVHgp/ObQVzRccbxJ+ooiAvDCLLIJlIoshaSUEqSNutz/whP2kILbZo8S/J5/yM0aXJ4fJJzvud8z/c4bQLCURF1DRHk58TP7igpKcG+fftO2Yh7OoePB6EHEPVm16SAxWLpcPGkYDA+YF2yZEkqmkSUVlKGhiuFKexSimDTiR6itkqmz8oG7e2fGGCRqjlsQoeLXEgdGAMsSremJZKlAMtkMqG8vLxdr3Pn71egX2kB/ji5d8rbmOm2b9+O+vp6TJs2DZFIBL/+9a/Rr18/pZtF1CKPPwiDXoc8iyllr+mymRGKxnA8GEnp61J2SKbPolMxwCJVc9oF7Hb7O/Qa6UjBIGpJovKlP4SKouRfx+tnUZZkWSwWTJ8+HePHj0d1dTXuuOMOLF++vNWzUoiU5DlxRqM+hSnBjRM9IQZYRAphkQtSNYfN3OEiF1zBIrlIG9U7cs82hKPwBSO8X5NUXl6O0aNHQ6fToby8HAUFBUx1IdXy+EMp/6xLk4k8bJhIOQywSNVcdgFHAyFEY8lXtJFSMKSULaJ0cUkDmw4UZvGyKEuHLFu2DE899RQAoKamBj6fD0VFHVhOJEojjy+Y8tVqKWBzs1Q7kWIYYJGqOWwCYiJQG0i+o/D6Qyi0pjYFg6glhbZ4EO/twMBGWv3isQLJGTduHI4fP47Jkydj5syZmD9/PtMDSbXiK1ipnUxJxUQPEXUMex1SNWkWP74nJblOyO0LpbRCE1FrzEYDci3GDh2OLQ2KeM8mRxAE/OEPf1C6GURt4j2xByuVUpGqTEQdwxUsUjVXClIdvP7Ud2BErYkf8tnxFaxUz2oTkbo0hKM4HoykfDJFOkOSe7CIlMMAi1TNcaLj8XZowBrkfhaSjdNu7tDARrrXHVzBIspo6dxvmYozJIkoeQywSNUay14nP2BNR5UmotY4bEKHJgTc/iAEgx65ZmZwE2WyxGRKGvqn+GHDXMEiUgoDLFK1Qmu8aECyKYLBSBTHG1jymuTjsgsdSmmVzsXR6ViUhSiTuX3p22/pTMERJ0SUPAZYpGpGgx6FVhO8Sa5gseQ1yc1pM+NoIIRYkkcL8JBhouyQzv2WTnvH9oISUccwwCLVc9iEpGfiWPKa5OawCYjGRByrDyf1+x5fkPcrURZI535Lpz0+0ROJxlL+2kR0ZgywSPWcdnPSM3HS77HkNclFWn1Kdt+gxx9KnGNDRJkrnfstXXYBoggcDSQ30UNEHcMAi1TPaUt+s66UWsgVAZJLojBLB1Zdeb8SZT5vGvdbpqJAFBEljwEWqZ7TnnxVtkSOO1cESCaNK1jtv2cDoQjqw1HuwSLKAp407rdMfA+x0AWRIhhgkerFiwaEk8ol9/hDMBl0yLOw5DXJQ6pYmUyAJQ2GXDxkmCjjpfOMRikt3s1S7USKYIBFqifNxCWTSy4VDGDJa5JLoRRgJTGwSee5OESkLuk8o7GjqcpE1DEMsEj1OpJL7vWH4OBqAMnIZNAjP8eUVFqrdI8zRZAo83l86Quw8nNMMOh13INFpBAGWKR6DlvyueRuX4gVBEl2TntyRwu403guDhGpR+N+y/R81vV6XYeOOCGijmGARarn6kDRAG8aUzCIWuOymZNecQW4gkWU6RoPGU7fZ91pExKTNkQkLwZYpHqODuxpie/B4moAySvZmWOPLwizUQ+rYEhDq4hILTwyTKa47MlN9BBRxzHAItUrsArQ69DuPS0N4Sj8IZa8Jvk57UJyVQRPHDLMoixEmU2aMEznESLJpioTUccxwCLVM+h1KLS2P9UhMUPIFEGSmdMm4GgghGhMbNfv8ZBhouwgR//ktJmTyvwgoo5jgEWaED9suH0dhRwzhEQtcdrNEEXgaKB9kwLeNB48SkTqkdiDlcbPu9MuwB+Koj4UTdt7EFHLGGCRJsRn4pJbweKKAMlNuufam9bq8QVZQZAoC3j9QVhMelgFY9reo7FAFFexiOTGAIs0wWEXkhisxp/PMu0kN2lW2t2O9BxRFOMHj/J+Jcp48TOw0juZwsOGiZST9NTJwoUL8cUXXyAcDmPy5MkYP358KttF1IzLJrRrsAogkVLIFSySmzSwac+kgD8URTAS455Boizg9qf/jEYnV7CIFJNUgLVmzRqsX78eb775Jurr6/Haa6+lul1EzThsZtQ1RBCKxCAY27bw6vGFIBj1sJvTl4JB1JLEwKYdM8fSnkFOCBBlPq8/iKI07w92nXh9noVFJL+kRp5ff/01evbsiXvuuQc+nw8PPfRQqttF1Iw0YD0aCKFTnqVNv+Pxh+CyCSx5TbIrtArQ6dp3OLb0XBeLshBlPI8vhHPOykvreyQz0UNEqZHUHqyjR49i8+bNeP755zF37lw88MADEMX2lSMmag8pbao9aYIeXxAO7mchBUhHC7SnRLI0COIKVmp4PB4MHToUVVVVSjeFqBlRFON7sNLcP1kFI3JMBpZqJ1JAUitYBQUFqKiogCAIqKiogNlshtfrhdPpTHX7iAA0llpvz54Wrz/9m4iJWuO0ta8wi7RnkEUuOi4cDuOxxx6DxdK21W4iOfmCEYSi8uy3TPbQcyLqmKRWsC666CJ89dVXEEURNTU1qK+vR0FBQarbRpQgzeq3J9XB7QuxYAApxmET2n2/AuCkQAo8/fTTmDRpEoqLi5VuCtEpPDJ+1p12c7sLRBFRxyUVYA0fPhy9e/fGuHHjcPfdd+Oxxx6DwWBIdduIEhrP82jPnpYgVwNIMS67Ge52VO/y+kOwCgbkCPwu7Yj3338fDocDgwcPVropRC3yyLha7WrnRA8RpUbS5dVY2ILklGcxwaDXtTmXPBCKoCEcg4OrAaQQRztTBD2+IPdfpcB7770HnU6H1atXY9u2bZg1axZefvllFBUVKd00IgByr2AJ2HzgWNrfh4iaY/1q0gS9XteuAWuiA+MKFinEaRdQGwgjHI3BZDhzskD8kGFOCHTU0qVLE3++5ZZbMGfOHAZXpCpSJoYc/ZPTbobXH4IoiqyoSySjpFIEiZTgtAltPs8j0YFxRYAUIt17RwNtnxRw8X4lynjSRKEcK9ZOm4BwVERdQyTt70VEjRhgkWbEqyG1LUVQSiXkigApRbr32rr/weNnimCqLVmyBJWVlUo3g6gZty8Iu9kIiyn9+y1die8hFrogkhMDLNIMp83c9hRBrmCRwqR7ry33rCiK8WMFOCFAlPHkOANL4kyiQBQRdRwDLNKM9pS95h4sUpp077WlRHJdQwThqMgJAaIs4PWHZFutlgppcAWLSF4MsEgzXHYBvmAEDeHoGZ/r9QeRYzLAKrCOCylDGti0ZQXLK+OmdyJSltsXlO28O1dioocrWERyYoBFmuFox4DV45NvhpCoJfk50tECbblf47PLvGeJMp/HH0oEPulWeOI7hWdhEcmLARZphjS735YAyy1jB0bUEr1eh0Jr2wqzSPsjXNyDRZTRYjERR2VMETQZ9CiwmtpcIIqIUoMBFmmGtD+lLXtavKzIRirgbOO+Qek5vGeJMltdQxiRmChrQZu2fg8RUeowwCLNkDqktqYIsiIbKS1+tEBb9mAxRZAoG0h7oeTMsHDazW2amCSi1GGARZqRKDd7hpk4URTh8YdYkY0U57AJbUtp9YWQK9O5OESkHDkPGZa42jjRQ0SpwwCLNCPXbITJoDtjR+ELRhCKxFiRjRTnauPMsdcfgoP3K1HGkwrayFVFUHovlmknkhcDLNIMnU7Xpo6icYaQKYKkLIdNwPGGeMB/Oh5/kCuuRFnA7VciRVDA0UAYkejpv4eIKHUYYJGmOGxnTnVw85BhUom2Vr6MHyvACQGiTOc90T8Vyjihkti/HGCaIJFcGGCRprSlaIA0mHVxwEoKk9KAzlQiWc5zcYhIOR5/EPk5JpgM8g2/XDwLi0h2DLBIU+LlZs8wWJUObeWAlRTWlsIssZgY34PFFEGijKdEASZpBYsBFpF8GGCRpjjt5jOnW514nHtaSGnSPXi6e7auIYyozOfiEJEyPL6g7OnriYkeHjZMJBsGWKQpDpuAQCiK+lC01ed4fCHYBANLXpPipBTB01USTOwZ5IQAUcbz+EKyVhAEGtPl3VzBIpINAyzSFFcbZuI8/iBXA0gV8nKMMOpPf7SAtLrFoixEmU+JIxkS30Ms1U4kGwZYpCmJogGnmYnjfhZSC51OFz9s+DT3qxLn4hCR/KIxEd5AKFF0Qi46nS5eIIorWESyYYBFmuJoQ9lrt48V2Ug9nHbzGVZcuYJFlA2OBkIQRSiSYeG0nf57iIhSiwEWaYqrDXtavP4gV7BINZxnOLtNmlUutPKeJcpk0sSgEv2T0y5wDxaRjBhgkaY4EnuwWu4oRDFe8pp7sEgtzpSa4/EHkWcxQjDy65gok0kTg0qsVrvOsJJORKnFHp00xSYYYDbqW00RrGuIIBwVWZGNVMNpO/3RAvFDhjkhQJTppIkWJT7v8TMkuYJFJBcGWKQpOp0OTpvQaoqgR8EZQqKWOO0CfMEIGsItHy3g8TGllSgbKJsiaEYgFEUgFJH9vYmyEQMs0pzTHTacKHnNimykEmc6bDie0soAiyjTeXxB6HTK7LdMHDbMVSwiWTDAIs1xnCbVQdrEyxUBUgvpXmztnvX4QnBwQiBlotEoHn74YUyaNAlTpkzBzz//rHSTiADE04ELrQIMep3s7+06w/5lIkotBlikOU67cMYVLO5pIbWQCq60tME8GhNxNMBjBVJpxYoVAIC33noLM2bMwJNPPqlwi4jiPL6QYvuDG8+QZKELIjkwwCLNkfZgiaJ4ymNS51FoM8ndLKIWOU+zglUbCCEmcsU1la666irMmzcPAHDgwAG4XC6FW0QU5/EHFUsHzsYUwXV7vPjVm+sRjLS8/5UonRhgkeY47WYEIzEEQqd+aXr8IeRajDAbDQq0jOhUiYFNCytYiT2DXHFNKaPRiFmzZmHevHkYMWKE0s0hAhDvn5TaHyy9rztLSrWLooj/+49t+HDjAfz1+/1KN4eykDHZX7zhhhuQm5sLACgpKWEaBsmm6YqAzdz8Fo53YFwNIPWwm40QDPoW9z5IewZdvGdT7umnn8YDDzyACRMm4KOPPoLValW6SZTlPD7lCtrkCAbYBEPWrGB9vdONjXtrYTHpsXDVLowfUKrI3jfKXkkFWMFgfAZkyZIlKW0MUVtIHZTbH0RXZ/NBk8cX5GoAqYpOp2v1sGFpVcvBPVgp88EHH6CmpgZ33nkncnJyoNPpYDBwRZuUFY7GcKw+rGiFW6fdnDV7sF74YifOyrPg4evOwX1vbcDHmw9iVN+zlW4WZZGkUgS3b9+O+vp6TJs2DVOnTsWGDRtS3S6iVkkdlLeFAauXK1ikQq0VZuGxAql3zTXXYOvWrZgyZQqmT5+O2bNnw2zm9SVlHZXOwFJwMsVpF7KiiuC/d3vx791e/MeQCozqezYqXDYsWFHV4r5tonRJagXLYrFg+vTpGD9+PKqrq3HHHXdg+fLlMBqTzjgkarNE2esWcsndvhAu7Fogd5OITstha3nmWEoRLLSyKEuqWK1WPP/880o3g6gZNaQDO21m7K+tV+z95fLiip1w2gRMvrgrDHod7hpaiYfe24QvdxzBsF7FSjePskRSK1jl5eUYPXo0dDodysvLUVBQgCNHjqS6bUQtcrZynkfsRMlrrgaQ2rhsLc8ce/1BFFpNMBpYb4gok0kTgkqmsLvsQsanCG7cW4tVO47gF4MrkCPEU4NvuLALOudbsGBllcKto2ySVK++bNkyPPXUUwCAmpoa+Hw+FBUVpbRhRK2xCkbkmE7drHusPoxoTGTJa1Kd1g7Hjh8yzPuVKNNJ6cBKft6lVOVYLHNT5V5csRP5OSbcfGnXxM8Eox6/GFyBf+/2Yt0er4Kto2ySVIA1btw4HD9+HJMnT8bMmTMxf/58pgeSrFra0+JJlLzmgJXUxWk3oz4cRSAUafZzjz/EoixEWSCRIqjkHiybGZGYiLqGsGJtSKfth+rw2dYa3H55GXItzdOuJ19cikKrCQtWcBWL5JFUVCQIAv7whz+kui1EbSYdNtyUlPrAFEFSm6ZHC1gdjV+7Hl8QPTvlKtUsIpKJ1x+EQa9DnkW5/ZaJCry+EAqsmTcR+dKKKtgEA24bVHbKY1bBiNsGleO5f+7A9kN1OOesPPkbSFmFif+kSU67mStYpBmt7Rv0+pU7F4eI5COlA+sVPIvJdWK1PBP3YVUd8eEfmw7glsvKWg0ebx3UDTbBgJe5F4tkwACLNMnZwp6WRIDFPS2kMtK+C2+TypeRaAxHA8qei0NE8nD7lD9CpLWJnkzw8soqmI16/GJweavPKbAKuOmSrvhw4wH87AnI2DrKRgywSJMcdgEef7DZuRbSrFwhAyxSGWnm2N1kUsAb4IorUbbw+oOKf9alyZxMW8Ha6w3gr+v3Y/LFXRPfta35xeAKGPV6LFzFVSxKLwZYpEkumxnhqIjjwcaiAV5/CAVWE0wseU0qIw2smqa18pBhouzh8St/hEih1QSdrvlETyZ45csqGHQ6/MeQijM+t1OeBTde1AXvrtuHw8cbZGgdZSuOREmTHE2KBkhY8prUyioYYTHpm80cS/cu71mizOfxKb/f0mjQo9AqJM7kygQ1dQ14d+0+3HhRCTrn57Tpd+4cUolINIZXv96d5tZRNmOARZrUuCLQZMDqD8LF1QBSKafN3Gzvg/RnJcs2E1H6NYSj8AUjiu/BAlrev6xli1btQlQUcffQyjb/TpnLhuv6dMbSf/2MY/WZWbKelMcAizRJSrVwcwWLNMJpF05acY1PDvCeJcpsiXRgFZx5d/L3kJZ5fEEsXbPkDUF2AAAahklEQVQHY/qdja5Oa7t+9+5hlfAFI1iyujotbSNigEWa1NqeFqVTMIha47QJp9yveh0y8jwaImokBTSqWMGym+HOkBTBV7/ejWAkhl8O697u3z3v7HwM61WE176pRn0omobWUbZjgEWa1LgHK95RRGMivAHly+AStcZhMzfbg+X2hVBoFWBQ8FwcIko/ac+TGiYAXRmSIngsEMZfVu/BdX06o3uxPanX+OWw7vD6Q3j7u59T3DoiBlikURaTAXazMbGPpTYQgiiqIwWDqCUuuwCPP5Q4WkANZZuJKP0aV7CU75+cdjOO1YcRisSUbkqH/Pe31fAFI7gnidUrycXlDgzoVojFX+1GOKrt60HqwwCLNMvRZCZOCrS4n4XUymETEIzE4D+RjsI9g0TZQUoNdqhgQkWa1Dka0O4qli8YwZ++3Y2rehfj3LPzOvRavxxeif219fj7hgMpah1RHAMs0iynvbHcrNunnhQMopZIq6tSmqDHH+KKK1EWcPuDEAx65JqNSjelSYEo7e7DWvqvPagNhHHP8ORXryTDexXjnLNy8fKXVYjFxBS0jiiOARZpltNmTqxgeRMlrzlgJXWSgn9ptdXjC8LFFSyijCedgaXTKb/fUjoWQqv7sBrCUSz+ahcG93Dhwq6FHX49nU6Hu4dVYudhHz7bVpOCFhLFMcAizXLahCaDVaYIkro5mxyOHYrEUNcQgUMFezKIKL28fvWkAydW0jVaSfCtf/8Mty+Ee1OweiUZ2aczujqsWLCyKrFHlqijGGCRZjntAo76Q4jFRHj8Ieh0QCFLXpNKSQMbrz+Y2P/AlFaizOfxBVWTDuzU8ApWKBLDwlW7MLCsEJdUOFP2ukaDHncOrcDGvbVYXeVJ2etSdmOARZrlsAmIxETUNYTh8QVZ8ppUTVrBcvtCjXsGVTKrTUTp4/aFVJMOnGs2QjDo4dZggPX+9/tw8FgD7r2iR8pf+8b+JSjKNWPByqqUvzZlJwZYpFmuRKpDKH7IsEo6MKKWWEwG2AQDvCfuV4DHChBlAzWlCOp0uniBKI0VuYhEY1iwsgp9S/IxpIcr5a9vMRnwi/9Vjq93urFpX23KX5+yDwMs0ixHkz0tLHlNWuA4MbDhnkGi7BAIRVAfjqpqMsVpb9y/rBUfbjqAn70B3Du8e9qKhdx0SVfkWYxYsIKrWNRxDLBIs6Rccq8/CI8/yAqCpHpOmxkefygxuHFxDxZRRkscMqyiz3q8Aq92VrBiMREvfrET55yVi6t6d0rb++RaTJh6WRk+2XoIOw/70vY+lB0YYJFmNZ7nER+wcjWA1M554nBsjy8Ig16HPItJ6SZlnHA4jAcffBA33XQTxo0bh88//1zpJlEWkyZT1JTC7rQLmtqDtXzLIVQd8eOXw7tDn+Z91rdfXgazUY9XvuQqFnUMAyzSLCmgOlzXgNpAWFUzhEQtkQ7HlvZkpHuwkI3+/ve/o6CgAG+88QYWL16MefPmKd0kymLSSpGaUgRddjM8/qAmSpKLYnz1qtxlw8g+ndP+fk67GZMGdsUH6/djf2192t+PMhcDLNIswahHnsWInUfiS/lq6sCIWuK0m+H1x6sIqmlGO5Nce+21uO+++xJ/NxgMaX/PYCTKARm1KJEiqKLPu9MmoCEcQyAUVbopZ7Tix8PYerAOvxxWKVuV4DuGVAAAFq/aJcv7UWYyKt0Aoo5w2s3YUXMiwFJRB0bUEqdNQDgqotoTQKc8Tgikg81mAwD4fD7MmDED999/f9rfc9/Revzm3Y2IiSL+V3cXJg4sxdXndoLZmP7gjtQtkSKoogyLxGHDvhBsZvUOA0VRxB8/34kuBTm44cIusr1vl4IcjOnXBW999zN+dUV3Tt5SUriCRZrmtAmodvsTfyZSM2mQVe32J/YQUuodPHgQU6dOxZgxY3D99den/f0qi+xY+cAwzLiiB3Yd8ePeN9bjkvmfY87ft2Drgbq0vz+pl8cXRI7JAKugnkBG+h5y+9Vd6OLbKg827K3F3cMqYTLIO1y9e1gFgpEY/vvbalnfVymRaAz/3u3FM5/8iEWrqnD4eIPSTdI89XziiZIgHTYMqGuGkKgljhNBVSQmsihLmrjdbkybNg2PPfYYLrvsMtnet9Rhxcyre2LGlT3wbZUbb3+3F2+s+Rn//W01+nTJx4QBJRjdrwvyc7RX2EQURWzYW4sP1u+HRTBgZJ/O6NMlP23lsjOJms7AkrhsjStYavbCFz+hONeMcReVyP7e3Ytzcc25nfDnb6vxH0MqkJuBBYkOH2/Alz8ewcodR7BqxxEcb4jAoNchGhPx9PIfccU5xZgwoBTDexXBKHOAmwkYYJGmNV2654oAqV3TVVaWaE+PV155BXV1dViwYAEWLFgAAFi8eDEsFoss72/Q6zC4RxEG9yhCbSCED9bvx9tr9+HRv23BEx9tw7Xnn4WJA0pxaYVT9UVOPL4g/rp+P95Zuxc7anywmPSIREUs/HIXujqsGNm3M0b26Yzzzs5jsNUKtz+kus+6NBmp5lLta6u9+NcuLx4Z2RsWkzKptr8c1h2fbKnBG2t+xp1DKxVpQypFYyI27qvFyu2HseLHI/hh/zEAQHGuGf/7/LMwvFcxLu/hwuG6IN5duxfvfb8fn22tQVGuGWP7d8GEAaWoLLIr/K/QDgZYpGnSgNWg12lyZpiyS9NVVgcnBNLikUcewSOPPKJ0MwAABVYBt11ejtsuL8fm/cfwztq9+GD9fvxtwwGUOnIw/qJS3HhRCboU5Cjd1IRINIZVPx3BO9/twz+31SASE9GvtADz/08fXH9BZ0RjIj7dUoN//HAQi1btwssrq1DmlIKts9G7cy6DrSY8viA65ckT3LeVtKKm5sOGX1yxEw6bgJsu6apYGy4oLcDl3Z34r69349ZBZYoFeh1x1B/Cqp+OYMX2w/hyxxEcDYSh1wH9uxbiwRG9MKxXEc7t3HyCJM9iwsPX9cYDI3phxfbDeGftPvzXV7ux8MtdGNCtEBMGlmJkn86q3r+nBrw6pGnSgLXQypLXpH5NU4WY0ppdzu+Sj/O75GP2db3xyZZDeGftXjz72Q48988dGNyjCBMGlChaGKPa7cc7a/five/3oaYuXuXytkFlmDCwFD075TZ77oSBpZgwsBRefwifbjmEj344iFe+3IWXVlShosiGUX06Y2Tfs9Gzkz3rgy2vP4TenfOUbkYzFpMBuRYjnv/8JyxM0XlPeTkmlLts6Oa0osxpQ7nLhjKXDaWFVgjG9qWX/bDvGFb+eAQPjuil+N61Xw7rjin/tQbvfb8PUy7ppmhb2iIWE7H1YB1WbD+MFT8exoa9tYiJ8cno4b2KMeycYgzp4UKB9cz9j8mgxzXnnYVrzjsLh+sa8P76/Xjnu714aNkmzP37FozqezYmDCxB/66FWf85bwkDLNI0acDKAhekBWajAblmI44HI7xns5TFZMCYfl0wpl8X7PUG8O66fVi2di/ufWM9Cqwm3NCvC8YPKEHvs/LSPmkUCEXw8Q+H8Pbavfj3bi/0OmBYr2LMHV2CK87pdMaBscMmYNLFXTHp4q7w+IL4ZEsN/rHpAF5csRN//GInuhfbMbJPZ4zq2xk9TgrSsoEoivD4QqqcTJk7+jxs2ncsZa/n9YdQ7fHjbxsO4HhDJPFzg16HLgU5KHPZUO60ouxE4FXutKGkMKfFvT0vrvgJeRYjpl6mfEAzqNKJC0rysfDLXZg4oFSVe5FqAyF8s9ODFT8exsofj8DtC0KnA/qWFGDGlT0wvFcx+nTJ79D3SXGeBXcNrcSdQyqwbs9RvP3dXny46QDeXrsXlUU2TBhQirH9S1CUy8wMCQMs0jTXiT1YauzAiFritAvxAIulf7NeqcOKX1/dE/dd2QPf7HTjnbWNhTHMRj3KnDaUuawn/mtLrAx0yjMnPWMsFax4Z+0+fLjxAHzBCMqcVjw4ohfGXVSSdDqb027GTZd0xU2XdMWR40Es33IIH206gD9+8ROe//wn9Oxkx8g+Z2Nk387oXpwd+ziOByMIRWOJohJqMrZ/Ccb2T33xCFEUE8FWtTuAao8fu91+VHv8+H7PUfiCjcGXUa9DqcPabNXLbjbiky01mHFFd1UUltDpdLh7WHfc9fo6fPTDQYzpJ1+5+KZ8wQiq3SeupduP3Z74f6s9AXhPpHrm55gwpGcRhvcqwpCeRYnxUSrpdDoMKHNgQJkDj48+Dx9tOoB31u7Dkx9vx+8/iRfGmDigFMNYGKNjAZbH48HYsWPx2muvobJS+xsASXukwIqDVdIKp92Mak+AkwKUYNDrMKRnfFB01B/Cp1sPYedhH3a7A6g64seK7UcQisYSz88xGdDNaU2kYZVLAZjLiiJ7y8HXyQUrckwGXNenMyYMKMHF5Y6UpvgU5Zpxy6XdcMul3XC4rgEfbz6EjzYdxP/7PJ4Sec5ZuRjVt3PGpxZJpa7VVkUwnXQ6HZx2M5x2My7q5mj2mCiKcPtCjUHXicBrtzuANbu8qA/HDz62CQbcfnm5Es1v0TXndkL3YjteXlmFcpcNVsEIu9kIq9kAm2BM2QHIgVCkeVDa5Pq4TypIclaeBWUuK0ac1wllThsGlBXigpICWYMau9mIiQO7YuLArth5+DjeXbsP732/L1EY48b+JRjcwwW9Cj/jRbnmtE/0JB1ghcNhPPbYY7JVZiJqCVMESWscNgEmgw653CBMLSi0CZg4sPnG/mhMxIHa+hOrAvEBV7XHjx8PHcdnW2sSR1UA8cFpt8QeGCs65+fgm51u/HNbDcLReMGKJ8f2wai+nWVZISjOs+DWQWW4dVAZDh1rwMebD+KjTQfxzKc70v7eatGlUD1FTJSk0+lQlGtGUa4ZA8tODb4OHw9it9uPAqsJhSrq0/V6HX51RXfc99YGjH7xm1Met5j0sAlG2MxGWAUDbOb4n22C4UQwZoD1xN/jPzfCbNLjQG1Ds9Wow8ebB1HFuWaUuWy48pzi+ESKy4puzvhKdo6groIb3YtzTyqMsReLv9qFV1K0xy/VDHodfphzTVr3+CX9yk8//TQmTZqERYsWpbI9RO3isApw2ARUZknKCWlf92I79noDGT1zT6llOJFKVeqwYnCPomaPRaIx7K+tR7Un0JhC5PFjy4FjWL7lEKIxMVGwYvyAUwtWyOmsfAtuv7wct19ejoPH6lHtDijWFrlYBQP6luQr3QzV0+l06JRnUV3FRcmYfl1Q4bKjpq4B/lAEgVAU/mAE/mAUgVAEvmCTn4UiqKsP49CxeviD0fjzg9Fmq9ASl92MMqcVQ3oWxSdFmqQFa7FKX7PCGMcbUHXYr3STWlSUa057AZWkXv3999+Hw+HA4MGDGWCRoowGPb58cJjilYaI2mrmVT1x7/DuSjeDMoTRoEc3pw3dnDYM7dk8+ApHYzh0rAGd8iztruSWbp3zc9A5nys7pB19SvLRB8kHy6FIDIFQBP5QFPWhKDrlmVWxzyxdinMtKM5VZ8Ash6RGpe+99x50Oh1Wr16Nbdu2YdasWXj55ZdRVFR05l8mSrFM/oKizCMY9aob7FJmMhn0KHVYlW4GEUH67hdQwI9kVkgqwFq6dGniz7fccgvmzJnD4IqIiIiIiLIep1GJiIiIiIhSpMMbV5YsWZKKdhAREREREWkeV7CIiIiIiIhShAEWERERERFRijDAIiIiIiIiShEGWERERERERCnCAIuIiIiIiChFGGARERERERGlSIfLtLfF/v37MXbsWDneioiIMsz+/fvT+trsn4iIKBmt9U86URRFmdtCRERERESUkZgiSERERERElCIMsIiIiIiIiFKEARYREREREVGKMMAiIiIiIiJKEQZYREREREREKSJLmfb2isVimDNnDn788UcIgoAnnngC3bp1Szz+xRdf4KWXXoLRaMSNN96ICRMmKNjaU4XDYcyePRv79+9HKBTC3XffjSuvvDLx+J/+9CcsW7YMDocDADB37lxUVFQo1dwW3XDDDcjNzQUAlJSU4Mknn0w8pvbr//777+Ovf/0rACAYDGLbtm345ptvkJeXB0Dd13/jxo145plnsGTJEuzZswe//e1vodPp0KNHDzz++OPQ6xvnRM70OVGy7du2bcO8efNgMBggCAKefvppuFyuZs8/3T2mhKbt37JlC+666y6UlZUBACZPnozrrrsu8Vy1XXugeftnzpwJt9sNIF5C9oILLsBzzz3X7Plqu/5awf5Jeeyf5Kflvglg/6Sm6581/ZOoQp988ok4a9YsURRFcf369eJdd92VeCwUColXXXWVWFtbKwaDQXHs2LHi4cOHlWpqi5YtWyY+8cQToiiKotfrFYcOHdrs8d/85jfiDz/8oEDL2qahoUEcM2ZMi49p4fo3NWfOHPGtt95q9jO1Xv9FixaJo0aNEsePHy+Koijeeeed4r/+9S9RFEXx0UcfFT/99NNmzz/d50RuJ7d9ypQp4tatW0VRFMU333xTnD9/frPnn+4eU8LJ7X/nnXfEV199tdXnq+nai+Kp7ZfU1taKo0ePFmtqapr9XG3XX0vYPymL/ZP8tNw3iSL7J7Vdf0mm90+qTBFct24dBg8eDADo168fNm/enHisqqoKXbt2RX5+PgRBwEUXXYS1a9cq1dQWXXvttbjvvvsSfzcYDM0e37JlCxYtWoTJkydj4cKFcjfvjLZv3476+npMmzYNU6dOxYYNGxKPaeH6S3744Qfs3LkTEydObPZztV7/rl274oUXXkj8fcuWLbj44osBAEOGDMG3337b7Pmn+5zI7eS2P/vss+jduzcAIBqNwmw2N3v+6e4xJZzc/s2bN2PlypWYMmUKZs+eDZ/P1+z5arr2wKntl7zwwgu4+eabUVxc3Oznarv+WsL+SVnsn+Sn5b4JYP+ktusvyfT+SZUBls/ng91uT/zdYDAgEokkHpOWDQHAZrOdcnMpzWazwW63w+fzYcaMGbj//vubPT5y5EjMmTMHf/7zn7Fu3TqsWLFCoZa2zGKxYPr06Xj11Vcxd+5cPPDAA5q6/pKFCxfinnvuOeXnar3+I0aMgNHYmLUriiJ0Oh2A+HU+fvx4s+ef7nMit5PbLn1hfv/993j99ddx2223NXv+6e4xJZzc/r59++Khhx7C0qVLUVpaipdeeqnZ89V07YFT2w8AHo8Hq1evxtixY095vtquv5awf1IW+yf5ablvAtg/qe36A9nRP6kywLLb7fD7/Ym/x2KxxP+ckx/z+/3NvlDV4uDBg5g6dSrGjBmD66+/PvFzURRx6623wuFwQBAEDB06FFu3blWwpacqLy/H6NGjodPpUF5ejoKCAhw5cgSAdq5/XV0ddu3ahUsvvbTZz7Vw/SVNc9r9fn8iR19yus+JGvzP//wPHn/8cSxatCixn0ByuntMDa6++mqcf/75iT+ffI+o/doDwPLlyzFq1KhTVigA9V9/NWP/pCz2T8rTet8EsH9SWjb0T6oMsPr3749Vq1YBADZs2ICePXsmHqusrMSePXtQW1uLUCiEtWvX4sILL1SqqS1yu92YNm0aHnzwQYwbN67ZYz6fD6NGjYLf74coilizZk3ig6IWy5Ytw1NPPQUAqKmpgc/nQ1FREQBtXH8A+O677zBo0KBTfq6F6y8599xzsWbNGgDAqlWrMGDAgGaPn+5zorS//e1veP3117FkyRKUlpae8vjp7jE1mD59OjZt2gQAWL16Nc4777xmj6v52ktWr16NIUOGtPiY2q+/mrF/Uhb7J+VpuW8C2D+pQTb0T+oKaU+4+uqr8c0332DSpEkQRRHz58/Hhx9+iEAggIkTJ+K3v/0tpk+fDlEUceONN6JTp05KN7mZV155BXV1dViwYAEWLFgAABg/fjzq6+sxceJEzJw5E1OnToUgCLjsssswdOhQhVvc3Lhx4/Dwww9j8uTJ0Ol0mD9/Pj7++GPNXH8A2L17N0pKShJ/b3r/qP36S2bNmoVHH30Uzz77LCoqKjBixAgAwEMPPYT777+/xc+JGkSjUfzud79D586d8atf/QoAMHDgQMyYMSPR9pbuMTXNsM2ZMwfz5s2DyWSCy+XCvHnzAKj/2je1e/fuUwYPWrn+asb+SVnsn5Sn1b4JYP+kFtnQP+lEURSVbgQREREREVEmUGWKIBERERERkRYxwCIiIiIiIkoRBlhEREREREQpwgCLiIiIiIgoRRhgERERERERpQgDLCKVu+WWW1BVVaV0M4iIiJph/0TUMgZYREREREREKaK9k7uIVCwcDuPxxx/Hnj17EIvFcP/992Pu3LkYMGAAfvrpJ+Tn5+PZZ5+FyWTC7NmzsXfvXkSjUdx+++247rrrsHHjRvzud7+DKIro1KkTnnnmGQDASy+9BLfbjfr6ejz77LMtnj5PRETUGvZPRPJhgEWUQu+++y4KCwsxf/58HD16FDfffDMaGhpw/fXXY+DAgfj973+Pt99+GyaTCYWFhfjP//xP+Hw+jB07FpdeeikeffRRPPfcc6isrMTSpUsTqRdDhw7FmDFj8MILL2D58uW44447FP6XEhGRlrB/IpIPAyyiFNqxYwfWrVuHTZs2AQAikQiMRiMGDhwIAOjfvz9WrVoFg8GAQYMGAQDsdjsqKyuxd+9eeDweVFZWAgCmTJmSeN3zzz8fAOByueB2u+X8JxERUQZg/0QkH+7BIkqhiooKjBw5EkuWLMHixYtx7bXXIhQKYfv27QCAdevWoXv37qisrMTatWsBAD6fDzt27EBJSQmKi4tRXV0NAFi0aBE+++wzpf4pRESUQdg/EcmHK1hEKTRp0iQ88sgjuPnmm+Hz+XDTTTdBr9dj8eLFOHDgAM4++2zMnDkTAPDoo49i8uTJCAaDuPfee+F0OjF37lzMnj0ber0eRUVFuO222/CXv/xF4X8VERFpHfsnIvnoRFEUlW4EUSa74oor8PHHH8NsNivdFCIiogT2T0TpwRRBIiIiIiKiFOEKFhERERERUYpwBYuIiIiIiChFGGARERERERGlCAMsIiIiIiKiFGGARURERERElCIMsIiIiIiIiFKEARYREREREVGK/H/gB9aSRNR2pgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy\n",
      "\taccuracy         \t (min:    1.000, max:    1.000, cur:    1.000)\n",
      "log loss\n",
      "\tlog loss         \t (min:    0.313, max:    0.313, cur:    0.313)\n"
     ]
    }
   ],
   "source": [
    "liveloss = PlotLosses()\n",
    "for epoch in range(num_epochs):\n",
    "    print(epoch)\n",
    "    logs = {}\n",
    "    running_loss = 0.0\n",
    "    running_corrects = 0    \n",
    "    for i, (features, label) in enumerate(dataloader):\n",
    "        \n",
    "        features = Variable(features.float())         \n",
    "        label = Variable(label.long())\n",
    "\n",
    "        # Intialize the hidden weight to all zeros\n",
    "        optimizer.zero_grad()  \n",
    "        \n",
    "        # Forward pass: compute the output class given a image\n",
    "        outputs = net(features)\n",
    "        \n",
    "        # Compute the loss: difference between the output class and the pre-given label\n",
    "        loss = criterion(outputs, label)\n",
    "        # Backward pass: compute the weight\n",
    "        loss.backward()\n",
    "        # Optimizer: update the weights of hidden nodes\n",
    "        optimizer.step()\n",
    "        \n",
    "        _, preds = torch.max(outputs, 1)\n",
    "        running_loss += loss.detach() * features.size(0)\n",
    "        running_corrects += torch.sum(preds == label.data)\n",
    "\n",
    "        epoch_loss = running_loss / len(dataset)\n",
    "        epoch_acc = running_corrects.float() / len(dataloader.dataset)        \n",
    "        logs['log loss'] = loss.item()\n",
    "        logs['accuracy'] = epoch_acc.item()\n",
    "\n",
    "    liveloss.update(logs)\n",
    "    liveloss.draw()        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain predictions from our trained model, we pass it feature data and convert the prediction to a Numpy array. We get softmax probabilities for each of the two classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.462269Z",
     "start_time": "2020-06-21T18:00:51.454153Z"
    }
   },
   "outputs": [],
   "source": [
    "test_value = Variable(torch.from_numpy(X)).float()\n",
    "prediction = net(test_value).data.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.471201Z",
     "start_time": "2020-06-21T18:00:51.463455Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50000, 2)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From here on, we can proceed as before to compute loss metrics or visualize the result that again reproduces a version of the decision boundary we found above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Score Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.491042Z",
     "start_time": "2020-06-21T18:00:51.472557Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_true=y, y_pred=np.argmax(prediction, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Decision Boundary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Feature Space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.497946Z",
     "start_time": "2020-06-21T18:00:51.494342Z"
    }
   },
   "outputs": [],
   "source": [
    "n_vals = 200\n",
    "x1 = np.linspace(-1.5, 1.5, num=n_vals)\n",
    "x2 = np.linspace(-1.5, 1.5, num=n_vals)\n",
    "xx, yy = np.meshgrid(x1, x2)  # create the grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.507199Z",
     "start_time": "2020-06-21T18:00:51.498889Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([40000, 2])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test = np.array([xx.ravel(), yy.ravel()]).T\n",
    "X_test = torch.from_numpy(X_test)\n",
    "X_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict Feature Space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.527177Z",
     "start_time": "2020-06-21T18:00:51.508480Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40000, 2)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zz = net(Variable(X_test).float()).data.numpy()\n",
    "zz.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:51.535341Z",
     "start_time": "2020-06-21T18:00:51.530732Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a color map to show the classification colors of each grid point\n",
    "cmap = ListedColormap([sns.xkcd_rgb[\"pale red\"],\n",
    "                       sns.xkcd_rgb[\"denim blue\"]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Decision Boundary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-21T18:00:52.162115Z",
     "start_time": "2020-06-21T18:00:51.537879Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the classification plane with decision boundary and input samples\n",
    "plt.contourf(xx, yy, np.argmax(zz, axis=1).reshape(n_vals, -1), cmap=cmap, alpha=.25)\n",
    "\n",
    "# Plot both classes on the x1, x2 plane\n",
    "data = pd.DataFrame(X, columns=['$x_1$', '$x_2$']).assign(Class=pd.Series(y).map({0:'negative', 1:'positive'}))\n",
    "sns.scatterplot(x='$x_1$', y='$x_2$', hue='Class', data=data, style=y, markers=['_', '+'], legend=False)\n",
    "plt.title('Decision Boundary');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ml4t-dl]",
   "language": "python",
   "name": "conda-env-ml4t-dl-py"
  },
  "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.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}