Energy and emissions data analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis of the scraped data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fossil fuel and renewables data cleaning, aggregating and plotting (all in thousands of megawatthours)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Fossil and renewable energy data both show net generation per month, by energy source\n",
    " - See items files in the scrapers for exactly what is included under each heading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "import pandas as pd\n",
    "\n",
    "from pathlib import Path\n",
    "import statsmodels.api as sm\n",
    "from pylab import rcParams\n",
    "import re\n",
    "\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "import plotly\n",
    "plotly.tools.set_credentials_file(username='scollier95', api_key='fPWI7fnBxIFigL28FW7m')\n",
    "#plotly.offline.init_notebook_mode(connected=True)\n",
    "import plotly.graph_objs as go\n",
    "import plotly.figure_factory as ff\n",
    "import colorlover as cl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Read in and clean data from the scraped csv's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "old_renewable_data_path = Path(\"renewable_energy_old/RenewableEnergyOld.csv\")\n",
    "renewable_generation = pd.read_csv(old_renewable_data_path, index_col = 5)\n",
    "\n",
    "old_fossil_data_path = Path(\"fossil_energy_old/FossilEnergyOld.csv\")\n",
    "fossil_fuel_generation = pd.read_csv(old_fossil_data_path, index_col = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_renewable_data_path = Path(\"renewable_energy_new/RenewableEnergyNew.csv\")\n",
    "renewable_generation = renewable_generation.append(pd.read_csv(new_renewable_data_path, index_col = 5))\n",
    "\n",
    "new_fossil_data_path = Path(\"fossil_energy_new/FossilEnergyNew.csv\")\n",
    "fossil_fuel_generation = fossil_fuel_generation.append(pd.read_csv(new_fossil_data_path, index_col = 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "fossil_fuel_generation.drop_duplicates(inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Check the shape and data types of the tables look correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fossil_fuel_generation.shape)\n",
    "print(fossil_fuel_generation.head(1))\n",
    "print(fossil_fuel_generation.tail(1))\n",
    "print(renewable_generation.shape)\n",
    "print(renewable_generation.head(1))\n",
    "print(renewable_generation.tail(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fossil_fuel_generation.dtypes)\n",
    "print(renewable_generation.dtypes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Joining and plotting energy sources (slightly grouped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Join the tables to make a plot featuring all of the main energy sources\n",
    "energy_gen = pd.merge(fossil_fuel_generation,renewable_generation, how = 'inner', left_index = True, right_index = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "High five! You successfully sent some data to your account on plotly. View your plot in your browser at https://plot.ly/~scollier95/0 or inside your plot.ly account where it is named 'filled-area-us-electricity-generation'\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sam\\Anaconda3\\lib\\site-packages\\IPython\\core\\display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~scollier95/0.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Following Plot.ly example for filled area plot, altering xticks and adding chart title and axis labels\n",
    "x = energy_gen.index.tolist()\n",
    "linewidth = 1.5\n",
    "brbg = cl.scales['10']['div']['BrBG']\n",
    "\n",
    "coal = dict(x=x, y=(energy_gen['coal']/1000).tolist(), hoverinfo='x+y', mode='lines', \\\n",
    "            line=dict(width=linewidth, color = brbg[1]), stackgroup='one', name='Coal')\n",
    "\n",
    "petroleum = dict(x=x, y=((energy_gen['petro_coke']+energy_gen['petro_liquids'])/1000).tolist(), \\\n",
    "                 hoverinfo='x+y', mode='lines', line=dict(width=linewidth, color = brbg[3]), name='Petroleum', stackgroup='one')\n",
    "\n",
    "gas = dict(x=x, y=((energy_gen['natural_gas']+energy_gen['other_gas'])/1000).tolist(), \\\n",
    "           hoverinfo='x+y', mode='lines', line=dict(width=linewidth, color = brbg[0]), name = 'Gas', stackgroup='one')\n",
    "\n",
    "nuclear = dict(x=x, y=(energy_gen['nuclear']/1000).tolist(), hoverinfo='x+y', mode='lines',\\\n",
    "            line=dict(width=linewidth, color = brbg[2]), name = 'Nuclear', stackgroup='one')\n",
    "\n",
    "wind = dict(x=x, y=(energy_gen['wind']/1000).tolist(), hoverinfo='x+y', mode='lines',\\\n",
    "            line=dict(width=linewidth, color = brbg[-4]), stackgroup='one', name='Wind')\n",
    "\n",
    "solar = dict(x=x, y=((energy_gen['solarpv_utility']+energy_gen['solarpv_small']+energy_gen['solar_thermal'])/1000).tolist(), \\\n",
    "             hoverinfo='x+y', mode='lines',line=dict(width=linewidth, color = brbg[-3]), stackgroup='one', name='Solar')\n",
    "\n",
    "biomass = dict(x=x, y=((energy_gen['bmsw']+energy_gen['landfill_gas']+energy_gen['other_waste']+energy_gen['wood'])/1000).tolist(), \\\n",
    "               hoverinfo='x+y', mode='lines',line=dict(width=linewidth, color = brbg[-2]), stackgroup='one', name='Biomass')\n",
    "\n",
    "geothermal = dict(x=x, y=(energy_gen['geothermal']/1000).tolist(), hoverinfo='x+y', mode='lines',\\\n",
    "            line=dict(width=linewidth, color = brbg[-1]), stackgroup='one', name='Geothermal')\n",
    "\n",
    "hydro = dict(x=x, y=(energy_gen['hydro']/1000).tolist(), hoverinfo='x+y', mode='lines',\\\n",
    "            line=dict(width=linewidth, color = brbg[-5]), stackgroup='one', name='Hydro')\n",
    "\n",
    "data=[gas, coal, nuclear, petroleum, hydro, wind, solar, biomass, geothermal]\n",
    "\n",
    "labels = ['January 2015', 'January 2016','January 2017','January 2018','January 2019']\n",
    "tickvals = ['January 2015', 'January 2016','January 2017','January 2018','January 2019']\n",
    "\n",
    "layout = dict(title = dict(text = 'Monthly energy generation', font = dict(family='calibri', size = 32)),\n",
    "              xaxis=go.layout.XAxis(ticktext=labels, tickvals=tickvals, title='Month', titlefont = dict(family='calibri', size = 24), tickangle=20, tickfont = dict(family='calibri', size = 18)),\n",
    "              yaxis = dict(title = 'Millions of megawatt hours', titlefont = dict(family='calibri', size = 24), tickfont= dict(family='calibri', size = 18), exponentformat='e'),\n",
    "              shapes = [{ 'type':'line', 'x0':'20 January 2017', 'y0':0, 'x1':'20 January 2017', 'y1':420, \\\n",
    "                            'line':dict(color = '#ff0000', width = 2, dash = 'dashdot')}],\n",
    "             legend = dict(yanchor = 'middle', y = 0.5, font = dict(family='calibri', size = 20)))\n",
    "# orientation = 'h', x = 0, y = 1.07,\n",
    "fig=dict(data=data, layout=layout)\n",
    "plotly.plotly.iplot(fig, fileopt = 'overwrite', filename = 'filled-area-us-electricity-generation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Looks as if there is an annual pattern in the above data - lets split it before and after Trump was inaugurated, and see if there has been a change in the monthly averages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the total energy frame, split it either side of Trump's inauguration,\n",
    "# get the months as a column on their own, make them categorical so that they \n",
    "# retain order\n",
    "\n",
    "months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', \\\n",
    "          'September', 'October', 'November', 'December']\n",
    "\n",
    "energy_gen['month'] = energy_gen.index.map(lambda x: re.sub('[\\d\\s]','',x))\n",
    "energy_gen['month']= pd.Categorical(energy_gen['month'], categories = months, ordered = True)\n",
    "\n",
    "pre_trump = energy_gen.loc['January 2015':'January 2017']\n",
    "post_trump = energy_gen.loc['February 2017':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group the two resulting frames to average over the time period for each month, then add\n",
    "# columns showing the total renewable/fossil energy/nuclear (i.e. summed over the sources, have \n",
    "# to delve into the MultiIndex object of the grouped data frame)\n",
    "\n",
    "group_pre_t = pre_trump.groupby('month').agg(['mean'])\n",
    "group_post_t = post_trump.groupby('month').agg(['mean'])\n",
    "\n",
    "# Exclude nuclear from the column names, as it is not really renewable or fossil\n",
    "# Make a vector to index with that selects just the renewable/fossil columns to sum\n",
    "\n",
    "r_col_logical = [True if i in set(renewable_generation.columns) else False for i in group_pre_t.columns.levels[0]]\n",
    "group_pre_t['total_renewable'] = group_pre_t.loc[:,r_col_logical].sum(axis = 1)\n",
    "group_post_t['total_renewable'] = group_post_t.loc[:,r_col_logical].sum(axis = 1)\n",
    "\n",
    "no_nuclear = group_pre_t.columns.levels[0][group_pre_t.columns.levels[0] != 'nuclear']\n",
    "f_col_logical = [True if i in set(fossil_fuel_generation.columns) else False for i in no_nuclear]\n",
    "group_pre_t['total_ff'] = group_pre_t.loc[:,no_nuclear].loc[:,f_col_logical].sum(axis = 1)\n",
    "group_post_t['total_ff'] = group_post_t.loc[:,no_nuclear].loc[:,f_col_logical].sum(axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now plot the nuclear, total renewable and total fossil fuel monthly average for the two portions of time and see if we can see a big difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sam\\Anaconda3\\lib\\site-packages\\IPython\\core\\display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~scollier95/4.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "dark2 = cl.scales['6']['qual']['Dark2']\n",
    "pre_t_ff = go.Scatter(x=months, y = list(group_pre_t['total_ff']/1000), name = 'Pre Trump fossil fuels', \\\n",
    "                      line = dict(color = dark2[0],width = 4))\n",
    "\n",
    "post_t_ff = go.Scatter(x=months, y = list(group_post_t['total_ff']/1000), name = 'Post Trump fossil fuels', \\\n",
    "                       line = dict(color = dark2[1],width = 4))\n",
    "\n",
    "data2 = [pre_t_ff, post_t_ff]\n",
    "\n",
    "layout2 = dict(title = dict(text = 'Average fossil fuel generation', font = dict(family='calibri', size = 32)), \n",
    "               xaxis = dict(title = 'Month', titlefont = dict(family='calibri', size = 24), tickangle = 35, tickfont = dict(family='calibri', size = 18)),\n",
    "               yaxis = dict(title = 'Millions of megawatt hours', titlefont = dict(family='calibri', size = 24), tickfont= dict(family='calibri', size = 18), exponentformat='e'), \n",
    "               legend = dict(orientation = 'h', yanchor = 'bottom', xanchor = 'center', x = 0.5, y = 1, font = dict(family='calibri', size = 20)))\n",
    "\n",
    "fig2 = dict(data=data2, layout=layout2)\n",
    "# plotly.offline.iplot(fig2)\n",
    "plotly.plotly.iplot(fig2, fileopt = 'overwrite', filename = 'pre-and-post-trump-ff-gen')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sam\\Anaconda3\\lib\\site-packages\\IPython\\core\\display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~scollier95/6.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dark2 = cl.scales['6']['qual']['Dark2']\n",
    "\n",
    "pre_t_r = go.Scatter(x=months, y = list(group_pre_t['total_renewable']/1000), name = 'Pre Trump<br>renewables', \\\n",
    "                       line = dict(color = dark2[2],width = 4))\n",
    "\n",
    "post_t_r = go.Scatter(x=months, y = list(group_post_t['total_renewable']/1000), name = 'Post Trump<br>renewables', \\\n",
    "                       line = dict(color = dark2[3],width = 4))\n",
    "\n",
    "pre_t_n = go.Scatter(x=months, y = list(group_pre_t['nuclear']['mean']/1000), name = 'Pre Trump<br>nuclear', \\\n",
    "                       line = dict(color = dark2[4],width = 4))\n",
    "\n",
    "post_t_n = go.Scatter(x=months, y = list(group_post_t['nuclear']['mean']/1000), name = 'Post Trump<br>nuclear', \\\n",
    "                       line = dict(color = dark2[5],width = 4))\n",
    "data3 = [post_t_n, pre_t_n, post_t_r, pre_t_r]\n",
    "\n",
    "layout3 = dict(title = dict(text = 'Average renewable and nuclear generation', font = dict(family='calibri', size = 30)),\n",
    "               xaxis = dict(title = 'Month', titlefont = dict(family='calibri', size = 24), tickangle = 35, tickfont = dict(family='calibri', size = 18)),\n",
    "               yaxis = dict(title = 'Millions of megawatt hours', titlefont = dict(family='calibri', size = 24), tickfont= dict(family='calibri', size = 18), exponentformat='e'),\n",
    "               legend = dict(yanchor = 'middle', y = 0.5, font = dict(family='calibri', size = 20)))\n",
    "\n",
    "fig3= dict(data=data3, layout=layout3)\n",
    "# plotly.offline.iplot(fig3)\n",
    "plotly.plotly.iplot(fig3, fileopt = 'overwrite', filename = 'pre-and-post-trump-renewable-and-nuclear-gen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Doesn't seem to be much difference! In fact, looks like post-Trump there has been an average decrease in fossil fuel generation, and an average increase in renewable generation.\n",
    " - Use statistical tests to see if this difference is significant, need to check they are applicable before using them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "renewable_generation['total'] = renewable_generation.sum(axis = 1)\n",
    "ren_gen_pre_t = renewable_generation.loc['January 2015':'January 2017']\n",
    "ren_gen_post_t = renewable_generation.loc['February 2017':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fossil_fuel_generation['total'] = fossil_fuel_generation.loc[:,['coal', 'natural_gas', 'other_gas', 'petro_coke', 'petro_liquids']].sum(axis = 1)\n",
    "fos_gen_pre_t = fossil_fuel_generation.loc['January 2015':'January 2017']\n",
    "fos_gen_post_t = fossil_fuel_generation.loc['February 2017':]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Statistical testing and assumption verification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make histogram to visually inspect normality - assuming populations are the whole\n",
    "# sets of renewable and fossil fuel generation data\n",
    "print(fossil_fuel_generation[['total']].describe())\n",
    "mean_median_diff_f = round(abs((fossil_fuel_generation['total'].median() - fossil_fuel_generation['total'].mean()) / fossil_fuel_generation['total'].mean())*100, 3)\n",
    "print('median diff from mean: ' + str(mean_median_diff_f) + \"%\")\n",
    "\n",
    "plt.title(\"Distribution of monthly fossil fuel generation\", fontdict = {'family':'calibri', 'size':40, 'color':'#404040'})\n",
    "plt.xlabel('Total', fontdict = {'family':'calibri', 'size':30, 'color':'#404040'})\n",
    "plt.ylabel('Proportion', fontdict = {'family':'calibri', 'size':30, 'color':'#404040'})\n",
    "ff_dist = sns.distplot(fossil_fuel_generation['total'], color = 'r', bins = 10).tick_params(axis = 'both', labelsize = 24, colors = '#404040')\n",
    "plt.savefig(\"Fossil fuel distribution.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(renewable_generation[['total']].describe())\n",
    "mean_median_diff_r = round(abs((renewable_generation['total'].median() - renewable_generation['total'].mean()) / renewable_generation['total'].mean())*100, 3)\n",
    "print('median diff from mean: ' + str(mean_median_diff_r) + \"%\")\n",
    "\n",
    "plt.title(\"Distribution of monthly renewable generation\", fontdict = {'family':'calibri', 'size':40, 'color':'#404040'})\n",
    "plt.xlabel('Total', fontdict = {'family':'calibri', 'size':30, 'color':'#404040'})\n",
    "plt.ylabel('Proportion', fontdict = {'family':'calibri', 'size':30, 'color':'#404040'})\n",
    "ren_dist = sns.distplot(renewable_generation['total'], color = 'g', bins = 10).tick_params(axis = 'both', labelsize = 24, colors = '#404040')\n",
    "plt.savefig(\"Renewable distribution.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sam\\Anaconda3\\lib\\site-packages\\IPython\\core\\display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~scollier95/26.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist_data = [(renewable_generation['total']/1000).tolist(), (fossil_fuel_generation['total']/1000).tolist()]\n",
    "group_labels = [\"Renewable\", \"Fossil fuel\"]\n",
    "colors = [cl.scales['10']['div']['BrBG'][-2], cl.scales['10']['div']['BrBG'][1]]\n",
    "fig4 = ff.create_distplot(hist_data, group_labels, colors=colors,\n",
    "                         bin_size=5, show_rug=False)\n",
    "fig4['layout'].update(title = dict(text = 'Renewable and fossil fuel distributions', font = dict(family='calibri', size = 30)), \\\n",
    "                      xaxis = dict(title = 'Monthly generation (millions of MWh\\'s)', titlefont = dict(family='calibri', size = 24), tickfont = dict(family='calibri', size = 18)),\\\n",
    "                      yaxis = dict(title = 'Proportion', titlefont = dict(family='calibri', size = 24), tickfont= dict(family='calibri', size = 18)),\\\n",
    "                      legend = dict(yanchor = 'middle', y = 0.5, font = dict(family='calibri', size = 20)))\n",
    "plotly.plotly.iplot(fig4, filename='renewable-and-fossil-fuel-distplot', fileopt = 'overwrite')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do a Shapiro - Wilk test, which is supposed to be suitable for relatively smaller data sets\n",
    "# Assumes a null hypothesis that data is normally distributed, low p-value means reject\n",
    "\n",
    "# PROBLEM IS THAT THIS STILL ASSUMES A PRETTY BIG SAMPLE - small sample sizes, normality tests have \n",
    "# little power to reject the null hypothesis and therefore small samples most often pass normality tests\n",
    "stat1, p1 = stats.shapiro(fossil_fuel_generation['total'])\n",
    "print(\"Fossil fuel Shapiro - Wilk p-value: \" + str(p1))\n",
    "\n",
    "stat2, p2 = stats.shapiro(renewable_generation['total'])\n",
    "print(\"Renewable Shapiro - Wilk p-value: \" + str(p2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check with a D'Agostino/Pearson omnibus test (checks for skew and kurtosis):\n",
    "stat3, p3 = stats.normaltest(fossil_fuel_generation['total'])\n",
    "print(\"Fossil fuel D'Agostino/Pearson p-value: \" + str(p3))\n",
    "\n",
    "stat4, p4 = stats.normaltest(renewable_generation['total'])\n",
    "print(\"Renewable D'Agostino/Pearson p-value: \" + str(p4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check further with a Anderson-Darling test, which tests the null hypothesis \n",
    "# that a sample is drawn from a population that follows a particular distribution \n",
    "# (normal in this case). If the returned statistic is larger than the critical \n",
    "# value then for the corresponding significance level, the null hypothesis that \n",
    "# the data come from the chosen distribution can be rejected.\n",
    "stat5, crit_val_f, sig_level_f = stats.anderson(fossil_fuel_generation['total'])\n",
    "print(\"Fossil fuel Anderson-Darling:\\n\" + \"Statistic: \" + str(round(stat5,3)) + \"\\nCritical values: \" + str(crit_val_f) + \"\\nSignificance level: \" + str(sig_level_f) +\"\\n\")\n",
    "\n",
    "stat6, crit_val_r, sig_level_r = stats.anderson(renewable_generation['total'])\n",
    "print(\"Renewable Anderson-Darling:\\n\" + \"Statistic: \" + str(round(stat6,3)) + \"\\nCritical values: \" + str(crit_val_r) + \"\\nSignificance level: \" + str(sig_level_r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Neither distribution looks particularly normal, though the renewable generation is definitely less skewed, and it's mean and median are more similar\n",
    " - Shapiro - Wilk sugests we reject H0 of a gaussian distribution for fossil fuel generation, but fail to reject it for renewables (alpha = 5%)\n",
    " - D'Agostino and Pearson fails to reject the null hypothesis of a normal distribution for either source\n",
    " - Anderson - Darling:\n",
    "      - finds that for fossil fuels, 4/5 of the sig levels tested end up rejecting the null hypothesis that the data is normal\n",
    "      - finds that for renewables, at all of the significance levels the null hypothesis of normality cannot be rejected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**On balance, I am going to move forward assuming the renewable generation to be normally distributed, but for fossil fuels I will NOT make that assumption**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As such, perform a two sample t-test on the renewable data to compare either side of T-day, essentially taking the data sets either side of the split as samples from the population of all of the data. Note the assumptions:\n",
    " - Satisfied: The populations from which the samples are drawn are normally dist \n",
    " - Not neccessary: The standard deviations of the two populations are equal.\n",
    " - Hmm....: Sample observations are randomly drawn and independent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=-6.594688768711309, pvalue=4.50831416284386e-08)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Welch's two sample t-test comparing means of renewable generation time series before and after T-Day\n",
    "stats.ttest_ind(np.array(ren_gen_pre_t['total']), np.array(ren_gen_post_t['total']), equal_var = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - p-value well below threshold, therefore **reject the null hypothesis that the mean renewable generation before and after Trump's inauguration is the same** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " For the fossil-fuel generation, need to use the Mann-Whitney U test, a non-parametric test for the null hypothesis that two independent samples were selected from populations having the same mean (equivalent to t-test with no normality assumption, but less powerful)\n",
    " \n",
    " Assumptions:\n",
    "  - Hmm...: Independent observations\n",
    "  - Satisfied: Ordinal observations\n",
    "  - Equal population distributions of both samples under H0 \n",
    "  - H1 is that population distributions are not equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats.mannwhitneyu(np.array(fos_gen_pre_t['total']), np.array(fos_gen_post_t['total']), alternative = 'two-sided', )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "p-value well above 5% threshold indicates we cannot reject the null hypothesis that the population distributions of both fossil fuel generation samples, either side of T-day, are equal.\n",
    "**So conclude that there does not appear to have been any statistically significant change in fossil fuel generation under Trump**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Was the renewable generation already on an upward trend before the inauguration? This requires further time series analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Time series decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZoAAALICAYAAAD2cUWAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4FOX6xvHvOwk1dEIHaVIFQbCioIgiKmAfsXss2HsBUUGxoXL0gNh7OZaxoVhRbPywHEVFlKIgIEiHUAOkzPP7Y1ZARQ1kk9kk9+e6cu3u7O7MHcqbybPvPK8zM0REREREREREREREdpQXdwARERERERERERERKdlUaBYRERERERERERGRQlGhWUREREREREREREQKRYVmERERERERERERESkUFZpFREREREREREREpFBUaBYRERERERERERGRQlGhWUREREREREREREQKRYVmERERERERERERESkUFZpFREREREREREREpFDS4w5QhCzuACIiIiIiIiIiIiIpzCVrR6W50MzChQvjjiAiUuJlZmayfPnyuGOIiJR4Gk9FRJJD46mISHI0bNgwqftT6wwRERERERERERERKRQVmkVERERERERERESkUFRoFhEREREREREREZFCUaFZRERERERERESKjYX5cUcQkSJQqhcDFBERERERERGR+JgZLFuEzZoOs6ZHt4sXQNXqULchrl4DqNMAV68h1G0IdRvgKlaKO7aI7ICUKjT7vt8GeGGrTS2AocBTie3NgLmAHwRBVnHnExERERERERGRv2Z5ufDLz9isaVFRefYMWLMqerJSBrRsi+u8F6xdjS1diH3/DayegG29k+q1oG59XN2GUK9hdFu3QVSErlAxjm9LRAogpQrNQRDMBDoD+L6fBvwKvAoMBiYEQTDC9/3BiceDYgsqIiIiIiIiIiLY+rUwewY2azo2ezrM+Qlyc6In69THtd8Ndm6H27kdNGiC8/7cxdU2boCli2DpQuy32yWLsKlfwaRVvy9C16iVmAndMDETukE0E7pOA1yFCsXyPYvItqVUofkPegGzgyCY5/v+EcABie1PAh+hQrOIiIiIiIiISLHZZhuMRfOjJ9PSoEkL3P59oqJyy3a4GrUKtF9XsRLs1AJ2aoH74zE3ZEfHXBIVoFmyMJoJ/e0X0azorV9cMzOa9Vy3wVYzoRtCnXq48ipCixS1VC40DwCeS9yvFwTBIoAgCBb5vl93W2/wfX8gMDDxOjIzM4slqIhIaZaenq7xVEQkCTSeiogkh8bT4mO5ueT+PJPcGd+RO30quTOnEq5aCYCrXIXybTtSruehlG+3K+VatS+6thZNdtrm5nD9OvIXLyB/4XzyFi0gf9EC8hfNJ2/K/7A1W82Edo4qp5xHxlEnF00+EQFStNDs+355oD9wzfa8LwiCh4CHEg9t+fLlyY4mIlLmZGZmovFURKTwNJ6KiCSHxtOis6UNRqK/8txZv2+D0bYTbqs2GPmeRz6wEWDtuuiruFXPjL7a7bZ5kwdY9jpYsiia/TzpfdY9/wjZnfbGVatR/BlFUlTDhg2Tur+ULDQDhwJfB0GwJPF4ie/7DRKzmRsAS2PMJiIiIiIiIiJS4tnqLGz6FPjx+79pg9E+WsCvgG0wUoWrXAWat8I1b4U13Zlw6AXY+Fdxx/4r7mgipVaqFppPYEvbDIDXgdOAEYnb1+IIJSIiIiIiZYtlrcC+/hT7ahKsXIrrfyKuWy+c+2MXURGR1GfZ66Oi8ozvogLzwl+iJyplRMXkvfaPZis3a12qFtZz9Rvh9uyOffgW1vsozWoWKSIpV2j2fb8ycDBwzlabRwCB7/tnAr8Ax8WRTURERERESj9buWxLcXn2jGhjo6ZQvRb2xGjsi4/xTj4/WmxKRCSFWW4uzJ6OTf8OmzEF5v4EYQjly8POu+D26Ylr1wmaNMd5aXHHLVLu8OOx/32CjR+LO/b0uOOIlErOzP75VSWTLVy4MO4MIiIlnnrgiYgkh8bT1GYrlmKTP8UmT4KfZ0YbGzfDdd03+mrQGAtD7JN3sZefgDAf1/8k3EH9cWmluzgjkmo0nv41C/Nh/hxs2pSosDxrGuTkgOdBs1a4dp2iwnKLtrhy5eKOW+zCh0diU/6Hd9sjuKrV4o4jErtEj+akXaaVcjOaRUREREREioMtX7KluDznx2hjk+a4I0+Oisv1G/3u9c7zcAcciu26B+GzD2AvPY59ORHv1AtxO7WI4TsQkbLOzGDJQmzGlKgVxoypkJ1YkK/hTrjuh0SF5dYdcJUqxxs2Bbi+x2NfTsTeexV39GlxxxEpdVRoFhERERGRMsOWLcYmT4raYsybFW3cqSXu6FNxXbvh6v7z6uuuVibeBddiX03CnnuQ8JbLcYcches7AFe+9PQ0FZHUZKtWRrOVpyf6LGclZnfXqoPbbS9o1xnXdldc9ZrxBk1BrkET3O77YR+8hR18lGY1iySZCs0iIiIiIlKq2dJFW4rLv8yONjbdGXfMabgu3Xao17JzDrfHflj7TtiLj2Fvv4xN/iya3dymQ5K/AxEpy6IF/KZGfZanT4FF86MnMqpC2464dj6u3a5Qp4EWKi0A1/d47Kv/w94bizv61LjjiJQqKjSLiIiIiEipY0sWRoWEyZNg/pxoY/PWuGP/heuyD65O/aQcx2VUxZ1+Cbbn/oTP3Ec4cgiue2/csafjKldJyjFEpGyx3ByYNR2bkSgsz50FFkL5CtCqPW7fXlE7jMbNcZ4Xd9wSxzXcCdd1X+yDN7HeR+KqaFazSLKo0CwiIiIiIqWCLV4QtbOYPAkWzI02tmiDO+6MqC1G7bpFdmzXvjPesHuw15/F3nsN++4rvBPPwXXZp8iOKSKlj82bTXjPTbB6ZbSAX/PWuMOPiwrLzduUyQX8ioLre3x0pct7r+OOOjnuOCKlhgrNIiIiIiJSYtmi+VuKy7/Oiza2bIs7/syoLUatOsWWxVWogDvuX9ie3QmfuIfw/tugyz54JwzE1ahdbDlEpGSyH74hvH8EZFTBu2AItNlVC/gVEdeoKa5LN+yDcVjvI3AZVeOOJFIqqNAsIiIiIiKFYtnrouLIurXgOXAeOPeHL2/LcxDN1Nv6uW2+1uG29Vzivs39CRb+Ej1u2Q434GzcbvvgamXG+ufhmu6Md+2/sffGYq8/Rzj9u6iVRvfe6p8qItsUfvYh9uRoaNAE75Jh+nCqGGyZ1fwa7kjNahZJBhWaRURERESkUOzdV2HGd7DrHlHRNwzBLOopaiRubcu20CA/L3oc/uG5zfej52zrx3/cT2Y93ICBuK77pFxRxqWn4w49FtttH8Kn78Wevhf73yd4p1yAq9cw7ngikiLMDHvnFeyVJ6FNR7zzh+AqZ8Qdq0xwjZtBl27YB29gBx+Jy1BffZHCUqFZRERERER2mK3JwiaMw+3RHW/gVXHHSTmufiO8K27G/u897KUnCG+8GNfvBNzBR+DS9euYSFlmYT72/CPYh2/i9uyBO/0S9WAuZl6/4wm//hR7/3XcESfGHUekxNPypCIiIiIissPsrZcgJwfX/4S4o6Qs53l4PQ7BGz4GOnTBXnmS8NYrsHmz4o4mIjGx3BzCB++Misy9j8SdebmKzDFwjZtDl32wCeOw7HVxxxEp8VRoFhERERGRHWIrlmEfv43rdiCufuO446Q8V6M2aecPwTtvMKxZRXjLlYQvPo5t2hR3NBEpRrZ+HeHdQ+HrT3H+mXjHnYHzVJ6Ji9d3AGxYj70/Lu4oIiWeRjIREREREdkh9uYLYOD6DYg7SoniunTDG34vbr+DsPGvEt54ETZ9StyxRKQY2IplhLcPgjk/4gZehXfwEXFHKvNck+bQeW/s/dc1q1mkkFRoFhERERGR7WZLFmKT3sft3wdXu27ccUocV7kK3qkX4l1xMzhHeNf1hE+MwtavjTuaiBQRWzCXcMTVsGoF3iU34O3RPe5IkuD1Oz6a1TzhjbijiJRoKbf6hO/7NYBHgA5Ea1SfARwCnA0sS7xsSBAEb8WTUERERERE7PVnIT0dd9hxcUcp0VzbXfGGjcbGPY+NfxWbOhnvhIHQdV+cc3HHE5EksZlTCe+9BSpUxLt6BK5xs7gjyVbcTi2h817Y+69hvfrhKmfEHUmkRErFGc2jgHeCIGgLdAKmJ7bfHQRB58SXiswiIiIiIjGxBXOwLyfievXDVa8Zd5wSz5WvgHfMaXjX/htq1CZ88A7C+27FslbEHU1EkiD8ciLhf4ZBjdp4g+9UkTlFeX0HQPZ67APNahbZUSlVaPZ9vxrQA3gUIAiCnCAIVsWbSkREREREthaO/S9UrIQ75Oi4o5QqbqeWeENG4o79F0z7hnDYBdgP38QdS0QKIXz/NeyhO6FZa7xBI3C168QdSf6Ca9oSOu2JvfcatiE77jgiJVJKFZqBFkTtMR73ff8b3/cf8X3/t+sVLvR9/zvf9x/zfV/TJkREREREYmA/z4Qp/8P1PgqXUTXuOKWOS0vDO+QovGH3QO26hA+MwBbMjTuWiGwnC0PCFx/DXngUuuyDd/lwjZklgNdvAGSv06xmkR3kzCzuDJv5vr878DmwbxAEX/i+PwpYA4wBlhP1bL4JaBAEwRnbeP9AYCBAEARdc3Jyii27iEhplZ6eTl5eXtwxRERKvNIynmYNu5jcubPIfOBFvErqYVmU8pcvZeWgs8BLo9Ydj5BWs3bckURSQqqPp5abw5p7bmHjxPeodOgxVD3zUlxaWtyxpICybrmK3BlTyXzoZf2ck1KvfPnyAElbFCLVFgNcACwIguCLxOOXgMFBECz57QW+7z8MbPOjpSAIHgIeSjy05cuXF2VWEZEyITMzE42nIiKFVxrGU5s+hfC7r3D+maxcvwHWb4g7UinnwfnXEt4xmOXDL8e78lZchQpxhxKJjeVswp68B+/XuYR7HYDr1ivl+sRb9nrC+2+DGd/hjj6NTX2OJicrK+5Ysh3skKOxryax/MWn8LTgrZRyDRs2TOr+Uqp1RhAEi4H5vu+3SWzqBUzzfb/BVi87Cvi+2MOJiIiIiJRhZkY49hmomYk74NC445QZrmlLvLOvgHmzCB+7GwvDuCOJxMLWZBGOvDZaiLRSZeyVpwgHnUH+fbdiUydjYX7cEbFVKwjvvAZ++gF3xmV4hx6Dc0mbKCjFxDVrBR13x94bi21Ur2aR7ZFqM5oBLgL+6/t+eeBn4F/AaN/3OxO1zpgLnBNfPBERERGRMui7r+DnmbhTzseVKx93mjLFdd4bd9wZWPAo9urTuGNOizuSSLGyhb8Qjh4Oa1fhnXcNtQ/uy7Lvv8Umvod9OoHwm8+hVh3cvgfh9jsIV6v4F9yzRfMJ/3MDrF+Hd9FQ3C67FXsGSR6v3wDCW6/EPnwLd+ixcccRKTFSqkdzktnChQvjziAiUuKVhku9RURSQUkeTy0MCW+6FDZtxBt+Hy49FeerlG5mhv33fuzjd3CnXojXvXfckUSKhU37lvCB26F8ebwLr8M1a/W78dRyc7Fvv8AmvgvTp4DzoEMXvB69oeMexdIb2WZNI7znZkhPx7t4GK5pyyI/phS9/FE3wNyf8G57BFexUtxxRIpEonVGqe3RLCIiIiIiKcYmT4IFc3FnXq4ic0ycczBgILZsSVRwzqyHa9cp7lgiRSqcOB777/1QvzHeRdfjatf902tcuXK4PfaDPfbDli3G/u89bNIEwntvheq1cPv2wu13MK5O/SLJaN98TvjwSKiZiXfpDUV2HCl+Xt8BhCOuxj56C9fnmLjjiJQImtEsIiJ/qyTPwBMRSSUldTy1/HzCYRdGM/WG/gfnFf3sQPlrlr2e8PZBkLUC75o7cA2axB1JJOksDLGxT2Nvvwztd8M752pc5YzNz//TeGr5+TD1S8JPxsP3X4OF0K4TXo9DoPNeuPRySckZfvQW9uxD0GznqF1G1WpJ2a+kjvz/DIN5s/FGPIKrUDHuOCJJl+wZzSm1GKCIiIiIiKQW++wDWPIr3hEnqcicAlzlDLyLrof0dMJ7bsLWro47kkhSWc4m7KE7sbdfxvXoE81k3qrIXBAuLQ3XeW/SLh6KN+JhXP8TYclCwgfvILz6DMIXH8cWL9jxjGaErz6N/fcB6NgV74pbVGQupbx+J8C6NdhHb8UdRaRE0IxmERH5WyV1Bp6ISKopieOp5eYSXncuVKuBN2Rk1L5BUoL9PJNw5LWwUwu8K27WAo1SKtiaVYT33gJzfsQdczqu95HbHHd2ZDy1MB9++JZw4rvw3ZeQnw+td8F1743r0g1XvkLB9pOXhz01Bvvsg+i9J51XLH2gJT75dw+F+XPwbntYs5ql1NGMZhERERERKRb2ybuwchneUSeryJxiXIs2eGdcCrNnYE+MphRPIJIywhbNJ7ztKlgwB+/cQXiHHJXUccd5abiOXUk7fwje7Y/hjj4VslZgj95NeNXphM89hC2Y+/cZN24gHHNTVGTufyLulAtUZC4DvH4DYO1q7OO3444ikvK0koeIiIiIiPyJbdqIvfkCtOkI7TrHHUe2we2+H27pIuzVp6Few6g9gEgJZNOnED4wAtLS8a68Fde8dZEez1WviTv0WOyQo2HmVGzieOyTd7AP3oDmraOZynt0x1WstCXjmizC0TfB/J9xp16I1713kWaU1OF2bg/tOmHvvILtfxiuQsFmv4uURSo0i4iIiIjIn9gHb8Da1XhHajZzKnOHHgtLFmLjnies2wBv755xRxLZLuGk97Gn74W6DfEuHorLrFdsx3aeB+064dp1wtauwT7/MCo6PzUGCx7F7bk/rkdvqFiZcNQNsHol3vnX4jrtUWwZJTV4/U4gvGMw9sk7uIOPiDuOSFIUxdVQKjSLiIiIiMjvWPY67J2XoePuuJ3bxR1H/oZzDk45H1uxFHvyHqxWXVzrXeKOJfKPLAyx157F3gqgXSe8cwfhKleJLY+rWg138BHYQf1h1nRs4rvYZx9gn7wDaelQqXK06F+LNrFllPi4Vu2h7a7YOy9jPfpoVrOUWLZ+LUyfgk37FvvhG3g6uS1hVGgWEREREZHfsXfHQvZ6vCNPjjuKFIBLL4d33mDC264mvP9WvGvuxNVtGHcskb9kuTnY46OwLyfi9js4WlAvPTXKE845aNUe16o9NuBs7IuPYeb3uKNOwdXT/6uyzOs3gPDOIdjEd3AHaVazlAyWlwc/z8SmfYNN+xbm/gRmUCkD2nZM+vFSYyQXEREREZGUYGtWYRNej/r/7tQi7jhSQC6jKt7F1xPedhXh6JvwrrkDl1E17lgif2JrVxPeewvMnoE7+jRcn6NTtj2Pq1wF1/Nw6Hl43FEkBbjWHaBNx6hXc48+uPKa1Sypx8yillq/FZZnTIVNG8Dzoh70fQfgdtkNmrUqksVMVWgWEREREZHN7O2XICcHd4QWlitpXN2GeOcNIbz7esL7R+BdegMuvVzcsUQ2s8ULCEcPh1Ur8c65Grf7fnFHEtkuXr8TCEcOwSaOx/XqF3ccESDRDmPGd9gPieLyiqXRE3Xq4/beH9d+N2jbsVjaE6nQLCIiIiIiANjKZdhHb+O69cTVbxx3HNkBrvUuuNMuwh69G3vmPjjt4pSdLSpli82cSnjfbZCWhnfFzbiWbeOOJLLdXJsO0LoD9vbLWI9DcOXKxx1JyqDN7TCmJ/osz50FFkKlytB2V1yfY3DtO+PqNij2bIUuNPu+PxH4x2UKgyDoUdhjiYiIiIhI0bE3XgAzXL8T4o4iheDt3ZNwySLsjeehbkPcYcfFHUnKuPDTD7CnxkCd+ngXD8XVqR93JJEd5vUbQPjv67BPxuN69Y07jpQBZgZLF0XtMH74BmZOhY0bwHnQojWurx/NWm7eukjaYWyPZMxofmSr+y2BM4AngXnATsBpwGNJOI6IiIiIiBQRW7oQm/Q+bv9DcbXrxh1HCsn1PwGWLsRefRqr20AtCiQWZoa9/lz0oUfbXfHOHYzLKPpLt0WKVJuO0HoX7J2XsB69NatZioStXxe1w/ituPxbO4zMeri9ircdxvYodKE5CIInf7vv+/7nwCFBEPyw1bZniQrNwwqyP9/3axAVrzsQzZQ+A5gJvAA0A+YCfhAEWYXNLiIiIiIiEXvtOUhPxx3uxx1FksA5B6dfjK1YSvjYf/Bq1cG1aBN3LClDLDcXe2I09r+Pcfv2wp18vnqGS6ngnMPrO4Dwruux/3svWjBSJAlswRxs8qdRn+U5P21ph9Fm12jh1Pa7xdIOY3t4Sd5fO2D2H7bNAban+dIo4J0gCNoCnYDpwGBgQhAErYAJicciIiKFZvaP3Z9EREo9WzAX+/IT3IH9cNVrxh1HksSVK493wbVQoxbhmJux5UvijiRlhK1dExXh/vcx7siTcaddrCKzlC5td4Wd22NvvYTl5sadRko4WzSf/AdGEN54CfbmiwC4w328QSPw7nqGtAuG4B1wWMoXmSH5iwF+DDzh+/71wAKgCXADMLEgb/Z9vxrQAzgdIAiCHCDH9/0jgAMSL3sS+AgYlLzYIiJSFoUT3sBeeQLXaa9o1egWbbRgkoiUSeFr/4WKlXB9jo47iiSZq1od76KhhLddRXjPTXiDbsdVzog7lpRitmQh4egbYeVy3MCr8PboHnckkaRzzkW9mu8empjVfFjckaQEsuVLsHHPY599COUr4PoNwPXqh8uoGne0HZbsQvPpwH3AD4l95wKvAP8q4PtbAMuAx33f7wRMBi4B6gVBsAggCIJFvu9vs2mc7/sDgYGJ15GZmbnj34mIiACQnp5e6sZTM2N98Bjrn3+U9J3bkf/DN4RfTiR953ZUPvw4Ku57oHqtiUjSpep4mvvjNFZ++wUZJ5xNlabN444jRSEzk02Db2PV8MtIf/xualw3EpeW7F8FRSBn2resGjEY53nUuGkM5dt2LJLjpOp4KmWLde9F1tsvkv/uK9Q+coB+f5ACy89awfqXnmTD+LHgPCr3P56Mo07GKwVXlbmiuGTY930PqAMsC4Ig3I737Q58DuwbBMEXvu+PAtYAFwVBUGOr12UFQfBPf/q2cOHCHUgvIiJby8zMZPny5XHHSBoLQyx4FJswDtetF+7UCyE3B/vsQ+yDN2DxAqhWA9ejD27/PrgateKOLCKlRKqOp/l3XQ/z5+Dd9hCuYuW440gRCieOx54aE/18O+k8XcUjSRV+/iH25D2QWQ/voqFFeol3qo6nUvbYtG8I7x6GO+k8vAMOjTuOpDhbvxZ79xVswjjIz8ftezDucB9XK74Pzho2bAiQtBOCpH+M7ft+O+BYolnIF/q+3waoEATBdwV4+wJgQRAEXyQev0TUj3mJ7/sNErOZGwBLk51bRERKP8vPx54ag306AXdQf9xxZ+A8D9Iq4Xoehu3fB6ZPIfzgDezNF7C3X8J13RfXq68WUBKRUslmfAfTp0TjoYrMpZ7XvTfh0kXYOy9DvUa4g4+IO5KUAmYWXfo97jlo0xHvvGtwGVXijiVSPNp1hpZtsbdfxPY7SL3IZZts4wZswjjs3VdhYzZuzx64/ifg6jaMO1rSJXUxQN/3jwM+ARoBpyY2VwXuKsj7gyBYDMxPFKcBegHTgNeB0xLbTgNeS1ZmEREpGyw3h/CB26Mi8xEn4vwzoyLzVpzn4XbZjbSLrse7+f6o+Dz1S8LbriL/1isJP/8Iy9NiHyJSOpgZ4dhnoEZtnGZhlRnuqFOgyz7Yi49h337xz28Q+Ru2dCH20J3YuOdw+xyId+kNKjJLmeKcw+s7AFYuxyZNiDuOpBjLzSF8/3XCIQOxsc9Amw54Q0fhnXVFqSwyQ/JnNA8HDg6C4Fvf949PbJsCdNqOfVwE/Nf3/fLAz0T9nT0g8H3/TOAX4LgkZhYRkVLONm4gvO/WaNbegIF4vfr+43tc3Ya448/Cjjgxaqsx4Q3s0buwlx7f0lajFPTQEpEybOpXMHsG7uTzceUrxJ1GionzPLwzLiccOYTw4ZF4V4/ANW0ZdywpQcwMZk0nfG8sfPsFeGm4I0/GHXac2rFI2bTLbtC8NfbWi9i+vTSrWaIraT+dgL3xPKxcDu064R15cpm4SjbZhea6RIVlANvqtsCNoIMg+BbYfRtP9SpcNBERKYts/VrCUTfCvFm4f12K1+3A7Xq/q1gZ1/NwbP9DYdq3UVuNcc9hb72I22M/3IH9cM1bFVF6EZGiYWFI+OozUKc+bt+D4o4jxcxVqIB34XWEt15JOOYmvGtGxtofUkoGy8/Hvv4Me28szPkRMqriDj0O1/MwrWkhZZpzDq//CYSjbsQ+/QDX45C4I0lMLAyxyZOwsf+FpQuheWu80y/Btdue+bclW7ILzZOBU4Cntto2APhfko8jIiLyj2zVCsK7h8HShXjnDcZ13nuH9+U8Dzp0Ia1DF2zxr9hHb2GT3sc+/whatMEd2BfXtZtmMIhIiWCTP4UFc3BnXo5LT/qyLVICuOo18S66nvD2QVGx+eoRuIqV4o4lKcg2ZGP/9160eNWKpVC3Ae7Ec3HdDsRVqBh3PJHUsEuXLbOau/XSz9Yyxszgu6+ilmQL5kCjpngXXAud9ixzV3o4swJPNv5Hvu+3BcYDc4C9gY+A1kDvIAh+StqBCsYWLlxYzIcUESl9Suqq3rZsMeHdQ2HNarwLhhTJp8i2IRv79APsgzeiT6yr14paaux/CK6a2mqIyO+lynhq+fmEwy6EtDS8YaNwXlrckSRGNnUy4T03wa67451/jf49yGa2clnUOmziu7AhG1q1x+t9JOy6R+z/TlJlPBXZmk39inD0cNypF+J17x13HCkmNnMq4atPw+wZ0ZViR5wUXflaQn6eNmzYECBp1fCkFpoBfN+vDPQFmgLzgTeCIFiX1IMUjArNIiJJUBJP5O3XX6Iic14u3iXDcM1bF+3xwhB++Ibwg3Hw/deQno7bvTuuV19cM7XVEJFIqoyn4aT3sSdG450/BLfbjl/pIaVH+OFb2LMP4A7qj3f8WXHHkZjZvFnY+LHYV/8HgOu6L+7gI1OqVViqjKciWzMzwluugHVr8G5+QLOaSzmb8xPh2Kdh2rfRwsr9jsd1O6jE/b0nu9Cc1O/e9/0jiQrLQTI/MFiSAAAgAElEQVT3KyIiUlD280zC0cMhvRzeVbfhGu1U5Md0ngcdu5LWsSu2eAH2wZvRTOfPP4SWbaO2Gl26lbiTDhEpfSw3F3v9OWjWCjrvFXccSRFez8MIl/yKvf86Yd2GeD0PizuSFDMLQ/juy2iBvx9/gIqVcL36RV+168YdT6REcM7h9TuBcMxN2Ocf4vY7OGn7trw8WJ0Fq1ZA1nJs1QrIir4sa0W0fdNG3FGnaDZ1EbNffyF87Rn45nOoUhV33Bm4Aw7VwsoJyf6N9wbgMd/3XwGeCYLgoyTvX0RE5C/Z9CmE994C1WrgXTYcV6d+sWdw9RvjTjwHO/LkaKXhD97AHh6J1aiF2/9QXI9DcNVqFHsuEREgugR+5TK80y4scz0D5e85/wxs2WLsuYewWnVwnfaIO5IUA9u0CfvsA+z912HJr1CrTlQ06d4bV6ly3PFESp5dd4emO0e9mvfuWaCJJrZpY1Q0XrVV0ThrOZa1ErKWR4/XrII/diQoVx5q1IKambgWbaN2N0+NIVy5DNf/RP2cTzJbthh7/Tnsi4+gQsXoz/ig/hor/6AoWme0B04kWgSwIvAC8GwQBJOTeqB/ptYZIiJJUFIuTbRvPid86A6o1wjv0htTZvVzC0P4fjLhhDdg2jeQng4t2+EaN4PGzXBNmkPDnXDlyscdVUSKWNzjqW3aSDhkINRvjHflLfoFVP7ENm4gHHktLJqPd9WtqP1T6WWrs7AP38Q+fhvWrYWmO+N6Hxm1yUhL/b6icY+nIn/HpvyPcMzNuNMvxnXaM1E4ThSRNxeUl8OqRCE5e/2fd1I5A2pmQo1auJqZUKM21KyNqxndUqM2ZFT93c9yy8vDnrkPm/Q+bp+euFMv1ELlSWCrVmBvBtjE8eCl4Q48HNfnGFyVanFHS4qU79G8Nd/39waGA72CICjun1YqNIuIJEFJOJEPP/0Ae3I0NN056smcUTXuSNtki+Zjn7yLzZ4Bv86DnE3RE54H9RpFRefGzaMidJNm0eKCKgSJlBpxj6fh2y9jrzyJN2gEbuf2seWQ1Garswhvuwpyc/CuuROXWS/uSJJE9us87L2x2BcfQ34+dNoT7+AjoVX7EnXOEfd4KvJ3zIzw5svhl9l/ftI5qFZzy0zkmrUSBeVEEfm3gnKFijt8bHvjBez1Z6FdJ7xzB+MqZxTyOyqbbHVW1K/+wzchzI+u9Djcx9WoHXe0pCoRhWbf95sQzWg+kWhRwFeCICjuVSVUaBYRSYJUP5EPJ4zDnn84OpE6fwiuYqW4IxWIhfmwdDEsmIMtmIstmAvz58DKZVteVKUaNGmOa9QMmjTDNW4ODZrgymlmgkiqsfx8yF4H69dGswPXr8PWr40er48eV27YmA0t20GTFsVe0LHsdYTXDISWbUm7eGixHltKHlv4C+Htg6B6LbxBt+MyqsQdqcSyjdmwZFH0M71qtVh6eJoZTPs26r/8wzdQvny0YNVB/XH1GhZ7nmRI9fNTEfvlZ+x/n0CNmlFh8rdZydVrFsu6LeGkCdjTY6BBE7yLhuJqZRb5MUsLW7oIG/8qNmkC5Ofh9to/apMRQ1vG4pDShWbf988nKi53At4CngPeCoIgJ2kHKTgVmkVEkiBVT+TNDBv3PDbuOdhtb7yzryoVBVhbvw5+KzwvmIPNnwMLf4HcxI/StDSo3zgx+zlRfG7SDFetZqy5RUoLC/NhQ3aiWBx92VbF4z9ty14X3W7YxmWvv3EeVKocvRaiXzI7dMF16ArtO+MqF30RL3ztv9gbL+Bdfzdup5ZFfjwp+Wzm94R3D4WWbaOWVKXgZ2xxs6WLCO+6HlYs3bKxQsWo6FylGlStjqsa3VKlelSIrlp9c1GaKtWhUuUd/mDKcnOx/32CvTc2upKqek1cz8Nx+/cp8Zd8p+r5qUgqsR++IXxgBFSsHF312bhZ3JFSmv0yG3vnFeyrSZDm4fY5ENf7KFz9RnFHK1KpXmh+G3gWeDUIgnVJ2/GOUaFZRCQJUvFE3sIQCx7FJozDdesV9R8rAf0Ed5Tl58PShZtnPW+e/bxqxZYXVavxu7YbrnHzqCBdDDMmREoa27QJe+clWLY4+nBnq1nHZK/782I7v3EOKmVARpWoEJRRJWrV87uvKrgqf9hWqTLO86iZ5lgx8X2YOhmb9k3Uk9HzoGVbXMfdcR27QqNmSZ/tbGtXE14zENehC965g5K6byndwi8+xh75N27P/XFnXV6iWivEzRbNj4rMubk4/4yoTcXa1bB2DaxbjW11n7Vrtnyg/Efp6YnC9FaF6KrVoUpVqFI98XirYnVGFcheh338TnS59+osaNQUd/CRuD17lJoPDFLx/FQkFdn8OYSjb4RNG/HOuwbXrlPckVKKmcHMqYRvvxytp1OxUvRh3EH9S12LjL+SsoVm3/fTgAnAIUEQbErKTgtHhWYRkSRItRN5y8/HnhqDfTohOgE47gyc58UdKxa2bk1i9vMcmJ+4XfgL5OVFL0hPj1pttO+M63cirkLxX64rkmoszCe8/3aY8gVk1oPKVaLFdKpERWIyqiVuE9sqbykqUzkD5+34h1pbj6eWnw8/z8S+n4xN/Sr68AiiHo0du+I6dIF2nZOyknkYPIq9Pw7vxjG4Bo0LvT8pW8I3A2zsM7jDjsM76pS445QI9stswruHgefhXX4TrlHTf37Ppo3bLkSvXQ3r1kQ/89eu3vyYDdnb3pHzwHNRYXuX3aL+y+07l7oPCVLt/FQkldnKZYSjh8PiBbjTLsbbp2fckWJnYQjffkH4zssw58foCpOD+uMOOLRYrjRLJSlbaAbwfX8e0CYIgo1J2+mOU6FZRCQJUulE3nJzCB8aCd9+HvXJ6nt8qfvFqbAsLw+WLEwUn+dg83+Gad9G/dkGXqVL5qTMC194BHv/ddyAs/F69SvWY//deGqrVmDff419Pzn6P7shO2qVs3P7ROG5KzTcabvHPFu5nPDac3B79sD71yXJ+DakjDEz7Ol7sYnjcadcgNfjkLgjpTSbPYNw1I1QqRLe5TcXWQ9ky82NCs5rVycK02u2PM7Px+19QIEK3CVVKp2fipQElr2O8L7bYOZU3JEn4w47rkz+HmV5udjnH2HvvgKLf4U69aP2GN0OjKWHfipI9ULzGUAPYBiwANi88yAIwqQdqGBUaBYRSYJUOZG3jRsI77sVpk+JpUBUktm0bwgfvRs2ZOP8M3D7H1omTyxFwglvYM8/hOvVD2/A2cV+/IKOp5aXBz/PwKZOjgrPC+ZGT9TKxHXYHdexC7TtVKDFT8On78MmvY938/24zHqF/A6krLL8fMIxN8G0b/EuvD5q8yJ/YjO+IxxzM1SrgXfFzbjadeOOVGqlyvmpSEliebnYE6OxLz7Gde+NO+m8Ut1+cGu2MRv7ZDz23mtR+8EmzXF9jsF13bfM/Bn8lVQvNP9WTN56pw6wIAgK9Dfn+/5cYC2QD+QFQbC77/s3AGcDyxIvGxIEwVv/sCsVmkVEkiAVTuRt/dpodtC8WdHlXt0OjDVPSWRrsggf+0+02nyXffBOvTDqLStSRti3X0QzeTrtgXfe4EK1wNhROzqe2srl2A9fRy02pk+BjRui1jitdsF16BoV/eo3/tMHSLZ0EeHQ83E9DsE78dxkfRtSRtnGbMI7roGli/GuvlWLSv6BTf2K8P4RkFkvapdRo1bckUq1VDg/FSmJzAwb+wz21ovQoSveOVcX6IPrksrWrsYmjIt61mevhzYd8focA7vspok3CckuNCd7haDmSdpPzyAI/vhT4+4gCEYmaf8iIlJC2KoVUZ/DpQuj4lDnveOOVCK5ajXxLh6Gvf8a9srThMMvwTvrSlyr9nFHEylyNm8W4cMjYacWeGddEUuRuTBcrUxc997QvTeWlwuzpid6O0/GXnwMe/ExqF030WJjd2jbEVehIjbuOUhLwx3mx/0tSCngKlbGu3go4W1XEY6+Ce+aO3G168QdKyXY5EmED/8bGjXFu/RGXNVqcUcSEdkm5xzuqFMIa9fBnnmA8M4heBcPxVWvGXe0pLLlS7DxY7FJ70FODuy2N16fY3At2sQdrdRLaqE5CIJ5AL7ve0C9IAgWJXP/IiJSttiyxYR3D4U1q/AuHqZVkgvJeR6u91FY6w6ED91JeOcQXL8BuMOPK3GFN5GCshVLCe+5CapWx7voelyFinFHKhSXXg7a7opruysc+y9sxbLNCwraZx9iH70N6eWgVXuY8R3ukKM1s1KSxtWojXfxMMLbBxHeMxzv6hG4yhlxx4pV+OkH2BOjoUXr6FyljP95iEjJ4PXog9WoTfjgHYS3XYV3yTBcgyZxxyo0WzAXe+dl7MuJ4Dzc3vtH50Kl4HsrKZLdOqMGcB9wLJAbBEGG7/v9gT2DILiugPuYA2QRtd94MAiChxKtM04H1gBfAVcEQZC1jfcOBAYCBEHQNScnp/DflIhIGZeenk5eXl6xHzdv3myybrwMy82h5vV3Ua61Zt4mU5i9nrUP3snGT8ZTbpfdqH7pMNIy1UtSSpdw/VpWXnMu4Ypl1BrxIOlNknXx3Y4p6vHUcnPImTaFnK8/Y9Pkz7Ds9dQe9QyeZldKkm367itWDb+M8rvsRo3r/o0rVy7uSLHIfucV1j44kvIdu1L9mtvxKlWOO1KZEdf5qUhpkztrOqtuvhLLz6PGNbdTvn3nuCPtkJxpU1j/ytPkTP4UV7ESlXofQeV+A/T7TQGUL18eUrhH8/NEReLhwLQgCGr6vl8H+DQIglYF3EfDIAgW+r5fF3gPuAiYCSwnKj7fBDQIguCMf9iVejSLiCRBHD3w7OeZUU/mcuXxLhuOa7RTsR6/rDAz7LMPsGcfhPRyeKdfjOu8V9yxRJLC8nKjceSnadEsnRS4IqK4x1MzU/9BKTLhpxOwx0fh9umJ+9elZe7fWvjuq9hLj8Oue+CdOwhXrnzckcoU9WgWSR5btphw9I2wfAnujMvx9tgv7kgFYmEIU78ifPslmD0DqlTD9eqH63mY1qLZDsnu0ewla0cJvYCLEy0zDCAIgmVAgT9CCIJgYeJ2KfAq0WzoJUEQ5AdBEAIPA3smObeIiKQImz6F8K7rIaMK3qARKjIXIeccXrdeeNfdDbXrEN57C+FzD2G5uiJISjYzw56+L2odceoFKVFkjkNZK/xJ8fK69cL1PzFq2TLuubjjFBszI3z9Weylx3G774d33jUqMotIiebq1McbdDs0a409dEf0QVoSJ6Umm+XlEX76AeGNFxOOuRlWrcSdMBBvxKN4fY9XkTlmyV4McDWQCWzuzez7/k5bP/47vu9nAF4QBGsT93sDw33fb7BVv+ejgO+TG1tEROJgG7Nh5XJYuQxbuQyWLsYmvA71GkWL6aivaLFw9RvhDb4Te+VJ7P3XsR9/wBt4Fa5B47ijiewQezPAPp2A6zcAr1uvuOOIlFqu7/GwfAk27nnC2nXx9j0o7khFysywlx7Hxo/FdeuFO+1CrXEgIqWCq1IN7/Lh2KN3R1drrFgKA85KqTHO1q/DPv8QGz8WVi6DRk1xZ16O230/XHqyy5uyo5L9N/EI8LLv+9cCnu/7+wC3Ag8U8P31gFd93/8t27NBELzj+/7Tvu93JpolPRc4J8m5RUQkySw/H1at3FJE3rqg/Nvj7HW/f5PnQZuOeOdcrU+ii5krVw53/FlY206ET4wivPky3InnRL9Ia1aklCDh5x9ir/0Xt3dPXL8T4o4jUqo55+CUC7BVK7Cn78Vq1sa13y3uWEXCwhB79gHs43dwPQ/HDTgb5yX7AmERkfi4cuVh4FXwch1s/FgsawXeWVfgKlSIJY+ZwYK50YLHUyfDzzMgDKFVe7yTz4MOXfV7SgpKdo9mB1xCtCBfU+AX4EFgVBAExT3vXj2aRUSSYFs98MwMstcnCsaJ4vGKZZC1fEshOWslWPj7nVWuArXqQO06uFqZ0f2ambjadaL71Wvh0lLnU/OyylatIHzkLpg5FbdnD9xJ5+EqZ8QdS+Qf2czvCe8eCju3w7v0Blx6ai1Qpp6iUlrZhmzC2wfBiqVR26vG8S68mWyWn489MRr7/ENcn2NwR5+q4kbMNJ6KFK1wwhvYCw9D89Z4F16Hq1q9WI5rG7Jh+rfY1MnY95OjiUsATXfGdeiC67QXrnmBloCTAkp2j+akFppTjArNIiI7ICoir4PVWbA6iyp5Oayd9/MfZiYvh00bfv/G9HSoGRWPNxeRa9XBJQrL1MzEVawUzzcl283CfOztl7HXn4VadaJWGs1bxx1L5C/ZogWEI66C6rXwBt2Oy6gSd6Q/UWFESjNbuZzwtqsA8K65MzoXKAUsL5fw4ZHw9We4I0/GHXaciswpQOOpSNGzrz8jfOTfULN2tLBy3YbJP4YZLPwF+35yNGt51jTIz4dKGbhddotmLXfogqteM+nHlkhKF5p93+8JzA2CYI7v+/WB24F8YEgQBIuTdqCCUaFZRCTBzGDjhqh4vCYL1qzCVq+CNatgTRa2OitxP/GVn/fnnVStvtVs5D/MRK5VB6pW1yWkpZDNmh6dYK5aEf2C3fso/T1LyrE1q6IC16aNeENG4jLrxR1pm1QYkdLO5s8hvGMwZNbDu3oErlLluCMViuVsIrx/BHw/GXf8mXgHHRF3JEnQeCpSPGz2DMIxNwEumtncsm3h97lxA8z4LjFr+atoEhNA4+a4jl1wHXaHlm11pWsxSXahOdk9mu8DDkncvytxmwc8BPRP8rFERMo827Rpc+GY1VnY5vurtrqfuM3N+fMOPA+q1oDqNaBaDVyjppvvU60mrloNarZoRRYernw8vbkkXm7ndnhD/0P41Bjs5Sex6VPwzrhMswokZdimTdGK42uy8K68NWWLzCJlgWvSHO+cQYT3DCd84Ha8i64vsQs02cZswntuhp9+wJ1yAV6PQ/75TSIipYxr2RZv8J2Eo24gvOs6vLOuxO2293btw8xg8a+JWctfwU8/QF4eVKwE7Trh+g7A7dKl1FwJU9Yle0bzmiAIqvm+nw4sIerTnAMsDIKguP/FaEaziJQq9vNM7P3XsawVUXF59ao/t68AcA6qVEsUi2tEBcFE4ZjqNXCb79eEjKr/ODtVM0YEohNEm/gu9vwjULFSVGzu0CXuWFLGWZhP+MDt8O0XeOdds92/+BQ3jadSVoQTx2NPjcHtexDutItKXKsJW7+OcNQNMG8W7ozL8PbaP+5I8gcaT0WKl61ZFX2wP/cn3ICz8Q7s+/ev37QJfpy6ZSG/5UuiJxruhOvQFdexK+zcLuXW0yiLUn1G8xrf9+sBHYBpQRCs832/PKB/OSIiO8hyc7DXnsXGj4UqVaMfzk13jorH1WtunnkczUSuGbWw0GVGkmTOOVyPPljL9oQPR7MaXO+jcEedrBNEiY299AR88znu+LNSvsgsUpZ43XsTrliKvRlAZj1c3+PjjlRgtmYV4d3DYPF8vHMHa2wREQFctRp4V9xC+MhI7LmHCFcswx1z2u8mLdnShdjUr6N2GDO/j66oLV8hmrV8yNG4jl1xtevG+F1IcUh2ofke4EugPHBpYtu+wIwkH0dEpEywOT8RPv4fWDQf17037rgzSny/QynZXKOd8IaMxF58DBv/Kvbj93hnX4mr2yDuaFLGhB++ib33Gu7AvngHqUObSKpxR5wEK5Zhr/2XMLMu3t494470jyxrBeFd18PKpXgXXKcrd0REtuIqVMA7bzD2/MPY+Fdh5TLY96AtC/ktTXQVqN8It3+faNZyq11w5crHG1yKVVILzUEQ3O77/qtAfhAEsxObfwXOSuZxRERKO8vNxd54HnvnZaheC++SG/TLjqQMV74C7qTzsHadCJ+8h/CmS3Enn69Li6XY2JQvsecehk574o4/M+44IrINzjk47UIsazn2xD1Y9Vq4dp3ijvWXbNniqMi8bk103tW6Q9yRRERSjvPS4IRzoHY97KXHsa/+D8qVhzYdcb36Rm0xNAGlTEtqj2YA3/fTgL2BhsBC4PMgCPKTepCCUY9mESmRbN4swsdHwa/zot6G/pm4yhmx5VEPPPk7tmIZ4SMjYdZ0XLdeuBMG4ipW2vH9mcHGDZC9Dtavgw3rYf06LHtdYtv66DY7sW39Oti4Abf7frh+A0pcH1DZfjZvNuEdg6FBE7yrbsVVqBh3pALTeCplkWWvIxwxCFatxBt0O67RTnFH+hNbtCAqMudswrv0RlzzVnFHkn+g8VQkfjZ7BmSvhzYdtHB8CZbsHs3JXgxwV2AsUBFYADQGNgJHBUEwJWkHKhgVmkWkRLG8XOzNAHvrRahWA+/UC3Edd487lk7k5R9Zfn40A//NAOo2xDv7SqhTf3NBmPXrIHv9VsXixG32emzz/S3bCMO/PpjnQeUMqFxly1d+HsycGn0wc8oF6lFeitmKZYS3XQXp6XjX3BktdlqCaDyVsspWLI3+76Yl/u/WqBV3pM1s/hzCu4cC4F0+HNe4ecyJpCA0noqIJEeqLwb4GHAvcFcQBOb7vgMuS2zvmuRjiYiUGvbLz1Ev5gVzcfv0xB1/Ni6jStyxRArEpaXhjjgJa7sr4SN3Ed582d+/IS1tq0JxBlSpGl1it/W2yhnR/4Hftv12v2KlP81aNjNs3HPYuOexdWvwBl6lWRWlkGWvJ7xneDTj8LLhJa7ILFKWudp18S4aSnjnNYT3DMe76rZCXf2SLPbzTMJRN0CFSlGRuX7juCOJiIiUaMme0bwGqLl1q4xEK42sIAiqJe1ABaMZzSKS8iwvD3vrReytAKpUwzvlAlynPeOO9TuaMSLbw9auwSa9B14aZFTBbS4UbzULuULFImlxEX74Fvbcg7BzO7wLr4uOLaWC5eURjr4Rfvw+6p2awn1e/47GUynrbOpXhGNuhl264F1wbaxXoNjM7wnvuQmqVce7/CZcZr3Yssj203gqIpIcqT6j+S2gP/DqVtv6AW8m+TgiIiWeLZhD+Nh/YP4c3N4H4AacjcuoGncskUJxVavh+hwTy7G9nocRVqmGPXoX4Z1DooJkCl2eLTvGzLBn7oPpU3CnX1Jii8wiAq7j7riTzsWevg979gE4+fxYeuvb95MJ77sNMutFM5lr1C72DCIiIqVRoQvNvu8/Dfw2LToNeMH3/a+A+UATopYZrxX2OCIipYXl5WHvvIy98QJUzsA7fwhut73jjiVSKnh77IdlVCG871bC2wdFizrVaxh3LCkEe+tFbNL7uL4D8PbtFXccESkkr0cfwuVLsLdfhsx6uEOPLbJjWZgPOTmQsxE2bYKcHGzeT9hT90LDJlEbnqrVi+z4IiIiZU0yZjTP+sPj77e6Pw14d3t25vv+XGAtkA/kBUGwu+/7tYAXgGbAXMAPgiBrB/OKiMTGfp1H+PgomDcLt0d33Ann4KoWd2chkdLNte+Md+UthKNujIrNl9yAa9oy7liyA8IvPsbGPoPbuyeu/wlxxxGRJHFHngIrlmGvPEVYrSauTQfI2RR9bdq0+b5t2rhle86mqGCck5N43UZs6+c2/f45cjZBXu62A7Rog3fJMLVYEhERSbJCF5qDILgRwPf9dOBk4GAgE1gOTACeDoLgL37C/6WeQRBs3XBpMDAhCIIRvu8PTjweVNjs8mcWhrBqBSxbjC1dBMsWw/IlWNYKXJsOuP0OVv8ykR1g+fnYu69g456DShl45w7Gde0WdyyRUss1a4U36HbC/wwjHDkkunJALRdKFPvxe+yJUdC6A+7UC2O5vF5EiobzPDj9EmzVCuyJURR41aC0dKhQAcpv9VWhYnSbUTVaCHZbzyW+XIUKUKEStOmgRWNFRESKQFJ6NPu+Xx0YDzQF3gG+BhoAtwHn+b5/UBAEqwtxiCOAAxL3nwQ+QoXmHWa5ObB8CSxdjC2Lism2bDEsWxRtz8vb8mLPg9p1oUq1xIJlL0L7znjdD4FOe+DSy8X3jYiUELbwl2gW89yfcLvvhzvxHF2mKVIMXP1GW4rNo2/EO+tKfcBTQtjiBYT3/j979x0nd3Xf+/91Zou0q7IraVcNAWogUQUYEJheDDbGuMR83eOW4MSxr3OT3OvEN/m53Zs4N8mNfZ3EMcG+LnHhxDFu2BiMjSk2zQVsQBQ11KWVtGorbZvz++M7q11JC1pJsztbXs/HYx7znfmW+cw8xGH2vWc/56+haWb+S4Iav29Io02oqaHwvr8i/eIBCIU8CK4dB7W1BwbEPds1tYTqci8xJEmSyimkNODfH7+gLMv+hTxkzmKMe/o8PwGIwOoY43sHeK2VwHbyvs+fjTHenGVZa4yxsc8x22OMU/o59ybgJoAY40s6OjqO5W2NWCkl0q6ddG9cR9emtXRvXE/3xnX5bdM6ilu3HHB8GF9P1czj8tuM2b3bM4+jqnkGoSr/Qte9eQN7776dvXd/j+LWzRQapjD+yuuou/oGqmcfX4m3Kg1rqbubtu98jd1fu4Uwvo7J7/kzxo/A/qLV1dV09f0FlDTCFHftpPWv/xudT/+WSe/5b9Rf+5pKl6QXUdyxnW0f/H3Svr1M/dt/o2oU9dh2PJWk8nA8laTyqK2tBSjbnw6WK2heD1wQY3y+n31zgZ/HGGcN8FqzY4zrsyybDtwFvB/4zkCC5oOk9evXD/g9jDSp2A3bt8LmDaXZyD2zkzfl7S727jnwhIYp0DyT0DwTmmdB8wxC8yxongmTGo7oz1FTsRt++0uK990Jjz8CxSIsOoNwyTWEcy4k1NSW+d1KI0/asJbiFz4FK56Gcy6k8JY/IEw+3LA1PDU1NdHS0nL4A6VhLLW3U/zs38JvHiW8+s2EV77BVgzDUOpop/gPfwlrV1L4s78mzDu50iWVleOpJJWH46kklcfs2bOhjEFzuf72qAFY9wL71gIDXukqxri+dL85y7LbgPOBTVmWzYoxbsiybBaw+VgLHqnSju2k275EeuinB1pyYloAACAASURBVLa4qKrKW1w0zyTMX5TfTy+Fyk0zCOPGl62GUKiCM8+j6szzSK3bSA/8iHT/XaRb/oE0YRLhgssJl1xLOO6Esr2mNFKkYjfpR98h3fbvMG484ff/LF/0z0BLqqgwbhyF936I9KVPk779Vdi5A974+3mfUA0LqVik+Ll/hJXP5H3sR1nILEmSJI125QqalwNXks9APthVwIqBXKTUaqMQY9xV2r4G+BjwHeDtwCdK998uR9EjSerszMOr2yN0dRIuuhpOnN87K3lqUx4AD7HQOJXwyoz0itfDssdJ991JuucHpLu/CwsW57Ocz724rEG3NFyljevyWczLl8FZSym89b2EhpE5i1kajUJ1NbzjAzCpkXTnbbB7J7zrj11vYJhI//lF+OXPCNm7CedcWOlyJEmSJB2hcgXN/wf4UpZl7wNuizEWsywrAK8DPg18aIDXmQHclmVZT21fjTHekWXZI0DMsuzdwPPAjWWqe9hLKcGvH6L4H5/PW2IsOZ/Cje8iDLN+haFQgFPPIpx6FmnXDtLPf5yHzl/4v6RbbyGcf2k+y/nEBZUuVSq7VCySfvxd0je/nC9U8+7/Slh6ubOYpWEoFAqEG99JcXID6RtfIO3ZReEP/4Iwvq7SpY0YqasLOjugo73P7cDHqaMdOkuP20v7Ow/a3/ec9n2w/nnCFa8kXH1Dpd+iJEmSpKNQlh7NAFmW/SnwEWAc0AI0Ae3Ax2KMf1eWFzkyI75Hc1q3muKtt8BTj8Gs4ym88fcIp55d6bIGLKUEzz6ZB86/eCD/ofSEBfks56WXEerqK12idMzS5vUUv/B/4dkn4czzKLztvYTGaZUuq6zsgafRqvjA3aQvfRpOWEDhv3yYMGnAnb5GtdS6jfStfyetW52HwAeHyt3dR37RUIDacVBbW7ofd8jjMPsEwg1vqshfaA0Vx1NJKg/HU0kqj3L3aC5b0AyQZdkk4KXkIXML+SKAO8v2AkdmxAbNafdO0re/SvrpHVBXny9adNkrCFUj9wevtGc36aF7SPfdCWtX5T9Qnncx4ZJrYf4iZ35qRCrefxfpazdDVTXhjb9PuPCKUflv2S/yGs3SYw9T/Oz/hmnNFP74o4Rp0ytdUsWkYpF07x2kb34JOjvh5NNh/HhCTyhcc3BInAfFoZ/nDjmuqnpUjo9HyvFUksrD8VSSymNYB83DzIgLmlNXF+mnd5C+81XY15aHyze8iTBx9MywSinBqmfzWc4P35v/qezsE/JZzhdeQZgwqdIlSoeVUiJ979b8v9VTllB45x8TpoyuWcx9+UVeo1169kmKn/44jBufh81jcDHbtHYVxS//M6x4GhafmfeYH2ZtukYDx1NJKg/HU0kqD4PmgUvrfvAtOO2cfPGfYS498au8TcaGNXlw9YbfIxx3YqXLGlRpXxvp4fvyWc6rnoXqGsI5LyVceg2cfLoznzQspWKR9PWbST/5PuHCKwm/+74RMcYcC7/IayxIa1dR/ORHoLODwvv/irDwlEqXNCRSezvpe18n3fUtqJuQL8R3gT3mB4vjqSSVh+OpJJWHQfPApTWvPBcmTs4XorvgCpi7cNj94JQ2rc8X+nvsYWieSSF7FyxZOuzqHGxpzUrSfT8kPfhT2LsHps8mXHk94dJrCDW1lS5PAiB1dZI+/0nSI/cRrnkt4fXvGBP/rfpFXmNFatlE8R8/DK0tFP7gzwlnnFvpkgZV+u0vKH7lX6FlE+Giq/MxbRT9FdVw5HgqSeXheCpJ5WHQPHBp3Q++Tfr5j0mPPQxdnTBzTt6eYenlhGnNlS2ubQ/p9ki6+7v5TN7rM8JVNxBqaipaV6Wl9nbSLx4g3XsHLF8GU5oI17+B8NKrRv2sUQ1vaV8bxc98Ap78NeH176Bw7esqXdKQ8Yu8xpK0s5Xipz4Ka1cS3vEBChdeUemSyi7t2E669RbSI/fBzOMovPWPCItOr3RZY4LjqSSVh+OpJJWHQfPA7e/RnNp2kx59gPTgT+DZJyGEvDXDhVfkrRrq6oeuqGI36YG7Sbd9GXbvzAPU176N0DBlyGoYCVJKsOxxird9GVY+A80z837V5186qlej1/CUdu2g+H8/Bs8vJ/zu+ylcdFWlSxpSfpHXWJP2tlH8l7+GZY8TbnwXhWteU+mSyiIVi/kaCf/5RehsJ1yXEV7+O2P+l9xDyfFUksrD8VSSysOgeeD6XQwwbdlIeuge0s9/Aps35Kuln3Uh4cLL4ZSzCFWDF2KmZ56geOu/wfMrYOEpFN74+4QTFw7a640GKSV4/FGK3/p3WLsSZh1P4dVvgXMuHBMtC1R5aetmip/8MGzdQuE9/52w5PxKlzTk/CKvsSh1dlL83D/AL36Wh7Gv+90R/f+dtG51vtjf8mWw6Ix8sb+Zx1W6rDHH8VSSysPxVJLKw6B54PoNmvfvTAlWPE168Cekh++Dtt3QMCWfMXvhlYTj55WvkK2bSd/4AunR+/NWEK9/B+G8S0b0D6xDLRWL8MufUfz2V2HjWjhhAYXXvBVOP8fPUYMmrXs+D5k79lF4318RTjq10iVVhF/kNValYjfpq58l/fSOvIfx2/5oUH8hPRhSezvp9q+T7vwW1NUTbnx3/hdd/r+zIhxPJak8HE8lqTwMmgfuRYPmAw7s7ITfPErx5z+B3zwK3V1w3Il54Lz0UkLjtKMroH0f6Y5vkn74TQgQrv0dwrWvI4wbd1TXE6Tu7nxG+ne+Bls35zPDX/NWwqIzKl2aRpn03FMUP/1xqKml8McfIcyZW+mSKsYv8hrLUkqk736N9N2vw5LzKdz03wi1I+P/4+m3v6T41X+FLRvzVl2vfydhkov9VZLjqSSVh+OpJJWHQfPADThoPuCk3TtJj9xP+vmP897AoQCnLMln/5x9AWHc+MNfIyXSw/eSvvEFaN2az5L+nbcTplZ2AcLRJHV1ku7/Een2W6F1G5yyJA+c5y+qdGkaBdJvHqX4r5+AxiYK//WjhKYZlS6povwiL0HxJ7eTvnZz/gvO9/0loX5ipUt6QWnHdlL8HOnhe2HGcRTe9l5/ITtMOJ5KUnk4nkpSeRg0D9xRBc0HXGDjury1xoP35LNnx9URzrmQcOEVsOj0fhelSyufzfswL18GJy6k8IbfG7N/bj8UUkc76ad3kH7wDdi1I59tdsObCSfMr3RpGqGKP/8J6QufgjnzKHzgw4TJjZUuqeL8Ii/lio/cR/rcP8KsORQ+8BFC49RKl3SAVCyS7i8t9tfRTnjFjYRXvN7F/oYRx1NJKg/HU0kqD4PmgTvmoHn/hYpFeO5J0oP35H2W97blvZaXXpbPdJ59Aql1G+m2L5N+djdMbswXDbrwSkKhUJYa9OLSvr2ku79LuvM2aNtDOPdiwg1vJsyaU+nS9kspQcsm0jNPwDO/Ja1+jjDvZMKl18Lck+yXOQwU7/wW6T8+D4vPpPDeDxHq6itd0rDgF3mpV3ryVxT/5W8gBJi/iDD3ZMK8hTD35IoGz4cu9veHhJnD5/+ByjmeSlJ5OJ5KUnkYNA9c2YLmAy7a0U567JG8tcYTv4RiEY6fB5s3Qncn4epXE6670YCqQlLbbtKd3yL96DvQ0UG44HLCq95IaJ459LWkBJvWk575bR4sP/MEbC99GZo4CY6fDyuehvZ9MGce4dJr8l9eDOM/xx6tUkqkb36JdMd/wkteSuHdf+oMwD78Ii8dKK1ZSbrn+6RVz8LaVfl3AYApTTDvJMLckwlzF+a/RBzk7wOpo510e8zXg6irJ9z4rvwX3f7yclhyPJWk8nA8laTyGPVBc5ZlVcCjwLoY4/VZln0BuAzYUTrkHTHGXw/gUoMSNB/wAju3kx6+L5/l3DiVwut+lzB99qC+pgYm7dpB+sE3SD/5PqQi4eKXEV75BsKUo1vYcUCvmRKsX9MbLD/7BOzYnu+c3Eg4+XQ4+fT8ftYcQqFA2tuW9/O+94fw/HKorSWce0k+y3n+IoOCIZC6u0lf/mfSAz8iXPZywpvf029bnLHML/LSC0vt7bBmBWnVM7Dy2Tx83rwh3xkCzJxDmHsSzDs5v58zt2y/yEpP/oriv38mX+zvwivzkNnF/oY1x1NJKg/HU0kqj7EQNP8JcC4wuU/Q/L0Y4zeO8FKDHjRr+Evbt5K+H0n33QmFKsLlr8j7VU5qOPZrF4uwdhXp2SdK4fITsHtnvrNxWh4oLzotv59x3GFD47T6OdK9d5Ie+im074XZJxAuvZZwwRWECc5yHgypo53izX8Hjz2cz3x/1ZsM9/vhF3npyKTdO2HVc6RVz5BWPpsvLryr9Pvy6mo4fj5h7kn5jOd5J8OM2UfUaivt3E669fOkh38K02fni/0tPnNw3ozKyvFUksrD8VSSyqPcQXN1uS5UDlmWzQFeCfwv4E8qXI5GgTBlGuEtf0i65rWk791K+tF3Sff+kHDVDYRrX3NEbSpSd3c+a62nDcazT0DbnnzntOmEM87NF4k8+XRomnHEgWU4cSHhbQtJN76T9Mh9pPvuJH3930j/+UXCS15KuORaOOlUg9AySW27Kf7T/4TnniK8+T0UrnhlpUuSNEqEiZPh9HMIp58DlP7iZVsLrHqGtDIPn9PP7oaf3E4CqKvPQ+fSjXkn9/sXOPlif3eR/vML0N5OuP6NhOteT6ipHcJ3J0mSJEn9G1YzmrMs+wbwN8Ak4M/6zGi+EGgH7gb+PMbY/gLn3wTcBBBjfElHR8eQ1K2Ro2vtKnbf+jna77+bMGES9a9+E/XXZxT66aGZurrofO4pOp/4FR1P/JrOZY+T9rYBUDXreGpPO4ua086m9rSzqBqkHtCdK59h753fYd+9PyS17aHquBOpe9kN1F3xCgqTGwflNceC7m0ttH78T+hau4qGD/x/jL/46kqXNKxVV1fT1dVV6TKkUSV1d9O9bjWdzz5J57NP0fnsk3Stfg66uwEoTG2i5qRTqVl4CtUnnUqhfgK7/t+n6XzqMWpOPYvJf/jfqZ4zt7JvQkfM8VSSysPxVJLKo7a2FkZj64wsy64HrosxvjfLssvpDZpnARuBWuBmYHmM8WMDuKStM/SC0pqVFL/9FXjsYZjUkLfTuOiqvBXGM6VWGMuXQUfpdxqzjiecfFqpx/JphMbB6/Xcb73t+0iPPkC674d5XdXVhHNeSrjkGlh0hrOcj0DatJ7iJz8Mu3ZQeO9fEE49u9IlDXv+aaI0NFJnBzy/Iu/zXJr5zOY+32UmTCLc+E7CS69y3B+hHE8lqTwcTyWpPEZtj+Ysy/4GeBvQBYwHJgPfjDG+tc8xl1MKoAdwSYNmHVZa8TTFb/07PPXYgTvmzCX0LNx30qmEYTR7OK1bnbfV+PmP89Yd02cTLr0mXwhqGNU5HKXVyyl+6iOQEoX/8mHCvJMqXdKI4Bd5qXLSnt2w+lnS5g2El1xUljUGVDmOp5JUHo6nklQeozZo7uvgGc0xxg1ZlgXgH4F9McY/H8BlDJo1YOnp35CWPU44cQGcdBphwqRKl3RYqaOd9Iuf5bOcn30SqqoJZy0lXHotLD7ziBaWGgvSsscp/vP/gvqJFP7rRwkz51S6pBHDL/KSVB6Op5JUHo6nklQeo3oxwBfwlSzLmsnf9K+BP6hwPRqFwqIzCIvOqHQZRyTUjiNceAVceAVpwxrSvfks5/SLB6B5JuHilxEuuprQMKXSpVZc+sXPKN7y9zB9NoU//mi/i2xJkiRJkiTp6A3LGc1l4oxmjTmps4P0y5+T7rsTnv4NVFXBkvMpXHItnHrWmJzlXPzpHaSvfAbmL6Lw/r8aEbPVhxtnjEhSeTieSlJ5OJ5KUnmMxRnNkgYo1NQSll4GSy8jbVxHuv9O0gN3U/zlz2HadMIV1xEufyVh3LhKlzroUkqk2yPp21+BM86l8J4Pjon3LUmSJEmSVAnOaJZGudTZSfr1Q6R774Blj0PDFMJ1NxIuuZZQU1Pp8gZFKhZJt95C+vH3CBdcQXj7+wnV/l7taDljRJLKw/FUksrD8VSSysMZzZKOSKipIZx3MZx3Mem5Jyne9mXS124m/fA2wg1vyoPYqqpKl1k2qauT9PlPkh65j3DNawi/844x2TJEkiRJkiRpKDmjWRpjUkrw5K8p3vZlWP0czDyOcMNbCC956YgPZNO+vRQ/8wl48leE17+DwrWvq3RJo4IzRiSpPBxPJak8HE8lqTyc0SzpmIQQ4LSzKZx6FvzqQYrf/grp5v9NmjOPwmvfCmecmx8zgqTODtKvHiT94D9h3WrCO/4LhYuurnRZkiRJkiRJY4ZBszRGhRDgnAspnHU+6eF7Sd/5GsVPfxwWLKbw2rcRFp1R6RIPKz2/nHT/j0gP/RTadsO06RT+6EOEJedXujRJkiRJkqQxxaBZGuNCoYpwwRWkcy8h/exHpO/eSvHv/wecsiQPnOedXOkSD5D27CY9dA/pgR/B8yuguoZwzoWEi18Gi84Y8e0/JEmSJEmSRiJ7NEs6QOrsIN3zA9L3/wN274SzllJ49VsIc+ZWrqZiEZY9Trr/LtKvHoSuTjhhAeHiqwnnX0aYMLFitY0F9sCTpPJwPJWk8nA8laTysEezpEEVamoJL3s16ZKXkX70XdKd36L4sQ8QzruEcMObCTNmD1ktaetm0gN3k352N2zdDPUTCZdeS7joasIJ84esDkmSJEmSJL04g2ZJ/Qrj6wnXv4F0xXWkH36TdPf3SI/en4e817+BMLV5UF53/8J+D/wInnosf/KUJYTfeTvhrKWEmtpBeV1JkiRJkiQdPYNmSS8qTJhEeN3bSVfdQPr+f5DuvYP08x8TLnsF4bobCZMby/I6/S3sF65/I+GiqwjTppflNSRJkiRJkjQ4DJolDUhomEJ4002ka15D+u7XST+5nXT/XYSrXkW45rVH1Sf5BRf2u+hqWHymC/tJkiRJkiSNEC4GKOmopI3rSN/5KumR+6B+Qh42X/Uqwvi6Fz+v34X95uctOZZeRpgwaYjegQbKxVYkqTwcTyWpPBxPJak8yr0Y4LAMmrMsqwIeBdbFGK/Psmwe8HVgKvBL4G0xxo7DXMagWRoCac1Kit/+Cjz2MExqyNtpXPbyQ3op97uw39LLCBdfTThhQYWq10D4RV6SysPxVJLKw/FUksqj3EHzcG2d8QHgKWBy6fHfAv8YY/x6lmX/Crwb+EylipPUKxw/j6r3/SVp+TKK3/p30q23kO78FuFVbyScdwnp8UcOXNhv8ZmE1/0u4ewLXNhPkiRJkiRplBh2QXOWZXOAVwL/C/iTLMsCcCXw5tIhXwQ+gkGzNKyEBYup+tP/SXrqMYq3fZn0pX8ifflfIBVhajPh+jcQXnoVoWlGpUuVJEmSJElSmQ27oBn4JPDfgZ5GrdOA1hhjV+nxWuC4/k7Msuwm4CaAGCNNTU2DXKqkQ1xyFeniK+l49AHaH3uYcedeTO2Z57qw3whWXV3teCpJZeB4Kknl4XgqScPTsAqasyy7HtgcY/xFlmWXl57ur09Iv42lY4w3Azf3HGPPJqmC5i2GeYvpANi2rdLV6BjYA0+SysPxVJLKw/FUksqj1KO5bIbbFMOLgBuyLFtFvvjfleQznBuzLOsJxecArvInSZIkSZIkScPEsAqaY4x/EWOcE2OcC7wR+HGM8S3AT4DXlw57O/DtCpUoSZIkSZIkSTrIsAqaX8QHyRcGfI68Z/PnKlyPJEmSJEmSJKkkpNRvu+PRIK1fb4cNSTpW9sCTpPJwPJWk8nA8laTyKPVo7m99vKMyUmY0S5IkSZIkSZKGqVE9o7nSBUiSJEmSJEnSMOaM5sPJsqyF/IPyVqZblmX/VukaRtvNz9TPdCTcHE8H5TP136mf6bC/+ZkOymfqeFr+z9R/p36mw/7mZzoon6njafk/U/+d+pkO+5uf6aB8pmXtQzRqg2agtdIFjELfrXQBo5Cfafn5mZaf42n5+e+0/PxMy8/PtPwcT8vPf6fl52dafn6m5ed4Wn7+Oy0/P9Py8zMtv7KOp6O2dUaWZY/GGM+tdB2SNNI5nkpSeTieSlJ5OJ5KUnmUezwdzTOab650AZI0SjieSlJ5OJ5KUnk4nkpSeZR1PB21M5olSZIkSZIkSUNjNM9oliRJkiRJkiQNAYNmSZIkSZIkSdIxMWiWJEmSJEmSJB0Tg2ZJkiRJkiRJ0jExaJYkSZIkSZIkHRODZkmSJEmSJEnSMTFoliRJkiRJkiQdE4NmSZIkSZIkSdIxMWiWJEmSJEmSJB0Tg2ZJkiRJkiRJ0jExaJYkSZIkSZIkHRODZkmSJEmSJEnSMakeqhfKsqwRuAU4HUjAu4DXAa8COoDlwDtjjK39nLsK2AV0A10xxnOHqGxJkiRJkiRJ0mEM5YzmTwF3xBgXA0uAp4C7gNNjjGcCzwB/8SLnXxFjPMuQWZIkSZIkSZKGlyGZ0Zxl2WTgUuAdADHGDvJZzHf2OexB4PVlfNlUxmtJkiRJkiRJ0mgTynWhoWqdMR/YAvy/LMuWAL8APhBj3NPnmHcBt77A+Qm4M8uyBHw2xnhzfwdlWXYTcBNAjJGOjo5y1S9JY1Z1dTVdXV2VLkOSRjzHU0kqD8dTSSqP2trasl5vqILmauAc4P0xxoeyLPsU8OfAXwFkWfY/gC7gKy9w/kUxxvVZlk0H7sqybFmM8d6DDyoF0D0hdGppaSn3+5CkMaepqQnHU0k6do6nklQejqeSVB6zZ88u6/WGqkfzWmBtjPGh0uNvkAfPZFn2duB64C0xxn7bXcQY15fuNwO3AecPesWSJEmSJEmSpAEZkqA5xrgRWJNl2aLSU1cBT2ZZ9nLgg8ANMca2/s7NsmxClmWTeraBa4DfDkHZkiRJkiRJkqQBGKrWGQDvB76SZVktsAJ4J/AIMI68HQbAgzHGP8iybDZwS4zxOmAGcFtpfzXw1RjjHUNYtyRJkiRJkiTpRYSU+u1WMRqk9evXV7oGSRrx7IEnSeXheCpJ5TGaxtO0tw22bYGtm0nbtsDWLbCthdTVSaiqgkIBClVQVVW6P+jxIc8VXuD5fF/Yf52DjilUQU0NVFX33lfXQPWB96EwVB1YDy+lBF2d0NmZ3/fcOrsOely6hwM+C17ssxjA5z2cPgvpaJV6NIdyXW8oZzRLkiRJkiSNCalYhJ3bYeuWPETeHyi3wNbN+eO2PQeeVFUNU5ugppZU7IbubigWS/elW3exdN/zXHHgNR3rmyoUesPnw4TSPduhv2OrqqC764AgOB0cGu/f7uo/UO7qOtZ3c2xCePGAenw9VR/9p8rWKA0xg2ZJkiRJkqQjlDo7SjOQt5C2boZSgLw/VN7WkoepfdVPgKnTYdp0wkmnwbRmmDqdMLUJpk2HyY1HPFM2pZSHzQeHz/2F0j2PD36uuyfQ7SJ1d+Whbk8Q3NXP/f5j8hnEqfug/R3teYje1dn/9bq781C2J5CuOei+ugbqJpQel8Lqg/e/0HZ1DaGm+oDH1NQA4aD33X3I55YOCfH7+wwPPa/fz7XKyE1jj//qJUmSJEmS+kjt7fls5J2tsGP7/vA4be2dmcyuHQeeFArQOBWmNhHmnQznXgRTmwnTpsPU5ny7rr7stYYQ8tC2qgpqynC9Y7/EiDWW37tUDgbNkiRJkiRp1Evt+/LguCc87tne1Zpv7ygFyzt3QPveQy9QW5vPRp7aTDh+Xh4eT5tOmNqcz0xunEaoNmaRNHY5AkqSJEmSpBEp7dvbGx7vbCX1zELe2dobJPfc2vf1f5GJk2BSY962Yu5J0DAFJpceT26EyVPyUHnipHz2sCSpXwbNkiRJkiRpyKWUoLMD9rXB3r35fdse2LeXtLet9HzpVjom7d3Dto59dG9ryWcgd7T3f/GJk3vD4nknl7an9AmPS7dJDc5ClqQycTSVJEmSJElHJKUE+/bmfYr37tkfBqe2PgHxvr2lfXtJ+0rP9+zvCZcPXiyvP9U1UFef38bXExqnEOYt6g2LGw4KjycaHktSJTjySpIkSZKkfAG8Xa2wa2fet3jXjjxILt3Srh15/+Ldpfuuzhe/YE9APL6uFBRPgGmlBfHG1x8QHlNXR6ibsH87v58A4+sINQeucDelqYmWlpZB/CQkSUfDoFmSJEmSpFEodXYeGhT3DZJ37oDdO/P+xbt3vnAP49ravIfxxMnQMIUwZy5Mmpw/N2kyoX7iQaFxaebxQQGxJGl0M2iWJEmSJGkYScVu2Lcvbz3Rvje/L93SvgMf5/vbDny+J1ze29b/C1RXw8QGmNyQ9yieMRsmNey/hVKAzKSGvKfxuPFD+wFIkkYkg2ZJkiRJko5C6u6Gznbo6MgXtevo2W7fv53a9x0SFh8QGve374UWuDtYKMD48TCuLm9PUWpREeaedFBw3HDAY+rqCSEM6mcjSRp7DJolSZIkSaNWSgn27ILWbbBjex7w9oTDHe2lgPjAcJjODtIBoXHfY/ucM5CF7A5WO643FO65NUwlzKg79PnxdTCujjC+vv99teMMjCVJw4ZBsyRJkiRpxEkpQdtuaN0OO7aSWrftD5NT6zbY0fN4G3QNIBCurYWacVBTm2/X9myPg8mNUFNLqK3tfa7n+P3b+S2MG9d7nXGl/ftnHI8nFKoG/8ORJKkCDJolSZIkScNGSgn27slD4tZtpdB4O+zYRmrd2jszuXUbdHUeeoG6CdA4FRqnEk46DRqm5NuNU6FhKtTV9R8QOzNYkqRjMmRBc5ZljcAtwOlAAt4FPA3cCswFVgFZjHF7P+e+HfjL0sP/GWP84hCULEmSJEkaBGnHdnh+OWn987B966GzkDs7Dj2prj4PihunEhYs3h8m0zCV0NBne9y4oX9DkiRpSGc0fwq4I8b4+izLaoF64EPA3THGT2RZ9ufAnwMf7HtSlmVTgQ8D55IH1L/Isuw7/QXSkiRJkqThI6WUB8nPP0davYL0/HJYvTwPlHuUehTTAeNzawAAIABJREFUOJUwb1EpMO4zC3l/gDy+cm9EkiQd1pAEzVmWTQYuBd4BEGPsADqyLHs1cHnpsC8C93BQ0AxcC9wVY9xWutZdwMuBrw123ZIkSZKkgUkpwdbNsHo56fnlvaHyrh35AaEAM48jnHImnLiAcMICmDOXUD+xsoVLkqSyGKoZzfOBLcD/y7JsCfAL4APAjBjjBoAY44Ysy6b3c+5xwJo+j9eWnjtElmU3ATeVrkdTU1P53oEkjVHV1dWOp5JUBo6nGk1SsUj3pvV0LV9G54qn6VrxDJ3Lnybt3pkfUFVF9fHzqT7vYmoWLKJ6/iJq5i4kjK+rbOEaFRxPJWl4GqqguRo4B3h/jPGhLMs+Rd4mYyD6W5Eh9XdgjPFm4OaeY1paWo64UEnSgZqamnA8laRj53iqkSoVu2HTBtLq5/K+yquXw5oVsLctP6C6Go6bSzj7AsKJC0szlU8k1dTSCexfrm/3nvwmHSPHU0kqj9mzZ5f1ekMVNK8F1sYYHyo9/gZ50Lwpy7JZpdnMs4DNL3Du5X0ezyFvsSFJkiRJKqPU3Q0b1uRtL55fkYfLa1ZC+778gJravN3F0svhhPmEExfA7BMI1TUVrVuSJFXekATNMcaNWZatybJsUYzxaeAq4MnS7e3AJ0r33+7n9B8Cf51l2ZTS42uAvxiCsiVJkiRp1EnFIrRugy0bSZvXw5YNsHkjacsG2LAWOjvyA8eNh+PnEy5+WSlUXggz5xCqqir7BiRJ0rA0VDOaAd4PfCXLslpgBfBOoADELMveDTwP3AiQZdm5wB/EGH8vxrgty7KPA4+UrvOxnoUBJUmSJEmHSt3d+cJ8WzaSNm+ALRvy+80boGVTb5gMUFUNTTOgeSZh0RnQ0/5ixixCwVBZkiQNTEip33bHo0Fav359pWuQpBHPHniSVB6Opyq31NkBWzYeGiZv2ZiHzN3dvQfX1kLzLGieRZg+Kw+Vp8+C6bNgapOBskYUx1NJKo9Sj+b+1sc7KkM5o1mSJEmSdATSvjbYvPGAELknVGb7Vug7cahuAkyflbe4OPcSmD6T0DwLps+EhqmEULafIyVJkg5h0CxJkiRJFZKK3bB9G7RsJG3ZCFs25dstm/KZybt2HHjC5MbeFhfN+YzknhnKTJhkmCxJkirGoFmSJEmSBlFq2533Rd6yidRSanVRCpTZugW6u3oPLhRg2nRomkE4a+kBrS6YPpMwvr5yb0SSJOlFGDRLkiRJ0jFIXV2wbUufmcj5bOT9s5Lbdh94wsRJMG1GvuDeS14KTTMJzTPzBfmmNhOq7JcsSZJGHoNmSZIkSTqM1L4P1j+ft7do2QQtm0qtLjbCthZIxd6Dq6rz0LhpOmHeSaUgeQY05WFyqJ9QuTciSZI0SAyaJUmSJKmP1NEOa1aSVj8Hq57L7zesPTBM7umVvPCUPFRunklomgnNM6BxKqHgrGRJkjS2GDRLkiRJGrNSZwesXU1a/WxvqLz+eSiWQuVJDTD3JMI5LyWcMB+mz8pnJY8bX9nCJUmShhmDZkmSJEljQurqhHWrD5ypvG41dHfnB0ycDHMXEs48nzB3IZy4EKZMI4RQ0bolSZJGAoNmSZIkSaNO6urKeyqvfg5WP0da9RysWwVdXfkB9RPzUPma1xJOXAhzF+YL8RkqS5IkHRWDZkmSJEkjWuruhg1rSKuXw+pn81B5zUro6swPqJsAJy4gXHUDnLiQMHdh3v7CUFmSJKlsDJolSZIkjRipqxPWryGtXQnPryCtehbWrICOjvyAcXV5qHzlK/NQ+cSF+UJ9hUJlC5ckSRrlDJolSZIkDUtp105Yu5K0ZgWsWZWHyxvW9PZUrh0HJywgXPry3lB5xmxDZUmSpAowaJYkSZJUUanYDZs3kNashDUrSWtX5bOUW7f1HtQ4FebMI5zxEjh+PmHOPJgxi1CoqljdkiRJ6jVkQXOWZauAXUA30BVjPDfLsluBRaVDGoHWGONZAzl3SIqWJEmSVFZpXxusXUVaswrWrMhD5XWreltfVFXBzDmExUvg+Ll5oHz8PMKkhgpWLUmSpMMZ6hnNV8QYW3oexBjf0LOdZdk/ADsGeq4kSZKk4SulBNu25DOU16zM216sWQlbNvYeVD8xD5EvfXk+W/n4eTDreEJNTeUKlyRJ0lEZFq0zsiwLQAZcWelaJEmSJB2Z1LY7b32xdlVptvJKWLsS2vbkB4QAzbPghPmEi64uzVKeC1OaCCFUsnRJkiSVyVAGzQm4M8uyBHw2xnhzn32XAJtijM8exbn7ZVl2E3ATQIyRpqam8lUvSWNUdXW146kklcFIHk9TsUhx2xa6N66je+N6ujeupWtTz/Y60u6d+48N4+uoOWE+1ZdcQ/XchfntxAUU6uor+A4kjSYjeTyVpNFsKIPmi2KM67Msmw7clWXZshjjvaV9bwK+dpTn7lcKoHtC6NTSYqcNSTpWTU1NOJ5K0rEb7uNp6miHlk2wZRNpywbYspG0ZWPe6qJlE3R19h5cVQVTm6F5FuElLyU0zyI0z4TjToTmmRQLBTqAjp7j97TlN0kqg+E+nkrSSDF79uyyXm/IguYY4/rS/eYsy24DzgfuzbKsGngd8JIjPXfwq5YkSZJGh5QS7N4FLRtJm/MgmS0bSS0bYfNGaN164Anj66B5Jsw+nrDkvDxUbp6ZPze1mVBVVZk3IkmSpGFpSILmLMsmAIUY467S9jXAx0q7rwaWxRjXHsW5kiRJkkpSd3e+AF9LaVby5lKQ3DMzee9Bs4obp0LzTMIpS2D6zAPD5ImT7Z8sSZKkARuqGc0zgNuyLOt5za/GGO8o7XsjB7XNyLJsNnBLjPG6w5wrSZIkjSlpb9shs5H3h8nbtkB3d+/B1dXQNCMPkBecAtNnEppnQdNMaJpBGDeucm9EkiRJo0pIKVW6hsGS1q9fX+kaJGnEsweeJJXHQMfTVOyG7dvyFhdbNvYJlTfBlg15+4u+Jk7Kg+SmGflM5OaZ+azkppkwZSqhYIsLSaOL308lqTxKPZrL9idsQ7kYoCRJkiQg7dubL7DXspG0eWOfUHkTbN0EXV29B+9feG8m4ZyL8lnJTaX2Fk0zCPUTKvdGJEmSpBKDZkmSJGmQpO5ueH45adnj7GjZSPe65/MZyjtbDzywbkIeHM85kXD2BdA8o9TiYoYL70mSJGlEMGiWJEmSyiQVi7D+edKyx0nLHodnfrt/Ab6O5hkwdTphyfm9fZOb83YXYcKkClcuSZIkHRuDZkmSJOkopZRgy4Y8VF72m/x+1458Z/NMwnmXwOIzCYtOp3n+SfYUlSRJ0qhl0CxJkiQdgbR9aylYLs1a3rYl39E4lXDa2bB4CWHxGYRp0ytbqCRJkjSEDJolSZKkF5F274Snf1tqh/EYbFyX75gwCRadQXj57xBOORNmHEcIZVu0W5IkSRpRDJolSZKkPtK+Nnj2yd4+y2tWQkowrg5OPo1wyTWExWfCnHmEQqHS5UqSJEnDgkGzJEmSxrTU2QErniY99VgeLK96Frq7oboaFpxCuOHNebA89yRCtV+fJUmSpP684DflLMtWAulwF4gxzi9rRZIkSdIgSinBqudIT/06D5afewo6OyAUYO5CwrWvy4PlBYsJteMqXa4kSZI0IrzYlIzf67P9EuDtwD8Bq4ETgT8Cvjh4pUmSJEnlkzasJT10D+mhn0LLpvzJOXMJl72csHgJnHQqoX5CZYuUJEmSRqgXDJpjjHf3bGdZ9kng5THGNX2eux24Hfi7Qa1QkiRJOkqpdRvp4XvzcPn55fms5VOWEF71RsLpLyFMbqx0iZIkSdKoMNAmc8cBOw56bgcwp7zlSJIkSccm7W0j/ernpAfvgWW/gVSEExcS3vBuwnmXEhqmVLpESZIkadQZaNB8O/CtLMs+DqwFjgc+VHpekiRJqqjU1QlP/Ir04D2kxx7Oey43zyS88kbC0ssIM50fIUmSJA2mgQbNNwEfB74AzAI2AhH48OCUJUmSJL24lBIsf4r00E9Jj9wPe3bBxMmEi68mLL0c5i8ihFDpMiVJkqQxYUBBc4xxL/BnpdtRybJsFbAL6Aa6YoznZln2EeD3gS2lwz4UY/x+P+e+HPgUUAXcEmP8xNHWIUmSpJEtbVhDevCnpIfuga2bobaWcNYFhKWXwalnE6oHOpdCkiRJUrkM+Ft4lmULgCXAxL7Pxxi/dASvd0WMseWg5/4xxvj3L/K6VcA/Ay8jb9vxSJZl34kxPnkErytJkqQRLLVuJT1834GL+p26hPDqtxDOXkoYX1/pEiVJkqQxbUBBc5ZlHwQ+CjwBtPXZlYAjCZqPxvnAczHGFaVavg68GjBoliRJGsXS3jbSL3+ez1zuWdRv7kmEN/we4bxLXNRPkiRJGkYGOqP5T4ALY4y/OobXSsCdWZYl4LMxxptLz78vy7LfBR4F/jTGuP2g844D1vR5vBZY2t8LZFl2E3k/aWKMNDU1HUO5kiSA6upqx1NJQyZ1dtL+qwfZd++dtD9yH3R0UDXzOMbf+A7GX3oN1cedUOkSj5rjqSSVh+OpJA1PAw2aO4DfHuNrXRRjXJ9l2XTgrizLlgGfIV9kMJXu/wF410Hn9beCS+rvBUrhdU+AnVpaDu7SIUk6Uk1NTTieShpMqViEFctID95DevSB3kX9LnoZYellpPmL2BcC+wBG8HjkeCpJ5eF4KknlMXv27LJeb6BB84eAT2VZ9uEY45bDHt2PGOP60v3mLMtuA86PMd7bsz/Lsn8DvtfPqWuB4/s8ngOsP5oaJEmSNDykzg5Y9jjp1w+THn8YWreVFvW7kHDBZXDKWS7qJ0mSJI0gA/32/sXS/XuyLOt5LgApxlh1uJOzLJsAFGKMu0rb1wAfy7JsVoxxQ+mw19L/rOlHgJOyLJsHrAPeCLx5gHVLkiRpmEi7dpJ+8wjpsYfhiV9B+z4YVwenn0046wLCWUsJ4+sqXaYkSZKkozDQoPmkY3ydGcBtpZC6GvhqjPGOLMu+nGXZWeStMFYB7wHIsmw2cEuM8boYY1eWZe8DfghUAZ+PMT5xjPVIkiRpCKSN60iPPUz69UOwfFm+oF/jNMKFVxCWLIVFZxBqaipdpiRJkqRjFFLqt93xC8qybHqMcfMg1VNOaf16O2xI0rGyB56kI5GK3bDi6bwlxmMPwcZ1+Y7j5+UzlpcshRPmE0J/y3CMbo6nklQejqeSVB6lHs1l+2I+oBnNWZY1AJ8GMqAbmJBl2auAc2OMHy5XMZIkSRp5Uvs+ePLXpMceIj3+KOzaAVXVsOh0wpXXE848nzCtudJlSpIkSRpEA22d8RlgD3kLjcdLzz0E/ANg0CxJkjTGpNZtpMcfyVtiPPUYdHVC/QTC6efCWUsJp51NqJ9Q6TIlSZIkDZGBBs1XA3NijB1ZliWAGOPmLMtmDF5pkiRJGi5SSrD+edKvH8oX81v5TL6jaQbh8lcQlpwPC08lVA/066UkSZKk0WSgPwnsBKYCG3ueyLLseGDTYBQlSZKkyktdXfDck73hckvpq9+8kwmveSvhrKUw+4Qx2W9ZkiRJ0oEGGjR/HviPLMs+BBSyLDsP+Bvgs4NWmSRJkoZUSgm2biY99xT85hek3z4KbXugphZOWUJ4xesJZ55HaJxa6VIlSZIkDTMDDZr/BugAPgeMB75KHjL/n0GqS5IkSYMsdXbC88tJy58iLV8Gy5+GHdvynZMaCGdfQFiyFE49izBufGWLlSRJkjSsHTZozrKsCngL8OkY498PfkmSJEkaDGnHdli+jLR8GWn5U7D6Oejqync2zyScciYsWExYcAocdwKhUFXZgiVJkiSNGIcNmmOM3VmWfTrG+KWhKEiSJEnHLhW7Ye1q0opl+8NltpSW26iugbkLCVe+irBgcR4uN0ypbMGSJEmSRrSBts64Pcuy62KM3x/UaiRJknRUUttuWPF0abbyMljxDLTvzXc2TIEFpxAuvy4Plk9YQKipqWzBkiRJkkaVgQbNBeCbWZbdD6wBUs+OGOO7BqMwSZIk9S+lBJvWl/oql/orb1gDKUEowPFzCS+9Ig+XFyyGadMJIVS6bEmSJEmj2ECD5meBvxvMQiRJktS/1N4Oq54lrVi2P1xm9658Z/0EmL+YcN4leag872TC+LrKFixJkiRpzHnRoDnLsjfFGL8WY/yroSpIkiRpLEn79kLrVti+lbR9a+926Z7WrbCzNZ+tDDBzDmHJ+b2zlWfOIRQKlX0TkiRJksa8w81o/izwtaEoRJIkaTRJxSLs3lkKjreRtrfk262lQLknRN7bdujJ9RNhyjRonEo4fh5MaSLMXQjzFxEmTh7y9yJJkiRJh3O4oLlszfyyLFsF7AK6ga4Y47lZlv0d8CqgA1gOvDPG2DqQc8tVlyRJ0pFKXZ2wYztsbyFt31YKk1ugtRQob98KO7ZBV9eBJ4YCNDTClCaYeRxh8Zn59pSphClN0DgNGqcRxo2rzBuTJEmSpKN0uKC5KsuyK3iRwDnG+OMjeL0rYowtfR7fBfxFjLEry7K/Bf4C+OAAz5UkSTpiqasL9rXlM4n37indt5EOetyzP+1t6/f4Q9TW5kHxlCbCwlN6t6dM3b/N5EZCVdXQv2lJkiRJGmSHC5rHAZ/jhYPmBMw/2hePMd7Z5+GDwOuP9lqSJGnsSB3t+Yzina2wYzupbfeLB8d9g+KOjsO/QHUN1NWXbhPy++mzCOPr88X3Sq0twpRppRB5GtRPJISy/TGYJEmSJI0ohwua98QYjzpIPkgC7syyLAGfjTHefND+dwG3HuW5AGRZdhNwE0CMkaampvJULkljWHV1teOphkTq7qK4o5Vi61aK27fl963b6N6e3xd77lu3ktr2vOB1wvh6woQJFOonUqirJ0yZSqg/gUL9BEL9BEL9xNL2REL9hHx7wsT8+br6fLumdgjfucYKx1NJKg/HU0kang4XNJfTRTHG9VmWTQfuyrJsWYzxXoAsy/4H0AV85UjP7asUQPeE0KmlxU4bknSsmpqacDzV0UopQdse2Lk9n3ncZxYyO7eTdrTu38funZDSoRepq4fJU6ChkTD7BDhlCWFyIzRMIUyeApMbYeKk/LjxdYRCb2uK4pEW3FWEHTuP6T1LL8TxVJLKw/FUkspj9uzZZb3ekC0GGGNcX7rfnGXZbcD5wL1Zlr0duB64KsbYz0+XL3xuuWqTJEn9SynlrSb2tcG+vb0tKPa1kfYe+JjS47S37YAw+ZAF8QCqq0vh8RSYNp0wf1FvmNzz/ORGmDzFhfEkSZIkaQR40aA5xjipHC+SZdkEoBBj3FXavgb4WJZlLydf/O+yGGM/q+q88LnlqEuSpNEsdXfns4R37zooIC6Fxj0B8b69sG/vgYve9d1fHMC84Kqq0ozi0m1yI2Hmcb1h8uRGQkPP9hSon2A/Y0mSJEkaRYaqdcYM4LYsy3pe86sxxjuyLHuOfMHBu0r7Howx/kGWZbOBW2KM173QuUNUtyRJw0ratxd27chnDO9qJe3s2d4Bu3aQdrbu38fuXYe/4LjxeTBcV1e6r4eJDYS+j/vsDwc87nNMdY3BsSRJkiSNYSH11wtxdEjr16+vdA2SNOLZA29wpWI37Nmdh8M7W0m7+gTHfR/3PNfR3v+F6ibkrSYmNeSzhyc37N9mwuRSQFx3YHA8ro5QVdX/9SSVneOpJJWH46kklUepR3PZZgwN5WKAkiSNOWnPbti8gbR5PWzekG/v2NZnFvJOSP20pigUYFKf4HjG7N4geVJjvhje5Ib9x4SamqF/c5IkSZIklRg0S5J0DFJKeYuKzetJWzbAplKYvCW/Z0+f9hUhwJRpMKUJmmcRFizunXV8QHjcAPUTCYVC5d6YJEmSJElHwKBZkqTDSCnlPY83byCVZiUfsL13T+/BoQBTm2D6LMJ5F+eB8vRZMH0WNM8k1NRW7o1IkiRJkjRIDJolSaIUJu/Yfmibi56Zyfv29h5cKMC06XmYPP/k/H767DxMnjbDNhaSJEmSpDHHoFmSNOql7u58RvKOVti5nbRjex4q79hOat0KWzbmYXLfhfaqqmDaDJgxm3DSaQfOTJ42nVDt/0IlSZIkSerhT8mSpBEppQR72/LAuCc83rkdWnse56EyO7bD7p2Q0qEXqZ8ADVPzlhaLz4Tps3vD5KnNhKqqoX9jkiRJkiSNQAbNkqRhJXV1ws7W3hnHO7f3zkQuhch5uNwKnR2HXqC6GiZPgYYp+czj+YuhoREmTyE0lJ5vmAKTG+2XLEmSJElSmRg0S5KGTOrshNatsK2FtH0LbO/ZboHtLbCtJZ993J+Jk3sD4pNO7Q2TG6YQJjeWtqdC/QRCCEP7xiRJkiRJGuMMmiVJZZG6OqF12yHBcb69FbZtgV07Dj2xfiJMmZa3qph7MjROzcPjhqn7ZyIzuYFQ7QJ7kiRJkiQNV/8/e3ceH1V1/nH8c24SIOxL2BJWWQRFUURUQBRZXVhEndZWrbWt3ay11f7aqq1LW6utttbue21rl1FAEJBVQEHFfUVU1gBhC/saktzn98cZFpVKIJO5M5Pv+/XKKwmZ3PvNGM+9eeac56jQLCIiR2UVFbB9C2wtxbYkishbN2NbNvlZyNs2+1YWH+6DnN8AmhdAsxa4DickPi7ANSvwHzdtgauXH80PJSIiIiIiIiJJo0KziIgAic31dm6DtcXY2lVQUoyVFLNpaynh1s0fLSLXy4dEwdi173zo4wNF5GYtcPXqR/PDiIiIiIiIiEhKqdAsIlIL2e5dvpC8dhWUrMLWFkNJ8Qf7IzdsBIUdqXP62ZTlN0wUkVtAs5b+43wVkUVERERERETEU6FZRCSL2b69sG71oRnKa4uhZJXvpXxAvXwo6og7/Wz/vrADFHWARk1xztGkoIDS0tLofggRERERERERSXsqNIuIZAEr3w/r1350hnLphkMPqlMH2nbA9eydKCh39AXlZgU456ILLyIiIiIiIiIZL2WF5lgsthLYCVQCFfF4vG8sFmsO/BfoBKwEYvF4fOsRvvczwO2JT38Yj8cfTkVmEZF0Y5WVsLEE1q7CDp+hvGEdWOgflJMLbYpwnbvDwGGHZigXtMYFOdH+ACIiIiIiIiKSlVI9o3lwPB4/fP31d4A58Xj83lgs9p3E598+/BsSxeg7gL6AAS/HYrHJRypIi4hkE6ushHXF2MqlsGoptuJ9WLsSKir8A1wArdpCYXtc34FQ2BFX1AFaFeJytWBFRERERERERFIn6krEGOD8xMcPA/P4UKEZGAHMisfjWwBisdgsYCTw79REFBGpeRaGsGHtoaLyyvdh9XLYv98/IL8+dOyKGzIKijr5gnKbdrg6daMNLiIiIiIiIiJCagvNBsyMxWIG/D4ej/8BaB2Px9cBxOPxdbFYrNURvq8IWH3Y52sS//YRsVjseuD6xPEoKChIZn4RkaQwMyrXr6Vi6TuUL1tC+dIlVCx7F9u3BwBXL5+8E7qTN+JScrv2JK9LD3LatsMFQSR5c3NzNZ6KiCSBxlMRkeTQeCoikp5SWWgeEI/HSxLF5FmxWGxJFb/vSDtU2ZEemChe/+HAY0pLS4/0MBGRlDEz2FIKq97HVr5/cMYye3b7B+TmQfvOuHMG4zp1xXXsBm2LCIMcyoCyAwfasiWaHwAoKChA46mISPVpPBURSQ6NpyIiyVFYWJjU46Ws0ByPx0sS7zfGYrGJQD9gQywWa5uYzdwW2HiEb13DofYaAO3wLTZERNKObduSaH2RaH+xains3O6/mJPj2170HQiduuE6doXCDuqnLCIiIiIiIiIZLyXVjVgs1gAI4vH4zsTHw4G7gcnAZ4B7E+8nHeHbZwD3xGKxZonPhwPfrfnUIiIfz3buSMxUXoqtWgorl8K2zf6LLvCb9J3aFzp2w3XqCu064fLqRJpZRERERERERKQmpGoaXWtgYiwWO3DOf8Xj8emxWOxFIB6LxT4HFANXAMRisb7Al+Lx+Ofj8fiWWCz2A+DFxLHuPrAxoIhIqtieXbBqWaKo/L4vKm8+bBFGmyJcj1P8hn2dukL7E3B160WWV0REREREREQklZzZEdsdZwMrKSmJOoOIZCDbtxeKlx9sfWErl8LGw8aTlm1824tOXf37jl1x+fWjC1zD1ANPRCQ5NJ6KiCSHxlMRkeRI9Gg+0v54x0WNQUWkVrP9ZbB6xcHWF7byfVi/Bg68CNe8wBeS+1+A69zNf9ygUbShRURERERERETSjArNIlJrWEU5rF3lZyivShSVS4qhstI/oHFTv0lf34G4TokZy42bfewxRUREREREREREhWYRyVJWWQnrVn+w/cWaFVBR4R/QoJGfnTziTFwn3/6CZi1wLmkrRkREREREREREag0VmkUk45kZbN6ILX0HVr7vi8url8P+/f4B+fWhQxfckFG4Tr79BQWtVVQWEREREREREUkSFZpFJONYWAlrVmFLF8PSd7D3F8O2zf6Lder6ovKgkX7Gcqdu0KotLggizSwiIiIiIiIiks1UaBaRtGdlZbDyPez9xb64vGwJ7Nvrv9isANf9ZOh6Eq5rTyjsgMvJiTawiIiIiIiIiEgto0KziKQd27HNz1Reuti3wyhe5jfsc84Xks8+P1FYPgnXomXUcUVEREREREREaj0VmkUkUmYGG9f5mcrvJwrLG9b6L+bmQeduuOGX4rqdBCf0wDVoGG1gERERERERERH5CBWaRSSlrKICVq9IzFb2xWV2bvdfbNAIuvbEDRyK63qS77GclxdtYBEREREREREROSoVmkWkRtnePbD8XSzRCoPl78L+Mv/Flm1wvfr4NhjdToLWRdq0T0REREREREQkA6nQLCJJZbt3wftvY+++ib33FqxeCRaCC6B9Z9y5w/2mfV174pq2iDquiIiIiIiIiIgkgQrNIlIttme376387hvYu2/B6uVgBnl14IQTcRcPhPFIAAAgAElEQVTHcN16+o/r1Y86roiIiIiIiIiI1AAVmkXkmNjePbB0MbbkTezdN6F4uZ+xnJsHXXrgLvkkrscp0Lk7Lq9O1HFFRERERERERCQFUlpojsViOcBLwNp4PH5JLBZ7BmiU+HIr4IV4PD72CN9XCbyZ+LQ4Ho+PTklgEcH27YGl7/jC8ntvwaqlEIaQm3toxnKPU/zHKiyLiIiIiIiIiNRKqZ7R/HXgHaAxQDweP/fAF2Kx2Hhg0v/4vr3xePy0mo8nIla2zxeWD7TCWPm+Lyzn5PpZyhdejjvxFDihB65u3ajjioiIiIiIiIhIGkhZoTkWi7UDLgZ+BHzzQ19rBFwAfDZVeUTEs7IyWPaO37zv3Td9YbmyEnJyoFM33MjLfGG5Sw9c3XpRxxURERERERERkTSUyhnNDwL/x6FWGYe7FJgTj8d3/I/vrReLxV4CKoB74/H44zWUUSTr2f4yWLbkUGF5xftQWQFB4AvLw8fiTjzVF5br5UcdV0REREREREREMkBKCs2xWOwSYGM8Hn85Foudf4SHXAn86WMO0SEej5fEYrETgKdisdib8Xh82RHOcz1wPUA8HqegoCAJ6UUyl1VWULm2mPJVS6lYsZTyd9+i/L23oaIcgoDcLj2oM/oT1Ol1Bnk9TyHIbxB1ZElDubm5Gk9FRJJA46mISHJoPBURSU/OzGr8JLFY7MfA1fgZyfXwPZonxOPxq2KxWAvgPaAoHo/vq8Kx/gZMicfjjx3loVZSUlK94CIZxHZuh9UrsDUrYc1KbO1KKCmGigr/gJxcaNcJd+IpfvO+rifh8utHGVkyREFBAaWlpVHHEBHJeBpPRUSSQ+OpiEhyFBYWArhkHS8lM5rj8fh3ge8CJGY03xKPx69KfPkKfOH4iEXmWCzWDNgTj8fLYrFYATAA+EnNpxZJT1ZRDuvX+ILy6pX+/dqVsH3roQc1aeaLykNG+fftOkGbdrjcvGhCi4iIiIiIiIhIVktlj+b/5ZPAvYf/QywW6wt8KR6Pfx7oCfw+FouFQIDv0bw49TFFUsvMfPH4wOzkNSux1Stg/Rq/WR9Abi4UdsCddDq07+wLykUdcY2bRhldRERERERERERqmZS0zoiIWmdIxrDy/bBuNbZ65QcKy+zcfuhBzQoSs5M7QlEnXPvO0KoQl5sOrxdJNtPSRBGR5NB4KiKSHBpPRUSSIyNbZ4jIB9nuXdjT0w/1VN6wFsLQfzGvjp+l3LvfobYXRR1xDRtHGVlEREREREREROR/UqFZJAoObMLfoUUrX0zuc44vKLfrBK3a4oKcqBOKiIiIiIiIiIhUmQrNIhFw9RsSPPQfXH79qKOIiIiIiIiIiIhUWxB1AJHaSkVmERERERERERHJFio0i4iIiIiIiIiIiEi1qNAsIiIiIiIiIiIiItWiQrOIiIiIiIiIiIiIVIsKzSIiIiIiIiIiIiJSLc7Mos5QU7L2BxMRERERERERERFJApesA2XtjOZYLFaKf6L0lqS3WCz2x6gzZNubnlM9p5nwpvG0Rp5T/Z7qOU37Nz2nNfKcajxN/nOq31M9p2n/pue0Rp5TjafJf071e6rnNO3f9JzWyHNaShJlbaEZ2BZ1gCz0RNQBspCe0+TTc5p8Gk+TT7+nyafnNPn0nCafxtPk0+9p8uk5TT49p8mn8TT59HuafHpOk0/PafIldTzN2tYZsVjspXg83jfqHCIimU7jqYhIcmg8FRFJDo2nIiLJkezxNJtnNP8h6gAiIllC46mISHJoPBURSQ6NpyIiyZHU8TRrZzSLiIiIiIiIiIiISGpk84xmEREREREREREREUkBFZpFREREREREREREpFpUaBYRERERERERERGRalGhWURERERERERERESqRYVmEREREREREREREakWFZpFREREREREREREpFpUaBYRERERERERERGRalGhWURERERERERERESqRYVmEREREREREREREakWFZpFREREREREREREpFpUaBYRERERERERERGRalGhWURERERERERERESqRYVmEREREREREREREakWFZpFREREREREREREpFpUaBYRERERERERERGRasmNOkANsqgDiIiIiIiIiIiIiKQxl6wDZXOhmZKSkqgjiIhkvIKCAkpLS6OOISKS8TSeiogkh8ZTEZHkKCwsTOrx1DpDRERERERERERERKpFhWYRERERERERERERqRYVmkVERERERERERESkWlRozkC2by/2zuvYjq1RRxERyWgWhn48Ld2AmfaQFRGpDlu2BFu3Ggsro44iIpLRbO0qbNUyrKI86igiIsckqzcDzFY2/mFs3jT/SdMW0LELrkMXXMeu/uOmzaMNKCKSIeyZmdg/f+M/adgIOnTBJcZUOnaFgtY4l7QNeEVEspYtXUx433f8J3XrQfsTcB27JMbVrtC2CBfkRBtSRCQD2I5thD+6Gcr3Q04uFHX042nHrv59USdcXl7UMUVEjkiF5gxjO7ZhC2fDaWfjup8Mq5b6VzrfePHQbLwmzQ8rPieKJU2bp2WxxMr3w8b1sGENtn4trF+LbSyBDWuh60kEn78FV7du1DFFJAtZWInNmOCLIOcOh+Jl2Kql2MxJWGWFf1D9honx9IRDN/ct26bneFpZCZs3+HF0/VrYsBbbUALr10LT5gQ33IZr2iLqmCKSpcLpE6BhI9zln4Xi5X48fWYm7C/DAOrUhfadD76Q5zp2gbbtcTnpV3y2MIStmxPj6NoPjKs4R/Clb/viuYhIDbCnpkBFOe7TX4bSDVjxMuzlZ+GZmX48zcmBwg6HJpp17ArtOuHy6kQd/SPMDHZug/Ulh8bTDYnxdM9ugk9/Cdenf9QxRSSJXBYvFbaSkpKoMyRdOOkRbGqc4O5f49q0O/jvtm8PFK/AipfBKl8sYf1asNA/oHFTf1Pf4YSDFySaFaSkWGJmH71ZT7xn86ZDGQGaNofWRbgmzbEXn4buvQi+9j1c3Xo1nlNEjqygoIDS0tKoYySdvbyQ8Hf3EXz5Ox+4wbXycli78rDxdBmsXQkVieJzfgPo8KGZeq3a4oKa70ZlZrBrR6LosQY2HLppZ9N6OFAgBz9Du3URrlVb7JXnoUkzgpt/iGteUOM5ReTIsnY8Xbea8PtfxY36JMHoTx3697AS1q1NjKd+cgSrl0PZPv+AvDq+OHJ4saRte1xuaubC2N49iftSP54eLChvLIH9ZYceWDcfWhfi2hRhy5bA3t0EN92N69wtJTlF5KOydjzdt5fw25+DHqeQ8+XvHvp3MyjdcGhixCp/n8runf4BQZAoPidezOvQxb+4Vyc1k7Zsf5kfOw++MHfYPere3YcemJsHrQv9W+kGWLOS4Au34PoOTElOEfmowsJCgKQVB1VoziBWts9fdLqdRM5Xb6vS41m9HFu13N/cFy+DktWHCruNmiSKJV0PzXxu3vK4i8+2b4+/oCRmJh8sLG8oOfQHBfjllK0Lca2LoE2RL4S0KfL/Vq/+wYeFz8/F/vIL6NaT4Gvfx9XLP65cIlI92Xgjb2aE99wCe3YR/OA3R13ObRXlsLbYv4hXnCg+r1kJB/rm1cv342mHw4olrdse9zJxv9pj3WEF5cNmJ+/ZdeiBubnQsi20OTCOFh0cW13DxoeOt2wJ4YN3QKMmBDf/CNei5XHlEpHqycbxFCD820PYC08T3PdnXKMmH/tYCyv9/WKiSGLFS6F4Oezb6x+Qm5coPh8287mwAy73+JaJW0WFL2ZsKPEF5fWH3Z9uP2y/ExdAQSto086Po4nCMm2KoMmhlYG2eSPh/bfB7p0EX78T16XHceUSkerJ2vF09mTsv38i+M5Pjjq+mBls3njw3tRWLfXF5107/AOCwL94d/hKkvadj3sSl1/tUervS9ev/eB4umUTHF5balbg70cP3Je2LoTWRdCi5cH7Y9u3h/AXd8PyJbjrvkFw1nnHlUtEqkeF5qrLukJzOGcK9p8/EHz7PlzXnsd1DCsrgzUrPlgsKSmGMFF8PrxHaceu0KHLB3qUfnRp9mGvVG7fcuhEzkGLVh+6uPgiCM1aVLmYHS6aj/3559DlRIKv3/GBQrSIpEY23sjbu28R3n8r7qqvEJw38viOUVEBJQeKz36ZOGtW+n564GfAte/8wWJJm0M9Si0MYdvmD9yk23pfBPnIzfqB1R5tDoyn7fxMkIJWVS5m2/J3fbG5QSOCW36Ea9HquH5uETl+WTmebttM+N0v4AYOJ/j0l47vGGEIGxPF5wP3p8XLYO8e/4DcXN+TtGOXQy/mFXY82KPUL83e/oEl2QdbXWxaD5WHbU54YLVHmyJo3e7gZAdatq1yz1PbsskXm3du98Xm47wvF5Hjl5XjaUUF4W1fhBYtyfm/e4/vGGawpfRDM5+X+jES/ItqbYo+uJKkfecPTOqyPbs/UEw+OIFsYwns33/oZHXzP/D3/qG/+QurXMy2fXsJf3k3vP8O7rqvE5w9+Lh+bhE5fio0V11WFZqtstJfdJq1IOfb9yX32PvLYM3Kw27ul/ri84Gb8voNoagD7NrpZ9gdvjS7QSN/QWlVeNiMunbQqk3SekSFLy7A/nQ/dO7ub+bzVWwWSaVsvJGvfOhuWPk+wb1/SuqSQquogPWrD5upl1gmfuCmPNGjlP1lfvbHB5Zm10vMSC48bLVHu8Rqj+Ss6LAV7xM++H3Ib+DbaLRsk5TjikjVZON4Go5/GJsxkeCHv8W1apu041oYwqb1H5wcUbwM9iSWYOfk+vvTnNyDvT4Pys2FA/emrQs/UFA+fLVHtfJtKSV84HbYvtVPhuh2UlKOKyJVk5Xj6aL52J8eILjhe7jeZybtuAdbWR4+87l42aFVHc75CWENG/ti8o5th745CKCg9QdXzSXuU2nSLCmtOK1sH+EvfwDvvYW79kaC/kOqfUwRqToVmqsuqwrNBy86X70Nd9pZNX4+K98Pa1YdurkvKYZGTQ+bTZe4aW+UnJv1o+Z5+VnCP/4UOnQhuOkuXP0GKTmviGTfjbytWUl41424sVcRXByr+fNVVsL6NYdmPq9eDnXqHdbqohDatEvZpq22ahnhz74H9er5NhpJLAyJyMfLuvF07x7Cb1+HO7kPwRf/r+bPZ5YoPh82OcLsI62DDl+aXaN5tm32xeatmwlu/D6ue68aP6eIeFk3npoR3n0TVFYQ3PnL1Oz9sW3zwf1IrHgZ7N51cMLDwWJyyzbH3bromLKUlRH++oew5A3cNTcQDBxW4+cUEU+F5qrLmkKzmRH+4CYoLye461cpueikI3v1ecLf/wTad/bF5gYNo44kUitk2418+JefY68853uJNmgUdZxIWPFywp9/D/Lq+pnNrQujjiRSK2TdeDpjIvbYXwluewDXqXZujGfbt/pi8+aNfgPrHqdGHUmkVsi28dTefpXwwTtw136dYEDtnNFr+8sIf30PLH4Vd/VXCQaNiDqSSK2Q7EJz7axYZpp3XoPVK3DDx9baIjOAO/1sgi9/B9asIPzZ97ADO+yKiFSRbdmEvfA0buCwWltkBnAdTiC4+YdQvp/w/lt9b2gRkWNgFeXY7Elw4inU1iIzgGvSjOCWH0JBa8Jf3o0tfi3qSCKSgcIZE/zqtrMGRR0lMq5OXYIbboNeZ2D/+DXhvCejjiQix6H2Vi0zSDh9gu9/pMb4uN79CL5yK5QUEz5wO3ZgR10RkSqw2ZP9MuthY6KOEjnXrjPBLT+CykrC+2/D1q2OOpKIZBBb9DRs20IwclzUUSLnGjfz42nLtoS/+iH29qtRRxKRDGKrlsE7r+OGjk5Jm4p05vLq+L/3Tz0Te+S3hHOnRh1JRI6RCs1pzooTF50ho6u8E3a2c6f0JfjqbbBujS82H9hBV0TkY9ieXdjTM3Fnnotr0SrqOGnBFXX0xREzX2xeWxx1JBHJABaG2MyJUNQRTu4TdZy04Bo1Ibj5R9C6yBeb33w56kgikiFsxgTIr487V60iAFxeHsGXvgOnnYX96/eEsydHHUlEjoEKzWnOZkyEevm483TROZzr1Yfga7fDhhJfbD58Z1wRkSOw+dOhbC9uhGbfHc4VdiC45R5wAeEDt2FrVkYdSUTS3VsvQ0kxbuS4lGximilco8a+jUZhB8Lf/Ah7/cWoI4lImrNN67GXFuIGjdSG94dxeXl+k9k+52D//RPhzMejjiQiVaRCcxrzF50FiYuONr77MHfS6QRf+x5sWudn4m3fGnUkEUlTVr4fm/MEnHw6rn3nqOOkHde2nZ/ZnJPjX7xbvSLqSCKSxsIZE6B5Aa7vuVFHSTuuQSOCb/4AijoR/vbH2GuLoo4kImnMZk2CIMANHRV1lLTjcvMIvvAt3BkDsEf/4q89IpL2VGhOYzZ7MrgAN0QXnf/F9exNcOOdsHmj39Bq2+aoI4lIGrLn58H2rQSazfw/uTZFBN+6B/Lq+GJz8bKoI4lIGrJlS+C9t3HDxuByc6OOk5Zcg4YE37wbOpxA+Lt7sVeeizqSiKQh27kDWzgLd/Z5uKYtoo6TllxuLu4Lt+DOPBd77G+E0x6NOpKIHIUKzWnKdu3AFszC9RuEa14QdZy05k7sRfD1O2HrZsKf3oZtVbFZRA452Eu0QxfocWrUcdKaa1Xoi8116/li86qlUUcSkTQTzpwI9RvgBg6POkpac/UbEtx0F3TqRvj7+7CXF0YdSUTSjM2dCvv344ZfGnWUtOZycnCf+yburPOwif8gnPKfqCOJyMdQoTlN2bxpsL8MN0IXnapw3U8muOlO2LGV8KffxbZsijqSiKSLN16A9WvVS7SKXMs2vtic34Dwge9hK96LOpKIpAnbUAKvPo87/yJcvfyo46Q9V7+Bvz894UTCP/yU8MVnoo4kImnCysp8obl3P1xhh6jjpD2Xk4O77ibcOYOxSf8inPwvzCzqWCJyBCo0pyHbX4bNmQKn9MUVdYw6TsZwXU/yM0d27fA9mzer2CwiEE6fAAWtcX36Rx0lY7iC1r7Y3LAR4c+/75fKi0itZzMfh5xc3AWXRB0lY7h69f3Ku649sT8+QLhoftSRRCQN2LNzYNcOtXU7Bi7IwV17I27AEOyJ/2CTHlGxWSQNqdCchg5edEbqonOsXJceBN+4G3bt9DObSzdEHUlEImRLF8OyJbjhY3E5OVHHySiuRSu/QWDDxoQP3oEtfSfqSCISIduxFXt2Dq7/BbgmzaKOk1FcvXyCG++A7idjf/454XNzo44kIhGyykps1uPQpQd07Rl1nIzighzcNV/DnTscmxrHJv5DxWaRNKNCc5qxsNLPFuncHbqdHHWcjOQ6dye4+Qewdw/hT2/FNq2POpKIRCScPgEaNsL1Hxp1lIzkmrck+NaPoXEzwgfvxN57O+pIIhIRmzMVKitww8ZGHSUjubr1CL72fehxCvbXBwkXzok6kohExF55DjatJxh+qdq6HQcXBLirvoIbNBJ78jFs/N9UbBZJIxlTaI7FYitjsdibsVjstVgs9lLUeWrMgYuOeolWi+vY1Reby/b5YvPGkqgjiUiK2brV8PoLuMGX4OrWjTpOxnLNWvg2Gs1aED50F/buW1FHEpEUs317sXlT4fSzcW2Koo6TsVzdugQ33A49T8MefojwmZlRRxKRFDMzbMYEaF0Ep/WLOk7G8sXmL+MGX4TNmIjF/6Jis0iayJhCc8LgeDx+Wjwe7xt1kJpgZn72Xau2cNpZUcfJeK5DF4KbfwjlZYQ/vQ1bvzbqSCKSQjZjItSpgxt8cdRRMp5r2ty30WjekvChO7F3Xo86koikkC2YCXt2EwzXJtXV5erUJbjhNjj5dOzvvyJ8enrUkUQklZa8AauW+rZugdq6VYdzDnflF3FDRmGzJ2H//ZOKzSJpINMKzdntvbcSF51LddFJEte+M8HNP4LKCr9B4Lo1UUcSkRSwbZuxRfNwA4biGjWOOk5WcE2a+WJzy7aEv/wBtvjVqCOJSApYRQU2azJ0OwnXpUfUcbKCy6tD8JVb4ZS+2D9+Qzh3WtSRRCRFwpkToXFT3DmDo46SFZxzuE98Hjd0DDbnCexfv8fCMOpYIrVaJhWaDZgZi8VejsVi10cdpiaE0ydAoya66CSZa9fJF5vDSsL7b8VKiqOOJCI1zOZMgcpQvUSTzDVu6leKtC4k/OUPsbdeiTqSiNQwe2kBbNlEMOKyqKNkFZdXh+DL34Xe/bB//Y5wzpSoI4lIDbM1K+CtV3BDRuHy6kQdJ2s453Cx63AjLsXmTcMe+Z2KzSIRcpmytCAWixXG4/GSWCzWCpgFfC0ejz/9ocdcD1wPEI/Hz9i/f38ESY9P+cqlbPnGNTT41PU0vOLaqONkpYrVK9l6x9cgDGl210PkduwSdSSRjJCbm0tFRUXUMaos3LOb0i+MpU6fs2l68w+ijpOVwh3b2XrnjVSsWUXTb99D3TP6Rx1JJCNk2nhqZmz55mewykpaPPgPXJBJc1Qyg5WXs/2B71O2aD4NP3sjDUZ/MupIIhkh08ZTgO0P3kXZoqcp+ONEgoZacZdsZsauR37PnvF/J3/oKBp9+du6bolUQZ06dQCStklcxhSaDxeLxe4EdsXj8fs/5mFWUpI5G8CFf/459upzBPf9GdegUdRxspatX0P4wO1QUUFw8w9w7TpHHUkk7RUUFFBaWhp1jCoLZ0zEHvsrwe0/w3XsGnWcrGW7dxL+7PtQsorgS9/F9T4z6kgiaS/TxlN76xXCX9yJu/brBAOGRB0na1lFBeEf74dXnsVd/lmCEeqFLXI0GTeebt5IeOv1uAtGEXzic1HHyVpmhk16BJsaxw0YgrvmBrUlFTmKwsJCSGKhOSNe3onFYg1isVijAx8Dw4Gs2fbetmzCXnwaN3CYisw1zLVpR3DLPZCbR/jA7Vjx8qgjiUgSWUU5Nnsy9DhVReYa5ho0IvjmD6BdZ8Lf/hh77fmoI4lIkoUzJkDT5rizBkUdJau53FyCL9yC6zsQe+yvhE+OjzqSiCSZzZ4MzuGGjo46SlZzzhGMvQo36kps4Rzsbw9hYWXUsURqlYwoNAOtgQWxWOx14AVgajwez5otmm32ZDDDDRsTdZRawbUuJPjWPVCnri82r1oWdSQRSRJ74WnYtplgxLioo9QKrkFDgm/cBR1OIPzdfdgrz0YdSUSSxFYthSVv4IaOxuXmRR0n67ncXNznb8b1G4RNeJhwajzqSCKSJLZ7F/bMTNyZg3AtWkYdp1YIRl+JG/Mp7Lm52J8fxCpVbBZJldyoA1RFPB5fDvSOOkdNsN27sKdn4s48F9eiVdRxag3Xqi3BLfcQPnA74c9uJ7jpblznblHHEpFqsDDEZkyEdp3g5NOjjlNruPoNCb5xN+Ev7iT8/U8OzsoTkcxmMyZCfn3cuSOijlJruJwc+Nw3IMjBHv8nYWUlwegro44lItVk86ZB2T6c2uKkVHDJJwmDHGziP8BC+Nw3/TgrIjUqU2Y0Zy2b/ySU7cVp9l3KuZZt/Mzm+g0Jf/59bPm7UUcSkep462UoKcaNGIdzSWsxJVXg8usT3HQnnNCD8I/3E77w9FG/R0TSl21aj720EDdoJK5+g6jj1CouyMF99kZc/yHYE/8mnPQImbinjoh4Vr4fm/ME9OqDa9cp6ji1TnDRFbjLr8VefAb74/1Yhm0gKZKJVGiO0MGLzsmn49prU7oouBatfM/mho0IH7wD27Yl6kgicpzCGROgeUvNpo2Iq1ef4Ot3QNee2J9+hi19J+pIInKcbNbjEAS4oaOijlIruSAH95mv4QYOw6b8F1swK+pIInKc7LmnYOd2tXWLUDBiHO6K67CXF2KP/TXqOCJZT4XmCNlzc2HHNl10IuZatCT4+p2wvwx74j9RxxGR42DLlsB7b+OGjcHlZkRXqKzk6uUTfO370Lgp4WN/1Sw8kQxkO7djC2fjzj4f17RF1HFqLRcEuKu/Cl1Pwh7/J7Zvb9SRROQYWViJzXgcOnaFE0+JOk6tFgwfiztvJDZvGrahJOo4IllNheaIWBhiMx+HDl2gx6lRx6n1XOtC3KCR2IKZ2Po1UccRkWMUzpwI9RviBg6LOkqt5+rl40Z/EpYtgdcWRR1HRI6RzZ0K+/erl2gacEFAcPm1sGMbNmtS1HFE5Fi9tgg2lhCMVFu3dOBGXwm5eYQT/x51FJGspkJzVF5/ATasxemikzbcJZ+AvLqEE/8RdRQROQa2oQRefR53/kW4evlRxxHADRgGbdoRTvi7dvkWySBWVuYLzb374dq2jzqOAK5LD+hzDjZjIrZjW9RxRKSKzIxw+gRo2Qb6nBN1HAFc42a44WPh5We1P5NIDVKhOQL+ojMeClrj+vSPOo4kuMZNcSMvhVee88vwRSQj2MzHIScXN+TiqKNIgsvJIRh3Daxfgy2cHXUcEakie3Y27Nqptm5pJrj0aigvw6b8N+ooIlJV7y+GFe/hho3FBTlRp5EEN3wsNGpCOP5htXgTqSEqNEdh6Tuw/F3c8LG4HF100okbOibRW/RvuvCIZADbsRV7dg6u/xBc42ZRx5HDnXYWdOmBTf43VrYv6jQichRWWelfuOvSA7r2jDqOHMa1aYcbOBx7ejq2Ub1FRTJBOGMCNGyM6z8k6ihyGFevPm7UlfDeW/DmS1HHEclKKjRHwF90GuH6D406inyIq5fvLzxLF/v2JiKS1mzOVKis8LMTJK0453xv0e1bsNmTo44jIkdhrzwLpRsIRqitWzpyoz4JObnYxH9GHUVEjsLWFsMbL+IuuARXt27UceRD3LnDoVVb3+ItVIs3kWRToTnFrKQYXn8BN/hiXXTSlBs4DFoXqbeoSJqzfXuxedPg9LNxrQujjiNH4LqeBKedhU0fj+3cEXUcEfkfzAybPgFaF0HvflHHkSNwTZvjho/FXlqArXg/6jgi8jFs5kSoUxc3+KKoo8gRuNxc35Jo7SNZWSQAACAASURBVCrsuXlRxxHJOio0p5jNfBzq1MENVi/RdOVycwnGXQ3rVmPPzok6joj8D7ZgFuzZpV6iaS4Ydw2UlWFT1VtUJG0teQOKl/m2boH+PEhXbvilid6iavEmkq5s62Zs0XzcwGG4ho2jjiP/yxkDoHN3bNIj2P6yqNOIZBXdSaaQbduMPT8PN2AorlGTqOPIxzn9HDjhRGzyv7AyXXhE0o1VVGCzJkH3k3EnnBh1HPkYrm173MCh2LwnsU3ro44jIkcQzpgAjZvizhkcdRT5GC6/Pu7iT8C7b8Jbr0QdR0SOwOZMhjDEDR0ddRT5GM45gss+A1tLsaemRB1HJKuo0JxCNvsJf9EZpl6i6c5feK6FbVuwp56IOo6IfIi9tAC2bNJs5gzhRl8JOQH2+CNRRxGRD7HVK+DtV3FDRuHy6kQdR47CnTcCWrbxs5rVW1Qkrdie3dj86bi+A3At20QdR47CnXgKnNIXe/IxbPfOqOOIZA0VmlPE9uzGntZFJ5O47idD737Yk+OxXeotKpIuzAybMQEKO0CvM6KOI1XgmrbADR2DvTAfW7Us6jgichibMQHq5uPOuzDqKFIFLjcPd6C36PPzo44jIoexp6fDvr04TYTIGMG4a2DvHmzaY1FHEckaKjSniD0zA/buwY24NOoocgyCS6+BfXuxqY9GHUVEDnj7VVizEjfiUvUSzSBuxDho2Ihw/N+ijiIiCbZ5I/biM7hBw3ENGkYdR6rInTEAOnb1vUXL90cdR0QAKy/3K5h79sZ17BJ1HKki164T7pwLsKemYJs3RR1HJCvoL/QUsIpybPZk6HEqrmPXqOPIMXBFHXD9L8DmTcVKN0QdR0SAcOZEaNoC129Q1FHkGLj6DXAXx+Cd17HFr0YdR0TA3586p16iGcYFge8tumUTNndq1HFEBLAX5sP2LQQjNZs507jRnwLAJqnFm0gyqNCcArboadi2Rb1EM5Qb/SlwgS48ImnAVi2Fd17HDR2Ny82LOo4cI3feRdCiFeH4h7EwjDqOSK1mu3diz8zEnTkI17xl1HHkGLmevaFXH2zqo9juXVHHEanVLAyxGROhfWfoeVrUceQYuRYtcUMuwZ6fi61ZEXUckYynQnMN8xedCdCuE5x8etRx5Di45gW4IaOwRfOx4uVRxxGp1WzGRMivjxs0IuoochxcXqK3aPFy7IWno44jUqvZvCehbJ/aumWwYNxnYO9u7En1FhWJ1JsvwbrVuBHjcM5FnUaOg7vwCsivTzj+71FHEcl4uUd7QCwWu64qB4rH43+pfpws9ObL/qLzuW/qopPB3IWXYc/MJBz/MDnfuCvqOCK1km1aj7200Pdmzq8fdRw5Tu7Mc7GZE7HH/4mdMQCXp5npIqlm+8uwOU9ArzNw7TpFHUeOk2vfGXfW+dicJ7ALLtbMdJGIhNMnQItWvn+6ZCTXoCHuoiuwx/6GLXkD1+PUqCOJZKyqzGi+ugpvV9VUwEwXzhgPzVvi+g6MOopUg6vvLzwsfhVb/FrUcURqJZv1OOQEuCGXRB1FquFgb9HNG7H506KOI1Ir2XNzYed29RLNAm7spwHDJv8r6igitZItfQeWLsYNG4PLPeo8Pklj7oJLoHkB4WN/w8yijiOSsY46Esbj8cGpCJKNbNkSeH8x7hOf10UnC7jBF2FzniAc/zBBj1NxgTrPiKSK7dyBLZyNO3swrmmLqONINbmTToeTTsOmxrH+Q3H1G0QdSaTWsLASmzkROnWD7r2ijiPV5Fq0wg2+GJv9BDZsLK6oY9SRRGqVcMZEaNAIN3BY1FGkmlxeHdyYT2N//YVfRXmmJguKHI/jrpTFYjEXi8WCA2/JDJUtwpkToX5DXXSyhMurgxt7FRQvw158Juo4IjXOzLDl71K5dXPUUbC5U2H/ftzwsVFHkSQJLvsM7NqJTR8fdRSRlLC1q6hYtybqGPDaIti4jmDEpWrrliXcRVdAvXzC8Q9HHUUkJax0A+Ur3os6BrZ+Dby+CDf4IlzdelHHkSRwZ58PRR2xiX/HKsqjjiNS42zn9qQf85im2cZisSLgV8AgoOmHvpyTrFDJEj76V9wFl+BapL5fma1fC68+j7vwCly9/JSfX2qGO+s8bObjid6i/XG56i0q2cfCSuzl57Bpj8KaFZTm5uH6DcING41r1zn1ecrKsLlToHc/XNv2KT+/1AzXoQuu33nYnMnY4ItxzTRTXbKPmcF7bxFOexQWv8ZmgFPPJBg2Bk48JeWFXjPzvURbtoE+56T03FJzXMPGuAsvxyY8jL37Fu5EzVSX7GRrV2HTHsNefIYtFkLn7rhhY3F9zsHlpL4cYTMfh9w83OCLU35uqRkuyCG47DOED92NPTNT/20la9mWUmzW49jTM2DiwqQe+1j7OfwO2AMMAebjC853AmnZZNFmT8JmT8KdMcD3TOrcPXXnnvU45OTihmhgyiYHeouGv7gTmz8dN2RU1JFEksYqyrHn52FPjoeNJdCmCHf1V6i3ZSN7Z0/Bnp0DPXv7AsnJfVLWPsaenQ27dqqXaBZyYz+NvbIQe+LfuGtuiDqOSNKYGbzxEuGTj8KyJdCkGe7ya6mfm8vuqY8SPnA7tOvs70/7nZu6F67ffxtWvIf79JdwQdrNEZFqcEMuwZ6aQjj+bwTf/almq0tWsRXv+RfsXlsEdfNxw8fQsENndk76N/aHn2DNW+KGjMINHJaydly2fSv23FO4AUNxjT88B08yWq8z4MRTsCf+g50zGFdPm5BL9rCNJdj0CdizT4GFuLPOS/o5jrXQ3B/oEI/Hd8diMYvH46/HYrHPAc8Cf0x6umoK7vkj9tQU7JkZvtVB156+QHLaWTV6c23bt2LPPoXrPwTXuFmNnUcicvLp0ONUbMp/sf5DcPm68Ehms7IybMEsbOYE2FIKHU4g+NJ34HQ/VjYuKKBs2Dg/ls6ZQvjQ3dCmnZ/hfPZgXJ26NZetstLPFunSA9f1pBo7j0TDtWyDO/8ibM4UbOhoXGGHqCOJVItfEfJsYkXISmjRyhd1BwzF5dWhYUEBeweNxBbNx2ZNwv76IDbh737Z9XkjcQ0b12i+cPoEaNQE139IjZ5HUs/VqYsb8yns4V/CK8/CGQOijiRSLWYGS94gfPIxeOd135Jy1JW4IZfgGjSifkEBu/sOgjdeJJw1CXv0L/6F64HD/WMKWtdsvjlPQGWl2rplIeccwWXXEt5zMzbjcdyYT0UdSaTabM1K7MnHsBcXQE4O7tzhuBGX1shYeayF5kqgIvHxtlgs1hLYARQlNVWSuBYtcVd8Fhv1CWzBbGz2ZMLf3gsFrXFDR+MGDKmRV6fsqSlQWaGLTpZyzhFcfi3hD7+JTZ+Au/SqqCOJHBfbsxubNw2bPRl2boduJxFc/VU/W/lDM6Fcg4a4kZdhQ8dgLy/0LWT+8Rts4j9x51+IO/8iXJPkv7BmrzwLpRsIPvG5pB9b0oO7KIYtnE044e/k3HB71HFEjotVlGPPzcWmT0isCGmH++xNvu3QhzaEdnl1cAOHYQOGwuLXCGclWnJNi/tJCkNG49ok/9ba1hbDmy/hxnyqRl8glOi4/hdgsyYRTvgHQe+ztBm5ZCS/IuRFP4N5+bt+RcgVn8UNGvGRv91dEMBpZ5Fz2lnYqmV+RfPcKb4I3OdsgmFjcV16JD/jvj3YvCehzzm4VoVJP75Ez3XuhjtjgG8tcP6FNfJ3jkgq2LIl/gW71184uCLEDRtbo7/Tx3r3sQi4CJgIzAD+C+wFXkpyrqRy9erjho7GLrgYXl3kb+j/80ds0r9wg4b7Ps7Nk9PH2fbtxeZNg9PPxrXWRSdbuY5dcWeei81+HBt8Ea5p86gjiVSZ7dzud6efOxX27oZefQguvALX/eSjfq/LzfW9yvsNgvff9jNIpsax6eNxZ52HGzoG165TcnKaYTMmQpsiOLVfUo4p6cc1aowbMc4X2t5fjOummeuSOfyKkJl+rNpaCh26EHz5O3Da2UdtL+Scg5NPJ+fk07G1xb5f+YLZvnjRux/B0NFJ7eNsMydCnbq48y9KyvEk/bggh2DcZwh/9QNswUz9t5aMYmEl9uIC7MnHYO2qxIqQL/vJYXl1jvr9rmMX3Oe+iY37jC82z59O+PKzcMKJflXz6cnr42zPzIK9uwlGXJaU40l6cuOuxl57HpvyH9ynvxx1HJEqO7giZNqjsOQNaNAIN/pTuAsuxjVoVOPnP9ZC89XAgbvmm4BbgIbAg8kMVVNckANn9CfnjP7Y8nex2ZP9ssVZB/o4j8V17latc9iCmbBnN8EI9RLNdm7sVdgrz/klWld/Neo4IkdlW0qxmROxZ2ZAeTn0OccXmDt2OeZjOeegey9yuvfyfZ5mP4EtnI0tPNDHeSycfHr1+jgveQNWLcVdc0PK+kFLNNzQMdi8ab636LfvU29RSXu2Zxc2d5qfNbdzO3Q/meCaG/y4dxy/v66oA+6aG7CxV2HznvT/PzxwO7Tv7O9PzxxYrT7OtqUUWzQ/Je05JGKn9oVuJ/neomcP1qbkkvasvBx7fi42fTxsXAdt2+M+9w3cmYOOqzDsmrXAjfsMdlEMe+4pv6r59z/xhesDfZyr0frQKiqwWZOge69q1w4kvblWhbhBI7D507EaWm0kkkwWhodWhKx4D5o0T6wIGZnS+wFnZik7WYpZSUnJ0R+0eWOij/NM2LsHup6U6OPc75j7OFtFBeFt10NBa3K+9ePjzS0ZJPz3H7B50wju/BWubbuo44gc0Ucb/p+Pu/DyKv/OFhQUUFpaevTz7N6JPT0Te+oJ2LbF/6EwdDTu7POPa5l25YN3wJqVBD/+Y5VmskhmC5+Zif39VwRf/i6uzzlRxxE5ItuxDZtzYEXIHuh1BsFFV1R5Jn6Vx9Py/X5z1lmTYN1q/4fCBRf7QvFxzEQJH/0rNnsSwY9+X+N9SyV6tmwJ4b3/hxt1JcHoK6OOI3JEVrbP7/8x43HYthk6diW46IrEfkpHn2BQ5fE0rDzYx5n33oZ6+b436QXH18c5fG4u9pefE9z4fdwpfY/5+yWz2I5thLd+0a9A+vJ3oo4jckRWWYm9dNiKkILWuJGX4fpfUKW/owsLCwGSNtPnmArNsVisDnAtcBp+JvNB8Xj8mmSFSpIqFZoPPnjvHmzhLGz2E7B5I7Rs43vkDRhS5cp/+Pxc7M8/J/ja93Cnnnm8uSWD2M7thLdeDz17k/OVW6OOI/IBtmYFNu0x7KWFiYb/w3DDj73hf1Vv5A+et6Ice2mhL5AUL4OGjX0P58EXVnmDVFu9gvDur+PGXUNw4eXHlFcyk1VWEt75NcD8i3dJWt4qkgy2ZZPvTZ9YEeL69MdddDmuw7GtCDnm8dQM3n7VF0gWv+pbX/Qf4mflVXFmle3ZRfjtz+FOPZPgC7ccU17JXJW/vRfefpXgnt9pc3JJKwdXhMyeDLt2QPdeBBdfAT1PO6YVIcc6ngLYqqV+RfNLCyA0XJ9zcMPGVLmPs5kR3nUjAMEdD2kFVi0RTv439sS/Cb7zkxrp+S1yvKy83K/cmD4eNq33E70uuvyYV4Qku9B8rK0zHgZ6A08AG5IVIh24/Pp+6e7gS+C1A32c/4BNesRvPHDBJbjmBf/z+83MbwBT2AF6nZHC5BIl16gJbsSl2KR/YUvfwXXtGXUkkSM0/B/rb6JTtImFy83DnX0+dtZ5h/Vx/i82/TE/m3rYGFxRx4//GWZM8NnPG5mSzBI9l5NDcNk1hL++B1s4CzdI/+0lerahBJs+HntuLmCJFSGX4dqkZhWTcw569SGnVx9s7Srf9m3BLGz+k3DqmX4VXvdeH1vssPkzYN9e3IhLU5JZ0kNw6VWErz2PTfkv7lNfijqOCLZjqx/D5k6DfXvhlL4EF12O65q6vRlcx664z9+c6OM8FXt6OvbyQujSI7Gq+eyPL8689QqsXeU3e1WRudZww8di858knPAwwS336L+9RM7K9mFPz/D7b2zb4leEfOVW6N0vLVpOHuuM5q1A53g8vq3mIiXNMc1oPuIBli3xF8OXn4XA4c4YiBs2Gtfpo72Y7K2XCX9xF+6zXyfoP6Ra55XMYmX7CG/7IrRsQ/B/9+rCI5E42PB/ahzefdM3/B86Cjf4ElyDhkc/wMc4nhkjH8m3ocRvdLVwDuwvg5NO8zf0J/f5yP8ztnkj4a3X44aOJrjiumqdVzKLmRH+5Duwab1f4l+3XtSRpJay1SuwJxMrQnJzfU/PEZfiWrSq1nGTMp7u2Jro4/yk7w/d4QT/Al7fj/ZxtvJywu9+Hoo6kvONu6t1Xsk84T9/gy2YRXDXr7VJuUTGNm9K7BEyEyrK/d5IF16O63BCtY6blPF0317s2Tl+dvWm9b6P89BRuAFH7uNcef9tsHEdwT2/r1bffMk84bxp2CO/I7jhe7jeWr0u0bDdu/xmp3OegF074cRTfMuhnr2rVYeKekZzMXDsjTYzlOvSA9elB1a6wfdxXjALe2E+dDvJb3TV+8yDfZzDGROhaQtcv0ERp5ZUc3Xr4UZdif3zN34G6WlnRR1JahHf8P8FwmmPHdbw/zq/EiONNgByrQtxn/oSNubT/tXXp6YQ/uIuv7xn2BjcWecd7ONssyeDc7ghoyJOLanmnCO47FrC+76NzZ6MuzgWdSSpZWzZEr+Byhsv+j6eIy71kwzSqPWAa9wMN/pT2MjLsEXz/TLwP/8cG/+wX4E3aMTBPs62aB5s30pw3U3RhpZIuFFXYs/NxR7/J+6L/xd1HKllbP1abPpj2PPzAHBnD/Y9Q9NoQzVXLx93wSXY+Rce7ONs//0zNvnf/gXGIaMOvsBoK96Hd9/0G2upyFzruIHDsVmT/azmU/oc835eItVhO7ZisyZj8xIrQk49k+DCy9N2Rf2xzmi+GbgC+AUfap0Rj8efSm60j5x7ZOK8OcCf4vH4vUf5lmrPaP7IAY/Ux3noaFxRJ8L7b8Vd/lkCLUuslayiwvcWDQLfr0u9RaWGWWUl9uIzvuF/SbEfj0aOw50zBJeX3JvfZMwY+TDfx3lBoo/zcmjUBHfehbh+gwh/9E1cn3MIrvtGUs8pmaPy1/fAktcJ7vkDrlGTqONIljMzeOc1/4Ldu29Cw0Z+n47BF1d7RciH1ch4+j/7OF9C+Ot7IC+P4HsPasVVLRVOegSb8l+CWx/Adf7oqkyRZLPi5X5FyMsLITfPb7w3/FJci5ZJPU9NjKcAtvJ9X9B5eQGY+Z78w8b4Pv2LXyO4789HnO0s2c9eXkj4u/tw195IMGBo1HGkFrDNG7EZE7AFs/2KkL4D/YqQ9p2Tep6oNwNc8T++ZPF4vHprXz7+vDnAe8AwYA3wInBlPB5f/DHflvRC88EDV1bCa8/7G/plS/w/5tcnuO8vuujUYvbKs4S/vRd3zQ0E5w6POo5kKd/wf47vCb9pPRR28BebM8+tsRc4aupGHhIFkvfeJpz1uJ9BmLgmBXc8hGvXqUbOKenP1q0hvOMG3AUXE3zyC1HHkSxlYQivv+BnMK98H5o298WQc4fX2IqQmhxPAWzNSt/2bdE8qKgAwH3+ZoKzzquxc0p6s317CG/9IhR2ILj5h3rBQWqMLV3sX7B78yXIr+83gh46Gte4aY2cr8bH0y2bsKemYk/PgL27AXAXXkYw7jM1dk5Jb2ZG+ONvwbYtBD/87cHVmCLJZuvW+D1CFs0DHO6cwbgR42psRUikrTPi8Xhyy+ZV1w9YGo/HlwPEYrH/AGOAjys01xiXkwNnDCDnjAG+j/O8J6H7ySoy13annwNdemCT/4X1Ow9XVxceSS5b/i7hb3/sG/536kYQuw5OTY+G/8fLOQcn9iLnxF5+ieVTU/wfJyoy12qubTvcwKG+D+2QUbiWbaKOJFnGtmwifOhuWLvKrwi5+qu4cy5I+oqQVHPtOuGuvREbdzU290ko3YDrOzDqWBIhV68+7pJPYP/+A7z1MpzSN+pIkmWsrIzwdz/2G+U1bIwbexVu8EW4+sldEZJqrnlL3OXXYpd8wvdxfud13NAxUceSCB1s8Xb/rdicKbgLL4s6kmQZM8P+9Xu/6XNenn/BbvhYXPPkrgipacfao5lYLJYL9AeK8LOLn4vH4xXJDvYhRcDqwz5fA3ykEW4sFrseuB4gHo9TUFBQw7GAgoFwlm7gxdt/3Y1sve0r1H9+Dg0uuybqOJJFKjeuY8tv7iGnXj6N7vwFdU7tm7JZSbm5uSkaTwugV++aP49khMprv0rpovnUefJRmnzzrqjjSBYJ9+5h64/uxbZsotFNd1Bv4BBczjHfEh+XlI6nJ6hNgnh26afZPHcqbtIjNB80TC3eJGksDNl+/+2Uvf0qDa/5KvUvHJeyPUJSNp4CxK5NzXkk/RWcz9a5/SmfPp7mY68kaNQ46kSSRXb950/snjeN/JHjaPiJ6wiaNo860nE5prvqWCzWA3gCyMcXftsD+2Kx2Kh4PP5ODeQ74EjVlI/0/IjH438A/nDg6zW5lEbkiFq1g979/p+9+46Sos7aOP69RUZQsoCIEgQkiIABI0ERMSEIjQEVjGtG17DGNac1rhkVFV2VVlGUIIqCoIISVESSYEBFJKjkNNR9/6gx8BqYYbqnunuezzmclZ7uroc6s7+puV2/e1n10mDWtN0f0w8eSQFft4bw1stgwwaCf97Eyjr1YNmyYjt+urcmivw5ww7uzrqRSTZ06Ibt1DjuQJIDPAyjnSFfzyc4/2pWt2jH6p9+Lrbjaz2VuIRHHY8P/A9LRrxIsO9BcceRHBG+/Aw+cRzW+xTWHtCVtatWw6rVxXJsracSFz/yOHzaJJY+8zBB71PijiM5IvxwPD5kELZPZ9b3PJkNeSEU0xqX3zojZQq73/pBokLujslkcp9kMlkPeDj/8XT6lqio/Yt6QHoaMIsUUdDzJFi3Dh+ZjDuK5AAPNxEOvAO+/4bgH5dhderFHUmk2NihPaFSZcKXnqIwMyVE/ooPHQwff4D1ORVr2S7uOCLFxtrtBzs1xof9D9+4Ie44kgPCSWPxkcmor30XtZSQksN22AnbtxP+9nB82eK440gO8C/m4E/cC7s0j9q5Zfk8hcIWmncH7komk7//be+e/MfTaTKwSyKRaJBIJMoCxwKvpvmYIlvF6tbH9jsIHzsSX7Io7jiS5fzFJ+HTKdhxZ2DN073UimQWq1ARO7wPzPoEZn4cdxzJcuF7b+Gjh2IdDsU6HxF3HJFiZUFA0Ksf/LgUf3tE3HEky/m8WfhT90HTVtjxZ2Z9UUSksOyo48ECfNj/4o4iWc6XLSF84CaoUo3grCuyfl4IFL7QvBD4/2OrDyDNdxfn94A+FxgNzIoeSn6WzmOKFIUdeRwE+sEjRRNOeAN/cxjW+QiCjofFHUckFtahG9TYnvClJ/EwjDuOZCmfOwN/+gHYtTV27BkqikiJZM12g5Zt8ZEv4KtXxR1HspQv/YHwwZuhWk2Cs/6Flc7+oohIYVm1mljnI/BJ4/Bvvow7jmQpX7eW8P4bYeMGgvOuzpnWq4WdfHIF8GoikRgOfA3sDBwG9E1xrj9IJpMjgZHpPo5IKli1GtjBR+KjXsIPORqr3yjuSJJlfPZ0/H8PQYs2WOLUuOOIxMbKlMGO7os/dif+4TtY+05xR5Is44u/j/oy19ie4MzLsNLFM/hPJBMFx5xMeP0AfNQLWK/+cceRLONr10RFkU15UVFkm8pxRxKJjXXrhU94g3DoU5S64Nq440iW8XAT4WN3wndfE5x/NVa3ftyRUqZQdzQnk8lXgbbADKAy8CnQLplMDktDNpGsZoceA9tUJnxpcNxRJMv4DwsJH7oVatUlOONSTYeXEs/2PADqN8Jf+R++cWPccSSL+JrVUVEk9PyiSKW4I4nEyuo1wNp3xN8ajv+4JO44kkU83ET4aP7ckDMvw2prboiUbLZNJeyw3jBjGj7rk7jjSJbxoYPhkw+xPqfl3NyQwrbOIJlMzk0mkzcmk8mzgTuBr1KeSiQHWMX8HzwzP8LVW1QKyFevIrzvBgiCqChScZu4I4nEzoKA4JiTYdlifJw2N0nB+KZNhI/cDosXEpx9ObZ9aidqi2Qr634C4PiwZ+OOIlnEX3gyf27ImZobIpLPOh8O1WpGg6vV4k0KKHxvDD76Zaxjt+h7KMcUqtCcSCTuSCQSe+X/9+HAj8DPiUTiyHSEE8l21ulwqF5LvUWlQDwvj/CR22DpDwRnXY7VrB13JJGMYc13h+Zt8BFJfI16i8qW+ZDHYOZH2AlnYU1bxR1HJGNY9VpRb9GJb+PffhV3HMkC4fjR+Jhh2EFHEnTsFncckYxhZcpGH959PQ+f+l7ccSQL+JwZ+NMPRnND+pyek3NDCntH8wlEbTMAriHqzXwUcHMqQ4nkiqi36Amw4At88oS440gGc3f8+YEw6xPspHOwJi3ijiSScYJjTobVK/HXX4o7imS4cOxIfOwIrEt3ggMOiTuOSMaxw3pDhYqEQ9XiTf6ez56OP/swtGyL9T4l7jgiGcfad4B6O+MvP43nqcWb/LVf54bU3J7gH7k7N6SwheaKyWRyTSKRqA40TCaTLyWTyTHATmnIJpITbK8OUK9B9INHvUXlL/jbw/F3XscOPYZg34PijiOSkax+Q2zvDviY1/CflsUdRzKUz/wo+uButz2xXv3ijiOSkWybyli3XvDpFHzOp3HHkQzli777bW7I6ZdobojIn7CgFEHPk2HJInz86LjjSIbyNfktMiG/RWbuzg0pbKF5biKROAE4F3gTIJFI1ADWpjqYSK7YrLfoO6PijiMZyD+dig95HHZvj/U4Me44IhnNju4LHuKvqreo/JF//w3hw7dDnR0JTv8nFqgoIvJXrPMRULVG1FvUPe44kmF89cpomKrmhohsWcu20LQVPnwIvnZN3Gkkw/w6N2TJoqhFZq3cnhtS2ELz2cA5uUfWgQAAIABJREFUQCfg6vzHugJvpDKUSM5p0QZ2bY2PGIKvWR13Gskg/t3XhANvh3o7EZx6IRYUekarSIliNbbHOh6Ov/cWvnBB3HEkg/jKFdGdIqVLR0WR8hXjjiSS0axsOaz78fDlXFBvUfkdz8sjfPg2WPYDwdlXaG6IyBaYGcEx/WDlcvyNl+OOIxnGn38UZn6M9T0La9oy7jhpZzn86bUvXLgw7gwiv/Kv5xHeeBF2WIKgR9+440gG8BU/E958MeRtJLjiTqxajbgj/akaNWqwdOnSuGOI/MpXriC88gxo0pJS514VdxzJAJ63kfDua+CLuQQX34Q1ahZ3pD+l9VQyjYebCK+7ILoWue6BnO0XKQXn7vgzD+LjR2P9BxDs2znuSH9K66lkovCR2/HpkwluHohtVzXuOJIBwreH488NxA7pQdC7f9xx/lTdunUBUjaVsNBXEolEoizQFKjx+yDJZPLtVIUSyUW2U2NszwPwMa/gnbphVarHHUli5Bs3RoMAVvxMcMktGVtkFslEVnlb7NBjot73n8/EdmkedySJ0S9FEeZ+hp32z4wtMotkol96i4b334BPeAPrdFjckSRm/tarUZG52zEZW2QWyVTWoy/+0UT8teewvmfHHUdi5jOm4c8/Bq33wo45Ke44xaZQe7QTicT+wNfAO0Q9ml8ERgOPpT6aSO6xHifCphB/9bm4o0iM3B0ffD/Mm4X1H4A12CXuSCJZxw46CqpUJ3zxCfUWLeH8jZfx997CjuhDsHeHuOOIZJ/d9oAmLfDXnsPXqbdoSeafTsGTT0Cb9tjRmhsiUlhWqy524KH4hDfwRd/GHUdi5AsXRC0yd6hPcFrJmhtS2GagdwO3J5PJasDK/P+9AXgw5clEcpDVrI117Ia/Owb/Xj94Siof9SI+aSx21PEEe+4fdxyRrGTlymFHHQdfzIGPJsUdR2LiH3+Av/QU1m4/7Mjj4o4jkpU27y06LO44EpNobsh/YMedCU69SHNDRLaSHdEHypQjfPmZuKNITHzlimiYapmyBOdejZWvEHekYlXYnx5NgHv/32O3AhemJo5I7rPDE1CuHOHQwXFHkRj4tPfxl5/G9jowuggRka1m+x4EdXYkfHkwvmlT3HGkmPmCLwgfuxPqN4p2h6goIrLVrGFTaLtvtENgxU9xx5Fi5it+joaplqtAcM5VWLnycUcSyVq2bRWsaw+Y9j4+f3bccaSYRS0yb4aflkXDVKvXjDtSsSvsFflyYNv8//4+kUg0B6oClVKaSiSHWeXtsK494eNJ+NwZcceRYuRfzyd8/G5o2BTrdz5mKeu3L1IiWalSBD1PgkXf4eNHxx1HipEv/4nwgRuhwjYE516FlSsXdySRrBf0OBE2bsCHqcVbSeIbNxA+eDOs/Jng3Cs1N0QkBaxLd9i2StTiLQzjjiPF5Ne5IZ/PjH7fL6FzQwpbaB4K/DIh4nFgLDAVeCGVoURynXXpDtVrEQ66B1+zKu44Ugz852WE998AlbYlOOcKrEzZuCOJ5IbWe8GurfEXn1AvvBLCN6wnfOAmWLWS4LyrsCrV4o4kkhOs9g5Y5yPx8a/j0yfHHUeKwa9zQ+bPJjjlQmxnzQ0RSQUrXwHreTLMm4W/8XLccaSY+Oih+PtvYUccW6LnhhSq0JxMJgckk8ln8//7TuAY4HTgjDRkE8lZVq48wekXw09L8cEPaJBVjvP16wnvvwnWro2KIttWjTuSSM4wM4JTBkDZcoSP/AffuCHuSJJG7o4/+V/4cm7UQ7R+o7gjieQU63ki1GtA+MS9+M/L4o4jaeYjX8AnjcO6n4C12y/uOCI5xfbtjLXbD3/lGfyLOXHHkTTzjybhQwdje+yPHXls3HFitVXN7BKJxI6JRKJ9Mpl8N5lMjkomk9oLIFJI1qgZdnRffOp7+IQ34o4jaeJhSPjE3bBgPsHp/8TqNYg7kkjOsSrVCfpfAN9+ib/4ZNxxJI38tefxyROwnidhbfeJO45IzrEyZQnOuAQ2rCd87C48VP/7XOVT38dfeQbbu0M0Q0ZEUsrMsJPOgSrVCQf+B1+zOu5Ikia/zg3ZqTHW/4ISPzekUP/6RCJRP5FIvAfMBsbkP9YrkUg8lo5wIrnOuvaMtnwPeRRfuCDuOJIG/uqzMPV9rFc/rPVecccRyVm2257YwUfhbw/HP/4g7jiSBuHkCfhrz2H7dMIOPSbuOCI5y+rUw447A+Z8io96Ke44kgb+9TzCQXdBo2bYyedpbohImljFSr/tZH7mQe1kzkH+84+E998I21QmOOdKrKzmhhS2zP4IMAKoDGzMf+xNoEsqQ4mUFBYEBKdcCOUqRJ9yblgfdyRJoXDSOHxEEtu/C9bl6LjjiOQ863ky1G9I+OR/8R+Xxh1HUsi/nIs/cS80bo6deK6KIiJpZvsdjO15AP7qs/i8WXHHkRTyn5ZFRZFK2xGcfbnmhoikmTVqhnU/AZ88AX/3zbjjSAr5hvXRMNXVK6NhqpobAhS+0LwXcGt+qwwHSCaTy4HtUh1MpKSwKtWi/qLffY2/MCjuOJIiPn82/tR90KQldsI/VBQRKQZWpgzB6ZdA3kbCx7XlO1f4j0uiosh2VfOLImXijiSS88wM63s2VKtJ+Ogd+GoNr84Fvj5/mOratQTnXa25ISLFxA49JtrJ/PxA/Ptv4o4jKfDr3JCvPic47Z+aG/I7hS00/wA0/v0DiUSiOaA9/yJFYC3bYYccjY8bhU97P+44UkS+bHF0EV+tBsFZ/8JKqygiUlys9g7Y8f+AuTPwES/EHUeKyNetJbzvRti4ISqKVNa9DSLFxSpuE/VrXv4j4eD7teU7y3kYEg76ZW7IxVi9neOOJFJi/GEns4ZXZz1/7bnf5oa0aR93nIxS2ELzHcDwRCLRHyidSCSOA4YAt6U8mUgJYz1OhJ0aEz51H75sSdxxZCv5ujWE990AeXkE516NVdo27kgiJU6wb2esfadocNzcz+KOI1vJw5Dw8bvgu68JzrgEq1s/7kgiJY41aBJdo057Hx8/Ou44UgQ+7FmY9j7Wqz/Wes+444iUOFalGkH/AfDtV9rJnOXCD8fjrz2P7XdQNHdLNlOoQnMymRwEXAr0Br4BTgKuSiaT/0tDNpESxUqXie4aCUPCx+7AN2nLd7bxcBPhwDvg+28I/nEZVqde3JFESiw74UyouT3hY3fiq1bEHUe2gg8dDB9/gPU5DWvZLu44IiWWdTkaWrTBhzyGf/d13HFkK4STxuIjk9gBh2BduscdR6TEslb5O5nHjsSnTYw7jmwF/2JONDdkl+ZY37PVIvNPFKjQnEgk2iUSiZYAyWTyFaAf8AmwA3BYIpGolLaEIiWI1aoT9cObNwsf/nzccaSQ/MUn4dMp2HFnYM13jzuOSIlm5StGH96t+DnaKaIt31klfO8tfPRQrGM3rPPhcccRKdGiLd8DoEJFwkdux9dreHU28XmzorkhTVthx5+poohIzLSTOXv5siVRi8yq1QnOukItMv9CQe9ovgeo/bu/DyTq1fwI0AK4PcW5REqsYO8O2L4H4SOS+OzpcceRAgonvIG/OQzrfARBx8PijiMigO3UGDvmZPj4A3zcyLjjSAH53Bn40w/Arq2xPqerKCKSAWzbqlF/0e+/wZOPxR1HCsiX/kD44M1QrabmhohkiGgn88WwaVO08047mbOCr1sbDafeuIHg3KuwymqR+VcKWmjeFZgAkEgkqgCHA32TyeQDwHHAkemJJ1Iy2XFnwPZ1CR+/C1+pLd+ZzmdPx//3ELRogyVOjTuOiPyOHXwUtNoDTw7Cv/ky7jiyBb74e8KHboGa20ctiEqXjjuSiOSzFm2wrj3x8aPxKe/GHUe2wNeuiYoim/KiYarbVI47kojks1p1sb5nwbyZ+PAhcceRLfAw+lAgmhtyqeaGbEFBC82lgV/GYrYHvk8mk3MBksnkN0CVNGQTKbGsfAWC0y+BVSsIn7xXW74zmP+wkPChW6FW3eiHTqlScUcSkd8xM4L+F8A2laMp3+vXxR1J/oKvWR0VRZyoKFJRndlEMo0d3RcaNCEc/AC+9Ie448hf8HAT4aP5c0POvAyrrbkhIpkmaN8R26dztJN5zoy448jf8KGD4ZMPsWNPw1q2jTtOxitoofkzogGAAMcCY375QiKR2AFYnuJcIiWe1W+I9eoP0yfjb70Wdxz5E756FeF9N0AQ5BdFtok7koj8Cau8HcGpF8IP3+HPPxp3HPkTvmkT4SO3w+KF0fbuWnXjjiQif8JKlyY4/WLAoy3feXlxR5I/4S88mT835EzNDRHJYHb8mVCrjoZXZ7DwvTH46JexjocRdD4i7jhZoaCF5suARxKJxI9EbTNu+93X+gDvpTqYiIB1PgJa74W/9CS+YH7ccSSff7eA8KWnCK89D5b+QHDW5VjN2lt+oYjExnZtjXXrhb/7JuHkCXHHkXz+4xLCUS8RXnc+zPwIO+EsrGmruGOJyN+wmrWj4dXzZ+OvPRd3HMnnq1cRvvM6m267DB8zDDvoSIKO3eKOJSJ/w8pXiPo1r1pO+OR/tZM5Q/iG9YSTJ7DpvhvwwfdD892xY0+PO1bWKFDju2Qy+W4ikagPNAHmJpPJlb/78gjg+XSEEynpzIzg5PMJr7+A8JH/EFx9N1a+QtyxSiT/+Uf8w/H4pLHwzZcQBNCiLUGX7liTFnHHE5ECsCOPw+d8ij/9AL7zLvqAKCa+dg0+9T180jiYOwPcoVEz7NQLCdp3ijueiBRAsNeBhLM+wUe9iDfbDdu1ddyRSiTfuBE+nUI4aSx8OgXy8qDOjlivftjB3eOOJyIFYPUbYb36488/ir89AjtId83GwcMQ5s7AJ43Dp70Pa9dAlWpYl6Oxw3qrRWYhWA5/YuILFy6MO4NISvicGYR3XoW170hwyoC445QYvn4d/tHEqBgy8xPwEHZqjO3TCdtzf2zbqnFHLBY1atRg6dKlcccQSQlftpjw+gtg+x0ILr1Vw+aKieflwWcf4R+Mwz/+ADZugFp1sPadsL07YLXqxB2xWGg9lVzi69cR3ngRrF1NcM292LYa21Mc3B3mz8InjouGMq5ZBdtWwfY6EGvfCeo3xMzijpl2Wk8ll7g74QM3wWfTCC7/D1a/UdyRSgz/bgH+wVj8g3fgx6VQrgLWdh9sn07QtCUW5H6BuW7dugAp+8GhQrNIlgiHPYsPfx479SKC9h3jjpOzPNwEs6bjk8biH02C9eugei1s745Y+45YnZI3TEUX8pJrfOr7hA/finXtSdCrX9xxcpa7w1efR3eGTJ4AK5dDpcrYngdge3eEhk1LRDHk97SeSq7xb78kvOliaLZbNK8iKGhnRiks/2FhdH06aRws/QHKlsV23wfbpyPsunuJu9tO66nkGl+5gvD686FcBYKr7tJO5jTy5T/9tlt5wRe/7la2vTtgu7fHypWLO2KxSnWhOeNv40kkEtcCpwNL8h+6IplMjowvkUg87Ig++Jzp+DMP4Q2baFBSCrk7fPNldPH+4QRY/iNU2Oa3O0Ma76pfnERyiLXbFzvwUHz0UHzX1liLNnFHyim+ZBH+wTtRMeSH76B0Gaz1Xlj7jtCyLVa6TNwRRSRFrF4DLHEK/uwj+JhXsUOOjjtSTvGVy/HJE6L19Mu5YAbNdsOOPA5r2x4rXzHuiCKSIlZ5W4LT/kl451X4cwOx/hfEHSmnRLuVJ0XF5d/vVu5zGrbXASVmt3JxyPhCc767k8nkHXGHEImTlSoV/eC57gLCgXcQ/Os2/bJeRP7j0vxiyFhYuABKlYZW7aIeobvtgZUpG3dEEUkT63MqPm8m4aC7Cf59ry4ui8hXr8KnvotPHAfzZkYPNmmJde0RFfYrVoo1n4ikj3U8DJ/5CT50MN60JbZT47gjZTXfsB7/ZHJ0ffrZNNi0Ceo1wHr1j26CqFo97ogikibWtBV2eAIfPoSw+e4Ee3eIO1JW83ATzJ4etRr6aOJvu5W79cLad8Dq7Bh3xJyULYVmEQGsWk2CfucTPngzPnQwljg17khZx9euwae9H90ZMufT34ZQnfAPbI/9sUrbxh1RRIqBlS1HcMalhDddRPj4PQQX/Fs7FwrJN26EGVOjIVTTJ/82hKrHidHWw+q14o4oIsXAzAj6nZd/M8Qvw6t1p21heBjC55/hE8duPoTq4KOiXvb1do47oogUEzviWHz2p/gzD+INmpSYORap4u7w7VfRbuUPxv+/3codoXFzXfOnWcb3aM5vndEPWAFMAf6ZTCZ/+ovnngGcAZBMJttt2LChmFKKFK8Vj9zB2teHUuWqOynXbp+442Q8z8tjw8cfsPad0az/cDxs2ECpOvUo36Er5Q/sSukS2He5MEqXLk1eXl7cMUTSYs3oV1j58O1UOukctulxQtxxMp67s3HODNaNe511743BV60kqFKN8gd0oXyHQyndsEmJ67tcGFpPJZdtmPkxP119LuUP6MJ2A/4dd5yskPfNl6wd9zrrxr9BuPQHrHxFyu3TkfIdD6VsizYlru9yYWg9lVy2ackill10MqVq70C1mx/Bymgn85ZsWrqYdRPeYN2418lb8AWULk25tvtQvuOhlGu3L1a2ZPVdLoyyZctCrg0DTCQSY4Daf/KlK4FJwFLAgRuAOslk8pQCvK2GAUrO8o0bCG++GJb/FE35rlIt7kgZJxpCNS/6JFNDqIpEw1Ykl7k74SO3wccfEFx2G9agSdyRMlI0hGoc/sE4WLKoxA+h2lpaTyXXha89j7/6LNZ/AMG+neOOk5F+G0I1DhbML/FDqLaW1lPJdT5tIuFDt2CH9CDo3T/uOBnJ163Bp06MWg39frdy+47arVwIqR4GmBGF5oJKJBI7A8OTyWTLAjxdhWbJaf79N4Q3XgSNmhEMuE7bP/L50h9+K4Ys0hCqVNCFvOQ6X7OK8PoBEAQEV92NVdwm7kgZwVeuwKdMwCeO3XwIVftOGkK1lbSeSq7zcBPhnVfD1/Oi9bT2DnFHygi/DqH6YBx89vFvQ6j26YTtub/mBGwFradSEoT/exgfNzJq8dayXdxxMoJv2gQzP4paDX3yAWzYADVrR9en7Tuq1chWSHWhOeN7NCcSiTrJZPL7/L/2AGbEmUckU1idHbFjT8cH34+//hJ2WO+4I8XKV68kHHgHzPwoeqBJS+wQDaESkS2zipUITr+Y8PZ/4c88CKdfXKJ3PHheXtQXcNLY/CFUO2sIlYgUiAWlCE69iPD6Cwgf/Q/Bv/5Tord8uzs+Iom/PhTWr/3dEKqOmFq3icgWWO/++OefEQ66RzuZgfDD8fjzj0a7lbepjO17cHRDmXYrZ5SMLzQDtycSid2JWmd8BZwZbxyRzGH7d4FZn+DD/oc3bYU1ahZ3pFj42jWE91wL336FHd03unjXECoRKQRr1Aw76nj8lWeg+e7R+loCebgJH3Q3PnkC1ulw7MBDsHoN4o4lIlnEqtWIhlc/cBP+0pPYsafHHSk2PmIIPuxZaNOe4OCjNIRKRArFypYjOPNSwhsvJBx0d4neyexT38Mfuwsa7EJw0rnarZzBMr7QnEwmT4w7g0imMjPoezb+5VzCR+8guOaeEnf3rq9fR/jf6+GbLwjOugJrvWfckUQkS1m3Y/DZ0/HnBuKNmmF1dow7UrHyMMSfuj8qMvfqR9C1Z9yRRCRL2e57Y52PwN96Dd919xJ5fRa+8Qo+7Flsn85Yv/NLbHFIRIom2sl8RrSTefRQrFuvuCMVO58+mfDRO6Bhk6jYXr5C3JHkb+innUiWs4rbEJx+Mfy8DB/8ANnUd72ofOMGwgdvhvmzsVP/WSJ/iRGR1Im2fF8IZcsRDvwPvnFD3JGKjbvjzw/E338LO/JYFZlFpMisVz+o14DwyXvwn5bFHadYhe+8jr8wCGu3H3byeSoyi0iR2P5dsD32x195Bp8/O+44xcpnfUL40K2ww84E5/9bReYsoJ94IjnAGjbFuveNtpNMeCPuOMXC8/IIH7kdZn6M9TuPYM/9444kIjnAqlQnOGUAfPsV/sITcccpFu6Ov/QUPnYkdsjR2JHHxR1JRHKAlSlLcOYlsGED4eN34eGmuCMVi3DiWPx/D0GrPbDTLsJKlYo7kohkOTPDTjwHqtYgfPQOfM2quCMVC583i/CBm6BWnehOZg3szgoqNIvkCOvaA5rvjj//KP7dgrjjpNUvPUT55EPs+H8Q7HtQ3JFEJIdYqz2wg7vjY0fgH0+KO07a+Ygh0VbMjt2ioX8apiIiKWK162HHnwlzPsVHvhh3nLTzqe/jT9wLzXYjOOtf6h8qIinz607mn5biTz+Y8zuZ/ev5hP+9DrarRnDRDVjlbeOOJAWkQrNIjrAgIDjlQihfgXDg7fiG9XFHSgsPw6g/1eQJWK/+BJ0OizuSiOQg63kS7NSY8Mn78B+XxB0nbX7rIdoJO+5MFZlFJOVs34OwvTrgrz2Hfz4z7jhp459OiXqINmpKcM6VWJmycUcSkRxjjZphR5+IT3kXf/fNuOOkjX/3NeE910DFSgT/vAHbrmrckaQQVGgWySG2XVWCUy+ChQvw5ONxx0m5X3uIvvdLD9EecUcSkRxlZcoQnHEx5OURPnYnvin3tnyH40b9roeoBlWJSHqYGdb3LKhei/CxO/DVK+OOlHI+6xPCB2+BejsTnHcNVq583JFEJEf9tpN5IL4w93Yy+w8LCe++BkqVie5krlYz7khSSPqNQiTHWIs2WNce+Duv41PfjztOymzeQ7SHeoiKSNpZrbpY33/A5zPxEUPijpNS4cSx+LMPq4eoiBQLq1CR4PRLYPlPhE/dl1Nbvn/tIbp9XYIB16qHqIik1a87mctViIZX59BOZl+2mPCuq2DTJoKLrsdq1Yk7kmwFFZpFcpAd3Rd23oVw8H34ssVxx0mJzXuI9tP2bhEpFkH7Ttg+nfDhSXzOjLjjpIRPfS/qIdq0lXqIikixsQa7YD1Ogo8m4e+MijtOSmzWQ/TC67FK6iEqIuln21WNis3ffY2/MCjuOCnhPy8jvPMqWLeW4MLrsLr1444kW0mFZpEcZKXLEJxxCYRhTmz5/q2HaGf1EBWRYmfH/wNq1o7W01Ur4o5TJD59ctRDtGET9RAVkWJnXbpDizb4kMfxb7+KO06RqIeoiMTJWrbFDumBjxuFT8vuncy+cjnhXdfAiuUE5/8bq98o7khSBCo0i+Qoq1kb63s2zJuFv/Zc3HG22uY9RM9TD1ERKXZWvkL04d3K5YRP/jdrt3z7rE8IH7oVdtg5uogvXyHuSCJSwkRbvgdAxW2iLd/rs3PLt3qIikgmsB75O5mfug9flp3Dq33NKsJ7/g1LfyA47yqsUbO4I0kRqWIjksOCvTtg+x2Ej3wBnz097jiFph6iIpIpbKdGWK+T4ZMP8bEj4o5TaL/2EK1Vh2DAdeohKiKxsW2rEpx6IXz/DT7k0bjjFJp6iIpIprDSZQhOvzh/J/MdWbeT2detIbz3OvhuAcHZl2NNW8UdSVJAhWaRHGfHnQnb1yV8/C58ZfZs+f61h2iz3dRDVEQygh10FLTaA3/hCfybL+OOU2Cb9RC96AassnqIiki8rHkb7NBj8Alv4FPejTtOgW3eQ/R69RAVkdhZrTq/7WQe/nzccQrMN6wnvP8m+OpzgjMuwVq2izuSpIgKzSI5zsqVj6Z8r1pJeO+1+Bdz4o60Rb/2EG3UVD1ERSRjmBlB/wugUmXC+2/EP5qU8W001ENURDKVdT8BGjQhfOo+wnEjM/5OvD/2EG0YdyQREeB3O5lHJAlfeQZftzbuSH/LN26M2rnNnYH1H4C13SfuSJJCpa699tq4M6TLtStXrow7g0hGsO2qYnXr4x+Ox996DRZ9Czs1xipWijvaH/isT6Lt3fV2jrZ3V6gYd6QSr2LFiqxZsybuGCIZwcqVx3ZpgU+fjI8dgc+Zge1QH6tSPe5of+A/LIzuvAtKEVx8E1Zj+7gjlXhaT0V+Y0GAtWiDfzEbxo3Cp7yHVa8F29fNuMHPvmZV1JN58fdRkXmX5nFHKvG0nor8P7vuDksWRcMB3xsDFSrCjg0wy6z7S33TJsJH/wOffIideA7BfgfHHanEq1y5MsB1qXo/y/Q7cYrAFy5cGHcGkYzi69bgo1/G33gZwhA76EjssN4ZU3D2ebOiQQA1to+KIpW0vTsT1KhRg6VLl8YdQySjeF4e/u4b+KvPwcrlWPuOWI8TM2YglC9bTHj7v2DDBoJLbtb27gyh9VTkj9wdPv6A8MUnYfHCqG1a71My5o5hX7eG8O5/w9fzCc69Utu7M4TWU5E/5/NnE74wCObPhh12IujVH2vZNu5YAHgY4k/cg08ah/U5leDg7nFHEqBu3boAKfuEV4VmkRLIf1yKv/IMPmksbFMJO/I47MBDsdKl48v09XzCO6+EylUILr1F27sziC7kRf6ar1mNv/4i/uarYIYdfBTWrVesuzH852WEt18Oq1cS/PNGrH6j2LLI5rSeivw1z8vD33kdH/4crF6F7dMZO7ovVjW+HSO+YT3hf6+Hzz8jOPMybe/OIFpPRf6au8O09wlfegqWLIIWbaKCc72dY83kzzyIjx+NHd2X4PBEbFlkcyo0F5wKzSJb4AvmEyYHwZxPofYOBMf0g9Z7Fft2Rf/ua8I7roByFaIic4bcESgRXciLbJkvW4y//DT+wTtQeTvsqOOxAw7BSpUq3hwrlxP+5wr4cSnBhddhjZoV6/Hl72k9FdkyX7MKH/EC/vZrEATYIT2wrj2x8hWKN8fGjYQP3gyfTcNOvYhg7w7Fenz5e1pPRbbMN26MWr2NGAJr12L7H4x1P6HYb+pydzz5OD7mVaxbL4KeJxXr8eXvqdBccCo0ixSAu8P0KYQvPhH1bm7aiqB3f2ynxsVz/B8WRtu7LYiKzLXqFMtxpeB0IS9ScP7l54TXlCE2AAAgAElEQVQvPA6fz4Q6OxL06get9iiWD/B8zaqoJ/P33xJc8G+saau0H1MKR+upSMH5kkXRB3iTJ8B2VaPiyH4HYUH6P8DzTZsIB94O0yZiJ51LcMAhaT+mFI7WU5GC89Ur8eFD8LEjoXRp7NCeWJceWLlyxXL88JVn8BHJqHVnn9Myrg9/SadCc8Gp0CxSCJ6Xh094A3/1WVi1AmvfCevRN613F6uHaHbQhbxI4bg7fDSJ8KUnYfH3sGvrqN/ojg3Sd8x1a6NBVeohmtG0nooUXnH3G/UwxAfdjX/wDtbnNIKDj0rbsWTraT0VKTxfvDBqpzFtIlSphh19IrZPJyxI38DAcNSL+NDB2P5dsBPPSeuxZOuo0FxwKjSLbIU/9Bvt0h3rdgxWPrX9RjfvIXpTxgx8kT/ShbzI1vG8jVG/0deehzWrsH3z+41WSW2/UfUQzR5aT0W2jrvD1PeiAsnSH6J+o71PwXbYKeXHUQ/R7KD1VGTr+eczow/wvpwLOzaI1tNdW6f8OOFbw/HnB2J7dcBOHVAsO1Kk8FRoLjgVmkWKwJctxoc+jX+Y32+0+wnRp5Ap6DeqHqLZRRfyIkXjq1fhI5P428MhKJXfb7RHSvqNbtZD9JQLCdp3LHpgSRutpyJFk85+o5v1ED2sN0GPE1OQWNJF66lI0XgY4pMn4C8/DcsWw257EvTqh9XZMSXvH777Jv7UfbB7e4IzL8VKl07J+0rqqdBccCo0i6SAfzk3Ghg4L7/faO/+0LLdVvdV2ryH6LVY05YpTiyppgt5kdTwJYvwoYPxKe/CdtWw7scXqd/oZj1ETzyH4MCuKU4sqab1VCQ1fNWKqN/ouJFQukxK+o2qh2h20Xoqkhq+cQP+1mv4yBdg/TrswK7Ykcdh21bZ6vcMP3gHf/wuaL47wTlXYWXKpDCxpJoKzQWnQrNIiqSq36ivW0N497/VQzTL6EJeJLV8/mzC5OPwxZyo32jvU7AWbQr3HmGIP3EPPmkc1udUgoO7pymtpJLWU5HU8h8WEg79pd9o9Wi+SPvC9xv9tYfoAYdEPURVZM54Wk9FUstXLsdfew5/53UoWw7r1gs7+CisbOE+wPOPJxE+dCs03pXg/GuLbeCgbD0VmgtOhWaRFPO8jfi4UfjwIYXuN6oeotlLF/Iiqefu+JT38KH5/UZbto0GXBWg36h6iGYvraci6eFzP4v6jX71eaH7jaqHaHbSeiqSHr7oW8IXn4RPPoRqNbEeJ2J7HVigD/B8xjTCB26EHRsSXHR9yuc8SXqo0FxwKjSLpMmv/UbfGg6lSkW9Rrv2xMqV//Pn/76H6KkXEezdoZgTS1HoQl4kfaJ+o8Px4UlYt+V+o5v1EO3Wi6DnScWcWIpC66lI+vzab3ToYPhxSX6/0f5YnXp/+Rr1EM1eWk9F0stnTyd84QlYMB92akyQOAVr8tdtL33uDMJ7r4VaOxBcfBO2TaXiCytFokJzwanQLJJmvmQR/tJT+NT3on6jR58Q3eX8uztBNushetK5BAccEmNi2Rq6kBdJv837jZbN7zd69B+2G6qHaHbTeiqSfr5xAz7mNXzUL/1GD8WOOg6rvN1mz1MP0eym9VQk/TwM8UnjooGBPy+LPpQ75mSs9g6bP+/LuYR3Xg1VqxNccnOR+jtL8VOhueBUaBYpJj5vVrRd8Ys5UG9ngt79seZtoh9Mg+7GP3gH63MawcFHxR1VtoIu5EWKjy/6Luo3+tGkP/Qb/bWH6P5doh6ihexBKvHTeipSfHzlcvzV5/Dx+f1GD+sd9RstU1Y9RHOA1lOR4uPr1+NjhuGjXoK8DVjHw7Aj+mCVtsW/+ZLwjitgm8oEl9yCVd1yW03JLCo0F5wKzSLF6I/9RtthlSpHg6rUQzSr6UJepPj53BmEyUHw9Tyo3xBrthv+xivqIZrltJ6KFD///ttooPUv/Ub3Owgf9aJ6iGY5racixc+X/4S/+iw+4U0oXwE7+Eh83CgoXYbg0luwGtvHHVG2ggrNBadCs0gMNus3unY1dlhvgh4nxh1LikAX8iLx+EO/UfUQzXpaT0XiE/UbHQQLvoB6DdRDNMtpPRWJj3+3gPDFJ2DGVNi2SnQn8/9rpyHZQ4XmglOhWSRGvmoFfDUPWrRRD9Espwt5kXj5hvUwazo03109RLOc1lOReHkYwsyPoEFTFZmznNZTkfj5vFlQpZruZM5yqS4065YYEUkLq7QttGwbdwwRkaxnZctB6z3jjiEikvUsCKBlu7hjiIjkBGu8a9wRJANpioyIiIiIiIiIiIiIFIkKzSIiIiIiIiIiIiJSJBnTOiORSPQGrgV2BfZKJpNTfve1y4FTgU3A+clkcnQsIUVERERERERERETkDzLpjuYZQE9g/O8fTCQSzYFjgRbAocCDiUSiVPHHExEREREREREREZE/kzF3NCeTyVkAiUTi/3+pO/B8MplcD3yZSCTmAXsBE7f0nvmTE0VEpIi0noqIpIbWUxGR1NB6KiKSeTLpjua/sgPwze/+/m3+Y3+QSCTOSCQSU/L/rAJMf1L3J5FIPBp3hlz7o3Oqc5oNfxKJxNK4M+TaH32f6pxmwx+d07ScU62nqT+n+j7VOc34PzqnaTmnWk9Tf071fapzmvF/dE7Tck6XkkLFekdzIpEYA9T+ky9dmUwmh/3Fy+xPHvM/e2IymRwIDMw/1udbFVL+zmtxB8hBOqepp3Oaej/HHSAH6fs09XROU0/nNPW0nqaevk9TT+c09XROU0/raerp+zT1dE5TT+c09VK6nhZroTmZTB68FS/7Ftjxd3+vBywswOuWb8Wx5G8kk0n9HzrFdE5TT+c0LbSeppi+T1NP5zT1dE7TQutpiun7NPV0TlNP5zQttJ6mmL5PU0/nNPV0TtMipetpxvRo/huvAs8mEom7gLrALsCHBXjdwLSmEhEpObSeioikhtZTEZHU0HoqIpIaKV1Pzf1Pu1AUu0Qi0QO4D6hJdNv2x8lksmv+164ETgHygAHJZHJUbEFFREREREREREREZDMZU2gWERERERERERERkewUxB1ARERERERERERERLKbCs0iIiIiIiIiIiIiUiQqNIuIiIiIiIiIiIhIkajQLCIiIiIiIiIiIiJFokKziIiIiIiIiIiIiBSJCs0iIiIiIiIiIiIiUiQqNIuIiIiIiIiIiIhIkajQLCIiIiIiIiIiIiJFokKziIiIiIiIiIiIiBSJCs0iIiIiIiIiIiIiUiQqNIuIiIiIiIiIiIhIkajQLCIiIiIiIiIiIiJFokKziIiIiIiIiIiIiBSJCs0iIiIiIiIiIiIiUiSl4w6QRh53ABEREREREREREZEMZql6o1wuNLNw4cK4I4iIZL0aNWqwdOnSuGOIiGQ9raciIqmh9VREJDXq1q2b0vdT6wwRERERERERERERKRIVmkVERERERERERESkSLKqdUYikSgFTAG+SyaTR8SdR0RERERERERERESy747mC4BZcYcQERERERERERERkd9kTaE5kUjUAw4HHos7i4iIiIiIiIiIZD5fv45Nt/+L8M1hcUcRyXnZ1DrjHuBSoPJfPSGRSJwBnAGQTCapUaNGMUUTEcldpUuX1noqIpICWk9FRFJD66kUlLuz4r83su7zmQRr11DjuFPjjiSS07Ki0JxIJI4AFieTyamJRKLjXz0vmUwOBAbm/9WXLl1aHPFERHJajRo10HoqIlJ0Wk9FRFJD66kUVPjum/i4UVBnRzZ9+xVLZs3AataOO5ZIxqhbt25K3y9bWmfsBxyVSCS+Ap4HOicSiWfijSQiIiIiIiIiIpnIv/0Sf/YR2LU1wVmXR499OiXmVCK5LSvuaE4mk5cDlwPk39F8cTKZ7BtrKBERERERERERyTi+bg3hw7dDxUoEp12EbVsVatXBP50KnY+IO55IzsqWO5pFRERERERERET+lrvjgx+Axd8TnHFxVGQGrNUeMOdTfP36mBOK5K6suKP595LJ5DhgXMwxREREREREREQkw/g7o/DJE7CeJ2FNWv76uO22B/7WazB7OrTeM8aEIrlLdzSLiIiIiIiIiEjW86/n4UMeg1Z7YF17bv7FXVpCufL4DPVpFkkXFZpFRERERERERCSr+ZpVhA/fBttWIThlABZsXvKyMmVg19b49Cm4e0wpRXKbCs0iIiIiIiIiIpK13J3wif/CT0sJzrgUq7Ttnz7PWu0BPy6BhQuKOaFIyaBCs4iIiIiIiIiIZC0f8yp8PAnr1Q9r1Owvn2ct20XP/1TtM0TSQYVmkRLC58zA58yIO4aIiIiIiIhIyvj82fhLT0Kb9thBR/3tc61aDajXQIVmkTRRoVmkBAjHjya88yrCe67B534WdxwRERERERGRIvOVKwgfuR2q1iDodz5mtsXX2G57wLxZ+OpVxZBQpGRRoVkkh7k74fAh+NMPQPPWUGN7wgdvxhcvjDuaiIiIiIiIyFbzMCQcdDes/JngH5dhFSsV6HXWag8IQ3zmR2lOKFLyqNAskqM8DPHnHsGH/Q9r35Hg3KsJzrsGDML/3oCvXhl3xKwXjh3BpgduJhw7El+yKO44IiIiIiIiJYa//hLMmIr1OQ3bqXHBX9iwCWxTGdQ+QyTlSscdQERSzzduxAfdjU95F+vSHevVHwsCqFWH4OwrCe+6ivDBWwguvA4rXSbuuFnJV67AX3wScPzjSThArbpYy7ZYy7bQpBVWrly8IUVERCRlfOEC/Ov5WNt99TNeRCRmPmcG/sr/sD0PwDp0K9RrLSiFtWiLz5iGh2H0u7KIpIQKzSI5xtetIXzwFpj1CdarH0HXnpt93XZpjvW7AH/sTnzw/dB/QIH6WMnmfOxw2LCe4Nr7oXTp6CLls2n4u2/gbw+H0mWgSQusRX7huc6OOs8iIiJZyBd9h7/2PD55PLjjLz+NHXMytteB+tkuIhIDX/ET4aP/gVp1sJPO2bq1eLc94MN34KvPoWHT1IcUKaFUaBbJIb7iZ8L/Xg/ffIH1v4Bg34P+9HnB3h0IF3+Pv/osbL8DdniimJNmN1+3Fn9rOOy+N7ZDfQBs+7pw0BH4xg3w+WdR4XnGNPyFQfgLg6Bajd+Kzs1aYxW3iflfkXk8DPHk4/ji7wnOuAQrXyHuSCIiUoL5kkX4iCH4xLFQugzWtSfWpCXhK89EH9iPHUHQ53SswS5xRxURKTE83ET46J2wZjXBgOuw8hW36n2sRRvcAvzTqZgKzSIpo0KzSI7wJYsI7/k3/LyM4OwrsdZ7/u3z7Yg+sHgh/sozhLXqEOx5QDElzX4+fjSsWUVw6DF/+JqVKQvN22DN20DiVHzZkuhO58+m4VPexSe8AUEAjZrlF57bwY4NSvx2LXfHhzwW3Q0OhPffSHD+NVhZbU0WEZHi5T8uwUe8gL/3JliAdT4S69YT27YqAEGL3fH338Zffprw5n9i+3TCep6EVakec3IRkdznrw2B2dOxfudj9Xbe6vexSttCwyb4p1Og+/GpCyhSwqnQLJID/JsvCe+9FjZuJLjwBqzxrlt8jZnBSefhyxbjg+7Bq9Yo0OtKOt+4EX/zFWjaCmvUbIvPt+o1sQO7woFd8bw8+GJOVHSeMQ1/5Rn8lWeg8nZYi7bQsi3WvA1Wedti+JdkFn/lGfzt4ViX7lC/IT7oHsKHbyM4+3L1ERcRkWLhP/+Ij3oRH/86ONgBXbHDemNVNy8gW1AK278L3m4/fOQL+Jhh+LSJWLde0WwMfUgqIpIW/tlH+Igh2L4HEex3cJHfz1rtEf0e8vOPWJVqKUgoIubucWdIF1+4cGHcGUTSzufMIHzgRihXIdo6lN/KocCvX7WC8JZLoq1HV9yB1aydpqS5IZzwBj74/uhct2hTpPfyFT/hn30MM6bhM6fBqpVgBjvv8lubjZ13wUqVSlH6rVOjRg2WLl2atvcPR72IDx2MHdgV63s2ZkY4/nX86Qeh7b5RG42Yz4GISCqkez2VreMrl+OvD8XHjYC8PGy/g7HDE1j1WgV7/eLvCV98Aj6aBNVrEfTuD233Vf9mkTTSelry+E/LCG8YAJW3I7jizpQMZfUFXxDeMAA7+TyC/bukIKVI9qlbty5Ayi5aVGgWyWI+bSLho3dAje2jwmf1mlv3Pou+I7z10uiH9r9ux7aplOKkucHDTYRXnwPlKxBcdVdKf4H0cBN8Pf/XoYJ8MRc8hIqVsOa7R3c7t2gTy7bcdF7Ih28Px58biO3VATt1ABb8VlAOxwzDhzyOte+E9b+gxLcXEZHsp8JIZvHVq/A3Xsbfeg02bMD27oAd2QerVXfr3m/WJ4TJx+Hbr6BJC4I+p2H1G6U2tIgAWk9LGt+0ifCOK+GbLwiuvBOrs2Nq3ted8NJToGFTSp31r5S8p0i2SXWhWa0zRLJUOH40/sxDsHPjqJdtpa1vt2C1dyA463LCu68hfPhWgguuxUprefiDaRNh8UKCMy9N+V1KFpSCBk2wBk3gyGPx1SvxmZ/AZ1PxGR/BlHdxgJ0aE/QfUOg71zNR+N5b+HMDo6GK/S/YrMgMEBzcnXDdOnzY/6BsOeh7lu4OExGRIvO1a/Axr+JvDoO1q7E9D8COPA6rU69I72u7tia4+m58wpvRDIwbL8L274IdfcKv/Z1FRKTw/JVnYN5M7LR/pqzIDFE7SWvVDp88Ac/bqJZ9IilQ6tprr407Q7pcu3LlyrgziKScu+MjknjycWjZNioyV9ymyO9rNWpBtZowZhgs/xFa76Wi3u+4O+Gge6B8Rez4MzFL7921VrYctkN9bPf2Ub/HtvtAje1h5sf4+NFYgyZYje3TmuEXFStWZM2aNSl9T5/yLj7oHmjemuCsK7Ayf3FRt0sLyNsY3W22di20aKPvSxHJWulYT6XgfP06/M1X8EduhxlToWU7gjMvIeh0eMrmI5gF2M6NsQMPgY15+ITR+LhRUKoU7NRYraBEUkTracnhn0zGn30YO/BQgsN6p+EAIT5xLNa0ldpISolUuXJlgOtS9X66ZVEki3gY4s8PxMeOxNp3xE4+P6V3Hgf7diZcvBAfkYRadbFux6TsvbPezI9hwXzspHP/cOdtupkZ1GuA1WuA73kA4b3XEd5zLdbvPIL2nYo1Syr49MmEj90JjZoRnP03RWby/+09ToL16/Exw6B8eaz7CcWYVkREsp1vWI+PG4W//hKsXA6t9iDofjy2U+O0HdMqVsL6nIp36EqYHIS/+CT+zusEiVOg9d760FREpAB82WLCQXfDjg2wY09Lz0GatYbSpfEZU7FdW6fnGCIliArNIlnCN27EB92NT3kXO+Ro7Jh+aelZa91PgMXf40OfwmvVxtrtl/JjZKNw1ItQpRoWc2HXqtci+NdthA/egj9+N+HSxdHAoiz5hdVnTyd86Fao14DgvKuxcuW3+Bozgz6nwfp1+PAhhGXLE+hDEBER2QLfuBF/9w18xAvRbq1dWxN0PwFr1KzYMljtepQ6/xp8xjTC5OOED9wc5ehzGrbDTsWWQ0Qk23jeRsJHbgcPCf5xGVambFqOY+UrQJOW+PQp0PuUtBxDpCRRoVkkC/i6NYQP3gKzPsF69SPo2jNtxzIz6H8B/uMSwsfvJqhaA2vYNG3HywY+fzbM+RTrfcrf3n1bXKxiJYIB1+JP3R/1L162GE44K+P7avv82YT33wg1a0d9wAvR8sWCAE46Bzasx4c+RViuHEHnI9KYVkREspXn5eHvvxXt0PpxCezSnOD0i7GmLWPLZC3bEjTbDX/ndfzVZwmvuwDr0BU76oSUte0QEckl/uKT8OVcgn/8a6uHtBaUtdoDH/IYvmSR2meIFJF6NItkOF/xM+Fd18CXc7B+5xN0Ojztx7RSpbDWe0VDESa+jbXbD6tYKe3HzVThc4/AiuUEp12UMQMiLCgFbdqDezTQ6Ku5WOu901IIT0UPPF/wBeE910Dl7Qguvhnbrkqh38MsgNZ74999BWNeheo1sfoNi5RLRKQ4qadoenm4CZ84Dn/kNpg4FmrXI+h/Pta9b7HNNfg7FgRYwybYAV2iXTrjX8fHvw5lykD9xmnZqSaSq7Se5jaf+j7+wiDsoCMJDjk6/QfcpjL+9nCoWQdr2CT9xxPJIKnu0Wzunqr3SptEIrEjMBioDYTAwGQyee8WXuYLFy5MezaRdPIliwjv+Tf8vIzgjMuw1nsW7/G//4bwlkuhanWCy25LydDBbOPfLSC89lzsiGMJuh8fd5w/Fb77Jv70A1B3p2g4ZNXqKX3/GjVqsHTp/7F353E2V38cx1+fM6ux77Lv+76EpJLSrv2WFqUiSpa00CLSvpCSSHtJXaUQZUtU0oJkSUkiZN+Z1fn8/viqH0UNc+98771zno/HPEwzd77nHXe+93s/33M+Z+tx/7z+sQ775ABISMDc9RhSvFSO8mhmpjcz+sfFSNd+mBZtc3Q8x3Gc3JLT86lzZGqtt8ns5HGwcT1UrIq58Gpo0DyiW0vp+rXY4MuwfBGUKYcJ3IQ0aOZ3LMeJCu58Grt08wbsQ7d7NwvvejTXJvocuLc7lCpDXO9BuTKe40SKsmXLAoTsgilabptnAf2CwWAdoBVwayAQqOtzJscJK/19Nfbxu2HvHkzfIbleZAaQEypgevSHTeuxo59As7JyPYPf9JP3ITEJaR+5bRrMyWdibhsIWzZiH70TXfeb35H+ols2YofeDyLe8ziHRWYASUjA3HIPVK+NvjwU/f7rECR1HMdxoo2qogu/wj7YGx3zFMTFY3r0x9w3DGnYIqKLzABSriKmzyBMz/vBKvbZwRwYPhj9Y53f0RzHcXyhmRnYUY+DGMzNd+XqalJp2BxWLEHT03JtTMeJRVExo/nvAoHARGBEMBic8S8PczOanailPy3FPv8QJOXD9BmMlKvoax77+XT0jRHIKWcj1/SI+DduoaLbNmPv6Yacfj7mijDtchxC+vtq7LMPQnqq18usbuOQHPd4Z4zojm3eTOZ9ezF3PoKUrxySPH8dP3U/dthA+P1Xb2PBuk1CenzHcZxQy0sz8FQVsjIhIx3S0yEzw/v8r48MNCMdMg//GhmHP1YzDvm5w46RAempkJYKZcohF3RCmp8cte0nNCsT/fQj9KN3ISMdOe1c7/8pf95tXeY4/yYvnU/zEvvmSHTuJ5ie9+f+at7l32OHDcT0vA9pdGKuju04fgr1jOaoKzQHAoHKwFygfjAY3P2373UDugEEg8FmGRkZuR/QcXIobf4cdg19gLhSJ1D0gWHERchmBHveGMn+D96iwPW3kf/CTn7HyRW7xwwldfqHlHjhPeJK5Hwmbm44sHUzOx/qR9a63yh0S3/ynZ7znt7x8fFkHeNsdrtrB9vvvQW7bQtFBz9LQs3wLEKxe3azY2BPsjb8TtEHhpEYouK64zhOOBzP+TRa2N272PFALw5s3+LNBstIh+N5nxEXhyQlex+JSd6qooOf///riUhSMiQmkVC9Dsltz0DiIntD3OyyO7ezd9wYUmdORvIXpECnm8jX4cKY+f9znFCJ5fNpXpU6Zxq7nxlMysVXU7Dzrbk+vmZmsKXzOSSfejaFut+Z6+M7jl8SExMhrxaaA4FAAWAO8HAwGJzwHw93M5qdqGPnTkPfegEqV/d67RaInF3I1Vrsi0/Awq8wPQYgTVr5HSmsdPdObP+bkBPbYq7v7XecY6L792FHPeb1ML7gSm9GVA5moR/rjBHdvxf71L2wcT2m9yCkVv3jHjtb4+3e6c2c3rkdc/tDSJUaYR3PcRzneMXyDDw7dTz6wZtI2w6QLz8kJsLBQjEJ3udy2NcO/vm3x0m8K6jCwVVK774EPy2BOo0wXe9ECkbOdaHj+C2Wz6d5kf7xO/bhflChKqbfQ769Fhx4/hFY+wvmsZfzzCpexwn1jOaouZILBAIJwPvA2GwUmR0nqqgqOiWIThwL9Zthut/tzdSJIGIM5oa+2O1bsS897W3MUKm637HCRmd9BFmZyNmX+h3lmElKfkyvB9A3n0cnvwNbN0PnW3Olx5mmpXrtOzb8jul5b9iLzABSqAjm9oewT/THPvMA5s6HkfJVwj6u4ziO49GsLHT2FKjbGNO5p99xYoJUqILp9xD65Ux07CjsQ30xtwyI6Wsvx3HyJk1P8/oyJyRiut3p6w1Hadgc/X4+rF8DIW775zh5RVQ0MQsEAgK8DPwYDAaH+p3HcUJJrUXHjUYnjkVanYa59d6IKzL/SRKTMD3vhYKFsc89hG7f4neksNDU/d4b5iatkTLl/Y5zXCQ+Hrm+F3LhVehXn2KffRDdvy+sY2pmBvb5h+HXnzFd70DqNwvreIeSosUxtw+BxCTs0IHoRreRkuM4Tm7RBV96q0rO6Oh3lJgiIt6Gv3c/Bij2sbux82b5HctxHCek9O3R8MfvmJv6IUWL+5rlz/cvumSBrzkcJ5pFRaEZaANcC5weCAS+P/hxrt+hHCenNDMTHfMUOnsq0uEipEufiF8yKoWKYm67HzLSsM8NQdP2+x0p5HTOx5C6D3NO9M1mPpSIYM6/EunSG35ein2if9huDmhWFnb0E7DiB6RLb6TZSWEZ599IyTKYfkMAsE/fj27ZmOsZHH/YL2ehi+b7HcNx8iRVRWdMhDLloF5Tv+PEJKlcA3PfMKheB311OPbtUWhWpt+xHMdxcsx+OROdNws57wqknv8be0vR4lChCrrkW7+jOE7UiqoezcfI9Wh2Ipqm7ceOfNTro3vZ9ZizLvE70jHRZYuwzw6Guk28nXnj4vyOFBKamYEd0BXKViTu9iF+xwkZ/XEx9oVHISkZc9tApGLVbP/sf/XAU3sAfWko+u3nyNXdMaf5ex9Q163GPnkvpOTH3PkoUqyEr3mc8NL9+7B9rwZrodlJmKu6I4WK+B3LcY4oFnuK6i/LsY/3j4jzf6zTAwfQCW+g0z+A6nUwN9+NFCnmdyzHyfzacy0AACAASURBVHX2s49JXLOSzAs6IcVK+h3HOU66bjX2kTuhWm1M38GIiYz3k/aDt9BP3sMMfQvJX8DvOI4TdqHu0RwtM5odJ6Z4m5fdCz8tQbr0jroiM4DUa4Jc1R2WLkDffcnvOCGj8z6FXTsw51zmd5SQkjqNMHc9BsZgnxiALg3NcjC1Fn3jea/IfNn1REKRQcpXwfQZDHt3Y4fdj+7e6XckJ5xWLAZrkdanw+JvsA/civ1mLjF8I91xIoqdOQlSCni/g05YSVwc5vIuSLc7Ye2v2IduR3/50e9YjpOrdM8u9L1XSf9iJnZQL29Vk3vNjzq6bTN21BPexJCu/SKmyAwgDZqBteiyhX5HcZyo5ArNjuMH8X71zK33Yk5q73OY42dOPRvpcBE6ewp21mS/4+SYHjiATpsAVWpC7YZ+xwk5KV8ZM+BJKFUG+9wQ7OfTc3Q8VUWDL6NfzkTOvyKibphIlRqY2wbC9i3YYQPRfXv8juSEiS5dCPnyI9fdhrn/GSh5AjrmKezIR9FdO/yO5zgxTbdthoXzkVPOitj9JWKRadHWez1PTMQ+dS/2s6mu0BahVBX79mgOPP8wmp7ud5yYoNMmQEYGRe59EipURl8bjn3+YXTndr+jOdmg+/di33sNe18P2L4F0/VOpFBRv2MdrmpNKFAQXJ9mxzkucYMGDfI7Q7gM2rPHFRacyCRJSUjbDlG70dxh6jRE162BWR8hFashZcr5nei46befwxczMJ26IWUr+B0nLCQ5BWl5Krp2FcyYCAcOQO0GiBx9pUxKSgr79/+zF7d+OBad/gFyRkfkkuv+9Rh+kOKlkCo10E8/Qn/8AWl+MpKQ4HcsJ4RUFR03GmrUw5x4ClKwMHJSe0jOB3OnoXOnQdFiUK5yxD0/nbzpaOfTaKVT3oXVP3kbOOXL73ecPEUKFUFatUPXrYaZk2D7FqjXNGZamcUKnTnJ+z3ZuB5d8wvS7GT3b5QDunsH+tLTSIuTKRzoQmqjVpA/P8ydjn4+HYqWgHKV3Gt+BNKsTHT2VHTUY96eLi1PwdxyD1Khit/R/kHEwLrf0GULkQ4Xev/tODGsYMGCAINDdTxXaHYcn8TKBZCIQRq1QJctROd+gtRvhhSOsLvS2aCq6MtDIX9B5MquMfPvcyQSn4A0Pxl270BnTYLNf0CDFkd943Okwoj9+H100tveDZOrbo7Yvy8peQJSvrL3Rm/lMqR524jfcNM5Bn/8jn78HnLmhUilagCIMUj1OkizNuiqH2HWR+iaVUit+khyis+BnbwulgrNmrYffXkY0rgl5uQz/Y6TJ0liItKiLaDorMno0oVIvaZIiiv6RwL9cTH6yjBo3BLpcBHMnIRuWIs0PQkxrnB1PPTDt2HVCszNd5O/VGlSU1ORqrWRZiehPy+DTz9C169FajdwqywihKrCwq+8vWK+ngNVa2N69Mecdm5E36DUzEyY/5n33tbt9+LEOFdozj5XaHacXCLx8UjD5uj8OejXc5AWbZF8UVbQWboAnTERubwLpmI1v9OEnRgDDVtAXLz35vSXH5FGLZHExH889u+FETt7Chp8GTnxFOT62yL+zZKUKQ+ly3pv8H5b6c1sdrOJYoJ+NRuWL8JcdfM/3qxIwULISadDSgH4Yro3u7lQUahQJWJvjDixL6YKzXOmwffzMdfdhhR1b8L9IiJI7YZIxSro59PRL2YglasjJUr7HS1P062bsM8MhGKlML0GYqrVhvwFvNnnWzd5xWf3WnRMdOc29JVhSMtTMSefedj5VAoU8lY0JSbB3E/QL2YiJcsgJ8TmCsVooatWYF98Ep3xIRQuhunSG7nw6ujYxLRocXTah1CkKBKDLRUd51Cu0Jx9rtDsOLlIklOQOg3Rzz5Gly9EWp6KxEdPmwL72rOAYjr3jKjNKMJJRJCa9bwi7Kcfod/PRxo0R1IO31350At5O28W+ubz0OhETNc7kLjomB0s5SpBsZIwYyK6fo2bTRQj7KS3ISERc+7lR/y+iEGq1Uaan4z++pP3PF+9EqlZL6Jn0TixK1YKzWot+vLTUKYcpmMnv+M4eDdVpWlr9Idv0ZmTICkZqtZyxUwfaHq6V2TetxfT76G/impStRbExXn/Prt3QsPm7t/nGOiEN+G3lZjudyP5C/zjfCrGIDXqIk1aoSt+QGdNhk0bvBZxiUk+Js97dPMG7JvPo+NfAXsAueImzDW3eOepKHnOS2ISunwRbPgdc+rZfsdxnLByhebsc4Vmx8llUqgoUqEKOmOSV8xr3iYqelrpyuXo5HHIhVdjqtfxO06uk/KVkRp10S+mo/NmecsND5lp8OeFvC74En15GNRp6PVUi7J+x1Kxqrexx8xJsHkDNGkVFc9P58g0PQ0d+4J3U6tek399rBQoiLQ+HQoUgi9moHM/8T6vWDVq3vA4sSFWCs388C362VTk8huRchX9TuMcJAUKIa3boRvXwazJsHE91G/mWkblIlVFXx0OKxZjevT3isuHkJr1ICvDK4Kmp0Hdxu51KBt0+xb01WeQk9pjTjodOPr5VAoVQdqc4RX153yMzvsUKVMOKR29+8hEC927G53wBvrqs7BlI3JuANP1Dky12tE5wWP3Tvj6M2/D2+R8fqdxnLBxhebsc4Vmx/GBlC77/6WBaalI/aZ+R/pPduwLsH8v5obb8+ybMSlRGml0IvrdF+jsKUiFKn9dkKekpLDv67nYUU9A1ZqYXgOjdmaIVKkJCYleb+od26BhC/cGL1r9+D361WxMx6uQkmX+8+EiglStiZx4CvrbSm9286oV3uxm18/UySWxUmi2b40Etd4MtWgsHsSwv/ZhSEj0NsNd/A1StwmSv6Df0fIEnTERnfEhctE1R+9dXrsR7N3jFZsRpFaDXM0YjfT912Htr95s5oOv2f92PhVjvL0ZGrZAly3yZpFv3ww1GyAJ/2wT5+SMZmagMyeiox6HlcuRNu0xt9yDaXRiVK1w/YfkFHTOJ3BC+b/2AnGcWOQKzdnnCs2O4xOpUhP27/UuoOPjkRr1/I50VLpuNRp8BTnnMkzdRn7H8ZUULIy0aIsu/x6dMQkKFkYq1yD+1xWkPn0/lK2I6TM4+vpv/43UqAtqvefn/r1Qv6krNkch/fQjWL8Gubr7MfXclvwFkFbtoHAR+HIW+tnHXh/nitXc88AJu1goNOvvq9EJryPnBTAR/Pqel4mI10Kgam30y5no59OQ8lW8yQBO2Hib/z0DTVthOh19o2QRgXpNYfsW78Z3cjJSLe+tqMsu3boJfe05pO2ZmJan/fX17JxPpXAxpM2ZoIrOnorO/wwpWxEpdUKYU+cNai36zVx05KOw4Euo0wjTYwCm7ZmxMQO4UBH0i5mQmY5p0dbvNI4TNq7QnH2u0Ow4fqrbGDZv9C6g8xf4x9LBSKHvvgxbN3v9ho+wEV5eI8n5vBmf636DmRNh22bSgq9C8ZJen8ECMTIjqlYDSE31is1ZmUidxn4nco6RfWcMVKr+1xLaYyEiSOUa3nN97SpvdvPKZUiNekj+Av/5845zvGKi0DzhDdi0AXNjP/e6GeGk1AlI8zbo0kXozIkgBqrXdTfVwuCvzf+Kl8L0uv8/Z82KCDRqARvXe7NtCxVBKtfInbBRRse/CuvXYG6++7DJDtk9n0pcHFKnEVK/KbrkO+/ve9cOqFUvumfb+kx/Wood/TjMngIlSmFu6oc5/wqkUGG/o4WMiMDGdfD910iHi/LMPj5O3hPqQnOO1ogHAoEbsvO4YDD4Sk7GcRwn+oiJgy690Yx09J0x2MQkTNsOfsc6jG7ZiH77BXLmha64dAhJzoe55R70nRfRzz4mrkw59PYHkYKF/I4WMiICgRsgIx39+H1s6XKYNmf4HcvJJt38B2zegJx+fo6OIyVKY/o+iH4+HR3/CnZwL+SSzshp57p2AI5zBLp7B/rNHOTkDu51M0pIyTKY/k+gb45AJ45F1/yCuaFv1K9OiiSano4d+QgcsJhb70WSs/d3KyYObuzr7Tnw9ihscjKmVbswp40uuvkPb/+QduchxUrk6FhSpSbm/mHe78GMieiyhZguvV3rkmOkf/yOff91WPwNFC2B3NDX2y8jRq+bpEFzdO40WLkc6uTt1a+Ok105bUZ6bTYeo4ArNDtOHiTx8Zhud2JHPoy++bxXbG55qt+x/qLTJkCcQc7s6HeUiCNxcXBVd6R+M4o2acEOG3uzn0QErr4Z3bQefXsUWqUmUtZtahUNdNkigJD0gBcR5JSz0HpNsW+OQMe9iC74EnPdbUgpt8zccQ6ln30CWVlI+wv8juIcA0lKghtvh8o1vJtqj/TzNvU9oYLf0aKeqqJvPAfrfsPcNvCY25NIfAKm+93Y54agrw5HE5OQpieFKW300Y/ehbh45OxLQ3I8SUxCLr8BbdwK++oz2KfuRdpfgFzc2fs9cY5Kd+9AJ41DP58OiUnejfn2F0Ttvi3ZVrshxMejS75DXKHZcbJFVNXvDOGiGzZs8DuD4zgcnOnx7GD4ZTmme3+kSSu/I6G7dmD734S0bofp3NPvOBGtRIkSbN261e8YYaM7t2Mf7A0FC2Puedq90YgCB0Y8BBvWYh4eHdIl4KqKzpvltdQ5kIlcfC1y+vkRsVRSszLdEt8YEM3nU83MwN59I1SuQVyvgX7HcY7TX8vdMzIwN/RBmrb2O1JUs9M/QMe/6m3+d17guI+jaanYZx6A337B9LwXqd8shCmjk25cjx14K3LGBZjAjf/4fk7Pp5qehr7/Ojp7CpQq681uru56Zf+dpqejMz5EP5kAWRnIKWcjF1yJFIydFhn/5cCwB2D7ZuKGvOB3FMcJi7JlywKE7E1VWHo0BwIBGT9+vBk/fryMHz9eLr/8cj+q2a5Hs+NECImPR5q19jZJmf0RUrmG75tw6JQgrFyO6XaH24n9P8RCT9F/I8n5kPJVvJ59e3YijU70O5LzLzQzEx37AtL0JEzDFiE9toggFasirdqh69fCp1PQHxcj1esgBcLfOkYz0mHjevhlOfr91+iXM7DTPkAnvOF9zJuFrlwGWzZCZgakFIj9mUQxJprPpzr/M/hmDuaaHkjJMn7HcY6TlCiFtDgF/WkJOmMiHMiCWvURic1l7+Gky79HXxkOTVtjOnXL0Y1PiU9Amrb2egjPnopUr4uUKBXCtNFHx42BLX9gut+NJCX/4/s5PZ9KfDzSoDlSsx666CvvOjAtDWrWO6ZNhmOV2gPovE/RkY94bTIaNsf0uAfTut0R/z1i2v69MP8zpNVp7n2jE5MiqkfzoQKBQDlgBHAKUORv33ZnasfJ4yQ5BdN7EPbpe7EjH8H0HoTUqu9LFt2/F/1sKtK8jVsa7wAg9Zog51yGTh2PrdUgolq8OH/zy3JITwtJ24yjkaLFMbfdj87/zOsx/2Af5MKrkTM75nh2sx44ANs2w6YN6Kb13p+bN8CmDbB9Cxy60qxwUShdFmncEooU8zaNWvMLuvAr/npUyTJIxWpQuTpSqTpUqoakuN65TmipqreZXLlK3jJiJ6pJsRKYOx9Fx41Gp473+jZ3dTfej4Vu2Yh98Uk4obw3EzYEq2skpQCm74PYJ+/BPjcE028IUqVmCNJGH92wFv12LnLWJUihv5cWQktqN8QMehYd/yo6/QN0yXeYLn2QKnl3c0Zdtgj73quw7jeoUhPT7S6kRl2/Y/lGGjRD3xmDLlmAtM/Z/iCOkxeErNAMjAL2A+2BOXgF50HA1BCO4ThOFJP8f7uAvv1BpGqtXM+hs6dCWmrI+r05sUE6XoX+vBR9cyRaqTpSppzfkZwj0GULIS4ewrx5j4ggrduhdRphx76Avveq17u5S+//7GuqqrBr+yHF5D/+KiqzZaM3g/BP+VKgdDlvuW7pM7zCcumyUKrsUTfr0n17Ye0q9Ldf0DUr0TW/wIIv/198LnWCV3SuXB2pVAMqVnUbfzk589MSWPcb0rlnSNvVOP6RhASkc09s5RrouNHYh/thegxAKlTxO1rE8zb/exTUYm69B0nOF7JjS8HCB6+VB2CfGYS582GkfN77N9HJ70BiMtLh4lwZT5JTkGtvRZu0wr4+AvvYncjZlyEXXJGn2lbputXY8a/B8kVQojTS7U6k+cl5/rwvpcpC6XLokm/BFZod5z+FrEdzIBDYBlQMBoP7AoHAzmAwWCQQCBQD5gWDwdohGeTYuB7NjhOhdOc27BMDYN8eTL+HkYpVc2/s9HTsgJugUjXieg/KtXGjWTT3FD1Wun0L9sE+UKwEZsCTSEKi35Gcvzkw6DYoWJi4fg/l2piqin4zF33nRUhLQzp28t78pqXCpvX/n5F8yCxl0tP+f4D4BChd1isilzr4Z+ly3tcKFg7JGzjduxvWrEJ/O1h4XrPKmyENIOKNeWjxuUKVkBZHnOyJ1vPpgREPwaoVmCdecefFGKS//oR94THYvwfpfJtb1fMvVBUd8xT63ReYXgPD1ktZt27CPt4fDmRh7noUKVM+LONEIl33G3ZwL+TcAObia476uHCdT3X/Xm/26lezoXxlb3ZzLr5X8YudNgF9/3XIlx85/wrktHORhLxTZP8v9t2X0c+mYp4Zm/dahzgxL9Q9mkM5o/kA8OcUnZ2BQKAksBtwU8IcxzmMFCmO6fcQ9on+2GEDvQvoXNr5XOfNhD27MOdclivjOdFFipXEdOmDHTEEHf8KclV3vyM5h9Ad22D9GuSy63N1XBFBWp6K1mmIHTva65f80buQkX7IgwyUKOUVdGvU+//M5NLloGgJxIS3/6kUKAT1miD1mvz1Nd290ys+r1npzX7+aSl8Pceb+SwCZcojlatDpRren+Wr5JnNMPWX5dgxT3sbeLVu53eciKabN8AP3yLnBVyROUZJ1VqY+4diRz+BvvQ0dvMfmAuu9DtWRNLpH6Lffo5c0jmsG/ZJidKYfkOwTwzADj14rVyidNjGiyR20tuQLwXpcKEv40tKAeSGvmjTk7BvPo99pJ9XeD37MiQ+lOWTyKHLFnlF5iatMZ17IvldC66/kwbNvBZSPy6Gxi39juM4ES2UZ8qvgXOBD4BpwLtAKvBdCMdwHCdGSPFSmL5DvKWBT9/vXUCHeYNAzcpCp30A1WpDjXphHcuJXtKoBdLhIu/NZK2GSLOT/I7kHKTLFgIg9cLXn/nfSKGixPXojy6Yh65YDCXK/L+YXKJ0xM38kUJFoEEzpMH/iyG6c/vhxedli+Cr2V7x2Rg4oQJ/FZ+btkYKF/UrftjoH+uwzz0EqfvR14ajKQWQRqHdWDKW6KyPwMQhp53rdxQnjKRQUUzfId7vxOR30EYn5olZnMdCl3vFOGnWJlfar0mZ8l4bjafuwQ49eK1cpHjYx/WTrlkFi+YjF3TyvWe4NG6JqV4HfXs0OvFt9PtvvFnsYe4Zndt0+xbsS09B2YqYG/rmmRvOx6xmPUjK5/VpdoVmx/lXoZxecy1eb2aAPsBsYClwVQjHcBwnhkiZcpjbh8CBTOzQ+9E/l3mHiX77OWzbjDnnsjzfa8z5d3LxtVClJvb159AtG/2O4/xp2SJvU7xylXyNIc1OwlzdA3PWxUjjlsgJ5SOuyHw0UqQY0qgFpuNVxPUaiHnqdcwTr3p9Rs+5DIoWRxd/i749Cvvond4s8hiiO7djhw+CuDjMwGFQoSp29OPoyuV+R4tIun8v+uVM5MS2MXnTwTmcxMcjnW6G/AWw77xIqFosxgJv87+noGwF5PpeuXYdKRWqYHoPgt27sEMHont25cq4frGTx0FKfuSMjn5HAbzVQqbbnZib74INa7GjHkOzMv2OFTKaleVtapmVhene3xWZ/4XEJ0DdRuiS79y50XH+Q8gKzcFgcGcwGNx+8PPUYDA4JBgM3h0MBv8I1RiO48QeKVcJ02cw7N+Lffp+dNeOsIyj1qKfvO8VqBo0D8sYTuyQ+ARM1zsAsC8+GVNvKqKVHjiALv8eqdfU3SgKIRFBihZHGrfCXHQNcb0HYYa+ibn7Mdi3BztsILpnt98xQ0LT9mOfexD27vZmpZWvgun9ABQriX1uCLputd8RI45+MQPS0yKm6OOEn+QvgFzSGVYuR7+Z63eciKDpadiRj4Aq5pbQbv6XHVK1Fua2+2HrJuwzD6D79+bq+LlFV6+Exd8gHS5GUvL7Hecw0vxk5LrbvN+Ld1/yO07I6Puve/33r7vNbYKdDdKgOezYCut/8zuK40S0kBWaA4HAg0f7CNUYjuPEJqlUHdPrAdi5zStq7A1DUeOHb2HDWuTsS8PeK9WJDVKyDOa62+C3leiEN/yO4/y2EvbvRer70zYjLxERpHpdTM+DhY3hg9DU/X7HyhHNysKOehzW/Ya5+W6kcg0ApGBhTN/BkJSMfWawW8FwCD1wAP10CtSsj1Ss5nccJxdJm/ZQqTr63qtoWqrfcXylqujrz8H6tZiud4S9zdvRSK36mFsGwPq12GcfjMl/FztpLBQoiLQ/3+8oR2RanoqcdQn62cfYOZ/4HSfHdME8dOZEpP0FSPOT/Y4TFf5sRaZLFvicxHEiWyirLRX+9tECuAMIyZVpIBA4OxAI/BQIBH4JBAL9Q3FMx3Eih1Svg+l5H2zagH1mELp/X8iOrarYj9+D4qWQFm1Ddlwn9kmzk5B256IzJqKLv/E7Tp6mSxd6G+7Vaex3lDxDatXHdL8b1q3GjngIPXTzwyiiqugbI2DZIuSaWw7rWQ0H9wzoMxgyM7zZgrt3+pQ0wnw/32s35WYz5zli4jCdusHO7ejUoN9xfKXTJnib/118re83OqV+M0y3O2D1z9jnH0YzM3zNE0r6y4+wdCFy1iVIcorfcY5KLrkW6jdFx41Gf17md5zjpps2YF8bDlVq5voGy9FMihSHilXRH9w2ZI7zb0LZOqPL3z7OAS4BsnJ67EAgEAc8D5wD1AU6BQKBujk9ruM4kUXqNML06A/rfsM+9yCanhaaA/+8FH79ybt4jYsLzTGdPEMuvwEqVsW+OjzsfcSdo9NlC6FqTbcTei6Thi2QLn1g5TLs6CfQrBxf1uU6nTgW/epT5IIrMW07HPExUq4iptdAb2VNDMzgDgU7cxKULANuo8Q8SarVRlq3Q6dPRDdt8DuOL3TZInTCm17bhLMv8TsOANL0JOT63rDiB+yox6PynHwkdtLbULAw0u48v6P8KzFxXmu14qW9fs3bou+6UDPSsaMeg7h4b4VPfHTsMREppEFzWLUC3bfH7yiOE7HCvX58OnBRCI5zIvBLMBj8NRgMZgDvABeG4LiO40QYadgC07UfrPopZLM17MfveRevbdqHIKGT10hCIqbbXXBww5RYeVMXTXTPbvhtpe+zyfIq0/JU5Kru8MO36KvDUWv9jpRtds4n6JQgcvKZyAWd/vWxUq02pvsAWL8m5mYLHitdvRJ++RE5/XzEuBu0eZVcej0kJGBjqCdtdunmP7xN0nJ587/sMK3bIVf38M7JrwxD7QG/I+WI/rwUflzstbdLSvY7zn+SlALeKsysTOzIR9D06Frto2+PhvVrMDfdjhQv6XecqCMNmoNab6Wd4zhHFB+qAwUCgap/+1IKcBXwewgOX+5vx1kHtDxChm5AN4BgMEiJEiVCMLTjOLnurAtJTUpk9/AhxL88lCJ3P4okHN/d9sxVP7F92SIKXNOd/GXdJhfHIz4+3p1PS5Qg9da72T10EMkzP6TgNd39TpSnpP64kN2qFG1zOgl5/bnol8uuZZ8oe98aRXKxYhTsdkdEFV6OJP3bL9j59igSm7amSO/7kfhsXPa2O4tUA7ufGUzCGyMofMeQkK6EiZbz6a43R5CeL4USHa/ARNimXE4uKlGCfVfeyN7XRlDwt59Iat7G70S5QtNS2f7QE6gRit33FPGRuEnaZdeyLz6Ova+PIKlgIQrdOiBq9yDZPvw9KFqcEpdec0yFZl/PpyVKkN53MDsfvYvEd1+kUN9BEf+aCJA68yN2fzmT/Jd3ocBpZ/kdJypp0dZsKVSEpJVLKXzepX7HcZyIFLJCM/ALoMCfZ9j9wCLguhAc+0hnbf37F4LB4IvAi39+f+vWrSEY2nEcX9RvgVzdg4yxL7Dl8XuQrncc15t9O+4lyJfC/hankurOCcelRIkSuPMpUKcp0rYD+99/g7TyVd3s2lxkv5oDBQqxs3AJxD0X/XPquciWzaR+MoE0E4+5+Fq/Ex2V/voT9un7oEJVsrr0YdvOY+i7XK8ZcsVNpL/7Eluefcjr6xyiAkI0nE91xzbsl7OQduezfX8q7I+9Tcec7NOW7eCTD9g5ZiimXNXjvvEfLVQVffFJdO1qTO8H2BmfBJH6O3tyB2T7VtImv0M6glzZNSqKnYfSHxdjly5EruzGtj17Yc/ebP+s7+fTKrWQC68m7cO3SC9VFnN2ZBcd9ffV2BefgjqNSD2jI2mR+ryOBnUbk7ZgHhmbN7lVP05MKFu2bEiPF7JCczAYDOct1HV4Gwz+qTyQN5uFOU4eYk47B5uRjo5/BRIT4frexzRbQzdtQBfOQ86+BHEzspwQkCu6egWsV4ZhBg5HihTzO1LMU2vRZYuQuk2idrZWLJFLr4PUfejU8diU/JizIqNv6aF00wbsc0OgcDFMr/uR5HzHfAxzRkfsnl3o1PFQoDBy8TVhSBqZdPYUsIqcHtm9Up3cIfEJmCu7eRtlzpyInHOZ35HCSj+ZgH73BXLpdUi9Jn7H+U9yQSdIS0VnTISkZOSSzn5HyjZV9XozFymOnHLk/vmRTs69HH5fjU54Ay1XyWurEIF0/z6vL3P+Apib+rniaE7VbwbzP4PVK6Fabb/TOE7EiZZ3bN8CNQKBQJVAIJAIXAlM8jmT4zi5wHS4CLnwKvSr2d4Oz/qPxQxHpdMmQHwCckbHMCZ08hJJSsJ0uxPS07AvPR31fRGjwrrVsHsnuBnkEUFEkKu7Iy3a5lHKbwAAIABJREFUou+9hp07ze9Ih9HdO7HDBwGK6fUAUqjocR9LLroGadsBnRr0NsbLAzQ9HZ07DZq0REqW8TuOEyGkXhNo3AqdEkR3bPM7Ttjo0oXoB28gLdoiEXgT7UhEBLn8BuSUs9GP38NOCfodKfuWf+/1gj/vciQh0e80x0VEkC69oVxl7Jin0Y3r/I70D6qKff052LoJ0+0upFARvyNFPanfFMSgS77zO4rjRKQczWgOBAK/c4QWFn8XDAYr5mScYDCYFQgEegLTgDjglWAwuCwnx3QcJ3rIeVdAejr6yfuQmAyXXf+fSwN1xzZ03qdI2w45KjQ4zt9J2YrIVd3R14ajHwWRjv++wZiTM39utiL1GvucxPmTmDi4oQ+auh99ayQ2XwqmRVu/Y6Hpad5M5p3bMf0eQnLYV1VE4Joe6L496LsvYQsUwrQ6LTRhI5R+PRv27cG0dzdoncOZwA3Ygbei772GdO3nd5yQ081/YMc8CeUqIdfdFlUtKEQEru4O6anoh29hk/Nh2l/gd6x/parYiWOhWEmkzZl+x8kRSUrG3HoP9uF+2Ocfxgx4KqJWUuqsSbBwHnJZF6RGXb/jxATJXxCq1fYKzRflnRVPjpNdOW2dcehvVQu8fszPAmuASkBP4I0cjgFAMBicCkwNxbEcx4kuIgKXdIb0NHT6B5CUhHS86l9/Rmd8CGqRDhflUkonL5GTTocVP6AfvYPWrIfUbuh3pJilyxZCxWruhlGEkfgETPf+2OEPoC8PRZNTkAbNfMujBw5gRz8Ba1ZhbumPhGgpq5g4zE39sMMHezeXChRE6vv3/xlOqorOnAwVq4ErRjh/IyXLIGdfgn70Lnrq2UjNen5HChlNS8WOfAQQzC33HNOGdJFCjIEufdCMdPSdMdikZMzJEVzAXfIdrP4Z6dwzJvp+S4nS3mvisPuxLz2N6XlvRLSn0FUr0Pdeg8at3HuiEJOGzb2WKTu3IUWK+x3HcSJKjlpnBIPBOX9+ANcDZweDwTHBYHB6MBgcA5wHdAlBTsdx8jiRg5uctGmPTn4HO23CUR+r+/agc6d5Sx/d0l8nDP5sH0DpstiXhqK7j2GjMSfbdP8+WLXCbbwYoSQpCdPzfm/J8KhH0Z/9WWymqujYF2DJd8hV3ZDGrUJ6fElIxNx6L5SrhH3hMXTVipAeP2IsWwR//I6c2TGqZnM6uUfOvgyKlcCOezFmWkepKva14bDhd8zNd0b1daPExWG63gn1mqBvjMDOnHhMLedyizeb+W0oURppfbrfcUJGatVHrugKS75DPxzrdxx0zy7vBmyxkpguvdx5PcT+vLmuSxb4nMRxIk8oezSXBf6+TexeIGfrFh3HcQ4SY7yZD3/2Bp195EUO+ukUSE9DInz3Zye6SXI+zM13wb492JeHodb6HSn2rPgBDhxA6rlCc6SSlPyYPoOgWEnsiCHomlW5nkGnvIt+Ph055zLMaeeGZQzJl4Lp/QAUKYZ99kF0/dqwjOMnO3MiFC6GND/Z7yhOhJKkJMzlN8C61V4v7xign7wPC+Yhl3ZG6kb+5n//RRISMD3ugcYt0XdfRse+gGZl+R3rcIu/hrWrkPOvROJzusA6sshp53i9/T9+D/vt577lUHsA+9JQ2LML0/1uJKWAb1liVrnKULSE69PsOEcQykLzJGBSIBA4MxAI1AkEAh2AD3Cb9jmOE0Ji4pAb+kKjE9G3R2G/nHXY9zU9Df10MjRsgZSv7E9IJ8+Q8lWQK7vC8kXe5pNOSOmyhZCcD6rW8juK8y+kYGFM3wchX37s8EG5uhmS/XImOvFtpFU75OJrwzqWFCqK6TMYEhKwzzyAbtsS1vFyk25YC8sWIe3OReKjfxm7E0bN2kCtBuiHY9G9u/1OkyO6dAH6wZveCrgOF/sdJ2QkKQnTvT9y9qXonE+wzz2I7v/7fDB/qLXYieOgVFkkBnveiwhy1c1QvY7Xbmntr77k0CnjYfkipFM3pGI1XzLEOhFBGjSH5YvRzEy/4zhORAllobk78BUwClh48M+vD37dcRwnZCQ+3ptJWrcx+vpzh80Y0M+nw949mHMu8zGhk5fIKWchzU9GP3wL/WW533Fihqp6GwHWaRRzM55ikRQribl9CAB22MBcKcLq0gXoGyO858h1PXNlWbCULOPN4E5Pwz4zEN0T3YW2P+msjyAhETnlLL+jOBFORDCdukHqPvTDt/yOc9x08wbsmKeicvO/7BBjMJdeh1zfC35agn3sbnTLRr9jwaKvYN1q5IIrkTj/exiHg8QnYHr0h/yFsM8/jO7Zlavj6/JF6ORxSOt2SNsOuTp2XiMNmkF6Kqz0p3WY40SqkBWag8FgWjAY7B8MBqsFg8F8wWCw6sH/Tg3VGI7jOH+ShETMLfdC9dreRlSLv0GzMtHpH0LNekj1On5HdPIIEUGuvRWKl8KOeSrqZ3hFjI3rYPsW1585ikjpst7M5tRU7ND70d07wjaWrvkFO+pxKFcJ02NArs7ClfJVMD3vg21bsM8ORtP259rY4aB7d6PzP0VanYYULOx3HCcKSLlKSLvz0LnT0LW53y4npzQtFfv8IyAmajf/yy7T5gzvvLxrB/aRO3y9Ia72gNebuUx55MS2vuXIDVKoKOaWAbBnF3bUY7nWvkS3b8WOeRrKVkSu7hFzN1AiTp1GEJ/g+jQ7zt/kqNAcCAROOeTz04/2kfOYjuM4/yRJSZjbBkKFqt5F3NujYcdWN5vZyXWSkt+bZb9rJ/a1ZyNy851oo0sXArj+zFFGKlTB9BoIO7dhhw0Ky3Jt3bIR++yDkL8gptdAJF9KyMf4L1Kznvc7v3YVduSjUb1sVudOg4wMpH1Hv6M4UUQ6doL8BbHjxkTVa55ai311OPyxDtMtujf/yy6p1QAz4ElIKYB9+j7s/M98yaHffeltONqxE2JiczbzoaRyDaRzT/h5GfruS2EfT7OysC8+AZmZXl/mGL6BEikkKRlq1Xd9mh3nb3I6o3nkIZ+/fJSP8J9VHcfJsyRfireMuUx5r21GhSrgClOOD6RSdeTyLrD4G3Sm254gp3TpQjihAlK8lN9RnGMk1etgegyAP373Ns5LTwvZsXXvbuyzgyErE9P7AaRI8ZAd+1hJoxOR626DHxejrz6D2gO+ZTlempWJzp4CdRsj5Sr6HceJIpJSALmkM/yyHP16jt9xskWtRd8aCQvnIZddj9Rt7HekXCNlymHueRKqeisB7cSxuXqDQO0BdPI4r1VJsza5Nq7fTKvTkLMuRj+bip37SVjH0gmvw6oVXiupMuXDOpbzf9KgBWxaj27e4HcUx4kYOWp6GAwG6x/yeZWcx3Ecxzl2kr8gpu+D2DdHYs64wC0Tc3wjp5+PrvgBff91tHodpEpNvyNFJU1Ph5+XIqed63cU5zhJ/aaYrv2wo5/EvvAopud9OW5voRnp2BEPwdbNmL4PImX9L4yak9pj9+xG33sVChSETjdH1WuQLpgHO7djOt/mdxQnCkmbM9A5n6DvvYY2PhFJzv3VBdmlqui40ejn05HzApgOF/kdKdd518uD0bdeQD96FzZtgOt7IYlJYR9bv5kLG9djevRHTCi3iYp8cklndP0a9O0X0RMqIjXqhnwMXTgPnTEROf18TIvYbksSaaRBM/Qd0CULkPZl/Y7jOBEhbGf5QCDQLhAIuLOc4zi5QgoVIe7We5BaDfyO4uRhIoK5vhcULop98cmI2eU96vy8FLIyXX/mKCfN2iCdb4Vli7AvPZ2jGb9qD3h9J3/9CXPT7UjNeiFMmjPmrIu9GWuzp6KT3/E7TrapKjpjIpQpB/Wa+B3HiUJijLcx4K7t6JTxfsc5KlVF330J/exj5OxLkQuv9juSbyQ+wdv88NLr0O++wD59X1j76QPogQPeubFCFWjcKqxjRSIxcZib7vD28njhUXR7aDfL1c0bsK89C1VqeivrnFwlpU6AMuXQH1z7DMf5U8gKzYFAYE4gEGhz8PO7gXeAdwKBwD2hGsNxHMdxIp3kL4jpdifs2Ip9Y0RU9a6MFLpsISQmQgQVE53jY04+E7n8BlgwD31z5HH9Pqgq+s4Y+H4+ErgxIpddy6XXIye1RyePw86e6nec7Fn1I6z5BWl/QZ6bYeiEjlSrjbQ+HZ0xEd243u84/6Cq6HuvorMmI2dciFzSOapWHYSDiGDOvhTTvT+sW419+A503W9hG0/nz4bNf2A6XpVnzzWSvwCm572QmYF9/hFv5VYIaEY69oXHwcRhbr4rVzfGdf5PGjSHn5egaal+R3GciBDKM319YP7Bz7sCpwGtgO4hHMNxHMdxIp5Uq41cfK1XXPvsY7/jRB1duhBqNkASEv2O4oSA6XARcv4V6Bcz0PGvHHOxWT+ZgM6einS4CHNGZG5YJyLepk+NTkTHjcZ++4Xfkf6TnTkJUgogrd2+3U7OyKXXQUICNviy31EOo6roB2+g0z9E2p2HBG7I80XmQ0nT1pi7HoMDB7CP340uWRDyMTQry5vNXKk6NDox5MePJnJCBcxN/eD3X9EQTUTQcS/CutWYG293e1r4SBo0h6wsWLHY7yiOExFCWWg2gAYCgWqABIPBH4PB4O9A0RCO4TiO4zhRQc68COo3Q4MvoWt/9TtO1NAtG2HTetc2I8ZIx6u8HuYzJqJTgtn+OTv/M3TC60iLtsil14cvYAhIXJy3mqFaHfTloejy7/2OdFS6dRMsnI+cchaSlOx3HCfKSeGiyAWdYMl36OJv/Y7zF500Dv34feSUs5FO3VyR+QikUnXMPU9ByTLY54ZgZ30U0uPrvFmwbTPmwqvd3z8HN5G98Gr0mzno9A9ydCz75Uz0ixnIuQGkQbMQJXSOS426kJwvLDdrHCcahbLQ/AUwAngK+ADgYNF5awjHcBzHcZyoIMZgbugDBQphRz+Bpu33O1JU0GULAZB6rtAcS0QEueImpFU7dOJY7Kf/XczQHxejrz0LtRogXfpExZJrSUzC3HYflCmHHfkIunql35GOSGdPAQFpd57fUZwYIaefB2XKY98dg2Zm+B0H+9G76EfvIG3OQK7u7oqc/0KKlfBmNjdsjr7zIvbtUeiB4++p/yfNzESnvAtVa4G7efwXOfdypFkbb+PopcdXmNR1q9Gxo6B2Q+TCTiFO6BwriU+Auo3RJQtcyzzHIbSF5uuBncAPwKCDX6sNDA/hGI7jOI4TNaRgYUzXO2DLRvTNF9zFZzbo0oVQojSUdjt3xxoxBrm+FzRuiY57ETt/9lEfq+tWY194FEqXxdwyAEmInr6TklIA02cwFCyMfXYQ+sc6vyMdRtP2o5/P8DZrLFbC7zhOjJD4BEynrt7r3YyJvmaxn7yPThyLtGqHdL41Km5S+U2S83nn2g7exqZ2xBB0/74cHVO/mAHbt2IuvMoV+g8hIkiX3lCuMvbFp465t7mm7vf6MqcUwHTth5i4MCV1joXUbwY7tkIY+507TrQI2atuMBjcFgwG7wkGgw8Eg8G9B782JRgMPhOqMRzHcRwn2kjN+kjHTt4yyS9m+B0nomlWJqxYgtRv6t6Uxqi/2kvUboi+Ohz9fv4/HqPbtmCHD4akfJjeDyApBXxImjNSpBim72AQg33mAXR75Czw0y8/hdR9SIT2u3ail9RtAk1aoVOCvj3n7YyJ6PsH2+106eWKcMdATBzm8i5ev/kfF3t9m7duOq5jaWYGOjUI1etCncYhThr9JCkZc+s9EBeHff7hbBf1VRX7+rOwdSOm251IIdelNFJIg+YA6JLvfE7iOP4LWaE5EAgkBQKBhwOBwK+BQGDXwa91CAQCPUM1huM4juNEIzn3MqjTCH3nRXT9Gr/jRK5VKyA91bXNiHGSkOi9wa5UHTv6SfTH/2+eo/v2YocPgvQ0r8hcrKR/QXNISpXF9BkE+/d6xeZ9e/yOhFqLzpoE1WojVWv5HceJQebyG0AVfe/VXB/bzp6CBl+GpichN97uiszHybTtgOk9CHZuwz5yB7pqxTEfQ+dOg53bMRe53sxHIyVKY7r3hy1/YF96GrX/3a5EZ02GBfOQSzojNevlQkonu6RIMahYzRWaHYfQts4YBtQHrgb+XBu8DOgRwjEcx3EcJ+qIicPceDsk5fP6Naen+R0pIunShRAXD7Ub+B3FCTNJTsH0fgBKneDN5lr9M5qZgR35MGz+A3PLPUj5yn7HzDGpWA3T8z7YshH77INoWqq/gX74FrZsRNq72cxOeEjJMshZl6Dffo7+vDTXxrVzP0HfHg2NW2K63oHEuSJzTkidRpj+T0JyPuxT92K/mZvtn9X0dHTqeK+/fi33ev5vpFZ95Iqu3kaaE9/+18fqqhXeDZzGLZEOF+dSQudYSMPmsOondO9uv6M4jq9CWWi+GLgqGAx+BViAYDC4HigXwjEcx3EcJypJ4aKYm/rBxnXYV54JyUY7sUaXLoTqdZDkFL+jOLlA8hf02ksUKoIdPhg78lH4eRnSpTdSu6Hf8UJGajXwerWvXsm2vp2xfrYVmDkJipVAmrb2ZXwnb5CzL4ViJbHjXsyV1zr7xQz0zZHQoDmm211IfHzYx8wL5ITymAFPQZUa6JinsJPfydZeEzpnKuzeiel4VS6kjH5y2jlI2w7o1PHYbz8/4mN0z27s6CegaAlMl95ulniEkvrNQC26bJHfURzHV6EsNGcAh72qBwKBksC2EI7hOI7jOFFL6jZGLr8BFs5D3xyBWut3pIihO7fButWI25k+T5EixTF9H4T4BFi6ALnsekzLU/2OFXLStDWm572Y4qXQD9/C9r+RA8MewH4zF83MyJUM+vtq+GkJcvr5branE1aSlIQJ3ADrfvNaKISR/Wo2+sYIqNsE06N/VG0cGg2kYCFM3yFI69PRSW+jLw3913OWpqWin0yAuo1da4dsEhHkqpuheh30teHo2l8P+77aA9iXnoY9uzDd+0flvgV5RpUaUKAQuPYZTh4XykLzeOD1QCBQBSAQCJwAjADeCeEYjuM4jhPVzJkXIudfiX45Cx3/SrZmB+UFuux7AFdozoOkZBnMXY8i3e6M6eXA0rAFxR56HvPwaOS8AGxc580SvOM67FsjvfYhYTwf6MxJkJiEnNwhbGM4zl+anuRt+vnhW+ie8Cwjt9/MRV8dDrUaYG69B0lIDMs4eZ0kJHgrTS6+Fv1mDvbp+9DdO4/4WJ091SuIutnMx0TiEzA9+kP+Ql47qT27/vqeThkPyxchnboilar5mNL5L2LikPrN0GULs9Vz23FiVSgLzfcAvwFLgCLASmADMDiEYziO4zhO1JOOnZD2F6AzJ6GT3f1YAJYthMLFoFxlv5M4PpBSJ2BatM0Ty4Gl1AmYC6/GPDoGc/sQpGEL9KtPsY/cgX2gJ3baBHTXjpCOqbt3oN/MQdq0R/K72XBO+IkI5spukLYf/fCtkB9fF3yJvjwUatTB9LwPSUwK+RjO/4kI5tzLMd3vhrW/epsEblh72GM0dT86bQI0aI5Uq+1T0uglhYpibhkAe3ZhRz2GZmWhy79HJ49DWrVD2p7ld0QnOxo0g7174Nef/U7iOL4JWQOrYDCYAfQB+hxsmbEVaAiMBS4/3uMGAoEngQvwWnOsAroEg8Ej30J1HMdxnCggIhC4EVL3o5PHYVNSMGdc6Hcs36g9gC5bhDRpmScKjY4DIMZAnUZInUZop5vR775A581C33sNnfAG1GuKaXMGNGqBxOesHYB+9jFkZSGnXxCi9I7z36RcRaTdeeinH6GnnoVUDM1sTP1+PnbMU1ClJua2+5Gk5JAc1/lv0qwNplgp7PMPYR+7C3Pz3Ui9JgDorMmwbw+mYyefU0YvqVwD6dwTfXmo10Zj+fdwQgXkmh7u+ihKSL2mqDHokgVI9Tp+x3EcX+S40BwIBFKAAUBjvFnMg4CCwGjgTOCNHA4xAxgQDAazAoHA4wfHujuHx3Qcx3EcX4kx0Lmn18/w3ZexySmYk8/0O5Y/Vq+E/XuhXjO/kziOLyQlP3LKWXDKWejGdV7B+avZ2FGPQYGCyImnIm3aQ4Wqx1xs0MwMr9DcsAVSxu3R7eQu6dgJ/WYudtyLmLsey3GxTJd8hx31v/buPFqq6s7b+LOLCwgIIqASRASVgIADahs6SRttTdTEmGjMjnackqhJa2wVNaYdcB5ijEM0k9G29e0ky53uDCavb+L0mph+X42KAyCaOOAATogzIMPZ/UddDTHIBercOnXvfT5r1eJWnVP7fM9etfY9/O6ufS6EUZtTO+YMbx5bgTBmLLV/vYjiirMpvn0m4YAjCDvuRL75F7DNjoTRY6uO2KXVpuxM8cwT5N/+HPquU1+X2T+mdBlhwLqw+XjyjLthnwOrjiNVoowZzd8BJgO/BfYEtgLGA9cCR6SUGrqtdkrpphWe3gns10h7kiS1itCrF7XDjqe4YhH5uu+Q+/UnbP+hqmM1XZ41HUKNMGGbqqNIlQvDRxL2PYT86QPhofvr67n//jfk234NI0fXl7/4wM6EgeutVnv5j3fU10zdbe9OTi79rdB/3fravtddQb7rdsKUXda6rTzrPorvng8jR1M79gxCP4vMVQlDN6B20gUUV15E/tH363/MWvimazOXJOx7MBAI47civG9k1XG0hsJWO5B/dh355ZcI6w+tOo7UdKHRm47EGOcB26aUXogxjgSeAnZOKf2+jIDvOtavgOtTSitd6CvGeARwBEBKafslS5pzF29J6s7a2tpYtmxZ1TG6tbx4ES+feRxLH32IwSdfSN/JU6qO1FQLTjocQmDIBVdWHUXqVGs7nhavv8biP9zMottuZNmjs6FXL/ru8CHW+cdP0He7vye0rXzuSM6ZBVMPgZwZcsl1fvValchFwYKTDqd46UWGfucn1PoNWOM2ljx4Dy+fewJtIzZl/bMupzZwUCck1ZrKy5fzxrVXsPBX19N3ys4MPum8ph3b61O1qqVPPsaCYw9i4JFfp/9H/SOvWl+fPn0ASrtILKPQ/FpKadB7PV/NNm4Bhq9k0ykppV+273MKsAOwb0ppdULnefPmrUkMSdJKDBs2jPnzG/pyilZDXvgGxUWnwPNzqR17FmHshKojNUV+4zWKqQcRPnkAtU/uX3UcqVOVMZ7muU++s7QGr78KA9cjTNmZ8MFdCSNH//W+Dz9I8a1TCYcc3XOX5lFLyI8/QnH+iYTd96W236Fr9t4/zaS47EzYYDi1488lWGRuOfmRmbDJaEL/5t1s1OtTtaqcM8XXvwSjtqDXUSdXHUfq0IgRI6DEQnMZS2e0xRh3YYVQ736eUrptVQ2klHZb1fYY4yHAXsCuq1lkliSpSwn916V27JkUF/4rxeVn1f8zvWk5N05qZfmh+yHnd24mJGnVwsabEj77RfI+B8Os6RT/fUv9Zms3/xI23aK+tMaOOxEGDKS45YZ6IfoDH6k6tnq4sNk4wgd3Jd9yA/nDuxGGr95yAPnRhyi+fRYM2YDa1LMsMreoMG5S1RGklhFCqC+fceft5KVLCb0bu6Gv1NXUSmjjBeDfgKvbHy+96/lVjTQeY9yD+s3/9k4pLWwsqiRJrSsMGkxt6lnQbwDFpaeTn32m6kidb+Z0GDAQRm9RdRKpSwltbYRtdqTXkSdT++a/Ez53GCxfTv7xDyhOOITl3zkPHryb8JE9Cb37VB1XInzmYOjTh+L6q1idb9Xmxx+pz2Rebwi1488hDFq/CSklqXFhqx3grcXw55lVR5GaruEZzSml0SXkWJUrgL7AzTFGgDtTSl/p5GNKklSJMGQDalPPprjw6xQXn0btpAsIwzaqOlanyEVBnjWdMGFbQq1X1XGkLisMXI+w296w297kpx6vL61x1+3Quw9h5z2rjicBEAatT/jkAeR0NTx4N2yz43vum598lOLSM2DgevUi8+AhzQsqSY0avzW09SbPuJcwwW/tqWcpY+mMTpVScoqTJKlHCRuNoHbcmRTfPJnikmnUvnYBYb1uOJPrmTnw2iswabuqk0jdRhi1GWHUZuT9DoWFbxIGDa46kvSOsMsnyHfcRHH9VdQmbLvS2fb5qccpLp4G/QfUl5EaMqyCpJK09kLfdWD8VuQH74HPHVZ1HKmpylg6Q5IklSyMHEPtX06HV1+muGQa+c3Xq45UujxrOoAzPaROENp6W2RWywltbdT2PwxefI580y/+Znue+yTFJafBOuvUZzIP3aCClJLUuPB3/0DYbBx56ZKqo0hNZaFZkqQWFTYfT+3Ik+H5uRSXnUlevKjqSKXKM6fDJmP8SrQk9SBhwmSYPIV840/JC1585/X87NMU3zoV2nrXi8wbDK8wpSQ1pvbBXal96Tjvk6Aex0KzJEktLEzYltoRX4MnH6X47nndZlZEXrQQHptNcNkMSepxavFLkDP5P/8dgPzc3HqRuVarF5k3HFFtQEmStFYsNEuS1OLC5CmEQ4+B2Q9QXPlN8rJlVUdq3MMPwvLlhInbV51EktRkYdhGhD32Jd99B8Ufbq4XmYuC2tSzCcNHVh1PkiStJQvNkiR1AbW/34VwwBFw/13ka79NLoqqIzUkz5wO6/SDzcdVHUWSVIGw+2dgyAbkay+HZUvqReYRo6qOJUmSGmChWZKkLqL2j3sRPn0g+c7byT+5kpxz1ZHWSs65fiPA8dsQ2npXHUeSVIHQty+1A4+EjTeldtxZhJGjq44kSZIa1FZ1AEmStPrCxz8Li94k//bn0H8AYZ+Dqo605p6bCy+9QNhzv6qTSJIqFLbanl5buYSSJEndhYVmSZK6kBACfOZQWPgm+cafUvTrT22Pz1Qda43kWfcCECZOrjiJJEmSJKksFpolSepiQghw4D/D4kXk/7qWot8Aah/Zo+pYqy3PnA7DRxKGbVR1FEmSJElSSSw0S5LUBYVaL/jiceTFi8g/+h7FOv2ofeAjVcfqUF7yFvxpFqELFcYlSZIkSR3FWMpMAAAOA0lEQVTzZoCSJHVRoa2N2ldOgrETyddcSn7g7qojdexPs2DpEsLE7apOIkmSJEkqkYVmSZK6sNCnL7Wvngojx1B8/wLyIzOqjrRKedZ06N0H3j+x6iiSJEmSpBJZaJYkqYsL/fpTO+YM2GA4xeXnkJ/4c9WR3lOeOR3GTSL06Vt1FEmSJElSiSw0S5LUDYSBg6hNPQsGDqK47Azy3CerjvQ38vzn4blnXDZDkiRJkrohC82SJHUTYfBQalPPhrbeFJecTn7h2aoj/ZU86z4AwiQLzZIkSZLU3VholiSpGwkbDKd23FmwbCnFxaeRX36p6kjvyDOnw9ANYaONq44iSZIkSSqZhWZJkrqZsPGo+prNb75Occk08uuvVR2JvGwpPPwAYdJ2hBCqjiNJkiRJKpmFZkmSuqEwZiy1r54G85+nuPhU8gvzqg302COweJHLZkiSJElSN2WhWZKkbiqMm0TtqFNgwXyKs4+juPsPlWXJs+6FXr1g/NaVZZAkSZIkdR4LzZIkdWNh4mRq0y6FEaPIV15I8R/fJS9d0vQceeZ02GICYZ3+TT+2JEmSJKnzWWiWJKmbC0M3pHbi+YTd9yH/7jcU551Ifm5u046fX1kATz9BmDi5aceUJEmSJDWXhWZJknqA0NZGbb8vUDv6NHhlPsU5Uynu+l1Tjp0fuq+eYaLrM0uSJElSd9VlCs0xxhNijDnGOKzqLJIkdVVh67+jdtplsMkY8lXforjuCvJbb3XuQWdOh/XWh03GdO5xJEmSJEmV6RKF5hjjJsBHgaeqziJJUlcXhgyjdsK5hD33I99xE8X5J5CffbpTjpWL5eSH7idMmEwIoVOOIUmSJEmqXpcoNAOXAF8DctVBJEnqDkKvXtT2PZjaMWfAa6/Ul9L4f7eVf6A5j8Kbr8Mkl82QJEmSpO6sreoAHYkx7g3MTSk9EGPsaN8jgCMAUkoMG+YqG5LUqLa2NsfT7mznj7F868m8evEZLL3mUno/+ScGHX48YZ1+pTT/xq2/5M0QGPbhXakNWq+UNqWuyvFUksrheCpJraklCs0xxluA4SvZdApwMvCx1WknpXQlcGX70zx//vxyAkpSDzZs2DAcT7u7QD56GuHX17P4f1/P4tkzqH35JMLGoxpuefkf/wCjx7JgyVLwc6QezvFUksrheCpJ5RgxYkSp7YWcW3c1ihjjVsCtwML2l0YC84AdU0rPdfD2PG/evM6MJ0k9ghfyPUue/QDFVd+CxQsJB3yZ8KHd1npt5fzGaxRTDybsFant/U8lJ5W6HsdTSSqH46kklaO90FzazXRaYkbze0kpzQA2fPt5jHEOsENKyd8okiR1grDlNtSmXUZx9cXkay+Hhx+EA49cq6U08uwHIBeEia7PLEmSJEndXVe5GaAkSWqSsN761I49g/CpfyL/8Q6Kc6aSn3lizRuaOR36rwtjxpYfUpIkSZLUUlp6RvO7pZRGV51BkqSeINR6Efbanzx2EsUPL6I49wTCAYcT/mH31VpKI+dMnjWdMHEyodarCYklSZIkSVVyRrMkSXpPYdwkatMuhfdPIv+v75J/eBF50cKO3/jMHHj1ZXDZDEmSJEnqESw0S5KkVQqDBlM75nTCPgeR7/1vinOOIz/12Crfk2dOr7934uRmRJQkSZIkVcxCsyRJ6lCo1ah9/LPUTjgPliyhOP9Eiv97Iznnle6fZ02HkWMIg4c0OakkSZIkqQoWmiVJ0moLYydQm3YZbLkt+cffp/jBN8gL3/yrffLihfDobMIkl82QJEmSpJ7CQrMkSVojYeAgal89lbDfF+D+uyjOPpY8589/2eHhGbB8mYVmSZIkSepBLDRLkqQ1Fmo1arvvQ+3E86EoKC44ieKWG8g515fN6NsPNh9fdUxJkiRJUpO0VR1AkiR1XWHz8dSmXUpxzWXk668iPzITnnoMttya0Na76niSJEmSpCZxRrMkSWpIGDCQ2lGnED73JZhxDyx4kTDRZTMkSZIkqSdxRrMkSWpYCIGw26fIm08g334jYYcPVR1JkiRJktREFpolSVJpwpixhDHHVB1DkiRJktRkLp0hSZIkSZIkSWqIhWZJkiRJkiRJUkMsNEuSJEmSJEmSGmKhWZIkSZIkSZLUEAvNkiRJkiRJkqSGhJxz1Rk6S7c9MUmSJEmSJEkqQSiroW47oznGOJ96R/ko6RFj/GHVGbrbwz61T7vCw/G0U/rUz6l92vIP+7RT+tTxtPw+9XNqn7b8wz7tlD51PC2/T/2c2qct/7BPO6VP51OibltoBl6pOkA39KuqA3RD9mn57NPyOZ6Wz89p+ezT8tmn5XM8LZ+f0/LZp+WzT8vneFo+P6fls0/LZ5+Wr9TxtNsunRFjvCeltEPVOSSpq3M8laRyOJ5KUjkcTyWpHGWPp915RvOVVQeQpG7C8VSSyuF4KknlcDyVpHKUOp522xnNkiRJkiRJkqTm6M4zmiVJkiRJkiRJTWChWZIkSZIkSZLUkLaqA6yuGOMmwHXAcKAArkwpXRZjHAJcD4wG5gAxpfRyjHE8cA2wHXBKSumiFdqaA7wOLAeWeRMBST1JyePpYOAqYBKQgS+mlP5/E09HkipT1ngaYxzXvv/bNgOmpZQubda5SFKVSr4+PQ44jPq16QzgCymlxU08HUmqTMnj6THA4UAAfrg616ZdaUbzMuD4lNKWwBTgqBjjBODrwK0ppbHAre3PARYA/wJctLLGgF1SSttaZJbUA5U5nl4G/CalNB7YBpjd2eElqYWUMp6mlB5pvy7dFtgeWAj8vEnnIEmtoJTxNMa4cfvrO6SUJgG9gP2bcwqS1BLKGk8nUS8y70j9//p7xRjHdnTwLlNoTik9m1Ka3v7z69SLGRsDnwKubd/tWuDT7fu8kFK6G1haQVxJallljacxxkHATsDV7fstSSm90pSTkKQW0EnXp7sCj6WUnuy04JLUYkoeT9uAfjHGNqA/MK+T40tSyyhxPN0SuDOltDCltAz4HbBPR8fvMoXmFcUYRwOTgbuAjVJKz0K9M4ENV6OJDNwUY7w3xnhEpwWVpBbX4Hi6GfAicE2M8b4Y41UxxgGdmVeSWlUJ16dv2x/4SekBJamLaGQ8TSnNpT4r7yngWeDVlNJNnRpYklpUg9enM4GdYoxDY4z9gY8Dm3R0zC5XaI4xrgv8F3BsSum1tWzmQyml7YA9qU8h36m0gJLURZQwnrZRX8fpeymlycCb/OXrN5LUY5R0fUqMsQ+wN/DTsrJJUlfS6HgaY1yf+qy9McAIYECM8cByU0pS62t0PE0pzQa+AdwM/AZ4gPqyHKvUpQrNMcbe1DvpRymln7W//HyM8X3t298HvNBROymlee3/vkB9/bsdOyexJLWmksbTZ4BnUkp3tT//T+qFZ0nqMcq6Pm23JzA9pfR8+UklqbWVNJ7uBjyRUnoxpbQU+Bnwwc7KLEmtqMT66dUppe1SSjtRX8v5zx29p8sUmmOMgfo6oLNTShevsOkG4JD2nw8BftlBOwNijAPf/hn4GPXp4JLUI5Q1nqaUngOejjGOa39pV+ChkuNKUssqazxdwQG4bIakHqjE8fQpYEqMsX97m7vizaol9SBlXp/GGDds/3cUsC+rcZ0acs5rmrkSMcYPA3cAM4Ci/eWTqa8zkoBR1H+pfDaltCDGOBy4BxjUvv8bwARgGH+5i3cb8OOU0rnNOg9JqlpZ42lK6bUY47bAVUAf4HHgCymll5t5PpJUlZLH0/7A08BmKaVXm3smklStksfTM4HPUf+K933AYSmlt5p5PpJUlZLH0zuAodRvFDg1pXRrR8fvMoVmSZIkSZIkSVJr6jJLZ0iSJEmSJEmSWpOFZkmSJEmSJElSQyw0S5IkSZIkSZIaYqFZkiRJkiRJktQQC82SJEmSJEmSpIZYaJYkSZKaJMY4K8a481q+N8cYtyg5kiRJklSKtqoDSJIkST1FSmli1RkkSZKkzuCMZkmSJKmTxRid4CFJkqRuzQteSZIkaRVijHOAHwAHAe8DfgH8c0ppcYxxL+AcYDTwEPCVlNKDK7zve8DngXExxgHAo8BhKaVbYox9gW8Asf1QCTgppfRW+/tPBKYCGTi1889UkiRJWnvOaJYkSZI69nlgd2Bz4P3AqTHG7YB/A74MDKVejL6hvYD8tgOATwCDU0rL3tXmKcAUYFtgG2BH2gvKMcY9gBOAjwJjgd0657QkSZKkcjijWZIkSerYFSmlpwFijOcCl9NeXE4p3dW+z7UxxpOpF49/1/7at99+30p8Hjg6pfRCe7tnUi9Wn0Z9lvM1KaWZ7dvOoF60liRJklqShWZJkiSpYysWi58ERgCbAofEGI9eYVuf9m0re9+7jWhv693tvr3t3ndtkyRJklqWhWZJkiSpY5us8PMoYB71IvK5KaVzV/G+vIpt86gXq2e9q12AZ1dyTEmSJKllWWiWJEmSOnZUjPHXwELgZOB64GfAz2OMtwB/BPoDOwO/Tym9vhpt/oT6Ws93Uy9ITwP+o31bAq6JMV4HzAFOL+9UJEmSpPJ5M0BJkiSpYz8GbgIeb3+ck1K6BzgcuAJ4GXgUOHQN2jwHuAd4EJgBTG9/jZTS/wEuBW5rb/e2Mk5CkiRJ6iwh51V9m0+SJEnq2WKMc4DDUkq3VJ1FkiRJalXOaJYkSZIkSZIkNcRCsyRJkiRJkiSpIS6dIUmSJEmSJElqiDOaJUmSJEmSJEkNsdAsSZIkSZIkSWqIhWZJkiRJkiRJUkMsNEuSJEmSJEmSGmKhWZIkSZIkSZLUkP8BOKYCgCDn/eYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make a copy of the renewable generation data frame, changing the index to a datetime to make a timeseries\n",
    "ren_gen_datetime_index = renewable_generation.copy()\n",
    "ren_gen_datetime_index.index = pd.to_datetime(ren_gen_datetime_index.index)\n",
    "\n",
    "# Decompose the time series data into three components\n",
    "rcParams['figure.figsize'] = 20, 10\n",
    "decomposition = sm.tsa.seasonal_decompose(ren_gen_datetime_index['total']/1000, model='additive')\n",
    "fig = decomposition.plot()\n",
    "plt.savefig(\"Renewable time series decomposition\")\n",
    "plt.show()"
   ]
  },
  {
   "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": 2
}