proj4_GAN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import csv\n",
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "import pandas as pd\n",
    "from skimage.transform import resize\n",
    "from PIL import Image\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from skimage import io, transform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Load data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_dir='C:\\\\Users\\\\user\\\\Documents\\\\Documents\\\\McGill Undergrad\\\\Year 3\\\\semester 2\\\\Comp 551\\\\proj4\\\\data\\\\data\\\\allendata'\n",
    "dir_list=os.listdir(image_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='C:\\\\Users\\\\user\\\\Documents\\\\Documents\\\\McGill Undergrad\\\\Year 3\\\\semester 2\\\\Comp 551\\\\proj4\\\\data\\\\data\\\\GO_terms.pkl'\n",
    "with open(filename, 'rb') as handle:\n",
    "    GO_data=pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('GO_terms_per_gene.csv', 'w') as f:\n",
    "    for key in GO_data.keys():\n",
    "        f.write(\"%s,%s\\n\"%(key,GO_data[key]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x256 at 0x267E10566D8>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#check how the process looks for one image\n",
    "gene_id = dir_list[1]\n",
    "GO_terms=GO_data[str(gene_id)]\n",
    "gene_dir=image_dir+'\\\\'+gene_id+'\\\\'\n",
    "jpg_file = os.listdir(gene_dir)[0]\n",
    "jpg_array=np.asarray(Image.open(gene_dir+jpg_file).convert('L')) #keep all colours\n",
    "img=resize(jpg_array, (256,256), anti_aliasing=True, mode='constant') #resize all images to 140x300\n",
    "img=img*255 #multiply by 255 to scale images back to the same integer value distribution\n",
    "img=np.asarray(img, dtype='uint8')\n",
    "img = Image.fromarray(img)\n",
    "img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAEaCAIAAAC3tEgwAABbIElEQVR4nO29S5Msy5bf9V/uHhGZWY+9zzn7PO859/Zt6XZLIHWLy0sIQUvWAxjBWGYw1BwzPg9DZgwwA5MQhkkGGGgAoiWM1pW4orvv6/R5n713VWVmRLj7YrDCPT0j31mZWVlV/rOyvbOiIiM8IjyWL18vBzKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMpn9oYduQCZzCoiWd3Vm3vs4u343kzkq5qEbkMmcC1lSZx41WTfPPAtW6ear2EaaZ+mfOSuybp551qyXwlleZx4R6qEbkMk8JES0q9qeyZwnWTfPPGuUUswsAj1q36ka3vtTJnO2ZGmeee4Q0VJhnartUaZn20vmbMnSPPOsEYmc/tsj6+aZx0K2GGYeJSuN3aQXJS8RsfekFAD2XjZBdtMKsgWA1gDgPZjJGIgQl93iMb3bqT0sm9MmyZ7MyANE5qBk3Txz7vS0YzGArFKWOYrmdCMzgtmEiRDM5ez9TM6KfJdfleJ0e/iXiHiFNF/JYjuzmp85DlmaZx4BqeZLREop59ZK1Si7E+Xai6DvGVXSD/GzUpiX5hTwOQAmc65kaZ55BCwGmayEZsgXheUaMVFnaZm3hMzp/sxYPRXIZM6HLM0zZ8GaOioSSbI0fHCH4ysl1hXvvWj3ckxVmLZt4RyUEsN6bNDMYi7qPBHv52gK2v2s8XlsyByBLM0zj4BUgm+Q5lH89ywtcTxg5iSIhZk7L6j3iG5SZtJa9kDv311JDDWz9sehIpM5HFmaZx4BO+vmIqbnNyD6SJm9czOR6sORrYtCVikAxID8xO2rIlFW2n9EdveanUV55ghkaZ45a9L8na0qYaXhKPMHISJeUIqZmZSKcTLeOTlI7+vJ1GD3a2Dm1NKSRXnmOGQHfeboLNVbe45KFaTwmkSe7ejM33Nyc7XjdNEgszh+zIvgJRGQixlGM7sKWBvjnBsMBk3TjEajyWTirJW/rTrUHux6x7TWHON8DsGqm7B9XbMU+dZi5u2h6tQ/SbJunjk1UUSmpuS9V41YKLHSz7/fqj1JBAvPH3NvMcEhO0lk92AwMMY455y1x7Cb9y55VbOVUiLBY4jnVhGfuzQjC9aHIkvzzEkRaXJvBfxgLDF9BIHejz8Ra8yq7KRVW4KQtdbGQeuAIm/X4/QChGQMOJQoR0jLkgEjeKOzfD8RWZpnTorWmoicc72J8w5RK/P7LOx8mLIqi6GEnWkoUdu3si14L5r47c0NKTUYDMqqaprmns1bSnQPAFhlQundGSI6oLEFie7fO0sW6CcgS/PMw9OzutzrWKkRIxofQmDJyq+saNayfXcUTEl7mLltWzqomUUFh20qytfL6K6qQWLvOkNRu8YVkVlFluaZk+K9j5YWrFOxN7DSbr6w2wYv3IrtS761YCRZX0Cmy1EqjK1rEGmty7KcjMdbXNwOiNSO590o8nq6s3xrqUK9d3vW2Z0yxySvPZQ5Kbxou3hQlgqaVRslj3R9m+N3lVLGmJ607Tj0VXPAB9Y3j4jKsuzp9QchPfs2MS2ZA5J188wDIHJkLgRwR1Yq9QtyaaN6vtPZe4JvjRwU3dxPawBKKWetKOZFWYpHdPuTbtme7f0Nw+FwNBq1bfvmzRscVJpn2f2AZFNU5l6sEgRR7+tFkffCzA9+3lXH3FVgHVsq9eLrN7Lyemlm3yeltJRoB6yEtMfBjHlNTI7st3y778+lUsW/t0Wq30iETPoniW1fvNI1A+2uz3HRu/sMx5Wsm2eORU99PuzbdbJ39UjmgsV7cpATzb6eOhJCfI4YWQ5z/PBrz7KktW6axjnXmzT0OsOxjTDPUJQjS/PMkeip5A/dnH1I5dExpM8xRoiZ4pxK7cTWv99JY8nJNV8XZVwpJblIvYGqZ8rveZIzByFL88xRWCXHl4ZenOG8eGnMzAHbuShe9zxy+q1V0vbeolwMOBKv0mt5jHcUA4v3vm3bvc91HxZv6Rn2q6OSpXlmK87N7rymPUvts0dtzB7EcMbD3Kj1MewcFtxYs88WgTqxtT0pGQsDOOfStNI4EB42QWkNz01898jSPPMAnP8rF5XQtKkHt7QcTJRjiUDvykkyg8gYw8y2bfc4vKjkq+4Dr0jfTzcutasc9mZS4OBHfkTkePPMqVn62j9UY9bQ890dVkYszbLZ+z4s3sPOgK0UgqlEa92r9LsN0WK+uF0+pKp3T6QuvWPHe9zp2eOWY5zobMm6eeboHEMjO1Qk4t4nOuxh76lXLgpc9t4F00rMv2UpGrMLWmvvfVpwURpZVZXEriy2OR0CxS8qkn1R2j5bJfpIPK+xK9NDhVLgG71866VkzwS85XHu8zIfSmrv3YYomxa17G3atut9jndY5CNi4UO1+lxpVImEmliLeZHaPTVeWccmWadjq6opvX3iufYu07hxkNtmFFycMWzT/kdH1s2fNWvsodsfYfG7j/qV2Mh6S8KR6DkSiUi05lUt6AZUkVnMYmxxziGMCWla/wEvIx3I4/BznwMe5CanA6FI9phd9ZTI0vyZkhbSuw/ybohoWFpO64mx1CRy4lCKuTnQ6nVKeWGLUkqWyuvFMh62/b2j7W07wrLZwK5HS/u53AFJccrSPPN0kHVwYgQx3SNaLgq4dCWKJ0wspIUjxKGvItrEkEwLmHmVpYVD/qf8KsmZp5k/Hck1sp+an/ZqDlXJDtK8MyRL88y9YGYZFe4zHjwi0kXX4uh1+njq2Ri8Zs/wCcxgds7x0kxReWRH8ENQKLZOoXjLfsdZv3H740hfjWVkdj3U+ZOl+TMlXdjsIFL4OYjyHqeciPQmBNEEbP1yKdlJ0uj8FLkWJmGz/Y6f5HVPuXmfUB/MS+0n3z+zNH+mLK+7vRe0ICNObEc+JUuNFcPhcDKZnL4xawRlail2RAhrDPWfy/0iI9eTTiP2+HoaEsOBXQ+i5kPsTzmROj1Zmj9rehbz/aTw4mv2VEU5klEw3quqqq6uro4tzWNF+LiA8nqp5BciwXlh0bj7WEJW0RsbZvb9fY+26GDfiQMuYH3+PEHj0dNmMXL2nsfB/Cu3Pg53cd66q9rVi2Dr/TWNQJD0xVULIq+KeejVDT/8uCJZ9AocTdBKFUXR1PXy/bc+fxRby0+7KsZj4wniwDNvH+8fMMbJKEVEMhgorb19RtIQu9edPyuybv7I6IlCyd7WWterpMnq4zxIf+2tdZC2p/dXDmX5duI0F9U7yf0n76mavPRPi6fornQhpmUmpkNYC0en6JqbM1/mhYJQ25vehTxG4fjoyNL88dF7MWI5jkdKb4oQN561fTO2dIWo3Ug6R7m/q3CRbuHm5JZu1P177bmnjzeL79OTpfnjxntvrd1b8C3KkdO/hKkQWWOE2fVo9znIOlIdNty9Pe5/etVIjNqLbd5wFav233eATxu23yiFLMofiCzNHyXpO7NfQkSc2mOZxeN4rDmXmIx6i74fRKwfiajD3ifOb9cBbEtxObO0bFeKIDWgS/bAPa9r1wZn7k+W5o+Ve74kR9dhV7C+2RLDcB9pfvRrSRTzYxx+vd180Xe92IzZHZZpRLo/r6yuBWapl8ves/e8fvmL1fTMNWIGJKJd/TqZPcjS/LFykPjuxW8d3IC78Yzpn2Ke3vnGFXAsVqUg6q8n7Fu3aqdZURp/vfErWusuinG+o6w5vohdB/AhtPL4BM/xIT5RsjR/ZPRq2Ar3iee9z9f3YDHGDsFEm4a9rzIinws9BZkVaDdjV8/GNbO3LEQcBh0cTAB1IZIcHbEr7OamLKXiQrdPGAnWGOVEj15Tl3Eb0hhTDpn0x1YRMkK+y0+K7ePB10jVpcfp7Rz/jcksvR3W2FJ2uaAzVM+N0lopZa0FzwdQLhXonTlk3XOZu8auYutsMNPhdNFUQvPGk3TFOFmOWSrfLm9+MKF0ceUxJXiVlN/u9vf6w/HYpj8/W7Ju/kxZDGoU8bHKbrv0bXmer1Dnp2UGlNIhmO9QUmxhSuKs9VFehx1634ifXCh42z/smkF0jTE986jI0vyZksroxbCKU0a5nCc9G8jsVygwR5VbKQMEOb67vWXpicPR5ixpvTrdSKJWOhPKdnK8HwZ6tv6JzO5kaf5EWNSg19s0Fi0kKet9lfcJHHws9Az3PFvWUrJyut2Cnn4E80JYNghJxYK+Vg6AOaaPiUBPTSi9K1p5rqf+NJ8JWZo/U7aJoFi121KDzBNjiegUNVYq0Ma8oa72gJpp6FsfP35eORMiipp16iWOu/YPGoICT2C/zpwhWZo/EZbqy1sq0aljsyepVyWeLLXJPCV6F5iYpMTfMD9BIdq+uta2BLm8NLaHkrorsxUzmBH3X4iLXzzIk59gPTeyNM909KznOYUPIQQbAIcKtGVZtW3LbCVhUqopEtGh7pPSOt7/6KnuKfKJET+MtIkFfE6UI6jwC+b4/iTgeT/op0GW5pkcr7KcXraOqMnD4ZCZ29aDfSg2i4MFtCTimBMbS/owoic0immaL5i1/ME9+6f5HMjS/ImwNLp86SR9PTGxXmtdFAURWWvbtl1vUbm/veVQg4fuLCHw8IjR0rF10fzQ37C8STE3NWrKzBNgCrQAwBRve9f+xcN1yT48tyWRxXPpYMzwDCKlNYIcl92kgk03bKRGGOcJUKRYjuG8lEjevCb9ehP8JpYOG3s8xMUeu35/ZjbGxKsrimJj5+ydpR+kND/vWdWARxHnnqV5Zo7oPZMUPjrcqjSHZZWfIIjNFcoybZsOs4h4FOq6jjeEDlGBYHaE+ZDEuS3MXVCN1nG6EL8Y5xBx8D6NC1TOuFQsbs+u35I1THpjVVmW+9WBWeWLfqQ8+gvICMfQHVKpsWtfP7aOsyoeXIk4kz91u/bONLdtm7OmXuIoKNeXC0++vORw0u5VJ5v7UxKnKDUmRYZKZCQzw89WfBZpfuJolji6nOy8cRThrYNlN+ZPxEe8fu2nRbJunjlrFuNYzlBtia9xPwKHt4r9piBlN6/EloTYpzZ07Pom97J40vTO1V+JjlDvXPB3cpKM2jVPXLJ7GNbuz2aT/e6sP5QYA2MgZs/2cp+T3vMID84jXrMmcwwoId34gE3aiSjKlyvm0Six6YKW2nPTaJPdRrveDsE8MredqBPf82NGenbvvXPOJ2VYpIqL/Ck27wTPS2YJafNwkn5ijJE775yL67QYk7VSIEvzTA9OiBvPMBWFE800/Qwk9QVT2RKkZJTjDN5GMe+dMXGH7mwaWidnw0xfa22MUVpTsOR459jH+JnkuRCRUiLN00nDaaR5WZZFUSyNodyJWAB9y/3TlbaGw6F8mE6n+5095axsJvuRx7RMn8fSrdN2zmJL4qYFrTxm68v+ewi83rARDryPhWHpyj7R6j2zRPfsGElUIhaG3kUT2fFYXDV0v5OqsJz0ll+X+zAYDLTW19fXAOq6vv+Kd9ub4M+ZLM0zK1laS/1MWNokZl7l158zfHMa2rKzIEhlh9plbfs5edH7Fnf1WJy1qbk8fjMNaRftW2R9Vym3O8bpHlMaQ3KfsJYYEbulMDXGtG0ryjgRTSaTXc+Ykp6UH3+9isfd+sz5QEmFkHTZs3Qw2FUR26sdAKBK7dsujrAcjZrJRBWFb1owg7s1GaTr8+7SfPlpV8U8gKMVJd3Np3GfuwqRuVDx3b56KHTIWe090F1jPzZGm2S2J9vNM8vZw/y6aHBPfy2KoizLQzZxKYRyVPnWXb3zAsDw6qKZTl99+GHwHCpK1F6t9NHbE4hS7zznOrsSq4Dd83IOcpCMkKV5pk8qx7eX6fJCLppT0+MsLpFxDJqmNoPyhz/8IRW6ti3Y13UN5yQJM9qmGerE/f+UkmtpbNIBWXohBzzXsdufyTx94isUgw32e6MWv0hExphjv580IGigBDT++t/+m6P3rqEBDShAaygNkl8MYBSKg513Bd1Knut/FO32k353bXsOdXXbs/I+7HWcY7Rw43lPf9JD8YibnjkGqVaOFVEcOx1qqfp2f+V0pX22ZDDg8clvffrN19998MEHX3zxhbUe1oIVZAVjVgoEgADHzT1bsqE9qwzb6f6LyZ9LDrRin3utybw/vdjEve3m58ah+ueDkC0tmTlS8b29KO+9w2lE9qmVLK2qiyGAzz///L333oMi5xzaFt5DAv54tgDbI31p9+OwDyIe7Z7H3F5/P01Hyrp55gmyvZISXwDZWewzaa2uxTfkiLq5ZihUF8PLy8tvv/gaZQFrYRkAdAkArQUrdMn9zLhvRviG9vR086W7HVM374ndQ9VQS683fZq76uZaa2DORbx4omO0fxXblt85S3K8eWY59xG4MfF9MR7x6LoPAR71zaSeTsFA3Xabq2pQDIiombZ22sVKK1LulNp5IpVOMy3oab50uIqYh2p/TxVY/OuR2r+mPY93xpZ1841sNEY9ymH8PFDhX1KkfKiXRV35LMm8X6k7E5HktQPw3nd1l9TyLi3iIA2q6SJb3JHjzVeMZOtFRpRf5xC6J7UbpURM3HJY7XX9nZG7cfRMhcdP1s3vz84r/GYWSGWWvLRgbNDCmNk51wnlTS+55FK6kO/HG+sXPhCLuuo5+OVk4JwFdz5EYx611nwasjTPnAmzYlkMR0RYW9qWQpbpbm/4vVXdY1uKaKGwbaqZPhTSBhHoJ4uXT8cz2qWa+bMlS/PMg+MB1cUVdr9u1pt7pnnE6iUbU93XLxbx0CxaMM7B2HImDXjwZpw52W6+kW2COLOlZT969za5jbFjrnh/Uwt4+pKvLI0Yylr1N+4oH+6jm28vjM7Kbk7LKvAc1gu66F1Y6m948Ftx5mTdfCMbJXUvQTxL9i3pi/LunU1WUuutqja3d1I5Ful7vkbaPhJZEKUnQo3cB5dipzeX00J1wwe/CedPluaZB2HJ+EcEUp3IZfl1g/H8AZS1VWc8rD39HFTyyIO35FFn9JySLM0zJ2a55YpC1REiCWpBb521hf13jPRYNJefqwH9rES50IsgPI0XFEnN8XMI7Dl/cmb/BoxRALRekrn+JKEVHPu8YtZ2DkqBGe+9N/iDP/i3N8Y0L29nkr4/O/piSCIzmOOjTK9REhQPzn1u6Zrnkq7EprVe0/hVB9nYGE7Ypp3rtyweeXFLtC/1fn0o1ty6Pe7nkXiyUulQWOdBs2VkB4NSa3qkib/nzGg0cA4XF6W1+NGPPjDGVFVVluiVctz4tpCo9LJuXNx59U9crZiTpWdO/3zv8/6nki4G4C+9UVm3fdpkg9QGBkMznXbpiARoraz189651YEZj5BVYuVwgmBRgQh3jADgww9ffvf9648/fm8ymXz99VhhtyWVSc+WdovXMhf0Ej8zA6jKqmkaDhVmsK8o31Uc7xqzsea5xNEo7snzi6ItPdea9tyHXmOWbnmM3Of5noxsN9+AvNsyefUe1noASpE7aYGPp4TIyiWTQgKGo7JprCJ89dW3sg77Ktm6/u1KxVk/VHn+NfPeU5I1/lBz5G0E+qovLhWgveM81HVlTkm2tGygafxwaD766ENjNDOUFvNuFuX3JJXRsVI23n///e+/v726ejGdYDjEHgvPdXZY7rNqf6nuEgXig9hY7mNplTanzV56sVtave+PnCW1iZ2hU/epkkfsDbx85wIAEb1+fcuMoqC26XXNbGnZj/59M8aUpRlPpkqBCN5DKbDfzdLClGjfSdQKza+uELeDQxLp/eT43jNxCgvsrXf0rX8uPfXcGJN6Ebc/zqFYZed5vDwKS0vWzTfwgx/8oGma77+/ZYbWsJZBeLohLQ9GWQ6IyFoPRlFo52AMDqgoL1FOkxDIuF2crgc76ybuH/8QVeBYTlJrbYxJR4sHj7XInIZsN9/Ar371q+m0jUFf8o5orb0/bp3lZ4BPlYmmaWRSboyy1gFwDlrDtvvYzXu7LglPnCd6QUWrPYG9ZTHaZD9tLn4rHqE3bklEUIwLaprDrJyXOUPyWL0Z0gDAHiBA6W5Bski3kA0AKMA9EkvLuc2FV2nE6wXr8a7iUEfe1bKhQLORZ/GrRGAmkFIKnj3PrTwU7dRrjk+ke3/d6E+e3zB7HEVROOeYveyypgxD5jRk3XwzLFo4AQx4n7vtMTiHESVllbw7djuXlwEL+ZBRUnvv6aFvWNu28fOu78TeMTyZNWRpvgEKueZxRgus7LxnqJavkkQPJa0yO0NdxYPU1dmLLu994wQPUTJOxdeqFKT0uXN+1ZnTPpb725HI0nwDWpRyRV6mtVJD5LFx/u/MiVu4h254siyYXgxKjMzxRFopx4xQU5DmKwAzgcHrradpDMyqLdsgq8pprZ1z3kPcSNnJ+rDk4IzNMIMca0ARCOgWyZF3Lka7PVjrNpCjfRd5fKEdwZEbY1fO5BKUUkQwRo1GA6ytYJb6ZrfJA8jsQZbmG9CyCDHADA3oVP/oFXE6ddP25JlHqlGwQe96H06UfRM/UaLrhvOKKY+D6YVjXZr5hsqfl//Ew9+vGxRFIQepqvLly5evXr0aDLbK9cpy/HhkS8sGSm0aZyHjXnBRKSxfseyce2h8e+XfjdmDmQdhZgKarb7UrZpEShERe8/eMz/wqCyWlrZtmVmpsVJqOs2xjw9MluYbuBiOaDyuvY1bFLB58ckzo5c/cv/Ux6fBGml4KE/dypXt1p63f0ZmMkY8jfHBMbNSalXLVkZGJv8u/bAlxpimacqyrOt6PJ5Kq4pCt+3mPIznPDU8KtnSsoFXr1413gIolAbAYKONokd230QKOOestdZaUamewJx38SpoBelX4hel5NZSFo+5dxOX/iidGO2ISKoZAJBAEZGuMenJaCk945zrvquCCu/9YDCQgxRFMQu98p6911qzlBWTpeCkWK5SUgeYvQczKaXNzlqdZCHVdQ2ACE3TSKXoVfdz6bN4QI7dtjKpMRQPfuw040cmlU5PUZWDspLPohRZ7/369c0ymU1452ZOQ2YOKWmi5Cqty7LUZQmlAIa18N6xj7UOKDGaiUgFs0QNDoZDFXKXRXzIv8YYKVbD3scy6PLrmonalmIuFjrb62Y8QYwxsihCqhwce0KcpfkGvv/++6ZtGWh9VziRaGXexlloHZllLOrd5yB9UpUcRJ0UVqSU0loXRTHTmqWATNifvQfBOQfRvo0BoIwBUA4GsZCQ9R6AFRu3c8wsZ+mKutBMwd/c1E0yfVP1hOdFGvd5sm6W7eYb+PyrL2NP9wCBZjKb5syNWZRndiMZXeJvujBiE/MAETnvOpnrPYueDjARKcXeR3vLYDAQ6xkAa60PWZreWiBEuYQIcUoTjoIFQLyaS9uI+WSlhV3mhNV52FEenqZpTr/6XZbmG+j6uAIRsWMQPPtFgZ77cGY3QmQRhZJYcSae2ri7jkUEZrYWzABJoUfvvTGmbhqRyEVRTMZjAOPxGIAqCu89nCNjZJxwbYu4wGaUzko0db1Kmmf2o3c/4yh4VPmepfkGmEAEz5ACRwwGgmaUyWxkjbLKs8RiEeWzTkXULXctHhqlQKSU8s7BeZHInRGWCEDbtt4Hq7pzpqpcsMtLJIwxRraURem9t9bGMcPvUnVrrZKemRENU6cMBc7SfAMhmz9Rv6XS+TJprqIunzkzVtWlOTarzhVUb6IQLZqKcq01OusHQSlTFKKPN03jnecg9521uiydtUqpdjqNCx4aY2xdi6CXbwFdiWHxlGqtvZyX2TvnndtoIlkl1pGtK8uQ+NETnzRL882Q7srhklHcegBs7cZvZTJYG/dNYWWMTisXG7pIWNniO5ue1rpt2043T8SoCkaSoihq4Pr6ejKZWGtleKCglTeTiQum+fHd3axtSmFZ0a65dmbP5r70tPIT6BB5VD0wi17s9X7tlW/7U32LVvS4OeNVsgLcifO0YuTf0ogXWi37Vj53cIwLlK0iwUUljwHg8hVmhufZoSSDXymllLNWFYVvWxCNrq/qunZ1XQyHrYQnEiFZkgKAnU6hlC6KsixF4k+nU25b4u4S4kCy9LpmW9SKB7aqfz7RbvsoyLr5gVl825+sXD4oc3fpCd0xkcVEJCY4MZhw9EYCSK992YXLuFIMBlrradDcu7B0peBDdieRdz5WQgcDzjtuG89aa+89Ow/GkpMudNE0mP3pPIlnQJbmRyHVuPeT5s9OZw/VSLrPTwVxVnaqLrMPT9CnK1jJta+qTMvMzLF0Intvm5adQ7pg03yw9+yT965pnNTbCir5Ut18qbMuuzofF1maH540fS7mkT90ox4H/Sn/k1jmib3ncCHs/fLrCQJ9qV2OmW3TQCl2Dsy2bbs1sOLBFm9UumWZBzhVwNepDgcS6M9OO3kIsjTPnBEnzp1bw9I27DnNUopCAMmcS2BRwK26fJHgkaBHt207V/92C2Ic9FI9I73/opE8ugJzz5kszQ9P7z05B9n0CAhy5OndrrSiwOJWLLtqTsX9KqWb2dZ1jFdPD4wFawmvmBKkpDZ9dKXAlCwqdH+e3mM9Q7I0Pwr377vPrffPhZE8LQP63Og+X5dRpOcsOXPuJiR+yGhY30IBXxMYjsSW1VPDF7+VjeaPjizND8yuEYoZIfoJESL2nswdm9PNE3V7SbZ3J1znvrs02idGPWracK84MZUQKC7DvOj27JKYwnCSK+A/OvLw23EaL83i5FoSr+Ov8c1/snUzVvW4VZrgChPBrs9rmyij1CV4H1k2dy5wV1clWM+dc3uWhVjW6l1f4J1786wk0WwcklqPqTFnNsPY8QSrnuPiUHe80X2bWciuZy+KgpNY0tOQdfMH5oDetkfGac0pD3VLSSlmlnriS6RGumVNCx+uO5RVFUuDMbMkmsqWTnwTHckssyYi/v6sCjk71IUs9QCtyT47CFmaPzzpg09tmk8Zov7nk0vbVRaww8qmKPXi5AuYu/wk83PFfVh7Y45316RhjeSahioCM0P/rAV8n2ZslG7HE3+LHoUDStt0wh2Pf5AjryFL81Oz3km1ZuPTYT7G+TQXu9O7dMQmpVJ7cTjZ4ry9yzhSQ2dh6VJxgagoiqIoolFlOp3O1e8+9B07dq/oyVlZHkQpVYfR655EJ8RBjrYlWZofmJwlceac+EH0ohLj1tm/66cmvejEQzdvkV4HjqE49XRaT6dxe1GWADy2WrfoGbKo+J/gpFman4jtY12evtwPxtbTnnN/7+gBzptWPumdZeuTrnAX7tqgtadYEDqyqpFzLjVE0KKhDMe1lR18JpcaVdY5Ng7EaXp7luaZh4AXqrKsepGO8BrQGtl6hHPFyEteFJdbekGXISVaDhX5tCjIZMt0MpFfUxswxy1p6Dr2eVgb57LpDof1IvaOJpfzqF1WWZpnHoiHmILEnJ0YKtqmGfPHJhFRaZOw3gu6jNOtgxBGvs5iHur6+jSC9mgScGa+P/QpTuyfPA1ndxl7xBGnAcIHV7jK7n9lSl03rSnVR598/Otf/4YZYeFGTdAhKUMBQTokJS728Fzt2sMejX2mVy97abO3ufbeF9eIwrVHo84svO7dfjT3dhto+b16+c47bdvWdW3nhzdFajGMD4QliykSQSlYF36bM2GtfK9XPBwZceVz390aS0LGjeno2LdjPaFnt4lHr5tvEyJyH6TDMjw5eKB1/u7urtNLCEpJNSVoZZjhOa63sNI19Eg717FDZedYb3sJzK0CsS5Ye6ujPReS/DUkpQXevn2bqt5RmLJb3pOjKJ+rKXa4NTAXdX/JwLLWijSn9BRhZkOP9O06EI9emmOZ+/iAcsdBiUhv2TPAHm9vbsJK6vDMYDCc80zQWinHQbVJA8/OcBK0O2dVokAbIw/ahRyW5VUBzqO1Z8SyrBYwe+ckTC/uJV7BTSMq6ZAXKu4BY0z8dWkGzZZo04mmTjFnGWv8bOWm3lufn/PTkOYph7evAVDUiYeC4LhpHRRAwQNliDyz98yelOk27pYC8ghYfC2PJdy3e4Jp8ROZyM9Uy3REf6DUpMdCdGAqrWMNxVh7gJmJ1pnoU3+y0EsvijustJSueDJVUQJwzjmG844Z7DyISCej9Wp9PG58Vg/+KUjzNHZqSa7afY8OQInkJqWYHThsIADQxFBgwHu457H6c/RV4IDSfMExuP74zjk1r4YTEcsqyYuHOnlA5NkilQYQXpZYAtc7N6dQB3fxKkuLTIbmFHAiEFlrF1/AdXbzFc9lksTShBOSUsqHgysQdQunznZ75hr605HmRzs6AO7U8/lKWKZU7LxrAUABlYa1B4sYO1vOJACAvXciuOVtlzXVFrJyHnvM2cFJpedcuZV4S+OessOK48QvziU99mJdkp3v0845fGgtzV58Zn7mclx4CtI85cCKOQAQmEkX7Bp4wChYDwciKPiiNGx8O/Xs4SxKhWl4HeatemkTD9q6U7E8RfCAzEf+buu0TBJANvwpy3QhvVHMs9nkfL0BBFP1KktL/4aHcXQxpnB9V1k5WmBmoukKMzJ755AcNs7I2XtaOJK0+1klqj4dac4hkeGwgkYr7awtlG4sABSkWvZSNLp1+OCj609/8PHk9u7/+/mftQ7kZ32IotzudTMCOH1DHkd/S80aRxgyF1gWfNYjjWmZJbD0vp5ZYC4WCOhF+4lBA+J+XJO1P28Zn42c869hz4C+PUGCLzR+vvahhNPkgVp4sPtw7Izqw7FE8hI6P6gCPvvkvd/+8Y/+6T/5v+6mKBVuQ5S5XyXNuafs7CbNH899W4Fa0eX2uJbgCEUSU0FhGfvlYS0LuZeLOl3/67s0ZxbYxzwXJb3jcdKLkl8PViZ71f1fxdL68jQrcT6zwmttyrIZT7Y56qwbh6ewvjJ63EF2isXi4x3WpGZafPgKETmeDfbhhId8ayipdpAmvjwIWZpvgBakufxuFNhjVKlp7YcG/8G//9f/2R/90Xdv6wlQaM2E2rqu5xmdGBMV5mQLMe9maT/sfdvjaPc1uayQJpTUy06DVdZJ+Xl/Sfx62rjFr/T+elhp3hPEe0vzXhsOOOPcWUdeel4KGn26TSlljKubnRqwMtZl3u0xE5paMYfgpfBVY0y3ugvPSXMAJ16l+mGjeE+XIfwgiLqU5pXtipr76RQ/ApyHAia1HxRUW/zsZz/7G3/jb8j+rXPOOlHetV6pVRE09fX00xHlzuKHLb97LOdzGimx/q1IxOVsZ/mw8btHQNosizncxxjVs1GcKakpLIiwjQtmxZ4WjsG9v/ZeVQm56cwpovmGU2hjQFBGg+BCQE7XGCIQ7bMS0u703oI4nTr2eZfylKU5LbDXYbyo5L77UQjZQBa4vBhOWr66HNxNpv/D//iP/sq/9hdevftShx0Gg5KjUZEAcSh1rXjgO5/KwTmZ+FDtCVmIXTskt3CbL57AiL81yUh0yGnTORKaJ5XBOwPXFkaGnignrUDydoC0kh8QOlmsCAT51wfpHKa8BkCXuwSWI8wFupww4KA3CD1Uh3w6XtAj4Wf/K3lEDooABl8Mh2/uxsNCf387JUADP//TP/utH/+O9/6b128ZqOvGAyCgMJDggc43ehaDaLT3Ycf+dyQBKrMoiX3utmi9NOJtHauE4NlI/I1EQ9PSX4/Ersen+YqymydSyYlS4wnHoitETNSVf1FKZlfKGO8caQ2JZmFWRSEzoHY6BdDKa6VUHEik8EtsCmHJrTvg/UyPEwX6If0cu/CUpXl6o/cWQDNPJs9tZJBX5IDb1pUa7NEw7MR9/vnn8HxRFbd1yxxcpV1f7B35LOTLrrfleGJlcbmWzefatMOqSf3587AW2O3xaZ2cBWN6j0XTiigUCP/OdiACUBSFtbYsy0nTKK09s2cP7yX/A1p3p1tdH2bxNh5jdJSjyepFCD7wAx5/S56yNMdBtEjqfQhqtaa78eTy+mo6vqudJ8ZwaNrafvv6jQZ0oRXBM5QmL7NGpSR0/V6NOTT38YIeXtBIQHG6YY9XYj6C5fyl4VJS0/l5XsKsVYn81UWxyguaStU4KaT5AgzsfU8SG2PEktMdgRnOASiGQ2vt1dXV7e0tDHzTIKSEpl/HQnc9uL8nruaBkI2Fh3tkZzHlP2so/EvzEUCOVVXe3twwKQCkMZ5aCxjAAXXrpGN6x/CJ9kF0Jvf8/l5QMYwcqj3amGgkMUVRlGWsu7Q/9/CFLjpdtrk/B/EPn7MQnyO6HAEAxpiiKFbv278h4S5x8nIx2Hdb2IM9FDF1tnUPBkENB1CktWZrxVo9Go10VS2PlTq+72E0GlVVFYW4Cxz7vEs5b0/LY6QEGNSihKp0deNqdVm5egIAFgPGAGiBMRGXJcjTtKu5mIZWIdkkv4nU1IqaRH2R3iyvfVrePbKPRFjbI+aqfGhtjGkTXWyb0x3bubc4pxZWvWA736IVzU/vTHr6lXVODsRSS8Iex1l1H3Y+1oIuvOm8M1uzUkp0BGhlrfW2hdYQic8M79Vg4Kfj4mKota7rmp1Txnjv0VgAxcWwvZuoQembZmbz4S71Q2nylgEoBZ6Lb0w0trmti20FAHHtSIOLomgaCySVO0OI7epp5RH7wxO3tDwAGvBdEV3SSnlVKO0IIBgDauEQ1txyDma1bkv9jtV1ueT1SG1zpzEQpwLroYyDu3LEG5LaqbwXgZSe9xmugNy726kvd+n+aY6xFEl3zrEjRHM8EbQ2xmitr66u3rzhdjptmVVZMrOfNgD0sHLTuh1PAHhry9GouR0DgIIpCmstAPai8s/iFin6SwnQBE6m0ei7ZCgUIIt9XmsdpfmSm7DSG7/63t2bs5j1Pym4UwoYkHLMXYd28BYEXA0GJeiiLMEeieK2Rochguo8/yujCZfO7g+vCM+7KO1514zkkJB5olGHmYi01lpr2uQPfKrsaqFKtRAZ/9h7OCcBiF1wS9CFlVKuaS8vry4ur3zdwLIui8HFiDzD4+W771aj4Q8++UE7rcvhwFTlx5/8wNZtPIuafywzzYQxk/FxlcEV09wl6lR6melgsPTnmGRLy6EpAQdyKAAFYxWjNNY3ptC6ddRwCTiASY3hURV62kZJ05/6JZYWQ11/61Y9Svx7Ij5cUtF0dpg93IDb9IhYmAlzuZTnYGlZ1YxV5905Mk+H4XnpWYIvYVbk5CQiPb26LU0cPQ5laZmFBs6bgFbf/4XtRCCYsrRNA6O70F6jodTo4mL85jt4QFNRls4531gA5WjgnKuqCsD47e3w6kKG1dvbW25dMayctb51SpH3DEZhtHPOx+aKM0sC1KkzwC9x8zLksBzypIiIMVtjdvb2retUR1Qssm5+aDxASmnNIAsLwLYtQBfD0Scffvzy6kJ6jmZvGMa1WP0MukhcOSql22cJrkqp9d6nY3HGiudRBwxeq2Sx985aZ+0ztLHcE1FsZV06ENm2jVp5h7XT6TQs7TintTRN46zVWo/f3oIwublTSt18/4Zbd/3uy9FohK6CCoNBCsOL0WA0HAwqU2ipuERaq8LAKHjPSfkXkiYFA1pvnhFj59OAGfmT6iz+4XWVBKsjqzJZmh8BSewGWMyC3sP7N9++LYriww8+GpalAQxQAXrtevHG6KIwXUdixUlt0pg77r1v27ZpmlOEQMSJ5BmL8qOzmIoiC7AtfVFPmM95z0CaVfCOP7ENxhgTopLWW1pE3HXOQxHT3ncCVCkoBa2V0vDs6wbA4PKyGl7YaeMbWwyHxXAI6+H45s3N8OoKpEB0+/otlHr3gw/upvWbm1vfWCilTAGAPeq6BRSUgTIgDVLMxEqTCVrR/IBNREVZSqCkcy4a7qLRf10kdGoaPfKLk72gh4YVIMs9EwFFqZtx5/r8/PMvrqpq3DTXg+pmWotAfwMA3dqjc45PgjKFJuU9nLeiBUS9JD2hFAZZ+sIcXMSTpHuEGOF1a9M8KJRUtjvskZXW3aubBko/5+FtHqWULAuVyr4YB7LIkhvHDIJSyhEpkCeS6KmmbeG9MsX05rbbk0g8n2IBYWsnb2/IGPbu6sXLm9evm2nt2hbWgjAYjZi5blsA9XSKuAgqSw0JZrcw+obnysxiYElfNBmHfFw9Yz6Cvhcv0F3Xkcm6+aGhorN3a0BhOBwSQCCl1GRa342nn3zy8b/x09+/NiiBwRq7ZCcrJAoXsnbA3HnmC4pF7WAb19OeVzZ/TAqFsM+T2NrD3oqiKIqimFUmiY67DAAg5tFE4sblMKOn2yoC4KwFs29beE9ExhgyBkr5tlVFQaL1M1++eDG6ugKz7KCKgq0FUdM0AG7fvPnok09QljCmKIrkFAree2tnwSdi1Vl8jsGw1jaNT5yxIrWdc6lTNX1DVbSrxPf0+C9L9oIeACIqy9Ja65yDqeBawButRhcDo3Rdt5NxTaTBnuAN8LLA7372ybeff/5mij8HAGgN6+ABbZS14igPRw89ZGM47GGuRc/HTYeBYZal2Uux21E3X++N3NJ11tu/t2VpyPlK3XBXjSlmqTAj+C201nEdy+5Ps89zwwnNV+U+H2Lw1fZti+qqFKTd+MXoH5Zf5UmRMjIWamO898wewODiYnp3F6uv6LJkghdLOnsyhp0DMxlTlqVzzrZtJzqdU0XhvR8Oh5PxGMw0KLmuAYAUgkHHyaG6+jCAMSDAWig1HIxUGI0kDyi+DlLRq5fY0Xlx0446/+50q6nM0hFyvPlZEkWPRJVAdBDHYAXy1vvpdKpJ+dYT2LMHUJiCbXvXwrv2r/7uj7/5899M6vLNm1vrAFnbshNJi1JbcSfQj6sGcmJA6G8Mv/S3HILk9ZgLgrx/bMaBmzp/K7xzdq3uGW3B1DniPBaGnEdKHJYkUFWU1jW3Yml6hNbaiv4uFRM9FVU1GAym43HshM5aEMF3BW+NUtZ7ZiZmb613jgCOi8x5D+faupaRoBPlAIhgrWfosjRlaeuatCairgC699C6GAymk6lKHlCcfS4u4B4k+waXAIfI4m1v6z3I0vwAiCuy0w2T59a0Huw1g0BVOZw2dWNdpQGHf/mLr5uvvv7tj6/fv37v7dtbYigFJ253zBLZAKQrz52iRwRp3hOvvXnikvit+yGm1Z5afZ8DLqrtR6KbtaxorTGmbUO6b2jGeqn3WLjPXZWpADNb24o8NMYQUdu2bdPccsiolL0pJBMRKVLRLMPM1lr2XmnNUdknQhhg5LiwVhTrGE9LzCASDUwBpBUATzDGtDzlZQXgepe8TeecM/FxqL1+zHf4fO2ej4KocLVtKx1IQSkoQKe7KVDd1IPhCEbXHkoDwIsr9f6L61KbWZ8JNb3netHpV7RY5tlTAZrnUOdMp+r3t8inzVsXb7Dv0WfhPdu1BOEGHrIZp4FW/ygirQajIRQpoxns/MohKq0ALnPZ7m6IKzJ2Oefgva1reM9hwKNEu/GWbevhCdCKDDuAlSIDVmAJ/ZXMTi1brq9ekqnABE+kC6NLttzWtjAVHOy0tY3VZIwpyVM7bRFjVKTCfvyZN5ft0PNPOAnLuvmepM6QOY0SiiXFR6ErKMRgEEFNJxNogDB1uAR+/KNPX11d3H71vYSyyDGUkiTSB/NopPVGmGfrusVp8rEDrXoieNVrQwtDzuKWI7Wv+xDHnrBG5dLdl1rJH0VFhM0wg6gsy+lksve4fnV1NZlMbF3baBLR2hgz+1WsKACAoizbyVTuvCJSRPIHmR6Jhdo7Z4xhZlZKbN/sfXypXLKbk6fguWkaInK2s8vPZsXzL3jaM7fpZv19ckzL2SL+n5gSRsFzLXVvuyenJa8NDC6LEqQAhobSaIE/+5NfTie3b968gVhTgr167UM/vlt8md7R33icMOpVA+SuB9n1rdsNXpI9tEaWRZtyDPDA04holJucmsJjzN8y0lFNvItyN+q6nllFiMgYiRoqh8OiqmYBJ4yyrF5cXiGUEe95I0TTl1+lsoL8e/f2BtaRMYUpJPpIsu2ccybMD3zTuqaBZ9IGSdbPrPVBmi+GkK2Bk5ISJ0gdQpbm94Hnkf4aJ2MgwMOHVWbrti4vL1EWYLDCVYXbO9STcV3XCAbxkFK86oSneFhrdMk5C4v0zoN20M5rlNhb9shxTc39pxGaHAb1VUiRbmlMdJg/duJ9lme0q+UtdrNmMpGS5VCKtAbQtu1kMulselqDiELenOhLYmGX5yuf42FjvlJUs8Tg3ilaweTVWczlUImc1aG8F6kkXz9ZjiOay3o+0vV3ShsjfWDLm7M32dKyJ0sTIrpnDMPKeszecAWlTVnf3kJ7Ghh7Z98yPtC4GFZpXywK1XZy8+HWJVrhBT1BSHV0bcmvZVlWVXVzc7PTQZbaWw5o3+8OGOcQaam/ZYiAiNO4aC9+Al5QANqYwWAAQCllrd0wr0wiFKNaHReNQwzbJwLRdDLpnJ/crdLV1PV4PEYScCLSXFzKcQ4EwFrLzJ3z2Wg455qWjFFEDLRtC2ajtPe++5ZSgATIWLCbeVwDEq64OFwRzSX8rbrqOJnYeVnEHcnx5gdH9T4ToKRALvxAm8ZZQ3AMBfzH/9F/+K/+wf9yC3yJ6zFeQnmUY7TfFQzlARQWpYMHebDXMBqqwd3Ss4YurtJ3hoiYncwQ03nfrLLjkuYnlopEgsdJdG87rehCx9aLdxXQh21PevbFI8/9FUl+SigKD6BJ7MIpXdj14ti5WFOh20Lx19kamElkJ823btX6hST+neQDAK20JQfgxfvv39zcXFxc3Hz7reTZz2qIy7/GABgOh3Y8FTEqvS7q4FIYjkLYSfwXBBBBKY1OEfbeE6CCPh4mt3P3uayqeAOHo9FkPF5S7wyd4dIYY60tiqJtW21MF2tIREZ3flcARksII8i//OCD119+dfny5e3r12L84aYFYKpKLPiSNNQtYcpKjp+eZVHViyMQLUQYH7BfZkvLoaH0afWfnJU6+ZJFCHz73Xf/1k9fNQBhbEoGapiwFAsAtEAN1KAaJJ+XL9OVnjG1z/a2pr+u+r54A7z4jqgrOUSinng/Z4c5tKXlqZLqdMwcFcml7F+xi5ePWIs1CpcS7T8MjiO0xKjo4bCu69FodPPtt1CKjHnvg/dlTU4zGEApiInDWufc5eWlaOtypRyqBMtchJlHo1HUrBeND717Fa+o1+uaujZFAUAbI3lbXb2zXrRoUN7j8cXeorSW8EY4B6V0WWqlo0r++suvzGDQNI2uqs9+67e4baG1LkvbtkYGA2ZtDDNXg4FY51M3uHwuikJOTSHbbqmR7bAqT5bmR4B8ItO9eNM1aRbHCNC4bkWUP/3FLyf2m/ffQUHWNt9ATWEnEgkTsFAeSh6UB1aW6Ur0QR9HkaiVR6f8TiptNIZyGqolgS5JwFlmI9HTIDLOO7fE8RB/XYyAXHOr487zD2jV7rziRyrox8+z7YCztqyqajD48LPPqCiI6OsvvoB3UGSnXYSJbVto3YzHt7e3ddCaoyzzITu/LMt3330XgKy+VlWVlLrFgtc6/TA3Ss2PATNxKfeTQ2ThfPItEguPGE+KspQdirIcDodFUShjVFmWgyGAoiia8bizjzEAXF1dFWV5eXmJIJ3BIRjGOVHGO3MTAEBClmUwUyG6JjWv8aFFObI0PxaMKFLlmXmCD4oSAw5wwNffv/3Fb/BXf/8DRSDUUIx2SgQJ2+09bL84SUtPGHp8UAE84JlnITdbCt80LGFOlC894xOIzTg+M3k0Hw/TfyLMAMqqmnn2aIuilVvMkJg2a+hx1pU6ojvPYdu+ffv222++uRuPua6993Du+tUrMEMrsEdVfvrZZ6KqxzQ6SAcO7kpmttZa5+qmAVDXNTNP61rNr3MfmxGHpqWtvby6sm0LwFo7HA4BXF9fD4fDWY5bEj8jEtZ7DyKJpbHWxpSutq5vb26m47FvWnbeOaerSnYG8Pkvfgmt4dzr16/b6XQ6nVIIm5H747z3zLKGbRfdK75WrdOfOHjzceS4kKX5oZl7Vp2azID1jgEPBU0eUAamVB5UjXB1/VIrXA+HaGp4VDp2SeNh5jWolTEe0cmepmZwqPrWC+raEFYRRMlsGOj9nLEo5xU8WIOWOSEoiYuYIwRpiILZPbi9YmAWL3i9TO+CQMIEAoDSuhIP53CIuh4Mh7fffgulYO3w5Uut9dV778F7FAWAL7/5urwY2bYpq8qESKSuHhnNFtjzzr19+3bWJDHreQep0JIOAyuuQg5CREVZFmUpI0BRlquUldQA0oVIhTFVFUU5HHbVYJjlbXFhYlGNRpejCwAyWsA5EI3HY7k59XRKSkkwe++FkgJbEvPurLVta9tWdivDhOBI5JiWQ9OFGaabpD+JrYQ9A4TWQYG945sJnB+8+87wz76+M0BRkKtlaYrCowIUuIVvRZQzijXGlpUtiiq2NG1t8ZNFt7sK2THxOLJ+467NeL70UgmknknwxfW07958XMZgWr1KdffFZU8jDXudsVZJZxUKUQFkdDGoJnbq20ZfXpSDyvsrIqrfvp3c3DRN48ZjlCWaBtIpm8aMRnZci1kpVpuCdLmwpZ5OtTHiEVVKOWfn2k8ksYH96w09Vinlnbu5ufnggw++//57ANPJ5PrFi5ubm1jRUGnddVTnlNZi1yKlyrIU95G0ZFhW5XDQVUzzHl1RTHLTWg2orWt1cVEMBtZaXZZKqaooptOpxLdAJjHeAyTTDoQ2y/QiOmllbBOB3tT10pirQ5Gl+XHoRS4RQKyo8F1tIALgnQfwy2/w4W++N6q40JPyEqbgmxvUNRgOUCwPqLPb6I1zKe+9cy1CvZe4saefbhUel1RzlndDFP85h+pDhlI+KkKtAu8c5p9FuuIBmOu6RjLubn5S8UH3sl2iL3GXRqaGIJnkmdHI3t66tn371Vc0HBqpSsHsxmMUBZoGRYG2RduiLJVS1jmIPNUa0WzNzMwxEMVZK8K9bzkM9sD0/hBRIupn7k2xSstvdV0vVsWKsTQ+OGBpPmV3PB5ba1006jgHoBwOmslEBobJ7a2pKlvXpqpc206s7YJViMqyJKJiNLp9e6eU6uJYwuDRtVapqqpEtZ9MJlPxMSiCBA6ls9sDvUTZ0nJgiENMWHy5QlKQZy/xWGY4UFWpqoEqRy3wj//oV199/fb3f++jf+enH77zEr/3+4AGwzPqYKuxgGPUHsvD2pC8y86xc9Eyi6hNp2/IZtUg5E1IfIsLocQ9+3t2hG5JDDqWX9PpfwowC2SUuAu5/1tWArjX45AcyDjrCgF/Yp4Gkb644Mnk1atXKIpPf/xjAJA/OQfADIdomubuzhSF2D1mPQeQMJJ33nlHhbrwIuOMMd3sRCuEEP5UXYhXFO+PyMpqMPju22/lD0VZ1tNpOpjJeVPTFgcvZCxGr41h7+vp1LfWKA0QGESqmUwAELMYnWzTAHBtK2aTsixF9BNRPZ1OJpOyqsR+UhSF0jra7uX408nk7du3b968mU4mMsSmlY5mbT7Qa5Sl+VGgpdKye0/ITluCLkwFoAFa4P2P6D/9T/793/2d4d0tPvgQf+c//xEKeNTABKhBrdLWFC0wWXbc2bGNkZ4kswEp/7LjuE8kpndTFKYodEyWI3LOSR52tKSvMlKfwE79sPbx9WdM/ypWVGaOddlkj+7/sI5oFxIaEFGYHjHVmtONM6t6PB0RiKqqevHiBQARQIPBIHa/XuUsaAWj4d07r95776MP9aCSjdPJ+Ptvv7m6vqbhEHXt7u6gTVVVFIq5/80//MNYghxAeXn50WefOefapnHWXlxeklKmKOS6iqJomsY7J57V8d3dYDhsmwZKqaLoRhGt0muU4JN33n23KAoiYvZXL18AnapRDQai9bdNQ0qBuUis0mLfUFq3zSyoV8LS5etRlxd7+nA4jE1FEicqN1Os3qTUeDzWxpiicM4prZ21TV1PJxNjTD2dKqXu7u44WaBDQr865wcRmElrGZ7FNaJD8upBBHrWrQ5MvKG8uAkAlBRxpqLQ2tim0a6tyBvGf/Z3fvy7f2nwy89/9vv/7r/5R//31//tf//LP/8c07HShfLOMtBVzV0x89aanGOxfKjwUsTwmCXtXKHHMWaVtrAYHxa+ONvoTyRAHyvp6hbHgBXCohmSl2SttdZKfVfnHEtpz6KgbqEM303ZFqKVqsHAOWen07hFVxVrJRkxfjIBcP3++29fvx6MRtO7O4iduiiqwaC+udHDoZtMCl1qreu6nvkGAMnZKcqybdvhcGitbZumM0oUqhoM68kEXvq3F9tI7GAXl5d3d3diza9GI9/aKKBF7XBh5JP2d3bt6KUwGjxbLZqoKyoXVwRUyZwAzFDR+rHieaXmIOZ4/8XMgl4IUwwRDg0wg8I2TfcmExVF0cY8rHt3kKybn4jOrU8k4o+dt9bCeww+nnDhgP/5H/7pd1989YMP3vvZ//PHf//v/dJ6tAyQcrLcFSPU8lr+yMRQzoCepUEsWRhrK5hDsEFin1ka/5t9oRtZqlbvYRJZ85XwRMJzc953EdBi0NBl6dtWdbmLUKQKbQptjNIkMzjPhSnaurGTaZcQygBoWA38ZFJPJt654vISwM3bt3BuenMzGI3ADK3RtL/9o98y1cCNJ6oo27bxBAabqqTCFMPB4PLCOQtC2zYATybj1lko8t6BZJkIqdDCYI7BV/HiOkcCdZ9dXJUC8DGhP/geRqNRF14SZi3GGJUW0tIq1ucSxCzj45pwnuVHpp9dakWa5cRh7UBxTnQmSQeC986DmX0XgiZ/YhlBAUWqLFz31+6Z+u5/ad7CM9+ph2RpfgRUP560+8Un/wLs4RkMVxOrl0rh9Te4Hn5a+Hf/+J9Ov/wSn/8GrlbgCmyIYbQqzND7oZxi8azMslg5VFAGD1DkJ9jKVVgDc/GvmX3Y49bxTAT0okUBSLzEZDyeTiYSJSICQh6cMhoSnkhzZqBuvu8kQJBZdMmiKAcDhOwYaI22RdMMqgpF0S3l4/305hYMWAetf/7zn4tG75sGUrSAuR6P2VpJeQegyxJEpqrk69JsVRSIoe5EpJQDz/nYo+FeLCRBDdcio4NBXKR/52INs9cusjBFzNZGK9Ho5ysozPr57JYzPM/WSuyF9itFWuuylBLto6sryY9d/viIdFEMBoNQ3Zfjs8AKc+geZpMszQ+M2Cb7N3beVgEGgTQRgHd+8rsoB403zuG//q/+2X/33/z843d+OLmBawG+0OWoLCtFSnnjbUEYrTwxoSy1Umhb6R/Qeq+Hmx2bByWWRtgmzWfbYxLFxILlpVaJXNN4a8fjMbRq2xbGMLMuCoRQGWutl9khAMDWNYecSWaWiJRmMrl6+VINBgBs3cC6mebu/ej6Gkq/uH4xGgx1UUJpWYeFlCJjisEASrG10+kUSrmmAfDy5cuL6+tZ1VkAQNs0sFZq4XaRVFGqhjxPsSWJUweAs9Z7r2IwfhLc4oPBWm6ObduZ3h2kZ087kZsplihNKkQtJFEDzqfmx9g2pdRwOJTZwOXl5XA47I65LEWg/3UAceg6kGKUpfnBUclPggcY1E0ZvQrS/PvP/zkNyQEecA2uBi8+/1VtAK2GYHJki8rrwlvfODg1iyhdqp53A39VSZW+faserp3U9z9k1hLf4SPF/3CMQok2gWS1eG9byfchItc0zlqttGLAeTg/E83cdU54hnW+tTq40W9ev6lMYapBlG4kK6owqqKEc2++++7y8tI1DawzpACwc9fX16PRaHRx0YWFeC96693dnXNuOBxeXF4C8KJ3t618y8ksIerLMTFCB9tLkMXi9oy+4mgM6YoKEBFR95k92Megfm+tVI+JBXJn0TIymLEUyIOmWYkV8SFzr54XwMx1XctANZ125cYkd7T/EjHbtq3rGoUJliXEK1p84/brK1maHxxKnkX/9jLzfCkuhv6OJ78uCs/A6wneefHpn/z869bDeUC18G9ad+sdQFCoCSurNQFoGgkewI9//GMAqys7bXMRc2mfcxFy55oFep7EbHU+3H2LdhI/byhAdM15r4qic8BKfRIR+t6lzu206jcW7AxKKVMUsFZqSHnvi6IEKbYOwMX19ffffAOGMcWf//o3YJRVZduWjJFg8DfffTe+uYm6qpTimtzeTu/uJPufJJxDKTUYiAHdBfcmh8R6imn0QXDLvyZYWqTlRVGwxBQyx2KKdcjChzG6KBD18RDxKaOCqOSLcf0xqFQqM8/9Lbwa3vs2OI3fvn0r6yVdXl52+/Tw3ta1MUYi+cNtx/Kd9yJL8+Ox5N7KmyT/dh9UDe0b6y80ABRUFlpsixbaofCNBROUgVbWYbp4zO5kwcn66tWrn/zkJ8PhgZ7sUideZnviDTzUPQw56HN587HYejgRh3QYeA8JMy0MtOYklTe1FGutOer4RFYcg8Dly5dKqWZaN3dj7z28h/fFYHB3dwdGUZZy3hcvX4rZmq0lYz799NNqNAIgIrsoiundHZSC1lDK1vX45oathdaDy8sXL17oxMatQgkUzFv/o1HIO9c2DTNXg8FgOFRKiaVehWqOaeVCGFOWZVGVs1hAUVBCfcfUq6+UivUjvfdiz6nrejqdzjlCwzDQ/VYUUR9XRfH+++9rCUtP9k8+KlLKR+l90GUDspF0jqPm3S5lANQAFwNYvlD1T//ix0Pl/9UvvvzNGDUVith4SwBKqosrtAXab8uibBpP0IAyCuwnuoBzKAcwBf7L/+Lv/Pnn3/7D/+kf/+JPb9SaAPWQ4SmfdXzP1WwtOx2WAuin+4ckCKWUbfqVBtJ56/NkG6PKrn0sfVgIgpiI1OWFMWZ8e4u2HVxfW2vt3VhEWHM31mVZKD2dTJTWQxHB6Ib9aCx2zklyZu8sYoJwRaf8+ljDRCm0tjMNWys+IVNVg8Hg8vLyi6++mEUEUlf6/Ief/fCXv/gFbFdMThrPzjOYVLfShSkLa+177733+vVrCW2sRqP33nvv888/74YlrcGsiLxzo4uLyWTC3puiEDepBJt/+OGHX375pYQwdqXMiWI4YNf40JmrwUApNZ1OOVjqOS4VFmoqMLMxZjgc3t7e7vfgFklXLEnWIcgK06HpeSqOZOtMuZQq/VQARQl8APxkhD/4y5++MCAoAi4LDGXU1RXKd0AoSwMoQwNCpVBoQBMKDWNgCvy13xtUBn/tX//wukS19tSpSbdbQIvmU0tW/SgirZTRyui4Psssw+3ZQ1twkFMopVCVF++/QmFgtL68gJF+YKA0SIEUKQMobcrh6BJQpIwpqrIamqLSptSmBOnOzUOalIm/kjJKFzAaZaEuRjQadnlGVQmlXn7wwdV775nBEEpTUaqyUmVVji5QFtAKVQmtRu+9i8JQVUEpKkpoI0dWymhdGFUoaIR6hLowIFxeXymjuxQnRaPrq1mWU8h7GoyGL999J25XRpNW8vPinZekFQjyr/yostBVKZ/fef/V+r69+GjE2HLA7q2Ukurn8WiHemuypWVGTzFXwQB3VBovotoBThOmwHdjfPjxD6xFAa8B28LH9S1cC4J1lshDe8AxHICyxPsfoijw/iv8i59N/9Yf/M6f/MmXjcVOJds6G6UxkgUqUbqklDamKMtZYAaCKV2WiZnviFnFOA3RdA7v7968GV5fg9lNJnowgPfKmNHlZTUamapSqlt8eTqdAt0qpqIVyvIOMix0B03qqXHMNoi2CKWgtNEGxlhrvZ0ZoJnZN20znrx48RIMo837H3384av34TxLRI1zM1OJtME7SZiRg8uhpEghhW42Fo1Y9OvQsLZt7+7uAFSDgfhCO7sT89u3b7vE/SSqxLctBd9AV8WQKCaOSg+XqUpRlnHKIn+V4zTRoH+I7s2h0kY82qHemizNOxaHR1rwCx2DhkGkwF7DGw0HMPD9m7cjgwIwXbiBLEfH8HVRdFusbQiuqrTY4P7u3/27H3+MP/zDv/7JZ/hH/+j/ZcZP/uKn7dp6i3N5QKFLxRqeXX0o710oBh3tqvELvYDZLMqPTTSwzDZ5XwyHk7s7MT27yeT63Xd904xvbqy1tmnE+NvVbg32hCXWs2Uws0S2qC5HMph3QLdv3t7d3fm2hWc4TyElWAreeu8nk8kvfvELSHZya3u5junLJus8dPGRzvW6pbRDzCOqKMqq8t63TVMNBj/84Q+7owWLeYw5oRDaKL/aUNHwzZs3AJRSbeJxlTx+b11bN8wsS7kuTqQO2L2XXOMhyNL8oSHj2ZcKGmgsiNAC/+Jf/qsffPJqABTAwKAyBQPk2oJbeS9evhy+8+5VUVJdt0T4nd/54R//8c9+7/d/+ptff/n+q488MLwwxpRbdphFZQEAiLQxXZ2WeQ9b6oKfi9novpftLUchCpc5ga5Ue3t7ITGCwOjq+vb2Nq7upmQVhZDmbowpq0o00HjMzn264nzwHs671rqmhXW+aW3TihDXIXxrViQ2TGd909x+/9rXjdJGl2VQSWY1pyBWDdDchDio5GAeiF+UKI3d7pSGhZpcgujRtLCIdjkcQvyxzNO7O8TAmKKoBoMwL+l2ls48l+6fnPpQHEma57duxqKlhdbUlT4U5SXa8UB55TrFHEAF/JW/8NGf/+qLNw1qoAUxSMMboBngb/3Bv/ejH/323/97/+A3v/mmNBiOCkarCW/D6vYUkocHZXnbbFxKFEiuXZkutkHqfhCRLNQy98LPqecrD7XvHXn0bDOY7Xd/ohznALRCWaJtVVX5aQ3m0fX1+M3bajQaDodt29bjCUJGpZgXWFbs9B5hkbO5RNPkMxExwtJ08VmHfRYXpNZaV1cX47dvy8GwqevhaDS5ua0GAyKaTia9m8NdXE0n15TRaSrNO++++/rtW7ZWCnupovDpTJMIzLK+c9zWVdylWR15+fDhJ598+eWXSikfboIo5heXl0VRTMcTqSojXV1amFZ+luHnUF79/Hacjp5eeQods7gGmQHhAqgADRDUtaa//Zc/++n7xaeEC8DADHX1rsY7gCpgSnz0yQuloU1c8RykMKigFYYDlAYauKhKvXbutfxKU4+QVqk3adEflZWBpRzVC0qJhktEKAooVV1dibNRybLL4v+MjkfS4tIsysGiq1PcpNERmn7uHKELX+k+hC1KGfmsdQGlzGD4zvsfgJTSBaCqajifUqeINM1O1AUgDi9GoM4XCkWjywtI39MKhGI4AEGcmaSV7CyfldGmLEBdAYOuixIuri6j55MKQ4WR/WVn+Vwm05TF+xw/H9Di2jeUHZRsaVnHKYZQL8HCAKAAMiVD144//fTTd19eX15gVBQE1TrXOpQAe1QVymIgBTbKge6UJ6BuUJSY1pDlXNqGaPVqJOmcdwnUFQLlGGoWt/d3vK94yuxEf5LOrKvKOVcUBRWFrxsZY6vRyBijac6i0jaNLLVcVZXEX/O8co35IwOYy42QQwGYjxEQQzPEvqGUrevvv/lGFYXUwBLN1ygtPnTRfCUqHOFQkFrnQYYqpcZ3d+I1jVlCqihevHihtGbvp6GguTHGOyczj7AUDJRS2pjRqCuD8f2333KoYaCUsm3bXbvz4t6MvVciu+INSO1ROz6lh+FxtPIpo1/C31XcasACDQxABu1P3h/9hU/e//XnX1evfvjVTfObX//ZT3/yo6K5/V9/+XX3xfmBZuFBGlmriNdFnC9jVY9Y1aGfaEXcc5sRrxIobAycA6miLNvpFEQXV1d3b9+G5S7D15OVSFVc7WhuDSkGUJRlURTOuaZputQkOct8qDsWDJKzcptKYro9gKoaEFDXtdhrjDYXV5evX78uy7KZhYQ3chCmLpFVEnOMMTYYOpxz4gXVZVlo3dVJl5K23gMwRSG2e6myK7YU+azCMrmyuPNMO/HdregM/fOJtY+UvJLcg+PB4LggNACAgV9/Pb797hdjh+LuF2NXAPjm2+8v9fwiikCcXfFs9VEl1pf7TrxS43jmbPExzG+WyRmSDwlJtfrOTg0f6p9w6DMgkBzFu9ZCAmCcbF/Vi0ajUdM01tpoXBZHy7Stkczn0vK21tnxeFxVVWstCOVw6L1frFUh+zdN8+Kdd8qyfPv2bcz4d20bP4vFyYZKYbJR6oynI1/M+UTqPmVZBkD1opDZP27dJEvzh4YdgFAlE4jB5cAbBwB344nFRAF//t3rJBuo945F2d3Ng8Oh9mW+Vtz+x8kcmxAS7oMMJSKjtA2L/4l05Fk8Uty2BDdf1J6IpBMt7t2VGg9nZGbrnPPeXAxt8EzK+sgIo4XSWiq0/M2/9Qf/2z/+35u2iWupxEDX+CuY37x5Q0TsnCSatm1bj8eihksCDsI8QylV13UXM5MapqPHeM6ahG7okgo2clLPzFk3z9wTbwFOFHMvtRtcQa5lTfAMDRilnXctEB7Z0p4Xxa78dV89Y77m3/lYGzJLEIWbma0DgzxLVSySxZGT0oOzbyw80DnxvXgGWtKVYqxXtNuIRf/Fy5ffjsfQCs47Z1vbFViXBQiZ2Qyq/+Of/J9spS8buKbfJA5LVDvHWpuydM7dvnnTnSzYTLpl+ZhB1EWaLwbjA11NAimKG2J04l+7icWa2/uoyNL8gSG0DMUoAACO4BXggXHLAIghAQTOOwAN6bn3imLtUAAqpBnJHr77axbFTxtmMRBzqJXYtq04RUO6brdKjpiPbVtjxQgdDTJRIHrviZaU6mbg088+m0wmd3d302lwzBAAFEUBqW/FgCywBTjnjDHW2sFwOJ1O2ChAalExLS1RErdI3lMSJdzVNpmX/t2KFvNpE50VPg1NAcWpSWJ6Su5AsDg9UrI0f2AK+BaKYSR6QHEor0YG1ZDrCZGVKaAFHJuuUDoSUS6fF6V858DavU3MyGWAHg89bVSSAxYfnyfISgw9TbyXXx7CwFd2ANn6+eef+2TN2Wo0urq6ury8/NXXXyAowhIWJX3JWjscjSaTMYweDoc//Et/6Z//0z8SZdsva63SmonYWrYWRMPLS+dcM5m4YFCa+XKT+YcPKf7xQtJUCQ51FmeXn3p3H7+O/ugv4LEzAGoophEI4Npwq4AWYF1AVXCtRl15OMAXVYsK7RgAaFPx8mhF37XK+SwSbd4LmmNaHpSVMS1MsY5g3LWzKkRbmYgzrUgp2HaVNE9/jZ9FN+8lCQMgyTLrrCIMZmhdFEVbTzAYYDKVOEFfN0VRtk0jFQ11VTrbAoxB9c77r77/4gtjQ6F2mh1cDju6vNRa39zcrFzafP4GxWmK3BAK1QLCnVpiPFy8p+fyvPci6+YPjCRROAAwQI3Yw5QBK2jj2loco3Xrgu8zBpaFo8wp5gsf9uNsBFlmPSqW4kvlV7CuAGCl3CYxlca9YIvBjONiKLGEsrUtoK4uX73z7le//g20Nto0dQhHsVYb45oGmqA0rL27u4NzSy050v7xzY00pYu2BOLqiD3zESUF2RcvrLs67ofq07w+/qhtLELWzTM9do1rfPSRAJlDQjp6JiVUXIRstyhzUPx1CAPXWt/d3XnnyqqS/CbE0uQAQr6+KYoQpbO8vw0GAx/KQ87a8swMhlk3z2Qyh4ZZau3GSHCttSzIKRJd6iACKMpS1muO2aQikruiK4D4UW3bgqisqqZeng0n3tHe0nrPTZpn3TzTI+vmmXsgunn3meacLqsFqzamKAoxmMSMTVJKa22tlZwgOQ6t7m+LCat0uGpZj4IszTM9sjTP7A8pM1fbR0wrPYdktyuRBL3MvqviEmtgfve996qq+uqrr2IlAGethNEvsijKcU5O7NOQLS2ZTOZgzBUYiFGPoX6WxCN2inbMEgoqvOSzSuCgFJZpmsZZO3EOzKHU/ob4ludmXUnJunmmR9bNM/cgJtUv6OMUloCIyrvW2rU+jUrsaesScZhWXd9GN3+2ZN08k8kcnrRAozHGSk5T+OusmkqQ1BL00jNzM/PV9bWU95Iol1VS+9zyAx6ErJtnemTdPHMPFPW8naYopEKWmE1kY9TclSp8Wr1rwebepR3N1jla3t96BpbsBc08LyTgtw1phPI+DIcXzrlY6RSrsxBlu/fd4lvdJHpTXnjmibOrROHttIeZseUZSeddyZaWZ4rUFBXlRUKDRQQ3TcPJ4rbYNHulxN/Vq/iReY4c6Ml3C5bKQkJaI9bbyqwmS/NnShTic1We5xc7X2+LlEJ0i6IcWTfPHA4KBbaOvt764ydbWp41y8TubOYbC87116IM3wXACxFjPQNOJrOWDZYWClXLu1TSbGlZTdbNny+pQTxq2UQ6WlpiqeteOka68bmp4KtrGT6zG3EqmDlq5RTWQ88sJevmz5RU70YijLQultabXpRiYUsn95+JpSVL80OzUjdfLNirtba2OVG7HiFZN3+mLDWeQOr9rzaUx89xkZqe9Xxxz0xmP3h+5SAsRKNnemTdPDPTN4koyfmgEIO4MsIXwW7+fCIUs25+aDZHKMo8MvTDLNAzmXsjU90ozrTWVVXJr/K+SSTZKnmXyRyPqHw8Z3ZN/Ms8a1INNDpLoyYef01XX8xkMpnMOUIBFeqXYkEfz9I8c2Kybo6sm2f2QER5mjJaliUAWT7muRXHyGTOhCzNMzuTKkFiKx+NRgAuLi4ASImlTCZzYnKEYmY3YuBKz4a+9HMmk8lkHhOioUdLy0M3J/PsyHbzTOYApOGJYmbJXtDMicnSPJM5O57Sa/lkLiTzKMh280zmXsT8qRhun+txZx6ELM0zmT1JpxGxUo3WWsxNvUU/Mpljk6V5JrM/6SofMSFWlgHJsT2ZE5PtepnMgREn8KoqlZlMJpM5d3oLgEjIZiZzGnIkWSZzGBajcbJunjkl2dKSyezJ/Ip6eaWOTCaTyWQy9ybr5pk5JFYa8+uFZn0zkzl/st08M0c0/kYTcBblmcyjIOvmmTlidB2yHM9kMplMJpM5MVk3z6wj21symcdCtptnVpJLAGYymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMpnMvfn/ASXiG+UyMnDKAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=495x282 at 0x267DC8A5E10>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image.open(gene_dir+jpg_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use i to control how many samples are processed\n",
    "i=0\n",
    "j=0\n",
    "data_list=[]\n",
    "GO_list = []\n",
    "for gene_id in dir_list:\n",
    "    try:\n",
    "        GO_terms=GO_data[str(gene_id)]\n",
    "        gene_dir=image_dir+'\\\\'+gene_id+'\\\\'\n",
    "        jpg_files=os.listdir(gene_dir)\n",
    "        for jpg_file in jpg_files:\n",
    "            jpg_array=np.asarray(Image.open(gene_dir+jpg_file).convert('L')) #converts it to black and white?\n",
    "            img=resize(jpg_array, (64,64), anti_aliasing=True, mode='constant') #resize all images to 140x300\n",
    "            img=img*255 #multiply by 255 to scale images back to the same integer value distribution\n",
    "            img=np.asarray(img, dtype='uint8')\n",
    "            img = Image.fromarray(img) #convert it back to an image from array, for input into Comb_dataset\n",
    "            data_list.append(img)\n",
    "            GO_list.append(GO_terms)\n",
    "    except:\n",
    "        continue\n",
    "    i+=1\n",
    "    if i%500==0:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "555"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='data.pkl'\n",
    "with open(filename, 'wb') as handle:\n",
    "    pickle.dump(data_list, handle)\n",
    "pkl_path='C:\\\\Users\\\\user\\\\Documents\\\\Documents\\\\McGill Undergrad\\\\Year 3\\\\semester 2\\\\Comp 551\\\\proj4\\\\data\\\\data\\\\data.pkl'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('GO_terms_per_image.csv', 'w') as csvFile:\n",
    "    writer = csv.writer(csvFile)\n",
    "    writer.writerows(GO_list)\n",
    "\n",
    "csvFile.close()\n",
    "csv_path = 'C:\\\\Users\\\\user\\\\Documents\\\\Documents\\\\McGill Undergrad\\\\Year 3\\\\semester 2\\\\Comp 551\\\\proj4\\\\data\\\\data\\\\GO_terms_per_image.csv'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GAN**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import math\n",
    "\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.utils import save_image\n",
    "import torchvision.utils as vutils\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "nc = 1 #number of channels (3 for RGB)\n",
    "nz = 300 #size of latent vector\n",
    "ngf = 256 #size of feature maps in generator\n",
    "ndf = 256 #size of feature maps in discriminator\n",
    "num_epochs = 5\n",
    "# Learning rate for optimizers\n",
    "lr = 0.0002\n",
    "# Beta1 hyperparam for Adam optimizers\n",
    "beta1 = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Comb_Dataset(Dataset):\n",
    "\n",
    "    def __init__(self, csv_file, pickle_path, transform=None):\n",
    "        self.images = pd.read_pickle(pickle_path)\n",
    "        self.transform = transform\n",
    "        self.labels = pd.read_csv(csv_file, sep='\\t', header=None)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        image = self.images[idx]\n",
    "        labels = self.labels.iloc[idx,0]\n",
    "        sample = {'image': image, 'label': labels}\n",
    "\n",
    "        if self.transform:\n",
    "            sample = self.transform(sample)\n",
    "\n",
    "        return sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = Comb_Dataset(csv_path, pickle_path =pkl_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GO:0003674,GO:0005575\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=64x64 at 0x267E1090048>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_idx = 309\n",
    "print(dataset[img_idx][\"label\"])\n",
    "dataset[img_idx][\"image\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ToTensor(object):\n",
    "    def __call__(self, sample):\n",
    "        image, label = sample['image'], sample['label']\n",
    "        transformed_image = transforms.ToTensor()\n",
    "        return {'image': transformed_image(image)} \n",
    "               # 'label': torch.tensor(label)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformed_data = Comb_Dataset(csv_file = csv_path, pickle_path = pkl_path, \n",
    "                                transform = ToTensor()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_loader = torch.utils.data.DataLoader(transformed_data, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#weights are initialized from a Normal distribution with mean=0, stdev=0.2\n",
    "def weights_init(m):\n",
    "    classname = m.__class__.__name__\n",
    "    if classname.find('Conv') != -1:\n",
    "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
    "    elif classname.find('BatchNorm') != -1:\n",
    "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
    "        nn.init.constant_(m.bias.data, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#start by creating low resolution image, then progressively get more complex\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Generator, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            # input is Z, going into a convolution\n",
    "            nn.ConvTranspose2d( nz, ngf * 8, kernel_size=4, stride=1, padding=0, bias=False),\n",
    "            nn.BatchNorm2d(ngf * 8),\n",
    "            nn.ReLU(True),\n",
    "            # state size. (ngf*8) x 4 x 4\n",
    "            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf * 4),\n",
    "            nn.ReLU(True),\n",
    "            # state size. (ngf*4) x 8 x 8\n",
    "            nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf * 2),\n",
    "            nn.ReLU(True),\n",
    "            # state size. (ngf*2) x 16 x 16\n",
    "            nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ngf),\n",
    "            nn.ReLU(True),\n",
    "            # state size. (ngf) x 32 x 32\n",
    "            nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n",
    "            nn.Tanh()\n",
    "            # state size. (nc) x 64 x 64\n",
    "        )\n",
    "\n",
    "    def forward(self, input):\n",
    "        return self.main(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            # input is (nc) x 256 x 256\n",
    "            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            # output 256*2\n",
    "            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 2),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            # state size. (ndf*2) x 16 x 16\n",
    "            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 4),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            # state size. (ndf*4) x 8 x 8\n",
    "            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 8),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            # state size. (ndf*8) x 4 x 4\n",
    "            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, input):\n",
    "        return self.main(input)\\\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discriminator(\n",
       "  (main): Sequential(\n",
       "    (0): Conv2d(1, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "    (1): LeakyReLU(negative_slope=0.2, inplace)\n",
       "    (2): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "    (3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (4): LeakyReLU(negative_slope=0.2, inplace)\n",
       "    (5): Conv2d(512, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "    (6): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (7): LeakyReLU(negative_slope=0.2, inplace)\n",
       "    (8): Conv2d(1024, 2048, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "    (9): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (10): LeakyReLU(negative_slope=0.2, inplace)\n",
       "    (11): Conv2d(2048, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)\n",
       "    (12): Sigmoid()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loss functions\n",
    "adversarial_loss = torch.nn.BCELoss()\n",
    "auxiliary_loss = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Initialize generator and discriminator\n",
    "generator = Generator()\n",
    "discriminator = Discriminator()\n",
    "\n",
    "# Initialize weights\n",
    "generator.apply(weights_init)\n",
    "discriminator.apply(weights_init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create batch of latent vectors that we will use to visualize\n",
    "#  the progression of the generator\n",
    "fixed_noise = torch.randn(256, nz, 1, 1)\n",
    "# Establish convention for real and fake labels during training\n",
    "real_label = 1\n",
    "fake_label = 0\n",
    "\n",
    "# Setup Adam optimizers for both G and D\n",
    "optimizerD = optim.Adam(discriminator.parameters(), lr=lr, betas=(beta1, 0.999))\n",
    "optimizerG = optim.Adam(generator.parameters(), lr=lr, betas=(beta1, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Training Loop...\n",
      "[0/5][0/6]\tLoss_D: 0.0429\tLoss_G: 50.3079\tD(x): 0.9609\tD(G(z)): 0.0000 / 0.0000\n",
      "[1/5][0/6]\tLoss_D: 27.6311\tLoss_G: 0.0000\tD(x): 1.0000\tD(G(z)): 1.0000 / 1.0000\n",
      "[2/5][0/6]\tLoss_D: 27.6310\tLoss_G: 0.0000\tD(x): 1.0000\tD(G(z)): 1.0000 / 1.0000\n",
      "[3/5][0/6]\tLoss_D: 27.6311\tLoss_G: 0.0000\tD(x): 1.0000\tD(G(z)): 1.0000 / 1.0000\n",
      "[4/5][0/6]\tLoss_D: 27.6311\tLoss_G: 0.0000\tD(x): 1.0000\tD(G(z)): 1.0000 / 1.0000\n"
     ]
    }
   ],
   "source": [
    "# Training Loop\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "# Lists to keep track of progress\n",
    "img_list = []\n",
    "G_losses = []\n",
    "D_losses = []\n",
    "iters = 0\n",
    "\n",
    "print(\"Starting Training Loop...\")\n",
    "# For each epoch\n",
    "for epoch in range(num_epochs):\n",
    "    # For each batch in the dataloader\n",
    "    for i, data in enumerate(data_loader, 0):\n",
    "\n",
    "        ############################\n",
    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
    "        ###########################\n",
    "        ## Train with all-real batch\n",
    "        discriminator.zero_grad()\n",
    "        # Format batch\n",
    "        real_cpu = data['image'].to(device)\n",
    "        b_size = real_cpu.size(0)\n",
    "        label = torch.full((b_size,), real_label, device=device)\n",
    "        # Forward pass real batch through D\n",
    "        output = discriminator(real_cpu).view(-1)\n",
    "        # Calculate loss on all-real batch\n",
    "        errD_real = adversarial_loss(output, label)\n",
    "        # Calculate gradients for D in backward pass\n",
    "        errD_real.backward()\n",
    "        D_x = output.mean().item()\n",
    "\n",
    "        ## Train with all-fake batch\n",
    "        # Generate batch of latent vectors\n",
    "        noise = torch.randn(b_size, nz, 1, 1, device=device)\n",
    "        # Generate fake image batch with G\n",
    "        fake = generator(noise)\n",
    "        label.fill_(fake_label)\n",
    "        # Classify all fake batch with D\n",
    "        output = discriminator(fake.detach()).view(-1)\n",
    "        # Calculate D's loss on the all-fake batch\n",
    "        errD_fake = adversarial_loss(output, label)\n",
    "        # Calculate the gradients for this batch\n",
    "        errD_fake.backward()\n",
    "        D_G_z1 = output.mean().item()\n",
    "        # Add the gradients from the all-real and all-fake batches\n",
    "        errD = errD_real + errD_fake\n",
    "        # Update D\n",
    "        optimizerD.step()\n",
    "\n",
    "        ############################\n",
    "        # (2) Update G network: maximize log(D(G(z)))\n",
    "        ###########################\n",
    "        generator.zero_grad()\n",
    "        label.fill_(real_label)  # fake labels are real for generator cost\n",
    "        # Since we just updated D, perform another forward pass of all-fake batch through D\n",
    "        output = discriminator(fake).view(-1)\n",
    "        # Calculate G's loss based on this output\n",
    "        errG = adversarial_loss(output, label)\n",
    "        # Calculate gradients for G\n",
    "        errG.backward()\n",
    "        D_G_z2 = output.mean().item()\n",
    "        # Update G\n",
    "        optimizerG.step()\n",
    "\n",
    "        # Output training stats\n",
    "        if i % 50 == 0:\n",
    "            print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n",
    "                  % (epoch, num_epochs, i, len(data_loader),\n",
    "                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n",
    "\n",
    "        # Save Losses for plotting later\n",
    "        G_losses.append(errG.item())\n",
    "        D_losses.append(errD.item())\n",
    "\n",
    "        # Check how the generator is doing by saving G's output on fixed_noise\n",
    "        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(data_loader)-1)):\n",
    "            with torch.no_grad():\n",
    "                fake = generator(fixed_noise).detach().cpu()\n",
    "            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "\n",
    "        iters += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#try rectangular GAN\n",
    "#try convert back to grayscale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the first input should be the dimension of image but is instead the batch size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, data in enumerate(data_loader, 300):\n",
    "    print(data['image'])\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(i) #so there are four tensors..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data['image'].size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data['image'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ToTensor(object):\n",
    "    def __call__(self, sample):\n",
    "        image, label = sample['image'], sample['label']\n",
    "        #transformed_image = torch.from_numpy(image).double()\n",
    "        transformed_image = transforms.ToTensor()\n",
    "        unsqueezed_image = torch.unsqueeze(transformed_image(image),0) #add a dimension with value 1 to represent colour\n",
    "        return {'image': unsqueezed_image} \n",
    "               # 'label': torch.tensor(label)}\n",
    "dataset[img_idx][\"image\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im1 = dataset[1046]['image']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformed_image= transforms.ToTensor()\n",
    "transformed_image(im1).size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im1.mode"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}