03_02_ConvLSTM_SeqToOne_Adam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "from torch.utils import data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import moving MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 10000, 64, 64)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Moving_MNIST = np.load('data/mnist_test_seq.npy')\n",
    "Moving_MNIST = Moving_MNIST / 255\n",
    "Moving_MNIST.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Give `torch` the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10000, 20, 1, 64, 64])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Making into PyTorch tensor\n",
    "Moving_MNIST_tensor = torch.from_numpy(Moving_MNIST)\n",
    "\n",
    "# Putting the existing dimensions into appropriate order\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.permute(1, 0, 2, 3)\n",
    "\n",
    "# Added the acknowledge that this is 1 spectral band\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.unsqueeze(2)\n",
    "\n",
    "# Checking shape\n",
    "Moving_MNIST_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train/validation split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_indices = np.random.choice(range(10000), size = 8000, replace = False)\n",
    "\n",
    "OutofSample_indices = [index for index in range(10000) if index not in train_indices.tolist()]\n",
    "validation_indices = np.random.choice(OutofSample_indices, size = 1000, replace = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separating $x$ (first $10$ in each sequence) and $y$ (last $10$ in each sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sep_x_y(tensor_to_separate):\n",
    "    x = []\n",
    "    y = []\n",
    "    for i in range(len(tensor_to_separate)):\n",
    "        current_seq = tensor_to_separate[i, :, :, :, :]\n",
    "        for j in range(current_seq.shape[0]):\n",
    "            if j >= 10:\n",
    "                current_x = current_seq[(j-10):j].numpy()\n",
    "                x.append(current_x)\n",
    "                current_y = current_seq[j].unsqueeze(dim = 0).numpy()\n",
    "                y.append(current_y)\n",
    "    x = np.asarray(x)\n",
    "    x = torch.from_numpy(x).type(torch.FloatTensor)\n",
    "    y = np.asarray(y)\n",
    "    y = torch.from_numpy(y).type(torch.FloatTensor)\n",
    "    return(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = sep_x_y(Moving_MNIST_tensor[train_indices])\n",
    "x_validation, y_validation = sep_x_y(Moving_MNIST_tensor[validation_indices])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing the overlaid $(x, y)$ sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHVZJREFUeJztnWtwXdV1x/9LV++HLcsP2dgEQzAQh4cBASbQjIE4cUgaMm3KhKQNydC6M6FtMk0ngXamTTrNTPIlj5m2tG6BuDM0kBBSKENJiANNQ4LBgAPGjsEYY1vYFrYkW2/5Sqsf7vHZa2/rStfWfUjs/29Go3Xu3uecpXu17llr77XXFlUFISQuqiqtACGk/NDwCYkQGj4hEULDJyRCaPiERAgNn5AIoeETEiHTMnwRWSciO0Vkl4jcUSylCCGlRU43gUdEMgBeBbAWwH4AzwG4RVW3F089QkgpqJ7GuVcC2KWquwFARO4HcBOAvIbf1Niora2t07glIWQyenp7MTg4KFP1m47hLwWwzxzvB3DVZCe0trbi9j/942nckhAyGf/4L/9WkAtf8sE9EVkvIltEZMvA4GCpb0cIKYDpGH4ngDPN8bLkNQ9V3aCqHara0dTYOI3bEUKKxXQM/zkAK0TkbBGpBfBJAI8URy1CSCk57RhfVbMi8mcAfgIgA+AeVX2laJoRQkrGdAb3oKqPAXisSLoQQsoEM/cIiRAaPiERQsMnJEJo+IRECA2fkAih4RMSITR8QiKEhk9IhNDwCYkQGj4hEULDJyRCaPiERAgNn5AIoeETEiE0fEIihIZPSITQ8AmJEBo+IRFCwyckQmj4hEQIDZ+QCKHhExIhNHxCIoSGT0iE0PAJiZApDV9E7hGRLhHZZl5rE5EnROS15Pe80qpJCCkmhTzxvwdgXfDaHQA2qeoKAJuSY0LILGFKw1fVXwDoDl6+CcDGRN4I4ONF1osQUkJON8ZvV9UDiXwQQHuR9CGElIFpD+6pqgLQfO0isl5EtojIloHBwenejhBSBE7X8A+JyBIASH535euoqhtUtUNVO5oaG0/zdoSQYnK6hv8IgFsT+VYADxdHHUJIOShkOu/7AH4N4HwR2S8itwH4BoC1IvIagA8kx4SQWUL1VB1U9ZY8TTcUWRdCSJlg5h4hEULDJyRCaPiERAgNn5AIoeETEiE0fEIihIZPSITQ8AmJEBo+IRFCwyckQmj4hEQIDZ+QCKHhExIhNHxCIoSGT0iE0PAJiRAaPiERQsMnJEJo+IRECA2fkAih4RMSITR8QiKEhk9IhNDwCYkQGj4hEVLIFlpnisiTIrJdRF4RkS8kr7eJyBMi8lrye17p1SWEFINCnvhZAF9S1ZUAVgO4XURWArgDwCZVXQFgU3JMCJkFFLJ33gEABxK5T0R2AFgK4CYAa5JuGwE8BeArJdGSlBVVdQfdB1Nx2/ce9PrtHRlL5ZWNtV7b2V/8fGmUI0XhlGJ8EVkO4FIAmwG0J18KAHAQQHtRNSOElIyCDV9EmgH8CMAXVfWYbdPcI0LznLdeRLaIyJaBwcFpKUsIKQ4FGb6I1CBn9Pep6kPJy4dEZEnSvgRA10TnquoGVe1Q1Y6mxsZi6EwImSZTxvgiIgDuBrBDVb9lmh4BcCuAbyS/Hy6JhqTk6LDviekzm1L58V+9nvc8MfJZq1cUWy1SQqY0fADXAPgjAC+LyNbktb9GzuB/ICK3AXgTwM2lUZEQUmwKGdX/Jfwvd8sNxVWHEFIOCnnik3cA4137vOOhx36aynu7h7y23cPZVLbf+BcEU3bLr1/l+l14VRG0JOWCKbuERAgNn5AIoav/DkPHnJs+8B8bU/mFrn6vX/+4S7uoqanx2pYuW5rKHXObU3n+le/2+h1act70lCUVg098QiKEhk9IhNDwCYkQxvizEO1xK+b05ee9tmc3u0y77uPjqVyV8b/jL2+fn8qXXeFn3WUucLG7nHORu17vUV+Rvr5T0JrMJPjEJyRCaPiERAhd/VmAjo15x6/e6wpi7DJZdgAwr6E+lT+77uJUbl+w0OvXcMONqZytb/HaDhw4kMrHuntSeZDLqt8x8IlPSITQ8AmJEBo+IRHCGH8WoHt3eMe7TZHL9vZFXtuSBW6aTvvdarodvd1ev7rX70vlFvixe99VV6TyQE3TaWhMZjp84hMSITR8QiKErv4MpabGuenN7zrHa7vq4kOpfLzaL46Rqc6k8stHB1L52DE/y+5I95FU7u3t9dqqf7k1lW+49vxUlivWeP2kriGv/mRmwyc+IRFCwyckQujqzyBE3PfwihVu4Uxzsz+yfu7KC1O5v7fHa2s58lYqH523OJV7evx+B1/cnMojL/qzBvuOuFH+x3+xM5XXiV9zVa5ZN8FfQWYDfOITEiE0fEIihIZPSIQwxi8z1dXuLa+trfPaFixYkMotLa7IZVWV//1ctWBJKs+d52fujb3LjQ3UjQynck1ts9ev7jK3iq/qoqu9thXDbhoQd92bijs37/L6XdDhxgKkjvsiziamfOKLSL2IPCsivxGRV0Tka8nrZ4vIZhHZJSIPiEjtVNcihMwMCnH1RwBcr6qXAFgFYJ2IrAbwTQDfVtVzAfQAuK10ahJCikkhe+cpgBNF2WuSHwVwPYBPJa9vBPBVAHcVX8XZh2aPp7IEmXVz57amsnX7Ab8u3ripe19d7X8/j46OpnI26xfpyGZdYY4R4+pXB7Xzlyxx4UJvMCXYX+Wy/5a2ORf+qc5jXr/zn/+/VJb3fQhk9lDQ4J6IZJKdcrsAPAHgdQC9qnriv2w/gKX5zieEzCwKMnxVHVPVVQCWAbgSwAWF3kBE1ovIFhHZMsDSTYTMCE5pOk9VewE8CeBqAK0icsJXXQagM885G1S1Q1U7mho58kvITGDKGF9EFgI4rqq9ItIAYC1yA3tPAvgEgPsB3Arg4VIqOpPRIX9fOjWxb931H/faamrcW97U1By0uTh8aMh5R5mMXwzTntdtVtkBwFtvue9fOxbQ0OCvpLPjC/Pa2nz93fAC+k2Wrp+wC/S8/GYqt60e99qkiikiM5lC5vGXANgoIhnkPIQfqOqjIrIdwP0i8g8AXgRwdwn1JIQUkUJG9V8CcOkEr+9GLt4nhMwymLlXBLb9873e8cUf6kjlurr803mZTMZrq611rr51xa3bDwD9/X1GHvDabDagdfUPH/ZDArvQrr293WtraXGhxeFJXPbNZhXfh0eH/MZ61uqbyTAQIyRCaPiERAhd/dPEFs3YO+pnz73PjLrX1dV7bXYbqrFga6y5c+emco+pgzc6MhJcw7nV4QIeGyLY0f/wXlYPGxIAQFOzO6/tErdzLvY+C/LOgE98QiKEhk9IhNDwCYkQxvingJ1+a2py01U1wcq3ZhMj1waFMm0MXp3x3347xVZnpuWGh4a9fiMm5h8b87fJtvl1c+bMSeXGIF16eNi/Zj6k02y9FabuKcgshU98QiKEhk9IhNDVDxDjb6v6vuzSpctSua/PZc8tMi41AAy/tCeV5670M+aqFp6ZyrZoBgAMDjkXfmTYyar+AhibWTcYLHUeGnJTfVlTEKS+3l+kU1/vTzN6mJp7JjkPVVV+pmGNmilCCeMAMpPhE5+QCKHhExIhNHxCIiT6GD+MW+vr3TSaTY0F/NhaqlxMu/ZzN3n9fn3fY6nc+O17vLaO1eemcnb1Wq9t3MyXjY66GD+Tyf8xWX2Biab3JqbWzMWNHNjjtXX+91OpvGvYjRO0ZPw4fvWFbsyj1HX1xRtDkEnafOz4SDhmEzN84hMSITR8QiIkele/Lag3Z6fHwikvu1310LALAzJnnuf1u/YPndz5yC+8tp8+80YqX7jVDwNalrtQ4viZZ6Vy9rjvvo+PO/fVZhACQI3xerMvbUvlriP+Cr+jZkXhqwN+W32jm/qzTvRVZ83z+mXW/YHrF3jbdtWgdcVDt3wy9zvf1OrYmD+9SXf+1OETn5AIoeETEiFRuvrWhayu9kf1bY28MLPO0myKXOiov+AlaxbztLX4NfcWGrf9rRG/AMb+F99K5aGn3c60wyP+9a07Gy6+sVtlWae6ttbXwy44qgtmBhpN25oL3VZbb69a7fWD2R7Mhh9AWPjDuuzIS9gWXtP0zHuNyUb4S4Gv8+wJM/jEJyRCaPiERAgNn5AIiSbGt9NLNt4Na9vbfmHG3P59+1N58f7tqfzWM7u8fl3DLna/uL3Va3vvB34nlcdb5nttK1/dmsqju3an8kvb9nv9dg+4mD+ccrTFPZe3uunBVect9PotWOiOBwf82vxyw0dSudvca+zwYa+fmi26w9DaxtphQVCL3Q688PA8M3WXBH96L38Mbvud2oygnUo8lfMqS8FP/GSr7BdF5NHk+GwR2Swiu0TkARGpneoahJCZwam4+l8AsMMcfxPAt1X1XAA9AG4rpmKEkNJRkKsvIssAfATA1wH8peT8uOsBfCrpshHAVwHcVQIdi0JLiyuWMWKmx2x9fABYetzVs6/p7fbajv3vvlT+WY/L8Auz565e4Fz4pvMWeG2HDx9M5b43/RBh7LhbENO83BXsWLPiHK/fdcYntvX9AH9X3EVma6yx81d5/bK1bhpw6O23vbZeU9P/yBHn3mcy/ns12dSZn62X//niu9jBjrvmvPHxMdMv7+UmuL67ZpjxV6ge+frNZgp94n8HwJfhApr5AHpV9cSk9H4AS4usGyGkRExp+CLyUQBdqvr86dxARNaLyBYR2TIQlIkihFSGQlz9awB8TERuBFAPYA6A7wJoFZHq5Km/DEDnRCer6gYAGwBg6RlnvDP8JEJmOVMavqreCeBOABCRNQD+SlU/LSI/BPAJAPcDuBXAwyXUsyAmK5Rp43Cb5nrSdNgvXdz9ZGeP12YvedhMbXW+5X/n7alxExxt+/wVbXZ/vJoa/94DA1kjuzjbbp8NAEOmzn7YdtZZy1N5d6ebBrwi2CZ7+GpXBGRwyC84Ygt2Nja69y2Mfe00XRg/23Rb/3PJ3y/8zNQU87TXD/cB9M8JV+55R3le99tiYDoJPF9BbqBvF3Ix/93FUYkQUmpOKYFHVZ8C8FQi7wZwZfFVIoSUmlmduRdOE9ntqY4f91e+LVrkMtW8GvOvveD1+9Xb/anc2uC74u9pcuct+7svpXJm69Nev3Hjio4EW1x7/cYLc49teBD2C6cSxUxb6gWXpfJbh/wpu869bmoydLEbGlwoZGv4nayvdZ39lYzWHZ+sDqDtdzwoOMICG6WDufqERAgNn5AImXWuvnWBwyIUtiR12DZ/vsugq3tuUyo/+hPf1W8acgtWOv7ic15b3eLl7qDGvXWZa2/0+mXMCHE2GDG3C39CF9i6s1mzAGYo2I3X/p0jQYEN6zoPdLoswc5Of+bBbq8VuvD2PR4xxULC7bp8Vxx52/yQIBx1pwtfCfjEJyRCaPiERAgNn5AImRUxvo05bYwcFniYY7arbmvzi1z0v+Dq2z/00C9TuTXrT7e13Py7qbx/wM8QkzdccYyMubfNbgP8FXItLf7quaNHe82Rv7qtpsbG/y4WHhz0C2XkyyAEgN7eo6ls358wPu/v70c+7NiDHTMI43G7/djJWXf5V7iRysMnPiERQsMnJEJmhatvF9IcN8Uqwim7xYtd4QmbxQcAT3z9gVTe1e3c4bW/v8brJw3ONR8Y8N1hW5/PToENBDXrbD3+sFiFzeQLa903m91460xbOONlL9nT0+u1WZ3te2VlwHfhw9qChWfM2Xp5YVGO/AumSOXhE5+QCKHhExIhNHxCImSGxvh+vJivqOPixYu94/nz3ZbXe/a86bVt3nsglW9a9a5UrrnwKq+fnUYL99WzhS3HbAGJcT+GrTNb0YWxtR0nqAli/Lo89f5t+m54PDzspwQPDrpjf6vqsFBm/jje9hXRvP3scfgZ+ddAXgqP/yeriV9YP+LgE5+QCKHhExIhM8bV97dcyr9FknUh64PtnW2tuGPHjnlt1yxyW1ltftNN571/+3Nev/7F55rr+4U47DSdlW3NfmBy99X+beGUoz1veNiswAuKedhMPlt/L7yGX9jD18NO4YVuelWVOx4fL+zZcHJN/Im3xj45rCh02m+yGv6T6TXxFlqxTzHyiU9IhNDwCYmQGePq2yy2sPaadUttUYfRUb+unj+K7ft/577vPam89xm32Obh7z/h9RsZfjSVz5jjL755b5vTMWt0HGr3S2g3XnFFKlcHRTSqlyxPZa31d7C1Mwo2lOjr88MW+/6E4YLFL7ARLrAp7Dvf3004HNX3rljQ9ULyhSZhWyGvT4T/f2C39fKvEd77nQ6f+IRECA2fkAih4RMSITMmxvfjLz8+t8Ulq6tdzGynvABgwQJXUHPhQj9+bv3M7al8y2WbU3nbfY95/d4YcZl2R4OxhueP2akzE7vv8Vfxyd6nUrm+zp8SbG9004cNwdfuBWe4acGxi1emclX72V6/Wm/l3mRbOtuCl6e39fPpFtTIf7/8WZn+eEIY/9vsRcnbb3J98/+P2TGPGOL9ggxfRPYA6AMwBiCrqh0i0gbgAQDLAewBcLOq9uS7BiFk5nAqrv51qrpKVTuS4zsAbFLVFQA2JceEkFnAdFz9mwCsSeSNyO2p95XTvZifued/H/k7pTp3u6ury+tnz5s3r9VrmzvXHbe9/8Op3HjR1V6/y3sOuesN+wU2jpta9NVefXx/Ec3Is7925xzza909udNd/1CwwOaVF99I5dpXXB38S5v9KcG2z9ySylrnFyPJN00XLvTxt7jy2/zMvfy18yd3iSfeIffk7bTs555/oU++6+X62fP8v9+GCL53n79wSAwU+sRXAD8VkedFZH3yWruqnljydhBA+8SnEkJmGoU+8a9V1U4RWQTgCRH5rW1UVZUwIyIh+aJYD5y8+SMhpDIU9MRX1c7kdxeAHyO3PfYhEVkCAMnvrjznblDVDlXtaApq5BFCKsOUT3wRaQJQpap9ifxBAH8P4BEAtwL4RvL74WkpYlJPw+klG0valN3u7iNeP7uKrbfXXzG3aNGiVG5udkUtw5hY2lxxjzCGnWO2zbYr98Ktqo9ffm0q21r5ALDC7EXX3XXQa9v1Pw+m8tGnt6byzzv9yZIL/3VjKi/9/J/AZ+L998KpMnscttlU6EKzYycbJ7Cxeibjx9L+Hn5+W9jX6RTG+Bkj558uDIuRxEwhrn47gB8nb2A1gP9U1cdF5DkAPxCR2wC8CeDm0qlJCCkmUxq+qu4GcMkErx8BcEMplCKElJYZk7lna9NNNq1jXfPAu/QKVIQ18e1WU3bLqxZTyx4Aamrd1JkEUzy28MdkBUHq6+0WWv71m5rcOMfiZWd6bcNrf8/Jc10WYtVd3/f67elzf9uSSTPy7DZcfpZjJmPd7/yFT+znYs8B/KIiYTEMe151df5Vk/bzPCnsyrOyLlQ3Xz+g8JV8sW35xaCHkAih4RMSITR8QiJkxsT4durMpugCYRxo6tIH1W1sPBdew0432UKcYVFOW0vfrgQM9bDxbhib1pnC+nbqEADaWl0S09L5fkJT68tPp/L2jQ+l8nDwt9SNuLRlW2AU8KcPrf61tX7sa+vxhzG+DZltymsYL9fV2SlB/18p3zRaOH5jmSzG96dWw+dV/io++QpsstgmISQ6aPiERMiMcfUnwxaXzGScKxfW37du+smu5/T1sFM+2ax1Kf2Lj3W7jDzp9TOZR1/bn8qbRv1pQFtwZOcxNzV5Xouf6nz+Zz6dyn1Zf4suq2NNjSvYYcOPsF+IH07Za/hbftlsyzArzmb/+S67PwdrP7PxYCsyG55NXpQz/wpCbqk1MXziExIhNHxCImTGuPq2jnxYK7662rmKflEOv65+Npt/pN26lJPvIuvk0G2sGnHud/VetzI5+/IbXr9XRkzIURtm9bnjbNYfkW/qdmHBdVe/O5VbP/Bxr1/GuN9jg36hD5s1WFvrz0pYrBsdzo5Y99jW9zt5RN4dj4z4W3nZghu+yx7cKW9dvfz9yPThE5+QCKHhExIhNHxCImTGxPj+VFm4d97ERSNUw8KKNv7PX1wy37UBoPb5J1O5c/shr02amlP5KNx5rY1+dt7ad7elctMZzV5b/4WXp3J3j19gY6TKxdMNJuOvocGfzrNxd3V1r9dms/XsWMnQkD8WYP/usACmnVaz71s2mDq0beFUXL7pQsbqMwM+8QmJEBo+IREyY1x9S+gmZrPOPbQualjUYbKCEnPmuBp8LXOcG10TLMSp2fNyKp91kV+3L1Nvrn/5qlTsD6KIrNkK++1R3z32dDrDX6RjF9hMVlyiv98V4ghd54EBN+VoXfMwfLL1+MIwKH8mHN30dwp84hMSITR8QiKEhk9IhMzIGP9k7PSSjVXDwo35a6jbopdz5/ixu2Xo+o+lcrjfXF9fn7m+vW+Q9pvNn3pq02jDMYqBATflZu8VFtuYbPvrfOmxsRWTJJPDJz4hEULDJyRCZomrn49wqy177Lu2tq5+j8mYm8wFthlygD8lZkOJsEBFf3+fOWcsaPPr/fvXd9NvzHAjpaSgJ76ItIrIgyLyWxHZISJXi0ibiDwhIq8lv+eVWllCSHEo1NX/LoDHVfUC5LbT2gHgDgCbVHUFgE3JMSFkFlDIbrlzAbwfwGcBQFVHAYyKyE0A1iTdNgJ4CsBXSqFkMbDu92Q0NLhCFmGJbut+25pyx46FteL8LDlCZhqFPPHPBvA2gHtF5EUR+fdku+x2VT2Q9DmI3K66hJBZQCGGXw3gMgB3qeqlAAYQuPWaexROOBolIutFZIuIbBkIykQRQipDIYa/H8B+Vd2cHD+I3BfBIRFZAgDJ766JTlbVDaraoaodTY2NE3UhhJSZKWN8VT0oIvtE5HxV3QngBgDbk59bAXwj+f1wSTUtE2GWHCHvRAqdx/9zAPeJSC2A3QA+h5y38AMRuQ3AmwBuLo2KhJBiU5Dhq+pWAB0TNN1QXHUIIeWAKbuERAgNn5AIoeETEiE0fEIihIZPSITQ8AmJEBo+IREi5Sz4ICJvI5fsswDA4Sm6l5qZoANAPUKoh8+p6nGWqi6cqlNZDT+9qcgWVZ0oISgqHagH9aiUHnT1CYkQGj4hEVIpw99QoftaZoIOAPUIoR4+JdGjIjE+IaSy0NUnJELKavgisk5EdorILhEpW1VeEblHRLpEZJt5rezlwUXkTBF5UkS2i8grIvKFSugiIvUi8qyI/CbR42vJ62eLyObk83kgqb9QckQkk9RzfLRSeojIHhF5WUS2isiW5LVK/I+UpZR92QxfRDIA/gnAhwGsBHCLiKws0+2/B2Bd8FolyoNnAXxJVVcCWA3g9uQ9KLcuIwCuV9VLAKwCsE5EVgP4JoBvq+q5AHoA3FZiPU7wBeRKtp+gUnpcp6qrzPRZJf5HylPKXlXL8gPgagA/Mcd3ArizjPdfDmCbOd4JYEkiLwGws1y6GB0eBrC2kroAaATwAoCrkEsUqZ7o8yrh/Zcl/8zXA3gUuZ1QK6HHHgALgtfK+rkAmAvgDSRjb6XUo5yu/lIA+8zx/uS1SlHR8uAishzApQA2V0KXxL3eilyR1CcAvA6gV1VPbApQrs/nOwC+DLfn2fwK6aEAfioiz4vI+uS1cn8uZStlz8E9TF4evBSISDOAHwH4oqoeq4QuqjqmqquQe+JeCeCCUt8zREQ+CqBLVZ8v970n4FpVvQy5UPR2EXm/bSzT5zKtUvanQjkNvxPAmeZ4WfJapSioPHixEZEa5Iz+PlV9qJK6AICq9gJ4EjmXulVETtRhLMfncw2Aj4nIHgD3I+fuf7cCekBVO5PfXQB+jNyXYbk/l2mVsj8Vymn4zwFYkYzY1gL4JIBHynj/kEeQKwsOlKk8uIgIgLsB7FDVb1VKFxFZKCKtidyA3DjDDuS+AD5RLj1U9U5VXaaqy5H7f/i5qn663HqISJOItJyQAXwQwDaU+XNR1YMA9onI+clLJ0rZF1+PUg+aBIMUNwJ4Fbl48m/KeN/vAzgA4Dhy36q3IRdLbgLwGoCfAWgrgx7XIuemvQRga/JzY7l1AXAxgBcTPbYB+Nvk9XMAPAtgF4AfAqgr42e0BsCjldAjud9vkp9XTvxvVuh/ZBWALcln818A5pVCD2buERIhHNwjJEJo+IRECA2fkAih4RMSITR8QiKEhk9IhNDwCYkQGj4hEfL/NfCBqhahWicAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(x_validation))\n",
    "\n",
    "for i in range(10):\n",
    "    plt.imshow(x_validation[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "plt.imshow(y_validation[random_index, 0, 0], cmap = 'Reds', alpha = 0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch\n",
    "\n",
    "\n",
    "class ConvLSTMCell(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, GPU):\n",
    "        \"\"\"\n",
    "        Initialize ConvLSTM cell.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_size: (int, int)\n",
    "            Height and width of input tensor as (height, width).\n",
    "        input_dim: int\n",
    "            Number of channels of input tensor.\n",
    "        hidden_dim: int\n",
    "            Number of channels of hidden state.\n",
    "        kernel_size: (int, int)\n",
    "            Size of the convolutional kernel.\n",
    "        bias: bool\n",
    "            Whether or not to add the bias.\n",
    "        \"\"\"\n",
    "\n",
    "        super(ConvLSTMCell, self).__init__()\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "\n",
    "        self.kernel_size = kernel_size\n",
    "        self.padding     = kernel_size[0] // 2, kernel_size[1] // 2\n",
    "        self.bias        = bias\n",
    "        self.GPU         = GPU\n",
    "        \n",
    "        self.conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                              out_channels=4 * self.hidden_dim,\n",
    "                              kernel_size=self.kernel_size,\n",
    "                              padding=self.padding,\n",
    "                              bias=self.bias)\n",
    "\n",
    "    def forward(self, input_tensor, cur_state):\n",
    "        \n",
    "        h_cur, c_cur = cur_state\n",
    "        \n",
    "        combined = torch.cat([input_tensor, h_cur], dim=1)  # concatenate along channel axis\n",
    "        \n",
    "        combined_conv = self.conv(combined)\n",
    "        cc_i, cc_f, cc_o, cc_g = torch.split(combined_conv, self.hidden_dim, dim=1) \n",
    "        i = torch.sigmoid(cc_i)\n",
    "        f = torch.sigmoid(cc_f)\n",
    "        o = torch.sigmoid(cc_o)\n",
    "        g = torch.tanh(cc_g)\n",
    "\n",
    "        c_next = f * c_cur + i * g\n",
    "        h_next = o * torch.tanh(c_next)\n",
    "        \n",
    "        return h_next, c_next\n",
    "\n",
    "    def init_hidden(self, batch_size):\n",
    "        to_return = (Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)),\n",
    "                     Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)))\n",
    "        if self.GPU:\n",
    "            to_return = (to_return[0].cuda(), to_return[1].cuda())\n",
    "        return(to_return)\n",
    "\n",
    "\n",
    "class ConvLSTM(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, num_layers,\n",
    "                 batch_first, bias, return_all_layers, GPU):\n",
    "        super(ConvLSTM, self).__init__()\n",
    "\n",
    "        self._check_kernel_size_consistency(kernel_size)\n",
    "\n",
    "        # Make sure that both `kernel_size` and `hidden_dim` are lists having len == num_layers\n",
    "        kernel_size = self._extend_for_multilayer(kernel_size, num_layers)\n",
    "        hidden_dim  = self._extend_for_multilayer(hidden_dim, num_layers)\n",
    "        if not len(kernel_size) == len(hidden_dim) == num_layers:\n",
    "            raise ValueError('Inconsistent list length.')\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.kernel_size = kernel_size\n",
    "        self.num_layers = num_layers\n",
    "        self.batch_first = batch_first\n",
    "        self.bias = bias\n",
    "        self.return_all_layers = return_all_layers\n",
    "        self.GPU = GPU\n",
    "\n",
    "        cell_list = []\n",
    "        for i in range(0, self.num_layers):\n",
    "            cur_input_dim = self.input_dim if i == 0 else self.hidden_dim[i-1]\n",
    "\n",
    "            cell_list.append(ConvLSTMCell(input_size=(self.height, self.width),\n",
    "                                          input_dim=cur_input_dim,\n",
    "                                          hidden_dim=self.hidden_dim[i],\n",
    "                                          kernel_size=self.kernel_size[i],\n",
    "                                          bias=self.bias,\n",
    "                                          GPU=self.GPU))\n",
    "\n",
    "        self.cell_list = nn.ModuleList(cell_list)\n",
    "\n",
    "    def forward(self, input_tensor, hidden_state=None):\n",
    "        \"\"\"\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_tensor: todo \n",
    "            5-D Tensor either of shape (t, b, c, h, w) or (b, t, c, h, w)\n",
    "        hidden_state: todo\n",
    "            None. todo implement stateful\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        last_state_list, layer_output\n",
    "        \"\"\"\n",
    "        if not self.batch_first:\n",
    "            # (t, b, c, h, w) -> (b, t, c, h, w)\n",
    "            input_tensor.permute(1, 0, 2, 3, 4)\n",
    "\n",
    "        # Implement stateful ConvLSTM\n",
    "        if hidden_state is not None:\n",
    "            raise NotImplementedError()\n",
    "        else:\n",
    "            hidden_state = self._init_hidden(batch_size=input_tensor.size(0))\n",
    "\n",
    "        layer_output_list = []\n",
    "        last_state_list   = []\n",
    "\n",
    "        seq_len = input_tensor.size(1)\n",
    "        cur_layer_input = input_tensor\n",
    "\n",
    "        for layer_idx in range(self.num_layers):\n",
    "\n",
    "            h, c = hidden_state[layer_idx]\n",
    "            output_inner = []\n",
    "            for t in range(seq_len):\n",
    "\n",
    "                h, c = self.cell_list[layer_idx](input_tensor=cur_layer_input[:, t, :, :, :],\n",
    "                                                 cur_state=[h, c])\n",
    "                output_inner.append(h)\n",
    "\n",
    "            layer_output = torch.stack(output_inner, dim=1)\n",
    "            cur_layer_input = layer_output\n",
    "\n",
    "            layer_output_list.append(layer_output)\n",
    "            last_state_list.append([h, c])\n",
    "\n",
    "        if not self.return_all_layers:\n",
    "            layer_output_list = layer_output_list[-1:]\n",
    "            last_state_list   = last_state_list[-1:]\n",
    "\n",
    "        return layer_output_list, last_state_list\n",
    "\n",
    "    def _init_hidden(self, batch_size):\n",
    "        init_states = []\n",
    "        for i in range(self.num_layers):\n",
    "            init_states.append(self.cell_list[i].init_hidden(batch_size))\n",
    "        return init_states\n",
    "\n",
    "    @staticmethod\n",
    "    def _check_kernel_size_consistency(kernel_size):\n",
    "        if not (isinstance(kernel_size, tuple) or\n",
    "                    (isinstance(kernel_size, list) and all([isinstance(elem, tuple) for elem in kernel_size]))):\n",
    "            raise ValueError('`kernel_size` must be tuple or list of tuples')\n",
    "\n",
    "    @staticmethod\n",
    "    def _extend_for_multilayer(param, num_layers):\n",
    "        if not isinstance(param, list):\n",
    "            param = [param] * num_layers\n",
    "        return param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking one of the like-sequence tensors within the list to set parameters\n",
    "channels = x.shape[2]\n",
    "height = x.shape[3]\n",
    "width = x.shape[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_lstm = ConvLSTM(input_size = (height,\n",
    "                                   width),\n",
    "                     input_dim = channels,\n",
    "                     hidden_dim = [128, 64, 64, 1],\n",
    "                     kernel_size = (5, 5),\n",
    "                     num_layers = 4,\n",
    "                     batch_first = True,\n",
    "                     bias = True,\n",
    "                     return_all_layers = False,\n",
    "                     GPU = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvLSTM(\n",
       "  (cell_list): ModuleList(\n",
       "    (0): ConvLSTMCell(\n",
       "      (conv): Conv2d(129, 512, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (1): ConvLSTMCell(\n",
       "      (conv): Conv2d(192, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (2): ConvLSTMCell(\n",
       "      (conv): Conv2d(128, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (3): ConvLSTMCell(\n",
       "      (conv): Conv2d(65, 4, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_lstm.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(conv_lstm.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class train_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x[IDs, :, :, :, :]\n",
    "        curr_y = y[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)\n",
    "    \n",
    "class validation_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x_validation[IDs, :, :, :, :]\n",
    "        curr_y = y_validation[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = train_Dataset(data_indices=range(y.shape[0]))\n",
    "validation_set = validation_Dataset(data_indices=range(y_validation.shape[0]))\n",
    "\n",
    "batch_size = 100\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset = training_set,\n",
    "                                           batch_size = batch_size,\n",
    "                                           shuffle = True)\n",
    "validation_loader = torch.utils.data.DataLoader(dataset = validation_set,\n",
    "                                                batch_size = batch_size,\n",
    "                                                shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_lstm = torch.nn.DataParallel(conv_lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0 \n",
      "\tBatch loss:  0.019357115030288696 \n",
      "\n",
      "Epoch:  1 \n",
      "\tBatch loss:  0.01647569052875042 \n",
      "\n",
      "Epoch:  2 \n",
      "\tBatch loss:  0.01225698459893465 \n",
      "\n",
      "Epoch:  3 \n",
      "\tBatch loss:  0.012852807529270649 \n",
      "\n",
      "Epoch:  4 \n",
      "\tBatch loss:  0.011498953215777874 \n",
      "\n",
      "Epoch:  5 \n",
      "\tBatch loss:  0.01102896686643362 \n",
      "\n",
      "Epoch:  6 \n",
      "\tBatch loss:  0.009712866507470608 \n",
      "\n",
      "Epoch:  7 \n",
      "\tBatch loss:  0.011440486647188663 \n",
      "\n",
      "Epoch:  8 \n",
      "\tBatch loss:  0.009078849107027054 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "epochs = int(np.ceil((7*10**5) / x.shape[0]))\n",
    "for i in range(epochs):\n",
    "    for data in train_loader:\n",
    "        \n",
    "        # data loader\n",
    "        batch_x, batch_y = data\n",
    "        \n",
    "        # move to GPU\n",
    "        batch_x = batch_x.to(device)\n",
    "        batch_y = batch_y.to(device)\n",
    "        \n",
    "        # run model and get the prediction\n",
    "        batch_y_hat = conv_lstm(batch_x)\n",
    "        batch_y_hat = batch_y_hat[0][0][:, -2:-1, :, :, :]\n",
    "        \n",
    "        # calculate and store the loss\n",
    "        batch_loss = loss(batch_y, batch_y_hat)\n",
    "        loss_list.append(batch_loss.item())\n",
    "        \n",
    "        # update parameters\n",
    "        optimizer.zero_grad()\n",
    "        batch_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    print('Epoch: ', i, '\\n\\tBatch loss: ', batch_loss.item(), '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss_list,\n",
    "         color = 'cyan',\n",
    "         label = 'Batch')\n",
    "plt.plot(np.convolve(loss_list, 1/10*np.ones(10))[10:-10],\n",
    "         color = 'navy',\n",
    "         label = 'Running average')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_x, rand_y = next(iter(validation_loader))\n",
    "\n",
    "rand_y_hat = conv_lstm(rand_x.to(device))[0][0][:, -2:-1, :, :, :]\n",
    "rand_y_hat = rand_y_hat.cpu().data.numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_random_validation_pred():\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(4)\n",
    "    f.set_figwidth(8)\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    for i in range(10):\n",
    "        axarr[0].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "        axarr[1].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "    axarr[0].imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    axarr[0].set_title('Red = True', fontsize = 15)\n",
    "    axarr[1].imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)\n",
    "    axarr[1].set_title('Green = Predicted', fontsize = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAD8CAYAAABEgMzCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXmUJFd15r+bmbWvXdWLepHU2oUMlgSNQCNsyxJgsRjJGDRgjIUtLOwBDGM22T7jkQ22wWYMHMMwllkkY1YLhASYRW4kwAYktZBA1t5o6726a+1as6ryzR8RHfe+qIisrKrMjOyq73dOnXoR8SLiRWTeeBnfu+9ecc6BEEIIIdmRy7oBhBBCyFqHnTEhhBCSMeyMCSGEkIxhZ0wIIYRkDDtjQgghJGPYGRNCCCEZw864RojIdSLizN9BEfm6iPxiFc/xQRF5slrHSznHDbHrSPq7oZZtIKQcInKFiHxHRAZFpCgi+0TkJhG5LOu21RMReUPMLgdE5Nsi8uwan9d7Dpl2dC7hGO8WkYur2KaXh23YXq1j1hp2xrVlFMCF4d/bAZwJ4DYR6cu0VUvjvdBruBDA7QDuja17b2atI2saEfkQgC8D2AfgjQBeCOBaAG0Avikip2XYvKy4BIFdvgnABgC3i8iWOp7/G+H5J5ewz7sBXFyT1hwnFLJuwCpnzjn347D84/DX448AXAbgc5m1agk4534O4OfHlkVkCEDOXFcqItLmnJuqZfvI2kVELkfwI/d3nXM3xDZ/RkR+HUDq928Vfz/vds6NA4CI7ALwFIDXAfi7eEUREQAtzrnpap3cOXcYwOFqHW+twDfj+vLT8P+JdqWI9InI9SJySESmReSHIvK8WJ1eEfmciIyLyAER+bO6tboCRKQ1lIXeIiIfFZEjAO4Otx0UkffF6v9BWL9g1m0QkU+G8tqUiPxARJ5T50shxw9vR9Dx3JC00Tn3Nefc/mPL4fftj0XkwyJyGMD9ZtvlIrIrtL+DIvK3ItJkjycizxSRb4jI0fDvX0XkBLP94vAcF4fbxkXkcRH5H1W/8gpxzu1B0DFuD9t4nYgcEZEXiMjdAKYBvDrcVpXnUJJMLSJt4T19SkRmROQJEfmbcNuTAPoB/G8jsV8cbsuJyLUisjvc71ERuSp2PgmvayD8XP4ZQHe17mG94JtxfTkp/P/EsRUi0gLg3wH0AngXgAEAfwjg30XkDOfcwbDqpxHIOP8TwEEA7wRwGoC5cicMf/nmF2uYc67scZbAnwHYCeC3l7KTiLQhkMBbAPwxgEEAbwWwU0ROd84dqVL7yCog/BF3IYAPLnHXdwH4PoDXI3wZEZErAXwewD8C+FMEdvU34fZ3hnVOB/CfAHYh+G4XEAzPfE1ELnB+XOF/AnAjgOsBvBbAx0Rkl3PurjLXk8PiL0fOOTe/lIsVkS4AfQieGcdoD9v3twAeBbC/ls+h8Bl0C3RI6x4AWwH8UljlNxDY/k0APhGuezD8/w8ArgLwlwB+AuBFAD4lIoPOua+Hdf4IwJ8D+GsAPwDwyvDaji+cc/yrwR+A6wAcQWC0BQRf2NsQjLe2mHpXAygCOMOsKyCQhv8uXP4FAA7Afzd1OgEMAXhykXa8Idy37N8SrusmAHckrG8Nj/WjhG0HAbwvtu4PwvqFcPnNCCTF7aZOC4A9AN6b9efJv8b6A7Ap/P68KbZejM0VAIjZ5gD8JKH+UwA+HVv/e+H3sT9c/gyARwA0mzpnAJgH8LJw+eLwHH9p6jQheDN9/yLXc0MFdnrHIsc4Zus94bWfCOCLCDrK88I614V1Lo/tW7XnkGlHZ7j8a+HyK8q0/QiA62LrTgdQAnBVbP0/I1BEgOBFYz+Aj8fq3Baec3vW39VK//hmXFv6Acya5UEAz3XOzZh1L0TwS/EJK9kC+B6AHWH5ueH/W45tdM6Ni8htADwZKYGvmf3rwTeWud8LAdwJYK+5D/MIfunuSN2LrHXimW7eAX9s9K0APmqW/y1W/0wEitWXYvb3XQQ/MJ+JwBZfiOBtsmTqPQHgSQTfT/u9/07UOOdmReQxANsWuY7rYu1M4ugi248xYspHAPyec+4+s84B+GZsn1o+hy4BMOScu7XC9h/jUgSd8c2xNu0E8FoRySP4wbHZtinkKwiu6biBnXFtGUXwhcgDOBeBpPY5EbnIOVcK66wH8Hz4nfYxjjlOnQDgqFvoZDFQQRuGwnbUi0PL3G89gBcg+T48sPzmkFXKIIAZLOzkPgPgjrB8d8J+8e/n+vB/vJM+xomm3nvCv7Q6xxiJLRcRdOzleBrA3kXqVJpi75cReDIfAbDHPGuOMeycK8bW1fI51A/gwKKtXsh6BM/OtOfX5rBNSW2o5NnYULAzri1zzrldYflOEZlCILG8GoF8BASd5S4E4zNxjr1BHwTQJSKtMUPYWEEbrkIwzrMYUkGdSkh6YEwDaI6tWxdbHkIwJvf2hP1Xo8crWQHOuTkR+RGAFyMYLzy2/hDCDjcYqly4a2x5KPx/DYIhpDhPmHo3Q8c0LdXwZ/gUAlstx/dQ2fSfe13oTZ1Cko3W8jk0iKDjXCpDCCT2ixC8IccZgPZh8TZU8mxsKNgZ15d/gf66PtYZ70TwQHnaOZf2a+7YL/zLj+0Xeiq+CMDYIuest0ydxF4Az4ite3FseSeA/wXgcefcEAhZnA8D+KqIvN4595llHuMRBHOUtzvn/qlMvZ0IxkzvceGgZJW5DtWTqZdDLZ9DOwG8W0Re7tTpKk6SevBdBG/GPc6525J2EpE9CH4kXA7gW2bTK8u0pyFhZ1xHnHNORP4awGdF5FLn3E4Eb8p/AOAOEfkggMcRyDoXADjonPuQc+4BEbkVwMdFpBuB5PMuVDCp3jk3iOCXaZbcDOADIvJuAPcBuBKBQ5vlEwB+H8F9+HsEbyTrEXhgPuGc+1gd20uOA5xzt4jIhwHcICK/iuCH5xEE9nPsx165N0Q450oi8g4E85K7EYylFgGcCuAKAK9yzk0i6CzvAvANEflUeJ6tCDqiG5xzd6zwWp5EMP6cFbV8Dt0G4NsIhuiOeUVvBvDLzrk3hXUeBvAyEfkWgs/sEefcIyLy/wB8QUT+FsGbeyuCH0VnOufe6JybD7d9UILplD8A8JtY+OO/8cnag2y1/iH0pk5Yn0cwneDbZl0PgI8g8BwuIniT/AqAi0yddQC+AGACgQz35wjGoJ+s83Ut5k39xoRtzQimKAwg+GHwQQBvgfGmDuv1AfgYgjeVYng//hXABVl/nvxr3D8EU2NuQyBrziLwrv0ygJfE6jkAb0k5xksQPMgnELzl3QfgfbHv59nh938IwdDJbgTTobaF2y8Oz/HM2LHvAHBTHe7DG2C8mFPqJD6Xwm1VeQ4ltQNBRLQPhsecQfBj+6/M9ucA+HF4XAfg4nC9IBi6eiDc7zACuf53zL6CYMrUYQTqwWcB/BaOM29qCS+GEEIIIRnBCFyEEEJIxrAzJoQQQjKGnTEhhBCSMSvqjEXkMhF5JAzifW21GkUIqT+0Z0KyY9kOXGEoskcRuPbvRTAH7bXOuQfL7kgIaThoz4Rky0rmGV8AYLdz7nEAEJEvIJh4nWq8He3trre3dwWnJGRtsP/AgSPOuQ11POWS7Lm9g7ZMSCUc2F+ZLa+kM96KYD7aMfYiIVi4iFyDINQcenp68OY3vXEFpyRkbfBn1733qTqfclF7jtvym/7wmvq1jpDjlOv+119UZMs1d+Byzl3vnNvhnNvR0d5e69MRQmqEteX2DtoyIdVkJZ3xPvjZSraF6wghxx+0Z0IyZCWd8d0AzhCRU0SkGcBrACw1XyUhpDGgPROSIcseM3ZBCrO3IAgAngfwKecc884SchxCeyYkW1aUtck5929IT8pNCDmOoD0Tkh2MwEUIIYRkDDtjQgghJGPYGRNCCCEZw86YEEIIyRh2xoQQQkjGsDMmhBBCMmZFU5vI6iaXy5uy/m7L57Us4v+em5+fj8qlUsmUdf1yM4URQpaHtV/fltXGRcTbJ92WtUxbrh58MyaEEEIyhp0xIYQQkjGUqUkqVs6yWGlr4T76lbISVqmk+8zPl0zZyte6nhBSPZZny7qPb8vJ9uvb8tLla4fK9hHI4pWOQ/hmTAghhGQMO2NCCCEkYyhTr3Hi8pX1jrbOldbT0srM1rMaAAqFJrNNJTArQc/NqZxVLM4kHjdYnlu0/YSQgIW2LIuWrbQcl6wLhULiNitBz82pjRaLxcTjJi0nsVrl50rhmzEhhBCSMeyMCSGEkIyhTF0VFpeDymEl3HpPoo8H7bCUSs7Us2Vbx5eWrUxtpalcTndqamoy9VX+mp31ZWkre83OFkFIPVmeLbvEcj0o10Zrp2nXtdCWtXvwbVmfGb4ta/3Z2VnvWL4t+9tIAN+MCSGEkIxhZ0wIIYRkDGXqZeJ7Ha/MC9CXiusrWcelqbTgALYp5YJzzMxMR+WmpmZzHj2AlbPstcc9s1taWhLPQcmaVJPlyNGVHMvSWLZcmZQ+M6MzHawcbc/j27Jee9wzu7WlVeuZYb0ibTmCb8aEEEJIxrAzJoQQQjKGnTEhhBCSMYuOGYvIpwC8HMCAc+6Z4bo+AF8EsB3AkwCudM4N166ZjYE/BrP42JI/HuOPzfhjS3bMygZnXzxqTaVUOsZdWbKG9DE2G10L0CkMbW06ZtTcrGPJdmxpdtYfZ7LTIZqakhNQzM1xmsRSoD0HpI2nplFubDXNnuz6ao4Z5yq25cXPKWVseX4u+fnT1tYWldNsea7MNMWCseWSF5lvbUfcq+QbeQOAy2LrrgWw0zl3BoCd4TIhpPG5AbRnQhqORTtj59z3AQzFVl8O4MawfCOAK6rcLkJIDaA9E9KYLHdq0ybn3IGwfBDApiq1p6FYKGVVMm3BRqrKJZaDZSRuszJxqYrpfSufspFWz06HsA3zr8tG2rL75HLJ+YztNIn4/bZyWLGYnHeV+ZCrwqq350pl6TRpt9z0p7RtaTmAV0yFppyWeMHmDbYycS5my5JL3t/ey9IybDlXTP4sVpoP+XhnxQ5cLrhrqXdORK4RkV0ismticnKlpyOE1JBy9mxteXKCtkxINVluZ3xIRDYDQPh/IK2ic+5659wO59yOjvb2ZZ6OEFJDKrJna8vtHbRlQqrJcmXqWwFcBeD94f9bqtaiDEiXoCrzOvb3X5rH9cK2JHtKrlS28du7nN9gyfcoHmnHylN+RC2XWMdG5rLlYP/ka7aRuew+09NTaY0n5Vk19rzS5A61isZVXVs2+68wBbBtVy4fH3Kytpw8TGSlbCtTx2V5ySc31Ldl3Wd6ejqp+qpm0aeyiHwewI8AnCUie0XkagRG+yIReQzAC8NlQkiDQ3smpDFZ9M3YOffalE2XVrkthJAaQ3smpDFZU4kiliNH+6R5SlfigexLU3bReiB7spGRiayn4XLwz58uWfttsXlL0wLCp3+FrDRucxXbfKbWy7K1VctAundmWjCQUqk5sQ5ZfdRDTk5joS0nD8HUx5aVeNvT2mKTPpQbcko7p7XfdFvWID9Aej7ltGAgzRnbsvU4T/NKrzYMh0kIIYRkDDtjQgghJGNWvUyd7um8dKzsk+YQaaVZX75K9zpO80A2CtCKpS2/jekxs+3vszQJK34t6edJDgDi5zZWyaxYnIHFxrm2XpcdHZ2mjcnzXeNxbqsadIFkQjWlad+Wk405Le9vPKBFui3buOtqzLWz5XTSbXllwVDSchvHpWVrj80tKkF3dHRoG6eSP9OsbblekjXfjAkhhJCMYWdMCCGEZMyql6krI03q8SWJNEWoVFLZyUrhftCLuKfj4nGufW/I5PjVlZIm8S30wLRyVvJvtTRZrtyx0+LOWjmruVkl6+DYydc5O6v7WMmtrU2jQsUDiExMjCcei6xNKpFdK/U0TpN6K/GyXk4AkMptefGgHeVsOS1VY5otzxZVim9aYMvJ96hobNkGHbGe2W6BLU8kHquq2FPWx5mab8aEEEJI1rAzJoQQQjKGnTEhhBCSMat+zNifnpA8HuSP3y49uLyd6uMP20jK+nLu+cnjzHb8dm5uZa795aZ42VzDdpzHTs0oN7XJz8ecfO/tFAg7/jQ5aeZyAejtXReVbdQge+/t/ja4fHOzTp8I6rUm1iPHD2lTjdIiXS3nuGlju5b4+kqm2giSx5/j03aWSrkpXtY20m25zLPA6f72Gu39srY8N2+i7C2w5V7dx0Ta8mzZTGWcmdFpjgttOdnmj3f4ZkwIIYRkDDtjQgghJGNWvUxtsYrOcuQsi5WN/dkJNtJUZXKylcmtTFxuOsVKSJP4gmUt27ZYrDRUKKRHFrMytT2uTRphEz3Er7etTaVlK+fZ89s6vb09UXlsLP3zLZopGHZaGjl+WKk0bfG+d84WjSxuh1xSp0LG8vvWwZZtUxZI1maxVJEt+92Bb8vJQ3xW8rZDSfHcyDZxRKotmzqtbWrLubK2rFOjjvcoe3wzJoQQQjKGnTEhhBCSMWtKpvZJDrFSLiKOHzkn+VhpQeDjHshW3k3zxvblNz1HOQ/MpeZpjkt8ad7ndr2Vg+Iyr5WjrDSX5vVp68RzI09Z72gjgdlA8/ZzmJ5WD8y45NbV1RWV7Wc0Njaa2C5y/FO5LSfXS7PlfMyW88aWvW0ptuyWYctegoIUE49Lw2ne5971GmU3LvOuzJb9tlg52srZ1lPafgozy7LlscR2rZg6RePimzEhhBCSMeyMCSGEkIxZUzJ1mtSa7plZaQCQ5HM0NakEE5eDfW9s63WsUo9tY7l8wmkewZXkfF1eblUrs/nS1syMejdamSs9mL6WbQIIAHATutGmOt2wYaM5h+Y5tvmP4/Lf5KTmPU7z0p6crEMAelIVlm7LSz+uLTeXseVcii3nK7DluOQ9X4ktp5j1AlteYg6K0gJbVqm4Mls2CWBm/aAfJZdsW+s3rI/K7a2aHMLO5Chvy22mnp5zYkLrlHsOOt99PnF9LXMYW/hmTAghhGQMO2NCCCEkY9aUTJ1G5dJ0su7jx2pVT8Fy+YzTZDYrtfrSdHqe4TSZulxwj2pRLmiIvV/pQQ/sfYhtccn7t7dr3mI76X9qatLU6fCO1d/fb46VHLDFynLz8yuLGUyyYaUBQLxhpkJyEIu4bJlmy/MptmwDg8Q9oNNk6opseempkT0W2vLiXtOpxONvmLZZ7/POjs6obPMhT0+p93V7h9o7ALSbvOW2LSUz+8POxEgLeLKQFd7AFbLoN1dEThSR20XkQRF5QETeFq7vE5HbROSx8P+6xY5FCMkO2jIhjUslPyPnALzDOXcOgOcDeLOInAPgWgA7nXNnANgZLhNCGhfaMiENyqIytXPuAIADYfmoiDwEYCuAywFcHFa7EcAdAN5Tk1ZmRDwYQJocbINVpHsa+lKJH4Na929tTf5IrBwTb5eND+tvS/bSTqsTbNOy58Bp0i7aa4xLVjbWtJXs7ET/tLbH69hj24n/ExPqmdliAoC0tKhndfweWQnbDiX09elLoPVGHRw8ktje4xnaspIWxzhNTvb2jdmylUELxpYLVbRl692bd8n7L4iZnRKsIlehLReWaMtFMxvC7gsABc+Wdf9J4/Vs7dcL7FPyr2uyaG1Zz9O3Tm3ZelYPDQ4lthfIWpj2WdIAi4hsB3A+gDsBbAqNGwAOAthU1ZYRQmoGbZmQxqLizlhEOgF8GcDbnXNe3DEX/DxL/JEhIteIyC4R2TVh5ocRQrKhGrZs32gIISunos5YRJoQGO9nnXNfCVcfEpHN4fbNAAaS9nXOXe+c2+Gc29HR3p5UhRBSJ6ply3EPV0LIylh0zFgC//ZPAnjIOff3ZtOtAK4C8P7w/y01aWGNsGMtlUahShs39QK6m7EZGzmm3HioP4Zkz6dlO8YcD5xux5zT8/MmT41YOMadPIXKXrtNchFP7mCx40xpgeLtlK0NGzZ4+9voOnaqkf3sRkY00YMdc5qf1/PF97FjVva67JSp2dnuqFyzAPR1hraspNmAb8taXo4tp43ZlsrYsh1zTp3mVKEt2ylYdgqVHTO204wKK7Rle8Hr1/fD0mGmGtpnmT3uyMhwVLa2PB2bmuTbsh3j1+vqMFOm5mbLJZOwkbaypZJ5xhcBeD2A+0XkvnDdnyIw3C+JyNUAngJwZW2aSAipErRlQhqUSryp/wPpPxourW5zCCG1grZMSOPCCFxIj24Tl5AqETLS5NB4cgcrj1hp2sqxpZI9lp0+5bfDSjXFYsnUs9MWkqcwlIvMZSVcWy8eAczfJ3m9lQ/9e6xtsbJ0HCuH2+lT3d09ie06ePCQt//AgA6DdveoBG0TANhEFTYw/mTM8bBcDlqSLZXb8tKO5dtf+vc/TTK3cmy5Y1nZeL44n1gvTRYvb8vJ8rs3RBbz2/NyPns52+dMHa0/C51O1GISuAD+dDArmTe16DOyq3uLaZfeo0OHfFs+bG25W205b54LM8XkJBdxW56d8xNaKIsn5qg2jE1NCCGEZAw7Y0IIISRjKFMjLmclR5epdP8078L41E0/OURy1J00b87mZpVW4/X8xAtW5tI6vmd2LOqOuX5//2SZLBZAyIs0ZttlJeCikZB6e3ujso2SBfgekVbas3K0zU1s27hxo+Y8Bvx7NjqmHtjj40cTr8VK9HGPccrUjctKpel0W07Ht+Vkr//l2XLyOez33ErhCzyzC8kRtNJtOR6Nz7Zf19vkLDa5ynBeI13lh/z3vJ4ulZPbW9SzulAy0QebNYJWc0HvS3yWhR2mGh4dicrWU9pG7cqZ6IO5fOz+NpAp882YEEIIyRh2xoQQQkjGUKZeQMpMfaQnWLCe0r5Mq791rLQT7JMsR9nJ7mlel02xIOy+HJysu5S8YOsqbZWTpnwJS69rdraUWD84j53Q7xLrzXz+xqj8r/vHo/Iz+9QzGgDOeYZ6V/a/6rVRWVo0OMfMjMpf69ap5B33+LZBCOx93bt3L8jaI/69PYa1szSZeaEtJ7/TVGbLvhTu23Kyp29akovKbVnXpyeZiduyKafcu9t336vHffAevy3mvW/TJpWd+9d1ReUzN6m9n731zKjcCh2KAoBiu0rjQ+Oa0OXAyIGovL51fVTOG5l6aj4WxtWZwCimnn06x/NX1wq+GRNCCCEZw86YEEIIyRjK1PDlGevpGA/U4XseJ0sXvtSTLCcBC70oo6N6gTZ0vZW24t68VoKy9aw3tO8pLKaO30YrQaedIy2AR3ybX0/btfMJ9bq0kvtj41Pesfb+135t//3/Jyo/q0Plv62v1MBRuQsvicrWSxsAurpUDrPy4eDgYFSemtLz23tnvb9JY5Nuy/57RyWe1mlSdpx0W04OtLE8W04eGipvy8ky90pt2YuHYfaZnlb5fmhEc44DQMu8nvPoEfV63m2G6+7reiQq73iO2uW2Tf7MCGcC9RwaORyVnzqyR/fpUC/rjoLK3FMj/jPGytmteR3+yov9vlCmJoQQQtYE7IwJIYSQjKFMvYDkuMnxbWmkpUBsjcVqFUn+HWS9rOfmVBqyXtILUygme1pPTSXHkC2nvtltVuZK89KOkxYD2/LS522Pyt+5R6UlKxMDvrRsA288NKPtGrz5jqi87ZDGrO148zu9Y/nxePVY69ZpoIHJSZXWhodV5qpUriSNy0pjU9vvj411HN9mSZOjrV0ttGWT0tDY8vSUnxI0aqM3FOa3Q1yyZ3aafB0nPc2rmUligmg8e8v2qLy/W72cAeDovNYbMxL27Lhel5hhwVmT9jDX4j87O2x6xV59RmycUi/twSMqXw9N6bBYb5PWB4Bpk2q1OafHzXnPZ5tmsXaSNd+MCSGEkIxhZ0wIIYRkDDtjQgghJGM4ZryAysYH04LD2/3b2zUgenz81EanstMGikU9lh2bsuX4eLON4uNPNVjZlBx7nnjUr5XgXvgbUfnXztUx4/k7f+TVs9c8MqDTJh4xt3vCjP9+d7dOh3jZJz7qHWvD7781sS12jNt+DnOpeU7JaiPdlpX2djPtZYEt6/72O5SWU9eWc2Vs2TI9rWObNhrevJmCN+/mvX3ssVvMeGhzkxmDTc4xE2wqkx85idN7zojKZ/ae5W1ralE7HXRqp3ft2x2V21o1n3l3lz47S9P+eHlXpyaQmWjRaU7dJmnMtGn72Iz6ohRi759NOW1XR8E8r03XyAhchBBCyBqBnTEhhBCSMZSpY1i3/XhAeCvbpAVht/mA/fr+eWx+35YWlVdsNJ/mZptb2OYj9Y9lJVW7v5W87PnKzdSxypQ9ri3b45aT7PxIP8lB53PrT4zKhV8/2W+LOc+JRpo66xtfi8oPFI2cZGS5Hz6uUhgA/Nq+n0flmU6NujM5qRKWlQ/t9Kf5+QZKekoqZuW2XFi0PgAUjW21eras398mEzWqZKRsl4sldzAR8ArNZmpRwSadMXJ02WmKeqwZ00Y7ZbLZtCueXGV+Xg/u5UZOs2UzNckmZwCAvNN7sb3j1Kh88g61+aN5TeJgJff4JYoxxyZz/qKRs5vM9KeSfaaVfCl/3kr+9pzOThkz96WGijXfjAkhhJCMYWdMCCGEZAxl6jLE5Sgrg9pkA2m5idPyHwNAq/EcrGR/K7N5QdsBNDfbvKnJMtvMTHIEn4XnXLyOlbnibbHYbVbattfeaeTnpljA/a5OP1rOMdr7NTfx7NMa6cd6nB6e8WXJffferfucfl5U9qIJGZnNJpoYHPSjCZHjj4W2rDbn23Ly+0m5KGzWC9j3QNZ9Skb29G3ZHwJpNm2xknlTQW2jaL7bYt6n4vHuSp4Ea84jJpmGiYw1P5/+bma9tq20ba+9td14jDf7UbM6u9WWbbvymo4cI0d0KOnw6HBUnow9u5oLGl1r1ETNg5Gsu1pMuzZtjsqzY/4ME5sQwrbLVTirppos+mYsIq0icpeI/FREHhCRvwjXnyIid4rIbhH5oogkpy4hhDQMtGdCGpNKZOoZAJc4584FcB6Ay0Tk+QA+AOBDzrnTAQwDuLp2zSSEVAnaMyENyKIytQv0mfFwsSn8cwAuAfBb4fobAVwH4OPVb2J2xCUrK2dVNh/eeiPGJ/MnyyDW69gmTrDr416PVvYqFBaXv1eKPW5BNBmZAAAe80lEQVRLLIh7PAd0Em1t2sa+vj6zJd5eI/Md2ReVH979dFQ+PKoylZUIm2My2eioJn4YO3ggKvcbydtig5xYb3egcsm/EVmr9lzelpdmJ+WSTlg520q7E1PGU9gM38TbZeVRayc2Noh9cohXTr8OT6Y2R2gyAkg8AUY+1ZZ1f5sAp7PXBEbJ+feoOK/y8MiMJm7Y9cSDUfng8GhUtkGRurt1KAsApqd0psTYmO5z+tZtUXldm8rirkmfnePzfp5lzJlndM4G+qi/O1VFZxSRvIjcB2AAwG0Afg5gxLnoE94LYGttmkgIqSa0Z0Iaj4o6Y+fcvHPuPADbAFwA4OxKTyAi14jILhHZNTE5ufgOhJCaslx7trY8OUFbJqSaLMmb2jk3IiK3A7gQQK+IFMJf09sA7EvZ53oA1wPA1i1bjqvEsAsdKJMFIjvx3cpUVpqOe03aoBIzMyrhpClmXV0q1cRlUyubtZhYrbYtR48eTT7wMrDxe+Pe1Fb+s+3y4z5reWxM2xWXyXDP7VHxh99TOWvCSPbWS9ueb1OTL7F1PPuXovL4YZW5bNCPeGCI1c5S7dna8patx5stLz3mvG/L+t2ai9lywdpy0XrrJp/T5umOD/N4OYSbTaAPI/NOz+sPobzouePXOFsqmrIG7WkzQ1k2mM9U7PdVS4pnt32WzZpnwUMHHtJ9Y/nbD0yoB/RTgzpkdPSonnTO2HVHu22j/4wRIyfPmdgc02ZYb84MU7XktdwUk8/nxQQtMWMBOfsgrk9o6oq8qTeISG9YbgPwIgAPAbgdwKvCalcBuKVWjSSEVAfaMyGNSSVvxpsB3CgieQSd95ecc18XkQcBfEFE3gfgXgCfrGE7CSHVgfZMSANSiTf1zwCcn7D+cQTjTasWPz6pn5LQylY2HnRa0ADrHQgAIja+q8owHR2axssey8racSk7bwJ9FIsqO9ngGlZysrL4Slkgjc3q+YsHn4rK8//5/ag8MaXS1g/2j0fl7Sdv9441Na2yk5XDpo20LMaz+9TNJ0Tl83/nN/2GmkAFGzdujMoDA4f0WLL6A9KtVXuOf09tgJil2rKL2XJJkoPgdHSod7H9nlpbjkvZNqTz1IxKuLkWE5wir+cYn1b7OVr0h6Im59RO2o00bWVbq8GWs+VZm1LUVBsxsxR2Pq2BdXr7NnjH2ndgICrPjOh1TY6pd3POxN/eesZJUXlhzGy9/q5OjRry1KAOP811a3u7m/WZau8pAIxO6D1r7jFx/Y3MXSeVmuEwCSGEkKxhZ0wIIYRkDDtjQgghJGOYKGIJpAWXT4/go4Mr8ZkVdkpBe7uOaSyM1BVgo17Fx3z9nLx2alFycoZqjhnHsRG4Wsc12Ptte3Ssxt6KFjNGd+DA/tTjpkUdgpn1cOo6rTVlchYDQLOZNtHermN5HSZRBefOrh2WbsvKgrFV48/QaXw+CmbanY2sZceix6f8cd4pM9Un16T1bN7jOTNmPDKjY7ZDUxqNCgDy5jwb2tQemvN2PDT9em0ErtY2nXaYM2O4c2bKlAlmhcce06QPADA5bqLWzRijNTmT5522Zc8enVm3caM//myfcd0FnSY2W9RjDUzEIm2FjEyNeMt7RjQa2Akdep6uJpPBok6+JHwzJoQQQjKGnTEhhBCSMZSpl02ycGqjU/lysC9trVunCRKsTGanOc3O6rFGR1W+sjmLAWCdSbbQYSRYG9HKTrOwbZyY0KkR1WB2VqP+FI0c9tx1KkffOaj3xUYzstG04u20UXjs9dvIQPc+qDL3yyZ9Oaq9d7tZWjwa05QJR3Q8J4YgyyfNluO5bvs8W1abs1NwrF1M2By8sdeh/nUqJ7eZ/MD5Zv2e95jpPM4Mv0zO6nAVADTn1Z5s1K2cyXxcTqYumjbbqU2eZG2mI53U3ROVO2IRuMZNdKypKbWnktG2m030QDsVbOOGdd6xenr0PHb4br6kn1GnkdJnzJTUo7GhqBnzjD0ypZJ1f6t+DnlnuskaznPimzEhhBCSMeyMCSGEkIyhTL0ErIQ8aTJQ2chNNmqXlV3jyR3iUWWOYXMY+zk9u025y9vHeoDavMc2Ypil03gQ22uKn3+lyOZTonLL686IyhN/85Go/Px+lc/7nnOat3/7c38lKruiSluPfvpLUXm/M3KUkej3fv5W71jPeMdbE9tooylNGvmwmok1SONhE0L4tpwckcq35VgO70ps2amd9XT3RuWOrnakYc9fmjWzAQrqsX1iv0aqahJ/mMeevzlnJODUM/pISnSuWRPlDya3yukdau9ndvv3pLtdn182IcO8eV7mm0zLzC3OdfrDcvZ5a6X4gVa9r2ND6lk+Mq3lyWb/Obx/Xrc9NnwwKm/u0Gh+681wXzlZf6XwzZgQQgjJGHbGhBBCSMZQpl4mVuYqGI/Cjg6VkK2nbxwrJ+fzNmmEykE276n1NIwfd8bk4bWyq/WUtsEtLB0d/vpqytQWGxz/Ne//86icFuSkHOe+/U1Rue9zN0flsRaV/H4+4+ecPeuBu6Jy8bRzo/KgCS5PaXpt4tuyfk9t0pZytlwytlzK23zIWu60ttys3/n4cW2iFzuEND6uttxpc5vnVULd2LPJO9bBosqunrxqpHgry5eTYO22tHvUV+gz9RceQTHyuyl3det1tXaqTj057wfwsDFXrHw/OKne0E2z+rzc1K73JX6ND80fiMrDY3qP943rzAzrWV3L91e+GRNCCCEZw86YEEIIyRjK1MvEyq6dnSpBVRLbFvClMZtb1U5otx6cNtCFjUUN+PLqhg0qqfT2bks8lphQr8PDfnCMI0eOmKXFg2NUig2cUSyql7eV4uMe51bm6+vrj8p5E+Rk2gQgGJxWuV5iuWhHRkwM3717o/LRo2OVXQBZtVip2M40WKktd6fYsvW+norZspWjN27QvNvrTX7g5qbkoZ3DQwPe8pFBteXl5OqOBzc5hr1GGwzF3jsbcAjwJfe+fg3iYYN72FfDohl6y4vfTY2Nq80eOXI4Kg+N6PU2We9x8zmW4Oeot8OF8yaw0LgJoOLFImfQD0IIIWT1ws6YEEIIyRh2xoQQQkjGcMx4mfg5TZOTRszO6jSFeLIBO+bc26uRY2yuTjvOY6MEFZr8j23TJnXdb40FaD+GHae1EYR6e3u8ep2dOlXBjl+l0dTU7C3bwO0WOy5np0NY4kN07e06BmXHpkoP3R2V7z+s0xnG7fjPvD82dNiMLY0U/Gsma5t4fuJj2GkwNmlCPB+4/W5bW24zOcTtuKVNFNEUm9q3+YQtUbm1xUZ+UmZmtC3Wlvt6+2Hp69Zla8tpU5jiiVrseK4dP/bG2M3UyLT7CPg2bxM3lIxfiB3PnTcRy+bmTcQvAAeGdTrSnkN7tF0m/3JbQY81YcaC94zpdC/Av5e2+VPm804bO682fDMmhBBCMoadMSGEEJIxlKmXiXXVHxvTqUU5M6XGSrbd3b40aqPYSEpEHDtlostE3bESd7Cs8ozNoTphcneOjmpA9C1bNkfl+BSEnh6V2SqTqf222P1t1LCKlJ64emYj7dz2laj8/Z88HZWnvEQPer1Dw8PeoYaGTozKuRNASIS1s6PGlq1Ma+3aJm0BfFu2SRC8pBM26UuX7h+PwOXZsheBS9vl27LK2k0tvsy8rlenEE1N6FSdtAQQ+Sa/Lb3Wlpv94agkbDKMuDHbbVaCttG1js7qNR4aORSVDxz2peUj4zpNMW/ucVtTckKH8Vl9Luwb86cyztlIiBVOZasVFb8Zi0heRO4Vka+Hy6eIyJ0isltEvigii39ahJDMoS0T0ngsRaZ+G4CHzPIHAHzIOXc6gGEAV1ezYYSQmkFbJqTBqEimFpFtAF4G4K8A/LEE+sslAH4rrHIjgOsAfLwGbWx4rGRtpeleIxOVi4BjpaI5IzNbmWhuTj0K457C1rtzYGAgcb2V0kZHVaqJy9TlAuInYaVhAJiaUq/xvj69/rY29SydMRF82kSvZeo/vuMd6+m7fh6V7zeJH5qMTD8yqpLVtDn3JafquQEgd84FZa5i7UBbLo+Vhgs5/Z71mFkHuTK2bL2D7ZCRjaw3N6ffZSuRA77N7j+0LyofnVSbzZtofKJ5TrB+o01o4Mvs9vmT5k0djwZm7Wldii0XjTdyvkXPMTHlD3GNTqqdHpnVGRBjs1rvoI2mZaIKzsXuUdHc1yYzfFAwM1ZmzT5TJvnGxLh/jS1mmG3bJvU+33HCs6JyPAJYraj0zfjDAN4NRL7n/QBGnHPHvlV7AWxN2lFErhGRXSKyayL24CaE1J2q2PLkBG2ZkGqyaGcsIi8HMOCcu2c5J3DOXe+c2+Gc29HR3r74DoSQmlBNW27voC0TUk0qef++CMArROSlAFoBdAP4CIBeESmEv6i3AdhX5hhrBjtx3MrPcUe9WTOp3NJhgm44lxzEYmhoyNvHBm534+pFPPjpz0Tlnxp1pt38KOrt8b28n3+aenq6s3fohiH1aHQzZXIej2rbnvjRfYlVikW9lruHK3vD8mK1m3vZZ3JJX3SWynTNr3xdRcddY9CWl4C133LJAmxwH4tNnGD3t/L14UE/ucOwsd//GnowKt/12GNReXpG9+8wP4pO3Kqe1QBw4bbTo3LOGWlbkoei4kE7rNezDZojKbmJB6b0GbFv3PeAfsQ8Pw4fVsl63krQKUFD7BAbALS2qn9hW5sGPWk28r0Vtm2SnZ5eP3/7ab36zHhG31lRuaOw9OQ/K2XRN2Pn3J8457Y557YDeA2A7zrnXgfgdgCvCqtdBeCWmrWSELJiaMuENC4rCfrxHgQOILsRjDt9sjpNIoTUGdoyIRmzJDcx59wdAO4Iy48DoItqjPl59ZS0cnJ7bLzcBg4o2LzFxps5l7NyUrIUBgAzn78xKj+2XwMCPDmt+1iv6TZTtrmQAeDb9+j+50wYj0iTs/mJb90ZlR+Z9NtViaKTJjlXykUbVWrqevVv6LG6+5OqkwRoy4tj5eThIZWPy9myjTWd92xZ33us/Dta9POJf/WxO6Ly07s1BrMb12Gt1iaVZltK6tm89/4nvWN95aAGztixUYPenNJ1WlT2Jdi4TKzLJU+yVxF4zqn9P31URzcei+VW3rdfcw3PjZo4/SWXXM6bdrX63ZSNJz07q8/bvj79HLaYmNkdze1mvR/xZ32r5olOy4FcLxgOkxBCCMkYdsaEEEJIxjA2dQ3xU6vFglDkk38HzZqAAFYqKU7opP99H/kHb5+fDGt815EJLZ+zQWXbc7aq13TfK6+Iyoc+/1XvWHcO6v4PfO+/ovKz3vHWqHzqab8Ylbd9+Qve/g/uU5n75E6V0+4cUq/p88z6Ddv1vhw94MeNHZ3Se3HyS58flcWcX/L8CpPaY2153QJbTvZOtsE9ICrB7hl9Kip/8ge3evuMH1QbmDKx4Xu2qpy6rl/l2NY2lWBnBnzJuzihAUR+tO/hqHzSWSdH5XyZLkDMu1pOnLdF12uds9edGZVP6NgEy8+7nozKuw+pZ/bYmD5v5o1M3dWh8vu2jX3esU7u1nvR0aSzT1oL+lxpzbeZOipZN+f8FLNeXoCUYCj1gm/GhBBCSMawMyaEEEIyhp0xIYQQkjEccKshLmU6QID+DpoyMbvHTL7Ngb2at3f/P2k0rQen/Ohd7Wb8+bLTN0blvt+7JirnzXSIvIny1f+KS7xjTXxUx4Cn5+JtDpAmnQLQ8prf8badn7gH8JKU9Za+RZYJyYrUaFzBiqg4ManjvMMmicmPd+u0n28+oNFIp4b8CHRNfToG/ILnaAStF5+udtpcMFNwzBDozQ/f7h3r/vse1SaaaY52alVObGQuf8xUvKBjYhcMWqmjSac/thc6bCVsaNVIV89ar+PEE7MTSKK1oNMvW/N+MptmMwXJtt+OX+e961o8SUYjwDdjQgghJGPYGRNCCCEZQ5m6htgA8gdNNBzAD14+YyJdzf/sh1H5wF27df+Cuupv7faDnZ93xa/owjadXiB5jQbU06PTIYqmXXElenhYIw21Na6iQ8iKcDbalEtZbygWdWhoz4GnvW3O5OQem9JhpkeH1H5/+KiWO6Hacnu3L+f+4tknReWLTtCgaC1Gqu3t1Tzn0yaHb5eJ5AcAw2PDZh99ZpSMTG2vNxd/N6vI/s00J+/e+cfKmymIdtpRf4ufg7mik3uK+ep5SPHNmBBCCMkYdsaEEEJIxlCmrhNzc35CheLTj0Tl3V/8ppantJ6N0rVpo8pZZ3SqNyEAzG46NSq3pkakUjnHBsCf+N4dXq2SzS+aXz0SECGVkPaNL5kMuZPT4962fePqKX3nXs07vO9xzeGbn1EJt3uzJisotPnS8ikdW6NyW7OfkELbqK20z5VDo6OxilqvKyaHH8NK1uVk6krk4HSP64U1yUL4ZkwIIYRkDDtjQgghJGMoU9eJ0pF93vIP/+VrUXlsLtmDs8nITPk59eZsOXGLV296RgPCt7Wpp2Jbu5Y9+dkwenAocT0hqxrPg1pto+QF55GEEjBXMgkgANxz8PGovG+3StMoqgSMVjOzYZsmbbninBd4x2otqZxsA1e0tqk3tbXl8TnNR753rzk3gFxOW729R0Po5HN87DcifDMmhBBCMoadMSGEEJIx1CvqhDT5eTTbjYQ0ZjSzC0xs2vW/+dKovO7MZ9mjecdqmVfZLG88sLs6NVbs2FENRlCamYrKjx7wc6Banndib+o2Qo5n/DjMJqaxZ1vJXr8dBT/oznNO0NkMxaJ6N9tznLdVcwi/4FSVppty/swIO9PBzqbo6lJbHjExr392+IGofPiQP+TUYqTx09edEpXzoo99L2Z+7HJXU0CN4wG+GRNCCCEZw86YEEIIyRjK1HVCevwYrOe/6fVR2Q2pF6RsUckLRtqenVUpuikWg7a3d11UbjNel/PzvtfnMY58/tNReffRKW/blhb14Gx59WsS9ydk1WLla2+Sgy5YL2cAOKVbbfakX9DY0laCLhhpGPPGSzvnS8E27nRrq9ry3Jza8vicDjl9d9d9UXl2UmdVAMCGE/RYXSa9oSV5HgfJgoo6YxF5EsBRAPMA5pxzO0SkD8AXAWwH8CSAK51zw2nHIIQ0BrRnQhqPpcjUv+qcO885tyNcvhbATufcGQB2hsuEkOMD2jMhDcRKxowvB3BjWL4RwBUrbw4hJCNoz4RkSKVjxg7Ad0TEAfhH59z1ADY55w6E2w8C2FSLBq5WpGtdYjmNqSkd221p8adD2CkQMybvqjc1wQwOfe9+PxqY5fR+nVoVn45FVg20Z0PqFB5JXshLLFeveYym5UO25/Bt2bexfE7Ho20O5RJ0ytODgw9H5dEhHT9Gs9+uszeegCRscgjSOFTaGb/AObdPRDYCuE1EHrYbnXMuNOwFiMg1AK4BgJ6enqQqhJD6six7pi0TUjsqkqmdc/vC/wMAbgZwAYBDIrIZAML/Ayn7Xu+c2+Gc29HRnpwSjBBSP5Zrz9aW2ztoy4RUk0XfjEWkA0DOOXc0LL8YwF8CuBXAVQDeH/6/pZYNXevYaUrDw37UrHxepa3+/v6oPDU9HZXnHrtX9x+fiMqlmKzWfs72FbeVNC6059pSSdQqG2VrJGbLdsipv09teXRS6z106EBUnhxTW27t1cQwALClU2VqMe9d4iXASC6T+lOJTL0JwM1haLcCgM85574lIncD+JKIXA3gKQBX1q6ZhJAqQXsmpAFZtDN2zj0O4NyE9YMALq1FowghtYH2TEhjwghcxyGlku8Nab0uCwWNztW3TmWr7998R1SeN8p0b8F3GxAvIQUhpNpYj+t4buTijNpyvmAifbVrQodDNiFEi9rvGSdt9o7V36oyd8HkMBaxknVyu4JtlK3rCWNTE0IIIRnDzpgQQgjJGMrUq4DpaQ0Q39qqQQQmHtdcp7v2JAf6+G+/9AxvWXo3Vrl1hKxNrOybFoDHz6sMzMyoLTeb4D4P7n80Ku95ck9U7unRBBC/euLzvGO15n3v6mTSEmMAVKnrC9+MCSGEkIxhZ0wIIYRkDGXqVcDs7GxUPnjwUFSWwSNReXpOvTGbbT5kE1iAEFI9Kot57WNt+dAhteW9Rw5H5VJJbbmzUyOhNef8ONf2/C5lPT2mGwe+GRNCCCEZw86YEEIIyRjK1KsAG7d6ZkbjUTf97GdReeNG9ZI+EVo/d9Zzatw6QtYmad7U5aRhG7d6anoyKo+aOPMbT9Dslv3rNXtWPuc/zr3gHs5z4V6s6SQD+GZMCCGEZAw7Y0IIISRj2BkTQgghGcMx41XGyMhoVG7apzlQbWSf9c/oq2ubCCFLZ3hkOCpPT6n9zsxqMomjR49G5dIJOuUJYN7i4w2+GRNCCCEZw86YEEIIyRjK1KuMmeGBqPxvP304KhetgnXhlXVsESFrk+XIwXY6lJ2muP/A/qg8fnQsKnd3aTKJeefnRrZnzwsf9Y0O34wJIYSQjGFnTAghhGQMtYvVhom605JToapYMhF4clrHHVWPTQCQrnW1axshxJOi4zmES9DxpJl5lam7TJ7yUZPnuFjUxBKD05oYBgDWt26IyjnJR2V6UzcmfDMmhBBCMoadMSGEEJIxlKlXGdLeFZV/oactKv94UIPO7/2/n4zKW887yd//V15ew9YRsjYpJ01bcub9qLOpOypffKImdHmi56moPDmrUraVtQFgzqmE3YRmkMamojdjEekVkZtE5GEReUhELhSRPhG5TUQeC/9zsJGQBoe2TEhjUqlM/REA33LOnQ3gXAAPAbgWwE7n3BkAdobLhJDGhrZMSAOyqEwtIj0AfhnAGwDAOVcEUBSRywFcHFa7EcAdAN5Ti0aS5dF7xWVRed0/fzUqbz61PyrLRS+ua5tIdtCWs8PzYK7QmTnn9F2pp1nFinP7e6OyVbzjaYqt5G1zG5PGpJJP6BQAhwF8WkTuFZFPiEgHgE3OuQNhnYMANqUegRDSCNCWCWlQKumMCwCeDeDjzrnzAUwgJmM55xxS3BJE5BoR2SUiuyYmJ5OqEELqQ9VseXKCtkxINanEm3ovgL3OuTvD5ZsQGPAhEdnsnDsgIpsBDCTt7Jy7HsD1ALB1y5YyfoSk2uQ2qaf0he/6owxbQhqEqtnylq205VojYtMe5s2GDBpDas6ib8bOuYMA9ojIWeGqSwE8COBWAFeF664CcEtNWkgIqQq0ZUIal0rnGb8VwGdFpBnA4wB+F0FH/iURuRrAUwCYCoiQxoe2TEgDUlFn7Jy7D8COhE2XVrc5hJBaQlsmpDGhvzshhBCSMeyMCSGEkIxhZ0wIIYRkDDtjQgghJGPYGRNCCCEZw86YEEIIyRgJot/V6WQihxGE4DtSt5M2Huuxdq9/LV87sLTrP9k5t6GWjVkJoS0/hbX9ma7lawfW9vVX3Zbr2hkDgIjscs4lzXNcE6zl61/L1w6szutfjddUKWv52oG1ff21uHbK1IQQQkjGsDMmhBBCMiaLzvj6DM7ZSKzl61/L1w6szutfjddUKWv52oG1ff1Vv/a6jxkTQgghxIcyNSGEEJIxde2MReQyEXlERHaLyLX1PHe9EZETReR2EXlQRB4QkbeF6/tE5DYReSz8vy7rttYKEcmLyL0i8vVw+RQRuTP8/L8YpvFblYhIr4jcJCIPi8hDInLhavrs15ItA7RngPZca3uuW2csInkAHwPwEgDnAHitiJxTr/NnwByAdzjnzgHwfABvDq/3WgA7nXNnANgZLq9W3gbgIbP8AQAfcs6dDmAYwNWZtKo+fATAt5xzZwM4F8F9WBWf/Rq0ZYD2DNCea2vPzrm6/AG4EMC3zfKfAPiTep0/6z8AtwB4EYBHAGwO120G8EjWbavR9W4Lv6CXAPg6AEEwSb6Q9H1YTX8AegA8gdAnw6xfFZ/9Wrfl8Jppz7Tnqn729ZSptwLYY5b3hutWPSKyHcD5AO4EsMk5dyDcdBDApoyaVWs+DODdAErhcj+AEefcXLi8mj//UwAcBvDpUNb7hIh0YPV89mvWlgHac7hMe67yZ08HrhojIp0Avgzg7c65MbvNBT+pVp07u4i8HMCAc+6erNuSEQUAzwbwcefc+QhCwHoS1mr97Fc7tOc1SV3suZ6d8T4AJ5rlbeG6VYuINCEw3M86574Srj4kIpvD7ZsBDGTVvhpyEYBXiMiTAL6AQNr6CIBeESmEdVbz578XwF7n3J3h8k0IjHm1fPZrzpYB2jPtubb2XM/O+G4AZ4QeeM0AXgPg1jqev66IiAD4JICHnHN/bzbdCuCqsHwVgrGnVYVz7k+cc9ucc9sRfM7fdc69DsDtAF4VVluV1w4AzrmDAPaIyFnhqksBPIjV89mvKVsGaM+059rbc72zNr0UwdhDHsCnnHN/VbeT1xkReQGAHwC4HzrO8qcIxpm+BOAkBFlvrnTODWXSyDogIhcDeKdz7uUiciqCX9Z9AO4F8NvOuZks21crROQ8AJ8A0AzgcQC/i+DH76r47NeSLQO052PQnmtnz4zARQghhGQMHbgIIYSQjGFnTAghhGQMO2NCCCEkY9gZE0IIIRnDzpgQQgjJGHbGhBBCSMawMyaEEEIyhp0xIYQQkjH/H7WYy5M1RL+mAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overlay_pred_true():\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    plt.imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    plt.imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAG1dJREFUeJztnWtsXMd1x/9nl68lRYqkVpSoJ2VJfj9km/GjDgxHjlM1DWJ/SN08UAipCgFtWjhogMRugbYB+iH5kseHIoEQpxECN7brPOwYbhJHsdGmqR+0LVuSZVmynpQoUZQoipT45umHvbozc00ul8u7L87/RxCce2f23rO793DOmTlzRlQVhBC/SJRaAEJI8aHiE+IhVHxCPISKT4iHUPEJ8RAqPiEeQsUnxEPmpfgiskVEDojIIRF5NC6hCCGFRfIN4BGRJID3ATwAoBvA6wA+p6rvxiceIaQQVM3jtXcAOKSqhwFARJ4E8CCAGRU/nU7r2rVr5nFLQkg2Dh36YHxgYKBmtnbzUfyVAE5Yx90A7sz2grVr1+CVV34PAFAwVJiQuLn5pttGcmlX8ME9EdkuIl0i0tXX11fo2xFCcmA+in8SwGrreFVwzkFVd6hqp6p2ptNpaPBDCCkd81H81wFsFJF1IlID4LMAnotHLEJIIcnbx1fVCRH5WwC/BpAE8ENV3RebZISQgjGfwT2o6gsAXohJFkJIkWDkHiEeQsUnxEOo+IR4yLx8fELmj5nandKpGVuJmD5KIAWVyAfY4xPiIVR8QjyEik+Ih3jv4xfCX2RIMmD77vbS7+hnMzI5HJYHxwedulRVKizXJxvCclKS7q1k7t/hh1/h17gBe3xCPISKT4iHeG/q0yyPh4mpced4dNIsC780cSksD4wNOO1ODfWG5ZGJCaeuY/HysNze0B6WaxO1M8oxMukuR7fvfW74XFhuqG5w2q1oWDnj9e2pxIXCwntHhJBZoeIT4iHem/oLjXxmKfJ1d+xIu5OXup267qGesHxq0Jj3l0fGnHYT45NhOTo4PzJh3IfLE2b0v6G63mlnv+eD/a4cF4aN6T8xblyJFc2LnXYttS1huba2DjOR7fOtJLeRPT4hHkLFJ8RDqPiEeIg3Pv5Mvtlc/DL7GnH4c5UeNTihxgc/0H/UqTt+9nxYHhoy/vnUlCufHdVXXeVG5EnCfD5VCVO3otGVw/b5bZ8eAC5Z97bvHP2cqhJGFaKbzIjE+72XA+zxCfEQKj4hHrJgTf1CTLvEbeaVi9kY/axmlss9PzDWH5ZP9bsReQMXTcTcmDWNFjXna6qrw3Jz8yKnrq3JHLfWmfLy+mVOu/oqY+ovrnO3dhgatEx9y4S/MDLqtJuYcqMGbezPI9tzFbcrWEjY4xPiIVR8QjyEik+IhyxYH78SKOV0Xj7+aDQZ5qlLp8Ny/4Uhp25syPKhrbdZV59y2rUsMj5+x9glp65p0LxwcuBiWB46f8FpN7lkRVi+PO6uEhyxfHl7Wu7i0GWnXc9lE2K8qNqdL0xY/WMi0ldW6sq9WaUWkR+KSK+I7LXOtYrIiyJyMPjbku0ahJDyIpd/Vz8CsCVy7lEAu1R1I4BdwTEhpEKY1dRX1f8WkY7I6QcB3BeUdwJ4GcDXYpQrduKeXsnVTI/et5g54XO9V65Tn1FTf2DUmPejo66JrUPGNK9KmrrmyX6nXXWPeQSPivs41iaNSX9hxOTjq61yE2WkEu+F5UPdJ5y6vn4jR2OdcSuS99zptLOvP9Hovhc7x58kapy6mT653KdIS0O+DsoyVb3iFJ0GsCxbY0JIeTHvkQnNREXM+O9MRLaLSJeIdPX19c33doSQGMh3VP+MiLSrao+ItAPonamhqu4AsAMAbr/9tvKyd+ZIPmZ6sbd7ivt+tok6MOaOpl8cMQtiatRNsDF86nhYHm0ySS8mFze77ezyuDvS3mtH/CVNH9WSanLaHTp/Jiwf6XdTdI9fNKP650fM9eTVN912NcaNGW7d4NRVJYyLUB9J7Z1YqKP6M/AcgK1BeSuAZ+MRhxBSDHKZzvsJgP8DcI2IdIvINgDfAPCAiBwE8PHgmBBSIeQyqv+5Garuj1kWQkiRWFCRe3GvnKqE7ZjznS7M9TMYmzQ+8uGLR526Cwf2hOXze487dcOWMbneitYbHIskyhizEmpGou5qrZV8N7aYvPorFkd8/FPHwnL15KRTNz4+/dbbPZfd1XlHDpsoxJuvd8crauvNykDJY7suIPvzV4pVfZU5MkEImRdUfEI8ZEGZ+nFQyOmwQly/EEypMZcvjpsEG+MXz7kNB6zJuHo3F33SMuH7rWm/ZOT9L5o0U2yNS9xtrRJWzr3EDR1h+Xiy2mmXtPLvrxzb69QdtKb6YOX7G49s13V62LyXoT1vO3WpO+8Ly/m6kwslco8QUsFQ8QnxECo+IR7ijY8fh4810zVK6bfne+9s/uilCbPqbl/fgbB88f33nHb91uxbyyJ3P7uePhPe23vWlDta3LGA2tvvMOUa93GsqzUr4cYsv/7EWXeF37id9CM6e2d3bQlzMDXmTvtdHDDv+fJqN73EqDWlmYiE7FbPELIb/UztlY3lEOZbegkIIUWHik+Ih3hj6scRHbVQo/+iq6p7Lpn8c+//bldYPnnJnQKzI+hqI/nyW5cbc3l8w9VheXTMvUZzk3ERVja6K/caa0zd7h4TGXiuz83hr31mmvHokchC0Sqrb6uyvouk+720r2o115hyowtrRsz1WyM7aCeqrSQdVlRfNGlJNkox1ccenxAPoeIT4iELytTPttVRruZUPtslVTpTkd1hLw+ZTEmnh8zQ/dImd4ur5YuWhGWdche2LNrQFpa7J81j1hTZJmt9i2mXjIyYD0+Y0fT+c2ZmQLuPOu3GPjCuyXh1JP11g7l3XZ3J1be+yY0SbFhm5BiOLBY6N2Lu3VzruiPRp2z68+UHe3xCPISKT4iHUPEJ8ZAF5ePHzcKaspsZjYS7LUoYX9iOyIsmyugeMMkrmmrcz+Dc6PKwfP6CmX7TyHjChX4TMbc44v/f0Gqytq+oNZF23RNu1N3RlHmMN2xc6dRtsMYQWmrMXNzym9yEmslGM53XVr/UqauxPo/6qsgKwsi4REgkYYf9vsvhaWGPT4iHUPEJ8RCa+jFQCck2srktUXlH9p8My2cvmwQVJ46ddtpVDZsovIkqtw+56rjV1sqJj8tu5N45K+LvfMtip25v3/mwfHrEuBnJyL0aUsaEXxWJ/mtPmeMl640Jr5ZpDwBL6sxx1Jyvsrb2yrbAxv6Eoy5NucEenxAPoeIT4iFUfEI8ZMH6+HGseCr3rY6nI3cZZ97++uSQWQl34ogJh8WAG5Y7YU9ZpdxHabzRrNxrrDXTYd1jbsLOwUtmv7zksJvrfsKetrNCh6ciK+uGrLf8wXl3Y9Yl1oq8mtTqsNyacBN2NtcaH7/6Q1thm2tky6ufdcouz3z8hSKXLbRWi8hLIvKuiOwTkUeC860i8qKIHAz+tsx2LUJIeZCLqT8B4Cuqej2AuwB8SUSuB/AogF2quhHAruCYEFIB5LJ3Xg+AnqA8KCL7AawE8CCA+4JmOwG8DOBrBZGSxI5t3veOnHHq/vDu++YgYt7PRDKSL++W5casXte0ztx3jetW2Dn8RyZdU/+VUyZH/v59R01Fjdtf1Vur7qLTaGMtxmyfrDIyLk2lnXZ2dF7eOfHELpaXaR9lTu9QRDoA3ArgVQDLgn8KAHAawLIZXkYIKTNyVnwRWQTgpwC+rKoX7TrN/JuddlRJRLaLSJeIdPX19U3XhBBSZHJSfBGpRkbpn1DVnwWnz4hIe1DfDqB3uteq6g5V7VTVznQ6PV0TQkiRmdXHl8z8xeMA9qvqt6yq5wBsBfCN4O+zBZGwjCjFdsZxEZV3bMr40384/LpTd/zMoDlIZPFVrWm1qSnXdz82cDYsL6s3K+SiU2XjU2aabnLKDeftWGxCbI+1mOs1RnL419SaqbnmlJsN81KPWRlYu8asBEym3Uc/YU23ZfPPs4c+Vw65zOPfA+AvAOwRkd3BuX9ARuGfFpFtAI4BeLgwIhJC4iaXUf3fY+Z/ZvfHKw4hpBgs2Mi9QhB3ws445MjXLLW3hZJJ18ROLjbm8pIWE4G3aokbo5WqNib28oYlTl1bypj3dclUWF4k7vSgpMx03vHJS05ds5Uos2OFud5VzW1Ou8aaxrC8oXGFUzeiZvVfe69xM5o6Gp12Ekv0euUY+4zVJ8RDqPiEeAhN/QJTyiQd2e41aUXMDQ27W0ZVW8kxrm0zi1c2r7nRadc3bI3IS61Tt6jKmPdLq81jprdc7bQbtLarmuw95NRd3L0/LLekzPVGJl13ITlhFvo03bjaqRt/53BY7rFe1nzsfaedXHU9fII9PiEeQsUnxEOo+IR4CH38IpPPVN9cogRzjS6srzLRb4mkmxve3kuvb9T48U3XXOu0a60zefAnx91xAq01U4KTg/2mnHD7mokJM5U49t4Bp27IqhuftCID1b3Xant1XspNlJlOmSm83hHz2VzsHXTaNV8Fr2CPT4iHUPEJ8RCa+nOgVIt0CpH7r0pM1F1rixt112pNv/UPmWi60VPHnHapG+8xB5FtsnuHzWLNM2oWyiwZc99LTZ9ZfDM15Zrp1Vb+/CmY61dF3IXUerNt1viUu71WykqqUS7JMcohlyN7fEI8hIpPiIdQ8QnxEPr4FU6+IcF2QsmN6bVO3eG0maY72Gd8/PdOHnTa3XWD8fHtFXgAsCxlUjCORpJo2jRZK+vu3XSXU2e/t7PDZizg7Ei/026s2cqJn3Qf6ZqkmeoTcf3/XMnHBy+X8YSZYI9PiIdQ8QnxEJr6FUiu04rZ2tl1bfVuYotl13SE5T2n3grLv9jjRtatuutIWO5o3ujU2VtNX734mrA8oW7Sj0ST6XsSkX7IbnvitJkS3HfONdn1sNnyq+lad0pwpoC86shW23FPqZV7Tkb2+IR4CBWfEA+hqV9gCp1zby51DlY66eiI/G3rbw3Le/YcDcvn+p19VLD7f18Iy21b/sqpa6gyo/XJhHnMEuouCLLltbfTAoBhK8HG8X4zkn85kjikttYsxFkUeS9nh82sRNJ6z6mro06A/bm531k+3yFNfUJI2UHFJ8RDqPiEeAh9fIKkuH53eumGsPyJm9eH5Z/+Ya/T7vUPzPbaHzm136mrX/ORae9lb1UFAFNZXOGBMTOFd/68SZwxMemOBbSkTHRe47FTTt25KeP/b2wzEYnS1AqfmbXHF5E6EXlNRN4WkX0i8vXg/DoReVVEDonIUyJSM9u1CCHlQS6m/iiAzap6C4BNALaIyF0Avgng26q6AUA/gG2FE5MQEie57J2nAK5sM1od/CqAzQA+H5zfCeBfAHwvfhFJIbCnqKKmfn3S5ONbecMfheWWN93IvdMXzVRZ11u/d+paV5g89Q1Vloktbl9jLxZSuHIMTwyH5ZFRk4hDJ92deRtqzTUG+6O74Fr3k/JeOFNMchrcE5FksFNuL4AXAXwA4IJqGFPZDWDlTK8nhJQXOSm+qk6q6iYAqwDcAeDaWV4SIiLbRaRLRLr6+vryFJMQEidzms5T1QsAXgJwN4BmEbliV60CcHKG1+xQ1U5V7Uyn0/MSlhASD7P6+CKyFMC4ql4QkRSAB5AZ2HsJwGcAPAlgK4BnCyloOVDuYZjZyJbgMRHxu+0Q27S17fQ1na6hd+yFV8LyC13uXnRL1v5XWL775ofCsp0YIyOXdd+IHClr/z11Pnr3vbSdPR2WR5NLnbrahDWWsdZMTWb7JvMNs66k5yOXefx2ADtFJImMhfC0qj4vIu8CeFJE/hXAWwAeL6CchJAYyWVU/x0At05z/jAy/j4hpMJg5F4W4jDdSrlNdq5yRN+lnRCjPmkSW9xm59EH8NrLJklH/xl3S6pfPv3bsFy31Ez43L7iTqddlVhbaEckOXDe5PHXUZOUoyXd6LS7brI9LA9FVv9dtcaMK0mdnaSjcszyQsBYfUI8hIpPiIfQ1C8y+eyWGyXurbw+JIfYefAMHY3rnGaff/DjYfn7P/6lU3d+0ETaPfP4E2G5dnu1066tycwafDBw3Knbd6Q7LNc1mRH+h1ZscNoNHjduQHU0Oq/NuAGFGHWvpJF8G/b4hHgIFZ8QD6HiE+Ih9PErnGwReXFMHdqJM6oij8tN120Jy5vvfM+pe/F/zPG5PpM088ff/3en3bV/fG9Yvjzu+svj4ybhRvtSM4WnJy7DxaSC6Ghzp/pQ1wDyYdjjE+IhVHxCPISmfoWTa479uZj9M0X1JSIJO2qSpt946FN/49SdO/uNsPzmPrNws/+sa6a/85PfmOvVRPqhRcaEr+0w03InVrv5/NbWm/x5U+vdrbwSM3w+PizEyQZ7fEI8hIpPiIdQ8QnxEPr4nlCIVYL2NVI17jTan//ZX5p2CTOF98aR0067S1bezKlGd9+769aYcN472m8Ky621zU67tptMghBJuiHBM8mbL9mmTysJ9viEeAgVnxAPoalfQrInx6gsEzJqAre1mhV0f/3Ffw7Lg4M9Truet03evlPDbr785pqWsNxeZ3LzL990g3vzhsVzF9hz2OMT4iFUfEI8hKY+yUoc7keyykTgNbesdeqa7zPH1+V19fIh26xBublu7PEJ8RAqPiEeQsUnxEPo4y9g4s7hX+ikH+WyB8FcqAQZpyPnHj/YKvstEXk+OF4nIq+KyCEReUpEama7BiGkPJiLqf8IgP3W8TcBfFtVNwDoB7AtTsEIIYUjJ8UXkVUA/hTAD4JjAbAZwDNBk50AHpr+1WQmJPKTrS6fn2LKXwjU+iHxkmuP/x0AXwVwJaZyCYALqnplJ4NuACuneyEhpPyYVfFF5FMAelX1jXxuICLbRaRLRLr6+vryuQQhJGZy6fHvAfBpETkK4ElkTPzvAmgWCbc6XQXg5HQvVtUdqtqpqp3pdHq6JoSQIjOr4qvqY6q6SlU7AHwWwO9U9QsAXgLwmaDZVgDPFkxKQkiszCeA52sA/l5EDiHj8z8ej0iEkEIzpwAeVX0ZwMtB+TCAO+IXiRBSaBi5l4Vcp6kqMeKsHOHnVjwYq0+Ih1DxCfEQmvp5wmgyUsmwxyfEQ6j4hHgIFZ8QD6GPnwVO05GFCnt8QjyEik+Ih9DUnwO5TuFla0d3IT9y/ez5+eYGe3xCPISKT4iHUPEJ8RD6+KQioO8eL+zxCfEQKj4hHrJgTf1s2z3FcU2uziOVDHt8QjyEik+IhyxYUz8OCjGSHPcOs4TkA3t8QjyEik+Ih1DxCfEQKj4hHpLT4F6wYeYggEkAE6raKSKtAJ4C0AHgKICHVbW/MGISQuJkLj3+x1R1k6p2BsePAtilqhsB7AqOCSEVwHxM/QcB7AzKOwE8NH9xCodYP+WCRn6y1cX9Q/wmV8VXAL8RkTdEZHtwbpmq9gTl0wCWxS4dIaQg5BrA81FVPSkibQBeFJH37EpVVRGZthsJ/lFsB4A1a1bPS1hCSDzk1OOr6sngby+AnyOzPfYZEWkHgOBv7wyv3aGqnaramU6n45GaEDIvZlV8EWkQkcYrZQCfALAXwHMAtgbNtgJ4tlBCxo3k+BNlIfnI9P/9JhdTfxmAn4vIlfb/oaq/EpHXATwtItsAHAPwcOHEJITEyayKr6qHAdwyzflzAO4vhFCEkMLC1XnkQ5R7DnvuWzB/GLJLiIdQ8QnxECo+IR6yYH18bnFdePKZ+iv098DvPTfY4xPiIVR8QjxkwZr6UWZKcpnNNCx2FJsPUXPl8pnG5QIU+vqFgj0+IR5CxSfEQ7wx9W2ymZs+mNuE3zN7fEI8hIpPiIdQ8QnxECo+IR5CxSfEQ6j4hHgIFZ8QD6HiE+IhVHxCPISKT4iHLNiQ3Wyro3wP1ySEPT4hHkLFJ8RDFqypT3OelJJyf/5y6vFFpFlEnhGR90Rkv4jcLSKtIvKiiBwM/rYUWlhCSDzkaup/F8CvVPVaZLbT2g/gUQC7VHUjgF3BMSGkAshlt9zFAO4F8DgAqOqYql4A8CCAnUGznQAeKpSQhJB4yaXHXwfgLIB/F5G3ROQHwXbZy1S1J2hzGplddQkhFUAuil8F4DYA31PVWwFcQsSsV1UFph/NEJHtItIlIl19fX3zlZcQEgO5KH43gG5VfTU4fgaZfwRnRKQdAIK/vdO9WFV3qGqnqnam0+k4ZCaEzJNZFV9VTwM4ISLXBKfuB/AugOcAbA3ObQXwbC43lOCHEFI6cp3H/zsAT4hIDYDDAL6IzD+Np0VkG4BjAB4ujIiEkLjJSfFVdTeAzmmq7o9XHEJIMWDILiEeQsUnxEOo+IR4CBWfEA8p+uq8cl+1RIgPsMcnxEOo+IR4iGTC7It0M5GzyAT7pAGUOnC/HGQAKEcUyuEyVznWqurS2RoVVfHDm4p0qep0AUFeyUA5KEep5KCpT4iHUPEJ8ZBSKf6OEt3XphxkAChHFMrhUhA5SuLjE0JKC019QjykqIovIltE5ICIHBKRomXlFZEfikiviOy1zhU9PbiIrBaRl0TkXRHZJyKPlEIWEakTkddE5O1Ajq8H59eJyKvB9/NUkH+h4IhIMsjn+Hyp5BCRoyKyR0R2i0hXcK4Uz0hRUtkXTfFFJAng3wD8CYDrAXxORK4v0u1/BGBL5Fwp0oNPAPiKql4P4C4AXwo+g2LLMgpgs6reAmATgC0icheAbwL4tqpuANAPYFuB5bjCI8ikbL9CqeT4mKpusqbPSvGMFCeVvaoW5RfA3QB+bR0/BuCxIt6/A8Be6/gAgPag3A7gQLFksWR4FsADpZQFQD2ANwHciUygSNV031cB778qeJg3A3gegJRIjqMA0pFzRf1eACwGcATB2Fsh5Simqb8SwAnruDs4VypKmh5cRDoA3Arg1VLIEpjXu5FJkvoigA8AXFDViaBJsb6f7wD4KoCp4HhJieRQAL8RkTdEZHtwrtjfS9FS2XNwD9nTgxcCEVkE4KcAvqyqF0shi6pOquomZHrcOwBcW+h7RhGRTwHoVdU3in3vafioqt6GjCv6JRG5164s0vcyr1T2c6GYin8SwGrreFVwrlTklB48bkSkGhmlf0JVf1ZKWQBAM7sivYSMSd0sIleWahfj+7kHwKdF5CiAJ5Ex979bAjmgqieDv70Afo7MP8Nify/zSmU/F4qp+K8D2BiM2NYA+CwyKbpLRV7pweeDiAgyW5HtV9VvlUoWEVkqIs1BOYXMOMN+ZP4BfKZYcqjqY6q6SlU7kHkefqeqXyi2HCLSICKNV8oAPgFgL4r8vWjMqexnu1nRfgF8EsD7yPiT/1jE+/4EQA+AcWT+q25DxpfcBeAggN8CaC2CHB9Fxkx7B8Du4PeTxZYFwM0A3grk2Avgn4LzVwF4DcAhAP8JoLaI39F9AJ4vhRzB/d4OfvddeTZL9IxsAtAVfDe/ANBSCDkYuUeIh3BwjxAPoeIT4iFUfEI8hIpPiIdQ8QnxECo+IR5CxSfEQ6j4hHjI/wOd3AhJEfDWVAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "overlay_pred_true()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mimicking sequence-to-sequence by shuffling in predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXuUnFWV6H+7qp95dpJOQkiCCRCIASUEUBHUAMpDQVyIqHC5MRONcxVX0HEcuIMLHB7iY+Ew63JHIgzgkuEhIrC48tAAF/B6g5GHV5IQISQmIWnyTjqPfp77x3l8p7qqu6u7q7q7vuxfVqe+Oud8X+2qPn1qf3vvs7cYY1AURVEqn8xQC6AoiqKUBl3QFUVRUoIu6IqiKClBF3RFUZSUoAu6oihKStAFXVEUJSXogq4oipISBrSgi8i5IvKGiLwpIleVSihFGWp0biuViPR3Y5GIZIE1wCeAjcAfgS8aY1aWTjxFGXx0biuVykA09A8Abxpj1hpjWoH7gQtLI5aiDCk6t5WKpGoA504FNkTPNwIf7OkEEdE8A0pZMcZICS7Tp7nd2NhojnjPESV4WUUpzCsvv7LNGDOxt3EDWdCLQkQWA4vL/TqKMpjE83r6EdN5cfnzQyyRkmZGVo9eX8y4gZhcNgHTo+fTXFsOxpilxpiTjTEnD+C1FGUw6XVux/O6sbFxUIVTlO4YyIL+R2CWiMwUkRrgC8BjpRFLUYYUndtKRdJvk4sxpl1ErgCeArLAfxhjXi+ZZIoyROjcViqVAdnQjTG/AX5TIlkUZdigc1upRHSnqKIoSkrQBV1RFCUl6IKuKIqSEnRBVxRFSQm6oCuKoqQEXdAVRVFSgi7oiqIoKUEXdEVRlJSgC7qiKEpK0AVdURQlJeiCriiKkhJ0QVcURUkJZS9woShK+jHkFiPLrVXctVCZ5B9J3FaKolOHJqqhK4qipARd0BVFUVJCryYXEfkP4HzgXWPM8a5tPPAAMANYB1xijNlZPjEVpfTo3O4f3rwSm1U6TDsArR0HAdjZuiP07WjZDiSmlPG1E0LfOHdcm60LbVlRS3B/KUZDvxs4t0vbVcAyY8wsYJl7riiVxt3o3FZSRK9fhcaY50VkRpfmC4H57vge4Dngn0ool6KUHZ3bvWNMJwAdpiO0HejYB8DaPW+Gtv+7ZQUALe2tAJw0+YTQd2zDsQCMrBoNQFayoS+bsUtQJmpT+k9/beiTjTGb3fEWYHKJ5FGUoUbntlKxDNhYZYwxItI1LikgIouBxQN9HUUZbHqa2/G8nn7E9EGVazBo72wDYF2z1cKXLPu30Pfan23bmFEjQtvfnfkxAC46+nwAJtQ2hj5vH6/J1ALdhCVG9njjujV8se/0V0NvEpEpAO7x3e4GGmOWGmNONsac3M/XUpTBpKi5Hc/rxsbGQkMUZdDp74L+GLDAHS8AHi2NOIoy5OjcViqWYsIW78M6iRpFZCNwLXAz8KCILALWA5eUU0hFKQc6ty0+DHF/297Qdutr/24fH3kSgOaNu0JfprEegMXnzQ9tFx/9aQAm1Nm7lbpsYo6pylQDiQklZ1ep6dZaG8ap6aV4ioly+WI3XWeVWBZFGVR0bitpQyP4FeUQp62jBYCfrbwrtN34n4/Yg03N9rGhNvRdcdHZAPz9+xaGttHVY4HEASr0kJsldoAWkEf18f6jW/8VRVFSgmroinIIEtuxt7dsBeD23z6TDPCaeZXV+T7+yQ+Grq+f8CUg0coBarJdQhKj7InhtQrYy8WNUzt5aVANXVEUJSXogq4oipIS1OSiKIcgcabEFza/AMDf/ropGdBu+ye9bwoAP57/9dA1oXYikJhZADJeN3QmFFPIvOIfRfXIcqGfrKIoSkpQDV1RDkF8/nKAX61ebg/2tCYDxtQAcMfCKwGYNvI9oSvJXR45MoNm3lng1fIdpUp5UA1dURQlJeiCriiKkhLU5KIohxDeJNLWmZhXmnbstgeZxCRy+LHWGXr8+PcBST4Wi0T/hwt329eTE1TztZQW1dAVRVFSgmroijJMKZidcIB0kK+hHzjQkjfuPTOshl6XtZkVM5GW7Xd35uz87NoW7xR1dwWFM7hIzoM9VG29v6iGriiKkhKKyYc+Hfg5traiAZYaY24VkfHAA8AMYB1wiTFmZ/lEVZTSUilzuxiNtTct3mvJvrTc1oNNoW/DJpvLhZakEPSRjeMBqM7Y8MWcIs5OC2+PQh/bOlpz2uLwRa/dV7lrVUmy7PiC0bGyb8gNfczJ3KibknqkmE+nHfgHY8wc4EPA10VkDnAVsMwYMwtY5p4rSiWhc1tJFb0u6MaYzcaYl93xXmAVMBW4ELjHDbsH+Ey5hFSUcqBzW0kbfXKKisgM4ERgOTDZGLPZdW3B3rYqSkVS6XM7Nkt480tshul0ZozWjoMA3PfGI6Fv91vb/ImB/zb3YiDeFZqwt30PAPeveSC03fWH5wF4911rmWpoGBX6Lj31VAC+9N5LARhfNyn0+Rwwsax+F2unM9tkIxONukt7pmiDlIiMAn4FXGmM2RP3GZuJp6ART0QWi8gKEVkxIEkVpUz0Z27H83rbtm2DJKmi9ExRGrqIVGMn/L3GmIddc5OITDHGbBaRKcC7hc41xiwFlrrrlC7+SlFKQH/ndjyv5500r2Tzur8he4Wcoh0mcXK2uzDFVbteB+Cup59PBu61fdXHTghNs8bOBhINel9UQPriX/8jAL//TaSj7XJhkPXWydl8VHKt0TW2YLR3sMYe0A46nKyJg7Xre4mdpCZsXFJdvRC9auhig07vBFYZY26Juh4DFrjjBcCjpRdPUcqHzm0lbRSjoZ8GXA78PxF51bX9d+Bm4EERWQSsBy4pj4iKUjZ0biupotcF3RjzIt37Is4qrTiKMnikYW4XMrX4GPCWjgOhbVfLDgD++Zm7AWh6K4lDp9reqH/+nA+HphpnHtnTtguAy35zTej7/cMu3W5zW3KNWhenPtqed/jkxOQyd+Lx9pquIEZnjgnFEseX+yPRfY99Rj8xRVGUlKC5XErEMcccA8CiRYtC28KFCwHYuHFjaHvyyScB+PGPf5x3jeZmW2m9tbU1r09RisVrwM1tScDO23vXArBy1br8Exqs5rxyw+bQ9G9//p8A/Px/vwjAWy+uiV7A6tWj5h4WmubMngFAU5O9E/jw8bNC38wxRwLJbtNCHuTOyIHrHZ5Zp7XnZG5UZ2iPqIauKIqSElRDHyALFthgiGuvvRaAGTNm5I1pbGwMx3PnzgXgqqvyd5PfddddAFxzjbVXbt68OW+MohQid2OO1Xb3tTWHttYOa++ur7U27t0NSYFndtlsiy///vXQ9PLyVfbgnX32McqeePO//D0Alx37+dC2vMna1ZfcdzsA63fvDn0tHfb6QfMmztxojzvJz+ao2njfUQ1dURQlJeiCriiKkhLU5DJATjvtNKCwqaWveCfq0UcfDcC5554b+g4cOFDwHCX9iOSbHozpvnSbdz421I4LbRPbrelk4sQGAJq2J9mAzb4o/NDTYXIeP/Klj4SuRXPsPI1zrDy3we4a3bR2ix0/772hb2yNlcPvFI1lTkIYCxS9UPqMauiKoigpQTX0AXLLLXbHuNegffhidxx11FFAooUX4iMfsdrQ/PnzQ9sTTzwxEDGVCiF2bva3sEXGnVeTSTIlbtr3DgDbt1tnpWmK7vi8Nl4XLQeuJnTD8TY08afn/GPo8gWjX9/xWmi77eGn7cFuG3J76ZxkX1ZtxjpgfaGLzqj4RVIIo8BdiBaQ7jOqoSuKoqQEXdAVRVFSgppcBsjq1asBWLJkSVHjJ0+2tRIOO8zeyl5//fWh7/zzz88ZG8eqP/vsswAcPHiw/8IqFY0xxWbptSaKTJQfZcs+mwH4QIvbhRzVDy24dXOsdWD+8LL/CsDk+imha2+rze/y2duvTS7xlt2VWjXLOkDnjDsu9GUzdpkJ6XwLvI/Y8dvVxNJXM9ShjGroiqIoKUE19EGmqakp5/Gmm24KfV01dO8cBTjjjDMAdY4eSoRScj1o5smYxNHY6opZrNm9KrQ9uPIlAHbtcbtH25Lx4TinzWrTd7/8AgA7DiQ7P//Hk9YB2rR8fTK+ymrO3/svnwNgRNXI0OWzJoZQyzgM0721nPco/kF3jPYV1dAVRVFSQq8auojUAc8DtW78Q8aYa0VkJnA/MAH4E3C5MUbTBPaRl156KRx77fu8887LG/fxj388Z4wycCplbhfS1H3JttZOmyflr7tXh75frHwMgGdeS9rWvG0zfpq/OQ09tqF7svma8P955hX7+L+icnO77Wt6rRzg69/6LAALZl8GwKjqMaHPbx7y5exybeghI3q+PEqfKUZDbwHONMacAMwFzhWRDwE/AH5ijDka2Aks6uEaijIc0bmtpIpeF3Rj8Wnbqt2PAc4EHnLt9wCfKYuEilImdG4raaMop6iIZLG3nkcDtwFvAbuMCaW6NwJTyyJhypk0aVI4nj179hBKcmgyXOZ2oR2f3jThw/28eQXgYMd+ANo6bR6W7Qe3h76t+21fZ2fi5PQhjB0uHDE2lzDS7vwcOXl0aDpqpn3LF807EYC9rftDn0+N+6X3JbmGTp74AQDqsvVAriMzeW8m+j+XgvlqEo9pNE7dfj1R1KdjjOkwxswFpgEfAIpeeURksYisEJEVvY9WlMGlv3M7ntfbtm0rq4yKUix9Cls0xuwSkWeBU4EGEalymsw0YFM35ywFlgKISLE7I1LF+PHjw/Hhhx8OJCGJ55xzTuibOXNmt9fwmRfvvPPO0LZy5cqSynko09e5Hc/reSfNK928jrRRr6F6zXzjviRMcGOzFWl8nd3Is2HvO6Gv3Wnm9SOSXC5TD7NFVkYdbTXosQ2jQt95x9pNQGcdcXpomz7yCABGVI3KkQWSXCy+6DNAlcu8WCjEULro5DljiilmUUB7VwrTq4YuIhNFpMEd1wOfAFYBzwIXu2ELgEfLJaSilAOd20raKEZDnwLc42yNGeBBY8zjIrISuF9EbgBeAe7s6SKHCuPGJTmofSHoU045JbQdf/zx3Z7r7YiFNmC89702v/RrryUZ7q644goAbr/99oGKfagyfOa2+50n+cGho9Oa8fe4rfYvb3019P32bXu8ee9eADasbwp9u5utvbujIwlNnDzRzsslZ9qQ2PlTPxb6JtXZNBSxfTrTxVYdZ0jMhOLNPdi9c9rceX6jkNrBy0avC7ox5s/AiQXa12JtjopSkejcVtKGflUqiqKkBM3lUiK8qeXee+8NbXEJuWLomrOjUA6PbDYbjm+99VYA3nrrLQB+97vf9en1lKElx9HoTC0+DNEeW2doc7s1q9Rma0JfXZX9093XbAtV7NufZOGsylg9bUJDEoZ45vtt8M4ZU+cDML5uYuirds7NgiYUZ2qJTTDeZBLnj/HvJWRUjOhqvilE4TBHpa+ohq4oipISVEMfIGPG2JwV9913HwBnn312v6/Vk1O0kLZeU+NyVv/whwBccMEFoW/TpoJRpMpwIg5R9E7RSMP1uU9qs3XuMQkTbOvI1YRHRiGKdfV23JixScbDcXX22N8BtHcmqWk6XfHmTKTfdXjnbKFMj07GWJPuqlXH15IuemOh/OaqlZcG1dAVRVFSgi7oiqIoKUFNLgPkU5/6FNCzqSWOHb/55psB+M53vgPAiScmUXNdzSp/+ctfwvH27TZXx0c/+tG868+dOxeAhQsXhrYbbrihuDegDDqmQE4T7xQtGMft5kVWEod4tXOOeyd5dU3yp9zRbk0iGze8G9oe2mbzr7R0WFPLGUecGvpOmGDnj98V6qUEaHex8D53TCzjyKrE6ZrEpmd8Q/77cI+SU8yie5OLFrboO6qhK4qipATV0AeILw1XiPZ2q918//vfD20PP/wwAN/85je7Pc/v8Pvc5z4X2hoaGgB46qmnQtvo0aNzzvNFMOLX7OgoUMhAGXZ4Z+j+9ubQ1txmj1/e+jIAj65ZHvpeX2sLVuzYYYszt7S1hz6fZfFgSxICOWb0CAC2H7Bhjm/v/lvom1xvM35OGZEklfSFnQ+07wNg3d63Q593zh4z9r2hzWvmiaYe45z8obZcoXwvqo2XAtXQFUVRUoJq6GXkl7/8JQAPPvhgaPOFoD/wgfyd5T5M0Wvvq1evzhszdWqiRe11eTy8jTW2r1911VUA3HjjjUXJ+rGP2dwezz33XGjzmt4JJ5wA5Nr0lVJjf/f72xNbtc9x/odN9nNftS7JqLjxna0ANO9x4/cnGnooLxdpwtvd3eJfNthr+I1JAI31dlPcPqeNA0yqnwxA0/4t9rV3rEn6RtjMjUeOmRXaspK7lMQad572XcCGXiymq7av5KAauqIoSkrQBV1RFCUlqMmljPj8Lr6oBcD3vve9bsc///zzADzwwAPdjmlpScqQ/eIXvwDgsssuyxv31a9+FYA77rgjtDU1NeWN81xzzTVAbtmyHTt2ANDc3FzwHKX0HIhMLlsPWLOKd2TGtHe431NLAaf3GF9mLtLX3LgVf3oDgNVrEqfoq8dZM8z7p04JbYve91kAdrfacMe9rYk55six7wFyd4N2Tanb887PyFzi88H0YHrp0Xyj5KAauqIoSkooWkN3RQBWAJuMMeeLyEzgfmACtsju5caY1p6ukUa84/PLX/5yXp/Ptvjiiy+GthkzZnR7LV8QY+vWrd2OaWtLQtEWL14MwLRp04DEsRm3jRqVbBbpqqHHIZenn346XfF3AOvWretWnkpn+Mxrq9HG2Ra3HbBO0SZ3h+Q3DAFUV9kNRQfrXem3bKK5VmVtW1sUtsg+d1xjz2upTZyoBw/Yu753nJMdYFfLLneavWMYXZPkhRlfl5RUTKTvPlNo13DF3JJ04k/Ia/PvyMQV61RD75G+aOhLsOW5PD8AfmKMORrYCSwqpWCKMkjovFZSQ1ELuohMAz4F3OGeC3Am8JAbcg/wmXIIqCjlQue1kjaKNbn8K/AdwG9NnADsclXRATYCUwudmHZ8bLZPVxvHiXt6MrM8+eST4fiFF17o02sfcM4yb+7xjlCAmTNnArBv376886pcDLLPQwNQXV0N5O4sfeKJJ/okTwUypPM6Nh5kXJ6WcbWJOWPSCFuEYorbEdwyITGh1NZZx2fzXmsSaYvMMW1u1+ie5sTBur8z1/mYiXKtHNhvTS7b9yZzZeuBbQDUV9UD8P7R00Pf9JHWKVoTpfPtyRQSzDHBrJJfzCJOFV3oSCmOXjV0ETkfeNcY86f+vICILBaRFSKyoj/nK0o5KOW83rZtW4mlU5T+UYyGfhrwaRH5JFAHjAFuBRpEpMppM9OAghUVjDFLgaUAIpK6LPabN28G4Gc/+xkA1113XVHn+UXg85//fGjbGzml+oIvQeczOPaG34l65ZVX5vUtX57kC3n66af7JU+FULJ5Pe+keX2a1yG0L1JAq9yfYmPd5NB28kSrHWddSOBbu9eHvnW77Q7OPztHty9FB7DXae2xhs5Bp8HXZb38oWvXbut0jTM27mm1bRPrG93jpNBXk8kvWdcZlaOzffETyRvfc1/uOHWEFk+vGrox5mpjzDRjzAzgC8AzxpjLgGeBi92wBcCjZZNSUUqMzmsljQxkY9E/AfeLyA3AK8CdpRGpMrnrrrsAOO6440JbnC3R4+3kF154IdB/rbw/eNv5Oeec0+2YQjIfYgzJvPaFl6sz1aHN5yc/bvzxAMwYMyP0/XX0mwDsa/0DAC+5fOcAGzbZPOj7/7YreYF2p0GPduXmMokud6DFRmV2diZa+/i6hhx54lzs7abNjY+KRDuN328wqopyu/hz/UYkiQtO+xDFAuUWBytvS5rK3/VpQTfGPAc8547XAvkZphSlwtB5raQF3SmqKIqSEjSXS4nYsGEDkOvkjI+HA3V1tjL8/PnzgdwQxZ/+9KcAbNmyZdDlUhLi/Ci1WesUnVh3GADjTfL7GuXKv7V2WnPJ65uTXcC1tdassn9yfTJ+hD0eWW/nQGwu8RzYfzAcb91v8/h4c8n4KJxyRJXfNRqbQrzZIt+sEt5TD/laupZfHAhpMqH0FdXQFUVRUoJq6IcQPlOjzy2zc+fO0LdkyZIhkelQRgpssOkJQ6JVdzhtPWQ5jLTfuhrryDx80oTQNnWq3aRUU1udN77eje+ItOTDRtrxvuBGXHij3eWbyWQTR6lxYYvZAkp41+LQplD0YgHHp4Yr9h3V0BVFUVKCLuiKoigpQU0uKWX27NlAktMF4KSTTgJg4kR7O/3UU08NvmBKIDazeKdgZ2RWCQYHZx6pIolRn+h2lH5imk3R/KHPfCj0bWy2DnrvMAWoy1pnqC9Y0dqR9O1vt7tMV21/K2/8ut0bAZgxOkm36+U2Jt+xWhgT/U+XmqL90ykLmWMOZWeoRzV0RVGUlKAaekppaLA7/e6///7Qtnr1agDGjBkDJAUsesNnXZw1a1Ze24033hjaNORxIORrvT70Lwn7I+rzWrt9bKhJHKCjxo3Nu1a7SyC5r83uTI5L3b2z35agq8kmdwBVGevwbO+0542tGRP6fC6XeDeox2eNLOTw9XchOZkVvbbeQ0hjIWJtPOw2Lar8XbpRDV1RFCUlqIaeUo455hggNx/63LlzgaRUnd8MFePHADz0kK3zENvhPV/72tcAaGxsDG3f/va3gSQ3vNIzuVpsftbB5Dg3twkk2Q29Ft8RbTrqcFp1Z9Tmzw25YqpGJH1OSx5RXRfaJrnsih+cYrXx8bXJHUByzei9+DzrXcrNxeO8PBLrkW5YJvdirktDGfuKauiKoigpQRd0RVGUlKAml5TiU+ROmpQUJvC5W8aNG5c3/sMf/jCQWwYvpDHtIc9GnG73zTdtStfvfve7/RX7kCdTIIzPm1M6TBI62NJh8654x2R71OfHF3SKtlsTXGyO8cwed3Q4nlhn583k+ikA1GRqkuu70MqcEnpd8rUUCmkM5xWaT7HD1+Q6gYs1sxzKzlCPauiKoigpoSgNXUTWAXuBDqDdGHOyiIwHHgBmAOuAS4wxO7u7hlJ+6uuT7HpHHnlkXv/Bg1ar8yGHV1xxRej70Y9+1O11H374YQBuuumm0Hb99dcDcN555w1A4qFnuMztxP1ZKINh/jMfHugfq3JCAfP1tEynHdciNp9PbciYCKPG2syNcTihL65RKJzQXz2b49zsocycH+L64mIZ3qkb3wUaXJ6aoPWr3lksffmkzjDGzDXGnOyeXwUsM8bMApa554pSiejcVlLBQL76LgTuccf3AJ8ZuDiKMizQua1UJMU6RQ3wtIgY4HZX8XyyMWaz698CTO72bGVQmDw5+RWccsopef2XX345AF/5ylcAuOWWW0KfrzEZF73wZhW/GzSOOT/77LNLJfZQM8zmdmx6yDW55NTpzOQWkojHZp3DszNyTPrxPkdLXTYxzyVmj3xHZqeLac9EZpIqF8seO3C71gHNkT2YUwr1dea1ebkzLs9uNpO870I7UZWEYhf0040xm0RkEvBbEVkddxpjjPuDyENEFgOLByinopSLfs3teF5PP2L64EiqKL1Q1IJujNnkHt8VkV9ji+g2icgUY8xmEZkCvNvNuUuBpQDdLfpKaVi0aFGP/a+88goAy5YtA3Irv3u8Vt71GGDhwoXhOBsVN/A0NTXltQ13+ju343k976R5ZZnXXcNF47JuiWPRaqpxGKIPb2ztbEnOdeN8+GKc1dE7N+Pdpsad668xIps4UY1bNuI7gI5wV5B/d5DI4M6Ppp13fOZmnrTnBmmiihgSStyphl6IXm3oIjJSREb7Y+Bs4C/AY8ACN2wB8Gi5hFSUcqBzW0kbxWjok4Ffu2/EKuA/jTFPisgfgQdFZBGwHrikfGIqpeC6664DCoc0rlmzBsjXygGOOuooAK699tq8vvXr14fjn//856UQczAZPnPba5yxedk9CZpzpEF3zZkSa9f725sBWLs3P7+5t3sf7EgKQvv8LvvamkObLwTt+6Qq0f1CVsMcDd1q/r48XY793tu9/aajzii3ehEhiTk5acKdiYYyFqLXBd0YsxY4oUD7duCscgilKIOBzm0lbejXnKIoSkrQXC6HEAsWLOi2z5taamtrQ9tFF10EwA033ABATU2Sz8ObWuKdonv27CmdsIcaPeTL8aaNNtMW2rzZw5tQYrOEz9eyq2VXaJtYb8sO1mbt73fHwR3JeGdq+dvejaFt7sT3A3DYCJvLRQqYRjoj+5A3tfjCGTXZZK6IC7dM0ugmJpdOp1PGu06TIMf8MMesD2mM4is0hDFBNXRFUZSUoBq6AsAFF1wAwNVXXx3a5syZkzNmxYoV4fjSSy8FYO3atYMgXfoJ2msUTthZYNNNGO/62kMmxshh6rRpX6QCYGS1dXL6DUX7oxJ0B5yDdFfL3kie3NeM7wC8Vu21coA9bbb4tM8COTbTEPqq3N1HexfHKUCV3zQUZXPsWlIuxr/vOKRTQxgTVENXFEVJCaqhp4hHHnkkHMeadjFccomNzIu1Ha8F3XbbbQB861vfCn1xigBl4IRNN1G4nyG3zFyWZDNXa5eNP3EGQ388Iioz57fM+/DFw1yec4AJdTalw6jqZPPQSBe2mCmg8yXhlIkt/GD7Afc6dnx1pHF7efzdh08dEPfF2njXkMycsnzu+qqTF0Y1dEVRlJSgC7qiKEpKUJNLinj11VfD8Te+8Q0ArrnmmtAWZ2Ps7tzHH388tN19990AvPPOO4CaWcqKMy/EJo4O5/fzJodqiUwVVfZPt9ZYE0q8M7MmY39P9ZHJxZvPfCm5bHXyp+/Prc0kIaveWVmTsdfPKUoRClUk15hUf5g7r9qdl1zLm0lqCuR3Sd5rfi4aL1ehghgx3gSk4YuqoSuKoqQG6akAcMlfTLMtKmXGGDPoatq8k+aZF5c/X/Lrho01XfKJx/jNPW2draGtw+VKifOIZ0OWQvuYk8vcPcbXMEE7rsobH1470ri9M907X7M9OFMLtcXX8nL4xzgPfJ276xDi3DJehvTqpyOrR/8pqqjVLen9BBRFUQ4xdEFXFEVJCeoUVZRhSnDy+cy6ORYLE3flOFN9Stq4zZtCkvwo+eReo2uumGgHq4vWlwEVAAAFLElEQVQnj3ePirN0VTmrqkTmnnxnpeT1ZaIhcQx7LLsdXyAOXXeKBlRDVxRFSQlFaegi0gDcARyP/XL/O+AN4AFgBrAOuMQYs7MsUipKmaiEud1VU4dYW3cascRary/rFu867V13i/Xcrg7M2Ckadqx20aTja+TsMO1Jgw5vJC6v5wphOGdo7OwMV5J8LV8pXkO/FXjSGDMbWxBgFXAVsMwYMwtY5p4rSqWhc1tJDb2GLYrIWOBV4EgTDRaRN4D5USHd54wxx/ZyLQ1bVMpKX8IWSzW3yxW22BNBgzb5OcMLhQd2tT0X/kMs1Jr/cfaY3dB/jD1o0IXkK3yp/HGFwicPBUoZtjgT2ArcJSKviMgdrqDuZGPMZjdmC7Y+Yx4islhEVojIikL9ijKE9Htux/N627ZtgyiyonRPMQt6FTAP+HdjzInAPrrcgjrtpuDXrjFmqTHm5GK+XRRlkOn33I7ndWNj46AIqyi9UcyCvhHYaIxZ7p4/hP0jaHK3o7jHd8sjoqKUjYqd2+L/SSbvJyPZvB8RsaYS9yPRT0Yy7if/vKQv+ZGe/nk5on/dyt7Lv0KvrfRMr5+QMWYLsEFEvA3xLGAl8Bjgi1QuAB4ti4SKUiZ0bitpo9iNRd8A7hWRGmAtsBD7ZfCgiCwC1gOXlEdERSkrqZjbGrqnQJELujHmVaCQDfys0oqjKIOLzm0lTahRSlEUJSXogq4oipISdEFXFEVJCYNd4GIrNta3kndiNFK58ley7NC7/O8xxkwcLGE8bl6vp7I/30qWHSpb/mJkL2puD+qCDiAiKyp5k1Ely1/JssPwl3+4y9cTlSw7VLb8pZRdTS6KoigpQRd0RVGUlDAUC/rSIXjNUlLJ8ley7DD85R/u8vVEJcsOlS1/yWQfdBu6oiiKUh7U5KIoipISBnVBF5FzReQNEXlTRIZ1FRgRmS4iz4rIShF5XUSWuPbxIvJbEfmrexw31LJ2h4hkXZ7vx93zmSKy3H3+D7j8JcMSEWkQkYdEZLWIrBKRU4frZ19J8xp0bg815Zzbg7agi0gWuA04D5gDfFFE5gzW6/eDduAfjDFzgA8BX3fyVlJ5siXYkmqeHwA/McYcDewEFg2JVMVREaXhKnBeg87toaZ8c9sYMyg/wKnAU9Hzq4GrB+v1SyD/o8AnsAWEp7i2KcAbQy1bN/JOcxPjTOBxbC2xbUBVod/HcPoBxgJv43w8Ufuw++wrfV47mXVuD57sZZ3bg2lymQpsiJ5vdG3DHhGZAZwILKfI0nvDgH8FvgOh9PsEYJcxpt09H86f/4DKHg4yFTuvQef2EFDWua1O0V4QkVHAr4ArjTF74j5jv06HXZiQiJwPvGuM+dNQy9JPBlT2UCkOndtDQlnn9mAu6JuA6dHzaa5t2CIi1dgJf68x5mHXPOzLkwGnAZ8WkXXA/dhb01uBBhHxOfCH8+dfSaXhKm5eg87tIaSsc3swF/Q/ArOcN7oG+AK21NewREQEuBNYZYy5Jeoa9uXJjDFXG2OmGWNmYD/nZ4wxlwHPAhe7YcNSdqi40nAVNa9B5/ZQUva5PcgOgU8Ca4C3gH8eagdFL7Kejr3t+TPwqvv5JNZetwz4K/A7YPxQy9rL+5gPPO6OjwReAt4EfgnUDrV8Pcg9F1jhPv9HgHHD9bOvpHnt5NW5PbRyl21u605RRVGUlKBOUUVRlJSgC7qiKEpK0AVdURQlJeiCriiKkhJ0QVcURUkJuqAriqKkBF3QFUVRUoIu6IqiKCnh/wORB3oCso7PZgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXmU3FXZ5z9PVa9JZ+9sJIEECGJECAkwCKiAyiJBPL4aV04mE43vKA5uwwszOOALIioH5cxxRiPIcmQEBHzhMLJoZJHzjsEIqBgSspCYkLVJQrbe684f997f71ZXdXd1d60/no+nrV/de+tXTxe3b771PPc+jxhjUBRFUWqfVKUNUBRFUYqDLuiKoigJQRd0RVGUhKALuqIoSkLQBV1RFCUh6IKuKIqSEHRBVxRFSQgjWtBF5CIRWSciG0Tk6mIZpSiVRue2UovIcA8WiUgaeA34ELAN+BPwaWPMmuKZpyjlR+e2UquMRKGfAWwwxmwyxnQB9wGXFccsRakoOreVmqRuBK+dAWwNnm8D/sNALxARzTOglBRjjBThNkOa262treboY44uwtsqSn5eevGlNmPM5MHGjWRBLwgRWQ4sL/X7KEo5Cef1rKNn8fyq5ypskZJkRteP2VLIuJG4XN4AZgXPZ7q2LIwxK4wxpxljThvBeylKORl0bofzurW1tazGKUp/jGRB/xMwV0TmiEgD8Cng0eKYpSgVRee2UpMM2+VijOkRkSuAJ4E08HNjzN+LZpmiVAid20qtMiIfujHmN8BvimSLolQNOreVWkRPiiqKoiQEXdAVRVESgi7oiqIoCUEXdEVRlISgC7qiKEpCKPlJUUVRko8hO6uHUIwMDMpQUYWuKIqSEFShK4qSQ6S4XXrtDJm4L0/K7ZRYbeiVeZgiTdV6+VCFriiKkhB0QVcURUkI6nJRlBohK/Do3B6+rdf0Rl29pscNiceLc4mkJe0e4z997xAJHSk9phuA1w+sB2Dl1jg98OiGZgDOnn5m1HbUKJucsilt+1KqFSuCfuqKoigJQRW6olQ5XoUbEwcmvSLv6D0CwNZDcf2DdftfA+BIT3vUdswYq6CPHXscAGPrx0d96ZRdBg527Y/a/vWP/xOAh55+AYCu7p6o733veTcA7540L2qbMcrrfMmy2bZoULRcqEJXFEVJCLqgK4qiJIRBXS4i8nNgEbDbGHOSa5sI3A/MBjYDi40x+0pnpqIUn2qf27GrJTfw2dXbAcD2w9sAeOofz0R9z26xgcyJzc1R2/mz7ePkJltn+K3AvfLE5t8DcOczceBz4/ptzgj73icvOCHq+8rCjwBwdMsxUVtDuhEAEeteUTdLZShEod8FXNSn7WpgpTFmLrDSPVeUWuMudG4rCWJQhW6MeU5EZvdpvgw4113fDTwD/EsR7VKUklMrc9u4U5qhQu/otQHPXe27ANiwd2fUt//AYQBGNzREbaPrRrnXWWX/8IbHo76f/eZZAN7a8mb8pk5pn3aeDYD+7LKroq5ZLXMAaE6PCmy0Sl6VeWUZrg99qjFmh7veCUwtkj2KUml0bis1y4i3LRpjjIjkJndwiMhyYPlI30dRys1Aczuc17OOnlUqA7wd7jF322Jdqh6AmWMnRH31aXt4aF7r0VFbc531p//8lV8DcNdjz0Z9Pf94K+et555tfeY/+vCXAZg+ambU15Rqyhmvyrw6GK5C3yUi0wHc4+7+BhpjVhhjTjPGnDbM91KUclLQ3A7ndWtra1kNVJT+GO6C/iiwxF0vAR4pjjmKUnF0bis1SyHbFn+JDRK1isg24DrgZuABEVkGbAEWl9JIRSkFlZ7bfYtC9NefyRMU7cx0Zo2d0TIl53p807iora3DBjx/8/9eBvq4WdrdfWePiZpu/acvAnD8OOt6GV3XEo8Xda9UK4Xscvl0P10fKLItilJWdG4rSUNzuShKNRBlT4zxijx+jPOpdGe63cvsK+rT9VFfR49V7xMa43wtzWkbyOz0OVk64wArKau4P/9PH4yaTp50snvd6OH9PkpF0KP/iqIoCUEVuqJUiiBfuYkeY+WccdsUMxmrqkMfus9r3uiO3Icc6baHh6aNmha19Wbsa5sbG3Lem0lWvS9+xwVRU3NdtjLPl4udMpWZy3fvweIPb1dUoSuKoiQEXdAVRVESgrpcFKVCmDzPMsFpUF8GricqKRf3eTdExrlh9rbH2xBH1VsXSp3EgdLDvTa/S3tnV44d71hgi15MD1w0/rWRayMwNj48W5ibpa97pFD3zEDjwj51v8SoQlcURUkIqtAVpczkU5RR7vOgz29J9GrU522x1/ZPtytjFffaN7dFfcdPsEr71X2vRm2Pbfx3AN5cv9u/YcTFC08CYHR9fHjIB1273f0zQUA2417sC0ID1Lmi074YdchwA6aawXHoqEJXFEVJCLqgK4qiJAR1uShKxcgTzDO5bWnnXgldDw0pu5/c7y8Paayzffe8sjJqe/R3q+zFXrtHnXFx8YuPz70YgJa6OJeL3/P+t70298sv18YFMXYftgHWi449JWq7dM6lAIypt/lj0hIvLak+bhiTtf9+8ICmBj0LRxW6oihKQlCFrihVgNegvcFJ0a6MVdMHug4AsPXQP6K+3255HoCVa14DoLOzO+rb/Jbdwvjs83+J32DTAfcG9p0mnBBnZxzXEGdl9KzZ91cAPnfndwF4469b484ea+O/jftD1PTs4jUAfO+cbwAwsSm+f19UcZcOVeiKoigJoZB86LOAe7C1FQ2wwhhzm4hMBO4HZgObgcXGmH2lM1VRikul53b2FkWrev02QYA1+/4OwF2vWP/1s6v/HvVtf90Wh/a5zFNT4i2Er67bYi+2HorfrMv52l1mxWNmxaVSD3Rb9f6LtQ9GbT/5v08D8NZL221Db6Cq086XXxd/K/jH3uyPJ2/+lTzxgULQQ0SFU4hC7wG+YYyZB5wJfFlE5gFXAyuNMXOBle65otQSOreVRDHogm6M2WGMedFdHwReBWYAlwF3u2F3Ax8tlZGKUgp0bitJY0hBURGZDZwKrAKmGmN2uK6d2K+tilKTVGJu53NLHHLuD4DHX38OgJV/tAHK3Rt2xQMPu0IVdS6ny+HY/UG76+sJilj4snFN9gTo9u1tUdd/vPdmANb/bXM8fvuRbMNa4qVi6skzAejsjt+z/YgtqnGox7p5xmUmRn3+hGu+39e3FepKGer4txsFB0VFpAV4CPiqMeZA2GescyzvJywiy0VktYisHpGlilIihjO3w3nd1tbWt1tRKkJBCl1E6rET/l5jzMOueZeITDfG7BCR6cDufK81xqwAVrj76D+rSlUx3LkdzusFCxcMa16HKtOXl9t5ZEfU9uJ2e33oiDsMNDY+DCSuKMWopkZnT3zfztFWOfcGAp1Op9pdUHT3up1R126v7tuDQ0pOTJ+4yJai+18f/y9Rly+q8cWHbo3a9u87CEBHTzuQnfsF+mRuDBiu0taiF/kZVKGLiAB3AK8aY24Nuh4FlrjrJcAjxTdPUUqHzm0laRSi0M8GLgf+JiIvu7b/BtwMPCAiy4AtwOLSmKgoJUPntpIoBl3QjTHP038m+w8U1xxFKR+Vntuhg8Dv0R4d1PI8eZqNxe6ZZfd4798f7yvv6unJuldPT+zimDRhLABbu4Ixbzr/S6cbdzAIovo95qn4ozjzc2cB8ODHvgdAY7op6ntoo92v/spfNsb36Lb3b++1LpdUKl5a+gYy87lGBkqRq66UwtGTooqiKAlBc7koSoXIKinnMhLOGH101Pb5kz4JwPwpLwLw6Pp4o9ia9TavS1OzDVC2tcUl6Lq7nTLfH5SbO+QUeY9Tu5lA9TplPmbB9KhpxSX/FYBm943hzY44Lnz9Qw/Yix2Ho7aJ82cAMKXZfquoD8rf9f19Q70d6XLpX6ErhaMKXVEUJSGoQleUcmNyfcnehxz6qr1anzb7KADOOersqG/D/A1AvD3wydf/Pep76kWb82Vnvtwp0ucRYIxV0/950flR05Rmq9bbe6wKv+yeq6K+nS+4XDEtsQp/8J//BwATGltzfjdvo/8ds7S4KvOiogpdURQlIeiCriiKkhDU5aIoZaLvtr3eTLyt0Jd8S6dyS7eJO2k5viHOj3La5DPsvVygMSXpqO/FbTbl7frgZGmUPrfTBWK7w2Okluc2vR5d16d/AsB9z9vSdRufWRcPdAHVzy29MGqaN+HdADSlm7PssvY7V4v7fQo9MTrQVkYlP6rQFUVREoIq9GFwwgknRNfLli0DYOnSpQBs27Yt6nviiScAuOWWW3LuceiQPSTS1dWV06ckh3zKM+Paekx8uKfDHciR3rAQtN2S6FV7XVB42Wcw9Dlgjm6ZFfW9d85sAF7ftD1q29nlMjXus1kRCc8lueyMf/z9y1FTdL3H5ZEJFP3CxacDcMNZV0Zto4IDURCr8RA9IFR6VKEriqIkBF3QFUVREoK6XIbAkiU2Ad91110Xtc2ePTtrTGtra3Q9f/58AK6+OreC2Z133gnAtddeG7Xt2LEjZ5ySQNz+8K7ezqhpb8ebALS5R4j3b09ommAfg6Do6PoWAA66ghibDmyK+g502fvOmBHPxQ7n2ts/yuWDORK7e8ZMGwfApz90VtRWn7Jab+M+m0fmE+88M+q75JhF1oa6MVFbaoCAp0dT3pYeVeiKoigJQRX6EDj7bHtSr68qHw4+iHr88cdHbRdddBEA7e3tI76/Uh3kq1jvHw/3xLlQth7aCsBz2/4Utf1tt82fknGK/sTg29/xE2zulL3tNofL4e54znT3WmV/3olzo7YZk626n9Zilf0Hjzkt6jtz6nuAOG9LaGNPxir5RrcdEaDel5STPL9bdDo1OAWbJ0Aa9enWxKKiCl1RFCUhDKrQRaQJeA5odOMfNMZcJyJzgPuAScCfgcuNMYneg3frrbaoTaigwy2MfTnuuOOAbBXel/e+973R9bnnngvA448/PhIzlQKp1Nz2qjQTHL454kq3dQR5ztu7rDo2kc89znne0WP95JvfejPndZNHjQLgjGnvjtounG0Ver3bAjmpKVb7/jBQuC3Sq2q/dTJU0t7unuBgVHwIyo5LBwedlPJRiELvBM43xpwCzAcuEpEzge8BPzTGHA/sA5aVzkxFKQk6t5VEMeiCbiy+VEq9+zHA+cCDrv1u4KMlsVBRSoTObSVpFBQUFZE09qvn8cCPgY3AfmOM/861DZhREguriLVr1wJw5ZVXDjLSMnWqTfY/bdq0qO2GG24AYNGiRTnj/fbGp59+GoCOjo7hG6sURDnntndHePfE2IaxUd+YBrsFsDdIeZtyhSdmjrXbCo8ZNznnngf9dsRgrnjXzN6O/VHbzJaZWa/r7I3H97hftZ4490tfF4rPNQNxoPRwz8GozbtmGlz63zBgmorS5moAtNQUFBQ1xvQaY+YDM4EzgBMLfQMRWS4iq0Vk9eCjFaW8DHduh/O6ra2tpDYqSqEMaduiMWa/iDwNvAcYLyJ1TsnMBN7o5zUrgBUAIvK2OkWwa9eurEeAm266Cciv0H2A9LzzzgM0OFpOhjq3w3m9YOGCIc3ruJhFvBVwavMUAGaNDYKVdfbP89Sp7wDgqNFHRX1vHLImzRjT5l4Xqn0X5AwyN+7ttAeEDnUfyno/gO6mLjc+LliRMjaomcEGQLsy8SGojp4jQPa2S6nLDoamgq2KPogaBV0D9a6qvbgMqtBFZLKIjHfXzcCHgFeBp4GPu2FLgEdKZaSilAKd20rSKEShTwfudr7GFPCAMeYxEVkD3CciNwIvAXeU0M7E8MILLwCx+r744otzxnzwgx/MGqOUjMrMbadQ64JCyhMbJwFwyuR5UVtbu1Xfo92BnwNdB6K+TfttVs9tB2xb6EP3RaLXjo2/GfoDRX7ccRNif3z9MdaOcCvj5CYb//G+887e4OCS86GHWxP9NsfI156Jd3mmnTL347O+p2sJuqIy6IJujPkrcGqe9k1Yn6Oi1CQ6t5WkoSdFFUVREoLmcikzU6bYYNSJJxa8UUhJKGHgsNFt92tMN0ZtB7psAPPVN20mxb/v2R31rdtoXS4799hg58GDR+IbuxJx4yfG2RCPmmbdKb1uS+O26bH75uTJdi6GQdTxDTbDo8/REm5DbHA21pvYZeTzu6ScRgxL4vnAZ3QvDYSWDFXoiqIoCUEVepGZODHOWX3UUXabWZiv5cILbWHdOXPm9HsPn3XxjjviWNyaNWuKaqdSeUKl6svMHe4+FLW9uNMq85dft5kY9+yJDwpt321zuJgDLvgYFn12anq/xPfKONXuFXpdXaygj/QE6r7PPXzu9lBxp/LkaYkDn3VuTKwVJTqkNLyydKroC0cVuqIoSkLQBV1RFCUhqMtlhEyYYINHt9xyCwCnn3561HfSSSf1+zofZDLG5LS9853vBOAvf/lL1HfFFVcA8NOf/rQYZitVQOiWaEjZPCrTR0+P2o5qsTlcXjL/AKC3N3armF43b7yrpTPOtYLLAcPhuMxcz2jbP7V1PACXLjgl6nvnBBsUHRPklvGnOv1J0dBWfx2m/x0IHyj18ztf0Q9MHteL7lEfMqrQFUVREoIq9GHgVTnAvffeC8SBzEIxeRRJ37Z0Og4+3XbbbQBs3Lgxavvd7343pPdUqoNYocYKtM4p9BmjZkVt586ypeF2H7FZDV8bH29DHNVstw4earUnOLuCAhcto2wul5aWOFfMlKk2WH/mTJt18eyjFkZ9zXW2IEZWgQtfqCKVfcoz7BOCbwzuuhBNPWggNI+SVwpDFbqiKEpCUIU+BMa6jHa//OUvo7YLLrhgWPcayIeeT703NFgF9/3vfz9qu/TSSwF44428iS6VaifMGW6stgoLNZ843vq2//kU+42wvSfOp7Ju3/qsW41rjP3fTe6Q0piGlqitN2N96GGGRE9bxx4AJjTG3zzHu9wy8XeJIEOi86GHatD0yXmerzC0n9dZutt/BpqBsSioQlcURUkIuqAriqIkBHW5DIFLLrkEGNjNEm41vPnmmwG46qqrorZTT7XJ/fK5VV555RUA3nzTngJ83/velzNm/vz50fXSpUsBuPHGGwv7BRzvf//7AXjmmWeitkzGBrVOOSXezubtUUpE6G5zj/VBkYkxDXaL4Zj6cTkvPW7s3KznYXGKvqXuAHozNmj6Vrc9bbqnPc4L0+HK0YVzMgyQ9r2Xv38mqy37d8p2mpjsUepeKRmq0BVFURJCwQrdFQFYDbxhjFkkInOA+4BJ2CK7lxtjuga6R63jS8Plo8dtG/vud78btT388MMAfO1rX+v3dT63BsAnPvEJAMaPt8rsySefjPrGjBlDX3whDP+e4b0G4tprrwViVQ6wd+9eAA4dOpT3NUml2uZ1ijw5UHxalWBcc59cK/mCkKH6TaVsf0udnUf1o2NF7xW6D6ZCnJMltiU4DBQp+dxvGPm2HKoKLx9DUehXYstzeb4H/NAYczywD1hWTMMUpUzovFYSQ0ELuojMBC4BbnfPBTgfeNANuRv4aCkMVJRSofNaSRqFulx+BFwF+O/9k4D9rio6wDZgRpFtqyl+9atfAfDAAw9EbYsWLQLgjDNyq5n5r7ChO2bt2rVZY2bMiD/SgwftacEwcOWDpldffTUA3/nOdwa00buMzjnnnJy+X/ziFwBs3rx5wHskjKqb15Iv0BgR/7dPYU9uZrButjCvin9dbzC+19UB9blZGtPxKdLGlHW1pIMCFz4IavLka/H3z3IP9bEw717zqC/3NxvILVNIil3FMqhCF5FFwG5jzJ+H8wYislxEVovI6uG8XlFKQTHndVtbW5GtU5ThUYhCPxv4iIh8GGgCxgK3AeNFpM6pmZlA3uOKxpgVwAoAEUnsP7U+v4svagHw7W9/u9/xzz33HAD3339/v2M6Ozuja6+gP/vZz+aM++IXvwjA7bffHrXt2mUrvtfVxf+J/bbL+nobEAuDqI8//ni/diSUos3rBQsXFG1e51Wj+TIROiJlGwrcaOtgmNXQ4lW1z+6Y++L8dmRvs82jw6NgaP82Dzc4mjc7o5KXQRW6MeYaY8xMY8xs4FPA740xnwWeBj7uhi0BHimZlYpSZHReK0lkJAeL/gW4T0RuBF4C7hhkfM3j/eSf//znc/p8tsXnn38+aps9e3a/9/L50/fs2dPvmO7uOJ/18uXLAZjpsuVBfEDIt7W0xLk7vEIPffRf/epXs+6/atWq6Pqpp57q1463GeWb16FvOY+q7jsuVKdpfPbDVE6f95OHbf7gUa/JzfQYm5AJn2S9d9boQkRyiQ4P9S04rWQzpAXdGPMM8Iy73gTkRvsUpcbQea0kBT0pqiiKkhA0l8sQ8LlNwnS14dZCGNjNAvDEE08A8Ic//GFI793eblOnhu4eHwydM2cOAIcPx6lRfTD0wgsv7Pee/mSqUhmygn0FeCXyuS4yzvWQCVwQ3h0RboGsd9dpY101oXsln4tmwCITeVxAI8VknTrVLYzDRRW6oihKQlCFPgR27NgBwM9+9rOo7frrrx/0deE+5U9+8pNAfFBoqIQl6MIsjn3xAdJzzz03avPbFH/yk58AsHPnzmHZoJSOgRRolqJ3CrvXnYHqznTljAszMKaCEnIAPSYuWdeV6cy5/2h31kryFGrOWz6xhMpZVXnhqEJXFEVJCLqgK4qiJAR1uQyDO++8M7p+17veBeQPMPrA52WXXRa1DdfVMlT8KdNwX/y+ffsAuPLKK8tigzIEnBvD5AluelID6K/Q5eKvR9XF5xJwJ0N7XE6XA137o65d7db1NrFpUtQ2tsGefI73uw9MMfeaq4tl+KhCVxRFSQiq0IfB1q1bo2sf5PSPleDEE211eL99EWDhwoUATJ48OWoLC2YolSdbjee25fbF+K2GR3psQZKNB9ZHfT2u3Ny0UdOjtomNrUCcRXGsK28HMM6p8fogv0t0InOAPDJK9aEKXVEUJSGoQk8AvmTdfffdF7X53Opjx46N2nzGxoEIsy7OnTs3qy3Mt65bHkdOeLjHbyMMFbFX02m35TD0UvvrhlQjALPHxN/OfPk43wex+k7luVd0zzxl7KJDSlpGriZQha4oipIQdEFXFEVJCOpySQAnnHACkJ3LZf78+UCcYheyg7nhGIAHH7RlNMPAqudLX/oSAK2trVHbN7/5TSA7r41SGN6N0WviAiPdvXabaZiTxbtMvAsldImknRZrdjl7mupGRX35UswWo7hEX/uV6kMVuqIoSkIoSKGLyGbgINAL9BhjThORicD9wGxgM7DYGLOvNGYqA+EzKk6ZMiVq83lbfGm8kLPOOgvIzvjog3EDbVMLD09t2LABgG9961vDNbsqqMjcznOIqCdPTpaMU/A+n0odcW4Wv4kxEwUtY8TptIEKNRdsqqrxmmIoCv08Y8x8Y8xp7vnVwEpjzFxgpXuuKLWIzm0lEYzE5XIZcLe7vhv46MjNUZSqQOe2UpMUGhQ1wFMiYoCfuornU40xO1z/TmBqKQxU+qe5uRmAY489Nqevo6MDyN5XfsUVVwDwgx/8oN97Pvzww9H1TTfdBMANN9wAwMUXXzxCi6uSis3t0L3lA6QdvR1RW8btU/d7yCUVu028a8aPaQhOefq0uWGANa3hsrcFhS7o5xhj3hCRKcBvRWRt2GmMMe4PIgcRWQ4sH6GdilIqhjW3w3k96+hZ5bFUUQahoAXdGPOGe9wtIr/GFtHdJSLTjTE7RGQ6sLuf164AVgD0t+grw2PqVCscTz/99Jy+yy+/HIAvfOELUdutt94KQCpl1ZoPnEKswsPToH6b4gUXXFBMs6uK4c7tcF4vWLhgxPPanwZNBVsTvdL22xUzwcnS8JRpf1TidKeWj6ssg34PE5HRIjLGXwMXAK8AjwJL3LAlwCOlMlJRSoHObSVpFKLQpwK/dlun6oD/Y4x5QkT+BDwgIsuALcDi0pmp5GPZsmX99r300ksArFy5MmrzytzjVXnfa8/SpUsBSKdzc2Lv2rVraMZWJ5WZ224LYTooC+f95PVB2bg6f6Aoz0GhdKrO3SP70d6+8nlXQhs0Y2P5GHRBN8ZsAk7J0/4m8IFSGKUo5UDntpI0NPStKIqSEDSXS0K5/vrrgfxbGl977TUgv5vluOOOi66vu+66rL4tW7ZE1/fcc08xzHxbE7olvMulKR3nZIlzvthTpGFQ1AdMfRA1vFc1pLoN3SwaDC0fqtAVRVESgir0hLJkyZJ++7wyb2yMCyB87GMfA+DGG2+M2hoarGr0yjw8WHTgwIHiGatEAdKmdHPU5g8b+S2Kvuxc2FYM8hWx0O2HtYkqdEVRlISgCv1tyKWXXgrANddcE7XNmzcvZ9zq1asB+MxnPgPApk2bymDd2wCTmw8939bEKNui6wsPHaWkz1bScGtgAdsWQ4WfW6oa6FOOLp96V6VefahCVxRFSQi6oCuKoiQEKecpLs3lUlwWLlwIwKpVq4b1+nyn+X784x9HbV//+teB7Jwv1Y4xpux79hYsXGCeX/VcweO9u6MrKGYRuy/iPxHfny9A6U+R9t2+CJDyBS6Ctr5ukkFdLn1el93Y/0dcDVsmk8jo+jF/DvL194sqdEVRlISgQdEa5uWXXwbgK1/5CgDXXntt1OczMQ70usceeyxqu+uuuwDYvn171FZLyrymkNwgZ0+mG4gDobbNK3hx/x+oX/dSk8ndcujzvDRIvC21bwAzW727MVmq3ZfJy4PJU/bOH3AaIGA6UBC1UGWvRasHRhW6oihKQtAFXVEUJSFoUFRJFLUQFPX4HC0Ql5TrDErQ7W7fCcDhnsMANKZjF8qkRlt8xAdFu4MA66i6FgBa6sZEbSKDa7dCT5/6P+KBXC75X6d//sNFg6KKoihvMwoKiorIeOB24CTsP9D/CVgH3A/MBjYDi40x+0pipaKUiErO7VSeAhcSaKzWpikANPcccuPjvsZ0U9Y96oICFz4vTG+Q+yUdyeo8AdaoK75/3/wuoboe6CuQqvDKUqhCvw14whhzIrYgwKvA1cBKY8xcYKV7rii1hs5tJTEM6kMXkXHAy8CxJhgsIuuAc4NCus8YY94xyL30n2+lpAzFh16suT1cH3pIpGxJUtaLAAAENElEQVSDv0efXTHfH02qoG1+Qf6VAZT5UMmXnVEpLcX0oc8B9gB3ishLInK7K6g71Rizw43Zia3PmIOILBeR1SKyulDjFaVMDHtuh/O6ra2tjCYrSv8UsqDXAQuA/22MORU4TJ+voE7d9HMGwawwxpxWyL8uilJmhj23w3nd2tpaFmMVZTAKWdC3AduMMT5hyIPYP4Jd7uso7nF3aUxUlJJRNXNb/P8kFf2kJE1K0tRJXc6P7xv4JxX9+PsX01al+hh0QTfG7AS2ioj3IX4AWAM8CviyOEuAR0pioaKUCJ3bStIoNJfLV4B7RaQB2AQsxf5j8ICILAO2AItLY6KilJSqnduqgpWhUtCCbox5GcjnA/9Acc1RlPKic1tJEnpSVFEUJSHogq4oipIQdEFXFEVJCOXOtrgHu9e3lk9itFK79tey7TC4/ccYYyaXyxiPm9dbqO3Pt5Zth9q2vxDbC5rbZV3QAURkdS0fMqpl+2vZdqh++6vdvoGoZduhtu0vpu3qclEURUkIuqAriqIkhEos6Csq8J7FpJbtr2Xbofrtr3b7BqKWbYfatr9otpfdh64oiqKUBnW5KIqiJISyLugicpGIrBORDSJS1VVgRGSWiDwtImtE5O8icqVrnygivxWR9e5xQqVt7Q8RSbs834+553NEZJX7/O93+UuqEhEZLyIPishaEXlVRN5TrZ99Lc1r0LldaUo5t8u2oItIGvgxcDEwD/i0iMwr1/sPgx7gG8aYecCZwJedvbVUnuxKbEk1z/eAHxpjjgf2AcsqYlVh1ERpuBqc16Bzu9KUbm4bY8ryA7wHeDJ4fg1wTbnevwj2PwJ8CFtAeLprmw6sq7Rt/dg7002M84HHsPXI2oC6fP89qukHGAe8jovxBO1V99nX+rx2NuvcLp/tJZ3b5XS5zAC2Bs+3ubaqR0RmA6cCqyiw9F4V8CPgKohKv08C9htjetzzav78R1T2sMzU7LwGndsVoKRzW4OigyAiLcBDwFeNMQfCPmP/Oa26bUIisgjYbYz5c6VtGSYjKnuoFIbO7YpQ0rldzgX9DWBW8Hyma6taRKQeO+HvNcY87JprofTe2cBHRGQzcB/2q+ltwHgR8Tnwq/nzr5rScAVQc/MadG5XkJLO7XIu6H8C5rpodAPwKWypr6pERAS4A3jVGHNr0FX15cmMMdcYY2YaY2ZjP+ffG2M+CzwNfNwNq0rboeZKw9XUvAad25Wk5HO7zAGBDwOvARuB/17pAMUgtp6D/drzV+Bl9/NhrL9uJbAe+B0wsdK2DvJ7nAs85q6PBV4ANgC/Ahorbd8Ads8HVrvP/9+ACdX62dfSvHb26tyurN0lm9t6UlRRFCUhaFBUURQlIeiCriiKkhB0QVcURUkIuqAriqIkBF3QFUVREoIu6IqiKAlBF3RFUZSEoAu6oihKQvj/e8wORV5a9bEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXuU3FWV7z+7qh95ddLpdBLypCEEISCEhDAIKhF8gAZxeRUfXFYGo1lrHL2o49JwL14cwTcXhz9cV6IM4shAEHFgWCOgGViRixMIA44QQgghMSHPzqvz6Hef+8f5nfM71fXr7uruqu6qX/ZnLehfnfOrX+2qPvn1t/beZ28xxqAoiqJUPpnRNkBRFEUpDnpDVxRFSQl6Q1cURUkJekNXFEVJCXpDVxRFSQl6Q1cURUkJekNXFEVJCcO6oYvIlSLymohsEZFVxTJKUUYbXdtKJSJD3VgkIllgM/A+YCfwPPApY8zG4pmnKCOPrm2lUhmOQr8I2GKM2WqM6QAeAK4pjlmKMqro2lYqkqphPHcWsCN4vBP4q/6eICJaZ0ApKcYYKcJlBrW2GxsbzdxT5xbhZRUlmRf/88VmY8zUgc4bzg29IERkJbCy1K+jKCNJuK7nzJ3DM+vXjbJFSpoZX123vZDzhuNyeQuYEzyeHY3lYIxZbYy50Bhz4TBeS1FGkgHXdriuGxsbR9Q4RemL4dzQnwfmi8hpIlIDfBJ4tDhmKcqoomtbqUiG7HIxxnSJyBeAJ4As8I/GmFeKZpmijBK6tpVKZVg+dGPMvwH/ViRbFKVs0LWtVCIlD4oqilL5GBIS1II9LMb/7Ml5HJLBJiAJQSKSJIwpQ0a3/iuKoqQEvaEriqKkBHW5KMpJTo/piX52+7Hu6Ni5UAhcIs51kpFsPBYdZ2XgW0qi+0YpCqrQFUVRUoIqdEU5iTBOjXvlDcc7jwKw/dib8XmRim6onQLAxJp6P1ebGZN/3eh63SY/KOpe0/10gVCIg6HZQO27bwMi+YFSDZ72jyp0RVGUlKAKXVFOJiLVe6LzuB967cirAOw6vjvv9H1V+wBoGNPgx2aPt1UR6qon+TGnsJ3vvdN0+jmnzKsy1fYn1X4uk3HKPFTtvUxWVV4wqtAVRVFSgt7QFUVRUoK6XBQlpYTpgZ09HQC8eujPADy69Xd+buP+vdE5caD0vGnTATh10kwA6mrq8q7f1t2ad9ze3Q5AVSa+tdRVTwTilMYwAJqJNGWOUyUhGKoUhip0RVGUlKAKXVHKFBcMHOpGHKfKATYfse1Qv/XsvQCs++Of/Vw2a3Xdey9d6MfObGgC4PSJ9ufsCXF5+JpsbY59ABOqrYKfVDPZXjPYYOTUulPjSWmLSnFQha4oipIS9IauKIqSEgZ0uYjIPwLLgH3GmHOjsQZgDdAEbAOuNcYcKp2ZilJ80rq2XU2Wfa1xXvmjbzwJwLPPW9fLif1H/dyF7zoXgM+8/Uo/dtbkswAYVzUegNrsWD/ngpqhuyQjmV5jCXnlCcFO505S10txKESh/xy4stfYKmCtMWY+sDZ6rCiVxs/Rta2kiAEVujFmnYg09Rq+BlgaHd8LPA18vYh2KUrJSevadtUT32zZ6seeemMLAC37WwA47ew4yPnt9/81AOdNucCP1WRs4NOrcYm1X6zB88ccYSC3x6lwMzj1rgyeofrQpxtj3Pe5PcD0ItmjKKONrm2lYhl22qIxxohIn3lVIrISWDnc11GUkaa/tR2u6zlz5ySdMiSG6ksOFbE73n1ijx/7y/bouMpe/ytXXe3nzmuw6Ypjs+P8WO+65iaozuheSRJUeI+vthjPuffkVH4mfI+qzIvKUBX6XhGZARD93NfXicaY1caYC40xFw7xtRRlJClobYfrurGxcUQNVJS+GOoN/VFgeXS8HHikOOYoyqija1upWApJW7wfGyRqFJGdwC3A94AHRWQFsB24tpRGKkopSOvadm6PYx1xrZWeqE7L2887A4B3z7rEz7mUxLDGinOEONeJMaF7xTXJyMe5VzKBVuyd0hgGWJXiUkiWy6f6mLqiyLYoyoiia1tJG1rLRVFShlPVJ7pa8+bqJ9uaK9WZGj+WFJbsMl0AtHafAOBoxxE/19Jpj2uzcSu6+qiGy9hoI1JVEFR19rjmF2FpmuS0SA2UDhX97qMoipISVKErSpnTn2JNqsTY0WNrkv/LKy/5sV27mgGYOtU2ex4fKWmI1XFHUJ1xw/7/AOD/PPdrADZu2h5fv8O2l1u88Ew/9sVFHwZg0dQlAFRn4zZzeb5zk5/umA3GNJVx6KhCVxRFSQl6Q1cURUkJ6nJRlArGRCmK3UES4caDtnnFltd3xCe22iDnB849G4BxVRPyrrFmywN+7Mv33ANA+5aDdqAncInMsO6a5lNb/JBznbimGmHQNUt+dca895HwSIOjg0cVuqIoSkpQha4oZURSDRT/OAgW9q6Z0tp13M+9cnCTHWuPg5yMt0HKy+faDUX72/b6qVv/4y4A7l+zNj5/Z3w9+/zgVhGp9ekNk/zQjHGnAFCdqc6z3W82StxQ5AKm2pauGKhCVxRFSQl6Q1cURUkJ6nJRlDJHEvKye7sljnTkd8mrGx+Xw+2J3CT/9MrjAGzY9Kafe+3P0fHuE/GTx9lbwymL5wIwZcpEP5XN2iDnB89Y6MeqMvZ8txu0y3TGr+12iEp+nRe3U9QFTsPzHEm59uqWSUYVuqIoSkpQha4oZUrvSoehKu2tWsOA49EOq7Rb29v92Il9tin0fY88bQeOxAqaFhs8nffes/3Qvf/dtlKdMsbWev/uc6v93B9eskHX1w/+xY+945SLAKgSGxR1LexCkhpcFFKBUdV44ahCVxRFSQmF1EOfA/wC21vRAKuNMXeKSAOwBmgCtgHXGmPyHXmKUqZU2tpOajPn1KuvZAhs3P8WAEeOBqmHxyNF3hadl4lV7/Ql1k/+m898x49NHWNbqf7r9n8F4MHf/dHPtXdYRb9kxrl+bOY424bPbVgK/f7xNwyiuf51pHtPSb5zpX8KUehdwN8ZYxYAFwN/KyILgFXAWmPMfGBt9FhRKgld20qqGPCGbozZbYz5z+j4KPAqMAu4Brg3Ou1e4COlMlJRSoGubSVtDCooKiJNwAXAemC6MWZ3NLUH+7VVUSqSclnb/e0UDentlujuiV0u2w5a75DpDJrEuVosGfuzdmachvi//9vHAairjsee3PkEAH9zl91F2r3lsJ+bt/RtACyZtsSPuWYXvnWdCd1D1o6MFHa7UVfL0Ck4KCoiE4BfA18yxrSEc8b+9hJ/CyKyUkQ2iMiGYVmqKCViKGs7XNfNzc0jZKmi9E9BfzJFpBq74O8zxjwcDe8VkRnGmN0iMgPYl/RcY8xqYHV0Hf3Tq5QVQ13b4bpetHhR0db1UFP0TgS1XNrbbNAyUxNv1ulxQdB2q+SbZsdfOi6Z8VcAbD7ymh/7m5/9BIDu16NYcFWs/W758CcAGB9UbPSvk9A6ur8gZ6jk/fm9NhYlfSb9pXCezAyo0MV+uncDrxpj7gimHgWWR8fLgUeKb56ilA5d20raKEShXwpcD/xZRFxPq/8JfA94UERWANuBa0tjoqKUDF3bSqoY8IZujHmG5MbgAFcU1xxFGTkqZW3367KIfrZ3x7tCnRtjwrixfqxlahQ0PWjPq59c5+fu3/QbAH75VJxrfmLjfnvQba81/4q3+blLTrEleMcluFz8zs8B3CTBYN9z/aBulmR0p6iiKEpK0FouilLm9KdGXVXD3Sf2+LGjLbaWS1vY4MKlMEat6P708ht+av0Lr9qDbS155897n63v8svrb/ZTk2om59nRW2GHwVHxulFVdalRha4oipISVKErSgXiVHtbl1XjoQ993Hi7yWfalHo/1jPZKuYT0+15H7ks3hR0LKrNsnlHrPI/scRWT/z4GXaTbF1N3G7ObSJybfAgTjXsIbduS67Rxp2cN2aCIa2uOHRUoSuKoqQEvaEriqKkBHW5KEqZYyLXxrGuOGj5//Y8A8A/vbwWgFe37vRzHe02UDrvjFl+bNn88wCYOs4GNC+afpGfc80xQldHQ61tbFGVsQ0rwrZx7rzOnjjoWhO5YTJJaYsJLfSU0qAKXVEUJSWoQleUMsUFPo902noq//zaGj/36Gt/AuDNrbsAOHq81c9Nb7TB0LrauA3c9PFTADh78lkAjIkUNcSNmsO2cdWZmhxbwjREV9kxbEw9bewMoLCWcjmoei8qqtAVRVFSgt7QFUVRUoK6XBSlTHHuiwnVNgf8kplx7viOo7aib0+PdYW43aEhR9vj3HSXM95Qa10vY7Jj8+bCsrW968eEAdCOKOc9LNmre0DLA1XoiqIoKUEVuqKUAYn1WqJdlB3dbQC82bLNT20+cACAbW/aTnktx2KFXl1t/1l3dnb5sVcPbAXgnIYFAEwIFLdT5i44CnGaotv52dYdXD8KmE6O1D4Ered6PVZGFlXoiqIoKWFAhS4iY4B1QG10/kPGmFtE5DTgAWAK8AJwvTGmo+8rVT5nnnkmACtWrPBjN9xwAwA7d9qNHY8//rifu/322/OucezYMQA6OlL9UVUEo722c1S5q2kSzHcbq7DfaNkMwHO7X/Fzu/cdBODA4aMAtDUfC58IwMHmI37oyBE7v+WgVfbnTJ3h586balMZp4+b5sfG1o0D4k1HVVLt52ozUcpj4HNXZV4eFKLQ24HLjTHnAwuBK0XkYuD7wI+MMWcAh4AV/VxDUcoRXdtKqhjwhm4s7s9/dfSfAS4HHorG7wU+UhILFaVE6NpW0kZBQVERyWK/ep4B/Bh4AzhsjHFRl53ArD6eXtEsX77cH99yyy0ANDU15Z3X2GhrXyxcuNCPrVq1Ku+8e+65B4Cbb7YNA3bv3l00W5XBUy5r27ksuk0cyDzeZd0pz+5+DoBX9u/3czt3NQPQdjgKVrYEHqHI5eKaWQDsOmbX2W9bbKrhK7Nj98obZ9rrnt04049NOt2mSo6tsq6X2mAXqds1mg1uH3ENF2U0KSgoaozpNsYsBGYDFwFnFfoCIrJSRDaIyIYh2qgoJWOoaztc183NzSW1UVEKZVBpi8aYwyLyFPAOoF5EqiIlMxt4q4/nrAZWA4hIxe0/uPTSS/1xkjIfLC6IesYZZwBw5ZVX+rnW1tbE5yilZ7BrO1zXixYvKtq6DptG7D1hVfXG5h0A7NsX1045HAU5fWu5mjjlkGykk6sDvRZZeOKwVeivd8RvacdbdpPS0xPjps8TPzwegLMm20SAqWMb/VyjWHU/rmp84W9MGREGVOgiMlVE6qPjscD7gFeBp4CPRactBx4plZGKUgp0bStpoxCFPgO4N/I1ZoAHjTGPichG4AERuQ14Ebi7hHaOGnfccYc/dgrapS8mMW/ePH/sVHgS73rXuwBYunSpH/vtb387VDOVoVFGa9tK6K5gw8/e1r0AtERb+DOZ2EPdOHkiAO0T7Bb+cBORSfi+0Bpdw0T+9Ww21nI1NTYlcUxtXGFxbp0NG0ysqQPiuugQVFRM0IMm4aj385I2UWnbueIw4A3dGPNfwAUJ41uxPkdFqUh0bStpQ3eKKoqipASt5TIAmzZt8sc33njjgOdPnz7dH59yyikA3HrrrX5s2bJlOeeHqY1PPfUUAG1tbUMzVqlgonoqgWvj9InWfffJs98DwMtTN/u553ZtA+BgVMPl8KGjfu5wtHs0bHpRlY3qu3R35r2yiXw0J1rj6owTa6xLZ0K1dblkgoYVXcZeI2x64Wq++LMS3D7unBznija4KCqq0BVFUVKCmKQISqlerALTFovBxRdf7I+fffbZPs/70Ic+BGhwdDgYY0Zc8i1avMg8s37dsK7hAoXhv0cTKGDIrUm+r3UPAM1tdlPQjmNxk+h1O14C4Pmt2/3YsaNWrbt0xzAo6l6yvTNW7z+94X8AMGVMA5AbAJ0UqffGMUHtl2gDUlVUiTGTo8NzazGGAdCCW9Wd5IyvrnvBGHPhQOfpp6koipIS9IauKIqSEjQoOgI899xz/ti5U6666qq889773vfmnFMMLrvsMn/89NNPA3HbsvPPP9/Pvfzyy0V7TWXw+NzunCBhrt6STPx42lhb/rau2ro/ZoyL67CcWjcXgMvnxrtBj3fZ4OnL+7cAsO71rX5uV1QXxq0LgN9u/aO97gRb06UqE98qFkyx+yu6TXdgj00AGF8V2ZgJ67zE7zJ6kwyG0EWT2AhE8ahCVxRFSQmq0EeAadPi4NFZZxVc16wouKqOECuwgwdtcwTXbEMpT/J3VuarU6ecx0lcV2XaWJs6OzUIWjpOGWfndrS0+LH2dhsMzR6O68HsjObnTrQ1XCbUxE2lT0RqvzpIsXRVIuNKjLnvJP7/4FFVXjiq0BVFUVKCKvQi0dBg07tmzox9ma5eywc+8AE/dtppp/V5DVd58e67bemQjRs3Dtme97zHbkZ55zvfmTf3y1/+EoBt27YN+fpK6fGpjNHPsBJj7zTHUMWOyVo1XZsdE1zMztfX1gMwZ+JEP3V4mt3IVlUV6+rx1VZ9N02y6zlsIL3jqK0CedG0uPZLXi2WMB3aTYkkn9vHmCrzwaMKXVEUJSXoDV1RFCUlqMtlCEyePNkf33777QAsWbIEgHPPPbff57q0NPdVOUxTO/vsswH405/+BMAXvvAFP3fXXXcNaFdVVfzrdLtOq6uDwFW3TTPTnaiVSU7tlChl0O0ePdYVB7irxK6DmqBtXFu3DWS+dsjWgznSHtdtqclad0rD5Do/dv70OQBMGzsVgH2tcfu7lnbbJCOs7+LcQca5hbREy6igCl1RFCUlFKzQoyYAG4C3jDHLROQ04AFgCrbJ7vXGmI7+rlHpOGV+3333+bGwhVwh9K6dk1RLJxsppjvvvNOPvfHGGwD8/ve/7/PaX/7yl/3xl770pbz59evXA/Dkk08OwuJ0Uy7r2iTUOYkDn1b1hrVcYoVuUw6PdcbVFt2Gn/Db39GOOE0RYEHjHH/cNMkGRdu74+uf0zgfgGyUFrnr2D4/19rVnvPa4Wu6QKz7lhDaISbjBlBKw2AU+o3Y9lyO7wM/MsacARwCVhTTMEUZIXRdK6mhoBu6iMwGPgT8LHoswOXAQ9Ep9wIfKYWBilIqdF0raaNQl8s/AF8DXNRkCnA46ooOsBOYVWTbyoKJQb7u/fffD8D73//+IV+vv6Bob/dLTU2c5/uDH/wAgKuvvtqPvfWWrdXhgqFhvnsSH//4x4dqdlopn3XtfvfBenDuF9cYoitwcfggZDRXk4nXitvJGeaOT661+yTOnXIOAC2BC+Z4pz0/dKG4YKijrSsOomajmjKhC6irx35kSQFZ52qJ13q8zvvrM6oMngEVuogsA/YZY14YyguIyEoR2SAiG4byfEUpBcVc183NzUW2TlGGRiEK/VLgwyLyQWAMMBG4E6gXkapIzcwG3kp6sjFmNbAaKrPBhUv/g/6VuUs1/N73vufHvva1rwFwwQVxH+LeKjyscnjgwAEA3v3ud+ddf+HChQDccMMNfuy2224DYMwYG4haunSpn3Mpij/5yU/82J49e/q0/ySkaOt60eJFw17X/gI5u0Et3ZH6Pdh+wM85dXy806YQHmo/7OdcXZVxUdMJgJpsbTRn10V7d6y4x1W5naX1fqw6a9Nd3TeBsBGFa15xsO2gHzsSKf6u8fa1J9ZM8nOxQrc/Mwm7SJN2iiqDZ0CFboy5yRgz2xjTBHwS+HdjzHXAU8DHotOWA4+UzEpFKTK6rpU0MpyNRV8HHhCR24AXgbuLY1J54Wqi9EVXl1Uk3/3udwF4+OGH/VyYRtgbp6BDv3Z9vVVITzzxBAB1dXV5z3M108PXbI82iTzzzDN+7tChQ0Bhja2VHEZpXUf1WvrxJYc+8e5I7Trfc+j/dr72I4GfvL7WKubWrqgVXfsRPxdWTYzH7K2hK1L0h9ritEinpbcciWuqH2w9kmPP3AlNfq42ekZmmFUXlYEZ1A3dGPM08HR0vBW4qPgmKcrIoutaSQu6U1RRFCUlaC2XYfKrX/0KgAcffBCAZcuW+bmLLsoXei51y7ljNm3alHfOrFk2U+7o0fhrrgumhgHTVatW5Vxz6tQ41cy5bZTKIGzn1hcTqmMXXGePDXK6oGXoXplQPQGAhtq45tDYKEDqXC0dObtO3U7U2G1Tk7VpkCc6W/PsGFdtg/DNrXEgtvmEPZ5Xb12QoXso448TnC2u/G8wpQHSoaMKXVEUJSWoQh8mrr6La2zx93//9/2ev27dOgDWrFnT5zkuyOkaUQBcd911eee5tEin8sNNUOFz+yKsujh//vy8sW9/+9uApjuOBGHzCoerZujS/VzjCogDmW5Dz5QxDX7OKfkJVRP82PEum9647eg2AP68//W81wtTahvG2iDq8Q6r0Nu7uvzcrAn2+hNr47Z3MyfYb4fzJs2L7AuaX/Sq3WKSHpmEsX4aYijJqEJXFEVJCXpDVxRFSQnqchkAF/QE+OxnP5s378rnuhzwpqamfq/nGmLs37+/z3M6O21wauXKlX5s9uzZAFx22WV+zOWpu12k4dyOHTvyruvOe+ghW3sqqb/p5z//eX/c2Gg7vn/1q18F4toxSvHpXSoXgoYWCX1DHc6d0dEdBzSPGhsgdTtMAQ602V2m24/YfqA7W+Ig6s7DNlB67OgJP1YfNbsYGzVImRXsiWgcZ/dLNNWd6scaIpfPlFrreskEQdF8THBkEsai9+bK7Ya1X0Q1aH/op6MoipISVKEPQFhrxSlUl1YY0p8yf/zxx/3xH/7wh4Jfu7U1Thlz3w6+9a1v+bFPfOITOeeHrfEcl1xySd5r+07xCc01Qtwu1i1btgDwjW98o2DblcHh0vx6EgKARiKl3hP/vjqiWiyucYUJ2tPVRUHR8dVxUNSlKbqUw87uOE3y+DG7zlpPxPVd5s2cBsDbp9lg/9unnuXnTqtrAqBhzBQ/5gK2Wcm/pcQaPPcbhx3rew2Ka/oRVqD08dL8qpSKKnRFUZTUoAp9AHbv3u2Pf/rTnwLwzW9+s6DnurKqoZIONwsNhl27dgFw+umn5821tdkWYmHKoWsw/cMf/rDPa4Z1Z77zne8AcOutt/qxq666aki2KoNHEuqceF9ypLuyQc2Vmmi2Pto8FKpxl+7o6qID7D5u1/H+E7ZCYnug0Kuq7LeDSfXxNd4x26axnte4AIBTA3+5S4sMUxOrxNrmlHMm0Iq9q6DnNrvOretuz+9d+yW4VnSxrAm0qLa086hCVxRFSQl6Q1cURUkJ6nIZBPfccw8A55xzjh/r3dYtDHpec801wNDdLCHTp08HYMmSJXlz119/PQCf+9zn/Ngdd9wBQCYT/812JXudW8XtBIU4RXE47fWUoSOS4F6Ifvodo4FDxgVR3c+OnjigebDNuvoefTMOxj/8km3MtHOnTZfNZuPXqauzdV7Onx+7VZbOvhSA2ePtWOheca+Z2/RiYG1oono1YTpl2Mau9/WNT32MXTTe1ZKpCsbIs+dkRT8BRVGUlFCQQheRbcBRoBvoMsZcKCINwBqgCdgGXGuMOVQaM8sDt1knDHL2Th0sFStWrOhz7sUXXwRg7dq1fixU5g6nzMPAp8O1tstm8zeE7N27d3DGVhDltrbDmi49kaJ1m3SqQlUapQdmsvm/5+qoUmJNEER166Gtw25AcoFQgFPG25TDc6bO9GMu8FkVXaMqSEfMeCUcpg7mklSvxQU+u0ys0Nt7bEA/R+FH3wZ6Euq8ONVeFZS+kehziYOoJ2+QdDAK/T3GmIXGmAujx6uAtcaY+cDa6LGiVCK6tpVUMByXyzXAvdHxvcBHhm+OopQFuraViqTQoKgBnhQRA9wVdTyfboxxSdp7gOmlMFAZGJcXn5SjvnnzZn/c29Uyb948f3zLLbfkPXf79u0A/OIXvyiGmeVKWaxt53IIG0PkuTFMWNPEHrsA477WuMTxjmN/AWB23Sl+7LrFdsfwpibrNmw+EeeoT6ixLo4DrXF9lzWbfwPAomnnArCwcaGfG181MbIhttC5hTLe6niud52anqCZh9+1LPF7c3nqkrCT2blTuiX2uUh0XRdQ7l2u92Si0Bv6O40xb4nINOB3IpLTZscYY0QkcQ+viKwEVibNKUoZMKS1Ha7rOXPnjIylijIABd3QjTFvRT/3ichvsE1094rIDGPMbhGZAezr47mrgdUAfd30leGxfPnyPudCVV5ba9uWffSjHwXgtttu83M1kUpzqhzinaItQWW+tDHUtR2u60WLFw17XbuUu2zOWK7SzAkcRnMundClFwLMHGcrc4bBx7ZuW69l30yr5LcdjX/PB9rs7tEjbcf82OF2m2q7K9phemb9mX5ubNQ4IxPu1nQqPDI5acdrd6S8uwO7XOu90FYXGHbfVsLKjRIp80wQPHY1YlzNm1DYn2ypjAO+WxEZLyJ17hh4P/Ay8Cjg7iTLgUdKZaSilAJd20raKEShTwd+E6mFKuCfjTGPi8jzwIMisgLYDlxbOjOVoXL11Vf745tuugmABQsW5J23YcMGAD796U/7sa1bt5bYulGn/NZ2TmXBXH90otqMzs8Gz8tG/6yrqfVjY7N289CkGlv75dQJcbzlRJdV5kc6j/ixA9HmpDFZW51xYvWk4PqZPFsd+VXNyZXMwfuBOBUzbFDtFLpLj8wkbGBKSk3Mr6ye2JY61Qx4QzfGbAXOTxg/AFxRCqMUZSTQta2kjZPLwaQoipJiZKAmB0V9MQ2KDpnFixcDsH79+iFfwwXZ3O/8xz/+sZ/7yle+AsT1XioVY8yIf8tetHiReWb9uqJfN07vi8rJFhjg86VoTb4DxKUE9gT1VMKApMMFLt2O1HCnqHO1hLtaM73cQkkuEfd+OoL6Lc6ersDl4qz1u2GDoGgcKM13w2QS5vqzp5IYX133QrDxrU9UoSuKoqQErbZYIbz00ksAfPGLX/RjN998MxBXYuzveQCPPfYYAD//+c+BuGkGVL4yr3ScgkxuyZbfQHrw6XhRO7foUTaoC1NFdY4Nyc+O7XKphuEGIWeZC8gmq2T7syqoMeOuIZn813bXyN1slb95yNt9Em8ocqhCVxRFSQkXbByyAAAGSElEQVTqQ1dSRaX60JMUeqiAIVeVF+ITNjmbb3L/6eU839diL+yjc9cNfeHO5+587ZKg0OOt//kVJcP36jdZSb7a78/+pLIDMsj3Vq6oD11RFOUkQ2/oiqIoKUGDoopSBiQFQ8N0vaGQGzh1QdF810N/7ojeqa4QB0C7E+qvJNZycXPO5UK+Kyi01QVN8ys49r5yHyNJAdOTBFXoiqIoKUEVuqJUCLlBzrxZf5SUxtdbqUpC4LDf1w6DtQmbgdy8q8BoyN/446+QkIiRSQj4JgY5+zMyJQHQ4aAKXVEUJSXoDV1RFCUlqMtFUSqEXLdHfr0Wh8+9NvnBRJ8TnuSiCV+rgP0p4Y7P3tcKc817u0ISA8Chi6Z3/ZUE11HSNU5mV4tDFbqiKEpKKEihi0g98DPgXGxs4zPAa8AaoAnYBlxrjDlUEisVpURU1toOlapVqE6p5+y+7Il2Xwbpga4eSlL1RJPYLCJXAYcBWUeo0Hur4+5g52eml9KWUEea/LTFQpS2qvFkClXodwKPG2POwjYEeBVYBaw1xswH1kaPFaXS0LWtpIYBFbqITALeDfw1gDGmA+gQkWuApdFp9wJPA18vhZGKUgoqbW33TjyEBH9zcJ5JqIfulHY3QZ2YQtL9whZ3xtVaifVg3P4tX8nnXzdQ/5n8Wu+9feeqxgunEIV+GrAfuEdEXhSRn0UNdacbY3ZH5+zB9mfMQ0RWisgGEdlQHJMVpWgMeW2H67q5uXkETVaUvinkhl4FLAL+rzHmAuA4vb6CGisFEsPixpjVxpgLC6kUpigjzJDXdriuGxsbR8RYRRmIQoKiO4GdxhjX++wh7KLfKyIzjDG7RWQGsK9URipKiaistR2m7/k/MdJ7ytdAcY0rcs5LutZgg5AJO0u9m8fv8uxbKybVqElsWKEMmgEVujFmD7BDRN4WDV0BbAQeBZZHY8uBR0pioaKUCF3bStoodGPRF4H7RKQG2ArcgP1j8KCIrAC2A9eWxkRFKSkVs7aTm1KUF0mbgfKbayiloqAbujHmJSDJB35Fcc1RlJFF17aSJnSnqKIoSkrQWi6KopQUDXKOHKrQFUVRUoIUUlWtaC8msh+b61vJOzEaqVz7K9l2GNj+U40xU0fKGEe0rrdT2Z9vJdsOlW1/IbYXtLZH9IYOICIbKnmTUSXbX8m2Q/nbX+729Ucl2w6VbX8xbVeXi6IoSkrQG7qiKEpKGI0b+upReM1iUsn2V7LtUP72l7t9/VHJtkNl218020fch64oiqKUBnW5KIqipIQRvaGLyJUi8pqIbBGRsu4CIyJzROQpEdkoIq+IyI3ReIOI/E5EXo9+Th5tW/tCRLJRne/Hosenicj66PNfE9UvKUtEpF5EHhKRTSLyqoi8o1w/+0pa16Bre7Qp5doesRu6iGSBHwNXAQuAT4nIgpF6/SHQBfydMWYBcDHwt5G9ldSe7EZsSzXH94EfGWPOAA4BK0bFqsKoiNZwFbiuQdf2aFO6tW2MGZH/gHcATwSPbwJuGqnXL4L9jwDvwzYQnhGNzQBeG23b+rB3drQwLgcewxa5awaqkn4f5fQfMAl4kyjGE4yX3Wdf6es6slnX9sjZXtK1PZIul1nAjuDxzmis7BGRJuACYD0Ftt4rA/4B+Br4Jo9TgMPGmK7ocTl//sNqezjCVOy6Bl3bo0BJ17YGRQdARCYAvwa+ZIxpCeeM/XNadmlCIrIM2GeMeWG0bRkiw2p7qBSGru1RoaRreyRv6G8Bc4LHs6OxskVEqrEL/j5jzMPR8N6oLRll1Z4sl0uBD4vINuAB7FfTO4F6EXEVNsv5809qDbeI8vzsK25dg67tUaSka3skb+jPA/OjaHQN8Elsq6+yRGyTw7uBV40xdwRTZd+ezBhzkzFmtjGmCfs5/7sx5jrgKeBj0WllaTtUXGu4ilrXoGt7NCn52h7hgMAHgc3AG8D/Gu0AxQC2vhP7tee/gJei/z6I9detBV4Hfg80jLatA7yPpcBj0fHpwHPAFuBXQO1o29eP3QuBDdHn/y/A5HL97CtpXUf26toeXbtLtrZ1p6iiKEpK0KCooihKStAbuqIoSkrQG7qiKEpK0Bu6oihKStAbuqIoSkrQG7qiKEpK0Bu6oihKStAbuqIoSkr4/y/9nTCbjLbnAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(rand_x) - 1)\n",
    "rand_x = rand_x[random_index:(random_index+1)]\n",
    "\n",
    "for i in range(10):\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(3)\n",
    "    f.set_figwidth(6)\n",
    "    axarr[0].imshow(rand_x[0, 0, 0], cmap = 'gist_gray')\n",
    "    rand_y_hat = conv_lstm(rand_x.to(device))[0][0][:, -2:-1, :, :, :]\n",
    "    axarr[1].imshow(rand_y_hat[0, 0, 0].data.cpu().numpy(), cmap = 'Greens')\n",
    "    rand_x = torch.cat([rand_x, rand_y_hat.data.cpu()], dim = 1)\n",
    "    rand_x = rand_x[:, 1:]\n",
    "    plt.pause(0.01)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}