Egypt_gp.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FoHsQnTVPyqM"
      },
      "source": [
        "#How to upload an image to Colab?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryAQC-3gP0qC"
      },
      "source": [
        "# Use libraries\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "# Display\n",
        "from IPython.display import Image, display\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm\n",
        "import io\n",
        "import os\n",
        "import cv2 as cv\n",
        "from PIL import Image\n",
        "import PIL\n",
        "\n",
        "# Import the necessary libraries\n",
        "from PIL import Image\n",
        "from numpy import asarray"
      ],
      "metadata": {
        "id": "lCZVSjk5iVAE"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPVqkNhgPlv0"
      },
      "source": [
        "from google.colab import files\n",
        "from IPython.display import Image"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oXd5i9OvQN5p",
        "outputId": "0b1070b8-c764-4ecc-ee48-b8bef31e442a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        }
      },
      "source": [
        "uploaded = files.upload()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-b60a6857-17e0-4f7c-9264-9b25f452311d\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-b60a6857-17e0-4f7c-9264-9b25f452311d\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving egypt_gp.png to egypt_gp.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e3RuLhrCQbzI",
        "outputId": "1c658606-41a6-43ad-edb9-35c5f9ff16f7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "img = Image('egypt_gp.png')\n",
        "print(type(img))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'IPython.core.display.Image'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "im = plt.imread(\"egypt_gp.png\")\n",
        "# fig, ax = plt.subplots()\n",
        "# im = plt.imshow(im)\n",
        "plt.matshow(im)\n",
        "plt.show()\n",
        "# resized_heat_map = cv.resize(im, dsize= (350,500))\n",
        "# plt.imshow(resized_heat_map)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 437
        },
        "id": "eqosnbJp7hYR",
        "outputId": "5d6d6003-74b6-4e7f-b12b-f54505bdc11d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 685.714x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from skimage.measure import label\n",
        "import tensorflow as tf\n",
        "import io\n",
        "from PIL import Image\n",
        "\n",
        "#Binarize a saliency map using a threshold\n",
        "def binarize(saliency_map, threshold):\n",
        "    \n",
        "    #Get the dimensions of the saliency map\n",
        "    h, w,e = saliency_map.shape\n",
        "    \n",
        "    #The binarized version of the saliency map\n",
        "    result = np.zeros((h,w))\n",
        "    \n",
        "    for i in range(h):\n",
        "        \n",
        "        for j in range(w):\n",
        "            \n",
        "            if(saliency_map[i][j][0] >= threshold[0]):\n",
        "                \n",
        "                result[i][j] = 1\n",
        "                \n",
        "    return result\n",
        "\n",
        "#Donne la valeur moyenne des pixels dans une carte de chaleur\n",
        "def get_average(saliency_map):\n",
        "    \n",
        "    #Les dimensions de la carte de chaleur\n",
        "    n, m ,k= saliency_map.shape\n",
        "    \n",
        "    #La moyenne au départ elle est à 0\n",
        "    average = 0\n",
        "    \n",
        "    #Je somme pour chaque pixel\n",
        "    for i in range(n):\n",
        "        \n",
        "        for j in range(m):\n",
        "            \n",
        "            average += saliency_map[i][j]\n",
        "       \n",
        "    # ma moyenne c'est la somme divisé par le nombre de pixels\n",
        "    return average/(n*m)"
      ],
      "metadata": {
        "id": "G8yvTDwPXnkI"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "avearge_saliency = get_average(im)\n",
        "mask = binarize(im, avearge_saliency)\n",
        "plt.imshow(mask, \"gray\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 429
        },
        "id": "n85Jm4z8VrtR",
        "outputId": "da5c50d1-6040-483b-de53-e5e972cae40c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f8670e1ee50>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Retourne la plus grande boite qui entoure la composante connexe\n",
        "def get_bounding_box(image):\n",
        "    \n",
        "    #Dimension de l'image\n",
        "    n, m = image.shape\n",
        "    \n",
        "    #La coordonnée la plus haute\n",
        "    upper = 0\n",
        "    \n",
        "    #La plus petite coordonnée dans l'image\n",
        "    lower = 0\n",
        "    \n",
        "    #La coordonnée la plus à gauche\n",
        "    left_result = n\n",
        "    \n",
        "    #La coordonnée la plus à droite\n",
        "    right_result = 0\n",
        "    \n",
        "    #Pour savoir si la première bande supérieur a été trouvée\n",
        "    first_bound = True\n",
        "    \n",
        "    #Pour chaque ligne\n",
        "    for i in range(n):\n",
        "        \n",
        "        #Je cherhce le pixel le plus à gauche\n",
        "        left = n\n",
        "        \n",
        "        #et le pixel le plus à droite\n",
        "        right = 0\n",
        "        \n",
        "        #et je regarde si la colonne contient au moins un pixel\n",
        "        contain_pixel = False\n",
        "        \n",
        "        #Pour chaque colonne\n",
        "        for j in range(m):\n",
        "            \n",
        "            #Si l'image contient un pixel à 1\n",
        "            if(image[i][j]) :\n",
        "                \n",
        "                #Je sais que je suis à la première colonne\n",
        "                contain_pixel = True\n",
        "                \n",
        "                #Je compare quel pixel et le plus à gauche\n",
        "                if(j < left):\n",
        "                \n",
        "                    left = j\n",
        "                    \n",
        "                if(j > right):\n",
        "                    \n",
        "                    right = j\n",
        "                    \n",
        "        if(left < left_result):\n",
        "            \n",
        "            left_result = left\n",
        "            \n",
        "        if(right > right_result):\n",
        "            \n",
        "            right_result = right\n",
        "        \n",
        "        if(contain_pixel and first_bound):\n",
        "            \n",
        "            upper = i\n",
        "            first_bound = False\n",
        "            \n",
        "        elif(contain_pixel and not first_bound):\n",
        "            \n",
        "            lower = i\n",
        "            \n",
        "    return [upper, left_result], abs(left_result-right_result), abs(upper-lower)\n",
        "\n",
        "def make_matrix(mask, coordinates):\n",
        "    \n",
        "    result = np.zeros(mask.shape)\n",
        "    \n",
        "    for i in range(coordinates[0][0], coordinates[0][0]+coordinates[2]):\n",
        "        \n",
        "        for j in range(coordinates[0][1], coordinates[0][1]+coordinates[1]):\n",
        "            \n",
        "            result[i][j] = 1\n",
        "            \n",
        "    return result"
      ],
      "metadata": {
        "id": "H-PlsaLoMhAE"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predicted_box = make_matrix(mask, get_bounding_box(mask))\n",
        "plt.imshow(predicted_box, \"gray\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 429
        },
        "id": "57xYbzgRMbnV",
        "outputId": "577fa16a-40ef-4156-8357-55e7aa1df6f0"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f866ce29220>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 38
        },
        "id": "sWf-Q7DPQVMH",
        "outputId": "70b3490c-75c4-4d73-9e2a-2a48f2d31e8a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-28e25d64-e483-4154-84d0-b76014210b55\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-28e25d64-e483-4154-84d0-b76014210b55\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def read_trimap(path):\n",
        "    \n",
        "    with tf.io.gfile.GFile(path, 'rb') as fid:\n",
        "        \n",
        "        encoded_mask_png = fid.read()\n",
        "    \n",
        "    encoded_png_io = io.BytesIO(encoded_mask_png)\n",
        "    \n",
        "    return np.array(Image.open(encoded_png_io))\n",
        "\n",
        "\n",
        "#Transform a trimap like the one above into a binary one \n",
        "def transform_trimap(trimap):\n",
        "    \n",
        "    h, w = trimap.shape\n",
        "    \n",
        "    result = []\n",
        "    \n",
        "    for i in range(h):\n",
        "        \n",
        "        line  = []\n",
        "        \n",
        "        for j in range(w):\n",
        "            \n",
        "            if(trimap[i][j] == 2):\n",
        "                \n",
        "                line.append(0)\n",
        "                \n",
        "            else:\n",
        "                \n",
        "                line.append(1)\n",
        "                \n",
        "        result.append(line)\n",
        "                \n",
        "    return np.array(result)"
      ],
      "metadata": {
        "id": "z7-ce3oSQmzo"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trimap = read_trimap(\"Egyptian_Mau_1_mask.png\")\n",
        "binary_map = transform_trimap(trimap)\n",
        "ground_truth_box = make_matrix(binary_map, get_bounding_box(binary_map))"
      ],
      "metadata": {
        "id": "qtpj93Ws45YK"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig, ax = plt.subplots(1, 3, figsize = (12, 12))\n",
        "\n",
        "ax[0].imshow(trimap)\n",
        "ax[1].imshow(binary_map, \"gray\")\n",
        "ax[2].imshow(ground_truth_box, \"gray\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 274
        },
        "id": "zZAg0eUS5Nfx",
        "outputId": "5fd5b71a-a324-4707-badb-3629f64455b7"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f866ccddb50>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from math import log\n",
        "from skimage.measure import label\n",
        "import numpy as np\n",
        "\n",
        "##The ground_truth (mask/box)  and the predicted (mask/box) must be in a binary format\n",
        "##Please make sure that the ground_truth (mask/box) exists (the entry must be a matrix that contains at least a pixel with 1 value)\n",
        "def IoU(ground_truth, predicted_mask):\n",
        "    \n",
        "    #verify if the two images has the same dimensions\n",
        "    # assert ground_truth.shape == predicted_mask.shape\n",
        "    \n",
        "    #Get the dimension of the picture\n",
        "    m, n = ground_truth.shape\n",
        "    \n",
        "    #The variable that will contain the value of the intersection of the two masks area\n",
        "    intersection = 0\n",
        "    \n",
        "    #The same but for union\n",
        "    union = 0\n",
        "    \n",
        "    #We iterate on pixels\n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "            \n",
        "            #If the two of pixels is equal to one that mean that the pixel is in both masks\n",
        "            if(int(ground_truth[i][j]) == 1 and int(predicted_mask[i][j]) == 1):\n",
        "                \n",
        "                intersection += 1\n",
        "                union += 1\n",
        "             \n",
        "            #If the pixel is in one of the twos without being in the other we add 1\n",
        "            if( int(ground_truth[i][j]) == 1 ^ int(predicted_mask[i][j]) == 1):\n",
        "                \n",
        "                union += 1\n",
        "    \n",
        "    return intersection/union\n",
        "\n",
        "#Dice coefficient F1 score\n",
        "#ground truth, preidcted --> (box/mask) must be numpy.array\n",
        "def DC(ground_truth, predicted):\n",
        "\n",
        "    #make sure that the dimensions are the same\n",
        "    # assert ground_truth.shape == predicted.shape\n",
        "\n",
        "    #Get the dimensions of the matrix\n",
        "    h, w = ground_truth.shape\n",
        "\n",
        "    #The number of pixel with 1 as value that are in both of ground_truth and predicted mask or box\n",
        "    TP = 0\n",
        "    #The number of pixels that are in the ground_truth but not in the predicted mask or box\n",
        "    TN = 0\n",
        "    #The same but for predicted instead of ground truth\n",
        "    FN = 0\n",
        "\n",
        "    #We iterate in each pixel in both ground_truth and predicted to see what does match\n",
        "    for i in range(175):\n",
        "\n",
        "        for j in range(175):\n",
        "            \n",
        "            #We verify if they had 1 pixels in commun (intersection)\n",
        "            if(int(ground_truth[i][j]) == 1 and int(predicted[i][j]) == 1):\n",
        "\n",
        "                TP += 1\n",
        "\n",
        "            #To count the number of pixels \"1\" that are in ground_truth but not in predicted\n",
        "            elif(int(ground_truth[i][j]) == 1 and int(predicted[i][j]) == 0):\n",
        "\n",
        "                FN += 1\n",
        "\n",
        "            #Same thing but for predicted\n",
        "            elif(int(ground_truth[i][j]) == 0 and int(predicted[i][j]) == 1):\n",
        "\n",
        "                TN += 1\n",
        "\n",
        "    #The dice formula (2*Union/(cardinality(ground_truth)+cardinality(predicted))\n",
        "    return 2*TP/(2*TP+TN+FN)\n",
        "\n",
        "#Localization error\n",
        "def LE(ground_truth, prediction):\n",
        "    \n",
        "    return 1-IoU(ground_truth, prediction)\n",
        "\n",
        "\n",
        "#Energy pointing game it is equivalent to the \"Pixel-wise precision\"\n",
        "def EPG(ground_truth_mask, saliency_map):\n",
        "\n",
        "\n",
        "    # assert ground_truth_mask.shape ==  saliency_map.shape\n",
        "    \n",
        "    h, w = ground_truth_mask.shape\n",
        "    \n",
        "    #The saliency contained in the ground_truth (mask or box)\n",
        "    ground_truth_saliency = 0\n",
        "    \n",
        "    #The saliency on the hole image\n",
        "    global_saliency = 0\n",
        "    \n",
        "    \n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "            \n",
        "            #We and the value of the saliency when we have a pixel of 1 in the ground_truth\n",
        "            ground_truth_saliency += float(saliency_map[i][j][0])*int(ground_truth_mask[i][j])\n",
        "            \n",
        "            #We sum the saliency of all pixels\n",
        "            global_saliency += float(saliency_map[i][j][0])\n",
        "\n",
        "    #The formula of energy pointing game\n",
        "    return ground_truth_saliency/global_saliency\n",
        "\n",
        "\n",
        "#The precision for the class of pixels with 1 value\n",
        "def precision(ground_truth, predicted):\n",
        "    \n",
        "    #verify if the dimensions are the same\n",
        "    # assert ground_truth.shape == predicted.shape\n",
        "    \n",
        "    #Get the dimensions of one of the matrices\n",
        "    h, w = ground_truth.shape\n",
        "    \n",
        "    #The well classified pixels\n",
        "    good_predictions = 0\n",
        "    \n",
        "    #The number of pixels with value of one\n",
        "    hypothesis = 0\n",
        "    \n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "\n",
        "            #If the predicted label correspond to the ground label\n",
        "            if(ground_truth[i][j] == predicted[i][j] and ground_truth[i][j] == 1):\n",
        "                \n",
        "                good_predictions += 1\n",
        "                \n",
        "                hypothesis += 1\n",
        "                \n",
        "            #If it's not\n",
        "            elif(predicted[i][j] == 1 and ground_truth[i][j] == 0):\n",
        "                \n",
        "                hypothesis += 1\n",
        "                \n",
        "    return good_predictions/hypothesis\n",
        "\n",
        "\n",
        "#The recall of class 1 pixels\n",
        "def recall(ground_truth, predicted):\n",
        "\n",
        "    # assert ground_truth.shape == predicted.shape\n",
        "    \n",
        "    h, w = ground_truth.shape\n",
        "    \n",
        "    #Well classified pixels\n",
        "    good_predictions = 0\n",
        "    \n",
        "    #The number of pixels with 1 as value\n",
        "    refrences = 0\n",
        "    \n",
        "    #Same thing as the precision but we calculate the number of references pixels of ground truth\n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "            \n",
        "            if(ground_truth[i][j] == predicted[i][j] and ground_truth[i][j] == 1):\n",
        "                \n",
        "                good_predictions += 1\n",
        "                refrences += 1\n",
        "                \n",
        "            elif(ground_truth[i][j] == 1 and predicted[i][j] == 0):\n",
        "                \n",
        "                refrences += 1\n",
        "                \n",
        "    return good_predictions/refrences\n",
        "\n",
        "\n",
        "#The beta F-score \n",
        "def F_score(ground_truth, predicted, beta=1):\n",
        "    \n",
        "    p = precision(ground_truth, predicted)\n",
        "    \n",
        "    r = recall(ground_truth, predicted)\n",
        "    print(p)\n",
        "    print(r)\n",
        "    \n",
        "    return (1+beta**2)*p*r/((beta**2)*p+r)\n",
        "\n",
        "\n",
        "#Calculate the fraction of the ground truth  that is covered by the saliency map\n",
        "def pixel_wise_recall(ground_truth, sallience_map):\n",
        "    \n",
        "    # assert ground_truth.shape == sallience_map.shape\n",
        "    \n",
        "    m, n = ground_truth.shape\n",
        "    \n",
        "    ground_truth_saliency = 0\n",
        "    \n",
        "    refrences = 0\n",
        "    \n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "            \n",
        "            if(int(ground_truth[i][j]) == 1):\n",
        "                \n",
        "                refrences += 1\n",
        "                \n",
        "                ground_truth_saliency += float(sallience_map[i][j][0])\n",
        "                \n",
        "    \n",
        "    return ground_truth_saliency/refrences\n",
        "\n",
        "\n",
        "#The F_beta score\n",
        "def pixel_wise_F_score(ground_truth, saliency_map, beta=1):\n",
        "    \n",
        "    p = EPG(ground_truth, saliency_map)\n",
        "    \n",
        "    r = pixel_wise_recall(ground_truth, saliency_map)\n",
        "\n",
        "    return (1+beta**2)*(p*r)/((beta**2)*p+r)\n",
        "\n",
        "\n",
        "#Calculate the \"1\" class pixels in a binary mask or box\n",
        "def get_cardinality(predicted):\n",
        "    \n",
        "    h, w = predicted.shape\n",
        "    \n",
        "    result = 0\n",
        "    \n",
        "    for i in range(h):\n",
        "        \n",
        "        for j in range(w):\n",
        "            \n",
        "            if(int(predicted[i][j]) == 1):\n",
        "                \n",
        "                result += 1\n",
        "                \n",
        "    return result\n",
        "\n",
        "#The saliency metric\n",
        "def SM(predicted, probability_class):\n",
        "    \n",
        "    h, w = predicted.shape\n",
        "    \n",
        "    return log( max( 0.05, get_cardinality(predicted) / (h*w) ) ) - log( probability_class )\n",
        "\n",
        "\n",
        "#The absolute mean error\n",
        "def AME(saliency_map, ground_truth):\n",
        "    \n",
        "    # assert saliency_map.shape == ground_truth.shape\n",
        "    \n",
        "    h, w ,v = saliency_map.shape\n",
        "    \n",
        "    result = 0\n",
        "    \n",
        "    for i in range(175):\n",
        "        \n",
        "        for j in range(175):\n",
        "            \n",
        "            result += abs(float(saliency_map[i][j][0]) - int(ground_truth[i][j]))\n",
        "            \n",
        "    return result/(h*w)\n",
        "\n",
        "#The mask and box accuaracy it works for both of them\n",
        "#Max value refer to sigma the second threshold\n",
        "def accuaracy(ground_truths, saliency_maps, thresholds_list, max_value=0.5):\n",
        "    \n",
        "    assert len(ground_truths) == len(saliency_maps)\n",
        "    \n",
        "    results = np.zeros((len(thresholds_list),0))\n",
        "    \n",
        "    for i in range(len(ground_truths)):\n",
        "        \n",
        "        for j in len(thresholds_list):\n",
        "            \n",
        "            if(IoU(ground_truths[i], saliency_maps[i]) >= max_value):\n",
        "                \n",
        "                results[j] += 1\n",
        "                \n",
        "    results = results/len(ground_truths)  \n",
        "    \n",
        "    return np.max(results), results\n",
        "\n",
        "\n",
        "\n",
        "def concept_influence(binary_segmentation_mask, top_k_binary_mask, k = 1_000):\n",
        "    \n",
        "    assert binary_segmentation_mask.shape ==  top_k_binary_mask.shape\n",
        "    \n",
        "    h, w = binary_segmentation_mask.shape\n",
        "    \n",
        "    top_k_binary_mask = 0\n",
        "    \n",
        "    relative_size_concept = 0\n",
        "    \n",
        "    for i in range(h):\n",
        "        \n",
        "        for j in range(w):\n",
        "            \n",
        "            top_k_binary_mask += binary_segmentation_mask[i][j]*top_k_binary_mask[i][j]\n",
        "            \n",
        "            relative_size_concept += binary_segmentation_mask[i][j]\n",
        "    \n",
        "    top_k_binary_mask /= k\n",
        "    \n",
        "    return top_k_binary_mask/relative_size_concept\n",
        "\n",
        "def relevance_rank_accuracy(ground_truth, top_k_pixels):\n",
        "    \n",
        "    h, w = ground_truth.shape\n",
        "    \n",
        "    result = 0\n",
        "    \n",
        "    for pixel in top_k_pixels:\n",
        "        \n",
        "        result += ground_truth[pixel[0]][pixel[1]]\n",
        "        \n",
        "    return result/(h*w)"
      ],
      "metadata": {
        "id": "VNOG0hXsQpHQ"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "LE(ground_truth_box, predicted_box)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1UK_RwPGRKJb",
        "outputId": "dea206d6-a84a-45bc-a528-4f402bf96511"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.013698630136986356"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fig, ax = plt.subplots(1, 2, figsize = (12, 12))\n",
        "\n",
        "ax[0].imshow(predicted_box, \"gray\")\n",
        "ax[1].imshow(ground_truth_box, \"gray\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 378
        },
        "id": "7eKjLKsrhB2x",
        "outputId": "9cb06747-f3a6-4e1c-ac25-a0700b6670b8"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f866c6e5760>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "LE(binary_map, mask)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4fDpgarxhI82",
        "outputId": "8516de4b-00c2-454e-c462-aeee17b90972"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.1779320186818889"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fig, ax = plt.subplots(1, 2, figsize = (12, 12))\n",
        "\n",
        "ax[0].imshow(binary_map, \"gray\")\n",
        "ax[1].imshow(mask, \"gray\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 378
        },
        "id": "1inCczJhhOTN",
        "outputId": "208f88ce-9f52-472c-e5b2-1fe328dc1750"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f866cb7c3d0>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9oAAAFYCAYAAACs8IS9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACCf0lEQVR4nO3deXhMZ/8/8PdMJvsqi0QQQZHaSSRCbJXa1V5UVVEea2t5uqjSog+lllYXS6uo2kpRe0sQW2S1LylqCbIgMtmXmTm/P/zMt1NBlpncs7xf13WuK3PmzDnvOTOZez5zzrlvmSRJEoiIiIiIiIhIL+SiAxARERERERGZExbaRERERERERHrEQpuIiIiIiIhIj1hoExEREREREekRC20iIiIiIiIiPWKhTURERERERKRHLLSJiIiIiIiI9IiFNhEREREREZEesdAmIiIiIiIi0iMW2kRERERERER6JLTQ/u677+Dv7w87OzuEhIQgJiZGZBwiIiLSM7b1RERkiYQV2ps3b8aUKVPw6aefIiEhAU2aNEHnzp2RlpYmKhIRERHpEdt6IiKyVDJJkiQRGw4JCUGLFi3w7bffAgA0Gg2qV6+OiRMn4qOPPnruYzUaDe7duwdnZ2fIZLKKiEtERPRckiQhKysLvr6+kMt5ZRbAtp6IiMxLadp6RQVl0lFYWIj4+HhMmzZNO08ulyM8PBxRUVFPLV9QUICCggLt7bt376J+/foVkpWIiKg0kpKSUK1aNdExhGNbT0RE5qokbb2Qn9wfPHgAtVoNb29vnfne3t5ISUl5avl58+bB1dVVO7HhJSIiY+Xs7Cw6glFgW0/6snnzZiiVSp1p4MCBomMRkQUrSVtvEue2TZs2TefDNSkpSXQkIiKiYvE057JhW0/FkclkcHBwgIuLi85kY2MjOhoRWbCStPVCTh339PSElZUVUlNTdeanpqbCx8fnqeVtbW1ha2tbUfGIiIionNjWExGRJRNyRNvGxgaBgYGIiIjQztNoNIiIiEBoaKiISERERKRHbOuJiMiSCTmiDQBTpkzBsGHDEBQUhODgYHz11VfIycnB8OHDRUUiIiIiPWJbT0RElkpYoT1w4EDcv38fM2fOREpKCpo2bYr9+/c/1WkKERERmSa29UREZKmEFdoAMGHCBEyYMEFkBCIiIjIgtvVERGSJTKLXcSIiIiIiIiJTIfSINhkPKyurMg+VodFoUFBQoOdEREREREREpomFNgEA+vbti2nTppXpsefOncM777wDlUql51RERERERESmh4W2BQsICICLiwsAICgoCM2aNSvTeqytrRESEoKioiJoNBpcuXIF2dnZ+oxKRERERERkMlhoWyiFQoFvv/0Wbdq0AQDI5WW/XL9BgwY4dOgQAKCwsBBdunTBiRMn9JKTiIiIiIjI1LDQtkCtW7dG+/btUbt27TJfl/1PMplMux6FQoG33noL9evXx9q1a1FYWFju9RMREREREZkSFtoWqEOHDpgzZ45B1i2XyzF69Gi0adMGW7ZsgUqlgkajMci2iIiIiIiIjBGH9yKDqFGjBnbt2oWJEyeKjkJERERERFSheETbgtjZ2cHPzw9eXl4G35aDgwPCwsJw+/Zt1KtXD3fv3mUHaUREREREZBF4RNuCNGzYECdPnsSYMWMqbJsDBgxATEyMttM1IiIiIiIic8dC24JYWVnB2dlZLx2glZS1tTVcXFzQs2dPvPnmm7Czs6uwbRMREREREYnAQtuCyGQyYdseO3Ys5s6dqx23m4iIiIiIyFyx0LYANjY2+Oqrr7BgwQJYW1sLy+Hp6Ym1a9di6tSpwjIQEREREREZGjtDswBWVlbo0KEDGjduLDSHvb09unTpgkePHgnNQUREREREZEg8ok1ERERERESkRyy0qcLVqFEDAwcOhL+/v+goREREREREesdCmypcq1atsGnTJg75RUREREREZonXaJMwo0aNQnBwMGbNmoUHDx6IjkNEREQVrHbt2vjoo4+gUDz7K2nTpk2fmjdq1Ci88sorT80vKCjA559/jjt37ugzJhFRqbHQJmHatGmDhg0bYtWqVSgoKEBWVpbBtuXg4FDuMbyzs7NRWFiop0RERESW6Z9t8ksvvYRhw4aVelSUNm3aFHtmXG5uLn755Rfk5uZq50mShKysLKhUqvIFJyIqBRbaJJSrqyt27tyJgwcPYuTIkZAkySDbmTp1Kt5+++1yr2PHjh16yUNERGSppkyZguHDhwMA7Ozs9Dr0qL29PTZu3Kjzw7hKpcIbb7yB+Ph4vW2HiOhFWGiTUHK5HNWrV0ejRo3QpUsXXLp0Cbdu3Sr3eq2trREaGgp7e3sAQGBgIGrVqlWudbZq1Qp5eXkAgPv37yMhIaHcOYmIiMydIdrkZ5HJZKhWrZrOPLVajbZt28LT0/OZj0tOTsa5c+cMkomILJNMMtQhRAPKzMyEq6ur6Bgmw97eHqdOnRI+jvaLSJKEyZMn4+uvvy73ujw8PBAbG6vt2Vwmk5V7nf/8V9mzZw9ee+01gx2BJyLTpVQq4eLiIjqGyWNbbz7c3d0RGxuLmjVrAtBPm1xaL2qv169fj6FDh1ZQGiIydSVp63lE28y99tprCA8Ph6+vr+goLySTyfTS+A4ePBht2rSBh4eHXhvzf66rQYMGWLRoEbZt24bjx4/rbRtERESmpnXr1ujXr98z77ezs4Onp6eQAvuJF207KCgIixcvBgDk5ORg8eLFePToUUVEIyJzJenZ3LlzpaCgIMnJyUny8vKSevXqJV25ckVnmby8PGncuHGSu7u75OjoKPXt21dKSUkp8TaUSqUEgFMJpsWLF+v7JTaoDz74QLK3t5dkMlmJn6NMJpPs7e0lBwcHycHBQVq/fn2F5X333XeFv8acOHEyrkmpVFbYZ5AobOs5/XMaP368vt9iQj148EAKCAjQfq8obrK2tha+3zlx4iRuKklbr/dxtCMjIzF+/HicOnUKBw4cQFFRETp16oScnBztMpMnT8auXbuwZcsWREZG4t69e+jbt6++o5AJeu+993D48GHUrl27xI/x9vbG3r17ERUVhaioKHTt2tWACYmIiG09mTM3Nzds27ZN+72iuGnkyJGiYxKRkdP7qeP79+/Xub1mzRpUrlwZ8fHxaNu2LZRKJVatWoUNGzZoxz9cvXo1Xn75ZZw6dQotW7bUdyQyIb6+vnBzc3vhUFze3t7a6699fHzQtGlTuLm5GT7gv/j7+yMoKAgXL17UdpRGRGTu2NaTKUtNTcXNmzd15nl6emp/5LeyssLLL7/83HUEBgYiJCREZ15KSopeOnQlIvNg8Gu0lUolgMcdYQBAfHw8ioqKEB4erl0mICAAfn5+iIqKKrbxLSgoQEFBgfZ2ZmamgVOTsevbt69Op2n6HBqkNN599128/fbbaNOmDS5evCgkAxGRaGzryZT89ttvmDRpks68wYMHY+3atSVex4gRIzBs2DCded999x0mT56sj4hEZAYMWmhrNBpMmjQJrVu3RsOGDQE8/rXPxsbmqaOP3t7eSElJKXY98+bNw6xZswwZ1ezUqlULgwcPfurXVlNgbW2N//znP0hNTX3mMiEhIcKK63+ysrKCtbW10A5eiIhEYltPpkatVqOoqEhn3pkzZ/D555+jV69eaNSo0QvXIZfLIZfrXoEZGhqKTz75RGfe+fPn8fvvv5c/NBGZHIMW2uPHj8eFCxfK3SvztGnTMGXKFO3tzMxMVK9evbzxzNpLL72EOXPmmGQBaG1tjQkTJoiOQUREJcC23rIpFApYWVmJjlEqMpkMCoUCarVaO+zXuXPncO7cOfj7+5eo0C5OSEjIUwc4NmzYgD179ujMkyQJarW6bOGJyGQYrNCeMGECdu/ejaNHj6JatWra+T4+PigsLERGRobOL92pqanw8fEpdl22trawtbU1VFQiIiIqA7b1ls3f3x8rVqwoVQemxqBfv35o0qQJPvroI5w8edKg23r11Vdx+PBhnXlRUVH44IMPDLpdIhJP74W2JEmYOHEitm/fjiNHjqBmzZo69wcGBsLa2hoRERHaMRcTExNx+/ZthIaG6jsOERER6Rnbesvl6emJypUrAwBq166NsLAwODg4AACSkpKQlZUFAHBxcdH58cWYVKlSBVWqVEGTJk2QlpaGGzduGOwIs5eXF7y8vHTmaTQaNGjQAJIkQaPR4MaNGzr9ExCRmdD32INjx46VXF1dpSNHjkjJycnaKTc3V7vMmDFjJD8/P+nQoUNSXFycFBoaKoWGhpZ4Gxxb88VTp06dJI1Go++Xl4qRlZUlNWzYUPhrzokTJ+OYLGEcbbb1ljt98MEHUlZWlpSVlSXl5OTovGavv/665OTkJDk5OUnDhw/X2/vNUHJzc6WLFy9KHh4e2ue3bt06g29XpVJp92FKSooUEBAg/HXlxIlT6aaStPV6P6K9bNkyAED79u115q9evRpvv/02AGDJkiWQy+Xo168fCgoK0LlzZ3z//ff6jmKRbG1t8frrryM4OFh0FCIiMlNs6y2HQqFAv3794OnpCQBo06YNnJycil02Ly8P2dnZAB5f8/ztt9/i1VdfRb169QAAt2/fxu7du9G6dWs0adKkYp7Ac9jb28PR0bHC+7OxsrLS7kMbGxsMGTIECQkJ+P3336HRaCo0CxEZkMF/tjMA/sr97Mnd3V26fv266JfIovCINidOnP45WcIR7YrAtt44JgcHB+ns2bMles169uz51OPXrl2rvX/v3r2STCaTlixZYqB3TendunVL8vLy0uatiCPaxTl27JhkbW0t/PXmxIlTySYhR7SJiIiIiIDHZzZs3boVAJCWlqbt5dtYeHl5Yd26dSgsLAQANGvWTHAiIjIXLLSJiIiISMvOzg5eXl6QyWSwt7eHtbV1qdfh4OAAT09PpKen4/79+0hJSdF2OPbo0SPcuXMH3t7eZVq3Ptnb26Nz585CMwCP93n16tXx4MEDZGZmio5DRHogFx2AiIiIiIxHaGgoYmNjERcXh+PHj6Nu3bqlXkfnzp0RFxeHuLg4HDp0CFWrVtXet3jxYoSFheHatWv6jG3SmjRpglOnTmHUqFGioxCRnrDQJiIiIiItGxsbVK5cGV5eXvD09ISVlVWp1/HkqLiXlxd8fX3Ru3dvtGvXDgBQt25ddOjQ4Zmdqlkia2treHl5oWXLlhg4cKC28zkiMl0stImIiIjIYJycnPD111/jww8/hEwmw9ChQ7F69WpUr15ddDSj079/f6xbt65MZxEQkXHhNdpEREREJs7GxgYzZsxAUVER5s6dC5VKVarHjxo1Cm3atAEA+Pr6lmnIq8mTJ2PAgAEAAH9//1I/nh6zsrLCjBkzcPr0aXz22WfajtqIyLSw0CYiIiIycVZWVmjTpg3y8/NLVSTb2NjA2dkZHTt2xMCBA8uVoUOHDuV6PD0ml8vRpUsX+Pv7Y9myZUhPT0dOTo7oWERUSjx1nIiIiMjE5efn44033sDw4cNRVFRU4sd16dIFcXFx6N69uwHTUVnUrl0bx48fx3//+1/RUYioDHhEm4iIiMiEBQQEwM/PD1FRUcjKynrh8oGBgahcuTIAoHXr1hV2mreXl5f2SC29mLW1Nfz8/NCsWTPtDyIPHjwQHYuISoiFNhEREZEJGzVqFEaPHo3WrVvj3LlzL1x+5syZ6NmzJwCU6VrssgoKCsKePXsqdJvmoFevXujZsye6d++O/fv3i45DRCXEQpuIiIjIhMlkslINwSWTyYQVuyyyy0bka0ZEZcNCm4iIiIgAAHl5eZAk6Zn3W1tbw9raugIT0RN2dnawt7dHXl6e6ChEVAIstImIiIgISqUSAwcOxN27d5+5zH/+8x9MmDChAlMR8PiI9pIlSzBmzBgMHDgQGRkZoiMR0Quw0CYiIiIyQW5ubggICICvr2+513Xt2jVcu3YN586dQ3Jy8jOXi4+PR1RUFBo2bAhnZ+dyb5dKrkaNGrC1tUVoaCiuXr2Ka9euiY5ERM/B4b2IiIiITFBQUBCOHDmCAQMGlHtdc+fOxWuvvfbcIhsAfv75Z3Ts2BFnz54t9zap9Hx8fPD777/j448/Fh2FiF6AhTZROezfvx9z585FWlqa6ChERGRh5HI5bGxsIJfLYW1tjbFjx+Kdd94pVcdoT2g0mhKNv63RaFBQUICffvoJ33//PQoLC8sSncrB2toagYGB+PTTT9GwYUPRcYjoGVhoE5XDvn37MG/ePBbaRERUoRQKhU5BrVAo8M4772DYsGFlKrRfRCaTQaFQQC6XQ6PRYPXq1fjuu+9YaAvSuHFjfPbZZ2jUqJHoKET0DCy0iYiIiEyIs7MzNmzYgAULFmiHfCooKMA777yD8ePHl+jIdGnVr18fBw4cwIgRI/S+biIic8RCm4iIiMhEVK1aFY0bN0ZoaKjOacMajQanT5/GuXPnnjs8V1k5OzujdevWCAoKQoMGDeDg4KD3bVDp+fn5ISAggEOuERkhFtpEREREJmLmzJn4888/UbVqVSHbHzFiBE6cOIGmTZsK2T7pmjVrFvbv3w9vb2/RUYjoX1hoE5XBrVu38O2337LXVSIiqlC2trZwcHDQnjL+PDKZDH369MGQIUN0jnju3r0ba9asQV5ennZeeHg4Ro0aBRcXl+eu09raGo6OjpDL+RXSGNja2sLDwwMjRoxAjx49RMchon/gONpEZXDx4kW8++67Bjk9j4iIqCxkMhlkMpm2bbKyssKkSZNQuXJl7Nq1CyqVCgCwcuVK7Nu3D926dYO9vT0A4M0330S3bt0QERGBrKys527nyfpLUuyT4Tk5OWHWrFnYvXs39u7dC41GIzoSEYGFNhEREZHJs7W1xTfffIPY2Fh8+OGH2qIaAKpVq4YtW7ZApVJBo9Fgzpw5xY6X7ezsjB9//FHnSPcTbm5uUCgU2LRpE9avX49hw4ahbt262kKdxAsODsauXbuwbNky7N69W3QcIotn8PN+vvjiC8hkMkyaNEk7Lz8/H+PHj4eHhwecnJzQr18/pKamGjoKERERGQDbesNzdHSEv78/nJycir1fLpejTZs2aN26NeRyOVxdXVGjRg3Y2dnByckJnTp1Qrdu3dCjRw94e3tDpVIhKSkJDx480K7D2toaHTp0QLdu3Z6aWrVqBZlMhvv37+Py5cto0qQJ2rZta5ChxKhsKleujG7duqFGjRqioxARDFxox8bGYsWKFWjcuLHO/MmTJ2PXrl3YsmULIiMjce/ePfTt29eQUYiIiMgA2NZXjE6dOiEuLq7E1+G+8847iI6ORvPmzYu9PzU1FZ06dcL06dNLlePJeps1a1aqxxERWRqDnTqenZ2NIUOG4IcffsDnn3+una9UKrFq1Sps2LABr7zyCgBg9erVePnll3Hq1Cm0bNnSUJGIyq2goAB79+7FiRMneH02EVk8tvWG5+DggG7duqFdu3bw8PB44fKenp544403EBoa+szl27dvD1dXVwBAkyZNSpXH3t6ep4sbueDgYDx48AD79++HUqkUHYfIYhms0B4/fjy6d++O8PBwncY3Pj4eRUVFCA8P184LCAiAn58foqKiim18CwoKUFBQoL2dmZlpqNhEz5WdnY3Jkyfj1q1boqMQEQnHtt7w3N3d8d1336Fy5colWr527dpYvXr1c5eZMmWKPqKRkXrrrbfQt29ftGzZkoU2kUAGOXV806ZNSEhIwLx58566LyUlBTY2NnBzc9OZ7+3tjZSUlGLXN2/ePLi6umqn6tWrGyI2ERERlRDbetKn7du346233kJiYqLoKGbBzs4OX3zxBWbMmMGh2IgE0ft/XlJSEt577z2sX78ednZ2elnntGnToFQqtVNSUpJe1ktUGllZWXj48CHUarXoKEREQrGtJ327fv06Dhw4gIyMDNFRzIJCoUCPHj3QqVMnFtpEguj9Py8+Ph5paWlo3rw5FAoFFAoFIiMjsXTpUigUCnh7e6OwsPCpD9LU1FT4+PgUu05bW1u4uLjoTEQVbcaMGXjllVeKHRKFiMiSsK0nfRs9ejRiYmLQtGlT0VGIiPRC79dod+zYEefPn9eZN3z4cAQEBODDDz9E9erVYW1tjYiICPTr1w8AkJiYiNu3byM0NFTfcYj05uHDh7h7967oGEREwrGtrxhBQUFo0KABbG1tRUcxOP64Yhju7u7o3r07Ll68iGvXromOQ2RR9F5oOzs7o2HDhjrzHB0d4eHhoZ0/cuRITJkyBe7u7nBxccHEiRMRGhrKXkiJiIhMANv6ivHJJ5/gtddeg0wmEx2FTFT9+vWxfft2fPrpp5gzZ47oOEQWxWC9jj/PkiVLIJfL0a9fPxQUFKBz5874/vvvRUQheqG4uDisWbMGMTExoqMQEZkMtvX6wSKbyksmk6FHjx7w9PTEkiVLcPPmTdGRiCyCTDLBwYAzMzO14z+SLnd3d8TGxqJWrVqio5iNDRs2YMiQIaJjEJGJUCqVPAVWD9jWAzt27ECvXr1ExyAzUVRUhM6dOyM6Ohq5ubmi4xCZtJK09eyGkIiIiIjIzFlbW2PVqlX45ZdfYG9vLzoOkdkTcuo4kSkoKCjAmTNncOXKFdFRiIjIgvj4+OCll16Ch4eH6ChkZmrWrAlJkhAWFobr16/j77//Fh2JyGzxiDbRM6SmpqJ3796YO3eu6ChERGRBXnvtNRw+fBitW7cWHYXMUK1atbB3716MHz9edBQis8ZCm6gYv/zyCxYvXozMzEyo1WrRcYiIyILI5XIoFAp2hEYGo1Ao0Lp1a3z22Wd46aWXRMchMks8dZzoHzQaDYqKirBhwwbs27dPdBwiIiIigwgJCUFwcDDi4+Nx69YtAI+/B/EAA5F+8Ig20T9s27YN7du3R1RUlOgoRERERAYlk8mwYMECHD16FEePHsX06dNFRyIyGzyiTYTHHZ9dvXoV8fHxOHXqlOg4RERERBUiICBA+/f9+/fRsGFDJCUlQalUCkxFZPp4RJsIwN9//41XXnkFixYtEh2FiIiISIhu3bohOjoanTp1Eh2FyOTxiDYRALVajdzcXBQVFYmOQmS2rKys8Prrr8Pb27vCt33+/HlERERU+HaJiEyJlZUVHBwc0LNnT1SqVAkbN25EVlaW6FhEJomFNlk8SZJERyAya096TraxscHUqVMRGBhY4Rl+/PFHHDp0SHub//dkrGQyGXsbJ+GGDh2KLl264I8//kB2djY/M4nKgIU2WTS1Wo33338fMTExyM/PFx2HyOw0adIEc+fOhZWVFeRyOerUqSMkR5cuXbQjCTx8+BATJ05Eenq6kCxEz1K9enV8/fXXqFevnugoRHB1dcXatWtx5MgRfPbZZ6LjEJkcFtpksTIyMnD//n0cPXoU8fHxouMQmRWZTIaqVauifv366NKlC+RysV2CVKtWDdWqVQMApKWloU6dOrhx4wbS0tKE5iL6J0dHR4SHh8PZ2Vl0FCLY2NigXbt2UKlUqFWrFu7fv8/TyIlKgZ2hkcX64YcfEBISgrNnz4qOQmR2nJ2d8dtvv2HFihXCi+x/8/Lywv79+7FgwQLRUYiIjF7btm0RGxuLgQMHio5CZFJ4RNuMtG7dGo0bN+Yv4S9w//597N+/H1FRUXj06JHoOERmp2XLlmjatCn8/PyM8vNIJpPBzc0NDRo0wLBhw3DixAlcu3ZNdCwiIqNkbW0Nd3d3tG3bVttpbGpqKv744w9eu030HDLJBP9DMjMz4erqKjqG0VmzZg2GDRsmOobRO3nyJNq3b88exokMZOXKlRg1apToGCX2zjvvYNWqVXpbn1KphIuLi97WZ6kssa0PCAhATEyMUf5ARfRPx48fR4cOHaBSqURHIRKiJG09j2iTxalXrx7Wr18PjUYjOkqJJCYmYvbs2VCr1aKjEBGRAcjlcsyYMQMhISGwt7cXHYfohQICArB+/Xps2rQJ27dvFx2HyCix0CaL4+HhgQEDBoiOUWIxMTFYuXKlzhF4lUrFHpPJ6Nja2sLV1dXkCgUXFxd4eXkhPT2dP2iREDKZDK+88gratm0rOgpRiXh6euL111/HjRs3cPz4cTx69IhHt4n+xbh6qCGipzRt2hSnTp1CXFycdtq8ebPJFTNk/jp06IC4uDj07t1bdJRSmTFjBg4dOoTq1auLjkJEZFLGjh2LU6dOoXHjxqKjEBkdHtEmMnI2NjbaYYmekCQJPXv2REFBASRJwqlTpzhMEQlnb29vksVqpUqVIJfLoVCwSSQiKg0XFxc4ODggPDxc+/l//fp1XLhwQXAyIvH4rYLIBPn5+WHz5s0AAI1Ggx49emDfvn2CUxEREZGlUSgUmD9/vvb2V199hcmTJwtMRGQcWGibgcDAQIwYMQItW7YUHYUEkMvlGDduHHr06KEzf/Xq1YiLixOUisi02Nvb49NPP0VsbCy++eYbDllDRFRGr7zyCr777judedHR0fj5558FJSISg4W2CZPJZHB0dESjRo0wbtw40XFIoH8X2QCQkJCAxMREAI87T8vLy6voWEQmw8bGBm+++SaqVKmCb7/9loU2VRgbGxs4Ojry0gUyG40bN37qmm03N7dn9k6en5/PIVfJLBmkM7S7d+/izTffhIeHB+zt7dGoUSOdI2uSJGHmzJmoUqUK7O3tER4ejqtXrxoiilmrXLky9u3bh//973+io5ARmj17NmJiYhATE4PFixeLjkNEZoZtvX4MHz4cJ0+eRLNmzURHITKY7t27a7+T/Hvq37+/6HhEBqH3n08fPXqE1q1bo0OHDti3bx+8vLxw9epVVKpUSbvMggULsHTpUqxduxY1a9bEjBkz0LlzZ1y6dAl2dnb6jmSWGjRogICAADRs2BBubm6i45AR8vX1ha+vL4DH/5ft2rXD1atXce/ePcHJiMjUsa3XH09PTwQEBIiOQWRQrq6ucHV1Lfa+Fi1a4O7duzrzbt68idu3b1dENCLDkfTsww8/lMLCwp55v0ajkXx8fKQvv/xSOy8jI0OytbWVNm7cWKJtKJVKCYBFT9u2bZNUKlW5Xy+yDBqNRlKpVNLYsWOFv3c5me/Up08f0W/1cjt48KAkl8vLtR+USqXop2FwbOv1N02fPr3crweRKVOr1ZJKpdKZpk2bJvx/kxOn500laev1fkR7586d6Ny5MwYMGIDIyEhUrVoV48aNw6hRowAAN27cQEpKCsLDw7WPcXV1RUhICKKiojBo0CB9RzIrwcHB6NWrFxo0aAArKyvRcchEyGQyWFlZoVevXtqj3P+k0Wjw448/IikpSUA6IjI1bOuJSF/k8qevZO3cuTMcHBx05p08eZIjrJBJ0Xuh/ffff2PZsmWYMmUKPv74Y8TGxuLdd9+FjY0Nhg0bhpSUFACAt7e3zuO8vb219/1bQUEBCgoKtLczMzP1HdtkNG/eHB9//LHoGGSiOnfujM6dOz81v6ioCBEREUhNTQUAqNVqqNXqio5HRCaCbT0RGVK7du3Qrl07nXlLly5FRESEzjyNRgOVSlWR0YhKTO+FtkajQVBQEObOnQsAaNasGS5cuIDly5dj2LBhZVrnvHnzMGvWLH3GJKJ/UCgUWLZsGbKzswEAmzZtwpIlSwSnIiJjxbaeiCra66+//tRQtnv27MHs2bMFJSJ6Pr33Ol6lShXUr19fZ97LL7+s7dDAx8cHALRHzp5ITU3V3vdv06ZNg1Kp1E6WeHqrra0tGjZsiKpVq4qOQmZIJpOhfv36CA4ORnBwMJo3b44mTZrA2dlZdDQyIRkZGThz5gwePnwoOgoZGNt6IqpoPj4+2u8pT6agoCA0bdoUTZs2RYMGDWBtbS06JpGW3gvt1q1ba8fufeKvv/5CjRo1AAA1a9aEj4+PzqkfmZmZiI6ORmhoaLHrtLW1hYuLi85kafz9/REREYEPP/xQdBSyAIMGDcLJkyef+T9JVJzIyEi0atUKO3fuFB2FDIxtPREZg27duuHkyZM4efIk9u7di8qVK4uORKSl91PHJ0+ejFatWmHu3Ll4/fXXERMTg5UrV2LlypUAHh85mzRpEj7//HPUqVNHO+SHr68vevfure84ZkMmk8He3p6/1FGFUCgUUCgUGDBgAPz8/PDLL78gPz9fdCwychqNBnl5ebxezgKwrS8/Hx8fDBo0CGFhYaKjEJksKysr2NvbAwDc3d3xn//8B0qlUnt/YWEh1q9fj/T0dFERyZIZopv+Xbt2SQ0bNpRsbW2lgIAAaeXKlTr3azQaacaMGZK3t7dka2srdezYUUpMTCzx+i1lyI8nk0wmk+rXry9lZmbq+6UieqEbN25IXl5eklwuL/ewR5wsY1qxYoWkVqtFv3XLhMN7lRzb+vJNwcHBUkFBgb5fFiL6h8zMTKl+/fra7zAymUz4/z4n85hK0tbLJEmSYGIyMzOfOei9uZHL5fjyyy/RsmVLhISEcEgvqnD5+fmIjo5GYWEhgMcdFh0+fFhwKjJmAQEBCAgIwDfffINq1aqJjlMqERER6NSpEzQaTZnXoVQqedqzHph7Wx8cHIxjx47BxsZGdBQis6VWqxEdHY2cnBwAwOrVq7Fx40bBqcgclKSt1/up46RfMpkMQUFBaNWqlegoZKHs7Ox0htjYu3cvbty4gTt37vAUYSrWlStXcPfuXVy5cgVyubzYsduJiIgMzcrKSuc79Pnz5xETEwPg8ZCCd+/ehQkecyQToffO0IjIvM2ZMwd//vnnM3sOJgKA7Oxs9OvXD+PGjSvX0WEiIiJ9GTt2LGJjYxEbG4v169fDzs5OdCQyYzyiTUSl4uTkpO3E55/DOKlUKuzatQsZGRniwpHRkCQJmZmZSExMxE8//QS5XA4rKyv06NEDHh4eouMRCfPk/yAoKIiXgxFVMHt7e23naTVr1sSwYcNQUFAAAPjzzz9x9+5dkfHIzLDQJqJSc3Z2xpdffqkzLzs7G/Hx8Sy0SceVK1cwatQoAI8vQzh+/DgLbbJoNjY2+Oyzz9C0aVPRUYgsWvXq1bFs2TIAj0fN6Nq1Kwtt0iueOk5EemFnZ4dFixZh8+bN2Lx5M/r06SM6EhmZwsJCfPTRR/joo49QVFQkOg4RERGAx50PT58+HUuXLoWjo6PoOGQmeETbiDk6OsLNzY09kpJJUCgU6NKli/b2zZs3ERUVBQAoKirSOc2cLJNGo8HBgweRkpKCsWPHwtbWFjKZDJUqVeLnHBERCdW2bVv4+/vj+++/156dl5GRgfz8fLHByGTxiLYRGzlyJGJiYtC8eXPRUYhK7Z8djmzatEl7TRRRYmIiWrVqhaCgILRo0ULbAywREZFIVatWxaFDh7TfX1599VXRkciE8Yi2EXN2duawOGSynJ2d4ezsDOBxR2mvvfYaLl68iAsXLghORqIVFRXh3r17AB6frvekIxoiIiKRrKysUKVKFe3ttm3bajstTE5ORnR0tKhoZIJ4RJuIDM7f3x+bNm3CyJEjRUchIiIiKpH//ve/2L59O7Zv345p06aJjkMmhke0iajCdOzYEcuXLwcAPHz4EHPnzkVOTo7gVCRKp06d0L9/f9SrV090FCIioudq2rQpVqxYAUmSkJ+fj3nz5iE1NVV0LDJiLLSJqMI0atQIjRo1AgDcunULP/zwg844spIkITs7G5IkiYpIBubo6Kh9zVu2bKkd+ovIEtja2sLFxYXjZxOZoBo1amD06NEAHg9pum7dOuTl5QEA8vPzUVhYKDIeGSEW2kQkRNWqVXHw4EGo1WrtvIcPH6Jv375ISUkRmIwMxcbGBj///DMaNmwIAHB3dxeciKhiTZo0CSNHjoSfn5/oKERUDg4ODti6dau2uF68eDFWrFghOBUZGxbaRCSEQqFA7dq1deZlZGSgbdu2SEtLAwD89ddf2k6zyLTVqlULL730Eho2bIi6deuKjkMkhJeXF+rUqSM6BhGVk1wuh7+/v/Z2UFAQEhMTATw+2p2QkACNRiMoHRkLFtpEZDTc3NywceNG7anjEyZM0F7TTabtnXfewQcffMBTZomIyOyMHDkSw4cPBwCcPXsWYWFh2tPKyXKx0CYioyKX/99gCH369EGNGjUAADdu3MCPP/7IX4hNTO3atTFy5Eh06NCBRTYREZklmUymbeOqVauGOXPmICIiAvv27ROcjERioU1ERqtTp07o1KkTAOD48eNYv349VCoVAKCwsJCdppkAPz8/HskmIotUWFgIuVwOhYJfty1J5cqVMXXqVFhZWeHQoUMAHnf2ys7SLA/H0SYik9C0aVMcPXoUJ06cwJEjR9CgQQPRkYiIiIqVkpKCbt26Yfbs2aKjkCCDBw/GiRMncOLECfz6669wdnYWHYkqGH9iIyKT4OTkhObNmwMAioqKEBgYCBsbGwBAWloa7ty5IzIe/YtcLkdAQADq1q0LmUwmOg4RUYUqKCjAmTNnYGNjg4SEBNSsWROVKlUSHYsqkLe3N7y9vbV/BwYG4saNG7h165bgZFRReESbiEyOtbU1Vq5cqf2leOLEiaIj0b84OTlh06ZNWLp0qc5190REluTPP/9E69at8eeff4qOQgJVrVoV+/fvx7Rp00RHoQrEI9pEZJKeHM0GgNDQULz//vvYsmULbt68KS4UAQA6d+6MkJAQVKlSRed1IrJ0hw8fhkwmw5tvvonKlSuLjkMG5OrqinfffRc5OTkAgHr16glORCLJZDLY2toiMDAQH3zwAQAgJycHa9euRXZ2tuB0ZCgstInI5LVp0wZhYWG4cOECbt++DeBxxyPsLK3i/POodf/+/fHOO+8ITFM2Go2GvdqTQe3ZsweHDh3CK6+8wkLbzLm5uWHmzJnPvP+fnzU868dyBAUFISgoCACQmpqKnTt3Iicnh99XzBQLbSIyCzKZDHPnzsXUqVMBPD5db8GCBYJTWQZ3d3csW7YMHh4eAICXX35ZcKLSy87Oxvjx43Hu3DkW20RkUDExMZg+fTokSYK9vT2+/fZb7VCWZDkqVaqEDRs24NChQ/j0009FxyEDYKFNRGajadOm2r8zMzPx0ksvAXh85OD27dvaocGo7KytreHn56fTwVnlypXRvn17kz5Cp1arcfLkSVy7dk10FCIycw8ePEBERAQkSYKjoyOysrJERyIBbGxsEBYWhvz8fNStWxepqalQKpWiY5Ee6f1cFbVajRkzZqBmzZqwt7dH7dq1MWfOHJ1TIiRJwsyZM1GlShXY29sjPDwcV69e1XcUIrJgPXr0QFxcHOLi4vDHH3+YdBFoTKpXr46IiAjtvo2Li8O+ffvg5eUlOhpVILb1RET60b59e8TExKBPnz6io5Ce6f2I9vz587Fs2TKsXbsWDRo0QFxcHIYPH67tFAIAFixYgKVLl2Lt2rWoWbMmZsyYgc6dO+PSpUuws7PTdyQiskDW1tZwdXUF8Pj6tyFDhuDMmTM4cOCA4GSmp2HDhggJCQHw+Oi1l5cXHBwcBKfSn+PHj+P06dPIzMwUHcVksK0nItIPhUIBV1dXvPLKK9BoNPj99995ZNtM6L3QPnnyJHr16oXu3bsDAPz9/bFx40bExMQAePwL91dffYVPPvkEvXr1AgD8/PPP8Pb2xo4dOzBo0CB9RyIiC+fs7IwFCxZg586dOHjwIDsdKaWuXbua9fXua9aswapVq0THMCls64mI9Gvo0KHo1asXYmJiWGibCb2fOt6qVStERETgr7/+AgCcPXsWx48fR9euXQEAN27cQEpKCsLDw7WPcXV1RUhICKKioopdZ0FBATIzM3UmIqLSatGiBbZs2YKtW7di3bp1qFq1quhIRsna2hpffPEFtm7diq1bt2Lo0KGiI+nVo0ePMGrUKPTv3x/9+/dHRESE6Egmh2192RUWFuK///0vpk2bxn4jLFTz5s2xZcsWdO3aFfn5+ZgyZQo++eQTqNVq0dFIMAcHB3z99df47LPP2Bu9GdD7Ee2PPvoImZmZCAgIgJWVFdRqNf73v/9hyJAhAICUlBQAgLe3t87jvL29tff927x58zBr1ix9RyUiC1OlShX069cPwONepn/44QdtD9NZWVkWPZaljY0N3N3dIZPJYGNjgy5duqBJkyaiY+lNXl4eMjIyAPzfkCppaWliQ5kwtvVlp1arERERgaysLIt4vvS0SpUqoVWrVtizZw/UajUOHDiA3NxcaDQaWFlZiY5HAikUCnTq1AlOTk748ccf8ejRI+1Y7GR69P5Tya+//or169djw4YNSEhIwNq1a7Fw4UKsXbu2zOucNm0alEqldkpKStJjYiKyRI6Ojti6dSvi4+MRHx+PkSNHio4kVFBQEGJjYxEfH49Tp06hfv36oiPp1W+//YbAwEAEBgaic+fOePDggehIJo1tPVHZHT9+HEFBQdi8ebPoKGSknrTJI0aMEB2FykHvR7Tff/99fPTRR9rrrxo1aoRbt25h3rx5GDZsGHx8fAA8PqJQpUoV7eNSU1N1hub5J1tbW9ja2uo7KhFZMJlMptNTdkhIiPZod0ZGBo4cOWIRp/EpFAq88sorCA0Nha+vr9meqpaXl4fk5GTRMcwG2/qys7KyQvv27dGiRQuz/X+j5ysoKEBycjL7C6FnsrGxgY+PD1q2bIk7d+7gyJEjePTokehYVEp6/4TPzc19quGwsrLSnp5Zs2ZN+Pj46FwTl5mZiejoaISGhuo7DhFRiQwePFh7TfLChQthY2MjOlKFcHR0xDfffMPrwahU2NaXnY2NDRYuXIh58+ZBodD78Q4iMiNvvPEGNm7ciNq1a4uOQmWg90/4nj174n//+x/8/PzQoEEDnD59GosXL9ae+iCTyTBp0iR8/vnnqFOnjnbID19fX/Tu3VvfcYiISs3Pzw/ff/+9zhHt+/fvY86cOcjNzRWYTD+aNm2K8ePHQyaTwdra+qnraM1JWloaPv/8c5w+fVp0FLPCtr7sCgsLMXv2bAQFBeHDDz/kNblmaOnSpbh79y5mzJgBJyen5y5ra2uLjz/+GM2bN+cPL1Qsa2trfPLJJ0hISMC8efNQVFQkOhKVlKRnmZmZ0nvvvSf5+flJdnZ2Uq1ataTp06dLBQUF2mU0Go00Y8YMydvbW7K1tZU6duwoJSYmlngbSqVSAmD20/Tp0/X98hBRGd24cUPy9/eXXF1dJVdXV8na2lro54OdnZ02S2mnN998U/TurBBZWVlSXFyc5OLiUqGvjVKpFP3UDY5tffmn4OBgnf1F5kGj0Uhdu3aVatSoIT148KDYZf744w/Jzc1NcnV1lXx9faXLly9XcEoyRWfPnpV8fHwkOzs74Z9fnErW1sskyfQuEMnMzISrq6voGAY3ffp0fP7556JjEBEAlUqFpKQk7VHud999F/v27ROWZ+rUqRgzZkyZHuvk5KS9htZcaTQavP322zh69CiSkpK0pzRXBKVSCRcXlwrbnrky97Y+ODgYx44ds5jLVCyFJEno3r07Ll26hPj4eHh4eDy1TG5uLu7duwcAkMvlqFatGt8H9EKFhYVISkrCDz/8gPnz54uOY/FK0tbzHBUiohJQKBSoWbOm9narVq1QWFgoLE9gYCBeeuklYds3RllZWYiLi4NGo4FGo8H58+dx69Yt0bGIyELcuXMHV65cwcOHD5+7nIODAz+/qdRsbGxQu3ZtNG/eHB07dsTp06eRnp4uOhY9BwttIqIymD59Oj7++GNh25fJZMK2baz++usv9OjRA/n5+QBQoUexiYh27NiB9957DxqNBjVq1BAdh8zUgAED0KdPH3Tr1g0HDx4UHYeeg4U2EVEZyGQyFrtGQqVS4bvvvkN8fDwKCgpYYBOREJIk8fOHDE4mk8HKyorfQUwAC20iIjJZKpUK2dnZWLNmDc6cOSM6DhFZCJVKBZVKBVtbWxY8RFQsDppKREQm6/vvv0eHDh2QmJgoOgoRWZCffvoJ7dq1w/nz50VHISIjxSPaRERkMtRqNS5duqS9Djs+Pp5HsomowslkMsjluservL29ERQUhKtXrxb7GJVKhUuXLqGgoAAAUKNGDVSuXNngWcn8yGQy1K1bF48ePQIAPHjwADdv3hQbip7CQpuIiExGdnY2Bg8ejGvXrgF4/MWViKiijRgxAm+99ZbOsFz9+vXDa6+9hj59+uDy5ctPPSYjIwP9+vVDUlISAGDx4sUYN25chWUm8yGTybBkyRJtnwBr1qwp85CfZDgstImIyCTs378fp06dQkpKivaIEJGpunfvHhYsWIC2bduibdu2ouNQKVlZWcHKyqrYeQMHDkRqairs7e1x4cIF7N69GwCQk5ODBw8eaD+/9u/fj/z8fLz11lvw9PQEABw/fhzHjx8HAHh5eeGtt96CtbV1BT4zMhX/fF/wPWKcWGgbMY1GA7Va/dQHORGRJXnSk+9vv/2GH3/8UXQcIr24c+cOZsyYgenTp7PQNjNvv/02gMeXuiQkJGDatGnFLrdr1y4cOnQInTp10hbaBw4cwOzZswEADRs2xODBg1lEETQaDSRJeu79ZHxYaBuxDRs2ICYmBosXL0bjxo1FxyEiEuLYsWP47LPPcOXKFdFRiIhKJDU1Ff/5z3/YUSOVW1FREd59993ntoHJyckVmIhKioW2Ebt16xbu3LmDjIwM0VGIiCqcWq3GrVu3cPbsWRw+fFh0HCKiElOr1UhJSYFGo0HdunWRnJyMrKws0bHIiKWmpkKpVD41v7CwEMePH8eFCxcEpKLyYKFNRERG6cGDB+jatau24yAiIlNRpUoVHDhwQHu67zvvvIMtW7YITkXGbN68eVi9evVT8yVJQk5OjoBEVF4stImIyChpNBpkZWUhLy9PdBQiIh3x8fGIi4sDALi7u6NPnz5QKP7va7VMJoOzs7P29j/ve56goCC888472LVrl34Dk94cP34cFy9e1Pt64+PjkZmZqff1kjgstImIiIiISmH37t347LPPADzutKxr165wcnIq93p79uyJLl264NKlS8jMzGQnV0Zo/fr1WL58uegYZALkogMQERH924IFCzBixAikp6eLjkJE9JSBAwdi69atqFev3nOXi4yMRJ8+fXDs2LESrXfTpk3o378/rly5glu3buGNN97AqlWr9BGZ9GTMmDHYsGEDqlatKjoKGTke0SYiIqORm5uL9PR0HDlyBPv37xcdh4ioWAEBAXjppZewbt06ZGZmQi4v/thVUlISduzY8cL1FRYW4sGDB4iJicHOnTu183ft2oWaNWvqKzbpQZMmTVC7dm0sX74cBQUFePDgQbnWZ2dnBw8PDwCPL5m6f/8+VCqVPqKSYCy0iYjIaOzYsQNTpkzhaAtEZPQUCgV++uknSJIEe3v7cq3rzJkz6Nu3Lz/7TISjoyO2bduGo0ePYsCAAVCr1WVeV4cOHbSdoGVlZaFr1664du2avqKSQCy0iYhIuOzsbBw4cABHjx5Famqq6DhERCXi7u7+3Ptr1KiB119/HadOncLt27eful+lUuHPP/9ETk4OUlJSylWwUcWRyWTw8PBAvXr1MGDAAJ1r6TMyMhAREaHzWjo6OuLVV1+FjY0NACAqKko7ooatrS28vb0BAPb29rCysqrAZ0KGxEKbiIiES05OxogRI3g0h4jMSps2bdCmTRu88cYbxRbaBQUFmDp1qoBkpA/169fHxo0bdeadOXMGrVq10hkxw8fHBz/99BMqVaoE4PE1/hy60vyx0DZyGo0GX3zxBfbv34+ZM2fCzs5OdCQiIr2RJAkLFy5EVFQUxwklIrPx8OFDzJo1C1lZWQCA6OhowYmoovj5+WHFihVQq9XQaDRYtGgRkpKSMH78eLz66qsYPny4zvIJCQkYPnw4hg0bhtatW2PevHlQKpXa+4uKijB37lxoNBpMnz4dERER+PXXXyv6aVEZsNA2cpIkYd++fbhx4wamTZvGQpuIzEZ+fj5ycnKwZ88eREZGio5DRKQ3eXl52Lt3L1JSUvgjooVxd3fH0KFDATw+YLZ7924kJydj//798PT0fKrQvn37NtasWYOWLVuiffv26NOnj879hYWF2LhxIzQaDd566y0UFBTgwIEDyMrKKrbTNJlMBhcXF20HfTk5OSgsLDTQs6XnYaFNRERC/Pzzz5g/fz6Sk5NFRyEi0isfHx8cPHgQ27Zt46nhFkwul+O7775Dbm4uAMDFxaXU67CxscHPP/8M4PH13EOHDkWXLl0wfPhwnDhx4qnlPTw88Pvvv2uv+/7kk0+wadOmcjwLKisW2kREVCE0Gg1iYmKQmZkJAIiJicHff/8tOBWRWH///TcOHDiAoKAg7fWbZPpUKhVu3rzJzh0JVapUKfc6qlWrpv3bzc0Nrq6uaNOmDRwdHZ9a1t3dHfXq1dMOGRYaGorU1FRER0drC36qGMUP+vccR48eRc+ePeHr6wuZTPbU2ICSJGHmzJmoUqUK7O3tER4ejqtXr+osk56ejiFDhsDFxQVubm4YOXIksrOzy/VEiIjIuBUVFWHixIno2rUrunbtip9++kl0JHoGtvUVZ9OmTejevTsuXLggOgrpUVpaGl5//XV8+eWXoqOQGZLJZJg7dy727dv31LRhwwZtkQ0AEydOxG+//aZTrFPFKPUR7ZycHDRp0gQjRoxA3759n7p/wYIFWLp0KdauXYuaNWtixowZ6Ny5My5duqS9vnjIkCFITk7GgQMHUFRUhOHDh2P06NHYsGFD+Z8REREJl5+fj6+//hr379/XzlOpVEhKStIZBoWME9v6iiNJEjQaDSRJEh2F9IivKz3P0KFDERwcrDMvNDS0VOuQyWSQyWQlWs7R0REffvghYmNjsWLFCr4vK4pUDgCk7du3a29rNBrJx8dH+vLLL7XzMjIyJFtbW2njxo2SJEnSpUuXJABSbGysdpl9+/ZJMplMunv3bom2q1QqJQAWNdWrV09KTU2VCgsLy/OSEREZjEqlknJzc6Xc3FwpOTlZeumll4R/doqYlEql6JdCr9jWG36ysrKSIiMj9fOCkVG4efOm5OHhUezrLZfLJXt7e0mhUDz3fSGTySR7e3vpv//9r+inQ2bi8OHDkpWVlfDPPHOYStLWl/rU8ee5ceMGUlJSEB4erp3n6uqKkJAQREVFAXg8QLubmxuCgoK0y4SHh0Mulz9z6IOCggJkZmbqTJbm5s2b6NixI+bPny86ChFRsSIjI9GqVSu0atUKr776KscINVNs64nKp1WrVjh58iT69+//3OVq166NQ4cO4b333qugZESkT3rtDC0lJQUAtL3cPeHt7a29LyUlBZUrV9YNoVDA3d1du8y/zZs3D7NmzdJnVJNTUFCACxcuICwsTHQUIiLcv38fN27c0JkXFxeHM2fOiAlEFYZtPVHZKBQKNGjQAC1atEDTpk3h5eUFuVyO+vXrw8HBAQBw584dJCcno169emjWrBmaNm3KoV2JTJRJ9Do+bdo0TJkyRXs7MzMT1atXF5iIiMiy7d69G2PGjNGZx2uvqTzY1pO5c3Nzw9atW+Hv76+dZ29vj3Xr1qF+/foAgNmzZ2PBggVYvnw5WrVqBWtra0Fpiai89Fpo+/j4AABSU1N1urJPTU1F06ZNtcukpaXpPE6lUiE9PV37+H+ztbWFra2tPqMSEVEJnTp1CgcPHtSZFx8fj8LCQkGJSCS29URlk5ubixUrVsDV1RUAEBsbC+DxkW4bGxsAQIcOHWBlZYWaNWuyyCa9q1GjBj7++GMcOHAAp06dEh3H7Om10K5ZsyZ8fHwQERGhbWwzMzMRHR2NsWPHAnjco15GRgbi4+MRGBgIADh06BA0Gg1CQkL0GYeIiMpIrVZr/46MjMSMGTMEpiFjwrbeMNRqNdRqNaysrERHMTnS/+/h+wlj3Ye5ublYuHCh9rZcLoezszPk8v/rMqljx47o2LGjiHhkAWrWrIlPP/0UBQUFLLQrQKkL7ezsbFy7dk17+8aNGzhz5gzc3d3h5+eHSZMm4fPPP0edOnW0Q374+vqid+/eAICXX34ZXbp0wahRo7B8+XIUFRVhwoQJGDRoEHx9ffX2xIiIqGyefC5fuXIFAHD79m3Biaiisa2vWGq1GpMnT0bjxo2xfPly7fW6VDIxMTH48MMPIUkS7OzssGzZMtSqVUt0rBeaOHEi+vfvr3MqOZEhnT59GlOmTMH169dFR7EIpS604+Li0KFDB+3tJ9dTDRs2DGvWrMEHH3yAnJwcjB49GhkZGQgLC8P+/ft1OnJYv349JkyYgI4dO0Iul6Nfv35YunSpHp4OERGVRW5urragLigowMmTJ3HhwgXBqUgUtvUV7+zZsygoKNA5m4RKJj09HUePHoUkSXBwcEBOTo7oSCXi5OQELy8vKBQm0WUSmQGlUoljx47xc6aCyCTJ9EYsz8zM1F7fYmnGjBmDZcuWiY5BRGbm2LFjeO2116BSqQA8LrzZuVnZKJVKuLi4iI5h8iyxrQ8ICEBMTAycnZ1FRzEp+/btQ/fu3bWF9qlTp9CoUSOhmW7duoXAwEA8fPjwmcvY2tqiUqVKOHToEF5++eUKTEeW6siRIwgPD2ehrQclaev5ExoRkYWKjIzExYsXAQB//fUXMjMzWVwTCfTo0SP88MMPCAoKQtu2bUXHMTlhYWEICgqCh4eH6ChwdnbGiBEjkJCQgIiICACAnZ0dBgwYgPT0dOzZswcFBQXIyspi0UNkplhoExFZqA0bNmDlypWiYxDR/5eamoqpU6dizJgxLLTLYMCAAXj33XdFxwAAuLu7Y8GCBfjll1+0hbaTkxPmzJmDixcvYu/evTDBk0rJxPE9V7FYaBMRWYD58+fjxIkTOvPOnTsnKA0RifT5558jJiYGANC2bVv897//FZzIfLVv3x47d+7EokWLtGcQ/VN+fj4mTpyIkJAQ/O9//zPaHtPJtOXm5mLq1Kk4c+YMz1yrQCy0iYjMzP3795Gfn68z79ixY9izZ4+gRERUGtnZ2bhz5w48PT11Opj7t4KCAty/f1/nKJWtrS0qV6783PXHxMRg165dAB4PMTVw4EB4eHiwt3MDqFatGqpVq4YDBw4gIyPjqUJarVbjyJEjKCoqgkajeWGhrVarkZqaCjs7O7i7uxsyOpmRoqIiHDp0CH/99ZfoKBaFhTYRkRnRaDQYP348IiMjdeYrlUpBiYiotH777TccOHAAa9asQZcuXZ65XFRUFAYPHqxzhCowMBC///47rK2tS7St/fv3IygoCEuXLsXAgQPLnZ2K9/nnn6OwsBDu7u7lOpvo3r176NSpE8LDw/HNN9/oMSER6RsLbSIiE3Tu3LliT0OUJAmXL19GWlqagFREpA95eXnIy8tDQUFBsfcXFhbijz/+wMmTJ5GamqpzRPvq1avYtGkTFAoF5HI5XnnlFXh5eT1zWwUFBUhLS3vqLBhT4uvri0GDBqFu3bqiozyTvkYisLe3R9u2bVG/fn29rI+IDIeFNhGRCdq0aRPmzZsnOgYRCZCdnY1Jkybh77//fuq+a9eu4a233gIAKBQKREREPLfQNgdNmjTBhg0bRMeoEJ6enlixYoXoGERUAiy0iYiM3Nq1a3H48GGdefHx8YLSEJFoTk5O+PLLL5GVlaWdV1hYiDlz5iApKUk7T61WY968efjpp590Hn/69Omn1vnDDz8gOjoas2fPhqenp+HCE1GFWrt2Lf744w+kpKSIjmJxWGibCCsrK7i6usLR0VF0FCKqIEVFRcjKysLhw4exdu1a0XGIqIJlZWUhIyMDrq6ukMlk2vk2Njbo27evzrJ5eXn45ZdfoFQqkZmZCeDxpST79+8v0bZOnDiBy5cv4/333ze5QvvJZ6WDg8NzO48zFtbW1vDw8EB2drZJn7JPpiEqKgobN24UHcMiyUUHoJLx9/fHkSNHMG3aNNFRiKiCHD58GIGBgdi2bZvoKEQkwNSpU9G1a1ekp6e/cFk7OzusX78ea9asKXFHaObi5MmTaNGiBTZt2iQ6SomEhYUhNjaWnc8RmTke0TYR1tbW8Pf3h7Ozs+goRGRAZ8+e1Z7edfLkSdy8eVNsICISJi0tDTY2NlCr1UhJScHZs2cBPP5OEBoaCnt7e+2yMpkM1apVw927d3WOflsCR0dH1K1bF5UqVRIdpUTs7e3h7+8PFxcXWFlZoWXLlggODoZczuNfROaEhTYRkRGZN28efv31V9ExiMjIREZGYvDgwQAAd3d3xMbGombNmoJTGYegoCDs3bvXJH9gsLOzw/Lly9GgQQOTzE9Ez8ZC28jJ5XKMGzcOLVq0MInrjoiodB4+fIhFixYhLy8PwONOzv45VA8RWbaMjAzMmDEDSUlJ2s8GSZKe+TlRo0YNLFy4EPv27cO+fftKvJ3Bgwejbdu28PDw0Evu4ly+fBk//PCDTnZ/f39MmDABVlZW5Vq3KRWply9fxsqVK3H06FHtPFPKT6bh/Pnz+Omnn3DixAnRUSwWC20jJ5PJMGDAALRt21Z0FCLSs4KCAiQnJ2PZsmXIyMgQHYeIjFB2djZWrlypM0+SJOTm5qKgoAC2trY69/n4+GDixIlQKpWlKrQ7dOiAIUOGAECx69WHpKQkrFy5UqfQDg4Oxrhx48pdaJuS27dv44cffjDYfiYCHg/199VXX4mOYdFYaBMRCSBJEt59911ERkbqDNFDRPQimZmZ6N+/P9q3b49ly5bp5Wjo7NmzsXTpUgCPO+v6/vvv9X6UNTQ0FFFRUTrzHBwcoFBY1tfRVq1aISoqCvPmzcPOnTtFxyEiA7GsTzYTU7VqVW1nGURkXiRJwo0bN5CYmCg6ChGZGLVajcTERNSoUeOZy1StWhUhISG4dOlSiX7Mu3PnDu7cuaN9rCE4OzujUaNGBlm3KXmyH4KCgpCSksKhW4nMFLs3NGJDhw7F4cOH0aRJE9FRiIiIyIQMGzYMhw4d4ncII/bee+/hjz/+gL+/v+goRGQAPKJthHx9fTF8+HB06NDB4sbCJCIiovKTy+Wws7PD8OHD0ahRI6xatQqFhYXPfYydnR1Gjx6NoKAgds5VAaysrCzq2nQiS8NC2whVq1YNM2fOhI2NjegoREREZKQkSUJRUZF2/OV/X+ssl8sxYsQItGrVCps2bYJKpYJGo3nm+hwcHDBp0iQOG0Zk4lQqFVQqlegYFo+FNhEREZEJio2NxSuvvALg8dHoFStWoHbt2k8tV6NGDezduxdbt27FokWLKjomEVWg9PR0jBw5EleuXBEdxeKx0DYiMpkMtWrVQq1atXjKFhERET1XRkaGdoxce3t75OTkFLucvb09WrZsiZs3b6JBgwa4ffs2RzsgMlOFhYWIjY3F3bt3RUexeOwMzYjY2dlh3bp1+Omnn3htNhEREelVv379EBUVhbCwMNFRiIjMHo9oG4nWrVsjODgY1atXh729veg4RGRAp0+fxrFjx3D79m3RUYjIDISFhaFFixbw9PR87nLW1tawtrZG79694e3tjc2bNyMvL097f35+PtauXYvmzZvjtddeM3RsIiKzVuoj2kePHkXPnj3h6+sLmUyGHTt2aO8rKirChx9+iEaNGsHR0RG+vr546623cO/ePZ11pKenY8iQIXBxcYGbmxtGjhyJ7Ozscj8ZU9anTx8sXrwY1apVEx2FiAzs0KFDeO+99ziGNhkttvWmpU+fPli0aBF8fX1LtPzo0aMxe/ZsODs768zPzc3F7NmzsWzZMkiSZIioREQWo9SFdk5ODpo0aYLvvvvuqftyc3ORkJCAGTNmICEhAdu2bUNiYuJTv4oOGTIEFy9exIEDB7B7924cPXoUo0ePLvuzICIiIr1hW29aVq1ahX79+uHmzZvlWo+TkxN++OEHzJo1i33FEBGVl1QOAKTt27c/d5mYmBgJgHTr1i1JkiTp0qVLEgApNjZWu8y+ffskmUwm3b17t0TbVSqVEgCzmOzs7CQ/Pz9p5cqVZX4diMi0LFy4UPhnDyfDTUqlUvRbTK8AtvWmMNnZ2Un79u2TkpOTJUmSpIyMDOnWrVtSfn7+U/s2LS1NioqKkjw8PHTW4e7uLv39998lfGcQkbG5f/++FBsbK3l7ewv/TDL3qSRtvcE7Q1MqlZDJZHBzcwMAREVFwc3NDUFBQdplwsPDIZfLER0dXew6CgoKkJmZqTOZi5YtWyI2NhZvvvmm6ChERERlwrZevPz8fAwePBhvv/02ioqKsGrVKoSEhCAhIeGpZadMmYLu3bsjPT1dQFIiMpQPPvgAnTt3xv3790VHIRi4M7T8/Hx8+OGHGDx4MFxcXAAAKSkpqFy5sm4IhQLu7u5ISUkpdj3z5s3DrFmzDBlVGBsbG3h6ekIuZwfwRObu0aNH+PPPPxEfHy86CpHesK03HhkZGcjIyIAkSahVqxZeffVVVKpU6anlmjZtCrVa/dR8Z2dnODk5lXn7kZGR2iGF/Pz82Ls5UQXLysriD2hGxGCFdlFREV5//XVIkoRly5aVa13Tpk3DlClTtLczMzNRvXr18kYkIqpQt27dwvDhw3V6+SUyZWzrjVfv3r3Ru3fvYu+bOnWqQba5aNEi7Nq1CwAwePBgFtpEZNEMUmg/aXhv3bqFQ4cOaX/hBgAfHx+kpaXpLK9SqZCeng4fH59i12drawtbW1tDRBXG0dERs2fPRtOmTXk0m4iITA7beuN0/fp1vP322+jXrx/69etXIds8ePAg1q5dq3OaelRUFIYOHQrgcSdrs2fPhpeXV4XkISIyBnovtJ80vFevXsXhw4fh4eGhc39oaCgyMjIQHx+PwMBAAI+HutFoNAgJCdF3HKNlY2OD3r17o1atWqKjEFEFUCqV2lM6iUwd23rj9eDBA2zcuBG1a9cuc6FdVFT01DXyCoUCrq6uyMvLQ25urs598fHx+OWXX+Ds7Kx9L2RlZWHfvn0AgEqVKmHatGllykJEZKpKXWhnZ2fj2rVr2ts3btzAmTNn4O7ujipVqqB///5ISEjA7t27oVartddiubu7w8bGBi+//DK6dOmCUaNGYfny5SgqKsKECRMwaNCgEo//SERkSgoLC/HWW28hNjYWBQUFouMQvRDbest28uRJvP322zo/DDZv3hybN2/Gjz/+iEWLFuksn5WVBQBYsmQJwsPDn1qflZXVM89kICIyW6XtNv7w4cPFdnE+bNgw6caNG8/sAv3w4cPadTx8+FAaPHiw5OTkJLm4uEjDhw+XsrKySpzBHIb8qFSpknT9+vXS7n4iMjFXrlyRduzYIdWtW1f45w6nipnMYXgvtvWmP33yySdlfv33798vyWQynfUFBARIv//+u/Tmm28+ta0aNWpI3bt3l6Kjo8u8TSIqu6SkJGnPnj1SWFiY8M8eS5lK0taX+oh2+/btn3vq4/Pue8Ld3R0bNmwo7aaJiEzO2rVr8cUXX/CUcTIpbOvp365cuYLevXsX+9r36NED33zzDWQymYBkRHTgwAGMHDmS3zWMjEGH9yISJTs7GwsXLix2iIOaNWvi3XffhZWVlYBkZCmuXbuGb7/9FsePH2fDR0QVpkaNGpg0aRJCQ0P1vu5/f5b5+Phg6tSpaNGiBYtsIoEkSeJ3DSPEQpvMTkFBAdLT07F69Wrcvn37qftDQkIwfPhwKBSP3/4ODg7s+Z307u7du/j222+LHauWiMhQfHx8MG7cONjY2Bh0O3Z2dqhatSrGjBlTrrG3iYjMFQttMjuzZs3Ctm3bkJycXOz9586dQ+vWrSGTyaBQKLB69Wo0a9asglMSERGZJisrK6xcuRKhoaFwcHAQHYeIyCix0Cazcf/+fSQmJuL06dNITEx85nJ5eXm4dOkSgMdfFk6dOoWcnBydZRo0aIBKlSoZNC+ZJ7VajbNnz+L8+fM8jYuIKlxWVhZOnjyJWrVqwc/Pr9zrk8vlaNy4MRwdHbXzrKys0KRJE7z00kvlXj+ZPkmScP78ee2QcFWrVkXNmjUFpyISj4U2mY2DBw9i2LBhUKlUJX6MWq3GxIkTdU4dl8lk2L59O7p162aImGTmcnNzMWzYMFy+fBkajUZ0HCKyMJcvX8arr76K6dOn47PPPiv3+uzs7LBq1So0atRIO08mk7GfE9JSqVQYP348oqOjAQDvvvsuFi5cKDgVkXgstMmk/fLLL7h69SoA4Pz58ygqKir1OtRq9VPX0a5bt07bYDRu3Bj9+vUrf1gye7t378bx48eRnJzMa7OJSAhJkqBSqRAREaE9q8bLywujR48u8XXbL730EmbNmgVJkmBtbY2qVasiNTUVP/30E9RqNeRyOYYPH66XI+Zk+qysrDB8+HC8+uqrAICWLVs+d/ns7GysXLkSPj4+eOONNyoiIpEQMskEz23MzMyEq6ur6BjlUqlSJcTFxaFWrVqio5gkjUYDlUqF3r17Y9++fQbd1qBBg/Dzzz8/dxlra+vn3q/RaJ4qvORyOY8ImJmxY8di+fLlomOQYEqlEi4uLqJjmDxzaOuNRUBAAE6cOAFXV9cStTtPivV/OnXqFDp27IiioiIoFAr8+eefCAsLA8D2jErn/v37CA4ORrNmzbBt2zbRcUxeUVER1qxZg9GjR4uOYlFK0tbziDaZpO3bt2PhwoXPvRZbXw4ePIj27ds/8357e3usXLnyuT+abNu2DUuWLNGZ17lzZ8ycOVNfMYmIiIp169YtdOvWDQMGDMDUqVNfuHxMTAymTp2q089EZmamtvhWqVR49913tV8y+/XrhylTphgmPJkdNzc3bN26Vee6fyqbO3fu4J133sG1a9dER6FisNAmk1JQUICrV68iPj4ep06dqpBtPnjwAA8ePHjm/fb29jhz5sxTHar9U3x8PE6ePKkzr1KlSjh//nyxy/v6+sLDw6NsgUmYqlWrokGDBrh27RoKCgpExyEiAvC4E9Do6Gj4+/vj/Pnz8Pf3h7Oz81PLqdVqXLt2DadPn8bJkyef26HjhQsXtH/7+fk91Z65ubmhevXq+nsSZHJu3ryJrKwsAI+/81SrVg3A47MAAwMDRUYzG/n5+YiOjkZGRoboKFQMnjouCE8dL5vLly+jffv2yMjIQGFhoeg4Wvb29pDJZM+8X6VSPZXXysoKtra2xS6/aNEijBkzRq8ZyfAKCwuRnp6Odu3a4a+//hIdhwThqeP6YQ5tvbFRKBSwtbXFr7/+WmyHn48ePUJYWBiuX79eqh8LFQrFU9d/v/7661i9enW5M5NpkiQJffr0wYEDBwAAb775JlasWCE4lfm5du0aWrRowUJbAJ46TmZDo9Fg27ZtiI+PN7oiG3h8tKC01Go1cnNzi73v4MGDkCQJAwcOhLu7e3njUQWxsbGBo6Pjc390ISISRaVSQaVSFdtZ44EDBxAXF4eUlJRSn5HzZL3/dO7cOSxdulRnXo0aNdCrV6/SByeTcubMGURGRiIxMVH7Paek76l79+5h27ZtCA4ORnBwsCFjEhkcC20yCRqNBl9//TWOHz8uOkqF+O2337B//360adMGlSpVYuFmYmQyGWQyGcfRJiKTIEkSfvnllxd2/FkaCQkJSEhI0JnXpUsX9OjRgx2nmbnIyEhMnjwZALTfX0r6Peb69euYMmUKZs6cyUL7BSRJ4vcMI8dCm8hI5efnY+zYsQgJCcH8+fP5xcREODg4YOXKlYiKisK0adM4ljYRGbXIyEjMnz8f586dM/i24uLi0KNHD/znP/9B7969Db49EqNXr16oW7euzrwn12e/SMOGDbFz507UqVPHENHMhiRJmD59Ok6cOIHs7GzRcegZWGiT0VMqlbh//z7y8/NFR6lQarUax48fR35+Pm7cuAEvLy9er2gCrKys0KZNG2g0Gp6JQERGKS0tDTdv3gQAnD171uDDZD6Rk5ODy5cvIz09vUK2R2L4+/vD39+/TI+tVKkSunTpot9AZkiSJMTFxeHo0aOio9BzsNAmo7dy5Up88cUXyMzMFB1FiDNnziAkJAQfffQR3n//fdFxiIjIxE2ePFnbeVlFjpDQqlUrbNq0CU5OThW2TSIiUVhok9F68OAB9u/fj6ioKIv+9VulUiE9Pb1MHa6RON7e3hg6dCji4uJ0hsEhIhLtyZBLFc3GxgYeHh4824eoHC5duoTY2Fjcu3dPdBR6ARbaZLSuXbuGESNGoKioSHQUolILCAjA6tWr8fHHH7PQJiIiIr3Ys2cPPvjgA9ExqATkogMQ/VtBQQE++ugjzJw5s9ghSCzVli1bMHToUFy9elV0FCIiIq1OnTphw4YNaN68ebH3Ozk54euvv8aHH37Io9lEZDFYaJPRUavV2LNnDw4cOMAem//hwoUL2Lx5M65evYpHjx6JjkMl5OTkBE9PTygUPIGIiMxT1apV0bFjR3h5eT11n7OzM3x9fdG7d2+0a9dOQDoi86BSqfDgwQPk5OSIjkIlxEKbyIQUFRVhxIgRGDhwIK/ZNhHjx49HVFQUGjRoIDoKEZFBbNmyBUFBQcX2gDx79mxERESgatWqApIRmY8rV66gdevW+Prrr0VHoRLiIRYiE5Oamork5GRIkiQ6CpWAq6sr7O3tYWtrKzoKEZFBZGdnP3MsXw8PjxKPoUxkLJKSknDmzBkEBgbC19dXdBwAjw+2JCUl8UCLCeERbSIiIiIiov8vIiICvXr1wvHjx0VHIRPGI9pkVLZu3Yo///yTQxa8wL179zBp0iS8+uqrGDBggOg49AIKhQIffPAB4uPjsXDhQvakT0RmLygoCMOHD0dISIjoKESl1rJlS3z77bcIDAwUHQUqlQqLFy9GXFwcCgsLRcehUij1Ee2jR4+iZ8+e8PX1hUwmw44dO5657JgxYyCTyfDVV1/pzE9PT8eQIUPg4uICNzc3jBw58pmnHJFlOXHiBH744QeLHje7JNLT0/HDDz/wl1YTIZfL0a9fPwwePBhubm48jZyMHtt6Kq86depg3LhxqFu3rugoRKUWEBCAcePGoXbt2kJzFBYWQqlUYvPmzdiyZQtH4zExpS60c3Jy0KRJE3z33XfPXW779u04depUsdc1DBkyBBcvXsSBAwewe/duHD16FKNHjy5tFCIik1K3bl0cPXoU7777rugoRM/Ftp6ISLzvv/8eYWFhuHTpkugoVAalPnW8a9eu6Nq163OXuXv3LiZOnIg//vgD3bt317nv8uXL2L9/P2JjYxEUFAQA+Oabb9CtWzcsXLjQaDocMDSVSoWYmBjk5OSgUaNGouMI9+jRI1y4cAF3794VHcWk3L17F8eOHUPDhg1RqVIl0XHoBWxtbREQEABvb2/RUYiei209EZF4aWlpuHLliugYVEZ67wxNo9Fg6NCheP/994sdziYqKgpubm7ahhcAwsPDIZfLER0dXew6CwoKkJmZqTOZuqysLLz55pv48MMPOVY0gOjoaHTs2BFbt24VHcWkbNu2DR07dnzm/w4RkSGwrSciIno+vRfa8+fPh0KheOapkSkpKahcubLOPIVCAXd3d6SkpBT7mHnz5sHV1VU7Va9eXd+xhVCr1RZ/rUVeXh4WL16Mn3/+GUVFRRyyqpQkSUJRURF+/vlnLF68GLm5uaIjUQm0bt0as2fPFn7tF1FZsa2nZ3F1dcVHH33EjjqJyuHGjRv49NNPix2bnkyHXnsdj4+Px9dff42EhATIZDK9rXfatGmYMmWK9nZmZqbZNMAajQaFhYWwsbGBXG55o63l5eVhxYoV+Pvvv0VHMWkbN25EVFQUhg0bBgcHB9Fx6AVatmyJ4OBgHDt2DNevXxcdh6hU2NbT87i4uGD8+PHw8fERHYXIZN26dQv/+9//LP6AnKnTa2V37NgxpKWlwc/PDwqFAgqFArdu3cLUqVPh7+8PAPDx8UFaWprO41QqFdLT05/5oWxrawsXFxedyVzExsaiffv22LRpk+goQri4uGDz5s348ssv9fqFjYiIDINtPT1PamoqevXqhdmzZ4uOQkQklF6PaA8dOhTh4eE68zp37oyhQ4di+PDhAIDQ0FBkZGQgPj5eOzbdoUOHoNFoLHKsRaVSiejoaCQnJ4uOIoRCoUDTpk0t9vnrU2FhIS5cuIBatWrxKBARGQzbenqewsJCJCQkwNvbG+fOnUP16tXZWSdRCWk0Gly9ehXXr1/n5ZRmoNSFdnZ2Nq5du6a9fePGDZw5cwbu7u7w8/ODh4eHzvLW1tbw8fFBvXr1AAAvv/wyunTpglGjRmH58uUoKirChAkTMGjQIPZCSlQOycnJ6Nq1K4YMGYIffvhBdBwiMmFs66m8/vzzTxw5cgQ//vgj3njjDdFxiExCTk4OBg4ciCtXrrCzZDNQ6kI7Li4OHTp00N5+cj3VsGHDsGbNmhKtY/369ZgwYQI6duwIuVyOfv36YenSpaWNYlaOHj0KGxsbDBo0CF5eXqLjVJj8/HysX78e0dHR/OWunCRJQl5eHs6cOYMlS5aga9euCAgIEB2LihEfH48jR47g1q1boqMQFYttPZWXWq1GXl4edu/ejdTUVACAv78/+vTpIzgZUenk5uZi/fr18Pb2xmuvvWaw7Rw8eBCxsbFITk5GQUGBwbZDFUcmmWB1k5mZCVdXV9Ex9M7e3h4nT55E06ZNRUepMA8fPkRQUBBu3rwpOorZWbduHYYMGaK9zWvgjceiRYvw3//+V3QMMhClUsnri/XAXNt6S9alSxfs3r1b2/kr2yUydpIkITU1FcHBwQgMDMT27dsNtq0xY8ZgxYoVBls/6VdJ2nq9XqNNRMZj/vz5WLduHQAgJCSEHdMQEZFQcXFx6Nq1K2QyGezs7PDVV1+hZs2aomMRPdO8efMQGxuLJUuWcEhOKjUW2kZEkiTcuXMHlStX5jVsVG4XLlzAhQsXAAA2NjaQJIlHDwQrLCzEvXv38PDhQ9FRiIgq3IMHD3DgwAEAj8/iu3LlivaysUqVKrHTNDIa2dnZSEtLw/Hjx5GQkIBvvvkG1apVM8i2cnNzkZKSgszMTIOsn8RhoW1E8vPzMWTIEAQHB2Pv3r2wtrYWHYmI9Oivv/5C586d8ejRI9FRiIiEysvLw6BBg6BQPP4q+v777+Ojjz4SnIrosZ07d2LixInIzs42+A9AR44cwdChQ5GTk2PQ7VDFY6FtZDIzM5GZmWkRHYMdO3YMZ8+eRXZ2tugoZsvW1havvfYaWrduzaPZAmk0GuzduxcJCQm4f/8+ioqKREciIhLun0fwoqKitB3tubm5oUePHtoinKiiFRYWIj09He3bt0eTJk3g6Oio923k5+dj586dOH78ONLT0/W+fhKPn2AkzA8//KC9hpgMw9nZGQsXLoSfn5/oKBZNpVJhzpw5iImJER2FiMgo7dy5Ezt37gQANGjQAOHh4XBychKciizd2LFj8frrrxtk3UqlElOmTMHdu3cNsn4Sj4W2Ebp27RqGDBmC/v37Y+DAgaLjkB599NFHaNasWYVtz9bWFp6enhW2PSIiovJKSkrCW2+9BWtra8hkMnzwwQdo3ry56FhkAdLS0vDRRx/h/PnzBt3OV199hcOHD/NItpljoW2E0tPTsXXrVtSrV88sC+38/HwolUrk5+eLjmJwCoUC7u7ukMlkkMlkCA8PR8eOHUXHogqUnZ2NR48eobCwUHQUIiKTkJmZqR1GSSaToUePHqhatSoAwM7OjsO+kUFkZGTg5s2b2LZtGwoKCuDt7Q07OzuDbCsqKkp7BgeZLxbaVOH++OMPTJgwwSJ+xatduzZ27twJBwcHAODRZQv03Xff4ZtvvkFaWproKEREJkeSJEyaNAn29vYAgN69e+Obb74RnIrMjSRJGDduHA4fPozMzEwMGDAAixYtgoeHh+hoZMJYaBuxxMRE/P777wgLCzOLf/S8vDwcOXIEkZGRuHPnjug4BiWTydCmTRs0bdoUNWrUgK2trehIVMEePnyI48ePIzY2ltdfERGVwz+HRDx37hx27NgB4PHQle3bt9f+mE1UGkqlEkePHoVarYYkSbh8+TIyMzPRpUsXhIWFGWQ4r9u3byMhIYHfCyyETDLB7q0zMzMt5rQhhUKBiIgItG3bVnSUcktKSkJQUJBFHNmztrbGkSNH0KpVK9FRSJDIyEiEh4dDpVKJjkIVTKlUwsXFRXQMk2dJbT2VjaenJ2JjY+Hv7y86Cpmgs2fPolWrVsjNzdXOq1WrFuLi4gw2pNdPP/2EkSNHGmTdVLFK0tbziLaRU6vVWLx4MTZu3AgAaNu2LQYPHiw4VektW7YMJ0+e1BnKw1x1794dr732GmrXri06CgmQn5+P+fPnIyEhAWq1WnQcIiKzlZ2djU8++QTOzs4AgNdffx0dOnQQnIqMnVqtxsKFCxEXF4eCgoIK2eaDBw8wd+5cnD59ukK2R8aBhbaRkyQJv//+u848Uyq0CwsLkZeXh127dmHfvn2i41SIFi1aYPTo0aJjkAD5+fl48OABfvnlF1y7dk10HCIis5afn4/169drb9esWROBgYEAALlczuHBqFhqtRrbtm17ashNBwcHODk5QSaT6XV7ubm5uHv3LlavXo2MjAy9rpuMm1x0ADJvW7duRUhICI4dOyY6CpHBzZ8/Hx06dMDt27dFRyEisjiLFi1CcHAwgoODMWrUKF66QyUmk8mwdOlSbN++Xa+X/kiShAkTJqBv374WcVYn6eIRbRPh4OCA5s2bo27duqKjlEhubi4SEhIQExODxMRE0XEqhIuLi7bzM7IMRUVFiI+P1556lpCQwCPZRESCpKWlafuBUSgUiIyMhEKhgEwmQ9OmTdl3gkCpqam4cuUKXn75ZVSuXLnCt69UKnH27FlIkoSioiKdordatWqoU6cOmjRpglq1aultm3fu3MHVq1dx7tw5/P3333pbL5kOFtomws/PD7t27TKZRuLWrVvo2bOnRf16V79+ffzxxx/sYdyCpKenY9CgQdpe9DUajeBEREQEABcvXkTnzp0BPO6gNCIigh2UCvTHH39gxIgR+OWXXzBo0KAK3/65c+fQqVMn7VkO/+xDpX///li4cCGsrKz0us0tW7bg/fffZ38tFoyFtpGTy+UYOXIkgoKC4ODgALncuM/212g0+PHHHxEXF4fc3FyLKjzkcjmsrKz0fm0PGadNmzYhKioK6enpbESJiIzQk89mSZKwfPly7N69GwDQqlUr9OjRQ2Q0i9OsWTPMmTMHjRs3rrBt7ty5E6dOnQLweOSbwsJCFDfYkkwm02uRnZycjOXLl+PYsWP8fmDhWGgbMSsrK9ja2uKtt95CWFiY6DgvpFarkZeXh59//hknTpwQHYfIIDQaDYqKivDbb79h69atouMQEdELaDQarFu3Tnt77Nix6NSpk/a2jY2NQbZbWFio/VuhUBj9wRJ9UavVOgWmjY0NGjVqhEaNGul1vf/0z/2r0WigUqmwd+9erFix4pnrk8lksLa2hkKhv3KoqKgId+7cwYIFC5Cfn6+39ZJpYqFtxN566y2MGzcOAQEBoqOUyNq1a7Fs2TJcuXJFdBQig9m7dy9mzZqF69evi45CRERl8NtvvyE2NhYAUKVKFfz8889wc3PT6zZSUlIwdOhQbS/Tc+bMQZcuXfS6DWP166+/YvHixQCAqlWrYu3atXB1dS33ejdv3owlS5YUe9/cuXPx6quvAgCOHz+OqVOn4tatW89dX506dbBq1Sq99a1TVFSE0aNHIzY2tsKGDSPjxkLbiPn6+iIoKEh0jBfKzc3FX3/9hbi4OMTFxYmOQ2QQhYWFSExMRHx8PN/nREQm7J+dplWpUgWnT5/WFtr+/v6oVKlSudb/999/48qVK4iLi9MW2gkJCahatSoCAgJgbW1drvUbq/z8fCQmJiIhIUHbTj548KDcvb8/We/zvmfGx8fD09NT+/fz2mmZTIY6deqgefPmaNGihV761klOTkZSUhJiY2Nx8eLFcq+PzIRkgpRKpQTA7Kfp06eL3tUlEh0dLbm4uEgKhUL4PhM5tWrVSiosLBT9cpCB3LhxQ6pSpYpkbW0t/L3GybgnpVIp+u1qFiylreckdpLJZJKdnZ1kb28v2dvbSxs2bCjX+1aj0Uh9+vSR7OzsdLZjbW0tVa9eXbp9+7ae/kOMz7lz5yQPDw+ddtLf31968OBBudfr7u7+3PbXxsZG+xra2Ng89zW3sbGRjh49KuXn5+vpmUvSzJkzJTs7O0kmkwl/T3OqmKkkbT2PaBshHx8fDB482CSuywYeXwuTl5fH8SrJrGk0GuTn56OoqEh0FCIi0hNJknSupd25c6d2JIknOnbsiObNm79wXadPn8bBgwdx+fLlp67PLSoqQnp6OpYtW1buI+YA0KBBA3Tr1q3c6ymrO3fu4Ndff9W5Zjo5ORmZmZnadrJ///4IDAyEvb19mbah0WiwYcMGJCQkICsr67nt7z+vh3+esLAwhIWFwd/fv1xHsgsLC/HLL7/g4cOHAIBjx47xmmx6mt5+yqlA5vwrt1wul1q2bCkVFBSI3s0lFhUVxaN8gNSyZUspPz9f0mg0ol8S0jONRiNdvXpVqlSpkvD3GSfjn3hEWz/Mua3nZFrTkiVLJLVa/cL37NKlSyss05tvvimp1WrtVFIajUbnccWt41n3/3OKjIws9kxGuVwuyeVySaFQSPv37y/T//6TbeTl5UkhISF63W9z5swpU6Z/78OMjAypXr16wt+bnMRNPKJtYmxtbfHVV1+hefPmZnv9jjm7fPkyunfvjmHDhmHo0KGi45CeSJKEjz/+GMeOHUNWVpboOEREVMGWL1+OQ4cOYenSpfD39xcdBwAQERGh7VzN1dUV33//Pby8vJ77GJVKhalTp+Ly5ctP3efj44PvvvsO0dHRWLBgwQu3/+jRo6d6AK9Vqxa+/vpr2NraQiaToVmzZqV4Ro+dP38eH3zwAdRqNTQajVF2sPvNN99gx44dSEpKEh2FjFypC+2jR4/iyy+/RHx8PJKTk7F9+3b07t1bZ5nLly/jww8/RGRkJFQqFerXr4/ffvsNfn5+AB53ajB16lRs2rQJBQUF6Ny5M77//nt4e3vr5UmZKrlcjpYtW6Jp06aio1AZKJVKREREoE2bNqKjkB5JkoSEhAQOWUcWhW090f9JTEzE7du3cenSpWIvk7OxsUH16tUrNFNycjKSk5MBAJUqVcLly5ehVCqf+5iioiIcPXoUZ86ceeq+atWqITExEWfOnMGBAwdKnMPd3R3u7u4AgICAAISHh8POzk57v0qlQlJSEhwdHVG5cuVnrkeSJCQlJeHChQs4cOCA3saflslkqF69unYINw8PjzKvKzs7GykpKTh16hQOHz6sl3xk3kpdaOfk5KBJkyYYMWIE+vbt+9T9169fR1hYGEaOHIlZs2bBxcUFFy9e1Pmnmzx5Mvbs2YMtW7bA1dUVEyZMQN++fflFloiIyAiwrSfSlZeXh0GDBsHKyuqp++rXr1+q4lTfMjIy0LNnzxKN0/2sM7Pu3buH8PDwUvdD8p///AcffPABAMDKykrnM+Cf633yQ9uz5OTk4PXXX8fFixf1VmQDgKOjI7Zs2YK6desCQJmvFwceX4c9ZMgQ5OTk6CsemblSF9pdu3ZF165dn3n/9OnT0a1bN53TTmrXrq39W6lUYtWqVdiwYQNeeeUVAMDq1avx8ssv49SpU2jZsmVpI5mF4OBgBAYGluuXNjIOCQkJWL16Nbp37/7cX2+JiIwV23qipz2rSL116xZ++uknREVFAQA6depU5iPc8fHxxR5xfh5JkpCZmVmm7T2h0WheeET8n7y9vdGtWze0atXqqTHIL1y4gOjoaADA/fv3kZqairNnz2LVqlXPXF9eXh5u376N7OzsMuV/FplMBhcXF72Mk15YWIhHjx6VPxRZjvJ0BgBA2r59u/a2Wq2WnJycpNmzZ0udOnWSvLy8pODgYJ1lIiIiJADSo0ePdNbl5+cnLV68uNjt5OfnS0qlUjslJSUJvwBe39PChQvL81IIdfLkSXaG9q/J2tpaOnHihOiXhvRArVZLnTp1Ev6e4mQ6k7l1hgawrefEqaSTTCaT9uzZU+b/t5kzZwp/DiWZwsLCpKKiomKfw5IlS4TnezI5OztLly9fLvPr8U87duwQ/nw4Gc9U4Z2hpaWlITs7G1988QU+//xzzJ8/H/v370ffvn1x+PBhtGvXDikpKbCxsXnqlyVvb2+kpKQUu9558+Zh1qxZ+oxKelBYWIjp06cjPj6eQ3uRWdq9ezfWrl2Ls2fPio5CZDTY1hM9myRJmDdvHnbv3o358+fD2dm5VI8fOHAgGjVqZKB0LxYZGYlvv/222PtGjhyJdu3a4eOPP8aVK1cwaNAgDB48GP369dNZrnv37qhWrRoAICUlBdOmTdP7keqSeOedd9C9e3dUrVq1wrdNBJTh1PHn0Wg0AIBevXph8uTJAICmTZvi5MmTWL58Odq1a1em9U6bNg1TpkzR3s7MzKzwTifoaSqVCn/++SfOnTsnOorRkSQJDx8+xIMHD+Dh4QGZTCY6EpXB1atXsXXrVtExiIwK23qi5zt+/DiSkpIwZ86cUj+2fv36qF+/vgFSldxvv/1W7PzWrVujT58+WLVqFf766y+cPHkSTZo0QatWrXSW8/b2Rv/+/QEAN27cwGeffVahhbatrS3c3d0RFhb2VCeORBVJr4W2p6cnFArFUx8QL7/8Mo4fPw7g8fABhYWFyMjI0PmlOzU1FT4+PsWu19bWtlyDyhNVNJVKhREjRqBRo0bYvXs3HBwcREciItILtvVE5qt79+5PFc5PuLm5wd7eHlu2bNF2mrZ8+XIEBQXpLDdq1Ch89tlnho76TO3atcPq1av1cl02UXnotdC2sbFBixYtkJiYqDP/r7/+Qo0aNQAAgYGBsLa2RkREhPZUkyfDJoSGhuozjkk5f/48du7ciXbt2sHV1VV0nBc6f/48Ll68WKqOMyzNgwcPcP36dfz+++9o0KABGjduLDoSlZBSqURkZCTP1iAqBtt6IvNlb2//wp65/zletyRJuHfvns79T74bnjx5EufOnUNBQYH+gxbD1tYWHTp0QLt27eDr61sh2yR6rtJ2BJCVlSWdPn1aOn36tARAWrx4sXT69Gnp1q1bkiRJ0rZt2yRra2tp5cqV0tWrV6VvvvlGsrKyko4dO6Zdx5gxYyQ/Pz/p0KFDUlxcnBQaGiqFhoaWOINSqRR+AbwhJgcHB+nMmTOlfUmEmDRpkvD9ZUrTxIkTRb9kVApnzpyRHBwchL9vOJnmZA6dobGt58SpfFONGjWkBw8e6P1/09h88sknTz33SZMmSRqNRurSpUuF7vPKlStLSUlJBnuu7AyN0z+nkrT1pS60Dx8+XOzGhg0bpl1m1apV0ksvvSTZ2dlJTZo0kXbs2KGzjry8PGncuHFSpUqVJAcHB6lPnz5ScnJyiTOYa+Nrb28vnT59urQvSYU6f/68NHr0aKlhw4bC95cpTQ0aNJBGjRoljRo1Svroo4+krKws0S8lPcfp06cle3t74e8bTqY5mUOhzbaeE6eyTxMnTpQ2bNgg5efn6+tf0uhcvXpVGjNmjNS0aVPt865WrZr0zTffSHPmzJHeeecdqVq1ahW2z0eNGiWtW7fOoN+vWGhz+udUkrZeJkmSBBOTmZlpEqdXl5a9vT3+/PNPNG3aFE5OTqLjaOXl5aGwsBAAEBERgf79+8ME3zZGo3r16oiMjIS7u3uJlreysjKq94O5y87OxpkzZ9CpUyfk5eWJjkMmSKlUwsXFRXQMk2eubT2ZLxsbGzg4OGDz5s3o1KmT6DgGFRUVhZ49e0KlUkGSJOTk5ODll1/GgQMHsGbNGkybNq1CclhbW8PBwQE//fQT+vbta9Bt/f777+xcjbRK0tbr9RptKp/8/HwMGTIELVq0wMaNG2FtbS06EgDgs88+w7Zt2wAAubm5LLLLKTk5GeHh4ZDL5SVaPigoCOvWrYNCwX9XQysqKsLbb7+N2NhY5Ofni45DREQmZODAgZgxY4ZFDCfVrFkznDp1CpIkoaioCEOGDMGlS5cQFhaGzMzMCsvRo0cPzJ8/H1WqVKmwbRKVFL+5GxFJknD79m04ODjg0KFDsLa2hkwmQ7NmzYT0nJiamoqLFy/izJkzuHbtWoVv31ypVCr8/fffJV7ezs4Ohw4dMppCu0GDBvD29hYdQ+/+/vtvXL16FRcvXsTt27dFxyEiIhPh6OiIoKAgBAcHo06dOqLjVAg7Ozu89NJLAB5/rwkLC4ONjQ3i4uK0QwAaevtBQUEICQlBnTp1cOHCBaSlpQF43FmbyLHIibQMdiGDAVnCdVtWVlaSlZWVZGNjIx09elTIft64caNkZWUlyWQy4fvD0qcn7wdjmDZu3Cjk/Whon3zyiWRlZSX8teZk+pM5XKNtDCyhredkHlODBg0kpVIpaTQa0f82wqjVaikhIaHCOhL19/eX0tLStPt88ODB2u8pffr0Mchz5DXanP45laStN45DZPQUtVoNANBoNFi2bBl2794NAGjZsiX69OljsO2uXbsWly5dAgBcvnxZm4PEMqbXQTKzSwdu3LiBlStX4siRI0a1n4mIyDTIZDLI5XLIZDLRUYSRy+WoVq0aPv/8c+0Y28XZsGEDzp49W6ZthIWFoWfPngAej+nt7Oys3eeDBw9G06ZNAcBiziog48dC28hJkoSNGzdqb48aNQpdu3Y12Pa2bNmCPXv2GGz9ZPqKiopQUFAAW1tb0VHKTKVSQaVSAQCuX7+OL7/8kkU2ERFROXh5eWHy5MnPXebixYtITEws0/pbtWqFDz74oNj7evbsqS3CiYwFC20Ts2PHDiQkJBhs/bwWm17k008/xbp16/DLL7+Y7LXaixYtwpYtWwA87mWcRTYREZHhffbZZ3j33XfL9FhT/c5BlouFtom5f/8+7t+/LzoGWbCbN29CqVQiNjZW28unn58fvLy8BCd7NpVKhUuXLmlPZ4uLi0N8fLzgVERERJalZs2aqFmzpugYRBWChTYRldqjR4/Qv39/7bVRS5YswZgxYwSnerZHjx6hb9++uHv3LgA89/oxIiIiIqLyYqFNRGVSUFCg/Xvfvn3Izc3FsGHD4OHhITDV03bu3ImYmBjcv3+fY2MTERERUYVgoU1E5bZz504cOnQInTp10o75LrIHVo1Go+0dff369fj111+F5CAiIiIiy8RCm4j0Ii8vD++88w4cHBwAACNGjMCbb75Z4TmSk5MxduxYZGZmAnjcwykRERERUUVioU1EeqFWqxEdHa293bhxY4SEhKB69eqws7Mz6LYfPXqk7SQwKSkJR44cgVKpNOg2iYiIiIieRS46ABGZp+XLl6NVq1Y4f/68wbe1fv16BAcHIzg4GH369NEezSYiIiIiEoFHtInIIAoKCqBSqbBt2zacOXMGANCoUSO0bNmyxOs4fvw4Ll++/MLljh49yiPYRERERGQ0WGgTkcGo1Wp88cUX2tuTJk0qVaG9YcMGLFu2zBDRiIiIiIgMhoU2EVWYXbt24datWyVe/vTp0wZMQ0RERERkGCZZaD8ZtoeITMv169dx/fp10TGIDIptlH5wP5KpUKvVyMzMhEajER2FDCg3N1d0BDIiJWmjTLLQzsrKEh2BiIioWFlZWXB1dRUdw+SxrSdTcfnyZVStWlV0DCKqQCVp62WSCf5krNFokJiYiPr16yMpKQkuLi6iI5mFzMxMVK9enftUT7g/9Y/7VL+4P/VLkiRkZWXB19cXcjkH9SgvtvWGwf97/eL+1D/uU/3jPtWf0rT1JnlEWy6Xa385dHFx4RtGz7hP9Yv7U/+4T/WL+1N/eCRbf9jWGxb3qX5xf+of96n+cZ/qR0nbev7kTkRERERERKRHLLSJiIiIiIiI9MhkC21bW1t8+umnsLW1FR3FbHCf6hf3p/5xn+oX9ycZO75H9Y/7VL+4P/WP+1T/uE/FMMnO0IiIiIiIiIiMlcke0SYiIiIiIiIyRiy0iYiIiIiIiPSIhTYRERERERGRHrHQJiIiIiIiItIjky20v/vuO/j7+8POzg4hISGIiYkRHckkfPbZZ5DJZDpTQECA9v78/HyMHz8eHh4ecHJyQr9+/ZCamiowsfE5evQoevbsCV9fX8hkMuzYsUPnfkmSMHPmTFSpUgX29vYIDw/H1atXdZZJT0/HkCFD4OLiAjc3N4wcORLZ2dkV+CyMx4v259tvv/3Ue7ZLly46y3B//p958+ahRYsWcHZ2RuXKldG7d28kJibqLFOS//Pbt2+je/fucHBwQOXKlfH+++9DpVJV5FMhYltfRmzry49tvX6xrdcvtvWmwSQL7c2bN2PKlCn49NNPkZCQgCZNmqBz585IS0sTHc0kNGjQAMnJydrp+PHj2vsmT56MXbt2YcuWLYiMjMS9e/fQt29fgWmNT05ODpo0aYLvvvuu2PsXLFiApUuXYvny5YiOjoajoyM6d+6M/Px87TJDhgzBxYsXceDAAezevRtHjx7F6NGjK+opGJUX7U8A6NKli857duPGjTr3c3/+n8jISIwfPx6nTp3CgQMHUFRUhE6dOiEnJ0e7zIv+z9VqNbp3747CwkKcPHkSa9euxZo1azBz5kwRT4ksFNv68mFbXz5s6/WLbb1+sa03EZIJCg4OlsaPH6+9rVarJV9fX2nevHkCU5mGTz/9VGrSpEmx92VkZEjW1tbSli1btPMuX74sAZCioqIqKKFpASBt375de1uj0Ug+Pj7Sl19+qZ2XkZEh2draShs3bpQkSZIuXbokAZBiY2O1y+zbt0+SyWTS3bt3Kyy7Mfr3/pQkSRo2bJjUq1evZz6G+/P50tLSJABSZGSkJEkl+z/fu3evJJfLpZSUFO0yy5Ytk1xcXKSCgoKKfQJksdjWlx3bev1iW69fbOv1j229cTK5I9qFhYWIj49HeHi4dp5cLkd4eDiioqIEJjMdV69eha+vL2rVqoUhQ4bg9u3bAID4+HgUFRXp7NuAgAD4+flx35bQjRs3kJKSorMPXV1dERISot2HUVFRcHNzQ1BQkHaZ8PBwyOVyREdHV3hmU3DkyBFUrlwZ9erVw9ixY/Hw4UPtfdyfz6dUKgEA7u7uAEr2fx4VFYVGjRrB29tbu0znzp2RmZmJixcvVmB6slRs68uPbb3hsK03DLb1Zce23jiZXKH94MEDqNVqnTcFAHh7eyMlJUVQKtMREhKCNWvWYP/+/Vi2bBlu3LiBNm3aICsrCykpKbCxsYGbm5vOY7hvS+7Jfnre+zMlJQWVK1fWuV+hUMDd3Z37uRhdunTBzz//jIiICMyfPx+RkZHo2rUr1Go1AO7P59FoNJg0aRJat26Nhg0bAkCJ/s9TUlKKfQ8/uY/I0NjWlw/besNiW69/bOvLjm298VKIDkAVq2vXrtq/GzdujJCQENSoUQO//vor7O3tBSYjKt6gQYO0fzdq1AiNGzdG7dq1ceTIEXTs2FFgMuM3fvx4XLhwQefaTCIyf2zrydSwrS87tvXGy+SOaHt6esLKyuqpXvNSU1Ph4+MjKJXpcnNzQ926dXHt2jX4+PigsLAQGRkZOstw35bck/30vPenj4/PU535qFQqpKencz+XQK1ateDp6Ylr164B4P58lgkTJmD37t04fPgwqlWrpp1fkv9zHx+fYt/DT+4jMjS29frFtl6/2NYbHtv6kmFbb9xMrtC2sbFBYGAgIiIitPM0Gg0iIiIQGhoqMJlpys7OxvXr11GlShUEBgbC2tpaZ98mJibi9u3b3LclVLNmTfj4+Ojsw8zMTERHR2v3YWhoKDIyMhAfH69d5tChQ9BoNAgJCanwzKbmzp07ePjwIapUqQKA+/PfJEnChAkTsH37dhw6dAg1a9bUub8k/+ehoaE4f/68zpeaAwcOwMXFBfXr16+YJ0IWjW29frGt1y+29YbHtv752NabCNG9sZXFpk2bJFtbW2nNmjXSpUuXpNGjR0tubm46veZR8aZOnSodOXJEunHjhnTixAkpPDxc8vT0lNLS0iRJkqQxY8ZIfn5+0qFDh6S4uDgpNDRUCg0NFZzauGRlZUmnT5+WTp8+LQGQFi9eLJ0+fVq6deuWJEmS9MUXX0hubm7S77//Lp07d07q1auXVLNmTSkvL0+7ji5dukjNmjWToqOjpePHj0t16tSRBg8eLOopCfW8/ZmVlSX997//laKioqQbN25IBw8elJo3by7VqVNHys/P166D+/P/jB07VnJ1dZWOHDkiJScna6fc3FztMi/6P1epVFLDhg2lTp06SWfOnJH2798veXl5SdOmTRPxlMhCsa0vO7b15ce2Xr/Y1usX23rTYJKFtiRJ0jfffCP5+flJNjY2UnBwsHTq1CnRkUzCwIEDpSpVqkg2NjZS1apVpYEDB0rXrl3T3p+XlyeNGzdOqlSpkuTg4CD16dNHSk5OFpjY+Bw+fFgC8NQ0bNgwSZIeD/sxY8YMydvbW7K1tZU6duwoJSYm6qzj4cOH0uDBgyUnJyfJxcVFGj58uJSVlSXg2Yj3vP2Zm5srderUSfLy8pKsra2lGjVqSKNGjXrqizb35/8pbl8CkFavXq1dpiT/5zdv3pS6du0q2dvbS56entLUqVOloqKiCn42ZOnY1pcN2/ryY1uvX2zr9YttvWmQSZIkGfaYOREREREREZHlMLlrtImIiIiIiIiMGQttIiIiIiIiIj1ioU1ERERERESkRyy0iYiIiIiIiPSIhTYRERERERGRHrHQJiIiIiIiItIjFtpEREREREREesRCm4iIiIiIiEiPWGgTERERERER6RELbSIiIiIiIiI9YqFNREREREREpEcstImIiIiIiIj06P8Bahu3T0vhMl0AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "1- DC(binary_map, mask)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cml_32RDhQpG",
        "outputId": "0f9f6e74-7c62-4a4c-8b22-5b3cf5f62b45"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.19689480354879596"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "EPG(binary_map, im)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m0hTJYPFihY_",
        "outputId": "0fbfa3f9-7985-444a-9f44-c1d3c5016a42"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.5649409200989643"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "EPG(ground_truth_box, im)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s2-Tl2SYihg0",
        "outputId": "b117dd2d-2a06-462e-8d68-602e8e59f5ce"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8434543764250535"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pixel_wise_F_score(binary_map, im)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cpK5busrnXt9",
        "outputId": "574b0def-32d5-4e61-b051-86aed977ed46"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6405657350359302"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pixel_wise_F_score(ground_truth_box, im)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xNm29qYdHAvY",
        "outputId": "eff3b979-90e5-4b97-b078-8eb38423e83c"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.763944154037741"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "AME(im, ground_truth_box)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cnGfaZ32HH9-",
        "outputId": "a743e8d7-585a-42c9-c703-ac867939e3a6"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.240443243562494"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "AME(im, binary_map)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vl7xmX-IFuC",
        "outputId": "486d74ca-d3bc-4758-b213-668019c546c3"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.2924533758194106"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    }
  ]
}