05_01_MissingMNIST_ConvLSTM.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"
   ]
  },
  {
   "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": [
    "# Creating 9 data subsets, which the data will be uniformly sampled into and subsetted from 20 frames to [11, 20] frames, keep tracking of the number of frames omitted (i.e. $\\Delta{t}$ where 1 = no omission, 2 = 1 omission, etc...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating empty nested lists to store data...\n",
    "train_data = []\n",
    "for i in range(9):\n",
    "    train_data.append([])\n",
    "# ...and time steps in\n",
    "train_delta_Ts = []\n",
    "for i in range(9):\n",
    "    train_delta_Ts.append([])\n",
    "\n",
    "# For the train (above) and validation (below) data\n",
    "validation_data = []\n",
    "for i in range(9):\n",
    "    validation_data.append([])\n",
    "validation_delta_Ts = []\n",
    "for i in range(9):\n",
    "    validation_delta_Ts.append([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(Moving_MNIST_tensor.shape[0]):\n",
    "    \n",
    "    # Determine how many frames to keep out of the 20 possible\n",
    "    #     leaving 11 so that there is at least 10 for input and 1 for out\n",
    "    num_frames = np.random.choice(range(11, 20))\n",
    "    \n",
    "    # Determining what index that places the data in\n",
    "    data_index = (num_frames - 11)\n",
    "    \n",
    "    # Now that we have a number to keep, picking which specific ones to keep\n",
    "    frame_indices = np.random.choice(range(20),\n",
    "                                     size = num_frames,\n",
    "                                     replace = False)\n",
    "    \n",
    "    # Sorting those frames to proper chronological order\n",
    "    sorted_frame_indices = sorted(frame_indices)\n",
    "    \n",
    "    # Getting the missing-frames-data\n",
    "    frame_data = Moving_MNIST_tensor[i, sorted_frame_indices]\n",
    "    frame_data = frame_data.unsqueeze(dim = 0)\n",
    "    \n",
    "    # Determining \"time steps\" between indices\n",
    "    #     1 = proper sequence\n",
    "    #     2 = missing one index inbetween\n",
    "    #     3 = missing two indices inbetween\n",
    "    #     etc...\n",
    "    delta_Ts = []\n",
    "    for j in range(1, len(sorted_frame_indices)):\n",
    "        delta_Ts.append(sorted_frame_indices[j] - sorted_frame_indices[j-1])\n",
    "        \n",
    "    # Getting delta_Ts as an image band\n",
    "    #     \"num_frames - 1\" because it's not necessary for the first band\n",
    "    #     since it has no prior reference\n",
    "    delta_T_tensors = torch.ones([1, num_frames - 1, 1, 64, 64])\n",
    "    for k in range(delta_T_tensors.shape[1]):\n",
    "        delta_T_tensors[:, k, :, :, :] *= delta_Ts[k]\n",
    "    \n",
    "    # Storing it and its time steps appropriately\n",
    "    if i in train_indices:\n",
    "        # Initiating the tensor within the empty list\n",
    "        if train_data[data_index] == []:\n",
    "            train_data[data_index].append(frame_data)\n",
    "            train_delta_Ts[data_index].append(delta_T_tensors)\n",
    "        # Or expanding upon the tensor\n",
    "        else:\n",
    "            train_data[data_index][0] = torch.cat([train_data[data_index][0],\n",
    "                                                   frame_data])\n",
    "            train_delta_Ts[data_index][0] = torch.cat([train_delta_Ts[data_index][0],\n",
    "                                                       delta_T_tensors])\n",
    "    elif i in validation_indices:\n",
    "        if validation_data[data_index] == []:\n",
    "            validation_data[data_index].append(frame_data)\n",
    "            validation_delta_Ts[data_index].append(delta_T_tensors)\n",
    "        else:\n",
    "            validation_data[data_index][0] = torch.cat([validation_data[data_index][0],\n",
    "                                                        frame_data])\n",
    "            validation_delta_Ts[data_index][0] = torch.cat([validation_delta_Ts[data_index][0],\n",
    "                                                            delta_T_tensors])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For train data...\n",
      "torch.Size([849, 11, 1, 64, 64])\n",
      "torch.Size([903, 12, 1, 64, 64])\n",
      "torch.Size([887, 13, 1, 64, 64])\n",
      "torch.Size([873, 14, 1, 64, 64])\n",
      "torch.Size([935, 15, 1, 64, 64])\n",
      "torch.Size([858, 16, 1, 64, 64])\n",
      "torch.Size([930, 17, 1, 64, 64])\n",
      "torch.Size([843, 18, 1, 64, 64])\n",
      "torch.Size([922, 19, 1, 64, 64])\n",
      "\n",
      "For validation data...\n",
      "torch.Size([116, 11, 1, 64, 64])\n",
      "torch.Size([110, 12, 1, 64, 64])\n",
      "torch.Size([114, 13, 1, 64, 64])\n",
      "torch.Size([98, 14, 1, 64, 64])\n",
      "torch.Size([110, 15, 1, 64, 64])\n",
      "torch.Size([113, 16, 1, 64, 64])\n",
      "torch.Size([117, 17, 1, 64, 64])\n",
      "torch.Size([101, 18, 1, 64, 64])\n",
      "torch.Size([121, 19, 1, 64, 64])\n"
     ]
    }
   ],
   "source": [
    "print('For train data...')\n",
    "for i in range(len(train_data)):\n",
    "    print(train_data[i][0].shape)\n",
    "\n",
    "print('\\nFor validation data...')\n",
    "for i in range(len(validation_data)):\n",
    "    print(validation_data[i][0].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separating $x$ and $y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_11, y_11 = sep_x_y(train_data[0][0])\n",
    "x_12, y_12 = sep_x_y(train_data[1][0])\n",
    "x_13, y_13 = sep_x_y(train_data[2][0])\n",
    "x_14, y_14 = sep_x_y(train_data[3][0])\n",
    "x_15, y_15 = sep_x_y(train_data[4][0])\n",
    "x_16, y_16 = sep_x_y(train_data[5][0])\n",
    "x_17, y_17 = sep_x_y(train_data[6][0])\n",
    "x_18, y_18 = sep_x_y(train_data[7][0])\n",
    "x_19, y_19 = sep_x_y(train_data[8][0])\n",
    "\n",
    "x_11_validation, y_11_validation = sep_x_y(validation_data[0][0])\n",
    "x_12_validation, y_12_validation = sep_x_y(validation_data[1][0])\n",
    "x_13_validation, y_13_validation = sep_x_y(validation_data[2][0])\n",
    "x_14_validation, y_14_validation = sep_x_y(validation_data[3][0])\n",
    "x_15_validation, y_15_validation = sep_x_y(validation_data[4][0])\n",
    "x_16_validation, y_16_validation = sep_x_y(validation_data[5][0])\n",
    "x_17_validation, y_17_validation = sep_x_y(validation_data[6][0])\n",
    "x_18_validation, y_18_validation = sep_x_y(validation_data[7][0])\n",
    "x_19_validation, y_19_validation = sep_x_y(validation_data[8][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Consolidating the 9 subsets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.cat([x_11, x_12, x_13,\n",
    "               x_14, x_15, x_16,\n",
    "               x_17, x_18, x_19])\n",
    "y = torch.cat([y_11, y_12, y_13,\n",
    "               y_14, y_15, y_16,\n",
    "               y_17, y_18, y_19])\n",
    "\n",
    "x_validation = torch.cat([x_11_validation, x_12_validation, x_13_validation,\n",
    "                          x_14_validation, x_15_validation, x_16_validation,\n",
    "                          x_17_validation, x_18_validation, x_19_validation])\n",
    "y_validation = torch.cat([y_11_validation, y_12_validation, y_13_validation,\n",
    "                          y_14_validation, y_15_validation, y_16_validation,\n",
    "                          y_17_validation, y_18_validation, y_19_validation])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing the overlaid $(x, y)$ sequences where blue = early $x$ frame, green = late $x$ frame, and red = $y$ frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_ex():\n",
    "    random_index = np.random.choice(len(x_validation))\n",
    "    for i in range(10):\n",
    "        if i > 5:\n",
    "            plt.imshow(x_validation[random_index, i, 0], alpha = 0.25, cmap = 'Greens')\n",
    "        else:\n",
    "            plt.imshow(x_validation[random_index, i, 0], alpha = 0.5, cmap = 'Blues')\n",
    "    plt.imshow(y_validation[random_index, 0, 0], cmap = 'Reds', alpha = 0.25)\n",
    "    plt.pause(0.01);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_ex()\n",
    "plot_ex()\n",
    "plot_ex()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 16,
   "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": 17,
   "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": 18,
   "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": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_lstm.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(conv_lstm.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils import data\n",
    "\n",
    "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": 21,
   "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": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_lstm = torch.nn.DataParallel(conv_lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0 \n",
      "\tBatch loss:  0.026458468288183212 \n",
      "\n",
      "Epoch:  1 \n",
      "\tBatch loss:  0.024416333064436913 \n",
      "\n",
      "Epoch:  2 \n",
      "\tBatch loss:  0.026674434542655945 \n",
      "\n",
      "Epoch:  3 \n",
      "\tBatch loss:  0.020224059000611305 \n",
      "\n",
      "Epoch:  4 \n",
      "\tBatch loss:  0.023150352761149406 \n",
      "\n",
      "Epoch:  5 \n",
      "\tBatch loss:  0.021289145573973656 \n",
      "\n",
      "Epoch:  6 \n",
      "\tBatch loss:  0.021601008251309395 \n",
      "\n",
      "Epoch:  7 \n",
      "\tBatch loss:  0.025517204776406288 \n",
      "\n",
      "Epoch:  8 \n",
      "\tBatch loss:  0.0220030490309 \n",
      "\n",
      "Epoch:  9 \n",
      "\tBatch loss:  0.021812530234456062 \n",
      "\n",
      "Epoch:  10 \n",
      "\tBatch loss:  0.019466962665319443 \n",
      "\n",
      "Epoch:  11 \n",
      "\tBatch loss:  0.020250407978892326 \n",
      "\n",
      "Epoch:  12 \n",
      "\tBatch loss:  0.018998702988028526 \n",
      "\n",
      "Epoch:  13 \n",
      "\tBatch loss:  0.019118022173643112 \n",
      "\n",
      "Epoch:  14 \n",
      "\tBatch loss:  0.022934427484869957 \n",
      "\n",
      "Epoch:  15 \n",
      "\tBatch loss:  0.01903742365539074 \n",
      "\n",
      "Epoch:  16 \n",
      "\tBatch loss:  0.018058082088828087 \n",
      "\n",
      "Epoch:  17 \n",
      "\tBatch loss:  0.021866662427783012 \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": 25,
   "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": 27,
   "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": [
    "# View prediction on sequence ($\\hat{y}$ on $x$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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 = 'Blues', alpha = 0.5)\n",
    "    axarr[1].set_title('Blue = Predicted', fontsize = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAD8CAYAAABEgMzCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztvXmUJVd15vvtvPfmnJVDValUqtKEZiEzFjJYDEIMlkE20AvzbGO3aOSnBoOf3R4wNP36qbHbbbp5tlltP2w1k9wNNoOhBYjGLYQws0AggRCSQJTGmrKysnIe783z/rhRsb8TdSPzVuUQOXy/tXLliYgTESfujR3nxnf22dtCCBBCCCFEcbQU3QAhhBBiq6POWAghhCgYdcZCCCFEwagzFkIIIQpGnbEQQghRMOqMhRBCiIJRZ7xKmNlNZhbo77CZfc7MnraC53iPmT26UsfLOceHM9fR6O/Dq9kGIU6FBrY3ZWb3mdmNmXpXJ9uvKKqtp0Pm2qaTa/stM1u157mZXZGc7+pMO956Csd4uZn97gq3a8jMblrJYxZFuegGbHJGAVyblM8D8C4At5vZZSGE4cJadWr8MYC/oeU/BdAH4Ldo3dE1bZEQS8O21wXgFwH8rZlNhBA+WlyzVoz/F8AnAXQCeDWAv0b95eqv1rANzwPwyCnUfzmA1wL4y9VpzsZGnfHqUg0hfCspfyt5i/0m6g+JDfFACCH8FMBPTyyb2TCAFrquXMysI4QwvZrtEyKHauYevcPMfg71jmtD2N4SPErX9yUzuxzAm5HTGa+GLTbzDBDNI5l6bfl+8v9sXmlmA2Z2s5kdMbMZM/uGmf1spk6fmX3UzCbM7JCZvXPNWt0EZtZ+QrYys78ysyEA30m2HTazP8nUf1NSv0zrdprZB8xsMJHfvmpmz17jSxGbl3EAlbyNZnZeck9el1n/YTO7O7PuCjO7zczGk79PmNmZq9TuZvgu6uobX8frzezvzGwEwGdPVDSz3zSz+81s1sweM7O3ZQ+WyN5PmNmkmX0WwO4GdU6Sqc3sNWb27cR+j5nZ583s3ERK/n0A5zYa3jKzF5jZPydDCsfM7L+ZWU/m2C80s+8nz8jvJj+uNg16M15bzkn+p9KOmbUB+CLq0u8fAhhE/RfuF83sohDC4aTqhwBcDeDfADgM4A8AXACgutgJzcwAlJZqWAhh0eOcAu8EcAeAXz+VncysA8CdANoA/B6AYwB+G/U3mgtDCEMr1D6xRaAfep0AfgnAiwC8cQWOeyGArwO4G/X7vIz6cM5nzezKkBNjeJVt8TzUnwvMewB8CsAvA6glbfhD1Iea/jOALwN4NoA/NrOpEMJfJXVehbrs/TcA/ifqn9sHl2qAmf0GgL8D8A+ofx4G4BoAOwG8H8BFyfJrkl2OJvtdhfoz8H+iLmNvB/BnAPqTZZjZWQD+F4BvJ+vOAvAR1L/bzUEIQX+r8AfgJgBDqBtqGfWO83YA9wBoo3o3AJgDcBGtK6MuDf+XZPmpAAKA/4PqdAMYRl2uWqwdb0j2XfTvFK7rkwC+3GB9e3KsbzbYdhjAn2TWvSmpX06W3wJgGsB5VKcNwBMA/rjo71N/G+cvsb1G9/l7M/WuTtZfkSyflyxfl6n3YQB30/J/B/AQgFZadxHqHd4rF2nX1Tntyv6dt8T1BQD/V/Kc6AHwL1H/Uf6ezHV8OrPfNgATAP6fzPp3JTZaSpa/DeB/Zer8t+SYV2fa8dak3ALgAIBPLdLu9zR6XgH4KoA7M+uuyXw3/xn1H+idVOf1SZ2bir7nVuJPb8ary3YA87R8DMBzQgiztO6lqEtMj7BkC+CfAexLys9J/t96YmMIYcLMbgcQydkN+Cztvxbcdpr7vRTAXQCepM+hhrqh7svdS4jGjKJ+TwH1H3XPBvAuMxsOIfyHZR77pQBuAbBA9+ojAB5F/V7Ns4HvojlbPNhEnfcmf0C9Q/o71H+EMNl2PA91Z7ZPZJ41XwLwfwPYa2YHADwLQNZL+lMAfnOR9lyC+tvqh5poe4qZdSbt+u1Mm76G+rPz2QB+COBKALeHEKaozqdP5VzrHXXGq8uJB0IJwNNR/2X4UTO7KoSwkNTZAeC5iDvtE5xwnDoTwHgIYSazfbCJNgwn7VgrjpzmfjsAPB+NP4f7T785YotSDSHwOO/Xk4f9fzKz/xqWN5thB4A/Sv6ynN1g3QkmANy71MFDczL1fwHwcdTVpP2hsXNW1hZ3JP/z7OlsALOoP6+yz5alnjXbk/+HlqiXpT853/+X/DVqE1B/Bv6AN4QQpsxs4hTPt25RZ7y68APhLjObRv0X7C8D+Fiyfhj1sac3N9j/xBv0YQA9Ztae6ZDPaKIN16O5X6vWRJ1maDReNgOgNbOuP7M8jPo4XKN5iPLIFivBA6jfhxegfr9lOWFbzdyrn0Z9HDTLYr4NL0LdL2JRzOz8EMKjS1R7PPNjoxFZWzxxzdeh8Y/mh1C3tRpOfrYs9aw5lvw/ydFrCUaQSM0APt9g+wmV4HC2Dclbdfcpnm/dos54bfkf8F/UJzrjO1Cff/d4CCHv1+d3kv+vOrGfmXUDeBmAsSXOudYydSOeBHBZZt3LM8t3oC6V7V/mW4sQeZwI7vFEzvZB1JWZ9F5N7OznADxG9e5A3Y/juyEZvGySlZSpT4dvot7ZnhVCyB1OMrN7UH/WcHyBf7HEsR9Cfcz4epDndoY51H1LUkIIk2b2LQCXhBDetcjxvwPgjWbWSVL1axapv+FQZ7yGhBCCmf0pgI+Y2UtCCHeg/qb8JgBfNrP3ANiPuuRzJYDDIYS/CCHcb2afAfA+M9uGuhT0hwCmGp8pOucx+K/Wovg0gHcnUyjuBfA61N9OmPcD+D9R/xz+HPUxuB1IAguEEP56DdsrNj5lM3tuUm5Ffezx3wG4NfgMhYgQwoKZ3Qrg35jZY6i/tf0+TlZmbkLdyek2M/sg6m/De1D/cfzhEMKXc44/jroKVgghhJFkitF7zexcAF9B3fHqYgAvDiGc6Nz+FMCnzOx9qNvui+ABVPKOvZDY90fM7CMA/h71N95rAPx98hb/IIBdZvYG1MeBhxIF4G2oz5pYQN1BdBz1mSevBPDOEMKPUQ8U8hYAn0ueD2cBeAc2k2pWtAfZZv1D4k3dYH0JwI8B/BOt60XdGeMJ1H89Pom6w8RVVKcf9SkDk6hLTP8eOd6Jq3xdS3lT/2aDba0A/ivqbx7Hkna/FeRNndQbQH1KxYHkc3gCwCcAXFn096m/jfOHk72p5wD8BMC7AfRQvatBHrvJul2oO0qOof42fCMy3tRJvUsTWxhGvUN4GMDfAti7BteXejHnbD8PDbzCafuvo/6WPg3gOOqOk7+XqfPW5Dk0hbp8/HIs4k1N6/5FcuyZxNZvA3Busq0d9SGzwWTfD9N+PwvgC8nnPgngRwD+HEBv5vv6AerDd/cCuAr1H0I3FX3PrcSfJRcphBBCiIJQBC4hhBCiYNQZCyGEEAWjzlgIIYQomGV1xmZ2rZk9ZGYPm9nbV6pRQoi1R/YsRHGctgOXmZ3wCn4Z6l533wHwqyGEH61c84QQa4HsWYhiWc484ysBPBxC2A8AZvYPqE8UzzXers7O0NfXt4xTCrE1OHjo0FAIYecanvKU7Lmzq2tZttxMuDfN8xCbgUMHDzZly8vpjPcgjmTzJBokLTCzG1Gfq4fe3l685V8vFmtcCAEA77zpjx9butaKsqQ9Z235X7/pt077ZPVsgoujaZdiM3DTv/93TdnyqjtwhRBuDiHsCyHs6+rcPKknhdhqsC13dnUV3RwhNhXLeTM+gDhDyd5knRBi47Gm9qy3XiFilvNm/B0AF5nZ+WbWCuBXAHxmZZolhFhjZM9CFMhpvxmHEKpm9lYA/4R6vOUPhhCUd1aIDYjsWYhiWVbWphDC59E4B6UQYoMhexaiOBSBSwghhCgYdcZCCCFEwagzFkIIIQpGnbEQQghRMOqMhRBCiIJRZyyEEEIUjDpjIcQpY6jHl24mxrQQYmnUGQshhBAFo85YCCGEKBh1xkIIIUTBqDMWQgghCkadsRBCCFEwy0oUIYTYmgQ0l5OYva1PNYfx6Xhqb4Q8ydzCbHMtZ0E+65sfvRkLIYQQBaPOWAghhCgYydRCiFVjObLxYvvmSdjLkcVXgpCzEEvTvrSQaWKpxdtvvD9fLq1fq5grzQwZbIQhgvWM3oyFEEKIglFnLIQQQhSMZGoREctRlrPeCWEhsyypSqwPmvXGXsl7lg+Vd9zFztZUk5uUpvn688rMwsJCw/VFs9z45xvlmaQ3YyGEEKJg1BkLIYQQBaPOWAghhCiYJceMzeyDAK4DMBhCuCJZNwDgYwDOA/AogNeFEI6vXjPFShKPH+X/HuOxluzYcN7+LS15Y8t+LB4CWmw8iMew1ut41kZjs9jzehoH5JbMV/0+zbMFpokqi8L209LSnC3n2VJ2/3w/kcaf/WrZ8ulMccurs57umyzNvBl/GMC1mXVvB3BHCOEiAHcky0KI9c+HIXsWYt2xZGccQvgKgOHM6lcBuCUp3wLg1SvcLiHEKiB7FmJ9crpTm3aFEA4l5cMAdq1Qe8QyaSYy0eJzI1hOzpPAcsIBZbbFTfH9Y8mqsXxdP2cpLZdKJdrSWHbi/Xnf+nJLw3p5stX8fDUtV6vzDetsImTPp0D2lpmvLTQsV9D4notk05MO3rgeY6Rttywi08a20diWF5Nw887P+7MtLyYB59lyMxJybPv5cnze/tWq2/L8/Pq15WU7cIX6J5D7LZjZjWZ2t5ndPTk1tdzTCSFWkcXsmW15anJyjVsmxObmdDvjI2a2GwCS/4N5FUMIN4cQ9oUQ9nV1dp7m6YQQq0hT9sy23NnVtaYNFGKzc7oy9WcAXA/gz5L/t65Yi8QyWTrSTuxNnd3WWI5uxjP05P3ZG9vL5XIlLbe2tqXl9nYvZ9vJsDRWq9XScqnkt3NWypqbm0vLk5MTaZnl6DyP8S2A7DmBJYFoMIY2sBQNALWFSFtueKw8OXm+FosQ85HN+PpSye/nVrbLUr4tsw3EbWn8DpZVf5ux5UpldWy5XG7Olicm3JZZjubjLjeC11qx5Juxmf09gG8CuMTMnjSzG1A32peZ2U8AvDRZFkKsc2TPQqxPlnwzDiH8as6ml6xwW4QQq4zsWYj1iRJFbAKaCQLffH2XoFiabmtrT8tdNF7IMhUQe3pOk8Mee013ku9AqeyekjPTM7ltae/o8H3IM3N2drZhmSUrIJbwuM1ZT01vb3Neoqe6D0txp3JsUSwsRc9VY5mabYjvc85BzF/z5KzfA0cm43v+yIR7+07P+3l6O/xRfVaPS8Bn9Lgt9bTHj3M+p5HUWyE5ubvbbbk1Y8ts/1PT037cyJbJLklaztpyIFvuaMKW5+bybZnZTLascJhCCCFEwagzFkIIIQpGMvUGJCstW9W9CxcO7k/LE3d8Iy3/ZMRlowrJOc99wWXRsXa+5nov79zp+1T8Vjl46FBaPjZ0LLedLGFVKo0lJCPP0PaO9mhbhWQv9tSMpXT/PcnyVxb2lM5TkzggwPy8f6ZZOYqpVn0b75MnrbH3dnYfUTx5gzxVkma5DMRDIDXytK4tNA5o8bVHPQDa/kfjYGg1loPZa5rlWBra2da/LS2/8cUXR8c69yyP3bKdbJk9lQ+TLR8fzgZmcyI5utI4AA9/dllbLke23Oob6KNkW+bzZWkmtjV7XLNdL2bLvI33z7Pl7Hre53TQm7EQQghRMOqMhRBCiIKRTL0BCd++I1q+52sPpOWhOZdarrnUZapr3/j6tLzjwsvTcmcmKtpc8N9nIyOeRW+KPKN5on1WGs4eL20zyXRtbY29ObPEMXS9zLGieT17Y5bLWVm8sUzOxDJ1vgcnX8vsrMv/MzOzXCstsfwl5+n1Qd7XkCtTk/xczQTqqJJsenRqhtZ7vUeGXH5+7HGXgxeO5wYvBEok51b93hrY3p+Wt5f8HI9hINp9d4tLxQcOD6Xl2Rlvy+y0hzXNSsPdbMs5EVB4lgXbcvbzZVtuybFlDmzCtpz1ks7zmmaakZmB2JZnZvy74/NzncVk7uWiN2MhhBCiYNQZCyGEEAWjzlgIIYQoGI0ZrzMWHvmhLwweTovD33skLX9vInahb2/3cZt9Az7Oc9azfsbLcz7m2/Ho/Wk5644/R+PBLTRW0kFjJf3tPrbU2+tTKwAgHKdIRRc9zctl32f79u1en84xPj4WHWty0tvMUyOGh3061ehovE8z8Dl5ahGP58bRdDJjhFVOLoHcemJj0EwaAR4mzk5tmqHpbYOTPgbKkboef8L9L/h8LV190bHaWynxQrfbVm9/b1o+7ynn+v7mdpGd8fONR3ycuLPV37u6K96Cc7fvTssDfXFbKiWes0XTg2icd+cOsmW6/8fGxqNjTVLKTZ4mefy4j5+PkS03m9uB7TRvahHXyUbJWk+2rDdjIYQQomDUGQshhBAFI5l6nTFx57fS8lcPu2TM7vyWyS3c3dOdlgc7vTx6z8G03Lt/Eo3Iuv2PjIyk5bY2n1rBU5i6u3vScq32ZLT/6Kjvf92VLrMPvPYNDc/JuYUnJuI2Hj16tOFxa1E+WUnDYnnk5jCmMieAGJ+bB3No3KfBPHnU7+F5SvRQo3v+rLN3pOVd/fFUwJ4+n5507i4v93T5UNTuHT61aWSacvhmpt3ct3/U27Lg+1vFpyAZSeEjmel8lQmfArWNzt/X7+efj2zZr52nPwLA0JDb8tiot4sj461W1mGOWLieE7PozVgIIYQoGHXGQgghRMFIpl4HLDz0vbR816DLO50UkeayLpeML/6D3472P+OJB9NyV4fLXhXyzDx40CVrlolrtYw4tJeTQ/j+Pd0ufy+Q1HM8I22de/kvpuWxHX6skccf930oIH2+N2McBScODr9+pSaxAcnRqdky2LuXvafr21gG9fU8nLKt34d2fmavly8+020EAPac5d7N2/u8XoWSKzz+hA8N1SY8atRoJodw24LL6RWysy56Bxs6eCAtT9JQEAD0d3qkvNJOl8ynxr3ecJ4tI2YuJ6JVyBsjWCZxwLCN8bzQm7EQQghRMOqMhRBCiIKRTF0QC1+5LS1/5ZsPp+Vz21wavuyNr0vL/Rd43uH+/jggfOsFnsd0moJYDJNsdbx3b1rmYOcn5UamZfaaniSZbGzMvSGnptzjEgC6SBEaI49KDgIwQ4Hqu7pc/q7VYsk7Dsqe5+cqxDJpQh7lKuWW+B1mZ5cvP17xMufg3tXvHsx7znBp+tyzz4qOxV7L1Tm337ERl4NHKVDG3KxL0Z2Zdp1Pjto9Pd6Wctnl81GaPRHmYpkb7X68yQm3Xw7OM03PmO4uv8aFhVjKDzTM1ELPmAWy5dXypt4o6M1YCCGEKBh1xkIIIUTBSKZeI9hjGgDu/MZP0vKeVv8aLn7zG9Jy1xkuYfX1+UT7hUwQWs7DWSWpd3zcpaU4N3BzghDnHWYJuaWlRHVaF9nHpSoOWsJe2nnHre9DQRNyJOuN4ikpNjZ8l21rjR+brTTr4al7PIjG4XGXkPu3+XBMOwXayE4hYK/jBbKNSRryqUS5ut0WyqX8IafebtesOVBHZ7vbYqjE+3d2uGTOsnO55NffGtlyY3sHgEDSeJW80VtOw5abfX6d6nGLZsk3YzM728zuNLMfmdn9ZvY7yfoBM7vdzH6S/O9f6lhCiOKQLQuxfmlGpq4C+P0QwuUAngvgLWZ2OYC3A7gjhHARgDuSZSHE+kW2LMQ6ZUmZOoRwCMChpDxuZg8A2APgVQCuTqrdAuDLAP5oVVq5CXjotm9Eyyy0XPKK5/n6Dpez+iilGcvMnEIQAPopVuwMxZPloBnRuenkWQWHJ+7z/hyburWVZKZMnOxKpZXqeZlTIFarLmWb+XWVSvFvQ44HzDLZPAUayUublpXyszG4T8CxcTeKnHW6bCZbbiae9Eqeo0T3eWs5lmBbSR7e2+N2MjjhMnWgeNCjs37PHRv21IoAsPdMj1s9STMVpmfYlr1lLE1nxdvqPKVznPP9W9tcfi6VXGa2jDc2Dye103BUhWy5vb05W2bbYjmb7TLPluNY9CfPumh0jqz9bwROyYHLzM4D8EwAdwHYlRg3ABwGsGtFWyaEWDVky0KsL5rujM2sG8A/AvjdEEKU0T3Uf5I0/FFqZjea2d1mdvfk1FSjKkKINWQlbHlqsnEWMCHE6dFUZ2xmFdSN9yMhhE8lq4+Y2e5k+24Ag432DSHcHELYF0LY19XZ2aiKEGKNWClb7qQAD0KI5bPkmLHV/cg/AOCBEMKf06bPALgewJ8l/29dlRZuEvbPxOMcL7/0jLTc+jPPpS0+8sPThDjv7+RkrDB0UHKINhoPam31cSKOesVjsdkxXx53mZ3NRORJ4GkLPC4MAO00HaJEY1CdnR1oRJS0IjPOw1MoeGx3bo7HwnycaZ7GyGqZ3K78ssdjUFyPx6V5ffZYJx97Y7DRbDn7em455bw6zR4rb5yZ63DUqNZy/A7D28pUPne7/2B5yjkeNa9GdjWRURimpijXMI3nosVtoTZP48ch35aZaZr+WCP7b2/z47a1xjbaRbbcQjbfkfNSxbacHbPNt+U5Krv9NmvLfJ7YlnkqVbVhncbHLo5m5hlfBeA3ANxnZvcm6/4t6ob7cTO7AcBjAF6Xs78QYn0gWxZindKMN/XXkP+D8yUr2xwhxGohWxZi/aIIXGvEc3pjCejrDw+l5Zf+5N60XLrk2Wl5vupSDUfgms7kLWU5edu23rS8a5dL4bMs55IclCdFA7GcXaW2lGlqRzYg/OTEJNWjSD0kZ/M0LZbW2jKSN5+fg+5zpK6WUmO3B56WUW8/DxN4mSX3WNri643NhGVunjKy2adGFU1Tn26TX0Fetbz1rAC3ZiJdVUmRnav5ESbmG9tPP01ZHD4aTz8cHvMhqApNcxwvuzTcT+vbWkiyrcVTg7iV1Vpj2baNcp6HjLTMEnpkyzR9ke2PpzaVy7H98Seba8stp27LPM0pz5Y5Ytd6tmXFphZCCCEKRp2xEEIIUTCSqdeInU+N85bW7nokLd/2iTvTcmvl62n5gl0ejeflV5yflgcy0aTKfS5hdezb1/D8fXuekpang8s509PTjaoDyHo0No56k03uYKTncdD74WHKwUqSOSeayB4rKyn5PiRzkUzGctZUZk47y1bszclS+Pw8y3yUczUjxbMcxt7r7LEuVoFlKIeL7cqSZEtOEoIKy7EZr+XaHHnx0rHaKaHEE8N+P7Z3eaKIjgHPbQwAk3Q/Dk14+cCg21JXp9//F+x0+zmnKx4Ka6XcylW6t2vVxhH0ypnkDrxtdpbypI83tuUSydfZCFxtZJssG0e23NJYTs4+o9iW4/LGtmW9GQshhBAFo85YCCGEKBjJ1KtIJMf8/Gujbb9w4Q/S8gFKIvEEuWY+OuRB5D96t0vGHZkAGu0kr+AHB9IiSzg7SQ5uJ9Husr3ufQ0AlSuf6e0/+1Jvf1tPWo5ko4yqx57anDSip8dvNc6/PDbm0RizHowhJ6BBnpc2S07s2Vk/p7eZj8tt5GQYk+RJynL9yeeBWC0W05Zzonbkekln7q2FnIpcj7/byOufpFUAKFd8n1KZhnPm3P5GZjy3+LEhvzd7uuIAGqPzfm+NTrg0zcMug4d8JsaBJ13+veppu6NjPaXfj80ezH29jeXYrETPEnRe0he25dHR0bRczSR3GKcyS9h8LB5mYhvLyueb1Zb1ZiyEEEIUjDpjIYQQomAkU68ZsQZSvtjl4Kdc5h7QF0251DM/6nmLeUJ8KSPbsIQ0e9c3vTzqEtJXf3owLbNCd9+RWCYr3eNe3i/e456eO2/49bTMwQiyuUZZNmJ5iCUolpDYm/rYsThPc5wDtXFsao4t29sbS+5MXj7jzk5vF3/GHLQgLxiBWFuiHMY50nResIaT8nbT/cSSdTQcQuVFwj5H90cn5fft6HA77ZpyWywv0L04Fcemnp7x+7mVZjDs6fby/mmXrw8Pumfz1+6Lg348SLMsrjjHZ2acvc2vvaeDgn6EfFuemsqzZZe82ZaPDsW2HM1moPI8SeFso2zLltGP56keb8mzZW7verbl9dsyIYQQYougzlgIIYQoGMnUK0wsqeQnaiuVGnsRVnaQR2SPp13j42ZlmzmSfVp+4Zd9w7R7YD6fT1+lGKw/vhfM+Lfcy/sTP3ggLV/xzj9Jy099xx+k5a5MXltOlViiGNbHhoaojstntVpzLowcD5tl+fb2Dqrjn2n2M+JzsmdpJScYAXuvZo8Vp5mMYwuL1eNUnV35ll/I6NRR2sNSYzmaJc3FjsVDGtXg+4zOu+Qc6FhtFAykkgmOcTYtliiFIqdNrWz3+79WpRSEM+yzDOx/fCQtP/TTJ9PyZWe7BHzVhf686d/mMyaAOFUi29YQ2fLOHS5/s/SfHS6Yp5jd7B3N8eij9Kt0vqy03BmljF3alqenN4Yt681YCCGEKBh1xkIIIUTBqDMWQgghCkZjxisAj0O0t7c3XJ+Fo9DwlILsVCE6S1rKRpHhfeIA7TQWxqtbvY3hqc+NjtWza29arvztx9Ly4Vk/54XR2Eo8NrSNxp14PDcaQ+JxuZxED/VlHhtub1ivXPFbuEQXyYHtAaC313PIcls4oPz4+ERa5ilT2WlR8bJyGK8VzUTX4mlKvP6kffkezBkn7qB7brHwTJWKj4GWyHw7an6sqZz9QyZxQSvlJ46mGtH+NPwaJaMYPB4nNxg57mOlNbpnp3f51ESeWjSZmWbV2+sJLTo78mzZ28XPnva2ODd5dzdNh6LnQoXsl8fejb6HucxYbitNewpgW/Zn1MRp2HLR+cj1ZiyEEEIUjDpjIYQQomAkU68IjacdRcHOy7EE29rqy+xSz1IJy7wsAU1OxlL2/LxLLdl8nelxSb9rmXU5yr739ajeg3d7BK5Abe7tdMluYMCnXJ155q5o/54el7b4s+AIPCwajo35dIz+/gEwLBnGMrXftlOUtIKnI2XlKJawZmb88+ZpD7FKxXKhpOj1RiRB50jTC43VVADx1KZ42iAarudpetk822zbU9Meaau73ffppKh1/A5UnYvjsPL8AAAgAElEQVSlZZ6qNDHj9/DYjN+/+4/5PkeG/XyTY5kc3pS3+Izd/Wn5WWf7dKQd293mztodJ5rYts1tmSOTxbnB2ZY96Utfv58PAFoocQtH4OPPcpLsd4ai9y3U4mfafNU/i9kcW2bie2X92rLejIUQQoiCUWcshBBCFIxk6tOE8+WynJWXX5Nl6fqyR45ZID0tltM4UYJLNSzZAnHe0YXhQS8f2J+Wp7/zw7R85wGXk9ra49ys3d0up11zvkvQL/jDN3urtnkCiWwELm7bgQOeW3l21uW0iQmXoFjKr2XkKL4ulqBYcubyNEmEWf9ZPvZ6lqpEPnnfWy03OUSUWiLeGAXKI5maNnCkrXby4G+txJ7CZdpW4yQI1dCwPDnv0urEfCbvL0nNx6bIO5gk68PHvM7wUU8sw/IvAFxwic+M+LUXXJ6WLz3vLKrl5+/uYik935Y5hzHbMg8r1TLDZXOzbMsus+fa8kws3zMLm9SWl3wzNrN2M/u2mX3fzO43s/+QrD/fzO4ys4fN7GNm1rrUsYQQxSJ7FmJ90oxMPQvgmhDC0wE8A8C1ZvZcAO8G8BchhAsBHAdww+o1UwixQsiehViHLClTh7oOcGIGdSX5CwCuAfBryfpbANwE4H0r38T1A0vTXV2dDdczLNuwFA3ky6YtLS7bcuCK2oQHfS896gkcAGD8a57s4a6jPtmdlDH09vlE+csuuzQtX9EbS1OXkpxV+bmfT8vzJL9Njbk0dvCg50mut3mWyi5nsaclX2OelzUQe4lHXrI5HuNiadajPecpjdmEDGxCNVqYz8lNPD3n90k2H3FXu0vLA91uy5y4IfKmbuEc4pkG51xAGwUDmSLZtUoewO2Z3OQ/GnWptquNhnDonBdd4PLztmf9TFo+5wz3fgaA55yzPS0P9LiEXSWP7WnyYD508FC0P9sv2/XoKNlyiZ9xZMuZj4Q9oBF9j7WG6yMWGWHYTDTlwGVmJTO7F8AggNsB/BTASAjhxNPySQB7VqeJQoiVRPYsxPqjqc44hFALITwDwF4AVwK4dIldUszsRjO728zu5nlkQohiOF17ZluempxcegchRNOckjd1CGHEzO4E8DwAfWZWTn5N7wVwIGefmwHcDAB7zjprQ7u+xQEB/HcMT1xnr+m2NvdGnMl4B7Ls2tPj8ZztW/87Ld9/+/fS8hGKtTo4Gwe0OKPf4y7/4lMvTMs7LzgjLfe/4tV+DpLPpzO3wIERl6BG7/shGhHH3I6/0ioFGmBvaI4BvZk8IDcyp2rPbMtn7dmzrC8xLz8wr8/eJlXSoOcoV/DMPMvUXmeE4qn3tcWzGUqkW5dz4qOzLbNnMXsD19tJtkyzEWAuMx+fdJm3lZTpwYn4R82xUb+WDgrOsbPH2/LSp52Tlvs7fDZEOcQx60ePHU7LBx4ZQ2NO3ZbnmrHl5Zr4ZtWiF6EZb+qdZtaXlDsAvAzAAwDuBPDapNr1AG5drUYKIVYG2bMQ65Nm3ox3A7jFzEqod94fDyF8zsx+BOAfzOxPANwD4AOr2E4hxMogexZiHdKMN/UPADyzwfr9qI83bVpaWmLhIC/WclubS0XtHS5ncQq22Gs4cyxOoTg0nJYv3evekHumfNpn6WefHR2r90yfxF/Z/ZS0PEGeikcOHKVz+77ZdIysD1XJA5Lj77J8d3JKssaT+CVNrw/Wiz3z7ILZauO0oeWMCzQvsrTcSrcWy9S98Pu0Uo69luP73O2Eg9hw2kC262ya0yi2NeuzwW1joM89nUeO+/rOzJBTb6+fc2+vt/lsSkE4efjxtDxDH0qtFh/LcmyZpXgun5YtLxJXpRlyHaiXedyNiMJhCiGEEAWjzlgIIYQoGHXGQgghRMEoUUQGHifmfJ5AfqQtTnawQONJPAaTHTPl/KgzNFWi+sJfSMs8ntNBUXuyIy0TFM2rNuRjwzwux1MTODcyJ6wA4vHkUqnx7cHHzUYW4/G3EBqPBQrBt80MRcriyFo9HfF0JN6WV+bpT3xnbuuJbbmLjl0q+U3P9l8lu8qLBlff3/fhfMY8zjo6Q+1is8hE4NrR4XbeU6Vc2xQBa5LGcjkyWGtbHE68JWf6JdOsLS/k2bI1LCI0Oc6rt0FHn4UQQghRMOqMhRBCiIKRTH0SNE0hR5ZejDFKotDamp+FjuXgWo60PTfnchTLZ3EErHjaEZcZznXKAeCzOYS5zVzOmw6VnRqVnV4hRCNYEq2ROjqfIz8DmUhdVI6GVrhMEm65HNtyrcayMQ3n0PrRMU/O0kYScCkz5ao1+LYoahVJ208MewSs/cMuOR84NB4dq7fP7bREtryvz6dctXZ6YgtO4FCrxrZcokQTbTQc1awtV3NsuRkFeovMRlpR9GYshBBCFIw6YyGEEKJgJFNn4EhZnIMXiHMYVyokW7E3NUcWmp1rWAcAquQpGeVNpXpmFJmrlu+ZnCfZcd5glrk5gUVWmiqTlzd7c0eB4qMye3kr0pZojjjXiN8zUyTtljLDMbM19u5lydrrtJJn8zxFoJsfOh4diyNtLZDNVTr8YGPTfp+X5yhqVns8/DRNCSmiISQa5trb6+frJs/mSuZ16NId/ow5c1s71WOPby93dOTbcmtO0otmbZk/WMnOq4/ejIUQQoiCUWcshBBCFIxkasSSMyd9yNJNuUrbKAlEX6/nE25v9/05UMDUVJy3lD2lWULKJpRodCwO4J7dhz2lOWgH52Nlmat8UgD9xsdl+Zk9vrOBAoRoBr4HW8nTuXPB79npjHfw0SmXUbe1eb1+ko27O/0+jwPaxPdpZ5fnEJ+jvMNn7PQcwv09LhnzLIGpKR9iAoAqycPt5HXNSSM6KJ8yBzPZ2RM/b1ooQ8I82TIW/Pxsy3lDXFnybHl+EVvOTeKQe5ZTJzszJD33Fhzu0puxEEIIUTDqjIUQQoiC2fQyNXsUsyLCQTA4uAVL1lm6ukimZjmKDtzX10d1XILav/+R6FjsHZ0X3IOlPD5fW1t+G0PwNk5NecxrDu5RqVD+5Xb/HID4M2JPSw4uEHttbj05SSwfFiej3MSl/PtpG8nRZ23z+7avxz2VeZiodRFbbut0O6kGP3+F2tIz0J+WOTf5T/fvj47FcnSNZF+OWV0iu+ZjtWViw7PNszfzzExjW+ZnDD/TsjRjy6FJW15J+XorytF56M1YCCGEKBh1xkIIIUTBqDMWQgghCmbTjRnzGDEAbN8+kLutETxtKJsDtEYRfaYoB/HIyGjuPifITlniKUU0zIQFOgfvstjYCk9h4jFnjhg2Q/mQObJWNgfqLNWbmfGpFdN0vRrnEcuF/SzKNE7aTiGp2lpjW3rK3u1puavd72EeZ+VxS562k7XLSgtF8CKbHxkeSsutFd+HZ/1wAggAaAH7eXB+YJpOROWFRSJbcZ5zTnTRmZMcIrLlTGKamRxbZl+SsNypiQrNtWLozVgIIYQoGHXGQgghRMFsOpk6G9CFpWmeBsASLnPkyBE+WrStm4LLs+w1OenRtY4dG07L09McqSc+FkexaoY4gk5W8napigPg82+tSiVHPs8koGCZnKdc5UUGE2K5NDtVhqNYdXX6NJ5mbLkl82Do2+YRuFooctXY+ERaPjp0LC1PUtStqdk4MhjL4V2UQ9jA0bHo/JEtxVfPsnN3t9tyCZyb2W2Z965mIpbVcmyZ1/P+iyrO1rAoVpCm34zNrGRm95jZ55Ll883sLjN72Mw+Zmb5k/qEEOsG2bIQ649Tkal/B8ADtPxuAH8RQrgQwHEAN6xkw4QQq4ZsWYh1RlMytZntBfBKAP8RwO9Z3RXyGgC/llS5BcBNAN63Cm1cEg6Qzt7EQBytpnvcZauOux9seKzOI4N03PhY9x50L8QByiN66Suem5YP1Bp7MLP8m22zGXtjNv59FK+P60SB3+c5AQXlUO1m+dqFJvaSBmJPS046oUhbm4P1aMusIJfKjT2YASCQDfX0uMzcRfc2S6h8L7dkbDnQSQMliih1bEvLjwz+NC3PkTfy4ERsM+3k9X3+gEf2Yrsu8zOKPKZbTtJ882yZkmFQJEC+YL5eAJicdGl9mtrf9GSIU9SjV/IJsRWl8GbfjP8SwNsAnBjs2A5gJIRwYrDkSQB7Gu1oZjea2d1mdvdkJtuJEGLNWRFbnpqcbFRFCHGaLNkZm9l1AAZDCN89nROEEG4OIewLIezr6mzsaCGEWH1W0pY7I0dBIcRyaUamvgrAL5nZKwC0A9gG4L0A+sysnPyi3gvgwOo182RY5j2z36WlUojl4IWvfD4tHxlyr8f7JllCdoFlcNBl6qy0VSNvxTYKSP/dD92Wlq/53Rt9hxYPUjCdUQWiiffkHZ3NlXoCvt6T85a6qMNezxzQg3OgcsCS7PnYM1zBPTYd68aWWYbk4Bq7dp3pdTJBeiqU97hCOcDnZj0JQo3u//FJv8+zNjMy6l7TNfPzPzLhNn50wW1m9w5/xvS1xTZzbHQ8LVeDn4dl4tBBucWp7dl84hwMhZPJRDnX2ZbJficyasX4hF9jyAk0spiF59VbLTl6qz9tlnwzDiG8I4SwN4RwHoBfAfClEMLrAdwJ4LVJtesB3LpqrRRCLBvZshDrl+UE/fgj1B1AHkZ93OkDK9MkIcQaI1sWomBOKehHCOHLAL6clPcDuHLlm9QcNuvyzH1/8+m0fHCu1qg6AGCg3/OT9o8dT8ujlOvzgpJLQ+fs9voAsPPFfrnshVwlj212DeXYst3d7v3ZaDk9FgUQGB31mNcTJDllJ/dHOVDhEhjrPuxVzuXYY/pkr2+xOVlPtswzBTg4zUmjJLSCtx06dCgtc9zoiWkfiurv643P2eb+Kw8d8uAe9z3uzwUEnqVBgUGmY1/fOfPx89EK5TzvJy/vBcohXPNyFrZlDgDCsP2yvfLsjXo9f5ZxzJG8AB6LeTCvhXfzVvSgZhQOUwghhCgYdcZCCCFEwWzY2NTVGZepv/vok2l5+/btUb2ODo9hy6kGz3/Lb6blMEeT5WnSP8eyBgCj5TaWikiyZvmaY0ZnvTnZU7uFgwNQ0AO+Fpbv8jyuAaC722UyvnaWtsbH3PszGyhAHtRiranR0MzBgy45DwwMRPU6aGpkIJup0mwIDhTCHsiz8/HwywjJ2V00M2Jnr9vMDMVz7qnQ0E7mqTk37yc9s9vPeUaXez13tJKX9cRYWs4G3eH0ijx9rL3d28WxsEdG/VjZ50JkyxxZpemA1MvaRZwiejMWQgghCkadsRBCCFEw6oyFEEKIgtmwY8aBxnZf+oZXpeWZL94V1XucxmZ53JTHQNoHzkjLFRrn5UDtANBGEa040lU7jTmN0XgsT0fK5gMeH/exnrY2H1vasWNHWubxYw4Unx3n5ehaHDR/bt6nbHEEMJ4ylc2NLMSawNNryBirdM8uZDJFhEAJTmbcNudoPLhCttRO9jNDUboAoEL21EblKygBzOiY22h53qcNTSOeDoia2/zciK9u6dqVljmyVjv5nszMxLbcRX4evZQMY46mX3KkrePH3ZbnM7nJ4yQUjUd6mx3/1Tjx6qM3YyGEEKJg1BkLIYQQBbNhZWrjqUI7PONbWyZBaCCp68I232fXmR6Qvnd6OC1PPXhPWh555LHoWF+/z6dQddBUgxIFe79ou8vEey7Z6ztnIm4tXPactHz06FBaHhtz2WnbNpfieZpUZ6efG4gj7VRpygZPbeCg9bWa1xGiEHJm0LGcaxltdJ6GmeZoes/Ajp1pubvHI20Njfkw0RPDngAGAH74uC+fucP3qZC0fcY2Wk/Ple72ePiqa4CmTS24hHzwiD9XBgb8WB2U/7i1Ld+WZ0martIw19iEn4OnOdUyMrXREF3e1CRNWVo/6M1YCCGEKBh1xkIIIUTBbFiZmmGv45AJrl6dJq/LKZd3Dv3136Tl20bdO7JE+2cTMkzOuQw0P+Vuk+zpvH/c5eDyEx50vpzJjdzx+W+n5Rc9/5K0PPG0q/y4FEGIWSxKFiea4Og+Ezm5TYUogig/Lt2PnByhNWPLC5z3mzyKS2QngzTkc2DKbeHwRMaWJ/258OCIR/0CeWyfvdcjgLECPDkZD/O0d3g791zosyFKs5QzvcXrBEo60dERi8O8xBL0BA0znY4tR/mMs/q/WBfozVgIIYQoGHXGQgghRMFsCpm6ZcZlm8Favmxz75hLPQvHfZ9Jkq8rJCH1t8THYtE4kKfjDMlR7AJarboUVs14TQ7s2p2WP3fn/Wn5Wto/PPvqtMyB4jn/KwAcP+5emyytT0x4MALlKRbriYUcebVUapzbGIgTQtTIu3iK7vPhUS8fmnAbPXjU7R0Ajh93m58c9/LosA8/PbLfg3NwAKAuSlgBAJddcXFa3tHmAYRqFX+WcNKJjg7fv2Kx5D087ENbPOTE0jRIrmfFOSs/xxJ24yTGpyNYywN7ddCbsRBCCFEw6oyFEEKIgtkUMnVt9FhafnwmjkHLki7Hpq4dc6/LZ5/tATlan/bUtNzzrBdEx+LAG021i4JrzH7/69G273zx+77Q1+/nIA/sthd6ABGWwscoZi4AzJEENkWSeza2thDrHQ7SEzLx3Etky4GGXUaPuy3Pz7id9JOeOrDbbQkAjvR7DOrhKQ/IcWjIy6MkZU+TTDw77lI4ADz80KNp+Udn+/5PP9+DEbWT5GzBy+OZY1XJZsfpnJEth4bFkz2rowAqVMapkzf4J8l65dCbsRBCCFEw6oyFEEKIgtkUMnW15PLxzNDRaNssBQTYRmnQnvkvX5OWbeBMNGJ8PPbA5FSF7OmZJ1+XSl6n81kvira9vNX3+f793uZ73eEbL/jht9Ly8J5L0zJ7SQNx3Gl5TYuNQAvPGiB5dZ5mIBwZPBLtw6lGJynoB8djb6EY0iWSuatzcdrDMykd6jnd7t18+U6Xs79/2O3s4GFKezhNsycAbOv1GPITC37cB4+7LVrNr6tn3j22W2bjZ8zMtNsyz4zg67Kc4NJZb2oONJQXj5ppWmaWNr0qNNUZm9mjAMYB1ABUQwj7zGwAwMcAnAfgUQCvCyEczzuGEGJ9IHsWYv1xKjL1i0MIzwgh7EuW3w7gjhDCRQDuSJaFEBsD2bMQ64jljBm/CsAtSfkWAK9efnOEEAUhexaiQJodMw4A/reZBQB/G0K4GcCuEMKJCOuHAexajQY2Q8/eC9LydW97U7Rt9OtfSsszlz0zLVt3P5YmHl2ZmZmmcn7e1RNw1KxKJug9KAJX6UGPoMXjzPOHDqflsR6vnx3Lzh8FEqIh68qeaTYTerq603J3VzwdaWTUc33P0TjxAh0gL7JX1kYWyH+kuuDjuSUy5l1lrzPe7e8t5UocTe/ss3zM+IUXeG7lgYHtaXlyzBX/Jx/zsfDxaR/7zjaTx3w5TTtfIuW1QHspfhC12PJCbYXchaXrZ0+nYealabYzfn4I4YCZnQHgdjN7kDeGEEJi2CdhZjcCuBEAent7G1URQqwtp2XPsmUhVo+mZOoQwoHk/yCATwO4EsARM9sNAMn/wZx9bw4h7Ash7MvGdBVCrD2na89sy52Zt1YhxPJY8s3YzLoAtIQQxpPyywG8C8BnAFwP4M+S/7euZkMXY4GmMFh/PE2p95W/4gssc1Gih9PL70uRgnJ2n6ZpCpRaGADQSfvUKFnq8LBHExuk6U8jZ3jbJUuL02W92DPbXI1kZp7Os5C5zds7XcIepzzl47M+bYltiWktx+8dZVrmaUN5kvcYJZOYmY2TO8xVfcirQqdZmPFIedPjPhQ1PelTprLPDv5cSi05EbRydN7s+mamMy3KKe4k+Xl5NCNT7wLw6eRmKAP4aAjhC2b2HQAfN7MbADwG4HWr10whxAohexZiHbJkZxxC2A/g6Q3WHwPwktVolBBidZA9C7E+2VARuOIIM15mObhcLoHh3KF9lJBhepo9ozMacgJL2csl6/DS/sW70zLncOXg8Ec63YNakbXERidWPRuLmmMTLgdbKbblSqtH4Grv8uQuw/MuTU/Ouy23cQSqjHzNcjB7LbNkzt7InW3+qOzv64uONbB9R1qmpmCKooQNHnEPak6AwVJ0vV1ebiq5w2k4TJ+WfJ3jzW05nt3i1FFsaiGEEKJg1BkLIYQQBbOhZOreHpemere5Z+XQsAden5iIJ9FzEI3WVg/i3tHR0bDMZPMBz1JO4Wq1mq0OACiX/XxtbR5cvrsSazhHZ12qYsnsWR4/AMfPfxrtIQ9qsbFhC+jvd6m3s9vtemjIZxNMTMTBbTq6+AguYbe1sy37sFQPJXOpWCxTV+d9CIoDiFRrbmf9ZX9eXNbphlluj6d17djh2zjuxvFh96CemYkTVeTRkusq3bDYNM3sc/LE8px69LyylsZSevZYUrCXRm/GQgghRMGoMxZCCCEKZkPJ1HOf/Vhavu2Ayz4//zKfqbFwzhXRPqOjLmGzhMWSNZeZbDzpk+JLLwHX30E5TAHgm2PuAT4y4tt29LlkZpKmxSZlIcejeOf2gbQ8dCyWlqcoWAZ7Vu9scztrp6EhdlRuOclr2evN1xoHIJmt+vk7yBQ7+jzmNADMzrnNHj7igcvGjnmZbTmaE5InS2crcttPrfqiNLsPe1C35EjTy23LVkdvxkIIIUTBqDMWQgghCmZDydQTLa6VjI+7ZPWdO+9Ly899VTwhf2LX+Wl5asa9oaenPYgGy8SsGnV2xl6T7B1dIU9NlnDYS7Qy5cf9xvs/GR1rZNyDE8wOD/mGVysKodj8jI973GaegdBDMybO3BVncRwjm+c0ovNzPmQ1NjaKRnRlElvw0FSJzp8nmVvJpfDjGS/v9uDPkrFR96DmQD1lOu5iqQ1PVd5dXlT9U+AUJfPlshVlbr0ZCyGEEAWjzlgIIYQoGHXGQgghRMFsqDFju+ratPycI3+flu+laUKf/8d/jvZ56Xk+ntx91ZV0MB+VmD/Tx5U5gcTcXByBi7fVaj6GxBG8Jj/70bT8wx8cSMuPTcdJJ44d80hDL37ZM3wDRfoRYiswRnnGW1t5mlJ7VG8bjSd3d3sEPp6aNBP5hbi9zs/H9jdHOZArCz5+3Em2PDfnx5qY9XHiwck4mlZl2reVg09zai0vPfLZ9NSiZe4j1j96MxZCCCEKRp2xEEIIUTAbS6Zu8d8OpVe+Ki3v/cBH0vLDmYDsn3vQl9sf/YIfi+pc3ulTls653KdT2J6zc9sSDjyRlh//kecqvX+qsUxWHTke7f+ia/f5sS5+ZsN2CbFZ4fu8RlOABimC1bZt8ZBNa7vL1q2tbrOc3GHBKDFMp8va7YsY1gJF3Zqm8sNDPpXqpwd9ytLRIZqKCOBpZ/m0qV1dLK3786pMGSTK9AqUTQxxWgkdlljf7HFFsejNWAghhCgYdcZCCCFEwWwomZqxDvem3PXmG9LyGV/+XFRv8AGXkO8ZPEoH8OIIyWH3jrhnZKX18abaMjfrnpojlJjiaaSNbX/zb0T7mLymhTgJzpU7MhpH0wojvlwlTXaeEjpUKNdwC0XMQyl+1E1VXRqfmvP9Ryd9aOmJQy5HHx/z50JrOX6H4YQS8zUvc26KUksJzdCM17Qk582J3oyFEEKIglFnLIQQQhTMhpWpGSMJyl7y6mjbrhe7HHVtlYJ4kBxW++Jn0/L+H7uU/eNMoA4jgSiQoPRU8sZ+xnVXef3zPbeylZqTqYTYarDsyjItS9YAsBBvTIsVeqWozricXJ30ZBS1jKsxe1CX6Fh9tH7bdkomscNzGGdl6jZaLpHXdIk8paMcwPl5InKRNL35aerN2Mz6zOyTZvagmT1gZs8zswEzu93MfpL871/txgohlodsWYj1SbMy9XsBfCGEcCmApwN4AMDbAdwRQrgIwB3JshBifSNbFmIdsqRMbWa9AF4I4A0AEEKYAzBnZq8CcHVS7RYAXwbwR6vRyOVg7MXY2lgqLr/Scwhf/Epff/FqNUqIAtgItswSbktGnGXv5JAj3JZZ2q7kv2twtTxp3FhmXkQn5noWrc/fR4gszbwZnw/gKIAPmdk9ZvZ+M+sCsCuEcCipcxjArtwjCCHWA7JlIdYpzXTGZQDPAvC+EMIzAUwiI2OF+s/JhtHYzOxGM7vbzO6enJpqVEUIsTasmC1PTU6uemOF2Eo00xk/CeDJEMJdyfInUTfoI2a2GwCS/4ONdg4h3BxC2BdC2NfV2bkSbRZCnB4rZsudXV2NqqwoZvl/LTl/pRZr6q9cavxXKbekf7y+pYX+LP4zIP2LPq+cPyEasWRnHEI4DOAJM7skWfUSAD8C8BkA1yfrrgdw66q0UAixIsiWhVi/NDvP+LcBfMTMWgHsB/CvUO/IP25mNwB4DMDrFtlfCLE+kC0LsQ5pqjMOIdwLYF+DTS9Z2eYIIVYT2bIQ65NNEYFLCCFOl1OegaQpS2IVUGxqIYQQomDUGQshhBAFo85YCCGEKBh1xkIIIUTBqDMWQgghCsayOUNX9WRmR1EPwTe0Ziddf+zA1r3+rXztwKld/7khhJ2r2ZjlkNjyY9ja3+lWvnZga1//itvymnbGAGBmd4cQGs1z3BJs5evfytcObM7r34zX1Cxb+dqBrX39q3HtkqmFEEKIglFnLIQQQhRMEZ3xzQWccz2xla9/K187sDmvfzNeU7Ns5WsHtvb1r/i1r/mYsRBCCCFiJFMLIYQQBbOmnbGZXWtmD5nZw2b29rU891pjZmeb2Z1m9iMzu9/MfidZP2Bmt5vZT5L//UW3dbUws5KZ3WNmn0uWzzezu5Lv/2NJGr9NiZn1mdknzexBM3vAzJ63mb77rWTLgOwZkD2vtj2vWWdsZiUAfw3gFwBcDuBXzezytTp/AVQB/H4I4XIAzwXwluR63w7gjhDCRQDuSJY3K78D4AFafjeAvwghXAjgOIAbCmnV2vBeAF8IIVwK4Omofw6b4rvfgrYMyJ4B2fPq2nMIYU3+ADwPwD/R8jsAvGOtzl/0HxAkR2MAAAJHSURBVIBbAbwMwEMAdifrdgN4qOi2rdL17k1u0GsAfA71xHNDAMqN7ofN9AegF8AjSHwyaP2m+O63ui0n1yx7lj2v6He/ljL1HgBP0PKTybpNj5mdB+CZAO4CsCuEcCjZdBjAroKatdr8JYC3AVhIlrcDGAkhVJPlzfz9nw/gKIAPJbLe+82sC5vnu9+ytgzInpNl2fMKf/dy4FplzKwbwD8C+N0QwhhvC/WfVJvOnd3MrgMwGEL4btFtKYgygGcBeF8I4Zmoh4CNJKzN+t1vdmTPW5I1see17IwPADiblvcm6zYtZlZB3XA/EkL4VLL6iJntTrbvBjBYVPtWkasA/JKZPQrgH1CXtt4LoM/Mykmdzfz9PwngyRDCXcnyJ1E35s3y3W85WwZkz7Ln1bXnteyMvwPgosQDrxXArwD4zBqef00xMwPwAQAPhBD+nDZ9BsD1Sfl61MeeNhUhhHeEEPaGEM5D/Xv+Ugjh9QDuBPDapNqmvHYACCEcBvCEmV2SrHoJgB9h83z3W8qWAdmz7Hn17Xmtsza9AvWxhxKAD4YQ/uOanXyNMbPnA/gqgPvg4yz/FvVxpo8DOAf1rDevCyEMF9LINcDMrgbwByGE68zsKaj/sh4AcA+AXw8hzBbZvtXCzJ4B4P0AWgHsB/CvUP/xuym++61ky4Ds+QSy59WzZ0XgEkIIIQpGDlxCCCFEwagzFkIIIQpGnbEQQghRMOqMhRBCiIJRZyyEEEIUjDpjIYQQomDUGQshhBAFo85YCCGEKJj/H4BByRHL85EzAAAAAElFTkSuQmCC\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": "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\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": "markdown",
   "metadata": {},
   "source": [
    "# View prediction on true ($\\hat{y}$ on $y$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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 = 'Blues', alpha = 0.5)\n",
    "    plt.pause(0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHIJJREFUeJztnWuMXVd1x/9rnp4ZPybj61fsxI/aJBhCnDANQSAUEoJSighSUcRDlVVZ8hdaBZUKklaqQGol+MLjQ4VkNRR/oE3Cq4kiBKQmtEItIRMSguPEsRM8yTi2x9cevz3v1Q/3+O7HzDlz7p1zzr139v8nXc0+Z+9zzjrnzrp7rbPXXltUFYSQsGhrtACEkOKh4hMSIFR8QgKEik9IgFDxCQkQKj4hAULFJyRAFqX4InKfiBwWkaMi8lBWQhFC8kXqDeARkXYArwG4F8AIgOcAfEZVD2UnHiEkDzoWcewdAI6q6hsAICKPArgfQKzil0ol3bx58yIuSQhJ4ujRo1Pnz5/vWqjdYhR/I4C3rO0RAO9LOmDz5s34zW9+s4hLEkKSuOWWW8bTtMv95Z6I7BWRIREZKpfLeV+OEJKCxSj+cQA3WNubon0OqrpPVQdVdbBUKi3icoSQrFiM4j8HYIeIbBWRLgCfBvBkNmIRQvKkbh9fVadF5K8B/BxAO4DvqurLmUlGCMmNxbzcg6r+FMBPM5KFEFIQjNwjJECo+IQECBWfkACh4hMSIFR8QgKEik9IgFDxCQmQRY3jk4wpcokDKfBapOlgj09IgFDxCQkQmvrNhG1+a8x+kg9p3awl8l2wxyckQKj4hAQITf1mZYmYlIsiY/M7qZnGuVm10ELuGXt8QgKEik9IgFDxCQkQ+vikeUnrdyf51jF1c06n8XWp3fXElwj1nDA/2OMTEiBUfEIChKY+aV4s83jWWuPRN8XbxNjO4lVqXTZ23cZ+PE1g3tuwxyckQKj4hAQIFZ+QAKGPT+bSJENPGlOujTrieWu4WOrDmuSZXmPBHl9EvisioyJy0No3ICJPi8iR6O91+YpJCMmSNKb+9wDc5+17CMABVd0B4EC0TQhpERZUfFX9HwBnvd33A9gflfcD+GTGchELqeGTK5rwyQH7vtrEfOq+/9Tyx5+10OedI/W+3Funqiei8kkA6zKShxBSAIt+q6+qib/5IrJXRIZEZKhcLi/2coSQDKhX8U+JyAYAiP6OxjVU1X2qOqiqg6VSqc7LhUdDzclmsWUdOcyGiPtJfQpSpV7FfxLA7qi8G8AT2YhDCCmCNMN5/wHg/wDcJCIjIrIHwNcA3CsiRwB8JNomhLQICwbwqOpnYqruyVgWQkhBMHKvxUlKKOHQ4k5uvfPqYs+XcMK0+TQWatvMMFafkACh4hMSIDT1m5S6g+HqsT1T2q9JMjWvyZs26V5YsMcnJECo+IQECBWfkAChj7+UycKP1dgNFOrZpxxjm5tWX2LrYk5R011l8qqgAUk62OMTEiBUfEIChKZ+K1LkUJSTVG5uUgpTl3Bc3iQkvpOU7VKff4nAHp+QAKHiExIgNPWzoBWiwHJYBcpJf63uQ2izWzfSVK4ju3YIsMcnJECo+IQECBWfkAChj18vahfrdfLjPcu6fc6sndWE+5yZNeUpewNAd4fpU9oWSIiZKWkvlfTCIgCHnz0+IQFCxSckQMIx9XM15dJnabNHvTKxgHM2S90hO7dufGrGlCddU7+91wjWJXUO7RVpfufoIjUj7PEJCRAqPiEBQsUnJECWro+v/qbZIbr4cFJN2LKZ9eVwkkZ4Ya5OLsh0gknaWXF1+5zmwDk+vuXXD1+44tTtXLbCbCzd/7KWJc0SWjeIyDMickhEXhaRB6P9AyLytIgcif5el7+4hJAsSGPqTwP4oqruBHAngM+LyE4ADwE4oKo7AByItgkhLUCatfNOADgRlS+KyCsANgK4H8BdUbP9AH4F4Mu5SJkSe4aYb5bam+31Dt3YUWzWBaZn/SE7s+0FtDmmf3enn9jCyg+XKKN1n55tP8f0z5BZ76GOjU9Wy88fOevUbV7VWy33dLabihqefVMG0zX5MF1aanq5JyJbANwG4FkA66IfBQA4CWBdppIRQnIjteKLyHIAPwLwBVW9YNdppYub97dQRPaKyJCIDJXL5UUJSwjJhlSKLyKdqCj991X1x9HuUyKyIarfAGB0vmNVdZ+qDqrqYKlUykJmQsgiWdDHFxEB8AiAV1T1G1bVkwB2A/ha9PeJXCRMYo6NEe8j+0Nni0WsC7R7P5+2K+z7xUnvF1yfNmdnso7Ek36zdmv8sd27sTNXJ6rl1cs7rcumfABzdhTn5c+ZuJfwfJryPUQK0oywfgDAXwL4g4i8GO37e1QU/nER2QNgGMAD+YhICMmaNG/1f434H7N7shWHEFIESzamKmkpJcc8Sxj2S8rVYNPmN7TcgKQkFH6Vakw59gxAW+rQPY+UiURsOWa8YUvbjent7XTqjpy+Wi1vHeirlrtqGEt1oxxTkoG9nTQUvFRgrD4hAULFJyRAWtrUTzLB/Do/73uVWl4yZ4CT2MKL6puenbXKVjtP9k5rGKHTN50t0z/xDXqSjCmThXS2GTn6lrmm/rlL5q3+xavT1fKqXvdfrt3xk7woxPiq7FmK9nwC7PEJCRAqPiEBQsUnJEBaz8fX2A23mVc1NWN2uAkvXNotxzJtMkw/Os+ZreddYGLa7PBz0Z+6PF4tvzRipkN0tLm/z+/b3F8tD/R1O3VWOnt0WRuSeDO+bz3/c5XDB53tzrNmyG7jtpudulPly9Xyr4+ZmXu3b1zltLu+f1m1PHekr5Vi4VoL9viEBAgVn5AAaT1T38E1Be1hLz/X3aVxM6R0cdKUT1rDTgDQ12V+CweWdTl15asm8cTwWWOWj5y46LSbnTH55vuWu6b4smXmkfd7ZvpF6/ynRy9Vy+KFBh4f6DHn6HFlVKut/QzaPfM9eahv/ijHCxfGnVbnrPHI68+86dS91LGyWh5+61y1PGHl4geAv9h1/XyXLZykiM20qya00oQd9viEBAgVn5AAoeITEiAt7uO72D7WxLQ7VHbsvMn7fqxsyictXxoApi0ftM3zrWet4bepySmz/4rr46PD+N0T4z1OVVe3CW29cmXKqZuxhhzt87d5w3ln7eM8Z9IO57UThNQbvmsf5c80tLenz7rPsXfV6mr57GkzNOkPszaLL9wschQFe3xCAoSKT0iAtLipHx+555tu/ZaJ3dlh5XmfO42vWpzx3IVZa3zMiYRr9x6jNcyls+45pqeNK3HZG0qcsYYBZ6aMOT/j3c3wcWM637ym16nbutokvajXvK+Hs959Lps4Xy3b93Lp8qTTzo6o7J6T0aRBpM3A4jVtpQl+7PEJCRAqPiEB0uKmvv+W2TIbO9zftPUrzGSQCcukHj3jrvLaYS335M9rmZoy5qwdgTc11ee0m54ykYFt7e1OnW3622Y/AExNWGbwuJnk4rsSMzPGvD8/Me3UxZqbNZivabFP4UdKztj3NmNM/WnPfUrK91coTeJlFAV7fEIChIpPSIBQ8QkJkNbz8WXeYgW18tl7P2nLrFl36/qMv3/DuuVOOzt5RYc3vLS829St7zXnGJtwh6iGx8ww3amz7juEc1aE2+Tly04drpghMCfErdsdsuuwhiNvXOXWxY6IJS4DVaefbck47s26G71k3fe4ueeZmdVOu6R1B0h+LNjji8gyEfmtiPxeRF4Wka9G+7eKyLMiclREHhORroXORQhpDtKY+hMA7lbVWwHsAnCfiNwJ4OsAvqmq2wGMAdiTn5iEkCxJs3aeArhmq3VGHwVwN4DPRvv3A/gKgO9kL2IN2G6AZ73aJnBPlzGVb9uw0mnX3Wl+C3XSTTwhb5tkE2OHjVl+2ovAO3vRHPfq8Dmnrvzm22Zj2nURtg8Y96HtPX9qZOofcNrd/95N1bK9Ei3gReslhJXZ5v2ciTP2KayN1ZvXOO3OvH7SyOuZ7BcOvW421l5XLfb0uPI2jalfbyYOu1mTjEymIdXLPRFpj1bKHQXwNIDXAZxT1WuDyCMANuYjIiEka1IpvqrOqOouAJsA3AHg5gUOqSIie0VkSESGyuVynWISQrKkpuE8VT0H4BkA7wfQLyLXXIVNAI7HHLNPVQdVdbBUKi1KWEJINizo44vIGgBTqnpORHoA3IvKi71nAHwKwKMAdgN4Ik9B06BnjM+JixecuuMjY9WynQffzzdve+sznvM7YSfzjMlfDwCXJszQ1vi4G1Lb1mPCezs63RzzZyxRtpdM7vzb33W9027dSpOkM3EGXtIQXsL6eLHnXNnvbHbLqWp50gvFHbESn2zsMRcr9buJSZplQl6hNMG7gDTj+BsA7BeRdlQshMdV9SkROQTgURH5JwAvAHgkRzkJIRmS5q3+SwBum2f/G6j4+4SQFqP1IvcmreWXf/eSU1W2osem4pbFhjd8lTAG45/Cztt/2TLnf3nEfWn59ttmCM9OrgEAvStMpN0KL+d+h+UyvHe1cRE2r3LNYzeXuy+/zFOaa106Q3Ypx6tk+XXOdp8VHjl6xR36nLSm640Pn66Wp/zkJpZgbfG3kmweJ95oTF29yfOTrt1CMFafkACh4hMSIC1n6mv5RLV8YnI6oaV3XNz+BHPezgcHABevmoQS//3GmWp5+Nhpp529hFZ3r2umL+8zUxq2r1/h1P2J9bZ+y/bt1fKyLjeZh303s7MJK93aqwLPidyL37Kj6ezTJbkLo5fcVOFtVm7vmS4zenHpqtvOXjG4o827z7Rvv5NkrOcNei3HxFw7Ke9JM3gH7PEJCRAqPiEBQsUnJEBazsdHh5nd1e6FnPmRdg4xvph6x9h+/bnL7qy7F46ZYboLx00k4Nblrm/6+jnj43d2ubPRBreaIbHtJTcJyNpu83Ws7jcRfkn++YyX5bItZjjP91tnUzqy9jmuTrlDcYe6jfxHR15z6uxkm2INU67s85b1tsSY9W40buJe0mzCOdiVaX33WpzwJojCqwf2+IQECBWfkABpOVNf1ppp/9s8m0/Pm4k5p0+7K9iuudHMDLQP892DN60cef875lRhorShWh6wyvbquADQ94eD1fKGtW7O/Y1Wjrz2Nn8oDvMyZ//8I3bJ+BNxrPyEc90dY9LbKwZPe8ObXdaQnZ9gY3raJBVpt9Yq6IDrLly0JjHNzLouU1eH5bZIjAvj1SVP+rEmZ2U1qJaQ/KWZYY9PSIBQ8QkJECo+IQHScj6+jazd5O5Ya4prticFpRqmvSGqly+Y8NsLk17e+3HrvYGVS3/q9Hmn2Q0bTIjqjVYCTcD1T/315vr7jf9vu93+8JU97DVnOM/6KW9PXoTAOsatnLbOeXXSDMuNeeG2Nv3eTMMuy6+3E5UM9rpDpCusNQg72/21EOPWSUjvn7uT8+z3GvHtEk9Sb7sm8//Z4xMSIFR8QgKkpU39ueg8pWjbzpdnVY5dcc3X02evmo0ZbwnqNjNkNXHS5Jtb4eXm32Vtd3nmqy3HZi9yb3bHzmrZmRXn2aW2eZ90n5o0BBYX4Qd36TCx1hlY0+aa82vXm/ts2+bm/rdl7LCG/Vb0xP/L+ZF7ToTlrMTUJEfupc3p553R3Wq2qXUZwB6fkACh4hMSIC1t6tfyotQ2PcenTPnEJTdX3Pi4Mf3VW+LqwguHTLvVZrLNnevc6Lzr+oxL4C8R5ViN17uLD9kuiNiuiffm3mk3x/Sc3xZNauY/R/stvzMy4OcDsdyAlV7kXhw9XlIR6Urb96RNwNecSOwGGnI77PEJCRAqPiEBQsUnJEBa2sevBdsvPnnJDNm9+rY7i2/qsonWu/jiK07dKSvIb6WTQCL+uqu85bXWrTbvA2S5OwyoMUNF/vmdJcD8g6zk9Haeep0zPc++sHeKmO4gKc9JNuQb+pa0bFhopO7xo6WyXxCRp6LtrSLyrIgcFZHHRKRroXMQQpqDWkz9BwHYXeDXAXxTVbcDGAOwJ0vBCCH5kcrUF5FNAP4cwD8D+FupZD64G8Bnoyb7AXwFwHdykNFFYzdcU9SzDO1ceuXLZsju8mVvyG7oxWr5lLhDT22dxj6ctCbpHClfcdptWWkm5my4badTJ31WLn1PRjspiG2J+mZphx2R51XakWp2oo/kvHQJdRnQb7k7snLAqy3OvCeGtD3+twB8CaimT1kN4JyqXotpHQGwcb4DCSHNx4KKLyIfBzCqqs/XcwER2SsiQyIyVC6XFz6AEJI7aXr8DwD4hIgcA/AoKib+twH0i8g1V2ETgOPzHayq+1R1UFUHS6XSfE0IIQWzoI+vqg8DeBgAROQuAH+nqp8TkR8A+BQqPwa7ATyRo5yGepZOhpvk4foVZpbZiekzTrvXOoxf7+fEd8JtLaf5zAU37Ld0y83VcnufO2TnpHlPSIBpV/kzzJwlrr26donz6xefLN6/ls7MztvOp8s+sGuZV9scU9/sdwFzZvQtwaG/xQTwfBmVF31HUfH5H8lGJEJI3tQUwKOqvwLwq6j8BoA7sheJEJI3LR65Fz/NyR/GabeyKawaPlwt91508+VdbyXROFl2c+7NWKZtX4+JV/rIO1Y77dr6TM69qVnXHHaSXHi2s2PC27J7dpmdRCMuym7uWdJjnz8pc+HY0RFzTMKl+q2EI3ObxR/oLnVmHeG7HBlE5IUWycdYfUIChIpPSIC0tKmfmIPCfzFdPlktjpwzk3TWLnffMq/sNm/yx9b0OnWjVsTfu955Q7W8ftt2p509iWZy2jOWrWBA34S3sd8s+7fiugR+oo+48MX0tmy6xORA/4B5PuVRd7LTtlU95so3bo09WxYWdpKZHid9LfGCiUtjtaiLwB6fkACh4hMSIFR8QgKkpX38pKWf20bfdOpef81EFNuz1rq8RBl2XV+3+3g+vM34tJ3vfpd14fjc+XOTaMRteBFjztLP8TPwNGGGontY9o5q203mGbzjpvhz1L08lR3JmNrRTsqQn3Ap57n5bznqvLcmhj0+IQFCxSckQFrb1PfQk8PV8vDRE06dbfbaE3Y62uONtfWd7uPpu3WX2UgOmbOlSqhLbYimbFcv8edPHxVX50BdSyTKSBgWbY45RjXDHp+QAKHiExIgVHxCAmRJ+fgXj41Wy1N1Zlnss3z3le/c6tRJar/eOaouOWyShpOSl4yu99pW0s/Up5CErTQVmOPvpzyjdwp/xmO6oN30w4UJVS3k77PHJyRAqPiEBMiSMvVXbFtfLZ99zc39OZnS9O+2w+J6V8Y3tKh7wC6l2Zu8qnJSbX3RbrlSw6VSW86JtxKzbHhCMo/6nIwFGjaZ6c8en5AAoeITEiBLytSXtSY5xsYT7uIdf/RSYMdR2mHOIZ3eOqAxJmWTWXExNIeUtcT3ZZKko46WhT+pBnw17PEJCRAqPiEBQsUnJECWlI9v0/HuW5ztHcNHq+Ujx8fM/k3ess0Da+NPGjMUVdO8tDr8udoG2+pxGLN3MuOG4nJxZzN431L/cGFrkkrxowUzLwKYATCtqoMiMgDgMQBbABwD8ICqjsWdgxDSPNRi6n9YVXep6mC0/RCAA6q6A8CBaJsQ0gIsxtS/H8BdUXk/KmvqfXmR8mSGtHu3ts2sYPuObWlP4m3HmHk1mZctbSrWl2yjKeeu5PE9NOWNzk8taWR+ISLPi8jeaN86Vb2W5uYkgHWZS0cIyYW0Pf4HVfW4iKwF8LSIvGpXqqpKzLzG6IdiLwDceOONixKWEJINqXp8VT0e/R0F8BNUlsc+JSIbACD6Oxpz7D5VHVTVwVKplI3UhJBFsaDii0ifiKy4VgbwUQAHATwJYHfUbDeAJ/ISsmGo92nQpZv3Cg16OAlk8pWJ96mnrslJY+qvA/CTaC33DgD/rqo/E5HnADwuInsADAN4ID8xCSFZsqDiq+obAG6dZ/8ZAPfkIRQhJF+WVuTeEoywWpjsl8aKOyrvpaSyWEK7BazspoCx+oQECBWfkACh4hMSIEvLx1+y1PvCIp3/n9Yvztt/bqh/HtjLAfb4hAQIFZ+QAKGp3xLUsO5UXB75zGRZorTQzLosYI9PSIBQ8QkJkOBN/XrflzfWGkySen6bNYuouCTyPn+h1PJP0aI3yh6fkACh4hMSIFR8QgJkafn4DZqRl5V/qwlbWdOEC2i3JmkfUJO9C2CPT0iAUPEJCZClZerXQbFLMdd71sWPL+WytBRpWdjjExIgVHxCAoSKT0iALC0fv8XHoeLFT+9pN71P3kgB8/ifaPoHPj/s8QkJECo+IQGytEx9m2YxwXJ2OZinziNvF68Z77kOUvX4ItIvIj8UkVdF5BUReb+IDIjI0yJyJPp7Xd7CEkKyIa2p/20AP1PVm1FZTusVAA8BOKCqOwAciLYJIS1AmtVyVwH4EIBHAEBVJ1X1HID7AeyPmu0H8Mm8hGxp/NVVkz51HFYoDb14SrJ4cE3zwPMjTY+/FcBpAP8mIi+IyL9Gy2WvU9UTUZuTqKyqSwhpAdIofgeA2wF8R1VvA3AZnlmvqrHLkYvIXhEZEpGhcrm8WHkJIRmQRvFHAIyo6rPR9g9R+SE4JSIbACD6Ozrfwaq6T1UHVXWwVCplITMhZJEsqPiqehLAWyJyU7TrHgCHADwJYHe0bzeAJ3KRMCRqeR/QiM9SIpT7jCHtOP7fAPi+iHQBeAPAX6Hyo/G4iOwBMAzggXxEJIRkTSrFV9UXAQzOU3VPtuIQQoqAIbuEBAgVn5AAoeITEiBUfEIChIpPSIBQ8QkJECo+IQEilTD7gi4mchqVYJ8SgEYH7jeDDADl8KEcLrXKsVlV1yzUqFDFr15UZEhV5wsICkoGykE5GiUHTX1CAoSKT0iANErx9zXoujbNIANAOXwoh0sucjTExyeENBaa+oQESKGKLyL3ichhETkqIoVl5RWR74rIqIgctPYVnh5cRG4QkWdE5JCIvCwiDzZCFhFZJiK/FZHfR3J8Ndq/VUSejb6fx6L8C7kjIu1RPsenGiWHiBwTkT+IyIsiMhTta8T/SCGp7AtTfBFpB/AvAP4MwE4AnxGRnQVd/nsA7vP2NSI9+DSAL6rqTgB3Avh89AyKlmUCwN2qeiuAXQDuE5E7AXwdwDdVdTuAMQB7cpbjGg+ikrL9Go2S48OqussaPmvE/0gxqexVtZAPgPcD+Lm1/TCAhwu8/hYAB63twwA2ROUNAA4XJYslwxMA7m2kLAB6AfwOwPtQCRTpmO/7yvH6m6J/5rsBPIVK8qtGyHEMQMnbV+j3AmAVgD8ieveWpxxFmvobAbxlbY9E+xpFQ9ODi8gWALcBeLYRskTm9YuoJEl9GsDrAM6p6nTUpKjv51sAvgRgNtpe3SA5FMAvROR5Edkb7Sv6eykslT1f7iE5PXgeiMhyAD8C8AVVvdAIWVR1RlV3odLj3gHg5ryv6SMiHwcwqqrPF33tefigqt6Oiiv6eRH5kF1Z0PeyqFT2tVCk4h8HcIO1vSna1yhSpQfPGhHpREXpv6+qP26kLACglVWRnkHFpO4XkWt5GIv4fj4A4BMicgzAo6iY+99ugBxQ1ePR31EAP0Hlx7Do72VRqexroUjFfw7AjuiNbReAT6OSortRFJ4eXEQElaXIXlHVbzRKFhFZIyL9UbkHlfcMr6DyA/CpouRQ1YdVdZOqbkHl/+GXqvq5ouUQkT4RWXGtDOCjAA6i4O9Fi0xln/dLE+8lxccAvIaKP/kPBV73PwCcADCFyq/qHlR8yQMAjgD4LwADBcjxQVTMtJcAvBh9Pla0LADeA+CFSI6DAP4x2r8NwG8BHAXwAwDdBX5HdwF4qhFyRNf7ffR5+dr/ZoP+R3YBGIq+m/8EcF0ecjByj5AA4cs9QgKEik9IgFDxCQkQKj4hAULFJyRAqPiEBAgVn5AAoeITEiD/D0To7NP/1SN6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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()\n",
    "overlay_pred_true()\n",
    "overlay_pred_true()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mimicking sequence-to-sequence by shuffling in predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXuQXVXV4H+rbz+SfuXVScyr6QDhEXTEBB8oOp8wjsLHKDUjD/20Ug4lFuWMWvWV34hT1vwhilT5wD9QSaGIFA6Cfgjlc/wQh2Fk+IiCIo+QQBKSkCdJ59VJOt295o+99zn7dt++fbv73tv3nKwflbrn7n3OPutedu+7zlprryWqimEYhpF9mmZaAMMwDKM62IJuGIaRE2xBNwzDyAm2oBuGYeQEW9ANwzBygi3ohmEYOcEWdMMwjJwwrQVdRD4gIhtFZLOIfKFaQhnGTGNz28giMtWNRSJSAF4C3gfsAJ4CPqKqz1dPPMOoPza3jawyHQ39bcBmVX1FVQeB+4APVUcsw5hRbG4bmaR5GtcuA7ZH73cAby93gYhYngGjpqiqVGGYSc3tnp4e7T2jtwq3NYzSPP3np/er6sKJzpvOgl4RInIDcEOt72MY9SSe1yt6V/D4k4/NsERGnulo6dpWyXnTMbnsBFZE75f7tiJUdb2qXqSqF03jXoZRTyac2/G87unpqatwhjEe01nQnwJWichKEWkFrgMero5YhjGj2Nw2MsmUTS6qOiQi/wX4LVAAfqCqz1VNMsOYIWxuG1llWjZ0Vf0V8KsqyWIYDYPNbSOL2E5RwzCMnGALumEYRk6wBd0wDCMn2IJuGIaRE2xBNwzDyAm2oBtGzhD/n3H6YQu6YRhGTqh5LhfDMGpPnjTy0Z9FGZvTr1TbeNefTpiGbhiGkRNsQTcMw8gJZnIxjBwQmyAaweRQziQSU0rWcG25vuJG3yYz/7lnGtPQDcMwcoJp6IaRMyrVjutFzZ8YTDNPMA3dMAwjJ9iCbhiGkRMmXNBF5AcisldE/ha1zReR34nIJv86r7ZiGkb1sbldOyT6b3Rbpaj/r9S4492rVAx7o5mgakklGvoPgQ+MavsC8IiqrgIe8e8NI2v8EJvbRo6YcEFX1ceAA6OaPwTc7Y/vBq6qslyGUXMafW7rqP+yTjU/x3ga+XjnnS5M1Ya+WFV3+ePdwOIqyWMYM43NbSOzTDtsUVVVRMb92RWRG4Abpnsfw6g35eZ2PK9X9K6oyf0bQbOsVIZqPkFUksul0k1H5TYp5ZGpauh7RGQJgH/dO96JqrpeVS9S1YumeC/DqCcVze14Xvf09NRVQMMYj6ku6A8D6/zxOuCh6ohjGDOOzW0js1QStvg/gSeAc0Vkh4hcD3wNeJ+IbAL+nX9vGJnC5nblVOqcDeeM6HDyb7LO3dHnlXKA5slZXE0mtKGr6kfG6bqsyrIYRl2xuW3kDcvlYhgNzkw69sK9K3VMJpkPy8haaWbIqnxuL49GQ+TZQWpb/w3DMHKCaeiGcZoTNNaypd406pPxzxcJOuJYLbzcWNNhhJGicVMZTj9O309uGIaRM2xBNwzDyAlmcjGMBqcaTrzJhvclzlBvxhjR4aSvibGmjVIZEEcT2oquC+abyAwzaWdokNGbXgol9NQ8O0JjTEM3DMPICaahG8ZpRDlNtSnSnDUJ9wva+Pga92SJnxbCfeKxmkY5NWPtvdQ9h7xmHp4imk5jPfX0/eSGYRg5wxZ0wzCMnHBam1xaW1sB+MxnPpO0LVu2DIA5c+YAcOmllyZ9HR0dAMyaNStp+8pXvgLAbbfdBsCJEydqKLFhTI1KzCOxaWMy11WDIqetlunzFOV1UWdyGRo5BUBzobnkeacDpqEbhmHkhNxr6CtWuOIDixe7wjNB8wa46ipXXezGG28cc12pcKpS3HzzzQA8+uijADz55JPTlNgwZoaK87XMgBzlzimIW8aGZKhmMmUF09ANwzBywoQauoisAH6Eq62owHpV/baIzAd+AvQBW4FrVPVg7UStnDvuuCM5vuKKKwCYO3cuALNnz67JPT/60Y8CpqFniSzO7XrTqPnGg90c0g1FoW0k1t4rKFWXJzt7JRr6EPCPqroaeAfwaRFZDXwBeERVVwGP+PeGkSVsbhu5YsIFXVV3qeqf/fER4AVgGfAh4G5/2t3AVbUS0jBqgc1tI2/IRE6/opNF+oDHgDcCr6rqXN8uwMHwvsz1NX1+C+aOtWvXTnusUk7R48ePA9DW1pa0nTrlQ6WanfXq5MmTY8b61a9+lRxfd91105bNGB9VndLz83Tm9pq1a/TxJx+bym2NCii1s3RYUwfoqZHBotfZhfakr9Dk/i6bpDDu+FkwuXS0dP1JVS+a6LyKnaIi0gn8DPicqh6O+9R9yyUXaxG5QUQ2iMiGSu9lGPVkKnM7ntf79++vk6SGUZ6KwhZFpAU34e9V1X/2zXtEZImq7hKRJcDeUteq6npgvR+nJhp6CEWcP3/+lK4/eDD1d7300ksAPPaY07j+8pe/jOnr7e1N2s455xwAvvrVrwLQ3p5qB4F3vvOdyfHChQsB2Ldv35RkNarLVOd2PK/XrF3TmJ7DnHBqOH3qPTrkfm8PnjyQtB0eLPoN5oyuvuS4o7kbgJamODNkOGh8zXyyTKih+0fO7wMvqOo3o66HgXX+eB3wUPXFM4zaYXPbyBuVaOjvAj4OPCsiz/i2LwJfA+4XkeuBbcA1tRHRMGqGzW0jV0y4oKvq44xfwvuy6oozNW699VYAVq5cOe4527ZtA1JTCsD3vvc9oLTJpRRnnXUWUJzfpRIn59KlS5PjkA/GTC4zTxbmdqMQOyanmzZ3stc3N7Ukx2FX6PHh46k83nQyOByco6eSvpBSN6k7CjSF+4ePFIlTqr5qFpymAdspahiGkRMym8slzsly8cUXF/XFoYbf+c53APjSl74EwOHDxQ6U8QihibHW/8tf/hKAM844Y1KyDg+n5bsmEyZqGNOhOIPhqN2RUpkuF8YYLipBN/7uy1LhgXH5Oki17ErvHY/Z3eKiR8/uTjOeHh7sB+CQfy1E5we5CyNRnpcQypjeKCXjjlLT0A3DMHJCZjX0Q4cOJcdbtmwB4IILLgCKc5Lfe++9QHnNvK+vLzl+97vfDcDnP/95AFavXj1tWe+5557kONjyDaOalNPGoXKNfMx1XhtvnkCrDnlUStmgk6fSqmq/6VhDfpNR0MZnRRuLmr02PtXPnzVOj09pGIZxGmALumEYRk7IrMkl5sEHHwTgyiuvBIpT5IYCFNdeey1QHKJ44YUXAnDXXXclbW9605uAygtclOOb33R7VW655ZYpj2EYlRCH1o0k4YF1vH85k4b/W2qaov4Ym29C+GGhhKM05HBpK8xiNPH3U+ooL5iGbhiGkRNyoaHff//9ALz//e8H4Jpr0o19YRPQj370IwDOP//8pK+npwcoDoGMQwwrYdeuXQA88MADANx5551J3/bt2wE4cuTIpMY0jMlSXLShxI6ZOhNrxIVJ6o0j3sF6cuSEHysl3TQ01unaVOIpIXly0LEbhcK4xc/g2Q4rNg3dMAwjJ9iCbhiGkRMmVeBi2jercYGLwPPPP58cn3vuuVMao8mn2xwZSXNA7Ny5Eyh2cn73u9+d0vhGbZhqgYvp0AgFLkrFfUsc913BTtFS9UOT+HKJ089O7isuV8Mz9MXr0JAvVHF0yJkqjw8NJH3BGdre3DHmPiEevbOlO2kLjtg4l0ugWVrGtEmJWPlGyOVS9QIXhmEYRmOTC6foaN773vcmx0GrLkW50MSBAacV3HfffUnb5z73OcCcnEZjU0qfHPYa6sDQUQC6mrujC8b+HZQL7SulyY/ZIRqNNfrsUmGIcb6XIOvJYecUPTiYFrM4MeSKXbQWUu16lg9T7Gju9O/TsOWQN6bU08qIjNXaC+p13IzmdDEN3TAMIydMqKGLyCxc8dw2f/5PVfV/iMhK4D5gAfAn4OOqOlhLYSsllIObiHL+gxCOeP3111dFJqPxyOLcHpcijThoyWn3sVMul9HDWx4G4IMrP5j0dbW4sN0QLghpcWUp52OL7ynFbfFVQfsONu5YG0/ysETZEEMB6MFgSx88OubWsYYe8qW3NI21iYfvokC6EUmleONVyYDP+HNnSFuvREM/CVyqqm8GLgQ+ICLvAG4FvqWqZwMHAVv5jKxhc9vIFRMu6OoIP5Et/p8ClwI/9e13A1fVRELDqBE2t428UZFTVEQKuEfPs4HbgZeBflUNz0k7gGU1kXAKXH311eP2xc4RKzZhZG1uV0LqdCxhhvFsOpSWWjyr+2wADp9KU1Ivme0+cuq0TM0xIYSxJQr7C+GBJR2m/m8umD3iAhlJ8Yqm1qTthC8vFxyts5sjJ2eTOz84QAG6WrqANIdLXBAjyflSLoRznOMsUpFTVFWHVfVCYDnwNuC8Sm8gIjeIyAYR2TBFGQ2jZkx1bsfzev/+/TWV0TAqZVJhi6raLyKPAhcDc0Wk2Wsyy4GS8YGquh5YD/XbWFQpYVPQokWLkraQsTG0XX755Unfr3/96zpKZ9STyc7teF6vWbtm5ud10ZPn2O7BYRfut7Dd5S866d8DPH/wOQAODaYaetdiF9bYP5hmJ036vEbc2ZLmQArad6zJB0JxjGSDTrRJqclr9ENRYecj3oG7a+A1AAaG0oLQi2YvLJIBYLbfZFQum6OUfZd1vTxlQg1dRBaKyFx/PBt4H/AC8CjwYX/aOuChWglpGLXA5raRNyrR0JcAd3tbYxNwv6r+QkSeB+4TkZuBp4Hv11DOqhFnU7zssssA+PKXv5y0vec97wFSDf1rX/ta0vfEE08A0N/fX3M5jbqQm7kda5mpPTu2e7v+lV19AJzSVCMOrOxOC6K3Nbki6WHr/4nhtKxjp7dfl9JrtYSGPsRQUV8cthgyKu47vjdp237UZSntbnVPCWt61iZ9Ld7WHpfEC+GN4T6xGV/85yiVibFkTsrwpJNR/9qEC7qq/hV4S4n2V3A2R8PIJDa3jbxhO0UNwzByQi5zuXzqU59Kju+5556ivpBFEdJMjKPPibnggguS4+XLlwPFJpfgRP30pz8NwCc/+cmkb8eOHZOW3TCmQhwuGBtfAiG/yexmV6atIzJBhNC+OEthGO3Y0DEATgylJpe5rc5ccypyZDaJM6MEp2ixCUiL+gZH0rHC+EOa7hRd1O7MnXNaXWm5EMYIachk7EQd8GOE7IxxFsWeWW6ssPPVD+I+YzABxd9FRk0tAdPQDcMwckIuNfSf//znyXEINYzDD6fL2WefnRzfdtttQKr579u3r2r3MYxK0aJcLmM3A4XNNvPa5gPQHG3kCQ7G2HEYrl3RcQYAuwbSyM2Q/TDOghjyk7eVcEKGp4KgtR89leZmCZr5kvalSVtrk9sgFJ4cTo2kaXQG/LXx+MPeydp/0oVdtkTa+PxZLkxTS2yMCk81UiInTVYDGU1DNwzDyAm2oBuGYeSEXJpcjh9PnSgf+9jHgDSefN26dUlfW5t7PCyX3yXe1j13rnPSxE7U3t5eANaudbGyJ0+exDCqSWIaKFNsIi6xFpsoAiF+O4xRiPKdlNwp6ZvCLsxFsxcnXTuPOWf/a8d2JW3NPsfKQr+Tc37bgqSv3Q8WzDiHBtOgglJO1LmtTs9s8rlZYodmt3eUxiXxRqLUu64vHavgddbhyOka5fp19ykRo55V8vNJDMMwTnNyqaHHHDrkHCU33ngjAF//+teTvksuuQSAH/zgB2OuO3zY5ZPYunVr0vb73/8egEIh1W7CeM8++2wVpTaMsZkLS2UyTApKxA5Qr6fFmmq5bIhBu4+15KA5B+21JXKihkISsXNz0IcRzml1+V1CWThIC1CEMUM4YkysJYfSc+E1ZFgE6Gh2OVwKsS7qNfiQlVGivkTu6LsITtQ0t0x5F2i5J6RGwzR0wzCMnJB7DX00L7/8cnIctO/zzkszpn7iE58AoLnZfTVvfetbx4yxfv365PiLX/wiUJwjxjCqSvDrlNAktUS2wmBfjvOdpEMVb/KBSGOVWEN3bUGzjzXooKG/oT21qy+a7TbwLO1YAUCrD190MvoNRT7D43CUyyXY+/cdT31Vr594HYDZzU7L7+3sTfra2r3mH6miwT4+MOQKu3dFG6QS34LGfjL/RBL8CEXl5sg0pqEbhmHkBFvQDcMwcsJpZ3KJCWaSm266KWkLxwsWuLCrkDIX0hDFZ555ZswYhjGTxM7OZm9KiJ2DwfQQdmYORulwj55yOVA6o6IRwQE4y+/yjHeWBqdmbIYJ14br4jDBYFYJhSvisMpN/ZsAeHZ/WhJv+2FXVGPlXBcCORKZRIL8YWcqpCGYcT6YwLAPaYzDOoPJJ1zXVIgLbgTncexQzo4dxjR0wzCMnFCxhu6LAGwAdqrqlSKyErgPWIArsvtxVR27oyGjhNwscYjiH//4RwDuuOOOGZHJqD6Znddeaw3FHY567Regy5eGk6ZUswyFJI74MnObD29K+rYdcQUlemalm4EW+ONz554PFG9EavZhgvFTQdgsdOCkc2gODqdf2XFfQi6Uktt7PM139MNnHnPybEozk+474GRsa3X36epoTz9bp88a2Z6GRZ6z4g0AXHPeu53M885NZfWZF+MnhuA07Rj1VBGTHZ28mMlo6J/FlecK3Ap8S1XPBg4C11dTMMOoEzavjdxQ0YIuIsuBvwfu9O8FuBT4qT/lbuCqWghoGLXC5rWRNyo1udwG/BMQvCYLgH5fFR1gB7CsyrLNKGeeeSYAfX19Sdtdd901Q9IYNSJT8zo2DYSw6hAT3hXtvmzz6WfjuPIWWv15zhyzsuvMpO/ACeeE3D2Q1vUMu0DP6napopub06IRYfdlHO/df9KNsevYbiCNJYfURLPz6B4Afr35uaTvj//vbwAM7zmWftADLl59qNvd81RvGngwZ45zhnZ1p2aYFm8W3bDbjfXigS1JX2erM9GcNy9NeX1hzxp3nTfHxM7dcvlycrFTVESuBPaq6p+mcgMRuUFENojIhqlcbxi1oJrzOk7gZhgzSSUa+ruAD4rIFcAsoBv4NjBXRJq9NrMc2FnqYlVdD6wHEJHM1HeqZkEMoyGp2rxes3ZN1eZ1yXwtJXaIBm0xFK5oi3ZmSonzw67R5oLTSme3pxru5b1LABgcSTOFhp2nbT4nS5yFNJSEOxI5YvedcI7OJ177MwD7j6d5Xlq9Bv2C/+F7aeOrSd/wYX/PQiTzYqdVLz7L7US99O1vSrreuNA9MLU2pU8M24+4J4s/bHK7wPsPHkn6RkZcuOJHLkllXT3flZUMmSTLaeXj9TcqE2roqnqTqi5X1T7gOuD3qvoPwKPAh/1p64CHaialYVQZm9dGHpnOxqL/BtwnIjcDTwPfr45IjUGwocf8+Mc/ngFJjDozo/N6stpgmjGwvB04CcRLtPf0nGYZm4kx5HI57vOjHBtKNe7dA85OvvXI1qTt6T0bAXjgsacAGBpK7d49Pc5uH0KA41Dg1nlOG29rTTXuOV1Oc37zBSsBePvS1P7d27VsjKyHB51sh/rd60ubo+LsXkP/7YI0kOkDfa4/hHdqFJIZvpc4100hQ/nSJ7Wgq+ofgD/441eAt1VfJMOoLzavjbyQnZ8ewzAMoyyndS6XcoTCGDHXXnstALfccku9xTGMIhKTQ4nUuiUdq0mnL4gRNQXzSpzWdvRYp6L0vIcHnYPxN6/8OWn7w1MuFHHXHheuuHzpwqSvb7lLrds3x4VWHjiR5pHZftDtMG1vS3PFhNwt5/e4Mbpa07wtJ30K3oMn07/PZ/e6Uni797nQSXZHIZCnnOnkhY3bkqYnLnQBdyu7zgKKc96keWHSz1vI0DJpGrphGEZOyM5PT525/fbbgbTINMDVV18NFG8w2r17d30FM4yIoGlLUZGGMo5V36eRNh6yFMbFlkMOlBFxGm5wjgI897pzgL64PS0SPTTkrl3Z6/KqrFmdBhVcvHwVAD2znYa+b+Bg0rdyjtP29w6koYaHfaH18Lrx9XSj0IETLmTyxb1pPphXt7kNS4eOeM28OdJT2/3Gq47ZSVNnizsOWR/jQiDD3gEaQjMB2grptY2OaeiGYRg5wRZ0wzCMnGAml3F48cUXAbj55puTtiuvvBKApUuXJm1mcjFmluDkjMwsOtYpGup6NmlTdJUjOAK1KYpD9+aXvcfd/P75y79J+n72ry5bwqs70twvwcrT6uPJX34t7Tt2yjkYe+e4uO83L0rNMX1zlgPwXFTg4v/0OxPLlj1uZ+nAQOpE3bnLtfUfjhyfJ4bCh3QsSFPrLlnSA8CaN6Wx7H3drlBNqEEa8tbEdPucN5CznaKGYRhGNjANfQK+8Y1vlDw2jEYgzQQ4tm04cnKe8mF4s4KDr4QWXygqWecIeWGCQxOgu9uFEc6alYYaDg668Q8fHSh6D3D0iGubdY4vWBGFIYZCGL/bvDFpe3mzS58z6B2tsUMziN0UFe8YaXVPGJ2++MXc7s6k7/1vc3lgPrTqPUnb/FnzgTQXTUuUF6bb7x5tb07HyBKmoRuGYeQE09ANI8Ok9t1oY5HPQxIXRg65SUa/QnF5tqTNXxvKxe08mtrEQzbDI0fT0L5gQ+/qTLM4Bk4OuvEPDLjztxxKE1j+3+2vuNfH/5pesNePO89lkGxfmWaSXDDXpa7vju4TniKWLXcbkd7auzzpu2Kl08wXROX1gkbe7F/bm6MSd15Db42KYmcJ09ANwzBygi3ohmEYOcFMLoaRaUqE1HkTRJyDpFBwx6HcWiFOGeutL0N+52Q8aleLcw4u61yU9K06c6m/TXrvWbOdiWLWLGceGR5Od6KOjBQ7YO957PHkePMrr7mDV9ICFEmxi1lOxq6u1CTy92ve6GSY15u0zWtzZpLeLtc2vy01rzSVSH0bPnsopRcKXQC0+kIhpa7LAtmU2jAMwxhDRRq6iGwFjgDDwJCqXiQi84GfAH3AVuAaVT043hiG0YhkfW6XKWWRlKeLW5Pz4wLS3jkYa+0hA2NvZx8Ac/vmJX3XrPrwmPNbvGY7MOQcpi8cTAtKbOp3peF+t+VZADZGzlSO+KeCuARdp5enx2nm//aN5yRd//FsVxryDe1LGE3QrmO5guNzKHL8hiLaoXh1QfJjqJiMhv5eVb1QVS/y778APKKqq4BH/HvDyCI2t41cMB2Ty4eAu/3x3cBV0xfHMBoCm9tGJqn0WUOB/yUiCtzhK54vVtWQP3M3sLgWAhpGjcnm3C6x0zNQKjY9ODBL5iVJHKVRoQe/NATHYUdLdzS+oynSB4M0w4WxMe1/2+dys7y4xcWfHx2ITC5dPt47Nrn4nZ8L5ztn58L2rqRrXpvb5dnRnLYFB2bq0IxNTcUyuzdlvouMU+mCfomq7hSRRcDvROTFuFNV1f9BjEFEbgBumKachlErpjS343m9ondFfSQ1jAmoaEFX1Z3+da+IPIgrortHRJao6i4RWQLsHefa9cB6gPEWfcOYKaY6t+N5vWbtmrrM67Kl5YqYouYZaf3itV71QzVpPObY8UM2x6M+P8qDm/4l6XvkGecg3X/Q9XXMTrMhdne6kMGBEyeTthDy2NnhzutsTcMWg8MzDitMnJoyyvFb1JY/bbwUE9rQRaRDRLrCMfDvgb8BDwPr/GnrgIdqJaRh1AKb20beqERDXww86G1wzcCPVfU3IvIUcL+IXA9sA66pnZiGURMabm7HWnhFWmWJcnNSxr5ecgh/Hy1lXg8ylNhoE8sX7hkyGG6Niqw3t7hl5pKLVgNwzoJ048/eYy6v+YaXtiZtr+5wJeUGjodSdGnu8xBqGNvJg7ZeKiTzdGPCBV1VXwHeXKL9deCyWghlGPXA5raRN2ynqGEYRk7IzxYpwzidKGdWCH0lS9GFghgypq3s7SYw/4Qxjgy6naJ79vcnff39ru3AAhf6uKUp1SO37X0dgB2v7Uvaju515wdH6f/e8nLS9x/OdOaYkOYWoNk7RZtK6afhOzhNzDCmoRuGYeQE09ANo0EppU1XdmEJjXuUpjqRVl55iKQjFMzo9NkZz13+hqQvFMTYs8tp46+8nBa4eG3vAXewKyr6fMSVrxs57PK8bF20K+l69cirQJpjBtJ8LU14R2lUvGNMDpucYxq6YRhGTjAN3TAanMlqy+Vs6OXs6rEeOzof+EiR1jt2jJDNcNOhzQC88OprSd+e/S5R5TEfhkh/uokoaOMcj1IGDGvRa1Nkcx/SNM96KptrG2bs00ewr0/6O4zI0qYk09ANwzBygi3ohmEYOcFMLobRQEw2nLBsWF7c5s8LI4bcK8VDpW2hP+RJCTs0ITW/nIpK1h08uR+AAyeceeX83qWRGE6OnTtdaOKBwtGkb6jzVPHnAPAmlnafy2XJ0nRn6eCwu+fAUOpElSRb5HCRfADNUVbGyZAlM0uMaeiGYRg5wTR0w2hQpISTb+xJFWqSozIRiqa63LB3KsZl2sQndhnGtY0UyVCs7UO60eedb3iHe9/amfS1ND0FwNEjAwAcP5lq9sM+z0tLS7oULVrgxvo355wBwH86711J3+p55/sxW8Z+Rq/lh7zoUFzIuhKyqpkHTEM3DMPICbagG4Zh5AQzuRhGg1OR6aXMdaU7076CPy5ompI23CuYYWKHaYj7HhxO48mPDh3xr87h2d48O+l757LzADh3wZIxYrQVXAm6uW2p83JZpztvSbt77W6dE53vHKUtkppcCqNS6obYc8i+CWWymIZuGIaREyrS0EVkLnAn8EacL+Q/AxuBnwB9wFbgGlU9WBMpDaNGZGlu10rbTItYRAUr/Gur13qLng6887GtkGrhHS1Ow+5pWwTAmV2r0tN9CKSWK2xdVFKuUCRXqb54J6t4vbRsIezThEo19G8Dv1HV83AFAV4AvgA8oqqrgEf8e8PIGja3jdwg5X41AURkDvAMcKZGJ4vIRuDvokK6f1DVcycYy4pEGzVFtVQhtdJUa26vWbtGH3/ysemIbRhl6Wjp+pOqXjTReZVo6CuBfcBdIvK0iNzpC+ouVtWQ13I3rj7jGETkBhHZICIbKhXeMOrElOd2PK/3799fR5ENY3wqWdCbgTXAd1WPjtjkAAADuElEQVT1LcAxRj2Ceu2mpPatqutV9aJKfl0Mo85MeW7H87qnp6cuwhrGRFSyoO8Adqjqk/79T3F/BHv84yj+dW9tRDSMmmFz28gVEy7oqrob2C4iwYZ4GfA88DCwzretAx6qiYSGUSNsbht5o9KNRf8VuFdEWoFXgE/gfgzuF5HrgW3ANbUR0TBqis1tIzdUtKCr6jNAKRv4ZdUVxzDqi81tI0/YTlHDMIycYAu6YRhGTrAF3TAMIydMuFO0qjcT2YeL9c3yTowesit/lmWHieU/Q1UX1kuYgJ/X28j295tl2SHb8lcie0Vzu64LOoCIbMjyJqMsy59l2aHx5W90+cqRZdkh2/JXU3YzuRiGYeQEW9ANwzBywkws6Otn4J7VJMvyZ1l2aHz5G12+cmRZdsi2/FWTve42dMMwDKM2mMnFMAwjJ9R1QReRD4jIRhHZLCINXQVGRFaIyKMi8ryIPCcin/Xt80XkdyKyyb/Om2lZx0NECj7P9y/8+5Ui8qT//n/i85c0JCIyV0R+KiIvisgLInJxo373WZrXYHN7pqnl3K7bgi4iBeB24HJgNfAREVldr/tPgSHgH1V1NfAO4NNe3iyVJ/ssrqRa4FbgW6p6NnAQuH5GpKqMTJSGy+C8BpvbM03t5raq1uUfcDHw2+j9TcBN9bp/FeR/CHgfroDwEt+2BNg407KNI+9yPzEuBX6Bq/u7H2gu9f+jkf4Bc4AteB9P1N5w333W57WX2eZ2/WSv6dyup8llGbA9er/DtzU8ItIHvAV4kgpL7zUAtwH/BL7kOiwA+lV1yL9v5O9/WmUP60xm5zXY3J4Bajq3zSk6ASLSCfwM+JyqHo771P2cNlyYkIhcCexV1T/NtCxTZFplD43KsLk9I9R0btdzQd8JrIjeL/dtDYuItOAm/L2q+s++OQvlyd4FfFBEtgL34R5Nvw3MFZGQA7+Rv/8slYbL3LwGm9szSE3ndj0X9KeAVd4b3Qpchyv11ZCIiADfB15Q1W9GXQ1fnkxVb1LV5arah/uef6+q/wA8CnzYn9aQskPmSsNlal6Dze2ZpOZzu84OgSuAl4CXgf8+0w6KCWS9BPfY81fgGf/vCpy97hFgE/AvwPyZlnWCz/F3wC/88ZnAvwKbgQeAtpmWr4zcFwIb/Pf/c2Beo373WZrXXl6b2zMrd83mtu0UNQzDyAnmFDUMw8gJtqAbhmHkBFvQDcMwcoIt6IZhGDnBFnTDMIycYAu6YRhGTrAF3TAMIyfYgm4YhpET/j/ZYxsEYSe3bAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnWmQXFeVoL9T+6qqkkqWtVqyJcsIDEZSA2ZvGzqwx9E2BNhmCzXjwdFEz2AieujATBDzx2AcQbD8YLHCbreGsDHgbsYEmGYYt8FEw6gtYwM23rVYEtpKUmmv/c6Pe++7NzNfZWZVZWZlPp3PUc6X977lZOrWq/POKsYYFEVRlManab4FUBRFUSqD3tAVRVEygt7QFUVRMoLe0BVFUTKC3tAVRVEygt7QFUVRMoLe0BVFUTLCnG7oIvI+EXlBRF4Wkc9VSihFmW90bSuNiMw2sUhEmoEXgfcC+4AngA8bY/5UOfEUpfbo2lYalblo6G8CXjbG7DTGjAEPAtdXRixFmVd0bSsNScscjl0O7I3e7wPeXOwAEdE6A0pVMcZIBU4zo7U9OLjIrLroogpcVlHSeep3Tw0ZYxaX2m8uN/SyEJFbgVurfR1FqSXxul65aiW/3v6reZZIyTI9rQv2lLPfXEwu+4GV0fsVbiwHY8xWY8xmY8zmOVxLUWpJybUdr+vBwcGaCqco0zGXG/oTwDoRWSMibcDNwI8rI5aizCu6tpWGZNYmF2PMhIj8V+DnQDPwj8aYZysmmaLME7q2lUZlTjZ0Y8wjwCMVkkVR6gZd20ojUnWnqKIo5SNUIkjHYtCgsvMNTf1XFEXJCHpDVxRFyQhqclGUCiBIjonDm05mavZQM4kyF1RDVxRFyQiqoStKhUhzaMZj+dp3uQ7QedHa84v2SeWctUr1UA1dURQlI6iGrig1ohyNPE0bn20o41zOVZESZ0rNUQ1dURQlI+gNXVEUJSOoyUVRKkA5Ds9aOzeLmVdmKkspU42GW9YHqqEriqJkBNXQFaUKeI21krVZKkm5Gne9yp+KD7U8j0MsVUNXFEXJCHpDVxRFyQglb+gi8o8iclhEnonGForIL0TkJfc6UF0xFaXyNMraNin/FdtnPhH335wwZnY/xY4/TyhHQ/8n4H15Y58DHjXGrAMede8VpdH4J3RtKxmi5A3dGPM4cCxv+Hpgm9veBtxQYbkUpeo02tqW6L+ZUo72nqblpz0dpD4xOE049TrlaMtF5k3Jn3DV/KOTsfNEa5+tDX2JMeaA2z4ILKmQPIoy3+jaVhqWOYctGmOMiEz7505EbgVunet1FKXWFFvb8bpeuWplVeWoSC0Xp5EWq9GSWhmyWChgpOX6LfHXKSJXqgjx+cs4R44YSYilf69hizPlkIgsBXCvh6fb0Riz1Riz2RizeZbXUpRaUtbajtf14OBgTQVUlOmY7Q39x8AWt70FeLgy4ijKvKNrW2lYyglb/B7wW2C9iOwTkVuALwPvFZGXgPe494rSUGR1bdcsfFEk+RFyTSmS8jPz00vhT9HzzvZK2aGkDd0Y8+Fppq6usCyKUlN0bStZQ2u55NHW1gbApz/9aQCWL1+ezPX19QFw1VVXJWPd3d0AdHR0APDFL34xmfv6178OwMjISBUlVrLOTBtVpDaoLlLfpFjrvLSaLqnafzn1U0x55xKZ3nCQOHUjh2y+/PG7bAYnTo+m/iuKomSE805DX7kyhJgtWWJDjL3mDXDDDTaP5FOf+lTBseK0EFMkKeGOO+5Ith977DEAtm/fPgeJlUZmPlLxZ3rNYvsn4Ygpc9Vqcl10/5SQxrD/9NLGoYzJVtrvcYNXalQNXVEUJSPoDV1RFCUjnDcml7vvvhuAa6+9Nhnr7+8HoLOzsyrX/MhHPgKoyUWpPPnOypJOy2SyWBZmPGrPN2Um7buUTM5KmCfKMdukOXclx1ySr5fOwczV4E0yVENXFEXJCFLMwVfxixWp+VItvHa8adOmOZ8rzSl67tw5ANrb2wEYHx9P5lpa7APQ6OhowbkeeeQRAG6++eY5y6UEjClWraQ6bNy00fx6+69qfVmgMo2gi57DTNl9olDCYu3pynk6KBaWmHpYqc9R8NSRWy0SQCLdtawFUmcaek/rgifLKZ+iGrqiKEpG0Bu6oihKRsikUzSOK1+4cOGsznH8+HEAXnzxxWTs8ccfB+D3v/99MubnV61aBcCll16azH3pS18CoKurq+D8b33rWwFYvHhxMnbkyJFZyapknCKOumLmj5jU7NGZiBCbMUx+3Hfa/oEprNnGO1jbpH3G1/QUy4JNK91bLI4+i6iGriiKkhEyqaHfddddyfaaNWum3W/Pnj1A0LwBvvOd7wDpGnoal1xyCRDqu5Tr5Fy2bBkQasGAaujnNeWEy5lCrTSZKqO9XKm5NC1/0mnVTZHuN+X2byZ2lHqxpFBWt90kzUVlzKecejX22ibndSrnaWLKHXB+6K7nx6dUFEU5DyipoYvISuB/YXsrGmCrMeYbIrIQ+D6wGtgN3GiMOV49UUvjbedXXnllwZy3+33rW99Kxr7whS8AcPLkybLO70MTY63/pz/9KQAXXXTRjGSdnJzMkUupPXW5tstdD8X2S9OS8w9PeZc7JjnnSmtnNylT0ZDdbsZq4VOp9u/cfe3pZ6dTptn0k2uW+A7zZytiX6+ThKRyvs0J4O+NMRuAtwB/JyIbgM8Bjxpj1gGPuveK0kjo2lYyRckbujHmgDHmd277FPAcsBy4HtjmdtsG3FAtIRWlGujaVrLGjJyiIrIaeCOwHVhijDngpg5iH1vnlRMnTgCwa9euZOy1r30tEJpM3H///clcMVPL6tWrAXjHO96RjH32s58FYMOGDXOW9bvf/S4QHLPK/FKttV12jZUgSNiuojkutwmEFIzl7xd/jlDXJToibyzWFH3urqToj+WEXcbfW/p+eaaW1O8w7bucpXmkjs2kZRuwRKQH+GfgM8aYnDuhsUas1E8pIreKyA4R2TEnSRWlSsxmbcfremhoqEaSKkpxytLQRaQVu+DvN8b8ixs+JCJLjTEHRGQpcDjtWGPMVmCrO09N/rT96Ec/Sravu+46IFRUjBtQ3HTTTUAIUQS44oorALjvvvsAuPzyy5O5chpclOKrX/0qAHfeeeesz6FUjtmu7Xhdb9y0ce7rOs2ZVoZzsxLXaUpL1vFJOv41OiwJV4zOlf87UVqrLj2X9kST/pTjnjASB27h/hNmouCaTYlDdoZ1XuqYkhq62G/pXuA5Y8xXo6kfA1vc9hbg4cqLpyjVQ9e2kjXK0dDfBnwc+KOIPO3GPg98GfiBiNwC7AFurI6IilI1dG0rmSKT5XPjhhX33nsvADfeWPg72dxsY2ZfeeWVZGxwcBCAnp6egv3LMbkcOHAg2f7hD38IwD333JOM7d27F4BTp06V+BTKbKi38rkzdooWYw6/q8WOTOLDo718TPfE1BgQMkYhZHy2NrUlY5NT1qTR3FSoIzaR6zDN+QdKMzXlf860GjYmljW3Vkzad5425rNf4wzW1MWTf/1ycgAqjJbPVRRFOc/IZC0X33QCQhs47+xcv359Mjc1Zf+yF6v3EtPU1JRzHMD+/fuB4OT89re/PVuxFaVsZl5FMFernEpxgMZaeH5oYlzLpTmlJkt+FmiOs1NyNfMcSXzTi2ISG1MwmlavJdHac6IWfVONYt9UYeu9RkU1dEVRlIyQSQ09DZ/IE4ctztR/cPbsWQAefPDBZOwzn/kMoDZxJZ05282LnNn+f/qkoJya5EnVwelDIZuiuip+O9G0Yzuzm4s1df/0mvbsYBIbd3iyDXO5lRKtaLmyTZjQ1nF00j59nxoPv29exu4WW7m0syVUME2r8Bg+U0qCVIOjGrqiKEpG0Bu6oihKRsi8yWXBggUA3HbbbcDcsjx9SOItt9wyd8EUZQ6EJhP55oOARGs9hOpJzvH2UKfXxaGAzjwyMWXNHbHD1Jtampo7Cq7p94vL4poUU8t0xwGcGbfVF46O2JIKZyfOJnMvn7Ahxs8d3ZmMDXYOAHDZwrUArO8PgQ/9bXaupTm61cn0ZqpGRzV0RVGUjJB5Df3qq68GQjNmbSihNCpp4X5F1cxIaxfjtdImd66gEZOE/U0VHOs1+7GpkWTKOxrbmgubPafVZikYi+SaijRzT0tTKwC9bfbpurs1JPl1tdiG68t7lidjo5Ojdv/WXnf62CE7PaUaa4eT1EfzinJQDV1RFCUj6A1dURQlI2Te5FIOo6OjybZ3eL7//e8HQvldgAsuuACAa665Jhn72c9+VgsRFSWHEL9tkRKmRF/vxNtozkRx3N7sEddm8Yy7Wi4nx0OZ+IXti9yZYhOEL2EbJEzOH9JIC87vna6jk8Gkc+Cszb4+O2FjzntbC+sqNUtTwXZ3qzXHdOXEoXsTU+QETr60lBoxOZ9m+v3qFdXQFUVRMkLmNfTf/e53AJw5cwaArq6ugn1aW1uT7Y9+9KMAPPDAAwC8853vTOa8hv7lL385Gfvtb38LwPDwcCXFVpQCYgdi4sCUtMzMwtosI5OhvhHAk0eeSLYXdViNu6+tLxlb4La91j7YcUEy156EK0ZO1wJpw4gPrQyt6AL+/F5Th/A0cXz0GADnorBF/9mOnAtdog6ftfst77EtKDubw+/4og4bDBF+w9NlzAqqoSuKomSEkhq6iHQAjwPtbv+HjDH/U0TWAA8Ci4AngY8bY8aqKexs8E2Yd+ywLU3f9a53JXM+hDHUoQj28dhOno9vPA3wve99D4BPfvKTAOzbt68SYis1oC7XdhFb+HhU08TXH/chhHHNEq+ZnxoPT43HRo8CMNC2EICeyC492Gm12KacVmy52mtsX28Re9soXsGwEEkL/3NDwcYf5Ohv7wdg6NzRZO7Q2SMA7Dnx52Ts6Dmrwfe2daWcK6W9Xv7FUzT1Rq2/WI6GPgpcZYx5A3AF8D4ReQtwF/A1Y8xa4Dig6ZNKo6FrW8kUJW/oxnLavW11Pwa4CnjIjW8DbqiKhIpSJXRtK1mjLKeoiDRjHz3XAt8EXgGGjUlaae8Dlk9zeF3gW9AdOnSoouf1DTOOHDlS0fMqtaER1rZ//D8bhRr6LvYtruVbWxTG5+eGx4LJxZtQhseOAzAZZYW2OXNKXN7Wm1haXTZoa1NwK5adYZlPWr0Zd64WCedf3GkdsH2T1sp1bOR4MvfcUWtCfWLP3mTs2JB1hj6125o7919+OJm7atXbALi495JkrC35TG0F1w4lhBvJ0BIoyylqjJk0xlwBrADeBFxW7gVE5FYR2SEiO2Ypo6JUjdmu7XhdDw0NlT5AUWrAjMIWjTHDIvIYcCXQLyItTpNZAeyf5pitwFaoXZPoNOK2dB7v1IkTi9raCpMrpjsO4AMf+EDBOZTGY6ZrO17XGzdtrPK6LmwC0dZktczgDA1rstVpnEs7w4OFr5B40jlK4wqGZybOuHOGte8TitKSjWbe/m56vFxxMlBHc6e7jr3SFYPhNnXwrNW+D0QNZc6dtb97Q05T//5v/yOZ+8kf/wjA377tPcnYlUveDMBg5xL7OaKgCP8UkaPpNlD5p5IauogsFpF+t90JvBd4DngM+KDbbQvwcLWEVJRqoGtbyRrlaOhLgW3O1tgE/MAY8xMR+RPwoIjcATwF3FtFOefMyIhNLd6yZUsytm3bNgBaWsLX4MMbPZs3by4411e+8pVk+49OA1AakgZZ21ZrjFurebuvf42fGptdWGHcIs4rmT2ttoJha1Pw+Qyds9tHR44lY2NOQ3/dQhuiu6xrZbi2s6c3R7ePclsw5+/rtfDYfu/DM32y0bPHnk3mnjzwEgAd0e/spktWWZknbbjm4u7wPQ273/tLFoRG8D7ZyIdf5grrnoZyc/8L5K5XSt7QjTF/AN6YMr4Ta3NUlIZE17aSNTRTVFEUJSNkvpaLZ9I9jvnMTggZn5/4xCeSsbVrbRurgYGBgnNs3boVgM9//vMF51WUihA3Z3CP/36kvSm0fPPO0KLZmjkNLvy5rA4XO0C9uWPXiRAK+MgrzwCwvNc6GP/L669P5ha5aosXdC5Nxjpc44mksGIkRn4Tizjs0We1jk+FoIIjI9bxeWrMVnh89ugLydyyXps92t3amYx1tdrvpa/dNrhY2bMimRt3ZpuLelcnY3FWrZW1sFVfWp2aSjqDq4Vq6IqiKBnhvNHQPbFGffvtt+e8AixaZLUPX0Vx1apVydzTTz9dcA5FqRYFmqEUao1lt0dz8z4RKa6e6Fu8DY+dSMb+5vW25ku/q7rYHrWb+/NZW0dlQVSdMWjorgl1pJWfHrfnnUypu+73H4s09Ljyor122L+jxcqxsCNce9zVtfH1aQbaw9O1bxLtncFQqKE35Wjjad9jI+jmFtXQFUVRMoLe0BVFUTLCeWdyKYUvpdvcbB/LfvOb3yRzd99997zIpCiVwhsPJqJSvN4p2tvam4xd2n8pEErZxg0y/P4+WxVCww3jW75FceUnnXMz3zkK0OxMQMdGohK556xT1Jt5Bjpic0lTzitAh9vPlxQeidrZ+e2ullAu2MfpG1dmdypuT+c+76zr1cwzqqEriqJkBNXQ87j44osBWL16NQD33XffPEqjKLMgpUmGH5lyWuzYZGG/jrOupgsEbXfYVXh88vDvk7mdw9Yp2hJVYLys39Y063Dt3+Kmz3tPvwrAgjaraZ+KqkaeGLUO0+Gx0IR6bd/FOfsv7bowmfMad2dzCFv0Wa0+RHF4NFSZ3Htqrzvn2mTswq5lAIgU6rNtTVYzj92m/qmjEbR21dAVRVEygmroeRRrPaco84Ekr0X0r1StPIx5O7Fvz9YVtaDzmudrBjYkY70uzG+xq0i4ujfUQvHVGU9HmvYrJ1/OufbBs6HvwM932uQknxQ0MhFCFH1IYl9HkKd70NZiWdQ+CITqixBs7nENc/+ZfLjjsdFQzviZo7bW0p/PHkjGepyvwNvo42baLa3+/I15a1QNXVEUJSPoDV1RFCUjNOZzRRXxTlHPAw88ME+SKMrckJwMSGty8c7OOOTQmxdaOoIZw5fe9eeIHYi9rdZ0MtYeTCfHR23Y4UmXbdrXFkINF3dZE8obFtt2jf1RJqc3e3jHJsBguy1v61vF5WbIpjgmjS/BWxgWOeHG/OeG4LD1oY/jUWZqV4vd35txAJqMD5UsvHS9oRq6oihKRihbQ3dNAHYA+40x14nIGuBBYBG2ye7HjTGFsVANxokTJ3Le33TTTcn2nXfeWWtxlCrTqOu6oLpISi2XuMHFlNOAz0ycBqCvbWEy5zVgr4na806vjvrEorjmyjnX0u6Ia5YRJ+us7ret8F4z8Bone5g7PW7lORmFLXoZvZY8nlfbJZ8elzQUHKbhtraqxzbm8DVs7LZ9EvFPBfH35D9TfA6JwjPrnZlo6Ldh23N57gK+ZoxZCxwHbqmkYIpSI3RdK5mhrBu6iKwA/hNwj3svwFXAQ26XbcAN1RBQUaqFrmsla5Rrcvk68A+AL/awCBh2XdEB9gHL0w5sNL75zW8C8LGPfQyAD33oQ8mczxo9ePBg7QVTqkH9reuUePJpdnT/d07LEnHo3oTiy9w2pWRJpo15Z2hcYnZKfI/NMObNGP41dlBe0GnjydNMKN7s0RqZRLz5ZefJnUBu4419p2x8+4L2ELd+zeqrAFjqMkDbonK7F7g4+tis0tFi49q9eSW/nC6EvqYALWTI5CIi1wGHjTFPzuYCInKriOwQkR2l91aU2lDJdT00NFT6AEWpAeVo6G8D/lpErgU6gAXAN4B+EWlx2swKYH/awcaYrcBWABEpV/2YN55//nkA7rjjDgCuu+66ZG7ZMqsBqIaeCSq2rjdu2li5dV2kUYUpor2nZYXmNmSw276NXXOOVur3myKfphSdz4/FtVwG2q2T1Wv5Y5MhpNFnlnpNeGQiZJi+6mqtHDhzJBk7fOYYAE/stzVjho6E2izt7faar121LBl7y9LjQNDG48qK3S32s8Xfj88MNRQ6RT3xN5cc6/9tyn6Kqj0lNXRjzO3GmBXGmNXAzcC/GWM+CjwGfNDttgV4uGpSKkqF0XWtZBEp9le/YGeRdwP/3YV3XYwN71oIPAV8zBgzWuL4+v3TpmQCY8yM0z/muq43btpofr39V7MRd2ZEv6v5zYwnTUicGXd26U5X+dDuZvcLduNCXS62bXutNa2mib92XFHx4DmrTf/7Ads/4HvP/r9k7s/7rPbd1W2fDjq7QrPrlhZ7nd27Qq2Vw0etRj563IZCciZ8Ntpcv4KFob7LmpVWM7/+zVcA8DcbQqjxoNPaY3v/ubxaNHErPa+9tzcHGTubbWJUW9SGLyH//lmqFeAs6Wld8KQxZnOp/WaUKWqM+SXwS7e9E3jTbIRTlHpC17WSFTRTVFEUJSNoLRdFaRTix/mCJ/2gmyVmkpTH/5aUrEdvjmhqjjJLE8fh9OGQcb0TP3Zm3Laq27snlM/dvc9ut7rStL2RycW3fDw6HBylEyecKWfItb07F9VocQVVJk8F89ArLnP18YW2fsymC59J5l6/yJ6/IzKh+KzWCWemir+TVmzIY2tTCH1MM0/VK40jqaIoilIU1dAVpVGYabhcvH++th47WN1UbnVGq+t5LTxu+jzmnKHPHP9DMvbS8CsA7By2zs229qD1Tk7ZYyeHrWY8cjbFxzwWaeFTTrZ298QQlzlsdTrogqBBXzhoQyZXLLavzxx5KZn7xS6b/hJ/c+9adTkAly96nZU1qjzpn3TiUMa0VnX1SuNIqiiKohRFb+iKoigZQU0uipIBcnJCK2AiaEpquOSaXmLikrfDo6dy5uL8lh7nBDWddqy7s9ApOjYRYs1HRmwc/cjYWMG5erttbH1fb3cytnixbbhx4Lgtff3HF3YncweP2CzSuEnG6bfb8142YBtuNEex9snnbiAzS0xjSq0oiqIUoBq6otQ7xldWnJ7YoekdmHHObH41xpxKjG4zJ8c275qxhjuJb3ARHJmjEzaM8IzTqhcuCtmXbW3WQeozRZcPhLnlC2yoYW9byPz89727AWhx2vu6haEZx+p+m/k5Phk0+r52Wyzz4BlbJO0Xk88nc7v22pDJybOhR8nze2xW6/NrXwBg7YL1yVyTtOV87hxMXk2X/O06QDV0RVGUjKAauqLUExWo5FfMhh5XSC9xEvuS0oDZ10LpaAm2cD+/96S1q09Ohv0HFloNuq/D7r9mIDSJXjewCoCl3UuSsXZXz/zAaVt1sas1hEDuGrYa96nREPq4oN2GHb560trQT548k8x5Gz1dbQVjA+3W9p5TqdKHZ5o4aWrKHeeaVpf67uYR1dAVRVEygt7QFUVRMoKaXBSlIclvYhFneU5vEkidSWkpl1zFD0WWoIkp65D8/ZE/JWOP7rTZmceOnig4x6gLQzw6YecODYdwR3OxC2VsDaV+z07YTFRvvjl6KphQTp44DUBzVHems9OaQo4O2bK7Z6JM1O4uZyaJnJd9/bYBRqdrRefLDdsdrTxxWzpfUjfOKK1XVENXFEXJCGVp6CKyGzgFTAITxpjNIrIQ+D6wGtgN3GiMOV4dMRWlOjTC2jYpW7M90mvh8ZnStHbvKPRJPV4rBzh0zrZg/PWrLydjx49ZbbqjwzofOzqDNuu16YkJ1zwiqvNy7JytqPj04RBq+JvdrwKwZ7etC3NuNGjQY2M2PHJBT9Dou9y1xsbt+X3TDIDF3TZEsrUtXPPKlSsBWNYV2tiFz22ZiBqG+Lou9ewM9cxEQ/9LY8wVUdeMzwGPGmPWAY+694rSiOjaVjLBXEwu1wPb3PY24Ia5i6ModYGubaUhKdcpaoD/43qC3u06ni8xxvhGgAeBJdMerSj1S92v7RS/5LT7xKQ1p/Bmg/L3t7RGTSDW9dnMyr994zXJ2Ktr9wNw2cClACxo603mdp3cDcD9z9q+qy/u3J/M7XvVxpUn8eLAsePWfDPknKdmMsjlTScd7SGuvKvbOjfXL10EwF8sXZXMbVi0FoC+9pCdemHXhQB0tlizjW94AdDVYmvExE7RNt8co86yQtMo94b+dmPMfhG5APiFiDwfTxpjzHQNoEXkVuDWOcqpKNViVms7XtcrV62sjaSKUoKybujGmP3u9bCI/AjbRPeQiCw1xhwQkaXA4WmO3QpsBZjupq8o88Vs13a8rjdu2lijdV2oIabpjL5S4FSkcTclzlCT8wogpqngXH520jkHTc657P7r+y9Lxi7ps5pwf9tAznEAw6M2nLCjxd5uxsfD3Khzck5NhfOfPGMdpeaEc4Y2B8l6XZu5t78h1F/5i6XrAFjeYzXv1b0XJXOLOy9w8oTM1UlXg2bc2Gu3RNUWvTbeltOCLmjr9U5JG7qIdItIr98G/gp4BvgxsMXttgV4uFpCKko10LWtZI1yNPQlwI9cYH4L8IAx5l9F5AngByJyC7AHuLF6YipKVcjk2k6aPuckGxXuVbAV2Yh9DZe0uuBNzvZ8YfPyMJjsb7XZOFlnQZvVqge77HGLLwi1XHwY4rlzIRlo2CcSjVhNuvnCUPv8svVW+77l8uCnvshp5C1S2AC7w8ma9vThx1oibbzZ67gNYC9Po+QN3RizE3hDyvhR4OpqCKUotUDXtpI1NFNUURQlI2gtF0VpYPLNBzHF67aUQLzZJsUh6MwrzZE5xtd8Sc6b41S0+710zJbDPXToWMEpfRapPb37VN329tTbE5pf/NU66wztagljnc3dTp7mnFeAFhduWTTLs0HNK2mohq4oipIRVENXlAxQqjbL3C9QPDIzqWboa79EYYv7TttEogu7nXNz7Ypkbtxp5r4iI0Bfn62GeKTbls8Z6A9JSp440clr5Ik2nuPILePbKLepSANo8qqhK4qiZATV0BWlzimuPxbOmiLp/amNjovs58/u27DZqZSQRpO7cXIsFKd86IXHAXjuVducuT0nbd8m8nR2FdYab2qyMg4u7k/G1i+8GIDFnaEaQ75mHn+ytJDMWbf5SzuuzrR21dAVRVEygt7QFUVRMoKaXBSloangI38RU0Qc9hfauRVe29ePic0xIxPWQXrqpK1qeFrOJXO+MUZcbdGbdCYnp/KuF2j7cDrAAAAGI0lEQVQqoovmzFXbJJL/nc2zCUY1dEVRlIygGrqi1DkV0fnK0RxT9klGSvgRg0/UaddRdUOvYZ919VrGJkJIo0l5KvCa+dSUfW1pDYlCr6y27enesiRo+b5eS1HtdLaO0DTqzBEaoxq6oihKRtAbuqIoSkZQk4ui1BOViJeuBiXMDL7crjevdDSHWitvXrYGgD8ftY0uRkdDVujYmDW/xJmi50asacZ//La2kBU6aawZ5vT4qWSst9W2lxMXty45ZYCLf6zpP1D9mlWKoRq6oihKRihLQxeRfuAe4HVY/8d/Bl4Avg+sBnYDNxpjjk9zCkWpS+p6bTeQlugV4SmnQcdt3d6z6l0ADHTYRhfPDu1K5nwFxqPDQeP2Leo6u2wW6WuWLE7m3rDYtr3rbu1JxgrDGsP71GqUDfS9zpRyNfRvAP9qjLkM2xDgOeBzwKPGmHXAo+69ojQauraVzCBpYUM5O4j0AU8DF5toZxF5AXh31Ej3l8aY9dOdxx1TR0ZBJYsYY8pWvyq1tjdu2mh+vf1XcxG78Ulqv9hXr6kDTLhmzONT/jXYy0cnRwA4M3E6GRtxYz6Zqbd1QTI30L4QgPamjmSsqck+DTQlNWxSlkCDa+U9rQueNMZsLrVfORr6GuAIcJ+IPCUi97iGukuMMQfcPgex/RkLEJFbRWSHiOwoV3hFqRGzXtvxuh4aGqqhyIoyPeXc0FuAjcC3jTFvBM6Q9wjqtJtU7dsYs9UYs7mcvy6KUmNmvbbjdT04OFgTYRWlFOU4RfcB+4wx2937h7CL/pCILI0eSw9XS0hFqRK6tudCirnWmzuaojZwba6uS4trS9dhQkijDzkcTHnA9+Vwm1IK4p4vTs6ZUlJDN8YcBPaKiLchXg38CfgxsMWNbQEeroqEilIldG0rWaPcxKL/BtwvIm3ATuAT2D8GPxCRW4A9wI3VEVFRqoqu7dlSRDOWlHeJzi4pjaeVilDWDd0Y8zSQZgO/urLiKEpt0bWtZAnNFFUURckIWstFURSlCngHsSlVe7iMc5SLauiKoigZoWSmaEUvJnIEG+vbyJkYgzSu/I0sO5SW/yJjzOIi81XBres9NPb328iyQ2PLX47sZa3tmt7QAURkRyMnGTWy/I0sO9S//PUuXzEaWXZobPkrKbuaXBRFUTKC3tAVRVEywnzc0LfOwzUrSSPL38iyQ/3LX+/yFaORZYfGlr9istfchq4oiqJUBzW5KIqiZISa3tBF5H0i8oKIvCwidd0FRkRWishjIvInEXlWRG5z4wtF5Bci8pJ7HZhvWadDRJpdne+fuPdrRGS7+/6/7+qX1CUi0i8iD4nI8yLynIhcWa/ffSOta9C1Pd9Uc23X7IYuIs3AN4FrgA3Ah0VkQ62uPwsmgL83xmwA3gL8nZO3kdqT3YZtqea5C/iaMWYtcBy4ZV6kKo+GaA3XgOsadG3PN9Vb28aYmvwAVwI/j97fDtxeq+tXQP6HgfdiGwgvdWNLgRfmW7Zp5F3hFsZVwE+wJe+GgJa0f496+gH6gF04H080XnfffaOvayezru3ayV7VtV1Lk8tyYG/0fp8bq3tEZDXwRmA7ZbbeqwO+DvwD4Js7LgKGjTET7n09f/9zantYYxp2XYOu7XmgqmtbnaIlEJEe4J+BzxhjTsZzxv45rbswIRG5DjhsjHlyvmWZJXNqe6iUh67teaGqa7uWN/T9wMro/Qo3VreISCt2wd9vjPkXN3zItSWjjtuTvQ34axHZDTyIfTT9BtAvIr7CZj1//2mt4TZSn999w61r0LU9j1R1bdfyhv4EsM55o9uAm7GtvuoSERHgXuA5Y8xXo6m6b09mjLndGLPCGLMa+z3/mzHmo8BjwAfdbnUpOzRca7iGWtega3s+qfrarrFD4FrgReAV4H/Mt4OihKxvxz72/AF42v1ci7XXPQq8BPxfYOF8y1ric7wb+Inbvhj4D+Bl4IdA+3zLV0TuK4Ad7vv/38BAvX73jbSunby6tudX7qqtbc0UVRRFyQjqFFUURckIekNXFEXJCHpDVxRFyQh6Q1cURckIekNXFEXJCHpDVxRFyQh6Q1cURckIekNXFEXJCP8fp8Ad1R7xG4IAAAAASUVORK5CYII=\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/UCwAAIABJREFUeJztnXmMXFeZ6H+nqrp6s3tze19iZyWBTILjxySEYUnEAHkBgkQWAsiCSAE08wBpxAx5TwghBUIkIPAHS6wwmYACCcswQSzD8EIY1hdIICGQkM2xYztu73a7273XeX+cc+45t+p2dXV1rTffT7L61jl3+er69O3vfqvSWiMIgiC0P5lmCyAIgiDUBnmgC4IgpAR5oAuCIKQEeaALgiCkBHmgC4IgpAR5oAuCIKQEeaALgiCkhCU90JVSb1RKPamUekYp9dFaCSUIzUbWttCOqGoTi5RSWeAp4PXAXuD3wDu01o/XTjxBaDyytoV2ZSka+iuAZ7TWO7XW08A9wFtrI5YgNBVZ20JbklvCseuBPcHnvcDfljtAKSV1BoS6orVWNTjNotb28PCw3nTaptiYqoUURYQv0/U4v9C6/OHhPx7WWq9caL+lPNArQil1I3Bjva8jCI0kXNcbN23kN7/7Vc2vUc4cqur8RF+sKbbe8rzY6c717q5kv6WYXPYBG4PPG+xYDK31Dq31Nq31tiVcSxAayYJrO1zXK1cON1Q4QZiPpTzQfw+cpZTaopTKA9cB36+NWILQVGRtC21J1SYXrfWsUuofgZ8AWeBftdZ/qZlkgtAkWmVtOzNGM0pcF5tQpMx2e7AkG7rW+kfAj2okiyC0DLK2hXak7k5RQRCWRqs5QOt1jjSw0P9V8X2q9f+tpP4LgiCkBHmgC4IgpAQxuQhCi7JUM4Zm/uNjc/Y64VjBbmdwJgFvGnBmAkWpuSBp7MVE+H+WZE6pt/lMNHRBEISUIBr6Isjn8wB88IMfjMbWr18PQH9/PwCXXXZZNNfb2wtAV1dXNPbJT34SgM9//vMATE5O1lFioZ2pJHQwSQt3Y3N6Lji2ENunEHye07Ml+yhldL2MytqfXvfL6Phckqz11tTLvX1USt1ltP9fSVp5ubmlIBq6IAhCShANvYiNG03G9+rVqwGveQNcddVVAHzgAx8oOa7SJJCbb74ZgAceeACABx98cIkSC2mnEk0v1KAdmUBfK6hC0bm8Nu407lBrdxpwtVpsqEEv9hzu2Ogcwe9U0lahSFtPulpcBusDSLJx18Ev0MiQTtHQBUEQUoI80AVBEFKCmFyA22+/Pdq+4oorABgYGACgu7u7Lte8/vrrATG5CAtTztRS8Tmc2cD+yGqvy+nIAVooPqy8CSKQq3i/cmaKhRyazjnr9gtNKtFcYB6a0TOAdwLHnLtWjmzMgTu/w7fc/uW+U6uEa4qGLgiCkBKq7ila1cVarGOR044vuuiiJZ8rySk6MTEBQGdnZzQ2M2O0iVzOvBxNTU2VnOtHPzI1oa677roly/Vio0YdixbFRdu26l8/WPsGF+XQCclADqct6gTNNvFciVvFTtFQG3cb1TkVE0MtYw7Z0q3iY8PfM6ehT8yOAzBy6oVo7uTMSQC6c/5Nuz8/EPuZz/jfT6e1hxq60+Cdk1klOKCr1dArDVvszvU+XElPCdHQBUEQUoI80AVBEFLCgk5RpdS/AlcCB7XWL7NjQ8C9wGZgF3CN1vpY/cSsHWFc+dDQUFXnOHbMf9WnnnoKgF/84hcAPProoyVzmzb5BsJnn302AJ/61KcA6OnpKTn/K1/5SgBWrvQ9YQ8dOlSVrML8pGltl8sYreTo4v2TTC3lWKpTVMe2C/PK4LZihrWCOXq2YEwvRyaPRFN7x4z5ZaDT/9539hkTy/KOvgW/BwTmrchiXKbXa5Odo5Vo6P8GvLFo7KPA/Vrrs4D77WdBaDf+DVnbQopYUEPXWv9CKbW5aPitwGvt9l3Az4F/qaFcdePWW2+Ntrds2TLvfrt3mybbTvMG+MpXvgIka+hJnHHGGUC8vksljs5169YBvhYMiIZeD5q1tpMyPxdb26PYCR8LbkhMlVTuQvHPgFM8E7XLMvIsXguPa9LhWKxKof3pHJSx++R+Bk7UWVuL5tTsKQDG7U/woYw9gVO0O2feinOq9PFXLkM2KXO12EG8lAzZWlCtDX211nq/3R4BVtdIHkFoNrK2hbZlyYlFWmtdLhxRKXUjcONSr7NUnO38kksuKZkLtYMvfelLAHzsYx8DYHR0tKLzu9DEUOv/4Q9/CMBpp522KFnn5lyCREtFeb7oKLe2w3W9cdPGSs9X9nPxWCXautMCk2q5JB+QoHmWuUwtarkk1VsvvU74IX7NWI0Zu+20coCZwpT9OQ3Asg7/Zuvk78t7e7m7V+XeIhJldUOxBCwVmwzv11Lr4VRDtRr6AaXUWgD78+B8O2qtd2itt1USQykILUBFaztc1ytXDjdUQEGYj2of6N8Httvt7cB9tRFHEJqOrG2hbakkbPGbGCfRsFJqL/Bx4NPAt5RSNwC7gWvqKWSlZDLm79Nb3vKWaOx73/seAL/85S8BeO6556K5l770pUC8ycTdd98NlDe1bN68Odr+u7/7OwA+8pGPAHDeeedVLb/j61//OuAds0J9aJe1XYtmCEkOvbJUcK2kTNSo/kpCZqobKwSNN+Y5sdnPmkbmAvPKqdkxwGeAmjGTIXpq5pSVxcvVkekAYGLO/45P2e2enDHNdJSXpsQMk4nVwcGO1adhxWKpJMrlHfNMXV5jWQShocjaFtJGqqotOu34u9/9bjRWKBit4NJLLwXgve99bzR35ZVXAvGKiq4BxbXXXgvEQxQvvPBCAO68885o7Pzzzwcqb3BRjs997nMA3HLLLVWfQ0gftdD6kiokLpVwrTvt24UJOgcllGq4YdhiNqHiYXScSxgKNPS5gjl/Z1B/RWfNtfOZvD2/33/cau9jM+PR2Oi0efvuzS0rOVdxVUr7Ra38Vgb8G4ar7+I0dR1LgmqfsEVBEAShxUiVhv7mN7+5ZOyaa4wJNEl7f8Mb3hDbB3wS0Ne+9jUAzj333GhueNhEMyxbtqxqGffvNyHO3/72twG44447ork9e/YAcPLkydIDBSGBWrwZVn3tBDmcVhravZ32Pm3DC08FiT/dWfN27JJ9zLmc7Xwuds5wv/hYvGfB1JyvYOrkOjF1Iho7Pm22h7pWANBLaRhiUvXHxJDGotuuAh25GfZ00dAFQRBSgjzQBUEQUkIqGlz09ZksMFdXJQxDvPjiiwEYGRmZ9/jHH3882j7nnHOqksGFTDonLMC+ffuAuJPzy1/+clXnFyqjlRtcLLptXBlzSrm5yqssLkKWhAzIMDTRhSK6sMKRCd9kImdDB10I4eTsRDTX22HMl/0dA9GYq+FSwLWb898nmzFW4kygizrzjjPp7Dq5M5r76e7/BuC/nn4yGhtcZkw0N/yNMblesOKCaM6FMuaz3lEafe+EjNfi5hfuu4bfo2zrOmlwIQiCICSRCqfo5ZebsGFXP/zjH/94NFdOM3e87nWvi7adVr1YTp0yjp577rknGvvwhz8MiJNTqI5yGn1JXZg6aOXznd9p4zENnbjjM3RydiijtTptdkr5N2intWeClm9RKCPm5yw+zDFJn41qs9h78tjhv0RzX73fVEvds99XK9241jwnntzwLADnDPi3cqeZZ7V/NJZroeeuWVClDa1VG9VyEQRBEFoMeaALgiCkhFSYXIpZvXpxJaxdO7il4OLLb7jhhiWfSxAqpVpTS9kGDgn7xR2BrvGE1wddLZPurDG1zAX1Wpxp5uSMydAcmxmL5qL9s37/4uzRXFBtxUldIHTIxmvE9HTE49IBmPLnH58wJp+/HDbm1W1rXgh2M3NretYF8uRicsVMLkGUOsTj14mySBvX9EI0dEEQhJSQCg39D3/4AwDHjx8HvJMUfFbn2NhY6YGWq6++uo7SCULtKc5aXEjzq0QzTApNTNLanUYc79NsNGCnmTttHODwxGEAnh01lU6zgQN0pt84PDuCcD/VsRzwVQ2T2rqFYy5scdRe8/EjPmxx74h1hs54zXlmxuz/1H5T6v6xNT5s+Yx+04xmZfeqaCxy2Lps2ITIWF9tMsgwTSgLU29EQxcEQUgJldRD3wh8DdNbUQM7tNZfUEoNAfcCm4FdwDVa62PznaeeuLrhjz76KACvec1rorkLLjBJA7/+9a+rOvfUlK8L4ezjb3vb26IxV7Fx1SrzF/1Nb3pTNPfjH/+4qmsKjaEd1nZIORv3QmOLPW9kC7ZaaSHBJh5q2lGyEU579zKs610f+xna112FxFzGP4rctaL646GtPsGOPTpt3sz/e5/peXDvLx/0co2ccgdGYyf3mf1/d8JUYDx86Hg097fnnwXASwZ9DafeXCb2fcPvVvx9CzH7utPWG6c3V3KlWeCftNbnARcD/6CUOg/4KHC/1vos4H77WRDaCVnbQqpY8IGutd6vtf6D3T4JPAGsB94K3GV3uwu4ql5CCkI9kLUtpI1FOUWVUpuBlwMPAqu11vvt1AjmtbWpuDK4Bw4ciMbe//73A/Db3/4WiNdaqYSODu+seec73wnAN77xjWjs1a9+NeBNLp/+9KejOXdN56wVWpdGrO3FlrqtJCSx3D7xMq/aCTH//mHDCmdKsEOTQclbN9dhzSXgw/1OWPNHaFbpisIcbWnduaBBRFGpXICM3c5GTsVS004YHjhpr/3k0ecBODYaBEBkM+7L+bFR23zjuDGn7pzaE03NzpnzPn/+89HYSwZeQozgHjoHaZITufEFjRdh3FFKLQO+C3xYax1ruKnNSkiUXyl1o1LqIaXUQ0uSVBDqRDVrO1zXhw4dbpCkglCeijR0pVQHZsHfrbX+dzt8QCm1Vmu9Xym1FjiYdKzWegeww56nrn+0JiYmSsauv/56wIc23nbbbSX7vO9974u2XYNmp024KorgHZ6h47MY13gaYMOGDYBo6K1MtWs7XNcXbdtal3VdzrlZabiiP1m8AUXSucK/WzpqKWd+ThXC+iullQidpu3auYUat2viPNA5CHiNGmDCav4zQVs6F8K4zIYvdmV9otCsNvuFyUk7R02YYtZ+xwsvOCuaG1k1BMDTO32NprmnrX972mr5J3y7vGMnTN2lZ4/70EenoYeVFKNzFVVgjCUWRW9FJYfVjQU1dGWebF8FntBafy6Y+j6w3W5vB+6rvXiCUD9kbQtpoxIN/VLg3cBjSqlH7Nj/Bj4NfEspdQOwG7hmnuMFoVWRtS2kigUf6FrrXzH/S8Pl84w3BdfYYvv27dHYXXeZYIVbb70VgGuvvbbkuK1bt0bbzezRKDSWdlrbME+8uBsL12s5x2eSqys6NnD2RY0bDDnlzQ1h/Hm0v92zuLcoeHOMi1+fDcwrswWTtTluzTLge4Ku7ja+6Jmc3//wpMn8fH7MOzLHZ4zZ5rT+tQBctOa8aG7Fxcbk8shBX1L38z8w+SEHHrNmmJw3VLg6L//x1MPR2LlDxuTysqG/sd/fPzajuHhdanKpd0njJCRTVBAEISWkopaLw4VDffOb34zGnJPyPe95DwBnnnlmNDc4OFhyjh07dsQ+h9p+Pp8v3r2Ew4d9xMPo6GiZPQWhMmqq6UVOvFJiFQyt5hyFLyZkayY5WJ3GPT3nM6w7snl7nDmHc3YCHJ8yDsrRaf+7cmTyKOCzSMNGGk57d1o5wEBnPwDnrzC/60OdK6I551A9q//saGzLuzYC8PU/PwDAM7v2R3MdHTl7TX+Hdp80mehn9JlnR29uWTSnop8ufNFT7o2qXlUXRUMXBEFICanS0B1h4sJNN90U+7lihf/r7RJ/Nm3aFI098ojxjd1+++0AfOYzn4nmXvWqVwHJtVycNv6JT3wimnv+eZ+cIAh1pcJmw77mSljB0E2WJsU423hYDTEpRM9VPHQ1WUItvNO2dXOJSGFCkgtXDEMT3f7uTWC64MMKB23o43lDXdHYQH4w9jO08bs3jE58qOVLB42N/R+3mubyPxnyDb4fO2giVPNZf46jkycAnzTVmfXXziT4EyKa4IcTDV0QBCElyANdEAQhJaTS5FKOMPMza1+rfvOb30RjztTiePbZZ0u2XSikIFRDLUNjF18q12ZAx46Ll74Fb0JxZpVZ+zk+V1r7xZlmXGu58NjJOZPJPTHrM7qdGWPP2N5obHLWOD43LjOZ1n35/mjOZaL2dnjHpHNSOsdtaKJxmaXhNU/OmGzQLms6OWNgQ3BtI+uJoGy2k2d8diz2/SG54UYzEQ1dEAQhJbzoNPTTTz892t68eTMAd955Z5OkEV7MqMCR6bTdpLFaoIsaKRO7jpmbCTTb6cJUbP+w1ooLPwwTbLqs5pyxOmLoLMziQgHNuaaCWi6urks2CItc3bPSjplz9OZ6g2uXOiGLE5ac1g8wZrXqsRmfuHRiyjg53ZvDvjFfqmfEtqo8dNLXilnZY942JmaNrOG9yGaLHqEVOqfrhWjogiAIKUEe6IIgCCnhRWdyKVf6VhBST6Xx6tbc4zI/Q/LWvJILTC4qalRhM0wDc5EznXTaWPM1PeuiObe9Nhhz5h7nWA0drNmo9+j8JqPQKbrnpKn5Mh406JieMyaT41PGOfrMUZ/dfWTc7Dc3FzTQmI3fg6R6LZkW0Y1bQwpBEARhybzoNPTQKeoIW8oJQprJJIbZ2Y71gebpQvQOTRy0n71TceMyk1nd1+HDCb3m7M5Y6tB1mnp4bdfazoU0gm9eMabMz3zWZ5b2KpOBGr4dzNm3DufkdGGJAKdsuGLSG8P4tJl7buRQNHfokHGYdncHdZvWmyqOHZmEx6U7byahgUgTHKSioQuCIKSEBTV0pVQX8Aug0+7/Ha31x5VSW4B7gBXAw8C7tdbT85+pNThx4kTJWFgj/ZZbbmmkOEITSdvadiQmuzhtMRoKkoJsOOHknLczj06b3xOn4U4F1ROTwimdDTkpwca1o3NhhQcnRqK5g/YNoBBr+myulbEydwd1XrLdRrvuCuzq7pouHDKs3OjmQu3aXWtqzvyXzs762k9Hj5tjh+iLxlxdF1enJvyOriaOD6Zs/bDFKeAyrfUFwIXAG5VSFwO3Ardprc8EjgE31E9MQagLsraFVLHgA10bXJR9h/2ngcuA79jxu4Cr6iKhINQJWdtC2qjIKaqUymJePc8Evgg8CxzXOipqsBdYXxcJa8wXv/jFaPtd73oXAFdffXU05rJGR0ZGENJPq63tWmSHlmszp3EZo97EMWPrnTgzC8Bxu+1MFX35VdHcclsaNyyD67aTS+vGM0QPTByI5naPmrDCgS7vYO22NVacozWs2+JCH3NhOV/73VxNl1XdXlZXWybM7pyxoZh9nWb/wSFvXlk1asxOK4a9PGt6TVle13AjzFZ15q3iFnzhXCOpyCmqtZ7TWl8IbABeAbyk0gsopW5USj2klHqoShkFoW5Uu7bDdX3o0OGFDxCEBrCosEWt9XGl1APAJcCAUipnNZkNwL55jtkB7ABQSjW9JNlf//rXaPvmm28GfJMKgHXrTIKDaOgvLha7tsN1fdG2rVWt61rWaknSBpOcou6SoQbttPWOIDxwsHMA8Fpv2LCix45lEtrSRTVjAnmiJhNW89607LRobmW3qdsSatCOFZ3DVhbflCZ8K/DfzfxwGv1g51A05bTqbMZr1XOFOXuYOfDwKV/7pStnznFG0J5yVa8/X8ml7X0N70UzWVAKpdRKpdSA3e4GXg88ATwAvN3uth24r15CCkI9kLUtpI1KNPS1wF3W1pgBvqW1/oFS6nHgHqXUzcAfga/WUc668NnPfjb2U3jR0ZS1XUvNPDpnrKVcGdttVNXR63IulX8w7zXhftfOzVVPDML+nP06vIq7pgsAjNVWtzZrZ0N3qf0QJBEF1RCHbJu57pwJTQyrOvqvEbxhuEbWVoawXZ7bDt8+dMbcA9dcenneh0CuWWbePlb2eLv68o74G0l4f4tT/pthNw9Z8IGutf4T8PKE8Z0Ym6MgtCWytoW00RqGH0EQBGHJvOhquQhCu1KpWSUKHQydos7MY5142UCXcyaN0FRRKA591OG1k2SIyzMbODkPT5ps0H3jxrc8csqHLbr2bhuW+8jQ05ZvAWCZrRUTN2sYOeaCERdq4TNLeygm/G7OAeta0OUCc9LYtMkenZj1ZiHnNI5CFMMaLcX1WsLPdTCtLYRo6IIgCClBNHRBaFFKNG1dGoZYvC8EtVwStOpMlAgTJMAkhNwVj+jAyZksqxOxUDTinaiuauLRSZ/A9Ju9TwPQkX08Gut4mXksnT90Qez4UO5ColPUMJFQkyYMK3TVGJ8b3QXA7hNBtcVx45w9Y9CHKqqiao5zQY34OWW2XfP5bBvUchEEQRDaAHmgC4IgpAQxuQhCk6g4drzK86qEBgsq8o16Xa4SB2uSWSaMBY9MOtbB2EFnNOeyTNf1GsdnZ9bPnda3AYiX53UOzOfHdgG+xG44NzE7GY05Z6jLOg3NMc4Bu6yjNxpz1zo2aUrljs94B+6pcXPeIxOB2ca2qjthzTdh1qwzB2V11spS2X2tF6KhC4IgpATR0AWhBUiskBhNOueop5zuV1bjrlBpLCePmwuzQaOm0tZxOD3nNehpqxG7ffo6fBZmT58JMRwPMkVdu7s9Y3sBeObYrmjuxLSZ2zvq6684Th8wtV829a2NxpyMLvsUfLhivt84aYe7/dyTK3YCcHRyLBqbtI0wTk6bsaku/zbRWdQwW+ugEmNCy73i/5uY47oGLetEQxcEQUgJoqELQpNYvA19YS0+PG+S3btSeSrbP+nY0nN05UwN846CsTeHTZw7XVu3BE3VVXA8Y2BTNPfCuLGnv3DShz7uPHIUgJExo0GfWuPfDtb0Gq29O+fb2PXnTSXJmYLRvAe7vIY+bcdOHnwqGjs4bs7vNPlTQcPsSNu3P5PvSeMQDV0QBCElyANdEAQhJYjJRRAahNbxzM9YGd0ki0vx/uVe4St1qLlzJuyeVPslOVyxtM2cCxWctVmUx6aPRnOuros7vyuZCz7M78ik39+FFWbtXDZWa8WEEz6534cyvvCC6RjV020clMM9vpbLWYPGXNOT82MuY9WFQGaDlnLue5yY8o7PSWti6e8yIZD9+bBdXrc9f2/sOzYL0dAFQRBSQsUaum0C8BCwT2t9pVJqC3APsALTZPfdWuvp+ogpCPWhZdZ1QmU+72a02nIZx2mlSSxRyGGgXbvKi7N6tmS/DDZhJjj/5NwEAHPB/q5io6v54hpDg9e4XQhh+GYyYc91ZPJINOY05+VRAo+/zsj4MQD27fP1V06cNBr0qlXG2XnusA9bXL9s3bzyOKfo4eDaB8bN9vFJ71idLRi5R8bMXH/+hWhuVY9JZhqw5y/XoBuo/E2qShajoX8I057LcStwm9b6TOAYcEMtBROEBiHrWkgNFT3QlVIbgP8J3GE/K+Ay4Dt2l7uAq+ohoCDUC1nXQtqo1OTyeeCfAfcOtAI4bruiA+wF1icdKAgtTJPXdRg7nugVje21lNogzhTgTA+hCUJbp6AzQYRklDE3hCaXsRlTAyU00SzLmVvoHIz9Hd5x2Gsdhs5hOhbEoY9PGnPJkQmf+Xlqxpg7Oq3z8viU3//BnbsBOHjE7z/YZ3p+blljzB89ua5ozjlkw1oxkzaLdXTafI+jk8eC/efs9/bf96RtevH8CRP73t952N8Lmz1a6Lb3cyFHd51ZUENXSl0JHNRaP1zNBZRSNyqlHlJKPVTN8YJQD2q5rg8dOrzwAYLQACrR0C8F3qKUugLoAvqALwADSqmc1WY2APuSDtZa7wB2ACilmhvTIwiemq3ri7ZtrcG6Lj1FgaLwwKU41IqcrmHIIVarTmp6EVUPDI7vyBjNWRf8mNP4ndZ+KmgyEbVusz87s16DdjVQ9p30YYg/+ZNxaTy3ez8AM7PB24S95OYNq6Kxa15p+nm/ZsPFgA93BJ8hGoYturDJMVs/ZjLQ3nMZcy+W5/PR2OSs+U7ZjLsnPsxxpigkM+n/KKkGTyWO7mpYUEPXWt+ktd6gtd4MXAf8TGv9TuAB4O12t+3AfTWVTBDqiKxrIY0sJbHoX4B7lFI3A38EvlobkQShqTRpXXvdLaIogacQatBRw+KMPSoh7DHQqgtWg3Z28tBenhTK2GlDByMNPVAke3PGZt3DsuAchdg5wrZxxd8ntN/PaqPh9nX6c02cMhrz+JPWlDUTvE2sMhq3Xu+/29NHXQjj/wNguHsgmjt36CwAlud9hcdlHeZaA50DVix//plOI89wz2g0dmTChFbms05799q+09Zd2GaocZerb1MvFvVA11r/HPi53d4JvKL2IglCY5F1LaQFyRQVBEFICVLLRRCahiq/pZwzMaGeSvFWQqZpfP+4WcWF80HcBOLI2zZx7tqh6y4TtJCLzq/jTS/yCeV8venImzhWqtUAbOn30aFbtphMz6MnTLhiT5e/XneXcVbmOvyj69GnTSjjn9TzAJy9eV00t6pnBQCn950RjS3rNCV11/SY/ULzk2szt6b36Wgsl3kM8KaWLf0bo7lBa7YJ68FE3zuqm5NQ2rhOMY2ioQuCIKQE0dAFoUUpdnzGcVpv/HN8j6SmF+acLvQQvIYetkCLHKpRV+nyzY/924RyO81/rmDSyfG69ZdFY85p+e1ek5A0OuXrqhwbMw7K0RO+YuPBgyYxaGLKaNq9vT4scuYc8ybiqiGCD5t0cqmM/25DneaReO6gd+o6h6erXbOu178BOGdrYlVKaXAhCIIgVIs80AVBEFKCmFwEoRVIyDB0FopyWpeLLw8djWE8uceVw7XZjoFjM+vquxRmSw9LMq/YsSSTQqKzryjEPjRPuBo2PTkfhz5ke3z25Mzj6dkRX8vlhDW1HD/uTS6Hj4/Grp3v9Oaktb1rgHhcvIsdd/csdGc6UUMTzcpu40Qdt5mly6Kyvr7BhSfsE9t4fVk0dEEQhJQgGrogtAKR43B+jTjEaZcu0zIMvXNOzkxCKJ07VyboQefrsPhQxg6dt/vPL0PSWFmtPakWjQt3DEIn19pwwjeebmqzHDr1s2ACip9uAAAL/ElEQVR3s39noIXn80b7Hh42FR5v/B/ewXr+0AVAcps55+QMv0chynj18rhqkZ32rWZ5h886ded1IZlJdVvqFaKYhGjogiAIKUE0dEFoBZK0VzcWNYv2uO3i5sxmrjR5JdLCbUJRWMt8ctaEAnZkvdbbnfU25MVQiTYaavGund3jx/4cjf12/+8BeOzgHgAO2xZzAJ02sWjVkNeS160eAuC1p50NwKvXvjqa686aZKC4jyFeu1xlvPautNFxYy3rCqa2jLOr5zOliVVhO75mIhq6IAhCSpAHuiAIQkoQk4sgpIBsxv8qu9DE0MxAUeu5maCWizMpuJ8AQ7beSb1x5pewRdzek6Zs7umDRoaXr9kSzeWz5nsOdw9FY8ttGOGWPrNfb4cPgZyz9yB0Gs/Ya7ns1qz29+7UrDHvHJ/2bemm58yxg3lzzdDBGtXIKasbl5Y9rheioQuCIKSEijR0pdQu4CQwB8xqrbcppYaAe4HNwC7gGq31sfnOIQitSFusbVcnRYdJKwbXgCIX/Cq7xB0VOkqLQhinA434yOQRAPaPj0RjK7tMi7dOmziTW4LuVxzKGH52dVW2Dm+Lxk7vOx2AY1NHgbj2nrNvIr1B4o9zVjrNPEzombWa+XjQmNo5kp02PmEds+Db0oVhi8Nd5k0ha52nSaGZmYSqlE3oEb2o/6XXaa0v1Fq7O/9R4H6t9VnA/fazILQjsraFVLAUk8tbgbvs9l3AVUsXRxBaAlnbQltSqVNUA/+llNLA7bbj+Wqt9X47PwKsroeAglBnWn9tl2le4RtQhOaYhMxMHZ8L6704M8OuE/uisfHVZmygQudocex7rHRvYm0Zg8tm7cr5Pp1rrJlnZZepwzIVmEQK9rxh+d9MdE3DbOAAnZwzpXedeSWU7dCkcb4emzwazXVbOdb0+P/ytT2++Ubxd3OmFmcKyhDWqWk8lT7QX6W13qeUWgX8VCn113BSa63tL0QJSqkbgRuXKKcg1Iuq1na4rjdu2lg8LQhNoaIHutZ6n/15UCn1PUwT3QNKqbVa6/1KqbXAwXmO3QHsAJjvoS8IzaLatR2u64u2bW3auo7qhQTaeKSxBo7QrP3V68oZ7TcMUey2jsneDq8lR801aiFjYoOOsgcAkHPHBd/NhR/mVBCmafdzbx06qKyYLeRKZMhaLbovv9yeK8gUtdcKQx8z0bG2Dk6wv5Mj6c2kkNDaL7pOs1rQKaV6lVLL3Tbw98Cfge8D2+1u24H76iKhINQJWdtC2qhEQ18NfM/+5coB39Ba/6dS6vfAt5RSNwC7gWvqJ6Yg1IWmru2l6GjF7eli775RmGNp62ln4+3K+jZtw7be92l9vsa4qyxY7avHYjXQcu3aMsG5oqQeFX43pzmb79apfK2VnK3EGCZeuXo2bv+erH8zcQlXYZ3zqFWdS0QK9GCfZGTmml3TZcEHutZ6J3BBwvgR4PJ6CCUIjUDWtpA2JFNUEAQhJUgtF0FoFglmgyQiy0ksfNE5LZ3pZQEThzPDWB2uMzC5rOleC8Bw18pobDC/AvAmhUY2aXDmFx2VDfbfu0MZE0qSozVJQpfhmg/CHN19dGan2cAcw5w5S1he2Dliw1DJ4quqBDOXM+k0MmNUNHRBEISUIBq6IDSJSrXeKCQu2F0VOepCzdBrtIFGr+OJP07TBcjnjBMxDAXssE7RTBmdL8mRWc65uVh8uKCXoVpnq0pwZLrz60KpzBOzp6LtKWVCPPvzpsWdCYhy8sTlioWP2mYZ4duEVFsUBEEQKkI0dEFoE0LtzinkTjPPBFqgjhpOBwcXqW6h5u00yLDOd7WaZKWNoxd7jsWQVHYgrA1/bNqk+odvJI5O215uOigf4MIcc0n2+zK+i0wFCVUL+j4WiWjogiAIKUEe6IIgCClBTC6C0CCi12vtfizOFJG8f0LNFfvBOeVKd4ibXHx43eJe/+vt4Kv2/OF9ci3o5oJmH87hOdA5CECn8iGc7l6EGZ+uwYYPp/TmGx3VcIlXfIR4hmujEA1dEAQhJYiGLghtTJRzlNSIWHlNMku8BZ2KOUXjSUqVUssQxZClyhGvSW7mwlou3UHtdYDJoN66S0DKBRUbu3Pm3mWtEzXU3p22nikKhYSgzk4DNXXR0AVBEFKCPNAFQRBSgphcBKFJxOLKy5gvormglkvxVnLWZvjBxaY784oumSpnGUgyG9TSRFPuXAvFapc71pmaOjPe8bmiaxXgW9uF7ficqSU0nThziovvnwsbVzgHtCptpFEJOvg/rUVMumjogiAIKaEiDV0pNQDcAbwM84f/vcCTwL3AZmAXcI3W+lhdpBSEOtGMte00sZh2ltDCrGQuoZZLWE2k9LjwQ3z/+NzCTtFQrlpmkdYCXdREeyFnbZQhaptYhNq7uxdJNWySFOgoy5ZSB2gjnaGOSjX0LwD/qbV+CaYhwBPAR4H7tdZnAffbz4LQbsjaFlKDKv7rVrKDUv3AI8DpOthZKfUk8Nqgke7PtdbnLHAuaRIt1BWtdcVqUa3W9kXbtupfP/irpYhdomXG5spVNVzg97eEBDWzEk0y0YZe4zoktSLpXsbqu9jtpCbO86duhZ9VyWzVyVkV3sPuXO/DWuttC+1XiYa+BTgE3KmU+qNS6g7bUHe11nq/3WcE058xSeAblVIPKaUeqkhyQWgcVa/tcF0fOnS4gSILwvxU8kDPAVuBL2utXw6MU/QKarWbRFVBa71Da72tkr8ugtBgql7b4bpeuXK4IcIKwkJU4hTdC+zVWj9oP38Hs+gPKKXWBq+lB+slpCDUiZZZ20mO0miuTMigroEVs15mgmaRKF9wmypu21fJtZrg+CzHghq61noE2KOUcjbEy4HHge8D2+3YduC+ukgoCHVC1raQNipNLPpfwN1KqTywE3gP5o/Bt5RSNwC7gWvqI6Ig1JWWWttJWmM5h2ktNcRW17yXQvjddFE7vlqfv5lU9EDXWj8CJNnAL6+tOILQWGRtC2lCMkUFQRBSgtRyEYQWp1Ve59NCmu+naOiCIAgpYcFM0ZpeTKlDmFjfds7EGKZ95W9n2WFh+U/TWq9slDAOu6530973t51lh/aWvxLZK1rbDX2gAyilHmrnJKN2lr+dZYfWl7/V5StHO8sO7S1/LWUXk4sgCEJKkAe6IAhCSmjGA31HE65ZS9pZ/naWHVpf/laXrxztLDu0t/w1k73hNnRBEAShPojJRRAEISU09IGulHqjUupJpdQzSqmW7gKjlNqolHpAKfW4UuovSqkP2fEhpdRPlVJP25+DzZZ1PpRSWVvn+wf28xal1IP2/t9r65e0JEqpAaXUd5RSf1VKPaGUuqRV7307rWuQtd1s6rm2G/ZAV0plgS8CbwLOA96hlDqvUdevglngn7TW5wEXA/9g5W2n9mQfwrRUc9wK3Ka1PhM4BtzQFKkqoy1aw7XhugZZ282mfmtba92Qf8AlwE+CzzcBNzXq+jWQ/z7g9ZgGwmvt2FrgyWbLNo+8G+zCuAz4AaZX1mEgl/T/0Ur/gH7gOayPJxhvuXvf7uvayixru3Gy13VtN9Lksh7YE3zea8daHqXUZuDlwINU2HqvBfg88M9AwX5eARzXWs/az618/5fU9rDBtO26BlnbTaCua1ucoguglFoGfBf4sNZ6NJzT5s9py4UJKaWuBA5qrR9utixVsqS2h0JlyNpuCnVd2418oO8DNgafN9ixlkUp1YFZ8Hdrrf/dDh+wbclo4dZ7lwJvUUrtAu7BvJp+ARhQSrkKm618/5Naw22lNe99261rkLXdROq6thv5QP89cJb1RueB6zCtvloSZWpsfhV4Qmv9uWCq5duTaa1v0lpv0Fpvxtznn2mt3wk8ALzd7taSskPbtYZrq3UNsrabSd3XdoMdAlcATwHPAv+n2Q6KBWR9Fea150/AI/bfFRh73f3A08D/BYaaLesC3+O1wA/s9unA74BngG8Dnc2Wr4zcFwIP2fv/H8Bgq977dlrXVl5Z282Vu25rWzJFBUEQUoI4RQVBEFKCPNAFQRBSgjzQBUEQUoI80AVBEFKCPNAFQRBSgjzQBUEQUoI80AVBEFKCPNAFQRBSwv8HL6VqZd6lpcIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnWuQXEeVoL9T1dUPdUtqPSxZ1sOykTCIYW3LWhawgcEedsFrwESAMGBCQTgwOGAxERPM4t0gCCJ4OcKB8Q9eChhGgL3GwNgmwMws6zEDyxoPAswY/MK2rJf1cEvqbkmtflbuj8y8N6vqdvWt7npenU9R7luZ9+Y9VZ2dPveck+eIMQZFURSl88m1WgBFURSlPuiCriiKkhF0QVcURckIuqAriqJkBF3QFUVRMoIu6IqiKBlBF3RFUZSMsKAFXUTeLCJPicgzIvLJegmlKK1G57bSich8NxaJSB54GngTcAD4LfAeY8zj9RNPUZqPzm2lU1mIhv4q4BljzHPGmEngbuDt9RFLUVqKzm2lI+lawLVrgf3B+wPAf6p2gYhongGloRhjpA7D1DS3V65cYTacv6Gs1YohgTS1Pwzrn4ti+cPvHx0yxpwz13kLWdBTISI3Ajc2+j6K0kzCeb1+w3p+9Zt/LT/B/iBe0Y1foDV/klIjA91L96Y5byEml4PA+uD9OtdWgjFmpzFmmzFm2wLupSjNZM65Hc7rlStXNFU4RZmNhSzovwU2i8gFItINXAf8uD5iKUpL0bmtdCTzNrkYY6ZF5KPAPwN54O+NMX+um2SK0iLqObdNaAdPYWqpdkY9nANKtlmQDd0Y8wDwQJ1kUZS2Qee20ok03CmqKGclXhuX2vTqkrPLr1VnqjIHuvVfURQlI+iCriiKkhHU5KIojWQhZpIq1/oedZQqIaqhK4qiZIRMaui5XPz/qbe97W0A3HvvvQD86le/ivquueYaAEZHR5sonaLUiHeOBhq718xr1f+TrquHll9Pd22znzoWInu7PSGphq4oipIRMqmhb9myJTr+0Y9+BECxWATg8ssvj/q89v69732vidIpyuxU1ZwXlumrYvxqbRW3Tjl+tfPa1e4fylPrt1p+fqs/m2roiqIoGUEXdEVRlIyQSZPLW9/61oq27du3A6XmmPvuu69pMinKgkltZml+Rpg0o9Z65/k6KxfyCdM4jWv9LTTTDKMauqIoSkbIlIa+ZMkSAG6++eaobf9+W3jm17/+NRA7SRWlHUnU5qpo5snhi/MNamwPKqVO+zmk4uyq2nFSnh33XVe7rtWOz2qohq4oipIRdEFXFEXJCHOaXETk74FrgKPGmL9ybcuB7wMbgeeB7caYE40TMx1XXXUVAOecE9dS/fSnPw3A4cOHWyKT0r500twGSkwEEpkXnIkgMMtU7ielomWh8dazn9Fu+06r3aYzTVLVSKOh/wPw5rK2TwIPGmM2Aw+694rSafwDOreVDDHngm6M+SVwvKz57cAud7wLuLbOctWN1atXs3r16laLobQhnT63wWrqUoNWbEir/9ozDUUMxeDK2V7ld0jqSyOZif4lI7O+klrPNuZrQ19tjDnkjg8DumIqWUHnttKxLDhs0RhjRGTW/w2LyI3AjQu9Txp+//vfAzA8PBy1ebv6wMAAAKdOnWqGKEoGqDa3w3m9fsP6pso1F+ns5EnBfdXyr4eW+WYH9c3uC2gJdcip0yjmq6EfEZE1AO7n0dlONMbsNMZsM8Zsm+e9FKWZpJrb4bxeuXJFUwVUlNmY74L+Y2CHO94B3F8fcRSl5ejcVjqWNGGL/wv4a2CliBwAPg18EbhHRG4A9gLbGylkWvbu3QvAH//4x6jtDW94AwAXX3wxEO8YTYsvggHwkY98BIAPfvCDUduBAwfmJ6zScjppbpcThSumNj6Ysnem8tgktCWQeE9nhpBEudIk1U0av81MLR3AnAu6MeY9s3RdVWdZFKWp6NxWskamcrl4fGZFgCNHjgDw4Q9/GICHH3446vNFL5LYtGkTAF/+8pejNl/a7sUXX6yfsIpCyuC+xBJ0psr1s2vcJe+qFaM27m8kKe9JQOQ6nuO8hCsTJJLEM5S50a3/iqIoGSGTGvqZM2cq2t773vcCcWgjwO23315x3hVXXAHAd7/7XQA2bNgQ9V122WUATExM1E9YRZmTpPyDC9Rb57CXe828SLFChJzTA0XqqQ82z15erWxcqgQGbRaqGKIauqIoSkbQBV1RFCUjZNLkMj4+Hh3v2GFDinftsuk5br311qjv3e9+d8W1W7duBSCfzwNw2223RX2PPfbYnPfu7u6Ojj/2sY8BsHbt2qht6dKlAFx55ZUA9Pf3R329vb0AfO5znwNKHbLhZ1LOLiLHZ+gUlbJiDgkmlKIpBm3+WFzfTNV7VmRzDMwrSWaJOPSxVL7ksZuHiX7OHgBRqtcmOZkl+G97oxq6oihKRhDTRAN/tZwvjcJr2p/97GcB+MAHPhD1dXXZB5Rly5ZVXLdz504APvrRj0ZtMzNWq1m/Ps7d4TM5es372mvj5Hw33XRTxbiRZpXie7/88suj40ceeWTO8xUwxjRdkdp62aXmV7/51wWNkZTNvFzTTptPxTs0Z0It3M0779CcLk5W9FUbM+zz2noudIoaM2tf+UahZjk7If6cR8fjeghdYv/uFxVsfqe+/KJU4+cl747CvPRzy1OPzzvQvfR3adKnqIauKIqSEXRBVxRFyQiZdIqGeDPJLbfcUvITYMUKmyUv3D3q484fffTRkusBvvGNbwBw9dVXR22Dg4MA9PX11V12HzsPanI5WwjNKsUy04kJnJz5nP3TFSrNJbEjsNJEExk/EmLIq5l0SvuScr/4A2ceKjG5NJZyU0voAJ1xxyenRqO2x48/AcBUcRqAly17adS3steWr1zUFQcrFHIFALpzNmjBf/cAuSaZk9KiGrqiKEpGyLxTtBq+mPRvfvObqM1nbPRhhaFm7HeKLoRyp2i4q7WnpweAqakpIHbaQvLu1AceeACA6667bsFyZYVOd4oWA+2y6DTISEMPdNEupzUmOTJN5ESNyZU5K2fc2OF5MyZoK386CO/tnIq5yElYGQZZyPdEx96ZmJRFcb6/rKSFxGvmYbjmtPtMEzPx39mZ6TEAjk0MWVmlEMvj/j79ZwSYKtq/x/P61wHQk4+fxuPP5nbPJsioTlFFURSlZtLkQ18PfAdbW9EAO40xd4jIcuD7wEbgeWC7MeZE40StPxdeeCEAGzdujNq+/e1vA3EY4vLly+c9/okT9ut4+umno7Zf/vKXQJyzPezz9vuXvtTa9D7/+c9HfYsWVYZWvfa1rwXiJw3NAlkbbTm3wyfmKNTQaoFpbdzFKrnS/ZNhSW5DH7ZoKu3wSWG2Xusl0OjHnQbsNfrFLIn6espsz0n2/vlldU9uDcf32nd3Id7wN1Cwf9sres6puLqYsAFpcsZu6utyY4VPJrUU6G4GaTT0aeBvjTFbgFcDHxGRLcAngQeNMZuBB917RekkdG4rmWLOBd0Yc8gY83t3fBJ4AlgLvB3Y5U7bBVybPIKitCc6t5WsUVPYoohsBC4FHgFWG2MOua7D2MfWjuItb3nLrH0+58sFF1xQdQzvRPWmlK9//etRX5LJpZyXvOQl0bF3xKZ1cp533nlAnA9GTS7zp23mdpADxZtAkvKilOdaSepLus6bFEIHqB8i3FlarQxcfFlSWKTPFVMZOiiuLV8iV20mi6RyGOUhg8l5ZOI2r8Xmct4MUz0PjuR73QjuyhKzWHu5IVNLIyIDwI+AjxtjRsM+Yw1sieYtEblRRHaLyO4FSaooDWI+czuc10NDx5okqaJUJ5WGLiIF7IS/0xjzj675iIisMcYcEpE1wNGka40xO4Gdbpy2Clv0TtGQu+66C4B77723os87hr761a9GbZ/61KcAGB0drTg/CR+a6DX/n/70p1Hf+eefn2oMj9/01MzQ06wx37kdzuutl11at19AiW4plaFwFSTcuVqmQ69dTrtQPHt+znWFG5cKpZeFN3JjhBq9D+3zbeNBmGCkvedL7wexRrmwgh1Oq46yUgZPB06e0HmZK9Oqw8/mz0/KRlnI5SvaKotvt9ZJOqeGLnZ2fAt4whjzpaDrx8AOd7wDuL/+4ilK49C5rWSNNBr65cD7gcdE5FHX9j+ALwL3iMgNwF5g+yzXK0q7onNbyRRzLujGmP/L7E99V9VXnOYyMjJS0eaLXuzZsweAV7ziFVGfLzJx5513Rm3VTC0+vv11r3td1PaJT3wCgC1btsxT6hhf99Q7ZpXaaMe5XRrXPHs8eXBBeOqseLPClLGmkZGp4aivJ9dTcX5vmdlm3O2uhNikMx3sNp0o2p3M3lQRmmP8eYuMdd735APTTrTrNJ07LzLXJJgZ/b0ninExmJHJ4QpZe52Ts9vtZh2bPh31HR6zaXaHJ+JtBy9ZugmANYvWORnCOPrZY+CTqOfu0STay0WrKIqizJvMZ1usxle+8hUArr/++qjtXe96FwB33HEHANdcc03U5zMq+mIZEGv0PkTxkksuifr8rtNXvvKVUVstBS6S+NKXYlPvF77whXmNobQHc82AqkUsysrSJYUvJjn7zjhtNNRAl/XY3dA9Qf4Vf+fyjI8Qh1NOBY5Vnxum4EIBB1zxCIjzzuSl0qloojBKU9Ia/7f0e/AjhI5PTzEhl8tY9HnjJ5LeLquhLy4sqRjrhdMvAPDTZ+McThevsk/r773I/q33dy0uk5SgwEfJHtwKGRuNauiKoigZ4azW0J988kmgVOP2GrkvCH3PPfdEfdu3W9+Y3wAE8J3vfAeAl7/85QCsXLky6hsYiLWUWjh0yO5p+cEPfhC1ffOb3wRg//79UdvJkyfnNb7SfsSm8HT5+qLzo4O5jOi2f2LG2rqPjx+Puvpd7u9FXWG+oMoNQrFUlaGPXlv3dum8VC4tkzM+Y2icOdSf35WLc63Em5TizO7xx3BaOJUafRxyGMvsnw7Cp49TU1ZrH5mwPrThydiX9pNnbObV3U/tidoee/4AABuXWhv65edeEfX1+bzpkYYeZpIsK+TdBFRDVxRFyQi6oCuKomSEs7rARa08/vjjAFx00UXzHiOXs/8PLRbtY+HBgwejPu/k/NrXvjbv8c92OqnARZL7LP0fSGXOkXgwN1rwt+0dhn4H575TsUlheY8txdjfFZsIfYpYb1aZNrF5xaeRPT19Kmrz4/blrdkmLOHmzRDecTpZnIz6vCnEl3ez93Y7V91nzAV6p5T12Y9Z6rgdC+R6cdxu8j0xHjuBjzuH8L5R6wB96tgLUd//+/MzALxwJE7n0N9nZbvpLX8DwHsvemfUt6xnZYmM1crThdQ6SbXAhaIoylnGWe0UrZU3vvGNQKlWXStjY3aDxt133w3Axz/+8ahPnZxKdaqHJsaNs2dg9KXVzuldFfX1upJqYWjiTLRBKMjK6PAadHfgyIxypoh3psZj+aeIk1N2fo8khBCu6ImDCXx4o9+sFIY7FhIyJJbfJwzJPHDK/q0OnYk17skZ+5n2j9rspI+/cCTqGx6x2v3MTPzkUyjY72xpz0DJZw2JioRU9DQX1dAVRVEygi7oiqIoGUFNLjUQ1vicLz7G/IYbbljwWMrZQRqHadLOyaTzvbNzsaurWXKfwLwSj1fpfPXHSQ7Z2PQS64ozM9ah6vOk/GL/w1HfyIQ1Qb5k8Lyobc2ANQednrJ9UzOxQ3ag2zpbBwqx03XGyXFi3JpyHj36l6jv6WPW1DJ6Ok7n600ouZz9Zrt74lTBq1YtA2DxWF8sz1pbe/TCpbbmb5j7JnZ7lhb4aBWqoSuKomQE1dBrwOd5UZR6ULsuV7mLNNq1GWjXSVpi7LRz4XXBTk6fT6UrWA7EhddOuxDDsGDFyanRkjEBCm5HpkkooLHvlM0G+sBzDwHw092PRX1nxu34mzbH5RP/y4V213Vvl9WE+7pijdg/FUwF2RNfdA7P3x2ymvnDTz4X971oHaShhj7Qb7XvjRtsZcFXblgb9U0N2ieXPceCXDeL7Pn+6aY0ZNIdt9ob6lANXVEUJSPMqaGLSC/wS6DHnf9DY8ynReQC4G5gBfA74P3GmMnZR8o2ExM2xCq0jb/jHe8ASjM2rlpl7YO+QPXPfvazZomolJGFuR0XhA423ySe58rZSaWt11CqvYfnGafJ+81E9vyxijHibI62Lww19LlTzhuwtuhXv2JT1LfKFTh/2fK4GPvSHpsF8eApa3PfMxJv/PHkgnvvG7Xa9OFTp5zs8Xl9blNQaO3vck8fvX09Tq5Kf8LwRJxTveDOPzVlx5+YiXPRFLt8CGNpyb5WkUZDnwCuNMZcDFwCvFlEXg3cCtxujNkEnADUy6d0Gjq3lUwx54JuLH4vbcG9DHAl8EPXvgu4tiESKkqD0LmtZI1UTlERyWMfPTcBXwGeBYaNiTwxB4C1s1x+VlAo2Eeu973vfVHbXXfdBcDrX//6qM2bXL74xS8C8PDDcQjX8HC8g05pDp07t0tNLXkqi0eUmlVKy9mFYY6Rsy9ItVS+A7UryFFSmmbX4k0si1wuF5+2Njxe038uAJetjss2+l2nYXrbSRem6E0ce0cORX1TLgdSfyHepTrY2+s+k5X59NLYJOJ3fE5MxBazsXHbv3+fzfPywKnYYToxYe89NBT/LS5ZbM1Cr1p7IQAvXbo5lqfbnl8wVh5TYvpq0wIXxpgZY8wlwDrgVcDL0t5ARG4Ukd0isnueMipKw5jv3A7n9dDQsbkvUJQmUFPYojFmWEQeAl4DDIpIl9Nk1gGJCU6MMTuBndD52RY/9KEPAXFx5hCfRdE7O8uPy/HFp9etWxe1qYbeOmqd2+G83nrZpQ2d19UG9zpgmJEQSQhbLCtVFxaIkKQcMaZUow/DHH0+lTBfi9fy87l8xfmD3XazztLuQaA0b4vPvBgWcZ7K27Z1A/ZvY6YYP01MzNi+nnysoY9OWk1+X87mZHn+eBxyOOHCIkdOxUWux522PnbGaur7DsS5XDjutPti/J28uMI+AfzhsA2/fO2auKi0L9rRl483OrWSOTV0ETlHRAbdcR/wJuAJ4CHA55HcAdzfKCEVpRHo3FayRhoNfQ2wy9kac8A9xpifiMjjwN0i8lngD8C3GihnW3DfffcBpaGG1bRwpe3p+Lkdhy1KSaslsInXmHA9srk7m3CoxRdcCONEYIePNHp/fmBLjvObW8KQRi9/mG/dZ2U86DIl/mno2ajvyGmrHffk4zG63bHf5v/8ntjmfvBZG/rIUGwnZ9LlT+92Mk4HX8qU+0x9gU9isf28UzP2iWQ8CFtMyrzYSuZc0I0x/w5cmtD+HNbmqCgdic5tJWvoTlFFUZSMoLlcauDMGfvYdv3110dtPvxwx44dAHR3d1demMDQ0BAAo6Ojc5ypKNWoFhpXWYHexyXkEnS5MMwuNIuUY9ylEpSS87levKmmEJhoyrMyhiXoxqatCWV4Mg4IGJ20fxPHx0cAGBqLHZoHR2zf5GRsounttX9zJ45X5pjJL7HhkDNjQaEO51iNnceByaXHfe7BOIxy8crFAGwctE7druC7SSww0kJUQ1cURckIqqHPg5GRkej4pptuAuC2224D4Iorroj6knK5eI38M5/5DAD79u1rrLCKkkAuQQPPJWxESsx97hygucDxGW48glJtv0tK+8LSdf5JoBBsRPIl8TYuWV/R97IV1mHqwxdD/tRnHaDjZ+K+mWGXk+VE7MiMQhJ73XewKHiqdm2FZfHmqVUrrGa+uNu2hU8YPq9LHMIZftY23VikKIqitD+6oCuKomQENbnUiWeffbbkJ8CuXbtaJY7SYdTXtZZiNBOc45yD4e5R3+/jrMPcL5Hjs8R00uWGsmOFJp1yB2xfianGmlMGCoujtomiNWNMzFhzybKewajvtEvPe2Y6jis/7dLzLu+1aXDPTMUO0/0v2MIZY6fjNkbd8UyZ6QWQJfYz+fJ0AGdc7pcDJ+0O1JOTp6I+s8h+L/47Cb/55DTGjUU1dEVRlIygGrqidCReF6zU+dJoiyVl1Iozs57vS8nNBCXuvDM0LHrR7bIlJhXciG+UkDMmV9nmNf8+5xwN88Ismrba8ejkyajN54EZ7LVafqih97gC0NMb4iIWkyecdu93hXbFsnoRfQ4YgJGT9gngz4dszpf/uOZ41DcVfT+VTzJxWGTznKOqoSuKomQE1dAVpQ2oMdVKTWPa41ItMUmDLgZa+IzTNH2OlZkgG2J33mYfzAehij78MCkHeBT66ArBTQdhf0WKFedHIZDFsvfBWPlAfn/sC0f3FeInhxWDVmtfv3ZV1HZmzNrmj7ic52cCbTwqcj0Tf95xlyP9+DEbrjw8ET8deHt/sU1yuqiGriiKkhF0QVcURckIanJRlI5kdkebRHra7G7RUJOLy6bFy8FU0ToOvSmhpKScD1FM6eyLQhldEpiuINwxduCGuV/sPSeL1hk5EuR5eeH0IXdOpamm35XGu+Tc86K2v3IlHzcNro/aTk7a0Mef73kcgENHYifnaVeO7vhI4HSdLjWnTIXmmOnxEnlandtFNXRFUZSMkFpDd0UAdgMHjTHXiMgFwN3ACmyR3fcbYyoTLChKG9PKeZ2kP8ss/fW9WzJJ+VdyeVecIgg5TNKqo/4EpT06y2vqCXpkqHF7R+zRMzZM8IE9D0Z9z4/YIhavOCcu3bh11X8A4Ny+1QC8fFlcFrbgStWF+WOOjdtMp3lXNvLf+uLNgPuO26eB/oG+qG3SOUVffqG950XLL4z6FhXsU0E1p3AzM7rUoqHfjC3P5bkVuN0Yswk4AdxQT8EUpUnovFYyQ6oFXUTWAf8V+KZ7L8CVwA/dKbuAaxshoKI0Cp3XStZIa3L5MvB3gE+4sAIYdlXRAQ4Aa+ssm6I0mrae1/OPTU9zxezFLwAKbuen3zqZ5OwrMS9INSft3FKVmm+s+SUpRe6mZdassm3VxXHb0s1AHB8/6XLAQJxTJpcQd3/Fea8GYPNgbEI5NGZT8L44diJq++OR/QBctMI6WJf3LIv6+rsGgNhpLGXR/81mTg1dRK4BjhpjfjefG4jIjSKyW0R2z+d6RWkE9ZzXQ0PH6iydosyPNBr65cDbRORqoBdYAtwBDIpIl9Nm1gEHky42xuwEdgJIqAIoSmup27zeetmlbTav56sZxtdFgY8J6nWyU7Q0jNAk5G1JksqfFV7vy9kdGrMhij7MEOJ8Ladd6TqAk1M2xHDAyxXc22vt4b0XF5YA0OOeQvq64mIWa/rPBeDUVJxR8fSklae/YB2lA90DUV9/Vz8QPAFUeVJpBnNq6MaYW4wx64wxG4HrgH8xxrwPeAh4pzttB3B/w6RUlDqj81rJIgvZWPTfgbtF5LPAH4Bv1UckRWkpmZnXteqKpTq1s6sn2NcTszmW2drDQs3l9vdQg47yuwR5ZMZczvM9w9Z2vT8opP7imM+HHpeU8yGPl67cCkCf05qhNFyx/HN6rbon1xv1+ayJpwrxxqLzl64BYHTCPhWEJfW8dh/lg6+4W3OpaUE3xvwC+IU7fg54Vf1FUpTmovNayQq6U1RRFCUjaC4XRckAC3nUb4RHt8TM4kwsvsRdWCzDm1/CsML+gjWZrF1sQxSPjY9EfcPjNiRxaCx2WnqzUG++dNcmJKcJ9t9VZCbJBal4XQpe7zgF2LDY7hD9y8xzFeP7vDRSZqJqFaqhK4qiZATV0BWlg2mpPpiQ38UTaqo+9NFXmyuS4DANQw1zNpxw26ptALx0cHPU9/zJvQAcOnU0als/YDMpei3f54IBEHfzsIydD5FM0qrzboNQLlgaX7ncbmJa3rscgJW9cbGMgivDJy0OV/Sohq4oipIRdEFXFEXJCGpyUZQ2pZHbT5PHnr0gBglmkpKdouWmk8AE4U0a3vRSkO6KvhCXRYY+5+Rc1bcm6rtw8SYgdrACFJxj0jsrZ2bighQ+rjxM2RvtTg2OPGGMucfna1nTZwtnhHHulTli1CmqKIqi1AHV0BWlDWiPZDBJ5TUqNc5cpHFX6oOR1luiofufSWU8ZsdnSgwXKZOrLD1XTlLYYhi+GKenccU7gmtjjT58IrHEZfja47eVhGroiqIoGUE1dEU5C6mW+TA8IzmXedImmtISdGnzgtea8z3J5u5zufji0j5bI8QhkPl8vuI6b1f3WjnEuWVMgs/Aa/mhrFFfy7O4WFRDVxRFyQi6oCuKomQENbkoStszu4OyfSg10aQxsyzkPklGmhlnLkkyuRRLCnDYa/3uURPklvF5ZsIwR+/gjcIvg7Ha7TejGrqiKEpGSKWhi8jzwElgBpg2xmwTkeXA94GNwPPAdmPMidnGUJR2pH3mdutD4RqvZVYWxoh74tZKB2OSZEG5POeszBv7sxCFF8Yat5j4fB/W6ItqTBfj3C9ejnyucmnMVyk4XfmE0prfaC0a+huNMZcYY7a5958EHjTGbAYedO8VpRPRua1kgoWYXN4O7HLHu4BrFy6OorQFOreVjiStU9QA/1tsYcFvuIrnq40xh1z/YWB1IwRUlAbTFnO7PP2sFyykVPuSknNa7ZSLXZWVpgfK+qpdn/Qu+T6VrTmpjDUfnrSWssHuZVFbzhW0mCxOuLHi0fryNk9LuNs0yl1jKnepVtv72orfSdoF/QpjzEERWQX8XESeDDuNMUbCKrIBInIjcOMC5VSURjGvuR3O6/Ub1jdHUkWZg1QLujHmoPt5VETuxRbRPSIia4wxh0RkDXB0lmt3AjsBZlv0FaVVzHduh/N662WXLnheRwMkFI0oz1Zo20qPquVJrAdpx6x2XrU+U9WdWJlXpfxq+1/78+TkaNRz8PRBAEZ74jJ2q/rsA5fXwhe5bIoQO0NLc7n4EnpemvDbn91q3Yqnpzlt6CLSLyKL/THwn4E/AT8GdrjTdgD3N0pIRWkEOreVrJFGQ18N3OtKLHUBdxlj/klEfgvcIyI3AHuB7Y0TU1EaQtvN7ZIc475UmtMkTdmZkLyRZ76aYZL2W0/tMv1jTK13LT1/eHI4Ov7TsacA2LhkXdTWk7ebjVb2nuPkqvzOiwnZGX0ul1xLrOPpmHNBN8Y8B1zXaxShAAAGg0lEQVSc0H4MuKoRQilKM9C5rWQN3SmqKIqSETSXi6K0iKQEs9V2UVZP0ZrOLZpkjpmvRzfpjvVxBM4+SrVx/Q7OxYXFUdviblvGbk3/uVGbLylX8Kl1E0IUS3836fPUtBrV0BVFUTKCauiK0gakKpAQhDSGJd5mPb1k/Frlqe2cci0/TXihHWPh2m6sz9uxlvesiPq2rdoKlG4s6uuyWrsvLp0rcYAmbYxqX428HNXQFUVRMoJq6IrSrqTQwtOSzk5uEo4SNFbxecEbs0+w0o4918aiUvoLS6LjnnwfAF1B9kSf6zwpVUB57vO5aDfdXTV0RVGUjKALuqIoSkZQk4uitIjknZn1eIivFjzoHZOVLs2kjI+JoXrzNrWkM2fM/zuw14VhiLm8392ZVFKu2r3TydBuyalUQ1cURckIqqErSlvgtMbQEVqRdLAe2VnSSlOqqSaFQDZKmmqbrNJdnyBZwncXZbFsOz17/qiGriiKkhF0QVcURckIanJRlBaRbLIIdi1WrQdTzwjo2mKva02zW724XuWVC80HE+78LCaUjfNOXZNwg9j8kuQgnt3Y1C7x6KqhK4qiZIRUC7qIDIrID0XkSRF5QkReIyLLReTnIvIX93PZ3CMpSnvRbnNbglfpu/JXujFmu2qutlpftcgz15Vpxkx7R+P+zRSno1fRzFA0Mxhj7Auqvjx+rOTe9iCthn4H8E/GmJdhCwI8AXwSeNAYsxl40L1XlE5D57aSGdLUFF0KvB74FoAxZtIYMwy8HdjlTtsFXNsoIRWlEbT73K6ntlxNn1y4Rrxw0mr7tY6Vl7x95bqiV869RMS+SPd9ivtXX2nrSxoN/QLgReDbIvIHEfmmK6i72hhzyJ1zGFufsQIRuVFEdovI7vqIrCh1Y95zO5zXQ0PHmiiyosxOmgW9C9gKfM0YcylwmrJHUGPTriUqAMaYncaYbcaYbQsVVlHqzLzndjivV65cUd6tKC0hzYJ+ADhgjHnEvf8h9o/giIisAXA/jzZGREVpGGfN3G4nQ0GtTtWF3cv+y5OreCX9kyovL20z5a+VORd0Y8xhYL+IXOSargIeB34M7HBtO4D7GyKhojQIndtK1ki7sei/AXeKSDfwHPAB7P8M7hGRG4C9wPbGiKgoDUXnthLRTtr2fEi1oBtjHgWSbOBX1VccRWkuOreVLKE7RRVFUTKCLuiKoigZQRd0RVGUjCCNqtydeDORF7GxvkNNu2n9WUnnyt/JssPc8p9vjDmnWcJ43LzeS2d/v50sO3S2/GlkTzW3m7qgA4jI7k7eZNTJ8ney7ND+8re7fNXoZNmhs+Wvp+xqclEURckIuqAriqJkhFYs6DtbcM960snyd7Ls0P7yt7t81ehk2aGz5a+b7E23oSuKoiiNQU0uiqIoGaGpC7qIvFlEnhKRZ0SkravAiMh6EXlIRB4XkT+LyM2uvWNK74lI3uX5/ol7f4GIPOK+/++7/CVtSbuVhqtGJ81r0Lndaho5t5u2oItIHvgK8BZgC/AeEdnSrPvPg2ngb40xW4BXAx9x8nZSebKbsSXVPLcCtxtjNgEngBtaIlU6OqI0XAfOa9C53WoaN7ejQqkNfgGvAf45eH8LcEuz7l8H+e8H3gQ8BaxxbWuAp1ot2yzyrnMT40rgJ9hEckNAV9Lvo51ewFJgD87HE7S33Xff6fPayaxzu3myN3RuN9PkshbYH7w/4NraHhHZCFwKPELK0nttwJeBvwOK7v0KYNgYM+3et/P3v6Cyh02mY+c16NxuAQ2d2+oUnQMRGQB+BHzcGDMa9hn7v9O2CxMSkWuAo8aY37ValnmyoLKHSjp0breEhs7tZi7oB4H1wft1rq1tEZECdsLfaYz5R9fcCeXJLgfeJiLPA3djH03vAAZFxOfAb+fvv5NKw3XcvAad2y2koXO7mQv6b4HNzhvdDVyHLfXVloiIAN8CnjDGfCnoavvyZMaYW4wx64wxG7Hf878YY94HPAS8053WlrJDx5WG66h5DTq3W0nD53aTHQJXA08DzwL/s9UOijlkvQL72PPvwKPudTXWXvcg8Bfg/wDLWy3rHJ/jr4GfuOMLgX8DngF+APS0Wr4qcl8C7Hbf/33Asnb97jtpXjt5dW63Vu6GzW3dKaooipIR1CmqKIqSEXRBVxRFyQi6oCuKomQEXdAVRVEygi7oiqIoGUEXdEVRlIygC7qiKEpG0AVdURQlI/x/7G1I7TJ7rWEAAAAASUVORK5CYII=\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/UCwAAIABJREFUeJztnWuwXVW1oL+x93nmdfIOIQnkAYpRi2fTIvgA2lZoVKzWCIqVtmkpLW2xyva22GXZP3xRZYH+UDSF1xsRGxEuYPlo2+biRS2kiYjC5SUguUlMCCfknZzkPGb/WHOuNdfe86y99j77uTK+qlNn7TnXmnOsfWZWxhpjzDHEGIOiKIrS+5Q6LYCiKIrSHPSBriiKUhD0ga4oilIQ9IGuKIpSEPSBriiKUhD0ga4oilIQ9IGuKIpSEGb0QBeRd4jIMyLynIh8tllCKUqn0bWt9CLS6MYiESkDzwJvA7YDjwBXG2OebJ54itJ+dG0rvcpMNPTzgeeMMS8YY44DdwDvbo5YitJRdG0rPUnfDK5dAWzzPm8H/m3WBSKieQaUlmKMkSYMU9faXrR4kTnl1FNoxsSKEuKPjz42aoxZUuu8mTzQcyEi1wHXtXoeRWkn/rpedcpKHvz9Ax2WSCky8wYWbM1z3kxMLjuAVd7nlbYthTFmkzHmPGPMeTOYS1HaSc217a/rxYsXt1U4RZmOmTzQHwFOF5E1IjIAXAX8pDliKUpH0bWt9CQNm1yMMRMi8gngl0AZ+HtjzL80TTJF6RD1rm1jf040G3rDDrFQZJ3k+/ZOtO+4XmZkQzfG/Bz4eZNkUZSuQde20ou03CmqKEVH6B3NMbdWXaFFmxpXxv32OhPqC4wh1uor3jfojkWqLcLNCJOr929Vz5ydXge69V9RFKUg6ANdURSlIKjJRVG6nKbuxotNItWj+m2m6jyvr2Ks0Hipz/Y8Z0IpeaYUiX9Xm1wyyZi75qV1nV1NSr4KZ65Jndd+VENXFEUpCKqhK0qXEtKEq8+x2m9AH8zSXI2Zio+niI6n/DZ7bHC/awlbcYZUa9zl+LOnoQccn5Vj1nqbmFaGCjmmHz/QxfRvACVffufArfgNYHKEYjZbi1cNXVEUpSCohq4oXUqsvWVqetP3BW3RTov1NOOSiS+Y9nSnxU87t5WxFAg5dDZzp9mKVGu4qXvM0Mzdm0NYHnd50jc+eRyAoxNH4raxyTEAhvuGARgsD8V9/dIfyVqqfjQGv2kna6AzTkWYc9NUM1ANXVEUpSDoA11RFKUgqMlFUbqIkIOu7hf2HE5U3wFqAk7RSTORlicwZtqSkDa1pM0q6bassL8QE1Pj8fHRych0cuD4/qTfRP3OpLPtUJLK/tHdTwDwwNa/xG0HD0ZjnLRwBIDXLTkp7nvTyn8DwJp5a+O2OX1zAeizZpiyJI/NOATTVDtFXV+wCkSLzDCqoSuKohQE1dAVpcvJChn0HYC5xorDEas3CmWGOQbDBJPDUoX27Yf2lbJCExPBquaaNJMAjE0ejfv2jL0MwLZD2+O2wxOH7ZzR3A/86x/ivl89GiXJfO6RF5K59kROUUYGAPjl6vlx1xNv3gXAf3r92+K2NfNWAzCvP9Lo5/TPi/sSjdw5R33nbvQrdP+5Nk81gGroiqIoBUEf6IqiKAWhpslFRP4euALYbYx5nW1bCPwIWA28CGwwxuxtnZiK0ny6aW0HjR0Zzs3q67N3Tk45k0DA5FLvfKH0tqUKZ6hkOP38uZ3D0G9zppZj1tQyOrY77tt+OKoE+Nsdj8Rtz76yB4CDx44B8NTTSfnNHc9HJpTYzAIwGO1ZHbSmljNOT6oNvnHlOgBOnr08bls4uAiAARuvXpZy3Ofus+78MPF+gOaaXvJo6P8AvKOi7bPA/caY04H77WdF6TX+AV3bSoGoqaEbYx4UkdUVze8G3mqPNwO/Bv57E+VSlJbTqbWdqc3lCDlMn+52TqZLSkA4N4sLR/RxGrc//lSVJu9p1VYPTPRUmAxI688Qms/Hl8s5QXcfjbTr5/c/H/c9MRqFH/72xRfjtv37DkXjWm330BFPGx+2j7jls+Km085cDcB/ufhiAN604g1x38rZq+xls+O2Prt71I2flTcnlcslh97e7OyMjdrQlxljdtrjXcCyJsiiKN2Arm2lZ5lx2KIxxogEQ+cBEJHrgOtmOo+itJuste2v61WnrGytHA1m8M7SFn3t3Wmek1OJluzs2NWaemJDNl6+k5LV12NNNZTcJCCX45gXmvjKscgmvvXgvwLw8M4/x32P7PgbADt3jMZtfX3R3HPmRlr4ySctivtOXRX9fzw42B+3ffrN7wbgvCXnATBUHk7GKvVXyVipmYfkD+WkkYycNK2iUQ39JRFZDmB/757uRGPMJmPMecaY8xqcS1HaSa617a/rxYsXt1VARZmORh/oPwE22uONwH3NEUdROo6ubaVnyRO2+L+InESLRWQ78AXgq8CdInItsBXY0EohFaUV9PLadq/xgcJwQUqx49OFHHrmGGsa8FPSHp+K0s5OWDOM3xcXrAiE75UCOqKTtc/mQPHndqadPWOJCeU56wR9YOsfAfjdk8/FfS+9HEWQHh07HredunIpAGuXLwFg4XBiQjl1JGpbMJTs7jx3ybkAzOmPcrSk89qkd6kClEw5fb95Qw2dqcavxtdi80ueKJerp+m6tMmyKEpb0bWtFA3N5aIobSad/WNmJBqfpFohrQk7p2WiNXpaqVMhvbQw4zKeGt/PeOi0VxPIvxJ0GNo5XSGJPi9boQtR9HOzPP7yswA89VKUt+XIkWNx3+zhaIw5sxIt/LTV0SagC1e+CoDlc5bGfets1sRFQ4mfw+VicfIfmTgY9x2bjObadzzZS7Z0OHKszh9YCMBAadC/OXvf1ZiKc2CazItNRLf+K4qiFATV0BWlhwlvcgmcZ08rmZK7MMbZkEPb9WNbvaeNOw19wgtzjMcIbFJyaQEGrWZbKlWnDPCzRjpb9cjsSAs/vjTJhuiuHfDCEM8/eTUAa0aiTUHLZiVbB+YORNq4r1U7Wd1bh9PKAZ7bH21c2noweWNYPS8a94z5rwFgyVAyfsm+bTS6WazZqIauKIpSEPSBriiKUhDU5KIoXUpmiJtxTkh3bkKmGaZOj6wLQyyXkhDFiUkbyuiZSY5PRmGEk/HO0qRvoBQVkpCBaKz+UmIuceGRfubGkaE5AJyxKNrxuWpeEnK4cDjKsbJ4ODHDvG7RqwFYMrwkNZ/PEVsEw5//0HjkDN1hMzgCbHnpcQBeOXoobhvqi8w1K2avAGDBYLITtd9Ul9yLaaOpxaEauqIoSkFQDV1ROkR1oGE9F1dkMKypDaadlalcJYEcJc4x6Qojmyk/l0t1xkanaY9bR6Mfmjg0YEMN+yPNe7A0FPc5Z+u8gblx20mzoxDDWX2RU3RsInFazhuMNPSTZiWhiUuHo+PhvllWluR857gNlepzm6WG+hJ5nDY+MpicP6c/mjN2+PohnxW5bkL5c9J5YVqrQ6uGriiKUhD0ga4oilIQ1OSiKB2iXjNLyklaWcKsRn4RMRWv/96rfzmQ38UZIfqtg3HKy20Sm2E8eca8WG6AWV6BiJGByIE5aNPUlj090o3lOzKH7Y5SbOi4n1fl2KRzolant3XsOrIruQ875+z+pMBFf3nAyhPN4+8iPX3+qQDsO34gGd9+P3FKYc/h646dSSotS3XOm0qaW4BONXRFUZTCoBq6onQplbsuU+GIOcqhpQdz2RBdVWbvHKk6QEg7E8e9XC7jk+lMjNG40bVO0x72HI1xQQy3Q9PTcMcmx6x4ydxzrYN0eGqWnSfR0Hcfjopf/O1QtRbu5vzb4Z1UsmAwCXN04Y3u7WBOX+KQXTcSFYk+NJ6EOQ5ajd5lZyTl+Ewjno6cVbKuVaiGriiKUhDy5ENfBXyfqLaiATYZY74hIguBHwGrgReBDcaYvdONoyjdRq+s7UwNz2m2nsadSyMM2NxLvtIuabu6v4mosjwdJDlZnNbrhy1WXueThDt62r64DUjR3H5Io3srcFozJPZxt2Ho+GTyNuHkGe5LsjM6ucfteWOSlL9zmrmTC5JNUjK+H/A19eTtw8lc8nwTobJ0rSaPhj4BfNoYsx54A/BxEVkPfBa43xhzOnC//awovYSubaVQ1HygG2N2GmMetccHgaeAFcC7gc32tM3Ala0SUlFaga5tpWjU5RQVkdXA2cDDwDJjjPM+7CJ6bVWUnqTn17b/Wt+EHCJuBJNRud7P7zIkkUPSmSD8vqSsW/UOU5fC9ojnhDwyEZlAnMN0sJykvl0yHIUY+mGIlWaeg8ePxH3DdufnpOdYdXlnplxpvFLyGHTyHPDCFl163aMTkTx7ju6J+1bMifK7LB06yc7nPVLbaGpx5HaKisgc4G7gU8aYA36fif7qwVUkIteJyBYR2TIjSRWlRTSytv11PTo6WtmtKB0hl4YuIv1EC/52Y8w/2uaXRGS5MWaniCwHdoeuNcZsAjbZcdqffkxRMmh0bfvr+pxzz27eum6Gph3SDCs2FoU07vSWGOcUtdkWvc0xfdb5OBUoYxdyyB63Gq7Tkn1Nfe+xyNe87/j+uG334VeAxAF68twkb8tJtnjFrL5EQ3fOzVI5kvXpPUlxipVzFwCwdFayeahyI9K+Y/vi41esPE/veSFue3I0CpHcuT/6v/4ta9bFfe9ct8ANCqS/V6nc/NUGamroEt39d4GnjDE3eV0/ATba443Afc0XT1Fah65tpWjk0dAvBD4EPC4ij9m2zwFfBe4UkWuBrcCG1oioKC1D17ZSKGo+0I0xv2X6lAOXNleczuDXOHzXu94FwD333APAb37zm7jviiuuAODAgZSZVelRun5tB2LMpyWneSZkanGmEz9fS1Jvc8z+PlbV5+c0KVW87PvmmLiGp919Om6SOPHD40fs+Enc94HjUXEJZ76Jc7sAIwMjUZtnchmzTlTniN03Nhb3nX9yZK5ZPffUuM3FkTszku90PToZjeXvLJ0/FNUZfXo4MuUM9nkx8DZnTXz/3t8hNkNlFXltMrpTVFEUpSBoLhdg/fr18fHdd98NwNRUpFVceOGFcZ/T3n/wgx+0UTpFyUEtjS/DKRq60u14jMvH+cUvrCbshwI6Jqz27fdNVIQr+n1uF+ZcW/wCYN38VUBSeGLtyNq4b+lw5BT1i2S4rIzuO/iPr07+za6c48rGLYzb3D253aD+28fRieiNYdlwEqnatzhyAi8ejhyg/q7W/cfTu0elPymX10d0XVa2xWajGrqiKEpBUA0deOc731nVtmFD5Afztfd77723bTIpSrtICkgnWniSm6Xffk60zH4TtU2WfE07GmVs0uV+SezYrqi0y5roF5B2tvDFXk7yuQORljvParuz+hLt3cnlZzV0c7u+i5ZfFPc5Tb7sFaZ2dzwU56RJ7mPI2uv9UnGJjFFxaBdqCYn93QR8GFlZL1uFauiKoigFQR/oiqIoBeGENrnMmxe90l1//fVx27Zt2wD43e9+ByROUkXpOTLMALV3irp0sPazZ4IoGbt71Ht8JKGPU/a65HxX6q0U2HXqnK1+mzvflb/r88wleVIDD3gO05LN0yIVdxfNac/x5i7bfDDGC7vsG4zmPzIehVP6hT0WD0XFMoZt+GK/eLK676CbdooqiqIovcEJraFfemm0d2TJkiVx2xe+8AUAdu3aFbxGUdpGo7lcGs62WF14uRR4RDin5pSn5TttN7sg8vTl8vw3Bpc10WnO/nWZRSNMdfbEOGuk54id7rro0Baz8N4w+qzeO8uGVvobo5zD1r1FSKjARRtRDV1RFKUg6ANdURSlIJzQJpcQy5Z1fy0D5cQi7MCsI89LA+NPOx+Aq5+Z2m3qTDTVZgbfDDHd3Kk8MnZnqZhqJ6o7P8t8k6oHGjChuPFcjVMTyDsz6OWPcc5cY3ePu92kACP9LudLyPkaoMUpdVVDVxRFKQgntIb+6KOPArBvX5Lg3jlK58yJnB2HDh1qv2CKUoMsTTXr/KTBpHqxo1US0q7j4heBeUJOS3cUTDpoTFVv7Ci12vKkp72X4rmn19B9bb96Hpgi6t8z9jIAB7ziGiMDkcbt534ZLA+nxtp1JAmYmGt3s5bjMnhJ2GL8N/JuvN6/W72ohq4oilIQamroIjIEPEiU06wPuMsY8wURWQPcASwC/gB8yBhzfPqRuo+tW7cC8Kc//Slue8tb3gLAmWeeCSQbjPLicqYDfPzjHwfgIx/5SNy2ffv2qmuUztCVa7tOm3ge+3ft86u1RZffO6xJTj+nkWoNulKjT2V6dLlZfI3elFJ9vo0ba/8O3YeTeaic5Ep3c/tl75ydfPfRlwB47OUn4r63rrjInl+dp+b4VJSV8Zm9z8d9K+dEmSFHWFAlT7eGLR4DLjHGnAmcBbxDRN4A3AjcbIw5DdgLXNs6MRWlJejaVgpFzQe6iXCG5H77Y4BLgLts+2bgypZIqCgtQte2UjRyOUVFpEz06nka8E3geWCfMfF7zHZgRUskbAMuVS7ASy9Fr2Ef/ehHAXjooYfiPlf0IsRpp50GwNe//vW4zZW2e/nll5snrNJUunltV+2i9M0xFWFvuZ2jcaGL6mv9tqkK04lv4jCB0LvEREPqd0jWynJ1rtXhdp0mDlZP/pBTsTIE0P+a4lO8XDT294LByEyyfuGrkj57Xqgc3+HxwwDsOrynqs8vuddJcjlFjTGTxpizgJXA+cAZeScQketEZIuIbGlQRkVpGY2ubX9dj46OtlRGRclLXWGLxph9IvIAcAEwX0T6rCazEtgxzTWbgE0AIsFyqR3n6NGjVW0f+MAHgCS0EeDmm2+uOu+iiyInym233QbAKaecEvede+65ABw7dqzqOqW7qHdt++v6nHPPbsLunumzICZ91W0xQd+lHwoY4Qo7lz1dTgKOzFIcyeg2MPlzufM9rTdj81AWwTeADKdrKJtj5XfhnJeQvk/HZEVel+Wzl8fHLmzRl8Fp6wPlKPvjO9f+u7hv2XB0bZw/psaGoVY/AWv+FURkiYjMt8fDwNuAp4AHgPfa0zYC97VKSEVpBbq2laKRR0NfDmy2tsYScKcx5qci8iRwh4h8Efgj8N0WytlSxsaSclkbN24EYPPmzQDceOONcd/73//+qmvPOeccAMrlKJzqa1/7Wtz3+OOP1yXHwECkAXzyk58EYMWKxHQ7MjICwCWXXBK3zZ4d5WAeGoq2KX/pS1+K+5wt3783pYqOrO16lbSs8xP7ekYfATt5auNPYLNOhcbthxWawPl1hegFtNjUWBnb48s55nHZGn1KgeyJJ8+KQg79TIyhfOjO/j5/YGHqt9/nrqsZ5Nni3Og1H+jGmD8DZwfaXyCyOSpKT6JrWykaulNUURSlIEioWnXLJutSp6iPM5188YtfBODDH/5w3NfXF73QLFhQvSts06ZNAHziE5+I2yYnq3NKrFoVvea5rI7OlAJw5ZVRuPPHPvaxquvcK2/ev9eFF14IwMMPP5zr/KJgjGn79rxzzj3b/PPvH8h9fvwXNPU5An3cTU4Fr3M5TZLrkjJrUV85YJZo5s7GzAyRefO8ZI4faoxaJ7xdoY5SnYUnss7JujcJmFSy/sXm/cbnDSz4gzHmvFrnqYauKIpSEE7obIshnFZ9ww03pH4DLFq0CEhvNnJhio899ljqep/vfOc78fHll18OwPz5UXjU8PBw1fnNwIVdnmgaepEJaX+hd96wtp8OfQw5TDO16pzkyi3jv5nkcBL6MiQbi/w53Ym2+DPVZfCCG5Gy3nYz3iJSY2U4cJuhmdeLauiKoigFQR/oiqIoBUGdonWwZMkSAH7/+9/HbS4Frx8f7nDmDrdjdCaEnKJuh+vg4CAA4+NJNXLnwA3tUv35z38OwFVXXTVjubqNIjlF3at9nFcko9K97xx15/tOUVeAwcVXp2K1AztFK2WoZUrJ6s8y22SadDLuN288d67kvxk5ckJjZDlkZyJXFuoUVRRFOcFQp2gdrF27FoDVq1fHbd/73vdS5/hhiAsXLqQR9u7dC8Czzz4btz344INAuhiH63eO2Ve9Kska9+UvfxmAWbOSZP+ON77xjUDyxgGaEbKrCWjQlRpxWLuenilvd2TJFpRIjTnDHY0Na+WBuVMO0Pi7qI+gm9gVkK4xWl1mhZDFo8W7Q31UQ1cURSkIqqHXwWWXXVbzHD/3y5o1a6Y9z9neneYN8O1vfxsIa+gh1q1bByT2+7w28ZNPPhlIcsGAaujdQii8TjLcAkkY4pTXVm1XL1Vojr4vZsq6tkre3JX5XWqGI1ZlhKwuM1cpnz9+lhY7fRCmG6M2KS2/IrNlvaGZWSGT9ZYQbDaqoSuKohQEfaAriqIUBDW51IFzivr88Ic/BBJn6AUXXFB1jv96+61vfQuAz3/+8wAcOHAg19wuNNE34/zsZz8D4NRTT801hsPtZm1nyKqSTfC1v9JM4hsaYrPBlP3ohy3WLoeWNnskeyAbJsPkkMe0kRVeGDJxzMTN6OSZnIpyvkip35OjMfNLlemlxvmtQjV0RVGUgpBbQ7dFALYAO4wxV4jIGuAOYBFRkd0PGWOOt0bM7mD//v1Vba7oxVe+8hUA/vrXv8Z9r33ta4F0kYnbb78dyNbMXVjkm970prjtM5/5DADr169vRPQUrlyec8yeyPTSujaBjUhOG/e18nFbgs0vEeeyiFZen26r/hQXqja+Rm9/BzMYZmUiLLkb8Tpr66y1nKKVcuUdY4qchZ0rnajefed5x23nTrd6NPTricpzOW4EbjbGnAbsBa5tpmCK0iZ0XSuFIdcDXURWAv8BuNV+FuAS4C57ymbgylYIqCitQte1UjTymly+DvwdMNd+XgTss1XRAbYDK0IXFolvfvObAFxzzTVx2/ve9z4g2TF6zz33xH1XXHEFkE6R6wpnOFONizkHOOuss1Jjvf71r4/76i1wEeKmm24CEvOQ0kXrOuBUTMwdzqwyWXV+3OeZD8YmIxNfWRIzy0BpwF5WsmN5O0WtXmfEy/0S7x6txs1VDuiDlTHnUH9BiVCK3EpmEofu6qX22+8kPXDavBI1Rfc7ae+7z3ts5omjbyc1NXQRuQLYbYz5QyMTiMh1IrJFRLY0cr2itIJmruvR0dEmS6cojZFHQ78QeJeIXA4MAfOAbwDzRaTPajMrgR2hi40xm4BN0PvZFp9++mkg0bIh0cLd7ss777wz7nv7298OwIYNG+I2t6vz+9//PgCvec1r4r7FixcDMGfOnIbk27lzZ3z84x//GIBbb701btu2bRsABw8ebGj8gtG0dX3OuWc3tq5DWp3fVpFJ0dfQncMzFMbnNPN+PxzPaqWJYzIp0xZro6nCE+n8LqXUDNNr4bkKXHj36Mb1NfRkLCefvwt25sRO3YDMcZv3BhN//zbMcarkOZuluphGJ6mpoRtjbjDGrDTGrAauAv7JGPNB4AHgvfa0jcB9LZNSUZqMrmuliNSVD11E3gr8NxvetZYovGsh8EfgGmNMdfLt9PU9raE3ypNPPhkfv/rVr25ojJLVCqamEs1hx45IeXQ28VtuuaVREQtDI/nQZ7quG86HHuystqG7osduIwwkRY9DGvHxyUjclA29PJg6Z3wqyZ1fCoQTlq127zTWUsA2npdKO7Ok+tybQ6CEm0l0dEeoKHajmRfd9zk+lUSlOrt6KqSxwq7uF9iOv+MMG3ozrOt586HXtVPUGPNr4Nf2+AXg/EaEU5RuQte1UhR0p6iiKEpB0FwubeDiiy+Oj52ZpF6OHDkCwB133BG3fepTnwLUyXmikDJVOCdnoK/PlpsreSaXUpbuZk0K4yYxwziLQxKGmDwqwo7SWDArTygMcfpSd6EcMMmOVM/x6EIIPacuGSadrHJ/Sam+xNk8Yc0vk57JxcnrzCvdEaAYRjV0RVGUgqAaehtw5eBmggtJvPZa3Yl+olDl8BQ/tC995GvLfWIdmv75FU5N32Hq+vo9P6ArKg3VWm8cxueL5s4LFEuWijHSYYKubfoSer5D1h1PTCZvE05bL7vHWcCB68/pnKD7jr8SjeU5m0cG5kf35oUt9ldsygptnspLM7JFZqEauqIoSkHQB7qiKEpBUJNLG3D5XhSlHiqdhyFnYrzT0jMDNLp3MTGzJA7V0M5JAmYVU2lM8M53Ts1wwYrqWPMEG2sfis334uidCaXPxs77DmB3H74TdffRXQD85m+/BeCMha+K+5zJJWQWqrf4RSdQDV1RFKUgqIbeYY4dSzYhOofne97zHiDJEwOwdOlSAC677LK47Re/+EU7RFTaSSCXi9M4p7yuEtM76OrNeOjC9kqBvCRxiJ/nAp2055dTOVlKdoyAjiiVTtFsfL0/mi/Rrp2z0s+UGO/utH0TXvjl5FQk69jkkbjt8VceB+Cft0U7uM9flmzAdGOV/WyU9nsJhWnGIZnBihvpnDTp6+wpgb6ZoBq6oihKQVANvcP09ycZ8T74wQ8CSeHpN7/5zXGf09C/+tWvxm0PPfQQAPv27Wu5nEr7SUq32dBE45V8q9CEQxt5fCrb/M9xjhhvyHKFDd0vZxfazDSd7Ok5A4SKSseabXUWyHh8//7dm4xtK3uPtXGbhufAeFLy8fhkZHNfO38RAEuGl8Z9Lk+LSPXGoqx8LXkKYbcD1dAVRVEKgj7QFUVRCkJd6XNnPNkJmj736quvjo9vu+22hsYIlaBzJeueeOKJGUhXLBpJnztTmpE+N+gwrEjbalKhgPWZXCqZ9PKXOKejP0ZleTZ/7smMEnSlOESxumhEiExTRcjEEQiZrMTPzeJCGo9MHIrbDo1Hx8PlqDTkwqElifxx4ZAGa5b495GjLF3exZo3fa5q6IqiKAUhl1NURF4EDgKTwIQx5jwRWQj8CFgNvAhsMMbsnW6ME5l77703Pnahhn74odI5unptVxSOrnRrzoRyKhNjtdMvq6RcyEmYZxNUbsdhowWX3ffkvcWGwhxHBkYAGC7PBioyUQayRU43D9TQ5HO8TTSbejT0i40xZ3lq/2eB+40xpwP328+K0ovo2lYKwUxMLu8GNtvjzcCVMxdHUboCXdtKT5I3Dt0A/8c6Nb/XuQ8PAAAIN0lEQVRjK54vM8a4MvO7gGWtELAIHD16ND6+5pprgCSefOPGjXHfwEDaERVidHQ0Pj5w4EDGmUpOumptB4szxJ+9V/14F2ntGOnakwbMDJnmngbHN+nPkMgfcgYH7ynrPl28vqenDpaHgLQTeNzWXC1l1APN+jaNb2pyofIzNIE1i7wP9IuMMTtEZCnwKxF52u80xpjpIlhE5DrguhnKqSitoqG17a/rVaesbI+kilKDusMWReR/AoeAjwBvNcbsFJHlwK+NMZkl7U/UsMUs1q1bFx9fdNFFQDiXiysz97nPfS5uu+WWW9ohYk8xk7DFRtd2M8MWQ+eZQNk19+/WhS+WM/KwpBurNW5jwxD9Z4HLXOjm9As+uONUdsaMXC6VDta8IZZ5dmimMNV5Z0LZIl1/nKPFL/aRZ5qMuYMEC5PUR9PCFkVktojMdcfAvweeAH4COHvBRuC+BmVVlI6ga1spGjU1dBFZC9xjP/YBPzTGfElEFgF3AqcAW4lCu16pMZZq6EpLqUdDb9barldDz0u1hp7YgV1bXg3dZGxSCmnOiYZeXUjZkSpCHRetzhH2N42Mjqpra2i4oULQldem8rnHXaG3ifqo94HWag29pg3dGPMCcGagfQ9waWPiKUrn0bWtFA3dKaooilIQNH2uohSAYO4U47el+0zAERgyQVSm0fWRwE7RzJwsdQZghIpHmIz8LkHzjYuAzDB2dH9hufyohq4oilIQVENXlC4iS4f1NVAXeiem2skZcgQ6DbUch+pl63JVoYaB0njNKObQ8Bh586nEE2VlfPTl6W1UQ1cURSkIqqErSpcTCjV0YYTJBiNfg5bUORAqAJ29+cZtGkr6QpuUqt8KQsx4e3yNjUUh238ucmZDbFVB51agGrqiKEpB0Ae6oihKQVCTi6J0iLwGCGf2SOccidomsaYXb7QkA6Ovr9k8J7GpJukJOkgrzBEhp2i9ZBXNyMSfTwJjVMiTu5xdTkdpVlu3oRq6oihKQVANXVF6BD9fi3E5XIwrypwQLDidgQQ2/sy0CLVP5fl1hyoG85VnyFMjv3l2aKg7qH4r6AVUQ1cURSkI+kBXFEUpCGpyUZQOUdMMULEjM+34LFUPEg88vclB7HUhJ6fxkqbEse8V50TnZZtAKmWtjGGvtUt1ujGjtmoZ8phwgiXugpNOX1QjK3VvvX2tQjV0RVGUgpBLQxeR+cCtwOuI/uP5z8AzwI+A1cCLREUA9rZESkVpEd2ytoOOzApnZUgTzcowmD7P/Z6sniiUDTFr52dm5sJQwenaY2bRLS7JPM7UTsuaV0P/BvC/jTFnEBUEeAr4LHC/MeZ04H77WVF6DV3bSmHIU4JuBHgMWGu8k0XkGbRItNJl1FmCrilru9Ul6LqCWpuJulz7bvV32er7aFqRaGAN8DLwPRH5o4jcagvqLjPG7LTn7AKWhS4WketEZIuIbMkrvKK0iYbXtr+uR0dH2yiyokxPngd6H3AOcIsx5mzgMBWvoFa7mcZRbzYZY87L87+LorSZhte2v64XL17cFmEVpRZ5Hujbge3GmIft57uI/hG8ZF9Hsb93t0ZERWkZXb22pYk/MxdGsn8alLldNPO77OR91KLmA90YswvYJiLOhngp8CTwE2CjbdsI3NcSCRWlRejaVopG3o1F/xW4XUQGgBeADxP9Z3CniFwLbAU2tEZERWkpJ8Ta7iYtUmkduR7oxpjHgJAN/NLmiqMo7UXXtlIkdKeooihKQdAHuqIoSkHQB7qiKEpBqLlTtKmTibxMFOvbyzsxFtO78vey7FBb/lONMUvaJYzDruut9Pb328uyQ2/Ln0f2XGu7rQ90ABHZ0subjHpZ/l6WHbpf/m6XL4telh16W/5myq4mF0VRlIKgD3RFUZSC0IkH+qYOzNlMeln+XpYdul/+bpcvi16WHXpb/qbJ3nYbuqIoitIa1OSiKIpSENr6QBeRd4jIMyLynIh0dRUYEVklIg+IyJMi8i8icr1tXygivxKRv9jfCzot63SISNnm+f6p/bxGRB623/+PbP6SrkRE5ovIXSLytIg8JSIXdOt330vrGnRtd5pWru22PdBFpAx8E7gMWA9cLSLr2zV/A0wAnzbGrAfeAHzcyttL5cmuJyqp5rgRuNkYcxqwF7i2I1LloydKw/XgugZd252mdWvbGNOWH+AC4Jfe5xuAG9o1fxPkvw94G1EB4eW2bTnwTKdlm0belXZhXAL8lCjh3ijQF/p7dNMPMAL8Fevj8dq77rvv9XVtZda13T7ZW7q222lyWQFs8z5vt21dj4isBs4GHiZn6b0u4OvA3wFT9vMiYJ8xZsJ+7ubvf0ZlD9tMz65r0LXdAVq6ttUpWgMRmQPcDXzKGHPA7zPRf6ddFyYkIlcAu40xf+i0LA0yo7KHSj50bXeElq7tdj7QdwCrvM8rbVvXIiL9RAv+dmPMP9rmrihPVoMLgXeJyIvAHUSvpt8A5ouIy4Hfzd9/V5eGq6Dn1jXo2u4gLV3b7XygPwKcbr3RA8BVRKW+uhIREeC7wFPGmJu8rq4vT2aMucEYs9IYs5roe/4nY8wHgQeA99rTulJ26LnScD21rkHXdidp+dpus0PgcuBZ4Hngf3TaQVFD1ouIXnv+DDxmfy4nstfdD/wF+L/Awk7LWuM+3gr81B6vBf4f8BzwY2Cw0/JlyH0WsMV+//cCC7r1u++ldW3l1bXdWblbtrZ1p6iiKEpBUKeooihKQdAHuqIoSkHQB7qiKEpB0Ae6oihKQdAHuqIoSkHQB7qiKEpB0Ae6oihKQdAHuqIoSkH4/+z2WLy1hMZ4AAAAAElFTkSuQmCC\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)"
   ]
  },
  {
   "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
}