lstm_autoencoder.nbconvert.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torchvision import transforms, datasets\n",
    "from resnet_feature_extracter import Img2Vec\n",
    "import numpy as np\n",
    "import os\n",
    "import time\n",
    "import copy\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Device configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyper parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_length = 6\n",
    "input_size = 2048\n",
    "hidden_size = 32#64#1024\n",
    "num_layers = 2\n",
    "batch_size = sequence_length # set to the number of images of a seqence # 36\n",
    "num_epoches = 100#250\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature vector extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "extractor = Img2Vec()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Antoencoder definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderRNN(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, hidden_size, num_layers, bidirectional):\n",
    "        super(EncoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, \n",
    "                            dropout=0.2, bidirectional=bidirectional)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        # initialize weights\n",
    "        #nn.init.xavier_uniform_(self.lstm.weight_ih_l0, gain=np.sqrt(2))\n",
    "        #nn.init.xavier_uniform_(self.lstm.weight_hh_l0, gain=np.sqrt(2))\n",
    "        nn.init.orthogonal_(self.lstm.weight_ih_l0, gain=np.sqrt(2))\n",
    "        nn.init.orthogonal_(self.lstm.weight_hh_l0, gain=np.sqrt(2))\n",
    "\n",
    "    def forward(self, x):\n",
    "        # set initial hidden and cell states\n",
    "        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)\n",
    "        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)\n",
    "\n",
    "        # forward propagate lstm\n",
    "        out, _ = self.lstm(x, (h0, c0))  # out: tensor of shape (batch_size, seq_length, hidden_size)\n",
    "\n",
    "        return out[:, -1, :].unsqueeze(1)\n",
    "\n",
    "\n",
    "class DecoderRNN(nn.Module):\n",
    "\n",
    "    def __init__(self, hidden_size, output_size, num_layers, bidirectional):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "        self.num_layers = num_layers\n",
    "        self.lstm = nn.LSTM(hidden_size, output_size, num_layers, batch_first=True,\n",
    "                            dropout=0.2, bidirectional=bidirectional)\n",
    "\n",
    "        # initialize weights\n",
    "        #nn.init.xavier_uniform_(self.lstm.weight_ih_l0, gain=np.sqrt(2))\n",
    "        #nn.init.xavier_uniform_(self.lstm.weight_hh_l0, gain=np.sqrt(2))\n",
    "        nn.init.orthogonal_(self.lstm.weight_ih_l0, gain=np.sqrt(2))\n",
    "        nn.init.orthogonal_(self.lstm.weight_hh_l0, gain=np.sqrt(2))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # set initial hidden and cell states\n",
    "        h0 = torch.zeros(self.num_layers, x.size(0), self.output_size).to(device)\n",
    "        c0 = torch.zeros(self.num_layers, x.size(0), self.output_size).to(device)\n",
    "\n",
    "        # forward propagate lstm\n",
    "        out, _ = self.lstm(x, (h0, c0))  # out: tensor of shape (batch_size, seq_length, hidden_size)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class AutoEncoderRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_layers, bidirectional=False):\n",
    "        super(AutoEncoderRNN, self).__init__()\n",
    "        self.encoder = EncoderRNN(input_size, hidden_size, num_layers, bidirectional)\n",
    "        self.decoder = DecoderRNN(hidden_size, input_size, num_layers, bidirectional)\n",
    "\n",
    "    def forward(self, x):\n",
    "        encoded_x = self.encoder(x).expand(-1, sequence_length, -1)\n",
    "        decoded_x = self.decoder(encoded_x)\n",
    "\n",
    "        return decoded_x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageFolderWithPaths(datasets.ImageFolder):\n",
    "    \"\"\"Custom dataset that includes image file paths. Extends\n",
    "    torchvision.datasets.ImageFolder\n",
    "    \"\"\"\n",
    "\n",
    "    # override the __getitem__ method. this is the method dataloader calls\n",
    "    def __getitem__(self, index):\n",
    "        # this is what ImageFolder normally returns \n",
    "        original_tuple = super(ImageFolderWithPaths, self).__getitem__(index)\n",
    "        # the image file path\n",
    "        path = self.imgs[index][0]\n",
    "        # make a new tuple that includes original and the path\n",
    "        tuple_with_path = (original_tuple + (path,))\n",
    "        return tuple_with_path\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "data_dir = './pregnant'\n",
    "\n",
    "data_transforms = transforms.Compose([\n",
    "    transforms.Resize((224, 224)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),])\n",
    "\n",
    "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), \n",
    "                                          transform=data_transforms) for x in ['train', 'val']}\n",
    "data_loaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                                               batch_size=batch_size, shuffle=False) for x in ['train', 'val']}\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}\n",
    "'''\n",
    "data_dir = './pregnant'\n",
    "\n",
    "data_transforms = transforms.Compose([\n",
    "    transforms.Resize((224, 224)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),])\n",
    "\n",
    "image_datasets = {x: ImageFolderWithPaths(os.path.join(data_dir, x), \n",
    "                                          transform=data_transforms) for x in ['all']}\n",
    "data_loaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                                               batch_size=batch_size, shuffle=False) for x in ['all']}\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['all']}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, criterion, optimizer, num_epoches=25):\n",
    "    #losses = {'train': [], 'val': []}\n",
    "    losses = {'all': []}\n",
    "\n",
    "    since = time.time()\n",
    "\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    best_loss = 100\n",
    "\n",
    "    for epoch in range(num_epoches):\n",
    "        #print('Epoch {} / {}'.format(epoch + 1, num_epoches))\n",
    "        #print('-' * 10)\n",
    "\n",
    "        #for phase in ['train', 'val']:\n",
    "        for phase in ['all']:\n",
    "            if phase == 'val':\n",
    "                # scheduler.step()\n",
    "                model.eval()\n",
    "            else:\n",
    "                model.train()\n",
    "\n",
    "            running_loss = 0.0\n",
    "            \n",
    "            # sequence input\n",
    "            for i in range(dataset_sizes['all'] - batch_size):  \n",
    "                imgs = []\n",
    "                for ii in range(i, i + batch_size):\n",
    "                    path = os.path.join('{}{}.jpg'.format('./pregnant/all/pregnant/', ii)) \n",
    "                    img = data_transforms(Image.open(path))\n",
    "                    imgs.append(img)\n",
    "                \n",
    "                inputs = torch.stack(imgs)\n",
    "            #for inputs, _, paths in data_loaders[phase]:\n",
    "                inputs = extractor.get_vec(inputs)\n",
    "                \n",
    "                inputs = inputs.reshape(-1, sequence_length, input_size).to(device)\n",
    "\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                with torch.set_grad_enabled(phase != 'val'):\n",
    "                    outputs = model(inputs)\n",
    "\n",
    "                    inv_idx = torch.arange(sequence_length - 1, -1, -1).long()\n",
    "                    loss = criterion(outputs, inputs[:, inv_idx, :])\n",
    "\n",
    "                    if phase != 'val':\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "\n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            \n",
    "            losses[phase].append(epoch_loss)\n",
    "\n",
    "            #print('{} Loss: {:4f}'.format(phase, epoch_loss))\n",
    "\n",
    "            if phase == 'val' and epoch_loss < best_loss:\n",
    "                best_loss = epoch_loss\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "        \n",
    "        #print()\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
    "    print('Best val loss: {:4f}'.format(best_loss))\n",
    "\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training complete in 90m 3.947445s\n",
      "Best val loss: 100.000000\n"
     ]
    }
   ],
   "source": [
    "model = AutoEncoderRNN(input_size, hidden_size, num_layers)\n",
    "model = model.to(device)\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "\n",
    "model, losses = train_model(model, criterion, optimizer, num_epoches)\n",
    "torch.save(model.state_dict(), './lstm_autoencoder_model.pt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot training/val curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAJcCAYAAABaP3UWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XmUnmV9P/73NTNZyArJkAkQloSwhV0SEgliUMAdcUHFpagoWqu21drT1q767ddW2lqtoOJX2rogCmq1FUUUA4RNdpSwJIQlYckGIRvZZu7fHzP4izSETDIz9zMzr9c5c3iW+76f98PxOgff574+T6mqKgAAAACwK5rqDgAAAABA/6dkAgAAAGCXKZkAAAAA2GVKJgAAAAB2mZIJAAAAgF2mZAIAAABglymZAAAAANhlSiYAgCSllC+XUv6qhs+tSilTn+e9uaWU9/V1JgCAnaFkAgD6vVLKQ6WUU3blGlVVfbCqqk9383PvL6UcvCufCwAwUCiZAIABr5TS0gvXPDBJU1VV9/f0tQEA+iMlEwDQr5VSvpFkvyT/XUpZW0r501LKAV3b0M4ppTyS5KquYy8tpTxRSnm6lHJNKeXwra7zH6WU/9P1eE4pZUkp5eOllGWllMdLKe95zke/JsnlpZRZXdds3upabyil3NX1+PhSyg2llFVd1/liKWXoTnzPplLKX5ZSHu7K9PVSytiu94aXUr5ZSlnZ9Tk3l1Laut57dyllUSllTSnlwVLKO7a65ntLKfeUUp4qpVxRStm/6/VSSvlc1+c8XUq5q5RyRHczAwCDi5IJAOjXqqp6V5JHkryuqqpRVVV9dqu3X5rksCSv6Hr+kyQHJZmQ5LYk39rOpScmGZtknyTnJDm/lLLHVu+/OsmPq6q6Mcm6JC/b6r23J7m463F7kj9O0prkxUlenuRD3fyaSfLurr+Tk0xJMirJF7veO7sr675Jxif5YJJnSikjk3whyauqqhqd5IQkdyRJKeWMJH+R5I1J9kxybZJvd13vtCQnJTk4ye5J3ppk5U5kBgAGESUTADCQ/W1VVeuqqnomSaqquqiqqjVVVW1M8rdJjn72bqBt2JzkU1VVba6q6vIka5MckiSllBFJZiS5uuvYbyc5q+u90eksoL7d9Zm3VlV1Y1VVW6qqeijJV9JZfnXXO5L8S1VVi6qqWpvkz5O8rWsr4OZ0lktTq6pq7/rM1V3ndSQ5opSyW1VVj1dVdXfX6x9I8pmqqu6pqmpLkv+b5Jiuu5k2Jxmd5NAkpeuYx3ciMwAwiCiZAICBbPGzD0opzaWUfyilPFBKWZ3koa63Wp/n3JVd5cuz1qfz7qGk826k66uq2tD1/OIkbyylDEvnnUG3VVX1cNfnHlxK+Z+uLXWr01nmPN9nbs/eSR7e6vnDSVqStCX5RpIrklxSSnmslPLZUsqQqqrWpfMupA8mebyU8uNSyqFd5++f5PNd2+tWJXkySUmyT1VVV6XzLqnzkywtpVxYShmzE5kBgEFEyQQADATVDrz+9iSvT3JKOreWHdD1etmJz3t1kh//9kOqan46S59X5Xe3yiXJl5Lcm+SgqqrGpHOL2s585mPpLIaetV+SLUmWdt1t9XdVVU1L55a41yb5va5sV1RVdWqSvbpyfLXr/MVJPlBV1e5b/e1WVdX1Xed9oaqq45Icns5tc5/YicwAwCCiZAIABoKl6ZxTtD2jk2xM52yhEem8o2hnvSrJ5c957eIkH03nLKNLn/O5q5Os7bqL6Pd38jO/neSPSymTSymj0pn/O1VVbSmlnFxKObJr+PjqdG53ay+ltJVSTu+azbQxnVv+2ruu9+Ukf/7s8PNSythSypldj2eUUmaWUoakc97Uhq3OAwDYJiUTADAQfCbJX3Zt/fqT5znm6+m82+jRJPOT3LgzH9T1K2trq6p65DlvfTvJnCRXVVW1YqvX/ySddzetSeddRN/Zmc9NclE6t8Vdk+TBdBY/H+l6b2KSy9JZMN2TzllR30znf+t9PJ13QT2ZzllQH0qSqqp+kOQf07nFbnWS36SzPEuSMV1Zn0rnv7OVSf5pJ3MDAINEqarnu7scAIDnKqX8aZLWqqr+tO4sAACNpKXuAAAA/cxDSf677hAAAI3GnUwAAAAA7DIzmQAAAADYZQNmu1xra2t1wAEH1B2jR6xbty4jR46sOwb0G9YMdI81A91jzUD3WDPQPY2+Zm699dYVVVXtuSPHDpiS6YADDsgtt9xSd4weMXfu3MyZM6fuGNBvWDPQPdYMdI81A91jzUD3NPqaKaU8vKPH2i4HAAAAwC5TMgEAAACwy5RMAAAAAOyyATOTCQAAAGBHbN68OUuWLMmGDRvqjpKxY8fmnnvuqTtGhg8fnkmTJmXIkCE7fQ0lEwAAADCoLFmyJKNHj84BBxyQUkqtWdasWZPRo0fXmqGqqqxcuTJLlizJ5MmTd/o6tssBAAAAg8qGDRsyfvz42gumRlFKyfjx43f5zi4lEwAAADDoKJh+V0/8+1AyAQAAALDLlEwAAAAADeKAAw7IihUrkiSjRo3a5jHP93rdlEwAAAAA7DIlEwAAAEAfO+OMM3Lcccfl+OOPz4UXXrhT16iqKp/4xCdyxBFH5Mgjj8x3vvOdJMnjjz+ek046Kcccc0yOOOKIXHvttWlvb8+73/3u3x77uc99rie/TpKkpcevCAAAANBP/N1/3535j63u0WtO23tM/uZ1h2/3mIsuuijjxo3LsmXL8rKXvSxvetObMn78+G59zve///3ccccdufPOO7NixYrMmDEjJ510Ui6++OK84hWvyCc/+cm0t7dn/fr1ueOOO/Loo4/mN7/5TZJk1apVO/39no+SCQAAAKCPfeELX8gPfvCDdHR0ZPHixVmwYEG3S6Z58+blrLPOSnNzc9ra2vLSl740N998c2bMmJH3vve92bx5c84444wcc8wxmTJlShYtWpSPfOQjec1rXpPTTjutx7+TkgkAAAAYtF7ojqPeMHfu3Pz85z/PDTfckPb29rzuda/Lhg0bun2dqqq2+fpJJ52Ua665Jj/+8Y/zrne9K5/4xCfye7/3e7nzzjtzxRVX5Pzzz893v/vdXHTRRbv6VX6HmUwAAAAAfejpp5/OHnvskREjRuT+++/PjTfeuFPXOemkk/Kd73wn7e3tWb58ea655pocf/zxefjhhzNhwoS8//3vzznnnJPbbrstK1asSEdHR970pjfl05/+dG677bYe/lbuZAIAAADoU6985Svz5S9/OUcddVQOPPDAzJo1a6eu84Y3vCE33HBDjj766JRS8tnPfjYTJ07Mf/7nf+a8887LkCFDMmrUqHz961/Po48+mve85z3p6OhIknzmM5/pya+URMkEAAAA0KeGDRuWn/zkJ0mSNWvWZPTo0b9976GHHvrt47Vr127z/GdfL6XkvPPOy3nnnfc775999tk5++yz/9d5vXH30tZslwMAAABglymZAAAAANhlSiYAAABg0Hm+X2YbrHri34eSCQAAABhUhg8fnpUrVyqaulRVlZUrV2b48OG7dB2DvxtMe0eVDv8jBwAAgF4zadKkLFmyJMuXL687SjZs2LDL5U5PGD58eCZNmrRL11AyNZivzVuU7960IXsftjqHThxTdxwAAAAYcIYMGZLJkyfXHSNJMnfu3Bx77LF1x+gRtss1mLYxw/PEuo689gvz8o8/vTfPbGqvOxIAAADAC3InU4N5/TH7pGnZ/bnm6XH50twH8j93PZZPvf6InHzIhLqjAQAAADwvdzI1oNFDS8478+hccu6sDG1uynv+/eb8wcW3ZdnqDXVHAwAAANgmJVMDmzVlfC7/w5fk46cenCvnL83L//nqfOOGh9LeYTA4AAAA0FiUTA1uWEtzPvLyg3LFH52Uo/fdPX/1w7vzpi9dn/mPra47GgAAAMBvKZn6icmtI/ONc47Pv771mCx5an1e98V5+b+X35P1m7bUHQ0AAABAydSflFJyxrH75Ocfe2neMn1SLrxmUU773DW5+v7ldUcDAAAABjklUz+0+4ih+cwbj8p3P/DiDGtpytkX/Sp/dMntWbl2Y93RAAAAgEFKydSPHT95XC7/w5fkoy8/KD/+9eM55V+uzvduXZKqMhgcAAAA6FtKpn5uWEtzPnbqwfnxR1+SKXuOyscvvTPv+tqv8vDKdXVHAwAAAAYRJdMAcXDb6Fz6gRfn02cckTsWr8or/vWafPnqB7KlvaPuaAAAAMAgoGQaQJqaSt41a//8/GMvzUkH7Zl/+Mm9Of2L1+WuJavqjgYAAAAMcEqmAWji2OG58Pem58vvfFFWrN2YM86/Lp+5/J5s2NxedzQAAABggFIyDWCvPGKv/PzjL81bZ+ybr1yzKK/+wrW59eGn6o4FAAAADEBKpgFuzPAh+cwbj8o3z5mZjZs78uYvX5+///F8dzUBAAAAPapXS6ZSyitLKfeVUhaWUv5sG+9/sJTy61LKHaWUeaWUaVu99+dd591XSnlFb+YcDE48qDVX/PFJefvx++Wr1z6YV3/+2tzy0JN1xwIAAAAGiF4rmUopzUnOT/KqJNOSnLV1idTl4qqqjqyq6pgkn03yL13nTkvytiSHJ3llkgu6rscuGDWsJX//hiPzrffNzMYtHTnzKzfk0/8zP89sclcTAAAAsGt6806m45MsrKpqUVVVm5JckuT1Wx9QVdXqrZ6OTFJ1PX59kkuqqtpYVdWDSRZ2XY8eMHtq511N75y5f74278G86vPX5GZ3NQEAAAC7oFRV9cJH7cyFS3lzkldWVfW+rufvSjKzqqoPP+e4P0jysSRDk7ysqqoFpZQvJrmxqqpvdh3ztSQ/qarqsuece26Sc5Okra3tuEsuuaRXvktfW7t2bUaNGtUnn3XPyvZ87Tcbs/KZKqfs35I3HzQ0w1pKn3w29JS+XDMwEFgz0D3WDHSPNQPd0+hr5uSTT761qqrpO3JsSy/m2FZT8b8araqqzk9yfinl7Un+MsnZ3Tj3wiQXJsn06dOrOXPm7ErehjF37tz01XeZk+T3Xrsl//jTe/P1Gx7OA+uG5V/fdkyOmrR7n3w+9IS+XDMwEFgz0D3WDHSPNQPdM5DWTG9ul1uSZN+tnk9K8th2jr8kyRk7eS67YOSwlnzq9Ufk4vfPzDOb2/PGC67P+b9cmPaO3rnLDQAAABh4erNkujnJQaWUyaWUoekc5P2jrQ8opRy01dPXJFnQ9fhHSd5WShlWSpmc5KAkv+rFrCQ54cDW/PQPT8orDp+Y8664L2d99cY8uuqZumMBAAAA/UCvlUxVVW1J8uEkVyS5J8l3q6q6u5TyqVLK6V2HfbiUcncp5Y50zmU6u+vcu5N8N8n8JD9N8gdVVfkJtD4wdsSQfPHtx+afzjw6dz/6dF75r9fkR3e6iQwAAADYvt6cyZSqqi5PcvlzXvvrrR7/4XbO/fskf9976Xg+pZS8+bhJmXHAHvmj79yRj3779sy9d1n+7vWHZ/TwIXXHAwAAABpQb26Xo5/bf/zIXPqBF+ePTjko/3XHo3nV56/NLQ89WXcsAAAAoAEpmdiuluam/NEpB+fSD56QUpK3fOWG/MuV92dLe0fd0QAAAIAGomRihxy3/x65/KMvyRuOnZQv/GJB3vKVG/L404aCAwAAAJ2UTOyw0cOH5J/fcnT+7axjc//StXntF+bl+oUr6o4FAAAANAAlE932uqP3zg8/PDvjRg7NO792Uy6YuzBVVdUdCwAAAKiRkomdcuCeo/JffzA7rz5yr3z2p/fl3G/cmtUbNtcdCwAAAKiJkomdNnJYS/7trGPz16+dll/euyyn/9u83PP46rpjAQAAADVQMrFLSil574mT8+1zZ2X9pva84YLr8oPbl9QdCwAAAOhjSiZ6xIwDxuV/Pnpijpq0e/74O3fmr/7rN9m0paPuWAAAAEAfUTLRYyaMHp5vvW9m3v+SyfnGjQ/nLV+5IY8//UzdsQAAAIA+oGSiRw1pbsonXzMtF7zjRVmwdE1e+4V5ufXhp+qOBQAAAPQyJRO94tVH7pUffvjEjB7ekrd/9cb89DeP1x0JAAAA6EVKJnrN1Amj8r3fPyHT9h6T3//Wbblo3oN1RwIAAAB6iZKJXjV+1LBc/L5ZOW1aWz71P/Pzqf+en46Oqu5YAAAAQA9TMtHrdhvanAvecVzefcIBuei6B/Ohb92WDZvb644FAAAA9CAlE32iuankb08/PH/12mm5Yv4TeftXb8yT6zbVHQsAAADoIUom+tQ5J07OBW9/Ue5+bHXeeMF1eWjFurojAQAAAD1AyUSfe9WRe+Xi98/M089szhu/dH1ue+SpuiMBAAAAu0jJRC2O239cvvf7J2TUsJacdeGN+elvnqg7EgAAALALlEzUZsqeo/L9D52QQ/cak9//1q35zs2P1B0JAAAA2ElKJmrVOmpYLnn/rLzkoD3zZ9//dS69ZXHdkQAAAICdoGSidrsNbc6F7zouJ05tzZ9+76784PYldUcCAAAAuknJREMYPqQ5F75remZNHp+Pf/fO/PCOR+uOBAAAAHSDkomGsdvQ5nzt3dMz/YBx+dh378yP73q87kgAAADADlIy0VBGDG3Jv797Ro7dd/d89JLb/eocAAAA9BNKJhrOyGEt+Y/3Hp+jJo3Nhy++LVfOX1p3JAAAAOAFKJloSKOGteQ/33t8Dt97TD70rVtz1b2KJgAAAGhkSiYa1pjhQ/L1c2bm0Ilj8sFv3Jar719edyQAAADgeSiZaGhjdxuSb5xzfKZOGJVzv35L5i1YUXckAAAAYBuUTDS83UcMzTffNzOTW0fmfV+/OTcuWll3JAAAAOA5lEz0C+NGDs233jcz++4xIh/4xq15cMW6uiMBAAAAW1Ey0W+MHzUsF717RppK8v6v35LVGzbXHQkAAADoomSiX9l33Ihc8I7j8tCKdfmjS+5Ie0dVdyQAAAAgSib6oRcfOD5/e/rhuereZTnvivvqjgMAAAAkaak7AOyMd87aP/c+sTpfvvqBHDpxdM44dp+6IwEAAMCg5k4m+q2/ed3hmTVlXP70e3flzsWr6o4DAAAAg5qSiX5rSHNTLnjHcZkweljO/cYtWbp6Q92RAAAAYNBSMtGvjRs5NP/v7OlZs2FLzv3Grdmwub3uSAAAADAoKZno9w6dOCb/8pZjcufiVfmL7/86VeUX5wAAAKCvKZkYEF55xMR87NSD8/3bH81Xr11UdxwAAAAYdJRMDBgfednUvObIvfKZn9ybX967rO44AAAAMKgomRgwSik578yjctjEMfnot2/PwmVr644EAAAAg4aSiQFlxNCWfPXs6Rna0pRzv3GLQeAAAADQR5RMDDj77L5bvnDWsVm0fF3++Wf31R0HAAAABgUlEwPS7KmtecfM/fL/5j2YWx9+su44AAAAMOApmRiw/vzVh2XvsbvlE5fdZdscAAAA9DIlEwPWqGEt+cc3HZVFy9flc1feX3ccAAAAGNCUTAxoJx7UmrOO3y9fvXZRbnvkqbrjAAAAwIClZGLA+4tXH5qJY4bnE5feadscAAAA9BIlEwPe6OFD8g9vOioPLF+Xf/35grrjAAAAwICkZGJQOOngPfO2GfvmwmseyB2LV9UdBwAAAAYcJRODxl+85rC02TYHAAAAvULJxKAxZviQfOaNR2bBsrX5wi9smwMAAICepGRiUJlzyIScedykfOWaRblriW1zAAAA0FOUTAw6f/naaWkdNTSfuPSubNxi2xwAAAD0BCUTg87Y3Tq3zd23dE2+eNXCuuMAAADAgKBkYlB62aFtedOLJuWCuQ/kN48+XXccAAAA6PeUTAxaf/3aaRk/cmj+5NI7s2lLR91xAAAAoF9TMjFojR0xJP/njCNy7xNr8t1bFtcdBwAAAPo1JROD2qnT2jJ9/z3yb1ctyIbNhoADAADAzlIyMaiVUvInrzgkS1dvzDdueLjuOAAAANBvKZkY9GZNGZ+XHNSaL139QNZu3FJ3HAAAAOiXlEyQ5E9OOyRPrtuUi+Y9WHcUAAAA6JeUTJDk6H13z2nT2vLVaxZl1fpNdccBAACAfkfJBF0+ftohWbtpS7589aK6owAAAEC/o2SCLodMHJ3Tj947/3H9g1m2ZkPdcQAAAKBfUTLBVv74lIOzub3KBb98oO4oAAAA0K8omWArB7SOzFumT8rFNz2SJU+trzsOAAAA9BtKJniOj7zsoCTJF36xoOYkAAAA0H8omeA59t59t7xj1n753m2PZtHytXXHAQAAgH5ByQTb8KE5UzO0uSmf+7m7mQAAAGBHKJlgG/YcPSzvPfGA/Pedj+Wex1fXHQcAAAAanpIJnse5Lzkwo4e35J9/dn/dUQAAAKDhKZngeYwdMSQfOGlKfn7P0tz2yFN1xwEAAICGpmSC7XjP7MkZP3Jo/vln99UdBQAAABqakgm2Y+Swlvz+nANz3cKVuf6BFXXHAQAAgIalZIIX8M5Z+2evscPzT1fcl6qq6o4DAAAADUnJBC9g+JDmfORlB+W2R1Zl7v3L644DAAAADUnJBDvgzOmTMmH0sHz9+ofqjgIAAAANSckEO2BIc1PeOmPfzL1/eZY8tb7uOAAAANBwlEywg946Y98kyXduXlxzEgAAAGg8SibYQZP2GJE5B++Z79y8OJvbO+qOAwAAAA1FyQTd8PaZ+2fZmo35xT3L6o4CAAAADUXJBN1w8iF7ZuKY4bn4V4/UHQUAAAAaipIJuqGlawD4tQuWZ/GTBoADAADAs5RM0E1vnbFvSpJLbnY3EwAAADxLyQTdtPfuu+XkQybku7csMQAcAAAAuiiZYCe8feZ+Wb5mY34+f2ndUQAAAKAhKJlgJ8w5ZEL2HmsAOAAAADxLyQQ7obmp5K0z9su1C1bk4ZXr6o4DAAAAtVMywU5664x909xU8u1fLa47CgAAANROyQQ7aeLY4XnZoRNy2a2Ls2mLAeAAAAAMbkom2AVvn7lfVqzdlCsNAAcAAGCQUzLBLjjpoD2zz+675eJfPVx3FAAAAKiVkgl2QXNTydtm7JvrFq7MQysMAAcAAGDwUjLBLnrLbweAP1J3FAAAAKiNkgl2UduY4TnlsAm59NYl2bilve44AAAAUAslE/SAt8/cP0+u25Qr7jYAHAAAgMFJyQQ94CVTW7PvuN1y8U0GgAMAADA4KZmgBzQ1lbxtxn65cdGTeWD52rrjAAAAQJ9TMkEPOXP6pLQ0lVxiADgAAACDkJIJesiE0cNz2uFtuezWJdmw2QBwAAAABhclE/Sgs47fL0+t35wr7n6i7igAAADQp3q1ZCqlvLKUcl8pZWEp5c+28f7HSinzSyl3lVJ+UUrZf6v32kspd3T9/ag3c0JPmX1g5wDwy25dUncUAAAA6FO9VjKVUpqTnJ/kVUmmJTmrlDLtOYfdnmR6VVVHJbksyWe3eu+ZqqqO6fo7vbdyQk9qaip59RF75YYHVubpZzbXHQcAAAD6TG/eyXR8koVVVS2qqmpTkkuSvH7rA6qq+mVVVeu7nt6YZFIv5oE+cdrhE7Olo8rc+5bVHQUAAAD6TEsvXnufJIu3er4kycztHH9Okp9s9Xx4KeWWJFuS/ENVVf/13BNKKecmOTdJ2traMnfu3F3N3BDWrl07YL7LYNRRVRk7rOSbc3+dsasW1B1nULBmoHusGegeawa6x5qB7hlIa6Y3S6ayjdeqbR5YyjuTTE/y0q1e3q+qqsdKKVOSXFVK+XVVVQ/8zsWq6sIkFybJ9OnTqzlz5vRI8LrNnTs3A+W7DFavWfXr/PD2RzNr9ksyfEhz3XEGPGsGuseage6xZqB7rBnonoG0Znpzu9ySJPtu9XxSkseee1Ap5ZQkn0xyelVVG599vaqqx7r+uSjJ3CTH9mJW6FGnTWvLuk3tuf6BFXVHAQAAgD7RmyXTzUkOKqVMLqUMTfK2JL/zK3GllGOTfCWdBdOyrV7fo5QyrOtxa5LZSeb3YlboUS8+cHxGDWvJz+5eWncUAAAA6BO9tl2uqqotpZQPJ7kiSXOSi6qquruU8qkkt1RV9aMk5yUZleTSUkqSPNL1S3KHJflKKaUjnUXYP1RVpWSi3xjW0pyTD52Qn9+zNO0dVZqbtrV7FAAAAAaO3pzJlKqqLk9y+XNe++utHp/yPOddn+TI3swGve20aW357zsfy22PPJUZB4yrOw4AAAD0qt7cLgeD2pxD9szQ5qb87O4n6o4CAAAAvU7JBL1k9PAhOWHq+Fxx99JU1TZ/WBEAAAAGDCUT9KLTpk3MI0+uz31L19QdBQAAAHqVkgl60SnTJqSU+JU5AAAABjwlE/SiCaOH50X77ZErzGUCAABggFMyQS87bVpb7n5sdZY8tb7uKAAAANBrlEzQy047fGKS5Mr5tswBAAAwcCmZoJdNbh2Zg9tG2TIHAADAgKZkgj5w2rSJ+dWDT+apdZvqjgIAAAC9QskEfeAVh09MR5X84t5ldUcBAACAXqFkgj5wxD5jstfY4bbMAQAAMGApmaAPlFJy2rS2XLtgeZ7Z1F53HAAAAOhxSiboI684fGI2bO7INQuW1x0FAAAAepySCfrIjMnjMna3IbbMAQAAMCApmaCPDGluyssPnZBf3LMsW9o76o4DAAAAPUrJBH3otMMn5ulnNudXDz5ZdxQAAADoUUom6EMnHdyaYS1N+dn8pXVHAQAAgB6lZII+NGJoS046eM/87O4nUlVV3XEAAACgxyiZoI+dNq0tjz29Ib95dHXdUQAAAKDHKJmgj738sLY0leRn8/3KHAAAAAOHkgn62LiRQ3P85HH52d3mMgEAADBwKJmgBqdNm5j7lq7JQyvW1R0FAAAAeoSSCWpw6rS2JLbMAQAAMHAomaAG+44bkcP3HpMrbJkDAABggFAyQU1efuiE3P7IU3n6mc11RwEAAIBdpmSCmpx40J7pqJIbF62sOwoAAADsMiUT1OSYfXfPbkOac93CFXVHAQAAgF2mZIKaDG1pyswp45RMAAAADAhKJqjRiVNb88DydXni6Q11RwEAAIBdomSCGp1wYGuSuJsJAACAfk/JBDU6dOLojB85VMkEAABAv6dkgho1NZW8+MDxmbdwRaqqqjsOAAC4AON4AAAgAElEQVQA7DQlE9TsxKmtWbZmYx5YvrbuKAAAALDTlExQs9lTO+cyzVtgyxwAAAD9l5IJarbvuBHZb9yIzFu4su4oAAAAsNOUTNAAZk9tzU2LVmZLe0fdUQAAAGCnKJmgAZw4tTVrNm7JXY8+XXcUAAAA2ClKJmgALz5wfJLk+oXmMgEAANA/KZmgAYwbOTSH7z0m85RMAAAA9FNKJmgQJ05tzW0Pr8ozm9rrjgIAAADdpmSCBnHC1NZsau/IzQ89WXcUAAAA6DYlEzSIGQfskaHNTbnOljkAAAD6ISUTNIgRQ1vyov13N5cJAACAfknJBA1k9oGtmf/46jy5blPdUQAAAKBblEzQQGYf1JqqSm54YGXdUQAAAKBblEzQQI7aZ2xGD2vJdQ/YMgcAAED/omSCBtLS3JSZU8Yb/g0AAEC/o2SCBnPi1PF5eOX6LH5yfd1RAAAAYIcpmaDBzJ7amiS53pY5AAAA+hElEzSYqRNGZcLoYZm30PBvAAAA+g8lEzSYUkpOnNqa6xeuSEdHVXccAAAA2CFKJmhAJ0xtzcp1m3Lf0jV1RwEAAIAdomSCBjR76vgk8StzAAAA9BtKJmhAe43dLQfuOVLJBAAAQL+hZIIGNXtqa2568Mls2tJRdxQAAAB4QUomaFCzp7Zm/ab23LF4Vd1RAAAA4AUpmaBBzZoyPk3FXCYAAAD6ByUTNKixuw3JkZN2VzIBAADQLyiZoIGdOHV87li8Kms3bqk7CgAAAGyXkgka2OyprdnSUeVXD66sOwoAAABsl5IJGtiL9tsjw1qaMm+BkgkAAIDGpmSCBjZ8SHOOnzwu1z9gLhMAAACNTckEDe6EA1tz7xNrsnzNxrqjAAAAwPNSMkGDO+HA8UmSm8xlAgAAoIEpmaDBHb73mIwa1pIbFymZAAAAaFxKJmhwLc1NmXHAHrlx0ZN1RwEAAIDnpWSCfmDWlPFZuGytuUwAAAA0LCUT9AOzppjLBAAAQGNTMkE/YC4TAAAAjU7JBP2AuUwAAAA0OiUT9BPmMgEAANDIlEzQT8zsmsv0qwfdzQQAAEDjUTJBP3HE3mMycmizuUwAAAA0JCUT9BMtzU2ZMXmckgkAAICGpGSCfmTWlPFZsGxtVqw1lwkAAIDGomSCfmRW11ymm/zKHAAAAA1GyQT9iLlMAAAANColE/Qj5jIBAADQqJRM0M+YywQAAEAjUjJBPzNz8rgk5jIBAADQWJRM0M8csc9Yc5kAAABoOEom6GeGNDdl+gHmMgEAANBYlEzQD5nLBAAAQKNRMkE/NGtK51ymXz1oLhMAAACNQckE/ZC5TAAAADQaJRP0Q+YyAQAA0GiUTNBPzZoyPvcvNZcJAACAxqBkgn5qprlMAAAANBAlE/RTR+4zNiPMZQIAAKBBKJmgnzKXCQAAgEaiZIJ+bNaUceYyAQAA0BCUTNCPzZoyPom5TAAAANRPyQT9mLlMAAAANAolE/Rjz85lummRO5kAAACol5IJ+rlZU8blvqVrstJcJgAAAGqkZIJ+buZkc5kAAACon5IJ+rmjJo3NbkPMZQIAAKBeSibo5zrnMu2RG81lAgAAoEZKJhgAZk0Zby4TAAAAtVIywQAwa4q5TAAAANRLyQQDgLlMAAAA1E3JBAOAuUwAAADUTckEA4S5TAAAANSpV0umUsorSyn3lVIWllL+bBvvf6yUMr+Uclcp5RellP23eu/sUsqCrr+zezMnDATPzmW6yVwmAAAAatBrJVMppTnJ+UlelWRakrNKKdOec9jtSaZXVXVUksuSfLbr3HFJ/ibJzCTHJ/mbUsoevZUVBoKjJo3NyKHNuf6BFXVHAQAAYBDaoZKplPKHpZQxpdPXSim3lVJOe4HTjk+ysKqqRVVVbUpySZLXb31AVVW/rKpqfdfTG5NM6nr8iiRXVlX1ZFVVTyW5Mskrd/RLwWA0pLkpM6eMz3ULDf8GAACg77Xs4HHvrarq86WUVyTZM8l7kvx7kp9t55x9kize6vmSdN6Z9HzOSfKT7Zy7z3NPKKWcm+TcJGlra8vcuXO3/y36ibVr1w6Y70LfasvmXLViUy77yVVp3W3wjFyzZqB7rBnoHmsGuseage4ZSGtmR0um0vXPVyf596qq7iyllO2dsNU5W6u2eWAp70wyPclLu3NuVVUXJrkwSaZPn17NmTPnBSL1D3Pnzs1A+S70rb2eWJNv33tNOloPypwZ+9Ydp89YM9A91gx0jzUD3WPNQPcMpDWzo7c63FpK+Vk6S6YrSimjk3S8wDlLkmz9/3InJXnsuQeVUk5J8skkp1dVtbE75wK/6+C2UWkdNSzXmcsEAABAH9vRkumcJH+WZEbXDKUh6dwytz03JzmolDK5lDI0yduS/GjrA0opxyb5SjoLpmVbvXVFktNKKXt0Dfw+res1YDtKKTlx6vhct3BFqmqbNw4CAABAr9jRkunFSe6rqmpV19a2v0zy9PZOqKpqS5IPp7McuifJd6uquruU8qlSyuldh52XZFSSS0spd5RSftR17pNJPp3OourmJJ/qeg14AbOntmbF2k25b+mauqMAAAAwiOzoTKYvJTm6lHJ0kj9N8rUkX8//P0Npm6qqujzJ5c957a+3enzKds69KMlFO5gP6DJ7amuSZN6CFTl04pia0wAAADBY7OidTFuqzr03r0/y+aqqPp9kdO/FAnbW3rvvlil7jsx1C81lAgAAoO/saMm0ppTy50neleTHpZTmdM5lAhrQiVNbc9ODT2bTlheazw8AAAA9Y0dLprcm2ZjkvVVVPZFkn3TOUwIa0OyprVm/qT13LF5VdxQAAAAGiR0qmbqKpW8lGVtKeW2SDVVVfb1XkwE7bdaU8WkqyTxb5gAAAOgjO1QylVLekuRXSc5M8pYkN5VS3tybwYCdN3a3ITlq0u7mMgEAANBndvTX5T6ZZEZVVcuSpJSyZ5KfJ7mst4IBu+bEqa350tUPZM2GzRk93Ag1AAAAeteOzmRqerZg6rKyG+cCNZg9tTXtHVVuWvRk3VEAAAAYBHa0KPppKeWKUsq7SynvTvLjJJf3XixgV71o/90zfEiTuUwAAAD0iR3aLldV1SdKKW9KMjtJSXJhVVU/6NVkwC4Z1tKc4yePN5cJAACAPrGjM5lSVdX3knyvF7MAPWz2gePzmZ/cm6WrN6RtzPC64wAAADCAbXe7XCllTSll9Tb+1pRSVvdVSGDnzJ7amiTuZgIAAKDXbbdkqqpqdFVVY7bxN7qqqjF9FRLYOdP2GpM9RgwxlwkAAIBe5xfiYABraio5YWprrlu4IlVV1R0HAACAAUzJBAPciVNbs3T1xjywfG3dUQAAABjAlEwwwJ3YNZdp3gJb5gAAAOg9SiYY4PYdNyL7jRuReQtX1h0FAACAAUzJBIPA7KmtuWnRymxp76g7CgAAAAOUkgkGgROntmbNxi2569Gn644CAADAAKVkgkHgxQeOTynJdeYyAQAA0EuUTDAIjBs5NIfvPSbzFiqZAAAA6B1KJhgkZk9tzW2PPJX1m7bUHQUAAIABSMkEg8SJU1uzub3Krx58su4oAAAADEBKJhgkZhwwLkNbmnKdLXMAAAD0AiUTDBLDhzRn+v57ZN7ClXVHAQAAYABSMsEgMntqa+55fHVWrN1YdxQAAAAGGCUTDCInTm1Nklz/gLuZAAAA6FlKJhhEjthnbMYMb8l1C8xlAgAAoGcpmWAQaW4qOeHA1sxbuCJVVdUdBwAAgAFEyQSDzOyDWvPoqmfy8Mr1dUcBAABgAFEywSDz7FymeQttmQMAAKDnKJlgkDlg/Ijss/tuufr+5XVHAQAAYABRMsEgU0rJyw6dkHkLVmTD5va64wAAADBAKJlgEDp1Wlue2dye62yZAwAAoIcomWAQmjVlfEYPa8mV85fWHQUAAIABQskEg9DQlqa89JA98/N7lqWjo6o7DgAAAAOAkgkGqVOntWXF2o25ffGquqMAAAAwACiZYJCac8iEtDQVW+YAAADoEUomGKTG7jYkM6eMy5Xzn6g7CgAAAAOAkgkGsVMPa8sDy9dl0fK1dUcBAACgn1MywSB2yrS2JLFlDgAAgF2mZIJBbNIeIzJtrzFKJgAAAHaZkgkGuVOnteXWR57KirUb644CAABAP6ZkgkHu1GltqarkqnuW1R0FAACAfkzJBIPc4XuPyT6775Yr77FlDgAAgJ2nZIJBrpSSUw6bkGsXLM8zm9rrjgMAAEA/pWQCcsq0tmzY3JF5C1fUHQUAAIB+SskEZObk8Rk9rCVXzn+i7igAAAD0U0omIENbmjLn0An5xT3L0t5R1R0HAACAfkjJBCTp/JW5les25fZHnqo7CgAAAP2QkglIksw5ZM8MaS65cr5fmQMAAKD7lExAkmTM8CGZNWW8kgkAAICdomQCfuvUaW1ZtGJdFi5bW3cUAAAA+hklE/BbpxzWliTuZgIAAKDblEzAb+29+245Yp8xuXL+E3VHAQAAoJ9RMgG/45TD2nL74lVZvmZj3VEAAADoR5RMwO84dVpbqiq56l5b5gAAANhxSibgd0zba0z22X03c5kAAADoFiUT8DtKKTl1WluuXbAi6zdtqTsOAAAA/YSSCfhfTp3Wlo1bOnLtghV1RwEAAKCfUDIB/8vxk8dlzPAWW+YAAADYYUom4H8Z0tyUkw+dkKvuXZb2jqruOAAAAPQDSiZgm06d1pYn123KrQ8/VXcUAAAA+gElE7BNLz14zwxpLrly/hN1RwEAAKAfUDIB2zR6+JC8+MDWXHH30lSVLXMAAABsn5IJeF6vO2qvPPLkelvmAAAAeEFKJuB5vfrIvTJiaHMuvWVJ3VEAAABocEom4HmNHNaSVx+5V/7nrseyftOWuuMAAADQwJRMwHadedykrNvUnp/82gBwAAAAnp+SCdiu4yePy/7jR+TSWxfXHQUAAIAGpmQCtquUkje/aFJuXPRkHlm5vu44AAAANCglE/CC3nTcpJSSXHabAeAAAABsm5IJeEF7775bTpzamu/duiQdHVXdcQAAAGhASiZgh7z5uEl5dNUzuXHRyrqjAAAA0ICUTMAOecXhEzN6eEsuvdWWOQAAAP43JROwQ4YPac7pR++dn/zm8azesLnuOAAAADQYJROww9583KRs2NyRH9/1eN1RAAAAaDBKJmCHHbPv7pk6YVQuvWVx3VEAAABoMEomYIeVUnLmcZNy2yOrsnDZ2rrjAAAA0ECUTEC3vOFF+6S5qeQyA8ABAADYipIJ6JYJo4dnzsF75ge3L0l7R1V3HAAAABqEkgnotjOnT8rS1RtzzYLldUcBAACgQSiZgG572aFtGTdyaC67xZY5AAAAOimZgG4b2tKU1x+zd66cvzSr1m+qOw4AAAANQMkE7JQzj9s3m9o78sM7Hqs7CgAAAA1AyQTslGl7j8nhe4/JpbcurjsKAAAADUDJBOy0Nx83Kb95dHXueXx13VEAAAComZIJ2GmvP2afDGkuuexWA8ABAAAGOyUTsNPGjRyaUw5ry3/d/mg2t3fUHQcAAIAaKZmAXXLm9ElZuW5Trrp3Wd1RAAAAqJGSCdglJx20ZyaMHpZLb7FlDgAAYDBTMgG7pKW5KW940T755X3LsnT1hrrjAAAAUBMlE7DL3nH8/qmqKl+b92DdUQAAAKiJkgnYZfuNH5HTj94737zx4Ty1blPdcQAAAKiBkgnoER86eWrWb2rPf1z/UN1RAAAAqIGSCegRB7eNzmnT2vIf1z+UtRu31B0HAACAPqZkAnrMH5w8NU8/sznfuvHhuqMAAADQx5RMQI85et/d85KDWvPVax/Mhs3tdccBAACgDymZgB71oTlTs2Ltxlx6y+K6owAAANCHlExAj5o1ZVyO23+PfPnqRdnc3lF3HAAAAPqIkgnoUaWU/MHJB+bRVc/kh3c8VnccAAAA+oiSCehxJx8yIYftNSYXzF2Y9o6q7jgAAAD0ASUT0OOevZtp0fJ1+dndT9QdBwAAgD7QqyVTKeWVpZT7SikLSyl/to33Tyql3FZK2VJKefNz3msvpdzR9fej3swJ9LxXHbFXprSOzBd/uTBV5W4mAACAga7XSqZSSnOS85O8Ksm0JGeVUqY957BHkrw7ycXbuMQzVVUd0/V3em/lBHpHc1PJB+ccmLsfW52r719edxwAAAB6WW/eyXR8koVVVS2qqmpTkkuSvH7rA6qqeqiqqruS+AkqGIDOOGaf7D12eM7/5cK6owAAANDLWnrx2vskWbzV8yVJZnbj/OGllFuSbEnyD1VV/ddzDyilnJvk3CRpa2vL3Llzdz5tA1m7du2A+S7wsr078s17nspXvv+LHDKuuVc+w5qB7rFmoHusGegeawa6ZyCtmd4smco2XuvOYJb9qqp6rJQyJclVpZRfV1X1wO9crKouTHJhkkyfPr2aM2fOTodtJHPnzs1A+S4wa3N7fvqPV+X6VaPzgTce3yufYc1A91gz0D3WDHSPNQPdM5DWTG9ul1uSZN+tnk9K8tiOnlxV1WNd/1yUZG6SY3syHNA3hg9pzjknTsnV9y/Pr5c8XXccAAAAeklvlkw3JzmolDK5lDI0yduS7NCvxJVS9iilDOt63JpkdpL5vZYU6FXvnLVfRg9vyQVzzWYCAAAYqHqtZKqqakuSDye5Isk9Sb5bVdXdpZRPlVJOT5JSyoxSypIkZyb5Sinl7q7TD0tySynlziS/TOdMJiUT9FOjhw/Ju084ID+9+4ksXLam7jgAAPD/tXfn4XFd9f3HP2f2GW2j3ZbkNZbt2E5sJ06cxQ5uNpZCwlIoSyFlLbQUCqT8oL9fy9JSoJQU+IWmQEjZAiWELUBISEicfY9jO17iNbHlTbK1S6PZdPrHvTMaybIjWcuMpPfreea595676Ds8z+VOPj7nXAATYCLnZJK19k5Jdw5p+6ec9afkDKMbet6jks6ZyNoATK53X7pANz+0X/+5ca9ueMuqfJcDAAAAABhnEzlcDgCyKooCevvaufr1c4d1sLU33+UAAAAAAMYZIROASfP+9Qvl8xh94Xc78l0KAAAAAGCcETIBmDSzykL66JWNumvbUd2z/Vi+ywEAAAAAjCNCJgCT6v3rF2pJbYn+6dfPqzueync5AAAAAIBxQsgEYFL5vR796xvP0ZGOPt3wh135LgcAAAAAME4ImQBMuvPnlesda+fqe4/u19amjnyXAwAAAAAYB4RMAPLik69aqsrioD79yy1KpfvzXQ4AAAAAYIwImQDkRVnYr8++brmeP9Sp7z36Yr7LAQAAAACMESETgLx5zTmz9CdLqnXDPbt0qD2W73IAAAAAAGNAyAQgb4wx+vy1K2St9JlfPy9rbb5LAgAAAACcIUImAHk1pyKij13VqHt3NOvubUfzXQ4AAAAA4AwRMgHIu/dcukDLZpfqM3dsU2dfMt/lAAAAAADOACETgLzzeT364hvPUXNXXF+9+4V8lwMAAAAAOAOETAAKwso5UV138Xz94PGXtOlAW77LAQAAAACMEiETgILxiasXq7YkpE//YquS6f58lwMAAAAAGAVCJgAFoyTk12evWa6dR7t0y8P7810OAAAAAGAUCJkAFJRXrZilq5bV6j/u3aWDrb35LgcAAAAAMEKETAAKzueuWS6vMfr4bc8pkWLYHAAAAABMBYRMAApOXTSsL77pXD31Yps+95tt+S4HAAAAADACvnwXAADDuWZlnXYc6dRNG/fq7Nml+ouL5uW7JAAAAADAadCTCUDBuv7qJbp8aY0+e8c2Pb7vRL7LAQAAAACcBiETgILl9Rh97a2rNK8yor++9VkmAgcAAACAAkbIBKCglYb8+s671iiZ7tcHfviMehOpfJcEAAAAABgGIROAgrewulj//22r9cLRTv39z7bIWpvvkgAAAAAAQxAyAZgSNiyp0adevVS/23pEN963J9/lAAAAAACG4O1yAKaM969fqB1HuvTVe3ZpyawSXb18Vr5LAgAAAAC46MkEYMowxuiLbzxHKxvK9LGfPqddx7ryXRIAAAAAwEXIBGBKCfm9+tY71ygS9On9P3ha7b2JfJcEAAAAABAhE4ApaFZZSN965/k60t6nD/94k9L9TAQOAAAAAPlGyARgSjpvbrm+8IYVenjPcf14Z4I3zgEAAABAnhEyAZiy3rxmjt6/foH+eCClf/z18+qnRxMAAAAA5A1vlwMwpf3Da87WoaYm/ejxA+qMpfTVt6yU30t+DgAAAACTjZAJwJRmjNFblgR0zpKz9OW7dqqrL6n/fMf5Cge8+S4NAAAAAGYU/rkfwLTwoQ1n6V/fcI427mrRdbc8qc6+ZL5LAgAAAIAZhZAJwLTx9rVz9Y23rtazB9r0tm8/ruPd8XyXBAAAAAAzBiETgGnldSvr9J3r1mhvS7fe8l+P6VB7LN8lAQAAAMCMQMgEYNr5kyU1+uF716qlO6433/So9rZ057skAAAAAJj2CJkATEsXzK/Q/3zgIsVT/XrLfz2m5w915LskAAAAAJjWCJkATFvL68r0sw9erJDfq7d9+3E9se9EvksCAAAAgGmLkAnAtLawulg/++DFqikN6l23PKmfPnVA1tp8lwUAAAAA0w4hE4Bpry4a1m1/dbHWzC/X//n5Vn3its3qiafyXRYAAAAATCuETABmhMrioH7wnrX62JWL9cvnDumaGx/WC0e78l0WAAAAAEwbhEwAZgyvx+ijVzbq1veuVUcspWu/+bBue/pgvssCAAAAgGmBkAnAjHPJoird+dF1Wj2nXJ+8fYs+cdtm9SYYPgcAAAAAY0HIBGBGqikJ6UfvW6uPXNGoX2xq0rU3PqLdxxg+BwAAAABnipAJwIzl9Rh9/KrF+uF71qqtN6FrbnxEtz/TlO+yAAAAAGBKImQCMOOta6zSnR9Zr5VzynT9zzbr73/G2+cAAAAAYLQImQBAUk1pSD9671p95PJFuv3ZJl3x1Qf0uy1HZK3Nd2kAAAAAMCUQMgGAy+f16ONXL9HtH7xEFUUB/c2Pn9U7v/uk9jR357s0AAAAACh4hEwAMMT588r1m79dp89fu1ybm9r16q8/qC/ftZM30AEAAADAaRAyAcAwvB6jd108X/dfv0HXrqrXTRv36sqvPqDfb2UIHQAAAAAMh5AJAE6jqjiof3/zSt3+wYtVFgnoQ7c+q3fd8qT2tTCEDgAAAAByETIBwAismV+h33z4Un32dcv03IF2vfJrD+ordzOEDgAAAAAyCJkAYIR8Xo/+8tIFuu/6DXrdyjp98/69uuzf7te3HtirnjhhEwAAAICZjZAJAEapuiSoG96ySj//0CU6e3apvvj7nVr35fv0zfv3qKsvme/yAAAAACAvCJkA4AydP69cP3zvWv3iry/RqjlRfeXuF7Tuy/frG3/crY4YYRMAAACAmYWQCQDG6Ly55frvd1+oOz58qS6YX6Eb7tmldV+6Tzf84QW19ybyXR4AAAAATApCJgAYJ+c2RHXzdWv0279dp0sXVekb9+3RpV+6T/92106d6I7nuzwAAAAAmFC+fBcAANPNivoy/dc7z9fOo5268b49uumBvbrlkf1603kNeu+6BVpYXZzvEgEAAABg3BEyAcAEWTqrVDe+/Tz9XXOXvvPgfv3s6Sb9+MkDumJprd6/foEuXFAhY0y+ywQAAACAcUHIBAATbFFNib78Z+fq+lcu0Q8fe1E/fPwl3bvjmM5tKNP71i/Ua1bMks/L6GUAAAAAUxv/VQMAk6S6JKiPX71Ej37qCn3hDSvU3ZfSR36ySa/4ykbd/NA+dfXxRjoAAAAAUxchEwBMsnDAq3esnad7P/4K3fyuNWooD+tffrdDF3/xPv3zb7drT3NXvksEAAAAgFFjuBwA5InHY3TlslpduaxWW5s6dPPD+/T9R1/Udx/er/PmRvXmNXP02nNnqyTkz3epAAAAAPCy6MkEAAXgnIYyff2tq/XYp6/Q/33N2erqS+nTv9iqC75wrz7+0+f02N4T6u+3+S4TAAAAAE6JnkwAUECqS4J6/2UL9b71C7S5qUO3PX1Qv3nusH6x6ZDmVkT0Z+c36E3nN6g+Gs53qQAAAAAwCCETABQgY4xWzYlq1Zyo/vFPl+nubUd129MHdcM9u/Qf9+7SukVVesPqel29fJaKg/xfOQAAAID8479MAKDAhQNevX51vV6/ul4HW3t1+zNNuv2ZJn38ts0K+bfqqmWz9PpVdVrfWK2Aj1HQAAAAAPKDkAkAppA5FRF97KrF+ugVjXrmQJt+temQfrf1iH6z+bDKI3695pzZev3qep0/t1wej8l3uQAAAABmEEImAJiCPB6jC+ZX6IL5FfrM65brod0t+tVzh/XzZ5t06xMHVB8N65pVdXr9qnotmVWS73IBAAAAzACETAAwxQV8Hl1xdq2uOLtW3fGU7tl+VL/adFjffnCfbtq4V4tqinXVslpdeXatVs+J0sMJAAAAwIQgZAKAaaQ46NMbVjfoDasb1NIV151bj+gP24/qO27gVFUc0BVLa3XlslqtW1SlcMCb75IBAAAATBOETAAwTVWXBHXdJfN13SXz1dGb1MZdzbpn+zHdufWIfvr0QYX8Hq1bVK2rltXo8qW1qi4J5rtkAAAAAFMYIRMAzABlEb+uXVWva1fVK5Hq15P7W3XP9qO6d0ez7t1xTMZs1cqGqC5bXK1XLK7SyoaofF7eVAcAAABg5AiZAGCGCfg8WtdYpXWNVfrsNVY7jnTpnu3HdP8Lzbrxvt36xh93qzTk06WLqnTZ4mpdtrha9dFwvssGAAAAUOAImQBgBjPGaFldqZbVleqjVzaqvTehh/cc14O7WvTgruP6/fNHJUlnVRdlA6eLFlQylxMAAACAkxAyAQCyopGAXntunV57bp2stdrT3K0HdrXowd3H9eMnDui/H3lRAa9HFywo1/rGaq1bVKVls0t5Yx0AAAAAQpBTw9sAABx9SURBVCYAwPCMMWqsLVFjbYnet36h+pJpPbm/VQ/uatHDe47rS7/fKUmqLApoXWOV1jdWa31jlWpLQ3muHAAAAEA+EDIBAEYk5Pdmh8xJUnNnnx7afVwP7zmuh3a36NfPHZYkLaktcUOnKl0wv0JFQR41AAAAwEzAL38AwBmpKQ3pTec36E3nN6i/32rn0S49tLtFD+0+rh8+/pK++/B++TxGK+rLtHZBhdYurNCa+RUqDfnzXToAAACACUDIBAAYM49nYALxv3rFWYol0nrqxVY9sf+EntjXqlse2a9vPbhPHiMtqyvVhfMrtXZhhS6cX6HyokC+ywcAAAAwDgiZAADjLhwYPLQulkhr04E2PbHfCZ5ufeIl3fLIfknS0lklWjO/XOfNdT7zKiMyhonEAQAAgKmGkAkAMOHCAa8uWVSlSxZVSZLiqbS2NHXoiX0n9MT+Vv1q02H96PEDkpyJxFfPLdd586I6b265VjZEFQ5481k+AAAAgBEgZAIATLqgz6sL5lfogvkV+rCkdL/V7uYuPfNSm559qV2bDrTp3h3HJEk+j9HZs0t13tyozptXrnMboppPbycAAACg4BAyAQDyzusxWjqrVEtnleoda+dJktp6Etp0sC0bPP3smSZ9/7GXJEllYb/ObSjTyoaozm0o06o5UdWUhvL5FQAAAIAZj5AJAFCQyosCunxprS5fWitJSqX7tbu5W5sPtmtzU4c2H2zXTQ/sVbrfSpJmlYa0ck6Zzm2IamVDVCvqSxWNMKk4AAAAMFkImQAAU4LP69HZs0t19uxSvfVCpy2WSGv7kQ5tPtihzU3t2tLUobu3Hcue01Ae1oq6Mp3TUKbldaVaUV+mquJgnr4BAAAAML0RMgEApqxwwKvz51Xo/HkV2baO3qS2HGrXtsOdev5Qh54/1KG7th3N7p9VGtKK+lItryvTinonfJpdFmKOJwAAAGCMCJkAANNKWcSv9Y3VWt9YnW3r7Etquxs6ZcKn+3Y2yx1pp/KIX8vqSrVsdqmW1TkB1MKqIvm8njx9CwAAAGDqIWQCAEx7pSG/LlpYqYsWVmbbehMp7TjSqe2HO7X9SKe2He7U9x97SYlUvyQp6PNo6awSJ3yqK9PZs0rUWFuisrA/X18DAAAAKGiETACAGSkS8J001C6V7tfelh5tP9KhbYec8OnOrUf1kycPZo+ZXRZSY22JltQWa3FtiZbMKtGimmJFAjxSAQAAMLPxixgAAJfP69GSWU5w9IbVTpu1VofaY9p1rEu7jnVr19EuvXCsS9/fdyLb68kYaW5FRI01JVoyywmfGmtKdFZNkYI+bx6/EQAAADB5CJkAADgNY4wayiNqKI/o8qW12fZ0v9VLJ3qc4OmYEzy9cLRLG19oVsqd7MnrMZpXGdHimhItri3W4lklWlxbovmVRQr4mO8JAAAA0wshEwAAZ8DrMVpYXayF1cV61YpZ2fZEql/7j/do17Eu7XbDp13HuvSH7UezE437PEYLqoq0qKZYi2qKdVa1s1xYXcSwOwAAAExZ/JIFAGAcBXwDQ+5y9SXT2tvSrd1uz6ddx7q182iX7t42ED5JUn00rLNqinVWtRtCVRdrQXWRqouDMsZM8rcBAAAARo6QCQCASRDye7W8rkzL68oGtcdTab10old7mru1t7lbe1q6tbelW0/tb1Usmc4eVxz0aUFVkRZUFWl+VZEW5qzzxjsAAAAUAkImAADyKOjzanGtM1dTrv5+q8MdMe1p7taLx3u0/3iP9p/o1aaDbfrNlsOyOb2fqooDml/pBE7zKiKal1lWRhSNBCb5GwEAAGCmImQCAKAAeTwDE45ryeB9fcm0Drb2OsGT+9l3vEcP7W7R7Z3xQceWhf2aVxnRvMqB4Km1Na2lHX2qKQnK42EIHgAAAMYHIRMAAFNMyO9VY22JGof0fpKkWCKtA629eulEj1460auXWp3l5oPt+t2Ww9n5n7745B8V8Hk0pzysuRURza2IaI67nFsZ0ZzyiIqC/EwAAADAyPHrEQCAaSQc8A478bgkJdP9amqL6bf3P6bonEY1tfbqgPt5+sU2dcVTg46vLAqooSKiOeVhzalwgqc5FU4oVRcNy+/1TNbXAgAAwBRAyAQAwAzh93q0oKpI51T7tOGieYP2WWvVEUvqQGuvDrbG3PCpRwdbY9p6qEN3PX9UqZzX4HmMNLssrIacACq7XhFWTUlIXobiAQAAzCiETAAAQMYYRSMBRSMBndsQPWl/ut/qaGefDrb2DnzaYjrY2quHdrfo2JC5oPxeo/poWA1u76cGN4RqKA+rLkoIBQAAMB0RMgEAgJfl9TihUX00rIsWVp60vy+Z1uH2mA62xdTU5vSGampzgqg/bDumEz2Jk643qzSk2WUh1UXDmh0Nqa7MCaBml4VUHw0rGvHLGIIoAACAqWJCQyZjzKskfV2SV9LN1tovDdl/maSvSTpX0luttbfn7LtO0v9zN//FWvv9iawVAACcuZDfq4XVxVpYXTzs/t5ESk1tMR1qj+lwe0xH2vt0uD2mwx0xPXewXXc936dEun/QOWG/V3VRJ4TKBFB1USeAmu2GUSG/dzK+HgAAAEZgwkImY4xX0jclXSWpSdJTxpg7rLXbcw47IOkvJV0/5NwKSZ+RtEaSlfSMe27bRNULAAAmTiTg0+LaEi0e5o14ktTfb3W8J54Nnw61x3SkIxNE9Wnn0Wa1dMVPOq+yKKDa0pBmlYVUWxpSbWlQs0pDqi0LOcvSkMrpEQUAADApJrIn04WS9lhr90mSMeZ/JF0rKRsyWWtfdPf1Dzn3lZLusda2uvvvkfQqST+ZwHoBAECeeDxGNSUh1ZSEtHLOyXNCSVI8ldaxjvhAb6iOmA6196m5s09HO/u0paldx7sTJ50X8HlUWxpUbYkTOlWXBLOBVE2JuywNqTTkI4wCAAAYg4kMmeolHczZbpK0dgzn1g89yBjzAUkfkKTa2lpt3LjxjAotNN3d3dPmuwCTgXsGGJ3pcM9USqr0SCsqJFVkWv1K9fvUHrdq67PZZVvcqq0voY6uuJ453q72Pqu+9MnX9HukaNA4n5AZWA8aRYOebFvEJ8KoGWY63DPAZOKeAUZnOt0zExkyDffryw7TdsbnWmu/LenbkrRmzRq7YcOGERdXyDZu3Kjp8l2AycA9A4wO94zUE0+puSuuY519au6Kq7mzT8c6+3SsM67mLqdtx9G4uuPJk84N+jyqLQ2ppiSo6synOKia0sy601uqsjggv9eTh2+H8cY9A4wO9wwwOtPpnpnIkKlJ0pyc7QZJh0dx7oYh524cl6oAAMCMVxT0aUHQpwVVRac9brgwKrvdGdfu5m49uveEOmInh1HGSBWRwKAgqnpIMJVZLwszbxQAAJj6JjJkekpSozFmgaRDkt4q6e0jPPduSf9qjCl3t6+W9OnxLxEAAODURhpGxVNpHe9OqLmzTy1dcbV0x51lV1zN7nJfS49auuNKpIZORSn5vUbVxUFVlQRVWRRQZXFQVcVBVRUHVFXs9IrKLCsiAfnoIQUAAArQhIVM1tqUMebDcgIjr6RbrLXbjDGfl/S0tfYOY8wFkn4pqVzS64wxn7PWLrfWthpj/llOUCVJn89MAg4AAFBogj6v6qNh1UfDpz3OWqvOvlQ2gBocRvXpRHdCLd1x7TjSpRM9cSXTJ880YIxUHglkA6jcEMoJqga3B33eifraAAAAg0xkTyZZa++UdOeQtn/KWX9KzlC44c69RdItE1kfAADAZDLGqCzsV1nYr0U1xac91lqrzlhKx3viOt4V14mehI53O+vHexLOsjuuzU3tOt4VV09imNnMJRUHfaooCqi8KKDKooAqcpYVRQGnd1RRUBWRgCqKAyoKeBm6BwAAzsiEhkwAAAA4M8YYlUX8Kov4dVb16QMpSYol0jre7fSOyoRSJ7qdZav7OdrRp+2HO9Xak1AiffKwPUkK+DxO4FR06k95xAmnyiMBlUf8DN8DAACSCJkAAACmhXDAqzkVEc2piLzssdZa9STSau1O6ERPPBtCtfYk1NqbUGt3Qm29CZ3oSaiprVcnehLq6kud8nplYb8bPvmdXlFFfpVHAopGAopG/CqP+FUWDqjcbS8L+xXyM4wPAIDphpAJAABghjHGqDjoU3HQp7mVLx9KSVIi1a/2XjeEcgOptp6EWnuSau2Jq7XXWR5qj2nroXa19SaHneQ8I+z3OuFTJKCKIr+ibq8op3eUE0hF3fWKSEDRIr9Kgj6G8gEAUMAImQAAAPCyAj6PakpDqikNjeh4a636kv1q63V6RXX0JtXWm1R7LKH23qTaehJqjznLtt6EjrR3qq3XabMnz3cuSfJ6jKJhZwhhZqheWdhZRiP+bM+psrBf0XAgO/9VScgnj4dwCgCAiUbIBAAAgHFnjFE44FU4EFbdy7x1L1e636ozlnTDqaTa3aUTSjkBVbsbVh1ud+aYao8l1XuKic+dWqSSoE9lkcHhk7PthlJuYJUNqdxjQ37mmwIAYKQImQAAAFAwvB6jcvdteKMRT6WzvaU6YgOf9t6EOmOD2zpiSR3uiKkz5gRWqf5TdJ2S04Mr7LWqemajysJ+lYb9Kg353XWfsww57QPrPpWGnB5UTIoOAJhJCJkAAAAw5QV9XtWUekc8nC/DWqveRFrtbiDV4YZU7bGBHlM79x5QcXmpOmJJtfYk9OLxHnXEkursSyl9moBKkoqDPpWGfNlwqjQ8EEIVB30qCflU4gZSmfXSnLZIwMs8VACAKYOQCQAAADOWMUZFQZ+Kgj7Vn2JY38aNx7Rhw3kntWfe0tcZS6qzL6mOXid4ymx3xlJuGJXMth1uj2nHkaS6+pLqjqf0MhmVvB6jktBAz6jsMuw/bXtucBX08SY/AMDkIGQCAAAAzkDuW/rqNPJ5pzIyIVVXX1JdfSn3c/J6Z2YZc5YHWnsHtuOpl/07AZ9nUO+oYjdUK3GXxW5bpj2znulxlQmu/Az9AwC8DEImAAAAIA9yQ6rZZWd2jXS/VXd8IIDKhlRxpyfVQFDlrHf2pdQTT6m1xwmqehIpdfelTjsvVUbY7z0peCoN+U8KqTLhVVHQq5LQ4OAqEvAp4COsAoDpipAJAAAAmKK8HpN9W96ZstYqnupXTzyl7szH7U01MNRvIMjq7HOG/p3oTmj/8R519znnxFP9I/p7Aa9HkaBXRQEniCoK+gbWAz5nX9Cn4oBPkaBPxUGvIoGBECsS8DqBVdCrkqBfIb+HeasAoEAQMgEAAAAzmDFGIb9XIb9XlcXBM75OMj04qHLW0+ruS2XbexNOm7NMqTeeVk/C2d/SFc+u98TTSqRHFlp5PQM9woqHDP/L3R7UqyqUM1wwZx9DAgFgbAiZAAAAAIyZ3+tRNBJQNBIYl+slUv3qTaTUk0i7wZMTPmXCqmyIFU+6vanc9XhK7bGkmtp6s72yehLpEf3NoM+THern9K7KBFG5vamc9aKAs4wEvYoEvAr7M/vcdnfJ8EAAMwkhEwAAAICCE/B5FPAFFI2M/Vr9/daZfyozFDDT08pdzwwPzPSw6okPhFsdvQkdbk9ne2P1jOCtgLl8HqNwwAmfigK+7HomiAoHcoYJ5oRTg8Ks4MAy4vcqEvQq4GWYIIDCQ8gEAAAAYFrzeIz7dj2/dIaTrGdk5rDqdUOoWDKt3kRavfGU05ZIKZZw2xIpdzmwntnX7oZXuftGOq+V5AwTjASG9pwaHF45PaycTyhnPRw4eZkJtDLrXg8BFoDRI2QCAAAAgBHKncOqomh8hgZmpNL96k2ms3NVZZcJZ6hgjxtkOcGW0xbLCbZ6EqlB4VWfG4DFkiMbLpgr6PNkQyunt9XgUCrkHxJa5YRYLx5OKbX9mHN+cEhvLIYQAtMaIRMAAAAAFACf16NSr0eloTN/W+BwMr2vYm7gFEums+sDvasGelrl9sbKXY8l0zrencie35ccuJ4dOoRwy9On/p7ZXlg+hfwehfxeBf1ehXweN8DzZEMsZ59HYf9Az6zQKXpj5S5Dfi8TuQN5QMgEAAAAANNYbu+r8gm4fm6I1ZtM64GHH9OKVedlhwL2xHN6XiUHemT1JlLqS/YrlnQCq3iyX229CfUl0+pL9rtLZ32kbxvM5fOYk4YKOuuDQ6xMqBXyexXyOdvhgLMeHLRvYD3snhd0l8yRBTgImQAAAAAAZ2xoiFVX7NG5DdFx/RvpfjvQcyoxZJlMq8/tbdWXGtLLKjEQYuWe19ozEGbFsmFWWsn0KGZ1H/S/gRTyuUMJfR6F3JDKGVro9MQK5oRTA/u8CvoGQq3M8U7ANRCABXMCrqDPQy8tFCxCJgAAAABAQfN6jIqCPhUFJ/Y/YXPDrNyeVIOWqcE9reKpgfVYTnAVz1lv700Oukbm+qN5U2Eur8co5PMMDDMMnNwLa1BbTq+tYKaHlrsMZpeDAy2CLZwJQiYAAAAAADR5YZbkDDNMpPvVl+xXfEhAFUukFXfDLGeZG2b1Z/dlg6tUetA12nuTbtA1PqGWNEyw5fcq4PM4H68TQuVuZ9t9RkHf4B5cub26BgKwTAjmBF+DruPzyOcxDEmcAgiZAAAAAACYZMY44UvQ55XC4zvZ+3CstUq5PbUygVU81e8EUal0znJwe2a+rL7UyQFXIuXMl5VI9SuZ7ldvb0pxdz2R7lcy5QRp8WRafal+pceQcnmMcoInp3dVtieWG0RlAqpgNqwa2B90A7LgsMcNXGNoWDa0nbDr9AiZAAAAAACY5owx8nuN/F6PSvJUQzKdMwdWov+kObQyk7wnUk6YlUj1D3yy7c4nc8zAdlrd8ZROdCey7X1Jpz1zzHjwGJ0UUIVywq7M8MKg36NrV9XrlctnjcvfnSoImQAAAAAAwITzu8PqSkMT33NrqMzwxEwvrWxAlbOeCbQyPbHiQ0KuZCbQyvTOSg4OujJDG9tjCcWT/WrtSUz698w3QiYAAAAAADCtDRqeGMp3NdMX08MDAAAAAABgzAiZAAAAAAAAMGaETAAAAAAAABgzQiYAAAAAAACMGSETAAAAAAAAxoyQCQAAAAAAAGNGyAQAAAAAAIAxI2QCAAAAAADAmBEyAQAAAAAAYMwImQAAAAAAADBmhEwAAAAAAAAYM0ImAAAAAAAAjBkhEwAAAAAAAMaMkAkAAAAAAABjRsgEAAAAAACAMSNkAgAAAAAAwJgRMgEAAAAAAGDMCJkAAAAAAAAwZoRMAAAAAAAAGDNCJgAAAAAAAIwZIRMAAAAAAADGjJAJAAAAAAAAY0bIBAAAAAAAgDEz1tp81zAujDEtkl7Kdx3jpErS8XwXAUwh3DPA6HDPAKPDPQOMDvcMMDqFfs/Ms9ZWj+TAaRMyTSfGmKettWvyXQcwVXDPAKPDPQOMDvcMMDrcM8DoTKd7huFyAAAAAAAAGDNCJgAAAAAAAIwZIVNh+na+CwCmGO4ZYHS4Z4DR4Z4BRod7BhidaXPPMCcTAAAAAAAAxoyeTAAAAAAAABgzQiYAAAAAAACMGSFTgTHGvMoY84IxZo8x5lP5rgcoNMaYOcaY+40xO4wx24wxH3XbK4wx9xhjdrvL8nzXChQKY4zXGLPJGPNbd3uBMeYJ9375qTEmkO8agUJhjIkaY243xux0nzUX84wBTs0Y8zH3N9nzxpifGGNCPGeAwYwxtxhjmo0xz+e0DftsMY5vuJnAFmPMefmrfPQImQqIMcYr6ZuSXi1pmaS3GWOW5bcqoOCkJH3CWnu2pIsk/Y17n3xK0h+ttY2S/uhuA3B8VNKOnO0vS/oP935pk/TevFQFFKavS7rLWrtU0ko59w7PGGAYxph6SR+RtMZau0KSV9JbxXMGGOp7kl41pO1Uz5ZXS2p0Px+QdNMk1TguCJkKy4WS9lhr91lrE5L+R9K1ea4JKCjW2iPW2mfd9S45P/7r5dwr33cP+76k1+enQqCwGGMaJP2ppJvdbSPpckm3u4dwvwAuY0yppMskfVeSrLUJa227eMYAp+OTFDbG+CRFJB0RzxlgEGvtg5JahzSf6tlyraQfWMfjkqLGmNmTU+nYETIVlnpJB3O2m9w2AMMwxsyXtFrSE5JqrbVHJCeIklSTv8qAgvI1SZ+U1O9uV0pqt9am3G2eNcCAhZJaJP23O8T0ZmNMkXjGAMOy1h6S9O+SDsgJlzokPSOeM8BInOrZMqVzAUKmwmKGabOTXgUwBRhjiiX9XNLfWWs7810PUIiMMa+V1GytfSa3eZhDedYADp+k8yTdZK1dLalHDI0DTsmdQ+ZaSQsk1UkqkjPUZyieM8DITenfaoRMhaVJ0pyc7QZJh/NUC1CwjDF+OQHTrdbaX7jNxzLdSN1lc77qAwrIpZKuMca8KGcI9uVyejZF3WENEs8aIFeTpCZr7RPu9u1yQieeMcDwrpS031rbYq1NSvqFpEvEcwYYiVM9W6Z0LkDIVFiektTovo0hIGfSvDvyXBNQUNz5ZL4raYe19oacXXdIus5dv07Srye7NqDQWGs/ba1tsNbOl/NMuc9a+w5J90v6M/cw7hfAZa09KumgMWaJ23SFpO3iGQOcygFJFxljIu5vtMw9w3MGeHmnerbcIeld7lvmLpLUkRlWNxUYa6dMr6sZwRjzGjn/yuyVdIu19gt5LgkoKMaYdZIekrRVA3PM/IOceZlukzRXzg+eN1trh06uB8xYxpgNkq631r7WGLNQTs+mCkmbJP2FtTaez/qAQmGMWSVnovyApH2S3i3nH2Z5xgDDMMZ8TtKfy3kD8CZJ75MzfwzPGcBljPmJpA2SqiQdk/QZSb/SMM8WN7C9Uc7b6Holvdta+3Q+6j4ThEwAAAAAAAAYM4bLAQAAAAAAYMwImQAAAAAAADBmhEwAAAAAAAAYM0ImAAAAAAAAjBkhEwAAAAAAAMaMkAkAAOBlGGMedZfzjTFvH+dr/8NwfwsAAGCqMdbafNcAAAAwJRhjNki63lr72lGc47XWpk+zv9taWzwe9QEAAOQTPZkAAABehjGm2139kqT1xpjnjDEfM8Z4jTFfMcY8ZYzZYoz5K/f4DcaY+40xP5a01W37lTHmGWPMNmPMB9y2L0kKu9e7NfdvGcdXjDHPG2O2GmP+POfaG40xtxtjdhpjbjXGmMn9XwQAAOBkvnwXAAAAMIV8Sjk9mdywqMNae4ExJijpEWPMH9xjL5S0wlq7391+j7W21RgTlvSUMebn1tpPGWM+bK1dNczfeqOkVZJWSqpyz3nQ3bda0nJJhyU9IulSSQ+P/9cFAAAYOXoyAQAAnLmrJb3LGPOcpCckVUpqdPc9mRMwSdJHjDGbJT0uaU7OcaeyTtJPrLVpa+0xSQ9IuiDn2k3W2n5Jz0maPy7fBgAAYAzoyQQAAHDmjKS/tdbePajRmbupZ8j2lZIuttb2GmM2SgqN4NqnEs9ZT4vfdAAAoADQkwkAAGDkuiSV5GzfLelDxhi/JBljFhtjioY5r0xSmxswLZV0Uc6+ZOb8IR6U9OfuvE/Vki6T9OS4fAsAAIAJwL96AQAAjNwWSSl32Nv3JH1dzlC1Z93Jt1skvX6Y8+6S9EFjzBZJL8gZMpfxbUlbjDHPWmvfkdP+S0kXS9osyUr6pLX2qBtSAQAAFBxjrc13DQAAAAAAAJjiGC4HAAAAAACAMSNkAgAAAAAAwJgRMgEAAAAAAGDMCJkAAAAAAAAwZoRMAAAAAAAAGDNCJgAAAAAAAIwZIRMAAAAAAADG7H8BtNvrl40owJsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 10))\n",
    "\n",
    "#for phase in ['train', 'val']:\n",
    "for phase in ['all']:\n",
    "    plt.plot(losses[phase], label='{} loss'.format(phase))\n",
    " \n",
    "plt.legend()\n",
    "\n",
    "plt.title('train/val losses')\n",
    "\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('loss')\n",
    "\n",
    "plt.grid(True)"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}