final_distribution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "## Final Distribution"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "from config import PROJECT_ID, INITIAL_TS, SNAPSHOT_TS, \\\n",
    "    CITIZENS_AUDIENCE, ETH_ANALYSIS_DATASET_NAME, ETH_ANALYSIS_DISTRIBUTION_TABLE_NAME, \\\n",
    "    CYBERPUNKS_AUDIENCE, \\\n",
    "    HACKERS_AUDIENCE, GAS_ANALYSIS_DATASET_NAME, GAS_ANALYSIS_DISTRIBUTION_TABLE_NAME, \\\n",
    "    LEADERS_AUDIENCE, LEADERS_SEGMENT, ERC20_TOP_DISTRIBUTION_TABLE_NAME, \\\n",
    "    MASTERS_AUDIENCE, ERC721_ANALYSIS_DATASET_NAME, ERC721_ANALYSIS_DISTRIBUTION_TABLE_NAME, \\\n",
    "    INVESTORS_AUDIENCE, ERC20_ANALYSIS_DATASET_NAME, ERC20_ANALYSIS_DISTRIBUTION_TABLE_NAME, \\\n",
    "    HEROES_AUDIENCE, GENESIS_AND_ETH2_DATASET_NAME, GENESIS_AND_ETH2_DISTRIBUTION_TABLE_NAME, \\\n",
    "    COSMOS_AUDIENCE, COSMOS_SEGMENT, COSMOS_DATASET_NAME, COSMOS_DISTRIBUTION_TABLE_NAME, \\\n",
    "    MANUAL_ADDRESSES_AUDIENCE, MANUAL_ADDRESSES_SEGMENT, MANUAL_ADDRESSES_DATASET_NAME, \\\n",
    "    MANUAL_ADDRESSES_DISTRIBUTION_TABLE_NAME, \\\n",
    "    FINAL_DATASET_NAME, DISTRIBUTION_TABLE_NAME, FINAL_DISTRIBUTION_TABLE_NAME, STABLECOINS_LOVERS_TABLE_NAME, \\\n",
    "    SERVICE_DATASET_NAME, CONTRACT_ADDRESSES_TABLE, GIFT_PER_ADDRESS_PIVOT_TABLE_NAME, \\\n",
    "    FINAL_DISTRIBUTION_PIVOT_TABLE_NAME, FINAL_DISTRIBUTION_PIVOT_BY_AUDIENCES_TABLE_NAME, \\\n",
    "    FINAL_DISTRIBUTION_PIVOT_BY_GRADES_TABLE_NAME\n",
    "from src.utils_bigquery import create_table, drop_table, get_df\n",
    "from src.utils_charts import heatmap_from_df\n",
    "\n",
    "\n",
    "CREATE_CONTRACT_TABLE = False\n",
    "DROP_TABLES = True\n",
    "CREATE_TABLES = True"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Set cyberGift for the Audiences\n",
    "**Total Supply:** 1 PBOOT = 1e15 BOOT\n",
    "\n",
    "\n",
    "**1% of Total Supply:** 10 TBOOT = 1e13 BOOT\n",
    "\n",
    "\n",
    "Distribution between **audiences**\n",
    "\n",
    "\n",
    "<table style=\"text-align: left\">\n",
    "    <thead style=\"text-align: center\">\n",
    "        <tr>\n",
    "            <th>Audience</th>\n",
    "            <th>Share of Total Supply, %</th>\n",
    "        </tr>\n",
    "    </thead>\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Astronauts </td>\n",
    "            <td style=\"text-align: center\"> 2 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Average Citizens </td>\n",
    "            <td style=\"text-align: center\"> 35 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Cyberpunks </td>\n",
    "            <td style=\"text-align: center\"> 2 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Extraordinary Hackers </td>\n",
    "            <td style=\"text-align: center\"> 7 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Key Opinion Leaders </td>\n",
    "            <td style=\"text-align: center\"> 2 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> CEXes </td>\n",
    "            <td style=\"text-align: center\"> 1 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Masters of the Great Web </td>\n",
    "            <td style=\"text-align: center\"> 13 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> Passionate Investors </td>\n",
    "            <td style=\"text-align: center\"> 3 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align: left\"> True Heroes of the Great Web </td>\n",
    "            <td style=\"text-align: center\"> 5 </td>\n",
    "        </tr>\n",
    "    </tbody>\n",
    "</table>"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "gift_per_audience = {\n",
    "    COSMOS_AUDIENCE: 2e13,\n",
    "    CITIZENS_AUDIENCE : 35e13,\n",
    "    CYBERPUNKS_AUDIENCE: 2e13,\n",
    "    HACKERS_AUDIENCE: 7e13,\n",
    "    LEADERS_AUDIENCE: 2e13,\n",
    "    MASTERS_AUDIENCE: 13e13,\n",
    "    INVESTORS_AUDIENCE: 3e13,\n",
    "    HEROES_AUDIENCE: 5e13\n",
    "}\n",
    "ZERO_ADDRESSES = ('0x0000000000000000000000000000000000000000', '0x000000000000000000000000000000000000dead')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Contracts Table"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "query_1 = f'''\n",
    "    SELECT\n",
    "        to_address as address\n",
    "    FROM `bigquery-public-data.crypto_ethereum.traces`\n",
    "    WHERE block_timestamp >= '{INITIAL_TS}'\n",
    "      AND block_timestamp <= '{SNAPSHOT_TS}'\n",
    "      AND trace_type ='create'\n",
    "      AND status = 1\n",
    "'''\n",
    "\n",
    "if CREATE_CONTRACT_TABLE:\n",
    "    if DROP_TABLES:\n",
    "        drop_table(table_name=CONTRACT_ADDRESSES_TABLE,\n",
    "                   dataset_name=SERVICE_DATASET_NAME)\n",
    "    if CREATE_TABLES:\n",
    "        create_table(query=query_1,\n",
    "                     table_name=CONTRACT_ADDRESSES_TABLE,\n",
    "                     dataset_name=SERVICE_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Distribution Table without Gift Size"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table final:distribution_without_gift_size has been deleted.\n",
      "Table final:distribution_without_gift_size has been created and filled 4,612,966 rows.\n"
     ]
    }
   ],
   "source": [
    "query_1 = f'''\n",
    "    SELECT\n",
    "        audience,\n",
    "        segment,\n",
    "        address,\n",
    "        grade\n",
    "    FROM (\n",
    "        SELECT\n",
    "            audience,\n",
    "            segment,\n",
    "            address,\n",
    "            grade,\n",
    "            ROW_NUMBER() OVER (PARTITION BY audience, address ORDER BY grade DESC) AS rank\n",
    "        FROM (\n",
    "            SELECT\n",
    "                '{HEROES_AUDIENCE}' AS audience,\n",
    "                segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{GENESIS_AND_ETH2_DATASET_NAME}.{GENESIS_AND_ETH2_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                IF(segment = 'Contract Creator by Factory', '{MASTERS_AUDIENCE}', '{HACKERS_AUDIENCE}') AS audience,\n",
    "                segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{GAS_ANALYSIS_DATASET_NAME}.{GAS_ANALYSIS_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                '{CITIZENS_AUDIENCE}' AS audience,\n",
    "                segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{ETH_ANALYSIS_DATASET_NAME}.{ETH_ANALYSIS_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                audience,\n",
    "                segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{ERC721_ANALYSIS_DATASET_NAME}.{ERC721_ANALYSIS_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                audience,\n",
    "                segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{ERC20_ANALYSIS_DATASET_NAME}.{ERC20_ANALYSIS_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                '{LEADERS_AUDIENCE}' AS audience,\n",
    "                '{LEADERS_SEGMENT}' AS segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{ERC20_ANALYSIS_DATASET_NAME}.{ERC20_TOP_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                '{MANUAL_ADDRESSES_AUDIENCE}' AS audience,\n",
    "                '{MANUAL_ADDRESSES_SEGMENT}' AS segment,\n",
    "                address,\n",
    "                3 AS grade\n",
    "            FROM `{PROJECT_ID}.{MANUAL_ADDRESSES_DATASET_NAME}.{MANUAL_ADDRESSES_DISTRIBUTION_TABLE_NAME}`\n",
    "\n",
    "            UNION ALL\n",
    "\n",
    "            SELECT\n",
    "                '{COSMOS_AUDIENCE}' AS audience,\n",
    "                '{COSMOS_SEGMENT}' AS segment,\n",
    "                address,\n",
    "                grade\n",
    "            FROM `{PROJECT_ID}.{COSMOS_DATASET_NAME}.{COSMOS_DISTRIBUTION_TABLE_NAME}`\n",
    "            WHERE grade IS NOT NULL\n",
    "            )\n",
    "        WHERE address NOT IN (SELECT address FROM `{PROJECT_ID}.{SERVICE_DATASET_NAME}.{CONTRACT_ADDRESSES_TABLE}`)\n",
    "          AND address NOT IN (SELECT address FROM `{PROJECT_ID}.{ERC20_ANALYSIS_DATASET_NAME}.{STABLECOINS_LOVERS_TABLE_NAME}`)\n",
    "          AND address NOT IN {ZERO_ADDRESSES})\n",
    "    WHERE rank = 1\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=DISTRIBUTION_TABLE_NAME,\n",
    "               dataset_name=FINAL_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_1,\n",
    "                 table_name=DISTRIBUTION_TABLE_NAME,\n",
    "                 dataset_name=FINAL_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Gift per Address Pivot Table"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table final:gift_per_address_pivot has been deleted.\n",
      "Table final:gift_per_address_pivot has been created and filled 24 rows.\n"
     ]
    }
   ],
   "source": [
    "query_2 = f'''\n",
    "    WITH gift_data AS (\n",
    "        SELECT\n",
    "            audience,\n",
    "            [STRUCT(1 AS grade, grade_1 AS number_of_addresses, ROUND(IF(grade_1 > 0, gift_amount_per_audience / grade_1 / number_of_grades, 0), 2) as gift_per_address),\n",
    "             STRUCT(2 AS grade, grade_2 AS number_of_addresses, ROUND(IF(grade_2 > 0, gift_amount_per_audience / grade_2 / number_of_grades, 0), 2) as gift_per_address),\n",
    "             STRUCT(3 AS grade, grade_3 AS number_of_addresses, ROUND(IF(grade_3 > 0, gift_amount_per_audience / grade_3 / number_of_grades, 0), 2) as gift_per_address)] as gift_data_by_audience,\n",
    "            total_addresses AS number_of_addresses_in_audience,\n",
    "            gift_amount_per_audience\n",
    "        FROM (\n",
    "            SELECT\n",
    "                audience,\n",
    "                SUM(IF(grade=1, address_count, 0)) AS grade_1,\n",
    "                SUM(IF(grade=2, address_count, 0)) AS grade_2,\n",
    "                SUM(IF(grade=3, address_count, 0)) AS grade_3,\n",
    "                SUM(address_count) AS total_addresses,\n",
    "                COUNTIF(address_count > 0) AS number_of_grades\n",
    "            FROM (\n",
    "                SELECT\n",
    "                    audience,\n",
    "                    grade,\n",
    "                    count(distinct address) as address_count\n",
    "                FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{DISTRIBUTION_TABLE_NAME}`\n",
    "                WHERE grade IN (1, 2, 3)\n",
    "                  AND audience != '{MANUAL_ADDRESSES_AUDIENCE}'\n",
    "                GROUP BY audience, grade)\n",
    "            GROUP BY audience)\n",
    "        LEFT JOIN (\n",
    "            SELECT\n",
    "                gift.audience as audience,\n",
    "                gift.amount_per_audience as gift_amount_per_audience\n",
    "            FROM UNNEST([{''.join(f\"STRUCT('{k}' AS audience, {v} AS amount_per_audience), \" for k,v in gift_per_audience.items())[:-2]}]) AS gift\n",
    "            )\n",
    "        USING (audience))\n",
    "    SELECT\n",
    "        audience,\n",
    "        number_of_addresses_in_audience,\n",
    "        gift_data_by_audience.number_of_addresses as number_of_addresses,\n",
    "        gift_data_by_audience.grade as grade,\n",
    "        gift_data_by_audience.gift_per_address as gift_per_address\n",
    "    FROM gift_data\n",
    "    CROSS JOIN UNNEST(gift_data.gift_data_by_audience) AS gift_data_by_audience\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=GIFT_PER_ADDRESS_PIVOT_TABLE_NAME,\n",
    "               dataset_name=FINAL_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_2,\n",
    "                table_name=GIFT_PER_ADDRESS_PIVOT_TABLE_NAME,\n",
    "                dataset_name=FINAL_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Final Distribution Table"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table final:final_distribution has been deleted.\n",
      "Table final:final_distribution has been created and filled 4,612,968 rows.\n"
     ]
    }
   ],
   "source": [
    "query_3 = f'''\n",
    "    SELECT\n",
    "        audience,\n",
    "        segment,\n",
    "        address,\n",
    "        CAST(grade as INT64) as grade,\n",
    "        gift\n",
    "    FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{DISTRIBUTION_TABLE_NAME}`\n",
    "    LEFT JOIN (\n",
    "        SELECT\n",
    "            audience,\n",
    "            grade AS grade,\n",
    "            gift_per_address / 1e6 AS gift\n",
    "        FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{GIFT_PER_ADDRESS_PIVOT_TABLE_NAME}`\n",
    "        )\n",
    "    USING (audience, grade)\n",
    "    WHERE audience != '{MANUAL_ADDRESSES_AUDIENCE}'\n",
    "\n",
    "    UNION ALL\n",
    "\n",
    "    SELECT\n",
    "        '{MANUAL_ADDRESSES_AUDIENCE}' AS audience,\n",
    "        '{MANUAL_ADDRESSES_AUDIENCE}' AS segment,\n",
    "        address,\n",
    "        3 AS grade,\n",
    "        amount / 1e6 AS gift\n",
    "    FROM `{PROJECT_ID}.{MANUAL_ADDRESSES_DATASET_NAME}.{MANUAL_ADDRESSES_DISTRIBUTION_TABLE_NAME}`\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=FINAL_DISTRIBUTION_TABLE_NAME,\n",
    "               dataset_name=FINAL_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_3,\n",
    "                 table_name=FINAL_DISTRIBUTION_TABLE_NAME,\n",
    "                 dataset_name=FINAL_DATASET_NAME,\n",
    "                 clustering_fields=['audience', 'segment', 'grade'])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Final Distribution Pivot Tables for Dashboard Speeding up"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table service:final_distribution_pivot_by_segments_and_grades has been deleted.\n",
      "Table service:final_distribution_pivot_by_segments_and_grades has been created and filled 35 rows.\n"
     ]
    }
   ],
   "source": [
    "query_4 = f'''\n",
    "    SELECT\n",
    "        audience,\n",
    "        segment,\n",
    "        grade,\n",
    "        count(DISTINCT address) as number_of_addresses,\n",
    "        sum(gift) as gift\n",
    "    FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{FINAL_DISTRIBUTION_TABLE_NAME}`\n",
    "    GROUP BY audience, segment, grade\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=FINAL_DISTRIBUTION_PIVOT_TABLE_NAME,\n",
    "               dataset_name=SERVICE_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_4,\n",
    "                table_name=FINAL_DISTRIBUTION_PIVOT_TABLE_NAME,\n",
    "                dataset_name=SERVICE_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table service:final_distribution_pivot_by_audiences has been deleted.\n",
      "Table service:final_distribution_pivot_by_audiences has been created and filled 10 rows.\n"
     ]
    }
   ],
   "source": [
    "query_5 = f'''\n",
    "    SELECT\n",
    "        audience,\n",
    "        count(DISTINCT address) as number_of_addresses\n",
    "    FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{FINAL_DISTRIBUTION_TABLE_NAME}`\n",
    "    GROUP BY audience\n",
    "\n",
    "    UNION ALL\n",
    "\n",
    "    SELECT\n",
    "        'Total' as audience,\n",
    "        count(DISTINCT address) as number_of_addresses\n",
    "    FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{FINAL_DISTRIBUTION_TABLE_NAME}`\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=FINAL_DISTRIBUTION_PIVOT_BY_AUDIENCES_TABLE_NAME,\n",
    "               dataset_name=SERVICE_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_5,\n",
    "                table_name=FINAL_DISTRIBUTION_PIVOT_BY_AUDIENCES_TABLE_NAME,\n",
    "                dataset_name=SERVICE_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table service:final_distribution_pivot_by_grades has been deleted.\n",
      "Table service:final_distribution_pivot_by_grades has been created and filled 3 rows.\n"
     ]
    }
   ],
   "source": [
    "query_6 = f'''\n",
    "    SELECT\n",
    "        grade,\n",
    "        count(DISTINCT address) as number_of_addresses\n",
    "    FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{FINAL_DISTRIBUTION_TABLE_NAME}`\n",
    "    GROUP BY grade\n",
    "'''\n",
    "\n",
    "if DROP_TABLES:\n",
    "    drop_table(table_name=FINAL_DISTRIBUTION_PIVOT_BY_GRADES_TABLE_NAME,\n",
    "               dataset_name=SERVICE_DATASET_NAME)\n",
    "\n",
    "if CREATE_TABLES:\n",
    "    create_table(query=query_6,\n",
    "                table_name=FINAL_DISTRIBUTION_PIVOT_BY_GRADES_TABLE_NAME,\n",
    "                dataset_name=SERVICE_DATASET_NAME)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Distribution Heatmap"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "query_7 = f'''\n",
    "    SELECT\n",
    "        ANY_VALUE(audiences) AS audiences,\n",
    "        count(address) AS number_of_addresses\n",
    "    FROM (\n",
    "        SELECT\n",
    "            address,\n",
    "            ARRAY_AGG(DISTINCT audience) as audiences\n",
    "        FROM `{PROJECT_ID}.{FINAL_DATASET_NAME}.{FINAL_DISTRIBUTION_TABLE_NAME}`\n",
    "        WHERE audience NOT IN ('{COSMOS_AUDIENCE}')\n",
    "        GROUP BY address)\n",
    "    GROUP BY TO_JSON_STRING(audiences)\n",
    "'''\n",
    "\n",
    "final_distribution_df = get_df(query_7)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 864x864 with 2 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2oAAAO5CAYAAABogdaKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAADhaklEQVR4nOzdd1hU59b38R8IIoK9YMOCPUajqNGosetRo8YKFrDGlkSNLYi9K1iw93rAAij2EqPGmtiSGE1irLFGRUVUEJAy7x++zCMCiokcZsj381xcT2bPve+99p6Zc81yrX2PhcFgMAgAAAAAYDIs0zoAAAAAAEBCJGoAAAAAYGJI1AAAAADAxJCoAQAAAICJIVEDAAAAABNDogYAAAAAJoZEDQBSyfDhw1W6dOkEf++//77q1KmjYcOG6dKlS4n2cXd3V/369d/6WM+fP9e9e/feOC4oKEilS5fWiRMnknz8rty8edP437du3VLp0qU1b968d3qMd+Xx48fq16+fKlasqKpVq+r3339/7finT59q9erVcnFxUfXq1VWhQgU1btxYEyZM0F9//ZVofOnSpTV8+HDj4+fPn8vT01POzs5ydnbWgQMHJCW8ZslJ6j1VtmxZOTs7q3379tq8efNbnv2bPXz4UM+ePUsUw9uYN2+eSpcurVu3br3r8N5aXFzcO4njxIkTKl26tIKCgt5BVK/n4eGh0qVLa8KECaky/6vnYuqfWeDfwiqtAwCA9M7T01M5cuSQJEVEROjGjRvatGmTvvnmGy1btkzVqlUzju3bt68iIiLeav7bt2+rR48e6tOnj9q0afPasVWrVpW3t7eKFy/+9ieSQj179lSePHk0bdo0SVLOnDnl7e391l/u/1cWL16sAwcOqFu3bnJyclLRokWTHXv58mX169dPf/31l5o0aaKWLVvKxsZGf/zxhzZv3qwtW7ZoxYoVqlSpknEfb29vFS5c2Pg4ICBAQUFB+vTTT1W1alW9//772rRpk8aPH6+zZ8+mKOaX31MGg0FhYWHatm2bhg8frkePHqlHjx5/72K84tChQxo6dKg2b96szJkzS5JcXV310UcfvdU8jRo1UuHChZUzZ853EtffFRYWpm7duqlOnTrq379/msaSUpGRkfr222+VOXNm7dy5U8OHD1fGjBlT9Zim/pkF/i1I1AAglTVs2FCFChVKsM3d3V1t27bVV199pX379snOzk6SVLNmzbee/9atW7p27VqKxjo6OsrR0fGtj/E2jh49qtatWxsfZ86cWZ9++mmqHvOfuHDhgrJnzy5PT8/XjouMjFTfvn319OlTBQQEqFy5cgme7969uzp16qSvv/5au3btkrW1tSQlOvcLFy5IksaMGSN7e3tJ0qlTpxQVFZXimJN6T7Vr107NmjXTggUL5Obm9k6+zJ89e1ZPnjxJsK1SpUoJEtGUKFOmjMqUKfOP4/mnQkNDde7cOdWpUyetQ0mxAwcOKDw8XH369NGSJUt04MABNWnSJFWPaeqfWeDfgtZHAEgD+fPnl4eHh0JCQrRp06a0DudfLTo62pgov86qVat08+ZNff3114mSNEkqVKiQBgwYoBs3buj48eOvPZ4kY5L2rmTKlEn169dXWFhYkm21ME/bt2+XnZ2devToIWtr61RpbwVgmkjUACCNNGnSRBkzZtSRI0eM2169R+358+eaPHmyGjRoYLy/bfz48Xr8+LGkF/eYdenSRdKLdrj4VqV58+apfPny+vbbb1WzZk1VqlRJgYGByd6TFhwcrC+++EIVK1ZUjRo1NHHiRIWFhRmfT26/l7fH39ciSZs3b060/dX7XQIDA/Xpp5+qfPnyql69uoYMGZLg3qH4/bZs2SIfHx/Vrl1b5cuXV/v27V+bCKX0GPHznzx5Urdv3050L9mrtm/frjx58ry2vbRJkyZau3atatSoYdz28rylS5c2ftEuXbq03N3d5e7unmDb62J4EwsLC0lSbGyspBdtkevXr1e7du1UqVIllS9fXk2aNNHSpUtlMBiM+9WvX1+jRo3SiBEjVKFCBdWuXVt9+vTR/PnzJUkNGjSQu7u7pKTvUbt3755GjBihWrVqqVKlSmrbtq327dtnfP7Ve9TmzZun9957T1evXpW7u7s++OAD1a9fXwsXLjTGHu+3335T//79VaNGDZUrV04fffSRhgwZort37yaYv3z58rp27Zr69OmjSpUqqWrVqvLw8NCjR48kvbgPq0GDBpKk+fPnJ4jnm2++Udu2bVWpUiVVrlxZ3bt3148//piiax4WFma85/DDDz/U119/rfv370t6cT9c7dq11a5du0T7HT58WKVLl9bBgweTnTs0NFRHjhxRlSpVlD17dlWrVk1Hjhwxzh8vufvlktr+7NkzTZ48WbVq1VLFihX1xRdfKDg4OMF+yX1mg4KC1KpVK+Pnafjw4Qn2fdvP7NatW9W2bVtVrFhRtWvX1pgxYxQSEvJWx5ReVKl79uxpvGe0devW2rhxY7LXFTAXtD4CQBqxsbFR4cKF9ccffyQ7ZsKECdqxY4e6dOkiR0dHXbp0SWvXrtX169e1cuVKVa1aVX379tXixYvl6uqqypUrG/eNiYnRmDFj1L17dz1//lyVK1fWmTNnkjzOmDFjVLZsWQ0ZMkQXL17U2rVrdenSJa1Zs8b45f9N4u9r+frrr1WlShW5uLioePHiioyMTDTWy8tLK1eu1EcffaSvv/5awcHB8vPz0/fff6/AwMAEbX1z5syRra2tevTooejoaK1cuVJ9+vTRwYMHjfdpJeVNx4iPd/HixXr06JE8PT0T3Ev2socPH+rKlStq3rz5a6+Hvb29qlSpkuzz3t7eCggI0OnTp+Xt7a3cuXNLevGFPn5bcjG8SVxcnE6ePKmMGTMa70GcPXu2Fi9erNatW8vFxUXh4eHasmWLZs6cKTs7O3Xu3Nm4/86dO+Xk5KQRI0bowYMHqlmzpqytrfXtt9/K09NTJUuWTPK4oaGhcnFxUWhoqDp37ixHR0ft2LFDX375pebPn6+GDRsmuZ/BYFD37t1VsmRJDRs2TCdOnNCcOXN09+5d46IZFy5cUKdOnVSkSBH17t1btra2+umnn7R161Zdv349wZfxuLg4denSRVWqVJGHh4fOnTunjRs3KjIyUnPmzFHx4sXl6empqVOnqlGjRmrUqJFy5sypkydPatCgQapdu7bat2+viIgI+fn5qXv37tq5c+cbW4V9fHyM1dR79+7J19dX586d0+bNm5UpUyY1a9ZMq1at0q1btxK8r3fu3Kns2bO/tt35m2++UXR0tPEaNmrUSEePHtXWrVv12WefvTau5K553759derUKbm4uKhkyZLas2ePxowZ88Z958+fr3nz5uk///mPXFxcdO/ePfn5+enkyZPauHFjgvsPU/KZXbZsmWbMmKHKlStr8ODBevjwodasWaPz589r/fr1srKyStExQ0JC1LNnT+XIkUP9+vWTjY2Ndu7cqZEjR8rGxkYtWrR46+sEmAwDACBVeHh4GEqVKmW4efNmsmM6dOhgeP/9942P3dzcDPXq1TM+rlChgmH8+PEJ9vHx8TG0adPGEBYWZjAYDIbjx48bSpUqZdi0aZNxzNy5cw2lSpUyLFmyJMG+mzZtMpQqVcpw/PjxBI9dXV0N0dHRxnHz5s0zlCpVyrB///4k90tuPoPBYChVqpTBw8PD+PjmzZuGUqVKGebOnWswGAyGS5cuGUqXLm344osvDHFxccZxZ86cMZQuXdowYMCABPvVqVPHEB4ebhy3c+dOQ6lSpQz+/v7JXteUHsNgSHzNk/Lrr78aSpUqZfDy8kr03JMnTwwPHz5M8Bf/2iR1PeLfFy9LaltS4sf99ttvxmMFBwcbfv75Z8PAgQMNpUqVMkyZMsVgMBgMz58/Nzg7OxsGDRqUYI6nT58a3n//fUOfPn2M2+rVq2coU6aM4e7duwnGxr+PXn4Pvxqrt7e3oVSpUobTp08bt0VGRhoaNmxoaNu2bZLzxD/+/PPPE7w+Q4YMMZQuXdpw+fJlg8FgMIwZM8bwwQcfGB49epQgrkGDBhlKlSpl3B4/39SpUxOM69mzp+G9994zPHv2zGAwJH4vGgwGw9ixYw2VKlVKEMcff/xhaNy4sWH37t2JXoN48Z+7+vXrJ3h/BgUFGUqVKmX473//azAY/u+9s3TpUuOYqKgog7Ozs2HMmDHJzm8wGAydO3c2lClTxvDgwQODwWAw3L9/31CmTBlDs2bNkozl5f8NSGr7gQMHDKVKlTKsWrXKOCY6OtrQtWvXBONevU43btwwlClTxjBjxowE81+4cMFQrlw5w+TJkxPs96bPbGhoqKF8+fKGnj17GmJiYozjAgICDKVKlTIcPHgwxceMn/vs2bMJrm/r1q0T7QuYG1ofASANxcTEvLZCky9fPu3atUtBQUHGRR2++uorbdq0KUX3VVWtWjVFcXTr1k1WVv/XZBHf5va6tqy/67vvvpPBYFDv3r0TnPsHH3ygmjVr6tChQ4qJiTFur1OnjnHFQUnGRSlebf/6J8d4k7i4OElK0C4Yr2vXrvroo48S/E2cODHFc/8drVu3Nh6rVq1acnV11f79++Xu7q4hQ4ZIkqytrfX9998nWtL90aNHsre3T7DkviQVLlxYDg4Obx3LwYMHVa5cuQTVXBsbGy1dulRz58597b6vvj7du3eXwWDQd999J0kaN26cDhw4oOzZsxvHhIWFycbGRpISnUPTpk0TPC5btqxiYmIUGhqabAz58uVTeHi4Jk2apCtXrkh60YL6zTffpGjRjk6dOiV4f7Zs2VLZsmUzfnbKlSsnJycn7d692zjm0KFDCgsLU/PmzZOd986dOzp9+rQqV66sXLlySZJy584tZ2dnXb58OcUrhL7s8OHDsrS0VPv27Y3brKysElRWk/Ltt98qLi5O9evXV0hIiPEvd+7cKlu2bKL/nXjTZ/b7779XVFSUOnfurAwZMhjHtWzZUkFBQfrwww9TfMx8+fJJkmbOnKnTp08rNjZWGTNmVFBQkPGzAJgrWh8BIA2Fhoa+dsnycePG6auvvpKnp6dGjx6tihUrqlGjRmrbtq2yZMnyxvnjv+C9iZOTU4LH2bJlU7Zs2XT79u0U7f824u8LKlasWKLnihcvrqNHjxrvK5KU6PrEr2YYnzz9k2PkyZMnRTHnzZtXkvTgwYNEz40bNy7B/Xzdu3dP0Zz/xPTp041tk5aWlsqaNauKFy9uTGDiWVtb6+DBg9q/f7/+/PNPXb9+3Xh/46tJZ0rfK6+6fft2kr/9l9S1f9WrPxNRpEgR45zSi3vuHj16pCVLlujChQu6ceOG/vrrL2Psr74HknuvvHrf28vc3Nx09OhR+fn5yc/PT4UKFVK9evXUrl27FK1U+epnJ0OGDCpYsGCCz07z5s01d+5c3bx5U46Ojtq5c6fy58//2jbZHTt2yGAwqHLlygnu3axSpYpOnz6toKAgVahQ4Y3xvez27dvKlStXon/kefUcXnXjxg1JUocOHZJ8Pn6F03hv+szGX5v41zuejY2NcaGelB7T2dlZXbp0ka+vr3744Qdlz55dtWrVUosWLVS3bt3Xnhdg6kjUACCNhIWF6ebNm6/9MvHRRx/pu+++M/4dO3ZMU6dO1erVqxUUFPTG36WytExZ40RSVT2DwZDgX7uT8rovwMlJqioVL/6LnLW1tXG5+pSew985Rko5ODioYMGCOnnyZKLn3vbL8rvg7OycaHn+VxkMBn3++ef67rvvVLlyZVWqVEmurq6qWrWqunbtmmj8m17r5MTGxqb4PsZXvfoaxL828bHs2rVLQ4cOVd68eVW9enXVrl1b77//vo4ePaolS5Ykmu/vxGFvby8/Pz+dOXNG+/bt0+HDh+Xr66u1a9fK29v7jfc4peSz06JFC82dO1e7d++Wm5ubDh48qI4dO7423u3bt0t68Tt/ixcvTvT8rl27NGLEiNf+DMOriayFhUWSPwPxun/0ePn5RYsWKVOmTK8dK735Mxs/3+vO/22OOXLkSLm7u+ubb77R4cOH9c0332jHjh1ydXVNtR8JB/4XSNQAII3s2bNHBoPBuBLdq54/f67z588rX758+uSTT/TJJ58oLi5Oq1atkre3t3bu3GlsUfynbt++nWCxiJCQED158sS4sEX8F6/nz58n2C+pCtObxCcYV69e1QcffJDguT///FOZM2dWtmzZElSpUusYb6NFixZavHixdu/enajFzhSdPn1a3333nT7//HMNHDjQuD2+FfBd/Z5egQIFjNWPl23evFk//vjjaxequHnzpkqUKGF8HP97gPGVlpkzZ6pIkSLatGlTgla6+CTmXfjzzz/19OlTVaxYURUrVtTQoUN1+fJlde7cWatWrXpjovZq1Tk6Olq3bt1KUC0rXLiwKlSooAMHDsjJyUkRERGvnffSpUu6cOGCypcvr759+yZ6fvXq1Tp16pT27dunZs2aGZPCVz+fr7YHOzo66uDBgwoJCUnwjzw3b9587TkWLFhQ0oufFSlbtmyC5w4dOvTWPzWRP39+SS+qZi9XXp8/f65hw4apRYsWKT7mgwcPdOnSJX300Ufq1auXevXqpUePHumLL75QQECAhg0blqLuA8AUcY8aAKSB4OBgzZ07Vw4ODsl+YXv06JFcXV0TVA4sLS1Vvnx5439L/1d9eNO/ir9OYGBggscrVqyQJGMSGd8ieP78eeOYmJgY7d27N9FclpaWr42lXr16kl6s+vZy5eu3337T999/rzp16vztCk1qHqN3794qXLiwxo0bp9OnTyd6PioqSjNnzvxb8ca/lv/kNXxV/H1ZLydCkhQQEKCIiIgU3aMXH9frKpS1a9fWuXPn9Ouvvxq3RUdHa8WKFfr1119fW/Hx9fVN8HjVqlWysrIytlKGhoaqQIECCZK0O3fuGN93b1vRTeqzMmnSJH3++ecKDw83bnNyclLWrFlTVM0NCgpKEEdgYKCePn2aaLXLFi1a6OzZs9q2bZucnJz03nvvJTtnfCLq5uamhg0bJvrr0aOH8diSjG2wL38+pRdVt5c1atRIkrRy5UrjNoPBoHXr1r32HOM/T0uWLEnwXjh//rz69eunNWvWvHb/V9WoUUPW1tYKCAhIMN+ePXu0Z8+etzpmUFCQunXrpnPnzhnH5MiRQ0WKFJGFhcXfqsgDpoKKGgCksn379hmXpI6KitLVq1e1ZcsWRUVFadmyZcm29cQncevWrVNERIQqVaqk0NBQ+fn5KXfu3MaqTvzc27Ztk8FgUOvWrd86xtOnT+vzzz9XnTp19NNPP2nLli1q2rSpPvroI0nShx9+qDx58mjhwoWKiopSrly5tHXr1kSLOUgyLnkeEBCgWrVqJXq+ZMmScnd3l6+vr7p3766GDRvq/v378vX1VdasWd/JAgCpcQw7OzstW7ZM/fv3V5cuXVS7dm1Vq1ZNdnZ2unLlinbu3Kn79++rXLlyb32fWnx1Y+7cuapWrZrxuv8TlSpVkr29vaZOnarbt28rW7ZsOnHihHbt2iUbG5sEicmb4lq+fLlq166dZPW3b9+++uabb9S1a1e5ubkpb9682rlzp65cuZIgIUjK5s2bFRYWJmdnZx05ckTfffedvvjiC2M1pXbt2tq1a5fGjBmj8uXL69atW8ZEU1KKzuFl2bNnl6Wlpfbv368CBQqocePG6t69u3r16qXOnTurVatWsrGx0b59+3Tjxg15eXm9cc5bt26pa9euat68uS5fvqx169apUqVKatWqVYJxzZo107Rp0/TNN9+of//+yc5nMBi0Y8cO2dvb6z//+U+SY+rUqaP8+fPr+++/171791S0aFGVK1dOAQEBypw5s4oWLapvv/02UaWsWrVqatq0qZYtW6b79+8bq3y//fbba8+xVKlSxs9TaGioGjZsaPzfIjs7uwQV25TIlSuXvvjiC82ePVs9evRQw4YNdffuXfn5+alatWqqX7++LC0tU3TMVq1aadWqVerbt686duwoBwcH/frrr9qyZYtat26dokWXAFNFogYAqWzq1KnG/7a2tpaDg4Pq16+vXr16vXHBhYkTJxoXH9i5c6dsbW310UcfadCgQcYv0cWLF5e7u7uCgoJ07tw5VatW7a1j9PHx0YoVKzR58mRlz55d/fr10xdffJEg7uXLl2vatGlavny5MmfOrObNm6tx48Zyc3NLMNfQoUM1c+ZMTZw4URMnTkxywYSRI0eqWLFi2rBhg6ZNm6Zs2bKpUaNGGjBggPFL+j+VGscoWrSoAgMDtXXrVu3YsUPLly/X48ePlStXLlWuXFktW7ZU/fr137pa17FjRx0/flzLly/XuXPn3kmiljt3bi1dulQzZszQokWLlDFjRhUrVkyzZs3S2bNn9d///lcPHjwwVmOS8sknn2jv3r0KCgrSyZMnk0zUcuXKJX9/f82cOVMbNmzQ8+fPVaZMGeNv2L3O/PnztWDBAu3du1eOjo6aOHGiXFxcjM+PGzdOmTNn1oEDB7R161bly5dPrVq1UqNGjYzX7HWVqVfZ2tpq0KBBWrFihSZNmqTChQurVq1aWrRokZYsWWL8h4iSJUtq1qxZ+uSTT94459ixY7V3715NmzZNmTJlUocOHTR48OAEq6hKL16Pjz76SEePHn3tao8//fSTbt++LVdXV9na2iY5JkOGDHJxcdGcOXO0detW9e7dW3PnztW0adO0YcMGY1VyxIgRidp0p0+frmLFimnz5s3avXu3qlSpolmzZr3xHxdGjhwpJycnbdiwQV5eXsqSJYuqVKmigQMHJloUJiX69eunPHny6L///a+mTZumPHnyyMXFRf379zdWwVJyzLx58+q///2v5s6dqw0bNig0NFQFCxbUl19+qV69er11XIApsTC8rp8BAADgHZs3b57mz5+v/fv3v3FRlPTks88+0+PHjxO1GgNAUmjcBQAASGXXr1/XDz/8oDZt2qR1KADMBK2PAAAAqeTw4cPavHmzTp06pRw5cujTTz9N65AAmAkqagAAAKnE1tZWR44ckZ2dnebOnZtgBUsAeB3uUQMAAAAAE0NFDQAAAABMDIkaAAAAAJgYEjUAAAAAMDEkagAAAABgYkjUAAAAAMDEkKgBAAAAgIkhUQMAAAAAE0OiBgAAAAAmhkQNAAAAAEwMiRoAAAAAmBgSNQAAAAAwMSRqAAAAAGBiSNQAAAAAwMSQqAEAAACAiSFRAwAAAAATQ6IGAAAAACaGRA0AAAAATAyJGgAAAACYGBI1AAAAADAxJGoAAAAAYGJI1AAAAADAxJCoAQAAAICJsUrrAAD8b9lWGZTWIZiMS996pXUIJmPItt/SOgSTcft+WFqHYDKK5sua1iGYDKc8mdM6BJMxe9UPaR2CyciRN0dah2Ayrs9tkdYhyLbSl2kdgiJ+nv/O5qKiBgAAAAAmhooaAAAAAPNnkb5qUOnrbAAAAAAgHSBRAwAAAAATQ+sjAAAAAPNnYZHWEbxTVNQAAAAAwMRQUQMAAABg/lhMBAAAAACQmkjUAAAAAMDE0PoIAAAAwPyxmAgAAAAAIDVRUQMAAABg/lhMBAAAAACQmkjUAAAAAMDE0PoIAAAAwPyxmAgAAAAAIDWRqAEAAACAiaH1EQAAAID5Y9VHAAAAAEBqoqIGAAAAwPyxmAgAAAAAIDWRqAEAAACAiaH1EQAAAID5YzERAAAAAEBqoqIGAAAAwPyxmAgAAAAAIDWRqAEAAACAiaH1EQAAAID5YzERAAAAAEBqoqIGAAAAwPyxmAgAAAAAIDWRqAEAAACAiaH1EQAAAID5M4PFRJYsWaIDBw4oOjpaHTt2VPv27ZMdS6IGAAAAAKnsxIkT+vnnn7V+/XpFRERo5cqVrx1PogYAAADA/Jl4Re3o0aMqVaqUvvjiC4WFhenrr79+7XgSNTOzbNkyrVmzRvv375eNjU1ah2N0+vRpLViwQDExMXr27JnatGmjzp076/Dhw7pz545cXV3l7++vNm3a6PLly9q/f7++/PLL/1l8t27dUsuWLVWuXLkE21evXq0ePXooLi5OV69eVc6cOZU9e3bVqFFDDg4Ounr1qoYOHWocP2jQIHXo0EHVqlVLMM/Zs2fVqVMnrVu3ThUqVHjr+E6cOKENGzbIx8cnxfsMGjRIXl5eypgx41sfDwAAAO+ev7+//P39jY9dXV3l6uoqSXr06JH++usvLV68WLdu3VK/fv20Z88eWSSzWiWJmpnZtm2bmjVrpp07d6pNmzZpHY4k6ebNm5o0aZKWL1+u3LlzKzIyUl26dJGjo6Nq165tHLdkyRK1atVKZcuWVdmyZf/ncZYoUUK+vr6Jtq9Zs0aSNHz4cDVr1swYc1BQUIrnDggIUPfu3f92ovZ3vE1SBwAAgNT3cmL2quzZs8vJyUkZM2aUk5OTbGxsFBISoly5ciU5nkTNjJw4cUKFCxdWhw4dNGzYML333nuaPHmyMfno06ePBg4cqLCwMPn4+ChDhgxydHTUhAkTtH37dm3atElxcXEaMGCArly5or179yoiIkI5cuTQ/PnzFRcXp6+//lrBwcHKnz+/Tp06paNHj+rChQuaNGmSpBdvsClTpihLlizGuLZu3apWrVopd+7ckqRMmTJpxYoVypw5s4KCgnT16lUVKVJE9+/f16BBg9S1a1dt2LBBgwcP1ogRIyRJ4eHhunr1qn744QcdPHhQq1evlqWlpSpXrqyhQ4dq3rx5unXrlh4+fKi//vpLnp6e+vjjj+Xj46MTJ04oJiZGjRs3Vu/evf/Hr8qL2I8fP66dO3eqRYsWCgkJUc6cOZONec+ePVq7dq1iYmJkYWGh+fPnG+c6evSoAgICNHfuXElShw4dNGfOHM2ePVvXr183JsGtWrVS/fr1tXv3bh06dEjLli2TlZWV8ubNKx8fH1lamnbpHwAA4J2zNO3fUatcubL++9//qnv37goODlZERISyZ8+e7HgSNTMSGBio9u3bGzPxqKgoPX/+XLdv35a1tbUePXqksmXLqkmTJlq3bp1y5cql2bNna/PmzbKyslLWrFm1aNEixcXF6ccffzQmQz179tS5c+f066+/qlChQpo7d66uXLmi5s2bS5JGjx6tKVOmqESJEgoMDNTy5cs1aNAgY1zBwcEqU6ZMglhfTuQkqX379lq0aJF8fHx05swZSZKjo6N8fX31/Plz9e3bV3PmzFFUVJTmzZunTZs2ydbWVsOGDdOxY8ckSRkzZtTy5ct17NgxrVy5Uh9//LG2b9+u//73v8qbN+8bK2CXL1+Wu7u78XG5cuU0fPjw1+6zY8cO/fLLLwnm6NChQ4Ixu3btUqNGjWRjY6OmTZtq48aNxoQxqZivXbumpUuXytbWVmPGjNHRo0fl4OAgSapZs6YmTZqkx48fKzg4WDly5JCdnZ1OnTqlgIAASTJej5dj7Nmzp5o0aaItW7YoLCxMWbNmfe15AQAA4H+rXr16OnXqlNq1ayeDwaAxY8YoQ4YMyY4nUTMTjx8/1uHDhxUSEiJfX1+FhYXJz89P7dq105YtW5QxY0a1adNGISEhCg4O1ldffSVJioyMVI0aNVSkSBEVK1ZMkmRpaSlra2sNHjxYmTNn1t27dxUTE6MrV64Y2/6KFy+unDlzSpKuXLmi8ePHS5Kio6NVtGjRBLEVKFBAd+/eTbDtjz/+UFxc3BvPKyYmRoMGDVLLli1Vp04dnT17ViEhIcZEJzw8XDdu3JAkY7tkvnz59Pz5c0nS9OnTNXPmTD148EAff/zxa4+VXOvj6zRv3jzRPWqvCgwMVIYMGdSzZ09FRkbq7t27+uyzz5KNOVeuXPLw8JCdnZ2uXr2qihUrGueysLBQy5YttWPHDt26dUvt2rWTvb29RowYodGjRyssLEwtW7ZMcHxPT08tWbJEfn5+cnJyUsOGDd/qHAEAAPC/8aYFRF5GomYmtm3bprZt28rDw0OSFBERoQYNGmjw4MEaMGCALC0tje2G+fLl08KFC5UlSxbt379fmTNn1p07d4ztcH/88Yf27dunwMBARUREqE2bNjIYDCpVqpR+/vlnNWzYUDdu3NCjR48kScWKFZOXl5cKFCigH3/8Uffv308QW/PmzfXFF1+oWbNmypkzp8LDwzVmzBh98cUXCcZZWFgkSN4MBoNGjhypSpUqqVWrVpKkQoUKKX/+/Fq5cqWsra0VFBSksmXLat++fYlutHz+/Ln27NmjWbNmSZKaNWumTz75RAULFnx3F/4NLly4oNjYWGO1S5K6d++u7777TpISxfz06VPNnTtXBw8eNI41GAwJxrRt21ZDhw5VRESEhgwZouDgYP32229asGCBoqKiVKdOHX366afG8f7+/urfv79y5cqlMWPG6Ntvv1Xr1q1T6YwBAABMlImv+vi2SNTMRGBgoLy9vY2PbW1t1bhxY23dulVlypRRTEyM7O3tJUkjR45U7969ZTAYZGdnJ29vb925c8e4b5EiRWRra2ts4cuTJ4+Cg4PVrl07DR8+XJ07d1aBAgWMq0qOGzdOHh4exnuqJk+enCC2QoUKadiwYfryyy+VIUMGhYeHq127dqpTp06CdsQqVaqod+/exgRuz5492rt3r+7du6dDhw5JksaOHatu3brJ3d1dsbGxKliwoJo2bZrkNcmYMaOyZcsmFxcXZcqUSTVr1lSBAgW0fft2PXv2LNGNnK+2PkrSlClT5OjomPIX4hWBgYEJkibpRZvn2rVrValSpUTj7e3t5ezsLFdXV2M7anBwsAoVKmQc4+DgIDs7O1WsWFFWVlbKkyeP7t+/rw4dOsjS0lI9evSQldX/fXQrVKigPn36yM7OTpkzZ1bdunX/9vkAAADANFgYXv3nfPxr/fTTT3r27Jlq1aqla9eu6bPPPtO+ffvSOqx/pT59+mjEiBEqUqTIO5/btkri9s1/q0vfeqV1CCZjyLbf0joEk3H7flhah2Ayiubjftd4Tnkyp3UIJmP2qh/SOgSTkSNvjrQOwWRcn9sirUOQbYMpaR2CIvaPeGdzUVGDkaOjowYPHqz58+crJiZGY8aMSeuQ/nUiIyPVqVMnVatWLVWSNAAAAJgHEjUY5cmT560X28C7lSlTprf6/TYAAACkTyRqAAAAAMxfOltMJH2dDQAAAACkA1TUAAAAAJi/V34WydxRUQMAAAAAE0OiBgAAAAAmhtZHAAAAAOaPxUQAAAAAAKmJihoAAAAA88diIgAAAACA1ESiBgAAAAAmhtZHAAAAAOaPxUQAAAAAAKmJihoAAAAA88diIgAAAACA1ESiBgAAAAAmhtZHAAAAAOaPxUQAAAAAAKmJihoAAAAA88diIgAAAACA1ESiBgAAAAAmhtZHAAAAAOaPxUQAAAAAAKmJRA0AAAAATAytjwAAAADMH62PAAAAAIDUREUNAAAAgPnjd9QAAAAAAKmJRA0AAAAATAytjwAAAADMH4uJAAAAAABSExU1AAAAAOaPxUQAAAAAAKmJRA0AAAAATAytjwAAAADMH4uJAAAAAABSk4XBYDCkdRAAkBauP4xK6xBMRpFcNmkdAmDSnkbGpXUIJuNpZExah2AyctpnTOsQTEYmE+jTs22zIq1DUERQz3c2FxU1AAAAADAxJGoAAAAAYGJMoEgJAAAAAP+MBb+jBgAAAABITVTUAAAAAJg9KmoAAAAAgFRFogYAAAAAJobWRwAAAADmL311PlJRAwAAAABTQ0UNAAAAgNljMREAAAAAQKoiUQMAAAAAE0PrIwAAAACzR+sjAAAAACBVkagBAAAAgImh9REAAACA2aP1EQAAAACQqqioAQAAADB7VNQAAAAAAKmKRA0AAAAATAytjwAAAADMX/rqfKSiBgAAAACmhooaAAAAALPHYiIAAAAAgFRFogYAAAAAJobWRwAAAABmj9ZHAAAAAECqoqIGAAAAwOxRUQMAAAAApCoSNQAAAAAwMbQ+AgAAADB7tD4CAAAAAFIVFTUAAAAA5i99FdSoqAEAAACAqSFRAwAAAAATQ+sjAAAAALOX3hYTIVEDUtGlS5c0ffp0RURE6NmzZ6pTp45at26tTz/9VOXKlUswdvXq1Zo3b56Cg4M1ZcoUSdLRo0e1ZMkSrVq1SlZWfFwBAAD+LfjmB6SSJ0+eaPDgwZo3b56KFi2q2NhYDRw4UEePHlWJEiXk6+ubaJ8vv/xSbm5u2rVrlypWrKipU6eSpAEAAKQAFTUAKbJ//35Vq1ZNRYsWlSRlyJBBXl5eCg4O1ubNm5Pcx8rKSjNmzFCXLl2UN29ejRo1Snnz5pUk7d69W6tXr5alpaUqV66soUOH6scff5SXl5esrKxka2urOXPmyN7e/n91igAAAEglJGpAKgkODpajo2OCbXZ2drK2ttbly5fl7u5u3F6uXDkNHz5cklSoUCE5Ozvr999/V9WqVSVJoaGhmjdvnjZt2iRbW1sNGzZMx44d09GjR9W0aVN17dpVBw4c0JMnT0jUAAAA0gESNSCVFChQQL///nuCbTdv3tTdu3eTbX2UpH379unevXuqVKmS5s6dq8GDB+vGjRsKCQlR7969JUnh4eG6ceOG+vbtq8WLF6tr165ycHBQhQoVUv28AAAATFF6a31keX4gldSrV09HjhzRjRs3JEnR0dGaNm2aLl68mOw+N2/elJeXl6ZPn66RI0dq3759+uGHH1SoUCHlz59fK1eulK+vr9zc3FSxYkVt27ZNrVu3lq+vr0qWLKmAgID/1ekBAAAgFVFRA1KJvb29pk2bplGjRslgMCg8PFz16tVT7dq1NXPmzAStj5I0fvx4DRs2TMOHD1e+fPkkSdOnT9eXX36pjRs3qlu3bnJ3d1dsbKwKFiyopk2b6vnz5xo1apRsbW1laWmpCRMmpMWpAgAA4B2zMBgMhrQOAgDSwvWHUWkdgskokssmrUMATNrTyLi0DsFkPI2MSesQTEZO+4xpHYLJyGQC5Z+8PdO+syh4hcs7m4vWRwAAAAAwMSaQ+wIAAADAP8NiIgAAAACAVEWiBgAAAAAmhtZHAAAAAGaP1kcAAAAAQKqiogYAAADA7FFRAwAAAACkKhI1AAAAADAxtD4CAAAAMHu0PgIAAAAAUhUVNQAAAADmL30V1KioAQAAAICpIVEDAAAAABND6yMAAAAAs5feFhMhUQMAAACA/4HWrVvL3t5eklSoUCFNnTo12bEkagAAAADMnqlX1KKiomQwGOTr65ui8dyjBgAAAACp7I8//lBERIR69OihLl266MyZM68dT0UNAAAAAN4Bf39/+fv7Gx+7urrK1dVVkpQpUyb17NlT7du317Vr19SrVy/t2bNHVlZJp2QkagAAAADMnim0Pr6cmL2qWLFiKlKkiCwsLFSsWDFlz55d9+/fV/78+ZMcT+sjAAAAAKSyjRs3atq0aZKke/fuKSwsTHny5El2PBU1AAAAAEhl7dq1k6enpzp27CgLCwtNmTIl2bZHiUQNAAAAQHqQ9p2Pr5UxY0bNnDkzxeNpfQQAAAAAE0NFDQAAAIDZM4XFRN4lKmoAAAAAYGJI1AAAAADAxND6CAAAAMDs0foIAAAAAEhVVNQAAAAAmD0qagAAAACAVEWiBgAAAAAmhtZHAAAAAGaP1kcAAAAAQKqiogYAAADA/KWvghoVNQAAAAAwNSRqAAAAAGBiaH0E8K9VJJdNWodgMmpOP5LWIZiMPvWKpnUIJsMhc6a0DsFkPI2OSesQTMaCg3+mdQgmw9kpV1qHYDJmtiid1iGwmAgAAAAAIHVRUQMAAABg9qioAQAAAABSFYkaAAAAAJgYWh8BAAAAmL101vlIRQ0AAAAATA0VNQAAAABmj8VEAAAAAACpikQNAAAAAEwMrY8AAAAAzF4663ykogYAAAAApoZEDQAAAABMDK2PAAAAAMweqz4CAAAAAFIVFTUAAAAAZi+dFdSoqAEAAACAqSFRAwAAAAATQ+sjAAAAALNnaZm+eh+pqAEAAACAiaGiBgAAAMDssZgIAAAAACBVkagBAAAAgImh9REAAACA2bNIZ72PVNQAAAAAwMRQUQMAAABg9tJZQY2KGgAAAACYGhI1AAAAADAxtD4CAAAAMHssJgIAAAAASFVU1AAAAACYPSpqAAAAAIBURaIGAAAAACaG1kcAAAAAZi+ddT5SUQMAAAAAU0NFDQAAAIDZS2+LiaT7RO3SpUuaPn26IiIi9OzZM9WpU0f9+/dP8oU8ceKENmzYIB8fn/95nLdu3dLgwYMVEBDwt/YPCgrS3Llz5ejoaNxWqlQpjR49Wu7u7oqIiJCtra3i4uL05MkTDR06VHXq1JEk+fv7a9u2bbK0tFR0dLQGDRqkatWq6a+//tKIESMUGxsrg8GgCRMmyMnJSQcOHNCCBQtkZWWltm3bysXF5Z1cgytXrmjcuHHy9fVNsP39999XpUqVEmybMWOGjh07luCcnzx5ImdnZ40dO1ZS8q/9kSNHtGzZMkmSwWDQjz/+qB07duj58+eaOHGiMmTIoIwZM8rLy0u5c+eWJIWEhKhjx47atm2bbGxsEsW+a9cujRgxQt98840cHBze+tyDgoJ09epVDR06NMX7fPnll5o/f/5bHwsAAACmL10nak+ePNHgwYM1b948FS1aVLGxsRo4cKA2bNigjh07pnV471zz5s2T/aLv5eWl4sWLS5KuXr2qAQMGqE6dOtq5c6eOHTum1atXy9raWjdv3pSbm5s2b96sOXPmyM3NTQ0bNtSRI0c0a9Ys+fj4aOrUqdq4caNsbW3VsWNH1a9f35jQpIZs2bIlSt6SOue4uDh16tRJ586dU5EiRV772teuXVuStHz5cjk7O6t48eJyc3PT6NGjVbZsWW3YsEHLli2Tp6enjhw5opkzZ+r+/fvJxhgYGCh3d3cFBASof//+7/4iJIEkDQAAIP1K14na/v37Va1aNRUtWlSSlCFDBnl5ecna2lqzZs2Sg4ODOnfurMePH6t79+7y8PDQ9evX1bNnTz169EgdO3ZU+/btdeHCBU2aNEmSlD17dk2ZMkW///67ZsyYIWtra7m4uGjp0qWqUqWKLl26pGzZsmnWrFnas2ePsUoSFRWlpk2b6sCBA3J3d1eZMmV06dIlhYWFac6cOcaYY2NjNXz4cJUsWVJdu3bVwIEDFRYWpoiICA0aNEi1atX6x9flr7/+UtasWSVJGzZskKenp6ytrSVJjo6O2rJli3LkyCEPDw9lyZLFGJeNjY2uXLmiwoULK1u2bJKkypUr69SpU2ratKlx/pMnT2r+/PkyGAwKDw/XzJkzZW1trSFDhihfvny6efOmypcvr/Hjxys4OFhDhw6VwWBQnjx5/tF5hYeH6+nTp8qSJctrX/t4d+/e1datW7Vp0yZJ0qxZs5Q3b94E5ytJlpaWWrVqldq2bZvkcW/evKnHjx+rV69eatOmjfr27Stra2sNHz5cGTNm1O3btxUcHKxp06apXLly8vPz0969exUREaEcOXIkSLj8/f117do1eXh4KDY2Vq1atdLGjRuTfB/UrFlTx44d09q1a7VlyxZZWlqqfPnyGjVq1D+6jgAAAOYonXU+pu9ELTg4OEEroCTZ2dlJktq3b6/Bgwerc+fO2rFjh1q0aCFJio6O1qJFixQXF6dPP/1UDRo00OjRozVlyhSVKFFCgYGBWr58uWrUqKGoqCgFBgZKkubOnasWLVqoatWq8vb2lr+/vzGZSUqFChU0cuRI+fj4aOfOnWrWrJliYmI0dOhQValSRZ07d9alS5cUGhqq5cuX6+HDh7p27dprz3fHjh365ZdfjI/btm2rVq1aSZI8PDxkZWWlv/76SxUrVtTUqVOTvUY5cuSQJOXMmVPSiwqcl5eXFixYoJCQEGPyFn89w8LCEuwf33Lo4OCgxYsXa8+ePWrRooWuXbumFStWyNbWVg0bNtT9+/e1ePFiNW/eXC4uLtq1a5fWr1+f6LweP34sd3d34+O8efNq5syZxnM+c+aM7t+/Lzs7O/Xt21dFixbVN998k+xrH2/VqlXq1q2bMmbMaJxXkn766Sf5+flp7dq1kqSaNWsme80laePGjWrbtq2yZs2qihUr6ttvv1WzZs0kSQUKFNCECRMUEBAgf39/jRs3TqGhoVq9erUsLS3Vs2dPnTt3zjjXJ598ojZt2mjo0KE6cuSIqlWrphs3brz2fRAUFKSxY8eqQoUKWrdunWJiYmRlla4/2gAAAOleuv42V6BAAf3+++8Jtt28eVN3795V1apVZWdnp8uXL2v79u1auHChLl26pIoVKxq/uBcvXly3bt3SlStXNH78eEkvErn4Kk2xYsWM81pZWalq1aqSJGdnZx0+fFgVK1Y0Pm8wGBLE8d5770mS8uXLpwcPHkiSLly4IHt7ez179kySVLJkSbm6umrw4MGKiYlJkKwkJSWtjxs2bNCOHTuUP39+SVLBggV1586dBMnXkSNHVLp0aeXNm1fHjx/X+PHj5e3tLScnJz1//lzh4eHGseHh4Qn2lSQHBwdNnjxZmTNn1r179+Ts7CxJKly4sOzt7SVJefLkUVRUlK5du2a8x83Z2TnJRC0lrY83b97UZ599Znxt3vTax8XF6eDBgxo0aFCCMbt27dKiRYu0dOlSY6L6OrGxsdq+fbsKFiyoAwcO6PHjx/Lz8zMmamXLlpX04nX+6aefZGlpKWtraw0ePFiZM2fW3bt3FRMTY5zP3t5eVatW1dGjRxUUFKTPP//8je+DqVOnauXKlfL29lbFihUTvdcAAABgftL18vz16tXTkSNHdOPGDUkvkqxp06bp4sWLkiQXFxctXLhQDg4Oxi/lv//+u2JiYvTs2TNjm1+xYsXk5eUlX19fDRs2THXr1pX0oiUuXkxMjP744w9J0o8//qgSJUrIxsbGeF/Tb7/99sZ4y5Urp6VLl2rbtm36448/dOHCBYWHh2vp0qWaNm2aJk6c+I+vSYcOHZQ/f37jgilt27bVwoULjcnCn3/+qVGjRilDhgw6fvy4Jk+erOXLl6t8+fKSXiSv169fV2hoqJ4/f67Tp08nWugjvgI5bdo05c2b15g4JLWAS/HixfXzzz9LUoLK0ttydHTU2LFjNXDgQEVERLzxtb948aKKFSumTJkyGefYunWr/Pz85Ovrm6gal5xDhw7p/fffl6+vr1asWKGNGzfq4cOHxvfCq+f8xx9/aN++fZo9e7ZGjx6tuLi4RImVi4uLAgMD9fDhQ5UpU+aN74OAgACNHz9efn5+On/+vPF6AgAA/JtYWFik+d+7lK4ravb29po2bZpGjRplvF+qXr166tSpkySpYcOGmjBhgqZPn27cx8bGRr169dKTJ0/Uv39/Zc+eXePGjZOHh4diYmJkYWGhyZMnKzg4ONHxli1bpr/++ksFChTQoEGDFBkZqfXr16tjx44qV65cota7pGTKlEljx46Vh4eH/Pz8dPLkSe3evVtxcXEaMGCAJMnb21tNmjRRhQoVEuz7auujvb29Fi1alOgYI0eOVMuWLfXpp5/qk08+0f3799WpUydZW1srNjZW06dPV65cudS9e3dFR0dr+PDhkl5UECdMmKDhw4erZ8+eMhgMatu2baJVDlu2bKnOnTvL1tZWuXPnTvJaxevXr5+GDRumXbt2qVChQkmOebX1UZIGDx6caFyNGjVUo0YNzZ07Vx4eHq997f/8888EyVhsbKwmT56s/PnzGxcDqVq1qvGaJycgIEDt27dPsK1du3bGtslXFSlSRLa2turQoYOkF5XFV6/PBx98oOvXr6tz586SpKJFi2rBggWJ3gfxSpcurU6dOsnOzk4ODg764IMPXhszAAAATJ+F4V/cJxURESE3NzcFBgYmqI79HfXr19fu3buTXLodeBtxcXHq2LGjVqxYYWwVBVJbzelH0joEk9GnXtG0DsFkOGTO9OZB/xJPo2PePOhfYsHBP9M6BJPh7JQrrUMwGTNblE7rEFRl0ndpHYJOj6r3zuZK162Pr/PTTz/JxcVFvXr1+sdJGvCu3Lx5U61bt1azZs1I0gAAAP7F0nXr4+s4Oztr+/bt72y+AwcOvLO58O/l6OiorVu3pnUYAAAASGP/2kQNAAAAQPrxrhfzSGv0/AEAAACAiaGiBgAAAMDspbOCGhU1AAAAADA1JGoAAAAAYGJofQQAAABg9lhMBAAAAACQqqioAQAAADB76aygRkUNAAAAAEwNiRoAAAAAmBhaHwEAAACYPRYTAQAAAACkKipqAAAAAMxeOiuoUVEDAAAAAFNDogYAAAAAJobWRwAAAABmj8VEAAAAAACpikQNAAAAAEwMrY8AAAAAzF4663ykogYAAAAApoaKGgAAAACzx2IiAAAAAIBURaIGAAAAACaG1kcAAAAAZo/WRwAAAABAqqKiBgAAAMDspbOCGhU1AAAAADA1JGoAAAAAYGJofQQAAABg9lhMBAAAAACQqqioAQAAADB76aygRkUNAAAAAEwNiRoAAAAAmBhaHwEAAACYPRYTAQAAAACkKipqAAAdG/ZxWodgMgr0DUrrEEzG3H4fpXUIJqNEDvu0DsFkREfHpnUIJsMuIzUPU5LOCmpU1AAAAADA1JCoAQAAAICJofURAAAAgNmzTGe9j1TUAAAAAMDEkKgBAAAAMHsWFmn/lxIPHz5UnTp1dOXKldeOI1EDAAAAgP+B6OhojRkzRpkyZXrjWBI1AAAAAPgf8PLyUocOHZQ3b943jmUxEQAAAABmz8IEFhPx9/eXv7+/8bGrq6tcXV0lSUFBQcqZM6c+/vhjLV269I1zkagBAAAAwDvwcmL2qk2bNsnCwkI//PCDzp8/Lw8PDy1atEh58uRJcjyJGgAAAACksrVr1xr/293dXePGjUs2SZNI1AAAAACkA5Zp3/n4TpGoAQAAAMD/kK+v7xvHkKgBAAAAMHumsJjIu8Ty/AAAAABgYkjUAAAAAMDE0PoIAAAAwOyls85HKmoAAAAAYGqoqAEAAAAwexZKXyU1KmoAAAAAYGJI1AAAAADAxND6CAAAAMDsWaavzkcqagAAAABgaqioAQAAADB7FulsfX4qagAAAABgYkjUAAAAAMDE0PoIAAAAwOyls85HKmoAAAAAYGqoqAEAAAAwe5bprKRGRQ0AAAAATAyJGgAAAACYGFofAQAAAJi9dNb5SEUNAAAAAEwNFTUAAAAAZs8inZXUqKgBAAAAgIkhUQMAAAAAE0PrIwAAAACzl846H6movUsnTpzQRx99JHd3d+PfgAEDkh1/4cIFnTp1KtXimTFjhoKCgnT+/HnNnz8/1Y4jSfPmzdP69esTbHNxcdGtW7feap769esrKirqXYaWyM2bNzVgwAC5uLioS5cu6t27ty5duvSP5+3bt6/69Onzt/d3d3fXlStXUjz+8OHD8vf3/9vHAwAAgOmiovaOVa9eXT4+Pikau3fvXuXOnVtVq1ZN1ZjKli2rsmXLpuoxzEVERIT69euniRMnqlKlSpKks2fPasKECfL19f3b8/7111969uyZYmJidPPmTTk6Or6rkJNVu3btVD8GAAAA0gaJ2v9ATEyM3Nzc9MUXX6hs2bLq2rWrli5dqs2bN8va2lrlypXTiBEjVLRoUVlbW8vDw0Pjxo1TVFSU7t+/r6+++koNGzbUsWPHNHv2bNnY2Ch79uyaMmWKzp8/rxkzZsja2louLi6ytbXVokWLlDNnTkVHR8vJyUknTpzQhg0b5OPjo8aNG8vZ2Vl//vmncuXKpXnz5ikiIkIjR47U06dPFRwcrE6dOqlTp05yd3dXzpw59fjxY+XMmVMtW7ZU3bp1deXKFXl5eWnp0qUpOv+7d+8meT7fffed5s+fL4PBoHLlymn8+PHGfdavX69jx45p1qxZOnPmjHx8fJQhQwY5OjpqwoQJ2r59uzZt2qS4uDgNGDBA27Zt0/Xr1xUZGakuXbqoVatWScby3XffqXr16sYkTZIqVKig//73v5Kkixcvatq0aYqNjdWjR480btw4OTs7y9PT87Xzb9q0SQ0aNFCmTJm0bt06eXh4SNJbXe94HTp00MSJE1WyZEkdOnRI3333nVq0aCEvLy9ZWVnJ1tZWc+bM0d69e3X16lX1799fAwcOVFhYmCIiIjRo0CDVqlUrRa8NAABAemGZznofSdTesePHj8vd3d34uE6dOvrss880Y8YM9e3bV3ny5NHXX3+tggULqnXr1sqdO7cqVKigZ8+e6fPPP9d7772n77//Xt27d1e1atX0008/ad68eWrQoIFGjx6t9evXy8HBQWvWrNGiRYtUt25dRUVFKTAwUNHR0WrcuLGCgoKUPXt29e7dO1F8N2/e1Jo1a5Q/f3516NBB586dk7W1tT755BM1btxY9+7dk7u7uzFxaN68uRo1aqTjx49r/fr1qlu3rjZu3Kh27dolmnv16tXatWuX8fHly5clSVevXk10PnXr1tXEiRMVGBioXLlyadmyZbp7964kydfXV+fPn9ecOXNkaWmp0aNHa926dcqVK5dmz56tzZs3y8rKSlmzZtWiRYsUFham0aNHKyAgQJJ07NixZF+fW7duqXDhwsbH/fr1U1hYmIKDg7VmzRpdvnxZHh4eKl26tLZv366goCCVKlVKp06dSnb+uLg47dixQ/7+/rKystInn3yigQMHKlOmTG99vSWpffv22rx5s77++mtt2rRJffr00Y4dO9S0aVN17dpVBw4c0JMnT4zjb9y4odDQUC1fvlwPHz7UtWvXkj1/AAAAmAcStXcsudbHQoUKydnZWWfOnEm2Za1YsWKSpDx58mjRokXauHGjLCwsFBMTo0ePHsne3l4ODg6SpKpVq2rWrFmqW7eucb+QkBBly5ZNOXLkkKQEVaN4OXLkUP78+SVJ+fPnV1RUlPLnz681a9Zo7969sre3V0xMTKKYqlWrpkmTJikkJETHjh3T4MGDE83drVs3dezY0fjYxcXlteeTNWtW5cqVS5LUq1cv434//PCDMmTIoAwZMujhw4cKDg7WV199JUmKjIxUjRo1VKRIEWNs9vb2GjFihEaPHq2wsDC1bNkyyesrSfny5dOvv/5qfLxo0SJjrDExMcqbN68WLlyoTJkyKTw8XPb29m+c/8iRIwoPD9eQIUMkvUjctm/frvbt27/19Zakpk2bqk2bNurZs6fu3buncuXKqVChQlq8eLG6du0qBwcHVahQwTi+ZMmScnV11eDBgxUTE5PgHwoAAAD+LdJXPY3FRP5nzpw5o0uXLqlq1apauXKlpBc/yhcXF2ccY2n54uWYM2eOPv30U02fPl3VqlWTwWBQjhw5jJUfSTp58qSKFi2aYL9cuXLpyZMnCgkJkSSdO3cuURxJ/RDgypUrVbFiRc2YMUNNmjSRwWBINN7CwkItW7bUpEmTVLNmTVlbW6f43JM6n/hYQ0NDJUmTJk3S2bNnJUkLFy5U1qxZtX79euXIkUP58uXTwoUL5evrq759+6p69eoJzjs4OFi//fabFixYoKVLl2r69OmJkp94DRo00A8//KAzZ84Yt12/fl13796VhYWFJk+erAEDBsjLy0ulSpWSwWB44/wbN27UpEmTtGLFCq1YsUKzZ8/WunXr/tb1lqTMmTOrWrVqmjx5sjEp3LZtm1q3bi1fX1+VLFnSWN2TXixKEx4erqVLl2ratGmaOHFiil8bAAAAmCYqau/Yq62P0ovEY+TIkZo/f74KFCig9u3b68MPP9T7778vb29vFS9ePMH4Jk2ayNvbW0uXLlW+fPn06NEjWVhYaNKkSerfv78sLCyULVs2TZ06NcFqhVZWVhozZox69uypbNmyycoqZS9vvXr1NGnSJO3atUtZsmRRhgwZ9Pz580Tj2rRpo7p162rr1q1vdU2SOh9LS0uNHTtWffr0kaWlpd577z2VL1/euM+oUaPUvn17ffTRRxo5cqR69+4tg8EgOzs7eXt7686dO8axefLk0f3799WhQwdZWlqqR48esrKy0qpVq1S4cGE1aNDAONbOzk6LFi3SzJkzNWPGDMXExChDhgzy9PRUwYIF1bJlSw0cOFBZs2Y1xprc/JL04MED/fLLLwmqqJUrV1ZUVJR++umnv329XVxc1KlTJ40bN07Si/voRo0aJVtbW1laWmrChAnGFUOLFi2qBQsWaPfu3cZ79gAAAGDeLAyv/nM+kIx79+7p66+/1po1a9I6lHTv7Nmz8vPzk7e3d1qHAvzrFOgblNYhmIy5/T5K6xBMRokc9mkdgsn4MuBMWodgMuqXz5fWIZiMCf8pmdYhqON/z6R1CFrfpeI7m4uKGlJk7969mjdvnrHCg9Tj5+enjRs3avbs2WkdCgAAANIIiRpSpHHjxmrcuHFah/Gv4ObmJjc3t7QOAwAAwKxYprPVRFhMBAAAAABMDIkaAAAAAJgYWh8BAAAAmL2kfhbJnFFRAwAAAAATQ0UNAAAAgNlLZwU1KmoAAAAAYGpI1AAAAADAxND6CAAAAMDssZgIAAAAACBVUVEDAAAAYPYs01dBjYoaAAAAAJgaEjUAAAAAMDG0PgIAAAAweywmAgAAAABIVSRqAAAAAGBiaH0EAAAAYPbSV+MjFTUAAAAAMDlU1AAAAACYPUsWEwEAAAAApCYSNQAAAAAwMbQ+AgAAADB76azzkYoaAAAAAJgaKmoAAAAAzJ5FOiupUVEDAAAAABNDogYAAAAAJobWRwAAAABmL511PlJRAwAAAABTQ0UNAAAAgNmzTGclNSpqAAAAAGBiSNQAAAAAwMTQ+ggAAADA7KWzzkcqagAAAABgaqioAQAAADB7FumspEZFDQAAAABMDIkaAAAAAJgYWh8BAHjJX4vbpHUIJqP4kN1pHYLJ2Da4dlqHYDKcS+RJ6xBMho1V+mq1M3fprQKV3s4HAAAAAMweFTUAAAAAZo/FRAAAAAAAqYpEDQAAAABMDK2PAAAAAMyeZfrqfKSiBgAAAACmhkQNAAAAAEwMrY8AAAAAzB6tjwAAAACAVEVFDQAAAIDZ43fUAAAAAACpikQNAAAAAEwMrY8AAAAAzB6LiQAAAAAAUhUVNQAAAABmL52tJUJFDQAAAABMDYkaAAAAAJgYWh8BAAAAmD3LdNb7SEUNAAAAAEwMFTUAAAAAZi+9VaDS2/kAAAAAgNkjUQMAAAAAE0PrIwAAAACzl87WEqGiBgAAAACmhooaAAAAALPH8vwAAAAAgFRFogYAAAAAJobWRwAAAABmL511PlJRAwAAAABTQ0UNAAAAgNmzTGcVNRI1AAAAAEhlsbGxGjVqlP78809ZWFho/PjxKlWqVLLjaX0EAAAAgFT23XffSZI2bNigr776Sj4+Pq8dT0UNAAAAgNkz9d9Ra9iwoerWrStJ+uuvv5Q1a9bXjidRAwAAAIB3wN/fX/7+/sbHrq6ucnV1NT62srKSh4eHvv32W82dO/e1c5GoAQAAAMA78GpilhQvLy8NHTpULi4u2rlzpzJnzpzkuDfeo3bixAkNGjQowbYZM2YoKCjoLUJOXb/88osaNWqkmTNnJtju7++v6OjoJM8hpX7//Xf16tVLHTp0UJcuXdS/f3/du3fvH8fs5+eX4PHz589Vs2ZNxcbGSpJ+/vlnlSlTRmfPnpUkRUVF6eOPP1ZcXFyS87m7u+vKlSspPv7OnTvVqVMnderUSe7u7po8ebKeP3/+N8/mzc6fP6/58+en2vxS0u/LoKAg1a1bV+7u7sa/iRMn6sKFC8bH5cuXV+fOneXu7q6DBw9q+PDhOnz4cIJ5atasKelFmbpbt25yd3eXm5ubrl69miiOzZs3q0uXLnJ3d1eHDh109OhR474HDhxINv5bt27JxcXln14GAACAfyULi7T/e50tW7ZoyZIlkiRbW1tZWFjI0jL5dCxdVNSOHDli/GL8siVLlqhVq1Z/e97g4GANHTpU8+bNU/HixSVJ3377rby9vRMlhW9r0aJFcnNzMz7OmDGjypQpo/Pnz+v999/XoUOH1KRJEx0+fFgVKlTQzz//rCpVqrz2xUypQ4cOKSAgQIsXL1bWrFllMBg0depUbdmyJdUShbJly6ps2bKpMvebNG/eXEOHDk203dfXV5JUv359rVy5UjY2NpKkPXv2JDvXnDlz5ObmpoYNG+rIkSOaNWtWggT06dOnWrhwoXbu3KmMGTPq3r17at++vQ4ePKjjx4/r6tWrql+//js+QwAAAJi6xo0by9PTU507d1ZMTIxGjBihTJkyJTv+HydqM2fO1OnTpxUXF6du3bqpadOmcnd3V86cOfX48WMtXbpUI0aM0K1btxQbG6vu3burWbNmunDhgiZNmiRJyp49u6ZMmaLo6Gh99dVXMhgMioqK0vjx4xN8uY+Ojpanp2eCuQoVKqSgoCBZW1srX758atSokSQpMDBQ9+/f16BBg9S1a1ddv35dn332mUJCQlSvXj31798/yRiyZMliPN6WLVvUvn17Y5ImSY0aNVLDhg0lKdF5jhs3TtevX1dcXJy++uorVatWTXv27NHatWsVExMjCwsLzZ8/X/7+/nr8+LHGjRuncePGGeeuWbOmTp8+rffff1/Hjx/X9OnTNWTIEH355Zc6efKkPv7442SvuSTNnTtXjx49UsaMGeXt7a2cOXMm+Zr5+vrq66+/Nt7AaGFhIU9PT1n8/38G2L17t1avXi1LS0tVrlzZmKzeunVLDx8+1F9//SVPT099/PHHOnnypHx8fJQhQwY5OjpqwoQJunXrljw9PWVlZaW4uDjNnDlTN27c0IYNG+Tj4yNPT09dv35dkZGR6tKlS6JkeubMmfr1118VGhqqMmXKaOrUqcke/5tvvtGiRYuUM2dORUdHy8nJ6e3ewG/Jw8PD+B6JjY01JnfxMmbMqOjoaK1fv1716tVT4cKFtW/fPhkMBi1dulSRkZGqVKmSsmTJovnz58tgMCg8PFwzZ86UtbW1cd7hw4erZMmS6t27t3x9fbVjxw5ZWFioWbNm6tKli4YPH67Q0FCFhoZq4cKFr/3cAAAA/BuY+u+oZc6cWXPmzEnx+BQlasePH09Qrbp586YGDBigQ4cO6datW1q/fr2ioqLk4uJibBFr3ry5GjVqJD8/P+XMmVMzZsxQWFiY2rRpo+rVq2v06NGaMmWKSpQoocDAQC1fvlyVKlVS9uzZ5e3trcuXL+vZs2cJ4vD3908014YNG9S6dWvlzp3bmKRJUvv27bVo0SL5+PjozJkzioqK0sKFCxUbG6u6deuqf//+ScbwcovkrVu3VKdOHUlSZGSkevXqJUm6c+eO9u3bl+A8161bpxw5cmjKlCl69OiR3NzctHPnTl27dk1Lly6Vra2txowZo6NHj6pfv37y8/NLkKRJUo0aNbRgwQI1b95ctra2cnR0lMFgUEhIiE6dOqUOHTq89po3btxYn3zyidauXaslS5bI09Mzydfz1q1bKlKkiKQXLZazZs1SdHS08ufPr7Fjx2revHnatGmTbG1tNWzYMB07dkzSiyRk+fLlOnbsmFauXKlatWpp9OjRWrdunXLlyqXZs2dr8+bNio6OVoUKFTRs2DCdPn1aT58+NR47LCxMp06dUkBAgCQZ5375+axZs2rVqlWKi4vTJ598Ymw1ffX41atX17Rp0xQUFKTs2bOrd+/eSZ7vjh079Msvvxgft23b9o2V1unTp2vZsmXGx48fP5YkY/J79epVeXl5acGCBQn2s7Gx0Zo1a7RmzRp99tlnio6OVq9evdSpUyf17t1bV69eVYMGDbR27VpNnz5dDg4OWrx4sfbs2aMWLVooJiZGQ4cOVZUqVdS5c2ddvnxZu3bt0rp16yRJ3bt3V61atSRJ1atXV7du3XTw4MHXfm4AAABgflKUqFWvXj3BOv8zZsyQJF28eFG//fabMYmLiYnR7du3JUnFihWTJF25ckU1atSQJNnb26t48eK6efOmrly5ovHjx0t6USkrWrSoateurWvXrunzzz+XlZWV+vXrlyCO5OZKiZIlSypjxowvTtrKyjjfqzG8LH/+/Lp165YkKVOmTMZWufjE6OXzvHjxon788UfjPWUxMTEKCQlRrly55OHhITs7O129elUVK1ZMNsbSpUvr2rVrOnLkiLF6VqtWLZ04cUJRUVHKmzevtm7dmuw1r1KliiTJ2dlZhw4dSvY48edVpkwZVapUSb6+vrpy5YrGjRunGzduKCQkxJj0hIeH68aNG5JkrNLky5dPz58/V0hIiIKDg/XVV19JepHM1qhRQ59//rmWLVumzz77TFmyZEmQ/Nrb22vEiBEaPXq0wsLC1LJlywSx2djYKCQkRIMHD1bmzJn17NkzRUdHJ3v8bNmyKUeOHJKkSpUqJXm+ybU+vs6wYcNUu3Zt4+OXX/Pjx49r/Pjx8vb2TlTBu3fvniIjIzVmzBhJ0p9//qnPPvtMlStXTjDOwcFBkydPVubMmXXv3j05OztLki5cuCB7e3tjsnXx4kXjfXHSi4Tx+vXrkv7vvfemzw0AAADMzz9qfXRyclK1atU0ceJExcXFaeHChXJ0dJQkYxtd8eLFdfr0aTVq1EhhYWG6ePGiChUqpGLFisnLy0sFChTQjz/+qPv37+vEiRPKmzevVq5caaz0xCdHr5srORYWFsbFNyySuLsvqRhe1qpVK/Xq1Uu1a9c2fin+9ddfE1Qs4ud1cnJSvnz51LdvX0VGRmrRokWytrbW3LlzdfDgQUkvqiEGg0GSjP//1XhLly6twMBATZgwQdKLL+He3t768MMP33jNz507JwcHB50+fVolS5ZM9rq4ubnJ29tbc+bMMbbxnTx5UpJUqFAh5c+fXytXrpS1tbWCgoJUtmxZ7du3L9E1zJEjh/Lly6eFCxcqS5Ys2r9/vzJnzqz9+/ercuXK+vLLL7Vjxw4tX77cWMEKDg7Wb7/9pgULFigqKkp16tTRp59+akyeDx8+rDt37mj27NkKCQnRt99+a7xWrx4/V65cevLkiUJCQpQzZ06dO3dO+fLlS/a834Xjx49r8uTJWr58uQoWLJjo+QcPHsjT01Pr1q2Tvb29ChYsqBw5csja2lqWlpbG9+Po0aP17bffyt7eXh4eHsZzLFeunJYuXar27dvr448/lpOTk0qUKKHly5fLwsJCq1evVunSpfXNN98Yr8ebPjcAAAD/BhYy8d7Ht/SPErX69evr5MmT6tSpk549e6aGDRvK3t4+wRgXFxeNHj1aHTt2VFRUlL788kvlypVL48aNk4eHh/HercmTJyt79uwaPHiw1q9fr5iYGH3xxRcpmis5VapUUe/evRPNEy+pGF6WP39+zZgxQ15eXgoPD1dUVJTs7e21cOHCRHN16NBBo0aNkpubm8LCwtSpUyfZ29vL2dlZrq6usrKyUtasWRUcHCzpRdI5dOhQY3UyXs2aNTVv3jyVKFFCklShQgVdvXrVWLV63TXft2+f1qxZIzs7O3l5eUmSevToocWLFxuriZLUoEEDxcTE6PPPP5f0ompWokQJTZw4UTlz5jSuahgbG6uCBQsa74F7laWlpUaOHKnevXvLYDDIzs5O3t7eCg8Pl4eHhxYtWqS4uDh5enoqLCxMkpQnTx7dv39fHTp0kKWlpXr06GFM0uLPd+HChercubMsLCzk6OhovGavsrKy0pgxY9SzZ09ly5YtwTwve7X10d7eXosWLUpy7JvE30s5fPhwSS+S/fikWnqRaMWvCJkpUybFxsaqffv2cnJyMibw5cqVU8uWLdW5c2fZ2toqd+7cCc4xU6ZMGjt2rDw8PBQYGKiPPvpIHTt21PPnz1WhQgU5ODgkiKlMmTKv/dwAAADA/FgYkirtAACAf73iQ3andQgmY9vg2m8e9C+x5FTKbjv5N3DIki4WUH8nRjYokdYhaNqBlP9UVWoZXr/4mwel0D9f6x0AAAAA8E6RqAEAAACAiaFeCwAAAMDsmfrvqL0tKmoAAAAAYGKoqAEAAAAwe0n9HJc5o6IGAAAAACaGRA0AAAAATAytjwAAAADMHouJAAAAAABSFRU1AAAAAGYvna0lQkUNAAAAAEwNiRoAAAAAmBhaHwEAAACYPct01vtIRQ0AAAAATAwVNQAAAABmj+X5AQAAAACpikQNAAAAAEwMrY8AAAAAzF46W0uEihoAAAAAmBoSNQAAAAAwMbQ+AgAAADB7lkpfvY9U1AAAAADAxFBRAwAAAGD2WEwEAAAAAJCqSNQAAAAAwMTQ+ggAAADA7FnS+ggAAAAASE1U1AAAAACYPct0tpoIFTUAAAAAMDEkagAAAABgYmh9BAAAAGD20lnnIxU1AAAAADA1VNQAAAAAmD0WEwEAAAAApCoSNQAAAAAwMbQ+AgAAADB76azzkYoaAAAAAJgaKmoAACBJV2Y2TesQTMbnQb+ndQgmo0L+zGkdgskIfx6X1iHgJemtApXezgcAAAAAzB6JGgAAAACYGFofAQAAAJg9i3S2mggVNQAAAAAwMSRqAAAAAGBiaH0EAAAAYPbSV+MjFTUAAAAAMDlU1AAAAACYPUsWEwEAAAAApCYSNQAAAAAwMbQ+AgAAADB76avxkYoaAAAAAJgcKmoAAAAAzF46W0uEihoAAAAAmBoSNQAAAAAwMbQ+AgAAADB7Fums95GKGgAAAACYGCpqAAAAAMxeeqtApbfzAQAAAACzR6IGAAAAACaG1kcAAAAAZo/FRAAAAAAAqYqKGgAAAACzl77qaVTUAAAAAMDkkKgBAAAAgImh9REAAACA2WMxEQAAAABAqqKiBgAAAMDspbcKVHo7HwAAAAAweyRqAAAAAGBiaH0EAAAAYPZYTAQAAAAAkKpI1AAAAADAxND6CAAAAMDspa/GRypqAAAAAGByqKgBAAAAMHvpbC0RKmpv48SJExo0aJDx8Z49e9S8eXP99ddff3vOP/74Q5999pnc3d3VoUMH+fj46Pnz58mOP3/+vObPn5/s84cPH5a/v//fjkeSatas+Y/2f9mVK1fk7u7+zuaLd+LECX300Udyd3c3/g0YMECSNHz4cLVo0ULu7u5yc3NT8+bNtWnTJuO++/btM+7Tvn177dmzR5L09OlT9e3bV25ubnJ1ddXPP/8sSTpz5ozat2+vDh06JHvtz549q/fff19nz5792+fz8nsrJQYNGvTa9woAAADMFxW1v2nHjh1auXKlVq9erdy5c/+tOR48eKDBgwdrwYIFKlasmAwGgxYsWKCpU6dq7NixSe5TtmxZlS1bNtk5a9eu/bdiMUfVq1eXj49Pks8NGzbMeC1CQ0PVvHlztWnTRj///LNWr16tJUuWyM7OTo8ePZKrq6tKlCihXbt2qXr16urWrZuuXr2qIUOGaPPmzRo7dqzmzZsnR0dH9e7dW7///rvee++9BMcLCAhQ9+7dtW7dOlWoUCHVz11SsucOAAAA80ei9jds2bJFfn5+WrVqlbJlyyZJunDhgiZNmiRJyp49u6ZMmaJly5bJwcFBnTt31uPHj9W9e3cFBQUZ59m6davatm2rYsWKSXrx2w9ffPGFGjRooMjISPXq1UvFihXTn3/+KYPBIB8fH129elUbNmyQj4+PGjduLGdnZ/3555/KlSuX5s2bp61bt+rq1asaOnSoVq5cqZ07d8rKykpVqlTRsGHDNG/ePN26dUsPHz7UX3/9JU9PT3388cdvPOc7d+5o9OjRioqKko2NjSZOnKj8+fNr5syZ+vXXXxUaGqoyZcpo6tSpCg4O1tChQ2UwGJQnTx7jHCdPnpSPj48yZMggR0dHTZgwQdu3b9emTZsUFxenAQMGaNu2bbp+/boiIyPVpUsXtWrV6h+/Xg8ePFDGjBllYWGhwMBAde3aVXZ2dpKkHDlyKDAwUFmzZlW3bt2UMWNGSVJsbKxsbGwUFham58+fq3DhwpKkWrVq6fvvv0+QqIWHh+v48ePauXOnWrRooZCQEOXMmTPZa71nzx6tXbtWMTExsrCwSFClO3r0qAICAjR37lxJUocOHTRnzhzNnj070XWpX7++du/erUOHDmnZsmWysrJS3rx55ePjI0tLiuUAAODfxTKdLSfCt7m3dPr0aQUEBOjx48eKjY01bh89erTGjh0rX19f1a5dW8uXL1f79u21ZcsWSS8qcC1atEgw182bN40JQDwLCwvlyZNHDx48kCQ5OzvL19dXTZs21ZIlSxLtP3DgQPn7+yskJETnzp0zPnfhwgXt3r1bGzZs0IYNG3T9+nV99913kqSMGTNq+fLlGjlypFavXp2i8/by8pK7u7t8fX3Vs2dPzZgxQ2FhYcqaNatWrVqlTZs26cyZM7p3754WL16s5s2by9fXVw0bNpQkGQwGjR49WvPnz5efn58cHBy0efNmSVLWrFm1fv16lS9fXqdOndL8+fO1fPlyZciQ4bUxHT9+PEHr4/Lly43PTZ8+XZ06dVLdunU1depUzZkzR5IUHBwsR0fHBPNky5ZNFhYWypo1qzJlyqT79+9r2LBhGjx4sMLCwmRvb28ca2dnp6dPnybYf9euXWrUqJFsbGzUtGlTbdy40fhcUtf62rVrWrp0qdavX68SJUro6NGjxvE1a9bUxYsX9fjxY126dEk5cuSQnZ3da6/Ljh071LNnT61fv1716tVTWFjYa68bAAAATB8VtbeUJ08erVq1SoGBgRo2bJiWLVsmS0tLXblyRePHj5ckRUdHq2jRonJ0dJSdnZ0uX76s7du3a+HChQnmcnBw0O3btxNsi42NVXBwsLGdsnr16pJeJGwHDhxIMDZHjhzKnz+/JCl//vyKiooyPnf16lV98MEHsra2liRVqVJFly5dkiRj62S+fPlSfI/TxYsXtWTJEi1fvlwGg0FWVlaysbFRSEiIBg8erMyZM+vZs2eKjo7WtWvX5OLiYox7/fr1CgkJUXBwsL766itJUmRkpGrUqKEiRYoYK4r29vYaMWKERo8erbCwMLVs2fK1MaWk9fHQoUOaMWOGMSEuUKCA7ty5ozJlyhjH/vjjj8qdO7eKFCmiCxcuaPDgwfr666/14YcfKiwsTOHh4cax4eHhypo1a4JjBQYGKkOGDOrZs6ciIyN19+5dffbZZ8le61y5csnDw0N2dna6evWqKlasaJzLwsJCLVu21I4dO3Tr1i21a9fujdfF09NTS5YskZ+fn5ycnIzJMQAAwL8Ji4n8yxUpUkQ2NjZyc3OTtbW1Fi1aJEkqVqyYvLy85Ovrq2HDhqlu3bqSJBcXFy1cuFAODg7KmTNngrlat24tf39/Xbt2TdKLqtP8+fNVu3ZtZcqUSZL066+/SpJ++uknlShRIsH+Fq95Nzo5Oens2bOKiYmRwWDQqVOnErRYvi0nJycNHTpUvr6+Gj9+vJo0aaLDhw/rzp07mjVrlgYPHqzIyEgZDAYVL17cuBBHfJUvR44cypcvnxYuXChfX1/17dvXmITGt+kFBwfrt99+04IFC7R06VJNnz5dMTExbx3ry+rUqaMGDRpo9OjRkqQ2bdpoxYoVevbsmSTp4cOHGjFihCIiInT58mUNHDhQM2fOVJ06dSS9SB6tra1148YNGQwGHT16VFWqVDHOf+HCBcXGxmr9+vVasWKF1q5dq8KFCxurl69e66dPn2ru3Lny8fHRpEmTZGNjI4PBkGBM27ZttWfPHp06dUp16tR543Xx9/dX//795efnJ0n69ttv/9E1AwAAQNqjovYPTJkyRa1atVLlypU1btw4eXh4GO87mjx5siSpYcOGmjBhgqZPn55o/3z58snb21vjx49XRESEYmJi9OGHH2rkyJHGMZs3b9bq1atla2srb29vXbx4MUWxlS5dWk2bNlXHjh0VFxenypUrq2HDhvrjjz/euG9oaKjatGljfNyjRw95eHho3LhxioqKUmRkpEaOHKlChQpp4cKF6ty5sywsLOTo6Kjg4GD169dPw4YN065du1SoUCFJL5KxkSNHqnfv3jIYDLKzs5O3t7fu3LljPE6ePHl0//59dejQQZaWlurRo4esrKy0atUqFS5cWA0aNEgQZ3zr48uWLVuW6Hw+//xztW7dWgcPHlTdunXl4uJinDsyMlKDBw9WmTJl1K9fPz1//tz42tnb22vRokUaP368hg4dqtjYWNWqVUsffPCBce7AwEB9+umnCY7Xvn17rV27VpUqVUoUi729vZydneXq6iorKytlzZpVwcHBxuskvai02tnZqWLFirKyskr2usSrUKGC+vTpIzs7O2XOnNn4jwQAAAAwXxaGV/85H+9URESE3NzcFBgY+NYLPLi7u2vcuHEqXrx4KkUHU9WnTx+NGDFCRYoUSetQAACSPg/6Pa1DMBkV8mdO6xBMRvjzuLQOwWQMqeOU1iFo56/BaR2CPnk/7zubi9bHVPTTTz/JxcVFvXr1YhU+pEhkZKTatGkjJycnkjQAAIB/MSpqAAAAb0BF7f9QUfs/VNT+jylU1Hb9lvYVtWblqKgBAAAAQLpFogYAAAAAJoZVHwEAAACYPUulrx9So6IGAAAAACaGihoAAAAAs2eRvgpqVNQAAAAAwNSQqAEAAACAiaH1EQAAAIDZo/URAAAAAJCqqKgBAAAAMHsWLM8PAAAAAEhNVNQAAAAAIJVFR0drxIgRun37tp4/f65+/fqpQYMGyY4nUQMAAABg9ixNvPNx27Ztyp49u6ZPn67Q0FC1atWKRA0AAAAA0lKTJk30n//8R5JkMBiUIUOG144nUQMAAACAd8Df31/+/v7Gx66urnJ1dZUk2dnZSZLCwsI0YMAAffXVV6+di0QNAAAAgNkzhVUfX07MknLnzh198cUX6tSpk1q0aPHauUjUAAAAACCVPXjwQD169NCYMWP00UcfvXE8iRoAAAAAs2eR9gW111q8eLGePHmihQsXauHChZKkZcuWKVOmTEmOJ1EDAAAAgFQ2atQojRo1KsXj+cFrAAAAADAxVNQAAAAAmD1TWEzkXaKiBgAAAAAmhooaAAAAALNnmb4KalTUAAAAAMDUkKgBAAAAgImh9REAAACA2WMxEQAAAABAqqKiBgAAAMDsWaSvghoVNQAAAAAwNSRqAAAAAGBiaH0EAAAAYPbSWecjFTUAAAAAMDVU1AAAAACYPct0tpoIFTUAAAAAMDEkagAAAABgYmh9BAAAeIOFbd5L6xBMhm2lL9M6BJNRplWbtA7BZAyp45TWIbCYCAAAAAAgdZGoAQAAAICJofURAAAAgPlLZ72PVNQAAAAAwMRQUQMAAABg9izSWUmNihoAAAAAmBgSNQAAAAAwMbQ+AgAAADB7Fumr85GKGgAAAACYGipqAAAAAMxeOiuoUVEDAAAAAFNDogYAAAAAJobWRwAAAADmL531PlJRAwAAAAATQ0UNAAAAgNmzSGclNSpqAAAAAGBiSNQAAAAAwMTQ+ggAAADA7Fmkr85HKmoAAAAAYGqoqAEAAAAwe+msoEZFDQAAAABMDYkaAAAAAJgYWh8BAAAAmL901vtIRQ0AAAAATAwVNQAAAABmzyKdldSoqAEAAACAiSFRAwAAAAATQ+sjAAAAALNnkb46H6moAQAAAICpIVEDAAAAABND6yMAAAAAs5fOOh+pqAEAAACAqaGiBgAAAMD8pbOSGhU1AAAAADAxJGoAAAAAYGJofQQAAABg9izSWe/jaytqJ06cUOnSpbVz584E21u0aKHhw4e/9cH8/Pzeep+/c4ymTZtq165dxm1RUVEKDAyUJM2bN0/r16//W3Pv3LlTnTp1UqdOneTu7q7Jkyfr+fPn/yje0NBQbd++PcG206dPq1evXsbHS5Ys0YcffqiYmBhJL16Xzz//PNk5a9asmeLjx8TEaP78+Wrfvr3c3Nzk5uYmf3//tzyLd+PKlStyd3dPtP3999+Xu7t7gr979+4pKChIdevWNW779NNPNX78eON+ly5dUu/eveXu7q62bdtq7ty5MhgMOnz4sHEfNzc3lS1bVleuXNH58+eNr23Pnj314MED41whISH6z3/+o6ioqCRj37VrlypWrKh79+79rXMPCgrSjBkz3mqfL7/88m8dCwAAAKbvjRU1Jycn7dy5U5988okk6cKFC4qIiPhbB1u0aJHc3Nz+1r4ptXfvXs2ePVulS5c2brt//74CAwPVvn37vz3voUOHFBAQoMWLFytr1qwyGAyaOnWqtmzZIhcXl78974ULF3TgwAG1aNHCuO2DDz7QhQsXFBcXJ0tLSx09elTVq1fXTz/9pA8//FAnTpzQxx9//LeP+TIfHx/FxcVpw4YNypAhg8LDw9WnTx9VqVJFxYsXfyfH+KeyZcsmX1/fJJ9r3ry5hg4dKkmKi4tTp06ddO7cORUpUkSDBw/WvHnzVLRoUcXGxmrgwIHasGGDOnbsqNq1a0uSli9fLmdnZxUvXlxubm4aPXq0ypYtqw0bNmjZsmXy9PTUkSNHNHPmTN2/fz/ZGAMDA+Xu7q6AgAD179//3V+EJMyfP/9/chwAAABzYJG+CmpvTtTKlCmjP//8U0+fPlWWLFm0bds2tWjRQnfu3JH0ooK1d+9eRUREKEeOHJo/f75u374tT09PWVlZKS4uTjNnztSWLVv0+PFjjRs3TiNHjtTYsWN1/fp1xcXF6auvvlK1atXUvHlzFS1aVNbW1nJzc5OXl5esrKxka2urOXPmyN7e3hjXrVu3NGLECMXGxsrCwkKjRo3SL7/8ot9//10jR46Uj4+PHB0dJUmLFy/W5cuXjV9s9+/frz179ig0NFQDBw5U/fr1tXv3bq1evVqWlpaqXLmy8ct/PF9fX3399dfKmjWrJMnCwkKenp6y+P/viHr16snJyUnFixdX9+7dNXr0aEVFRcnGxkYTJ05U/vz5NXPmTP36668KDQ1VmTJlNHXqVC1evFh//PGH/P395erqKkmytrbWe++9pwsXLqhgwYKKi4tTs2bNdPDgQX344Yc6deqUpk6dqqdPn2rkyJF69OiRJGnUqFEqXbq0nj9/rkGDBunOnTsqXbq0xo0bZ4zzZTExMdq9e7f27t2rDBkySJLs7Ozk6+srCwsLxcbGasyYMbp7966Cg4NVv359DRo0SHv37tWyZctkZWWlvHnzysfHR5aW/1ecPXnypObPny+DwaDw8HDNnDlT1tbWGjJkiPLly6ebN2+qfPnyGj9+vIKDgzV06FAZDAblyZMnJe/ZZIWHhxvfp/v371e1atVUtGhRSVKGDBnk5eUla2tr4/i7d+9q69at2rRpkyRp1qxZyps3ryQpNjZWNjY2kiRLS0utWrVKbdu2TfK4N2/e1OPHj9WrVy+1adNGffv2lbW1tYYPH66MGTPq9u3bCg4O1rRp01SuXLkkPzPx/P39de3aNXl4eCg2NlatWrXSxo0bNXDgQIWFhSkiIkKDBg1SrVq1VLNmTR07dkxr167Vli1bZGlpqfLly2vUqFH/6DoCAAAg7aVoMZHGjRtr7969MhgMOnv2rCpVqiTpRQUjNDRUq1evVmBgoGJjY3Xu3Dl9//33qlChglatWqX+/fvr6dOn6tevn7Jly6Zx48YpMDBQOXLk0Nq1a7Vw4UJNmDBBkvTs2TN9/vnn8vHx0b59+9S0aVP5+fmpY8eOevLkSYKYvL291aVLF61du1YjR47UiBEj5OrqqrJly8rLy8uYpElS3759VaJECWOrmIODg9asWaMRI0Zo/fr1Cg0N1bx587R69WqtX79e9+7d07FjxxIc79atWypSpIgk6eeff5a7u7s6duyoQYMGSZLu3LmjGTNmaMSIEfLy8pK7u7t8fX3Vs2dPzZgxQ2FhYcqaNatWrVqlTZs26cyZM7p375769u2r6tWrG5O0eDVq1NDp06d19OhR1ahRQzVr1tT333+vqKgoPXnyRIUKFdLixYtVvXp1+fr6auLEiRo3bpwkKTIyUkOHDtWGDRsUGhqqAwcOJPm6Pnr0SNmyZZOV1Yt8fd26dcY2wdWrV+vOnTuqWLGiVqxYoY0bN2rDhg2SpB07dqhnz55av3696tWrp7CwsATzXrp0SdOnT5evr68aN26sPXv2SJKuXbumyZMnKzAwUIcPH9b9+/e1ePFiNW/eXL6+vmrYsGGScT5+/DhB2+OQIUOMz+3YsUNubm76z3/+o65du6pv374qWrSogoODE7wHpBdJaMaMGY2PV61apW7duhm3xSdpP/30k/z8/NStWzdJL1pJc+TIkWRskrRx40a1bdtWWbNmVcWKFfXtt98anytQoIBWrFghd3d3+fv7J/uZiffJJ59o//79io2N1ZEjR1StWjXduHFDoaGhWrx4sWbNmqXY2NgExw8KCtLo0aPl7+8vJycnY4ssAAAAzFeKFhNp0aKFxo0bJ0dHR1WpUsW43dLSUtbW1ho8eLAyZ86su3fvKiYmRu3atdOyZcv02WefKUuWLMZkJt7Fixf1448/6uzZs5JeVHZCQkIkScWKFZP0IrlavHixunbtKgcHB1WoUCHBHFeuXFHVqlUlSWXLltXdu3dTfNLlypWTJOXOnVuRkZG6ceOGQkJC1Lt3b0kvKjM3btxIcK9X/vz5devWLZUpU0aVKlWSr6+vrly5YkyOcuTIYfwyf/HiRS1ZskTLly+XwWCQlZWVbGxsFBISYrxWz549U3R0dLIx1qxZU3PnzlXmzJnVuXNnZcmSRVmyZNGRI0f04YcfGo9z/Phx7d69W9KLhEZ6kRwULFhQklSpUiX9+eefSR4je/bsCg0NVWxsrDJkyGC8/279+vV68OCBsmfPrnPnzun48eOyt7c33o/n6empJUuWyM/PT05OTokSLAcHB02ePFmZM2fWvXv35OzsLEkqXLiwsSqaJ08eRUVF6dq1a8bWUWdn5yTvH0xJ6+PNmzf12WefGStoBQoU0O+//55g7M2bN3X37l1VrVpVcXFxOnjwYKL35q5du7Ro0SItXbpUOXPmTPKYL4uNjdX27dtVsGBBHThwQI8fP5afn5+aNWsm6cV7U5Ly5cunn376KdnPTDx7e3tVrVpVR48eVVBQkD7//HOVLFlSrq6uGjx4sGJiYhLdxzd16lStXLlS3t7eqlixogwGwxvjBgAASG/SWedjyipqjo6OevbsmXx9fdWyZUvj9j/++EP79u3T7NmzNXr0aMXFxclgMGj//v2qXLmy1qxZoyZNmmj58uWSZPwC6eTkpE8++US+vr5atmyZmjRpouzZs78I6P+30G3btk2tW7eWr6+vSpYsqYCAgAQxFS9eXKdPn5YknT9/Xrlz507+JC0tFRcXZ3z8ahtgoUKFlD9/fq1cuVK+vr5yc3NTxYoVE4xxc3OTt7e3nj59atx28uTJBMeI5+TkpKFDh8rX11fjx49XkyZNdPjwYd25c0ezZs3S4MGDFRkZKYPBkCi2l88vODhYFy9eNCaWtWrV0ooVK4z3pzk5Oalbt27y9fXV7Nmzja9NfKui9KI6VLJkySSvi7W1tRo3bqzZs2cbY4iKitIvv/wiCwsLBQUFKUuWLJo5c6Z69OhhjNnf31/9+/c3Lg7zcgVJkkaPHq0pU6Zo2rRpyps3r/F1T6r9snjx4vr5558lKUFl6W05Ojpq7NixGjhwoCIiIlSvXj0dOXJEN27ckCRFR0dr2rRpunjxoqQXSW6xYsWUKVMm4xxbt26Vn5+ffH19E1XjknPo0CG9//778vX1NVYeHz58qD/++CPJc07uM/MyFxcXBQYG6uHDhypTpowuXLig8PBwLV26VNOmTdPEiRMTjA8ICND48ePl5+en8+fPG68nAAAAzFeKl+dv1qyZtm7dqmLFiunmzZuSpCJFisjW1lYdOnSQ9KJKEhwcrIoVK8rDw0OLFi1SXFycPD09Jb34Uj506FBNmTJFo0aNkpubm8LCwtSpU6cEiY4kVahQQaNGjZKtra0sLS2N7ZHxvv76a40ePVorV65UTEyMJk+enGzsuXLlUnR0tKZPn57gi3m8nDlzqlu3bnJ3d1dsbKwKFiyopk2bJhjToEEDxcTEGFdbDA8PV4kSJRJ9aZYkDw8PjRs3TlFRUYqMjNTIkSNVqFAhLVy4UJ07d5aFhYUcHR0VHByswoUL6+LFi1q9erWx1S5e0aJFZTAYjF/2a9eurYULFxoran379tXIkSMVEBCgsLAwY2tn9uzZNWnSJN27d0+VKlVSnTp1dPnyZfn5+RkrgPGGDRum5cuXq3PnzrKyslJYWJhq1aqlbt266c6dOxoyZIjOnDmjjBkzqkiRIgoODlaFChXUp08f2dnZKXPmzKpbt26COVu2bKnOnTvL1tZWuXPnNiaNSenXr5+GDRumXbt2qVChQkmOiW99fNngwYMTjatRo4Zq1KihuXPnysPDQ9OmTdOoUaOM98rVq1dPnTp1kiT9+eefCZKx2NhYTZ48Wfnz5zcuBlK1alUNGDAg2dilF0nSq4vUtGvXTmvXrk1yfHKfmZd98MEHun79ujp37izpxftgwYIF2r17t+Li4hLFVLp0aXXq1El2dnZycHDQBx988NqYAQAA0qV0VlKzMNAnBZiUuLg4dezYUStWrEiwgA4AAKbAthI/DxOvTKs2aR2Cyfh5bP20DkG/3g5786BU9n7Bd/fdLUWtjwD+N27evKnWrVurWbNmJGkAAAD/YilufQSQ+hwdHbV169a0DgMAAMDsWKSz3kcqagAAAABgYqioAQAAADB7SSwwbtaoqAEAAACAiSFRAwAAAAATQ+sjAAAAALOXzjofqagBAAAAgKmhogYAAADA/KWzkhoVNQAAAAAwMSRqAAAAAGBiaH0EAAAAYPYs0lnvIxU1AAAAADAxJGoAAAAAYGJofQQAAABg9izSV+cjFTUAAAAAMDVU1AAAAACYvXRWUKOiBgAAAACmhkQNAAAAAEwMrY8AAAAAzF86632kogYAAAAAJoaKGgAAAACzZ5HOSmpU1AAAAADAxJCoAQAAAICJofURAAAAgNmzSF+dj1TUAAAAAMDUUFEDAAAAYPbSWUGNihoAAAAAmBoSNQAAAAAwMbQ+AgAAADB/6az3kYoaAAAAAJgYKmoAAAAAzJ5FOiupUVEDAAAAABNDogYAAAAAJobWRwAAAABmzyJ9dT5SUQMAAAAAU0OiBgAAAAAmhtZHAAAApFjEz/PTOgSTkcNtbVqHgJeks85HKmoAAAAAYGpI1AAAAACYPwsT+EuBX375Re7u7m8cR+sjAAAAAPwPLFu2TNu2bZOtre0bx1JRAwAAAID/gcKFC2vevHkpGkuiBgAAAMDsWZjA/73Jf/7zH1lZpaypkdZHAAAAAHgH/P395e/vb3zs6uoqV1fXvzUXiRoAAAAAs2dhAuvz/5PE7FW0PgIAAACAiSFRAwAAAID/kUKFCikgIOCN42h9BAAAAGD2TKDz8Z2iogYAAAAAJoaKGgAAAACzZwqLibxLVNQAAAAAwMSQqAEAAACAifl/7d1nWJRXuz78c+gKKiqiqKhg10gSu0Y0lhhsiEqzoLEXrFhQ7BpERbAES+yiqIhiN2pEY43dJMZYsRcEBIIUgYF5P/g6yKPu/d97Z+aacJ+/48jxzNzjA6fDsJxr1lrX4tJHIiIiIiIqBArX2kfOqBERERERERkYzqgREREREdG/HpuJEBERERERkU6xUCMiIiIiIjIwXPpIRERERET/eoVs5SNn1IiIiIiIiAwNZ9SIiIiIiOhfj81EiIiIiIiISKdYqBERERERERkYLn0kIiIiIqJ/PVUhayfCGTUiIiIiIiIDw0KNiIiIiIjIwHDpIxERERER/fsVrpWPnFEjIiIiIiIyNJxRIyIiIiKif71CNqHGGTUiIiIiIiJDw0KNiIiIiIjIwHDpIxERERER/eupCtnaR86oERERERERGRjOqBERERER0b+eqpC1E2Gh9j9w4cIFjB07FtWqVQMAZGVloUuXLvDx8fk/f+1x48ZhwYIFMDMz+z9/rdu3byM1NRWNGjX6b/9sdHQ07t+/jwkTJvyfv+//Ncv/xNOnT+Hq6oq6desWuL5x40asWLECBw4cgK2tLQAgJSUFHTt2xPDhwwEAly9fxvLly6FWq5GRkYHu3bujd+/eyMnJQUBAAJ49e4bs7GwMHz4cbdu2xaNHjzB58mSoVCpUr14dM2fOhJFRwcnoly9fon379pg/fz46dOjwv/r7+Pn5YceOHf/P/5/AwED0798f5cuX/x9/PyIiIiIybCzU/oeaNm2KxYsXAwCys7Ph4uKCrl27onjx4v+nr/vua/4Tjh49Chsbm3+8ODK0LNWqVcPmzZs/+th3332Hnj17Anj7c+rYsSM8PT2RkZGB77//HmvXroWNjQ3evHmDvn37wt7eHgkJCbC2tkZwcDBSUlLg5uaGtm3bIigoCGPHjkWTJk0wY8YMxMTE4Jtvvinw/aKjo+Hj44OtW7f+rwq1/42pU6fq5fsQERERkf6xUPs/SEtLg5GREYyNjXHx4kWEhYVBo9EgPT0dISEhKF++PMaMGYO0tDRkZmZi3LhxaNGiBaZMmYJHjx5piwQ3Nze0adMGP/30ExISEhAQEIDc3FyoVCpMmzYNtWrVQvv27VG/fn08ePAApUuXxg8//IDMzExMnToVr1+/Rnx8PHr16oW2bdti9+7dMDU1Rd26dfHmzRssXrwYxsbGsLe3x5w5c2BqavrRv8/HvseYMWPQt29fNG7cGNevX8eKFSuwbNkyzJw5E48ePUJeXp62iFm8eDEuXLgAtVqN9u3bo2vXrgWyvH79GkuWLIG5uTmsra0xb9483Lx5E4sWLYKpqSk8PT3x4MGDAl9jyJAh/+efU3JyMtRqNczNzbFt2za4ubnBxsYGAGBhYYF169ahaNGiePPmDb799lsAgEajgbGxMQDgxo0baNy4MQCgZcuWOHv2bIFCTaPRYO/evdi6dStGjBiBO3fuoEaNGoiOjsbJkyfx5s0bPH78GIMHD0b37t0/+lp59zN58OABJk6ciJ07dwIAxo4diwEDBiAmJuaD58XHxwezZs1CSkoKFixYABMTExQpUgRLly6FlZXV//l5IyIiIvpXKVwrH1mo/U+dP38ePj4+UKlUMDU1xfTp02FpaYm7d+8iODgYZcuWxapVq3D48GG0a9cOKSkpWLt2LV69eoWHDx8iLS0Nly5d0i5xO3v2bIGvv3DhQvTt2xft2rXDzZs3ERAQgOjoaDx58gSbNm2CnZ0dvL29cf36dZiamqJTp05o3749Xr58CR8fH/Tq1QvdunWDjY0N6tWrBxcXF2zduhWlS5fGkiVLsHv3bnh6en707/ax7+Hh4YHdu3ejcePGiI6OhqenJ6KiolCyZEnMmzcPycnJ6NOnDw4ePIj9+/cjPDwctra2iI6ORtmyZQtkadu2LbZt24ayZcti06ZNWLlyJb7++mtkZWUhKioKANCmTZsCX+O/cu/evQLLTuvWrYvJkycDeLsE8uDBg3jx4gXKli2L77//HlZWVoiPj0etWrUKfJ1ixYoBACwtLQG8LcBHjx6NsWPHAnhbiKn+/zZClpaWeP36dYH//6+//ooaNWqgVKlS6NGjByIiIjB79mzt11q3bh0ePnyIYcOGoXv37h99rXTp0gUA4ODgAAsLC9y7dw82NjZ4+vQpnJycMHbs2E8+L8eOHUOHDh3Qr18/HD9+HKmpqSzUiIiIiP7lWKj9D72/9PF9ZcuWRWBgIIoWLYqXL1+ifv36qF69Ory8vODn5we1Wg0fHx9YWVkhICAA06dPR1paGlxdXQt8ndjYWO0ywdq1ayMuLg4AULJkSdjZ2QEA7OzskJWVBTs7O2zatAlHjx6FlZUV1Gp1ga+VlJSE+Ph4bcHx5s0bNG/e/JN/t499D2dnZ+1SwMuXL2PatGmYO3curly5gj/++AMAoFarkZSUhODgYISEhCAxMRHOzs4FvnZycjKsrKxQtmxZAECjRo0QGhqKr7/+Gg4ODto/9199jf/0/7L08c8//4Sfnx+qVKkCAChfvrz2OX3n1q1byMvLQ506dfDixQv4+vqiV69e2uLp/f1o6enpHyxz3bFjB54+fYqBAwciJycHt2/f1u75e1cU2tnZITs7G8DHXyvv8/DwQHR0NMqXL699ffxXz8uwYcOwatUq9OvXD2XLloWTk9N/+bwRERERFUaFbEKNhdo/Zfr06fj5559hZWUFf39/aDQa3L59G+np6Vi9ejXi4+Ph7e2NunXr4saNG1i+fDmysrLQqlUrdO3aVft1qlatisuXL6Nt27a4efOmdome6iMHQ6xfvx5ffPEFevXqhfPnz+PkyZPaP5uXl4eSJUuiXLlyWLFiBYoVK4aYmBgULVr0k3+Hj30PIyMjuLi4YNasWWjXrh2MjY3h6OiIcuXKYdiwYXjz5g1WrlwJKysrHD58GKGhoQCAjh07olOnTgWypKWlIT4+Hra2trh48aK2eHpXCGVnZ3/0a1SoUOF/8RN567PPPsPgwYPh5+eH7du3o3PnzvD19UXHjh1RqlQppKenY8aMGfD19UViYiIGDBiAGTNmoFmzZtqvUadOHVy4cAFNmjTBqVOn0LRpU+1jSUlJ+P3333Hs2DHtUslp06Zh9+7dsLKy+uhz+rHXyvtcXFywfv16WFtbY+nSpZ98Xt7Zt28funXrBn9/f/z444/YsWMHRo4c+b9+zoiIiIhIHgu1f4irqyt69+6NIkWKwMbGBvHx8ahSpQqWL1+On376CXl5eRg9ejTKlCmDhIQEeHt7w8jICAMGDICJSf6PYdKkSZg+fTrWr18PtVqNwMDAT37P1q1b4/vvv8ehQ4dQrFgxGBsbIzs7G5999hkWLlyIqlWrYurUqRgyZAg0Gg0sLS2xcOHC//HfrUePHmjXrh2OHDkCAPD29sa0adPQp08fpKWloVevXjAzM0OJEiXg6ekJCwsLfPXVVyhfvnyBLN9//z1GjRoFlUqFEiVKICgoCHfv3tV+n099jf379yMjIwNeXl4Fcv3n0kcAmDdv3gf5PTw88NNPP2Hbtm3o3bs3Jk6ciJEjR8LY2Bjp6elwd3dHq1at8P333yM1NRUrVqzAihUrAABr1qyBv78/pk+fjtDQUDg6Omr3sQHA3r170b59e22RBgCenp6YNGkSBg8e/NHn82OvlfeZm5ujUaNGSEpKgrW1NQB89Hl5x8nJCdOmTUORIkVgZGSEOXPmfPJnSURERET/DirNf36cT0TiZs+ejfbt2xeY2SMiIiLDUrJPhHQEg5G8pbd0BLxKV//3f0jHSlv+c/NgRv/9HyEifRowYABSU1NZpBEREREpGJc+EhmY9evXS0cgIiIi+tdRFbJ2IpxRIyIiIiIiMjAs1IiIiIiIiAwMlz4SEREREdG/3kdORfpX44waERERERGRgWGhRkREREREZGBYqBERERERERkYFmpEREREREQGhs1EiIiIiIjoX4/NRIiIiIiIiEinWKgREREREREZGC59JCIiIiKifz0VCtfaR86oERERERERGRjOqBERERER0b8em4kQERERERGRTrFQIyIiIiIiMjBc+khERERERP96hWzlI2fUiIiIiIiIDA1n1IiIiIiI6N+vkE2pcUaNiIiIiIjIwLBQIyIiIiIiMjBc+khERERERP96qkK29pEzakRERERERAaGM2pERERERPSvpypcE2qcUSMiIiIiIjI0LNSIiIiIiIgMDJc+EhERERHRv14hW/nIGTUiIiIiIiJDwxk1IiIiIiL69ytkU2qcUSMiIiIiIjIwLNSIiIiIiIgMDJc+EhERERHRv56qkK195IwaERERERGRgWGhRkREREREZGC49JGIiIiIiP71VIVr5SNn1IiIiIiIiAyNSqPRaKRDEBERERERUT7OqBERERERERkYFmpEREREREQGhoUaERERERGRgWGhRkREREREZGBYqBERERERERkYFmpEREREREQGhoUaERERERGRgWGhRkR6k5aWhvT0dOzZswd///23dBwyEHl5ecjNzcXly5eRnZ0tHYfI4HDszMfx4q2MjAzExcUhMTERy5cvx7Nnz6QjkQ7wwGsi0otx48bh66+/xrVr15CXl4dXr15h+fLl0rFEZGRkIDU1FSYmJoiMjISbmxsqVKggHUtEYGAgqlatiufPn+PGjRuwsbHBggULpGOJOHfuHNRqNTQaDebOnYsxY8agS5cu0rFE3Lp1C5mZmTAyMkJoaCiGDRuGZs2aSccSwbEzH8eLfIMGDYK3tzeOHj2KatWq4cKFC1i3bp10LPqHcUaNiPQiPj4eXbt2RWxsLObMmYP09HTpSGJGjx6NP//8EwsXLoSpqSlmzJghHUnM9evX4e3tjWvXrmHdunWIi4uTjiRm8eLFqFKlCsLDw7Ft2zZs375dOpKYWbNmwczMDCtXrsS4ceMQFhYmHUkMx858HC/yvXnzBm3btkVcXByGDBmC3Nxc6UikAyzUiEgvcnJytJ/8JSUlKfrNBv+BzZeXl4c///wTFStWRHZ2tqJfFxYWFihdujRMTExQpkwZqFQq6UhizMzMUL16deTk5OCLL76AkZFy365w7MzH8SJfTk4ONm3ahLp16+LevXvIzMyUjkQ6oNyRj4j0atCgQTh48CCGDh2KzZs3Y8SIEdKRxPAf2Hxdu3bF7NmzMWDAAAQHB8PLy0s6khhLS0sMGjQIHTp0QEREBEqVKiUdSYxKpcKkSZPQsmVLHDp0CKamptKRxHDszMfxIp+/vz/i4+MxfPhwnD9/HlOnTpWORDrAPWpEpFNqtRomJiYf3fRtZmYmkEje1atXcezYMQwbNgz79u2Dk5MTnJycpGORsOzsbDx+/BjVqlXDnTt3UKVKFcX+jiQlJeH69eto2bIlLly4gFq1asHa2lo6ll5x7KSPiYuLQ7ly5fDgwYMPHnNwcBBIRLrEQo2IdGr8+PEICQlBmzZtoFKp8G7IUalUiImJEU4n59y5c3jy5Ak+//xzODg4wNzcXDqSXo0ePRrLli1DixYtPnjszJkzAonkREVFwcPDA6GhoR885ufnJ5BIXs+ePbFt2zbpGKI4dubjeJEvKCgIU6ZMgY+Pzwevi/DwcOF09E9joUZEepebmwtjY2PpGGJCQ0MRFxeH2NhY9OnTB6dPn/7om3RShtOnT8PZ2Rm7d+/+4LFu3boJJJL3rsujg4ODdn/ax96kK43Sx076uBcvXsDOzk46BumAiXQAIlKGffv2wdjYGNnZ2QgODsbAgQMxcOBA6Vgirly5goiICPj4+KBbt26KnjlgS3rA2dkZAPDtt98iNTUVxsbG2LFjB9zc3GSDCSpZsiRu3bqFW7duaa8ptVDj2JmP40W+tWvXonjx4khNTUV0dDScnZ0xZcoU6Vj0D2MzESLSi/DwcDRv3hz79u3DL7/8ghMnTkhHEpObm4usrCyoVCrk5uYquqMdW9LnGz16NG7cuIHg4GDFH9sQFBSEIUOGwMXFBWPGjEFgYKB0JDEcO/NxvMh39OhRuLm54dSpUzh06BD++usv6UikA8p9d0BEevVuD5alpSXMzMygVquFE8n57rvv0L17d9y9exceHh7o1auXdCQxbEmf782bN2jTpg2PbQCwZcsWzJo1C4sXL8aRI0fw/fffS0cSw7EzH8eLfEZGRkhMTISNjQ0AICsrSzgR6QILNSLSi0qVKsHLyws9evRAWFgYatasKR1J7/Ly8gAALi4u2Lp1K3788UesXbtWsUu6ALakfx+Pbch38OBBbNiwAcWKFUO/fv3w+++/S0cSw7EzH8eLfE2aNIGPjw/69OmDefPmoVWrVtKRSAfYTISI9CIhIQFFixaFpaUlEhISUKZMGelIetevXz+EhoaidOnS2mvnz59HQEAAjh8/LphMDlvS5+OxDfm8vb2xbds29OvXD+Hh4YruAsmxMx/Hi3zXr19HvXr1ALx9XpT6PBR2bCZCRHoxevRolCpVCu7u7or95G/w4MHo168fZsyYgYYNG2Lp0qWIiYlBWFiYdDQxPXr0QNOmTeHh4YEaNWpIxxF14MABeHh4oHjx4ujTp490HFGdO3dG79698fz5cwwePBjt2rWTjiSGY2c+jhf51q9fj2fPnsHV1RWurq4s1AopzqgRkd7cu3cPu3btwpUrV9CsWTO4u7vD3t5eOpZevXjxAn5+fnj9+jW+/PJLBAQEoEiRItKxxOTl5eH06dPYtWsXkpOT4erqio4dO8LS0lI6mt6dOnUKu3btwsuXL7VvvqysrKRjiYmNjcWdO3fg4OCAqlWrwtTUVDqSGI6db3G8KOjvv//GgQMHcOzYMZQqVQqenp5o0qSJdCz6B3GPGhHpTdmyZWFvbw8LCwvcuXMHgYGBWLRokXQsvfrtt98QHx+P2rVr4/Hjx3j9+rV0JFFGRkZo2bIlevToAWtra2zevBkDBw7Eli1bpKPpXcuWLbF06VKsWLECV65cgbOzMyZPnozHjx9LR9O7NWvWoGrVqujQoQNUKhU8PT2lI4ni2PkWx4uCEhMT8fz5cyQnJ6NkyZI4cuQIJkyYIB2L/kFc+khEejFmzBjcvXsXrq6uCA4ORtmyZQEA3bt3F06mP1OnTsWDBw8QHh6OChUq4NixY/Dx8cGUKVPw9ddfS8cTsXDhQsTExKBx48YYPHgwnJyckJeXh+7duytu+V9sbCyio6Nx4sQJNG7cGBEREVCr1Rg7diyio6Ol4+nV3bt3sW3bNmRkZGDPnj2YNWuWdCQxHDvzcbzI5+HhAQsLC3h4eGDMmDHapY9KPWOvsOLSRyLSi7Nnz+Krr7764HpWVpa2/XRht3TpUowcORLGxsbaa0+ePMG4ceOwc+dOwWRyduzYgU6dOn2wdOnp06eoWLGiUCoZPXv2hKenJ1xcXAosh42IiEDv3r0Fk+lfXl4eJkyYgKSkJKxevVrR+284dubjeJHv4cOHqFKlinQM0jEWakSkU35+fp886yYkJETPaWRpNJqPPhcPHjyAg4ODQCI5ISEhn3xd+Pn56TmNrAcPHgD4+OtDaa8LLy8v7XOQk5OD27dv47PPPgMAxR1uzLEzH8eLfO//jrzzbuxQ2u+IEnDpIxHplLe3t3QEg/Gu1TgALFiwAP7+/gCAmTNnaq8rhaOjo3QEgzFjxoyPXlepVIp7XYSGhkpHMBgcO/NxvMjH3xFlYaFGRDrVuHFjAEBKSgrOnDkDtVoNjUaD+Ph47WNK8f4Chhs3bnz0ulJ069YNAKBWq3H9+vUCrwul2bx580evZ2dn6zmJvAoVKgAAHj16hMOHDyMnJwcAEB8fjzlz5khG0zuOnfk4XuTj74iysFAjIr0YOXIkHB0dcefOHZibmyu6JT1QsDj71JIeJRg5ciRycnIQHx+P3Nxc2NraonPnztKxRGzfvh0bNmzQvgk1NTXFkSNHpGOJGD9+PL755htcvXoVtra2yMjIkI4khmNnPo4X+fg7ogxsz09EeqHRaDBnzhw4ODhgw4YNSElJkY6kd+8XZEouzt6XnJyMdevWwcnJCdHR0cjKypKOJCYiIgKbN29Gy5YtERQUhKpVq0pHElO0aFEMHToUZcuWxfz585GYmCgdSQzHznwcL/Lxd0QZOKNGRHphbGyMrKwsZGZmQqVSITc3VzqS3t24cQPe3t7QaDS4d++e9nZsbKx0NDEWFhYAgMzMTFhYWCi6gLW1tYWtrS3S09PRpEkThIWFSUcSo1KpkJCQgPT0dGRkZCh6toBjZz6OF/n4O6IMLNSISC969+6NjRs34quvvkKrVq3QoEED6Uh6t3fvXpw5cwZNmzaFqakpXrx4gTt37qBly5bS0cS0b98eYWFhqFWrFjw9PVG0aFHpSGKKFSuGY8eOabu3KXnmZOTIkfj555/RtWtXtGvXDl27dpWOJIZjZz6OF/n4O6IMbM9PRHqXlpYGKysr6Rh6FxYWhjt37mDBggUoUqQInj59ivnz56N27drw9fWVjifu9u3bqFKliuLOhnonLS0Njx8/RunSpbFhwwa0bt0aTZo0kY4l4sSJE2jdurX2/qFDh9CxY0fBRIZBqWPnxyh9vCBlYKFGRHpx9uxZbNy4scCeAqW1Hvfw8MCOHTsKLNfJycmBt7c3du3aJZhMzs2bNxEZGVngdREUFCSYSI5Go8H169cLPBeNGjUSTKR/J06cwNWrV3Hw4EFtk4i8vDzExMTgp59+Ek4ng2NnPo4X+fbs2YMff/yxQHfYmJgYwUSkC1z6SER6ERQUhICAAJQrV046ipgiRYp8sKfC1NQUlpaWQonkTZ48GX369FH06+KdUaNG4dWrV7CzswPwdg+K0gq1WrVqITk5Gebm5trDvlUqFTp16iScTA7HznwcL/KtWbMGq1at0o4XVDixUCMivbCzs0Pz5s2lY4gqUqQInjx5Ant7e+21J0+eKHpDvI2NDTw8PKRjGITExERs375dOoYoOzs7dO/eHW5ubjAyMsLdu3dhamqKKlWqSEcTw7EzH8eLfPb29qhcubJ0DNIxFmpEpBelS5fGjBkzUKdOHW1h4uXlJZxKvyZMmIARI0agWbNmsLe3x/Pnz3HmzBksWLBAOpqYChUqYPXq1ahdu7b2ddGiRQvhVDIcHBzw8uVLlC1bVjqKmLNnz2Lq1Kn4+eefERkZiXXr1qFUqVLw8PBQ7Bt0jp35OF7ks7CwwKBBgwo8F35+fsKp6J/GQo2I9KJixYoAoOizXqpXr46tW7ciJiYG8fHxqFu3Lnx9fRXdHCAnJwcPHjzAgwcPtNeU+sbr6tWraN26NUqVKqW9dubMGcFE+rd8+XJERUXB1NQUa9aswYYNG2BnZwcfHx/FFmocO/NxvMjXqlUr6QikByzUiEgvRo4cqb19/PhxRERECKaRU6xYMbi5uUnHMBjvNwK4ffu2Yl8XAHDkyJEC969duyaURI6JiQnKlCmDJ0+ewNTUVLu0y8jISDiZHI6d+The5OvWrRuAt51Ad+/ejW3btmmvUeHBQo2I9CIlJQVRUVHYsWMHKlWqBHd3d+lIZAByc3Nx9OhRREREIDExUbGzJu9kZ2dj//79iIiIQHZ2Ng4cOCAdSa9UKhXUajV++eUX7UxJeno63rx5I5xMDsfOfBwv8t27dw9btmzB4cOH0b59e8yfP186EukACzUi0qk///wTERERuHr1Kjp06IBy5cph3bp10rFIWEJCAiIjI7F371588cUXyM7OxuHDh6VjiXn69CkiIiLw008/QaPRYPHixahfv750LL3r1q0bOnbsCLVajU2bNuHOnTuYOHEifHx8pKPpHcfOfBwv8h05cgQRERHIyclB9+7d8eDBA8yZM0c6FumIctcSEJFeeHt7w9bWFvv378fYsWNhYWEhHYkMQPv27ZGTk4Pdu3cjODgYxYsXl44kZtiwYZg8eTIcHR1x4MABVK9eXZFFGgC4ubkhOjoahw8fhr29PaytrREUFKTIWSSOnfk4XuTz9/fHF198gRUrVsDDwwNmZmbSkUiHWKgRkU5t3boVSUlJ6Ny5M4KDg5GRkSEdiQxAYGAgrl+/jn79+mHr1q3IycmRjiTK2NgYb968QV5enqKPawAAKysr7ZtPW1tb1KlTRziRDI6d+The5Dt69CiKFi2K3r17Y+zYsUhOTpaORDqk0mg0GukQRFT4ZWRk4ODBg9i5cyfy8vLQtWtX9OnTRzoWCXv69Cl27tyJffv2wcnJCV27dkXr1q2lY+ndixcvsGvXLuzfvx8ZGRkIDAxEixYtFN1Eg97i2JmP40VBv/76K3bs2IHff/8d3377Lfz9/aUj0T+MhRoR6d3t27cRFRWFadOmSUchA5GXl4dffvkFO3fuxIoVK6TjiNFoNDh9+jR27tyJP/74A7/88ot0JDIgHDvf4nhRUFJSEvbt24fvvvtOOgr9w1ioERERGaBXr16hdOnS0jH06uHDhwgJCYG5uTlGjhyJKlWqAABmzpyJ2bNny4YjItIzrqkgIiIyQEor0gBg+vTp8PLyQufOneHr64u//voLAHD//n3hZERE+sf2/ESkU5cuXfrkY40aNdJjEqJ/j7y8PMXuT3t3flqlSpUwatQorF27VrENVm7duoVz587h9evXKF68OBo0aAAnJyfpWCTs2LFj+PXXXwu8LlxcXBT7e1KYsVAjIp3atm2b9vaFCxfQtGlTaDQaqFQqFmoKlp2d/cnHlNpuet++fTA2NkZ2djYWLlyIQYMGYeDAgdKx9MrExATHjx9Hq1at4OjoiOnTp2Po0KFQq9XS0fQuLCwMf/zxB1q0aIGKFSsiPT0dYWFhqFOnDsaOHSsdT684XuSbPXs28vLy0LJlS1haWiI9PR2nTp3CmTNnEBgYKB2P/mHco0ZEeuPj44PNmzdLxyAD8O233+LVq1coUaKEtnB/978xMTHS8US4u7tjzZo18PPzw48//ogBAwZgy5Yt0rH06vnz51i2bBkmT54Ma2trAMD58+cRFBSEvXv3yobTs169emHr1q0Frmk0Gnh6eiIqKkoolQyOF/n69Onz0XHB29sb27dvF0hEusQZNSLSGy7LoHe2bduGgQMHYuPGjShRooR0HIPw7kBjS0tLmJmZKXIWqXz58pg/f36Ba02bNlVckQYAarUaT58+RcWKFbXXnj59qsglsRwv8uXl5eHy5cto2LCh9tqlS5dgamoqmIp0hTNqRKQ3ffv2RXh4uHQMMhBnzpyBsbExmjVrJh3FIEyZMgVXrlzBlClTcOPGDSQkJCiu0+G7/WkA8Pfffxd4U37mzBmJSGJ+++03zJo1Czk5ObCyskJaWhrMzMwwa9YsfP7559Lx9I7jxVuPHz9GUFAQbty4AY1GA2NjY9SuXRv+/v7aLqlUeLBQIyKdCgkJ0c6k7d+/H126dNE+5ufnJxWLyCClp6fD0tISCQkJKFOmjHQcUVwq/VZaWpr2dWFlZSUdhwxUdna24vbrKYHy5s+JSK8cHR3h4OAABwcHjB49WnvbwcFBOhoJSkpKwoIFC7B48WIkJydrr4eFhQmmkvXbb79hwYIFmDJlCkJDQxXXSOQ/KX2p9O+//47u3btj8ODBePLkibZI8/X1FU6mfxwv8h0/fhytW7fGN998g0OHDmmvDxo0SDAV6Qr3qBGRTsXHx2Po0KHSMcjATJo0Cd988w3UajX69OmD1atXo0KFCrh48aJ0NDGzZs3CoEGDcOTIEdSoUeO/7HRHhV9QUBBCQkKgVqsxadIkjB8/Hi1atEBqaqp0NL3jeJFv1apV2LNnD/Ly8jBmzBhkZWWhW7du4AK5womFGhHp1NmzZ1mo0Qeys7Ph5eUFAKhduzZGjBiBzZs3K/rNRsmSJdG5c2ecPXsWo0aNQp8+faQj6d37+9D+/vvvAvff37+mBKamptqVB6tXr8aAAQNQpkwZRc40crzIZ2pqqt27uWLFCvTr1w92dnaKfF0oAQs1ItKplJSUTzYBUNobL8qXm5uL27dvo2bNmqhfvz6GDh2K4cOHIyMjQzqaGCMjI9y9exeZmZm4f/8+/v77b+lIenfw4EHt7Tp16hS4r7TxwtLSEuHh4fD29kaZMmWwaNEijB07VpEzrRwv8lWoUAFBQUEYM2YMrKysEBYWhoEDBypyplUJ2EyEiHSqRYsWcHZ2/uhjQUFBek5DhuLmzZuYN28eFi9eDBsbGwDA3r17MW/ePFy4cEE4nYy7d+/i7t27KFu2LAIDA+Hq6orvvvtOOpZenTx5Eq1atZKOYRDS0tKwYcMG9O/fX7s/7d69ewgNDcWKFSuE0+kXx4t8arUa+/btQ4cOHVCkSBEAwKtXr7Bq1SpMnTpVOB3901ioEZFOsXMbfcz9+/fh6Oj4wfW8vDxFnhP1zsuXL5GbmwuVSgU7OzvpOHrHIzwKio2NRdWqVQEAT548QWZmJmrUqCGcSv84XhR05swZfPXVV1CpVLh58yYSEhLQsmVL6VikA8p7dRORXhkbG0tHIAPUuXNnLFmyBDk5OQWuK/FN171799C3b18AQL9+/TBu3Dj07NkTR48eFU6mfxqNBjk5OcjOzv7gP6U5cuQIRowYgdevXwMAEhISMGrUKBw7dkw4mf5xvMi3detWhIWFIT09HcDb7qjLly9HZGSkcDLSBeW9wolIr9avX//R68+ePdNzEjIkDRo0QLFixeDu7o7du3cr8o34O4sWLcLEiRMBAGXKlEFkZCQ2bdqkyJno33//HS4uLnBxcUGHDh3QoUMH7W2lWb9+PSIjI1GsWDEAQP369bF161asXr1aOJn+cbzIt3v3bmzatEm7HLZWrVpYv349duzYIZyMdIGFGhHp1Pt7bBYsWKC9PWXKFIE0ZChUKhUGDhyIH3/8Ebdv30aXLl0wYsQIRe5bzMzMRL169QBA+6a8cuXKUKvVkrFEfP7554iJicHx48cRExNT4LbSmJmZwdrausC10qVLw9zcXCaQII4X+SwsLD54DVhaWsLS0lIoEekSuz4SkU69vw32xo0bH71OyvPu51+uXDlMnjwZ/v7+uHPnDh48eCCcTP+ysrK0t99vEmFiwn+ilUylUuHNmzewsLDQXsvMzPxg+Z8ScLzIZ2pqiqSkJJQqVUp7LSkpCbm5uYKpSFf4rwAR6c37xRnPfFG2IUOGFLivUqlQs2ZN1KxZUyiRHFtbW/zxxx9wcnLSXvvjjz9QpkwZwVQypk+fLh3BYPTt2xeDBw9Gv379YG9vj7i4OKxdu1aR5+txvMg3YsQIDBw4EG5ubrC3t8eLFy+wc+dO7fJpKly49JGIdOr9gozFGb3j7OyMyMhI7fK+y5cvY9u2bcKpZEycOBFTp05FYGAgtmzZgqCgIEybNg0TJkyQjqZ37++z2bdvn/a2r6+vRBxR7dq1w7hx4xATE4OFCxciJiYG48ePR+fOnaWj6R3Hi3wNGzbEsmXL8Pr1a/zyyy9IS0tDWFgYmjdvLh2NdIAzakSkUzdu3IC3tzc0Gg3u3bunvR0bGysdjQSFhYXhzp07cHV1hYmJCcqVK4eNGzfi1atXGDlypHQ8vbK3t0dUVBSOHz+Op0+f4rPPPsOYMWNQtGhR6Wh6d+fOHe3tnTt3wtXVFQAUe5hv/fr1Ub9+/QLXlHjWHMeLgiwtLTFgwIACY8TWrVvRq1cvwVSkCyzUiEin3v9UnOidkydPYseOHdpZ1ooVK2Lx4sXw9vZW5BsvCwsLdOzYUTqGuPeXRyt9qXR0dDRCQ0NhYWGBZcuWwd7eHtOmTcP9+/cVV6hxvMj3448/YufOncjNzUVgYCAqV66McePGwcrKioVaIcRCjYh0qkKFCtIRyAAVLVr0gzffpqam7FymcFwqnW/Dhg04ePAgEhISMH/+fMTHx6Nt27ZYtGiRdDS943iR7+DBgzh48CCSk5Ph5+eHxMREDB48GO7u7tLRSAdYqBERkd5ZWFjgyZMnsLe311578uSJ4t+cK92TJ08QGhoKjUZT4PbTp0+lo+mdtbU1SpQogRIlSiA2NhazZs1S3EzaOxwv8pUoUQJmZmYoW7YsXr58iaVLl6Ju3brSsUhHWKgREZHeTZgwASNGjECzZs1gb2+P58+f48yZMwXO2lO6EydOoHXr1tIx9Gr06NEfvT1q1CiJOKLeL0LKly+v2CIN4HjxvvdfF3Z2dizSCjkWakQkIioqCh4eHtIxSEj16tWxdetWxMTEID4+HnXr1oWvry+srKykoxmMR48eSUfQu27duklHMBgpKSk4e/Ys8vLykJaWhjNnzmgfa9GihWAy/eN4ke/ly5eIjIyERqNBfHw8IiMjtY95eXkJJiNdUGl46iwRCThw4IAi20xTvhs3bqBYsWKoVKkSgLcHPy9btoznAQHIy8uDkRFP0FGyKVOmfPKxoKAgPSYxDBwv3goLC/vkY0prrKIEnFEjIr178eIFizSFmzt3Lv766y+kpaVh+PDhqFy5MkaPHo2vvvpKOpqYffv2wdjYGNnZ2Vi4cCEGDRqEgQMHSsciIZ8qxrKzs/WcRB7Hi3y+vr4f3Zv37NkzgTSkayzUiEgv1q5di+LFiyM1NRXR0dFwdnb+Lz8xpsLt6tWr2L17N16/fo3vvvsOGRkZ+P7779GsWTPpaGLCw8OxZs0a+Pn54eTJkxgwYIDiCrU9e/Z88jE3Nze95TAEY8eOxZIlSwAA69evx4ABAwAAgwYNQnh4uGAy/eN4ka9fv37an/+CBQvg7+8P4O0MrNJeF0rAdRVEpBdHjx6Fm5sbTp06hUOHDuHmzZvSkUjQu70lxYoVQ1paGtasWaPIN13vMzc3B/D2MFszMzOo1WrhRPoXGxuL2NhY7Nq1C4cOHcKLFy9w9OhRHDp0SDqa3r169Up7+5dfftHeVuKOFY4X+d7/+d+4ceOj16nw4IwaEemFkZEREhMTYWNjAwB48+aNcCKS9P7SHVtbW1SsWFEwjWGoVKkSvLy8MGXKFISFhaFmzZrSkfRu/PjxAICBAwdi9erV2uvvZpOUSumHf3O8+Dilvy6UgIUaEelFkyZN4OPjg+DgYMybN0/RraYJH5yRFRoaqn3Mz89PMJmcrl27Ytq0abC0tMRnn32GMmXKSEcSk5SUhNTUVBQvXhzJyclISUmRjqR3PPw7H8eLfHxdKAu7PhKR3uXk5MDU1FQ6BgnavXv3Jx9Taov23r17IyIiQjqGQThy5AgWLFiAEiVK4PXr15g+fbriPtxp3rw5mjVrBo1Gg/Pnz2tvX7hwAWfPnpWOp1ccL/I1aNAA1atXh0ajwb1797S3Y2NjcfnyZel49A9joUZEenH27Fls3LgRWVlZ2mvc+Kxc8fHxsLW1/eD677//js8//1wgkbw+ffqgRIkScHBw0LbmV9pswfvUajWSkpJQunRpGBsbS8fRu4sXL37yscaNG+sxiTyOF/n+q+6OFSpU0GMS0gcWakSkF507d0ZAQADKlSunvebo6CiYiCT17dtXW6hPnDgRwcHBH1xXmo/NGihttuAdfrBD7+N4QUrFPWpEpBd2dnZo3ry5dAwyEO9/RhgXF/fR60rTpUsX7N69G8+fP0fTpk1RvXp16UhigoKCPvhgh5SL4wUpFQs1ItKL0qVLY8aMGahTp452A7SXl5dwKjI0St4cP3PmTNja2uLcuXOoV68e/P39sWbNGulYIvjBDv2/UPJ4QcrAc9SISC8qVqwIW1tbJCYmIiEhAQkJCdKRSBA7l33o8ePHGDNmDMzMzNCmTRu8fv1aOpKYdx/sbN++HZGRkYiMjJSOZDBOnDghHUHvOF7896KioqQjkA5wRo2I9GLkyJE4d+4cnjx5gs8//xwODg7SkUjQ1atX0aJFCwBASkqK9vbff/8tGUtUbm4ukpKSoFKpkJaWpm0ookTvzslKTEwUTmJ4Hj16JB1B7zhe/PeKFCkiHYF0gM1EiEgvQkNDERcXh9jYWPTp0wenT58ucBYOkdJdvHgR06dPR0JCAuzs7DB16lRFL/+Lj4+HWq2GRqNBfHw8vvzyS+lI4vLy8hRdwNPHvXjxAnZ2dtIxSAc4o0ZEenHlyhVERETAx8cH3bp1w7Zt26QjERmUL7/8EkeOHEFSUhJKliyJJ0+eSEcSExAQgN9++w2ZmZl48+YN7O3tsWPHDulYIvbt2wdjY2NkZ2dj4cKFGDRoEAYOHCgdi4StXbsWxYsXR2pqKqKjo+Hs7IwpU6ZIx6J/GD+WISK9yM3NRVZWFlQqFXJzc/mpMNF/GD9+PACgVKlSiIyMxODBg4UTybl16xYOHjyIFi1a4ODBgzA3N5eOJCY8PBzNmzfHvn37cPLkSUXuUaMPHT16FG5ubjh16hQOHTqEmzdvSkciHeCMGhHpRb9+/dC9e3ckJSXBw8MD/fv3l45EZFCaNWuGiRMn4vXr1yhWrJhiZ5AAoGTJklCpVMjIyECpUqWk44h6V6RaWlrCzMwMarVaOBEZAiMjIyQmJsLGxgYA8ObNG+FEpAss1IhIL9q0aYPmzZvj0aNHqFixIpKTk6UjkSAfH59Pdm9T2gG22dnZAIAePXogIyMDv/76KwIDA4VTyapbty7WrVsHW1tbjBs3TtFvQitVqgQvLy9MmTIFYWFhqFmzpnQkveN48aEmTZrAx8cHwcHBmDdvHlq1aiUdiXSAzUSISC++/PJLLFu2DM7OzgCAvn37KvYfWALu378PAFi+fDnatm2LBg0a4I8//sCJEycwb9484XT61aZNG6hUqgKH9757UxoTEyMVS1xaWhosLCxw6tQpODk5aWcOlOb8+fOoV68eLC0tkZCQgDJlykhH0juOFx/at28fXF1dAbz9sMfMzEw4EekCZ9SISC8cHR2xceNGJCcnw9XVFfyMSNkcHR0BvG2/3rFjRwDAN998g82bN0vGEnH8+HEAgEajQVxcHOzs7PDHH3/AyclJOJksKysrAG8LWSX74YcfEBERAQCKLNIAjhcfs2PHDm2hxiKt8GKhRkR6YWlpiZUrV8LPzw+JiYkwNTWVjkQGIioqCk5OTrh27ZqiXxczZ85E5cqVMXDgQOzbtw/79+/H1KlTpWORMJVKBV9fXzg4OGibMPn5+QmnksPx4q3s7Gy4ubnBwcEBKpUKKpUKISEh0rHoH8alj0SkFz4+Pti8eTNyc3MREBCAn3/+GVevXpWORcISEhKwatUqPHz4ENWqVcOwYcNQsmRJ6Vgi3N3dsXPnTu393r17a2dSlEzpZ4ft3r37g2vdunUTSCKP40W+ixcvfnCtcePGAklIl1ioEZFePH36FBUrVtTeP3z4MFxcXAQTkaF49eoVsrKytPfLly8vmEaOu7s71qxZg5IlSyI1NRVDhgzB9u3bpWOJ4Nlh+dRqNXbv3o3nz5+jadOmqF69uqI7YXK8eCstLQ3Lly9HbGwsqlSpghEjRsDa2lo6Fv3DuPSRiHRqxYoVGDFiBEJDQz/o2sVCjWbNmoVTp07B1tYWGo0GKpVKscWJr68vevTogRIlSuD169eYMWOGdCQx4eHhWLNmDfz8/HDy5EkMGDBAsYXazJkzYWtri3PnzqFevXrw9/fHmjVrpGOJ4HiRLyAgAI0aNYKrqysuXryIyZMnY9WqVdKx6B/GQo2IdOpdIwBvb2/hJGSI/vjjDxw7dkzRS9vead26NVq2bInk5GSULl36k+3IlcDCwgIAzw4DgMePHyMwMBCXL19GmzZtsHr1aulIYjhe5EtOToaPjw8AoHbt2jhy5IhwItIFFmpEpFPVq1dHdnY2wsPDsXjxYmg0GuTl5WHIkCFsz0+oXLkysrKyUKRIEeko4mJiYrB161bk5ORAo9EgJSUF+/fvl44lwt7eXvFnh72Tm5uLpKQkqFQqpKWlKbpI4XiRLysrS3tcQ2JiIvLy8qQjkQ6wUCMindq1axdWrVqFxMREuLi4QKPRwNjYGA0aNJCORgbgxYsXaN26NSpXrgwAil7KtGTJEsyZMwfbt29HkyZNcO7cOelIYoKCgpCeng5LS0vUq1dPsWeoAcDYsWPRs2dPJCQkwMvLCwEBAdKRxHC8yDdmzBh4e3ujWLFiSEtLw9y5c6UjkQ6wmQgR6cXOnTvh7u4uHYMMzLNnzz64VqFCBYEk8gYOHIh169bB398fCxYs0HZKVZJ3e1r9/Pw+WPqp9NbjSUlJKFmypKKXxHK8yHf9+nXUq1cPSUlJKFWqFC5evMiuj4UQZ9SISKeioqLg4eGBR48eITQ0tMBjSj4LiN5Sq9U4fPgwcnJyAADx8fGYM2eOcCoZpqamuHTpEtRqNU6fPo3k5GTpSHrHPa35fHx8PlmUKXXZOMcL4PLly7h37x42btyI/v37A3h7hEVERAQOHDggnI7+aSzUiEinypUrBwBwdHQUTkKGaPz48fjmm29w9epV2NraIiMjQzqSmNmzZ+P+/fsYPnw4li5diuHDh0tH0rtatWoBeLsX6fXr1zAyMsLatWu1TROUZPbs2QCA5cuXo23btmjQoAH++OMPnDhxQjiZHI4XQPHixZGYmIjs7GwkJCQAeLsEdOLEicLJSBdYqBGRTjk7O+PMmTNwc3ODSqXCzZs3kZCQgJYtW0pHIwNQtGhRDB06FA8fPkRQUBB69eolHUnvnj9/rr39bu/NlClTpOIYhPHjx2PkyJHYunUrvv32W8ybN09xy0DffbiVmJiIjh07AgC++eYbxT0P7+N4AdSoUQM1atSAh4cHypYtC+Dt3j07OzvhZKQLLNSISKe2bt2Kffv24YsvvoCVlRVUKhWWL1+OFy9ewMvLSzoeCVOpVEhISEB6ejoyMjIU+Qn5uHHjoFKpoNFoEBsbi2rVqin+jCiVSoVGjRph1apV6NSpE3bs2CEdSVRUVBScnJxw7do1mJqaSscRw/Ei3/79+1G8eHGkpqYiOjoazs7Oiv+ApzBioUZEOrV7925s2bIF5ubmAN4ubVq/fj369u3LQo0wcuRIHDt2DF27dkW7du3QtWtX6Uh6FxkZqb2txAYiH6NWqxEcHIyGDRvi/Pnz2j1JSrRo0SKsWrUKhw8fRrVq1bBo0SLpSGI4XuQ7evQotmzZgkGDBuHQoUPo27evdCTSARZqRKRTFhYW2iLtHUtLS1haWgolIkPSqFEjNGrUCADQtm1b4TTylNzR731BQUE4e/YsPDw8cOzYMSxYsEA6kpgyZcpg6NChUKvV0Gg0ePjwIUqWLCkdSwTHi3xGRkZITEzUHl3x5s0b4USkCyzUiEinTE1Nte2D30lKSkJubq5gKiIyZPb29jAzM8PKlSvRtGlTRX+wExAQgN9++w2ZmZl48+YN7O3tFb8UlIAmTZrAx8cHwcHBmDdvHlq1aiUdiXSA56gRkU5dvnwZgYGBcHNzg729PV68eIGdO3di4sSJaN68uXQ8InHvL31cv349BgwYoL2v1OXBU6dOha2tLc6dO4ehQ4di27ZtWLNmjXQsEd27d8euXbswY8YMjBs3DmPGjOHyWNJKSUlB0aJFYWZmJh2FdMBIOgARFW4NGzbEsmXL8Pr1a/zyyy9IS0tDWFgYizRCUlISjhw5gp07d+Lo0aOIj4+XjiQiISFB+1+XLl0K3Feqx48fY8yYMTA3N0ebNm3w+vVr6Uhi3h1ynZGRUWBlglKlpaUhPT0de/bswd9//y0dR8ylS5fQuXNn9OzZEytXrkRUVJR0JNIBLn0kIp2zt7fHyJEjpWOQAYmKikJkZCQaNGgAS0tL3L17F6tWrYKHhwd69uwpHU+v+LvxodzcXCQlJQF4+8bcyEi5nyvXrVsX69atg62tLcaNG6fovUjjxo3D119/jWvXriEvLw8///wzli9fLh1LxJIlS7BlyxaMGjUKw4YNQ8+ePeHh4SEdi/5hLNSIiEjvdu3ahW3bthVoNZ6dnY2ePXsqrlCjD40dOxY9e/ZEQkICvLy8EBAQIB1JjJ+fH9LT02Fubo5Tp07ByclJOpKY+Ph4dO3aFTt37sTmzZvx3XffSUcSY2RkBGtra6hUKpibmyt6H2dhxkKNiIj0Tq1WIysrq0Ch9ubNG3Y9JABA48aNceTIESQlJWmX/inVy5cvERwcjKSkJLi4uODZs2faTn9Kk5OTg6NHj6JatWpISkpCenq6dCQxlSpVQkhICFJSUrB69WqUL19eOhLpAJuJEJFepKWlYc2aNYiPj0fr1q1Rs2ZNVK5cWToWCTl+/Djmz5+PypUro1ixYkhLS8OjR48wefJktG7dWjqeiKFDh8LDwwOtW7eGsbGxdBxRZ8+excaNG5GVlaW9Fh4eLphIzpAhQ9C/f3+sWLECs2fPxuTJkxXb9fHo0aM4ePAgpkyZgsjISDg5OSl2vFCr1YiKisKdO3fg6OgILy8vNhQphFioEZFejB49Gi1btkR0dDQmTJiA0NBQbNmyRToWCVKr1YiNjUVaWhqsrKxQtWpVmJgod6FHbGwsdu3ahbNnz6JFixbw8PBAlSpVpGOJ6Ny5MwICAlCuXDntNUdHR8FEcvr27Yvw8HDt//JQ9Hzx8fGwtbWVjiHC19cXnp6eaNmypaJnnAs75e7OJSK9SklJgbu7O0xMTFC/fn3k5eVJRyJBDx8+hJ+fH9asWYPSpUujZs2aMDExwcyZM6WjialatSomTZqEDRs2IC4uDp07d0b//v1x7do16Wh6Z2dnh+bNm8PR0VH7n1KZm5vj9OnTyMvLw2+//aboWZMlS5agadOmaNCgAerWrYv+/ftLRxIzfPhwnDx5Em5ubvjhhx/w/Plz6UikAyzUiEhvYmNjAQBxcXGKX9qldNOnT4enpyc6d+4MX19f/PXXXwCA+/fvCyeTc/LkSYwdOxb9+vVD7dq1cfLkScyfP1+RxWvp0qUxY8YMbN++HZGRkQXOmlOauXPnIjo6GsnJyVi/fj1mz54tHUnMiRMncOrUKXTp0gWHDh1C2bJlpSOJ+eyzzzBjxgyEh4fj/v37aN++vXQk0gHlrjEhIr2aOnUqAgICEBsbi9GjRyvyzScV1KJFCwBvN8WPGjUKa9euVfQSnn379qFnz55o0qRJgeujRo0SSiSnYsWKAIDExEThJPLKlSuHxYsXa+8fOnRI+/woTZkyZWBmZob09HRUrlwZOTk50pHEXL58GdHR0bh+/TpcXFzg7+8vHYl0gIUaEelFzZo1Ff2pOBVkYmKC48ePo1WrVnB0dMT06dMxdOhQqNVq6WhikpKSPijSAOCbb74RSCNr5MiROHfuHJ48eYLPP/8cDg4O0pEMxvr169GxY0fpGCLKlSuHnTt3okiRIggJCUFqaqp0JDGbNm2Cp6cnAgMDFf0BV2HHZiJEpBfOzs7aVtspKSkwMzODjY0NZs6cia+++ko6HunZixcvsHTpUkyePBnW1tYAgPPnzyMoKAh79+6VDSdk7Nix6Ny5MxwcHLQHPCu1QAkNDUVcXBxiY2PRp08fnD59GqGhodKxDEKPHj2wa9cu6Rgi8vLy8OLFC5QoUQK7d+9Gs2bNUK1aNelYIvLy8vDnn38W6IzaqFEjwUSkC5xRIyK9aNSoEUaOHAlHR0c8fvwYYWFh8PX1xcSJE1moKZCdnV2BIi0xMRE1atRQbJEGAK9evcKmTZu091UqlWJb0l+5cgURERHw8fFBt27dsG3bNulIBkOpsycPHjyAg4MDYmJikJqaCpVKBTs7O+lYYkaPHo1Xr15pnwOVSsVCrRBioUZEehEXF6ft3FapUiW8ePEClStXZlMRhbp48SL8/f2xZ88elChRArdu3cL06dMRHByMhg0bSscT8Z8t17Ozs4WSyMvNzUVWVhZUKhVyc3O1M4xK8m4P539KSUnRbxADsGPHDuzfvx+bN2/Gnj174Onpid9//x2rV6/GuHHjpOOJSExMxPbt26VjkI6xUCMivShTpgwWLVqEL7/8EteuXYONjQ3Onj0LU1NT6WgkYMmSJdi8eTNKlCgB4O2b0vXr12Pq1KnYunWrcDoZ27dvx4YNG6BWq6HRaGBqaoojR45IxxLx3XffoXv37khKSoKHhwe+++476Uh6d+bMGekIBmP//v1YvXo1AMDS0hLe3t7o1q0bevbsqdhCzcHBAS9fvlR050slYKFGRHqxcOFCREZG4tSpU6hRowZGjRqFv/76i/tOFMrY2PiDznXv781SooiICGzevBkrV66Ei4tLgWWQSuPi4oJmzZrh0aNHqFixIkqVKiUdiYQVKVIEALSNVMzNzWFlZSUZSdSVK1fQunXrAr8bLO4LHxZqRKQXxsbGqFevHmrXrg2NRoOff/4ZnTt3lo5FQjQaDfLy8goUZrm5uYput21rawtbW1ukp6ejSZMmCAsLk46kdzk5OdizZw88PDwwZ84cJCQkQKVSYe7cuahUqZJ0PBKSlZUFjUYDlUqFnj17Ang7hii5S+zRo0elI5AesFAjIr0YOXIkcnJyEB8fj9zcXNja2rJQUzBXV1f4+flh2LBhqFixIuLi4rBixQp06NBBOpqYYsWK4dixY1CpVNi+fbsi9yIFBwdri/fnz58jMDAQFy5cwIoVKzB//nzhdCSlZcuWWLRoEcaPHw8jIyNoNBosWbIErVq1ko6mdyEhIZ9sKOPn56fnNKRrLNSISC+Sk5MRGRmJqVOnYvr06ejfv790JBLk6ekJS0tLzJs3D/Hx8ahQoQJ69Oih2POhAOD777/H48eP4efnhw0bNmDatGnSkfTu1q1b2k6XJiYmcHR0hKOjI3bu3CmcTM7Zs2exYcOGAs1llNYNdPjw4Vi8eDHatWsHa2trpKSk4Ntvv8WYMWOko+ndu6ZcpAws1IhILywsLAAAmZmZsLCwUGyLacrXqVMndOrUqcC127dvo2bNmkKJZFlaWkKtVuPx48do27atdBwReXl52tvjx4/X3lbyXqSgoCAEBASgXLly0lHEGBsbY8KECRg3bhySk5NhbW0NExNlvoXt1q2bdATSI2W+yolI79q3b4/ly5ejVq1a8PT0RNGiRaUjkaBTp04hODgYJUqUQFBQEOzs7BAaGopDhw7hl19+kY4nYtSoUYo/F0mj0SAtLQ1WVlb44osvAABpaWnQaDSywQTZ2dmhefPm0jEMgrGxMWxsbKRjEOkNCzUi0ouqVauiSZMmUKlUaNWqFSpXriwdiQQtWrQIy5Ytw7NnzxASEoJXr16hfPnyij7wmuciAb169cKoUaPg7+8Pe3t7PH36FAsXLoSPj490NDGlS5fGjBkzUKdOHe1KBC8vL+FURKQPLNSISC9++OEHNG3aFAAUu7SN8hUvXhwODg5wcHDA1KlT4evrC09PT+lYongu0tvlsFZWVggJCcHTp09Rvnx59O7dG23atJGOJubdMRaJiYnCSciQ5ObmIjo6Gs+fP0fTpk1RvXp1HmNRCLFQIyK9UKlU8PX1LXBWFjtUKdf7bfnt7OwUX6QBPBfpnVatWimym9+njBw5Er/88gvu3r0LBwcHtGvXTjqSwZgzZw5mzJghHUPEjBkzYGtri3PnzqFevXrw9/fHmjVrpGPRP4yFGhHpRY8ePaQjkAHJzMzEw4cPkZeXh7y8PDx8+FC7D8nBwUE4nQyei0QfExISgkePHqF+/frYs2cPrly5An9/f+lYBqF3797SEcQ8fvwYgYGBuHLlCtq0aYPVq1dLRyIdYKFGRHrRpUsX7N69u8AyDVIuCwsLTJ8+HQBgbm6uva1SqRTXenzFihUYMWIE/Pz8PuiGGhISIpSKDMWlS5e0exf79eun+NnnEydO4MGDB6hevTqcnZ2l44jJzc1FUlISgLcNd95fpUCFBws1ItKLmTNncpkGaW3evFk6gsF4t//K29tbOInhUqvVim3HrlarkZeXpz3oWclHm8yePRvJycn48ssvERUVhXPnzil2dnHcuHHo2bMnEhIS4OXlhalTp0pHIh1g+U1EevH48WOMGTMGZmZmaNOmDV6/fi0diQR9//332tv79u3T3vb19ZWII+rWrVvYs2cPnj9//sF/9NbQoUOlI4jp2LEjevbsiXnz5qFXr16KPhT+1q1bWLJkCfr164dly5bh2rVr0pHEWFhY4MiRIzh27BgOHDig2A8yCjv+VIlIL94t01CpVFymQbh9+7b29s6dO+Hq6goASE1NlYokJjY2FgDw+++/w8LCAl9++SWuX78OtVoNNzc32XAGYt26ddIRxAwYMAAtWrTA/fv34e7ujho1akhHElO+fHnExcWhXLlySExMVOQh4JcvX8a9e/ewceNG9O/fH8Dbg+IjIiJw4MAB4XT0T2OhRkR6wWUa9CnvH2asxGVd48ePBwAMHDiwQEOAAQMGSEUSl5ycjB9//BEPHz5E9erVMWTIEBQrVkw6ll5FRUXBw8MDISEh2t+Lv/76C4DyOua2aNECAJCdnY2ff/4ZdnZ2ePnyJUqWLCmcTP+KFy+OxMREZGdnIyEhAcDbcXPixInCyUgXWKgRkV4UK1YMR44cQVJSEkqWLKnIN+SU7/2fP18LbyUlJSE1NRXFixdHcnIyUlJSpCOJ8ff3x9dffw03NzdcvnwZ/v7+WLFihXQsvXo3W+To6CicRJ4Sj6n4lBo1aqBGjRrw8PAocOZiTk6OYCrSFRZqRKQXS5YsQUpKCrp3747OnTujaNGi0pFI0JMnTxAaGgqNRlPg9tOnT6WjiRk+fDjc3NxgbW2N1NRUbSdMJcrKykKvXr0AALVq1cKRI0eEE+nfu46Gbm5uuH79OrKysoQTybt79y5mzpyJ1NRUuLq6onr16mjdurV0LBEnTpzAhg0boFarodFoYGpqqsjfk8KOhRoR6cWqVauQkJCAvXv3YsCAAahatSoCAwOlY5GQ0aNHf/T2qFGjJOIYhDdv3uDo0aNISkpC6dKlYWxsLB1J7x48eAAAKFmyJH766Sc0bNgQf/zxBypWrCicTM6oUaOQlJSknWFTqVRo1KiRcCoZ33//PYKCgjBt2jS4u7tj0KBBii3UIiIisHnzZqxcuRIuLi7YtGmTdCTSARZqRKQ3arUa2dnZyMvLU+SbUMrXrVs36QgGZ8eOHXB1dYWtra10FDEzZszQ3t66dSu2bt0KQNnLYxMTE7XnqBFQuXJlqFQqlCpVCpaWltJxxNja2sLW1hbp6elo0qQJwsLCpCORDrBQIyK96Nu3L7Kzs+Hu7o5ly5YVaMlORG8bJbi5ucHBwQEqlQoqlUpxB16/f77e69ev8ezZM9jb2yv6DbmDgwNevnxZYD+SUpUoUQLbt29HZmYmDh48iOLFi0tHElOsWDEcO3YMKpUK27dvV/Se1sJMpXm/3RYRkY7cvn0bWVlZ2LJlC86dO4f27dsX+PScSOkuXrz4wbXGjRsLJJF35MgRrFy5Erm5uXBxcYFKpcKIESOkY4lo3749nj59ilKlSmmvKbW5RlpaGlatWoU7d+6gatWqGDp0KKytraVjiUhLS8Pjx49RunRpbNiwAa1bt0aTJk2kY9E/jIUaEelUdnY2Dh48iIiICJiZmSEtLQ07duyAhYWFdDQyQNevX0e9evWkY4hIS0vD8uXLERsbiypVqmDEiBGKfRPq7e2N8PBwDBw4EOHh4ejRoweio6OlY5EQX19ftGzZEs7Ozihfvrx0HIOg0Wg+aDKj1L2LhRmXPhKRTrVp0wadO3fGokWLUKVKFQwaNIhFGn3S4cOHFVuoBQQEoFGjRnB1dcXFixcxefJkrFq1SjqWCGNjY5iZmWmXgBYpUkQ6kt6tWLECI0aMgJ+f3wd79JS2JLZfv364cOEC/P39kZaWhsaNG8PZ2RmNGzeGmZmZdDwRo0aNwqtXr2BnZwdA2U1mCjMWakSkU/369cP+/fvx7NkzuLu7g5P49F9R8qGtycnJ8PHxAQDUrl1b0a22GzRogPHjx+Ply5eYMWOGIov3Nm3aAHg7u6h0jRs31i4Dzs7OxqlTp7BixQqMGjUK165dE04ng01mlIGFGhHp1ODBgzF48GBcvHgRUVFR+PPPPxEcHIyuXbuiRo0a0vFI2Llz57TnAM2dOxdjxoxBly5dpGOJyMrKQkJCAsqUKYPExETk5eVJRxLj5+eHU6dOoXbt2nB0dNQWLUpSq1YtAEDVqlWxcuVKPHz4ENWrV8ewYcOEk+lfXl4erl69ihMnTuDXX3+FlZUVvv76a0Xvc2aTGWXgHjUi0qvU1FTs3bsXu3btwp49e6TjkDAPDw+EhIRg9uzZmD9/PsaOHYuIiAjpWCLOnj2LGTNmwMrKCunp6Zg7dy6aNWsmHUuvWrZsiUaNGsHZ2RktWrSAjY2NdCRxPj4+6NixI7788ktcuXIFp06dwo8//igdS6+aNGmCpk2bolOnTmjevDmsrKykI4n79ttv8eTJE5QsWVK7NFapTWYKM86oEZFeFS9eHD4+PtolXqRsFhYWKF26NExMTFCmTBlFn5f11VdfISYmBklJSQU6/CnJsWPHcO3aNVy8eBHjxo1DTk6Odj+Skvff9OzZE8DbWbbDhw8Lp9G/AQMG4MyZM9i8eTNiY2PRqlUr1KlTRzqWKCUvjVYSzqgREZGYYcOG4e+//4aXlxfS09Nx4cIFLFu2TDqWiJiYGGzduhU5OTnQaDRISUnB/v37pWOJSUpKwsWLFxEeHo779+/j/Pnz0pFEzJw5Ew0aNECTJk1w48YN7N69G35+fgDeLn9TktevX+PMmTM4ffo07t69i2rVqiEoKEg6lojbt28jICAAL1++hI2NDebNm6f44rUwYqFGRERisrOz8fjxY1SrVg137txB+fLlFbusqUuXLpgzZw62b9+OJk2a4Ny5c1i0aJF0LL36888/cfLkSZw6dQoA0KJFCzg7O8PJyQlGRkbC6WR8avWBSqVCeHi4ntPIunXrFi5fvozLly8jPj4eDg4OCAwMlI4lwsfHB1OnTkWtWrVw8+ZNzJ49m81FCiEufSQiIjGbNm3C4MGDAbw9F8jHxwe7d+8WTiXD1tYWX375JbZv347u3bsr8nnw8PBAhw4dEBISgooVK0rHMQjr1q1DYmIibGxsFNuKfsiQIbhz5w5q166Nr776CqNGjULVqlWlY4l713Cmdu3aMDHhW/rCiD9VIiISc/fuXWzbtg0ZGRnYs2cPZs2aJR1JjKmpKS5dugS1Wo3Tp08jOTlZOpLebd26FadOncKECRNgaWkJZ2dnODs7K/JNeU5ODoKCgnDq1CnY2NggPj4eX3/9NaZMmQJTU1PpeHo1ZMgQfPHFFyxG3mNkZIQTJ06gYcOGuHTpkmKL+MKOSx+JiEhMXl4eJkyYgKSkJKxevVrRbzZevnyJ+/fvo0yZMli6dClcXFzQqVMn6VhiXr16hdOnTyMqKgpxcXGIiYmRjqRXS5YsgampKXx9fQEAubm5WL58ObKzszFhwgThdCTt2bNnWLBgAe7fv4+qVati0qRJqFChgnQs+oexUCMiIr3z8vLSdnjMycnB7du38dlnnwGAYvdZjB8/HiEhIdIxRGk0Gty8eVO7D+nhw4eoWbMmvvrqK7i5uUnH06uePXti27ZtH1z39PTEjh07BBKRIVCr1TAxMUF2dvYHjyn5g67CinPIRESkd6GhodIRDE52djZu3boFBwcHbRGrtDdezs7OqF27Npo3bw5fX1/UrFlTOpKYTy1vVPLyv6ioKHh4eGjvh4eHo2/fvoKJ9M/f3x8hISFwcXHRjhMajQYqlUpxs85KoNzfdiIiEvNuic6LFy9w4MABZGVlaR8bOXKkVCxRDx8+xIgRI7T3lfjG6/jx44orTj/F3Nwcjx8/RqVKlbTXHj9+DAsLC8FUMg4cOIDjx4/jwoUL2mMacnNzcffuXcUVau9m3Y8fP669lpubC2NjY6lIpEMs1IiISMyYMWPQrFkz2NnZSUcRFxgYCCcnJ+39CxcuCKaRwSIt3/jx4zF8+HC4u7vD3t4eT58+RVRUFBYuXCgdTe+cnZ1RpkwZpKSkwMvLC8DbZhr29vbCyeTs27cPxsbGyM7ORnBwMAYOHIiBAwdKx6J/GPeoERGRmP79+2PDhg3SMURdvnwZ9+7dw8aNG9G/f38Ab5usRERE4MCBA8LpSNKrV6+wd+9ePHnyBGXLlkW3bt1QtmxZ6Vii4uPjoVarodFoEB8fjy+//FI6kgh3d3esWbMGfn5++PHHHzFgwABs2bJFOhb9wzijRkREYqpXr46DBw+idu3a2v0WDg4Owqn0q3jx4khMTER2djYSEhIAvF32OHHiROFkcubMmYMZM2Zo70+aNEmRM0mlS5fGgAEDpGMYjICAAPz222/IzMxEZmYmKlWqpNjGKu+WwFpaWsLMzAxqtVo4EekCCzUiIhJz8+ZN3Lx5U3tfpVIhPDxcMJH+1ahRAzVq1ECPHj0KLAG9ceOGYCoZERERWLlyJVJSUnD06FEAbxslVKtWTTgZGYJbt27h4MGDmDFjBsaNG4cxY8ZIRxJjb28PLy8vTJkyBWFhYYpuvFOYsVAjIiIxmzdvlo5gMAYPHozJkyejRYsWWL9+Pfbt24c9e/ZIx9Kr3r17o3fv3li1ahWGDRsmHYcMTMmSJaFSqZCRkYFSpUpJxxEVFBSE9PR0WFpaol69erCxsZGORDrAPWpERCSmTZs22iWPAFCsWDHFFSfvJCYmYtKkSUhKSkLDhg0xadIkxTbXSElJwZkzZwrsRRo6dKh0LBHdu3eHq6sr3NzcYG1tLR1HVGhoKEqUKIHExETExcVpG6wo0blz57S/H3PnzsWYMWPQpUsX6Vj0D+OMGhERiTl8+DCAt8vb/vzzT+19Jbp9+zYSEhJQv3593Lx5E3FxcQVasyvJyJEj4ejoiDt37sDc3BxFihSRjiRm48aN2L9/P4YNGwY7Ozt4eHigefPm0rFE+Pn5IT09Hebm5jh16lSBLqlKs3jxYoSEhGD27NnYtm0bxo4dy0KtEDKSDkBERMplZmYGMzMzmJubo0GDBvjrr7+kI4n54Ycf8OOPP2L27NmYOHEifH19pSOJ0Wg0mDNnDhwcHLBhwwakpKRIRxJTvHhx9O7dG4GBgTAyMsL48ePh4eGBn3/+WTqa3r18+RIzZ87EkCFDkJiYiGfPnklHEmNhYYHSpUvDxMQEZcqUKbAygQoPzqgREZGYkJAQ7RuM+Ph4GBkp9/PDiIgI7aG1X3zxBbZt2yacSI6xsTGysrKQmZkJlUqF3Nxc6UhiIiIisHfvXlhZWcHd3R3z58+HWq2Gp6cnvvnmG+l4ejV9+nT0798fK1asQMOGDTF58mTFdn20srLCoEGD4OXlhYiICMXv2SusWKgREZEYR0dH7e1atWrB2dlZMI2MsWPHYsmSJTA2Nsb69eu17dhHjBihuA6Y7/Tu3RsbN27EV199hVatWqFBgwbSkcTEx8cjNDQUFStW1F4zNTXFnDlzBFPJePPmDZo1a4aVK1fC0dER5ubm0pHELF26FI8fP0a1atVw584deHh4SEciHWChRkREYlxcXBAZGYkHDx6gevXq2rOBlOTVq1fa27/88ou2UFNyr69vv/0WwNumIh06dICVlZVwIjmDBw/GmjVrEB8fj9atW6NmzZqoXLmyIg96Njc3x+nTp5GXl4fffvtNsc12AODFixeIiYnR7uuNj49XZPFe2Cl3jQkREYkbP348EhMT4ezsjOfPn2PKlCnSkUS9X5wpec/JpUuX0LlzZ/Ts2RPr1q1TbGc/4O0hz/b29nj06BFsbGwwdepU6Uhi5s6di+joaCQnJ2P9+vWYNWuWdCQx48ePBwBcvXoVT58+VfQ+zsKMhRoREYlJSUnBhAkT0K5dO0yaNAnPnz+XjqR37xdkSi7O3rdkyRJs2bIFNjY2GDZsmKL366WkpMDd3R0mJiaoX78+8vLypCOJ2bhxIxYvXoyDBw9i2bJlsLe3l44kpmjRohg6dCjKli2L+fPnIzExUToS6QCXPhIRkZhq1arhypUraNCgAW7fvo3y5csjJycHGo1GMcua7t27h/Hjx0Oj0RS4HRsbKx1NjJGREaytraFSqWBubg5LS0vpSKLevRbi4uK0DWeU6N69e0hNTUXx4sWlo4hTqVRISEhAeno6MjIykJGRIR2JdIAHXhMRkZhOnTohMzMTpqamyMnJ0V5XqVSIiYkRTKY/Fy9e/ORjjRs31mMSwzF16lSUKlUKJ0+eROfOnREbG4sFCxZIxxJx584dTJ8+HbGxsXB0dMSsWbNQp04d6VgiWrdujbi4OJQqVUo7+3zmzBnhVDIuXbqEu3fvomzZspg+fTq6du0Kf39/6Vj0D2OhRkREYvbu3YuuXbtKxyADk52djV27duHOnTtwdHSEl5eXYmZY34mLi0O5cuU+uH7x4kXFFvD0VlpaGoyNjRV9ELxScI8aERGJUXKTCPq0YcOGoWfPnpg5cyZ8fHwUV6QBb7s9JiUlFbi2YsUKTJo0SSiRnJycHO1YMX78ePTt2xf9+vXDkydPhJPp35YtW+Dq6oquXbvi9OnT0nFIx7hHjYiIxGRnZ8PNzQ0ODg7aw65DQkKEU5G04sWLIyYmBlWqVNG+LhwcHIRT6Zevry8GDx6MTZs2IScnBxMmTICZmRmio6Olo+ldcHCw9nXw/PlzBAYG4sKFC1i+fDnmz58vnE6/Dhw4gMOHDyMtLQ2TJk1S5NmTSsJCjYiIxEyYMEE6AhmgV69eYePGjdr7KpVKcYd/u7i4QK1Wo3///khNTUXfvn3Ru3dv6Vgibt26pf35m5iYwNHREY6Ojti5c6dwMv0zMzODmZkZSpUqVWBfLxVOLNSIiEhMnTp1PjjMl2jz5s3SEQxC586dkZubi6ioKHh4eEjHEfP+kQTvzg8DoOiD0IGC5y5S4cRCjYiIxAQEBKBly5a4dOmS9jDfLVu2SMciIS9fvsSiRYsQHByM9u3ba9uOr1y5Ek2aNJGOp1d+fn5QqVTQaDR4/PgxevXqhcqVKwNQ3vJgjUaDtLQ0WFlZ4YsvvgDwtqGGEguVjx3n8Y7SXhdKwEKNiIjEvDvMd9++fYo/zJeAwMBAuLq6AgDKli2LzZs3488//8TixYsVV6h5e3t/9LYS9erVC6NGjYK/vz/s7e3x9OlTLFy4ED4+PtLR9G7JkiXa20p/XSgBCzUiIhLFw3zpnb///hvt2rUrcO2zzz5DWlqaUCI5bMGfr1OnTrCyskJISAiePn2K8uXLo3fv3mjTpo10NL3j60JZWKgREZGYadOmISAgALGxsRg9ejRmzpwpHYkEZWdna2+vXbtWe9vc3FwiDhmQVq1aoVWrVtIxiPSKhRoREYmpUaMGVq5ciWfPnqFy5cooXry4dCQSVKxYMTx8+BBVqlTRFmePHj1C0aJFhZMREemfSqPEnZhERGQQdu7cibVr16JatWqIjY3FqFGj0LFjR+lYJOSvv/7CxIkT4eHhgcqVK+PJkyeIiorCokWL2BGUiBSHhRoREYlxd3dHREQEzM3NkZGRgX79+iEqKko6FglKSEjAnj178PTpU9jZ2cHNzQ3lypWTjkUG4tdff8Xjx4/x+eefw8HBgctiqVDj0kciIhJjbW0NE5O3/xRZWFhw6SOhTJkyGDx4sHQMMkChoaGIi4tDbGwszMzMsHr1aoSGhkrHItIZFmpERKR3786ISkpKQvfu3fH555/jr7/+goWFhXQ0IjJQV65cQUREBHx8fNCtWzds27ZNOhKRTrFQIyIivXt3/s+7A30BoHPnzpKRiMjA5ebmIisrCyqVCrm5uTAyMpKORKRT3KNGRERiunfvDldXV7i5ucHa2lo6DhmItLQ0rFmzBvHx8WjdujVq1qyJypUrS8ciYT/99BPCwsKQlJQEOzs7fPfdd9oD0okKIxZqREQkJjU1Ffv378f+/fthZ2cHDw8PNG/eXDoWCRs9ejRatmyJ6OhoTJgwAaGhodiyZYt0LDIAf//9Nx49egR7e3uULFlSOg6RTnHpIxERiSlevDh69+6Npk2bYsWKFRg/fjwqVqyIIUOG4JtvvpGOR0JSUlLg7u6Offv2oX79+sjLy5OORAbgl19+wbZt25CZmam9Fh4eLpiISLdYqBERkZiIiAjs3bsXVlZWcHd3x/z586FWq+Hp6clCTeFiY2MBAHFxcTA2NhZOQ4Zg6dKlmDJlCmxsbKSjEOkFCzUiIhITHx+PkJAQ2Nvba6+Zmppizpw5gqlI2rRp0xAQEIDY2FiMHj0aM2fOlI5EBqBEiRJo3LixdAwiveEeNSIiEhEZGYkePXrAxMQEly9fxt27d9GzZ0/pWERkYCIjIwEAx44dQ7ly5VC3bl2oVCoAgJeXl2Q0Ip3ijBoREendDz/8gLt378LV1RUmJiYoV64cNm7ciKSkJPj6+krHI2FhYWGIiIgosOTxzJkzgolIUkJCAgDg888/BwAkJiZKxiHSG86oERGR3nl4eGDHjh3aT8UBICcnB97e3ti1a5dgMjIEPXr0QEREBA9ApwJWrFiBESNGaO+HhIRg/PjxgomIdIszakREpHdFixYtUKQBb/emWVpaCiUiQ1K6dGmYmPAtCr0VFRWFnTt3IjY2FqdOnQIA5OXlIScnh4UaFWocBYmISO8sLCzw5MmTAk1Enjx58kHxRsri5+cHlUqFxMREdOvWDdWrV9e+JkJCQoTTkZSuXbuiWbNm+PHHHzFs2DAAgJGREUqXLi2cjEi3uPSRiIj07u7du/Dz80OzZs1gb2+P58+f48yZM1iwYAHq1KkjHY+EXLx48ZOPsdsfESkNCzUiIhLx+vVrxMTEID4+HuXLl8fXX38NKysr6VgkKDc3F7m5ufDz88PixYuh0WiQl5eHIUOG8GBjIlIcFmpERERkEHbs2IFVq1YhMTERZcqUAfB2iVuDBg0wf/584XQk5aeffkKHDh3w7NkzVKhQQToOkd6wUCMiIiKDsnPnTri7u0vHIAPRqVMnLFmyBFOnTsXChQvx/ltXBwcHwWREusVCjYiIiIgM1pYtW/Dzzz/jr7/+Qq1atbTXVSoVl8RSocZCjYiIiIgM3o4dO+Dp6Skdg0hvjKQDEBEREQHA4sWLAQDHjh0TTkKGyMnJCT169ECLFi3g5uaGv/76SzoSkU7xHDUiIiIyCD/99BNsbW2xefNmvHr1qsBjXl5eQqnIUAQGBiIwMBC1atXCzZs3MXv2bGzfvl06FpHOsFAjIiIig7Bo0SKcPn0a2dnZSEhIkI5DBkaj0Wj3qNWuXRsmJnwbS4UbX+FERERkEJycnODk5ARnZ2dUqlQJjx8/RsWKFVGqVCnpaGQAjI2NceLECTRs2BCXLl2CmZmZdCQinWIzESIiIjIohw4dwtKlS1G1alXcvXsXI0eORNeuXaVjkbBnz55hwYIFuH//PqpWrYpJkybxXDUq1FioERERkUHx8vLC+vXrYWlpibS0NPTr1w+7du2SjkVEpFfs+khEREQGRaVSwdLSEgBgZWUFc3Nz4URERPrHPWpERERkUOzt7TF//nw0bNgQly9fRqVKlaQjERHpHZc+EhERkUFRq9WIjIxEbGwsqlatCk9PT5iamkrHImEZGRlITU2FiYkJIiMj4ebmxj1qVKixUCMiIiIigzdo0CB4e3vj6NGjqFatGi5cuIB169ZJxyLSGe5RIyIiIiKD9+bNG7Rt2xZxcXEYMmQIcnNzpSMR6RQLNSIiIiIyeDk5Odi0aRPq1q2Le/fuITMzUzoSkU6xUCMiIiKDcuvWLVy7dg2///47+vXrh19//VU6EhkAf39/xMfHY/jw4Th//jymTp0qHYlIp1ioERERkUGZNWsWzMzMsHLlSowbNw5hYWHSkcgAREREYNKkSShevDj69OkDJycn6UhEOsVCjYiIiAyKmZkZqlevjpycHHzxxRcwMuLbFQKys7Nx69YtZGVlITs7G9nZ2dKRiHSK56gRERGRQVGpVJg0aRJatmyJQ4cOsTU/AQAePnyIESNGaO+rVCrExMQIJiLSLbbnJyIiIoOSlJSE69evo1WrVjh//jxq1aoFa2tr6VhkIJKTk2FtbQ2VSiUdhUinOKNGREREBsXMzAxXr17F4cOH0bp1a/z9998s1AiXLl3C7NmzkZubCxcXF5QvXx4eHh7SsYh0hou+iYiIyKAEBATA3t4ejx49go2NDbv7EQBgyZIl2LJlC2xsbDBs2DBs27ZNOhKRTrFQIyIiIoOSkpICd3d3mJiYoH79+sjLy5OORAbAyMhIu+TR3NwclpaW0pGIdIqFGhERERmc2NhYAEBcXByMjY2F05AhqFSpEkJCQpCSkoLVq1ejfPny0pGIdIrNRIiIiMig3LlzB9OnT0dsbCwcHR0xc+ZM1K1bVzoWCVOr1YiKisKdO3fg6OgIb29vdgSlQo2FGhERERmc5ORkPHnyBBUrVkSpUqWk45ABmDNnDmbMmKG9P2nSJCxcuFAwEZFusesjERERGZRDhw5h6dKlqFq1Ku7evYuRI0eia9eu0rFISEREBFauXImUlBQcPXoUAKDRaFCtWjXhZES6xRk1IiIiMiheXl5Yv349LC0tkZaWhn79+mHXrl3SsUjYqlWrMGzYMOkYRHrDZiJERERkUFQqlbajn5WVFczNzYUTkSHo1q0b7t27hwcPHiAgIAC3bt2SjkSkUyzUiIiIyKDY29tj/vz5OHbsGObPn49KlSpJRyIDMH78eCQmJmLx4sX46quvEBgYKB2JSKdYqBEREZFBCQwMhL29Pc6dOwd7e3vMnTtXOhIZAJVKhUaNGiE1NRWdOnWCkRHfxlLhxmYiREREZFCGDRuG9evXS8cgA6NWqxEcHIyGDRvi/PnzyMnJkY5EpFP8KIKIiIgMSvHixRETE4PY2Fg8ePAADx48kI5EBiAoKAj29vYYMmQIkpKSsGDBAulIRDrFro9ERERkUHx8fArcV6lUCA8PF0pDhkKtVuP69etQq9XQaDSIj49H586dpWMR6QwLNSIiIjI4r1+/xrNnz2Bvb6/tAEnKNmzYMOTk5CA+Ph65ubmwtbXFxo0bpWMR6QyXPhIREZFBOXLkCHx8fDBx4kRs3LgRK1askI5EBiA5ORnr1q2Dk5MToqOjkZWVJR2JSKdYqBEREZFB2bBhA3bs2AFra2uMGDECx44dk45EBsDCwgIAkJmZCQsLC6hUKuFERLrFQo2IiIgMirGxMczMzKBSqaBSqVCkSBHpSGQA2rdvj7CwMNSqVQuenp4wMzOTjkSkU9yjRkRERAYlNDQUT58+xY0bN9CkSRMULVoUkydPlo5FBuT27duoUqUKzM3NpaMQ6QwLNSIiIjI4p06dwp07d1C1alW0bt1aOg4JmjJlyicfCwoK0mMSIv1ioUZEREQGYc+ePZ98zM3NTW85yLB06dIFb968gaurK7788ku8/9bV2dlZMBmRbplIByAiIiICgNjYWO3tgwcPonPnztBoNGwaoXD79+/HnTt3sG/fPqxevRqNGjWCq6srKleuLB2NSKc4o0ZEREQGx8fHB5s3b5aOQQbo0qVL2Lx5M+Li4rBjxw7pOEQ6wxk1IiIiMjicRaP/lJaWhp9//hkHDhxAZmYmXF1dpSMR6RQLNSIiIiIyWIcOHcKhQ4fw/PlztG/fHrNnz0bFihWlYxHpHJc+EhERkUHw8/ODSqWCRqPB+fPn0axZM+1jISEhgslIUq1ateDo6IhatWoBKDjbytcFFWYs1IiIiMggXLx48ZOPNW7cWI9JyJDwdUFKxUKNiIiIiIjIwBhJByAiIiIiIqKCWKgREREREREZGBZqREREREREBoaFGhERERERkYFhoUZERERERGRg/j9a9ZRllfNXLwAAAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "heatmap_from_df(final_distribution_df,\n",
    "                title='Distribution of Gift Participants by Audiences\\n',\n",
    "                fig_size=12)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}