rwnn.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kEk1w4jnYmWL"
      },
      "source": [
        "# Modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zNzIm5StYl5l"
      },
      "outputs": [],
      "source": [
        "import time\n",
        "import torch\n",
        "import random\n",
        "import pickle\n",
        "import numpy as np\n",
        "import torch.nn as nn\n",
        "import networkx as nx\n",
        "from tqdm import tqdm\n",
        "from copy import deepcopy\n",
        "import torch.optim as optim\n",
        "from torchvision.datasets import CIFAR10\n",
        "from torchvision.datasets import VOCSegmentation as VOC\n",
        "from torch.utils.data import DataLoader\n",
        "import torch.nn.functional as F\n",
        "from sklearn.metrics import average_precision_score\n",
        "from heapq import heappush, heappop\n",
        "from torchvision import transforms\n",
        "import tensorflow_datasets as tfds\n",
        "import torch.utils.data as data\n",
        "import numpy as np\n",
        "import scipy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dS7sHWN3_PuA"
      },
      "source": [
        "# Setting Seed "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_kzgxOMN_R6y"
      },
      "outputs": [],
      "source": [
        "SEED = 981126\n",
        "\n",
        "random.seed(SEED)\n",
        "np.random.seed(SEED)\n",
        "torch.manual_seed(SEED)\n",
        "torch.cuda.manual_seed(SEED)\n",
        "torch.backends.cudnn.deterministic = True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TNObyZO3Rkct"
      },
      "source": [
        "# This is a debugging notebook for the Randomly Wired Neural Network model\n",
        "\n",
        "\n",
        "1.   Overall architecture of the model\n",
        "2.   Node Operation\n",
        "  *   Seperable Convolution\n",
        "3.   Edge Operation\n",
        "4.   Graph Contsruction\n",
        "5.   Mapping the Graph onto the architectural computation method\n",
        "  *   Make sure all the edges meet at the end\n",
        "  *   Ensure that all the nodes are connected and directed\n",
        "6.   Make unit testing functions to check the architecture works in general\n",
        "7.   Data preprocessing functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eVUM__EtTFen"
      },
      "source": [
        "# Overall Architecture of the model\n",
        "![Screen Shot 2021-11-14 at 1.15.38 AM.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAeAAAAERCAYAAACjGnQpAAABRGlDQ1BJQ0MgUHJvZmlsZQAAKJFjYGASSSwoyGFhYGDIzSspCnJ3UoiIjFJgf8rAzcDLIMrAzsCZmFxc4BgQ4ANUwgCjUcG3awyMIPqyLsismxqz5huuann/9IVb4Lp/OX6Y6lEAV0pqcTKQ/gPEackFRSUMDIwpQLZyeUkBiN0BZIsUAR0FZM8BsdMh7A0gdhKEfQSsJiTIGci+AWQLJGckAs1gfAFk6yQhiacjsaH2ggCPU2peoIJruJG5hQEB55IOSlIrSkC0c35BZVFmekaJgiMwlFIVPPOS9XQUjAyMDBkYQGEOUf1ZDByWjGKnEGLJsxkYjFYABVkRYtmHGBj2CjMwCCKpU68EesuVgeFAXEFiUSLcAYzfWIrTjI0gbJ4iBgbWH///f5ZlYGDfxcDwt+j//99z////u4SBgfkmUG8hAH0hYD797i4LAAAAVmVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAADkoYABwAAABIAAABEoAIABAAAAAEAAAHgoAMABAAAAAEAAAERAAAAAEFTQ0lJAAAAU2NyZWVuc2hvdJ74+KwAAAHWaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjI3MzwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj40ODA8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpVc2VyQ29tbWVudD5TY3JlZW5zaG90PC9leGlmOlVzZXJDb21tZW50PgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KrraIfwAAQABJREFUeAHsnQe8JUWV/wvFAJIkuyNBQIkC6i5JwoASZUZAcMhDEkSQJJKRIQ0DSFYyDCA5Ss7RgKCAuIAC4rBIUJAVXdQ1/K3/73vW0/Tt1ze89+697/a9dT6f925XV3V11anqOnVCnTNTFIQECQMJAwkDCQMJAwkDXcXAu7r6tvSyhIGEgYSBhIGEgYQBw0AiwGkiJAwkDCQMJAwkDIwBBhIBHgOkp1cmDCQMJAwkDCQMJAKc5kDCQMJAwkDCQMLAGGAgEeAxQHp6ZcJAwkDCQMJAwkAiwGkOJAwkDCQMJAwkDIwBBhIBHgOkp1cmDCQMJAwkDCQMJAKc5kDCQMJAwkDCQMLAGGAgEeAxQHp6ZcJAwkDCQMJAwkAiwGkOJAwkDCQMJAwkDIwBBhIBHgOkp1cmDCQMJAwkDCQMJAKc5kDCQMJAwkDCQMLAGGAgEeAxQHp6ZcJAwkDCQMJAwkAiwD08B/7jP/6jh1tXnaZ9+9vfDhdddFF1Gpxa2lMY+MUvfhG23377nmpTakx/YCAR4P4Yx9SLhIGEgYSBhIGKYSAR4IoNWGpuwkDCQMJAwkB/YCAR4P4Yx9SLhIEhGPjrX/9ac6+YrslMib7EwD/+8Y/w//7f/+vLvvVDpxIB7odRTH1IGPgXBt54442wzTbbhPnnnz+cccYZdvf4448PSy65ZFhrrbW6hqdbb701XHDBBV17X3pRLQbuu+++MH78+DD77LOHl19+uTazx1K//vWvwwEHHBAGcYPYtwT4qaee6rFp1l/Nefrpp9vaod/85jfhzTffbGudg1jZfPPNF3bccccAIV5nnXUMBSxuv/vd72xB7hZOrrzyyjBlypRuvS69p4ABxp5N17/927+FRRZZpJDbW8knnnginHjiiYHfQYO+JMDPPvts2GqrrQZtLLvW39NOOy1Mnz69be9DTLbllluGF154oW11DnJFDz74YJh77rnDiiuuaGhgM/rf//3f4TOf+UzX0MIceeihh7r2vvSioRhgHnRzzIe2oLU7EydODI899lhYZZVVWnugj0pVmgDHGAOT7IQTTgjXX3+9LeDPP/98+NznPhdee+21cNlll4X//M//tOH629/+Fh544IFw7LHHhttvv33IEP74xz8O06ZNC+edd1545plnwj//+c+aMvfff3+YOnWqidX+53/+pyavigk4To7mHHfcceGuu+4KEEEAPII3PggATob0vffea+lLL7007L///uHnP/+53f/jH/8YwC3PPffcc+HOO+8MxxxzTHj88cetPJwYz/PH9euvv56lGSue5YgH43jHHXcERJf9DGwO4Ub/67/+K+smordf/epXln777bcNj5751ltvBUR0ZTBjxozwhz/8wfJfffXVrIiLH9/1rv/7vBm7973vfWH11VfPyhQvGJff/va3dru4EeJbQOJRnPdILLhf/Fao5O9//7uJP/09lOUdAP1hLjjQ9z/96U+erPmlbL3+1xSsQKLdOGb8+X4A9LxsshxeeeWVwFxzKYjf57fevPnLX/6SbYJZP0mXQbNyZWPGWs17y8byz3/+c5hrrrlqXsUcZE3yuefrE/1kfS4D5ifrPe+qClSaAB9yyCHhqquuChtssEE488wzw913322TBjHcTDPNFN7znveEd7/73TZJP/GJT4RrrrkmTJgwIXz9618Pu+66azZGcHOTJk0KK620ktWx7LLLho985CPhm9/8ppWh7He+8x3Tqx199NG2U6s3ObNKe/iCjQh9ZcH95Cc/GfbYY4+w2Wabhf/93/8N4G7bbbe1/tKFj370o2HPPfe0zQfpD37wgzbBWdzBL4Rk1VVXDV/4whfCFltsEcAP+GQ3y2ZmzjnnDD/96U+tTgjubLPNZqJm3gFhgOAssMACVB1mnnlm+7NEn/2DIK2wwgrh3HPPtbm23nrr2aKJvhY9HZsWNiDMu+WWWy6AK8p++MMfDv/+7/9eQ6DYLEJM2dQceuihYZlllrF5C8rA56OPPlrD+UCQGaNZZpllCFZZqNmwMgZ8P1wvscQStgFjsaP+L37xi+FrX/ta+PznP2/Ps9Ax3ptuumm45ZZbwoc+9CEr87Of/czGeo011ggLLrhgIA2Bpv3zzjtv+MlPfmKbt8UWW8zew3xjznzsYx+zOZZvHLgYP358OPnkk61/+Q1LvlwVrtuN4x/+8Idh+eWXN7w4seFbA8e///3vDSWMOWtgngA3mjdHHnmkzcPDDjssnHTSSTYPjzrqqCHobVSu3pgxH5deeulw6qmnhgMPPNDa/qUvfcnWZdZW5j8iaODiiy8O88wzj80ZmATmOd/DKaecYoSXelifb7vttqxt4Jd1HZUHtOCcc87J8nr+QgNYWVh44YXj7rvvbu0XxxZldGLXWtQieQ76eKMmY7zhhhvslghw1GT17LjoootGTQhLa8Fg+xTFVVta3HIU0Ykvvvhi1O4taiGyfBHk7PlOXWjhanvV2jFbf0UAs7r1YVqfNIHtnhbquPfee2f5ItZRH3KWFuE1PPiNe+65x56XBMFuiQhEEZJsDLRIW/4PfvADy2c8wPFZZ51l6e9+97uWfuSRR7zKtv5+61vfitoUtLXO4Vamxcn6KKcOUZxQ3GSTTawKEVq7v99++8Wdd945SgJgaeltI+MhAmRzVwurlZckJopbiN///vctLUMnK69FyNL+PO8BxDnEOeaYI2oxtXTZPxFee4cWsXjTTTfZe7U5i5/97GfjaqutZnXwPN8JoEUzvv/9748ixJbWpi1KhZCltcjGWWedNYqzt3xJjqI48EiftMBGbfiiiG7cbrvtInPi05/+dFx//fWtLP8YL+agOLgoSYv1T4t4lt/tC9pAW0cD7caxNsxRG5SsSXyjYjKy9A477BA//vGPZ+lm80acpq1z2hjGgw8+OIqhiVIhZM/7Rb1y9caMOaDNXdRmzarQ5t/G85JLLrG0NmWWlgTNX2H92HDDDaM2eTb+PC+7hqgNYJQ6xcqff/75Vl7ccGT+iVmK2jBGbXIj63tVAG6msiA9rw0GH4dEJlk/igSYDIn9osR5UTupKOMEWyD8AQaQRcBBO7JswfrqV79qC89XvvKVyB8En98bb7zRi3fstxMEWCIaw5m4q5p2iyuJ2m3aPRbPPAFeeeWVGxJgFlEIKoTW4ctf/rLdk1ja7pM/yASY+QcRYoFjEYMIA+JcDE8bbbSRESypSCy91157Wf7mm28eP/WpT9m1RHW2sdltt90szT82juIKsjQbxHHjxmXpH/3oR1af4z7LyF2I67Ey4sKzu5JkRDZazBeIpjjayGYUkFQkilO2awg9Y/uNb3zD0vxj3rKAOtBn6pI1tt1ikXzve99rmw1Jkgwvnieu2fJ4P4utuJ24zz77eFVj8tsOAtxOHDN/YCB8w/zwww/bGOQJDwyI462VeQPeGUc2Rmza6kFZuUZjJumX1St1l1XJuPIe5hUAoyMppa3NpKWqiJKuRXHB8cknn4ysH94uvqGrr77a0lJbREmV7Ntg48HaPnnyZCPeUm9QVSWg0gSYiSXRsQ2IjE4iuzygjADDbTFQ7OokVqshwOzYWRCuuOKKKF1khAD7AikRmXEBVnGX/3WCAPsOFM4qD2uuuaYt7txrBwF2wsJHlDjg/8O0S08kIstQz/xigYETBtZee21bgFiIWGjZHMKRAKeffrqVnTFjhqWZ/wsttJBtCO2G/snwqoZbg/tkPrNY1QO5PDUOGMkFACcB1yx1QWRjQB3SNWePw13RThY92s+GlsUR4JcFlI0uAIGFm11qqaUszXeFNAruGpCo1PokmwFLw+mAD97LNcRvrKEdBLidOJa1sOGItYo5AtEEZ7K/MFS5VAVpBtDKvJEI2Oq4+eab7Zl6/8rKNRoz5iibBYmf4y9/+csoq+zI5tzBpSyelprQ2nH44YfbLThx+ibbE0vDAC2++OJ2LTG05TG3kN4g4QQfVYJKE+DrrrvOcM3EY4fuHzkEWLqzbBwQbTKIPiGlO64hwDIksp0U3AQ7cekesmeZvOzQ2Ik5IHrLcwt+v92/nSDAfBBwYmxc8gD+ZI1otyDAzoFxg41LUQS97777Zo+XccCIVHkPC7AT4O9973v2DB8i41EUQbOT7wSMtQia+QlXAS6kX804VggdG0fmK+Bj49ykSysgUjwPsfPFh/KMAXiUHQRJI34QN7gN5jQgK1jjVhEFukjYMv71zwmmL3jc9gUe8XYZ0C7agXSIBVIGVFkxX0BR5QAy8LM2usRIRn2WhrsF6CubDPrH4gl3nRdHW6Ex/jdaAtxuHLO5QQUgHXqEILJ5hoFgAwUO2eCxZrFpYh40mzegF0Lo62cjdJeVazZmMvS0NrIBhWg60H764Zw891mDUbH4nELULhsHf8S+HYgw84V1nPnvcz0rVKGLShthYbWMcQsGLRpcM/DRgJixFFZ8mvhmWIKFLYDREdZ1HI/AAASLPKwId9lll0DgA34xicd4wQGjFIxRUPKLgJvyHwMU0lUEDHH0QVpfXnrpJesChjLghvOigLgqM5AChxi5cT4PQwcRCMvHYEeLUsBIwq2dyXBLXn0cZg2tBTroAwsSh9lz2jBZPYwbwFjoW8mMsLBulMg0YPnbT4BhCQZn4EKcnRmZ0D+MYrBcxSANYF6KSJqRlqd5RoQ7nH322WbZj1GhFlmrD1wBGMPhdAPjOvCphTRgoMjcxmAHYya+DyyRi4DhFfXlj+25RapbwmOhzPMYhgHSVZuFKgZ8EvsFbdiyarUZs7On2mTZHMMqniNREklbGd6H0RiGNADfprhpM/aifoz2mI/gAZCu0AxzLFHRf+3GsTaqQZti+8YwTgNnGNlxwgPLZwywtHm30w3iaJvOG75rbY5r5kAZquuVazRmsp2xuYjxJWurzwPqZ36xDktXbePPPeYLBqHMKdZdSTXNwI88LOdZdzheh/EW7wV8nrJ+sOZUCiq0WRjSVLg29GNHHHGE6dYwBgLgGBCfwclhLIUxB2IQDUxEFAT3yjWiG8RoG2+8saW5539aXDIxNDs0dmrkwQ0iqu4GdIIDpt2II3faaSfrP5wuOl50Kw4XXnih7ajBH/puuF90cW74oGNIhgu4uRkShzoHjO4R4yL06exk8xwX98EfxllwTegE4XTQEVGOsUB0iV6f3W07Yaw5YHTrcBfMUy2U0ecpnAGiXscTqhBEyg7o6cET9wER4ShL8SjHCqajv/baaw2n4IwxhfMFx+BahN04IMrDQfBNlIE2nSZCLuZhaEVdjAvfB8YugDZtNh/WWmstGy+4FQzMHJhPSD6ci+d7yRswYWuAdMRh3XXXNZ2165fhlBFZY/gI9z59+nQvOma/o+WA241jjJMYG36ZO/wyj1zPin4eHapzls3mDRIa6kOX2wjqlWs0Zki/WF9YK3gHaxoGfgCGhNyDg4eLdcmYSyrdQMslYxjBsq7zPaHnxfCQdQluH2NB1iqkSFWCSougEWEwAbFQLgKE1cUY5DEwbilKWucmbdFiIJkADDaiNXEMpktARIse0wHxIROgm9ApAux9AH8sqGUAXlzv5xa4+XIYvSHuApwAoz+ivnofAcQasSvPMT55gOj6h5m/347rsSbA4IR5Ko5/2N0p4p55m9fV5o0Pqbw4R8lvpP9t1CC5MKwZJ8aHDYJ/b4wnG1qMqhywsh/OONIXnskDizGW8r0CoyXAjfoxEhwXv1vWObdI512ksSHIQ7N5ky87kuuyMUMdwdrKNw+wyYKRyavv6P9woPg9MLch3COd48N5dyfKzqwdSGVBO21ruziCIX1w8YRnIHrlz4GziwDnVhFFc77MRWlCtJ2lzHtmQRTImcx+AvCHuLkMJDHIbrtIMruhC0kfsiT4cqhXH/k6xuLFMvGR30C0iv/ifgTHCedfhwtF3Pu8pR7OYufHgXvFOVrMp0yrIIlGTVFEfIijvQ2MJ+oMcTlZOcThwxnHD3zgA9mzfsG5UP4GAUaC4+J36+uW44t08Z6PGWXK5o0/O9LfsjFDfCxbAXsf9XJGF3Fzfm0u9r/Z+4vfA74DeEdVodIEuB1Ix2mARKKBxRGdFgsMuk+JC+0AeDve0c91oO9Fdwmg59SON0gc1s9dHti+sSFF/4a+WGLuIM7e9Njf/va3BxYn7e54P+FYai7T38qK39ZS7EXQ/0s91W60Vba+gSfAOmdpBg0QETz84MAc7ytlO/PKjnIHGy5xpHmvwh0oABHGQ1KC/sMAUiDGF+NGjGEYZ4xrErQPA/2EY9nnmKElhmFSNdjGDe47wTsYGHgCDCoQYVRZjPHOcHb/CreFuPZMMDgYQD2B5ChB5zDQTziGqUlQjoGOEWBMxjmmkmDkGOAjlGHYyCtITxoGUCsgKk+4TBNiJBjgCB561zR/RoK9aj1D+EZ8UXcNOmHZRZ3uckwdMVPz9JvwkOZAmgNpDqQ50MtzAI9d3YSOccA4ayD6S4KRY0BHV2znPfIa0pNgAO4XwGIyQcJAwkDCQD0MyCtbvayO3J8Jat+RmlOlo8YA3rnwlpRgdBjAShejOvkwHl1F6emEgYSBhIE2YiCZpLURmamqhIGEgYSBhIGEgVYxkAhwq5hK5RIGEgYSBhIGEgbaiIFEgNuIzFRVwkDCQMJAwkDCQKsYSAS4VUylcgkDCQMJA13GgAKgBPlk7/Jb0+u6hYFEgLuF6TF8D+HmFMEpCyeXb0q9PDzXKBZyOOiggyykY/6ZkV7LkXo47bTTSh+vl6dIK+bog5B+cvhe+my6ObYYYOxw53rkkUcG/EWPFqhD0ZQCxnN4p+sH4CwxISIJx6cIUGYQqLi+gbCNW265ZWkXwSshBvN+nQlfqShYQdHLLDxf6YPpZmUwkAhwZYZqZA0lHiwf/dZbb22xePO11MuD+CqkYID4QfiItzx16tT8o8O+VmSpsPzyywdFQhnybL08YtAeeuihFhMUC2YFA7f4z0MqSDfGDAOKImZO9olLe/311wd8GeOEZ6QAET/88MON6+N3m222GWlVPfEch0yI5Uz8XoJUgCPiAyt0oMV5Ji5yPlBCvtEKpWrEmQAXALjGBzfxoeGKOeap4PQWAzr/XLquEAa6eei4Xe8iVB6hArU7HBLnlPBrxBAVwYjEr8yHqSJUm7g6C3926aWXWnxVQncR3ou0/xFLlfB4nlag+XY1fVj1tCMcIaH/CKemKRkVnaTm/fXywBFxlAHwRzxPeYipefapp56ymJw1N/+V0AIz5DbvOuqooywuczGzLI/QkZ///OezotOmTbM+EEN0uDDW4QiH294qlWdMPbSkx3P1eMfejwcffDALXen3+CUUIeE/HQhjKaLrSfuG55577ixdxYvjjz8+6ghcVND4Ic0nhCCxj2+44YYhedxYbrnlakJYEpf7jDPOyMqyBvJdP/DAA9m9dFEtDFSOA1ZwZou4Q1gqwqFpUgZEOYAmYlhppZWC4pFaZKM99tgjbLbZZkEE1rgoBW0OChhu9xS7NijQuT2PgwZCEm677ba2OyW0FuHxCDSgoOghH5qP9+DasCow00wz1XWYXy9PhN9wQR/BjQhh8F249/v555833IHrPMDhIjbTZ5C/Heq9i0JleYohGkQ4szoUdNyu3/ve92b30sXYYwAu1cPLIU7lm+QbzAMSDr7F/JxAtLz++usHIuQ4EC5UBN2T5sifcIfN4PXXXw/aBNQtBrfYzC0uImI4y3YCAV4QO5944om2HhXrJpAFgV+IIFYExdg2zjgfwhI8i5BnRVdddVW7Ti4yM5RU76JK+wW40oUXXjged9xxWbM/85nPxF133dW4Wn38UUQ0y5MTC9shTpkyxe4ddthhloZ7A3CXqcU/6gO2oNEf+9jHbNdpmfo3efLkGg778ssvjzvuuGMUERgSRNyfaedvOzhg2gPnr5k5hANulud9mTRpUvzyl7/syewXLpldugeFhxsiADecTRmcfPLJpRwwZRvlkX/ddddFifBMMkF6OJA44OFga/hlkWDccccd8SMf+Ujcc889swDsXhNSFBHSuNtuuxknTPB2bYZrvmMvyy+coaJrGedIvfUAyY4i7piERpGZ7NuXiDYrTlB67isObVQIxQgHqQ18li/7BnueNWTChAlWLs+BS20TtRm3thNUnveJ6EV5S6rhRLMKCxe0hTn7t7/9rZDzThJpXhlst912UbresqzsHtywGIX4s5/9LLuXLqqFAXallYEf/ehHRkh++tOfDmmzdoGWJ461Jk87yKhdpt0Td2ZlEDsDV155ZU19LNQQKu0+I4uE4gNbOf+HCJc8yiC27jT0AgFG/C49VWQxKwOIMPn77bdfQ+LLs42IbKM8FngWyVtvvbWsCU3vJQLcFEWjKoC6AB+6ECe+jTLC4USYDSzl8pvo4svFOUa+VUmeorjE6N9rvhwEkc0fa4IDhIi56CDjJtu4eZqNNt9Ufi4j4v7FL35hRdjgL7XUUvbt+zMbbbRRls89GZtF5lMzYM5St2wXmhUdko8KDGaiEeF+9dVX44ILLhilMx/yfLpRHQxUSgSNoQeAuKgI+qjsFgZEefjwhz9cWp4yiD7zsP3225u4FrEzVoYYLuVh/PjxAR/XgwL4UCZ49oUXXhi0mJR2G7E9oRxRA1xwwQUdiaOMCA+jMC2GpW1IN8cWA0SQ2XvvvQMiV0SqV1111ZAGoco466yzwjXXXGOGdKh/6gGhDjG+e/TRR00srI3XkKKIuzFqkn1Clvfxj388SN9saeauJDOmbvIC+PnFmA9VlYM22RYDnDRqJ4zI8tb2++67b6bi0rIeMIyijmbAOoRYPC9CLj5z++23W1zl4v1LLrnEYucW1T5ejnjMG2+8sYm3sRZPUF0MVIoA+8f23e9+twbjHJdB70TIsEceeaQm77nnngt8mK0Aul+IMMSXIxASQbfyWF+WYbFhUWWhdJ1e2ZEQFgDuY+mJrphFr52Arh49M9axQHGD1c53pbpGhwGIrCQVpZbq6GE/97nPGWGVqDpIbVSjEy57M+WkFiqtj/If/ehHhzyWDyVXZi8AURvOHMLyXhK3ANGTONziIONXvBmwlqy44op2zKisrLjbIMPCUgLN2V82vmWAvhu7Fonow1e/+tXw9NNPh1tuuaWsaLpXAQxUigAvssgiYZlllgmycrbjLLK2DNJNBs7LYcCBwcZNN90UXnrpJUM9k5PF+4ADDrC0G09h4AP4AXeiDjl85StfsV03QaSLxldepmq/si61JkssNqTp9fIgvhh9sJBIzBdkER5OOumkmuchvhiLsACwoB588MF2VKgeEeZdEPYyKMu77777bKHBAIs2MN477bRT3TrK6k33OosBiUJrzuoyRsWNK98ZBld8n5wrly2FfXtlRBjjPp8jL7/8snGRHKMrAoSZYzmUd4CoSbRtEi82Ax/84AeNaHo+HCnEjU3CcICjPnDvEj0H6bizR9l4wqnn25Bl6mKfffYJMAvFs9Hg44tf/KId7YNpyIOs/AMSBTYfRWAtQ8KAJI6jXpdddpkZrcG5J6goBjTZKwX6KKPERKZr4mjMEUcckRl9oGfSAh0xppK1sxlniJu1/nF8RQTcntPZwijryyhibmkdjK/RC2mC1zXt96MWVdEB6+OP+titn+iz0K851MtDH6vpXPOHsZoWGn80akEyoxYRzuweF26YhY4uD9oYRXEsVqcsQ6MWkyy7LE+bJ9P/FdvB8bLhQtIBDxdjrZdnbnHMhm9q4sSJUZvjIQ9j/KTNW8191wljGOmA3cUcc8xh+k9xgFEbr1hm7+HlMYriWxeXat89+l3mB/pXQITO2oQuGAMwncWNt912mz8eMbJCT8tRIeDee++NOpNr97NCutAGPWpDboZc+fvYnbzrXe+ydubv56/BB+/FOA09Ob+sUflvKV8eI1IMDsuAdan4PZDWaY2y4uleBTBQyXCEcHIcG0K/W7b7g6NFVLPQQgtpfg4fEDfV437RPSH64sjC+9///uFXPownejkcIXp4dGplYj509UgregVSOMLOjgTH9ZgHcG5lIEO+UlErelq4unHjxmWPiTCb2JZvG+lLKzBjxozAN48tQpneFI4TbhqpFpxxO4EjQEjktGltWC3fC3hYYokl6jrewMuVNhEBtVm729mwcSlzzDDQ3tnYpW5o19lwgUesM1LiSxfqEV9ErHxw6IDQFaOTxlvTIEJ+0Sz2v5eIb7FtKd1+DHD2txHUM0SCyBTnEQR06aWXblTdkLwycW2+EKoUP6ucvz/aa1RZ2D7oOGPTquhnsa/Fh9z4KhHfImb6N11JAjxWw4F+KUHCQMJAwgAYQPqGdKVdwCkCbFgSDA4GKmWENTjDknqaMJAwMGgYmDJlSqnx1aDhYZD6mwjwII126mvCQMJAz2LA3a32bANTw9qOgY6JoNGVcn4uwcgxgCEKB/8TjA4DGOyhV0u4HB0e09MJA/2OAQxf5Q2ta93sGAEmAALncxOMDgMJh6PDH09jsQ4BTrgcPS4HsQbO+z777LNmoTyI/R+kPud9QnSj35U8htQNxPTCO3r5GFIv4KfVNqRjSK1iKpUrw4B8RZvTDKyUEyQMtBMDSQfcTmymuhIGEgYSBhIGEgZaxEAiwC0iKhVLGEgYSBhIGEgYaCcGEgFuJzZTXQkDCQMJA2OEARyD4KkPA9hehFaDYNAP7DYGARIBHoRRTn1MGEgY6GsMEBYUd6C4yS1Gi+uFjiu+c5Cfbwvq0qg9ct9sxm64NcWdcL9DIsD9PsKpfwkDCQN9jwH8Ubsf7PXWW6/n+ot1McSV6FmNgDKUxfI8H5e50TNVzuvYMaQqIyW1PWEgYSBhoEoYeOyxx4xwEYKR0xO9BocffnhQVKqw7LLLNmwafv4feOCBQGhJ/CD0OyQC3O8jnPqXMJAw0HUMEN/6hRdesChMxCXfaqutwnnnnRcUAjEQyxh46qmnwo033hjWWmutQEQn4pUT3xwukZjmREVacMEFLf+aa64JREsiXrkHayBy1N133231EG0JINYxRMyBONr333+/BaPYbLPNrD6IG23jGfTFCv1o6RtuuMHaSft4hljftIeoZ3ngvQrnas8SYMLjNSvcosVARnRMX6mXiHG8g/cR+QoCTD4R04gOBdeukJDhhz/8ocVIphx/EF/E0OCAdhJTeZNNNrG+EZv8U5/6lMUe93ZRBj/av/nNb8L48ePDqquuar66XSrg5XrutwIhEwe2icQ3TTB6DKR4wKPH4SDXQNzh7bbbblgo+NnPfhZXWGEFi99LPGB5V7Jr4gED0olaWgQuEtdchMHinJN32mmnWZxh7p144olR0aEsn7S4Q4pYrOM11ljD4icfe+yxUfpfK3Puuedavgye4qRJk6IIWbznnnvi8ssvb/HQ33jjjShiFVdffXUrv/DCC8dvfvObUYTK0sQjJsaziLylFe3N6sv/EwHNnv/85z9vWbfccouVJ046cY9pK30kDru3f+2117ayF198cRbrO/+ur371q1GR7OzZM888M0oMHT/3uc9ZepZZZokKVmH9pW5tCrImXXvttZF88HH55ZdbecrwBx56Gd7ZKqm1CRIGEgYSBhIGRo+Bj3/848alUROOPDbaaKOw5pprGheHY5jDDjssbL755uGss84KIo72wgkTJtgvBlUiGsbB3X777eHWW28Nc801l+XNOuus9gs3+L3vfS+I4IaDDjooi03u+t/JkyeHq666yuqHK4aThuu84447jLMUMbR6MIyCezzggAMsfcUVVxjHTRuAsjCOcMSnn3665cPFwxF7WNbXXnvN+kikKAzCPv3pT1vYVgp726jb47g/+uij4cADDwzrrLNOOPLIIwOhZL3sbLPNFiZOnGhpuGFE0yKwlnY8oC/eYYcdzGr6pJNOMs7XCugfbSF0bE9DL+8OBr1tiQNuzwxIHHB78DiotYyEAwZXioNsXFj+O4Z7FDG1+08++aShVMTR0nDNwNVXX21pEY4o71vxrrvusrT0u/Ef//hHFJG0tMS5Vv7hhx+2tETHlvbyH/rQh+I///lPu6eYyVaG+oDVVlvN0hIRRx35iSuttJKlJb6NElFHiYUtfe+991r54j+5dbV82gTHTlv5oy0SIcclllgiijjaY4rNbnk/+clPLC19dVbe20OGxOV2H7w5bLHFFllZibCjxNqW3nnnna2INjeWph2AjNEszTurAIkD7untUWpcwkDCQBUxgB4THScAl+uA/vKtt94KIoDG+aJrRW8pUXCAawbuvPNO+xXhDnCL6H8BiXuNczzjjDMsjY4VcK5w3XXXtbTHFF5//fXDTDPNFAhGgo4ZkDjc3v/II49YmgAlb775Zvjxj39sZbVZDSK6pm+ed955jRu2goV/cMZwsfhXhwtHjw3wrp122imIKNuxKHxoc4+6PvnJT1oZbRDsd/HFFw/bbLONXfMPfTbg/eA8sMTndm/atGlhnnnmCeipAfTZAPpqifrNaIvn4aJnn3124/6tQI//SwS4xwcoNS9hIGGgehhA1AtI/1kTxAGRKyB9pf26KBdiiXES4AR4jz32MKKICBqAAItLDk888YSlEWljmHXRRRdZGuOjl19+OYiztrRbQ19//fWWlt7XjKAgahC3BRZYwMTFnBsWt2hEFCOpm2++2cpD5DAgKwMIu4vF99133yyO8T777GNW2IjcASeqn/3sZ63df/jDH0wMTh6bi7zBmJdFVH3fffcFcAWB53zzrrvuGjAo+93vfmdiccTb1CWJgIm52VjwjHTm4cUXX6wRRfOuXoVEgHt1ZFK7EgYSBgwDnAllcUU/CYFxgHvsVbjtttusaTIyqmkihA9APynjp8xphkTFRmSw9qWPWO9CAOEe/ews+mCIi9cBF7vLLrvYmVnqhDvkONIiiyxCMsw///yBqHTonOFY4cQhnL45IP4wFtXuuMPjETt3DHE7//zzra6yf1g4w9XuuOOOmaU03Ohxxx2XFYdoArwXXTU6W6yrgTxu6BNcOPDggw+avtc3IhBkjld5u5Zccsnw9a9/PYAzOHgZbBle0Pcus8wyZlVtFVXgXyLAFRik1MRqYQDCgIgRkRnGLr5wjKYXnahzNO3pxrMcdQGPiCTh2nBPeMQRR9hRmYMPPjhgdNOLwDEf3xy4qNTbCbHCgOiyyy6z4zaIVgHpR43YsdEA4JAxkOIPThWDJOLUYpREHcAhhxwSZJ1tomyMlxBhwyUjhkU0C344IoTRFMRtueWWs+ec08ToC/eQEDyAZwGOBUEw4cjhKOsBImgINFwsImZE5ojL/ZgUz0mfa48///zzdjRJVtHGtdI+iGUeKAu3y6aBcXYcbrzxxlYMrheACyYforziiiva+9m0cNYYDn7TTTe1I11WuNf/VUFRPahtzBtvdAoHHB/g6AJ/+++/f8RIJA/SV8VzzjknHnrooVF+ZvNZw7rG0MPfw++UKVOGPC9xV9TuOXKsop3QTSOsn/70p1FcgRnPiOOI4kIixjCjgU7UOZr2dPpZDIe0mEZxNPHkk0/ODIn8vbIgjlpX7YiO3+vk70iNsOq1SRxtxKAIwKhKXG+9onZfYuaoM8I1ZfhW3MhJHqOi9Lg1+ST4Xnl2uEC9xXWgrA4R1ew25THMKgJjKR138XZpmj6y3jQCjlA5YNSF8ZWkAFEW4ZEjXswL/rQR8GI9/YvsP0GPYqDTBFhiMDtPh4UkfzoWUYMJGYzY2UHO3+moQU3ecBMQcQiRv+vCCy/MqsDqko+I85JYSLYbukmAp06dGuVEIesCGxcWhOJCKAcDWZniBQuWdvnZ7VbrzB6o+IW4QjsHW88CF4IFTsXVdaWn7SbAXWn0ALzEvy02qA7Si9vccItrv9+rv5UkwBwml6cV45QksqnBLUQFU3QWLekQagiH9ClRRg9mZg9xOfvss21nyeFx0v7HYsnO1NOyZqx5R7cSnSbAEuNF6Y1Ku8PxAA73s7MsA53/i4xDGUjEVXNb+h075lB2KJ4dskRG5qigLL+mohEmukmAi01kU6MzjsXbkYVCZy+H3Icwc4SiOK/zBevVmS+Tv2Z+NwPGgXFqBpQb7Was0TukHzQnEHvttVejYnbEh2+0G5AIcDewPPx3sNZLLB0XXXTRuPvuu0edjY44Fslv7odfa3efqBwBlssy86yCiEF6FNvtIKYCpDOwxYsdtAwN7Cya9Bx2zo0Fzc+jSadgXmJkmBBXXnllI7aIPtlV6wB7tsDgyYWFEhGPAwsQ4tRuQCcJMF5mOI8ofVSUkYPhzvtEHucAOXMHkS0TLUG4pXMaIl46+uijI2cJwZODrDANt3j8gdNFBOcgAxDLk4FJlB4nE6t5fjt+x4IA03/3+OPnPfN9YZOHqDpPhJ34soEsg2Z1Fp9hkyo9W+R8KJ6DODuJ56U8gHMZ3xhBoyybIemssyIQObwmyWI1IvqV60Hz8MQmwMWebFCZC3g8ok9+n7pYIKm33kYve9G/LmQNHKVbNG9Nxbx8upscTiLAecz31jXfBKJ2zhAzD7u1KWsXFipFgEEuOxyIpYO8vESZqBtXy06IhcIBERVE1fWNrjuCewMgFjI2MH0Hu38WKhkq+ONGjJ0TYddPPbhm450QmYceeigr24mLThJguE0O9O+9996Rw/jgQZ5zrBsyrDC86ZyeLaq4h5Nhx5DJLQtEwxc7UeCoo46yDUuRk+UDQdqgowlWL3pR1wtB/BkjnSPMxOE4EmgnjAUBhtAxV+kbeio2NUWAUCF2hwg3I74820qd/g70zxAz1+Xx/uOPPz7i9MGBccJFIhsFBxwpQDDlv9dvmb6SfnzjG9/INqO4DdQxmawM9dPf4mYN94N5gp49UHLB960znDYXSrLH7FYiwGOG+r5/caUIsHtKycv8fYRYMFgkMPDJA15V2MED7n/VDRquvPJKe8brY6GmDsRgcL3s5h2oFzGHg9ynGQfZSXEcnEk3gJ0jhABcAWwyMIBxzh+/rOBF1pJDmgMRxiPPfvvtV0p8iw9g9IVoW0cSLItF2/vJuCCdgEjkOehiHcNNo8PGR2y3AYICcQV3qDPKACIM98gmZ3odzjf/XCt1Up7NZF6P7HXg99eBTRGGd0VAYuE+i8mDiBc3g2yqiqJ1xvSEE07IqoPzlyvCLN3sQudbDVdl/ofzz+YlKPn7nbqWM4mos66dqj7VO8AYqNQxJHyZAvguLYIWMrulXX1NFlE1yspTCFP7PGy//fZm7i9iG+QOziKXeD4m73iwceAQPGm82HQKvL+dqt/rlWGURTGZIW85WuDtNofs8SgDcNSBowV+Ls9u/usfh+nxaHPKKacEEbqmvlflXN18worjy6oREbZrjmfI9ZzhFIcD7QKOr3D+sNvAMQ2OmXAeE+9CZcC8ZR5RRkStrEjNvVbq5BvgjCbHoIrgPnu5j5MF5nERJI0I4oRrbrvvXb/JmUutm560X3HFQUQ9m0NEx8FJQ6uAv1++STnWr/sIR3w4LlN8d90H2pChzaAdfWlDVamKhIEaDFSKAEtfa433g+PeE7zJyJepOfIunrlkoed8XCsAwYEIQ3w5vC59cPaYdF6ZyzduEkYMJ+r9ErMSIiwrZSO0HHSX7tecrNNXziByFrG4YSFPYklzBMDCy8IocTS3G4JUBUH6eCvDu/IbJD/r17CCCmWCMzZvEusOaTVnI3GUL9G9hXfDAxFnGZtBozp5lvGCQEk607Aq2iTx6pAyuA/0TdGQzAY3IKA43+f7EddsRJygAa0CmxC+VUmk6j7CRk9RfkrnYt2HUkZTDOBVKsEYYKBq3D/6KUJlob/F2na33XbLdLzofwlLJc7RuoWuV4uVhcTiBla/QnEmWkWsTDqvo+IZ7il4dF3UYCGMwQliuE5CUezXznchVswbB6HPQ8cHIBaVA4BImC+AM4vgpCiC5qwmYkgX6SOOZnyKIkJEiy4OxSIXUTf3AETDGMO5uBs1AMZyfsbRCo3yXzd1wOgLMQZ0ETrh2Dh+5ec+vStlOl8M3ggbB17z0Gqd+WfQ7fOHyNoBVQPh3VzlggEWTvN9LCiHbh7VC0ZxDswVjBHzgN7fw8vl71OXYrXaN+nGkZ6P8SLvR3/s+PE8/8UOARUFRpR5oB+E5kP1023oZR0wtit8r/yV2RnwbYJ3/vwbK+KP9ZL1rJPAuzlWxvfOaRQHt7Hx9KD9VkoHzOCwaKyyyipGELCqlUeU7PgE+lg5Ajf9F8cYsHAmsgjAQrjIIovYc3IAHuVlx4gFhEWedjLLTcpiYKXQV1wOASxLIc5MKA7Dl036IQ+N8EYnCTCW4mxOMH7aYIMNzMgqr89GD8iZXTY68ilr+vN8NzDygfgq8Hj+dnTDrPyRFvrBxkhByW0h53iYA+UwLiI6C0ZyGMHVO/rkzwz3t5sEGOLCnIKIyQuS6bchtkWQB59Sna8TYXTlDq3W6eX5hWBhcY5+3vEuaUPEwC4PbD4VvNzmAFbLfCP5Mjg+YHHGWp7vBmCe8A1yj/lRBAgzVtfiqmqyIORs7MBPGU68sKRLdrSE94njNaLLPGXOjQX0MgFmHSOmrrxR2Tfmxo2OJxgUvj1sOpiPZRsfDCzz1vjUgc4bY1OeZyOe/5697lZ+OdfP/GIthgHCHoM1mjUUmwE2ZIMMlSPADBaTQT5Ra3b3+UGEy8o7Q8jntXLNIlgGWPlKzGom7xyHwmCoqgSY/nEUBm829T4uHGSw+BStmnm20ZEhxqYIcF/FxSFfBg84GLvUa0u+7HCvu0mAaRvcIaHl4DrqQaN5w3N5zrXVOsveBQeE8SIh4hrhFkLLYt5OyUNZe9i4EjidudUMmEeK7BM5ctTpdjVqSy8TYNrN2EkVZhsbuacc0hU2VvUYCggyG23C+gFIqtiocRKBMUISwUZr8uTJlt/qP+rtJW9mrba72+UqSYC7jSTex+6bnXv+DwveTkInOeBOtrvX6u42Ae61/vdSe+CsOP5WJeh1Aow/BPl9NotzzvYXN3dwn/VAPrZN+uT5iPmxys9vHqVzt3Uv73rSy9f77TVvZvXaOdb3K2WEJeI3ZiAxKZuVmr9uWSmPWafTixMG2owBothI/NjmWge7OnG3QWqzIP24WdRzisMBI1QCH9QDeY0KctCSZWM9ryOdFijCb3roRIJjtAKSDgapk4KOsgWpqUofkVrDAjUQRnCQIRHgQR791PeEgS5jAEv7BO3FAPF/iQpE1CAs27EUdwt4J85lb+T4m0TNNWEB5evAwh8SVciB42ocQ3RC7Pfr/WLVD7PChqARYC3PsbpBhkSAB3n0U98TBhIGKo0BnTgIclxjIfk4noaEQfYZFjuZjjUiwMRXJiQhx9YcIIj5TZJsB8L06dOD3NLW3PfyxV/ZGQQ4YDk/ChxLawSylm+UPRB5iQAPxDCnTiYMJAz0IwaI5Yv42UGW4+abgDi+cKEyfsxi8noZ/0X8LItkTw75xUkMjnOIQXzGGWcMyS+7gfhaOmiLDVyW7/da8RfgZfv5NxHgfh7d1LeEgYSBvsZAkcN9z3veY97H5M/ARNE4uikDPM3JIt041bJ8GWEZdwzxhVMGIOjNoFe9mTVr91jlJwI8VphP700YSBhIGBglBtD/rrDCCjW1IC7G+xpuR/Pccb5QI+4Xd586W2zGcvLtbeJtnQIJt912W76K0uvkzawULXVvJgJcFzUpI2EgYSBhoHcxoKAx5jdbTjhqGolLXYypADlFqckjAYFVIBpzu1vM1Plzc/WJHhn3lBhU4W4W17xw0/KxYMZecnRUlyM+9NBDzbir6Dse/bCCgQRFzLLNQfHdg5ieeRA7nfqcMJAwkDBQZQwgGlY41ABRwwc7vunzAIEkAAh+14sg5yZB3u1KjaoIHuK+9vM+uRWtK+AvXs57gjzVhVtvvTUQfKPMdzvcM8eZOLqJb3D5M7AAK3IIY1y1InAVmzSw6Zkk128u2B9Y9Ixtx/lIFNN4bBvRB29n9070nh122KEPepO60G0MyEtUmDp1apAP+G6/uiPvU1xus2qWh6wR1Y+RFcZZEHh0zo0AXwnom9ENE2hDfr4bFR+4vMQBD9yQpw4nDCQMDCoGEC3D2XJmeKQg//vhK1/5SlPiS/3yLW5/I31Xvz+XCHC/j3DqX8JAwkDCwL8wcPHFF1uc82acayOEcdY4f1a4UdmU1xgDtdr7xmVTbsJAwkDCQMJAhTGAHlZRskbVg0R8R4W+mocTB1yDjpRIGEgYSBjoXwzcfPPN/du5CvYsccAVHLTU5ISBhIGEgYSB6mOgY1bQCrwcOLydYOQY4Mwd5vwJRocBd0w/Gr3X6FqQnq4yBhTb1oIbcBQnQX9jgCNS3YzW1TEC3N/D1J3epWNI7cFzOobUHjwOai39dgxpUMexF/udRNC9OCqpTQkDCQMJAwkDfY+BRID7fohTBxMGEgYSBhIGehEDiQD34qikNiUMNMHAn//85/CTn/wkvP76601Kdj8b94hE02kF/vSnP9X1KdzK86nMOxgA77/85S8DIQF7Ed5+++2WmjWc+dNShT1cKBHgHh6c1LSEgSIGfv3rX4ePfexj5loTGwF88/YS4NkW37+4Hmy2OcAj03zzzRdG6hKxl/o91m3Zdtttzc0jvpndl/NYtyn//mOOOSbMMccc4dJLL83fHnI9nPkz5OEK3kgEuIKDlpo8uBhYaKGFwnHHHWcIWHjhhcNSSy3VU8hgAf3rX/9qQdmJN9sIZpppJouu88orrzQqlvJawMD06dMz15DrrbdeC090twhzgrnx6quvNnzxcOZPw4oqkpkccVRkoFIzEwYcAz/84Q/tshcXWkLjESSekHcf/vCHvcmlv8Sxffrpp0sj9pQ+kG7WxcBjjz1mGx/iACMZ6TU4/PDD7XjPsssu27Bpw5k/DSuqSGYiwBUZqNTM3sUAolaivvzqV78yLmTuuecOEEnOFBL9hXPId999d3j88cfD+uuvHwiijpP6z3zmM+G5554LcIDPPPNM2GSTTSz4OWK6T33qU+Gzn/1s1unf/e534brrrjPR8x133GH38wQY/RrRaViIiTqz2WabhXe/+90We/XFF18M/KFv5YzjLbfcEn7+85+HfffdNxD/9aqrrrLf3XbbLXufXyDiRtdMm7faaisjqq+99pqFwps0aVL4/ve/b3l77LFHeOmll6zeF154wcqBB64JAACh5fnzzjvP2gBHRB46y80339xE0aRpJ/igvocfftjiyu60004Bzt8B3BISb+aZZ7aoPIsvvrjhjf72CqCjL+v71ltvbSoE2vnUU09ZGMG11lorzJgxw8aHEH5wieCSubHgggsG8q+55hpTNxAEgX4DPq+ox6UIzKl8fGBcT95///1hzjnntDlBfWyOaBvPoC/+0pe+ZOkbbrjBxggVB88Qb5j2oCbIA+9lLvPsuHHjwoYbbmjZp556athnn31M9cA4Uy9+DCjH+377298GCHC974UwhpTjj80baoxWvw/6QpjF3/zmN2H8+PFh1VVXtfnf82f/xfIn6FEMSJfWoy2rVrO+9a1vRYnoOtZoObiPs802G2E9oxaRqAXSrh988MGooOZxjTXWiHPNNVfcc889oxYEyzvppJOiwrpFhXWz9CyzzBLlvCZKT2ZpLXpZe7WIRnE2UUQ57rrrrpavRTa++eabVkbh3qKIUPzCF74QtQhZvkIvWp7itsb555/f7ilIe1x33XWjRL+WPvPMM6NivNo1bec9RVBQ9ahF28poY2DZkydPjhMmTLBrxXu1vGeffTaedtppUc4qsrppl7hcS3/iE5+IEpfbNX1QDFu7pi1akKMW+7jEEkvYPemE4zbbbBPBCe0S0cmateOOO9o9BYmPWuDtmjIKsZeVafeFNitxu+22G1a19frOHACkE7W2i8BFERq7XmWVVSwPPDK+9OvEE0+MSy+9dNZPSResjM8r5suxxx4btdGzMueee67la0MWtUGKImTxnnvuicsvv3zUpi++8cYbUcQqrr766lZeaoz4zW9+M5uX0iXXzOGvfe1rVl/+H+PlzzOOgDZ1Vp+cB0URYrumj9qgZe1fe+21rWy970XxhWvmT6vfx7XXXmtzhe/s8ssvt3eDO/7AQy8DcvkEPYqBRIDbMzCdJsCy2oziMOyDVwD0eOihh8Z11lnHiK+4F7svLjNKJ5oRP+3srXPnnHOO5UNAWeR9IWOxBMRVx9lnnz3OO++8Ubv7eNttt1n5lVZayfJZUOeZZx77E4dr72ThgdD74uOE75Of/GRkAReHY3UssMACUdxT1nYITRkcfPDBVv6ggw6Kik9tfZCY04qefPLJtmiK44viprMNhDhbyxf3as9CTPfbb7+45pprGkFgY0A7IcwO4t7s3nLLLRevuOKK6MRW0XesiDg0y2fTIO9U8YQTTrA0mwre3ykYCQGmLfX6znyk7+L8rckbbLCBpSGkABsrNibi6G0eMQfYwPHMo48+amUgZqSvvPLKyPzzjZskCJbPZox8+X62tKQllv7Od75jaYmELQ2uJQmxOUt53inHNZENHOmjjjrKyhf/iQO2fOatOOq45JJLWlqcfKQN1MOcB7wu2S5Yut73ImlL1g+fP82+Dwi+b37BDe+n3fxJUmPv6+V/iQD38OgkAtyewek0AZbYN/voFbQ9a/Rll11m9yGAEIyHHnrI0ixWDltssUX2rER0GVe38847WxGJki1fMVgtDRFjcTnssMMs7Vwg3AMAgSQfDgoCLPFvVv9ee+1li6MvUHC0EmdbPgSeNpYBXBXPwLmuvPLKdg1nBUAEWcABOGjKLbbYYpbmH9fcK85l78eBBx5oZXVsKeN4JXqPEnPapoNnaSMAMfB2kIbrJV3GpZHfLhgpAS7rO9yjE1OJ9a2JLmGAawauvvpq6xd9Yz7dddddlkYKwiaHzQl5EudaeYnqLc3GCvDyilqUjalLOnx+rrbaavaMRMQR3LOho06Jb42gSn1gaak1rM7iv9///veWT5vg2HmWP9oiEbJJM6RmsMekPrA8qTIsXe97KZs/zb4PeSnL2kHlSLpoB++sAiQC3MOjVFy0eripPd20ThNgdvZ89HAD7O4dpIey+6eccordQtxIOScYLKYsYNybNm2aLa4QQtJwiHniidiQ8tK5Wb6LIuFiKQ9nDMCRkoboA4i1SbPov/XWW5l4EM4HgutcJsS1HiDiow64fMSaXMNhS68bl1lmmQjnAhx99NGWJ12ypeFiKMsfG4M8SE9t932B940AnBPSAenMLZ92w2EBLNwf+MAHIhzj+eefb1wiGwLEsZ2EkRDgen338YEAAvfdd5/1E1GwA5svcMb3zxj5JsvVCk48EfUCbL4oL725pRFzk/by0idbmnvSx0aIJ3gmLd2yzTM4bv6QiNx+++2Wx1xkzpUB7fI62Ai4pIfNA9fMX8AJZH6DV+97Kc6fZt8H9dMO1BzMCzYeSKCQGMlOgOyeh3QMSbMwQcLAaDDgRlGcxXQDGAxVnnjiCatWuqkg4pedgcQQC0MUiczMSApDLRHAIA4gYGyFwQznOUVk7XkRdjNIwVgKYxMtNmbEhaEOhi2AFmv7xVALkL7Xfr1tGEBRL4Y2+XwRbktzFleExq6L/zCmArQgBhEQez/9k/7ajKq0ibB8DM0AjMNEWIK/WzrMrH3kYyiDYc6ss84atBEwwzEvC27oO4ZiwMSJE81AjWsR4wAuJJ43PEjHbsZYnC/tNfD+FPvOmAPMCeD000+3X58TJKR3t3sYookoBhEzS0vfGsQlZ/NK4nwzzLrooossH+MjDN4wmAPcGvr666+3tPS2ZgQlnXDQRjFo82aGf5wbFqUyYy+MpDxkIYZ8GM+VAe1iPACM+cRh2zVGWLxX0glL+5zAoJDvQZulbF7kvxcKe1mfP5I9NfEAAEAASURBVM2+D+piTsoOIUiVYXNOOnMz5MMIqwqQCHAVRim1sWcxwCKAtSiAFacDC5wDxAZrUomE7RYLrDiFbKFlwYGIPfLII5YvEXWQ3jPzJoVF7Y033hgkrrV8zv+yOGPhKf2XWXtKD2yW11gIsyCRTxtYbAHaBnHHapnFk8VVujoj4OJkjDBD3MvAI3JJF2wbAXEzVuyQQw4J4sbsmneJy7VrCCObByfuebxQwIkQVq5sPGiPuBd7FstqgM0IQJ5E4HZNnyBAMvgyK1mIBTjoRajXd58XWJLL+ClzmiFOznCBNTxElH4xRjhe8bOz4kxtzLwO5ssuu+xiZ67BAZsrrODZoAAyvrNz1gQjYfNFdDrw6ZsD6YnNotodd5AGfB5C3CRpsHtl/5gXsisIkqJkltIcLfNz6jyTH0fZENhRqXrfS3H++Eak3vcBzqTTDjImNLywMZVEJviGsazNPXev53n0AW5gEkG3Z/A7KYIWx2niOte/5VuM9a4+eBMzY0CEFTO6WXSxAAZJ5J999tmWdgtmdIcYuWCM45bBiGwR1/I8VrNaJO0ZdHoYoWC9Ks4xIubGMAWgjL8fnSoGOKTd2hYjFXSAiOwQjdYDLFmxonVRMPMSK+Q8IC5EFIk1LuJsjKLcitl1nV5eHrCsH4jPMSLCuIx20TeMygAM0kQszErc+zNlyhQrR1n+sLg+44wzvNqO/Q5XBI3us17fURWI8zfxLWOF6oG+IEal7/SHNEZ8AGoD8MQY+xgh4qcM6gtxtzY24MKNnNDBMh8ZZ3S6iKzd6I86EXfzPKJmLI1RJ5BGVA24pfzGG2+czSXLKPyjHuYpcPzxx5vI3A3/vKgbezFntOGL9b6X4vwh3ez74B2oJZg3tN//dJwvM0D0dvTqb9IB9+rIqF2dJsB8fBhQYAiD/iQPLLZ8oFigskiO1soUfSGLNgtOfjHgnSw8Ojdolpg635lvRluuO0mAmzVQHE10YxQWU50XbvgIut48sKDl8YVeGGKaB8YK/DqBzOc1u0Z/22xssd6GSDrk2+P3+MUKmz62AhgjscjWA3BGGYepU6fa8S7mIjppPwYD4XEC7WXb/TtcAtzs/eJoIwZ3ADhgjjQCxgjc5oHx9nnF+PiRtHwZ9NCun8/fb3ZdxH298s8//3yWxVihWy4COtr83Cnm59OtzJ/894FRF5sQSQEi64brviHE6LarAIkA9/AodZIAQ3zhathpuxWmH4NgUeDdnEFkocBQB2vckYLEkWY8xM4aDgmDCemDrDosPzmnysfEQgfHh5VnO2EsCXA7+zHIdcHd56UMLOpwyHmL607hp90EuFPtHLR6Oe4HsUWi4uBcs1tc+/1e/a2kDhhdFroJ7YrNY4sGIQN9mOEiGSWgh0CvJGKS5aFbkYjHPMjoiEjQGbOAfk07vkDa/7STM/2Zp2fIS02/wXT5jkXPiPck9EyyJg3oigB0bJrAQUcATI+EJyLXJToeMM5gHMqgWBZdF7opxoPniJTDGAEYDaHTxPOTLHfNeKP4vBVM/wYaA9ocBvSmsrANsvq1eYKhDd6PEgwmBsTxmsEeHuTwEIYhocTc4cILL7T1pApYqRwBxj0d1n9Y4C266KJBHFzQMQ/DNYYfOs9mhiUYB2C0gSGDRFRGqDEYkf7N7mHph1ELz+PaDSKEVR6WeNKJmWELg4kBiBud+IC2GmrNy/firzhc6y9to/9YWLpBC0YcWOZidIO1K0YaWLzmQeInw51b4XoeUU9YLLXj9FtWDxaXgDjcIM7b6ieNwRHEHgtfjJTYEBTfRbkEg40BNoNsrtkkTp48OWCQhDEPhlgJBhMDuNWEWWDDzpzAQh93sBiFVQZ6lTUvaxeiURT/bmxAGbznYPSB/ksE2YxR/Fl3SoDxBoDzAg2MnXUjzbkzxFjoL2RZaCIuzkc6aFDtnJ6n0WEi9sAjEIp+HCt0Ejopgi62m/OdGIU44IEG3DhOi3pHymHUA77c4wyOEhABFQ0xvE5+0ddhoML5R4B6cajAuxhbjJXaDUkE3W6MDlZ9SQQ9WOPdzd5WSgfsnlLyMn9HFgfMIa7uC9XvoyPCYANw/6tu0IBBB894fSzUpPFLi2EDrvscOFCOwYcf+scSsdMEEr/C3QBc3WHBmjfk4BodMfpa/BIXHSl4uyDCPOtuBhsRX57BzR065TxoB5t5PcLFXrM68s+2ci2RVNv1yq28N5XpDwzg59qdp/RHj1IvegUDlRJBE3EGKDuvKIJheYgx80BUjbLylBHXlS8att9+eztXidiZc5pELnGQAYgdiPdD/4hguddJQJzSaUBHTtQS9CZ+fg6xM7o2SQzsbKc4VhNRc+6uCIjtcY6AGkBel8xJQ7GMpznjKAOrTNfMfc7+ITJCN4xeX1IFE1n7M+34Rc+PGiJBwsBIMMC8l5RsJI+mZxIGGmKgUgQYQyHAD457z/Amg+5XHGp2iNzzdGTCwrN5utEvul+IMMTXdU1eHmJNqC8d27GQchB6DoBXGbQLDHvvvbfpwsEfIOvogCMFiCV6YTz5oC/HGQC62iJILG/P6CyrlcdQpgzQ30l8b2MHQefdkkQY0UUfjdMAueAz4ovTiQQJAwkDCQP9joFKEWCMg/B0ggUvxj4o3/EwhNUyizqGGlhF4qIPgKvCSOiAAw6wNAs+4J5k8GIEYAXtgDUdRlYYBxWNryhDvg6dm5EW1pgQkqoCxBcPOWw88FhDHFqFyQvS+wZ2/RLNW9c8Hqi7HPT+QnwxhMFtIB6NMNrC5VyRCOssorm8Y3OD5IBneLd0a/YuYos68K7iezwv/SYMJAwkDPQVBnpFFt5qO3BEgIcXDYJ5BDpCUWIwoAIw6CEEGOcF8TaEo3acgwN48xEBt+eINYoHFxzJUw/nU/P6T7zHcHY1Dzgpz99z/bF7gsmXbdd1J3XMeNWh7/k/DKH8cP2RRx5pul0MzzDQwtNNHuTWzs4QF504uGGWjwnP+Hjl3+Vh6HDcQPQbuZszRx3EF223M45BMcLCPoF5jPMFHCDkASNFbB8wgsO+ocyoLl++0TXP45WL2Ks6PZAVdcO67EafXFTJCIvIRswB/txRR34YmCPMAeZC8dvNl2vHNZ61cIiBQx+366BdbnPTjndUvY5KGWE5slncdUSoricdJpi7VfNnhvPr7vDyz4iLNstnv0eEGwgWBkydgk4S4FbazKLtBLlYno1Q2QdOOcZmuADRwENQJ2AQCDAEl82nh36TPr0GlcRmJY85i0vMonvImsJ1Erj9I8ITG1tiBBNpiXduueWWdjJAx8fqPFnt21UiwGyM5QvcNtYK8FCDeNZEj6REOEkMIlsBTp/gInPChAlRZ20j35N78ip7nhMUkqJZWfkAsGdlU2K/hD2UD4CyxwbyXiUJ8FiMFJ53CHKN60a4QayrO+2HdqwJ8FjguRPvHAQC7HjjGBiezZAC5aUQ5ONhTGfjvWjLvxB3fPpiEY/kpMhd+/E+PKf1I1SJAIN/whRCYJE4ucc5Hxc2zRBHOOVWAYkh44+0CiLOukTozeKGGTeRSLOIPcyJlTywmefIIm0ayQY9X1c/XVdKB6zBGzPAkYR80AZNxqCjMhZaC08sCRIGegUDWHsDRJ3B+LBozIaeH6v14cIJJ5xgzlWwryD0HAaJefDTAoTDSzD2GMAhkVRk5mCHscsDpw5wTuQRrvJ5ZdecPJEYOSgwg9mLSIpi80sBH8wWx5/h5ATRlERcbW10g1nPx8kPNjqELZQq0G8P/G8iwMOcAoR9I96lH0ca5uOpeMJAxzBAKEK8vRGijiNlxcUXK3ZxL8N6P3VyHI3NJl7jygBLeUmELCZrWX661z0MiDu0Y5eEpCQGNCc6IIoOEOfhbJTYbPHn4RWpx2MZ540nCU3JBg8DWQw7y4B4xMN5d1kd/XYvEeB+G9HUn4HFgC+uxEWFYLIgyqDN8CHjF1sYcTs6HJB3M9RUWSzies+y0BNXOMHYYoB4ybh6BfD1LjWEnWzwVnHOHle+rQJ+2vFHwIkHB06XAL4hk2ja3EBCmCGy9YB2ySthveyBvJ8I8EAOe+p0P2KA412+AHJEjqN5zgUPd+EFPyzecMDUqRjEDVFGMI0EY48B34TREsWQtqAVONlhAyY9rB2xrMeh1ms9Y6+Yu5bNnNDJExMlK2az3WPeyS4g6LREvSrsPsc6IegJ3sFAIsDv4CJdJQxUFgPof+FU4X4BFjuiWN166612Hj6/MLfaSbl3NScrzcTWxXPfrdafyrUfAzjRyYt5CTjD3JAhYnj00UfNYdFo3srGDr0wQVPwHwCwSQNQzTUCnPkkqMVAIsC1+EiphIFKYsD1v/nGy3+xcS6yTrZwkMPlUuF80P/BSdcDuCo8pkH8E4wtBlz/i/tdB8TNOodvBBg9bp44e5lWf4lyhh3BI488YhwwhlfAuHHj7LeRYZf8MJghnxVM/zIMJAKcoSJdJAxUFwNlHC4WpwroEeQcxbiV4ep/cQ+KGNM9opVhBx/giB6LltFlZdO9zmIAiYXrf/NvwhMgsbvZiA1H/5uvg9jpbPLuv//+QBhAfGPjQx7A+x1Qb57gaRAdMhb0CWoxkAhwLT5SKmGgchhggZNXqkAM7CKw+KKf4+hcEQhQwfESYmTX42Dx333XXXeFO++8s+ZxdIFysmBuYOG0E4w9BtD1ysPckIYgocC17oorrjjk9EYrc0COMwJjjASFmLsYUuEC2IPR8CtnLHYft7N5kFMj86+PJT2xwBPUYmDm2mRKJQwkDFQJA+j2pk2bZoSQYCGXXHJJWGGFFbIusOiyAG+wwQbZPb8g8AZW0uiJ0e199KMf9azsFw4a0SILLkdb0AcTWAMLaxbd/fffPyubLsYGA3KTa0eOsFbGjzoRzthUOWBAxUbql7/8pd/KfpvNAfy1EySFTZzip2fPcYFvd4fLLrssKCSpzQ/O+37oQx+ygC60CUPAss2hPzvIvzNp55uUNz06AzBq4OB8gtFhgMhWGCftsMMOo6uoD59mAZYLSTOqwVlCI8D4hmMu6IYRTb/3ve9tVLxv8hQLPEydOtU2N33TqVxHhjMHco+VXiIZQRRNEBw448T1lqIpu5k44AwV6SJhYPAwwJESInw1I75gBg9GyYtR/82R4cyBZr3nLPhwjf2a1dnP+YkA9/Popr4lDDTBAM4aEBcmGFwMpDkwdmOfjLDGDvfpzQkDY46BRHzHfAjGvAFpDozdECQCPHa4T29OGEgYSBhIGBhgDHTMCAv3ZJxNTDByDHDgvRhVZOS1De6TChpvfoqbuVMcXAylnjfCgILXW0CDZZddtlGxlNcHGFhvvfWaevRqZzc7pgOeb775QpqwoxsqLKATDkeHQ57mrCMWuwmXo8flINaAH2WsetP86f/RJ9pdN6FjHHA3O9Gv70rHkNozsukYUnvwOKi19PsxpEEd117od9IB98IopDYkDCQMJAwkDAwcBhIBHrghTx3uBwwQ4QbH+Pjk7TXAGcNf/vKXlpqFfjX5AmoJVU0LgXe8XeETuhfh7bffbqlZw5k/LVXYw4USAe7hwUlNSxgoYgCDMjwM4dkLFUXR926xfLfTEFPcVWLw1mxzgMckbEU23XTTbjez79637bbbmp0D7kS/+93v9lz/jjnmGPNDfemllzZs23DmT8OKKpKZCHBFBio1M2EADCy00ELhuOOOM2QQ3HyppZbqKcSwgBIcAveGf/zjHxu2jQhKGMi98sorDculzOYYmD59eubNDEveXgPmBHOjWUzg4cyfXuvjSNrTMSvokTQmPZMwkDDQHAMeAL0XF1oc/3P8kDjB+bi0Zb0iaMTTTz8dFl100bLsdG8YGHjsscds40MwBiQjvQaHH364Be9oZkk+nPnTa30cSXsSAR4J1tIzCQM5DCBqJVABkV/wqTz33HNb7FQiBXH8icDld999d3j88cfD+uuvH5588knzqUz0oueee844wGeeeSZssskmgQUIMR3+dD3OKq8inut1111nouc77rjD3p4nwOjX7r333sBCTKCEzTbbzM4+//73v7czrC+++GJA30oEo1tuuSUQ5Yb4rETOueqqq+x3t912y/Xq/y4RcaNrps1bbbWVEdXXXnstPPTQQxYHmEDr5O2xxx7hpZdesnpfeOEFKwceuH755ZeN0PL8eeedZ22AIyIPneXmm29uomjStBOOmPoefvhhC4W40047GefvjWMDQhQn4hsTSGLxxRc3vOGHuFcAHX1Z37feeussjB9RjG688caw1lprhRkzZtj4EHUKLhFcMjeIvUv+NddcY+oG/HZ7XGefV9TjUgTmFHPIgahVxPCdc845bU5QH5sj2sYz6IuJ60v6hhtusDFGxcEz+HKgPagJ8sB7mcs8O27cuLDhhhta9qmnnhr22WcfUz0wztRLJC3KUb8f5ar3vRB5i3L8sXlDjdHq90FfbrrpJovUNX78+LDqqqva/G/Fx3m+b12/FsufoEcxIF1aj7asWs1SyL4oEV3HGn3xxRfH2WabjahiUYtI1AJp1w8++GD8wx/+ENdYY40411xzxT333DNqQbC8k046KUpMG0VALD3LLLPECy64IM4xxxyW1qKXtVeLaBRnE0WU46677mr5WmSjzqdaGUUoiiJC8Qtf+ELUImT5ivxkeQo1GOeff367t/vuu8d11103SvRr6TPPPDN+5CMfsWvaznuKoDjAUYu2ldHGwLInT54cJ0yYYNcKUWh5zz77bDzttNPi+973vqxu2iUu19KKUxslLrdr+qAQiXZNW7QgRy32UZFz7J50wnGbbbaJ4IR2iehkzdpxxx3tngK8Ry3wdk2ZjTbaKCvT7gttVuJ22203rGrr9Z05AEgnam0XgYsiNHa9yiqrWB54ZHzp14knnhiXXnrprJ+SLlgZn1fMl2OPPTZqo2dlzj33XMvXhixOmjQpipDFe+65Jy6//PJRgTSi4vNGEau4+uqrW3mpMaLiOmfzUrrkmjmsOMBWX/4f4+XPM46ANnVWn1QKUYTYrumjNmhZ+xWT2srW+14UErNm/rT6fVx77bU2V/jOFBfb3g3u+AMPvQzI5RP0KAYSAW7PwHSaAMtqM4rDsA9e4tSo2KtxnXXWMeIr7sXui8uM0olmxE87e+vcOeecY/kQUBZ5X8hYLAFx1XH22WeP8847b1Qc3njbbbdZ+ZVWWsnyWVDlPMD+xOHaO1l4IPS++DjhU0zWyAIuDsfqWGCBBaK4p6ztEJoyOPjgg638QQcdFOUcxvogMacVVYB2WzTF8UVx09kGQpyt5Yt7tWchpooXG9dcc00jCGwMaCeE2UHcm91bbrnl4hVXXBGd2CpYgBURh2b5bBoUnzYqzqyl2VTw/k7BSAgwbanXd+YjfRfnb01WrGZLQ0gBNlZsTMTR2zxiDrCB45lHH33UykDMSF955ZWR+ecbN0kQLJ/NGPk333yzpSUtsfR3vvMdS0skbGlwLUmIzVnK806dm49s4EgfddRRVr74Txyw5TNvxVHHJZdc0tLi5CNtoB7mPOB1yXbB0vW+F0lbsn74/Gn2fUDwffMLbng/7eZPkhp7Xy//SwS4h0cnEeD2DE6nCbDEvtlHf8kll2SNVpByuw8BhGBIbGtpFisHBS/PnpWILuPqFATdikiUbPkKGWdpiBiLy2GHHWZp5wLhHgAIJPlwUBBgiX+z+hWk3RZHX6DgaCXOtnwIPG0sA7gqnoFzlWtUu4azAiCCLOAAHDTlFltsMUvzj2vuFeey9+PAAw+0sjq2lHG8Er1HiTlt08GztBGAGHg7SMP1ki7j0shvF4yUAJf1He7RialE99ZElzDANQNXX3219Yu+MZ/uuusuSyMFYZPD5oQ86VOtvET1lmZjBXh5BVnIxtQlHT4/V1ttNXtGIuII7tnQUafEt0ZQpT6wtNQaVmfxn1Qblk+b4Nh5lj/aIhGySTOkZrDHZDhoeVJlWLre91I2f5p9H3KSkrWDypF00Q7eWQVIBLiHR6m4aPVwU3u6aZ0mwOzs+ejhBtjdO0gPZfdPOeUUu4W4kXJOMFhMWcC4N23aNFtcIYSk4RDzxBOxIeWlc7N8F0XCxVIezhiAIyUN0QcQa5Nm0X/rrbcy8SCcDwTXuUyIaz1AxEcdcPmINbmGw5YBVVxmmWUinAtw9NFHW550yZaGi6Esf2wM8iA9td33Bd43AnBOSAekM7d82g2HBbBw6/hVhGM8//zzjUtkQ4A4tpMwEgJcr+8+PhBA4L777rN+Igp2YPMFzvj+GSPfZLlawYknol6AzRflpTe3NGJu0l5e+mRLc0/62AjxBM+kpVu2eQbHzR8Skdtvv93ymIvMuTKgXV4HGwGX9LB54Jr5CziBzG/w6n0vxfnT7PugftqBmoN5wcYDCRQSI9kJkN3z8I62XqORIGEgYWD4GHCjKM5iugEMhipPPPGEVSbdVBDxM+MqbmCIhSGKRGYBIykMtUQAgzgAM7bCYIbznCKy9rwIuxmkYCyFsQlngCWiNkMdDFsALdb2i6EWIH2v/XrbMICiXgxt8vki3JbmLK4IjV0X/2FMBWhBDCIg9n76hwEUxjbaRFg+hmYAxmEiLMHfLR1m1j7yJUo3w5xZZ501aCNghmNeFtzQdwzFgIkTJwYM1AARYzO4ou/gQTp2M8aS+NXye+mf96fYd8YcYE4Ap59+uv36nCAhvbvdwxBNRDGImFla+tYgLjmbVxLnm2HWRRddZPkYH2HwhlEc4NbQ119/vaWltzV/1tIJB20UgzZvZvjHuWFRKjP2wkpZYmsrjyEfVuplQLsYDwBjPnHYdo0RFu+VdMLSPicwKOR70GYpmxf574XCXtbnT7Pvg7qYk7JDCFJl2JyTztwM+TDCqgIkAlyFUUpt7FkMsAhgLQpgxenAAueAFSjWpBIJ2y0WWHEK2ULLggMRI/oVIBF1IEi6e5PCohZrWYlrLZ/zvyzOWHhK/2XWnjiRxzqYPxYk8mkDiy1A27CkxmqZxZPFVbo6s0wVJ2OEGaJWBliyAtIF20ZA3IylDznkkCBuzK55F8FDAAgjmwcn7nm8kO9ECCtXNh60R9wLWWZZzS+bEYA8icDtmj5BgGTwZVayEAtw0ItQr+8+L7Akl/FT5jRDnJzhgs0GRJR+MUY4XvGzs+JMbcy8DubLLrvsYmeuwQGbK6zg2aAAMr6zc9b4QmfzddZZZxk+fXMgPbFZVLvjDtKAz0OImyQNdq/sH/NCdgVBUpTMUpqjZX5OnWfy4ygbAjsqVe97Kc4f34jU+z7AmXTaQcaEhhc2ppLI2CmEsvb25L2e59EHuIFJBN2ewe+kCFocp4nrXP+WbzHWu/roTcyMARFWzOhm0cUCGCSRf/bZZ1vaLZjRHWLkgjGOWwYjskVcy/NYzWqRtGfQ6WGEgvWqOMeImBvDFIAy/n50qhjgkHZrW4xU0AEiskM0Wg+wZMWK1kXBzEuskPOAuBBRJNa4iLMxinIrZtd1enl5wLJ+ID7HiAjjMtpF3zAqAzBIE/E1K3Hvz5QpU6wcZfnD4vqMM87wajv2O1wRNLrPen1HVSDO38S3jBWqB/qCGJW+0x/SGPEBqA3AE2PsY4SInzKoL8Td2tiACzdyQgfLfGSc0ekisnajP+pE3M3ziJqxNEadQBpRNeCW8htvvHE2lyyj8I96mKfA8ccfbyJzN/zzom7sxZzRhi/W+16K84d0s++Dd6CWYN7Qfv/Tcb7MANHb0au/SQfcqyOjdnWDAGs3bab7+Q+0iBJ0mM8//3zx9rDT6Apdb1X2MLo8LG7bDZ0kwM3aKo4mujEKi6nOCzd8BF1vHljQ8mODXhhimgcII/pYJ5D5vGbXjEkzC2KstyGSDvn2+D1+scKmj60AxkgssvUAnFHGYerUqXa8C4KNTtqPwUB4nEB72Xb/DpcAN3u/ONqIwR0ADpgjjYAxArd5YLx9XjE+fiQtXwY9tOvn8/ebXRdxX698fk1grNAtFwEdbX7uFPPz6VbmT/77wKiLTYikAFHnwu2YnxNhdNtVgESAe3iUOk2AOXsp8Y7tHO+///5STEj0aflY8I4GsKTFchZjjHogJwW226+XP9L7Y0mAR9rm9FwtBuDu81IGFnU45LzFde0T7Uu1mwC3r2WDXRPH/SC4SFQcnGt2i2u/36u/lfSEhS4LvQWGLCjbdSZO4/B/oA/TlPzoWPAmJFFO5jkG3Qp6EvRx6ODQyUnUZTo07aq9CjMgwLBDu227h57LjQyyQn1wAe50hCBgKFIGGPjoHF5ZlhlnYMTh+sB8IfSOeS9O5KGrYmzc6CRfnmsMjOoZARXLpvTgYUBnZIOsg81QSOJw03Uzf10/PHgYST2Wtbet43iQwxsXa77E3OHCCy+0tb8KGKqcERbu6bD+wwJvUfmQhcBKRGq4xvBD59nMsATjAIw2MGSQiMpcq0FIpX+ze1j6YdTiBBpjB6zysMSTTsyIMoPJB15GZKowuM3aiIELRjz1QMcbzOq1LF/iJ8OdW+F6GaKesFhqx+m37LfRu8C9zjaa4VHNQymRMPAvDOg8qG3gMCiSJ66AQRLGPBhiJRhMDOBWE4M8NvzMCSz0cQeLUVhloFdZ87J2oS9B8e/GBpTBew5GH+i/RJDNGMWfdacEGG8AOC/QwNhZN9KcO0OMhf4CXSgiLs5HOmhQ7Zyep/O/IhrZIff8/XZed1oETVvpBzgpiqAR2+KFBryQXyaCxqgHfGHMA+AoARFQ0RDDMvUPI5KiCJr6cWenzY4Z5GBw0m5IIuh2Y3Sw6ksi6MEa7272tlIcME7hcVLuzr/Z5bD7QUzKTgiOFe7YQQQsSEeUHcXw4xQuTua8oZBtZv6ypDPuGMfmHOUgnBrHR/Liba+XdyG2leGD3+qrX0TBONvniEgjQGKAFAFxs5xLGJ45fsFxgFZBPpFNIuFHJ1p9LpVLGEgYSBioOgYqRYCJOAOUnVd0YoheNw9E1SgrTxnEonnYfvvtTSSL2BkdMZFLisCZTLnRy850FvPbmeZs51gAenEOtqNLma44owDOADjfWQSIMI4iUAPI69KwiC9RTxApSrJh7xIXbnjlvWy02gU4uujV86Lt6mOqp3MYaKQ+6dxbU82DgIFKEWC5nbMx8YPjPkAY9qD71ZGE7BC55+nIhIVn83SjX3S/EGGIr+uaiuVxkEBsy26Abyq68a78O1ZccUU70I+ezQ/tc6CeQ/5F0HlQkxboLGvAUw+GEK2CjjuY1xzewx8hziDGXLvzgVbralRO6gkLCdioTMpLGKiHAaRkxY19vbLpfsLAcDBQKStoxJR4OoErwxuQDpoHrJfldDzo4HvAUANXfHBP5ONGDSOhAw44wHCic2b2K72j/eLFCIAQOBBvE88qeCMqGl/BmbEJ6CfDDzh6AK8yDkXvN4jnpS/P3Od5OYgvhjC4DcStIH+Io1ELMCZF4F0sZg6MJXFOHRg7DOfy9zwv/SYMJAwkDPQbBirFAYN8XNah24ULxfINSzjnSCHM+LyVJ5ew995727EFjrfgmg9CoViRNn74ycUvKQGkARlnmU9VriGu8h5jR5VIO7gPVjjkfgF0vY47dLEEOS8DCHBRXA/Hmye+PIc4GneFuI7LE3TysDpXHFDTm+v8nh0h434eiu/I56XroRiQAwabt/iTzm9sKImvZjY8bC6xZ0Cy0Cmgfnw/Y8nOUT8HVAoJuosBTnzI+Yb9IfkpAnOGOcHccFenxTLtSnO6AQYJKZozP7TNfVW36z2VrkcfbuUAy1msZrGKLgM847hbtbL8ZvfcHV6+HPFPiUoiwh4JbK5Bt7SOLeWLtfW6G1bQI20wHpn0IZc+ztj0EvSjFTQehog366HeiA6UB2KxkqdNjbnALLqDzJfNX+PggvCCnC7A5SFep/jeygA3gDqLayEK8WBG5CXatOWWW0ZiBytYQ9ljlbtXJSto+XuOYjhsfVKAhxpcsybilpK1C6c4UrPV5Lea4HQI86IecHqCEykK8BHl79rcaxIhCTebhD1U8Ih6jw7cfXbOCVrAADEzcZXGHyG9mMQQmqJbwBaqarlILxPgljvRAwX7kQA7Wjn2RTxZjtAVCSVxYyXS96JNf+XgxgKrE9aNY33iXMxvMQtuHiD+kpxYCDiOlpHOgx/3U2Sa/O3KXleJAINk3L1CYFmjJOmrwTubZogj69lIwP2JlxFR3ERKBRV1ysRiQ+frZz5xZNHXzXzeIF9XTgStARwT4AgTOk7Eavvvv79d44mF6DIJEgbGAgOuvyfKDMaGREzKA4ZzqAVaBVQ4WIwTKg+rcULkTZgwwVQH8iucVXPCCSeYsxUFj7BQdEXVgZ8eQJWToPsYwCERXvxmnnnmwFjlgYhDOCfyI5n5vGbXqBewgykDVB5EUxJTYuo9N5j1sswnbHQ4ApqOHDpWQkgE+B1ctHRFDFTXaaDXTItMS2hLhTqAAc6r490NN5/E7C0utpybx16iVWBR5uw7x8McPG4tFuoA78Rmgs0nXuTKgDPynL/nKFuC7mJA3KQdu8TuBXsYTnRAFB0gziNZs6gX2xmJkb2qml9CU7LhYxNH6MMyIB7xSN5dVle/3EsEuF9GMvVj4DDgiymOTyCILIBuSMcRNhZCuKBWgQWW4195K39OElCHE2J5OzODL49NXK9uFn7iDCfoLgYwFsVXNsCRSU58YGDpgIOdvLMiv9/sV2qcILsAO4VSLKsIWOYGkjkCka0HtGvKlCn1sgfyfiLAAznsqdP9gAGs0H3Bw283R/GcCx7JQgvBzB8fgxOGo5Hxod1nMYcD5p2KSdwQhQRCSdB9DPimjDcrhrQFlkFszIYMq2gsn+txqPVai+c/pH6cLCkD5iGnHiZNmlSWnd3jWCfHQxO8g4FEgN/BRbpKGKgMBvxMtbv9ZHGTBbJ5LINrzS/EI+kUCzbqlokTJ2ZiR8TTHDlqJtYejjOWkbQtPVMfA3iry4t5kVQwV+BgH330UXNYVP/poTkcX0O6gm+Eoq7fS7MpA3RSxG+V/rbTuU7pCyp4MxHgCg5aanLCgOt/85jAHzdntmV9bF7LRsqFwiVhfAXx5WwvgA4QrpdFGE67HsBl4RGN8gm6iwHX/+J+1wFxMw6LIMD4ac8TZy/T6BcXs3gIxJ4ARzn8ARBzQrvC+Y4bN87uNTLswliVKGkJajGQCHAtPlIqYaASGCjjcLEw/eIXvxh0VMQWzeHof73TEFDq0FleE2dD0HW21Bbv+eef38SaCoDuxYf8smAjiqzHLQ15IN1oGwaQULj+N18pngCJoc7GbLj6X/S6G2+8ccBrIH+EIQVw+IEDGDhkj/1db17g+AOveTpfnm9WuhYGEgFO0yBhoGIYYEHDqxsxr4vAYgtXUhbFC66ZBdi5mOKzLKYQT46bsNhicMXCiV90XLMCeDHDG92dd95Z8zj6YTldsEUZTjxB9zGArrfM8hyJBOOHj/c55pijpmEQUggscdLLpBZwz6g2/I8jTADiZu5xbE1n0G3DhoEVnq7yIKdG5l8fy/klllgin5WuhYHWTSQTuhIGEgbGHAOIEqdNm2aEDqvUSy65JKywwgpZu1hkWXA32GCD7J5fYFSFlTTuCDmzWQTq9UAneW6GICdw1wDcMaLGL3/5y+biFX2wvGeZBTZcM2fkE3QXA4RQ5cgRweg/+MEPGlcKQXVAisHGKX+W2/PQ6TMniHaGIR8hWusBmzv8vGN3gLEfIm3mC/VfdtllFiWO+cB5X4z5nnnmGWsTZcs2i/XeM0j3Z9KuJylrenTE2WVycD7B6DAAB8eiscMOO4yuoj54Gt0dfrzrOVQYThcJD8qxF3TDWNzCDfUj/OIXvwhTp061zU4/9g8ijMHdvffeO+qwnUhC2LwRBAfOOHG9jWdM4oAb4yflJgz0DQZef/11454RFbcD8GiUvBq1A5NjW8cRRxwRiALXjpjZHGUbqfHf2GJhbN6eCPDY4D29NWGg6xiYbbbZgnz4DtEDdr0h6YU9hQEcduTPf/dU4/q8MYkA9/kAp+4lDDgG8GWeIGGgiIFEfIsY6V46WUF3D9fpTQkDCQMJAwkDCQMZBjrGAXOkgTOFCUaOAXQyHvFm5LWkJ7EzxDgk4TLNhZFggGNf6DbT/BkJ9qr1DIaEIzk/P9JedswKGmcAChI+0nal54SBt99+O6C3SzA6DLCA4hiiX610R4ed9HQzDLB5Yw4lEX4zTFU/n6NYm2++edc60jEC3LUe9PGL0jGk9gxuOobUHjwOai39fgxpUMe1F/qddMC9MAqpDQkDCQMJAwkDA4eBRIAHbshThxMGEgYSBhIGegEDiQD3wiikNiQMDBMDGAQRoQbnGr0G6EyJqNQK/OlPfyr1QdzKs6lMLQbAO+4mCcrQi4BNSyswnPnTSn29XCYR4F4endS2hIECBn7961+biz9ca2IjUHR+Xyje9SQW5/gDxj1ls80BLgvnm2++sOmmm3a9nf32wm233daMDPHl7P68e6mPxxxzjDmAufTSSxs2azjzp2FFFclMBLgiA5WamTAABhZaaKFw3HHHGTIWXnjhsNRSS/UUYlhAsRjGvzBBHxoBlulE43nllVcaFUt5LWBg+vTpmSvJ9dZbr4UnuluEOcHcePXVVxu+eDjzp2FFFcns2DngivQ/NTNhoHIYIKwg0IsLLZFxHnjgAfMBkA8MX4Zkojg9/fTTYdFFFy3LTveGgYHHHnvMNj5EQ0Iy0mtw+OGHW8jCZZddtmHThjN/GlZUkcxEgCsyUKmZvYsBRK1EBiIcHM5T5p577gCRJDQfZ4///ve/h7vvvjs8/vjjYf311w9PPvmkBTEgnOBzzz1nHCCh2zbZZBML7YaYDof2HuicnhNQnTi+iJ7vuOMOQ0aeAKNfI5oNCzGRiYjbivMIgqa/+OKL9oe+lZCBt9xyS/j5z39uAdJxmHPVVVdZCLvddtttCJIRcaNrps2EvIOovvbaa+Ghhx6y2MHf//73LW+PPfYIL730ktVL2EPKgQeuiS8MoeX58847z9oAR0QeOkvOXSKKJk1b4Yip7+GHH7bYw8SdhfN3ALeE0MNhAlF8Fl98ccMb/e0VQEdf1vett97aVAi0kzCCN954Y1hrrbXCjBkzAuNDmEe4RHDJ3FhwwQUt/5prrjF1A0ET3FGEzyvqcSkCcwoi5vCjH/0o3H///WHOOee0OUF9OEiibTyDvvhLX/qSpW+44QYbI6IY8cwPfvADaw9jkwfey1zm2XHjxoUNN9zQsk899dSwzz77mOqBcaZeQldSjvcRIQkCXO97IdQl5fhj/qDGaPX7oC833XSThcYcP358WHXVVW3+tyPARL7vbb8Wy5+gRzEgXVqPtqxazVIM3SgRXccaffHFF0c5TCGsZ9QiErVA2vWDDz4YFdg+rrHGGnGuueaKe+65Z9SCYHknnXRSlJg2ioBYepZZZokXXHBBVMB0S2vRy9qrRTSKs4kiynHXXXe1fC2y8c0337QyCgkYRYSiYvxGLUKWv8MOO1ie4rzG+eef3+7tvvvucd11140S/Vr6zDPPjIrza9e0nfcU4c4774xatK2MNgaWPXny5DhhwgS7/vSnP215zz77bDzttNOiYgdnddMucbmWVqD4KHG5XdMHxSy2a9qiBTlqsY8KXWf3pBOO22yzTQQntEtEJ2vWjjvuaPe+8Y1vRC3wdk2ZjTbaKCvT7gttVuJ22203rGrr9Z05AEgnam0XwY0iNHa9yiqrWB54ZHzp14knnhiXXnrprJ+SLlgZn1fMl2OPPTZqo2dlzj33XMvXhixOmjQpipBFxfCNyy+/fFTkqvjGG29EEau4+uqrW3mpMaKiY2XzUrrkmjn8ta99zerL/2O8/HnGEdCmzuqTSiGKENs1fdQGLWv/2muvbWXrfS9yglEzf1r9Pq699lqbK3xnl19+ub0b3PEHHnoZkMsn6FEMJALcnoHpNAGW1WYUh2EfvMSpUcHP4zrrrGPEV9yN3ReXGaUTzYifdvbWuXPOOcfyIaAs8r6QsVgC4qrj7LPPHuedd96owPdRQdCt/EorrWT5LKjzzDOP/YmDsney8EDoffFxwqeg6JEFXByO1bHAAgtEcU9Z2yE0ZXDwwQdb+YMOOigqPrX1QWJOK3ryySfboimOL4qbzjYQ4mwtX9yrPQsx3W+//eKaa65pBIGNAe2EMDuIe7N7yy23XLziiiuiE1tF67Ei4tAsn03DP//5z6hA75ZmU8H7OwUjIcC0pV7fmY/0XZy/NXmDDTawNIQUYGPFxkQcvc0j5gAbOJ5RPGcrAzEjfeWVV0bmn2/cJEGwfDZj5N98882WlrTE0vJQaGmJhC0Nrvfdd1+bs5TnnXJcE9nAkT7qqKOsfPGfOGDLZ96Ko45LLrmkpcXJR9pAPcx5wOuS7YKl630vkrZk/fD50+z7gOD75hfc8H7azZ8kNfa+Xv6XCHAPj04iwO0ZnE4TYIl9s4/+kksuyRp92WWX2X0IIARDYltLs1g5bLHFFtmzEtFlXN3OO+9sRSRKtnzFbLU0RIzF5bDDDrO0c4FwDwAEknw4KAiwxL9Z/XvttZctjr5AwdFKnG35EHjaWAZwVTwD57ryyivbNZwVABFkAQfgoCm32GKLWZp/XHOvOJe9HwceeKCV1bGljOOV6D1KzGmbDp6ljQDEwNtBGq6XdBmXRn67YKQEuKzvcI9OTCXWtya6hAGuGbj66qutX/SN+XTXXXdZGikImxw2J+RJnGvlJaq3NBsrwMsrylE2pi7p8Pm52mqr2TMSEUdwz4aOOiW+NYIq9YGlpdawOov/pNqwfNoEx86z/NEWiZBNmiE1gz0m9YHlSZVh6XrfS9n8afZ9yEtZ1g4qR9JFO3hnFSAR4B4epeKi1cNN7emmdZoAs7Pno4cbYHfvID2U3T/llFPsFuJGyjnBYDFlAePetGnTbHGFEJKGQ8wTT8SGlJfOzfJdFAkXS3k4YwCOlDREH0CsTZpF/6233srEg3A+EFznMiGu9QARH3XA5SPW5BoOW3rduMwyy0Q4F+Doo4+2POmSLQ0XQ1n+2BjkQXpqu+8LvG8E4JyQDkhnbvm0Gw4LYOGWDjzCMcrPvHGJbAgQx3YSRkKA6/XdxwcCCNx3333WT0TBDmy+wBnfP2PkmyxXKzjxRNQLsPmivPTmlkbMTdrLS59sae5JHxshnuCZtHTLNs/guPlDInL77bdbHnOROVcGtMvrYCPgkh42D1wzfwEnkPkNXr3vpTh/mn0f1E87UHMwL9h4IIFCYiQ7AbJ7Ht7R1ms0EiQMJAwMHwNuFMVZTDeAwVDliSeesMqkmwoifsHPQGKIhSGKRGZmJIWhlghgEAdgxlYYzHCeU0TWnhdhN4MUjKUwNsEQSyJqM9TBsAXQYm2/GGoB0vfar7cNAyjqxdAmny/CbWnO4orQ2HXxH8ZUgBbEIAJi76d/GEBhbKNNhOVjaAZgHCbCkhmLSYeZtY98idLNMIfgBtoImOGYtxPc0HcMxYCJEycGDNQAEWMzuKLv4EE6djPGkvjV8nvpn/en2HfGHGBOAKeffrr9+pwgIb273cMQTUQxiJhZWvrWIC45m1cS55th1kUXXWT5GB9h8IbBHODW0Ndff72lpbc1IyjphC06mDZvZvjHuWFRKjP2wkhKYmsrjyEfxnNlQLsYD0ASkCAO264xwuK9kk5Y2ucEBoV8D9osZfMi/71Q2Mv6/Gn2fVAXc1J2CEGqDJtz0pmbIR9GWFWARICrMEqpjT2LARYBrEUBrDgdxAn7pREbrFslErZ7LLDiFLKFlgUHIvbII49YvkTUQXrPzJsUFrVYy0pca/mc/2VxxsKTaFniRIL0wGZ5jYUwCxL5tIHFFqBtWFJjtcziyeIqXZ1ZpvI8hBmiVgZYsgLSBdtGQNyMpQ855JAgbsyueZe4XLuGMLJ5cOKexwsFnAhh5crGg/aIe7FnxWHbL5sRgDyJwO2aPkGAZPBlVrIQC3DQi1Cv7z4vsCSX8VPmNEOcnOGCzQZElH4xRjhe8bOz4kxtzLwO5ssuu+xiZ67BAWOIFTwbFEDGd3bOmmAkbL7OOussw6dvDqQnNotqd9xBGvB5CHFrFNGOeSG7giApilmx8yxHy/ycOun8OMqGwI5K1fteivPHNyL1vg9wRtQ9GRMaXtiYSiJj1ve8uxLQ8zz6ADcwiaDbM/idFEGL4zRxnevf8i3GeleLgImZMSDCihndLLpYAIMk8s8++2xLuwUzukOMXDDGcctgRLaIa3keq1ktkvYMOj2MULBeFecYEXNjmAJQxt+PThUDHNJubYuRCjpARHaIRusBlqxY0boomHmJFXIeEBciisQaF3E2RlFuxey6Ti8vD1jWD8TnGBFhXEa76BtGZQAGaSK+ZiXu/ZkyZYqVoyx/WFyfccYZXm3Hfocrgkb3Wa/vqArE+Zv4lrFC9UBfEKPSd/pDGiM+ALUBeGKMfYwQ8VMG9YW4WxsbcOFGTuhgmY+MMzpdRNZu9EediLt5HlEzlsaoE0gjqgbcUn7jjTfO5pJlFP5RD/MUOP74401k7oZ/XtSNvZgz2vDFet9Lcf6QbvZ98A7UEswb2u9/Os6XGSB6O3r1N4Uj1Kj1KiDK8V1hN9vIOUEt7CaWyr8XMZKLmvL3m13DsXBuNA/6aIJ0XflbHbsey3CEiHURISNmhlvmDw62HsDtwBk6cDaUe4hlAbhURId+FpR7iIOff/55KzNcjpBzwnAyIhhUVQp4tYIL572Av6tYmDK0BW6rGYjYGKcC910GzEFw5WdQ4apE9E2MT985cwo3L8Jj5fjtFLQ7HCHcL/2GQ4Wb5awroup6wBjRv3w8Yjhlbc5sXjE+4N1VBV4P52m55yoCv9/st4j7euWl57Y2kM94MvdcLO3PiPCZusXnjt8v+21l/vz/9s475pLxi+NDJKxgrRJEWy2IKEG0JdYf2OhEhLBr9d6tGqKL1YnOWuxitVXDWr1EiZbovaxEIgiJkiB5fudzfr9zf8+d987cufWdue85yXunPfPMM2fmnfOc9j3x/wfavkwWEjR3SY3TfHaZbGvX5E33s65vo/spss8FcBEuDVOb4RLAmEcBP8AUigmQfyIS7zH/AfLQKkkko4IqAAIAiWanH/0sn2Or/TdrP5wCuNnY/HgxDohGp+8ikzkI37dE+eqEEEHTS+q2AO7lWEdS35IJkEjqVgKmOKZvSALAdLIPeAxgNmWnSiJh4cvCb0EgC852yYmr8ZkAD3wczDJ5AGLKqWkL+Fbwk+CPQ8jgkxNTl85GJdKz1gcBBAR2iHlM9+Hnakfzq3VYsRW0bpCd8CtCbAswQp3wJTiDWa35A+NbxO9oKE7wmA8lvDc65ZRTSuu7szH6slwc4EOLxYQPrJjD1d/N/775h8s1Wh9NPzgg0d76HQdBDjQuvvnfSFzDtGnTKiF8lUdltY1njYvwcpBhCJ+3PEvzjQh8muZ/4VcRIaz+MxB7yHMj3N/y0fBtkE4hpjLNa8TfYKHxoPzgL4NAcsEPAYACZHltuiE/+Ll6SWXxAQOEAAhDTPg08Uviv4uJVAL8TqQHZJFMZtR3k3W82/t76QPu9li9v2wOADRCGo1MCAM50/2iVn3A/RqXX+e/aUikfJFDDGAJ3/IqUaXygGEujn8LNoDRoOcQ9EGAyFjJASMYxYh/VJllBII3IMAL2CbXDUJYEOhBcrz4YjRwgfxII4QxgtuIQBSuAfwe8H6W1G7Hu70siwBGYMLLNBHUA78I5oEASmDCkg7EiM+jH/rrJ7kA7ie3B+9aLoAH75mW5Y4qZYLGrg9IuYF/o8JbmgWA5JgfSI0wEgGWSESpthEkIfU7cszMyQS2yIPQIBeCPSQ6NcGsQSoHvk5AxGPzNoDwkvivARHkJwrYgV2qJ8te919k0PCccH94mSby+CDMzeQx0pb0C9IBsojgCNIr+kmMJy/IqJ9j8WtVjwMEDOJGcXIOdJsDlcoDxi8JNcpXJLAHwucYE1U1GrWnDQFGMU2aNEnzKvEr4SOmcklMRKdSVmvy5Mk9F75cl+CP4aZmAhMhTJSvoD0lgrqUK3y5F/qzfMN+3RuRxOKG6Nfl/DoDxgEmoPgXnZwD3eZApQQw2idkiePGDNBkBMtUNVNLIrdjhPgXjdyVfMgEIYzwJXKW0PaYiNoVc7Y6+dH4SIMYdCI4LU9gkhpCGoTksiYg9eR9qEgbIMVB8hMHnW1+f84B54BzoCkHKmWCBuEFpJPbb79dcyn5kCMgMA9hYiTdBSg+zNTkWhKpS7oCUbcQmhBkSDLkGULUJjWi3ibIKqTgpCN8uS65dxBaH9cjLy2tSVtfVV8iMNEcs2DdEL6g2gAbSI4if5ijcQs0Mtmh/QJ5OKj8qvrz9vE7B5wD/eVApTRgWANkHf5ITMFoqOSWsg4hIMG8JTn7uOOO07QF8HOB5kNQSK1IbQdOLrikJPND5JNReBwC3k6ieDVVSXf87wdsW8NUZRf+Y1KeEPaDSiYw8YGlCY03Fr4cxxwNXCHQcZjt0jQc5uf0GAZpW6Lz9b0FqIFYhpgAZgDYgMklFgoJYIwPd3Wd/vn/kCo9delmkpXQ1et4Z805IKhh+k7wPcPalCbeGd4J3o1eu2WA0URBIi3UlB/GZVjV6bGNyO2yRIO1Mg4iliXgKjPkHOg6g1VrpV9ra3B4ts2SVCer8sI2RaWJhO5l2PtwR0FLvnVmRLPk9Q5Jy4IvEM+mEck/ZF21oEZterFvEKOgSfOi3qyl1lEdKCZqsXKMKH8gMNNwkHHbrHVSfUj5S6ffWXtgAMU6oql81Aym8hJj2nvvvTVtTYo1WNNKL6sUBS14z5qlIcIsiJusju98E62SEuUkxc1Wdzxvg7RDUjf5E5dfEMtfZnNq+JItItauIHjXCq9JhSRgNil7OH369MxzR9oBZs5OBThALrD4hzUFSip+6IdJQOcLnNl+k+EWwO2PvFxnDqIANg6T9kU9WbB/mZjGRN1YKWAQ72ppnRx6PuTk38aE8AfjV6LLdWLKdkyW7ieVaeLdlV2vkgCGyZQpRMDy7MTSV8d3JlMIR7ARihJCXSyKiktNuicCFDxyK0Np/UiwaxAXlKYZkpcbE+eRssiYsibocfuRsj7UtigcchrKAQK0ROvVyh9EQQN/Jh+/oQ19j3OgTxzAjAhRZYZgQyomxUQlGksVi/cXWced8/XXXzdsOnXqVIUAlOIRWoou7dO37AFcOU795wCVqEDxAzObZxWT5OFrGqBVuIqPZa0TkErFIzC+wXvG9UdGSIzvjsuDYE0Rrures4BZ65PziJkhBdSqNdmxkbx0Adzi0wd+EdxRwPWdnAPDyQHy1YFJpSQdoPvpjy152Y3yt5uNmY8o/lz8+WnimsRMkC8PzGsjorAA+ffUaHXqLwdEc9S0S+JeiIcho4PnaYRwbnViBEYCcTOWBsrET1Cn9Blbv+AvMOFj4pZVjIN6xK1e2/of1KUL4EF9sn5fA88B+5gCNIJA5AP48ssv632TF8+HMK6aVIQhBM+RCYDW06hSkaCdacCX1SbO6pMPf6Pzs9r7/u5wgIIpYGVD1JQm4+Pyyy+vdY7W2qrljvfhtdde04pNTL6YeAFsZOmdUjIxkRiZZKuttkoQslnEuEjjdPo/B1wA/58XvuYcqBQHiEK3D94xxxyjqXimBbfzoeXmAVSR4Kla+cOYIXzM0YC5ZlwyMW5j61WoRGNjHaSlTcq4JwQkhWUoTsCEjKhoIp+zNNQsPlDWT+Je9FyKYhDdHD9f3kMmbhKgldWF7ietM68UZ+7JA3rQBfCAPli/rcHmAGZAzI0G+8nHjRKSTzzxhOa/xx/iopwgb14CC1UDbnQO0KykHDUza+eBsTTq1/d1jwM8v9jMi6U73l4TAAAbbklEQVSCd0UCEZM333xTAYtavRpaLxM60ofoj9q/VKV69tlntSsmZRDlU/MIzASneg64AK7nh285ByrBAfP/xoM96aSTEnK2Jfo4AUQl1lLidlnrlJyU4iaa7w6gjaHKgTyHeRutl4CrPFxttCwQ0ZgcOPWXA+b/BX7XCHMzgEUIYHDaY+FsbfKWCF2pLqcBfpiQWefd4hogEELLL7+8LvMCu0ANRHt2queAC+B6fviWc6ASHGik4RJhutdeeyVSpSohar9V/y8CnPNAiOPPMNQBb8DPJ3nvatYkAyCLMGFjikxHRme19/3d4wAWCvP/xr2CBEgNdSZmrfp/KXJDn7FQx7RNgB4og5DV/s56LwD+ADXvhBNOiIfl68IBF8D+GjgHKsYBPmigum244YZDRs7HFn9cXMXLGqE18wFGu21EEydOVDM2pmz+LMgGoT5hwgQ95cwzz1Q0ujlz5tR1gX9YQBcSULkQ5E795wC+3kaR51gkgNbdYIMNksUWW6xuYCBnSX10rQTXyGpBOpHU202+/PLLuvM+/fRT9S+zU3LQEwFf0QArQxS0xpirwdfHjG0wvnbMl0lSKSxof2DOgZHOAUyJmAERdJiLpSa1psUZX/jI8sE1gWn7WfIRJUoajTavwAZ+XlJYMD/iY6b8JyUk8f8hjDE1Hn744Qrxij8YSFZM1HyETz755PiSvt4HDqCl8rxIDRozZozCjlJa1Qi3BBMnBGmaeNa8E8QOEMgHxG5MCE0i4sntBoefv7lz56pGbAF/tJ85c2Zy4oknanwA+b5gwX/00Uc6Jto1mizG1xmp6/PJrMedNSV9+gQ1kDjv1BkH+IAgSABQGelEIA443mhLnRJ5oaS94BtGWx7U3HjKgl500UU62emUZ2U8HyFM5DtBVQBmZNHnn3+e8CeIVpnRzFhCMEVjnkYzdq03i5v/3e8acD5//KhzYGA48OOPP6r2jKm4GwSikaMadYOTw9sHOb3k+uYJX0aIdpzWkNMjJ/e71eC/dB8jadsF8Eh62n6vI5oDiyyySDJ9+vQhfsARzRS/eQXsaFQ+1FnTew64AO49j/0KzoFScIB6zU7OgTQHXPimOdK/bY+C7h+v/UrOAeeAc8A54ByocaBnQVgkfaers9Su6iuFOEA1GnI7nTrjABHD5KUuvvjinXXkZ49IDpD2BZRjM/jNEcmcAbtpctizioz04lZ7ZoIm7FzqlPZizCOmT3LnDjvssBFzv7260aefflpTZ1oFIejVeLxf54BzoJwcWHHFFfs6sJ4JYISvC+DOniVJ7J4/1xkPOZtKLqQhOS8756X34BxwDnSPA+4D7h4vvSfngHPAOeAccA4U5oAL4MKs8obOAeeAc8A54BzoHgdcAHePl96Tc8A54BxwDjgHCnPABXBhVnlD58DI5QAFHu655x6FIuwGF8CZnj17dje6GvY+su6FLJApU6Ykd9xxh+JvxwMFv/m8887Tkn7fffddfCihbu4ll1ySXHXVVVp7t+5gxgZFFcBzBtHKqToccAFcnWflI3UODAsHqKJEQQYA+a1EYbsDISWMgg1U7XnmmWfa7aYU5+XdCxWhKIDw/PPPKwY5Jfv++ecfHffFF1+sFaMOPvhgDVQlOBCYUOipp55Kttxyy2S//fbTggZbbbWVlhLUgzk/FNi4//77Fec7p5kfKhkHXACX7IH4cJwDZePA5ptvnlx99dWZw/rwww8zhURayFKtByxqAP2rTln3ggZL5Sm03LfeekvxtymqQiEMaMaMGVpDl7xiqkuBwfzuu+9qGcnjjjsuOeqoo7TIPTmpo0aNSqiA1Yyo1bzDDjs0a+bHS8YBF8AleyA+HOdA2TgAiAk40llEhRzAC6xAu7W74IILkgsvvDBpVHAtrz8735Z//fVXMm/ePNscskSzBLSm0XWsMRV/0uOzY50u0/dCRaBYaFrpR6sWRZWgG264QUv1vfHGG6oZM8mBj5999lnCuhHrs2bNss0hS3hz0003JdSBfvvtt4cc9x3l5oAL4HI/Hx+dc6D0HNhtt91UAGBmpTYwdP7552vd2Mcff1xRyNq5CRCoDjnkEC0mj9l69913T7bffvuEYvBGl156qQosKvpst912CdtGmHOXX3559YtSOxmzMOdjroVuueUWPb7JJpto7WP27bvvvlqsgpq2eQKdtlkEmMMKK6xQO0zJRjRUy0OnnvOff/6ZUG4UoJ133nlHr4nGDNHWiPVvvvnGNuuWTDzGjx+vPmP6oa6vU7U40DMgjmqxwUfrHHAOdMIBfJYQQhghh+kVOFoAUNolavAutdRSqt1S5g6Bg3/0999/1y4feughrUeMFslxAsUOP/zw5L777lPT7oQJExJ8qBSRv/766/Wc0047LeG8yVIbGuG+wAILqABbf/319Tjmcfyx+FO7QQhxrn377bfrGOlzzTXX1MnEAw88oOO/9957dQJjE4OFFlqodmnWCbBC08UcHROVrTB1n3POOTrJ4d5ff/31uImvl5wDrgGX/AH58JwDVeEAQni11VZLrrzyyuS2227rSPhyz0T1Hn/88TXBha8UrdY0SYQkQhrhC80///wJZm8EbEz77LNPbRM4UoKnjAgsQxD+/fffuuu6665TH6wd73SJRj5u3Lg6/+xZZ52l2NJEP++xxx7JqaeeqtrrqquuqpfDXG7EOtWKvv/++2Sbbbap/cGHV199NVlvvfVqFoZYcNv5viw3B1wAl/v5+OicA5XhwNlnn50gMG688cZk1113TX744YeOxj569OhkmWWWqeuDwCd80hCCF6EbE0L6jz/+iHflri+44IIJPtq7775bNU2CxnbZZZfcc4oefOyxx9TvfO655+opprkj5BG8aLT4d9HQSVlae+219Z6+/fbb2iUwP6OdY4rGDG9/66yzToJPmRSodk3ltYv4yrBxoP7tHbZhFLswL5qF8hc7o7VW+JyyCBOQk3NgpHIAnyWEmbcRIXzRyPD5Hnroocnpp5+u5ugsIUx/WX1Z/xtvvLEGGNk2SzQ/03AR8gi3WACxjU+6FcJ0y6Thrrvu0lSrWKjfeuutqiHn9dfoXp577rlk6tSpKtwxCyPYDzzwQB3r2LFj1URPn0willhiCf1DyOJ7xnQP8T0ijenYY49NmIzsuOOOtT/8zPi8f/nlF7UU0B5hDS9iDZ/9TiXmgDyw0pNE9wV5eYMEVAQxF/VkvOKjCeIPCh9//HFd/wI+ECT4I4gZK0jaQLjiiivqjvdyQz5Avex+xPQtEamB5+vUHgc++uijIOkyQT5jQVJdwksvvVTXkUT0BomCDiKI6vaLQAuSbhQkKri2XyayQUAmgmixYaWVVgoSwVs7ll4R36deV3ymQYRkEBOsbks0c62pmJyDCKJw9NFHhy222CJINHDtmAjVIBq0jllMzEE00LDpppsGMZOHr776qtaOFQli0vGIBl+3XzTNIFHO4bfffqvbz0bWvUhalp4Dv+I/MZdrHzJRCRIJHY444oggJna9J+tfhGgQE3sQkA795klwmZ7T6Id7Eo04iCas/W200UZ6v1JFrVFz31dCDjBjKj3xogmajL7MvRLACPk999wzSAWiGj/mzp2rQt/+KWVGGyR5vna81yvDLYD5cIppLkhqRFduVWbrQdB9utJXK524AG6FW623Ff9kEG2t4YkIlE7p119/DZIn21AI0ve///4bJNI4SBBTp5cacj6TCtG0g2jrQ451uoNJQHrSYn1KcFVgAlKEJGgs8I1iggEvnKrDgfkYaokV9NrQCNWXGZ6agyyvrnawRysEaGDOefLJJ3t0hfxuSVMggX84CPQjzHnU0sUMRrpDJ0TKB9B7RHRSZrGfhM+NaNzJEvnq5BxohQPAQfJ/SCCVk3Og2xwoXRrSTz/9lDz88MOaCkASOpF/WUTbZ599VvMCicC0KELaE/BAPwhQ/CX4TwjQyNqPYMB/tcEGGySrr7568uCDDypyDWkQM2fO1CFwLikKZ5xxRi3yEt8wUZQAAYh5S1MwaCwzURXca6yxRiImPPXnxNGY2mGTnzyfdJNTOz4M70E/IjCkEYF+RIAM/EkT/i7SUWICdo8c0WuuuSbe3Zd1gnIscKcvF/SLDAwHiMJ2cg70igOlCsKicDppAosvvnhCoALoOqQ0NCICG0iyB4UGXFkiCRGgEEo9qQr0s9Zaa2nwAzl2WftBkNlss800AIK8OogPtgVXsI5AvfbaaxOCTSxIgwkAeYYg7NA3eYfkGYJow4yZaMqDDjpIUykmTZqk/WnnBX9sLAWbd7UZ95xG+Ikv0Cr6UbP+4r67vU5OKhYUJ+eAc8A5UCYOlEYAA9+29957Jwgq8cVqNCLoNZ988klDfmEiRaPddtttk5133llz5Sx6EMxVBARmR46DEkP0dNZ+TNug08REmsCiiy6q2jOm6P3331+1aNogTCDg3xDwjBtBS4L95ZdfnoDxSjUTSAJDEtIK0BgXXnhh3TcIP71CPxoE3vg9OAecA86BIhwojQkaLYXEdKquGKWB3G0/S0xDhPWjJZIqgBaKxgqRI4f2C3QdKDHA4oF4g0bXaD/nFBGOaL4mfDkH3zCg8lQ3gdDYmTRg9rb+QO7hHPBfB416gX40aDzy+3EOOAecA1kcKI0AtuRzyp0ZLFzWoNmPP/aYY45RzRYztZmfOYagBRcVAXzCCSeojxZ/MP7KrP2c1wqhsRNMtNNOOyVUMEkTFVE6pSz/a6f9dvN8hDCIRDwDgOQ7gR7s5rjivnAT5JnT47a+7hxwDjgH+sWB0pigCWCCEJQxZQXtoNVicp42bZqan+Ngbsnl1SApzL5E8uJbpp+s/fH1iq6TQI95mSLlCGMjrvXoo4/aZkfLWNvuqKMentxt9KNeDDVtuejFNbxP54BzwDnQKgdKI4BXXnllDaQSwATFc8X8DEKNoboYvJwhUr344ouq/aKFEgkNViptQd5B+wSLFqg2BASIOvhzs/bDNLuOJMTXeIiWbWZtdrKNoGcJUX8TIHj81q+88opOBhD4mNFtnAawridU7MfuPQuxqB30o3iiVDF2tD1cyWPVqHoQjZoREzhQpIhhKEqt9F+0z0FtB19JS7v55psL3yLfhkb1kMlSoJCCAF8MKQXY7rG8QRFISCof70geCWaCxqegcPSDsFoSfEocDGhoTi1wQD6IpSES+iUaWQE3QJ0CBQYwCMmFDZIWo/slTSgIzFsAfUduM4gmqig2Eoil22KWDiK8gwhcBdYQoPMg1VkCyfxZ+1944YUA6AX9gUIjAV7hzDPP1G0xqQb5h1UELpC4aCOFsgPgID///HOQIC/dBxqNRD0HKZWmaFp2H2JGDmKibYvHwwnE0U30I25erAJBUrKUV5LGFWI0o7aY08JJww3EwTsBkpSYwXNHDYiC1M9VHkmUf27b+GDR/uNzRuq6TNYV8eqAAw4oxAIR1EFKCwZxX9W1B/QDJC+AgSR2JYwdOzZITIi2afdY3QUabIi1T9+NvO8JCFoygQuiCARQwnpNfJ9BKgMIRYpMBFC4+C46FeMAGl2piAcKek4RRBcQYHjZIc6TmZiuS8Szni8z1yC5p7qPn6z9tQZtriBMEPDdpuEUwM3updfoR82u38rx4RbAjFUsMk0FMO0kFqJlAdxK/7Qd6STpgqGoAAYBC6GWFsCi8SmspfESmElJhdTNdo9ZX1lLxoICkCWAJS0ySPBn4LvYL5LMEh0T31+I7+DWW2+t6/7TnAOlCcKSF0sJfx3m6CK09NJL15pxHuk/EBHPEBHPMWXtj9u0sx4X0G7n/CqeQw52FhV9flnnV3k/Zj8q6/BOEAFP4B9AMGl/Pi6KGTNmaODauuuum4hVJaEyj5FoEQkoTIDtE+S35JJL6iGBL9TYB9wpgn9ce+fT/Vs/tsRl87wgmvE/Q7EE3Au4eyCeFwGLVO8hqwCQf/LqqbRDbV0i+4nwhzB/zps3T6P8v/jiC81GyBoT7bP4wbFG/bPfiMpKs2fP1rGACEeg5oknnlgrWJ/Hw7xjzXhl12dJ20YBfMSfGE9oB3ANAD0ffPCBPp92jpFR0YjmzJmTUNwh6zjn4ILjfVp22WXVRUaBB+JUcB+9//77ikAHohffySwiVZNgVkzdovUnEydOrGVzMAaxFOr7w7uyyiqrqNmdDBQIEz3XFsukPlfeXVIVwU+geAYZKwAa4b4TDGx1FQJgBIZDXH0q/Z4yftwFIuATyi3yXtr4SFetOmU/jarfmY/fOdBnDvCRIh5g33331TJzBOlRDzZNCD8+hghXBAofKEBcLM6B9tSIFUtQgj+PjzsCGeCXTTbZRNHhWJJ3brEL6WvE2whRhDh9ErMg5nCtrsOElCwBK/nHZIGx0C+589wPwpjJwVFHHaXBhXws6YvKQXxQmQhkjSmPH436j8fMOvEU5N8jCIiwZ8JA/Vt8jnk8zDuWvkY72wgV8AliBcDWmZS0cwwkvUZEiiNVlYBRhQdZxHOjohOCk8BQ4gKYLIk2mkjxjIQaxASu5hGCDnwFSh4yieT9hMA7QKAycSO9kncX8CIxu9cmBSAWAn5EMC2CEvwFcBqoz8x7R7YEaIMIbN4p/PBMbKj+ZFC/jd5TJqVMZog34ZpMrJgo8s4NBDVXkr3FcHGgzCbo4eJJO9ftlwlaNIMgAliHSCUg0Z6CCFXdxn9nPmAqamHSNLOdzOjVjCcCrWaClmL0eh6+YPnQBPoDvB9fMvEHFMhgP0VEoLh/3RH93HnnnUEmAroHH7NAtuo6LhnRzoMIYd2m2Ai+enzKxFbQVgRAII6BWAjGS6yFwIzWes8bUxY/8vqvdSwr8I57lEAn3c212MYvm8fDvGN0JEGShU3QtLf+WIcofMA42G8klgPdRwWmdo5Nnz7duqotcZ+JAAr4rSGZWGjfWSZomQToe0Jb3g/eN5lwsRlEuAXRbnU960cmO0EmOGrCpmIThWlwiYjWrPEzdp5A9QbRbnVTslZ0TLyTkKQjatU43ZAfmQTocZlg6K4pU6YE0Z7tcBANOIhw1e2s95SD8JU4G76J/TSx1wbao5XSmaDl5XVyDlSSA5iJ5WOp0flok5jL0AbSJJV91D1i5kDy3hdbbDGNpMdsDZnJWT44GsGPCRYtAi0GEBoDekEba0ZokJhyDznkEM1dt3PQgMk0AL1NfJiJVP9SjRztB1x1EN4gNGYjxhy7XDBFZo0pix9o4Vn923VYGn8st5xr8QdoD5oQLiZrE/MQM2fWMVDtOiU0NzReTORGlu2AmbidY+DP83zR7iG0zPHjxyuGvOEiNHqX7Ppo0GSEYC2BiKTHdWCaIppmM+K9QjsFNIh3AgsOJmnMwJi0jcirRwstQmbut+fEc8E0bjRmzBgFUWI76z3lGNo35m3I/jd0o+I/boKu+AP04ZeHA5gK+bhgfuPDJTP6moCIR4kQwVTJBxPi40SaXCzYrD39cQw/LXntmPkQmqR9FCXGdc455+gHTDIC6k6jSAYCSzQT/XhzPcyY+Fv5WCIo+cOciO83TXljyuJHK/2nr8c2PvU8HuYda9RfO/sQtLgIjOAXwgZ/frvHSOPB/Msf/k14DjFhi8mEWryPCRrvj9Q61t2kRRq2Qtwubx0hi3+VQiqMBRcDZmYoTn0aPXp0w3dVG3bwk/eeMi4mqe+9996wFHTp4LZyT3UBnMseP+gcKM4BhC4aBNoBhTsQlkYEuBBIAlGZC6FLYA2E9kKVrVjTROuAqKSFpoU2im+P8/jIIvgg/Gr0G/evB6IfcuLRxjkX/yQ5qjYWPtpoR2Km148up6GFo22hkQEPiwDAj0eQDeeJubHWe96YsviR13+t42jFcvMJECPYCF7k8TDvGN3CK7MCoE1LuqNqedEl61bxKYsFsm4fKHxm7eAAQVn4qxES7R7Dj8rY+UNzRdMcNWqU+tu5BkIeIh4gTeDcm/bLMawG+IEh3hFiCaC8+8Vfi/Y+a9Ys1cCZJALrywTM3lX6AE2QOAcI3kAWv4B1gPHBY56V8VkbyQ/vT1zljW3jbdZ7yvjJocdHjD9aUkQ1WND6rPSyR6Zt77YLHHAfcBeYKF30ywcsAVXq75IPgvp/8a/iv8RPKwU/9JgIMr0pfHL40kTbCeS2m19PtNEwfvx49Y1JtKieR546xBI/mGim4aSTTgr4/MhNf+SRR4b0ryf878fGJYI74INjfOSsG5H3LpCqtqlLct9FCOt9SIWyIJG0QUp0BtGSgpgNgwTTaLusMeETteum+cGJjfrXDqMfMTPrWMkzFU09MH7zB9Msi4d5x/C1ghEAzoBMEDRflvHF/UZDyMxflwlSEJN+kNrkQUzwQYq31HLb2z0WX9fWebbEC4hWH8SkHMRtEPCtS/CbNdElz0gmfbV9Un9b3w8x66q/m7RBiPzgrPvlHiTgKVx22WXqJ7driKYfxAweRCtW3IMjjzxS4xBifAb8x/jo8T3zfpIjzfuCr5jrSdCd4jmIhUC38RVzbzJh0ZgEfMX2vsTvKf56cBzEJK/jB8uB/sRMHiSKXvdV+YfZh1NJOeACuDsPph8CWGb1KtT4KEnqjQa/8AHig5ZFfKj5yLFMEwFIcQ67HSfPEiENEQxEYE4REoS4WtAXQSzpa5IznyYEIIE4zajRmIrwo1n/JoD5UJPjL9rSkKHk8TDvmHVEG4KAEADtELm3jZ4TfbV7LD2O+F0Qa0D6sL4HBMkhKGPimaafX979EkjFnwneuC/W6Uu00fTuIdu8l0XaDTlRdjR7TxudU+V9HoQl0ykn50CnHHj66ac1iAlTrSB+aQoHOaFpn2t8HXx5yy23XLyrtk6QlQVa1XbKCv43I8x9RQnzsRFmxjTh700TZui8wB9r32hMmJ8J6srjR7P+zXzJ0nL87Zq2zONh3jE7H5MsfKQeeDuUFxDU7rH0OOJ3ARO3Efm9mMF5npRPTeffN3qmefdrPuesd5LAwiLUynuZ7q/Ze5puX/VtF8BVf4I+/lJwQDRdBRRA4MqMXP20AGWIqbgU4+v3ILrBDyJ5IUAeyFUeN25c12+DaGP+qkj4UiVdTQPSrr/++kK3UOX7LXSDFWs0H+p7xcY8YobLPwvRjU6dcYCkf4JSJk+e3FlHBc8msCROtSh42sA2a5cfBPLY5wl+Ok8H9hUZsTfmGvCIffR+473igAuKes62yw8zidb35lvOgcHhgAvgEj/LPP9hiYdduqHhky3iyyzdwH1AzgHnwEBzwE3QA/14/eacA84B54BzoKwccCCOsj4ZH5dzwDngHHAODDQHXAAP9OP1m3MOOAecA86BsnLABXBZn4yPyzngHHAOOAcGmgMugAf68frNOQecA84B50BZOeACuKxPxsflHHAOOAecAwPNgf8ARaPwpRuBqrkAAAAASUVORK5CYII=)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lbfZRsfRTFDU"
      },
      "outputs": [],
      "source": [
        "class RandomlyWiredNeuralNetwork(nn.Module):\n",
        "\n",
        "    def __init__(self, channel, input_channel, p, k, m, graph_type, classes, node_num, is_train=True, is_small_regime=True):\n",
        "        \"\"\"The base architecture of Randomly Wired Neural Network model.\n",
        "\n",
        "           Args:\n",
        "              channel(int): Number of initial output channels for generator.\n",
        "              classes(int): Number of classes to classify.\n",
        "              input_channel(int): Number of initial channels.\n",
        "              node_num(int): Total number of nodes in the graph.\n",
        "              conv_layers(Modules): Convolutional Neural Network Layers.\n",
        "        \"\"\"\n",
        "        super(RandomlyWiredNeuralNetwork, self).__init__()\n",
        "        self.channel = channel\n",
        "        self.classes = classes\n",
        "        self.input_channel = input_channel\n",
        "        self.node_num = node_num\n",
        "\n",
        "        self.conv1 = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=input_channel, out_channels=channel//2, kernel_size=3, stride=2, padding=1),\n",
        "            nn.BatchNorm2d(channel//2)\n",
        "            )\n",
        "        \n",
        "        if is_small_regime:\n",
        "            self.conv2 = nn.Sequential(\n",
        "                nn.ReLU(),\n",
        "                nn.Conv2d(in_channels=channel//2, out_channels=channel, kernel_size=3, stride=2, padding=1),\n",
        "                nn.BatchNorm2d(channel)\n",
        "            )\n",
        "\n",
        "            self.conv3 = Rand_Wire(node_num, p, k, m, graph_type, channel, channel, is_train, \"small_regime_1\")\n",
        "\n",
        "            self.conv4 = Rand_Wire(node_num, p, k, m, graph_type, channel, 2*channel, is_train, \"small_regime_2\")\n",
        "            \n",
        "            self.conv5 = Rand_Wire(node_num, p, k, m, graph_type, 2*channel, 4*channel, is_train, \"small_regime_3\")\n",
        "\n",
        "            self.conv6 = nn.Sequential(\n",
        "                nn.ReLU(),\n",
        "                nn.Conv2d(4*channel, 1280, 1),\n",
        "                nn.BatchNorm2d(1280),\n",
        "                nn.AdaptiveAvgPool2d(1)\n",
        "            )\n",
        "        else:\n",
        "            self.conv2 = Rand_Wire(node_num, p, k, m, graph_type, channel//2, channel, is_train, \"regular_regime_1\")\n",
        "\n",
        "            self.conv3 = Rand_Wire(node_num, p, k, m, graph_type, channel, 2*channel, is_train, \"regular_regime_2\")\n",
        "\n",
        "            self.conv4 = Rand_Wire(node_num, p, k, m, graph_type, 2*channel, 4*channel, is_train, \"regular_regime_3\")\n",
        "\n",
        "            self.conv5 = Rand_Wire(node_num, p, k, m, graph_type, 4*channel, 8*channel, is_train, \"regular_regime_4\")\n",
        "\n",
        "            self.conv6 = nn.Sequential(\n",
        "                nn.ReLU(),\n",
        "                nn.Conv2d(8*channel, 1280, 1),\n",
        "                nn.BatchNorm2d(1280),\n",
        "                nn.AdaptiveAvgPool2d(1)\n",
        "            )\n",
        "\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(1280, classes),\n",
        "            nn.LogSoftmax(1)\n",
        "        )\n",
        "\n",
        "        for parameter in self.parameters():\n",
        "            if parameter.dim() >= 2:\n",
        "                nn.init.xavier_uniform_(parameter)\n",
        "\n",
        "    def forward(self, x):                             \n",
        "       x = self.conv1(x)                              \n",
        "       x = self.conv2(x)                              \n",
        "       x = self.conv3(x)                              \n",
        "       x = self.conv4(x)                              \n",
        "       x = self.conv5(x)                              \n",
        "       x = self.conv6(x).squeeze(-1).squeeze(-1)    \n",
        "       x = self.classifier(x)                         \n",
        "\n",
        "       return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "67lVfYqVUZt7"
      },
      "source": [
        "# Node Operation\n",
        "  1.   Aggregation: The input data of one or more input edges to a node and are combined via a weighted sum; the weights are learnable and positive (use sigmoid on the weights to ensure positivity).\n",
        "  2.   Transformation: After the aggregation, then the data is passed through a 3x3 sepearable convolution layer (ReLU -> Conv -> BN triplet). (ReLU is used to intake both positive and negative value so as to prevent large computational values.)\n",
        "  3.   Distribution: After the Transformation, the copies of the processed data is then passed to the output edges.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "llmKjrfpYfNB"
      },
      "outputs": [],
      "source": [
        "class Node(nn.Module):\n",
        "\n",
        "    def __init__(self, in_channel, out_channel, degree=1, stride=1):\n",
        "        \"\"\"Node Operation defined by the paper.\n",
        "\n",
        "           Node Operation:\n",
        "            1. Aggregation of the input nodes.\n",
        "            2. Transformation through the convolutional layers.\n",
        "\n",
        "           Args:\n",
        "              aggregate_weight(tensor): Weight to aggregate the node tensors.\n",
        "              conv(Module): Convolutional layers defined by the paper.\n",
        "              degree(int): The in_degree of the node.\n",
        "              stride(int): The stride of the seperable conv layer.\n",
        "        \"\"\"\n",
        "        super(Node, self).__init__()\n",
        "        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "        self.aggregate_weight = nn.Parameter(torch.zeros(degree), requires_grad=True).to(device)\n",
        "        self.conv = nn.Sequential(\n",
        "            nn.ReLU(),\n",
        "            SeperableConvolution(in_channel, out_channel, stride),\n",
        "            nn.BatchNorm2d(out_channel)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        # x = [B, channel, W, H, degree]\n",
        "        # aggregate weight = [degree, 1]\n",
        "        x = torch.matmul(x, torch.sigmoid(self.aggregate_weight))\n",
        "            \n",
        "        # x = [B, channel, W, H]\n",
        "        x = self.conv(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "class SeperableConvolution(nn.Module):\n",
        "\n",
        "    def __init__(self, in_channel, out_channel, stride=1):\n",
        "        super(SeperableConvolution, self).__init__()\n",
        "        \"\"\"\n",
        "        Seperable convolution defined by the paper.\n",
        "\n",
        "        Combination of depthwise 3x3 convolution and 1x1 convolution would act \n",
        "        as convolution for each channels and then taking a channel-wise pooling.\n",
        "        \"\"\"\n",
        "        self.conv = nn.Sequential(\n",
        "            nn.Conv2d(in_channel, in_channel, 3, padding=1, stride=stride),\n",
        "            nn.Conv2d(in_channel, out_channel, 1) \n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        # x = [B, C, W, H]\n",
        "        return self.conv(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OYdGFkU2MF4R"
      },
      "source": [
        "## Unit Test "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9nlJlplNMHby"
      },
      "outputs": [],
      "source": [
        "def test_seperableConv():\n",
        "    test = [(1,1), (3,4), (3,10)]\n",
        "    for i in test:\n",
        "      tensor = torch.randn((32, i[0], 96, 96), dtype=torch.float)\n",
        "      sep_conv = SeperableConvolution(i[0], i[1])\n",
        "      output = sep_conv(tensor)\n",
        "\n",
        "      expected = torch.randn(32, i[1], 96, 96)\n",
        "\n",
        "      assert output.shape == expected.shape\n",
        "\n",
        "def test_node_operation():\n",
        "    nod = Node(3, 4, 10)\n",
        "    tensor = torch.stack([torch.randn((1, 3, 5, 5), dtype=torch.float) for _ in range(10)], -1)\n",
        "    output = nod(tensor)\n",
        "\n",
        "    expected = torch.randn(1, 4, 5, 5)\n",
        "\n",
        "    assert output.shape == expected.shape\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BP5EWvRm4w9H"
      },
      "outputs": [],
      "source": [
        "test_seperableConv()\n",
        "# test_node_operation()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B15BgfdlLnV6"
      },
      "source": [
        "# Edge Operation\n",
        "\n",
        "The edge operation will be the forward function of the random graph generator."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f4695JRWLt5x"
      },
      "source": [
        "# Graph Construction\n",
        "\n",
        "*   Use networkx module to construct the random graph models\n",
        "  *   Watts Strogatz (default)\n",
        "  *   Erdos Renyi\n",
        "  *   Barabasi Albert\n",
        "\n",
        "* Input and output nodes: \n",
        "  * After generating the general random graph, it is not yet a valid neural network because it may have multiple input nodes and multiple output nodes. A typical neural networks have a single input and a single output.\n",
        "  * Thus we apply a post-processing step:\n",
        "    * Given a general random graph, we create a single extra node that is connected to all original input nodes, which is the unique input node that sends out the same copy of input data to all original input nodes. Similarly, we create a single extra node that is connected to all original output nodes. This is the unique output node; we have it compute the (un-weighted) average from all original output nodes. When referring to the node count N, we exclude these two nodes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uA9iuInnLvoq"
      },
      "outputs": [],
      "source": [
        "SEED = 981126\n",
        "\n",
        "class Graph(nn.Module):\n",
        "\n",
        "    def __init__(self, node_num, p, k=4, m=5, graph_mode=\"WS\"):\n",
        "        \"\"\"Random Graph constructor class to map it onto the CNN.\n",
        "\n",
        "           Args:\n",
        "              node_num(int): Total number of nodes in the graph.\n",
        "              p(float): Probability that a graph generate a new edge.\n",
        "              k(int): Number of nearest neighbors the graph will join.\n",
        "              m(int): Number of edges to be added sequentially. \n",
        "              graph_mode(str): Type of random graph the object will generate.\n",
        "        \"\"\"\n",
        "        self.node_num = node_num\n",
        "        self.p = p\n",
        "        self.k = k\n",
        "        self.m = m\n",
        "        self.graph_mode = graph_mode\n",
        "\n",
        "    def get_dag(self):\n",
        "        \"\"\"Returns a dict representing the post-processed random graph.\"\"\"\n",
        "        networkx_random_graph = self.make_graph()\n",
        "        return self.make_DAG(networkx_random_graph)\n",
        "\n",
        "    def make_graph(self):\n",
        "        \"\"\"Creates a networkx object based on the given graph mode.\"\"\"\n",
        "        if self.graph_mode == 'ER':\n",
        "            return nx.random_graphs.erdos_renyi_graph(self.node_num, self.p, seed=SEED)\n",
        "        elif self.graph_mode == 'WS':\n",
        "            assert self.k % 2 == 0, \"k must an even number.\"\n",
        "            return nx.random_graphs.connected_watts_strogatz_graph(self.node_num, self.k, self.p, seed=SEED)\n",
        "        else:\n",
        "            return nx.random_graphs.barabasi_albert_graph(self.node_num, self.m, seed=SEED)\n",
        "\n",
        "    def make_DAG(self, graph):\n",
        "        \"\"\"Given an undirected graph, constructs a directed acyclic graph\n",
        "           and adds an extra node to all the initial nodes\n",
        "           and adds an extra node to all the output nodes\n",
        "           in order to map the graph \n",
        "           to the convolutional neural network computation.\n",
        "\n",
        "           Args:\n",
        "              Networkx generated random graph class object \n",
        "              \n",
        "           Return:\n",
        "              Python dictionary with input nodes as keys and output nodes as values\n",
        "        \"\"\"\n",
        "        sets = set()\n",
        "        out_graph = {}\n",
        "        graph = graph.to_directed()\n",
        "        for temp_edge in graph.out_edges:\n",
        "          edge = (temp_edge[0]+1, temp_edge[1]+1)\n",
        "          sorted_edge_tuple = tuple(sorted(edge))\n",
        "          if not has_edges(sorted_edge_tuple, sets):\n",
        "            insert_edge(edge, out_graph)\n",
        "            sets.add(sorted_edge_tuple)\n",
        "            \n",
        "        post_processing(out_graph, self.node_num)\n",
        "        \n",
        "        return out_graph\n",
        "\n",
        "def has_edges(edge, sets) -> bool:\n",
        "  \"\"\"Check whether the edge exists in the graph to avoid cycle.\n",
        "\n",
        "     Args:\n",
        "        edge(tuple): Represents an edge (input node, output node)\n",
        "        sets(set): Stores inserted edges\n",
        "\n",
        "     Return:\n",
        "        Whether edge has already been inserted to the grpah\n",
        "  \"\"\"\n",
        "  return edge in sets\n",
        "\n",
        "def insert_edge(edge, graph) -> None:\n",
        "  \"\"\"In-place modifier that inserts the edge into the graph \n",
        "     with input node as key and output node as values\n",
        "\n",
        "     Args:\n",
        "        edge(tuple): Represents an edge (input node, output node)\n",
        "        graph(dict): Represents the graph {input node: [output nodes]}\n",
        "\n",
        "     Return:\n",
        "        None\n",
        "  \"\"\"\n",
        "  input_node, output_node = edge\n",
        "\n",
        "  if input_node not in graph:\n",
        "    graph[input_node] = [output_node]\n",
        "  else:\n",
        "    graph[input_node].append(output_node)\n",
        "\n",
        "def post_processing(graph, node_num) -> None:\n",
        "  \"\"\"In-place modifier that \n",
        "      inserts an extra input node to all original input nodes\n",
        "      and inserts an extra output node to to all original output nodes\n",
        "\n",
        "      extra input node is defined as 0\n",
        "      extra output node is defined as max(node_value) + 1 \n",
        "\n",
        "      Args:\n",
        "          graph(dict): Represents dag {input node: [output nodes]}\n",
        "          node_num(int): Number of total nodes in the graph.\n",
        "\n",
        "      Return:\n",
        "          None - Modified in-place\n",
        "  \"\"\"  \n",
        "  original_input_nodes, original_output_nodes = find_original_nodes(graph)\n",
        "  all_output_node = node_num + 1\n",
        "\n",
        "  graph[0] = []\n",
        "  \n",
        "  for input_node in original_input_nodes:\n",
        "    graph[0].append(input_node)\n",
        "  \n",
        "  for output_node in original_output_nodes:\n",
        "    graph[output_node] = [all_output_node]\n",
        "\n",
        "def find_original_nodes(graph):\n",
        "  \"\"\"Returns origianl input and output nodes\"\"\"\n",
        "  original_input_nodes = []\n",
        "  original_output_nodes = []\n",
        "  all_output_nodes = set()\n",
        "\n",
        "  for output_nodes in graph.values():\n",
        "    for output_node in output_nodes:\n",
        "      all_output_nodes.add(output_node)\n",
        "\n",
        "  for input_node, output_nodes in graph.items():\n",
        "    if input_node not in all_output_nodes:\n",
        "      original_input_nodes.append(input_node)\n",
        "\n",
        "    for output_node in output_nodes:\n",
        "      if output_node not in graph:\n",
        "        original_output_nodes.append(output_node)\n",
        "\n",
        "  return original_input_nodes, original_output_nodes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VwSk0x2O2hTT"
      },
      "source": [
        "## Unit Test\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EkdJX0BSwkXp",
        "outputId": "444e118f-1923-4464-af57-d01cc4de0a1c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{1: [8, 5], 2: [9, 6], 3: [8, 7], 4: [5, 7, 8, 9], 5: [8, 6, 10], 6: [10, 9], 7: [10, 8, 9], 8: [9, 10], 0: [1, 2, 3, 4], 9: [11], 10: [11]} {0: 0, 1: [0], 2: [0], 3: [0], 4: [0], 5: [1, 4], 6: [2, 5], 7: [3, 4], 8: [1, 3, 4, 5, 7], 9: [2, 4, 6, 7, 8], 10: [5, 6, 7, 8]} [9, 10]\n"
          ]
        }
      ],
      "source": [
        "graph_ = Graph(10, 0.75, 4, 0, \"WS\")\n",
        "graph = graph_.get_dag()\n",
        "\n",
        "heap = [0]\n",
        "heapSet = set()\n",
        "heapSet.add(0)\n",
        "processed = {0 : 0}\n",
        "\n",
        "in_nodes = {}\n",
        "for in_, out_ in graph.items():\n",
        "  for node in out_:\n",
        "    if node not in in_nodes:\n",
        "      in_nodes[node] = [in_]\n",
        "    else:\n",
        "      in_nodes[node].append(in_)\n",
        "\n",
        "while heap:\n",
        "  node = heappop(heap)\n",
        "  heapSet.remove(node)\n",
        "\n",
        "  if node != 0:\n",
        "    in_degree = len(in_nodes[node])\n",
        "    in_nodes_ = [node for node in in_nodes[node]]\n",
        "    processed[node] = in_nodes_\n",
        "  neighbors = graph[node]\n",
        "  for neighbor in neighbors:\n",
        "    if neighbor not in heapSet and neighbor != 11:\n",
        "      heappush(heap, neighbor)\n",
        "      heapSet.add(neighbor)\n",
        "\n",
        "print(graph, processed, in_nodes[11])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36M8MBSyLv6F"
      },
      "source": [
        "# Mapping the Graph onto the architectural computation method\n",
        "  * Make sure all the edges meet at the end\n",
        "  * Ensure that all the nodes are connected and directed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XY39MSDWL39N"
      },
      "outputs": [],
      "source": [
        "class Rand_Wire(nn.Module):\n",
        "\n",
        "    def __init__(self, node_num, p, k, m, graph_mode, in_channels, out_channels, is_train, name):\n",
        "        \"\"\"Generator mapping the random graph onto the CNN architecture.\n",
        "\n",
        "           Args:\n",
        "              params(dict): Parameters to build necessary componenets.\n",
        "              input_node(int): Node connected to all original input nodes.\n",
        "              output_node(int): Node connected to all original output nodes.\n",
        "              in_nodes(dict): input nodes for each nodes.\n",
        "              nodeOps(ModuleDict): Node operation for each nodes.\n",
        "              graph(dict): Post-processed random graph.\n",
        "        \"\"\"\n",
        "        super(Rand_Wire, self).__init__()\n",
        "        self.params = {\n",
        "            'node_num': node_num,\n",
        "            'p': p,\n",
        "            'k': k,\n",
        "            'm': m,\n",
        "            'graph_mode': graph_mode,\n",
        "            'in_channels': in_channels,\n",
        "            'out_channels': out_channels,\n",
        "            'is_train': is_train,\n",
        "            'name': name\n",
        "        }\n",
        "        self.input_node = 0\n",
        "        self.output_node = node_num + 1\n",
        "        self.graph = self.get_graph()\n",
        "        self.in_nodes = self.get_in_nodes()\n",
        "        self.nodeOps = self.get_nodeOps()\n",
        "\n",
        "    def get_graph(self):\n",
        "      if self.params['is_train']:\n",
        "        nx_graph = Graph(self.params['node_num'],\n",
        "                      self.params['p'], \n",
        "                      self.params['k'], \n",
        "                      self.params['m'], \n",
        "                      self.params['graph_mode']\n",
        "                      )\n",
        "        graph = nx_graph.get_dag()\n",
        "        self.save_graph(graph)\n",
        "      else:\n",
        "        graph = self.load_graph()\n",
        "\n",
        "      return graph\n",
        "\n",
        "    def get_in_nodes(self):\n",
        "      \"\"\"Returns a dict of input nodes for each node.\"\"\"\n",
        "      in_nodes = {}\n",
        "      for in_, out_ in self.graph.items():\n",
        "        for node in out_:\n",
        "          if node not in in_nodes:\n",
        "            in_nodes[node] = [in_]\n",
        "          else:\n",
        "            in_nodes[node].append(in_)\n",
        "\n",
        "      return in_nodes\n",
        "\n",
        "    def get_nodeOps(self):\n",
        "      \"\"\"Returns a ModuleDict of Node Operations for each node.\"\"\"\n",
        "      tempNodeOps = {}\n",
        "\n",
        "      for node, inputs in self.in_nodes.items():\n",
        "        node = str(node)\n",
        "        if inputs[0] == 0:\n",
        "          tempNodeOps[node] = Node(\n",
        "              self.params['in_channels'], \n",
        "              self.params['out_channels'], \n",
        "              len(inputs), 2\n",
        "              )\n",
        "        elif node == str(self.output_node):\n",
        "          pass\n",
        "        else:\n",
        "          tempNodeOps[node] = Node(\n",
        "              self.params['out_channels'], \n",
        "              self.params['out_channels'], \n",
        "              len(inputs)\n",
        "              )\n",
        "\n",
        "      return nn.ModuleDict(tempNodeOps)\n",
        "\n",
        "    def save_graph(self, graph):\n",
        "        path = self.params[\"name\"] + \".pkl\"\n",
        "        with open(path, \"wb\") as f:\n",
        "          pickle.dump(graph, f)\n",
        "\n",
        "    def load_graph(self):\n",
        "        path = self.params[\"name\"] + \".pkl\"\n",
        "        with open(path, \"r\") as f:\n",
        "          out_graph = pickle.load(f)\n",
        "\n",
        "        return out_graph\n",
        "\n",
        "    def forward(self, x):\n",
        "      \"\"\"Forward propagate through the random graph given input tensor x.\n",
        "\n",
        "         Use heap queue to begin from the lowest node since the graph is a\n",
        "         directed acyclic graph. The input node and the output node will not\n",
        "         have any computation and they are not included in the node count.\n",
        "      \"\"\"\n",
        "      heap = [self.input_node]\n",
        "      heapSet = set()\n",
        "      heapSet.add(self.input_node)\n",
        "      processed = {self.input_node : x}\n",
        "\n",
        "      while heap:\n",
        "        node = heappop(heap)\n",
        "        heapSet.remove(node)\n",
        "\n",
        "        if node != self.input_node:\n",
        "          in_nodes = torch.stack([torch.clone(processed[input_node]) for input_node in self.in_nodes[node]], -1)\n",
        "          processed[node] = self.nodeOps[str(node)](in_nodes)  \n",
        "\n",
        "        neighbors = self.graph[node]\n",
        "\n",
        "        for neighbor in neighbors:\n",
        "          if neighbor not in heapSet and neighbor != self.output_node:\n",
        "            heappush(heap, neighbor)\n",
        "            heapSet.add(neighbor)\n",
        "\n",
        "      original_outs = torch.stack([processed[node] for node in self.in_nodes[self.output_node]], -1)\n",
        "\n",
        "      return torch.mean(original_outs, -1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJmG68z0H5VP"
      },
      "source": [
        "# Data Preprocessing\n",
        "  * PCam (Problem with tfds server)\n",
        "  * VOC (Experimenting on)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v1uumcnv2ccO"
      },
      "source": [
        "## VOC"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F-phOejH20Qt"
      },
      "source": [
        "### VOC dataset download"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a89a9p4liydu"
      },
      "outputs": [],
      "source": [
        "import subprocess\n",
        "import tarfile\n",
        "import shutil\n",
        "import os\n",
        "\n",
        "def download():\n",
        "  # This function is designed to move the files and untar it in google colab.\n",
        "  if not os.path.exists(os.path.join(os.getcwd(), 'VOCdevkit_2012')):\n",
        "    subprocess.call(['sh', './host_download.sh'])\n",
        "    if not os.path.exists(os.path.join(os.getcwd(), 'VOCdevkit_2012')):\n",
        "      subprocess.call(['sh', './backup_download.sh'])\n",
        "\n",
        "    if os.path.exists('VOCdevkit'):\n",
        "      os.rmdir('VOCdevkit')\n",
        "\n",
        "    shutil.copyfile(\"VOCtrainval_11-May-2012.tar\", \"/content/VOCtrainval_11-May-2012.tar\")\n",
        "    tar_train = tarfile.open('/content/VOCtrainval_11-May-2012.tar', 'r')\n",
        "    tar_train.extractall('/content/')\n",
        "    shutil.move(\"/content/VOCdevkit/\", \"/content/VOCdevkit_2012\")\n",
        "\n",
        "    shutil.copyfile(\"VOC2012test.tar\", \"/content/VOC2012test.tar\")\n",
        "    tar_test = tarfile.open('/content/VOC2012test.tar', 'r')\n",
        "    tar_test.extractall('/content/')\n",
        "    shutil.move(\"/content/VOCdevkit/VOC2012\", \"/content/VOCdevkit_2012/VOC2012test\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GQ8Ak1ct2233"
      },
      "source": [
        "### VOC custom Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MdKe7c-1j3kw"
      },
      "outputs": [],
      "source": [
        "import xml.etree.ElementTree as ET\n",
        "import torch.utils.data as data\n",
        "import os, numpy as np\n",
        "from PIL import Image\n",
        "\n",
        "VOC_CLASSES = (\n",
        "    \"__background__\",\n",
        "    \"aeroplane\",\n",
        "    \"bicycle\",\n",
        "    \"bird\",\n",
        "    \"boat\",\n",
        "    \"bottle\",\n",
        "    \"bus\",\n",
        "    \"car\",\n",
        "    \"cat\",\n",
        "    \"chair\",\n",
        "    \"cow\",\n",
        "    \"diningtable\",\n",
        "    \"dog\",\n",
        "    \"horse\",\n",
        "    \"motorbike\",\n",
        "    \"person\",\n",
        "    \"pottedplant\",\n",
        "    \"sheep\",\n",
        "    \"sofa\",\n",
        "    \"train\",\n",
        "    \"tvmonitor\",\n",
        ")\n",
        "\n",
        "class VocDataset(data.Dataset):\n",
        "    def __init__(self, data_path, dataset_split, transform):\n",
        "        self.data_path = data_path\n",
        "        self.transform = transform\n",
        "        self.dataset_split = dataset_split\n",
        "\n",
        "        self.__init_classes()\n",
        "        (\n",
        "            self.names,\n",
        "            self.labels,\n",
        "            self.box_indices,\n",
        "            self.label_order,\n",
        "        ) = self.__dataset_info()\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        x = Image.open(self.data_path + \"/JPEGImages/\" + self.names[index] + \".jpg\")\n",
        "\n",
        "        scale = np.random.rand() * 2 + 0.25\n",
        "        w = int(x.size[0] * scale)\n",
        "        h = int(x.size[1] * scale)\n",
        "        if min(w, h) < 224:\n",
        "            scale = 224 / min(w, h)\n",
        "            w = int(x.size[0] * scale)\n",
        "            h = int(x.size[1] * scale)\n",
        "\n",
        "        x = self.transform(x)\n",
        "        y = self.labels[index]\n",
        "        return x, y\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.names)\n",
        "\n",
        "    def __init_classes(self):\n",
        "        self.classes = VOC_CLASSES\n",
        "        self.num_classes = len(self.classes)\n",
        "        self.class_to_ind = dict(zip(self.classes, range(self.num_classes)))\n",
        "\n",
        "    def __dataset_info(self):\n",
        "        with open(\n",
        "            self.data_path + \"/ImageSets/Main/\" + self.dataset_split + \".txt\"\n",
        "        ) as f:\n",
        "            annotations = f.readlines()\n",
        "\n",
        "        annotations = [n[:-1] for n in annotations]\n",
        "        box_indices = []\n",
        "        names = []\n",
        "        labels = []\n",
        "        label_order = []\n",
        "        for af in annotations:\n",
        "            filename = os.path.join(self.data_path, \"Annotations\", af)\n",
        "            tree = ET.parse(filename + \".xml\")\n",
        "            objs = tree.findall(\"object\")\n",
        "            num_objs = len(objs)\n",
        "\n",
        "            boxes = np.zeros((num_objs, 4), dtype=np.int32)\n",
        "            boxes_cl = np.zeros((num_objs), dtype=np.int32)\n",
        "            boxes_cla = []\n",
        "            temp_label = []\n",
        "            for ix, obj in enumerate(objs):\n",
        "                bbox = obj.find(\"bndbox\")\n",
        "                # Make pixel indexes 0-based\n",
        "                x1 = float(bbox.find(\"xmin\").text) - 1\n",
        "                y1 = float(bbox.find(\"ymin\").text) - 1\n",
        "                x2 = float(bbox.find(\"xmax\").text) - 1\n",
        "                y2 = float(bbox.find(\"ymax\").text) - 1\n",
        "\n",
        "                cls = self.class_to_ind[obj.find(\"name\").text.lower().strip()]\n",
        "                boxes[ix, :] = [x1, y1, x2, y2]\n",
        "                boxes_cl[ix] = cls\n",
        "                boxes_cla.append(boxes[ix, :])\n",
        "                temp_label.append(cls)\n",
        "            lbl = np.zeros(self.num_classes)\n",
        "            lbl[boxes_cl] = 1\n",
        "            labels.append(lbl)\n",
        "            names.append(af)\n",
        "            box_indices.append(boxes_cla)\n",
        "            label_order.append(temp_label)\n",
        "\n",
        "        return (\n",
        "            np.array(names),\n",
        "            np.array(labels).astype(np.float32),\n",
        "            np.array(box_indices),\n",
        "            label_order,\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJ_7w1Nl27Zb"
      },
      "source": [
        "### VOC dataloader\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RNzSjolej6HX"
      },
      "outputs": [],
      "source": [
        "from torchvision import transforms\n",
        "import torch\n",
        "\n",
        "def get_dataloader(split='train',batch_size=32):\n",
        "  normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                     std= [0.229, 0.224, 0.225])\n",
        "  if split == \"train\":\n",
        "    train_transform = transforms.Compose([\n",
        "                transforms.Resize(224),\n",
        "                transforms.CenterCrop(224),\n",
        "                transforms.RandomHorizontalFlip(),\n",
        "                transforms.RandomResizedCrop(224),\n",
        "                transforms.ToTensor(),\n",
        "                normalize\n",
        "            ])\n",
        "    \n",
        "    ds_train = VocDataset(\"/content/VOCdevkit/VOC2012\",'train',train_transform)\n",
        "    \n",
        "    return torch.utils.data.DataLoader(dataset=ds_train,\n",
        "                                       batch_size=batch_size, \n",
        "                                       shuffle=True,\n",
        "                                       num_workers=1)\n",
        "  elif split == \"val\":\n",
        "    test_transform = transforms.Compose([\n",
        "                transforms.Resize(224),\n",
        "                transforms.CenterCrop(224),\n",
        "                transforms.ToTensor(),\n",
        "                normalize,\n",
        "            ])\n",
        "    \n",
        "    ds_val = VocDataset(\"/content/VOCdevkit/VOC2012\",'val',test_transform)\n",
        "    \n",
        "    return torch.utils.data.DataLoader(dataset=ds_val,\n",
        "                                       batch_size=batch_size, \n",
        "                                       shuffle=True,\n",
        "                                       num_workers=1)\n",
        "  else:\n",
        "    test_transform = transforms.Compose([\n",
        "                transforms.Resize(224),\n",
        "                transforms.CenterCrop(224),\n",
        "                transforms.ToTensor(),\n",
        "                normalize,\n",
        "            ])\n",
        "    \n",
        "    ds_val = VocDataset(\"/content/VOCdevkit/VOC2012\",'val',test_transform)\n",
        "    \n",
        "    return torch.utils.data.DataLoader(dataset=ds_val,\n",
        "                                       batch_size=batch_size, \n",
        "                                       shuffle=False,\n",
        "                                       num_workers=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-cTL_rNOJgIa"
      },
      "source": [
        "# Training Pipeline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kEuOg4VAInIl"
      },
      "outputs": [],
      "source": [
        "import torchvision\n",
        "class Trainer:\n",
        "    def __init__(self, num_epoch, lr, batch_size, \n",
        "                 num_node, p, k, m,\n",
        "                 in_channels, channel,\n",
        "                 graph_mode, is_train,\n",
        "                 is_small_regime):\n",
        "        super(Trainer, self).__init__()\n",
        "\n",
        "        self.params = {'num_epoch': num_epoch,\n",
        "                       'batch_size': batch_size,\n",
        "                       'lr': lr,\n",
        "                       'node_num': num_node,\n",
        "                       'p': p,\n",
        "                       'k': k,\n",
        "                       'm': m,\n",
        "                       'in_channels': in_channels,\n",
        "                       'channel': channel,\n",
        "                       'classes': 21,\n",
        "                       'graph_mode': graph_mode,\n",
        "                       'is_train': is_train,\n",
        "                       'is_small_regime': is_small_regime\n",
        "                       }\n",
        "        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "        self.rwnn = RandomlyWiredNeuralNetwork(\n",
        "            self.params['channel'], \n",
        "            self.params['in_channels'], \n",
        "            self.params['p'],\n",
        "            self.params['k'],\n",
        "            self.params['m'],\n",
        "            self.params['graph_mode'],\n",
        "            self.params['classes'], \n",
        "            self.params['node_num'],\n",
        "            self.params['is_train'],\n",
        "            self.params['is_small_regime']\n",
        "        ).to(self.device)\n",
        "\n",
        "        if not self.params['is_train']:\n",
        "            pass\n",
        "            \n",
        "\n",
        "        pytorch_total_params = sum(p.numel() for p in self.rwnn.parameters())\n",
        "        print(f\"Number of parameters {pytorch_total_params}\")\n",
        "\n",
        "        # self.optimizer = optim.SGD(self.rwnn.parameters(), lr, 0.9, 5e-5)\n",
        "        self.optimizer = optim.Adam(self.rwnn.parameters(), lr)\n",
        "        self.scheduler = optim.lr_scheduler.StepLR(self.optimizer, step_size=30, gamma=0.5)\n",
        "\n",
        "        self.criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "    def train(self):\n",
        "          print(\"\\nbegin training...\")\n",
        "          path = '/content/' # filepath to download voc data\n",
        "          voc_train = VOC(path, \"2012\", \"train\", True)\n",
        "\n",
        "          train = get_dataloader('train', self.params['batch_size'])\n",
        "          val = get_dataloader('val', self.params['batch_size'])\n",
        "          test_set = get_dataloader('test', self.params['batch_size'])\n",
        "\n",
        "\n",
        "          for epoch in range(self.params['num_epoch']):\n",
        "              print(\"\\nEpoch: {} out of {}\".format(epoch+1, self.params['num_epoch']))\n",
        "              start_time = time.perf_counter()\n",
        "\n",
        "              epoch_loss = train_loop(train, self.rwnn, self.optimizer, self.criterion, self.device)\n",
        "              val_loss = val_loop(val, self.rwnn, self.criterion, self.device)\n",
        "\n",
        "              self.scheduler.step()\n",
        "\n",
        "              end_time = time.perf_counter()\n",
        "\n",
        "              minutes, seconds, time_left_min, time_left_sec = epoch_time(end_time-start_time, epoch, self.params['num_epoch'])\n",
        "          \n",
        "              print(f\"Train_loss: {round(epoch_loss, 3)} - Val_loss: {round(val_loss, 3)}\")\n",
        "\n",
        "              if (epoch + 1) % 5 == 0:\n",
        "                  test_voc(test_set, self.rwnn, self.criterion, self.device)\n",
        "\n",
        "              print(f\"Epoch time: {minutes}m {seconds}s - Time left for training: {time_left_min}m {time_left_sec}s\")\n",
        "\n",
        "def train_loop(train_iter, model, optimizer, criterion, device):\n",
        "    epoch_loss = 0\n",
        "    model.train()\n",
        "    \n",
        "    print(\"Training...\")\n",
        "    for src, tgt in tqdm(train_iter):\n",
        "        src = src.to(device)\n",
        "        tgt = tgt.to(device)\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        logits = model(src)\n",
        "\n",
        "        loss = criterion(logits, tgt)               \n",
        "        loss.backward()\n",
        "        \n",
        "        optimizer.step()\n",
        "\n",
        "        epoch_loss += loss.item()\n",
        "\n",
        "    return epoch_loss / len(train_iter)\n",
        "\n",
        "def val_loop(val_iter, model, criterion, device):\n",
        "    model.eval()\n",
        "    val_loss = 0\n",
        "    \n",
        "    with torch.no_grad():\n",
        "      \n",
        "      print(\"Validating...\")\n",
        "      for src, tgt in tqdm(val_iter):\n",
        "          src = src.to(device)\n",
        "          tgt = tgt.to(device)\n",
        "\n",
        "          logits = model(src)\n",
        "          \n",
        "          loss = criterion(logits, tgt) \n",
        "          \n",
        "          val_loss += loss.item()\n",
        "\n",
        "    return val_loss / len(val_iter)\n",
        "\n",
        "def test_voc(test_iter, model, criterion, device):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "\n",
        "    print(\"Testing...\")\n",
        "    with torch.no_grad():\n",
        "      y_true = np.zeros((0,21))\n",
        "      y_score = np.zeros((0,21))\n",
        "\n",
        "      for src, tgt in tqdm(test_iter):\n",
        "          src = src.to(device)\n",
        "          tgt = tgt.to(device)\n",
        "\n",
        "          logits = model(src)\n",
        "              \n",
        "          y_true = np.concatenate((y_true, tgt.cpu().numpy()), axis=0)\n",
        "          y_score = np.concatenate((y_score, logits.cpu().numpy()), axis=0)\n",
        "          loss = criterion(logits, tgt) \n",
        "          test_loss += loss.item()\n",
        "      aps = []\n",
        "      for i in range(1, y_true.shape[1]):\n",
        "          ap = average_precision_score(y_true[:, i], y_score[:, i])\n",
        "          print('-------  Class: {:<12}     AP: {:>8.4f}  -------'.format(VOC_CLASSES[i], ap))\n",
        "          aps.append(ap)\n",
        "      mAP = np.mean(aps)\n",
        "\n",
        "      test_loss /= len(test_iter)\n",
        "\n",
        "      print(f\"Test Loss: {round(test_loss, 3)}, Test Accuracy: {round(mAP,3)}\")\n",
        "\n",
        "def epoch_time(time, curr_epoch, total_epochs):\n",
        "    minutes = int(time / 60)\n",
        "    seconds = int(time % 60)\n",
        "\n",
        "    epoch_left = total_epochs - curr_epoch\n",
        "    time_left = epoch_left * time\n",
        "    time_left_min = int(time_left / 60) - minutes\n",
        "    time_left_sec = int(time_left % 60)\n",
        "\n",
        "    return minutes, seconds, time_left_min, time_left_sec    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zfNK9WeeLHBD",
        "outputId": "74dca97b-7067-485b-bdc3-cdef3e8792c1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Number of parameters 33471525\n"
          ]
        }
      ],
      "source": [
        "trainer = Trainer(\n",
        "    num_epoch=100, \n",
        "    lr=0.05, \n",
        "    batch_size=64, \n",
        "    num_node=32, \n",
        "    p=0.75, k=4, m=0,\n",
        "    in_channels=3, channel=78, \n",
        "    graph_mode='WS', \n",
        "    is_train=True,\n",
        "    is_small_regime=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "OuwC0nc2WIkf",
        "outputId": "42af8a57-a63f-44ad-b699-34ff262315bd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "begin training...\n",
            "Using downloaded and verified file: /content/VOCtrainval_11-May-2012.tar\n",
            "Extracting /content/VOCtrainval_11-May-2012.tar to /content/\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:111: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Epoch: 1 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.01it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 7.837 - Val_loss: 4.209\n",
            "Epoch time: 2m 20s - Time left for training: 231m 44s\n",
            "\n",
            "Epoch: 2 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:44<00:00,  2.02it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.282 - Val_loss: 4.156\n",
            "Epoch time: 2m 19s - Time left for training: 228m 47s\n",
            "\n",
            "Epoch: 3 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.00it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.219 - Val_loss: 4.171\n",
            "Epoch time: 2m 20s - Time left for training: 227m 15s\n",
            "\n",
            "Epoch: 4 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.02it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.186 - Val_loss: 4.034\n",
            "Epoch time: 2m 19s - Time left for training: 224m 15s\n",
            "\n",
            "Epoch: 5 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.01it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.147 - Val_loss: 4.031\n",
            "Testing...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.00it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "-------  Class: aeroplane        AP:   0.2620  -------\n",
            "-------  Class: bicycle          AP:   0.0555  -------\n",
            "-------  Class: bird             AP:   0.0869  -------\n",
            "-------  Class: boat             AP:   0.1946  -------\n",
            "-------  Class: bottle           AP:   0.0966  -------\n",
            "-------  Class: bus              AP:   0.0770  -------\n",
            "-------  Class: car              AP:   0.1538  -------\n",
            "-------  Class: cat              AP:   0.1436  -------\n",
            "-------  Class: chair            AP:   0.1858  -------\n",
            "-------  Class: cow              AP:   0.0273  -------\n",
            "-------  Class: diningtable      AP:   0.1252  -------\n",
            "-------  Class: dog              AP:   0.1344  -------\n",
            "-------  Class: horse            AP:   0.0580  -------\n",
            "-------  Class: motorbike        AP:   0.0564  -------\n",
            "-------  Class: person           AP:   0.4191  -------\n",
            "-------  Class: pottedplant      AP:   0.0583  -------\n",
            "-------  Class: sheep            AP:   0.0503  -------\n",
            "-------  Class: sofa             AP:   0.0910  -------\n",
            "-------  Class: train            AP:   0.1239  -------\n",
            "-------  Class: tvmonitor        AP:   0.0584  -------\n",
            "Test Loss: 4.031, Test Accuracy: 0.123\n",
            "Epoch time: 2m 20s - Time left for training: 222m 11s\n",
            "\n",
            "Epoch: 6 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.05s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.01it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.127 - Val_loss: 3.964\n",
            "Epoch time: 2m 20s - Time left for training: 219m 54s\n",
            "\n",
            "Epoch: 7 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:35<00:00,  1.06s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.01it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.096 - Val_loss: 4.162\n",
            "Epoch time: 2m 20s - Time left for training: 218m 3s\n",
            "\n",
            "Epoch: 8 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:35<00:00,  1.06s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 91/91 [00:45<00:00,  2.01it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train_loss: 4.113 - Val_loss: 4.029\n",
            "Epoch time: 2m 20s - Time left for training: 215m 43s\n",
            "\n",
            "Epoch: 9 out of 100\n",
            "Training...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 90/90 [01:34<00:00,  1.06s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validating...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            " 29%|██▊       | 26/91 [00:13<00:33,  1.94it/s]\n"
          ]
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-18-3435b262f1ae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-16-5be9b90964bb>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m               \u001b[0mepoch_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrwnn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcriterion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m               \u001b[0mval_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrwnn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcriterion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m               \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscheduler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-16-5be9b90964bb>\u001b[0m in \u001b[0;36mval_loop\u001b[0;34m(val_iter, model, criterion, device)\u001b[0m\n\u001b[1;32m    109\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    110\u001b[0m       \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Validating...\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 111\u001b[0;31m       \u001b[0;32mfor\u001b[0m \u001b[0msrc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtgt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    112\u001b[0m           \u001b[0msrc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msrc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    113\u001b[0m           \u001b[0mtgt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtgt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1178\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1179\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1180\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1181\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1182\u001b[0m                 \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    519\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sampler_iter\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    520\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 521\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    522\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    523\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1184\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1185\u001b[0m             \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_shutdown\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1186\u001b[0;31m             \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1187\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1188\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_get_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1150\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1151\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1152\u001b[0;31m                 \u001b[0msuccess\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_try_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1153\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0msuccess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1154\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_try_get_data\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    988\u001b[0m         \u001b[0;31m#   (bool: whether successfully get data, any: data if successful else None)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    989\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 990\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    991\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    992\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/multiprocessing/queues.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, block, timeout)\u001b[0m\n\u001b[1;32m    102\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mblock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m                     \u001b[0mtimeout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdeadline\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmonotonic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m                     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_poll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    105\u001b[0m                         \u001b[0;32mraise\u001b[0m \u001b[0mEmpty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m                 \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_poll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/multiprocessing/connection.py\u001b[0m in \u001b[0;36mpoll\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    255\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_closed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    256\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_readable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 257\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_poll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    258\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    259\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__enter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/multiprocessing/connection.py\u001b[0m in \u001b[0;36m_poll\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    413\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_poll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 414\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    415\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    416\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/multiprocessing/connection.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(object_list, timeout)\u001b[0m\n\u001b[1;32m    919\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    920\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 921\u001b[0;31m                 \u001b[0mready\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mselector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    922\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mready\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    923\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfileobj\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevents\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mready\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/selectors.py\u001b[0m in \u001b[0;36mselect\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    413\u001b[0m         \u001b[0mready\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    414\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 415\u001b[0;31m             \u001b[0mfd_event_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_selector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    416\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mInterruptedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    417\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mready\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "trainer.train()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "UJmG68z0H5VP",
        "uV4vUDvY2Ri3",
        "v1uumcnv2ccO",
        "F-phOejH20Qt"
      ],
      "machine_shape": "hm",
      "name": "RWNN.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}