04_02_EXP_ConvTimeLSTM_SeqToOne.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": "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\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": [
    "class ConvTime_LSTMCell(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, GPU):\n",
    "        \"\"\"\n",
    "        Initialize ConvTime_LSTM 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(ConvTime_LSTMCell, 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",
    "        ## Defining the input convolutional layer ##\n",
    "        self.i_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "        \n",
    "        ## Defining the T2 convolutional layer ##\n",
    "        self.T1_conv_x = nn.Conv2d(in_channels=self.input_dim,\n",
    "                                   out_channels=self.hidden_dim,\n",
    "                                   kernel_size=self.kernel_size,\n",
    "                                   padding=self.padding,\n",
    "                                   bias=self.bias)\n",
    "        self.T1_conv_t = nn.Conv2d(in_channels=1,\n",
    "                                   out_channels=self.hidden_dim,\n",
    "                                   kernel_size=self.kernel_size,\n",
    "                                   padding=self.padding,\n",
    "                                   bias=self.bias)\n",
    "        \n",
    "        ## Defining the T1 convolutional layer ##\n",
    "        self.T2_conv_x = nn.Conv2d(in_channels=self.input_dim,\n",
    "                                   out_channels=self.hidden_dim,\n",
    "                                   kernel_size=self.kernel_size,\n",
    "                                   padding=self.padding,\n",
    "                                   bias=self.bias)\n",
    "        self.T2_conv_t = nn.Conv2d(in_channels=1,\n",
    "                                   out_channels=self.hidden_dim,\n",
    "                                   kernel_size=self.kernel_size,\n",
    "                                   padding=self.padding,\n",
    "                                   bias=self.bias)\n",
    "        \n",
    "        ## Defining the activation convolutional layer ##\n",
    "        self.c_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "        \n",
    "        ## Defining the output convolutional layer ##\n",
    "        self.o_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim + 1,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "\n",
    "    def forward(self, input_tensor, time_tensor, cur_state):\n",
    "        \n",
    "        \n",
    "        ## Getting the h_{m-1} and c_{m-1} ##\n",
    "        ##     the previous hidden and activations ##\n",
    "        h_cur, c_cur = cur_state\n",
    "\n",
    "\n",
    "        ## concatenate the prev. hidden state and the current input along the color channel dim ##\n",
    "        x_h_combined = torch.cat([input_tensor, h_cur], dim = 1)\n",
    "        x_h_t_combined = torch.cat([input_tensor, h_cur, time_tensor], dim = 1)\n",
    "        \n",
    "        \n",
    "        ## The input gate ##\n",
    "        ## Running the input convolution ##\n",
    "        i_conv_outputs = self.i_conv(x_h_combined)\n",
    "        ## Running the input LSTM gate equations ##\n",
    "        i_m = torch.sigmoid(i_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The first time gate ##\n",
    "        ## Running the first time convolution for x ##\n",
    "        T1_x_conv_output = self.T1_conv_x(input_tensor)\n",
    "        ## Running the first time convolution for t ##\n",
    "        ## Ensuring that the theoretical constraint of non-positive is met ##\n",
    "        self.T1_conv_t.weight = torch.nn.Parameter(self.T1_conv_t.weight.clamp(max = 0))\n",
    "        ## Passing the convolution ##\n",
    "        T1_t_conv_output = self.T1_conv_t(time_tensor)\n",
    "        ## Performing the internally nested non-linearity ##\n",
    "        T1_t_conv_output = torch.tanh(T1_t_conv_output)\n",
    "        ## Consolidating the output of image and time ##\n",
    "        T1_conv_outputs = T1_t_conv_output + T1_x_conv_output\n",
    "        ## Performing the externally nested non-linearity ##\n",
    "        T1_m = torch.sigmoid(T1_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The second time gate ##\n",
    "        ## Running the second time convolution for x ##\n",
    "        T2_x_conv_output = self.T2_conv_x(input_tensor)\n",
    "        ## Running the first time convolution for t ##\n",
    "        ## Passing the convolution ##\n",
    "        T2_t_conv_output = self.T2_conv_t(time_tensor)\n",
    "        ## Performing the internally nested non-linearity ##\n",
    "        T2_t_conv_output = torch.tanh(T2_t_conv_output)\n",
    "        ## Consolidating the output of image and time ##\n",
    "        T2_conv_outputs = T2_t_conv_output + T2_x_conv_output\n",
    "        ## Performing the externally nested non-linearity ##\n",
    "        T2_m = torch.sigmoid(T2_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The c vectors ##\n",
    "        ## Running the c convolution ##\n",
    "        c_conv_outputs = self.c_conv(x_h_combined)\n",
    "        ## Computing the c tilde and c activation vectors ##\n",
    "        c_m_tilde = (((1 - i_m * T1_m) * c_cur) +\n",
    "                     (i_m * T1_m * torch.tanh(c_conv_outputs)))\n",
    "        c_m = (((1 - i_m) * c_cur) +\n",
    "               (i_m * T2_m * torch.tanh(c_conv_outputs)))\n",
    "        \n",
    "         \n",
    "        ## The output gate ##\n",
    "        ## Running the output gate convolution ##\n",
    "        o_conv_output = self.o_conv(x_h_t_combined)\n",
    "        ## Running the output LSTM gate equations ##\n",
    "        o_m = torch.sigmoid(o_conv_output)\n",
    "        \n",
    "        \n",
    "        ## The hidden vector ##\n",
    "        h_m = o_m * torch.tanh(c_m_tilde)\n",
    "        \n",
    "        \n",
    "        return h_m, c_m\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 ConvTime_LSTM(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(ConvTime_LSTM, 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(ConvTime_LSTMCell(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, time_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",
    "        \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",
    "        cur_time_input = time_tensor\n",
    "\n",
    "        for layer_idx in range(self.num_layers):\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",
    "                                                 time_tensor = cur_time_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_time_lstm = ConvTime_LSTM(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": [
       "ConvTime_LSTM(\n",
       "  (cell_list): ModuleList(\n",
       "    (0): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(129, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_x): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_t): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_x): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_t): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(129, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(130, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (1): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(192, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_x): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_t): Conv2d(1, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_x): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_t): Conv2d(1, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(192, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(193, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (2): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_x): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_t): Conv2d(1, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_x): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_t): Conv2d(1, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(129, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (3): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(65, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_x): Conv2d(64, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv_t): Conv2d(1, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_x): Conv2d(64, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv_t): Conv2d(1, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(65, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(66, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_time_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_time_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 = 64\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_time_lstm = torch.nn.DataParallel(conv_time_lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0 \n",
      "\tBatch loss:  0.019063185900449753 \n",
      "\n",
      "Epoch:  1 \n",
      "\tBatch loss:  0.015539495274424553 \n",
      "\n",
      "Epoch:  2 \n",
      "\tBatch loss:  0.01512474101036787 \n",
      "\n",
      "Epoch:  3 \n",
      "\tBatch loss:  0.012715155258774757 \n",
      "\n",
      "Epoch:  4 \n",
      "\tBatch loss:  0.011914855800569057 \n",
      "\n",
      "Epoch:  5 \n",
      "\tBatch loss:  0.01031804271042347 \n",
      "\n",
      "Epoch:  6 \n",
      "\tBatch loss:  0.010855745524168015 \n",
      "\n",
      "Epoch:  7 \n",
      "\tBatch loss:  0.011242993175983429 \n",
      "\n",
      "Epoch:  8 \n",
      "\tBatch loss:  0.010622349567711353 \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_time_lstm(batch_x,\n",
    "                                     torch.ones_like(batch_x) / 10)\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_time_lstm(rand_x.to(device),\n",
    "                            torch.ones_like(rand_x).to(device) / 10)[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/UCwAAIABJREFUeJztvXmYHGd17/893T3Tsy8arZZkZCPvJhgsjB2zGBu4LL6YBOKwhJjEiSGX5BduEoiTPL/8fCG5lyQ8LDfJw8VhsUMgwLVxbIxZjGwRE4xtGTsGW15lyZKt0Wg00mj2mZ5+f39Uqc55a7p6ema6u1oz34+eeXSqupa3uuv02/V9z3uOOOdACCGEkPTIpN0AQgghZKXDzpgQQghJGXbGhBBCSMqwMyaEEEJShp0xIYQQkjLsjAkhhJCUYWdcI0TkOhFx5q9fRG4XkV+q4jk+KSJ7qnW8hHPcELuOUn831LINhJRDRN4uIj8QkcMiMi0iz4vITSLyprTbVk9E5P0xvxwQke+LyMtrfF7ve8i0o2MBx/ioiFxSxTZdHrZhS7WOWWvYGdeWYQAXhX8fBnA6gDtFZFWqrVoYH4dew0UA7gbwUGzdx1NrHVnRiMinAdwM4HkAvwPg9QCuBdAK4Lsi8uIUm5cWlyLwyw8AWAPgbhE5qY7n/054/vEF7PNRAJfUpDUnCLm0G7DMKTjnfhraPw1/Pd4L4E0AvpZaqxaAc+4ZAM8cXxaRIQAZc12JiEirc26ilu0jKxcRuQLBj9zfcs7dEHv5KyLyXwEk3n/L+P58wDk3CgAishPAXgDvBfB38Q1FRADknXOT1Tq5c+4QgEPVOt5KgU/G9eU/w/8325UiskpErheRgyIyKSI/EZFXxrbpEZGvicioiBwQkb+oW6srQERaQlno90XkH0RkEMAD4Wv9IvJXse0/GG6fM+vWiMgXQ3ltQkTuEZHz63wp5MThwwg6nhtKveic+7Zz7oXjy+H99kci8hkROQTg5+a1K0RkZ+h//SLytyLSZI8nIueKyHdEZCT8+78ist68fkl4jkvC10ZFZLeI/LeqX3mFOOf2IegYt4RtvE5EBkXkVSLyAIBJAL8WvlaV76FSMrWItIbv6V4RmRKRZ0Xkf4Wv7QHQB+D/MxL7JeFrGRG5VkSeDvd7UkSuip1PwusaCD+XfwbQVa33sF7wybi+nBz+/+zxFSKSB/BDAD0APgJgAMDvAfihiJzmnOsPN/0yAhnnvwPoB/AnAF4MoFDuhOEv3+x8DXPOlT3OAvgLANsB/MZCdhKRVgQSeB7AHwE4DOAPAGwXka3OucEqtY8sA8IfcRcB+OQCd/0IgH8H8D6EDyMiciWAfwXweQB/jsCv/lf4+p+E22wF8B8AdiK4t3MIhme+LSIXOD+v8D8BuBHA9QDeDeAfRWSnc+7+MteTwfwPR845N7uQixWRTgCrEHxnHKctbN/fAngSwAu1/B4Kv4NuhQ5pPQhgI4BXh5v8CgLfvwnAF8J1j4X//z2AqwB8DMDPALwBwJdE5LBz7vZwm/8HwF8C+J8A7gHwq+G1nVg45/hXgz8A1wEYROC0OQQ37J0IxlvzZrurAUwDOM2syyGQhv8uXD4HgAPw62abDgBDAPbM0473h/uW/VvAdd0EYEeJ9S3hse4t8Vo/gL+KrftguH0uXP4QAklxi9kmD2AfgI+n/Xnyr7H+AKwL758PxNaL8bkcADGvOQA/K7H9XgBfjq3/7fB+7AuXvwLgCQDNZpvTAMwCeGu4fEl4jo+ZbZoQPJl+Yp7ruaECP90xzzGO+3p3eO2bAXwDQUd5XrjNdeE2V8T2rdr3kGlHR7j8X8Llt5Vp+yCA62LrtgIoArgqtv6fESgiQPCg8QKAz8W2uTM855a079VK//hkXFv6AMyY5cMAXuGcmzLrXo/gl+KzVrIF8CMA20L7FeH/tx5/0Tk3KiJ3AvBkpBJ82+xfD76zyP1eD+A+APvN+zCL4JfutsS9yEonXunmj+GPjf4BgH8wy3fEtj8dgWL1zZj/3YXgB+a5CHzx9QieJotmu2cB7EFwf9r7/gdR45ybEZGnAGya5zqui7WzFCPzvH6co8YeBPDbzrmHzToH4LuxfWr5PXQpgCHn3G0Vtv84lyHojG+JtWk7gHeLSBbBD44Ntk0h30JwTScM7IxryzCCGyIL4KUIJLWvicjFzrliuM1qABfC77SPczxwaj2AETc3yGKggjYMhe2oFwcXud9qAK9C6ffh0cU3hyxTDgOYwtxO7isAdoT2AyX2i9+fq8P/4530cTab7f40/Eva5jhHY8vTCDr2cjwHYP8821RaYu81CCKZBwHsM981xzninJuOravl91AfgAPztnouqxF8dyZ9f20I21SqDZV8NzYU7IxrS8E5tzO07xORCQQSy68hkI+AoLPciWB8Js7xJ+h+AJ0i0hJzhLUVtOEqBOM88yEVbFMJpb4wJgE0x9b1xpaHEIzJfbjE/ssx4pUsAedcQUTuBfBGBOOFx9cfRNjhBkOVc3eNLQ+F/1+DYAgpzrNmu1ugY5qWasQzfAmBr5bjR6hs+s9DLoymTqCUj9bye+gwgo5zoQwhkNgvRvCEHGcA2ofF21DJd2NDwc64vvwL9Nf18c54O4IvlOecc0m/5o7/wr/i+H5hpOIbAByb55z1lqlLsR/AWbF1b4wtbwfw/wLY7ZwbAiHz8xkA/yYi73POfWWRx3gCwRzlLc65fyqz3XYEY6YPunBQsspch+rJ1Iuhlt9D2wF8VEQudxp0FaeUenAXgifjbufcnaV2EpF9CH4kXAHge+alXy3TnoaEnXEdcc45EfmfAL4qIpc557YjeFL+IIAdIvJJALsRyDoXAOh3zn3aOfeoiNwG4HMi0oVA8vkIKphU75w7jOCXaZrcAuBvROSjAB4GcCWCgDbLFwD8LoL34VMInkhWI4jAfNY59491bC85AXDO3SoinwFwg4i8DsEPz0EE/nP8x165J0Q454oi8scI5iV3IRhLnQZwKoC3A3inc24cQWd5P4DviMiXwvNsRNAR3eCc27HEa9mDYPw5LWr5PXQngO8jGKI7HhW9AcBrnHMfCLd5HMBbReR7CD6zJ5xzT4jI/wHwdRH5WwRP7i0IfhSd7pz7HefcbPjaJyWYTnkPgHdg7o//xiftCLLl+ocwmrrE+iyC6QTfN+u6AXwWQeTwNIInyW8BuNhs0wvg6wDGEMhwf4lgDHpPna9rvmjq3ynxWjOCKQoDCH4YfBLA78NEU4fbrQLwjwieVKbD9+P/Argg7c+Tf437h2BqzJ0IZM0ZBNG1NwN4c2w7B+D3E47xZgRf5GMInvIeBvBXsfvzzPD+H0IwdPI0gulQm8LXLwnPcW7s2DsA3FSH9+H9MFHMCduU/F4KX6vK91CpdiDIiPbJ8JhTCH5s/7V5/XwAPw2P6wBcEq4XBENXj4b7HUIg1/+m2VcQTJk6hEA9+CqA9+AEi6aW8GIIIYQQkhLMwEUIIYSkDDtjQgghJGXYGRNCCCEps6TOWETeJCJPhEm8r61Wowgh9Yf+TEh6LDqAK0xF9iSC0P79COagvds591jZHQkhDQf9mZB0Wco84wsAPO2c2w0AIvJ1BBOvE523va3N9fT0LOGUhKwMXjhwYNA5t6aOp1yQP7e105cJqYQDL1Tmy0vpjDcimI92nP0okSxcRK5BkGoO3d3d+NAHfmcJpyRkZfAX1318b51POa8/x335mg/+bv1aR8gJyv/4y49V5Ms1D+Byzl3vnNvmnNvW3tZW69MRQmqE9eW2dvoyIdVkKZ3x8/CrlWwK1xFCTjzoz4SkyFI64wcAnCYip4hIM4B3AVhovUpCSGNAfyYkRRY9ZuyCEma/jyABeBbAl5xzrDtLyAkI/ZmQdFlS1Sbn3B1ILspNCDmBoD8Tkh7MwEUIIYSkDDtjQgghJGXYGRNCCCEpw86YEEIISRl2xoQQQkjKsDMmhBBCUmZJU5tWGiL626Wpqcms122mp6dLbu9c0TvWYqtlEbJikfk3qZRMgi/bc8xMz+hq4+RF+vLyJ4WPlE/GhBBCSMqwMyaEEEJShjL1AmhuVjkrm82W3KalpSWyrbQVl7KmpqYiu1j0ZS9CVixVlKLL0WR8OZct/TWYbVEfr6YvuzQ0ULJ4ku7JKn+MfDImhBBCUoadMSGEEJIylKnLYKUpwJemc7nS0dSFwmzCsXxNw8rZk5NW5iq9PyErgnLS3xIk7PK+nCu5XaFQqOhYvi9PRnaSZC1lLoQSdgNiPxJJsOPbLQI+GRNCCCEpw86YEEIISRnK1GWIR0zn8ypHWWnKMjWlMlUmo/vH5eepKU0OYs9DmZqQBJLkwgqI+3JLBb48aXw56/myLz/baGrflzlLYlnDaGpCCCFkecHOmBBCCEkZytRlmJ31JWNfzlKNYmZGoy4zmYyxVUtraWn3jmUlbEuhoPlwmfOWkOpQzpdtBHMh0ZfVjsva9jWLjcamL5P54JMxIYQQkjLsjAkhhJCUYWdMCCGEpMy8Y8Yi8iUAlwMYcM6dG65bBeAbALYA2APgSufckdo1Mx3i0yFmZmYStrSYuqdFO6487W3V3q5jyHY8y9ZDju9DyFJZ9v6cMP1pMb4sni/rNKXpRflyJd8d/jmZjStF7NQ5l2BXmUqejG8A8KbYumsBbHfOnQZge7hMCGl8bgD9mZCGY97O2Dn37wCGYquvAHBjaN8I4O1VbhchpAbQnwlpTBY7tWmdc+5AaPcDWFel9jQUcWkrl9NlO51penrKbKX6hk0on8/nE8/T0qKvjY2NLaaphCyFZe/PcV+2y3Y6oc2MZ+tBiOhzSz7fnHie/AJ9OS5FW5k6qaAE5esKSHqLyhV3qFMt7SSWHMDlggl0iXeHiFwjIjtFZOfY+PhST0cIqSHl/Nn68vgYfZmQarLYzvigiGwAgPD/gaQNnXPXO+e2Oee2tbe1LfJ0hJAaUpE/W19ua6cvE1JNFitT3wbgKgCfCP+/tWotaiDiid6np1XOspHOVvKyctbk5ERkt7a2escSk52rqanZ2PqR+PI3ITWj/v5ciSS4GDU24biu6B/MRjfb6OisGYrKGF+eKOfLRs9uMnXOc8aXp6wvl7kuZ+qeJ8nU5eohV8KKkLmToqHLUUnd4jSjqUXkXwHcC+AMEdkvIlcjcNo3iMhTAF4fLhNCGhz6MyGNybxPxs65dye8dFmV20IIqTH0Z0IaExaKmEOyBDQ2NhrZ7e0dkd3crNKUzQff0aHbtLb6yeXb2jRRwLGRY5Gdy/EjIWReKoiCLSfn2khnm7SjuVmHjGxxh/YO3SYuU7cn+LKVrL22GHNOAYk6RPcysUhjwnSYhBBCSMqwMyaEEEJShppoDL82qa8TWUXJJgCx0dBWZrZRljbKOr5/d1d3ZI8b+WzczMtmbVRCDBVIuEl1hgHfh7KeL5to6ARfzsR8OZvgy2MJvjxb0PzVRfgzNuotG1OyNpzoST8IIYQQsjTYGRNCCCEpQ5k6hnNWNvLz2VoJK5/X6OjOzk7dI6u/b2z+ahtZHRxL3/piURMCNDfnzTalJbPJyclYm1e4vERIiCe7lvEL61stCb5sZW47TBT3ZS+5h/Hl/BJ92crGleSpXkwykBUvTTcQfDImhBBCUoadMSGEEJIy7IwJIYSQlOGYcQw7ZjO3UIQmlG83VWvs+K8dW2pp0bEoO5UJAFpb2+bdx2YDsuPPdhvAH3fi+DEhAZX7smbQsmO7yb7sf222GV+205aSfVmLVNj6x0DtfJljwwmkPJ3JwidjQgghJGXYGRNCCCEpQ5m6DFJGwpgwclLOJIS3cpTN2hOXnMbHNTtPR4dOp5ic1KkR3T09kT1yTBPQT02pxEbISqeSKT1SxpknJ9SXmxJ82Z6i6HzJ22bXstOebD3z7m7NzHXM+PKcmuUuwV5EMQxyYsEnY0IIISRl2BkTQgghKUOZOobNuhOXttraNGrSZtexWbdmZ2fNHrp/sejL1JmMvmazbuXzaufG9eOx9ZOBMVis5E3ISiMpUrhSX27Om6El45c2mtqrQRyLzLZFYGxt82bjy9lcaSl7LOa6Y2PjqBaMoA45QZR8PhkTQgghKcPOmBBCCEkZytQxrJycy/n6xsSERkdOz0yb7fRttDL1kSNHIjsuk61du8YcV6WpbNYkBzG7WMktnqh+eHjYnL8AQgjgjC9LOV82Ec2ZnPpZcVbl6PK+vDayx81xc8aXbdSz78s6kwIAhoc10rqwQF+mLH1iwydjQgghJGXYGRNCCCEpQ5l6Dir1zM7GoybVthKWXwNZ91+1alVk9/b2wGJz4NpEHzaCs9Xkth2ZGTXt8GUy5qMmK5lKEl8UY75sd/H8vLQro8/4ck9vr3eo5iaNxra5pZNyW4+OVs+XKU0vH+Z9MhaRzSJyt4g8JiKPisgfhutXicidIvJU+H/vfMcihKQHfZmQxqUSmboA4I+dc2cDuBDAh0TkbADXAtjunDsNwPZwmRDSuNCXCWlQ5pWpnXMHABwI7RER2QVgI4ArAFwSbnYjgB0A/rQmrawj5XLY2kQBXV1dkW2jI23SDmvbMovBskpbGzduiuz+/v7IHh5WCaqtTaO044kByrWZkOOsZF+Oy7meL3ebiGazT1u+NbLzeVMO0fgu4Oew3rhxY2RbX3buaGTPzupxbV7r2OnJCmNBAVwisgXAywDcB2Bd6NwA0A9gXVVbRgipGfRlQhqLijtjEekAcDOADzvnjtnXXBB1UDKSQESuEZGdIrJzbLx6qd4IIYujGr48XsW0jYSQCjtjEWlC4Lxfdc59K1x9UEQ2hK9vADBQal/n3PXOuW3OuW3tRhoihNSfavlyWzt9mZBqMu+YsQQDL18EsMs59ynz0m0ArgLwifD/W2vSwjpTbmpBa6t+AeVyml2naUIfLty3b47sMZNAp/e97/KO1TapY8CZLj2uza41NaVTnmxmLr8YhT9mHXspImlcee76ag5a6Xtp31dOxUqHlebLtu5wJnZft7bquK31n2NmbPeO3b+IbDHbvP3MV3vH2tRzstlOz9PR0R7ZU1M65SlToS9LfDrW8fXGZ+20rlrGjjj6cs2pZJ7xxQDeB+DnIvJwuO7PETjuN0XkagB7AVxZmyYSQqoEfZmQBqWSaOofI/lx6bLqNocQUivoy4Q0LszAVQY/sxYwOjoS2cWiJod/8u8/H9k/HtBtevOaZatvt1UFgfb1OgXi5DadAnXR7703skfMlAmbtSeOlbaPHj1Schtbc7V+JEloNnsZZS6yCMxt4yThHjKr4/XER0fUT1et1hwnn7r9a5E9sV8LsNhhqV/86OfesTa/5MWR/ZHLfzOyezo1a9cxc76RCn35yFGVzOslRyeRdP4ifblqMDc1IYQQkjLsjAkhhJCUoUxdFl8OslmzDh14IbKfHlLZKd+iknPW1Co95vxjTZv6qPm85li45e+/EtkXX/Eq3aZzfWQPH1P5DEiWraxs5G+SHA1pozmTVCcvmjN2bn8xSU4rHU0ab0t8mIAQxdOp592mCD9quZjVe+tTP/xyZI89NxTZNkuXrTucyfjnO/Lswcj+33d9M7I/9Lp3RHY2a7P06ffIsWFvmndipLTvy/P7e9DOTOJrJc8XP65Ys/Q5sxX6cpG+PC98MiaEEEJShp0xIYQQkjKUqWOUi1QsFo3U8sh9kTncrEnk13epnNVuIjAzsWjmgokALRh5x5OWHn44sosXvzGy20zCAgAYGx1LbLO2vXQ2kLlR1la2mvewJaRlteNyXunzJ8tkNgKWkZrE4sosHWfGTUf2f+y/33tt116VljtmdNZDp4lmbm9XO2Nk5syc+1S/F2YH1Bf/4fsqWf/6ha/THWZ1/9a4L48lR1qXOp+l3HdXJRHYc3zMLMoSfdktxZfjmy/TYhp8MiaEEEJShp0xIYQQkjKUqWMkRyAD4+MqQcnWl0Z2292aBOCCt2yL7OYLNKnRxITmpgWAVsxE9nNfvSWyB7Maafmjhw5H9mlnam3UTFu3d6y+vr7IHh7WSOuZmWnMx9yI5dIRmMnSkr/eyt6znvy+cG0pk7GRmoUyW5KVRiV3U05Ufr5w/cu91zZ27ovsZ8Y1ghpO79+tW7TO+BlrNf/0s4P7vWM98ou9kX3o0GBkt49rNPaNP74jst/24osiu61J81cDwCrPlzXSemZmBvNRTv6txJfjNZ8zCb5ciWQdJ5tJiLpOGGJIWr2c4ZMxIYQQkjLsjAkhhJCUoUxdhrnSqi6PT6vUsvUqLXKzP6/RkS0vHIjs1atXe0dqateo65Pf9trI3vWFb0X28LgWcD/zJ3dFtnv9r3jHsgkFkqKmK6USOdjKxzb6G/Blavv+WWXMRoPanL+VYmW2pV4vOVGZXyq1ZRM7m/2hnXPyunxOn27X3KTStr3P8xOazOeyF231jrXtRZrA50u3afVJO2Q0sXsisves3xDZZ3Wf4x0rmyktDS+GSva3/hv3ZStTe9J0gi9nl+jLsyeCL9vbrspSOp+MCSGEkJRhZ0wIIYSkDDtjQgghJGU4ZrwAslkdE+ns1DHfpiZ9G9vadapCS17Hmez4EwAUCjo+0tSldU/X9uhYVrNJVI+CGZvJ+seamtJpUwtNblNpbVTb/krHeZMyaMXbn7y/XnNSdh87NYtZuojFu7djt3k2qz7b2amZtnI5HTNub1f/azbFHeJjq+1F9fmmFt0u36z722PtH9WpVOf2+b4wPTn/dMQkKvdlbX+l47xJGbSq68u2sIeZcrlC3JpPxoQQQkjKsDMmhBBCUoYydRniUwPmFlUI6O1Vmbm7u6vkNvF9rTxTvP+HkT0yq/KMlZN6e3sju3W91j8GgMcffyKyrWxkp/340tDCf4MlScBWigaSM21ZaTtJTouvt8dK2qdY1FvYZhxb6rQQsrwozvqZ5opihjfM+t5V6medpuiLd/+Lf8/vG34usvNZlblhpNlMs96nl55xYWRv6NY65UCyL1uZ2KszXKE0bUnMwBXz5aRMW9kKfDleGMcey75mM3DlPF/WjGOF2HRLr86z2T9pfVWpoWTOJ2NCCCEkZdgZE0IIISlDmboMcTmnUFDpxGbXyZtIy7yJoLaaxthRk4weQP/n/ymyfzwwEtldXSpzrzZJ4zu3nqLnHtPMXACwdu3ayD5wQLN+LVWatljJ2ErA8WhKu2xfqkTmLpdNy0asJ7XLRnzH5fO5BTHIsiRBtS3GPv+ZBF9ublZfbmpWyblQ1O0fPfgL71hfvf37ujCpkqr15b6T1EdXdakUPjrm1yJfu25NZPf3a3GYxAjkReimsghfRgW+bGXumWJyYYtMk8nsZeune75sMoMV/e8ur5hPwgdeF8m6ysz7DS0iLSJyv4j8p4g8KiL/I1x/iojcJyJPi8g3RKR5vmMRQtKF/kxIY1LJ49IUgEudcy8FcB6AN4nIhQD+BsCnnXNbARwBcHXtmkkIqRL0Z0IakHllahdoAqPhYlP45wBcCuA94fobAVwH4HPVb2J6xBN1WHnIJv2wkX/7n3o8ssdv+kZk33tQE8UDQMFILU0m0cCkqXs8NKQJ6B+87T8ie8tLnvUbuu01ps0mSru4cGnaj2Cef/+4HJzLlU50byVoq3IVCgWz3pcSbQIGr56q167SElQu59/aldR2XgmsVH/OzvFlta0vT02r/937uPrcv9yjMx7yo/AxN3TOFJqwNcyH+rXO8Rf/XYtJvO+8t8aOZRtZ2q5UdrVSbyVR1/Fo6kyCL3sFHRJ8OT4s0JToy/O3a64vz1/b+USkom9rEcmKyMMABgDcCeAZAEedc8ff/f0ANtamiYSQakJ/JqTxqKgzds7NOufOA7AJwAUAzqz0BCJyjYjsFJGdY+Pj8+9ACKkpi/Vn68vjY/RlQqrJgqKpnXNHReRuABcB6BGRXPhrehOA5xP2uR7A9QCw8aSTToywtpC5SSj0t4uN7s3nWyJ79kffiey7BlVOkaz/VpvUAJ4aZesJj46qHnavif58dMSXvDt+8GBkd75ZayOjNSkBiZWi57waWX7e55KHmpPkY3q6tBxsj2WjNK0EFc95nZT31kZT2qGEpqZSW5dvi5XWVhoL9WfryydtbCBfTlA6vYQQZRLK2HtwKqO+tf2pRyK7fdr4b4Xfmp4vj6gvP3WfDmX93RMHvH3OOWdTZG90WvfYV69LR1aXk3w92dj75Mx7FMu5neTLxQp8OZ7zOjGHtWmL//1amTPb74Ka+XKd7vRKoqnXiEhPaLcCeAOAXQDuBvDOcLOrANxa+giEkEaB/kxIY1LJb7wNAG4UkSyCzvubzrnbReQxAF8Xkb8C8BCAL9awnYSQ6kB/JqQBqSSa+hEALyuxfjeC8aZlSzwJhZWBRkY0UYcX7XfOSyLzl3YdTDz2SedtjuzsmeeWPMfED3dE9gP9OkZ3+PBh71gDpp3NX/p6ZJ/xgav0uE2ajMSXs+LJMRamycQ3t9HUlkzGSFgVyM9xbAm2bHb+35CzsXy2ftk7te1xrb1cWan+PDvHl/UeHBk5FtlNHXpvre7TYZ7hw7oNJmK5kk10fyav+3vDTxM6zDQ9rfbhgUFYdvTrd8aqLXr+N2y8OLJzYs5RLgFIghydiItHU5f201ySL5vd5/iyWbR+Vkk51nhu6ngJy+PYz9jz5aQI9XKkMAjDdJiEEEJIyrAzJoQQQlKGnTEhhBCSMiwUUYb4VAE7JWZqSsP+Dx06FNnt3Todoe+a90d2S4tOfwL8caNJMyZis8s0vf3KyH5t/1ORvet2zQwEALvNTKdnRnRseas5VsbUWU2qOVwp9m3JZpOTuFtmTT3ZpiZNe2zHduLtsoey54mfU/fPJm6TlE2sWNSx9HEzD365ZvlZSdgpQPH6ul4WuGkz1jisL7xl46t1/826vy0MAwBTto52QY9ls76NO53a9PWHfqTnO+RPU7Q8+ez+yH7tuqnIlmy5qYmWCvzcHCATi+VILO5iMmjZKUheDfGMv6+dDuXMa7O2NrN5NszZKVMZv5vK5u1nqQfIz57YvswnY0IIISRl2BkTQgghKUOZuixxmUeXV69eHdlWErXyiM2gZW3AD89va2uP7D5z3JyZwlPzgGGOAAAekElEQVToPj+yTx/ypzY9dsfOyC7OJk3PqUyatrJxUnafSpK7x7EStJXvrGQdn+ZgpWUrgdnhArs+KWMQ4GdJ89tlM3hZyc1OeUqus0waFy8DV+z+t/fw6j71OSsB25SfY+Nad3gsVoPYSuDt7W2RvapnlW5jpvx9uE+Hsj51yz97x5o6qscePabTqUZndCplPqtybLlZO74vm+0q9eWEqVHOPMJNTOl7lGuyw0R+15IzU8lsLWlbJ9omCZue1nZlY0MM2ZbWks2138PWl63/zjbw9EU+GRNCCCEpw86YEEIISRnK1GWI19f1Mu0Y2bW1ta2kvVTiWYOidnX6BSAGBgb0NRMB6QZf0I02bY1MK1/Fr9HKtn49VJRcH8e+5n54i+5v1g88odHnPxvVmq/5vMpvQLIE7SX2n9Io0/M79b0/9fwt3rFa3vru0m0075eNku0yb/ExIxfG22XPTxqMMhmhxBmp1vPlVmOXHtqYKwi7Eha8kO1Zr263ri/mfV/yfNl8O4/NqHzd16KyuufLsXrEVrb1fNZGUFfoy/axzcEM4Tj1hZEpbaOL9SwzBfXfbFG/YzpatJZ0wUSiZ42s3dre4R0r36zfE0kZwPxhqe7IqtSXndibB3WBT8aEEEJIyrAzJoQQQlKGMnUZ4tKWlYRssQYbEexF8bnkyD17bC/SMyG4ceqxByL7u9ff7B/LyFNWcpPVJ5U8XzndxcrWNpm+leWT5HrAl6a/c/8es4+tk1z6/OXqkVoJ28rU9ri7jKr/xM7nvP3fctbPdWHjaZFZSd3UeGSoXbbSWrw4BakhCX6S5EtxX7S+PDiowybr1q+PbFuz3L9n48lpEvzJSJ2Fot4b335qR2Qf2PWs3y7Tzoy5z2eNHFy09bzLFlfR17I2UYiRn20kuGSSI87tve0VpDByf15U4s8UY0l3Mio15438b2dQFLIFs70tgOF/dtNmNgamtC1NzX4yllLEi9TYZfv9Ey9OUQ/4ZEwIIYSkDDtjQgghJGUoU5chns/YRhTbfKdPf+LjZiuVU0+6+JzIbj//YlhsdPDMUa1pOnbPv0f2vY9obtqD45rDNhY06Uk6v9RuoghzKsEmT/T3pSkbQWkl6KQaxHHcpVfown2ficyXmXad/kqN7LYSX9crLvSO1X7Gy0ueo/Un34vsfeY9uv/ISKnNAQA7bt4R2f/lI1o/+ujRo5FtpfBi/E1OoK1NI7htXVxSYxI+Hi8K1hDPTW0ZN4krfvy4+t9jIwci+9JTtQT0qatf7O1vo3AHRrUe8R1P3hvZTz/4TGRPj+kMgngN4oyJgH75K86M7E3tWv/cXot3XTHpPmtnQxg70Zdjb50nTZv31Urp3d0aqWz37+4y6wG0tpWeZWKTpExO6ftipej4MMDYMY3atsNEw8PDkW19OR5lnoT15WMp+DKfjAkhhJCUYWdMCCGEpAw7Y0IIISRlOGa8IEqPu05M6PjxTwZ1DBJfP2jsu2rRDADA6mb9GLd86OrILubMuEmZKRAWu50tluBlxzFjTvFE83ac+fI//++R3dPTE9nd3WqXy+xlp1nZ6UyTF785sjdfptf44Mf+ruT2ALCxXYtxnHrqqZHd36+fkS0AMDmp41c9vdpeACiYeAEbO8Ax4ypTrh5J0u2ctD42luzdt+a2u3PXQ5E99LRmw/r5jkeS25Lx5lDN35akdgDoPXVNZL9q07bIzmdsdjopYc3FurwtIDPr+XLpzFzxtrmEceKubk1VZ+sOx6cDuqL1ZY1lGTPFOHLNZiw7Y6dreofCxk2bdB9znoOV+HKP78u2aIX15XimropYWpl4PhkTQgghacPOmBBCCEkZytRlmJNcPqH2Z8+73hHZL/qnr0X23qlFZHFJSG6fNVLYaa1+1qjTP3iVLjSbLDjmYLaMp72OYjFeDKN0s2ymnHLJ5W3idbvdkSNHIrvLTHuYNNNCrPxbHm3k9k9/LrI7OzTLT3Mss9ZbX3lKySP19WnNWZtVzcpvcXIJdY+t/FYoVHotZFHY+zRRDrbTcZJf6x/TKUxHhhOmx5WTnGdLv2inLVlfzqxWH33fq9/o7bOxUyXYjMmAZwtb+Fny1Mfivpwkm2atL1spOrZdwZvaZLIPHtGpmO1dOh1oekKnI8Wz6dk226lRk0Wdsjkp+l1QzGtrTlm9xTuWnf5l6evr0zYaX7bTrOJTyZqMz1op32Zfm5mpTzauip+MRSQrIg+JyO3h8ikicp+IPC0i3xCR+XOREUJSh75MSOOxEJn6DwHsMst/A+DTzrmtAI4AuLrkXoSQRoO+TEiDUZFMLSKbALwVwF8D+CMJdM5LAbwn3ORGANcB+FzJA5ywJBeK8OTcDpU6z/09lYzPuucHkT267wgs9/SrHPZL7RopuWaNSlhNZ2umH9nwosjObfAlV0mUjbWRvsys6+MSTFJBCSvHJkVcA/HsPqWLQ+zdu7dku2zBDcCPfJTnn4zsw9/5j8jebCIrJyZU8jozlmRo1a/9dsntbLvaTcS1vY4pE40J+DK/zb7U2am1WY8cGUIjsix9OVGyLlOcxCyvbV0X2a97iWbNu+exxyN7+rBG/WLGrzPuHbnJZLrqUV8+Y4sWbblgg55jTeta71hino/Em72h22SzJrOe8eVCGV+28qyVY4vmuPH66dmk7xUjme97TjPgNZl2NTX7w0R22KfoVM6emlV72ibpMu9xcdr/julcr8NRhanSdaI9XzbfMROT6vtAZb48NOR/d9eKSp+MPwPgo0BUPqMPwFHn3PF3Yj+AjaV2FJFrRGSniOwcGx8vtQkhpH5UxZfHx+jLhFSTeTtjEbkcwIBz7sHFnMA5d71zbptzblt7Qn5SQkjtqaYvt7XTlwmpJpXI1BcDeJuIvAVAC4AuAJ8F0CMiufAX9SYAz9eumY2CjY5MWJ9XeURe/yuR3QmftyyhFfG6uUWjNWUypZPA28hmWwShXNKOZGm6dJQo4EdR2lrBNrlA5u7bzHptb3dvr3es5maV77/7oNYn9qJGR/QJ7VdffUZkn/q7f4Qk7HFHR0cju62ttdTmGBj2EwBUUgO5QVn+vpxU59jFX9DlZhOvdv6a8yP75a/VQiVJkm/8lF5BFv+V0utj6nmxYIbCsqUjna167Mr4spWwiwm+bKOc5/jybOnkIDYC2fNx892zapVGNgNAc97MNCiaRBuTak+NqBzc26HfBZs3a5GMoC0myrxZr3F0VBN9tCb48rEG9uV5n4ydc3/mnNvknNsC4F0A7nLOvRfA3QDeGW52FYBba9ZKQsiSoS8T0rgsJenHnyIIAHkawbjTF6vTJEJInaEvE5IyC0r64ZzbAWBHaO8GcEH1m0QWipWXiiYiMl6PuRTNsahHKwHbfNT2HMm1kX3ZR+76t8j+4SP9ifvoufd6y+vWaZSrrf9s2/Ka9ZrLt/1tvxHZNsnIXPT8AwOHIttGdttrP/lkXyY7cKAfpZiMRWo2MivOl8vmDS6d69mTk5eYd7hSrARuo5vL1WM+TjyC2frybIIv2zrFDn7U8qzokNNPDv5nZA+M6tDQWes3RHZvi0ZMP3LYz+V9CHqsvXs1yYpt47q1qyP75BdpDOHsHr9dZ686O7KbszrkNHBIc4k3mZzVVm7fHPPlfs+X9b2YmPBnUNQDpsMkhBBCUoadMSGEEJIyzE29zPDlZF1vc0ZbsrE8r14+bBO1mFSC0e173FsuPKmJnb7/M00IYOWofD6PUqxatcpbTorMtm35T5MP9+SnVUorbFEpC/DLqA0Oat5aG026erVK3p2dGmE7PZ2cZ9rmoLbJRAhZKp7PVeDL8ZzNyb5shqKcHmt6VpNeAMDDg7+I7Mf3aYB9V7fOGFndrFHP1hek1e9aJg7rrIXVqzSZj5Xi83n1uYGD6qMPTPrtWg8dvho9qhHU5rLQvkYl785mPe5MLP+9HRawSVPS8GU+GRNCCCEpw86YEEIISRl2xoQQQkjKcMx4GWOnOdlxomw2+WP3axUn1D3efktkfvunuxP3t7YdJ7Z1R7u7tdZoJjblqdnsM2vGj21Cd5sKzZ4vPn1q3IwB2ew869Zqov5cTt8XO04cTxRvpzBxnJjUAzu2ausB5yr0ZTtNq2Cydjlz3P2jGuMBAHtMsZOcqe+7zvjsc7PqG4NHdcpTYdLPEpgXM9XI1EaeMmO+Uxn1pdWn6Ljwq2LxHzNT2ua2Vk3Lunat7mN9eWpGvy8OD/kFXMYntM1T3nSmRcxlK1fzugL4ZEwIIYSkDDtjQgghJGUoU68QkuoUx6csWXnXFo2wtYazL9sW2bmdWsAhfjw7HanNVOyy9mvP0ikI2XNe4h2rZetLSx63/x8+H9nPZLVdP73jvsi+9J1+VaG2DpWj7TXaqQ5Wircy9fS0P7Wi3FQnQmpNUtGKcr5s7VyTTnN6+pj6744ndSoTAAwPac315oz68h5Ru2tE5ejpQZ2+lI1lDJs1Q062nTazWHeHltPJFbVr2tzrZ82aPqb+ZwvjJPuy+u/UlJ9Za8Zk9vNIrJFdO/hkTAghhKQMO2NCCCEkZShTr0BsZitbsxjwoxAtNgJ75hea6SoetWyzaL3zNWeVPJacdY4ubNIaxJnYua2c1draEtnnvEqPe+hRLfRgI66bdj/lHav71adFts3GZTl6dFi3MXJWLlbztKVF2zI2NgpC0sL6cnGOL6uEWzRa66jT+/zB53Q2xPSMHwHdt1qHkNpadAbCSSfrkM+5GzZF9iPP74vsoaMqcQNAb69m3Zqc0Wjojin1+VbjV4VpvZbdo3u8Y53VfWZkz0z5bT7O8PDRyJ4w/p5t8r9jrC+Pj6U7M4JPxoQQQkjKsDMmhBBCUoYy9QrHJgMBfNnLJpe3yJkqM/9qXMJ967t0OxMdaRMV2AoWNtFH/HzNJsG7lcl3/eSJyH5hVKWl9Ru0tmrPK3/Zb/O69ZF94MALkW2LRoyPawKCbIJcDwCzs6WlMULSxEvMA2DayMGTTv3ku3vuj+zBQZWsN29S/wGA0zeoz2zqU3tNixZUac2pfH1yl0rW2Zzvy9MZjVq+d++Tkb3/GfVFjKi0fMb5OhS1df0p3rHWmpkRh/oHI3vosPry2Jgm87ByPWIR5/b7Lm34ZEwIIYSkDDtjQgghJGUoUxOP2b1ajxhPa63i6Tf/uq5fd2pkNp1yrrd/c3Pe2Cphi5ncPzKikZY2Ynp8XKUlAGhtVQms46jWU31wRLez0dzTSRP4Ec8nrdGVNhp60tRNbWnR64hHU3d2qvxeKMwam8lASJ0xqmsRvkw9M6v+8MKEysGzRZVme3s7Ivuc9Ru9/U/u0+X2dq1h3NqsflmY0GPlxdQpL/izLExqahw7pj7njJRuffmsjSqLr25VWRzwI6jtzIjRUZPn2uSvt3nxszn/+bOrqyuyh48e03PM1N+X+WRMCCGEpAw7Y0IIISRlKFMTj/5/uyuyfzaqEtDbXq+Sl81THcfKOzai8dgxlYB6ejQBgI2yttIwALQNaUm3u27eEdk2yvoMU47tvPe+KbJHe3zJbcpIWLYtVn6zMrWVvzIx+dtK000miQBlauJRzZzGFeRKnin6OdSfPKJRy08d6Y/sHpPooqtN7/+uJpWsAaBNNL97h9OhmdFDKjOv6tVyqBnzbNcUG9p5vqC+PHNU29ls9OvxFvXlrd1bIntqzL+uoimJmOTLNgf1xKQZ/oolKbIR6DbhURoydUWdsYjsATACYBZAwTm3TURWAfgGgC0A9gC40jl3JOkYhJDGgP5MSOOxEJn6dc6585xzx0v2XAtgu3PuNADbw2VCyIkB/ZmQBmIpY8ZXALgxtG8E8PalN4cQkhL0Z0JSpNIxYwfgByLiAHzeOXc9gHXOuQPh6/0A1tWigaS+2HFiS+7gs5Hdfc4FkR2v9WvHWq1tpynZsRk7/jv5nX/1jnXTg/tK7jMxodOUXnaejg0Ptuj41djTT3vHsmO79lg2A1lfnxa5sNMk7PnizMw0TgafBUB/rgcy/yZLPq6ZGrh3ZK+32XcfeiiybW3yi1+q2a1O26DZrbozOs0HAIomVOLotGbHKjapz4wVdZriqFOfeXjfM96xnnxM6ybnzHEnzElec7bWMy8c07iMvf1+zfTmJjPt0PqyGf/tNQVrxsasL/vTJzPmzUw75qPSzvhVzrnnRWQtgDtF5HH7onPOhY49BxG5BsA1ANDd3b2kxhJCqsKi/Jm+TEjtqEimds49H/4/AOAWABcAOCgiGwAg/H8gYd/rnXPbnHPb2tvaSm1CCKkji/Vn68tt7fRlQqrJvE/GItIOIOOcGwntNwL4GIDbAFwF4BPh/7fWsqEkXSbv/llkt77itZE9ODjobWenJ83+4ObIPvyCytm7c7pNl8lmNWgSvQPA6GjpWsEXr1EJat17rolsO00hXnRiaEgDg6201dmp0zlsBqCkus4nOvTnZYCXdUsXfn7Il6lnh3WYaLao2+0eUMl5w3qTtWrYH3Iag0q6jxzUIaOuLvXZU086KbKfeV6/Cw7vPgDL6LCpb2zaf8ZFWs/81adpcZemjE6NKuRUsgaAoSNDkW39tL1DpzbZAjS5rPXlcmMHtRpXqIxKvnHWAbgl/KLKAfiac+57IvIAgG+KyNUA9gK4snbNJIRUCfozIQ3IvJ2xc243gJeWWH8YwGW1aBQhpDbQnwlpTJanFkcqxkrJ5XjMBA2/yOzzg9vv97azmWs6OlQCttHUfX1mvNHISUeO+DkmLuhROez033ybHvfM8835Skcz20ju+LINPpoy2bVsTIONEo9HWdpCE2lHYJJlhg2bq0A1tbMBRsZjUf8mghpGps7M6vpnDqq0fMzUEwaAp55U2bsDmrXraK8OH01M6nFbJzUE6ciQ78u5dh2aWr1Z6xG/47xL9Vpm9Vi26MXUZPKMDevLM9Pqi74vq0ReiH1f2AIyac+MYG5qQgghJGXYGRNCCCEpQ5l6hZN94zu85bec+URk3/Evd5Tc57s7dRK+LfoAAENDGuk4O6tRkDbqev06zSdhox7f8RJNRgAAqy9/dWTL5jNLX4DByldHj/qSWzarvztbTKJ8W3M5iUKhEFumNL0iSCr0UE4+rmZxiAUea1Ov74sja1WCHR3VyOh8h97/NhnOuj5NmgMAB7t0dsPMlPHlQ4d0H+PL0qLHeuUbL/SO9ZINmpzHzlqwhWKmZtV/3YxuM8eXMzpTwvNlrzhF6Q8p7sueNJ30uVbzMy0Dn4wJIYSQlGFnTAghhKQMZWrikTlZJ+G/5w9U9rJJP2z+aisTAcCmTZsie+2aNZF90thwZJ/7y1sju+2/vieyi0VfDxoZGUEprBw9Pm6SFkyZyOhYhqhVJletxUZTj5kkI34+2+Tc1GSZscBo5jnUI2+EaaOYE57dt9XbrCevsxkKeX3uOmvTqZHd3az5qFtyvi//8imaK3qqRWXqJ5/TKOutxt9b8zpjYnPnBu9YmSmVlotOjzU5pZHSoyPqcxkjWbfFMjf2rfLl9ONMG18erdSXK/m8KqglXQ34ZEwIIYSkDDtjQgghJGUoU5NEjnVqpGTLlb8S2W9dvz5xn/XrSr9m5SFn8kaPjY2X2hyAH7VsIzCtBGUl606T57rD5Kktx7g5/+CgRo8yYrrGLFUOruS41TxWpW2s5PxVlD2dOUB3s19Jy7Xra+MFvc9nh/Xe7t6kMnU+48vUp68/PbInZtV/T23bHNldeT2nTdThYkNOU0WVo03VR0yN6frijCmB2KXt6uxQvy6HHbI6fFhnb6SdzKNS+GRMCCGEpAw7Y0IIISRl2BkTQgghKcMxY1IRdmz2YH9/ZHd395TafA62vrCdsmQzYE3EijvMFnQKRJPZrre3snMmYcepD5lsQhwnriO1mgJUqyxKKWbWKn8AveDmTN7bqtuM53Y267hrwRRz2b3v2cju7e319u9Zo36WE1MDPK/jueNjOpZss3nFC7XMFnQ8uLm5ObLXr9Z6yBnRZ8OM90Em3yzjZtqS9eXFjBPbaWJ2LJ4ZuAghhJAVAjtjQgghJGUoU5MFYyWobHbUe23v3j3z7j8yovtYaczWPAaA1lh2r/mw0pSd5gAAAwNWwpoGWUbUSUZsHFROtYVW4s9WLVnfn45jizMMT2vd4cPDh73tnturBWHac5rNK5vRbsNmrevp1Sx3ba1+1qxcmw4zuYQPzErTtqBDfPrjoUMDkT09XcHQUpkhEUl6MYV7ik/GhBBCSMqwMyaEEEJShjI1WRJjY75MbZO19/WVLs7Q2WkS2JsI5pGRpUUz20IRNksXQGm64VhMreAk6pTIvzHRixeJvXnOvqars6IzG1blVyceuTCicnZTX3PJbTo7NLJ61gwTjcyMxrZ0xiodDW4l4+lpU0BiNP4ds8DviTKZ1JIk8zTgkzEhhBCSMuyMCSGEkJShTE2qipWDDx8eiuyODpWm8/nSklc5rARtpfC4TE5WONUs6LCY49YDr56xXe030kZaJ0UNZyX5eaxgZOehIY20tr7c3OwnGqkEKzN7vjw6Vmrz6tI4qvQcKnoyFpEeEblJRB4XkV0icpGIrBKRO0XkqfD/3vmPRAhJE/oyIY1JpTL1ZwF8zzl3JoCXAtgF4FoA251zpwHYHi4TQhob+jIhDci8MrWIdAN4DYD3A4BzbhrAtIhcAeCScLMbAewA8Ke1aCQ5MbGS9ZEjQ2W2JPXghPDlWtU5jtNIsvMSsG+XM8k8AABGgk5MblEhVloeGjpSZkuyWCp5Mj4FwCEAXxaRh0TkCyLSDmCdc+5AuE0/gHWJRyCENAL0ZUIalEo64xyAlwP4nHPuZQDGEJOxnHMOCUPjInKNiOwUkZ1j4+OlNiGE1Ieq+fL4GH2ZkGpSSWe8H8B+59x94fJNCBz6oIhsAIDw/4FSOzvnrnfObXPObWtvayu1CSGkPlTNl9va2wKp90SRe90y+jOI+Tf3mp3+kYZn3s7YOdcPYJ+InBGuugzAYwBuA3BVuO4qALfWpIWEkKpAXyakcal0nvEfAPiqiDQD2A3gtxB05N8UkasB7AVwZW2aSAipIvRlQhqQijpj59zDALaVeOmy6jaHEFJL6MuENCbMwEUIaUw41LkgshL/OucbWHVqGCPB3NSEEEJIyrAzJoQQQlKGMjUhZGms6HrCjcxCNdX4h3eizFtbHvDJmBBCCEkZdsaEEEJIyoirY3YWETmEIAXfYN1O2nisxsq9/pV87cDCrv9Fzrk1tWzMUgh9eS9W9me6kq8dWNnXX3VfrmtnDAAistM5V2qe44pgJV//Sr52YHle/3K8pkpZydcOrOzrr8W1U6YmhBBCUoadMSGEEJIyaXTG16dwzkZiJV//Sr52YHle/3K8pkpZydcOrOzrr/q1133MmBBCCCE+lKkJIYSQlKlrZywibxKRJ0TkaRG5tp7nrjcisllE7haRx0TkURH5w3D9KhG5U0SeCv/vTbuttUJEsiLykIjcHi6fIiL3hZ//N8IyfssSEekRkZtE5HER2SUiFy2nz34l+TJAfwboz7X257p1xiKSBfCPAN4M4GwA7xaRs+t1/hQoAPhj59zZAC4E8KHweq8FsN05dxqA7eHycuUPAewyy38D4NPOua0AjgC4OpVW1YfPAviec+5MAC9F8D4si89+BfoyQH8G6M+19WfnXF3+AFwE4Ptm+c8A/Fm9zp/2H4BbAbwBwBMANoTrNgB4Iu221eh6N4U36KUAbkeQ6HYQQK7U/bCc/gB0A3gWYUyGWb8sPvuV7svhNdOf6c9V/ezrKVNvBLDPLO8P1y17RGQLgJcBuA/AOufcgfClfgDrUmpWrfkMgI8CKIbLfQCOOucK4fJy/vxPAXAIwJdDWe8LItKO5fPZr1hfBujP4TL9ucqfPQO4aoyIdAC4GcCHnXPH7Gsu+Em17MLZReRyAAPOuQfTbktK5AC8HMDnnHMvQ5AC1pOwlutnv9yhP69I6uLP9eyMnwew2SxvCtctW0SkCYHjftU5961w9UER2RC+vgHAQFrtqyEXA3ibiOwB8HUE0tZnAfSIyPGyncv5898PYL9z7r5w+SYEzrxcPvsV58sA/Zn+XFt/rmdn/ACA08IIvGYA7wJwWx3PX1dERAB8EcAu59ynzEu3AbgqtK9CMPa0rHDO/ZlzbpNzbguCz/ku59x7AdwN4J3hZsvy2gHAOdcPYJ+InBGuugzAY1g+n/2K8mWA/kx/rr0/17tq01sQjD1kAXzJOffXdTt5nRGRVwG4B8DPoeMsf45gnOmbAE5GUPXmSufcUCqNrAMicgmAP3HOXS4ipyL4Zb0KwEMAfsM5N5Vm+2qFiJwH4AsAmgHsBvBbCH78LovPfiX5MkB/Pg79uXb+zAxchBBCSMowgIsQQghJGXbGhBBCSMqwMyaEEEJShp0xIYQQkjLsjAkhhJCUYWdMCCGEpAw7Y0IIISRl2BkTQgghKfP/AyMsRgtU3zNCAAAAAElFTkSuQmCC\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": "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\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": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXuwXVWd5z/r3nMfyU1y87hJTAgkASKPAYWAiA0zTYu2tFomM2pa7KEYpM04gtLlA6Wn1XLsrkFLpdXSqc6ogDUoKN09UE4XKC8typEhyqPBEIyBkGDeL0Jyb3Ifa/5Ya+29zjn7nnvuvee5/X6q4Oyz9uu3T1ZWfvv3NNZahBBCtD8dzRZACCFEbdCCLoQQOUELuhBC5AQt6EIIkRO0oAshRE7Qgi6EEDlBC7oQQuSEaS3oxpgrjDGbjTFbjDGfrpVQQjQbzW3RjpipJhYZYzqB54G3AjuAx4ErrbW/qZ14QjQezW3RrkxHQ78I2GKt3WqtPQHcCaypjVhCNBXNbdGWFKZx7knA9uj7DuCNlU4wxqjOgKgr1lpTg8tMam4PDCywpyxfXoPbCpHNE79+Yp+1duFEx01nQa8KY8x6YH297yNEI4nn9cmnnMyjj/28yRKJPNPXNXtbNcdNx+TyMnBy9H2ZHyvCWrvBWnuhtfbCadxLiEYy4dyO5/XAwEBDhRNiPKazoD8OrDLGrDTGdAPvA+6tjVhCNBXNbdGWTNnkYq0dMcZcD9wPdALftdY+WzPJhGgSmtuiXZmWDd1a+y/Av9RIFiFaBs1t0Y4oU1QIIXKCFnQhhMgJWtCFECInaEEXQoicoAVdCCFyghZ0IYTICVrQhRAiJ2hBF0KInKAFXQghcoIWdCGEyAl1L58rhBCtiMW3Z4i6toWxUTuajI3ZMf85WnxeRIfpBKBgCmVjxpSX6DfUomx/OdLQhRAiJ0hDF0LkliwtfAyncY+OjQAwbIeTfcNjJwA4NnI0GTs6/CoAx8eOl12/y3QBMKtrdtEnQE9nLwCFju5krNPr0KGvVq01dWnoQgiRE7SgCyFETpjQ5GKM+S7wTmCPtfYcPzYfuAtYAbwIrLPWHqyfmELUHs3t9iV2TFpvTgmmlLEMh6b1n/G5yWdkjunwOm53ZCYZ7uwBoNDhzCud3tkJ0OXHgnmlI9oXrlt0b+OuXx+XaHUa+m3AFSVjnwYetNauAh7034VoN25Dc1vkiAk1dGvtz40xK0qG1wCX+e3bgUeAT9VQLiHqjuZ2axM02+CoBPj9sR0A7B7clYwt7F0IwKIZSwDoMOV6ahyGSEnYYaxVF7yTM34DGB5zL2jHRo6VXTdo8nO757nzvcYeX6NYQ3fbxhY7R6E2DtKp2tAXW2t3+u1dwOJpSyJEa6C5LdqWaYctWmutMaY80t5jjFkPrJ/ufYRoNJXmdjyvTz7l5IbKlXeCDfz3x7YD8Od3/U2y78mntgBw/nmrkrH/9Z7PAdDlteU4kSfYsU2ktdskUch9joylYYtDo4MAHD5xKBnbdmQbAMdG3L5Yk+7x9vXjM11I49KOk5J9HZ197n6R4p3Y1ZOwxdoyVQ19tzFmCYD/3DPegdbaDdbaC621F07xXkI0kqrmdjyvBwYGGiqgEOMx1QX9XuBqv301cE9txBGi6Whui7almrDFH+CcRAPGmB3A54CbgR8aY64FtgHr6imkEPVAc7t1iM0eT+x/HIDL/u5jbmDrK2XHd78xdT7O71kAZDtDT/jszlE7kowFJ2hp+CLEoYbpWKevzxJMNEMjacZocLYOjQ7550jvYztTZ2g54fq1NbpUE+Vy5Ti7Lq+pJEI0GM1tkTdUy0UI0TRCSOIvdz+ajF3x33yU6LYj7jN2S3c5Lfwjb/qzZCgOFYRUk3anuu04NLHDa8Wj/sJxIlKo6xJr7TMLMwA4mtR3STX0QodbQnuTui3pkho0+/jNIXXYqtqiEEKICkhDF0I0lNie/cKR3wJwzW1fSQ94yVU3zDQznzoHgMuW/kkyFGqQxyn5gZ4OpzmPRPcMGvyg17gPHU8rO+w/fsDJGNnCO73WHTT1+A0gJBYFDb0rKhkQtjujGun1SvkPSEMXQoicoAVdCCFygkwuQoiGkFXdMIT57d4fFbS0Jcm5Hamh4po1ztQSqhu63eWmlkDIEO2MlrpR65ya+4b2AvDbQ1uSfQeGDgMwp6cvGZvfM7/omoW4omJJy7r42UJGaVYLutJjaoU0dCGEyAnS0IUQjcFrr3EY37K+UwA458yVydjTm4K27rXd3lQj/sC5awHo7uhJxlIN3ddtydB6R6KKjXuHdgPw+O5fA7D10I5kX9CmX9OXlnMITtdQt6W7M3V8BmdocMgWJTdV0MzrhTR0IYTICVrQhRAiJ8jkIkQbEkrAjlu3uoTk5T/DDFBrx9zEsqT3C1me3d0VlqJCqnfO6poFFDtCw9Vs2DJF9WoBODZ6NBkK5XCf2fsCAHuPpY0rZnc7c8qMwpFkrLvTyTan2927ryt1mAZrUKbjMzhIG/jzSkMXQoicIA1diBYiblc2Gpoe+9C+ONuxkoaepY0HrTirvkjY7mB8h169tPiQNfqb57alg0GzDQ/XHTdldhp0VmXFcEIn5WGFcRZpyO5cONNlnfYU0mWwpzM4QFPHZ6jPMqfbHT+jkIZM9vrttEl0hlylYZgxNXacSkMXQoicUE099JOB7+F6K1pgg7X2a8aY+cBdwArgRWCdtfbgeNcRotVo9tzO0sbjuuCh1sjOYy8D8Ks9TyT7ntrzOwD2D7q2aH1dacXBJbP6AVg4c14ytmimqxm+tG+J/0xbpc3vcSF6RaGAJbperGOaDFt1JQ0+qVzoj4+fe9ex3wNwbOuB7JsBZmGqEfd39497n2wZQihj+jwDve63OGfAtbHbO5jeOyQI9ffMTsYWz1gEwCL/GWvhQTMPTaK7ot+wUkJRvahGQx8BPm6tPRu4GLjOGHM28GngQWvtKuBB/12IdkJzW+SKCRd0a+1Oa+2v/fYRYBNwErAGuN0fdjuwtl5CClEPNLdF3piUU9QYswI4H3gMWGyt3el37cK9tgrRljRybqetz6Ixb4aIS8seOuGsPM8fciVmf707rTny+yMurK6rM7RTSzkw5Ew1u4/Grduc03Fgpgu5O3vgtGTP6oWrAVjU+5pkLDgOg5kkDhPsnKaDdDRqKPHkvqfcxrGRcY6Gmb2pGSOUw61EUUs5v31kOP0turzDc4E3vQyPxe3pnI47r2duMrZwxkIAZnunaGzamVGY6a/pZOwsCqf0JqYMGetljKnaKWqMmQX8I/BX1tqiJn/WVaTJdOUaY9YbYzYaYzZOS1Ih6sRU5nY8r/ft29cgSYWoTFUaujGmCzfh77DW/pMf3m2MWWKt3WmMWQLsyTrXWrsB2OCvU20ehBANYapzO57Xqy9YPcV5HTcnHgsbyVjQkoO2uLx/YbKv14faDY2MFH0HmN/rEmBmdKXabGjOEJJkuqNGDDuP7vTXGkzGlvYtc9ftdOcV4iYNmSGD1RMaNwP861739sHY+D/h0e2Hk+2xjMbOpWGBY0TOZv82EDel6Cu4t5QQhnj4xCtlx5+Iar+E7VAZsitqeVeVMziSNdXafSXGcc+eGhP+yRjnqv0OsMla+9Vo173A1X77auCeGssmRF3R3BZ5oxoN/RLgKuBfjTFP+rG/Bm4GfmiMuRZnoFtXHxGFqBua2yJXTLigW2sfZfw3g8trK44QjaPRczt5Ba+QORjvGUs61rsX6ZX9y5J9q+YuB2Bo1JkvXh1O65GELMfZUc2Reb2uScMC36xhQW9aHrav4GKuC5EpIWSUhljqaWWK2mIncNyv86TZLrY7bmLBaMnvczg10Qx780csz1iJaSN2ugZTS2/UECPEjs/0ppd+b3oBOHj8EACvDqe1X4JDuMfHmFtvvgLoGnO/WZKB25EaPbJ+M+uHwlE2wxwzHZQpKoQQOUG1XIRoMKk+mWpnQRuPwxaDEy40Vjit/9RkX3+3c5QGre7o8KvJvsFR59wMNUgg1Ubn+vPi8L/Q1b4o5K6CZp6peVZV99FnbUZO1fMXnus2CtE1hylmJG5ZNzzu/RKHqS13Nse/xZjX4BNtP8roHBodAmDnq3uTsf0Fp7V3+OdePDONYg1vT0Ge2CHbZbr89dPnDXVmxpLWeLVFGroQQuQEaehCNBgbqijGtVy8Nj40moYODo44u/hR/xkn9xSM08hDBcY9x1KNcs+g2z5yIrUDz+pyCTBL+1zyUJ+vKw6wZKar77Kgd1EyFkLzwj1jrTxoo5O3+ZqiawOcOscnOM2IlqLBUcYjto8XXzWbxP4d2dCHvZZ/zP+ux0ePl+2L75OEPvrnjuUPNW9Gx9wxx0n//MY63FhnFPKJP7dA18TCTwFp6EIIkRO0oAshRE6QyUWIRmGLnXaxySWYTuIMxbGSkrp7BtOE1af3ObPKQ9ueBWDH3rQEbN8sF1Y3b0YaXrfvVWd+GR529zlv2dJk31+e+16g2OQSZEvNKpFtIJTBzXBMZpphTHFWZGyCSEwhc9N6LRxITSClZJlcAsFpOZZR1jc2V43ZIX8bVysnLlkcHMOzu9OQzy6fXRtMM8PR8aHhRjgvy4wWhzLaOrelk4YuhBA5QRq6EA1mLHGKljveikPugibvPl+NQhMffPEZAO554Jfu2Fir7fZ6Wk8UFDfk79Xl9r2w9PfJrjcuPQuA5bPSsMhE4/RaeJHml8gYa8J+V+h9MUkVtKsv1dCH067PpbcpCq1Mb26K5YoTt0r3kb4FHfPJQ91Ru7mZoXpiXK/FX2NoxGn2h0+ktWXCcxZ8k+tuE7euC0lHcThox7hy1aIdnTR0IYTICVrQhRAiJ8jkIkSDCE7E4CwbtqlzLcSfH/eZivHxs3zMeNxtvjM4Jvf4uOdXUmdqWS0UdzGHf6vf/XIao/5fXv0HAM74xGuTsZVzTvf3ceaCoZG0VszBE1H/T8+Ad6jOKswpOs/dc3xTQqaTs9QcUSjv4ZmdreqvGWVr4p2UsbP5FW8yOeTL5s6Kat6MjJU32gh/DgcGD3vx0nsHB29odBHXjAn7OqMs1ZBZ2vQGF0IIIVobaehCNIikKmAI47OpnhYyDgejTNE9x1yYYqj8F4cJvm6xq7z40p+eB8DBA2mThuMnfPbo/kPp2O9ciF7S6u1EqhkPPe3u80c3/GUy1rfc1XxZtsQ11Rg6nmq427btKnoOgEUL3fEffecVAKz/Nx9I9s0ouDeMxNcZhfaFphrDQ9EbRiknpxp0qHiYlbmafI+un7b7i+rB+BDRoyfcvQ8Ppc7mY97xOTN6G+otuHu+4jNvZxRSB+7iGe4tK2jtBZM6Uys5RWtRWTELaehCCJETJtTQjTG9wM+BHn/83dbazxljVgJ3AguAXwFXWWsr/DMrRGvR6LmdJtb4+iiROhWqIQ70pm3m5nT1A9lhjq+duwqANac6jTi20w6POlG7onC8UI3xR8//GIAN/+eRZN+R53wdmGOpTf/oc65P6uZNaY2YMgbSxKV581xN9XMGXuvl6So7PGjJI1FFycQe/2ppiUWSH+w//Ye0NH3WdctOiO/p7fBxrfdg5+70CT+7jqY9YV894cI/F/fNS4+PNPJSgk08tOgrrinfWfQJ8ZtC8zT048CbrbWvB84DrjDGXAx8EbjFWns6cBC4ti4SClE/NLdFrphwQbeOYGTq8v9Z4M3A3X78dmBtXSQUok5obou8UZVT1BjTiXv1PB34JvA74JC1ybvTDuCkukgoRB1p5NwOjrCs+iLhtXxG58xkLJgGQmhfHFIXzDF93uHYWVTS1d/HlOtrf/OGswH46zd8IhkLoZIP7PhpMvbR7/1PAA5tcyaRRaeldV4+/Pa3APCWU/5dMja725lcFva65g+FqF5LaeJn7LQ8GlrnzYpMKYPuOZdfuBKAz7zxumRXyOCMQwcr9dYIZqrY7BF+s2WzXD2b4BwF6O5013/NrAXJ2Fzfoi5pOFJITVnhzzA00OiIfvN0uzyjNh2oremlKqeotXbUWnsesAy4CDiz2hsYY9YbYzYaYzZOUUYh6sZU53Y8r/ft2zfxCUI0gEmFLVprDxljHgbeBMw1xhS8JrMMeHmcczYAGwCMMdX0qRKi4Ux2bsfzevUFq6c2r6M6HqMZLeiStmYZbdRCC7mOrPZxQQ8s0mJDyGRofZbqcqFJ9L9f+Z5kbO3n3u1PKw61hOgNoIJjL347KG2OHTtwF81wmv+n/uO7krGLlrwegHPmnwNAf3fqoCxqFlF6/SBf/Gbi5e7IaMe3cs4KIG10AbD3mHsjiZONen0IY/j94zovhY5ix6eJfldT9m5SfybU0I0xC40xc/32DOCtwCbgYSDMgKuBe+olpBD1QHNb5I1qNPQlwO3e1tgB/NBa+2NjzG+AO40xfws8AXynjnIKUQ8aPLeLNdsoQT2xK8f1tMN20EDjNmqFkvC9+LyOrOSVkqbPsW6dpMxHYZHhGonmX6Wtt9RPEF9rNGjokZY9t2c+AOtem2rooT1eEl6YVWGxSP7QEi+VopI8wb4/u8vZxsNbQkxozO3ODY2gy9+UupLkoULJnZvDhAu6tfZp4PyM8a04m6MQbYnmtsgbyhQVQoicoFou06S724Uwve1tbwPgPe9JHUuXXHIJAKeddloydv311wPwzW9+s1EiihYheR1Pqgmm+0IbtKGo2uLwWHFyamw2MIXil/s4TDCEMMaGirSBhjMbxGaMEHoXOxPDvZK8Rpvh2Msww2S1pUsvEswfUWif347NGIPeSRnMSLO75la8fiqrLfo+EcGsMtCbhigGJ6fNaIgR5J5ZSDNkkzDKzOqPE8tT65ou0tCFECInSEOfBEuWLAHghhtuSMbWrFkDwBlnnAHA3r1p7Ytdu1xVus9+9rPJ2Le+9a26yylanNAsOnKLBs08rocekmeCpnpkOK2oeOD4fiDVvBf0DiT75nbPL7vlcV/Fcc+gm5Nx6ODiGW5eh4bHkGrtJqlWGIsfwhDTMWNKnY9RNcSS+ubFDln3bEWhg4Pu79DSPpf4M1bkPnZkOY9JZE0FqxQ6GByZs33iUPwccf30QV8Rcl6vO66/O31j6A7VH03xG02zkIYuhBA5QQu6EELkBJlcxmHGDOf4+MxnPpOM3XjjjUCxw+TZZ58F4IMf/CAA3//+95N9g4NpjQghEkL2oo2yNX3sdXH8szsuNL0IJXAhNQnM9VmU83vSsrshRj2umRIyN4Np474XH072Dcx0JoQ/PunSZGzJTNdAI42vjhtKuOt2FDk3vTMxJKnGZg9b3HYtdooGc8nmg88nY5v2bwXgihWzy54j/bsXm1XCiP9dM2Lgi0xGyXnuuN7O1MkZTFgdo+UO4uA8ne3/rKA4a9RdO0PWDL+nGlwIIYSoiDT0cbj11lsBWLduXTL26KOPArB+/fpk7LnnnmusYKJ9Cc7BMV+jJdLmQuPo2DkYGkHsH3LFv0JLOkgbHK/qdyGxC3vTbMdQYfDYSKrRbz60GYD7X/wZAD99ZnOyb06/q1vSHWmba091DslOU+4UDVpsLH9XyE4N/tIopDF1rIYqkOVNlncc2Z2MbTt8yD//aNH93DXG/DXL67WE0Mq4jkxHBZ01HNcVtY0L26MmvafpdNdf4DX0mVGdl+6oiQgUO2utSd8FKNuqD9LQhRAiJ0hDL2HZMmc7vOKKK8r2rV3r+hwcOHCgoTKJfBE06Dhx6PAJp5XuHUrDXvcPuXn2+M6nAXj+wP5k386DhwE4a8kmAD5yfhp6F6oJbjm8JRn7u5/fBcAv/+8zbmBP5N+Z47TMI68cTYbetdLVVunA2/QjrdoGm3hGvfUkmSZS6ccSI3dIakqXnW7vM4jbvC3w/qu+Qlobvoys2jLBNxHpqZbyRKGODLlL5YmPCW9KiaxRTZ3wLKllP71P+lsUxXe6j3ElmB7S0IUQIidoQRdCiJwgk0sJAwMu427OHPcK+8ADDyT7Dh482BSZRM7IyCoMDsbYNNDjHW6h5dms7tQB1z/LmSMGZs7010rP6/YZn69f8Ppk7L9f7sww/3nfLQA8vycNEyz0OxPCu1dfGN3bmT3ixhCB4OzLardWWvLXP5T/8CYXm9aRCU7If3vSxcnYBYucY3j57JX+eVJzTDCnVK6PEsvlRYgcuGMV9NhQE8d0RKGPtvjZspqJ2OS5o2uHP8sOU3Z8vZCGLoQQOaFqDd03AdgIvGytfacxZiVwJ7AA12T3KmvtiUrXaAeC4zPwi1/8Itm2WRXnRFvTjHmd3XTBaar9Pf3JWNg+f5Fzop4+70iyL2jhoY3a4hmvifb1Fh0DsHrAlXd/9EPfBeCZP3862beq39UhmuVb0QEU/LmZlVCS6ozljSfSyMwo7M9fJbTZ6yo63umUr51zVjIWwhQLSUPo8hDFSsRhkYl2HT1BquVTti/cqyMaG7OhqXd50+dKlActRt9q3Bw6MBkN/QZce67AF4FbrLWnAweBa2spmBANQvNa5IaqFnRjzDLgHcC3/XcDvBm42x9yO7A2+2whWhPNa5E3qjW5/D1wIxDeyRYAh3xXdIAdwEk1lq0prFixouj7yy+XNXzPpLPTvX4GZyrAyIj7eY4cOZJ5TrMIz/izn/0sGTvllFMA+NjHPpaM3XLLLQ2Vqwk0ZV4nGYpRZuZ8X/42NLoAGPVi9HinYNxHdIZvsjCjs69sX9qBPq5p4sZmFlwdkjcs/KNUngoyJs5NG5slMmKpk/o0weGbcVVbnnUajipE5qHOJBu0vBTvZClrKkKWYzXqx0q5/Cbp0VruDE7MZ8FUE+8rKyncApmixph3Anustb+ayg2MMeuNMRuNMRuncr4Q9aCW83rfvn01lk6IqVGNhn4J8C5jzNuBXmAO8DVgrjGm4LWZZUCmKmut3QBsADDGtLxXcfXq1UXf582bl2xffLELrQqt5QDe8Y53ADDTh49ddFHaWziEOd53333JWGiO0cxFYNWqVUCaFQswNua0lPjZcq6h12xer75g9aTmddDSijImfWhbXFdkxDptvdDT5Y+JGlD4cMJOgmYYt5QrD+0rz+rMagKRJWtSPjE6dfxMUUo01qI9FTI0Y0dmqM6Y5TicathfXIExOHXTTM4sbTzW2ovDFovffMLxGRp61htGnZyhiTwTHWCtvclau8xauwJ4H/CQtfYvgIeB0EDzauCeukkpRI3RvBZ5ZDqJRZ8C7jTG/C3wBPCd2ojUWtx8880V94e6Lrt3u2pxmzalARN9fc6+eeWVVyZjoZn05z//eQC+8Y1v1E7YKvnkJz/Z8Hu2EXWf16V2V4gaOsdJK15TDSGN2bVTwufkXn6nk+CShjJmJA/5r0Uasd9ObfsTyDNNLbaodnt4wcjqcZ3x9pFV/z1o32NmrPTwtMG2PyZ+60q096LKk/XV0Ce1oFtrHwEe8dtbgYsqHS9EO6B5LfKCMkWFECInqJZLCd/73vcA+MIXvgDA0FDahf3hh13brh/96EfJ2EMPPQSkJpeYYHL50Ic+lIx96UtfAuCrX/0qAEuXLk323XTTTdN/ANEGhDKv8VCxo65oO8vJWZJxGJs4Kjkfy649roQlpoFJZ0lnODTN+M7OelH6O0F5KGZc+yUxCxVlm5b+2WRknZqOovOL7t1ApKELIUROkIZewpe//GUA7rjjDgCGh9NEj8mGGh496hoGfOUrX0nGtm/fDsCdd94JwMc//vFk3/333w/AI488MkmpRXtSFAsY/T8MlbdUS48O2uX4yTdVhSNOgaRGibVlY5WY7B2z3iJqofUmFRITh2nc/KLYyelPGFeuUnkywzUbqKlLQxdCiJygBV0IIXKCTC7jsHPnzrpcNzhUQ0bqjTfemOy77LLLAJlc8k7WC3jyEp9hxgg1XbLqqXSECPY4lprysrbTJnZkVqjJkkVaRra8tkn28Y1JKC81vbixrK1ieSvJ1wxHaIw0dCGEyAnS0BtMaJKxdevWJksimk2RAy2jvVnINAwNH0ZJm0ZQEnoXt1hL9LQKGYrVOhzLna/RvbMI98wIc6xWe0005wZr6vE9m61pTxVp6EIIkROkoTeJ7qjhb6MIiU6zZ8+e4EjRCIqTiBxZ7cqCthhX8kubMZeflz1WQ203SwsvTRbKsLk3MqFoMkynDk6rafTS0IUQIidoQRdCiJwgk0sJPT2u3dcPfvADAK655ppk3+HDh6d9/dCi7sMf/nDZvsHBwWlfvxLnnnsuUNyEQzQPG5ksxigvzVpaGtcWORqzjTRujzfHFMUVVhcyWA1Z9VHSe2c4Q6d471rIWskkUsnUUikbNKZVTC0BaehCCJETqtLQjTEvAkeAUWDEWnuhMWY+cBewAngRWGetPVgfMRvHWWedBcData7Ze9zg+dprrwXS5s9TIdRuOfPMMwF46aWXkn2h0qNoHM2Y21kVUGyJkzMeG0s07nKNsiOrF3PyGWmZIcox6ekwOY211WgnWRvJZDT0P7HWnmetvdB//zTwoLV2FfCg/y5EO6K5LXLBdEwua4Db/fbtwNrpiyNES6C5LdqSap2iFviJMcYC/+A7ni+21oaCJ7uAxfUQsNGEnqDBKXrVVVcl+5YvXw6kzSkA7r333nGv1d/fD8AnPvGJZOyGG24A0rK88b561Y8JrFy5sq7Xb1MaPrfTnpxZwpTHdneGv6YZ5pXscq1Z1x1/Xy1plJOw1ZyRrUK1C/ql1tqXjTGLgJ8aY56Ld1prrf8LUYYxZj2wfppyClEvpjS343l98iknN0ZSISagqgXdWvuy/9xjjPlnXBPd3caYJdbancaYJcCecc7dAGwAGG/RbyWOHz8OpOGKvb29yb41a9YAcOmllyZje/ZkPjaQZoPOnz8/Gdu1axcA119/PQB33313LcSuive///0THrNly5YGSNI6THVux/N69QWrq5rXZdX9bMY+G9VkKQn3y+4eb6L/Z58n/nCY0IZujOkzxswO28CfAs8A9wJX+8OuBu6pl5BC1APNbZE3qtHQFwP/7LWDAvB9a+19xpjHgR8aY64FtgHr6idm4zlx4gQA7373u5OxM844A4CPfvSjydgll1wCwOte97qyazz11FNAao+HtP5D76gIAAAF6UlEQVR5vZOIpsofWJ2XpsztTI072MttVMu8gqZdGrY3WW180k2ic0i9E5eawYQLurV2K/D6jPH9wOX1EEqIRqC5LfKGMkWFECInqJbLJNi8eTMA1113XZMlqR+LF+ci+rR9qdCUouiwBr/it5qJptoGHX9oSEMXQoicIA1diBag3tplecXG8hbPmQ0xMioqtoIm3AoytCLS0IUQIidIQxdFhFBLkS+yQiVF/pCGLoQQOUELuhBC5ASZXAQA27ZtA+C2225rriBiUky10UO7OxWrfe5Kz1mLa7Qa0tCFECInSEPPOYsWLUq2V6xYMe5xt956KwDbt2+vt0iiDcljIk9NG2a3CNLQhRAiJ2hBF0KInCCTS875+te/nmyfffbZ4x73k5/8pBHiiBrTaq/8jeIP9bknQhq6EELkhKo0dGPMXODbwDm4IhAfADYDdwErgBeBddbag3WRUkyZxx57LNl+73vfC8BLL70EwFve8pZk3wsvvNBYwVoEze3qkEbcHlSroX8NuM9aeyauIcAm4NPAg9baVcCD/rsQ7YbmtsgNJq2+Ns4BxvQDTwKn2uhgY8xm4LKoke4j1tozJrhWyzeJFu2NtbZqVbJWc3v1Bavto4/9fDpiC1GRvq7Zv7LWXjjRcdVo6CuBvcCtxpgnjDHf9g11F1trd/pjduH6M5ZhjFlvjNlojNlYrfBCNIgpz+14Xu/bt6+BIgsxPtUs6AVgNfA/rLXnA0cpeQX12k2m9m2t3WCtvbCaf12EaDBTntvxvB4YGGiIsEJMRDUL+g5gh7U2eNfuxv0l2O1fR/Gfe+ojohB1Q3Nb5IoJF3Rr7S5guzEm2BAvB34D3Atc7ceuBu6pi4RC1AnNbZE3qk0s+ghwhzGmG9gKXIP7x+CHxphrgW3AuvqIKERd0dwWuaGqBd1a+ySQZQO/vLbiCNFYNLdFnlCmqBBC5ATVchFCtB3TKedbem6esmCloQshRE6YMFO0pjczZi8u1redMzEGaF/521l2mFj+5dbahY0SJuDn9Tba+/dtZ9mhveWvRvaq5nZDF3QAY8zGdk4yamf521l2aH35W12+SrSz7NDe8tdSdplchBAiJ2hBF0KInNCMBX1DE+5ZS9pZ/naWHVpf/laXrxLtLDu0t/w1k73hNnQhhBD1QSYXIYTICQ1d0I0xVxhjNhtjthhjWroLjDHmZGPMw8aY3xhjnjXG3ODH5xtjfmqM+a3/nNdsWcfDGNPp63z/2H9faYx5zP/+d/n6JS2JMWauMeZuY8xzxphNxpg3tepv307zGjS3m00953bDFnRjTCfwTeDPgLOBK40x47ehbz4jwMettWcDFwPXeXnbqT3ZDbiWaoEvArdYa08HDgLXNkWq6miL1nBtOK9Bc7vZ1G9uW2sb8h/wJuD+6PtNwE2Nun8N5L8HeCuugfASP7YE2Nxs2caRd5mfGG8GfgwYXPJCIevPo5X+A/qBF/A+nmi85X77dp/XXmbN7cbJXte53UiTy0nA9uj7Dj/W8hhjVgDnA49RZeu9FuDvgRuBMf99AXDIWjviv7fy7z+ttocNpm3nNWhuN4G6zm05RSfAGDML+Efgr6y1r8T7rPvntOXChIwx7wT2WGt/1WxZpsi02h6K6tDcbgp1nduNXNBfBk6Ovi/zYy2LMaYLN+HvsNb+kx9uh/ZklwDvMsa8CNyJezX9GjDXGBMqbLby799OreHabl6D5nYTqevcbuSC/jiwynuju4H34Vp9tSTGGAN8B9hkrf1qtKvl25NZa2+y1i6z1q7A/c4PWWv/AngYeI8/rCVlh7ZrDddW8xo0t5tJ3ed2gx0CbweeB34H/NdmOygmkPVS3GvP08CT/r+34+x1DwK/BR4A5jdb1gme4zLgx377VOD/AVuAHwE9zZavgtznARv97/+/gXmt+tu307z28mpuN1fuus1tZYoKIUROkFNUCCFyghZ0IYTICVrQhRAiJ2hBF0KInKAFXQghcoIWdCGEyAla0IUQIidoQRdCiJzw/wH5YRY3DPOj7AAAAABJRU5ErkJggg==\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/UCwAAIABJREFUeJztnXuQXFd54H+nu+c90kia0WOk0Qtb2JYNtmyvMWsIxiTYC2zsLcDBZL0uyhUVC96Q4uHgTZEUlfwB1BYEUrC1qhAwtYAxDom9hCWAH6S8gIMMfsSWbWTZsvV+SyNpNM+zf5zz3XO6+05Pz0w/pi/fr0o1Pefcvve7V0dX3/mexlqLoiiK0vrkmi2AoiiKUhv0ha4oipIR9IWuKIqSEfSFriiKkhH0ha4oipIR9IWuKIqSEfSFriiKkhHm9UI3xtxgjHneGLPTGPPJWgmlKM1G17bSipi5JhYZY/LAC8DvAXuAXwK3WGufrZ14itJ4dG0rrcp8NPSrgJ3W2l3W2jHgHuDG2oilKE1F17bSkhTm8d01wKvR73uAN1T6gjFG6wwodcVaa2pwmlmt7f6Bfrtu/boaXFZR0nniV08csdYun+m4+bzQq8IYsxXYWu/rKEojidf12nVD/PQXDzdZIiXL9LUv3V3NcfMxuewF1ka/D/mxIqy126y1V1prr5zHtRSlkcy4tuN13T8w0FDhFGU65vNC/yWwyRiz0RjTDrwPeKA2YilKU9G1rbQkcza5WGsnjDF3AP8M5IG/s9Y+UzPJFKVJ6NpWWpV52dCttT8AflAjWRRlwaBrW2lF6u4UVRQlA6TlqxhTNm8pP85gyo9X6oKm/iuKomQEfaEriqJkBDW5KIoCQGwQSQwn3pQyaSejOTeWJx/G7BQA43YcgNHJc8lcR64DgPZ8p7uOaaAeWaG0SZp5KA1DBVPRAjMjqYauKIqSEVRDV5QFiuh+pdoywBROI56cmgCCZgwwMTXmDw/Ht+WdltyWawcgb4J2nfN6nU3RNkWLlesB5CvogeP+2gfO7kvG+jtd4tWS5Nqz0yNTdw4VkN2CO356J63M2ZTnGp+j7PuR/DnrPuf8WEVt3n258vw8UQ1dURQlI6iGrigLFFsSCjhpJ5I50czHvEZ8duJMMnducsQfH+ze7d6Ovbh9MQCd+e5krmDca8BE+p0p0ThzKXOx9iua7fD4KQB2HH8umZPdwFtWXwtAT9uicK4UjbbUxj7bEt9FcnlNO75OopnLLid6ThNTbqczMnE2GYvnATr8bsd9dn4B2fnkop1P6r2JaF5Tn+3uYyZUQ1cURckI+kJXFEXJCGpyUZSFRGReCKaBZJ+ezIlZQswZhVz4p2wm3XFTkWNvPDHNnPXfi47P+3NFe/5Ss0exacCWnX9schSAZ465kjdfejRUTTh+bBiAr7yvH4ArBq5K5vJe7iKTTnKdRJjo4tNnpJYe4z56J2eFc4iZBeDY6FEADo8cSsZGJpwJq5BrA2BZ59JkbkXnSiCYXGIzy4wOUmpjZolRDV1RFCUjqIauKAuBFM2zNKxuKnbeeQfp6JRL4Dk9PpzMnRw76cdOJ2OdSVKP0xq78l3JXKKtx1q+aLbikI3CFkVECY8EOD52DICf7/s1ANt/9Xw4/qyTdc9pF8p4aX9w7hrfYMpEGrTcb3DMRpcWZ2Kk2pbuGOIQS3FoxrsJcShL8pM4cgGOnnMa+vHRE5TS25Yrki8+f9WatoYtKoqiKNWgL3RFUZSMMKPJxRjzd8C7gEPW2kv82DLgO8AG4GXgZmvt8fqJqSi1Z6Gv7VJTS2oc+uSYn5uklFyc0eidp+KoKzZLuHOZuL+2N8OIDOOReWXUx7mf8qYdgOd83Pk3fvz/3MDBEMe98pI1APy7FVcAIe7d3ZuYdsK95RNZ8XMppDg5w68pmaJxNmhiJnFj4uwEWNKxBIDOQmeZjBJ/3tPWm8zF3y29NtVmj9aQajT0rwM3lIx9EnjQWrsJeND/riitxtfRta1kiBk1dGvtvxhjNpQM3whc6z/fDTwC/GkN5VKUurOQ1nZ5iGL02Ui2ZshCLHhVTLTG+HuiNUpWKIRM0Z5Cj/s9ynaUkME0TVK09yMjB5OxXad2AXDWh/MB/NOLjwFw6AV/XFd4tXz6PX8AwGD3EBBCFSEKGYw06MRBaovv38laXIfFfZaf09dfiXck8t0kCzbayYg2LjsfCNm4sgsSB7Mbm/Cieods9AhzsjmI5E+cwHVq+jFXG/pKa+1+//kAsLJG8ihKs9G1rbQs8w5btNZaY8y0UTvGmK3A1vleR1EaTaW1Ha/rteuG5nqBimMhbLG8Holo1ZLQkqbZT04Ffa274Gq3lNp8IYRAxsk9BeteDYmGfu5IMnds1LkU9p0+nIz96OdPug+nnDabO78vmbu4/6Ii+eMQQrm3XIpcwkxJTaWhicVzxSGKsRxyrtg/cML7BQ6eDTuSU2Mu/HNxu7Odx5Uq5Xl25JzWHtdyEc0/fq7xfCxLrZirhn7QGDMI4H8emu5Aa+02a+2V1tor53gtRWkkVa3teF33Dww0VEBFmY65vtAfAG7zn28D7q+NOIrSdHRtKy1LNWGL38Y5iQaMMXuAvwA+A9xrjLkd2A3cXE8hFaUeNHttx2YSMRtMRnVFzky4rf5p/zMukXv8nDN7vHzqFQAe2xcyM/9tj3MBnDoVju/q8uVz+5zZ4PWrgmtg88AGAC5a+tpk7KKlFxfJGpeMPX7OZVZ+8+c/T8YOPbHHfRh35o5VA6HeyfKuFUXniu9bTBC5FNNDWgMKITariGM1rTmFmFri48XMMeLDLw+NBNPR00eeBeCZw68kY2fG3fkHe92zi0NExazS7k1fMV3ezNUWzUmJYlOnjNFqolxumWbqbTWWRVEaiq5tJWtoLRdFaTS23LEnjrmxyHknNUZOJo66YM5/6rBL5Pnp7hcBeHHn3mRu70HnwLTDQdtPnK2T7ue/dATn3NJVLpnm2je8Lhn77Judo3dRu3Nu7juzP8z9o7NCHXw6XFPqtUgY3lWXBm2/2zfTSMIFU+qwxDq4La0jEyVUibYb17UZm3KVHuUZjke7HGn2ETsjJSlr/1l3T88d25nMPX1oNwAvnwxJU7JDKOScdn1yNNTNkfBGCW2MKze2eYdpW4r2Xi809V9RFCUjqIauKA0mhN6Vtz6LtUux1UrVxCcP70jm7v35LwF4/nmnUXIihN5xzp83VtdKk3Ui+pe4lnDdhfA6EHu9aOjnop3DwRd9SN+p6Jq2+MMbVm+MLl2iN8aVFad8Gn6ktpdq6KfGQuXDxe1uNyH11wH2nXX2+0NnD/vjQ/VECcmMQw1Fw47DLoW1i5cBsLI3JGWJPEs73djqnlWRPG6sLSXsMr0tXX1RDV1RFCUj6AtdURQlI6jJRVEajDhD4/A3Ca87GZkXXh525pT/s/NRAH74i6eSuf3Pu2YRiallKjKl5PzGvi3S13rdP/W25a6Wy2vWB7PBmy9xDszr1l+ejA10ulBDMRG8eOLVcK5j3tyRlkPrxzb0hexZyaaURhqxqUmeQc4Gs0SoLul+vnAihGRuGXAVG6WhBsD/felBAB599SUAJqaCs3lwkTMnxZrrpDc79bQ5uS5dGcxDGxevB4rDNEe9eSfvTUdLoxZ0vW3u/FLfpTNqHCIml3yRyUUbXCiKoihVoBq6ojSKkvrmY1PB0bjvrAsBfOLwvyVj/7TzCQAef+IFAA7vC1pp4vgseI2vENUIWe208Esvfk0y9IZNTgs9b6nTzLsLQZPs63AJMxctvTAZ6/JVGSXh542DV0T38beV7xP455d+mXy+euXVTsQ297o5NHIgmTs17sIDh3rWJWPyfA764776VGg4/T/eshmA3X73AvDjnU6D3/OqC+vs7g7VECXkMPYFd3o5VvS4e1zTO5jMrep2CVexVi0hieKklYqVEGq7y+4jrvUun9O08npp6qqhK4qiZAR9oSuKomQENbkoSoMZty7W/PBIlPl55BkAHj8QshbFubf5YmcuWX7VJcncJcudmWDT0g0ALGoPbdHWL3KOvWUdoQqkmBDE0VjcUs45/TqKml74RgzeEbipb1O4gfN8adwdKZ35ctLAISBmFbn2P7z4/WTu8QOuZsqZsSDP2sUutvtnO1wW7I7ng3ll62XOvLLj6G+SsRPHXVz5lHcMS90agIHu7jIRe9qds3JFt4tpj+9bZIybd0hMvtRrieu2JNmvUio3at4hY0Vx+ClNO2qJauiKoigZQTV0RWkQos1JvZajo8HJOTzmtMDVvaExxKUrNgCwsW8tAK9ZHJycElYooXGxFphLq+gnDlmkCURwivYUJIwy1Ewp1SDPRJUe4wbQZSx3Dsn/etkfJEP9HcuB0PbuP18Y5i5Y5pyn33vh0WTsx9vdbuWVF3ytmOMhK/TVYTd2ZCTsDjo63DPo63Myr+gPz3C5d3yOToR76+sMTlOAA2dCM4sToyf8WGjoIZmlq3rcjuf8JSHMUSoq9lhpazcDddLMBdXQFUVRMkI19dDXAt/A9Va0wDZr7ReNMcuA7wAbgJeBm621KUY1RVmYNGttS8haW2RvXd3rNO71i0NNkKHeNQAs6+gHYHF70DxDnRBp8Bx0M9HM49A435s4aTQdt0UTu7e1wTacK9H14hrm5KfXA9/53jcDQXONZZSaJr1t4T7eMngtAG9c+e+TsV+81tVZ/9/PPATAP97702RO2sGNTQaNu6fX7zbcFEdPhGqIr+x19VpORGMd7e4ZL1nqkoL6l4W6LUu89n78XAgpHRt313rtgNPeu9uChj/YHUIeoeTvoe6VW8qpRkOfAD5mrd0MXA182BizGfgk8KC1dhPwoP9dUVoJXdtKppjxhW6t3W+t/ZX/PAzsANYANwJ3+8PuBm6ql5CKUg90bStZY1ZOUWPMBmAL8Biw0lorVe8P4LatitKSNHJti7lkWceyZExCB8engilhZMJt+3eN7gJCowuAdl8fZXjcOSvPjAdHZUfenX/dolBP5eKlLuRRzB250pK2TNMWzY+t7Ay1X7a81Z3r1z94IhnrvcA5DP/s6v8CwBJf5ja+34QobVPC/Doiec7rc87f/i7f4q4Q5Do16uwqR0dCWOHQEndPL0+4kMPnojDH4ye9HeZMKEucW+TkEVNKd08woWxe7hy4W1aFzFVByucOdodn0VNw4aISFlr0DOvsAE2jaqeoMaYX+HvgT6y1p+I56/Jr00r1YIzZaozZbozZPi9JFaVOzGVtx+v66JEjpdOK0hSq0tCNMW24Bf9Na+33/PBBY8ygtXa/MWYQOJT2XWvtNmCbP0/qS19RmsVc13a8rrdcsWVW61qqD/ZFWqyEBe49vS8Z23XmZQBeOOYaODxzODRkOD3sNPJ9+9x/JieHQ1hhPu+0xY1RRcU7r/tPALx19XUAdEZOS3Hexc2VSZytxssctOw/ecs7Afh8VNXwtqudM3Rll7tmR1R10JScK81XGD/APaddaKIkFjERZsUZ2t0WnMcb+pxDeZl3aL64c084mVShHA+yTk24z90+AWndslA98YpVrp7N2t6wu5F6MPmce66LfIVFd5/umuLwbYYjNGZGDd24PcRXgR3W2s9HUw8At/nPtwH31148RakfuraVrFGNhn4NcCvwtDFGjGb/HfgMcK8x5nZgN3BzfURUlLqha1vJFDO+0K21jzJ9AtTbaiuOojSOZq1t2Z6354Mzri1xcoZ46d0nnV/2pRMuBP7smRAbPTnpzAY534l+YjKYFMTkksRnE+qVTPg6MnFzDTETTEb9TEMvzoKXOWzm3z50PQDX3HJNMiZx52Jqyceb/5J+pjaOj/fGlvj8r3qTy0lxaHaFUrarel1M/gX9G5Kx83wG7eSgewavngpukGd/42rF7N4bzFVLFjlZ13mT1OUrw7kuWXYxACu6gh9c/r6mYpOUp72kb+iCN7koiqIorYHWclGUBiNaXJo2NzoRqg625Z3WPtjrMxq7giOzs+D+6e5d7hyrew+GujAF3+ziiqE14Vw+PPB4VD9GEC38bFSv5djoUSBo8pNTQaMfmTxHKcs6nGNxdY+rO2MiJ2rOOr1R6sjEyPknot1BV8HtJlascOfcdyjIPOHliEM+e9uKQwdf29+fzL3wsnMyxxGE0gBDqjouag/PVXYa7bmwe4qbXUBx1qxo5skOowmhijGqoSuKomQE1dAVpcGk6XCircd1zS9ctgGA9uVO2xU7OwSN8Pg5V19k14oQqjcy4ZKULli2PhmThKWnjj4NFNuDl3S4xJy4wXFvW4+fc1ryy6deSub2nz3ojw91xM/5JKiBTpeYE7disyU3HIdHTnq5Yg1942J3379z4fkA7Ny1N5nbd9rZwi9cen4yJs9CwkE3LQ1JQX1LnNydB8KOod23oBufdNr+VKRxS7PnfFRnJ/EHlPgC4rFm284F1dAVRVEygr7QFUVRMoKaXBSlwciGPTY9nJ1wmZ9SvwWgt92ZPfraF/vjw1b/9LgL6RNHY2chmD/COcO5XjnlzBYvnnBOwlOjoWnEqh5n5rlkeWgzd9nApQAsbXfOx/YlwWSxvMuZVU5EtWVGvPwTYkKJmmWYxObi5E8LmYwbdKzpcVmaN2x4EwDf738ymds/POyPLw99LHgzydre4Ax+3RpX3vbYkSCr1G45Mz5eJDMEs1ZsQjGldW+a7PishGroiqIoGUE1dEVpMNZr1ZLkA0HjjrVFcSxKWOHpidPJ3OERF8q3d9iVmTl0Nmrg4BOLOgpBq5YWdy8cdeGII2Ph2lNe8794edgBJBUSvTbaXeiJjnfyFyLH4cSUc6xK2F/sFBUNd8rf23h03xISGB+/yFeEvGjpZgBe85rVydykFW08dhD7+825XcpAV2iOffGAc5C+uC70Jxn3VRbHfQjk8XPh2UnVy658uF9KkoZseh3CcurcEDoN1dAVRVEygr7QFUVRMoKaXBSlwciGPY4FF7PK4o64NGuHn3N6V+xMFBOKmGiGFoUSsMu7nSOzLzpX3AAD4ETUM3Nlj3O6Ssalu6YzM9iU+iVifumNysgK7TmROWRXSpy3mF7SzDGxGUO+2+Wv89YNr03mDp894a/TXna8xI7H5iF5FpevCqWE93rH6oQv/yvPEuCUd/TG95a3/l5SmoKUETmuk3uKxkIJ4fqYYVRDVxRFyQiqoSvzYsOGDcnnn/7UdWdft845oj760Y8mc1/4whcaKteCxpY71boKLpRuSXtfMiYNFcZ9FmWsLUvYnnSgX71oRTI30OlqmeQjjVIcmMu7nSbf2xY0dNFil3aEhhtdhS5/He/QjHYHiQwVsiPT3IZpIYq5xNFYHiZY8GNbll+czO086TI/23Llry6RMc1pObQoVE+UGjnDo66NXfycJHx0fCqqqeN3A/kK+m/aNWVHVVoLpp6ohq4oipIRZtTQjTGdwL8AHf74+6y1f2GM2QjcA/QDjwO3WmvHpj+TkkU2bQrJKENDLiFkytsmr7km1MteiBp6s9d2LkWDjsdKG0fHoXqrelxo3si407R7opZy7b5JdC7Seie9dj/Ys7xMDrGddxe1pSvW9YoTbYyXNWieoqHKz6LKiiU7kvgew3lTdHp/ncGewWRI7PGd+fJqiJJ4Fe9kpJn2YG/YwciO5OSos6XHvgn5e4j9G/I5l9JBs3SXEl+76vDGGlKNhj4KXGetvRS4DLjBGHM18FngC9ba84HjwO31E1NR6oKubSVTzPhCtw7JaGjzfyxwHXCfH78buKkuEipKndC1rWSNqpyixpg8but5PvBl4EXghLVJwYY9wJppvq5kmE984hPNFmFeNGVtp5gsJMuxryNyiko4XhLGF0wiUm72yLkjAAyPhWzHgj8+LrcrDlYxr8RORTHRLI4csmIWSQtbrJQxmZheIjOGOCtzXn8scoqKuYQ4tM+fy5tQegohnHJllzOdLPL1bSA8OwlbbItCGuWZTUa1ZTr9fS7xTuDJKDu3xz+f2CyUODdtoUg+fzPxb8VPRExAJiVssU5U5RS11k5aay8DhoCrgAurvYAxZqsxZrsxZvscZVSUujHXtR2v66NHjtRVRkWpllmFLVprTxhjHgbeCCwxxhS8JjME7J3mO9uAbQDGpHgVFGUBMNu1Ha/rLVdsmdW6Fq031tZEg06SWAiJRUlT6UjzFO1VNPNXhvclc0s7nfa6PKppIt8N5wy6nOwAeqKEHNFy0zT0Sk0dSuu2QNBaZS5XpKHnpj2X1LrpiBppiGYea+2SlCVafny8sO/MweRzb5vT2pd1LvPnDElEXdLkOkp+kh2GOHrj8EW5ZiXNu5HNL2bU0I0xy40xS/znLuD3gB3Aw8B7/GG3AffXS0hFqQe6tpWsUY2GPgjc7W2NOeBea+33jTHPAvcYY/4K+DXw1TrKqSj1oKFruzS0L7YbSxNmCVWEoL2258o1PPnusK/SeODMkeh77vhYQ+/xLeXStNdcYnMPO4CQoj69Bh3bj0tnY/9ADl9RUWqNpyQWFZ/B1003k2Xn6s6XV3PMedu57CZi38H+swcAuPfZf03G2n01yv+4aQsAF6S0s4sRf4U8n6novnNh+1H2PdOEuukzvtCttU8BW1LGd+FsjorSkujaVrKGZooqiqJkBK3loiiNwjsyxckWh8tJy7Y4a3GypDZJmjOxkJgb4vZ0Uo8kdkyWZmsGM4aYL9LargWDSHnLtzgTNTE5JE0dKJvLlzSKcOcqR+bTml+QS6sH40Ms/XUKJphcdp/cD8BTT7+YjEkm85pFzhm6dlHIRJVnHoc5jk45M1ibdeaqtkj+KXH0TnMnjUY1dEVRlIygGrqiNAjR4aR64lhU0W9s0n2Oa4iIo3TcjJfNiRYrFRJX9fZH5/LafqShy3flp9Qth/LKisXSpjj7UqomhsnpQxrlXEXO4JQqjqXVCdOcqMX1YIqPi2ve9He5JKKJiaiW/Bm3g9l51LXx27c6hDRuXLzRXyecX/6+5Hnm85HDN7mVWbanqxOqoSuKomQEfaEriqJkBDW5KHOip8fFNS9aVN6GTKmMONxis0SonVJujhBzTFqbtn7fzGLdopFkTtrNdbeFzM+OktZwcTx6h8+OTIvBFmYdU50ao14efy8moNgJOVWS+ZlLMd/Ehg0pqSvmj/g+1i92JZ17ukK53VOn3fMZOetKDx/xbe0gZN7GMfmljtIpG16bSaaoEZNLoJEZooJq6IqiKBlBNXRlTrzuda8D4KqrNP9mrkj9FggNG2LtUuqvSGhiR+TIDBqh0wmXd4XGFV0Flz3aF1UkFG1dQgA7UhpE5IpqlJR/mg3V6qZyv1Mp9VGS9nS58roqRU0z/MXEZRxLLC39errLM2THxpzGPToZnNOnfeZtT7S7ERmlIXdbLq5v4+vy2HJnsGlg6zlBNXRFUZSM8Fujobe3O23n+uuvT8be8x5XfylulXbeeecBcMcddwDw5S9/uVEiKhnHUhw6GGvjbUmdk6DhiRYtc/lIU7Ulbd3iUD9pJSeVAyGqgZJSTyWEIUbWblts7zam/FWRZnMPwY7V6ejJtdPmkmbRUW3yEvnSrx7o9pUVO7uCht5WKE7Gis91dsL5IuKQUtnVjPvqj4Wp6bsRxlUa05/PzNUZ54Nq6IqiKBlBX+iKoigZIZMml8HBUJvhIx/5CAA33ngjABdccEEyd/jwYQAOHDiQjP35n/85AF/5ylfqLmcrs3HjxmaL0HLIxj4tO1K24ucmzyVjkqEYN7Yo5fS4C7OLs0jFRNMehSa25YvDFmNC3ZbIMWl8OKFkR0bnTz1Hmemk/FPlLMr4+BIHY1yu1pfinSJ+huEKxWeCRW3OMTw0GEoJHz/unlnfEtcko6c9mKZGvMllIsqylcciY5K5C+G5JzLnm6sjq4auKIqSEarW0H0TgO3AXmvtu4wxG4F7gH5ck91brbXTewvqSFeX+x/2U5/6FAB33nlnMicOj2eeeQaAP/qjP0rmvvWtbwEwMhKSMpTqeP/73z/jMTt37myAJPOjGetatLpY0xXt9axPCgKY9MdJElDsqJPjT/lEmFiLb8+3FR3jfimp2JiS+GOKGjfkimSs1Bi5mHIHayR0yrncjzz5aKi8Xks4hWjv5bVcJMEo3gdIW71r1782GZvw1RYvW7UKgLWLVoVzebnjHU9p8tNElAQl9XZyKXVkbFrlyTApF0yZnDuz0dA/gmvPJXwW+IK19nzgOHB7LQVTlAah61rJDFW90I0xQ8A7gb/1vxvgOuA+f8jdwE31EFBR6oWuayVrVGty+WvgTkAKd/QDJ3xXdIA9wJoay1Y1X/va1wC4+eabAXj00UeTua1btwLw3HPPNV6w33JaoM5LU9Z1WiyyNJyIs0cl9VF6Wh47F8wx4jyd8Fv+OFM0iVtPdYBOX9Y2jcTcYIIJIifx20XnKr6n9DjrcpNIcs6iuPji5hpFkiYNJdJO72S0RQ5iZ4rasuKSZEwyb9f0rgRgIOq9enb8TJk88gzEKZo3UWMS/3cjz7XDBke0pd3/DHdc7/ouM2roxph3AYestY/P5QLGmK3GmO3GmO1z+b6i1INaruujR47M/AVFaQDVaOjXAL9vjHkH0AksBr4ILDHGFLw2MwTsTfuytXYbsA3AGFOz6u9DQ0PJ5xtuuKFo7qabwi752LFjtbqkMktWrlzZbBEqUbN1veWKLVWt69LWanFFP8nqXNK+JBkrbUEnlQABJvyc1IBZ1NYbzuUzRePaL6HlXLkGnWiQUcak1EyRn+IkBbCm/PhKLevC90ra1EWkHl82Euq7TKU23hAZg4Yu2vhgdwhlNgPuuJ628ozaNn98W+TcLP17iCtDhkqMxT/j44vrzjRZQ7fW3mWtHbLWbgDeBzxkrf1D4GHgPf6w24D76yalotQYXddKFplPYtGfAvcYY/4K+DXw1dqIVB0DA8HutXixSx74yU9+AsDx48cbKYqSLeq2rsUu2+k1wrg2S8HX2I6TgSSpRzS9uAKg1Cjp9mF5i9tCZUXR/OO6IklFxZRQwDS7d2J99/LkUqohptqDpQVdSl2YuVJsqU85f3KcKZPV4DTtJe1LIxGLn0Ec8inPJ35OYjtPKlwW7WSkPo/eGR8ZAAANZElEQVQ0/o409Ephi3ViVi90a+0jwCP+8y5Aa6cqLY+uayUraKaooihKRmjZWi6x41P42c9+Bsx/i6fUhieffLLZIiwoxCTQ7p2VsdlAxnKF8m7zkiEaZ4rKucTxGTtYpdxrLjLp5JJQwApO0VhWcXKWmBTi7xaZYUzx+WNKnYOVa7qUk3Z0mvxhLG4y4X7GGZxiYhEHZtyOL2TGhnPEmaGl8uenCkXfi8NOG9+ATjV0RVGUzNCyGvqGDRvKxvbuTY0wKyKfD/+DijN1YiL8Dzw8PFz2HWV27N69G4Cvf/3rzRVkgVEatpiWcBJr2uI0NZNu7txkqDkkTrs0Z2ep0y+NmbRkmZfdbhyOl2jmRVUQS74f7ZKTc4l8VTe/kO/PjriptAQwxs9EdjDy7AomaO+FfPgstDNVNiaUVs5sTw0VbRyqoSuKomQEfaEriqJkhJY1uVx++eVlY0uXuljTq6++OhmTfqHvfOc7Aeju7k7mpGN9HLf+wx/+EAiNMY5oWnfCihUrks9pJi9Bauu8+uqr9RapJUm2/1HNEXGQxtt0+STmi9gck5hvcsUZoBA7IaMSsKb4e0Xd6SuYQBJ5TPnxca2YXMNcgFUYYGJZk1DwMCbZo3GJ3Iqnozg2vch8U1IGt+iZiIM1zQRWp4xR1dAVRVEyQstq6Gl85jOfmXZOarocPHgwGduxw5XB7ukJGXi33HILANdffz0An/70p5O5v/mbv6mdsC3Il770peTz5s2bpz3uRz/6USPEaT1Ei0vaqMWZmdKAotyRls85x1shV/7PtTRTEdIbRJSFLabMxdqvNIuQmaIqTKZcyy+l2nZzlajWGZqcLWXnQ/Jcw/1KBq1l3P9M09Sn38HEv5lEC0/T0KfPyq0XqqEriqJkhJbV0L/xjW8kn//yL/8SgHPnXI3ohx9+OJn77ne/C8BDDz0EFGvoQqyhf/CDHwTgc5/7HACf//znk7nVq1cDcNddd83/BlqQxx57LPn83ve+F4BXXnklGfvd3/1dAF566aXGCtZipLdYK5SN2ZJWdd354P8RDVjs6kX29ZLKhzMzvS4cGjVXtgOLPKFp8myvN3/NNa1BtcgdV4sMYaOyuynX0OOdUnkN+ZT2fSnJVpTMNQLV0BVFUTKCvtAVRVEygmlk3ZNaNriIGRx0xevHx52ToxahhtLO7p577knGJKP07W9/ezL2yCOPzPtaSu2w1ja8hMaWK7bYn/7i4ZkPFFJqmqSVpBWTi9QSGY9quQiFlHZzEmZX7JgUJ6eE4FUyKYRQyUrOzYrlcyscl1o7pqJuWV1Wa9rR1pabVSb8c5TnWpzt6b4dlx4ulT+X4vgMmbsp36tBiGJf+9LHrbVXznScauiKoigZoSqnqDHmZWAYmAQmrLVXGmOWAd8BNgAvAzdba5vSWWL//v01P6c4U+MEpjvvvBOAa6+9NhlTDb21acraFi02RfG0RaGDxdplURiiVPeTWi6xbpYSVigad1qSS5r+W671lh+VVoumYrXFElmKiJpQzz0cMuW0KQ0xksYifjNX1F4vRQb5nOyiUpKsUncYdW43l8ZsNPS3Wmsvi9T+TwIPWms3AQ/63xWlFdG1rWSC+ZhcbgTu9p/vBsoLlCtKa6JrW2lJqo1Dt8CPvFPzf/mO5yuttWLrOAAs6Bbvs0W2hbt27WqyJEqdWVhrO6VfpcRLx2aVXImpZeaSudObUOYaqlCpHsxsTzm9W3P2FPUgNeVmFWOKzSRT1Za5tWkml5I6L01paxGo9oX+JmvtXmPMCuDHxpjn4klrrZ0ugsUYsxXYOk85FaVezGltx+t67bqhxkiqKDNQ1QvdWrvX/zxkjPkHXBPdg8aYQWvtfmPMIHBomu9uA7ZB/cIW60l7e/vMBykty1zXdryut1yxZW7rOnaapTgKS7MP0+qvmDTNUM4bN5mowkGXFkaZKnYVbeaq/V44QXxt+UL58XPWf1MqMCYhh1Vanq0pDy0Nck0foli0Y6jqSnNnxjsxxvQYYxbJZ+DtwL8BDwC3+cNuA+6vl5CKUg90bStZoxoNfSXwD95uVAC+Za39oTHml8C9xpjbgd3AzfUTs5yOjtDq6dvf/jYAH/jABwA4efLkvM8v7ek+9KEPlc2NjIyUjSktyYJZ2yE0Lm0yrYZ5+jHTUlK3u2gqNdGntMJgdd9LPb6G4XshrLA6UtvYVQgbrXyuCldtQohiGjO+0K21u4BLU8aPAm+rh1CK0gh0bStZQzNFFUVRMkLLls+96KKLks833eTChIeHhwG4/fbbkzmpvzJbPvaxjwFw4YUXJmNSKjYu3asotSS2AkimaJJZmVY6pcqsyqRhhdQ0Scl2TKMmYXil5p5q60dVMGPMuvlFpfPPJE8NzSmpJqAaohq6oihKRmhZDV3ax0Fwit56660ArF+/PpmTBhUPPPDAtOfq6+tLPn/84x8HQpNoqeAYz9Wjdozy20OavpckwEQ6VoE2PyeVEiOtWkIYZ6k9Jk7FWCut5hwzhFhWd/Ha6aWz1ZlTn3kyWXsNfDqaHraoKIqitAYtq6GPjo4mnyVcsbOzE4Abb7wxmXvTm94EwKFDqXlPQHHy0LJlywA4cOAAAHfccUcyd999981XbEVJpazRMZAvrfKXEgpYSfOMj09rWFydYCnXSTTalKvPVQuvc9hfUY/rul6puaiGriiKkhH0ha4oipIRWtbkEjM25lpKvfvd7wbgggsuSOb++I//GIBrrrkGgNe//vVl33/yySeTz+JglWYWmhWq1JpK2Y5plQLnHDoYmTHiaoNzoWpDSoMyJucTttjoglKNvJ5q6IqiKBkhExp6Kc8//3zy+cMf/nATJVGUuVPvJJSqqEESUNmhM12y6jPNTC3OVUne2daWqTeqoSuKomQEfaEriqJkhEyaXBSlFag2NrqS6SVty1+pZGxNsjXn6fhsuS43FajGHNNIVENXFEXJCFW90I0xS4wx9xljnjPG7DDGvNEYs8wY82NjzG/8z6X1FlZRas1CWduW6TW6SnOlx8R/UjEGjMGk/KHKPwZa7k/RI0gZK52b7rsLnWo19C8CP7TWXohrCLAD+CTwoLV2E/Cg/11RWg1d20pmqKanaB/wO8BXAay1Y9baE8CNwN3+sLuBm+olpKLUg1ZZ2/XWWGd7nVYkTf6s3FtMNRr6RuAw8DVjzK+NMX/rG+qutNZKHdkDuP6MZRhjthpjthtjttdGZEWpGXNe2/G6PnrkSANFVpTpqeaFXgAuB/6ntXYLcIaSLah1LVVSzXbW2m3W2iuttVfOV1hFqTFzXtvxuu4fGGiIsIoyE9W80PcAe6y1j/nf78P9IzhojBkE8D+nr0+rKAuTll3baU5Q/TO3P7WkXuetlhlf6NbaA8CrxhipePU24FngAeA2P3YbcH9dJFSUOqFrW8ka1SYW/Tfgm8aYdmAX8AHcfwb3GmNuB3YDN9dHREWpK/Ne2+JQq4VWlqWkm1ahmc+81tUgq3qhW2ufANJs4G+bx7UVpeno2layhGaKKoqiZASt5aIoirKAmE88vGroiqIoGcHYWlRfq/ZixhzGxfq2cibGAK0rfyvLDjPLv95au7xRwgh+Xe+mtZ9vK8sOrS1/NbJXtbYb+kIHMMZsb+Uko1aWv5Vlh4Uv/0KXrxKtLDu0tvy1lF1NLoqiKBlBX+iKoigZoRkv9G1NuGYtaWX5W1l2WPjyL3T5KtHKskNry18z2RtuQ1cURVHqg5pcFEVRMkJDX+jGmBuMMc8bY3YaYxZ0FxhjzFpjzMPGmGeNMc8YYz7ix1um9Z4xJu/rfH/f/77RGPOYf/7f8fVLFiQLpTVcNbTSugZd282mnmu7YS90Y0we+DLwH4DNwC3GmM2Nuv4cmAA+Zq3dDFwNfNjL20rtyT6Ca6kmfBb4grX2fOA4cHtTpKqOlmgN14LrGnRtN5v6rW1rbUP+AG8E/jn6/S7grkZdvwby3w/8HvA8MOjHBoHnmy3bNPIO+YVxHfB9XEbxEaCQ9vexkP4AfcBLeB9PNL7gnn2rr2svs67txsle17XdSJPLGuDV6Pc9fmzBY4zZAGwBHqPK1nsLgL8G7gSm/O/9wAlr7YT/fSE//3m1PWwwLbuuQdd2E6jr2lan6AwYY3qBvwf+xFp7Kp6z7r/TBRcmZIx5F3DIWvt4s2WZI/Nqe6hUh67tplDXtd3IF/peYG30+5AfW7AYY9pwC/6b1trv+eEF354MuAb4fWPMy8A9uK3pF4ElxhipsLmQn38rtYZruXUNurabSF3XdiNf6L8ENnlvdDvwPlyrrwWJMcYAXwV2WGs/H00t+PZk1tq7rLVD1toNuOf8kLX2D4GHgff4wxak7NByreFaal2Dru1mUve13WCHwDuAF4AXgT9rtoNiBlnfhNv2PAU84f+8A2evexD4DfATYFmzZZ3hPq4Fvu8/vwb4V2An8F2go9nyVZD7MmC7f/7/CCxdqM++lda1l1fXdnPlrtva1kxRRVGUjKBOUUVRlIygL3RFUZSMoC90RVGUjKAvdEVRlIygL3RFUZSMoC90RVGUjKAvdEVRlIygL3RFUZSM8P8Bzj2Smqsj3bYAAAAASUVORK5CYII=\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_time_lstm(rand_x.to(device),\n",
    "                                torch.ones_like(rand_x.to(device)) / 10)[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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving the model weights for transfer learning to MissingMNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type ConvTime_LSTM. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type ConvTime_LSTMCell. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(conv_time_lstm, 'ConvTimeLSTMSavedModel3.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}