v10_single_heart.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "v10-single-heart.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "_EBaK_urXiUt",
        "VizHiNgIepz3"
      ],
      "toc_visible": true,
      "mount_file_id": "1xcIId9jP3RPLAeyWC55VfEuSnxEBtl8S",
      "authorship_tag": "ABX9TyO9hZI7ghvWXlvQdMko+B7C",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/puaqieshang/automatic-labeling-heart-vessels/blob/master/v10_single_heart.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0q3bQztjs6pW",
        "colab_type": "text"
      },
      "source": [
        "# Update from Previous Version\n",
        "\n",
        "* Feed single heart into the model "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogFQbGjAd5_L",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2e9bd732-9969-4723-c94d-a0ce60ffaaa7"
      },
      "source": [
        "# Import dependencies\n",
        "\n",
        "import os\n",
        "import time\n",
        "import helper\n",
        "import numpy as np\n",
        "from tqdm import tqdm\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.utils import shuffle\n",
        "from collections import defaultdict\n",
        "\n",
        "import torch\n",
        "from torch import tensor, nn, optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "\n",
        "if torch.cuda.is_available():\n",
        "    device = torch.device(\"cuda:0\")  # you can continue like cuda:1 cuda:2....etc. \n",
        "    print(\"Running on the GPU\")\n",
        "else:\n",
        "    device = torch.device(\"cpu\")\n",
        "    print(\"Running on the CPU\")\n"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Running on the GPU\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BsXDGkEGj5wt",
        "colab_type": "text"
      },
      "source": [
        "# Data Retrieval\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4EE5l4kdHw8r",
        "colab_type": "text"
      },
      "source": [
        "<table>\n",
        "  <tr>\n",
        "    <th>Label</th>\n",
        "    <th>Class (Vessels)</th>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>0</td>\n",
        "    <td>LAD</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>1</td>\n",
        "    <td>Diagonals</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>2</td>\n",
        "    <td>Septals</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>3</td>\n",
        "    <td>LCX</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>4</td>\n",
        "    <td>Obtuse Marginal</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>5</td>\n",
        "    <td>Atrials</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>6</td>\n",
        "    <td>LCIM</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>7</td>\n",
        "    <td>Acutes</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>8</td>\n",
        "    <td>Crux</td>\n",
        "  </tr>\n",
        "    </tr>\n",
        "    <tr>\n",
        "    <td>9</td>\n",
        "    <td>Unknown</td>\n",
        "  </tr>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W8qlfLlwx8MO",
        "colab_type": "text"
      },
      "source": [
        "## Import from Google Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4B4g74MZc0dL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        },
        "outputId": "ec0bdd61-edcd-4932-9f06-1f781cd07e81"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "!unzip -uq \"/content/drive/My Drive/processed.zip\"\n",
        "!ls \"/content/\" # Lists all the files \n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly&response_type=code\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n",
            "drive  __MACOSX  processed  sample_data\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lakOOLExKLQd",
        "colab_type": "text"
      },
      "source": [
        "## Split data into Train/Validate and Test \n",
        "Ensures that these 3 data are independent of each other - remove bias\n",
        "\n",
        "*   Validation - For hyperparameter tuning and model comparison\n",
        "*   Testing - For Performance Evaluation\n",
        "\n",
        "Current ratio of Train/Validate:Test = 0.9:0.1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u4S20dbqpfR9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "10b48397-d4f6-4815-95d9-d705af67eddc"
      },
      "source": [
        "source1 = \"/content/processed\"\n",
        "\n",
        "test_dest = \"/content/test\"\n",
        "\n",
        "if not os.path.exists(test_dest):\n",
        "    os.makedirs(test_dest)\n",
        "\n",
        "folders = os.listdir(source1)\n",
        "total = 0\n",
        "import shutil\n",
        "for singleHeartFolder in folders:\n",
        "\n",
        "    if singleHeartFolder == \".DS_Store\":\n",
        "        continue\n",
        "\n",
        "\n",
        "    if np.random.rand(1) < 0.1:\n",
        "        shutil.move(f\"{source1}/{singleHeartFolder}\", f\"{test_dest}/{singleHeartFolder}\")\n",
        "\n",
        "train_folders = os.listdir(source1)\n",
        "test_folders = os.listdir(test_dest)\n",
        "\n",
        "print(f\"Total number of train/val samples are {len(train_folders)}\")\n",
        "print(f\"Total number of test samples are {len(test_folders)}\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total number of train/val samples are 290\n",
            "Total number of test samples are 35\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xb4J-jjoI5Yo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import re\n",
        "\n",
        "def getLabel(text):\n",
        "    vessels_names = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'atrials', \n",
        "                     'lcim', 'acutes', 'crux', 'unknown']\n",
        "\n",
        "    try:\n",
        "        label = re.search(\"^(.+?)-\", text).group(1)     # regex is awesome!\n",
        "    except AttributeError:\n",
        "        label = ''  \n",
        "\n",
        "    return vessels_names.index(label)\n",
        "\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7nLr3PkaLAK7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "e03b5744-8ecb-4488-bb85-21fbcc019e33"
      },
      "source": [
        "MAX_BRANCHES = 16\n",
        "\n",
        "def storeDataForSingleHeart(dest):\n",
        "\n",
        "    \n",
        "    X_singleHeart, y_singleHeart = [], []\n",
        "    allHearts = os.listdir(dest)\n",
        "\n",
        "    print(f\"There are {len(allHearts)} heart datasets\")\n",
        "    # print(allHearts)\n",
        "\n",
        "    for singleHeart in allHearts:\n",
        "\n",
        "        # # print(f\"The file is {singleHeart}\")   \n",
        "        # if (singleHeart == \".DS_Store\" ):\n",
        "        #     continue\n",
        "        X_singleBranch, y_singleBranch = [], []\n",
        "        if singleHeart == \".DS_Store\" or singleHeart == \".test.sh.swp\": continue;\n",
        "\n",
        "        file_des = f\"{dest}/{singleHeart}\"\n",
        "        flag=0\n",
        "        singleHeartFolder=os.listdir(file_des)\n",
        "        for numOfBranches, f in enumerate(singleHeartFolder, 1):\n",
        "\n",
        "            if f == \".DS_Store\": \n",
        "                flag = 1\n",
        "                continue\n",
        "            \n",
        "            # print(f)\n",
        "            # print(f'{file_des}/{f}')\n",
        "            geometry = np.genfromtxt(f'{file_des}/{f}')\n",
        "            geometry = geometry.tolist()\n",
        "                       \n",
        "            # print(geometry.shape)\n",
        "            X_singleBranch.append(geometry)\n",
        "            label = getLabel(f)\n",
        "            y_singleBranch.append(label)\n",
        "\n",
        "    # X_all, y_all = shuffle(np.array(X_all), np.array(y_all), random_state=0) # SHUFFLE?\n",
        "        if flag == 1:\n",
        "            remaining = MAX_BRANCHES - numOfBranches +1\n",
        "        else:\n",
        "            remaining = MAX_BRANCHES - numOfBranches #16 branches is max\n",
        "        for i in range(remaining):\n",
        "            zeroMatrix = np.zeros_like(geometry)\n",
        "            X_singleBranch.append(zeroMatrix)\n",
        "\n",
        "            y_singleBranch.append(9) #9 is unknown\n",
        "        \n",
        "        X_singleHeart.append(X_singleBranch)\n",
        "        y_singleHeart.append(y_singleBranch)\n",
        "\n",
        "    X_all, y_all = np.array(X_singleHeart), np.array(y_singleHeart)\n",
        "\n",
        "    return X_all, y_all\n",
        "\n",
        "dest = '/content/processed' # changes this later\n",
        "X_all, y_all = storeDataForSingleHeart(dest)\n",
        "\n",
        "\n",
        "print(X_all.shape)\n",
        "print(y_all.shape)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are 290 heart datasets\n",
            "(288, 16, 100, 4)\n",
            "(288, 16)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GnkG18rTQd79",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "0c2bf022-9bed-4056-ae1b-866aceee2e97"
      },
      "source": [
        "unique_elements, counts_elements = np.unique(y_all, return_counts=True)\n",
        "\n",
        "print(np.asarray((unique_elements, counts_elements)))\n",
        "\n",
        "print(y_all[0])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[   0    1    2    3    4    5    6    7    8    9]\n",
            " [ 286  295   35  287  195    6   68  220  480 2736]]\n",
            "[3 7 8 8 7 0 9 9 9 9 9 9 9 9 9 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vorrIKyZwZvO",
        "colab_type": "text"
      },
      "source": [
        "## Develop Custom Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-now3mxWhlcL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class HeartVesselsDataset(Dataset):\n",
        "\n",
        "    # Initialize your data, download, etc.\n",
        "    def __init__(self, attributes_data, labels):\n",
        "\n",
        "        self.x_data = attributes_data # Access dict\n",
        "        self.y_data = labels # Access dict\n",
        "        self.len = labels.shape[0]\n",
        "        \n",
        "    # USE DICTIONARY\n",
        "    def __getitem__(self, index):\n",
        "        # print(index)\n",
        "        geometry = self.x_data[index]\n",
        "        label = self.y_data[index] # Its a number\n",
        "        # print(label)\n",
        "        \n",
        "        return geometry, np.array(label)\n",
        "\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.x_data)\n",
        "\n"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4KoNEnafwq8Y",
        "colab_type": "text"
      },
      "source": [
        "Create Validation Datasets using KFold\n",
        "\n",
        "Cross validation (CV) is one of the technique used to test the effectiveness of a machine learning models, it is also a re-sampling procedure used to evaluate a model if we have a limited data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9HpQ6U3ySIs8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "08a8dec3-b885-4cc8-c10a-08876df9ed35"
      },
      "source": [
        "from sklearn.model_selection import KFold # import KFold\n",
        "X = X_all \n",
        "print(f\"Before splitting, the data has this shape - {X.shape}\")\n",
        "y = y_all\n",
        "\n",
        "kf = KFold(n_splits=4,random_state=None, shuffle=False) # Define the split - into 5 folds \n",
        "# kf.get_n_splits(X) # returns the number of splitting iterations in the cross-validator\n",
        "print(kf) \n",
        "\n",
        "for train_index, val_index in kf.split(X):\n",
        "    # print(val_index)\n",
        "    X_train, X_val = X[train_index], X[val_index]\n",
        "    y_train, y_val = y[train_index], y[val_index]\n",
        "\n",
        "\n",
        "print(f\"\\nAfter splitting, the training data has this shape - {X_train.shape}\")\n",
        "print(f\"After splitting, the validation data has this shape - {X_val.shape}\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Before splitting, the data has this shape - (288, 16, 100, 4)\n",
            "KFold(n_splits=4, random_state=None, shuffle=False)\n",
            "\n",
            "After splitting, the training data has this shape - (216, 16, 100, 4)\n",
            "After splitting, the validation data has this shape - (72, 16, 100, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6trhsNY-wp-j",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "908109f2-a680-4f49-f971-8fc4bc89ed4e"
      },
      "source": [
        "BATCH_SIZE = 16\n",
        "train_dataset = HeartVesselsDataset(X_train, y_train)\n",
        "trainloader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE,shuffle=False,num_workers=0)\n",
        "\n",
        "val_dataset = HeartVesselsDataset(X_val, y_val)\n",
        "valloader = DataLoader(dataset=val_dataset, batch_size=BATCH_SIZE,shuffle=False,num_workers=0)\n",
        "\n",
        "print(f\"Train has {len(trainloader)} batches and {train_dataset.len} datasets\")\n",
        "print(f\"Validation has {len(valloader)} batches and {val_dataset.len} datasets\")\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train has 14 batches and 216 datasets\n",
            "Validation has 5 batches and 72 datasets\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APGAYL6FxfHE",
        "colab_type": "text"
      },
      "source": [
        "## Inspecting Input - A Single Branch"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jDOQJS0Wm29G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 384
        },
        "outputId": "25f7da74-49e4-4aa2-a0b0-f0a072dc8d0d"
      },
      "source": [
        "geometries, label = next(iter(trainloader))\n",
        "\n",
        "print(geometries.shape)\n",
        "print(label.shape)\n",
        "\n",
        "# print(f\"Geo is of type {geometries.type}\")\n",
        "# print(f\"Label is of type {label.type}\")\n",
        "print(\"\\nA Random Coronary Branch\")\n",
        "print(f\"Dimension of a single heart dataset is {geometries[0].shape}\")\n",
        "print(f\"Dimension of a single branch is {geometries[0][0].shape}\")\n",
        "\n",
        "plt.imshow(geometries[0][0].view(20, 20))\n",
        "plt.show()\n",
        "print(f\"The label is {label[0][0]}\")"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([16, 16, 100, 4])\n",
            "torch.Size([16, 16])\n",
            "\n",
            "A Random Coronary Branch\n",
            "Dimension of a single heart dataset is torch.Size([16, 100, 4])\n",
            "Dimension of a single branch is torch.Size([100, 4])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD4CAYAAADl7fPiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAATAElEQVR4nO3dfYxcV33G8e8z4zdstt7YDk7iuAFBGtVFxCDLFDVtkwJpEkUYKkodVSW0qZwiIhWpqEpbiSD6D1VFaUsQYMBKqCCkbyYWWEmstFJA4iVL5LxB0rhRaLyYGHDid3u9u7/+sddoz3pmfc7M3J3Z5flI1s7ce/bOb+6uH8/c+fkcRQRmZmc1+l2AmQ0Wh4KZJRwKZpZwKJhZwqFgZolF/S6glRUXLInhS5b3/LgvHxzKHvuKNSezxy5rnMkaN4myj3m4z7XCgNTbLKg3el9vSa2vKKh1ooZaIb/eYweOcerlUy2LGMhQGL5kOe+/96qssSW/uPf94zXZYzfe+nj22NctP5g17tTk4uxjfu2ffjt7bB21wmDU+ysrfpw99sTE0uyxufWW1PqrKw5kjz06sSx7bB3n9r73fq3tPr99MLNEV6Eg6TpJz0jaJ+n2FvuXSrq32v8dSa/u5vHMrH4dh4KkJvAp4HpgA3CTpA0zht0CvBQRrwM+Afxdp49nZnOjm1cKm4F9EfFcRIwBXwG2zBizBbi7uv3vwFsl5V8EMLM5100orANemHZ/f7Wt5ZiIGAcOA6tbHUzSNkkjkkaOvzTWRVlm1o2BudAYEdsjYlNEbFpxwZJ+l2P2C6ubUBgF1k+7f2m1reUYSYuAlcDPunhMM6tZN6HwCHC5pNdIWgJsBXbNGLMLuLm6/W7gv8L/V9tsoHXcvBQR45JuAx4AmsCOiHhK0keBkYjYBXwB+BdJ+4BDTAWHmQ2wrjoaI2I3sHvGtg9Pu30K+P3S4zY0yfLm6ayxh8d73w5d6pXNU1njSjoE67KyeSJ77InJ4RorybOymd9mfKygS7Cgyzhbybk9NL6i9wX0yMBcaDSzweBQMLOEQ8HMEg4FM0s4FMws4VAws4RDwcwSDgUzSzgUzCzhUDCzxEBO3LqISVY1j2WN/emZ/Jlu6zKc2d56YKygbbim/zaWWyvA/rFV2WM12Uk15zfcPJ499v+i5VQdLTXGO6lmdiXntoQmajlsW36lYGYJh4KZJRwKZpZwKJhZwqFgZgmHgpklHApmluhmhaj1kv5b0vclPSXpz1uMuVrSYUl7qz8fbnUsMxsc3TQvjQN/ERGPShoCvidpT0R8f8a4b0TEjV08jpnNoY5fKUTEgYh4tLp9FPgB564QZWbzTE/anKvVpN8IfKfF7rdIegz4EfChiHiqzTG2AdsALrxkcS0toyXtoo2Cvt2SVtxcJW3DZbXmn9fJkimPC9qyi+pt1FRvppJaV2e25gOciWYn5ZxXbr1S+x9Y1xcaJb0S+A/ggxFxZMbuR4HLIuJK4JPAV9sdZ/qycb+0aiD/S4bZL4SuQkHSYqYC4UsR8Z8z90fEkYg4Vt3eDSyWtKabxzSzenXz6YOYWgHqBxHxD23GXHR26XlJm6vH81qSZgOsm9fpvwH8EfCEpL3Vtr8GfhkgIj7D1PqR75c0DpwEtnotSbPB1s1akt8EZr2yExF3And2+hhmNvfc0WhmCYeCmSUcCmaWcCiYWcKhYGaJgWwdbGoyux339GT/n0JuK+58qhXqa8Utsbqghbzf9Q43TmaPraMlu1f8SsHMEg4FM0s4FMws4VAws4RDwcwSDgUzSzgUzCzhUDCzhEPBzBL9b7Frockkw41TPT/uLHNVdmXVfKq12ftaob56hxtjtRy3jnpXNs5kj20UFFDXuW3HrxTMLOFQMLNEL6Z4f17SE9WycCMt9kvSP0vaJ+lxSW/q9jHNrD69uqZwTUT8tM2+64HLqz9vBj5dfTWzATQXbx+2AF+MKd8GhiVdPAePa2Yd6EUoBPCgpO9VS7/NtA54Ydr9/bRYc1LSNkkjkkZePlSwZpqZ9VQv3j5cFRGjkl4F7JH0dEQ8XHqQiNgObAfY8IYlXhvCrE+6fqUQEaPV14PATmDzjCGjwPpp9y+ttpnZAOp2LckVkobO3gauBZ6cMWwX8N7qU4hfBw5HxIFuHtfM6tPt24e1wM5quchFwJcj4n5JfwY/XzpuN3ADsA84Afxxl49pZjXqKhQi4jngyhbbPzPtdgAfKCsqGG6MZ41drIn8A9d0pWKokXdhdGnmcwLqq7WgZ7akXk3UU/DygvlNlzfzW6IbZ3pf74pGfrHLClqim2Nze4nNHY1mlnAomFnCoWBmCYeCmSUcCmaWcCiYWcKhYGYJh4KZJRwKZpZwKJhZYiBnc25ILFdey2hJa2td7aLLcmstmJl40em6as3/d2CoYObnZn7XbpGSel9ZUG9jvPfnd2lBrSubJ7PH1tVC3o5fKZhZwqFgZgmHgpklHApmlnAomFnCoWBmCYeCmSU6DgVJV1RLxZ39c0TSB2eMuVrS4WljPtx9yWZWp46blyLiGWAjgKQmU9O272wx9BsRcWOnj2Nmc6tXbx/eCvxvRPywR8czsz7pVZvzVuCeNvveIukx4EfAhyLiqVaDqiXntgFcuq7J4syW0ZJ20UZN7aLL1Mwat3LRiexjarKeWpcq/0e+sjnf6i1oHa5hZcJltZ3bTqrpXC+Wol8CvAP4txa7HwUui4grgU8CX213nIjYHhGbImLTmtW+/mnWL73423c98GhEvDhzR0QciYhj1e3dwGJJa3rwmGZWk16Ewk20eesg6SJVy0dJ2lw93s968JhmVpOurilU60e+Hbh12rbpS8a9G3i/pHHgJLC1WjHKzAZUt8vGHQdWz9g2fcm4O4E7u3kMM5tbvqJnZgmHgpklHApmlnAomFnCoWBmicGczRmxXEuyxg4VtLZS04ehS7U4a9xQo79tuFDWNlwym/Mg1DvcPJ49VjX8LuT+HgAML+Q2ZzNbWBwKZpZwKJhZwqFgZgmHgpklHApmlnAomFnCoWBmCYeCmSUcCmaWGMg2ZyEWZ86QPAjtovXUWk9PdjNzlmyA1c1j2WMHod7hRsH5rWlm71xFLdk1ndt2/ErBzBJZoSBph6SDkp6ctm2VpD2Snq2+XtDme2+uxjwr6eZeFW5m9ch9pXAXcN2MbbcDD0XE5cBD1f2EpFXAHcCbgc3AHe3Cw8wGQ1YoRMTDwKEZm7cAd1e37wbe2eJbfxfYExGHIuIlYA/nhouZDZBurimsjYgD1e0fA2tbjFkHvDDt/v5qm5kNqJ5caKzWcujqEqmkbZJGJI385GcTvSjLzDrQTSi8KOligOrrwRZjRoH10+5fWm07x/S1JC9cnfcRn5n1XjehsAs4+2nCzcB9LcY8AFwr6YLqAuO11TYzG1C5H0neA3wLuELSfkm3AB8D3i7pWeBt1X0kbZL0eYCIOAT8LfBI9eej1TYzG1BZHY0RcVObXW9tMXYE+NNp93cAOzqqzszm3EC2OZcoaW1tjPe3tbWobXg8/7jNOqYmpvDcjuXXUFu9BW3kufWW1DoR+X30w42x7LHN03N7bt3mbGYJh4KZJRwKZpZwKJhZwqFgZgmHgpklHApmlnAomFnCoWBmCYeCmSUGss05iOyW0eHG6ezjNsby21BL2kXPRN78D0ONM/mPX1BridxaAYYKWnFLzm2J05F/zobU3/N7OvJ700t+F+o6t20fb04fzcwGnkPBzBIOBTNLOBTMLOFQMLOEQ8HMEg4FM0ucNxTarCP595KelvS4pJ2Shtt87/OSnpC0V9JILws3s3rkvFK4i3OXetsDvD4i3gD8D/BXs3z/NRGxMSI2dVaimc2l84ZCq3UkI+LBiJ+3b32bqUVezGwB6EWb858A97bZF8CDkgL4bERsb3cQSduAbQDr1zU5GXkttkON/NbSktbWRsEqeCdya1V+i3FJa2tJrccm89vCl6ugLfxMPfUencxvtV7RyD9u7vktOrcFLdnLCtroG2MFvzeZ9WqWfV2FgqS/AcaBL7UZclVEjEp6FbBH0tPVK49zVIGxHeCNVy7p71zsZr/AOv70QdL7gBuBP6wWmD1HRIxWXw8CO4HNnT6emc2NjkJB0nXAXwLviIiWK3BIWiFp6OxtptaRfLLVWDMbHDkfSbZaR/JOYIiptwR7JX2mGnuJpN3Vt64FvinpMeC7wNcj4v5anoWZ9cx5rym0WUfyC23G/gi4obr9HHBlV9WZ2ZxzR6OZJRwKZpZwKJhZwqFgZgmHgpklBnI258kIjk7mtS8vna1fc4bG6fx20RJHJ/OOu2wQas2cJRsK6z2Z325e4uhkfnPrikZ+wc1Tva+3pNaVfa51Nn6lYGYJh4KZJRwKZpZwKJhZwqFgZgmHgpklHApmlnAomFnCoWBmicHsaAROZDaHlXSG1dV1dyLyariwpIvtRP6EpSWOT+b/O3BRM/+4jRP5k5aWOBH5RQwXTLLaqOH8Ho/8v06rKJjo9nj+ZLu94FcKZpZwKJhZotNl4z4iabSan3GvpBvafO91kp6RtE/S7b0s3Mzq0emycQCfqJaD2xgRu2fulNQEPgVcD2wAbpK0oZtizax+HS0bl2kzsC8inouIMeArwJYOjmNmc6ibawq3VatO75B0QYv964AXpt3fX21rSdI2SSOSRg4dyr8ya2a91WkofBp4LbAROAB8vNtCImJ7RGyKiE2rVvn6p1m/dPS3LyJejIiJiJgEPkfr5eBGgfXT7l9abTOzAdbpsnEXT7v7LlovB/cIcLmk10haAmwFdnXyeGY2d87bglUtG3c1sEbSfuAO4GpJG5laav554NZq7CXA5yPihogYl3Qb8ADQBHZExFO1PAsz65nalo2r7u8Gzvm48nwmEEcnF2eNXdXIn+C0cfxUaSlZcmu9sJHfZq26ao28WgEuIr91uXH8ZCflnFdJ6zAF9epYy3WRu3KqoCWbgjZnHTleXkwXfEXPzBIOBTNLOBTMLOFQMLOEQ8HMEg4FM0s4FMws4VAws4RDwcwSDgUzSwzkbM6BmCBv5uOG8mdI1pFj2WMnMx+/REmtHK6n1iUlswgX1BsvH8keOxD1vnQ4a1xJrctU0HJfUOvkkaP5YzPrnW3ea79SMLOEQ8HMEg4FM0s4FMws4VAws4RDwcwSDgUzS+TM0bgDuBE4GBGvr7bdC1xRDRkGXo6IjS2+93ngKDABjEfEph7VbWY1yWleugu4E/ji2Q0R8Qdnb0v6ODBbJ8g1EfHTTgs0s7mVM3Hrw5Je3WqfJAHvAX6nt2WZWb902+b8m8CLEfFsm/0BPCgpgM9GxPZ2B5K0DdgGcPG6ZnbLaLOgDXXyaH7rcInlypuleXHB6Y7j9czgu7xgRullWpI9Nk7WM5vzUCN/huZlWpo9NsbGssZNRP7v13DRue19rQAT0f1lwm5D4Sbgnln2XxURo5JeBeyR9HS1YO05qsDYDvBrb1gyW2u2mdWo41iRtAj4PeDedmMiYrT6ehDYSevl5cxsgHTzWuNtwNMRsb/VTkkrJA2dvQ1cS+vl5cxsgJw3FKpl474FXCFpv6Rbql1bmfHWQdIlks6uCLUW+Kakx4DvAl+PiPt7V7qZ1aHTZeOIiPe12PbzZeMi4jngyi7rM7M55o5GM0s4FMws4VAws4RDwcwSDgUzSwzkbM5NgpWNvDbnpXpF9nFjLL9ldiKa2WOHG3kzDi9VQZtzUWvr4uyxwwX/DCwi/xxMFp3b/PbplY38NuOiek+fzhy5LPuYQ8o/uY2Cf48ju1aYjBV5x5ylfduvFMws4VAws4RDwcwSDgUzSzgUzCzhUDCzhEPBzBIOBTNLOBTMLOFQMLOEIgZvjlRJPwF+OGPzGmAhrh+xUJ8XLNznthCe12URcWGrHQMZCq1IGlmIK0wt1OcFC/e5LdTndZbfPphZwqFgZon5FAptV5ea5xbq84KF+9wW6vMC5tE1BTObG/PplYKZzQGHgpkl5kUoSLpO0jOS9km6vd/19Iqk5yU9IWmvpJF+19MNSTskHZT05LRtqyTtkfRs9fWCftbYiTbP6yOSRquf215JN/Szxl4b+FCQ1AQ+BVwPbABukrShv1X11DURsXEBfO59F3DdjG23Aw9FxOXAQ9X9+eYuzn1eAJ+ofm4bI2J3i/3z1sCHAlMrVe+LiOciYgz4CrClzzXZDBHxMHBoxuYtwN3V7buBd85pUT3Q5nktaPMhFNYBL0y7v7/athAE8KCk70na1u9iarA2Ig5Ut3/M1KLDC8Vtkh6v3l7Mu7dFs5kPobCQXRURb2LqrdEHJP1WvwuqS0x99r1QPv/+NPBaYCNwAPh4f8vprfkQCqPA+mn3L622zXsRMVp9PQjsZOqt0kLyoqSLAaqvB/tcT09ExIsRMRERk8DnWGA/t/kQCo8Al0t6jaQlwFZgV59r6pqkFZKGzt4GrgWenP275p1dwM3V7ZuB+/pYS8+cDbrKu1hgP7eBXCFquogYl3Qb8ADQBHZExFN9LqsX1gI7JcHUz+HLEXF/f0vqnKR7gKuBNZL2A3cAHwP+VdItTP1X+Pf0r8LOtHleV0vayNTboeeBW/tWYA3c5mxmifnw9sHM5pBDwcwSDgUzSzgUzCzhUDCzhEPBzBIOBTNL/D/hSZkDG45YxwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "The label is 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ckegxusw6uVv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8e885401-cd8e-45c6-9a97-ee4ebaf2334e"
      },
      "source": [
        "print(label[0][0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(7)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xv9OG9k3kAjA",
        "colab_type": "text"
      },
      "source": [
        "# Model Definition\n",
        "\n",
        "So that different model architectures can work interchangeable\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7dBvPPD73SN",
        "colab_type": "text"
      },
      "source": [
        "## Linear Layers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b9wlmug-LeLy",
        "colab_type": "text"
      },
      "source": [
        "### Model 1 - nn.Linear in Sequential Form\n",
        "\n",
        "A simple Multi-Layer Perceptron, but achieves accuracy of 0.78 - 0.8 after 350 epochs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQy8VcNALcrc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# model = nn.Sequential(nn.Linear(400,128), nn.ReLU(), nn.Linear(128,64), \n",
        "#                       nn.ReLU(), nn.Linear(64,9), nn.LogSoftmax(dim=1))\n",
        "\n",
        "# model = model.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZ8LPLeb1dHQ",
        "colab_type": "text"
      },
      "source": [
        "### Model 2 - nn.Linear in Class form \n",
        "Basically same as Model 1, just that its in nn.functional() form. This allows user to tune the parameters more, which is better. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSpsZlv2B9be",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# # Start Timer\n",
        "# t0 = time.time()\n",
        "\n",
        "\n",
        "# class ConvNN(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super().__init__()\n",
        "#         # Defining the layers, 128, 64, 9 units each\n",
        "#         self.fc1 = nn.Linear(400, 128)\n",
        "#         self.fc2 = nn.Linear(128, 64)\n",
        "#         # Output layer, 9 units - one for each digit\n",
        "#         self.fc3 = nn.Linear(64, 9)\n",
        "        \n",
        "#     def forward(self, x):\n",
        "#         ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "#         x = self.fc1(x)\n",
        "#         x = F.relu(x)\n",
        "#         x = self.fc2(x)\n",
        "#         x = F.relu(x)\n",
        "#         x = self.fc3(x)\n",
        "#         x = F.log_softmax(x, dim=1)\n",
        "        \n",
        "#         return x\n",
        "\n",
        "\n",
        "# model = ConvNN()\n",
        "# model = model.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "voy06Xl8797G",
        "colab_type": "text"
      },
      "source": [
        "## Convolutional Layers\n",
        "\n",
        "Suggestions to Improve:\n",
        "* Use He Initialization for ReLU layers instead of random or zero initiliazation. Refer to roadmap\n",
        "* Use more regularization techniques (if necessary)\n",
        "\n",
        "Things to note:\n",
        "* Increasing number of layers by more than 2 do not improve the accuracy - could be due to my model being simple?\n",
        "* No need to have a lot of nodes in a hidden layer; the input is not a 2D image anyways.\n",
        "* [Dropout Layers FAQ ](https://https://stats.stackexchange.com/questions/240305/where-should-i-place-dropout-layers-in-a-neural-network )\n",
        "* Dropout layers may result in [Test Accuracy > Train Accuracy](https://www.quora.com/How-can-I-explain-the-fact-that-test-accuracy-is-much-higher-than-train-accuracy)  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aSq31moBhyNi",
        "colab_type": "text"
      },
      "source": [
        "### Model 3 - Conv1D with 3 Hidden Layers\n",
        "\n",
        "Tested on different pooling layers:\n",
        "*   Max Pooling\n",
        "*   Average Pooling\n",
        "*   Global Max Pooling\n",
        "*   Global Average Pooling\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wGcAZPPMhxWD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvNN_single_heart(nn.Module):\n",
        "\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        \n",
        "        # Input Tensor [batch, in_channels, in_width]\n",
        "\n",
        "        # Random Initialization\n",
        "        # input = (batch_size, no of channels, height, width)\n",
        "        x = torch.rand(16, 100, 4).view(-1, 4, 16, 100)\n",
        "\n",
        "        # He initialization variants\n",
        "        # x = torch.empty(100, 4).view(-1, 4, 100)    \n",
        "        # x = nn.init.kaiming_uniform_(x, mode='fan_out', nonlinearity='relu')\n",
        "        # x = nn.init.kaiming_normal_(x, mode='fan_in', nonlinearity='relu')\n",
        "\n",
        "        # Defining the layers, 4, 8, 16 and 32 units each\n",
        "        self.conv1 = nn.Conv2d(in_channels=4, out_channels=16, kernel_size = (1,3))\n",
        "        self.conv2 = nn.Conv2d(in_channels=16, out_channels=64, kernel_size = (1,3))\n",
        "        self.conv3 = nn.Conv2d(in_channels=64, out_channels=256, kernel_size = (1,3))\n",
        "        self.conv4 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=(1,3))\n",
        "        self.conv5 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=(1,3))\n",
        "\n",
        "        # Activated during eval mode\n",
        "        self.conv1_bn = nn.BatchNorm2d(16)\n",
        "        self.conv2_bn = nn.BatchNorm2d(64)\n",
        "        self.conv3_bn = nn.BatchNorm2d(256)\n",
        "        self.conv4_bn = nn.BatchNorm2d(512)\n",
        "        self.fc1_bn = nn.BatchNorm1d(128)\n",
        "        self.fc2_bn = nn.BatchNorm1d(32)\n",
        "    \n",
        "        self.fc_dropout = nn.Dropout(p=0.5)\n",
        "        self.conv_dropout = nn.Dropout(p=0.1)\n",
        "        \n",
        "        self._to_linear = None\n",
        "        # Time distributed layer - maybe change to keras\n",
        "        self.convs(x)\n",
        "        \n",
        "        # self.fc1 = nn.Linear(self._to_linear, 64) #flattening.\n",
        "        # self.fc2 = nn.Linear(64, 9) # 64 in, 9out bc we're doing 9 classes \n",
        "\n",
        "        self.fc1 = nn.Linear(self._to_linear, 128) #flattening.\n",
        "        self.fc2 = nn.Linear(128, 32)\n",
        "        self.fc3 = nn.Linear(32, 10) # 10 labels\n",
        "\n",
        "    def convs(self, x):\n",
        "        # max pooling over 2\n",
        "        \n",
        "        x = self.conv1(x)\n",
        "        x = self.conv1_bn(x)  \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)    \n",
        "        x = F.max_pool2d(x, (1,2)) #or Elu\n",
        "\n",
        "        # print(x.shape)\n",
        "        x = self.conv2(x)\n",
        "        x = self.conv2_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool2d(x, (1,2)) #or Elu\n",
        "\n",
        "        # print(x.shape)\n",
        "        x = self.conv3(x)\n",
        "        x = self.conv3_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool2d(x, (1,2)) #or Elu\n",
        "        \n",
        "        x = self.conv4(x)\n",
        "        x = self.conv4_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool2d(x, (1,2)) #or Elu\n",
        "\n",
        "        x = self.conv5(x)\n",
        "        x = self.conv4_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool2d(x, (1,2)) #or Elu\n",
        "        \n",
        "        \n",
        "        if self._to_linear is None:\n",
        "            self._to_linear = x[0].shape[0]*x[0].shape[2]\n",
        "            \n",
        "        return x\n",
        "        \n",
        "    def forward(self, x):\n",
        "        ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "        x = self.convs(x)\n",
        "        # .view is reshape ... this flattens X before going to FC layer\n",
        "       \n",
        "        # print(x.shape)\n",
        "        x = x.view(-1, 16, self._to_linear)  \n",
        "        # print(x.shape)\n",
        "        x = self.fc1(x)\n",
        "        # print(x.shape)\n",
        "        x = x.view(-1, x.shape[2], x.shape[1])\n",
        "        x = self.fc1_bn(x)\n",
        "        x = F.relu(x)\n",
        "        x = self.fc_dropout(x) \n",
        "\n",
        "        # print(x.shape)\n",
        "        x = x.view(-1, x.shape[2], x.shape[1])\n",
        "        x = self.fc2(x) # bc this is our output layer. No activation here.\n",
        "        # print(x.shape)\n",
        "        x = x.view(-1, x.shape[2], x.shape[1])\n",
        "        \n",
        "        x = self.fc2_bn(x)\n",
        "        x = F.relu(x)\n",
        "        x = self.fc_dropout(x)   \n",
        "\n",
        "        # print(x.shape)\n",
        "        x = x.view(-1, x.shape[2], x.shape[1])\n",
        "        x = self.fc3(x)\n",
        "\n",
        "        # print(x.shape)\n",
        "        return F.log_softmax(x, dim=1)\n",
        "        \n",
        "        \n",
        "        return x\n"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_EBaK_urXiUt",
        "colab_type": "text"
      },
      "source": [
        "###Different Pooling Layers\n",
        "Suboptimal models with varying pooling layers are shelved"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z_zrDOKDmlSi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvNN_avgpool(nn.Module):\n",
        "\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        \n",
        "        # Input Tensor [batch, in_channels, in_width]\n",
        "\n",
        "        # Random Initialization\n",
        "        x = torch.rand(100, 4).view(-1, 4, 100)\n",
        "\n",
        "        # He initialization variants\n",
        "        # x = torch.empty(100, 4).view(-1, 4, 100)    \n",
        "        # x = nn.init.kaiming_uniform_(x, mode='fan_out', nonlinearity='relu')\n",
        "        # x = nn.init.kaiming_normal_(x, mode='fan_in', nonlinearity='relu')\n",
        "\n",
        "        # Defining the layers, 4, 8, 16 and 32 units each\n",
        "        self.conv1 = nn.Conv1d(in_channels=4, out_channels=16, kernel_size=3)\n",
        "        self.conv2 = nn.Conv1d(in_channels=16, out_channels=64, kernel_size=3)\n",
        "        self.conv3 = nn.Conv1d(in_channels=64, out_channels=256, kernel_size=3)\n",
        "\n",
        "        # Activated during eval mode\n",
        "        self.conv1_bn = nn.BatchNorm1d(16)\n",
        "        self.conv2_bn = nn.BatchNorm1d(64)\n",
        "        self.conv3_bn = nn.BatchNorm1d(256)\n",
        "        self.fc1_bn = nn.BatchNorm1d(128)\n",
        "        self.fc2_bn = nn.BatchNorm1d(32)\n",
        "    \n",
        "        self.fc_dropout = nn.Dropout(p=0.5)\n",
        "        self.conv_dropout = nn.Dropout(p=0.1)\n",
        "        \n",
        "        self._to_linear = None\n",
        "        # Time distributed layer - maybe change to keras\n",
        "        self.convs(x)\n",
        "        \n",
        "        # self.fc1 = nn.Linear(self._to_linear, 64) #flattening.\n",
        "        # self.fc2 = nn.Linear(64, 9) # 64 in, 9out bc we're doing 9 classes \n",
        "\n",
        "        self.fc1 = nn.Linear(self._to_linear, 128) #flattening.\n",
        "        self.fc2 = nn.Linear(128, 32)\n",
        "        self.fc3 = nn.Linear(32, 9)\n",
        "\n",
        "    def convs(self, x):\n",
        "        # max pooling over 2\n",
        "        \n",
        "        x = self.conv1(x)\n",
        "        x = self.conv1_bn(x)  \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)    \n",
        "        # print(x.shape)\n",
        "        # x = F.max_pool1d(x, 2, 1) # (input, kernel_size, stride) \n",
        "        # kernel_size will downsize a 2x2 matrix into a single pixel/number\n",
        "        x = F.avg_pool1d(x, kernel_size=3, stride=2)\n",
        "        # print(x.shape)\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.conv2_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "\n",
        "        # print(x.shape)\n",
        "        # x = F.max_pool1d(x, 2, 1) # (input, kernel_size, stride) \n",
        "        # kernel_size will downsize a 2x2 matrix into a single pixel/number\n",
        "        x = F.avg_pool1d(x, kernel_size=3, stride=2)\n",
        "        # print(x.shape)\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.conv3_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "\n",
        "        # print(x.shape)\n",
        "        # x = F.max_pool1d(x, 2, 1) # (input, kernel_size, stride) \n",
        "        # kernel_size will downsize a 2x2 matrix into a single pixel/number\n",
        "        x = F.avg_pool1d(x, kernel_size=3, stride=2)\n",
        "        # print(x.shape)\n",
        "        \n",
        "        if self._to_linear is None:\n",
        "            self._to_linear = x[0].shape[0]*x[0].shape[1]\n",
        "            \n",
        "        return x\n",
        "        \n",
        "    def forward(self, x):\n",
        "        ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "\n",
        "        x = self.convs(x)\n",
        "        # .view is reshape ... this flattens X before going to FC layer\n",
        "        x = x.view(-1, self._to_linear)  \n",
        "\n",
        "        x = self.fc1(x)\n",
        "        x = self.fc1_bn(x)\n",
        "        x = F.relu(x)\n",
        "        x = self.fc_dropout(x) \n",
        "\n",
        "        x = self.fc2(x) # bc this is our output layer. No activation here.\n",
        "        x = self.fc2_bn(x)\n",
        "        x = F.relu(x)\n",
        "        x = self.fc_dropout(x)   \n",
        "\n",
        "        x = self.fc3(x)\n",
        "        # print(x.shape)\n",
        "        return F.log_softmax(x, dim=1)\n",
        "        \n",
        "        return x\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wd-7Kc-Y8Bn4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvNN_GAP(nn.Module):\n",
        "\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        \n",
        "        # Input Tensor [batch, in_channels, in_width]\n",
        "\n",
        "        # Random Initialization\n",
        "        x = torch.rand(100, 4).view(-1, 4, 100)\n",
        "\n",
        "        # He initialization variants\n",
        "        # x = torch.empty(100, 4).view(-1, 4, 100)    \n",
        "        # x = nn.init.kaiming_uniform_(x, mode='fan_out', nonlinearity='relu')\n",
        "        # x = nn.init.kaiming_normal_(x, mode='fan_in', nonlinearity='relu')\n",
        "\n",
        "        # Defining the layers, 4, 8, 16 and 32 units each\n",
        "        self.conv1 = nn.Conv1d(in_channels=4, out_channels=16, kernel_size=3)\n",
        "        self.conv2 = nn.Conv1d(in_channels=16, out_channels=64, kernel_size=3)\n",
        "        self.conv3 = nn.Conv1d(in_channels=64, out_channels=256, kernel_size=3)\n",
        "\n",
        "        # Activated during eval mode\n",
        "        self.conv1_bn = nn.BatchNorm1d(16)\n",
        "        self.conv2_bn = nn.BatchNorm1d(64)\n",
        "        self.conv3_bn = nn.BatchNorm1d(256)\n",
        "        self.fc1_bn = nn.BatchNorm1d(128)\n",
        "        self.fc2_bn = nn.BatchNorm1d(32)\n",
        "    \n",
        "        self.fc_dropout = nn.Dropout(p=0.5)\n",
        "        self.conv_dropout = nn.Dropout(p=0.1)\n",
        "        \n",
        "        self._to_linear = None\n",
        "        # Time distributed layer - maybe change to keras\n",
        "        self.convs(x)\n",
        "        \n",
        "        # self.fc1 = nn.Linear(self._to_linear, 64) #flattening.\n",
        "        # self.fc2 = nn.Linear(64, 9) # 64 in, 9out bc we're doing 9 classes \n",
        "\n",
        "        self.fc1 = nn.Linear(256, 9) #flattening.\n",
        "        # self.fc2 = nn.Linear(16, 9)\n",
        "\n",
        "    def convs(self, x):\n",
        "        # max pooling over 2\n",
        "        \n",
        "        x = self.conv1(x)\n",
        "        x = self.conv1_bn(x)  \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)    \n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.conv2_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.conv3_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "        \n",
        "        if self._to_linear is None:\n",
        "            self._to_linear = x[0].shape[0]*x[0].shape[1]\n",
        "            \n",
        "        return x\n",
        "        \n",
        "    def forward(self, x):\n",
        "        ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "        x = self.convs(x)\n",
        "        # print(x.shape)\n",
        "        # .view is reshape ... this flattens X before going to FC layer\n",
        "        # x = x.view(-1, self._to_linear)  \n",
        "        \n",
        "        x = torch.mean(x,dim=2)\n",
        "        # print(x.shape)\n",
        "        # print(x)\n",
        "        x = self.fc_dropout(x)\n",
        "        x = self.fc1(x) # bc this is our output layer. No activation here.\n",
        "        # print(x.shape)\n",
        "\n",
        "        # x = self.fc2_bn(x)\n",
        "        # x = F.relu(x)\n",
        "        # x = self.fc_dropout(x)   \n",
        "\n",
        "        return F.log_softmax(x, dim=1)\n",
        "        \n",
        "        return x\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YjGitBb88HsF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvNN_GMP(nn.Module):\n",
        "\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        \n",
        "        # Input Tensor [batch, in_channels, in_width]\n",
        "\n",
        "        # Random Initialization\n",
        "        x = torch.rand(100, 4).view(-1, 4, 100)\n",
        "\n",
        "        # He initialization variants\n",
        "        # x = torch.empty(100, 4).view(-1, 4, 100)    \n",
        "        # x = nn.init.kaiming_uniform_(x, mode='fan_out', nonlinearity='relu')\n",
        "        # x = nn.init.kaiming_normal_(x, mode='fan_in', nonlinearity='relu')\n",
        "\n",
        "        # Defining the layers, 4, 8, 16 and 32 units each\n",
        "        self.conv1 = nn.Conv1d(in_channels=4, out_channels=16, kernel_size=3)\n",
        "        self.conv2 = nn.Conv1d(in_channels=16, out_channels=64, kernel_size=3)\n",
        "        self.conv3 = nn.Conv1d(in_channels=64, out_channels=256, kernel_size=3)\n",
        "\n",
        "        # Activated during eval mode\n",
        "        self.conv1_bn = nn.BatchNorm1d(16)\n",
        "        self.conv2_bn = nn.BatchNorm1d(64)\n",
        "        self.conv3_bn = nn.BatchNorm1d(256)\n",
        "        self.fc1_bn = nn.BatchNorm1d(128)\n",
        "        self.fc2_bn = nn.BatchNorm1d(32)\n",
        "    \n",
        "        self.fc_dropout = nn.Dropout(p=0.5)\n",
        "        self.conv_dropout = nn.Dropout(p=0.1)\n",
        "        \n",
        "        self._to_linear = None\n",
        "        # Time distributed layer - maybe change to keras\n",
        "        self.convs(x)\n",
        "        \n",
        "        # self.fc1 = nn.Linear(self._to_linear, 64) #flattening.\n",
        "        # self.fc2 = nn.Linear(64, 9) # 64 in, 9out bc we're doing 9 classes \n",
        "\n",
        "        self.fc1 = nn.Linear(256, 9) #flattening.\n",
        "        # self.fc2 = nn.Linear(16, 9)\n",
        "\n",
        "    def convs(self, x):\n",
        "        # max pooling over 2\n",
        "        \n",
        "        x = self.conv1(x)\n",
        "        x = self.conv1_bn(x)  \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)    \n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.conv2_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.conv3_bn(x)   \n",
        "        x = F.relu(x)\n",
        "        x = self.conv_dropout(x)\n",
        "        x = F.max_pool1d(x, 2) #or Elu\n",
        "        \n",
        "        if self._to_linear is None:\n",
        "            self._to_linear = x[0].shape[0]*x[0].shape[1]\n",
        "            \n",
        "        return x\n",
        "        \n",
        "    def forward(self, x):\n",
        "        ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "        x = self.convs(x)\n",
        "        # print(x.shape)\n",
        "        # .view is reshape ... this flattens X before going to FC layer\n",
        "        # x = x.view(-1, self._to_linear)  \n",
        "        \n",
        "        x, _ = torch.max(x,dim=2)\n",
        "        # print(x.shape)\n",
        "        # print(x.shape)\n",
        "        # print(x)\n",
        "        x = self.fc_dropout(x)\n",
        "        x = self.fc1(x) # bc this is our output layer. No activation here.\n",
        "        # print(x.shape)\n",
        "\n",
        "        # x = self.fc2_bn(x)\n",
        "        # x = F.relu(x)\n",
        "        # x = self.fc_dropout(x)   \n",
        "\n",
        "        return F.log_softmax(x, dim=1)\n",
        "        \n",
        "        return x\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VizHiNgIepz3",
        "colab_type": "text"
      },
      "source": [
        "### Model 4 - Conv1D with 2 Layers\n",
        "\n",
        "The node layers and numbers are based on multiple websites:\n",
        "https://stats.stackexchange.com/questions/181/how-to-choose-the-number-of-hidden-layers-and-nodes-in-a-feedforward-neural-netw\n",
        "\n",
        "https://www.researchgate.net/post/In_neural_networks_model_which_number_of_hidden_units_to_select\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_7UrOf4aBgpe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# class ConvNN(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super().__init__()\n",
        "        \n",
        "#         # Input Tensor [batch, in_channels, in_width]\n",
        "#         x = torch.randn(100, 4).view(-1, 4, 100)\n",
        "\n",
        "        \n",
        "#         self.conv1 = nn.Conv1d(in_channels=4, out_channels=7, kernel_size=3) \n",
        "#         self.conv2 = nn.Conv1d(in_channels=7, out_channels=5, kernel_size=3)\n",
        "#         self.conv1_bn = nn.BatchNorm1d(7)\n",
        "#         self.conv2_bn = nn.BatchNorm1d(5)\n",
        "#         self.fc_dropout = nn.Dropout(p=0.5)\n",
        "#         self.conv_dropout = nn.Dropout(p=0.1)\n",
        "        \n",
        "#         self._to_linear = None\n",
        "\n",
        "#         self.convs(x)\n",
        "\n",
        "#         self.fc1 = nn.Linear(self._to_linear, 64) #flattening.\n",
        "#         self.fc2 = nn.Linear(64, 9) # 64 in, 9out bc we're doing 9 classes \n",
        "\n",
        "#     def convs(self, x):\n",
        "#         # max pooling over 2\n",
        "#         x = self.conv1(x)\n",
        "#         x = self.conv1_bn(x)       \n",
        "#         x = F.max_pool1d(self.conv_dropout(F.relu(x)), 2) #or Elu\n",
        "\n",
        "#         x = self.conv2(x)\n",
        "#         x = self.conv2_bn(x)       \n",
        "#         x = F.max_pool1d(self.conv_dropout(F.relu(x)), 2) #or Elu\n",
        "\n",
        "#         # x = self.conv3(x)\n",
        "#         # # x = self.conv3_bn(x)       \n",
        "#         # x = F.max_pool1d(F.relu(x), 2) #or Elu\n",
        "        \n",
        "#         if self._to_linear is None:\n",
        "#             self._to_linear = x[0].shape[0]*x[0].shape[1]\n",
        "            \n",
        "#         return x\n",
        "        \n",
        "#     def forward(self, x):\n",
        "#         ''' Forward pass through the network, returns the output logits '''\n",
        "        \n",
        "#         x = self.convs(x)\n",
        "#         x = x.view(-1, self._to_linear)  # .view is reshape ... this flattens X before \n",
        "\n",
        "#         x = self.fc1(x)\n",
        "#         # x = self.fc1_bn(x)\n",
        "#         x = F.relu(x)\n",
        "#         x = self.fc_dropout(x) \n",
        "\n",
        "#         x = self.fc2(x) # bc this is our output layer. No activation here.\n",
        "#         return F.log_softmax(x, dim=1)\n",
        "        \n",
        "#         return x\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5c8rxsQup9Ts",
        "colab_type": "text"
      },
      "source": [
        "# Train and Validate Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_c7jC0r8Lzv",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "```\n",
        "model.train(), model.eval()\n",
        "```\n",
        "\n",
        "Both are the same. By default all the modules are initialized to train mode (self.training = True). \n",
        "\n",
        "In case you want to validate your data, call model.eval() before feeding the data, as this will change the behavior of the BatchNorm (or Dropout) layer to use the running estimates instead of calculating them for the current batch.\n",
        "If you want to train your model and can’t use a bigger batch size, you could switch e.g. to InstanceNorm."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dhFOuDsN-hWO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = ConvNN_single_heart()\n",
        "model = model.to(device)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mlPEe_rknZYi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train(loader): # for train cases\n",
        "    running_loss = 0\n",
        "    sumCorrect = 0\n",
        "    sumTotal = 0      \n",
        "    size = 0\n",
        "    model.train() # for train cases\n",
        "        \n",
        "    for X, y in loader:\n",
        "        \n",
        "        X = X.view(-1, 4, 16, 100) # feed \"-1\" batch size \n",
        "        # print(X.shape)\n",
        "        X, y = X.to(device), y.to(device)\n",
        "        # print(f\"hello {y.shape}\")\n",
        "        \n",
        "        optimiser.zero_grad()\n",
        "        \n",
        "        # train_X = train_X.view(-1, 4, 100)\n",
        "        output = model(X.float())\n",
        "        \n",
        "        _, predicted = torch.max(output.data, 2)\n",
        "        # print(predicted.shape)\n",
        "\n",
        "        \n",
        "        for input, target in zip(output, y):\n",
        "            loss_per_minibatch = 0\n",
        "            # print (input.shape, target.shape)\n",
        "            loss = criterion(input,target)\n",
        "            loss_per_minibatch += loss.item()\n",
        "            # print(loss_per_minibatch)\n",
        "\n",
        "            running_loss += loss_per_minibatch/BATCH_SIZE\n",
        "            size += 1\n",
        "            # print(\"-----\")\n",
        "       \n",
        "        loss.backward()\n",
        "        \n",
        "        optimiser.step()\n",
        "        \n",
        "        # Accuracy\n",
        "        for predict, y_correct in zip(predicted, y):\n",
        "            # print(predict, y_correct)\n",
        "            sumCorrect += (predict == y_correct).sum().item()\n",
        "        \n",
        "            sumTotal += y.size(1)\n",
        "\n",
        "    l = running_loss/size #average loss for whole loader dataset\n",
        "    acc = sumCorrect/sumTotal\n",
        "\n",
        "    return acc, l\n",
        "\n",
        "def validate(loader):\n",
        "    running_loss = 0\n",
        "    sumCorrect = 0\n",
        "    sumTotal = 0 \n",
        "    size = 0   \n",
        "\n",
        "    model.eval() # for validation cases\n",
        "    with torch.no_grad():   \n",
        "        for X, y in loader:\n",
        "\n",
        "            X = X.view(-1, 4, 16, 100)\n",
        "            # print(X.shape)\n",
        "            X, y = X.to(device), y.to(device)\n",
        "            \n",
        "            \n",
        "            # train_X = train_X.view(-1, 4, 100)\n",
        "            output = model(X.float())\n",
        "            \n",
        "            _, predicted = torch.max(output.data, 2)\n",
        "         \n",
        "            for input, target in zip(output, y):\n",
        "\n",
        "                loss_per_minibatch = 0\n",
        "                # print (input.shape, target.shape)\n",
        "                loss = criterion(input,target)\n",
        "                loss_per_minibatch += loss.item()\n",
        "\n",
        "                running_loss += loss_per_minibatch/BATCH_SIZE\n",
        "                size += 1\n",
        "                    \n",
        "\n",
        "            # Accuracy\n",
        "            for predict, y_correct in zip(predicted, y):\n",
        "            # print(predict.shape, y_correct.shape)\n",
        "                sumCorrect += (predict == y_correct).sum().item()\n",
        "\n",
        "                sumTotal += y.size(1)\n",
        "            \n",
        "            # print(sumTotal)   \n",
        "\n",
        "    l = running_loss/size #average loss for whole loader dataset\n",
        "    acc = sumCorrect/sumTotal\n",
        "\n",
        "    return acc, l\n",
        "\n",
        "def train_and_validate(trainloader, valloader):\n",
        "    train_acc_list, train_loss_list, val_acc_list, val_loss_list = [],[],[],[]\n",
        "    \n",
        "    for e in tqdm(range(EPOCHS), position=0, leave=True):\n",
        "\n",
        "        # Train\n",
        "        train_acc, train_loss = train(trainloader)\n",
        "        train_acc_list.append(train_acc)\n",
        "        train_loss_list.append(train_loss)\n",
        "        \n",
        "        # Validate\n",
        "        val_acc, val_loss = validate(valloader)\n",
        "        val_acc_list.append(val_acc)\n",
        "        val_loss_list.append(val_loss)\n",
        "    \n",
        "    return train_acc_list, train_loss_list, val_acc_list, val_loss_list"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hAF_19BC52Hy",
        "colab_type": "text"
      },
      "source": [
        "## Calculate Accuracy and Loss - *Testing (Not the Main Program)*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nYYBoUuVB7Ek",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "0eacca63-6a39-44a5-dbae-ce30e73d4592"
      },
      "source": [
        "criterion = nn.NLLLoss()\n",
        "optimiser = optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-4)\n",
        "\n",
        "# Refer to Deep Learning Roadmap\n",
        "\n",
        "EPOCHS = 2\n",
        "train_acc_total, train_loss_total, val_acc_total, val_loss_total = [],[],[],[]\n",
        "for i in range(EPOCHS):\n",
        "    \n",
        "    a, b, c, d = train_and_validate(trainloader, valloader)\n",
        "  \n",
        "    train_acc_total.append(a)\n",
        "    train_loss_total.append(b) \n",
        "    val_acc_total.append(c) \n",
        "    val_loss_total.append(d) \n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 2/2 [00:00<00:00,  3.30it/s]\n",
            "100%|██████████| 2/2 [00:00<00:00,  6.15it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DlycNgZ2fk6m",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "2838f6b6-c1d7-43a8-b79e-f4c919878cee"
      },
      "source": [
        "print(train_acc_total)\n",
        "print(train_loss_total)\n",
        "print(\"------------------\")\n",
        "print(val_acc_total)\n",
        "print(val_loss_total)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.12384259259259259, 0.1316550925925926], [0.12818287037037038, 0.12731481481481483]]\n",
            "[[0.1799049771356362, 0.17832671347315665], [0.17665089439186785, 0.17571445982213374]]\n",
            "------------------\n",
            "[[0.10503472222222222, 0.12760416666666666], [0.1605902777777778, 0.18229166666666666]]\n",
            "[[0.17334381221897072, 0.17292252224352625], [0.17235539274083245, 0.17190176414118874]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZHLzE8CxsFpk",
        "colab_type": "text"
      },
      "source": [
        "# Visualization\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8EnMpT09QnJT",
        "colab_type": "text"
      },
      "source": [
        "## See Validation Results for 1 Sample (FIX ME!)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TNJoiAuHI_xn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "outputId": "6ee3d8bc-8e88-487b-bb48-0d6ab1b2aa95"
      },
      "source": [
        "%matplotlib inline\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "vessels_names = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'atrials', 'lcim', 'acutes', 'crux', 'unknown']\n",
        "\n",
        "\n",
        "dataiter = iter(valloader)\n",
        "geometries, labels = dataiter.next()\n",
        "\n",
        "# Convert 2D matrix/image to 1D vector\n",
        "\n",
        "geom = geom.resize_(1, 400)\n",
        "\n",
        "\n",
        "# TODO: Calculate the class probabilities (softmax) for img\n",
        "with torch.no_grad():\n",
        "    \n",
        "    logps = model(geom.cuda().view(-1, 4, 100).float()) # convert to cuda tensor to run faster\n",
        "    \n",
        "ps = torch.exp(logps)\n",
        "\n",
        "# Plot the image and probabilities\n",
        "\n",
        "def view_classify(geom, ps):\n",
        "    ''' Function for viewing an image and it's predicted classes.\n",
        "    '''\n",
        "    ps = ps.data.cpu().numpy().squeeze()\n",
        "\n",
        "    fig, (ax1, ax2) = plt.subplots(figsize=(6,9), ncols=2)\n",
        "    ax1.imshow(geom.resize_(20, 20).numpy().squeeze()) #First figure on left\n",
        "    \n",
        "    ax1.axis('off')\n",
        "    ax2.barh(np.arange(10), ps) #Make a horizontal bar plot\n",
        "    ax2.set_aspect(0.1)\n",
        "    ax2.set_yticks(np.arange(11))\n",
        "    ax2.set_yticklabels(vessels_names, size='medium');\n",
        "    ax2.set_title('Class Probability')\n",
        "    ax2.set_xlim(0, 1.1)\n",
        "\n",
        "    plt.tight_layout()\n",
        "\n",
        "\n",
        "geom_numpy = geom.cpu().numpy()\n",
        "view_classify(geom.reshape(20, 20), ps) # convert back to numpy\n",
        "\n",
        "print(f\"The actual vessel is {vessels_names[labels[0]]}\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-746f1c33d40a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# Convert 2D matrix/image to 1D vector\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mgeom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgeom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresize_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m400\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     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'geom' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9l8qw83t58OQ",
        "colab_type": "text"
      },
      "source": [
        "## Plot Accuracies and Loss vs Epochs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zR56kkoDR02e",
        "colab_type": "text"
      },
      "source": [
        "This fucntion is used to average the five fold train and validation accuracy and loss. It won't be useful if we are tying to tune the hyperparameters OR just training on one dataset. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owBbcE6yHf8i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def averaging(train_acc_total, train_loss_total, val_acc_total, val_loss_total):\n",
        "\n",
        "    train_acc_total = np.asarray(train_acc_total)\n",
        "    train_loss_total = np.asarray(train_loss_total)\n",
        "    val_acc_total = np.asarray(val_acc_total)\n",
        "    val_loss_total = np.asarray(val_loss_total)\n",
        "\n",
        "    # print(train_acc_total)\n",
        "    firstRow = train_acc_total[:, 0]\n",
        "    # print(firstRow)\n",
        "    # print(np.average(firstRow))\n",
        "\n",
        "    train_acc_avg, train_loss_avg, val_acc_avg, val_loss_avg =[], [],[],[]\n",
        "\n",
        "    for i in range(train_acc_total.shape[1]):\n",
        "        mean_acc = np.average(train_acc_total[:, i])\n",
        "        train_acc_avg.append(mean_acc)\n",
        "\n",
        "        mean_loss = np.average(train_loss_total[:, i])\n",
        "        train_loss_avg.append(mean_loss)\n",
        "\n",
        "        mean_acc = np.average(val_acc_total[:, i])\n",
        "        val_acc_avg.append(mean_acc)\n",
        "\n",
        "        mean_loss = np.average(val_loss_total[:, i])\n",
        "        val_loss_avg.append(mean_loss)\n",
        "\n",
        "    return train_acc_avg, train_loss_avg, val_acc_avg, val_loss_avg"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sNBLPY7cvAfN",
        "colab_type": "text"
      },
      "source": [
        "Average Accuracy and Loss for Train and Val"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wZCaUppuB2Aj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib import style\n",
        "import pandas as pd\n",
        "\n",
        "style.use(\"ggplot\")\n",
        "\n",
        "def create_acc_loss_graph(train_acc_list, train_loss_list, val_acc_list, val_loss_list):\n",
        "    epoch = list(range(0, EPOCHS, 1))\n",
        "\n",
        "    d = {'epochs': epoch,\n",
        "        'train_acc': train_acc_list,\n",
        "        'train_loss': train_loss_list,\n",
        "        'val_acc': val_acc_list, \n",
        "        'val_loss': val_loss_list}\n",
        "\n",
        "    df = pd.DataFrame(d)\n",
        "\n",
        "    df['train_acc_avg'] = df['train_acc'].ewm(alpha=.02).mean()  # exponential weighted moving average\n",
        "    df['val_acc_avg'] = df['val_acc'].ewm(alpha=.02).mean()\n",
        "    df['train_loss_avg'] = df['train_loss'].ewm(alpha=.02).mean()\n",
        "    df['val_loss_avg'] = df['val_loss'].ewm(alpha=.02).mean()\n",
        "\n",
        "    # Then plot using pandas:\n",
        "    df.plot(x='epochs', y=['train_acc_avg', 'val_acc_avg'], figsize=(8,4))\n",
        "    plt.ylabel(\"Accuracy\")\n",
        "    df.plot(x='epochs', y=['train_loss_avg', 'val_loss_avg'], figsize=(8,4))\n",
        "    plt.ylabel(\"Loss\")\n",
        "\n",
        "    plt.show()\n",
        "\n"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OroCqwvNypGG",
        "colab_type": "text"
      },
      "source": [
        "## Compare Validation Sets\n",
        "\n",
        "Validation Set is used to compare diff models and tune hyperparamters to get the optimum one.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L0RYVGppymto",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from scipy.interpolate import make_interp_spline, BSpline\n",
        "\n",
        "def compare_graph(x, y, parameter, compare):\n",
        "\n",
        "    plt.figure()\n",
        "\n",
        "    for i in range(len(x)):\n",
        "\n",
        "        # 300 represents number of points to make between T.min and T.max\n",
        "        x_smooth = np.linspace(min(x[i]), max(x[i]), 300)  \n",
        "        spline = make_interp_spline(x[i], y[i], k=3)\n",
        "        y_smooth = spline(x_smooth)\n",
        "        plt.plot(x_smooth, y_smooth, label=f\"Model = {i}\")\n",
        "\n",
        "        # plt.plot(x[i], y[i], label=f\"batch size = {parameter[i]}\")\n",
        "    \n",
        "    plt.xlabel('Epochs')\n",
        "    \n",
        "    if compare is \"acc\":\n",
        "        plt.ylabel('Accuracy')\n",
        "        plt.legend(loc=\"lower right\")\n",
        "    else:\n",
        "        plt.ylabel('Loss')\n",
        "        plt.legend(loc=\"upper right\")\n",
        "    \n",
        "    plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_zvNSlZY16Q7",
        "colab_type": "text"
      },
      "source": [
        "# Main Pipeline\n",
        "24/6/2020 - Curerntly used for hyperparameter tuning through Five-fold cross validation\n",
        "\n",
        "26/6/2020 - The parameters that are selected for pruning are:\n",
        "\n",
        "*   Learning rate \n",
        "*   batch size\n",
        "*   weight initialization - random and He initialization, random is better\n",
        "*   Different pooling layers and Global Pooling Layers\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NftXXQowxWWl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import statistics as stats\n",
        "\n",
        "accuracies = []\n",
        "\n",
        "modelsArray = [ConvNN_avgpool(), ConvNN_maxpool(), ConvNN_GAP(), ConvNN_GMP()]\n",
        "learningRate = [0.1, 0.01, 0.001, 0.0001, 0.00001]\n",
        "batch = [8, 16, 32, 64, 128]\n",
        "\n",
        "X = X_all \n",
        "y = y_all # Create another array\n",
        "kf = KFold(n_splits=4,random_state=None, shuffle=False) # shuffle was fale\n",
        "\n",
        "train_acc_total, train_loss_total, val_acc_total, val_loss_total = [],[],[],[]\n",
        "epochs_total=[]\n",
        "\n",
        "i = 0\n",
        "for train_index, val_index in kf.split(X):\n",
        "\n",
        "    X_train, X_val = X[train_index], X[val_index]\n",
        "    y_train, y_val = y[train_index], y[val_index]\n",
        "\n",
        "    train_dataset = HeartVesselsDataset(X_train, y_train)\n",
        "    trainloader = DataLoader(dataset=train_dataset, batch_size=16, shuffle=True,num_workers=0)\n",
        "\n",
        "    val_dataset = HeartVesselsDataset(X_val, y_val)\n",
        "    valloader = DataLoader(dataset=val_dataset, batch_size=16,shuffle=True,num_workers=0)\n",
        "\n",
        "    model = modelsArray[i]\n",
        "    model = model.to(device)\n",
        "\n",
        "    t0 = time.time()\n",
        "    criterion = nn.NLLLoss()\n",
        "    optimiser = optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-4)\n",
        "\n",
        "    EPOCHS = 200# at least 5 for the interpoaltion to work\n",
        "    e = list(range(0, EPOCHS))\n",
        "\n",
        "    train_acc_list, train_loss_list, val_acc_list, val_loss_list = train_and_validate(trainloader, valloader)\n",
        "    \n",
        "    train_acc_total.append(train_acc_list)\n",
        "    train_loss_total.append(train_loss_list) \n",
        "    val_acc_total.append(val_acc_list) \n",
        "    val_loss_total.append(val_loss_list) \n",
        "    epochs_total.append(e)\n",
        "\n",
        "    t1 = time.time()\n",
        "    duration = (t1-t0)/60\n",
        "    print(\"\\nTime taken to train for 1 validation set is \" + \"{:.2f}\".format(duration) + \" minutes.\")\n",
        "\n",
        "    i+= 1\n",
        "\n",
        "compare_graph(epochs_total, val_acc_total, modelsArray, compare=\"acc\")\n",
        "compare_graph(epochs_total, val_loss_total, modelsArray, compare=\"loss\")\n",
        "\n",
        "# To get acc and loss for both val and test\n",
        "# a,b,c,d = averaging(train_acc_total, train_loss_total,  val_acc_total, val_loss_total)\n",
        "# create_acc_loss_graph(a,b,c,d )\n",
        "\n",
        "# print(f\"\\nThis model has an accuracy of {round(max(accuracies), 3)} +/- {round(stats.stdev(accuracies), 3)}\")      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jkpkDkWIU9VD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "modelsArray = [ConvNN_avgpool(), ConvNN_maxpool(), ConvNN_GAP(), ConvNN_GMP()]\n",
        "\n",
        "for counter, val_list in enumerate(val_acc_total):\n",
        "    maxValue = max(val_list)\n",
        "    print(f\"Model {counter} has a max accuracy of {round(maxValue, 3)} at epoch {val_list.index(maxValue)}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lT0bMCFxf2EF",
        "colab_type": "text"
      },
      "source": [
        "# Training on Most Optimum Model\n",
        "\n",
        "So far the deafult model - **ConvNN_maxpool()** has the best performance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-CklZBhdTDj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Decide which model is the best\n",
        "model = ConvNN_single_heart()\n",
        "model = model.to(device)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ijEP6xo-f0Mt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 632
        },
        "outputId": "b647d867-f9c1-4e46-c0a4-ef86a86b7e9d"
      },
      "source": [
        "import statistics as stats\n",
        "\n",
        "accuracies = []\n",
        "\n",
        "learningRate = 0.0001\n",
        "batch = 16\n",
        "\n",
        "\n",
        "X = X_all \n",
        "y = y_all # Create another array\n",
        "\n",
        "train_ratio = 0.8\n",
        "\n",
        "train_index = list(range(0, int(train_ratio*len(X))))\n",
        "val_index = list(range(int(train_ratio*len(X)), len(X)-1))\n",
        "\n",
        "X_train, X_val = X[train_index], X[val_index]\n",
        "y_train, y_val = y[train_index], y[val_index]\n",
        "\n",
        "train_dataset = HeartVesselsDataset(X_train, y_train)\n",
        "trainloader = DataLoader(dataset=train_dataset, batch_size=batch,shuffle=True,num_workers=0)\n",
        "\n",
        "val_dataset = HeartVesselsDataset(X_val, y_val)\n",
        "valloader = DataLoader(dataset=val_dataset, batch_size=batch,shuffle=True,num_workers=0)\n",
        "\n",
        "\n",
        "\n",
        "t0 = time.time()\n",
        "criterion = nn.NLLLoss()\n",
        "optimiser = optim.Adam(model.parameters(), lr=learningRate, weight_decay=1e-4)\n",
        "\n",
        "EPOCHS = 800# at least 5 for the interpoaltion to work\n",
        "\n",
        "train_acc_list, train_loss_list, val_acc_list, val_loss_list = train_and_validate(trainloader, valloader)\n",
        "\n",
        "t1 = time.time()\n",
        "duration = (t1-t0)/60\n",
        "print(\"Time taken to train for 1 validation set is \" + \"{:.2f}\".format(duration) + \" minutes.\\n\")\n",
        "\n",
        "create_acc_loss_graph(train_acc_list, train_loss_list, val_acc_list, val_loss_list)\n",
        "\n",
        "# To get acc and loss for both val and test\n",
        "# a,b,c,d = averaging(train_acc_total, train_loss_total,  val_acc_total, val_loss_total)\n",
        "# create_acc_loss_graph(a,b,c,d )\n",
        "\n",
        "print(f\"\\nThis model has an accuracy of {round(val_acc_list[-1], 3)} and loss of {round(val_loss_list[-1], 3)}\")      "
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 800/800 [02:09<00:00,  6.20it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Time taken to train for 1 validation set is 2.15 minutes.\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfQAAAEJCAYAAABi2tVNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxU1f3/8dedLfs2E0gIO2FViohhEVFAoqAgonVprVVErQWrrW1df0VtFcUqaqu22opYq61ov26IK+AKosgiKBgWAVkCWSbr7DP3/P64SSCyTWAyG5/n45FHMtudz5lM8p5z7r3naEophRBCCCESminWBQghhBDi2EmgCyGEEElAAl0IIYRIAhLoQgghRBKQQBdCCCGSgAS6EEIIkQQssS7gWO3evTti28rPz6eqqipi24slaUt8krbEn2RpB0hb4lUk21JUVHTI26SHLoQQQiQBCXQhhBAiCUigCyGEEElAAl0IIYRIAhLoQgghRBKQQBdCCCGSgAS6EEIIkQQS/jx0IYQQIppUKAQBPwQDEAiAzwM+L3g94PWivG7jOrcLlIKf/zIqdUmgCyGESCoqEDDC1VUPdTXQWI9qbIDGenA1gMfdEsYqGIBQ0AjmYACCwQO/hwIQCIIeMi4rPfxi0jMk0IUQQiQvFQwaAetxGQHr9xlfAT/K78dts6LXVIPPuI6A37jd50U1ND0u4Ae/f9/tzZdDwUM/sS0F0jLAagVL85fF+N58m8WKZrWC2dJ0PwuYrWA27bvOajMeY7VCShpaSiqkpEJqOqSmQkqaEeYpqVF7TSXQhRBChEUpZQwtuxqgsQFcDShXI3gaweUCdyN43Ubo+n37wnj/Hm8gYDze1XDY52p1q2YCm80IUVsKZOUYYZmRBVYrmjVlv9ttRpimpkFGJlqOHbKyISMbMrPQrLZ2fY1iSQJdCCGSkFLK6MU21kNDvbFP1+tF+bz77fNt/bNq/rl5f3Dzz8GAMcwc0g/f+7VYjB5qSqoRvLamoLWlQHomWCxoFqsRxNm5RtCmZ6KlpYMtdd99rTbshYU4G11gTTEep2nRe/ESlAS6EEIkAOX3GfuDa6pRdU5wNRpB6/MaB1+5GqgN+Ag5q6C+Fmqqjd7xkaSkNQ0RN38ZPVvs+WgpaZBiBCxoxpBzeiZkZKFlZhvBnJFpXJeeCTZbxILXbM9H0yXE20ICXQghYkh5PVBfA7U1UF+Dqqs1Ltc5UbVOaP463BC1zQbpmYRy8iA1Ha1bMQweDjl5kJmDlpll7BtOSd23f7epF62Z5OzlZCGBLoQQEaZ8PmioNXrRrgZUY9PR1rVOqK1G1VQZP9fXGj3sHzKbjf3EuQ7o0Amtz4mQa4dcB1rTdzIyW/Ypa1YrAI4kWnJUtJ0EuhBCHIYKBKChzgjkOiequTfdUAuNDSh3o3GUttdjfLkbDx7SYBwVneeAPAdajz6QY4ecXMixo+XkQnae0avOyJKes2gzCXQhxHFLuRoJ1FSgb9wAleVQVYFqqDMCvLHe+O71HPzBzfuQ0zOM4ey8fLTUNGNfclY2ZOWgZWVDehZkZhnhnZ4hB3eJdiOBLoRIWkrXjf3RVRWoyj1QUQ4V5ahK4zuuBpz7PyDHDtk5Rhh36NQSzGRmo+XkNfWo8yA7F80i/z5FfJF3pBAi4SmvB/buQu3ZBXt2QvlO1N5dULHbmGikmWYCez507IRWchp07ER2cT8aUjOhQwGaLSV2jRAxF9IVroBOSFdogMmkYWna8xEMKQK6Iqgb3wMhhcuv4w3qBHRFgy/Erno/O+p87GkMUOsJEtAV6VYTC6/Lj0r9EuhCiJhTSlHvC1HtDlLnC1HnDVLnDVHf9HPzd58v0DI5iTXoI8vXQJarhgx3DRlBLxlBD+lBH2kZqdg6/ghrvzMw59qx5eZiczhIseeTkmrDZtawmjVSzCZSO3agselAMqUUIWX8Y7eZtbCHx3WlCOnN//DBH9LxBRW+oI7CmM5bofZrb9P3pssmDcyahgKCuiLFrJGZYibLZm5THe1NVwp/SOEP6vhCRqgFdIVZA6tZw2wy6lTKaEewKfj2D8Hmn5sD0uU3fs8NvhA13iA1niANPp1U2/eY0bGaNGwWk/E7M2mkWDQsJg2zZjyfWaPpu2ZM5NZ0vanpepMGGhruQIg6bwinJ0ilK0CVO4g7ECKo7/u9BNswo+vBWE0anbNtdM9NYXCnDGwmjVRL9I6FkEAXQrQ7f0inyhWk0h2gyhWg0t30T9UVoMIVpModwB9SBzzOjCJb+ckOuMj21JIZ8KI1xaDfmkpNag7f5xXjsttwYz7wiUNAddPXFg+w48DnMG3EZtJQGGHV/P/dpEGa1US6xbQvqDBC3xdSrXps+oGlR4zVpJFuM4Fq+uDQ9F1XkG41kWEzk9H03Z5VhUUPkmkzLqdbTU1fZswm8AR03AEdX0hHV+ALGpc9TV/ulssh3AEdf1ARVEZbfU1h3B40IDPFjD3VQm6amfx0K2arDZfHiy+k8ARC1Hn3fZgI6k0fvJo+SIV04+cjlZdmMZGbZqZjhpUhRRlkWE1YTMYHJqUUKRbj9bKYjHeZrowPIZoGFpOG1WTCYmr62ayRaTOTajFhNWtkWM040i0t75VYkEAXQhyUUgpvUOFq+ueuAZoGJjQ0DXxWL7WNfkyahlJQ4w02hXWAyqaQrnQZ19X5QgdsPzfVTId0Cz1Sgwy1uMh3V+Oo3UNOxTZy9mwlO+AiI+hBS8uAzt3RunSHou5oRd2gsLOxH3u/nmtIV3iCOi5/CG9T7zikG4EUaAokf1A3QiGk8IeMn822VGobXZg1owdoM2uYNA1v0Ag4TyBEUDdCp/k1sJmNf+JWk9EbtJqaeo0mo6dqM5tIMRs9y+b/78bjjQv7d7g1QFcQVAoTRq/SH9Jp9Os0NPVc3QHdeO01MGnGc4ER0I3+EK6m71UVLuq9flz+UNi9TYsJ0q1G+KdZTaRZTOSlWijKMpFiMRmvi9l4XWxNbbOZNVL26zWHFARCOvt/JrM0vSbNr1Pzz5bm16vp+uYPIz8MwvyjOAWv+YNOSFctAa83feBKt5mwmZP7zAEJdCHiSKhpX5y3aUjTFzR6UmaT8Y/cpEFWihl7mgWT1jy8afScmoctPQEdT9AY8m0OLX/I+AfXHEgaGiGlqPMaQ9m13iBV7iCepv2H3qae2kE6zfv57pC3pFpMdMiw0CHdSm97KvkZFvLTLOT768iv3I5jx7dYvi2DHVv3TSWqadChEDp1RTtpgjE5SufuxileYQw5m01GjynTdpCe+mEcTXDEq+a2qKahcVdzz7tpaLk5uFOahvFTLRrWJAq55r8RSwx7ybEkgS5EOwo2haMvaPS2tntq2bqnjip3kIrGAE5PAJffCOAGn7F/L5xRTYvJ6OuFM8x4OCYNclLM5KRayE+3kJFjDM2mmPcN5WamGMOKGvuGnBWQkZlJfX1Dyz7ivDRjG/kZVjKsJuOUr60bUVs3orZugm0bjSlKwZiprEdvtNLJ0LWn0esuKJKD0iJE04x9zSkWE6TFuhoRLRLoQrSRyx+iwhUwDuDyBqn17juIq87XfICPcSCXN3jotM1KMRshajXRIcNKj9wU8tOt5KVZSLOajH/IZmPIdv9hxDqv8fxgHADUPNSbaTOTnWomw2omxWIcjJPSNDRsMxsHDekATYFs0jQybKaWnn5bGb1BozesfD74fgvqmzLYugl960aorjDuaDIZQ+Ylo6BnX7SefaFTFzRT23rSQojDk0AXx5XmIe3mfZIaEGjpRe/rTXuCxlClK6BT7ws1HbxlfLn8B+6ctJk1clMt5KSayU010zXHRnaKueWgmRSLRpbNTNcCOya/C0ealTRr4g51qlon3g2r0VctR235FnZtB73pdXF0NEL7zEnG927FaCnS8xaivUmgi6Tk9ATZVO1hR61xXuiOej8VjX4aDhLGR5JuNdEh3UqHDAv989MoyLTSMdOKI81KbqqZ3DRL2Kem5OfnUlV1mOUn45RqqIOydaiydahv18GendSBMXRe3A/tnIvQevaDnr3RsvNiXa4Qx6WoBfqaNWuYN28euq4zbtw4pkyZ0ur2qqoqnnjiCVwuF7quc9lllzFkyJBolScSmC+os8XppazKw8ZqLxurPFS594WmI81Clxwbfbtnk5NqJjvFQobNhGo6/cdi0ki1mki1mJqGqbWWo30PdvTt8UC5G2Hj16hv16G+XWv0wMFYoavPiWijSskbNorabAeaWYbOhYgHUQl0XdeZO3cuf/jDH3A4HNx+++2UlJTQpUuXlvv83//9H6eeeipnn302O3fu5P7775dAFwflCehsqHSzdo+bryvcfOf0thyN3THDSv8OafR1pNHXkUr3vBTSrRI4R6K8bti0AfXtWlTZOvh+i3Gkm9UGvQegDT0drf8g6N67ZcpTa34+WpIcHS5EMohKoG/evJnCwkIKCgoAGDlyJCtWrGgV6Jqm4Xa7AXC73eTlybCdMNR6Any5q5FvKz18U+GmrMpDSBlHevd1pHLBCQ765qfSz5FGbprsRQqH8vlgy4amIfS1sG2TsQ/cbDGG0CdditZvEPTq17I0pxAivkXlv5/T6cThcLRcdjgcbNq0qdV9Lr74Yu69917eeecdfD4fM2fOPOi2Fi1axKJFiwCYPXs2+fmRmyPXYrFEdHuxlMht2VnrYcX3tXxdXs83exrYUWssRWnWoG/HTH56ShdO6ZLDoKJsUhOs9x2r34vyeQls3oB/3Ur861YR2PiNMYWqyYy1d3+sF1yO7UenYOv/I7SU1LC2mcjvsf0lSztA2hKvotWWuOnOLF26lDFjxnDeeeexceNGHnvsMebMmYPpB2sCl5aWUlpa2nI5khNCJOMEE4mgojHAqvJGVu12sdnppbpp/3duqpl++Wmcd2IPuqTp9HakGufVAhCisa6GxtiVfVSi9XtRrgbU16vg61Wo7Zthzy5QujF5S9deaGdOQuv/I+hzAnpqOj7AB9DQaHyFIZHeY4eTLO0AaUu8imRbioqKDnlbVALdbrdTXV3dcrm6uhq73d7qPkuWLOGOO+4AoG/fvgQCARoaGsjJyYlGiSKK9jT42eL08m2Vh1W7XeysN1bD6phh4cSO6fTPT2NIUQaFmVY0TUuqP+z2ooIB4yC2r1agNnxlrDimlLH0Z69+aKechta9F/QZiJaRGetyhRDtICqBXlxcTHl5ORUVFdjtdpYtW8aNN97Y6j75+fl8/fXXjBkzhp07dxIIBMjOzo5GeaKd7ar38/VeN+sr3ayv8LRMimI1aZxYkM7ZvXM5pSiDztm2uFlVKhEoXTdmYlu2BLXiE/C4jIPY+g1EG3YG2gmDoUcfNFPinu8uhAhfVALdbDYzbdo0Zs2aha7rjB07lq5duzJ//nyKi4spKSnhiiuu4KmnnmLhwoUAzJgxQ/65JyilFNtrfSzb0cCy7xvYUWf0wHNSzQzokMaUAXb6d0ija44t6RdLiDTlrEStXwPr1xg98cZ6sNnQhpxmrO/d/ySZxEWI41TU9qEPGTLkgNPQLr300pafu3Tpwj333BOtckSE+UM6a8pdrG76Km8IYNLghI7pnNMnj5M7ZdApyyof0tpI6SHjdLLVn6G+WW0MpQPk5KENPAVOGIw2eDhaWnpsCxVCxFzcHBQnEo8/pLO63MXS7Q18vrMRb1AnxawxsCCdKQPsjOiSJaeRHQUV8MO3a1Grl6O++gLqa/cNpZ9+tjGU3rm7fDgSQrQi/21Fmyil+GqPmw+21vHFzkbcAZ0sm4nTu2dxWvdsBnZMS6rlGKNFedyotStg9XLj6HSfB1LTjF74kFPRBg0N+3QyIcTxSQJdhMUdCPHBd/W8tbGGnfV+Mm0mRnbL4rRuWQwqzDhu1x8+Fsrng3Ur0Fd8Amu/NM4Lz8lDGz4a7eTh0G+QTOoihAibBLo4rB11Pt4sq+HDrXV4g4re9lRuGtmJ07plSU/8KKiAH/XVF6gvPkF99Tn4vEaIj55gHNTWq78clS6EOCoS6OIAzcPqb3zrZOVuFzazxundszmnby59HGmxLi/hqIDfmOBl9WdUrv0S5WqAjCyjJz70dOh7oqwNLoQ4ZhLoooU7EOLDrfUsLDOG1XNSzVw2KJ9z+uSSnSpvlbZQSsF3Zahli1ErPjXOEU/PIHXY6fgHDYMBg1sWORFCiEiQ/yiCnfU+3tpYy5ItdXiCOr3tqfz61E6M6p4l54m3kfJ5UZ+8i/rgbajYDbYUtCEj0U4dA31/RE5hocx6J4RoFxLoxymlFGv3unl1vZPV5S4sJjitWzYT++XR15Eqp0S1karai/rwLdQn74O7EXqfgHbuxWinnIqWKueICyHanwT6cSakK5Z+38Cr66v5rsZHbtOw+vjeuXLOeBsppWDDGvQlC2HtCmPhk5NHYCo9H633gFiXJ4Q4zsh/8OOEN6izaEstr2+oocIVoCjLxvXDCxnTM1uG1dtIedyoz5agPlhorGKWlYN2zsXGker25FjuUQiReCTQk1wgpFhQ5uSVb6pp8Ov0z0/jmlM6MrRLJiYZVm8TVb4D9cFC1LIPjIlfevZFu/omtFNGyfniQoiYk0BPYqvLXfzzy73sqvdzSlEGF5/oYEBH2Z/bFkoPwerP0Re/AZvWg8WCNvR0tLET0Xr2jXV5QgjRQgI9Ce1t9DNn+QY+3lJNpywrM8d0oaSzrIHdFsrrRn26CLV4AVTthfwCtB9fiTZyHFp2bqzLE0KIA0igJ5Ggrnhjg5P/rqvCpGn8/KQOnD8gT2Z0awNVX4t6/3XUR+8Y5473HoDp4qtg8HCZ/EUIEdck0JNERWOABz/dxcZqL8O7ZHLr2QMw+xpiXVbCULXVqHdfRX38DgSCaENORTt7ClqvfrEuTQghwiKBngQ+39nAXz4rRym4eVQRo7pnk5+VQpUE+hGp6grUO/+H+vR90HW0EWPRzrkIrbBzrEsTQog2kUBPYLpSzF9XxYvrqim2p3DzqM50yrLFuqyEoCrKUW//D/XZEkBDO20c2oQfo3UojHVpQghxVCTQE5QvqPPoZ+Us+76BM3vlMH1YgZxPHgZVvhP11suoLz4CkxntjAloEy5Es3eIdWlCCHFMJNATkDsQ4t4Pd7K+wsPUkzswZYBdpmo9ArVzG2rhS6iVS8FqQyudjHbWFLRce6xLE0KIiJBATzD13iB3f7CTbTVefntaEWf0yI51SXFN7diK/uaLsOozSE0zhtXPOh8tKyfWpQkhRERJoCeQaneAOxfvoMIV4PYzujC0i5xbfihq1/fob7xgBHlaOtqknxi98gx5zYQQyUkCPUGUN/i5c/EO6n0h7hzbhR8VZMS6pLikGupQrzyHWroIUlIlyIUQxw0J9ASwqdrDPR/uRNcV95Z2pY8jLdYlxR0VCqE+ehv1+gvg8xohfs7FaFmyS0IIcXyQQI9zK3c18udPd5FlM3NXaTe65qTEuqS4ozavR3/hKdi5FQachOmnv0Dr1DXWZQkhRFRJoMexRVtqeeLzPfTITWHm2K7YZb3yVlRdDep/z6KWfwD2fEy/vBWGjJQj/oUQxyVJiDj1ZpmTf35ZweBOGdx6ehHpVplHvJkKBlEfLkS98V8I+NHOvdj4SkmNdWlCCBEzEuhx6JVvqvnXmkqGd8nk5lFFsrjKftTGr9H/8xTs2g4Dh2D6yS/QCopiXZYQQsScBHocUUox/+tq/ru2itO7Z/GbkUVYTDJ8DKAa643h9aWLwNER0/V3wEnDZXhdCCGaSKDHkZebwvzMXtn8angnzBLmKKXwLFmIPu+v4HYZE8NM+glaihwcKIQQ+5NAjxMLy2p4YW0VY3tmc8OITpik54na/T36C3+nfuM3UNwf0+Uz0Lr0iHVZQggRlyTQ48BXe1w8vXIvw7pkSpgDyudDLZyPeu9VSE0n+/rbaRw0HM0kxxIIIcShSKDHWLU7wJxPd1OUZeO3I4uO+2F2teEr9Oceh6q9aKeeiXbxVaT1LMZVVRXr0oQQIq5JoMeQUoq/Lt+DN6gz66xupFmP3x6o8riNg94+fgcKOmP6/X1o/QbGuiwhhEgYEugx9O7mWtaUu/jl0ILjegY4tX4N+r8eg5pqtLMvQDv/MjTb8ft6CCHE0ZBAj5E9DX7mrapgcGE6E/rkxrqcmDB65fNQH78LhZ0x3Tobrbh/rMsSQoiEJIEeA0opHltejknT+NWITsfludRq/Wr0fz1u9MrHX4A2WXrlQghxLCTQY+DDrfV8XeHh+uGFdMiwxrqcqFIeN+rlZ1CfvCe9ciGEiCAJ9Chz+UM8u7qCvo5USotzYl1OVKntW9D/fj84q6RXLoQQERa1QF+zZg3z5s1D13XGjRvHlClTDrjPsmXLePnll9E0je7du/PrX/86WuVFzSvrndR5Q/xhTJfj5nxzpRTqsyWo5/8OWdnSKxdCiHYQlUDXdZ25c+fyhz/8AYfDwe23305JSQldunRpuU95eTmvvfYa99xzD5mZmdTV1UWjtKhq9Id4a2MNI7tl0ceRFutyokJ53OjP/hVWLYN+P8J03S1oWcfXyIQQQkRDVAJ98+bNFBYWUlBQAMDIkSNZsWJFq0BfvHgx48ePJzMzE4CcnOT7p/9WWQ3ugM7FAx2xLiUq1K7vjSH2ynK0H1+JdtYUNLMsAyuEEO0hKoHudDpxOPaFmMPhYNOmTa3us3v3bgBmzpyJrutcfPHFDB48+IBtLVq0iEWLFgEwe/Zs8vPzI1anxWKJ6Pb25/aHeHPjZk7rmcfQPl2O/IBj1J5tCYf300XUP3E/ptQ0cv70GLYTTz7qbcW6LZEkbYk/ydIOkLbEq2i1JW4OitN1nfLycu666y6cTid33XUXDz30EBkZGa3uV1paSmlpacvlqghOCZqfnx/R7e3v9Q1O6rxBJvfJbrfn2F97tuVwVDBonFu+eAH0HoB23S3U5zrgGGqJVVvag7Ql/iRLO0DaEq8i2ZaioqJD3haVQLfb7VRXV7dcrq6uxm63H3CfPn36YLFY6NixI506daK8vJzevXtHo8R25Q/pvLrByY8K0unfIXn3navqSvSnH4LNG9DGnYd20VVolrj5zCiEEEktKpOHFxcXU15eTkVFBcFgkGXLllFSUtLqPsOGDeObb74BoL6+nvLy8pZ97olu8ZY6ajzBpN53rn/+Efofb4Qd29Cu/T2mn1wrYS6EEFEUlf+4ZrOZadOmMWvWLHRdZ+zYsXTt2pX58+dTXFxMSUkJJ510El999RU33XQTJpOJyy+/nKysrGiU166CuuKV9U76OlIZVJAe63IiTrkbUf95CvX5R8aa5Vf/Fq1DYazLEkKI405Ygb5t2zZ69OhxTE80ZMgQhgwZ0uq6Sy+9tOVnTdO48sorufLKK4/peeLNx9vqqXAFuLakY9JN8arKd6A/fq+x1On5l6Gdc7EcxS6EEDESVqDfc8892O12Tj/9dE4//XTy8vLau66koCvF/31TTY/cFIZ2zox1ORGl1q1E/+eDYLEaS532OSHWJQkhxHEtrED/xz/+wapVq/jkk094+eWX6devH2eccQbDhw8nJUWm7jyUtXvc7Kz3c9PI5FmARek66q2XUG/8F7r0wHT9H9AcHWJdlhBCHPfCCnSz2czQoUMZOnQobrebzz77jDfeeIOnn36aYcOGUVpaSv/+MpXnD723uZasFDMjuyX+sQBg7C/Xn3kUvvoCbcQYtMuvR5MPdEIIERfadJS71+vliy++YNmyZVRXVzNy5EgKCwt57LHHePrpp9urxoRU6wmyfEcDZ/bMxmaOyskE7Urt3IY+63fw9Uq0n/4CbdpNEuZCCBFHwuqhr1q1io8//pjVq1fTv39/zjzzTG699VZsNhsAEyZMYPr06VxzzTXtWmwiWbK1jpCCs3rnxrqUY6ZWL0d/eg6kZWD6/Sy03rK/XAgh4k1Ygf7CCy8wevRorrzyyoMeEJeZmcnUqVMjXVtC+2hrPf3yU+mak9i9WH3xAtT8p6FHH0zX/z+0HDkgUggh4lFYgT5nzpwj3mfcuHHHXEyy+L7Ox7ZaH9ec0jHWpRw1peuol+ehFr0OJ4/AdPXvZIhdCCHiWFg7dx966CE2bNjQ6roNGzaEFfTHo0+21WPSYFT37FiXclSU34f+1AOoRa+jjTsP0y9vlTAXQog4F1agr1+/nn79+rW6rm/fvi1TtYp9lFJ8ur2egQXp5KUl3tSnyuNGf+ROWL0c7dKrjSlcTTJZjBBCxLuwAt1qteL1eltd5/V6McusYAfYXutjd0OA0xOwd67cLvRH74KtG9GuvRlT6fmxLkkIIUSYwgr0k046iX/84x+43W4A3G43c+fOPeh65ce7L3Y2AiTczHAtYb59M6Zf3IJp6KhYlySEEKINwhoTvuKKK3jssceYNm0amZmZNDY2MnjwYG644Yb2ri/hfLGrkb6O1IQablfuRvRH74bvt2C67la0k0fEuiQhhBBtFFbqZGZmcvvtt1NTU0N1dTX5+fnk5ib++dWRVuMJsqnay89Oyo91KWFT7kb0R+6CHVuNg98GS5gLIUQialM3Mi8vj9zcXJRS6LoOgMmU+LOgRcqKXcZw+7AEGW5X9bXGMPvuHZim34Z20rBYlySEEOIohRXoTqeTuXPnsmHDBlwuV6vb5s+f3y6FJaIVuxrpkG6he278n+KlnJXG0ezOSky/+gPawCFHfpAQQoi4FVb3+h//+AcWi4U777yT1NRUHnjgAUpKSrj22mvbu76E4QvqrCl3MbRLZtyvrKYqdqM/cBvU1WD6zZ8kzIUQIgmEFegbN25k+vTp9OjRA03T6NGjB9OnT+fNN99s7/oSxrq9bvwhxbAu8b2ymqrYjf7nO8Dvw/S7WbKOuRBCJImwhtxNJlPLOecZGRnU19eTlpaG0+ls1+ISyRc7G0m1mBjYMS3WpRySclaiz5kJoSCm39+H1rlbrEsSQggRIWEFeu/evVm9ejXDhg3jpJNO4pFHHsFms1FcXNze9SUEpRQrdjVycqcMrHG6VKqqr0F/+E7wuDH9/l4JcyGESDJhBfoNN9yAUgqAqVOnsmDBAjweDxMnTmzX4hLFtlofTk+QoZ0zYioUFDkAACAASURBVF3KQanGeuPUtJoqTDf9Ca2bfBATQohkc8RA13WdefPmcd111wFgs9n48Y9/3O6FJZK1e4wZ9E7qFH+BrlyN6A/PhL27jaPZew+IdUlCCCHawRHHh00mE2vXro37I7djad1eN52yrOSnW2NdSivK50N//F7jPPMZd6CdIFP1CiFEsgprh+/EiRN56aWXCAaD7V1PwgnpivUVbn5UkB7rUlpRwSD6k7Nhywa0q38rp6YJIUSSC2sf+jvvvENtbS0LFy4kO7v1KmJ///vf26WwRLGt1ocroDOwY/wEulKK+r/Phq9Xov38elloRQghjgNhHxQnDq6sygNA/w7xc7qaWvAi3iVvoZ33E0xnjI91OUIIIaIgrEA/4QSZfORQNlZ5yE010zEjPvaf60sXoxb8l9Sx5+I/76exLkcIIUSUhBXoh5uv/dJLL41YMYmorMpL3/y0uDhoUK1fg/r34zDgJLKn30p1XV2sSxJCCBElYQV6dXV1q8u1tbWsX7+eYcOO79W5Gnwhdjf4GdcrJ9aloCr3oD/1Zyjsgmn67WjW+BgxEEIIER1hBfqMGTMOuG7NmjV8+umnES8okWyqNvaf981PjWkdyu9D//v9gDJOT0uLnwP0hBBCRMdRz1M6aNAgVqxYEclaEk5ZlQcN6O2IXaArpVDP/x12bMV09W/ROnaKWS1CCCFiJ6we+t69e1td9vl8fPrpp+Tn57dLUYliU7WXrjk20q3mmNWgPnoH9dkStEk/QRs0NGZ1CCGEiK2wAv3GG29sddlms9GzZ0+uv/76dikqUWyr8cV0Qhm15VvUi/+EgaegnfeTmNUhhBAi9o75KPfjVb0vRLUnSI+8lJg8v6qvQX/yAchzYLrmt2im+FzlTQghRHSElQLbtm2jqqqq1XVVVVVs27atPWpKCNtqvAD0yIv+/nMVCqH/4yFwNRhHtGdkRb0GIYQQ8SWsQH/ssccIhUKtrgsGgzz++OPtUlQi2F7rA6BnbvR76OqV56BsHdrPr0fr1ivqzy+EECL+hBXoVVVVFBQUtLqusLCQysrKdikqEWyt8ZGTaiY3Lay9FhGjvvwU9d6raGPPxXTq2Kg+txBCiPgVVqDb7Xa+++67Vtd999135OXltUtRiWBbrY8eUe6dq93foz/7Vyjuj3bJ1VF9biGEEPEtrO7lxIkTefDBB5k8eTIFBQXs3buXBQsWcOGFF7Z3fXEppCu+r/UxsV/0PtAoj9uYPMaWgum6W9EsMhOcEEKIfcIK9NLSUjIyMliyZAnV1dU4HA6uuOIKRowYEfYTrVmzhnnz5qHrOuPGjWPKlCkHvd/y5ct5+OGHuf/++ykuLg57+9G0u8FPQFd0j1IP3Zg85m9QUY7pt/ei5Tmi8rxCCCESR9g7gE899VROPfXUo3oSXdeZO3cuf/jDH3A4HNx+++2UlJTQpUuXVvfzeDy8/fbb9OnT56ieJ1p21vsB6JYTpUBfugj1xcdoUy5H6zcwKs8phBAisYS1D/2ZZ56hrKys1XVlZWU8++yzYT3J5s2bKSwspKCgAIvFwsiRIw86bez8+fM5//zzscb5wiK7mgK9KLv961TlO1D/fQr6D0I758ft/nxCCCESU1iBvnTp0gOGv3v16hX24ixOpxOHY98wscPhwOl0trrPd999R1VVFUOGDAlrm7G0u95PXqq53ad8VX6fsYJaSpoxT7spdlPMCiGEiG9hDblrmoau662u03UdpVREitB1neeee+6gq7r90KJFi1i0aBEAs2fPjuh88haLJaztVXp208OR0e5z2dc/+SCeXdvJnfkwKb37tumx4bYlEUhb4lOytCVZ2gHSlngVrbaEFej9+/fnxRdf5PLLL8dkMqHrOi+99BL9+/cP60nsdnurNdWrq6ux2+0tl71eLzt27OCPf/wjYKy3/uc//5lbbrnlgJGB0tJSSktLWy7/cAa7Y5Gfnx/W9rY5XYzomhnR5/4hteZz9HdfRRt/AQ3detPQxucKty2JQNoSn5KlLcnSDpC2xKtItqWoqOiQt4UV6FdddRWzZ8/muuuuayksLy+PW2+9NawCiouLKS8vp6KiArvdzrJly1ot+JKens7cuXNbLt999938/Oc/j8uj3Bt8Iep9ITpn29rtOZTXjf6fp6Bzd7Qpl7fb8wghhEgeYQW6w+HggQceYPPmzVRXV5OTk8OKFSu44447eOqpp474eLPZzLRp05g1axa6rjN27Fi6du3K/PnzKS4upqSk5JgbEi27G5oOiMtqx0B//b9QW43pulvkfHMhhBBhCfu0tcbGRjZv3syHH37I9u3bGTBgAFOnTg37iYYMGXLAAW+XXnrpQe979913h73daNt3hHv7BLravgW1eAHaGePRisPbpSGEEEIcNtCDwSBffvklH374IV999RWFhYWcdtppVFVVcdNNN5GTkxOtOuPG7no/Jg0KMyMf6EoPof/7CcjKRrvwiohvXwghRPI6bKBfe+21mEwmRo8ezSWXXEKvXsbKXu+9915UiotHuxv8FGZasZi0iG9bffAWbN+M9oub0dIzI759IYQQyeuw56F3794dl8vF5s2b2bJlC42NjdGqK27tafTTqR32nytnFerV52HgELSSURHfvhBCiOR22B763XffTWVlJR999BELFixg3rx5DBo0CJ/Pd8D66MeLCleQPo60iG9Xf/EfoEKYLvslmhb53r8QQojkdsSZ4jp06MBFF13EX//6V+68807y8vLQNI2bb76Z559/Pho1xg1PQKfBF6JDRmSPPFdrlsPq5WiTforWoTCi2xZCCHF8CPsodzAmmOnfvz9XXXUVX3zxBR9//HF71RWXKl0BADpGMNCNc87/YZxzftb5EduuEEKI40ubAr2ZzWZj1KhRjBp1fO3rrWiPQH/9v1BT1XTO+VH9OoQQQojwFmcRhuZA75ARmeBV3zedcz56gpxzLoQQ4phIoLdBpSuAxaSRl3bsga70EPpzcs65EEKIyJBAb4MKV4AOGRZMETgKXX30rnHO+U+ulXPOhRBCHDMJ9DaodAUicoS7cjWiXn8B+g+Sc86FEEJEhAR6G1Q0BiJyQJx6cz64GzFdcrWccy6EECIiJNDD5A/p1HhDxxzoau9u1AcL0Uadhda1Z4SqE0IIcbyTQA9TlSsIcMxD7vr/ngWLFe38n0WgKiGEEMIggR6mSJyDrsq+hjXL0c75MVpOXqRKE0IIISTQw3Ws56ArXUd/+Rmw58uMcEIIISJOAj1Mla4AJg3y04+uh65WLjVOU5vyczRbSoSrE0IIcbyTQA9TRWMAR5oF81Gsg66CQdRrzxvztQ8/ox2qE0IIcbyTQA9TxTGcg66WLYKKckwXXIFmMke4MiGEEEICPWyVrqM7B135fKgFL0JxfxhU0g6VCSGEEBLoYQnqimpPkI6ZRxHoH7wJtU5MF14pk8gIIYRoNxLoYah2B9BV289BVx436u3/gx+VoPU9sZ2qE0IIISTQw1LZNKlMW4fc1YdvG1O8Tv5pe5QlhBBCtJBAD0O12zgH3ZEe/jnoyu9DLXodTjgZrUefdqpMCCGEMEigh6HGa/TQ7W1YB10tXQz1tZjOvbi9yhJCCCFaSKCHwekOYjNrpFvDe7lUMIh69xXjyHbZdy6EECIKJNDD4PQEsadZwj5KXa34BKorMJ1zsRzZLoQQIiok0MNQ0xTo4VC6jnr7f9C5u5x3LoQQImok0MPg9ATJC3f/+VdfQPkOtHMukt65EEKIqJFAD4PTEwqrh66UQn/rZehQiFYyKgqVCSGEEAYJ9CNwB0J4g3p4Q+4bv4Ztm9DGX4hmljnbhRBCRI8E+hHUeEIA2MM4B11//3XIzEY7dWx7lyWEEEK0IoF+BE6PManMkfahq727Ye0KtDHnyHrnQgghok4C/QhaeuhHCvTFb4DZjDbm3GiUJYQQQrQigX4E4fTQlasBtXQx2rDRaDl50SpNCCGEaCGBfgQ1nhA2s0bGYWaJUx+/B34f2lmTo1iZEEIIsY8E+hE43YefJU7pOuqjt6Hfj9C69IxydUIIIYRBAv0InN4jzBK34SuorkA7Y3z0ihJCCCF+QAL9CJzuw88Sp3/yLmRmoZ18ahSrEkIIIVoLfz3QY7RmzRrmzZuHruuMGzeOKVOmtLr9zTffZPHixZjNZrKzs5k+fTodOnSIVnmH5PQEOaUo46C3qfpaWPMF2tiJaFZrlCsTQggh9olKD13XdebOncsdd9zBI488wtKlS9m5c2er+/To0YPZs2fz0EMPMWLECJ5//vlolHZYR5olTn22BEJBtDPOjnJlQgghRGtRCfTNmzdTWFhIQUEBFouFkSNHsmLFilb3GThwICkpxoQsffr0wel0RqO0w2o+B/1gQ+5KKePo9t4noHXqGu3ShBBCiFaiMuTudDpxOBwtlx0OB5s2bTrk/ZcsWcLgwYMPetuiRYtYtGgRALNnzyY/Pz9idVosllbb2+GtA6BnoYP8/NxW9/V/vYqait1k/+Rq0iJYQ6T8sC2JTNoSn5KlLcnSDpC2xKtotSVq+9DD9fHHH/Pdd99x9913H/T20tJSSktLWy5XVVVF7Lnz8/Nbbe+7ciPQTQEXVVXBVvfVF7wMaRk09h2EK4I1RMoP25LIpC3xKVnakiztAGlLvIpkW4qKig55W1SG3O12O9XV1S2Xq6ursdvtB9xv7dq1vPrqq9xyyy1Y4+Ags2q3EeL5P1iYRTXWo1YtRRsxBi1F5m0XQggRe1EJ9OLiYsrLy6moqCAYDLJs2TJKSkpa3Wfr1q3885//5JZbbiEnJycaZR1RlSdIutVEurX1Uqhq+QcQlIPhhBBCxI+oDLmbzWamTZvGrFmz0HWdsWPH0rVrV+bPn09xcTElJSU8//zzeL1eHn74YcAYorj11lujUd4hVbsDOH7YO28+GK5nX5kZTgiR0JRSeL1edF0/5GyYsbJ37158Pl+sy4iItrZFKYXJZCI1NbVNv5eo7UMfMmQIQ4YMaXXdpZde2vLzzJkzo1VK2KrdQRzpPxj637IBynegXfGr2BQlhBAR4vV6sVqtWCxxdzgVFosFs9l85DsmgKNpSzAYxOv1kpaWFvZjZKa4w6hyBw/cf/7xe5CShjb09BhVJYQQkaHrelyGuTA+BOi63qbHSKAfQlBX1HpaB7pqrEd9+SnaiNFoqeF/ahJCiHgUb8PsorW2/n4k0A+hxhNEQashd7V0EQT8aGMnxq4wIYQQ4iAk0A+hyh0A9p2ypvQQ6sO3oe+JaJ27x7I0IYQQ4gAS6IfQfA56Sw99w1qo2os25twYViWEEMmjrq6OZ599ts2P+/nPf05dXV3kC0pwcjTEIewL9KYe+vIPIT0DbfCIGFYlhBDtQ3/xn6gdWyO6Ta1rT0w/ufaQt9fX1/Pcc88xderUVtcHg8HDHqz373//O1IlJhXpoR9ClTtAqkUjw2pC+Xyo1cvRTjlNlkkVQogIue+++9i+fTtnnXUW5557LhdccAFTp05lzJgxAEybNo0JEyYwduzYVitwDh8+HKfTyY4dOxg9ejQ333wzY8eO5ac//Skej+eQz/fCCy9w7rnnUlpayrXXXtty38rKSq6++uqWqcWbFw97+eWXW6674YYbDrnd9957j0mTJnH22Wdz6aWXUllZia7rDB8+vNVIwmmnnUZlZSXbtm1j0qRJjBs3jgceeIA+ffocy8vYQnroh9B8DrqmaehrvwCfB2346FiXJYQQ7eJwPen2cscdd1BWVsb777/PsmXLuOKKK1iyZAndunUDYM6cOeTl5eHxeJg4cSLnnnvuAdOGb926lSeeeIIHH3yQ6667jrfeeosf//jHB32+c845h5/97GcAPPDAA/z3v/9l2rRpzJw5kxEjRjB37lxCoRAul4uysjL+8pe/8MYbb2C326mpqTlkO4YNG8aCBQvQNI3//Oc//O1vf+Ouu+5i/PjxvPPOO/zsZz9j1apVdOnShQ4dOvC73/2Oa665hilTpvDcc89F6NWUHvohVbmD+4bbP/8Ich3Q58QYVyWEEMlr8ODBLWEO8Mwzz1BaWsp5553H7t272br1wF0CXbt2ZeDAgQAMGjSIHTt2HHL7ZWVlXHDBBYwbN45XX32VsrIyAJYuXcoVV1wBGDObZmdns3TpUiZNmtTyASIvL++Q2y0vL+eyyy5j3Lhx/P3vf2fjxo0AnHfeebzxxhsAvP7660yePBmAlStXMmnSJAAuuOCC8F6cMEigH4RSit0NfgozrajGevh6JdqwM9BM8nIJIUR7SU9Pb/l56dKlfPLJJyxYsIBFixYxcODAg06fmrLfAllms5lQKHTI7d90003ce++9LF68mJtuuiliU8vOnDmTq666isWLF/PAAw+0bLekpIRt27ZRVVXFu+++yznnnBOR5zsUSaiDqPGGaPCF6J6bgvpyKYRCMtwuhBARlpGRQWNj40Fvq6+vJycnh7S0NDZv3syqVauO+fkaGxspKCggEAjw6quvtlw/atSolqHvUChEfX09p512Gm+++SZOpxPgsEPu9fX1FBYWAsZ+92aapjFhwgTuuusu+vTp09LbHzJkCAsXLgSMnnukSKAfxLYaLwA9clNRX3wEnbpCV1mIRQghIslutzN06FDOPPNM7r333la3nXnmmYRCIUaPHs199913wFogR+Pmm29m0qRJTJkyhd69e7dc/6c//Ylly5Yxbtw4JkyYwMaNG+nXrx833ngjF110EaWlpfzxj3885HZ/97vfcd111zFhwoQD9vFPnjyZ//3vf5x33nkt1/3xj3/kn//8J6WlpWzbto3s7OxjbhuAppRSEdlSjOzevTti22pehP7V9dU8u7qSf5+ZS8adv0CbcjmmiZdE7HmiobktyUDaEp+SpS3J0g5oe1vcbnerYe54YrFYCAaDsS4jIn7YFo/H07KS2uuvv85rr73GvHnzDnjcwX4/RUVFh36eyJWcPLbV+rCnWcj8eCHKZJLhdiGEEBGzdu1a/t//+38AZGdnM2fOnIhsVwL9ILbX+uiRaUK99jbaiLFo+QWxLkkIIUSY7rjjjpZzyZtdc801rZbsPhp/+ctfePPNN1tdN2nSJH7961+3aTvDhw9n0aJFx1TLwUig/0BIV+yo83OS+1tQCm3ixbEuSQghRBvcd9997bLdX//6120O72iSg+J+YFeDn6Cu6L51FdqPr0TreOj9FUIIIUS8kED/ge27jVMUuhXkoJ05KcbVCCGEEOGRQN+PUoqtH3yEWQ/R7cKLZSIZIYQQCUMSaz++zz9me8BGUUoIW+eusS5HCCGECJsEehOlFI3PPsb2nC706GQ/8gOEEEJEVaRWJUtWcpR7sx1bqa9yUjkgmwl5abGuRgghourpL/eytWmWzEjpmZfKNSVy2m+0SKA3Uds28n2WcUR799yUI9xbCCHEsbrvvvsoKipi6tSpgLFcqtlsZtmyZdTX1xMIBLjlllsYP378Ebflcrm46qqrqKurIxgMtnrcyy+/zFNPPQXAgAEDeOyxx6isrOS2225j+/btANx///0MHTr0oNueNm0au3fvxufzcfXVV3P55Zfz3HPPsX37dmbOnAnA/PnzWbt2LbNmzeKRRx7hlVdeweFwUFRUxODBg/nFL35xrC/XEUmgNzGdMQFnl5Hw2W565EmgCyGOL7HoSU+ePJm77rqrJdAXLFjACy+8wNVXX01eXh4VFRWcd955nH322WiadthtpaSkMHfuXLKysnA6nS2P27hx40HXNT/YGuiHcrB12SdOnMjkyZNbAn3BggXceOONrFmzhrfeeov333+fYDDI+PHjGTx4cGResCOQQN/PVpciw2oiP11eFiGEaG8DBw6kqqqKPXv2UF1dTU5ODh07duTuu+/m888/R9M09uzZQ2VlJR07djzstpRSzJ49+4DHHWpd86VLl/KXv/wF2LcG+qE888wzvP322wAt67KfcsopdOvWjZUrV9KzZ082b97M0KFDefrppxk/fjypqakAnHXWWcf8OoVLkms/m6tcdM9NOeInQSGEEJExadIkFi5cSEVFBZMnT+aVV16hurqa999/H03TGD58eFjrljc/7u2338ZqtYb9uCNZtmxZy7rsaWlpXHTRRS3bPf/881mwYAG9e/dmwoQJMc8OOcq9iS+oU1bRSC97aqxLEUKI48bkyZN5/fXXWbhwIZMmTaKhoYH8/HysVitLly5l586dYW3nUI871LrmB1sD/VDbPdS67BMmTOC9997jtdde4/zzzwdg6NChvP/++3i9XlwuV7vM2X4oEuhN1u114wvqlHTOjHUpQghx3OjXrx8ul4vCwkIKCgq48MIL+eqrrxg9ejT/+9//Wq1bfjjNjxs3blyrxx1qXfODrYF+MGPGjDnkuuy5ubn07t2bXbt2cfLJJwMwePBgzj77bEpLS7n88ssZMGAAWVlZx/IShU3WQ2/y1R4Xb21u5PendsBqTvzPOcfzGs/xTNoSf5KlHSDroccLl8tFRkYGHo+HCy+8kDlz5nDCCSe0eTuyHvpROqkwg3EDuyfNH7YQQojYuOWWW9i4cSM+n4+LL76YQYMGReXDiQS6EEKIhLFhwwZuvPHGVtelpKQcsE55WzmdzoOulz5//vyWI+TD9cQTTxxTLUdLAl0IIY5TibjHdcCAAbz//vsR367dbm+X7R6Ltv5+En9nsRBCiKNiMpkSdj91sgsGg5jauOKn9NCFEOI4lZqaitfrxefzxfwc6h9KSUmJyHnk8aCtbVFKYTKZWianCZcEuhBCHKc0TSMtLT4Xozqezz44WjLkLoQQQiQBCXQhhBAiCUigCyGEEEkg4WeKE0IIIYT00Fu57bbbYl1CxEhb4pO0Jf4kSztA2hKvotUWCXQhhBAiCUigCyGEEEnAfPfdd98d6yLiSa9evWJdQsRIW+KTtCX+JEs7QNoSr6LRFjkoTgghhEgCMuQuhBBCJAEJdCGEECIJyFzuTdasWcO8efPQdZ1x48YxZcqUWJd0WH/7299YtWoVOTk5zJkzB4DGxkYeeeQRKisr6dChAzfddBOZmZkopZg3bx6rV68mJSWFGTNmxM2+qaqqKp544glqa2vRNI3S0lLOPffchGyL3+/nrrvuIhgMEgqFGDFiBJdccgkVFRU8+uijNDQ00KtXL2644QYsFguBQIDHH3+c7777jqysLH7zm9/QsWPHWDejFV3Xue2227Db7dx2220J25brr7+e1NRUTCYTZrOZ2bNnJ+R7zOVy8eSTT7Jjxw40TWP69OkUFRUlXDt2797NI4880nK5oqKCSy65hNGjRydcWwDefPNNlixZgqZpdO3alRkzZlBbWxv9vxUlVCgUUr/61a/Unj17VCAQUL///e/Vjh07Yl3WYX3zzTdqy5Yt6re//W3Ldf/+97/Vq6++qpRS6tVXX1X//ve/lVJKrVy5Us2aNUvpuq7KysrU7bffHpOaD8bpdKotW7YopZRyu93qxhtvVDt27EjItui6rjwej1JKqUAgoG6//XZVVlam5syZoz799FOllFJPPfWUevfdd5VSSr3zzjvqqaeeUkop9emnn6qHH344NoUfxoIFC9Sjjz6q7r//fqWUSti2zJgxQ9XV1bW6LhHfY4899phatGiRUsp4jzU2NiZkO/YXCoXUNddcoyoqKhKyLdXV1WrGjBnK5/MppYy/kQ8++CAmfysy5A5s3ryZwsJCCgoKsFgsjBw5khUrVsS6rMM64YQTyMzMbHXdihUrGD16NACjR49uacOXX37JGWecgaZp9O3bF5fLRU1NTdRrPpi8vLyWT9ppaWl07twZp9OZkG3RNK1lucNQKEQoFELTNL755htGjBgBwJgxY1q1ZcyYMQCMGDGCr7/+GhVHx6hWV1ezatUqxo0bBxhLOiZqWw4m0d5jbrebDRs2cOaZZwJgsVjIyMhIuHb80Lp16ygsLKRDhw4J2xZd1/H7/YRCIfx+P7m5uTH5W5Ehd8DpdOJwOFouOxwONm3aFMOKjk5dXR15eXkA5ObmUldXBxjty8/Pb7mfw+HA6XS23DdeVFRUsHXrVnr37p2wbdF1nVtvvZU9e/Ywfvx4CgoKSE9Px2w2A2C323E6nUDr953ZbCY9PZ2Ghgays7NjVv/+nn32WS6//HI8Hg8ADQ0NCdsWgFmzZgFw1llnUVpamnDvsYqKCrKzs/nb3/7G9u3b6dWrF1OnTk24dvzQ0qVLOe2004DE/B9mt9s577zzmD59OjabjZNOOolevXrF5G9FAj1JaZqGpmmxLiNsXq+XOXPmMHXqVNLT01vdlkhtMZlMPPjgg7hcLh566CF2794d65KOysqVK8nJyaFXr1588803sS7nmN1zzz3Y7Xbq6uq49957KSoqanV7IrzHQqEQW7duZdq0afTp04d58+bx2muvtbpPIrRjf8FgkJUrV3LZZZcdcFuitKWxsZEVK1bwxBNPkJ6ezsMPP8yaNWtiUosEOsanp+rq6pbL1dXV2O32GFZ0dHJycqipqSEvL4+ampqWT3x2u52qqqqW+8Vb+4LBIHPmzOH0009n+PDhQOK2pVlGRgYnnngiGzduxO12EwqFMJvNOJ3Olnqb33cOh4NQKITb7SYrKyvGlRvKysr48ssvWb16NX6/H4/Hw7PPPpuQbQFa6szJyWHo0KFs3rw54d5jDocDh8NBnz59AGO49rXXXku4duxv9erV9OzZk9zcXCAx/+7XrVtHx44dW2odPnw4ZWVlMflbkX3oQHFxMeXl5VRUVBAMBlm2bBklJSWxLqvNSkpK+OijjwD46KOPGDp0aMv1H3/8MUopNm7cSHp6elwMVYGxX/bJJ5+kc+fOTJo0qeX6RGxLfX09LpcLMI54X7t2LZ07d+bEE09k+fLlAHz44Yct761TTjmFDz/8EIDly5dz4oknxk2P5LLLLuPJJ5/koCE3ZgAABYpJREFUiSee4De/+Q0DBw7kxhtvTMi2eL3elt0GXq+XtWvX0q1bt4R7j+Xm5uJwOFpGfdatW0eXLl0Srh3723+4HRLz7z4/P59Nmzbh8/lQSrX8XmLxtyIzxTVZtWoV//rXv9B1nbFjx3LhhRfGuqTDevTRR1m/fj0NDQ3k5ORwySWXMHToUB555BGqqqoOOOVj7ty5fPXVV9hsNmbMmEFxcXGsmwDAt99+y5133km3bt1a3tQ//elP6dOnT8K1Zfv27TzxxBPouo5SilNPPZWLLrqIvXv38uijj9LY2EjPnj254YYbsFqt+P1+Hn/8cbZu3UpmZia/+c1vKCgoiHUzDvDNN9+wYMECbrvttoRsy969e3nooYcAY9h61KhRXHjhhTQ0NCTce2zbtm08+eSTBINBOnbsyIwZM1BKJVw7wPhwNWPGDB5//PGW3WyJ+DsBeOmll1i2bBlms5kePXrwy1/+EqfTGfW/FQl0IYQQIgnIkLsQQgiRBCTQhRBCiCQggS6EEEIkAQl0IYQQIglIoAshhBBJQAJdCBFxzatnhUKhWJcixHFDAl0IIYRIAhLoQgghRBKQudyFOE44nU6eeeYZNmzYQGpqKhMnTuTcc8/lpZdeYseOHZhMJlavXk2nTp2YPn06PXr0AGDnzp08/fTTbNu2DbvdzmWXXdYyjaXf7+fFF19k+fLluFwuunXrxsyZ/7+9ewdpJQ3DOP5nThJjIYiJMQmCIRhFsFIUwQtIOrWwiKiVKS28xFZdELQwCkJSK0IKRSuxSCuoKIo2QiCYKHhBA+YisYlJHLY4bM7Ksuzu2WWF5P11MwPzzXzNM/POx7y/FMY8OjpiZ2eHbDZLf39/4Q+M0WiU9fV1np+f0el0dHV1MTY29r/PiRDFRAJdiBKgqiper5e2tjY8Hg+JRILFxcVC17GLiwump6eZnJwkGAyyurqKz+cDwOv10tvby/z8POFwmJWVFZaXl7FarQQCAR4fH1laWqKyspJIJPLpv9ThcBifz8fT0xOzs7O0t7dTW1vL5uYmfX199PT0kMlkuL+//5J5EaKYSMldiBJwc3NDOp3G5XKh0WioqanB6XRycnICgN1up6OjA41Gw8DAALlcjkgkQiQSIZPJMDg4iEajobm5mZaWFo6Pj1FVlYODA9xuN1VVVSiKQmNjI1qttjDu0NAQOp0Om81GXV0dd3d3AGg0GmKxGOl0Gr1eT0NDw5fMixDFRN7QhSgBLy8vpFIp3G53YZ+qqjQ1NWE0GjEYDIX9iqJgMBhIpVLA925SivLj2b+6uppkMsnb2xu5XA6z2fyn4/7WFhOgrKyMTCYDwPj4ODs7O8zMzGAymXC5XLS2tv5XtytESZJAF6IEGI1GTCYTfr//D8d2d3dJJBKFbVVVSSQShfaU8XgcVVULoR6Px7FYLFRUVKDVaonFYoXv7X+XxWLB4/Ggqirn5+esra2xsbGBXq//+ZsUosRJyV2IElBfX095eTl7e3tks1lUVeX+/p5oNArA7e0tZ2dnfHx8EAwG0Wq1OBwOHA4HZWVl7O/vk8/nCYVCXF5e0tnZiaIo9Pb2EggESCaTqKrK9fU1uVzuL6/n8PCQdDqNoiiF1pm/rwIIIf45aZ8qRIlIJpMEAgFCoRD5fB6r1crw8DDhcPjTKnez2cz4+Dh2ux2Ah4eHT6vcR0dHaW9vB76vct/a2uL09JRMJoPNZmNubo7X11cmJibY3t7m27dvACwsLNDd3Y3T6cTv93N1dcX7+zvV1dWMjIwUzimE+DkS6EKUuN3dXWKxGFNTU199KUKIf0FqXEIIIUQRkEAXQgghioCU3IUQQogiIG/oQgghRBGQQBdCCCGKgAS6EEIIUQQk0IUQQogiIIEuhBBCFIFfAbo8sQ1DlZFVAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 576x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "This model has an accuracy of 0.852 and loss of 0.111\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "roCsWtjWr3Qb",
        "colab_type": "text"
      },
      "source": [
        "# Test Model on Unseen Data \n",
        "Well technically, `model.eval() `is not learning any new weights so its testing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wQXsop42Nztw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "35b8c7b4-46e6-4221-c6da-9e7da38c605a"
      },
      "source": [
        "# !rm -r /content/test\n",
        "dest = '/content/test/'\n",
        "X_test, y_test = storeDataForSingleHeart(dest)\n",
        "\n",
        "test_dataset = HeartVesselsDataset(X_test, y_test)\n",
        "testloader = DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,shuffle=True,num_workers=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are 28 heart datasets\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8cAsvvzwOvKq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 394
        },
        "outputId": "2e2ad917-0204-4ab5-cf36-47e7f75687ad"
      },
      "source": [
        "vessels_names = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'atrials', 'lcim', 'acutes', 'crux', 'unknown']\n",
        "\n",
        "def test(model):\n",
        "\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    vessels_count = np.zeros((10,), dtype=int)\n",
        "    vessels_correct = np.zeros((10,), dtype=int)\n",
        "    mainBifurcations_count = np.zeros((3,), dtype=int) \n",
        "    mainBifurcations_correct = np.zeros((3,), dtype=int) \n",
        "\n",
        "    predicted_class_array = []\n",
        "    true_class_array = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "\n",
        "        model.eval()\n",
        "\n",
        "        for test_X, test_y in testloader:\n",
        "\n",
        "            test_X, test_y = test_X.to(device), test_y.to(device)\n",
        "\n",
        "            # for i in tqdm(range(len(test_X)), position=0, leave=True):\n",
        "            for X, y in zip(test_X, test_y):\n",
        "                test_y_list = y.tolist()\n",
        "                # true_class_array.append(test_y)\n",
        "                true_class_array.extend(test_y_list)\n",
        "                X = X.view(-1, 4, 16, 100) # feed \"-1\" batch size \n",
        "                # print(X.shape)\n",
        "                X, y = X.to(device), y.to(device)\n",
        "                # print(f\"hello {y.shape}\")\n",
        "\n",
        "                # train_X = train_X.view(-1, 4, 100)\n",
        "                output = model(X.float())\n",
        "\n",
        "                _, predicted = torch.max(output.data, 2)\n",
        "                predicted = predicted[0].cpu().data.numpy()\n",
        "                # print(predicted)\n",
        "                predicted_class_array.extend(predicted)\n",
        "\n",
        "                for predict, real in zip(predicted, y):\n",
        "                    real = real.item()\n",
        "                    if real == 9: #exclude unknowns\n",
        "                        continue\n",
        "                    \n",
        "                    vessels_count[real] += 1\n",
        "            \n",
        "\n",
        "                    if predict == real:\n",
        "                        vessels_correct[real] += 1\n",
        "                        correct += 1\n",
        "                    \n",
        "                    # These numbers follow the sequence in the \"vessels_name\" list\n",
        "                    # print(predicted_class)\n",
        "                    else:\n",
        "                        if predict in {0, 1, 2} and real in {0, 1, 2}:\n",
        "                                # print(f\"predicted {predicted_class}, real {real_class}\")\n",
        "                                mainBifurcations_correct[0] += 1\n",
        "\n",
        "                        elif predict in {3, 4} and real in {3, 4}:\n",
        "                                # print(f\"predicted {predicted_class}, real {real_class}\")\n",
        "                                mainBifurcations_correct[1] += 1\n",
        "                        \n",
        "                        elif predict in {7, 8} and real in {7, 8}:\n",
        "                                mainBifurcations_correct[2] += 1\n",
        "\n",
        "                    # print(\"hello\")\n",
        "                    total += 1\n",
        "\n",
        "\n",
        "    print(\"\\n\\nOverall Accuracy (excluding unknowns) is:\", round(correct/total,3))\n",
        "    print(\"------------------------\")\n",
        "\n",
        "    for i in range(len(vessels_count)):\n",
        "        acc = round(vessels_correct[i]/vessels_count[i],3)\n",
        "        string = f\"Accuracy of {vessels_names[i]} is:\"\n",
        "        print(\"{:<30} {:<5}\".format(string, acc))\n",
        "\n",
        "    print(\"------------------------\")\n",
        "    print(f\"No of samples for each vessel in a batch is {vessels_count}\")\n",
        "\n",
        "    mainBifurcations_count[0] = vessels_count[0] + vessels_count[1] + vessels_count[2] #LCA\n",
        "    mainBifurcations_count[1] = vessels_count[3] + vessels_count[4] #LCX\n",
        "    mainBifurcations_count[2] = vessels_count[7] + vessels_count[8] #RCA \n",
        "\n",
        "    mainBifurcations_correct[0] += vessels_correct[0] + vessels_correct[1] + vessels_correct[2]  #LCA\n",
        "    mainBifurcations_correct[1] += vessels_correct[3] + vessels_correct[4]  #LCX\n",
        "    mainBifurcations_correct[2] += vessels_correct[7] + vessels_correct[8]  #RCA\n",
        "\n",
        "    print(\"------------------------\")\n",
        "    print(f\"Bifurcation LCA has accuracy of {round(mainBifurcations_correct[0]/mainBifurcations_count[0], 3)}\")\n",
        "    print(f\"Bifurcation LCX has accuracy of {round(mainBifurcations_correct[1]/mainBifurcations_count[1], 3)}\")\n",
        "    print(f\"Bifurcation RCA has accuracy of {round(mainBifurcations_correct[2]/mainBifurcations_count[2], 3)}\")\n",
        "\n",
        "    # print(test_y)\n",
        "    return true_class_array, predicted_class_array\n",
        "\n",
        "\n",
        "true_class_array, predicted_class_array = test(model)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Overall Accuracy (excluding unknowns) is: 0.767\n",
            "------------------------\n",
            "Accuracy of ldai is:           0.962\n",
            "Accuracy of diags is:          0.69 \n",
            "Accuracy of septals is:        1.0  \n",
            "Accuracy of lcxi is:           0.815\n",
            "Accuracy of obtmar is:         0.4  \n",
            "Accuracy of atrials is:        nan  \n",
            "Accuracy of lcim is:           0.0  \n",
            "Accuracy of acutes is:         0.88 \n",
            "Accuracy of crux is:           0.822\n",
            "Accuracy of unknown is:        nan  \n",
            "------------------------\n",
            "No of samples for each vessel in a batch is [26 29  1 27 20  0  3 25 45  0]\n",
            "------------------------\n",
            "Bifurcation LCA has accuracy of 0.893\n",
            "Bifurcation LCX has accuracy of 0.851\n",
            "Bifurcation RCA has accuracy of 0.929\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:75: RuntimeWarning: invalid value encountered in long_scalars\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pxQjuU2CYx5f",
        "colab_type": "text"
      },
      "source": [
        "# Analysis "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iY5iEU8f69aZ",
        "colab_type": "text"
      },
      "source": [
        "## Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cqnJMlKtUlfs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "5ed5d6d6-47ba-4401-9176-b15f12800787"
      },
      "source": [
        "from sklearn import metrics\n",
        "\n",
        "# y_true = np.array()\n",
        "\n",
        "# True values\n",
        "y_true = true_class_array\n",
        "# Predicted values\n",
        "y_pred = predicted_class_array\n",
        "\n",
        "y_true, y_pred = zip(*[(i, j) for i, j in zip(y_true, y_pred) if i !=9]) # zip(*..) is unzip\n",
        "\n",
        "\n",
        "# Print the confusion matrix\n",
        "array=metrics.confusion_matrix(y_true, y_pred)\n",
        "print(array)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[25  1  0  0  0  0  0  0]\n",
            " [ 2 20  1  0  5  1  0  0]\n",
            " [ 0  0  1  0  0  0  0  0]\n",
            " [ 0  1  0 22  4  0  0  0]\n",
            " [ 0  4  1  6  8  1  0  0]\n",
            " [ 0  1  1  0  1  0  0  0]\n",
            " [ 0  0  0  0  0  0 22  3]\n",
            " [ 2  0  0  1  1  1  3 37]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dEAMgvzs_eCH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        },
        "outputId": "af3d0622-2cf7-4def-a658-3fa5b9fb1d7d"
      },
      "source": [
        "# Print the precision and recall, among other metrics\n",
        "vessels_names_without_unknowns = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'lcim', 'acutes', 'crux']\n",
        "print(metrics.classification_report(y_true, y_pred, digits=3, target_names=vessels_names_without_unknowns))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "        ldai      0.862     0.962     0.909        26\n",
            "       diags      0.741     0.690     0.714        29\n",
            "     septals      0.250     1.000     0.400         1\n",
            "        lcxi      0.759     0.815     0.786        27\n",
            "      obtmar      0.421     0.400     0.410        20\n",
            "        lcim      0.000     0.000     0.000         3\n",
            "      acutes      0.880     0.880     0.880        25\n",
            "        crux      0.925     0.822     0.871        45\n",
            "\n",
            "    accuracy                          0.767       176\n",
            "   macro avg      0.605     0.696     0.621       176\n",
            "weighted avg      0.777     0.767     0.769       176\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9G_WTr1TS_Av",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "outputId": "f154b1c6-a4fd-4308-bee8-dabaa057a100"
      },
      "source": [
        "import seaborn as sn\n",
        "vessels_names_without_unknowns = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'atrials', 'lcim', 'acutes', 'crux']\n",
        "df_cm = pd.DataFrame(array, index = [i for i in vessels_names_without_unknowns],\n",
        "                  columns = [i for i in vessels_names_without_unknowns])\n",
        "plt.figure(figsize = (10,7))\n",
        "sn.heatmap(df_cm, annot=True, cmap=\"YlGnBu\", fmt='d')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f644b6250f0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABEAAAAM2CAYAAAD2I/YdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxU1f3/8fdM9iEh+wokIUiAAEpEdmQRQUWx8nUBoVpbvypU/Npvv1VEBVFrEfuo/lSkUhdUZFGxFgFFBZFFJCBBIpAEFEKABEICgYTsZH5/ILFpwiK5mTtz83o+Hnk8es85M+eTOb138JOz2JxOp1MAAAAAAAAWZjc7AAAAAAAAgOZGAgQAAAAAAFgeCRAAAAAAAGB5JEAAAAAAAIDlkQABAAAAAACWRwIEAAAAAABYHgkQAAAAAABgeSRAAAAAAACA5ZEAAQAAAAAAlkcCBAAAAAAAWB4JEAAAAAAAYHkkQAAAAAAAgOWRAAEAAAAAAJbnbXYATTHgo/Vmh4CffHZDldkh4CcO72izQ8C/sdt8zA4BAM6qurbM7BDwEy++L9wK39/uJNnsAJpVQPztZofQqPLchWaH0CyYAQIAAAAAACyPBAgAAAAAALA8j14CAwAAAACAp7LZmJPgSnzaAAAAAADA8kiAAAAAAAAAy2MJDAAAAAAAJrAxJ8Gl+LQBAAAAAIDlkQABAAAAAACWxxIYAAAAAABMwCkwrsWnDQAAAAAALI8ECAAAAAAAsDyWwAAAAAAAYAKWwLgWnzYAAAAAALA8EiAAAAAAAMDyWAIDAAAAAIAJbDab2SG0KMwAAQAAAAAAlkcCBAAAAAAAWB5LYAAAAAAAMAVzElyJTxsAAAAAAFgeCRAAAAAAAGB5LIEBAAAAAMAENhtzElyJTxsAAAAAAFgeCRAAAAAAAGB5LIEBAAAAAMAELIFxLT5tAAAAAABgeSRAAAAAAACA5bEEBgAAAAAAE9iYk+BSfNoAAAAAAMDySIAAAAAAAADLYwkMAAAAAAAm4BQY1+LTBgAAAAAAlkcCBAAAAAAAWB5LYAAAAAAAMAFLYFyLBEgzmtg1UZ1DAtUuMEAhft6qPFWrQ2WVWptfpA/35OtEVU2D13QLC9Jdndqpa1iQ/Lzs2l9aoeX7Dmvxj3mqNeF3sLobRjym/LyjjdaFh7fW52tmujiiluuzFRu0efMOZWXlKCsrRydPlmvUqEF67q9/MDu0FuvQoUK9+OJ8rVuXruLiE4qKCtOwYX01adLtCg4ONDu8FoWxcB+MhfmKj5Vo5cpNWrtmq3bvzlXB4aPy8fFWx+R43TR6iEb/1xDZ7fwHhavw/e1+eE4BZ0cCpBmNuSROu4pLtflIsY5VVinAy0tdw4L0310S9KvEGN27ZpsKyqvq2g+MDdMzvbuoqrZWqw4cUUl1jQbEhOnBS5PUPby1pm7KMvG3sa7AoACN+/VVDcoDHH4mRNNyvfrqYmVl5cjh8FdMTLj27DlodkgtWm5uvsaOfVhFRcUaNqyPkpLaKiNjt95552OtW7dFCxc+p9DQ1maH2SIwFu6DsXAPn322UU8/+boiI0PVu0+KYmIjVFR0XKu+2KQnps7R+nXf6fn/97+y2Wxmh9oi8P3tXnhOAedGAqQZjVj6japqnQ3K701J0G86tdMdye30t20/SpIc3l56JPUS1TqdemDd98oqLpUkvbZzn14a2F1XtYnQV20itOpgoUt/h5YgKChA991/g9lhtHiPPPJbRceEKyEhVps37dBvfjPN7JBatCef/LuKior1+OP36o47RtWVz5jxut56a4leeGGennrqfhMjbDkYC/fBWLiHxMRYzZr9sAYNTq030+MPf7hdY8c8qi8+T9PKLzZp+Ig+JkbZcvD97V54TnkelsC4Fp92M2os+SFJXx44ncRoF+hfVza0TYRC/Xy16uCRuuTHmff4x859kqTRSbHNGC1grj59uysxMY6/2LmB3Nx8rV+/VW3aRGn8+Ovr1T3wwDg5HP76+OPVKiurMCnCloOxcB+Mhfvo07ebhgzt2WCZS0RkiG4bM1yStHnTDjNCa5H4/nYfPKeA8yMBYoIBsWGSpB+Ol9WV9YwIliRtPHysQfttRcdVXnNK3cOC5GPny8VoVVU1+mRpmt78x6daMO9Lbd6UrVOn2HEFLVdaWoYkaeDA1Ab/gREY6NDll3dReXmltm3LNiO8FoWxcB+MhWfw9vaSJHl5eZkcCeB6PKeA82vSEpidO3dKki655BL5+vrWXV+IlJSUpnTtUW6/pI0CvL0U6OOlziGBuiwiWLuPn9S7u/bXtYkPCpAk7S8tb/D6U04pv6xCSa1bKa6Vv/aVNGyDi1dUeEJTp7xVr6xN23A98fSd6tkr2ZygABOdWb+dmNim0fqEhDitX79Ve/ceVL9+l7kytBaHsXAfjIX7q6k5paVL1kqSBl7JGKDl4TnlmWziD9yu1KQEyJNPPilJeuGFFxQXF1d3fSHee++9pnTtUW7v2Ebh/r51198cOqpn0ner+N9OgWnlc3ooSqtPNfoeZ8oDfdi2xUg33tRPPXpeog4d4uRo5a+DB47o/QVr9M/F6/XAxFl6692Hldy5rdlhAi5VWnp6dlpQkKPR+jPlJSUnXRZTS8VYuA/Gwv298PwC7d69X1cOStWAgT3MDgdwOZ5TwPk16b+mb775ZtlsNrVu3bretZEmT5589sq+o85e50Zu/HSTJCnUz0fdw1prYtcEvTW0hx76Zqd2HecBZKZ7f19/89NLOrbRo0+MU4DDT+++vVJzZi/T316aYFJ0AADgQrw771O9PXeZ2ifF6dmZk8wOBwDgppqUALntttvOeY36jlVWa21+kbKLS7VoeE9NvSJZd6zaKkk6WX16NkigT+NrVs+Ul1bXNFoPY90y5kq9+/ZKbd3yg9mhAC4XGHjmL0RljdafKQ8KauWymFoqxsJ9MBbua8H8FXr2L2+pQ4e2emPuVAWHBJodEmAKnlOeiVNgXMvt11PMnDnzrHUDPlrvwkiMc7i8UjklZUoOCVSwr7eOV9Uot6RcXUKD1C4wQNnF9WeFeNmkWIe/amprlXeSXZtdISQ0SJJUXl5pciSA6yUlnV47nJNzsNH6ffvyJEnt2ze+xhjGYSzcB2Phnua9vVwzn31HHTu20+tzpyo8PNjskADT8JwCzo90k0kiftoTpNZ5+qjcLYXHJUl9o0MbtL0sPFgB3l76/miJqs9ytC6M9X3GXklSm7YRJkcCuF6fPpdKktav36ra2vonIpWWlik9PVMBAX667LJOZoTXojAW7oOxcD9vvLZEM599R527JOrNt6eR/ECLx3MKOD/DZ4A4nU5t3LhR27Zt09GjR1VdXd2gjc1m07Rp04zu2q20C/TX0Ypqnaypv6mpTdI9KQkK8/dVRtEJlfy0uenqg4Wa2DVRw9pEavGP+coqLpUk+dptujclQZL00Z58l/4OVrf3x3zFxIYpwOFXrzzvYJGee2aRJGnkDb3NCA0wVXx8rAYOTNX69Vs1f/5y3XHHz/stvfzyApWVVWjMmGvlcPibGGXLwFi4D8bCvbw6+0PNevl9pXRN0muvP8ayF0A8pzwVS2Bcy+Z0Og2bUlBdXa0ZM2Zox44d521rxCkw7rwE5rYOcZrQNUEZRSeUd7JSJ6qqFervq9Tw1moTGKDCiio9uP575fzbkbZXxobpz727qKq2VqsOHNGJqhoNjA1TQpBDXx4s1NRNWSb+Ruf22Q1VZofwi815ZZnefXulUnt2VGxcmFq18teB/Ue0fu12VVZWa8CV3fS3l+6Tj4edvOPwjjY7hIuycmWaVq08vWFwYeExrV//ndq1i1bPnqePzA4NDdLDk+8yMcKLY7f5mB3CRcnNzdfYsQ+rqKhYw4b1UYcO7bRt2y6lpWUoMbGNFi16TqGhrc0Os0VgLNyHFceiurbxvQLc2ZJ/rdFjU2bLy8uuceOvVWAjJ160aROpm0YPcX1wTeDlod8XfH+7Fys+p6RkswNoVtFdHjI7hEYdzvyr2SE0C0MTIIsXL9YHH3ygm2++WSNHjtTdd9+tW2+9VVdffbV27NihBQsWKDk5WQ888IDs9qZnutw5AdI+yKHR7WN0aXhrRQb4KdDHWxWnTml/abk2HDqmD37MU0kjG5p2DwvSbzq1U9ew1vLzsulAaYWW7zusD37MU20j/bgLT0yAbNm8Sx++v05ZWftVVHhC5eWVCgpyqFOntho5qo+uv7GP4acauYKnJkBmvbxIr7zy/lnr4+IiterLOS6MyBie+g8oScrPP6KXXpqvdevSVVxcosjIUF19dT9NmnS7goP5a6srMRbuw2pj4YkJkFdmfaC/v7L4nG2u6JWit955wkURGcNTEyB8f7sfqz2nSICYgwTIBfi///s/+fj46Nlnn5UkjRkzRrfeeqtuueUWSdLhw4f18MMP65ZbbtGoUU0/wtadEyAtjScmQKzKUxMgVuXJ/4ACYH2emACxKk9NgFgV39/uxNoJkJiUyWaH0KhDO89+GIknM3TB0eHDh9WpU/1NdWpqfp7lEB0drdTUVH311VdGdgsAAAAAAHBOhiZAvLy85OPzc7Y0ICBAJ06cqNcmMjJSBQUFRnYLAAAAAABwTobu7hgeHq6jR4/WXcfGxmr37t312uTk5Cgw0BPXngEAAAAAYCROgXElQz/tTp06adeuXXXXvXr1Um5url599VWlp6dr3rx5ysjIUEpKipHdAgAAAAAAnJOhM0AGDhyooqIiFRQUKCoqStdff72+/fZbrV69WqtXr5YkxcTEaPz48UZ2CwAAAAAAcE6GJkC6du2qrl271l37+fnp6aef1ubNm3Xo0CFFRUWpZ8+e8vPzM7JbAAAAAAA8js3GEhhXMjQB0hgvLy/17du3ubsBAAAAAAA4K9JNAAAAAADA8po0A2TNmjUX/drBgwc3pWsAAAAAADwaS2Bcq0kJkNmzZ1/0a0mAAAAAAAAAV2lSAmTixIkNyjZt2qQtW7YoJSVFKSkpCgkJUXFxsXbs2KHMzEz17NlTvXv3bkq3AAAAAAAAv0iTEiBDhgypd52enq7vvvtODz30kK644op6dbfeeqs2b96sF154QSNGjGhKtwAAAAAAeDwb23K6lKGf9kcffaTevXs3SH6c0atXL/Xq1Usffvihkd0CAAAAAACck6HH4Obk5Khr167nbBMTE6OtW7ca2S0AAAAAAB6HTVBdy9BP29vbWzk5Oedss2/fPnl5eRnZLQAAAAAAwDkZmgDp3r27tm7dqhUrVsjpdNarczqd+vTTT7V161Z1797dyG4BAAAAAADOydAlMOPGjdOOHTs0d+5cLV++XJ07d1ZwcLCOHz+urKwsFRQUKDAwUOPHjzeyWwAAAAAAPI7NZjM7hBbF0ARITEyMnnnmGb3++uv6/vvvVVBQUK/+0ksv1d13363o6GgjuwUAAAAAADgnQxMg0ukkyOOPP66jR49q7969Kisrk8PhUPv27RUWFmZ0dwAAAAAAAOdleALkjLCwMBIeAAAAAACcBafAuFaTEiCzZ8++qNfZbDZNnDixKV0DAAAAAABcsCYlQNasWXPRryUBAgAAAAAAXKVJCZBZs2YZFQcAAAAAAC2KTSyBcaUmJUAiIyONigMAAAAAAKDZkG4CAAAAAACW12ynwAAAAAAAgLPjFBjX4tMGAAAAAACWRwIEAAAAAABYHktgAAAAAAAwAUtgXItPGwAAAAAAWB4JEAAAAAAAYHksgQEAAAAAwAQ25iS4FJ82AAAAAACwPBIgAAAAAADA8lgCAwAAAACAGTgFxqU8OgHy2Q1VZoeAn/z3eo/+v5KlLBrqY3YI+De1zmqzQ8BPKk4Vmx0CfuLwjjQ7BPzEy8Z3BgCg5SDdBAAAAAAALI8/2wMAAAAAYAIbS2BcigQIAAAAAAAw1P33368jR440WhccHKzXXnutQXl2drb++c9/ateuXaqqqlJsbKyGDh2q6667TnZ705NFJEAAAAAAAIDhHA6HRo4c2aDc39+/QdnmzZv1t7/9TT4+Purfv78CAwO1ZcsWvf3228rOztYf//jHJsdDAgQAAAAAABPYbDazQ2hWrVq10m233XbedmVlZZozZ47sdrumT5+uDh06SJLGjBmjp556Shs3btTXX3+tAQMGNCkeFhwBAAAAAADTbNy4USdOnFD//v3rkh+S5Ovrq7Fjx0qSPv/88yb3wwwQAAAAAABguOrqaq1du1aFhYXy9/dXfHy8UlJSGuznsX37dklSjx49GrxHly5d5Ofnp127dqm6ulo+Phd/hDsJEAAAAAAATGBz00UZkydPPmvdzJkzL/h9iouLNWvWrHplUVFR+v3vf6+UlJS6svz8fElSXFxcg/fw8vJSVFSU9u/fr8OHD6tt27YX3P9/IgECAAAAAAAMNWTIEHXp0kVt27ZVQECADh8+rBUrVmjVqlX6y1/+oj//+c9KTEyUdHoPEOn0pqmNOVN+pt3FIgECAAAAAADq/JJZHmdz66231ruOj4/XvffeK39/fy1btkwffPCBHnrooSb380u453wbAAAAAAAszmazu+VPcxoxYoQkKTMzs67sfDM8zjdD5EKRAAEAAAAAAC7RunVrSVJlZWVdWWxsrCQpLy+vQftTp06poKBAXl5eio6OblLfJEAAAAAAAIBL7Nq1S9LpzVDP6NatmyTpu+++a9A+MzNTlZWVSk5ObtIJMBIJEAAAAAAAzGGzuedPEx04cEAVFRUNygsKCvTmm29Kkq688sq68r59+yooKEgbNmzQjz/+WFdeVVWlRYsWSfp56UxTsAkqAAAAAAAwzIYNG7Rs2TJ16dJFkZGR8vf31+HDh5Wenq7q6mqlpqbqxhtvrGvvcDh033336fnnn9f06dM1YMAABQYG6ttvv1VeXp769u2r/v37NzkuEiAAAAAAAMAw3bp1U15ennJycpSdna3Kyko5HA517txZgwYN0qBBg2T7j5kmvXv31vTp0/XRRx8pLS1NVVVViomJ0Z133qmRI0c2aH8xSIAAAAAAAGAGi25KkZKSopSUlF/8us6dO2vKlCnNENFpFv24AQAAAAAAfkYCBAAAAAAAWB5LYAAAAAAAMIMB+1rgwjEDBAAAAAAAWB4JEAAAAAAAYHksgQEAAAAAwAwsgXEpZoAAAAAAAADLIwECAAAAAAAsjyUwAAAAAACYgSkJLsXHDQAAAAAALI8ECAAAAAAAsDyWwAAAAAAAYAInp8C4FDNAAAAAAACA5ZEAAQAAAAAAlscSGAAAAAAAzMAKGJdiBggAAAAAALA8EiAAAAAAAMDyWAJjghtGPKb8vKON1oWHt9bna2a6OCJrqyktVfF3W3Xi+wyV5x1UdXGxbF7eCmjTRuH9+yus3wDZ7A1zgc7aWhVt+FpHN36jiryDqq2ulk9wsBwJiYq98Vfyj44x4bextkOHCvXii/O1bl26iotPKCoqTMOG9dWkSbcrODjQ7PBajM9WbNDmzTuUlZWjrKwcnTxZrlGjBum5v/7B7NAgafnSb/T4I69JkqY+eZf+65ZBJkfUsvCccg88p9wHY+F+eE55GDtrYFyJBIhJAoMCNO7XVzUoD3D4mRCNtRWnf6v9C+bLOzhYQcmd5BsWruqSEzq+NV25897Rie3blXjvBNn+7QiqUxUV2vP3V1SanaWAdu0U1refbD4+qi4u1sndu1V5+DAJEIPl5uZr7NiHVVRUrGHD+igpqa0yMnbrnXc+1rp1W7Rw4XMKDW1tdpgtwquvLlZWVo4cDn/FxIRrz56DZoeEnxzKP6pnn3lXDoefysoqzQ6nxeE55T54TrkPxsK98JwCzo0EiEmCggJ03/03mB1Gi+AXFa2k309S627d6830qP7VaGU/+xcVb03X8a3pCrm8Z13d/vnzVJqdpXbjfq2IQYMbvKfzVI1LYm9Jnnzy7yoqKtbjj9+rO+4YVVc+Y8breuutJXrhhXl66qn7TYyw5Xjkkd8qOiZcCQmx2rxph37zm2lmhwRJTqdTTzz+hkJCAnXV1T31ztwVZofU4vCcch88p9wHY+FeeE4B58YeILC8oM5dFHzpZQ2WufgEByti0Omp4yW7suvKy3L36djmTQq5olejyQ9JsnmROzRSbm6+1q/fqjZtojR+/PX16h54YJwcDn99/PFqlZVVmBRhy9Knb3clJsbVmxUF8y18d6U2p2Vp+p9/p4AAX7PDaXF4TrkXnlPug7FwHzynPJTN5p4/FmVoAqS0tFQHDhxQdXV1vfLVq1frueee04svvqgffvjByC49VlVVjT5ZmqY3//GpFsz7Ups3ZevUqVqzw2pxziQybHavurJjmzZJkkKv6K1T5WU6mrZRh1Z8osJ1a1VZUGBKnFaXlpYhSRo4MFX2/0hUBQY6dPnlXVReXqlt27IbezlgeXt+zNNLLyzWuF9frZ5XdDI7nBaJ5xQAd8dzCjg/Q/+MvXDhQq1bt06vv/56Xdmnn36qt956q+568+bNevbZZ9W2bVsju/Y4RYUnNHXKW/XK2rQN1xNP36mevZLNCaqFcZ46paMbv5Ekte7ata68bF+OJKnqaJF2PP6YTp0s/flFNpsiBg1W2zG3N7pxKi7OmfXCiYltGq1PSIjT+vVbtXfvQfXrd5krQwNMV1NzSo9PeU0xsWGa9IebzQ6nxeI5BcDd8ZwCzs/QBEh2dra6desmX9+fp+YuXbpUYWFhevDBB1VcXKxZs2Zp2bJlmjBhwgW95+TJk89aN/XP1zQ5ZjPceFM/9eh5iTp0iJOjlb8OHjii9xes0T8Xr9cDE2fprXcfVnLnlp0gcoW8j/6piryDat2tu1p37VZXXl1yQpJ0cPH7Crmsh2J/dZN8QkJVlrNX++e/q8I1X8k7MEixo240K3TLKS0tkyQFBTkarT9TXlJy0mUxAe7iH3//WNmZuXpz3hT5+7P0xSw8pwC4O55THsq6q03ckqF/wj569KiioqLqrg8cOKCioiJdd9116ty5s/r27auePXsqMzPTyG49zr2/v0G9+3RWeERrBQT46pKObfToE+M0/s5hqqyo1pzZy8wO0fIKvlylgpWfyy8mRgm/vbt+pdMpSfKPiVHiPffJPyZWXv7+CurcRYn3TZBsNhWs+kK1NWyECqB5fZ/xo958bbnu+M01uqzHJWaHAwAA4NEMnQFSVVVVb/ZHVlaWJKl79+51ZdHR0UpPT7/g95w5c+ZZ60qrv7yIKN3XLWOu1Ltvr9TWLeyT0pyOrP5SB99fJP/YWF3yh/+Td6tW9eq9Ak5nx4O7N9w41dG2nXwjIlR15IgqDuXL0bady+K2ssDAM3+RKGu0/kx5UFCrRusBK6qpOaWpU15XfEK0fv8/o80Op8XjOQXA3fGcAs7P0ARIWFiYDh78+ezvbdu2yeFwKCEhoa7s5MmT9ZIk+FlIaJAkqby80uRIrKtg1Uod/OA9+ce10SV/+KN8Wjc8B90vOlplOXvl5Qho9D28HQ5VSXJWVTVztC1HUtLptao5OQcbrd+3L0+S1L5942taASsqL6vUvpzDkqQ+qfc12ubpJ97S00+8pXG/vloPTRnnyvBaHJ5TANwdzykPZWcNjCsZmgDp2rWr1qxZoxUrVsjHx0fffvut+vTpU28X4sOHDys8PNzIbi3j+4y9kqQ2bSNMjsSaDn/2qfI++qcC2rXTJQ/+r7wDgxptF9Sli46lbVR5Xl6Dutrq6rqTYHzDGSej9OlzqSRp/fqtqq2trffMKC0tU3p6pgIC/HTZZZx+gZbDx9dbN918ZaN1WTv3KSszV6mXd1RC+xhdyvKYZsdzCoC74zkFnJ+hCZDRo0crLS1Nc+fOlST5+/vrtttuq6svKytTVlaWhgwZYmS3HmXvj/mKiQ1TgMOvXnnewSI998wiSdLIG3qbEZqlHVq+TPlLlyggPuF08qPV2af+haT2VP5HH6n42806OeQqtWrf/uf3+WSZTpWXK7BTJ/kEB7si9BYhPj5WAwemav36rZo/f7nuuGNUXd3LLy9QWVmFxoy5Vg6Hv4lRAq7l7++rJ576baN1r77yL2Vl5uqGXw3Qf90yyMWRtUw8pwC4O55TwPnZnM6fdnw0SHFxsTZu3ChJuuKKKxQR8fNfyffs2aO1a9dq4MCBuuSSpv+1yhP3AJnzyjK9+/ZKpfbsqNi4MLVq5a8D+49o/drtqqys1oAru+lvL90nHx9Dc1PN7r/Xu2+8Rd9sUO7bcyW7XZFDrpJXQMOlLb7h4QrvP6Du+sTOndoz+2VJUnCPVPmGhOpkzh6d/OEHeQcFqeOfJss/Otplv8MvsWhojNkhXJTc3HyNHfuwioqKNWxYH3Xo0E7btu1SWlqGEhPbaNGi5xQa2nDJkrurdVabHcIvtnJlmlat3CRJKiw8pvXrv1O7dtHq2TNFkhQaGqSHJ99lYoQXp+JUsdkhGObVV/6lObM/1tQn7/LIBIjDO9LsEC6KFZ9TnviMkqz7nPJEVh0Lu83H7BAuihWfU1Ky2QE0q47D3zA7hEbt/uLu8zfyQIb/V2tISIiuvfbaRuuSkpKUlJRkdJce5YreydqXc1hZWfu17bsfVV5eqaAgh3qkdtDIUX10/Y19ZLOxDsxIVYWFp/9Hba2OfLmy0TaBHZPrJUBap6Qo+ZFHdXj5MpVmZepUebm8WwcrYtBgxYy8QT4hIa4IvUWJj4/Vhx8+r5demq9169K1du0WRUaG6s47b9SkSbcrODjQ7BBbjKzMvfrXv1bXK9u//7D27z+9H0VcXKRH/mMWaCqeU+6D55T7YCzcC88p4NwMnwHiSp44A8Sq3HkGSEvjqTNArMpT/7pqRVaaAeLpPHUGiBXxjAIa56kzQKyJGSBmYAbIBVi8ePF529hsNgUEBKht27ZKSUmRtzf/4QwAAAAAaIGY/O9ShmYfPvjgg1/UPigoSL/73e/Uv39/I8MAAAAAAACox9AEyBNPPKFPPvlEW7du1aBBg9S5c2cFBwfr+PHjyszM1Lp165SamqqBAwdq7969WrFihV5++WWFhoaqS5cuRoYCAAAAAABQx9AEyJEjR5SRkaEZM2YoPj6+Xt3gwYN17bXXaurUqerdu7duv7MEf7sAACAASURBVP12DRgwQJMnT9bSpUtJgAAAAAAAWhY7a2BcyW7kmy1fvlz9+vVrkPw4IzExUf369dPy5cslSfHx8br88su1a9cuI8MAAAAAAACox9AESF5enkLOczxoaGio8vLy6q5jY2N18uRJI8MAAAAAAACox9AlMAEBAeedzbFr1y75+/vXXVdUVCggIMDIMAAAAAAAcH+sgHEpQ2eApKamaufOnVqwYIEqKirq1VVUVGjBggXauXOnUlNT68r379+vyMhII8MAAAAAAACox9AZIOPGjdOOHTu0ZMkSffHFF0pISKg7BWbfvn0qKytTRESEbr/9dknSsWPHdOjQIQ0fPtzIMAAAAAAAAOoxNAESEhKiGTNmaP78+dqwYYMyMzPr6nx9fTV48GCNHz9ewcHBkk7vBzJnzhwjQwAAAAAAwCM4bayBcSVDEyCS1Lp1a02cOFH33HOP8vLyVFZWJofDobi4OHl7G94dAAAAAADAeTVbRsLb2/usx+ECAAAAAAC4ElMyAAAAAAAwg50lMK5keALE6XRq48aN2rZtm44eParq6uoGbWw2m6ZNm2Z01wAAAAAAAI0yNAFSXV2tGTNmaMeOHUa+LQAAAAAAQJPYjXyzJUuWaMeOHbr55pv1xhtvSJJuvfVWzZkzR//zP/+jiIgI9e/fXwsXLjSyWwAAAAAAPI/NTX8sytAEyDfffKP27dvrtttuU2BgYF15SEiIBgwYoGnTpik9PV3Lly83slsAAAAAAIBzMjQBcvjwYXXq1KleWU1NTd3/jo6OVmpqqr766isjuwUAAAAAADgnQxMgXl5e8vHxqbsOCAjQiRMn6rWJjIxUQUGBkd0CAAAAAOB5bDb3/LEoQxMg4eHhOnr0aN11bGysdu/eXa9NTk5OveUxAAAAAAAAzc3QBEinTp20a9euuutevXopNzdXr776qtLT0zVv3jxlZGQoJSXFyG4BAAAAAADOydBjcAcOHKiioiIVFBQoKipK119/vb799lutXr1aq1evliTFxMRo/PjxRnYLAAAAAIDnsVt3uYk7MjQB0rVrV3Xt2rXu2s/PT08//bQ2b96sQ4cOKSoqSj179pSfn5+R3QIAAAAAAJyToQmQxnh5ealv377N3Q0AAAAAAMBZNXsCBAAAAAAANIIVMC7VpATImjVrJEm9e/dWQEBA3fWFGDx4cFO6BgAAAAAAuGBNSoDMnj1bktSxY0cFBATUXV8IEiAAAAAAAMBVmpQAmThxoiQpNDS03jUAAAAAADgPG2tgXKlJCZAhQ4ac8xoAAAAAAMAd2M0OAAAAAAAAoLk1aQbIpEmTLup1NptNL7/8clO6BgAAAADAs7EExqWalABxOp0NympqalRcXCxJstvtCgoKUklJiWprayVJISEh8vbm9F0AAAAAAOA6TcpEvPLKK/Wuy8rK9PTTTysyMlLjxo1T586dZbfbVVtbq8zMTC1YsEBOp1NTp05tUtAAAAAAAAC/hKF7gCxatEhlZWWaPn26UlJSZLeffnu73a6uXbvqiSeeUGlpqRYuXGhktwAAAAAAeB67m/5YlKFrUTZt2qQBAwacdYmLr6+vrrjiCm3YsEG/+93vmtxfoE/bJr8HjLFoqNkR4IxaZ7XZIeDf2G0+ZoeAnzi8I80OAXA7p/jOcBs+dofZIQCA5Rma2ykpKdGpU6fO2ebUqVMqKSkxslsAAAAAAIBzMjQBEhMTo40bN6qsrKzR+tLSUm3cuFHR0dFGdgsAAAAAgOex2dzzx6IMTYAMHz5cx44d05QpU7RmzRoVFBSoqqpKBQUF+uqrr/TYY4+puLhY11xzjZHdAgAAAAAAnJOhe4Bce+21ys/P14oVKzR79uyztiEBAgAAAABo8aw72cItGZoAkaTf/va3GjBggL788kvl5OSorKxMDodD7du315AhQ9SpUyejuwQAAAAAADgnwxMgkpScnKzk5OTmeGsAAAAAAIBfrFkSIAAAAAAA4NycdtbAuJKhm6ACAAAAAAC4IxIgAAAAAADA8lgCAwAAAACAGWwsgXElZoAAAAAAAADLIwECAAAAAAAsjyUwAAAAAACYgRUwLsUMEAAAAAAAYHkkQAAAAAAAgOWxBAYAAAAAADPYWQPjSswAAQAAAAAAlkcCBAAAAAAAWB5LYAAAAAAAMIONJTCuxAwQAAAAAABgeSRAAAAAAACA5bEEBgAAAAAAM7ACxqWYAQIAAAAAACyPBAgAAAAAALA8lsAAAAAAAGAGO2tgXIkZIAAAAAAAwPJIgAAAAAAAAMtjCQwAAAAAAGZgCYxLMQMEAAAAAABYHgkQAAAAAABgeSyBAQAAAADABE5WwLgUM0AAAAAAAIDlkQABAAAAAACWxxIYAAAAAADMwCkwLkUCxCSHDhXqxRfna926dBUXn1BUVJiGDeurSZNuV3BwoNnhtSiMhXv4bMUGbd68Q1lZOcrKytHJk+UaNWqQnvvrH8wOrcXi3nAfjIX7YCzMV3ysRCtXbtLaNVu1e3euCg4flY+Ptzomx+um0UM0+r+GyG5nkrMrcV+4F8YDODub0+l0mh3ExdtldgAXJTc3X2PHPqyiomING9ZHSUltlZGxW2lpGWrfvo0WLnxOoaGtzQ6zRbDiWNQ6q80O4aKMvumPysrKkcPhr5iYcO3Zc9ASCRC7zcfsEC6KFe8NT8VYuA8rjkV1bZnZIfxi7y36Qk8/+boiI0PVu0+KYmIjVFR0XKu+2KSSkjINH9FHz/+//5XN5ll/VfWxO8wO4aJY8b7wZNYcj2SzA2hWSfcuNjuERu35xy1mh9AsvKZPnz7d7CAuXpHZAVyUP/7xr8rOztHjj9+rRx+9R/3799Do0cNUWlqmr77arJKSMg0d2tvsMFsEK46FU7Vmh3BR2ifG6b4Jt+jhh3+jjh3j9a9/rVanTgkaPqKv2aE1ic3mZXYIF8WK94anYizchxXHwhOT5idLyzXimr6aNv2/NeKavurXr7uuGtZLN900RCtWfKOMbbuVnByvDh3amh3qL+LloQlzK94Xnsya4xFudgDN6sVlmZLN5nY/D45KMfujaRbMD3Sx3Nx8rV+/VW3aRGn8+Ovr1T3wwDg5HP76+OPVKiurMCnCloOxcC99+nZXYmKcx/3Fzoq4N9wHY+E+GAv30advNw0Z2rPBMpeIyBDdNma4JGnzph1mhNbicF+4F8YDOD8SIC6WlpYhSRo4MLXBF3dgoEOXX95F5eWV2rYt24zwWhTGAmgc94b7YCzcB2PhGby9T8+68/LyzNl3nob7wr0wHsD5GZYAqa2tVWVlZYPy7du3a+7cuVqwYIEKCgqM6s5j7dlzUJKUmNim0fqEhDhJ0t69B10WU0vFWACN495wH4yF+2As3F9NzSktXbJWkjTwystMjqZl4L5wL4yHh7Lb3PPHogw7Beadd97RF198oddee00Ox+lNnL7++mu99NJLdW1WrVqlmTNnKiIiwqhuPU5p6enNxoKCGt/o6kx5SclJl8XUUjEWQOO4N9wHY+E+GAv398LzC7R7935dOShVAwb2MDucFoH7wr0wHsD5GZYAyczMVNeuXeuSH5K0ePFitWrVSnfddZeKi4u1cOFCLVu2THfdddcFv+/kyZPPWjdz5t1NCRkAAAAW8O68T/X23GVqnxSnZ2dOMjscAICbMiwBUlRUpE6dOtVdHz58WHl5ebr55ps1aNAgSaeTJNu2bTOqS48UGHgm89r4sXNnyoOCWrksppaKsQAax73hPhgL98FYuK8F81fo2b+8pQ4d2uqNuVMVHBJodkgtBveFe2E8PBS7crqUYQmQ8vJyBQQE1F1nZ5/eXKdHj5+nILZr1047dvyyXblnzpx5jtpdv+i93EFS0uk1eTk5ja+927cvT5LUvn3ja/dgHMYCaBz3hvtgLNwHY+Ge5r29XDOffUcdO7bT63OnKjw82OyQWhTuC/fCeADnZ1i+KSQkpN4mpxkZGfL19VVSUlJdWUVFRYvflbtPn0slSevXb1VtbW29utLSMqWnZyogwE+XXdapsZfDQIwF0DjuDffBWLgPxsL9vPHaEs189h117pKoN9+eRvLDBNwX7oXxAM7PsARIx44d9e2332rLli3KyMhQWlqaunXrJm/vnyeZFBQUKCwszKguPVJ8fKwGDkzVwYMFmj9/eb26l19eoLKyCt1441A5HP4mRdhyMBZA47g33Adj4T4YC/fy6uwP9cLzC5TSNUlvvDlVoaGtzQ6pReK+cC+Mh4ey2dzzx6JsTqfTacQb5ebm6tFHH1V1dbUkyW6366mnnlLHjh0lSVVVVbrnnnvUt29fTZw40Ygu5YlLYCQpNzdfY8c+rKKiYg0b1kcdOrTTtm27lJaWocTENlq06Dm+yF3EimNR66w2O4SLsnJlmlat3CRJKiw8pvXrv1O7dtHq2TNFkhQaGqSHJ99lYoQXx27zMTuEi2LFe8NTMRbuw4pjUV3b+F4B7mzJv9bosSmz5eVl17jx1yqwkRMv2rSJ1E2jh7g+uCbwsTd+coe7s+J94cmsOR7JZgfQrJImfWR2CI3aM2u02SE0C8MSINLpJMhXX30lSerfv78uueSSurpdu3ZpyZIluuaaa3TppZca1KNnJkAkKT//iF56ab7WrUtXcXGJIiNDdfXV/TRp0u0KDmbzLley2lh4agJk1suL9Mor75+1Pi4uUqu+nOPCiIzhqQkQyXr3hidjLNyH1cbCExMgr8z6QH9/ZfE521zRK0VvvfOEiyIyhqcmQCTr3ReeznrjQQLEDCRA3JLnJkCA5uKpCRCr8uQECADr88QEiFV5cgIEaF4WT4D8z7/MDqFRe166yewQmgWH7gAAAAAAAMu76GNw16xZc9GdDh48+KJfCwAAAAAA8EtddAJk9uzZF90pCRAAAAAAQEvntPCJK+7oohMgxp3kAgAAAAAArGzt2rWaNWuWJOm+++7TsGHDGrTZsmWLli5dqr1796q2tlbt2rXTiBEjNGTIEENiuOgEiFEBAAAAAAAA6yosLNSbb74pf39/VVRUNNpmxYoVevPNNxUUFKQrr7xS3t7eSktL0+zZs5Wbm6s777yzyXFcdAIEAAAAAAA0QQs4lsTpdOrvf/+7goKC1Lt3by1durRBm4KCAs2bN0+BgYGaMWOGoqKiJEm33HKLpkyZomXLlqlv375KTm7aqUAt4OMGAAAAAABm+PTTT7V9+3ZNnDhRfn5+jbZZvXq1qqurde2119YlPyQpMDBQo0ePliR9/vnnTY7F0BkgFRUV+vzzz7Vt2zYdPXpU1dXVDdrYbDa9/PLLRnYLAAAAAADczIEDBzR//nxdd911SklJ0fbt2xttd6a8R48eDepSU1MlSTt27GhyPIYlQE6ePKlp06bpwIEDCggIUHl5uRwOh2pqalRVVSVJCg0NlZeXl1FdAgAAAADguezueQrM5MmTz1o3c+bMC3qPU6dOadasWYqIiNC4cePO2TYvL0+SFBsb26AuNDRUfn5+KioqUmVl5VlnkVwIw5bAfPjhhzpw4IAmTJiguXPnSpKuv/56vfPOO3r66afVvn17RUdH64UXXjCqSwAAAAAA4IYWL16svXv36v7775evr+8525aVlUmSHA5Ho/Vnys+0u1iGzQDZsmWLunTpoqFDh9Yrt9lsSk5O1pQpU/SnP/1J//znPzV27FijugUAAAAAAAa60FkeZ7N792599NFHGjVqVJM3LjWSYTNACgsLlZSUVHdts9nq7QESHBysHj16aMOGDUZ1CQAAAACA57LZ3POnCc4sfYmNjdWYMWMu6DXnm+FxvhkiF8qwGSB+fn6y/dsH5XA4VFxcXK9NcHCwjh49alSXAAAAAADAjVRUVCg/P1+SNH78+EbbzJkzR3PmzNHIkSN11113KS4uTtnZ2crPz1dQUFC9tseOHVNlZaXCw8ObtP+HZGACJDw8XEVFRXXXbdu2VWZmpmpra2W3n55okp2drZCQEKO6BAAAAAAAbsTHx0dXXXVVo3V79+7V3r171blzZ8XFxdUtj+nWrZuys7P13XffNVgys3XrVklS165dmxybYQmQlJQUffPNN3I6nbLZbOrfv7/mzp2rGTNmqGfPntq5c6d27dqlESNGGNUlAAAAAACey01PgWkKX19fTZgwodG6999/X3v37tXgwYM1bNiwuvKhQ4fq448/1ooVKzRkyBBFRUVJkkpLS/XRRx9JkiG5BMMSIIMHD1ZNTY2KiooUERGh4cOHa/v27dq8ebMyMjIkSZ06dWIDVAAAAAAAUCcqKkq//vWvNXfuXE2ZMkX9+vWTt7e30tLSVFRUpBtuuMGQzVQNS4AkJSXV2wTVy8tLf/rTn7Rnzx4dOnRIkZGR6tChQ91yGAAAAAAAAEm67rrrFBkZqaVLl2rt2rVyOp1q27atxowZoyFDhhjSh83pdDoNeSdT7DI7AMDt1Dqrz98ILmO3+ZgdAgCcVXVt47vtw/V87E072QCwLvc5QrU5tJ+8zOwQGrV35g1mh9AsDJuOMWnSJH3yySfnbLNixQpNmjTJqC4BAAAAAAAuiGEJkCNHjpz1zN4zysrKdOTIEaO6BAAAAAAAuCCG7QFyIcrLy+Xt7dIuAQAAAABwS04LngLjzpqUjSgsLKx3ffLkyQZlklRbW6vCwkKlpaUpOjq6KV0CAAAAAAD8Yk1KgNx///31rj/55JPz7gNy5513NqVLAAAAAACAX6xJCZBBgwbJZrPJ6XRq7dq1SkhIUGJiYoN2drtdgYGB6t69uy677LKmdAkAAAAAgDWwBMalDJsBsnbtWvXu3Vu33HJLk4MCAAAAAAAwkmE7kr733ntGvRUAAAAAAIChmuVIlsLCQuXk5KisrEwOh0OJiYmKiIhojq4AAAAAAPBMNpbAuJKhCZD8/Hy9/vrr2r59e4O6bt266e6771ZcXJyRXQIAAAAAAJyXYQmQQ4cO6fHHH1dpaamio6PVuXNnhYSEqLi4WFlZWdq+fbumTZumP//5z4qJiTGqWwAAAAAAgPMyLAGyYMEClZaW6q677tI111wju91eV1dbW6sVK1bo7bff1oIFC/THP/7RqG4BAAAAAPBM9vM3gXEMS4B8//33Sk1N1XXXXdegzm63a+TIkdq2bZu+//57o7oEAAAAAAC4IIblm2pqapSYmHjONomJiTp16pRRXQIAAAAAAFwQw2aAJCYm6tChQ+dsc+jQISUkJBjVJQAAAAAAnotTYFzKsBkgo0ePVlpamrZu3dpofXp6ujZt2qTRo0cb1SUAAAAAAMAFMWwGSElJiVJTU/Xss8+qe/fu6tKli4KDg3X8+HHt3LlT27dvV8+ePVVSUqI1a9bUe+3gwYONCgMAAAAAAKABm9PpdBrxRmPGjLno17733nsX9bpa546L7hOwKrvNx+wQ8G8GLztidgj4yUfDj5odAn4S5tfJ7BDwk1pntdkh4Cd8fwNnk2x2AM0q8cnPzA6hUTlPXGN2CM3CsBkgEydONOqtAAAAAAAADGVYAmTIkCFGvRUAAAAAAIChDEuAAAAAAACAX8DOKTCuZHgC5MSJE9q4caMOHjyoyspKTZgwoa68oKBA8fHx8vX1NbpbAAAAAACAszI0AfLll19q7ty5qqqqqis7kwApLi7WY489pvvuu09XXXWVkd0CAAAAAACck92oN8rIyNCcOXMUGxurhx56SMOHD69XHx8fr3bt2mnTpk1GdQkAAAAAgMdy2mxu+WNVhs0AWbJkiUJDQzV9+nQ5HA7t3bu3QZv4+Hjt3r3bqC4BAAAAAAAuiGEzQH788UddfvnlcjgcZ20THh6u4uJio7oEAAAAAAC4IIbNAKmpqZG/v/8525w8eVJ2u2E5FwAAAAAAPBf/eexShn3ckZGR2rNnzznb/PDDD4qLizOqSwAAAAAAgAtiWAKkV69eyszM1DfffNNo/erVq7Vv3z716dPHqC4BAAAAAAAuiGFLYG688UZ9/fXXevHFF7Vx40aVlZVJklasWKHMzExt2rRJsbGxuvbaa43qEgAAAAAAz2XhE1fckWEJkMDAQD355JOaNWuWNm7cWFc+d+5cSVLnzp314IMPnnefEAAAAAAAAKMZlgCRpIiICE2fPl379u3Trl27VFJSIofDoeTkZCUlJRnZFQAAAAAAwAUzNAFyRkJCghISEiRJJSUlyszM1IkTJ3TppZdyCgwAAAAAAJJkZwmMKxmWAPn888/11Vdf6dFHH1VgYKAkac+ePXrmmWdUWloqSerQoYOmTZvGMhgAAAAAAOBShk3H2LBhg2w2W13yQ5LmzZunkydPaujQoUpNTdWPP/6oL774wqguAQAAAAAALohhCZD8/HzFx8fXXZ84cUI7d+7UVVddpQkTJuiRRx5Rhw4dtH79eqO6BAAAAADAc9lt7vljUYYlQEpLSxUcHFx3nZ2dLUnq3bt3XVnnzp1VWFhoVJcAAAAAAAAXxLAESGBgoE6cOFF3vXPnTtntdiUnJ9eV2Ww2VVVVGdUlAAAAAADABTFsE9Q2bdpoy5YtKikpkd1u14YNG9ShQwc5HI66NkeOHFFISIhRXQIAAAAA4Lmsu9rELRk2A2TkyJEqLi7WhAkTNHHiRBUXF2vEiBH12uzevbvueFwAAAAAAABXMWwGyBVXXKF77rlHK1eulCQNHDhQgwYNqqvfsWOHKioq1KNHD6O6BAAAAAAAuCCGJUAk6eqrr9bVV1/daF3Xrl01d+5cI7sDAAAAAMBjOS184oo7MmwJDAAAAAAAgLsiAQIAAAAAACzP0CUwAAAAAADgAtlYAuNKzAABAAAAAACWxwwQAAAAAADMwCaoLsUMEAAAAAAAYHkkQAAAAAAAgOWxBAYAAAAAADOwAsalmAECAAAAAAAsjwQIAAAAAACwPJbAmOCzFRu0efMOZWXlKCsrRydPlmvUqEF67q9/MDu0FoexcC+HDhXqxRfna926dBUXn1BUVJiGDeurSZNuV3BwoNnhWUprH29dGROuftGhah/kUKS/r6prndpTUqZP9x/Wp/sL5PyP1wR4eWn8JW00KDZcMQH+qjpVq8ziEi388aDSi46b8ntY3fIlm/Xnqe+ds43dbtPX3/3VRRGB55R74PvbvXBfuBfGw7PYmZLgUiRATPDqq4uVlZUjh8NfMTHh2rPnoNkhtViMhfvIzc3X2LEPq6ioWMOG9VFSUltlZOzWO+98rHXrtmjhwucUGtra7DAtY0hshP7v0g4qrKjS1qLj+qq8UmG+ProyNlyTL+uoPlGhemJLdl37QB8vzep/qdoHObTnxEl9vO+QAry9NDA6TC/066aZ23brk/0FJv5G1tSxU5zunjC80brv0vdqy6Yf1HdgZxdH1XLxnHIffH+7D+4L98J4AOdGAsQEjzzyW0XHhCshIVabN+3Qb34zzeyQWizGwn08+eTfVVRUrMcfv1d33DGqrnzGjNf11ltL9MIL8/TUU/ebGKG17D9ZrimbduqbgmP1Znq8lr1Prw68TENiIzQoplBrDxVJkn6bHK/2QQ6tyS/Uk+nZOvXTi17z9dE/rrxMD3ZL0uYjxTpSUeX6X8bCkju3UXLnNo3W3fPrlyVJN93c15UhtWg8p9wH39/ug/vCvTAewLkx4cYEffp2V2JinGw2tvw1G2PhHnJz87V+/Va1aROl8eOvr1f3wAPj5HD46+OPV6usrMKkCK1na9FxbfiP5IckHa2s1sf7DkmSUsN//gvRlTHhkqQ3s3Prkh+SVFxVrff3HJS/l5dGtotu7rDxkx925Wt7xj5FRgWr/6AuZofTIvCcci98f7sH7gv3wnh4JpvNPX+sigQIANOlpWVIkgYOTJX9PxZCBgY6dPnlXVReXqlt27IbezkMVlN7OsNR82+JjjA/H0lSXlllg/Znyi6PCG7+4CBJWvLhRknSqNG95eXFV7kr8JwCGuK+cC+MB3B+/KsJgOnOrN1OTGx8qn9CQpwkae9e1ng3Ny+bdE3bSEnSpiPH6sqPV9VIkmIdfg1eE/dTWbtWAS6IEBUV1fpsWbq8vOy68eY+ZofTYvCcAhrivnAvjAdwfk3aA2TMmDGy2Wx6/vnnFRcXpzFjxlzQ62w2mxYtWtSUrgFYSGlpmSQpKMjRaP2Z8pKSky6LqaW6t3Oiklq30jeHj2rzkeK68o0FR3VDfIx+lxyvJ9OzVftTebCvt25tf/ofVEE+bCvlCqs++04lJeXqP6iLomNCzA6nxeA5BTTEfeFeGA/PZOXlJu6oSf9a7dKli2w2m/z8/OpdG2ny5MlnrZvx7J2G9gUALdnNibEa26GN9pWU6ZnvdtereyM7V70iQzUkLkLxgQH/n707j46qSvc+/qvKAFQGCJBAwpAwRZkDKsGADKKi2NgOtIC2Q7fdKi329fq20CoKaHs12o6AV9rhiopyBRTHBgQViQiEKQghRIQQJEBIQkhIASFJvX8AucYMIHVS59Sp72etrEWdc7L3I3udbXiyn721vuCwmgU7NahNSxUcK1dbSZ5aO4qgMXy0cI0k6doxbH4KAADwa3iVAJk2bVqDnwHgbISHn/6NhLvO+6evR0SE+SymQHNdQlv9tVdn7Sp16/7VW1R6oqLG/aLjJ3TXygzdmthBF8dE6dqEtjpcXqGv8gq0YNc+vXvpBTp0/IRJ0QeOnTv26/tNOYpp01wpl7D5qS8xTwG18V5YC+MBnJnl1yunpqbWe6/Ks9WHkQBoLJ07n6xVzcmpuyZ19+48SVKnTnXXtMI7YzrF6t6enbWzpEz/uXqrisvrTmQcKj+hF7fs1Iu/uN6v1cnNT7MOH2nkSPHRAjY/NQvzFFAb74W1MB7+idOsfMvQn57y8vLO6rn09HQjuwXg55KT+0iS0tI2qqqqqsa9I0fc2rBhm5o1a6K+fc8zIzxbG9+lne7t2Vk/HD6i+77bUm/yoyGnN01dtveg0eHhZ44fov90PQAAIABJREFUP6F/f7peQUFOjb6ezU99jXkKqI33wloYD+DMDE2APPjgg/rmm2/qvV9RUaE33nhD//znP43sFoCf69gxVoMH99PevfmaO/ezGvdmzHhXbvcxXXPNcLlcTU2K0J5u7dZed3dPUFbxEf3n6q06/Iuyl59zSGpWx4qDK9pFa2T7GH1fVKK0/UWNGC2+XLpZpSVHNXDQeWx+agLmKaA23gtrYTyAM3N4PB7Ddq3785//rJKSEg0dOlR/+tOfFBoaWn1v//79euGFF7Rr1y517dpVTzzxhNf9+WsJzLJla7R82VpJUkHBIaWlbVKHDm10wQU9JElRURGaNPl2EyMMHHYcC6cjxOwQzklu7j6NGzdJhYXFGjEiWV26dFBGRrbWrNmshIR2mjfvaUVFRZod5q829FNrrooY2T5aDyUlqqLKow9y9qmsonbyY7/7uBb/lC/pZPLjw8sHaF1BsfLKjqlKUu+oCPVqGamcUrfuX71VhcfLffxf8et8eLl/J2juvm2WMjbu0tMv/UGXDOtpdjheadnEP3/7aMd5qsrjn3v38P9v67Dje+HP7DkeiWYH0Ki6vlL/AgIz7bh7iNkhNApDEyDFxcV68cUXlZmZqXbt2um+++5Tx44dlZaWpldffVXHjh3T6NGjNX78eAUFBXndn78mQGbOmKdZs96v935cXLSWfznbhxEFLjuOhb/+ACVJ+/Yd1EsvzdXKlRtUXFyq6OgoXXbZxZo4cbyaNw83O7xzYtUEyO2JHfSHxI4NPrOx8LDu+26LJCnI4dD/691FvVtGKrrpyeT2T2VH9fW+Qs3fmafjv1hqa0X+nADJ2XlA4699RjFtmuuDxQ/7/f4f/poAkew3T/lrAoT/f1uL3d4Lf2e/8SABYgYSIGfJ4/FowYIF+uCDDxQcHKyePXtq48aNioyM1D333KOkpCTD+vLXBAjQmPz5Byg7smoCJBD5cwLEbvw5AWI3/poAsSP+/w3UhwSIGeyaADH8FBiHw6Hf/e53ioyM1BtvvFGd/EhNTVXLli2N7g4AAAAAAL/EITC+1ShraJctW6Z33nlHTqdTMTExKikp0YwZM1RcXNwY3QEAAAAAADTI0ATI0aNH9cILL+jVV19VeHi4Hn30UT333HMaMWKEMjMz9cADD2jDhg1GdgkAAAAAAHBGhpbATJo0Sfn5+erXr5/uueceRURESJLuvPNO9erVS7Nnz1ZqaqpGjRql2267zciuAQAAAADwKw7/3tfc7xj6111YWKhbbrlFf//736uTH6elpKTo6aefVufOnfX5558b2S0AAAAAAECDDF0B8thjj6lr16713m/Tpo3+8Y9/aO7cuUZ2CwAAAAAA0CBDEyANJT9OCwoK0q233mpktwAAAAAA+B1OgfEtQ0tgSkpKlJmZqaNHj9Z53+12KzMzUyUlJUZ2CwAAAAAA0CBDEyALFy5UamqqnM66m3U6nUpNTdWiRYuM7BYAAAAAAKBBhpbAbN68WX369FGTJk3qvN+0aVP17dtXGRkZRnYLAAAAAIDfcVIC41OGnwLTpk2bBp+JiYlRQUGBkd0CAAAAAAA0yNAEiMPhUEVFRYPPVFRUqKqqyshuAQAAAAAAGmRoCUxcXFyD5S0ej0cZGRlq27atkd0CAAAAAOB3OAXGtwxdAZKcnKy8vDy9/vrrKi8vr3GvvLxcr7/+uvLy8pSSkmJktwAAAAAAAA0ydAXIqFGj9O2332rp0qVKT09X9+7d1bJlSxUVFWnbtm06dOiQ4uPjdfXVVxvZLQAAAAAAQIMMTYCEhoZq2rRpeu211/Tdd99p1apV1fccDocGDRqkO+64Q6GhoUZ2CwAAAACA36EExrcMTYBIUlhYmP7jP/5Df/jDH7Rjxw653W65XC517dpVkZGRRncHAAAAAABwRoYnQE6LjIxU//79G6t5AAAAAACAs+ZVAuTll18+p+9zOByaMGGCN10DAAAAAODXHNTA+JRXCZAVK1ac8/eSAAEAAAAAAL7iVQJk5syZRsUBAAAAAADQaLxKgERHRxsVBwAAAAAAAcXhNDuCwMJfNwAAAAAAsD0SIAAAAAAAwPYa7RhcAAAAAABQPw6B8S1WgAAAAAAAANsjAQIAAAAAAGyPEhgAAAAAAExACYxvsQIEAAAAAADYHgkQAAAAAABge5TAAAAAAABgAkpgfIsVIAAAAAAAwPZIgAAAAAAAANujBAYAAAAAABM4KYHxKb9OgDgdIWaHgFOOnPjJ7BBwSnhIe7NDwM/MGVpkdgg4ZfcRfsKwipZNzI4AABpW5Tlhdgg4hQQBjEQJDAAAAAAAsD2/XgECAAAAAIC/4hQY32IFCAAAAAAAsD0SIAAAAAAAwPYogQEAAAAAwASUwPgWK0AAAAAAAIDtkQABAAAAAAC2RwkMAAAAAAAmcDipgfElVoAAAAAAAADbIwECAAAAAABsjxIYAAAAAABMwCkwvsUKEAAAAAAAYHskQAAAAAAAgO1RAgMAAAAAgAkogfEtVoAAAAAAAADbIwECAAAAAABsjxIYAAAAAABMYOcSmHfeeUc7d+7Uvn37VFJSotDQUEVHR+uiiy7SlVdeqYiIiFrfs337dn3wwQfKzs5WeXm5YmNjNXz4cF111VVyOr1fv8EKEAAAAAAAYKjPPvtMx48fV+/evTVq1ChdcsklCgoK0vz58/W3v/1NBQUFNZ5PT0/X1KlTlZmZqQEDBujKK69URUWF5syZoxdeeMGQmFgBAgAAAAAADDVnzhyFhobWuv7ee+/pww8/1KJFi/SnP/1JkuR2uzV79mw5nU5NmzZNXbp0kSSNHTtWjz32mFavXq1vv/1WgwYN8iomVoAAAAAAAGACp8OaX0aoK/khSRdffLEkad++fdXXVq9erZKSEqWkpFQnP063MW7cOEnS0qVLvY6JBAgAAAAAAPCJ9evXS5Li4+Orr23ZskWSlJSUVOv57t27q0mTJsrOztaJEye86psSGAAAAAAAUG3y5Mn13ktNTf1VbX388cc6duyY3G63du7cqaysLMXHx+vaa6+tfub0apC4uLha3x8UFKSYmBjt2bNHBw4cUPv27X9V/z9HAgQAAAAAABPY+RSY0z755BMdPny4+nNSUpL+8pe/KDIysvqa2+2WJLlcrjrbOH399HPnigQIAAAAAACo9mtXeTTk1VdflSQVFxcrOztbc+fO1eTJkzV58mR17tzZsH7OBnuAAAAAAACARtWiRQsNGDBAU6ZMUWlpqWbNmlV970wrPM60QuRskQABAAAAAMAEDqc1vxpTdHS02rdvrz179qikpESSFBsbK0nKy8ur9XxlZaXy8/MVFBSkNm3aeNU3CRAAAAAAAOAzhw4dkiQ5nSdTEr169ZIkbdq0qdaz27Zt0/Hjx5WYmKiQkBCv+iUBAgAAAAAADJOXl1dnOUtVVZXee+89HT58WOedd57Cw8MlSQMHDlRERIRWrVqlH3/8sfr58vJyzZs3T5J0xRVXeB0Xm6ACAAAAAGACu54Cs3HjRr377rs6//zzFRMTo4iICBUXF2vbtm06cOCAWrRoobvuuqv6eZfLpbvuukvPPfecpk2bpkGDBik8PFzr1q1TXl6eBg4cqJSUFK/jIgECAAAAAAAM07t3b1166aXKyspSTk6OysrK1KRJE8XFxemSSy7RqFGjqld/nDZgwABNmzZNH374odasWaPy8nK1bdtWt956q0aNGiWHAdkih8fj8XjdimmyzQ4Apxw58ZPZIeCU8JD2ZoeAn8kp3W52CDjlULlNf8Xih/q1SjQ7BJxS5Tlhdgg4xenwrq4dxuLdsA6no6fZITSqSz5OMzuEOq28ZrDZITQKVoAAAAAAAGACI1Y14OyxCSoAAAAAALA9EiAAAAAAAMD2KIExyf79BXrxxblauXKDiotLFBPTUiNGDNTEiePVvHn4mRuAIX5zxcPal1dU571WrSK1dEWqjyMKbLwXvrVyWYY2b9ipH7PztOuHPLnLjuvSq/pr8uM31fs9WzNy9N7ry7Rty26VHz+hdh2idcU1F+m3YwcrKIic+rla/WWGtm36UTk/5Cn3hzwddR/X4Cv6a+K0m2s9W3DgkD5660vt3P6TCvYfUlmpWxHNwxTTrpWGXz1Ag6+8QMHBQSb8VwQG5ilrWLJ4ldLTtyorK0dZWTkqKzuq0aOH6Oln7jM7tIDEe2ENvBf+iQoY3yIBYoLc3H0aN26SCguLNWJEsjp3bq/Nm3/QW299rJUr1+u9955WVFSk2WEGjPCIZrrp95fWut7M1cSEaAIX74XvvfvGcu3MzlMzVxO1jmkud1l+g8+v+nqLHp/8lkJDgzX08iRFNG+m1d9kavZzHyszI0dTUm/1UeT28+GcZdr9Q56aupqoZXRzHd1d/1gc2FuotKUb1LVHR100pJfCIl06crhMm1Zn6ZX/+l+tXLxeD71wp4JIghiOeco6XnllgbKycuRyNVXbtq20c+des0MKWLwX1sF7AZwZCRATTJ/+3yosLNaUKXfqlltGV19/8snX9OabH+n559/WY4/dY2KEgSUiopnuuuc3ZocR8HgvfO+u+69RdExzxXVorc3rf9Sku1+p99myI8f0whPzFeR06JnZE5TYo4Mk6ba7r9SkCa9o5fLN+nrJRg0b2c9X4dvKrX/9rVrGNFfb9q2VufFHPT7xv+t99rzeCXp9yeNyOmuuuKmoqNR/3TdbWzfs0NoV3+viEUmNHXbAYZ6yjr///Q9q07aV4uNjlb52q2677VGzQwpYvBfWwXsBnBnrlX0sN3ef0tI2ql27GN1889U17t17701yuZrq44+/ktt9zKQIAd/jvTBH0oVd1a5j9FntPp62fLMOHyrT0CuSqpMfkhTaJES3T7hSkvTpwu8aLVa763lBV8V2OLuxCA4JrpX8kKTg4CBdeEkvSdL+PQWGxxjomKesJXlgbyUkxHF6gsl4L6yF98I/ORzW/LIrQxMgBQUFKi4uNrJJ21mzZrMkafDgfrV+gA0Pd6l//+46evS4MjK2mxFeQCovr9Dnn6zRG//6t959+0ulr92uysoqs8MKKLwX1rdp3Q5J0oUXn1/rXu9+ndWkaYgyM3JUXl7h69BwSlVllTZ9t02S1LFrrMnR2A/zFFAb7wUAf2NoAuSee+7Ru+++a2STtnO6Fi8hoV2d9+Pj4yRJu3ZRs+crhQUleuTBNzXrpY/1bOp83f3HF3Td1Y9qfXq22aEFDN4L6/vp1J4U7eOja90LCg5S27iWqqys0v69hb4OLWCVFB/R/NeWaP5ri/X6Mwt1//hUbV6brUFX9NMFg3uaHZ7tME8BtfFeAPA3hu4BEhYWpshINjlqyJEjbklSRISrzvunr5eWlvkspkB2zbUXK+mCrurSJU6usKba+9NBvf/uCn2wIE33TpipN9+ZpMTz25sdpu3xXlhf2ZGTy5dd4U3rvB8W3kySdKT0qM9iCnSlxWVa+MbS6s8Oh0O/uWmYxt09ysSo7It5CqiN9wLwnp3LTazI0ARIt27dtGvXLiOb1OTJk+u9l5p6h6F9IfDc+Zeam5927dZOD029Sc1cTfTOnGWa/fKnevalu02KDgDq1y6hjeatelZVlVUqOnhYa1d8r/mvLdH2jF2a/OyfFB5Z9z9IAAAAApWhJTC/+93vlJWVpeXLlxvZrK2Eh5/OhLvrvH/6ekREmM9iQm1jxl4iSdq4fofJkQQG3gvrCzu18sN9pO6N7MqOnFz5ER7RzGcx4SRnkFOt20Zp1Ngh+vOkMfph6269/+pis8OyHeYpoDbeCwD+xtAVIJs2bVKPHj30r3/9S0uXLlXXrl3VokWLOnciHjNmzFm1mZqa2sBd/9ujoXPnkzWSOTl110Lu3p0nSerUqe5aSvhGi6gISdLRo8dNjiQw8F5YX/v4GGVn/qSfdh9Ut+41y8IqKyq1P69IQUFOtW3XyqQIIUlJpzapzdzwo8mR2A/zFFAb7wXgPSclMD5laAJk/vz51X/OyclRTk5Ovc+ebQLEbpKT+0iS0tI2qqqqqsaO2UeOuLVhwzY1a9ZEffueZ1aIkPT95pOlXO3atzY5ksDAe2F9SRd21Zf/3qB132Vp+JX9atz7fuNOHT92Qr37d1ZoqKH/W8GvVHTwsCQpKJhT7o3GPAXUxnsBwN8Y+pPq1KlTjWzOljp2jNXgwf2UlrZRc+d+pltuGV19b8aMd+V2H9PYsVfK5ap7o0EYZ9eP+9Q2tqWauZrUuJ63t1BPPzFPkjTqNwPMCC3g8F5Y3+ARffT6jM+0Yukm/XbsYCX26CBJKj9+Qm/+98lyi9/ccLGZIQaMXdt/UnzXODmDaiY5jrmPa84LiyRJ/S7ubkZotsY8BdTGewHA3zg8Ho/H7CDOnf+VwEhSbu4+jRs3SYWFxRoxIlldunRQRka21qzZrISEdpo372lFRfnXaTpHTvxkdgi/2uxZn+qdOcvU74Juio1rqbCwpvppz0GlfbNFx4+f0KBLeunZl+5SSIh//UY7PMQ/T62x43shSTml280OoV6rvt6iVV9vkSQVFZZq/XfbFduulXr16yRJimwRpjvvG13j+ccnv6XQ0GANuyJJEZEufffNVv20+6AuGdFHDz91S50lj1ZxqNy6saWv+F7pK0+OxeHCUmWs2a6YuFY6P+nkWEQ0D9Mt914jSfrn5De0/fscJfZKUOu2LRTaJFSF+cXKWJ2lstKjSuydoIeev1NNf5HctZJ+rRLNDuGc2HGeqvKcMDuEc7Js2RotX7ZWklRQcEhpaZvUoUMbXXBBD0lSVFSEJk2+3cQIfz2nI8TsEM6JHd8LyT/fDTu+F5LkdNj7aPfLF39rdgh1+uLKQWaH0ChIgJhk376DeumluVq5coOKi0sVHR2lyy67WBMnjlfz5uFmh/er+WMCZH16tha+v1JZWXtUWFCio0ePKyLCpfPOa69Ro5N19TXJlv7HXH38NQEi2e+9kKydAHl79hK98+oX9d5vExultz55uMa1rZt26b03lmvb97tVXn5Cce1ba+Q1A/TbcYMVFGTtsgsrJ0Dmv7akxpG2v9S6bZRmfjBFkrTh20yt+mKjdmzL1eGiIyo/Vq6wCJc6do3VwEv7avhvBigoOMhXoZ8Tf02ASPabp/zxH3mSNHPGPM2a9X699+PiorX8y9k+jMh7/poAkez3Xkj++W7Y8b2QSICYhQSIJflvAsRu/DEBYlf+nACxIysnQAKNlRMggcafEyB244//yLMrf06A2BHvhnWQADGHXRMghq/tP3TokBYuXKiMjAwVFRWpoqKi1jMOh0Pz5s0zumsAAAAAAPyG0+HH6xH8kKEJkKKiIj344IM6fPiwOnTooIqKCrVu3VohISE6cOCAqqqqlJCQIJfLZWS3AAAAAAAADTI0AbJgwQIVFxfr4YcfVp8+fTR27FgNHz5cY8aMUWFhoWbPnq2DBw/qkUceMbJbAAAAAAD8jpMKXZ8ydMe6jIwMJSUlqU+fPrXutWrVSvfff7/Ky8v1/vv1b84DAAAAAABgNEMTIMXFxerQocP/Ne50qry8vPpz06ZN1bt3b61bt87IbgEAAAAAABpkaAlMs2bNamx6GhYWpqKiohrPuFwulZSUGNktAAAAAAB+x9AVCTgjQ/++o6OjVVBQUP05Pj5eW7Zs0fHjxyVJVVVV2rx5s1q1amVktwAAAAAAAA0yNAHSq1cvbd26tXoVyNChQ3Xo0CFNmTJFb7/9th555BHt2bNHF198sZHdAgAAAAAANMjQEphLL71UYWFhKi0tVVRUlIYMGaKdO3dq8eLFys3NlSSlpKTo+uuvN7JbAAAAAAD8jtPhMTuEgGJoAiQ2NlbXXnttjWu33367rr/+eh04cEDR0dFq0aKFkV0CAAAAAACckaEJkPpERkYqMjLSF10BAAAAAADU4pMECAAAAAAAqMnpMDuCwGJ4AuT48eP68ssvlZOTo6KiohrH4p7mcDj06KOPGt01AAAAAABAnQxNgOzevVv/+Mc/VFJSYmSzAAAAAAAAXjE0AfLmm2+qpKREN954o4YOHaqWLVvK6TT0pF0AAAAAAGyBfy37lqEJkB9++EHJycm64YYbjGwWAAAAAADAK4YmnJo2baro6GgjmwQAAAAAAPCaoStAevXqpR07dhjZJAAAAAAAtsQpML5l6AqQ8ePH66efftKiRYvk8XiMbBoAAAAAAOCcGboCpE2bNnr88cc1ZcoULV++XPHx8XK5XLWeczgcmjBhgpFdAwAAAAAA1MvQBEhhYaGeeeYZlZWVqaysTPn5+fU+SwIEAAAAABDIHA4qJ3zJ8GNw8/LyNHz4cA0dOlRRUVEKCgoysgsAAAAAAIBfzdAEyJYtW9S3b1/dfffdRjYLAAAAAADgFUMTIB6PRx07djSySQAAAAAAbIlTYHzL0FNgunXrpj179hjZJAAAAAAAgNcMPwZ369at+vbbb41sFgAAAAAAwCuGlsBs2LBBvXr10ksvvaQvvvhCnTt3rvMYXEkaM2aMkV0DAAAAAOBXDF2RgDMyNAEyf/786j9v27ZN27Ztq/dZEiAAAAAAAMBXDE2ATJ061cjmAAAAAAAADGFoAqRHjx5GNgcAAAAAgG05HR6zQwgohpYcrVixQrt3727wmdzcXK1YscLIbgEAAAAAABpkaALk5ZdfVnp6eoPPrFu3Ti+//LKR3QIAAAAAADTI0BKYs1FVVSWHw+HrbgEAAAAAsBQn/zT2KZ+fupOXl6ewsDBfdwsAAAAAAAKY1ytAflnOkp6ervz8/FrPVVVVqbCwUNu2bVP//v297RYAAAAAAOCseZ0A+eWGpjk5OcrJyan3+W7duum2227ztltYTHhIe7NDACypY3hns0PAKR3NDgCwIKcjxOwQAEvi3YCv+LwkI8B5nQCZOXOmJMnj8ejee+/VqFGjNGrUqFrPOZ1OhYWFqWnTpt52CQAAAAAA8Kt4nQCJjo6u/vOYMWPUs2fPGtcAAAAAAADMZugpML/73e+MbA4AAAAAANviFBjfapRjcLOysvTVV18pJydHbrdbLpdLnTp10rBhw3T++ec3RpcAAAAAAAD1MjwB8sYbb2jJkiW1rufk5Oirr77SyJEj9cc//tHobgEAAAAAAOplaALk3//+t5YsWaKYmBjdcMMN6tmzp1q0aKHi4mJt3bpVCxcu1JIlSxQXF6crr7zSyK4BAAAAAPArTofH7BACiqGn7nzxxReKiorSU089pWHDhik6OlohISGKjo7WsGHD9OSTT6pFixZaunSpkd0CAAAAAAA0yNAEyIEDB5ScnKywsLA674eHhys5OVkHDhwwslsAAAAAAIAGGVoCExERoeDghpsMDg5WZGSkkd0CAAAAAOB3OAXGtwxdAXLRRRdp3bp1qqioqPN+RUWF1q9fr4suusjIbgEAAAAAABpkaAJk/Pjxcrlcevzxx7V9+3Z5PCc3dPF4PMrKytLjjz+usLAwjR8/3shuAQAAAAAAGuTwnM5SnIOJEyfWulZRUaFDhw5JkoKCghQREaHS0lJVVlZKkqKiohQSEqIZM2aca7c/k21AGwDQeKo8J8wOAbAcpyPE7BAAAH4j0ewAGtWdaV+bHUKd/jV4mNkhNAqv9gCpK3cSFBSk1q1b17gWFRVV43NVVZU33QIAAAAAAPwqXiVAZs2aZVQcAAAAAAAAjcbQU2B+6ejRoyorK5PL5ZLL5WrMrgAAAAAA8CtOxznvSIFzYHgCpLKyUp988omWL1+u/Pz86usxMTEaMWKERo8eraCgIKO7BQAAAAAAqJehCZCKigo98cQTyszMlMPhUOvWrdWiRQsVFxfr4MGDeu+997Rp0yZNmTJFwcGNuvgEAAAAAACgmqFZiE8//VSZmZnq37+/br31VsXGxlbf279/v9566y2tX79en376qa699lojuwYAAAAAwK84HWZHEFicRjaWlpamDh066IEHHqiR/JCktm3b6m9/+5s6dOiglStXGtktAAAAAABAgwxNgOzfv19JSUlyOutu1ul0KikpSQcOHDCyWwAAAAAAgAYZWgITHBysY8eONfjM8ePH2QQVAAAAABDwKIHxLUNXgMTHx2vNmjUqKSmp835JSYlWr16thIQEI7sFAAAAAABokKEJkJEjR6qkpEQPPvigvvzySx04cEDl5eXKz8/XV199pYcfflglJSUaOXKkkd0CAAAAAAA0yNASmJSUFOXk5Oijjz7S7Nmz63zmmmuuUUpKipHdAgAAAADgdwxdkYAzMjQBIkk33XSTLrzwQn355ZfKycmR2+2Wy+VSQkKCLr30UiUmJhrdJQAAAAAAQIMMT4BIUmJiIokOAAAAAABgGY2SAAEAAAAAAA1zOjxmhxBQKDkCAAAAAAC2RwIEAAAAAADYHiUwAAAAAACYwOkwO4LAwgoQAAAAAABgeyRAAAAAAACA7VECAwAAAACACViR4Fv8fQMAAAAAANtjBYhJ9u8v0IsvztXKlRtUXFyimJiWGjFioCZOHK/mzcPNDi+gMBbWwVhYw5LFq5SevlVZWTnKyspRWdlRjR49RE8/c5/ZoQUkxsNamKesg7GwDsbCWhgPoH4kQEyQm7tP48ZNUmFhsUaMSFbnzu21efMPeuutj7Vy5Xq9997TioqKNDvMgMBYWAdjYR2vvLJAWVk5crmaqm3bVtq5c6/ZIQU0xsM6mKesg7GwDsbCWhgP/8MpML4VNG3atGlmB3HuCs0O4Jzcf/8z2r49R1Om3KmHHvqzUlKSdN11I3TkiFtff52u0lK3hg8fYHaYAYGxsA67joVHVWaH8Kt1SojTXXeP0aRJt6lbt45atOgrnXdevC6/YqDZoQUkO46HwxFkdgjnxK7zlD9iLKyDsbAWe45HK7MDaFRf7N1ldgh1urxdJ7NDaBTsAeJjubn7lJa2Ue3axejmm6+uce/ee2+Sy9VUH38iv9TMAAAgAElEQVT8ldzuYyZFGDgYC+tgLKwleWBvJSTEyeHgVxJWwHhYA/OUdTAW1sFYWAvjAZyZTxIgpaWlWrt2rTZt2qSqKv/7baiR1qzZLEkaPLifnM6af/3h4S71799dR48eV0bGdjPCCyiMhXUwFgCsjnnKOhgL62AsrIXx8E8Oh8eSX3ZlaAJk6dKleuihh3TkyJHqazt37tR9992nZ599Vk8++aSmTJmiY8cCN+t4unY7IaFdnffj4+MkSbt2UePd2BgL62AsAFgd85R1MBbWwVhYC+MBnJmhCZBVq1bJ4XAoPPz/dhd+++23VVZWpuHDh6tfv3768ccf9cUXXxjZrV85csQtSYqIcNV5//T10tIyn8UUqBgL62AsAFgd85R1MBbWwVhYC+MBnJmhp8Ds27dP/fv3r/5cUlKizMxMjRgxQnfeeack6aGHHlJaWppGjx59Vm1Onjy53nupqXd4FzAAAAAAACbhFBjfMnQFyJEjR9S8efPqz9u3n6wvGzDg/3YaPv/881VQUGBkt34lPPx05tVd5/3T1yMiwnwWU6BiLKyDsQBgdcxT1sFYWAdjYS2MB3Bmhq4ACQ8PV0lJSfXnzMxMOZ1OJSYmVl9zOBwqLy8/6zZTU1MbuJt9LmGaqnPnkzV5OTl1197t3p0nSerUqe7aPRiHsbAOxgKA1TFPWQdjYR2MhbUwHsCZGZoAadeundavX6/S0lI5nU6tWrVKXbp0kcv1f3VoBw8eVIsWLYzs1q8kJ/eRJKWlbVRVVVWNHZqPHHFrw4Ztatasifr2Pc+sEAMGY2EdjAUAq2Oesg7GwjoYC2thPPyTT45lRTVD/75HjRql4uJi3X333ZowYYKKi4t1xRVX1Hjmhx9+UHx8vJHd+pWOHWM1eHA/7d2br7lzP6txb8aMd+V2H9M11wyXy9XUpAgDB2NhHYwFAKtjnrIOxsI6GAtrYTyAM3N4PB5DD/ldtmyZli1bJkkaPHiwfvOb31Tf27p1q/75z3/q5ptv1mWXXWZAb/5XAiNJubn7NG7cJBUWFmvEiGR16dJBGRnZWrNmsxIS2mnevKcVFRVpdpgBgbGwDruORZXnhNkh/GrLlq3R8mVrJUkFBYeUlrZJHTq00QUX9JAkRUVFaNLk202MMLDYcTycjhCzQzgndp2n/BFjYR2MhbXYczwSz/yIH3t43XKzQ6jTExeOMDuERmF4AsS3/DMBIkn79h3USy/N1cqVG1RcXKro6ChddtnFmjhxvJo3Dz9zAzAMY2EddhwLf0yAzJwxT7NmvV/v/bi4aC3/crYPIwpsdhwPf02ASPacp/wVY2EdjIW12G887J0AeWT9MrNDqNPjFxixYMF6SIAAQCPyxwQI0Nj8OQECAPA1EiBmsGsCxKtNUL05zrZ169bedA0AAAAAAHDWvEqA3HPPPef0fQ6HQ/PmzfOmawAAAAAA/JrTYXYEgcWrBMiQIUPkcDBiAAAAAADA2kxZAQIAAAAAAOBLXiVAAAAAAADAuaEExrecZgcAAAAAAADQ2BplBciOHTuUkZGhoqIinThR+whIh8OhCRMmNEbXAAAAAAAAtRiaAPF4PJo1a5ZWrlx5xmdJgAAAAAAAAlmQ2QEEGENLYBYvXqyVK1dqyJAhevLJJyVJo0aN0uOPP67x48erWbNmSklJ0cyZM43sFgAAAAAAoEGGrgBZsWKF4uLiapwOExYWpsTERCUmJqpv3756+OGH1adPHw0fPtzIrgEAAAAAAOpl6AqQvXv3qmfPnjWuVVZWVv+5U6dO6t+/v5YuXWpktwAAAAAA+B2nw2PJL7sy/BQYl8tV/ecmTZroyJEjNe7HxsZq7969RncLAAAAAABQL0MTIC1btlRRUVH15zZt2mjnzp01ntm3b5+aNGliZLcAAAAAAAANMjQB0rVrV+3atav6c1JSknbs2KEFCxZoz549Wrx4sdatW6du3boZ2S0AAAAAAH7H6bDml10ZuglqcnKydu7cqfz8fMXExOi3v/2tvvvuO82fP1/z58+XJIWHh+vmm282slsAAAAAAIAGOTweT6PucOJ2u7Vs2TIdOHBA0dHRGjp0qKKiogxqPdugdgCgcVR5TpgdAmA5TkeI2SEAAPxGotkBNKqnMr4wO4Q6/b3v5WaH0CgMXQFSF5fLpWuuuaaxuwEAAAAAwK/YtdyktLRUa9eu1YYNG5Sbm6uioiIFBwerY8eOGj58uIYNGyans/aOHNu3b9cHH3yg7OxslZeXKzY2VsOHD9dVV11V5/O/VqMnQAAAAAAAQOD47rvv9NprrykqKko9e/ZU69atVVxcrLVr1+qVV17Rxo0bdf/998vh+L8MUHp6up599lmFhIQoJSVF4eHhWr9+vebMmaPt27fr/vvv9zourxIgmZmZkk5ufhoaGlr9+Wz06NHDm64BAAAAAIAFxcXFadKkSerfv3+NlRs33XSTHnzwQa1Zs0Zr1qzRwIEDJZ3cOmP27NlyOp2aNm2aunTpIkkaO3asHnvsMa1evVrffvutBg0a5FVcXiVApk+fLkl6/vnnFRcXV/35bPzv//6vN10DAAAAAODXgmxaAtOrV686r7do0UKXX3655s2bp8zMzOoEyOrVq1VSUqIhQ4ZUJz8kKTQ0VOPGjdNjjz2mpUuXmpsAueGGG+RwOBQZGVnjMwAAAAAAwC8FB59MQ/x8ZciWLVskSUlJSbWe7969u5o0aaLs7GydOHFCISHnvpm6VwmQG2+8scHPAAAAAADAv0yePLnee6mpqefcbmVlpVasWCGpZrJj3759kk6WzvxSUFCQYmJitGfPHh04cEDt27c/5/4N3QR1wYIFiomJ0ZAhQ4xsFgAAAAAA27HrKTD1mTt3rvbs2aN+/frVSIC43W5JJ0+Rrcvp66efO1eGJkAWLlyoq6++2sgmAQAAAACAD3mzyqM+n3/+uT799FO1a9dO9957r+Htnw1DEyAtW7b0OiMDAAAAAADsY/HixXrzzTfVvn17PfroowoPD69x/0wrPM60QuRsOc/8yNkbMGCAvv/+e5WXlxvZLAAAAAAAtuN0eCz5ZaTPPvtMb7zxhjp06KCpU6eqRYsWtZ6JjY2VJOXl5dW6V1lZqfz8fAUFBalNmzZexWJoAuTGG29UeHi4nnnmGeXm5hrZNAAAAAAA8COLFi3SnDlzlJCQoKlTp6p58+Z1Pnf62NxNmzbVurdt2zYdP35ciYmJXp0AIxlcAvPAAw+ooqJCO3fu1AMPPKDQ0FBFRkbWOhrX4XBoxowZRnYNAAAAAIBfsfMmqAsWLND777+vzp07a8qUKbXKXn5u4MCBmjt3rlatWqWrrrpKXbp0kSSVl5dr3rx5kqQrrrjC65gMTYB4PB4FBQWpdevWta439BkAAAAAANjD119/rffff19Op1Pnn3++Pv/881rPxMTEaNiwYZJO7u1x11136bnnntO0adM0aNAghYeHa926dcrLy9PAgQOVkpLidVyGJkBmzZplZHMAAAAAAMDP5OfnS5KqqqrqTH5IUo8ePaoTINLJPUWnTZumDz/8UGvWrFF5ebnatm2rW2+9VaNGjapVWXIuHB6/Xo6RbXYAANCgKs8Js0MALMfp8K5+FwAQSBLNDqBRvZy51OwQ6vSXHt6Xm1iRoZugTp8+XStWrGjwmW+++UbTp083slsAAAAAAIAGGZoAyczM1MGDBxt8pqCgQJmZmUZ2CwAAAAAA0CBD9wA5G+Xl5QoKCvJ1twAAAAAAWIqdT4GxIp8lQDwejwoKCrRx40a1atXKV93CR9wVDa/8ge+4gqPNDgGwpEr2Y7EM9gCxDvYpAurGPAXYk9cJkLFjx9b4PH/+fM2fP7/B77nuuuu87RYAAAAAAOCseZ0A6d69e/VxNJmZmWrdurViYmJqPed0OhUeHq7evXvr0ksv9bZbAAAAAAD8mtPhx4ey+iGvEyDTpk2r/vPYsWM1fPhwjRkzxttmAQAAAAAADGPoHiAzZ85UWFiYkU0CAAAAAAB4zdAESHT0yc0XDx06pO+//15FRUWqqKio81lWiQAAAAAAAlkQp8D4lOGnwLz//vtatGiRKisrG3yOBAgAAAAAAPAVQxMgK1eu1MKFC9WrVy+NHDlSzz77rIYOHaq+fftq69at+uqrrzRw4EBdfvnlRnYLAAAAAADQIEMTIEuXLlXLli310EMPKSgoSJIUExOjQYMGadCgQRowYICeeuopDRo0yMhuAQAAAADwO05KYHzKaWRjubm56tevX3XyQ5Kqqqqq/5yUlKS+ffvqk08+MbJbAAAAAACABhmaAKmsrFRERET159DQULnd7hrPdOjQQTk5OUZ2CwAAAAAA0CBDS2CioqJ06NCh6s+tW7fW7t27azxz6NChGitEAAAAAAAIRJTA+JahK0ASEhK0Z8+e6s89e/ZUVlaWvvnmGx07dkwbNmzQ6tWr1alTJyO7BQAAAAAAaJChCZALLrhAe/bsUX5+viTp2muvlcvl0qxZs3TbbbcpNTVVkjR27FgjuwUAAAAAAGiQw+PxeBqzg/z8fH3yySc6cOCAoqOjNXLkSHXs2NGg1rMNagfeclccNDsEnOIKjjY7BPxMleeE2SHglErGwjJCnC6zQ8ApzFFA3ZyOELNDQLVEswNoVG/vWGJ2CHW6petIs0NoFIbuAVKXmJgY3XHHHY3dDQAAAAAAQL0MLYEBAAAAAACwokZfAQIAAAAAAGoLcjTqjhT4BVaAAAAAAAAA2yMBAgAAAAAAbI8SGAAAAAAATMCKBN/i7xsAAAAAANgeCRAAAAAAAGB7lMAAAAAAAGACp8PsCAILK0AAAAAAAIDtkQABAAAAAAC2RwkMAAAAAAAmoATGt1gBAgAAAAAAbI8ECAAAAAAAsD1KYAAAAAAAMEGQw2N2CAGFFSAAAAAAAMD2SIAAAAAAAADbowQGAAAAAAATcAqMb7ECBAAAAAAA2B4JEAAAAAAAYHuUwAAAAAAAYAJKYHyLBIhJ9u8v0IsvztXKlRtUXFyimJiWGjFioCZOHK/mzcPNDi+gffbJd5ry91clSY9Mv13XjxlickSBg/fCGpYsXqX09K3KyspRVlaOysqOavToIXr6mfvMDi3gFB8q1bJla/XNio364Ydc5R8oUkhIsLoldtS11w3TddcPk9PJYk5fYp6yBuYp62AsrId5CqgfCRAT5Obu07hxk1RYWKwRI5LVuXN7bd78g95662OtXLle7733tKKiIs0OMyDt31ekp554Ry5XE7ndx80OJ6DwXljHK68sUFZWjlyupmrbtpV27txrdkgBa8mS1Xp8+muKjo7SgOQeahvbWoWFh7X8i7Wa+shspa3cpOde+E85HPz6yBeYp6yDeco6GAtrYZ4CGkYCxATTp/+3CguLNWXKnbrlltHV15988jW9+eZHev75t/XYY/eYGGFg8ng8mjrldbVoEa5LL7tAb/3PYrNDCii8F9bx97//QW3atlJ8fKzS127Vbbc9anZIASshIVYzX56kIUP71Vjpcd994zVu7EP6YukaLftirS6/ItnEKAMH85R1ME9ZB2NhLcxT/ocSGN9i3ayP5ebuU1raRrVrF6Obb766xr17771JLldTffzxV3K7j5kUYeB6751lSl+TpWn/+KOaNQs1O5yAwnthLckDeyshIY5VBRaQPLCXhg2/oFaZS+voFrpx7OWSpPS1W80ILeAwT1kL85R1MBbWwTwFnBkJEB9bs2azJGnw4H61fqAND3epf//uOnr0uDIytpsRXsDa+WOeXnp+gW76/WW64MLzzA4n4PBeAL9ecHCQJCkoKMjkSAID8xQAq2OeAs7M8BKYwsJCffbZZ8rJyVFhYaEqKytrPeNwODRjxgyju/YLp+siExLa1Xk/Pj5OaWkbtWvXXl18cV9fhhawKioqNeXBV9U2tqUm3neD2eEEJN4L4NepqKjUJx99I0kafAnvhC8wTwGwOuYp/xTE4imfMjQBsnXrVj355JM6ceKEnE6nWrRoUefu9B6P56zbnDx5cr33UlPvOKc4zXTkiFuSFBHhqvP+6eulpWU+iynQ/eu/P9b2bbl64+0H1bQppS9m4L0Afp3nn3tXP/ywR5cM6adBg5PMDicgME8BsDrmKeDMDE2AvPPOO6qqqtI999yjwYMHczQfLO/7zT/qjVc/0y23jVTfpK5mhwMAZ/TO2//WnP/5VJ06x+mp1IlmhwMAAOA3DE2A5ObmatCgQRoyZIhhbaampjZwN9uwfnwlPPx05tVd5/3T1yMiwnwWU6CqqKjUIw++po7xbfSXv15ndjgBjfcCODvvzl2sp/7rTXXp0l6v/88jat4i3OyQAgbzFACrY57yT07H2VdHwHuGJkDCw8MVHs4PYw3p3PlkTV5OTt1npO/enSdJ6tSp7to9GOeo+7h25xyQJCX3u6vOZx6f+qYen/qmbvr9ZXrgwZt8GV5A4b0AzuztOZ8p9am31K1bB732P4+oVavmZocUUJinAFgd8xRwZoYmQPr376/MzEwjm7Sd5OQ+kqS0tI2qqqqqUSZ05IhbGzZsU7NmTdS3LyeRNLaQ0GBde8Mldd7LytytrG256te/m+I7tVUfymMaFe8F0LDXX/1Izz/3rs7vnqBXX39YUVGRZocUcJinAFgd8xRwZoZu0jF+/Hi53W699tprOnaM86Xr0rFjrAYP7qe9e/M1d+5nNe7NmPGu3O5juuaa4XK5mpoUYeBo2jRUUx/7Q51fQ4ef3FTwN78dpKmP/UEjrxpgcrT2xnsB1O+Vlxfq+efeVY+enfX6G4+Q/DAJ8xQAq2Oe8k9Oi37ZlcPza45kOQv79+/XQw89pIqKCsXGxsrlqr0LscPh0KOPPmpAb/63B4gk5ebu07hxk1RYWKwRI5LVpUsHZWRka82azUpIaKd58572ux9w3RUHzQ7BUK/MWqTZL3+sR6bfruvHGLenjS+4gqPNDuGc2PG9kKQqzwmzQ/jVli1bo+XL1kqSCgoOKS1tkzp0aKMLLughSYqKitCkybebGOG5qfTDsfho0Qo9/ODLCgpy6qabr1R4HTv7t2sXrWuvG+b74LwQ4qz7hAKrs+M85Y9zlGTfecof2XUsnI4Qs0M4J3acp6REswNoVMv2fm52CHW6rN0os0NoFIaWwOzZs0fTp09XWdnJo5VycnKMbN42OnaM1cKFz+mll+Zq5coN+uab9YqOjtKtt16jiRPHq3lz9lFB4OG9sI6sbbu0aNFXNa7t2XNAe/ac3DMnLi7aL3+Y9Uc//ZQvSaqsrNLbb9X9A9KFF/XwuwSIv2Kesg7mKetgLKyFeQpomKErQJ544glt3rxZN954o4YOHaqWLVs28lG4/rkCxI7stgLEn/nrChC78tffrtqRP64AsSt/XQFiR8xRQN38dQWIPdl7BciXedZcAXJpHCtAzig7O1vJycm64YYbjGwWAAAAAADAK4YuzwgODlZ0NL99BgAAAAAA1mLoCpAePXpox44dRjYJAAAAAIAtBTnMjiCwGLoC5Pe//71++uknLVq0SAYfLgMAAAAAAHDODF0BsnDhQnXs2FHvvfeeli9frvj4+HqPwZ0wYYKRXQMAAAAAANTL0ATIihUrqv+cn5+v/Pz8ep8lAQIAAAAACGROB5UTvmRoAmTmzJlGNgcAAAAAAGAIQxMgnAADAAAAAACsyNAECAAAAAAAODtOToHxKa8SIAUFBZKkli1byul0Vn8+G61bt/amawAAAAAAgLPmVQLknnvukSQ9//zziouLq/58Jg6HQ/PmzfOmawAAAAAAgLPmVQJkyJAhcjgc1Ufdnv4MAAAAAAAaRgmMbzk8Ho8fn7uTbXYAOMVdcdDsEHCKK5jNiK2kynPC7BBwSiVjYRkhTpfZIeAU5iigbk5HiNkhoFqi2QE0qu/yPzM7hDpdHHO12SE0CqfZAQAAAAAAADQ2QxMgJSUlyszM1NGjR+u873a7lZmZqZKSEiO7BQAAAADA7zgt+mVXhv63LVy4UKmpqXI6627W6XQqNTVVixYtMrJbAAAAAACABhmaANm8ebP69OmjJk2a1Hm/adOm6tu3rzIyMozsFgAAAAAAoEGGJkAKCwvVpk2bBp+JiYlRQUGBkd0CAAAAAOB3HA5rftmVoQkQh8OhioqKBp+pqKhQVVWVkd0CAAAAAAA0yNAESFxcXIPlLR6PRxkZGWrbtq2R3QIAAAAAADTI0ARIcnKy8vLy9Prrr6u8vLzGvfLycr3++uvKy8tTSkqKkd0CAAAAAOB3HBb9sqtgIxsbNWqUvv32Wy1dulTp6enq3r27WrZsqaKiIm3btk2HDh1SfHy8rr76aiO7BQAAAAAAaJDD4/F4jGywrKxMr732mr777jv9vGmHw6GUlBTdcccdCgsLM6i3bIPagbfcFQfNDgGnuIKjzQ4BP1PlOWF2CDilkrGwjBCny+wQcApzFFA3pyPE7BBQLdHsABpV+sHPzA6hThdF23PRguEJkNNKSkq0Y8cOud1uuVwude3aVZGRkQb3QgLEKkiAWAcJEGvhHxfWQQLEOkiAWAdzFFA3EiBWYu8EyLoCayZALmxtzwSIoSUwPxcZGan+/fs3VvMAAAAAAABnzasEyMsvv3xO3+dwODRhwgRvugYAAAAAADhrXiVAVqxYcc7fSwIEAAAAABDIDD2WFWfkVQJk5syZRsUBAAAAAADQaLxKgERHs9kiAAAAAACwvkbbBBUAAAAAANTP4WiUQ1lRD0qOAAAAAACA7ZEAAQAAAAAAtkcJDAAAAAAAJnCYHUCAYQUIAAAAAACwPb9eAXK8stjsEHCKK5gTgaziRJXb7BDwMyFOl9kh4BSnI8TsEHBKleeE2SHgFN4L67jo/XyzQ8DPpN0QanYIOKVJkNkRwE78OgECAAAAAIC/clAD41OUwAAAAAAAANsjAQIAAAAAAGyPEhgAAAAAAExABYxvsQIEAAAAAADYHgkQAAAAAABge5TAAAAAAABgAic1MD7FChAAAAAAAGB7JEAAAAAAAIDtUQIDAAAAAIAJqIDxLVaAAAAAAAAA2yMBAgAAAAAAbI8SGAAAAAAATOCgBsanWAECAAAAAABsjwQIAAAAAACwPUpgAAAAAAAwARUwvsUKEAAAAAAAYHusAAEAAAAAwASsAPEtVoAAAAAAAADbIwECAAAAAABsjxIYAAAAAABM4KQGxqdYAQIAAAAAAGyPBAgAAAAAALA9SmAAAAAAADABFTC+xQoQAAAAAABgeyRAAAAAAACA7VECAwAAAACACRwOj9khBBRWgAAAAAAAANsjAQIAAAAAAGyPEhgAAAAAAExg11NgVq9erczMTOXk5Gj37t06evSoBg8erL/+9a/1fs/27dv1wQcfKDs7W+Xl5YqNjdXw4cN11VVXyek0Zu0GCRAAAAAAAGCYhQsXavfu3WratKlatWqlvXv3Nvh8enq6nn32WYWEhCglJUXh4eFav3695syZo+3bt+v+++83JC4SIAAAAAAAwDC33XabWrVqpbZt2yozM1PTp0+v91m3263Zs2fL6XRq2rRp6tKliyRp7Nixeuyxx7R69Wp9++23GjRokNdxsQcIAAAAAAAmcDis+eWtXr16KTY2Vo6zaGz16tUqKSlRSkpKdfJDkkJDQzVu3DhJ0tKlS70PSiRAAAAAAACASbZs2SJJSkpKqnWve/fuatKkibKzs3XixAmv+6IExgTPPztPW7fs0u7d+1V8qFRNmoQqLq61ho/or/E3X64WLSLMDjGg7N9foBdfnKuVKzeouLhEMTEtNWLEQE2cOF7Nm4ebHV7AKD5UqmXL1uqbFRv1ww+5yj9QpJCQYHVL7Khrrxum664fZtjmRzg7vBvWwVhYw5LFq5SevlVZWTnKyspRWdlRjR49RE8/c5/ZoQUk3gvfmtgnQT2i/n97dx5WVbX/D/x9GGRG5kkEREBAEBUUc84RSyvTi0NWlmW30m92+6VlzplDVppXy1IT7QrmkImGs+KYgAqoDIoDiIHM8yRw+P3B5VyP54AgmzPxfvX4PLH3Pnt9zl5nT5+91trGcDIxQMcOOqiqFeNheRUi/87DntuZKHpUI1lWWyTCP9zs4WFmhG5mRuhiaghdbS0sj0nBgXtZSvwWmo/3GSSUefPmNTpv9erVgpaVmZkJAHBwcJCZp62tDRsbG6SnpyMrKwuOjo6tKosJECX4dfsReHm74LnnfGBhaYqK8ipcu3YbP27cj317IvGfsMWws7dUdpjtwv37mZg8eS7y8goxfHggXF0dce1aCnbsCMe5c1cQFvY1zM1NlR1mu3D06CV8uXQLrK3N0TfQG3b2VsjLK8LJ49FYvPAnnD8Xh+/WfdysZnTUetw3VAfrQnVs2rQXycmpMDTUh52dJe7ebXpAN2o73C8Ub6q7A5ILSxGVVYiCykfQ19GGr6UJ3vNxxnhXO7x9Mh5ZFY8AAAY6WviklysAIK/iEfIqH8HOSF+Z4bcbvM9QP3y8Vz8GCAAYGhrKnd8wvWG51mACRAn+ivkZenodZKavX7cHW34Ox5bNB7Fg0XTFB9YOLV36I/LyCrFgwUy8/vo4yfSVK7cgJOQA1q79FcuWfajECNsPFxd7bPhhLgYP6SXV0mPOnCmYPGk+jh+Lwonj0Rg5KlCJUbYf3DdUB+tCdXz22VuwtbOEs7M9YqIT8Oabi5QdUrvF/ULxhu7/C4/EdTLT3/dxxtvenTHdqzNWX70DAKisFeOjswm4WViKvMpqvNvdCTO7Oyk65HaJ9xkkFKFbeagKJpyUQN5BCQBGB/UFANxPe6jIcNqt+/czcf58LDp1ssFrr70oNW/27KkwNNRHePhplJdXKinC9iWwnw+GPu8v083FytoMwZNGAgBiohOUEVq7w31DdbAuVEtgP1+4uDiwJZqScb9QDnnJDwA4kZ4LAOhs/L8WHjXiOlx8WIC8ytb311Yw/bAAACAASURBVKeW4X0GqaOntfB4WguRlmACRIWciYwFAHh4MEOuCFFR1wAAAwf2krnpNjY2RO/eXqioqEJ8/E1lhEeP0dHRBlDfB5DaHvcN1cG6IJLF/UK1DHKwAADcLmp903RqO7zPUF3KfttLW70FpiXs7e0BABkZGTLzamtrkZ2dDW1tbdja2ra6LEG7wJSWlqKwsBC2trbQ1dWVTD99+jRiYmKgp6eHF198EW5ubkIWq7ZCfvkT5eVVKC0tR8KNe4i9egse3Trj7XfHKju0dqGh77aLSye5852dHXD+fCzu3fsbzz3np8jQ6DE1NbU4eOAsAGDgINaDInDfUB2sCyJZ3C+Ua1q3TjDQ0Yaxrja8zI3Ry7ojbhWWISQ5Xdmh0WN4n0HqxMfHB+fPn0dcXBwGDhwoNS8pKQlVVVXw8vKSyjE8K0ETIGFhYTh37hy2bNkimXb48GGEhIRI/o6JicGqVataPXqrJti+7TDy8ookfw8Y2APLV8yEhQUH7VKE0tL6JxUmJvKbUjVMLykpU1hMJGvtd6FISUnHoMG9MGCg7KuxSHjcN1QH64JIFvcL5Zrm0QmWBv/rZnExMx9Lo1NQWFXTxKdI0XifQeqkX79+2LlzJy5evIgxY8aga9euAIBHjx5h165dAIBRo0YJUpagCZCbN2/Cx8cHHTr876B48OBBWFhY4KOPPkJhYSE2bNiAQ4cO4Z///Gez1tnU63eWrZjQ6piV6fS5DQCAvNwixMWlYN13vyF4wgL8+8dP4O3totzgiFTAf349jO3bDqGLqwNWrZ6l7HCIiIjavaCD0QAACz1d9LAyxSxfZ/xnVE98fC4RNwuZdFIVvM9QH5o6qlR0dDRiYmIAAIWFhQCAlJQUbNy4EQBgYmKCN954A0D92B7vvfcevvvuOyxZsgQDBgyAsbExLl++jIyMDPTr1w/9+/cXJC5BxwDJz8+HjY2N5O8HDx4gLy8PY8aMgaenJ/r16wd/f38kJSUJWazas7TqiOEjAvDT5nkoLCzFF59tUnZI7YKxccMTIvl9Vhumm5gYKSwm+p/QnUewakUIunZ1xLaQxehoZqzskNoN7huqg3VBJIv7hWrIr6pG5N95mHU2AR076GJpoIeyQyI5eJ9BypKamoozZ87gzJkziI+PBwBkZWVJpkVFRUkt37dvXyxZsgTe3t6IiorC4cOHoa2tjTfeeANz5swRbAByQVuAPHr0SKr1R3JyMgDA19dXMs3W1hZXr15t9jqbev1OVW30M0Spuhw6WaFr105ITk5DQUEJzM1NlB2SRnN1re87nJr6t9z5aWn1g/B06SK/jzG1nV+3/4nVq3bA3b0ztmxbCEvLjsoOqV3hvqE6WBdEsrhfqJaH5VW4V1yObubG6NhBB0WP2BVGFfE+gxQtODgYwcHBLfqMp6cnPv/88zaKqJ6gCRALCwv8/ff/Tkbx8fEwNDSEs7OzZFpZWZlUkoSkZecUAAC0tfiCnrYWGNgDAHD+fCzEYrHUSPKlpeW4ejUJBgZ68PPrpqwQ26Wtmw9g7Xeh8PRyweatX8DcnH1VFY37hupgXRDJ4n6heqz+OyaIuE7+q3JJNfA+QzXxzeqKJeivv3v37oiNjcWRI0dw8uRJXL58GX5+flInpqysLFhaWgpZrFpJTc2U22RTLBZj/bo9yM8rRs9e7jDtyGabbc3JyR4DB/bC339nY+fOP6Xm/fvfoSgvr8RLLz0PQ0P9RtZAQtv0wz6s/S4U3t1dsfWXhUx+KAn3DdXBuiCSxf1C8ZyM9WGkK/sqehGA932cYanfAfG5xSiprlV8cCTB+wyipxPV1QmXqs3OzsZnn32GsrL6AZD09fWxcuVKODg4AADKy8sxc+ZMDB06FO+8806ry1PHLjC/7jiC9Wt3o1dvD3RytIZZR2Pk5RXj8uVkPEjPhpVVR2z+5XN0dVOvZpt62mbKDuGZ3L+ficmT5yIvrxDDhweia9fOiI+/haioa3Bx6YRdu75Wu5vwarH8PtGq7sAfZ/DF5z9AW1sLU18LgrGc0f07dbLGK+OHKj64VtDVkv+WAlWnifuGutLEuhDXVSs7hGdy4kQUTp6ov/bIzS3A+fNx6NzZFv7+3gAAc3MTzJ03XYkRtpyWqPWvFFQGTdwv+uzOVnYIjZri7oAPfJ0Rn1uMjLIqFD2qhoV+B/S2NoWjsQFyKx7hgzPXca+4QvKZNz0d4WJiAADwMDOCh7kx4nOLkV5Sv0xcbjEO3MtSyvdpjvMT1K/FuubeZ/RVdghtKr3soLJDkKuz0Thlh9AmBE2AAPUjvF66dAkAEBAQACsrK8m8u3fv4uzZsxg4cCDc3NxaXZY6JkBSUtKx57dTiL1yC1lZ+SgpKYeBgR6cXewwaHBPvDZtlFoO9qiuCRAAyMzMwfr1O3Hu3FUUFpbA2tocI0Y8h1mzpqBjR/WrC3VNgGzcsAc/btzb5DIBfbwRsmOxgiIShromQADN2zfUmabVhbomQDb8exc2btzd6HwHB2ucPPWTAiNqPXVNgACat1+ocgKkq6khXu1qh55WprAx1IOxrg4qa2pxv7QC5zML8FtKBoqfGPtj01Bf+Ns0PobXoXtZWBqT0tahPzN1TIBo7n2GZidAHqhoAsSRCRDVo44JEE2lzgkQTaOuCRBNpc4JEKK2oq4JEE2kzgkQTaPKCZD2SB0TIJqKCRDl0NQESJuNgFNZWYl79+7xlbdEREREREREpHSCvgUGAPLy8rBt2zZcuXIFYrEYIpEIu3btAlD/WtyffvoJ77zzDrp37y500URERERERERqQ4tvgVEoQVuAFBQUYP78+bh8+TL8/f3h4eGBx3vYuLm5obi4GBcvXhSyWCIiIiIiIiKiJgmaANmzZw+Ki4uxYMEC/L//9//Qo0cPqfk6Ojrw9PTEzZs3hSyWiIiIiIiIiKhJgiZAYmNj4e/vDx8fn0aXsbKyQkFBgZDFEhEREREREakdkYr+01SCJkCKiopgb2/f5DLa2tqorKwUslgiIiIiIiIioiYJmgAxNjZGXl5ek8tkZmbCzIyvTCUiIiIiIiIixRH0LTDdunXD5cuXUVhYKDfJkZmZibi4OAwaNEjIYomIiIiIiIjUjkhU9/SFSDCCtgB56aWXUF1djcWLFyM2NhZVVVUAgMrKSsTGxmL16tXQ0tLCuHHjhCyWiIiIiIiIiKhJorrH31MrgFOnTmHLli2ora2VmaetrY33339fsBYgVbXRgqyHWk9Pm92aVEW1uFzZIdBjdLUMlR0CkcoR11UrOwT6Ly2RrrJDoP/qsztb2SHQY85P6KDsEOi/9LT7KjuENvWwIlzZIchlZ/CSskNoE4J2gQGAYcOGwcvLC0ePHkVKSgpKS0thaGgId3d3BAUFwcHBQegiiYiIiIiIiNSOJr9xRRUJngABAHt7e0yfPr0tVk1ERERERERE1GKCjgGyd+9eJCYmNrlMUlIS9u7dK2SxRERERERERERNEjQBsmfPnmYlQPbs2SNksURERERERERqRyRSzX+aStAESHPU1NRAS0vhxRIRERERERFRO6bwTMS9e/dgYmKi6GKJiIiIiIiIqB1r9SCoS5culfo7MjISCQkJMsuJxWLk5eUhJycHAwYMaG2xRERERERERGpNg3ubqKRWJ0CeHPMjJycHOTk5MsuJRCKYmJigf//+fEMMERERERERESlUqxMgv/32m+T/J02ahH/84x+YOHFia1dLRERERERERCSYVidAHvf++++jS5cuQq6SiIiIiIiISCPx9SCKJWgCZOjQoUKujoiIiIiIiIhIEIImQJ4cD6Qp3t7eQhZNRERERERERNQoQRMgT74RpimPjx1CRERERERE1N6I+BoYhRI0ATJhwgSI5NRgWVkZ7ty5g1u3bsHf35/jhBARERERERGRQgmaAAkODm5yfmRkJH755RdMnjxZyGKJiIiIiIiIiJqk0EFnhw4dCnd3d4SFhSmyWCIiIiIiIiIVJFLRf5pJ4W/dcXFxQVJSkqKLJSIiIiIiIqJ2TOEJkLy8PNTW1iq6WCIiIiIiIiJqxwQdA6QpYrEYp0+fxqVLl+Dp6amoYomIiIiIiIhUkkiDu5uoIkETILNmzZI7vba2FkVFRaitrYWOjg6mTJkiZLFERERERERERE0SNAFSV1cnvxAdHTg5OcHNzQ1BQUFwdHQUslgiIiIiIiIioiYJmgDZuHGjkKsjIiIiIiIi0lgikcKH5WzXuLWJiIiIiIiISOMJmgB59OgRcnNzUVNTI3d+dXU1cnNz8ejRIyGLJSIiIiIiIiJqkqAJkL179+Kjjz5CZWWl3PlVVVWYM2cO9u/fL2SxRERERERERGpIpKL/NJOgY4DExsbC19cXxsbGcucbGxvD19cXV69exaRJk1pdnp62WavXQaRpxHVsYaVKxHW6yg6BSOVoibhfED3p4kT518+kHKYuq5UdAv1Xxf0wZYdAGkTQFiA5OTlwcHBochl7e3tkZ2cLWSwRERERERERUZMEbQFSW1sLkajp5jIikQjV1dVCFktERERERESkdkQa3N1EFQnaAsTGxgaJiYlNLpOYmAhra2shiyUiIiIiIiIiapKgCZCAgADcvXsXBw4ckDv/jz/+wN27d9GnTx8hiyUiIiIiIiIiapKgXWDGjRuH8+fPIzQ0FH/99Rd69OgBCwsL5OfnIz4+HqmpqbCyssJLL70kZLFEREREREREaohdYBRJ0ASIsbExFi9ejPXr1yMlJQX37t2Tmu/h4YHZs2c3+pYYIiIiIiIiIqK2IGgCBKgfB2T58uW4e/cuUlJSUFZWBiMjI7i7u8PV1VXo4oiIiIiIiIiInkrwBEgDV1dXJjyIiIiIiIiIGiESCTosJz1FmyRACgoKcP36deTn56OmpkbuMhMnTmyLoomIiIiIiIiIZAieANm9ezf++OMP1NbWNrkcEyBEREREREREpCiCJkDOnTuHffv2wcfHB6NHj8a3336LIUOGwM/PDwkJCTh9+jT69euHkSNHClksERERERERkRriW2AUSdAEyLFjx2BhYYH58+dDW1sbQP2gqAMGDMCAAQPQt29frFq1CgMGDBCyWCIiIiIiIiKiJgk64sr9+/fRq1cvSfIDAMRiseT/e/bsCT8/Pxw8eFDIYomIiIiIiIiImiRoAqS2thYmJiaSvzt06IDy8nKpZTp37ozU1FQhiyUiIiIiIiJSOyIV/U9TCZoAMTc3R0FBgeRvKysrpKWlSS1TUFAg1UKEiIiIiIiIiKitCZoAcXFxQXp6uuTv7t27Izk5GWfPnkVlZSWuXr2KS5cuoUuXLkIWS0RERERERETUJEETIP7+/khPT0d2djYA4JVXXoGhoSE2btyIN998E6tXrwYATJo0SchiiYiIiIiIiNSOsru6tLcuMKK6urq6tiwgOzsbBw8eRFZWFqytrTF69Gg4OTkJtPZbAq2HSHNU1RYqOwR6jK6WkbJDIFI5WiJdZYdApHKqxeVPX4gUxtRltbJDoP+quB+m7BDaVGn1KWWHIJex7jBlh9AmBH0Nrjw2NjaYMWNGWxdDRERERERERNSoNk+AEBEREREREZE8go5KQU/BrU1EREREREREGo8JECIiIiIiIiLSeOwCQ0RERERERKQEIpHmvnFFFbEFCBERERERERFpPCZAiIiIiIiIiEjjsQsMERERERERkVKwC4wisQUIEREREREREWk8JkCIiIiIiIiISOOxCwwRERERERGREojYBUah2AKEiIiIiIiIiDQeEyBEREREREREpPHYBYaIiIiIiIhIKdgmQZG4tYmIiIiIiIhI4zEBQkREREREREQaj11glOThw1x8//1OnDt3FYWFxbCxscDw4f0wa9YUdOxorOzw2hXWhepY++0uJNy4h7S0hygsKIGeXgc4OFjh+eG9MeW1kTAzM1F2iO3C0SMXEROTgOTkVCQnp6KsrALjxg3G12vmKDu0don1oVp4zlAdrAvVUFhQghMnonH2TCxSUu4jOysfuro6cPdwwivjh2L8q0OhpcVnrkJKvrAezp2t5c57mF2ILgHvS/7++dt/4vV/DGlyfacv3MALU74SNEZqPr4FRrGYAFGC+/czMXnyXOTlFWL48EC4ujri2rUU7NgRjnPnriAs7GuYm5sqO8x2gXWhWn7dfgRe3i547jkfWFiaoqK8Cteu3caPG/dj355I/CdsMezsLZUdpsbbtGkvkpNTYWioDzs7S9y9+7eyQ2rXWB+qg+cM1cG6UB1Hj17Cl0u3wNraHH0DvWFnb4W8vCKcPB6NxQt/wvlzcfhu3ccQiXiTJ6TCojJs+OWwzPSyskqpvw8evYy0Bzly1zH11UFwdbbFsdNxbRIjkSpiAkQJli79EXl5hViwYCZef32cZPrKlVsQEnIAa9f+imXLPlRihO0H60K1/BXzM/T0OshMX79uD7b8HI4tmw9iwaLpig+snfnss7dga2cJZ2d7xEQn4M03Fyk7pHaN9aE6eM5QHawL1eHiYo8NP8zF4CG9pFp6zJkzBZMnzcfxY1E4cTwaI0cFKjFKzVNUXI6v1u576nIHj13GwWOXZaZ3NDXEv/45DlVV1fh1z9m2CJFIJbE9moLdv5+J8+dj0amTDV577UWpebNnT4WhoT7Cw0+jvLyykTWQUFgXqkde8gMARgf1BQDcT3uoyHDarcB+vnBxceDTOhXB+lANPGeoDtaFagns54Ohz/vLdHOxsjZD8KSRAICY6ARlhEZNmPrqIBga6OHAkRjkFZQoO5x2TSQSqeQ/TaWUBEh5ebkyilUJUVHXAAADB/aSOVEYGxuid28vVFRUIT7+pjLCa1dYF+rjTGQsAMDDw0nJkRBRe8VzhupgXagPHR1tAIC2traSI9E8HfR0MHn8QHz64cv48O0gDH7OG1pazb9pfWvKMADA1tCTbRUikUoSNAHy1Vdfobi4uMllUlJSMG/ePCGLVSsNfbddXDrJne/s7AAAuHePfbzbGutCdYX88id+2PA7vl71H7w57UtsWL8PHt064+13xyo7NCJqp3jOUB2sC/VQU1OLgwfqu1YMHOSn5Gg0j72NObZ9/yGWzZuMb5a8iaO/LcSNs2sxMNDrqZ8N7O0OXy8n3LqTgbN/JSogWiLVIegYINeuXcPcuXMxe/ZsdO/eXWZ+eHg4du3a1aImNU0lS1avnvFMcSpTaWl96xcTE0O58xuml5SUKSym9op1obq2bzuMvLwiyd8DBvbA8hUzYWHBAe2ISDl4zlAdrAv1sPa7UKSkpGPQ4F4YMLCnssPRKDv2nMGF6GQk3XqAktIKdHGywT+nj8aMqcNwYMc8DH1lEa4n3W/0829PrW/9sS3slKJCpiZpbncTVSRoC5D33nsPZWVlWL58OXbv3o26ujoAQElJCVauXImdO3fC0tISX375pZDFEpGGOX1uA64l/orTZzdg7fqP8OBBNoInLEBiYqqyQyMiIqKn+M+vh7F92yF0cXXAqtWzlB2Oxlmxbh/OXExAdm4RKiofIfHWA/zf/K1YvzkChgZ6WPDxxEY/a2pigAlj+3HwU2q3BG0BMmzYMLi7u2PdunXYt28fEhMTERQUhO3btyM/Px/PPfcc3nvvPRgYGDR7natXr25i7q3WB61gxsYNTyXkj4PSMN3ExEhhMbVXrAvVZ2nVEcNHBMDLywXjXvgUX3y2CfvDVyk7LCJqh3jOUB2sC9UWuvMIVq0IQdeujti6bSE6mhkrO6R2Y/N/TmDOe2MxINCz0WWmjB8II0N97D5wkYOfqggR30uiUIK/Brdz585YuXIltm7disjISCQlJUFPTw/vvfcehg0bJnRxasfVtb6/amqq/H6paWkZAIAuXeT3ayXhsC7Uh0MnK3Tt2gnJyWkoKCiBubmJskMionaG5wzVwbpQXb9u/xOrV+2Au3tnbNm2EJaWHZUdUruSm18/FqORgV6jyzQMfrpl5wmFxESkatok3VRWVoasrCypaZr8Kp2WCAzsAQA4fz4WYrFYal5paTmuXk2CgYEe/Py6KSO8doV1oV6ycwoAANpazJITkeLxnKE6WBeqaevmA1i9agc8vVzwy/ZFTH4oQd9e7gCAe+nZcuf36dkVft1dcOtOBs5dSlJkaEQqQ/A7idjYWMydOxdJSUkYNmwY5s+fD0NDQ2zatAnr169HRUWF0EWqFScnewwc2At//52NnTv/lJr373+Hory8Ei+99DwMDfWVFGH7wbpQLampmXKbM4vFYqxftwf5ecXo2csdph3ZpJmIFI/nDNXBulA9m37Yh7XfhcK7uyu2/rIQ5uYctLytdHNzgKGcFh5OjlZY++V0AEDY7+flfvbtqcMBAL+EcvBT1SJS0X+aSVTXMFKpAHbs2IGIiAhJl5f+/fsDqB8EdcOGDYiLi4OtrS3mzJkDV1dXAUpUvzFAAOD+/UxMnjwXeXmFGD48EF27dkZ8/C1ERV2Di0sn7Nr1NU8cCqKJdVFVW6jsEJ7JrzuOYP3a3ejV2wOdHK1h1tEYeXnFuHw5GQ/Ss2Fl1RGbf/kcXd3Uq0mzrpb6JWxOnIjCyRPRAIDc3AKcPx+Hzp1t4e/vDQAwNzfB3HnTlRhh+6KJ9aEl0lV2CM9EE88Z6koT66JaLH9ME1V34I8z+OLzH6CtrYWprwXBWM7beTp1ssYr44cqPrhWMHVpahxC5fni4wn46N0XcT4qGff/zkVpWQVcnW0RNKwXDPQ74PDJWEya+S2qq2ulPmdibIC7MT9AR1sLboGz1Gr8j4r7YcoOoU1V1cYoOwS59LT7KDuENiFoAmTSpEno0qUL5syZAzs7O5n5Bw8eRFhYGEQiEXbu3ClAieqZAAGAzMwcrF+/E+fOXUVhYQmsrc0xYsRzmDVrCjp25GBRiqRpdaGuCZCUlHTs+e0UYq/cQlZWPkpKymFgoAdnFzsMGtwTr00bpZYDqaljAmTDv3dh48bdjc53cLDGyVM/KTCi9k0T60NdEyCA5p0z1Jmm1YW6JkA2btiDHzfubXKZgD7eCNmxWEERCUNVEyADA73w7rQR8OvuDFtrMxgZ6qGwuBzXEtMQ+vs5hO47J/dz704bgfUrZmD3gYt4c/a/FRx16zABohxMgDRDSEgIpk2bBh2dxsdWvX37Nr7//nv8+99C7HjqmwAhaivqmgDRVOqYACFqa+qcACFqK+qaANFUqpoAaY80PQHySHxZ2SHI1UErQNkhtAlBEyDNVV5eDkND2eZxLccECNGTmABRLUyAEMliAoRIFhMgqoUJENXBBIhyaGoCRCmvUxAm+UFERERERERE1DyN91V5BomJic1e1tvbW8iiiYiIiIiIiNSM5r5xRRUJmgBZunRps5f97bffhCyaiIiIiIiIiKhRgiZAJkyYAJFINoNVVlaGO3fu4NatW/D390eXLl2ELJaIiIiIiIiIqEmCJkCCg4ObnB8ZGYlffvkFkydPFrJYIiIiIiIiIrUjUs6wnO2WQrf20KFD4e7ujrAwzR7Jl4iIiIiIiIhUi8LTTS4uLkhKSlJ0sURERERERETUjgnaBaY58vLyUFtbq+hiiYiIiIiIiFQM3wKjSAprASIWi3Hy5ElcunQJXbt2VVSxRERERERERETCtgCZNWuW3Om1tbUoKipCbW0tdHR0MGXKFCGLJSIiIiIiIiJqkqAJkLq6OvmF6OjAyckJbm5uCAoKgqOjo5DFEhEREREREakdEbvAKJSgCZCNGzcKuToiIiIiIiIiIkEIOgZIYmIiUlNThVwlEREREREREVGrCZoAWbp0KU6cOCHkKomIiIiIiIg0kkgkUsl/mkrQBIipqSk6dOgg5CqJiIiIiIiIiFpN0ASIt7c3bt68KeQqiYiIiIiIiIhaTdAEyOTJk5GRkYFdu3ahpqZGyFUTERERERERaRgtFf2nmQR9C8z+/fvh5OSE/fv34/Tp03B2doaZmZnMciKRCO+//76QRRMRERERERERNUrQBMiZM2ck/19YWIjCwsJGl2UChIiIiIiIiIgURdAEyIYNG4RcHREREREREZHGEkFz37iiigRNgFhbWwu5OiIiIiIiIiIiQQg6uslff/2FpUuXIj8/X+78/Px8LFu2DFFRUUIWS0RERERERETUJEETIKdOnUJ5eTksLCzkzrewsEB5eTlOnTolZLFEREREREREakikov80k6AJkPv378PV1bXJZbp27Yq0tDQhiyUiIiIiIiIiapKgCZDS0lJ07NixyWVMTExQUlIiZLFERERERERERE0SdBBUExMTZGZmNrlMZmYmDA0NhSyWiIiIiIiISO2IRJrb3UQVCdoCpFu3brh8+TL+/vtvufMfPHiAy5cvw8vLS8hiiYiIiIiIiIiaJGgCZNy4cRCLxVi0aBEiIiKQkZGByspKZGRkICIiAosXL4ZYLMa4ceOELJaIiIiIiIiIqEmiurq6OiFXeOLECWzduhVisVhmnpaWFt555x0MHz5coNJuCbQeIs1RVVuo7BDoMbpaRsoOgUjlaIl0lR0CkcqpFpcrOwR6jKnLamWHQP9VcT9M2SG0qTrcVHYIconQrdXryMvLw2+//Yb4+HiUlJTA3Nwcffr0wcSJE2FsbCxAlC0n6BggADBixAh4enri2LFjSElJQXl5OQwNDeHu7o5Ro0bB0dFR6CKJiIiIiIiISEU8fPgQCxcuRFFREQICAtCpUyfcvn0bERERiIuLw5dffgkTExOFxyV4AgQAHB0d8fbbb7fFqomIiIiIiIhIhW3duhVFRUV46623MGbMGMn07du3488//0RYWBhmzpyp8LgEHQOEiIiIiIiIiJpHpKL/tcbDhw8RHx8Pa2trjB49WmpecHAw9PT0cO7cOVRWVraqnGfBBAgRERERERERCSIhIQEA4OfnBy0t6ZSDgYEBPD09UVVVhZSUFIXH1iZdYIiIiIiIiIhIPc2bN6/RyGP9WwAAIABJREFUeatXNz1IcEZGBgDA3t5e7nw7OzvEx8cjMzMTvr6+zx7kM1DzBIiHsgNotYYf1tN+RNT2NKUu9LSVHUHraUpdaArWh+pgXagO1oXq0JS60NWAdtmaUheAZrx5RJPqQ7Op/z3tk8rL699qZWhoKHd+w/SysjKFxdRAzRMgRERERERERCQkTU2caUCumYiIiIiIiIhUQUMLj4aWIE9qmG5kZKSwmBowAUJEREREREREgnBwcAAAZGZmyp3/8OFDAI2PEdKWmAAhIiIiIiIiIkF0794dABAfHw+xWCw1r6KiAsnJydDT04O7u7vCY2MChIiIiIiIiIgEYWdnBz8/P+Tk5ODo0aNS83bv3o2qqioMGjQI+vr6Co+Ng6ASERERERERkWBmzJiBhQsXYtu2bbh+/TocHR2RkpKChIQE2NvbY8qUKUqJS1RXV1enlJKJiIiIiIiISCPl5uZi9+7diIuLQ0lJCczNzdG3b19MnDgRxsbGSomJCRAiIiIiIiIi0ngcA4SIiIiIiIiINB4TIERERERERESk8ZgAISIiIiIiIiKNxwQIEREREREREWk8JkCIiIiIiIiISOMxASKA7OxsBAcHY+PGjc1aPjIyEsHBwYiMjGxVubt370ZwcDASEhJatR5N8OGHH+LDDz+U/C3UNibN0t5/Fy09VrXWkiVLEBwcrJCyVMmTxyPSPEKdfzdu3Ijg4GBkZ2cLFJl6ae0xqb1vPyIiajkmQIhIZfHiltoDRSemqP0m54iUITg4GEuWLFF2GEREAAAdZQdAzy4oKAgDBgyAlZWVskNROX379oW7uzvMzc2VHQpRuzVr1ixUVVUpOwwiwfH8qxqmTp2KV155BRYWFsoOhYiI1AQTIGrM1NQUpqamyg5DJRkaGsLQ0FDZYRC1a7w5JE3F869qMDc354MOIiJqESZA2tDDhw8RGhqK69evo6amBs7Oznj11VcbXf7GjRu4cOECkpOTkZ+fj5qaGtjZ2aFfv354+eWX0aFDB6nld+/ejb1792Lx4sXo3r17W38dpaurq8PRo0dx7NgxZGVlwdjYGH379sWUKVNklo2MjMQPP/yADz74AEOHDpVMb+k2BoCCggKEhYXh6tWrqKiogIODA1588UVYW1tj6dKlmDhxolRT6qysLPzxxx+4ceMG8vPz0aFDB1hYWKBbt26YMmUKTExM2mT7COny5cuIiIjAgwcPUFpaChMTE9jZ2aF///4YPXq0ZLnS0lKEh4cjJiYG2dnZ0NHRQdeuXfHyyy/Dz89Pap2P14mpqSl+//13pKWlQUdHBz4+Ppg6dSrs7e0lyz++TWfNmiX5f2tra0lXgbt37+LMmTNITExEbm4uHj16BEtLSwQEBODVV1+FsbFxs75vWloa9u/fj5SUFBQUFMDAwABWVlbw8vLCtGnToKOj2YfKqqoqHD58GJcuXUJGRgbq6upgZWUFX19fvPrqqzAzM0NKSgoWLVoES0tLfP3111IJxoKCAsydOxeVlZVYtWoVOnXqBKC+m0FiYiJ2796trK8mqIsXL+Lo0aNITU2VHDsGDhyIsWPHQldXV2b58vJyhIWFITo6GqWlpbCxscHIkSMxZswYiEQiAP87jgPAmTNncObMGcnnG45fCQkJkmONv78/du3ahVu3bkFLSwvdu3fH9OnTYWVlhaysLISFheH69euorKyEh4cH3nzzTbi4uEjFlZGRgdOnT+P69evIyclBRUUFzMzM4Ofnh4kTJ8LS0lJq+cfL7927N/bs2YNbt26hrKwMGzZsgI2NjcBb+tlERkbi8uXLSE1NRUFBAXR0dODk5ISRI0di8ODBAOq7Gz1+PHn8OOPt7S1ppt8whsuaNWuwZ88eREdHIz8/H+PHj0dwcHCj59/o6GhcunQJd+7cQX5+PgDAwcEBQ4YMQVBQELS0mtfzuLnHYE3VnGMSUN9N8syZM1K/w4Y6HjJkCCZMmICdO3ciISEBNTU18PDwwBtvvAEnJycUFxcjLCwMV65cQVlZGZycnPDaa6/Bx8dHmV9dMM3ZHx5XWlqKgwcP4vLly8jKyoK2tjZsbGzQs2dPTJgwAfr6+gD+t2/I67L35H7RcN4HgMTERKn97clrp5SUFISHhyM5ORmlpaUwMzNDr169MHHiRJkWPppwnfU0t2/fxsGDB5GcnIySkhIYGxvDyckJw4YNQ//+/aV+5+PHj8dvv/2GhIQElJSUYNGiRejevXuL6goAtm3bhsOHD+PFF1/Em2++KbX8qVOnsGnTJvj6+uKLL75o9rGMSBVp9lW9EmVmZmLBggUoKSlBr1694OzsjIcPH2LNmjXo2bOn3M8cOHAAGRkZ8PDwQO/evVFdXY2bN29iz549SExMxMKFC9v1ASckJASHDx+Gubk5hg8fDh0dHcTExOD27duoqalp1k1qS7dxUVERFixYgJycHHh5eaFbt24oLCzE1q1b0aNHD5n1FxQU4PPPP0dFRQV69eqFwMBAVFdXIzs7G+fOnUNQUJDKn5hPnDiBn3/+GWZmZvD394eJiQmKi4uRlpaGyMhIycV3Tk4OlixZItk2fn5+qKqqwtWrV7FixQq8++67GDFihMz6o6KiEBcXhz59+sDb2xtpaWmIiopCQkICli9fDgcHBwD1F0cxMTFIS0vDCy+8ILnhNjIykoo1JiYGXl5e8PX1hVgsxr1793Do0CHExsZixYoVMDAwaPL7pqWlYf78+RCJRAgICICNjQ3Ky8uRlZWFo0ePYvLkyRqdACktLcXSpUuRlpYGBwcHPP/889DR0UFWVhYiIyMRGBgIMzMzuLu7Y8qUKfjPf/6DTZs24V//+hcAQCwWY/369SgqKsIHH3wgSX5omtDQUPzxxx8wMTHBwIEDoa+vj7i4OISFhSE+Ph4LFiyQ+p3U1NTgyy+/RFlZGQYMGICamhpERUUhJCQEGRkZeOeddwAA3bt3R3l5OSIiIuDs7Iw+ffpI1vFk4uLOnTs4cOAAvL29MXz4cKSnpyM6Ohrp6emYO3cuFi1aJLnZzsnJQXR0NJYvX44NGzZIbl6A+pv048ePo3v37vDw8ICOjg4ePHiAU6dO4cqVK1i1apXcLgUpKSn4448/4Onpieeffx4lJSUqtW9s3rwZnTt3hpeXF8zNzVFSUoLY2Fhs2LABGRkZmDx5MoyMjDBx4kScOXMGOTk5mDhxouTzTyZyampqsGzZMpSWlqJHjx4wMDB4arInNDQUIpEIbm5usLCwQHl5OW7cuIGQkBDcuXMHs2fPfur3aO4xWFM195j0NDk5Ofjiiy/QqVMnDB06FNnZ2YiJicHSpUuxfPlyyfmhf//+KC0txYULF7By5Up8//33GtF6rTn7Q4Ps7GwsXboUOTk5cHV1xahRoyAWi5GZmYk///wTI0eOlDqGNJeLiwsmTpyIvXv3wtraGkOGDJHMezxxeOrUKfz888/Q1dWFv78/rKyskJmZiZMnT+LKlSv46quvJHWiCddZT3PixAls2bIFWlpaCAgIgJ2dHYqLi3Hnzh0cO3YM/fv3lyyblZWFL774Avb29hg4cCAePXr01Ouexrz++utITk5GREQEfH190bt3bwBAeno6tm3bBjMzM8yePbtd34uQZlCdKxcNs3XrVpSUlGD69Ol44YUXJNNjYmKwZs0auZ955513YGNjI3ky2GDXrl34/fffcenSJamDXnty8+ZNHD58GLa2tli5cqXkyf7kyZOxdOlSFBQUwNra+qnraek2Dg0NRU5ODl566SVMmzZNMv2FF17A/PnzZdZ/6dIllJaWytQ7AFRWVqrFSeP48ePQ0dHBmjVr0LFjR6l5xcXFkv/fuHEjcnNz8dFHH2HAgAGS6WVlZViyZAm2bduGgIAAmQvVK1euYN68efD395dMi4iIQEhICLZs2YJFixYBqH8ym5OTI0mAyLvxGD9+PN555x2Z7drwpOLo0aN45ZVXmvy+Z86cQXV1NT799FOpm0+g/kJcXqsgTbJ161akpaVh5MiRmDFjhtS2rKyshFgslvw9btw4JCQk4NKlSzh+/DhGjhyJffv2ISEhAYMHD5ZqbaVJbt26hT/++AOWlpZYuXKl5Dc9depUrFmzBlevXkV4eLhUC7+CggLY2Njg22+/lbQOCQ4Oxueffy65gPX29kb37t1hbW2NiIgIuLi4NDkwZ2xsLGbPno1BgwZJpv344484ffo0FixYgHHjxknFsHfvXuzevRunTp2SOh4NHjwYL774okyrlfj4eKxYsQL79u3Du+++K1N+fHw83n33XYwcObKFW1Axvv32W9jZ2UlNq6mpwYoVK3DgwAGMGjUKFhYWCA4ORmJiInJycprc3gUFBXB0dMSSJUuaffP32WefycQgFovxww8/4OzZswgKCoK7u3uT62juMVhTteSY1JTExERMnjxZ7j4xf/58PPfcc1Lnjx49emDDhg04dOgQpk+fLuh3Uobm7g8AsH79euTk5GDKlCkYP3681GeKi4ufKfkB1CdAXFxcJAkQeftbRkYGNm/eLGlV+3jy9fr161i+fDm2bduGTz/9FIBmXGc15cGDB9i6dSsMDAywbNkydO7cWWp+Xl6e1N/Jycl45ZVXMHXq1FaXraOjg48//hjz5s3Dxo0bsWbNGhgZGWHdunV49OgR5s6d26zkI5GqU++jhIrKy8vDtWvXYGNjg6CgIKl5DU+95bG1tZW5MQeAsWPHAgDi4uKED1ZNnD59GgBkujV06NChRQf9lmzjmpoaXLhwAYaGhpgwYYLU8i4uLnKbkD4e15P09fXV5mZaW1sb2traMtMb+rynpqYiMTERgYGBUskPoL6FRnBwMKqrqxEVFSWzDh8fH6nkB1A/oKCtrS1u3LiBnJycZsdpbW0t92Ln+eefh4GBAeLj45u9Lnl1Y2xsrPYXU00pKirCxYsXYW5ujtdff13mu+rr60t1dRGJRPjwww9hYWGBkJAQHDlyBPv27YODg4OkRYMmOnXqFABgwoQJUhd/2traeOONNyASiSTLPG7q1KlSSQZjY2PJseRZXsXs6ekplfwAIHmiamhoKJPsa5iXmpoqNd3CwkJulx0/Pz907ty50f3GxcVFZZMfAGRu9oD6C/rRo0ejtrYW169fb/E6X3/99Rbd/MmLQUtLS3Kj1txj0tOOwZqqpcekplhbW8vsEw1J2pqaGpn1Dxw4ENra2khLS2vdl1ARzd0f7t69i1u3bsHFxQUvv/yyzGdMTU3b9Nrl2LFjqK2txVtvvSXT8szX1xcBAQG4cuUKKioqpOap+3VWYxq2x4QJE2SSHwBkuih27NgR//jHPwQr387ODjNnzkRJSQm+//57bN26Fenp6Rg/fjx8fX0FK4dImdgCpA3cu3cPQP3FqrybJ29vbyQmJspMr6ysREREBGJiYpCRkYHKykrU1dVJ5hcUFLRd0CquYZvKSx41tp3lack2zsjIwKNHj9C1a1e5zQk9PT1lbnoCAgIQFhaGrVu3Ii4uDj179kS3bt3g6OgoN/GiigYNGoQdO3bgX//6l+Qptaenp9SF961btwDUj3Egb3yHhqeUf//9t8w8eXWopaUFT09PZGVl4d69e81qzQPUX8SeOHECFy5cwIMHD1BeXi5Vnw198JvSv39/REREYM2aNejXrx98fX3RrVs3uRePmubOnTuoq6uDl5dXs2/yTE1N8X//939YtmwZfvnlF+jq6mLOnDnP/IRQHTQcf+SNDeDg4ABLS0tkZ2ejvLxccnOmra2Nbt26ySzf8PtvWGdLuLq6ykxruGFwcXGROQ42zHvyiWFdXR3OnTuHM2fOIDU1FWVlZVJP1Rvr1uLm5tbimBUpNzdXMi5Aw5hAj2vO8eBxurq6cHZ2btFnSkpKEB4ejtjYWGRlZcm8Bak5MTTnGKypnuWY1Bh5+0TDgKn29vYy53UtLS107NhRZn9RV83dHxrO535+fkpJ+KekpACob7Fz+/ZtmfnFxcWS7jiurq4acZ3VlIbt0atXr2Yt7+LiIjeh3RoDBgzA9evXcerUKSQlJcHT05OvDSeNwgRIGygvLwcAmaarDeQ1H2voa3z79m107twZ/fv3h6mpqeQJ0N69e1FdXd12Qau4praptrZ2s/p7tnQbP0s9WltbY8WKFdizZw/i4uIQHR0NoD5jP27cOJnmmqpo7NixMDExwbFjx3D48GFERERAJBLB29sb06ZNQ9euXVFaWgoAuHbtGq5du9bouiorK2WmPW17Nmz35li3bh2io6Nha2uLPn36wMzMTHLzFhERgZqamqeuw83NDcuWLZN0gTp79iyA+hvbiRMnYuDAgc2OR92UlZUBQItfIenm5gYrKytkZ2fDx8dHZqwKTdPwm2ys6a+5uTlyc3NRVlYmSYCYmJjIvZl4lt95A3lPvhvKkDev4dhWW1srNX379u2IiIiAubk5/Pz8YGFhIXlq2jA2hjyq3PQ5KysL8+fPR2lpKby8vNCjRw8YGhpCS0sLOTk5kq5uLdGxY8cW3VCVlZXh888/R3Z2Ntzc3DBkyBBJK7KGcV6aE0NzjsGa6lmPSfI0tU801opEW1tbZn9RRy3ZHxqORcp6lXBJSQkAIDw8vMnlGq4nNOE6qykt3Qcau6ZqrX79+kke8rVkAGcidcAESBtoOLEWFRXJnV9YWCgz7fLly7h9+zaGDh2KDz74QGpeQUGB5C0B7dXj2/TJp0K1tbUoKSmRaRb4pJZu44anQy2pRwBwdHTExx9/jNraWqSlpeHatWs4cuQIQkJCoK+vj2HDhjUZpyoYMmQIhgwZgrKyMty8eRPR0dE4ffo0vvrqK6xbt05SH/L64D7N07Znc5s337lzB9HR0fD19cX8+fOlmouLxeKnXkw9zsPDA5999hmqq6tx9+5dxMXF4ciRI1i/fj1MTU3lDnirCRoGlG3pk/GQkBBkZ2fDxMQEsbGxOHfunEzXDE3S8JssLCyU2zKooeXY47/dkpISiMVimYvGlv7OhVZUVITDhw+jc+fOWL58ucxT8AsXLiglrtY6dOgQSkpKZN78BQDnz5+XertOc7X0afLJkyeRnZ0t83YLoP4pe0RERLPX9bRjsKa2BnnWYxJJa8n+0HAsau42F4lEjT5caE1iNyQkpNnHRU24zmrM4/tAcwYVb+o49ax1VVxcjE2bNkFPTw9AfdLcx8dHY4871P4wndcGunTpAqB+YCJ5g3XJ6/7y8OFDAEDfvn2btXx707BN5W2Lxrbzk1q6jTt16oQOHTogLS1Npu9pQ7lN0dbWhqurK1555RV89NFHACB5UqEujIyM0Lt3b/zzn//E0KFDUVpaisTERMkgfk/bBvLI29ZisViyroa6Bv73dFte/TbUZ0BAgExf+du3b8s0920OXV1ddOvWDZMmTcJbb70FoD5xpqnc3NwgEomQlJQkt7WOPBcvXsSJEyfg5eWF1atXw9TUFJs3b0ZmZmYbR6s8TR1/Hj58iLy8PNjY2Ei9oai2thY3b96UWb5hHc39nQstKysLdXV18PPzk0l+5OXlITs7u81jaAsNx4PAwECZefLqrS22eUMM/fr1a1YMzdHYMVhTPcsxiWS1ZH/w8PAAUD8+TXP2ByMjIxQVFcm9sb5z547cz4hEokbX3ZrrCU24znpSw/aIjY1t9bqepa7q6uqwceNG5OfnY/r06Zg+fToKCgqwYcMGqS7GROqMCZA2YGlpiR49eiA7OxtHjhyRmhcTEyP34qVhzIMn52VlZWHnzp1tF6yaaHiC8fvvv0u6XwDAo0ePEBoa2qx1tHQb6+jooH///igvL8e+ffuk5qWmpkq6Sjzu7t27crPqDa0eGrLpquzGjRtyT3KPf4euXbvCy8sLUVFRcgd/BID79+/Lbe1x48YNXLlyRWrakSNHkJWVJXkjRoOGrk25ubky62lYLiEhQSbOrVu3NvUVpdy8eVNusqThSb26D6jWFFNTUwwYMAAFBQX49ddfZS5QKysrpX7PWVlZ+Omnn2BiYoKPPvoIVlZW+PDDD1FVVYV169ZpbDe9559/HgCwb98+qbdwiMVi7NixA3V1dXKfOIaGhkptk9LSUsmx5PGnssbGxhCJRHJ/50JreJvSk4njyspK/PTTT2rb/L+x40FcXJzcY1TDYNpCbvOGbftkDPfu3cP+/fubvZ7mHIM1VUuPSSRfS/YHV1dXdOvWDampqThw4IDMukpKSqTOkW5ubqitrZUZyDkyMlJu0heoP5c3NrZKUFAQtLW1sX37dmRkZMjMr6mpQVJSkuRvTbjOasqoUaOgra2Nffv24cGDBzLzWzJGzbPU1aFDhxAbG4v+/ftj+PDhGD58OPr374+4uLgWtawlUmXsAtNGZsyYgQULFiAkJATx8fFwdnbGw4cPERMTA39/f5kbQH9/f9jZ2eHQoUO4f/8+XFxckJubi6tXr6J3794KuTBWZZ6enggKCsKRI0fwySefIDAwEDo6OoiJiYGxsbFkYLOmPMs2njp1Km7cuIHw8HDcvn0bHh4eKCwsxF9//YVevXohJiZGqon72bNncfz4cXh6esLW1hbGxsZ4+PAhrly5Al1dXbz44ouCbpe28M0330BfXx/u7u6Si6ikpCTcuXMHrq6uklHAGwbC3LRpEw4fPgx3d3cYGhoiPz8faWlpSE9Px/Lly2X6p/r7++Obb75Bnz59YGdnh7S0NMTGxsLY2FjmTSI+Pj4IDw/HTz/9hMDAQBgYGMDIyAhBQUFwc3NDt27dEB0djQULFsDT0xOFhYWIi4uDg4NDs34TAHDgwAEkJCTA09MTNjY20NfXR3p6OuLi4mBkZIQRI0YIsFVV19tvv4309HQcP34ciYmJ8PPzg46ODrKzsxEfH4+5c+eie/fuqKmpwbp161BRUYG5c+dK+if36tULY8eOxcGDB/Hrr7/i7bffVvI3El63bt3w0ksvITw8XHL80dfXR2xsLNLT0+Hp6YmXXnpJ6jPm5uaoqanBJ598goCAANTU1CAqKgoFBQUYNWqU1GDA+vr6cHNzQ3JyMtavXw97e3toaWkhICCgxYNwPo2ZmRn69++Pixcv4tNPP4Wfnx/Ky8tx7do16OrqwsXFReatMepg9OjRiIyMxNq1axEYGAgLCwvJfvzcc8/h4sWLUsv7+vri0qVL+Oabb9CrVy906NAB1tbWTb7d62kGDx6M8PBwhISEICEhAXZ2dpLjf2BgoEwMjWnuMVhTNfeYRI1r6f4we/ZsLFmyBGFhYYiKipIcnzIzM3Ht2jWsXbtWkuAbM2YMIiMjsXnzZly/fh2WlpZIS0vDrVu30Lt3b1y9elUmHh8fH1y8eBGrVq2Cq6srtLW14eXlBW9vb3Tq1Anvv/8+fvzxR3zyySfw8/ODg4MDampqkJubi+TkZJiammLdunUANOM6qymOjo6YMWMGNm/ejLlz5yIgIAD29vYoKSnBnTt3YGhoiMWLFzdrXS2tq9u3byM0NBQ2NjaYOXOmZPrMmTNx584d7Nq1C15eXpJWQ0TqigmQNmJvb4+vvvoKO3fuxPXr15GYmAgnJyd8+umnKC4ulkmA6OvrY9GiRQgNDUVCQgKSkpJga2uLCRMmYOzYsc2+cNJkb731FhwcHHD06FGcOHECJiYm6NOnD6ZOnSp5P3xTnmUbm5mZYfny5QgNDUVsbCxSUlLg4OCAGTNmQF9fHzExMVLNyAcMGIDq6mrcunULd+/exaNHj2BhYYEBAwZg7NixcHJyEnSbtIWpU6ciPj4e9+7dQ2xsLHR1dWFtbY3XXnsNo0aNkgwyamlpiVWrVuHw4cOIiorCuXPnIBaLYWZmBkdHR4wZM0bu9w0MDMSIESPw+++/IzY2Ftra2ujbty+mTp0KBwcHqWV79uyJN954AydPnpQMamptbS0ZkGvevHnYtWsXYmNjcfjwYVhYWGDYsGGYMGEC/vWvfzXr+44ePRrGxsZISUmRPBW3sLDAqFGjMG7cuGa/kUZdGRsb48svv0RERISke4uWlhYsLS3x/PPPw9HREUB9a4Y7d+5gzJgxCAgIkFrHlClTkJSUhCNHjsDHx0duNzN1N23aNHTp0gVHjhzB2bNnUVtbC1tbW0yePBljx46VeXOKjo4OFi5ciNDQUFy4cAElJSWwtbXFyy+/jDFjxsisf/bs2QgJCUFcXBwuXLiAuro6WFpaCp4AAYD3338ftra2uHjxIo4ePQpTU1P4+/tj0qRJ+PbbbwUvTxGcnZ2xePFiyfGgtrYWzs7O+OSTT2BkZCRzfB8+fDhycnJw8eJFhIeHo7a2Ft7e3q1KgFhYWGDZsmXYuXMnkpOTER8fL3lFtK+vb7PP4809Bmuq5h6TqHEt3R9sbGywevVqHDhwADExMTh69Kjkdzd27FipBxmOjo5YuHAhwsLCcOXKFWhra8PT0xPLly9HVFSU3ATIW2+9BZFIhBs3biA2NhZ1dXWYOHGiJNEyePBguLi44ODBg0hISMC1a9egp6cHCwsL9OvXD/3795esSxOus55mxIgRcHJyQnh4OBITExETEwNTU1M4OTlh+PDhzV5PS+qqvLxckmSaM2eO1HgshoaGmDNnDhYuXIjvv/8eX3/9tVSXTyJ1I6pjhy6iZxIWFob9+/dj/vz56Nmzp7LDUXmRkZH44Ycf5A7KRkRERERE1NY4BgjRU8gbGf3+/fs4fPgwjI2NpZqyExERERERkWrS7HaURAL4/PPPYWdnh86dO0NPTw+ZmZmIjY2FWCzGzJkzNXqQTCIiIiIiIk3BBAjRU4wYMQIxMTG4cOECKioqYGRkBD8/P4wbN44DsREREREREakJjgFCRERERERERBqPY4AQERERERERkcZjAoSIiIiIiIiINB4TIERERERERESk8ZgAISIiIiIiIiKNxwQIEREREREREWk8JkCIiIiIiIiISOMxAUJEREREREREGo8JECIiIiIzbNxPAAAARElEQVQiIiLSeEyAEBEREREREZHGYwKEiIiIiIiIiDQeEyBEREREREREpPGYACEiIiIiIiIijccECBERERERERFpvP8PuBZLozbxgQYAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 544,
              "height": 411
            }
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sni8SmGzV6Vc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "outputId": "f614f5d3-51f1-46e0-edfd-beaab78e8c36"
      },
      "source": [
        "# import seaborn as sn\n",
        "\n",
        "\n",
        "# # remove unknown labels \n",
        "# array = array[0:-1, 0:-1]\n",
        "\n",
        "# vessels_names = ['ldai', 'diags', 'septals', 'lcxi', 'obtmar', 'atrials', 'lcim', 'acutes', 'crux']\n",
        "# df_cm = pd.DataFrame(array, index = [i for i in vessels_names],\n",
        "#                   columns = [i for i in vessels_names])\n",
        "# plt.figure(figsize = (10,7))\n",
        "# sn.heatmap(df_cm, annot=True, cmap=\"YlGnBu\", fmt='d')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f99614d9390>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 544,
              "height": 411
            }
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F09_QQ7r_qyw",
        "colab_type": "text"
      },
      "source": [
        "# Appendix A - Displays Model Information"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Eo0MTCT2w7rj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Move all the files in the test folder back to the main folder \n",
        "\n",
        "import os\n",
        "import shutil\n",
        "source = '/content/test'\n",
        "dest1 = '/content/processed'\n",
        "folders = os.listdir(source)\n",
        "\n",
        "for folder in folders:\n",
        "\n",
        "    if folder == \".DS_Store\":\n",
        "        continue\n",
        "    new_folder_path = f\"{source}/{folder}\"\n",
        "\n",
        "    single_folder = os.listdir(new_folder_path)\n",
        "\n",
        "    for f in single_folder:\n",
        "        shutil.move(f\"{new_folder_path}/{f}\", f\"{dest1}/{folder}\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-AEnfmgy3qVL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        },
        "outputId": "27c6615d-dd8b-4890-da33-c4212341bfe9"
      },
      "source": [
        "# from torchvision import models\n",
        "# model = models.vgg16()\n",
        "print(model)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ConvNN_single_heart(\n",
            "  (conv1): Conv2d(4, 16, kernel_size=(1, 3), stride=(1, 1))\n",
            "  (conv2): Conv2d(16, 64, kernel_size=(1, 3), stride=(1, 1))\n",
            "  (conv3): Conv2d(64, 256, kernel_size=(1, 3), stride=(1, 1))\n",
            "  (conv1_bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (conv2_bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (conv3_bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (fc1_bn): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (fc2_bn): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (fc_dropout): Dropout(p=0.5, inplace=False)\n",
            "  (conv_dropout): Dropout(p=0.1, inplace=False)\n",
            "  (fc1): Linear(in_features=2560, out_features=128, bias=True)\n",
            "  (fc2): Linear(in_features=128, out_features=32, bias=True)\n",
            "  (fc3): Linear(in_features=32, out_features=10, bias=True)\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvErnUHdHhYn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 663
        },
        "outputId": "3d6124fe-7bbb-4a01-b19c-a9d787b76896"
      },
      "source": [
        "# Prints the model's state for each layer\n",
        "print(\"Model's state_dict:\")\n",
        "for param_tensor in model.state_dict():\n",
        "    print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size())\n",
        "\n",
        "# Print the weights of the model - A LOT OF MATRICES\n",
        "# print(\"Optimizer's state_dict:\")\n",
        "# for var_name in optimiser.state_dict():\n",
        "#     print(var_name, \"\\t\", optimiser.state_dict()[var_name])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model's state_dict:\n",
            "conv1.weight \t torch.Size([16, 4, 1, 3])\n",
            "conv1.bias \t torch.Size([16])\n",
            "conv2.weight \t torch.Size([64, 16, 1, 3])\n",
            "conv2.bias \t torch.Size([64])\n",
            "conv3.weight \t torch.Size([256, 64, 1, 3])\n",
            "conv3.bias \t torch.Size([256])\n",
            "conv1_bn.weight \t torch.Size([16])\n",
            "conv1_bn.bias \t torch.Size([16])\n",
            "conv1_bn.running_mean \t torch.Size([16])\n",
            "conv1_bn.running_var \t torch.Size([16])\n",
            "conv1_bn.num_batches_tracked \t torch.Size([])\n",
            "conv2_bn.weight \t torch.Size([64])\n",
            "conv2_bn.bias \t torch.Size([64])\n",
            "conv2_bn.running_mean \t torch.Size([64])\n",
            "conv2_bn.running_var \t torch.Size([64])\n",
            "conv2_bn.num_batches_tracked \t torch.Size([])\n",
            "conv3_bn.weight \t torch.Size([256])\n",
            "conv3_bn.bias \t torch.Size([256])\n",
            "conv3_bn.running_mean \t torch.Size([256])\n",
            "conv3_bn.running_var \t torch.Size([256])\n",
            "conv3_bn.num_batches_tracked \t torch.Size([])\n",
            "fc1_bn.weight \t torch.Size([128])\n",
            "fc1_bn.bias \t torch.Size([128])\n",
            "fc1_bn.running_mean \t torch.Size([128])\n",
            "fc1_bn.running_var \t torch.Size([128])\n",
            "fc1_bn.num_batches_tracked \t torch.Size([])\n",
            "fc2_bn.weight \t torch.Size([32])\n",
            "fc2_bn.bias \t torch.Size([32])\n",
            "fc2_bn.running_mean \t torch.Size([32])\n",
            "fc2_bn.running_var \t torch.Size([32])\n",
            "fc2_bn.num_batches_tracked \t torch.Size([])\n",
            "fc1.weight \t torch.Size([128, 2560])\n",
            "fc1.bias \t torch.Size([128])\n",
            "fc2.weight \t torch.Size([32, 128])\n",
            "fc2.bias \t torch.Size([32])\n",
            "fc3.weight \t torch.Size([10, 32])\n",
            "fc3.bias \t torch.Size([10])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6L46iOl4dkub",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1719dde0-3e0c-42d6-a520-4732b0881e73"
      },
      "source": [
        "\n",
        "total_params = sum(p.numel() for p in model.parameters())\n",
        "\n",
        "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "print(f\"The total params are {total_params} and the trainable one are {trainable_params}\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The total params are 1305562 and the trainable one are 1305562\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fKL2Be963upd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}