Economic_Financial_Index.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/C00ldudeNoonan/financial-conditions-index/blob/main/Economic_Financial_Index.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import requests\n",
        "import pandas as pd\n",
        "import requests\n",
        "from datetime import datetime\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "import json\n",
        "import matplotlib.dates as mdates\n",
        "import matplotlib.font_manager as fm\n",
        "\n",
        "pd.set_option('display.max_columns', None)\n",
        "\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "\n",
        "import gspread\n",
        "from google.auth import default\n",
        "creds, _ = default()\n",
        "\n",
        "gc = gspread.authorize(creds)\n",
        "\n",
        "\n",
        "from google.colab import userdata\n",
        "apiKey = userdata.get('fredKey')\n"
      ],
      "metadata": {
        "id": "UGeSNv5_iE1c"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "spreadsheetId = '1k8qnFgKx3xk4CCp55m1zPrZaiulSBHRpE9_BlfeCy2M'\n",
        "\n",
        "\n",
        "url = 'https://github.com/C00ldudeNoonan/financial-conditions-index/raw/main/EBGaramond-Medium.ttf'\n",
        "response = requests.get(url)\n",
        "\n",
        "with open('EBGaramond-Medium.ttf', 'wb') as f:\n",
        "    f.write(response.content)\n",
        "\n",
        "\n",
        "fm.fontManager.addfont('EBGaramond-Medium.ttf')"
      ],
      "metadata": {
        "id": "iRoGA3iTqFeI"
      },
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cIcdvOYVJcm2",
        "outputId": "aeec6470-b2c8-42e0-d6db-7c1f7c5fa1a8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "    period       FFR      10yr  mortgage   tripleb    equity   housing  dollar\n",
            "0        4  0.099944 -0.008149  0.217428  0.079268 -0.021319 -0.032228   0.048\n",
            "1        5  0.068579 -0.014000  0.145249  0.091179 -0.020216 -0.031274   0.048\n",
            "2        6  0.050929 -0.018387  0.119053  0.098644 -0.018436 -0.029702   0.045\n",
            "3        7  0.030389 -0.021524  0.077495  0.100473 -0.016158 -0.026759   0.039\n",
            "4        8  0.025688 -0.023217  0.062434  0.100648 -0.014444 -0.019780   0.031\n",
            "5        9  0.020009 -0.024366  0.045143  0.099580 -0.013024 -0.013424   0.023\n",
            "6       10  0.015812 -0.025224  0.033697  0.097661 -0.011753 -0.006052   0.017\n",
            "7       11  0.011352 -0.025907  0.024835  0.095353 -0.010661  0.000769   0.012\n",
            "8       12  0.007393 -0.026403  0.018457  0.092766 -0.009704  0.004236   0.008\n",
            "9       13  0.003964 -0.026700  0.013733  0.090084 -0.008866  0.006672   0.005\n",
            "10      14  0.001711 -0.020122  0.008658  0.066539 -0.006343  0.007861   0.002\n",
            "11      15  0.000393 -0.013446  0.004899  0.043675 -0.004042  0.008861   0.000\n",
            "12      16  0.000129 -0.006723  0.002102  0.021504 -0.001937  0.009192   0.000\n",
            "2609\n",
            "dow min date 2014-04-30 00:00:00\n",
            "zillow max date 2000-01-31 00:00:00\n",
            "dollar min date 2006-01-31 00:00:00\n",
            "bond min date 1996-12-31 00:00:00\n",
            "mortgage min date 1971-04-30 00:00:00\n",
            "10 year min date 1962-01-31 00:00:00\n",
            "fed funds min date 1971-04-30 00:00:00\n",
            "equities\n",
            "bond\n",
            "zillow\n",
            "dollar\n",
            "10yr\n",
            "fed funds\n",
            "Index(['date', 'equity', 'tripleb', 'mortgage', 'housing', 'dollar', '10yr',\n",
            "       'FFR'],\n",
            "      dtype='object')\n",
            "          date     equity   tripleb  mortgage   housing    dollar      10yr  \\\n",
            "113 2023-10-31  -7.309979 -0.257998  0.240000  1.085096  1.014923  0.710283   \n",
            "114 2023-11-30   3.478294  0.051236  0.142308  0.802177  1.119585  0.613374   \n",
            "115 2023-12-31  11.761331  0.066695 -0.118462  0.572598  0.504598  0.297414   \n",
            "116 2024-01-31  14.342522 -0.367084 -0.300769  0.431895  0.000000 -0.273742   \n",
            "117 2024-02-29   8.131524 -0.592669 -0.256154  0.469999  0.000000 -0.476680   \n",
            "\n",
            "          FFR  equity_score  tripleb_score  mortgage_score  housing_score  \\\n",
            "113  0.616154     -0.058025      -0.235962        0.084038      -0.200740   \n",
            "114  0.537692     -0.083775      -0.211040        0.084609      -0.179130   \n",
            "115  0.263846     -0.295179      -0.175655        0.045400      -0.143924   \n",
            "116 -0.276923     -0.560600      -0.181353       -0.011435      -0.102329   \n",
            "117 -0.675385     -0.676086      -0.222645       -0.047335      -0.064522   \n",
            "\n",
            "     dollar_score  10yr_score  FFR_score       FCI  \n",
            "113      0.026847   -0.037205   0.091649 -0.329398  \n",
            "114      0.080459   -0.040717   0.102929 -0.246665  \n",
            "115      0.099119   -0.047365   0.092617 -0.424987  \n",
            "116      0.086656   -0.050299   0.048519 -0.770842  \n",
            "117      0.069468   -0.049164  -0.010187 -1.000471  \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/pandas/core/arraylike.py:396: RuntimeWarning: invalid value encountered in log\n",
            "  result = getattr(ufunc, method)(*inputs, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "def fetchData(apiKey):\n",
        "\n",
        "    url = f\"https://api.stlouisfed.org/fred/series/observations?series_id=BAMLH0A0HYM2&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(url)\n",
        "    bondData = response.json()\n",
        "\n",
        "    bondDf = pd.DataFrame(bondData['observations'])\n",
        "    bondDf['series'] = 'High Yeild Bond Rate'\n",
        "    bondDf = bondDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    bondDf['date'] = pd.to_datetime(bondDf['date'])\n",
        "    bondDf['value'] = pd.to_numeric(bondDf['value'], errors='coerce')\n",
        "    bondDf.set_index('date', inplace=True)\n",
        "    bondDf.sort_index(inplace=True)\n",
        "    bondDf['90_day_avg'] = bondDf['value'].rolling('90D', min_periods=1).mean()\n",
        "    bondDf.reset_index(drop=False, inplace=True)\n",
        "    bondDf['month'] = bondDf['date'].dt.month\n",
        "    bondDf['day'] = bondDf['date'].dt.day\n",
        "    bondDf['year'] = bondDf['date'].dt.year\n",
        "    bondDf = bondDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    bondDf.reset_index(drop=True, inplace=True)\n",
        "    bondDf.drop(columns=['value', 'month', 'day', 'year'], inplace=True)\n",
        "    bondDf['diff'] = bondDf['90_day_avg'] - bondDf['90_day_avg'].shift(3)\n",
        "    bondDf['date'] = bondDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "    # Reset index to make 'date' and 'series' columns\n",
        "    bondDf.reset_index(inplace=True)\n",
        "\n",
        "    dowUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=DJIA&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(dowUrl)\n",
        "    dowData = response.json()\n",
        "\n",
        "    dowDf = pd.DataFrame(dowData['observations'])\n",
        "    dowDf['series'] = 'Dow Jones Industrial Average'\n",
        "    dowDf = dowDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    dowDf = pd.DataFrame(dowDf)\n",
        "    dowDf['date'] = pd.to_datetime(dowDf['date'])\n",
        "    print(len(dowDf))\n",
        "    # Compute log levels\n",
        "    dowDf['value'] = pd.to_numeric(dowDf['value'], errors='coerce')\n",
        "    dowDf.dropna(subset=['value'], inplace=True)\n",
        "    dowDf['month'] = dowDf['date'].dt.month\n",
        "    dowDf['day'] = dowDf['date'].dt.day\n",
        "    dowDf['year'] = dowDf['date'].dt.year\n",
        "    dowDf['log_price'] = np.log(dowDf['value'])\n",
        "    # print(spyDf[(spyDf['month']==3) & (spyDf['year']==2024)])\n",
        "    dowDf = dowDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    dowDf.reset_index(drop=True, inplace=True)\n",
        "\n",
        "    dowDf['log_diff_90'] = (np.log(dowDf['value'])-np.log(dowDf['value'].shift(3)))*100\n",
        "    dowDf['date'] = dowDf['date'] + pd.offsets.MonthEnd(0)\n",
        "    # feds fund rate\n",
        "\n",
        "    fedsFundUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=MORTGAGE30US&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(fedsFundUrl)\n",
        "    fedsFundData = response.json()\n",
        "\n",
        "    fedsFundDf = pd.DataFrame(fedsFundData['observations'])\n",
        "    fedsFundDf['series'] = 'Fed Funds Rate'\n",
        "    fedsFundDf = fedsFundDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    fedsFundDf['date'] = pd.to_datetime(fedsFundDf['date'])\n",
        "    fedsFundDf['value'] = pd.to_numeric(fedsFundDf['value'], errors='coerce')\n",
        "    fedsFundDf.set_index('date', inplace=True)\n",
        "    fedsFundDf.sort_index(inplace=True)\n",
        "    fedsFundDf['90_day_avg'] = fedsFundDf['value'].rolling('90D', min_periods=1).mean()\n",
        "    fedsFundDf.reset_index(drop=False, inplace=True)\n",
        "    fedsFundDf['month'] = fedsFundDf['date'].dt.month\n",
        "    fedsFundDf['day'] = fedsFundDf['date'].dt.day\n",
        "    fedsFundDf['year'] = fedsFundDf['date'].dt.year\n",
        "    fedsFundDf = fedsFundDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    fedsFundDf.reset_index(drop=True, inplace=True)\n",
        "    fedsFundDf.drop(columns=['value', 'month', 'day', 'year'], inplace=True)\n",
        "    fedsFundDf['date'] = fedsFundDf['date'] + pd.offsets.MonthEnd(0)\n",
        "    fedsFundDf['diff'] = fedsFundDf['90_day_avg'] - fedsFundDf['90_day_avg'].shift(3)\n",
        "    fedsFundDf['date'] = fedsFundDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "    # ten year yield\n",
        "    tenYearUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=DGS10&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(tenYearUrl)\n",
        "    tenYearData = response.json()\n",
        "\n",
        "    tenYearDf = pd.DataFrame(tenYearData['observations'])\n",
        "    tenYearDf['series'] = '10 Year Treasury Yeild'\n",
        "    tenYearDf = tenYearDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    tenYearDf['date'] = pd.to_datetime(tenYearDf['date'])\n",
        "    tenYearDf['value'] = pd.to_numeric(tenYearDf['value'], errors='coerce')\n",
        "    tenYearDf.set_index('date', inplace=True)\n",
        "    tenYearDf.sort_index(inplace=True)\n",
        "    tenYearDf['90_day_avg'] = tenYearDf['value'].rolling('90D', min_periods=1).mean()\n",
        "    tenYearDf.reset_index(drop=False, inplace=True)\n",
        "    tenYearDf['month'] = tenYearDf['date'].dt.month\n",
        "    tenYearDf['day'] = tenYearDf['date'].dt.day\n",
        "    tenYearDf['year'] = tenYearDf['date'].dt.year\n",
        "    tenYearDf = tenYearDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    tenYearDf.reset_index(drop=True, inplace=True)\n",
        "    tenYearDf.drop(columns=['value', 'month', 'day', 'year'], inplace=True)\n",
        "    tenYearDf['date'] = tenYearDf['date'] + pd.offsets.MonthEnd(0)\n",
        "    tenYearDf['diff'] = tenYearDf['90_day_avg'] - tenYearDf['90_day_avg'].shift(3)\n",
        "    tenYearDf['date'] = tenYearDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "\n",
        "    # mortgage rates\n",
        "    mortgageUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=MORTGAGE30US&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(mortgageUrl)\n",
        "    mortgageData = response.json()\n",
        "\n",
        "    mortgageDf = pd.DataFrame(mortgageData['observations'])\n",
        "    mortgageDf['series'] = '30 year Mortgage Rate'\n",
        "    mortgageDf = mortgageDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    mortgageDf['date'] = pd.to_datetime(mortgageDf['date'])\n",
        "    # Convert 'date' column to last day of the month\n",
        "    mortgageDf['value'] = pd.to_numeric(mortgageDf['value'], errors='coerce')\n",
        "    mortgageDf.set_index('date', inplace=True)\n",
        "    mortgageDf.sort_index(inplace=True)\n",
        "    mortgageDf['90_day_avg'] = mortgageDf['value'].rolling('90D', min_periods=1).mean()\n",
        "    mortgageDf.reset_index(drop=False, inplace=True)\n",
        "    mortgageDf['month'] = mortgageDf['date'].dt.month\n",
        "    mortgageDf['day'] = mortgageDf['date'].dt.day\n",
        "    mortgageDf['year'] = mortgageDf['date'].dt.year\n",
        "    mortgageDf = mortgageDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    mortgageDf.reset_index(drop=True, inplace=True)\n",
        "    mortgageDf.drop(columns=['value', 'month', 'day', 'year'], inplace=True)\n",
        "    mortgageDf['date'] = mortgageDf['date'] + pd.offsets.MonthEnd(0)\n",
        "    mortgageDf['diff'] = mortgageDf['90_day_avg'] - mortgageDf['90_day_avg'].shift()\n",
        "    mortgageDf['date'] = mortgageDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "    # zillow index\n",
        "\n",
        "    zillowUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=USAUCSFRCONDOSMSAMID&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(zillowUrl)\n",
        "    zillowData = response.json()\n",
        "\n",
        "    zillowDf = pd.DataFrame(zillowData['observations'])\n",
        "    zillowDf['series'] = 'Zillow House Index'\n",
        "    zillowDf = zillowDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    zillowDf = pd.DataFrame(zillowDf)\n",
        "    zillowDf['date'] = pd.to_datetime(zillowDf['date'])\n",
        "    # Compute log levels\n",
        "    zillowDf['value'] = pd.to_numeric(zillowDf['value'], errors='coerce')\n",
        "    zillowDf.dropna(subset=['value'], inplace=True)\n",
        "    zillowDf['month'] = zillowDf['date'].dt.month\n",
        "    zillowDf['day'] = zillowDf['date'].dt.day\n",
        "    zillowDf['year'] = zillowDf['date'].dt.year\n",
        "    zillowDf['log_price'] = np.log(zillowDf['value'])\n",
        "    # print(spyDf[(spyDf['month']==3) & (spyDf['year']==2024)])\n",
        "    zillowDf = zillowDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    zillowDf.reset_index(drop=True, inplace=True)\n",
        "\n",
        "    zillowDf['log_diff_90'] = (np.log(zillowDf['value'])-np.log(zillowDf['value'].shift(3)))*100\n",
        "    zillowDf['date'] = zillowDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "\n",
        "    # dollar index\n",
        "    dollarUrl = f\"https://api.stlouisfed.org/fred/series/observations?series_id=DTWEXBGS&api_key={apiKey}&file_type=json&\"\n",
        "\n",
        "    response = requests.get(dollarUrl)\n",
        "    dollarData = response.json()\n",
        "\n",
        "    dollarDf = pd.DataFrame(dollarData['observations'])\n",
        "    dollarDf['series'] = 'Dollar Index'\n",
        "    dollarDf = dollarDf.drop(columns=['realtime_start', 'realtime_end'])\n",
        "    dollarDf['date'] = pd.to_datetime(dollarDf['date'])\n",
        "\n",
        "    dollarDf['value'] = pd.to_numeric(dollarDf['value'], errors='coerce')\n",
        "    dollarDf.set_index('date', inplace=True)\n",
        "    dollarDf.sort_index(inplace=True)\n",
        "    dollarDf['90_day_avg'] = dollarDf['value'].rolling('90D', min_periods=1).mean()\n",
        "    dollarDf.reset_index(drop=False, inplace=True)\n",
        "    dollarDf['month'] = dollarDf['date'].dt.month\n",
        "    dollarDf['day'] = dollarDf['date'].dt.day\n",
        "    dollarDf['year'] = dollarDf['date'].dt.year\n",
        "    dollarDf = dollarDf.groupby(['year', 'month']).apply(lambda x: x[x['day'] == x['day'].max()])\n",
        "    dollarDf.reset_index(drop=True, inplace=True)\n",
        "    dollarDf.drop(columns=['value', 'month', 'day', 'year'], inplace=True)\n",
        "    dollarDf['date'] = pd.to_datetime(dollarDf['date'])\n",
        "    dollarDf['diff'] = np.log(dollarDf['90_day_avg'] - dollarDf['90_day_avg'].shift(3))\n",
        "    dollarDf['diff'].fillna(0, inplace=True)\n",
        "    dollarDf['date'] = dollarDf['date'] + pd.offsets.MonthEnd(0)\n",
        "\n",
        "\n",
        "    # data cleanup for merging\n",
        "    dowDf['equity'] = dowDf['log_diff_90']\n",
        "    zillowDf['housing'] = zillowDf['log_diff_90']\n",
        "    dollarDf['dollar'] = dollarDf['diff']\n",
        "    bondDf['tripleb'] = bondDf['diff']\n",
        "    mortgageDf['mortgage'] = mortgageDf['diff']\n",
        "    tenYearDf['10yr'] = tenYearDf['diff']\n",
        "    fedsFundDf['FFR'] = fedsFundDf['diff']\n",
        "    print('dow min date', dowDf['date'].min())\n",
        "    print('zillow max date', zillowDf['date'].min())\n",
        "    print('dollar min date', dollarDf['date'].min())\n",
        "    print('bond min date', bondDf['date'].min())\n",
        "    print('mortgage min date', mortgageDf['date'].min())\n",
        "    print('10 year min date', tenYearDf['date'].min())\n",
        "    print('fed funds min date', fedsFundDf['date'].min())\n",
        "    dowDf = dowDf[dowDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    bondDf = bondDf[bondDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    mortgageDf = mortgageDf[mortgageDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    zillowDf = zillowDf[zillowDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    dollarDf = dollarDf[dollarDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    tenYearDf = tenYearDf[tenYearDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "    fedsFundDf = fedsFundDf[fedsFundDf['date'] > '2014-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "\n",
        "    dowDf.drop(columns=['series','month', 'day', 'year', 'value', 'log_price', 'log_diff_90'], inplace=True)\n",
        "    zillowDf.drop(columns=['series','month', 'day', 'year','value', 'log_price', 'log_diff_90'], inplace=True)\n",
        "    bondDf.drop(columns=['index', 'series',  '90_day_avg', 'diff'], inplace=True)\n",
        "    mortgageDf.drop(columns=['series', '90_day_avg', 'diff'], inplace=True)\n",
        "    dollarDf.drop(columns=['series', '90_day_avg', 'diff'], inplace=True)\n",
        "    tenYearDf.drop(columns=['series', '90_day_avg', 'diff'], inplace=True)\n",
        "    fedsFundDf.drop(columns=['series', '90_day_avg', 'diff'], inplace=True)\n",
        "    merged_df = pd.merge(dowDf, bondDf, on='date', how='inner')\n",
        "    print(\"equities\")\n",
        "    merged_df = pd.merge(merged_df, mortgageDf, on='date', how='inner')\n",
        "    print(\"bond\")\n",
        "    merged_df = pd.merge(merged_df, zillowDf, on='date', how='inner')\n",
        "    print(\"zillow\")\n",
        "    merged_df = pd.merge(merged_df, dollarDf, on='date', how='inner')\n",
        "    print(\"dollar\")\n",
        "    merged_df = pd.merge(merged_df, tenYearDf, on='date', how='inner')\n",
        "    print(\"10yr\")\n",
        "    merged_df = pd.merge(merged_df, fedsFundDf, on='date', how='inner')\n",
        "    print(\"fed funds\")\n",
        "\n",
        "    return merged_df\n",
        "\n",
        "\n",
        "# Define the data\n",
        "weights = {\n",
        "    'period': list(range(4, 17)),\n",
        "    'FFR': [0.099943944, 0.068578534, 0.050928985, 0.030388756, 0.025687511,\n",
        "            0.020009094, 0.015811759, 0.011351882, 0.007392853, 0.003964395,\n",
        "            0.001711082, 0.000393424, 0.000128902],\n",
        "    '10yr': [-0.008148666, -0.014000342, -0.018387348, -0.021524343, -0.023217226,\n",
        "             -0.024365968, -0.025223595, -0.025907416, -0.026403294, -0.02669953,\n",
        "             -0.020122033, -0.013446104, -0.006723265],\n",
        "    'mortgage': [0.217427793, 0.14524869, 0.119052555, 0.077495153, 0.062434293,\n",
        "                 0.045143184, 0.03369689, 0.02483504, 0.018457125, 0.013733173,\n",
        "                 0.008657804, 0.004898748, 0.002101614],\n",
        "    'tripleb': [0.079267719, 0.091179148, 0.098643896, 0.100472542, 0.10064806,\n",
        "                0.099579542, 0.097660772, 0.09535261, 0.092766486, 0.090084434,\n",
        "                0.066538625, 0.043675043, 0.021503906],\n",
        "    'equity': [-0.021318565, -0.020215983, -0.018436156, -0.016157903, -0.014443706,\n",
        "               -0.01302431, -0.011752768, -0.010660868, -0.009703574, -0.008865985,\n",
        "               -0.006342937, -0.004042458, -0.001937252],\n",
        "    'housing': [-0.03222844, -0.031273991, -0.029701866, -0.026759405, -0.019779925,\n",
        "                -0.013423982, -0.006051851, 0.000769171, 0.004236312, 0.006672419,\n",
        "                0.007860665, 0.008861208, 0.009192217],\n",
        "    'dollar': [0.048, 0.048, 0.045, 0.039, 0.031, 0.023, 0.017, 0.012, 0.008, 0.005, 0.002, 0, 0]\n",
        "}\n",
        "\n",
        "# Create DataFrame\n",
        "weightsDf = pd.DataFrame(weights)\n",
        "\n",
        "# Display DataFrame\n",
        "print(weightsDf)\n",
        "\n",
        "\n",
        "def weightcalc(window, variable):\n",
        "    '''takes in a window of values and a variable and returns the adjusted sum\n",
        "    '''\n",
        "    weights = weightsDf[variable].to_list()[::-1]\n",
        "    adjusted_values = [x * weight for x, weight in zip(window, weights)]\n",
        "    # print(adjusted_values)\n",
        "    adjusted_sum = sum(adjusted_values)\n",
        "    return adjusted_sum\n",
        "\n",
        "merged_df = fetchData(apiKey)\n",
        "print(merged_df.columns)\n",
        "merged_df['equity_score'] = merged_df['equity'].rolling(12).apply(lambda x: weightcalc(x, 'equity'))\n",
        "merged_df['tripleb_score'] = merged_df['tripleb'].rolling(12).apply(lambda x: weightcalc(x, 'tripleb'))\n",
        "merged_df['mortgage_score'] = merged_df['mortgage'].rolling(12).apply(lambda x: weightcalc(x, 'mortgage'))\n",
        "merged_df['housing_score'] = merged_df['housing'].rolling(12).apply(lambda x: weightcalc(x, 'housing'))\n",
        "\n",
        "merged_df['dollar_score'] = merged_df['dollar'].rolling(12).apply(lambda x: weightcalc(x, 'dollar'))\n",
        "merged_df['10yr_score'] = merged_df['10yr'].rolling(12).apply(lambda x: weightcalc(x, '10yr'))\n",
        "merged_df['FFR_score'] = merged_df['FFR'].rolling(12).apply(lambda x: weightcalc(x, 'FFR'))\n",
        "merged_df['FCI'] = merged_df['equity_score'] + merged_df['tripleb_score'] + merged_df['mortgage_score'] + merged_df['housing_score'] + merged_df['dollar_score'] + merged_df['10yr_score'] + merged_df['FFR_score']\n",
        "\n",
        "print(merged_df.tail())\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.rcParams['font.family'] = 'EB Garamond'\n",
        "plt.rcParams['font.size'] = 12\n",
        "\n",
        "# Plot the FCI time series\n",
        "plt.plot(merged_df['date'], merged_df['FCI'], color=plt.cm.plasma(0.5), linestyle='-')\n",
        "\n",
        "# Fill the area between the line and zero with light blue if above zero, and light orange if below zero\n",
        "plt.fill_between(merged_df['date'], merged_df['FCI'], where=(merged_df['FCI'] >= 0), color=plt.cm.plasma(0.3), alpha=0.4, interpolate=True)\n",
        "plt.fill_between(merged_df['date'], merged_df['FCI'], where=(merged_df['FCI'] < 0), color=plt.cm.plasma(0.7), alpha=0.4, interpolate=True)\n",
        "plt.gca().set_facecolor((0.8, 0.8, 0.8, 0.4))  # RGBA values: (R, G, B, Alpha)\n",
        "\n",
        "plt.title('Financial Conditions Index - 3 Year Lookback')\n",
        "\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('FCI')\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 571
        },
        "id": "aK41A5dnWEDP",
        "outputId": "28982750-3157-406b-eced-a36ab02e4ebf"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Stacked bar chart\n",
        "\n",
        "df = merged_df[['date', 'equity_score', 'tripleb_score'\n",
        "                  , 'mortgage_score', 'housing_score', 'dollar_score', '10yr_score', 'FFR_score']]\n",
        "df = df[df['date'] > '2015-04-30 00:00:00'].sort_values(by='date', ascending=True)\n",
        "df.rename(columns={col: col.replace('_score', '') for col in df.columns}, inplace=True)\n",
        "df.set_index('date', inplace=True)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(10, 6))\n",
        "# Define a list of jewel tone colors\n",
        "\n",
        "ax.stackplot(df.index, df.T, colors=plt.cm.plasma(np.linspace(0, 1, len(df.columns))))\n",
        "ax.set_facecolor((0.8, 0.8, 0.8, 0.8))  # RGBA values: (R, G, B, Alpha)\n",
        "\n",
        "ax.set_title('Contributions to FCI Over Time')\n",
        "ax.set_xlabel('Date')\n",
        "ax.set_ylabel('Total Score')\n",
        "\n",
        "# Create a MonthLocator instance for every half-year\n",
        "months = mdates.MonthLocator(bymonth=[1, 7])\n",
        "\n",
        "# Create a ConciseDateFormatter instance\n",
        "date_fmt = mdates.ConciseDateFormatter(months)\n",
        "\n",
        "# Set the major locator and formatter\n",
        "ax.xaxis.set_major_locator(months)\n",
        "ax.xaxis.set_major_formatter(date_fmt)\n",
        "\n",
        "\n",
        "# Create a custom legend\n",
        "legend_proxies = []\n",
        "for i, column in enumerate(df.columns):\n",
        "    legend_proxies.append(plt.Rectangle((0, 0), 1, 1, fc=plt.cm.plasma(i / len(df.columns))))\n",
        "\n",
        "ax.legend(legend_proxies, df.columns, title='Score Type', loc='lower right', bbox_to_anchor=(0.15, 0.1))\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 601
        },
        "id": "vVWNn3ighNQ4",
        "outputId": "8ae90cdf-d4a0-4d09-b557-4b8787565eed"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9YAAAJICAYAAACE8nw1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wjd50//tdnZtSre9nqXW/fTbLp2bQlISQBQu8B7uAXOI47jhJaCPV7fI923JccodwBBwkkBA4S0ns22WR7tnu9XvfeLUtWl2bm8/tDa8myJFuyR5Zsv5+PRx5Zj0YzH9uyNO/5vD/vN+OccxBCCCGEEEIIIWROhEIPgBBCCCGEEEIIWcwosCaEEEIIIYQQQuaBAmtCCCGEEEIIIWQeKLAmhBBCCCGEEELmgQJrQgghhBBCCCFkHiiwJoQQQgghhBBC5oECa0IIIYQQQgghZB4osCaEEEIIIYQQQuaBAmtCCCFLWjQaLfQQCCGEELLEUWBNCCFkyQkGg/jLX/6CW2+9FXfffXehh0MIAKCzsxNve9vbMDg4WOihEEII0RgF1oQQQuL8fj9++tOf4uabb8bu3btxzTXXoL6+HhdeeCE++clP4vXXXy/0ENM6fvw4rrrqKvzhD38AAPT39+NrX/sannnmGaiquiBj8Hg8uPXWW/GFL3xhQc5XCD6fDzfddBMEQQBjDIwxXHHFFdi9ezeuv/561NTUQBRFtLe3pzy3t7cX3/jGN3DttdfixhtvxGWXXYa6ujrs2rULX/3qV+PB5iOPPIJ169bFj88Yw65du9DS0jLr+J566im8733vw+7du3Hddddh48aNuOWWW/Dggw8u2OtgJocPH8bjjz+OG2+8Ebt378bVV18NSZLAGINer8euXbuwe/duXHnllTAajWCMoa+vb1m8tgghZNHjhBBCCOf8scce45WVlfzmm2/mzc3NSY899dRTvKqqir/xjW8s0Ohm9ulPf5oD4Nu2bYtv+/3vf88B8DvvvHNBxvDnP/+ZA+AA+MjIyIKcs1Amf94XXnhh0vZgMMh37drFjx8/Ht+mKAr/7ne/yw0GA7/zzjv52NhY/LFwOMzvueceLggC/+53v5u0ffXq1RwA/8IXvjDreAKBAH/Xu97Ft2zZwo8dO5Z0nB/96EdcFEW+a9cuPjAwMPdvWgPvfOc7+c9//vOkbW95y1s4AP7JT34yafvJkyf5qlWrOOfL67VFCCGLlVSwiJ4QQkjR+M1vfoM77rgDb3vb2/Dwww9DFMWkx2+99Vb813/9F77+9a8XaIQzu+222/DAAw/gfe97X3zbypUrF3QMu3btwurVq7F582aUlZUt6LkX2s6dOwEATqczabvRaMRXvvIVmM1mAADnHB/72Mdw//3340c/+hG++MUvJu2v1+vxL//yL+jo6EhKj9br9airq0N3dzd27Ngx63je//734+WXX0ZTUxNqa2uTjvPFL34RjDF88YtfxJve9Cbs27cPNpttrt/6vLzzne/ERz7ykaRtJSUlAICqqqqk7RdccAHuvPNOAMvrtUUIIYsVpYITQsgyd/LkSfzDP/wDrFYrfvOb36QE1ZPe+ta3oqKiIu/j+fWvf43vfOc7OT3nlltugdvtxje/+c08jSphdHQUV1xxBSKRSNL2FStWoKurC88++ywYY3kfR7ba29tx/fXXa3pMScp8X/5tb3sbNm7cCAD4+c9/jvvvvx9XXXVVPEhM54477oCiKHMay0MPPYTHH38cd9xxR1JQPdXnPvc51NfX4/Tp0/jXf/3XOZ1HC9ODagDxvzdBSL0k++xnPwugeF9bhBBCEiiwJoSQZe5rX/saFEXB7bffjvLy8oz7iaKIF154YU7naGpqwj/+4z/OuE80GsVXvvIVfOITnwDnfE7nybfjx4/jyiuvxIkTJzQ/diAQwHe+8x0cPnxYs2O++OKLuPLKK9Hb27vga4zD4XD8Rse//Mu/zBgQbtu2Dffee++czvOTn/wEAHDTTTdl3EcURXz0ox8FAPziF79AOBye07kIIYSQTCiwJoSQZczj8eC5554DAFx33XWz7j99Vm18fByf//zn8aY3vQlbtmzBVVddhcceeyxpn5tuuglbt27Fnj178JOf/AQf/ehHsX79eqxbtw4vvfRSfL89e/bgj3/8IwDgpz/9KXbv3o3du3fj2WefBQAcO3YMH/jAB/DYY4/hm9/8JioqKvCpT30KQGwW+Qc/+EH866lkWcYTTzwRn9HcuXMnnnzyyfjjX/va1+JFsv70pz8BAL71rW/Fi0fV19fH9/3e976H9vZ2RCIRXHnlldi9ezc++MEPAgBCoRD++Mc/4tprr00Zw+9//3vcfPPN2LVrF9atW4e7774boVAo/vgvf/lL1NTU4Nvf/jb27duHO+64A29605vgdDpTZnpdLhduv/12XHHFFdi8eTPe8573pP1dybKMb33rWxgZGUF7ezuuvvpq7N69G5///Ofj+/T19eETn/gEbrrpJtTX1+ONb3wjXnvttbTHS2dqsB6NRvH2t789/n29+OKLcLlcAOb22sqG2+3GkSNHAACrVq2acd83vOENAGIF2A4fPox77703XjjM4XDg8OHDmJiYwJVXXgnGGHbs2IHu7m4AsRsq73znO3HDDTdgw4YNuOuuu+Iz7D6fD7/4xS/w9re/HQ0NDbjqqqtQXV2NM2fO5Pz9ZJLptdXQ0ID3ve992LdvH/7nf/4H1157LYxGI97+9rejq6sLP/jBD/D2t78dRqMRH/rQh1KyAmb6vgghhOSo0Iu8CSGEFM6xY8fiRZGef/75nJ47OjrKN23axH/6059yzjmXZZl/7GMf4wD4f/7nf8b3myy8VFVVxRsaGjjnnI+NjfGqqipeU1PDQ6FQfN/f/va3HAD/xje+kXSuBx54ID7Oyy67jN92223c4XDwr3zlK/yll17iRqORA+Cf/vSn48/Zs2cPB8Df9a53ca/Xyznn3OVy8YsuuogLgsCffvrp+L433HBDys/gqaee4gD41VdfnTSWNWvWcABcUZT4tqGhIb5y5UoOgG/dujVp/zvvvJNfe+213O/3c845f+aZZ7gkSXzXrl08HA5zzjmfmJjgVVVVHAD/93//9/hzP/GJT3AA/NFHH41v+9CHPsSvv/76+PM2bNjABwcH0/+SOOcA4kWwpmppaeHV1dX8scce45zHCoDdfPPNXJIk/sgjj2Q8HueJ35MgCPzaa6/l119/PV+3bh0HwFVV5Zxz/h//8R/x31k0Gp3xeOlcf/31HAD/7W9/m3Gfo0ePxs8xveDedMPDw/F9//jHP3LOOf/GN77BAfAPfvCD8f327dvHKysrucvl4pxzfuTIEX7xxRfHf8ZtbW0cAP/pT3/KZVnmW7Zs4QB4TU0Nf8Mb3sCvuOIK7nA4ZvydTPV3f/d3HAD/1re+lfbxTK+tX/ziF/Hv57e//S1XVZX7/X5eX1/PAfAbb7wx/pr78Ic/nPR9z/Z9EUIIyR3NWBNCyDImy3L83z6fL6fnfvazn0V/f388xVsURdxzzz1wOBy488470dfXBwC4+OKLAQCbN2/Gtm3bAAClpaW4/vrrMTAwgHPnzqUce/rs5Yc+9CHceOONAIDbb78djz32GAYHB/H9738fb3jDG+JjmF5MCwB27NgBq9UKIFYo6oc//CFUVcVdd90V32dytnPq2uEtW7akbMs0xsrKSvzsZz9LGcMLL7yAH//4x/jMZz4TL+h1880346Mf/Sj279+Pe+65BwBgs9mwYcMGAMC73/3u+PPf+c53AgBefvnl+LaTJ09ifHwc4XAYNpsNf/rTn2A0GtOOMd1YJ33sYx9DaWkpbrvtNgCAyWTCL3/5S6iqijvuuAPBYHDGYwKxAlt79+7Fyy+/jHPnzmHr1q3xNP75vLayNXWdu9vtnnHfqb+XyZ/XZz/7WRgMhqQ2cqdPn8ZnP/vZeFGxT33qU2htbcX73/9+7N69Gx/60IewZs0ahMNhiKKI//7v/wYQm71/+umncfDgQQwODqYUI5urTK+tT33qU/G17FdddRUYYzCbzfHf53ve8574a+69730vACRlI8z0fRFCCMkdBdaEELKMrVmzJv7vs2fPZv08t9uNP/3pT/G+xZNsNhve+MY3IhqN4oknngCAjMXQTCYTAMTThWczWeV7+/btAJAUTE5WjtbpdLMeZ/fu3TAYDDhx4gS8Xm9W585GujH88pe/BJBaoXwyYH744Yfj29L9nNL9jK6//nqcOnUKV1xxBY4cOYKdO3fC4XDkNNaGhga89tprKeNau3Ytdu7cibGxMezdu3fW4xgMhvi/JUnChz70oXhgNtfXVi6mFitrbm6ecd+pNwomb2KUlZXhfe97H1paWrBv3z4AwIMPPoiPfexjAICuri4cPXoUP/jBD/Dyyy/j5ZdfxsGDB9HZ2RlP0Z/8GW7YsCH+85jtRkeuMr2+a2pqACT/Hux2e8oYJrdN3uDI5vsihBCSGwqsCSFkGausrMSll14KAHjqqaeyft65c+cgy3LaAGL16tUAYuu38yFdAJpLpWSdThdvWTR1nfN8pRvD5Drb6T+n+fyM/v3f/x3vfe97cfLkSVx55ZX44Q9/mPMxMo1rvmO7++674zcDbrrppnggmMtrKxerV6+OB8l79uyZcd/J9dIrV66MZ04AiGc7/O53v0NLSwtKS0vjAWt/fz8AYGxsbNaxZLqBpAWtK4Hn8n0RQgjJDgXWhBCyzN19990AYmmis1WkvvfeexGNRuN9gHt6elIqeE8Gq5MBT7HhnMPj8cDhcMxYBV0Lkz+nrq6upO3z+RmZTCb8+c9/xh/+8AeYTCZ89atfxalTpzQZ13zHNlVJSQk+/elPAwB+9atfzZgdoCgK/vM//3NO55lsSfXXv/51xnM8//zzAGIVyqe66qqrsH37dvz5z3/GL3/5S9xxxx3xxybbyz300ENJqe2L3VL9vgghpJAosCaEkGXuHe94R3zW7o477sDExETa/Q4cOID/+3//L3Q6HTZv3oxVq1ZhfHwcr7zyStJ+586dQ3l5OW655ZacxzI525nN+t5sTQ8ejx8/Dr/fjw9+8IPxmUC9Xg8A6O3tje/X1tY27zFOtoD629/+lrR9cl35hz/84Sy+g4SmpqZ4W6rbb78d99xzDzjnaG1tzfgco9GYMtarr74aJpMJp0+fRnt7e8rYtm7dip07d846nuk3Vab77ne/i8suuwxDQ0P4zGc+k3G/H//4xzlVI5/qH/7hH3DDDTfA7Xbja1/7Wtp9fD4f/uM//gOXXXYZPve5z6U8/olPfAITExN45JFHcOutt8a319fXY+3atWhoaMAdd9wRD9wPHz6cc6/1TCZ/hrP9LLW0EN8XIYQsNxRYE0IIwb333otvf/vbOHv2LK677rqkYk4A8MQTT+Atb3lLPFAUBAH33nsvRFHE5z73uXjhqJMnT+LAgQP4r//6r3gAOjkDOj3tenItbjQajW+bXEv6yiuvxFs5BQIBAIlCVekC2sljTS285Pf7AcRm5SbbekWjUXz9619HfX09/u3f/i2+7yWXXAIA+M53voMDBw7g2Wefxbe+9S0AsVn5s2fPxs9/wQUXAEikHk+OL90YvvSlL6G+vh4PPPBAvAd4OBzGr371K7zrXe+KF5XK9HOa/jPS6/X41re+hZaWlvj3aLFYcPnll6f8TCZdcMEFGB4ejqd/BwIBOBwO/OhHP4Kqqvj0pz8dP+dTTz2FoaEh/PrXv854PADxQL61tXXGWWKr1YrnnnsO7373u3Hffffh/e9/f7yo3eT396Mf/Qh33XVX0o2YYDAYP8fx48dnHIskSXjkkUfw1re+Fffeey+++tWvxn/3ANDS0oJbbrkFdXV1eOaZZ9Kuw//ABz4ASZLw4Q9/OKXQ2/e//30AwH333YeqqirU1NTg+uuvx9vf/nYAM78uZxONRuPf38GDBzP2Gk/32gISBeKmbp8cz9Rtk6+fqbPTs31fhBBCclTAiuSEEEKKTFtbG7/zzjv5jh07+AUXXMCvv/56fumll/Jdu3bxb37zm3xoaChp/z179vDdu3fz1atX8xtuuIG/9a1v5Xv37o0/fuLEiXgbJgD8wx/+MOec8y9/+ctcFMV4K6iXXnop/pzvfve7vKysjF999dX8i1/8Ij9x4gT/wQ9+wE0mEwfAy8vL+S9/+cv4/k888QSvra3lALjD4eD/7//9P8455/fdd1/8vAD4zp07+dVXX80/85nP8LGxsaTvIxwO8w9+8IPcYDDwVatW8S9/+cv88ccf59u2beNf+cpX+AMPPBBvXdTS0sKvuOIKXl5ezj/2sY/x//iP/+AtLS384osv5gA4Y4x/9KMfjbedGh0d5Z/85Cd5bW0tv/rqq/k111zDf/zjH3NZluPnf9e73hUfZ11dHW9paeF79+7l1dXVHADX6/X8S1/6Euec87vvvpvX19fz6667jl911VVJP7t0Dh06xLdt28ZXrFjBP/WpTyW1r/rrX//KL7vsMr5u3Tr+hje8gb/3ve/lp06dyniswcFB/uY3v5kLghAfb01NDf/1r3894xg453zv3r387/7u7/iGDRv4JZdcwnfv3s0vvPBCfsstt/Cf//znPBKJcM45v+eee+LtpSb/u+KKK/ixY8dmPcfjjz/O3/GOd/ANGzbwXbt28euvv56/9a1v5Q888ED895HJBz7wAd7T05P2sQcffJBv2bKFGwwGfskll/DXXnuNcx77e7nsssvi47zhhhv48PDwrOPknPNf//rX8dZtk/9t3LiRP/7440n7ZXptffzjH4//HjZt2sS7urr4r3/9a26xWDgAXlJSwv/3f/+Xv/7663z16tXx19FXv/rVWb8vQgghuWOcL2DuESGEEEIIIYQQssRQKjghhBBCCCGEEDIPFFgTQgghhBBCCCHzQIE1IYQQQgghhBAyDxRYE0IIIYQQQggh80CBNSGEEEIIIYQQMg8UWBNCCCGEEEIIIfMgFXoAC01VVfT398Nms4ExVujhEEIIIYQQQggpQpxzeL1e1NbWQhBmnpNedoF1f38/Vq1aVehhEEIIIYQQQghZBHp6erBy5coZ91l2gbXNZgMAvPTSS7BarQUeDSGEEEIIIYSQYuTz+XDDDTfEY8iZLLvAejL922q1UmBNCCGEEEIIIWRG2SwhpuJlhBBCCCGEEELIPFBgTQghhBBCCCGEzAMF1oQQQgghhBBCyDxQYE0IIYQQQgghhMwDBdaEEEIIIYQQQsg8UGBNCCGEEEIIIYTMAwXWhBBCCCGEEELIPFBgTQghhBBCCCGEzAMF1oQQQgghhBBCyDxQYE0IIYQQQgghhMwDBdaEEEIIIYQQQsg8UGBNCCGEEEIIIYTMAwXWhBBCCCGEEELIPFBgTQghhBBCCCGEzAMF1oQQQgghhBBCyDxQYE0IIYQQQgghhMwDBdaEEEIIIYQQQsg8UGBNCCGEEEIIIYTMAwXWhBBCCCGEEELIPFBgTQghhBBCCCkIxgIAooUeBiHzJhV6AIQQQgghhJDlyVb6B5jtzyAS2opI8AKEgxchGq4Hzf+RxYYCa0IIIYQQQsjCYxGYbS9CEMIwmo/DaD4O4D6oigXh0A5EAhciFLgcilxd6JESMiu6FUQIIYQQQghZcCbLaxBEX8p2QfTDZDkIR8V/wVHxswKMjJDcUWBNCCGEEEIIWXBm+9Oz7qM3ngWg5H8whMwTBdaEEEIIIYSQBSXpumAwNc66nyAEodN3LMCICJkfCqwJIYQQQgghC8psfybrffWmM3kcCSHaoMCaEEIIIYQQsnBYGGbbi1nvrjdSYE2KHwXWhBBCCCGEkAVjsr4KQfRnvT8F1mQxoMCaEEIIIUueTXgKAC/0MAghACy27NPAAUCU3BB1fXkaDSHaoMCaEEIIIUuezfEQyvU/LPQwCFn2JH0n9KazOT+PZq1JsaPAmhBCCCFLn8kD/Yq9sLCXCj0SQpa1bFpspWMwzl5BnJBCosCaEEIIIUuagDHAJAMC4Ki5ByIfKvSQCFmeWBhm6545PZVmrEmxo8CaEEIIIUuamR1NfGGSUVXyZdB6a0IWnsm6N6eiZVNJ+n4IokvjERGiHQqsCSGEELKkGaQz0PXqAOX8hrJRlBu+V9AxEbIcWXLoXZ0OzVqTYkaBNSGEEEKWNJ2+E9KgDoYWY3ybvnYfLOyFAo6KkOVF0ndCb2ya1zH0tM6aFDEKrAkhhBCypDH9EESfAF2PDuKIFNsoAI7an0Lkg4UdHCHLhGWORcum0ptoxpoULwqsCSGEELKEcQhSECwqgIHB2GgEC7PYQ0YZVaVfBrgy8yEIIfPCWAimORYtm0qn7wBjAQ1GRIj2KLAmhBBCyJKl410QIhxKVAQACBEBxsZESjhKx1BhpPXWhOST0frqnIuWTcWYSungpGhRYE0IIYSQJcskHoPgEzF6eiX8LgsAQBrVQdeti++jqz1A/a0JySMt0sAn6U0UWJPiRIE1IYQQQpYsvXQWok+AGBbhbqyFqsTSwA0tRgje85dBAmC3/6GAoyRk6ZL0HdAbz2XeQc7teFQZnBQrCqwJIYQQsmQxtQvwSBBUBgvj6Du67vx2BmODKd6Ci5UOQeRDBRwpIUuTyfLajI+zg2VgT9UAk7UPZqE3NAOIajAyQrRFgTUhhBBClizR4kKoxw4BsYt2SxhwdVXEHvOJMLQYYjsKgFNPs9aEaG3GSt4KoOyvgXy4BuovNkPoN8x6PCZEoDO0aDhCQrRBgTUhhBBCliYehShFEB63xDcJAkOksxSRkB4AoOvRQxyNFTYzOA8VZJiELF1R6AzNGR8VukzggdjfInebEP3vrWCvlM+aHm6gtlukCFFgTQghhJAlycAaIYYYWFCXtN0oKRg8fD4lHAzGMyawCAPsfhhxtBBDJWRJ0hlaIQjhjI+rhyunbWGQ96wG//UGsDEp4/NonTUpRhRYE0IIIWRJEoNHIfhEIJx6gW4XZfS3xYJrISJA1xmbNXOY/7SgYyRkKZtpZplNiFCaStM+pg7aIN+7HcLrTkBNfTzWcotrM0hCNEKBNSGEEEKWJBZqgugVgEj6yx1dn4gIK4v9e1AHcEAsaQI4FUYiRAszzSyzMw4AMxQs4wKiT6wD21uR8pAg+iHpuzQYISHaocCaEEIIIUuSwTEAZUwPQU1/8a4TOcaO1oJDhBAWILpEwKjALj66wCMlZCni0EkN6R9SAHl/TVZHUZucabfrjRmOTUiBUGBNCCGEkCVJX+JDuN8OxjLPipmCQUyELgQA6AZia7Et1mcWZHyELGWSvguiIZD2MaHHBO6dvQI4AKiDVrBQ6t8wrbMmxYYCa0IIIYQsOVzxQhIUqD7jrPuqRycQEtZAGtYBCsBKByBiZAFGScjSJfgOZ3xMPVyew5EY2EhqEE6VwUmxocCaEEIIIUtOpG0/xIAA1a+fdV8GIDhcAaYwSEM6QAScugfzP0hCljDJk759HfMJUBpzCawB9JpTNonSGERpaC5DIyQvKLAmhBBCyJIjhU5A8IrgaSqCp8NbJqAwSzwd3ODYn8/hEbKkye4QLPXpi4vNWrQsDbXNnnY7pYOTYkKBNSGEEEKWHGt5NwSfABbN7lJHUFUE5PUQXWJsPafDBwNO5XmUhCxNgadfga48mPqAmn3RsqmUDiegpG7Xm6iAGSkeFFgTQgghZMmxrByDPGiGMEPhsunkbhEMDNJgbNbaYXwoX8MjZMlSFRU20+tpHxN6jeCe2esepFAECC5dymaasSbFhAJrQgghhCwpwZEI9NYQ5FFrTs9j/V6EhZp4OrhUdgbgaabJCCEZTfztHKzbB9M+ph5J7UmdtX5TyiadvheC4Jn7MQnREAXWhBBCCFlShvc1QwRHNMt2PlOFfLUQfSKECQEwyrCJT+RhhIQsXcprTTBtS62qz/wClNNlcz6u2mlLu11vbJzzMQnREgXWhBBCCFlSTMoRiD4BanD2iuDTKeeC4BDjs9ZWy1NaD4+QJct/oA9Wxwj0K70pj7FGO+YTeqgtToCnbtdT2y1SJCiwJoQQQsiSUlrbCsEnAmExvk1Vs1trLQQiCLL1sXXWHGClvRD4eL6GSsiSEnzsFIxbR1MfUAF5X/qiZTzLv03uM4B5xZTtBtOJXIZISN5QYE0IIYSQJYNzjpL6QTCPCEFJXLAfPVkHrmZ3jPCIHUJEgDgmAhLg1D+Qp9ESsnSEuzwwBkZg2jac8pjQZwB3p66RBoC2hjp0nl0NnmY2ejo2lFr4TGfogCCO5TxeQrRGgTUhhBBCloyhI16YV3oQ7beBTakIvuf1dejpLc/qGLx5AopghW4glkputO/Ly1gJWUq8D5yAICDtjLX6evqiZYosoOlkPY4f2IETr22HIs8cmvBuS9rtRnP6KuSELCQKrAkhhBCyZPTvGYNkjCLqNse3RcMS+sbseGTP9qxmxQSuIhBdD2lYAmQAzgnoQQWSCMlE8UegH+wFM0VhqHMnPcYCApRT6W9qDXZWIxqN1TPobFmD1566EuFA5toIaosj7XaD+cjcBk6IhhZ1YL1nzx7s37+/0MMghBBCSJGQfOcgRgHZl6gIPuayAWBoHyjDQH9pVseJdjIwlUEaOt/T2vC/+RguIUuC5w+nIIkKTJtHwcTku1es3QLw1JCDqwxnjm9M2uYaLcGLf7sWnlB12vOog1awUOqabIP5BIDonMdPiBYWXWDtcrnw4Q9/GFu2bMENN9yAvr6+Qg+JEEIIIUWitv4sBJ8IHtTFt/UMlsT//egr27KbtR70ISxO6Wlt7NJ8rIQsBZxzsDNtANKngfPu9P3kXUMl8HtTU7vDISMO7rkEE5bNaZ7FwEZS2+gJQhB6U0NuAydEY4susC4tLcX3vvc9XHjhhQCQtH6KEEIIIctXaDyKqgu6IfoEsGji+qCpM7G+s6m7EiPDzuyO510BcVwECzIwE1UGJyQd90ONMIhhAEjbv1ppS5++/eyJ7dBttgFpLuUDA8Bokw2jfAdUUZf8YK859Qmgddak8BZdYA0Aq1atwi233FLoYRBCCCGkiPQ854J94yjUUQOE85c4XGU41V6VtN8Te7dmdTy5KQBAgm5QB5giAA9qPWRCFrVQiwvigeOxLyQFhg2upMdZiIGPpVYDHx+z4tDJCjy/N4rx1ekDbz8rgfd4CONq8sy12mZPu7+BAmtSYIsysM5FOBzGxMRE0n+EEEIIWXpGDrphqPAjMpBIPfX5jIhEk2e8TrbVwDVqm/V4YvB8T+sBHSAAZnZM8zETslipEQWBe/dAEmN97IwbXBAMStI+bFSPdFPSLx+pj//79PEQREtqf+qhplgRM1+rDD7lGEqHE1BSdodO3wtRGpjDd0KINpZ8YP29730PDocj/t+qVasKPSRCCCGE5EG42wNJUiB7E6miQ8PpZ8Oe2bclu2MO2yH6RQgeAQbptCbjJGQpGPv+KzAK/vjX6dZXoz91tjroN+DlE3Xxr1WZQViZmt7t7ebgZXaoHhlR65R2XYoAwaVL2R8AjFQdnBTQkg+s77rrLng8nvh/PT09hR4SIYQQQjTGOcfK+laIIQbVn2jX05ahd/Whs6vgGU/fEzfpuC0eyIIV0ogOen27ZuMlZDFz/7UJlvHepG2mranrq9Xu1MyQ10+vwfQQxK2mD0mCUqyKf4iXJT+QJmAHAIOFAmtSOEs+sDYYDLDb7Un/kcXNNHockn+w0MMghBBSREZOeFF7VWusIngkkVZ6uq0q43NeOLBp1uMKnCMYWQ/RJ0A0UJopIaG2cQivHE3eyDiMW6bNWHNAaXMmbZKjIh7fl1rtu61FTnuu4bZYBfDAkJS0Xe1Mv5TDYGwAY6EZRk9I/iz5wJosLcaxUyiL3oOSsfsLPRRCCCFFpO/FcZTvGIAwIYBFY5c30YiEnpH0qeAAsPfUWvgm0s98TRXpYBB8ImCmOi1keVMjCvw/fQmSmLzIWb/GDdGa3EeaeUUgmJyy3dRSg3A0NY3bNaxAv8KYst3dygGnFcG2MFQpkYmitjiBNG3zmBCB3nQqh++IEO0s2sB6cDA2Y+l2uws7ELJgjK4zqAj+PyirApAqT0EMuWZ/EiGEkGVh4rQX1rpxyAMWCOdbcbpcVqTt5RPH8PKhDbMeWxz2IRJZAUgyBIxpM2BCFqGxH+yFiflTtpu2pa6vZsPJ/aZVleHRGSryRxyp/akBIGQqAxSOsKUmvo37DLHAPQ1aZ00KZdEF1h0dHbj99tvxzW9+EwDw+c9/Hp/4xCfQ399f4JGRfDK6m1Dp/zGiZRGof9gAPmSE00Wz1oQQQmLksQh0tjCiY4mK4L2DJbM+7/mj6xHwpc6UTRf210LwCzAzaulDlifPw02wuNLXKjKmWV/N+5ILkvX2lmHYnbkaf/9YmiloABNjsYA7FEh+LhtK/3droMCaFMiiC6zr6urwwAMPIBKJgHMOr9eLX/3qV6itrS300Eie6D0tqHT/EBEdB/9rHRAVwI9UQF9zGCxMaXmEEEIAo8kNkamQvYlZr7OdlVk8U8BrR9fPule4X4XgE2GQGucxSkIWp1DbONjLRzM+nq5wGe9Mrmv05Gsz949vOxuBYEoNTdzdsf/7u5IDb96dvvigpBuBpO+c8VyE5MOiC6zJ8qKfaEPN2PcRCejAn18B8PMpfUEJfFSPEvcfCjtAQgghBcc5R91VZyH6Bajn13RyFTg1Q+GyqZ4+sBGhgH7GfdSBEESfAB1dsJNlJtO66klStQ9S2bSCYTKgdCUCa9eoDU3dFZiJIgPi6tS2W4FBACY9ooMRyCZnYlwtmesnGM2UWUIWHgXWpGjpvV2oHfwewkNm8KOVmL5Ojh+shH7Fq2By6lofQgghy4e7LYiaS7oh+ESwSKx6sN9nSlskKR0VAo6cWjvjPgYeAfxGCMbh+Q6XkEVDVVS4/s8LaddVT7LuSk0PF9w6YEoLrT1HZq9lAAAeVUq7XXXEgvSQLpGFog5agXD6GgoGCqxJAVBgTYqSztuD2u7vItRhB291pt/JbQAmRDjcDy7o2AghhBSX8UY/nJtHALcOTI1tG5qhGng6j+/bDDmavhgSADDGoPirAbMPacsRE7LEqBEFrq8/C7N/KPNOjMNxa1vq9sHE+ueg34C9J9dmdc62tmja7REWS/sOjk0tcMYgDKfPNNEbG8EEmnghC4sCa1J0xJALKzr/FeEmJ/hw+vUzk/i+KhhXvgAo1LOQEEKWK09LAIbyACJ9VrDzFcHbektzOkY4qsPZ5pnrtYTdJQBToeNdcx4rIYuBEorCdffTMIdS105PZb5kALqq1ACW9ySu35rbqzBzdf6EsUEF+prUomR+byz7xN8aARem3ADrTX+dyJgCg+lYVuckRCsUWJOiYx1+BeFuK9TA7FVaMWgGCzHYJv6Y/4ERQggpSsGeICRBgexJrM883V4zwzPSe3TvVqhq5gAgOKCD6BNhEuiCnSxdij+C8bufglmeva2p482taber7YmMkcaO7GodTIqWpLbdmuiLBdM8qCJiTRxP7bCn7DuJ2m6RhUaBNSk6oncUqmvmmeqp1H1VMNc+DaiRPI6KEEJIsZLdQYhMheKPXZBHIyK6h3JLBQeAEY8VPT3lGR9XRxUIPgF6fdOcx0pIMZPdIbi//iTMqmfWfaVqH8wXD6RsZyEGdSR2k4urDCdac7vJNeBKXWrh6VIBXSy4Dkad8e1KmwNIX1MNBvNR0LINspAosCZFRzeeY2GYdhsEpkLXT2utCSFkOTKK45AUDh6KFT4aH7ch29TT6Z54dUvGx3ShCASfCEmfvpcvIYtZdCSAiW89CRO8We3vuLUVLE0kwcb0mPz783pNCEWyKyI4qfVsBIJx2oFVBu6MzU4H+6c8pogQXOmPL0pu6AzpZ9QJyQcKrElRYREvmHs812eB76tCyaYnATV90QtCCCFLV8XaLrCAABaNXdb0DjjnfKzm3gqMjdrSPqYXVPCADYJxdM7HJ6QYRfp98P7rkzBmWfCL6WXYb+xI/+CAKf7P/kFnzmORo4CUpu1WVBfLZgx1hqHqpzzeb0rZd5KB0sHJAqLAmhQVy9hBcE/q2prZ8MYSiAYZ8ulf52FUhBBCipWqqChbNwh13ADh/CzZbP1yZ7Pn0MaMj8m+asASAHiG/FNCFplwlwf+7z8JoxjM+jnWa7sh2tMvwVO7Ejemmrvm9rfoQWqF/mDw/PUhB0Km6sT52midNSkOFFiToqLz9Cf1PcyaysAPVKL22hcQ9VOFcEIIWS7c5wJwrB1DZNAKAOAqcKqtepZnzezV02sQ8KUvoBkcsIHJDAbWOK9zEFIsJn5zGAYxnNNzMhUtAwfUtlh9A86BYy0zV9rPpKMj9cbVxFCix3VwIjFjrTSUZ+xnrTO0QBDdcxoDIbmiwJoUFckzOOfn8uNlEC1RKMd+quGICCGEFDNXox+WSh+U0diFtt9vQjCcvrdt9hgOZei7Gx5iEHwCTOLJeZ6DkOIgemYvVDaVYeMYjBvSL9tjPhE8EPv7CwUMGPempnRnY7hPhr46OYPR3c4BIRZAB6YG3qoAoTP9eRjjMJiOzmkMhOSKAmtSPJQoRPc81q1FRfDDFVj9loOQQ7J24yKEEFK0JtqCMJgjUM+niQ6PZE4LzcVT+zchGklNR+VuFYJPhE7XrMl5CCkkNaJAj+xTwIEZZqsBsOFEMDw4nHtl/qmipcmBtRIC4IxlpsguGVFrooK/eiJzNX+j+fV5jYOQbFFgTYqGefww+Lg0+44z4IcrIDrCcB/Yp9GoCCGEFLNAbxB6YwT8fOGy9t4yTY4bUSScaVqZst2onK8MbujT5DyEFFLw+CAEIfuWVIItDOs13Rkf532JmeO23szBbjYGx1PTu2WjNf7vEBLHV86WgAXTp4MbLQchSkPzGgsh2aDAmhQNvacLiM4vsEZAB36iHHbDa9oMihBCSFHj3iBEgwzIsUua0+1Vmh370Ve3QlWSL9YlgUMNlkEw5drBgpDiEzqdW8Bpv6kdgl7N+DjvTBQuO9GcW//q6VqbwhAMyaFKKJqoAB4YmdpmSwBrsyIdJkRgL/vNvMZCSDYosCZFQ/JoczeRH6pA+XbqW0gIIcuBEApA1MtgKiBHRXQOlmh2bJfXjK40FcYjoxXgpjDAc0uhJaTYqF1j2e/MOBy3tmV+XAGUrlj6dyQsoWdknqng4dS2W96xKQXM2sLgYuJr9WjmGXKTdR/0RqqLQPKLAmtSHDiHOKZRms6YEaYqH9wdbm2ORwghpGiVVA0AQRECYxh3WQGkTwedq8f2bgWflikb6DOBhRlMwnFNz0XIQhMnsi9cZr5kALqqzH2uhXEdoMRCi9FRO7T4W5xgyZmM7imts3mEI2xJzIorHU4wX+bQxlH+KwDUJo/kDwXWpCgYPafAPNmv8ZkNGzBBaXpGs+MRQggpPkpERXl9P5SxWGus3iHtZqsntQ+UYXRaEaboCCD4RBjFBs3PR8hCybVwmeMtLTPvMKVwWWdf6VyHlaSjM7kYbXgcgC2RDh4MTS1WyMCabchEZ+iA2U7XhiR/KLAmRcEwcQ48mF17FEURoKoz3wXlbXaUr6CZBEIIWcpcZ/0oXTcK1RULrM91pqZta+GFQxuTvhYDCkSfAL2elh2RxSuXwmVStQ/mnTO3ROU9iTXOp+fZS37SUK8MXdW06uDWRDAd6EneXzlaOePx7I7fggleTcZGyHQUWJOiILmHs9pPVRgefOwynGpYPfOOnTaUXtgDVclcYIMQQsjiNt7oh22VG8qYGZwDpzQsXDbVwcZV8HkTs2RGRMD8eoiGmQMNQopZLoXLHLe2gs0SNahtscwORRbQ2KXdTS6lzJj0dZgn/hYjfREoxkSgrfbZwNyZC+EK+iCq8GWkrO8gRAMUWJOiIIzNfnGiKgwPPn45Xj+3Er9/9iIEfMbMOwckSPoohvdRn1FCCFmqvO0BGG0hqEEdAj4j/CHD7E+aE4azLYm1nILAoPgqAVP261MJKTZqd3aFy5hehv2NHTPvFGZQh2OFxmK1DrQLMcamLev2u3VJX4f0ybPUrGnmXvbCmm6s7v5nCGG3FsMjJI4Ca1JwOn87xInwjPuoCsNDT1yGI+d7isqKhP999qIZbziyThvMoee1HCohhJAiEhwIQW+KgkdEDI/OfDE9X23T+mMHeksBgwwBOVRVJqSIiJ7sbgzZbuiEaIvMuI8wpsdksbLuAW3WV0/q7UleZ+3pSQ5fAi5T0tfykQpgpglpAeAX9KCu7Qswjp3WapiEUGBNCs/kOQk+kXn2WVUY/vTkpTh0dlXS9mMtK9DennkND2+3oWJTk2bjJIQQUmS8AUiGKCALml/MTzc9tTU4oIcQEGBmR/N6XkLyIdvCZYIlgtIPZVGkbyAR3DZ2aLskY2xQgeRIpHf7+jhgTMxa+xpCkM3O+Nd8zAJhNHlWezqlXAFWTWC16/sUXBPNUGBNCk6cYX21qjD8+alLcLAx/Zrq3zx+KSLhDGtpuq1wbBtCYGTm2XBCCCGLE4sEIRqiYApD32jmasBa8PhNCIcSF+t8nEPwCzBIZ/J6XkLyIdvCZaW3n4bknP06Su2OFS5TVYaTLdoULptKqEqegFEdUzJUVGAisjLpcX529h7aoY1hQFJQNvSIJmMkhAJrUnBihvXVqsLwv09fjANn1mR8rj9kwNOvbE//oCyA+SWMH9inxTAJIYQUGaM0AcZUCGDoGZr9Qnq+3G5L/N/6qAzBJ0Cn78r7eQnRWjaFy/Rr3XDc2jb7wXiicJnXY0ZEyVw8bK6Ckpj0dVSwJH3tOR6GYkhUJVeOVAGz1K/lZhWR1RGYxWZAoUkYMn8UWJOCEsMuSN6JlO2qwvCXpy/G/oa1sx7jpWPrMTiQvncpa7ehvJQCa0IIWWqiAQUV6/vB3QaoKkP/WH5nrAFgYEo/a4OoAAErBGP2lZUJKRbZFC6r+OQxMHH2WW3mF8B9scKBfUPO+Q4trTFP8jgC/mktWqOAlyUmYrjXAGFo9jaukXVhwBxFSc+TmoyTLG8UWJOCMnsOgI8lF53gKsPDz16MfVkE1ZN+8+hlUOTUlzNvt6HignZwaqtACCFLiuuMH+UbRqCMGREJ6bAQlzQd/cnruCOucsDsy/t5CdHabIXLrNd1wbR9JKtjsW5z/N/56iXf0zGtgFm/mLKP+7gMVZdIGednnLMfWALkKhkO3yvzHSIhFFiTwpI8w5isIjnJ5bLi1VNrczrOsNuGfUfqUx8YMMO0xoOhw9n1ySaEELI4jDf54ahzQRk1weefof2ihhqnBQ3+TicgqdChe0HOT4gWZitcxoxRlH/sZPbHOxL7u+AcON68Yt7jS8frVqGrSMxAezo5ICaHMTyowqevi38tH60ClNmPLVdGoTcNQ+fr0Wy8ZHmiwJoUFBseSNnWOa2lSbb++so2uMeT19yAM7ABE4T+5+Z0TEIIIcXJ1x6EpdwH1WuAx2ua/QkaGHbbEI0k1o9GhiUIfgEm4diCnJ8QLcxWuKz0A42QymavGA4AzCNC6XDGjus3whPI402uskSfei4DvCS1xd74SQ5VPF9kMKiD0Df7eJQSBVyvorSPipiR+aHAmhSOEoLO60rZfLKldo4HFPD7xy+FqibPgKPDhqr1p+Z4TEIIIcUoNByE3hiFGpEw5rbM/gSNeDyJtFfmUyD4ROilswt2fkLma6bCZboVE3De1pz1sViTHZOZh4PD+S0gGJgWtkT1qX/36oQCv3ld/GvekL4GTxIBkCtlWJUTsWl3QuaIAmtSMBbPPmDUkLRNkQWcnkf/w9b+cpxqSG7NxdttKL2oFxGfnOFZhBBCFhvmD0A0RoGoiKEx6+xP0MjQaGKWzKjGKoNLBkoFJ4vHTIXLKj55DEw3SzntSRyQDyVaa7X0lM93aDMaHksOekPh9LPR7gYBXIitwZaPVwDR2Y8tV0YhGYOwDlHBWzJ3FFiTgpE8AwBPfgm6XDao6vxelg+9eEHyrLXLAJ0jjL5nm+Z1XEIIIcVDCMV6WEMR0Ddqh6hjsz9JA11TCpjpRA7V74RgHF2QcxOihUyFyyxX9cK8M/sq98KQHtyVWIZx4lzNvMc2k+72aFLk4h1K39ZLHpMRsJ5fax2VIEwprpaJUqqASxzO0ae1GCpZpiiwJgUjDPalbOvomdv66qmCYT1co1PbrjCgw4pS8/PzPjYhhJDiICmxwJopDN1DToxtCaFks2H2J87T2e7kAmbBgTLAHAR4FlWSCCmwTIXLmF5G+ceP53QsfjqRZh0O6dDvym8qeDjIoa9OzFK7O/j0+rdx480GcBZ7UD1aPmtPawiAXBGF2dAJFvFqNGKy3FBgTQpDVaDzpt7hPzHn9dXJzrZXJ29ot6Fqe/ZrhgghhBSvyIQMR9UYEBShRkVEJRNeaxnCgz2tKLl49t6189E95Ehq7xjssALgMDBaZ02KX6bCZSXvboKuKpD9gWRAPpJYujcymlpILB9UZ+LvO+oH4Ei/DCTaH0HIthYAoDSWg9+3Hmws/Qx3/DlVMpioorT3Ua2GS5YZCqxJQZh8B8FGdUnb5KiIMxr1P3zt1Nqk+hO8wwb79mG4GqnfKCGELHajDT5UbRmE6jIiEDTAuk4HReWIyCp+d6YFlitmvoCeHwbvRCK1VHaJEHwijOKJPJ6TEG2kK1wmVfngfFduy+WELjMwpUJ+xxw7uuTKKyeHLrLZlmFPYLwzUdxM7XJAvnc72N7yjGuulTIZXOSwB/ZrMlay/FBgTQpC8vQCipi0bWzMBq1ekoMuG/xT268EdGBRBu8xKkpBCCGLnbspgJJ1Y1DGTPB6jfAYIkmPP3iiDeqlHIKUn3XXw1OWG0khBaJfgF7XkpdzEaKldIXLHLe2QjDktpRBPZ4cSJ9qrc6wp7YGh5PHGY5mbqcV7gwjZF+V2MAFyC+thvqzLRC60jxPAOQKGXrzOPRu+nsmuaPAmhSE2Nebsq1d42qS7dPWwbF2G2rWUmBNCCGLna8jAOsKDxSXCeMTZpwZHU/Z5/HT3RjZEoTeqv2lTvdgYm2pSZDBfDqqDE4WhXSFywzrU/9+ZsICApSGRGAtR0U09+a3Ivik3vYo2JRChb5x3Qx7A+6B1HXf3G1C9LdbgUdWgvmnzYBXxaazywaopzXJHQXWZOGpEehC/Smbj53TZn31pENnprfdsqP8wm4okSzbSBBCCClK0bEg9JYI1KAO4wE7zvWnr3L8WvMQzlSNw1KpbWr4ue5EECEIgOwpBbO6ND0HIVrLVLjMUOfO6TisxYqpIcTQsAMZq4hpTJEBXe2UAmadM+8fPBdGxJZ+Nl05WQn5nu1g44n3B/l8OriFNQAqtWkluaHAmiRhLACD7lfg/ofydg6r9wUIfckpONGI9nc7GzoqEQlNuZPZbYG5fhydTw9oeh5CCCELiwUCEA1R8KiIMWHmSsSNvW7sEfrhrNOuqFlrbxlUJRFI+LtLAKMMHe/U7ByEaC1d4TKxNADRHsnwjPSUw1VJX79waOO8x5YL2ZL4Ww6OArBkTgcHgPHhCoTsKxGyr5ry//P/GevAj1UmdhYBuVyGqI/C3v9inr4DslRRYE3OU2GyPovS8o9DGDwEw9g+CGL2vQxzIQ11AtN6VY+O2qH93U6G3in9RhEVwUeMsASp7RYhhCxmQvh8D2tZQGNg9h61A+NBjJaGNDu/CgF+X6KOR6jbDEQYzBItNyLFK13hspxnq10S1L5EjQHvhAnHmrXNOJyNJ5z8tWrLXMAMAAJnQxh42YSBl41T/p/4b+z4NUA4cQ06mQ7udL+g+djJ0kaBNYHOcBol9n+Eo+RnYIetWOX2o8Y7AaX/13k5n9TXk7KttVubauDTHT+3Iulr1m5H7Y6TeTkXIYSQhSEpIUjGKLgs4Km28OxPANDp1rY37YgrcTHPPQyiX4BRf1rTcxCipXSFywzr3Lkd5Exyhsihk3VYqDTwSf390wqYYfabazNxHxHBziW+L7lMBhc4jMY+iKHU1rCEZEKB9TKmerpg9n4JFSu/Ckkeh/RCKZyhMFyvr4W/YQXKRrsgcm1bDhh9r0McTt2u9frqSQcbVkFREi9z3m5DyQUDGG/OoVcjIYSQohEci8CoD0AQVESDBvS6spuJPjfggajXLgDoGUxciBsUBYJPgGhKvXFMSLFIV7hMv9ad/QFUQDmcWK8cjYh49uAGDUaWm4HuKERLorOMf2J+yzx4UIXn4FXAZAkeKZYOzgSO0h4qYkayR4H1MqTKCoTj30Htts/AeVEjwscqYD+pg+QX4T62GmJEghgRoesxg7U/Bsa0S5/TDTUl9T0EgGhYQvtAaYZnzE9EkTAyPOXuar8ZusoA+h47kZfzEUIIya+xBh8qNw5D9RgQCBuyfp6scNhWzlxBOBetUwqYGSUF8JkAqwfgubUtImQhaFG4TOg3gHsTf3NNLbWIKLMXBnSu10Nv0TDk4AxidWJd9dBpBojzO/7IS04IfYnlHXJlLB3cFjkyr+OS5YUC62UocvQAqt9zGAAQfb4G5WNhBPud8J+pgThl7bM6YkXFmAts4i+anVvsaE/ZNjyS32qSjVN7K3IG3mlF/c5n8nY+Qggh+eM+F0D5xmHIY0a4gjMXLUpRMvsu2WrqrgCf0mQiPFgO6DiMjJYbkeITPD6UUriM6WXoanxZH4OfSEyCcJXhsVe3zPocS6WEv7k6scfcD9vlOkgGba73IoZEQB/1AmpF2Qx7z44HVPiP7oh/LVfI4IxDZ/LCNHpiXscmywcF1suQybAH0T4rdC+WooT7MX6mFnJXCYRpwa0AhmhLBexdByBJ8+/PKYW7YHD7U7a3dOVnffWkV0+tBZ/yWcI67Ki5th3Dxyfyel5CCCHa83cGYV/jhjpqQstYbm20JoSoZuOIKBICgURg7291Aipglg5qdg5CtBI6PZiyTb/WAybyNHunEWGQjyeqZ/f3l2LYPXPRMCYAHRUT8ASiGJ0I4w8nW3GgdBiOS/UQpPkF2OPTLie9Ifu8jgcA/Q+tA/OcTzGXAKU81m7LOUyTMSQ7FFgvM0owCseWVthPSzBwGa6ja8HcZjCW/g1OVAWIrWaw9j/N+9yGwRNAMHUdzNFpBca05vKaMeGxxL/m7TYYN7rR9+jZvJ6XEEKI9hR3AHpnCKrPgLMjua2t7PWn3tydjzGXNf7v6LAewoQIvaFJ03MQooW0hctySQNvtwBKYl3zswc2zfoc66U6HGgdSdrW7wrg/tMtOFY9ipJL9GBihifPoqc7ucf0wGkJyHAtmy0e4JBPr41/Ha2MncPCmpA0Q0NIBhRYLzOhfQchhhgUrxHu19dCDM9+t1+cMMDe1Q0De3Ve52ZNzSnbwiEduoed8zpuNlo7p/QoHDOAu/XYdPmzeT8vIYQQbbFArNWWGhHRMJpbKnhT/7imK4/6hpzxf0sBFeKECMEyoN0JCNFIusJlhrrxrJ+vvp6oKeD1mHGyrWbG/R1r9fjzmdTlf5O6Rnz4XUMLzq4aR+mO7GslTHINKZCciWvY0BgHr5j/Wo/e310IRGNvEnJFFJxxiIYwzCO01prMjgLrZcZi3QtxUBdbT82zu7pgjIF1OWA89RiYMLe7/UyZgMnrStk+NOxIs7f29p9aPXU0QKMTK25oRt+r7gU5PyGEEG0I4UCsh3VUxPER0+xPmMIblGGr0a6AWVtfYl2nSZTBPHrAEgCDtjPjhMxHpsJl+ixnrJlXgNKaCFoPnFg74/6inuF1cQQRWZ1xPwA4NzCBxwe7wOYQkQgVyTfWfKoz94NMEx3Wgbee/7vWAUrp+XTwUeppTWZHgfUyIrtDcG5vhdhvSFlPPRuRM+CsDqbhh+d0bsPQcQjB1Nnx5q7KNHtrr7W/DKFAImWQn3WeTwdvXZDzE0II0YZODUMyRhEJSnBHcs8j1VVqd+nT2FkRzxAVBCDQXQkIgJkd0OwchMxXusJlAIdhTeosdlqHyjGZ6hENS3j28MwttoSLGBp73VmPb3QiDGd97i2zglLy3//QWW1umg0+eAFw/sclV8UCazM7R+ngZFYUWC8jgT2HIKoc8ph19p3TMIZFSA2noeOZU3syYSfPpN1+9Gx++lenGQG6e6dUjOw3A34Jm698HpzeKAkhZFHwDYRhFCMQ9VH4fbmnjwJAQC/PvlOW/CEDwlNqh3jPOYEoYNId1ewchMxX6Ehvyjap2g/BPPvfgjCoh/xaohZOY0st5BlabJVuMeCvJztyHmOwJPe/y7Fp9wV8fRy8bP6ZkP6TFWBDZgCJ6uCiIQLLMBUmJDOjwHoZsZXsgzgoAYHcqqhOpevWw9L0RwCzp/fEcRUmb+qas1BAj37XwqSCA8DrTSunfMXAG51YfetZdD2TWtCDEEJI8XE1+OGodgNRAeP+uQXWg6GApmMaH0/crObjEsQJETpji6bnIGQ+WEtXyras1lfLgPJwHSZnq1WV4fEZWmwZbAKe9/RiLtMVJ0eyX+89qbsjtcp/QNKmp577qdisPNdzKCWx3vSOMUoHJzOjwHqZiPR74byoDdKgAcI8qiZKjEE5EYbdm33rAWmkAbpw6tvs4JSiLwvhSNNKyNHES56fLYFp0zj6Hpt/KzFCCCH552nxo3LjMBSXAf0TuaeOAkDzcJbpr1nqH0m0+TFwFaJHhGAZ1fQchMyV/1AfjELq+upsKoILR0qhDie6qvT3lWLEkznr0bsxit6xud24aupzw1qd28SPz6NCV5n8PjDSNrcbbtON/G0jmD+Wai5XxwJ4s9BC6eBkRhRYLxOBF1+HJMqIjlpm33kWZpmDHzkCScmy8unhU0hXhvXcAq2vnqSqAoaGptzJ7LUAEQFbr34BqpLDDDwhhJCCCPQE4Fg3DnXUjHb33C6gB8aDMJXOscdPGu1TCpgZJRXKqAXcHIXIqTo4KbzgU+lbi85WuIy5JESfW5207dn9mVtslew04OmG1JTzXIir5jDxU5r8PuBu5YBzbksekwkI7o9lOkYrz1cH10dhHdqnwbHJUkWB9TJhrzwIcUgHHpjbHf7pDL1RWJsfympfkzv9WpvXmxZqfXXC6ZYp7SE4g3rWibW3nUHbwyOZn0QIIaQoKBMB6Cp8UFxGNLlya7U1lSnHmbGZNHYm3yT2nqsAAFjE+bWoJGS+FH8U+vHBtI/NOGOtAuqjawCeCBMm3Gac6kjfYstaLeHRrs55jDSmPeTN+Tl+pN4kC5nK0uyZu6E/7ABkxKqDl8XWgDtcL2lybLI0UWC9DIRaXCi5pB3SsC7rFluzERkDPzoO2/hzM+7HJvpg5qGU7UG/AcNumyZjycVrp9eAq1N+BmedMG91YeCpvgUfCyGEkNwwfxCSKQo1rMOpkbkH1lGrdllKLq8ZkVCiGnGo0w4WYjDqT2l2DkLmYuKRJkhi6mtdsESgq8ycsi2ctkPtSq6Bs//4utQdGeC8VI8nwt0Y90fmPd5DbcPQW3ILTYbHUr+/0R5t0sGj4xYo52KZjtHz1cFNQiugKpocnyw9FFgvA4EXTkA0RBAd1iI1JsHIOdTXDkKSM8/28r1HkO5l1r/A66sneQPGpEIz6LIBKsPWq1+BHKI3SkIIKWZSJAjRGIESFtE0PvcMrBE59YbvfLg95vi/xZAA0SNCMqUWjCJkIanH2tJu1691Z3wO8wmIPrE2aVskLOH5I/VJ2+wrdRjcEsB9p1vgCaQWEZuLqMJh3ZBby6ye9mjKZeboGQ5Y537jbaqRh7YBAOTKKLgwmQ7+mibHJksPBdbLgHPlYUjDOnCfNmngU1nGIzAd/1PGx41D6Sujnu2o0nws2TrXPuXcKgNvcmDdO0+h5Y9DBRsTIYSQmXHOYRTDkAyxVlt8HpcwHeMTGo4MGBxJzO4ZBQWCRwKsbmBO9ZEJmb9QswtGNf3r3LDOnf5JHOBPrgKiiaUSXAWe2bsNshpLuRYkBssVEv7X3Y5DbdovoxuWUgutzSQc5NDXTAuiOUPEXq7JeHwnVwDDBkAC5PLJdPA9mhybLD0UWC9xgaMDcF7aAd2oCJHP/OtWFYahwRI8+8o2dHZWZHV8xhj0TUMwDaauOeFBL2y61OqrqsKw//TqlO0LZd+pNUlf87MlsGwfw9Bz6dchEUIIKTxvTxgmcxSiMQqPd36zUa0DE9CZtLsE6uxPFMaURI5gjwPQqzCgQbNzEJIL3yNnkKkJTKb11UKLBcrZxPpkzoHnX92GF4/GZqtLNujRtNqNB0+0IRTNT9HXg13DYDnWFlTsqRNHY4PmNHvOje+VVQAAuep8dXCpDVBz77tNlj4KrJe44J4GSJYwosPp1zMrioCBvlI89eIOfO0/34p/+90NeOrAZvz28UshR7N7Z5MASC+/mpISrr60P21rr5ERB/whbda/zEXPiBMTU9L20G4DRI4tu/Yj4qM3SkIIKUauBh90hgAEUcHYxPw+Q1QOWFdoV8DsbFfyzWhfYznAAbN0ULNzEJItVVEh9WWu0J0uFZyFGOS/1cW/5hx44dxG7I9cAGu1BOEyhvt7WnC2L/W5WhqbCMO5PrcMS6+cGs4MnwRg0iZTc+Rv2wAZkCtkcIFD0MmwDb6iybHJ0qLdpwopOpxzONcegzQqQZ0wJNVN7OsrxbHGlXj11FqEo6nrWdx+Mw4dW4err0ifyj2dOSoj+sIfId/yGUy21jL2ngXS3DA8dW7hq4GnjKFpJa65ojn2hSKAn3Og/r3Hse++AVzwT6sKOzhCCCEpJloDWL9iBOqEHt2e+d+c5c75j2lS/5gdclSEpIvV6lBHzRD8AvT6xlhVYUIWkPfpNujFDOueBRX61Wl6ub9Qk9Q55i/HavGlvXYA568Dx7UfZyYBZ25/NGcbI7jMKkANJ2bRuQJES8qhC/bPezyK1wi11QFhswdyhQzdkA6O8Vfgrb1x3scmSwvNWC9hvpe74bi8E/pxBlFN/Kr9PiN++Ps34IWjG9IG1ZP+smc7/L7s0+1sw8OQTj0LAFAjYdgNrpR9VJXhleN1KdsX2nOH66FOqQ7OG0tgvXAUoy+MFnBUhBBCMvGP+eGsG4fiMqF1fP6BtRvzr2KcwJIyoUQFECZEiGbqOEEWXvTV5oyP6VdOQNAnp3ELvQbIr1fHv37iZDW+tLdwkyCnRlOvH2fiHVeB9akFet0ui1ZDgvvp9QAAuTp2w8IkdQCKNkXbyNJBgfUSFtl3FnpnENGh5DTwxpbs3ixVCHj0pR1Zn09gDNZT+wFvH+Q9ByCJqUVbxkbt8Ia0qdQ4Hx6/CcNTK5O32QGDgk27DiM4ouXFFiGEEC0EA14Yar1QR404Mzr/z5Fur0+DUSUMjdrj/zYJCuDSA1Y/wMOanoeQmUSH/DCGMgem+jTrq3mjM/7vlxor8c8vrczDyLLX1OeBtSa36uANrWpKVDN4ggG6HBdsZ+Dasx7wC5DLZHDxfDr4wMuaHJssHRRYL1FqREFJ3SmIYxIUjym+nXPghWktE2ZyqHE1BqYUZZmNgXMYnvgjDN3pC7acbi58GvikQ6enFDGLCuAtdmz8wFE0/W6gcIMihBCSlhL0Q2cPQfUZcHzENPsTZtE04M65SNJM2voSRZ8EAfA3lwIiYBYOaXcSQmYx8b9nIAiZq9Eb6tIUle2I3RTa31yOjz9bHMvhhBxj++FeGboNyRNJSghQKrIrxpvFiBA5VgmIsdZbAODw0DprkowC6yXK+2wbbFd1w+hRIUQTKc/jYzYMutIXMsvkD09dAlXJUFoyDUfUjXJjaoVtrgIvF0Ea+KS9J9ZCjiSuqvgZJ+wXD8G1l9LBCSGk2LBwEKIxiqBfD3dk/hFxMKzAVpvbrNhMjk2rHxJqKQFUwKQ7rNk5CJkJ5xxCc+eM+xjqpi2WjjCoA1Ycay/Fh55cg8k6OYXWHsy9JV5zmq6pHm9qivhcjTy8BeBAtCq2BtwkdVI6OElCgfUSFT3UCn2pH5FBO9iUytzHGnO/E9k76kDD2eyfxxiDkOaN2eWyw+Of/yyDVmRVRGf3lDuZrU7AoqD+8hNUHZwQQoqMJIchGSOYmNBuOZFYrl0QMTZhQdCfWPut+gwQvAL0hlbNzkHITPz7+2AQQzPuMz0VXHDp0DFox7sfXYtiCaoB4HD7CPSW3MKUruYo9OuT11UPnBQAUZtwJ9hWCQwZoJTJ4BKHoFPg6H9Rk2OTpYEC6yVI8UdRUn8G0rgIxZ0opqIqDC8cXT+nY/7h2YsQDs3vzn5DS828np8PLx9dl/giLIK3W7H59iPoeHQk85MIIYQsKK5yGNQoREMUYxpUBJ/k12l7E3VoxBH/t55ziB4RzJJmGo2QPAg+e3bGx0VnEJJz2pr/QSP+2lgGXmQhQVThsG7I/bqzJ5jc8Cg6AagVZRn2zp3v1VWAAETP97S2T+zV7Nhk8SuuvyKiCe+TLbBd2QuTT4EQSfyK+/tLEQzPradfOKrDi/u2zHlMXAVePrZu9h0X2OmOagSmzjA0lMB5ySCGX1nAvhKEEEJmNNrlh1mSIRmiGHJrN2PdH/BrdiwAaOkuj//bKKmQB8yAOQIRdLOW5Jfij8DonvkmjmGdO2Wb2mPFo2321J2LwJAYzPk5Z0+EoV+Z/B7hDWv3/cV7Wp8PrI26bkChAoUkhgLrJUg52QpjzQSi09LA959cO6/jPnukHuNjc1ur4h63wuVN09S64BjOTqmSzpqdYI4oLGgv4JgIIflgHXwNdWc+hYqWX0MIuws9HJKDvsYJlJUEAUVAl4aB9bmhNP1852H6Omv/uTKAARZhn6bnIWQ6z1/OQhTVGffRr3WnbPM3lqPHN7dJl3w71D08pwKDI7rkrJbugyL8VXWAZf7ZLorXCKXZAaVEgapTIUgKHH3Pz/u4ZGmgwHqJkSfCKNvZAHFcRNSVCGSjYQkHGlbP8+gMDz17MfjM79tpnWktvjTwSc8d3gA+WUAzKEHttmLLba/D1z/zOiVCyOJh638JlYZ7IF/dD4f9OdR3/xNWnvkmTKPHCz00koXRFh9q68eguAxocmkXWI9OhGGpkGbfMUv9Y46kZVPhTicQBQy6E5qdg5B0+InZJwQM09ZXsyBD+7ny9DsXgbGJMJzrcw/6T7wegq4i8TwlCLQ8q8Pp11fDU7IeKJlfQTPPM+sBAZDPFzGzT7w2r+ORpYMC6yXG+1gzHDe0wxyQwcKJ23xtnZVQNfh1N3VXoK2jOqfncA68UkTVwKcbdNkwPpaolM4bSlBzTQfaH6bUPUKWAnvvsyh3/hyhiwNQyhQErvQjsjEAs7kZqyd+iLozn0JZ+4Ngcu5ph2Rh+Ef8sKz2QB014cSwdoE1ABiqNOy5BWBkSj9rISpAnBChM3Voeg5CpgqeHYUJ3ln3m164jI3p8Xq/dlWz8yHgzL0OAlcYvCWpWZJKmKFjj4gTr9RgxLgBvDL7drJTuV5eD/hFyNWxdHCToQdMDszpWGRpocB6iRH6T0FkCqJDVghT0sD3HM2+d/Vs7n/qYkRzaHUy4bZg2J1bi6+FdvTMlKrnzQ6Y1nvgOugu2HgIIdpwdD+B0hX/hfCOYOITTwAi6yIIXOmH7JShN3lQjsexuumugo6VZBYZ90NX4UdkzIhmt7Zpq2GLounx2noShZKMTIXglgCrC0Dm3sKEzIf/iaZZ92E6BfoV04LvAROe6Sju67OTI645Pe/40TBEW4ZsFJWh7yDDyecq0K9uBByW9PtlJCBytAKKU4FqUMFEFc7eZ+Y0TrK0UGC9hMiuECrfcBKmESAymrgD6fca0TS1rdQ8efwmPPzcRYn06Vk0FnEa+KQXjtZDUc7/OXhjF21Oe1sBR0QImS9n18Nw1P8akfpYYRlhRAf1x9uAh9ZA2F8GjBgQ2hxGaHMQXOQwGIZp1rpIcX8IkiEKr9ekefXi4bC2v/OTU+p2SAIQ7rIDBhV6tGh6HkImsYHRWffRr/GAickXbtEOO/YPFmP9m4Rz/R7YanKvDh4OckRXzR4wD58CRqO1s+433cgj2wAkipjZfPtzPgZZeiiwXkImHmuEeeMITIoMNqXdwJmW3N8wZrO/YS0asuiJzTnw8vHiqwY+XSiiQ19fafxrtdOGrbcdxegZXwFHRQiZq5LuP8K2/T7Iq2IXPcwtIvo/m8C9BihNZYg+twbR+7ZA/vGFCD24Cb6uCoSDRpi7qXVKMRJDIYiGKFwebdPAAaBtbELb4/WXJmV1Bc7FZrDNIl14E+2psgK9PPu1yvQ0cHCg/2g1iql3dSZs5dyed/xkFIJh9lCndz/LOS082FYODBoQPb/O2mjoB4vMno5PljYKrJcQi34/dKMivF3l8TRwzoHnD2uXBj7V/zx+KdyumdfmeCfMGHQVd5rRpH0nEuvAeasdVVd3oYv6WROy6JT1/AaWnX+EUhm74GF+AcrvNgLBDCnEQT2ULifCPSXQdVHwU2xURYVejUDUyxh2mTQ/fuewD3qrlpdDDGNjiXXW0WELWIjBZHlVw3MQEhM8OjRrNXAAMNQltxFlfgEnWoq3cNlUvZG5tcXzjqvA+uzWkPf3V+Z8fN/eVVCdClSTCiZyOPueyvkYZGmhwHqJiA75UXblWdh5AMpYIq3HNWrP2/pmFQJ+8ZddkKOZ11s3teVW6KyQDjaujFdzZZ02GOsm4DmmbSsWQkh+lfX9DMbL/gbVGVs3y0IM6v0bwN2zB2R83ASzbTDfQyQ56j7ng+V8D+veMe0Daw7AskK7yuAA0NGbWGetVwDRI4KVD8KIo5qeh5DQsb6s9jPUJV/PsBEDXupaHBMfJ/vG5jyx3tCiZox2dFUGCFsd0K80YqSBQ6nN7Zp15LFYT+toTQQAYPcfnNsgyZJBgfUSEXjhdRj0YYRHbBDVxK/1aGP6/BlLhQSDTYAgzS8FaNBlw6MvXJhxvfVcqoEbHSIMtkK8NAW0tFfF/unXAQpDZU0reLaLyQkhhaUqMF76DLjl/OxNFOAPrYM6lGVhGs4gSir4UE/+xkhy1tXghc2gQNDJaB/Lz3pQxa7t+/zp1sQFuoGpgEsPMKDE/gtNz0MI78ous06/xp38vD4znu4s7orgk1zeCOwrc19nDQDDfTJ0G2M3EJieQV9vQXiTA2f1Vjx/muGll8PoiMSymTrPOAAh++viyZ7W0dooODgMxiGIobkVWyNLAwXWS4RjxSuw+SMI9iXWiCiKgBfTVAN3rNHjwYk2/DnSgUfETjxl7sar5QM4vmIU59Z50LPZh9JthqzPvfdkHZrOrUjZ7pswoXfEmfP3om7i2G8bymkMWnnxyIbEODpt2PS2Y+jb617wcRBCcmfyHwU3nw+qFQAPr4HS6cjpGErAAHaI0vmKyVhHACWOIHhERONYfj4XxnlY0+Od7aqAIscusRhjCLQ6Y/8uH6BZa6IpKTB7Zp1U5YNojSZt8zWVwi9r22oun4SquU8Ene7gGFnpwP4xI57br+DAq2EM9SbaeLU0RKDbZIW3iyNcnduCbs8z68FNHEqJAiZwOPuenPM4yeJHgfUSEO6ZgGN1P0QFYIFEOlt/XylCkdQ7fN7KSNLXUYXD5Y2ge9SPpj43jnWM4aSS2x23/37scnjcybNCzZOzvzkw2EU809yD3rEAftvaDOFyQGdauJdp+0ApJjyxGRHeakf1VT3ofWb2apuEkMIzq+fXR6sAe7oWytmymZ+QhjJuRIlt9tY1ZOH4BoKoWT8OZdyIY8Pap4IDQKdb20KVKgSMT6lBEmg9XxyTASX2X2p6LrJ8hTs90IvRWfczrHMnb1CBUwdSJ0SK2SgPzfm5gz0yzhwLIxzMnJlyuhNgEkP7QRNgyH523PXyesAnIlp7vjp48Micx0kWPwqsixFXYMa+rHdXTz8LixyBr6ssqXf1vpNrU/bVmQS82No/6zGPdYyiZHP2vUJVVcAv//eqpPXWr5zIPQ1c3Ax4g4m7iI+c7MKxilGUbNS2b+lMTjXFPmxYpw36ugn4z2hbMZYQkh8GY6ydEXu5EvLrc6zv4DLCXD2B0NjcL+KItsKjIZSu9iA4bMbEDDU95uNcv3veS6Om6+pPdJpgHj0E3/kZ7PJ+GHFc03OR5SmwP7tlK7brupK+Zh4Jr7aUZti7ODUOj8++0zwM9shgG+0IuwCfI5dZawHho5WQK6PgIofeOAIxMJy3cZLiRoF1UeJw1v4QIs+uIIWj8iisYhCKK7H2LBKWcOBMajss61YJE4HZ724CQIcht7YB/WMOPP7iDnAe653dOZjbm7bOLODZ9t6U7e1DXtzf3QLD5QJEff7bQrx0dH1szXhQAiICatc3Q4nMXnGTEFJYgm0UwhEn5L1z7M0CAGCAIsD7+EuajYvMj+oPQV8WgCfbtfJzEFU47KvmtoYzk4b2xM0dI+cQJs7fFGCATXevpuciy5PcPDTrPoItDMvlyRMqbMSAx9rtGZ5RnDqGfTCXa1tkcLojJ6IQLSI69uoAW/bZMaOPbAXEWE9rJgAl/U/kcZSkmFFgXZQYpHGGqvIvArOs+wp39cNudyEw6EgqWtbWUYV0v94T3uxTvF9pGoRjbW4zxS+fWI/mlhq0dOSeBm7cLsLljaR9TOXAn092oGmVG866/M5ej01Y4PfF3lDVDhs2vuMkOp+idHBCih23BxF9bvW8j6MEDajW0zrYYiFGYz2sR7Ko7D4fPPeVAzM61VYFVYndDJYYg3IuUYFZt2oQ7gMva3tCsuyI47PP4tpv6ATTJU8OyF1WdHkXLhNQK8aV+V0T7nWrCK2yQgkB4yz7VPlgezkwYIyng1tD9PmxXFFgXZQYjGeM0HmDqLZ+ecY9df2PwsH8CPU7k7a/9Pr6lH2d6/Q40TWW00hGynJPh/zvv12BJ/dvyuk5op7hhe7ZZ+gbe914cKgVtlptZxam6+6LzbbzVgeqLu/BwItU5ZGQYib5z6c6Ruc/o8F7rSjd3I/gSPobfWThRMPne1ibIhjIQw/rqY65tb2BKitSUu0RX0MFRFdi1nrtjt+i+SFq70bmRvZGYGCBWfez3dSesq3vRO6TH8XAo8//e/Khg2HoKvToeo2Bl2Vf/NK3dzWU8z2t9SYXJN/syy7J0kOBdVFiAAQYmowwBrtRqvtpxj0dpmbwiAghmAg0/V4jmnsrUvZ1l+b+hvRcYy+s1bldqMqqmHPvbOsFOgyOB7PaN6pwhFcqOR0/V6eaawEArMsK/RofIm20zpqQYmaL7AEb12gGxqeDvjSI9j+0aHM8MmftDV6Y9TIkYxT9eQ6sG3rGNa/n0TMwZUmUxwR9e6KqufmCUbAjL6PxN9kt+yJkqsC+HrBZVscZN4/CsHra9YsM7HkldangYtA6nv9rMTkCjFhNgMowOJ79DYiRv22J9bSujYAxoGSA0sGXIwqsixKHx3cJGBj0rQbYQ3thZc+l7KX0HkWJeRz+rvKkN9fG1tqUffUWAS+15v7hragcgdX5DWIFCXhlcCCn57zY3gfJkL/11kfP1cZS+EISeFDEyh3nEBrPbm06IWThGfRngCHjjPtwFWg8uwJHjq/DgSP12HtgI156bQuefXk7nnjhApyeUpdCjepQE30t38Mms+g644VFL0MyRNHtmvn3q4VBa3Y3eLPV2FEZ/7chyhBucSbNWl/+7afh+n0PTv1nt6bnJUtf5PTs2Q72NLPVwrgOT7Y48zCi/DvTOw6dOf+hy4lDYejXmjF0DFCrUyeq0lECRijnnIjWxHpaWyPH8jxKUowosC5WJ92YiO4EA4OhS0K5/wHoePIbpLHvRRjFcFLRMs6BF46k9q42bZGSqm3n4pmmHhid+VvX4rhAj66R3FqduLwR2LblLx08okhwjcVm3dUOGzbedgodfxvJ2/kIIfMjWgeh9lln3OfQsfX4r0evxB+e3YmHXrwQf31lBx59bSueOrgJz7++AX968QJwNXbDTnUZsWprO3wD2vY3JrkZaPbDrlcg6BS0j+V3xhoAXmzqg7lUu8+74y218dcUYwyhrrKkWWvTBaOouaQT3of7cfzfuzIdhpBUgzMvXWCmKKzXpFYN50NG7B80p3lG8VNUDtua/BYwm9Tmi70PdLeWYtbUgPPGn9oQ62ldqkBv8kA/0ZHPIZIiRIF1EVMOe+HHVgCAYTCCavfPwfj5u+ksjBJLO/z9Tog88Qfvdlkx6EpNw57P2rFgWAHLbcl09hhwYHxubQlOBfK77rm1O3aXUm21o+LyPgy/lt9WD4SQuWMOL9SuzEtQurvL8ccXLpzxGN6AMdF7uMsG6/YRNP+O1skV0sRAGFZTBOBAk1ap/jOIKhxsg3bZUKGIDl5v4oaAEJQgtzsSs9YCcOm3ngZjgO+JAbgate2nTZYmVVFhiM7cucV2bTcEU+qEirfZidiSw8UpZMtvFuWktsYodJttcLdyRGqyK2Tmfq0O8IqI1sQyHJ0DT+ZziKQIUWBdxBiAyEEZQWEdAMA83oeqsf8BIEPofgEOoxvhAWfSc042pbaZcdbr0dAzv6DwudbevKTflF5gwLl+z5yee6xjDM51+bvQev1s7GcpdNmgW+WD0ptb+zFCyMJgES+4XgH3pE8VnnCb8dM/XY1sLibPTrZICosQTQr0nY0ajpTkKuKKoHatB8qEHn3+/BatnPRK9wAEDSfF+gZL4v9mjMHfXp48a33hKKp2dkJkwIm7W7U7MVmyQieGIIoztwFNlwYOAKf2z6cdYeH1BP0Ldq6TbRxMx9C23wKYDbM/AQzhI1WQq2I9ra3yqbyPkRQXCqyLHFNUBA/rERZj66YdE6+hVP0f2Eb2QQkaIIQSKWuqyvDC0dRq4GPO3Ct7T+fyRWDarn06+LHg/Kqwukrzl6bZ0leGSEgHRERwv4Q1l57FRKe26+8IIfNn9b8C5ksfCUXCEn760DWIKNlFSq+dWBPrYw9ADeqwdedpeHvn/x5K5kb1RVG11o3AsAkLNcvW5wrAsS2bi+jsNHUkr9FMN2t9ybefAQAY3SE03ZdbzRGy/IRen7lmjn6NG8ZNabL6wgx/2bO4A+uTPWNg+e26FTfcJ4NvsCPs5nDrsiv4NvLwNkAAolVR6Exe6N1UBHM5ocB6ERDCMgInSxEVYne9yzpfRrm1G76ucrAp6z6Gh5zwBpJnbAw2AS82a5PKuKe3H4Kk3YVN6VYDTnbNL537heY+GGz5ehkzDAw5AQBquw0bbmtA+yNzS1snhOSPSTgKjKTOVqsKw+//dnlOXQr6XQ74z6fu8m4rSi/uw7nfUjp4oQiRCEzVXrgHZ14/r7VziluzYx1vXhG/WQOkn7U2XziCiotia6wH7utB1De3mihkeVA6Z675kmm2mrl0eKrTno8hLRhvUIZj9cL14D5yLArRJqFzLwOvLJ11/1B3KXifCfL5ntYlg1QdfDmhwHqRYJ4QfOdWQ1aNEMAhCgpUd3Ihl8MNq1OeZ9wsIhjWZj1K71gAjgu0S8U7y+a/ZjkYVmDYnL9bl43tsVYLvNWB8kv7MX54bmnrhJD8kSzd4P2pxXheeG0rTnXU5Hy81s7zlZx7LTBtHIfvMN1QK4SgX4aBRyCaI3C581+4bKoDLcNwrNbm884TMCLgS77xk3bW+uuxWWsDV3HoLkoJJ5np/DNci0gKbLvTF8JTei3wyws03ZtHvJzPvpNG/BMqPFVWgDN0dVQAwuwTTL49q6GUxHpaW9WGBRglKRYUWC8ibNgPz5FaqLIAf39pUtEyOSrglRNrU55zeEzbStYHXEOaZOOVbNTjYKs2Yzs4os2Y0h67YRU4B1i3DdJKP9gYrbMmpNgIdjfUnuRZ6bNNK/D0kc2wVEpw1utReqEBjsv0KN0ye4rvgYY1sX8oAsAYtmxupGUgBdB2cgJGY6yH9fACB9YA4K3SrsXiZPbTpHSz1tYLR8CMAQAAP+3G8LH89+wli0+4ZwJ6MZLxcetVfRDt6R8faCjL17AW1JCysO/Hr+8PQV9vgbuFI1w1e0r4yONbgQhDtDYCyRiA0UXB9XJBgfUiI8oCxk+uRnjQkbS9p7cc8rQ1hCWbDGjq03aG9dzABEp3zH/tWadJu8qnLQNelG7OT1qQ22+Gz2sCogK4V4e1VzfSxQ4hxUSJglsjUPst8U1DLhs+fmAtHpW68KCnDff1tOC3Tc24/1QL/tDVgtKLZn4Pa+ouRzgYe0/hIyasvLqN0sELoOuMD2Z9FKIxiv4F6GE93QstfdBbtLlMau5K7YUrBCVE2+0Qx8/PIBo4Lv54rHe6yIDT32oF5ws3M0cWh8D+1BZaU2VKAweA555bq/FoCuP0wMJ3aTnRzSAYBLTuNQLWmW/0qSE95LOJnta20dcWaJSk0CiwXoTEkAQxnJzKs+9kXcp+w9b83NE7FZnfumhnnR4vN2lbnKXHkL8qkd29sTu8arsN9W9uRNfj8yu4RgjRjsl7HCwiADz2ceYP6HHbn9djwB2GmiYmiSoc959rQcnFM92MY+g6/3fPO2xw7hzExGG39oMnMxpsDcJqkKEzRtC9AD2sp/MGZZi2apM2e6y5NmUbYwyB9gro2xI3ela/5RyYOfZ5ZvJF0PDLmYtUkeVHOTeU8TGpygfTBekfZwEBv301u7ZRxa7fFYC1emH6WU8a7pURrrMh6gdG+ewF4Maf2BjvaW2ONC/ACEkxoMB6CQiHdDjSlPyhbXSIeOlcfj6Qj3aMonTr3GetB0oCGo4mZs+5AZjL8/Mme+L8BZHa7EDZJQPwnqR11oQUC7O6DxhNvB997ql1GA7O/F6gqBz3nWmB89LMwfXrjefT/YZM0K3wo8w4ivEW7d+7SGbu3jCsehmCIYr20dQ19Avh0Ig26+tHPFaEAqmvt+mz1uImD9av64OKWG2UsT/3ITSuXUo6WfyEscyztfY3doBlurIf0aPDq121+0LT1S58CLN/Xwj61Sb07mNQq8tn3NdzaA3gkRCtjUCvGwbUhem/TQqLAusipKoz9yacrq2jEtN/lfpNAkLR3I6Ti+PK2JzWNdtX6vBCo/YBv6Jy8HX5SZk71lwLRREg9Foh1gYg+bxQ8/izJYRkz2BqAx+KzWYqsoDneyyzPCOGA7jvdAvsl6cvUHXk3ArIURHgDGpYwobrz6D5d5QOvpACw1HYDDIY42geX7gqwFOdG5jIal1+NqavswbSzFrrOda8uQm2ylhmmB4cR75C7XpIjOKPQo8MN/gEFbYbOjI+17/Iq4FPNz7DOvN84QrD2XEJTGLoPFsKiDOFUQyhQ9WQK2Uwowyz6+SCjZMUDgXWxSjHmG1Pmt7Vh4fzW8X2ROcYSi/M/WLDVZ0+PVMLr3QPQMjDpLWsinCN2gBZAPfosO4NZ9DxJKWDE1IMBNsIeE+sFZPbl3uv49+fbIX58tQ3DlUVMDAQa3GIThuqdnXBd2Th1/UtZzygoLzSDzUooXNCu44UueoxalMT5M8vXABFSb3smj5rbd/dhfqacXB9rH86a55A/363JmMgi5t/fy8EIf1FlPniQegqMi8BPPt6Vb6GVRDnxgqTPdjTFoW60Y6JLiBYkdqNZ6qRv24DGCCXy7C4Di/QCEkhUWC9yPm9RjT3JhdFca7X49xA/gts7fMMguWw/MxaLeHZxt68jWdgPAjntvzMarR0x37GarsN625pQv9TFFgTUnCcA44glK7YTEzb6NwKXP3xZBuMV6R+HJ48F1sGwtttsO4YgSkqo+1har21UISIipr14wiNmMELeLmyp2kAlsr537XtH3Pg8LF1KdsnZ611XbHPL3GjB0wnY/WqYXDOITDg7L+2USEzgsipzPVpZipaBg785uH6PIyocM71uWGwFeZ9Yd/+MPTVBrS+rAccmbOkwgNO8B4zlFIZ5si5BRwhKRQKrBe5xtbUgijesoVZj9XcPwHnRdkHsoHVMmQlvxcGTXJ+7mAeaYwVqlBbHCjdOYhIG7XdIqTQdL4OcAYgEgt6Tg7NfR3un050pMxcv9awBqrCALcBrCSK6q3t6LyPikktBM9YGBKXUbLKA89gYdZXT1JUDmWtNp9df35xB7ye1O9HCEqQWx1AFICeo+zGVpTZQjCUuAEAplAUp++duRo0WQYG0t/UF50hWC7NHHQzr4gnlkirrUkcgGVNYTJZ5AjQoRqghIHhYOp1+FTel9ZALpWh14/QOutlYFEG1mfOnMHnP/953H777fj2t7+NcDhc6CEVBOfAC0eS70AKEvBaZ+aKkVp7cbAfkmH21EtzmYSnG/N/UXCgdRj2Vdq/0bYPlCIc0oH1WCBUB2A0ejF8nNpuEVJIlsirYO7E3/trvdmtr85kb0/yhWkwrMfYaGw2nA+asP6GczB6whg8RAUM8639lBdGfQSSLQTX2Px+r1rY0zkAUTeHwiLTqBDw4FMXg09b8hWbtS6HNBJ7Pduv7wIAbFg1ClWM3SwffZWWIixnnHPoI+lv6tuu7wLTZV5HGO2wFjTrI1/85sIV9mtpiEDYYkf/YQa5NnNwPfLkFnAJgDUK8xits17qFt1f2ZkzZ/CmN70JX/7yl/Hf//3feOSRR/CBD3yg0MMqCLfLikGXLWmbc5MBw578tNlKp2fUD/OFs6fIyevVvBZTm8pfLefhqAz9AyVgqgiM67H5LafQ/ueFu4FBCEll1J0BhmLp36rCsG9gfjObfa4AnHXJWThnWmti/2i3o+yKPjDGcfaernmdh8yuu9EHozHWw3rYvfA9rKcb9gRh367NTdvGrio0Nae2PWJ+HcSB2DnEjR5AL0MnclSvGAbAwUaX5yQCiQmeGoEkpp/xNF86Q2FFGbjrS9fkaVSF1enTpv7BXB18PQqpVIeze6xAafricDyig9pug1wqwzJ+aIFHSBbaogusv/nNb+LGG29ETU0NLBYLvvKVr+Bvf/sbDh9efkUBTjal9tEbNC5cUD3p6Y4e6C2ZX0pGh4inzy1cCtsLrX0zjmeuGturAQBKhx3r3tIE/0masSakkCRrP9T+2Gymx2+AzOf/dx+pSL4BuPfkWnAe62et2zIOe+0gdP0BuDsW/r12ORluC8FkiEIyRjHgWvge1uk0R7TLVPjtk5cgFEy+iSMwhvDping6ePmNrQCA2lI/BIsPBq7C3UYt35ar4JH0NWqYQYZpa+a6L+6DFXjo0NLoXz3dqe4xiPr5Z5LMVcDHMWQxQwkCHR01gD79RFPgRNX5ddbUz3qpW1SB9fj4OJ544gns2LEjvu3GG28EANx///2FGlZBqCrDC9OqgevMAl5pybzGJl9GJ8KQtmV+KbFNgC+Uj1nk9CYCUZi25lBVLUuHzqwC57F+1pYdIzBEAggM0QwCIQXj9EE9X7isR6Pg67TLlfT12IQFE24LEJAARcCF7zoGgQENP+zU5HwkvfG+MCx6GZIxiu6x4gisD7QOa1LEDADCUR0ee3FHyvbIkA264diste36zvj2+jXDUJmC7mfGNDk/WXzUjvSFE007hjOngYcZbv3YTXkcVWGFoirsBVpnPen00TDErXZ4OjjGdHVp93HvrYNSqtA662VgUQXWDQ0NiEQiKC0tjW+rqqpCSUkJTp8+nfY54XAYExMTSf8tBcNDTngDyelx1k0SAuGFC2CneqK5C0ZnajCrtwh4ri1/lcAzOTAyNKc+2zPxBIzwTpjBei2AI4rSjX1ofnBQ25MQQrIiht3gBgV8PPY+eGZEmwJXDT3jKcFTc2esTQ1vt6F8dze4GIVy1oOQe2HW9wXHIjh0dytevPn1ZdN2KTiiwGKQIRkj6BgtjsCaA2BrtTvevoa16O1JLijFAjoI/efTwesnAH3sM92sV2ByejB+bGlcw5DcSd70GRPmnZmvQ47/bQ16h635GlJRkEsKXy3/lf0R6Feb0LOPIVKbmk0a6i0BD4ngjgjMY8cLMEKyUPLQ9Td/+vtja0gsluRCJuXl5RgaSr/e9Xvf+x6+853v5H1sWlKzaPR8uCG1d96u26twQ93M1Qnz6czD42h6IPmNv/QKA37yT1cVZDyPfr4Lcre2b7hdvWXY4QiA95qx433H8eA31+LHhzs0PQchZHa3X3MKd3xZwuQdtO23XYz7P71Rk2Pv+dEA/MOJm5T7T63BZTvbwdvsEN7TgVU72tB7YjP++91HcKQykvVxd4zpIalAiz0Kn2H29yZnkOEStwF1HNAJgAlA011N+KEzgjHzwtSsKJTdJdXYud0CJir4yJ3X4L3O4qhobIMOv3t3i2bH+81jl+PuTz4HSRebxRIYQ7ihAuzCbnA9R/mNLRh9egsAwG4LYrDFi4988GXNzk8Wh1Io+F51+gy5jIG1X8SE7Ru4/8HC1yjIJ09jFC8cLmy3BjkCvHhKxmUlHKefNqBqix4r9cmfDXKbA0qpD01/egp3P1nYteHFRKdj+J/7ry/0MDSzqAJrh8MBACmzzqFQCHV16dMv7rrrLnzhC1+Ifz0xMYFVq1blb5B5JkdEHDi2HnuOJvfCjAgKttzghN6gfQp0tlZ+xoKTD7lgUGJjUKDiTZ9dgZX1hblbuu1dEzj5E9fsO+bgxLla7NjWA+WcA+W7elAlKGht8kAt3BIfQpalCz/RBowYAMQ6JFRceyEqjQZNjt22awKug4mL2PaBUgT9Bpg6bQBn2PaOBvSc3IAtUREPNnliLb9mca1gw9VWAYwBV44b4I4C7VEZp+QgTquBpPeQHcyMGw1WrNYzMIak7BujANw2rsdPe1wYQOEq4ubbFY4y2EwhcFXA6svWgInFc7kSMsswBrQZj8trxisHN+LGa8/Gt0WG7bAMS4iujMJ2fVc8sK6wBzEocHQ2eRChz5xl5X0VHKhO3S5V+qFfmb5SeGDwzdiwKc2TlphBox8cHEzrNMUcKRERh8aBax0Cupqr4djUA5sucQPVf7QGxrc3YcvKATSfo84Sk/T6RZU8PatF9d1s2LABANDZ2Zm0fWxsLP7YdAaDAXa7Pem/xUhVGc42rcC3f34L/vLyDqjTfnWmzVJBg2oAsNh0WPeORJVy3WahYEE1ALz5jlUI6bVNjT/WWgtFFqCeLYFYNwGjzYcLxML2WCVkOarf5gI/X7gsKpvANAqqAeCGD65AlCXPCHd0lwMqA290wryrH3qHFxYRuE6c/TNlOzPh7VZzLEg+z6kDLjZL+Hu7Dd+3V+Fzxgq8RyrFN8xV+LjdhjUGlrT/VCYR+CdrKSpR2LWF+eIw62AxMphKB6B6zEUVVAPAquu0/Vx7bN8WuEYTn50sIEHsixU2EzdMgJ3/HNNLKpg+gs0CfeYsN5c602eomHemr6vDPAa4+SfyOaSiUb3WgrC+ONYt84gJrwcVWGQjXu8ox9QEVNfeOshOBdU1HjC2tDOOlrNFFVivX78eF198MV555ZX4tv7+fgQCAbz97W8v4Mjya6C/BP/vdzfgl3+7Et5Q+pSeaz9aHHclP3j3eoT0MlRwvOeb6bMIFgpjDKvfqO0FkKoKGB21Q5wwACERm9/cgIuk4lj/R8hy4ljph9oT+/uO6Eo0PbbRLIJNe0s9dCa2/IafLoWwwYPtV5wD5xzXGWf++1/N9PiI1Q5xhskUnQCsMQi42qJDaZaxskUEPmMpRRkKe0M1H1aXWWF3MBhLRiBPFN/N8Ns+swoKtFxmxPDbxy+DqsReJAJjCDWWg4UZoOMoe2OikrDeFMYmcWmn9pJU6+3pl5yYL06fBu4d+wjAlt57QybGlXO/+RZlKgw7BSjQJtj1+8xojkRREijBwf7E0lXFYwY8OrCyKN56AbVrXaoWVWANAF/96ldx4MABnDp1CgDwpz/9Cbt27cJb3/rWAo9Me16PGfc/fAW+f/8N6B52ZtwvpJdx1VsrF25gM9AbRFzwkVJgLVB/oaPQw8F7v7ouZeZpvlq6Yj9rtc2GulubsE6/fD68CCkGBkmB4JCh9sUCa9lZpfk56t+QHNCdaK1GNCwBPRbAr0PNra0QLH6U6oALM8wglkDEJy0lyFemm1UC/sVSjpIlFlxX2UxwODl0JX7IIWehh5Oieq0FSqW2nyvdQyU43ZhYphYdtkMaigULtuu749stliBWS8U1g0/yyyZwOC1pAmtBhemCNJXCXQ5M8Hfmf2BFZO2Vc59Eqb3ZjDv/cAE++OB6KCtV8HneNGMQ0OcxY1RRYBiuwTlP4u81cq4EcqmCd11R2DXhJH8WXWD93ve+Fz/72c9wxx134HOf+xxOnDiBxx57DCxTztyixPD8K1vx9V/cjKPNqdUFpyu/1FhU3/+7P1+Hv78nfWr+QnOU6WHeru1F56EzsYsf5WwJTDvGYLOEsBr6WZ5FCNHKmy/uB5cZcL5vtVy7RvNz3PT3K6AmXWAJ6O0vBTgDbyiB8aoBVFeNAwDeqE+9qDNwhn82l8My5e1HFWRwPteLNg5VTF1TbZeAz1rKYV9CwbVD0sNuVyAZI5AFZ6GHk9aOt5XOvlOOHn9tC/hkvB6UIPbHljeI9RNg+tjvvsweQIWueD7vSf5d7wSENL9y46YxiJZp7wkccLs/tSDjKibv+/I6hBy5p4MHjTL+7t9i16v1FzrwjWcvxrX/Wo2QZX7LCBkXcdojQQGDq2sFxs8XRfAeWgmlVMblmzP3HSeL26ILrAHgH//xH3H48GH85Cc/wX333YeysuKoFqoVJgp44sAWZPPr4eC4+VOzB98LiTFW0LXV0739K2unXSDPT/ewEwG/AazdDpREUL5+AJdJltmfSAjRxG03doO5EoXLlAw1NuajYoUJEUfyrOSR8zfVeEMJhJog6q9uBdeHsNLAsHbKzTXGgX82VSSldXMpik2burFhSweMpS5wIbvCYypToHO4sWZDNy7e0QFmSa0m65CAz5nLYeWL8iM9hZlLsFoUiEYZsqR9AKuFN39yJSJM23WdIx4rRkdimV4CGEKNZWCh8+ngN8UqkdtNUehFmW7mLiNXlGRYX50mDZyP1iDAr8v3kIqOpBPwid9uQkTI/m+Sg+OGr9Sm1Ce67l01+M6hS1B3uw1hce5/40w24LCXw6QacHowVkPBfWANFJuKqloPhCJaZ717cw1KrfSeooWl8Sm8jIVtCjZd4iz0MIraxp0OyFXavoF1dFWAqQLQb8T295zAJt3SLCJESDHasXMUfDC2tlmW9UCeilLWXpac4r2vYTXCQT3QbwZ3GeC4sRMlZbHqrrcaEktfPmEox0pDYoqJi1HU1/fCYpBhNcrYvHoUF+7oQNnKAcAYAFJu/HFAH4SjZggXbG/HtrphlFhiVcq3rRsAN4RSxlqiAz5vqcCVghVC4du6zosUEmA2RKEzRiAbijOwNll0MGzQPkvg0OlE9kV0xA5pKPbZYr++K75dMIWwRaTaHsvFBnv62dOUNlsq4Jr4XP4HVKRWbbLiqjursk7lVldzvOF96VvUMsbwwa+txxdf2QHrLgnyHNdfyyEzTgSjMI6XwS8DPKIDHzICFVHcdlFxrLN2mnUoOWPA9Z4afGzjBty8bQVMtMRxziiwXuTWXG+bfSeCqz+ubXG3g+f7iCvNTpRc1YtSc3RJpWISUswq1nrBe89XBBedeTvP7o/UTNsioOHcCgCxdHDDFYNYVT0GVYii3iCgDCLeK5ViiynxXsCFKNbX98JmTJ6hFhiwqtyLizb3Yt2mTuid41DFKHQOD9bUd+OirT2oq/JAEpMvEiWRY/P6vrRp4aU64P02C/7NVoWP68uxkS3OIlfyhAqTFIVojEAxFUf9kHSu+Yj2a/v3HK+DHD3/+gkmqoML673xdHCTOYR1Es0uLQd6xlFuTe1fLdjCMKwfT9qmDm9AGNsXamhF6ea/XwnzZbPXIIgyFX9/z8ZZ97OV6PEvv9qOf3xuC5y79QhLuc9gj3stGI0ynBqOfWaFG8uglMp452XFsc766vXVUGUOVQZcpyMwHpPwFmU1/m7bBlyzobLATcwWHwqsFzEFHG/959WFHsai8MbbaxE0atd661R7NSIhHZRGJ8R1XphsXlwuUjo4IfnHoasIQ+mKzVJH7fkLvDZf6kTIkPy+8eT+TVBVBn66BMwqo3x3JywlExAY8A+mcuyyJLJXuCCjbn0f7KaZ077tpii2rh3BxTs6sK1uCCVpLqSnMukV1K3rB8+QimwQgR0mEf9od+A7liq8V1pErbk4EBiWoUcEol6G4ijiwPqd1QjptG3pKCsSOs4XyBTAEGoqAwueTwd/U6w6uNMWRLVEl2/LwdUOQEyTgmK+aAhs6k23KMOo74sLOLLi9ZlfbZt1vXXVDSas2pj9ksWKFSZ8+mdbcffhi7Dx/3MgZMs+wGYQ0BYQwF1lUDgwsX8N5FIFlxXJOuvKUGr2SzSgwn0sgrIGEz5gXYdtK7XtvLGU0TvzIqZUqqhaRelg2WCMof5WLdNFGbr7yiCOm8CiDJvfdBbbdNr10SWEpHfp2vFYzbJQLFCUq1fN/IR5cm5Lnhkcm7BgoL8EGDGBDxlhv6ETa6rcUKGiYsqunClYs64vfTVfDZRYwqhaNThrMTS7BOyy6PBVeym+ZKpETZEH2BUOI+SwCkmJpbvzyooCjygzxhgqLtf+M/ilI+vj/46M2KEbjP3OLOdb9JTZQrBKKmVJLQNXOdP/fU/vX62MbIPMiqveTqFIOgH/3/9szLjeOmSQ8fEfzD5bnY7eIOI9X6jD/zl4CW789xqoa3hWrfeiISPCER1OjRkwcbwWqlFF5cqJgq+ztpt0cDfN/BkVGFNwcenSqmWVTxRYL2Lb3kp3kHLx7i/VaVps5ujZ2IeY2m7D6pubUWtUIS3ytY2EFLv33NgFNpEIDpV19Xk93+XvTp0x3fN6rFgabyiBtM0Fa5UbOluiqBhnClat60PpLDPP81Vb6oejegSpa7RTMQbU6hk+byvFG8Ti6w09aWWpBc5SEQbbCNSAAUxf3CnPt/7Tynm355musasKfm8sjZ8FdRD6Yz8DqdYPIDaDyfRhbBPoxvpSt8WRaX118vrcieB7F2I4i8aazTZc/tmKtH+b136hBnrT/G9KXXFrFb7+1E58/LGNMOwUZlyHLUBAc5BjYrgMgAC1xwpWFcbbCrzO+przaeCzkdtVSgnPEgXWi1SUqXjzJ/M7U7PUWB062HdqN1tzuHEl5KgAuakExu2jMFqCuIjSwQnJqyuvHASGY0GHLEvgVflNFb7qtkqEp818HGlagYDPCH6mBEziKL2lDSurxwFwqFCwcm0/ym2pBcbyYV2NG3qnJ+v9dQLwNqsJnzZUwFSEVcQrLUY4ykSYS4ageIq/hkj9hQ6EHdrPOp0+F7txKwAINZWDBQSwssRrymAOYYNIWVJLGQNHdZqbc/o1bkhlwcSGCQOCuHQBR7Y4vPmO1TBdkrzeWl6h4qYPr9D0PCvWW3DnHy7A3/91I9hGZOxC4w+YYAibcc4jIXiqEnKpgnde3qvpWHJVFcnu5lxgTMFV9cW7LKeYFN+nKsmKrk6AxVbcKX3F6J131WnWektWRQwOlgAtdqAsjKp1Q7hQohkEQvJp5UYP1L7zhctY/mdeRVGAYe302Q2G442rAJcRvM8My7W9KLGEwcx+rFg7gApHMO2x8mXr2mEwc2obrplsMAr4mrUCW1hxvWc5JD3sNgZ92TiigcWRlVV/k/avw2cPbQBXY3NEkVEbdIMSYFEh2mOvLZs1hBXS7EWayOJ1qRWQpNSbNtOrgUcnLlyoIS06//yrrQjZYzdGZaj4yE+0b804afVmK+565CK85746KKvUlNlygYs4G1IwMFQC96troZTIuHTTWN7GMxubSYLnXPZLlTZM6XxBMqPAepG64oPFu+6smNVttUGt1S5t70TzCgiyCAwbsfWdp1Cnp2QZQvLJVB2EOlm4zLIw74PbbnGmbHt6/0aoSqw6uLjSD8vWAeyo70eVM7AgY5pu2/oBcH1us+RWCbjDZsd7pVKwIlnGYlIlOEtkiKYIZO4s9HCycts/r5pzO55MXF4zhoedAGLp4GJfbHbauj0WVJXbAyjTcYhF8nsj2nvLivSTJ0n9qzngCb1vgUa0+OgNIj72m42IMAVl1xtQtzX/WTCbL3XiG89cjFvuWYVIRXK207jfCJvfgdaGSqiMoXK1B2IOvbe1dPW6aiiR7N9AAs0yDFQ0cVb0E1pkwqKCHf9Sghs/pG0qy3Ky+x+mt9CZu9dOrYGqMCgtDtiv6IPFGsI6LM4WN4QUuxu3DAMmFdwV+xuLVi5MsZ4bP7wiJXDyhozo7q4AP1MCzgHnTe0QCviJKokcWzb0wl49DMHqhSrMXIl8ksBixc2+Yq5EeREUNmMBwGZVIBkjkKXFMWNdUmFEPupGHTgZ62ktAAg2l0HwCTBvjFUSNukVMEnGJlpnvWRtNqf+DTO9DOPWkcQGtwkRtmUBR7X41G214Yb/U4v/7983L+h5L3ljOb798iW45jtVCOlja+UFVYfWqIKWITuUdjtQHcFtFw4v6Lgm1cjmnPaP+FRcu1Hb1rVLEQXWiwQHB9sIfPb5bbjtH9YUejiL2nXvqcGlXylPaaMzF8GwHqOjdiiNJRDXT8Bq8+FSKbc3K0JIdr75iRNASATOl1FR6tbPuL9WrA4d1MrUO/vPHdoITOiBLiuMlw8CYn5nHgTzzB/ZRp2KddVuXFA/gIsv6MDaDZ2wVY2AmX1QhZnf76r0DJ+zFn7mWnZzWM0yJGMUimHxVKK95H3lmh/zlZN1iEZi6d6RURvEUQmGtYn19DpTCJtEupG7FDnNEkqM/pTtpu0jEPSJm3wRL62tzsZ176qB0VyYKvrXvacG7723Ln5zdsCvg8VThrHXa2L9rAuwztpiyC0NfNIqleoIzYYC60UgpFNwxdcqcdcjF6G0ij5EtfCmj67E1/ftROkbDYjOs93BmZYaCENGMBXYdMM5bNDTujdCtGbSRbHxDQPASCwlVlEEqCsWLnNn3bWpKYRnOqvg9ZjBG0rAbDJKb2jNy7mlEgkVu4HVW1thuzj7glVOSwTra8Zx4cZ+XHxBO1au7wYz+5GpirhFBHYWsgAjBwIjMoy6KCRjFLJ58Sx5etNHVyKs8Y0VVRXQ1hErGMQCEgSPBKk6EWxZLEGsoXXWS9L715VBr099PZkvntJmSwU8kQ8u4KjIXO24ugz1HzpfiyFqxJDM8dr/bodcIuPSTQvfz/qa+ioo4dzvonrORmEz0XvOTCiwLmIqOHQ7BHxpzw688XZK/daa3iTiU/dswccf3gh1DZ9zy5RXTtYBEKB2WVHzxlaUmCIoB73xEKKlL9/WAmVFBHwglhES5VYwceE+wt74sRVp3yOOnF4D3ugEVwHnhxux+q49KLu5CaItuYCZonJEnR4ErD54wZFNiyzBIqD8WhEr61tgnWgBUxWUsTOwXjS3atDlthAu3NiHmrV9Gddj79IVLuOmttQEJcphFKIQjRHI1sWTdijpBNi2a59K/+KRWDs5gTGE25xAWaJKdIk9iCpa87j0cGBDIH2thqTCZWMWRBllMC4WH7q7HlgX+3dHQECgcR14UEJ53cKvs65V5vY+r0Q4rluv3XLKpYjekYtUyCBj9/+twZceugC2kuLu47nYrdpoxdef2olrv1ONoCn39PBxrxmecSvkJieMO0ZhtgWwWyr+NjGELCYfuf0suIFD7bECAKIm7VNvZ1JbZ0HYmnrx88yhDZA9BqDdDqEkAv1Vwyj5p5Oo+/1jqP+fR7Dmay+h5NZGmDf2Y+O6YWzbOIALLm7FyuvccF6ph2BPTU9keoaSq3VYtb0TNn8TmJJ4X2Kco1w8A+PWuQdxVc4Adm7tRumKAahi8jrOtQYB5gK14VpREvvd6ngETODglVUFGcdcfeQHGzSftW7urYDXc/5mUo8d0HHoqyYAACWWMPSSghpW+LXxRDvXbKpCpcGbsl0q90O/KrE95Nu1kMMiGviXP2xDyCAjGjIiqAgYbywDq47gvZf1L9gYzAYJE03Z1eBIpyJIdR1mQoF1ERJEhq+9thPXvGPx3K1fCq57Tw2+deBiVL7ZmHNLrqb2KqDJCVSEULN2GDsMdDOEEK1cvNoN8w4PEGZQe2M3raJltQs+jqpLUi8owlEd2juqwBumFdoSAJRHoLtyBGX/eBqrfvwapH85BemKAYCp0PlGURI5g9Ubm1G9OwLLdgOYnsF5hQGrLumDM9gIIXp+dpKpkK7phfTZUxDr3GCco9rUBGn9/DJjVld4cdG2DlgrR+JrsEUGXF+gG4MVZiP0BkCncwNRCcy4uPo0V60y4arPV845+ymTk02xjDXuM0AICLBuG4o/JhjD2EoFzJaUethRbk+dsU6qBq4AHoXSwBcbq0OH99xTBxVAc5Cj85lNUEplfPCa7gUbw9XrKyHPIQ18krspjEoHvedkQoF1EWKMFazIwnIn6QTc8aPNqPuALaeLo1dProUQkcDG9NjwtjOw6qNF1x+WkMXqW7efhlIhQ2i1AGrsY0tZU7fg43jHnWvT1mR4+sAmqGcd4PIM7fYYwEtl8FsHIH3uNKRLBwFwMFWFaaILlfoGrNnRipJoA8Tw+XW0TIV0+QCkL5wGf+MweIkMfLADYt04GFex0nkOau38WvwJAlBfO47tWzuhc7gBABcbClPLwy7q4KyQYCkdgDxhLcgY5uuWj62CtE3bS6vnDm+AqjKwqADBL8BUn+h9azIHsV6kG7lLxepyC9QWH0zG1BnFpDTwYRsUtrgyOkjMBdeWYf0H7PAHTGh95GIoDgU7N43M/kSNrODzq6PBVeCatfTay4QCa0LSuP0b9Si7MfuLy94RJ/xeI5QWB6yX9cNo9+EaHVVPJGS+GFNx+Zu7AAFQDsY+zFWVQalb+MB6xXoLVr4ldW1a+0AZ3P0lQIs9q+NwhwL+1n5Inz0NcecQJtdbMz4ZtHOIFw1B+mwD+JsHwG1T0ov1HPhQJ8R1seB6XU0rQiXznyHVSyq2rB0GF6Io1wGrsfDBmjEiwuFkMJSMQvYujlZb6fzzb7Zq0nViksdvwuBACQQwYFwH/ZpEZXCHLYgaiW7ELxXX1lajvsyX+oCgwnRhIlMh6LtuAUdFtHb7N+rB1go4OWJAZMwIyxo/ttZM5P28Jr0I37n5vzfZxmj5SSYUWBOSwaf+cwsMO7P/E2nrqoy13ar3oLbCjXqDAKnArWsIWez+6cYOqGtDYC4Jao8DABBVzGC6/5+9Ow+PqywbP/49s2/JTGYy2felbdIm6Zq2dKULUMoitCD7rsgqLojgBr6+ovgivvhTEVQUlFcRFdxAQWRRgRYKdC/d17TZJzOZ9Sy/PwaSTvakk/35XFcvyJlzZu6k6cx5nud+7nt0Ptiv+eYUwvbuNyZvvFeM+mIu6lte1PaBpWhraTKcfxTDbVvQVzUAGvrKRoy3boWPHUVz9XIDZNTg0s7B9bTSffitp9bdAJOMY+oJrK74Hs7lxhFOB9cgfFDB6dQwOELIqmtkXz+J7ClGzvlWIcogU8JDFrnXTKn/vF8EgHLchj6rM004PSVEqlEbtX3xQvKYDTrkDzTy3N3bbFmmNKN3fLiKLUu0SpePcHRCst3+5HQaJROtb+chZ8S4cdX+YX/NRWWZxEJdPys0bli8i1tXbO34c8uKrdxy+raOP5UZvoQrWvdGKckcn1lFw028EwtCHz77ZBVa8cBujv6zpQCO2pAkjYLT92K0RFisH9gKliAIPbvxku2oqSps7lzBjJrdoxaPXq9j7X353eow/OOdEmJ1DlqfmsZXS+/ksY9fxuY/TUOR+/+Y1TwyrDuM4Qvvw8WHUNMHUFjGqMXTwstakFSVqukH8A20cJZBJnXWEbKvfpui//o7ZY//nrKnf0fOA68wrXYvGioVZsOI9rSemusk1KKQ6lTQW2LI+vG7Yg1Qe4YX97KBrfpraNgXGrh3w2xW/U8O4ZTuEyr/3lxINGJAOeqAtCgfZTkY9BqSKcJ0/ehVcxeSY+XUXMI+Ba+z+/5qe+1Jxa3qUtEk5whGJgyHlDQTH3ugjA1/mYrslTm9pq7/i05RXg9p4AWuIA5bBINB7fhjNKgYjUrHn8qc1m7X1WZlDHu845EYWAtCHyRJ4s7fVRPN6P+GdcfBDGJhC9phO+5zdpGa1sa8UdqrKAgTQXF6O955TSCD/FZnMUfZPbrtPuavycRYkfjxKat6/vzPGXzz8ZW0tjp4/7npPHLRFfzr2e/ja/wEsUj/qeuabZCrzkbg4x8NrhVqavaRPfsI9ooGtNxW2p0B2kwRfFIM8/z95H/5H5T99A+U/fZ3ZNz3b+zr9mKoaQFPLH43oIPCT7yN3t6ORQ+1+pFbkahMjw+kU+xyvIe1yTNirz1cbvzfCsKpfaddxiSVqlvcfPonM9Drdcxfk8l9b8yh6FIHkZNa8KjoOHjYi1LnAAksxc0dj5msYcrFPutxz9tmwWqUsVsj3R6z1R7t+P9g4PSRDEsYRtVLPBwzLEM1a2SVtWA3Db1ad3/MBh2BD7q/H03Pbu332iyPH0OXlmCGo7qBdI2cdMTAWhD6YTLr+fyz1YRT+xtcSxw87EHe6cIwvYXCwgayjJroaS0IQ/S19duRs2PoDtgg1Jn6LecWjV5QH/rED6YmDHwAXnmvlHC0M07DNInyWUW0+z5Gw5H/R8OR7xENT01uIB2D62YkwEKIDGsrJZn1VK/Yydyvvszc/3uW/C9twFzbCN4o9LEl1zirkYKKIwAsMI1cAUZnJD4wtFlkDNYoss07Yq89XAxGHVf+qLzHgncQb6u5/idFnHdzYi9iSZK47Mtl3PHydMwzdR0p5YfqXGhhA7p2HY6Kzv22DkeYfIP4nBnPqgvctO6JUuYJIHWpR2jM9mMu+HD/bVTCZxRp4BPJ2Z+rILjbDTlRrlkyfNXBF5VlEQt2TwPPT+/e2q0rg16lKitxD7j/aIyqwtHLHhurxMBaEAbA4TRy+++nE7L0vfqwYXsB6g4X6DVyL9yKwdHO6YbBpYPPLU7nnKp8MRMoTHIaq8/bG+9dvbFzkKVpoJSVjWJcce5MC5VXuHp9PCapXPlAeeKxSDmNR7+Dr/EGVDWJraSMwCUH0Jc3o8v2Yzx3H4bPbUa6di9qddvgVsINUHXrf9AMEfJNOlJG4jZBg+D++EqN1RDDYImiOCZG1dnymU7KPt79MyCWrfK5F6uZvqD3G9M0r4XP/aqaCx4rJOJR2HPEE68MHtBjKe1csU5PDZJuYERT94Xkmm2PZ2gU9LC/OiEN/EgamiTS/icSSZJo3j8b2Stzw5Ijw/Y6BbruaeC5qSFs1mif11mrT2Cbe4ypPaxs17jG95ad4SAG1oIwQOnZFj7xq2mEDb2vXL+zMwfVZ0U6bibl9EOke9qYYR54kaWZhW6KDqWgf1vHNZXlpFjFKoQwOV06/wi6siCSX4+yq3PwEZMtSLax0cru4i+UEEnr+f0gbaGJ3NKeOgPoafddQMPhHxAJ1gzodVTVTHvbaprrvoyi9LK30gBcegDpxt2oc1oTK4kPknlRHe6CevQSg54YHIqqgjQi/vjg30wUnUFB8Yxuun8yXfblUuSc+PenouFcauSrL87C6RlY+vaM09zc99ocDnq8SJoOrcmEKb9zlclultEbZcp0YuvReDQ1x0nL+/HBTYazh4H1/M408EDbyhGLSxg5hmmXozgVcssbMQ7DDJlJL9HeQxr4jGxfD2efdF2+j6wv/hvXeR+QkRbAYkh8DmUfnFrDx4lHDKwFYRAKpjm45MclhI0937Sq6DhW50Z+Ox2yw5TOO4DDHKNyAD2tp+elMaXO2ZGq0/JelPOsRcwUqTbCJPTp9TuRvTLS9lRO/uiOGcfODLkkSVz8P8UoJK4IR3QK1zwwpc9rFTmbprr/prX+dlSl5xWoaKSU1oZbOXHgl/ga7iAcXEhz3b29r3Yn6xPdrDH/06+iSQozTUlcWe/FVLfrw//TMGjtgA7JPnFW5SRJ4safVRCyyMz5XDq3/Gg6Utd83wFYfUsxoaAZ5ZgdXUYo4TG9JUyFXgysx6OFzgzQwKhTSLGHEx7TpUSwVDTGvwjraHNcNgoRCsNNlbwo9SlIRe08vKwl6c9/WnkW0fbumUsF3t4H1vq0ENlfew29I4Zt5gnM+T6quwzEg00yC8pEEbOTiYG1IAxS5YI0bvtLJdH0ngfX7+7MRX0/HSki4V23DWuqv9+e1lOzncxo7Fy1+UigLkbxvhQuqikWqeHCpOGxRyheHK+QKv8nceUy5hxbKcLTF7hJqU1ceSw610Fq2kBWIyWC/jOpP/wjwu21AKiqlXbf2TQc/l8ajzxMsG0NmtY5yIxFptBy4otow9xeybH6EKa0VtKMUMrwDthSgvGsnhSXHpvrBIp/bGQkJFNmvpWvvTmbNdflD/k5Khek0eSzoxxxgDMGJ1WBt9nD5OlFb9nxZlqOq2O1usTTjq7LP2v73GNI+viHv3bQDZIoUjdRydGZyF6ZlQt2k+9M7oRmUQ+FKLNTQthtPaeBS2aZ7K+8jjGjs0K98+w9lGe1djt3ikVUqD+ZGFgLwhB4c6185eVZOE4zdOs7+u+tBWgRI9puB6Y5DeRkNlNm1mHqZWBcmpHCrDYPYV8vq+AyRDeoXFM+BW+qWJEQJr6vfGwncl4U3VEzmi/xd17OKezlqtHziYendmSxhE0yl39tcHvAVSWd5uNfpfHoA/HV6cZbiEV7f45IsBZf482nFHO/HAqLbnsV0Fhm6nti8FToJfDvi++vdnn0WDz1yG2uYXu90WQwnvotV7PqQmm0ggr2qQ0dx9NSQqTpxS3deLMg1dsxaV7Y0/7q+Z37qwPNq0YqLGEU+GPnI3tkHEUNfDFbh9XUR5XJQchJsxLY0VMaeGvPF+hUsr7wHyxliSvnKSsO4M1qxW5MrFwe+kDGpBcJ4R8R78KCMER6vY7bH5tBzac9CVVfozEjhw6nE3szC6wqpRdsx2ANs6iHvYoF6XbmhzMINfe/H7JlW4SVSg6LykXajZB8LpuRK6vKuKymNGkf6EP1sXP2oKaqqJvSE45rGiilo1+4rCt7ipEFt8YLrM281oPJPJSfn0Q0PB1NG9jkWbBtDf6Wjw/hdXqmtTngYGIl7vSPfQDWIFPMBvTDlDFTU+Tp2P6S6gSjow05NnbS/ccae00pRI3oA3rs0+o7jqc5wqT0Uf9DGHsq8zpXqwGyXF0G1gYF26zjAEjtOtrSRTXwiSwqVUDYjHFKK9NyjnB1YUFS9i+fkZ1HLNQ9DbzQ29bD2eC9cRP2ed17auvtMVJPP8jM3NaE4xG/ysKysZVJNpqGPLDeu3cvZ599NjfeeGPHsZtvvpkjR4avop0gjEXnfLKAS35RQsjaOSP40oYyOOxAatGTesZenGltzDUl3jDnptlYomTR3tB3pfGThZoVvNutTMkWqTdCcugl+Fh1IWeq+bS9HaN9g8wF1iJWVeaMyvaDlRX1WKb7kcISynuJA72Q6oY018gHNQBn31CA5wwzF9xWNGKv6W++kqB/aMWMVMVGKLCI1vrbOX7gF9Q1/IZjscfRnTgpBdETY/bV/8Gsg4X6lCRFnagstXPC0ZWmxFtt6UVdid6kzK9AkiUkvx5LSeeKkk4CszWKq69easKYUuvonCSXJBWnI3HfvK3mBLoP7yvUfelIXfPEhQlHbpuKkhUjq+II1fIRrqgqO6XP4doSLy3vdk/3zrCHcNi790t3XbgD55q9vT6f8+w9lGV235ddaOqeaj5ZDflf6XXXXUdZWRnHjx/vOLZs2TJuvnmY09MEYQyaOsfFXf+oQS2KvwNu3Z9NMGBDed+DrjhAaeUxskwa6cT3wGU4rZyuzyFwfOCD6o9oKixKFavWwqlbWJbB5ZllaBtJ2IrQXi9jf9fINaXlIz6Jc9cFO5CzYki7UqDLPuJQ+bwRjWWwbnyoYkhFqYZOorX+NsLBWQM6OxYpwt9yEY1Hv83xA/9Hy4l7CPrPRFU+zAyQJML7lidcU3z1e2j6GLXD1NPaFujcF5zqUDBYY8hGMbDuVXo6qmxEa7BgyA0kPGS2hSiUhr/YnHDqpuel0fJ+58CmyBVE3yUt5ORq4L7jZ41YbMLoaQ+tRk6XSS2qZ0puE9rmIOtnFg/pufQSTAv2/PldldN9cOxYfAjPVZv7fE5zkY+shQdwWRIH6+rRXi6YhIY8sK6qquLhhx+mpKSk45jdbueVV15JRlyCMO44nEa+9OeZZJ9vJWyWeWdXLvKGTNAg5+LN6F0Bzit0c/q0bM605OI/Guv/SXvRvDnK3OL0/k8UhB4UeR1cO20KGdus+A52/h56rBEcps6vW3ZEmX7ExRXVZTgsw9/6zW6KUbPiCJpJQ3kjMbVMlo3EahcMewzjj5GW4/cQi/R88xUNl9HWdDUnDj1Kw5Ef4G++hmh4BvH+XN01uj+J/lhngSQpN0z5uZvINUmkJXk11KSX8O/tvEFLtSsYzDFkm7ePq4SI5ohXBvcmrnDarVFy9aK41Xgwz574O17sCXQ5Q8M+L76/Wmox0J6/boQiE0ZTu7YMDR2myib0epXlU04Q26ByRmXuoJ/r/KqihM/3k3VNA7dUNJBxx1tIAxgVutbuoSY3cf+1vy5GSaZYtYZTGFjLsowsyx2z85FIhAceeAC3W8w0C5OXJElc+82pfH3TXKZ940IkvwnpsBXraceomh9ltsVM6vtG2g4NfVD9kRlKmqgULgyOBpfVlDK7Pp3mk1ZLLAaZsyuOcvmiD7h60QfMyWvmo18uVQb/xhjnGgpYMyN/WH/nvnT+LtSCCLoGI+rxxNTj9tRyJKPo694TTbPRVHcfcix+sx4NT8PXeD0nDv6UxqP/S6D1YpTYAG/MDBZiu+ZwcgexqlvfQJLUpPe0nlmYjhz58BdK0nDoIxgsURRHVlJfZ6JRHF7kIyngUNCZOycmHNYImTqRCj7WzchLo2VzYhpubpfCZebyZgyeeOstZUemeO+bLCQ9ams+Wl6Y1LxGirNacFsjOLYaWTiItlbeVAv6HT1nT3lsEVIdiW3dvJ96B52p+z7snjgWHGVqRfc92DWZngHHN5ENeWC9fv16amtr+cMf/sAXv/hF5s+fz7/+9S++8IUvJDM+QRi/UlIIGnKJbcgAl0xa0SbMhggl05KTqteyO8qKypykPJcwOZxfXUj7BhklGh/MSKicVtTAdUt2MSW/CZ1Ow2hUWFJ5hMvm7k9I9wo2KZje0XFN+RRy0oYnLfjytfuQvTLa+4kTtJoG4dNOH5bXnChUxUPTsW9z/MAvaDz6IO2+C1HkoQ1QG9I/geFoZ4q2vtxP1sJdzLGY0CVxYqUkpXPypHiKGZMuis4SQ3Fl93GVIHuzUVvNSFEJR2VnATOnLYpH7MMd8+bZErPNDDqFtNRgwrGONHAVWo+cOVKhCWNAKLQY2SuTVnYcnU5j+ZQTKDGN3P12ZuQNrLDj2QX5RAM9D5Src1oTvtalRDAV9t7PuivJqJJ7wQ68tsTBuSsktqHAKQysV61axcMPP8yMGTN49tlnycjI4Le//a3YYy0IJwnVnIa6PQ2pXYf73A/ImR6lKImLMbmNNkSXA2EgctNsGLd3vuVP8/q4fvFuaqfUYTJ2ryac4Q5wxWkfsLCwkZOXqVu2RVjcnsWa6XlJXb1eVXkCS1ULKFJ8C8VJQlo6ZItVzP4ocmbnfulTeR5bJsqOKfDRr4UE8+76JzY9rDQkb8+9pa1zdTU/S8IUaUXSgZYyPIXSJgolrwiienQBHdZpnS239DoNp3nwdTuEkVOd76Z5S+L+1PL0ALouM1b22ngauO64mfA0sb96MmmTz0Uzq1grGwHIz2glyxEiFlSZ0ZJGYXrf7Q9nFXlofafn/tQARRmJg2jrjPo+U8ClNj1SS2LGhPOsvcwsbE6Me09UtN3iFAbWv/jFL8jJyeFPf/oTO3fu5O9//zvr1ok9IIJwMmXGDJSYHW1nKvqKFhwcRDoYINWdnFWFtiMxzqkae319hTFGg9XpucSCKlkpIS6ft4+zZh3EYeteFfRkBoPK/KnHuLJ2H56Tzo34VUyb9FxTUU56knqrf/Py3cRyo+j22iCW+CEemjK2i5ZNRE1pV2I83Llf11LTRErpMZZYLEhJmFCxGPW07e3cEuMyhTFpx1HD5hEuADf+KMVFSLIOXZsBS3HiXkeHNYZJbBEas2Zbu6fLlqQn7q82ZAYwF8UHP7H3s8E+fH3khbFHkxzg86Ir8WF0BJEkWFp+Aoh3hlmiZff6uSsB1bHet+SmWaM4u6SBW6vqezkbJJ8e5adT4Y3EmgAGT4iaj21NOCaHNeaViPoYQ767/+xnP8ujjz6azFgEYcKRJIn2jEqib2aBATJWvoOnXGV+pY5kLffZ9umxmcX+K6F3Z87Io2VrlCxHiIvn78Gb1rVQTt88rnYuW/gBS0vqOXnzbcv7UVbJOZw+7dRSdz22KEULDqJZNdS3EveRyTEjsdraU3p+YfDC7irYngMfjX31sPBrz5NigKVJaL01p8iDEou/B6a4dHjcQcx5PhR/cvdxT0SS0UhMtaHUWzHkJO7NNZmj5EvJmewSkqu6wE3Llu4ridld3o870sBj0HpoxUiEJowx4fa5yBky6VPjmQvZ6W1kp8SLFfqPxVibmo+9h/u+86oLad3X+2p1dU5Lt2O9Dawlnx7lZ1PRfBbkjZlI7YlDxowLdpDTZQtDsVW8fw95YH3jjTcye/bsbsefeeaZUwpIECaa6OLT4YQdXb0Rx/JDeHMCxD4IMGt+cm5+gk0K504tSMpzCROPJ8WMa2985XFlRV23lMOB0us1Zpcd54ra/QmVw0MtCqnvm7h6ejkp1qFN8Dx63WHkojBSswFlf+IesnbXVCS9mDgaDS228zAd7Nw3l7roGNb8Eyy32E75uQttnYPzsqlGHBY/5kw/sZAogDoQMaML5YgDyZO4+mSxRMnTicrgY9Fsc/fV6lRztFs/4Y408EM2olVLRiQ2YWxpi34MNVXB/mE6uCTBkg9XrQFa90a5KL8Ew0mp12l2E5YP+i5eWNylGrguNYwpv63beZJPj/KTaWi+D+9TNR3Se4mfzbbqek5bktjzWjrBpDfkgXUwGOTrX/8699xzD1//+tf5+te/zn333cdnPvOZZMYnCOOfy0lIl01sUzpkRXA63ye1ENwNAVye5KSEK9u0pKXkChPLufkFhH0KFRm+Qa9U9yTd1c6Vp+2mxJ34XK2bopxrKqQ6f3ADI5vZwILTNqN4FOihaFlkkShaNlra8s5A94ETKfrhzZsRTv+fP+EywgLdqbVWMbV0vvd57Qr6xib0tiiyNLDiPJOd7MpEOeYAm4o+tbPtlsMaJVtMRI05MwvdtGztvpI4NcOf8LXOEcFaGd83H3s7By1z4JWghYlDlvLA78BU0Qi6eLGLbE8bOSmdK8Qt2yJcMbWsI/nx3JL4Z31vnOYozpTEFn3WqoZu+6ul1g8H1f74pGokZkOR9cT+dVIG04eqrt7EydmXbYdiw1bcdLwY8l292Wxm+/btfOtb3+Lee+/l3nvv5b777uPYsWPJjE8QJoRw1QKUTV6kqET6edsoLjuBFpWZNy05KeGxoMqawrxTD1SYUJZOyaLl3SgSKoundG+PMVRmk8w5s/exrPQEJ//+ttfLVDa7yO+nuMrJ7j07jH66D2SQ30gsUBbSvOLGcjRJEj79Mkz7OldAbfPqcM44xkrL0Pd9OiyGk9IVNTwp7RBTMFhiyEbRsmUg5Kx8VL8ZKajDMeN4x3GnLYJXVAYfc2aZei4qWNilf7Vtbh2SQUMK6fAdXjgSoQljVMw/HSUrgrs4nqrdddUaoOXdKFfUlFGVn0bbpr7buFbnttK1fIV1RmIauNRiIPZoBe2+XFq8Czix+lZar7ubQOpUCBnR7UrcBpS2ah9leYnp5XPyJvc+6yG/+37qU5/ikUceQZZlVFXt+PO5z30umfEJwoQg18xECTpgvw3TnAb0wQamrowQ2x1g7sLkrDQH3pMp8p7aKpIwcTgsBvKOxwc/pxU1Ybf1vu9qKHQ6mFV6gkvmHMBi6KxEHGpWWK7PJtVq7OPqOG+qhbPm/odYTgzdHgdEuxQtmzY/qTELg9dcdDH6A3ak0Id3ZAZY/s0/k27UmKUbWkr4nMJ0tA8XVoqmmHC54qswJnc7smVy35QNlFJSihTToQ/osE1p6jhuNqqkieplY8rMQjfNW3sqFKmR4UocWDs+3F8t7XYQnSGKNk5mgcjZKGkyqRWdg98sj5/cLvua/RtjTG9KQ+unDXWJt3vK98n7q6UWI40vfYoTZ9+H/+pPEz1rLWTFO3SEF69E00B+NefkMivobDJn3LAh4TnTY5M7e3LIA+vi4mI++clPousyM/rAAw+cclCCMNFIkkTQWxEvYmZRyb3xLcx1h8ieC866AGkZfe+LGQhV1ljuFX2thbgLy4tob5CxGmVmFvde9fNUZXn8XH3abvKdnR/2bYdiXJhTjEHXd3Xni6e5yFx6EEwayn8SW2zFYiZic8WN5WjTDDYCcg3mvZ17rY1VJyg9r46zXEMrYpZv7pwAzM+WMAeb0ZmjWMqaURyZfVwpdPC4UWUjtBowF7YmPJRi7XvlShhZva1W56aGMJlOSt01KNhmxbMPIm/moJSVjER4whgV0uYgRYxYZp00+O1h1RritU76kmKK4eoyINc7w5gL4oNtqc3C8aYfE5m9Bsnaw8A4M4MQGWgNdnSHEx8vuXQzJ4+22/fFJnUb2FPKF/rFL37BlClTcDgcLFq0iL/97W/JiksQJpzIacvR9rrQ+fSYlx7DnNdCpukgJpvCvDJIRkp4y7sRqgtE8Z/Jbl6JF9878ZvrFeUnMPbQpzqZrJYYF8zb+2HP67iW7REuryzr9de6NDOFNZWvIhdE0TUaUQ8n9kcOuqci6UVK61jQmH85+qNmdIEP/z70UHXjc2QoGqcVDr6vtb6x867L44iCrx33GbvRoyG7Tq3C/GQSk1JRj9sxZCdWBreYo2TQf8aIMPxmFXp6Wa2GKd7E/dW26np0NhmpVU97wwzRdm6ykyRkXynk+bF6OlebM93dV637U53Tdxp4c8MXUKS+JzWDlfGtCerriVu2LIU+lpy5q+PriF9lVlHPk0mTwZDvWn71q19x7bXXEo1GWbRoETqdjosuuogXXnghmfEJwsThcROWMlG3usAAube/CcEI5XObie4JMO+05KTPzDZ4ktXJSxiHzAYdU9ucoIHXHqY0p3lEXlen05g/9RhnVXTW2Wh9J8rFM4t7PH9JWhZzzt2M6lLQ3u1StEyFyGLRZmaskB3ZhMJFmPd0rlobpjdSeelhLs30kOseeEq4y2ak9UB8W4IjVYfHGU+FTV1yCI6b0VLFxOBAxWweYkcc4EkcuJktUQpFZfAxocbY++9zrqfnNlvSDieR8uphjUsYH4Kh05HTY3gqOz9Xe1u17p1Gaaav21Fr9YcD65COkNZ/S0t5zhyiMQvKHje6psRtWzNOT6wOXp46+AnXiWLIA+sHH3yQp556igMHDvC3v/2N119/nf379/PEE08kMz5BmFBClfOJvpUNUQndtDacCw+gO95I2WqZlKN+0jNPPSW8ZUeUheWi4NNktW56Mf6j8dXqVdOG3l5rqKblN7KstHMmPLJB5YzK3IRz5hSlMz3lPaSKAEQk5LcSZ8qDUiZa+uSd8R6LmrIuRt9gQN/44Q2VDqZe8yeUPe18PC9vQHvqAWYXejsm/sorjNj1bejMUfTZ7cgnUsQq3SDI6TmodQ4waJgyO1e07JYoOWJgPepmFXlo2dZzbQuDpOBOWHXUsM87BipE/pODXF0zMkEKY5pfPQM0HbYFxxOOZ3n8CduveiOhcn7VEdw9nPvRirXWmkm35eyenkuSaM+YHr9mQ2ItjOzZRxO+NjVN3myzIX/nM2bM4JJLLkk45vF4cLvFbLMg9EaeMwelyYHu/VQAvDe8C5KKo+kArkKV2SWQjOXmqcrknS2czLypFkKb4oXEpqT7yfT4+7lieMwsOc7cvM6Vcsc2I3OKPxwoa1ClpbH24jeJZcXQ7XaA3KVoWeWCkQxXGIBQ+kyiQS+WnZaO7XT6qc3UXL2XYqvKhdlFCT1Ve5Nr7FzdzkhV0DU04V69G2OzHiUmii8OhpJfjBY2oGvX4ZjeuYKVaouQoTv1SVrh1NQYeq9wX5benjDpaS5rwZAeQnfCRNBfhGQULdMEQDKh+bLRlTZjSknc8rG4rO9Va5NO4dK5ByjObun2mN4VwpQfvz8IRwZeyyS6dCWqIiFvyEQKdg4hU6Y3cPK9a+u+KJ4Ucw/PMPENeWCt13d/096/fz+vv/76KQUkCBOZJEkE3dMI/70QXZsOvFEyL3kfVI2CzKOoxwPMX3TqPQBbdkapLRHVdSebeQVeVBlAZcnU0Wt9KElw2rQjVGTE08+UqEZZXSrFGQ5WVuaga2rEs+Qo6ED5d+J+rVjMjDxnzmiELfSjyXU+upAO04EPV0N1UHLZX9AO+jH6Va4oL2fJlEwK0+29zw923AtqeJ3toGqkLj2Eod5ITBUTgoOhFBVCTI8uoMda1lkZ3GGRcYtx2aiaXeShZVvPe6sBSrrsr7bPi79fa1vSiBRWDGtswvgSal+InBEjfeaRhOOZHj/5zvYer0kxxbhiwV4y3IEeH7dWxXulo4FfPmvgwaSmEDTmgaZDet/VcdjoCTFl2kkDfS1+PzIZDfmt97zzzqO2tpazzjoLu93Ojh07eOaZZ7j22muTGd+o0DQNTRObVCcaSZLGRJphZPHppPx5G+qrGXDucVI+tofGP1Wg+GDasgDbX9bhSLUSaOund0I/KnGxgYYkRS2MBxmKhRaiLChsJsXe+03dSNDpYFXVIUKbSjjQYifsU1jkyIIG+PilLyLnR9HVm4jVJVaWbk+vGBP/ToXu/LkriWz/A6b9TcSyY2hWDV25j5nX7oR/1vKPVyO4seDGwhyzF0e2EZ1LImKSaVWitIajtG2Lb1MoLDfhtDcjhWPoc9rRHbYRk1yj+w2OM5LRgCzb0JpNmAoTW+k4rTEYXH0jIYlqDB6a6f09ODuty/7qOcdAhujGLORzRDcEoVObfD426RnsS47B61MTHltcfoL/ezuxenyGI8QFsw9gtfTeHaCjcFnAjCwVDiqe0JxlODb+kthrOejnNXeMJGct28cHOzsnyrM49UWi8WjIA+sLLriApqYmPv/5z9PWFn9DX7t2Ld/+9reTFtxI0zQNWZbRNE3c2E1AH/29GgyG0f37TU+ntWwFrk1/xzarCTkvRu7Nb3LogeUYjtWRN89O2zEjb79xagOjlh1R5lV42bhPDK4nAwkI7Vcw62VmFw+msMnJPppQTM6/D71eY+3MAzyzsYQTAeuHe781as7fQsyhIr2WmCqpKhKRJaJo2ZglSTS6LyY39AjmXRbCM0MgQeFFL7Dl/ypwZ9horo9XoFciGr4DnftLTejJOOlGKz9Hh7GtCc8ZH2Bo0SMhETOJdoGDFTOlodTZ0de0Jhy3W2LYNB1B6dQmaIXBm1OUTnMfq9UpphgOW+fjOnsUU1kLuv02wmEvOOwjEaYwTqiSG3xudKXNGG0hYsHO99FMd4B8VzuHW+O/MyXuAGtqDvbbCeSj/tVKYPAt3dRpUwn/JwULfnQfOFAr45NEhbWH4ced54X3K/Fbikk2nDqlZKEbbriByy67jC1btpCRkUFxcc/VX8cLWZaRJAmv14vFYhGD6wlE0zTC4TCNjY3IsozROLqtSOTFSwke3o3+b23or9qLaeEJLMVNhPd7cEcOkOFIzl7D6VIaG8Wq9aQws9BD+AOFNRUnEnujDpC5wER6cbxdVnOdl9AHyVnxNhoVLphzgF+/VUpr2MTKlZvRpgSRwhLy24lFy9rNRZCWlpTXFYZHIHsZ4W2/w9xQj75Rj5KuoCv1M+ua95FfWMzL9QP73ct0haA9TOrSQxhPGFAViWDh0mGOfuKRnZkohx3ol9dz8l2s2RylUGdmhxYa1fgmihSrgfJMJ5sONPV7brXB3edq9dQMf0KtKGvNCSQdqO96iGSWJyNcYYIJB+ZjyXseT+1Bjr8yLeGxJWUneOrtEmqyW1g2/Ui/BUv1aSFMefGtCKHwwiHFEyycheXYayiv5CJN2wU68FQnFlgLtShUlbvZcmhkOpOMFUMeWD/77LOEQiEuvfRS5s+fD8CXvvQlvvKVr2CxJKdt0Ej6KP3b6/XicrlGOxxhGHz0e1lfXz8mshLaL7gC46/rce2sI1YVJOe2N9n32bUQlclM92OxOgiHTm1LQsv2CHOmpvPOgcb+TxbGtakuJ5ohQnnu4D7EJIuEp1bC0b4dyR//fctynCC8PJ+mvalED/dc1bYrU24rede8jTHPD0csKLtdRE+kEG5yEGxK4RKdzC/+VcG5l72B7JXRbU4FtbPMh6ZBaMmZg4pdGB0N3svJD3wPyy4L7e520EHehS+x+ZfVzF/k5K1/9z0pY0/V4U5tQ1Ji6HMD6A7b8Tdno5X33UdV6E7OLkA5YEMPWAqbCR+MZ4FYrVHydHZ2KGJgnQxnlOchb9SoqfbwH/8Jdh3r3r4I+l+tBihM77K/eu5RpJBEbKuH6Bn9tz0SJh9f9CIsPE/KsmPdBtYZ7gDnzThCcXbzQIp7d6xWo4BfOXNIK8rRRUtR/u/fUG/HeMSCWhDGOqWJFEsYf7hzDFiR5px0A+shFy/78pe/TDCYuIEnPz+fz33uc6cc1Gj4aKA1HicFhIH7KBNhLOyhlyxm2pZdQvvfStH5dejKAqQt2wNAqr6FaVXJaZdSbRCV+icDS4ue8vTAINpraTiqzeTPriMlsAupy78JS9thcrzbyVyuYPT2MgdrUHAsOkTRd5+n4Id/Qze/CSU3ijK/DS4/hOX6naRf+x4lV7/Bgs/8lR/86n+xza8HCeR/Zyc8VVDKQsvL7fl1hDElmDGfUCgHXVCP6WD8fUoqbGf2dW9j3e1j/qK+q8GWTzNi03x4ztjdkQbu14v2QkOhlJZA1ICuXZ9QGTzFGiVLJyqYJYMEWA7FC/Y2b44w7YCLayrLKUjvnrJdre/v81Yjw5VYcMoxpw5pr4NoLAUyRatMoTtFyoRWN1JpM3pz98nukpyBDarhpIF1mxNNGlp2pGQx026Pp5Gr/45PiOrMCnMWHUw4z9Y2+d6DhjywNhgMXH/99QnHCgoK+O1vf3vKQY2m0V7FFIbXWPv71YqL8aWejrTBBYDn2s2gU5Dqm8nzDmylsD/N2yLMKuy97Ycw/qXZTbTujVLo6bkCaFdGr4Gs5VG8hq3ow7235JLQsLXtI7dwF+lLJXSp8ZtLU2Er6TdsouSJ58i66w0MZW3dZ70lUF0K0fIIwdPaaV/iJzbTTywviq7OjNaQeFManCv2Vo8njZlXoGlg2mdGCsX/8rMvfJkpZ4Wx7m5l/uLeB9dZaQpSQwspS+LVwDUV2otWjVToE0taGmrEhM6vx1LWuTKUao2Qbhhbn3fj1crKHAIn5M4DGrS8G2XOCS9XVZeRkRpfkJlTnE7z9r5Xq3NSQphNnc9lzG1DlxZF3Z5GOG18b6cUhlc4MB/VpeBdsv+UnuejwmWx9mn9nNlPPAtXoGmg7HIjtcQH0FNPO5Bwjm9PlBTr5BpcD3lgXVVV1W3V7/HHHx8TK4GCMJ7EVp5Jy5b5GOoM4I6RfeW7AGS5/RiTs2jNTJMYWE9ktUVeNBUyXT233uikkbbQSG7Rbqxthwb8/JKqkhL4gILz3qbokZco+P7fcJ23G52j96qj3V7ZqhEriKFZNNS30xMeC8ku1ArRYmY8CabPIhQuQFIlzB98mOmVHWHqpb9iyplRrB+09rJyrZGRFkAyxjDk+9G36GlvyUBLF4XLhiompaI1mDFmdf771+vAaR58rQWhu7xAz8XEVFnDtzHG0kA2l9WUUkX/9SHKMxInMm2z6yAqoex0E50+OynxChOTL7oeVHCcfqT/k3uhdwcx5cYn4Nsjp59SPFp+HiHVDUhIh2wAZM9JbPOpylBbNLmyMIY8sL7qqqtYsWIF3/ve93jkkUdYtWoVv/vd7yZEu63J6rOf/SybNm0SkyOjILDiWmKvF4AM9nP2oXeEsccak5YO3rw1Qk2BSAmfqLKwYTXKCZVme+KotuKKbEdS5D7P6yanHd01H2C4+AMMOf0X7+mLFNShvJvY37J9+pJTek5hdDRkX4mmSRjqDeib4tkM5uXHyJvxElPPimDd3UrtosTtVQWlRlItfjyrd2No/TANXJo5CtFPHLI9HeWYHb0nnHA81RJjwDtDhB7NKvLQsrvv7LFYSKV9g0zLzv6zzPK69BV2LjqI7piFWMSCUl52SrEKE5siZUFrGlJJM3rj0DIaO9LAozqC2mmnHFNoarzGlrrXCUDqjBNIXToR5BkmV5X7IQ+sV69ezVe/+lV+97vf8bnPfY4dO3Zwzz338M1vfjOZ8U04wWCQr371q5x//vlccsklzJ49mwcffHC0wwLghRde4M477+Tmm2/m2muvxWazYbfbueqqq7jpppu48sor8Xq9fOc73xntUCceu5369Bsx7rGAWcN7wVak5jaK8ge+ItifWRaxaj0haRDZrzAl3d/nHivJJJGWcrD3E3rijCCt24/uE7uQivpPM9fVG5Fe96Db7kBXZ0Jq13V28Pooju2poHV+9ERiNuR5om/reBR2zyAYLkZCwrzTAioggfvGd3Hp32famgi23S3UntY5uC7I02NobiRl6SEMJ+LdGQJFK0fpO5gY5PQc5CMpkJp4s202R8nVJSntaZKqsSZvQlovKbhTT6pNZFAwlrei7U4lbMsbc1vVhLEnHFiAZlfxnrlnSNd/NLDWfJkg6U85nlhtLbGYCWWXC1Qw5vgpL2hJPOew2u0+YCI7pcT3008/nddffz1ZsUwKn/jEJ2hoaOD5559Hr9fzzjvv8LGPfWzUi7698847rF+/nq9//esdx1555RXsdjtPPPFEx7FHH32UkpLB970T+qcUzqD9/Vosef/CsfwwPDmXHJcPnT4FVTn1D9yWLVGqy9xsPjy5KjROdFUFaYT2KBTM6DsN3F2rxxBsG9iTWmSkJceR5jcgGfr/RJTaDGgvZxJ7L4Num62NMrrsdnRZQaSMEPK/EouWtRfPEzeU41hD7tXYGu9F/2Ehs2hxFCwa+V97lchNqVSsKWLHCy3UnuZiw38iZKeHkCJBDAV+9G/YCbZ4UEsKRvvbGNfkwiLUty1Ieg0MMsjxWzurNUq+lMJhLTn1OiabPI+N1i3J+9mVpgfR6zvfT63TGpH0Gsr76UTKq5P2OsLE5Yuux6I+j33ZUfhz5aCvt1bF269GQjOTEo+kN9DunobLvzm+z9ojU7NkHx8c7FzIaT8hM6UolQ/qBnj/Mc4NeMV606ZN3HHHHXzve99LOP7tb3+bBQsWsGbNGp599tkkhzex+Hw+nn32WWbOnIleH58pmjNnDp/+9KcJh8P9XD28Zs+enTCoBjCbzd2qpF999dUsXSp6jQ6X5inXY9iaAt4ojuqjWP31TJmRvBWHOTaxaj3RVLjj+/oynb0PrI0ZRlLCH/T/ZJKGNL8e3e3b0C2q739QHdERObSSo/W/pc5+FyG5hz2GMQPqISfyhmxify5Ba7V2PhQzEV28vP+4hDEr4ppCe2QKAKa95o6UcLIiFNz5Gua6w1SeFcK2t5VFS8247X48qz5MA9ck2tSqUYx+YlDzC9GiRnTtOmxFnROnDmuUHJ1xFCMb35bn5qAlcZt6WXriwMK1dD+6ZiNyqw25WlTFF/rXkQ5e1IJkHFxGoyE9iCk7nnkWiK5JWkyRJStRVQnpaHyfdWHt4W7nzPV6ux2bqAY8sL7pppvQ6/UJlcBvvPFG7rnnHjZs2MBbb73FunXr+N3vfjcsgU4EkiQhSRK//OUveeONNzqOf/7znx/1Nl8DXTEym82YTAMb6B07dqz/k4QEqjWdQOtK9C160i/YAf4gU8uSlw7evDnK9Lz+C6wI44fNp8dujGHvY3+1pzKApPZ/hygtPY5uzREkWz/nyiAfreH44V/QFPssSCa0klJ813yWVufMAcceyKhCMk6uiqETUX3+NaiqDkmTsG62ofPHby1Mp9WTvnY7projVK4JYtzViiXaEk8Dr4//vQfyT62AjgCS0YAStSO1GbAWd6ZhOm0RvPoh7/ib1BwWA5EdyS3+lu1OnPy0zToB+xyEDJnifVAYsHBgPpg1Ms4dwGT5ST6qBi61m4hKpckLyOMmTDrqvpT4lzO73/uH31MozUhJ3muOYQN+x7Xb7Tz44IOkpMR/MH/+85957LHHcLvdvPXWWzQ3N/Pmm2/y4x//eNiCHe9SU1O58cYbaW1t5cwzz+See+4hFAolnFNfX8+nP/1pzjvvPEpLS/nMZz5DLBYfWB0+fJibb76ZW2+9lcWLF/OZz3wGvz9eYTIUCvHEE09QW1vLa6+9RlVVFWvXrgWgoaGBz3zmM9x9992sWrWKxx9//JS+jyNHjjB79mxsNhsrV64kGAzyk5/8BJvNxtlnn83zzz/PWWedxerVq/nDH/7AVVddRVZWFkuWLGHbtm0dz7N//35uueUW7r77bpYvX85f//rXU4promgsuQppbwqGqmZ01ig5qS0gJW+Dyjz75Jk5nOhSrUZa90Qp9wZ63V9tn24ZWAXw/ADSsrq+z9FArS+g4cD3qQ9/E1VK3H8oSRKR89bRkjaH/mogKrKeyOln9B+XMObFUosIROJpiZIsYX3X1tGCy3XtVixFTZiOHaXqrDakQDOGIj/6JgMhnxMla8pohj5hxExpqA0WTHmdq6Img0qaSe3jKqE3Z0zJIxpI3s/OaY6SYu/MTNSlRJAywihb3ESKBp/SK0xevuhF8ergywdXHfyj/dVyW2HSY4p4i1B2uUEFe2UjadbELRRKTGNJavak2Gs94IF1enpnexS/388tt9yCJEk8/PDDzPuw8My8efPIzMxMfpQTyIMPPsjXvvY19Ho93/ve91iwYAH79u0D4oPjc845hxtvvJE//vGPPPvss5hMJjRN4/jx4yxevJhPfepT/L//9/947rnneO6551i/fj2apnH06FG+8Y1vsHXrVjZv3sxNN93E5ZdfTjQa5ZxzzuGSSy7h/vvv54EHHuD222/n6NGjQ/4e8vLy+MlPfgLA2rVrsdlsXH/99ZSWlvLMM8+wbNky6uvraW5upry8nCeeeIKXX36ZQ4cOcdFFFyHLMk1NTaxZs4YvfvGL3H///dxxxx1cd911RCJ9VzWeFPRG2utOQ1LB+7FtmJtPUFaZvHS+ls0RZhWNnZRwvQRTslM5c3oul9WUcvWMctbOyCcnzdr/xZNcbZEXTYFCd8+FxSQDuNO6p2V1Y1bQrTuA1McnghQ00rb/Fo77f0RM6rvOQvScj9Hqre1zcB1ImYJkt/UfmzAuNBZeg6rE08B1ER3Wd20QA0waeV99Dckko687QfrK3eg/TAP3K9NHN+gJJObKRDlhx5TVpeq0JXkZT5OFBFgPn3php5NVZvkSvnYuPoAU0iEfdBKbLYo3CgPXkQ6e14rUTyeQk9lmx/dXhyMLkh5TbFoVhIxIrQZ0jhjVNd0H/S3bIqyaPvHbKg54YK2qKj/72c/YsmUL69at4/Dhw6xevZpLL7004bzjx48nPciJ5q677mLDhg0sWrSI3bt3s379elRV5de//jUAlZXx2cuqqiq+/e1vYzKZuPfeezEajVRXxwtceDwerr32Wl5//XXeeOMNysrKWLJkCRkZGdx6663cfPPNXHbZZfzlL39h69atPP7449x555088sgj1NbWdqyCD9Xs2bOZPXs2v/nNbwB46623uPTSS7HZbNhsNubOnYvT6WTGjBkd39M111zDgQMHePPNN3nyySepq6vjoYce4s477+TZZ5+lpqbmlOOaKFrzPobhkImU0w9CKMr06cmdcJgeSMNmHp3Us8o8F+uqi7h6ejlX55ZzvlZExYE0LJsMtG+QaX0niuEdHfOOZ3BlRhlXVpexbGrWqMU7luXq420sMnrpX+2ab8QQbO33eaRzDyG5einSo4FSN4Vjx54goJ094Niia86lNeu0HgfXqioRPv2sAT+XMPbFHLn4Y50FmPTteqzv2UAB0qMU3v0KACnLDnamgWcvG4VIJyYlOx+53obeG0w4brfEcJLcQeJEt6Iih8DxQbYk7EeRN7F/tWvRQaRDNsKaR0wwCoMW9teCATI+tnNA5xvS2zF4AqCCX07+Z69aXIQsG5GOxRdEpi7pOUsu44h1wt/LDfi7u/fee1m6dCk+nw9N0ygpKeEXv/hFx+OBQIDPfe5zuN2iV25vTpw4QVpaGiaTifLycv7yl7+wdOlSNm/ezK5du3jvvfcwm809Xvvmm29ityf2gpsyJZ5CV1cXT9/U6/Xd9mrv2bOH9PR0HnnkkaR/P9deey233XYb77zzDr///e+54447+jy/sDCefhIMBtmzZw/V1dV897vfTXpcE4GSmktkczm687ZirzhOri8bSKdbxeUh8h+NsX5uEU9sGVrLhqFaWJZB9h4b8l6NVvqvttp2OAaHwYWZMw15OMuMhFIUDrb7ef9wM6FocvfAjSsaRA+qOEwx7LbuP0uDx4Az2v8eLGlmE7oZLT0/FjTiO34jAW3NkH71omesoeUfBtKOvpaQqt5uLACP+KyYaOpLP4V13xcwmeOrc4ZWA5atVsLVIQxzmsi8+D0MxX4M/7ET8TuIFYvCZcmilJahvWRB5+zScssSpVCysFkL9nKl0FV+yE7LAD6fBsogKaR3KS6pL/Oh/i2HSLbYCiEMni92MRb1b9iXHoOn+i98Z63+sH91Wwqq5Ep6PJIkETF4Me9LhRl+snsoYAbQ3iBzQW0hv3p/b9JjGCsGvGI9Y8YMtm7dyve+9z2+//3v89Zbb3WkfR8+fJi1a9fS0NDAN77xjWELdrz7/e9/z1NPPdXxtclk6qiw7XQ6cTqdbN68md27d3e71uv1cujQIYLBzg/Hj/7/o1XhnuTn59PQ0JBQLC1ZLr74Yux2Oz/5yU8IhULk5CSmeLS3J36QNDQ04HQ6mT9/Pvn5+Wzbtq0jDV7ortV6FobjRtLXbcfUUE/JtOTO8vnejrF0SlZSn7Mv80q85Oy1oUSGtslGlTVadkYJb1TI3G7jrFAeV+eVc2VVGWdMz510qeMVeS6CjTLl3p7TwNOrQkhKP6su7jDSmh4+ADVQ6qZ+uEp9atVDYytX05K/vGPlWtMgtPjMU3pOYWxSzakczf48itxZ4NJYb8S8Kz7hm3L5LvQ+HZIq4Y9V0GfjdWFwXE6UsA3JkDjZaLeKXtaDUVPgpmVXctuTTc0IJLbZKq8Hk4q81U1sTm1SX0uYHD5KB9dltaFP63/SzLGwCYBYYOqwxRTNKkbdmQYapFUdxaTreeEjuEmhPDt12OIYbYMqF5mTk8Ntt93GLbfcgsfTuUczPz+fV199ld///veUl5cnPciJIi8vj//+7//uWGGORqP861//4uyzzyYnJ4dLLrkEgHPPPZennnqKP/3pT1xyySUEAgFuuukmIpEIP/jBDzqe7+WXX2b9+vVMndr5D0Xrkne5du1asrKyuPDCC3nsscf4+9//zm233cauXbv6jFVRFAKBQEeGQk9SUlJYv349v/jFLzjvvPO6Pd7U1MTTTz8NQGtrKz/96U954IEHcDqdXHrppeh0Os4880yeeuop/vrXv3L99dfT2tra/w9ykgiVLIUdTow1jUhSmOrq5Ldkyzlqw5PSc5ZEMs0pSqfwoAM5nLzKFaoMrXujtL0dw7rJwLzjGVzmLOWainIuqC6kKj8tSev7Y9P09Hh19572V9ummbG2Hej7CXRafF+1ObFAjxQ00bb/05wIfhdNSs6HX+z0lTQXrURTIUgmWkF+Up5XGHuirjKO265CUzv/9ZkOmzDtN4EEhhPxehEB7+LRCnHCkjUnOhX0zs4b7VRbhEy9SAUfqFmO5NcfKctIbLOVfsYedMfNRMJpaCfVLxKEwQj7a0EH3gt6v583pAdxnrcLa1V8Aj0YGb52udHp1WhBE5LPgD4vQHGmv8fzVFljkTVzwhYyE30YRtAZZ5zBddddx8UXX8z111/P+vXrWbp0KT//+c+B+D7kX//619hsNm6//Xb+93//ly984Qs4HA4uvPBCfvazn/H0009zzTXX8MlPfpLi4uKOImL/+Mc/eOmllzh8+DB33HEH0Wh8xjUlJYXnnnuOiooK7rrrLu666y5WrlyZMBjv6uWXX+bMM8+kubmZo0ePsmbNGv71r3/1eO6VV15JcXExq1at6vaYw+Hg0Ucf5YYbbuCaa67hoYce4sorrwSgoKCA3/3ud7jdbm699Va+8Y1vcM011+ByuU7hJzyxSHo9viNz0Ad1eM/bTq61iWS/E4WaFc7NKRzWN7iaAjclR1KIBYe/Om17vUzLe1HUjVCyJ5V1+mKuKSnn0poSFpdnkmKdOHt7UvzxAYq36/5qPXi8/be6k1YeRcrtMtPtc3Ds2JMEtORX65aXLqe57EyCc1cm/bmFsSWQt5JmNfHv2bTHjPGIEUOjgWjQSjhv9ihFN3HFrOkQMGAv6exlbTfLpE+ct71hlZtmw7cluavVoJHdZfLTPKMBbU8qYU/fRSAFoS++2MWggm1xYjFiQ3o7rvN3kffASxT+5E94b3gPnS0KMYl2bRjrWuTkEIuZkY5akAwaNSt7r1resiPKGdNzhy+WUSTebkeQ2Wzm7rvv5u677+71nDVr1rBmTc+pl5dccknHqnZXK1eu7DWtuqqqipdffnnAca5YsYIVK1YM6Fyj0cjVV1/dYx9st9vNSy+91Ou1y5Yt46233hpwXJNRIH0p7gOvk7rqAPW/b6CgLJtDe5I7Cm7ZHGHtnHz+snUA1aMHqSo/janHnUTaR6flSyyo0rIjfqPkwcJKXS7OUhMHbQFe2VGXrC3rI85uNtC6O0qqKYa9S1uLtFoThvbmXq78UEkb0mn1icdiEo0N96JJjiRH20leJFYpJ4vG8uswbT9KinUHABIS5h0WJCT84SlIenH7kWyKKwOtxYy5oBXezes47rTKILZY92t5QXbSi5blpISwmDuLsurMUcgMozxTTLRaVAMXhq4jHTy9BevMOsxFPhyLDmMub+65w4cvI94qZBhFzJlY9x+E6QGKFx6AX/a+VdVzyILDYiCqTqyWgGLFWjgl//d//8fll18+2mFMWPK0GkLv5iGlRbCV1DNnVqj/i4bAusNAYbq9/xMHoSLXRWVDGhH/2HnT1FRo3R3F+b6JqwvKWVyeMS7TkWqLvaiyRnmXSrOSRUeq0r1GQwKbjO6Cg922t4aOnUdUqkhypMKkJUkcm/oFQqHOFpzShzNZ7Z7TRiuqCU3xZqI0WTDlJqYep1iiGMbh+9xIqi3xEtma/M+qiqzEvwvvqg+Q/AYi9WloxcnvJyxMLmF/fI9+7tdfI/2697FM7WVQDUSCw18sMpJXhvLhPuuMWXvp6wYr2CTzsSlFwx7TSEv6wPrJJ59M9lMKY9Tx48dpbW0lN3dipnOMBZIk4Q9XYzxiIn39VnJNjcPyOrGgyun2nKQt4E7NdlLd7CbsG7tVu1v3RPFstXJNcTnzS72jHc6g5Bvjq8oFnsQUQ2uJEZ3cSyqjQYX0MLqPHUBKSWxrpzXk0CJ/clhiFSYxg4VjhXcRi3S2E5LDZoL5ye+jKoCWm4vSYMWYmbg9xGyJUiBZerlKOHt6Prm77cOyXSnfkzj56Zh/BGm/nXBKQdJfS5h8PkoHH4hAbPiLhsozalD9ZqQ2PaaSFrI9fW+taH83xtQc57DHNZIGlBPw5S9/mddeew2Dof/TN2zY0LGPVpiYfD4f//3f/82WLVv4whe+0OM5mqaJntRJEipYgLr9NcyrGjG01JNXlMORA8lPNmn5IMpFtcU8/f7+Xs9x2YzkuuODunBMJiIrRGIq4ZhMKKIgqxqlmSnMavMQah27g+qTteyKkoWNayrK2aw2s+lA02iH1DcNlMPxT1KvMzG/05YeBa8fyRWBtCi4IvH+1GlRcMR6LsIcMlDfdv8IBC5MRrIjm2Pum8n3PYTOoOAPliEZRJXq4aB6PCgb7JhOa0g4bkuNkq+zs09NfgHMcU2DS2eWENygoA5D6pLdGMOZcnKWmYauJID6XAGRaTOT/nrC5PNROjjunltmfkQKGolQOfwBedzEZBumY1akigA1C9uo+3PvCxeqDPP042thoz8DGlgvXLiQ73znO8ycORObre9G9j3ttRUmlubmZp5++mkWL17M8uXLuz3+xz/+keeff57m5mYuu+wyHn30URyO4du3OdEp06bR/uc87K0teNfupNZSzpEDKcPyWrFNGqdNzUBWNTLsFlJ1JkxRHZofQg0KkRYF+nj/lvTAUQgp42NQfbKWHVHycVA9080vduwesxni5TmpBA7IOM1RbF32V1vTD6G/up9U8JOp0FZ3EwqiMq0wfMKZczjRvo4s7Wna0+aPdjgTliRJKH4nOnvipLY7NUa23jDgla3JwKSXuGxqGS0bkl2srFNlpj9hMtNVeRRMKpFdHpSrpo/XEh/CGBP212Jx/63PcxT/yHXiiNiysO1PgYoAU5fs5YU+BtYQzx6cSAY0sF6xYgV/+MMfOPvss/s994knnjjloISxrbi4mAMHDvT6+Hnnnddj+y1haCRJol2dhvPAB6SesY+cfzYCwzOwVmUN77bOftDtyLT3cX5X2vgbT3fT8l6Uy+eV8cvNe0Y7lB5Ved0oB7Ru/at1Dh2G9N6rcPZErqshoJ2VzPAEoUdtJRdg3F5PoHyxGFAMI1lLRdKrIKmgxTOb7FIEr14HIokMALfDxHnphbS8O7w39MVd2mylrdiHdMRK2JSLpBcljoTk8MUuxqL+rc/NveHQyBXKixZMQdmxA92aOnKrtgKTa+vPgAbWVqt1QIPq9vZ29u/vPY1UEIShiU5fQGjrW+grDuBwHyDTk8uJJpFOOVz8G2OcMyefPw9DpfRT5QyaaCbSbX+1rcSEVNhz38ge+ezUh+4dt5XRhfGnqfJG8es2zBSdEyksYc71ETkS73UvaeC0yyAywSnNSGGhkknLruEdVEuSSoYr8T3aOK0ZbbOHSOnwF5ESJg9FyiJ29DQkXTuqmoKqOlHUNBTNjaJ5iJGBrOWO2Ge9XFWN+ocX0Pv1WErqycqF40f7v26iGHLd9cOHD/PrX/+aUKhz/0hjYyNPPfUUX/va15ISnCAIcWpZKcG3M/AcOUbG+q1U7ZzLidfEwHo4Gd/XM7csnbf3D0/BuKHITbPRuisCgNeZmEtgTQsjFQR6uqw7WaKp8asgid8hQZhIlFQPms+EtailY2AN4HbJMMbLRwy3eSVeio+m4G8b/qX7ck87BkNn7r3RFkJLjxJ9z0vswtligklIqobol/o+YSR/4VJSiMgpmI5Z0BUHmV6jcPyofgQDGF1DHlifccYZ7Nq1C4inqmpafEeiGFQLwvCImMuRd+7HvLKR/LRWhisdXIhTZY3S46mcSA9xuHEwCfHDZ3l+DoHjMVyWKFZL4s2hxX4YyTmwG8bw0bOJ0Ht/SUEQxifFk4nabMGc70s4nuZVyNhrpH6S5oMXpNvJ32MnEhuZ/UrlXdLAPbUHkXxGQtFsJLN5RGIQhNESSc3BsT8FprUzZcZ+/vHXstEOacQMeZOHXq/n0KFDqKrKXXfdxe7du9myZcuAKocLgjB4kdkLCB3yYGzRUzD3XQzSBNjQPMaFWxVON2ZjN4/++1qK1UB0e/zvfEqX/tWGNAPGjA9zrSI6kKVe20dqDVk0x24azlAFQRglanYOSqMFU07ie0RGDhToJm+GyrLsbJTYyJWkzOnaZmvOMbQ9KUTyp41YDIIwWmJFFSi74hkzBTVvI+nGajnY5BvywPriiy8mHI5v2Lnlllv4whe+wHvvvcePfvSjpAUnCEInrbCQqM+D/oAF19J9lGcH+79IOGW+AzEuKirpdaA6Us6ckke0PZ5amOfukgZerIeCdrSAg2NH/sSxg3/m2N4/cnzPr2jY80Oa9n6T1r1fpG3/LdT7HqDnvluCIIx3anYmaoMNgzfx88EqhSn1Wnu5amJz2oyEto/cRLTXFsbepWODvrgNZaub2OzaEYtDEEaLPGMGSrMNya/HXnaEkqmTZ1JvyAPrz33uc1xwwQX85S9/ITc3F6vVypVXXklpaWky4xME4SRhdxnte7xY3AGmFI+N9OTJoGVzhEtnloza6xt0EqYDnXuUuu2vTg0hFQZQ/bmdByU9quQiJhUSoYYgSwioZ6NInpEKWxCEESbpDchNLvTuxEplks9PUfrkTEE+oyyPWHDkeo1VZCWmgZtTA2h2heDRPHA5RywOQRgtksVMRHUi1VnQ5weYNlUe7ZBGzJAH1na7nTfeeIPq6moAHnvsMf7whz/w5z//OWnBCYKQKDJ3IXKDA1MAKle8P9rhTCrBDQpnTs/t/8RhsLIil/b6+AeT2xrpsr9aw2w4iuQNE4nUjEp8giCMHXLMiWTsskIbUyjO0GPQTa5sFYNewrB/ZFtbFaYnpoG75xwEn5FwRvmIxiEIoymalo+2PwXNFSPXfRx76uRoMTfk7/LSSy/F4XCQnx9vOm61WqmsrOSVV15JVmyCIHSVk0Ms7ETem4J3/h7c1shoRzSp2LcZqSlwj+yLapDV0pnCWZ7epYVLpglDxnE0DfzyGSMbmyAIY46CE52kIZkSC5U5zTHWVRWPUlSjY3VFHsHGkVstM+tl0lIT0/Dts46jHUghVjN3xOIQhNEWLa2M77PWQeHMN5g50zjaIY2IIVfkeeedd7ody8/P58ILL+Tcc889paDGokz3/452CJxo/vRoh9Cjd999l7Vr1/Jf//VfXH/99aMdzoQXypiC+egJrMVHmZbt4z/7MkY7pElDiWhMPeFCy4fNh5tH5DUXlmfQuq1zv15+l/7V1gJdvM2W34kiZY9ITIIgjF2KzQ0BA7aSZtp3ZnYct9miWPZbqMxzsf1I6+gFOFI08DZZ8DG8PatPVpHpR5dQqElDX+wn+McpaGePTsaTIIwGZdo05HfsmAM6nNV7yfxjO3qDHkWe2Fkzgx5Yb9q0iQ0bNtDQ0MDjjz+OXh/f96eqKi+99BKHDh1KepDC2KaqKrFYjFhscrbxGGnReaehvvg2lrBK7QVb+c+DK0Y7pEkl0qYwVXWiL5J498DwN4adJrlo5qPMBK37/mp7O1JBACUwuVaiBEHomeL2oraYsBS2JAysLeYoGVkG5ga8fKDzIasTu1LvwvIMfNtGblANUOpN3F9t9bSh2RSC/qkjGocgjDbJaCAiubHUWZGm+sgqbKJmbiGb3gz3f/E4NuiBdWlpKddffz0+n6/b6qQkSXzlK19JWnDC+DBnzhwaGhoSjmmaxquvvsry5ctHJ6iJLDMDJWojcthJbvUB9JKKok2OvStjRTSgUno4FUOJjo37Gvq/YIimZDtp3tqZ7l/ibsdsPjmtUcOsHIPsEJFDs4YtDkEQxg81Kxu1yYI5L7GXtVEO4nbq+GBLmPW1xfz6/X2jFOHISJyUHAkqme7EjKK06iPQZiJaPH0E4xCEsSHqKUQ78D5aWTtFU19lz/sXE2+xMnFXrQd9N+50OvnTn/7EzJkz2b9/f8efAwcO4PP5uPfee4chTGE8CYfDXH/99fzkJz8Z7VAmrLA9h3CdE0d6C6Vd9twKIyMWVCnYb2dh2fCl4i/0JD53VU5LwtemfDP6jAaQIKCI/dWCIICSm4fSaMWYlZjdIrX5sRviRc0im1Qq81yjEN3I6DopORIK00KYuhSNs8+qQ92fglwjCksKk09s6nSUnS6QIHXhPlzuMOUzJnZ3giEtc+Xl5bFp0yYKCws7/hQUFOBwOJIdn5AkDQ0NfOYzn+Huu+9m1apVPP744wCcOHGCW2+9lU996lNcfPHFOBwObDYb//Vf/4WqqqxcuRKbzdbRn/w73/kOOTk52Gw2WlriN/nbtm3ji1/8Ig8++CAAX/7yl/n1r3/Nn/70J2bMmEFNTQ0vvvgiWVlZ2Gw27rrrLgCuvvpqbDYbX/7yl0fhJzK+xQqnobaZsRJj0RnbRzucSUsOa2TvsbFkSmb/Jw9SRqoF/+bO7RUSKrld0gxtuSAVBtDaXKKNliAIQLzVjdLoRN+llzXhGPYPC5qpssZc1Tthq4R3nZQcCdMy2roc0dAXBQjtKEIyT+zBhCD0RCkrI3bCidSug4IQ5dXbKXKNXOu70XBK+aO/+MUvmDJlCg6Hg0WLFvG3v/0tWXEJSRSNRjnnnHO45JJLuP/++3nggQe4/fbbOXToEEuXLiUrK4tHHnmEp59+moceegiAnJwcdDodP/jBD4B4ezWAO++8kxtuuAGAtLQ0NE3je9/7Hg8//HDHxMr//M//UFBQwLp169i6dSvvv/8+q1ev5u677wZg/fr1ANxyyy2cc845fOMb3xjRn8dEEKuuQVL0hI47Kas+ONrhTGpKRMO708rp05JbOGxlcS5KrHMP5LQMf7fVEIvFH99f3V6Y1NcWBGF8i7W50Dm61z1xWCPEUzHBtz/K+glYJdybasG/ZaRrvqjkdZn4dGQ3o1lU2iWxTUeYnCRJIqJPRzpqRfbIZJdsQj0cIDNXP9qhDZshD6x/9atfce211xKNRlm0aBE6nY6LLrqIF154IZnxCUnwl7/8ha1bt/L4449z55138sgjj1BbW8t9993H4cOHueWWWzrOXbVqFQAmkwmIt1GD+D+Oj3z02EfH77zzTgBsNlvC6xoMiVv4r7jiCsxmM08//TQAr7zyCrfffnuyvs1JRbJZiaiphI878RScwGURbbdGkxLTcG0zsboyJynPZzXpUXYmFhaqzG5NPEkCc+g45AWJRGcn5XUFQZgYZFzoDN1XhmyOKO6Mzs/myCaF6XlpIxnasFtZlIMSHbnCbBaDzGVzD5BiS/wcTqs4huY3Eq2eM2KxCMJYE80sRt2QAQawVJ+gYKGf6eViYN3Ngw8+yFNPPcWBAwf429/+xuuvv87+/ft54oknkhmfkAR79uwhPT2dRx55hO985zs8+uij/OMf/6C5uRmDwYDT6ew4V6cb/K+EeYApTh6Ph/PPP59f//rXRCIRtmzZwuLFiwf9ekJcNK0A/CbMtiCnzTow2uFMeqoM9veNnDk975Sf68xpeUTaOlen9ZJCtsefcI6l2IwuowX0Gn5l1Sm/piAIE4didCPJYHQn7rO2GMJk5XQOrFUZ5ijpEyYl3GLUo30wcq/ntYe5cuEeMtzda51YZ55A3ueC3ORMuArCeBSrqELZ40JqMaBkxaio+Q/sDWBPnZhFd4f8Xc2YMYNLLrkk4ZjH48Htdp9yUEJy5efn09DQwBtvvJFwPCUlBVmW2bZtW6/XfrRSHQ53lsf3+Xy9nZ5wnap2ny2/9tpraWpq4r//+79ZsGDBQL8FoQfR8unokAidcDFn+Y7RDkcANBXsWwzMKhz6fmcJcBw1JhybkeXH0GX1yZqlIhUE0HweNMmJIAjCRxSXF81nwlqS2BJQH2knLTXxXN+BiZMSfua0PMI+pf8Tk2Ca18fH5+/Bbu2hpZekoCsM0L6vckRiEYSxSivIJxYzw/tpyOky7sL9GO0Ks2Ya+794HBrywPqj/tUn279/P6+//vopBSQk39q1a8nKyuLCCy/kscce4+9//zu33XYbCxcuRJIkbrnlFvbs2UMkEuHf//53wrVZWVmYzWYef/xx3nvvPf7617/y5z//GYDNmzcjy3JPL4nb7WbDhg00Nzezb98+otH4B8/SpUspLS3lBz/4AZdffvnwfuMTnDJtKoqsJ3IileyqQ+iNoo/4WKDENCpaXHhTLUO6fmVlDv5jiX+X07qmgQNWkw+pMIASLBrS6wiCMHGpGVmozWYsBa0Jx6VWPzZ994FnZJNCVf44TwnXIKVuJG7WNZaW1HPmzIPdJjw/kprfhGbUCKaJrDxBCFtzkN/IQtNr6HKCzFyzE8uJIHrDyG3ZGClDHlifd9551NbW8tWvfpVvf/vbXHPNNVRVVbF06dJkxickQUpKCs899xwVFRXcdddd3HXXXaxcuZKbbrqJJ598klAoxPz58zn//PO7rTKbTCa++c1vsnv3bi6++GJ27NjBmWeeybp163jzzTcJhUIdLdZ+/OMfs3XrVgDuvvtu2tramDdvHk8//TRGY/zDTpIkLr/8ctatW4fL5RrJH8OEI+kNhHXp0G7CZguzcrVYtR4r2htk1nry0Q82u1KDvIA94ZBJr5CRlpgGLhnA1H4cCtoJR+eeYrSCIEw0al4uSqMFU46/ywMaKbbuk7CqDDOjHsyG8ZueubwiG//R4Z1g1ksKF9YcZnbZcaQ+3t9dU+vQ2o3I1dXDGo8gjAeh+SvQwkZ0ex3I3hiF0zYht8SomTO0BYixzND/KT274IILaGpq4vOf/zxtbfFKiGvXruXb3/520oIbS040f3q0QzglVVVVvPzyy92OX3jhhVx44YUdXx882L3C9E033cRNN93U63M//vjjHe27PnLOOedwzjnn9Hi+yWTiuuuuG2joQh+imcXYG07QXudizrJd/P2v4kN8rGjZGeXSeWX8cvOegV2gweU1pbRsTEwrrM72odcnzupaSsxIaQEwqQTUlfH8cUEQhI+kpqJuTsEws6HbQ3ZrGLDQ9Y2j7VCMi+aVDPw9ayzRoCjkoIUe0rKTJNUcZd3sgzhTQv2ea62qJ7rfi1Qu2mwJglZSTOg1D/p/Z8JF+7FlNZE53Y+pzcpHXQomigFPTb711lvEYokzgTfccAPHjh3jjTfeYO/evfzpT3/qVhlaEE6maRobN24U+6uTJDZjJgCR+hRyS+tIzeraR1MYTf6NsYFVCtfgyuoyAhu7b62Y2kMauC1TQSpsR2v1okniPVcQhO5izW707nC34zZblIy8nlOm/W/HqC3xDndoSXd5TSktHwzfoNqsl7l84Z4BDaolvYKuoB3/8dphi0cQxptg1RLUw06I6NGsCrPPfIPo4RDl0yfW5NOAB9YLFy7k6quvpr09scKkzWZj/vz5FBdPjMIXwvD6y1/+wpIlS0Y7jAlDy8slFjMjhYzY9REWnrN1tEMSunDuNDM1u4/iYhpcXVVO29vdUxjtRhmPs3u1WYuuBQoCxIIlyQxVEIQJRI6lobN0n6wzESIzs5d2NxqUN6fisAw5oXHEnVdV0OOkZDJNywhgNg3sNVxF9ah6CJasHtaYBGE8kWfPJhKzo73rRvbKpBftBVQKU0am2OBIGfDA+qyzzuKpp57Cbrf3f7IwbnXNSkiWd999l7vvvpv77rtPFC1LsrAlCx0S7cfSmDV/32iHI3QRC6nMi3lJsXa/UZWAq2eU0/pOzystNbktdO2AJ1kkjIF6pKJ2IrF5wxCxIAgTgaxLQ9KpoEu8cdW3+3E6et8/Ejghs65sfCyWLC7PQPfu8O+FKc7pPsHZG2fZcdR2k2izJQgnkSSJ9uK5yG9loaQoGOxR5ly4g+je9v4vHkcGPLDOzc0d0HnHjh0bcjDC6Kqvr+/YS/3www/z5ptvJu259+3bxxNPPMGVV16Z0DdbOHXRginx/zakkONqoeS0A6MbkNCN/2iMdQXFCVuJDDqJqyvKad3Ue/piWWb31na2UjNSShhsMgFt+TBEKwjCRKA40iFowJLX5X3EH8Jh6nsSvfWdKKdPzR7G6E7dtBwX2fvtaCOw4JWVNvCbf2tlA9EjA7tnFoTJJLp4GXLYgtpoRdNrlM55d7RDSroBD6wVZWDvXHfdddeQgxFGV0ZGBi+++CLBYDDp+6DXrVvH0aNHuf3225P2nEKcXD0LTQMprMehizDz7O2jHZLQg5bNUS6eGV8FMuklrigvo+W93gfVTnOUtNRgt+NWTxSpMIDakgnSxNqbJAhC8qjeTLRWE9bi5m6PpTr634+cedhK+hDbBg63TJeV2e0eou09t7tK6ms5Qlh0kQGdqzdGIb+dtuCKYY5KEMYfyWgkkD4d5c1MZLeMLaMJV3bLaIeVVAPeRPPcc89x4403Yjb3fiPX2trKb37zG5588smkBCcIwgCkphCRU7AY/bQfTaO87Dgme4Rouxh0jTXRt1VOn5FNoeKgZXPfN7Yz81p7bOdioenD/dXThylKQRAmAjU7B7XJgrnrijVgN4fR6W2oSu9p1KEWhXOqC/i574Mx1XnAZjZwlj2P1n3DV6zsZFOzB54GnlZyAlWnIzxl1Vj6kQnCmBFZfgby7zejhE9g1MGC9W/h46zRDitpBjywbmlp4bHHHuv3PKmvxn6CIAyLSGoeltAOYk0pZGY2MOuCbbz1y9mjHZbQhaZC6mbTgFrClGS0djtmzDZiDDQiFbUTbhP7qwVB6J2a4UV5z4aph/3BVnOErHwnxw70XZCrZXOEs2fn89dth4crzEGRgI8XFtO8ZWQG1QCFOd0zh3qTWlyPErQiWcXEtiD0KDWFgLUY0+ETaK5W0kv20X3qb/wacCr4ihUr2LlzJ/v37+/1zzvvvENJiahSKwgjLVZWCYAurCNVijDjjF2jHJFwKtJtEZwp3dvkpJZpYJUhVSaoier6giD0TpIk5GYXBm/3gaFRCZKR0Utl8C7suwzkusdGW78rqstGdFBtkBTSzP4Bn2+pbCTSMD4KvwnCaAktOYPYNg+KTkJvHp6iyaNlwCvWxcXFTJkypc9zCgsL+cxnPnPKQQ3Ee++9x5EjRzjnnHNG5PUEYSyTp09Hfe8P6PQqwaNppBUGSctvpeWwa7RDE4agJq+nPUcaNvUY5AdQWrJAGj/tcARBGB2y34vFubPbccnXRqpV6+GK7qLtKqsLcvl50+5RTQm/oLqQto0jexNe7g2gY2D7uI22MOSG8DVcOMxRCcI4l5NDkBwsh5vQZ7eNdjRJNaAV67q6OhobGwf0hDfffPMpBdQXRVH4xCc+wcyZM5k1axY7duwYttcShPFEMhoJ4wZAbrbjicSovWziVVucLEoyuidGWcstGEI+pMIAcnDqKEQlCMJ4E9PS0Bl6GBhGZFLtA+/93LIjypoZeUmMbHAWl2eivTPyr1tWMPA08LSS46jokDNnDWNEgjAxBOesINqYisbAJvjGiwENrG+99Vb++te/8vzzzw93PH3S6/V84xvf4PTTTwfEfm5BOFkkvRAAXVSHS41Qfa6YeBqPclKD2G3dK9A6cuKp4VJRkJA2f6TDEgRhHFIsHiRNQ2ftnj6dah9YpeuPuOssGHQjf99VmpFCzkEb2vAXAO8m2z3wwmUphQ3IYccwRiMIE4daWUGo1UskNrHqEQxoYP273/2O3bt3s3v37uGOp1+ZmZmcf/75ox2GIIw5scoaID7hFKlLQ/UZKao9NMpRCYNVk9s9DVwygC18GGwypMXEwFoQhAFRPJlobSasxU3dHrObwhhNA3+uQF2MtdMLkhhd/1KsBk4jk4h/5EfVadYoNkIDPFvDMrWJUKByWGMShImkfcpCYuGx2dJvqAZcvKygoGBc9iCORCK0tbUl/BGEiUgtLkKWjfH/b7Vgb5GYf4VIBx9fNAq83d+j7JUWdLEI0rRWlNYckAZWdEgQhMlNzcpGbTFjLeo+YWc2hskpNA7q+Wz7DViMI/P+IwHr8oppOzw6xY0q8gZetMw7/RBadhif69JhjEgQJpbYgtOINKSNdhhJNeGr39x///3cd999p/w8Vzp+l4RoTs2TgXWjHUKPgsEgr776Km+++Wa/P2u/388LL7xAY2MjN9100whFODlIkkTYmIFDO4oupsOrhDGds4PffX4tcnTC/1OfEObltWC1dL+JdLjboA2kilZioUWjEJkgCOORmp2Nst+CKbf7IFEfbic9XcfBQSQjBptkzq0t4Lfv709ilD27tKaUlg0jVwG8q6K8ga5Wq2TO20tMNaCa8oc1JkGYSCS9Dr9u2WiHkVQDXrEeTlu3bkWv1yNJUq9/Nm7cOKTnvvvuu/H5fB1/Dh8eG70Yx6pQKERVVRXXX3/9gK959dVXueSSS/jXv/7V77nf//73ufrqq3njjTdOJUyhF9HccuCjdHAXbftdzFjbvSKsMPYYdQpzS493O65z6LAEDoNZgWI/QW3xKEQnCMJ4JBkNKE1OTFnd9wpLrX5SLYNPsdbtkkixDu9k7ZnTc2nfMPDiaskmSSoe88AyHLNm7cfgChNTXMMblCBMQNGlK0Y7hKQaEwPrGTNm0N7eTigU6vFPJBJh3rx5Q3pus9lMampqwh+hd5qmEY1GiUYHPku8Zs0aqqurMRj6/6C95557cLvdpxKi0IdY9Sy0DwssSn4z2lEz8y8X6eDjwbKyBszm7jeSKZVGJFVFmuJD87uISDNHPjhBEMataEs6+vQeVl9VDWfq4NOswz6Fc6YM317r6nw3jm2DS1FPtlJPEL06gIG9TiFj9n6i+VFCzB3+wARhgpFMgyj0MA6MmfxQi2VibV4fi15++WVWrOh7Zshms7Fr165BP7fNZhvwuQ6HqJo5bDxuorINszGIXpZIj0XJWXUAhzdAoEH83PuTW2SkvFBHox+2vRdGU0emAm6qOUpFfs8tDR3WRvDH08AjraKNiyAIgyPHvOisPQ8SU21hYPD3X7GtGp4UM03+wVUW74831cIMXxrtkdFbrQaYUjqwNPDcuXvQ2aPEsmT8J9YPc1SCIIx1Y2LFerCOH4+nS7a2to5uIOPID3/4Q2644QZUdWiVNY8dO5bkiIThEnHkAvF0cLUuhYYd6cz9+PujHNVYpjF9tpkzFuopD/oxHGwl/UgrK8tVli0z480e/kI9q6YeR6/v/m/TmGnE5D8ORhXK/ASUjw17LIIgTCyKwY1kUKCHfrFWYxirbfATiLGgypri5O4nNugl1qbl094wuoNqgNwBtNnSGWJ4ag4Ry4kR9c1ClUQ2niBMduNqYN3c3MwnPvEJbrjhBgAeeOABLr/8crZv3z7KkY1tzzzzDF/60pc4fvw4lZWVzJgxgzfeeIMvfelLfP7zn+erX/0qubm5PPHEE9TV1fHwww9z9dVXA/Daa69x1llnsXr1av7whz9w1VVXkZWVxZIlS9i2bVuvr9ne3s4999zD3Xffzdlnn823vvWthMdbWlr40Y9+xPnnn09ubi7XXXcdLS3dq5YKgxctmtbx/8Z2E5H9DpEO3gOzVWL+Ygurq8B7pBWntZ0ZZ/uZMW0PM08/TkltO+6Yj+lqgDMW6plZa0Y/DDk+ualB8jNbe3wspfzDG+EyH6ovnahUlvwABEGY0BSnFyI6jN7ug0WzFCKncGhvbMH3ZXLTBp6t1icNLq8oo+WD0StW9hGHKYZN6b8ieO6C3egsMWI5Ck3hT49AZIIgjHXjamDtdrt57LHHCAQCHXuBf/WrX1FZKfoG9mX9+vVcdNFF5OTksHPnTrZu3cq2bdt46KGHePnll6mqquKaa65h0aJF/O1vf+OLX/wiiqIAMHfuXOrr62lubqa8vJwnnniCl19+mUOHDnHRRRchyz3PLF966aXMnDmT+++/nyeffJKvf/3rbNiwIeGc66+/nueee47f/e53PPPMM4MqmCb0Tq6uQf0whdmggsOnkT+rjpzp3QtjTUbuTD3Ll5tZnBnFfqCFnCkhalY1kGv4AMOxOlA1aPFjO3GAQscHzFx2jOLyZkosbSwvirFiuYnquWYcqcl5+1wxrQ6pxwUjDTt1wIdp4G2id7UgCIOnZmajtZixlXTvZa3zB/CkDe29TIlqrMrNPdXwAFhblU/rO6M/qAaoLGqnvzV8vTmKe8YR5EyZSGC2WK0WBAEYQ3usheF3cnGxa6+9lttvv521a9dy0UUXcdFFFwFQWlrKfffd17Fn2mazMXfuXF577TVmzJgBQGVlJddccw3f+c53ePPNN1m8OLFK8TvvvMNLL72E0+lk48aNhMNhamtrE87Jzs7G9GHBggULFrBq1SpeeOEF6urqyM7OHrafwWQgWcxE1FSsOl+8qv4JOw0feKi9/F2evWfNaIc3qipnmshqCWBuUMlfEsXmrwN/BPpanGhtx0o7BRZgpo2I3UNRxMj0DAMhxYQ/ZqYpoGP/3hi+psFttZiR1YrH1d7jY5ZSC4ZgK+hVpLIA/rqx2W5PEISxTcnLQ22yYC7wwVtdHgyESHUMbYsYgO+9KCW5Dvad6D91ujelmSlYtxuIMfQ4kqm0sP/91fmLdqIzKoRyVZpabqffkbggCJOCGFhPUnp9fN+o2Wzu9lhPx7oqLCwE4j2su9q7dy8AP/7xjwdc1GzatGm88MIL+Hw+MbBOgqgzD2u7DwBLyEj9jjTmXfoez335TDR1XCWqJInGwiUWbId9TF3ejunEMTjRfb9hv9qCmNuCmIGO/gIGIN/K0ik2okYrLRErL/zNgq+p7zstSVJZWN57FkFK3ocD/mI/SmsuCumDj1cQhElPslpQmhyYc3qeQXSlRhhqAqOmwFJ3NvtODKIZ9klMeolF+ix8obGxWg0qHqMP+tjmbbSHcE6tQ/bIRIKzUSXXiEUnCMLYNhnvsCetoRYug/ie6ZM1NDTgdDqZP797emp+frygyR//+McBx3Ls2DGcTidFRUVDjlHoFC2p6Ph/q6RhatTjzA5QsWpoNz/jmU6vsWKZGbffx4zTTmCqOxpP904mfwhdfROWo0fIbtzNNYt3cc7ZAQw6pddLFhU1Yrf2cjOpB1v4CABSZSvh4KLkxisIwqQSa3FjyOg5OybFHD6l5255L8r0vLQhXfvx6aX49o+VQTUUuMMY5L7jyV+8A51BJZoDjZHbRygyQRDGAzGwniQ8Hg91dXVs3ryZ5uZmTpw4AcT7Vg9EU1MTTz/9NBCvxv7Tn/6UBx54AKfT2e3c+fPnU1VVxac+9Sm++93v8tJLL/HlL3+ZV199FQBFUfjXv/5FY2Njx/P985//5Atf+IJou5YkSmUFqtL5z1s6Zsd3LIXaK94bvaBGgc0hsarWQLqxjfKig0iNvhF5XSkUpUzex03n7mNRtQ+pS4qj1ShTU9pzey0AR6UZXSwEkoZUEsTP+cMdsiAIE1jM70Xv7nkAbTWESHGd2u1grW3wGTXLpmbRtnHwfbSHU2VF35MMZleA1NIGlFSZUGw2mpTa5/mCIEwuIhV8krjhhht48cUXOeuss1i7di1GoxGAn//851RWVrJuXXz/5ve+9z2OHDnCiy++yHPPPcf558dv6B0OB48++ih///vfaWxs5KGHHmLt2rUA/PKXv+Sdd95B0zR++ctfcsUVV/DMM89wyy238M1vfhOv18tnPvMZli1bBsSru4dCIebPn88ZZ5xBa2sr9957L9dee+0o/GQmJslkIoITK/FK646ojqb3vVSfux1Laphw28SfwMjINVDjiZJX6Ce1dT8Ek7xKPQD6UIh5WQeZkWPjjS3pbD7qBCRWVNRj1PWea+jwBKANKAwgtxWiSfYRi1kQhIlH1nmRTD1n0BjlINn5BvytQ185bt4S5eo55fx2936CA+hBnemyknXIRpjes3pGQ547AH205s5b8gGSXiWSq6MpfJvYWy0IQgIxsB6gJwPju3BQaWkpb7/9dsKxH/7wh93Ou+OOO7jjjju6HXe73bz00ks9PvcVV1zBFVdckXAsPz+/11TwpqbulUmF5Iu48rH6PxxY61WajpoxWWVmrdvCG4/PG+XohlfZdBPFSjvls9swHTs62uFgVYOsmH6I2WV2tuxJoyy7qaeWsgDobDosgcMASBUtBMMfh+FvpS0IwgSm2NKRJA2dNYIaSqyjIvn8uJ2nPkJsfSfKurwi3jU3sfVIH+0zNVjjzqNlx9hJAQewGGTs0d6zmmzpPlIKG1BsCiF1LprkGMHoBEEYD0QquCBMULHyLm3ojtgJtlqYf8XE7mk9d4GZKXo/lXOOj4lB9clc5naWTD+C1McWDMd0I5KqABoUxWjXnTlyAQqCMCEpGdloPiP2KT1sQYnKpLn6X2UeiLYjMaYccnJhdVGvk4cXzSwec4NqgOnl4T7fm7NXHkWSVCI5Bpqit4xgZIIgjBdiYC0IE5QyZSrKSfusXVGJE5uyKFt0kPQe+pmOd5JO4/TlZgrNPqaUHURq6GPFZAxz2Jrj/5MXJBYoA0ksVwuCcGrU3Dy0FjOWkuYeH3c5+sh/HiQlpqFs1LimvBxvauK2o1mFHuRNY6OtVlflxb232TLYY6RkHEI1qwR1c8X2HEEQeiQG1kK/NE0jFhtbBUaE/klGAxHcHV87TQry/nj7s9rLJ9aqtc0hsXqBnuKsJvJteyBwalVuR4ulxITZfwyIp4G3y2eNckSCIEwILidKkx1zfs+pznZTiF6XmIeoZVuUlXIOi8szAUixGqhsc6EmZ3E8qSRJJV3f+2SsrUJDQiOSZaI59qkRjEwQhPFEDKyFPv3xj3/k+eefp66ujssuu4xAIDDaIQmDEPXkJ3ytO2wjGjJQe/l7JPsmarRk5xtYVqEwZcoJUpv3gTI2V0P6JWl48ho6vtTyJML6haMYkCAIE4nc6MKY1XPLLYsujDsz+WV3Qi0Knq0WrqguZV1RMYHjY3BUDcyrbMcQ6X1C1lYUQTNoBEy1aJJtBCMTBGE8EQNroU/nnXceR44cIRgM8tRTT+FwiGId40msfHrC16kRPcffzSK9qIWyJQdGJ6gkqqgxs6A4yNSSgxiO1SXlOa2eNpBGvlKta54ZU6A+/kVmkFhkCkii5KwgCMkRbc1En95zurMhFCA7d/jq2fo3yrS8N/b2VcdpzC7re3uUzeMjkmmhWf7ECMUkCMJ4JKqCC8IEppSXo7yhR2+IDxTd5hh7djnhtCPMv2ITe14vHuUIh0pj4RILZd4WPJH90HKqA2EV7/TDpNccwuIJoETN+A97adqSSdthL8PdU0WXqscp7e34Wqr04dfEDZwgCMkTkzOQzL28V7YGcKdOjCymwaqYEsESauvzHIuljjbLaaBN/FaVgiAMnRhYC8IEJul1RHRubHSmGOsO2lAViZkXbOPpO84lFjKNYoSDpzfAiqUmyvKPY647fErPpTPGyJ6zF3flUQz2ztUUvSmCq/QIrtIjRKNOfEfyaNroIVQ/PAVr0mfH0LV1piGqGRZihmnD8lqCIExOijkdSdXQp4ZQ2qyJD2oanrSxuqI8vE6raYXeu2xhSJfQmX00q1eLvtWCIPRJDKwFYYKLeIuwNXUOrJ1hibrNmeTOOs7Mj21n4//NHL3gBinFpWN5rUqJdx9S3dCrfptTA+TM30Nq6Ql0xr73ZJtMPrwlPrwlEFTz8R0vpv2QleAHoPhOfTeNtdSMvW1r5wFPmAgVp/y8giAIJ1MycqDVhL28gbZ3Cro97nSEgcm1IptfKJPiq+/zHHuFStSUB5K5z/MEQRDEwFoQJjh56nT4z8aOrz0WmQ+2eMiddZz5V2waNwPr7AIDS2eHydb2QMPQVlYkvULpWe/iKGpA6mVMHErzIqkqprZmdF16mtp0h7HlHIYcYAHEJBfhaAbhNiehOivhA3qCB41o6gBbZEngyT0OJ9cEnOYnoL9gSN+fIAhCb9SCAtRGK5aSlh4H1jZ9CL3BgjI264sNixVL/ND3uBp7XpCIMW9kAhIEYVwTA2tBmOCUkhLk1wwYDJ13S/p98ZTmKcv34cprpfWIa5SiG5gpVUYWV/tIbdoL6tD2AZpSgpSfvxFTWrDHx2NWB/7pLoxp2wGIanqUqBct5EIKmdEHNIxtQYx+H5KqARo6AtgsAWwWwKtBFUR1WRz5xzwCW/rvC+uqNWEMNCYcU9KdKPqcIX2PgiAIvUpLQ97hwJzX835iUyxATqGXw3snx8g6I0cjrflov+dZ01oImqpHICJBEMY7MbAWhAlOkiQihnQMHO845o1o1G3JILuqntrL3uPvDywfvQD7Mfc0E7VT6jAd6/8GqDeO7CZK1m5Cb+1+w6hKOtqmFCHl7cSoO4aqOJB0YSRJxmA+Dubj4IqfK3/4py9yxEh60xEcHhcN71lRWnu+QufU49T2JB7MDhIx1gz6+xMEQRiIWJMHU+m+Hh+TWtvIyNBxeG+PD084q05vh4Z+2jNKYDbW0WI6Z2SCEgRhXBMDa0GYBKLeIuwNnQPrVLPC8XfjA+v5V7w7RgfWGivPNDLDuw/pWPOQnyW94hB5y7cjGbqvdAeycolNacFgfg9FScXXeBXtvrMBHXpDPQbTUQzGoxiMR+L/NR1Bb2hCVa2oigtVcaJ8+N/41y50ujYs8/Zi2ekjb6qJFrWcto1hula98c6KoWvrsqq9oIWA8WND/l4FQRD6EvXlYHVv7/nBmILXMzlWq9O8EhmBI/2eZy4yoDe2EpZEMUlBEPonBtYD9IP0P4x2CNzSKPZdCkMTq6iChjcTjhn2xtPBM6c0UlR7iAMbuu+5Gy1GE6xdK1Ek7YD6nvuu9k8jf/EOPDMPdmsHHbWlEpiegtG1A51qwd98CYHWdWiareMcRc5GkbOJMLfL8ypAX3uoNQze+zHMcqB7uxUPW3Esy6Fhl4vY8RgA1nIztpMLlgHktBM2zEMzpA7x+xUEQeibrM9CMvbenjDNGQGMIxfQKFm1KgxN/dfqsJfKRE25II2v7hmCIIyOUy9pKwjCmKcW5CPHEm+WshWF+p3pAMy/4t3RCKtHqW4dH784SlFkKwSGNqiWdArl524kfVbioFpDo7W8hNDCBgzOD2j3raX+0GP4W65MGFT3rb/CZBJtLdeizW1Ds8TnLs3+Y+Tm7SLtNCOSETxZdd2u0mbH8JmuG2AMgiAIg6e4spFiEkZPe4+Pp5qGOpE5fjjdOnLk/lerAaw57URMY2fSWRCEsU0MrAVhEpAkibDRm3DMalBp2pAFwOz1WzCYRj8FUG+Aj5/vI71+J8j97H3rhdEWpuKSf+Moako4rqHRWl2Mvug9Iu3zqT/0CL7Gm1EVdzJCT6DI2YQNFajzHR3HJFXBFd5O/tyjGNsTYyMvQMCyBnSinYsgCMNHyc1DazZjK2/o8XGzEiDFNbFvDZevjCL5ep5Y6Mqa0kzEmD/MEQmCMFFM7HdPYVS0trayadOm0Q5D6CKWVdLtmHl/PB3c7g5Rdc6OkQ6pmwvWh7Ef3T/k613Fx6m4/HXMXVZjVElHy5x8JM8hGo8+QEv9XSjy8FbeDvjWoU6PoDoSB8v6SPeq5PL0VILWs4c1HkEQBDUnG6XRiqW4pcfHdW1+cvIH2C5wHEpx6ig0H+//REBn02E2nBAr1oIgDJgYWAtJdeTIEc4880w2btzY/8nCiIpOr+p2LEeWadybBox+Ovis2VHyWncP7WJJpfD0LRStfRe9JXHlXdEbaZ3vBXuIxqMPEQ1PT0K0A2EkIK9FW2bp8ywtP0Sb8+IRikkQhMlM0huQG1y9ttwiGCEjc2gtDceDxaer6OoHVgzTUmJAr28mrBeFywRBGBgxsJ4EVFXl73//O+eccw4vvPACq1evxu12s2bNGurr67ntttvIyclh2rRpHDp0qOO6xx57jJtuuokrrriCpUuX8ve//73jsS1btnDbbbdx//3386lPfYqcnBxefvll1q9fz5YtW/ja177GjBkzuPLKKwHYvn0769ev59Zbb8Xj8WCz2Zg+fTo/+tGPANi0aRM333wzubm53HTTTR2vo2ka3/rWt7jqqqtYvnw5NpsNl8vF6tWr8fv9tLe3c88993D33Xdz9tln861vfWuEfqrjUE4OsVji6qlRr9H4HJwnEQAATfhJREFURnzltmL1blIy/aMRGdmuEEuzh9aj2uwKUHnpv3DPONKtSJlsstK2wIGsc9N49DsockaSIh6YaKiGWIET1dP74DoytYyYeaQG+4IgTHaxliwMmb2nQmd4Ir0+Np7ZUiRKXfUDP78wSsScC5LYoiMIwsCIgfUk0Nrayn333cfLL7/MsWPH+OMf/8itt97Kq6++yu23385XvvIVnn/+eRoaGnjwwQcBuPfee/nHP/7Bj370I375y19y7rnncuGFF/Lyyy8D8Nvf/paf/vSnvPjii6xevZqrrrqK6upqfvOb3wBw//33s3XrVp588kn8fj9nn302K1eu5P/9v//H1772NQB++MMfctNNN/Hiiy/yxS9+kR/+8Ifccsst/OIXv+DEiRMAPPTQQ/z0pz/l0Ucf5S9/+QtZWVnU1tby4osvkpKSwqWXXsrMmTO5//77efLJJ/n617/Ohg0bRuGnPD5EzN0HlraD8aJdeqPKvEveH+mQsBtjfGzBYaRYbNDXeqcfZNol/+6W+g3xyt/+BRKhyDxajn8ZTbMmI9xB84fWoyzv+bWVfPB7149wRIIgTGaRUB46Z++DZ6c1PILRjJzTlkgY6gaWBg5g9QaIGkUauCAIAycG1pOA2+3mjDPOAODqq6/GarV2rCSfddZZZGRkUFNTQ3V1Nbt37+bAgQM8+OCDnHnmmR3Pccstt2AymToG3tdccw0Al156KevWreNb3/oW6enpHecbDJ2d3P75z39SX1/P0qVLAVixYgUAaWlpHed8tHKdnx8vEhIOxz/Yf/Ob3zBv3jwsFgt2u5358+d3XPfOO+/w0ksv8ac//Yk777yTe++9l9ra2iT91CamaE73fdbZUYWWQ04A5l8xsnvj9ZLK+gWHMauDu5GTDDFKz36HvBXb0Rm7FzkLOz20z4vi912Kv/laRvOtTlXSCLlnoBTYuz0WmrYQ1ZDew1WCIAjDQ7ZmoTOoQM8ZQjatHaSJlQ6uN0BZZlNv33IPNMyOZsKmwuEMSxCECUb0sZ4k9Hp9wn9NJlPC1x8dUxSFjRs3oigKdnvnQMBms5GXl0ddXV3CdRZL3/tHT34tn88HQCgUIi0tjYqKCgBWr14NwOuvv84TTzzR7dqPrvvo2tNPPx2AvXv3AvDjH/8Ym22grZImN7myGo68mnBMJ0HzhizSCnzkVp0gr+YYR94f3sJecRrnVR8hzRoY1FX2jBaKz34PY0rPg/GgN5tIhZ/WhjuJhiuTEegpC4VXYV5wAP2hzpX1WJ6H9oxVoxiVIAiTkZqVjxbSY8pqI3rc2e1xQ9BPdn4OdYdGv1NEskyZbsBSf2zA5xuzTZj1DTSLwmWCIAyCWLEWuvF6422Zdu7cmXA8GAxSVdW9ANbJpA83uapq5yriihUrmDZtGj//+c8BeOaZZ/jCF76A0Rjvq7xx40Zqa2vZuXMn559/fsLz3XzzzfznP/9h9+7d1NXVsX//fq699lqgc3X7j3/84xC/08lHy8wgGus+GeI8aur4/+W3/mdEYllWWk9hZuvAL5BU8pdso3z9Wz0OqjU0WqeWEJqm0nT8G2NmUB2nI2BfgVzx0U2sSmDGWaAz9XmVIAhCsikFBWhNFmxlTT2f4GsneyTmVkdQeXkEYsqAz7fkSehpIqIvHcaoBEGYaMTAWuhmyZIlVFVV8fOf/5zm5nj1zB07dtDU1MRnP/vZhHM1LTGvKi0tDUmS+Oc//0koFGL37t2YTCa+9rWv8dprr3HVVVeRnZ3Npz/96Y5rvvOd73DgwAGuuOIKjh49CkBjYyOBQIB169ZRVVXF5z73Oe69915++9vfkpqaCsD8+fOpqqriU5/6FN/97nd56aWX+PKXv8yrryauyAqJIpbMbsfSWvQE6uOr/rWXvUdezcBn9odielYrM0tODPh8R2YL0694jfSZh5D03XP5YmYbzXPL8FsW03j0QRS5+/c42mS5jPCMckAjXD6NqFdUmhUEYeRJNityo6PXllsAWVmDr3kxlmWlDC4zypobJmrORtN138IjCILQGzGwngTeeustfv3rXwNw9913E4lE+MpXvgLE9zbv3r2b3/72t2zatIm3336bX/3qV/zxj39k6dKlrF27ljvuuIP777+fF154gZqaGiKRCPfddx8A3/3ud3nllVc6XislJYW77rqLv/71ryxevJidO3eyadMmrr32Wr7//e/z0EMPcccddyTE98lPfhKbzcaaNWtYsGABCxYs4KqrrmLr1q1cddVV5Ofn893vfpeHH36YKVOmdFyn0+l45plnWLp0Kd/85je57bbbKCgoYNmyZcP7Ax3norllPRzV4X83XthMp9e44NvPD9vr56QGOX169wrePZIUCpZtpWz9W5hcoR5PCXjzqZ+6mqaWewj61wBjtwdr0LKKaG0W7TWLRzsUQRAmMbk5HVNuLy23AHfqxKkMnurWYQv2sjrfC6s7QMQs9lcLgjA4ktZ1yXGCa2trw+l0smHDBhwOR8dxVVVRFIWCggLMZtFaIZmampq4/PLLee2114B4YbOsrCw+/vGPc99996HT9T6/87Of/Yy77rqL9vb43lSHw0FNTQ3f/va3mT179qBjiUQiHDp0CL1e3+frTmhNzWT85aFuA9twoR/7tZ19pB+58Aq2/rUiyS+ucc2CPbhSex4kn8yR3UTh6i2YnD2fqwIt2atptp+Dqo5sG61ToZcOoWhi354gCKPH8c8f4Dj9NfZ9Zm2Pj0dyc/nR454Rjmp4zF+mZ6H53QGfL5kkyj55kPaMmbSmnDOMkQmCMB4EAgFqa2vx+XwdWbO9maQjC2Ek6fV6ioqKePbZZ3nnnXd4+umnqa2t5cEHH2Tz5s19Xuv1ernyyivZsmULr7zyCt/85jfZsWMH999//whFPwF53ETl7sXeLIfshFs7J5U+dv8L6PQD35M2ENO8bf0PqnUKhcu3UHbhhl4H1VF7KkdyvkSj9bpxNagGxKBaEIRRF9UK0NmjvT5uCgew2gaSVjT2Fef1P5F7MkuBCZO+kbBYsRYEYZBEVXBh2F133XWUlZV1tPyqqKjA6/Xy0ksvUVLSvf3TRzZu3Mgll1zCsWPHcDqdlJaWUltby1//+ldqampGKvwJKZxagDmUWJwOTUdouxvLafHK71lTG1n8iQ289sjCJL2qxsKy+j7PMLsClJ33do8Dag0NxaMQSinghPR5FCk7SXEJgiBMLoorF51OA0kFrfsai9TSRm6Rnj3bx3tlcA2PsXVQV5izFAxaAxFD7/cngiAIPREr1sKw8/l8vPXWWwSDQQAUReHHP/4xP/7xj/tMqfD7/Wiaxj//+c+OY++99x7hcJg777xz2OOeyKJTeq7u7jiSWKV6zZdexpI6uB7TvanMaMOZ0vvKQWpeA1MvfqPboFo1qUSKIgTnRGhyn8Mx6X/EoFoQBOEUqAUFaAEDljxfLydo5OYnN2NpNOSXGDE2D25/tSUzTNSUJQqXCYIwaGLFWhh2P/7xj7n77rtZuHAheXl5uN1ubrvtNmpra/u8bsWKFXz729/m61//Ot/73vfweDzMnDmT3//+92If/ClSpleivKNHb0i8cdLtchFrP4rRHl+lSPEGOfOuV3juS2ed4itqLCjrvQp4xowD5Czd2VHxW0NDcSvE8qLI6TLq4Xzqm7+JKrlhYmQnCoIgjBrV40FpsmErayR8OK3HczI8EWB8twScVilDeHAVzi1OPxFz0fAEJAjChCYG1sKwKysr47e//e2Qrr3tttu47bbbkhyRIOkNhA2Z2OnSVkvRoztshWn+jkPLb3mDfz1WS9MB95Bfb0aWj1RHTyvfGgXLtuGpPhz/yqARzYsSy42i2TSkFgO+t6+jPX2dGFALgiAkiSRJyE0uzIWtvZ7jNIcY7wPrvPQAXT/m+mJw6zHa2giaxHYzQRAGT6SCC8IkFcmb0uNx3b8y0U5ayDZaZM77r7+fwitp1JZ031st6RSmnL8BT/VhVLNKuDxMYImfaHkEzaShvZ7BsR2PxAfVgiAIQlLFWjIx5fl7fdwW8wPjt3GM0QQpsd57dffEkmfEpG8ibBL7qwVBGDwxsBaESSo2ay49NdtTj6Si2524t2zORVsonn9oSK9Tld19tdpoD1Fx6b+xTGsgXBmifXGAWFEUDKA7Yib0/bnUpTyMlin2UguCIAyHSLAQgzfY6+O61jY8WfoRjCi5plYZ0DW2DuoaizuKQa0nbCoalpgEQZjYxMBaECYrl5OI0nPxOOX5Qogm5l5f8K3nh/AiGrUliXurbRktTLnpFdTTGwie1k4sNxZ/J1JB928PvkeX03zmPZCSMoTXEwRBEAZCNhehs/RR9TsqU1gyflesy8vC9Dh73AdTeoiYKRNN5ximqARBmMjEwFoQJrFwWlGPxzWfBd17roRjJQsPMXt9333Hu6rJbiXFHun4WmeKkn/vK0SWtiFnyB37pqWwBL8pxP98NW2XfgpJFKcTBEEYVkp2PqCBrvfq3zlZvfe6Husy7W2Du0AH5v/f3n3HV1GlfQD/ze0tPaQ3SAKBgI3qir4KooAssAsIVlBABXkXAdcFlVdFV9e1gd0V0BULqIguoLRVo7IIGooFYUFBiAklQPqtM+f945oLEXJTbpmE+/t+PvmYO3Nm5jlPMLnPPTPnRFXDqe8YmoCI6KzHwpoogrkLz2t837pMSHUNf0UMf2gddIbmrmuqoHduw2erOz7wb8gZDd+oaY7oIb9YAMd3aagcOQmSoX1PlkNE1B4o6ekQlQaYcxp/DjnhjJNOtn2xiRJMlS1bZsuYaYDOWgeHkYU1EbUOC2uiCCbn5cHj1p95p0cHfJ7UYFNizglcPuuzZp37/LRK2CwnR6vTpnwJqbDhCILm2yi4XyiEp9yGEwNvAOJiWxQ/ERG1jqTXQT4eBUtu4wWoTaoNY0TBU3gOgGp7i44xJUswaI9xqS0iajUW1kQRTJIk2E1pje73bEqBdLzhqnzD7vs3hj+4Fv5ni1XQ65Rnq2OG/BeWIT+fcmJA+jAV7uX5ELIWJ84bAZGd3cpeEBFRa7hPJPhdcktfVQVdI5+9tmU56Y1PytYYo80OnXIYDgNHrImodbiOdTN91v8ZtUPAJV+0bj1nj8eDTZs2Yfny5Zg/f35wg6J2z5XTDfjx50b2aiDWpgPXNNx/xZ8/Q3Lno/jnTVfDVXf6rds90ytgtXhv+bb2/QWJt27z7ZOqtVCWdoL8i3dyshPp/SGff35wOkNERM3mrs6AOe+rxhvUOpCVp8FPPyjhCypgAnFSRYuPMsTVwq1LhKLlxGVE1DocsY4A27dvx7hx47Bq1aqwX9tut6NHjx6YOHFi2K9NzeM+73woitTofnl3AjQHTKdtP3fED5jx8T8Qm1HRYLsEBT1/Xbfa1PUoUv78H0j1v2ncgLIkD8qvRXWluQDuy68ISj+IiKhlnO5caBP93zKdldW+JjDL7qyHrvx4i47Rp+qhj7LDxeeriSgALKwjQK9evXDZZZdBpwv/DQpCCLhcLrhc7esPcySRLGY4RJzfNvLqbOAMAxaZ55Xhz5+/gOzeB33bemVUwGJ2QZ9ZidR7P4dkOHmg9HEKlCPeNbJrRQrso64NTieIiKjFPDHZkPSNzwoOAMkJ7evvd9euLsDjv0+/ZcsBdDYHHAY+kkRErcdbwSOExWJR7bq7d+9W5drUfM6kXFiONf4Jv3LYCv3OKCjdq0/bF5Nag5nrX8b+v18E538yYDDI0MbXIe3+z6CNcvvaaX4yw73J+zy3wx2F6msnQZIaHyknIqLQUrJzAEUCdB7vhJVnEKuvA6DOe4jWSI+vAX5p2TFmwwnotcdxgiPWRBQAjliTKiorK+F0OptuSGHhOrdXk208H2YDrjMXwlqTjNz/+wwp43dAY3Uh7f7PoO9wcvIYqVYD9zt5AAC324DK4TdDMnGtaiIiVdmsEJUmWDs1PjO4yd7C9aBVZDRLsNlbdhu4JloLvTgOg1IKp5Ej1kTUeiysI4iiKFizZg0uvfRSJCUl4YYbboDH412T2G6345577sH06dMxZMgQjBo1Cnv37gUAbNmyBWlpabBYLKiqqkJZWRnGjh0Li8WCMWPG+M7/4osvYsKECZg8eTKmTZsGACgrK8PTTz+N8ePHAwCqqqowb9489OjRAxs2bMCgQYMQHx+PoUOHorKy0neunTt3YvTo0Zg2bRoSEhJgsVhQWFiIF154IVzpiizpaXC5zX6biDoDpK/i/baJv+Z7ZL+0Gsackz9LKIBYkQ3YvVPLVna/EkhMDDhkIiIKnOd4LMx5jRfWUkUN4jqEMaAAFJyjgXS8ZR8E2PJ10GSY4dYlQNb6fyyKiMgfFtYR5PDhw3A4HFi6dCmmTJmC5cuX47333oOiKBg+fDjS09OxYMECfPjhh3C73bj88stx6NAh9OnTBzfffDMAICoqCqmpqVi2bBmSk5MRF+f9I7R7927MnDkT8+fPx8svv4z4eG8BtnbtWsyePRuy7H3eyWg0ori4GOXl5SgvL8eyZcvw5ptvoqioCP/4xz8AANXV1Rg6dCgGDhyIZ599Fvfddx8A4Pnnn8eUKVPCnbaI4bBmNNnG83EmpBr/vza00Q2fx9MUx0Le6/13YvfEQu7Tp/VBEhFRULkrk2HMqvTbplNey55ZVkteJ0eLj7FEVUMX5/x1tJqPJxFR67GwjiApKSkYOXIkUlJSMGfOHADA3r17sXTpUmzcuBFXXnklAO/axrNmzcKRI0fw6quvAgBMJpNvXz2j8eStvFarFVqtFtdccw1++uknzJs3DwAwYcIEJCcn+57xNhqN6NXLe9vx+PHjER8fj8GDByM1NdU3Qv7JJ5/gyJEjuOSSSwAAAwYMAABfEU+h4crv3nQjWQOxIhtSlbZZ59Qc0cP9YY7vdU0vzgBORNSWOOs6Qp9W47dNemr7mMAsyeT/A4LfkvSAsbYURl0ZnKac0ARFRBGDhXUEObUori+UFUXBpk2bADSc4Cw/Px+A91bu5sjIyMCiRYuwdetW9OzZE4sXL/btO7UA/20c9XQ6HYQQAACDwbsucv2t4Xa7HXFxcejatWuzYqHW8fToAVlu+leC/GMcPAt6QPNVLOBvEMMlwbMsFxDec9YpHaD06BGcYImIKChcmnxoY/2P9CZY/C/J1RYkJGtgPF7eomMsXYyQonXQK+VwGLJCFBkRRQoW1oQOHbwPT506e7fd7v0j2uPXQqi+GHY4vH98FUVBdfXJGaKPHDmCq6++GsXFxTj33HNxxx13NNjfEgMGDEBBQYFvtPzdd9/FXXfdBb1e36rzUfNIej0cmmY+SCdr4F7dCeIfXaApM5z5fBtSII55P6wRAqj93VXBCpWIiIJETu0ISSv8trHJ/ke024LCcxXA3rKRdWuCA1K6EQICTmNOaAIjoojBwjpCCCF8I8KAtzCu337DDTcgKioKTz31lK/Nhg0b0KlTJ4wbNw4AkJ3tnSnz4Ycfxq5du/DII4+guroapaWlOHToEBYuXIh///vfyMjIwKxZs6DX630jzy1lMBhw33334bPPPsONN96I1NRUTJ8+PZDuUzM50zq3qL1y2Ar3S4WQPkqB5Dh5J4JmjxWeLam+17WadCj5uUGLk4iIgkOkJAEeCRpz40WptqIKWm3bfs46O7W2hUcImFxl0MfUwmlOh0eTHJK4iChysLCOAKtWrcKaNWtQUlLim1V75syZAIA33ngD5eXl+PDDD2G32zFs2DBMnz4dxcXFWLduHWw2GwDgj3/8IwYOHIhnnnkGU6ZMwcCBA5GdnY3u3btjx44dGDZsGP7+97/jzjvvxCuvvIJ//vOfMBqNmD9/PkpKSrB+/Xp88MEH2LRpE9566y0AwIwZMwAAjz/+OA4ePIi1a9di1apV2Lp1K2666SY888wzeOqpp3DHHXeEP2kRyn1+Lwj/AxdnIMGzOQ2eBYXQ7LJBqtLC/c7JIlooEuou/X1Q4yQiouCQJAlKhQ3WgiONN5IVdMxv8R+HsNEbgDi5okXHmHJN0DprYNSUwG4qACcuI6JASUK0/G10e1ZVVYWYmBhs2bLFVzQC3hFcWZaRlZV12jPBFF7Hjh3Dddddh88++wyA9/nrlJQUjB07Fg888AA0mtZ/HuR0OnHgwAFotdqAznM2i138KIz6AG7708qAfHJys2pdR9Rdc3MQIiMiolBIOHAnXL8oOPz2eY222SnlY91a/8syqqXnRRpcbNsOtOAdbcLFWthsBxGftwO/pE1BjemSkMVHRO1XTU0N+vTpg8rKSkRHR/tty8qC2hytVoucnBy8//77KC4uxttvv40+ffrgiSeewDfffKN2eGe9moKLoSgBfHJ/SlGtyBrYBw0PQlRERBQq7pp0GHMq/LZJimm7E5h1y6tpUVENAGYchSZVB0UC7MaC0ARGRBFFp3YARL918803Iy8vD1dc4V2aqWvXrujQoYPvuW8KLc/vfodjUVGI+/o96HSegM5VbcuHSEwMUmRERBQKDndnWNM2+W0TjRoA8eEJqAVs0RLiHYdbdIw+WQ997TEYbBIclizIUlKIoiOiSMIRa2pzKisrsXnzZtTV1QEAZFnGSy+9hJdeeqnJWzAoOJQePXB80CS43KZWn0P2aOG4YkQQoyIiolBw27pAsrr9ttFXV0Ertb0JzHpeKCCdaNkqJLZOgNBIMOEg7KYuIYqMiCINC2tqc1566SUkJSXhwgsvxFVXXYUJEyZg0qRJGDGCRVo4iYx0nBj9v7B7Ylt1fHV8dyA6KrhBERFR0CmZWYAsAYbG71KSZAU52YHdxRQK+WmVLT7GbKgA0qOgEQ4W1kQUNLwVnNqcvLw8vPPOO2qHQQAQHY3K6/8Eedli2ERJsw/zePRwXDGMc6wSEbUDksEA5YQVts5HUPNdWqPtOma78eP+tjPBa1KaBNuJQy06RhOlgaGmDJrOUVAkDZ+vJqKg4Yg1Efkl6fWoue4WVEad0+yluKpTL4Bkbv1t5EREFF7uY4mwdC732yY5zhGmaJqnd18PUOds0TG2znpIQsBgOQ67LQcKEkIUHRFFGhbWRNQkSZLgGDkGx7MHNDljuNtthHPglWGKjIiIgsFVldXkzODRmgCWYgw6geyY4y0+yhJVA6HXwqQchN3I28CJKHh4KzgRNZvnfy5DeU4naMrLAVmGpMiAogC//ldSZMipGZD0erVDJSKiFnC6u8OavtlvG0NdNXSSDI/Q+m0XDh0LtDAcbtls4JIOMNb+AuTYIEHm89VEFFQsrImoRUR2NuTsbLXDICKiIHIlFkJj8j85maQIZKW68FOpOUxRNa7neXbguNKiY8xdTNDIbmgSZMhaHRzGLi1e/5qIqDG8FZyIiIgowonUVEBIgNb/klo52f6X5QoHSSOQqjva4uOsiXYAgNF0BHZrJygiNsiREVEkY2FNREREFOEkSYJcYYM1v4kJzOLVn8DsnF4aaI+09PlqAbOrDMJqgFEuhd3UOSSxEVHkYmFNRERERPCcSIKli/+R4BhdbZiiadw5BdUtPsbUyQStsxZSpgUAYDdxmS0iCi4+Y91Mv9wyU+0QkP6PJ4NyHrvdjkWLFuGDDz7A9OnTMWzYML/t6+rqUFRUhC+//BIPPPAAZFlGcXExli5digceeABRUVFBiYuIiIjU46jJgynnK79tjI4a6DQyPIo6E5gZTALxdS2btAwArOkeoBbQxTnh0Rnh0Ofz+WoiCiqOWEcgvV6P3bt3Y+PGjbBYLE22Lyoqwrhx4/DFF18AAPbv348bbrgBL774Isxm9ScwISIiosA5xLnQp/kfDZaEQFaCereD97lIQKpq+ai5Gd6ReKOuDHZbLoSIDnZoRBThWFhHIJ1Oh1GjRvm+b8qQIUNwzjnn+Nrm5uZi9OjRzT6eiIiI2j45vSskQ9MzbWdlqTeBWUFGRYuP0cZooa89BhFnhl4ph8PI56uJKPhYWEcojaZlP/rfjmxzpJqIiOgsEx3lnRlc8l9cp6g0Yh0dB9iOH2rxceZsPQBASjcCACcuI6KQYGEdoRSlZWs/EhER0dlPro6CuZP/Gbdj9HVhiqah313sBpz+19o+E1OsCwCgj6mF22CBQ5sf7NCIiFhYR4ra2lrcdddduPbaa9G/f38MHTq0wf6DBw9i6tSpmDZtGvr3748ZM2agurpls26+9957GDduHJKTk/Hqq6/6tm/atAnjx4/HCy+8gLFjxyI9PR27du0KRreIiIgoiFwV6bB2OeK3jclTC73G/3rXodAp9lirjjNKVQAEjJoSOGx5ELAFNzAiInBW8IggyzJGjhyJgoICvPnmmwCAmTNn4sUXXwQAHDp0CP3798fKlStxzjnn4NixY+jduzd27tyJNWvWQJKkJq/x4IMPwu12Y+nSpRgyZAgWLFiACRMmQAiBl156Ce+88w7q6upw9dVXIzc3Fzk5OaHsMhEREbWCy9kZpk5FfttIQiAzzo6fjoWvQE3PBgyH/S8FdkY6QF97BEqyDTrlR9hNHK0motDgiHUE2LBhAzZu3IgJEyb4tg0fPtz3/f333w+9Xo9zzjkHAJCQkICbbroJn3/+OTZt2tSsa+Tn52PWrFkAgMzMTNjtdgCAJEkYP348AGDy5MkYM2YMHn74YZhMpmB0jYiIiILIobsA+tSaJttlpbvCEM1J/fraAdHy9bFM2UZIigxNqncsqY4TlxFRiLCwjgDfffcdACA6+uTSEqdOXvbll1/CarU2OKZzZ+8fnrKysmZdY9y4cTCZTHj77bfx6aefNtin1XrXumQxTURE1LbJGXmQtE0XsMmJzjBEU08gTev/9vTGmJO8fTHYquAyRcMlccSaiEKDhXUESE5OBgAUFxefcX+HDh1w4MAB1NWdnIyk/vvu3bs36xpLlizBRRddhOTkZPTu3TvAiImIiEgNkl4HaLQA/BfXscbwTWDW/QIB7bHKVh1rNNZCSIAJB2G35kGAq5oQUWiwsI4Aw4cPR0pKCmbPno1169ahtLQU69atAwAcPnwYU6ZMgdPpxHPPPec75uOPP8bo0aPRpUuXZl3jrrvuQlJSEvr374+DBw+iqqoKDofDd0s4AIhW3MJFRERE4SXXRsOUecJvG5NcB0OYJjDr2bV1RTUgYHAeBTpYoREOPl9NRCHFwjoCREdHY+XKlcjNzcW4ceMwevRoxMfHIycnB5s3b0ZWVhYWL16Mt99+GxMmTMAtt9yCjh07YuHChQCA119/HcXFxfj666/x+uuvY/PmzVi6dCkAYMaMGRBCYMaMGdi2bRuuv/56zJw5E1arFcOGDUNVVRUef/xxAMC9996LHTt2qJYHIiIiapqrKhPWAv+3XksQyIy1+20TDCazjLiK5j2W9lv6JAO0zlpIHQwQEHAYWVgTUehIIsKGEauqqhATE4MtW7bAZjs5m6WiKJBlGVlZWTAajSpGGB6yLPuefY4kTqcTBw4cgFarbfCcOREREXmZ9q6CWV6NX1680G+7bSXpKNqZENJYrhhUi27Sj606NuoCExLxLbT9LDBEl2B/ypOAOPvf4xFR8NTU1KBPnz6orKxsMF/VmbCyiFCRWFQTERFR05xRvaBPrm2yXXKiI+Sx5EWXt/pYU5Q3Pr2+AnZLLotqIgopFtZERERE5KMkJQPN+Pw9zhzaCcxyMx0wVLf2+WrAKCogNBIMShnsxrwgRkZEdDoW1kRERETkI0kSoNWhqZnBTcIOgzZ0E5j1Oaeq1cdKJgm62nKIJCskuPh8NRGFHAtrIiIiImpAccTAmOq/sJUAZMWGZtTapPMgSRxt9fHmHAMkIaDpoIPbEgeX4Ig1EYUWC2siIiIiasBZ2xHWrv5nBgeA9BA9Z933nBpIntaPhpsSvMdqbU44DVkA9EGKjIjozFhYExEREVEDdnEuTJ2ON9kuOdEZkusXpDZ9bX+M+hoAgF5/Ag5DZjBCIiLyi4U1ERERETXgTuwNXWLTt3nHWoK/lnV2Qh3M7poAziBgsB+B0EowymVwGrKDFhsRUWNYWBMRERFRA5LFAknX9NTgZskOo9YT1Gv36d76mcABwJBuhMbtBJJtADwsrIkoLFhYExEREdHpdE0/lywByIoL3qi1SedBqjmw28BNaRIAQErUwmWOhwfpwQiNiMgvFtZEREREdBpZjoG+Q3WT7dKDWFj36lQJjRLYEl4mqzcendUBlzELzVqUm4goQCysiYiIiOg0Tkd+s2YGT0oI3gRmBdknAj6H0eMd8dbrjsGh523gRBQeLKyJiIiI6DQObS+Yc5u+LTvWGpwR6+y4WtikwNbF1kRpoKs7AaHXwKAc5vPVRBQ2OrUDaC+Up0epHQI0f1qudghEREQUITyJ3aF1uppsZ9E6kBplR1m1OaDr9cwLfLTanG0AAIhkGwAZDkNOwOckImoOjlhHoKKiInz55ZcNttntdvztb3/D9OnTMXHiROzatUul6IiIiKgtkLRaSM2YwAwALspt+pZxf0w6D9LjKgI6BwCY4twAAG2CBi5TAmQpJeBzEhE1BwvrCHH8+HHcfPPNOP/88zFkyBCUlpb69imKgtGjRyM2NhYLFixAfn4+BgwYgJ9//lnFiImIiEh1xuYV1ukdKpFoaf2z1j0zT0ALpdXH1zNqqgAAWqsdLkMO+FaXiMKFv20iRHx8PObNm4cePXoAACRJ8u376KOPsHHjRowfPx4AMGPGDMiyjCeffFKVWImIiKhtUBADbUzTzz1LEnBx3uFWX6cgu6LVx/poAEOdd+RcrzsGh5HPVxNR+LCwjiAZGRkYNGjQadvfeust5Obmwmz2PhtlNBpx4YUX4p133oHH4wl3mERERNRGOD1dYevWvII5M6kSsaamn8n+rcKkSkQZAp8AzZRthCR7IPRaGOTDcOhzAj4nEVFztbvC+rXXXkPnzp2h0+nQo0cPbNy4Ue2Q2r1t27YhLi6uwbYuXbqgoqICO3fuxIABA2CxWHDBBRfg0KFDWL16NWJiYtCvXz+UlZVh3bp1GDlyJJYuXYorr7wS2dnZqKioUKczREREFDR204XNmhkcADQagf4tfNZap5HRv6C06YbNYEoW3m9SrQAUOA0dg3JeIqLmaFezgj/88MP4z3/+g+effx4lJSWYNm0aRo4ciYMHD8JkMqkdXrtVVlaG3NzcBtsSEhIAAA6HA2+88QYKCgpw8cUXIyUlBVdddRUKCwvx7rvvIjo6GgsWLMAnn3yC1NRUjB8/Hnv37kVMTIwaXSEiIqIgEjFZ0EY3/9nnjiknYNuTjBpX857NHpB/BGaTu7XhNWA01QEuQIqX4DJ2gKxJDMp5iYiao10V1mlpafjggw+g1WoBAF9//TWee+45/PTTT+jWrZvK0bVf0dHRqK6ubrDN4XAAAJKSkpCamophw4bh/fffx+OPP47Dhw/j3HPPRVpaGgBgzJgx+OSTT3DHHXegS5cuYY+fiIiIQshobHZTrVagf6ejWLMrrcm2SVY7CjLLA4msAaPLey69b+IyyW97IqJgale3gk+YMMFXVAOARqOBxWJBx46N3+rjdDpRVVXV4IsaysvLw4EDBxpsO378OMxmM9LT0wEAN910E44ePYpVq1bh3Xffxc033+xrW/8z4V0DREREZx9han5hDQB5acdh0jU1R4vAFYWl0GhE6wM7hS5BB63DO0ig15Rz/WoiCrt2VVj/1vr16zF9+nTfpFtn8sgjjyAmJsb3lZmZGcYI24dRo0ahrKwMe/fu9W378ccfccUVV0Cv997KNXDgQGRnZ+OVV17B7t270bt3b7XCJSIiojASuhhobY5mt9fpFFzU0f9I9PnpFUiMrQ00NB9zpvdDfmHSwaAcgYPPVxNRmLWJwvq7776DVquFJEmNfn311VcNjnnjjTeQnp6OBx54wO+558yZg8rKSt/XwYMHQ9mVNu/wYe/MnqdOLnbttdciNTUVCxcuBAAcOnQIX331Fe6++25fG0mSMH78eGzYsAE9e/Y847mFCM6nzkRERNR2ONED1s4tm5SsIOMY9Br5jPuMWg/65ZcFI7ST54z+dTbyFCsEBBxGFtZEFF5torDu3r07amtrYbfbz/jldDobjJB+++23WL58OT744APfiGpjjEYjoqOjG3xFov379+Omm27Cgw8+CAD4y1/+gqlTp6K0tBQxMTH417/+ha+//hq33XYb/vKXv+DNN9/0rXld7/rrr0dUVBTGjRvn27Zv3z68/PLLAIBp06bh559/Dl+niIiIKOQctgthzKls0TF6vYzfdTx2xn2DuhyC0RDc5TyNqAAAaOIAlz4JiibO/wFEREHWZiYva+7zuTt37sSzzz6Lt956C8ZfJ9MoKSmBXq9HcnJyyOLT/Gl5yM4dDjk5OXjllVfwyiuvnHF/YWEhNmzY4Pccer0eY8aMgc1m823r2LEjPvvss6DGSkRERG2IIRZSdPNm+T5Vt8xyfPFTAmRxcn6c9Og6dEpv3vJdzaWL18JQ4x1R11nq4DTmBPX8RETN0SZGrJtr586duPnmmzFy5Eh8/vnnWLduHV5//XWMGTMmYkeiw+n111/HjTfeqHYYREREFG4WS4sPMRo86Jt9ahEtMKjbL9AEebJuW/7Jwt2gOQqnoVNwL0BE1AxtZsS6KceOHcOAAQNw+PBhDB06tMG+MWPG+J3AjALncDjwn//8B7NmzVI7FCIiIgozyda691k9ssqx6ecECKFBv+zjiI22BzkywGI6AbgBYdZDr5Rz4jIiUkW7KawTEhJw6NAhtcOIOIqi4N5778VPP/2E3//+92qHQ0RERCqQbBZAUgDRspsdzSY3eqVXYOfhKPTsFPz3cdoYLQzVv06ElmrhxGVEpJp2dSs4hV9tbS1WrFiB48ePN5i0jIiIiCKH25gLU0ZFq449L+cIruxWBr3+zLOEB8LWRQsJ3lVJNHGAS5cERcvHA4ko/NrNiDWpIyoqCj/88IPaYRAREZGKHPo+sJ7/JRwH41t8rNXigtXiCkFUgNVSCVR5v9eZa+DkaDURqYQj1kRERETkl5BioU3UNt0wjDQ2DQzVpb7XBukInEZOXEZE6mBhTURERERNs7StiWJtXfSQhAIAEFYD9MoJPl9NRKphYU1ERERETdLYTGqH0IA1qurkixSzd+IyQ45q8RBRZGNhTURERERNM5uAXycKU5tk1sBYU+J7rYkVcOmTOXEZEamGhTURERERNUkxJ8KQqagdBgDA1lUPSTkZi95cA6cxR72AiCjisbAmIiIioibV6fsh6twTaocBALBGV/u+FzoNjCiB05itYkREFOlYWBMRERFRkxR0gC5Z/VvBJYMEU+0vJ193joZW1HHiMiJSFdexbibTpl5qhwDHhV+rHQIRERFFLAmSRf0JzKxdDZBkj++1MaEcQhFw6LnUFhGph4V1BNi2bRtmzZqFL7/8Enq9HiNGjIBOp0NdXR3Wrl2LZ599Fg899BB+/vlnJCcn47LLLgMAlJWVYePGjTh06BCeeuopPP/88zhx4gQuvvhi9O3bF9u2bUNSUhLuvvtu5ObmqtxLIiIiCjmTQe0IYI2rBX6dEFwkWWFWdsBpSIKijVE3MCKKaCysI8D555+P5cuXIz09HRdccAFee+01375ly5bBbDbjb3/7G6655hrccMMNmDdvnm//7bffDpfLhXvuuQd2ux1PPvkk5s6di/79+6O2thaFhYX44osv8O2338JgUP+PLREREYWQ2QptjIBcKatyeUkHmOpO3gau+/Xub05cRkRq4zPWESIuLg4ATit+//CHP6Bv376N7r/nnnsQFRUFADCZvLd/mc1mAIDVakXPnj1x8OBB7Ny5M6TxExERkfpkSyyM6VrVrm8pMEHjcQHwTlpm0e8BADg4cRkRqYyFdYQzGAxITk5udH9aWhq02sb/gAohIEkSEhMTQxEeERERtSEOY3dYcipUu74tsc73ff2kZQDgMmWqFRIREQAW1hFHiJOzeRYVFWH58uWN7n/44YdRWlra6Dm2bduGTz75BA888AAyMjJCFDERERG1FTIyoEtyqnNxLWCyn7wN3JhQDgBwmc2o03dXJyYiol/xGesIs3XrVkyePBmSJGHDhg147LHHGux/6623cPDgQbjdbqxYsQKTJk067RxPPvkkZFnG+vXrsWDBAtx4443hCp+IiIhUpYFkVOfto6WzERq3AwAgOlhgVr4BANTE9ISQLKrERERUj4V1hOnWrRtefvllAMDOnTvxyy+/NNj/xz/+EQ899BAA4Morr2wwgl1v1qxZMJlM2LhxI15//XVcf/310Gh48wMREVFEMJmhsWig1Clhvaw1yQFUe7/XdfK+71D0CqpMl4Q1DiKiM2E1FGEkSfJ9361bNwwaNKjR/ePGjWv0+evCwkI89thj+OKLL/Doo4+GJlgiIiJqc2RLAkyZYV4JRALMTu/jaUIrwaL/LwDAHpsFp6ZHeGMhIjoDFtbUatdccw2GDRuGv/71r1i1apXa4RAREVEYeGzxMMaHd7TanG+E1vXrxGWdY6AVdRCSQI3tgrDGQUTUGBbWEaKuzvvHyOFw+N1vt9ubPMeJEyd821544QVkZGTghhtuwEcffRSscImIiKiNclvSYLBWh/WattSTE6aZEr2TlrnjDKjE8LDGQUTUGBbWEWDTpk0YNWoUAODbb7/FxIkTsW/fPt/+119/HXfddRcAYMmSJbjnnnsaFOB1dXW46667fM9m33777Vi8eDEAICEhAe+//z66dOmCMWPGYPDgwXjjjTfC1TUiIiIKMxnZ0MbXhO+CkoDZXQYAEB2sMCv7AQC1UV0hJGv44iAi8kMSZ5qd6ixWVVWFmJgYbNmyBTabzbddURTIsoysrCwYjUYVI6RQcjqdOHDgALRaLSdcIyIiaqXY4mdR9m4shCP0t4RbuhmRbPoOAKDta0WUbgdkm4xfku6CHb1Cfn0iilw1NTXo06cPKisrER0d7bctKwsiIiIiahHFFg9Thj4s14pO8o6Oeyct2wsAsMcnsagmojaFhTURERERtYgnKgnGhNDf9KiJ1sJUc8D7onMMtKIWQidQZzg35NcmImoJFtZERERE1CIeWzwM5jNPiBpM0d20kBTv7eb1k5a5kjWokK8J+bWJiFqChTURERERtYhii4NBqQjxVQRs+kPe7zpYYFb2Q0DAbu0IIdmaOJaIKLxYWBMRERFRi3i0aZDMtYAudNcw5Zqgrz0GANB18r5l9XTwoMrDJbaIqO1hYU1ERERELSOMUGJiYcwI3Uoq0ZneW82FRoLF4J20zBkXCzv6huyaREStxcKaiIiIiFpMtsXD2CE055ZMEsy1P3tf5MZAq9RAtsqw4/zQXJCIKEAsrH8jwpb1jjj8+RIREQWHHB0Po8UZknNHdTdAI7sBAIZfl9typQEn3DeE5HpERIFiYf0rSZIghIAsy2qHQiEkyzKEEJAkSe1QiIiI2jXZlgADqkJy7iirdwZwYdLDjL0QOgGXIQNCig7J9YiIAsXC+jdqa2vVDoFCiD9fIiKi4JBtcdDXlQNB/qzakGaAodo7G7iUb4UGHrjTXKiyjwruhYiIgiiEczm2L5IkQaPRoLKyEgaDASaTiaOaZxEhBBwOByorK6HRaPizJSIiCpDHmAxh0cKQboCrxBW080bneQDv3d8wxpZDKAKuWAvqai4K2jWIiIKNhfUptFotPB4Pjhw5wsLrLFR/C7hWq1U7FCIionZPwAYlPgamagmukiCdVAtYXQe8548zwax8B0+8DIfjd0G6ABFRaLCwPoUkSdDr9RBCcJKrs5AkSfzAhIiIKIjkqHgYbO6gnc/W3QiNyw4A0HQyAADcKQpO2G8M+i3nRETBxML6DFiAERERETXNY4uHQfoZgDUo54uKq4R3PjQBs6UEilaBW5sMRYoNyvmJiEKFk5cRERERUavItnjo7eVBGarRxetgrPLeUy7SomFQjsCT5kZN3dDAT05EFGIsrImIiIioVRRbPDQeF6LPNwZ8ruiugATvo3i6TAUA4ErQoloZEvC5iYhCjYU1EREREbWKx9wBwqJHjPEXAIHMTyNgRan3O40Es+EneOI8cDs6AxInHSWito+FNRERERG1iqyNgRIfDV3dCdh6mFt9HkuBCTp7pfdFx2jolGq409yodFwXpEiJiEKLhTURERERtY6kgRwVAwCIiT+C1o5aR6XU+r43pNghdAIekwVOdAtGlEREIcfCmoiIiIhaTYmKBQAYqg/DnG9q8fHaWC3MNd61qxWDFmZpL9xpLjiqLwpmmEREIcXCmoiIiIhaTbZF+76PTa9q8fGJ5zkhKTIAQJMfBY1wwZ0io8LN28CJqP1gYU1ERERErXZqYW2qOgBDhqHZx1q6GWGp2ud7bYw/Dk+MB7IzhWtXE1G7wsKaiIiIiFpNNsdBpNp8r+PyHM06TjJISIg76Hstoo0wKfvgznCjpnZY0OMkIgolFtZERERE1GoufQa0nT2+1+bqfdAl6Jo8LqGf5uRM4AA0uSZAp0COBqrloSGJlYgoVFhYExEREVHrSSYocWYIk7eYloSC2ELZ7yGGTANstf9tsM1kK4U7xQ13ZSHXriaidoeFNREREREFpNbaA5quFt9rq30fNLbG3mYKdOhUDkkovi1KshVGpQzudBcqHdeEOFoiouBjYU1EREREAamRLoMuqwz161hrZDdizz3z28yYPiYYqg832KbLliBHy1CEFU50D3W4RERBx8KaiIiIiAIj6eC0pELkxPo2Rcn7IRmkBs20sTrEYk+DbQKA2bgf7gwXHJVcu5qI2icW1kREREQUsBp9f+jzy32vNS47Ys7XN2iTeJ4DGo+zwTapeyx00gl4Ej2ocHHtaiJqn1hYExEREVHA7OJCaOIrIKKNvm1RuhLg10Fra6GpwZrVAKAYtbDF/RfuFDeUyjQoUnw4QyYiChoW1kREREQUFHZTHrQFJ0epdfZKRJ1rhGSQEB/782ntdeeaoVOq4M5woab2qnCGSkQUVCysiYiIiCgoquQ/wJC5E0Jz8tnqmOjDSOgrQWevatBWiTfDpv8OngQPhF6DanlYuMMlIgoaFtZEREREFBQuKReeKAuQH+Pbpq85iqja3ae1NXZzQdK44ehqh/s4164movaNhTURERERBY1d6g5jdpnfNiInGlaxG848J4RJcO1qImr3WFgTERERUdBUuK+BJuVniA7WM+4XEmDJLIMc7YE7ywVxNBNO9AhzlEREwcXCmoiIiIiCRpHi4TJ1gC5XOeN+qUcsDKIUjm4OwKnFkaoHwxwhEVHwsbAmIiIioqCqc/4PDOnfQegbPjctzDpExeyCq6MLSpSC2kPXQpY6qBQlEVHwsLAmIiIioqCqlP8AuYMLUkFUg+26c4yAuRKujk6IIxmolMepFCERUXCxsCYiIiKi4JIMcIsMmFL3AxAAANHBAqvuG+8t4G4tjlTNUzVEIqJgYmFNREREREFXXTcCSCuBkhEDQMDYpQ6eTCeUWBm1peMgS8lqh0hEFDQsrImIiIgo6GrFpfDEaqHPsUPkxcFk/C+ceQ6Io+moVK5VOzwioqDSqR0AEREREZ2FJAmu2m6wJX0Hk5QMR1cHIGtxpHIeIKkdHBFRcHHEmoiIiIhCosoxDp50B5BUBjnRg9rSsZClFLXDIiIKOo5YExEREVFIONENss4CuaAa4mgaKpXr1A6JiCgkOGJNRERERCHjrOwDKBocqXxQ7VCIiEKGI9ZEREREFDIVrutgK03lLeBEdFbjiDURERERhYwsJaNSuUbtMIiIQoqFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBYCFNREREREREVEAWFgTERERERERBUCndgDhJoQAANTU1KgcCREREREREbVV9TVjfQ3pT8QV1tXV1QCAAQMGqBwJERERERERtXXV1dWIiYnx20YSzSm/zyKKoqC0tBRRUVGQJEntcM6oqqoKmZmZOHjwIKKjo9UOp8UYv7oYv7rac/ztOXaA8auN8aurPcffnmMHGL/a2nP87Tn2eu25D82JXQiB6upqpKWlQaPx/xR1xI1YazQaZGRkqB1Gs0RHR7e7f6CnYvzqYvzqas/xt+fYAcavNsavrvYcf3uOHWD8amvP8bfn2Ou15z40FXtTI9X1OHkZERERERERUQBYWBMREREREREFgIV1G2Q0GnHffffBaDSqHUqrMH51MX51tef423PsAONXG+NXV3uOvz3HDjB+tbXn+Ntz7PXacx+CHXvETV5GREREREREFEwcsSYiIiIiIiIKAAtrIiIiIiIiogCwsCYiIiIiIiIKQMStY93eHT16FCtXroQQAhMnTlQ7nIhyNuVeCIGtW7ciMTERWq32tH1JSUltbhKKsyn/7RHzrx7mXl3Mv7qYf/Uw9+pi/tXT2txzxFolP/zwA0aPHg1JkiBJEsaPH48jR440edz8+fMxceJE7Nu3LwxR+nf8+HHcc889mDx5Mm699Vb88ssvZ2xXXV2Np59+usnz7dixAw899BC+++67YIfawNmQeyCw/O/fvx+9evVCTk4OMjMzG3x17twZR48eDVnczP9JRUVFuOOOOzBz5kzMnTsXFRUVIYzY62zIfzByf+DAAUydOhUDBw7EuHHjUFJSEsqQAZwduQean39/Vq9ejT/96U8YNWoUlixZEoIoT8f8NyTLMv7xj3/g2LFjQY7wzJh/9TD3XrW1tZg9ezby8vKQnp6OuXPnQpblEEV7EvN/uvLyctxyyy1BjO7Mwp57QapKSUkR+fn5zW5fW1srAIj77rsvdEH9yuPxiCeeeEJkZmYKnU4nLrzwQrFz505fHIWFhWLVqlVCCCEmTZokcnJyREVFhe/4f/7zn2LAgAHCZrOJbt26NXqdqqoqMWXKFDF37lzhcrlC26lTtOXcCxHa/K9cuVIMGTJELF++XKxcudL3NXPmTDF79uyw9C+S8y+EEC+88IKIjo4WJSUlQgghBg0aJPr27SsURQlD79p2/kOd+++++07k5+eL0tJS4XA4xMCBA0WHDh18P4tQa8u5FyLw/O/cuVMMHTpUGAwGkZCQIO6///4G53/11VdFv379hNvtFrt27RJWq1XMnz8/LH0TgvnfvHmzGD58uEhNTRUAxJEjR8LSr3qRnv/jx4+LqVOnipiYGGEymcS4ceNEZWVlWPoW6bkfPXq0WLx4sfjmm2/EiBEjBACxaNGisPRNCOb/VJMmTRI//vhjaDt0inDlnoW1yrKzs0VhYWGLjgnX/2STJ08W48ePF59++ql46qmnhEajEd27dxdCCPH000+LzMxMX9uSkhIBQDz66KO+bXa7Xaxfv14YDIZG+1haWiq6desW1jdV9dpy7oUIbf4//fRTUVVV1WCboihi8ODBDX5JhlIk518IIQoLC0WPHj18r2fPni0AiMOHD4ewVye15fyHOvcXX3yxGDVqlO/1nj17hEajEddff30Ie3VSW869EIHl//vvvxcFBQXitddeExs2bBD9+vUTAMS7774rhBDC7XaLpKSkBm9mJ0+eLOLi4oTD4QhL/yI5/0IIIcuy2LFjh+jWrZsAII4ePRqWftWL5PzX1dWJXr16iUceeUQUFRWJiRMnCgBi2rRpYelbJOdelmXx2Wef+Y7fvn27ACBeeeWVsPRNiMjO/6n+9a9/iaeeeiosfaoXrtyzsFZZW/6fbOHChQ1eX3XVVQKAqK2tFb179xZDhw5tsL9r165n7EtjfXQ6neKCCy447Tzh0pZzL0To8/9bb731Vlg/4Ij0/A8ePFhoNBrx0UcfCSGEuP7660WvXr2ELMtB7EXj2nL+Q517k8kkunTpIjwej29bQUGBSEpKClIP/GvLuRcisPx//PHH4qeffvLt++qrrwQA8ec//1kIIcTq1asFALFlyxZfm2XLlgkA4p133glVlxqI5Pyfavz48SyszyCU+T9w4IBYu3atb7/H4xHR0dGid+/eoepOA5Gc+9+aP3++6Nu3r6irqwtyLxrH/AtRUVEhRo0aFbb3OvXClXs+Y92GzJkzB5IkYdSoUQCADz74AF26dIEkSVixYkXY4/ntw/oajQYdO3aEyWTC9u3bER8f32B/QUEBdu3aBY/H06zzP/HEE9i6dSseeOCBoMXcWm0t90Do838ql8uFxYsXY8qUKQHF3FqRmP8FCxYgNjYWI0aMwL333gtJkrBhwwZoNOH/tdzW8h/q3I8ZMwa7d+/GjTfeiIULF2LTpk2wWCynTeQXDm0t90Bg+b/sssvQsWPHBscCQPfu3QEAxcXFANDgHAUFBQCAb7/9NvidaUKk5b+tibT8Z2Zm4oorrvDt12q1EEKo8vOJtNzXc7lc+Pvf/44FCxZgxowZqk3UGqn5v/vuu/Hggw9iyZIliI6Oxq5du0LUm8aFMvcsrNuQRx55BElJSbDZbACAESNG+CbeiYuLUzM0OBwOfP7555g9ezaOHj0Kt9sNq9XaoE1iYiJkWUZ5eXmT51MUBc8//zzOPfdc9OrVC1u2bMETTzyBTz/9NEQ98K8t5x4Ifv5/68UXX8TEiRNhMBiCFXKLRGL+O3fujKKiImi1Wvz1r39FeXl5WCZROZO2nP9Q5P7VV1/F/PnzYTQaYbVa0adPH+zbtw99+vQJRRf8asu5BwLP//r169GxY0dcffXVAIDS0lIAaHCOxMREAMDhw4dD1Y1GRVr+25pIz//mzZvhdDoxY8aMkMTvT6Tm/vnnn0d5eTlSUlIwbtw4XHfddSHtR2MiMf/r169Heno6unbtin379qG6uhq1tbUh78tvhTL3XG6rjTGbzZAkyfe6rSx59MQTT2D48OG45ZZbYLfbAQBVVVUN2jgcDmg0Gt+bJH8OHjyIkpISXH311fj000+xdu1arF69Gn/+85/x0ksvYfLkySHphz9tNfdA8PN/qqqqKqxduxarVq0KWrytEWn537dvH2655RasXLkSL7zwApYvX46BAwfi888/9/2yD6e2mv9Q5F6j0WD69Om+12vXrsWJEycwc+bM4AXeAm0190Bg+T9x4gQWLlyI9957DyaTCQAQExPjO0dKSorveABITk4OaV8aE0n5b4siOf9z587F888/jx49eoSmA02IxNzfcccdAIC6ujoUFhZi6dKlePTRR5GVlRW6zjQikvJfW1uL5557Du+++26Dtt47rsMvVLnniDU1acOGDfjxxx+xePFiAN5/jBkZGdi/f3+DdseOHUPHjh2h0zX9eU1ZWRkA76ddl156KR555BGsXr0aAPDyyy8HtwPtXCjyf6rHHnsMd911V4NfMHRSKPIvyzIGDBiAzMxMDBw4EMuWLcOgQYOwfft2vPbaa6HoRrsU6n/7gPdnce+992L06NG45JJLghH2WSOQ/Lvdbtx6661YsmQJzjvvPN/2/Px8AGhwjvrlnur3kVco8k/NF+r8z5s3D3/4wx+4PvEZhOPfvsViwZAhQwDAVziSVyjyf8cdd2Dt2rVISUlBYmIiHn30UQDAwIEDkZ2drdode8HGwrqNkSTJ9+k9gLCsa+tPUVER1q1bh0WLFvmeP9y5cyeuvvpqfP311w1u4dizZw9GjBjRrPOmpqYC8K4lWy8zMxOJiYmqfGoItL3cA6HLf72ysjLs2bMH//M//xPUuFsjkvJ/7Ngx7N+/3/cJqVarxezZs4PfgRZoa/kP9b/9erNmzYLH48Grr74ajLBbpa3lHggs/263G3/6059wzz33oF+/fr7tW7duxciRI2EwGFBUVNTgeKPRiMGDB4ehZ6eLpPy3RZGY/wULFiA3N7fBvCb18w+EUyTm/rdycnJU+1AvkvL/4IMPYs+ePdi+fTu2b9+O2267DQDw2muv4euvvw77HCehyj0L6zbg1E96cnJysHbtWqxfvx6bN2/GM888AwDYvXs3ampqwhpXUVER7rvvPgwaNAj//ve/sWbNGixatAi33347pk2bBoPB4Ps0a9u2bTh27BjuvPPOBudwuVw4fvw4KisrG2zPzs7GsGHD8Oabb2LPnj0AvP/j1tXVYd68eeHpINpu7oHQ5r/eQw89hP/7v/8LeV8aE6n5T0pKQs+ePfHxxx+juroagPfff3JyclifhWyr+Q/Hv/26ujrceuut+PHHH/HJJ5+c9uxYqLXV3AOB5d/tdmPs2LEoKCjA0aNHsWHDBrz//vuYPHkyvv/+eyQkJGDSpElYsmQJ6urqAADLli3DjBkzWvwYSyAiNf+nOnToEAB13sxHcv4ff/xxfPPNN0hOTsaGDRuwevVqPProo1i4cGFY+hepuXc6nXjsscd8heH27duxYsUKvPLKK2GdNDRS85+SkoKMjAzfV/3f3OTkZHTo0CEs/QtL7ls0hzgFXVZWlhgzZozv9caNG0VKSoqIjY0VkyZNEs8995y49NJLxaOPPir27t0rbr/9dgFAdOrUSWzatClkce3atUtYrVYB4LSv+qnzi4qKRO/evcWUKVPE2LFjxdatWxuc47nnnhMFBQW+43r37i1effVV3/7KykoxdepUkZubK0aNGiVGjRoltm3bFrI+/VZbzb0Q4cl/XV2d+N///d+Q9sOfSM9/WVmZGDt2rLjkkkvEtGnTxLhx48SePXtC2q9TtdX8hzr3VVVV4plnnhHTp08XH374Ycj64U9bzb0Qgee/fl3e336ZTCZx7NgxIYR3qcWpU6eKyy67TEyZMkXcfffdYV16JdLzv2HDBjFgwADfvqysLDFnzhyhKEpI+1YvkvO/ZMmSM+4HIFavXh3SvgkR2bk/cOCA6N27t8jLyxOTJk0St912m9i1a1dI+/RbkZz/eoqiiLlz54rExEQBQPTq1Ut8/PHHIe2bEOHLvSSESk+NEwAgNjYWy5Ytw5VXXql2KBGHuVcX868u5l89zL26mH91Mf/qYe7VxfyrJ1y5563gYXbo0CH07dsXGzduRHFxMQYPHsz/wcKEuVcX868u5l89zL26mH91Mf/qYe7VxfyrR63cc7mtMNPr9UhNTcX06dNx+eWXcwbgMGLu1cX8q4v5Vw9zry7mX13Mv3qYe3Ux/+pRK/e8FZyIiIiIiIgoALwVnIiIiIiIiCgALKyJiIiIiIiIAsDCmoiIiIiIiCgALKyJiIiIiIiIAsDCmoiIiIiIiCgALKyJiIiIiIiIAsDCmoiIiIiIiCgAOrUDICIiouD45JNPMHv2bGzZsgVGoxGjR49GSkoKHA4HvvnmG3Tp0gVTp07F+eefr3aoREREZxVJCCHUDoKIiIiCo6amBlFRURg8eDA++ugj33a73Y7p06dj0aJFeOihhzBnzhwVoyQiIjq78FZwIiKis4jNZgMAaLXaBtvNZjNeeuklXHbZZbj77rvx9ttvN3muiooKFBcXhyROIiKiswkLayIiogghSRLmzp0LAHj44Yf9ti0pKcGll16KzZs3hyM0IiKido2FNRERUQTp378/TCYTduzYgerqahQXF2Py5MmIj4/HpEmTfO1+//vfY8eOHZgzZw7y8vIwduxYAMDRo0cxbdo03Hnnnbj44ouxcOFCtbpCRETUZnDyMiIiogii1WoRHx+P0tJSvPfee1i8eDGKioqQmZmJ++67D3/961+RnJyMFStWoGPHjnjiiSd8BbfL5cLll1+OF198ERdeeCGKi4vRt29fDBkyBOnp6Sr3jIiISD0srImIiCLMiRMnYLVakZKSgkWLFgEAsrKyAHgnOTuVTnfyrcK//vUvfPvtt1i4cCGWLVuGyspK9OvXDy6XK3zBExERtUEsrImIiCJIcXEx7HY7rr32Wlx55ZUAgKKiIixevLjJY/fs2YPExERfMU5ERERefMaaiIgogjz22GOw2Wy4//77sWXLFpxzzjn44Ycf8Mc//rFBO0mSAACKovi2ZWVl4ejRo9i4cWNYYyYiImrrWFgTERGdRerq6gAAu3fvhsPh8G13uVyYM2cO1qxZgxUrViA/Px8PP/ww9u3bh/Hjx6OkpAQAUF5ejpqaGsTHx0OSJGzYsAF2ux3//e9/MXz4cKSmpuKqq67Ciy++iDVr1uC2227Drl27VOkrERFRW8HCmoiI6Czx+eefY+jQoQCAvXv3Ii8vD2PGjMHVV1+NAQMGwG634/vvv8fll18OAJg6dSosFgsGDBiAiy66CL/73e8wduxYfPPNN4iKisK9996LlStXolevXvjhhx8QFRWFNWvWoLCwEDNmzMCMGTMwaNAgFBQUqNltIiIi1UlCCKF2EERERERERETtFUesiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoACysiYiIiIiIiALAwpqIiIiIiIgoAP8PvcxadubtG44AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Open the spreadsheet by its ID\n",
        "\n",
        "spreadsheet = gc.open_by_key(spreadsheetId)\n",
        "# Convert NaN or Infinity to a string representation\n",
        "merged_df.replace([np.inf, -np.inf, np.nan], 'null', inplace=True)\n",
        "\n",
        "# Convert DataFrame to a list of lists for writing to Google Sheets\n",
        "df_values = merged_df.values.tolist()\n",
        "\n",
        "# Convert all values to strings\n",
        "df_values = [[str(val) for val in row] for row in df_values]\n",
        "\n",
        "# Update Google Sheets\n",
        "worksheet = spreadsheet.get_worksheet(0)  # Assuming you're updating the first worksheet\n",
        "worksheet.clear()\n",
        "worksheet.update([merged_df.columns.values.tolist()] + df_values)\n",
        "\n",
        "worksheet = spreadsheet.get_worksheet(1)  # Index 0 corresponds to the first worksheet\n",
        "\n",
        "# Clear existing data in Sheet 2 (optional)\n",
        "worksheet.clear()\n",
        "\n",
        "# Write DataFrame to Sheet 1 starting from cell A1\n",
        "worksheet.update([weightsDf.columns.values.tolist()] + weightsDf.values.tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a8OwAVJru1Dt",
        "outputId": "781e413c-7549-46e8-e8a0-6276cc63c475"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'spreadsheetId': '1k8qnFgKx3xk4CCp55m1zPrZaiulSBHRpE9_BlfeCy2M',\n",
              " 'updatedRange': 'Sheet2!A1:H14',\n",
              " 'updatedRows': 14,\n",
              " 'updatedColumns': 8,\n",
              " 'updatedCells': 112}"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    }
  ]
}