figure0620_barChart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mean state and seasonal amplitude and phase from different current and surface forcing \n",
    "The analysis is based on a box model analyses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xarray as xr\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read regional mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_mean_ts_mlist = {}\n",
    "reg_mean_season_ts_mlist = {}\n",
    "model_list = []\n",
    "\n",
    "syear = 1958\n",
    "fyear = 2007\n",
    "\n",
    "#####################\n",
    "model = 'JRA'\n",
    "model_list.append(model)\n",
    "\n",
    "# JRA \n",
    "varnames = ['srfflux','hcont'] \n",
    "\n",
    "paths = ['/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/regional_avg/',\n",
    "        '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/regional_avg/']\n",
    "\n",
    "files = ['JRA_net_heat_coupler_regional_sum_ts_scpt.nc',\n",
    "        'JRA_heatcont_scpt_400.nc']\n",
    "\n",
    "\n",
    "reg_mean_ts_list={}\n",
    "reg_mean_season_ts_list={}\n",
    "for nvar,varname in enumerate(varnames):   \n",
    "    reg_mean_ts_list[varname] = xr.open_dataset(paths[nvar]+files[nvar])\n",
    "    reg_mean_ts_list[varname] = reg_mean_ts_list[varname]\\\n",
    "                                .where((reg_mean_ts_list[varname]['time.year']>=syear)&\n",
    "                                       (reg_mean_ts_list[varname]['time.year']<=fyear),\n",
    "                                        drop=True)\n",
    "reg_mean_ts_mlist[model] = reg_mean_ts_list\n",
    "reg_mean_season_ts_mlist[model] = reg_mean_season_ts_list    \n",
    "\n",
    "#####################\n",
    "model = 'CORE' \n",
    "model_list.append(model)\n",
    "\n",
    "# CORE\n",
    "varnames = ['srfflux','hcont'] \n",
    "\n",
    "paths = ['/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/regional_avg/',\n",
    "        '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/regional_avg/']\n",
    "\n",
    "files = ['CORE_net_heat_coupler_regional_sum_ts_scpt.nc',\n",
    "        'CORE_heatcont_scpt_400.nc']\n",
    "\n",
    "reg_mean_ts_list={}\n",
    "reg_mean_season_ts_list={}\n",
    "for nvar,varname in enumerate(varnames):   \n",
    "    reg_mean_ts_list[varname] = xr.open_dataset(paths[nvar]+files[nvar])\n",
    "    reg_mean_ts_list[varname] = reg_mean_ts_list[varname]\\\n",
    "                                .where((reg_mean_ts_list[varname]['time.year']>=syear)&\n",
    "                                       (reg_mean_ts_list[varname]['time.year']<=fyear),\n",
    "                                        drop=True)\n",
    "reg_mean_ts_mlist[model] = reg_mean_ts_list\n",
    "reg_mean_season_ts_mlist[model] = reg_mean_season_ts_list "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regional mean processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for model in model_list:\n",
    "    for nvar,varname in enumerate(varnames): \n",
    "        # remove seasonal\n",
    "        da_mean = reg_mean_ts_mlist[model][varname].mean()\n",
    "        da_seasonal = (reg_mean_ts_mlist[model][varname]-da_mean).groupby('time.month').mean(dim='time')\n",
    "        reg_mean_season_ts_mlist[model][varname]=da_seasonal\n",
    "        reg_mean_ts_mlist[model][varname] = \\\n",
    "               reg_mean_ts_mlist[model][varname].groupby('time.month')-da_seasonal\n",
    "        # 13 month smoothing\n",
    "        reg_mean_ts_mlist[model][varname] = reg_mean_ts_mlist[model][varname].rolling(time=13, center=True).mean(dim='time')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read transect current "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_mlist = {}\n",
    "current_season_mlist = {}\n",
    "model_list = []\n",
    "\n",
    "#####################\n",
    "model = 'JRA'\n",
    "model_list.append(model)\n",
    "\n",
    "# JRA \n",
    "trannames = ['180','120','20','-20','400','-160'] \n",
    "\n",
    "paths = ['/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_uo_thetao_yz_-180/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_uo_thetao_yz_120/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_vo_thetao_xz_20/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_vo_thetao_xz_-20/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_wo_thetao_xy_400/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/JRA/transect_scpt/JRA_uo_thetao_yz_-160/']\n",
    "\n",
    "files = ['current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc']\n",
    "\n",
    "\n",
    "current_list={}\n",
    "current_season_list={}\n",
    "for ntran,tranname in enumerate(trannames):   \n",
    "    current_list[tranname] = xr.open_dataset(paths[ntran]+files[ntran])\n",
    "    current_list[tranname] = current_list[tranname]\\\n",
    "                                .where((current_list[tranname]['time.year']>=syear)&\n",
    "                                       (current_list[tranname]['time.year']<=fyear),\n",
    "                                        drop=True)\n",
    "current_mlist[model] = current_list\n",
    "current_season_mlist[model] = current_season_list   \n",
    "\n",
    "#####################\n",
    "model = 'CORE'\n",
    "model_list.append(model)\n",
    "\n",
    "# CORE\n",
    "trannames = ['180','120','20','-20','400','-160'] \n",
    "\n",
    "paths = ['/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_uo_thetao_yz_-180/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_uo_thetao_yz_120/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_vo_thetao_xz_20/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_vo_thetao_xz_-20/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_wo_thetao_xy_400/',\n",
    "         '/storage1/home1/chiaweih/Research/proj3_omip_sl/data/GFDL/CORE/transect_scpt/CORE_uo_thetao_yz_-160/',]\n",
    "\n",
    "files = ['current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc',\n",
    "         'current_ts.nc']\n",
    "\n",
    "\n",
    "current_list={}\n",
    "current_season_list={}\n",
    "for ntran,tranname in enumerate(trannames):   \n",
    "    current_list[tranname] = xr.open_dataset(paths[ntran]+files[ntran])\n",
    "    current_list[tranname] = current_list[tranname]\\\n",
    "                                .where((current_list[tranname]['time.year']>=syear)&\n",
    "                                       (current_list[tranname]['time.year']<=fyear),\n",
    "                                        drop=True)\n",
    "current_mlist[model] = current_list\n",
    "current_season_mlist[model] = current_season_list  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Current processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "for model in model_list:\n",
    "    for ntran,tranname in enumerate(trannames): \n",
    "        # remove seasonal\n",
    "        da_mean = current_mlist[model][tranname].mean()\n",
    "        da_seasonal = (current_mlist[model][tranname]-da_mean).groupby('time.month').mean(dim='time')\n",
    "        current_season_mlist[model][tranname] = da_seasonal\n",
    "        current_mlist[model][tranname] = \\\n",
    "               current_mlist[model][tranname].groupby('time.month')-da_seasonal\n",
    "        # 13 month smoothing\n",
    "        current_mlist[model][tranname] = current_mlist[model][tranname].rolling(time=13, center=True).mean(dim='time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'heat_content_180_-60' ()>\n",
       "array(-3.95019e+13)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_mean_ts_mlist['CORE']['hcont']['heat_content_180_-60']\\\n",
    "            .differentiate('time',datetime_unit='s').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'heat_content_180_-60' ()>\n",
       "array(-5.327659e+12)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_mean_ts_mlist['JRA']['hcont']['heat_content_180_-60']\\\n",
    "            .differentiate('time',datetime_unit='s').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'heat_content_120_180' ()>\n",
       "array(1.260106e+13)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_mean_ts_mlist['JRA']['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'heat_content_120_180' ()>\n",
       "array(-1.297739e+13)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_mean_ts_mlist['CORE']['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = 'CORE'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var7w = +(current_mlist[model]['120']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg4'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg5'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg2'%(box)])\n",
    "\n",
    "var4w = +(current_mlist[model]['-20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg2'%(box)])\n",
    "\n",
    "var5w = +(current_mlist[model]['400']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg11'%(box)])  # PW\n",
    "\n",
    "var6w = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_120_180_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w+var7w\n",
    "\n",
    "totw= reg_mean_ts_mlist[model]['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8w = totw-var1w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time_series_analyses import ts_mean_conf\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var7w_conf=ts_mean_conf(var7w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2+var7w_conf**2)\n",
    "totw_conf=ts_mean_conf(totw)\n",
    "var8w_conf=np.sqrt(var1w_conf**2+totw_conf**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'ts' ()>\n",
       "array(0.076382)\n",
       "Coordinates:\n",
       "    z        float64 400.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var8w_conf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = 'JRA'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var7w = +(current_mlist[model]['120']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg4'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg5'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg2'%(box)])\n",
    "\n",
    "var4w = +(current_mlist[model]['-20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg2'%(box)])\n",
    "\n",
    "var5w = +(current_mlist[model]['400']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg11'%(box)])  # PW\n",
    "\n",
    "var6w = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_120_180_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w+var7w\n",
    "\n",
    "totw= reg_mean_ts_mlist[model]['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8w = totw-var1w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray ()>\n",
       "array(-0.078725)\n",
       "Coordinates:\n",
       "    z        float64 400.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var8w.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var7w_conf=ts_mean_conf(var7w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2+var7w_conf**2)\n",
    "totw_conf=ts_mean_conf(totw)\n",
    "var8w_conf=np.sqrt(var1w_conf**2+totw_conf**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.DataArray 'ts' ()>\n",
       "array(0.066863)\n",
       "Coordinates:\n",
       "    z        float64 400.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var8w_conf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mean bar chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/storage1/home1/chiaweih/anaconda2/envs/python3/lib/python3.7/site-packages/ipykernel_launcher.py:423: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "/storage1/home1/chiaweih/anaconda2/envs/python3/lib/python3.7/site-packages/ipykernel_launcher.py:428: MatplotlibDeprecationWarning: \n",
      "The frameon kwarg was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use facecolor instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x2000 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from time_series_analyses import ts_mean_conf\n",
    "import matplotlib.pyplot as plt; plt.rcdefaults()\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(10,20))\n",
    "########################################################################################################\n",
    "fig.text(-0.1,0.15,'a',size=30)\n",
    "ax = fig.add_axes([0,0,1.,0.15])\n",
    "\n",
    "model = 'JRA'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var7w = +(current_mlist[model]['120']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg4'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg5'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg2'%(box)])\n",
    "\n",
    "var4w = +(current_mlist[model]['-20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg2'%(box)])\n",
    "\n",
    "var5w = +(current_mlist[model]['400']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg11'%(box)])  # PW\n",
    "\n",
    "var6w = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_120_180_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w+var7w\n",
    "\n",
    "totw= reg_mean_ts_mlist[model]['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8w = totw-var1w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = +(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var3e = -(current_mlist[model]['20']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg4'%(box)])\n",
    "\n",
    "var4e = +(current_mlist[model]['-20']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg4'%(box)])\n",
    "\n",
    "var5e = +(current_mlist[model]['400']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg21'%(box)])  # PW\n",
    "\n",
    "var6e = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_180_-60_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "tote = reg_mean_ts_mlist[model]['hcont']['heat_content_180_-60']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8e = tote-var1e\n",
    "\n",
    "\n",
    "\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var7w_conf=ts_mean_conf(var7w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2+var7w_conf**2)\n",
    "totw_conf=ts_mean_conf(totw)\n",
    "var8w_conf=np.sqrt(var1w_conf**2+totw_conf**2)\n",
    "\n",
    "\n",
    "var2e_conf=ts_mean_conf(var2e)\n",
    "var3e_conf=ts_mean_conf(var3e)\n",
    "var4e_conf=ts_mean_conf(var4e)\n",
    "var5e_conf=ts_mean_conf(var5e)\n",
    "var6e_conf=ts_mean_conf(var6e)\n",
    "var1e_conf=np.sqrt(var2e_conf**2+var3e_conf**2+var4e_conf**2+var5e_conf**2+var6e_conf**2)\n",
    "tote_conf=ts_mean_conf(tote)\n",
    "var8e_conf=np.sqrt(var1e_conf**2+tote_conf**2)\n",
    "\n",
    "\n",
    "labels = ['120$^\\circ$E','180$^\\circ$','20$^\\circ$N', '20$^\\circ$S','400m','SRF','RES','TOT']\n",
    "ebox_means = [0.,           var2e.mean(), var3e.mean(), var4e.mean(), var5e.mean(), var6e.mean(), var8e.mean(),tote.mean()]\n",
    "wbox_means = [var7w.mean(), var2w.mean(), var3w.mean(), var4w.mean(), var5w.mean(), var6w.mean(), var8w.mean(),totw.mean()]\n",
    "ebox_conf  = [0.,         var2e_conf, var3e_conf, var4e_conf, var5e_conf, var6e_conf, var8e_conf,0]\n",
    "wbox_conf  = [var7w_conf, var2w_conf, var3w_conf, var4w_conf, var5w_conf, var6w_conf, var8w_conf,0]\n",
    "\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.2                # the width of the bars\n",
    "\n",
    "rects2 = ax.bar(x - width*(1.+1./2.), wbox_means, width, yerr=wbox_conf, label='Wbox %s55-do'%model, color='C1')\n",
    "rects1 = ax.bar(x + width*(1./2.), ebox_means, width, yerr=ebox_conf, label='Ebox %s55-do'%model, color='C0')\n",
    "\n",
    "###########################################\n",
    "model = 'CORE'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var7w = +(current_mlist[model]['120']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg4'%(box)]+\n",
    "         current_mlist[model]['120']['%s_reg5'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg2'%(box)])\n",
    "\n",
    "var4w = +(current_mlist[model]['-20']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg2'%(box)])\n",
    "\n",
    "var5w = +(current_mlist[model]['400']['%s_reg1'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg11'%(box)])  # PW\n",
    "\n",
    "var6w = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_120_180_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w+var7w\n",
    "\n",
    "totw= reg_mean_ts_mlist[model]['hcont']['heat_content_120_180']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8w = totw-var1w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = +(current_mlist[model]['180']['%s_euc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_necc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_secc'%(box)]+\n",
    "         current_mlist[model]['180']['%s_nec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_sec'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res1'%(box)]+\n",
    "         current_mlist[model]['180']['%s_res2'%(box)])\n",
    "\n",
    "var3e = -(current_mlist[model]['20']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['20']['%s_reg4'%(box)])\n",
    "\n",
    "var4e = +(current_mlist[model]['-20']['%s_reg3'%(box)]+\n",
    "         current_mlist[model]['-20']['%s_reg4'%(box)])\n",
    "\n",
    "var5e = +(current_mlist[model]['400']['%s_reg2'%(box)]+\n",
    "         current_mlist[model]['400']['%s_reg21'%(box)])  # PW\n",
    "\n",
    "var6e = (reg_mean_ts_mlist[model]['srfflux']['net_heat_coupler_180_-60_-20_20'])*1e-15 # W => PW\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "tote = reg_mean_ts_mlist[model]['hcont']['heat_content_180_-60']\\\n",
    "            .differentiate('time',datetime_unit='s')*1e-15\n",
    "\n",
    "var8e = tote-var1e\n",
    "\n",
    "\n",
    "\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var7w_conf=ts_mean_conf(var7w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2+var7w_conf**2)\n",
    "totw_conf=ts_mean_conf(totw)\n",
    "var8w_conf=np.sqrt(var1w_conf**2+totw_conf**2)\n",
    "\n",
    "\n",
    "var2e_conf=ts_mean_conf(var2e)\n",
    "var3e_conf=ts_mean_conf(var3e)\n",
    "var4e_conf=ts_mean_conf(var4e)\n",
    "var5e_conf=ts_mean_conf(var5e)\n",
    "var6e_conf=ts_mean_conf(var6e)\n",
    "var1e_conf=np.sqrt(var2e_conf**2+var3e_conf**2+var4e_conf**2+var5e_conf**2+var6e_conf**2)\n",
    "tote_conf=ts_mean_conf(tote)\n",
    "var8e_conf=np.sqrt(var1e_conf**2+tote_conf**2)\n",
    "\n",
    "\n",
    "ebox_means = [0.,           var2e.mean(), var3e.mean(), var4e.mean(), var5e.mean(), var6e.mean(), var8e.mean(),tote.mean()]\n",
    "wbox_means = [var7w.mean(), var2w.mean(), var3w.mean(), var4w.mean(), var5w.mean(), var6w.mean(), var8w.mean(),totw.mean()]\n",
    "ebox_conf  = [0.,         var2e_conf, var3e_conf, var4e_conf, var5e_conf, var6e_conf, var8e_conf,0]\n",
    "wbox_conf  = [var7w_conf, var2w_conf, var3w_conf, var4w_conf, var5w_conf, var6w_conf, var8w_conf,0]\n",
    "\n",
    "\n",
    "rects3 = ax.bar(x - width*(1./2.), wbox_means, width, yerr=wbox_conf, label='Wbox %s'%model, color='C1', hatch=\"///\")\n",
    "rects4 = ax.bar(x + width*(1+1./2.), ebox_means, width, yerr=ebox_conf, label='Ebox %s'%model, color='C0', hatch=\"///\")\n",
    "\n",
    "\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Heat budget (PW)',fontsize=13)\n",
    "ax.set_title(' ',fontsize=15)\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim([-2,2])\n",
    "ax.tick_params(axis='x',labelsize=13,rotation=0) \n",
    "ax.tick_params(axis='y',labelsize=13,rotation=0) \n",
    "ax.legend(frameon=False,loc='upper left')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "########################################################################################################\n",
    "fig.text(-0.1,-0.05,'b',size=30)\n",
    "ax = fig.add_axes([0,-0.2,1.,0.15])\n",
    "\n",
    "model = 'JRA'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4w = -(current_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5w = -(current_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6w = -(current_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = (current_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3e = (current_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4e = (current_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5e = (current_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6e = (current_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2)\n",
    "\n",
    "var2e_conf=ts_mean_conf(var2e)\n",
    "var3e_conf=ts_mean_conf(var3e)\n",
    "var4e_conf=ts_mean_conf(var4e)\n",
    "var5e_conf=ts_mean_conf(var5e)\n",
    "var6e_conf=ts_mean_conf(var6e)\n",
    "var1e_conf=np.sqrt(var2e_conf**2+var3e_conf**2+var4e_conf**2+var5e_conf**2+var6e_conf**2)\n",
    "\n",
    "labels = ['EUC','NECC', 'SECC','NEC','SEC']\n",
    "ebox_means = [var2e.mean(), var3e.mean(), var4e.mean(), var5e.mean(), var6e.mean()]\n",
    "wbox_means = [var2w.mean(), var3w.mean(), var4w.mean(), var5w.mean(), var6w.mean()]\n",
    "ebox_conf  = [var2e_conf, var3e_conf, var4e_conf, var5e_conf, var6e_conf]\n",
    "wbox_conf  = [var2w_conf, var3w_conf, var4w_conf, var5w_conf, var6w_conf]\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.2                # the width of the bars\n",
    "\n",
    "rects2 = ax.bar(x - width*(1.+1./2.), wbox_means, width, yerr=wbox_conf, label='Wbox %s55-do'%model, color='C1')\n",
    "rects1 = ax.bar(x + width*(1./2.), ebox_means, width, yerr=ebox_conf, label='Ebox %s55-do'%model, color='C0')\n",
    "\n",
    "##########################################################\n",
    "model = 'CORE'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3w = -(current_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4w = -(current_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5w = -(current_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6w = -(current_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = (current_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3e = (current_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4e = (current_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5e = (current_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6e = (current_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2)\n",
    "\n",
    "var2e_conf=ts_mean_conf(var2e)\n",
    "var3e_conf=ts_mean_conf(var3e)\n",
    "var4e_conf=ts_mean_conf(var4e)\n",
    "var5e_conf=ts_mean_conf(var5e)\n",
    "var6e_conf=ts_mean_conf(var6e)\n",
    "var1e_conf=np.sqrt(var2e_conf**2+var3e_conf**2+var4e_conf**2+var5e_conf**2+var6e_conf**2)\n",
    "\n",
    "\n",
    "ebox_means = [var2e.mean(), var3e.mean(), var4e.mean(), var5e.mean(), var6e.mean()]\n",
    "wbox_means = [var2w.mean(), var3w.mean(), var4w.mean(), var5w.mean(), var6w.mean()]\n",
    "ebox_conf  = [var2e_conf, var3e_conf, var4e_conf, var5e_conf, var6e_conf]\n",
    "wbox_conf  = [var2w_conf, var3w_conf, var4w_conf, var5w_conf, var6w_conf]\n",
    "\n",
    "\n",
    "rects3 = ax.bar(x - width*(1./2.), wbox_means, width, yerr=wbox_conf, label='Wbox %s'%model, color='C1',hatch='///')\n",
    "rects4 = ax.bar(x + width*(1+1./2.), ebox_means, width, yerr=ebox_conf, label='Ebox %s'%model, color='C0',hatch='///')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Heat budget (PW)',fontsize=13)\n",
    "ax.set_title(' ',fontsize=15)\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim([-1.5,1.5])\n",
    "ax.tick_params(axis='x',labelsize=13,rotation=0) \n",
    "ax.tick_params(axis='y',labelsize=13,rotation=0) \n",
    "ax.legend(frameon=False,loc='upper left')\n",
    "\n",
    "########################################################################################################\n",
    "fig.text(-0.1,-0.25,'c',size=30)\n",
    "ax = fig.add_axes([0,-0.4,1.,0.15])\n",
    "\n",
    "model = 'JRA'\n",
    "\n",
    "var2w = (current_mlist[model]['180']['euc_Sv'])\n",
    "\n",
    "var3w = (current_mlist[model]['180']['necc_Sv'])\n",
    "\n",
    "var4w = (current_mlist[model]['180']['secc_Sv'])\n",
    "\n",
    "var5w = (current_mlist[model]['180']['nec_Sv'])\n",
    "\n",
    "var6w = (current_mlist[model]['180']['sec_Sv'])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "model = 'CORE'\n",
    "\n",
    "var2e = (current_mlist[model]['180']['euc_Sv'])\n",
    "\n",
    "var3e = (current_mlist[model]['180']['necc_Sv'])\n",
    "\n",
    "var4e = (current_mlist[model]['180']['secc_Sv'])\n",
    "\n",
    "var5e = (current_mlist[model]['180']['nec_Sv'])\n",
    "\n",
    "var6e = (current_mlist[model]['180']['sec_Sv'])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "var2w_conf=ts_mean_conf(var2w)\n",
    "var3w_conf=ts_mean_conf(var3w)\n",
    "var4w_conf=ts_mean_conf(var4w)\n",
    "var5w_conf=ts_mean_conf(var5w)\n",
    "var6w_conf=ts_mean_conf(var6w)\n",
    "var1w_conf=np.sqrt(var2w_conf**2+var3w_conf**2+var4w_conf**2+var5w_conf**2+var6w_conf**2)\n",
    "\n",
    "var2e_conf=ts_mean_conf(var2e)\n",
    "var3e_conf=ts_mean_conf(var3e)\n",
    "var4e_conf=ts_mean_conf(var4e)\n",
    "var5e_conf=ts_mean_conf(var5e)\n",
    "var6e_conf=ts_mean_conf(var6e)\n",
    "var1e_conf=np.sqrt(var2e_conf**2+var3e_conf**2+var4e_conf**2+var5e_conf**2+var6e_conf**2)\n",
    "\n",
    "labels = ['EUC','NECC', 'SECC','NEC','SEC']\n",
    "ebox_means = [var2e.mean(), var3e.mean(), var4e.mean(), var5e.mean(), var6e.mean()]\n",
    "wbox_means = [var2w.mean(), var3w.mean(), var4w.mean(), var5w.mean(), var6w.mean()]\n",
    "ebox_conf  = [var2e_conf, var3e_conf, var4e_conf, var5e_conf, var6e_conf]\n",
    "wbox_conf  = [var2w_conf, var3w_conf, var4w_conf, var5w_conf, var6w_conf]\n",
    "\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.45                # the width of the bars\n",
    "\n",
    "rects2 = ax.bar(x - width/2, wbox_means, width, yerr=wbox_conf, label='JRA55-do', color='gray')\n",
    "rects1 = ax.bar(x + width/2, ebox_means, width, yerr=ebox_conf, label='CORE', color='gray',hatch='///')\n",
    "\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Volume budget (Sv)',fontsize=13)\n",
    "ax.set_title('',fontsize=15)\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim([-55,55])\n",
    "ax.tick_params(axis='x',labelsize=13,rotation=0) \n",
    "ax.tick_params(axis='y',labelsize=13,rotation=0) \n",
    "ax.legend(frameon=False,loc='upper right')\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "fig.savefig('../figure/figure4.pdf', dpi=300, facecolor='w', edgecolor='w',\n",
    "                orientation='portrait', papertype=None, format=None,\n",
    "                transparent=False, bbox_inches=\"tight\", pad_inches=None,\n",
    "                frameon=None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seasonal amplitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/storage1/home1/chiaweih/anaconda2/envs/python3/lib/python3.7/site-packages/ipykernel_launcher.py:274: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "/storage1/home1/chiaweih/anaconda2/envs/python3/lib/python3.7/site-packages/ipykernel_launcher.py:279: MatplotlibDeprecationWarning: \n",
      "The frameon kwarg was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use facecolor instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGAAAARKCAYAAAAAOQb5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzde3zP9f//8ft7ZgebzWxmhG2sEUMHhxA7FEaEWHL6kEwnIk1S+aAmHfjEx+hTyGfTIss3lKTUNjJDhZSZ5awIZZu3nbf37w+/vT+92yYb897mdr1cXpfP5fV6PV+v9+P18tHl8rp7Hgwmk8kkAAAAAAAAVBobaxcAAAAAAABQ0xHAAAAAAAAAVDICGAAAAAAAgEpGAAMAAAAAAFDJCGAAAAAAAAAqGQEMAAAAAABAJSOAAQAAAAAAqGQEMAAAAAAAAJWMAAYAAAAAAKCSEcAAAAAAAABUMgIYAAAAAACASkYAAwAAAAAAUMkIYAAAAAAAACoZAQwAAAAAAEAlI4ABAAAAAACoZAQwAAAAAAAAlYwABgAAAAAAoJLZXq8bFRUVKTU1VampqTp16pQuXrwoW1tbubm5qVmzZurcubNcXV2v188BAAAAAABUG9cUwFy4cEEff/yx1q9fr61btyo9Pb3MtjY2Nrrnnns0depU9evX71p+FgAAAAAAoFoxmEwmU0Uvbteunfbv31/u6x5++GEtW7ZMTk5OFf1pAAAAAACAauOaesAUFRVZ7NevX1+tW7eWh4eHnJ2ddenSJR07dkw//vij8vPzze1Wr14to9GoDRs2yGAwXEsJAAAAAAAAVd419YBp27at6tWrp4cfflh9+/aVr69vqe0uXLig5cuX6+WXX9bFixfNx99++209/vjjFf15AAAAAACAauGaAphjx47Jx8fnqtvv27dPgYGBysjIkCQ1b95caWlpsrFhMSYAAAAAAFBzXVPyUZ7wRZLat2+vGTNmmPePHDmiHTt2XEsJAAAAAAAAVd4N73oyePBgi/2kpKQbXQIAAAAAAMANdU2T8JalsLBQRqNRFy9eVEFBQYlzf5aSklIZJQAAAAAAAFQZ1yWAuXDhgj7++GNt3LhRP/zwg44cOVJihaQrXQsAAAAAAFCTXVMAU1hYqDfffFNz5syR0Wis0D2KJ+QFAAAAAACoqSocwBQUFGjYsGH66KOPrqmAq+0pAwAAAAAAUF1VOIB56623SoQvd999twYPHqwOHTqoadOmatCggRwcHGRnZ2fRzmAwVPRnAQAAAAAAqp0KBTB5eXmaM2eOed9gMGjFihUaPXr0316bmZlZkZ8EAAAAAACotiq0DHViYqLF3C2jRo26qvBFkn799deK/CQAAAAAAEC1VaEAJi0tzWK/X79+V31tUlJSRX4SAAAAAACg2qpQAJOenm6x7+rqetXX/ve//63ITwIAAAAAAFRbFQpg3NzcLPYPHjx4VdetX79e27Ztq8hPAgAAAAAAVFsVCmDat29vsR8VFaVLly5d8Zpvv/1WjzzySEV+DgAAAAAAoFqrUADTuXNneXt7m/fT0tLUs2dPpaSklGhrNBr1xhtvKCgoSBcuXFCDBg0qXi0AAAAAAEA1ZDCZTKaKXLhmzRoNHTrU8mYGg9q1a6eWLVvKYDDo119/1a5du5SbmytJsrW11SeffKI+ffqYrwkMDFRCQkLFnwAAAAAAAKCKs63ohQ899JAOHTqkf/7znyrOcEwmk/bt26d9+/aVaO/o6KiYmBiFhoZWvFoAAAAAAIBqqMIBjCS99NJL6tChg1588UV9//33pbZxcXHRoEGDNGPGDLVo0eJafg7/X1FRkX799VfVrVtXBoPB2uUAAAAAAHBTMplMunjxoho3biwbmyvP8lLhIUh/dejQISUnJ+u3336TyWRSw4YN1aRJE3Xr1k0ODg7X4yfw/506dUpNmza1dhkAAAAAAEDSyZMn1aRJkyu2uW4BDG6cjIwM1atXTydPnpSLi4u1ywEAAAAA4KaUmZmppk2bKj09Xa6urldse01DkGAdxcOOXFxcCGAAAAAAALCyq5kepELLUAMAAAAAAODqEcAAAAAAAABUMgIYAAAAAACASkYAAwAAAAAAUMkIYAAAAAAAACoZAQwAAAAAAEAlI4ABAAAAAACoZAQwAAAAAAAAlYwABgAAAAAAoJIRwAAAAAAAAFQyAhhUGwaDQevWrbN2GdXWsWPHZDAYtHfvXmuXAgAAAAA3HVtrF1BdzJ07V99//72+++47HT16VN7e3jp27Ng13fOhhx5SXFycWrZsqYMHD16fQq/A5/mNlf4bxY69dn+52o8ZM0bR0dEljvfu3Vuff/759SqrQnx8fDR58mRNnjzZvH/8+HFJkoODg7y9vfXoo48qIiJCBoOhxPW9evXSV199pe3bt+vuu++2ODdr1izNnj3b4ljDhg115swZ835p76Zz585KTk6+Ls8HAAAAAKh8BDBX6YUXXlD9+vV15513Kj09/Zrvt3HjRq1du1aOjo7XobqaITQ0VCtWrLA4Zm9vb6Vqruzll19WeHi4cnJytGXLFj3xxBNycXHRY489ZtHuxIkT2rFjhyZMmKDly5eXCGAkqU2bNtqyZYt5v1atWiXa/PXd2NnZXcenAQAAAABUNoYgXaXDhw/r999/15dffqnGjRtf072MRqOefPJJPfnkk/L09LxOFVZ/9vb28vLystjc3Nws2pw+fVp9+vSRo6OjfH19FRcXZ3F+//79CgkJkaOjo9zd3TV+/HgZjUZJUk5Ojtq0aaPx48eb2x89elSurq5aunRpuWqtW7euvLy85OPjo3Hjxqldu3b64osvSrRbsWKF+vXrpyeeeEIffvihLl26VKKNra2txTM3aNDgb99N/fr1/7bGXbt26Y477pCDg4M6dOigPXv2lGiTmJioTp06yd7eXo0aNdLzzz+vgoKCq3wLAAAAAICrRQBzlZo3b37d7vXSSy8pPz9fc+bMuW73vFnMmDFDgwcP1r59+zRy5EgNGzZMKSkpkqSsrCyFhobKzc1Nu3fvVlxcnLZs2aIJEyZIujxcKDY2VtHR0Vq3bp0KCws1atQoBQcHKzw8vEL1mEwmJSQkKCUlRbVr1y5xbsWKFRo5cqRatWolf39/rVmzpsQ90tLS1LhxY/n6+urhhx/WkSNHSrRJSEiQp6en/P39FR4errNnz16xrkuXLqlfv35q2bKlvvvuO82aNUsREREWbX755Rf17dtXHTt21L59+/T2229r+fLlioyMrMCbAAAAAABcCQHMDbZ7924tWrRIb731llxcXKxdTpXy6aefytnZ2WJ75ZVXLNqEhYVp3Lhx8vf31yuvvKIOHTpo0aJFkqTY2FhlZ2crJiZGAQEBCgkJUVRUlFauXKnffvtNknT77bcrMjJS4eHheuaZZ3T48GEtW7as3LVOmzZNzs7Osre3V3BwsEwmk55++mmLNlu2bFFWVpZ69+4tSRo5cqSWL19u0aZz586KiYnR5s2btXTpUp05c0Zdu3bV77//bm7Tp08fxcbG6uuvv9b8+fO1e/duhYSEKDc3t8z6YmNjVVhYqPfee09t2rRRv379NHXqVIs2S5YsUdOmTRUVFaVWrVpp4MCBmj17tubPn6+ioqJyvxMAAAAAQNmYA+YGKigoUHh4uO677z4NHTr0qq/Lzc21+NjOzMysjPKsLjg4WG+//bbFsb8OtenSpUuJ/eJVfVJSUtS+fXs5OTmZz3fr1k1FRUVKTU1Vw4YNJUnPPvus1q9fr0WLFmnTpk3y8PAod61Tp07VmDFjdO7cOb344osKCQlR165dLdosX75cQ4cOla3t5b9mw4YN09SpU5WamqqWLVtKuhyuFGvbtq26dOmiFi1aKDo6WlOmTJEki/+vBAQEqEOHDvL29tbGjRv14IMP6vHHH9f7779vbmM0Gs3vok6dOmW+u5SUFHXp0sVi4uBu3brJaDTq1KlTatasWbnfCwAAAACgdAQwN9D8+fOVmpqqtWvXluu6uXPnllgppyZycnKSn59fua8rDhBMJlOpqxD9uY0knT17VqmpqapVq5bS0tIUGhpa7t/08PCQn5+f/Pz8tHbtWvn5+enuu+/WfffdJ0n6448/tG7dOuXn51uESsW9Ul5//fVS7+vk5KS2bdsqLS2tzN9u1KiRvL29zW1efvnlEsOLTCbT3z5Dae+r+Lqy3iMAAAAAoGIYgnSDHD58WLNnz9YLL7ygFi1alOva6dOnKyMjw7ydPHmykqqs+v669HJycrJatWolSWrdurX27t1rMdHt9u3bZWNjI39/f/OxsWPHKiAgQDExMXruued04MCBa6rJzc1NEydOVEREhDnAiI2NVZMmTbRv3z7t3bvXvC1YsEDR0dFlTnSbm5urlJQUNWrUqMzf+/3333Xy5ElzG09PT3MYVBxgtW7dWvv27VN2drb5ur++u9atWyspKckirElKSlLdunV1yy23VOxlAAAAAABKRQBzgzz77LNyc3PT0KFDdezYMfNWUFCg/Px8HTt2zDxPyV/Z29vLxcXFYquJcnNzdebMGYvt/PnzFm3i4uL03nvv6dChQ5o5c6Z27dplnmR3xIgRcnBw0OjRo/Xjjz8qPj5eEydO1KhRo8zDjxYvXqwdO3YoJiZGw4cP15AhQzRixAjl5eVdU+1PPfWURe+m5cuXa8iQIQoICLDYxo4dq/T0dG3cuFGSFBERocTERB09elQ7d+7UkCFDlJmZqdGjR0u6PJwoIiJCO3bs0LFjx5SQkKD+/fvLw8NDgwYNKrOe4cOHy8bGRo8++qgOHDigzz77TPPmzbNo8+STT+rkyZOaOHGiDh48qPXr12vmzJmaMmWKbGz4TwMAAAAAXFcmlFubNm1M3t7e5bqmffv2JklX3Hr37n1V98rIyDBJMmVkZFSg+qpp9OjRpb6Tli1bmttIMi1evNjUs2dPk729vcnb29u0atUqi/v88MMPpuDgYJODg4Opfv36pvDwcNPFixdNJpPJlJKSYnJ0dDR98MEH5vYZGRkmHx8f03PPPVdmbU2bNjUtWrTIvO/t7W166623SrQLDw83tWnTxvTtt9+aJJl27dpV6v369+9v6t+/v8lkMpmGDh1qatSokal27dqmxo0bmx588EHTTz/9ZG6blZVl6tWrl6lBgwam2rVrm5o1a2YaPXq06cSJE1d6nSaTyWTasWOHqX379iY7OzvT7bffblq7dq1JkmnPnj3mNgkJCaaOHTua7OzsTF5eXqZp06aZ8vPz//beAAAAAIDyfZ8bTKarmCwCFgICAmQ0GnXs2LFSz58+fVoZGRlq1qyZeRLU+Ph4ZWRklGg7fvx42dnZKSoqSg0bNiwxUWppMjMz5erqqoyMjBrbG6aqKCwslIuLi6KjozVkyBBrlwMAAAAAqELK833OJLxXaeXKlTp+/Lgk6dy5c8rLy1NkZKQkqV69euZhMNLlOVuio6MVHx+voKAgSZdX+CnN5MmT5eDgoIEDB1buA6DcTp06pZiYGBUWFuqee+6xdjkAAAAAgGqMAOYqLV++XImJiRbHZsyYIUny9va2CGBQM9x+++1yd3fXypUr5eXlZe1yAAAAAADVGEOQqiGGIAEAAAAAYH3l+T5nqRMAAAAAAIBKRgADAAAAAABQyQhgAAAAAAAAKhkBDAAAAAAAQCUjgAEAAAAAAKhkBDCo1gwGg9atW2ftMqqtY8eOyWAwaO/evdYuBQAAAABqNAIYWN1//vMf1a1bVwUFBeZjRqNRtWvXVvfu3S3abtu2TQaDQYcOHbrRZVrw8fHRggULLPYNBoMMBoMcHR3VqlUrvfnmmyprlfdevXqpVq1aSk5OLnFu1qxZ5nsVb15eXhZtxowZU6LN3XfffX0fEgAAAABw3dhauwDcQLNcb+BvZVx10+DgYBmNRn377bfmEGHbtm3y8vLS7t27lZWVpTp16kiSEhIS1LhxY/n7+1dK2dfi5ZdfVnh4uHJycrRlyxY98cQTcnFx0WOPPWbR7sSJE9qxY4cmTJig5cuXlxqctGnTRlu2bDHv16pVq0Sb0NBQrVixwrxvZ2d3HZ8GAAAAAHA90QMGVteyZUs1btxYCQkJ5mMJCQkaMGCAWrRooaSkJIvjwcHBFtefPn1affr0kaOjo3x9fRUXF2dxfv/+/QoJCZGjo6Pc3d01fvx4GY1GSVJOTo7atGmj8ePHm9sfPXpUrq6uWrp0abmeo27duvLy8pKPj4/GjRundu3a6YsvvijRbsWKFerXr5+eeOIJffjhh7p06VKJNra2tvLy8jJvDRo0KNHG3t7eok39+vX/tsZdu3bpjjvukIODgzp06KA9e/aUaJOYmKhOnTrJ3t5ejRo10vPPP2/ROwkAAAAAUH4EMKgSgoKCFB8fb96Pj49XUFCQAgMDzcfz8vK0Y8eOEgHMjBkzNHjwYO3bt08jR47UsGHDlJKSIknKyspSaGio3NzctHv3bsXFxWnLli2aMGGCJMnBwUGxsbGKjo7WunXrVFhYqFGjRik4OFjh4eEVehaTyaSEhASlpKSodu3aJc6tWLFCI0eOVKtWreTv7681a9aUuEdaWpoaN24sX19fPfzwwzpy5EiJNgkJCfL09JS/v7/Cw8N19uzZK9Z16dIl9evXTy1bttR3332nWbNmKSIiwqLNL7/8or59+6pjx47at2+f3n77bS1fvlyRkZEVeBMAAAAAgGIEMKgSgoKCtH37dhUUFOjixYvas2ePevToocDAQHPPmOTkZGVnZ5cIYMLCwjRu3Dj5+/vrlVdeUYcOHbRo0SJJUmxsrLKzsxUTE6OAgACFhIQoKipKK1eu1G+//SZJuv322xUZGanw8HA988wzOnz4sJYtW1buZ5g2bZqcnZ1lb2+v4OBgmUwmPf300xZttmzZoqysLPXu3VuSNHLkSC1fvtyiTefOnRUTE6PNmzdr6dKlOnPmjLp27arff//d3KZPnz6KjY3V119/rfnz52v37t0KCQlRbm5umfXFxsaqsLBQ7733ntq0aaN+/fpp6tSpFm2WLFmipk2bKioqSq1atdLAgQM1e/ZszZ8/X0VFReV+JwAAAACAywhgUCUEBwfr0qVL2r17t7Zt2yZ/f395enoqMDBQu3fv1qVLl5SQkKBmzZqpefPmFtd26dKlxH5xD5iUlBS1b99eTk5O5vPdunVTUVGRUlNTzceeffZZtWzZUosWLdKKFSvk4eFR7meYOnWq9u7dq8TERAUHB+vFF19U165dLdosX75cQ4cOla3t5emXhg0bpp07d1rU0qdPHw0ePFht27bVfffdp40bN0qSoqOjzW2GDh2q+++/XwEBAerfv782bdqkQ4cOmds+/vjjcnZ2Nm9/fhfF8+mU9u5SUlLUpUsXGQwGi/dlNBp16tSpcr8TAAAAAMBlBDCoEvz8/NSkSRPFx8crPj5egYGBkiQvLy/5+vpq+/btio+PV0hIyFXdrzhAMJlMFmFCaW0k6ezZs0pNTVWtWrWUlpZWoWfw8PCQn5+funTporVr1+qtt96ymEj3jz/+0Lp167RkyRLZ2trK1tZWt9xyiwoKCvTee++VeV8nJye1bdv2inU1atRI3t7e5jYvv/yy9u7da94klbki05+V9r6KryvrPQIAAAAA/h4BDKqM4OBgJSQkKCEhQUFBQebjgYGB2rx5s5KTk0sMP5JUYinn5ORktWrVSpLUunVr7d2712Ki2+3bt8vGxsZiJaWxY8cqICBAMTExeu6553TgwIFrehY3NzdNnDhRERER5gAjNjZWTZo00b59+yzCkQULFig6OrrMiW5zc3OVkpKiRo0alfl7v//+u06ePGlu4+npKT8/P/NW/C727dun7Oxs83V/fXetW7dWUlKSRViTlJSkunXr6pZbbqnYywAAAAAAEMCg6ggODtY333yjvXv3mnvASJcDmKVLlyonJ6fUACYuLk7vvfeeDh06pJkzZ2rXrl3mSXZHjBghBwcHjR49Wj/++KPi4+M1ceJEjRo1Sg0bNpQkLV68WDt27FBMTIyGDx+uIUOGaMSIEcrLy7um53nqqaeUmpqqtWvXSro8/GjIkCEKCAiw2MaOHav09HTz8KGIiAglJibq6NGj2rlzp4YMGaLMzEyNHj1akmQ0GhUREaEdO3bo2LFjSkhIUP/+/eXh4aFBgwaVWc/w4cNlY2OjRx99VAcOHNBnn32mefPmWbR58skndfLkSU2cOFEHDx7U+vXrNXPmTE2ZMkU2NvznAgAAAAAqii8qVBnBwcHKzs6Wn5+fORyRLgcwFy9eVIsWLdS0adMS182ePVurV69Wu3btFB0drdjYWLVu3VqSVKdOHW3evFl//PGHOnbsqCFDhujee+9VVFSUJOngwYOaOnWqefJZ6XIgk56erhkzZpRZa1FRkXkel7I0aNBAo0aN0qxZs/Tdd99p3759Gjx4cIl2devWVa9evcyT8Z46dUrDhg1Ty5Yt9eCDD8rOzk7Jycny9vaWJNWqVUv79+/XgAED5O/vr9GjR8vf3187duxQ3bp1y6zH2dlZn3zyiQ4cOKA77rhDL774ol5//XWLNrfccos+++wz7dq1S+3bt9fjjz+uRx99VC+99NIVnxUAAAAAcGUG09VMDIEqJTMzU66ursrIyJCLi4u1y7npFBYWysXFRdHR0RoyZIi1ywEAAAAAWEl5vs+v/E/4ACycOnVKMTExKiws1D333GPtcgAAAAAA1QQBDFAOt99+u9zd3bVy5Up5eXlZuxwAAAAAQDVBAAOUw/nz561dAgAAAACgGmISXgAAAAAAgEpGAAMAAAAAAFDJCGAAAAAAAAAqGQEMAAAAAABAJSOAAQAAAAAAqGQEMAAAAAAAAJWMAOYqzZ07V2FhYWrevLkMBoN8fHzKdf2FCxe0cOFC9erVS02bNpWjo6Natmyp8ePH6+TJk5VTdA1jMBi0bt06a5cBAAAAAEC5EcBcpRdeeEFff/21WrRoITc3t3Jfv3PnTk2ZMkUmk0lPPfWUFi1apL59++r9999X27ZtdeDAgUqouvoYM2aMDAZDiS00NNTapUmS9uzZo7CwMDVs2FAODg7y9/dXeHi4Dh06ZNEuOjpanTp1kpOTk+rWrasePXro008/tWiTkJBg8Yzu7u4KCQnR9u3bLdrNmjWr1HfSqlWrSn9eAAAAAMD1ZWvtAqqLw4cPq3nz5pKkgIAAGY3Gcl3fqlUrpaamys/Pz+L4/fffr549e2rmzJmKi4u7bvWWxjNsls59PEeOzTuowYBpMtSqXWbb3F9T9duHM2TXwFueYbNlY1+nzLb5f/yi31ZNl429kxo+/KpqObvp2Gv3l7u+0NBQrVixwuKYvb19ue9zvX366acaPHiwevfurdjYWLVo0UJnz55VXFycZsyYoQ8//FCSFBERoaioKEVGRmrgwIHKz8/X+++/rwEDBmjhwoWaMGGCxX1TU1Pl4uKic+fOKTIyUvfff78OHTokT09Pc5s2bdpoy5YtFtfZ2vLXFgAAAACqG3rAXKXi8KWifHx8SoQvknTfffepfv362r9//zXd/2rcqPClouzt7eXl5WWx/bW30enTp9WnTx85OjrK19e3RGi1f/9+hYSEyNHRUe7u7ho/frw5LMvJyVGbNm00fvx4c/ujR4/K1dVVS5cuLbWmrKwsPfLII+rbt682bNig++67T76+vurcubPmzZund955R5KUnJys+fPn680331RERIT8/Px02223ac6cOZo8ebKmTJlSYqiZp6envLy81LZtW7300kvKyMjQzp07LdrY2tqWeCceHh4Ve8EAAAAAAKshgLGyjIwMXbx40aLXQ2WpyuHL1ZoxY4YGDx6sffv2aeTIkRo2bJhSUlIkXQ5LQkND5ebmpt27dysuLk5btmwx9zxxcHBQbGysoqOjtW7dOhUWFmrUqFEKDg5WeHh4qb+3efNmnT9/Xs8991yp5+vVqydJWrVqlZydnfXYY4+VaPPss88qPz9fa9euLfUeWVlZ5p4/tWuX/WcDAAAAAKi+CGCsLDIyUvn5+Ro9enSZbXJzc5WZmWmxVURVD18+/fRTOTs7W2yvvPKKRZuwsDCNGzdO/v7+euWVV9ShQwctWrRIkhQbG6vs7GzFxMQoICBAISEhioqK0sqVK/Xbb79Jkm6//XZFRkYqPDxczzzzjA4fPqxly5aVWVNaWpok/e28K4cOHVKLFi1kZ2dX4lzjxo3l6upaYr6YJk2amJ/zrbfe0l133aV7773Xos3+/ftLvJNx48ZdsRYAAAAAQNXDZBJWtGbNGs2fP189e/bUI488Uma7uXPnavbs2df8e1U5fJGk4OBgvf322xbH6tevb7HfpUuXEvt79+6VJKWkpKh9+/ZycnIyn+/WrZuKioqUmpqqhg0bSrrcI2X9+vVatGiRNm3adMUhPSaT6Zqe6c/3MRgMFse2bdsmJycn7dmzR9OmTdN///vfEj1gWrZsqQ0bNlgcq1u37nWpCQAAAABw4xDAWMlnn32mUaNG6Y477lBcXJxsbMrujDR9+nRNmTLFvJ+ZmammTZtet1qqQvgiSU5OTqXOk/N3ioON0kKOv7aRpLNnzyo1NVW1atVSWlraFVda8vf3lyQdPHiwRPjz13bffPON8vLySvSC+fXXX5WZmalbb73V4rivr6/q1asnf39/5eTkaNCgQfrxxx8tJh62s7Or0DsBAAAAAFQtDEGygs8//1wPPvigWrVqpS+++EKurq5XbG9vby8XFxeL7XqpKuHL1UpOTi6xXzw8qHXr1tq7d68uXbpkPr99+3bZ2NiYgxRJGjt2rAICAhQTE6PnnnvuikuA9+rVSx4eHnrjjTdKPZ+eni5Jevjhh2U0Gs2T8v7ZvHnzVLt2bQ0ePLjM3xk1apSKioq0ZMmSMtsAAAAAAKovesDcYJs3b9agQYPk7++vr776Su7u7larpbLCl0LjhYrVk5urM2fOWByztbW1GCIUFxenDh066J577lFsbKx27dql5cuXS5JGjBihmTNnavTo0Zo1a5bOnTuniRMnatSoUebhR4sXL9aOHTv0ww8/qGnTptq0aZNGjBihnTt3ljp/i5OTk0YSuNwAACAASURBVJYtW6awsDA98MADevrpp+Xn56fz589rzZo1OnHihFavXq0uXbpo0qRJmjp1qvLy8iyWoV64cKEWLFhwxV5LNjY2mjx5siIjI/XYY4+pTp3LfxYFBQUl3onBYDA/DwAAAACgeqAHTCU4ffq0Dh48qKysLIvjX3zxhQYOHKhbb71VX3/9tVWXE67M8OW31S9UqKbPP/9cjRo1stjuueceizazZ8/W6tWr1a5dO0VHRys2NlatW7eWJNWpU0ebN2/WH3/8oY4dO2rIkCG69957FRUVJenyMKKpU6dqyZIl5jBk8eLFSk9P14wZM8qsa8CAAUpKSlLt2rU1fPhwtWrVSsOGDVNGRoYiIyPN7RYsWKAlS5Zo9erVatu2re666y4lJiZq3bp1mjhx4t8+/9ixY5Wfn2+uV5J++umnEu/E29v76l8qAAAAAKBKMJiu1yyjNdzKlSt1/PhxSdKiRYuUl5enZ599VtLlpYiLlzqWpDFjxig6Olrx8fEKCgqSJH377bfq3r27TCaTXnvttVLDl5EjR15VLZmZmXJ1dVVGRsZ1HY4EAAAAAACuXnm+zxmCdJWWL1+uxMREi2PFvSa8vb0tApjS/Pjjj8rJyZEkPfPMM6W2udoABgAAAAAAVC/0gKmG6AEDAAAAAID1lef7nDlgAAAAAAAAKhkBDAAAAAAAQCUjgAEAAAAAAKhkBDAAAAAAAACVrMatgnTgwAH99NNPOnv2rAwGgxo0aKCAgADddttt1i4NAAAAAADcpGpEAJOSkqK3335ba9as0blz5yRJxYs7GQwGSZKHh4ceeughPfHEE2rdurXVagUAAAAAADefar0M9bFjx/Tcc89p7dq1cnR0VPfu3dWlSxe1aNFC7u7uMplM+uOPP/Tzzz8rOTlZ27ZtU3Z2tgYPHqw33nhDPj4+1n6ECmEZagAAAAAArK883+fVugdMq1atdNttt+m9997T4MGD5ezsfMX2RqNRH330kRYuXKjbbrtN2dnZN6hSVBaDwaCPP/5YAwcOtHYpAAAAAACUqVpPwhsbG6s9e/Zo9OjRfxu+SJKzs7PGjBmjPXv2KDY29gZUiKvxn//8R3Xr1lVBQYH5mNFoVO3atdW9e3eLttu2bZPBYNChQ4dudJkl7NmzR2FhYWrYsKEcHBzk7++v8PDwErVFR0erU6dOcnJyUt26ddWjRw99+umnFm0SEhJkMBjMm7u7u0JCQrR9+3aLdrNmzbJoV7y1atWq0p8XAAAAAFBx1boHzODBgyt87YMPPngdK6kmZrnq0O+FCo7Okqu9QV+PriMv57IzuDPGIoVEZykj16T40XXk716rzLYXc00Kjc3Sj2cL9eUoJ3VaarzqsoKDg2U0GvXtt9/q7rvvlnQ5aPHy8tLu3buVlZWlOnXqSLocVDRu3Fj+/v5Xff/K8Omnn2rw4MHq3bu3YmNj1aJFC509e1ZxcXGaMWOGPvzwQ0lSRESEoqKiFBkZqYEDByo/P1/vv/++BgwYoIULF2rChAkW901NTZWLi4vOnTunyMhI3X///Tp06JA8PT3Nbdq0aaMtW7ZYXGdrW63/KgMAAABAjVete8BIlz/Ic3NzrV1GtXDDwpdbym5bmpYtW6px48ZKSEgwH0tISNCAAQPUokULJSUlWRwPDg62uP706dPq06ePHB0d5evrq7i4OIvz+/fvV0hIiBwdHeXu7q7x48fLaLwcEOXk5KhNmzYaP368uf3Ro0fl6uqqpUuXllpvVlaWHnnkEfXt21cbNmzQfffdJ19fX3Xu3Fnz5s3TO++8I0lKTk7W/Pnz9eabbyoiIkJ+fn667bbbNGfOHE2ePFlTpkzRyZMnLe7t6ekpLy8vtW3bVi+99JIyMjK0c+dOiza2trby8vKy2Dw8PK7ybQMAAAAArKHaBzAhISFyc3NTSEiIXnnlFX3zzTcWQ1nwP1UxfCkWFBSk+Ph48358fLyCgoIUGBhoPp6Xl6cdO3aUCGBmzJihwYMHa9++fRo5cqSGDRumlJQUSZfDktDQULm5uWn37t2Ki4vTli1bzD1PHBwcFBsbq+joaK1bt06FhYUaNWqUgoODFR4eXmqtmzdv1vnz5/Xcc8+Ver5evXqSpFWrVsnZ2VmPPfZYiTbPPvus8vPztXbt2lLvkZWVpRUrVkiSateuXeZ7AwAAAABUD9U+gHnmmWfUunVrbd26VTNnzlRgYKDq1aun0NBQvfbaa9q5c6eKioqsXWaVUFXDF+lyALN9+3YVFBTo4sWL2rNnj3r06KHAwEBzz5jk5GRlZ2eXCGDCwsI0btw4+fv765VXXlGHDh20aNEiSZfnCcrOzlZMTIwCAgIUEhKiqKgorVy5Ur/99psk6fbbb1dkZKTCw8P1zDPP6PDhw1q2bFmZtaalpUnS3867cujQIbVo0UJ2dnYlzjVu3Fiurq4l5otp0qSJnJ2d5ezsrLfeekt33XWX7r33Xos2+/fvN7cp3saNG3fFWgAAAAAA1lXtJ46YP3++pMtLP23dulUJCQlKSEjQli1b9MUXX8hgMMjZ2Vndu3dXcHCwgoODdeedd1q5auuoquGLdHkemEuXLmn37t26cOGC/P395enpqcDAQI0aNUqXLl1SQkKCmjVrpubNm1tc26VLlxL7e/fulSSlpKSoffv2cnJyMp/v1q2bioqKlJqaqoYNG0q63CNl/fr1WrRokTZt2nTFIT3Xa+V2k8kkg8FgcWzbtm1ycnLSnj17NG3aNP33v/8t0QOmZcuW2rBhg8WxunXrXpeaAAAAAACVo9oHMMVcXFzUr18/9evXT9LlQCYxMVGJiYlKSEjQ559/rk2bNslgMNy0Q5SqavgiSX5+fmrSpIni4+N14cIFBQYGXq7Zy0u+vr7avn274uPjFRISclX3Kw42Sgs5/tpGks6ePavU1FTVqlVLaWlpCg0NLfPexRMAHzx4sET489d233zzjfLy8kr0gvn111+VmZmpW2+91eK4r6+v6tWrJ39/f+Xk5GjQoEH68ccfZW9vb25jZ2cnPz+/Mn8XAAAAAFD1VPshSGVxcXFR//79NXLkSA0fPlxdunSRyWS6br0XahJrhy/FgoODzT2YgoKCzMcDAwO1efNmJScnlxh+JF0emvTX/eLhQa1bt9bevXt16dIl8/nt27fLxsbGYiWlsWPHKiAgQDExMXruued04MCBMuvs1auXPDw89MYbb5R6Pj09XZL08MMPy2g0mifl/bN58+apdu3aV1zJa9SoUSoqKtKSJUvKbAMAAAAAqB5qTA+YYvv371d8fLwSEhKUmJio9PR02draqkOHDnr++efNPStwWVUJX6TLAcxTTz2l/Px8iz+nwMBAPfHEE8rJySk1gImLi1OHDh10zz33KDY2Vrt27dLy5cslSSNGjNDMmTM1evRozZo1S+fOndPEiRM1atQo8/CjxYsXa8eOHfrhhx/UtGlTbdq0SSNGjNDOnTtLnb/FyclJy5YtU1hYmB544AE9/fTT8vPz0/nz57VmzRqdOHFCq1evVpcuXTRp0iRNnTpVeXl5FstQL1y4UAsWLFDTpk3LfB82NjaaPHmyIiMj9dhjj5mX4i4oKNCZM2cs2hoMBvPzAAAAAACqnmrfAyYlJUVLlixRWFiYPD091b59e02bNk2///67nnrqKX3xxRdKT0/X9u3b9eqrr6p3797WLrnKqKzwJa+wYr2MgoODlZ2dLT8/P4swITAwUBcvXlSLFi1KDSxmz56t1atXq127doqOjlZsbKxat24tSapTp442b96sP/74Qx07dtSQIUN07733KioqStLlYURTp07VkiVLzPdevHix0tPTNWPGjDJrHTBggJKSklS7dm0NHz5crVq10rBhw5SRkaHIyEhzuwULFmjJkiVavXq12rZtq7vuukuJiYlat26dJk6c+LfvZOzYscrPzzfXK0k//fSTGjVqZLF5e3v/7b0AAAAAANZjMFXzMTk2NjaqXbu27rnnHvOqOV26dLGYM6OmyczMlKurqzIyMuTi4mLtcgAAAAAAuCmV5/u82veAkaT8/HwdP35cJ0+e1MmTJ3Xu3DlrlwQAAAAAAGBW7eeAOXv2rHni1oSEBK1YsUKS5O3traCgIAUGBiooKIghGgAAAAAAwGqq/RCkvzp//rzi4+PNy08fOHBABoNBTZs2NQcyjzzyiLXLvCYMQQIAAAAAwPrK831e4wKYvyoOZBYvXqytW7fKxsZGBQUF1i7rmhDAAAAAAABgfeX5Pq/2Q5DKcvDgQYvlqIvnhanheRMAAAAAAKiCakwAc+jQIXPgkpCQoLNnz5rDFh8fH40ZM0bBwcEKDg62cqUAAAAAAOBmU+0DmBEjRighIUFnzpwxBy5NmjTRyJEjzYELE/ACAAAAAABrqvbLUK9atUqS9PDDD+vdd99VWlqaTpw4oejoaI0ZM+a6hS9z585VWFiYmjdvLoPBIB8fnwrd57vvvlNoaKhcXV1Vt25dBQUFaevWrdelRgAAAAAAUDVV+x4wKSkpatmyZaX/zgsvvKD69evrzjvvVHp6eoXusXv3bgUGBsrT01MzZsyQvb293n33Xd17773atGmT7rvvvutcNQAAAAAAqApqxCpI+fn5Wr9+vQ4fPiwPDw898MADatCgwXX9jSNHjqh58+aSpICAABmNRh07dqxc9+jSpYv279+vAwcOqFmzZpKkjIwMtWnTRnXq1FFqaqoMBsPf3odVkAAAAAAAsL7yfJ9X+yFIFy5cUIcOHTR06FBNnz5d48ePl7+/v5KTk6/r7xSHLxV15MgRJScnKywszBy+SJKrq6vGjRuntLQ07dy581rLBAAAAAAAVVC1D2AiIyO1f/9+3X///Vq0aJEmTJigrKwsPf7449YuzcKuXbskSV27di1xrvhYcRsAAAAAAFCzVPs5YD755BOFhoZqw4YN5mM+Pj6KiIjQyZMn1bRpUytW9z+//PKLpMsrNP1V8bFTp06Vem1ubq5yc3PN+5mZmZVQIQAAAAAAqCzVvgfMyZMn1bdvX4tj/fv3l8lk0okTJ6xUVUlZWVmSJHt7+xLnHBwcLNr81dy5c+Xq6mreqkqoBAAAAAAArk61D2Byc3NVv359i2Nubm7mc1VFnTp1JJVeU3Z2tkWbv5o+fboyMjLM28mTJyuvUAAAAAAAcN1V+yFIkspcOehqVhS6UW655RZJpQ8zutLwJOlyr5nSes4AAAAAAIDqoUYEMG+88YZWrlxp3s/Pz5fBYNDzzz8vd3d3i7YGg0EbN2680SWqY8eOkqSkpCSFh4dbnEtKSrJoAwAAAAAAahaDyWQyWbuIa2FjU75RVAaDQYWFhdf0mwEBATIajTp27Fip50+fPq2MjAw1a9bMYlhR586d9dNPPyklJcU8j0tmZqbatGkje3t7paWlXVWvnfKsMw4AAAAAACpHeb7Pq30PmKKiohvyOytXrtTx48clSefOnVNeXp4iIyMlSfXq1dOECRPMbadPn67o6GjFx8crKCjIfPzf//63goKC1L17dz399NOys7PTO++8o9OnT+uzzz6rUkOmAAAAAADA9VPtA5gbZfny5UpMTLQ4NmPGDEmSt7e3RQBTls6dO2vr1q168cUXNWvWLBUWFqpDhw7asmWLRVADAAAAAABqlmo/BOlmxBAkAAAAAACsrzzf59V6GeqXXnpJGRkZ5b4uPT1dL730UiVUBAAAAAAAUFK1DmDef/99eXt7a9KkSfruu+/+tv23336rSZMmydfXVx988MENqBAAAAAAAKCaD0HKzc3Vv/71L82bN0/p6eny8PBQp06d1KJFC9WvX18mk0kXLlzQzz//rN27d+v8+fNyc3PT1KlTNXnyZNnb21v7ESqEIUgAAAAAAFhfeb7Pq3UAUywnJ0erVq3SmjVrlJSUpIsXL1qcd3FxUffu3RUWFqahQ4dW2+ClGAEMAAAAAADWd9MFMH9WVFSkEydO6Ny5czIYDGrQoIGaNm0qG5tqPdrKAgEMAAAAAADWV57v8xq3DLWNjY18fHzk4+Nj7VIAAAAAAAAkVfNJeAEAAAAAAKoDAhgAAAAAAIBKRgADAAAAAABQyQhgAAAAAAAAKhkBDAAAAAAAQCWrUQHMiRMnlJ2dXeb57OxsnThx4gZWBAAAAAAAUMMCGF9fX3388cdlnt+wYYN8fX1vYEUAAAAAAAA1LIAxmUxXPF9YWCiDwXCDqgEAAAAAALisRgUwkq4YsCQnJ6t+/fo3sBoAAAAAAADJ1toFXKuFCxdq4cKF5v3JkyfrxRdfLNEuPT1dGRkZ+sc//nEjywMAAAAAAKj+AUy9evXk7e0tSTp+/Ljc3d3VsGFDizYGg0HOzs7q3LmzJk+ebI0yAQAAAADATcxg+ruJU6oRGxsbvf/++xo+fLi1S6lUmZmZcnV1VUZGhlxcXKxdDgAAAAAAN6XyfJ9X+x4wf1ZUVGTtEgAAAAAAAEqoUQFMsaNHj+qrr77Sb7/9phEjRsjHx0d5eXk6c+aMvLy8ZGdnZ+0SAQAAAADATaTGrYI0bdo0+fv7a/z48frnP/+pI0eOSJJycnLUunVrLVmyxMoVAgAAAACAm02NCmDeeecdvfnmm3rqqaf0xRdf6M/T27i4uOiBBx7QJ598YsUKAQAAAADAzahGBTBLlizRgw8+qAULFuiOO+4ocb5du3ZKTU21QmUAAAAAAOBmVqMCmEOHDqlnz55lnm/QoIHOnz9/AysCAAAAAACoYQGMg4ODjEZjmeePHz+uevXq3cCKAAAAAAAAalgA06lTJ3388celnsvOzlZMTIy6det2g6sCAAAAAAA3uxoVwEydOlU7duzQyJEjtWfPHknSL7/8oo0bN6pHjx765ZdfFBERUeH7r1q1SnfddZccHR3l4eGhYcOG6fjx41d1rclk0sqVK9WlSxe5u7vLxcVFbdu21auvvnrFXjsAAAAAAKD6M5j+vFRQDfDuu+9q0qRJysvLk8lkksFgkCTZ2dnp7bff1pgxYyp036ioKE2cOFHdunXTyJEjdf78eS1YsED29vbavXu3GjdufMXrp0+frtdee00hISEaNGiQatWqpS+//FIff/yxevToocTExKuuJTMzU66ursrIyJCLi0uFngcAAAAAAFyb8nyf17gARpLOnDmjuLg4HTx4UCaTSf7+/goLC9Mtt9xSofv9/vvv8vHxkb+/v3bu3ClbW1tJ0rfffqtOnTpp7NixWrZsWZnXFxQUyNXVVa1atdLu3btlY/O/jkcDBw7U+vXrlZKSolatWl1VPQQwVUN+fr5Onjypw4cPq2HDhmrXrp21SwIAAACAG+7PnR9uNuX5Pre9QTXdUF5eXpo4ceJ1u9/69etlNBr19NNPm8MXSerQoYN69OihNWvWaMmSJbKzsyv1+vz8fGVnZ8vLy8sifJFk7jlTp06d61YvKp/RaNTw4cOVkpKiw4cPy9XVVQMHDtSKFSusXRoAAAAA3BCFhYXKycnR0aNHFRAQcFMHMVejRs0BU1l27dolSeratWuJc127dtXFixd18ODBMq93dHRU165d9fnnn+uNN97Qzz//rGPHjmnp0qVasWKFxo0bp2bNmlVa/bi+jEajOnfurLy8PL300kvasWOHevXqpTVr1mjevHnWLg8AAAAAKp3RaNT48ePVrVs3tWvXTvfcc4/WrFmjgoICa5dWZdWoIUghISFXPG8wGOTo6KhmzZqpd+/eeuCBB64qnevfv78+/fRTZWVlydHR0eLckiVL9NRTT2njxo3q27dvmfc4ceKERo8erYSEBPMxGxsbzZo1SzNmzLji7+fm5io3N9e8n5mZqaZNmzIEyQry8/P16KOP6tdff9WyZcvUrFkz2djY6Pz587r77rvVtm3bMlfiAgAAAICawGg0qlOnTmrYsKF69Oghd3d3/fvf/5bJZNL//d//qX379tYu8Ya5aYcgHTlyRNnZ2Tp37pwkqV69ejKZTMrIyJAkNWjQQIWFhfrss8/0zjvvKDAwUBs3biwRqvxVVlaWJMne3r7EOQcHB4s2ZalTp45atmypZs2aKTQ0VDY2Nlq3bp3++c9/qrCwULNmzSrz2rlz52r27NlXvD9ujO+//14//fSTxo4daw5f8vLy5OHhoV69emnLli26cOGC3NzcrF0qAAAAAFx3ubm5GjlypG655Ra9++678vX1lSQFBgaqe/fu+uijj26qAKY8atQQpPj4eDk6OuqZZ57RmTNn9Mcff+jChQs6c+aMJk+eLCcnJ+3Zs0fnzp3TpEmTlJCQoDlz5vztfYvnZ/lzL5Ri2dnZFm1Kk5WVpa5duyojI0PR0dEaNmyYhg4dqlWrVumRRx7Ryy+/rL1795Z5/fTp05WRkWHeTp48+bc1o3I0atRIvr6+GjlypHk+n+K5fxo2bKiMjAzVoE5lAAAAAGBhw4YNOnLkiCZNmiQfHx9JUlFRkby9vdW8eXP99NNP1i2wCqtRAcyUKVN09913a/78+fL09DQf9/T01L/+9S917NhRU6ZMkbu7u/71r3+pd+/eiouL+9v7Fq+edOrUqRLnfvnlF0lSkyZNyrz+o48+UlpamsLCwkqcGzp0qEwm0xWXoba3t5eLi4vFButo1qyZYmJi5OrqqqKiIkky/2+9evVUq1YtFRYWmtsXB3QAAAAAUFNkZWWpe/fu5ik9bGxsVK9ePd1666365ZdfVFRUZP5Owv/UqAAmISFBQUFBZZ4PCgrSV199Zd7v1auXTpw48bf37dixoyQpKSmpxLmkpCQ5OztfcQnp4pAmPz+/xLniY0xUVH0U93b664pWtWvXtuj9YjQaNWbMGIWGht7Q+gAAAADgeiv+1gkLC9POnTst/lG6+JydnZ0MBoNsbGzM30v5+fmlfgvfjGpUAFNQUKBjx46Vef7o0aMWf/AODg5lLh39ZwMGDFCdOnX073//2yIo+fbbb7V161Y99NBD5vucPn1aBw8etJgTpnXr1pKk6OjoEvd+7733JEmdOnX62zpQNRX/hyUvL085OTkymUzKzs5WRESEPvvsM+bvAQAAAFBtFRQUKC8vTwaDwdzb393dXdL/voX+3Nvlz/9QbTQa9c9//lOvv/46UzWohgUw3bt3V1RUVKnDeRISErR48WJ1797dfOzHH3+84tChYh4eHnr11Vf1/fffKygoSO+8847mzJmj0NBQNWzYUC+//LK57fTp03XbbbeZl66WpH79+qlTp07atGmTevTooQULFmjhwoUKDg7Wxx9/rH79+lnUherJxsZGBoNBmZmZevbZZ7Vy5Upt3bpVnTt3tnZpAAAAAFBuRqNRw4cP13/+8x/l5uaqVq1apQYptWrVkiTZ2toqNzdXRUVFyszM1JQpUzRv3jwNGjToqlYgrulq1CpI8+bNU7du3RQSEqI777xTLVu2lCQdPHhQe/bskYuLi958801JUk5Ojr766isNHDjwqu49adIkeXh4aP78+Zo8ebLq1Kmjnj17au7cueY5YspSq1YtxcfHKyoqSqtWrdKsWbOUk5MjPz8/zZkzRxEREdf24LAqk8kkg8EgOzs72dvba8KECUpMTNT27dt1xx13WLs8AAAAACi37OxshYaGKikpSXv27FHdunU1fPhw2dvbm7+B/qq4l0xGRoamTZumDz74QLt27VKbNm2s8ARVj8FUw/oBHTlyRC+88II2btyoS5cuSZKcnJx0//33KzIyUn5+flau8NqVZ51x3DjLli3T+PHj5eLiosTERJZeAwAAAFAtFRYWavbs2Vq9erVGjRql1atX69y5c3r99ddLDWEKCwtVq1YtjRgxQmlpabr99tv1/vvv3xT/KF2e7/MaF8AUKyoq0rlz52QymeTp6VliwtTqjACmavr555/10EMP6YMPPrjipMwAAAAAUJWdPXtW9957r1xdXfXNN98oPT1d3bp10/nz5/Xaa6+V2RMmPDxcy5cvl5ubm7788kvdeeedVnyKG6M83+c1agjSn9nY2Khhw4bWLgM3ET8/PyUlJcnBwcHapVRpRUVFMhgMjAEFAAAAqihPT09FRUWpbdu2kqR69erpyy+/VM+ePfX8889LkjmE+bM2bdqodu3a2rZtm3kxGvxPte4Bs3Xr1gpd16NHj+tcyY1FDxhUV0ajUWPHjtWrr75aI4YDAgAAADVdYWGhecGRX3/9VT179tT58+c1d+5c/eMf/5Ctra1OnDghBwcHeXp66vz58/Lw8LB22TfMTdMDJigoqEL/il68dBaAGyczM1M9evTQDz/8oAYNGmjx4sXWLgkAAADA3yhe4chkMqlx48bmnjAvvPCCDAaD7r77bj399NPKy8vT/2PvzuOiqhf/j7+HbQDRIdkCcyEUNQL3JTRFUSTNtczcSs2yXMm6V3ApyZLqm3rdunSzTC3lkrbo1VBQUxRx7f5crqRXczcXNIYRGJhhfn9wZxJhkJlh5nxm5v18POZxg9k+H+8MzHlxzudkZWU5VXwxlV0HmNWrV1f53vLly5GXl4fRo0cbdnk6deoU1q9fj9atW2Pq1Km2HiaR01MqlYiKikLTpk0RGRmJrKwsXLt2DSEhIVIPjYiIiIiIakEmkxkizK5duxAbG4vZs2fDz88Ply9fRlZWFtzd3aUeptDsOsC8/PLLlb5esWIFrl+/jtOnT6Nx48aVrpszZw6eeuopqFQqWw6RyOkplUq0adMGoaGh2LZtG7Zu3YoXXngBmzZtwrRp06QeHhERERER1ZL+CJSgoCB8/vnn6NatG0pLS7Fv3z7DejFknOOcGggVe79MmjSpSnwBgKZNm+L111/H8uXLJRgZkXMqLCxEREQEmjdvjvXr18PLywvt2rVDaGgovvjiC1y6dEnqIRIRERERkYnOnDmDpUuXol69esjOzmZ8qSWHCjAXL16Er6+v0et9fX1x8eJFG46IyHnpdDpMmjQJrVu34dIEGAAAIABJREFUxpo1axAcHAwACAsLw8SJE3HixAnk5eUBqDgzEhERERERiU+j0SA1NRWbNm3i2Y5MZNdnQXpQ8+bNERwcjJ9//tmwUJCeRqNBz549cePGDfz3v/+VaIR1g2dBIntx7do1eHp6omHDhgAqQouLiwvOnj2LXr16ITQ0FNu3b4e3t7fEIyUiIiIiEp9OpzPrRDR17dy5c9BoNGjZsqXUQ5GcKdvnDrUHzKRJk7B//37ExsZiy5YtOHv2LP773/9i8+bNiI2NRW5uLt544w2ph0nkNEJCQgzxBQBcXCp+5LRo0QJ9+vTB0aNHcfz4cQDcC4aIiIiIyBitVot79+7h1KlTACpCjJTCwsIYX8zgUHvAAMCbb76JZcuWVXtdQkICFi1aZOMR1T3uAUP2TL8XTF5eHjp27IjRo0fjs88+k3pYRERERERCUqlUmDFjhuGPl9HR0Zg2bRqee+45uLnZ9Xl1HIIp2+cOF2CAigWBNm/ejHPnzgGoqHODBg1CeHi4xCOrGwww5AgKCgowZswY7N27FxkZGXjqqaekHhIRERERkVBUKhU6d+6MoKAg9OjRA35+fli2bBl0Oh2+++47tGnTRuohOj1Tts8dMpeFh4fj7bfflnoYRFQDhUKBN954AxkZGdi/fz8DDBERERHRfdRqNcaMGYNGjRrhH//4B0JDQwEAPXv2xNNPP42NGzcywNgZh1oDhojsS2xsLFq2bInU1FSo1WrJj2UlIiIiIhLF5s2bcf78ecyYMQPNmjUDUHE4f9OmTfH4448b1oMh++FQe8D07t37obeRyWTYuXOnDUZDRA8jl8sxdepU9OjRA3K5XOrhEBEREREJpaioCE8//bThzEcuLi7w9fVFixYtcOnSJcOJLPQnuyCxOVSAOX/+fJVTcmk0Gly/fh3l5eXw9/dHvXr1JBodEd1Pfwq9119/XeqhEBEREREJQ/85efjw4ejduzcUCoXhRBb66zw8PCCTySqFl7KyMgCAu7u7VEOnh3CoAHPhwoVqv69Wq7F48WKsXr0ae/bsse2giKhaD8ZSIiIiIiJnptFoUF5eDg8PD2i1Wri6usLPzw/An3u4lJeXw9XVtdL3gIrFej/44APUq1cPc+bM4WdtQTnFfkpyuRxJSUno0qULZs6cKfVwiIiIiIiIiAxUKhVGjRplWBvR1dW12vUR9fHFzc0NarUa5eXlUCqVmDlzJj755BMMHTqU8UVgDrUHzMN0794dSUlJUg+DiIiIiIiICABQXFyM+Ph45OTk4JdffkH9+vUxatQoyOVywyFHD5LJZNBqtSgoKMCsWbOwfv16HDp0CBERERLMgGrLKfaA0fvtt99QWloq9TCIiIiIiIiIoNVqkZKSgps3byI5ORkeHh6GoKJWqyGTySrtCaPVagFUrPeiv+3XX3+N7OxstGvXTqppUC051B4wly5dqvb7d+7cQVZWFpYtW4aYmBjbDoqIiIiIiIioGvn5+fj+++8RGBiIefPmYdq0aejWrRsSExMBoMqeMPpDkLy9vXHkyBGcO3cO+/btY3yxEw4VYJo1a2b0eDedTodWrVph2bJlNh4VERERERERUVWBgYFYsWIFIiMjAQC+vr7IzMxE3759q0SY+0VERMDd3R3Z2dl44oknbD5uMo9MV93KPnZq/vz5VQKMTCZDw4YNER4ejj59+jjE+dGVSiUUCgUKCgrQoEEDqYdDREREREREFtJqtXBxcYFMJsO1a9fQt29f3L59GykpKXjppZfg5uaGS5cuwdPTE4GBgbh9+zb8/f2lHrbTM2X73KECjLNggKlj8xWVvvzyl1JM3FyCSR3csXKAJ1xqWEV865kyDEsvRv8Wbvjn817wcDV+20NXtei77h6eDHRFxmhv1Jcbv+2ZfC3Cl6tMnwsREREREdk1/eFG+giTn5+PlJQUdO3aFdOnT0dpaSmysrLg7u4u9VAJpm2fO9QhSESWEiW+9FpThKvLLZoKERERERHZIf3CuyEhIdi1axdiY2Mxe/Zs+Pn54fLly4wvdsz+j8d5QHFxMVJSUtC5c2f4+fnB398fnTt3xocffoji4mKph0cCEym+KGq4DREREREROTb90hpBQUH4/PPPcePGDVy/fh379u1Dp06dJB4dmcuhAszNmzfRsWNHzJkzB2fOnEHTpk3RuHFjnDlzBrNnz0anTp1w69Ytsx9/w4YN6NChA7y8vODv74+RI0fi4sWLtb6/VqtFamoqunTpgvr168PHxweRkZFYsGCB2WOiuiFafNn1srdF8yEiIiIiIvt35swZLF26FPXq1UN2drZhsV6yTw4VYP7yl78gLy8Pixcvxs2bN3Hs2DH88ssvuHnzJhYtWoTTp0/jL3/5i1mPvWLFCowaNQpeXl5YsmQJEhISkJmZiejoaFy7du2h9y8rK8OQIUMwbdo0hIeH4//+7/+wePFiDBw40Ojps8k2RIwvj/o41FuTiIiIiIhMpNFokJqaik2bNvFsRw7CoRbh9fPzw3PPPYd//OMf1V4/ceJEfP/998jPzzfpcfPz89GsWTOEh4fj4MGDcHOrWDrnyJEj6Ny5MyZMmIBVq1bV+Bjvvvsu3n//fWzbtg39+vUz6fkfxEV465aLTCZmfJlfYPaciIiIiIjI/p07dw4ajQYtW7aUeihkhCnb5w71Z/bS0lK0b9/e6PUdO3ZEaWmpyY/7448/QqVSYfr06Yb4on+8Hj16ID09vcbHvXfvHv72t79h4MCB6NevH3Q6HQoLC00eB1mHkPGFiIiIiIicXlhYGOOLA3Gorb1OnTrh2LFjRq8/evQoOnfubPLjHjp0CAAQHR1d5bro6GgUFhYiLy/P6P337dsHpVKJzp074+2334avry8aNGiAhg0bYtq0aSgqKjJ5TFR3GF+IiIiIiIjI2hzqNNSLFi1CbGwsIiMj8frrrxtOzaXRaLBy5Up899132Llzp8mPe/XqVQDAY489VuU6/feuXLmCqKioau+vjzN/+9vf4Orqivfffx8hISH44YcfsGLFCpw+fRqZmZmGla4fpFaroVarDV8rlUqT50DGMb4QEREREZGzaZa4tdrva1V3cSNtNsrV9xA0MgXuDRsZfYxydRFufvsuSm9dRNCIBZCHGN9bR6ctw60fP0Lx+SMIGDoH3mHVn83pwocDTJuIHbHrANO7d+8q3/Pz80NCQgLeeecdPP7445DJZDh37hyUSiXCwsLw1ltvmRxh9HuoyOXyKtd5enpWuk119Icb3blzB8ePHzcsnvTcc88BAL7++mvs2LHD6NowKSkpSE5ONmnMZDnGFyIiIiIiciZSxxdHZ9dbfufPn8dvv/1W6aLRaNCkSRP4+vrizp07yM/Ph6+vL5o0aYKysjKcP3/e5Ofx9q44JfD9e6HoFRcXV7pNdby8vAAAXbp0qbJy9YQJEwAAu3fvNnr/pKQkFBQUGC6XL182bQJkMsYXIiIiIiJyJiLEF52u3KI5iM6u94C5cOGCTZ6nUaOKF96VK1fQokWLStfVdHiSnv664ODgKtfpv3fnzh2j95fL5dXufUPWIUJ8+V1VjkctmgUREREREVHtiBJf7uz4O/DRQIvmIjL++b0WOnWqeJHk5ORUuS4nJwc+Pj5o1aqV0ft36dIFAKrdc+XSpUsAgKCgoLoYKllIlPjSew0XZiYiIiIiIusTKb6o/p1h0VxExwBTC4MHD4a3tzeWLVsGjUZj+P6RI0ewd+9evPDCC/Dw8AAAXL9+HXl5eZXWhGnWrBl69OiBw4cPIzc31/B9nU6HlStXAgD69+9vo9mQMSLFlwK1zqK5EBERERERPYxo8cXvmWkWzUd0DDC14O/vj4ULF+LYsWOIiYnBZ599hg8++ADx8fEICgrCe++9Z7htUlISWrdubTh1td7y5cvh4+ODfv36Ye7cuVi5ciXi4+OxefNmTJgwAU899ZStp0X3ES2+7H7Z+JpCRERERERElhIxvvhExVk0J9HZ9RowtjRjxgz4+/tj0aJFSEhIgLe3N/r27YuUlBTDGjE1iYqKwoEDBzBv3jx8+umnuHfvHpo3b44lS5Zg+vTpNpgBGSNifAn3c7VoTtakP13dHzlpKMj+Goqnx8A3+sUa76M6vgP5Py2HT9t4NIx7AzKZ8X+LonOHcev7D+D1eEcEDJ4Fmau70duqr/2KG/+cB4+Apii58h/zJkRERERE5IQYX2xPptPpeKyDnVEqlVAoFCgoKECDBg2kHo7dk7vJxIwv8wvMnpM1NUvcKlx8CRyejEtLhps9JyIiIiJyXmq1Gj///DPOnTsHLy8vjB8/Xuoh2YRbfT8h48uFDweYNyGJmLJ9zj1gyOkJGV8EJmJ8cZHzkC0iIiIiMl1hYSEGDhyIK1eu4LfffoNOp8O3336Lbdu2ST00qxMxvjg6h1oDZu3atTWemvrChQtYu3at7QZEdoHxxTSML0RERETkCFQqFTp37gwPDw8sX74cZ86cwcyZM3Ho0KFKJ09xVIwvtudQAWb8+PHVnipa7+DBg06zOxnVHuOLaRhfiIiIiMjeqdVqjBgxAo0aNUJqairi4uIQFhaGsWPHoqSkBHK5HCUlJVIPUxKML9bjUAHmYcvZqNVquLraz4YuSYvxpXqML0RERERk73755Rfcu3cPEyZMwOOPPw4Xlz8/s4aEhGDBggXo1KkT4uLicOLECQlHaluML9Zl92vAKJVK/PHHH4av8/PzcenSpSq3u3v3LjZs2FCrMxYRMb6Yh/GFiIiIiOxBVFQUEhMT0bNnTwCATCaDWq3Giy++CI1Gg+DgYAQHB2PLli0YMmQIDhw4gMDAQIlHbV2ML9Zn9wFmyZIleO+99wBUvGkSEhKQkJBQ7W11Oh0WLlxoy+GRHRIhvhSqdahv0Sxsj/GFiIiIiOyFt7c34uPjAQDl5eWQyWQYP348FAoFvvrqK7Rq1QoA8Mwzz2Do0KFYvnw5FixYIOWQrUqU+PJHThoA+zoLkinsPsDExMQAqIgr7733HoYOHYqoqKhKt5HJZPDx8UGXLl3QrVs3CUZJ9kKU+BL/TRH2p1g0FZtifCEiIiIie6U//OiVV15BmzZt4O/vb7iuV69eUCgUUKvVUg3P6kSKLwXZXwNYZ+5UhGf3AaZnz56G3cb27NmDyZMnIzY2VuJRkT0SKb6cvKm1aC62JEJ8Kbtz1aI5EBEREZHz0ul0kMlkVbYjdTodjh8/Dn9/f7Rt27bSbR2FaPFF8fQYs+diDxxqEd7du3czvpBZRIsvmWPrWTQfWxElvtzYkGTRPIiIiIjIed0fVMrLyw3/fffuXXz22Wdwc3OrtFaMoxAxvjzshB/2zu73gDFGpVLhjz/+qPQG0mvSpIkEIyJzlZWV4fLlyzh37hyCgoKqHGJmKRHjS+dG4i/OK1J8cZHbR7AiIiIiIrHpD0c6ePAgPv30U/zwww/Izs52yJO5ML7YnsMFmLS0NLz//vs4ffq00dtotfZzeIezU6lUGDVqFE6fPo1z585BoVBgyJAhWL16dZ09B+OL6USLL0EvcnFtIiIiIqobH3/8MTIyMnDjxg1kZ2fX+R+ARcH4YnsOFWB++OEHjBo1CuHh4Zg0aRJSU1MxatQoaDQa/PDDD4iMjMSzzz4r9TCpllQqFbp06YLGjRtj7ty5aNWqFRYvXoz09HRERETg7bffrpPnYXwxjYjxxdXnEYvmRERERESkN3ToUHh7e2PgwIFo2rSpxY/XLHFrHYyq7jG+2J5DBZhPPvkErVu3xtGjR6FSqZCamooJEyagd+/eOHnyJLp162ZYPInEVlZWhsmTJyM4OBipqalo0qQJXFxcsHLlShw9ehT79++vswDD+GIaxhciIiIiMoe1lxaoKy1atEBYWJjhcCRHxfhiew71ijp+/DhefvlleHp6Gt4s+sONnnzySbz22mtISbGjc/s6sWPHjuHUqVMYOnSoIb6UlpbC398fcXFxOHXqFO7evVsnz8X4YhrGFyIiIiIylUqlwnPPPYd+/fqhX79+6NmzJ8aPHy/1sIxy9PhSE8YX63GoV5VWq4Wfnx8AwMvLCwBQUFBguL5ly5Y4efKkJGMj0wQHByM0NBRjxowx/PDz8PAAAAQFBaGgoAA6nc6qY2B8qR7jCxERERGZQr+0QGlpKebOnYsDBw4gLi4O6enp+OSTT6QeHt2H8cW6HCrAPPbYY7hy5QqAigATGBiII0eOGK7/9ddfUa8ez5ZiD5o0aYK1a9dCoVAYzmSl/19fX1+4urpWWky5uLi4Tp+f8cU4xhciIiKiqgoLCzF16lT8/vvvUg9FKA8uLTB27Fh06dIFK1euRHBwMPbv3y/1EOl/GF+sz6HWgImOjkZmZibeffddAMCgQYOwdOlSeHt7o7y8HCtXrsTAgQMlHiXVlrd3xQb5g7v/ubu7V9r7RaVS4ZVXXkFBQQEyMjIsfl4R4kupVgcPi2ZREaxkMhlkMuOHWNUlxhciIiJyVsXFxYiNjcWRI0eQl5eHDRs2ICAgQOphCUG/tMCECROqXVogKysLd+/exSOP8DOelESJL6rjOwAMMGcKdsGh9oCZPHkyevToYdgb4oMPPkB4eDjmz5+P9957D2FhYdzFzY7pQ0xpaSlKSkqg0+lQXFyMt99+G9u2bUNycrLFzyFKfBmx0bI9elQqFV588UWcO3fOosepLcYX0rP2oYFERESi0Wg0SEpKwu+//47Ro0fj6NGjGDp0KG7duiX10IQgwtICVDOR4kv+T8vNmoO9cKg9YDp16oROnf58sQQEBODf//43Tpw4AVdXV7Ru3dqpF1NyFC4uLpDJZFAqlZg/fz7WrVuHffv2oV27dhY9rkjxZdtZjdnzUCqV6NGjB44fP46AgACsXLnS7MeqDRHii1ZVNwsyk2lKS0tx/fp1XL9+HREREfD09IS7uzvKy8v5s5aIiJzGqVOnkJWVhejoaCxatAi9e/fGzJkzMWzYMHz33XdOvyeMfmkB/VEJLi4uhv81trSAfj1Psj7R4otP23iz5mEvHP4TskwmQ1RUFCIiIrhBYOf0ZdzDwwNyuRxTp07F6tWrkZ2d7XDx5bsXzPulo1QqERUVBYVCgcjISGRlZeHatWtmPVZtiBJfbqTNtmgeZLrCwkLEx8cjJiYG0dHRePLJJzFp0iTcvn0bLi4u/EsWERE5DV9fX4wYMQKffvopAgMDMWzYMHz44Yc4efIkhg0bZtgTxpl/N5qytMC4ceMQH+/YG+GiEDG+NIx7w6y52AuHLBJ79+7F3Llz8eqrryIvLw9AxZt57969+OOPPyQeHZlLv5aJm5sbbty4gdzcXOTm5qJ9+/YWPa6I8WVAuPGQYYxSqUSbNm0QGhqKjIwMzJs3D2fPnsWmTZtMfqzaECm+lKvvWTQXMk1xcTG6d+8Od3d3LFy4EDk5OejWrRu2bNmCjh074tSpU5DJZE79QZOIiByf/vdc06ZNMXv2bDRs2BBlZWVQKBQYPXp0pQhz48YNw2fZW7duoaSkRMqhS84WSwvQw4kYX2o64YcjcKjZabVajBgxAr169cLChQvx5ZdfGv767+bmhiFDhuDTTz+VeJRkqZiYGLRt2xa5ublo06aNxY/nCPGlsLAQERERaN68OdavXw8vLy+0a9cOoaGh+OKLL3Dp0iWTH7MmosWXoJEpFs2HTLN161YUFBTg448/xosvvoiuXbtizZo1WLRoEdzd3REXF4eTJ09CJpMZzl5GRETkKDQaDUpLSyv9nnN1rfis5+5e8ZnIx8enUoR5/vnncfv2bVy6dAnTp09HQkIC/1CByksLvPXWW1i3bh327t2LLl26SD00p8D4YnsONcOPPvoImzZtwuLFi3H69OlKP9Q8PT0xdOhQbNu2TcIRUl1o3rw5cnJy0KpVqzp5PHuPLzqdDpMmTULr1q2xZs0aBAcHAwDCwsIwceJEnDhxwrAnWF1sDIsYX9wbNrJoTmSa8+fPo7CwEG3atIFMJkNpaSnc3d0xZswYLF68GD4+Pujfvz9u3rzJw5FQ8b5z9n8DIiJHoVKpMGrUKKSmpkKtVtf4e87HxwcjR47Exx9/jJMnT2LgwIGYNGkSfvjhB0yePNlmZ6oUkTWXFqDaY3yxPYea5dq1a/HSSy9hxowZ8Pf3r3J969atbXZWGLIuT0/POnsse44vQMWhWZ988gnS0tIQEhIC4M/Q8vzzzyM4OBgLFixAUVFRnayDxPhC4eHhUCqV2L59O4CKD0/6xfQGDBiAd955ByUlJZg+fTrUarVTf8C09RnJiIjIeoqLixEfH4+NGzdi+fLlWL9+veH3XHURpry8HA0aNMDIkSPx17/+FQcPHsTBgweRm5uLqKgoCWYgDmstLUCmYXyxPYea6YULF/DUU08Zvd7X1xd37/JsKVSZPccXvZCQEDRs2NDwtT60tGjRAn369MHRo0dx/PhxAJbvBcP44pzu/2DZrFkz1K9fH6tXrzYc3nb/GQ1GjBiBQYMGYc+ePbhz545UQ5acUqlE9+7dsXHjRixZskTq4RARkQW0Wi1SUlJw8+ZNJCcnw8PDA7Nmzaoxwug/j925cwe5ubmoX78+9u3bVyeH0DuKul5agOoG44v1ONRs69evX+OH/bNnzzr9aeCo9uwlvhijDy2JiYlwcXHB6tWrAVRdfd5UjC/Opbrj3Nu2bYu5c+ciPT0dX375JfLz8wFUvLbKysrg5uaGpKQk3LhxA0ePHpVy+JKx9RnJiIjIuvLz8/H9998jMDAQ8+bNw/79+xEQEIDExMQaI8y9e/eQnJyMLVu2YO/evXjiiSckmoGY6nppAbIc44t1OdSMu3fvjq+//rraXQDz8/Px5ZdfolevXmY//oYNG9ChQwd4eXnB398fI0eOxMWLF816rBdeeAEymYw/bARl7/EF+DO0BAcHo1evXkhLS8OBAwcsflzGF+dR3XHuGo0GAJCQkIDJkyfjgw8+wMqVK3HlyhUAFYsPlpeX48KFC3j00Ufx2GOPSTkFSdj6jGRERGR9gYGBWLFiBTZv3gygYs/6zMxM+Pv7V4kw9/Pw8MCgQYNw4sQJ7uFhRF0uLUCWYXyxPoea9Zw5c3D27Fn07t0bP/74IwDg2LFjWLlyJdq3b4+ioiIkJiaa9dgrVqzAqFGj4OXlhSVLliAhIQGZmZmIjo42+a+aW7duxaZNm+Dl5WXWWMi6RIgv5XW4YKdCocAbb7yBoqIi7N+/v84e90GML47F2HHubm5u0Ol0cHFxQXJyMl599VXMnz8fc+bMwe7duwEAV65cwcaNG6FQKAyLQjsLW5+RjIiIbKdnz55o2LAhtFotdDodQkJCKkWYb775xvCHisuXL+PmzZtwd3fH4MGDERERIfHoiWomSnwpOnfYrPHbC5nOwU7NsG3bNkyYMAE3b94EAMOugIGBgVi7di3i4mp+IVUnPz8fzZo1Q3h4OA4ePAg3NzcAwJEjR9C5c2dMmDABq1atqtVjqVQqREREYNCgQdiyZQs8PT0NZ6ipLaVSCYVCgYKCAjRo0MDk+dAD5isM/ylKfJmytQR/P1Jq3nyqoVar0aFDB5SUlODUqVPw8PAwe2HUZolbqz6+APHlwocDTJsIGaXVapGcnIy0tDSMHTsWaWlpuHXrFj766COMGjUKcrnccNuysjIsXrwYCxYsMPys9fb2xu3bt7F9+3a0bdtWwpnYlk6nw+jRo3H79m189dVXhkWxASAlJQVz587FTz/9hLi4OMN6OUREZL90Oh1kMhmuXbuGvn37Ij8/HykpKejatStmzJgBtVqNrKwsw6mpyXlV9/lZJCLFl1vffwCdpsyseUjFlO1zhwswQMXGZmZmpuFU1OHh4ejXr5/Ze5x8+eWXeOWVV/DVV1/h5ZdfrnRdTEwMjh07htu3b8PDw+Ohj5WQkID09HTk5eUhKiqKAUYE/wswIsWXz46W1eleMACQmpqKHj16WHzs8YO/QESIL+XqIlxaMtz0yVC1bt68idjYWCgUCuzbtw9//PEHunXrhtu3b+PDDz80RBj9B08AyM3NxenTp3Hs2DG0bt0a8fHxePzxxyWeie1du3YNnp6ehkWx9aHl7Nmz6NWrF0JDQ7F9+3Z4ext/nxARkf3Q/y68ceMGYmNjkZ+fDz8/P1y+fBk7d+5Ex44dpR4iCUDkACNafPF6vCOKzli+bIItmbJ97majMdmUXC7Hs88+i2effbZOHu/QoUMAgOjo6CrXRUdHY8+ePYagUpPDhw8bduVnOBGLaPFl1aC6OxZW/8Hg9ddfr7PH1BMlvtz89l2AAabO6I9zj4yMBPDnce59+/Y1HMapjzD6wNC1a1d07doV48ePl3Lokrt/rxeg6hnJ0tPTcfz4cXTt2pV7wRAROQD9HyKCgoLw+eefo1u3bigtLcW+ffsMv0eJRCVifAkYPMusudgLfvKrhatXrwJAtYtJ6r+nX4DSGI1Gg1dffRV9+vTBiBEjTHp+tVoNpVJZ6UJ1R8T4MqHdw/emqi1zDzV6GJHiS+kt8xbDJuNqe5y7i4sLLl26hFu3bkk9ZGFZ64xkREQkjjNnzmDp0qWoV68esrOzGV/ILogYX2o64YcjsPs9YHr37m3S7WUyGXbu3GnSfYqKigCg0roHevpVu/W3MWbRokX49ddfzToLRkpKCpKTk02+H9WOI8cXaxEtvgSNWGDRfMg4V9eK1/n9EaZv376YPXs2ZDKZ4Tj30tJSZGZm8jj3alR3RrJx48bhqaeeknhkRERUFzQaDVJTU7Fp0yYcPnyYp5omu8H4Ynt2H2AOHTpU5S/8RUVFkMvlhg2H+5mzN4D+WH21Wl1lHZni4uJKt6nOuXPnkJycjNmzZyMsLMzk509KSsLMmTMNXyuVSjRu3Njkx6HqMb6YRsT4Ig9padGc6OH0C5qHhIRg165diI2NxezZsysd5874UjP9GckyMjKwf/8s0IDJAAAgAElEQVR+BhgiIgfh5uaGKVOmYNKkSWjZkp9JyH4wvtie3QcYlUpV6evbt28jMDAQ//rXv0zeO8aYRo0qNgSvXLmCFi1aVLqupsOT9N566y088sgjGDFiBC5cuGD4vkajQVlZGS5cuAAvLy8EBQVVe3+5XF7t3jdUNxhfTMP44rx4nLvlYmNj0bJlS6SmpmLatGkWnZGMiIjEYc4fWYmkxvhie3YfYB5kjQ+ynTp1wmeffYacnJwqASYnJwc+Pj5o1aqV0ftfuHAB165dM1rEQ0ND0a9fP2RkZNTpuKl2GF9Mw/hCDx7nzl2ta08ul2Pq1Kno0aMHwzoREVFd+9/ZTe+39UwZhqUXo38LN/zzeS94uBrfXjx0VYu+6+7hyUBXZIz2Rn258dueydei15oiKOQy7HrZG4/61LS223pTZiEExhfrcLgAYw2DBw/G9OnTsWzZMowePRpubhX/bEeOHMHevXsxfvx4wymor1+/joKCAjRp0sRwWNKSJUtQUFBQ5XFfe+01eHh4YMWKFUb3fiHpML5Uj/HFuYl+nHthYSGSkpIwd+5cPProo1IPpxJrnpGMiIiIqhIhvvyuKre7rW7GF+uxs5eCNPz9/bFw4UIkJCQgJiYGY8eOxe3bt7FkyRIEBQXhvffeM9w2KSkJa9aswe7duxETEwMA6NWrV7WPm5CQAE9PTwwZMsQW0yATML4Yx/ji3EQ+zr24uBixsbE4cuQI8vLysGHDBgQEBEg9LAMeakRERGQ7osSX3muKgFcsmopNMb5YF8+BWUszZszA119/jaKiIiQkJGDx4sXo06cPcnJyDGvEkGNgfDEP44vzCAsLEy6+aDQaJCUl4ffff8fo0aNx9OhRDB06lKfHJiIickIixZcCtc6iudiSCPFFfe1Xs8dvDxhgTDB69GgcO3YMxcXFyM/PR1paGkJDQyvd5quvvoJOpzPs/VKTCxcuIC8vz0qjJXOIEl/e36s2ew5SYHwhqZ06dQpZWVmIjo7GokWLsHjxYpw6dQrDhg1jhCEiInIiosWX3S8b33tcJKLElxv/nGf2HOyB3R+C9PHHH1f6uqioCDKZDGlpaThy5EiV28tkMvzlL3+x1fDIjogUX+btVmOu2TOxLRHii05bZtEcyP75+vpixIgRmDJlCho2bIhhw4ahtLQUiYmJGDZsGL777jsEBAQY1mEhIqKalZeXQyaT8Wcm2RUR40u4nytQYtG0rE6k+OIR0NTsedgDmU6ns599oqrh4mLaTjwymQxardZKo7ENpVIJhUKBgoICNGjQQOrh2L/5CuHiy4JecszdJeZP6maJWw3/LUp8ufXjRyg6c8C8CZFduz+oaLVauLq6oqysDO7u7lCpVPjmm2+QmJiIJ598Ehs3bjQseH7r1i3Ur18fnp6eUg6fiEhIKpUKEyZMwMKFC9G8eXOph0NUa3I3mXjxBUCzEnHPgiRafAkcnoxLS4abPR8pmLJ9bvd7wOzevVvqIZCdEzK+9BD/9LQixZfi81X3diPHptFoUF5eDg8PD5SXl8PFxQWurhXvXXf3ivelj48PRo8eDQBITEzE888/j++//x5FRUWYNWsWFAoF/v73v/Ovu0RE91EqlejRoweOHz+OgIAArFy5UuohEdWaiPFFZCLGl5pO+OEI7D7A9OzZU+ohkJ1jfDGdaPElYOgci+ZD9kX/l9nu3btj0qRJkMvlRg8t8vHxwciRI+Hi4oK//vWvGDhwIHx9ffHzzz/j4MGDjC9ERPdRKpWIiopC06ZNERkZiaysLFy7dg0hISFSD42oVhhfTMP4Ynt2H2DIjsxXSD2CajG+mEbE+OId1smiOZH9KC4uRnx8PHJycvDLL7+gfv36GDVqlNEIU15ejgYNGmDkyJG4ffs25syZA19fX+Tm5iIqKkqiWRARiUepVKJNmzYIDQ3Ftm3bsHXrVrzwwgvYtGkTpk2bJvXwiGqF8cU0jC+2x7MgkdNjfDEN4wtJRavVIiUlBTdv3kRycjI8PDwwa9YsrF+/Hmq1GjKZDA8ua6ZfJ+zOnTvIzc1F/fr1sW/fPrRp00aKKRARCamwsBARERFo3rw51q9fDy8vL7Rr1w6hoaH44osvcOnSJamHSGQRxpfqMb7YHgMMOT3GF9MwvpBU8vPz8f333yMwMBDz5s3D/v37ERAQgMTExBojzL1795CcnIwtW7Zg7969eOKJJySaARGReHQ6HSZNmoTWrVtjzZo1CA4OBgCEhYVh4sSJOHHiBPLy8gBU7FVIZG8YX8zD+GIddn8WJGdkt2dBEvQQJGMkjy/zCywZvtU0nvq1kPHlwocDTJ8M2Z09e/YgMjISDRs2BABcu3YNffv2xe3bt/Hhhx8aDke6X1lZGbZt24bmzZsjIiJCimETEQnt2rVr8PT0NPxs1S9ufvbsWfTq1QuhoaHYvn07vL2da0OJamAnn+tFiC+Fah0idRssmoetSR1f7O1zvSnb59wDhqgakscXgYkYX8h59OzZEw0bNoRWq4VOp0NISAgyMzPh7++PxMREfPPNN9BoNACAy5cv4+bNm3B3d8fgwYMZX4iIjAgJCTHEF+DPwzdbtGiBPn364OjRozh+/DgA7gVD9kOU+BL/TZFF87A1qeOLo2OAIXoA44t5GF/IllxdXQ2HG90fYWbPno1169bh9OnTeOWVVzB8+HCUlZVJPVwiIrujDy2JiYlwcXHB6tWrAfwZZ4hEJlJ8OXlTa9FcbEmE+FJ256pFcxAdf4IS3UeU+PLlL6VmjV8qjC91T61W486dO1IPQ3j3R5hdu3YZIszw4cNx8OBBLFq0CO7uxt/HRERUPX1oCQ4ORq9evZCWloYDBw5IPCqihxMtvmSOrWfRfGxFlPhyY0OSRfMQHQMM0f+IFF8mbi4xaw5SECG+6HSOtTu0UqlEkyZNkJaWVmVBWapKf+rpoKAgfP7557hx4wauX7+Offv2oWPHjhKPjojIvikUCrzxxhsoKirC/v37pR4OUY1EjC81nfBDFCLFFxe5fQQrczHAEEG8+DKpg338xV6U+HJnx98tmodIlEolOnTogFatWmHw4MGGuEAPd+bMGSxduhT16tVDdnY2IiMjpR4SEZFDiI2NRcuWLZGamgq1Ws0/DpCwGF9MJ1p8CXpxoUXzEZ2b1AMgkpqI8WXlAE80S9xq1nxsRaT4ovp3hkVzEUVhYSHatGmDsLAwfPXVV2jUyPi/KVWm0WiQmpqKTZs24fDhwzzVNBFRHZLL5Zg6dSp69OhR5UxzRCJhfDGNiPGlphN+OAIGGHJ6IsYXF8H3ehAtvvg9M82i+Yjg3r17iIyMREhICNauXYuQkBAAQF5eHs6ePYvffvsNjz32GIYOHcq9Yqrh5uaGKVOmYNKkSWjZ0vhrjIiITKPT6SCTyfD6669LPZSH0o+VnBfji2kYX2yPAYacHuOLaUSMLz5RcRbNSQTbt2/HpUuX0L59exQVVZyucPPmzZg6dSru3r2Le/fuAQCeeuop7NixA/XqOfbxseYICwuTeghERA5H1KBRWlqK69ev4/r164iIiICnpyfc3d1RXl7OMzU5McYX0zC+2B4DDDk9xhfTML5Yx7PPPosVK1bgzTffhL+/Pzp27IjJkycjISEBAwYMQKtWrbBy5UosWbIE/fv3x549e6QeMhERkSQKCwsxePBg/Pbbb7h48SIaN26M2NhYfPzxx/D39zdrTxjv8Kck27is6Y9bFz4cYNI8qHqML9VjfLE9BhhyeowvpmF8sQ4PDw+89tprKC8vx4wZM7B69WosWLAACQkJ8PLyAgD89a9/RUlJCRYvXozdu3ejV69eEo+aiIjItoqLi9G9e3c8+uijWLhwIUJDQ7Fs2TJs2bIFu3btwtatWxEREWFyhBExvlDdYHwxjvHF9rh/HpERjC/VY3yxHjc3N0yaNAmffvop4uPj0b9/f0N8KSsrQ4MGDfDqq68CAK5fvy7lUImIiCSxdetWFBQU4OOPP8aLL76Irl27Ys2aNVi0aBHc3d0RFxeHkydPQiaToby8vNaPy/jimESIL6Va+ztrGOOL9XAPGKJqML4Yx/hiXe7u7hg3bhx69+6NFi1aAKhYVNDdveIX37Fjx9CwYUOEh4dLOUynUtMZyaRcE4m7pRM5hvLycshkMmHXWhHN+fPnDWcNBCrWgvHw8MCYMWPwyCOP4O2330b//v1x5MgRBAYGWrwwL+OL/RIlvozYWAwMtmgqNsX4Yl0MMEQPYHwxD+NL3ZHL5Yb4otFo4OZW8aM6Pz8fW7ZsQVhYGJo1a2bZk8xXGP5TpFOxT/ix2LR5SEiEBamJyL6pVCpMmDABCxcuRPPmzaUejl0IDw+HUqnE9u3b0a9fP3h4eBgW3h0wYACUSiXefPNNTJ8+HWvWrLHotNmML/ZLpPiy7awGwRbNxnZEiC9a1V2L5iA6HoJEdB9R4svWM2VmjV8qjC/WodPpDPHl6NGjmDlzJv71r39h1apV8Pf3r5PnECm+TNxcYtYcpMD4QkSWUiqV6N69OzZu3IglS5ZIPRyh6XR/HsLRrFkz1K9fH6tXr8alS5cAAC4uLoYIM2LECAwaNAh79uzBnTt3zH5OEeJLubrI7PE7M9Hiy3cveFk0H1sRJb7cSJtt0TxExwBD9D8ixZdh6fazFwDji/Xod5l+//338eabb2L//v3Izs5GZGRknTy+aPFlUgfjzy8SEeKLTlf7dQ2ISDxKpRJRUVFQKBSIjIxEVlYWrl27JvWwhKPRaFBaWlppPZe2bdti7ty5SE9Px5dffon8/HwAFRGmrKwMbm5uSEpKwo0bN3D06FGznleU+HLz23fNGr8zEzG+1PT5ShQixZdy9T2L5iI6BhgiiBdf+rewj6MDRYkvf+SkmT0HezB06FDExMRgx44dhmPeLSVifFk5wNOsudiSKPHlzo6/WzQPIpKOUqlEmzZtEBoaioyMDMybNw9nz57Fpk2bpB6aUFQqFUaNGoXU1FSo1Wq4uLhAo9EAABISEjB58mR88MEHWLlyJa5cuQKgYh218vJyXLhwAY8++igee+wxk59XpPhSeuuiyeN3dowvphMtvgSNTLFoPqKzj608IisSMb7883kvhAt+FJJI8aUg+2sA68ydivAiIiLw7rvvwtW17k5vKGJ8EX1NJJHii+rfGRbNhYikUVhYiIiICLRq1Qpr166Fl5cX2rVrh9DQUHzxxRcYPHgwmjRpIvUwJVdcXIz4+Hjk5OTgl19+Qf369TFq1CjI5XLodDq4uLggOTkZ5eXlmD9/Ps6dO4dx48ahV69euHLlCjZu3AiFQoHgYNNW3hAtvgSNWGDS+AmMLyYSMb44+ppI3AOGnJ4IG5cPxhcPV7E3REWLL4qnx5g9F3tRl/EFAOOLiUSLL37PTLNoPkRkezqdDpMmTULr1q2xZs0aQxwICwvDxIkTceLECeTl5QGASadPdjRarRYpKSm4efMmkpOT4eHhgVmzZmH9+vVQq9WGw3P9/PywdOlSpKSkYNOmTXj22WcRGhqKZ555Bt999x02bNiAoKCgWj+vCBuXpvz+oOoxvpiG8cX2GGBMsGHDBnTo0AFeXl7w9/fHyJEjcfHiw3cNvHv3LpYuXYq4uDg0btwYXl5eaNmyJV577TVcvnzZBiOnmki9ccn48r/bWhBffKNfNHs+zorxpfZEjC/OuCYSkb2TyWT45JNPkJaWhpCQEAB/hpbnn38ewcHBWLBgAYqKiuDi4rwf0fPz8/H9998jMDAQ8+bNw/79+xEQEIDExERDhAEqgpa7uztmzZqFrKwsrFixAs8++yymTJmCAwcOoG3btiY9r9Qbl4wvdYPxxTSML7bnvD/dTbRixQqMGjUKXl5eWLJkCRISEpCZmYno6OiHLpp28OBBzJw5EzqdDlOmTMHy5cvRv39/fP3114iMjMR//vMfG82CqsP4YhoRNi4ZXyzH+FJ7jC9EVFdCQkLQsGFDw9f60NKiRQv06dMHR48exfHjxwE4714wgYGBWLFiBTZv3gwA8PX1RWZmJvz9/StFmPsX5u3atSvGjx+P5cuXY/LkyXj88cdNfl7GF8fG+FI9xhfb4xowtZCfn4+kpCS0b98eP//8s+G0sPHx8ejcuTPeeecdrFq1yuj9W7VqhV9//RXNmzev9P0BAwagb9++ePfdd/Htt99adQ5kHOOLaaTeuGR8sS7Gl6oYX4jImvSnT05MTMTGjRuxevVqdO3a1an3gunZsyeAisORXFxcEBISgszMTPTt2xeJiYnQ6XR46aWX4ObmhkuXLsHLywsBAQEWPSfji+NifDGO8cX2nPcnuwl+/PFHqFQqTJ8+3RBfAKBjx47o0aMH0tPTUVpaavT+zZo1qxJfAKBPnz5o2LAhTpw4YZVxk+UYX6pifHFcjC/VY3whImvSh5bg4GD06tULaWlpOHDggMSjEoOrqytkMhl0Op0hwvj7+2P27NlYt24dTp8+jYkTJ2L48OEoK7Ps7AWML45JhPhSrtNZNAcpML5YDwNMLRw6dAgAEB0dXeW66OhoFBYWGhZNM0VBQQEKCwsRGBho8Rip7jG+VI/xxTExvhjH+EJEtqBQKPDGG2+gqKgI+/fvl3o4Qrk/wuzatcsQYYYPH46DBw/ik08+gbu7dfY+YHyxX6LElylbSyyah60xvlgXA0wtXL16FQDw2GOPVblO/70rV66Y/Ljvv/8+ysrK8PLLL9d4O7VaDaVSWelC1sX4YjrGF/slSnzZekbwc68/gPHF+kRcA0PEMZHjiI2NRcuWLZGamgq1Wg2dHf7l3Fr0Zz8KCgrC559/jhs3buD69evYt28fOnbsaJXnZHyxXyLFl8+O2s/nGxHiS7m6yKI5iI4BphaKiipeBHJ51Q0NT0/PSreprfT0dCxatAh9+/bF+PHja7xtSkoKFAqF4dK4cWOTnotMI0J8OXRVa/b4pcD4Yr9Eii/D0ovNmoMUGF/qXmlpKf7zn/9g165d+PXXXwFA8jUwRBwTOTa5XI6pU6di8+bNkMvlhuhAfzpz5gyWLl2KevXqITs7G5GRkVZ5HhHii05rPxvuIhEtvqwa5GnRfGxFlPhy89t3LZqH6Pgpoha8vStefPrT3t2vuLi40m1qY9u2bRg7dizatWuHb7/99qEf5pKSklBQUGC48NTV1iNKfOm77p7Zc7A1xhf7JVp86d/CPtaFZ3ype4WFhYiLi0NcXBz69OmD9u3bIy4uDnl5eRav6+BIY7pfWVkZzp8/j8zMTMNZc6Qm4pjsiX5vl9dffx1PPPGExKMRk0ajQWpqKjZt2oTs7Gyr/TuJEl9u/fiRRfNwRiLGl4d9vhKBSPGl9NZFi+YiOgaYWmjUqOKFUt1hRjUdnlSdjIwMDBs2DK1atcKOHTugUCgeeh+5XI4GDRpUulDdEym+PBlo/BeASESJL6rjO8wavzMTMb7883kvs+ZiS6LElz9y0syeg2iKiorQrVs3uLq64sMPP8SBAwcwZMgQ7Ny5E4MHD8Z3332HwsJCpx/T/VQqFZ577jn069cP/fr1Q8+ePR+6N60zjsnecG+Xh3Nzc8OUKVNw8uRJtG3b1irPIVJ8KT5/xKK5OCPGF9OJFl+CRiywaD6iY4CphU6dKj405+TkVLkuJycHPj4+aNWq1UMfZ/v27Rg6dCjCw8Oxc+dO+Pn51flYyTyixZeM0bXfo0oqIsWX/J+WmzUHZyZifBF9TSSR4ktB9tdmz0M0aWlpKCoqwpIlSzBy5Eh06dIFy5cvx5tvvomzZ88iOTkZGRkZ0Gptd2imiGPSU6lU6NKlC0pLSzF37lwcOHAAcXFxSE9PxyeffGLz8Yg6JnJcYWFhaNnSOmumiBZfAobOsWg+zojxxTQixhdHXxOJAaYWBg8eDG9vbyxbtgwajcbw/SNHjmDv3r144YUX4OFR8Qa7fv068vLyqqwJs2PHDgwZMgQtWrQwrN5OYhBh4/LB+FJfLvaGqGjxxadtvFnzcGaML6YRLb4onh5j9lxE85///AdarRZRUVFwdXVFWVkZGjZsiOTkZAQHByMvLw+zZs0y7HFqi0VJRRwTUHGIz+TJkxEcHIzU1FSMHTsWXbp0wcqVKxEcHCzJmXNEHBOROUTYuDTl9wdVj/HFNIwvtmcfB9xLzN/fHwsXLkRCQgJiYmIwduxY3L59G0uWLEFQUBDee+89w22TkpKwZs0a7N69GzExMQAqQs3gwYOh0+kwYcIEZGRkVHmOMWMc58O0vZF645Lx5U/mxpeGcW+YNRdnJmp8aZa41bSJ2ICI8cWR1kQKCgrC77//jmPHjqF9+/Zwd3dHSUkJPD090bJlSzz//PPYtGkT3nrrLXz77bc2OUxDxDEBwLFjx3Dq1ClMmDABTZo0gYuLC0pLS+Hv74+4uDhkZWXh7t27eOQR4x+MnWFMROaQeuOS8aVuML6YhvHF9hhgamnGjBnw9/fHokWLkJCQAG9vb/Tt2xcpKSmGNWKMOXnyJEpKKs7//uabb1Z7GwYY6TC+mEaEjcsH44tMxp35TCVifBEV44t1DRkyBHPmzEFKSgreffddPPnkk/D09MTJkyfx//7f/8O0adOg1WqRmZkJlUoFHx8fpxwTAAQHByM0NBRjxowxLOCv3wM3KCgIBQUFNj9tsYhjovvMr36tQWtuXD7098f8ApOmYCuML46N8aV6jC+2xwBjgtGjR2P06NE13uarr77CV199Vel748aNw7hx46w3MLII44tppN64ZHyxPsaXyhhfrKtFixbIyMhAnz598Ouvv2Lw4MGQyWRYunQpBg0ahKFDh6JRo0ZYtWoVrl69ivDwcKvvcSLimACgSZMmWLt2Lby9vVFeXg4XFxfD//r6+sLV1bXSujTFxcXw8rLu4tYijolqJml8ERjji+NifDGO8cX2uOVCVAPGl6oYXxwb40tVjC/W17t3b+Tk5MDLywuffvop1qxZg9dffx1ffPEFACA7OxshISFo0qSJzQ73EXFMAODtXfFhWb+3iZ67u3ulPU1UKhXGjRuH+Hjrr5El4pioeowvxjG+OCbGF/MwvlgP94AhMoLxpXqML46L8aV6jC+20bVrV+zatQt//PEH1Go1Hn/8cQDAjRs3kJubi3bt2tn8UBYRx/QgffQoLS1FSUkJdDodiouL8fbbb2Pbtm3IysrimAgA44u5GF/slyjx5f29aqCz2dOwOcYX62KAIaoG44vpGF/smwjx5dBVLeBn9hRsjvGl7tWrVw/16tUzfH3o0CGsWrUKWVlZ2Ldvn2FPC2cfU3VcXFwgk8mgVCoxf/58rFu3Dvv27UO7du04JhImvnz5SykmmDUDaTC+2C+R4su83Wo0tZMAI0J80WnLLJqD6LgVQ/QAEeLLmXyt0etExPhi30SJL33X3TN7DrbG+GJ9p06dwscff4xdu3Zhz549iIiIkHpIQo5JvweOh4cH5HI5pk6ditWrVyM7O1uy0CHimJyZSPFl4uYSs+YgBRHii05XbtEcnJVo8WVBL/vYK0yU+HLrx48smofouCVDdB9R4kuvNUUWzcOWGF/sm0jx5clA4x+QRML4Yhvh4eFISEjAzp07ERUVJfVwAIg5Jv36M25uboZDo3Jzc9G+fXuOiYSLL5M6GH9+kYgSX+7s+LtF83BGIsYXezgsT6T4Unz+iEVzER23Zoj+R6T4orCTQ5NEiS9F5w6bNX5nJ1p8yRgtxqEcNRElvqiO7zBr/PbE3d0d3bt3R9OmTaUeioGIY9KLiYlB27ZtkZubizZt2kg9HABijsnZiLBx+eDvD9GJFF9U/86waC7OiPHFdKLFl4Chcyyaj+i4BgwRxIsvu172RleLZmR9IsWXW99/AGC+GbOwgfkKqUdQLRHjS325DBB473SR4kv+T8sBLDVnGuSgmjdvjpycHHh6irOBK+KYnI3UG5em/P4QgWjxxe+ZaRbNxxkxvphGxPji6GsicQ8YcnoixpdHfcR+a4oWX7we72jWPJyZkPFFYKLFF5+2PI0vVSVi6BBxTM6E8aX2RNi4NPX3B1XF+GIaxhfbE3srj8gGpN64ZHz5k7nxJWDwLLPm4swYX2pPxPjSMO4Ns+ZCRM6F8aX2pN64ZHypG4wvpmF8sT2xt/SIbIDxxTQixheZq30s6icSxpfaEzG+cEFqIrIE40tVjC+OjfGleowvtsdPcOT0GF9MI/XGJeOL9TG+VMb4QkSOhPGleowvjovxxTjGF9vjpzhyeowvpmF8cWyML1UxvhCRo2B8MY7xxTExvpiH8cV6+EmOyAjGl+oxvjguxpfqMb4QkSNgfDEP44v9EiW+fPlLqVnjlwrji3Xx0xxRNRhfzMP4Yr9EiC9n8rUWzcHWGF+IyF6IEl+2nikza/xSYXyxXyLFl4mbS8yagxREiC86XblFcxAdP9ERPUCE+PK7yv5+8DC+2C9R4kuvNUUWzcOWGF+IyF6IFF+GpRebNQcpML7YL9Hiy6QO9vHZVZT4cmfH3y2ah+j4qY7oPqLEl952tCEKML7YM5Hii8JODk1ifCEieyFafOnfws2sediaKPHlj5w0s+fgrESMLysHeJo1F1sSKb6o/p1h0VxEZx8/BYlsQKT4UqDWwV5SgwjxRX3tVwADzJ2C0xItvux62RtdLZqR9YkSX4rOHQZf80QCma+QegTVEi2+/PN5L7PmYUsixZeC7K8BrDN3Kk5JxPgi+ppIosUXv2emWTQf0THAEEG8+LL7ZW/Yww6posSXG/+cB6ydafY8nJGI8eVRHxdA4MOkRYovt77/AMB8M2ZBRM5E6o3L6n5/NEvcatZcbEG0+KJ4eozZc3FWjC+mETG+OPphedy3mZyeiPEl3M/VojnZgkjxxSOgqdnzcFZCxheBiRZfvB7vaNY8iMi5iBZfRCbKxqUpvz+oKsYX0zC+2J7Yn3iJbEDqjUvGlz+ZG18ChyebPeFdpzgAACAASURBVBdnxfhSeyLGl4DBs8yaCxE5F8aX2hNh45LxxXKML6ZhfLE9sT/1EtkA44tpRIwvLnJvs+fjrBhfak/E+MIFqYnIUowvlUm9ccn4Yl2ML9VjfLE98T/5ElkZ44tppN64ZHypG4wvtcf4QkSOhvGlKsYXx8X4Yhzji+3Zx6dfIitifDEN44tjY3ypivGFiBwJ40v1GF8cE+OLeRhfrMd+PgET2RjjS/UYXxwX40v1GF+IyFEwvpiO8cV+iRJftp4pM2v8UmF8sS77+hRMZCOML+ZhfLFfIsSX31XlFs1BCowvRGQvRIgvh65qzR6/FBhf7JdI8WVYerFZc5AC44v1McAQPUCE+FKo1lk0BykwvtgvUeJL7zVFFs3D1hhfiMheiBJf+q67Z/YcbI3xxX6JFl/6t3Azax62Jkp8+SMnzew52AMGGBNs2LABHTp0gJeXF/z9/TFy5EhcvHix1vc/evQo4uPjoVAoUL9+fcTExGDv3r1WHDGZSpT4Ev+NfW2IMr7YL5HiS4EdhUfGFyKyFyLFlycD7WPPX1Hii+r4DrPG78xEjC//fN7LrLnYkkjxpSD7a7PnYQ/sI8cJYMWKFZg2bRq6deuGJUuW4Pbt2/jb3/6GvXv34vDhwwgJCanx/ocPH0bPnj0RGBiIefPmQS6X4x//+AdiY2Px008/oU+fPjaaCRkjUnw5eVOLRyyaje2IEF/K7ly1aA7OSrT4svtlb9jDDqkixBf1tV8BDDB3Cs5pvsImG5cmvz8+KbRoWkQ1ES2+ZIz2RqTgrV2k+JL/03IAS82ZhtMSMb54uMoAgZeBES2+KJ4eY/Zc7AEDTC3k5+cjKSkJ7du3x88//ww3t4p/tvj4eHTu3BnvvPMOVq1aVeNjTJ8+HS4uLti7dy+aNGkCAHjppZcQERGByZMn49dff4XMgVbOtjeixZfMsfXwgkUzsg1R4suNDUnAP16zaC7ORsT4Eu7nCpRYNC2rEyW+3PjnPGDtTLPnYVXzFVKPoFpCxhcfFzRL3GrRvKzJFhuXpr4/is4cMGsuzkq0+FJfLhP657xo8cWnbbxZ83BmQsYXgYkYXxz9sDweglQLP/74I1QqFaZPn26ILwDQsWNH9OjRA+np6SgtLTV6//PnzyM3NxfDhw83xBcAUCgUmDhxIs6ePYuDBw9adQ5knIjxpXMj8XfRFSm+uMjrWTQXZyRkfBGcSPHFI6Cp2fNwViLGF5GJGF8CBs8yay7OTLj4IjBRNi4ffH+QaRhfTMP4Ynti//YXxKFDhwAA0dHRVa6Ljo5GYWEh8vLyzL7//bch25N645Lx5U/mxpegFxdaNB9nxPhiGtHiS+DwZLPn4qwYX0wjYnzhmkimY3ypPRE2Lk15f1D1GF9Mw/hiezwEqRauXq1YX+Kxxx6rcp3+e1euXEFUVJRF9zdGrVZDrVYbvi4oKAAAKJXK2gxfHIIusNnK3wXpz3tBB0BpZIz/vaPFgPVFaOAhw48vesHbXWb0tjdU5Xh2fRGUpTpsHVXxQdvYbQvVOgxLL8LpW+X44UVvtPL/87blajEX4lWd3Im7WZ+hXmQf+PZ8GbrSEhj7f7bot2PI3/J/8GzWDn7x06DTlEGnqf4gWPX1s7j53fvw8G8M/0EVf+U09m9Qdvcabm5MhouHNwKGzYPMXS7u+0HQ1/3nAz1RogFKNNWP78g1LYakFaF1gG3fHyK+7gsOboTyQDoaPPUCGnQYVOMYbfn+4GveNCl95FCVAjDy/8j2/5Zh9HcliAtzten7Q8TXPACo/v0THukzCd4tu9c4Rlu/P/i6rzvr/l8ppv6kxoS2bjZ9f4j6mi8+dxh+A/8Cz8cijI5RpyvH3V2rcO9Els3eH3zN152P96vxQXYp5jztgeldPIz+3Abq/v0h6us+YOgcuPs1Nv6a15bh9tYlKLnwi03fH8K+7o3Qj1enq8X7QkcP1bt3bx0AnVarrXLdF198oQOg+/bbb43e/7333tMB0O3cubPKdefOndMB0E2ZMsXo/d99910dKt7xvPDCCy+88MILL7zwwgsvvPDCi2CXy5cvP7QtcA+YWvD2rjgMQq1Ww8ur8mnEiouLK93mYfd/UG3un5SUhJkz/1xssby8HHfu3IGfnx8X7nVQSqUSjRs3xuXLl9GgQQOph0NkE3zdk7Pha56cDV/z5Iz4und8Op0OhYWFDz0zMsBDkGqlUaNGACoOE2rRokWl62o6vKi6+z+oNveXy+WQyysfo+jr61uLkZO9a9CgAX9Qk9Ph656cDV/z5Gz4midnxNe9Y1MoancWSK7sVAudOlUsNJSTk1PlupycHPj4+KBVq1Zm3//+2xARERERERGR42GAqYXBgwfD29sby5Ytg0ajMXz/yJEj2Lt3L1544QV4eFSsuH39+nXk5eWhqOjPRYTCwsLQuXNnfPvtt7h8+bLh+0qlEl988QXCwsLQtWtX202IiIiIiIiIiGzKdf78+fOlHoTovL294ePjg9WrV2PXrl0oKyvD9u3bMXXqVDRo0AAbNmww7E42bdo0vPrqq+jbty+aNWtmeIyoqCisXr0a6enpKC8vx9GjRzF58mT89ttvWL9+PZo3by7R7EhUrq6uiImJgZsbjxQk58HXPTkbvubJ2fA1T86Ir3vSk+l0tTlXEgHAN998g0WLFuH06dPw9vZG3759kZKSgtDQUMNtxo0bhzVr1mD37t2IiYmpdP/Dhw9jzpw5yM3NhVarRceOHZGcnFzldkRERERERETkWBhgiIiIiIiIiIisjGvAEBERERERERFZGQMMEREREREREZGVMcAQEREREREREVkZAwyRFfz888+QyWQ1XvRkMlmNCzHHxMRUuv39zp07h2nTpqF169bw8fGBp6cnmjdvjgkTJmD//v11PS2iSq/t1NTUam8jk8kQHx9v+Fr/GjZ2qe5kfAUFBfj/7N15dE3n/sfxz4nI5EqIMYZmMKuqsZWLRDqgamhVi6BUlbbqVlHTpWYpvdpeipamZpdGaig66K+iE1VatIooYoiZDIZIItm/P7KcSJOTyTnJSfJ+rXXW6nmeZz/7u7NOnO5P9rP3zJkz9fDDD6t8+fJycnJStWrV1K1bN61Zs0apqamZttm3b59efPFF1apVS66urnJzc1PDhg312muv6ffff7fazwAl08WLFzV69Gg1atRIZcuWlYeHh+rUqaNevXrps88+M4/j847izJ6/AwBbsrfvABRdPAcLsKGePXuqc+fONpl7xYoVeumll+To6KjevXuradOmcnJy0vHjx7V+/XotWbJEP/74o/75z3/aZP/AlClT1K9fP5UpUybHsaVLl9Ynn3ySZV/jxo0zvP/tt9/UpUsXnTt3Tp07d1avXr1Urlw5nTt3Ttu2bVPv3r11/PhxjR8/3rzN22+/rfHjx6tChQoKDg5Ww4YNZTKZdPjwYYWHh2vhwoU6efKkatSocW8HjRLp9OnTatmypa5du6Y+ffrolVdekST99ddf2rJli65fv67u3bubx/N5R0lgT98BgC3Z23cAijgDgNVt377dkGSEhITkOFaSERgYaLE/MDDQ+Puv6vbt241SpUoZDRs2NE6fPp1pm5SUFOOjjz4ydu3alefagezc+Wy3aNHCkGRMmzYt0xhJRocOHczvAwMDDWdn51zNf+HCBcPLy8soW7assWPHjizHfPfdd0ZoaKj5/YoVKwxJRkBAgBETE5NpfFJSkjFt2jTj1KlTuaoB+Lthw4YZkoxNmzZl2X/3v8N83lGc2eN3AGBr9vQdgKKPK2CAIujNN99Uamqq1q5dm+VfOB0cHDR48OBCqAwlxTPPPCMHBwe98847evnll1WxYkWrzPvOO+/o3Llzmj9/vgICArIc07ZtW7Vt21aSlJSUpDFjxqhMmTIKCwtTuXLlMo0vXbq0JkyYYJX6UDJFRkZKkoKCgrLsz++VJnzeUVTZy3cAUBDs5TsAxQP3gAFs6ObNm7p8+XKmV3x8fL7nPHnypPbs2aPWrVurUaNGVqwWyJtZs2YpPj5e06dPz9X4rH4XLl++rNu3b5vHrFu3Tk5OThowYECu5vzpp5909uxZPf3006pcuXJ+DgPIkZ+fnyRp8eLFMgwjV9vweUdxZw/fAUBBsJfvABQPBDCADU2bNk2VKlXK9Lp7nWheHThwQJLUtGlTa5UJ5Eu7du3UsWNHLVy4UFFRUdmOTUxMzPJ3oVKlStq1a5ck6dq1a4qKilK9evXk5uaWqxru3GyU3wfY0qhRo+Tu7q4RI0bI29tbffr00fvvv6+9e/dmOZ7PO0oCe/gOAAqCvXwHoHhgCRJgQy+++KJ69eqVqb1ChQr5nvPO1TPu7u75ngOwllmzZqlp06aaMGGCVq5caXFc6dKltXXr1iz7HnjgAUn5+2zz+4CC4Ofnp/379+udd97Rxo0btXr1aq1evVpS2ud3yZIlat68uXk8n3eUFIX9HQAUBHv5DkDxQAAD2FDt2rX12GOPWXXOO/9Q38syJsBaGjdurODgYK1atUqjRo1SkyZNshzn4OCQ4+9Cfj7b/D6goPj4+Gj+/PmaP3++zp07p507d2rZsmXatGmTOnfurIMHD8rT01MSn3eUHIX9HQAUFHv4DkDxwBIkoJC5uLgoISHBYv/Nmzfl6upqfn8nOf/tt99sXhuQG9OnT5eTk5PGjh17T/OULVtW3t7eOnLkSLa/E3fj9wGFwcvLS927d9fGjRvVu3dvnT9/3uJfOy3h847iojC/A4DCUFjfASgeCGCAQubr66vIyEilpKRk6rt9+7YiIyPl6+trbvPx8VHz5s31448/6s8//yzIUoEseXt765VXXtFXX32lb7/99p7m6tGjh5KSkrRs2bJcjf/nP/+patWqacOGDbp06dI97RvID39/f0lSdHR0nrfl847ioDC/A4DCVpDfASgeCGCAQtatWzfFxsYqNDQ0U19oaKji4uLUrVu3DO2zZ8+WyWRSz549dfbs2Uzbpaam6qOPPtLPP/9ss7qBu02YMEHu7u73/BfQN998U1WqVNGYMWP0448/Zjnmu+++0yeffCJJcnJy0syZM3X9+nX17Nkzy0t5k5KSNG3aNJ0+ffqeakPJtX379iz/QpmamqrPP/9cktSwYcM8z8vnHcVFYX0HAAXBXr4DUDxwDxjAhvbt22fxpnRdu3Y1/8/Khg0bNGTIEH377bfmJH3nzp1au3atGjRooDFjxmTY9pFHHlFoaKiGDBmievXqqXfv3mratKmcnJx07NgxrV+/XocPH9ZPP/1k82MEpLQbS48ePVoTJkzIsj81NdXi74KPj4/atGkjSapSpYo2b96srl27KiAgQF27dlVgYKA8PDx0/vx5ff3114qIiFBISIh5+/79++vMmTOaOHGiateureDgYPP/CB0+fFjh4eE6c+aMBg4caOWjRkkxZ84c/fjjj+rcubOaN29u/jyGh4dr7969CgoK0pNPPmkez+cdJU1hfgcAtmZP3wEoBgwAVrd9+3ZDUravQ4cOmcfHxsYaY8eONerXr2+4uLgYLi4uRv369Y2xY8casbGxFvcTGRlpDB061KhXr57h5uZmODs7G7Vq1TIGDhxo7Nq1qyAOFSXMnc92SEhIpr4bN24YXl5ehiSjQ4cO5vbAwMBsfxd69uyZaa6rV68a06ZNM1q2bGm4u7sbjo6OhpeXl9GtWzcjLCzMSElJybTN3r17jQEDBhi+vr6Gs7Oz4eLiYjRo0MAYNmyYcfDgQev+IFCi7Ny50xgxYoTRokULo3Llyoajo6Ph4eFhtGrVypgzZ45x69Yt81g+7yjO7Pk7ALAVe/wOQNFlMgzDsF28AwAAAAAAAO4BAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBjBDAAAAAAAAA2RgADAAAAAABgYwQwAAAAAAAANkYAAwAAAAAAYGMEMAAAAAAAADZGAAMAAAAAAGBj+Q5gIiIiZDKZzK/JkydbsSwAAAAAAIDigytgAAAAAAAAbIwABgAAAAAAwMYIYAAAAAAAAGyMAAYAAAAAAMDGCGAAAAAAAABsjAAGAAAAAADAxghgAAAAAAAAbMzRVhOnpqZq165dOn78uM6ePSsXFxdVr15dAQEBqlSpkq12CwAAAAAAYHesHsDcunVL77zzjhYvXqzTp09n6i9VqpTat2+v//znP2rYsKG1dw8AAAAAAGB3rLoE6fz58/L399dbb72VZfgiSSkpKfriiy/UpEkTffjhh9bcPQAAAAAAgF2y2hUwiYmJevLJJ7Vv3z5JkoODg5o3by4fHx8lJSXp0KFDioyMNI9PTk7WK6+8IpPJpCFDhlirDAAAAAAAALtjMgzDyM+GERERCgoKMr8vX768YmJiJEm9e/fWO++8o+rVq2fY5pdfftErr7yivXv3mtucnJz066+/6v77789PGQAAAAAAAHbPakuQ7oQvI0eO1OrVqzOFL5LUsmVLfffdd2rbtq25LSkpSS+//LK1ygAAAAAAALA7Vr0HTPPmzTV79uxsx7i5uWn16tX6xz/+YW774Ycf9Ouvv1qzFAAAAAAAALth1QBm8uTJcnDIecoaNWpo8ODBGdqWLl1qzVIAAAAAAADshtUCmPLly6tjx465Hh8cHJzh/Q8//GCtUgAAAAAAAOyK1QKY5s2by9Ex9w9VevDBB+Xi4mJ+f+DAASUlJVmrHAAAAAAAALthtQCmbt26eRrv6OgoHx8f8/uUlBRduXLFWuUAAAAAAADYDasFMO7u7nnexsPDI8P7q1evWqscAAAAAAAAu2G1AMZkMtnFHAAAAAAAAPbGagFMXFzcPW9Tvnx5a5UDAAAAAABgN6wWwERGRuZp/O3btxUVFWV+X6pUKXl6elqrHAAAAAAAALthtQBm7969un37dq7H79+/X7du3TK/b9y4sZydna1VDgAAAAAAgN2wWgATExOjL7/8MtfjV69eneF9mzZtrFVKjiIjI/XWW2+pVatWqlSpksqWLasmTZpoxowZunHjRqbxFy5c0MCBA1WlShW5uLiocePGWrx4cZ72mZSUpKlTp6pWrVpydnaWt7e3xowZo5s3b1rrsAAAAAAAgJ0yGYZh5GfDiIgIBQUFZWhr3ry5du/eLQeH7HOdM2fOqEGDBrp+/bq5bc+ePWrevHl+SsmzsWPH6oMPPlCXLl3k7+8vJycnbd++XZ9++qkaN26sXbt2ydXVVZIUGxurli1bKjo6WsOHD5evr682btyoLVu2aPLkyZo0aVKu9tmjRw+Fh4erX79+CggI0P79+7Vw4UIFBgZq27ZtOf7MAAAAAABA0WXVAEaSRo0apXfeecfidgkJCerQoYO+//57c1vr1q31ww8/5KeMfNmzZ49q166tcuXKZWifMGGCZsyYoQ8++EBDhw6VJI0bN05vv/22wsPD1b17d/PYrl276ssvv9SRI0fk6+ub7f6++uordezYUcOGDdPcuXPN7XPmzNGoUaO0YsUK9e3b14pHCAAAAAAA7InVLru48wSj//znP+rTp4+io6Mzjfnll1/Utm3bDOGLk5OTPvzwQ2uVkSstWrTIFL5I0nPPPSdJ+v33381tq1atkq+vb4bwRZJGjBih5ORkrV27Nsf9rVq1SpI0cuTIDO2vvvqqXF1dtXLlyjwfAwAAAAAAKDocrTXRkCFD9OWXX2rfvn1avXq11qxZo5YtW8rb21tJSUk6dOiQjhw5kmm7uXPnqlGjRtYq457cCY0qV64sSTp//rxOnz6t4ODgTGP9/f1lMpm0e/fuHOfdvXu3qlWrJm9v7wztrq6uatKkSa7mAAAAAAAARZfVAhhnZ2dt3bpVHTp00O+//67U1FT9/PPP+vnnn7McX7p0ac2dO1dDhgyxVgn3JCUlRVOnTpWjo6P69OkjKT2QqVGjRqbxzs7Oqlixos6cOZPj3NHR0WrYsGGWfTVq1NDOnTt18+ZNubm5ZTkmMTFRiYmJ5vepqam6evWqKlSoIJPJlOP+AQAAAACA9RmGoWvXrqlatWo53tvVagGMJHl5eWnXrl2aNWuWQkNDs1yGVKpUKT3++OOaM2eOxVCiMPzrX//Srl27NH36dNWrV0+SzE8osvR4bBcXl1w9xejmzZvZznFnjKUAJiQkRFOmTMlxPwAAAAAAoOCdPn06y4s37pbvAKZdu3bK6v69bm5umjJliiZNmqSdO3fq+PHjOnv2rFxcXFS9enUFBASYl/jYiwkTJmjBggUaNGiQxo8fb26/E4jcffXJ3RISElS1atUc53dzc8t2jrv3lZVx48ZpxIgR5vdxcXG67777dPr0abm7u+e4fwAAAAAAYH3x8fGqWbOmypYtm+NYq14BczcHBwe1bt1arVu3ttUurGLy5MmaMWOGnn/+eX300UcZlvRUr15dkrJcZnTr1i1duXJFbdu2zXEf1atXt7hUKTo6WuXLl882gHF2ds7yChp3d3cCGAAAAAAACllubg9itacgFUVTpkzRlClT1LdvXy1ZsiTTeq2qVaua79Hyd7t27ZJhGGrZsmWO+2nZsqXOnj2rkydPZmhPSEjQvn37cjUHAAAAAAAoukpsADN16lRNnjxZffr00dKlSy3eLCc4OFgnTpzQZ599lqH93XfflaOjo3r27GluS05O1uHDh3Xq1KlMc0jSnDlzMrQvXLhQCQkJ6tu3rzUOCQAAAAAA2CmTkdWNXIq5+fPn67XXXtN9992nqVOnqlSpUhn6q1Sposcff1ySFBMToxYtWuj8+fMaPny4fH19tXHjRm3evFkTJ07U1KlTzdtFRUXJ19dXgYGBioiIyDDn008/rQ0bNuj5559XQECA9u/frwULFqht27b6v//7vxzvlny3+Ph4eXh4KC4ujiVIAAAAAAAUkrycn9vsHjD27JdffpEknTp1SgMGDMjUHxgYaA5gypcvrx9++EHjx4/X4sWLFR8fr9q1a2vhwoV6+eWXc73PNWvWKCQkRMuXL9eaNWtUpUoVjRgxQpMmTcpT+AIAAAAAAIqeEnkFTFHHFTAAAAAAABS+vJyfc+kFAAAAAACAjRHAAAAAAAAA2BgBDAAAAAAAgI0RwAAAAAAAANgYAQwAAAAAAICNEcAAAAAAAIBiy8fHR++//35hlyHHwi4AAAAAAICSZsqUKQW6v0mTJuV5mwEDBig2NlYbNmzQgAEDtGzZMklSqVKlVK1aNT355JOaOXOmypcvn2nbmTNnauLEiZoxY4bGjh2boS8iIkJBQUGZtjl06JDq168vSVq6dKleeOGFTGMSEhLk4uKS52OxBwQwAAAAAAAgRx07dtSSJUt0+/Zt/fnnnxo4cKBiY2P1v//9L9PYJUuWaPTo0frkk08yBTB3HDlyRO7u7ub3lSpVytDv7u6uI0eOZGgrquGLxBIkAAAAAACQC87Ozqpatapq1Kih9u3bq2fPnvr6668zjduxY4cSEhI0depU3bhxQ999912W81WuXFlVq1Y1v0qVKpWh32QyZeivWrVqjjVevHhRXbp0kaurq3x9fbVq1apMY06dOqVu3brpH//4h9zd3fXcc8/pwoULufwp5B8BDAAAAAAAyJPjx4/ryy+/VOnSpTP1hYaGqnfv3ipdurR69+6t0NDQLOdo2rSpvLy89Oijj2r79u2Z+q9fvy5vb2/VqFFDnTt31m+//ZZjXQMGDFBUVJS+/fZbrVu3TgsWLNDFixfN/YZh6KmnntLVq1e1Y8cObdu2TceOHVPPnj3zcPT5wxIkAAAAAACQo82bN+sf//iHUlJSdOvWLUnSu+++m2FMfHy8wsPD9dNPP0mS+vbtq9atW2vevHnm5UZeXl5atGiRmjdvrsTERK1YsUKPPvqoIiIiFBAQIEmqX7++li5dqgceeEDx8fH673//q9atW2v//v2qU6dOlvVFRkbqiy++0K5du/Twww9LSguDGjRoYB7zzTff6MCBAzpx4oRq1qwpSVqxYoXuv/9+/fLLL2rZsqUVf2IZEcAAAAAAAIAcBQUFaeHChbp586Y+/vhjRUZGatiwYRnGrF69Wn5+fnrwwQclSU2aNJGfn5/WrFmjwYMHS5Lq1aunevXqmbfx9/fX6dOn9Z///MccwLRq1UqtWrUyj2ndurWaNWumefPmae7cuVq1apWGDBli7v/iiy909epVOTo6qkWLFub2+vXrq1y5cub3hw4dUs2aNc3hiyQ1bNhQ5cqV06FDh2wawLAECQAAAAAA5KhMmTKqXbu2GjdurLlz5yoxMTHT05w++eQTHTx4UI6OjubXwYMHLS5DuqNVq1Y6evSoxX4HBwe1bNnSPKZr167at2+f+dWiRQsZhiEp7d4xlhiGkWW/pXZr4goYAAAAAACQZ5MmTdITTzyhV155RdWqVdPvv/+uPXv2KCIiQp6enuZxsbGxCggI0B9//KFGjRplOddvv/0mLy8vi/syDEP79u3TAw88IEkqW7asypYtm2FMgwYNdPv2be3Zs0cPLQHtkAAAIABJREFUPfSQpLQnLcXGxprHNGzYUKdOndLp06fNV8H8+eefiouLy7BUyRYIYAAAAAAAQJ61a9dO999/v2bOnKkPPvhAoaGheuihh8zLiO7m7++v0NBQvffee3r//ffl4+Oj+++/X0lJSVq5cqXCw8MVHh5uHj9lyhS1atVKderUUXx8vObOnat9+/Zp/vz5FuupV6+eOnbsqJdeekmLFi2So6Ojhg8fLldXV/OYxx57TI0bN1afPn30/vvv6/bt23r11VcVGBiYYemSLRDAAAAAAABQwCZNmlTYJeQoNTVVjo7ZxwYjRozQCy+8oDfffFMrV67UmDFjshz3zDPPKCQkRLNmzVJSUpJGjRql6Ohoubq66v7779eWLVvUqVMn8/jY2FgNHjxY58+fl4eHh5o2barvvvvOfGWLJUuWLNGgQYMUGBioKlWqaPr06Zo4caK532QyacOGDRo2bJgCAgLk4OCgjh07at68eXn4yeSPybizSApFRnx8vDw8PBQXF2e+izQAAAAAANbUsWNH1a5dWx988EFhl2K38nJ+zk14AQAAAACAWUxMjLZs2aKIiAg99thjhV1OscESJAAAAAAAYDZw4ED98ssvGjlypLp161bY5RQbBDAAAAAAAMBs/fr1hV1CscQSJAAAAAAAABsjgAEAAAAAALAxAhgAAAAAAAAbI4ABAAAAAACwsRIbwISEhOjZZ5+Vn5+fTCaTfHx8LI41mUzZvmbMmJHj/iIiIixu36RJEyseGQAAAAAAsDcl9ilI48ePl6enp5o1a6bY2Nhsx65YsSLL9smTJ+vYsWPq0qVLrvc7ePBgtW3bNkObp6dnrrcHAAAAAABFT4kNYI4dOyY/Pz9JUqNGjXT9+nWLY/v27Zup7cyZMzpx4oRatGihxo0b53q//v7+Wc4HAAAAAIC9OX/+vGbMmKEtW7YoOjpalStXVpMmTTR8+HA9+uijkqSffvpJ06dP186dO5WQkKA6depowIABGj58uEqVKmWey2Qymf+7TJkyqlWrlt544w0NGDDA3B4REaGgoKAsazl37pyqVq1qmwMtACU2gLkTvuTXkiVLlJqaqkGDBuV525s3b8rBwUEuLi73VANgzwzDyPAPLAAAAIB0U6ZMyfD+9u3bWrdunY4ePaqePXuqbt26FrdNTU3V1q1btWfPHnXt2lXNmjXLdl87duzQt99+m+cao6Ki1Lp1a5UrV06zZ89W48aNlZycrK+++kpDhw7V4cOHtX79ej333HN64YUXtH37dpUrV07ffPONRo8erV27dunTTz/NcF6wZMkSdezYUTdu3NDatWv1wgsvyMvLSx06dMiw7yNHjsjd3T1DW+XKlfN8DPbEZBiGUdhFFLY7V8BERUXlarxhGKpVq5YuXLigc+fOZfpQZOVOiufu7q74+HhJko+PjwYOHKixY8eqdOnSFrdNTExUYmKi+X18fLxq1qypuLi4XO0bKCiJiYn66aefLCbWAAAAANLcHcDYOnzZvn278nPq36lTJx04cEBHjhxRmTJlMvTFxsaqdOnS8vb2VmBgoMLDwzP0f/755+ratavWrFmjnj17Skq7Amb9+vV66qmnzOMqVKigAQMGaM6cOZLSz51jYmJUrly5PNdc0OLj4+Xh4ZGr8/MSexPee/Htt9/qxIkTeu6553IdgJQuXVqdO3fW22+/rU2bNmnRokXy8/PTW2+9pS5duiglJcXitiEhIfLw8DC/atasaa1DAazm2rVrat++vWbPnq2NGzcWdjkAAABAkVAQ4Ut+/kB69epVffnllxo6dGim8EWSypUrp6+//lpXrlzRqFGjMvV36dJFdevW1f/+978s509JSdGnn36qq1evZntBQnFSYpcg3YuPP/5YkvTiiy/mepvWrVvr888/z9D20ksvadCgQQoNDdXatWsVHByc5bbjxo3TiBEjzO/vXAED2Ivr16/roYcekpeXl8aMGaNWrVpl6Gc5EgAAAJBZQYUvgYGBea7tr7/+kmEYql+/vsUxkZGRkqQGDRpk2V+/fn3zmDt69+6tUqVK6datW0pJSZGnp2eWt/aoUaNGhvfVq1fXkSNH8noYdoUAJo9iYmK0fv161a9fX23atLnn+SZOnKjQ0FBt2bLFYgDj7OwsZ2fne94XYAuGYWjMmDGqUKGCQkND5e3tLQcHByUmJpo/t4QvAAAAQEb2HL5IMi9Zys3/y1ta3pTVH2Lfe+89PfbYYzp9+rRGjBihN954Q7Vr18607ffff6+yZcua3zs6Fv34giVIebRy5UolJibm6eqX7NSsWVOlSpXSpUuXrDIfUNBSUlL0xx9/KCgoSL6+vnJwcNA333yjfv36qWnTpnr88ce1adMmXb16tbBLBQAAAOyGPYcvklSnTh2ZTCYdOnTI4pg7dVsac/jwYdWpUydDW9WqVVW7dm0FBQUpLCxMQ4cO1Z9//plpW19fX9WuXdv88vHxyfex2AsCmDwKDQ1V6dKl9fzzz1tlvuPHjyslJaVIP0oLJVtsbKyOHTtmviP5unXr1KlTJ8XHx6tatWqKjo5Wr1699MEHHyguLq6QqwUAAADsgz2HL5Lk6empDh06aP78+bpx40am/tjYWLVv316enp7mG+jebdOmTTp69Kh69+5tcR+1a9fWM888o3Hjxt1TrUUFAUwe7NmzR/v371eXLl0sPv4qOTlZhw8f1qlTpzK0nz9/PtPYlJQU8weta9eu1i8YKABOTk5ydnbWvn37lJycrEmTJmn06NEKCwvTli1btGPHDnXq1EmzZ8/Wvn37JFm+RBEAAAAoKew5fLljwYIFSklJ0UMPPaTw8HAdPXpUhw4d0ty5c+Xv768yZcroo48+0saNGzV48GAdOHBAUVFRCg0N1YABA9SjRw8999xz2e5j5MiR+vzzz7Vnz54M7RcvXtT58+czvJKTk61yXIWl6C+iyqcVK1bo5MmTkqRLly4pKSlJ06dPl5R2N+fXXnst0zahoaGSlOUNgu6Ijo5WgwYNFBgYqIiICHN7p06dVKFCBbVp00bVq1fXhQsXFBYWpv3796t79+565plnrHh0QMFxd3dXcHCwZs6cqXr16snDw0Pdu3c3r9esVKmS5s6dqzZt2mjx4sUKDAzknjAAAAAo8ew9fJHSlgH9+uuvmjFjhkaOHKlz586pUqVKat68uRYuXChJ6tGjh7Zv366ZM2cqICBACQkJql27tv79739r+PDhOf6//wMPPKDHHntMb731lrZu3Wpur1evXqaxO3fuzPTAj6LEZJTQP0W3a9dOO3bsyLLP29tbUVFRGdoSEhLk5eWlsmXL6uTJk3JwyPrioaioKPn6+mYKYGbNmmW+BCsmJkZubm5q1KiR+vfvr0GDBlmcLyt5ec44UBBOnjypoKAgXbp0SQ4ODtq+fbuaNWum1NRUOTg4KDk5Wf/85z/l7e2tdevWFXa5AAAAAGAVeTk/L7FXwNwdjuSGq6urYmNjcxzn4+OT5fKKMWPGaMyYMXnaJ1BUeHt7KywsTO3atdO1a9e0YcMGNW7c2Hyn8kuXLql06dLmlJ/HUgMAAAAoaUpsAAPAupo3b66IiAi1b99e06dP1/Xr1/X0008rOTlZS5cuVWRkpJYtWyaJx1IDAAAAKHlK7BKkoowlSLBnR44c0bhx47R582alpqaqcuXKcnd319q1a/Xggw8WdnkAAAAAYDV5OT8ngCmCCGBg7xITE3Xw4EH9/vvvqlGjhho2bCgvL6/CLgsAAAAArIp7wAAoVM7OzmrWrFmOd2sHAAAAgJIi94/eAQAAAAAAQL4QwAAAAAAAANgYAQwAAAAAAICNEcAAAAAAAADYGDfhBYqo8ePHy9nZ2WL/5cuXtWzZMjk7O6t///4qW7asxbHXrl3TsmXLlJiYqP79+6tixYoWxyYmJmrlypW6ePGi+vXrpxo1algce/v2ba1bt05Hjx5Vz549VbduXYtjU1NTtXXrVu3Zs0ddu3bN8Qa+O3bs0Pbt2xUUFKTAwMBsx/7666/atGmTWrRooU6dOsnBIWP2PGnSpGy3BwAAAIB7xRUwQBFF+GKd8AUAAAAACgJnIkAxQ/iSjvAFAAAAgL3gbAQoRghf0hG+AAAAALAnnJEAxQThS7q8hC+RkZHZzgUAAAAA1kAAAxQDhC/p8hq+rF27Ntv5AAAAAMAaCGCAIo7wJV1+wpc6depkOycAAAAAWAMBDFCEEb6ky2/40qNHj2znBQAAAABrcCzsArJz9OhRbd++XQcPHtTFixdlMplUqVIlNWrUSIGBgdme6AHFHeFLunsJXxwd7fqfQQAAAADFhN2deSQlJWnZsmVauHCh9u/fL8MwshxnMpnUuHFjvfrqq+rfv7+cnJwKuFKgcBG+pCF8AQAAAFAU2NUSpLCwMNWvX19DhgyRi4uLpk6dqm+++UYnTpxQfHy84uLidOLECW3btk1TpkyRq6urhgwZonr16iksLKywywcKFOEL4QsAAACAosNkWLrEpBC4uLjoxRdf1BtvvKHatWvnaptjx47p3Xff1SeffKKEhAQbV2gf4uPj5eHhobi4OLm7uxd2OSgko0aNInyxUvgyadKkbPcFAAAAAFnJy/m5Xf0J+OjRo6pZs2aetqlVq5bmz5+vcePG2agqwD4RvnDlCwAAAICiw66WIOU1fLlbdieNQElC+JKO8AUAAACAvbCrAObvRowYoQMHDhR2GUCRQfiSjvAFAAAAgD2x6wDm/fffV9OmTdWkSRO9//77unjxotXmDgkJ0bPPPis/Pz+ZTCb5+PhYHDt58mSZTKYsX8OHD8/1PpOSkjR16lTVqlVLzs7O8vb21pgxY3Tz5k0rHBFKOsKXdHkJX86cOZPtfgEAAADAGuz6T8KHDx/WsmXLtGrVKo0YMUKjR49Whw4d1L9/f3Xt2vWeHj09fvx4eXp6qlmzZoqNjc3VNu+9916mk9oGDRrkep/BwcEKDw9Xv379FBAQoP3792vOnDnas2ePtm3blu0JJZAdwpd0eQ1fVqxYocWLF2e7fwAAAAC4V3YdwNStW1czZszQjBkztH37di1fvlyfffaZtmzZonLlyqlXr17q16+f/P398zz3sWPH5OfnJ0lq1KiRrl+/nuM2Tz31VLZXymTnq6++Unh4uIYNG6a5c+ea2318fDRq1CitXr1affv2zdfcKNkIX9LlJ3ypXLlytvsHAAAAAGsoMpdcBAUFacmSJTp//rxWrFihhx56SIsXL1bbtm3zNd+d8CWvrl27puTk5Dxvt2rVKknSyJEjM7S/+uqrcnV11cqVK/NVD0o2wpd0+Q1fCD4BAAAAFIQiE8Dc4erqqurVq8vLy0suLi4yDKPA9v3ggw/K3d1dLi4uatGihdauXZvrbXfv3q1q1arJ29s7Q7urq6uaNGmi3bt3W7tcFHOEL+nuJXxxdnbOtg4AAAAAsAa7XoJ0t8jISC1fvlwrV67U6dOn5eDgoPbt26t///4233e5cuU0aNAgtW7dWhUqVNCxY8f0wQcfqFevXjp69KgmTJiQ4xzR0dFq2LBhln01atTQzp07dfPmTbm5uWXqT0xMVGJiovl9fHx8/g8GxQbhSxrCFwAAAABFgV0HMFevXtWaNWu0fPly/fLLLzIMQ40aNdLs2bPVt29fValSpUDqyOpJR0OGDFHLli01ZcoU9evXL9OVLX938+ZNiyd7Li4u5jFZBTAhISGaMmVKPipHcUb4QvgCAAAAoOiw6yVIXl5eGjZsmE6cOKF//etf2rt3rw4cOKCRI0cWWPhiiaurq958803dvn1bX3/9dY7j3dzcMlzFcreEhATzmKyMGzdOcXFx5tfp06fzXziKDcIXwhcAAAAARYddXwHTpUsX9e/fX0888US2J1eF5c4TkS5dupTj2OrVq+vMmTNZ9kVHR6t8+fIWAxhnZ2dOGJEJ4QvhCwAAAICiw66vgFm3bp26dOlil+GLJB09elSSVLVq1RzHtmzZUmfPntXJkycztCckJGjfvn1q2bKlTWpEyUP4ko7wBQAAAIC9sOsA5u9Onjyp2bNn6/XXX9eiRYt069Ytm+/z9u3bunLlSqb22NhYhYSEyMnJSR06dDC3Jycn6/Dhwzp16lSG8cHBwZKkOXPmZGhfuHChEhISeBQurILwJR3hCwAAAAB7YneXlixdulTz5s3T559/rmrVqpnb/+///k9PP/20bty4IcMwZDKZtGDBAv34448qU6ZMnvezYsUK89Uoly5dUlJSkqZPny4p7alHr732miTp+vXrqlGjhrp3764HHnhAFSpU0PHjx/XJJ5/o4sWLev/991W9enXzvNHR0WrQoIECAwMVERFhbn/iiSf01FNPad68eYqLi1NAQID279+vBQsWqF27durTp09+flyAGeFLuryEL5cvX862RgAAAACwBpNhGEZhF3G37t27KyoqSr/++qu5zTAM1alTRydOnNCoUaPk7++vDRs2aPny5Zo2bZr+/e9/53k/7dq1044dO7Ls8/b2VlRUlKS0k9qhQ4dq9+7dOn36tK5fv67y5cvr4Ycf1vDhw/Xoo49m2DYqKkq+vr6ZApg7c4WEhGj58uWKjo5WlSpV1KtXL02aNClPIVJ8fLw8PDwUFxcnd3f3PB03io+7n4xF+JIur+HLsmXLeLQ7AAAAgHzJy/m53QUwtWrVUo8ePTRr1ixz286dO9W6dWv169dPy5YtM7cHBQXp2rVr2rNnT2GUWmgIYCClBzCEL+nyE744Ozvn6kbaAAAAAPB3eTk/t7t7wFy8eFF+fn4Z2n788UeZTCb17t07Q/uTTz5pvhEuUBIRvqTLb/jSv3//bOsFAAAAAGuwuwDG0dFRycnJGdp2794tSXrooYcytFesWLFAbsQL2CPCl3T3Er6ULVs225oBAAAAwBrsLoDx8fExBy6SlJKSou+//15+fn7y9PTMMPbKlSuqWLFiQZcI2AXClzSELwAAAACKArsLYJ555hl9+umnWrRokSIjI/Xvf/9bFy9e1DPPPJNp7O7du+Xr61sIVQKFj/CF8AUAAABA0WF3j6F+/fXXtXz5cr3yyiuS0p6AVL16dY0cOTLDuPj4eG3ZskVvvPFGYZQJFDrCF8IXAAAAAEWH3QUwZcuW1Z49e/Thhx/q6NGj8vPz05AhQzItPzp48KD69eunXr16FVKlQOEifCF8AQAAAFB02F0AI0nu7u4aPXp0tmP8/f3l7+9fQBUBRQfhSzrCFwAAAAD2wu7uAQMg/whf0hG+AAAAALAndhXALF26VKmpqXneLjU1VUuXLrV+QUARQviSLi/hy7Vr17I9HgAAAACwBrsKYP71r3+pfv36mjdvni5fvpzj+MuXL2vevHlq0KCBXn/99QKoELBPhC/p8hq+LFu2LNtjAgAAAABrsKt7wNx57PQbb7yhUaNGqXnz5nr44YdVq1YteXp6yjAMxcTE6K+//tLu3bu1d+9epaamasCAAZo+fXphlw8UCsKXdPkJXxITE7M9LgAAAACwBrsKYKpWrarQ0FBNnjxZH374ocLCwvTf//43y7H16tXTmDFjNHjw4GyfBgMUZ4Qv6fIbvvTv3z/bYwMAAAAAa7CrAOaOmjVrasaMGZoxY4bOnTungwcP6tKlSzKZTKpUqZIaNWqkKlWqFHaZQKEifEl3L+FLxYoVsz0+AAAAALAGuwxg7ubl5SUvL6/CLgOwO4QvaQhfAAAAABQFdnUTXgC5R/hC+AIAAACg6CCAAYoowhfCFwAAAABFBwEMUEQRvhC+AAAAACg6CGCAYobwJR3hCwAAAAB7QQADFCOEL+kIXwAAAADYEwIYoJggfEmXl/AlMTHRYh8AAAAAWItdBzBOTk5as2aNxf6wsDA5OTkVYEWAfSJ8SZfX8GXlypUW+wEAAADAWuw6gLl9+7ZSU1Mt9qekpCglJaUAKwLsD+FLuvyELxcvXrQ4BgAAAACsxa4DGEkymUwW+yIjI+Xh4VGA1QD2hfAlXX7Dl379+lkcBwAAAADWYvksqZCsWLFCK1asML8PCQnRkiVLMo2LiYnRvn379OSTTxZkeYDdIHxJdy/hS40aNSyOBQAAAABrsbsrYC5fvqxDhw7p0KFDMplMio6ONr+/8zp8+LBu3Lihvn376sMPP8zXfkJCQvTss8/Kz89PJpNJPj4+WY4zDEMrV65Ur169VLt2bbm5uem+++5T165d9fPPP+d6fxERETKZTFm+mjRpkq9jQMlG+JKG8AUAAABAUWAyDMMo7CIscXBw0MqVKxUcHGz1uU0mkzw9PdWsWTPt3btX7u7uioqKyjTu1q1bcnV1VePGjdW5c2f5+fnp3Llz+vDDD3X27FktX75cffv2zXF/ERERCgoK0uDBg9W2bdsMfZ6enurUqVOua4+Pj5eHh4fi4uLk7u6e6+1QvJhMJsIXK4UvkyZNsrgdAAAAAFiSl/Nzu1uCdLejR4+qatWqNpn72LFj8vPzkyQ1atRI169fz3Kco6Ojvv32WwUFBWVoHzRokBo1aqRRo0YpODg42xPVu/n7++cqsAFyQvjClS8AAAAAig67W4J0t1q1aqlMmTJKSEhQRESE1q5da7UnltwJX3Li6OiYKXyRpKpVqyogIEAXLlzIc003b97UrVu38rQN8HeEL4QvAAAAAIoOuw5gJGnRokWqXr26Hn30UQUHB+uPP/6QJF28eFFlypTRJ598Umi1RUdHy8nJSeXKlcv1Nq+//rrKlCkjV1dX+fr6atq0aUpOTs52m8TERMXHx2d4AdkhfElD+AIAAADAXth1ALN+/Xq9/PLLat26tRYuXKi7b1dTuXJlPfbYY/rss88KpbYtW7Zo9+7deu655+Ti4pLj+NKlS6tz5856++23tWnTJi1atEh+fn5666231KVLF6WkpFjcNiQkRB4eHuZXzZo1rXkoKGYIX9IQvgAAAACwJ3Z9E15/f3+5urrq22+/1ZUrV1SpUiV98803euSRRyRJ06dP18cff5zlzXPz4s49YHI7z5EjR8y1/fbbb6pcuXK+9z1o0CCFhoZq1apVFm82nJiYqMTERPP7+Ph41axZk5vwlnBTpkzJ1Eb4kiYv4cvt27c1bdo0i/0AAAAAYElebsJr11fAHDhwQN27d7fY7+XlpQsXLhRgRdKJEyf0+OOPS5K++OKLewpfJGnixImS0q6oscTZ2Vnu7u4ZXsDfEb6kyWv4sm7dOov9AAAAAGAtdv0UpFKlSik1NdVi/7lz5+Tm5lZg9URFRSkoKEjXrl3Ttm3b1Lhx43ues2bNmipVqpQuXbpkhQpRUhG+pMlP+HL06FGLYwAAAADAWuz6CpjGjRtr27ZtWfalpqYqLCxMLVq0KJBaTp48qaCgIMXGxurrr7+22n6PHz+ulJQUmz1uG8Uf4Uua/IYvPXv2tDgOAAAAAKzFrgOYoUOHasuWLZo8ebJiYmIkpQUvR44c0bPPPqs//vhDw4YNs3kdJ0+eVLt27RQTE6Ovv/5aLVu2tDg2OTlZhw8f1qlTpzK0nz9/PtPYlJQUjRs3TpLUtWtX6xaNEoHwJc29hC9169a1OBYAAAAArMWulyD17t1b+/fv19SpUzV9+nRJUseOHWUYhgzD0MSJE9W5c+d8zb1ixQqdPHlSknTp0iUlJSWZ91GuXDm99tprktJOAoOCghQVFaVhw4YpMjJSkZGRGeZ6/PHHVaVKFUlpj6Zu0KCBAgMDFRERYR7TqVMnVahQQW3atFH16tV14cIFhYWFaf/+/erevbueeeaZfB0HSi7ClzSELwAAAACKArt+CtIdu3fv1qpVq3T48GEZhqG6deuqX79+evjhh/M9Z7t27bRjx44s+7y9vc1PRIqKipKvr2+2c23fvl3t2rXLMP7vAcysWbO0adMmHT16VDExMXJzc1OjRo3Uv39/DRo0KNsT4r/Ly12WUXyZTCbCFyuFL5MmTbK4HQAAAABYkpfz8yIRwCAjAhhI0iOPPEL4YqUrXwhgAAAAAORHsXkMNQDLCF9YdgQAAACg6LDre8AMHjw4236TySRXV1fdd999at++vRo1alRAlQH2jfAlDeELAAAAAHth1wHMxx9/LJPJJEn6+0qpv7ebTCb1799foaGh5j6gJCJ8SUP4AgAAAMCe2PUSpHPnzqlZs2bq2rWrfvjhB12+fFmXLl3S999/ry5duqhFixY6duyYfvrpJ3Xp0kXLli3Te++9V9hlA4WG8CVNXsKX1NRUi30AAAAAYC12fRPegQMH6syZM/r666+z7H/88cfl6+urRYsWyTAM+fv7KyEhQfv37y/gSgsWN+GFJE2ZMiXDe8KXNHkNX7Zu3apffvnF4hgAAAAAsKTY3IT3888/V7du3Sz2d+vWTRs3bpSUtgTp6aef1l9//VVQ5QF2g/AlTX7Clz179lgcAwAAAADWYtcBzI0bN3TlyhWL/VeuXNH169fN78uXL8/9X1DiEL6kyW/40rVrV4vjAAAAAMBa7DqAadq0qebPn68TJ05k6jt+/LgWLFigpk2bmtuOHj0qLy+vgiwRKFSEL2nuJXxp1qyZxbEAAAAAYC12/RSkkJAQtW/fXg0bNtTTTz9tPqk6fPiwNm7cKMMwNHPmTElSUlKSVq5cqU6dOhVmyUCBIXxJQ/gCAAAAoCiw6wAmICBA27Zt0xtvvKE1a9Zk6GvWrJneffddBQQESJJKly6tv/76K9uTRSAnhmEUmWVshC+ELwAAAACKDrsOYCSpbdu22rNnj86ePasTJ07IMAz5+fmpWrVqGcaZTCaVKVOmkKpEUZaYmKiffvpJQUFBRSZ8kUT4QvgCAAAAoAix+wDmjmrVqmUKXYB7de3aNXXu3Flubm6Kj4/P9qlb9obwhfAFAAAAQNFhVwHM2bNn87UdwQzy4/r163rooYfk5eWlMWPGqFWrVhn67X05EuEL4QsAAACAosOXOegDAAAgAElEQVSuApgaNWrk64Q3JSXFBtWgODMMQ2PGjFGFChUUGhoqb29vOTg4KDEx0RxA2HP4kh3ClzSELwAAAADsiV0FMOPHj8900rt161b99ttvCgoKUsOGDSVJBw8eVEREhJo1a6YnnniiMEpFEZeSkqI//vhDQUFB8vX1lSR98803WrRokY4ePaqKFStq2LBhatOmjTw9PQu52twjfElD+AIAAADA3thVADN9+vQM78PCwjR37lzt3LlTDz/8cIa+nTt3qkOHDho7dmxBlohiIjY2VseOHVOPHj0kSevWrVNwcLAeeeQRVatWTSdOnFCvXr00duxYvf766/Lw8CjkinNG+JImr+HLjh07su0HAAAAAGuwfBMJOxASEqKhQ4dmCl8kyd/fX0OHDtWMGTMKoTIUdU5OTnJ2dta+ffuUnJysSZMmafTo0QoLC9OWLVu0Y8cOderUSbNnz9a+ffskpS1bsleEL2nyE75s37492zEAAAAAYA12HcAcOnQo2xOzmjVr6siRIwVYEYoLd3d3BQcHa+nSpXrvvffk4eGh7t27mwOGSpUqae7cuapcubIWL14syX7vCUP4kia/4UtQUFC24wAAAADAGuw6gKlQoYK+/PJLi/1bt24tUvfngH0ZNGiQvL29NW3aNB08eNDcnpqaKikthKlQoYJu3bpVWCXmiPAlzb2EL4GBgdmOBQAAAABrsOsApk+fPtq8ebP69++vP//8UykpKUpJSdGff/6p/v3764svvlDfvn0Lu0wUUd7e3goLC5OUFiJs2LBBt2/fNj/e+dKlSypdurT5xN/eliARvqQhfAEAAABQFJgMezurvEtiYqKeffZZbd68WSaTyXxinJqaKsMw1KVLF4WFhcnJyamQKy1Y8fHx8vDwUFxcnNzd3Qu7nCJv7969at++vWJiYjR8+HA9/fTTSk5O1tKlS7V161bt3LlTderUKewyM3F0dCR8sVL4MmnSpGy3AwAAAICs5OX83K4DmDu2bt2qTZs26dixY5KkWrVq6amnnlLHjh0LubLCQQBjfUeOHNG4ceO0efNmpaamqnLlynJ3d9fatWv14IMPFnZ5WWrQoAHhi5WufCGAAQAAAJAfeTk/t6vHUFvSqVMnderUqbDLQDFWr149/e9//9PBgwf1+++/q0aNGmrYsKG8vLwKuzSLCF9YdgQAAACg6LDre8DYUkhIiJ599ln5+fnJZDLJx8cn2/EXLlzQwIEDVaVKFbm4uKhx48bmp+PkVlJSkqZOnapatWrJ2dlZ3t7eGjNmjG7evHkPRwJrcXZ2VrNmzdS/f389+uijdh2+SCJ8IXwBAAAAUITY9RUwgwcPznGMyWTSRx99lOe5x48fL09PTzVr1kyxsbHZjo2NjVWbNm0UHR2t4cOHy9fXVxs3btTgwYN19uzZXC9fCA4OVnh4uPr166eAgADt379fc+bM0Z49e7Rt2zbzPW6Ae0H4ko7wBQAAAIC9sOsA5uOPP7bYZzKZZBhGvgOYY8eOyc/PT5LUqFEjXb9+3eLYWbNm6a+//lJ4eLi6d+8uSXrppZfUtWtXzZgxQ88//7x8fX2z3d9XX32l8PBwDRs2THPnzjW3+/j4aNSoUVq9ejVPdMI9I3xJR/gCAAAAwJ7Y9SUXycnJmV4JCQk6ePCgXnjhBbVq1UqXL1/O19x3wpfcWLVqlXx9fc3hyx0jRoxQcnKy1q5dm6s5JGnkyJEZ2l999VW5urpq5cqVua4HyArhS7q8hC+//vprtv0AAAAAYA12HcCUKlUq08vZ2VkNGjTQxx9/rPLly2vChAk2reH8+fM6ffq0/P39M/X5+/vLZDJp9+7dOc6ze/duVatWTd7e3hnaXV1d1aRJk1zNAVhC+JIur+HLpk2bsh0DAAAAANZg10uQctKpUydNnTpV8+fPt9k+oqOjJSnLk0lnZ2dVrFhRZ86cydU8DRs2zLKvRo0a2rlzp27evCk3N7dM/YmJiUpMTDS/j4+Pz235dmXKlCmFXUKxRPiSLj/hS4sWLbIdBwAAAADWYNdXwOQkJiZG165ds+k+7jyhyNJJrYuLS66eYnTz5s1s57h7X38XEhIiDw8P86tmzZq5KR0lAOFLuvyGLzziHgAAAEBBKJIBzPXr17Vhwwa99957OZ6U3as7V6TcfQXK3RISErK8aiWrebKb4+59/d24ceMUFxdnfp0+fTo3paOYI3xJdy/hC08fAwAAAFAQ7HoJUunSpWUymTK1p6SkSJI8PDw0Z84cm9ZQvXp1ScpymdGtW7d05coVtW3bNlfzWFqqFB0drfLly1sMYJydnbM9uUbJRPiShvAFAAAAQFFg1wFMz549MwUwJpNJnp6eqlu3rvr06SMPDw+b1lC1alXzPVr+bteuXTIMQy1btsxxnpYtW2rlypU6efJkhhvxJiQkaN++fbkKcYC7Eb4QvgAAAAAoOuw6gLGXRzMHBwdr9uzZ+uyzzzI8ivrdd9+Vo6OjevbsaW5LTk7WsWPH5Obmpvvuuy/DHCtXrtScOXM0d+5cc/vChQuVkJCgvn37FszBoNggfCF8AQAAAFB02HUAY0srVqzQyZMnJUmXLl1SUlKSpk+fLkkqV66cXnvtNfPYsWPHat26derXr5/27t0rX19fbdy4UZs3b9bEiRPl5+dnHhsdHa0GDRooMDBQERER5vYnnnhCTz31lObNm6e4uDgFBARo//79WrBggdq1a6c+ffoUzIGj2CB8IXwBAAAAUHQUiQAmLCxM69ev17Fjx2QymeTn56fu3burR48e+Z4zNDRUO3bsyNA2ceJESdL/s3ff8VFV+f/H3xNIBRKkB6SDoSwoUkSCEJqLfuk2CKgIrIiKuujSBCGi4LqrKIoFDARFRJC1rCgqXYkouBQB6RakyUoJEUhIMr8/+DEhm0L6Pefm9Xw85rGbuXcmZ/B+5nzOO3fu1K5dO0MAc8UVV+irr77S+PHjNXv2bCUkJKhBgwZ69dVXdd999+X6dy5cuFDTpk3Tm2++qYULF6pq1aoaNWqUJk2axKIQhYbwJR3hCwAAAABTeLxer9fpQWTnzJkz6t27t1auXCmv16uyZctKuvAtSB6PR126dNGHH36o4OBgh0davBISEhQWFqZTp04pNDTU6eHkWkxMjNNDcD3Cl3R5CV8mTZqU43MBAAAAQFbysj43+s/B48eP14oVK3T//ffrl19+UUJCghISEvTLL79oxIgRWr58uR5//HGnhwkYgfAlXV7Cl927d+f4XAAAAABQGIw+AyY8PFzt27fX4sWLs9x+yy236Ouvv9ahQ4eKeWTO4gwY/C/Cl3R5DV/effddpaSk5PicAAAAAJAV15wBc+rUKXXp0iXb7V27dtWpU6eKcUSAeQhf0uUnfGnYsGGOzwkAAAAAhcHoAKZ58+bau3dvttv37dunP/3pT8U4IsAshC/p8hu+FORi3gAAAACQW0YHME8++aRmzZqlTz/9NNO2pUuXatasWb6vjgZKGsKXdAUJX0qXtuLL4AAAAABYzqiVx7333pvpvnr16qlHjx5q2rSpGjduLI/Hox07dmj79u1q3ry53nvvPXXr1s2B0QLOIny5gPAFAAAAgA2MWn288cYb2W7btm2btm3bluG+LVu2aOvWrXr99deLemiAcQhfCF8AAADcLC0tLcf+DrCNUSuQ8+fPOz0EwBqEL4QvAAAAbpGcnKy9e/fqyJEjqlGjhiIiIghf4DpGrUJKlSrl9BAAaxC+EL4AAAC4wenTp9WzZ0/t3btXhw4dUnBwsCIjIzVjxgzVr19f/v7+Tg8RKBREioDLEL6kI3wBAAAw25kzZxQZGalSpUrpmWee0ddff60+ffpoxYoV6t27t/71r3/p9OnTTg8TKBSsRgAXIXxJR/gCAABgvoULF+rMmTOaPn26mjZtqlKlSumll15SeHi4nn/+ecXExMjPz0/9+vXjExOwHmfAAC5B+JIuL+HLr7/+muPvBQAAQNHZsWOHUlNT1bx5c5UqVUrnz59XhQoVFBMTo/DwcO3cuVNjxozRwYMHJUler9fhEQP5RwADuADhS7q8hi9vvfVWjr8bAAAARadq1ao6cuSI/vOf/0iS/P39de7cOQUFBSkiIkIjR45UcnKyHn30UUmSx+NxcrhAgRDAAJYjfEmXn/ClSpUqOf5+AAAAFJ0+ffooNTVV06ZN07Zt2yRJQUFB+uGHH7RlyxZFRUWpT58+2rp1qxITEx0eLVAwXBQBsBjhS7r8hi+DBg3KcQwAAAAoOg0bNtSyZcvUtWtX7dq1S71795bH49GLL76oXr16qW/fvqpRo4beeOMNHTx4UFdddRVnwcBaVpwBEx8fr8mTJ2vEiBHatWuXJCkxMVHx8fE6deqUw6MDnEH4kq4g4UtgYGCO4wAAAEDR6ty5s+Lj4xUcHKxXXnlF8+bN03333afY2FhJ0pdffqnq1aurVq1ahC+wmtFnwKSlpenOO+/UwoUL5fV65fF4dNtttykiIkKlS5fW//3f/2nMmDEaO3as00MFih3hywWELwAAAPZr27atVq5cqZMnTyopKUn16tWTJB09elTr169XixYtuAAvrGf0GTDPPvusFi5cqL///e/6/vvvMxRcUFCQ+vbtq6VLlzo4QsA5hC+ELwAAAG5SpkwZ1ahRwxe+fPvtt5o4caKWL1+uJ598UiEhIQ6PECgYowOYuLg43XnnnXrsscdUrVq1TNsbN26svXv3OjAywHmEL4QvAAAAbrV9+3Y9++yzWrlypdasWaOmTZs6PSSgwIwOYH766SdFRkZmu/2KK67QiRMninFEgDkIXwhfAAAA3Oqqq67SI488ohUrVqh58+ZODwcoFEZfA6Zs2bI5Bix79+7NcREKlESEL+kIXwAAAOzk7++v9u3bOz0MoFAZfQZMZGSk3n777Sy3nThxQnPmzFGnTp2KeVSAuQhf0hG+AAAAADCJ0QHM448/rp07d6pr166+i+1u2bJFr7/+uq699lolJibyDUjA/0f4ki4v4ct///vfHMcIAAAAAIXB4zX8u7w++ugjDRs2TL///rvvq6i9Xq8qVaqkefPm6aabbnJ6iMUuISFBYWFhOnXqlEJDQ50eTq7FxMQ4PQTXInxJl9fwZd68eUpISMhxrAAAAIAtzp8/rwMHDmjfvn2qWrUq19ApYnlZnxt9DRhJ6tWrl37++Wd99tln+uGHH+T1enXVVVfppptuUpkyZYplDJMnT84xPChdurTOnz+f43NERUVpzZo1WW57//331adPnwKNESUX4Uu6/IQvfDQJAACURPxxtPBMmjTJ6SH4JCYmKjo6Wj/88IP27dunsLAw9enTR3PnznV6aJAFAYwkBQcHq0+fPo6FFP369VODBg0y3b9161b94x//UM+ePXP1PJUqVdL06dMz3d+qVasCjxElE+FLuvyGL3fffXeO4wUAAABskJiYqOuuu041a9bUhAkT1KhRIz3//PNatGiRmjZtqscee8zpIZZ4VgQwTmvevHmWp20NHz5ckjR06NBcPU+ZMmU0aNCgQh0bSi7Cl3QFCV/KlSuX45gBAAAA050/f17333+/wsPD9dprr6lWrVry8/PTzJkz9d1332ndunUEMAYw+iK8krRw4UJ16NBB1atXV2BgoAICAjLcnPr4wJkzZ7Rw4ULVqFFD3bt3z/Xj0tLSlJCQoLS0tCIcHUoCwpcLCF8AAABQ0v3nP//R9u3b1bdvX1/4kpycrEqVKunGG2/U9u3bdeLECaeHWeIZfQbMU089pUmTJqlSpUpq3bq1rrjiCqeH5LNo0SIlJCTooYceUqlSpXL1mIMHD6ps2bI6e/asgoKC1KlTJz355JOX/QhSUlKSkpKSfD9zwVBIInwR4QsAACi4i1/0AdgsPDxcdevW1aBBg3y9dkBAgCSpatWqOnXqlAz//p0SwegA5pVXXlGHDh302Wef+Q4eU8TGxsrj8WjIkCG52r9OnTpq166dmjVrpsDAQG3atEkzZsxQZGSkPv30U3Xu3Dnbx06bNo2LZCETwhfCFwAAkD9JSUmKj49Xp06dCF/gCrVq1dKbb76pkJAQpaWlyc/Pz/e/5cuXV6lSpZSamurb/+zZswoODnZwxCWT0QHMqVOn1L9/f+PCl127dumrr75Sly5dVLdu3Vw9Ji4uLsPP/fr106BBg3Tttdfqvvvu0+7du7N97Lhx4zRq1CjfzwkJCapZs2a+xg73IHwhfAEAAHl3+vRp9ejRQyEhIUpISFDv3r2dHhJQKEJCQiQpU8/t7++f4eyXxMREDR06VKdOndKyZcuKdYwlndEBTIsWLXTw4EGnh5FJbGysJGnYsGEFep6IiAjdfvvtiouL0549e9SwYcMs9wsMDOSrcpFrhC/pCF8AAMClEhMT1aZNG4WHh2vMmDFq27Zthu18HAlucrH/Tk5O1rlz5+T1enX27Fk99thj+uSTT7R8+XKHR1jyGH0R3ilTpujVV1/Vtm3bnB6KT0pKit58801VqFBBffv2LfDz1alTR5J07NixAj8XQPiSjvAFAABcyuv1asyYMapYsaJiY2PVoUMHBQUFZbjWIuEL3MjPz08ej0cJCQl69NFH9dZbb2nt2rW67rrrnB5aiWP0GTCdOnXSrFmz1KpVK7Vv3161a9fOdMFbj8ej119/vdjG9O9//1tHjx7Vww8/XChnpezZs0eSVK1atQI/F0o2wpd0eQlfTp8+nePrAQAA7pCamqpt27apU6dOvssILF++XLNmzdKePXtUqVIljRw5Uu3bt1eFChUcHi1QcBfP6Lr47cEPPvig1qxZo3Xr1qlFixZOD69EMjqA2bBhg4YMGaLk5GStXLkyy32KO4C5+PGjoUOHZrn98OHDOnXqlGrVquX7DN6JEydUpkyZTNey2bhxoxYtWqSmTZuqXr16RTtwuBrhS7q8hi/z5s3TP//5zxxfF/C/0tLS5PF4+EspAFjk5MmT2rdvn2699VZJ0nvvvafo6Gh17txZ1atX148//qj+/ftr7NixevjhhxUWFubwiIGCudinlC5dWkePHtX69eu1fv16XX311Q6PrOQy+iNIDz/8sEqXLq33339fv/32m86fP5/plpycXGzjOXTokJYtW6Y2bdqoWbNmWe4zbtw4NW7cWN9++63vvjVr1qhmzZp68MEH9cILL+jVV1/V8OHDFRkZKX9/f82ePbu4XgJciPAlXX7Cl0tPOwZyIzExUf3799e+ffucHgoAIA8ungWwefNmnT9/XpMmTdLo0aO1ePFiLV26VGvWrNHNN9+sZ599Vps3b5YkvrYXrhAVFaVrrrmG8MUARp8Bs3nzZk2ePNmYK5PHxcUpNTU1zxffjYiIUMeOHbVs2TIdPXpUSUlJql69ugYNGqSxY8dme/Fd4HIIX9LlN3y5++67c3xtwKUSEhLUoUMHbd26VZUrV9bMmTOdHhIAIJdCQ0MVHR2tqVOnKiIiQmFhYerXr5+vZ6hcubJmzJih9u3ba/bs2erYsSNnOsIVGjRooPj4eAUFBTk9lBLP6ACmSpUqRn37z/jx4zV+/Pgc94mLi8v0ldONGzfWokWLinBkKIkIX9IVJHypVKlSjq8PuCghIUHNmzdX7dq11axZMy1fvlyHDh1S9erVnR4aACCXhg0bprfffltTpkzJ0LOkpaXJz89PlStXVsWKFXXu3DkHRwkUPsIXMxj9EaS7775b77zzjtLS0pweCmAcwpcLCF9QHBISEnT11Verbt26WrZsmSZOnKg9e/ZoyZIlTg8NAJAHtWvX1uLFiyVd6As++OADpaSk+HqYY8eOyd/f39db8REkAIXJ6DNgOnfurE8++UTt27fXiBEjVKdOnUzfgiRJ7dq1c2B0gLMIXwhfUDxOnz6tpk2bqlGjRnrzzTcVHBysFi1aqG7duoqNjVXv3r1Vq1Ytp4cJAMilli1bavXq1brxxhv11FNPKTExUX379tX58+cVFxen3bt3a968eZL4WmoAhcvoAKZTp06+///NN99k2n7xa7VSU1OLc1iAEQhfCF/y6vTp0xo3bpwmTJigatWqOT0cK3i9Xg0fPlyNGzdWXFycwsPDJUn169fXsGHDNGHCBO3cuVO1atXynb4OADBfy5YtFR8fr3Hjxunll1/WjBkzVKVKFYWGhmrFihVcoxF5MnDgQKv63aSkJM2fP1+//fab7rzzTl155ZXZ7uvEZQ8mTZqU4+NsZnQAM2vWLFJnIBuEL4QveXH27Fl16dJFGzdu1M6dO/XOO++ocuXKTg/LeB6PR//85z8VFBSkChUqSEq/TsCtt96qmTNnasqUKWrfvr1CQkIcHi0AIC8iIiL0zjvvaPv27fr+++915ZVXqkmTJr6wHcgtm/pd08MXtzM6gMnrtw0BIHy5FOHLBSkpKRo3bpyOHDmigQMH6uOPP1bfvn31/vvvE8Lkwv9eZPficd+wYUN17dpVixYt0tatW9W2bVvOggEAywQGBuraa6+9bL8E5MSWfpfwxXl0iYCLEL6kI3xJt337di1fvlzt2rXTc889p+eff17bt29Xv379dOzYMaeHZ6WLF4cfO3as/Pz8NHfuXEkifAEAoASyod8lfDGD0WfALFiwIFf7RUdHF/FIAPMRvqTL62TkduXLl9cdd9yhBx54QBUqVFC/fv2UnJyssWPHql+/fvrXv/6lypUr+66rhcu7WAPh4eHq1KmTFi5cqMGDB+v66693eGQAAKC42dDvEr6YwegAZtCgQfJ4PJm+/u1/FwgEMCjpCF/S5Wcymjp1arb72OxioFK7dm2NHz9epUqV0vnz5xUWFqaBAwdKki+Eee+991S1alVJF76Cs1y5cgoKCnJy+FYICwvTiBEjtGzZMq1bt44ABgAA+JjU7xK+mMHoAOaLL77IdF9KSor27dunV199VeXKlVNMTIwDIwPMQfiSLr+TkdukpKQoLS1NAQEBvmuSlCpVSpLk7+8vSSpbtmyGEObWW2/V+++/rzNnzmjMmDEKCwvTq6++yhkxudClSxdFRETotdde08iRIxUQEMC/GwAAJZxp/a4t4ct//vOfHLfbzugApkuXLtluGzJkiFq3bq1t27apW7duxTgqwByEL+kKMhm5SWJiooYMGaL27dtr+PDhCgwMzPajRWXLltWAAQPk5+en0aNHq2fPnipfvrxWr16tb775hhAhlwIDA/Xggw+qQ4cOOR7PAFBSjRw5ksXl/1fQ/srNX8/rJib2uzbVh5sZHcDkJCgoSHfeeadmzpypv/71r04PByh2JjcH2bFtMrLN2bNn1b17d8XHx2vTpk0qV66coqOjsw1h0tLSFBoaqgEDBui///2vHn/8cZUvX17r169X8+bNHXoVdrn473rfffc5PRQAMJbT87lpi8vC7q9gFtv6XRPrw82s/rqGoKAg/frrr04PA3CEbc2BbZORbVJTUzVt2jT99ttviomJUUBAgMaMGaMFCxYoKSkpy+tpXfxve/z4ca1fv17lypXTV199pauvvtqJl2AlzhICgMtjcUn4UlLY1u+aWh9uZm0Ac/ToUb3++uuqU6eO00MBHGFTc2DbZGSj33//Xe+//76qVKmiiRMnat26dapcubLGjh2bYwjzxx9/KCYmRv/+97+1du1aNWnSxKFXAABwKxaXhC8lgW39ro314QZGV/SNN96Y5f3Hjx/Xjh07dO7cOc2ZM6eYRwWYwZbmwLbJyFZVqlTRyy+/rGbNmkm68NXTX3zxhbp166axY8dKku/jSJcKCAhQr169NGrUKDVt2rTYxw0AcD8Wl4Qvbmdbv2tjfbiF0VW9Y8eOTKd3ezweVahQQT169PBd9BAoiWxoDmybjGx38b9zamqq/Pz8VL169QwhjNfr1V133aXSpUvrwIEDCgwMVJUqVdS7d2+HR561iRMnWtccmFwfXLgRgGlYXKYjfLGbTf2ujfXhJkZXNtd3AfLHhOaA8MU5F79y2uv1Zghhxo8fL4/Ho7Zt2+rhhx9WUlKSli9f7vtqatPY1hzYVh8A4CQWl+kIX+xnS79rY324DdUNuIwJzYEJi8uSGr5c6uI1X6pXr66VK1eqS5cuGj9+vCpWrKgDBw5oxYoVxoYvkqxqDmyrDwBwEovLdHmdP2AmG/pdG+vDjUrWqwVczpTmwOnFZV4nIze7+DHOqlWravbs2Tp69KgOHz6sr776yviv+bOlObCtPgDASSwu0+Vn/oCZbOh3basPtzLqDJicDoTseDwe7dq1qwhGA9jFpObApvDlvffe05QpU7Ldxy12796tF198UWXKlNGXX35pxbcd2dAc2FYfAOAkFpfp8jt/wC4m9bs21YebGRXAVKlSJdNFdwFcnmnNgU3hy549e7Ldxy1SUlL02muvacmSJdqwYYMV4UtOTGkObKsPAHASi8t0BZk/YA/T+l2b6sPNjApgvvrqK6eHAFjHxObApvDljjvuyHY/tyhdurQeeOABDR8+XBEREU4Pp0BMag5sqw8AcAqLy3RFNX/ALCb2uzbVx9tvv53jc9qsZJ73A7iEbc2BbZORm9SvX5/wJQcloT4AwClOz+dunz9gFtv6XRPrw82MOgMmO0lJSVqzZo32798v6cJCokOHDrwRoUSzrTmwbTKCWUxsDmyrDwBwCotLwpeSwrZ+19T6cDPjz4BZtGiRatasqZtuukn333+/7r//fnXv3l21atXS4sWLi20cHo8n29vJkydz9RzfffedunfvrrCwMJUrV05RUVFau3ZtEY8cbmVTc2DbZASzmNoc2FYfAOAUFpeELyWBbf2ujfXhBka/uhUrVig6OlqVKlXSxIkT1axZM3m9Xm3btk2vvfaaoqOjVbFiRXXu3LlYxnPDDTfo3nvvzXR/mTJlLvvYDRs2qGPHjqpSpYomTpyowMBAzZo1S126dNGnn36qrl27FsWQ4WK2NAe2TUYFFdMjcvkAACAASURBVBMTU2TPXRLZ2BzYVh8AUNRYXBK+uJ0J87nb68MtjH6FU6dOVa1atbRhwwZVrFjRd/+tt96qkSNHqk2bNpo6dWqxBTD16tXL99XHH3roIfn5+Wnt2rWqVauWJOmuu+5S06ZNdf/992vXrl18AxTyxIbmwLbJCGaxsTmwrT4AwEksLtMRvtjN6fnc7fXhJkZ/BGnjxo0aNmxYhvDloooVK2ro0KHasGFDsY4pOTlZp0+fztNj9u/fr/Xr1+u2227zhS+SFBYWpmHDhmnPnj365ptvCnuoKMFMaA5MWFwSvtjNtubAtvoAACexuExH+GI/W/pdG+vDbYwOYFJSUhQSEpLt9pCQEKWkpBTbeN577z2FhIQoNDRUFStW1LBhw3TkyJHLPu7bb7+VJLVr1y7Ttov3XdwHKCgTmgMTFpeEL/azqTmwrT4AwEksLtPldf6AmWzod22sDzcyOoBp3LixFi5cmGXIkpKSooULF6px48bFMpbWrVvriSee0OLFizV//nz17dtXc+fOVZs2bXT48OEcH3vw4EFJyrJ4Lt7366+/Zvv4pKQkJSQkZLgBWTGlOXB6cZnXyQhmsqU5sK0+AMBJLC7T5Wf+gJls6Hdtqw+3MjqAGTFihL799lt16dJFS5cu1Y8//qgff/xRH3/8sbp06aINGzZoxIgRxTKWb7/9VqNHj1bfvn01cOBAvfHGG4qLi9OBAwc0adKkHB975swZScryTTUoKCjDPlmZNm2awsLCfLeaNWsW4JXArUxqDmwKXz755JNst8NZNjQHttUHADiJxWW6/M4fsItJ/a5N9eFmRr/qoUOHateuXXruuef01VdfZdr+2GOPaejQoQ6M7II777xTTzzxhJYuXZrjfhc/RpWUlJRp29mzZzPsk5Vx48Zp1KhRvp8TEhIIYZCBac2BTeHLxo0bs90H5jKhObCtPgDASSwu0xVk/oA9TOt3baoPNzM6gJGkZ599VkOGDNEHH3yg/fv3y+v1qn79+urTp48aNWrk9PBUp04drVu3Lsd9atSoISnrgymnjyddFBgYSOKNbJnYHNgUvvTq1Svb/WAmU5oD2+oDAJzC4jJdUc0fMIuJ/a5N9TF79uwcf7/NjAtg/vjjD5UpUybDfY0aNdLYsWMdGlH2vF6v9u7dq2rVquW4X+vWrSVJ8fHx+stf/pJhW3x8fIZ9gLywrTmwcTKCWUxqDmyrjylTpmS7DwAUJRPmczfPHzCLjf2uafXhZsZdAyY8PFzDhg3T119/7fRQfI4ePZrl/S+99JJ+/fXXDH9BP3z4sHbu3Jnhmi7169dXmzZttHjxYh04cMB3f0JCgmJjY1W/fn21bdu26F4AXMm25sDGyQhmMa05sK0+AMApTs/nbp4/YBYb+10T68PNjDsDpnr16pozZ47mzp2rq666SkOHDtVdd93laBI2bdo0LV++XD169FDt2rV19uxZrV69Wv/+97/VsGFDTZ482bfvuHHjNG/ePK1atUpRUVG++2fMmKGoqCjdcMMNeuihhxQQEKDXX39dhw8f1ieffCKPx1P8LwxWs6k5sHEygllMbA5sqw8AcAqLS8KXksDGfte2+nAD486A2blzp7788kvdc889OnTokEaPHq2aNWuqX79+Wrp0qSNfGdu5c2ddeeWVmj9/vv7617/q8ccf1/79+/X4449rw4YNORbXRdddd53Wrl2rq666SpMnT9aYMWNUoUIFLV++XDfeeGMxvAq4jS3NgY2TEcxiW3NgW30AQFFjcUn44nYmzOdurw+3MO4MGEmKjIxUZGSkZsyYoUWLFmnu3Ln68MMP9eGHH6pq1aoaPHiw7rnnHjVs2LBYxtOrV69cX6gzLi5OcXFxWW5r3bq1Pv/880IcGUoyG5oDGycjmMW25sC2+gAAJ7G4TEf4Yjen53O314ebGHcGzKVCQkI0ePBgrVmzRnv27NHYsWNVunRpPfPMM2rUqJE6duyoN9980+lhAo4wvTkwYXFJ+GI325oD2+oDAJzE4jId4Yv9bOp3basPtzE6gLlUvXr19PTTT+vnn3/Wp59+qptuuklffvmlhgwZ4vTQAKOY0ByYsLgkfLGfTc2BbfUBAE5icZkur/MHzGRLv2tbfbiRNQHMRfHx8Vq0aJHWrl0rSSXuPxiQE1OaA6cXl4Qv7mBLc2BbfQCAk1hcpsvP/AEz2dDv2lYfbmXkNWD+1+HDhzVv3jzNnTtXe/fuldfrVcuWLTV06FBFR0c7PTzACCY1BzaFL2vWrMlxO5xjQ3NgW30AgJNYXKbL7/wBu5jU79pUH25mbACTkpKiDz/8UHPmzNHnn3+u1NRUVahQQQ8++KCGDh2q5s2bOz1EwBimNQc2hS+rVq3KcR+YyYTmwLb6AAAnsbhMV5D5A/Ywrd+1qT7czLgAZuvWrZozZ44WLFig33//XZLUpUsXDR06VH379lVAQIDDIwTMYmJzYFP40qlTpxz3g3lMaQ5sqw8AcAqLy3RFNX/ALCb2uzbVx0svvZTjWG1mXABzzTXXSJJq1qypiRMn6p577lHt2rUdHhVgJtuaAxsnI5jFpObAtvqIiYnJdh8AKEomzOdunj9gFhv7XdPqw82MC2BuvfVWDRs2TN26dZPH43F6OICxbGsObJyMYBbTmgPb6gMAnOL0fO7m+QNmsbHfNbE+3My4AGbRokVODwGwgk3NgY2TEcxiYnNgW30AgFNYXBK+lAQ29ru21YcbWPc11AAusKU5sHEygllsaw5srA8AKEosLglf3M6U+dzN9eEWBDCApWxoDmycjGAW25oDG+sDAJzC4jId4YvdTJjP3VwfbkIAA1jK9ObAlMUl4Yu9bGsObKwPAHAKi8t0hC/2c3o+d3N9uA0BDOAyJjQHpiwuCV/sZlNzYGN9AIBTWFymy+v8ATPZ0u/aVh9uRAADuIgpzYEJi0vCF/vZ0hzYWB8A4BQWl+nyM3/ATDb0u7bVh1sRwAAuYVJz4PTiMq+TEcxkQ3NgY30AgFNYXKbL7/wBu5jU79pUH25GAAO4gGnNgU3hy0cffZTjPnCO6c2BjfUBAE5hcZmuIPMH7GFav2tTfbgZAQxgORObA5vCl1atWuW4H8xjSnNgW30AgFNYXKYrqvkDZjGx37WpPtyMAAawmG3NgamTEexhUnNgW30AgFNYXF5A+FIymNrv2lQfbkYAA1jKtubAxskIZjGtObCtPgDAKU7P526eP2AWG/tdE+vDzVh5AJayqTmwcTKCWUxsDmyrDwDu4fV6nR5CnrC4JHwpCWzsd22rDzdg9QFYypbmwMbJCGaxrTmwsT4AmC8pKcl3NpvH43F4NHnD4pLwxe1Mmc/dXB9ukf2/MgCj2dAc2DgZwSy2NQc21gcA850+fVo9evRQSEiIEhIS1Lt3b6eHVGhYXF5A+GI3E+ZzN9eHm7AKASxlenNgyuKS8MVetjUHNtYHAPMlJiaqTZs2KlWqlMaMGaM///nPGbbb9nGkS7G4vIDwxX5Oz+durg+34QwYwGVMaA5MWVwSvtjNpubAxvoAYD6v16sxY8aoYsWKio2NVe3ateXn56ekpCTfe51tH0e6iMXlBXmdP2AmW/pd2+rDjViN5MLu3bv1xBNPqG3btqpcubLKlSuna665Rk8//bT++OOPXD1HVFSUPB5PlrcPPvigiF8BSgpTmgMTFpeEL/azpTmwsT4A2CE1NVXbtm1Tp06dVLduXfn5+Wn58uW688471aJFC3Xr1k0fffSRjh8/7vRQ84TF5QX5mT9gJhv6Xdvqw604AyYX5syZo5dfflk9e/ZUdHS0AgICtGrVKk2YMEGLFi3S+vXrFRwcfNnnqVSpkqZPn57p/latWhXFsFHCmNQcOL24zOtkBDPZ0BzYWB8A7HHy5Ent27dPt956q6QL15mIjo5W586dVb16df3444/q37+/xo4dq4cfflhhYWEOj/jyWFxekN/5A3Yxqd+1qT7cjAAmF2699VaNHTtW5cuX99133333qWHDhnr66ac1Z84cPfDAA5d9njJlymjQoEFFOVSUUKY1BzaFL++++67efvvtHJ8TzjC9ObCxPgDYJSAgQIGBgdq8ebPOnz+vSZMmafTo0RozZozKlSunY8eOacSIEXr22WfVsWNHdezYUV6v19iPJbG4vKAg8wfsYVq/a1N9uBnn5OdCq1atMoQvF91+++2SpO+//z7Xz5WWlqaEhASlpaUV2vhQspnYHNgUvjRs2DDH54R5TGkObKsPAPYJDQ1VdHS04uLiNH36dIWFhalfv36+97LKlStrxowZqlKlimbPni3J3GvCsLi8oKjmD5jFxH7XpvpwMwKYAjh48KAkqUqVKrnev2zZsgoLC1OZMmV08803a+PGjZd9XFJSkhISEjLcAMm+5sDUyQj2MKk5sK0+ANhp2LBhql27tqZMmaLt27f77r/4x7zKlSurYsWKOnfunFNDvCwWlxcQvpQMpva7NtWHmxHA5FNqaqqefPJJlS5dWgMHDrzs/nXq1NHf/vY3xcbGasmSJXrssce0bt06RUZGauXKlTk+dtq0aQoLC/PdatasWVgvAxazrTmwcTKCWUxrDmyrDwB2ql27thYvXizpwvvVBx98oJSUFN9cd+zYMfn7+/veY0z8Wmqn53M3zx8wi439ron14WasPPLpoYce0vr16/XUU08pIiLisvvHxcVl+Llfv34aNGiQrr32Wt133305Xgh03LhxGjVqlO/nhIQEQhhY1RzYOBnBLCY2B7bVBwB7tWzZUqtXr9aNN96op556SomJierbt6/Onz+vuLg47d69W/PmzZNk5keQWFwSvpQENva7ttWHG3AGTD5MmDBBr7zyioYNG6bx48fn+3kiIiJ0++23a8+ePTle1TwwMFChoaEZboAtzYGNkxHMYltzYGp9ALBby5YtFR8frz59+ujll19Wp06dNGjQIH377bdasWKF0dc0Y3FJ+OJ2Nva7ttWHW7ACyaPJkyfr6aef1l133aXXX3+9wH9lqFOnjqQLp4+aPHHCPDY0BzZORjCLbc2BjfUBwB4RERF65513tH37dn3//fe68sor1aRJE4WHhzs9tHxjcXkB4YvdTJjP3VwfbsIqJA9iYmIUExOjQYMGae7cuYXS0F4886VatWoFfi6ULKY3B6YsLglf7GVbc2BjfbhZWlpaiX3tcLfAwEBde+21l33fsAGLywsIX+zn9Hzu5vpwG1YiufTkk09q8uTJGjhwoOLi4rItgMOHD+vUqVOqVauWQkJCJEknTpxQmTJlFBAQkGHfjRs3atGiRWratKnq1atX5K8BJYMJzYEpi0vCF7vZ1BzYWB9ukpycrL179+rIkSOqUaOGIiIiSsxrLw6EWSgKLC4vyOv8ATPZ0u/aVh9uxGokF2bOnKlJkyapVq1a6tatm955550M26tWrapu3bpJunDB3Hnz5mnVqlWKioqSdKHYhg8frttuu00NGjRQYGCgNm/erLi4OPn7+2v27NnF/ZLgUqY0ByYsLglf7GdLc2BjfbjJ6dOn1bNnT+3du1eHDh1ScHCwIiMjNWPGDNWvX1/+/v5OD9EqhFkoDiwuL8jP/BETE5PtPnCODf2ubfXhVqxIcmHDhg2SpF9++UWDBw/OtL1jx46+ACYrERER6tixo5YtW6ajR48qKSlJ1atX16BBgzR27Fiu/YJCYVJz4PTiMq+TEcxkQ3NgY324yZkzZxQZGanKlSvrmWeeUcOGDTVjxgwtXLhQvXv31pNPPqmbb745x2MD6QizUBxYXF6Q3/kD9jGl37WpPtyMACYX4uLiMn2NdF72bdy4sRYtWlT4AwP+P9OaA5vCl7feeouz0AxlenNgY324zcKFC3XmzBlNnz5dTZs2ValSpfTSSy8pPDxczz//vGJiYuTn56d+/fqpVKlSTg/XaIRZGXGWQdFgcXlBQeYP2MWkftem+nCzktOlAS5lYnNgU/hSpUqVHH8/zGNKc2BbfbjRjh07lJqaqubNm6tUqVI6f/68KlSooJiYGIWHh2vnzp0aM2aMDh48KEnyer0Oj9hcl4ZZAwYM0HXXXaeXXnpJf/3rX7Vnzx7FxMRo2bJlSk1NdXqosBSLywuKcv6AWUzrd22qDzcrWZ0a4DI2NgcmTkawh0nNgW314UZVq1bVkSNH9J///EeS5O/vr3PnzikoKEgREREaOXKkkpOT9eijj0qSPB6Pk8M1GmEWihKLywsIX0oOE/tdm+rDzQhgAEvZ2BzYNhnBLKY1B7bVhxv16dNHqampmjZtmrZt2yZJCgoK0g8//KAtW7YoKipKffr00datW5WYmOjwaM1GmIWi5PR87vb5A2axrd81sT7cjAAGsJRtzYFtkxHMYmJzYFt9uFHDhg21bNkyLVmyRNHR0Zo4caKeeOIJRUZG6uabb1bfvn1111136eeff9bBgwc5ayMHhFkoSiwuCV9KCtv6Xdvqww24CC9gKZuaA9smI5jFtubA1Ppwq86dOys+Pl4PP/ywXnnlFZUtW1b33XefpkyZIkn68ssvVb16ddWqVYuzNnJwMczq2rWrdu3apd69e8vj8ejFF19Ur1691LdvX9WoUUNvvPGGDh48qKuuuop/T+Qai0vCl5LAtn7XtvpwCwIYwFK2NAe2TUYwi23NgY314QZt27bVypUrdfLkSSUlJalevXqSpKNHj2r9+vVq0aIFZ7/kAmEWigqLS8IXtzNhPndzfbiJuzsywMVsaA5sm4xgFtuaAxvrw03KlCmjMmXK+H7+9ttv9cYbb2j58uX66quvFBIS4uDo7EGYheLE4vICwhf7OT2fu7k+3KZkdGVACWJKc2DC4pLwxW42NQc21oebbd++Xc8++6w2b96sNWvWqGnTpk4PySqEWSgOLC4vIHxxB1v6Xdvqw41KZmcGuJQpzYEJi0vCF/vZ0hzYWB9ud9VVV+mRRx5RzZo1Vbt2baeHYzXCLBQFFpcX5Gf+gJls6Hdtqw+3KrndGeAyJjUHTi8u8zoZwUw2NAc21kdJ4O/vr/bt2zs9DFcgzEJhY3F5QX7nD9jHlH7XpvpwM76GGnAB05oDm8KXefPm5ThOOMf05sDG+gDy6mKYRfiCwsDi8oKCzB+wi0n9rk314WYEMIDlTGwObApf+GiSfUxpDmyrDwBwEovLC4py/oBZTOt3baoPNyOAASxmY3Ng4mQEe5jUHNhWHwDgFBaXFxC+lBwm9rs21Yeb8acywFI2Nge2TUYwi2nNgW31MXv27Bx/f17ExMQU2nOVdJMmTXJ6CECRc3o+d/v8AbPY1u+aWB9uRgADWMq25sC2yQhmMbE5sK0+YKbswizbm2cn6oMwy1wsLglfSgrb+l0b68N2fAQJsJTTb36mLS4JX9zLxubAxPqAPdzePBdVfcBcLC4JX0oC2/pdG+vDDZjFAEvZ0hzYNhnBLDY2B7bVB8zi9ua5KOsD5mJxSfjidibM526vD7cggAEsZUNzYNtkBLPY2BzYVh8wi9ub56KuD9iHxWU6whe7OT2fu70+3IQABnAZU5oDExaXhC92s605sK0+YBa3N8/FUR+wC4vLdIQv9rOl37WxPtyGAAZwEVOaAxMWl4Qv9rOpObCtPmAWtzfPxVUfsAeLy3R5rQ+YyYZ+18b6cCMCGMAlTGoOnF5c5nUygplsaQ5sqw+Yxe3Nswn1AbOwuEyXn/qAmWzod22rD7cigAFcwLTmwKbwZd68eTm+JjjHhubAtvqAedzcPJtQHzALi8t0+a0P2MWkftem+nAzAhjAciY2BzaFL0lJSTm+LpjHlObAtvqAmdzaPJtQHzALi8t0BakP2MO0ftem+nAzApg8eOedd9SyZUsFBwerUqVKGjBggH7++edcP/67775T9+7dFRYWpnLlyikqKkpr164twhHD7UxtDmwKX+6+++4cXxvMYlJzYFt9wExubZ6drg+YhcVluqKqD5jFxH7XpvpwM6o4l15++WVFR0crODhY06dP1yOPPKIvvvhC7dq106FDhy77+A0bNuiGG27Qzp07NXHiRE2dOlW///67unTpouXLlxfDK4Db2Ngc2DYZwSymNQe21QfM5NbmmfAFl3J6Pnd7fcAstvW7JtaHmzF75cLvv/+ucePG6dprr9Xq1at9RdS9e3e1adNGTzzxhN54440cn+Ohhx6Sn5+f1q5dq1q1akmS7rrrLjVt2lT333+/du3aJY/HU+SvBe5hW3Ng22QEs5jYHNhWH7CL7c0z4QsuxeKS8KWksK3ftbE+bEc158KHH36oxMREPfTQQxmKqFWrVurQoYMWLVqk5OTkbB+/f/9+rV+/XrfddpsvfJGksLAwDRs2THv27NE333xTpK8B7uP0m59pi0vCF/eysTkwsT5gD7c3z4QvJQ+LS8KXksC2ftfG+nADKjoXvv32W0lSu3btMm1r166dTp8+rZ07d+b78ZfuA+SWLc2BbZMRzGJjc2BbfcAsbm+ei7I+YC4Wl4QvbmfCfO72+nAL/oyQCwcPHpSkLA/Mi/f9+uuvat68eYEen52kpKQM39Ry6tQpSVJCQkJuhm+Mc+fOOT0EV6lVq1a2/6Zer1eff/65Nm3apJtuuklNmjTJ8d9/3bp1+vLLL3XDDTfouuuuy3HfLVu26NNPP1WLFi3UpUuXHM/+2rdvn5YsWaL69eurZ8+eSklJUUpKSpb7Hjp0SAsXLlTlypV12223yev1ZjuO48ePa8GCBQoICFD//v3l7++f7b6JiYlasGCBkpOTFR0drbJly2batzBrieO88CQnJ+vdd9/VsWPH1L9/f1WqVCnbf9/U1FR98MEH2rdvn2655RbqI4v64Dg3X27ery6iPtJdrI/nnnsu2+fLK47x4lHY8/lFbq4P3svNtHDhQuP73YtsqA/b1rkXx+v1ei+/sxeX1blzZ68kb2pqaqZtsbGxXknexYsXZ/v4J5980ivJu2LFikzb9u3b55XkfeCBB7J9/KRJk7ySuHHjxo0bN27cuHHjxo0bN24G3g4cOHDZbIEzYHIhJCRE0oUzUYKDgzNsO3v2bIZ9Lvf4/5Wbx48bN06jRo3y/ZyWlqbjx4+rYsWKXLi3hEpISFDNmjV14MABhYaGOj0coNBxjKMk4DhHScBxDrfjGIfX69Xp06dVvXr1y+5LAJMLNWrUkHThY0INGzbMsC2njxdl9fj/lZvHBwYGZvpsYPny5XMxcrhdaGgob/RwNY5xlAQc5ygJOM7hdhzjJVtYWFiu9uPKTrnQunVrSVJ8fHymbfHx8SpbtqwaNWqU78dfug8AAAAAAHAfAphc6N27t0JCQjRjxowMF1TauHGj1q5dq9tvv10BAQGSpMOHD2vnzp06c+aMb7/69eurTZs2Wrx4sQ4cOOC7PyEhQbGxsapfv77atm1bfC8IAAAAAAAUq1KTJ0+e7PQgTBcSEqKyZctq7ty5Wrlypc6fP6/PPvtMDz74oEJDQ/XOO+/4TjcbOXKk/vKXv6hbt26qU6eO7zmaN2+uuXPnatGiRUpLS9N3332n+++/Xz/++KMWLFigBg0aOPTqYKtSpUopKioqx6+5A2zGMY6SgOMcJQHHOdyOYxy55fF6c/NdSZCkt99+W88995x++OEHhYSEqFu3bpo2bZrq1q3r22fw4MGaN2+eVq1apaioqAyP37Bhgx5//HGtX79eqampatWqlWJiYjLtBwAAAAAA3IUABgAAAAAAoIhxDRgAAAAAAIAiRgADAAAAAABQxAhgAAAAAAAAihgBDOCA1atXy+Px5Hi7yOPx5Hih5qioqAz7X2rfvn0aOXKkGjdurLJlyyooKEgNGjTQkCFDtG7dusJ+WSiBLj2WX3vttSz38Xg86t69u+/ni8dsdresvpzv1KlTmjp1qq677jpdccUVCggIUPXq1dW7d28tXLhQaWlpmR6zefNmDR06VPXr11dwcLBCQkLUpEkTPfjgg/r+++8L7d8AJcNvv/2m0aNH609/+pPKlSunsLAwNWzYUP3799e//vUv334c33Abk9/ngcJk2vs83InvyQIcdMcdd6hHjx5F8txvvfWW/vKXv6h06dIaMGCAWrRooYCAAO3fv1/vv/++5s6dq3Xr1qldu3ZF8vtR8sTExOjOO+9UmTJlLruvv7+/5syZk+W25s2bZ/h506ZN6tmzpw4fPqwePXqof//+Kl++vA4fPqwvvvhCAwYM0P79+zV+/HjfY5555hmNHz9eFStWVHR0tJo0aSKPx6OdO3dqyZIlevXVV/Xzzz/ryiuvLNiLRolw4MABtW7dWqdPn9bAgQM1YsQISdLevXu1dOlSJSYmql+/fr79Ob7hVia9zwOFybT3ebiYF0CxW7VqlVeSd9q0aZfdV5K3Y8eO2W7v2LGj939LedWqVd5SpUp5mzRp4j1w4ECmx6Smpnpff/117/r16/M8duBSF4/lVq1aeSV5p0yZkmkfSd4///nPvp87duzoDQwMzNXzHz161BseHu4tV66cd82aNVnus3btWm9sbKzv57feessryduhQwfviRMnMu2fnJzsnTJliveXX37J1RiAkSNHeiV5P/rooyy3X/o+y/ENtzHxfR4obCa9z8PdOAMGcKG//e1vSktL07vvvpvlX0D9/Px07733OjAyuNUtt9wiPz8//eMf/9B9992nSpUqFcrz/uMf/9Dhw4c1c+ZMdejQIct9brjhBt1www2SpOTkZI0ZM0ZlypTR4sWLVb58+Uz7+/v7a8KECYUyPpQMu3fvliR16tQpy+35PdOE4xs2MeV9HigKprzPw/24BgzgoDNnzui///1vpltCQkK+n/Pnn3/Wxo0bFRkZqT/96U+FOFogZ3//+9+VkJCgp556Klf7Z3Xs//e//1VKSopvn/fee08BAQEaPHhwrp4zPj5ehw4dUt++fVWlSpX8vAwgk3r16kmSZs+eLa/Xm6vHcHzDwwghVgAAIABJREFUjUx4nweKginv83A/AhjAQVOmTFHlypUz3S79jGlebd26VZLUokWLwhomkCtRUVHq3r27Xn31Vf3000857puUlJTlsV+5cmWtX79eknT69Gn99NNPioiIUEhISK7GcPHioxz/KEyPPfaYQkNDNWrUKNWuXVsDBw7UCy+8oO+++y7L/Tm+4VYmvM8DRcGU93m4Hx9BAhw0dOhQ9e/fP9P9FStWzPdzXjx7JjQ0NN/PAeTX3//+d7Vo0UITJkzQ/Pnzs93P399fn3zySZbbmjVrJil/xzLHP4pCvXr1tGXLFv3jH//Qhx9+qAULFmjBggWSLhyvc+fOVcuWLX37c3zDzZx+nweKginv83A/AhjAQQ0aNFDXrl0L9TkvvskX5GNMQH41b95c0dHRevvtt/XYY4/pmmuuyXI/Pz+/yx77+TmWOf5RVOrUqaOZM2dq5syZOnz4sL7++mvNmzdPH330kXr06KHt27erQoUKkji+4W5Ov88DRcWE93m4Hx9BAgwXFBSks2fPZrv9zJkzCg4O9v18MXXftGlTkY8NyMpTTz2lgIAAjR07tkDPU65cOdWuXVu7du3KsQYuxfGP4hAeHq5+/frpww8/1IABA3TkyJFs/xKaHY5v2MzJ93mgODj1Pg/3I4ABDFe3bl3t3r1bqampmbalpKRo9+7dqlu3ru++OnXqqGXLllq3bp127NhRnEMFJEm1a9fWiBEj9Nlnn2nlypUFeq5bb71VycnJmjdvXq72b9eunapXr64PPvhAx44dK9DvBnLj+uuvlyQdPHgwz4/l+IatnHyfB4pbcb7Pw/0IYADD9e7dWydPnlRsbGymbbGxsTp16pR69+6d4f5nn31WHo9Hd9xxhw4dOpTpcWlpaXr99df1zTffFNm4UbJNmDBBoaGhBf7r6N/+9jdVrVpVY8aM0bp167LcZ+3atZozZ44kKSAgQFOnTlViYqLuuOOOLE/7TU5O1pQpU3TgwIECjQ0lx6pVq7L862VaWpr+/e9/S5KaNGmS5+fl+IbNnHqfB4qCKe/zcD+uAQM4aPPmzdlewK5Xr16+xuaDDz7Q8OHDtXLlSl8K//XXX+vdd99V48aNNWbMmAyP7dy5s2JjYzV8+HBFRERowIABatGihQICArRv3z69//772rlzp+Lj44v8NaJkqlixokaPHq0JEyZkuT0tLS3bY79OnTpq3769JKlq1ar6+OOP1atXL3Xo0EG9evVSx44dFRYWpiNHjujzzz/X6tWrNW3aNN/j7777bv3666+aOHGiGjRooOjoaF/TtHPnTi1ZskS//vqrhgwZUsivGm713HPPad26derRo4datmzpO/6WLFmi7777Tp06ddL//d//+fbn+EZJ4OT7PFDYTHqfh8t5ARS7VatWeSXlePvhhx98+588edI7duxYb6NGjbxBQUHeoKAgb6NGjbxjx471njx5Mtvfs3v3bu8DDzzgjYiI8IaEhHgDAwO99evX9w4ZMsS7fv364nipcLmLx/K0adMybfvjjz+84eHhXkneP//5z777O3bsmOOxf8cdd2R6ruPHj3unTJnibd26tTc0NNRbunRpb3h4uLd3797exYsXe1NTUzM95rvvvvMOHjzYW7duXW9gYKA3KCjI27hxY+/IkSO927dvL9x/CLja119/7R01apS3VatW3ipVqnhLly7tDQsL87Zt29b73HPPec+dO+fbl+MbbmPy+zxQWEx8n4c7ebxer7fo4h0AAAAAAABwDRgAAAAAAIAiRgADAAAAAABQxAhgAAAAAAAAihgBDAAAAAAAQBEjgAEAAAAAAChiBDAAAAAAAABFjAAGAAAAAACgiBHAAAAAAAAAFDECGAAAAAAAgCJGAAMAAAAAAFDECGAAAAAAAACKGAEMAAAAAABAEStd2E+4f/9+bdq0SceOHdPx48cVEBCgChUqKCIiQtdcc43KlClT2L8SAAAAAADAaIUSwPz++++aPn265s+fr59//jnb/QICAtSuXTvdeeedGjBggIKDgwvj1wMAAAAAABjN4/V6vQV5gtjYWD3yyCNKTEzM0+NWrVqlqKiogvxqAAAAAAAAKxToDJhHHnlEL774Yqb7K1SooGuuuUaVK1dWamqqjh07pq1bt+rEiRMF+XUAAAAAAABWyncAM3369Ezhy/XXX6+nnnpKUVFR8vPLfH3fLVu2aNGiRZo9e3Z+fy0AAAAAAIB18vURpB07dujqq69WSkqK774HHnhAM2bMyDJ4+V9nz55VcnKywsLC8vqrAQAAAAAArJOvM2CefvrpDOHLTTfdpJdeekkejydXjw8ODuYCvAAAAAAAoMTI8xkwx48fV5UqVZSamipJ8vPz0+7du1W/fv0iGSAAAAAAAIDtLv95of+xZs0aX/giSd26dSN8AQAAAAAAyEGeA5j4+PgMP/NV0gAAAAAAADnLcwBz+PDhDD83bdq00AYDAAAAAADgRnkOYH7//fcMP19xxRWFNhgAAAAAAAA3ynMA879y+81HAAAAAAAAJVWeA5hKlSpl+Pn48eOFNhgAAAAAAAA3ynMAEx4enuHnHTt2FNpgAAAAAAAA3CjPAUxkZGSGn1evXl1YYwEAAAAAAHAlj9fr9eblASdPnlTlypWVkpIiSfLz89PevXtVt27dIhkgAAAAAACA7fJ8Bkz58uU1cOBA389paWl66KGHCnVQAAAAAAAAbpKvb0EaN26c/P39fT9//PHHeuSRR5SWlparx589e1anTp3Kz68GAAAAAACwTr4CmIiICD3//PMZ7nvxxRfVsWNHrVq1KtsgZsuWLXr88cdVu3Ztbdq0KT+/GgAAAAAAwDp5vgbMpUaNGqXp06dnur9ixYpq0aKFKlWqpNTUVB07dkxbt27N8JXVq1atUlRUVH5/NQAAAAAAgDUKFMBI0qxZs/TXv/5VZ86cydPjCGAAAAAAAEBJka+PIF3q3nvv1Y8//qhHH31U4eHhOe4bGBiobt266a233tL1119f0F8NAAAAAABghQKfAfO/tm3bpm3btunYsWM6deqUgoODValSJV111VW65pprFBwcXJi/DgAAAAAAwHiFHsAAAAAAAAAgowJ/BAkAAAAAAAA5I4ABAAAAAAAoYgQwAAAAAAAARYwABgAAAAAAoIgRwAAAAAAAABQxAhgAAAAAAIAiRgADAAAAAABQxAhgAAAAAAAAihgBDAAAAAAAQBEjgAEAAAAAAChiBDAAAAAAAABFjAAGPnXq1NELL7zg9DAAAAAAAHAdAphCMHjwYPXp08f3/z0ejzwej0qXLq1atWppxIgROnHiRJaPnTp1qkqVKqVnnnkm07bVq1f7nuvS286dO337xMXFZbnPuXPniubFAgAAAACAPCvt9ADcqHv37po7d65SUlK0Y8cODRkyRCdPntQ777yTad+5c+dq9OjRmjNnjsaOHZvl8+3atUuhoaG+nytXrpxhe2hoqHbt2pXhvqCgoEJ4JQAAAAAAoDBwBkwRCAwMVLVq1XTllVfqxhtv1B133KHPP/88035r1qzR2bNn9eSTT+qPP/7Q2rVrs3y+KlWqqFq1ar5bqVKlMmz3eDwZtlerVu2yY/ztt9/Us2dPBQcHq27dunr77bcz7fPLL7+od+/eKlu2rEJDQ3X77bfr6NGjufxXAAAAAAAAFxHAFLH9+/dr2bJl8vf3z7QtNjZWAwYMkL+/vwYMGKDY2Ngsn6NFixYKDw9Xly5dtGrVqkzbExMTVbt2bV155ZXq0aOHNm3adNlxDR48WD/99JNWrlyp9957T6+88op+++0333av16s+ffro+PHjWrNmjb744gvt27dPd9xxRx5ePQAAAAAAkAz/CFKrVq105MiRYv+91apV08aNG/P9+I8//lhly5ZVamqq71oszz//fIZ9EhIStGTJEsXHx0uSBg0apMjISL300ku+jxuFh4dr1qxZatmypZKSkvTWW2+pS5cuWr16tTp06CBJatSokeLi4tSsWTMlJCToxRdfVGRkpLZs2aKGDRtmOb7du3fr008/1fr163XddddJuhAGNW7c2LfP8uXLtXXrVv3444+qWbOmJOmtt95S06ZNtWHDBrVu3Trf/z4AAAAAAJQ0RgcwR44c0cGDB50eRp516tRJr776qs6cOaM33nhDu3fv1siRIzPss2DBAtWrV09XX321JOmaa65RvXr1tHDhQt17772SpIiICEVERPgec/311+vAgQP65z//6Qtg2rZtq7Zt2/r2iYyM1LXXXquXXnpJM2bM0Ntvv63hw4f7tn/66ac6fvy4SpcurVatWvnub9SokcqXL+/7+YcfflDNmjV94YskNWnSROXLl9cPP/xAAAMAAAAAQB4YHcDk5lomJv7eMmXKqEGDBpKkGTNmqFOnToqJidGUKVN8+8yZM0fbt29X6dLp/wnS0tIUGxvrC2Cy0rZtW82fPz/b7X5+fmrdurX27NkjSerVq5fvLBdJqlGjhj777DNJF64dkx2v15vl9uzuBwAAAAAA2TM6gCnIx4BMMmnSJN10000aMWKEqlevru+//14bN27U6tWrVaFCBd9+J0+eVIcOHbRt2zb96U9/yvK5Nm3apPDw8Gx/l9fr1ebNm9WsWTNJUrly5VSuXLkM+zRu3FgpKSnauHGj2rRpI+nCNy2dPHnSt0+TJk30yy+/6MCBA76zYHbs2KFTp05l+KgSAAAAAAC4PKMDGLeIiopS06ZNNXXqVL388suKjY1VmzZtfB8jutT111+v2NhYTZ8+XS+88ILq1Kmjpk2bKjk5WfPnz9eSJUu0ZMkS3/4xMTFq27atGjZsqISEBM2YMUObN2/WzJkzsx1PRESEunfvrr/85S+aNWuWSpcurUceeUTBwcG+fbp27armzZtr4MCBeuGFF5SSkqL7779fHTt2zPDRJQAAAAAAcHl8C1IhSEtLy/BRoqyMGjVKs2fP1s8//6z58+frlltuyXK/W265RfPnz1dycrKSk5P12GOPqXnz5rrhhhv01VdfaenSperXr59v/5MnT+ree+9V48aNdeONN+rgwYNau3at78yW7MydO1c1a9ZUx44d1a9fP917772qUqWKb7vH49EHH3ygK664Qh06dFDXrl1Vr149vfvuu3n4lwEAAAAAAJLk8Xq9XqcHYbvu3burQYMGevnll50eCgAAAAAAMBBnwBTAiRMntHTpUq1evVpdu3Z1ejgAAAAAAMBQXAOmAIYMGaINGzbo0UcfVe/evZ0eDgAAAAAAMBQfQQIAAAAAAChifAQJAAAAAACgiBHAAAAAAAAAFDECGAAAAAAAgCJGAAMAAAAAAFDECGAAAAAAAACKGAEMAAAAAABAESOAKSRHjhzRyJEjVa9ePQUGBqpmzZrq2bOnVqxY4dsnPj5eN998s6644goFBQWpWbNmeu6555SamprhuTwej+9WtmxZXX311YqLi8uwz+rVqzPsd+ntyJEjxfGSAQAAAABALpV2egBu8NNPPykyMlLly5fXs88+q+bNm+v8+fP67LPP9MADD2jnzp16//33dfvtt+uee+7RqlWrVL58eS1fvlyjR4/W+vXrtWjRInk8Ht9zzp07V927d9cff/yhd999V/fc8//Yu++4pq7/f+CvsFERGcoSEUVciFr3qIoo4ixaW9fH0botdc+6qXVVUatVq9Y9aF2luBdqq6KiOIo4wYUgCgKCjEDevz/4cb5EhoyEJOT9fDzyeOSuc98Hzs1Nzj3jG9jY2KBLly5y537w4AEqVqwot65KlSqlkm/GGGOMMcYYY4wVjoSISNVBaLpu3brhzp07ePDgAcqXLy+3LT4+Hvr6+nBwcED79u1x8OBBue0BAQHo1asX/Pz80K9fPwBZLWAOHz4MLy8vsZ+FhQWGDRuGlStXAshqAePm5oZ3796hUqVKSs4hY4wxxhhjjDHGSoK7IJVQXFwcTpw4ge+++y5X5QsAVKpUCadOnUJsbCymTp2aa3vPnj3h7OyMffv25Zl+ZmYm/vzzT8TFxUFfX1/h8TPGGGOMMcYYY0z5uAtSCT1+/BhEhDp16uS7z8OHDwEAdevWzXN7nTp1xD7ZBgwYAF1dXaSmpiIzMxPm5uYYMWJErmOrVq0qt2xnZ4cHDx4UNRuMMcYYY4wxxhhTIrWvgPH19YWvr+8n9/vss8/w999/y63r1asXbt68+cljJ0+ejMmTJxcrvuweXDnHb/nUvnmt//j4VatWoVOnTnjx4gUmT56MSZMmwcnJKdex//zzD0xMTMSynp7a/0sZY4wxxhhjjDGto/a/1hMTExEZGfnJ/ezt7XOte/PmTaGOTUxMLFZsAFCrVi1IJBKEhYXJjdmSk7OzMwAgLCwMrVu3zrX9/v37qFevntw6a2trODk5wcnJCfv370fjxo3RtGnTXPs5OjryGDCMMcYYY4wxxpiaU/sKmIoVK8LOzu6T+1WuXDnPdYU59uNZhIrC3NwcXbp0wa+//orx48fnOQivh4cHzM3NsXLlylwVMH///TcePXqEH3/8Md9zODk54csvv8SsWbPg7+9f7FgZY4wxxhhjjDGmGjwLkgJERESgdevWMDc3h4+PD1xdXZGRkYHTp09jw4YNCAsLw4EDB9C/f398++238Pb2RsWKFXH27FlMmzYN7u7uctNQ5zUL0t27d9GwYUNcu3YNTZs2FbMg5TUNtYWFBQ/YyxhjjDHGGGOMqRGugFGQqKgo/PTTTzhy5AiioqJQuXJlNGnSBJMmTUKHDh0AZI3XsnjxYly5cgUpKSlwcnLCt99+i4kTJ0JXV1eklVcFDAB4eHhAT08Px44dExUwebly5QpatmyptLwyxhhjjDHGGGOsaLgChjHGGGOMMcYYY0zJdFQdAGOMMcYYY4wxxlhZxxUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKxhUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKxhUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKxhUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKxhUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMEztbd++HRKJJN/X+fPnAQASiQTe3t55pnHgwAG5fXMKCAhAz549YWVlBQMDA5ibm8Pd3R179uyBVCpVYs4YU47sa8bIyAjPnj3Ltb1Dhw5wcXERy9WrV8/3+urQoUOu4+/cuYNvvvkGjo6OMDIyQoUKFfDZZ59h+fLliIuLk9tXJpNh165d6NSpEywtLaGvr48qVaqgR48eCAgIgEwmU3j+GVOUq1evonfv3qhWrRoMDQ1hZWWFVq1aYcqUKWKfDh065Hv9VK9ePVea4eHh8Pb2hrOzM4yNjVGuXDnUr18fc+bMQWRkZK79+R7Fyhp1ukcxpunU4T7FikZP1QEwVljbtm1DnTp1cq2vV69esdIjInz77bfYvn07unXrBl9fX9jb2yMhIQGBgYEYN24c3r59iwkTJpQ0dMZUIi0tDXPmzMGuXbs+uW+bNm2wYsWKXOsrVqwot7x582aMGzcOtWvXxrRp01CvXj1IpVIEBwdj48aNuHLlCg4fPgwASE1NhZeXF06dOoX+/ftjw4YNsLa2xps3b3DixAl89dVX+OOPP/DFF18oJsOMKdDRo0fRq1cvdOjQAcuXL4eNjQ2ioqIQHBwMPz8/rFy5Uuxbo0YN7NmzJ1cahoaGcstHjhxB//79YWlpCW9vbzRu3BgSiQR3797F1q1bcfToUYSEhADgexQr+1R9j2JM06n6PsWKiRhTc9u2bSMAdP369QL3A0Dfffddntv2799PACgwMFCsW7ZsGQGghQsX5nlMVFQU/fPPP8WOmzFVyb5mPD09SUdHh27duiW3vX379lS/fn2x7ODgQN27d/9kupcvXyZdXV3y9PSk1NTUXNvT0tLI399fLI8dO5YA0I4dO/JM7+HDh3T79u3CZouxUtWuXTuqWbMmSaXSXNsyMzPF+4+vp/yEh4dT+fLlqXHjxhQfH59ru0wmo4MHD4plvkexskpd7lGMaTpV36dY8XAXJKaVpFIpli1bhjp16mDu3Ll57mNtbY22bduWcmSMKc706dNhYWGBGTNmKCS9xYsXQyKRYNOmTbmemACAgYEBevXqBQCIjo7Gli1b0KVLFwwZMiTP9GrVqgVXV1eFxMaYosXGxsLS0hJ6erkbC+voFP3rk6+vL5KTk7F+/XqYmprm2i6RSNCnTx8AfI9i2kGV9yjGygJV3qdY8XEFDNMYmZmZyMjIkHtlZmYWK63g4GDExcXhiy++gEQiUXCkjKkHExMTzJkzBydPnsS5c+cK3JeIcl1fGRkZICIAWdffuXPn0KRJE9jb23/y3IGBgZBKpfDy8lJIXhgrba1atcLVq1cxfvx4XL169ZPjreR1/eQc4+jUqVOwsrJCy5YtP3luvkcxbaDKexRjZYEq71Os+LgChmmMli1bQl9fX+6V1xOOwnj+/DkAwNHRUZEhMqZ2xowZgxo1amDGjBnii2pejh07luv60tfXx08//QQAePv2LT58+FDoa4avMabpli5dirZt22Lt2rVo2bIlypcvjzZt2mDp0qVISkqS2zc0NDTP62fUqFFin+fPn/P1w9hHVHWPYqwsUOV9ihUfD8LLNMbOnTtRt25duXX8ZJCxghkYGGDRokUYOHAg/vzzT/Tr1y/P/dq2bYtVq1blWm9nZ6fsEBlTSxYWFvjnn38QHByMs2fPIjg4GOfPn8esWbPw22+/4fr167C0tAQA1KxZE35+frnSqFy5cmmHzZhG4XsUY8XH9ynNxBUwTGPUrVsXTZs2zXe7rq5uvl2SMjIyAAD6+voAgGrVqgEAIiIiFBwlY+qnf//+WLFiBWbPnp1v311TU9MCry9LS0uUK1eu0NcMX2OsrGjatKm4NqRSKWbMmIFVq1Zh+fLlWL58OQDAyMiowOsHyLom+PphLDdV3KMYK0tUcZ9ixcddkFiZYWVlle/c9NnrraysAGR9UJmbm8Pf37/AJq+MlQUSiQTLli3DkydPsGnTpmKloaurC3d3d9y4cQMvX7785P5ubm7Q19fHX3/9VazzMaaO9PX1MX/+fADAf//9V6Rju3TpgtevXyMoKOiT+/I9imkTVdyjGCurSus+xYqPK2BYmdGpUycEBgbizZs3cuuJCPv370f16tXh5OQEIOvDacaMGbh//z5+/PHHPNOLiYnBpUuXlB43Y6WhU6dO6Ny5M3x8fHL1Cy6sWbNmgYgwcuRIpKen59oulUoREBAAIGuGlhEjRuDkyZPYuXNnnuk9efIEd+7cKVYsjClbVFRUnuvDwsIAALa2tkVKb9KkSShfvjzGjRuHhISEXNuJCIcPHwbA9yimfUr7HsVYWaDK+xQrPu6CxDTGf//9J7oS5VSzZk1UrlwZ8+bNQ0BAAFq0aIGZM2eiVq1aiI6OxubNm3H9+nX8+eefcsdNmzYNYWFhmD9/Pq5du4aBAwfC3t4eCQkJuHjxIjZt2oSFCxeiTZs2pZVFxpRq2bJlaNKkCWJiYlC/fn25bfHx8Xk+8TA0NETjxo0BZI22v2HDBowbNw5NmjTB2LFjUb9+fUilUoSEhGDTpk1wcXFBz549AWRNZxgeHo5hw4bh5MmT6N27N6ysrPD27VucPn0a27Ztg5+fH09FzdRSly5dULVqVfTs2RN16tSBTCbDrVu3sHLlSlSoUAETJkwQ+6akpOT7xDB7NglHR0f4+fmhX79+aNSoEby9vcW1de/ePWzduhVEhN69ewPgexTTPqV9j2JM06n6PsWKiRhTc9u2bSMA+b42b94s9n306BH973//IxsbG9LT06NKlSqRh4cHnT17Nt/0/f39qXv37lS5cmXS09MjMzMzcnNzo40bN1JaWlppZJExhcq+Zq5fv55r28CBAwkA1a9fX6xzcHDI9/qys7PLlcatW7do6NChVK1aNTIwMKDy5ctT48aNad68eRQTEyO3b0ZGBu3YsYM6duxI5ubmpKenR5UrV6auXbvS3r17KTMzU/F/AMYU4I8//qCBAwdSrVq1qEKFCqSvr0/VqlWjwYMH071798R+7du3L/AeJZVK5dJ98uQJjRs3jpycnMjQ0JCMjY2pXr16NHnyZIqIiMgVB9+jWFmjTvcoxjSZutynWNFIiLhzMWOMMcYYY4wxxpgy8RgwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKxhUwjDHGGGOMMcYYY0rGFTCMMcYYY4wxxhhjSsYVMIwxxhhjjDHGGGNKpqfqAFjRyWQyvHr1CiYmJpBIJKoOh5URRIT379/D1tYWOjplv26WryOmDHwdMVZyfB0xVnJ8HTFWcsq4jrgCRgO9evUK9vb2qg6DlVEvXrxA1apVVR2G0vF1xJSJryPGSo6vI8ZKjq8jxkpOkdcRV8BoIBMTEwBZBaFixYoqjoaVFYmJibC3txflS5UuXryIn3/+GTdu3EBUVBQOHz4MLy8vsZ2IsHDhQmzatAnv3r1DixYt8Ouvv6J+/fqFPgdfR0wZ1Ok6Kg18HTFl4OuIsZLj64ixklPGdcQVMBoou1ldxYoV+QOGKZw6NNtMTk5Gw4YN8c033+DLL7/MtX358uXw9fXF9u3b4ezsjEWLFqFz58548OBBoT8g+TpiyqQO11Fp4OuIKRNfR4yVHF9HjJWcIq8jroBhjKmdrl27omvXrnluIyKsXr0as2fPRp8+fQAAO3bsgJWVFfbu3YvRo0eXZqiMMcYYY4wxVihlf0QmxliZEhERgejoaHh4eIh1hoaGaN++PS5fvpzvcWlpaUhMTJR7McYYY4wxxlhp4QorETzBAAAgAElEQVQYVibExsYiLS1N1WGwUhAdHQ0AsLKykltvZWUltuVlyZIlMDU1FS8eqK3kMjMzuSKLMQ2QlpaG9PR0VYfBWKG9efMGERERePXqFWJjY5GUlASpVAoiUnVojDFWIlwBwzRaTEwM+vfvj8qVK6NKlSoYNWoULl++zDdoLfBxX0wiKrB/5qxZs5CQkCBeL168UHaIZVpiYiJcXV1RuXJl/Pbbb6oOhzGWjwsXLqBatWqoVq0aLly4oOpwGMvXu3fvsGnTJnz++eeoUqUKatSoATs7O1haWsLExAQGBgbQ1dWFsbExKlWqBCsrK1SrVg21atWCi4sLevTogRs3bqg6G6yM4d8UikNEOHnyJA4fPozU1FRVh6MyPAYM02gmJia4ePEiiAiJiYnYvHkzNm/eDGdnZwwbNgyDBw/Wiqn3tIm1tTWArJYwNjY2Yn1MTEyuVjE5GRoawtDQUOnxaYsNGzbg3r17AIAxY8bAwMAA33zzjYqjYozldP36dfTo0QNJSUkAgO7du+PkyZNo06aNiiNjLEt6ejpOnDiBnTt3IiAg4JMttYgIqampef54Cw0NxZkzZ7B+/Xp8++23ygqZaZkhQ4bAxsYGs2bNgpmZmarD0Whnz56Fp6cnAMDMzAyDBg3CiBEj0LBhQxVHVrq4BQzTKDExMXLLxsbGmDlzJiwtLVGhQgWx/uHDh/jhhx/g4OAAT09P+Pn5ISUlpbTDZUrg6OgIa2trnD59WqxLT0/HhQsX0Lp1axVGpj1SUlLg6+srt2748OHYt2+fiiJijH0sNDQUnp6eovIFyJphrmvXrggKClJhZEzbERGuXbsGb29v2Nra4osvvsDBgwflKl/q1auH/v37o3fv3ujWrRvc3d3Rtm1bNGvWDK6urqhduzaqV68Oa2trmJmZwcjICEBWd7vhw4dj9OjR3DVdTfTq1QvVqlWDkZERbGxsMHjwYLx69Upun+fPn6Nnz54oX748LC0tMX78eLXoNhkUFITdu3fj559/hpOTE1atWsXlqgROnTol3r979w7r1q1Do0aN0KxZM2zcuBEJCQkqjK4UEdM4CQkJBIASEhJUHUqpCQsLo4EDB5KhoSGFh4fLbUtNTaWkpCRKSkqiHTt2kJubGwHI9QoNDVVR9JpBncrV+/fvKSQkhEJCQggA+fr6UkhICD179oyIiJYuXUqmpqZ06NAhunv3Lg0YMIBsbGwoMTGx0OdQp/xqmkuXLlH58uUJAFWuXFlcY7q6unTo0CFVh6dS2lautC2/muLJkydkY2Mjrs327duTh4eHWDY1NaXr16+rOsx8aVu50pb8RkRE0I8//kjOzs55fk+rUqUKTZw4kW7cuEEymaxIaaemptLYsWPl0mvWrBk9f/5cSblRf+pSrnx9fenKlSv09OlTunTpErVq1YpatWoltmdkZJCLiwu5ubnRzZs36fTp02Rra0ve3t5FOo+i8uvr60ubNm2iu3fv0ubNm8nQ0FCuXDk6OtK+ffsoMzOzROfRRjl/oxkZGeX6DDA2NqYhQ4bQxYsXi/wZoCzKuI64AkYDqcsHamm4f/8+DRo0iHR0dMTFOWLEiE8eFx4eTgsWLKDq1asTAGrevHmufa5fv05paWnKCFsjqVO5CgwMzPPL2dChQ4mISCaT0fz588na2poMDQ2pXbt2dPfu3SKdQ53yq4liY2NpwYIFFBISQqNGjRL/I319fTp+/Liqw1MZbStX2pZfTRAZGUmOjo5yP0ITExPpw4cP1LFjR7HezMyMQkJCVB1unrStXJWl/EqlUnrx4gUFBQXRgQMHaPXq1TRt2jT6/PPP87yvGxkZUf/+/eno0aMklUpLfP7t27fL/bCztLSkM2fOKCBnmkddy5W/vz9JJBJKT08nIqJjx46Rjo4ORUZGin327dtHhoaGRYpdEfnNzMykSpUqiQpBmUxGz549oyFDhpBEIpEru02bNqXAwMBin0vbyGQyMjU1JQBka2tL7969o19//ZU+++yzPD8bnJ2dadmyZRQdHa3SuLkChhGR+n6gKtKDBw/of//7n1zFS/aNdOXKlYVOJzMzkwIDA+ns2bNy62UyGdWuXZt8fHwUHbrG0oZylZO25VeZMjMzafDgweI6/eyzz7T2yZC2lStty6+6e/v2LdWrV09ci/Xq1aO3b9+K7UlJSdSuXTux3cLCosiV16VB28qVpuQ3PT2dIiIi6MKFC7Rnzx5avnw5jR8/nvr06UMtWrQgOzu7XN/b8nt16NCBfv/9d4qPj1d4nDdv3pSrhNTR0aGlS5eqzRP10qKO5So2Npa+/vpratOmjVg3d+5ccnV1ldsvLi6OANC5c+fyTSs1NZUSEhLE68WLFyXO771790S5+eKLL+S2hYSEUOfOnXOV5R49etC9e/eKfU5t8ejRI/E3+/zzz+W23bx5k7777jtRQZPzpaenR71796bHjx+rJG6ugGFEpJ4fqIo0b968XDdwCwsLWrJkCb1//77E6aelpdHu3bsJADVo0EABEZcNZb1cfUzb8qtsUqmU+vbtSw0bNqSYmBhVh6My2lautC2/6iwhIYGaNm0q10w+5xPlbImJidS6dWu5bh/q9uNB28qVOuQ3MzOTIiMjKSgoiPbv30++vr40ceJE+vLLL6l58+ZkY2OTqwVAUV916tShn376iZ4+far0/MTGxpKnp6fc+fv06aM1ZYpIPcpVtunTp1O5cuUIALVs2VKuYnjkyJHUuXPnXMcYGBjQ3r17801z/vz5eZazkuT3999/F+ksXbo0z31OnjxJrq6ucufU9u7XheHn5yf3N/v7779z7fPhwwfavXs3dejQIdf/1dPTUwVRK+c64lmQmFrZv38/fHx8xLK5uTmmTp0Kb29vmJiYKOQcBgYGWLNmDQDg7t27eP78OapVq6aQtBkry0JDQ2Fra5vnLAB6enrYs2cPPnz4gEqVKqkgOsa0V0pKCnr16oXg4GAAgI2NDc6cOQNbW9tc+5qYmODYsWPw8PDAtWvXEBMTg44dO+LChQtwdnYu7dCZEshkMiQkJCA2NhZxcXGIjY0Vr7yW3759i8jISGRkZJTovFZWVqhatSrs7OxQtWpVufcODg6oUaMGJBKJgnJZMHNzcxw5cgQ+Pj7ie+WhQ4cQGhqKQ4cOoV69eqUSR1m1YMECLFy4sMB9rl+/jqZNmwIApk2bhuHDh+PZs2dYuHAhhgwZgiNHjojykFe5IKICy8usWbMwefJksZyYmAh7e/viZEe4cuWKeN+qVas89/Hw8IC7uzt2796NOXPmwMHBAV5eXiU6rzbIvj9la9CgQa59jI2NMWjQIAwaNAiPHz/G1q1bsWbNGnz48AFXrlz5ZJnQFFwBw9TGhw8fMG7cOLE8c+ZM/PDDDwqreMmpZ8+euH79OgDg2LFjGDNmjMLPwVhZQkQYPHgwHj16hHHjxsHHxyfXtN4GBgYwMDCQW5ecnIyXL1+idu3apRkuY1pDKpXi66+/xoULFwBk/fA8ffo0atSoAQBISEiAqamp3DGmpqY4ceIEOnXqhJs3byI6OlpUwtSsWbPU88BKRiaT4fr16wgICMCRI0fw33//ITMzU2HpSyQSWFlZoVq1arC3t4e9vb2oYMl+2djY5Pr8VzVdXV0sXLgQzZo1w+DBgxEfH48HDx6gefPm2LZtG7766itVh6ixvL290b9//wL3qV69unhvaWkJS0tLODs7o27durC3t0dQUBBatWoFa2trXL16Ve7Yd+/eQSqVwsrKKt/0DQ0Nc30PKansChg9PT1ReZQXXV1dDB06FF9//TXevHlTJioFlO3atWvivYmJSZ4PCHJycnLC4sWLcefOHRw9ehQJCQl49uyZXLnSVFwBw9RGuXLlcPToUQwYMADNmzfH4sWLlfaB1r17d8ybNw8AcOTIEa6AYewTTp48iZCQEADA2bNnsXTp0k8ek5iYiG7duuHRo0e4ePEiV8IwpmCZmZkYOnQojhw5AgCoUKECTpw4gfr16wPI+sLbuXNnrFixAiNGjJC7p5qZmeHUqVNwd3fH7du3ERkZKSphysIX3LLu/fv3OH36NI4cOYKjR48iJiamWOno6urC3Nwctra2sLe3l6tkyX7Z2dmpXeVKUfTo0QPBwcHo06cP7ty5g+TkZHz99deYOnUqlixZAj09/jlUVNkVKsVBRAAgpnNu1aoVfvrpJ0RFRcHGxgZA1nTFhoaGaNKkiWICLoT4+Hjcu3cPANCwYUOUK1fuk8cYGxtzK/pCICK5FjB9+vSR+0xJTU0VU8l/rFGjRjh69CgA4NatW2Xi/sSfOEytNG/eXPzIU2ZtcuPGjWFjY4OoqCicPXsWHz58KNQHLWPaavHixeL9Dz/8UKjrc9q0abh06RIAwN3dHRcvXhRP5dVFcnIyzpw5I57KMaYpiAje3t7Yt28fgKynwQEBAWjWrBmArJYvAwYMQGJiIkaNGoXy5ctj4MCBcmlYWFjg9OnTcHNzQ2hoKJ4/fy4qYUralJ8p3tOnT3HkyBEEBATg/PnzSE9Pz3O/Bg0awMbGBhYWFuJlbm6e53LFihWho6NTyjkpfTVr1sSVK1cwevRo7N69GwCwYsUKRERE4MCBAyqOruy6du0arl27hrZt28LMzAzh4eGYN28eatasKbr4eHh4oF69ehg8eDB+/vlnxMXFYerUqRg5ciQqVqxYarFevXpVVA65uLjg0qVLaNOmTaGOTU5OxsmTJxEcHIyaNWti+PDhygxV4zx58gQfPnwQyzlbn927dw9du3bFunXr0LNnz1zHNmrUSLy/detW2ejupbDRZFipUadBtTTZiBEjxMBOR44cUXU4Kqdt5Urb8lsSFy9eFNdK3bp1Cz3DUVxcHDVq1EgcW716dXr+/LmSoy2ctLQ0WrduHVlZWREAqlChAj158qTE6WpbudK2/KqTGTNmyM0SERAQILbJZDLq16+f2N6yZUtKT08X5f7NmzdyaUVHR1OdOnXE/k5OTnkO4FtatK1c5ZffjIwMunTpEs2aNYtcXFzyHdy2XLly5OXlRVu2bKGoqCgV5UIzyGQyWrt2Lenp6Ym/38czZZYV6nAd3blzh9zc3Mjc3JwMDQ2pevXqNGbMGHr58qXcfs+ePaPu3buTsbExmZubk7e3N6WmphbpXCXNb85BfStWrEgAaN68eYU69tWrV3IzfDF5O3fuFH8fIyMjSktLIyKiiIgIsrS0JABkYGBAp06dynVsztmTPp6ZqjTwLEiMiNTjA1VR4uLi6OeffyapVFrq5z58+LC4oMeOHVvq51c3ZalcFYa25bckcs4ksXPnziIdGxMTIzctbq1atVT6AyEjI4N27NhB1atXz/UjZujQoSVOX9vKlbblV10sWbJElFuJRJJrppAtW7aI7aamphQREUHXrl0jJycnAkDjx4/PlWZkZKTYDoBq166tsmtV28pVfvlt3759vpUu9vb2NG7cODp27BilpKSoKHLNtWPHDvG3bNOmTZmcopqvo6Lx8PDIdZ3p6urSjRs3CnW8nZ0dASATE5NCP6jSFr179xZ/044dO4r1GRkZNHDgQLHN2NiYzp8/L3dsZmYmVahQgQCQg4NDKUfOFTDs/ysrH6gymYz69u1LAKht27b04sWLUj3/+/fvycDAgABQtWrVyuTNtyjKSrkqLG3Lb3HduHFDrgVLenp6kdN49eqV3A+7zz//XAmRFkwmk9Hhw4epfv36ub5gZX8O6OjoUFhYWInOo23lStvyqw42b94sV343bNggtz00NJSMjY3F9v379xNR1nWYPQ2snp4ePXr0KFfaz58/J0dHR3Fs7969SyVPH9O2cpVffmfNmiVX0daiRQtatGgR3bp1S+u/s5RURkYG1a1bV/x9T548qeqQFI6vo6JZu3Yt9erViypXriz3Gdu4ceNCPSj28vISx5T0u0RZk93aOK8HeVKplPr06SO2V6hQga5cuSK3T5s2bcT2uLi40gxdKddR2e/0ydTW77//LvrdhoaGin6XpaVChQro0KEDAOD58+f477//SvX8jGmCJUuWiPfTp0+Hvr5+kdOwsbHB2bNnUbVqVQDAP//8g1evXiksxk85d+4cWrVqhd69eyM0NFSs9/DwQHBwsJhKUyaTYcGCBaUWF2NFdfv2bXh7e4vlpUuXyg0in5KSgn79+iElJQUAMHr0aPTt2xdA1nU4depUAEBGRgZmzZqVK317e3ucO3cOVapUAQD8/fffePPmjdLywwrm5eWF3r17Y+vWrYiKikJQUBBmz56Nhg0b8qwrJaSrqyv3eT937txS/x6qCBcvXkRERISqwygTvL294e/vLwYxzxYSEgJfX99PHp89/hYAMdMqy7ovvX79GkDW+J5ff/213HY9PT3s27cP3bp1AwAkJSXB09MTN2/eFPs0bNhQvL9z504pRK1kCqvKYaWmLNRoh4WFiSdxAOjQoUMqiePXX3+lzz//nJYtW6b1/abLQrkqCm3Lb3GEhYWRRCIhAGRlZVXiZu4zZ84U1/yBAwcUFGX+rl27Rp06dcrV4qVly5YUGBgo9ktKSqIqVaqI7bdv3y72ObWtXGlbflUpKSlJbpwWb2/vXPuMGTNGbHdxcaEPHz7IbU9MTJR7Enn58uU8z5XzWl27dq1S8lMQbStX2pZfdZGZmUkNGjQQZV3TxgN8//492drakpGREc2fP58yMjLktmtbuVJEfjMyMqh8+fIEZI0Dk/0dyMjIiB4+fFjgsadOnRJl6fvvvy92DGXNmTNnxN+latWq+e6XkpJC7u7uYl8LCwu6e/cuERFt2rRJrF+9enVphU5E3AKGlRFpaWkYMGCAGA179OjR6N27t0piGTduHC5evIjp06fD2tpaJTEwpq5Wr14tnghOmTIl3ykCC6t169bi/ZUrV0qUVkHCwsLw5Zdfonnz5jhz5oxY7+LiAn9/f1y+fFm0fgOA8uXLy7UGmD9/vtJiY6y4Jk2ahPv37wPImhVixYoVctsPHDiAjRs3AsiaGtXPzw/GxsZy+5iYmMg99Z86dWqeT/0HDRok3u/Zs0dRWWBMrejo6IgWkAAwb948jWoFs2jRIrx69Qqpqam4ceMGdHV1VR2SxgsNDUVycjIAwNPTExMmTACQNU3yqFGjCiwfTZs2Fe+5Bcz/ydmKsqDfe0ZGRvD390fbtm0BALGxsejUqRMePnyYayYkTccVMKzUzZw5U1w89erVK1SzPsZY6Vu2bBmWLFmC2rVry3VzKK6WLVsCAKpUqQIDA4MSp/cxIsKsWbPg4uKCQ4cOifWOjo7YtWsXbt26hV69euXZdH/MmDGwtbUFAPz1118IDg5WeHyMFdf+/fuxefNmAEC5cuXg5+cHQ0NDuX1sbGzE1NG//PJLrmb02UaMGIE6deoAAC5fvozDhw/n2sfFxQWurq4AgKCgIDx+/FhheWFMnXh5eaFx48YAgJs3b8Lf31/FERXOgwcPxPdnAwMDrF69WsURaba7d+9CKpUiKChIrGvRogUWLVqE6tWrAwDOnz+P33//Pd80zMzM4OTkBCCrkkAqlSo1Zk1x48YN8d7T07PAfcuXL4+jR4+K7lyvX7/G8ePH4eLiAh2drGqLslABw12QNJAmNyk8evSoaEJmaGhYoqb+TLE0uVwVh7bltyQUOdjj06dPlTZ45OLFi+W6GllbW9P69evFdIefsn79enFs165dixWDtpUrbcuvKjx9+pRMTU1F2dy6dWu++8bGxtKqVas+eY35+/uL9GrVqpXn4NrLly8X+yxcuLDE+SgKbStX2pbfvMhkMoqNjaXw8PBc2z7uWqNoAQEBoqy7urqq/Qw2MplMbsaeOXPm5LmftpWr4uY3NjZWzMCTs5vnpUuXiIjo5MmTYp2pqSlFRkbmm9aAAQPEvjdv3ixRfsqKDh06iL9JdHR0oY6JjY2lhg0b0ooVK8S67Bk19fX1C/29ThG4CxLTaFFRURg2bJhY/vnnn8UTNlWTyWQIDg4WgwIzxv6PIgd7dHBwUMrgkXv37sUPP/wgln18fPDkyROMHTu20K1thg8fDgcHBwDA8ePHcenSJYXHyVhRZGRkYODAgUhISAAA9O/fX+4++jFzc3NMnDjxk9dYz5490a5dOwDAo0eP8Ntvv+XaZ8CAASKdPXv2aFTXDKZ+EhMTcfPmTfz9999Yv349fvjhBwwZMgQdO3aEs7MzypcvDwsLC/Ts2TPXsRMnToSVlRXatm2LYcOGYdGiRfDz80NwcDDi4+NLHFv37t3FE/c7d+7g4MGDJU5Tmfz9/XHq1CkAWQNn5zWgNiu8q1evAsgaLDYmJgYAoK+vL1pGeXh4YMiQIQCAhIQEuYHQP8YD8cp79eqVGEzXzs4OVlZWhTrO3NwcV69exZQpU8S67G5IUqkUYWFhig+2NCmsKoeVGk2t0f7uu+9EDWiPHj3UZgpFmUwmarwrVapUqKnmyiJNLVfFpW35LYrSfLKgCBcuXBBTSQOgxYsXFzut33//XaTj5uZW5OO1rVxpW35L29y5c0V5rF69OsXHx8ttf/z4cbGf1l+7dk08TcyvhYubm5s4/7Vr14p1nuLQtnKlDfnduHFjrgHR83qZmprmOtbT07PAYywsLKhFixY0YcIEevv2bbHiO378uEivXr16Sm91U1wfPnyg6tWri1izp5nPizaUq5yKm9+cn7PZr6ZNm8rt8/btW7npqfObSODKlSvUunVrmjBhQq6plLVNWloamZiYiL9Zr169SpRezlaZ27dvV1CUn8YtYDTAggULIJFI5F45B3clIixYsAC2trYwNjZGhw4d5KZFLctWrFgBb29v2NjYYOvWrWozhaJEIhEtceLj45U6OChj6i4+Ph4ODg6YOHEiXr58qdRzyWSyEqdx//59eHl5IT09HQAwcuRIzJw5s9jpDRkyRPThDgwMxLlz50ocI2PFcf78eSxatAhA1pS5+/btg6mpqdgeHR2N1q1bo0uXLoiOji5y+s2aNcPatWtx//59zJs3L899eDBeVhyZmZnIzMyUW1e1atV89zcxMUHdunXRuXNn9OnTBxkZGXLbLSwsYGNjk+/xsbGxuHr1Ks6fP4+kpKRixdylSxcxUPy9e/fw559/FisdZVu+fDmePn0KAHB3d8eXX36p2oDKgLy+92ePWZfNwsICa9euFcve3t549+5dnsddunQJq1evzpWGtjl9+jTev38vlnMOUlxU6enpqFixoljW+HFgFFaVw4iIaP78+VS/fn2KiooSr5iYGLF96dKlZGJiQgcPHqS7d+9Sv379yMbGhhITEwt9Dk2v0Y6Li1N1CLns2LFD1KpOnz5d1eGohKaXq6LStvwW1qJFi8S1MHr0aKWcw8fHh9q2bUs1atQoUUu46OhocnR0FPF6enoqpAXb7t27RZqtW7cuUozaVq60Lb+l5e3bt2RnZ5dvq67MzEzq3Lmz2D5o0CClxPHu3TvRuqxKlSql1kJU28pVWcmvVCqlnTt3Up06dWjPnj1y2x4/fkyjRo0iHx8f2rp1K506dYru3btXpDwnJSXR7du36eDBg7Rs2TIaOXIkubm5kb29PbVt25aSkpJKFH/O6XKdnZ3VrkV0eHg4GRkZEQDS09Oj0NDQAvcvK+WqsIqT34yMDKpQoQIBkGutsWvXrlz7ymQy6tmzp9hn+PDhigy/zBk6dKhcq6KjR48WK52lS5eSnp6eXFodOnRQcLT5U8Z1xBUwCjZ//nxq2LBhnttkMhlZW1vT0qVLxbrU1FQyNTWljRs3Fvoc2vaBWhpiYmJIIpEQAKpfv76qw1EJbStX2pbfwkhKSiILCwsCQDo6OvTkyROlnCfnD8eIiIhipZGcnEzNmzcX6TRs2LBIFdkFycjIEIO9AaBjx44V+lhtK1falt/SIJPJ6IsvvhDlr2PHjrm6QyxdulRst7a2ptevXystni+//FKc68SJE0o7T07aVq40Pb9paWm0efNmqlGjhlw3ntIczDY1NbXEachkMmrXrp3Iw44dOxQQmeJ4eXmJ2KZMmfLJ/TW9XBVVcfJ7+/Ztuc/S7PePHj3Kc/8XL17IVdScPXtWUeGXKWlpaVSpUiW5SpPCDsD7sa1bt4o0KlasKIaMKK2hLLgLkoZ49OgRbG1t4ejoiP79+yM8PBwAEBERgejoaHh4eIh9DQ0N0b59e1y+fFlV4SpVVFQU0tLSVB3GJ1WuXBktWrQAAISGhormnYxpk82bNyM2NhZA1gCcNWrUUMp5spt5A3k3/f2UzMxMDBw4ENeuXQOQ1bT96NGjMDExUUh8urq68PHxEctz587lAUhZqdmwYYOYCtfCwgK7du2Crq4uACAuLg6///47Zs+eDSCrC+3u3btRpUqVEp83JSUFS5Yswe3bt+XWczcklp+UlBSsW7cONWvWxMiRI8X3XSCr7L59+7bUYvl4Wvbk5OQid1OQSCRyn/0LFy5Um6mET5w4gb/++gsAYG1tnW+3QVY0Ob+DJCYmAsgquzVr1sxz/6pVq2LZsmVieeTIkfjw4UOu/YgIL168kLsmtMmZM2fkBsguygC8H8s5YUv297z4+Hg8f/68ZEGqEFfAKFiLFi2wc+dOnDx5Eps3bxZ9tGNjY0Uf7Y8LoJWVVYH9t9PS0pCYmCj30hTff/89zMzM0LVrV7x580bV4RSoe/fu4v3Ro0dVGAljpS8tLQ0rVqwQyyUZR+VTclbAFKfyefLkyeIHqomJCY4ePQo7OzuFxQcAvXv3FiPu37hxQ5yPMWW6e/cuJk+eLJa3b98OqVSK5cuXo127dqhcuTJGjBghxteYNWsW3N3dS3ze0NBQODs744cffsD06dPltnXr1g2VKlUCABw6dAjJycklPh/TbElJSVixYgUcHR3x/fffy40X1rlzZ1y4cAEXL15USMVgcURERKB169Zwd3dHREREkY5t3769uKbCw8gno5cAACAASURBVMOxc+dOZYRYJOnp6ZgwYYJYXr58udx4GKz4clbAZFektGjRosBxKkePHo3PP/8cQFYZWbBggdz2J0+ewMbGBtWqVcP8+fMVH7QG2L9/v9xyScZ/qVevHnR0sqosco4tpdHjwCisLQ3LU1JSEllZWdHKlSvp0qVLBIBevXolt8+IESOoS5cu+aYxf/78PEd9V/cmhRkZGWRmZkYAyMzMTG1HlM8WEhIi/rZdu3ZVdTiljpuqarfVq1eL8v/FF18o9Vzx8fGiy99nn31WpGNzxqmnp0enTp1SUpREAQEB4lwuLi6Fak6vbeVK2/KrTMnJyXJd38aPH09ERPv378/zO4Cnpyelp6cr5NypqalyM6ucPHlSbvvIkSPFtr179yrknAXRtnKlSfl98uSJ3PhE2a+ePXtSUFCQqsMjIqJBgwaJuFxdXen9+/dFOj77+zoAcnBwUPnMgMuWLRPxtGnTptBdLzSpXClCcfJbq1YtAkC6urrib+zj4/PJ4+7fvy/Gx9LR0aHg4GCxLS0tTWyrXbt2sfKiyfLqflSYv2lBateuTUDWrH3ZaS5YsEBBEReMuyBpoPLly6NBgwZ49OiRmA3p49YuMTExBTbLmjVrFhISEsTrxYsXSo1ZUW7cuCFGCHd3dxdNqNVVw4YNxVP0c+fO8VM+pjWuXbsm99R71qxZSj2fqakp6tevDwC4fft2oa+1w4cPY9KkSWJ506ZN6Ny5s1JiBLJaxWV3Tfzvv/9yPdFhTFFev36Nbt264d69ewCy7kfZzdw9PDygr68PAKhduzamTJmCc+fO4ejRo2J9SRkaGmLx4sViedq0aXJPGnN2Q9q9e7dCzqnunj59iuHDh8PR0RHGxsaoWbMm5s+fL2Zcy/bxzJcSiQQbN25UUdTKl5qaKmYkkkgk+OqrrxASEoK///5bfF6q2rp16+Ds7AwAuHPnDr755psidSNt3bo1PD09AQDPnj3D1q1blRJnYURGRopuUTo6Oli3bp3azCKq6T58+IDU1FQAgKWlpVhfmHJcu3Zt0Q1MJpNh+PDhoruagYEBGjZsCAB48OCBRvVcUISzZ8/KdT8CgCZNmpQozexuSDm7BHILGJav1NRUsrOzo4ULF4pBeJctWya2p6WlldlBeHPOpvLbb7+pOpxCGTVqlIj577//VnU4pUpTypWiaFt+8xMTE0P29vai3H///felct6c11pgYOAn9w8KChKzPwCguXPnKj9IIjp16pQ4Z+3atT85K4a2lStty6+iSaVSuUFu8f+fxIaFhcnt9+eff9LDhw+VGktmZiY1bdpUxLFt2za5bdmfE7q6unKzOyqDOpSr48eP07Bhw+jkyZP05MkT8vf3pypVquQa/DT7b5Vz9ssPHz4U6VzqkN+iyMjIoHXr1tHdu3dVHUq+wsLCxICdAGjRokVFOv7q1avi2KpVq1JKSoqSIi3YgAEDRBzjxo0r0rGaVq5Kqrj5ffHiBbm4uIi/87t37wp1XHp6Orm6uorjcs5WN27cOLH+3LlzRYpH033zzTe5WsgVdwDebD/++KNIy9DQkABQ9erVFRRxwXgWJA0wZcoUOn/+PIWHh1NQUBD16NGDTExM6OnTp0SUNXOBqakpHTp0iO7evUsDBgwos9NQ5xxJPjw8XNXhFIq/vz9ZWlrSkCFD6Pr166oOp1RpSrlSFG3Lb37WrVsn17S5tJpab9u2TZz3p59+KnDfx48fU+XKlcX+gwcPLrXR7z+eFWP79u0F7q9t5Urb8qto27dvz/VF1drautTK98cCAwNFHHZ2dnIVCTNmzBDb1q1bp9Q41LVcLV++nBwdHeXWAaDDhw+XKF11za+mO3LkiOjuWpwHaz169BDHrl27VklR5u/8+fPi/BYWFhQbG1uk47WtXBU3vykpKaJrS926dYt07PXr10lHR0dUDDx48ICI5GfuyfngXRuMHDmSjI2N5SowS8rf31/u3lTUyrKS4AoYDdCvXz+ysbEhfX19srW1pT59+lBoaKjYLpPJaP78+WRtbU2GhobUrl27Ij9B0IQP1Pfv34sPs5o1a6o6nEKTSqVqP1aNsmhCuVIkbctvQbZv306Ojo4UGRlZaud88OCBuIH26NEj3/1iY2PJ2dlZ7Ovm5lbq/fEvXLggzu/o6FjguBvaVq60Lb+KlJGRIVe2gawppz/VykrZcv7onDp1qqgMunPnjljfsmVLpcagruVq9uzZ1KRJE7l12T8ILCwsqGnTprRhw4ZPjheVmppKCQkJ4vXixQu1zG9OqqoULKnFixeLcmtiYkL37t0r9LE3b94Ux9rY2BS5ZVNJSKVSatCgQYlakqvrdaQsxc3vlStXxN952LBhRT7vlClTxPHu7u5ERHT37l2xrm/fvkVOU9PlHFdTEeMKRkREiPQcHBzE+wsXLigg2oJxBQwjIs34QD1y5Ii4OMaMGaPqcFghaEK5UiRty++nlHalhkwmIwsLCwJA5ubmeX65T01Npc8//1x8ltStW5fi4uJKNc5snTt3LtQXYW0rV9qWX0Xat2+fXOWLg4NDqTzN+5TQ0FDxRBcAjRw5UlQ65mxu//jxY6XFoI7l6vHjx1SxYkXavHmz3Poff/yRLl++TCEhIbRixQoqV64c/fjjjwWmpWmTK1y9epUaNWpEly9fVnUoRSaTyejrr78Wf+NatWoV6Trr3bu3ONbX11eJkcr75ZdfxHmbNGlSrIeD6ngdKVNx87tq1Srxty7KkBDZkpKS5AYxf/v2LWVkZFD58uXFZ7u22bt3r/h7lHQAXqKs69jExIQAULVq1UTaa9asUUC0BeMKGEZEmvGBOmHCBHFxHDx4UNXhsELQhHKlSNqW35wKM5tPadiyZQsdOHAg35Y3Pj4+4nPEysqKIiIiSjfAHIKCguSa0+Y3HoC2lStty6+iZGZmUs2aNUWZkkgk9O+//6o6LMHX11fEpq+vL2b4yDkby8KFC5V2fmWWq/wqP3K+Pu6CHBkZSU5OTjR8+PBPpr9ixQqqWLFigftoUgsYqVRKjRs3Fn+bj2fI0gRJSUnUsGFDkYeijAdz+/ZtcVyVKlUoKSlJiZFmef36NZmamorzXrlypVjpaNvnc1Hye/v2bWrWrBmNHz+e3N3dxd86JCSkWOeeOHGiSOPEiRNERHIPkJQ9bpa6ydkq6NixYwpJ8+rVqxQdHS03PtM333yjkLQLwhUwjIg04wM1eypNHR0dtXiiVxwJCQl05swZVYdRajShXCmStuU3W2JiIjVr1oz8/PxUHUqBnj9/LvoQ6+rq0rVr11QdEvXs2VPc9H/55Zc899G2cqVt+VWUPXv2yP3gnzNnjqpDymXv3r1kaGhIO3fuFOueP38uxtRwdnZWWrcUZZarN2/eUFhYWIGvnBWskZGR5OzsTIMHDy5U5fW///5LQNEGnVTn62j16tWinLq6uips6vPSFhERQZUrV6a5c+cW+SFEzhY0pTGex7fffquQH5jqXK6UoSj5Xb9+vfgbm5mZEQAqV65csbuA7t69O1cF3+TJkxVeCaHOXr9+LbrptW/fXuT99evXCj1PcnKyaKXZuHFjhaadF66AYUSk/h+o79+/p1q1ahGg/H7iyjJq1CjS19cniURCb968UXU4pULdy5WiaVt+ibKacPbt21clzamLql+/fiLOCRMmqDocIpLv02xlZUXJycm59tG2cqVt+VWUnINKOzs7q+2P2ufPn+da16FDh3xbiiiKupSrly9fUq1atah///6F7gKydu1aMjIyotTU1EKfR13y+7GXL19ShQoVxP9bE7sg5VTUQWyzhYaGiopHCwsLpf6fcra2NDU1LdHsMeparpSlKPkdPHhwrpZv7dq1K/a5c45r5+XlRUT/183U2NiYtmzZUuy0NcXw4cOpQoUK1K9fP9H9ShED8Oalbt26BIAMDAyU3oVeGdeRDhhTsAoVKuDhw4d4+vQp1q1bp+pwisXU1BRSqRREhOPHj6s6HMYUYuXKlThw4AAAoGLFiujRo4eKI8rbxYsX8ccffwAALC0tsWDBAtUG9P81atQIffv2BQC8fv0a69evV3FETBP5+/vjzZs3AAAdHR0EBARAX19fxVHlzd7ePtc6CwsL8X737t2lGU6pevXqFTp06AB7e3usWLECb968QXR0NKKjo8U+AQEB2Lx5M/777z88efIEW7ZswezZszFq1CgYGhqqMHrFmDhxIpKSkgAAo0aNQqtWrVQcUcmYm5vnWkdEnzyuXr16GDhwIAAgNjYWw4YNg0wmU3h8MpkM3t7eYtnHxwdWVlYKPw8Drly5AgByn70tW7YsdnpOTk6oWLEiAOD69esAAE9PT9y+fRuJiYkYPnx4CaJVf1KpFIcPH0ZSUhICAgKQnJwMAGjSpIlSzteoUSMAQHp6Ou7fv6+UcygTV8AwpXFwcFDahadsOX+YHj16VIWRMKYYgYGBmDFjhljevXs3atWqpcKIsrx8+RL79u3D+PHjER8fj8zMTIwfP15sX7x4MSpVqqTCCOUtXLgQEokEALBjx45CfXlnLFt0dDRGjBghltevXw9nZ2cVRlQ0O3fuxMGDB8Wyn58fMjIyVBiR8pw6dQqPHz/GuXPnULVqVdjY2IhXNn19faxfvx6tWrWCq6sr1qxZAx8fH6xcuVKFkSvGsWPHRIV95cqVsWTJEhVHpHiXLl1Cx44dC/U57uPjI35gHz58GHPnzlV4PL6+vggODgYAuLi4YNy4cQo/BwNiYmLw+PFjAECVKlXE+pJUwOjo6IjfPJGRkYiKikKlSpXg6uoKPT29kgWsAQIDAxEXFwcAcHV1FeubNm2qsHMQETZv3gxvb29ERESI9bdu3VLYOUqNwtrSsFKjbU0KVUEqlVKlSpUIAFWqVEltm4crkraVK23K74sXL+S6PKjTeBPe3t5yA9dt3LhRLDdu3Fgtp4WfMGECrVixgrsgkfbltyRkMhl5enrKNVPXtKl9BwwYkKvZvjLGNtC2cqVu+U1OTiZHR0fxP845DlBZsWvXLtLX1ycAFBYWVqhjjh8/LjdD2K5duxQWz/bt2+Wuq8DAwBKnqW7lStkKm19/f3/xd7a3txfv85sQoLCmT58u0goICChRWppmxIgRIu89evRQ2v0he7ap7DECAdCkSZMUeo6PcRckpvaojDwN1tPTg6enJwAgPj4ely9fVnFEjBVPWloa+vbtK7o8dOnSRW269ABA69atxfuzZ89i9uzZYvmXX36Brq6uKsIq0OrVqzFlyhSUK1dO1aEwDfLrr7/ixIkTAABra2ts3rxZtKbSFLt378bUqVPl1o0dOxapqakqiogpw08//SSeMHfo0AH/+9//VByR4kVFRUEqlQLIuvcUhqenJ3x9fcXyiBEjRFeWkjh8+DC+/fZbsTxnzhx06NChxOmyvOX8n2V/N7K3t4etrW2J0s3Z2iO7G5I2yO5+BADlypVDfHy82KbonhDZrWtSUlLEOk1sAcMVMEyhVq5ciYYNG2Lq1Kl4+vSpqsMpke7du4v33A2JaaqJEyfi6tWrAIDq1atjz549alWpkbMCxs/PD7GxsQCAAQMGoG3btqoKizGFunfvHqZMmSKWf/vtN1haWqowouLR0dHBzz//jNWrV4t1z549Q8eOHfH27VsVRsYUJTY2FqtWrQKQ1cVqw4YNGldRWBju7u7ifWErYABg/PjxGDVqFICsBxxeXl549uxZseM4c+YM+vfvL8aU8fb2ho+PT7HTY5+WswImu/K4RYsWJU43ZwVMdley169fw8fHBz179sSyZctKfA51FBgYKL67de/eHbdv3waQVamVs4uXIuTs3mRmZgYgqwJG0xoAcAUMU6hTp07hzp07WLlypcY/EfP09BRfOo4cOaLiaBgruu3bt2Pjxo0AACMjIxw8eFBuAE11UK1aNTGmwosXLwBkPUFZvny5KsNiTGHS0tIwcOBApKeni3WJiYkqjKjkJkyYAA8PD7F85coVtG7dWoyrwDSXhYUFgoKC0KpVK8yYMQN16tRRdUhK0ahRI/EDLjAwEJmZmYU6TiKRYN26daKFSkxMDHr16iUGKy6KoKAgeHl5ic+GwYMHY82aNWWywktdSKVSXLt2DYD8gOIlGf8lW/Xq1UWawcHBICJkZGRg/vz5OHLkCE6fPl3ic6ij/fv3i/dt2rTB+/fvAShnAN6cFTDZf+t3796J74+agitgmMKkpqbin3/+AQBUrVoVtWvXVnFEJWNpaSlG/A8LC5Mb8IkxTeDg4IDKlSsDADZs2IDPPvtMxRHlJpFI5FrBAMAPP/yAqlWrqigixhRr7ty54okgkPUlvV+/fiqMSDFmzZolt/zo0SN8/vnnePfunYoiYori6uqKf//9VykDzaoLHR0duLm5Acjqal6Ubgz6+vo4cOAAnJycAAB37tzB//73vyLNjHTnzh107dpVzBbzxRdfYOvWrdDR4Z9mynTnzh3RfcXU1FSsV0QFjEQiEa1gYmJi8OLFC9jZ2YmHTMHBwUqZPUuVPu5+lD1QNaD8CpicgxtrWjckvsqZwvz777+i1YuHh0eZqMHnbkhMk7m5ueHmzZtYuXIlhg0bpupw8lWhQgXx3sLCQq6rBmOaLDAwECtWrJBbN2vWLLWddroo2rVrl6uiNCYmBufPn1dNQEyhdHR0YGBgoOowlKq43ZCArHtVQECA+BHv7+8vN4ZZQR4/fgwPDw8xVkbHjh3h5+enFbPlqJqzszMCAgIwa9YsMYObnp6ewh5Q5dUNqVmzZgCAhISEMtdK8Pz583Ldj/777z+xTRkVME5OTjAyMgKQ9ffMxhUwTGvlbFrXuXNnFUaiONnTUX/22WdqNRUuY4VVtWpVTJ48WdVh5CslJQUnT54Uyw0aNBA3V8Y02bt37zBkyBC5vulVq1bF0KFDVRiV4ujo6GDgwIFiuU2bNnj06BF69+6twqhYcR0/flyum5w2KEkFDADUqVMH+/fvF+OqLV26FDt37izwmJcvX6JTp054/fo1gKyxR/766y++75USExMT9OjRAzNnzhTdVho2bAhjY2OFpJ9d2QL830C8ea0rK5KTk1GrVi0AwFdffYUbN26IbcqogNHV1YWLiwsAIDo6WqznChimtXJWwOS8qWmyBg0aIDIyEjdu3CiTswCwskfTxl5auXKl3E00MjJShdEwphhEhLFjx+Lly5dy66dPnw5DQ0MVRaV4gwYNEu9lMhlq1KihwmhYcV2+fBndunVD48aN8e+//6o6nFLj7OwsZr75559/kJaWVuQ0OnfuLDco9ciRI3Hp0qU893379i08PDzEoL0uLi44duwYTExMihE9K4nsMVoAxQzAm62gFjBA2auA8fLywoMHDxASEoKuXbvi5s2bAJQzAG+27G5IRCTupzm7+WoCroBhChETE4OQkBAAQOPGjcW4E5pOIpGUeFo6xkoLEaFnz54YMGAAoqKiVB3OJ7148QKLFy+WW/fo0SMxLSRjmmr37t34448/5NZZWVlhxIgRKopIOVxdXdGgQQMAWQPxPnnyRMURsaKSSqUYM2YMgKzZurJ/QGkDiUQiHhimpKSIGQOL6rvvvsPYsWMBAOnp6ejdu3eumUATExPh6emJsLAwAECNGjVw6tQpmJubFz8DrNiCgoLEe0WM/5LN1tYW1tbWAP6vkqesT08tkUjQqFEjREZGKnUA3mzZ9xwAsLOzAwCEh4fLdUlSd1wBwxQiZ9PNnDMjMMZKzx9//IEzZ87Az88PXbp0Uftp+aZPny4Gw2vevDnc3Nwwe/bsMjdIHdMuT58+xXfffZdr/bRp0xTWzF2d5GwFs3fvXgBZMz/dv39fVSGxIvjll19w9+5dAFk/mvIqu2WZu7s7rK2tMXDgQLnxyIpCIpFgzZo1ojLnzZs36NWrl/gxmpKSgp49e4ruGba2tjhz5owYnLWs69WrF6pVqwYjIyPY2Nhg8ODBePXqldw+Eokk1yt7FkdFuXXrFnbs2IGHDx/KTUWtyBYwEolEtHiJj4/HkydPYGFhIVoHhoSEiLFnyhpldz/K1rJlS3h5eWHevHlyY/fcuXNHaedUNK6AYQpRFsd/yUt4eLja/6hl2ikhIQGTJk0Sy4sWLVLrgbD/+ecf+Pn5AcgazPDEiRM4d+4cFi1aBCsrKxVHx1jxZGZmYvDgweKHV/Y1aGFhgdGjR6syNKUZMGCAeL9r1y6sWrUKNWvWRPfu3cvsD42yIiEhAYsWLQIA8YM3ezwTbTFo0CC8evUKe/bsKdFArPr6+ti/fz+cnZ0BAHfv3sXAgQORmpqKr776ChcvXgSQ9Vlw+vRpODo6KiR+TeDm5oY///wTDx48wMGDB/HkyRP07ds3137btm1DVFSUeCl6vKx9+/Zh2LBhqF27tpi11czMTIxhoigFdUNKSUnBvXv3FHo+Vfl46vbsvALyfwNFa9myJQ4fPoyFCxeiU6dOYr0mjQPDFTBMIS5cuAAAMDIyQps2bVQcjeJt2LABNWvWRM2aNREaGqrqcBjLZd68eWIslV69eqFXr14qjih/mZmZ+P7778XyTz/9BDMzMxVGxJhirF69WoyhYW9vjxEjRsDQ0BCTJ08u9tN1dVetWjW0b98eQFYXQj8/P0RGRiI8PBx//vmniqNjBVmzZo2YiWfo0KFK/dGkrvT09BT2sMLMzAwBAQFi0oYjR46gXr16YhZNExMTnDhxAvXq1VPI+TTFpEmT0LJlSzg4OKB169aYOXMmgoKCIJVK5farVKkSrK2txUvRLQZztnrJ7q7SsmVLhT+s0pZxYNq1a4emTZtiwoQJkMlkpdYCJqdGjRqJ91wBw7TO7du3ceTIEfj6+pbJkdzT09MRHh4OADh16pSKo2FM3s2bN7Fu3ToAgLGxMdasWaPiiAq2ZcsWMWBao0aNyty4GEw7xcXFybUm2LdvHzZt2oSIiAi5CseyKGc3JHt7e/F+yZIl3KVQTcXHx8PX1xdA1swic+bMUXFEZYOzs7PczEgREREAsh5QBgQEaGUlV05xcXHYs2cPWrduDX19fblt3t7esLS0RLNmzbBx40aFfnZIpVJRGZJzcFhFdj/KlteYL25ubhgzZgy2bNlSJnoKpKSk4Nq1a7hx44b4XZQ9Fqi9vX2pjQXaoEED6OhkVWf8P/bOOypq9Hvjz9CLIk1BVBRRQERsqIC9Fyy7lhVlsRd07aJiWcXe0MWGBbuC2HvDglgRCygIAjbAgkoRBJWa3x/zm/ebkQ4zkwy8n3NyTjKTSZ6BZJLc997n0gAMpdJRpUoVODg4EBOyigbb14YGYCh8Ii8vD5MmTSI3KosXL0a9evW4FVUEKSkpWLhwIVnevHmzWMo7wzB4+fIlvnz5woW8Ssft27fRr18/GBkZQSAQ4MyZM1xLkltWr14tlk0gygatWbNmhe9yMnjwYKioqAAQlheKTC3Dw8Nx4cIFLqVRCsHT05NkAYwcORKmpqYcK+Ke9PR0REVFlXs73bp1w5YtW8iykpISTpw4QTLFKiPz5s2DpqYm9PT0EBcXh7Nnz4q9v3z5chw/fhzXr1+Ho6MjZs+enc+k/3cyMzORlpYmNhXGs2fPiOccO+NWkga8ImrUqAFjY2MAwgGy3NxctGjRAtu3b8fYsWPJe/LMo0ePSIlp27ZtERMTQ0pvZRVkzMnJQWxsLPHXCQ8Pz5dVxVdoAIZCKQEWFhaoXbs2AGG5lby1+qVUXLy9vREcHAwAaNSoEWbNmsWxoqJxd3dHUlISAMDR0RHt27cn750/fx76+vpo1KgR8YehSJeMjAw0bdqUZFBRykZcXBx54FJVVcWyZcs4ViRbdHR04ODgAEDYFbF3797kvZUrV1LvNJ6RkpKC//77D4AwOFDZs1+ys7PRvn176OjoiHkalYdJkyZh9erVaN68OY4fP07Oj4qCu7t7gca57IntCTJnzhyEhITA398fioqKGDFihNjvwqJFi2BnZ4dmzZph9uzZWLZsGdavX1+khtWrV6NatWpkYmff/c79+/fJPPsevnXr1mX5+sUiCkKkp6cjOjpaKvvgEvbf097eXux/LYvyowsXLqBKlSqwtLSEpqYmAGG1gryYv9MADIVSAgQCAcmC+fXrFzHvolC45MuXL5g/fz5Z9vLyIqPQfCQ8PBzbtm0DICyVWrdundj7tWrVQnJyMgDxiztFevTu3RsrVqzAwIEDuZYi1yxZsgSZmZkAhLX+fn5+SE9P51iVbPn777/JfExMDKytrQEAwcHBuHnzJleyKAUQEBBAjs9Ro0ZVKkPYglBWVkZ6ejpycnIQGhpKBgnKi5ubG54+fYo//vhDItvjE1OmTEFkZGSRk5WVFVlfX18fZmZm6N69O/z8/HDp0iWxVtC/Y2tri7S0NHz+/LnQdebPn4/U1FQyxcfHF7ou2//lw4cPAABzc3Op+c9V9NbTvwdgZO3/YmxsTK65bA8feSlDogEYSrkIDg7G8OHDsX///iJ/JKXJ48ePMW3aNEyePBlr1qyBr68v7t27h/j4eIl2YKBlSBS+ceDAAaSkpAAAnJ2d0alTJ24FFcO8efOIa/6CBQvyjVZZW1tDQ0MDgPjNEoU/lCblu7IQFhaGAwcOAAC0tLTw5MkTzJ07F5aWlsjKyuJYnezo06cPqlWrBgA4c+aMWFe24koJKLJl4MCBiIyMhLOzs1hJaGVG1EKaYRjcunWLWzFygL6+PiwsLIqcCvOEFGW+iB6gCyIkJARqamrE0LggVFVVoaWlJTYVhuieQk1NjTwbSKP8SATbdJedHZKYmIjLly/LdVCGYRgSgNHV1YW5ubnMAzAWFhZQUlICAFL6C9AADKWScOHCBRw5cgSjR4/GlStXZLbfvLw8XLx4EZ06dUKrVq2wZcsWbN++HfPnz4eTkxPatWsHY2NjqKmpoV69eujQoQP+/vtvLFy4EDt37sTly5cRFxdXbZVaJwAAIABJREFUqn1269aNRFlpAIbCB1xdXXHkyBE0atSo2FRdrnn+/DkuXboEQDhyMXv27HzrKCkpkXTguLg4vH//XqYaKcVTmpTvysL8+fPJA0WLFi2Iz8CgQYN4nZEmadTU1DBkyBAAwrR7ZWVlNGjQAABw8+bNIke7KbLHzMwMBw8e5LVnmCwRBWAA4MaNGxwqqVgEBwdj69atCA0NRWxsLAICAjB8+HCYmprCzs4OgLD82NvbG+Hh4Xj9+jV2796NhQsXYsKECVBVVS23ho8fPyI2NhYAiJ0AIB0DXhHsIIQoABMSEoLq1aujT58+JBtYHomOjiZZYvb29mAYBk+fPgUgvL+ThQGviooKGjVqBABi94o0AEOpFLADEexe7NIiMzMT+/btQ5MmTdC3b1/S/rowcnNzERsbizt37sDHxwerVq2Ci4sL+vTpg7p16+L48eMl3reenh5JKXz+/Dk+ffpUru9CoZQXgUAAR0dHhIeHw8DAgGs5RcIuN5ozZ06h7SXt7e3JPM2C4R+lSfmuDAQGBpIWszVr1iQ32ioqKnB1deVSGiewuyH5+vrCzc2NLK9du5YLSRRKiWjfvj0ZUacBGMmhrq6OU6dOoWvXrjA3N8eYMWNgZWWFwMBAElxRVlaGl5cX7OzsYG1tjU2bNmHZsmXYsGGDRDSw7yXYnZekmQGjo6NDjK1DQkKQnZ0NS0tLsn95zoBhlx+1bdsW0dHRpKRRVu2nAWEHJEBoxqunpwdAGICRB88xGoChlJmUlBTyA2JpaYlatWpJbV/fvn3DmjVrYGJigjFjxiAiIoK8Z25ujl27diEoKAjHjx+Hh4cHpk2bhj/++APNmzcnJ2VBrF69ulQ62GVI169fL/0XoUiEgszfDA0NuZbFGaIWfHzl3bt3xFRXT08PY8aMKXRdGoDhN6VJ+a7oMAyDefPmkeWWLVuSm9CxY8dK9ZrIVzp06EBGmK9evYpevXrBzMwM06dPx+bNmzlWRwkODq5UZXGloUqVKiQjIjo6mmZgSogmTZrg5s2bSEpKwq9fv/D27Vts375d7PexV69eCAkJwffv35GRkYGwsDBMnz6dBMTKi5aWFnr16gVtbW3iM6eurk4e4KWFqAzp169fiIiIgKqqKtlnZGQk6Rokb3Dt/yJC5DMGAEZGRgCEbc7l4dzl9107hdcEBASQ1rfswIQkiY2NxaxZs1CnTh3Mnz9fLOukXbt2OHv2LCIiIjB+/Hi0adMGgwcPxuzZs7Fp0yacPn0aT58+RWJiItLT0xEREYErV65g165dsLCwACCMSovS5kqC6Htqamri69evkv2ylFLRuHFjfPr0iUxhYWFcS5IJcXFxpJRHXti4cSPxfpk6dSrxeSkI9ogUNeKl8JlTp07h4cOHAIT16Ldv3wYgLKVjB2YqEwoKChg+fDgAYQbq6dOn8eLFC3h6etJyNY5JTExE165d0bBhQ+zfv59rObyEXYZEjaMrDt27d8fly5cRGRlJ/CptbGwkFuApDLYRryg7UhSUYZftyBuiezMlJSXY2NjwIgDDzqqWhzIkGoChlJlr166R+e7du0t02yEhIXBycoKpqSn+++8/MqooEAgwaNAgPHjwAHfu3EH//v1LNPqvqamJRo0aoWfPnhg/fryYOaC3t3eJddnZ2SEgIADJycm8b/db0VFSUoKhoSGZZFFzygemT58OBwcHDBo0iDPj69KQmJiI3bt3AwA0NDQwZcqUItfX09ODubk5AODp06e05buUSU9PR2hoKLlhefv2LUJDQ0vtkVXZyM7OxoIFC8hyy5YtiSHxyJEjUbduXa6kcQ67G5KPj4/UH3IoJcPDwwPp6emIi4uT6/IHaUJ9YCo27ONemv4vIgrqhMQ255XX8/Du3bu4ePEiPD09oaGhIfMW1CLYARj2vSINwFAqNCL/F2VlZXTs2FEi28zLy8O4cePQokUL+Pr6klFzNTU1TJo0CdHR0Thx4kS56zaHDRtG+sb7+voiIyOjRJ9TVlZGp06dKpWxIl+JiYmBkZERTExM4OjoiDdv3hS5fkXo3nLhwgWcOXMGAHDv3r1COwzwia1btxJT0nHjxhVZEihCVIaUnZ0tNrJCkTyPHz9G8+bN0bx5cwDArFmz0Lx5cyxevJhjZfxmz549iI6OBiAMzF++fBkAoKioKNYavjLSpEkTkmYfFBSEV69eib0vuq5TZMfXr1+xdetWAEJ/osp+jBaGra0tGUm/ceOGXHhJUEqOKGMRkK7/i4gWLVqQ5h2/Z8AA8huA0dHRQZ8+ffDPP/8gLy8PISEhAGRnwCvCyMgIurq6AICEhATy+rNnz2SmoazQAAylTLx584Y88Nrb25NgRnmZO3cu9uzZQ5b19fXh7u6OuLg4eHl5kY4K5aVq1aoYOnQoACAtLQ0nTpyQyHYpsqFNmzY4ePAgrl69Cm9vbyQkJMDe3p64sheEvHdv+fHjB6ZOnUqWN27cSFq+8pWMjAxs2bIFgPDBtKRZY6LOCDo6OtTsWsp06tQJDMPkm2iJQuGkp6fD3d2dLDdv3pz4Coi6e1R22Fkwvr6+AITX2rVr18LExAQfPnzgSlqlZP369WSgacKECWKdYCj/Q0VFBe3btwcgvP9MSUnhWBFFkrA7sckiAFO1alViefD8+XNkZmbC0tKSBPnYmSPyClcGvICwKkKUBZOTk0MGJWkGDKXCIo3yoy1bthDHcwUFBXh6eiI2NhZLliyRSkR13LhxZF5UIlFa6EgeN/Tu3RuDBg1CkyZN0K1bN9KF5MCBA4V+Rt67t6xatQrv3r0DAHTp0gXDhg3jVlAJ2LNnD3kwHTZsWInLMgYOHIjIyEgkJiZi8ODB0pRIoZQaT09PUv43cOBA1K5dG5qamhAIBGJlSZWZYcOGkZHfw4cPg2EYeHh4wM3NDfHx8RLrbkIpni9fvpCWt6qqqjT7pRg2b96ML1++IDQ0lIyuU+Sf3NxcBAcHAwBq1aolM5N0URlSdnY2nj9/DiUlJbRo0QKAcDC7qIFDeYCdpcwuuZIVXl5e+PDhAxITE9G0aVMAwOvXr3mf5U4DMJQyIekAzJkzZzB9+nSyvH37dkyfPr1Is87yYmtrC0tLSwDCesaXL1+W+LM+Pj7o168fDAwM8OPHD2lJpJQQTU1NNGnSBDExMYWuI8/dW169ekXaOCsrK2Pbtm3k4YavZGdniz1kzZ07t8Sf1dPTg4WFBe+7O1EqH1+/fiXnoqKiIlatWoX58+fj3bt38PX1JaOdlZ06deqQ0uSYmBg8fvwYU6ZMISOUO3fuRGJiIpcSKw3r1q0j9ykTJ04k3UIoBWNubl5pPOUqEy9fviRdh2SR/SKCXXJUUBmSPGXBZGdnw8XFBfv27cPr168BgDP/FxGNGjWCkZERBAIBmjVrRl5//vy5zLWUBnp3SykTS5Yswdq1azFgwIByn3BBQUEYNmwYqbVdsGABJkyYIAmZRSIQCMSyYNilT8Vx+/ZtXLhwAUlJSQgMDJSGPEopyMzMRGRkJGrWrMm1FKlw8OBBZGdnAwDmzJkjFw95R48eJUauffr0kXq7RwpFFqxYsYLcxI8bN44YRuvr68PR0ZFLabzDycmJzB8+fBg1atTA+PHjAQhLKmlbaumTkJAALy8vAEIvPTc3N44VUSjcwC4/koUBr4jCOiEpKyujZcuWcpVJ/+zZM+zcuRNjxowhPnFcdUAqCHYAhu9lSDQAQykTTZo0wdy5c3HmzBkoKiqWeTuvX79Gv379iHv18OHDsWLFCknJLBZnZ2coKysDEJavZGVllehz7LbbIjNiiuxwdXVFYGAg3r59i4cPH2Lw4MFIS0vDyJEjuZYmFc6ePUvm//nnHw6VlAyGYUiWAIBK25KXUrF48+YNtm/fDkDY0WvJkiUcK+I3gwcPJob1fn5+yMnJwZw5c0hXpC1btvA+TVzeWbduHTFBd3FxqbCDFNJEnh6QKYUjawNeEU2bNiXPSSLT3YEDByItLQ2PHz9Gnz59ZKalvIjaTwNC/8/fDXj19fW5kgaABmAo/8/q1ashEAgwY8YM8hrDMHB3d4eRkRHU1dXRqVMnvHjxgkOV3JGYmIjevXuTNOROnTph7969Mi2t0NfXx59//glAmFp+/vz5En2uS5cupDyCBmBkz/v37zFs2DCYm5tj4MCBUFFRQVBQUIVs/fru3TuSStm6dWu5SB+/cuUKwsLCAAhvdESmhqUhKSkJixYtQteuXUtVvkShSItFixaRTLRp06bBx8cH375941gVf9HW1kbfvn0BCH1Irl+/jjp16mDEiBEAgG/fvpGAFkXyZGRkYO/evQAAdXV1GggvBTExMZg4cSIaNmyI//77j2s5FAkgyoBRVFSUaaaGhoYGrKysAAAvXrzAjx8/oKamJhddLH/n3r17ZN7e3l7MgJcL/xcRp06dwowZM/Dvv/+S12gAppLy6NEj7Nq1S6xHOSAcjdi4cSO2bt2KR48ewdDQEN27dycpzZWFnz9/on///sSzw9LSEqdPn4aqqqrMtZTFjFdHRwetW7cGAEREROD9+/dS0UYpGD8/P3z8+BFZWVn48OEDTp48Sfx8Khoig2EA6N+/P4dKSs7atWvJ/Ny5c8sUVFVWVsaqVatw8+ZNMc8pCoULnj59iiNHjgAQehQZGRlhzpw5qFu3LunyQ8kPuxuSj48PAGFGnOg3YePGjSRDg4/0798fxsbGUFNTQ82aNeHs7IyPHz+KrRMXF4d+/fpBU1MT+vr6mDZtWomzaaWJpqYmnj17hgkTJmDatGkwNDTkWpLckJOTg127duHVq1e4ceMG13Io5eT79+9ksNva2lqq/pIFIQpO5OXl8T4wUBSiDBiR7yLX/i8ifHx8sGnTJly/fh0mJiYAgPDwcDJgwkdoAAbCE8PLy0ti7ebS09Ph5OQEb29v6OjokNcZhoGnpycWLlyIgQMHwsrKCgcOHMCPHz/k5gYuPT0dK1euxKNHj8qclpmbm4u///4bDx48AADUrFkTly9fhra2tiSllpiuXbuSzImrV68S34ri6NmzJ5mnD4gUaTFx4kQEBgZi1qxZGDRoENdyiuXhw4fEF8nc3BwDBgwo03a0tLSIb8zz58/JKAuFwgVs74wFCxbA09MTgLC1Mm07XTh9+vQh1/bTp08jIyMDZmZmGDJkCAChqWN4eDiXEoukc+fOOHbsGKKionDy5Em8fv1arDNbbm4uHBwckJGRgbt378LPzw8nT57E7NmzOVT9P+rWrYudO3dizZo1XEuRKywsLEi51u3bt3kRUKOUncePHyMvLw+AbMuPRLCzQ0RlSCKysrJIVz0+Ex8fTwabbW1toaSkxBv/F3ayg+i8zczMRFRUFFeSioUGYCBMR5syZQqMjIwwbNgw+Pv7E0PYsvDPP//AwcEB3bp1E3v97du3SEhIEPMPUVVVRceOHcXq6n4nMzMTaWlpYhNX3Lp1C4sWLULr1q3LfIPh6uqKU6dOAQCqVKmCixcvwtjYWJIyS4WCggLGjh0LQBgk27dvX4k+x/4/Xr16VSraKBQlJSV06NABGzZskAvzXXb2y5w5c8rVycje3h6AcNRI1D6SQpE1165dI0H2evXqoVq1anjz5g0AYRdAWRo6yhuqqqok2JKRkUH8rBYuXIj169cjNjZWrCMI35g5cyZsbW1Rt25d2Nvbw83NDUFBQWRk1d/fHxERETh8+DCaN2+Obt26YcOGDfD29qb+NnKMQCBAly5dAAgNo+n1R77hyoBXREFdj759+4Zp06bByMgI06ZNk7mm0vJ7+RHAHwNedgCGXdrF52wjGoCBcMQ2MjIS06ZNw+3bt9G7d28YGxvj33//xatXr0q1LT8/Pzx9+hSrV6/O915CQgIAwMDAQOx1AwMD8l5BrF69GtWqVSNTnTp1SqVJkrAzPUQtJkuDp6cnGTlUVFTE8ePH0bx5c4npKyujRo0iD4p79+4tUXZP69atSSvja9euUaM2SqUnKioKZ86cAQAYGRmJlR+UBfaNEp8vpJSKS15enph3xvLly8UMptk155SC+b0bEiC8YXZ1dUXVqlW5klVqkpOT4ePjA3t7e2Le/+DBA1hZWYl5c/Xs2ROZmZliDye/I82BtZSUFNJ2mlJ2unbtSuZpGZJ8w5UBrwgrKytiSC4KwGhqasLPzw9JSUk4c+aMxKowpMXvBry5ubnEgLdu3bqcGvCyAzDsklY+3zfSAMz/Y25ujrVr1yI+Ph7nz5+Hra0tPDw8YG5uXuJAQ3x8PKZPn47Dhw8Xaa70ux8CwzBFeiTMnz8fqampZIqPjy/Zl5ICt27dAiDMGuncuXOpPnvq1CnMmjWLLO/cuRO9evWSpLwyU6dOHaIlLi4O169fL/YzSkpK5AKdnJxMfogolMrK+vXrSfbgjBkzyu3p1LhxYzIfGRlZrm1RKGXh6NGj5Le9WbNmUFBQQHR0NADhIERZDKYrG+3btycDR/7+/vjy5QvHikrHvHnzoKmpCT09PcTFxYl1pUtISMg3qKajowMVFRXOBtb+/fdfmJqawtPTk9f+OnxHlAED0ACMvOPm5oY1a9Zg2LBhaNiwocz3r6qqSoIEUVFRSEtLg7KyMglOZ2Vlwc/PT+a6SoMoA0YgEMDW1lbMgJfr9tMmJibQ1NQEADGPLhqAkSMUFBTQp08fHD9+HNevX0etWrVw9+7dEn32yZMn+PLlC1q2bAklJSUoKSkhMDAQmzdvhpKSErlI/35R/vLlS74LOBtVVVVoaWmJTVzw/ft3UqttbW1dKs+W+/fvw8nJiTyc/fvvv6Tshy+UxYyXXYbETs+jUMpLVlYWBgwYgG3btnEadC0pHz9+xKFDhwAA1apVw8SJE8u9TXNzczJPAzAUWZOXlyeW4bJ69WqsWrWKLNPsl5KhoKCA4cOHAxB6phw9epRTPe7u7hAIBEVObHPJOXPmICQkBP7+/lBUVMSIESPEytQLGkDjamDt1atX8Pb2RkJCAhYtWkS9s8pB3bp1ib9TUFAQMjIyOFZEKSu2traYN28efH19y1UWXR5EZUgMw+Dp06cAhNn3Ivbv38+BqpKRnp6OZ8+eARAOjGlra/Om/AgQXmNEnoGxsbEkGyc0NLRcliLShAZgfuP79+/w9vaGvb09OnTogKSkJAwbNqxEn+3atSvCwsIQGhpKJhsbGzg5OSE0NBT169eHoaGhWBlPVlYWAgMDST0dnwkODi6TiVVMTAz69++PX79+AQCcnZ2xdOlSqWgsD3379kWNGjUAAGfPni3RKF3fvn2xbds2xMTEyEUNJ0V+uHXrFs6dO4cpU6ZgwYIFXMspFk9PT2JUOGnSJIkEirW0tFCrVi0AwgAMXy+klIrJzZs38fr1awBAp06d8OPHD9JJw87OTmyEnFI0BXVD4oopU6YgMjKyyEnUNhYA9PX1YWZmhu7du8PPzw+XLl0inhKGhob5BtVSUlKQnZ0t84E1hmHg4uJCfoenTp2K6tWrl3u7lRlRlnN2dnaJB2MplIJgG/GKArxNmzZFs2bNAAifsSIiIjjRVhw5OTlYtmwZHBwc0Lt3bwDi/i9ctqAWIQrAAED9+vUBAElJSbztUksDMP/PzZs34ezsDENDQ0ycOBF5eXnw8vLCp0+fSM1ycVStWhVWVlZikyht1crKCgKBADNmzMCqVatw+vRphIeHY9SoUdDQ0CCjQ3yGbWJlZ2dXos+kpKSgd+/eSEpKAiC8mO3evbtMbWmljbKyMolGZ2dnk9H8oqhduzYmT56MBg0a8PI7UeSXc+fOkXm+t5/+9u0bduzYAUD4YDF9+nSJbbtRo0YAhGV+X79+ldh2KZTiYBuyT5o0CStWrCDL//77L/3NLwVWVlYkBf/hw4eIiYnhTIu+vj4sLCyKnAorIxcFgTMzMwEI74XCw8Px6dMnso6/vz9UVVVlPip88OBBUipTt25dLFy4UKb7r4hQHxiKpCisE9Lo0aPJ/IEDB2SqqaRoa2tjwYIFuHDhAvFA40sLahFsHxh2B2K2Tj5BAzAQdjXo3r07rl+/jsmTJ+PFixcICgrCxIkTJV7uM3fuXMyYMQOTJ0+GjY0NPnz4AH9/f7kwohO1jQZKHoBxd3cnI4hWVlY4efIkMaLiI+wyJG9vbzriTuEEhmFIAEZFRYU3XkmFsWPHDnz//h0AMHLkSBgaGkps26IADEDLkCiyIyUlBSdPngQA6OrqonHjxuRaZmNjw/tzko+ws2B8fX05VFIygoODsXXrVoSGhiI2NhYBAQEYPnw4TE1NyT1Qjx49YGlpCWdnZ4SEhODGjRtwdXXF+PHjZVou/uXLFzGPPS8vL1SpUkVm+6+osL0OaQYMpTxYWlpCXV0dgHhQYPjw4cTU+9ChQ8jJyeFEX2n43YBXT0+PY0XiARj24AjbgJlXMBTmjz/+YM6dO8fk5ORwLaVEpKamMgCY1NRUme0zLy+P0dPTYwAw+vr6TF5eXrGfiY6OZpSUlBgAjIaGBvPu3TsZKC0/HTt2ZAAwAJg7d+5wLUdmcHFccQmfv++TJ0/IMdirVy+u5RTJz58/GQMDAwYAIxAImOjoaIlu//Lly4ybmxtz4MABJiEhQaLblgZ8Pq6kQUX9vl5eXuQcnDp1KsMwDJOSksIsX76cuXz5Msfq5JP4+HhGIBAwAJgGDRoUeR/Bh+Pq+fPnTOfOnRldXV1GVVWVqVevHuPi4sK8f/9ebL3Y2FjGwcGBUVdXZ3R1dZkpU6Ywv379KtW+yvt9nZycyPHq6OhYpm1QCmbTpk1MQEBAqf+nfIAP55Es4fv3tbe3J+dpUlISef3PP/8kr1+8eJFDhSUjIiKC6B04cCDXchiGYZjk5GSmb9++zPz58xk/Pz+ir3PnzuXetjSOKyVZBHn4zunTp8l8cnIy1q1bh/DwcNSqVQvTpk0T68RRWYmJiSFlRLa2tiVKvZ4/fz6J5Lq6uqJu3bpS1Sgpxo0bh8DAQABCM9527doV+5nbt2/j8uXLiIqKwqlTp6QtkVLBkafyo4MHD+Lz588AgIEDB0q8w0CvXr1otgFF5rDLj8aMGQNAmIa9aNEiriTJPbVr10anTp0QEBCAV69e4dGjR2jdujXXsgqlSZMmuHnzZrHrGRsb48KFCzJQVDBXr14lvjo6Ojrw9PTkTEtFhPr7USSFjY0Naef8+PFj0shj1KhR5Fl0//796NOnD2caf+fr16+Ij4+HtbU1lJSEYQO++b8Awt++8+fPk2VXV1e8f/8ejx49Qm5uLhQVFTlUl59KW4Lk6uoKY2NjsdcyMjJgY2OD9evX49KlS8SMNyoqiiOV/CEvLw/Dhg2DiYlJiQx47927R9K3DQwMMGfOHGlLlBiDBg1CtWrVAADHjh1DampqsZ9ZtGgR1qxZg9OnT+Pdu3dSVkip6LDbnPI5AJObmwsPDw+yPG/ePA7VUCiSITw8nNToN2vWjJgkUsqPqO0qgBL761EKJyMjAy4uLmTZw8OjSPNfCoXCHaJOSIB4GVLv3r1Ro0YN1KxZU6zsmg+cPXsWLVu2hLa2No4cOQKAf/4vBSEK7qenp/OyfL3SBmDu378PR0dHsde2bt2Kd+/eYcaMGfj27Rvu37+PKlWqYM2aNRyp5A8WFhbw9fXFmzdv4ObmVuS6DMPA1dWVLC9btkyuapHV1dVJrfrPnz/JD05RsNtRs7tcUSilJTY2FqGhoQCEIwuiLkB85MyZM8RMs3PnzmI3FxSKvMLOfunbty81f5YggwYNgqqqKgDAz88P2dnZHCuSb6KiovDjxw8Awk5dbENPCoXCLwrqhAQIm4Dcvn0bcXFxvOsSe+/ePQDCYK8ocYFPLagLo02bNmQ+ODiYQyUFU2kDMG/evMmXNnX+/HlUr14d69atg5aWFmxtbTFr1izcunWLG5E8pbg0rhMnTpCOSZaWliR9W55gm/Hu3r272PXZAZirV69KRROlcsBOoRwwYACHSoqGYRisXbuWLEsz+yU3NxevX7/GhQsXyMMGhSINsrKySAc8FRUV3L59G/Xq1cPs2bORnp7OsTr5R1tbG3379gUgTG2/fv06x4rkmxYtWiAyMhITJkzAzp07aWcuKfH69Wts3boVf/75Jz58+MC1HIqcYmZmRpqusDshAYC5uTkp8eETopIpFRUVtGzZUsyAt169erww4GWTl5eHmJgY1KxZk7zGRyPeShuA+fbtm9g/JycnB48ePUKnTp3EAgzNmzcXay9IKZrMzEyxDJl169bx8gelOJo1a0aiuk+ePCE/NoXRsmVL0vbsxo0bcuFiTuEn8lJ+FBQUJFamwQ5CSppJkyahQYMG6NevH168eCG1/VAoFy9eJBkvnTt3xu3bt/Hjxw+cPXu20NbElNLB7oYk8i6hlB1dXV3s3LkTZmZmXEupsOzfvx9Tp07FmTNnSuQLRKEUhIKCAnm2eP/+PRISEjhWVDSJiYmIjo4GIHzOUVNTQ3R0NDIyMshrfOLt27eoWrUqzMzMcPbsWSgoCMMcNADDIwwMDMQCK0+fPkV2dna+rBgFBQWSLltZSU1NJSdbcWzfvh1v3rwBAHTp0oVXRlKlhZ0Fs2fPniLXVVRURLdu3QAIg3t87TtP4T979+7Ftm3b4OzsjCZNmnAtp1D27t1L5qdPny7VkVf2gwUfa3kpFQd2+ZGGhgaZnzp1qlwOJvCR3r17Q1tbG4CwCQLNLKLwna5du5J5GoChlAf2cya7lIfN+/fveXGcibJfAMDe3h4Av/1f6tSpQwbAIyIiSBOd8PDwEj/HyopKG4Bp2bIlvL29wTAMAOEojEAgEPuRBYCXL1+KZcpURrZt24Zq1aqhRYsWRUYRU1JSsGzZMgDCHuweHh5ynQ47bNgwqKurAxCaBf78+bPI9dkZAP7+/lLVRqm41KlTB5MnT8bBgwd5e/5kZGTg6NGjAIAqVapgyJAhUt0f25RUDBEnAAAgAElEQVSOBmAo0uLTp0+4dOkSAMDIyIh0w1NVVYWzszOX0ioUqqqq+OuvvwCAZBdRSs6bN2/w999/8370vCJha2tLMuBu3LhBnh0olNLCDsD8XobEMAz69+8PY2NjODk5cZ5Nzw7AtG3bFgC//V+UlJRgaWkJQOiPJdKXm5uLp0+fciktH5U2ADNv3jwEBATA3Nwc9vb22LJlC9q1a4cWLVqIrXf+/PlKbyz54MEDUvMnKrMpiJUrVyIlJQWAMMW4efPmspIoFapVq0ZuElNTU0lXp8KgARhKZeHkyZP4/v07AGDo0KHQ1NSU6v74FIC5evUqWrdujYULF+Lly5ecaqFIlkOHDiE3NxeAsFtFcnIyAGDw4MHQ1dXlUlqFg3ZDKhsMw8DFxQU+Pj5o1KiR2AMSRXqoqamhXbt2AID4+Hi8evWKY0UUeaWwTkiAcPBaRUUFDMMgISGBc09JkQEv8L8MGD4HYADA2toagNALht3Egm9lSJU2ANOmTRucPXsWRkZG+P79O8aNG0d6sItISEjA+/fveW2EKW0YhiGGurq6umjYsGGB6719+xZbtmwBILxQrVixQmYapUlpzHiNjY1hYWEBQOiPUZL21RSKPMIu05CFyXbdunXJ6CMfAjCPHj3CqlWrqB9NBYJhGLHjml2iPGHCBC4kVWjatWsHU1NT9O3bVy6N+rnCx8eHdFqsWrUqr8tUKxrsDHnanINSVkxMTMhg9uPHj/NlU40aNYrM79+/X4bKxMnKyiIZOqampjAwMBDLJOGjAS/wvwAMADELEb51Qqq0ARgAcHBwwK1btxAWFoZdu3blG+EyNDTEs2fPMHjwYI4Ucs/r16+RmJgIQJiCWVhJxIIFC5CVlQUAmDFjBmlVJu+0bdsW5ubmAIDAwEBiRlUYoiyY3NxcBAQESF0fpeJw//59zJ49G7dv3+Y87bQo3rx5Q24+zc3NYWdnJ/V9KioqkvPw9evX5LeGC0RdWxQUFNClSxfOdFAkS1BQEMlosrGxITdr5ubmaN++PZfSKiQKCgqIiIjA+fPnpV7CWFFITEzEzJkzyfK2bdtIRxWK9BFlwAD8G02nyA8CgYCUIX3+/Bnv378Xe79nz54wMDAAAJw7dw5JSUky1wgAISEhyMzMBPC/7Bd223s+Zr8A4gGYpKQkkqHNt3O2UgdgKMXz4MEDMl/Yg1ZwcDD8/PwAAPr6+mJdkOQdgUAglgXDNh4tiIEDB2Ly5Mk4c+ZMPj8hCqUojhw5go0bN6Jjx475svH4BHtEZvTo0TLzqRGVIeXm5nKW/p2QkICwsDAAwof0okoyKfIFO/uFPao3YcIE3noxyTsqKipcS5ArZs2aRQbEhgwZgn79+nGsqHLRokULYsQtygynUMpCUWVIysrKpFNcVlYWjhw5IlNtIr58+UI8UOWl/AgQD8CEh4cTnXFxcbzyzaIBGEqRFBeAYRgGrq6uZNnd3R3VqlWTiTZZMWLECCgrKwMQ3qQXNfresWNHbNu2DQMGDKAjU5QSwzAMzp07B0B48e3ZsyfHigomNzeXBGAUFBRkakzKBx8YXV1dXLt2DfPmzcPo0aM50UCRPBkZGWQQQVNTk6Rdq6ioYMSIEVxKo1AAANeuXcOhQ4cACP3pNm/ezLGiyoeGhgaaNm0KQNhhhZaZU8oK24i3oK6pI0eOJPNclSH169cPHz58wLt374gfJjsA83vXYL5gYGCAGjVqAADCwsLQpk0b8h6fypBoAIZSJKIAjEAgKNCM+OzZs7hz5w4AYavYilgrX6NGDeID9OXLF/KgTKnYyLJl3bNnzxAXFwcA6Ny5M7S0tGS279Jw8+ZNxMfHAxC2kjUyMpLZvvkQgFFRUUG3bt2wZs0auLi4cKKBInnYptKDBg3CnDlzUL9+fQwaNAj6+vocq6NUdn78+CH2e7N+/XoYGhpyqKjyYmtrC0A4aPJ7BxsKpaQU1QkJAJo0aUIyN548eUIyb2WNQCBA3bp1iUUHO1j0e9MaPiHKgvny5QvMzMzI63wqQ6IBGEqhZGRk4Pnz5wAAKyurfA+F2dnZmDdvHlleu3YtyRSpaEycOJHM79ixg0MlFGnCMAyuXLmCnj17ws7OTmatJtlBPT6bfrNL8GSdASIKwGhqahbbEp5CKQ3s8qMJEybAzc0NMTEx8PLy4lAVhSLE3d0db968AQB06NABY8eO5VhR5aVHjx4YNmwYNm3aRHzJKJTSUrt2beLzUpARLyB+j3XgwAGZaSsMUTdcgL8GvCJEmWp6enokGwagARiKnPDo0SPk5eUBKLj8aNeuXcSUtn379rx+cCwvXbp0gampKQDgxo0bxXpQfP78GYcPH8amTZtkIY8iIQQCAZYvXw5/f3+EhYXh5s2bMtnv2bNnyTxf6/pTUlKIN42+vr7MdVpYWCA2NhZpaWlYuXKlTPdNqbiwTaXNzMxIrbuCggK0tbU5VEahADExMdi4cSMAYQberl27oKBAb925on///vD19cW0adNQp04druVQ5BS2EW9KSgrevn2bbx1HR0fik3Xo0CFkZ2fLVOPvsA14+Vp+JGLatGl49eoVvn79in79+hEvG/ZzLdfQX3FKobDT/EVplyJSU1Ph7u5Olj08PCq0UaGCgoJYFsyuXbsKXZdhGFhbW8PZ2RmLFy/m/EeTUjpmzJhB5kU3vtIkPj6etPVr0aIFb2/qjhw5QhzxnZycZG6gqaSkBGNjY84ePi5duoQdO3bg9evXnOyfIh24MpWmUEpCgwYN4OvrCwMDAyxatIhmXVDkmszMTDRr1gwCgQChoaFi78XFxaFfv37Q1NSEvr4+pk2bxmnHQ2nDDmKw/TZF6OnpYcCAAejQoQPWrFkjs4xsAJg5cybs7Owwe/ZsfP36FYB8GPCKMDY2hqmpKQQCAQQCAVq3bg0ASEtLQ1RUFMfqhNAADKVQJk2ahKSkJFy+fBm9e/cWe2/t2rXEjd/R0ZEc3BWZUaNGkYfOffv2kYfR3xEIBKQDUlpaGu7fvy8zjZTy06VLF2IkfenSpWJbj5eX8+fPk/n+/ftLdV/lgV2mURkNaLdv345JkyahQYMGePHiBddyKBKAbSotEAiQkJAg9fOdQikNAoEAf/31FyIjI8VKvikUeWTu3LkFesfl5ubCwcEBGRkZuHv3Lvz8/HDy5EnMnj2bA5WyoUOHDmT+xIkTBa7j4+ODwMBAjB49WqaDXgEBAQgKCoKnpydUVVUBiPu/8D0A8ztsI16+lCHRAAylSHR1ddGrVy8xw7f4+Hj8999/AIQpsatWreJKnkypXr06Bg4cCABITEzEqVOnCl2XHbDasGGD1LVRJMerV6/EuhtIu4yMXX7E1zK+sLAwcvFt0aIFqa+tLGRnZ5MyFQMDA1haWnIriCIRbty4QUylmzdvTnwdli5dyrEyCkUcHR0d2rabR/z48QN37txBREQE11LkhsuXL8Pf3x8eHh753vP390dERAQOHz6M5s2bo1u3btiwYQO8vb2RlpbGgVrp07FjR+IDc+nSJaSkpORbhwtfzbS0NGL626RJE+L/yc6A4bMBb0HwsRMSDcBQSs2iRYvw69cvAMDUqVNhYmLCsSLZwe5EsHPnzkLXGzJkCGrXrg1AmOHAlxOeUjxt2rQR8zzas2dPgRdGSZCWloaAgAAAwpRJvgY22NkvY8aM4UzHq1ev4OrqCgcHB5m2ZgwKCkJ6ejoAoFu3brRMpYLAPq5zcnLIfNu2bbmQQ6FQ5ID79+9DS0sLHTp0oE0ZSsjnz58xfvx4HDp0CBoaGvnef/DgAaysrMSyY3r27InMzEyxB/+KhKKiIhwdHQEAWVlZRQ7qypLg4GDikyK6FrINeE1MTHhtwCsiKioKbm5u6NSpE2JjY8l9G82AocglT58+xaFDhwAIR2QWLlzIsSLZ0qFDB1hYWAAAAgMDC22Hq6amJva3Wbx4sUz0USSDm5sbmc/MzMSePXuksh91dXWcO3cOLi4uGDt2LC8f7LOyssg5r6KigmHDhnGmJTk5GRs2bMClS5dw7949me33+vXrZL5bt24y2y9FerBNpXV0dEjHv/r166NLly5cSqNQKDzG0tISubm5AITBeUrRMAyDUaNGwcXFpVDz1oSEBJINIkKU9ZWQkFDotjMzM5GWliY2yRNOTk5k3tfXt9D18vLycOvWLfz7779S18S+txKZ0rMNeOWl/OjDhw9Yu3YtAgMD8ejRI9JJ8/nz57zopEkDMJQCWb16NcaOHYvdu3eTkV9A+GAqMoJavHgxdHR0uJLICQKBABMmTCDLRZnxjhkzBvXq1QMAXL16VaYPjJTy0bdvX/K/A4Qm0+wRckmhrKyMXr16Yfv27bwN0l28eJH4Pf3555/Q1dXlTIso+Amg0OCnNLh27RqZ7969u8z2S5EebFPpBg0akNfHjx9Pu8xQKJRC0dbWJg9zISEhvHiY4wJ3d3diclrY9PjxY2zZsgVpaWmYP39+kdsraACKYZgiB6ZWr16NatWqkYmvTQwKw8bGhlx/AgIC8PHjxwLXGzx4MDp37owVK1bg2bNnUtXE9q0UBWDk0f/FxsZGLOtFVIaUk5NDsnm4hN5lUArkxIkT2Lt3LyZMmEBS0e7cuUMeRExMTDBp0iQuJXLGyJEjiSnVgQMHCr34qqioiEWrZRG5pkgGBQUFsZuFz58/k9HyysbevXvJPJflRwCgpaWFWrVqARAGYGTRFSA1NZWUEDZq1IjsnyLfsI9rUQtQJSUljBo1iiNFFApFXhB1BuXLwxwXTJkyBZGRkUVOVlZWuHnzJoKCgqCqqgolJSUScLCxscHIkSMBAIaGhvkyXVJSUpCdnZ0vM4bN/PnzkZqaSiaRp5e8IBAIMHz4cADCYNPRo0cLXI+deXvgwAGp6UlKSiJZXTVr1iQDkewyML63oBahpaVF/PqeP3+OZs2akff4UIZEAzCUfGRkZJAIa+PGjYkBE3uEfsmSJSQIUdnQ1dXFX3/9BUB4gTh+/Hih644YMUIsui3y+6DwH2dnZ2hra5PlNWvWcKiGGz59+oTLly8DAGrXrk26e3GJaOQxOTmZtEeUJrdu3SLp5rT8qGLw/PlzckNZv359kuE1YMAAMcN5CoVCKQhRAAbgx8McF+jr68PCwqLISU1NDZs3b8azZ88QGhqK0NBQXLp0CQBw9OhRrFy5EgBgZ2eH8PBwfPr0iWzf398fqqqqRWZcqKqqQktLS2ySN9hl3YWVITk6OhIT7sOHDyM7O1viOtatWwdjY2NSxmVvb08ySOTVgJed9VK1alXyOh/OWRqAoeTj8ePH5IFDZEZ68+ZN0gWkYcOGYnWLlZGJEyeS+aLMeJWUlLBkyRIAgKamJhlppfAfdXV1zJgxgyw/ffpUombK+/btw759+2QSRCgrhw4dIr8Fo0aNgqKiIseK/heAAWRThkTLjyoebPNdNTU1Ms8uL6VQKJTCYHdVoT4wRWNsbAwrKysymZmZAQBMTU1Js4oePXrA0tISzs7OCAkJwY0bN+Dq6orx48fLZVClNFhYWJCgxuPHjxEdHZ1vHV1dXdIl8+vXrzh37pzEdejo6BCfFyUlJYwbNw5AfgNeLsvQSwv7PE1MTIS6ujoAfnRCogEYSj7YFxM7OzswDJMv+0VJSYkLabzB3t4eVlZWAIT1kqKWbQUxbNgwrFq1Cm/fvuW8hINSOv755x+xNoDr1q2TyHYZhsGyZcswZswY1KlTBxkZGRLZriRhGEasTIMvpRlcBWCUlJTQqVMnqe+PIl2ysrJw+PBhAMIyUdExVK9ePZrhRKFQSkTjxo2hqakJgAZgJIGioiIuXrwINTU1tG3bFn/99Rf++OOPAltWV0REZUiA0J+sINj3YIMHD4a1tTVcXV3h7+9P/MxKAsMwuHbtGqKiosRed3Z2Rv369TF16lRER0ejV69eAICXL1/KnQGvCHYA5tGjRyTQ9fbtW84HP2kAhpKPBw8ekHlbW1v4+/sTA9lGjRqRtmmVGYFAUOIsGEVFRcyfPx/Vq1eXhTSKBNHX1xe76J05cwbv378v93bDw8Px7t07AED79u3JjRyfCAoKIhfojh07wtTUlGNFQmRpxJuXl4fJkyejb9++6N69u1gKK0U+uXDhAik5MjMzIz5C48aNo+a7FAqlRCgpKaFVq1YAgLi4OLHSGUrR1KtXDwzDiHlyAMJMmQsXLuDHjx9ISkrCli1bKo3VwdChQ0m5j4+PT4H+dj169ICJiQlZDgsLw4YNG9CzZ09yTSuKnJwcHDlyBC1atECPHj1I+ZcINTU1REVFYfPmzWL7kUf/FxHsQCnbiBfgPguG3m1QxGAYhgRgtLW1YWZmJpb94u7uzosyBD7g7OwMDQ0NAMJSDT5mMVDKz/Lly+Hq6gpAmIrp5eVV7m2ePXuWzIvSSvkGO/tl9OjRHCoRR5YZMAoKCpg+fTrOnz+PixcvSnVfFNnAPq7XrFmDEydOoGfPnrw6xikUCv+hPjAUSVG7dm107NgRABATEyMW9BChpKSEgIAALFiwAK1atSIBm8aNG+drDrB06VL8/fffOHjwIN68eYOtW7eiYcOGGD58OEJDQwEIM23i4uLy7eN32FrkLQNGSUmJBI3i4uJgbm5O3uP6nKUBGIoYb9++xZcvXwAILy5XrlwhUcImTZpg8ODBXMrjFdWqVSPZQGlpafDz8yvR51JSUrB582aZdHChlB8DAwPMmjWLlCLt3LmTpGOWhQ8fPmDLli1kuX///uXWKGkyMjKIG3+VKlV4dd4bGBgQc2RZtqIuqhUmRT74+PEjMZWuU6cOevXqhUGDBuHKlSswMjLiWB2FQpEnRAEYMzOzUpWAUCgFwS5DKsyMt27duli5ciWCg4Px9etXHDt2TGyQXISfnx98fHwwcuRImJqaYurUqSTrGhBmsvj6+paoqyO7BbU8GfCKYGe9sKEBGAqvYNeytmnTRuzEXrp0KU3R/o2SliGJOHDgAExMTDB9+vRK29ZYHqlZsyYJtiUnJ+PQoUNl2k52djaGDh1Kgpz9+/eHsbGxxHRKipMnT+L79+8AhKmxfCqREggEGDt2LGbPno2lS5fSQCalxOzduxd5eXkA+GMqTeE3ot9oNTU11KxZE87Ozvj48aPYOgKBIN+0Y8cOjhRTZEWPHj2QlJSEqKgoDB06lGs5FDln0KBBZKDPz8+PNEAoDD09PQwZMoR0ZRWRnJxcaKl8r169cPPmTQQHB2PIkCHFXgNzc3NJxoy8GfCKcHBwwKxZs3D06FH8+eefqFGjBgBhCRKX94/0aZoiBtv/BRB2fgGA5s2b448//uBCEq9p1aoVmjdvDkBo8CT6exVG9erVkZqaCkBoZix6GKDwH3ZHpJUrV5bpfzdv3jzip2RsbIw9e/ZITJ8kYXeJ4aNxtIeHBzw8PDBmzBipZaa8f/8ed+/elUq7R4rsyc7OJg/FCgoKvDyuKfyjc+fOOHbsGKKionDy5Em8fv26wIzAffv24dOnT2QaOXIkB2opskRdXV0uH0gp/ERXVxd9+vQBAHz69AmBgYFl3k5SUhJu376NRYsWoVu3bhgzZgyePXuGy5cvo3PnziW+b2Ib8Mqb/4uIDh06YMOGDfjrr79QvXp1khHz7ds3xMTEcKaLBmAoYowcORIrV66Eg4MDjh8/Tl5ftmwZTcEvgNKY8QJA7969yckfHh6OY8eOSVUfRXKoqKiQ0YL4+Hix9sQl4fjx4/jvv/8AAMrKyjh+/Dj09fUlrrO8vHnzhrScNzc3J63oKxtHjhxB+/btoauri/Pnz3Mth1JOzp49iw8fPgAQlgzMmDEDly5dKnaUkVK5mTlzJmxtbVG3bl3Y29vDzc0NQUFB+QKz2traMDQ0JJOo3SmFQqGUlJKUIZUEFRUVtG/fHsuXL8e1a9ewZ88eWFtbl3o78uz/UhitW7cm81yWIdEADEUMGxsbLFiwACNHjkRERAQA4cHq4ODAsTL+Mnz4cFSpUgWA8AdTVLpREAKBAMuXLyfL7u7uyMnJkbpGSvlp1KgRSV0EhEHJkvLt2zeMHz+eLG/atEnsIsAn9u/fT+ZHjx5daQOvogBbeno6zMzMOFZDKS9bt24l80lJSTh79iz69etHu5dQSkxycjJ8fHxgb29PSgVETJkyBfr6+mjVqhV27NhBs1srIbQcllJe+vbtS54nTpw4wbm3ENv/paIEYPjSCYkGYCTM9u3bYW1tDS0tLWhpacHOzo6Y/gHCH2h3d3cYGRlBXV0dnTp1wosXLzhUnJ/c3FwsWbKELNPsl6KpWrUqnJycAAgf1oqLWnfr1g3t27cHAERFRZU5yh0TEwNjY2M4ODhw3s++MqCoqIiFCxeS5fv375fYBFZbWxtHjx6Fnp4enJyc4OLiIi2Z5SI3N5cEYBQUFODs7MytoCJgGAZxcXGkPlmS/Pr1C3fu3AEgNGulARj5JiwsjKRz16pVi/xeOjg4oHbt2lxKo8gB8+bNg6amJvT09BAXFyfWxQ4Qdso7fvw4rl+/DkdHR8yePRurVq0qcpuZmZlIS0sTmyjyR2JiIsaPH48mTZpg3LhxXMuhyDkaGhr4888/AQCpqaliz49cUFEyYBiGQWxsLI4dOybmZcqpES9DkSjnzp1jLl68yERFRTFRUVHMggULGGVlZSY8PJxhGIZZs2YNU7VqVebkyZNMWFgYM3ToUKZmzZpMWlpaifeRmprKAGBSU1Ol8h18fHwYAAwApm3btkxeXp5U9lORePr0KfmbNWvWrNi/2a1bt8j69evXZ7Kyskq9z7y8PMbBwYEBwJiamjIxMTFllc8wjPSPK75Rlu+bkZHBaGpqkv+dk5NTqfYZFxfHpKenl1aqzPD39yffzcHBgWs5hZKXl8dUr16dAcCYm5tLfPvXr18nf4fRo0eX6rP0POIfEydOJP/PJk2akPnz589zLY1SCNI8rpYsWUKOgcKmR48ekfW/fv3KREVFMf7+/kzbtm2ZPn36FHmN9/DwYLS0tMqkgc/nESU/P3/+ZJSVlRkAjIWFBddy8iEPv8+SpCJ838uXL5PfgyFDhnCmIycnh9HQ0CDPKfLMnTt3yN90woQJjLm5OQOAUVZWZn7+/Fns56VxXNEAjAzQ0dFhdu/ezeTl5TGGhobMmjVryHu/fv1iqlWrxuzYsaPE25PWD8zFixeZhw8fMg0aNCAH6o0bNyS6j4pMq1atyN/t4cOHxa7ftWtXsr63t3ex6+fk5Igt5+bmMgsXLiTb0NfXZ4KCgsqsvyJcuEpDWb/vvHnzyN9cSUmJSUxMlJJC2ePo6Ei+24kTJ7iWUyRNmzZlADCKiopMZmamRLfN/h/7+vqW6rP0POIXKSkp5CZSQ0ODUVBQYAAwtWrVYrKzs7mWRykEaR5XX79+ZSIjI4ucCrspj4+PZwAw9+/fL3T7d+/eZQAwCQkJha7z69cvJjU1lUyi7fL1PKIUTuvWrcn1Ijk5mWs5YvD991nSVITvm5WVRQaY1NTUOPsu4eHhvAgESYLv37+Ta3/Tpk2ZESNGkO9WkucmaRxXtARJiuTm5sLPzw8ZGRmws7PD27dvkZCQgB49epB1VFVV0bFjR9y/f59DpcL0rDFjxqBNmzZ49eoVAKBTp07o0qULp7rkCXZZSUlaUrO9YJYvX46srKxC1w0JCYGNjQ0uXLhAXlNQUICLiwusrKwACFNhO3funC89miJZZs2aRcx4c3JysGXLlgLXCw4Ohqenp9zUhaekpJDW6Pr6+ujXrx/HioqmUaNGAIS/s6LfLEnBNlju2rWrRLdNkS379+8nXRysrKyIN8fYsWOhpKTEpTQKR+jr68PCwqLISU1NrcDPin7Pi/JmCAkJgZqaGrS1tQtdR1VVlZSqiyaKfGJra0vmufSUoFQMlJWVSWvpX79+4cyZM5zoqEj+L1WqVCHPSmFhYWjWrBl5j6syJBqAkQJhYWGoUqUKVFVV4eLigtOnT8PS0hIJCQkAAAMDA7H1DQwMyHsFIYta4Xfv3uHz589ir5XGZJQCDB06lNxEHTlyBN++fStyfTs7O/Tu3RsAkJaWhvDw8Hzr/Pr1CwsWLECrVq0QGhoKFxcX0sYaAGrXro07d+6gc+fOAICfP39i4MCB8PLyktTXovxGjRo1MGTIELL833//5euIkZiYiCFDhmDmzJn466+/kJGRIWuZpYJhGKxevZo8VDg5OUFFRYVjVUUjCsAAKLEXT0lITExESEgIAKBp06ZixssU+SIvLw/btm0jy+/evQMgDF5TvwZKcQQHB2Pr1q0IDQ1FbGwsAgICMHz4cJiampLucOfPn4e3tzfCw8Px+vVr7N69GwsXLsSECROgqqrK8TegyAJ2ACYoKIhDJZSKArsbko+PDyca2P4v8tqCmo3IfDcvLw8aGhrkdRqAqUCYm5sjNDQUQUFBmDRpklhHIQD5DG0ZhinS5Hb16tWoVq0amerUqSNxzQ8ePBBb7t69OzGKpZQMTU1NjBgxAoAwEHL48OFiP7N8+XIsXrwYb9++RYsWLcTeu3fvHpo1a4bVq1eTVqm6urr48uWL2Hra2tq4fPky+cHOy8vDP//8Azc3N9qJQUq4u7uT+bS0NPj5+ZHl3NxcODk5IS4uDgDw6dMnXgczcnNzMXXqVKxfv568NnbsWA4VlQxpBWBu3rxJRrm7d+8use3yGS8vL5iYmEBNTQ0tW7YkBsTyjr+/P8mOsra2Jr+d/fv3l8p1lFKxUFdXx6lTp9C1a1eYm5tjzJgxsLKyQmBgIAmuKCsrw8vLC3Z2drC2tsamTZuwbNkybNiwgWP1FFnB7qpCAzAUSWBnZ4d69eoBAK5fv55vgFwWsAMwvz+fyCPs8zQpKYn8hnOWtSaxYiZKoXTt2pWZMGEC8/r1awYA8/TpU7H3+/fvz4wYMaLQz8uiVnjy5MliRnBF1TdTCicsLIz8Da2srCv3cRsAACAASURBVMpkYPz9+3dmypQpjEAgINtSVlZmli5dWqTXRW5uLuPm5ib2f3RycmJyc3NLtN+KUDtbGsr7fdu2bUv+zpaWluR/zTZXrFGjBvP+/XtJypYoP3/+ZAYPHix2zHh4eHAtq0Swz7Xhw4dLbLvjxo0j27169WqpPy9v55Gfnx+jrKzMeHt7MxEREcz06dMZTU1NJjY2tkSf5/P37dOnD/lfWltbk3l/f3+upVGKgc/HlTSobN+3IsE2hdfR0eFV44rKdlxVpO87f/58cs3avHmzTPednZ3NqKurVwgDXhHse8aBAwcydnZ2ZLk4L0fqASOnMAyDzMxMmJiYwNDQUMxfICsrC4GBgbC3ty/087KoFWZ7i3Tr1o2k11JKh5WVFflfhoeHl9rbx9/fH1ZWVti6dSsZhW/Tpg1CQkKwePHiIjMpFBQUsHr1amzbto20WWvYsKFYyzWK5PDw8EDNmjUBABEREQgKCsKVK1dI6Z6CggL8/PxQq1YtLmUWSmpqKnr37o0TJ04AELbZPnDgAGbPns2xspLBPrYlmQFTs2ZN1KtXDyoqKmjXrp3EtstXNm7ciLFjx2LcuHFo1KgRPD09UadOHWzfvp1raeXi1atXpIVn7dq1oampCUB43FBfHwqFIikEAgEpQ0pJSUFMTAzHiigVAXYZkq+vr0z3/fLlS/z8+RNAxSg/AoRZ01WqVAEgLDtq3bo1eY+LLBj6ZCZhFixYgDt37uDdu3cICwvDwoULcevWLTg5OUEgEGDGjBlYtWoVTp8+jfDwcIwaNQoaGhpiJ5qsSUlJIeUSgLDkiVJ2SmvGK+Lbt284evQoYmNjAQjTnzdu3Ih79+6hcePGJd7O5MmTcerUKfzzzz9YvHhxyYVTSoWtra3YubJy5Uo4OTmRwNnKlSuJNw/f+PjxIzp06IBbt24BADQ0NHD+/HlSQicPqKqqwtTUFIDwZkFS5XbLli3Dmzdv8PbtW7E64YpIVlYWnjx5ImYMDwA9evQoNHgsC08ySbB9+3ZyLk6ZMgX3799HSEgIvLy8aFCaQqFIFOoDQ5E0VlZWsLa2BiA8pt68eSOzfbPLj+TdgFeEoqIiWrVqBQD48OEDGjZsSN6jAZgKwOfPn+Hs7Axzc3N07doVDx8+xJUrV4iXwNy5czFjxgxMnjwZNjY2+PDhA/z9/VG1alXONLP9LIyNjStMtJMrBg8eDB0dHQDAsWPHijRYFsEwDNavX0+8RLp06YLw8HDMnDmTdNwpDQMGDMDWrVvzeQulp6eXelt8hmvvCkdHR2LSevHiRSQnJwMAGjRogKSkJMycORNTpkzBxIkTMWbMGDg7O8PR0RGDBg3CwIEDsXz5coSGhsq0U1JUVBTs7e3x/PlzAMKOIAEBAcQQWp4Q+cD8/PlTLIhcXgQCAYyMjCS2Pb6SmJiI3NzcUhnDy8KTrLxkZGRg7969AISBOpGnUbNmzdCtWzcupVEolAoI9YGhSAP24PyRI0dktt+KGIABxM9T9kAMJ0a8EitmosgMSdaiZWRkMFWrViV1cP/++68EFFJmzJhB/qampqZMREREsZ/ZvHkzY2try3h7e0ulhvjmzZuMvr4+c/369QLfl7faWb54V7i7u4t5qJRlql27NuPi4sJcuHCB+fHjR7n0FEVQUBCjp6dH9luvXj0mKipKavuTNvPmzWMAMGpqaszt27e5lsMwjHydRx8+fCjQ82vFihWMubl5gZ+RhSdZedm1axc5xkeNGsW1HEoZkKfzSBJUtu9b0UhNTWVWrlzJ3Lhxg1f/w8p2XFW07/vu3TtyLWvUqJHM/IXY/ijJycky2acsOH36NKOpqcl07NiRuXDhAqOvr88AYPT09Ir820rjuKIBGDlEkgeCh4eH2INgeHi4BBRS3r9/zxgaGpK/q5aWFnPlyhXO9ERGRjJaWlrEHDgnJyffOvJ24WrdujXj4uIi9pqFhQXj5uZWos9L6vu+fPmSUVNTK3cQRjSpq6sz/fv3Z3bt2sV8/PixXNrYXLx4kdHQ0CD7adq0qUS3zwXx8fHMq1evCjyeS0tOTk6xRmwlQZ7Oo8zMTEZRUZE5deqU2OvTpk1jOnToUKJt8O375uXliRnu7t+/n1emmJSSwbfjStpUtu9LkQzh4eGMp6cn8/379wLfr2zHVUX8vu3atSPXs9DQUKnvj23Aa2pqKvX9yZKsrCyx+0W2Uf+rV68K/Rw14aVIlA8fPmDNmjVkuUqVKmKtXSllp1atWggODkazZs0ACFsV9+nTB1u2bJFpuYkIY2NjdOzYEQYGBjh37lyZypr4BJ+8K2rXrg1TU1MoKytj9uzZuHLlCm7cuIHbt2/jwYMHePToEUJDQ/HixQtER0fj7du3eP/+PaKjo+Hl5YXevXuTdniAsJzm3LlzmDBhAoyMjGBjY4OlS5fi6dOnZT529u/fj/79++PHjx8AgM6dOyMwMJCYCMsror+9JI7nJ0+eoHr16rCxsZFpqi+XqKiooGXLlmLG8ABw7dq1Io3h+czdu3dJeZ2VlRVGjRqFJk2a4OTJkxwro1AoFMmyZs0azJgxA8bGxrT0qYIiazNetgFvRSo/AgBlZWWx+0V2SZKsy5CUZLo3Cm9ITExE9+7dkZiYCEDoZbFlyxZqTihB6tSpg7t378LZ2RmnT59GXl4epk2bhsjISGzatAnKysoy06KhoYHTp08jNjYWJiYmMtuvtCird8XSpUslrkVTUxP/196dh0VV738Af8+ALCKbgGySIO5XDW4i4AJmqblCFoYparnk3nVPMiUU5WrpL0txeVwSzeuaKO5Q2XUJBYVcyIuhgghqaiIq63x/f/BwYgRMGGYGZt6v5znPw1nmfD/DzGdgPud7vt9ff/0Vz549k2ZaeVktW7bEhAkTkJeXh/j4eBw4cACxsbG4c+eOdExSUhKSkpIQFhaGxo0bo23btmjXrh3atm0rLS4uLpXmrhAC//73vzF37lxp25AhQ7Blyxalog+VFh2EEEhKStK5sZJeZPr06QgJCUGnTp3g6+uLdevWISMjQ2kw8frkm2++kX4uG4vr8uXLePTokbZCIiKqdTdv3pQuFsjlcnTo0EHLEZE6BAUFYerUqSguLsb27duxZMkStX5X09XxXypTfiakhIQEjU6IwwKMHsrNzcVbb70lTd3avHlzrFixAra2tlqOTPeYmZlh9+7d+Oyzz7B48WIApbNz/O9//8POnTvRuHHjWmmnuLgY9+/fx7179yosf/zxR4VtU6dORWhoaK20rU3PDzIshKiwrczcuXMxffp0aT03N7fWBhCVy+XVLr6U16hRIwQEBCAgIAAKhQJJSUk4cOAADhw4gOTkZOm4Bw8e4NSpUzh16pTS4xs2bIg2bdooFWXatm2LNWvWYOXKldJxU6ZMwf/93/+x0FqJuLg46Wd9Gqj1vffew/379xEeHo7s7Gy0b98ehw4dQrNmzbQdWrVlZWVh7969AEoHly6b2cDKygrBwcHaDI2IdJxCoUBycjISEhJQXFyMKVOmqLW9O3fuoG3btrh06RImT56s0v8gVHfZ2tqid+/eOHToEDIzM3Hq1Cl0795dbe0lJiZKP+tyAUYIgfbt20vrmp4JiQUYPfPs2TMMGjRIqnA6OTkhLi4ODg4OWo5Md8nlckRERKBNmzYYM2YMCgsLER8fDx8fH8TGxqJVq1bVPmd6ejq2bduGvXv3IiMjQ5p952VlZ2dXu826xNbWFgYGBhV6u9y9e7dCr5gyxsbG9aLXh1wuh5eXF7y8vBAeHo5bt24hNjYWBw8exIULF5CVlVXhMU+fPsX58+dx/vz5Ks+7ePFifPLJJ1UWqOqruLg4xMfHIzU1FevXr4ednV21z/HkyROpqOXu7q4TvcSqY+LEiZg4cWKtn1cIgfz8fJiamtb6uSuzbt06FBcXAyid8aisqPbBBx/o/JTiRKRdQgj06NEDjx8/hrOzs9oLMJ07d8avv/6KQ4cOKV3JJ93z/vvv49ChQwCAbdu2qbUAU74HzD//+U+1taMtWVlZGDduHM6ePYtBgwahZcuWSEtLw4ULF1BYWAgjIyONxMHLoHqkqKgIQ4YMwYkTJwAAjRs3xsGDB/Xuy4a2hISE4Mcff5S+IKalpcHb2xvx8fEv9fj79+9j9erV6NKlC9zd3TF//nwkJydXq/hiYmICFxeXen+lRBfHrqhK06ZNMX78eBw4cAC3bt3Co0ePkJCQgM2bN2POnDkYOHAgWrRoUWWvFgMDA2zatAlz587VueILAMTExCAyMhIxMTG4cuVKjc7x888/o6ioCADQq1ev2gxPb2VlZaFfv34YM2aMRtorLCzE2rVrAZQWMdPS0qR99fV2KiKqPwwMDKRCSFZWFm7duqX2NmUyGfr371+jCw9UfwQEBEgXMnbt2oXCwkK1tJOXlyf1unZ3d5du49Ul1tbWOHr0KP744w8kJCRIOVtQUICUlBSNxcEeMHpCoVBg1KhRiI2NBVB6y8P333+P7t274x//+AfeeecdzJo1S8tR6r4uXbrg3LlzGDhwIC5evIg///wTffr0wTfffFPpl4Rnz54hNjYWW7duxaFDh6Sru2VkMhnc3NzQpEkT2Nraws7OrsJSfruZmZnOfAnXtbErXpaFhQU6d+5c4YpXfn4+0tLSkJqaKi1//PEHZs2ahT59+mgpWvUrP3B4amoq/P39q32O8oU8fbr9SF2Ki4vh5+eH9PR0AMDbb7+Nd999V61t7tmzRxo7qUuXLjh58iSA0tezJr0MiYiqy8fHR7qo9ssvv6j9c4/0Q9lt6v/5z3/w4MEDHDt2DAMGDKi18+fn52PNmjVYsmSJzg7AW6Zhw4bo2LEjLly4gCtXrmDEiBHYtm0bgNLbkLy8vDQSBwswekAIgcmTJ0ujZxsbG2P//v04ffo08vLykJCQgH/84x9ajlJ/NGvWDKdOncL777+P2NhYlJSUYMKECbhy5QqWL18OuVyOEydOYOvWrdi9e3els/W0b98eISEhGDp0aK2NY1Lf6NLYFbXBxMQEHTp00LuB+J4vwNRE2a0qcrkcPXv2rJW49JmhoSHCw8MxfPhwAMCECRPQvXv3Km8PrA3lB98tP1uYOm6tIiKqjI+Pj/Szugowx44dQ+PGjdGpU6daPzfVXcOGDcN//vMfAMDYsWMxbtw4jBkzRqXvAEVFRdi0aRMWLlyo1GPLwMAAI0eOVDnmusrHxwcXLlyAEAKNGjWStickJGDSpEmaCaLWJrQmjanufOShoaHSPOcGBgZi//794saNG6Jhw4YCgJDL5eL8+fNqjpqeV1xcLGbNmiW9NgCEl5eXaNq0qdK2ssXJyUnMmjVLpKSkqCUedcxzX5fp2/PVVdnZ2VKO9OrVS6XHd+7cWeV49O19VdXzVSgUYvDgwdLvNiAgQCgUCrXEkJSUJLXTunVrIZfLBQDh7OwsioqK1NImqRfziOqju3fvSp9FXbt2rfXzFxUViebNmwsAomfPnuLp06cvPF7f3le6/HwLCgqEvb290vcCuVwuBg0aJA4ePCiKi4tf+lzFxcUiOjpauLu7V/iuMWTIEJGamqrGZ6J9mzdvlp5veHi4MDIykv5/qIw63lccA0bHffHFF9LsOwCwefNmDBw4EB9//DGePn0KAJg8eTI8PT21FaLeMjAwwNKlS7FhwwZpSupz584pVaHNzc3xwQcfID4+HhkZGVi6dCk6duyorZCJ6hx7e3tYWVkBAH777bdqP7787Ucc/6X2yGQyrFmzRhqbICYmBtHR0Wppa9WqVdLPzZs3h0KhAACMGzcOhobs6EtEmmFnZ4fmzZsDKB3MtGxssdqyd+9e6dZOAwMDjQ1wTtpnZGSEw4cPIyAgQBrzT6FQYP/+/ejfvz/c3d0RERFRYXKK8oQQ2Lt3Lzp27IiQkBD8/vvv0r4BAwbgwoUL2LFjB9q0aaP256NN3t7e0s9JSUnw8PAAAFy9ehUPHz7USAwswOiw9evXK43r8s0332D48OE4cOAAYmJiAAAODg4IDw/XVogE4MMPP0RcXBxsbGwAlHbfHzhwIHbs2IE7d+5g48aN6NmzJwwMDLQcKVHdI5PJpNuQMjMzkZeXV63HOzs7S0UCjv9Su+zs7LBu3TppferUqcjMzKzVNu7fvy/dXmtpaYk5c+Zg2LBhMDMz09gAwEREZcpuQ8rPz8evv/5aa+cVQmDp0qXS+uzZs2vt3FQ/eHp6Yt++fbh58ybCwsLg7Ows7bt58ybmzZsHFxcXBAUFIT4+XroYIYTA4cOH0alTJ7zzzjtKExa88cYbOHPmDA4cOCAVInRdq1atYGlpCQBKA/ECpRfCNYEFGB21c+dOfPTRR9L6okWLMGnSJDx58kRparwVK1ZIb0LSHj8/P1y5cgXff/89bt++jf3792PIkCG8ukH0EsqPA1PdXjA9e/ZESkoKJk6ciG7dutV2aHovMDAQISEhAIBHjx5h9OjRSmO0qGrjxo3Iz88HUFrM9vf3x9atW5GTkwMnJ6daa4eI6GU8Pw5Mbfnhhx+kKYI9PT3xxhtv1Nq5qX5p2rQpFixYgBs3biAmJgZ9+/aVJtgoLi7G7t278eabb6J169ZYuHAh/Pz80K9fP5w/f146h6+vL3744QfExcUpvWf1gVwul4ouOTk5cHd3l/adPXtWMzFopBXSqCNHjmD48OHSP7kzZsxAaGgoACAiIgI3b94EUFr1fO+997QWJylr0qQJAgMDOZ0gUTWpOhCvo6MjVq1axdtV1OSrr76SrtQdP35cmi5aVSUlJVi9erW0Xn7A3fID6xERaYq6CjDle7/MmTNHZ2a0pJozNDTEoEGDcOjQIaSnpyM0NFRpsPtr165h/vz50qyAAODh4YHY2FicOnUKr7/+ujbCrhPK34ZUdksXUNojRhNYgNExJ0+exODBg6X7TkePHo1ly5ZBJpMhNTUVX3zxBYDSewlXr17ND3AiqveqW4DJy8ur1V4YVLXCwkJYW1tjw4YN0raZM2cq3XteU4cOHcKNGzcAAH379kWLFi1UPicRkSpeffVVuLu7Y/DgwbX2BTc5ORnHjh0DALi5ueGdd96plfOS7nB1dUVERAQyMjKwc+fOCj2k2rRpg507dyIpKQn9+/fX++9/5QswWVlZmDhxItauXYslS5ZopH1e7tMhycnJGDBggDSHe1BQENauXSsl2ZkzZ6QvHbNnz0arVq20FisRUW1p3749evfujbZt28Lf3/+Fx5aUlGDAgAGwsbHB+vXr0bhxYw1FqX8ePHiAPn36IDg4GDNmzMD48eOxZs0aPHnyBKNGjcJPP/1U47GtEhMTMWHCBGnd2dkZmzZtwnvvvYeGDRvW1lMgIqoWIyMjXLt2rVbPWb73y4wZM9hbk6pkZGSEoKAgBAUFIS0tDTt37kTz5s0RFBTE9005Xbt2xcaNG+Ht7Y02bdoo9YLRBJngZcB6Jzc3F5aWlnj06BEsLCwAlF5lbN26tXQ1sE+fPti/fz+MjIyUHnvlyhUsXrwY69ev5/gipKSy95Uu07fnS6UiIiIwb948AECXLl1w8uTJWr0SpG/vq6qe77Nnz+Dj4yMNQrlq1SqMGDECHTt2xPXr1wGUztI3Y8aMarcZHR2NsWPHoqCgAEBpAe7GjRvIy8uDi4sL0tPT+Y9mPcc8Iip1/fp1tGzZEiUlJbC1tcXNmzdfusisb+8rfXu+pBnqeF/xFiQdYWRkhC1btsDCwgJdu3bFnj17KhRfAKBdu3bYunUriy9EpHdOnz6NBQsWACi95zcyMlLvu+Gqi6mpKd59911pfdKkSdi1axc2b94s/c4//fRTpdkY/k5xcTFmzpyJESNGSMWXrl27IiQkRJr9qm/fviy+EJHO2L59O0pKSgAAU6ZMYQ8/Ih3AAowO6d69O/773/8iNjYWZmZm2g6HiKjO+PPPP/H+++9L/8h+9tln6N69u5aj0m3z5s3D3LlzpfXRo0cjKysL06ZNAwAUFBRg5MiR0phlL/LgwQP069cPX375pbRt3LhxiI+Px9atW6Vt5W9LIiLSpoKCgmrPzPe8uXPn4ujRo+jXrx8mTZpUS5FpR0FBATw8PCCTyZCcnKy0TyaTVVjWrFmjpUiJ1IsFGB3TsWNHWFlZSeuJiYlYtGiRdLWQiEhXCSGQnZ2Ne/fuVdg+fvx4aQa4bt26SbchkfrIZDJERETg448/BlD6OoSEhMDLy0saODkxMfFvB727fPkyOnfujOPHjwMonfkhKioKa9euxblz53Dx4kUApdNqenh4qPEZERG9nMDAQFhYWMDb2xsKhaLG55HJZOjduzcOHjwIGxubWoxQ82bPng0nJ6cq92/atAnZ2dnSMnLkSA1GR/qmsLAQBw8exPz587F8+XKNts0CjA4rKSnBhAkT8Nlnn6FDhw5IT0/XdkhERGoRHx+Pxo0bw8nJqcI0x5s2bcKOHTsAAFZWVti2bRtvU9EQmUyGFStWYNy4cQBK/y6NGDECH330kTQA78KFC3H+/PlKHx8TEwMfHx9p1iQ7OzvEx8dj/PjxAICoqCjp2PLTUBMRaZNMJkNhYSFyc3NV7gWjCw4fPoxjx45Js7FWxsrKCg4ODtLC4RJInRQKBd5++20sXLgQ69ev12jbLMDosHXr1iExMRFA6RgxLi4uWo6IiEg97O3t8eeffwJQnor6t99+w5QpU6T19evX45VXXtF4fPpMJpMhKioKISEhAICioiJ88sknGDp0KIDSsV3Kj+sClP5jFB4ejsDAQGl8F09PTyQmJsLPzw8AcPfuXezatQsAYGtrqzTmDBGRNvn4+Eg/JyQkVPvx9+/fr81wtOrOnTsYO3YsoqOjXziGzeTJk2FrawsvLy+sWbPmb3sOFRQUIDc3V2khelkmJiZ49dVXAZT+r1j2P6QmsACjo+7cuaN0731UVBQaNGigxYiIiNSnZcuW0jSCZQWYgoICDB06FE+fPgVQOmYIv6Rrh1wux8aNGxEUFAQAyM/Ph0wmk24Zunz5sjRAcl5eHoKCgqR1AAgODsbJkyel4llGRgamTZsmjR/z4YcfwsTERJNPiYioSuULMJs3b65WL5ji4mJ4eXnB398fhw4dUkd4GiOEwKhRozB+/Hh06tSpyuMWLlyIXbt2IS4uDsHBwZgxYwYWL178wnMvWbIElpaW0sILzVRd3t7e0s/nzp3TWLsswOioWbNm4dGjRwCAUaNGcbBJItJpxsbGcHd3B1B6JUOhUKCgoEDa1rZtW6xYsUKbIeo9Q0NDbN26FQMHDkRISAg2btyILVu2SBcHli1bhm3btsHX1xd79+4FUNp7JjIyEt99953SldN9+/bhu+++k4756KOPNP+EiIiq0KlTJ+lW159//hlt27ZFr169EBMTIw0GX5Xdu3fj+vXr+Pnnn7Fy5UpNhFttYWFhlQ6cW35JTEzE119/jdzcXKWLwpWZN2+eNI7XjBkzEB4ejmXLlr3wMXPnzsWjR4+kJTMzszafIumB8gWYmvRUqykWYHTQTz/9hOjoaACAtbU1li5dquWIiIjUr2xg12fPniEjIwMWFhbYtWsX1q1bh+3bt3P6zjrAyMhImo7a0NAQHTp0QHh4OIDS246GDx+OS5cuAQAsLS0RGxuLjz76CHfv3lU6z4gRI9CwYUMYGhriiy++QPPmzTX+XIiIqmJmZoalS5cqjWMSFxeHwMBAuLu7V3m7gxBC6f/2OXPmqD3Wmpg8eTJSU1NfuLRv3x4//PADfvnlFxgbG8PQ0BAtWrQAUFqgetEguz4+PsjNzcWdO3eqPMbY2BgWFhZKC1F1sABDtaKwsFBpIMLIyEjY2dlpMSIiIs1o06aN9HPZbUgymQxjx46V7vMl7TM2NpZuFwNKe2w+P3tR69atsWXLFsTExMDZ2RlhYWFK+62srLBjxw5kZGRg+vTpmgib9NiLps/NyMjAwIEDYWZmBltbW0ydOhWFhYVaipTqkmnTpiErKwvLly+XemMCgKurq9KMpeXFx8fjwoULAEqLFD169NBEqNVma2uLNm3avHAxMTHBypUrkZKSguTkZCQnJ0u3VO3YsQMRERFVnv/ChQswMTGp8vdEVBtatmwJa2trAKUFGCGERtrlNBA6Zvny5dIXD29vb4wZM0bLERERaUZZDxigtADTt29fLUZDL+vq1avIysqCTCaDEAIeHh4wMTFBQECAdEx0dDQiIyNhaWkpbRswYIA2wiU9VDZ9bkpKitL2kpIS9O/fH3Z2djh58iTu37+PkSNHQgiBr7/+WkvRUl1ibW2NadOm4eOPP8bRo0fx9ddfY/To0UrHlPX+GzBgADZs2CBtnz17NmQymaZDrlXPD3rfqFEjAIC7uzuaNm0KADhw4ABycnLg6+sLU1NT/Pjjj/j0008xbtw4GBsbazxm0h8ymQze3t44cuQI7t27hxs3bsDNzU3t7bIAo0Nu3rwpdeWWy+WIiopSuspIRKTLyhdgli1bxp4R9cS0adNw7949af35HgaNGjXCyJEjlWZJItKUsulz9+zZg8OHDyvtO3bsGK5cuYLMzEw4OTkBAL788kuMGjUKERERvCWCJHK5HH379q30wkBcXBy2b9+O7du3S9vc3d0xePBgTYaoNQ0aNMDq1asxffp0KBQKNG/eHOHh4Zg0aZK2QyM9UFaAAUp7wbAAQ9XSpEkTzJo1C5GRkRg/fjw8PT21HRIRkcaUL8Dk5OTg2rVr0v3mVHdt27YN/v7+uHLlitL2du3aYdKkSQgJCYG5ubmWoiN9VjZ97r59+yodQ+rMmTNo3769VHwBgD59+qCgoABJSUl4/fXXNRku1VMHDhyosG3mzJkwMDDQQjTq5erqWuE2j7feegtvvfWWliIifefj44NWrVrBx8dH6pWlbuweoUNMTU3x+eef49KlS1JPGCIifWFhYYEJEybAxMQEy5cvIUWQUAAAEsNJREFUZ/GlnrC1tUV8fDw8PT1haGiId999Fz/++CMuXbqEiRMnsvhCWvEy0+fm5OTA3t5eaZu1tTWMjIyQk5NT5bkLCgqQm5urtJD+WrlyJU6cOIGgoCAYGRmhe/fuLxyglohqz1tvvYWrV6/i22+/Rbdu3TTSJnvA6KCWLVtqOwQiIq1YvXo1Vq5cKU3/SfWDg4MDEhMToVAo+NqRWoWFheHzzz9/4THnzp3D6dOnX2r63MrG6BBCvHDsjiVLlvxtDKQ/ZDIZ/Pz84Ofnp+1QiEgD+F8OERHpFH6Br5/kcjnHLSO1mzx5MoKDg194jKurKxYtWiRNn1tep06dMGzYMHz77bdwcHCoMHXpw4cPUVRUVKFnTHlz585VGqMqNzcXLi4uNXg2RERU3/C/VCIiIiLSC7a2trC1tf3b41auXIlFixZJ67dv30afPn2wY8cOeHt7AwB8fX0RERGB7OxsODo6AigdmNfY2BivvfZalec2Njbm7C5ERHqKBRgiIiIionJeZvrc3r17o127dggJCcGyZcvw4MEDzJw5E2PHjuUMSEREVCn29SUiIiIiqiYDAwMcPHgQJiYm6Nq1K4YMGYLAwEB88cUX2g6NiIjqKPaAqYfKpm/jqPlUm8reT89PD6irmEekDswjItXVxTyqbPpcoLSnTGxsrErnZh6ROtTFPFIn5hGpgzryiAWYeujx48cAwAHbSC0eP34MS0tLbYehdswjUifmEZHqmEdEqmMeEamuNvNIJvSlLKpDFAoFbt++DXNz8wrTHJaNpJ+ZmflS9x9X93hNtFEXY9JEG9qOSQiBx48fw8nJSS9mImEe6WYb2o6JefSX+vba1ZeYNNGGtmNiHv2lvr129SUmTbSh7ZiYR3+pb69dfYlJE21oOyZ15BF7wNRDcrlcGgCuKhYWFtUaAK66x2uijboYkyba0GZM+nCFpAzzSLfbYB5pBvNIt9tgHmkG80i322AeaQbzSLfb0KU80v1yKBERERERERGRlrEAQ0RERERERESkZgZhYWFh2g6CapeBgQF69OgBQ8OXu8Osusdroo26GJMm2qiLMekrXXjt6mJMmmijLsakr3ThtauLMWmijboYk77ShdeuLsakiTbqYkz6Shdeu7oYkybaqIsxqYKD8BIRERERERERqRlvQSIiIiIiIiIiUjMWYIiIiIiIiIiI1IwFGCIiIiIiIiIiNWMBhoiIiIiIiIhIzViAIY3gWM9EqmMeEamOeUSkOuYRkeqYR/qJsyCRRhgZGSElJQVt27bVdihqk52djaioKJw8eRLZ2dkwMDCAm5sbAgMDMWrUKBgYGGg7RKrnmEfMI1Id84h5RKpjHjGPSHXMI/3MIxZgdFhmZiYWLFiAjRs3StuePXuGpKQkNG7cGO3atVM6Pj8/Hzt37sSIESOUtqempuKXX36Br68v2rRpg99++w1fffUVCgoKMHz4cPTs2VM6dvr06ZXG8tVXX2H48OGwsbEBACxfvrzS4x4+fIhvv/0WaWlpcHR0xMiRI+Hi4qJ0zIULF2BlZQU3NzcAwNatWxEVFYWMjAw0a9YMkydPRnBwsHT8lClTMGTIEHTv3v3vfmVKvv76ayQmJqJ///4YMmQIoqOjsWTJEigUCgwePBjh4eHSXPGJiYl488034ebmBlNTUyQkJGDYsGEoLCzE0aNH0bZtWxw9ehTm5uZKbTx58gTfffcdTp8+jZycHMhkMtjb26Nr164YOnQozMzMXjreO3fuYO3atZg/f36Ffbdu3YKVlRUaNWqktL2oqAhnzpyBn59ftX43+oR5VIp5xDxSBfOoFPOIeaQK5lEp5hHzSBXMo1LMIy3mkSCdlZycLORyubR+9epV0axZMyGTyYRcLhf+/v7i9u3b0v6cnByl44UQ4vDhw8LIyEg0btxYmJiYiMOHDws7Ozvx5ptvijfeeEMYGhqK+Ph46XiZTCY8PDxEjx49lBaZTCa8vLxEjx49xOuvvy4d7+joKP744w8hhBDp6enCwcFBODg4iF69eommTZsKS0tLkZqaqhSTp6en+OGHH4QQQqxfv16YmpqKqVOniqioKPGvf/1LNGrUSGzYsEEpJrlcLlq2bCkiIyNFdnb23/7uwsPDhbm5uXjnnXeEg4ODiIyMFDY2NmLRokVi8eLFws7OTsyfP186vmvXriIsLExaj46OFt7e3kIIIR48eCA8PDzE1KlTldq4fPmycHJyElZWViIgIECMGzdOjB07VgQEBAgrKyvh7OwsLl++/Lexlnn+9RZCiNu3bwsvLy8hl8uFgYGBGDFihHj8+LG0v7LXnJQxj/6KiXnEPKop5tFfMTGPmEc1xTz6KybmEfOopphHf8XEPNJOHrEAU4/FxMS8cFmxYoXSmycwMFAMGDBA3Lt3T6SlpYmBAwcKNzc3cfPmTSFE5W82X19f8emnnwohhNi+fbuwtrYWoaGh0v7Q0FDRq1cvaX3x4sXCzc1N6UNHCCEMDQ0rTRaZTCbu3LkjhBAiODhY9OjRQzx58kQIIUR+fr4YMGCAePfdd5Ue07BhQylmT09PsXbtWqX927ZtE+3atVNqIy4uTnz88cfC1tZWNGjQQAwaNEgcOHBAlJSUVPq7bd68udizZ48QojRxDQwMxNatW6X9e/fuFS1atJDWTU1Nxe+//y6tl5SUiAYNGoicnBwhhBDHjh0TTk5OSm306NFDBAcHi4KCggrtFxQUiKFDh4oePXpI21JSUl647Nixo8LrN2LECOHj4yPOnTsnjh8/Ljp16iRee+018eDBAyFE6Wsuk8kq/R3oC+YR84h5pDrmEfOIeaQ65hHziHmkOuYR86iu5xELMPVYWeVSJpNVuZR/wzVp0kT8+uuvSueYOHGieOWVV8Tvv/9e6QeMhYWFSEtLE0KUJo2hoaFISkqS9l+8eFHY29srPebs2bOiVatWYsaMGaKwsFAI8XIfMJV9MP3yyy+iadOmSttsbGxEYmKi9JySk5OV9l+7dk2YmppW2kZhYaHYsWOH6NOnjzAwMBBOTk4iNDRUeo5lTE1NpQ8xIYRo0KCBuHTpkrR+48YN0bBhQ2m9WbNm4uTJk9L67du3hUwmE0+fPhVCCHH9+nVhYmJSoY0XVXAvXrxY4XlU9XqXbX/+9XNychIJCQnSen5+vggICBAeHh7i/v37vFIimEdlz4l5xDxSBfOIecQ8Uh3ziHnEPFId84h5VNfziLMg1WOOjo7Ys2cPFApFpcv58+eVjn/27Jl0T16ZVatWYdCgQfD398f//ve/F7Ynl8thYmICKysraZu5uTkePXqkdJyXlxeSkpJw7949dOrUCRcvXoRMJqvyvGX7CgoKYG9vr7TP3t4e9+7dU9rWt29fREVFAQD8/f2xe/dupf07d+5EixYtKm2rQYMGGDJkCI4cOYL09HSMHTsW27ZtQ+vWrZWOc3BwwJUrVwAAaWlpKCkpkdYB4PLly2jSpIm0HhgYiPHjx+PIkSP48ccfMWzYMPj7+8PU1BQAcPXqVTg7Oyu1YW1tjbS0tCp/L9euXYO1tbW0bmNjg/Xr1+P69esVlvT0dMTGxlY4x6NHj5TOYWxsjN27d8PV1RWvv/467t69W2X7+oJ5xDxiHqmOecQ8Yh6pjnnEPGIeqY55xDyq83mkttIOqd3AgQPFZ599VuX+5ORkpe5TXl5eYsuWLZUeO2nSJGFlZVWh2texY0dx+PBhaf3ixYuiqKhIWv/vf/8r3Nzcqoxh+/btwt7eXsjl8iorvB06dBCenp6iUaNGYu/evUr7T5w4IZydnZW2ZWVlCVdXV+Hn5yemT58uTE1NRbdu3cTYsWOFn5+fMDIyEgcPHlRqo6zCWxmFQiGOHTumtO3TTz8VdnZ2YsyYMcLNzU3MnTtXvPLKKyIqKkqsWbNGuLi4iGnTpknHP378WAwZMkQYGhoKmUwmunTpItLT06X9R48eFTt37lRqY8GCBcLS0lIsW7ZMJCcni+zsbJGTkyOSk5PFsmXLhLW1tfj888+l4/v06SMWLlxY5fN4/vUWQogOHTqI3bt3Vzi2qKhIBAYGildeeUXvr5Qwj5hH5TGPaoZ5xDwqj3lUM8wj5lF5zKOaYR4xj8qri3nEAkw99vPPPysl//Py8vLETz/9JK0vXrxY9O3bt8rjJ0yYUOENGhUVJWJjY6t8TGhoqBg9evQL48zMzBT79u0TeXl5FfaFhYUpLUeOHFHaP3PmTBEcHFzhcQ8fPhRz5swR7dq1EyYmJsLIyEg0a9ZMvP/+++LcuXNKx7q6ukoDWb2s4uJisWjRIjFgwAARGRkphCj9sHRxcRE2NjZi1KhRlT6fZ8+eKQ3i9HciIyOFo6Oj1D2urKuco6Oj+Pe//6107N69e0V0dHSV53rw4IHYvHmz0rbZs2eL3r17V3p8UVGRGDRokN7fK8w8Yh6VxzyqGeYR86g85lHNMI+YR+Uxj2qGecQ8Kq8u5hGnoSaqA65fv46cnBwApd37yqaQU1VxcTGePn0KCwuLSveXlJTg1q1baNasWa20R6RNzCMi1TGPiFTHPCJSna7mEceAIaoD3Nzc4OvrC19fX+nDJTMzEx9++OFLn6Oy4w0NDav8cAGA27dv4/PPP69Z0ER1DPOISHXMIyLVMY+IVKerecQeMER1VEpKCv75z3+ipKRELcfX9DFE9QnziEh1zCMi1TGPiFSnC3lk+PeHEJE67N+//4X709PTVTq+po8hqk+YR0SqYx4RqY55RKQ6fcgj9oAh0hK5XA6ZTIYXpaBMJpOqr9U9vqaPIapPmEdEqmMeEamOeUSkOn3II44BQ6Qljo6O2LNnDxQKRaXL+fPnVTq+po8hqk+YR0SqYx4RqY55RKQ6fcgjFmCItOS11157YYI/X5mt7vE1fQxRfcI8IlId84hIdcwjItXpQx4ZhIWFhant7ERUpaZNm8LBwQEtWrSodL+5uTl69+4NV1fXGh1f08cQ1SfMIyLVMY+IVMc8IlKdPuQRx4AhIiIiIiIiIlIz3oJERERERERERKRmLMAQEREREREREakZCzBERERERERERGrGAgwRERERERERkZqxAENUhbCwMHh4eGg7DKJ6jXlEpDrmEZHqmEdEqmMeqY4FGCKUzve+b98+bYdBVK8xj4hUxzwiUh3ziEh1zCP1YAGGiIiIiIiIiEjNWIChOqVHjx6YMmUK/vWvf8Ha2hr29vZYt24dnjx5gg8++ADm5uZwd3fH4cOHpcecOHECnTt3hrGxMRwdHfHJJ5+guLhY6ZxTp07F7Nmz0bhxYzg4OCAsLEza7+rqCgB4++23IZPJpPUy0dHRcHV1haWlJYKDg/H48WN1/gqIVMY8IlId84hIdcwjItUxj3QLCzBU53z77bewtbXF2bNnMWXKFEyYMAFBQUHo0qULzp8/jz59+iAkJARPnz5FVlYW+vXrBy8vL6SkpCAqKgobNmzAokWLKpzTzMwMCQkJWLp0KcLDw3H8+HEAwLlz5wAAmzZtQnZ2trQOAL///jv27duH2NhYxMbG4sSJE4iMjNTcL4OohphHRKpjHhGpjnlEpDrmkQ4RRHWIv7+/6Natm7ReXFwszMzMREhIiLQtOztbABBnzpwRoaGhonXr1kKhUEj7V61aJRo1aiRKSkoqPacQQnh5eYk5c+ZI6wDE999/r3TMggULRMOGDUVubq60bdasWcLb27t2niyRmjCPiFTHPCJSHfOISHXMI93CHjBU53Ts2FH62cDAADY2NujQoYO0zd7eHgBw9+5dpKamwtfXFzKZTNrftWtX5OXl4datW5WeEwAcHR1x9+7dv43F1dUV5ubm1X4ckbYxj4hUxzwiUh3ziEh1zCPdwQIM1TkNGjRQWpfJZErbyj5MFAoFhBBKHy4AIIRQOq6qcyoUihrF8jKPI9I25hGR6phHRKpjHhGpjnmkO1iAoXqtXbt2OH36tPShAgCnT5+Gubk5nJ2dX/o8DRo0QElJiTpCJKrzmEdEqmMeEamOeUSkOuZR3cYCDNVrEydORGZmJqZMmYLffvsNMTExWLBgAaZPnw65/OXf3q6uroiPj0dOTg4ePnyoxoiJ6h7mEZHqmEdEqmMeEamOeVS3sQBD9ZqzszMOHTqEs2fP4tVXX8X48eMxevRozJs3r1rn+fLLL3H8+HG4uLjA09NTTdES1U3MIyLVMY+IVMc8IlId86huk4nyfZOIiIiIiIiIiKjWsQcMEREREREREZGasQBDRERERERERKRmLMAQEREREREREakZCzBERERERERERGrGAgwRERERERERkZqxAENEREREREREpGYswBARERERERERqRkLMEREREREREREasYCDBERERERERGRmrEAQ0RERERERESkZizAEBERERERERGpGQswRERERERERERq9v+vnc6kv9fTWQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1000x2000 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from time_series_analyses import ts_mean_conf\n",
    "import matplotlib.pyplot as plt; plt.rcdefaults()\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.figure(figsize=(10,20))\n",
    "########################################################################################################\n",
    "fig.text(-0.1,0.15,'a',size=30)\n",
    "ax = fig.add_axes([0,0,1.,0.15])\n",
    "\n",
    "model = 'JRA'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_season_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3w = -(current_season_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4w = -(current_season_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5w = -(current_season_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6w = -(current_season_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = (current_season_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3e = (current_season_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4e = (current_season_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5e = (current_season_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6e = (current_season_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "labels = ['EUC','NECC', 'SECC','NEC','SEC']\n",
    "ebox_amps = [var2e.max(), var3e.max(), var4e.max(), var5e.max(), var6e.max()]\n",
    "wbox_amps = [var2w.max(), var3w.max(), var4w.max(), var5w.max(), var6w.max()]\n",
    "ebox_phases = [var2e.argmax(), var3e.argmax(), var4e.argmax(), var5e.argmax(), var6e.argmax()]\n",
    "wbox_phases = [var2w.argmax(), var3w.argmax(), var4w.argmax(), var5w.argmax(), var6w.argmax()]\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.2                # the width of the bars\n",
    "\n",
    "rects1 = ax.bar(x + width*(1./2.), ebox_amps, width, label='Ebox %s55-do'%model, color='C0')\n",
    "rects2 = ax.bar(x - width*(1.+1./2.), wbox_amps, width,  label='Wbox %s55-do'%model, color='C1')\n",
    "\n",
    "def autolabel(rects,amps,phases):\n",
    "    \"\"\"Attach a text label above each bar in *rects*, displaying its height.\"\"\"\n",
    "    \n",
    "    for nrec,rect in enumerate(rects):\n",
    "        if amps[nrec]==0:\n",
    "            continue\n",
    "        sign=np.float(amps[nrec])/np.abs(amps[nrec])\n",
    "        if sign > 0 :\n",
    "            ypos=0.1\n",
    "        else :\n",
    "            ypos=-0.5\n",
    "        \n",
    "#         print(sign)\n",
    "        \n",
    "        ax.annotate('%0.0i'%(np.int(phases[nrec])+1),\n",
    "                    xy=(rect.get_x() + rect.get_width() / 2, amps[nrec]),\n",
    "                    xycoords='data',\n",
    "                    xytext=(rect.get_x() + rect.get_width() / 2, amps[nrec]+ypos), \n",
    "                    textcoords='data',\n",
    "                    ha='center', va='bottom', rotation=45,size=12)\n",
    "        \n",
    "autolabel(rects1,ebox_amps,ebox_phases)\n",
    "autolabel(rects2,wbox_amps,wbox_phases)\n",
    "\n",
    "########################\n",
    "model = 'CORE'\n",
    "box = 'wbox'\n",
    "\n",
    "var2w = -(current_season_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3w = -(current_season_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4w = -(current_season_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5w = -(current_season_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6w = -(current_season_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "box = 'ebox'\n",
    "\n",
    "var2e = (current_season_mlist[model]['180']['%s_euc'%(box)])\n",
    "\n",
    "var3e = (current_season_mlist[model]['180']['%s_necc'%(box)])\n",
    "\n",
    "var4e = (current_season_mlist[model]['180']['%s_secc'%(box)])\n",
    "\n",
    "var5e = (current_season_mlist[model]['180']['%s_nec'%(box)])\n",
    "\n",
    "var6e = (current_season_mlist[model]['180']['%s_sec'%(box)])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "ebox_amps = [var2e.max(), var3e.max(), var4e.max(), var5e.max(), var6e.max()]\n",
    "wbox_amps = [var2w.max(), var3w.max(), var4w.max(), var5w.max(), var6w.max()]\n",
    "ebox_phases = [var2e.argmax(), var3e.argmax(), var4e.argmax(), var5e.argmax(), var6e.argmax()]\n",
    "wbox_phases = [var2w.argmax(), var3w.argmax(), var4w.argmax(), var5w.argmax(), var6w.argmax()]\n",
    "\n",
    "\n",
    "rects3 = ax.bar(x + width*(1+1./2.), ebox_amps, width, label='Ebox %s'%model, color='C0',hatch='///')\n",
    "rects4 = ax.bar(x - width*(1./2.), wbox_amps, width, label='Wbox %s'%model, color='C1',hatch='///')\n",
    "\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Heat budget (PW)',fontsize=13)\n",
    "ax.set_title(' ',fontsize=15)\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim([0,1.5])\n",
    "ax.tick_params(axis='x',labelsize=13,rotation=0) \n",
    "ax.tick_params(axis='y',labelsize=13,rotation=0) \n",
    "ax.legend(frameon=False,loc='upper left')\n",
    "\n",
    "\n",
    "autolabel(rects3,ebox_amps,ebox_phases)\n",
    "autolabel(rects4,wbox_amps,wbox_phases)\n",
    "\n",
    "\n",
    "#####################################################################################\n",
    "fig.text(-0.1,-0.05,'b',size=30)\n",
    "ax = fig.add_axes([0,-0.2,1.,0.15])\n",
    "\n",
    "model = 'JRA'\n",
    "\n",
    "var2w = (current_season_mlist[model]['180']['euc_Sv'])\n",
    "\n",
    "var3w = (current_season_mlist[model]['180']['necc_Sv'])\n",
    "\n",
    "var4w = (current_season_mlist[model]['180']['secc_Sv'])\n",
    "\n",
    "var5w = -(current_season_mlist[model]['180']['nec_Sv'])\n",
    "\n",
    "var6w = -(current_season_mlist[model]['180']['sec_Sv'])\n",
    "\n",
    "var7w = -(current_season_mlist[model]['180']['nsec_Sv'])\n",
    "\n",
    "var1w = var2w+var3w+var4w+var5w+var6w\n",
    "\n",
    "\n",
    "model = 'CORE'\n",
    "\n",
    "var2e = (current_season_mlist[model]['180']['euc_Sv'])\n",
    "\n",
    "var3e = (current_season_mlist[model]['180']['necc_Sv'])\n",
    "\n",
    "var4e = (current_season_mlist[model]['180']['secc_Sv'])\n",
    "\n",
    "var5e = -(current_season_mlist[model]['180']['nec_Sv'])\n",
    "\n",
    "var6e = -(current_season_mlist[model]['180']['sec_Sv'])\n",
    "\n",
    "var7e = -(current_season_mlist[model]['180']['nsec_Sv'])\n",
    "\n",
    "var1e = var2e+var3e+var4e+var5e+var6e\n",
    "\n",
    "\n",
    "labels = ['EUC','NECC', 'SECC','NEC','SEC']\n",
    "\n",
    "ebox_amps = [var2e.max(), var3e.max(), var4e.max(), var5e.max(), var6e.max()]\n",
    "wbox_amps = [var2w.max(), var3w.max(), var4w.max(), var5w.max(), var6w.max()]\n",
    "\n",
    "ebox_phases = [var2e.argmax(), var3e.argmax(), var4e.argmax(), \n",
    "               var5e.argmax(), var6e.argmax()]\n",
    "wbox_phases = [var2w.argmax(), var3w.argmax(), var4w.argmax(), \n",
    "               var5w.argmax(), var6w.argmax()]\n",
    "\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.45                # the width of the bars\n",
    "\n",
    "rects2 = ax.bar(x - width/2, wbox_amps, width, label='JRA55-do', color='gray')\n",
    "rects1 = ax.bar(x + width/2, ebox_amps, width, label='CORE', color='gray',hatch='///')\n",
    "\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Volume budget (Sv)',fontsize=13)\n",
    "ax.set_title('',fontsize=15)\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim([0,20])\n",
    "ax.tick_params(axis='x',labelsize=13,rotation=0) \n",
    "ax.tick_params(axis='y',labelsize=13,rotation=0) \n",
    "ax.legend(frameon=False,loc='upper right')\n",
    "\n",
    "\n",
    "\n",
    "def autolabel(rects,amps,phases):\n",
    "    \"\"\"Attach a text label above each bar in *rects*, displaying its height.\"\"\"\n",
    "    \n",
    "    for nrec,rect in enumerate(rects):\n",
    "        if amps[nrec]==0:\n",
    "            continue\n",
    "        sign=np.float(amps[nrec])/np.abs(amps[nrec])\n",
    "        if sign > 0 :\n",
    "            ypos=0.1\n",
    "        else :\n",
    "            ypos=-0.5\n",
    "        \n",
    "#         print(sign)\n",
    "        \n",
    "        ax.annotate('%0.0i'%(np.int(phases[nrec])+1),\n",
    "                    xy=(rect.get_x() + rect.get_width() / 2, amps[nrec]),\n",
    "                    xycoords='data',\n",
    "                    xytext=(rect.get_x() + rect.get_width() / 2, amps[nrec]+ypos), \n",
    "                    textcoords='data',\n",
    "                    ha='center', va='bottom', rotation=45,size=12)\n",
    "\n",
    "\n",
    "\n",
    "autolabel(rects2,wbox_amps,wbox_phases)\n",
    "autolabel(rects1,ebox_amps,ebox_phases)\n",
    "######################################\n",
    "fig.text(-0.1,-0.23,'c',size=30)\n",
    "ax1 = fig.add_axes([0,-0.35,0.15,0.08])\n",
    "(var2w+current_mlist['JRA']['180']['euc_Sv'].mean()).plot(ax=ax1,color='k',linewidth=2.0,label='JRA55-do')\n",
    "(var2e+current_mlist['CORE']['180']['euc_Sv'].mean()).plot(ax=ax1,color='k',linestyle='dashed',linewidth=2.0,label='CORE')\n",
    "ax1.set_title('EUC')\n",
    "ax1.set_ylabel('Sv',{'size':'12'})\n",
    "ax1.tick_params(axis='x',rotation=90) \n",
    "ax1.set_xticks(np.arange(12)+1)\n",
    "ax1.legend(frameon=False,loc='upper right',bbox_to_anchor=(0.3, 1.5))\n",
    "\n",
    "ax1 = fig.add_axes([0.21,-0.35,0.15,0.08])\n",
    "(var3w+current_mlist['JRA']['180']['necc_Sv'].mean()).plot(ax=ax1,color='k',linewidth=2.0)\n",
    "(var3e+current_mlist['CORE']['180']['necc_Sv'].mean()).plot(ax=ax1,color='k',linestyle='dashed',linewidth=2.0)\n",
    "ax1.set_title('NECC')\n",
    "ax1.set_ylabel('',{'size':'12'})\n",
    "ax1.tick_params(axis='x',rotation=90) \n",
    "ax1.set_xticks(np.arange(12)+1)\n",
    "\n",
    "ax1 = fig.add_axes([0.42,-0.35,0.15,0.08])\n",
    "(var4w+current_mlist['JRA']['180']['secc_Sv'].mean()).plot(ax=ax1,color='k',linewidth=2.0,label='JRA55-do')\n",
    "(var4e+current_mlist['CORE']['180']['secc_Sv'].mean()).plot(ax=ax1,color='k',linestyle='dashed',linewidth=2.0,label='CORE')\n",
    "ax1.set_title('SECC')\n",
    "ax1.set_ylabel('',{'size':'12'})\n",
    "ax1.tick_params(axis='x',rotation=90) \n",
    "ax1.set_xticks(np.arange(12)+1)\n",
    "\n",
    "ax1 = fig.add_axes([0.63,-0.35,0.15,0.08])\n",
    "(var5w+current_mlist['JRA']['180']['nec_Sv'].mean()).plot(ax=ax1,color='k',linewidth=2.0)\n",
    "(var5e+current_mlist['CORE']['180']['nec_Sv'].mean()).plot(ax=ax1,color='k',linestyle='dashed',linewidth=2.0)\n",
    "ax1.set_title('NEC')\n",
    "ax1.set_ylabel('',{'size':'12'})\n",
    "ax1.tick_params(axis='x',rotation=90) \n",
    "ax1.set_xticks(np.arange(12)+1)\n",
    "\n",
    "ax1 = fig.add_axes([0.84,-0.35,0.15,0.08])\n",
    "(var6w+current_mlist['JRA']['180']['sec_Sv'].mean()).plot(ax=ax1,color='k',linewidth=2.0)\n",
    "(var6e+current_mlist['CORE']['180']['sec_Sv'].mean()).plot(ax=ax1,color='k',linestyle='dashed',linewidth=2.0)\n",
    "# var7w.plot(ax=ax1,color='C0',linestyle='dashed',linewidth=2.0)\n",
    "# var7e.plot(ax=ax1,color='C1',linestyle='dashed',linewidth=2.0)\n",
    "ax1.set_title('SEC')\n",
    "ax1.set_ylabel('',{'size':'12'})\n",
    "ax1.tick_params(axis='x',rotation=90) \n",
    "ax1.set_xticks(np.arange(12)+1)\n",
    "\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "fig.savefig('../figure/figure16.pdf', dpi=300, facecolor='w', edgecolor='w',\n",
    "                orientation='portrait', papertype=None, format=None,\n",
    "                transparent=False, bbox_inches=\"tight\", pad_inches=None,\n",
    "                frameon=None)"
   ]
  },
  {
   "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": []
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}