Animations for Mexico Covid19 official Data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import calendar\n",
    "import imageio\n",
    "import joblib\n",
    "from shutil import copy2, rmtree\n",
    "from datetime import datetime, timedelta\n",
    "from IPython.display import clear_output\n",
    "from data_helpers import *\n",
    "from constant import *\n",
    "plt.style.use('seaborn-whitegrid')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\legacyCovidMexico'\n",
    "data_dir = os.listdir(data_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sufx_dict = {\n",
    "    'Deaths': 'Casos_Diarios_Estado_Nacional_Defunciones_2020',\n",
    "    'Confirmed': 'Casos_Diarios_Estado_Nacional_Confirmados_2020',\n",
    "    'Suspicious': 'Casos_Diarios_Estado_Nacional_Sospechosos_2020',\n",
    "    'Negatives': 'Casos_Diarios_Estado_Nacional_Negativos_2020',\n",
    "    'Actives': 'Casos_Diarios_Estado_Nacional_Activos_2020',\n",
    "    'Hospitalized':'Casos_Diarios_Estado_Nacional_Hospitalizados_2020',\n",
    "    'Ongoing':'Casos_Diarios_Estado_Nacional_Ambulantes_2020'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_single_discrete(index, plot_index, plot_data, state, file, dtype, max_day,trim):\n",
    "    plt.close('all')\n",
    "    plt.rcParams['figure.figsize'] = (14,6)\n",
    "    plt.rcParams['figure.constrained_layout.use']=True\n",
    "    plt.ylabel(f'Number of {dtype} Cases', fontsize=18)\n",
    "    plt.ylim(0,max_day+(max_day*0.3))\n",
    "    plt.xlim(trim,len(plot_index))\n",
    "    plt.xticks(rotation=70)\n",
    "    \n",
    "    if type(state) == list:\n",
    "        for ind, local in enumerate(state):\n",
    "            join_names = join_list_names(state)\n",
    "            plt.title(f'Daily {dtype} Cases for Covid19 in {join_names}', fontsize = 20)\n",
    "            plt.bar(plot_index, plot_data[ind], label = f'{local}: {max(clean_nan(np.array(plot_data[ind])))}')\n",
    "    else:\n",
    "        plt.bar(plot_index,plot_data, label = f'Number of {dtype} Cases: {max(clean_nan(np.array(plot_data)))}')\n",
    "        plt.title(f'Daily {dtype} Cases for Covid19 in {state}', fontsize = 20)\n",
    "    plt.suptitle(f'{calendar.month_name[int(file[-8:-6])]} {file[-6:-4]}', fontsize=22)\n",
    "    plt.legend(loc=0,fontsize=20)\n",
    "    \n",
    "    if type(state) == list:\n",
    "        join_names = join_list_names(state)\n",
    "        plt.savefig(f'plots/{join_names}/discrete/{dtype}/{file[-12:-8]+\"-\"+file[-8:-6]+\"-\"+file[-6:-4]}.jpg')\n",
    "    else:\n",
    "        plt.savefig(f'plots/{state}/discrete/{dtype}/{file[-12:-8]+\"-\"+file[-8:-6]+\"-\"+file[-6:-4]}.jpg')\n",
    "\n",
    "def plot_single_cummulative(index, plot_index, plot_data, state, file, dtype, max_cummulative,trim):\n",
    "    \n",
    "    if type(plot_data[0]) == list:\n",
    "        join_names = join_list_names(state)\n",
    "        cummulative_record = []\n",
    "        for local in plot_data:\n",
    "            cummulative_record.append(get_cummulative_record(local))\n",
    "            \n",
    "    else:\n",
    "        cummulative_record = get_cummulative_record(plot_data)\n",
    "    \n",
    "    plt.close('all')\n",
    "    plt.rcParams['figure.figsize'] = (14,6)\n",
    "    plt.rcParams['figure.constrained_layout.use']=True\n",
    "    if type(state) == list:\n",
    "        plt.title(f'Cummulative register of {dtype} Cases by Covid19 in {join_names}', fontsize = 20)\n",
    "    else:\n",
    "        plt.title(f'Cummulative register of {dtype} Cases by Covid19 in {state}', fontsize = 20)\n",
    "    plt.ylabel(f'Number of {dtype} Cases', fontsize=18)\n",
    "    plt.ylim(0,max_cummulative+(max_cummulative*0.3))\n",
    "    plt.xticks(rotation=70)\n",
    "    plt.xlim(trim,len(plot_index))\n",
    "    \n",
    "    if type(state) == list:\n",
    "        for ind, local in enumerate(state):\n",
    "            plt.plot(plot_index,cummulative_record[ind], label=local+': '+str(max(clean_nan(cummulative_record[ind]))))\n",
    "            plt.fill_between(plot_index, cummulative_record[ind], alpha=.2)\n",
    "    else:\n",
    "        plt.plot(plot_index,cummulative_record, label=dtype+': '+str(max(clean_nan(cummulative_record))))\n",
    "        plt.fill_between(plot_index, cummulative_record, color='b', alpha=.2)\n",
    "        \n",
    "    plt.suptitle(f'{calendar.month_name[int(file[-8:-6])]} {file[-6:-4]}', fontsize=22)\n",
    "    plt.legend(loc=0, fontsize=18)\n",
    "    \n",
    "    if type(state) == list:\n",
    "        plt.savefig(f'plots/{join_names}/cummulative/{dtype}/{file[-12:-8]+\"-\"+file[-8:-6]+\"-\"+file[-6:-4]}.jpg')\n",
    "    else:\n",
    "        plt.savefig(f'plots/{state}/cummulative/{dtype}/{file[-12:-8]+\"-\"+file[-8:-6]+\"-\"+file[-6:-4]}.jpg')\n",
    "\n",
    "def plot_multi_discrete(index, plot_index, plot_data, days, dtypes, state, max_day,trim):\n",
    "    \n",
    "    today = calendar.month_name[int(days[0][-8:-6])]+'-'+ days[0][-6:-4]\n",
    "    plt.close('all')\n",
    "    plt.rcParams['figure.figsize'] = (14,6)\n",
    "    plt.rcParams['figure.constrained_layout.use']=True\n",
    "\n",
    "    plt.title(f'Daily {dtypes} Cases for Covid19 in {state}', fontsize = 20)\n",
    "    plt.ylabel(f'Number of Cases', fontsize=18)\n",
    "    plt.ylim(0,max_day+(max_day*0.3))\n",
    "    plt.xlim(trim,len(plot_index))\n",
    "    plt.xticks(rotation=70)\n",
    "    for data in plot_data.keys():\n",
    "        plt.bar(plot_index,plot_data[data], label = f'Number of {data} Cases: {max(clean_nan(np.array(plot_data[data])))}',alpha=0.5)\n",
    "    plt.suptitle(f'{today}', fontsize=22)\n",
    "    plt.legend(loc=0,fontsize=20)\n",
    "    plt.savefig(f'plots/{state}/discrete/{dtypes}/{days[0][-12:-8]}-{days[0][-8:-6]}-{days[0][-6:-4]}.jpg')\n",
    "\n",
    "def plot_multi_cummulative(index, plot_index, plot_data, days, dtypes, state, max_cummulative,trim):\n",
    "    \n",
    "    today = calendar.month_name[int(days[0][-8:-6])]+'-'+ days[0][-6:-4]\n",
    "    cum_data = {key:[] for key in plot_data.keys()}\n",
    "    \n",
    "    for key in plot_data.keys():\n",
    "    \n",
    "        last_valid = int()\n",
    "        for i in plot_data[key]:\n",
    "\n",
    "            if len(cum_data[key]) == 0:\n",
    "                if not np.isnan(i):\n",
    "                    cum_data[key].append(i)\n",
    "                    last_valid = i\n",
    "                else:\n",
    "                    cum_data[key].append(np.nan)\n",
    "                    last_valid = 0\n",
    "            else:\n",
    "                if not np.isnan(i):\n",
    "                    cum_data[key].append(i+last_valid)\n",
    "                    last_valid += i\n",
    "\n",
    "                else:\n",
    "                    cum_data[key].append(np.nan)\n",
    "            \n",
    "    plt.close('all')\n",
    "    plt.rcParams['figure.figsize'] = (14,6)\n",
    "    plt.rcParams['figure.constrained_layout.use']=True\n",
    "    \n",
    "    plt.title(f'Cummulative register of {dtypes} Cases by Covid19 in {state}', fontsize = 20)\n",
    "    plt.ylabel(f'Number of {dtypes} Cases', fontsize=18)\n",
    "    plt.ylim(0,max_cummulative+(max_cummulative*0.3))\n",
    "    plt.xticks(rotation=70)\n",
    "    plt.xlim(trim,len(plot_index))\n",
    "    for key in cum_data:\n",
    "        plt.plot(plot_index,cum_data[key], label=key+': '+str(max(clean_nan(cum_data[key]))))\n",
    "        plt.fill_between(plot_index, cum_data[key], alpha=.2)\n",
    "        \n",
    "    plt.suptitle(f'{calendar.month_name[int(days[0][-8:-6])]} {days[0][-6:-4]}', fontsize=22)\n",
    "    plt.legend(loc=0, fontsize=18)\n",
    "    \n",
    "    plt.savefig(f'plots/{state}/cummulative/{dtypes}/{days[0][-12:-8]}-{days[0][-8:-6]}-{days[0][-6:-4]}.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_multi_state_plots(index, plot_index, state, file, dtype, max_day, max_cummulative,trim):\n",
    "    \n",
    "    join_names = join_list_names(state)\n",
    "        \n",
    "    if not os.path.exists(f'plots/{join_names}/cummulative/{dtype}'):\n",
    "        os.makedirs(f'plots/{join_names}/cummulative/{dtype}')\n",
    "\n",
    "    if not os.path.exists(f'plots/{join_names}/discrete/{dtype}'):\n",
    "        os.makedirs(f'plots/{join_names}/discrete/{dtype}')\n",
    "    \n",
    "    data = []\n",
    "    for local in state:\n",
    "        \n",
    "        local_data = pd.read_csv(os.path.join(data_path,file))\n",
    "        local_data = local_data[local_data['nombre'] == local]\n",
    "        plot_data = []\n",
    "\n",
    "        for day in index:\n",
    "            \n",
    "            try:\n",
    "                plot_data.append(local_data[str(day)[-11:-9]+str(day)[-15:-11]+str(day)[:4]].values[0])\n",
    "            except:\n",
    "                plot_data.append(np.nan)\n",
    "        data.append(plot_data)\n",
    "        \n",
    "    plot_single_cummulative(index, plot_index, data, state, file, dtype, max_cummulative,trim) \n",
    "    \n",
    "    plot_single_discrete(index, plot_index, data, state, file, dtype, max_day,trim)\n",
    "    \n",
    "    print(f'Plots of {dtype} for {join_names} ready for day: {calendar.month_name[int(file[-8:-6])]} {file[-6:-4]}')\n",
    "    \n",
    "def make_plots(index, plot_index, state, file, dtype, max_day, max_cummulative,trim):\n",
    "            \n",
    "    if not os.path.exists(f'plots/{state}/cummulative/{dtype}'):\n",
    "        os.makedirs(f'plots/{state}/cummulative/{dtype}')\n",
    "\n",
    "    if not os.path.exists(f'plots/{state}/discrete/{dtype}'):\n",
    "        os.makedirs(f'plots/{state}/discrete/{dtype}')\n",
    "    \n",
    "    data = pd.read_csv(os.path.join(data_path,file))\n",
    "    data = data[data['nombre'] == state]\n",
    "        \n",
    "    plot_data = []\n",
    "                       \n",
    "    for day in index:\n",
    "        try:\n",
    "            plot_data.append(data[str(day)[-11:-9]+str(day)[-15:-11]+str(day)[:4]].values[0])\n",
    "        except:\n",
    "            plot_data.append(np.nan)\n",
    "    \n",
    "    plot_single_discrete(index, plot_index, plot_data, state, file, dtype, max_day,trim)\n",
    "    \n",
    "    plot_single_cummulative(index, plot_index, plot_data, state, file, dtype, max_cummulative,trim)    \n",
    "    \n",
    "    print(f'Plots of {dtype} ready for day: {calendar.month_name[int(file[-8:-6])]} {file[-6:-4]}')\n",
    "\n",
    "def make_multi_plots(index, plot_index, state, days, sufx_items, max_day, max_cummulative,trim,dtypes):\n",
    "    \n",
    "    if not os.path.exists(f'plots/{state}/cummulative/{dtypes}'):\n",
    "        os.makedirs(f'plots/{state}/cummulative/{dtypes}')\n",
    "        \n",
    "    if not os.path.exists(f'plots/{state}/discrete/{dtypes}'):\n",
    "        os.makedirs(f'plots/{state}/discrete/{dtypes}')\n",
    "    \n",
    "    data = [pd.read_csv(os.path.join(data_path,x)) for x in days]\n",
    "    data = [x[x['nombre'] == state] for x in data]\n",
    "        \n",
    "    plot_data = {key:[] for key in sufx_items.keys()}\n",
    "    \n",
    "    \n",
    "    \n",
    "    for ind, key in enumerate(plot_data.keys()):\n",
    "        for day in index:\n",
    "            try:\n",
    "                plot_data[key].append(data[ind][str(day)[-11:-9]+str(day)[-15:-11]+str(day)[:4]].values[0])\n",
    "            except:\n",
    "                plot_data[key].append(np.nan)\n",
    "    \n",
    "    plot_multi_discrete(index, plot_index, plot_data, days, dtypes, state, max_day,trim)\n",
    "    plot_multi_cummulative(index, plot_index, plot_data, days, dtypes, state, max_cummulative,trim)\n",
    "    print(f'Plots of {dtypes} ready for day: {calendar.month_name[int(days[0][-8:-6])]} {days[0][-6:-4]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_indexes(sufx, data_dir, state):\n",
    "\n",
    "    newest_date = get_max_min(sufx, data_dir, 'max')\n",
    "    oldest_date = get_max_min(sufx, data_dir, 'min')\n",
    "\n",
    "    newest_date = pd.read_csv(os.path.join( data_path, sufx + str(newest_date)[-14:-12]+str(newest_date)[-11:-9]+'.csv') )\n",
    "    oldest_date = pd.read_csv(os.path.join( data_path, sufx + str(oldest_date)[-14:-12]+str(oldest_date)[-11:-9]+'.csv') )\n",
    "    \n",
    "    max_day = get_max_day(state, newest_date)\n",
    "    max_cummulative = get_max_cummulative(state, newest_date)\n",
    "    \n",
    "    index = pd.date_range(start= pd.to_datetime(oldest_date.columns[3], dayfirst=True), end = pd.to_datetime(newest_date.columns[-1], dayfirst=True))\n",
    "    plot_index = [calendar.month_name[int(str(x)[5:-12])] + ' / ' + str(x)[8:-9]  for x in index]\n",
    "        \n",
    "    return index, plot_index, max_day, max_cummulative\n",
    "\n",
    "def get_multi_indexes(files, data_dir, state, sufx_items):\n",
    "    \n",
    "    newest_date = max([get_max_min(sufx_items[sufx], data_dir, 'max') for sufx in sufx_items.keys()])\n",
    "    oldest_date = min([get_max_min(sufx_items[sufx], data_dir, 'min') for sufx in sufx_items.keys()])\n",
    "    \n",
    "    longest_data_check = 0\n",
    "    longest_data = ''\n",
    "    max_day = 0\n",
    "    max_cummulative = 0\n",
    "    \n",
    "    for dtype in files.keys():\n",
    "        \n",
    "        data_check = pd.read_csv(os.path.join( data_path, sufx_items[dtype] + str(newest_date)[-14:-12]+str(newest_date)[-11:-9]+'.csv'))\n",
    "        max_discrete = max(data_check[data_check['nombre'] == state].values[0][3:])\n",
    "        sum_cummulative = sum(data_check[data_check['nombre'] == state].values[0][3:])\n",
    "        \n",
    "        if len(data_check.columns[3:]) > longest_data_check:\n",
    "            longest_data_check == len(data_check.columns[3:])\n",
    "            longest_data = data_check[data_check['nombre'] == state]\n",
    "            \n",
    "        if  max_discrete > max_day:\n",
    "            max_day = max_discrete\n",
    "        if sum_cummulative > max_cummulative:\n",
    "            max_cummulative = sum_cummulative\n",
    "    \n",
    "    index = pd.date_range(start= pd.to_datetime(longest_data.columns[3], dayfirst=True), end = pd.to_datetime(longest_data.columns[-1], dayfirst=True))\n",
    "    plot_index = [calendar.month_name[int(str(x)[5:-12])] + ' / ' + str(x)[8:-9]  for x in index]\n",
    "    \n",
    "    return index, plot_index, max_day, max_cummulative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_animation(data_dir, dtype, state, trim=0):\n",
    "    \n",
    "    if type(dtype) == list :\n",
    "        \n",
    "        sufx_items = {key:sufx_dict[key] for key in dtype}\n",
    "        \n",
    "        dtypes = [x for x in sufx_items.keys()]\n",
    "        dtypes = join_list_names(dtypes)\n",
    "        \n",
    "        files = {}\n",
    "        for key in sufx_items.keys():\n",
    "            files[key] = [file for file in data_dir if file.startswith(sufx_items[key])]\n",
    "        \n",
    "        if os.path.exists(f'plots/{state}/cummulative/{dtypes}'):\n",
    "            plot_files = os.listdir(f'plots/{state}/cummulative/{dtypes}')\n",
    "            plot_file_dates = [pd.to_datetime(plot[:-4]) for plot in plot_files]\n",
    "            \n",
    "            for key in list(files.keys()):\n",
    "                \n",
    "                filtered_days = []\n",
    "                for item in files[key]:\n",
    "                    date = pd.to_datetime(item[-12:-8]+'-'+item[-8:-6]+'-'+item[-6:-4])\n",
    "                    if date not in plot_file_dates:\n",
    "                        filtered_days.append(date)\n",
    "                        if len(filtered_days) == 0:\n",
    "                            \n",
    "                            make_mp4(state,dtypes,max(plot_file_dates))\n",
    "        \n",
    "                            for root, dirs, files in os.walk(\"plots\", topdown=False):\n",
    "                                for name in files:\n",
    "                                    if '_' in name:\n",
    "                                        os.remove(os.path.join(root,name))\n",
    "                            return\n",
    "                            \n",
    "                            \n",
    "            for key in sufx_items.keys():\n",
    "                files[key] = [sufx_items[key]+str(x)[-14:-12]+str(x)[-11:-9]+'.csv' for x in filtered_days]\n",
    "        \n",
    "        assert len(set([len(files[key]) for key in files.keys()])) == 1\n",
    "        \n",
    "        index, plot_index, max_day, max_cummulative = get_multi_indexes(files, data_dir, state, sufx_items)\n",
    "        \n",
    "        for instance in range(len(files[dtype[0]])):\n",
    "            days = []\n",
    "            for key in files.keys():\n",
    "                days.append(files[key][instance])\n",
    "            \n",
    "            make_multi_plots(index, plot_index, state, days, sufx_items, max_day, max_cummulative,trim, dtypes)\n",
    "            clear_output(wait=True)\n",
    "        \n",
    "        plots  = [x[:-4] for x in os.listdir(f'plots/{state}/cummulative/{dtypes}')]\n",
    "        max_date = str(max(pd.to_datetime(plots)))[:10]\n",
    "        \n",
    "        make_mp4(state,dtypes,max_date)\n",
    "        \n",
    "        for root, dirs, files in os.walk(\"plots\", topdown=False):\n",
    "            for name in files:\n",
    "                if '_' in name:\n",
    "                    os.remove(os.path.join(root,name))\n",
    "        \n",
    "        \n",
    "    else:\n",
    "        \n",
    "        sufx = sufx_dict[dtype]\n",
    "        index, plot_index, max_day, max_cummulative = get_indexes(sufx, data_dir, state)\n",
    "        \n",
    "        files = [file for file in data_dir if file.startswith(sufx)]\n",
    "                        \n",
    "        if type(state)==list:\n",
    "            join_names = join_list_names(state)\n",
    "            \n",
    "            if os.path.exists(f'plots/{join_names}/cummulative/{dtype}'):\n",
    "                plot_files = os.listdir(f'plots/{join_names}/cummulative/{dtype}')\n",
    "                plot_file_dates = [pd.to_datetime(plot[:-4]) for plot in plot_files]\n",
    "                filtered_days = []\n",
    "                for day in files:\n",
    "                    \n",
    "                    date = pd.to_datetime(day[-12:-8]+'-'+day[-8:-6]+'-'+day[-6:-4])\n",
    "                    \n",
    "                    if date not in plot_file_dates:\n",
    "                        filtered_days.append(sufx+str(date)[-14:-12]+str(date)[-11:-9]+'.csv')\n",
    "                        \n",
    "                if len(filtered_days) == 0:\n",
    "\n",
    "                    make_mp4(state,dtype,max(plot_file_dates))\n",
    "\n",
    "                    for root, dirs, files in os.walk(\"plots\", topdown=False):\n",
    "                        for name in files:\n",
    "                            if '_' in name:\n",
    "                                os.remove(os.path.join(root,name))\n",
    "                        return\n",
    "                \n",
    "                files =  filtered_days\n",
    "                \n",
    "            for file in files:\n",
    "                \n",
    "                make_multi_state_plots(index, plot_index, state, file, dtype, max_day, max_cummulative,trim)\n",
    "                clear_output(wait=True)\n",
    "            plots  = [x[:-4] for x in os.listdir(f'plots/{join_names}/cummulative/{dtype}')]\n",
    "            max_date = str(max(pd.to_datetime(plots)))[:10]\n",
    "            make_mp4(join_names,dtype,max_date)\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            for file in files:\n",
    "                make_plots(index, plot_index, state, file, dtype, max_day, max_cummulative,trim)\n",
    "                clear_output(wait=True)\n",
    "            plots  = [x[:-4] for x in os.listdir(f'plots/{state}/cummulative/{dtype}')]\n",
    "            max_date = str(max(pd.to_datetime(plots)))[:10]\n",
    "            make_mp4(state,dtype,max_date)\n",
    "            \n",
    "        for root, dirs, files in os.walk(\"plots\", topdown=False):\n",
    "            for name in files:\n",
    "                if '_' in name:\n",
    "                    os.remove(os.path.join(root,name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/gAAAG4CAYAAADxHEzSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeVwN+/8H8Fd7UgnXmrWuc0JJRfZSkrSRfSnCRWixZ7lk32W9SJQlsl1RWqRQiiRLKGuWitCqDW3z+8PvzLfTOdU5hHTfz8fD494+85mZ98yZ8znzmfksEgzDMCCEEEIIIYQQQshvTfJXB0AIIYQQQgghhJDvRxV8QgghhBBCCCGkDqAKPiGEEEIIIYQQUgdQBZ8QQgghhBBCCKkDqIJPCCGEEEIIIYTUAVTBJ4QQQgghhBBC6gCq4BNCCCE/gZ2dHbhcLs6ePfurQ6kxu3btApfLxbt37yrNk5WVhbVr12LAgAHQ1NRE7969MXfuXLx69ernBUoIIYT8R1AFnxBCCCFiCwsLw759+6rMk5KSgmHDhuHIkSOQkpJC//79oaSkhMDAQIwePRqpqak/KVpCCCHkv4Eq+IQQQggRy7FjxzB79myUlJRUmW/JkiVIS0vDlClTEBISgt27dyM4OBh2dnbIycnB2rVrf1LEhBBCyH8DVfAJIYQQIpKkpCRMmzYNq1atgqKiIurXr19p3ri4OMTGxkJPTw8LFy6EpOTXWw5JSUnMnz8fqqqqePPmDUpLS39W+IQQQkidRxV8Qggh5Bfh9WHfs2ePwLK4uDhwuVzY2dmxaampqeByuXB2dkZaWhoWLFiAXr16oUuXLhg6dChOnz4tdD8fP37E5s2bYWpqCi0tLfTs2RPOzs54/PixWPGuWLECERER6NOnD86ePQsVFZVK8168eBEAYG9vL7BMXl4ely9fhr+/P6SkpMSKgRBCCCGVk/7VARBCCCFEPO/evcPIkSNRXFyMrl27Ii8vD3fu3MHff/+NL1++wNbWls379u1bTJgwASkpKVBVVYWBgQEyMzMRGhqKK1euYOfOnTAyMhJpv5qampg0aRKMjY2rzZuYmAgA6NKlC7KysnDhwgU8e/YM9evXh6GhIXr16vVtB08IIYSQSlEFnxBCCPnNxMfHo1+/fnB3d4eysjIA4PTp0/j7779x+PBhvgr+/PnzkZKSgqlTp2LOnDnsG/Po6GjMmDEDCxYswMWLF9G4ceNq9+vq6ipyjK9fvwYAvHjxAnPmzEFOTg67zNvbG1ZWVtiwYQOkpelWhBBCCKkp1ESfEEII+Q0tW7aMrdwDwLBhw1CvXj0kJycjOzsbAHDv3j3cvn0bnTt3xrx58/iaw/fp0wfjx49HXl4ezpw5U+Px5efnQ0JCAs7OztDU1MT58+dx+/ZteHp6QlVVFQEBAdi5c2eN75cQQgj5L6MKPiGEEPKbadCgAdq2bcuXJiUlhUaNGgEAPn36BAC4efMmAEBfXx8SEhIC2+nXrx8AIDY2tsZj/PLlCxiGQfPmzeHh4QENDQ0oKirCwMAAe/fuhZSUFA4fPoz8/Pwa3zchhBDyX0Xt4gghhJDfTPk39+Xx3tCXlZUBANLS0gB8bRLv7e1d6fbevXtXwxEC9erVQ0FBAUaOHCnQDJ/L5UJbWxt37txBfHw8+vTpU+P7J4QQQv6LqIJPCCGE/ETC3qQLw6uk18Q2unbtitatW1eaj/fmvyY1atQIBQUFUFVVFbq8ZcuWuHPnDtudgBBCCCHfjyr4hBBCSA25f/8+PD09weVy4ejoyLesuLgYAPjmjudV1IXNBZ+bm/vd8TRp0gQAYGhoiJkzZ3739sTB4XCQkpKCDx8+CF2ekZEB4Mc8XCCEEEL+q6gPPiGEEFJDsrOzERoaijt37ggsS09PBwA0bdqUTeNV9nnLyouPj//ueLp16wYAiIyMBMMwAstPnDgBS0tL/PPPP9+9r4oMDAwAAMHBwQLLsrOz8fDhQ8jKykJLS6vG900IIYT8V1EFnxBCCKkh2trakJGRwa1bt/D06VM2PSIiAqmpqVBSUkLnzp3ZdA6HAwAIDQ3F+/fv2fS7d+/i2LFj3x1Pz549oaGhgbt372Lbtm0oKSlhlyUmJmLbtm149uwZuFzud++rIktLSzRt2hSxsbHYv38/m/7lyxe4ubkhPz8fQ4cOhZKSUo3vmxBCCPmvoib6hBBCSA1RUVHB5MmT4eHhgZEjR6JHjx4oKipiR6lfsGABZGRk2Pw9e/ZEp06dkJiYCAsLC/To0QM5OTm4ffs2rK2tcf78+e+KR0JCAu7u7pg4cSI8PDxw/vx5dOrUCfn5+YiLi0NZWRns7OxgYmLyXfsRRlFREdu2bcPUqVOxdetW+Pn5oX379nj48CHev38PDoeDBQsW1Ph+CSGEkP8yeoNPCCGE1KC5c+fCzc0Nbdu2xY0bN/Dw4UPo6elhz549GD16NF9eKSkpeHt7w9bWFvXq1UNERASys7OxZMkSrFq1qkbiUVdXx7lz52Bvbw85OTlERUUhKSkJ3bp1w86dO7F06dIa2Y8w3bp1g7+/P2xsbJCXl4dr165BTk4O06dPh6+vb6WzARBCCCHk20gwwjrlEUIIIYQQQggh5LdCb/AJIYQQQgghhJA6gCr4hBBCCCGEEEJIHUAVfEIIIYQQQgghpA6gCj4hhBBCCCGEEFIHUAWfEEIIIYQQQgipA6iCTwghhBBCCCGE1AFUwSeEEEIIIYQQQuoAquATQgghhBBCCCF1AFXwCSGEEEIIIYSQOoAq+IQQQgghhBBCSB1AFXxCCCGEEEIIIaQOoAo+IYQQQgghhBBSB1AFnxBCCCGEEEIIqQOogk8IIYQQQgghhNQBVMEnhBBCCCGEEELqAKrgkzotISEBy5cvh5mZGbS1taGrq4sxY8bg2LFjKCkp+dXh/VS7du0Cl8tFWFjYN28jKioK9+/fZ/++efMmuFwu1q5dWxMh1nrfe7wVz19tUlJSgo0bN6JPnz7Q0tKClZVVpXkXLVoELpfL969jx47Q0dGBubk51q9fj/fv3//E6IHS0lL4+PigsLCQTauJa762ys3NBZfLhZ2dXbV5eZ/XzZs3K83Du7YXLVpUk2F+l9TUVHC5XMycOZMv/f79+4iKiqqxbf7q62Tt2rXVfj4VvX//Hrt27cLQoUPRvXt3dOnSBRYWFtiyZQuys7N/YLQ/36/6nXn16hU2btwIS0tL6OjooGvXrrCxsYGHhwdfOfMjGRsbo1u3biLl7datG4yNjavM4+zsjCFDhlS6PDQ0FKNGjYK2tjb69u2LefPm4cWLFyLt/0d8j3iffY8ePZCVlVVpviFDhoDL5dbYfisjzufxs1RWTpL/NqrgkzqprKwMO3bswPDhw+Hn5wd1dXWMGzcO5ubmePfuHVatWoVJkybh8+fPvzrU38bx48cxZcoUfPjwgU1TVVWFo6Mj+vXr9wsj+3m+53iFnb/a5MyZM/Dy8oKSkhImTpyIYcOGVbuOjY0NHB0d4ejoiGnTpmHYsGFQUFDAoUOHYGVlhQcPHvyEyL+aN28eVq9e/Z97cFeXKSsrw9HRERYWFmza1atXMXr0aDx//rzG9qOvrw9HR0e0b9++xrb5I126dAnm5ubYvXs3lJSUMGTIEIwaNQpycnLw9PSElZUVXr9+/avD/K0dP34clpaWOHToEJo3b45Ro0ZhyJAh+Pz5M9zd3TFy5MgqK5w1ZcKECZg2bVqNbOvgwYO4ePFipcsPHDgAJycnPH/+HObm5jA2NkZUVBRGjRqFu3fvVrv9H/k9ysnJwfr162t8u+Kqyc+DkB9J+lcHQMiPsG/fPuzZswddu3bFzp070axZM3ZZUVERlixZgoCAACxatAjbt2//hZH+PjIzMwXSWrVqBScnp18Qza/xPccr7PzVJomJiQCA5cuXo3fv3iKtY2Njgx49egiknzp1CsuWLYODgwOCgoLQoEGDGo1VmNp+fon4lJWVBb5vWVlZKCsrq9H99OjRQ+h1XBvdunULzs7OUFFRwcmTJ9G1a1e+5T4+Pli9ejUmTZqE4OBgyMnJ/aJIf1/nz5/HypUr0bZtW+zduxfq6ursstLSUmzbtg2enp5wcHDAqVOnfmgs9vb2372N0tJSbN26FQcPHqw0z+vXr+Hu7o4GDRrg5MmTbCXdwcEBw4YNw6JFixAQEABZWdlKt/Gjv0f+/v6wtrb+pS8UauLzIORnoDf4pM55+fIl9uzZg0aNGsHT05Ovcg8AsrKyWL9+PVRVVRESEoKkpKRfFCkhtUdRUREAoGHDht+9rVGjRmHs2LHIyMjA4cOHv3t7hJCvLdMWLVqEsrIy7N69W6ByDwC2trawtLTEmzdvcPbs2V8Q5e8tNzcXq1evhoyMDA4ePMhXuQcAKSkpzJ8/Hzo6OoiPj0dkZOQvilQ0CQkJGDZsGA4ePIg+ffpUmu/ixYsoLS3FX3/9xfcGvmXLlrC3t8erV68QERHxM0IWqmPHjgAANzc3fPr06ZfFQcjvgir4pM45d+4ciouLMX78eCgrKwvNIyMjg2XLlmHdunVshaaqfn68PqyPHj1i07hcLpYuXYrY2FiMGzeO7bPm7u6O0tJSPH/+HFOmTIGOjg769euH1atX8/0w8fZ3/vx5nDp1CoMHD4aWlhbMzMxw/vx5AEB4eDiGDRsGbW1tDBo0CMeOHas2rvLxVdXXjufKlSv466+/0LNnT3Tu3Bk9e/bEzJkz+bZpZ2eH3bt3AwBmzZrF9nWreM4cHBzA5XKF9tkLDAwEl8vFgQMH2LT09HSsWLECBgYG0NTUhLGxMTZv3oz8/Pxq4+bt+/jx45g7dy66dOmCvn374vbt2wC+Vlg9PDxgbm4OLS0t9OrVC/PmzUNKSorAtgoKCrB582YYGxujS5cuGDZsGC5fvoylS5fy9esTdo0UFBRg3bp1MDMzY/fj6OiIhISEas8fT3BwMMaMGQMdHR3o6upi4sSJiImJEet4KxMdHY1JkyZBV1cXXbp0gY2NDY4dO8a+BeX13/Pz8wMADB06VOz+wMJMmTIFwNfPvSJRjhcAiouLcfjwYYwaNQp6enrQ1NSEkZERli9fztc8lsvlIjY2FgDQvXt3gX7pX758wfbt22FsbAwtLS0MHjwYx48fF9hfVFQUJk6ciF69ekFbWxtWVlbw8PBgH35U5/bt23B0dETfvn2hqamJ7t27Y9KkSQLHxvvefvz4EW5ubuy4B8OGDRPahDY1NRXz589H7969oaOjA0dHR7x9+1akmL5XUVER9u3bB3Nzc2hqaqJHjx6YMWOG0O4Xopw/3nV8+vRpHDt2DCYmJtDW1oa1tbVAhbRi39JFixZh8eLFAID169eDy+UiNTUVgOjXijAV+w4LG2Oi/L+K/Zxv3LiBSZMmQU9PD127dsXo0aMREhIidF9nzpyBtbU1tLW1YWpqihMnTlQZW3kxMTFITU1Fjx49oKenV2k+BwcHLFmyROBtqihlPSBamcYjahleUlKC3bt3w8rKCtra2tDX18eUKVNw48YNkY8fAHx9fWFqasqOE1Lx/A0cOBDa2tpCf0N2794NLpeL69evV7r9ixcvIi8vD1ZWVmjdunWl+ebPn48VK1bgzz//5EuvrrwFACsrK2hpaQmNcf/+/eByuQgODgYgvM93VlYWVq5ciX79+kFbWxv29vZ48uSJ0DgvX76M5ORkzJ8/H56enpUeD+97pK2tLbCM93tV3W+NsD74vHE97ty5Azs7O+jo6KB79+6YPXs2u09RdO/eHcOGDcObN2+wc+dOkdc7d+4c7Ozs0L17d2hqarLjCgi7D3j8+DHmzJmDPn36QEdHBzY2Njhz5gwYhmHzCPs8RC0jeWXf2bNncebMGfY6MDAwwMaNGwUeXHxPmUYINdEndc61a9cAoNpmXEZGRt+9r/j4eJw/fx79+/fH2LFjERoaCg8PD2RmZiI0NBSampoYO3YsIiMj4ePjAykpKSxZsoRvG97e3nj9+jUsLCzQs2dP+Pn5YeHChXj8+DGOHj2KQYMGoVu3bvD398eqVavQrFkzmJiYfHfswP+ac7Zp0waWlpaQkZHBgwcPEB4ejpiYGISEhKBp06awsbEBAMTGxsLc3BxqampCt2dtbY0rV64gODgYs2bN4lsWGBgICQkJWFpaAgDevn2LsWPH4v379zAyMoK6ujoePXqEAwcO4Pr16zh27BgUFBSqPYZ//vkHCgoKsLW1xfPnz9GpUycUFxdj6tSpiImJQZcuXWBra4vMzEwEBwcjKioKR48eBYfDAfD1x3nSpEmIj4+Hjo4OBg0ahISEBMycORMtW7asdv+zZ89GZGQkjIyMYGJigoyMDAQFBSEqKgpnz56Fmppaledvx44d2LNnD1RVVWFjYwMJCQmEhIRg0qRJ2LBhg8BDGmHHW5mjR49izZo1UFJSwsCBA6GgoIBr165h1apViIuLg7u7O9vPOSwsDI8fP8bo0aPRpEkTqKqqVnvsVWndujWaNm2KV69eISsrC40aNRL7eOfNm4eLFy9CT08Po0aNQlFREaKionDy5EkkJCTg33//BQA4OjrCz88Pb968wdSpUwWuz7Vr16KsrAxmZmaQlJTEhQsXsHLlSpSUlGDChAkAgLi4ODg4OKBhw4YwNzeHnJwcrl+/Dnd3d7x+/Rrr1q2r8njDwsLg7OyMRo0awcTEBPXr18ezZ88QGRmJ2NhYnDlzhn0LxTNp0iTk5ORg8ODBKCwsREBAAFxcXODj48PeRL579w5jxoxBRkYGjI2N0bJlS1y7dg1//fXXd30+ovjy5QsmTZqE27dvg8PhsK0ywsLCcO3aNWzfvp0ti8Q9f76+vnj8+DEGDx6MBg0aICwsDIsXL8abN28q7QZjYmKC3NxchIeHo2/fvujatSv7EFfUa0UUJiYmQq//K1euICEhATo6Omza6dOnsWzZMjRq1Ajm5uZQUFBAeHg4XFxcMGfOHDg4OLB5t2/fjr1790JVVRUjRoxAeno6Vq1axX43qsN7W9y3b98q83Xo0AEdOnTgSxO1rAdEK9MA8crw1atX48SJE9DX14eBgQHy8vIQFBSEKVOmwNvbW6Sm3cHBwcjKyoK5uTn69euH8PBwuLm5sQ/AgK+Dre3atQthYWEYOnQo3/oBAQFo2rQpevbsWe05ru7+oVu3bgIVPVHKWwkJCVhZWWHr1q1CYwwMDISiomKlg+UVFBTA1tYWSUlJ6NWrFzgcDmJjY2FnZ4fPnz8LvNQwMjLC2LFj8ccff1R5PLym98IeZubl5QHANz9UTEhIwIQJE6Cnp4exY8fi/v37CA4OxqNHjxAcHAxJSdHeNbq6uiIiIgKHDx+GhYUFNDU1q8y/ceNGeHl5QUNDg/2tuXXrFi5cuIDbt28jJCQE8vLyAL4+pHNwcEBpaSkGDBiAli1b4urVq1i6dCnevn0LZ2dnofsQp4zk8fHxwdOnT2Fqaop+/frh0qVL8PLyQm5uLt/Lg5os08h/EENIHdOrVy+Gw+EwOTk5Yq0XExPDcDgcZs2aNQLLXF1dGQ6HwyQmJrJpHA6H4XA4jLe3N5uWlJTEpm/YsIFNz8vLY3R1dZlevXoJ7K9jx47MgwcP2PQTJ06w27hy5QqbfvPmTYbD4TAuLi5VxlU+Pmtra/bvnTt3MhwOh7l06RLDMAzz5csXRldXlzE1NWUKCgr41nVzc2M4HA5z4sSJStcXds4+f/7M6OrqMhYWFnzby83NZTQ1NRlbW1s2berUqQyXy2UuX77Ml/fw4cMMh8NhNm7cKHBM5fH2ra2tzXz48IFvmaenJ8PhcJhNmzYxZWVlbPr9+/eZzp07M8OHD2fTDh48yHA4HGbVqlV8eTds2MB+DpUd75MnTxgOh8MsXLiQb//BwcEC14Cw8xcfH89wuVzG1taWKSwsZNOzsrKYgQMHMtra2kxmZma1xytMcnIy06lTJ6Z///5McnIym15QUMBMmDCB4XA4jJ+fH5te1bVUES9vTExMlfmGDx/OcDgc5vHjx2If7927dxkOh8PMmzePb5vFxcWMpaUlw+FwmBcvXrDptra2DIfDYT5+/Mim8c65oaEhk56ezqYnJCQwXC6XsbKyYtOcnJwYDofDd66KioqYIUOGMB07dmRyc3OrPNZBgwYx+vr6fPthGIbZv38/w+FwmK1bt7JpvPM3YsQIvu+ev78/w+FwmAULFrBpCxcuZDgcDnP27Fk2raCggD3e8t+pyvD25+rqyuzcuVPov/J5eHbv3s1wOBxm0aJFTHFxMZv+4MEDpkuXLky3bt2YvLw8sc4f7zrmcDhMcHAwmzcjI4MZMGAA06lTJ+bly5cMwzBMSkoKw+FwmBkzZrD5/v33X4FyV5xrRdg2hX03K4qLi2M6d+7MWFhYMPn5+QzDMExaWhqjqanJDB48mMnKymLzfvr0iRk9ejSjoaHBPHnyhGEYhnn58iXTqVMnZsiQIXzX6OXLlxkulyvS98nFxYXhcDhMaGholfkqEqesF6dME7UMz8vLYzQ0NJjx48fz5bt//z7D4XAYJyenKuMvf82EhYWx6VlZWYyFhQWjoaHBJCUlMQzztdzjcrnMlClT+LYRHx8v0u/KiBEjGA6HwyQkJFSZryJxytu0tDRGQ0ODmTZtGt82ePcPixYtYtOMjIwYPT099u8dO3YwHA6H2bVrF5tWXFzMzJ07l+FwOIyRkVGVcVa8L+Dx8/NjOBwOs2zZMoFlvOvO3t6+ym0L+x7xPjdPT082raysjJk8eTLD4XCY69evV7nNir+5AQEBDIfDYYYOHcpXJllbW/P9Vr9794695kpKSvi2OXXqVIbD4TDXrl1jGIZhSkpKGGNjY0ZLS4u5c+cOm+/z58+MlZUV07FjRyYjI4NhGMHPQ5wysvw9X/n95ObmMj179mS0tLTY7+f3lmmEUBN9Uufk5uYCAOrXr//D9yUrK4tx48axf6upqbFN/idPnsymKyoqQl1dHZmZmQIj9/OaXvHo6uoCANq3b4/+/fuz6bymc2/evKmR2EtLS7F69WqsXbtW4E25vr4+APEHLpOTk4OpqSmePXuGZ8+eselhYWEoKiqCtbU1AODDhw+IjIyEoaGhQEsKW1tbtGjRQuT+o3p6emjSpAlf2pkzZ6CkpITZs2dDQkKCTed1gXjw4AEbn5+fHxQUFATyOjo6Vjs4HK/Z5fPnz5GTk8Omm5iYICwsjH2rVBle87+FCxeiXr16bHrDhg0xdepUfPr0iW2qWdXxCuPv74+SkhLMmjWLr6mpgoIC/v77bwD44W8AeG+FeE1RxTne5s2bY8OGDXBxceHbprS0NNs8WdTrc+TIkXxvsDp16oRmzZrxNdPkfZblm6HKyMjA09MTN2/ehJKSUqXbLysrw7x587Bp0yaBN2W8N5PCYh0/fjzfd8/Q0BDA1+m5gK9v00JDQ9GhQwe2FQjw9TOs7toSxs/PD7t37xb6j9dFo2L+evXqYenSpZCW/l+DP01NTYwbNw65ubkIDQ1lzwEg+vnT0dGBmZkZ+3fjxo0xffp0lJSUCFzz1anJa0WYtLQ0ODs7Q15eHrt372Z/W/z9/VFUVARnZ2e+sSvk5eXh7OyMsrIy9ryGhISgpKQEDg4OfG9ZjYyMqn0jz8N7kyrub5s4Zb2oZZo4ZXhZWRkYhsHbt2+RlpbG5tPS0kJYWBi2bt0q0nHo6+tjwIAB7N8NGzbEjBkzUFZWxnYFat26NfT09HDjxg2+Zsz+/v4AUG23tW+9fxCnvG3evDm6deuG6OhofPz4kc0bFBQEAFVOURoYGAhlZWVMnz6dTZOWloarqyvf75e4zMzM0LJlS5w+fRq7d+9Geno60tPTsXPnTrbvPVOuqbo45OXl2ZZSACAhIcG2kOCVdaKytLSEgYEBEhMTcejQoUrzycrKYtOmTVi6dCmkpKT4lnXv3h3A/675e/fuITU1FUOGDOFrnSMnJ4dFixbByckJX758EbofccrI8vsvvx8lJSXo6Ojgy5cv7PfjR5dppO6jJvqkzlFRUUF6ejpyc3NFbvr4rVq0aCEwqqyCggIKCwsFKmG80YyLiorYZmEA0LZtW758vIpPq1atKl2/JtSrVw/m5uYAvg5MmJSUhOTkZDx79oztF/kto1Xz+tIGBQWxP06BgYGQlZXFoEGDAHwdsZ1hGOTk5GDXrl0C25CRkUFaWhrev38vMEhiRRWb0hYUFODly5do0qQJ9u3bJ5A/IyMDAPDo0SO0adMGT58+RefOnQUqIPXr1+fr2y0Ml8uFjo4O7t69C0NDQ7b5qZGRUZX9N3l4fVpDQ0Nx9epVvmXv3r1j46zqeCvz+PFjAP+7mSmvQ4cOUFZWZvP8KAUFBQD+d7MszvE2b94cNjY2KCkpQUJCAl6+fInk5GQ8evSI7UMr6vXZrl07gTQVFRV2n8DXhwBhYWFwdXXF3r170a9fPxgYGKBnz55VjhwNAJKSkhg4cCCArw/gnj17huTkZDx//pwdy0BYrBWnk+Jdg7zveEpKCgoLC4U2RdXU1ISMjEyVcVV05MiRSptC37x5k+8mPD8/HykpKdDV1YWioqJAfj09PXh5ebHXkLjnT1gcXbp0AQCxr8uavFYq+vz5M2bNmoXMzEzs27eP71p6+PAhgK/Ne8s/0ATAzpPOOxbef4V9ljo6OmzXsqqoqKgAAF+lUBTilPWilmniluHm5uYIDAzEwIEDoaOjw26zYh/2qvAefpcn7JoZOnQo4uLiEBwcjPHjx6O0tBTBwcHQ0NCodq70hg0b4tWrV2KfY3HLW2tra8TGxuLSpUsYMWIEgK8V/CZNmlTaheDz58949eoV9PX1Bb77TZs2RatWrb75OpeXl8fevXsxY8YM7Nq1i/1MGzVqhE2bNsHR0ZHvvkUcLVu2FCgDKpZ14lixYgUsLS2xa9cuDBo0SOhvbcOGDWFlZYWysjI8ffoUSUlJSElJwZMnTwTKBN7nImzQyt69e1c6q4y4ZSSPsN8j3vkoLi4G8GPLNPLfQBV8Uue0bt0a6enpeP36dZUV/Ly8PHz69Intd/gtyr+FLK+6CkFNb+Nb3bp1C+vXr2crXnJyctDQ0EDnzp2Rlkr6Q58AACAASURBVJb2TU/se/TogWbNmrEV/OzsbNy4cQPGxsbsmyveW5J79+7h3r17lW4rJyen2gp+xWmgeG+L09PT2YHthPn48SP7hqqyN+LVXRsSEhI4ePAgDhw4AH9/f0RGRiIyMhJr1qxB7969sXr1aoEHNeXx3sjt37+/yjjLE3XaK955qOzNc9OmTX/oXNm8N3YSEhLsQwlxj/fEiRP4559/8OHDBwBfp03T1taGuro64uPjRb4+RTlnhoaGOHLkCA4ePIjr16/j6NGjOHr0KFRUVODo6CgwcF9FT548wZo1a9gHQjIyMlBXV4empiZevXolNNaK33HeGzheXt65EPY2UUpKSuhNZU3hPZyp6voBwLZIEvf8Cftu8b6HogyyWVFNXSsVLVmyBAkJCXB2duZrUQX873quaqA83mdY1ZthXsW9OryyJDk5udq8SUlJfCPAi1rWi1qmiVuGb9y4EZqamjh79ixiY2MRGxuLLVu2QFNTE2vWrBEYn0IYYf3IeeeT90AFAAYPHow1a9bgwoULGD9+PKKjo5GRkcEO/FmVVq1a4e7du0hOTmYfHghTVFSE9+/fs5VLcctbMzMzrF69GsHBwRgxYgQeP36MpKQkTJo0qdI+6VWVBwDQoEEDZGdnV3uMldHQ0EBQUBAuX76M1NRUNG/eHAMGDGDfKlfXj78ywu5lKpZ14lBVVYWLiwvWr1+P5cuXw9vbW2i+0NBQbN26lW0loKCgAE1NTWhoaOD69evsvnnXsrjlqbhlJI+o5+NHlWnkv4Eq+KTO6devH+7cuYPo6Gi+ZlAVnTx5Eps3b8aMGTP4mmcLKzRr67QslcUsSry8Acnk5OSwevVq6OnpoV27dpCSkkJQUBDfSLjikJSUhIWFBfvkOj4+HiUlJXzNDnnNRGfOnCnQBO178bbdrVs3gVkHKuLdlFVWoeD9gFelfv36cHFxgYuLC16+fIno6GgEBATg+vXrmDNnDk6fPl1lrFJSUoiPjxf7bawocQFfm9IKe9D18eNHkSsW3+Lp06fIzc0Fh8Nhb4DEOd7g4GC4ubmBy+XCzc0NnTt3RosWLQB8nSopPj6+xmPW19eHvr4+CgsLERcXh6tXr8LPzw9r1qxBmzZt2Cb0FeXn52Py5MnIy8uDq6srevfuDTU1NcjKyiI+Ph4XLlz4pnh4XUR4FcnyGIb5oeVS+etHGN5NcflrSJzzJ6zJq7BtiuJHXSseHh4IDAzEgAED2JH8y+OVNWFhYdW22OE93MzPzxeYilKUcgb4+tu2b98+REVF8TXRruj+/fsYOXIk9PT0cPz4cbHLelHKNHHLcBkZGUyePBmTJ0/G27dvER0djZCQEPZYwsPDqy0TeNdHebzrs3x3KkVFRQwYMABBQUF4//49goODISUlxQ7wWpV+/fohICAA0dHRVeYPDw/H7NmzYW1tjc2bN4td3iopKaF///4IDw9Hdna2SM3zqyoPAP6HHN+qXr16sLCw4EvjtVQRp7XFjzZhwgRcuHAB169fx7lz5wSWx8fHw8XFBc2bN4e7uzu0tLTQunVrSEhIYP/+/XwzKfCuZWHfw+LiYjAMI7RS/i1lpKh+xe8fqVuoDz6pc6ysrCAjIwMfH59Kfwg/ffrEVrx4c8Pybi6E/UgKm1KlNqgsZlHe8ISFheHTp09wdnbGqFGjoK6uzvZVS0pKAsD/4ECc/n28fo7h4eEICQmBsrIy39svXjNJ3o1DRTt37sT+/fu/qfmekpISWrZsiefPnws8OQe+Tpuza9cupKamQlFREe3atcPjx48F9lVaWlppfDyPHz/Gxo0b2TdY7du3h62tLY4fP4527drh/v377HaFnT8ul4vS0lKh0xzevXsXW7ZsQVxcnMjHXp6GhgYACF3/9evXSE9PFxhpuybxHq6Uv2EV53h5leKtW7fCxMSEvbkBwE7DWJNvMA4fPozt27cD+HrDZ2BggOXLl8PNzQ1A1VNExcTEICMjA+PHj8fkyZOhoaHB3hAK+y6Jqk2bNlBSUsLdu3cFllV2fdcURUVFtGrVCi9fvhQ6JdOtW7cA/O+mX9zzJ2yaPd73SNhUXTzCvkc/4lq5cuUKtm/fDjU1NWzatKnS7y8g/FhevXqFjRs34vLlywCAzp07AxB+HVVXzvDo6OigXbt2iI2NrfJ6PHLkCACwTYvFKetFLdPEKcNTUlLg7u6OK1euAPjaZHvkyJE4ePAgevbsiffv34s0ZZqw88z7bvDOL8+QIUPAMAzCw8MRGRmJXr16idRaz9jYGCoqKggICKj0d7+srAw+Pj4A/nf/8C3lrbW1NUpKShAREYGQkBCoqakJHEd58vLyUFdXR2JiosB3Pzc3V6Tf/crcv38fffr0EdqvndeHXNSxIn4GSUlJrFmzBtLS0li/fr3Aw5/AwECUlZXBzc0NFhYWaNOmDfsdrlgm8GbUuX//vsB+goODoa2tLfQhgrhlpDh+9u8fqXuogk/qnNatW8Pe3h7Z2dn466+/BJ6u5uXlYf78+Xj16hWMjIzYPnNt27aFlJQUYmJi+N6MXb16Vej8v7UBb7oi3o0T8PXmQ1jf84p4zZZ5fdJ5Hj9+zN4glpSUsOm8AWREqXRraGiAw+EgKCgIt27dwqBBg/iegLdu3Rrdu3dHZGSkwHzR586dwz///INr1659czcFGxsb5OTkYMuWLXz91J4/f45Vq1bB29ubfao+bNgw5OfnC/Qj9fDwQHp6epX7KSoqgpeXF/bs2cP3Y5ufn4+PHz+iSZMm7DEIO3+8gdPWrVvH14ogPz8fK1asgKenJ0pLS7/lFGDIkCGQlpbGvn37+G5UCwsLsWrVKjbPj+Dv749Tp06hadOmfINQinO8lV2f586dY5vBl78+eQ+7eH0YxRUVFYV9+/YJNDfmDWpZ1ZSJvFgrDnr09u1btptI+VhFJSMjA0tLSyQnJ/M1Qy0qKhJ5YLLvYWNjg8+fP2PdunV88SckJMDHxwfKysrsdF7inr9Lly7xVYbS09Oxd+9eKCgoYPDgwZXGxPself+cxb1WqpOUlIT58+dDSUkJ//zzT6VNd62trSElJYXt27fzlRUlJSVYvXo1vLy82G5AvKkD9+7dy5c3Li6OfQhQHSkpKSxduhQA4OzsLHCuS0tLsXfvXgQEBKBFixaYOHEiAPHKelHLNHHKcHl5eXh6emLHjh185V9RURHS09MhKysr0sCh165d43vY9eHDB3h6ekJWVlbgzXffvn3RpEkTHDhwABkZGSKXdbzBWYuLi/HXX3+xlSmeL1++sNPederUiX3L/y3lraGhIVRUVNipcnmD0FbFxsYGhYWF2LJlC/v5MAwDd3f3bypjeDgcDgoKCnD69Gm+z+jcuXO4cuWK2OMl/AwaGhqYPHkycnJyBKbwq+yav3HjBlt55p2v7t27o0WLFjh//jzfw+eioiIcOnQIkpKS6NWrl9AYxCkjxVHTZRr57/nuJvrPnj2DpKQkX18vQn61OXPmIDMzE2fPnsWAAQPQv39/tGnTBu/fv0d0dDSysrKgq6uLTZs2sevw5q++ePEiRo4cCUNDQ6SkpODy5cvQ09Or8o3Jr2JpaYkdO3bg4MGDSElJQatWrRAdHY3c3Nxq53A3MjLC1q1b4eHhgRcvXqBNmzZ4/fo1rly5wjapLj+KMq8v/N69e/Ho0SM4OjpWuX3eXL+8/69o1apVGD9+PFxcXGBgYIAOHTrg5cuXuHr1KlRUVNg3f99i2rRp7Hz3t2/fhr6+PnJzcxESEoJPnz5h8+bN7E27vb09QkJCsH//fty+fRtdunRBYmIi4uLioKysXGV/4C5dumDQoEG4ePEibGxs0LNnT5SUlCAsLAzZ2dl8c9oKO389e/aEnZ0djh49CgsLCxgaGkJWVhZhYWFIS0vDmDFjRJofWpjWrVvD1dUVa9euhY2NDUxMTKCgoIDIyEikpKTAwsJCYA5mcfn5+bE3G6WlpcjNzcW9e/eQkJAAFRUVgcqROMdrbW2NwMBAODo6wsLCAoqKinjw4AFiY2PRuHFjZGZmCr0+lyxZgj59+vANGCcKJycndqA5MzMzNGvWDM+fP8eVK1egrq5e5c23np4eVFVVcf78eWRnZ0NDQwNpaWkIDw+HnJwcJCQk+GIVx5w5c3Djxg1s2LABUVFRUFdXx40bN5CTkyPyeAzfaurUqYiKikJAQACePHmCnj17IjMzE2FhYWAYBtu2bWM/X3HPX/369WFvbw8zMzMoKioiLCwMGRkZWL16dZWVPd7n7Ovri48fP8LOzk7sa6U6M2bMQH5+PgYPHozw8HAEBQUJvC2bOHEi2rVrhwULFmDDhg2wtLSEsbExGjRogMjISCQlJcHIyIg9blVVVbi6umLVqlWwsbHBwIEDkZeXh5CQELRo0ULkt68GBgZYs2YN3NzcMHr0aOjr66Nz584oLCzErVu38OLFC3aAUV45Lk5ZL06ZJmoZ3qRJE0ycOBHe3t6wtLSEoaEhJCUlce3aNSQlJWHmzJki9X9WVVWFvb09LC0tISMjg0uXLiEjIwMrVqxA8+bN+fJKSUnBysoKXl5eUFBQYAfBFMXYsWPx4cMH7NmzB5aWlujbty/U1dWRk5ODmJgYvH37FmpqatizZw/7wOlbylsZGRmYmZmxYziI0oVg4sSJuHz5Mo4ePYqHDx9CW1sb9+7dw9OnT9G4cWORj7EieXl5zJ07F2vXrsWwYcPQr18/vH37FqGhoWjZsuV3/R7/SI6Ojrh48aLAeDLm5ubw9vbGypUrcevWLTRp0gRPnjxBVFQUGjZsyFcmSEtLY926dZg+fTrGjBmDgQMHonHjxrh69SpevXqFxYsXVzoWkDhlpDhqukwj/z0iV/AZhoGnpydevnyJ9evXo6ysDA4ODuzIr7169cKuXbt+ytRkhFRHSkoK69evh4WFBU6cOIHHjx8jIiIC0tLS4HK5cHFxwciRIwWmT1m3bh2aNm2KkJAQHD16FB06dMDOnTuRnJxcKyv4f/zxB44cOQJ3d3dERkZCRkYG/fr1w8KFC6vsowl8vVH29vaGu7s7YmJiEBUVhZYtW8LOzg7Tp0+Hqakprl27BoZhICEhAXNzc0RERODq1as4fvw437RdwlhbW2Pbtm1o2rSp0JGF1dTUcPbsWezZswcRERG4ceMGmjZtiiFDhghMNSQueXl5HDlyBAcOHEBQUBCOHz8OJSUl6OrqYvr06ezUUMDXJ+WHDh3C9u3bcenSJdy/fx8cDgf79+/Hjh078Pz58yr3tWnTJmhqaiIgIAAnT56EhIQEOnfujOXLl/M9uRd2/tTU1PD3339DS0sLvr6+8Pf3h5SUFNq3bw8nJ6dqz3F1JkyYgHbt2uHgwYMIDQ0FwzBQV1fH9OnT2ZGbv0f5qdUkJCRQr149tG3bFlOnToW9vb3QQZlEPd7+/ftj27Zt8PT0REBAAOTl5dG6dWssX74cOjo6sLGxQUREBHtT7ODggKSkJERHR+PVq1diV/C7dOkCHx8f7N27FzExMcjKykLTpk0xYcIEzJgxQ2B6sfIUFBTg7e2NLVu24Pbt24iLi0OLFi1gbW2NWbNmYdq0aYiLi0NBQYHYv5ENGjSAr68vduzYgfDwcMTFxUFXVxfbt2/H6NGjxdqWuHjfjYMHDyIgIAC+vr5QVlaGkZERpk+fjk6dOrF5xT1/1tbWaNOmDQ4ePIicnBx07NgRa9eurXScA57u3btj/PjxOH/+PI4dO4bevXuLfa1Uh1dZCA4OrnTKPhsbGygrK2PSpElQU1ODl5cXQkNDUVZWhtatW2PRokUYP34839RZ48ePR7NmzeDh4YGzZ8+iYcOGcHZ2hqysLNavXy9SbMDXGQu6du0KHx8f3L59G6dPn0ZxcTHatGkDBwcHTJ48ma9Purhlvahlmjhl+IIFC9C2bVucPn0afn5+KC0txZ9//okNGzaIXM6NGzcOJSUl8PHxQWZmJjgcDlauXAkTExOh+QcPHgwvLy+YmppWOphtZVxcXGBoaIhjx47hwYMHuHXrFhiGgZqaGsaNGwc7OzuBUeW/pbwdMmQITpw4AR0dHZF+82RlZdkWFhcuXICvry86duwILy8vrFixotJuiaKYMGECGjRogEOHDuHEiRNo2LAhxowZg5kzZ4rUwuJXkJOTw8qVK2Fvb8+X3rFjR+zfvx87d+5EWFgYpKSkoKqqCmdnZ4wYMQIGBgaIiIhg75N69+4NX19f7N69GxEREfj06RP+/PNPbNy4scoH4eKUkeKo6TKN/PdIMCJ24jhw4AC2bNmCfv36wdPTE4GBgZg3bx4GDRqEDh06wNPTE+PHj8fChQt/dMyEEFJjUlNT0ahRI6EVOCMjI9SrV48dAIkQ8n14b/knTJjANjcn5Ec4efIkli9fjkOHDlXaxJoQQuoikfvg+/n5YeDAgfD09ATwdb7OevXqYePGjXB0dMS4ceME+mERQkhtxxtVuuKASkFBQXj79u03N5EnhBDya+Tl5eHw4cNo06ZNpfPKE0JIXSVyE/2UlBS2CUxxcTFu3LgBfX19tomSurq6wGAQhBBS240ePRoREREYMWIETE1NoaKigqSkJFy9ehXNmzevdqwBQgghtUNsbCzWrVuH1NRU5OXlYePGjWLNAEMIIXWByBX88oNN3bx5E4WFhTAwMGCXJycnC+1vSQghtZmxsTEOHToELy8vXLlyhR0peuzYsZg5c+Z3DVxECCHk52natCkyMjIgJSUFZ2fn7x5IlBBCfkciV/B1dHTg4+MDVVVV7Nu3D9LS0jA1NUVxcTGuXLkCX1/fSgc6IYSQ2qxnz57UjJOQn6BHjx548uTJrw6D1FHt2rVDVFTUrw6DEEJ+KZEH2UtLS8OUKVPw4sULSEhIYOHChZg0aRJu3ryJiRMnsqPIVpyqhBBCCCGEEEIIIT+eyBV8ACgpKUFiYiKaNWvGzgn58eNHREdHs6NN13a1caozQgghhBBCCCGkOnp6elVnYL5BaWkpk56eznz58uVbVv+l4uLiqs2TmJj4W+WpTbHUVJ7aFMvPzFObYqmpPLUplp+ZpzbFUlN5alMsPzNPbYqlpvLUplh+Zp7aFEtN5alNsfzMPLUplprKU5tiqak8tSmWn5mnNsVSU3lqUyw/M09tioVhRKvLijxNHgC8fv0aTk5O0NPTg4GBAW7fvo0bN25g5MiRiIuL+54HEYQQQgghhBBCCPkOIlfwX716hZEjRyI2Nhb9+vUD8/8t+6WkpPDixQtMnjwZ9+7d+2GBEkIIIYQQQgghpHIiV/Dd3d0hLy+PoKAgrFixgq3g6+vrIygoCH/88Qd27979wwIlhBBCCCGEEEJI5USu4MfExGDs2LFo3LgxJCQk+JY1a9YM48aNw8OHD2s8QEIIIYQQQgghhFRP5Ap+UVERlJWVK10uIyODL1++1EhQhBBCCCGEEEIIEY/IFXwNDQ1cvnxZ6LKSkhL4+/uDy+XWWGCEEEIIIYQQQggRncgV/OnTp+P69euYP38+YmJiAABv3rxBeHg4JkyYgMTEREyaNOmHBUoIIYQQQgghhJDKSYua0cjICGvXrsW6desQGBgIAFi2bBkYhoGcnBxcXV0xaNCgHxYoIYQQQgghhBBCKidyBR8Ahg0bBlNTU1y/fh3JyckoKyuDqqoqevfujYYNG/6oGAkhhBBCCCGEEFINsSr4AKCoqAhTU1P27/z8fEhJSdVoUIQQQgghhBBCCBGPyH3wASAwMBDbtm1j/16xYgX09fXRrVs3LFu2DCUlJTUeICGEEEIIIYQQQqoncgX/33//xbx58xAVFQUAiIiIwIkTJ6CjowNra2v8+++/OHDgwA8LlBBCCCGEEEIIIZUTuYn+sWPHoK+vDy8vLwCAv78/ZGRksGfPHjRo0ACysrI4d+4cHBwcfliwhBBCCCGEEEIIEU7kN/gvXryApaUlpKWlUVZWhqioKOjq6qJBgwYAAE1NTbx9+/aHBUoIIYQQQgghhJDKiVzBr1evHoqKigAAd+7cwcePH2FgYMAu//DhA1RUVGo+QkIIIYQQQgipQYsWLQKXy+X7p6mpiSlTpmDBggV49uzZT4kjMzMThYWF7N92dnYwNjb+KfuujL+/P7hcrtBlmZmZcHV1RY8ePaClpYXhw4cjIiJCIF9ycjKcnJzQq1cvdO/eHU5OTnj9+vU377egoADr1q2DoaEhunbtimXLliEhIUGk46m47oQJE0Re93ckchP9Tp064dSpU9DR0cE///wDSUlJdjT9hIQE+Pr6QldX94cFSgghhBBCCCE1afHixex0358+fcLdu3dx9epVXLx4EZ6enujRo8cP23dERATmz58PPz8/KCgo/LD9iOPRo0dYuXKl0GVFRUWYOHEiXr16BVtbW7Rq1QpnzpyBg4MDPDw80KRJEwBARkYGxo0bBwCYPHkyJCUlcfjwYYwePRpbtmwRe78AMHfuXERHR8POzg6qqqrw8vKCnZ0d/Pz80LZt2yqPqeK6Pj4+7Lp1kchv8F1dXZGVlYURI0bgxo0bsLW1RevWrRETE4Phw4eDYRi4uLj8yFgJIYQQQgghpMaYmJhgyJAhGDJkCMaMGQN7e3ucO3cOioqKmD17NgoKCn7Yvu/fv4/c3Nwftn1xhYWFwdbWFvn5+ZUuf/bsGebPn49FixbB1tYWPj4+aNy4MXbs2MHmO3DgALKysuDl5YWpU6diypQpOHjwILKzs3HhwgWx9xsdHY2rV69i+fLlcHV1ha2tLdauXQtpaWns3LmzymMStu6xY8dEWvd3JXIFn8PhICAgAO7u7vD19cWSJUsAAB06dMDcuXNx7tw5qKur/7BACSGEEEIIIeRHa9GiBfty899///3V4fwUe/bswaxZs9C2bVv07dtXaJ6UlBQAQJ8+fdg0RUVF6Orq4unTp2wawzAwNjYGh8Nh0zp06ICGDRsKNNNfvnx5tfsNDAyEvLw8hg4dyqapqKjAzMwM4eHh+PLlS6XHJWzdxo0bs+vyuqDXJSJX8AGgYcOGGDx4MHR0dNi0xo0bY9q0aWyTDEIIIYQQQgj5nZmZmUFWVhbXrl3jS7979y7c3Nygo6MDHR0dTJ48Gffv3+fLwzAMfH19MWLECOjo6EBLSwtmZmbYv38/GIYBAOzYsQO7d+8GAAwYMAB2dnZ824iKisK8efOgpaWF/v37Y8+ePSgrK2OXFxUVYe3atZg+fTo0NTVhaGiIlStX4uPHj2ye1NRUcLlcvrfrlUlNTYWzszNOnDhRab2O1xT+5cuXfOkpKSl86yxevJg9Np53794hJycHf/zxB196UlJStft9+PAhOBwOZGVl+dI7d+6MT58+ISkpqdLjqm7d1NTUStf9XYncBx/4+sGHhYWhsLCQ7wIrLS1FQUEBYmJi4O/vL/L2PDw8cPnyZRQXF2Ps2LHQ19fHokWLICEhgQ4dOsDNzQ2SkpLYvXs3rl69CmlpaSxZsgRdunTB69evRc5LCCGEEEIIIaKSk5NDmzZt8PjxYzYtOjoa06dPR7t27eDi4oKioiKcPXsW48ePh7e3N7p16wYAOH78OE6fPg0bGxuMGjUKBQUFOHfuHLZu3YomTZrAxsYGgwYNgrS0NC5duoTFixejQ4cO7H7S09Ph5OQEU1NT2NnZISAgADt27ICCggLs7e0BAKtWrcKFCxdgbm4OHR0dPHv2DMeOHcPr16/Zac0bNWqETZs28dXbKrNy5cpq600DBgxAnz59sGHDBigpKaFVq1bw9fVFYmIiVqxYIXSdrKwsJCQkYPPmzahXrx6sra35lnt7ewtUvit6//49unfvLpDOeyDw9u1bdOrU6ZvWTU9Pr3LfvyORK/iXL1+Gs7MzSkpKAAASEhLsEygJCQlISkpCQ0ND5B3fvHkTd+/eha+vLz59+gQvLy+sX78es2fPRo8ePbB8+XKEh4ejZcuWiI2NxenTp5GWlgYnJyf8+++/YuUlhBBCCCGEEHEoKysjOTkZAFBWVgY3NzdoaWlh6dKl0NTUBADY2tpi6NChWLNmDc6dO4fi4mIEBgbCwsICGzZsYLc1cuRI9OrVCxcvXoSNjQ00NDSQmpqKS5cuwcTEBK1atWLzFhUVwd3dHa1atULHjh1hZWUFQ0NDXLp0ia3gBwQEYPjw4Rg5ciQ6duwIAFBQUMC1a9dQUFCA+vXrQ0FBAUOGDMGjR4+qPVYZGRmR8syaNQsuLi5sHMDXgfTGjh0rdD8TJ05km+8vXLiQ7zgBVFu5B76Ogi8vLy+Qzkv79OnTN6/7+fPnavf/uxG5gu/h4QEVFRVs2LABpaWlmD59Ok6fPo3i4mL4+PggLCwMa9asEXnHUVFR4HA4mDVrFvLz87Fw4UKcOnUK+vr6AAADAwNER0ejffv26Nu3LyQkJNCyZUuUlpayT4JEzduoUSMxTwshhBBCCCGE59/bqTgVl8KXVlhYCIXInErXqW759+YZ1a01huu1ErJGzSgpKYGEhAQAIDExESkpKRg7diwKCgqQlZXF5jMyMsKhQ4fw7t07NG/eHIcOHRIYmyw7OxuKiop8U+JVpl69ejA2NmYrxoqKilBTU0NGRgabp3nz5ggKCkKjRo2gqqoKZWVlzJ49G7Nnz66JQxfq2rVrcHBwQLNmzbBixQo0atQIYWFh8PLygrS0NMzNzQXWmTFjBiQlJREaGopNmzbB0tISW7duFXvfvM9BGEnJqnudf8+6vyORK/hPnz7FlClT0LdvX5SVlUFeXh5paWkwNTWFrq4uxowZg127dmHPnj0ibS87Oxtv377Fvn37kJqaihkzZoBhGPYDqF+/PvLy8pCfnw8VFRV2PV66OHmpgk8IIYQQQggRR05ODluP4L3J37RpU6X509LS0Lx5c0hLSyM6Ohrh4eF4+fIlXr9+zfaN57WAroqKigqkpKT40uTl5ZGZmcn+vWLFCsyeMduvhQAAIABJREFUPRu7du3C3r170bVrVwwcOBDDhw+HkpKS2Mcqil27dkFOTg7Hjx9H8+bNAQCDBg2CoqIi9u/fDw0NDbY1AQ+v0m9mZgbg66B3zs7O1U5tV56CgoLQgfR4b9/r16//zevWq1dP5Dh+FyJX8EtLS9GiRQsAX590tGnTBo8ePYKpqSmArx/ewYMHRd6xiooK1NTUICsrCzU1NcjJyeHdu3fs8oKCAigrK0NRUZFveoqCggIoKSnxPW2pLm9F1TVT+fz582+VpzbFUlN5alMsPzNPbYqlpvLUplh+Zp7aFEtN5alNsfzMPLUplprKU5ti+Zl5alMsNZWnNsXyM/PUplhqKk9tikVYnk4KwAoDlQp55IU2fxZ1+ffnyWNjFPeYcnK+tgh4/vw58vLyBPIUFhYiJSUFenp6ePToETuC/Lhx49C+fXuhTctLSkqQmJiILVu24Pr16+jYsSP+/PNPGBgYoHPnzli2bBkKCgrw6NEjfP78me3/XT6GgoIClJSUsHl48RYUFKCoqIj9W0VFBfv27cP169cRHx+Pe/fuIS4uDp6enti6dSsaNGgg9LjFOTfl1/n8+TMeP36MLl26IDs7G9nZ2ewyHR0dHD9+HPfu3YOamlql+9DS0kJgYCDCwsLQu3dvgeW8/VaMlzf6fsV4eIMb8s6psGMSti4Adl1FRcXf6nspEkZEZmZmjLu7O/u3o6Mj4+DgwP59/PhxRltbW9TNMZcvX2bs7e2ZsrIy5t27d4yJiQkzffp0JiYmhmEYhlm2bBkTGBjIPHjwgJkwYQJTWlrKvHnzhrGysmIYhhErb3lxcXHVxpaYmPhb5alNsdRUntoUy8/MU5tiqak8tSmWn5mnNsVSU3lqUyw/M09tiqWm8tSmWH5mntoUS03lqU2x/Mw8tSmWmspTm2KpqTy1KZaKeVxdXRkOh8OkpKQIzXP69GmGw+Ewp06dYhiGYe7cucNwOBzG29tbYF/x8fFMZGQk8/nzZyY2NpbhcDjM9u3b+fIUFxcz2trajK2tLbufnTt3CsRga2vLGBkZCcRbPv3Lly/MvXv3mHfv3rF5SktLmQMHDjAcDoc5cuRIjZybisu7d+/OTJ06VWDdu3fvMhwOh9mwYQNTVlbGDBs2jJk7d65APj8/P4bD4TBXrlwRGgNvvxXjXbRoEdO1a1emuLiYL55ly5YxWlpafOkVYxa2LsMw7LoPHjwQum75bVTnZ+YRpS4rcqcDExMT+Pj44PTp0ygpKUH37t1x/fp1xMbGIjMzE2fOnIGqqqrIDxaMjIzQsWNHjBgxAjNmzMDy5cvh6uqKXbt2YfTo0SguLsagQYOgqamJbt26YfTo0XBycsLy5csBQKy8hBBCCCGEECKKDx8+YOfOnWjWrBmsrKwAAJqammjSpAmOHj3KN6hbfn4+Zs+ejcWLF0NKSop9C/3nn3/ybfPUqVP49OkTO2A58L/+34wIzfbLy8nJwejRo+Hh4cG3LS0tLb7t1rQ+ffogJiZGYJq8kydPAvh6jiQkJPDHH38gLCyMbfUAAMXFxTh69CgUFBTY2QZENWjQIBQWFsLPz49N+/jxI0JCQtjZCMRZNysri123YleIukDkJvoODg64c+cOli9fjsGDB2PkyJE4ceIEJk6cCODrhbl27Vqxdr5w4UKBNB8fH4E0JycnODk58aW1b99e5LyEEEIIIYQQUlFY2P+xd+dhUZX9H8ffwy4oCWIqiohkiBJupLnvZpaPW4pLamX5aIna6lKZlkulaRZpqWkm5r5Uj6m5l6i4lqaoZS4IaijhAgrIzO8Pcn4SgkMOzKCf13VxwTn3d+7zGYyu6zvnnPusx8vLC4C0tDR27drFTz/9RFpaGjNnzjTfGuDs7Mxbb73F0KFDeeWVV+jZsyeurq4sWbKEhIQEJk2ahJOTE7Vq1cLd3Z0JEyaQkJCAp6cnMTExfP/997i6uma7nfjG/f2zZs2iSZMmtGzZ0qLM999/P+3bt+frr7/mzJkzNG/enOTkZKKiovDx8eGxxx4DshYnXLduHUajMce98f/Gyy+/zLZt2+jZsye9evXC29ubzZs3s2XLFsLDw82X5w8bNowuXbrw1FNP0atXL1xcXFi5ciWHDx9m8ODBFC9ePF/HbdasGfXq1WPMmDHExcVRpkwZZs+ejclk4sUXXzTX3Xi/FStWpFatWrm+NioqyvzavFbgL6osbvA9PDyYP38++/fvN/+jLFq0iLlz53Lx4kWaNGlC48aNCyyoiIiIiIiINU2YMMH8s4eHB97e3rRo0YLnn3+egICAbLWPPvoos2fP5sMPP2TatGk4ODhQpUoVpk+fTvPmzQHw8fHhrbfeYsmSJUybNg0XFxcCAgKYPHky+/fv56uvvjKvhv/444/zww8/sHz5cnbu3Glxgw/w7rvv4ufnx4oVK4iOjqZYsWLUr1+fl156yfzBQVJSEq+//jrNmzenU6dOd/qrws/PjyVLljBlyhTmzZtHSkoK/v7+jBw5kj59+nD48GEAKleuTFRUFFOmTGH69OkYjUZCQkKYNWsWpUqV+lfH/vTTT5k0aRKLFi0iIyODwMBAIiMjqVSpkrnmxvvt1KmTucG/1WtDQ0OZPHkylSpVss4973bG4gb/htDQUPPPJUqUYNCgQVYNJCIiIiIiUpDee++9bM+pvyE2NjbPs93169fn3XffzbMmODiYBQsW5Njfrl07hg8fDkBiYiKenp7MmTMnW828efNuOec/97u5uTF48GBat26da5YKFSpw5MiRfDexuf1uACpWrMiUKVNuO0f16tWZNWtWjv15Zblx3FvVlChRgjFjxjBmzBjzPP983zfe7+1ee7e77Q0ahw8f5p133rnl2HvvvcegQYM4cOCA1YOJiIiIiIiIiOXybPAXL15Mly5dWLBgAceOHcsxfvz4cdavX0/37t1veT+8iIiIiIiIiBSOXBv87du3M2rUKIKDg1m4cCGBgYE5aj7//HOWLVtG5cqVGT9+PHv27CnQsCIiIiIiIiJya7k2+LNnz6ZChQrMnz+fGjVq5DpB9erVmT9/Pl5eXnzxxRcFElJERERERERE8pZrg79//366dOmCq6vrbSfx9PSkS5cu7N2716rhRERERERERMQyuTb4165dw8fHx+KJ/Pz87srnCIqIiIiIiIgUBbk2+L6+vpw4ccLiiU6dOkWZMmWskUlERERERERE8inXBr9p06YsX76cK1eu3HaSK1eusGLFCmrWrGnVcCIiIiIiIiJimVwb/N69e5Oens6zzz5LfHx8rhPEx8fTv39/kpOTefrppwsio4iIiIiIiIjchlNuA+XLl+eDDz7g5Zdf5tFHH6VBgwaEhoZy//33k5mZyYULF/jll1+IiYkhMzOTcePGUa1atcLMLiIiIiIiIiJ/y7XBB2jZsiXLly9n4sSJREdH8+OPP2Ybd3Nzo2nTpgwZMoQHHnigQIOKiIiIiIiISO7ybPABAgMD+eyzz7h8+TJHjhzh/PnzODo64uPjQ7Vq1Sx6jJ6IiIiIiIiIFKxc78H/pxIlShAWFkbbtm1p3bo1tWrVUnMvIiIiIiJFzieffEJQUBAxMTG3HD99+jRBQUEMHz68kJNldyPn6dOnzfuMRmO2bUstX74823uOiYkhKCiI5cuXWy3v7Rw4cOBfH/P3338nKCiIoKAgOnbsaP45KCiITZs2Zatds2YNQ4cOpUaNGrRp04Z58+bdcs5t27bRoUOH29atWbPGorobLl68SIMGDQr1d3vDbc/gi4iIiIiISOFr3bo1FStWxNvbG8h6etnTTz9N06ZNiYiIuKO5AwMD+eCDD6hdu7ZFT06ztd9++w2A4cOHc+3aNXx9fc1jN68Ft3r1anNz37dvX/bs2cPYsWO5evUq/fv3z1b3wQcf0LBhQ8LDw/OsGzp06G3rbkhPT2fo0KFcuHChIH4Nt6UGX0RERERExA5VrVqVqlWrmreTk5M5cOAATZs2veO5fXx86NChAwCxsbF3PF9B++2333BycuKpp57i999/Jzg4OEdNZmYmEydOJCwsjBEjRhASEkLPnj0xGAxMnz6d8PBw7rvvPnNdtWrVmDlzJo6OjnnWhYWF5Vp3s3PnzjFkyBD27dtXWL+WHCy+RF9ERERERETEFn7//XcqVqyIs7NzrjX79u0jPj6ebt264ejoaN7/1FNPkZqaar6U/0ZdmzZt8qw7fPiwRfMBbN26lbZt23LkyBF69+5ttfedX2rwRURERERELHDkyBHGjx9PWFgYoaGhdOvWjfXr12erycjIYNy4cbRs2ZKQkBCaNm3KmDFjuHjxorlm6tSptG7dmn379tG5c2dCQ0Np27YtCxYsyDbXzffgx8TE0LJlSwAiIyMJCgri3LlzAJw8eZJhw4bRpEkTQkJCqFu3LgMGDDBf1n4r/7wHf/jw4dnua7/5q2PHjubXGY1GZs+eTdu2bQkJCaFx48aMHTuW1NTUbPOnpqYybtw4GjVqRM2aNRk8eDApKSk5cvTu3ZugoKDb/u5/++0385PbMjIySE9Pz1Hz66+/AhASEpJt/41L+G+M3/geGBiYZ92xY8csmu9Gbb169fjmm29o3br1bd9PQdEl+iIiIiIick+6fPkySUlJ5u1Lly6RlJTEpUuXctTu37+fPn364ObmxjPPPIOHhwfffPMNL774IqNGjaJXr14AzJgxg61bt9KnTx/8/Pz47bffmD9/PidPnmT27Nnm+ZKTk3nuuedo2rQpnTt35ocffmD06NFcunSJ//73vzmOHxgYyIgRI5gwYQKtW7emdevW3HfffZw/f55u3bpRvHhxnnrqKby8vIiNjWXx4sUcO3aMjz76yKLfRXh4OPXr18+27/Dhw8yePZuwsDDzvjfeeIOVK1fSqVMnnn76aY4dO8aCBQvYtm0bK1aswNXVFZPJxIABA9i1axfdunWjSpUqrFmzho8//jjHcQcMGMCTTz6ZZ7b09HROnTpF6dKlCQ8PZ//+/RgMBho2bMioUaPw8/MDMH/gUaZMGeLi4syvd3FxoWTJkpw5cyZbXalSpbId5591N+6jL1OmTJ51AD169KBv374A2fYXtlwb/MjIyHxPZjAYePHFF+8okIiIiIiISGHIT+8yduxYDAYDEydOpHHjxkBWU9ejRw8++OADHnvsMby9vdmyZQtdu3bl5ZdfNr/W3d2dn376iZSUFDw8PICsDxP69OnDG2+8YZ6rb9++TJs2je7du+c4vo+PD61atWLChAkEBQXRoUMHYmNjWb58OcnJyXz99dfZzkh7eHgwY8YMjh8/TvXq1W/7/mrVqkWtWrXM20lJSUydOhV/f3+GDh0KZJ31X758OWPGjMmWsWnTpvTr14+FCxfSt29fNm/eTExMDCNGjODpp58GoHv37vTo0YP9+/dnO27Dhg1vm+2PP/7g+vXrHDhwgOeff5527dpx5coVZs2aRc+ePVm5ciWlSpUyXyHg5uaWYw5XV1euXr0KYK671VPhbq678f1280FW028P8tXgGwwGAEwm0y33Q/7+SEREREREpAj4eQHsi8q2q2JqCuzwyPUltxu/45paT0HNHnm+9naGDRuWbRG7U6dOUbFiRc6fP89rr71m3n/+/Hl++eUXevTogY+Pj3m/q6sr/fr14+WXX2bbtm088cQT+Pj48P333xMSEkKrVq3w9PRk6NCh5ib5ZjefqXd0dKRPnz5ERESwbds2KlWqZNF76N+/P126dMl2NvratWs4ODiYf86v69evM2TIEJKSkli0aBFGoxGAH374AYPBQNOmTbNd+VCtWjW8vLzYvHkzffv25ccff8TBwYGuXbuaa5ycnGjXrl2OBt8Snp6eDB48mIYNG1KzZk1iY2MJDg4mNDSU5557jlmzZjFs2DBzzpv705vd2H+jLjf/7HtvN589ybXB37BhQ7btM2fOMHDgQFq1akWfPn2oXLkyRqORuLg4oqKiWL9+PTNmzCjwwCIiIiIiItZQvXp16tWrZ9728vIiODg4x3Pm4+PjAQgICMgxx42z5gkJCUBW0z5lyhRGjBjBW2+9Rc2aNWndujVdunShRIkS5teVLFky24cFAP7+/ubjWdrgQ9Y96VOmTOHgwYOcOnWK06dPk5mZCdy+mb2V8ePHs3PnTiZNmkRQUJB5lf1Tp05hMplo1qzZLV9343cQHx9PqVKlzFcr3FC+fPl8ZwHw9fW95Ynkxo0bU758eWJiYgDMx7vVhxppaWnm8Rvfb3Uf/811xYoVM8/3z/dyc509ybXB/+cv/8033+Thhx9mwoQJ2fY/+OCDvPPOO6SkpDBu3LgcC0OIiIiIiEgRV7NHjrPlp/4+i5qb241bs6ag/fMK5pvdaKBvrO5eo0YNNm3aZP6Kjo5mwoQJfPnllyxfvtz8TPtbrQZ/Y66bV2y/nV9//ZXevXvj5uZGgwYN6NKlC9WqVePUqVO88847Fs9zw5IlS5g/fz69e/emffv2OfJ5eHjc8mrvU6dOUaVKFSDrzPatmue8fo//lre3N5cvXwagXLlyACQmJmarSU9PJzk52Xwv/Y26v/76K8+6Gx/AJCYmZmvm/1lnTyxeRX/fvn00atQo1/E6depw6NAhq4QSERERERGxFzdOfv7xxx85xo4fPw5A2bJlSU9P5+jRo1y+fJnHH3+cSZMmER0dzeuvv86ZM2dYtWqV+XXnz5/Psar8iRMngP8/k2+JDz74ABcXF1atWsWHH37If//7Xxo3bmxuevNj7969jBkzhjp16jBs2LAc4+XLlyclJYWQkBAaNGiQ7SslJcV8xtvPz4+LFy9mu4wf4OzZs/nOBLBgwQJatmxpXtX+hszMTE6dOkWFChUAzGsN/LMvvbH90EMPZav757/nP+tuXJ1xu/nsicUNvre3N/v27ct1/KeffqJs2bJWCSUiIiIiImIvSpcuTUhICN9++y3nz583709PT2fOnDm4uLjQsGFDkpOTGTZsGJ9//rm5xsHBwdwI3rgvHrLOZs+fP9+8ff36debOnUuJEiVyrGZ/w40z+zdfdp+cnIy3t7f5ygDIejrAihUrctTm5dy5cwwePBgvLy8++uijW15h0KJFCwCmT5+ebf/GjRv54IMP+O677wDMj4m7+akBJpOJNWvWWJTlnypWrMjp06dzXC0+b948Ll68aL7SoHbt2pQuXZqvv/462/uOiorC3d2d5s2bZ6tbvXp1nnVVq1a1aD57YvFj8jp37kxkZCSlSpWiW7duVKxYkWvXrpkf97B582ZGjhxZkFlFRERERERs4s0336Rv37689tpr9O7dGw8PD7799lsOHjzIm2++iaenJ56enjRp0oSvv/6aq1evUqtWLZKTk4mKisLHx4fHHnss25zTpk0jPj6eKlWqsHr1avbt28e4cePMZ8L/qWTJkjg4OLBx40Z8fX2pVKkSTZo0YebMmQwZMoRGjRqRmJjI0qVLzR9E3LzSe15efPFFEhMTiYiIYPfu3WRkZJjHEhISKF26NE2bNqVly5bMnj2b06dP06BBA+Lj45k/fz6lS5emX79+ANSrV4/HHnuMmTNnkpiYSGhoKBs3buT333/Pcdzo6GjOnz9Phw4dcs3WsGFDWrduzbx580hOTqZ8+fLMmzeP5cuX06RJE/NrHR0deeWVVxg+fDjvvvsuXbp0YceOHfzvf/9j2LBh5jUQbq57/vnnadu27R3V2ROLG/yBAwdy+vRpvvzyS+bOnZttzMHBgX79+tG7d2+rBxQREREREbG1WrVqsWDBAsaPH8/s2bMxGo1UrVqVTz/9lFatWpnrXnjhBUJCQli1ahWrVq2iWLFi1K9fn5deeinbWXaAL774gtGjR7NixQoeeOABIiMjzWe/b6VYsWK89NJLfPHFF4wdO5Y33niDiIgIMjMz+f7779m0aRP3338/DRo04Nlnn+Xxxx+3eNX6AwcOAPDJJ5/ccrx27dr4+PgwdepUZs2axcqVK9m0aRPe3t60adOGxx9/PNuigRMnTiQgIIAVK1awevVqwsLCeOWVV3j77bezzfvZZ5+xc+fOPBt8gEmTJhEZGcn//vc/Vq9eTZkyZRg4cCADBgzItpp9p06dgKynwr3zzjv4+vry9ttv07Nnz2zzderUiYSEBFatWnXbOoCZM2fmWWcvLG7wHR0dee+993jmmWf46aefSEhIwGAw4OfnR8uWLfHz8yvInCIiIiIiIlYRERFBREREruMVKlTgyJEjOfZXr16dN998M89F/1xdXRk8eDCDBw++bY46deqYL2u3NGf//v3p378/ALGxsbi6ujJs2LBb3jMfGxtrXgG/c+fOdO7c2TxWr14983uMjY295fu9eZ4b79nZ2ZmBAwcycODAHDU3c3Z2ZsiQIQwZMiRbzT+PM2/evFyPezM3NzdeffVVXn311Wx5bqVTp05UrVr1tosztmjRwqLHvHfq1Mnc6Fvi5t9tYbO4wb8hKCiIoKCggsgiIiIiIiIiIv+SxYvsQdYCDu+99x6PPvooNWrUYPv27ezdu5ehQ4eaV3wUERERERERkcJncYOfmJhIly5diIqK4r777jM/1/Dy5cusW7eO8PDwHI8tEBEREREREZHCYXGDP3nyZC5evMjKlSv57LPPMJlMADRt2pSlS5fi4ODA1KlTCyyoiIiIiIjI3WDIkCE2u0db7m4WN/ibN2/mqaee4oEHHsi2SiFAcHAwvXr1Yu/evVYPKCIiIiIiIiK3Z3GDn5KSQtmyZXMd9/Ly4vLly1YJJSIiIiIiIiL5Y3GDHxgYSExMTK7j69evJyAgwCqhRERERERERCR/LG7we/fuzerVq5kyZQqnTp0CID09ncOHD/Pyyy+zY8cOunfvXmBBRURERERERCR3TpYWdu7cmYSEBKZNm8aMGTMAGDBgAAAmk4nevXurwRcRERERERGxEYsbfIBBgwbRoUMH1q1bR1xcHJmZmVSoUIHmzZtTpUqVgsooIiIiIiIiIrdhcYOfkJDA/fffj5+fH88++2yO8dOnT7N79246duxo1YAiIiIiIiIicnsW34PfokULevTowdmzZ285vnfvXkaMGGG1YCIiIiIiIiJiOYsbfIBff/2VTp06sX379oLKIyIiIiIiIiL/Qr7uwX/ppZdYs2YNzz33HEOGDKF///53dPCOHTtSokQJACpUqEB4eDjjxo3D0dGRRo0aMWjQIIxGI6NHj+bIkSO4uLgwduxY/P39+fnnny2uFREREREREbnb5avBL1euHAsXLmTkyJFMnjyZAwcO8N577+Hh4YHBYMjXgdPS0gCYN2+eeV+HDh345JNP8PPzo3///hw8eJD4+HjS09NZtGgRP//8M++99x7Tp0/n7bfftrhWRERERERE5G6XrwYfwMXFhUmTJhEcHMzkyZPp2rUrn3zyCU5O+Zvq8OHDXL16lWeffZbr168TERFBeno6FStWBKBRo0Zs376dxMREGjduDEDNmjX59ddfuXLlisW1IiIiIiIiIv+a0Qjpl+HqX39/JWd9v5aMd9wxSCwJmRmQmf7395t+Nmbgm5wEBz3BZPp7wr+/m7fBo3RzCA6+46gGk+mmWfNQtWpVJk6cSPv27c37tm7dyiuvvEJmZiYdOnTg66+/JjY21qIDHzlyhF9++YWuXbty4sQJnn/+eTw9PVm+fDkAS5cuJS4ujvPnz9OmTRuaNm0KQLNmzVi4cCEREREsWbLktrXr16/P9uHDnj17cHd3zzPbtWvXcHNzKzI19pTFWjX2lKUwa+wpi7Vq7ClLYdbYUxZr1dhTlsKssacs1qqxpyyFWWNPWaxVY09ZCrPGnrJYq8aeslirxp6yFGaNPWWxVo09ZbF6jasrjmnJOKck4JKSgPOVBJxT4nFJScDxyhmcMi7jmH4FA8Y85wIwGRwxOThlfRkcwcEJk8EJI4b/v+LdYMjq7/9xBfyZB/uQ+mDeT6RLTU2lTp06twlhoaCgINO3336bY/+JEydM7dq1MwUFBZmqVq1q6XSmtLQ009WrV83bHTt2NDVv3ty8/eWXX5pmzZplGj9+vGnVqlXm/Y0bNzZdvnzZ9Nhjj1lU+0+7d+++bbZDhw4VqRp7ymKtGnvKUpg19pTFWjX2lKUwa+wpi7Vq7ClLYdbYUxZr1dhTlsKssacs1qqxpyyFWWNPWaxVY09ZrFVjT1kKs8aeslirxp6y3FHN9XSTKW6XybT1I5NpQU/T1cm1TKZx5Uymtz2zf73nbzJ9+ojp8rRWJtOi3ibTyhdMptXDTaaN40ym6I9Npt1zTKYDS02moz+Yjm/+2mQ6FWMynd5jMsXvveXXH1uX5zpmit9rMiX8YtF7sqSXtfi6+kGDBhEUFJRjv7+/P4sXL2bkyJEcOHDA0ulYunQpR48eZfTo0Zw7d46rV6/i7u7OqVOn8PPzY+vWrQwaNIizZ8+yadMm2rVrx88//8yDDz5I8eLFcXZ2tqhWRERERERE7kEZ1yBhL5yIhpPREBcDGalZY54VyHTxAb+aUKJc1pdnOShRFpyzrvhOPH6C4gGV8jyEyekKODoX7PvIh3w1+Lnx8PBg6tSp+Trwk08+yYgRI+jRowcGg4Hx48fj4ODAq6++SmZmJo0aNaJGjRo89NBDREdH0717d0wmE+PHjwdgzJgxFteKiIiIiIjIPSDxCBxcQcWDq2FpLGRmLe6Od2V48FEoVwPKPgTupfjz+AkCAirZMKz15drgR0ZG0qZNG/NZ8MjIyNtOZjAYePHFFy06sIuLCx9++GGO/YsXL8627eDgwDvvvJOjrmbNmhbXioiIiIiIyF3qYjz8uhQOLIGzB8DggGMJf6jW4f8bejdPW6csFHk2+P7+/gXW4IuIiIiIiIj8K6lJcOibrKb+5DbABPcHQ/1BENicM+cu33Vn5y2Ra4O/YcMGvL29s22LiIiIiIiI2ERmBhxeRYUbdIWRAAAgAElEQVTombAkBowZULIihD0DgS3gvgo3FV+2WUxbyrXBL1++fJ7bIiIiIiIiIgXuSiLs+RJ2fwGXz1DM1QtCOsMDraDUAzkeOXcvy7XBX7ly5b+asGPHvJ/dJyIiIiIiInJb8Xth5wz4dRlkpkOFh6FBBHGZZQmoXNnW6exSrg3+8OHDMRgMmEwmiyczGAxq8EVEREREROTfycyA/Usg5nOI35X1yLqgdhDSCUr6Z9UcP2HTiPYs1wb/q6++KswcIiIiIiIicq+6dhF2zqDKtmlwLSnrfvoGEfBgW3DxsHW6IiPXBr9u3bqFmUNERERERETuNalJsGM6xHwGaZdIL/UQTs2HZV2Ob3CwdboiJ9cG/1ZSU1PZtm0bKSkp2S7dv379OikpKezYsYPp06dbPaSIiIiIiIjcRa4kwvZI2DUT0lOgUhOo3Ztzl50J8Ktk63RFlsUN/t69e/nvf//LlStXzPtuNPmGv1ct9PLysnI8ERERERERuWtcPgvRH2etiH89DQKbQ62nwPvvRfMun7BpvKLO4gZ/6tSpGI1GRo8ejclkYvTo0Xz66aekpqaycOFCDh48yMKFCwsyq4iIiIiIiBRFl89SZs8kWPodGK/DAy2hVq//XzhPrMLimxoOHjxIz549CQ8Pp0uXLjg5OeHg4ED79u2ZM2cOfn5+TJ06tSCzioiIiIiISFFizIQdn8EndfA6tiKrsQ//CpqPVHNfACxu8NPS0qhUqRIAzs7O+Pv7ExsbC4CLiwsdO3Zk3759BRJSREREREREipj4PTCzOawZBvdX43SD8dD0dfAsb+tkdy2LL9EvU6YM586dM2/7+flx5MgR83aJEiW4cOGCddOJiIiIiIhI0XI1GTa+C7u+APdS0Go0BDTl+omTtk5217P4DH6TJk2YP38+27ZtA6BWrVpER0cTFxfH9evXWbNmDWXKlCmwoCIiIiIiImLHTCY4sBQiw2D3bAjpDN3mQuVm8PfC7FKwLG7wX3jhBTw8POjXrx9//fUX4eHhuLm50bZtWx555BG2b9/Ok08+WZBZRURERERExA65XD4FX3WAZf2yztp3+gwaRICLh62j3VMsvkTfx8eH7777jg0bNpgfh7d48WI++eQTLl68SJMmTejevXuBBRURERERERE7kxwH2yMJ2PUFOLlAw6EQ3B4cHG2d7J5kcYO/a9cuAgMDadeunXmfr68vEyZMAODMmTN8++23/Oc//7F+ShEREREREbEf53+DrR/B/oWAiZSyDSjRYmjW2XuxGYsv0e/Tp4/5/vtb2bp1K2+99ZZVQomIiIiIiIgdSvgZFveByIfh1yVQrQN0/5rz1fupubcDuZ7Bj4uLY9q0aeZtk8nEokWLiI6OzlFrMpnYuXMnnp6eBZNSREREREREbMNkghNb4afJcGwDuBSHWr0g5EkoVjKrJvGETSNKllwbfD8/P/78809zQ28wGNi1axe7du3KUevg4IC3tzevvvpqwSUVERERERGRwmMywR+b8N8wCi4cgGJeULc/VPtPVpMvdifPe/C/+OIL889Vq1Zl4sSJtG/fvsBDiYiIiIiIiA2d3Jb1LPuT23BxKwUNh0BQO3BytXUyyYPFi+xt2LCBUqV0T4WIiIiIiMhd6/Qe2DQWjm3Muqe+4RDi3EIICKxi62RigVwb/Bur5nt7ewOQkJBAQkLCbSd8+OGHrZdORERERERECt7ZA7BpHBxZDW4l4ZGBWQvoObnB8RO2TicWyrXB7927d7ZL8nv37o3BYMh1IpPJhMFgIDY21vopRURERERExPoSj1J+2xsQ9/fieWH9IKQLuLjbOpn8C7k2+BMmTKBmzZrZtkVEREREROQukHYZNk2AmM8o7uAMtXpDaDdwLWHrZHIHcm3wO3XqlOe2iIiIiIiIFDEmExz6BtYMg8vnIPgJ4u5vjX9QqK2TiRVYvMjeDX/88QebN28mPj4eBwcHKlWqRIsWLShXrlxB5BMRERERERFrSPoDvn8Nfl8PpapAh7egTHWMusf+rmFxg280GhkzZgxLlizBaDRmG5swYQIDBgxg0KBBVg8oIiIiIiIid+B6GkRPhZ8+BIMD1B8E1TuCQ77P94qds/hf9PPPP2fRokW0b9+eZ555Bn9/f4xGI8ePH2fOnDl8+umnlC1blieffLIg84qIiIiIiIiF3M/tgnW9IOkYVG4O9V8Aj9K2jiUFxOIGf8mSJbRp04aJEydm2x8aGsqUKVO4evUqX375pRp8ERERERERW7vyJ6wdif+BJeBZAdpNhAp6pPndzsHSwqSkJOrVq5freJMmTYiLi7NKKBEREREREfkXjEbY8yVEhsHBlfxVuQM8+YWa+3uExQ3+Qw89xJYtW3Id37NnD8HBwVYJJSIiIiIiIvmUeATmPAbfDQGvAHjyC5IDO4GTq62TSSGxuMF/5513OHr0KIMHD+bAgQOkpqaSnp7OsWPHGDNmDBs2bGDQoEEkJCRk+xIREREREZEClHENNo6D6Q3hz0PQdBg8MQVKVrR1MilkFt+D/8QTT2Aymfjhhx9Yt25dtjGTyQTA888/n+N1sbGxdxhRREREREREbun4j/Dd0KxF9B5oBfVfhGJetk4lNmJxgz9gwAAMBkNBZhERERERERFLpCZRLuZdOLEKPH2h3SSoEGbrVGJjFjf4ERERBZlDREREREREbsdkgv2LYO1I7ruaDDV7Qu0+4ORm62RiByxu8CHrUvzTp0/j5+cHwPHjx1m8eDFOTk506dKFSpUqFURGERERERERSfoD/vcS/LEZ7q9OfOhQKoQ2tnUqsSMWN/hnz56lX79+uLi4sGLFCs6fP094eDiXLl0CICoqivnz51OtWrUCCysiIiIiInLPycyAbR/Dlg/AwREaDoXg9mSc1GPKJTuLV9GfPHkyZ86coUePHgAsXryYS5cu8dFHH7FhwwbKlSvHxx9/XGBBRURERERE7jlxO+HzxrDhHfCrC13nQvWOWY2+yD9YfAY/Ojqavn370q1bNwA2btxIuXLlaNu2LQDdunVj2rRpBZNSRERERETkHuKQfgX+9zLsng0epaHNOKjU0NaxxM5Z3OBfvnyZChUqAHDhwgUOHjxI165dzePFihXj+vXr1k8oIiIiIiJyrzCZIPZbKq9+CdL+gpDOENYPXNxtnUyKAIsbfF9fX44ePQrAqlWrAGjevLl5/KeffjJ/ACAiIiIiIiL5lBwH378GR1djLOEPj42D0lVtnUqKEIsb/CeeeIJp06Zx8uRJYmJiKFeuHI0bN+bUqVOMHz+eLVu2MHz48Hwd/MKFC3Tu3JnZs2fj5OTE8OHDMRgMVKlShbfffhsHBwciIyPZvHkzTk5OjBw5ktDQUE6ePGlxrYiIiIiIiF0zZkLM57DxXTAZ4ZGBJHiEEVA60NbJpIixeJG9QYMGERERQVxcHLVr12b69Ok4OTlx5coVdu/ezcCBA+nbt6/FB87IyGDUqFG4uWU9r3HChAkMHTqUr7/+GpPJxIYNGzh48CA7d+5kyZIlTJ48mTFjxuS7VkRERERExG4l/AwzW8DaEVD2Ieg6B0LDtYie/CsWn8EHGDhwIAMHDsy2Lzg4mO3bt+Ps7JyvA7///vt0796dGTNmAHDw4EHq1q0LQJMmTYiOjiYgIIBGjRphMBjw9fUlMzOTpKSkfNV6e3vnK5eIiIiIiEiBS7sCmyfAjmngVhJajoLKzcFgsHUyKcIMJpPJlJ8XHDt2jA0bNpCQkICzszPlypWjWbNmVK5c2eI5li9fztmzZ3nhhRfo3bs3o0ePpm/fvmzduhWA7du3s2zZMipXrkzJkiXp2bMnAL169WL8+PH06tXL4lp/f/9sx96zZw/u7nkvUHHt2jXzlQVFocaeslirxp6yFGaNPWWxVo09ZSnMGnvKYq0ae8pSmDX2lMVaNfaUpTBr7CmLtWrsKUth1thTFmvV2FMWa9XYU5bCrLFkDpcTm6h44COcU89xqXwz/qrSFaOzR7aatPQ0XF1c85ynsGrsKUth1hTWcUwGBy4Wq3jb/25SU1OpU6dOnjX5OoM/adIkZs+ejdFozLH/6aef5vXXX7donmXLlmEwGNi+fTuxsbEMGzaMpKQk83hKSgqenp4UL16clJSUbPtLlCiBg4ODxbW3EhwcnGe+2NjYIlVjT1msVWNPWQqzxp6yWKvGnrIUZo09ZbFWjT1lKcwae8pirRp7ylKYNfaUxVo19pSlMGvsKYu1auwpi7Vq7ClLYdbkOZ5yHla/Dr8uA69K0OpjPMuG4nmL0uPHTxAQUCnPLIVVY09ZCrOm0LIYHIlNdr7tf3t79uzJcxzycQ/+kiVLmDVrFk2aNGHRokXs3r2bnTt3snDhQpo3b86cOXNYsWKFRXPNnz+fqKgo5s2bR3BwMO+//z5NmjQhJiYGgB9//JGwsDBq167N1q1bMRqNJCQkYDQa8fb2plq1ahbXioiIiIiI2JTJBAeWwqd14dA3/FW5E3SeCWW1KLhYl8Vn8KOioqhXrx6fffZZtv01a9bk008/pW/fvkRFRdGpU6d/FWTYsGG89dZbTJ48mcqVK/Poo4/i6OhIWFgY4eHhGI1GRo0ale9aERERERERm7l0Bla9DEe+z3rkXbuJJF90wMsxf2uYiVjC4gb/+PHjDBs2LNfxNm3aMGnSpHwHmDdvnvnnqKioHOMRERFERERk2xcQEGBxrYiIiIiISKEzmWBfFKwdCdfToN4AeOhJcHCCiydsnU7uUhY3+B4eHiQmJuY6/ueff+LqmvfiAiIiIiIiIne95FPw7WD4Y1PWZfhNX4f7Ktg6ldwDLL4Hv1GjRkRFRXH48OEcY7GxsURFRdGwYUOrhhMRERERESkyjJl4/bYUpj0Cp3ZAwyHQ/iM191JoLD6D/9JLL7F161a6dOlCo0aNCAgIAOCPP/4gOjqaEiVKMHTo0AILKiIiIiIiYpdMJjj8P9g4lrKJh6F8GDR5BUqUs3UyucdY3OD7+vqyZMkSPvzwQ7Zs2cKWLVsAKFasGK1ateLVV1/Fz8+vwIKKiIiIiIjYFZMJfl8PG8fCmZ+hZEX+fOgF7n+kKxgMtk4n9yCLG3yAChUqMGXKFIxGI3/99Rcmkwlvb+9sz6UXERERERG56x3/ETa8C6d3Zp2pbzYcHmhFysnTau7FZvLV4N/g4OBAqVKlrJ1FRERERETErrmd/xXmDoPjW8CjNDR6GYIeAz32TuxArg1+nz598j2ZwWBg7ty5dxRIRERERETE7pz5BTaOI+C3tVDMC+q/CMH/ASc9SUzsR64N/s6dO2+532AwYDKZch0TERERERG5a/x5GDaPh0PfgGsJkh54Eu/Gz4Kzu62TieSQa4N/q8fhJSUl0aBBA+bMmUP9+vULNJiIiIiIiIjNXDgGW96H/YvBuRjU7guhXbkYfx5vNfdip/J1D77O0IuIiIiIyF0tOQ5+nAj7osDRCWp0hxrh4Fby74LzNo0nkpd/tcieiIiIiIjIXeXyWcrs/RD++Cbr8XfVOkCtXuCuxcWl6FCDLyIiIiIi9670VNj2MUR/hNf1NAhqB7V7Q/Eytk4mkm9q8EVERERE5N5jNMKBxbB+NFw+AwFNOe3bDr/q9WydTORfU4MvIiIiIiL3llM7YM0ISNgLpatC8xFQNpTrx0/YOpnIHcm1wV+5cmWOfSkpKQBER0dz7ty5W76uY8eOVoomIiIiIiJiRX+dgHVvw6GV4FEamo2EKq3A4GDrZCJWkWuDP3z48Byr5ptMJgBmzZp1yzGDwaAGX0RERERE7Mu1S5TePw2WLgKDAeo8DaHhWY+/E7mL5NrgT5gwoTBziIiIiIiIWJfJBL8ug7Uj8LnyJ1R5FOo+l3X2XuQulGuD36lTp8LMISIiIiIiYj0XjsGql+GPzVC6KvHVBlC+ZgtbpxIpUFpkT0RERERE7h4Z1yD6I/hpMjg6QcMhEPwf0k/G2TqZSIFTgy8iIiIiIneHY5tg1SuQdAwCW0D9F8G9lK1TiRQaNfgiIiIiIlKkOV69AEv7wa9LwbMCtJsEFcJsHUuk0KnBFxERERGRoslohD2zCfxhFGSmQ+2+ULMnOLnaOpmITajBFxERERGRoufcIfhuMJzeRbp3NYq1GgEl/WydSsSm1OCLiIiIiEjRkXEVfpwI0VPBxQOajeSsUxUC1NyL5N7gt2zZMt+TGQwG1q9ff0eBREREREREbumPLfC/oZD0Bzz4KDwyENxKwvETtk4mYhdybfB9fX1z7Dt06BApKSkEBQVRuXJljEYjcXFxHDp0CG9vbxo1alSgYUVERERE5B6UcgF+eBN++Ro8y8PjH0L5OrZOJWJ3cm3w582bl237+++/54033uCrr76ibt262cb27dtH//79CQkJKZiUIiIiIiJy7zGZ8DyxGr6LhGvJUPMpqN1bi+iJ5MLB0sKPPvqIPn365GjuAWrVqkXfvn2ZM2eOVcOJiIiIiMg96twhmNue8jFjoHhZ6DwT6j6n5l4kDxYvspeYmIi3t3eu4+7u7ly8eNEqoURERERE5B519S/YNAF2zQIXD85X7YNPo77g4GjrZCJ2z+Iz+EFBQSxdupTU1NQcY0lJScyfP58aNWpYNZyIiIiIiNwjjJmw50v4pA7smgnBT0D4PC77tVBzL2Ihi8/gDx48mP79+/PEE0/wxBNP4OfnR1paGidOnODbb78lIyODqVOnFmRWERERERG5G52KgdWvwZlfoGwotH0PfKr8PfiXTaOJFCUWN/gNGjRgxowZTJo0iRkzZpj3GwwGwsLCGD58ONWrVy+QkCIiIiIicvdxupoIy6fA/kXgURpavAWBLcBgsHU0kSLJ4gYfspr85cuXk5SURHx8PAaDgfLly+Pl5VVQ+URERERE5G6TeR1iPqPyxrFgvJ61On6tnuDsbutkIkVavhr8G7y9vfNccE9EREREROSWEvbBd0PgzC+k+YTi3mpY1rPtReSO5avBX7BgAd999x3nz58nMzMzx7jBYGD9+vVWCyciIiIiIneJtMuwaTzEfAbFvKDVaM7hT4CaexGrsbjBj4yMJDIykvvuu4+AgACcnZ0LMpeIiIiIiNwtDn8P378KlxKg2n/g4efAtQQcP2HrZCJ3FYsb/GXLllG3bl1mzZqFi4tLQWYSEREREZG7waUEWP06xH4H3pWhQySU0cLcIgXF4gb/woULvPDCC2ruRUREREQkb5kZeP22FFZ8BpkZ8PDzUCMcHP7VEmAiYiGL/8KqVKnC8ePHCzKLiIiIiIgUZekpsC8Ktn1C2YtxUD4MGr+kRfREConFDf7QoUN56aWXqFevHk2bNi3ITCIiIiIiUpSkJsHOGRDzOVxNgjIPcTagM2Uf7qhn2osUIosb/Llz5+Lu7s6AAQNwc3PDy8sLwz/+WLWKvoiIiIjIPSQ5DrZ/Cnu/hIyrULEB1OwBZR/i6vETau5FCpnFDX5aWhr+/v74+/tb5cCZmZm8+eabHD9+HEdHRyZMmIDJZGL48OEYDAaqVKnC22+/jYODA5GRkWzevBknJydGjhxJaGgoJ0+etLhWRERERESs6Nwhyu14B+LWASYIbAU1uoN3gK2TidzTLG7w582bZ9UDb9q0CYCFCxcSExNjbvCHDh1KvXr1GDVqFBs2bMDX15edO3eyZMkSzpw5Q0REBMuWLWPChAkW14qIiIiIyB0ymeDYxqwz9sc24OnoCtU6QmhXKF7G1ulEhHw0+JY4dOgQ1apVs6i2VatWNGvWDICEhAR8fHzYvHkzdevWBaBJkyZER0cTEBBAo0aNMBgM+Pr6kpmZSVJSEgcPHrS41tvb25pvU0RERETk3pFxDQ4szmrsEw+DeykI60dc8Vr4Pxhi63QichODyWQyWVKYkZHBjBkz+OGHH0hNTcVoNJrHMjMzSUlJ4cqVK8TGxuYrwLBhw1i3bh0ff/wxw4cPZ+vWrQBs376dZcuWUblyZUqWLEnPnj0B6NWrF+PHj6dXr14W1958W8GePXtwd3fPM9O1a9dwc3MrMjX2lMVaNfaUpTBr7CmLtWrsKUth1thTFmvV2FOWwqyxpyzWqrGnLIVZY09ZrFVjT1kKs8aeslirxp6y3KjxIBWv35fh9fsynNKSSStRkUsVH+VK2brg4ExaehquLq65znG78bu1xp6yWKvGnrIUZk1hHcdkcOBisYq3/btMTU2lTp06edZYfAb/o48+4osvvqBs2bJ4enpy9OhRwsLCSExMJD4+Hjc3N9544w1LpzN7//33efXVV+nWrRtpaWnm/SkpKXh6elK8eHFSUlKy7S9RogQODg4W1/5TcHBwnpliY2OLVI09ZbFWjT1lKcwae8pirRp7ylKYNfaUxVo19pSlMGvsKYu1auwpS2HW2FMWa9XYU5bCrLGnLNaqsacs/HmY5NUfUvLUD5CZBhXrQ2g3XMvVpLTBQOm/y44fP0FAQKVcp7nd+N1aY09ZrFVjT1kKs6bQshgciU12vu3f7p49e/IcB3C4bcXf1qxZQ926ddm4cSMzZ84EYNSoUaxdu5bPP/+c69ev4+zsbOl0rFy5ks8//xyAYsWKYTAYCAkJISYmBoAff/yRsLAwateuzdatWzEajSQkJGA0GvH29qZatWoW14qIiIiIyG1cPA0rX4Bpj+B5ci0EtYVuX0HbCeBbSyviixQBFp/BP3fuHM888wwODg6UKVOGUqVKsW/fPh588EGaNm1Kp06dWLx4MeHh4RbN16ZNG0aMGEGvXr24fv06I0eOJDAwkLfeeovJkydTuXJlHn30URwdHQkLCyM8PByj0cioUaOArEv7La0VEREREZFcXLsIW6fAjulgzITQbsR5NcI/6CFbJxORfLK4wXdzc8t2hr5ixYocPXrUvB0aGsratWstPrC7uztTp07NsT8qKirHvoiICCIiIrLtCwgIsLhWRERERET+4Xo67P4CtnwAV5PggdbwcD8oURbj8RO2Tici/4LFl+gHBwfz448/mrcrV67Mvn37zNvnzp3DoMt2RERERETsm8kEvy6DTx+GNcOznl3feSa0eANKlLV1OhG5AxY3+L169WLDhg307NmTK1eu8Pjjj3Po0CFGjBjBzJkz+fLLL3noIV3GIyIiIiJit05spdL6Z2Hps2BwhMc+gHaTwKeKrZOJiBVYfIl+27Zteffdd5kzZw7FihWjQYMGPP/88+YF93x9fRkxYkSBBRURERERkX/pz1hY/zYcXYuzmzc0G551Sb6Do62TiYgVWdzgA3Tt2pWuXbuat1955RV69OjBxYsXCQwMxMXFxeoBRURERETkX7p0BjaPh31R4FwM6vbndPEwKj3woK2TiUgByFeDfyu+vr74+vpaI4uIiIiIiFjDtUuw7WPY9gkYr0P1zlD7KXAriUkL6Incte64wRcRERERETthvA47Z8Lm9yD1PAS2gIefA0+dkBO5F6jBFxEREREp6kwmOPw/Kq8eDldOQ7ma0GYs3F/V1slEpBCpwRcRERERKcoS9sHakXByGwaP8tB2Avg9AnqEtcg9Rw2+iIiIiEhRdDEeNr4LvywANy9o9DLxrtUJqBho62QiYiN31OBnZGQQHR2Ng4MDDRo0wMlJnxeIiIiIiBSotCtZC+hFTwVjJtToAbWeAhcP0AJ6Ivc0izvy9PR0xo4dy+nTp5k9ezbp6emEh4dz+PBhAAIDA5k7dy6lSpUqsLAiIiIiIvcsY2bW4+42vANXzkHl5lC3P3iWs3UyEbETDpYWRkZGsnjxYsqVy/ofyMqVK4mNjaV3796MHz+exMREpk6dWmBBRURERETuSSYT/L6BgHVPwzcvgnsp6PAptHpbzb2IZGPxGfzVq1fz5JNPMnbsWADWrl1LiRIleP3113FyciIuLo4lS5YUWFARERERkXvO8R9h4ziI24GjWylo8VbWo++0gJ6I3ILFDf7Zs2epWbMmAFevXmXXrl00a9bMfN99uXLluHTpUsGkFBERERG5l5zaARvHwomfwN0HGg7ltFt1AgKr2DqZiNgxixt8Hx8fzp8/D8BPP/1Eeno6zZo1M48fOXKE+++/3+oBRURERETuGaf3wKaxcGwjFPOG+oMguD04uWoBPRG5LYsb/Hr16jF37lxcXV2ZP38+xYoVo1WrVly6dIlly5axePFiunfvXpBZRURERETuSq5/HYGv34aja8HtPqg3AKp1AOdito4mIkWIxQ3+yJEjOXfuHO+//z7u7u6MHTsWT09P9uzZw/vvv8/DDz/MoEGDCjKriIiIiMjd5dIZWD+ayvsXgqsnPPwcVO8MLu62TiYiRZDFDb6npydz5swhKSmJ4sWL4+LiAkBwcDCLFi2iRo0aBRZSREREROSucj0NdkyHHz+A6+kkV3qCks0GgEtxWycTkSLM4gb/Bm9v72zb7u7uau5FRERERCz12zpYPQySjoF/Q6j/An9dyKCkmnsRuUP5avA3bNjAunXrSExMJCMjI8e4wWBg7ty5VgsnIiIiInLXuHAM1o7Ius/+Pj947H3wq/f32AmbRhORu4PFDf7ChQsZM2YMkHUW39XVtcBCiYiIiIjcNdKuUHr/NDi6EBycshbQC+kCjs62TiYidxmLG/w5c+ZQpUoVPvvsM3x9fQsyk4iIiIhI0Xf1L9gzF3ZMw+fKOajyKNTrD+6lbJ1MRO5SFjf4CQkJjBgxQs29iIiIiEheLhzLWkDv5/mQkQq+tUgIfh7fWq1snUxE7nIWN/j+/v4kJSUVZBYRERERkaLJZIITW2HHp3BkDTg4wgMtIeRJ8KlC2vETtk4oIvcAixv8AQMGMHbsWFq1akXVqlULMpOIiIiISNFwPZ37jn8Pm5+HcwfArSTU7g3VOuhSfBEpdLk2+H369MmxLy0tjc6dO1OpUiVKlSqFwWDINq5V9EVERETknpByAXbPhp0z8E35E7wqQeNXoUprcG6+qSgAACAASURBVNJi1CJiG7k2+KdPn86xz8vLC4Br164RHx9fcKlEREREROxR4hHYMQ1+WQDX06DCw5x9sDdlw56Af5z8EhEpbLk2+Bs3bizMHCIiIiIi9slkgmMbsxr739eDo0vWmfqQJ8E7gKvHT6i5FxG74GBp4YgRI/jll19yHd+xYwf9+/e3SigREREREZvLuEbJY9/AtEcgqjPE74WwZ6HnYmjyGngH2DqhiEg2Fi+yt2LFCho2bEiNGjVuOR4TE8OOHTusFkxERERExCYyr2c94m7TOMpdOQfegdBsOAS2yDp7LyJip3Jt8OPi4njiiSdIT08373vttdd47bXXcp3soYcesm46EREREZHCYjLB0bWwflTWvfZlqnPmwb6Uq/OYLsEXkSIh1wbfz8+PUaNGsXv3bkwmEytXrqROnTr4+fnlqHVwcMDb25sePXoUaFgRERERkQIRvxfWvZX1LPv7KkDrd6BSY66dOKnmXkSKjDwv0e/SpQtdunQBID4+nhdeeIH69esXSjARERERkQL31wnY8C78uhTcvKDhEAhuDw4W38kqImI3LP4/17x5825bk5mZiaOj4x0FEhEREREpcKlJ3L9vKhxblnWGvtZTUKMHuHjYOpmIyL+Wr48md+/ezdq1a0lNTcVoNJr3Z2ZmkpKSwp49e7TQnoiIiIjYr2sXYcd02B6Jd9oVCHoMwp4Bj9K2TiYicscsbvCXLVvGm2++iclkAsBgMJh/BnBxcaFZs2ZWDygiIiIicsfSrsDOzyH6Y7iWDJUaE1/uUSo81MjWyURErMbiBv+rr77Cz8+Pzz//nIyMDP7zn/+wZcsWDAYDc+fOZc6cOfTs2bMgs4qIiIiI5E/GVdg1C7Z+BKnnoeIjWc+y93mQjOMnbJ1ORP6PvTuPbqs+E///vvdKsuTdkrfIjuM9GzshIRBoGWhoodBlUvqDtPRQOr+Wlkw5HZhAKUzbaWl7yBfKF7oNlBm2Fmj5hQkFCjSE0oQsJJA9zuLYjmN5l1fJ1nbv74+reImXyCDbcvK8ztGRdO+jex9dO44efTYRVzEX+LW1tdx+++2UlJQAkJKSwvvvv89nP/tZ7rrrLg4dOsR//dd/cfHFF09askIIIYQQQsRCiQRh63/BP9ZAbzMUXAif+hHkLZzu1IQQYtKoMQeqKllZWQPP58yZQ1VV1cDzK664gkOHDsU3OyGEEEIIISYiEoLt/03Zqyvg9bsgNQ+uewSu/T9S3AshTnsxt+AXFRUNK+CLi4s5cODAwPNwOIzP54tvdkIIIYQQQsQiEoY9L8I7P4fOOiIZZViv+Hez5V7WsRdCnCFibsG/5ppr+MMf/sDDDz9MIBDg0ksvZevWraxdu5bdu3fz3HPPDXTfF0IIIYQQYkroOuz5M/xqMbx8G1hs8Omf0XjRD6BwkRT3QogzSswt+LfeeiuHDx/m8ccf51vf+haf+9znePnll7nnnntQFAVN03j00UcnM1chhBBCCCFMhgEHXoENP4XWKnCWwqf+E4qXmUW9TKAnhDgDxVzgWywW1qxZw913343D4QDgySef5NVXX6Wzs5NLL72UioqKmI4VCoX4/ve/T0NDA8FgkNtuu43y8nLuvvtuFEWhoqKC//iP/0BVVR577DHeeecdLBYL3//+9znnnHOoq6uLOVYIIYQQQpxGDINUz0b4+/8LTbshswj+6T4ouwKUmDunCiHEaSnmAv+E7OxsdF3H6/WSnp7O5z//+QmfdN26dWRmZvLggw/S0dHBF77wBebNm8cdd9zBkiVLuP/++1m/fj1ut5tt27bxpz/9icbGRlatWsVLL73Ez372s5hjhRBCCCHEaSAShv0vw6ZfMrtpD6TNgk/eDeVXgTrhj7RCCHFamtBfw7q6OtasWcPGjRsJBAL8/ve/B+Chhx5i9erVLFq0KKbjfPrTn+bqq68eeK5pGvv27WPx4sUAXH755WzatImSkhKWLVuGoii43W4ikQher3dCsU6ncyJvUQghhBBCJJKgH3Y+B+89Cp11kFlE64JbyLlkpRT2QghxEsUwDCOWwNraWm644QYURWHJkiW89dZbPPnkk2iaxm233UYoFOLpp5/mvPPOi/nkvb293Hbbbdxwww384he/YOPGjQBs3ryZl156idLSUjIzM7npppsAWLlyJQ888AArV66MOXbOnDnDzrljxw6Sk5PHzau/vx+73T5jYhIpl3jFJFIuUxmTSLnEKyaRcpnKmETKJV4xiZTLVMYkUi7xikmkXKYyJpFyiVdMIuUS75gUJUDWkT+TdehFLMEu+jPK6Cq+Bn/O+QRCIZJsSeMeIxAMzKiYRMolXjGJlMtUxiRSLvGKSaRcpjJmqs5jKCpdjqJT/m30+/1ceOGF48bE/LXnQw89hN1uZ+3atSiKwptvvgnA4sWLee2117jxxht57LHHeOKJJ2I6XmNjI9/5zne46aabuO6663jwwQcH9vl8PtLT00lNTR229J7P5yMtLQ1VVWOOHc38+fPHze3AgQMzKiaRcolXTCLlMpUxiZRLvGISKZepjEmkXOIVk0i5TGVMIuUSr5hEymUqYxIpl3jFJFIucYvprMf76sM4a9dBqA+KLoZzb8Sefw726Iz4NTW1lJQUj3uemRaTSLnEKyaRcpnKmETKJV4xiZTLVMZMWS6KxoFO6yn/fu7YsWPc/TCBZfK2bNnCjTfeiMvlQjlpuZG8vDxuuukm9u7dG9Ox2tra+PrXv85dd93FihUrAFiwYAFbt24F4N1332XRokVccMEFbNy4EV3X8Xg86LqO0+mcUKwQQgghhJgBeprhL9+D/3seWUf+DMWXwYon4dM/h1nnynJ3QggRg5hb8IPBIOnp6WPut1qtBAKBmI7129/+lu7ubn7961/z61//GoB7772Xn/zkJzz00EOUlpZy9dVXo2kaixYt4stf/jK6rnP//fcDsHr1au67776YYoUQQgghRALr74b3/i9sfgwiQZj3Weqdl1O0YPxuqEIIIUaKucCfN28eb7/9NitXrhyxLxwOs27dOubOnRvTsX7wgx/wgx/8YMT2Z599dsS2VatWsWrVqmHbSkpKYo4VQgghhBAJKByA938P/1gD/nYovQIuuhUyConIGvZCCPGRxFzgf/Ob3+Tb3/42d955J1deeSUADQ0NrF+/nt///vfs37+fX/7yl5OWqBBCCCGEOA3oEdj1PLz9E+iqh4IL4eoHICe2hiIhhBBji7nAv+KKK/jpT3/KAw88wKuvvgrAfffdh2EYJCUlsXr16mFL3wkhhBBCCDFA1+HIW5S8+X3oOgLZlXDNGiiMbZllIYQQpzahxUO/+MUvsnz5cjZt2kR9fT26rlNQUMAll1xCVlbWZOUohBBCCCFmqr4O2PkHszu+txrNkQv/dB+UXQFKzPM9CyFEQukJ6DT1RtjTplBt9OML6fSFDHwhg76wgS8YvQ/ptHdpJFd5MQyIGKAboBtG9B50FK4ozeAUk+jHZEIFPkBqaqq01AshhBBCiPE1fGAW9Xv/DOF+yDsLrvg+x9VSSsrKpzs7IYQYU19I53h3hO3NCpt9Ppp6IzT2Rmjq0fH0RmjqjeALGdFoK+AdcQyrCnaLgsMCqqFg6wmiAKpiLgqiKuaSduZjhaBujDjGRxFTgb9hwwb+8Y9/UFVVRWdnJ4qi4HQ6mTdvHldeeSUXX3xxXJIRQgghhBAzlxLuhw+fhfefAM+HYHFAxadgwefAFS3qZQI9IcQ00w2Dxt4IO9sU3u/zU98Vpr47wrHofatfj0ZagS5UBZx2hexkFXeKwjk5VnKSFbIdKrrPS2F+Ng4LOCwKdouCXQOrNri0p8fjwe12j5mPqmoEralxeW/jFvhHjx7lu9/9LkeOHMEwDBwOB+np6YTDYY4dO8b777/Ps88+y8KFC1mzZg3FxcVxSUoIIYQQQswQhgENO2DPn6j44DkI9UDmHLjkX6FyOdji86FVCCEmKhQxqOsKc6QjTLU3zBFvmMPeMNUdYfrCBmYB34mqQE6ywqwUlQvzNPJTrcxKUdH62lkwJxenXUFTlVHP4fFEcDu1KX1f4xmzwG9qauLGG28kEAjwr//6r1x33XUUFhYO7Nd1nSNHjvD666/z1FNP8ZWvfIW1a9eSk5MzJYkLIYQQQohpYhjQtAf2vgT7/j/oPAaqlb6c80i9aCXMOtfsdyqEEFOgP2xQ3RHmiDdEdUeYw+1h9jdb8PgbCemDcbnJCrPTVT5daqUoXSUp0MFZc3LISVawjFLAezw6Ockza66QMQv83/72twQCAZ5//nnmzZs3Yr+qqlRWVlJZWcm1117Ll770JZ544gnuueeeSU1YCCGEEEJMk5Yqs6Df82fwVoOiQeGFcO6NULyMVk87qe7i6c5SCHGa6g8bVLWF2HRMpauha6BF/nh3hBMj2FUF3KkqOUk6S2fbKUpXKUrXmJ2ukmwdXsR7PBFmpc6sAv5UxizwN27cyIoVK0Yt7k9WXl7O5z//ebZu3RrX5IQQQgghxDTztcPOZynZ9hR0VQMKuM+Hy/4NSi4De+aQ4PbpylIIcZoJhA2q2kPsaQmxpznEnpYgh7xhwjqABZvqoyBNpSxT5YqipGghr1KQpmLTlOi4d+d0v40pN2aB39raSkVFRcwHmjt3Lq+99lpckhJCCCGEENPIMOD4dnOyvH1rIRKAjHJzXH3pJyDZNd0ZCiFOI4GwwSFviN3NId6r1qjd0sqh9tBA9/p0m0KFU2XFXBuVTo3UYBvnlOSPOS7+TDZmgR8IBEhOTo75QMnJyXR3d8clKSGEEEIIMQ2CPrP7/ftPQNNusCbDvGtgwedo7ISSkuJpTlAIMdMFIwaHoi3zu6Ot8weHFPMpFpW5Lp1/nmujwqlRmaWRl6KgKENnpTekuB9DTMvkCSGEEEKI05etuxZefwp2PgeBbnCWwbLvQcVVZpEP0Fk7nSkKIWaohp4w2z1BdjQG2Vpn4WjP4MR3qTaFiiyVL861UZGlUenU0LuaKCgYe0k5Mb5xC3xFZj8VQgghhDg9RcJw8FV4/wnKat4F1QKlnzTXrM87S2bBF0JMWFg3ONAWYrsnyPZGs6hv6jWreYcFilN0vlBpp9KpUZGlMStVGVFzeqRT+McyboF/1113cdddd01VLkIIIYQQYrJ1N8IHT8OOJ6GnCVLz8JavwLl0JTiypjs7IcQM0uqPsLMpxM6mIJtqLBx8vSm6vry5JN2CbI1/rrSxMFujNFOluanxjJz4biqNWeBfdNFFU5mHEEIIIYSYLIYBtf8wx9ZXvQp6GGYvNifNm72Errp6nFLcCyHG0R822Nca4sOmIDubguxsCnG8JwKApkBhisHyEgsLsy0szNbITTm9lp+bKcYs8J955pmpzEMIIYQQQsRbXydZh16E9X+BtkOQlA5n/TMsuB7SC6Y7OyFEgjIMg5rOiFnIN5tj56t7GqNL1EFessJcl8Y1ZUnMd2mUZ2l4Wxpxu+WLwukmk+wJIYQQQpxOImE4ugF2/gGqXiU/EoDc+fDJu6H0CrAkTXeGQogE0xWEDbX97GwK8mFTiF3NQboCZlf7E2PnV8y1M8+lMc+l4XJI63yikgJfCCGEEOJ00FIFu/4Au56H3maztX7etTSknkPBuZ+c7uyEEAkiGDEnwtvZZHa3/7ApSF2XDfCiACWZKpcUWJjn0pjv0ihKl7HzM4kU+EIIIYQQM5Qa6IJtj5ut9Z4PzJnwZy+BpbdD0cWgWQnW1E53mkKIaWIYBo1+2HOoL9o6H2Rfa4igOXQep11hvktjcVaAxSVZVDo1kq2ygsZMJgW+EEIIIcRMEglD9XrY+RwVVa+BHgJXOSz9DpRfJTPhC3EG6w7o7G4OsbM5yIeNQT5sDuHtswEd2DSozNK4vtw20Dqfk2wuU+fxdOLOk9LwdDDmT/Gdd97hrLPOIjs7eyrzEUIIIYQQo2neZ7bU734RfC1gz6Sn8AoyFn0JsiumOzshxBQL6wZHuhTe2+OLdrUPcbQjjBHdPztN5cI8jVkWPxeXuijJVLGo0jp/uhuzwL/zzju5++67WbFiBQA333wzt912G0uXLp2y5IQQQgghzmRaoBO2/g52PgeNu8wu+EVL4VJzeTvvsQYysounO00hxBRo7ImYS9Q1m8X83pYQfWEr0EV6ktnVfllBEvNcGnNdGmk2s5j3eDpwO7XpTV5MmTELfMMw2LFjB9deey0Oh4Nt27Zxww03TGVuQgghhBBnnkgIDr9ldsE/+FcwwpBdCZesgrIrwZE53RkKISaZL6izs03hr+097GwOsbMpSLPPXKPOqkJZlsbVpVby1W6WlmUzK9Xsai/EmAX+8uXLWbt2LS+//PLAtrvuuou77rprzIMpisL+/fvjm6EQQgghxJmgac9gF3x/Gziy6J59JRkX3QCusunOTggxSSK6wZGOMB82BtnZbM5sf9gbRjesQA/uVJWF2Sr/PNfKfJeF0kwVm3aidd6LO02WrBODxizwf/SjH7Fw4UIOHTpEMBjkf//3f7nwwguZPXv2VOYnhBBCCHH66m2FPX8yl7dr2gOqFeYshcpPw+zFeOuOk+Eqnu4shRBx1O6PsLFR4UVPNzubg+xqDuEPmSPn02wKc50qNy2wkat0cUlFDhlJUsCL2I1Z4NtsNr7yla8MPH/55Zf58pe/zHXXXTcliQkhhBBCnJZCfXD4LQo3PQ6N74Eehpx5cOl3oeyfwJ4x3RkKIeKozR9ha0OQLccDbGkwW+fBiqb0UpapcuUcC/Ojs9oXpKkDXe09Hq8U92LCYl4LoaqqauBxW1sbHo8Hq9VKXl4eTqdzUpITQgghhDgtBP1w5C3Y9zIc+iuE/DhsGXDWCqi8Gpwl052hECJOvP2w91AfWxsCbD4epLojDIDDAguzNb5+ThKzlA6WVuSRZJFx8yK+JrTY4d69e/nP//xPdu/ePWz7ueeey7333svZZ58d1+SEEEIIIWasQC8cfhP2/y8cfsNsubdnQvmVUPIJ6gNZlJTJ2HohZjLdMDjiDbO9Mch2T5DtjUGOdZnrzidbYWG2hSvOTeKcXI2KLG1gmTqPR5fiXkyKmAv8gwcP8tWvfhWAG264gbKyMnRd5+jRo7zyyivcfPPNvPjii1RUyDqsQgghhDhDBXrg0BsUbHkGXtoC4X5wOKFiOZR+EvLPNpe6A6ipncZEhRAfRX/YYGebwmttPWxvDPJBY5CugDl+PjNJYWG2xlJngMvKnZRnqWiy7ryYYjEX+L/85S9JSUnhhRdeoKCgYNi+b3/726xYsYLHHnuMRx55JO5JCiGEEEIkrP4uOPhX2P8yHFkPkQDJSZkw9zNmUZ93FqiyBrUQM00oYnCwPczuliB7mkPsbglxsD1EWDdnty9KV1laYGFhtsZZORoFqeb4eY+nE7dL/s2L6RFzgb99+3ZuueWWEcU9QH5+PjfeeCPPPPNMXJMTQgghhEhIfZ1w8HXYvxaqN0AkCCk5MP+zUPoJ6v2plJSWTneWQogYhXWzq/2GepXGuk52NYc40BYiGDH3p9oUKrNUVsy1ka92cVllDukyAZ5IQDEX+MFgkJSUlDH3p6am0t/fH5ekhBBCCCESTqAXDrzC7K1Pw5/eBz0Eqbmw4HNmS33ufFCiH/il+70QCcsf0jnQFmZ/a4h90dvB9hPFvAWHxU9Flsb15TbmujQqszRmpSrDZreX4l4kqpgL/Pnz5/OXv/yFlStXYrEMf1koFOKVV16hsrIy7gkKIYQQQkwbPQJHN8CuF6DqFQj1kWTPhrO+CKWfgJz5oMgYWyESlS+os6clxK7mEFtrNGr/0UxNZwQjuj/NplCWqXJ9uY2yLJXMcDsXlOWjyr9rMUPFXOB/4xvf4Pbbb+crX/kKt9xyC8XFxQAcPXqU//mf/2Hfvn08/PDDk5WnEEIIIcTUadoDu56HPX+C3mZISoPyq6BiOcf9qZSUyrJ2QiSaiG5w2BtmZ1OQnc0hdjYFOeQNo0ereVeSwtxshWWFSZRlqpRnaeQkD7bMA3g8hhT3YkaLucC/6qqruO+++1izZg133HHHwHbDMEhKSmL16tV8+tOfnpQkhRBCCCEmXXcjzqrn4J23oXmfOdv97CVw8beh6GKwJJlx0v1eiGlnGAYNPRF2N4fY1RxkS62Fw6834Q+b1XyaTWGuU+WmBTbmuTTmOjX83ibc7sxpzlyIyRVzgQ+wcuVKrr32WjZv3szx48cxDIPCwkIuueQSMjPlH4sQQgghZpigDw78BXb9EWr+Tp6hQ+4CuPS7UHaFuW69EGLaefsi7Go2u9rvbjZb6L19OgBWFWanGCwvsZrFvEsdmNF+KP90JC7EFJtQgQ+QmZnJZz7zmcnIRQghhBBi8ukRqHnX7IJ/YB2E/JA2C85bSb1jIbPPuni6MxTijOYL6uxtDUUL+iA7jltp6msGQAHmZKgsyteY57RR6dIozVBpbW7E7c6a3sSFSAATLvCFEEIIIWaipM4j8OYfYM+L0NMEtlQo+yeoWA75Z4GiEpbu90JMqZAOe1qC7GwKsTt6X90xOG4+L0WhKCXMdZWpzHVpVGRpJFtljLwQY5ECXwghhBCnr55mc6K8Xc9T2rwHVA0Kl8CSb0HR0sFx9UKISWcYBp7eCB82hviwKciHTUH2tFgJ6W0AZCQpVDo1Vi6ILk/n1Miyq3g8Htxu1zRnL8TMIAW+EEIIIU4vQT9UvQq7n4fqt8HQIWce7XNX4lr8JXDIuHohpkJ/GLY1BPiwySzoP2gM0uI3x83bNKjM0rjSHWJRUQaVTo38FGXEuHkhxMTEXODruo6qqpOZixBCCCHER6PrJDdvh4OPwv6XzcnzUvPg3Jug8lOQOYfumlpcUtwLMSlCEYOD7WF2twQHZrY/2G5FN9oBcKeqnJ2jMc9lY362OW7eqil4PF243dZpzl6I00fMBf7111/Pl770Jb72ta/F7eS7du1izZo1PPPMM9TV1XH33XejKAoVFRX8x3/8B6qq8thjj/HOO+9gsVj4/ve/zznnnDOhWCGEEEKcxlqqzJb63S8wp9sD1mQo/aQ5rn7WOaBI44QQ8aYbBkc7wvytXqXpWBe7moPsbw0RiJj702wKFVkq1xaGuKg4g/kujUy7/FsUYirEXODX1dXhcDjiduLHH3+cdevWDRzzZz/7GXfccQdLlizh/vvvZ/369bjdbrZt28af/vQnGhsbWbVqFS+99NKEYoUQQghxmultgT1/Ngv7xl2gaFB4ES1zPkfuRZ+XcfVCxJFhGByPrje/uznIruYQe1pC+EIGYMFh8VGepfHZchtzneZ687NSza720jovxNSLucBftmwZf/3rX7nmmmtITU392CcuKiri0Ucf5d///d8B2LdvH4sXLwbg8ssvZ9OmTZSUlLBs2TIURcHtdhOJRPB6vROKdTqdHztXIYQQQkwvJdwfLepfgCPrwYhA9lxYers5E36yE19NrRT3QnxMLb4Ie1pC/P2gxrHd7exqDtHRb46bt6hQlqnxT3MsVDo1nBEvF5bloakybl6IRKEYhmHEEvjII4/w1FNPYbFYOOecc3C5XCPG5CuKwgMPPBDzyY8fP873vvc9XnzxRZYtW8bGjRsB2Lx5My+99BKlpaVkZmZy0003AbBy5UoeeOABVq5cGXPsnDlzhp1zx44dJCcnj5tXf38/drt9xsQkUi7xikmkXKYyJpFyiVdMIuUylTGJlEu8YhIpl6mMSaRc4hWTSLmMG6NHSG79gIy6N0mrX48W9hO2O+nNX0rvrEsIpRYMCw8EAyTZxi7wT7V/JsYkUi5TGZNIucQrZjpy6Q3BwU6Fqk6Fg50qVZ0Krf1msa5gUJCiU5KqU5IWoTRNpzBFxzrk438oGMRqs415nlPtP11jEimXeMUkUi5TGTNV51FUlbS88lP+f+n3+7nwwgvHjYm5Bf83v/nNwOMTxfWIxCZY4A819MsCn89Heno6qamp+Hy+YdvT0tImFDua+fPnj5vLgQMHZlRMIuUSr5hEymUqYxIpl3jFJFIuUxmTSLnEKyaRcpnKmETKJV4xiZTLiBjDgIYPzKXt9r1kdse3JtOTewFpF/wzllnnkqmojDZVXk1NLSUlxWOe51T7Z2JMIuUylTGJlEu8Yib7PH0hnX2tIXY1h3jvaAfVvTZquyID+92pKgtz1YFu9imBFkpnu8c9l7l83dgxp9p/usYkUi7xikmkXKYyZqrOo6oaQav9lP9f7tixY9z9MIECv6qqKtbQj2TBggVs3bqVJUuW8O6773LxxRdTVFTEgw8+yK233kpTUxO6ruN0OicUK4QQQogZoPWgWdTv+TN01IBqhaKL4eJvQ9FS2uobSXMXT3eWQswIwYjBwXazmD8xo/1hbxg92m83y6awIEfhiqIk5ro0KrI00pOGd7P3eKYhcSHExxZzgT+Urut4vV7S09OxnaI7QqxWr17Nfffdx0MPPURpaSlXX301mqaxaNEivvzlL6PrOvfff/+EY4UQQgiRoNqOwIF1lGx/DrqOmDPeuy+Ac26A4mWQNHpPPCHEoIhuzmi/q8WcBG/bMQtHexoJRhvn020KlU6VG+fbqHSZrfOBjibcblkyUojT0YQK/Lq6OtasWcPGjRvp7+/nySefBOChhx5i9erVLFq0aEInLyws5MUXXwSgpKSEZ599dkTMqlWrWLVq1bBtE4kVQgghRIIwDHPW+6q/wIFXoDXaOzCjDC75Vyj9BCS7pjdHIRKYYcCxrnC0Zd5cb35Pawh/yGyad1hgTorB5ypsVEa72uenmDPaD+XpmI7shRBTIeYCv7a2lhtuuAFFUbjssst46623ANA0jaNHj/L1r3+dp59+mvPOO2/SkhVCCCHEDKNHoHbTYFHfVW+21OefA5esguJlNLb2nXJcsRBnohZfZKCY39UcYmejle5QCwBWFcoyVa4qdlwiQwAAIABJREFUtgyMmy9MU2luasTtzprmzIUQ0yXmAv+hhx7Cbrezdu1aFEXhzTffBGDx4sW89tpr3HjjjTz22GM88cQTk5asEEIIIWaAQA9Ub4DDb1Cx/y8Q6DTH1BcugnNvhDmXgGNI9+DW2mlLVYhE0R2Ed+v62d0SGijqm33m8nSaAnMyVM5zhTm/MI1Kp0ZJhopVk+XphBDDxVzgb9myhVtuuQWXy0VHx/B+PXl5edx0001S3AshhBBnIsOAtsNw+E04/AbUbQY9BLYU+rMWknrWZ2D2ErCNv0ytEGcKf0hnb0t0ArwWcxK8Y102wAtAQZrKwmyVL1ZaqXRqlGdp2C0KHk83brcMYxFCjC3mAj8YDJKenj7mfqvVSiAQiEtSQgghhEhwoX5SGjdDzZNmYd9Ra27PKoGzV5gFff5ZtNYdJ7WkeBoTFWJ6BcIGVe0hNtSqNFR3sKspxJGOwRntc5MVKp0aS7ICLCrOotKpkWqTlnkhxEcTc4E/b9483n77bVauXDliXzgcZt26dcydOzeuyQkhhBAigfjazRb6qleh+m2KQn6wJJkz3y/8glnUp+VPd5ZCTJuIbnCkIzxs3HxVW4iQDmAhI6mfSqfGTQts5rh5l0aWXQXA4+nEnf+RFrgSQogBMf8V+eY3v8m3v/1t7rzzTq688koAGhoaWL9+Pb///e/Zv38/v/zlLyctUSGEEEJMg/ZqOPiaWdTXbwVDh5QcqPgUTUll5J9/tVnkC3GGCesGNR1h9reF2HhYo3ZHG/taQvjDZtN8shUqszS+UGnOaJ8ZbuOckvwRM9oLIUQ8xVzgX3HFFfz0pz/lgQce4NVXXwXgvvvuwzAMkpKSWL16NVdfffWkJSqEEEKIKaBH4Ph2cnY9A+u3Qtshc7uzDM7/Csy5FLIrQVHoq6mV4l6cEbr6dQ60haK3MPtbQxz2hghE15q3qirlWRGWl1ipdKrMdZkz2qtDinmPx5DiXggx6SbUD+iLX/wiy5cvZ9OmTdTX16PrOgUFBVxyySVkZclyHEIIIcSM1N8N1evh0BvmeHp/Oy5FA/d55lJ2cy6BtFnTnaUQk84wDFp8OntbQ+xpCZkT4TVZaelrGojJTFIozVS5rtxGaaZKaaaG1ddMUaF7GjMXQgjThAf6pKamsnz5crxeL6qqSmEvhBBCzETeo2ZBf/B1qHvPnPU+KR1mL4Y5l3AsksecyoXTnaUQk8YwDJr9cKi6j70tIbOobw7R1mcuTacAs9NVSlPDXFeZSlmmRmmmitOujGiJ9/RNwxsQQohRTKjAr66u5pFHHmHjxo309Zl/ydLS0rjyyiv57ne/S36+TKwjhBBCJKRIGI5vg4OvU7p3HXTXmtuzis1Z74uWQt4CUM2PBnpN7XRlKkTcGYZBfXeEvS3RlvnWEHtbgnT024AONAWK0lXOz9OodNooz1Ipy9RwWGVpOiHEzBJzgb9nzx5uvvlmQqEQl19+OUVFRei6Tm1tLevWrePdd9/lj3/8I0VFRZOZrxBCCCFi1dcJR/5mttQfeQv6OkC1EMmcC0tvhzlLIb1gurMUIq7CukFtZ5i/N6i0NHQNFPTdAXPyO02B4gyVJW4LuWoPi0qclGSY68wLIcRMF3OBv2bNGlJTU3nuuedGFPGHDh3i5ptv5he/+AW/+tWv4p6kEEIIIWLUdgTnwT/A1g+gbjMYEbBnQtESs5W+8CKaG1opKSme5kSF+HgMw6CxV+dge8i8tYWpag9xxBseWJbOqvooyVS5rNBCRZZGuVOjJEPFppnFvMfTgdslS9MJIU4fMf9F27VrF9/5zndGbaGvrKzka1/7Go8//nhckxNCCCHEKYSDULfJnBzv0BvgrSYPwFkK5/4/5gR5OfNA1Ya8qHWakhVi4k4U8oe9ZvF+pCPMXo+FujebBlrlAbIdCiWZKp+vtFGSoZIa8rKoLA+rJi3zQogzR8wFfnp6OpFIZMz9ycnJ2O32uCQlhBBCiHH0NJsF/eE3oHoDBHtBs4H7fJj/WeqVQmYvuGi6sxRiQsK6wbGuCEe8Id6vVmk/3MFhb5jqjjD+0GAhn25TyLMbXD7bQkmGRnGGSnGGRnrSSRPfeXQp7oUQZ5yYC/yVK1fy3//931x11VWUl5cP29fc3MwzzzzDDTfcEPcEhRBCiDOerkPjTjj0BsW7X4aOKnN7Sg6UXmGOpXefD1YHAGGZIE8ksGAE9reGONIR5og3RLU3zGFvmJrOE13rASxkO/opSldZXmylKEOlKN28ZSYpNDY24nbLSk5CCHGyMQv8e+65Z8S2QCDA5z//eS677DJKSkpQFIWGhgbeffddkpKSJjVRIYQQ4owS6DFb5w+9YbbU+1oBBSWjDBbdahb1zjJQpIVSJJ6IbuDpjVDTEaa2M8LRzjC1nWGOdoY53mVFjw4TURWYlaIyO13lvEobRekqczLMdeXLimRdeSGEmKgxC/y1a9eO+aINGzawYcOGYdv8fj+/+93vuOOOO+KXnRBCCHEGsfYcg80b4NBfB9emt6VC4UXmBHmzF9PY1CkT5ImEYBgGrX6dms4wNR1mC/w+j4XmTS3UDmuNB4cFCtJUStJVLsgIsbAwg6J0lcK0wQnvhvIEpvCNCCHEaWTMAr+qqmoq8xBCCCHOLOEgNO+B49vh+PtQv43yzjpzX+YcOOuLZlGff9bA2vSmzmlJV5y5OvvNIn5bvYqvuZujHWFqOiPUdA4fG29VIdduUJwF5+faKEgzC/iCNBWnXUFRTsxc34nbbZ2utyOEEKc1WRdECCGEmGyGgcXXBHsPDBb0jbsgEm2mTMmGnAW05y3Ddf61kC5dk8XU6gvDvtYQtZ1mS/zRjsEu9Z39J4p4C6rSS36KSkGawvISq1nAp5qFfE6yQnOTjI0XQojpNKEC/+WXX2bTpk20trai6/qI/Yqi8NRTT8UtOSGEEGJG0iPQst9ch/6YeavoaTT3aUmQXQkLPwe5C8xbai4A3TW1uKS4F5MkEDao7x5sfR/atb7ZZ2Po8ok5yQoFqSqXFlgGWuKtfW2cW5IvM9MLIUQCi7nAf/jhh/nd736H1WrF5XKhqupk5iWEEELMGEq4H2o3Rov5LVC/1ZwkDyAlF/LPps19JdkLLgNX2Uld7oWIn4hu4OkxJ7Wr6TQnuNvnsdD092YaeiLogz3qyUhSKExTOSdHIyOnj3nuTArTVNxpKg7LKOPiPYYU90IIkeBi/oSxdu1ali1bxqOPPorD4ZjMnIQQQojEFfRD8z5o2mV2s2/czdymvWCEzf3OUnPpuvyzzVtaPgA9NbVk5xRPX97itGEYBi0+naOdYbbXqfQ0dHG0I0JtZ5i6ruGT2yVbITfJoMypcPlsG4VpKoVpGgVpKmm2wWLd4+mQcfFCCHEaiLnA7+3t5eqrr5biXgghxJkj0ENyyw7ofNss5j07of0wGNEKyp4BrnK65iwnc+4yyDsL7OnTm7M4bXT26+zvUPig3z+sS31tZwR/eHBcvE314Y6Ohb8gzzYwsV1hmkqWXdaMF0KIM0nMBf5ll13Gli1b+NKXvjSZ+QghhBDTQ9eh/Yg5Ad7xbeZ9ywHmnCjmU3LAVQ5FX4XscnMcfUouKAodNbVkzime1vTFzGQY5nrxR7xh89YRpjp67+3TASvQiaZAXopZuF9dah0cF+9vZWFxPpoqXeeFEEJMoMC/7777uOWWW/i3f/s3rrrqKlwu18ByJ0NddNFFcU1QCCGEmBS9rdC0i+x9f4UdNebs9v3RJehsqZA7H87/Kk2Gi/yFyyDZOb35ihkrrBs09kao74pwvDvCse4w9d0RDjRZOP5605DWeEizKRSlqyyepVGUbiUl1MnZc7LJT1FHHf/u8RhS3AshhBgQc4Hv8Xjo6enh1Vdf5bXXXhux3zAMFEXhwIEDcU1QCCGE+FjCQWg7ZI6bb94THT+/B3zmjOHZKOAsgeJLIXch5C2AzCJQzMlk+2pqpbgX4zIMg1a/Tn13hOPR4n1/g0bnh20c647Q2BMhMmRyO1UxZ6nPtuosL7VTlK5SlKZSlKGSmaQMa0DxeCK407VpeFdCCCFmopgL/B//+Md0d3dz6623UlxcjMUiMwALIYRIML0t0LwXmvZC8z5K6rbDn+pAD5n7VSs4i6HgAnCWg6uUOp+D4soF05q2SHzdAbOAr+8Os6tGxV/XxbHuMMe6IjT0hOkPD49Pt6q40yOUZyosK7AxK1UlP0VlVqq5XrxFVfB4PLjd8uWREEKI+Im5Sj98+DC33347//Iv/zKZ+QghhBCnFg6S1HkYdu0aUtDvHWiVByAlB92eD2evMJemc5ZB5uwRS9QZNbVTm7tISP1hg+PdYbY3K2zs8VHfHaa+KzJQ1HcFhjTBYyHF6iM/xSzaz8u1RR8r5Keq5KWodLQ04na7p+39CCGEODPFXODn5+ejqupk5iKEEEKM1NNsFu/Newe717cdolSPNplqNsgqhoILBwt5VynYM2muqaWkpHj6chcJI6IbNPmh6XhgsCv9kAK+2XdibTkr0IVNhbxUs2i/fLbFLOCjrfD0NFNRNGvUuYhO6JiSdyWEEEIMF3OB/41vfINHH32UT3ziE5SXl09mTkIIIc40ug69TeA9Ct4acg++B+97oq3ybYNxKTnmOvPn3EBLOJ3c+RdDRuGIVnlx5jEMg44AdDYFOdYV5nh3tHjvCpvj4HsjhHUb0A5Ex8E7FPJSVM7N1chPsZKfomDt93JWcS5Ou4I6RgHv6Wfc4l4IIYSYLjF/IqqqqkJVVa6//npmz55NdnY2mjZ80hdFUXjqqafinqQQQojTQNAP3Q2kNG6Gno3grYkW9Eehsw7C/QOhWarVnPiu4CKzNd5Vbj63Zw7E+GpqzZZ7cdrrCegc64HG+gAtvgjNPj16H6HFp0fvI/SFbcDgF0JZdrOAL8tUuLTAhiPczbwCJ/kpKrkp5jj4k3k8OtkO6bEohBBiZoq5wN+wYQOqqpKfn08oFKKxsXEy8xJCCDGTGAb4vdjb98P+Q9B1HDrroavefNxVD36z5bToxGssSZBeAGmzYNa5kO6GjAJId1PX2k9JWdm0vR0xdfwhs3g/fqyfxl6dxh6ztd3TE8HTa85A7wsZwGDrO4DDAi6HitOuUJKhsCjfhiPcw1x35sA4eIdleAHv8Xhx50tvDyGEEKevmP+Xe/vttyczDyGEEIlOD5ut7h010FEbfVw7+DzQQ8nQeIsD0vIgNReKLhl47OkxcM9bBA4njNXNub12st+NmAL9YYMGn9ny3tg7WLg3Re8beyPRyetsgHfgdVl2hZxkhTyHylkuKznJClqgi7JZTlwOBZdDJdk6Wuu7F7fbOnVvUAghhEgw8jW2EEIIiISx+Juhvge6G6DbA10Ng4+7G5jX0wiGPvga1Qrps8wW+PKrIM1Nc59GXtnZkJoHSWmjFvCBmlpIdk3dexNxpxsGbX6dQ50K1Uf7afJFaO41u8439ZoFfLNvaPE+2PKenqSQ41DISVapyLKQm6yiBbqoLHCSm6zicijYtNGK9zDuPPnYIoQQQown5v8pb7755pjinn766Y+cjBBCiEkQCWHxNcKxrjGLd3qbqRhavIPZhT4l15zYLu8sulznkzl7vtmVPt0NydmgDp+LxV9TC9nFU/bWRHxFdIOOfh1vn86eNoWdAX+0WNcHivam3gitfp2wDuaM82bLu6qYLe8uh0K2Q2Wu04LLoWINdFFR4CQn2dxut4xRvOdK8S6EEEJ8XDH/b3r8+PER23Rdp6Ojg0AgQEFBARUVFXFNTgghxCmEg1h7PVDXMVisjyjeW6jAGP46i8PsOp+SbY5/T8mhrV8le858s6BPyRnRAt9RU0tmSfGUvj3x8YR1A2+fTnufPuQ+QrVHQ6/txOs3t5m3CF39xpDfFCvQCUCKFbIdZuv6WdkaLoeF7GQVta+DioJssh0KWXYFbdRJ66TlXQghhJgqH3sMfiQSYf369fzgBz/g1ltvjVtiQgghQAn3Q+vB6IR1x6Dz2ODkdZ3HoKeJ8pOLd2sKpEaL9IILISWH1j6VnOJ5g8W7LXVE9/memlqyi4qn7s2JCQtGDFr7wN8awtsXGSja2/36sEK+qdtCT7gx2kV+JAWV9KQ+MpMUMpIU3KkKC1wWMpIUMpJUMu0KkV4vcwuzcTlUHKOMdwfweCK4Xdqo+4QQQggx9T72V+qaprF8+XJ27drFmjVreOGFF+KRlxBCnH5CfdDXMXBLO74H/FvN2eX93uitfdhtXqB7+DFUDVKiE9fNOgcqltPar5JTvGBI8Z4y4tS9NbXkzC6emvcpYtIfNlvXO/p1OqL3RxpU1JYec9uQ7R19Ot5+Hf/AbPKtw46lKUSLc/NWkBwhPzPJLNaTFDLs5vYTBX1vexOFBe5x8/N4IrjTpXgXQgghZpK49ZkrLi7m2WefjdfhhBAiMek6BLqx9jZAw5CCvb8z+ti8L2w5BpvDQwr6TogEhh2qcOgTix3sGWBPh6QMcJaC+3y8/eAsmh+dgT7fnJzupHHvvTW15BQWT/pbF4NCEQN/yKA3pOMPGhzqUKhX++kNGvQGDbqDOr1Bg56AHt2m09RpoW9zy0Dx3h8e7cgWoIdUq0J6kkK6DdKTVPJcKhlJGmk2Bfq7mJOXNVCsZySppNpAHdIjw+Ppwu0eeyJD/xiLFwghhBBiZotLgR8MBlm3bh0ul8yKLISYQSIh8LWBvw18reBrB18r2fWH4ah2UuHuNYv0/i4wdMrHOqbFAfZ0bNggzWVOUucqA1sa2NMgKd0c256UTkNbDwVl883C3pI06uG6ampxlhRP0gU4MxiGWYz7TtyCBv6QPvC4tlEluasXX/DEfn0g1h80aO+1EHmvhd4hrwtGTj7L4GRzQzkskGxVSLEqWA2D7DQoSNXISLKQHi3Q02zmfXqSQl9HCxVF+VhGGct+gscTlqXghBBCCDGqjz2LfjAYpKamhu7ublatWhW3xIQQYkyGAeF+CPog0APBXgj0ktK4HyIHBp4T7B3+ONDLnPbj8Fav2QW+v3PUw2ejRIvwIbesUshPGyjOW3sC5BSWjozTbAB4amopKSke920Eg7VmV3sBmBPC9YUM+qJrpwfaQvhDBv1hs0DvCw/u94d0PK0a1vousyU9qEfvjWHPewJW+iONJ89ScBILYA6FsKpmQe6wgMOi4LAoqIZOlgOK0lTsFjW6fzAm2arg7/YyO89FSrSYP3GMoZPOeTwe3O6scTPx+Ixxi3shhBBCiPF8rFn0wRyDX1paymc/+1luuummuCUmhJjhokW4FuiEjjqzGA/6IOQbfBzshaCPbE8dNKSaY9RP3MInHvdDyE9prxdeDw28Bn1k/+ai0fLQbGBNjt4cKIYVsorM8ev2THBkRu+zwJEB9kxqPe2UlJaO+/Z6a2rJmVMcl0uVSAzDIKxDIGIQCBsEIoOPazsV2jwBAuGh+4fHNbWqJDd1D9l3UmzEoLPXgrG5ZbBojxbuoWGr9I0cZ34yBRWH1WcW2RYFe7TgTrEqZDsUHBYVPdBPdmYqydFi3WEdLNwdVki2KHS3tzCnIB+HBayjrr/ehdvtHDcXjyeCO0dmihdCCCHE9PrYs+gnGl3X+eEPf8jBgwex2Wz85Cc/Yc6cOdOdlhDTwzBAj5hjvyNBs0t62Hxs66qBxui2SDC6Pfo4Yj7OrK+Brr9Hi+1+s9U83B8twAMQ7mN2RwtsZkjB7h8s4g2dyhjSzAFQrWY3dYsdLDbzXrNFtyURtrtIysweUqybBTu2weee1k7cc0oH99uSQR3+Z64phpZ1lI6PcrU/MsMwiBgQ1s11yMNG9F6HZj8YHeHRC+ro84ZmlbSu3oGCOhgZWXh7uyxY9rSPXXiHDfrCVkJ6I/qYzd1WoP0U78aCqvRiU8GmKdg0896qMbDNMHTSbZCbrGDXzHXRkyyQpJlFul1T6OvtJD87C7sGSRYFu0XBrmHGRre1NzfGMFFcB263ffwYn0F6krSaCyGEEGLmO+2aG/72t78RDAZ54YUX2LlzJz//+c/5zW9+Mzyot2XkC43BT7RaXzv0NJ/YMep5LH1t0N04Rhbmayz+FujOGPUcA8fxt0BX+pjnwTCw+JqgM3XUcwBYfI3QmTLsNSez+jzQ4RjzHIA5aZj35A/Cw49l7T0O3qRRz3GCrecYtFmiMcaQWGNgW1JnNTSFT4oZvLe318Bx35j7MQySW2rB3jZ8+8D7MbelNB4DS8OYxzAMHWvdMfqCBwEDI7rPMAwUYzDW5mnA1/uBWSwbETB0DD0SfW6AEcHe0kRvoyu6P2JOxmbow16T2t5O7+G0gdeY+3QwIii6TmZ3J75dKdF4Y+C1ykCcTo6vh76NFpRowa5EAih6CCUSNG96iPJQPzphlEgIZYzfrbIxf4KDZp30XFdtGJoNXbWha0nomo1wRKPbkYZuSUZ3uIik2tE1OxGLg4hmp6M3SKozb+B5xOIgog7uD2sOPK2d5M9yn/gtGfwxmj8NADyNzeTm5aEboBsQMQwMAyI66CHQAwbNPW04m7LN7YaBbgTQjUD0sfkjafOqZLT3DBxn2LGiz70dGin1XQNFdkSHkH6iCDeI6NDdayFpT/tgUa6b+8K6eRx/vwV1Y8vgPsN83YnXhw0IR6zoeAjrjMMGjPI3a5jBLuZgzqh+orA+ca/oBinBEFbV3JZqVciyg01VsWlg1SDY58OZnjrwuhOxJ47R2+klP8cVjVdOKuLBpiq0tTQy+5RFdywt4qceZy492YUQQgghhhuzwH/sscc+0gFvv/32j5xMPOzYsYPLLrsMgPPOO4+9e/eODFpTMe4xYmlxHP8IUxsTyzHGnBBsEmJiKRzH7/wMJTEcI5Z+GaN22R5CIX7v6eSvYIYKGyo6CjmoRFDRMZ8PPja3R1DxGsrAY2NYzODjAFaChoUQFkKkEsRCEAshw0IQa3S7hUB0W+jE/uh90DgRoxHEOvDagf0nXm9Y6cdGPzYCWDFQY7gSE9UHJHHqluHRJzEbzgKMPq5+eEzPiK2qYi4LrwKaomHR+tBU0BQFS/ReU80x1ZoKekjFoRuoijKwz6Kp2KLjrpOVEKkptoFjaCpYVAVNiR5DAX9vD5kZ6eZ2dXD70LiuDi+zcrNJ0hRslqEt4go2TSFJU2ht8lBSVDiwfbQx3MeOHaOoaPa4V8aMOflrnaH7+ykqyhn3GL09vThSxx9nbrX3zKiYRMolXjGJlMtUxiRSLvGKSaRcpjImkXKJV0wi5RKvmETKZSpjEimXeMUkUi5TGTNV51FUjWBgzN0TohjG6E2x8+bNi+0AyvAPkgcOHPj4WX0M9957L8uXL+cTn/gEAJ/85Cf529/+hsVifpexY8eO6UxPCCGEEEIIIYT4SC688MJx94/Zgr9+/fpTHry3t5eHH36Yd955B4vFMuZM+1MpNTUVn8838FzX9YHiHk59QYQQQgghhBBCiJlozAK/oKBg3Be+9tpr/PznP6elpYULLriAH/7wh1RWxtK5fXJdcMEFbNiwgWuuuYadO3cmRE5CCCGEEEIIIcRkG7OL/ljq6+v50Y9+xKZNm8jIyODOO+9kxYoVk5XfhJ2YRf/QoUMYhsEDDzxAWVksI6g/3jlVdTLGJgshhEgkhmGMGJom4keur5gsU/W7Fa/zzLR/C1OZ75l6jWeSQCBAUlKS1EjTJOYrHgqF+NWvfsV1113Hpk2b+MIXvsDrr7+eUMU9gKqq/PjHP+b555/nhRdeOGVxf/ToURobzdnwR/uuw+/3EwiMP+PBiV9cXR99Kuy9e/fS3j7+BGLBYJDGxkYikciYMX/84x85fPjwuMc5caz+/v5xY/r6+vB6x56wrKOjg6amplOea6qMd10A3nvvPRoaGj7WOX7961+zZcuWj3WME1paWk6ZTyJd46m4vhC/azzTru+pGIYx5t8PMTFjfWc99Hc8lu+1x/p5DP0wGK+f2QS/Z5928bjGcn0nRtf1ca/Hqf6GxyoYDMblOIlo6O/WaL8TJ1/jk2PC4fCI+NGOc+I8o+0/1WezieSbaKbq+g4915l2jWMRy/sYL2b79u0TuoZjefrpp+ns7IypuB8rn1AoRCQSobW1lb6+vo+d01Qa6z1N1Wc97Yc//OEPTxW0ZcsWvvWtb/HGG29QUlLCI488wle/+lUcjjGWXZsh7r33XqqqqtiyZQvnnXceycnJw/Y//vjj/OMf/6Cjo4N58+axf/9+rFYrdvvgUnJ33HEHfr+frKws0tLSqK6uxul0EolEBn6p77//fj7zmc9gGAZvvfUWe/fupaCggKSkpIHjfO9738Nms+F0Ovnggw/YvXs3s2bNGhZzzz330NraytKlS7FYLOi6PuKbx1/96lds3LgRj8fD2WefTXV1NaqqDsv5ySefZMuWLbz77ru8//77RCIRZs2ahaZpADz44IN88MEHvPrqq7zyyiv4/X7mzJmDzWab8DX+8MMP6evrIytr7FkjW1paCIVCw3I82YlrOfS6DvWjH/2I66+/nr6+Pp5//nm2b99OcXHxwO9oV1cXdXV1pKenD7zPk/34xz+mvb2dxYsXY7fbxzyX1+ulr69vzN//hx9+mD179rBu3TreeustQqEQhYWFw65fvK5xolxfmLprPBXXNxwOn/I/pUAgwOHDh1m/fj0FBQWj5moYBr29vVRVVeFyuUa9LoFAAIvFMuwDy8n/rqurq9mxY8eYX1h2dXVx+PBhent7cTpHX35u+/btPPLII3zqU58a8z0ZhoHf76eqqoqsrKxR8zUMA5/Px9atW7Hb7aSmjlw/IhwO09rayrvvvovD4SA9PX1ETCgUGvP3BMDn8/H++++zbt06iouLSUlJGRETiURobm5m69atzJo1C6vVOuLa+f1+rFbrwM9ztBabqqoq3n77bRYuXDiw/+SY9vZ2tm3bRnd3N3l5ecDISWaLFPwFAAAgAElEQVTfe+89Vq9ezfXXXz/mewuFQrS0tLBt2zZyc3Ox2WzDjhMOh2lqauJvf/sbaWlpo167eFxfmLprnEjXF+J3jYPB4Cmvsdfr5c0336SqqoqysrIR8ZFIhIMHD9Le3k52dvaox+jp6cFut4/b0rhu3To0TcPlco35d7W6upr9+/fjdDpH/TmC+Te6s7OT+fPnj3muUCjE0aNHaWpqIjc3d9SYcDjMwYMH2bNnDzk5OSP+9vr9fj788EO2b99Ofn7+qP8/9fX1YbWOv1Tm8ePHef7559m1axcLFiwYNufS0ONs3bqV+vp6Zs+ePervn9frJTk5edj2k2OeeeYZVFUlLy+PYDA47O82wK5du9iyZQu5ublYrVY0TRtxjO9973scOXKEJUuWjPmeent72bFjB0ePHqWoqGjUfP1+P5s3b+b/J+89w6q6tr7vH5vO3vTeQaqCoIgKqGDHHmNi1PSiMcnJMRo15STmaCKJ0RST6K0mdpMoCBYsIApSRZqKFKUjIE2kd9jwfPDd8xVBk/s+58l73ueZ17UvPqzBGGP+11pzjTnaTEtLw9LSckj8/h0Y/yfhC38dxn8Vvn92tLW1UVZWRltbG7q6ukPSKOyWJ60Tzc3NqKurP5amvLycL7/8kueee468vDxSUlLIzMzE0NBwwLe+traWtra2Ib8ZAHfv3uWdd96hurqamTNnPlYfxXdqKH0aGho4cOAA+/bto7q6mlu3btHX1zeohLyzs5OOjg7KyspQUlIa0hb7MzZdfX09N27coKamBguLoY/67e7uprGxEU1NzcdieO/ePaRS6WOvX7p0CSMjoyfawHfu3KG2thZDQ8P/cZbJEzf49fX1bNiwgW3bttHZ2cl7773Hli1bsLKy+m8L+k8b8fHxZGZmsmrVKmprazly5Ajz5s0DHvQXuHPnDgkJCfj7+xMaGkp6ejrp6enEx8czadIkVFVVaWtrIyYmhujoaOLj47l06RLnzp1j1qxZ4kWPjY2lsbGRgIAA1qxZQ2dnJ2VlZWRkZODv7w9AXFwcd+7cITAwkG+++Yb6+nrKyspIT09n0qRJKCkpkZCQQGlpKebm5jQ3N+Pi4jLohsfFxREXF8fkyZOJjIwkJSWF9PR0Ll68yMSJE1FXVycuLo6EhAQWLlyIlZUVcXFx1NfX093djaOjI3FxcaSkpLB8+XImT56MgYEBGRkZFBQUMG7cOCHr0KFD9PX1IZPJBjghHh5r167lzp07nD9/nuHDhw+58di6dSvXr1+nqKiI0aNHk5aWhoaGxgBny9KlS2lsbMTY2Bg9PT1ycnIwNjYWL0ZsbCzt7e1MmjSJVatWYW5uTkFBARcuXGDq1KmoqqqyevVq9PT0kEqlXLx4kbS0NGxsbMRCEB8fz927d3FwcOD27duMGTNmyJcuKCiI69evk52dja+vL5mZmaioqAh9FfitWrWKcePGce3aNUpLS7l37x6jRo0aQPOvYvyfhC/wl2D8V+F79uxZkpOTUVZWRldXd0ij5uuvvyYnJ4fq6mrKy8vx9vYGBm5udu/eTVRUFLdu3UJPT4+6ujri4uJwcnIShv7WrVvZtm0bcrkcd3d3SktLuX//PgYGBoLXjh07sLGxwcDAgHPnzrFz505aWlpwcXFBIpGwefNmWlpaUFdXp7CwkB07dtDc3Iyzs7OQ89tvv3Hx4kXMzMxwcnJCLpcPMmp27tzJ+fPnyc3NRVdXl66uLqKjo3FwcBAY/PLLL8TGxlJRUcHhw4e5fv06mpqa4rugpKTE9u3bSU5Opry8nJ07d3Lu3DlUVFRwdHQUMo8dO0Z4eDgSiQRDQ8NBG4CgoCCqqqqoq6vj+vXrTJgwAWVl5QH4fvvtt6SmplJcXIySkhJVVVVcuHABNzc3oW9QUBBBQUEoKSkxfPhwcnNzqa2txdTUVPDatWsXzs7OyGQyfv31V7755hva29sZPny4wO+LL74Qm9hr164RFBREa2srw4cPF7JCQ0O5efMmUqmUESNGCGfNwxh/++23XLlyhcLCQuCBoRkRESH4/PDDD8LI+O6777hy5QqampoDjNB/B75/Jca7d+/+j8EX+LdgDLB9+3Zqa2vp7+/H0NBw0DdZLpezYsUKjIyMyMnJQSaTYW1tPeD6mjVrKCsrIz8/HwcHB06fPk1VVRWOjg8OcO3r62Pu3LkkJyfT0dGBm5sbZ86cwcHBYYBj9quvvuKFF14gJyeHAwcOcPToUaRSKfb29vT39yOXy1m5ciVjx46lrq6OkydPcvToUTQ1NbGzsxN8fvjhB4qKinB0dMTU1HSQASqXy3n33Xe5c+cOubm5uLu7ExUVRWlpqdBZLpfz4YcfUl9fz+3btzlw4ABFRUWYmJhgaGhIb28v77zzDn19fdy8eZPvv/+eq1evYmhoKPDp7+/n448/pqSkhN7eXszNzQd9LxT4enh4cOPGDbq7uwc5JuRyOW+99RZyuZzc3FzMzMz4/fffqaioYMSIEQLjadOmcfXqVbq6unBzc+Pw4cM4OzuL75tcLue7777j1VdfJTU1lW+++Ybg4GDU1NRwdnamt7eXv/3tb8yaNYuSkhL279/P4cOHxXWFnEOHDtHY2IiBgQE2NjaD1mG5XM6bb75Jb28vN2/exN7enrCwMEpKSoS+crmcVatWIZVKuXnzJtu2bSM/Px99fX0sLCxERti/ivF/Er7AX4bxX4WvYjQ1NZGeno6ent6Qtl5NTQ0bNmwgPT2d0tJSXF1dhQ2nWAPr6+vZu3cvW7Zsob6+Hjc3NzIzM+nq6hIBoPr6erZs2UJNTQ1tbW2Ymppy7dq1ARvmX3/9FXd3dyQSCT/++CP19fX09fVRXFwsmpRXVlbyj3/8A3V1dZSVlblx4wZZWVno6ekJJ8Dp06dxd3fH1NSU3Nxc3NzckEgkAwIY9fX17Nmzhy1btlBdXc3o0aMpKCigubkZAwMDdu3ahUQi4e9//zvNzc1cuHCBlpYWGhsbcXFxAaCuro5vvvmGU6dOUVdXR0ZGBtXV1VhZWQksm5qaOHfuHMrKykgkEtTU1Abdh+rqatatW0dzczOlpaXY2NgIR4rCOVBXV8e2bds4fvy4uA8xMTE0NzcLh0B9fT3r1q2jsLCQhoYGrKysuHz5sgjOVFRUsH37dpYuXUpGRgZRUVHExsaio6MjnKUVFRV8+OGH2NjY0NLSQlxcHPHx8Uil0sc6VIcaj93gHz16lHfffZfs7GymTp3Knj17CAgI+D+mjuLXX39l1KhR+Pj4MGLECGJiYvD09CQ7O5uLFy9SV1eHs7MzzzzzDKWlpVRXV7Nx40bKy8spKyvD3d0dNTU1bGxskEgkfP3112ITHh4eTlNTE97e3vz4449IpVJycnKwtLTkvffew8fHh6tXr9LS0oKzszNnz57FxsaGzs5OpFIpq1atYuzYsSQmJlJXV4ebmxv79u3jqaeeYs6cOQQFBVFUVCRecoUxduTIEVxcXHj22WcpKiqiubmZdevWce/ePQoLC/H09OTw4cO4uLgQGBiItbU1ra2tKCsrk5OTg46ODikpKejp6TFr1ixkMhkODg54eHgQHR1Nc3Mzrq6uNDY2cuzYMVJTUyksLKS0tBQAAwMDYawlJCSQm5vLV199hbKyMrt372bhwoUCe1dXVxITE0lJSeGll14iKiqKc+fOkZ2dzYkTJ/D390cqldLX10dWVhYnT57kzJkznDp1ivDwcBYuXCg2jj/88AOtra3k5eUxbNgw3nzzTWbMmEFJSQkVFRXcv3+fu3fvsnjxYjZt2oSenh4FBQVERkYSEBCAmpoa+/btY968eTz33HPs2bOHxMREHBwcBkTG4+PjSU1N5ZVXXiE1NZWwsDCys7P5/fffmTBhAjo6OoSEhGBgYMDUqVPR1dWlvb0dExMTampq6OzsxN7enlOnTv3LGP/V+La0tJCfnz8kvu7u7sTFxf0lGEdERPwl+N68eZNjx47R2dlJWloaVVVVqKioYGhoCDwwEPbt28fGjRuZNGkS3333HdbW1lhbW3P48GEkEglGRkb88MMPrF27Fi0tLfFBTE5Opq+vTxg/xsbGhIeH09bWxjfffENISAgSiQQ/Pz+UlJTo7e1l7969rF+/no8++ghtbW08PT2JjY1FS0sLW1tbDh48SFBQEF999RWampoMHz6c2NhYVFVVcXR0RC6X8/PPP/PBBx9w9epVrK2tMTAwGLAhkcvl7Nixg3Xr1mFhYcEnn3xCT08PV69epb29HQ8PD+RyOd9//z0ffvgh06ZNQ1lZmfv373Pnzh1sbGzQ19dHLpeza9cuNm7cyOzZs3nppZfQ09MjJiYGbW1tbGxsgAcRicOHD9Pd3U1ERAT5+fmoqKhgYWGBXC7nwIEDbN26lRkzZnD48GGkUimOjo789NNPKCkpYWZmxu7du9mwYQN2dnasXr0aIyMjkpKSaGxsFA4XNzc3QkJCaG1tZdeuXfz+++9IJBL8/f1RUlJCLpfzyy+/sH79ej744ANGjRrF+PHjiYyMpLu7Gzc3N+RyOQcPHuTzzz9n69atuLi44OXlRWRkJG1tbXh6eop5f/rpp8THx6OlpSU2jA9j/PPPP/PZZ5/h7e3NqlWr0NLSIikpicrKSsaNG8eOHTv4/PPPmT59Om5ublRWVlJYWIixsTHm5ub/FnwVuvwVGPf19f3H4Ovr6yue838V487OTiIiIkhPT6epqYnU1FTq6urQ1NQUhuGlS5dobGzkww8/RCqV8vXXX7NkyRKUlJQICgqiubmZyspKNm3aRExMDHv37sXU1JTExEThtFVSUkJZWZlr165RV1dHUFAQsbGxDB8+HFtbW+CBQ1JJSYmxY8fy6aefMn/+fMzMzIiOjsbLywupVEpMTAxyuZzAwECCgoKYMWMGRkZGXLp0CQ8PD7S1tbl48SLd3d0sXryY2NhYfH19B2UcXLhwgerqajZv3kxWVhY//PADurq6JCQk4ODggLGxMRcuXKCiooJ//OMfjBkzhvr6enp6eqioqMDb25vLly9TW1vLP/7xD2bOnMkLL7xAZ2cniYmJeHp6ikhvVlYWSUlJNDc3c/bsWcrKytDS0sLY2BiAmJgYmpqaWLNmDS4uLmzbto3AwEA0NDRYs2YNAQEBxMXFiQ1SdnY2P/zwA56enkRFRWFnZ4e5uTlKSkqYmJgQFxdHc3MzW7duJTo6mpEjR2Jvbw88CPwA+Pj4sGnTJtauXYuRkRHh4eG4u7tz8+ZNent7WbBgAUFBQbzzzjviurOzs8Clo6ODl19+mTNnzjBq1KhBkb7o6Gjq6urYsGEDtbW1fPnll7i6uhIREYGFhQXW1tZcunSJ6upq1q9fz4wZM5DJZDQ1NVFSUoKXlxdqamrExMT8yxj/GXzj4+Oprq7+346vvr4+cXFxfwnGeXl5fwm+ilFQUMC7774rnI4aGhpoa2sL58f+/fsxNDRk3bp1pKamkpiYyJQpU6ivrychIQFHR0d27twJwPr16/ntt9/IyMggPT2d+vp6xo4di5KSEnV1dZw5c4aWlhbkcjnBwcHExMQwcuRI9PT0kEgk/Prrr4wZM4a4uDiWLFnCCy+8gK2tLeHh4Whra2Ntbc3Bgwdxc3PD0tKSw4cPU1JSQk9PD4WFhYwdOxZ4EABZsWIFw4cPJzQ0lM7OTkaMGDEooNDf38+HH37ImTNnuH79OnFxcdTV1eHt7c25c+eYPHkyw4cPZ/jw4VRUVGBqakpWVhaOjo7o6ury888/I5VKef/999HT00NDQ4O8vDzKy8tF0KeqqorPP/9cZEo1NzfT39+PioqKcAIcOnQICwsL1q1bR25uLmFhYcydO5e6ujpOnz6Nh4cHe/bsQVNTk08//ZTDhw8THx9PY2Mjd+/eZcyYMaioqNDR0UF6errYW/3888/iHhkbG/Pbb78Jx/auXbswNTVFW1ub7Oxsxo0bJ+6Bh4cHZmZmHDx4EJlMhpaW1gCaPzMeS7Vp0yYBQkxMDFOnThUgP+6nMFj//zAWLlzI5cuXaWxsRENDA2dnZ65evUpiYiLjx4/n2Wef5fr167S3t7N48WI2btyIrq4uNTU1A1JSHB0dqaurIz8/H4DNmzezc+dOAgICAHj99dfR1dUlIyNDeJy0tLTo6ekRD/rSpUvJzs4mPT1deL9kMhm9vb2oqanR3d1Na2sr3t7e6OnpsWfPHqRSKdHR0bS2tgo+zzzzDDdu3GDfvn0cPXqUZcuWYWhoSEVFhTA4nn76aeLi4rh48SJlZWWcO3eOxYsXI5VKqa+v5+WXX6apqYlTp04JT5tiU6Pwvunp6WFkZIS+vr74eJ8/f56tW7cSFxcHQFpamvCozpkzB319fW7fvk1KSgrXrl1DTU2Na9euYW9vj6urq4hG/Pjjj8yZM4czZ84ImW+//TYrV64kJiYGLy8vAAICAggKCgLgn//8J2PGjOH27duYm5uLe6Mwtu7cuYOFhQUpKSn4+fnx1ltv8fXXX+Ps7ExoaKhIX/fx8QFgx44dODk5cenSJXJyckS9TEpKCsOGDcPFxUVEu7/77jueffZZzp49C8CyZcsoKyvj/PnzJCUlcfz4cSZOnIhcLhc1TS+//DINDQ2cPHnyf4zxvxvfN99884n4enl5kZubOyS+wJ/GWBFBfxLG9vb2j8V42bJllJSUcPbs2Sfie//+fU6cOPE/xnfEiBHo6ekREBCAnZ0dlZWVHD9+nO+++47u7m4KCgrQ1NRETU0NbW1t1q5dS2hoKPDA6LS2tqawsBB1dXXMzMzw8fFBT0+P999/n23bthEZGSnqyVxdXVm5ciUbN24kJCQEQ0NDrl+/jo+PD62trVy/fp2ysjL27t1La2srK1asYMGCBaxevZrQ0FCKi4sxNTUlISEBKysrVqxYwdNPP83777/P77//TkdHB7GxsVhbWzNp0iQcHBx4++23CQ4OprW1VdzPvLw8UYIkkUjQ1dVl/fr1bN++nUuXLtHe3i5oFCm+AQEBKCkpMW7cOA4dOkR3dzfl5eVoaWlRXl4u6nmnT5/OG2+8wf79+8V9MjY2xt7enpdeeonFixejqalJSEgIa9asoaCgADU1NUpKSgBYs2YNp06dAh6UGjg6OlJWVoaqqipNTU3Y2dkxYsQI3nvvPX777TeuXLlCW1sb/f39GBsbs27dOj744AOOHDmCpaUlxcXFBAQE0NraSnZ2NsXFxWzevJmOjg6eeuopZsyYwU8//URUVBQdHR3U1dVhaWlJSEgIlpaWLFy4kNmzZ7Nr1y4iIiJob28nMTERGxsbxowZw/Tp0/nqq6/Yvn07NTU1AuOSkhKUlZUpLCwkPz8fY2Nj1qxZIwyy3Nxc1NTUqKqqor+/n2HDhqGsrMzLL7/Mr7/+SldXlzAQy8rKRH+Yx+FrZ2fHiy++OAjfrq4uSktLUVNTo7i4+F/CuK+vD2NjY9auXTskxoro/5/BNzg4GAsLiyHxTUhI+EN8i4uLUVZWpqCggLy8vEH4tra2UlJSgpqaGpWVlY/F+M88w4qsFQcHByZPnoyJiQlFRUX8/PPPnD59GnhgWCoiLr6+vnh6ehITE0NKSgrNzc00NjYKw3rEiBGMGTOG9957j6lTp3L8+HExryVLljBlyhR27tzJG2+8wYgRIwgKCuL9998HHvT5KSoqYvPmzUydOpWpU6eyePFiRowYwe+//w4gUp6Tk5PFPViyZAnDhw/nyJEjwIOMw2nTpuHv709TUxMvvPACSUlJ9PT0CF2qqqrQ0dGhubmZ+/fv4+vry5o1a5g1axZhYWHAgwifoqRBW1sbY2Njhg0bBjBg3ampqaGnpwdVVVWWLFmCmZkZBw4cELJMTU0ZPXo0K1asYM6cOXR3d/Pjjz+yd+9e4EEKr4qKCi0tLdjb2zNu3DguX75MamoqysrKaGpq0tLSImq7nZycmD17Nm+++SYvvvgi4eHhwIMo6IIFC1iwYAE//fQTr776KmPHjmX79u188MEHABQWFpKamsratWuZOHEirq6uPP3008ydO5fjx4+joqJCa2srYWFhzJkzB3d3d5555hlmz55NcHAwAMnJyUybNo3Ro0djZmbG66+/TlhYGM3NzWLO9fX1yOVysrKyuH37NlOnTmXlypW88cYbREREANDY2Ag8KN1Q6O/h4YGdnZ24lw9j3N3d/USMR40axfLlywdhrMC3ubn5sfg2NTX9Ib5yufwP8S0oKCA1NZX3339/SHwBlJWVaW1tJTQ09LEYX7ly5Q8xvn//PnK5nJs3bw6JcUNDA4D4nz/C9195hgFGjhzJ6NGjGTVqFE1NTWzZsoUNGzZw6NAh6uvraWhoYMKECUilUpYvX05VVRWNjY1ERESQm5sLPEhT9/Pzw8rKCnNzc9zd3fnyyy+pqKgQz421tTVvvPEGcrmcqVOn0tTUhFQqJTg4mMuXL9Pb28v8+fMJDw8nKipK9PUwNzenvr5eZIn29vbi4ODArVu3ePXVV9m2bRvLli0jOzubS5cuCaeCk5MT1tbWvPXWW1y5coWPP/6Y9PR0Me/m5mYmTJiAtbU1TU1NODo68sUXX1BVVcWZM2eYNm0an376Kd999x2nTp3iypUrvPTSS5SXl4vj0OVyOSNGjEBfXx8vLy/mzJnD888/T0ZGBklJSQDY29szYsQIRo4ciUwmIzo6miNHjnD48GGKiorE/VQ4BN544w1hy0RHR1NbWytkjRw5Em1tbVxdXZk4cSIbN26kpaVFrPkGBga8/fbbSCQSnn/+efT09LC1teXYsWOcOnWK0tJSJBIJx44dY/ny5bz55pssXryYmpoaLly4AICKigpGRkaUlJSwfPly3n33XZYuXcrdu3eFnD8zHhvBr6ioEBt3V1fXP/2bPn36nxb+/+UwMTFh2LBhIpXG3NycrVu3UlVVxYcffoipqSkuLi6YmJigo6NDb28vMTExREVFsW7dOuFZU1ZWZvTo0axZs4bq6mrWrl2Ljo6OqKUzMTHBycmJ3t5ekb588uRJYmNjWbt2LaqqqsKbd+HCBX799VdRJ5eTk8PatWtRV1cnMDBQpFgq6gGjoqLYs2cPzzzzDMrKyhgbG2NpaYm2tjZWVlaEhYWhpqZGVFQU69evR1VVFVNTU6RSKfv27SMzM5OZM2cikUg4cOAAa9euRSaTIZfLCQ0N5ZdffiEvL4+cnByys7NZs2aNmLe+vj4ODg74+PgwbNgwDA0N6erqwtHRERMTE2xsbLh48SJeXl5oampy7949KioqyM7OxtvbW2w64+PjGTt2LOPGjSMgIAB1dXVCQ0MZNmwYrq6uwAMD4ezZs6iqqpKdnc2mTZv46KOPsLCwwMDAAA0NDYyNjdHR0cHc3BxNTU3279/PtWvXWLt2LcOHDyc+Pp6Ghgb6+/txdXVFXV1dZE6MHDkSHx8f4UxRU1PDysqKnJwcTp8+zezZs1FWVsbOzo6EhARu3rzJ8ePHWbFiBXZ2dgQHB+Po6Mjw4cORyWR0d3dz8uRJmpubmTNnDu3t7fz222+sX78eZWVltLS00NfX58SJE+zYsYP8/PwhMdbT08Pe3h5fX99BGI8ZM4YLFy7g5eWFlpbWY/GNjY3F29ub8ePHPxHfM2fODImvnp6eiAjr6+tjYGCAlpYW+/fvJyMjg3Xr1qGiooKTkxOxsbGicePDGNva2uLu7o6vr6/wliorKz8W4/j4+CExHjZsGOPHj0dXV5fTp09z79495s2bNwBfVVVVNDU1sbCwIDg4mJ07dz4WXx0dHYYNGybwNTAwoLu7GwcHB5ycnETk39PTEwsLC2QymXifDQ0NxYfV3t4edXV10tPTuXv3Lu3t7SxYsABDQ0PKy8uRSCQ4OjqyaNEiVFRUiI2Npba2ltmzZwsHRH9/P+fOnaOkpARnZ2e+/PJLFi1ahK6uLubm5nh7e5Oeno6xsTGjRo1CTU1NyFuyZAldXV1ERkYKp6CRkREpKSlUV1czf/58bt++jbe3NxYWFowcORJvb29u3rxJZWUl5ubmYg2qra3l6tWrJCQkYGBgwKxZs4iNjaWmpoa5c+eKOZ04cYL29nZOnjyJhYUFrq6upKamMmfOHHR1ddHS0iIiIoLu7m5kMhldXV3cvHmT6upq5s6dS09PD4aGhuK5dnV1xcXFRfwdOXIkjY2NqKioYGtri0wm48aNG+Tk5AAwf/589PT0xHzt7e156qmnUFJS4tSpU9TX1zN37lyR3aSiokJ4eDiZmZmMGjWKTZs2sXDhQnR1dTExMWHBggXk5eWhpaWFu7s7AFFRUdy7d485c+agpaWFjo4OSUlJNDQ0UF9fL0qe6urqWLBgAeXl5YwfPx5jY2NsbW2ZPHkyhYWF5Obmoq2tjZGREQYGBkgkEjIzM0lOTkZbW5sZM2Zw7tw57t+/z0svvURnZyeRkZEUFxcTHh6OjY0NRkZG3Lx5k9mzZ6Ovr4+WlhZRUVF0dXWhra1NV1cXmZmZ4j719fWhr6+Ps7Mz+vr6g/C1tLTEwMCApqYmkYn2KMZz585FX1+f3t5eNDQ0sLOzeyLG6urqnD59egDGCxYswNnZmblz51JQUICGhgYjR44cgO/s2bMFvsnJydTX1w+Jb3V1NWPHjn0svoaGhhgaGiKRSETUTEdHZwC+Cmdod3c3UVFRFBUVDcJ47ty56OrqoqGhwdmzZ8Uz3NnZOQhjR0dHnJyccHd3x9XVVbxLbm5u6Ovr4+joyOnTpxk7diyampoigycjI4Pp06czb948YmJi8PPzw8PDg4kTJyKRSDh06BATJ07EwcGBvr4+VFRUqKioIC8vj+TkZL744gveeust/Pz8UFdXx8/PDw0NDYqKinBycsLV1RUlJSVCQkIYP348Dg4OODg4kJycTG5uLpWVlTg5OdHT00N4eDg+Pj7Y2dlRU1PDvHnzUFJSYtq0aejp6XHjxtPmGVEAACAASURBVA2ampqwtbVFWVkZV1dXYmNjyc/PJyUlhdmzZ+Pk5MSBAwfw9/cX62doaCg3btzgzp07XLx4kVdeeYXExEScnJyYN28e+fn5JCcno6SkhJqaGi0tLURERODj4yOyjlxcXDA3N8fW1lZ8sxSGura2Ns7Ozly/fh0PDw+0tLQwMjIiOjqalJQU5s6dKxzypaWljBgxguHDh+Pr60tXVxe//PILAQEBODo6ii7f9+7dE5lvX3zxBcuXL8fX1xc1NTXGjh2Lm5sbZWVlmJqa4ubmRl1dHcHBwfj5+TF16lSqqqrIz88nKysLfX19GhsbOXv2LBMnTmTYsGG0trYSGBgIwLhx43B1dSUrK4uSkhLs7OzQ0NDAzc2N4uJiiouLycrKwtPTEzc3N3bv3s3kyZNxdHTE0dGR1NRU0tLShFN/wYIFXL58GXd3d5ycnHB2dqaoqIjk5GSAITHu6+vDxcUFCwsLbGxscHBwGICxj48PGRkZjBo1Ck1NzSHxdXV15c6dO7i5ueHq6irw/fnnn4W+gIggJyQkkJqaOgjfcePG4ebmRkVFBcbGxri7u1NXV8exY8eYMGECjo6OWFtbU1tbS0FBATdv3sTAwIDGxkbOnDnDpEmTcHR0pLOzU/SZeRzG7u7ulJSUUFJSItarhzFeuHAhSUlJZGRkkJyczPXr11mwYAExMTED8M3LyyMpKUk8w01NTURGRg7AV2ET29nZ4eDggLOzM25ubuIZVjQJtLCwYNSoUcyZM4d58+ahrKxMbGwsY8aMQSqVsm3bNubNm4eenh65ubm0tbWRmJjIkiVLREnl999/z+LFi7GysmLy5Mmoq6vz22+/MX/+fFFCZGVlxb1799DR0eHq1asiY8/d3R2pVIqDgwOBgYF4eHigp6dHXl4eQUFBSKVSXnrpJWH/f/LJJ9y7dw8NDQ1Gjx6NtrY2v/32G/PmzRN2tWLPYmxszPjx4ykuLiYxMVG8A/39/XzwwQcUFhaSl5fHZ599hq6uLr///jsLFy5k3Lhx+Pj40NHRwZ07d5g2bRpJSUmUl5fzxhtvCDv5s88+E1nIVlZW6OrqcuTIEWbNmoWxsTG9vb24uLjg5ubGxIkTCQgIQCaTUVBQgJeXl+gb9c033zB//nzU1dW5f/8+hYWFpKSk8Pzzz4s+Inv27GHRokW4urqKzIhff/2VRYsWYWRkhFwux8jIiKamJlpbW7l69SobNmzA19eXESNGYGNjw/Xr18nNzWX8+PFYWVmhqqrK77//zrx58zAyMsLExIQtW7Zw+/Ztent78fPzQ1VVVch5OPvjSeO/fUze/wkjMzOT06dPI5PJ8PHxYfTo0WhqarJlyxYKCgpYtWoVp0+fRlNTEz8/P7y9vbl//z4hISHMnTsXJycnMjMzCQsLQ0VFhQULFtDV1YWOjg7Dhw+nt7cXFRUVbty4wcmTJ9HT02PKlCk4ODiIBevFF1/E2tqazMxMTp06hYmJCVOnTqW/v5+srCw0NTUZN24cJiYmXLt2jdOnT6Oqqsq0adPEYgsPGl2YmJgIPgYGBuKhOXHiBD09PcydOxdnZ2cxb3Nzc/z9/UWE9NSpU5ibm2NhYSFS/uBBs424uDjMzc0ZPXr0oBrvR5ugKbyY8MDTlZGRgbe3NxKJhPr6el599VX6+/sJDQ1FXV0duVxOTk4OHh4ewAMP2vnz5zlx4gQHDx5EQ0NDGI/t7e28++673Lt3T0Sf4UHk+GGde3t7yc3NJSUlhaeffhojIyP6+/tJTk7m6NGj5OTkMH78eDQ0NCgvL2fHjh1UVVWJNDEYeOzhw17Lvr4+MjIy0NTUJC8vj0uXLjF16lROnDjB/v37qa2tHaCLovFHRkYGZmZmuLu7c+rUKSIjI7Gzs+O9996jqamJ6OhoLCws8PT0fGyDNMVQRGHgQTRQUdfT0NDAK6+8IvBVUVFBIpFQWVkp6qsU+IaFhQl8H06Xeu2110QKl2KcOnWKiIgITExMeO+990Qt6dWrV3nqqafEgqasrExeXh779+8nLS1NYFxWVibqui9cuIC2tjZr1qwZUPOlwFix2S0uLkYikZCRkUF0dDRTp04lLCyMRYsWERMTg729Pe+++y4aGhq0traSnp6Oqakp7u7uZGZmEhISgqOjI6+99hqlpaWkpaVhYmKCu7u7iOQ/big6tmpoaNDW1oaqquqA2mXFs9HV1YWSkhJNTU3o6+ujoqLC3r17+e6779izZw+TJk2ivb0dNTU1Ojs7UVdXR1VVlaNHj5KcnMz8+fOZMWMG7e3topZu9+7dHDhwgF27dolMiv7+fjo6OtDS0iIzM5N79+4xZcoUfv75ZzIzM3n22WeZMGECampqHD16lMjISDo7O3FwcKCrq4tnn32WiRMnCr07OjqQSCSoq6uTlpbGwYMHRTRF0ezv1q1baGlpERQUhJmZGZ2dnQQGBjJz5kw6OjpQVlbml19+obS0lJdffll4nv39/Zk/fz59fX10dXVx6dIloqOj6erqEr1DFi1ahJ+f3586NkcRIVFkNR07doyNGzeKcjGFHBUVFdGMKTg4mCtXrvD0008zefLkATXaZ8+eZdOmTfzyyy/CU/9wrXlVVRW1tbWiJCozM5OlS5eKNPOenh7i4uKEI0tfX5++vj4WL16Mt7e3kKUw2FRUVCgtLSUkJIRZs2aJda6jo4PW1lbU1NQICgoSjsXZs2czZcoUWlpauHjxItXV1cyaNYvy8nLOnz9PQEAAs2bN4t69e7S3t3Pr1i2R8mpubk5LSwsLFy7E19eX+/fv09fXJ5rVPTrkcjkNDQ00NTWJTakC402bNrFr1y4mTZpEXV2daFCpuF/BwcEiChwQEMD9+/dFfenFixf5+OOP2bt3L6NGjaKvr09EP5SUlGhoaMDR0ZF9+/Zx8+ZNnnvuOSZNmsS9e/fo6uoiPz+fpKQkqqqq0NfXp7+/n2eeeQZvb29aW1tpbW0dkEVUWlrK8ePHCQwMxN3dnfr6elpbW9HW1kYqlbJhwwbU1dXp6ekhMDCQyZMnU1dXR0tLC1lZWdTV1TFlyhQqKioExnPmzKG1tRWZTEZ6ejohISG0t7djYWFBfX29eIYV0ff6+noRhX8U456eHtFkS5G599Zbb1FTU8Pp06fp7e0VTip1dXUaGhrYv3+/6KMhkUjEfBoaGkSj3bCwMPEO9fX10dbWhrq6OikpKejr64vyoJaWFn744Qfx3HV1dXHo0CGuXLkiaj5VVFT4/PPPxbqm0ENbWxu5XM6FCxe4fPky3377LfCgKWhnZ6coffvmm2/w8/OjoqKCH3/8ESUlJbq6uqivr+fAgQOYmJjg7+9Pfn4+oaGhHDhwAGVlZerq6jh//jxXr15FQ0NDOFg3btw4CMsnNZlqbGxER0cHiUSCXC7nvffeo6CggIiICMFHcT8V9AcOHKCiooKtW7cOKkHYuHEjGRkZnDlzZtA61dvbS1lZmYhef//996L/gbKyMg0NDVy6dEmcFKOmpoa+vj7r1q0bwOfhBnJpaWnEx8ezdu1aMcfm5mZUVFQoLi5m27ZtjBgxgtra2gH6KppE6uvr4+HhIey73bt309LSQnNzM+3t7WRlZZGQkICKigoGBgb09PTwz3/+k7a2Nurq6tDV1R3S7mhsbKSlpUUEFRTP9OrVq8nPzyciIoLm5maRIaGwoR7Ft62tjYaGBqRSKUZGRmzevJmUlBTOnDkj7mtjYyP19fXCnuzr60NVVZXt27cjl8v58ssvaWlpoampie7ubm7fvk1CQgJyuVw0p167dq147tTU1AZsglJTU0lISOD999+nqamJlpYWuru7GTZsGHl5eWzZsoXhw4dz7949Pv74Y9rb22loaKCgoACpVCrq2cPDw9m1axdKSkq0tbWhra3N+fPnOX/+PJqamhgYGNDR0SGe4aampsc2xHt4PKlZ3cPPjMIWycvLY9WqVVhZWbFv3z5B8/B7oigzbG1t5ccffwT+3/egqamJv/3tb9jZ2bF582bx/8eOHaOkpIT8/Hx8fX2ZPXs2UqmU+Ph4Jk+ejJ6enqCtr6/n0qVLIqPB7v9purx161aCg4MpLS0lKyuLkSNHsmTJkgF9Ph5+57q6urh37x4XLlwgJCQEHx8f6uvrmTBhguDh4+PDs88+i7m5ObGxsZiamg7oBVFXV8eJEydITk6murpafN+/+uorQdPX1yfstceNh+2xyspKVq5ciYGBAYcOHRI0D+97bt68ydGjR+nu7hbro2LcuXNHlLY8rIdCTkpKCqampjQ1NXHgwAF0dXXZtm2boGlqaiI4OJjDhw/T39+Pj48PMpmMTZs2PVb/R8f/dRv8srIyVq9eLWpRs7Oz6enpYerUqbzyyivk5OSwYcOGQdefeuopFi1aNIDHhx9+SHJyMllZWQD4+fnx2muvIZFIBsi5cuUKOTk5yOVyFi5cKGqlH6ZJSkoiJycHDQ0NZs6cKSIlj8pS6DNhwgReffVV1NTUBvBR0KipqTF//nzmzJnzWFn9/f3MnDmTZcuW0draysKFCzE2NmbcuHEsWbJkyC6SZWVlosYTHrw0ihdW8QF7dNOt+Eju27ePnJwcvvvuu0E08KDTcmpqKtOmTcPS0nKQrNu3b1NTU0NAQAC9vb10dnYKnX18fER61JP0vXv3LomJiWJDLZFIWLhwISYmJvj6+vLcc88NaRQ/qm9TUxP79+9HV1eXmTNnoqenx8KFCzEyMmL8+PFD4ldWVsb7779PUFAQISEh9Pf389lnnwEPNuuKD+SpU6c4f/48urq6rF69GktLywGL4qlTp7hw4QJGRkasXLlSNDc7ePAgN2/eFOlMkZGRGBgY8M4772BlZUV+fj5paWlMnjwZS0tLIUcmk/Hpp5/S0NDA3bt38ff3p7e3l8rKSt5//32+/PJLQkJCAPj000+BB4a1YsFWyLK2tmb16tW0tbURFxeHpaUlI0eOpKGhQfAJDQ2lr69P8CksLBTGg4KPmZkZK1euREdHh71796Krq8uIESPYunWrwA5gw4YNQhcbGxsqKipYvXo169at49y5c9ja2pKbm4uzszMvv/yyMPAyMzM5duwYRkZG/O1vf0NZWVk4plJTU4mIiODmzZv4+/vj7OzMuHHjBjgGUlNTOX/+PLdv38bHxwcXFxd8fHyQSqWsXLmSvXv3kpGRIWjGjx+Pq6srY8aMobCwEBcXFwwNDYWszMxMJk+ejKenp3DsPSwrIiKCnJwcpk+fjr29PR4eHuTk5DB27Fhu3brF+fPnycvLY+7cuSKbQCaTiUZ+V69eJTIykqysLCZNmoSLiwu+vr4DPtYPz0lBI5PJRKqdsbGxoCkoKGDOnDniHWppaaG/vx87OzvS09PR0dER5SOK576xsVFscNPT09HV1cXJyUnQKDbFysrKQ/KAB0bQ5s2b2bx5M9evXx9E09PTQ1paGl5eXmhoaAwp5+Hn9nG6dHd3c+XKFSZNmiT0eZSmoqKC1tZWkQXzOJ0fHkPRlJaWkpubS0BAALdu3RqSR35+voj+X7hwgTNnznD//n2eeuopli5dSnl5OY2NjSIyfuHCBc6ePUtlZSVTp05lxYoVA7o4KykpERUVRXh4OHV1dfj7+7N8+XLhjNq0aRObN28mOjqa8PBw7t27h7+/PytWrEAikZCWliaczA/LmjZtGu+8845YK/v7+4mKiuLs2bNUV1cTGBjIq6++Sl9fH8nJyUyYMAEVFZUBuixYsIDnn3+eu3fv0tbWJrCIjIwUfKZNm8Ybb7wxqGmgApu6ujomT57M8uXLuXv3Lrdu3WLixInIZDJBU19fz4IFC0Q9fFFREbq6uhgZGZGamipKgDZv3syYMWNISkpCKpWKd/PIkSNER0ejoqKCl5cX7u7uommuYhw5coRLly6hqanJyJEjcXd3JyAggOTkZGJjY7GysuLixYviuoLmzp07jBw5ElVVVQ4fPkxMTAzKyspMnDgRZ2dn7O3tRZ8KZWVloYuizOzhqKqiHvbw4cNER0ejq6vLpEmTsLW1RUdHB319ffG9O3jwILGxsWJObm5uotRQMRR8pFKpyG5SbFQ9PDxQU1MTNHp6ekycOBFzc3PGjh1LZWUlMpmM+Ph4/Pz8BjhqioqKROYVPGimOGnSpAHf4ofXCICwsDAmTJgw6JufkZFBWloab731FsePH8ff338An4aGBsrLy8V6NJSsysrKARiHhYUxceLEATT3798Xdb5D6XLnzh00NTVFicZQujw6hpKTlZVFT0+PcPqGhoYyceLEAbK6u7tFfbJUKiUoKIji4mL6+vp488038fX1pbS0FBUVFWEvKGja2tp48cUXRZNpRaBGcb2rq4ulS5eK64qG02+99RabN2+mpKSEzs5Oli5dyvz580WTMgW+D8t57bXXCAwMpKamBlNTUxEMU9B0dnby6quvMmPGDBobGykuLhbzVtAoGv9NmDCB8vJy1NTUBF4KfR6d08NDwae7u5slS5Ywb948bt26RVtbG97e3qLHFTwosVWUAJaWlmJqaopMJuPQoUNERETQ39/Pjh076OzsJC8vD3d3d3FfFDTt7e1s3bpVvCfDhg0b4KwKCQmhpKSE7OxsPD09Wbx48QBbU7Hpzs3NZeTIkTz77LMMGzaMTZs2YWpqyltvvcWxY8coLi7m1q1buLu7s3TpUvT19UlMTGTMmDGYmpoKOYoNs46ODlOmTMHa2pre3l6SkpL47bff+PDDD2lpaeHEiRNkZWUxZ84cVqxYIfQJDg6mqKiIW7duiX5exsbG1NTUMHr0aJKTkwWf1tZWTp48SWZmJlOmTGHVqlUD5lVcXCzq9hVBEYUDJjIykg8++ID29nbRXHX27NmsXLlS8Dh16hS+vr4D3peCggIaGhoYM2YMysrKnD59Gj8/vwEOn76+PuFYfRwfuVzOjz/+iJaWFitXrhySpqamhszMTPz8/JDJZINkFRUV0dfXJ5oanzlzZhCPyspKbty4wYwZM1BVVR1STlFREa2trXh6eg56np80/tQxef8njejoaDQ1NVm6dCk+Pj4sWLAAKysrIiMjsbCwELW1j14PDw/H0tISU1NTwWPJkiX4+Pjw1FNPYWFhIY7Lephm6dKl+Pr68tRTT4lNlZWV1SAaPz8/ERENDw8fRKOQpdDn8uXLWFtbP1aWkZERJ0+eHFIfhSxLS0vOnTsn0rMUxwKpqamxbds2Lly4QFdXF66urqL2admyZURGRlJZWYmdnR3a2toDjrhobW3l+eefJyIigqqqKkED4OXlhZ+fHz09PYNoZDIZRkZGeHp6oqOjM0iWjY0N9vb2A4xzdXV1obOqqipbt24lKiqKzs5OXF1d6ejoYNmyZURERFBeXo6trS2Wlpa4u7uLI9MUPGpra1FRURE8enp6cHFxEfNW6Hv37l3s7OwwMjLC19dXpCY9rIsCP0UKrQK/qKgoZDIZCxYswNvbm7CwMLGp//jjj1m0aBFlZWVs27aNDRs2UFJSwvXr1/H390cikVBUVERTUxPffvstn3zyCQUFBeI6PKj1mjFjBrW1tWzbto1PPvmEoqIiQWNoaIiOjg42NjYD5JSWlpKSksLChQuxtbWluLgYXV1dLl26JPQdM2YMoaGhODg40N/fz0cffTRA308++YTs7GyuXLnCnDlzcHNzo6enBzMzswHz9vLyEnwkEsmgeX/yySfk5eVx7do1pk+fLmrXc3NzB2Cn4AHw0Ucf8cwzzwhjetmyZdTU1HDy5EnWr19PYmIi3d3duLq6UlZWxscff8zrr79OdnY2d+7cYe/evWRlZTF69GjWrl3LypUrmTt3Lg0NDWRkZHD8+HHMzMxEOc/f//53Vq5cSWBgII2NjWRkZBASEoKzszMrV64UXV9XrlzJrFmzBE14eDiTJk0S91xBM3fuXO7fv8/Vq1eJi4vD2Nh4kKxZs2ZRW1tLeno6Z86cYcqUKdjY2IjrM2fOpKysjOTkZK5cuYK7u7sw5FatWjVoTsHBwRgbGwvn18NzUhxXlpaWxpQpU0TtrIJmxowZlJeXk5aWxokTJ/Dw8BDe9LNnz7Jq1SqSkpKor6/H1tYWc3PzAR8rBU1ycrJI/dXS0hIOQsX1K1euiOuKfgfTp09HIpEM4NHc3CzS+K2trUWGy8M0jY2N2NjYDHK6PSyrsbFRrEV2dnZD6nP//n1sbW0xMzMbcKTZUHN69KieR+el0MfJyQk1NbUB2DU0NGBnZ4eWlhaGhoaC16effsr69et5+umnOXz4MBoaGowaNUrUZBoZGQmaxYsXc/LkSdFJPSMjg5aWFoyMjPjkk09Yv349ixYtGkBz+/Ztxo4dO4DmmWeeETQODg4isveorLCwMNTV1Rk9ejQpKSm0trayfft2weP48eOiiZ8iGveoLkeOHEFDQwNPT0/KysoEzcNyTpw4IfRVyHmYZtGiRZw4cQJNTU1Gjx5NZ2fnIJqnn36aI0eOoKmpib29vai1NzIy4u9//ztvv/02gYGBbN++nWvXrnHlyhXs7OxwcnLi9u3b7Nixg2PHjmFjY0NNTQ3x8fGcOHGCsWPHIpPJyM/P56effuLYsWNYWVlRW1tLQkICJ0+e5PXXX8fCwkJcV6QdJyQkEBsby4IFC9DW1h7Aw9bWlvLycuLj44mOjmbMmDHo6OgMoLG0tKS8vJyEhAQSExOZP38+Uql0AI2pqSmFhYVcvnxZnNKj0PfROSUkJBAWFiZSWB/mY2FhQVVVFbGxsdy6dYt58+YN0lnRkyAhIYGIiAgCAwPR19cXvROSk5Pp7e1l2LBhmJiYCDuht7eXr776iu+//56UlBT6+vqwt7cfcAyjgmb79u0DaBRNJL29vent7WXLli2D+Ghra4v16FFZiki0IqItkUgG0Fy9ehW5XM6wYcPQ0dHBzMxsgC4Pz8nIyEhEZR+ny8Onswwlx97eHktLS+EMGUqWg4MD6urq6Ovro6amRkFBAceOHePIkSOYmppy8OBBAgICMDU1JSYmBgsLC8rKygSNlZWVcHKoq6tz5swZOjo6OHHiBEeOHMHCwmLA9du3bxMYGEhZWRnBwcGi50ZYWBiTJk0SzZrNzc0HyTl27JiwRRS28MM0FhYWgkZXV5e0tLRBfExNTTl06BABAQGYmJhw6dIlMSeFPo/OKSwsbJAsc3NzQkND8ff3x8rKivT0dNrb28W8jY2NOXLkCP7+/mhqapKYmIitrS2lpaXs2LFD9BbavXs3SUlJogO/sbExt2/fZufOnYSGhiKRSDhy5AjJyckkJyeLRpTw4MSf06dP8+abb4qyuUOHDlFXV8e4ceOIi4sjPDyclStX4u3tTVZWFocPH6a5uZnVq1fj5eVFQkLCIJpDhw4Jx4xMJhsgZ+zYsVy7do3ExEQ6OjoYP348EomEo0eP4uzszPTp0zEzM2PKlCnMmDGD2NhYZDIZ5ubmgo/iNI5bt25x/PhxVFVVmT9/PsrKyoP4TJ48mZkzZ5KUlIS2trbgo9BZcbpTcHCw2OucOnVK8DA1NWXKlCnMnDmTuLg4pFKpyKbasWMH8fHxZGRk0N3djbGxMRYWFlhaWorM4R07dhAXF8e1a9fo7u7G1NRUdP8HBvB5mEZDQwNfX1+8vb0fS2NgYICDgwNqamqDZHV2duLm5iYcPo2NjYJHeno6XV1dmJmZYWhoKIIxj86pq6sLExMTzM3NBzky/8z4v26D39nZKerqtLW1kclkWFlZUV5ezu3bt/Hy8nrs9Vu3buHn5/dYHmVlZX9IU1FR8UQaa2vrf4ssGxubP8VHMW8/Pz8RkXr99dd57bXXxJFGiu7Df7QZVqT+Kja6D9N0dXXh4uIi6hAfR+Pq6jqAj0KWYsOskKX4MD5O57t37zJlypQnOi2exOPIkSOD5v2wI+HChQvCkfBHulRWVuLn5ye8kiNGjMDc3FycdFBZWYmGhgZ+fn5P3AwrOqgPdR1g3bp1LFu27LE8Ht6Y/5GcZ599dkh9m5qaHqvv45wWj+NTUVExJB+FM0FxvNPHH3/M9OnTh+Rx9+5dwaOjo0NEQGQyGX5+fowePZra2lpKS0uZMGHCACdAVVUVJ06c4JNPPiE9PV3UVr/yyisYGRnh4eHBtGnTkMlkxMbGMm7cOHH++yuvvIKxsbGgkUqlovbuYZqH+airq3Px4sVBfB6mURwF+CRZCj4uLi5cu3ZNXB81ahTTpk1DVVWVmJiYJ8pRRNKeJEcikQypr7GxMZ6enkybNg1NTU0uXbrEuHHjUFVVZeTIkSQnJ7NixQoSExP5r//6L5KSkuju7hZNWBU0y5cvJz4+np07d5KcnCyOYHrcdcURYf39/Xh4eAiauLg4du7cyZUrV54o57/+678GyHmcLk/SVzGnK1eu0NPT80Q+/11ZD2OXkJAwaE719fUkJiaKtUVVVZXIyEgCAwPZsGEDo0aNQl1dXdBIpVKUlZXF5mrjxo14enoOoJHJZANoPv7440E0j/L59NNPh5SloqIi9Pn888+xt7enoKBAyFFRUXkij0fn9Nlnn/3hnD7//PM/nNM//vGPx8p6VB9NTU1xjxTNsr788ktGjRpFSEgIXl5e3Llzh7a2NqZMmYKZmRleXl7MmjVLnFvs7u5Odnb2Y2lKSkqQSCS0tbUxderUAdcLCwupqakZkseYMWOeKMfc3FzQFBQUDMlH0c9DQfNH+paVlVFXV/dEWXl5eUPKUmy0Z82aRXFxMVVVVXh6eiKVStHS0mLRokWEhYWxZ88eUlJSMDAwwNraGolEImiefvppjh8/zu7du0lNTUVfX/+JNIpTgBSnGw1Fc/Xq1cfKCg0NZc+ePaSlpT1WVmho6AA+tra2/1vmpNDlcfoqZCnmraC5ceMGzf+rvWuNiuo6o3uY4f0aBof3QwkoIuALUVQwGrLMUpvmqUk0iWmq6artMo8mK00MG/MPxAAAIABJREFUaUzWMrar1aQ1qY2oqbFpNAqiJIoRBZEQbDAgiCgGEIIQYEDewzxOf5h7AwpzL8xhuDOc/cvFt93n29/R4X5n7v1uezuWLFmC4OBglJSUQKPRICAgAFu3bsXq1asHcIKCgvDdd9+htbWV50RFRQ0a9/f3R0pKCp588skhNfz9/fHuu+8Ouk5xcTE0Gg0CAwMHzYV7bNWUzkg8/fnPfx5yLU5ny5YtA3zfnsuWLVuwZs0alJWVoa2tDcnJyWhpacHly5exc+dOtLW1obCwEAsXLhzAaW5uRnl5OXbu3Imuri6eA2DIZjgvLw/u7u44ffr0oPEzZ87wr+wbTOPee+9FTk4O35gPxrnnnnuQl5fHH1R5enrif//7Hz8jihACd3d3HDlyhJ/j0l/H19cXixYtwr333ovs7Gx+BtZgOty320ql8g4d7jAhOTkZubm5cHNzQ2Rk5JAaXl5emDJlClxcXFBYWMh/Nubl5eGrr77Ct99+C5VKBbVaPYATFxeHvLw8ZGVl4cKFC1CpVJgwYcKQnKKiInh5eZnUEbuWl5cXQkND+ficOXNw7tw5kxqzZ89Gfn4+Tp48yXOG84o8YBw2+P7+/ggKCkJpaSkqKytx9epV5Ofn4/z583jyyScRGxtrMs6dptgih/tW29XVlR8Mxt050P9ZtqGa4QULFgzJ+eSTT3Djxg1BjpAOt9b8+fMBYMicExISIJPJBJtuUxpCvoejww038fPzw9SpU/mpyampqcjNzcXGjRvh7e0t2AxHR0cLNrpiGnMxTfdI87390IKGzsqVKwU1AgICMG3aNISFhcHX1xeBgYH44osvcPToUaxduxZqtXrQQ4AZM2agsbERtbW1CA4OxnvvvQdCCBwdHaFSqRAYGIht27Zh7dq1UCgUqK2tHZSzfft2PP3000NygoKCROkIcTidZ5991iLriNUBbj2fplKpsGjRIqxYsQKPP/44tFotcnNz+ceFBuP09vbynKHiZ8+exbJlyyCTyaisY06+o7GWUFyhUPDzRebPnw+VSoWcnBw4OTmhrKwM69atM5tz6dIlKjplZWV47rnnRj1fWp6G4sTExCAsLAxKpRIff/wxnnnmGXh4eODYsWM4c+YMP6/D09MTFy5cQENDAxYuXAh3d3dkZmYOymlsbMSyZcsG1fjuu+9EaQhxxOhYcq3+OtybR5YsWYJf/vKXWLFiBerr69Hd3Y3p06fDaDTyrwnrz+EGmJri1NfXo6enR5BDay2OM9qehsNxdXVFeno6AgMDERAQAK1Wi2vXrvGvEY6Li4OLi8ugnMuXLyMsLAx33303Dh8+jKCgoDs0wsPDTWoMZx1zdWivZcp3f43Dhw8jMjISERERWLBgAdzd3flvZefPnw9XV1ccOnTIJId7m4+pZjg+Pn7IuIeHByIjI0U15kNxMjIy4OnpicjISPj4+KChoQGHDh1CUVERNBoNcnJyUF5ejhdffBEKhcKkDte8m6PD5ZyUlGRSg3vkTKfT8f8Xpk+fzt8N5e/vz8954jiLFy9GbGwsgoOD0djYCD8/P5McMTqmOFw+jY2N/Iyz4WgsWbLkDs5gj02bwrh7Bh+49fwFNx1eq9Wiq6sLd911F+655x5RcVvm9IfBYIBMJrtj4E1dXR38/f0HDMq4fRiNJTlCOdPQoKnT/+9t3boV3333HT799FM+VlBQgFmzZsHe3h4dHR145ZVXUFdXh23btiEiIkIwLkZDLIdGvrR1TGn0Bzfh2MfHB48++ij/80uXLg14pecXX3yBgwcP4uWXX0ZUVBROnz6NkpISdHd348qVK1AqlYiNjcUzzzzDP5MpJQ731oGxzoV7nlKv10Or1Q46NIjbu6E43K8jg8EwYg1r5IjxTQjhB6pxryDbu3cvtm/fjg0bNmDdunX8c8pS4XBD5qSQi1hO/2FzwK1np8+ePYuYmBisW7cOBoOBf56ypqYGbW1tuHLlCgICAvD8888jJCQEhBDodDqTHK1Wi2PHjpmlYa0c7rVtAIb8/anVaq2KI6Vcent74eDgwMeee+45FBYWIiMjA8HBwSCEQKvVmuT09PTA0dHRLA1r5IjxffvAx5SUFDQ2NuK1117j54+I4QC3nsHPzs6GWq1GTEwMmpubkZ+fj9TUVDg6OpqMc4OoaXA4tLe34/Tp06iqqsKUKVMQGhrKXy9ZWseUBofbaz3YwEIpcWitIwbjqsHnBnv0B3dRKiZuqxwu3n/itFiYamJHkzPSnGlojESH43D/3TiORqNBXV0dP5CmP4QaWTGN7kg5tPKlobN9+3ZBjcHWEfNvarBDAJ1Ohxs3bqC5uRmEENjb2yMyMhIODg78B6+UOHq9XjK59N8fDrdPzR3s4qc/RyhuqxwxGv1BCEFbWxv+8Ic/YNOmTZg0adIdB45S4kgpF1Oc2z/Dz58/D61Wi5kzZ8LV1ZXfp56eHvzwww/Q6/X885/9B8cBEOTQ0LA2zu3/zgkhIITcsTfWxJFSLv3B/ZvPz8/HkSNHsHXr1jv+vhCHhoY1csRoALcOWwoLC+Hr6zvkkFUhjlAjK6bRHSknIiJiwBBWMRgtncDAwEGvCQeDXq+HnZ0d7OzsBt0XqXForTMskHGC2tpakpqaSlpaWu6IGY1GwbgYDWvkmIr3R0NDAyGEEIPBwGuPFUdMzjQ0aOkMdy2j0ThgrZaWFlJcXCwYF6MhhkMrXxo6J0+eNKu+/fUGW0ev1xODwUDOnz8vmKeUOFLK5XaOwWAYEYeGhjVyhqtx++cQ9+9aShwp5UKDw/0sOzv7jp8Ph0NDwxo5t8fF1FfqHCnlIoaj0WiI0Wgkp06dGpLT0tJCsrOz+Z+PRMMaOTR8cz8T2idCCOnr6xv052LjNDknT54kv/nNb8jp06dJX18fMRqNd/w9S+nQykVKHFrrjATj5hl8mUyGyspK7Nu3DxqNhp98yJ3SCcXFaFgjx1ScOz2qq6vD8ePH+WnXg50qWZIjlDMNDVq5mOIYDAY+bmotZ2dn6HQ6k3FfX19BDbEcGvnS0lGr1YIaptbh/h8MtQ4XP3/+PP+6vdtfv8WhsLBQMhwp5XI7h7u1ebgcGhrWyBmuxu17wL3+UUocKeVCgwPcer1aXl4e2tvbMXHixEF/HwhxaGhYI0dKuYxXT87OzoKcnp4e5OXloaOjY8Qa1sih4VvMHnA4ffo0/vKXv8DNzY2f+K7X6/m7tYTiNDlhYWH8K4Xlcvkdj6FaUmckGnK5fMD1ttQ4tNYZCcZNg+/o6IjY2FgkJyejqqoKTU1NA95HKRS3VY4YDXOa2NHgCOVMQ4OmzlAc7oDF1FpcI2tnZ2dWozscDo18aek4OTkJaphaR2gvuUMAT09PfPPNNzh48CBkMhkmTrz1mrT+ey0ljpRyYZ7Gznf/QywpcaSUi7kcbh+cnZ3h5OSErKwsnDp1Ct7e3vyjb+Sn2ymFOC4uLmZrWCPHFn1bkycx/4aNRqNJT2I1rJFjru/h7BMg3MiKaXRpcYBbr1i2t7dHWloaCgsLoVar4e3tPSY6w9Xw8/O7oxGWEofWOiPBuGnwyU/PKSkUCv7VTp999hkcHBwQFhYmGBejYY0cMRpSOpAQ44mGBq1czF2La2TFNMu0ODTypaVjifoCgLu7O+Lj4zFr1ixcunQJ3d3dCA4OHrDXUuJIKRfmaex89z/EkhJHSrmYy+m/Dz4+PkhKSoJKpUJxcTGcnZ3h7e09LA4NDWvkSCkX5ml8eZKab0C4kRWK0+Rwec+fPx/d3d0oLi6GWq2Gp6fnmOjQ0JASh+Y+DQfjpsGXyX4enKNUKrFgwQJMmjQJWq0WoaGhgnExGtbIEaMhpQMJMZ5oaNDKhdZaUqqvJXUsVV+DwQBCbr2qhRCCjIwMZGRkYPr06XB3dwcASXGklAvzxHyPB08cRyaTQaVSQaPRYN++fbh8+TISEhLAQYhDQ8MaOVLKhXkaX56k5puDUCMrFKfF6X99FB4ejvr6ehBCEBQUZHEdWrlIjUNrnWGBjGPo9XrS29s74ritcsRolJeXk9zcXMlwhHKmoUFTh8ZaUqqvJXVo1vfMmTNDxi9evEgIGXrw2VhwpJQLLY6UcrEkR0q50OJIKReanKFgNBpJZWUl/+eRcGhoWCNHSrkwT+PLkxjOaK9jNBoHfPZkZGSQgoIC0XGanMFw++fiWOqMRENKnNHcJ1Ow+QZfr9cTQghpamoi1dXV5Pr166Sjo0N03FY5YjRMYSwOJMzJmYbGcHVGu8ZSqi9tna6uLkENGuucOHGClJSUkJaWliEv9LOzsyXDkVIuzBPzLeVcaHIIIaSnp4ecPHmSGI1GotfrB518LMShoWGNHCnlwjyNL09S820Kpj5/xMSHw+F4ra2tJDc3l5SWlpL29nZxiVLW0el0VHKxJg6tdUzB5m/R556xe/PNN3HgwAGUlpaiubkZ7e3tUCqVcHFxMRl3cnIS1LBGjhjfhp8GEDU3N6OpqQkdHR2Qy+VwcHCAnZ0dFAqFRTlCnuzt7c3WEOub1j4JrSWTySRTX5q1EdLh3qc6mvXt6enBxx9/jLKyMlRVVaGzsxOE3Hq3OzfNvKurC7t375YER0q5ME/M93jw1B/19fXYv38/QkND4ePjM+iQKSEODQ1r5EgpF+ZpfHmSkm9uYF9bWxvOnz+Pzs5OODs78581hBCTcZlMJqghlsM91vjaa6+hrq4O//znP2EwGODl5QWVSiUqX1o63LWcublIiUNrL82BTTf4Go0Gzs7OAIBjx45hz549UKlUuHbtGk6dOoXo6Gio1eoh4wsXLoROpzOpYY0cMb7d3d0ldSDR3d0t6NvDw8NsDTG+xeiI2Scxa1nqAMqStRHSIYTAy8tr1Ovb1dWFNWvWIDQ0FF1dXTh37hyKi4tx/fp1AEBAQABqa2uxcuVKSXAMBoNkcmGemO/x4CkgIAAcPD094e7ujq1bt6K1tRXR0dFQKBT8hZwYDg0Na+RIKRfmaXx5kpJvoWZYTLNMg8Plk5+fj4qKCmzZsgXnzp3Dgw8+iE8++QSLFy8eMDB5NHW8vLyo5EKrNrQ4tNYxB3bCFOtFWloaoqOjsXLlSuj1egBAfHw8Nm7ciO3btyM/P99k3N/fX1DDGjlifGs0Gr6OWq0WBw8exBNPPIGOjg7s378fPT09FuUIeer/bctINcT6prVPQmvduHFDMvWlWRshnfT0dIvUNy0tDb29vSgoKMDEiROxefNmPP300+jt7UVjYyMA4NChQ5LhHDp0CD09PZLIhXlivseDJ+DWNzF6vR61tbWYPHky3nvvPVRUVODLL78E8PNFmhCHhoY1cqSUC/M0vjxJyTchBACQn58PuVyOzZs3Izw8HPPmzUNqaip/HTNU3PDTEFAaHC7npqYmqNVqvPfee1i6dCkUCgW6urogl8stpmM0GqnkIiUOrb00FzLCrWKj0Gg0yM7Oxp49e3Dz5k3cd999uP/++xEbGwuj0Yi2tjaTcTs7O0ENa+QI+d6zZw+2bduGqKgoTJgwAR988AFf0+7ubri4uCA1NdViHKG93LVrF7Zv326WhljfYnTE7IHQWp9++qlk6kuzNmJ0LFFfFxcXdHZ24s0330R1dTW0Wi3uvfde3H///Zg0aRLPlRJHSrkwT8z3ePAEAOnp6fjmm29QW1sLZ2dneHp6Ijc3FytWrMCmTZtgZ2cnyMnIyDBbwxo5tuibebIdjiV9A8CRI0dQUVEBR0dHBAYGYsqUKfjoo4/w/vvvi4rT5PT09CA1NRXZ2dmIjo5Ge3s7Vq1aNWDiv6V0aOUiJQ6tdUaM4T+2bx3gBnBptVpSWVlJent7yZUrV8iWLVvIwoULSUNDg8l4U1OToIY1csT45tDS0kIOHjxIli1bRhYsWEDefvttUlxcTAj5efiDJTjcoBKhnGlo0NARs09iayyl+lpCR6/XE4PBMOr11Wq1xGAwkH//+9/k22+/JYQQUlFRQd544w3y3HPP8fqEEElwpJQL88R8jwdP/dHa2krKysoIIYTcuHGDHwr1pz/9ieTk5Iji0NCwRo6UcmGexpcnqfkmhJDu7m7y97//nTz44IPkjTfeIBs3biT5+fmi4+ZyuGvC3t5e0tHRQXJycsj+/fvJ8ePH+c9BS+nk5eVRyUWqHFrrjBQK848IpI2dO3fi2rVrWL16NQICArBo0SK8+uqr/O0PQ8UB2CRHrIZcLoebmxtmzpyJX/ziF7h+/ToOHTqEDRs2IC0tjX9G2pIcIU/maAzXN419MrXW559/Dl9fX0nUl3ZtxPge7fqmpaVhwoQJyMrKQn19PWJjYzF58mRs3ryZ/+xQKG59PEqFYzQaJZML88R827on7tbRqqoqHDhwAB4eHmhtbcXUqVPR2toKtVoNDw8P+Pr64tq1a4NyvL294enpib6+Pnz44Ycj0rBGji36Zp7GPl9r9O3p6cnPvNJqtTAYDIiNjYVKpYK3tzfUajVmzJhhMj5r1iz+zkVzOeSnm7bfeusttLa2IjIyEsHBwXByckJsbCz/2WcJnZkzZ1LJRUocWntJAzY7ZI+7HWbz5s3Yu3cvgoKC0NnZiW3btiE6Ohre3t4m415eXoIa1sgR45sQAjs7O3zwwQc4fvw4fH19oVKp4OXlhZSUFLi4uFiUI+RJqVSarSHWN619ElrL2dlZMvWlWRshHTc3N4vU18XFBT09Peju7kZVVRW++uorlJSUQCaTITg4GMCt5+akxOnt7ZVMLswT823rnrjPkJ07d8LR0RHV1dVIS0tDdnY2PD09ERkZialTpyIoKGhIzpQpUzBt2jSkp6ePWMMaObbom3ka+3yt0XdUVBQCAwMhk8mQkpKCjIwM6PV6eHt7w8PDA3PmzOGHyJmKc59Z5nJkMhk0Gg0OHz6MV155Bb29vaipqcHFixcxY8YMuLq6WkxHLpdTyUVqHFrrmAubHrJ38+ZNxMbG4uuvvwZwayLujz/+yE/GFYrbKkcozr3a4/jx4/jrX/+KOXPmQCaTYffu3fj+++8tzhHKmYYGrVxorSWl+lpaZ7Tre+3aNQCAo6MjYmNjkZycjMceewxKpRKlpaUAwJ9OS4EjpVyYJ+Z7PHgCfv6SoLy8HC+++CJCQkLw/vvvw97eHj4+PgAApVJpkmNnZwcPDw+zNKyRY4u+mSfb4VjSt4eHB98MNzQ04MUXX0RwcDBqamqQlZWF1tZWwTgAKhzu7seCggLMmjULEREReOihh/D73/8eTz75JH+ngSV0mpubqeQiNQ6tdWjAJm/RJz+9uqGxsRGzZs1Camoqdu3aBW9vbyQmJvIT14eKOzk5CWpYI0eMbw79G6iFCxcKNlmjxRHjm5YGDR1aa0mtvpbQ8ff3p/L/UmidwMBAAMBvf/tbBAUFobm5Ga6urtiwYQN/hwsHKXC4CbxSyIV5Yr7Hgyfg1nVEV1cXZsyYgcOHD6OpqQnh4eHQarWYO3cur9HZ2WmSIxS3VY6UcmGexpcnKfnmHhfs38hGRERAr9ejsrKSfx3aUHG1Wi2oIZbD4cqVK/jvf/+LyspKPPHEE4iPj0dkZCQIITAajRbR8fPzo5ILrdrQ4NDaS1qwyVv0ZTIZ+vr6sGnTJrz66qtITEzE5MmTERUVhRUrVsDBwcFk3N7eXlDDGjlifHMN1PXr12FnZ4cDBw4gPT0dZ8+exbRp05CUlGRRjpAnhUJhtoZY37T2SWitxMREydSXZm2EdBYtWjTq9Y2KisKiRYvw9ddfo6KiAm+++Sbi4+NRVVWFzs5OREdH839fCpxp06ZBJpOhoKBgzHNhnpjv8eApOjoae/fuxc2bN+Hv74+EhAS4urriypUreOeddzBz5kwsXryYf3vHUJyamhpoNBoEBASMWMMaObbom3ka+3yt0TfXoAJAZmYm/vOf/6C0tBQqlQrBwcGYMGECZDIZZDLZkHHuUSFTGmI4RqMRMpkMbW1tmD59On71q1+hu7sbu3fvxocffoiHH34Yjo6OFtHhDlFv3rxpVi60akOLQ2svZTIZnV6YcPeq2Qj6//J+++23sWnTJsTExMDd3V1U3FY5YjQ49PX14Xe/+x3+9a9/oaWlBVVVVTAYDIiJieFfhWYJjrOzs6icaWjQ0KFZYynV1xI60dHRcHV1HfX6Tps2DW5ubti1axfkcjmeeeYZAMDevXtRW1uLN954A3q9HgqFQhKc119/HQCwe/fuMc+FeWK+x4OnZ599FsuXL+dfWRQSEoIFCxbAy8sLOp0OPj4+6O3tNckxGo388M/IyMgRaVgjxxZ9M09jn681+lapVPy3tW1tbSCEwMHBAUePHkVaWhqamppw5MgRuLu7DxnPyMiAq6sr31Cbw+HmG504cQL/+Mc/EBMTg+XLlyMhIQHNzc3w8fHhr7EspWOuBq3a0ODQ2kuuvjRgc9/gcycfjY2NsLOzQ0VFBUpLS3Hx4kX4+fnBw8NDMC5Gwxo5QnHuP1RhYSGOHTuGSZMmISAgAJMmTUJQUNCAb0ctwRHy5O7ubraGWN+09kBoLe6OBCnUl2ZthHQcHBwsUl9unV27dqG8vBw6nQ4ajQb5+flYtWoV/9ycTCaTBMfX1xeEEKSmpo55LswT823rnlauXInw8HBMmzYNPT09mD17Nvz8/HDu3Dnk5ubCwcEBs2fPhoeHB6Kjo9Hd3X0Hx97eHnfffTeio6NHrGGNHFv0zTyNfb7W6DsuLg7Az3M8cnJy8Mc//hEVFRWIi4vD888/j2XLlvG3dA8V9/Ly4q97zOVwCA8Px5IlSyCXy3Ho0CHs2LEDiYmJUKvVFtcxV0NKHFp7SRM21+ADt555UalU8Pf3R2BgIBwcHKDRaBAbGwtXV1fBuBgNa+QIxaV4IGEqZ+6kyxwNsb5p7YGUDqAsWRsxOqNdX7VaDblcjqtXr+LRRx+FXC7H/v37kZWVhZqaGoSFhcHR0RGOjo6S4ISGhsLOzg7Nzc1jngvzxHyPB09hYWFwcXHB9OnTYTQakZaWBgBYunQpfH19MWHCBISEhMBoNCI0NNQkJygoCIQQszSskWOLvpkn2+FY0jd3PWKqkRUTN5fD3T7e2tqK5uZmBAQEYMqUKYiIiEBfXx+WL1/OP0ow2joLFy6Ej4+P2bnQqg1tDq11aMCmbtHnbof57LPPkJ6ejuDgYMycORMhISGws7NDfHy8yXhCQoKghjVyxPjuX0OtVou6ujq0traioaEB169fH/DthyU43t7eonKmoUFDR8w+ia2xlOprCZ1HHnkE/v7+o17fo0ePIjk5Ga2traiuroZCoYCTkxPq6+uRlJSE5uZm5Obm4uGHH5YE58CBAwgPD0dYWNiY58I8Md/jwVNzczOCgoKwceNGALde/ZeXlwdPT0/MmTNn0OsOIQ4NDWvkSCkX5ml8eRLDGe11uLsJW1tb0dnZiaCgIMhkMlRUVODIkSN4/vnn4eDgMGT8hRde4O/oNJdjb28PAEhPT0dFRQUiIiIQGRmJb775BvX19Xj99dcF86WtY64GrdrQ4NDaS66+tGBTU/S5U58TJ05g8+bN+Oijj3DkyBF0dHRg06ZNgnExGtbIEaPBNVCff/75HQ2Uj48P33haisNhqJxpaIj1LUaHRo25wSNSqC/N2gjpcNPzR7O+Hh4eaGhowLfffot3330X3t7eWLduHfbt24e+vj44ODigq6sL77zzjiQ4Op0O7e3tuHLlCtavXy/5fMerp/Hq2xY9OTg4ICsrC5WVlUhNTcVdd92Fy5cv49KlSygvL0diYiJSUlKQlZWFqqoqKBSKQTnz5s0zGRejYY0cW/TNPNkOx5K+gZ8fF87JybmjkdXpdPzjgkPF+zd75nA6OjqQm5uLuXPnIiwsDDqdDjU1NSgpKUFtbS3WrVsnKl8aOh0dHcjMzDQ7F1q1ocWhvZe0YHO36F+/fh1FRUVYvXo1cnNz8cEHHyAzMxNr1qyBi4uLYFyMhjVyhOLcs0J/+9vfkJKSgqKiIhQWFuLUqVNISkpCcHCwRTlCnrjb883REOub1h4IrRUSEiKZ+tKsjRid0a7vkiVL8Pjjj+PmzZsoLy/HDz/8AKVSiYSEBMjlchgMBjg4OCApKUkSHLlcjsTERLS3t495LswT8z0ePPX19WHNmjUoKyvD1atXodPpkJSUBKVSiZCQECQnJ0OtVmP16tUoLS0dlLNkyRK89NJLKCkpQWVl5Yg0rJFji76Zp7HP1xp9+/n5obm5GVlZWfD09ISjoyOMRiNqa2tRVFSE0tJSLF26FBcvXhwy/sgjj8DFxQUnTpwwm6PT6bB7926cOXMGPT09iI2Nxbx58zBr1iysWrUKoaGh0Gg0FtFJSEhAZmam2bnQqg0NDq29DAoKGknLaxI20+B3dXXBwcEBzs7OaGpqQkFBAQwGA4xGI65evYrly5ebjK9cuVJQwxo5YnxzkMqBBDddUihnGho0dMTsk9gaS6m+ltB56KGH4OnpaZH6uru7IyYmBkVFRdixYwfmzJmD+Ph4/pt/mUwGuVwuGY5CoZBMLswT823rnhQKBe6++25+unZDQwPa2towb948LF26FAEBAZDJZIKcRYsWma1hjRxb9M082Q7HUr4BoLq62mQzrNfrBZvlqqoqKhy1Wo0HHngAM2bMQHV1NTIzM5GZmYng4GBEREQAgMV0pk+fTiUXKXFo7eVowCYa/K6uLrz00ku4ceMG7O3tkZycjDlz5qC4uBj79u3DqlWrsGPHjiHjTz31FPz9/U1qWCNHjO/w8HDJHUiI8W2uhhjfYnOhtZZU6kurNkI65eXlOHfunEXqyx0CKBQKxMfHY+rUqSgrK4O7uzsCAwMHfJ5IiSOlXJgn5tuWPclkMnh7eyMiIgJ33XUXQkJC0NXVhaNHj6Kurg5xcXGiODQ0rJEjpVyYp/HlSUq+AQg2w2KaZVocg8EAOzs7eHp6Yvbs2VixYgUmT55ew9IiAAAEv0lEQVSMgwcPYu7cuXBycrKYDq1cpMShtc5owCaG7JWWlmLdunXw8/NDdHQ09Ho9IiIiEBUVhZkzZ+Lq1asm446OjoIa1sgR45s7HJk9ezbi4uIQHR0NuVyOHTt2ICsrCxs2bEBiYqLFOEFBQSZz1uv1ZmuI9S1GR8w+Ca3161//Gl9++aUk6kuzNkI6999/P3bv3j3q9d2wYQPuu+8+AD8PvgGAjz76CN9//z22bNky4PNEShwp5cI8Md/jwVN/6PV6tLS0QC6XY8KECTAajfyjQGI5NDSskSOlXJin8eVprH0TQiCXywfwLl68iD179iAlJQXu7u4m40qlkr/zyFwOB47b29uLCxcuYPv27fjss88GxCylY66GlDi09nI0YBMNPnDrtViffvoplEolpkyZgoqKChQVFWH+/Pl47LHHBONiNKyRIxSX0oGEo6OjoKfo6GizNcT6prUHUjqAsmRtxOhYor5cvoOB+4U92C9uKXKklAvzxHxLOReaHAYGBobhwlQjKyZOk8Ph/fffx40bN5CYmIhly5aNqY65GlLi0N4nGrCZBh8ALly4gAMHDkCpVOKRRx4BIQQeHh78tG+huK1yhOJSOpAQ44mGBq1caK0lpfpaWscS9WVgYGBgYGBgsDRMNbJi4jQ5RqMROp3O5BcfltKhlYuUOLTWoQGrb/D7+vrQ19fHT1Xv7u5GQUEBmpubkZycDDc3N5NxlUolqGGNHDG++0MKBxJKpVJ0zjQ0zNURs0/DqbGU6jvaOk5OTlAqlRatLwMDAwMDAwODJSHUyIppdGlxaORrSR1L1oYGx5L7JASrb/A3btyIzs5O2NvbY+7cuaiqqsKFCxfQ0tKCtWvXoqyszGR8/fr1ghrWyBHjW0oHEiqVStDT2rVrzdYQ65vWPknpAMqStRHSeeuttyxS39sPARgYGBgYGBgYGBhsGYqxTsAc/Pjjj6ipqeGbpLq6Ojz77LNQKBRobW2Fq6srvvjiiyHjEydOFNSwRo4Y3wDw8ssvD9lAtbW1Yf369RbjPPDAA4K+aWiI8S1GR8w+iVnL1EGMpetLqzZCOnV1dRar7/r16y33gcTAwMDAwMDAwMAwxrD6b/A7OztRWVmJ6upqlJSU4ObNm4iKisLixYsRFhYmGBejYY0cofiPP/6I9evXw83NDTKZDJMnT8ZTTz01oIHq7u62GMfNzc1kzm5ubmZriPUtRkfMHgit5erqihdeeEES9aVZGzE6AEa9vly+DAwMDAwMDAwMDOMFVt/gc9DpdGhtbUVlZSXOnj2LuLg43HPPPaLjtsoxFZfSgYQYTzQ0aOVCay0p1XcsdEa7vgwMDAwMDAwMDAzjCTbT4PdHX18fFArFkK+8EYrbKmeouJQOJMTkTEODpg6NtaRU37HSGc36MjAwMDAwMDAwMIwH2GSDzzBySOlAgla+ltShsZaU6itFHamsw8DAwMDAwMDAwCA1sAafgYGBgYGBgYGBgYGBgcEGwL7iYmBgYGBgYGBgYGBgYGCwAbAGn4GBgYGBgYGBgYGBgYHBBsAafAYGBgYGBgYGBgYGBgYGGwBr8BkYGBgYGBgYGBgYGBgYbACswWdgYGBgYGBgYGBgYGBgsAH8H6fBuumXOfvkAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Ongoing','Hospitalized'],\n",
    "               state    = 'Nacional',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Deaths',\n",
    "               state    = 'Nacional',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Confirmed','Suspicious'],\n",
    "               state    = 'Nacional',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Actives',\n",
    "               state    = 'Nacional',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Deaths','Hospitalized'],\n",
    "               state    = 'Nacional',\n",
    "               trim=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Ongoing','Hospitalized'],\n",
    "               state    = 'OAXACA',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Deaths',\n",
    "               state    = 'OAXACA',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Confirmed','Suspicious'],\n",
    "               state    = 'OAXACA',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Actives',\n",
    "               state    = 'OAXACA',\n",
    "               trim=40)\n",
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Deaths','Hospitalized'],\n",
    "               state    = 'OAXACA',\n",
    "               trim=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#os.remove(\"ChangedFile.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imageio.mimsave(f'results/{state}/{dtype}_discrete_{state}.mp4', dis_images)\n",
    "        \n",
    "    os.remove(\"ChangedFile.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Hospitalized','Ongoing'],\n",
    "               state    = 'Oaxaca',\n",
    "               trim=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Actives',\n",
    "               state    = 'OAXACA',\n",
    "               trim=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     ='Actives',\n",
    "               state    = 'Nacional',\n",
    "               trim=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Confirmed','Actives'],\n",
    "               state    = 'Nacional',\n",
    "               trim=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = ['Confirmed','Suspicious'],\n",
    "               state    = 'OAXACA',\n",
    "               trim=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_animation(data_dir = data_dir,\n",
    "               dtype     = 'Deaths',\n",
    "               state    = 'OAXACA',\n",
    "               trim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_dir = r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\pass'\n",
    "pass_dir = os.listdir(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\pass')\n",
    "dates_pass = {date[4:6]+'-'+date[2:4]+'-'+'20'+date[:2] : date for date in pass_dir}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtypes_states = {\n",
    "    'Defunciones': 'Casos_Diarios_Estado_Nacional_Defunciones_2020',\n",
    "    'Confirmados': 'Casos_Diarios_Estado_Nacional_Confirmados_2020',\n",
    "    'Negativos'  : 'Casos_Diarios_Estado_Nacional_Negativos_2020',\n",
    "    'Sospechosos': 'Casos_Diarios_Estado_Nacional_Sospechosos_2020',\n",
    "    'Activos'    : 'Casos_Diarios_Estado_Nacional_Activos_2020',\n",
    "    'Hospitalizados': 'Casos_Diarios_Estado_Nacional_Hospitalizados_2020',\n",
    "    'Ambulantes': 'Casos_Diarios_Estado_Nacional_Ambulantes_2020',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtypes_states = {\n",
    "    \n",
    "    'Ambulantes': 'Casos_Diarios_Estado_Nacional_Ambulantes_2020',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def create_data_from_patients_files(actives_window = 14):\n",
    "    result = {}\n",
    "    for state in cdns_states:\n",
    "        result[state] = {}\n",
    "        for dtype in dtypes_states.keys():\n",
    "\n",
    "            result[state][dtype] = {} \n",
    "            base  = pd.read_csv(os.path.join(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\legacyCovidMexico', f'{dtypes_states[dtype]}0518.csv'))\n",
    "            state_data = base[base['nombre'] == state]\n",
    "            for today in dates_pass.keys():\n",
    "\n",
    "                result[state][dtype][today] = []\n",
    "                \n",
    "                if dtype == 'Defunciones':\n",
    "\n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['day_of_death'] != '9999-99-99' ]\n",
    "                    patients = patients[patients['result'] == 1]\n",
    "                    patients = pd.to_datetime(patients['day_of_death'].copy())\n",
    "\n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "\n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                    \n",
    "                if dtype == 'Confirmados':\n",
    "\n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 1 ]\n",
    "                    patients = pd.to_datetime(patients['onset_symptoms'].copy())\n",
    "\n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "\n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                    \n",
    "                if dtype == 'Negativos':\n",
    "\n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 2 ]\n",
    "                    patients = pd.to_datetime(patients['onset_symptoms'].copy())\n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "\n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "\n",
    "                if dtype == 'Sospechosos':\n",
    "\n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 3 ]\n",
    "                    patients = pd.to_datetime(patients['onset_symptoms'].copy())\n",
    "\n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "\n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                    \n",
    "                if dtype == 'Activos':\n",
    "\n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 1 ]\n",
    "                    patients['onset_symptoms'] = pd.to_datetime(patients['onset_symptoms'])\n",
    "                    \n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients['onset_symptoms']),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    active_patients = {key:0 for key in local_index}\n",
    "                    \n",
    "                    for ind, day_active in enumerate(patients['onset_symptoms']):\n",
    "                        for _ in range(actives_window):\n",
    "                            if day_active not in local_index:\n",
    "                                break\n",
    "                            elif patients['day_of_death'].iloc[ind] != '9999-99-99' and day_active > pd.to_datetime(patients['day_of_death'].iloc[ind]):\n",
    "                                break\n",
    "                            else:\n",
    "                                active_patients[day_active] +=1\n",
    "                                day_active = day_active + timedelta(days=1)\n",
    "                    for date in local_index:\n",
    "                        today_result.append(active_patients[date])\n",
    "                    \n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                \n",
    "                if dtype == 'Hospitalizados':\n",
    "                    \n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 1 ]\n",
    "                    patients = patients[patients['patient_type'] == 2 ]\n",
    "                    patients = pd.to_datetime(patients['admission_date'])\n",
    "                    \n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "                                        \n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                    \n",
    "                if dtype == 'Ambulantes':\n",
    "                    \n",
    "                    today_result = []\n",
    "\n",
    "                    patients = change_df_names(pd.read_csv(os.path.join( d_dir, dates_pass[today] ), encoding='ANSI'))\n",
    "                    if state != 'Nacional':\n",
    "                        patients = patients[patients['treated_at'] == inverse_dict_for_name_states[state] ]\n",
    "                    patients = patients[patients['result'] == 1 ]\n",
    "                    patients = patients[patients['patient_type'] == 1 ]\n",
    "                    patients = pd.to_datetime(patients['admission_date'])\n",
    "                    \n",
    "                    if len(patients) == 0:\n",
    "                        min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "                    else:\n",
    "                        min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "                    local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "                    for day in pd.to_datetime(local_index):\n",
    "                        try:\n",
    "                            today_result.append(list(patients).count(day))\n",
    "\n",
    "                        except:\n",
    "                            today_result.append(0)\n",
    "                                        \n",
    "                    result[state][dtype][today] = today_result\n",
    "                    result[state][dtype][today+'_localindex'] = local_index\n",
    "                    print(f' Done for: {state}-{dtype}-{today} ')\n",
    "                    clear_output(wait=True)\n",
    "                    \n",
    "                    \n",
    "                    \n",
    "                    \n",
    "    joblib.dump(result,'result_hosp.pkl')\n",
    "    for dtype in dtypes_states.keys():\n",
    "        for date in dates_pass.keys():\n",
    "            base  = pd.read_csv(os.path.join(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\legacyCovidMexico', f'{dtypes_states[dtype]}0518.csv'))\n",
    "            data = {}\n",
    "            for state in result.keys():\n",
    "\n",
    "                data[state] = {}\n",
    "                data[state] = result[state][dtype][date]\n",
    "\n",
    "            max_len = max([len(data[x]) for x in result.keys()])\n",
    "\n",
    "            for state in result.keys():\n",
    "                if len(data[state]) != max_len:\n",
    "                    data[state] = [0]*( max_len - len(data[state]) ) +data[state]\n",
    "\n",
    "            today = pd.to_datetime(date, dayfirst=True)\n",
    "            data = pd.DataFrame.from_dict(data).T\n",
    "            index = pd.date_range(start=(today - timedelta(days=len(data.columns)-1) ), end = today)\n",
    "            index=[str(date)[8:10]+'-'+str(date)[5:7]+'-'+str(date)[:4] for date in index]\n",
    "            data.columns = index\n",
    "            data['nombre'] = data.index\n",
    "            data['poblacion'] = base['poblacion'].values.copy()\n",
    "            data['cve_ent'] = base['cve_ent'].values.copy()\n",
    "            order = ['cve_ent','poblacion', 'nombre']+index\n",
    "            data = data[order]\n",
    "            data = data.reset_index(drop = True)\n",
    "\n",
    "            data.to_csv(f'faltantes/{dtypes_states[dtype]}{str(today)[5:7]+str(today)[8:10]}.csv', encoding='ANSI',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "create_data_from_patients_files()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = pd.read_csv(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\legacyCovidMexico\\200615COVID19MEXICO.csv',encoding='ANSI')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a= change_df_names(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_hosp = a[a['patient_type']==2]\n",
    "_nhosp =  a[a['patient_type']==1]\n",
    "_hosp = _hosp[_hosp['result'] == 1]\n",
    "_nhosp =_nhosp[_nhosp['result'] == 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hosp = pd.to_datetime(_hosp['admission_date'])\n",
    "nhosp = pd.to_datetime(_nhosp['admission_date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_hosp = max(hosp)\n",
    "min_hosp = min(hosp)\n",
    "max_nhosp = max(nhosp)\n",
    "min_nhosp = min(nhosp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hosp_index = pd.date_range(start=min_hosp, end= max_hosp)\n",
    "nhosp_index = pd.date_range(start=min_nhosp, end= max_nhosp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patient_data_keys('patient_type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hos = []\n",
    "nos = []\n",
    "\n",
    "for date in pd.to_datetime(local_index):\n",
    "    print(date)\n",
    "    clear_output(wait=True)\n",
    "    hos.append(list(hosp).count(date))\n",
    "for date in pd.to_datetime(local_index):\n",
    "    print('second',date)\n",
    "    clear_output(wait=True)\n",
    "    nos.append(list(nhosp).count(date))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close('all')\n",
    "plt.rcParams['figure.figsize'] = (14,6)\n",
    "plt.rcParams['figure.constrained_layout.use']=True\n",
    "plt.scatter(local_index,hos, label ='sí')\n",
    "plt.scatter(local_index,nos, label =  'no')\n",
    "plt.xticks(rotation=90)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = pd.read_csv(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\legacyCovidMexico\\Casos_Diarios_Estado_Nacional_Hospitalizados_20200615.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = pd.read_csv(r'C:\\Users\\jupol\\Desktop\\TensorTut\\covid\\mex animations\\faltantes\\Casos_Diarios_Estado_Nacional_ambulantes_20200615.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a[a['nombre']=='Nacional']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = b[b['nombre']=='Nacional']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(a.values[0][3:])\n",
    "plt.plot(b.values[0][3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = b[b['nombre']=='Nacional']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.values[0][3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.scatter(b.columns[3:],b.values[0][3:])\n",
    "plt.xticks(rotation=90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close('all')\n",
    "plt.rcParams['figure.figsize'] = (14,6)\n",
    "plt.rcParams['figure.constrained_layout.use']=True\n",
    "plt.plot([str(x) for x in nhosp_index],nos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " patients = pd.to_datetime(patients['day_of_death'].copy())\n",
    "\n",
    "if len(patients) == 0:\n",
    "    min_date = pd.to_datetime(state_data.columns[3],dayfirst=True)\n",
    "else:\n",
    "    min_date = min(min(patients),pd.to_datetime(state_data.columns[3],dayfirst=True))\n",
    "\n",
    "local_index = pd.date_range(start = min_date, end = pd.to_datetime(today, dayfirst=True))\n",
    "\n",
    "for day in pd.to_datetime(local_index):\n",
    "    try:\n",
    "        today_result.append(list(patients).count(day))\n",
    "\n",
    "    except:\n",
    "        today_result.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([str(x) for x in d_hosp.keys()],list(d_hosp.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_hosp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patient_data_keys('patient_type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}