Grad_CAM.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "LsIFa5x608e5",
        "Rs178wNJ1xxb",
        "8KMLX4NH3xlk",
        "CKhoOcnd33CF",
        "sFGqW4kHXrIn"
      ],
      "authorship_tag": "ABX9TyPhogpl9pHDCnJ1gqt24Z1d",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/daniele-marini/Explainability_tools_medical_diagnosis/blob/main/Grad_CAM.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import of the libraries"
      ],
      "metadata": {
        "id": "LsIFa5x608e5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras.applications import ResNet50\n",
        "from tensorflow.keras.layers import Dense,GlobalAveragePooling2D\n",
        "from tensorflow.keras import Model\n",
        "import os\n",
        "import pandas as pd\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "\n",
        "from keras.models import load_model\n",
        "\n",
        "from IPython.display import Image, display\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm"
      ],
      "metadata": {
        "id": "AG9H2LA409Rp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import of the dataset"
      ],
      "metadata": {
        "id": "Rs178wNJ1xxb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In order to import the dataset directly from kaggle we have to create **and** import the kaggle.json key first"
      ],
      "metadata": {
        "id": "C2ko9lA010IU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip -qq install kaggle"
      ],
      "metadata": {
        "id": "ykln38131zTE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!mkdir ~/.kaggle"
      ],
      "metadata": {
        "id": "_FmXHby-28Az"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cp kaggle.json ~/.kaggle/\n",
        "!chmod 600 ~/.kaggle/kaggle.json"
      ],
      "metadata": {
        "id": "_tt6Dn3127-u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "I will use the brain tumor classification dataset for the fine-tuning"
      ],
      "metadata": {
        "id": "9qLt6zAl3B2O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!kaggle datasets download navoneel/brain-mri-images-for-brain-tumor-detection"
      ],
      "metadata": {
        "id": "kg6FTYKX278Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c67a5227-1fde-49f3-e21c-4b28754caa0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading brain-mri-images-for-brain-tumor-detection.zip to /content\n",
            " 99% 15.0M/15.1M [00:00<00:00, 25.1MB/s]\n",
            "100% 15.1M/15.1M [00:00<00:00, 15.9MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip -qq brain-mri-images-for-brain-tumor-detection.zip"
      ],
      "metadata": {
        "id": "dTFVtGswXW7N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dataset creation"
      ],
      "metadata": {
        "id": "8KMLX4NH3xlk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set the path to the directory containing the images\n",
        "data_dir = '/content'\n",
        "\n",
        "# Get a list of all the image filenames in the directories\n",
        "yes_files = os.listdir(os.path.join(data_dir, 'yes'))\n",
        "no_files = os.listdir(os.path.join(data_dir, 'no'))\n",
        "\n",
        "# Create a list of dictionaries, where each dictionary contains the image filename, its path, and its label\n",
        "data_list = []\n",
        "for filename in yes_files:\n",
        "    data_list.append({'path': os.path.join(data_dir, 'yes', filename), 'label': 'yes'})\n",
        "for filename in no_files:\n",
        "    data_list.append({'path': os.path.join(data_dir, 'no', filename), 'label': 'no'})\n",
        "\n",
        "# Create a DataFrame from the list of dictionaries\n",
        "df = pd.DataFrame(data_list).sample(frac=1, random_state=42)\n",
        "\n",
        "df.head()"
      ],
      "metadata": {
        "id": "-pNvPP-P276D",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "0f043dd7-4170-404c-b4cc-2daedf6610db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                      path label\n",
              "208  /content/no/46 no.jpg    no\n",
              "6      /content/yes/Y4.jpg   yes\n",
              "79    /content/yes/Y34.jpg   yes\n",
              "204    /content/no/N16.jpg    no\n",
              "117  /content/yes/Y168.jpg   yes"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-350f49e7-cba6-434a-9632-4c7204498ee5\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>path</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>208</th>\n",
              "      <td>/content/no/46 no.jpg</td>\n",
              "      <td>no</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>/content/yes/Y4.jpg</td>\n",
              "      <td>yes</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>79</th>\n",
              "      <td>/content/yes/Y34.jpg</td>\n",
              "      <td>yes</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>204</th>\n",
              "      <td>/content/no/N16.jpg</td>\n",
              "      <td>no</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>117</th>\n",
              "      <td>/content/yes/Y168.jpg</td>\n",
              "      <td>yes</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-350f49e7-cba6-434a-9632-4c7204498ee5')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-350f49e7-cba6-434a-9632-4c7204498ee5 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-350f49e7-cba6-434a-9632-4c7204498ee5');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_df=df[:200]\n",
        "val_df=df[200:253]"
      ],
      "metadata": {
        "id": "_6TqTxEw273s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "datagen = ImageDataGenerator()\n",
        "\n",
        "train_ds = datagen.flow_from_dataframe(\n",
        "    dataframe=train_df,\n",
        "    x_col=\"path\",\n",
        "    y_col=\"label\",\n",
        "    target_size=(224, 224),\n",
        "    batch_size=4,\n",
        "    class_mode='binary'\n",
        ")\n",
        "\n",
        "val_ds = datagen.flow_from_dataframe(\n",
        "    dataframe=val_df,\n",
        "    x_col=\"path\",\n",
        "    y_col=\"label\",\n",
        "    target_size=(224, 224),\n",
        "    batch_size=4,\n",
        "    class_mode='binary'\n",
        ")"
      ],
      "metadata": {
        "id": "JecUUSzg271P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "623516d1-87d4-4782-a8d1-fe275de7f2c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 200 validated image filenames belonging to 2 classes.\n",
            "Found 53 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fine Tuning"
      ],
      "metadata": {
        "id": "CKhoOcnd33CF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For the task I fine tuned ResNet50 on the new dataset\n"
      ],
      "metadata": {
        "id": "IcI58QYXWGhE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# load pre-trained ResNet50 model\n",
        "base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
        "\n",
        "# add new classification layer\n",
        "# After many trials we obtained the best results with this classification head\n",
        "base = base_model.output\n",
        "gp = GlobalAveragePooling2D()(base)\n",
        "dense_1 = Dense(1024, activation='relu')(gp)\n",
        "dense_2 = Dense(512, activation='relu')(dense_1)\n",
        "predictions = Dense(1, activation='sigmoid')(dense_2)"
      ],
      "metadata": {
        "id": "iQwnETuc31hM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8bc50fd7-7a28-4779-f9c6-6a51a2276230"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "94765736/94765736 [==============================] - 3s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model(inputs=base_model.input, outputs=predictions)\n",
        "\n",
        "# freeze ResNet50 layers to prevent re-training\n",
        "for layer in base_model.layers:\n",
        "    layer.trainable = False"
      ],
      "metadata": {
        "id": "vpJlM-m631fK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_callbacks = [\n",
        "    tf.keras.callbacks.EarlyStopping(patience=3),\n",
        "]"
      ],
      "metadata": {
        "id": "KBoawsgg31c0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer=keras.optimizers.Adam(),\n",
        "              loss=keras.losses.BinaryCrossentropy(from_logits=True),\n",
        "              metrics=[keras.metrics.BinaryAccuracy()])"
      ],
      "metadata": {
        "id": "W0LemRr831as"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(train_ds, epochs=15,\n",
        "          callbacks=my_callbacks, \n",
        "          validation_data=val_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwrma9VJaRJi",
        "outputId": "e58228ef-0da0-4235-ef5f-b61578fe51be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/backend.py:5703: UserWarning: \"`binary_crossentropy` received `from_logits=True`, but the `output` argument was produced by a Sigmoid activation and thus does not represent logits. Was this intended?\n",
            "  output, from_logits = _get_logits(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50/50 [==============================] - 9s 76ms/step - loss: 0.9637 - binary_accuracy: 0.6700 - val_loss: 0.5306 - val_binary_accuracy: 0.7170\n",
            "Epoch 2/15\n",
            "50/50 [==============================] - 2s 49ms/step - loss: 0.2996 - binary_accuracy: 0.8750 - val_loss: 0.3321 - val_binary_accuracy: 0.8868\n",
            "Epoch 3/15\n",
            "50/50 [==============================] - 3s 55ms/step - loss: 0.2317 - binary_accuracy: 0.8950 - val_loss: 0.6761 - val_binary_accuracy: 0.7547\n",
            "Epoch 4/15\n",
            "50/50 [==============================] - 3s 54ms/step - loss: 0.1449 - binary_accuracy: 0.9350 - val_loss: 0.4143 - val_binary_accuracy: 0.8868\n",
            "Epoch 5/15\n",
            "50/50 [==============================] - 2s 32ms/step - loss: 0.0946 - binary_accuracy: 0.9600 - val_loss: 0.3775 - val_binary_accuracy: 0.9245\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f39f90a8640>"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Save the model"
      ],
      "metadata": {
        "id": "sFGqW4kHXrIn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Mount Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# Save the model to Google Drive\n",
        "#model.save('/content/drive/MyDrive/ML4CV_models/brain_binary.h5')"
      ],
      "metadata": {
        "id": "1tSqhwrz31VP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Grad-CAM"
      ],
      "metadata": {
        "id": "wxCbP_ZEYIMU"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m3LkOsHWL0uB"
      },
      "source": [
        "## Import of the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yUCkaschqlp2"
      },
      "source": [
        "The model has been already fine tuned on Brain Tumore classification and can be loaded throught the following commands"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zQoliU1UL0TB",
        "outputId": "8aa99401-d7d1-4d04-de60-b873b16fa536"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1TMSBaroQmTO3L9l8tiDHEkSfjN8mrw8K\n",
            "To: /content/brain_binary.h5\n",
            "100% 126M/126M [00:01<00:00, 103MB/s]\n"
          ]
        }
      ],
      "source": [
        "!gdown 1TMSBaroQmTO3L9l8tiDHEkSfjN8mrw8K"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QjgQzDzKNmfa"
      },
      "outputs": [],
      "source": [
        "model_path='/content/brain_binary.h5'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EJnpPlAnjVTh"
      },
      "outputs": [],
      "source": [
        "model = load_model(model_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Hsq1vKNJs4pp"
      },
      "outputs": [],
      "source": [
        "#model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m43bMBjbrM1I"
      },
      "source": [
        "You can apply Grad-CAM on any CNN as long as it has been implemented using keras."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wO0IK2P9sE-X"
      },
      "source": [
        "For this experiment we will use a model for binary classification but feel free to speriment with different tasks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q9GKt9CYxIyQ"
      },
      "source": [
        "## Grad-CAM application"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GQhwr61V-K__",
        "outputId": "9b4467ee-3275-4fd0-e38c-57bdf4e9dbfd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1Ws4BUtOelM-E3X-BqTDejN3LzBU0AMtK\n",
            "To: /content/brain_center.jpeg\n",
            "\r  0% 0.00/26.8k [00:00<?, ?B/s]\r100% 26.8k/26.8k [00:00<00:00, 54.8MB/s]\n"
          ]
        }
      ],
      "source": [
        "!gdown 1Ws4BUtOelM-E3X-BqTDejN3LzBU0AMtK"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "id": "RWQ8AVYgjqlx",
        "outputId": "b9e13f2d-68a9-4ec6-d69e-297835006fd0"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "/9j/4AAQSkZJRgABAQEAYABgAAD/4RD+RXhpZgAATU0AKgAAAAgABAE7AAIAAAARAAAISodpAAQAAAABAAAIXJydAAEAAAAiAAAQ1OocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtpbm5hciBDaG93ZGh1cnkAAAAFkAMAAgAAABQAABCqkAQAAgAAABQAABC+kpEAAgAAAAM4MQAAkpIAAgAAAAM4MQAA6hwABwAACAwAAAieAAAAABzqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjAxODoxMToyNSAwMDoyNTo1MwAyMDE4OjExOjI1IDAwOjI1OjUzAAAASwBpAG4AbgBhAHIAIABDAGgAbwB3AGQAaAB1AHIAeQAAAP/hCyNodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkJz8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIj48cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIi8+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRlRGF0ZT4yMDE4LTExLTI1VDAwOjI1OjUzLjgwNTwveG1wOkNyZWF0ZURhdGU+PC9yZGY6RGVzY3JpcHRpb24+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iPjxkYzpjcmVhdG9yPjxyZGY6U2VxIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpsaT5LaW5uYXIgQ2hvd2RodXJ5PC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIAVYBEQMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APF/iF/yU3xP/wBha6/9GtXOV0fxD/5Kd4n/AOwtdf8Ao1q5umIWiiigAooopAFA96DS8UAFA5oA4pwXjk4x+tADcVLBazXDbYYy59BWronhy71mRHCGG0LbWmx0HeurtLVdKSSw0a2Wfb/rb6TA2Z7/AIUAcxa+Gj9miutUvIrKBnw6s3zgeoFW54/DdvI8WnWl5qLkDy5MHGfp3q7fLoGkXiyahJLrt8w3gBsRA9lNLD46uYjIljYW9muOkXVD60DLmi2+u4jtodBtbNLg7PtFygGzP8XPTFXv+Ed8WNLc2KarpqQwjeZ0kX5z1wP5VxV/4p1nUG8rUNTluom4bJ6isyWfbJ/o0smwdiaAO7lt/FmryR/btWt7byR5YCSDkepHeop/DupMVefxRCqDrtkwVH0BrhPPl3bvNfd65NMZi/JPNAj2CzsPAGkQ29zNr9xc6pjMj7+Cv51k67pWl/a31DwN4ka4cLult5jzn0BJ5rzZQnmANnb3q+sMEcQkglZJlOQRQM7S30jxXc24kYWMjTDKwsy7vriodSj061ZtP8Y6JJbXygNFc2Ryrr3HHWuMTUL1LlpoLuXeo+/u7Vp2/jDVIoYY7hlulgJZPNGSMnmgC3/Yejatc/8AEl1P7JDty0V3ww985rL1fw/eaW2fLMsGMiaMblP1rUfWdK1q8Mms6dFablwJLfg5rZstG1OHSyfDetQ38Eh3PYP9/HofrQB5820qoUc9z60hA2jB59K7D7BpF/ePYavbHQdQxkE/cJ9K57UNHutLvGgnXjPySAcMPWgRnkYbmkqUYDN5hyccVH9aYBSUuKSkAUUUUAFdt8HP+Sx+Gv8Ar8H/AKC1cTXa/Bz/AJLJ4Z/6/B/6C1AH3HRS0UAfBPxC/wCSneJ/+wtdf+jWrnK6L4h/8lO8T/8AYWuv/RrVztABRRiimAUtJjigUgCnBeAT0zQAu0ljz2FWLCzl1C7jtYRlpW2r7UARxwPczrHbxlnb7qjvXoXhXwRYLZR6n4icsS2IrbOCfrS6f4e/sFVefb59uCzE+nWs7X9ejhtRBDPvuWbeGH/LPJoGdH4q8QWGieTb2MUSbY/+PVT3z39q4q81DUdRWS4hkMVoR84ThU9cHvUumwQSk614ikWe2gl3GIH57oj+EHsKbq2uy61N9i03TlsraT5YbZB90ep9aAMOW5XaqW6nfuyXIyXP9Knsobu7nFo2Ylmb5nZOldVo/huzsYRNd/vrxSWH91Pwq+hRgxtoVbzDhmIzj6UAcZ/YsSXksc92HEK7j5Yzn29qiUWLyMba0cogyWdjXcxWen2iyRRKskjAvI5HQ+lQvYRjR5w8IJlzs8sYxQBytvE1xiRIEjgIwAQCaltdEtLpZGmuDCy9Vxz+FSolxZyhokDqnLA9FFWZNHuNTw0LeXI4Lbx0A70Acxd2ptpPvb48/LIB1qNtqsEV8qepBrtvDlvDETDqNmNQsxIcc4Oa6Sz0DQ75Vt4tJeAFmYksM4oA8mjhkeURR5zIcD3q6NBvQD5yiLAyu7+Kuq1K5ju5X0zSYIvNhkwrhPT3rStLSfU7dY9eaNGiGFKLg0AecPFcWcgLxkAHjIyDUtpfvaMGt55IiTlwpwCa7TV9mmp5IjW8hlO0R4+Ye9c1f6Xpq3UaWl2yySY3QshJQn3oAuy64mvwi21lVZgMRXWMGM+hPpTtNlurCVFlC6jp0ykEnkqP6Vlalp/9lulsj+ZI4y2BwRTdPeeSH7Lby/MTvC5xtxz+OaAN3UPB8clidX8Olr2wz+9tsfvYvX6j3rlpUHlt5f8Aqg2AGHzL9a7Dw/4iuBqiLbEW9wn8A4Vz6EVs6/4YsfFAnutGxba9GoafTx92YdyvvigR5cQRSYqeWF4ZHSdTHIjFWjYYKmocFcHselACUtHrR0oASu2+Dv8AyWPw1/1+D/0Fq4n6123wdH/F4/DPp9sH/oLUDR9x4opcUUxHwP8AEP8A5Kd4n/7C11/6Naudro/iF/yU7xP/ANha6/8ARrVzlIAoopRQADrzThj7xIOO3rSFcKCc8jPSpYox9phG0sGI49aYDrKzm1G9itrSMyTyttVR0r0fRvD6eHtPMt7tE8fzeYOoPoKteFNHttO0/wC2TERSMpd3I5UdMD3rm/GPiSO+m+x2m5IeFYZ/XNIY3xH4tnvlubNV5kwCy9QtYUcUa6TG8kdu7LJwwc+Y3P3dtMgtcxyec3ltEhZ5d2dy9do96vaLa2yK+q3bFFjJEce3OeMZoAu6ZoOp6pex3sVmwRG+SBh8sYHc/wA6dJczadqMsKbVugw3OgyAD2qZNTu7myazsrmRYHyJJc4J9alSyKW6xQ4kXGXkbliaANaxV7yFjsP2gA9RwwqmYri2kljhJC9XYD7pNT2d3KbdbWJfLVDlpc8mpSVSHZvOyQksMcmgCravHaxi2OZZZzzIaurDMBslBwO46AU2C3jaIuT+73YXHXNXpI8WwgRu2WJoAy3solkKqCYyvJ/ve1PMKWtvGUbY7ggj0FX5b2KKOK1TaxPJOOlZV8vnQyzu4CoQqL3PrQBVmt2dRPpsjRiEfMo7mtS1vr+/hNwX8ho12bl9KzbE+ZeMgmEURGMEZya1INsLNDGCUAO5s8GgCvp+mG1uH+yru8w73mbuafMTFefaBw3TZ61p6XII1d35X7qIOKhe0YTNKfnZ8/LnpQBQtZFXVPtYjDykYKkZC0ken21nJcX0tv5lxKTksOFFW7aH7Msn94noRVhJFKNDJ8ysPm9qAOUufD+6OS9SbzoCdw9Uz2rmrm3bT5BtBOTmKb0+tekxxJa4BjO0jKDswrmLqK3uEkiUFo2yRx900AUtOSz1eDy0drTVF+7KThZSOwPrXSeD5LeTWLWS5vfs+rx7hHMxwGx61wcYaOc7CyTwksvH38enpST3f2hSzM0cqYCADn3OaAPXvHHhWz1+zvdctSsOvWKh7i2QZW4QYG4e+D6dq8eYIzNuUqrnHI+4fSvVPCmsJfQ6frMoZp9Nj8q5iBz58Y4GfzrmviR4bj0rxILzTkK2GojzI1x/qyRyPzoA4rafMEb8YOKSQru+XpSyoUc8klTgn1NND4bJGfrTEA5U12nwdP8AxePw1/1+D/0Fq4pm3Hpj6V2vwd/5LH4a/wCvwf8AoLUDPuSikxRSJPgn4hf8lN8T5/6C11/6NaucroviHz8TvE//AGFrr/0a1c9QMOlOAO1QV/EU361MmxVUsGzkk46H0oAkhDvdqM8gZw/TPoa1/Ddm0uqx3LplVkOxB0Ld8D2FZXmO9sLcNueZt5UDnPQDNeh+FbH+zNAOqz4jW3jbYpP8XRv50DKvi7WxHZmztwrBwFXHUGuEVTHMDIu6XPCtyCTV3W76G81SS4t2YdlqnCHlmMsjfcGckdTQBoW8D3Xk6WsQSSRt0mP8+ldatrHDtsl/fBEwwI5FVPDNr5Glvr8oY3IYrGhHXtWxBtNu93MhWZuTk4xmgDCkhWGQwxAoJDyR2q4u/YLZTtyPv9zVlrVpLczgA+uR0oig8siRnDMfuj0oAjGQwVeAi8g9zVn5ri32OCjtwmKngt18lpWXLN0NWgyPsZ1ww6HPFAFUWz20kSImFUZlNPu2WS1aWIgMeAKsNKYxI8bE+dxtIpvklpI8D5P4qAOfu5DE6RRqdx5yO9N8mWSSNZWC7+uP4RW5Paxec8zcFFynNUp9qTpEzgsy7uBmgDPeBmkzbncucbiP1rX0tfLtWt3/AHjA5DGqsbEP8w27V6Zq5AGjj81QTjjGOtAE4LlgyxrhTgbe5qxD++aVhldgG7iq8ayQo0qnEY6j3qz52NMMpOwyHBTu1AFG6llkUKF2bT/rV702CNTh2kY7Qc8dake2CsoYsjMuVU96ljjSJRayjLSZOc0AZmo3JaJZlmKlDgL2xWTDaTXcZ+zSqqE5dlNa91ZOJJIA2YmGBkdPxqLSbBrS6NpKP3T8hwetACX2j2x0tbuLO6IY83HzKfWuL1LS7m1kWRzvhmOVkX+tekFBBIwc7oXJjKngD3rmNUs2LTWJJCD5kwc89qAMzwbrb6F4gjZv+PWcmKZD3B7165NYJ4o8Kan4aHz6gsf2iwdud4HzYB/SvBiHhlIfl1bbtIrtfDPiGdbOGSIsNU0c+fb/ADHMqjllP4GgRxs9vPZXk1peRtFLGxSRWGCpBqr3r0D4jxnxALbxrAuE1FVW5VR/q5QMH+QrgSM/U9KADOce1dp8HP8Aksfhr/r8H/oLVxZI4/Ku0+Dv/JZPDP8A1+D/ANBagZ9x0UYooEfBPxC4+Jvif/sLXX/o1q5yuj+IR/4ud4n/AOwtdf8Ao1q5ygBysQoU/dzzU6hREFD7Wbkg+naoB1644yKmVWcgFCXfAQj1oA1tDtZZ7wXxx5cRwp9ZcfKK2/FOqvbacunJlWdRI5z/ABHqK0fD+gNHpgu5Q32SxBeTjG+XqP5iuO1e5jutfdkHmQ79wXP50DM5o2jVS335RkD0Fauj6c+p6pa2YcKu8Fzjt1qp5sE955sn7uM8AZ+6K7rTrG30TQFkhPm3N1kxN6A0AW73yvt6R27bIbUBdo+6T1qC6kFzcLAJPlYhi/YY5xVczPAuwEFz8xXFOiZVsjIvzSSnDA8baALaSJJeGYyboU4YL3qwLaB3aZmCDqiiqMax2yRBRlB8zr61Oj72NwFKL0CmgC7lmuFjQr8oyQR0FTeXhfMwBEvJ5qlCkjtsDffPPFW7m3htmVZH8yQfwg0AVlTNyJRuEatkc8VP5qu+6MlSOx/iqO4ZRCdsuIox8y46msxpxlfLfKN+YoAtXUbyQOJMBQOvpWNe6fcG2klglO8Lyo+9itJZzEdsbh1f+E9c043FwLxpraVIpmADkjIAHtQBmaHE0i5nZ84yVdTxW5cSStCUtwAMYIqxLrl1eaf5FxDE0udqzJwfyrLuZWVlL7vPGNu1cj8aAJWmlURRNu2Zy4BrRJSWZNvMSAfnVDy2kZS5CFuSfUVfUQtiJQUXGSepJoAW4d7xfMIwbc/KPUVQd2mlEjFht961XnM0cayEbUGF5+99ay76J5CpePGeiigCz9qja1O4Da3GT2pkrgrCkYX5T97FV4YJmHIyqjoKtR2m6ISyvtboi96AKuozGRQo+Yr1Wqd3Y3N/HGtmhFztLAN/FjsK0r22lWPLjcgXt1Y1BEhSztZjN5Z38pj7vNAHnV9BdmY3VzCY383Yyd9wqxHqMlnqtnrAiyQwLIOAccY/ECrXimaSTXrppSc4ATA/Ws+GdJIJIowQVXeOO4oA9WsJE1bQdR0s2whsdWtvtEMnGIZSclR78V5Nd6ebG/e1lcN5T7SwHUGu48H6up0+10KVdwWU3jy555424qj49082Ooy+UhMMigg49qAOJmTypGj64PX1rsvg7/yWPw1/1+D/ANBauQlR2hjkKkKBtziuv+DvPxj8M/8AX4P/AEFqAPuPNFLj2FFAj4I+IQ/4ud4n/wCwtdf+jWrne1dJ8Qif+Fl+J17HV7r/ANGtXN5555pgSqymHaI8kHcze3pW/wCGrd7rUjqEg2rbJ8ox8rZ+XH61goryFTHzJIdiqOp7V6NpFqNNsoLeVV8rT0NzNJn7zsPu/hxSAj8Wa9JYaBH4fhYB3QNIQfU5/lXCrbiIKGfLynqOw71bvLh769udQnyZCxIB9BxUOm25kdp8bichfqaBmz4bsYrrxZBI0O+xg5kOOOB0roJ7j7brV1dIoitY1CQoD0xTrGL+yvD/ANkj/wBfdA5J6gk05NP+zWKozjfyzUARbpZIo2aIeYh7d6sQGOS6Hmp5fckdqdBa7oxlsNJyWHagW0vmBM5hB5OKALckEU7fKDzwMUjQP5qog3RoATQjLGhZWz6YqRN0cZYHMkvGKAEaUxqsjLgD5VxQ0ohh+ZAzSdW9Ke0JyqS5AU5ZvWmSJHJG5ibmP7tAEEphSSOFeYpPmZj2NZ/+qMrGP5FcDI9zirk0qGMKY97gZ+tVBdBYyzRH5iMqenBoAs28cUly8KkLtTKHHU0k1rFBFMzS/v1GdmOtR7laZ7kJsdOduaqT3H2m4acRhW24Bz6UAQC88yTCna0YzV2znhmgdncrJz+NYiM8e9if3p5/CrcbyGJI1VgWOSSKANeONigkT7q9NxqzbEiUzSygk4GAKpRNHIxRmwEHOO9WIZo/OwqcAZGT1NAGkU7Yx82QaI+MRA7pD1J7VA+oTldxVVXGMUsZwwmUHe3Y0AWDEDuTeFQHlh1zUNvJK8rLlTt7nriqtw5k3ZBXdyAOmaktmVWTdkMByaAJklKGTcchTwT3NV5vmnuoVxiSMuCexAzxTL+8Z4t0UGcHoTjNZ0Un+kH9zkqeRu6ZoAxNZt/tEUN9v3h18p0C9CM8/wAq5yyZrfUlZBkqSAD78V6Nc6VElpKwlUTytlIfQVwFxGn9vGFs7PNAbH60AbOhJ9iuhPcNhrmXy+O3eur8cab5vh2C5WVucVyQME+oziIGKK1XdGT1J6ZrrNREl58MVPn7xErEgjkfNQB5oxc27wg5VGLda6z4On/i8fhn/r8H/oLVyCKNxUE4ZcD611/wdH/F4vDX/X4P/QWpgfclFGaKQj4I+IWP+Fm+J8/9Ba6/9GtXOjpiuj+IIz8TvE/b/ibXX/o1q55O+OvRfc0wNvQbJmdtQIJhgO1Bjkv1FdTrso0zwvFp/LvcN5sshPPzHOP5VL4V06SKOwtZ4j5YQ3Mwx0OTjP4Vn+KrtNR1otbSKtvOdmz+7tGaQzlbjLOIFBLHlSD3rZ8PWbTatA8twqQWX7yQbepqlZ2Mss13eqreXGjbT6sOgrpbHTzH4VXzArS3J6jqOehoAtreR6rqct0lwotLfgnHPFT2iC73XIYeUGO0E8sKzJdPGba2ig8kEfvVHRuetW1hZLoWUUiqqgcjpQBrAFmDQ4DA/cpZZ5JWAIRD0aPFUo7Yhd/mksvUrViOJRIjzOCvU+tAEqct5duFwOXDdqcjLKxZ4ypQ8n1o3xNJ5ix4TPYdaS4lkkhH7sgeg7igAuJ95bCM6HrzSRqCoaLgAfdPWnpJ848lWVB2PelWEENJyufTtQBRuodxWXPzZ+6vaq8ULCJ3JJXOWyOlaUaKHyDjnhjVK+ldJmBfII5A70AUJ5MuFgbJYY5q9DpU+oQ7FUbUHLL61JpGmfa7xTkIWIVfzr2nwT4Mt7K1N3eOu9Tu2EcHFAHlNr8PrkoszgkY4G2su90aazkZpQVEQz93rX0gZbaaTfhIYem1QOtZupeFNP12IsrYZO2Ac0AfNke9FeU4QvxhhT1dZYtrZwncd667xT4VubbVJMwFlVfk2jArkVZ45WTySqr3oAm3jK43YXnGa0ra4dnRGwUPI46Vk25UOXL4FW4ZCCSr8noPSgC3chJWY7tirUKZ8hZGIIJwAOpFTGMyfKMPxljVSLc6l1wVjPamBZuLSSWNpIm+VV4XPNNNsGt4Tv8ALMuQRinLKymPeFJbqPapI5zskBC8H5KQEKwqkwZxvUDZvzXBeJbdbbVCEBRlBOfWu3niOPLUtsf5hj+E1geI9LM1hb3pmBZCfMU+gNAGPHIgt7JFx58igt7D3rtvD0Mcvh3VbeY7nMZ24PA6V5wzCGMy5JlZyA3oK7vwcVFlby3BbbOkilh65OKAOCnTy9QeMjG1yK634QY/4XN4bx/z+j/0FqwPEECw6vNsztDZyexrofhIAPjT4b29Ptg/9BagD7gooooEfBPxC/5KZ4n/AOwtdf8Ao1qytHsTqOs2tlvCea/X04z/AErV+IfHxM8Tf9he6/8ARrVJ4PtN01zdkFnSLEJ/2ulAHZvdSxaZe3CH55X+y5A4AwBn9K429XabmUjdFAioh6fMeCa6e1vDbeG4opwVjhDXDk/xMG6Vy2qh4NPjttyut5KZ8L1UE5wfyoGTWbvaWraUgLsZhKrDuMA4roI7kSzWaFuY+Hi6E/hVPwxZLHc/b4pRK+0oqkfd4p+pQRXd9JebWtplG0yDoT0oA04LgyalLOmAkf8ACx/SrFlIHuHnIGTkbcVz9tZyNZM/msX5/eDoa1NOvBb2PzqzuD95TgUAX12rbSM4xzgKOtQoN48vGRTnlWbErgq56D2qIqzXIELhQQMk0AaEEexV2cgfw01ojI7yM5Gz+Gq28IrRliX6rjvUwJaIbDtOPm3UAOt8m28zOBuxz1qRiywuQTjrUGWjCE/MpPQCknmKSrgttkH4UAOjwYxKgG0dVLVnzlnMmVzvGB7Vdhw6sUVl2ncc9CKj86N7go6FEfCgigC54RtHk1GFkQsquASa9wkkNppZzGxcr1BrgvAlpCnmpKj5Vsq3Y121/cx28ke2QSRsMNz92gCt9suoLMKkatHJyeeQfpWrZSzW1gs5dVdmxsPX61k/bIL+ZLSzLBlGd9WLZFlvt00m1o/l570AbmoWEOr2YNwqh14zjrxXlXjTwUsH7+JwCMnAXrXqEL+ZcGMliNvJHQVT1jTRcWwXzMxAHcxHNAHzc4ZJpFCFSOMMKkB88KpwhQcjPWt7xhYrBdtFnIDZDAVzQkVpF4y2CN3qKANG0ZVjYRFskdM0+S383BB2HuB3qlBJskXb8rdCGrRt4TKTN5gDDqCKAGrD5UyuOVxt5qCdfJkOxd5JyQD0qeTcoKNyobdkVCLlvN3GPY208EdRQBIlwWgBXlUbcR61n6nE1xb6ksEeEeMFFPsOat28gW0IYAHJJ+lSxOEuo2lDM2CAAe1AHmKwkXUW9eM7WU9jXa+Db6OBbLzI/MiFx5Tc8As1c/4kg+yaq8yrhDIWx9RVjR5HtfDeooMiXelwn0U5oAd8QYZLTxfeQEDawVgAOACM1b+D/Pxi8Me93/7K1S+P1+2W+jauvIuLZAx9+af8JUVPjB4cA/hv1GfqjGgD7byKKMUUAfBPxCI/4Wd4n3c/8Ta6/wDRrV1HhmeHRvC1hcTIZXW4LtGAPmBPSuc8bW5uvix4igXJMmsXI/8AIrV1NzpwtLfToYMt9gG+TjruGB+poApeMtQi1fXLyfSVa209SsAgYdMqMnj3NcVEnkanzJuEQJBb0x0rqdembTrG0gI3XMsZab2JJ/piovDGm6dfafNd6hKRch8RRY4YgigDc8NXDQeFRIgXdOS7H05qd1QaWibstNJn9c027hWXVIWI8mFMIIlGAw9alU+VqW9ACqLgKRQBAbcxTbRkgr8wxxTGzEpEYO0+1XWn8pmyN4c5J9BRGFaORY+GAyuTxQBVgndZFx87KcEn0q6BH5JVE+bOSxqh5kYmX7VnB4YpxzVpHRrhIYydpHGaAHrGYSjYyWbkelSP80ytuwo6rTkx8wU5KDPNKrkH96BluAAKAJv+WDOD8q9KhmRj+8DBlA3U5UXzDEN25hjaKhQbF2Oe/NADwzXCykjgDbzTdOge6vo7dPl+cDB9PWllljjjYAt8/wAufSuq8FWSKm+RN0ofIYjtQBvLOPC2nfNmUbS3p+FcRL4ikvLySadtkchwIg3Ndvrxjv4zZhWwy4DYzgmvPtW8HXLstwrfMvAIU/hQB6h4WnihhWGLajzDK7u1dFeSCC1ktxGJJpBw4HQ15p4WtdXns/KZAiQHmRic11+gXBjkdw5nkRh9BQBo6fdXKv8AZ4+JCOSxxk+lbcckj27LcqoZVJ+U5BqnNpcnmLcNIuGO8YHSq11eTQW8kSrv3fxCgDzL4hCNZWuEH3uCK868wGDyIl/eE5z6V3HjiR5EEYGMnJB61w6ySqpkVFI6bcc0AWIGI2oSD/ePpV9YiERDIAX+62elUoGEjKGQCRulXcBVIYZcDj0oAkkjLyGMS7hGuSQODTsK/ltnDtwAfyqmX2WT+Wx3d8cU9Ukaa33EDcO3agCSa2ZZJS2GK8fL0NUQqx3kSyF4wyls1pCDyp5UOcdjmqt4WjEcSursEZjntigDF8TRQz6PNKisGjAYEjqM1zmkMbrVpPNyqtbMhH1XFdD4kLvAkm8Ik8CqY/XnrWJCE/tGOPdtWZ1jyOwNAHW3+ltN8H7dhgi2uGUyN2AP/wBeqXwlA/4W74XIbduvQfyVq09jN8LdS00ux+z3cjZz1HFZ/wAJbcx/Fjwmcji7I/8AHWNAH2tz/eoo/D9KKBHxfe6eLz4zeJGZwv8AxOLlR9TK1X57+QavdW0aHEuyJiT12kHirLwiL4heLrqf/VLqF7IOOciVhVWzgIjtp3kBCGSZiRzgg4FAznPGV6s3iu+ulwo8kRhPfaBmq3heWN5rW0lT+J33j1xWXqdy07CN+ZGYtu9Rk1paNpb2qzXrDelugfg880AdmZluJopGUssK4JPqKbFiW8km+URoKoWVy8ll9uiX90xIYVo2jwvBtXgyHk44FAELRbk+0KcRq+do70mH83Kqdr9KsMM8D5lHpwKlUCNcEFmPTFABFD5umuhVVZcnnqaSCJJMyYClRwfSpN3y5I5z0z1pm4y5Cr5S9/c0AKjx+S8YUu7nAb0qSOF7WHEhUknOT2pkmyOPbKM8ZytNRF2r5e5lHzZagCzuAQkEFsZLDrUUhURtJtJZiOPSp1ZWtjK0YDHgDNQu5EJaPjg5oALmJLt4o0Rk3cdP1roPD01zp8by71kWNsAMcVzdpcBdQsWckEMBjNa2qXSQXDoqszumVx0oA7WfXmltEl+zxxFP4getOjLXFmWkYAYJx2NcloIuJbdFnBPmtgA84ruNRsBZ6P8AvH5CHPGO1AHA6rrl3pGoebbqWixhl3EKa7jwVrceoQxs0ZhYvyqnOa8yuNPN3fC2M3Dvu9QBXqvgrQ10v7rCUSYGdv3eMUAb+pyNZSRhdsgc5xnpUUOsLHdyIbaPLLgq5/WrOt20PlpbriSYchgelZ2i6bD9sLXCmdxxn+7QBwnxAso4la8DDcx6KOlecRBQ24HBJOM17p8QrJJNIMcfljB5IArw6WMJqTJINxUcEdKAJo3W3YEqGZRxirKR7o/OTIA5ZW71Wsoy6ES/MQelaTrIbPy3cIOuO5FMDOlbftIAUZ+76024nhhTeWACgnIPOfSmLbuVkk65Pye1OCbIowYQXDdD0JpAUW8RW0N9FbsjsXTcWBzioRfXlxH+7ssrcMYxI3VQeK3GlSOU+bax+Y4xkAcVXkDz2/mMxjCg4UetAFCfSzf+HpnmaP7ZYZVE5O8D/wDXXF2+RfWisGQiYA5HTmu+1m4kt/C+nyLtG64O988njvXHSzi+1GxDKEVpgHbPU560AegeHIvO8Oa9p8sqn5XcSN7kVQ+GsMlp8YPDkMgVtl+F3euUY1qeHoUnN7FEMQIGR2P8WMUzwXDInxo0EmMqn9pJg+3ltQB9c8+v6UUfg1FAj5d8TXo01tecwqd2q3SFsdd0zH+tcRFPcQ+G9S1e/GFuFEEEfPGCORmu/wDG8KPrdzAJlQLfzyyn/tq1ebeJNdOoaSLKUO2ydthK4VgKBnMK4uL1jgjedoHoK9AsE/szQRKymaZhtMeOHFcFaTD7YZkUBApOz2FdtZX63drbxD5FX5jk9aAEneKNo4Ud4Vm5MI6KTV22jPlmFXATHDHvUd9DDeSmRhsk24Uheg9apy/abBQzfvlTkAdSKANpSbaEuzq4HAUd6YszZChtu7uelZEetxzQg/ZnGz7ynr+VXYZ1ubhZCp2gZwR90UAaPG5YcKWcfepzq6sqDGU6+9ERRk3BgT/D61GXU3SozMsnY460ASpclpGh2gex6mnIGJYr93+L2qNixm3SR5PqKlwGAKMVHfFAACqSGQozFhhV9KiVtr56xg5IPeppEy6HeU56+tNuI9sTI3z8feoAr3Mw83z9gwmGQDpx2rorfX7KezUTW22QjCtx1rnJUVljXbxtwx96ZBuEDRtzGpPGKAO78NDzbjIBMhkG3HRa7zV7P7dpkhc7nZNpHvivO/AzMWQBCP3g5BzmvSrggyKqDZ6mgDgYNAh012M26WXG5cL09q7HSrklUlU7CBt8sn9aW9QNbN8oOwctjrXLQ2V2uuRpBNwxBLEnigDrr2IyPFNGSjxn5j/eq1bRPYRGRpY8yAluegqtfM3kLABlSv7xgc5NcJ4g8Wf2XDJZ20O44++Xx+lADPH/AIntzbPbWcTtgYZt3JrzWxeUwO5Q5YnluTSPLNfai00r5OM7SeKtJGRIqrw5HUHigCxbb7fZiMgsMl6txwyS2rbvkkY8M1Q2q4mCSs0hHY8CrLHCNuO8n7oz92gCmtqUm+aXJXqAOtSyOsEQ3KMFs+9OKny/3S81DNayP+9jkwy8kGgBm4z3LNkIhX5TjvS5YQFpjnGcJ60kEhKGSUHaD0NJuDKzliGCMR9KYFLXTDN4T8h0+ZpiUI/hrhbeBv7VgiXcT5y7QeldT4kvT/YEKoh27hz3Jz1rmBO8d5BOpwfMVgfTFID0HwzcNFpuowYDOLhicdeSK29Bjkg+N3htWJTddoSh6fcauX8KXKQXOpmcFlmTfkepIrp/D88r/HDw9lS0ZvI8Fuq/u2oA+qufU/lRRk+h/KikB8tfEnbbeLL6Q4ObyVHX0Bc15z4rkiP2Ty9oVGIG0Y7V6H8TLgxeMNTjltxKZ7uRVP8AdO8gGvKtaTN3OqAkxouR6H1pgSeHbSOUiV1yNxXGOtdY9tbi6j8uNlb+72FZHhO1kubONYojtBJeTsvNdBNMRf8A2aMAqig+aO9ACJA6XplmOY842jqBVtim0spXanIyKoQXZeRlG1mU45PWrivHKuGGOfmI7UAULu2aW6R7faC4G3sM+9SQxvcJHcH5ZYXKyAHhsVcR1d1KruVfusRimC1lU7WcBWbd160APjGb392gVMdfwqZyTy23ap4IHNNiIiYqyhRnt3oJbcRGfkYdKACMgXG9XJH9w96Vp/mPlgKufmB60gGwcqenyv6UjFTIo43EfeHegCdGRnXZuCgfxU3zJGErKAPTPenEszj5lCjg02QbJ0AbcjkCgCIRiW3jO4hgcFQetVbsmG4cruVMDcCetaDo8VwRGpCIclhVPUF8yS1kdzsYkbccmgDrfBmspEY42URq74BPrXpYcRW4LSq+7OOM14jp9hJcaXKYmw0NwTu9BXovhbV5LvSTBsLRxAgux5oA6JGRbWQGTJzkg+lDywQNDLbW5zj5ixHzVmWUscsM8eATk4DHk1ZFhHDp7tcYdgMqp7UAGqaklhZTOCN0yEBf7prxPXJJb3WD5yMpXkMOjV0uua2GmaGJMgEhiT0rnL68F0FjUMMDliOtAFVRy2Vz7irMe51BcDb0wvWo4lLMsKj7w5IrRWBY0RX+QP0YdaAJUKxKgRWL4+Xd3pkZ33BYrtKj5l9aY0gCkSZxGevtSht4XywWbsT6UAPNybZi8kY2H7qg1Hu8+Qtu2D0pZJVG5GTLDnjnFBUs6smMupO36UARiPdhmOI89/WmmNFmnnjYE+SwWN+nSozdsp2bSyyttCjsaiV5BPPHLlf3TMM+woAxPE6v/YlmwKhWPzLj+VcuX/fI7DLb1+Xtiup8TfP4Tst3H74nIrm9QUQWECAANjJf1oA7TwtC0jX1whQokSsVcf7QrrLCV2+PnhllI2SXEeQvT/VtXEeEnlWa9XkrNYp0PGdwrvtIcP8AFLwU8aKA10qse5+V6APpzmijPuKKQHyt8Rbo6X421G4uSJQ9zMI09P3jYry7WWMuoXjQsQ00akpjk+terfEKKAeMtSvrhPtEMU8xCAZ5DtxzXlDR3d/q0otFSORhvTnG0HtTA67wPrs1n4e/s5EjMMwbedvzDJpssUyzzBm2WzDCEA5zWZ4eW5l1OHTrCPN15Z3yE4T3Oa6FwsWpeVNdI0kQxInYnHagDGi02NLb90zmUNkPnrV2CcM8SLncpwSe+KufeXzY9ixr19TVQQvL5gA+TqSKALhklkZ3VQq4wRnpSQLNLIUjYOF55aqdvaBVyS3Q/e6GmOsVvdrIykMePk70AbRmzhiuVTrjmmPc7yUiBBboSOlV7e8KfcXahOPxq3tD9B8x7+lADPNYiNWGQPvAd6bIQHyAF3DABHSpFBjfyR95h1oIwzI/L4wDQAkCvErZXeqjP+9U9tKGkVlhO1zxn+GmojhAgyeeT2FOk5kCqyhE67e5oAlnDHLKwb1Ws68eLzImbohzj0q074YOo2sw4H9azpkWW6BUEqjAuw789KANTTLho9NuWj5RpsnBxXpXgeazj02aOWP768EY4zXnNslrY2t1ewM1xGSSYmGNpp2j+I5dP1GK4kVltnIHlKev1oA7+1S3tNYc+b5mDnIGBUnifWEGnO8AbYqHPOCa57UNesQsr4YNKCY1HauM1nX5LxkthvGRjIPAoAoSXJmmkn2nLcKD296hthJJuUnLs3bsKiRSjtGWJOM1dsnVFJCHdnGRQBJa2k0M7fxKeQR2FXfNUK5TL9uf4aIQbchpsjeflC0qhY2fjg+tAESph1IbKD72e9OSTYxfPyDgY7UjzosiEoJAp5A71AzKbg74jHG3Tb60AWGO6LfsO1nILA1EpDXryebhIkwB3OaFkAhEKnBH8R6UZVpPLhC+a3Vj0oAgSOUTQMkgUxyFgpHtU3yrNeSTqWItnOB3OO1IkSxuJbltwjbGE6mmO/2ieeVG2r5TBFPfigDmddleXQdNxEyRsw3bj0rK8Qypst7eNTlEBB9RWt4hLSeFLUL8ohnO9j3PtWBqcitYWca8mJCC3rk0Adb4atJ4dT094WUxahYrCf8AYIOf6frXe2N3G/xa8EW0eCyXQJIxz8riuK8OajGLVLWSMB1sIzGe+SxGRXZ2NrBpvxe8CWCRfv4pg0kpHXcrnH60AfT+2ikwPRvzopAfLvxLvYYPE91YyxkLNcTkNjqPMavJ0lktNamhiLZnGxT/AHRivVfilYT3urfbrTdi01CaJ/M/iBlYk/rXk98W1DxA8Ft8sjsQG/u4GePypgXNOeaLVovs07pGVKgL15966P7MjyIY4wGBwWzyTWDoNk92GnWQq1kTvz/Fj/8AXXSWoFw32lH2ADhaAJobeOFhlcjPJ3f0qf8A1LAo3yg5xt61Fu22pkHzFTz71Ml7HOI8KPk5+tMCtcO5usg/uinK+9QraGaZZI+CD/FWnOY5X80KoPU+1RLcR+Zjpu6kdKQEDKsJlDHcVOTxinQOr7VgYhCMkZqLUVLrKVOSRjC96rWeYI/Nwdq9R3oA2EQOm0KflHLE04Q7ESYEFAc4PU0kVyLmATRIy7vl2nvTt2wFTzuHX+6aAHSzr5ZKKwGMnFUGbz5lMQKRNjIqeVJQkVsjBpG5LZqt5pgugCrFR1HrQBprtW2lWRS7bcJ61QnTylVogVUcuo6mnNeu10rwhgNuCKWcrO6uGdHUcA96AIbWcpDMnzAySc8deKgWRHlZZVZuQFPYVZWRvsjMepcg5qKEqCQ3Gew70AVri4ZQ4TPyjgk9KoIrqcB87uSfSrF1l90XTjr7UltagzcviM8EntQBbgjEq/Jhx1PtVuGHKgqNqMfSnWRUxyRRrsj+6G9TVlo5FdY42BGMnmgBgKs7rtO6PgE1HvVkbbuZtwDZ7VM6DbuEmCDzjvScwsPlJRxkigCPyf3+2NwqZ5OOlPbdErrgMG4DE9Khd3lR2hwMfwGoIDIborLllI55+7QBPhG2qUyU+Y+9RkIsrM3ykjgDtUHm7LllLs7YwFWlW5W4VljRg44JPagBVbfY/aYn+7JtKEc04DuHHlNGTk8YpViZHSV8ANwAPWkVlis7sMnmxohBI96AMLxRJGPDtrGvV5sjjhq57UY18lTsCblAABzt9a19fuorhtN09OFTDk9ueKzdRDG6t9MCgMrDMgH3s0AdP4fNpa6vCSNzLZR9B05rrLWJh+0d4WnLsyzSIwB7YRhXP6T4buJLuPXIJF+z20awyxH7xIOPyrrLdWf43+DJpG+Z51wvoAr0AfT+D60UuRRSA+X/AIh20k8uoXUF60US6jPE0RBwzea3PWvH55ZvDviCV4iDMFyrA/d3D/CvZdfVtXsfEVoigPba7cShm7qszZryLxTCIdSSdSG8w8mmAvhm6vRqjG3bIuM+YM4HNdMI7uO+kXehRRwN2MVx+k3kdpq0T7W2MMAL613smGuoyAP3qAj2oAz4IbgTZZtxL8qCcYrVht1gkScsuM4aMUx5gW2fdyMlsUTiNY1Zg20Lng9aALLt8jbDj1qisoWQoyk+nHGaZa3aTy5X943QJ0xTby58m5Lbg8n/ADxXmgC5CmG5PL9BQ9oYzycq3I46GqS365Vo1dSx5QnpVyC/KMzBDx60AW7eM26rvcPkdRTgpdDHGQoc9TTLaZmbekYYv69qmS6XzGWSPkcD60AMQPb3StjeiR4b3PNQLAmTPOc5OUGOlPBZR8zHDHoDSo2W28hcdDzmgCFtQ8uRwkO75c7h2qFb1ZSJVTeRwamMEkS74mXYOCD3rMuLdUmByybhlVTgZoAvIT9lJfaQzZC55p1khaZtvRuvH3ar2qwWij7PFLLMfvs+MA1dsSY4ZI1fc7HJf0oAinVjCdoHB+8etRI4dj8uUxg8VoO25gqDO0fM1ZpuAY3CcOxwaALdp5lsT5rqyH7qCrRaKSREhBQjkn19qpW6/vVRcEqMknvVlUWRnlIIxwo9DQBGWMc7ps3Fug9KhmdorpFJbBHftVlC6RncMnH3vWhmhcF5GLYHT3oAqmUvL5aYBXgknrRFPGG8vbhFPzn+9TGhVrdplcDccCmiC4aMfZdrFBlwx60AWfJEitLCAiN7c02OEWqN83ycFxjrVCTVo7VQsrEHOGI6A1oIXnWGBnWVZFLEj0oAga9WK4klQFo2XAjNVrG9t7e6ikFszxmYeZE38YzVqW1METTAjAbaFI5FNkYQxNKke828RckHgGgDntTks7zx/PPp9r5USAMIMZyR1rL1GdJfGWY0KAyxgjuOBmrmiXbWkWoa9N0fcicZ+Y1iWMss+s+eRvkO58HvxQB2/hm9kuvFD+HYJ5Abqf5GJ+QdDz+Vdo8bWf7Q3hCwchjBKuWByCdrf41jaPqOjeJp9LtND0uSz1jT1EtzdnaAwGc9OelGjX0l3+0toSNJ5iw3aID6nyzQB9b/AIUUuf8AOaKQHyxBc/aPFnjLS1LF7jUb23U9kZpWwf1rzbWIVXwuLZ3VprC4aNzjljnFdZZaumnfHrxBHOCySavdMOf4hK2Kq+LrCPTfHGqfa4VFrqce6DH3Q5GaYHnsT+UqTryYmGBXc2msQzabFPNuBQZIHSuGETW98UnXChsMK2vD1rZv4jistXneK1lUlCoyMkcZoA6WbVLV2aSB1ld1ykY/hqC1mhvIneSW4W56BSvyr+tMs9Ht7O6uYyyv85CSgdqvQrAp2dC3HSgBfsn2ixdYmIVhhnUfMTmoLHTFspgYmaRz/eH3frWnEI48W6EjcflbFSEiG2YKcyNkZNAEYtA8SsMnaeeOlPe2jURtvyT1XHWqi3TxN5Pm/uycnjr7U9p8tgkFTwBnkUAXzB8sbIQuzkilZf3Jl29D1HaqZkYMsYbYSMjnrU0bs7BD98DkdiKAJxF5kQ2TZPVc1lXkkuSy/Mw9DWgEzIznh0/hzwaiYpGVJGEY5YUAZkF5tt1knDZ3bfLHr61a3M0bSbxtxwPSllaKWZmt49oTnmsXUJJIFco+F7qD1zQBqCSQ2ixb/vPg1fLIFjiXIK9TWbp0LSW8WxsOBuJPNWQsggZ2/es52gjtQBNNdBS6qCWIxkd6HtGKwtkDBySO9JBbGNY/NUFRy2DVwOrh3SPYi8DmgBtofIupLnG/IxsPFLPK8iDHyZbPH8qYshkXaF5HX3FODxPN5jKwSMYC+poAJZTKQB8rheAapLuWN1eJt7dCORV0fPIWI+Y9+mBTTmOQRhtxPIyaAIfs3n2scYiyIzudhTraBHMsjHbGBtqEXDIZvmIJGNq96I9zgRJldp3N7jrQBHe20aWTRSRhjMflbFZVtcnTrr7DdSN5Z5SbP6V0Sb7mV55VXyY1+XJ71l3dhGrFp/mE7AhcZ2igC553neWpX93ncMGsTxLfxR6NciFTm6YIGz0A6/ypL2GfQ1lvbW68+CTEccPIIPeqUcU+s3qNcIqW1j88wZs9eR/OgCK4lNj4aTTFHnfaUBBX+Fs5P6cU/QbVbj+0NaKoqW6eWIm6hiAOKpa1rEVzqMqWMRjUqIlOcY962tJ0d7gaVoyShJZHM9wV6NgkgH16CgDrvD0n9gfDXUNZuYVjZzIsbKBvbOABmuS+E90938bvD08mS0l8GOT/ALLVY+KGtOklv4ct8rb2qI7gHhmIz0qh8HP+SyeGv+vwf+gtQB9y0Un40UCPg7xzcSWnxY8R3ELEPHrFywIOP+WrV6Xr1pbfED4d6bqMLJaNZgPK7jluxHFeX/EIf8XN8T/9ha6/9GtXe/CaL7boVxA0+9FV1eBunPT+dAHnniiy8q9F1Ed1vMo8tgODgY/pVFRI9ilwkgZ4DyO4HauwfTbP+y9Y8P3UpGpWMrSwgrkFODgH8a4aGXyJg+3Kjhlz1oA6u0mvLiwtryzyIy+yVc962rlZgsboowB8xHWuM0zV2sL4AMwspDl4uw4rs7K+N3AFibCt9wkdaBjoY5YSJC7MxG4ZPStQwPJZgykbjyPWq9tAksTIzYKHmSnxLKx4HmqDgNnFAEEqtFJvkUFB0FIItxDKgRnOSfarDykx+Qg/eluAeaSR/wCArtkUfPj2oAzNRjKxyyRFiyLtLelaFirNZRnnKrl2HpWdcXaz3NvDHmFJCMg9+a0UKwWzASMVHHAxmgC1EQ8pSAF4+pY9RUcw+zyJdTJ5kSglgKrxXP73bESJAOntVxl/dLHPyeoPUUAc9B515qJ+zF/JkkBZM8D2q5qVlHNG+63KOmO3Bq4LVYuS2Gdv4RjioZRsfyY9zKTlmoAWKFo1QIFQuMAChy63ARGK7eq54NLbBSzeYWKx8rVlUidvMPyk9U70AQoZWu3hkbYxXeCegFW4CRCse4SlmO8j+Gnwldpk2BkI2nPXNNkmXGYo9ikY2g9aAHExhjLjcEODtqOeeMR+ZsY7j8uKrjzg+VGyEcsuetK+TIuw42jO3HWgCUX8PmJuHHfI6VUmuhFuJUszZ247VnXV6xvWgjjwrnOemDS3JubiPz44ypRdu0nqaAJYpFeMbC6SMefcVL9nkWbzHkZSBgYPXNN0YyR2Zivl2zHJVsZrR+SZDOFO2MEYP8XvQBQUyQtGvLwFsEN3NW2dfNMcr4CjLY7Cq8lu72u6RdxLZjGcYNZsmpIL3+y2tn86IGSaTOcqBnH5UAN165hFmQ6/LIQIj3B9agXRBp+mpLdXSqwjaWYZJEh/hH8qrxudc17+0oI/9Dt8DyXPUAYqr4o1UTsLNSy+UQWx0J9KAKdtFFqOoJHaQswDea/t6j6V6P4NsreLWX1nzFW2s4jJOxHPyjpXI6T5dhptpDaRBtW1T5El6CNCf512XjnULPwx8OIfDkHzX9xgzyIu3IJyc0AeZ+K9Xj1zxPe6hArLFK/yBjyAOK3vg7/yWPwz/wBfg/8AQWricV23wc/5LF4Z/wCvwf8AoLUCPuOijIooA+CfiH/yU7xP/wBha6/9GtVz4b61/ZPiqJW3EXBCcHgH3FU/iF/yU3xP/wBha6/9GtXPwzPbzpNExV0O5SDjBoA9b8d6JPbeJ5fE1ps2W+yWePkGRQBn2rhPFdrG93Hqtqu20vVWRcD7pPb6jFey6Ld2/jn4bCNYhHdPGYpHkOclTivMbRd9je+CtQhBvIZGe1mzwrcEj8hQM46HEp8knbu6EirtjdzR3MVpJMVVX+Vs8Cs+eGS3uHgl+WSNsH2oLDyyjAmTOQ2aBHpFrPnaoOWxyR0NPuTgO0DlCBxg8A1yOg68lvH9ivy2xidso5KZroWuo2C21uWeM8iRhgMetAxljDfFX1CSXdIrbT6/Wo7nW1tbr7J5bPM+C0vYZrRMpgjEjgIWQ/KDwayrC2jv9UaS5XILYHHQ44oAig1FIdVZbxg5Y/I4H3RWrc3kMcQPmgjGQMct7VFqWkfaH2bUSRVwoqvp+gzQzK12ySYbJy3QUAaFnCyxi8cFZJD3PIWtCKcKPsxYPHMeHI6GkdfkYeYQmMLkdqphGsrxLSWZXkPzxMOwoAt3izLP9z5QPkYVmCe9N7Fbqhy7fO4PAFa8zi4k80PuZByh74qqsEl7dIsT7JByEH8Y9M0ASrH5m94m+WI5YjvVbz1E3yqzeYcZJ6VZEkYtZU8oxBc7+ec+lQwugZGdNxf7tAF2C1cXW1Jf3IXofX1qGdtsjcnYvQjvVl12QbVU+Y3J9qgtbdnckbWji+Ylj1oAzo5j9tFozufOO9c9vatHfvV5Z2G9BsTtisXVL/yLyOZVA56jsKrX2vwCL7sjEDcD05oAvOn2jUo42xhRliOxrQTDACMmVYm5A71meHfOl0x7qX70z/KTyRWhLmJgqfJ3ZgaAJ7n5JwZAxeTlF/u1HC62k4Mku/jlfSnLK0dq0lyNpH3W67qguLmFdPeRl+aMjp1YUAJeX4trOa9ZgTykEajkN61y+qX6wW3lRswvJfmmuAe3pnr0pus6ykztbRbsNyCeiVkWU5tpWkcbwv8Ae70AamU0qwRg5E0g3Rxqeuaq6Dp41TXEhuJB5S5muWY8bF5NZ9zdSXUxuJmJZuFHoK6+LRrnTtPt9BUR/wBqa4VxIP8AlnHnoT9KAOw8FaemtXMmtCzRND00sLeR1GSVHYfU1wHxE1ka14yupYi3kR4RFPQYA6V6P4tlbwH8NYdAtZSZU4d4/l3O3JP614g7tJIWclmY5JJzQA2u2+Do/wCLyeGv+vwf+gtXFHiu1+Dn/JY/DP8A1+D/ANBagR9x0UUUAfBPxC/5Kb4n/wCwtdf+jWrnK6L4h/8AJTvE/wD2Frr/ANGtXO0AdZ8P/E8mgeIoVmlkNnLlGjB4BPQ4rv8A4kaL5mmR+LNKEcNzZMplYDDMh4B/WvFQSpyDgjoa9p8B6yviLwwmnX3+kCFTHcxyc70zx/SgZx2r6V/wlekpr2lRKsqR4uUPBLLwTXFMvlsySAh1OK7nXbe58A+MzDBI7aVMRKiKcqykdMdM5qfxBp+i+I9CTV9Ixb3WdrRFdu45x2oEefKjOcDk4rQ03VntXSC6Z3tAeUHb6VTurWSzuDDcDDDnj0qPfhSpGcjg0AdTPqs89uEt1aSzdgI8nkH0rZ02dbHScX0LRuTnp2z1ridL1S40m9imhO4Iwby25B/CvS7P4n6Xq9rDZ63pKNJ9zzFiXgetAxkdxHOEaM7t3y7vSlMcbsfNBOzqwPWptY8LvBbnXfD5D2Cx+Y8WTwR1rM0vVrTUYngeTyZlODG3UntigC4mw3Dy8sqjAUmqtyYzIlwyfMoJV8fpT55WtY1FzGVZ/u8dRSrPH9qgtz+8lf7idhmgCOC83rHKqEFztPvWrFZzw25dEBZwShU8rTdR0q7soIzdQxo8rfLtrtvD+hx2/hs3k8KG4B3xuRnpQB58s0Y3W0sbq4GWLnO6ks4WaYPJ91D8ozW744hN5qVlrNjAsNqUCTqox846msnaFkXzMiRxldvTFAE9yfMVQMqWb7/9KhunxIiFvJVfvEDhqe8nlxYzkv0qtdOyAPMwbcMbV60AV7vTVlJZ2DbgVTjt61zVzZrEqbiH8li0gx1Ga6eO7R7cgMxEf9+sDWpbeabdyo2kDb3NAG3b3sOoaej2imMZwsY4wBUd7ObW0dg26TqfwrntPnkWWEQL5IUZeQ9xUmoa/ZicGMyT7RjBHBoA2hqZn0tLu6V/JAwGJ6fhXM6lrUl8fI0/eqfxk96zLvUrm8bDysIf4YgcKPwqqC6fdYjPXBoEW98MduWYb5SSCarLg48wnb3pEiaRsLXZaX4Yj0SyXXPEhT7MFJhtxy0j9vagCXwvo1jpFi3iPxGVMcI/c2hXJdug9q7DwHZS3F1eePtaVfKO5LFW5aPHy5A6DFcXp9vqHxI8XW8BCQWuAGXO2ONVHoO9dv8AEDU7bRPCkWj2bNEsKCKBYhhST1NAzzfx3rz674pup1mkeEMAoZuMgYziua7U5shiGOTnk03HPFMQCu1+Dn/JZPDP/X4P/QWriq7b4Of8lj8M/wDX4P8A0FqAPuTFFJRSA+CfiHz8TfE//YWuv/RrVzldf4+sPM+JHiV/Mxu1W6P3f+mre9bkPwA+INxAk0Wi7o5FDKftduMgjI/5aUDseaVseGNdk8Oa/BfpvaNCRJGp++pBGK1vEvw08R+DzF/wkeny2azHEch2ujHrjcrEZ9s1zs1j5ETSeZux229aAse5u+n+LfC7WlxGPs98vmW9wyZMTemeo5BrzLUdIl8BeLEgvH+02bjho87SCPQ9xTfBnjRtFmWw1ItLpchO5epjJ7ivUb7TrXxL4bk0qFI7n7ZFvsbxlyyN1Az1HSgDz+7sItYjdoIhIypneR29K5O/0W4hhe6RQYFODzyKvnUNW8IanJplxjfbSfvFzw3tXRaR4n0u+KR6jEscTt+8TYOaAPOs4pR14ODXp+v+B7DXLB9V8MMsb4wLfpux1xivNrqznsbx7W8jaOZDgqRTEdB4Z8d6r4cfyklaezZsyQM2Qw79a6a98VeCvE9uwv8ATpNLvnXC3MaAhW7H5cV5mVwcd6Q8HBpAdvGLqymT/iZRapD/AMsxuxgfjW5pNrdw3kV+GhSTeDHucHGK8sUkHhiD6g4qz5k+dq3MmF5ALn9KBn0XBpcvi69tmudQgSeCQF1Y5GB9K6+Xw3qzTJZ2a7omwFYAhBXyJHqF9C+6K8uI3z1WVgf510Ft8SPGFpYNZweIL5YmGP8AXNkD2OaBHsfiyC80drvTJ1jmjkQ7lRvut7VwMc6qpJ3oB8uHySK8+l1jU5pC82o3Ujk5LPMxJ/Wmf2hes25rqZj/ALTk0DO9uZZoYzJGryFelU5pL14WkkkSHK52M2Tg1yB1TUCuDeTAem81XkmklbdLK7t6sxNAHS22qaXpwf7SZbyRuirwFP1NU73xDHcOv2e18tB2JBzWFSgE9KBE8txLcSMXkIB/hzwPaoMY6c09YnfOB071f03w/qerMBYWrTcckdBQBnAFunHqauadpd1qt0sFiu9ycZ7CumTwtY6dD5uv3iQbRloU+81Fx4oa6gTSPCNibbd8vmKoEj/iKBgy2vgtzDciO81Bl+4oyIie5Jro/Bvw81TxVcQ6x4knP9nsS6wyMTkemOgFaHhD4ew6VHFrfidlnmxueKQ7tn1z3rM8efFM3cbaV4ZeS2gjbaZl+TI9BigDsvE/ijw14Sikt7G1SHy0CrBAoDsf96vD/EOuTa/qkl3KWSMn93ETkIKzZppZ5DJcSPK7clnYkn8aYaYgPWkoPWikAd67b4O/8lk8Nf8AX4P/AEFq4mu1+Dn/ACWTwz/1+D/0FqAR9yUUZ96KBHxD45/5KH4j/wCwrdf+jWr0r41eGNe1rxJodxo+iajqEC6Hbo0traSSqGDyHaSoIzgg49xXmvjn/kofiP8A7Ct1/wCjWr0r41eJ9e0XxJodvo+t6lp8DaHbyNFa3ckSlt8g3EKQM4AGfYUGgxLXUvDv7O+tWXjWKe3e8u4hpNndsVlUgqSVU8qowTjA6H158Tvf+PN8e3869y8K3ereKfgv4vm8byzX2n2dv5mmXt987icB8hJG+Y/NsHXvj2rw69/49H/D+dAjJHIxXovw4+IkXh3bpesoz2TsRHOvJtye+PSvOaKZJ9KXuj+HPGNn5hW3upZB/wAfQUbvx96811/4QapaX0jaVNBLbsN0a78N9K4Gx1S/02VZLC8mgKnI2OQPyru9F+L19awwxarCblUOGdMBiPrSA5pJNf8ABuqI7NNAYmDFQxKtW7eeKND8YXySa3Zm2vWQRrMiggkdCfxru9O8aeD/ABJb/ZbmDfcTZXy7hPm/A1FJ8MdGm12G+sxH9nxu8lW6H6UAeY6h4RuE8yaxmjn28+Wp+YfSsCSF7d3huImSQHncOlel+LvCGqQ6lJqPh0SRpbRgyIGIJI7j1rjbrU9RYmHVLDe+BvYx/MR9aAMMQlk3JyKasTkgBDk9K05Lu1luYlhQ2qA/MGHH6VdsLTT9Y1+CxuNSW3SZvLWbaQoJ6E/jQBz7xujlW6im7TjNdNq9lH4X1GXR7mSG9eOUM11EMjbjoM81XZ9HF3C6ys0RI8wAH8aAMEjp3o746V3LjwffbozcLbfL8j7TwayINAhuS6R6jbsqN9/B5FAHOhc/Sl29BjnsK6S507RrGaOFNQjnDjDMmfkPvWmupeE9AhzaW51O+HzJNj5FP40AcrZ6Zc3swtreB3mbtjpWvb+DLiRnF7cw2RjGSJDk/lVtbvxNrXnXem2otkUbmeFQp/OrGm/DzX9exd39z5YY8vK5ZsUDM+z1rStGkMS2pvlVcGQgAE/jU/8AwnmsGRodCX7LGwx5ca8/pXotl4T8O6fpKW9wsP7r55HlH32/GornXPCfh/MiLau5/wCWccfP1oA4nTvh5ruvutzf3CxJI2T5jEsM+1ei2WhaJ4K0gXO6K3nVcNM65ZvpXG6z8WpJYjDo1sYscLI4GRXA6jrOo6vIX1G7muDnIDMSB+FAHSeM/HF1rVw9rZXUwtAeTnHmf/WrjRwfWjOOlJQIVjubNFJRQAd6DjNFFABXa/Bz/ksnhn/r8H/oLVxVdr8HP+SyeGf+vwf+gtQB9yYooooCx8Q+Of8AkofiL/sKXX/o1q34fjb8QbeCOGLxBtjjUIo+xW5wAMD/AJZ0UUFmP4j+IXirxbbrb+INZmuoFO4QhVjQnsSqAAn61yl7zZv+H86KKAMnHrRjOaKKCA/hpQuQKKKAD5kf5GII6EVrab4q1rSlC2WozIoOQu4kUUUAd9oPxfuf3dvrNqbk7sF1IyR+NdKfFuhapulm0qTewxnYnH60UVNxkknhHw9r1l50NgsRnG3LKAQfXioH+GWkJG0MMMYYbT5hzkEUUUXYE0fwi0mazup55WkmdSMtk4/GqT/CjRpVMSDY2PvUUUXYGY3wksI7iPfcMySHGOcioL/4QqhWSxvwkPAdXByaKKLsCxD8GbfzcTX2SeQADgV0dv8ACbRbaRJZYkcKuduM5oopXYEOq69pnh1AlraSIsY5VFXDY/GuH1H4q3rM66bB9njbIwT0ooqrgcbfa3qWqSb7y8kfvt3ECqJ3SPhnYn1JzRRQIQ4Ax6daTvxRRQAgFBGDzRRTAXHNGOvtRRQAmOKTpRRTAM/LXbfB0Y+MXhk/9Pg/9BaiikB9yZooopDP/9k=\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "img_path = 'brain_center.jpeg'\n",
        "\n",
        "display(Image(img_path))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hwSRdh-Dq-rI"
      },
      "outputs": [],
      "source": [
        "preprocess_input = keras.applications.resnet50.preprocess_input"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1RZYhqqlx0RK"
      },
      "outputs": [],
      "source": [
        "def get_img_array(img_path, size):\n",
        "    # `img` is a PIL image of size 224x224\n",
        "    img = keras.preprocessing.image.load_img(img_path, target_size=size)\n",
        "    # `array` is a float32 Numpy array of shape (224, 224, 3)\n",
        "    array = keras.preprocessing.image.img_to_array(img)\n",
        "    # We add a dimension to transform our array into a \"batch\"\n",
        "    # of size (1, 224, 224, 3)\n",
        "    array = np.expand_dims(array, axis=0)\n",
        "    return array\n",
        "\n",
        "\n",
        "def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):\n",
        "    # First, we create a model that maps the input image to the activations\n",
        "    # of the last conv layer as well as the output predictions\n",
        "    grad_model = tf.keras.models.Model(\n",
        "        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]\n",
        "    )\n",
        "\n",
        "    # Then, we compute the gradient of the top predicted class for our input image\n",
        "    # with respect to the activations of the last conv layer\n",
        "    with tf.GradientTape() as tape:\n",
        "        last_conv_layer_output, preds = grad_model(img_array)\n",
        "        if pred_index is None:\n",
        "            pred_index = tf.argmax(preds[0])\n",
        "        class_channel = preds[:, pred_index]\n",
        "\n",
        "    # This is the gradient of the output neuron (top predicted or chosen)\n",
        "    # with regard to the output feature map of the last conv layer\n",
        "    grads = tape.gradient(class_channel, last_conv_layer_output)\n",
        "\n",
        "    # This is a vector where each entry is the mean intensity of the gradient\n",
        "    # over a specific feature map channel\n",
        "    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))\n",
        "\n",
        "    # We multiply each channel in the feature map array\n",
        "    # by \"how important this channel is\" with regard to the top predicted class\n",
        "    # then sum all the channels to obtain the heatmap class activation\n",
        "    last_conv_layer_output = last_conv_layer_output[0]\n",
        "    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]\n",
        "    heatmap = tf.squeeze(heatmap)\n",
        "\n",
        "    # For visualization purpose, we will also normalize the heatmap between 0 & 1\n",
        "    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)\n",
        "    return heatmap.numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9XmHXlrs_Tr"
      },
      "source": [
        "The following configuration is ad hoc for our model:\n",
        "\n",
        "\n",
        "* **img_size** ->  depends on the size of the images with which the model was trained (e.g. (224,224) for ResNet50)\n",
        "* **last_conv_layer_name** -> depends on the architecture of the model, you can find the name of the last convolutional layer of you model looking into the `model.summary()`\n",
        "* **pred_index** -> specify the class I want the explanation of. In our case, since it's a binary classification we can only have 0 but with more classes you can specify it. By default it will be set to the majority class evaluated by the model.\n",
        "This index can be usefull if we have more subjects in the same image, for example if we have a dog and a cat in the same image we can create the heatmap w.r.t to the dog class or w.r.t the cat class\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 409
        },
        "id": "D65SmfD8x2It",
        "outputId": "90b550ea-732a-457a-b143-11a68a3fc78d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 480x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Prepare image\n",
        "img_size = (224, 224)\n",
        "img_array = preprocess_input(get_img_array(img_path, size=img_size))\n",
        "\n",
        "# Remove last layer's softmax\n",
        "model.layers[-1].activation = None\n",
        "\n",
        "# Generate class activation heatmap\n",
        "last_conv_layer_name = \"conv5_block3_out\"\n",
        "\n",
        "heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=0)\n",
        "\n",
        "# Display heatmap\n",
        "plt.matshow(heatmap)\n",
        "plt.axis('off')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OPcUCIsc14hC"
      },
      "source": [
        "Finally we combine the initial image with the heatmap in order to have a more comprehensive visual explanation\n",
        "\n",
        "* `alpha` is a parameter that controls the blending of the heatmap with the original image during the superimposition process. The higher is alpha the higher will be the contrast.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "JyiCkEm7x5_D",
        "outputId": "a53c3765-5052-4eaa-96a6-274dd1ddc2c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-55-da88a0bc1c6e>:10: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n",
            "  jet = cm.get_cmap(\"jet\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "def save_and_display_gradcam(img_path, heatmap, cam_path=\"cam.jpg\", alpha=2):\n",
        "    # Load the original image\n",
        "    img = keras.preprocessing.image.load_img(img_path)\n",
        "    img = keras.preprocessing.image.img_to_array(img)\n",
        "\n",
        "    # Rescale heatmap to a range 0-255\n",
        "    heatmap = np.uint8(255 * heatmap)\n",
        "\n",
        "    # Use jet colormap to colorize heatmap\n",
        "    jet = cm.get_cmap(\"jet\")\n",
        "\n",
        "    # Use RGB values of the colormap\n",
        "    jet_colors = jet(np.arange(256))[:, :3]\n",
        "    jet_heatmap = jet_colors[heatmap]\n",
        "\n",
        "    # Create an image with RGB colorized heatmap\n",
        "    jet_heatmap = keras.preprocessing.image.array_to_img(jet_heatmap)\n",
        "    jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0]))\n",
        "    jet_heatmap = keras.preprocessing.image.img_to_array(jet_heatmap)\n",
        "\n",
        "    # Superimpose the heatmap on original image\n",
        "    superimposed_img = jet_heatmap * alpha + img\n",
        "    superimposed_img = keras.preprocessing.image.array_to_img(superimposed_img)\n",
        "\n",
        "    # Save the superimposed image\n",
        "    superimposed_img.save(cam_path)\n",
        "\n",
        "    # Display Grad CAM\n",
        "    display(Image(cam_path))\n",
        "\n",
        "\n",
        "save_and_display_gradcam(img_path, heatmap)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Conclusion"
      ],
      "metadata": {
        "id": "Ow2K8xD4ZJRJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see the results are satisfactory and Grad-CAM has shown really good localization ability.\n",
        "\n",
        "Another interesting thing we noticed is that the same technique applied to a model with a lower perfomance (80% of accuracy instead of 92% on validation set) has way worse perfomances. \n",
        "\n",
        "From this we can infer that achieving high performance models is crucial for accurate tumor localization and that the there is a strong dependence between the model ability of the technique and the perfomances of the model"
      ],
      "metadata": {
        "id": "SGm5921mZLcd"
      }
    }
  ]
}