{ "cells": [ { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "import pandas as pd, numpy as np\n", "from scipy import stats\n", "import random" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "stations=pd.read_csv('data/stations.csv').set_index('ID')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Setup plot params" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from matplotlib.collections import PolyCollection\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import matplotlib as mpl\n", "import matplotlib.font_manager as font_manager\n", "path = 'KulimPark-Regular.ttf'\n", "path2 = 'Symbola.ttf'\n", "prop = font_manager.FontProperties(fname=path)\n", "prop2 = font_manager.FontProperties(fname=path2)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "color_ax='#E7CFBC'\n", "color_bg='#FFF4EC'\n", "color_obs_right0='#F2B880'\n", "color_obs_left0=color_ax\n", "color_pred_right0='#C98686'\n", "color_pred_left0='#966B9D'\n", "color_pred_talalt0='#59c687'\n", "color_pred_nem_talalt0='#c95498'\n", "font_size=12\n", "s=40\n", "obs_talalt_glyph0='★'\n", "obs_nem_talalt_glyph0='☆'\n", "pred_talalt_glyph0='✔️'\n", "pred_nem_talalt_glyph0='✖️'\n", "title_icon_right={'Temp':'☼','Wind':'🌀','Hail':'⭕️','Snow':'☃️','Snow Depth':'⛄️','Rain':'☔️','Visib':'☀️'}\n", "title_icon_left={'Temp':'✨️','Wind':'☘','Hail':'⚪️','Snow':'⚪️','Snow Depth':'⚪️','Rain':'🌂','Visib':'⛈️'}\n", "title_icon={'Temp':'♨️','Rain':'☂️','Hail':'✴️','Snow':'❄️','Snow Depth':'⛷️','Wind':'⛵️','Cloud':'☁️','Visib':'⛅️'}" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def get_data(data,th):\n", " a1=pd.DataFrame(data[data<=th])\n", " a1['g']='left'\n", " a2=pd.DataFrame(data[data>th])\n", " a2['g']='right'\n", " a3=pd.concat([a1,a2])\n", " a3['x']='x'\n", " return a1,a2,a3" ] }, { "cell_type": "code", "execution_count": 184, "metadata": {}, "outputs": [], "source": [ "def violin_plot(data,th,ax,color_left,color_right):\n", " a=0.3\n", " a1,a2,a3=get_data(data,th)\n", " a1_augment=True\n", " a2_augment=True\n", " if len(a1)==0:\n", " a1=a3.loc[[a3.index[0]]]\n", " a1['g']='left'\n", " a1[a1.columns[0]]=5\n", " if len(a2)==0:\n", " a2=a3.loc[[a3.index[0]]]\n", " a2['g']='right'\n", " a2[a2.columns[0]]=5\n", " if len(a1)>1: a1_augment=False\n", " if not a1_augment:\n", " if a1.nunique()[a1.columns[0]]==1: \n", " a1_augment=True\n", " if a1_augment:\n", " a11=a1.copy().loc[[a1.index[0]]]\n", " a11[a11.columns[0]]+=random.random()*0.1*th\n", " a11['x']='x'\n", " a12=a1.copy().loc[[a1.index[0]]]\n", " a12[a12.columns[0]]-=random.random()*0.1*th\n", " a12['x']='x'\n", " a3=pd.concat([a3,a11,a12])\n", " if len(a2)>1: a2_augment=False\n", " if not a2_augment:\n", " if a2.nunique()[a2.columns[0]]==1: \n", " a2_augment=True\n", " if a2_augment:\n", " a21=a2.copy().loc[[a2.index[0]]]\n", " a21[a21.columns[0]]+=random.random()*0.1*th\n", " a21['x']='x'\n", " a22=a2.copy().loc[[a2.index[0]]]\n", " a22[a22.columns[0]]-=random.random()*0.1*th\n", " a22['x']='x'\n", " a3=pd.concat([a3,a21,a22])\n", " a3=a3.sort_values('g')\n", " ax.axvline(0,color=color_ax)\n", " if a3.nunique()['g']>1:\n", " sns.violinplot(y=a1.columns[0], x='x',hue='g', data=a3, split=True, ax=ax,\n", " inner=None,linewidth=1, scale=\"count\", saturation=1)\n", "\n", " ax.get_children()[0].set_color(mpl.colors.colorConverter.to_rgba(color_left, alpha=a))\n", " ax.get_children()[0].set_edgecolor(color_left)\n", " ax.get_children()[1].set_color(mpl.colors.colorConverter.to_rgba(color_right, alpha=a))\n", " ax.get_children()[1].set_edgecolor(color_right)\n", " ax.legend().remove()\n", " else:\n", " if len(a1)>0: \n", " w=a1\n", " c=color_left\n", " else: \n", " w=a2\n", " c=color_right\n", " sns.violinplot(y=w.columns[0], data=w, ax=ax, \n", " inner=None,linewidth=1, scale=\"count\", saturation=1)\n", " ax.set_xlim([-1,0])\n", " ax.get_children()[0].set_color(mpl.colors.colorConverter.to_rgba(c, alpha=a))\n", " ax.get_children()[0].set_edgecolor(c)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def setup_axes():\n", " fig,axes=plt.subplots(1,3,figsize=(8,5),gridspec_kw={'width_ratios': [1, 3, 1]})\n", " axi_top= axes[2].inset_axes([0.1, 0.65, 1, 0.3])\n", " axi_top.axis('off')\n", " axi_bottom= axes[2].inset_axes([0.1, 0, 1, 0.5])\n", " axi_bottom.axis('off')\n", " axes[0].axis('off')\n", " axes[1].axis('off')\n", " axes[2].axis('off')\n", " axes[0]=axes[0].inset_axes([0, 0.15, 1, 0.85])\n", " axes[1]=axes[1].inset_axes([0, 0.15, 1, 0.85])\n", " axes[0].axis('off')\n", " axes[1].axis('off')\n", " return fig, axes, axi_top, axi_bottom" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def stem_plot(data,ax,color,s=s):\n", " data=pd.DataFrame(data)\n", " x=data.index\n", " y=data[data.columns[0]].values\n", " for i,e in enumerate(y):\n", " ax.plot([0,e],[x[i],x[i]],color=color)\n", " ax.scatter(y,x,s,color=color,zorder=10)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def stem2_plot(data,th,ax,color_left,color_right,s=s,axv_color=None):\n", " if axv_color==None:axv_color=color_right\n", " a1,a2,a3=get_data(data,th)\n", " stem_plot(a1,ax,color_left,s)\n", " stem_plot(a2,ax,color_right,s)\n", " ax.axvline(0,color=color_ax)\n", " #if th!=0:\n", " if True:\n", " ax.axvline(th,color=axv_color,ls='--',zorder=5)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th):\n", " ylim=axes[0].get_ylim()\n", " xlim=axes[1].get_xlim()\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*1.05\n", " y_max_coord2=ylim[0]+(ylim[1]-ylim[0])*1.05 #1.04\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n", " axes[0].text(observation_th, y_max_coord, title_icon[kondicio], \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th, y_max_coord, title_icon[mennyiseg], \n", " horizontalalignment='center', color=color_ax, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord2, title_icon_right[mennyiseg], \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop2, fontsize=font_size*1.5)\n", " axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord2, title_icon_left[mennyiseg], \n", " horizontalalignment='center', color=color_pred_left, fontproperties=prop2, fontsize=font_size*1.5)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n", " observation_th,prediction_th):\n", " ylim=axes[0].get_ylim()\n", " xlim=axes[0].get_xlim()\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.07)\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n", " x_icon_coord_shift2=(xlim[1]-xlim[0])*0.27\n", " axes[0].text(observation_th+x_icon_coord_shift, y_max_coord, obs_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n", " axes[0].text(observation_th-x_icon_coord_shift, y_max_coord, obs_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n", " axes[0].text(observation_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n", " axes[0].text(observation_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_bad, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n", " axes[0].text(observation_th, y_max_coord, '|', \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop,fontsize=19)\n", "\n", " xlim=axes[1].get_xlim()\n", " x_icon_coord_shift=(xlim[1]-xlim[0])*0.04\n", " x_icon_coord_shift2=(xlim[1]-xlim[0])*0.1\n", " axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord, pred_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n", " axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord, pred_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n", " axes[1].text(prediction_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_talalt, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n", " axes[1].text(prediction_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_nem_talalt, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n", " axes[1].text(prediction_th, y_max_coord, '|', \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop,fontsize=19)\n", " \n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.14)\n", " axes[0].text(observation_th, y_max_coord, 'feltétel', \n", " horizontalalignment='center', color=color_obs_right0, fontproperties=prop)\n", " axes[1].text(prediction_th, y_max_coord, 'jóslat', \n", " horizontalalignment='center', color=color_pred_right, fontproperties=prop)\n", " y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.13)\n", " x_coord_shift=prediction_th+(prediction_th-xlim[0])*(-0.4)\n", " axes[1].annotate('', xy=(x_coord_shift, y_max_coord),xycoords='data',annotation_clip=False,\n", " xytext=(xlim[0], y_max_coord),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt):\n", " y_icon_obs=0.65\n", " y_icon_pred=0.5\n", " if color_obs_right==color_obs_right0: x=0.72\n", " else: x=0.47\n", " axes[2].text(0.72, y_icon_obs, obs_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n", " axes[2].text(0.9, y_icon_obs,n_prediction_ts_good, \n", " horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n", " axes[2].text(0.47, y_icon_obs, obs_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n", " axes[2].text(0.29, y_icon_obs, n_prediction_ts_bad, \n", " horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n", " \n", " axes[2].text(0.72, y_icon_pred, pred_talalt_glyph,\n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n", " axes[2].text(0.9, y_icon_pred, n_prediction_ts_good_talalt, \n", " horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n", " axes[2].text(0.47, y_icon_pred, pred_nem_talalt_glyph, \n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n", " axes[2].text(0.29, y_icon_pred, n_prediction_ts_good_nem_talalt,\n", " horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n", " \n", " axes[2].annotate('', xy=(0.59, y_icon_pred*1.04),xycoords='data',\n", " xytext=(x, y_icon_obs*0.98),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def talalat_plot(axes,ns,observation_th,prediction_th):\n", " n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt=ns\n", " talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n", " observation_th,prediction_th)\n", " talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,\n", " n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "def year_plot(data,ax,k):\n", " y=data.values\n", " x=data.index\n", " ex=max(y)-min(y)\n", " text_off=abs(ex*k)\n", " text_align='left'\n", " if y[0]<0:\n", " text_off=-text_off\n", " text_align='right'\n", " ax.text(y[0]+text_off, x[0], str(int(x[0])), \n", " horizontalalignment=text_align, verticalalignment='center', \n", " color=color_ax, fontproperties=prop)\n", " text_off=abs(text_off)\n", " text_align='left'\n", " if y[-1]<0:\n", " text_off=-text_off\n", " text_align='right'\n", " ax.text(y[-1]+text_off, x[-1], str(int(x[-1])), \n", " horizontalalignment=text_align, verticalalignment='center', \n", " color=color_ax, fontproperties=prop)" ] }, { "cell_type": "code", "execution_count": 277, "metadata": {}, "outputs": [], "source": [ "def spine_plot(datum,title,mondas,jelentes,kondicio,mennyiseg,\n", " observation_ts,observation_th,prediction_ts,prediction_th,c):\n", " \n", " #data\n", " prediction_ts_good=prediction_ts.loc[observation_ts[observation_ts>observation_th].index]\n", " prediction_ts_bad=prediction_ts.loc[observation_ts[observation_ts<=observation_th].index]\n", " n_prediction_ts_good=len(prediction_ts_good)\n", " n_prediction_ts_bad=len(prediction_ts_bad)\n", " \n", " if color_obs_right0!=color_obs_right:\n", " prediction_ts_good,prediction_ts_bad=prediction_ts_bad,prediction_ts_good\n", " prediction_ts_good_nem_talalt,prediction_ts_good_talalt,\\\n", " prediction_ts_good_joined=get_data(prediction_ts_good,prediction_th)\n", " n_prediction_ts_good_talalt=len(prediction_ts_good_talalt)\n", " n_prediction_ts_good_nem_talalt=len(prediction_ts_good_nem_talalt)\n", " ns=[n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt]\n", " \n", " #plots\n", " fig, axes, axi_top, axi_bottom=setup_axes()\n", " \n", " stem2_plot(observation_ts,observation_th,axes[0],color_obs_left,color_obs_right,s/2,color_obs_right0)\n", " stem2_plot(prediction_ts_good,prediction_th,axes[1],color_pred_left,color_pred_right)\n", " stem_plot(prediction_ts_bad,axes[1],color_ax)\n", " \n", " violin_plot(observation_ts,observation_th,axi_top,color_obs_left,color_obs_right)\n", " violin_plot(prediction_ts_good,prediction_th,axi_bottom,color_pred_left,color_pred_right)\n", " \n", " #icons\n", " icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th)\n", " \n", " #talalat\n", " talalat_plot(axes,ns,observation_th,prediction_th)\n", " \n", " #years\n", " obs_year_index=observation_data[[obs_key,'pyear']].dropna().groupby('pyear').mean().index\n", " pred_year_index=prediction_data[[pred_key,'pyear']].dropna().groupby('pyear').mean().index\n", " pred_year_index_filt=prediction_ts.loc[pred_year_index].dropna().index\n", " obs_year_index_filt=observation_ts.loc[obs_year_index].dropna().index\n", " pred_year_index2=max(min(pred_year_index_filt),min(obs_year_index_filt))\n", " pred_year_index=range(pred_year_index2,max(pred_year_index_filt)+1)\n", " year_plot(observation_ts.loc[obs_year_index].dropna(),axes[0],0.09)\n", " year_plot(prediction_ts.loc[pred_year_index].dropna(),axes[1],0.03)\n", " \n", " #titles\n", " len_ratio=0.15*(-1+(len(jelentes.split(',')[0])/len(jelentes.split(',')[1])))\n", " fig.text(0.5+len_ratio,0.04,jelentes.split(',')[0]+',',color=color_obs_right0,\n", " fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='right')\n", " if color_pred_talalt==color_pred_talalt0: color_pred_side=color_pred_right\n", " else: color_pred_side=color_pred_left\n", " fig.text(0.5+len_ratio,0.04,jelentes.split(',')[1],color=color_pred_side,\n", " fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='left')\n", " if n_prediction_ts_good_nem_talalt>=n_prediction_ts_good_talalt:\n", " color_title=color_pred_nem_talalt\n", " else: \n", " color_title=color_pred_talalt\n", " verdict=int(100*n_prediction_ts_good_talalt/(n_prediction_ts_good_talalt+n_prediction_ts_good_nem_talalt))\n", " if color_pred_talalt!=color_pred_talalt0: verdict=100-verdict\n", " return_verdict=int(verdict)\n", " verdict=str(verdict)+'%'\n", " plt.suptitle(title,y=0.11,color=color_title,fontproperties=prop,fontsize=font_size)\n", " fig.text(0.97,0.04,verdict, fontproperties=prop,\n", " horizontalalignment='right', color=color_title, fontsize=font_size*2, )\n", " fig.text(0.03,0.04, datum, fontproperties=prop,\n", " horizontalalignment='left', color=color_obs_right0, fontsize=font_size*2, )\n", " \n", " plt.savefig(c+'/'+str(mondas)+'.png',dpi=300, facecolor=color_bg)\n", " plt.show()\n", " return return_verdict" ] }, { "cell_type": "code", "execution_count": 278, "metadata": {}, "outputs": [], "source": [ "def filter_data(dz,observation_range,prediction_range):\n", " dgs=[]\n", " dhs=[]\n", " for year in range(int(dz.min()['year']),int(dz.max()['year'])):\n", " k=0\n", " from_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n", " from_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n", " k=1\n", " to_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n", " to_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n", " if to_pred' in sign)):\n", " if '<' in sign:\n", " positive=False\n", " elif '>' in sign:\n", " positive=True\n", " return positive" ] }, { "cell_type": "code", "execution_count": 281, "metadata": {}, "outputs": [], "source": [ "universal_normalize=['XTEMP','XVSB','XSPD']\n", "\n", "def get_ts_data(data,key,sign):\n", " ts=data.groupby('year').mean()[key]\n", " if (('-' in sign) or ('+' in sign)):\n", " th=ts.mean()\n", " else:\n", " th=float(sign[1:])\n", " if key in universal_normalize:\n", " th-=ts.mean() \n", " ts-=ts.mean()\n", " return ts,th" ] }, { "cell_type": "code", "execution_count": 282, "metadata": {}, "outputs": [], "source": [ "def get_comp_data(observation_data,obs_key,obs_sign,prediction_data,pred_key,pred_sign):\n", " ertek_sign=True\n", " irany_sign=True\n", " observation_ts=observation_data.groupby('year').mean()[obs_key]\n", " prediction_ts=prediction_data.groupby('year').mean()[pred_key]\n", " prediction_th=observation_ts.mean()\n", " observation_ts-=observation_ts.mean()\n", " observation_th=observation_ts.min()*1.01\n", " prediction_th-=prediction_ts.mean()\n", " prediction_ts-=prediction_ts.mean() \n", " if obs_sign=='A':\n", " if pred_sign=='A':\n", " observation_th=0\n", " prediction_th=0\n", " else:\n", " irany_sign=False\n", " return observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign" ] }, { "cell_type": "code", "execution_count": 283, "metadata": {}, "outputs": [], "source": [ "mennyiseg_key={'Temp':'XTEMP','Snow Depth':'XSD','Wind':'XSPD','Rain':'YPCP','Visib':'XVSB',\n", " 'Snow':'YSNW','Hail':'YHAL'}" ] }, { "cell_type": "code", "execution_count": 318, "metadata": {}, "outputs": [], "source": [ "stations_to_include={'ro':[150040,151700,151450,152600,152470,150800,152300,150100,151200,152000],\n", " 'hu':[128820,128120,127720,128600,128390,128920,128430,128250,128220,128050,\n", " 129150,129420,129600,129700,129820,129920,129350,129100]}\n", "stations_to_include['huro']=stations_to_include['hu']+stations_to_include['ro']" ] }, { "cell_type": "code", "execution_count": 319, "metadata": {}, "outputs": [], "source": [ "def get_country(c,h='ds',plot=False):\n", " if c=='huro':\n", " hu=pd.read_csv('data/'+'hu'+'_'+h+'.csv') #daily data\n", " ro=pd.read_csv('data/'+'ro'+'_'+h+'.csv') #daily data\n", " df=pd.concat([hu,ro])\n", " else:\n", " df=pd.read_csv('data/'+c+'_'+h+'.csv') #daily data\n", " # df=pd.read_csv('data/'+c+'_hs.csv') #high_res data\n", " df=df[df['ID'].isin(stations_to_include[c])]\n", " df['time']=pd.to_datetime(df['time'])\n", " df['year']=df['time'].dt.year\n", " df['month']=df['time'].dt.month\n", " df['day']=df['time'].dt.day\n", " df['hour']=df['time'].dt.hour\n", " df=df.set_index('time')\n", " df=df.sort_index()\n", " if plot: df.groupby('year').nunique()['ID'].plot()\n", " nepi=pd.read_excel(c+'/idojaras_'+c+'.xlsx')\n", " return df,nepi" ] }, { "cell_type": "code", "execution_count": 320, "metadata": {}, "outputs": [], "source": [ "c='ro'\n", "df,nepi=get_country(c)\n", "dz=df.groupby(['time']).mean()" ] }, { "cell_type": "code", "execution_count": 321, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ts 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:42: FutureWarning: \n", "Passing list-likes to .loc or [] with any missing label will raise\n", "KeyError in the future, you can use .reindex() as an alternative.\n", "\n", "See the documentation here:\n", "https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 1\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 4\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAFaCAYAAADfOB3RAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde3xcdZn48c+ZSdI27QAttEzLpQEqiCg7UIhUEKujDuIVXRTRVTZUS5ZQ2br+ZFB3dtbL4Kq41GBEa9YrgnhbwMssHqku1wBywAURWlqgtKctLYVpkzZN5vz++J5JJ5O53845k+f9evU16cyZc75pk5lnvs/3eb6aZVkIIYQQQriVz+kBCCGEEEIUI8GKEEIIIVxNghUhhBBCuJoEK0IIIYRwNQlWhBBCCOFqEqwIIYQQwtXanB6AqF4qGV8CBIFR4IVAJPa0w0MSQggh6k6TPivek0rGNeB04B+BC1BB50PAr4AfByKxvalk3BeIxNIODlMITxlKJM4EnuuORk2nxyKEmEzSQN7kA84DXgu8GzgR+AEQBs5NJePvBnalkvHtqWT8Pc4NU0wXA32DHY2+hmnob27wJX4JyO+LEC4kaSBvei/wAeBtgUjseYBUMj4KvAM4BdgFnA0cCnwPNeMiRCN9EPh+PU9oGvoRgD8YCm8zDb0TFUj83n7MD5wcDIX/r5pzDyUSM4A+4D+7o9HxAscsAzq7o1G9qm9ACFE3Eqx4UxuQDkRiz9spoVOAKHCy/fWmQCT2V/ux8VQyvga4MxCJ/dK5IYsWd3wDzrka+Lr99duADVmPfQh4poZznwjEgDOGEok7gU8ARwFfHUokzgX+G/gO8FNAghUhHCZpIG96HJiXSsYPBb4GDKJeWG8BngpEYn+1j3sD8BTqxfaKVDK+1InBimnhtQN9g3PrfM5lwVB4R+ZrYDjrsR7g3mpP3B2N/gWVSv17oB/4LWrm5p+BVwI3AXcCK6u9hhCifmRmxZs2A/8F/A/wE9QL7rdRL6xbAVLJ+CxUquhnwMeBR4D5TgxWtLaBvsH5wHPARcBAPc5pGvoSoDPrLj9wBnCDnRI6MRgKj9Z4mdn2ed+SneoZSiS+BySBIwqliIQQzSXVQB5kp3eWAT9CpX1WAPcHIrGhAsf/B3A5sBF4Evh0IBJ7qknDFS1soG/waODLqJTNpcDTvf09N9V6XtPQlwJ/AI4KhsJ7TEP/e1SAfhTqQ9ZO4BXBUHh9peceSiQOBzRgDRDojkbfmeeYM4AHgNNQHw72dkejI9V+P0KI2sjMisekknE/qgronYCJyrs/ni9QsdNE+4BjgPMCkdj/ppLxk4DbgZOaN2rRKgb6Bg8DvggsBI5Dzahc1tvfsw340kDf4IcG+gafBDYBW4Cf9fb33D7QN7ist7+nkrTNY6i0Twz4FGoNyR7gkmAovMY09CHgm8Bbq/g2ngdm2F9/tcAxT9i3D9u3UeCaKq4lhKgDWbPiPbeiZlNuA/4FFXjcmn1AKhk/x/6yC7WO5TDgqVQyvgj4EvDrZg1WtJbe/p7dvf09lwMfsf/cBXx6oG9QG+gbfCeqfP6fgEuAS3v7e263n/qmSq4TDIX3AZ8GrjQN/fhgKHwAtS7ro/YhlwFvNA39g1V8G0ehUqI3oRal55O5/zT72OuquI4Qok4kDeQxqWR8JfAaVK79GdR0+PmoNSmPovL6h6HKMgEWAUtQTeQuBqKBSOyOJg9btLCBvsFzgFOBk3r7ez6R5/HTUAvBw739PUVfcExD11BrrULAZ1E/17FgKPwz09BPBu4PhsKH2Md+B9iPCpi6gO8EQ+Gd5Y57KJF4K/A7pq5ZaUetB+vojkbPLvd8QojGkWClBdhrWJajApPdwFmoPiu7gPWoRbdPA3ogEhsucBohqjbQN6gDV/b29/wl674Tgfejqm6+ikrnfA/4YW9/z77cc5iGPgv4OXBDMBT+b/u+m4AvBUPhR+3H/xQMhc+0H+sFfMFQ+HrT0I9CrWmJBUPhstJNdh+VPwFp1PqVu1CzKP+EmlG5FXivLLIVwnmyZqUFBCIxC1VmmSFpHtFsf0OV1AMw0Df44d7+nh8BXxjoG3wEuBJ4c29/T7FFqlcAz2UCFduMYCj8qP31KUxucPhq1PoZgqHw86ah/xuw1j6uqKFE4jWoip+foxby9qHSqilUkPJlVNrpBtQCdiGEg2TNihCiHv7S29+TPQPx2swXvf09twF/KhGoABxJVnm9aehzOLjQFeAc1DqTjPZgKLwl6+9B1MLfcjwJ/Dvwoe5o9Nvd0eipqIW3/687Gv1wdzR6M2pG6Cdlnk8I0UAysyKEqIe7M18M9A2+Czh5oG/w6N7+ns323b8t4xy/B35jGnoMNbOxF/iPrMd/EAyFd2X9/erMF6ahvws1C/L7cgbbHY3up3AlUOaYe8o5lxCi8WTNihCiLgb6Bs9HdYFdjKrk+SYqzfLr3v6eJ4o9N8M09G+hmhtuR6Uz70bNgmxCpWj2oj5kLUB1ml2O2szzZFQfoXODofDm3POWYyiROA14vjsa3V7N84UQjSPBihCirgb6Bk9CLaQ9u7e/J13p801D/yjwBeDoMp8yAvwQuCoYCr9Y6fWEEO4nwYoQou4G+gY/29vf84Vqn28aehtq88J3oMrxj0W1x0+jmsU9B/wFtT/QzcFQeHfNgxZCuJasWRFCNMIfa3lyMBQeQzU+vK0+wxFCeJnMrAghhBDC1aR0WQghhBCuJsGKEEIIIVxNghUhhBBCuJoEK0IIIYRwNQlWhBBCCOFqEqx4hGno60xDX1fquFQy/oFUMv6BJgxJiKZ66tafPPbUrT95zOlxCCGaT/qstJhAJHaz02MQohECxy7Y4fQYhBDOkGClxaSS8WMAApHYc06PRYh6OrB33wynxyCEcIYEK63nh/btcicHIUS97TTWnwxwzNlOj0QI0WyyZkUIIYQQribBihBCCCFcTYIVIYQQQriaBCtCCCGEcDVZYNt6vub0AIRohEBXUCrchJimJFhpMYFI7LZKn2Ma+qHAj4AFwCzg08AdwJeBcwEN+HkwFE6Yhu4Hvg90BUPhc0xDvxToAdLAFcFQ2KjPdyLEZLOPOmKn02MQQjhDgpUWk0rGTwIIRGJ/y7l/PtAFbApEYrnNtd4G3BYMhb9tGvpcYB3QDTwVDIU/CWAa+hdNQ/8o8Bvg18Dl9rEfDIbCZ5uGfgjwK+BNDfvmhOs0I9Ad6BucAyx667vnzW7v8KUb/k0JIVxH1qy0nhvsPxNSyfhFwDOoN5Fn7L9PCIbCNwVD4W/bX78IbAL+X855vgh8OBgK7wiGwj+x79sHdJiG3gEcCuyp/7cjXC4T6L4WeANwDfAZVKB7ZjAUPgOYYwe681CBLtmBLvB24NrcEw/0DbYN9A2uAbYDD95x684zHrhjS2igb1A+ZAkxzcgvvUdoY8NLNCs9J5WMrytxaAgg67h24CxUYDrLvm8wlYzreWZYMA29Bzgc+HMwFLYy9wdD4WHT0Cd1EA2GwiOmoT8NPA4cAVxZ8TcmPC0YCt+U9fWLpqFvQgW6c7IO+yLw38FQ+PvAT0xDv5zyAt1rgUuxf24tS+OFl9o77PtXNeDbEUK4lMystIi0r6N9vP3QgOVr13IemglYOfeNolJCE0xDX2Ia+m9RU/fnAX7T0H1Zj88GRnKe837guWAovARYDKw0Db2zHt+P8J5igS4wJdAFMoHuX4BfZD9up35WAJN+ntKWBrDCflzYTEOfYxr6iaahy7+LaEkys+IRVlvnegsIRGLLcx8zDf0iYBAYxUrPaU89/cTh565cDhNrVZ7h4KwKQAcq1ZN5/qtRawkuD4bC99n33QH8E9BvH/avQO4miXOBbfbXe1BrD/xVf5PCk0xDXwJ8A/WzcB7wP6ah+4KhcNp+vGiga697+Z1p6D+1AxuARcBYgUuO2Y8/Wf/vxltMQ29DzTStQP27tJmGvhZYHQyFC/37CYeYhr4OIBgKL3d2JN4jwYp3LEHl/tfl3D85zaP5OBA4/pWmoc8PhsI7ApHYjlQy3kMmmFGBSk9OCiiCCjyuMQ09c9/HgD7T0B+wz30r8F851/4e8HXT0JP2eb8WDIVT9fl2hRc0MNDdQuHXpzb7cZGTKrNdat9Kqky0DM2ycjMEwo1MQ9+MWgeQWzERAP6O7Bd6yxpG05YHQ+EHMneVqAYSoiqmoX8SuBx4NuvujwF9wOs4GOj+eyY1ZBr6XUAY+DpwAirQ/UYwFM5NBa1BvfFOpIJ8Plh0XOfzZ75x/vqGfVPe4efgv3GuEWBBMBTOu+jdThctArYUOkbUn8ysVE+CFY8o9ENuGnq+NA/Ax4Oh8HeaMjghGsCu+plIcfj8zFn8ijkHTl027z6fX5MXLvU7v5T8qdcUcEYwFJ6UKsuXNgIkbdQk5sO//yPW2CGzd9x/eiASk5/hCkgayDsKpYEAngNOzLnvOtPQfxUMhWUWRXhSb3/PGLBqoG/wamDRm84/7Kb2dl960dI3v8HpsbmBPTuynakfVKBwqkzSRk6yxjt9Y8Mh4AJyFpWL4mRmxSOKpIFA5f9PYfInrJeAt2SngoTwMmPgG/s1Df+RZ73qrjqe1o9KQ40C43U8b7MsARYyORWUBrYCuamyqtNGoj7MPycf9I3tXTrrxb88C5whKfnyycyKd6yHvGmgTCVQ7lTwpIofIcQkGmq9zEJUab+GeoPfwNRSfzfbYN/m+z5ydVD4e5MKq6bRRoC7gHtTyfh7A5HYo06PyAskWPGOfGmg7EogxbIAK43m65EUkGgp6fSIRX0WJ5qGvgY4g8mzDHOBR4KhsOfSIeUsmK0ybSQa4yZUNdy6VDL+A+CLMstSnAQr3ja14ZuVHp/x0pOPzX1j3035nyKER/l8szQNf4F1W5UolA7pBFaYhn6119Ih9niLzooEQ+E9dg+WSRVWwDDwXftxqRJqnjuBh4H3A0+lkvGfAtcHIrFHnB2WO0mw4gF2xc824JnsT5V5K4E0TfONpeRFRojCpnM6ZLV9m10N9F3gU/ZskzSXa67dwLeBn6L6XSVTyfg2VGr/5kAkZjo5ODeRYMXlstakdACaaegXZfZjCYbCO+wW5xMN3/z7dyd86VG98BmF8KZDlyx6DGpPA03ndIgdeKwyDf1qsmZQ7EBFqoScsxvVOPEW4FTU5p7/nkrGDeCHwM8DkdiLDo7PcVIN5GIFeqiMAIuz16PYx3UBm2SdimhVJSriKlVJFU2rkyqhJlHVQMOvmvXiox8o4/AO1Lqq1wGnA3cA1wN/mI49WmRmxd26UDMm2cFKZhPCiaDEDlB2AKSS8dcBBCKxe8q5gHS2FV6xb+fLHWiaf+a8QM3nstLpDft2pQ6dMXfOnEwNzf4X9wzPnBfYoPmm3f6u0zkt5majwD32n9moTWa/A+xMJeOXBCKxx5wcXLNJsOJum1AvJNlKlSR/yb5dXurkqWT84AaI0JFKxnsCkZgszBWutPuJZzuA8dDln1he67mGEok1wBma34d/Rgfj+0exxtM+4JHuaHRapT2mc1qsmewNPat9z90L/Bb4HfBm4M5UMn58IBKbNjNekgZyuYk1K5Y1E9DaUxse7xgxi82AhOzbUlPlU8ue7RSTzLB4z3So4ni4/7r9gP9AarjWpnAl0x7d0WhL/hsWkrVmJV+V0LQK3hrBNPTTgTtJjx/iGxu2Zr34yLtrON0S4N+Arum0jmXazXd6jb2Y9nTGR19kbDhVIlCpxNSy54MpJuERpqG32W8024EHge2moa+x94AR+ZWT9phuVqOqgkZQ+wqN2H9fXexJojTT0F8D/Ab4JljP1XCqWcCHgc8CH5lOgQpIGsj1JmZW2mZ0wAxt75HnfCtTDZRPKhlfBxCIxJYXO6+9ViV38a50vfWeabPXi6YxAtAdjS6v5TxDiYSkPXIUqhJyeFieZhq6BnwQ6EdtFnkP8KEqTqWhUj8fRKWBXhOIxKbdz6gEKy5mV/kMMvlFddA0dL3Wqp9AJLYjlYxPKnsGeiQF5B126mcFU990O4HLTUM/DW/udwN59uzR/L45llX799Mdje4ZSiQKNkebbimgbOU0lxOlmYZ+ArAGOBmIA09XeaqZwL+gsiCRQCT25/qM0HskWKlQk8uEuyijGijHleWePBCJ3ZRKxnWkGsirFqHSFvlYqDf7keYNpy4K7tkz9+TFI5ZlDdfpOoWao0naQ1TNNPQuIIrqSvvfqBmVWprq/QNqn6ePBCKxad2cTxbYViCrQdvETESxlEwdrldWnxUxPZWo4vBkf4xiCz1RzbLqsjdQhp0SWgRsmc4zKqJ6drrnLFSg+xYgiQpUUlMOTo9d7xsbObqCBbb/AfxjIBK7r07D9SwJVspUIHBIA/cBBxp46fnAK1HTgBZwcYk1K28GCERiv2/gmIRLtFIVR4ngKz3ywu4R0owc99b3zW/y0ISYwjT0w4CLgV7gMFRpsY76/cuv8mDl48CDgUgsXuNwPU/SQOXrYmpKxkLlFBsZrOxAtWI+FUhlApUi6ajP2rcSrEwPrZTOKJrW2rv5hZljI6PtjRzAdCgBF9UzDd2PWuzaA7wNeAi1r88jFK4wq8V9wDtR616mNQlWyreJqQ3aRoHzmpGSyd5pNjcdZRp6Q9NRwr1arIpjC4Vfk0bHR0ZHSacbcmG71PtaZCM/kYdp6K8CLgE+ArwIrAMuI1+qp3404LVMv+0f8pJgpUz5Ng1ErVlp1tqRJcAc09Dv5mAzt8wsT10qhIR3tUIVh72hXsEqHSud/kgDLz9tSsBFeUxDPxSV5vkYcDTwR+DzwLNNuPwp9rX3Av/YhOu5ngQrFQiGwjeZhj5RPeNQcFCsmVtF45F9gYQLFU5r+XwrNQ1/9ixjPukDY/6xkf0dbbNmjPra28opdS7U0bYTWGEa+tUenq0SFTINfSkqQL0A+DNqsayBWqPYSB3A64EIMAMVGP0gEIl5tf1AXUmwUqHsTQObLDMVeCF1aOYm+wIJNyqW1jLvfbzoc610Wtv56MYThs1dCzUNy7LQOoPzth5+6nEbNJ+v2HoC2chvmrMret4GfAY4HlXR80/AS024/JHA+cAbgSHgU8BvJUiZTKqBPGLbg7dt1qz0nFm7DGN0VnD+gcDxr1Qvx5rWnnr6iaw2/Jkgplh/DdkXSHjOs3+89X6AY9/wrtfme9zenLBQo7eCqZxWLAEX5TMN/SxUA7fDgV8Ad9GoWZTJ1UCHo1I9Z6BmD78ZiMQ2NuS6LUBmVjyoY8Tc0bZ/127LP2umNj6yD2C8/dCANj6yz5ceLacJWN1SSUI0i+b3HWWNp+cMJRLr8jxcNJUzlEhcXaiPSqm1MpUGKlJR5A2moc8AvgJcBPwYuJPGVPTkcxaq5HkAuDAQiTVjBsfTJFjxCKutc73F1D1/ciuD/CPb+2e+/OT/BiKx2wqdS/YFEl408sJLM0lbhV6zak3l1FwCLhVF3mEaegC1uaAP+ATQxKAyraH6p7wlEIk91LzrepsEK96RqQZal3VfdjpnFsD4zCM+md6z6WygYLAi+wIJLxp+/oU2YCzfRoa1bk5YpxJwqSjyjh+iZs6up3mzKaD5D1i+GQeAt0mgUhkJVrxtajrHsizLP2tmGc/VgUwXRUMCFeF6Pt+sQtVAx76tmxeMDbuGt+1aSNo6mAryaenOI+ftOiJ0wu2moVd0uQqPd2VFkWwnMJVp6MuB01EzKs1dtKlpaatt5mggEnuwqddtARKseMd6mLwvSt4tADRNy6xjKSS3EgjVjVEqgYSnHX7qcRt4FIa37VqogWWB1nmkqgZqwuVdVVE0lEhMSUnZO02v7o5Gp3tK6kLUh7Xp/u/gKRKseIQ2NrxEs9JzUsn4usx9s4HRWcGN2ZVBHS8/tc+XHj0l+7gcU1JHwGAqGddldkW4Wjo9YlF8I8OFp6vZBMueTXj1JR9vymxCiYqikmmoBpCUVGFdqL4pwkMkWPG43MogX3r0lBJPkUog0TCNrISxLGYB/gLVQHkNJRL1HEJRh596/K5ZwXkLfX7fRCooPZ5Oj5i7du189Onbn/3tULOGUnVl1DSxh/xBpXAxCVYaqMhmgxUrVA2UK5WMH4M67rkCj0slkKi7ZlTCHPbKY3aRTnfueOipepyu7nb+ZeOGw4HO4LyFFpaloWkj5q6tO/+ysRlpqGyuSkm50MOo2eU7nR6IKJ8EKw3i1GaDhYKUrMelEkg0QsPTDrOOOPRvAPmqgdzENPQ5mj27dMLbP7DnhLc39/q1VkZNA79BLa4dpNkLbEXVpINtA+Rd+Ko6It4HHKjytCFgTzAUPrrYQalk/AMAgUjs5hLHyb5ADmqlxmEl1mukgXuAmluH793ywplY7Dvh7R84vNZztbpqu/lOB3Zr/T+j2js80OTLXwssDIbCc5p8Xc+TmZU6yU752LejTH7xtlDrRaoNVsrVa98WDVbsAEWClCZr0cZhiyhcWWGhZu/K6axc1J5nt8+wLHnNKlPNTe5aVTAUtkxD/yLwBeBBZHbFE+QXvw5yUz6oKcaOnMNGgfOqXbtSaqdZ4RmtWKWxhcKvJaNAuB6zR+bd/7e71nNMF3Z58qqhRGKiyd00X1Sb6xfAp4E3ocqYhctJsFIje0ZlEPXmk3kD+haqL8oSVNSuARuBWyptTJUlRFNbQot6s9MlK5iaLukELjcN/TTqkC5xyC5gIZMrUNL2/RU3ZMtH8/vmWFb+f59WSqvVkx2gTOfFtHkFQ+G0aeiXoXZXHgJSDg9JlJBb2iYq14X69JjNQgUW9wGP2Lc7UD1OAvatmH7KSZd41QZgKypAGbdvt9r3N4xp6G2moa9BrZl5ENhuGvoaO90mREHBUPgh4EbgI06PRZQmv9C120QZKZ88qaKKqoMkDdQSmpIucVIjZzgKpIFaMa0mmuezqJmnJdhdwoU7STVQHZQKROpUHVRuNdARAIFI7IWyvwHRNPYsQN4qjWAoXPOb60Df4ESw0Nvf4+nAJ9fz9/9uCzDbP6P9YfuuQs3PQC3oXeD14E80nmnofcAHgP9owuWkGqhKMrNSB8FQ+CbT0HUKN4DroknVQZkgRUqTXashVRoDfYNTqowG+gbXAqt7+3u8WmU0iX9Ge5rJlRvS/EzUw/eBa1CvzzVXrYnGkGClTuwApVBQsIkaq4PKTQOlkvFLgNcCH7Wv0ZFKxnsCkZhsVOgCdnnyKtPQJ6o06vTpv+XTIS9vNPcAe0684EPLwZX78QgPCobCKdPQ1wPHIMGta0kaqElqXbOy7cHbNmtWes6sXUapDbhOAw7JuW8EWCwzLK3JTv00vCmb07pP2nMOGuNL+1bNyNzX6LSaV0l1VGVMQ38U+B7Q6L0cJA1UJZlZaZIyUkVAXfYType/l40KW1tTmrK5lDQ/y9KiTQcbyjT0ucAJwLNOj0UUJsFKE5VIFRXdT6iCjQzvRm3SlR20yEaFra1klVErLLY1rr9uSjVQA9NqXtXy6cAGWIkqdtjv9EBEYZIGcokyKobKrQZaB8wHjmPyRoWyZqWFDfQNFkyH9Pb3tMSblDHwjf2ahv/Is151l9NjqYf0gTH/2Mj+jrZZM0Z97W31SNNJdVSFTEOfh1qn8q9A0U1g60TSQFWSmRX36KJ+FUM7gOWUWQ0klUMtQdIhHmGl09rORzeeMGzuWqhpWJaF1hmct/XwU4/boPl8tXx6lOqoyl2F6mDbjEBF1ECCFffYRJGKoQqawp0PEIjEhiljjUoqGZ+UepLKIW+yy5NXDfQNTqRDWiH1k23BmSfdDxAMhZc7PJSa2DsinwH4MhPbw1t3zh3euvORWnZEluqoypiGPhv4OPDPTo9FlCZpIBcpVjFUQTVQJdqZur5FKoeEKz131+2brfH0HPOexyr5HfCjfpdGcUdFVMlUTS0bDkp1VPlMQ38T8HVUF9tmkTRQlWRmxUXKrRgqYZF9W86nqJlMnTaWyiHhSnuef2E2llXu/kkaqsJjIQc3E83sVeTkJ7RGp2okHVg+P2pdoPAACVZcplDFUAXVQOso4zj72PnAZtQvbcYspHJIuND+F17SgNHuaHR5qWOzUy1Zd88Fakq11GookWhoqkaqoypyL6oR3CtofH8VUSNJA3lEBWmgkH1bzlR5O7AM9akzYxQ4WtJAwm0e7r9uP+A/kBouVQ3U0FRLrexAKm+qxslAajoyDf29wLdQ7fabEbBIGqhK+X6ZhQuYhj7fNPQz7ZLmRpnJ1GnQEVQaSAhX0Xw+/LM60Nr8/hKHlpNqcdJqVGpmBEjZt5KqcUAwFP4F8DHgauCDTC1yEC4hMysulG+hLXAZlK6EqCINlNvbRRbYClfJdGW10ukrLMvC5/ePAAW7spZItTg+s5Jhj3MRsMUN45nOTEM/BrgONSP3M0CncFfoWsjMSpVkZsVl7JmUQdQL7aH27Y9Re/4sqee17ICkB/UC/pJ92yOBinCZa4FLNZ8Pn5pUmYVKo1yb72D7jX8tKrWSbRhY65bAoDsa3dMdjT7plvFMZ8FQ+LlgKPxe4D3AiajU0AXAbEcHJibIAlv36SJ/c7iyAstyZlRy6MC77a8NCVSEU+wNGSf1iLF7h6xg6ixJJ7DCNPSrCywglaoYUbFgKHwf8FbT0E8HPgXcANwF/AbZO8hRkgZymQJt90eAh4ED9WyIldsQDmnLLxww0Dc4ZfM97DTPBSsWHw88CATyPDUFnBEMhQuW+kqqRdTCNPSFqL2DLgNMIImqIqq2Z4+kgaokwYoL5Vuzoo0Nf7XMaqBj7NtS7aOlIZxwhWL7Gl2wYvHVlFh/IqW5otFMQ29HzUB/AjgJ+B/gd6j0eSUkWKmSrFlxIbtr7WLgLcDiTBfbMh1u/ymlWEM4IWoy0Dc4Z6Bv8EQ7tVP0ONSMSmfOQ53A5b9c+8xvn31qz67xsXRu1dowsFYCFdEMwVD4QDAU/lkwFH49EAb2AdcD/4Tz1WXTgsyseERmb6B6VQMVqwSyv+5CNjYUFSqW0rH3L8o9/kQKp3nGgYc0H/tOf/3hJxx9fOdRWBa+tuLVQEI0g52yvwK4HJWmvxmVKipGZlaqJDMr01ShSiDUp4ZngDuAZ+x1LUKU61pUSmcWKgApWoZKJ1cAACAASURBVLmD6thaaKH/KBC+bE3PG7ovfPfRO4aeeGnnoxtSqNTPKglUhJOCofCOYCj8r8BxwJ+ALwOXkD9lKWokMyse0aAOtqDWrsxETWuCrGMpyq5OkTbmedgpnULrS9LAPeRfmLgEtYePL+f4rcD6zB3dJ+05B43xpX2rZtRt0ELUiWnoRwJfBd4MfAP4S57DZGalSlK67AB7+rCL6jcrLKbSVeoH7D+gPgnLxoZ5ZBqTkZXeMA1dUhGTLaJwIy0LtVh8JM9jG+zbfJsOHuTTLM3ZTQiFKCgYCm8D/sE09LcB3wN+DfzS0UG1EAlWmiy30sc09J5yFtCWu5FhLQqsY+lANjaEyemNjEvtW9nPRSmZ0sn0T8knX5+VbJl1W0K4WTAU/q1p6EtR1UKHAN93eEgtQdJATVSgh0oauI+DsxuFhIA9wVD46AYND5DeK/nYqZ9q0hvTzgN37liyZePwwnT6YErH5yO96LjOrWe+cf76Ys8tQ1N+B2ohfV1Ehmnoc4H/Be4HfmXfLWmgKsnMSnN1kb877UxKBytlSSXjnwMIRGKfr/B5mdSUjqoI6kKqgTKqTW9MO0vPPWIDvMCWjcMLNU2zLMvSFh3XuVXdX5vdT22egYUWDJU+ttmGEokpacKhRGItsLo7GpU04TQUDIVftFNCfwb+CvzN4SF5mgQrzbWJqbt6jgLnlVq7UsEUeNi+LTtYkdmUkkqmN2Sx7UGLlmZSOtYiYMs7//miuvzbmHdft7se52kQSROKKYKh8HOmoV8OJJCtHmoiaaAmy9edtpw1Kw2uBpIKoBJMQy/YZTUYCsubURM83H/dfsB/IDV8l9NjyeFH7dabrxWEa3Z5Fs4wDV1DpYMeAN6BpIGqIn1WmqzG7rT10I6q+mm3/y6dbMuzGrUR3ghqT5oRZGM8oXRQuEqpjYNbYIhpKBgKW0AceJfTY/EySQM5wE75VDRrUW41ULEOtvnSPag1KlIBVIJdnrzKNPSrkT4rjtA0tS6oOxpd7vBQJrEX1RZagN2OSgP1NnVQwm1+b9/mbishyiRpII+oIA10in37WM79BdM9qHUusmbFIdJorjyP3NA/jEXb/hdT9zg9ljxeQeE9YiQVJDANPQ58EkDSQJWTNFCVTEOfbxr6mXY5sps8xtRABYqke+zAZCI1JYFKc5iG3mavhdmO2h9nu2noa+wGdCLHvFO6ds09+dhhp8dRwGYKp4LGkM3uBNwGzHZ6EF4lL4pVqLaxWy1qbQpXquGbvZhWFtQ2l1SQVKB9zqz14L40EJRMBbWhKsqEC5mGfi7wM+DqYCi81jT0S4A+VA+lJ4DeYCi8t8Q5DgNestenFPKwfdte5BgAUsn4EcCuQCSWu9t49jGHAj8CFqB+7j6NaoFxjT323cAHA5HYzlLX8wIJVipkz6QMon44Mi9MPzYN/Qrq1CulgBBQcho5lYwnAAKRWDT7/kAktiOVjPcwNd0jAYoD7NTPCqa+uXUCl5uGfhrTvNHcgf1p/949Yx2z57SNts/wjb/4xLNnYVmjbuyz0h2N7rH7quStGJMUkDuZht4JfAb4N/vv56JmmF8bDIXHTUOPoPb56Slxqo+gKjD/VOgA+3zjTG1fUex8fyhyzNuA2wKR2LdTyfhcYB0qKH57IBLblkrGz0ftTn5BGddzPQlWKtdFgxu71WhZ7h3S8M2VpNFcAelxS3voTy+ckNtY7piZe9pQ+wa5VaYybKIxHFIx5nZfRO2WfCzq/+ujwOeDofA4QDAUTpqGHjUNvT0YChd7fT8aOJIiwYptGFWNOUUqGe/gYCBzMXBqKhkfsv8+EojEJn14yU7XByKxF1PJ+Cbg84FIbJt9973299YSJFip3CaqbOxWi2r3RZGGb64ljeYKGOgbXAOcAfgyy0A2bxieO3pY+/gJC/e7NoCzO9WuGkokJirGZEbFvUxDPxuYFQyF/2CnfgCOAp7LOXQrKtXyfM7zj0G10X8BuAE41jT0+wAT+IdgKJzKc9ktwNwCQzoE+C9ULxaApajg6XrgXygy02rPmh+OnWqyU0T/BXyr0HO8RqqBqlBtY7daVNkUThq+uZg0mpvK3sww79oPTbP4uxP2ji67ctWM5o9MtBrT0L8CnAPsB4KoWbsO4O3BUPjxrOP+iPrwMGUm1DT0WcB1wOWoQGclau1L3jfWzIfOYCi8vNC4Usn4zcD77b/+a7GtU1LJ+BJUmmob0BeIxPakkvH3A58FvhqIxH5Q6LleIzMrVQiGwjeZhq5jp1MaOaNSo3wVQGPA+alk/DcSsDhO0gZTFUyPWRYY62d3GGrmZXVvf4/suSOqFgyFP5X52p5ZaQM2ADHT0C+215icj3qNz/uzFgyFR0xDTwNfAvba99U6A3AqcCsq+HlNoYNSyfirUTs6Xx6IxO6z74ujmhAuD0Riu2och6tIsFKlahq71aKCpnA/Qh334QIVQAFgDTCQSsYlJeQgaTSXV5H02MRyFamYEg0RDIXvNA39BOAB09DHgPXAZYWONw19MWrmOg4cCnyljPUtBaWS8VcAXwtEYmtTyXg78KlUMj47EInlq0aKoFJK16SS8cx9r0Wlgn5h37c+EImtqGYsbiNpII+oIA2Uaz7wStQMiz/nMUkJCdex16zkpsdyjQALevt7pntwVzFpQlg/pqF3BEPh0ay/a0BbtcGKKExmVlzGLo3uon7ppR2oevt5qC6b2QFLZg8gCVaEm2TSYB9DpTLzyTRae7IpI2oBdrPBa8lKO5qGvhZYXSjNIYrLDlTsv1u4oyq05Uiw4iLFms1VkAb6T9RxV+bcX7QpnBBuYa9FWTXQN/hF1M9nvoBFGq1VTpoQCs+SNJBL2DMqucFEGrgPFamHgD3BUPjoYuepdCNDWbMi3CxfSsjnI73ouM6tZ75x/nrnRlY1P+p3b5TmNv3zA68j/xYrI8ACSQkJN5O9geqgTvsEdaFewLJlms3VhewBJDxoNapCasTns/BpFouO69y69NwjNjg9sAppwBJUwLDUvl1C85rcdSB7F3lCKhm/yG4QJ7JIGqhGddwnaBNFms1V2xQul+wBJLwkKyV09aldw1s62tLppasuLTq76EZ2Tx270d2EucAjzeipYy+qlb2LXC6VjM8Dvo0qXc798DqtSRqoBmWkbiqVXbmjoTbRygQWNaeBhPAyY+Ab+zUN/5Fnveoup8dSIVekYKQJofulkvFLgHcFIrH3Oj0Wt5GZldp0Ud99gjKVOzOBfVWeQ6ojREtqnz2zot+H9IEx/9jI/o62WTNGfe1tTm4KWU4Kphm/t9KE0P3eC/zU6UG4kcys1KDAzMoIsLjeXW3LadOckbVxoWxWKFpGub8DQ4nElBJd1O6zq+39e5qqRAqm6Ytbpc+KO6WS8QBq/6FjA5HYbqfH4zaywLYGdkDSg3rBecm+7XGy/b5d8fMMcAfwjP13IaaT7BLdgH17qX1/09kBwVpUyiXbMLC22QFDMBTeEwyFn5RAxXXOB+6WQCU/mVmpgwY0cpuizA627cAyJlcYSJfaFjHdPxH/5bsDe4D2ke277y1yWMn1IU7shJyvIRv2bI80ZBMwsYHhHYFIbK3TY3EjWbNSB/n2CWpGAJPHTKaWQkqXWo+TzqPK2MhoO1O3jMjllvUhk8g+UKKYVDI+C7XXT5/TY3ErCVYaoI7lzBPK6WBrr1UxmfypUrrUep90HgU0jRGA7mh0eaFjhhIJV5fo2gGKLIIXud4CPCwz4IVJsFJn9ozKIOrFMvOC+WPT0K+gtj0jQkDRT2KBSGxHKhl/AlX+nOJgl1r5BfAoO/Wzgqlvvp3A5aahn0ZzO6EWdWB/2r93z1jH7Dlto+0zfHUdl+b3zbGs4t9rdzS6ZyiRWEuBEl0nUkBClOF9wC+cHoSbSbBSf13Ut5y5Upny5yspsxpIqodcbREqfZGPhQpIR5o3nPzS45b20J9eOGHLxuGFmqZZlmVpmU6zPr/W7IVxUqIrPCOVjLcD7wA+4/RY3EyClfrbRJFOtNWetIIOtgZAIBJ7oJyDc/cLSiXjsl+Qu2yh8O/pKBB2w9oHew8fu0Orik02bxieu3nDs4/09vfUJVW185ENm8s5zi5PXjWUSEysD5EZFeFibwSeCkRiZf18T1dSDdQAuWtWUOXMNQUAZVYDVaodOIvJa1ykeqgMzazMcXvn0YG+wWLrRNLAPdQhVbX8PcFQW5tvzyuWn+e5dvtCFJJKxr8FPB2IxP7D6bG4mfRZaQA7MJnYMLDWQKVcaV9H+3j7oYG0r6O9zKfMZGrlRKZ6SORhGnqbHTxsBx4EtpuGvsau2GmUic38UGuRRnBXWqOcVJUQIkcqGfcD70HWq5QkaaAGyVfOXItS1UATsznWeBtoPjTfh0sFSfZaldwOvFI9VFzTK3M8UPZaMlXV299T83gfXfvNbQegneW1nkkI13gdsC0Qia13eiBuJ2kgjzANfTMwB3tNSo6C6ZxS62Ry16ygqodkzUoeJdqm1y3d4UUP3LljyZaNwwvT6YM/gz4f6UXHdW49843zMy/EftTP2ChV/Dttu+/xcyyL8VDvFTPqM2ohnJVKxr8OvBiIxP7d6bG4ncysuEyVzeSKpXOKniMQid2USsZ1pBqoHJ6ozHHC0nOP2AAvkK8aCNWo8ARgIQd3FN8KbKBwAzchWloqGddQGxe+3emxeIEEKy5Sopncesi/iVuBDRXLTufYAYoEKaV5ojLHKYuWZhbbWouALe/854v2wMQCYbtSaMJc4JFKFgibd/+f7JkiWslSYB/wmNMD8QJJA7lEgYAjDdyH6s8SAvYEQ+G8lRATgU56vANN09B8H2rWwt7pxO2VOW5Tz9RZuWkgu4utlCwLV0sl4wmAQCQWdXosXiAzK+7RRQ3N5IKh8E2moeszXn7yK76xvbsPffOnKw5UpDlcWaThWGXqljrrOGzOGJY1WujxoURiyh5Kdjfb1XbvFSFcwU4BvQ/4kNNj8QoJVtxjE0WayZXTFE6tcQlfUs3FpTlceTxQmeM2dUydlfwdkD2UhFe8CvVB9EGnB+IVkgZykWLN5BrUFC5DmsO1ELtJ2yJgSz1KhmtVr9TZc3fdvtkaT88x73ks3++AH1UGmq931AiwQFJCwi1Syfi/AvMCkdiVTo/FK2RmxUUyqRwqrwbKdop9+yQqct9H6TRS1dVEwj0G+ganpEEG+gbXAqt7+3ucTIPUJXW267FN87AKvmZ1ULiyaAwVvMlux8It3gtc4fQgvESCFZcp1EyuVFO4jFQyvg6YD5xGmb1TpDlcy3BlGqReqTNrbHwUGO2ORpfnPmYvqi20kLcNlY4SwjGpZLwLWAusBIKoxeWiTJIG8ogK0kCnAYfk3FcypSPN4bytWfvzOKn7pD3noDG+tG9V3mqgoURiUrpJ8/vwz+wYSY+Off+Mf/lUbzPHKkSuVDJ+CKq/UBw4HlXpmQ5EYj9wdGAeITMrVaqyeVsz5MvZl0zpSHM4z5OGdZm0ksaKuScv9s8+en4H0Kb5tI+ahn4AWG3P8gjRdIFI7OVUMv4ycBFwJ/B5kM0jyiXBShVKNG9riArSQHczdbFsWSkdaQ7naU3Zn8dJxvXXFW0KZ5cnr9ry0B3tmk/7qKZpoBaPt+OCdJgQqNfh04EFwJsCkdgGZ4fjHRKsVMieURlETbdnptx/bBr6FZTRD6UGIaCcN5vfAc8D72BySkeCkBbW29+zx15Mm7fqxguBSqkqppnzD9PQ6ChRxu/3+X35qoI6gRWmoV8tpebCQQdQadk3ByIxWfBdAQlWKtdFDc3bGi0QiX0epMHbNOXJhnXlVjEdduLRKdRmnsVIVZBws6tR61SecHogXiMLbCtUoC1+WTsc13jddZB/b6BiJGiZftzWZ6WUgb7Bgn1Yevt7JtI25fwOlGjvPwIskJkVke3ie69ZAPwe1aCtC/Vz2AF87MZlVz1Uxfm0G5ddVfEb69CFN7wBtZ7lclTq8jvAV7tvWflokedkxn4rav+4PtTMzRNAb/ctK/dWOg63kmClCsWatzXwmuugdLCSSsZ/CxCIxN4mFT7C7SqpYuo+ee/ZGoyffvkVM4uds9YmdHbAI92Jp4mL771mGXA2asHrhTcuu+r2i++9ZjHwGyB047Kryp4xt593G7DyxmVX3Vvu84YuvKEb+AMwG/gBcDhqN+YXgGXdt6xcX+B5mbGfj6o0+kj3LSvHhy68IQJ8oPuWlT3ljsHtJA1UhTo1b6uINja8RLPSc+w+KsWEYMpC28wbwWAqGddlhkW4SPlVTGlLszS0Ms5ZVTrMNPQp6SjT0NciVUQt7cZlV9178b3XzAC+duOyq26373vm4nuvGQMORQUMJV187zWvAHRUYPzXCofxV+Bh4BzgI1n33w08W+hJ3besvHfowhtmACcDX+m+ZeW4fX9y6MIbokMX3tDefctKx5cn1IMEK1Uq1LzNCWlfR7vlnzVTGx/Z50tP7PMmXWmFF5RdxVSqGiijhiZ0rmyqJ5rr4nuv8QGfAf5247Kr8gYqF997zULgJuAqO9g5GRWojAFvvXHZVWX9rGZ037IyNXThDe8BNgIB++7nUbMjBTfvzLIYeC7nvq2oqqPnKxmLW0mw4hGFSpdzU1LtL6/f2DFi7gAuRLrSCperqIrJ55ulafjL2NTTj/pZH8VOIZmGXmoohfYWkiqiaeTie685HfgGKv14cZFDPw6cC3RffO81e1CBigUsv3HZVQVnQgqxZ0d+yMFABeAo4IahC2/o6b5lZbrEKZ5FBSyPZ923CNhW6VjcSoIV71gCzMl5oc7egHAWwIHA8a9s279r96Fvie5IJeM9TF2zIrMqwm3qVcWkAScAC1FvHBrq0+UGClcIZUgVkXgj8AZgxY3LriqVxsmkVvqAz6F+1t5447Krqv0ZORN4s/31r4B5qGDovUAC+FuJ558ExIYuvOFie83K+cCm7ltWtkz6UoKVOnKgq23eVM94x6EPgHSlFd5glyevGugbnEjb5O2zMi+wGQovMrcX1p7B5NmRucAjpRbWlqgikr2FpodHUcHKwMX3XpO57x03Lrsq34yaad8uQaXV33zjsqsKVu2U0n3LyruGLrzh74F/QM3ozAB+Cnyx+5aVpQIVUB1xNwEPDF14wxiqMuiyasfjRlINVCeNrhDKVw3kVBm1EE4wDX0zqs9Kvv2xCqVxoMyS5VqriMT0YVf9/C9qhuX8G5ddVU5AUXULCiEzK3XRpK62UzrYBkPhHaahT0n1SKAipqF6pHE82VSvFCnFrj+7Wugk++tW33PLFWRmpQ5MQz8T1Zgne7fjceARIFWny4SAPcFQ+Og8159IP83edtctUHoPISG8JlMNFLr8E4flPlbPZnCt8uaerxQbkFJsB8nMSvVkZqU+QkwOVEDNdJxXr1mOYhUQ2WXUqeRd9bicEJ4SDIX32D1RCqVxyg467GNbYTGtlGKLliHBSo3sWY3r8jz0HHBLGSWT5Sp3I0PhUa3yib5hSpcua8CLHFx4nvn735VR7txqpBRbtBQJVmrXxdSNDcc5GFi0o1489+GCjQ6F+0jn1LqxUFUQG8npszINSSm2aCkSrNRuE+qFIdsocB4Qpk4VQtPwk+F0ItP15UinRywk318OKcV2Jytt+cdG9h8zlEgs6Y5G8+73I/KTYKVGhSpy7IfrWSFUbhrop1WcWzjEflNZwdQ3lU7gctPQT2P6zg5MMvuoIzosi/1OXd9Labp6ruER9WONj88a3ze6GNVPJeb0eLxEgpU6yN3Y0L77fFRQkv0mZKFSQg1LBwUisW826tyiIcrfyG+aC3QFR4Gmb3nv4TRdS5Zit4g3OD0Ar5FgpU4yFTlZzeEOUMcKoXLTQKlkvBMgEIkNV3oN4YiSG/nJp2Bly4P/8yeHLu3JNF0NGzqKBtJ82ihwxlAiMac7GpX/jzJJsFJHBZrDgZrG11AL/6qtECo3DfQb+3Z5NRcRzSXT9eXb/sDfXqtp+H1t/nVNvKwrq2oqSUm1UCl2i9DGgceAtwM3OzwYz8jXmlpUrwv1aTjbOPAUcB92L5Q82lG7bbY3bGTCzVajpudHUE0ER5Dpercop6qmaUxDb7O3BdgOPAhsNw19jZ2qEt5xNwdn50QZ5Ae8vjaRvzLo3EKpn3L3FJJqoNYl0/VlcqAayIVVNZ5MSYkp7gb+cSiROL47Gn3a6cF4gQQrdVTpXj0V7ikkTeFanEzXl1C6KVwxfqrvvbILWMjkmei0ff/tdWz8WIorU1KiKqOADnzC/iNKkDRQndmzIouBt6B2Py7WV6WLqWkjC7WzrBCidhqwBPUmv9S+XWLfX64NwFZUgDJu3261728mV6WkRM1uBz46lEjMdXogXiAzKw2QvVdPCZuYmjbyA68gJx1UwafJ75V5nBCe0hmctxEqSwPZ6zvOYPIHs7nAI8FQuKK0idN9VlyYkhK12Qk8AFwGJBwei+vJrssOy1qzkvsClEYtys2kgwruuizEdGAa+mbUrKNR5lMKpU2gwp2Y3cIOvgpVjsmaFZfb8kDywQN79r1q232Pf8C+qwv4DHBsdzSaO8suskgayGH27Mm7mboeJdNAriKpZPyIVDJ+RD3GJoSbjO8/4Bvff6CS9E0rpk2kcqy1bELNiL3P4XG4nqSB3MFAfQrMNqmBXAVpoJ/Zt8vrMjIhXGLHg3/rBKzQ5Z9YXs7xrZg2kcqxlpQE+oCfOD0QN5OZFRewA5Ie1Kekl+zbglVEQojS7Dfxtag0SbZhYK2X3+SDofCeYCj8pJe/BzHhfuCkoUTiRKcH4mYSrLhEhVVEQojySNpEuN048EfgEofH4WqSBnKRCqqIhBBlkLSJ8Ig7gauHEonPdUejsst6HhKsCCFanjTcEy73DLAbOA/4tcNjcSUJVlrPgNMDEKIRZh+z4HmnxyBEAyWBTyLBSl6yZqXFBCKxmwORmOzkKVpO4NgFOwLHLpA0qWhVfwJOHkokljk9EDeSYKXFpJLxY1LJ+DFOj0OIejuwd9+MA3v3zXB6HEI0yBhwM7BmKJGQ9+Yc8g/Sen5o/xGipew01p+801h/stPjEKKB/gDMQDY3nEKCFSGEEMIdLOAbwOeGEonTnR6Mm0iwIoQQQriHCXwH+NVQIjHf6cG4hQQrQgghhLvcBdwD3DaUSFS8R1wrkmBFCCGEcJ8bUR2XfygLbqXPSiv6mtMDEKIe7I0IJ7rOBrqCzzk9JiGaKLN+5d+ALwOfcnQ0DpNgpcUEIrHbnB6DELUwDb0NuBZYgSrnbDMNfe3so47YhXoBF2K6OABcA1wzlEg82R2NfsfpATll2k8t1YNp6PNNQz/TNHTHF0OlkvGTUsn4SU6PQ4gaXAtcCswCAvbtpeOjB04afWnvLEdHJkTzpYAvAImhROINTg/GKRKs1Mg09ItQ+zrcATxj/91JN9h/hPAcO/WzAujMeajT5/cf+eITz4UcGJYQTtsK/Cfw06FE4linB+MESQPVwJ5JGUR98st84vuxaehXoKbv6ikEyG6xotUtQqV+prCw8HW0aU0eT8Plrs1xejyivgb6BjXgB8Drl79rwcKZfstf5akeAW4HfjmUSJzdHY3uq9sgPUBmVmxVpnK6gNGc+yxASs2EqM4WCnyI0tBI7xsdbvJ4GsY09DbT0NcA24EHge2moa+x1+yI1nEh8DrgSx0dvp1Wbe+7v0J9aP3mUCLRcoF7MfJLwUQqZxAVeHSYht4TDIVvKuOpm4COnPtGgfOCoXBdN1wzDX1dPc8nhBsFQ+E9pqGvRa1ZyU4FDQ9vf7HNSqcdGllDZK/NybjUvl3V/OGIehvoG+wCrgcSwFbNxxjjNZ+2H7Xotg9VLTQtTPtgpQ6pnI3AK1EzKpr991tMQ6/3UCUNJKo20Dc4kWro7e9x+8/Ravt2ohoI+G5q07aVmt83p0UCdz/q03bup+xOYIVp6FdLSsjbBvoGDwN+DfwSeKqOp96HCn4SQ4nEM93R6K11PLdrTftghYOpnOxPN5lUTjnByg5gt338vjKf00hfqPQJqWR8PurfYVMgEqvrjJBw1kDf4JQy4IG+wbXA6t7+nrxrQ5wWDIXHgFWmoV9N1lqOke27P4hGq1QDdVC4DHsM9X0/2bzhiHoa6Bs8FEiigpRGtJPYhgpY/msokXh/dzRa90/HbiPBShNTObUo99NkIBL7fSXnTSXjk1JgqWS8JxCJlZMCE97g2VSDPbMw8YY9a8Fhj9n3L3dqTPViL6rdDnmDrzbU2h3hQQN9gwuB36GqRAcbeKmngK+gKoQu7o5Gkw28luM0y5IeS7lrVoBy16w0zbYHb9usWek5s3YZRolD59i35UwhtwNnMXkqegRYLDMs7lZOBYmd+in0hphG7T1Sewa9SV7/lkOW+v3a8MnveN+RTo+lHuzFtVPW5gDfDYbCrg4kRX4DfYPdqLTP74Gf5T4eeX/weg6MHv3C0F/fXcfLngx8GrisOxq9pY7ndRWZWQGCofBNpqHr2KkQt8yo2OtpuoBNFSz7XmLflgpqQKWucqPVUfuarvg3EJMV6u4KrLbTJ9kKlgGj/t87UMGpJ+x/dssstCmzoF6Wd21O1v3CIwb6Bn3AJ4DPAd8E7m/i5f8KxIHrhxKJ+d3R6DebeO2mkWDFZgcornmDzp3tsdo6N1qwPhCJLS/2vFQyvg6g1HH2sfNRU5XZn7w7UKkx4U6VpHUKlgGjfq7CHlhsO8G4/rrdTo+hngqtzXF4WKJCA32DxwLfA44E/h9qPUmzbQSuBmJDiUSgOxr9sgNjaCgJVlyoQIXSq1BdDOsmEIntSCXjPeSkwCQF5E5Z3V1z0zqdwOWmoZ/GwbSO/4IVizse+tMLL25ev3dGOn0w1efzkV50XOeuM984//YGVK01jOb3zbEs76StypW7Nkd4w0DfoB+4HLXR4K3Adaj0qlO2AZ8FPj+UEqPD9QAAIABJREFUSIx0R6NrHBxL3UlTuCo1eD+gLqY2mwNV7lhX9mLaxcBbUGtVXLVWR0xSTlpHQ6UCXwcsPf31hweXRRYM+/2k/X5t3A5Uti4994gNTRqzEC3HXpvyIGpW82rg5zgbqGTsQqWEPjeUSJzt9GDqSWZWqlBDE7lybWJqhVIaWF/Ha0ywZ1JkNsX9SqZ1gC8BZ2B/ENE0jQVHzfK9/R+O+fat33vu68CWd/7zRZ5MNZh3/19LpYGE9wz0DR6Jasj2duBHwJ3Ojiiv7ai01FeBZc4OpX6kGqhC9kxK7jqPNHAf9e2xMp/Jzeb2AS8GQ+Gjiz0plYy/DiAQid1Tx7EIlyhWQYL6hFdN9Y8fFRyPFnjcFfbtSi3Fska6whcscHosYnoZ6BucgVpAexUqQLmZKhanN6gaKB8/aoyHdUejnllEX4zMrFSui9qayJUrt9ncKeU8SYKUllesguR4Kqv+0YATgIUcDIq3Ahso3LDMMTPnBcbJnx4VoiHsTQjfA3wdNbN5FXVeO9ggAdT7kdNNSutGgpXKbaLGJnLZJckVPGddOcfJzEprK1ZBYhp6yTRRdrWJPUszkTKyzQUecWOfj413/PzPTo9BTB8DfYOvQe3DczTqA0E57SDcwIf6MDPYHY26skt1NSRYqVAwFN5hGvqUCpoKgo5Gr3f5kn27vI7nFC6Tr4Kk2CaAqEZj2YFKJZVFrvDyhi2nWhbjvMXZcZTTkE94l90q/wvAxcBPUe0C3LB4thyzUBscgiqjbhkSrFSh2iZyNW6aKBsZinKU22ispRrGNUOFDfmEBw30Db4PtUvyw8AVQMrZEVXktagPKv8NXNkdje5zeDx1JcFKlapsItdF/vUu81AlZy2TXxTOqKDRWEUpIzdwQTWQZ/dZEsUN9A0eDnwbOB31//xXZ0dUkVcDF6E+YHyoOxr9g8PjaQgJVpprE1PXu/hRbyqLKbInUblrVoSA0o3GKkkZuYbPN0vT8Nf6u5A+MOYfG9nf0TZrxqivva3cVJcf1bsmtzdVJ7DCNPSrXflvJkoa6Bs8G7gFVdH5SbzzoXEpcAFwKKox3Q+7o1FXpW7rSYKVJspZ7zKGWrENcIh9WywlJGkgUW/Tam8aK53Wdj668YRhc9dCTcOyLLTO4Lyth5963AbN5ytV/dRB4QqpMdQHDulC6zEDfYMfQVX69KOavLldO2o94ttRHyyuAW5upYW0hUiw0mRZ613OB9ZwMFCB+pRAX1nDcyfY+wZ1AZuk/X5r8treNIeddMxfAIKh8PJqnj+USExUP2XaSw1v3Tl3eOvOR7qj0aJpHHtRbaEeNm2otJrwkIG+wY8D/45qUb/Z4eGUcgjwNuA84M/AZcDvu6NR17UYaBRpCueQAs3lRoDF+RbsZqa+q32hrkQqGZ9UsYTaL0ja8IumKFRt89xdt2+2xtNzzHseq6aEtFAaB9Tv3YLuaLRooFasIZ8bS71FYQN9g29CNU37DE3sm1JFU7iFwLuA16NSVdd2R6OPN2yALiYzKw6ptARaGxteolnpOZldlYuYa9++WOXQ2oGzUC/qmUBqMJWM6zLDIhqpVLXNvl2pGaStal+z6pHGmVZps1Zld6P9HvAN3Nvg7SjgQuA0YADo6Y5Gtzs7JGdJsOKgckqgsxrI+bTyTrvYvq02WJnJ1Bf1UXsMEqyIRipabbP3ue3twFh3NLq80hMPJRI1p3G8ljYTBf09aofih50eSB7zgA8CZ6J+Hy7ojkZfdnZI7iDBisOKlUBPaiDX1hlIwxOBSGx5sfNlZl5KHVfk+fnSUx2oSiYhGqKcJnWa3zfHsqprVNcdje4ZSiQKVj+VSgFlK1VpJVzvrcADTg8ihw94J/A+4DvARd3RqNOl+q6SL38rXCCngdyhqP+rk+37G8ZO9fSg8vgv2bc9kgISDXYMhT88ZZrU1Wo1Km0zgmr2NYKkcaajeajXNrc4HPg8cBLQ3R2N/j8JVKaSmZU6qGavnzJ0MbWBXOb+hgYOgUjsplQyPpGekkBFNMEq1HqpfEaBsDWerqliwy7vXDWUSEykcSqZUREt4xngSKcHYTsBtVv6fwLXdEejXmnr33QSrNSogXv9bGLqp0mLJqVj7ABFghTRcHYK6KNFDnkRuL2WNFA2O0BxRRpH9hlyxG+ArwK/dHgcXaiy6RXd0eivHB6L60mwUoMa9/opx0bglaggxQ/sLmPmZmUdritEM5Xap2gzwLxXHzdsWdZw00bVQLLPkKOSwHWoDrAPNfviPiwNtdng3wFXSKBSHglWatNF/r1+am3slrED2G2fbwl5NpbLTUEFIrG/1eG6QjRTsX2K9mHvU9RiW07IPkMO6e3vGR/oG7wCtV7pr6hF1k1hab7R0XTbfuBGVM+UZLOu7XXSFK4GlTZ2q/Fa62ByU7jcFBTQM3vbXXsBApHYbfW8vtsN9A1OTKf39vfIdLrHlNNw7enf3fICmjaz88i5XmiLXkzJBnWSEmq8gb7BbwGnAF+hcA+eunrrB466dv/I+MJXvfX8Oc24XiuRmZUaVNrYrUZLgDlZny7zNm9L+zoe9qVHDwDTIlgZ6BucMp0+0De4Fljd298j0+neUbLh2ssbzYCm4e88cm6ep3uK7DPkDp8A/oTqa3Kjw2MRJUiwUqNyGrs1SN7mbZZ/1kzSo6SS8TOZHpU8Mp3eAspquJZOj1g0Z8uJRpJ9htyht79n/0Df4DuB+4FdwO8cHpIoQtJAHpGbBiqUgpq17Z7nfKSXoPpItPS+Pnbqp9CLfhq4B2qvHhHu0H3SnnPQGF/at2qG02Oplewz5B4DfYMnAHcBPwT+t5HXkjRQ9aQpnEdoY8NLfAf2hFLJ+LpUMr5u9ra7bml/ef1GrHSa9Pg4Vjrd/tLfnvWRPhH1/3oo6k180O5K24pKVZHUo5GYcAf/yKjGeOt0oZAGdS7R29+zAYgA/4jalVu4kKSBPKxjxNzRtn/Xbss/a6Y2PrLPlx6dmeewVt7Xp1gVySgQlsW23pa9JumxTZ1+C/wP9Q2uweNrkmSfIXfp7e95dKBv8B0c7MHyfw4PSeSQYMUjrLbO9RbF9/yxZ1CeZ3In0Fm06L4+vf09e+zFtHmn0yVQaQkTa5LS1sRWni2zJkn2GXKP3v6e+wf6Bv8e+Bmq/f0Gh4ckskiw4hHa2PASzUrPyWxUWEA70+//tGQViSjMzR1U7TVJhTY3XDHQN3i1BKSinnr7e+4c6Bu8FLWZ4GeArQ4PSdhkzUpryVchNIJKA7Wk3v6esd7+nlXAAlS+eUFvf88qL6cImsE09DZ7ked24EFgu2noa+zOqm5RbE1SpsRXiLrq7e/5FRAF/hU4zOHhCJubXphEEeWkgXbe9d1Xtu/d/Jg2+e4OWjQNlM3+hC3T6eXzQsl3sTVJUuIrGqa3v2ftQN/gsahNBj+LWgMnHCTBSoswDf0i5nQNpn0zmZF6GrBGNDXJ0jMNeq2ICtipn0LplctNQz+Nykq+/aigeLTC5xV1wYrFPHDnjl1bNg4vTKcnzQLLmiTRDDHgeOBKmtjlVuQnwYp35HawzTbRzXa8M8jwzMPxje/z+ffvDB1+zqVPNHWUwgvKKfmesg9VHhpqi/uF9vM0VI5/A3V6YV967hEb4AW2bBxeCJYPC9KWJmuSRMP19vdY9vqVPwAfAn7k8JCmNQlWvKkdtT5lH2rDxMlrVXztpH3t+9LtgYAzwxMuV7Lku5zFtvaalzOYvPZtLvBIPRubLVqqFtuGjh/e0tGWTi9d9Qm3pKlEi7O73L4bta7reeBOh4c0bUmw4h3r7dtvkbMXEaAztZvtIcAlpqGvRn36fRm4OBgKbzcN/fvAyajp9PFgKBw2Df1i4FOozq9PAZcEQ+F9jf+2RD2Yhr4A+D3wP8BRlPg/B9YCHweyu8FmOqhOCVRyq4YakEoq6oIVi9l23+OdluWTjsSiqXr7e14Y6Bs8H9Xd1kTt1CyaTKqBvGMJcBrwY9QbxESHWvvxHmAEy0phWZktyEeAW4OhcDeqDO+79rELgfODofDyYCgctu/7MPC6YCi8FLW5V6IJ35OonxOAH9hfl/N/vhr1wpvpoHoAtUB5UnqlUNUQcAxN7h58xGmv2Dv/9FfsrPd5hSilt7/ncdRr5KeAIx0ezrQkMyve4mPqWoAxoGtiQ0VN60JV/5wC/AtwDUAwFL7fNPRMqeeRwL+Zhg7w5WAo/FwwFD4/65z3Atl/Fy4XDIXvNQ19BhX8nwNdWTMmRwBX251VsxWqGirW06fsVFIlCqzXEqIpevt7fjvQN/h5VIXQ1cBeh4c0rUiw4h3rUW8QpzH5jSMAhP5/e+cd5kZ1Ne53cYuBwSZfgKXFtEAogSXAwgQCJguIllC+mDJ0URyBaEmAMSWDwGaHbkCgOJ8Rpg3FQCBUBRZMHVjglw0Qmp1gQoB1TLPlguv+/jhXXllIu9qq3fV5n2cfrUZ37j135s69Z84991zg9eqautnZTOIgYNv56+0xE7CB85ubGuqB45A5V4DbgL8hA1gA/DyXWXNTw/rAjYj3u9L/6NA9N1M6WcQCs9I9b2eq5zTEMjOMlS20y5EdbB8zilG3Me+T/9a2tPBtdU23ZqsoZRNLRm9MxdNbIhaW8ZS2LirdjCor/YctgDWBT4AtC367obmp4eHqmrrZwInm2KWIf8ssZKDaFogDVNfUTcyd2NzUcKTZwflLYCwQAy6orql7ssdqovQk3XnP21s19B/zWWw1ULcz/9Mvhra0MKgn8laUDnAO8AjwGyBZYVlWGVRZ6X/MQxwX8zvtUpsVtlTX1N3Y3NQwHRhTXVOXaW5qGA7sWF1T90pzU8P3kTgCc5DB7VNgt+qaugU9XQmlx+jOe17WqqHeCtnf/PI73/RU3opSLrFkdGkqnj4Ccbg9Cri3wiKtEqiDbf9hBtAE7M93oymWjFLb3NSwF3AmcLo5tDqy2+sLwJPA2OqausXAocDPgCeamxqmNTc1jO/2Gii9Qnfdc6N4TEZWCeWzAJicU0yqa+rmVdfUfdjX9hZSlJ4ilozOBw4Adgf2rbA4qwRqWelnVNfUzW5uaohSsHzZTAHlp5sGTDNfn887/iXyNlCY74geElnpJXronutGkYpShFgyOisVT+8HvIT4ab1ZYZEGNGpZ6YdU19TdC4xCNPpR5ruidDvVNXVLTYC3FRtFVtfUnVVk1ZCirHLEktEPgUOQ/bQ2q7A4Axq1rPRTjCWl2J4/uuRY6XbMFE9FN4pcd9et36pk+YpSjFgyGqbi6dMQZ9sLECuL0s2oZWWAYUW8BVbEUwdZZcCx2uBBy1cbPGh5peVQlEJiyegDwE2Ai4SYULoZVVYGGNlM4vRsJnF6+ykVpX8xZ8anG8yZ8ekG7adUlIpwBfAucGqlBRmIqLIy8DjC/CnKgGLhrK/XXTjr63UrLYeiFCOWjLYgca62BPaorDQDD1VWFEVRFKUbiCWjWeBIZPXcyAqLM6BQZUVRFEVRuolYMvoGsrz/+ErLMpBQZUVRFEVRupfLgO2BTSstyEBBlRVFURRF6UZiyeg84ErgsErLMlDQOCv9hOqautHlpLMiXlnpFKW/UXPG2eoDoPQnbgUSgAVkKyxLv0ctK4qiKIrSzcSS0TnA00BtpWUZCKiyoihKv6Gxvr6lsb7erbQcilImTwLbVlqIgYAqKwOQbCbRks0ktENXFEWpLG8Am1RaiIGAKiuKoiiK0jP8C1i/0kIMBFRZURRFUZSeYS7wPWBQpQXp76iyoiiKoig9gAnBvwRdedtlVFlRFEVRlJ5jEKC7hXcRVVYURelzOKFfVWkZFKWrpOLpwYiysqTSsvR31DSlKEqXcEJ/XeAZWlc+rA4MBU4NbPfNTuQ3CnjUCf2xge2G5Z7XOGbSXsBRwBnAEOD/gGtqp459q41zcrL/BZgBxJG34PeBWO3UsfM7Kr+i5DECmFdpIQYCqqz0Ms1NDXsCDwAXVtfUTW5uajiRgg6yuqauzQ6yualhJDCnuqaupTMyZDOJHwBfWRGvpGkym0mMAO4C1gWGAxcgbwe+kfUb4Ggr4n3ZGRmUAcXmwB3A5cCYwHYfMwrHE07o1wS2W/ZbpRP6PwIagAXAe+We1zhmUi3wOLAGoiz9D3AQcEDjmEl27dSxM9qR/UBkH5dda6eOXdY4ZlIEuAmIliuDohRhbTR6bbeg00C9SHNTw+rARcCl5vuewL7ArtU1dbXA3UgH2R7HAz/vgijHA6PbSXMA8KgV8XYF9kKUlN8BB1kRrxaYCEzuggzKAMFYP94Arg1s9zFz7GNgKfJmWRQn9Nd3Qv95J/Rt831r4Hnz836B7X7TATHeA/5m/j8eUVQAXgb+Xeqk2qljc7J/BFxeO3XsMnM8A2zWOGbSkA7IoCiFqLLSTahlpXeZgGxu9UPk2p8AXF5dU7cMoLqmLtPc1DCuualhSHVNXVtvoxsB6wEvlFtwNpMYipjmARxg+2wm0Wi+L7Qi3rL89FbEuzfv/6+zmcRM4HIr4s0yh0NTF0VZCSf0V0OU8g8C2/2ijaSnAXsCtU7oz0MsKi3A6MB2SyoYxaidOjbbOGbSoYjSYZnDnwJH1k4du7iMLEYBnxQc+xyxLH7aEVkUJY+1ECuh0kXUstJLNDc17A4Mr66pezbv8IaU7iALz9+4uanhzeamhgzwKjC7uanh1eamhoebmxqswvRFWAu4B9Hyd0IUpSxiMWnz7TGbSUQRs/rfzPcRwG3AH8soV1mFcEL/p8CLSHtz2kmeU8jjwHOII+K+ge1+2NFyG8dMGgbcSauiAvJ8TWocM6mcfu7fiMKSzwbArCJpFaVchgPlKMtKO6hlpfc4FNihualhGlANVCGWjlHAu3npinaQ1TV1nzQ3NewB3AA8inTE6yG+L+36rlgR7wvgl9lM4j7gCHP4D1bEu7zUOdlMYgtkWmoWsL8V8ZZlM4kjgIuBa6yId0d75SqrFHsjU4anBLZbjr9Js/ncApgN7BPYbkln2HbYBdjH/P8w8H3EanM4UA980M75WwFe45hJjvFZORCYWTt17NJOyqMoIGPssnZTKe2iykovUV1Td17uf+NUOxj4J+A1NzU41TV1y5qbGg4EZlbX1BXtIKtr6hY2NzUsB64A5ptjHXWy3R5Z+bAh8JNSibKZxHbA7cAZVsR71RxLABsDo62I91UHy1UGPm8hykrKCf3csYMD2y21GqIBsSwuAQ4MbLc9haIktVPHvtQ4ZtKvgeMQi84w4H5gQu3UseXk+xwwE3i9ccykpcjKoN90Vh5FMSxFo9d2C6qsVJDqmrrnmpsaNgdeb25qaLeDbG5qGIVM3SUQx8Wry/BvWUE2k/gRcK0V8SZnM4khwHnZTGINK+IVW30UQZzD/GwmkTu2KzIV9JA5NsOKeKeUU7YysAlsdxowrYPnfOyE/lbm/4VdlaF26ti/IIo4GAWozPOm0Sq7Oo0r3cl8JNy+0kWqWlo6tfpVqQDNTQ1Dq2vqFud9rwIGFyor2UyiBRhnRTy/MA9FURSld0jF0z9BpiXPAdjvyA2vW7Rw2frb7HfgmpWVrP+hlpV+RL6iYr7n9p1YCSviafRPRVGUyvMpRRZMKB1HVwMpiqIoSs/wNeJgu1alBenvqLKiKIqiKD2A2XX5fb67LF7pIKqsKIqiKErP8SayPF/pAqqsKIqiKErPEQKbVVqI/o4qK4qiKIrSc7wCbFNpIfo7qqwoiqIoSs/xEbJTfXWlBenPqLKiKErFaayvH9pYX3+l+X+1xvr6G9pIO7qxvn58G79Pa6yv17AMSp/AONm+CGxbaVn6M6qs9HGymcR+2UwizGYSexb57cRsJnGK+f+lgt+qs5nEeQXHVkpTJL8pZj8gpR+QzSRGZTOJAbHKoHbcuMW148ZdYL4ORfbAUpSBwrPA1pUWoj+jbx99n9OAw62I93kHz1uM7O2jDFx2Bv6UzSQeBK6wIt7MCsvTJRrr618CbkaifS5rrK+fDpwK/Bi4BfgWmAjMM+m3BK5GTOxrIM/KUUANMBU4rJeroCileAG4EGnDSidQZaUPk80kLkJ2kr0tm0kkkd2Ov0V2qD0pL91E4CfZTOIWK+Kdns0kLgZ+CSzOZhIvWBHvorbSAC9YEe+iXq5eWWQziY2B3SstRx/mAmQPnLezmUQjcHI/VlpGAucCe9WOG7ewsb7+QmAsskP5Q7Xjxl3XWF9fhWyWCPBf4Cxz3t7AkbXjxvmN9fX7A2N6X3xFKcl7gNWyvEV38e4kqqz0YayINyGbSewLHAI0AbtZEW9ONpM4DOnEvzTpzslmEjsbJWRnYDeTtiWbSdyQzSR2KidNharZHlsCh1ZaiD7OmsBCwEasCjMrKk3n2Rq4sXbcuNymhk8gG3ueBZzTWF//ICtPD9UAHvAMsDnw716UVVHKJpaMLk/F028sW9ZScqd7pW1UWekfrAWsDzxidjsejGxp/2WRtJsC2wHPmbRrAn/tRJo+gRXxGoCGSsvRF8lmElsB1yKD/KXArVbEW1RRobrGB4DdWF8/rHbcuEXAQcC7SHu/FhgOPAjUm/RjgAtrx40LG+vrDwF2NMcXIzvdzutN4RWlHV5dvqylttJC9FfUwbZ/8DXwIfArK+KNBiK0dtg5BpnPvyNWmL1N2gOtiPd4B9Io/YcfIdaHLayId0s/V1QAvgB84JXG+vpGYEPEh2Un4DHgHsR3Jcf9wPWN9fWPIBaYHE8iSo2i9CX+tnxZy/cqLUR/paqlpaXSMihtkM0kpiF+KzbiszIXeWu8CPgpMNiKeJOzmcR1gGVFvFOzmUQM+BUwH9lE61Qr4s1tLw1wIzDeingzerWSyipPY339KMCvHTfu6ErLoig9QSqe3mqPg9Z7f9Cgqvnb7HfgmpWWp7+hyoqiKBWlsb5+D2ACcHbtuHFNlZZHUXqCVDw9ZI+D1ls8aLWqhdtEDly90vL0N1RZURRFUZRe4O0nH2+pguXbHXDQoPZTK/moz4qiKIqi9AKDBlXNq1qNJZWWoz+iq4EURVEUpRdYe52hb1Zahv6KKiuKoiiK0gtUVVVVWoR+i04DKYqiKIrSp1FlRVEURVGUPo0qK4qiKIqi9Gl06bKiKIqiKH0atawoiqIoitKnUWVFURRFUZQ+jSoriqIoiqL0aVRZURRFURSlT6PKiqL0c5zQr3VCf/NKy9FZnNDf0gn9nTp57hgn9HskuKUT+ms4oX9oB9Kv64R+XU/I0pM4oX+8E/qdilbmhP5BTuiP7G6ZFKUQVVZWIZzQP9EJ/WsKjh3shP6UConUKZzQ/6LSMlQSJ/RnOqGfv8X8UcCXpdI4oT/SCf2nOzsgdSclZDkY+LYg3TQn9LcrI8sDAttd2q1CtvITYIP8A+20vT2A7xWkn+KE/sHtFVTknvYmkcB221wW6oT+pU7ox4v8dCQwp4x03VpHJ/RHO6H/QHfkpfQPNNy+ovR/xlMw2OcT2O43wL69J05pSsiSBhZ3NC8n9FcDzndCf1Bgu8u6Q74C3gfe6UD6Z4B+FwsisN1junD6Re0pOorSHaiyoqzACf0zgZPN1yxwfGC7HxVJNwpIAqOAQcAdge1eWSTdJsDzwMfA5sBbwBXAH4Btgf8AJwW2+w8n9KuBm4FdTJ5PAGcFtrvQCf1dgUmmvM/y8n8HGBPY7nvm+03AB4HtJp3QPwCoB9Yxdbk8sN27S9Q7C0wDdgb+CVwMxIHdkLfG3wS2+6IT+jsA1wP/Y2S8OrDd24vkNxq4EVhmyn8J+KORZ1NkADwhsN1PndDf0tT7x8hAdw8wLrDd5U7o7wvcAIwEZgFrB7a7SV45vzC/fw2s54T+bYHt+k7o/wPYGPinE/o1ge1+7oT+F4Ht/qDce2fyL7c9bAM8AgwFXgOOBjYqVU6eLDsA/wcsBUY4of9sYLtnOqH/FPAzYJoT+gcGtttYpMxzgbFIe9jICf14YLt/dUJ/IfCuqf+egGuu308Rq8d9wDnAjkambUx+I4F/GXkBJgL7AEOd0H8ZaQNfmLRVpm6bAIcD1cBtwBrAMCf0pwMOcAtieTjECf1TAtt9sNh1ziPthP7PEcXzD4Ht3mnKugQ4zcj/PBALbPe/TugfZeScB9wa2G59iWP/QNosgAU8CTwGbBfY7u9NndYE3slvX3nX+g/A74HlTugPDmx3Yv7zZZ6fks9Xkfys/OsLrLi+Tuj/FrlnX5n8pyL3JcdI5No/Vk5ZysBBp4FWPWJO6Dfn/oA7YUUHvBiwA9utQQaRC0rkMRK4PrDd7ZFB4ASjbBRjI+CSwHY3BO4GXgAmBra7AdIJTzHpUkAQ2O4PkYHmY+B3TugPQTqsiwPbXRv4eV7edwDHGfkHA4cB9zihvz5ibTjYlLs7cKZRnoqxJnB/YLvrAxcCzwLPBba7ETLo3OGE/iCkwz83sN0dEJP/BPN2X4xRwHEmj7eBp4AzAtutNvWZaNLdCXiB7W4MbAGMABwn9L8PTAZ+ba6VU6SMr4GDAtvdE5myOMNYGbYFPgE2D2z384Jzyrp3HWwP44ArAtsdhShay8osZy5wamC7PwO2A37uhP5Gge3uD7wCjC6mqBjeA2oC2/0FMg12vjk+FDgnsN11A9t93xxbDdgGaVcbAmMD230DWOaE/i4mzeHA44HtZoHLEIVyM9Mm/gL4Jl0V8CdgM+DwwHYXIYqcF9juruZaDQN2DWz3VEQ5Oq4MRQXgOWTaaW+g3gn9dYAoMNpcn3WBfyCKO8DVgG1+u7PUscB2tzXtrgb4FLi8DFlWENjuZcA1wIVGUeno81VI0evrhP5QwENebGqBJwLbXRDYbrWRvw5p1xNL5KsMYFRZWfVI5R5+0wEcB2BMuTOBh53QbwR+C/ygRB7/Ag426aYhb5al0r4X2O7z5v97gTmB7T5uyswgnT7AL4CbjQL1GXAWsBWwPTAjsN3HzDlf5eV9F3CkGVhewADkAAAXeElEQVQjQGNgu18iFpFtgDdMfv8AtkSsF8XImrwIbPcFU/7d5vvfEevK+sgb+5lO6L8OPA58H1i9RJ4vBrabm0K4D3g/sN3/l/d9Ryf010asOQ8ZOf8N/C+wNWIVeDaw3XfNOZ8UKeMb4EYn9N8GXkTuwfAS8uQo6951sD08BJzlhL6DDIbllpNFFNJ3gEZEwSvXWXMJ0OCEfhOiSOXO+zqw3RcL0t4a2O48o1jcjShPIIryCeb/o2lVnH+BKK2fmvtyFdJ+QO75rxElcpE59i1whBP675i2UduBeuRzZ2C7LYHtzgTeQNr/L4EJge1+E9juciABjDZt/j7gJuBnge3+x+RR7BhGEXgAmbb5eydky6ejz1chRa9vYLuLgacRy8mPA9udnSf/SFO3E/Lrpaw66DSQAoB5W/oj4rD4vpnKKOooB0wAFgB7BLa72An9aW1kvcKXIrDdpU7oFzpD5ua7FwA7Bbb7Wf6PZoqh6Jx4YLufOaE/A7G2HItYWnJ5vRjY7n5tyJXP4oJ596XmL//7YMSs/xRisl7qhP7MNvLM9yEpld9CI+vGge0uyT/ZCf3Dad//IQXcHdhuzjqWL0+pc8u6dx1pD4Ht/tkJ/b8hU0avO6G/JzKotlfOeODDwHaPN2XmpylZdzPw3oVYXj4wb/RtOVvm+7MsorXfuxN4ywn9qxCl+VlzfAFwSGC7rxTJay4yFeMilkEQxXoYsENgu8uclR3WO+vPkWsjhX10FfKSuVpgu783U6RnOKF/ZmC7hxU7Zs5LItbCqeb7EmR6Lkd7L6759Sj5fDmhv1sZdSt5fQPb/bUT+vsAf3BCf3pgu+ca6+U9iKWu2D1RVgFUWVFyVCPzxNNN51DTRtpRwBQzCG1gzu0qjyKWlfOQjvQoxNfjNWBTJ/T3Cmz3eSf0f1hw3u1ADPFxON4cexXYwQn904CHjbwOcIF5e+sso4DQKCo/Qub/O01gu986oR8CNzmhPwHxSTgJuBUZOG9wQv9oxB9kkyJZVCNOoDiycmatvN+yyLTBvCJ1KOfeld0enNAfbqwBl5j7U1NmOdVAg8ljE1ZeeZOTvxirI4P2p0Y2u5RsbWH8Pl5DLCp35ymsjwJXO6E/FrkGvwRmB7b7ENI2TwBec0L/ucB2nzX1mG4UlXWR6bxy6lEOjwOukXM+cBHwvClreGC7rxlZPjJTlUOLHDsNWA/x8cnxN+AcJ/SHGQvRYbRNfj1KPl9l1qnk9TV1esYJ/ReRqaJzEd+VGYHt3prLILDdaYjFTllFUGVFyfF38/cR4gvxbhtprwYmO6F/BeJb0h2rAc4DrkOc7VZD5u/vM4rBccBtTugPQzrZfP6MWBjuyFknAtud40h8jOvM36eIUrO8izImgAec0F+E+EwsaSd9OZyEOOM2IW/9TwDfBLb7jRP6Y5C6pZGOu9Aq5QH3O6HfglyXfEXsDmTA2h5xzs1NWZR77zrSHk53Qv8IZOpnS2RKp2g5RrnIyXIlcl+vAqazsgUkAO51Qv/gQr8Vc20mmXOyiH9LZ7kNeBA4Je/Ytch0z1OIP9MriF9Orvw55t782Qn9nyEO0lMdWbL7CSv3qw+aeswBdkKmA++gfP6I+H29BwwxsuRkDYyVaTBiNVnmhH6xYzcgSuvnTugDPBnY7klO6N8KvGysnbPakeMJ4Ckn9L8yfitdeb6KXl/jd9bghP7niAJ4l1F0zwe+MNccxGfoUcTh+8wyy1T6OR3adTmbSayHPLQHIHP4P7Ei3sedKTibSUxB3lBsK+K92pk8OlDWIMREfTTiiLgW8F+kU51oRbwXerJ8RekMZmAfHtjufCf09wDOC2z3kE7ks585t8eWL5tpo3WAd4M24p70hiwdwQn9s5GpqjHtJu56WfsBcwPb7bb+zpHVZC2B7U5v61h/wbT5HwPzAtv9d6XlGSg4snrriXaSHR3Y7r0m/X3AEW2kXRTY7oqYQk7ofw+Z1j0GUUCfA84OClYPOhL88Q3gpcB28xdLtEvZlpVsJjESeB3xqF+IvC11xaTeK2QziaGIKXUfc+gL4ENkVcBhwKHZTGK8FfH+UCERFaUUuwDXmbfy5YhJvEM4oX854nx8cntpu0Igq44KVx5VRJZycUL/YmSFyf/2UpHTCzvvrhLY7oflHOsvGCfitqx4SufITcPORhz5i5G/eCGX/j3Ex6iQRQXfpyLBHb80f78EfuqE/vYFiyJyfdgNZcq9go5MA52OKCp3A6daEW9hRwurEGciisrXwJFWxHsaIJtJrAaMQUy4l2QziX9ZEW9KxaRUlAKM78HuXczjElodQStKX5IFILDd8cjbYG+V162KiqJ0gJzykQps1+tA+oPaa7eOxAY6GHFyP8b4qV2IOPOfjnnGjPX1CERZ+nNHK9CRpcs5k02iHykqIPETAC7MKSoAVsRbbkW8+5BldN8CE7KZxJBKCKgoiqIoPUhO+SjXbaMaseaWs0x8V/NZn7eAoR7xJ9s1L93piN9VMuhExOmOKCsdrWxfIYVYVx4q9qMV8d5CnOA2YOULqyiKoigDgdz43a4fkBP6wxG/zs8LQyqUIKeg5K+OHIYoJktMnsOQ1WjzkWCXHabdaaBsJlHogbsom0kA7G1FvGl56VZHlpDmgloNR4JrvQzcaEW810sU8ZtsJjEJCUM+BNHkHgOusSLepyXOKRsr4t1VRrKc9rhhV8tTFEVRlD7G+ubzP07o15rv3wBvBLY7v0Taj53QH4EEOVwT8bkqtlfWM+bzOif0j0H8Yq5FQjE0mN+OQRzwU4Htft2ZCpRjWXnT/H1b8D2bS5DNJNZF4mFcg8Q8WAbMQMKTHwu8ks0kTiuR/wnIPjGLEUeeLZC9O97MZhJtxfroTmrN52dtplIURVGU/kfOshIiY/XDSJyaT5zQj5VIuwOyIOWvyMzE207oNzoFu6GbKNvXIJGh3zPnnIAsyMlZUc5Cwhfc2NkKtKusWBFvZyvi7YyZ/sl9tyLem3nJ0sheFM8BO1sR7wdWxNvOingjkGXOnwE3ZzOJYlu+XwCsY875H0RxySBBjAKzmqfHyGYSByB7cXyJKGGKoiiKMpDIKSAjkHH6NiS209rALY5sIFmYdg0kPs99yFYps5EVii84oZ8f+JDAds9DrCePI0rQpcDege0uckJ/b0TxyQSt+3V1mC4HhctmElsDByEBmva3It5Ky5mtiPdUNpM4Aol6eDZwakEWL1gR7+u89O8aBeJVxOJxIKIFdjvZTGI0chMALrMiXrElWoqiKIrSnzkaOBG4MX/vLCf0o8jeWhOc0L/f7Lv0LPA7JBL1mYHtzjFp10K2ufglspnkwfkFBLYbIMEcCznbfHZpA8ruiGCbWyX0aKGiksOKeK9lM4lZSEj0drEiXks2k7gKWQq1P92srGQzicHIEsqLkP0xbrYiXqfNU4qiKIrSVwlk89jHixxPO7Lz+G+AI4FrA9v9BolMXJh2rtn+42Ngfyf01w1s979tleuE/maIcvM+Mp3UabpDWVnHfP42m0n8ts2UHQt3ngsMtFHHRSpNNpP4FbLL51ZIYJvfqqKiKIqirKLcgygrO7SX0ETT/guyTch2tG7+WYozEXeTG3J7b5mNTscj20/MQawxlwS222ZIlI4sXS5FbupkFq3Ot6X+mjqQb4fXYbdFNpPYOptJPI1sCrcV8AJQo4qK0l9IxdPlrGwrJ5/RqXj6lFQ8vUkqnu5wULRUPD0qFU8fnoqnVy/y25RUPP2dl6BUPL1X3v8npuLpfYqkKVq/VDy9Z0dlLCffniQVT++SiqfXMP+vuM49LUtBuXcV/Nbu/U7F04NT8fSULpS/0v3PtbUO5nGX+Rxh2tkG7Z2Td+46qXh62/bkKnHuSrKm4ukNU/H0Zh2RvZ8y23yu2Z3pndC3gCgSkPUOc8xGVg/VmM9ZyJTTfe0V2h2WlVxo56etiHdcN+SXI9fgyglK0ybZTOJUJFLtEMSEdb4V8e7var79GbM30ylWxFtqpsUmWxHvxMpKVZpsJjEekXFmNpPYBXjXinjzs5nEJkg9Lu5FWcq+XtlMYi8AK+I9391ypOLpauTtZsNYMnp7d+ffBqsDzbFktCwfr1Q8PYSVQ3l3lMKdo/sDi2PJaOGS0D5XbiqePg+4NZaMduX+dJpUPH0C8GosGf2gyM9rIG/es4v8VophtLPtQwdYvRvz6svkxtpyY6iVm/4kJF7LVYHt5vqKC5GVvzWB7f4LwGxKepoT+jsGtlu4Ue0KukNZeREJ9BLJZhIjrIg3pxvyBIl2B13cBjybSeyO7FwK4qF8pRXxvi19htIPWGxFvEoMBJ2h7LaWiqdHIPEJ5iC70p4SS0aXFaSJIp3F75G9rXYGhqfi6Y+Qac29Y8mon4qnj0MG+f8gTu3zEGvlxYjD29rIrsqDUvH0Lchz9jAyRToYWWZ4G7A5sn/OlshSxOsAF1iYiqcd4NxYMloYOGqnVDx9AeLQtztwKDAvFU9nESe7E8z3Z2PJaP7U8O6pePpPyNTyBGQH46tMWUuRfUVeBt4GqoApSJCrS8w1q0Isp1cgu1QvMXXd3FgL1kF2915Q5JyrkI1NhwC/iyWjKxSkVDy9i7mGC5BlmY8iMaUsYItYMrpSMEljvRiSiqd/b8o5G9gzz2KwSX75sWT03FQ8fRmyAnI9JM7UC8iu2vOB2bFk9KJUPH29KeKvSADLGlP/r2PJqFek3GIcmoqn1wHWNddzW2BuKp4+CnHC/MrIuBlynxeYa5RAFOPTkLAVmwCH8N32AvB/qXh6bWTxQjNwQiqe3tvkFYslo/kbXW4KvJyKp0cjbXo2MNJYhy5FXAeOScXT58SS0bl51/hIc+3uTcXTl5hrtoORcc1UPP04EvNrKK0b+N2aiqerkOW1VyP70yxE4oqcYe7T2ql4+hHg17Q+W3+MJaP9drNbJ/RXByKB7X4nxL0J1nah+fqAOVYLfBXY7owi6W1khe904K02ylwNmQJahhgKcvwI+CCnqBgeQ9rVlsju8UXpsrJiRby52UxiIuKs+kg2k3CsiLciXolZenwEslvzQVbEm1mQRTSbSUy3It6XJv0wpCHtg3RWf87L5/tWxGvuoIgnI9Nd11oRL9HhCq5CGIvFik7ZinjjC34/Gwn4Nx/4f8iAsKLTRpytCzuvsxAn5jnAB1bEu6kgz98j0YN/ANyUHzwwm0lYyDr9xUgnNNlYWIaY81YMBNlM4i7gYiviHWvOvQuJ9ZPr0AcjgQqzyID3ABIbYDhizjwfGeTaknWlDj2bSRTr0J9GBtObgbML5LnYlPFfZNuKwuBIc4GXkA58FyRIYX7EyRpgaSwZPTEVT68F2LFk9PhUPD0IuD2WjB6biqfPN2kPQJSCe819akE65c2RTnoLZGCIA2fFktH7U/H0r4BRiBJTBYyOJaPXpeLpaUASGTwSwPhYMjo9FU+fDOxFa1CoHDeZcxeYN/dcR78p8izeDvynQFEBeCOWjJ5m6nYlcq8Ky5oVS0ZPNoPOFKS95pZg/i+ieKRjyejkVDx9GjAa+Ke5Zmsiyla8yDn3xZLRa8012B/TcRs+RDrnYcC+sWR0fCqePh0J2XAs3+UZZBuP5cCe5nrPjyWj76fiaZBQDivKT8XTmwLLY8noWDNob4H0p7FYMjo3FU9fnoqnt8CEc0BCO+wKXB5LRt9MxdPXGgWksNxiPBlLRs9LxdPbIw6VOQ6JJaOHmKmSyeYazUeehbWRtnc8cFwsGW0xitf+FLQXk9epsWR0aSqeDoA/IW1zslG0R/Pd9gJwCvCrWDK63OR9AjA1low+nYqn65AxJD/y6cNI/3IvsH0sGb3cKMOjkHZzmEl3WiwZnWemHU+PJaPzU/H03Ua+Z4Adkf5re1qfi0UUPFu0tuF+hRP6VcgYup8T+hOBy3JB2ZzQ3xxZCbQj8Ehguy87ob8N0r6WmPgrDwe2u8zkczgwCXmGL8j5oJTgIORaTi3YPfsD4EAn9PcJbPcZs1tzLgbbd5SjfLrDZwWkE3sQ6UxmZjOJhmwmcUc2k3gC0azvRDZB/GmRc08GPs9mEq8Yn5JmRCP7FjjWini53R1fAz7LZhId3SH1h+bz19lM4o12/tp1MBpgTMhmEj7yFgutnfIXwL75CbOZxAikA2lGOgPbinh/RyxgS5BOO9d5fYEM6KPN6edYES8O7JTNJKoKZHgOeev/Chlg8zkKmGSmF3Oe7M8gnUn+QPCkFfFKrd+/zIp4ZyHK0Nnm//2R3X/ftSLeb5A32Jwlry1ZD7Ei3iG0Lr/PdejfmO81wEdWxDuxRMTmNYGlwC1FFBVM/X+APE8v8N3n80Pg+2YOf4n5y5GT9SVj8fjEWDy+BR6PJaOXAlfGktF3jQy59E8CB5tOeSEykCaQQf32VDw9FLnGZ8eS0YWI4phTMpYhyl0hb9C6AeNyYIopP2GmG/LLzyf3rC9AlMhiZc0BiCWjLeb7KciU1GWIkpjP8gL5qpComsXOyVmE5wIjC/K5CJgWS0bHIy9QIA6CU2LJ6PT8hMY6djpwOdLvrVakvoXlr2H+8llCq99eru7HmXxyS0BzMmcRhb+w3GIUXuMc3ytItxAIzX27HrG8jUQsFflpVmovBXkML/g+hNIvyIXlt9nOYsnoImBWKp4+hlbru48o1RNorX++ZTNX95ZUPL0NEl8rAfyFle9TqWer32EUiluRfuocYJYT+h84oT8d6U/2Rpxkjzen/BOxdKyDKOyzndB/G/EteQBpA+cUs9IUcI75LNxdeQJyX//qhP4HSPs5GHgssN0245x1i7JiRbylyA7GYxAT5XbIQGMjq3ouBLawIl6x/XmOQZxvNkOsKUuA+4GdrIiXr83+GxkUvuigeLmHYxTifdzWn1UsgwHMRVbEc5HOGPM5zVhUPilIuxh52K9COsSrzPHxwBQr4k2ndOeVPzVYOLglkLfoJN9tj4NYuXNrbyBYBissMjlypuMFtDqDD6F0Z9iWrEU7dCviXUprh57fOebkqQLWsCLeO4gz2UnZTGI/vssMYA9kMKor8vsCxGt/IvKc/N1Mm9yOvCGBXJcbEasDSOdwcyqefg+4OhVPDzPlOMhUwIfINOllSGjsNc2xBuTNyEMGwkuNf8EtgJeKp/+IvHw8V0TO3wInp+LpjU2+f0nF0+8jASBBLD3np+Lp9vqfcsp6CzgqFU9PRN4QMWXfhpjxnwU2ScXTN+Zdm2LntMXrwLlmGmaTVDy9LzJNcFQqnp5QkDbXxq6mVamdBdhmgPyOzLFk9B1kqutBxPq2CGlPfzJ1H2J8Oi5CpjqKbUNSrNyO8Ggqnr6b1iWrSSBu2s0kZFryKuChVDx9D+KLUKy9AFxr0jxmvh+ViqdTiOU1F369kDRwXyqevgF5zu8Hjjb1P5bWeFj53IY8C7nYHh8i7e3KMuo7C3mRvR4Zt6D1ubAoeLZS8fRZxnrV7whs935kUcn1SB03RJ79RqSt7BvY7lyTdlFgu8chL3MPIf3Zlkh/cy+wW2C7hQrISpgIt79AQvm/XCBLI/IS+yKy0vdbpM0e0V49qlpa2rLk9C7ZTGKQFfG6dRWQUpxiDraI9eIw5EHexYp4exScE0emdZYindrHyHTHs0gE4EuQDuRnyKB/BjJNlCtnRZl5eU5GOufvAZ+YgT/32wgj12xEmTwWGXw/Q6Y0ngTuRsyWcWA/ZKphdeStbgZwlxXxZhTU9y7E+esaxLS/BjKdM6EdWaOIEvEl0lmPQ7zY10GU6WOAiXlTP8cBuyFK1abmWsSQDn4SYjk8r637pHSM3DRKLBnt1GZplSIVT++EKIXbArfFktFZRdJUAatXyHEXM432K4zVIZaMTq2EHMqqSZ9SVhRloJPNJIYAVVbEW5zNJPa3It5TlZZJURSlr6PKiqIoiqIofZrucrBVFEVRFEXpEVRZURRFURSlT6PKiqIoiqIofRpVVhRFURRF6dOosqIoiqIoSp9GlRVFURRFUfo0qqwoiqIoitKnUWVFURRFUZQ+zf8HZ2nlMFduC8kAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 5\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 6\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 7\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 8\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 9\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAFaCAYAAADfOB3RAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde5xbZZ348c9JptPOMAFKb2mBtkC5I4ZbtIpYNmAAb7iKKP687IBCZQCtu0rQ3Zjd1aDrraU4W62jrnJxWV0VvEQ9a9ViMaAc7ogtbbm0py29QKYz7Vxyfn88J9NMJpncc04y3/frxWummeTkqU6Tb57v5dEsy0IIIYQQwq08Ti9ACCGEEGIyEqwIIYQQwtUkWBFCCCGEq0mwIoQQQghXk2BFCCGEEK4mwYoQQgghXE2CFSGEEEK4mgQrLpRKxC5yeg1CTGXJePy8ZDzud3odQghFghUXSCVis1OJ2Dz7+07g8qyfeVOJ2BmOLU6IMvX29LXX+zlMQ693QP+/ZP07FEI4S4IVd1gBpO3vLwU2Zf3sfcCshq9IiMq9t9YXNA19tmno8+zvxwX0pqF7TUOvOKBPxuPTk/H4J5LxuHeS+yxNxuOhSp9DCFGdNqcXIABY6gtHb8l8D/wt62fdwJsavyQhKnZ8Ha65Aviq/X2+gH5rFdc+CYgC5ybj8d8CNwFHA19KxuMXAD8Bvgn8N6BX8TxCiArJzorDUonYEqAz6yYvcK79s07gJF84OuTE2oSo0Gt6e/pm1viaS/2B0K7M98BA1s+6gQ2VXjgYiTwGXAK8C1gN/AK1c/Nx4BTgbuC3wLWVPocQojoSrDjvCOCUVCLWZf/5fuA9qUTscGAGMN8OaIRwvd6evjnA88B7anVN09ALBvR2SugkfyBUbUB/mH3dS4ORyD8GI5GfBCORbwKvQQUqs4ORyGiVzyGEqJAEK857AvUpMWr/+SdAP/AhXzi6B0gCX3dobUKUrLen7xjga8BngJm9PX21CliOAE4xDX1cQG8a+lhAbwc0ZUvG47OS8fhs4B+AnwUjkXFpnmAkMgx8EnhdMh4PJOPx2cl4vKPiv4kQoiISrDjMF44eAD4FfCyViB3vC0eHUfnxD9p3uQ64MJWI1bxoUYhq9Pb0Hdnb03d7b0/fj3p7+h5GBdX/tHx1947lq7s/D3h7e/qe6e3p+1VvT993env63mI/bmmZT1UwoPcHQtUG9C8Cu1BFwU8XuE/m9oft+95U4XMJISokBbYOSSViGnAlEEB9Ev0UcDbwLHAX8DEAXzj6cCoR+w7w+lQiZgGLgW/6wtHdDixbiDHLV3fvA67v7enrAo5DFb5+qren72PAW4AQ8FHgSWDH8tXdmTTK31FGjYk/EDpgGvqngG+Zht7rD4SeNQ09E9CvQgX0SdPQ3+sPhO4q869xNKABtwGnFrhP5vazgBeA/WU+hxCiSpplWU6vYcpJJWIdwA+BNb5w9Cf2bXcDn/eFo4/aP/+9Lxw9z/7ZcsDjC0dvTyViRwPfBqK+cLTiokIh6qG3p+984Ezg5OWruyfsQPT29J0FfBkILV/dPemLj2nouQH9I0DUHwj9j2nopwJ/8gdCh9v3/SZwEFiPHdD7A6GSA/pkPP4m4JfAxdmpoGQ8Pg34FdAejEReX+r1hBC1JWkgZ9wAPJ8JVGzTfeHoo/b3pwM/zvrZGaghVfjC0ReBzwJrG7BOIcqyfHX3euCd5Px+9vb0ndTb0/cZ1A7GKmB9b0/fh3t7+mbku45p6B3Az4BBfyB0sz8QGgEeA56x77IF+GvWQ/4CPOUPhO4GvgfcZRp6OemmFDAK/DwZj/9HMh5/ezIevwb4E7AMeGmyOSxCiPqSNJAz5gFzMn+wO4Gy8+Xno9olM6b5wtFtWX/2A/PrukIhKvdXVOoHgN6evv+3fHX394F/7+3pewSV4rxo+eruwUmucQPwvD8QGhfQ+wOhyQL6zwH4A6EXTUP/LCpgOr3YYpPx+KuABGq38/+AHuAfUQHMT4EvoOrI1gDXFLueEKL2ZGfFGb8B3pFKxKKpRGwGKgf+xayf/5cvHM0eepUZGEcqEXsb6kXzNw1ZqRDleyyrPgVU+y8Ay1d33wv8vkigAjkBvd0JNGlA7w+EKg3onwH+FXhfMBL5RjASORNVePvJYCTy/4KRyA9Qc1jKrYcRQtSI7Kw4wBeO/iKViK1BpXM+itruvj+ViD2D2t5OpRKxaaj/f+ai5rAsA96OKvbbjJroKYQb3Z/5pren723Aqb09fccsX939gn3zL0q4xm+An5uGHkXtbEwI6O1OoIyxgN409LIC+mAkchD4UpH7/LGUawkh6kMKbB2USsQ+CPw7cEyJDxlE5eNv9oWje+u2MCGq1NvTdxlqCuwiVKfb11Fplp8tX91dqEV4HNPQ/xM1NXYndkCP2gXZgkrR7CcroEfVlmQH9Bf4A6EXcq9bimQ8fhbwYjAS2VnJ44UQtSXBisNSiVgbquXzLaipnAtR0zTTqNkSz6MKCzcAP/CFo/scWqoQZevt6TsZ+A7w+uWru9NF7j6BaegVB/T+QEgCeiFahAQrQoi66u3p+8zy1d3/XunjTUMvK6D3B0IS0AvRYqRmRQhRb7+r5sF22/K99n9CiClIdlaEEEII4WrSuiyEEEIIV5NgRQghhBCuJsGKEEIIIVxNghUhhBBCuJoEK0IIIYRwNWlddqFUInYlwP555y8H8AdCyxxdkBAu87ef3vUEwIlve2/RgwqFEM1PghUX8oWjPwDYb+jLnV6LEG7kWzh3l9NrEEI0jgQrLpRKxI4FYN75Dq9ECHca3n9gutNrEEI0jgQr7vQ9pxcghJvtNjaeCnDs651eiRCiEaTAVgghhBCuJsGKEEIIIVxNghUhhBBCuJoEK0IIIYRwNSmwdacv218/4egqhHAp32L/806vQQjROBKsAKahHwF8H5gLdACfAn4NfAG4ANCAH/oDobhp6F7gu8BifyB0vmnoVwPdQBq4wR8IGdWuxxeO3guw39AlWBEij8OOnr3b6TUIIRpHghXlUuBefyD0DdPQZwLrgCDwN38g9AkA09A/Zxr6B4GfAz8Drrfv+15/IPR609APB34M/F2+JzANfQ6wGNjiD4QmHWiVSsROBmTOioMaEcCaht4FLAC2+QOh/nr/nVrJ0Mv7O5xegxCicaRmBfAHQnf7A6Fv2N/vBbYAnwTWZN3tc8D/8wdCu/yB0F32bQeAdtPQ24EjgLxvOKahvwfYinqz22r/eTJrcp5bNF4mgH0N8EbgVuDTqAD2PH8gdC7QZQewR6ECWLIDWODNwFdyL2waeptp6KuAncBDwE7T0FeZhi4fHkq05/HNJ+95fPPJTq9DCNEY8uKYwzT0bmAW8Bd/IGRlbvcHQgOmoY+bmukPhAZNQ38WeBKYDXwsz/XmAH2oT+eZT4N3mIZ+AzCcbw0z2roCWX+UT9wO8AdCd2d9v9c09C2oALYr626fA37iD4S+C9xlGvr1lBbAfgW4mkO/D9h/BrixZn8JIYRoERKs2ExDXwLcBuwALgF+ZRq6xx8Ipe2fHwYM5jzm3cDz/kBoiZ02+KVp6P/tD4QGsu62GBhi/BuTBcygQLBSS6lEbCz95AtH5TyVCtQygLVTP9cw/vcBoBOVWjwLGK3936K1aF5Pl2XJ/071kIzHx9KTwUhEPiwJV5BgBTAN/QxUzcH1/kDoAfu2XwMfBVbbd/sX4Ac5D52JCm5AfYJOA96c+2wB2nNuGwIuKVS7kkqsX1f2XyLvdWLvQe3qDAHtqUSs2xeO3l3kYcJWpwB2ATBS4Ckt1O/KYIGfC1E3yXi8DbXrdw3qd7QtGY+vBVYEI5FCv7OiDKahrwPwB0LLnF1J85FgRQmjAo9bTUPP3PZhoMc09AdRtT0/Bb6d87jvAF81DT2BepP5sj8QSmXfwR8I7bI/mY8FDUB3sSJbAG1kYIlmpbtSidi6Cv5O04DX2mvPfIrvSyViuuywFFfHAHYbhf/dDQEhKbYtzrz/8X1Or6EFSXpSuJZmWVbxe4mqldkNdBHAwKyzv6NZ6a6OPUYl7dA+4NWMf6N8GbjYF44+WMH1phRTtY1fDzyXdfOHgR7gdRwKYP81kxoyDX09EAK+CpyACkxv8wdCP8q59irUm0Bn1s0DwLf8gZC8KZTgbz+9axdpq2PvU1sfcnotLuVF/f4NUVpa0cuh3+tcg8BcSQlVT3ZWKic7Kw1iBygl7Wj4wtHfAOw39I2W+vOycp/PrlV5gfHBSgcqLSWK8AdCX+bQcL5sN03ymEyv+UeLXH6F/XVsux34VtbtoogZR/kOWqPpaU6vw4U0VKA8H5VW1IDtwCb7z4W0T/LzEVT68pnaLXOKsiwNa+TIVCLm8YWjaaeX00wkWHGhVCIWANBmnV1tGkhezF3IHwiNADeahn4LMmelIqNDIyZAMBJZ5vBSXCUZj68CzmX8DslM4JFgJFJw184uqt3JxMJvUO8T22q5zinLGu30jAycCbwe+IPTy2kmEqy409dqcI0ZTKyXGESlonaBdAo5zQ5Q5NNqBfY+ufVVgHfnn+LrnF5LnZWTzimUyukErknG47cUSuUEI5F+u5g2b3pSUkA1o9lf34kEK2WRYMXFrLbOatNAWxn/SakdOw0knUJCuFol6ZxqUzmSnmyMUeCDqUQs7gtHdxS9twCkwNaVMmmfATsNVGGBLcAc4BQOvdg9jdpVye4UyhgEFskOi2gGxu0r9wEErr/pSKfXUg92OqfQLkfedE6RVE7JRbIyZ6V+zL8kHvKMDJzWsffRe4Ejgct84ajMCyqB7Ky0tl2o9tnDgVc4NL9jBhM/gQ2RlSISws0siw7Am4y3ZBqo4nQO8D+oFEPFqRz7fpKerK+7gM8A30klYv/gC0dljk0REqy4WDVpIJiQ6lkEdPvC0buLpYiEEI4qK52TZ5hbu/11EEnluNUo6ryxfwJ+lUrErpRd7clJsOJOtwBoIwP/Xa+hcKlEbMKgOvnHIprFkScf8wTAcRe/c5nDS6m5Cjpz8g1zG0CdAv9RSeW41kHg88BVwGOpROw6Xzj6Y4fX5FpSs+JiOx6694V6DoWTbiDRrJ5ff98L1mi6y/zjE5XWczVCuYPZsi1BFddmp4LSqCLbjTnPIcPcmkRWzcqVOT86HVgOPA7c5AtHN0589NQmOysulErEXgdgzTu/bt1AqOvuAnalErE5qUTsPCRoEU3i4L7+diwr9xwut6h0MFu2TfbXfNfIJsPcWsMTqENP3wY8mErEvg/8q7weHyLBijt9vtoLlJrqkRZm0Yz6t+5oB0bdOBSu0sFsBa41aWeODHNrKSPAjwAduAJ4JpWI3Q58yReOTvmzsCQN5EI1bF0GVbsyAzgADOf5mbQwi6bz8OqVBwHvcGpgvdNrydHwtEwlbc7CGZOkgfKZC7wbFfh+GVjpC0f313WBLiY7K26XHtZQ9Sf5go1SDE/yOGlhFnXX29M3tjuwfHV3q9dPOJGWkWFurWkn6oT3o4H3ADelErEosHYqtjpLsOJi3qF9L7enNs/n0Am+NU3RSAuzqKfenr7cltq23p6+tcCK5au7q3qx1TQ1M8htaSAn0jLBSGQEuDEZj4+dNSVFtS3lRdTOyvHAR4AbU4nYtb5wdEqN68+3VSncYVp7avOpGpYHOAL14tdnBxg1Yad6ulHb0y/bX6WFWdRKdkutz/56tX17S7KDhLWoNEy2AWBtPYOIYCTSH4xEnpFApWU9C0SBnwD/k0rEVqYSsXaH19QwsrPSYKahj7UL+wOhQkHBx4DTQVuas6Nc8xSNPSROR1qYpxzT0MfSM7U+9dlO/VzDxB2GTuD63p6+syi/nXfMGy4+2uv1arkBgVtIWkbU0x+BR4EbgV+kErG3+MLRwSKPaXoSrDSQaejjOm9MQ+/2B0IT0jq+cNRIJWIvgpVpWcyoS4om08Jc6+sKdzINfUJ6xjT0tcAKfyBUq1z4Avva+Vio3+WKX2C9h3WOtrV5KqnhqjtJy4gG6EdNwF0B/AfQ4+xy6k+ClQaxd1T6UJ80M5827zAN/QZyCmC9B16ayRGngJU+MP2VjR0a6VeQKbOidvJNPL3a/lqr7pFtFH59GQJC1RTbPvvLex4pGAq5hJyxI+osDawBvplKxD7uC0ddGbzXigQrjbMY9SKd/QZhoTpyxv2STdv/wiKAA7MCw4PtR77c+VLy7dQwRSOTa6cuO/VTMD1jGnpV6ZmMd1yziAd/u2vPts0D89PpQ7VxHg/pBcd17jnvwjn3mYZe8fVTW8zTLav6ddaCnFIsHDSEapdv+fpTCVYaZwtqdyTbEHBJbu1KKrF+XeZ7y9tOZjx+LcgQuCmvrumZbOdcMHsTvMS2zQPzNU2zLMvSFhzXuV3d3vzyHCDYlozH1wIr7FSQEPV2GZDwhaMHnV5IvUmw0iD+QGiXaegTJspOUmSLNjKwpIqDDPOZ9HDDGj2HcLei6ZlaFtsuOCdTbGstALa99ePvqcm1zfsfd8NEz0ak04QoZAFwOXCe0wtpBAlW6iRf148/ELrbNHQ99/YGkiFwU5w/EOq3i2nzTjytdVcQgF2bUtPaDcuiA/Am4/F1pT5Ga/N62zqmt48MHhyyRkarTSEVmlTbCVyTjMdvkZSQqLOrgLgvHG2JncpiJFipg8m6fuwApaTAwGrrrPggw3xkCJywTa3WWk3TZr3quBM6/UfNt7AsDU0bMPds3/3Y5k1Uft6IHCAonHY68AGnF9EocjZQjdk7KrkBQRp4gBLH5XuG+zsA0tO6Tgb6/YHQMbVaX27NCjWeiiuaRz3nrNTbc7/76Z8AFr7xba8pdl/T0AueneMPhCpK1xSZVFuXM4BE8yvzbKBiPo56r/lIq3cCgQQrNWca+nnAr1FTZzNGgUeAVJmXC1D7YGWOfV0AQ2pVRDMyDf0FoAsodshn0YMFKw3U3HiAoHQmuVuNg5UO1ADRmcAtwE984Wi6Btd1JUkD1d4WSuz6KSSViL0VYP+88z9Ry4Xl21UBZFdFNJ0Bc88MNK2tc97MYnetZ7rGNek06UyakgaBOPAa4PPAV1OJ2DeA//KFoy84urI6kGClxirp+snjE1DzbiDpBBIt45VN29qAkePD71o22f3sVFddDhZ02aRa6Uyauv5k/3cSEAI+lUrEHga+A/zQF46Wu6PvSpIGqpMSzwDKKxOcDMw6e4lmpbs69hj5trqnobp7DlBaLYwPeDVqWzzjZeDiWs5xEaIRHl698iDgHU4NrC9231lnHr+kw3/UfI/XM5YKSo+m04Pmnu27H312Y10XWjov6oPNEOUP5Sua6pKUkPNMQz+c9EjSMzKwqGPvo++u41O1o9qZ3wC8CnXw4apmf52XnZU6Kafrp5BC3UCVFMlKJ5CYqnY/tnnTLCC7G2gw0w3kPA04AZiPSldpwHZgE4XTV7mkM8nlTEOfBvwSOJHx573VwxBwv/3fEcDfAT9NJWKPA9c1a6uz7Ky4UJGdlex0TsYgsKhYOkc6gUSrMG5fuQ8gcP1NR5b6GDd2P9WiSFc6k9zNNPQO4E5gLumRhZ6RwaM79j7y9gYvwwu81f7vTF84ajb4+asmOyvNp+LBbr5w9O5UIjY2lE5qVUSjqCm2KlCo5gDDjEqGwmV77hfJapdQCzUZLBeMRPrtYtpCQY8EKg4xDf104C7gJeBLwEqHljIK/AK4GDgZkGBF1MT7Aay2zu/lpoFSidiHgW/k3L/kdI4doEiQIhqit6dvQpdKb0/fWmDF8tXdFXepHHnKsXtIpzt3/flvNVqpI2qZvnFNZ5IA09CPAj4DfAi4A/iVg8uZDrwR+HtUKuoPDq6lYhKsuJAvHH0eYOChe3O7gTIpoFw3yS6JcKm6dKl0zD7irwDBSGRZxStzWJH0TVmdSi7rTJqyTEOfC9wELAc22N87cY5VB3AWEEQV2/4BuMoXjv7OgbXUhNSsuFAqEbsSYGDW2V/OqVnJ19HzCnBRs1d6i0NqnTJxiv33KPRmnAb+SPmdLwC8/g3Tz/N4tANnXHHVrCqW6Dg3DpYT5TMN/VWoAW3vQgUGPwZ2TLhjeuR2z8jgMXWoWfGgindfDZxhf/8n4Ieo9uWJa2kysrPiTsthYjdQKhE7BTWxMztYmYZ09LSEeqVMHLQA9ffIx0KlQQYrufDwzt3T0Vri9UvSN03K7vC5HLV7chIq1XM9aiREvXlQXWRnAKfaX7eipqd/GvidLxzd34B1NEwr/GOfErI6eTKfRDMv8t2SAmoZrTbYaxuFX2OGgFClO0eZbqBmJ+mb5mOneq5DfajcASRQxbPVnuRdzELUUSmnoeanbAP+z37u3/nC0Zfq/PyOkjSQC+VpXX6Cie3KB4GALxx92oElihqrZ8rEQV7UdvQcxv/uplGzRCoeyBY8uf98NEbP6blxenVLFKI0pqGfDHwKeCdqhsnPUbsZpSsvDdQBnI2qPTkL9QH11/Z/v/WFozvLeu4mJzsrzSFfu/IBVA2LaA11S5k4IN+gMwsVpGQPPRPC9UxDPw74HBBGtf8up/xDaUvVgfpguhS1e7IBVf9yvS8cdcu0ZUdIsOJimZoVVOtbxe3KoinULWXSaL09fauAcxm/mzKAKvb7aC3+Hq2SBhLuZdek3IIqnP0ZKkip1weGhcBbUHN31gO3Afe2yrk+tSDBiju9C0AbGTC00YM+1BkPuaRduYUsX93dbxfT5u0MqWegUsvJrnY66xomprM6gfcBx/X29FWdzrrgzcdpbW1aSxUQCvew61J+itoJXIEa6lYPc4APoOpQVgP/0IzTZRtBgpUyVXNAYakyhVIDD92Llh7yMDEF9AqqK0i0loZ2hpiGPqH7yDT0tcAKfyBUafdRQ9JZnmltlqfNk672OkLkMg19Jqr9+C+o6bP1Kux8A+rf3krgza3WvVNrEqyUwTT0cWfrmIbe7Q+Ean62TioR+xCANe/8jWnNOw1VXJX9SVXalVuQ3Z58Y29P31hnSJ1TP/XoPmpIOuuZ/73jaWkNEHVyO/BX1Hk+9XIhcCVwoS8cfaSOz9MypBuoRPaOSu6pxWngAWC4ls81Y7cRADgwKwDQf9iO9f+IHEAoashO/dSl++jB3+5asm3zwPx0+lDNisdDesFxndvPu3BOTYoEdzzw5PmWxWhg+Q3SDVQle5KutE0DpqEfDzwIXIvquKyt9MjtnpH9x3bsfWwfsFS6OUuXe4CWKGwxKljIZqE6derKDkwWoQ6hWgToqUTsvFQiNqfezy1aVinpmoqcc8HsTQuO69zu8ZD2erXRTKByzgWzpQPIRZLxeJs9QXcn8BCwMxmPr0rG41N5x/0i1P8WtQ9UANAyuwNflUClPFP5l7JcW5j4Aj4EXFLr2pVUYv263NsyBxBmDYcbAtpTiZjssohKFE3XVFNsu+CcTLGttQDY9taPv6emn9jN+x+XbqDqtdoQwlrwA3vrdnWPdyg9zTcA/FvdnqNFSRqoDLk1K0C9albWwbihcJli2sxBhtk7YoPAIukMEuUyDb3guTT+QMjVb1YPr155EPAOpwbWO72WJuVFtcnm210fBOZOxZSQaeg9wGVAb52e4ivAfH8g1FWn67csSQOVwQ5MxtIx1QYqpqHPMQ39PLsephT5hsMNoVJUQpRrBarbaBA15GqQFj+XRmvzeqf5Oju0Nq+3+L1bWjuFu1xGUGnCqWg96jBAzemFiPEkDVQmO+VT9S5Gkc6iywCsts6f5xxkmK/IV4bDiYrY7ck3moY+1n1U7ZyVRpn32lP/BLDg3DctK+X++dq0gWrbtJuWXVRbqMC6DZUmnIoeQf3d3wisc3YpIpvsrDjA3knpQ71QHGF/vcM09PtNQ1+3f975P98/7/yfow6tWpJ5nJ3q6UZ9An7Z/ioHGYqq+AOhfn8g9EyzBCoAnjZv2tPmLWfOSnZ9hs/+erV9+5Rjp3jWotJ+2QaAtVMxBQTgD4Qs1MnJHwLmObsakU12VpyxGLWjkv2pxgK6gL3T+p9bADDctXDCA33h6N2pREy3r7FFAhUxFeRO2X1ls/lqTWM66OtKeHih+oxO4BrT0G9ppkCthho6hLBZ+AOhpGno/wx8FvgXarCTLqonwYoztjCxsyhzQm13+/7nrgMY7lqYdys20xlUzwUK4QaFpuwOmHs6NQ2vb7G/lMuUUp/xTC3W20yCkcgIcGMyHh9LA07VHZVc/kDo6/bZQJ8HvkAVJ4SL2pBgxQH+QGiXaejdHEoFZXQAd4xMO7Jfs0YyL67y4iGmsrzttb7F80g9u73fHwgtK3aBIgPwpnJ9BjCWEppywVox/kBopWnoz6HSZXcBCYeXNKVJzYpD7GLatzMxGLFG2w9vs7Q2qUYXU5odZFzD+NZqgM7OuTPbtba2fMHHBHaKp2B9RqUpINPQu0xDP8lep2hB/kDof1EpxDcC/wgc5uyKpi4JVpxloNI/2bwjnUdPPzjztC7gRWT7UUxdBafsWlh42ssK6GvWpm0aeps9o2Zs8qtp6KvslJVoMf5A6K/AecCjwNeA051d0dQkwYqD7DboTHdPauwHHq8XzeNBHRt+kjOrE8JxBafsamikDwzl7pQU5A+ERuxBd3OBc4G5/kDoxgrblqWzaIrxB0IH/IHQDajX6xXAu5BZLA0lE2xdwG5lvgxYBRye8+Od/kCoqhY6ez7LYqR7SDSZSabsplEHLRr5HldHRSe/1qOzSA4bdA/T0I8GfoTq6FxJeecIyQTbCsnOigvYOyw/R43Tz5amyjSQfZbQVuDXwFb7z0I0i0Lpm5cdWk9DJ7/KYYPu4w+EXgQuQHV1xpA6loaQnRUXGZtqa6U1wEt6OOVJD3uzzgYql5wlJFpC7pyVp3/wnU0Ap1z5oRMcWEehzqKa76zYgUre85uCkYirz29qdaaha6idlYuBKOr//2JkZ6VCEqy4jGnoc2bseeyX2ujggQMzz1iUc5BhuXyocy6yi3hfBi72haMPVr1YIRzi5EGGs848fkmH/6j5Hq9n7ENAejSdHjT3bN/96LO5O6Fe1G7MECptVQ45bNDl7IClDzgZuJXCu24ZEqxUSLYSXcYfCO1KJdanAKy2zo3ZZwOVK5WIfaUcyHkAACAASURBVBj4Rs7NcpaQEFXY/djmTbOATv9R8y0sS0PTBs0923c/tnlT1t004ARgPuoNTAO2A5so/oaWIcPsXM4fCFmmoX8E+D3wDlQti6gDCVZcTBsZWKJZ6a5UIraugodnUkC5bpIUkGh2mqa23IORyDKn1mAaepdmp6ZOePOV/Se8+dDP7PTNuYzfFZkJPFJq+kYOG2wO/kBo2DT0K4GHgb8gHwbrQoKV1jWDiZ/KXqHx3RMNlVvb4PR6RH1YFh2ANxmPr3N6LQDP/SKZ/cdJzyJKxuO3lJK+CUYi/cl4fC2Fa1bk99sl/IHQc6ahfxI1OO5mVHOEqCEJVmrEbj9eDGyxu3uqMQjVpYHsduWtjP9UNo0WjfoLnSEDrKhwloZwMc2jWZSeTmm0WqZv5LDB5tEHfBB4M3Cvw2tpOVJgWwNjXTyqiK4d6LbH6Vd73XUApZx/ko/dpjxuXb5wtOp1udEk8zi+ZQ8DEy2k2n8b9VQkfVNRYazMWWkOpqGfCCSBTwJmnrtIgW2FJFipkr2jkruDkQYeAIarvHwA6PcHQsdUeoGpMBCuSDtpGvgj5XdiCHer+t9GPTVLy7EEQbVnGvoK1KTbTzMxHSTBSoUkDVS9xaidi+w3SgtVM1JRsNKeenYRwJDv+GrXhh2gjAtSWjCAKXiGDOr/i3ZKm4EgmsS+v70wHQvNH3B6JQW5On1jD5Ublza162NWBCMRSZtW52uoieTvA77n8FpahgQr1duCejPMNgRcUmntSiqxfh3AkO/4rVWtLO+1x6eGUolYK6SGCp4hg/p7hqTYtrWY96/c5/QaJmO/4d+YjMdvwZ07F9nnG2VcbX91zc5PM/IHQmnT0N+L6g7ahNrZFVWSNFAN1LpmJdOqPDDr7CVVDoXL1bITbaVmZWpxcihcg1UzVG6ya8qwuTozDf1s4DfAZ4HN9s2SBqqQnA1UA3Zgsgg1dnlRLYprKzANNbE293yhbPnamYdQKaFmV+gMGVdsuwtRJg1YggoqzrG/LqE2J/029HyjqcofCP0FWI5qZfY5vJymJ2mgGrFTPjXdnSi1dbnUrp8C7cwtMdHWbk++0TT0sW13Sf20LjcMhaunWgyVm+TaMmyuQfyB0A/sHZaPA//m9HqamaSBXCiViP0QYGDW2a8pIQ1UVmpnKrUz15sMoHPOI2tWD2DRdnBvqhXrAeqepmmWbqVWYM+A+gPwGHAhkgaqiKSBKmQa+hzT0M+zW5dryheOvtMXjr6zxLuXldqxA5OxlJUEKuUzDb3NrpHZCTwE7DQNfZX9oiQa4KjTF++ZeerCAafXUSeNSNNI2rRB7F3fDwBXMHmaXkxCdlYqUK8hcHmeZx1MPviqQGqnJYpm3UqKeZ3n5qFw1arHULkiz+XGbqWGMA39COD7wFzU/97/jErZgPr3vc8fCL2phOscCbzsD4QKvqGahr4Su+Oq2M5KKhGbDezxhaOTju1PJWIasBJV17QfuA6IAqeiXpNGfeFoqNj6m4F8EiyTvZPSh/rFzryY3GEa+g1UPwQOgPZXNh4HwOFLjgAmfQHxhaO7UolYNxNTOxKo1IGd+rmGiW8kncD1pqGfhQygq7u9Tz/3WixrqJQ5K82WrmvkmUD2tabyyc2XAvf6A6FvmIY+E1gHvMkfCO0wDf39wLElXucDqHPXfj/Jfb6KagsvZeZT5nr/V+R+xwMv+8LR16cSsdOB/0AV817mC0dfKuF5moYEK+VbTG2HwE2zH3sg83jPcP8R5VzAF47enUrEdFpr0JtbyQA6Fxja199mWZN3xjT5eVGuHirXKrJ3xP2B0F7T0LegApQdwOWonZZSHAPMY5JgxR8IbTENHfLvmJFKxNo5NLPrKuDMVCKWOSFz0BeOTvgQ5AtHN2WtcSYqpbcE+GwqEQP4gi8cfb7Ev4OrSbBSvi3UaAhcoXRSZihcOfJNqhV1IQPoXMC8//FShsI17eCzJhgq13JMQ+8GZgEPm4Y+AzjeHwg9Ocn9jwV+DLwErAEWmob+AOpMoPf7A6FUnodtZvxuWbbDgW8Db7H/fA7qYMTbUac5592xTSViXuB3QBC4CDgbNZBuHnAn8IZCf4dmIjUrFahFzcpkZwrN2G2cDnBgVgBcfP7JVCU1K84zem87qGl45732tEJD4Yp21EhQKQBMQ18C3IbaTenxB0L9pqG/FbjAHwj9U5HHdqBqRq4HjgauBW4pVLtSYh3iD4B323/8F184WlLLcyoRexXwRV84emnWbT8ErmuF3XbZWamAPxC62zT0sbRLhWP1F1M4nTROC57l0+xki77Oenv6xupMlq/uriSoKKWjZirXagjANPQzgO8C1/sDoQeyfnQ56gPppPyB0KBp6Gng86gCVyYrsi3RmcBPUcHPqya7YyoROxNY6AtH70Pt8MxOJWKv84Wjf0wlYkdh17RUuR5XkJ0VhxTYWRkEFh22Y/1XAfbPO/+YtoFtc6annj0OmYviOs1WuNkMenv6JtSZAGuBFctXd4/VmTy69us7AM685qPz8l2nyEncsrMiADAN/ROoXZHnsm7+CPBD4NX+QGjSbhzT0BehTldeARyBKnD9oD8Qylu/WGxnJZWInQi80ReOrk0lYtOAfwJW+sLR/QXuPwOV6lmAqlf5d9TU3AXAdOAGXziazPfYZiPBioOKpZN2JH+0rWPv4/O18R8QpS1ZtKzenr6CKbblq7vHUmylbKdLuk7Um2no7f5AaCjrzxrQVihYEZWTYMVh9g7LYvKkk3ZtuGvH9Fc2ztUYF9y/DFzsC0cfrPQ5Ja0k3MhO/RTaDUmjTq8dBVh2uT/Q1ubpP3HZJQXrufJ1A2Hv0rixG2iqzzwRYjJSs+KwfGcKpRKxrwGkZ5+3EazZjC8SrOosn9xx+6lETNJKwi1Kbgs/sPWFDk3TvCwrfLFmOS8qGY9PCKrsOSsr7K4gIaY8CVbcSY26skYXDXcee6B94LnMSH0N1fp2j91DX67sc4Qyn177UomYLjsswgWKtoVnim2N21eW0roMgB2guLmYtmlbrIVoFAlWXG50xlHDDDxnkDM4rkKTnSO0S9JDwknLV3f39/b0FZzcmt0VZFl0AN5kPL6usausuUIt1p3ANcl4/JZSU0KSRmoN9u73j3zh6FDRO08hEqy4mNXWudECfOHoslpcr8A5Qu3AFkkPCZeYam3hVbdYSxqpddjtxt9AtS5LsJJFghUX00YGlmhWuiuViK2r4WU3A6cwPq30YyQ9JFzAbk++sbenb6zOJN+cFU1TtSvBSGRZY1dYW0UOLWxDpcaKkTRS63gb8BtfONqqJ4pXTIIVd8p8klpSh2vvAvYxPq3kY5L0UB3WIMSk7ACl8I7CtPa2g8Na+x8/d+sf2jxWsx8cuQeYz/hUUNq+/b5kPD7ZY2uWRhKu8PfAfzu9CDeSYMWFfOHoRwD2G/q63DRQPepKJksP1eL6QtRKZmicxzO9U9PQ0qNzXjez48D2RTNf2eTRCqZT3G6T/XU+h3Y8t2fdPhmZ1NsiUomYD1iGOnFZ5JBgpYnUq67EF47uSiVi3eQMqJMUkHChrwBXp9OZE5c1z57Bjpl7BjseyR4a14wqKZCtURpJuMNlwP2+cLTkTrepRIbCuVAqEfsGwMCssy/TrHRXxx7DYHzbcUZNp9lOtW4gGZffXIoMjRsE5lZ4jlBTS8bjBSf1BiORpg7gphL7AMNf+8LRtU6vxY1kZ8Uhk02uBU7K85BJ245rsSY7QJkKQcqE7gnT0F072VSMmWxo3FROeUy1DqqWk0rEOoAw0OP0WtxKghUH5J4JZBr6uDOBMrJbl6WupKake6I5TTY0bsqmPOz25BuT8fhYB5UU1Tadi4GHp8KOdqUkDdRgBU5bTgMPYA98m7HbCAAcmBUA6PcHQsfAxJoV5ATmshU5jXfc+TMO8qL+/x1ywVpc5cHf7lqybfPA/HR6XDp0wkGHQjSTVCL2XeAhXzh6m9NrcSvZWamDIimexag3oew3SwuV5pl0Oq0vHL07lYjpTKG6kjoo+fwZB2jACeTvCpFPFcA5F8zeBC+x7dn9R6NBOq0NIikP0cRSidg04C3Ap51ei5tJsFJjJaR4tqDeELMNAZdkAptUYv3X7NsDudefKnUldVT0/Bmnim1NQ18FnMv4IuqZwCP+QEh2DWwLzoFH+r7x4sEhvH9+vG3JVCyqFS3lQuBvvnD0BacX4maSBqqhUlI8tjmMnyL7NPkDkABZaSBRG3ZQkLd7ol5BQbHOoyZJT7mJ/NsQLSGViP0n8KwvHP2i02txM9lZsRVJ3ZRqMaWlePJNkRWN07DuiTI6j9ycnhJC1EEqEfMClwPnO70Wt5NghdK7c0qwhSIpnlKkErHvA+yfJ7+/9WAHCTeahj7WPVHH1E+pnUeuTU+50aNrv74DmOYPhJxeihDVeB2wwxeObnR6IW435YMVe0elD/VmknlDucM09BuobMcj30GB95iGXvIFZrR1ZdeqyBtUndhv/nWby2Gndq5hYmqnE7jeNPSzGJ/amfSMmHJ+h1qdNTI6y7IqS4tVMilWiDr5e+CHTi+iGUz5YIUqunMKaEiKZ6pNm21S5aZ2qjkjRhSRjMcnpOSS8fhaYIU9q0SIhkklYhoqWHmz02tpBhKs1Ch1U0upxPp1k/+8PmcEiZqrKLUjxwAUZ97/eCXnp8gwQOEm56A+0D7h9EKagXQDMbFmBai0ZqUmUonYOoCBWWcvyTobKKPuZwSJ2nGi88jNahWIPbx65UHAO5waWF/iQ7yo+gBPnp8NAnMlJSQaKZWIxQF84WjE6bU0A9lZAfyB0N2moY8NW6tmR6VGXUUb7K9L8vys7mcEiZqSc1uo/XlM7Yd3HLQs2odTAyU/hMKD9abyuULCAXYK6J3A+5xeS7OQYMVmBxZVvdnXqqsoE2nvN/SlmbOBMj+TM4KaS4M7j9yspimYWWee8BcA/wc/sqyU+9tFtYXm2EzZc4WEY05DffB8yOmFNAtJA9VIGQPhypF38JWcESSaSY0H3mXOTTqZMofCJePxgim5YCQy5VJywjmpROxfgKN84ejHnF5Ls8iXvxWVWYwKHrJluorKMa39lY2vnr7vyTMK3cEOTBahTupcJIGKcLlSuqKK0VBp0dcB51jp9BEDO/fOs9NLpVqBSsENAin765RLyQlXkJblMsnOSo0U2FkZBBaVWrsylkZKj7ajaRqa52lglz8QWlbzBQvRIEV2VgaBucVSY/kKldOjaTxez23lFirLnBXhhFQithhYC1wL3A8c7QtH5QiNEkmwUkPVdBUVCHYAtvsDoQU1XagQDZDd+QN8ngq7omoR7AjhtFQidjhqblIMOB5VIpD2haP/5ejCmoSkgWrIDkzG0jNlFtcuZmIaCVSOXoimYRp6m70TshNVQLgTlcb5NpWlYCZLI2U6eYRwNV84+grwCvAeYD/wb6gdFlEC6QaqsSq6irYw8ZOjBciZEaLZ5Ov86UYFJ3MpvytqsuF60skjmskW4GzUv4O/84WjMp26RBKsuJsGHOf0IoQoVbHzkICx85DKPOtowrlJVjqN5vGslRSQaCLDqA64i3zhqMz1KYMEKw02ydC4xait8dzOCEkDiao0eHx/uechlSr33CSv5vH0I508orncgqpTedrphTQbCVYaqMjQuC1MDFTSSBpIVKjWU2NLVNF5SKXKCry+BYzW8e8hpoirNtw6F/gNqr5qMWoXsB348J1Lb/5zBdfT7lx6c97OFV84WvB4iOQVa96Iqme5HnWsyjeBLwXvufbRSR5zBPB9VFqpA/gU8DTqfQbgUeDjwXuuTZf793AbKbBtEHtHpQ/1C3WE/fUO09DvNw19HXAPsBlIkx61sNKgDrla5MyKRQvIrh3x2V+vtm+vCzsQWYvq9Mk2AFSdsvEHQv3+QOgZc8OTp5kbnnxVNdcSwnYC8F/Ae4Gv3Ln05tcC7wD+66oNt04r50JXbbh1EfDIVRtuXVrO45JXrAkCPwOuQxWi/xB4P6Anr1iT79iVjEuBe4P3XPsa4I3ArcC7gc8G77n2QtQHhJY41Vl2VhpnMeoXJzuXnxkal5lwuwvY157adKY2OpQ+eNQZ0lcuKlKsdsQ09LHakTrQgL0cOscq8+dX24H5ZDITaocmW5+mcYRl1W39Ygq5c+nNG67acOt04Mt3Lr35Pvu2rVdtuHUE9cHypVKuc9WGW08EdFRg/lSZy3gKeBg4H/hA1u33A88VelDwnmvvzvp+b/KKNVsAPXjPtZkx/keiuu+angQrdZZVo5JiYppnCLgkd2hcKrF+HcDBBqxPtKx61Y6UItPFtpkSAg+bhvqEm6lJ0VAzKTZR+ABCIWruqg23eoBPA3+9c+nNeQOVqzbcOh+4G7jZDnZORQUqI8Cb7lx6875ynjN4z7Wp5BVrLkf9m/HZN78IXBm859p8Iy0mSF6xphuYBTycvGLNm4EvobIn15WzFreSYKWO8gyJ+ybwYcYPjZOTkkU91LV2pNbsuSznMj41PRN4JN/QOPP+x8t6MxCiFFdtuPVs4DbUeVVXTXLXjwAXAMGrNtzajwpULGDZnUtvLrgTUkjyijXTge9xKFABOBpYk7xiTfdkNSd2mug2YAdwSfCea0dRKaWfJa9Y8wVUHcwd5a7JbSRYqZOcGpXMVnwPqoirDVWPcp1p6BOi3hltXYGsP7rmDUU0D38g1G8X0xaaGuua36tKUlaa19MlaaDqyLEDE1yIqvu45s6lNxdL42RS9z3AP6N2Ai+8c+nNlbYjnwdcZH//Y+AoVDD090Ac+Gu+ByWvWHMG8F3g+uA91z5g3/YPwC+D91y7HTBRqaymJ8FK/Swmf41KG0VyiKPtR+62v52V+7NUIjbW+uwLR2VXRkwm09Y71g2EOw/uKztlNWPOkcNYlmRKK5CMxyd0iSXj8bXAimAkMpW7qx5FBSu9V224NXPbW+5cenO+QM60vy5B1RpedOfSmwt27RQTvOfa9ckr1rwLVVR7FTAd+G/gc8F7rs0bqNjCqB3IW5NXrMnc9inUrsorqCCnJU4Ul7OB6qRGBxuuA8gcZJhKxCacPSQnLotiGjxnpWyVnP2T+29DlC4Zj084FBJ7xy0YibTEG1u92V0/f0DtsFx259KbJwsoxsjvbeUkWKmjag42BNjx0L0vaFa6q2OPYaD67l/L+Jz+ILBIdlhEs8t3qjKTHHT4/Pr7XrBG013mH58wGrC8kjqUmoQXeB35x1YMAnMlJVSaqzbc2gFw59KbSy5Ul2ClcpIGqiN/IHS3aeg6+SfWFpRKxNYBMOvs7JszbaDZhuxr1zxYkXSTaLCyUlYvGZvmUP/pzq3YodRO4bVnDoWUMfAlKCdIEdWTYKXOqjjYEKutc6MF+MLRZXbwkJtWakdNvq2p3HRTKhGTdJOoK3sS7Y2mod9CCSkrTVM1LMFIZFm91mSnS/J2KDVrusQuqi2UcpNDIYVrSRrIhTI7KwOzzl6SlQYCmAOcwqFPeU9T+10VSTeJMW6td3l49cqDgHc4NVBwfHmVWjZdIjUrzpE0UOVkZ6WBJjnEsFS7gH2olNABDrXP1VJD003CnRw6V8hNWjld0ixdYkKMkWClQYocYphXdhqoAUsExmpVGpJuEq6Wfa5QxtX2V8c/fdc7DdTK6RK7PfnGZDw+lnJr1l2iZmOlLe/I4MFjk/H4J4CvBiORpj9gsFEkDdQABdqY08AD5Nkdmdb/3AKA4a6Fc4F+fyB0TCPWmSEt0lNbkVbiNGq6p6NdMaktZtCyOHjSO943s17P8dCX/qPX0972wdEDQx3W6Nh7iqRLRMW2PZh4aCg1+Oqdf3pqG3BdMBL5hdNrahZy6nJjLEa98WfLHGKYa9pw18LUcNdCx1IudmCyCLgYVasigcrUUsqQNkf5FvuHDj/Ov78e1zYNvc009FVHh876oP/1Z7QdHTqbmactGkLt5ki6RFRF07Rh4B4glozHNafX0ywkDdQYWyjhEMOxVJFlDQPT0LTNOFQnYhfTSo3K1OT6c4W2PfSr39fx8l8BrtY0rUPzqveSroVzRw87Zs53F5xzseyoiFr4PXAZ6oyhNUXuK5A0UMMUGxBXIFUEsN0fCC1o2EKFoPwhbY1m9N52UNPwznvtaSV3A6WHR7wjgwfb2zqmD3mmtRVKYxXtAnI6UBPNa9uDiYeG+w+ctuOBJ68EjgE+B4SDkciDDi/N9WRnpUFKGBC3mIlnCcEkg69kcJuoo5bpGLHSaW33o5tPGDD3zNc0LMtC6/QftX3Wmcdt0jye3E9rrdwFJNzlBeB24L5kPB4KRiKPO70gN5NgpYGKDIjbwsRUURrYmO/OMrhN1FO5Q9oaLp0etChtXkX2cLfMRvLA9t0zB7bvnjDcrUhxcVN3AQlXSqIOLfxtMh5/ZzASqWd6s6lJGshFxlJF6dF2NE0jPbzPkx72Zg2Fy5DBbcI1env6xgbHLV/d3ZCApoyhcGUPd3N7Ckw0r5w0ULYAcBPwb8CqYCQib8w5pBvIRewalkUz9j35SMeuBx/yDr08Qno4X7X4ZIPbhGiI3p6+tt6evlWonYiHgJ29PX2renv63LRjW0paJ9cKVMprEEjZX5syBSaahgHcDFwH/CIZj0udYg43vagIVKoolVifBLqnv7LRC5YG/Gd2ikcGtwmXcGxw3GFHz94McNI73rdssvtVMtzN9Skw0ap2ABHgCuCxZDz+GeAbwUik2U/6rglJA7lMgUBkQopHBrcJJ9mpH8cGxy273B9oa/P0n7jskqIDE+UsHOEWk6SBci0ErkX9W+oJRiL1OgOraUgayH0WM3Gq7YQUjwxuEw5zdHBcenhESw8Pl/r6JWkd0WyeAz4N/Bq4JxmP/28yHj/R4TU5StJA7rMF6Mq5LW+KRwa3CQcVHRxXz2Jb4/aV+4ahk4uL31fOwhFN7PeoY1neBiST8fgPgFgwEtnu7LIaT3ZWXMYOQJ4G0haeUQstjUrxSFAiXMMORNai0inZBoC1jeoKKkcwEukPRiLPSKAimswQ8D/A9cAc4MlkPH5rMh6v27lYbiQ7K+60C9h3YOZpMyxvx4F551wmKR7hRi0zOE6IJpACvgPcB7wb2JiMx7+IanUedHJhjSDBinsNp9uPnHAisxBusXx19whwY29P31h6xY07KkK0mJeArwM/Ad4H3GSnOL/Xyp1DEqwIIapiBygygl6IxnoR+CJwMvAJYEUyHr8+GIn8wdll1YcEK+7Ua39d7ugqhHCpw46d+6LTaxDCJf4K3AK8AdU59Gvg48FI5CVnl1VbUmDrQr5w9Ae+cPQHTq9DCLfyLZy7y7dwrhSdC3HIH1DDGLuAJ5Lx+NsdXk9Nyc6KC6USsWMBmHe+wysRwp2G9x+Y7vQahHChQdSw0A3A15Px+MWoXZamr3+UnRV3+p79nxAij93GxlN3GxtPdXodQrjUU6g6lnOAhH3sRFOTYEUIIYRoPfuBW4GDqIAl39EYTUOCFSGEEKI1pVENGweBbzq8lqpIsCKEEEK0Lgs1l+WCZDx+mdOLqZQEK0IIIURrOwh8H/isw+uomAQr7vRl+z8hRB6+xf7nfYv9zzu9DiGayJ+AE5Px+AKnF1IJaV12IV84ei/AfkP/hNNrEcKNDjt69m6nntvurJDTm0WzSQMbgVehTk1vKhKsuFAqETsZmHTOSioRmwMsBrbIicxiqhl6eX/DOxuS8Xgb8BWyDm5MxuNrgRXBSGSk0esRogJDQFN2BUkayJ3W2P/llUrE3gNsBX4NbLX/LMSUsefxzSfveXzzyQ1+2q8AV6Ne7H3216vt24VoBrOA7U4vohKys+Ji2sjAEs1Kd6USsXVZN08DXosKNDMRcl8qEdNlh0VMFZZFB+BNxuPrGvSUXuB1TPyA1wlck4zHb2nWlJCktaaMw4BjgEedXkglJFhpPjNQrWjZhlApoYqCFUkpCVFUOxP/3WWMoN7sm+rkaUlrTTlvAH4TjEQGnV5IJSRYcTGrrXOjBfjC0WWZ2+zAYivj847twJZKnsNOIfWhAp72VCLW7QtH7650zUI0gqYxCBCMRJY14vns3Yed5M/3t9GEBYuMT2tlXG1/vbHxyxF15AHeDHQ7vZBKaZZV6MOCcEom7TMw6+wlmpXu6thjGDl3mQOcgvqkpwFPU9muSnZKKWMQWCQ7LCKbaehjqQJ/IOR4quDh1SsPAt7h1MD6Bj7tEmA+4/+9pFE1ABsbuI5aKJTWAvUaMFdSQrW37cHEQ8P9B07b8cCTVzb4qS8CzgXOD0YiTfmmLzsrZTINfSxl4g+E6vWG/u/21+8U+PkuYB8qJXQAqPREzZqnlERrMQ19QqrANPS1wAp/IORYqqBr4dxXSFsde5/a2sin3WR/nc+hDwrbs25vJi2X1hIFHQZcBVzWrIEKSLBSFtPQx6VMTEPv9gdCNU+Z+MLR3wDsN/QJaaBaqnVKSbQkV6YKfAvnPgFw4uVXLWv0c7dCQWqLprVEfu8HfhSMRB50eiHVkDRQiewdldw39jTwAJXvbOTlGXq5CyDdfsQSoN8fCB1Ty+tny61ZAaRmRWTSPkuADagduFxp4I/AaCPXlTH08v5zLMsaWLTs7fOceP5WkIzHV6ECz86smweAbwUjEalZqQMH0kBnoD5UnBKMRF5u0HPWhcxZKd1i1Bt6Nov8L+TTUHMYplXyRO2pzUvaU5uXVPLYctmBySLgYlStigQqU5hp6G2moa9CfepeT/7fb1C/++0NW1iOvU9t7dj71HNHOvX8LWIF8C1UjUrK/vot+3bR/NqB5cB1zR6ogKSByrGFiS/OQ8Al2bUruakioOxUUSqxfl1VKy2TXUwrNSoC8qd98hkCQk4V25r3P77PiedtJXZ78o3JePwWmjytJfJ6J/DnYCTyE6cXUgsSrJTIHwjtMg29m4mBSHagMsf+eQeHXuzvMA39VIPgeQAAIABJREFUBspIFc1o6wpk/VFePFzObZ0ylbL/HtdQPFBJA3uA+0xDr/u68tG8ni7LciYF1WrsAEWKaVvLPOAS1DlALUHSQGWwd0jGUiZ5dkwCTMzhF0oViSaXkzJ5CNhpGvoqu4OmGS1AdYIUkuZQq24zdsAIMVW8F1gZjERedHohtdKsL6qOsXdSJqRMstI/uZ9KJ6SKiml0GkhUzJWdMlXYRuHXhEHUXI6Nbtg9kjSQEAXNR31wvtzphdSSBCs1kJP+yZYGNgP3lLNd7j3y9MPtb49H0kCuNEnKpBO43jT0s3CoU6ZKe8g/+GwP8DUAp1I/2Y48dZEXy6rb2PBWSe2JKelS4JvBSCTl9EJqSYKV2ljMxKO3R4EngL3lXmx0+sxXarMsUUeTpUwynTLNeAZHUww+m3GUb5SJ3XlVc+sQPCFK5AEuAP7J6YXUmgQrtbGF/J1CF9mFuWVNvU0lYq8D2D/v/M/XeJ2idiZLmTjaKVMLbt9Z2PzrH/6lTpdutdSemFpOBrYHI5FmO/6hKAlWamCyTqEKp95KkOJy/kCo3/7EnXeolhvf4Mthr9+1HSIvb9x2uqbhNefo6yp5fHp4xDsyeLC9rWP6kGdaWyZdV+i8nE7gGtPQb2n2/19Fy3sVkHB6EfUgwUqN+AOhu01D18naQam0lVlal5tGZnjWWMoAGarlalY6re1+dPMJA+ae+ZqGZVlonf6jts8687hNmscj5+WIZrcE+F+nF1EPEqzUUJ5OocVMrGXJtDKXNaLfPsdnMbBFTkR2B7uG4UbT0MeGaskn7wZJpwctwB8ILSvnYfaI+XMBT+akkYHtu2cObN/9yMJLg7cg5+WI5nYC8GenF1EPEqzU1xZKmHqbK7d1Off8nlQiJuf3uIjbUyatyLLoALzJeHxdGQ+bNM3z3C+Styy8NLjWsqyrNU1rudSeaHlHANOB55xeSD3IULg6sgOSblRXyMv21+5SZ65oIwNLPAf3ngXcgfq0d4T9tc/eaRFClK5YmufY5375oNb/3M729Gia9MgoVjo9YlnWt5HUnnC/JYARjERa8nRi2Vmps3y1LCU87GP21/u09JCHiS+wQ/b1yhg0J2kk0TpmnrboMYDFf3f5slIfk4zHu5g8zXMjlvWBvU9ubdv31+fxTm9n9ODQkDWaTtvn6AjhZqcCv3d6EfWiWVZLBmEtwTT0ddrowWmdLz14FuNfYAdRJySXFHTkppEASSOJpvb8+vtesEbTXeYfnzDKfOgS8g+9MwE/+XebB4G5pRzy5/aWb+GsF/70y0dGBg6ctPOBp95dh8t/BegORiJ/qMO1HSc7Ky6USsQuAtBmnb1Es9JdqCm4p3BoSNdm4J5UIlbK5aYBr0W9CGcCnr5UIqbLDotoVgf2pKaTtip5/So09O5F1OFv+RTtBJJhcqIUr+wbOX2GF28dLn0cqvbq/jpc2xUkWHEZ09DnzJh2xBe00cEDWTfvAvahuogOUF4n0QxqkEYSwk32P79zGjASjESWVfJ4OyW0ANgWjET6S0gRFesEkmFyYlK9PX0z3viWuV60gnVT1XgHcFswEknX4dquIMGKi2QGyB048rR2NE1D8zxtwUZfOLqs0mvatSpbGf8i2o7qVBKiOXk8HZqG1zQqGwq38NLg2PemobPw0iAvGZv2DOzYM5+0dSgV5NHSnfOO2jM7cMJ9k5yJJMPkRCmWUrjAuxqnoXbe31qHa7uGdAO5xLgBch6vF83jQf0SnlTNde1Uz4SOJEkBCTfo7enr6u3pO6m3p6/L6bXMOvO4TZ3zjtqOR0trHm3UDlS2zzrzuGLnIpUyTE6It3u92kCNr3kYaufuulJqqpqZ7Ky4x2ImDpADCuc3S+3w8YWjd6cSMb2U+wrRCL09fRNqPHp7+tYCK5av7i5e41HhULhi5p+tUkSWnSI640MfKbWoVobJiYJ6e/qmAe/1TtP6GR13PEc12lAHFv5PMBL5SY2u6VoSrLjHFiYOkEsDeQ+kKndQnB2gSJAi3MK1NR72J9SSh/y1+jlRoiauALZ5PMxitOh9S9EGfAJ4nikyA0hal11k7NBDyxoF2kgPDXjSw96OPUZue2Z2h09GWe3MQtSbndpZAGxbvrq7P+f2QjsRaeCPMPlL+hvCR57d5tUGTrnsHf4aLrli+bqBAOkGEpldxCeB74ff7b+G4aFjXko+9fYqLtmB2lHZDrwrGIkM1WKdbic7Ky4yNkBO0xYDWzRr9GEgXy6/C+nwES5VQopngX17PhZqh3FwsufwdsxIe9s8rgkC5JwoMYmPog6kfbgG15oN3AL8DlWn4pp/A/UmwYrL+AOhXalE7LWAf/+88zdaQHY3UFb6J7eWRTp8hFsUS/Fso/BrzxAQyt6JyWfTz37wGAerXWbtyTlRIltvT99iIAp8pgaXexXwceBW4CutOla/EAlW3OkToM4G0qx0VyoRW2ffni/9A9LhM+W5ZXKqneK5hokpnk7g+t6evrNQKZ495J8kuwe4r7enb9LnCZ7cfypajbL/QtSBXVR7F/Bj4IUqLqUB7wQuAd4TjEQK9tC3MglWJmG3Ey+m9DN96i3fgLd+4O994eivHViPcJgLJ6eWmuIpNEm2WJuwEM3ii6hgvJpOnSNQu5GjwDnBSKSaoKepSbBSwFixq91tYxp6tz8Qauh5OlZb57g0UIEBb16g3PNRROtwW1dNWSmeQkW4xRi3r9xX1SqFqKPenr4PAe8CPknlg+BOR6V9vg18ZirVp+Qj3UB52DsquUFBGniA8kbdV2TGbiMAcGBWAKDfHwgdk/mZHEooMiab72FZVlrTtKJdNfXw4G93Ldm2eWB+On0oxePxkF5wXOf28y6ck7cVv1w7HnjyfMtiNLD8hum1uJ4QtdLb03cxcDeqTmXcTkj43f7bS+wGegdqIu0HgpHIL+qz0uYiE2zzW4wKBrJZqDRM44wOaZ6hV6bZOyqAGvAGLAIuRrUqS6AydRVMuYwMW57H/rTnxPSopTV4TZxzwexNC47r3O7xkPZ6tdFMoHLOBbMlxSNaWm9P3zmoQOU/qKxOZTrwj8CrUWkfCVRskgbKbwsTB7QNAZc0onYllVh/LPC2zpceXAXaYcDW7KFvMuBN2AqmXDQPbH6q37fxsdQjy1d3NzwdtOCcTIrHWgBse+vH31PTot/h/Qc21PJ6QlSrt6fvZODnQC/wRAWXOAr4NLAB+EgwEnFhv5tzJA1UQG7NCtCwmpUCtSky9E1MYBr6KsuyrtY0bWxy6shwmq3P9PPohr1Q4pA1p7W1a97Dutra9/ePDI0MWUXXuuxyf6CtzdN/4rJLjil2XyHqrbenbyHq39k9wP8Vut8kaaD5wGeB1UB8qrUll0J2VnJkdQDpqHTLYhrfDXQNMvRNlGbFgcHRI9vbPe9Pp9WOytZn+nnsgb2Zn5c0ZM0pmgft7DfMOuHo4w+bb1mWpWma9uKz+7f/5Q+7N1npwoWJw7v3Thv1aPkm4ArRUL09fbNR7xc/Z5JAZRJ+4F+Bfw5GIt+s5dpaiQQrWZzcTcnxFibWx8jQNzGBPxAa6e3p+6i3TXtXR6e3Y3BglNGRce/xJQ1Zc4pp6KuAcwGP6l6GhSd2zVx4Ytcj/kCoYPrKuH3lvvQkh3wK0Qi9PX2HAb8E/gLcW8ElfMC/ADEJVCYnwYrN3lHpQ6VeMp/Y7jAN/QYa0AGUbUZb1+na6PABzRruRNMszRo9gAx9EwUsX93d39vTt7b/lZG8B+m5OFCZdICcaeiZAXIADB9Me/f3j7Qf1tU2pHk9XZbl7tSWaG29PX0e1NC3PcD3K7iEhjqE8O5gJNJby7W1IglWDlmM+hSa/cKZ6QBqaLACYHmnDQ8e+epXPKMHDnTsffQMCVREEZmTV7MP0vsW7j6RtaQBculRS/vz7186YdvmgfmaplmWZWlzj2zXFvuHJFgRTvosqlTgsxU+/lLU73/k/7d35mFyVFXjfodsENLshgEUkEVFIA4BSgZRAoM0AVz4tEgIgrFZysYWgQ8kw9YpTJywLzY0hXxNQIhAASp7IaMBMYFiG0BBFhHkh0wggKHInpn5/XFuk06ne6Zn7ZnkvM/Tz0xX3eXUrdtV55577rl9JM86jSorq3mTKq4AKiQKHp8LwLCRtA8bSWeKinHG3RF4UxWa9RezQeCp2VTu0430BqtFpYAuA8jV1jV8kk3lCqaKZIrrvY+G097ewV4DI6eirEE2lTsEcJBlxj0J1jYGmAQcsL4He6sUXQ1UwGDxWcnvBbR46wMAqK1rmFAm3Rrytg/b8LSlW+2TAh4GtgN2Bj4GptTWNbzX2tJ8E7AbMj3QVlvX0NDa0jwF2W68HXgNmFpb17Cs/65O6WtaW5rHAo/QT/e9p1FmK5T9aiTi7lrTV7V1DaeauksGvqup6aCjoyY2BJQyZR3C9Ml/AB7djB5esBroVqDNamyc2g8irpOoZaWA2rqG21pbmpup/n5A3weoWbWkpWgjw0IKNzXcCKCmbdnVNauWNHUMHx0D7qmta/hta0vzV5HpgG8hy+MOr61rWFhQzg+A/WvrGpa2tjSfAjQhIZ6VocPOwM3IqoI+u+/ZVG6tfYeyqdwNwBnGktMXdDV9VXaqqGaDmo6ONrZFdzlWBpafA6/Qu21ODkE2JlQqRJWVIoyCUtXplFg8vRBgydMlnctHIH40wyla3lwDy4Yve7915Zgd9kW2Eae2ruHJ1pbmbU2SrYHprS3NABfV1jW8XVvXcHhBEfOBwu/KEKC2rmF+a0tzPvJlX973ft93yGy2eGprS/On01dFu0aXnyrqoMOcV5QBIZvKjQZSwNk9K6GmvYaOGuBVq7Hx+T4UbZ1HlZVBSBS4UwE6tj6geCPD4mmqNtZcvjmybcSmrUA98PPWluYm4DjgHXP+RuA55OU1B/h6PmNrS/M2wNVImGhlaNJn992Yusuu1Mmmcmus1OlbcsUHPkSsQ4V7DTF27AYrjzpvqk4BKQNJHNkZvLUnmTtqNli5rG3UYqux8cC+FWvdR5WVwclUgJpVS3YpmAZaa9oHUVqWUuBj0z5qs0XAdcAC5CW1OzISoLau4cp8Ba0tzZPMcu0PEEexJHB2bV2D7kUxdOnL+17RSp0+lb48+T2FtjF112y1yYqaz226YsD3PVLWe/ZH/FWUAUaVlaHDhqwd1XYpYAP/xawGWtzSPAHoqK1ruLq1pfk1wK6tawhaW5o3AvaqrWuY19rSvAWwE7AIebG9A+xXW9ewZKAuRukX+vK+d7lSZ6AdWwsdfXfeZnlPNolTlN5Siyj6ygCjuy4PYjqGj369fcSYFjMNdBhr7wQ9EmiJxdNPFS9bbm1pPhD4KXCKOTQa8Q14DHgQcGrrGlYA30VGCw+0tjTPbW1pntF/V6T0N311340icgOyMqeQJcAN1ViBk8wkPklmEq/q6h+linyMLDtWBhi1rAwRYvH0+1HgJihaWl2spNTWNcwF5pqvjxYc/wCYXFxubV3Dpv0ksjKA9NN9H4qB5hSlP3kWWUmnDDCqrAwhYvH0bVHgfrq0WoPAKf3JEA00pyj9yb3IKrkYEFVZlvUKVVYGJ/llpA8UnzAKiiopyoBhFJRBFctk7Fd3e6HaMijrH8lM4r1sKucD3wNmV1mc9QpVVgYhsXh6CcBiiYuhKEoRGwwf1l5tGZT1lnOBvwOPA69XWZb1BnWwHYREgXtKFLindJ1SUdZPFr3+zraLXn9n265TKkrfkswkFgA/QXy3Nq6yOOsNqqwMTo42H0VRSrB0wUdjly74aGy15VDWT5KZxO3A75Co0cO6SK70AaqsKIqiKEr3OYPVwRWVfkaVFUVRFEXpJma13PeQQHHHVFmcdR5VVhRFURSlB5iVcnFkX654lcVZp1FlRVEURVF6SDKTeA/4JrL1yd5VFmedpaajo3i7GUVRFEVRukM2ldsfCRp3Lqt3PF+DQydtd/nypW3bfPnQwzVkfzdRy4qiKIqi9JJkJjEP+Ln5jKyyOOscqqwoijIkCZuaOsKmpmnVlkNRCsgBTwLHVVuQdQ1VVgYhUeB2RIGrD2FFUZQhRDKT6EACxu0P7FRlcdYpVFlRFEVRlD4imUl8CKSBY6sty7qEKiuKoiiK0rf8H7C9+Sh9gCoriqIoitKHJDOJFYj/ykHVlmVdQZUVRVEURel77kbjrvQZqqwoijKomTJ/Vk21ZVCUHvAcsCUQq7Yg6wLDqy2AoijrDlPmzxoLPAI8DewIjEZiTpw0p37aMz0obwfg3inzZzlz6qfNrzRfaHsHApORlRkjgF8Dl1q+80KZ9JsCtwBjgY2As4F/IKZ8gBeA0y3fae/uNSjrJ8lMoi2byr2E/A5erLI4Qx5VVrpJa0tz8UPtfOB0c3o08N/auoZDKyhnM2BRbV1Dt0MIR4G7FfBhLJ7u9MEZBW4NcBViilwM/BjxUt8NWAK0xeLphu7WryidsDNwM/ALwJ5TP+0+o3A8MGX+rLo59dNWVlrQlPmzdgWakb76cqX5QtuzgPuBjZHf5JbAEcDE0PbqLd95vUS2icC9lu9cH9re5sBcYA4w3fKdR0Pbu8SUcW+lcigK8Cqy0aEqK71Ep4G6z0Tg3tq6hq8CBwIXApNq6xomAL9CHnKVcDzw9R7KcDwwoYJ0OwGLYvH01xCF6hJgG+DwWDw9QRUVpa8x1o+ngcvm1E+7zxx7C1gFbFou35T5s7aZMn/Wo1Pmz6o333cDHjWnD51TP+2/3RDjZcQED/JbOcL8/1fg36UyWL5zm+U715v/PwLeBJot38nLsBkQdUMGRQHpb1tWW4h1AbWsdJPauobbCv7/qLWl+U3gc8AC4LuIpaUSPgtsDTxWSeIocEeyOoTzFGBcFLih+b40Fk+3FeeJxdP/LJBnc+RhuwswPQpcgIti8fTbFcqrKN1myvxZGyB7pbwyp37awk6Sngx8A7CmzJ/1CWJR6QAmzKmfVlLBKIflO1Foe98F/sVqf4F3gEmW76zoKn9oewnkBfNcaHtHAJciA7sfd0cORQHeB/asthDrAqqs9ILWluZPH2qtLc0bAjvV1jW81En6zwG/BxYCHrB9a0vzE0ArcFxtXUNnI7dNgBuBI833vYEfAtcAZwJrKSsAUeAOQ0aoFnAIMB4ZdW6NmLl7at1RlE6ZMn/WeMTaOA9RsDsjPz2UQhTsGuCgOfXTXu1uvaHtjQJ+w5qOjdsBXmh7iXJ+J6Ht7WLkXQAcZvlOGzKddH9oexchPjC3dlceZb3mA0A3LewDVFnpAa0tzWs81GrrGtpaW5oPRxwLy1Jb1/B2a0vzAYgfyb3IA3Rr4JyufFdi8fRC4FtR4N4OHG0OXxCLp3/RRb424IAocPcELo7F0xPz56LAnRQF7mdi8fT7nZWhKD3gIGSa9MQ59dMq8TdpNX93QUajh8ypn1bSGbYC9kUUc5DBwRaI1eZ/gCbgleIMoe3tAdwE/MTynSfMsR8BD1m+866Rr+w0lqKU4QPEd0rpJaqsdJPWluZPH2q1dQ1PFJz6LqtXDpSltq5haWtLczvwS8TplW462Y4D7kEUnU7Ni1HgjgO2j8XT9yHWnK2iwN0/Fk/PiwJ3C4xPSzfqVpRKeQFRVrJT5s/KHztyTv20T8qkbwbeRiwsh8+pn7aWQlEplu88Htre95HN5KYAo4A7gJmW75QrN45Mlc4KbS9/7GzEqvIxouCc2lOZlPWWhaiS2yeostJ9Pn2otbY054+djEyznNRV5taW5h2Q+W8X6cSXtLY0j6ita+hylUQUuLsCl8Xi6RuiwB0BnBUF7saxeHpxmSyvIv4p5yH+KmcCp0aBOwt5gDuxeLrLOXxF6Q5z6qfNpXJH83yet6bMn/VF8//S3spg+c49iFIPRgHqIv1lwGUlTo3vrSzKes27wFbVFmJdoKajo9srZ5Ve0NrSPLK2rmFFwfcaYHihshIFbgfQGIunZ5UqQ1EURRn8ZFO54cjS+0nAqkMnbXf58qVt23z50MPVj6WbqLKiKIqiKP1ENpV7A7gYeEeVlZ6jcVYURVEUpf/4B7BDtYUY6qiyoiiKoij9xzNIyH2lF6iyoiiKoij9x1PIykulF6iyoiiKoij9xxPIfmz6vu0F2niKoiiK0k8kM4n3kACiO1ZZlCGNKiuKoiiK0r/8Cd0jqFeosqIoyqAibGoaGTY1XWT+3yBsarqqk7QTwqamGZ2cnxs2NWnwS6XaNCNTQUoPUWWln4kC99AocOdHgfuNEuemRoF7ovn/8aJztVHgnlV0bI00JcqbHQXuLn0ht6JUC6uxcYXV2Hi2+ToS2UtLUYYycxHLSk2V5Riy6Iij/zkZ+J9YPP1uN/OtQPYgUpROiQI3A2wI/DIWT79RbXn6grCp6XFkR/HTgLawqek1ZDuLLwHXAsuAK4FPTPovAJcA7cjGcScjuyTXAT5w1ABfgqJ8SjKTeC+byi1ob+vYqNqyDFXUstKPRIF7LrL7641R4B4ZBe4TUeDOjQLXjwJ3TEG6K4E9o8C91nw/D3gQuCsK3Jnl0kSB+2QUuH/Jp1HWWy4A/gOEUeDeEAXuurBMcjPgdGCC1di4P7KRoANMAO62GhsPAe4vSP8estHgdOABYJLV2DgLaAHsgRNbUcryWNuq9tHVFmKoopaVfiQWT8+MAvebwHeQh+Z+sXh6URS4RyEP3g9MutOiwN0nFk+fEgXuPsB+Jm1HFLhXRYG7dyVpqnSZ/UoUuMchI2yla2qAHwEnRIH75Vg8/XK1BeoFuwFXW42N+U0NHwB+jCgkp4VNTXex5vRQHZAGHgF2Bv49gLIqSiXMa2vj2JoaVlVbkKGIKisDwybANsAfosAFafc/Y5SVIj4P7AH82aQdAzzcgzTrCrcCf6i2EIOcEcCxwP8CTyLTQUNZUQGxpNSHTU2jrMbG5cARwEvIb+cyYCPgLqDJpLeBc6zGxvlhU9N3gL3M8RXIFNknAym8opTgmfb2jlHDhtWostIDVFkZGD4CXgW+HYunP44Cd2OgAzi6IM0w8/d5xApzlLGajI3F0+9VkiYK3HXO3B2Lp9uBj6stx2AmCtzZiDJ8TCyenldlcfqKhcDlwLywqakNeBr4KbA/cA6wCvFdyXMHcEXY1LQAccp90hx/EFFq4gMkt6KUQwYQHep+0RN01+V+JgrcuYjfSj1wHvLi3RA4FxgPDI/F0zdEgXs5EIvF0ydFgZsEvg0sBtqAk4yS02ka4GpgRiyefn1AL1KpKlHg1sTi6XXmhxw2Ne0AzLIaG4+ptiyK0pe8+OD9HTXQscfEI1Rh6SaqrCiKMmgIm5oOAGYCP7MaG1uqLY+i9CV/f+j+Fe0djNhz4hG6hLmbqLKiKIqiKAPAy398IFq1qmOMKivdR01RiqIoijIADB+xwUcb1LCy2nIMRdTBVlEURVEGgDGbDn+DTYevE4EbBxpVVhRFURRlAKip0dmfnqLTQIqiKIqiDGpUWVEURVEUZVCjyoqiKIqiKIMaXbqsKIqiKMqgRi0riqIoiqIMalRZURRFURRlUKPKiqIoiqIogxpVVhRFURRFGdSosqKsE4S2Nza0vYZelnFoaHtb9pVM6zp90ebrC6HtjQxt73vVlgMgtD07tD0NCKoMKbTDKoOS0PamAtcAL1q+s1/B8eHAG8BY4DDLd+aaUwcAy4vKmA3cafnOfRVWezTwSA9k3RW4HohbvrOiu/nLlDkBSFm+8/0u0k0HFlq+k+llfW8Ce1i+80knaWazZnuu0eZ5WYDHgYuBiZbvtHVS3gQquMbBRmh7cxG5/9ZJmumseV/2AGoLzk9F2vvMPpLpJuAKy3cq2al6ouU7fkHehZbvbFXJdSlKtVDLijKYyQIdoe3tU3DsKOBJoFgBeQR4rJf1TaNnCvyvgMa+UlSGECXb3Lww/wb8aMAlGry8AtzSX4VbvvPDShSV0PY2AH4e2t6w/pJFUfoDtawog51rgBQw1XxPARcAPwUIbW8H4EZgY2BUaHuvAVOAa4FJwHdC2zsRqAESlu8cbvJ9CQiAzwM24ALvAtuFtjfT8p2bQtubDFwJfAL8n+U7TcXChba3HfB5y3eeMN9nA7ubcjOW70wPbe/rwFXA9kArcKblOw+Z0fd+wK7AJsDDgGOO3QGMDm3vDst3ju6ijb4T2t4ZwGhEgTgBWGXa6SiT5m3gOMt3PixxDX8HPgf8M7S9OmAkkAF2AIYBN1u+c1FB+nJtXshvkHt3QxeyfyG0vWeAzyIv9KmW77wR2t4k4CxT/yogafnO0yVkn06JNrR855PQ9izk/u2AWIAylu9cbqwaJwFbARsCDwD3Ak2I9eMvSF/5uER9DwH7A3ND2zsc+Cdyb79iZA2AMwrSbwH8n5FhVWh7i4HvdNEm+bw1wGXAccASwLN855el+mXeKgLsg9z/LYCtgdBcS2toe6cj/es/wGdD20tZvvNwJbIoSrVRy4oy2LkDOCi0vS1D29sD2NzynUcLzkdA2vKdr1q+UweMAr5q+c5JwO3IC/ou4B5g79D2tjH5piAv4XZESam3fOcgoB44z6S5xHzfA3n5lmI88GzRsaeAWqOobG6u4SeW72wF/BCYXSDH5qaOrYEPgQss33kE+B/gvgoUFRBFrA5RhgB+jAxE/gOMt3xnHGKNOrlUZst3dkeUmZ0t33kX2AyZUhhnru+Hoe3VFmQp2eZFxT4P7FmB7FsBky3f2Rq4DXk5gygRh1q+sxfwv8CMTspYqw1D29sQ+DVwguU72wHjkH50gMmzHXAIsBPSfrOB7xg5XgXOL1WR5TuHAfOACZbvhIjC9jvLd/Y017sHa7bFEuA6y3fGW75jAS8C366gXQAaEaX3i8C+wD/M8a765TbAt0x/+xNwtTn+MlBn+c7BwGTg5xXKoShVR5UVZVBjplZ+g4wWf4KM1gtZBhwd2t7fQtt7CrCQl22pcu4AjjWHJiHKL266AAAXQklEQVQvKJCX7x2h7b0A3F+Q/3Zkimd/y3f+XxkRY4ifRiEPWL6zyvx/IPCI5TvzjRzPAH8ADjbn51i+855RmmYjykF3+b3lOx+ba7wT2NPyneXIyPuR0PaeBI5BFINKeAM4MrS9EJiLWBsK83bZ5uZ6Pgltb2QXdc2zfOc18/8cVis4LwE3mvIv6UL2Um24m/n8ObS9VuB1xCLyZZPnPst33jY+NXcaOd405+4A9upC7jzvAnuEtvcE4quze5GsK4Cvhbb3Ymh7TyNWlbX6ZxkmA2dYvvOhub67zfGu+uW9lu+8Yf6/kdV9aiXQHNpeC6LIVSqHolQdVVaUocB1iPn6SNae9z8VGdl/xfKdfYGHCs4V7yVxI2Il2AdYYPnOP83x3wIXWr4zzjjz1gAY58dfAFND2/tdGdk+QEb05Sg31Zo/XuiAurzgeE/3wVgFDA9tb2/gbOBYy3e+ClzUebY16puJvGQPsHynHnihKG1nbQ6A8YnYsJt+PHnZRwC/A2aa8id1ka9UGy4B3rR8p7bgs6XlO9ebdMuK6l1V9L2zKfLCtvopsAtwsGmr4mmVo4G9gX0t39kH6YPdYS0H5Qr65VrtYZTGW5ApoTpgUKxMUpRKUWVFGfSY0ePtwOWW7ywuOl0LvGb5Tltoe2ORF0eeCFk1lC/nWaAdWakyuyDdlojvAaHt7Z8/GNreRpbvPGn5zvFAXRmnxKeRl1E5HgUONv4ThLY3HvgWXa86WkP2HrA98IblO++Yl39XUzKF9e0APGn5zorQ9ralYBWLobM2zzMeeKaHso9B/D9eLCiru7wOtIW2lw5tb5vQ9vYMbe9yMy3XW4rb6lnLd5aEtrcZMm1TSC2iNC0LbW8TZOqmUnzgvND2hpnP16DiflnMaEQJf8c42dYXJ7B8Z4KuBFIGK6qsKEMCy3fOsXznihKnrgGODW3vLeBu1hwR3wXMLIpvcSMy/+8XHDsPCEPb+yfieLnSHJ8T2t79oe0FwJ9LLcO1fOcD4PnQ9g4sI/f7iIPk9WY64iZkdPtOF5f8AuK86oe2t09oe7/vIn0xDyEj6n8h/io7d5H+ZuBJ40tzCdAU2t7LQI61rTydtXme44FcaHsbhbYXdkdJsHznI8Qp9dXQ9v5G5T4ehWW0Ic7FByC+HvciiuryzvJVyBzgNqOAZhFr3SuIX9SoorS3AONC23sb8R9ZY+oltL1kaHvnlqnnl4jvzjuIT9Ex+fq76pfFWL7zX8ADXkPaI16cJrS9G0Pb262rshSlGnRr1+UocLdGnL4mIk5ce8bi6bd6UnEUuLMRZ8P6WDz9RE/K6EZdwxCfh2OQEeYmwHuIp/yVsXi6oiWvUeBeijj7AbwVi6d37Htplf7CjCgvAdot3zmrwjxfADoK/CpKpfk84ldziOU7y8ql6ylmVch5lu/8oq/L7g/MS9wFjrB8pz20vfOHiuwDjelf4y3fua2TNBsDbYV9q5J+qSh5Qtv7HOJQfShidX0feBD4peU7bxWlvR2ZvizHcst3NixIvyHiAH8sYhX9M/Azy3f+VVTu3ogl+nHLd77e3WuoeOlyFLibIascPgcsBd5C5rUHNVHgjkScJg8xhxYi3v7bISOv70aBOyMWT1/QRTlfQubq32L1qgtlaHEdsnLkuEozWL7zagVp/oWM4PuLEYilYUhgVslMLDjUb/FF1gEWIxbAspSY+qyoXyoKQGh7+yFL6jcBPkamvLdHVgceE9reEZbv/KUgS37a92XE96uYYuukj/gTfmA+3wLGh7Y3rihUwunm71U9uY7uxFk5BVFUbgVOisXTS3tSYRX4KaKofARMisXTfwSIAncDJL7GNcD5UeC+EYunZ3dSzq8Q5awe+Fcn6ZRBiuU7JZfuDnaMk+p/qi1HTykeYSmrqWA6UFF6TGh7Y5Ap0E2A6cAsy3eWh7Y3Cpn+Pg+4M7S9z1u+k1dM8srKEV39dk0MqSORFXXHGj+3cxAn/VMwIQfM9PLRwL8R5/lu0x2flbzZxh1CigpIvAqAc/KKCkAsnm6PxdO3I0tIlwEzo8AdUaqAKHC/hyg8F8Xi6Xf7W2BFURRF6QMOQFa33WP5jmtCGmD5znLLd85HLC5jEWtInlrEv6tcuIZC8jGFmgpW/jUhTuiF8YZOQSzEmUp8rErRHWUlr231yEelimQR68rdpU7G4ukXEDPstqwd2IoocDdCAlW9DVzaf2IqiqIoSt9h+c5Dlu/krRqlyK/+2hFkpRlihXnX8p2VZfIUkldQYgXHRiGKyUpT5igk9MRiuo5oXZYup4GiwC32wF0eBS7AQbF4em5ButFAElm/vxuwEWK6/itwdSyefqpMFT+OAtdDlvyNQLS5+4BLY/F0r02ksXi6kvnyvAa5XYlz5yDLE38wxCxKiqIoikLeolKIcdzP+9q9af7mI2u/FdrepkjAxzFIqIJSy9rzIRguD23vWMRx9zJkFVuzOXcs8Bkga1b69YhKLCvPmM+you9RPkEUuGOR5ZGXIj4dbUicgy2BHwDzosAt5y/wQyTq4wrEmWcX4DTgmShw67p5PT3FMn/X8AuIAncn4Exk1dCcAZJFURRFUfoNY+24DJlNeAvxa4HVMyhfQRajPIzMSrxoQhCsESfI8p2XkPf+eMQhdyHyTn+K1VaUU5HwB1fTC7q0rMTi6X0AosD9B/DF/Pcickiwoz8DZ8Xi6U+DQUWBexiyvv+aKHDnxeLpYu3sbODXsXj6I5P+y8DlSByAOVHg1sXi6X5bdRQF7kTgIMSLuTiI1ZWIhnh6LJ7uaURRRVEURakqJhbUZcg0zc7I7Mc7yJ5Yxc61GwP/RXxaOoAGJD7VY6HtWZbvvJ4v1/Kds0Lbew7Zb21jZIuOS40j70GI4vOQ5Tv5va16RK93XY4CdzfgCCTY0GHFikUsnn4oCtyjgSeAnyFBtwp5LK+omPQvGQXiCcTicTjQ3YBYlco+Adk8DeDCWDy9pODcRMTp6I5YPD2vP+pXFEVRlAFic9aOtt2KrJTN8yckllgd8FPLdxYBmOjLtyDvxCuRFUCfYvnOHErPPvzM/L2yt8L3RQTb/Cqhe8tZQGLx9JPAAmQjsS4xVoyLzdfDei1hEVHgDo8C10Xm2zYBronF01cXnB+JrAVfjlh+FEVRFGXIYvnO7y3fqUEsK+MRI8DewEPGsRbLd/5r+c7llu8cn1dUzPGPkaCqHwCHmW02OiW0vZ0Q5eYfrL1nVrfptWUFcZwBOCMK3DO6SNvejXJfMn8/232RyhMF7rcRReiLiDJyRqGiYvhfYFdkqfKbfVm/oiiKolQLs8T4OeCo0PbuRawkP0B24u4s3+LQ9u4BfoS4ffypi6p+ihhErrJ8pwMgtL1vILFX9gYWIdaY8y3f6XLxSl9YVvJTJwtY7Xxb7tPSjXJ7tBa7HFHg7hYF7h+BPyCKymNAXQlFBVbvm3F2FLgdxR9EM92h4Nj0vpS1u0SBOzsK3OHm/+FmK4NBSxS4M6LA3dH8v28UuBub/3eMAndGNWXrKVHgHh4F7u39VX42ldsxm8rNKPg+NZvKHdJZnr6op5dlTc+mcrv0VNZsKndANpWbUObcedlU7k/m/59kU7lbs6ncnGwqd0ovxc6XPz2bypXaoLHfyKZyI7Kp3NcKvt9i/s7OpnJ9MbDsst5S152Xo4syehylOJvKTcimcif2prxsKjcjm8rtaP7/RjaV+0Y38x9UiVxl8t5S9L1bdVeZfDiOCRWmf9/8HdNZotD2YkACmWK62RyrR2Yz6szfBYhhoKLnZl/8APJhn/8Yi6crDmNeAbubv5UEpumUKHBPQiLVjkA8n38ei6fv6CTLK3R+M8Yja8jzu8IO2eiig4AVsXh6rXDiQ5BJrN5obp0im8odjJhyv5nMJG4awKpLhfrOcy/wpWwqVwdsn8wkjgXIpnKXZlO53ZOZxN8HRMK+ZTTi8Dio682mcnsA45KZRFVWSGZTubHAsclMotTGpiD9ppIYIYV82HWSivmkD8vqb/LXXanhIv9e7ire2o8QF4uLC5x3z0FW/dZZvvMGQGh7HnByaHt7Wb7zXGcFVryRYcFqoJqi45sgL+slwK6xeHpRqfwlyptNJxsZGivIIcAxsXi67CZfFdTzNcSKAnAhMrXTq83mosBdBrQOlo0MTVueGIunVxkLyw2IcnYScl8WxuLpGUV5fobEw1kMPIsEB0oiwX12QXyRLkYU2g5kt+JTgWGI+e6VWDz9q6Iyz0SC620F/Kowtk4UuDEj1wrEhHgUcCKiQG4LnI84Y30DWZd/Xiye/oHJewuyFL4OCdc8HPFkj5A4PnciI4SNECXz58iOtZ3J+iYyjzoC2dxwGTDNtFcNshFfgJhLR5h2ajd1XFAYyTgK3EMRB7JZSF8739RbE4unT48C90Jga/O5D9lM85pYPP1qFLj3AkfF4ulVhfJlU7lNEc/9RcAWiOn0RGBTxNt+tJH5GOQhsNDcr6VIxMrTESf1F4FrkpnEUwVl70tB30hmEoUWmx2RAE75eu4q0bbHAY8mM4knsqncdUAa+CbSZyIkgOJ9yIgpNJ9CWZeWaOsksp3HBOAMZESWMmlfTGYSa+0nYka0TwN/SWYSz5hjewNfS2YSVxekm87qvvNRMpNIZ1O5XyIW0m2MTD5yrzcHLkCUz92NfH9NZhJXlMhzh2nfGmB2MpN4rKDO4Yjf21KT/iem3NHIgoSJyUzibwXpD0csuh3IFPjbJn8TcCBy7y8sqj+/v0uEBPU6ssS92scc/3/ICPd+pI+OAs4F9iqqd1vglmQm8elqj2wqdz8yCt4QGRG/gTwj7kf221oE1CcziV2zqdyFiGvAcuABYB7y21iJrCaZDOzHmn3leeAX5v4sQfrCX5BB42eAs5KZRN4tIN9HTwQuYu1nykRzzRsB1xXdkw2BXDKTmJJN5bZHfiNXmrZchDxX7kF+RyESFn4msgP65shv5ihkdcvGJu2m5r6eiSj0aeRZ8X4ykyi3m/aAYULfHwOcUrT/T/78L5HNic+yfOdSswnph4WrfQrS1gOPI3sLfTE/tVMi3QbIvfs8sJPlO/82x/8BLLZ8Z++CtN9C2nGy5TudWlh6PQ0Ui6c/Rm74Z4A/RIG7beH5KHBHRoH7gyhw/543/ReRiAJ3y4L0o6LAvRpRVN7G7CNgyqktkb8rTkCu84pYPO32VlEZxMyMAncW8uMCsXi9hrzEvlmYMArcTRFFsRV5YNTH4unnkZDIK5H5y8OQYHgLEe17gsl+WiyeTgF7R4G7huKKLF3/xKSfWHRuMuAZ69v95tgjyEOtHVFSrgIejMXT5Za4XRiLp09FlKGfmf8PQx62L8Xi6R8jD4v8VEBnsr4Yi6dPRhSkU5AX42JkuR7Iy+1dk+YnwLamvl+Za/mUWDz9MPBsLJ6+GVHcW0w5B0eB+3mgPRZPO6z2iL8GSEaBuzcQFisqho+RB8MnyDLD7YyMTyUzibxV8FrkQf53xJw6I5lJ/Bh56R4I/CuZSUwtVFQMZfuGobCeOPCSKTfftjcBx2VTudHAhslMYgGiYLxr5N03mUn8E1FYLi8h61ptncwkZiKrDe5NZhIPmOs5PplJnAh8JZvKbVRCzlLUIC/eYn6RzCROBcZkU7nPAH80MqxE+t4ryUziZMR0fabJ05jMJL4P7GHqL86zIJlJnIA8Y04orCyZSaxC+vcSZAAwLplJnIHM819WqKgYnkVM7O8DRyYziQeBMJlJ3FiQprj+BHBcMpNIIo6Ppe7VWERRudaU8SeT/kpkULBGvWXadHEyk0gkM4kpyBLWPCng9GQmcTzwZDaVG4coIQuQe/sNZP+1W0yd95l8a/QVc+wmYx2bjzxr/pnMJKYiSuNpZeSaDHjJTCL/TNkEUZpOQBTqNWJ7JTOJZcD72VTus8DxwGwjx4tGloNN0puTmUQKcUX4jekXv0Ha93FEkX4HOCqZSdyC3Kd7EOUvadK3D/Q0Yhk+QhS5+0PbOy60vWEgkWpD25uGDBoWAL8Obe/LyABtXmh73ytIWxPa3vcQa+YGwNnlFBXDEYgye3deUTG8AowLbe8QU+6GrL5HaylHxfSFzwrIBkl3IQ/IN6PAbY4C9+YocB9AXoi/QUZN40vkPQF4Nwrcecaa0oo45ixDosbmI+89CfzH7NPTHfI7JH8/Ctynu/h8pZtlDybOjcXT05AfDObvXGNRebso7QpESbgYGdHkV17NAGbH4unXkBHhf5BR7+XICwpkBJJnWFG5LjLaybB23xrGmtOOmyIP018g/WMDxCKQVyra4FOLTJ6Pzd8lrJ4iGGGup70gX16uzmRdBJ8q25sh1zs/Fk9PB65ArAofmzSF9S0xspfjRMTqdiHyENzYfD4lFk+/ioxgTwGuL1POREQpm46MhP+NbOl+ZDaVy1/LncgLB0q3QTnF/FxgrrGoFPcNiupZq9xkJtGKvBiOQywSIC/Qq5E+cL45Vng/C2VdCsxPZhLTMW1tRssnIw9PimRvZ+37l+dPrKk8Tqa041++L0RI2ydZs+8VUvx9FDCyRJ5FAMlMoqNYvmwq92UkfpOLjBw3yKZy+yBWn1LLOC9GXpIzWd3PCxckbFyi/s2MXHlK3asbEAvXVciAMt8O+X5fqt5iCld5Fr6kin/TS5H2nYFYGa+lRP+ndF/JM6KozBrEolOK4vpXsub0T/EABURBmQrsnswknkd+rwuSmcSFrA49X9j38u+fJYi1pgl5vs1gdT/Jt/lKVvtaFj6Hqsl1iIU2hljW3g9t72+IctoEvAccaVb+5AcYn0F+r++HtvcioszcifSX0yzf6WojwrxyWWwNnYm01cOh7b2CvF+OBO6zfKc4xtla9ImyYkaGtvk8jGhyk5Foti8hZrZdYvF0qf15jkUacSfEmrISMa/uHYunHytI929EW1/YTfHynXkHxAO5s0+sVAFDlKeA06PAvQKz70Mes23ArYgF4EXg0Chwvwl8H5gcBe5MJFTyGGQU3oxoyl3Rijz8Gkuc+y1wUhS41yKj+fzL/xJWx95ZANSbwIDPRYF7FatH5p3xKDAuCtzrkId5poI8xWSAVBS4LyNBDLfoQRkgJuPJUeBeCexlgiAujQL3LmSH0/zD705gRCyeXhAF7h5R4CaKynkdCYV9JatHs68iD58Lzfc7kBHc4ciLIW2mZcYjVq5yPAWcnk3l1uobJep5FBhnyi1sWx8ZIT9kvl+CTMm9jFjmQCw8F5SQNQOksqlcYVvfivxWr8mmcvXIyoSbsqnc9cDfkplEST+AZCbxAvCGca6dA7xegb9KfvrpCmTKC2DXbCp3E/Iyu8wcOy+byt2ImPdL5emMBchA6QrkuQgyoBuTTeWuy6ZyXyhK/6yp71JEEQR4O5vKJTuR+WLg7mwq91uTZ617lU3lDkOmAVZQ2peiVL2Vci1wUTaVywDjk5nEa8DfkfYKkX54IzApm8rdgWwqu5zSfWVyNpXLIpaZZmDHbCp3NaKYlYt8+lvgpGwql3+mLAWeN33mJkqsbklmEs+ZtPl3ywvA983171XBNb+GTDEX7hO3PJvKfQ+5N9eb9h8BdGRTub704+w2lu90WL5zJmKBfhBpo50RReESYE/Ld542aZdbvnMcYkG6G1HavoC8k28D9rN8Z63p2EJMhNuDgact3/lrkSwhYjX7C7LKd5mRody+RWtQsc/KQBAF7rBYPN2nq4AUpdqY6Z5tER+IG5ER16+Qaaq3zb5a+xQp58oAkk3lbklmEj/oOuXgIZvKjQG+jbEmJDMJv0y60cCyZCbRndARfYZRUNuQIJ8zjCVKUbrFoFJWFEVRFEVRiukrnxVFURRFUZR+QZUVRVEURVEGNaqsKIqiKIoyqFFlRVEURVGUQY0qK4qiKIqiDGpUWVEURVEUZVCjyoqiKIqiKIMaVVYURVEURRnUqLKiKIqiKMqg5v8DCucPJJD2T38AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 10\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 11\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 12\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 14\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 15\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 16\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 17\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 18\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 22\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 23\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 24\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 25\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:5: FutureWarning: \n", "Passing list-likes to .loc or [] with any missing label will raise\n", "KeyError in the future, you can use .reindex() as an alternative.\n", "\n", "See the documentation here:\n", "https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike\n", " \"\"\"\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "comp 26\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 29\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:37: FutureWarning: \n", "Passing list-likes to .loc or [] with any missing label will raise\n", "KeyError in the future, you can use .reindex() as an alternative.\n", "\n", "See the documentation here:\n", "https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 30\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 31\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAFaCAYAAADfOB3RAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde5xbdZ34/9dJZqad6YTSe1ouLbTclEsKOFJw3WrEeFmVFVkQr78BhS5j0boXwqr5ZdUNul4WLI5IHS/rdlHUdQUvUc9atQqEqocKCKWlBUp72tJpIdNJO5ec7x+fk2kmkzNJZpKcXN7Px2MemUlOks+0k+R9Pu/P+/3RLMtCCCGEEKJWedwegBBCCCHEZCRYEUIIIURNk2BFCCGEEDVNghUhhBBC1DQJVoQQQghR0yRYEUIIIURNk2BFCCGEEDVNghUhRMNJxGKvSMRifrfHIYQoDwlWhBBjenv62qrxPKahv67CT/E/wBUVfg4hRJVIsCKEyPbOSjyoaejzTUNfZH/fQVYgYRq61zT0c6f62IlYbEYiFvtoIhbzTnLMqkQsFpzqcwgh3NXi9gDqVTIebQW6gQ2+UGTU7fEIUSanV+hx1wFftL9/I7Aj67Z3Ac9M47HPBCLAxYlY7FfAzcBJwOcSsdirgf8F7ga+C+jTeB4hhEtkZqUEyXh0ZTIeXZ+MR58EUsBXgKPJePTRZDz6hWQ8eo7LQxRiul7Z29M3pwKPu8ofCB7IfA8MZt3WDTww1QfuCof/DLwBeAewHvgpaubmI8DZwD3Ar4AbpvocQgh3ycxKEZLx6BLgS8Db89zcArzc/vpwMh79L+AjvlDkhSoOUYhp6+3pWwA8B1wD9JbrcU1DXwF0ZF3lBS4G7rJTQmf6A8GhaT7NLPtxL+8Kh8dmTxKx2DeAODC/KxyWGVAh6pQmuy5PLhmPXoA6U1tcwt12AW/whSJPVmRQQpRZb0/fycBnUOma64Cn16zvvqccj20a+kXA/wEn+QPBAdPQ3wF8HZWqaQEOAmf4A8HtpT52IhabB2jAHYCvKxx+S55jLgYeBlYCu4EjXeFwaqq/jxCi+mRmZRLJeHQB8DOg1BLIZcDPkvFowBeKvFj2gQkxTb09fScCn0YF4aehZlRuXLO+ex/wb709fe/q7enbhgq89wDfW7O++/7enr5Va9Z3l5qyeQyV9okA/4haQzIAvN8fCN5hGnoC+DLw+in8Ks8DM+zvP+dwzBP25Z/syzBw2xSeSwjhElmzMrkokAYOZV03APwFyExJjdo/Z+fgXwBmArdWYYxClGzN+u7Da9Z33wS81/7aDPxzb0+f1tvT9xYgCPw98H7gujXru++37/raUp/LHwgeBf4Z+LBp6Kf7A8Fh1ILX99mH3Ai8xjT0qVQinQQsQK1LcVozlrl+pX3s7VN4HiGEiyQNNIlkPLoR9YY6E/g1Ku9+qS8U6U/Go+8A7gVe4wtFNiXjUT/wEHYKCBXkbPCFIu9xZfBClKi3p+9VwPnAWWvWd9+c5/aVwOeB4Jr13QXfOExD14CrgQDwMeARIOIPBL9nGvo5wEP+QPAE+9i7gWOooGkZcLc/EDxY7NgTsdjrUbOguWtWWoGfA21d4fBlxT6eEKK2yMyKAzsF9C1fKDLsC0WSwL8Ad/pCkX77kO8Dv/WFIpsAfKGIiTpb/GdfKJLyhSLHgB8m49F2F4YvRMnWrO/eDFwJbMi+vren78zenr6PoRaZ3wFs7u3p+0BvT99Mp8cyDb0d+DGQ8geCt/gDwRHgz8A2+5BdQPaarj8Cf/EHgvcA/wn8t2noq0oYfhI1y/mTRCz274lY7G2JWOx61AnEauCFyfqwCCFqmwQrzg4Bv8n6+efAxswPvlDEAh7Puc9dvlDkwZz7HKvYCIUovyfJ+rvu7el795r13dvWrO/+FGoB7oeA161Z3333mvXdRyd5nA8Bz/kDwf/Num6GPxDcan//cuCHWbedi+o6iz8QfB74/8kJmpwkYrHzUBU/37efN2Q/9hfs3+Ua4DXAXcU8nhCi9sgCWwe+UGQEGMn6eRRVtTDZfQ7k/JyszOiEqJg/r1nfnV3i+0rg2wBr1nff19vTd+Ga9d3FVNIsQq0PAcA09E6OL3QFeBVqnUlGqz8Q3JP1s5/iK/C2Af8KfNEuT/5qIhbbDXyqKxz+CkAiFnsOkFlOIeqUBCtCiGy/y3zT29P3VuCc3p6+k9es795tX/3TIh/nl8BPTEOPoGZkjgCfzbr9W/5AsD/r57HF6KahvxU1C/LLYp6oKxw+hnMlUOaY3xc5biFEDZIFtiVKxqMeXyiStr//ii8UudHtMQlRTr09fW9CdYBdiqri+TIqxfLjNeu7n5jsvtlMQ/8KqmvsftT6ld+hZkF2odaYHEGdMC1EdZpdDbwNVb2zE3i1PxDcnfu4xUjEYiuB57vC4f1Tub8QorZIsFKiZDx6A2AAW4C7faFIt8tDEqIienv6zgK+AVy2Zn13eiqPYRr6+4BPAScXeZcUaoHtLf5A8FChg4UQzUEW2JbuHuCfUAv6vuXyWISomDXru59EzaZMKVAB8AeC30Q1nXsr8FVU1c8LqKDkCHDAvu6bqH4rS/yB4A0SqAghssmalRLZHWmvdHscQlTJr6f7AHbZ8n32lxBClEzSQEIIIYSoaZIGEkIIIURNk2BFCCGEEDVNghUhhBBC1DQJVoQQQghR0yRYEUIIIURNk2AFMA19k2nom0q9XzIevToZj15dgSEJ0dCe+tF/P/bUj/77MbfHIYSoD9JnZRp8och33B6DEPXId+rCA4WPEkIIRYKVaUjGo6cA+EKR59weixD1ZPjI0Rluj0EIUT8kWJme/7QvV7s5CCHqzUFj+zkAp1zm9kiEEPVA1qwIIYQQoqZJsCKEEEKImibBihBCCCFqmgQrQgghhKhpssB2ej7v9gCEqEe+ZX6poBNCFE2ClWnwhSL3FTrGNPTZwLeBhUA78M/AL4DPAK8GNOD7/kAwZhq6F/gmsMwfCL7KNPTrgG4gDXzIHwgalflNhKiuWSfNP+j2GIQQ9UOClWlIxqNnAXOAUWCXLxTJ1+jqjcB9/kDwq6ahzwE2AV3AU/5A8KMApqF/2jT09wE/AX4M3GQf+05/IHiZaegnAD8EXlvxX0qIKhh68Ui722PIlYjFOoElwJ6ucHgg93Y58RDCPbJmZXp+APwO9Yb1TDIevSb3AH8geI8/EPyq/f0hYBfwT8BdWYd9Gni3PxA84A8E/9u+7ijQZhp6GzAbmPDmKUS96n9051n9j+48y+1xACRisZZELHYHsB/YAuxPxGJ3JGKx3JO5zInHK4G/Bm4D/gV14vEKfyB4MdBpn3jMRZ14kH3iAbwZ+EJVfjEhGojMrADayOAKzUp3JuPRTSXcrRV4mf39bPuyLxmP6g4zLJiG3g3MA/7oDwStzPX+QHDQNPRxHT39gWDKNPSngceB+cCHSxibEKJ4XwCuQ82WZFxnX67NXOEPBO/J+v6Qaei7UCcenVn3+zTwv/5A8JvAf5uGfhNy4iHEtEmwUoK0p63V8rbP1EZTRz3poZl5DhkClgHjghXT0FcAXwL2AW8Afm4auscfCKbt22cBqZz7/B3wnD8QXGFPP//MNPTv+gPBwbL/YkJUmWXRDngTsdimQsdqLV5vS/uMtpHUsSFrZHS0zEPxApcycZa5A7g+EYvd6pASkhMPIapIghXAaunYbgG+UGS10zGmoV8D9KECkjbPcPLm9v5HvsL4N7k2VJon+37nonLXN/kDwQft634B/D2w3j7sE0DupohzUMENqDOxNOqNVYjmoGnavPNOW97hn7vYwrI0NG3Q7N978M87d2BZVuEHKEob4PRYI6g1LNsyV8iJh5gO09A3AfgDwdXujqT+SLCirEDlmjc53N4KXIIKTNoB0q2+29N4tntIrwCSqDe97jwpoBAq8LjNNPTMdR8AekxDf9h+zB8BX8+53zeAL5qGHrcf+/P+QDA55d9QiBqiaeoDvSscXu10jGnodwAXAx7Nvm7WSfPnzDpp/iP+QHCt0/1KYS+q3c/4FFBGC7Anazxy4iGES7TynaDUL9PQd6Pyzk4r9H3ABYx/g3mxdeCZW9uOPJdCvfk85AtFnqjsSIVoDDt//v0DaLS3Lzhxi8MhTukZUDMXC/2BYFnWftiLa69DpX4yBoGvdYXDY0GRaegfBW4Cns067gNAT2aso8eGf/b8r4xvYll7usLhAdPQNwNB4IvActSJx5f8geAPyjF2UV9kZmXqZGZF2Q7Of0CmoS8AnmH82VdbS2r/CHAndmooGY92+0KRe/I9hhDiuPaFJx5DzVg6KSk9M03r7Mvr7cduAb6WdT0A/kDw8+RvBHmzXTn0BeAjwIeAlkQstgFY3RUOj6BmX0SzsywNa+QEt4dRjyRYoXA10CxgqN2/c9h3+tlYloWmaa0vPfWsJ32sl6zUEAWqgYQQytH+pAmw7LVXrM53u2noRadnpssOJtYmYrFbmaTPSgFFVRSJJmeNdnhGBgPJeHSOLxQ55PZw6okEK4AFHjSPN+1pa/Wkh4bzHdOWMg+0HOs/nFMNlDtFnbcaSAgx3qHHnzkP8O5/yLkaaN75p/e3++cu9ng9Y6+z9Gg6nTL7+w9uffr+Z3+aKPu4MpVHD//7Z0upPJpSRZFoSpnlV35AgpUSNH2wYhr6NbR0LLLASi3oWgl0Z/dTcJKMRxcAJgWqgYQQU3Pwzzt3zAOyq4FSmWqgcpte5VE1U1aiMZwM/MXtQdSTpg5W7LUofRwPONqBPtPQdX8gOOnsiC8UOZCMR58AzmbyaiAhRI5iqoEyTEPv1Oz0zPI3Xz2w/M3lH890Ko9KqSgSwrYc1flcFKmpgxVUymaI8W8ypaRyDgCHUU2enPYGEkLk8njaNQ3vJO0C8soq/y+nSdM4pqHfOlnlUVc4PGAvpnWqKKpoCshe37ME2FOuCilRcee4PYB60+zByi7UjEg2x1SOPROzDNiVNfMy7AtFHq7Q+IQQlVeONE5RFUXlZBp6pgJp7DlNQ98ArPMHgiOVel5RFhe6PYB609TBij8QPGC3zf4v1JvVEGrNyoQZktwOtqahd8+CW6s6YCEaxOwVSx6D2ug3UY7KozJVFJVKKpDqkjYMXJCMRz2+UCTt9mjqhTSFA0xD34Nq/LYVyFcNlN3BNiMFLC20tkUIMVERjRirbQWwmPGv8TRqEf1TroxoclVrmifKx/xjfItnZPBl7Ye29gOv94Uij7s9pnqR7w+9GaWBUSYGKq2oIKaTidPEQ61Hdr8lGY9eWoXxCdFQjh58qe1of7KWWs7vAPai3gsyr3UNVWK6guMlp7WimNSVqF1PoIJNUaSmTgNlmdDBNjftgwpmst9c21oG91yHCnBWI4Qo2uEnnm0DRgM33bza7bFkMw29F3gfKrWi2V9zgLLtR1QO1WyaJypiG/BqYIPbA6kXEqwouRsZTti4EBW0pDgevHR70kM3VnmcQjSGKVYDVdi0qoKqyR8IDtiLafNWINXKOIWjvwA3uz2IeiJpIMWDeqPK7FUyk4lTrCngbcDlqLUqsgeQqEmmoXeahn6mffYtildvqZV1qIqjFKrXU4oKVyCJsnkWWJyMR2e7PZB60fQzK3a6ZxHqTWol0A3o5Nm4EDBkQa2oVXVVyppOpyxqoxooo95SK/b/6VrT0McqkGRGpW6kgZ3A+cBvXR5LXWjqmZWcDrZe7A629s3dqDOVF+3LvCXNQtSQ7FJWn315nX29KMD+oN+ASqVkGwQ21Gog4A8EB/yB4LZaHZ9wtBvVAV0UodlnVpbh0MHWHwjeYxq6zsQmcNk+XOgJ7D2EliEdbkUF2bMC1zNxVqADuMk09JWoReIVMXws7T0yMNI2q7NlqHWGp+DzzD33NK9lWblBQS2oenM30bQOAkvdHkS9aPZgZReTdLC1AxTHAMMXikzaIyIZj46rKErGo92+UETWuohKWIL6cM3HQv1dp8r9pOlRS/vDb15Yvmfn4GJN0yzLsrQlp3XsvejV83d4vJpjE6e22bPytQpwnaRWRBUdRpXGiyI0dbAy1sHWsjYCGljp1uTTO9tS5r3J+OZiHmKOfZlvq+98FUV9yXhUlxkWUQF7cH49DwHBSnzo9vb0jW0AmFmbunvH4JzdO559ZM36bsdS36d/du8j5R5LOdn/VrJTsqiko8A8twdRL5o6WAHwB4L3mFvu+4IGvpmHHt3qSQ+VcraXmcLLF6zkqyiadJNESRmJqXKjlLW3p2/S1FNvT59j6qnrrIGXo028zd7BuFrt6oVw0yjHK1BFAU0frADQ0rHNAmZfXni7+mzJeHQTgC8UmXA/O/DIV1G0y+GxJGUkpqva6y3KlnpKxGITKpnsnYzX2fvuCNFoNFRVkCiCBCuANjK4QrPSnZngowQBOB605LETtdrbQv1h7gTuTcajucdJykhMmwvrLQqmntas7877/Madtx/OuUo25RPNxksNrtuqVRKsABZ40DzetKettcQ0UCEHUIuoZqLyk06PXXLKSAgn1VpvsWZ990BvT59j6skpUAGwLNoBbyIW20SBzrGJWOzWU9/YBbLgVTQWL84zkyJH0wcrpqFfQ0vHIgus1IKulah+KkWlXyZLA5Wi1JSREDWkHKkn586xGiNLVge+DLyDWm90J0RpLJq811kpmvofyqkpnH19MW6wv6bFTvVMaEInKSBR69as7x6xq34WoqqCFq5Z3712zfruSQOJeeedZsw777Q/dIXDq4EgaiZxgjnnLG33zmi9Eml0JxpPCjjB7UHUC82yHFshNDzT0F8B/ALI3p/hReByfyD4cLXH40Y1kFQgCTeYhr4b6AQMgBeMHSsG9/UvJm2NnUBprd70ya9dqWkej5bnIVLAwqmkhKTiSLjF/GN8i2dk8GXth7ZejVrP+E5fKHKh2+OqB82eBtrFJE3hCknGo28B8IUi95VjMHawULWAQSqQhFsGzf6ZaFpLxyLVqmje+aftYCsM7utfrIFlgdZ50oIDaNp81KxnrszGgkWvzZGKI1FjngPOTMajrb5QRBbaFtDUwUoZmsJlqoEm7WRbo6QCSbjmpR17WoCR00PvWJ25bvGFatbDsmc95pxzKpR3Y0GpOBK15Ahqf6BLgV+7PJaa19RpoAxzy3178jWFS3vaWi1v+0xtNHXUoUooYF/WY7DiAy5g/Fnri8DlvlCk6ikw0Vz+tP72Y4B3ODk46VnBvPNPX9Hun7vY4/WMpYfSo+l0yuzfe3Dr09tLeEqniiOwU0r1mBKy94SSKqk6kZMGArgSSPtCkW43x1UPmnpmZUyepnCmoY9LkZCnSqhc1UBukAokUQ8O/nnnjnlAh3/uYgvL0tC0lNm/9+Cfd+4o8aGcK46mkFJym2noE1JaUiVVl34JrE/Gox/zhSKlzhQ2FQlWlBVAp2nom+yf86ZITEPXHXZfrju+UORAMh7tJicgkxSQqAZNU51t7WqggkxD79TsGYTlb756YPmbS3s+e1FtOVNKbpOUVmN4EVXk8SlURahwIMFKfmVr0lbL1Ta+UOSeZDyqU6PjE1Nj79mzBNgzWWM2V3k87ZqGN+sEoWimoZf8dKe+sYsXjB39uRVHeLR0x6K5/fMDy++fyuO6ZNImeqah3yopobryPeBLyXj0Vb5QpKjFks1IghVlO4A/EFwNY/1XikmRvGeyB62HaptqVyCJyunt6ZuQGrA7zK4r1Pek2uZfsLwfbVzX24rLV3HUsWju3nnnn1ZqSsltDZXSEgwCdwPfSsaj5/lCkSNuD6gWSbDCxL2BZgFD7f6dw77Tz8ayLDRNm6xKKM9ePyDVNqL66iY10NIx40k4foJQLbkVR+e+/4N1NwNhL6ptpJSWgAeBVwB3cPw1K7JIsOKgLWUeaDnWf7hANVCm022+4EP2+xEVl5XyeRE1o5L7AdYB3NTb07cStSV9Tbjsr2a8wuPRjvoDhY8tN7vqp25nHvyB4IC9mDbvnkySAqpbG4DPJ+PRd/hCke+5PZhaI8EKYLV0bLcovaonuxood22KVNuISsqT8mklf/M0UEFzG6pEtyYM7z84A03ef6ahHHsyidqSAr4IfCUZjz7kC0Wec3tAtUTeLMrAaW2KVNuICsqX8nEyBARrabGtcefth90eQz2zy5PXmoZ+K9JnpZE8BdwPfDsZj77GF4qk3R5QrZCmcMC+Lfft1qx0Z3u/UWpztwCgofY4yV6ZnwKWZs2wLEOqbUSZ2KkfpzULudLAXuxF5NXW0qZ5Z3W2tB0ZGBkaGbLG0lBdZw28Co3Ri3rWznBjXEK4IU9TuHw8wKeBr/hCkfVVGlrNk5mVEjh0tPUwydoUqbYRFbAENfWfj5X1paEClapXu2getAv/at7yk06ftdiyLEvTNO35p4/s/eNvD+6w0o6VLEIIdYJxJ/DpZDz6P75Q5Hm3B1QLJFihuDUr+Traztq3+UbUWoGVyNoUUT17cH7tHgVOQ+0k7lqfFdPQ7wAuBjwqZoJTz+icc+oZnY/4A8G1kgYSYlK7gTjwOeCdLo+lJkgaiInb1eeRXYackWo9sntl28Cug8DrmLg2pab6qYjG8rWPfqO3babnfakjo+2jI2Ov4UHga2vWd7taplygtDYN/H702PD5wJGTXvmGJVUdnBAuKjINlDETNcPyZtmvTWZWipWvDHlkeNbJlwzPOvkn/kBQOsGKqsjsCfOmd5/8vvSo1QLwzLYjQ1sf6B+1rJqpBimUpmrzzmi1UIGLECK/o8C9wGeA17o8FtdJsKKM62Cby6GjrQ8r3Qua1zT09/nVTIoEKaLSvgBcp2lau7dFpVdOO6dzdOmZs7550sWX10rjt8nSVENA8KWd5hYAN/qsCFFHfgG8LRmPvtoXivzG7cG4SYIVJXcjw3x2AmejzgxVPwvN05CbHIraZKdXJjR+swOXD5qGfi610/itH1jM+NRp2r7+/tS+/hWWVTNjLZn9fyElw6LSRlF7B30S+GuXx+Kq3I2whLMDwBbgOSZ+IGSqf4SopILplSqOpZAdqEqkNOr1kimhrrd9eMYxDb3FXjy8H/V+sN809Dvs9JwQlbAJWJ6MR5s6WJEXmDJpGgjGVQMNM7FTqFT/iGoomF6ptbN8pxkI83eP1ms1UN3svyQaRmZ25dPJePSvfKFIU1bFSLCiFEoD5duUENKjo2iahubplhSQqLR63BPGHtPEfXg8nnZNw1sg9VoT0sMj3pHUsbaW9hkjntaW3KpAUP8X15uGfmst/h+IhvAr4G9Rlae/cHksrpBgpTj5qoFeaht4Zo/36IGXPNbwjmR88wKpAhJVIHvCVImVTmsHt+5cPmj2L9Y0LG/7DG3xZedqmjdv9nwENYNUtxskipqWBr4D3JaMR3/ZjLMrEqwoU6kGavUeO3inxxr+LCrSHdsTqNKDFc2rUfaEWfiKsx6CyVOvbkvEYmON7SwLRo8OjbUFzqMFlaYTolI2o2ZX3gL8yOWxVJ00haO4vYGG2v0Lhn2nn41lWWia1vrSU0+1HT1wBg57AlV80ELUsec237/bGk13mr9/rNT9uKrFC1xKTsrnxHNOpfOUBXi845atZdJwsmZFTKrEpnD5XAK8Cbiw2WZXZGYFsMCD5vGmPW2tWXv+jNOWMg+0HOs/nLU30Mw8h43tCVTJ8QrhpnKU7Q48/8IsLKuWqpdytTEx9cvhJ55F07ShzlMXpjVNG0bScKK6HgKuRZUxb3J3KNXV9MGKaejX0NKxyAIrtaBrJdDtDwQLpnLs3ZTNnKulKkg0rEz3XLLWy9gLftfZ6amiHXvhRQ0Y6gqHV5d9oGWQiMXybxlgwaHHnxlND4+cNnvFSbOp0zScqFsWatnBdTRZsNLUfVbstSh9qH8HL+qNqc++flJ2qucJ1MKnF1EpoG5JAYkGll2267Mvr7Ovbyhd4fAAsAGV4sk2CGw46x3v3ecPBLdJoCJc8ADwpmQ86rB8qjE1+8zKMlTqJvvsqZRUzgHgMPBhKrwnkD2Ts6zSzyNEPk7dc4EOy7Jueu6hX1zUOsOTN4Waj+b1dNZBB1upvBK16AX70o9qtNgUmj1Y2cXErp+lpnKGK70jZjIezTSkG0KqjoQ7HLvnjgxbnl/ft/eS2fPa9l706vk7PF6tIRb+dYXDI8DaRCw2Vnllz7gI4bZj5N/VvGE1dbDiDwQPmIbejWVtBDSw0q3Jp3e2pcx7k/HNxTxEACAZj26q4DDzNaTrS8ajusywiCpy7J6reWBwYNSTPDw4Z/eOZx9Zs767YFVMPXWwtQMU6Z8iakUbcCJNNKsCTR6sAPgDwXvMLfd9QQPfzEOPbnWqBnIwnbLLVlSzuaOoFv5O8jWkk6ojUVVO3XNHhtM8s22A0REL+/qbenv6VpJ/Q0Uv6o12aPUVZ9DS4pFZCiFKdynwkC8USbk9kGpq+mAFgJaObRYw+/LqVCbkpnVQC3PzpnXstSq5Demk6ki4YR2AZVkfGB2xZqLBM9sG+PODh7KPyWyomP1GqgHLUbswW4C2zXhx5OwLT5RgRTSbNhz7ChZlBnA18P6yjKaOSFM4imsK5+AU+/K5Eu6TndbJmLSZXCnBjRCVtunr31/03PYju1JHRmfaMyrZUsDCNeu7xwKR3p6+O8iZkfF4sBYt4KUrPt59YlUGLYTLTEN/LelR3TMyaLUfeuRtU3gIDVXMsdsXiry3zMOreU1dulwG8+yvUkyW1snLDkyWApejghoJVIRrVv9/V+4beHHk7tERK29Zb06gkqkiyt54kXQazdxvzbZvHycRi3UmYrEz7V4nQtQt09DbTUN/u2nocWAjWAen8XDdwCzgxvKMrr5IGgiwWjq2W4AvFFldyv0yC2tLud9U0zr2rMuBrMdYhpQxC/cUW9brWEWkAVbW5n+JWGxC07lELLYBWGdX5ghR00xDnwlcCPwVaofkVcCTwG+Bu4D/AOaW+LAtwBrUotrX+0KR3JOEpiDBSpX5QpEDyXi0m4lpnaKCDiljFrVgzfruEWBtb0/fWFlv9oxKFscqIuv47RnZTecyrrMvZd8dUVNMQ9eAM1Bp/czX2aiT0SeBh1EB/JFpPM1s4B+A3cBrfJtsc6EAACAASURBVKHIdB6rrsmaFaa1ZiVgX06lKqjYaqDc+5S03kVMnZ2imOyDWBQh75oVzWLB7GHr5FmHfmNflXfjQFsKWCg9ToTbTEM/BbgCCKH+Xo+iApOnUTOE21EnkvmlR+70jKROLnLNyhnAPwLfAD7mC0VqvYliRcnMyvRM549nmOKDlAwpY66C3p6+CemI3p6+DcA6e0ZBlGZCymjBicNtp/mHrOGXxo7Ju3GgbYSsdJEQ1WZ3cP46at3gQ8BW4F6gv0JP+UZU1c91vlDkhxV6jroiwQpTX7NSbfZald2os9CMdqSMudwkHVFG+VJGl155xv0A/kBwNUyycaDSwvh0kRDV9g5Uiuc6Jps5mb421PqUxcAlvlDkqQo+V12RYAXQRgZXaFa6s8KdaMuh1f4SFZJVvTJhDxwmb3gmSnDohWOBlhbPgN/+uSscHrAX045LF6EqjL5WqRSQfca8BNk9WUzuF6iTmDnAvgo9xzwgDPwReGuzLqR1IqXLgAUeS/N40562UgOBpfZXtcxE7fKcLcUkZc+iZI7VKxxveCam6djz5ozUs3t8OVevQy1ITAFJ+7IiGweaht5iGvodqNmcLcB+09DvMA1dTuDEBP5A8HlU6mdZhZ5iGXAbqnjiWglUJmr6F6Zp6NfQ0rHIAiu1oGsl0O0PBIuqrplK6fJ0SDfbqnCsXkFN/wZlse30GXfefjg36q7yxoGS6hNFMw395cDLgTsr8PBnAP8CrPGFIt+twOM3hKauBjINPd+HfwpY6g8ECy5YrXawYj+ndLOtsHzVK9jpiGI26ROFGb1fOqZpeBdd8rKidgwts4KVR1NNCUlaqTGZhv4fwMnAN6f1QBOrgU4F/hV4ny8UuX96o2xszT6zsgz1oZ8drAwBy0xDz9y+q5jApVp8ocg9yXhUR5rCVVKxDc9EfSp75ZGdPhpXQWZv/LjOHwhKBVmdMQ29FTgPeDVwDeAHImV+mlnArcDNEqgU1uzByi4mrkFoQ/VP+TX27IVp6EWnhqohu5utKL8SGp6JqUqnUxbHq4GqyZ79KHflkaSV6pDd2O1U4FxUmud8VJByJurv4Engl6h1TeVeWP8B4H98oci3y/y4Damp00Bgr1mBjaju32lUU58V5Gm8ljvDkoxHvw/gC0WurM5ohShdLTa327qhd1DTaFlw0Zm/d2kIK1Dlodmv8zSwF/UeUIqKpZVE+dnp/w8CrwdWohq77UQFJ8+hlgY8Axwr+5MfTwPdCvQAZ8pi2uI0fbACYBr6HsCHWu09E7iA8b1MXgQu9weCD+feV/bpEbUqX3M7oCaa25mGvhvoZGrdn8tBA5ajAhbL/nkvsAPnFJGTduAixr9nZCSBi/2BoDS0qxGmoX8Z1ctkM6ok+XEqEZjkkx650zMyeHL7oa1bgTt8oUhfVZ63ATR7GihjG6gpaYdFt3krbmSfHlHjajk1sR3cSQNlK8eC2AqllUTl3Ao8hlqP8k5U0NrC8Vm1TlRqaMS+7huAiZolczKLYvYA0jyjluaxgGdRM/p5JePR+UC/LxTJLZrLPmY28G1gIepv759RXdFvQ80SHgbe6QtFprPTc82QmRUm7g001O5fMOw7/Wwsy0LTtNbk00+0pczcWZNW1I6aWtZ1sk+PcEXuh66d+nH6AE0Dv8fF5naXXJS+xKMxdMH7rz/BrTGUk92zJW8FmT8QdDswFA5MQ+8A/gfYBJyASgm9FfgNcApwDipwycyaHQAOAodQwcAh+7qzUQHQQwWe8gvAYn8g2DnZQcl4dB1g+EKR/5vkmGuAE3yhyFeT8egc+3fYA7zfF4rsS8ajbwI+4AtF/rbAmOqCzKzk0ZYyD7Qc6z9sedtnaqOpo5700NgePmlPW6vlbZ+pjRxp8VgjWs5dZZ8eUVVOVSgz2j29x1LpQs3tJjtTrKj0wGBLWiP39VPPpIKsPn0a+AwqIDmAOgF9lz8QfCJzgGnom1B7ArWjTggWAyfZ32cW574SeAPqtbXH/noeNSO/h+OpxZnkTxeSjEfbOF7wcS1wfjIeTdg/p3I3MsyexfeFIoeS8egu4JO+UCTTYfcB+3drCBKsUPzeQPZiXJX2SQ+1dRxIWNr4mRVp0CaqLW+qJ3T1Sa0/+sZzNdvczrjz9sNuPXcl2OXJa01DH6sgk0W1tc009MuAdn8g+H+mob/fvvok1CLbbHtRi6SfB14CnrDvfwrwQ+AF4EZU4PIuYACVOloOXIzapTljAWo2Jp8TUJsl/o3980XA+1CN6P6BSWZCk/FoN6pd/5/sn2fbj/UVp/vUGwlWlBVApx1BO2kFLkGt+G/H08Yx3xnWjORTaU0toss0aJNZFVEVduon7z5G3hbPB089c5a5e/uRGen08SoVj4f0ktM6+l/xmgX3272EysmLeh0MUSDFpHk9nZbVeHss2QGKLKatD1cAF9jv+37UiWcbaguVx7OOW0Ke/YD8geBzpqG/CrgduA8V6CwCbvUHgnnXV0z2GeMLRV4A3pKMR78D/J199Sd8ocgnne6TjEdXAF+yx/cGXygymoxH/w74GPA5XyjyLaf71hsJVpy1oqbsjqIWLc0kp0pgdOb8dDplPuYdSV6PVAOJ6pt0H6OVl817Pj1qWXt2Di7WNM2yLEtbclrH3otePX9HmcdRzsoaIarCHwj+Y+Z7e2alBfU3GzEN/Vp/IDhqGvqbUI1B877O/IFgyjT0NPBv2AtsnQKVEpwP/AgV/JzndFAyHj0X1VH3Jl8o8qB9XRS11ma1LxTpn+Y4aooEK8q4yoRx6R57xgTQya0S0jS09NA2XygyoaRZiCqYdB8jj1d77Vs+co292NZaAux5y0euKXtqwl5cejHj+4zMAR5xWly6f8uT+xppwYpoDP5A8FemoS8HHjYNfQT12XCj0/GmoS9F/d1HgdnAv5uG3uoPBIed7jOZZDx6BvB5XyiyIRmPtgL/mIxHZ/lCkXyVRiHU6+y2ZDyaue6VqFTQD+zrtvtCkeunMpZaI9VATOj5kJ3uyUihpgaD5AQxtdTZVjQft6tQCpTtTlZ1FAAG/IHgyRUc3pQkYrGxyqoKbqQoGoBp6G3+QHAo62cNaJlqsCKcyczKRBPSPdhVPv5A8B7T0Mf25anknkHSbE4Uye0qlElTUbhcdVSKRCw2obIqEYttANbZO0ILMU52oGL/bKGWDYgyk2BFGUsDFWoKZwcoBwCS8eh/APhCkQ+XczDSbE4UqwaqUCZNRQHBfON57Jtf3Q3gDwQrOLSS1XITPSGamqSBmHJTOFBT2VDeluGOaSiZYRG1aCqpqD+tv/0Y4B1ODm6uwhCLUXB/H0kJCeEemVnJY7KmcNOUW2GUj2MaCmk2J2qT26moqcoutW7DuXJpBDVrJSXJouLsmfUf+EKRoYIHNxEJVii+KVyuZDy6iSLvl5vaQfVkmZDasdeqFLU3kRC1YCqpKE1T61i6wuHVlR/hePnWpqBKQM9D9vcRLkrGo3OBr6JKlyVYySLBCqCNDK7QrHRnJvgoQQCOBy2TGN9QTulLxqN6bmrHF4ocsLsR5gY2MqsialodNUTLtzblvaixn0GedJakgESVvBX4pS8UGXR7ILVGgpXpKfYPqqTUji8UuScZj45VHUmgIhqNd2ZbC9CaiMU2Vfupyb82pQM4EzXD8j5gRPN6WtpO6Pj+7DNP/niVxyia19uB77o9iFokwQol7Q00Vk5cStnyVFI7doAiQYpoSCeedcphazTdmdpf9S2CCq1N+eKMub5b5l2w/EveGa1XaZp2BfAO09A3AOucOpkKMV3JeNQHrEbN8okcEqwUKberrWnoRTeEk9SOEOO1drZvh+qvWbEbvjk1sWsB9ix65Tn/BlyJmhGdad8mJcyi0t4E/M4XijTUJp/lIqXLTOhgm0/ecuL2Aw9/z5M+dtQXinywmOeRRm/Cid0Jtml2633sW3cPAK3zzj/9gWo/9wvGjhWD+/oXk7aOv549Wrpj0dy98wPLd1KghLkZ/n9E9dkbGP7CF4pscHsstUhmVhQPKpfdSv6S4rxrTizvzJeTPpYs9kkktSNymYY+oTKlGVIOw0eOtmoaXjeee975p+1gKwzu61+sgWWB1rFo7t5555+2g/yv9QwpYRYVkYxH21F7/fS4PZZa1fTBip3eWYR6g1pJnv1+nLraaqOpo1UbqGhUzdk1NZ1OWRzfPLTaFl+oUkKWPZt17vs/OAAF9zqSEmZRKZcDf5IZd2dNHazYQUgfx6d824E+09D17AW0/kDwgGnoE9aceNJDjrtxClGI/cF4PRM/GDuAm0xDX0n+TQDdkt1EbVrj0ryeTsty93ezy5HHzZL4A8EBe2bLqSOvpIBEJVwJ/MDtQdSyfHnZZrKMiY13hoBlpqEvMA39FXZAgz3bshQVAS+V3ZZFGRSzCWAt0IAVqLUcF9mXK+zrG9E6VAfeFJC0L+uhI6+oQ8l4tBX4G+B/3B5LLWvqmRVU6XDuB0Ibqtnbr8mp/MnexNBWzj2BRPOZ0iaA1Wbv/XMx409u5gCPOO39U8jBR3bsLsfYKqEGNocUzeU1wFO+UKRmXxO1oOmrgew1KxtRZ4lp1A7MK8izkWApvVWEO+qtqmYqmwBWU4E1HGng90wtJRQABvyB4MnTGJ4QdS8Zj34FeNoXinzW7bHUsmZPA2XSOyYwADxoXzp1mxU1yjT0FvuDfz+wBdhvGvoddrVNLav1lEO9pKqEqDvJeNQLXIGsVymo1t/Iq2UbqMoEe43KbhhXVtlOnm6zyXj02wC+UOTdVRijmFxdVtXUQcqhIqmqrRu+vA9o9QeC0xmbEPXuUmCfLxTZ7vZAap0EK8oKoNM09E2oXiutRd5PprBrQB1W1UzKNHS3h5CrH1jM+JnYtH39/bnjHT6W9h4ZGGmb1dky1DrDk/ff3RoZned2NZAQNeDtwPfdHkQ9kGBlopmoN+LsmZUUDpsOgnSmrQHFpCpS1RtOw9lhXy5G/XtqwN6s6wFIj1raH37zwvI9OwcXa5pmWZalLTmtY+9Fr56/w+PVmntxnBA5kvGohgpW3uz2WOqBBCvKdhiXBipl08HM8UNAWzIe7faFIlLWXF11UVVT7wotXu7t6cuqGlKxye4dg3N273j2kTXru8el4szfPSr7n4hmdxFwFHjM7YHUg6avBgLYt+W+3ZqV7mzvNwyAoXb/gmHf6WdjWRaaprUmn36iLWXmmzFZCZyQc10KWCozLNVV61U1ja63p6+kqqGuswZehcboRT1rZ1RpiI7qrYJMNIZkPBoD8IUiYbfHUg9kZiWPtpR5oOVY/2HL2z5TG00d9aSHhgHSnrbWnOsGAR/jm2NlKockWKmuTPXM2B471FZVTaMrKRXn6ewY8WgTGjJWVbPuyyTcZ6eArgTe5fZY6oUEK4DV0rHdAnyhyGqnY+x+LOPa7c/at1mntJSRqJA6qKppdAVTcWvWd4/9f9iL2d1WlxVkoiG8DLU+covbA6kXkgYCTEPfDXTi3JG2FbiEPI3iZu3bHCQniJE1K6JYdvpkCbAn+8O8HtlrVvKm4iasWSn8mqs0L6psNF+vqRSwUIJdUSnJePQTwFxfKPJht8dSL2RmpTj5to0fmnHo0e8Ah1B7Bi2jgtVAUnHUWHp7+iakIHp7+jYA69as767XFETRqbj9W7bN1TRaFlx0ZhWHN04bE1/TGSOoAHKbw+1CTNfbgQ+5PYh6IsGKMlYNlO9Gpwohz8jgDGCeHTxULIBIxqPjUlBScdQQGi4FYQdZa3t7+sZScU6zReljQ0PAkNNrrtIKbCPQgkprCVE2yXh0GbABuAHwoxadiyJJGoiJ1UD5OFQInWTfXMmpbMcUlMyw1KdSK2dqUUub5p3V2dJ2ZGBkaGTIKnmstVANJBVkopqS8egJqP5EUeB01PYuaV8o8i1XB1YnZGbFQW7lj0OF0EkFH2j68qagkIqjela3Tew0D9qFfzVv+Umnz1psWZalaZr2/NNH9v7xtwd3WGnHtEqtkgoyUTW+UOSlZDz6EnAN8Cvgk8BqVwdVRyRYYWI1UL7KH3vDw3GS8egmmLyKaLrstSpScdRYSqqcqSX2bITd+E1V7J96RuecU8/ofKSU2QjjzttdbwonFWTCBbuAC4GFwGt9ociOyQ8XGRKsKLl7A2XSLpkAoc80dN0fCObOZFR8ExdfKHIgGY92M7HiSGZV6tSa9d0D9mJap8qZin1gTqcBWjn3YJq58MQZWO72Wcmw/x1kMa2ohmFUqvd1vlBE/uZKIMHKREWnXXyhyCerMSBfKHJPMh7VkWqgRlLVFESZGqCVLX114hknHwNkFkM0m1tR61SecHsg9UYW2HK8QVXW3kC7UW+8GUPAyXlmVoSYlmr1WSnHYtICFTQl9SbJfs0Vc7wQlZC46q6FwC+BH6GqQntQMx9PAGu67r3hSIH7/zVqDcpNqFn5u4HPdd17w9ZyjfHaB27TNq66xfGD+toHbsv8DltQJ7QdqM+vD2xcdcsfyjUOt0mwwoQGVa3AKia20J8QrCTj0Z8C+EKRN1ZpqEKUrECQUWr10QrU7svZ1WlpVJXD9mLHtD/xxGUWjF7wwZtmTnZcIhYbC+a6wmGZiRFllbjqrlXAZcCbUH/D7+2694bRxFV3hYCru+69oXuS+3YB/wfMAr4FzEPtoPwCsKrr3huKfj04ufaB25YC9wE3bFx1ywMOx2R+h08CV21cdcv99v1+AgQ2rrpleLrjqAX5ujc2u5moN99sKVTEmqud/B8AQtSSYtI3xdqBelNPowKcTKBS0kJBK53WrNG05nR7IhZrScRid6CCrC3A/kQsdkciFpPUtSibrntveAD197UT+GTXvTeM2tfHgdMTV93VOsnd/wL8yf7+vahABeB3wLPTHdu1D9x2BvBb1OvzL07H2UHMFuDzG1fdcr993TOo1/zs6Y6jVsgLXxlrCufUAI4KV99Ih1pRQQWrj6a42HbKFTTm7x4tVA3UcE3zRE1bCjyXc91eVNXO8/nu0HXvDcnEVXddgQp0fPbVz6NmZEpaPH7tA7ctBu4Bbtm46pYHrn3gtnNQBRwjwOs3rrql6Oq5ax+4zQP8C/DkxlW3vFDKOGqZBCs5/IHgAdPQJ1TfVHK9inSoFZXkDwQH7MW0TmtWSg42pltBY1m0A95ELLYpz81O+/Z0ANcnYrFbJSUkyuxZVMDyeNZ1S4B9TndIXHXXDOA/OR6ogOq9dVfiqru6u+69IXeGfjIfBF4NdF37wG0DqEDFAlZvXHVL0bM01z5w24XAl1Cp3WtLeP6aJ8EKoI0MrtCsdGemb8osIO1p+1NWA7gbk/HNN+a5awCO91uZoryl0sl4VJcZFlFG9dQAzXHfHs3rGZm94qRLTUP/vfREEWV0FhBJXHXXtfaalTcBu7ruvWGySrlXAK+zv/8hMBcVcLwdiAFPlvD8mXUlPcDHUWsmX7Nx1S2lnBC8Bvhr4PqNq25xTBvVKwlWHHjSQ8OoLrXj5HS2PViGp5IOtaLiaq0BWvuC2bsBVvbcvDr3NntR7fgFwRqcePapdJ6y0Kd5tO8D3imUXgvh5FeoVP/DiavuGkEtDch3gjqm694bNieuuusdwHtQsxgzgO8Cn+6694ZSAhUA075cgXrff93GVbeUWlG0FRWs9F77wG2Z6/5m46pbGiKol2ogii+jLLazbSkcOtTK3j+ioRV6zdmLa8fSVieecyqdpyzA4/VmHyb7+Ii64vR3b1fv/BY1w/KmjatuKTXYaXgSrDChdNmJ44aC013PkrtmBdWhVtasiIZV6DVnpdPawa07lw/u61/s8XqsJa9Z6fV48xYvltTfpdyktFqUYrIg/doHbmsH2LjqlprcF8xtkgYq3sR0TXq0bebhx38GwYtyDy6lukc61IpmYz7w+AJNw7vokpflvV3zeKz5geXb08NLd44eGzpB82gvRy28zTWCChaq2rrcLqEe1xE4EYttANZ1hcOSlhIlkyBlchKsKGOly04H5C1p1jRNG00dzT12KtU9doAiQYpoDul0yqK4DrYFmtq1oEqzq01Kq4WoIkkDAfu23Ldbs9Kd7f3GZGkghtr9C4Z9p5+NZVlomtb20lNHW48eGGb8VLZjukhmTEQ+1Wq5X0v+tP72Y4B3ODm4uZjj551/+op2/9zFHq9n7HWVHk2nU2b/3oNbn552p9ASOZVWg52WkpSQyEe2mZg6mVkpQVvKPNByrP9wVjXQy/Mclq+6ZxRV5vyLig9S1I3enr4JqQR7N+Z1a9Z3Syohy8E/79wxD+jwz11sYVkampYy+/ce/PPOkjrnloljaTUupaWEaHQSrABWS8d2C/CFIqtLuV+mv0r2/RyqezqB/5VmbyJH06YSNE3tztwVDq8u5X6moXdq9izU8jdfPbD8zQXvUnZ5S6uPcystJeqAlba8I6ljpyRisdO7wuGn3R5PPZE0EMWngfJYYl/mvjktAM5m4jSxpIMEMJb6KdfmgnXn0lXeLo+mHTvv2vfOcXss+RTaTiC3tNo2CHytKxxu6EBTTN2eh+Nbhl4avGh/4olwVzh8W+F7iAyZWXGQ0/zNaddKpzOoA6jp4NwKBmn2JjKK2VywYasD2hYtGGpp8Rxxexy5TEOfkJpzaD5XTx2BRe250O0B1BsJVpiYBiq2+VsyHu1A3W8wz22ubIgo6kbBzQUbebHtni0//43bY3BQVGrOLk9em4jFxjoCy6JaURQNC3il28OoN5IGYkKDqqKbv+Vbs5JzuzR7E456e/ocUwlr1nc3dCrB6P3SMbvPSlHVQFVSqMrnNGA2Lm9VIOrXnofjW4YHjr5s34OPHwUu6AqHc3d6Fg7ytoRsQh7UG1Urk+/VUxI7MFkKXI5aqyKBisi2DpU6SAFJ+1JSCe6ZrMqnBTUrugXYbxr6HXbKSIipeAR4vduDqCdN/2KzUz6LUG9SK4GbgdspU/pGmr0JJ3Z58trenr6xVEIjp37GKaEpXLUUaD7XyvGTGWiSqi1RMX8C/hZ1ciKK0NTBit2Vto/jM0ztqEAlE7Bkr1mRgENUhB2gNFdfDo+nXdPwZppklciLel0OUf6KqX5gMYVnnTuA601Dv1VSQmIKHgY+mIjFOmWtU3GaOlhBpXaGGH8mNYRau7LUvn2XBCpC1AQNWI4KJiz7573ADpzTN6XKNJnLfo7MVy5pACemagB4HHgT8F2Xx1IXmj1Y2cXEKd92jgcohYKUb1RgTEI0vA7/3J1QWhrINPQ7gIsZP+sxB3jEHwiWNR2T1WflRWAn0gBOlN+DwDVIsFKUpq4GstNAu1FTyhlDwMkymyJE5eRU4BWj4H48lUrH2EFS3qqtcgdJorFlVQNdDfiAu1B7STVsT6VyafZqoGVMbLyVosjKn2Q8Oj8Zj84v85iEaHijx4Y9o8eG86VWnBSzH0+lSNWWqIQk8DTw124PpB5IGmj8rAqUVvnzPftydXmGI0RzOLDlyQ7ACtx08+piji9QqVPRdIzduXataehjVVuyqFaUyVbgdcDP3B5IrWvqmRU71dON2otlFHXGJJU/QtQYOzjYgEq/ZBsENlQjePAHggP+QHCbBCqijJ4ALnN7EPWgqYMVALuN/oOoJj1L87XVF0LUBEnHiEbzLGrTW1FA0wcrtmEgKTMqQtQufyA4Yi9oXYiqClroDwTX5mwwKEQ9OQzMSsRiMwse2eSafc2KEKLO2GkY6W0iGsUgqjLuqNsDqWUSrExPr9sDEKIezTpl4fNuj0GIGuGh/J2YG44EK9PgC0W+4/YYhKhHvlMXSspVCBWotKPWYIlJSLAyDcl49BQAXygi23wLUYLhI0dnuD0GIWrAXKC/KxyWdVcFSLAyPf9pX652cxBC1JuDxvZzAE6Rok3R3Pyo7RxEAVINJIQQQrhjMfCU24OoBxKsCCGEEO5YCGx3exD1QIIVIYQQwh0+YJ/bg6gHEqwIIYQQ7mgBhtweRD2QBbbT83m3ByBEPfIt80sFnRBqy4gT3R5EPZBgZRp8och9bo9BiEqxdzquyC7Ds06af7CcjydEndqN2jpCFCBpIKUV8JmGvqCUOyXj0bOS8ehZFRqTEK4wDb3FNPQ7gP3AFmC/aeh3mIZetpOboRePtA+9eKS9XI8nRJ36A/DGRCw2y+2B1LqmD1ZMQ78GuAS4AHjG/rlYd9lfQjSSLwDXoTpr+uzL6+zry6L/0Z1n9T+6UwJ90exeALYiO4cX1NRpIHsmpY/jQVs70Gcaui47MItmZKd+rke9FrJ1ADeZhr6SMuxjonk9nZZV/v1QKpm6EqJCvgX8eyIW+1lXOPyw24OpVc0+s7KMiSuxh+zrxzENfYFp6K8oNVUkRJ1ZAji1/raAtiqOpWjVSF0JUSH7gS8D9yVisZe5PZha1ewv5F1MfPNts68fY6eG+lCBTJtp6N3+QPCeagxQiCrbg/P7whAQLMeMhfm7Rw9P9zFyZKeuMq6zL9eW+bmEKLeHUH+7mxKx2JVd4fBv3R5QrdEsy3J7DK6yA5GNgAakgSeA7BRQK2pNS/YsVApYOmvf5nsBfKHI6qoMVogqsGcorkOlfjIGga/5A0HHD/5SUjBG75eOaRreRZe8bHMZhuwFLiX/THEKWCgpIVEL9jwc3zI8cPRl+x58/GqHQ1YCNwOfAT7XFQ6nqze62tbsaSDsGRITGAAeZHygAjATNf2dLZMq+pT9JUQjWQd8DfVBn7Qvv4bDIsCppGBmL1/y0gnLlxwt03jbmPgazRhBBVBC1IM/Af8EvBv4TSIWk0XotmZPA2VsA/AHgqtzb7DXqOxGnb1ltAO7fKGILMIVDccfCI4Aa01Dv5XiZkpKTsG0LzzxMfu5Vk93vPaMzn4mLgoG9R63Z7rPIUQV7Qc+DrwZeDARi30F+HRXONzUs4NNnwYCMA19N9AJGHlubgVWodJEGUPAybP2bT4JwBeK5LufPAmuswAAIABJREFUqDNSSVK6AoFCGvg9eaqHhl48cpFlWYNLV79tUZnGMaXUlRDVVEQaKNdc4D3AuagA5utd4bDTAviG1vRpIJsHNXPSmue2mag33WwpVBroP+wvUcekkmRaplQ9dOgvz7Qf+suz5WwzXlLqSog60Q/cDnwW+HvgL4lY7KpELNZ0n91N/2ZsL7BdhHpjXQmMq/Sx00DPMP7McULFkKhrUkkydVOqHip3NdAUUldC1JOngE+gPqP+FfhEIhb7OPC/XeFwU6RHmjoN5BCIpICl2U3hckuXsQOaZDy6CaQaqJ5NNY0hxlkBLGb8TG0a2Atsz3eHfQ8+/irLYjSw5kMzqjA+IWrCFNJATrqAq1Gpzo8BP270oKXpppJyLKOIpnD2TMtS4HJUICM9VhrHZGkMDZAP08J2oAKTNCqwywQqO9wclBANLAH8A/Bj1FKEhxOx2OWJWEyb/G71q9nTQLuYeEbdTp4Ujz3TItU/jWeyNIYG/MEfCK6p4njqVikLlCvQFE6IZmOh2m08BFwGbAB2JWKxj3aFw1tcHVkFNHuwMl23uj0AMT3+QHDANPRvAjc6HPJB09DPRVJBoBaht6FmHyf99zANfdIHOvGcpV4sK1W+oQnRtCxgMyplfTnwk0Qs9nPgH7vC4b2ujqyMmj1YWYZao5JdsZCp9Ck4i+ILRX5fkVGJarsD6CZ/5UqmoqWZP1g1YDlqXYpl/5xJ80wpTz5zrm+UiSlYIcTUpYE48BvgHcCjiVjsFmBDI6xnafZgZRdF7A3kJBmPXgoStDSA53CeKSjbfjj1yi7rvpjxa9zmAI9MtYfJzl98/4/lGJsQYoIU8J+ooOWjwBWJWOzdXeHwIXeHNT1NHaz4A8EDpqHfzfjy1LuzK4EK+Df7cnVZByaqyk4FbcC5qVgzByqdwPVMXNvVAdxkGvpKppAie2nHnvMti1Eun/BcUnYsRHk8A4SB96EW4L62Kxx+1uUxTVlTVwPZpcsfyLn6A/b1orlIU7H8ptT0rRTSlE+IihlBvY/9CvhVIhab4/J4pqzZ3wyWoab5s88aM6XLk86umIa+YGbrbJ82mirXZmzCRdJUzNGUmr4VklMNJE35hKisH6Gan96Bat9fd5p6ZoUprlmxm8Q9c/TEl12Qmn/xJfbPogH4A8EBfyC4TQIVxf532IBKiWUbBDZM+d/J42nXvJ5O09B/C9zE+PQb9s/Xm4beaX+daaeJhBBT823gLYlYzO/2QKaiqWdW7DUr3cBGVIVDGtgJ3DtJ6WUrcAngwTO2EXOfaeh6CWtdhKgnmVTY9ahp5RbKlyJrw7miaAT4MqqyYQRosdcWrbNnwoQQxUsBTwIXAj9xeSwla/aZlUx32v2oM8UtFC5ZnsnEN9cJXW+FaBT+QHDErvpZiKoKWugPBNdOJ2A48axT/jz7zFMMIIhzCXM7cKV96bMvr0OljYSoK709fScND1k+C8vNLrOt1GnLgKaeWYGxlM4CVAByHjkbGeY5XjY2FE3JTvlsK8djzZzr8wOdwP2onWXz7S3kxTk9dKuk6kS96O3p8wKbU0dGFrd5p78ofYp8qH286rK7bVPPrNiBRx/q38GLCkD6JqsGslM93UAKK30EyzqGCnAkBSREkVL7D89IHTicOVnawcQ1MUdRAUs+I6hF0ELUi3cBybaZnv0ujuEq4Dtd4XBdbnXR1MEKRW5kmCuzseHMQ4892f7Cw3+QjQ2FKM2LT+1ufXHb7hF/ILgaeITS3otaUFVKQtS83p6+ucBngW+5OIyVwCrqeIuYZk8D7aLIjQxz+QPBA8n45mQFxiRE4/N42jUNr10NdCkTg5UO1AzKICU26pPmcqJW9Pb0eYBvAg+gFre6YRlwM/C3XeFw3WYAmn1mRQjhrsmqgVLA9ymyUZ80lxO1pLenT0PNqCzFvVmVpcAngBu7wuHfuDSGsmj2F/EyprGRoRBiitLplB2hBFHBRe4MJ6j3p7+3v4qZKZHmcqIm2IHKp4G/BT6OcxfoSjoLuAW4qSscvteF5y+rZg9WdjHFNJAQYhrsNBCTVwP127ePceh/5EW1FLiQ/OkkqR4SVdPb09cG3IVaI/Jx1Kxgtb0SFeS/pysc/rELz192zR6sTNcNbg9AiHo099xlhzRNy6xF2WFfLkalhDRgb9b1TjRgedb9nNLameqhspRdC+Gkt6fvZOB7qM09P46qaqu2twFvBl7fFQ7XZZlyPs0erCxjGmkgXyji1oIpIepam6/jCQC7GggofWGsvT7lYgqvvZPqIVFxvT19VwB3Az8GfoDzWqxKaQVuBPzAK+t5h+V8mj1Y2cU00kDJePQtAL5Q5L6yjkqIBjdo9p+Lps00DX1Tvtsn2e4iw0v+KqIJT0WB6iEhpqO3p+9E4HbU+qvP4E7Vz3zgn4DHUFU/R1wYQ0U1e7AyXR+1LyVYEVPSrGW2L+00fZqGt2PRlHesn6yKCOAIKpAp1x5GQkzQ29P3duBOVPXZR3An7bMStYD8M8DnusLhas/oVEWzByvLkGog4QK7nPYLZG0O2FSb9NnVQNlpoFLYQZ5TFVEKeBWwvZkCQFE99tqULwPno2ZVHnNhGB7gGmA1cGVXOPxrF8ZQNc0erOxCqoGEO6TMdhr8geCAHdxdR/6mcYY7IxONzN7jpweIAD9Fzaa4cXKxAPgw6qQ60BUO73NhDFXV7MGKEFVnzwpcz8RAuQO4yTT0lahqgoaleT2dljXt3zGT3hmbnSIn7ZOIxcbSbF3hsMyyiCnr7ek7D/g6ar3UrcDzLg3lVai/+X8HPtsVDjvtodVQmj1YWYakgfJKxqMLUP8Ou3yhSFP/W1TAEpzPxizU32OqesOpT3a6bK1p6LeSs+4nEYtNSLMlYrENwLqucLjx02yibHp7+lqBMGom47+An7s0lHbU3/Ny4A1d4fDDLo3DFc0erOyCCdt1t1F8Gug95RxMrUjGo9egdqMeAtqS8Wi3LxSRzRrLZw/Or70hINjoay2Gjxx9oFyPZf9b5fZQkTSbmLbenr7lwHdQTQrXAQddGso5qP19fkqDVvsUollWQy4cLppp6NdgWRsBDax0a/LpJ9pSZjPPJLQClzC+JDQFLG3GGZZKVevYPUKc1ls0/Ifpc5vv322NpjvN3z9WibUlk5U1p4CFkhIShfT29L0Flfb5AWWq+Az9nf9OhodOfiHxl7cVeRcvcDWqLPr6rnD4R+UYRz1q+o0M/YHgPYymTG00NdD+wpYHSwxUFthfjWQmE0tCh1ApoaZRhU3x1qHWVxS1SV+jGdx3qD114HBrhR5+srLmTDdbIRz19vTdjHo93oZ7rSkWofYXmgec38yBCkgaSGnp2GnBzNSCriv8gWDRwUoyHt0E4AtFVldqaNVmr1V5hvHT56WkxhpFRdMIk623aAYps98LDHeFw6vL/dj2otrJNkeUbrbCUW9P30dRKZdbcG/t4qXAB4FPAbc3yyLayTR9sGIa+jWotIcFPGMaerc/EGza9Rm+UORAMh7tJmvNCtDdTCkgt6p1iuja6jYv6u9hiGn+/mWqBsqrKxwesBfT5k2zSQpIOLFb5v8DakGtG+tTPMB7UdtIhBppb5/pauo0kGnoC1Afyh7UG3E70Gdf37TsxbRLgctRa1WaLXgrplqnmWjACtTZ3kX25Qr7+lrV1Gk2Ubrenr75qL19Poc7gcos1OaHs4GVEqiM1+wzK8tQZ4nZZ9CZ9RlNM5OQjz2T0qz/Bk1frZPNYcPAOcAjU10MbP7u0cPlGJsTuzx5bSIWG0uzyYyKKCAMPIg7u3PPAT6BKoteK+X1EzV7sLKLGulgaxr6QuCXqD/Wk1C19C8B1/oDwf2moX8TVb42CIz6A8H/196Zx8lRVA/8GxISEtIEFXDDYQBFuVkQBlo5ggs0ICBRAqR/chiOEAiHcvUAsRk5uhG5E0IQQ+RokCDKJbawEBRtGA5XRI4QuY9FbhoScu7vj1dDJpOZ3Z29ZrP7vp/PfGamurrqdfdM1atXr141NDc1usDpyLK6F4Ej6+obarE3RZ+iHdFR+02n111TYt05DVSMUVBq0fmstLQWSK+vtlPTJs0YBBwJnFmD6r8EnAdcB5zfV/f26Sz9XVnpLAd1YVlfB25Atve+q66+4ZbmpsYdEdP1/sBIYN+6+ob3is75MfCduvqG+c1NjccDARL+Wek8bUZH7Sd0SwC7tbbd5DNks0Gll9DOQHp9tZ3aBvgI6Omw9UORqZ/fZLLZ83q47pWK/q6sbEgnIthajv9eW3mKaS0qbF19Q9Lc1DgEce4KTdpjzU2NhWWWXwXONU6YF9XVN7xeV9+wb1ERCVD8XekE/X21ThHdMiXW3NQ4uzNCKd1Cmyvg+nA7tRm1WfF4AvA3xLKitEJ/V1ZeoRMRbNM4dySA5fgz25G3vVFhbeCM5qbGAImQW9h/4nrgn0hjEAG7FE5obmocCVyJ7BWhdCEVoqP2G7prSuyjF9/YmhZWe+2+YHYXiKl0nkqB9IYBR+eD4KySKaG+1k59BXHE7kl2N/U6OvXTNv1aWamrb3i3ualxfEkE25cHz2+elcaPtKeIelimtLRCcVTYwqhlRhrnGsssCb4GMUVeD2yB7PBJXX3D5YUMzU2Nh5gVS+8DE4CJwJl19Q33tUdoRamSLp8Sm//OR6sjHaTSO2hPIL1ipb2vtVODEJ+anmIoouTtk8lme5X/Tm+lXysrIBFsm5+4+9IBYK324TNPr7J04aJuqKa1qLClykpLXX3Dlc1NjS8CY+vqG+LmpsahwLZ19Q3/aG5q/DKwMfAx0lC8CexUV98wrxvkVpRumRIbMED8XLojKJxSPR0IpNfX2qlF9FB/aNb7/xCYrcuT20+/V1YAGDRsTgswYs/qGs72RrCtNipsc1PjbsCJyA8axBR7UnNTYwgMASbU1TcsbG5qPBAxuf7JzBE/UlffcE4116Ao7aW/T4n1ZToSSK+PtVPzEAt4NzNgiRm1bgG43V9f30GVlR6gvVFh6+obZgOzzdeHi9LfBw4tLbeuvmFEN4msKEr/o13TfX20nZpHDwR7bBmwyuIFSwbPy2SzW3V3XX0NVVZ6CMvxb03jXCMVVgMpiqLUkn4eSG8hPWJZUTqKKiudo6oleP08KqyifME6O272dK1lUMrTTwPpLUIdvns1qqx0Asvxe6uzmKL0alYZNLDf7yKr9CqW0rv3uur3qLLSCdI4dzyA5fhX11oWRVmZ+Hjum+sC1NXXWhJFAWTLiH69sW9vR5WVznGweVdlRVGqYP47H65TaxkUpQj1WenlqCapKIqi9Hc+Yfkl20ovQ5UVRVEUpb/zNhL6XumlqLKiKIqi9HfeRCKNW7UWRCmPKiuKoihKv2bilPFLgccADdbWS1EHW6CuvmF0R85rK8y+oijlqT/h5DVrLYOilHAbcDjwj1oLoqyIWlYURVEUBW5F9uwZWWtBlBVRZUVRlB4nHwQt+SDwai2HohSYOGV8ClyCWFeUXoYqK50gjXMtaZzTBldRFKVvcAmwDrBLrQVRlkeVFUVRFEUBJk4Z/zkwDjgKWK/G4ihFqLKiKIqiKIaJU8Y/CZwJZNGlzL0GVVYURVEUpYiJU8ZfB/wOOAuJv6LUGFVWFEVRFGVFzgTyiIVlcI1l6feosqIoykqBm4QDai2D0n+YOGV8C3AM8DyqsNQcDQqnKAoA+bHT1wEeAO4C5gKTgKVIYz0xM2vCZ62cuxtwKHACsnvtr4FfZWZNeLorZHOTcBRwt5uEEyLbSyrkKcj/BLAhsjHdYOCYyPae7Ao5lP7FxCnjl0ybNONw4AZkSuhCZIdmpYfps8pKc1PjrsDtwFl19Q3XNTc1HklJ41tX31Cx8TVlrAl8XFff0NIRGdI4txbwgeX4S1vJMwK4CVkuNxQxPS4CQiPrR8A4y/Hf74gMilIFX0ca5X2BjYAdM7MmLMmPne4AVwHjy52UHzs9A9wLrI4oCF8Bvg/skx873c7MmjC3M0K5SbgJ0AjMA55rh/znAWMj27vHKDl/cpOwPrK9RZ2RQ+mfTJwyfvG0STMOA34LnANcACyorVT9jz45DdTc1DgMOBs413zfFdgT2LGuviED3Iw0vm1xOJ1bb384MLqNPPsAd1uOvyOwG6KknAp833L8DHA5cF0nZFCUdpGZNSFBrBIvA+dlZk1YYtJjYOP82OmrVjj1OeCf5vPhiKIC8HfgtWpkcJNwpJuED7tJaJvvmwEPm8N7Rbb3UaVzjcXlCeCSyPbuMWmvAouBEdXIoSjFTJwyfglwBNAETEadbnucPqmsIJrvRchIDORHdl5dfcMSgLr6hhjYuLmpsVLjW2B9wKmm4jTODU7j3PA0zg0HXODwwvc0zg0szW85/q2W419rPn8IvAJMthz/HZMlAb5RjQyK0klGAa+XpL2NWP9WIDNrQgocCKRFyW8Ch2RmTajWZH4ssCuQcZNwK0RRGQjsEdletYrPKm4STgZeiGzvvSrlUJTlMArLUcCTiIVlSG0l6l/0OWWluanxu8DQuvqGB4uS16OdjW9zU+MGzU2NTzY3NcbAo8C7zU2NjzY3Nf6xuamxPWvu1wBuQRrubyOKUopYTFpVjtI4Nx4xof/TfB8BXA9c0456FaWreA1RWIpZF3inTF7yY6cPAW5k+ZgU6wHT82OnV9vGFKZqJgEPIYrKnpHtzammEDcJtwP+hvwf3SplUJSymN2Zj0ba6LNQp9seo88pK8gIb5vmpsbZgAecDnyLdja+dfUNrwM7A68CdwN/RBrNMXX1DWlp/lIsx3/Pcvz9kR08C/zccvxJluN/Xu6cNM59I41z9yEjyr0tx1+SxrmDkcb2Dsvxp7ZVr6J0Id8C/PzY6QMB8mOn7wu8kpk1YXGF/DsAe5jPfwT+aj7/ENikyrqbzfs3EJ+t3SPbq9ZJd3fgCuDoyPZOj2yvktyKUjVGYTkKmAOchijUSjfT5xxs6+obTi98Nk61g4D/An5zU6NbV9+wpLmpcV/glbr6hrKNWF19w/zmpsaliOf3ZyatWifbrZFVFesBW1XKlMa5LRHHrRMsx3/UpOWADYDRluN/UGW9itJZHkKmIx/Pj52+GFkZdFylzJlZEx7Jj51+EHAYYsUYgijrF2RmTXihyrobESvoImDfyPaqPR/gacT/a5qbhIW0/SLb+7QDZSnKCphVQochbfwJwJU1FqnPM6ClpUMLXVYKCsqKWQ10NHA84mw3Fziurr7hkwrnjUIcdH+GOOZdDBxRV9+w3GqCNM61AFnL8cOS9E2A3SzHvy6Nc6si1p0rLMdfYfVRGudORX7sxfPxOyJmxsJ8/1zL8Y+u6uIVpReTD4IWIJvJZsPSY24SDgWIbG9+jwumKFUwbdKMYcBs4CVk4Uar7HXIepcumL9k5OZ77Tu8u2Xra/RpZaWjNDc1Dq6rb1hY9H0AovS0S1lRFEVR+gfTJs1YC3gcuBOxDFZElZWOo8qKoiiKonSCaZNmbAY8giykeL5SPlVWOk5fdLBVFEVRlB5j4pTxzyExhk4D1qyxOH0SVVYURVEUpZNMnDL+XmA64uuofWsXozdUURRFUbqGHPAxMLbWgvQ1VFlRFEVRlC7ARLl1kcjn36qxOH0KVVYURVEUpYuYOGX8W8AE4CQ0wm2XocqKoiiKonQhE6eMvwN4DDik1rL0FVRZURSly8gHweB8EFxkPq+SD4IrWsk7Oh8E57dyfHY+CPpclG2l3zAJ+B7wtVoL0hdQZcWQxrm90jiXpHFu1zLHjkzj3NHm8yMlx+rSOHd6SdpyecqUNzONc7qTstIqaZwblca5NWotRzVkstmFmWz2TPN1MLJHj6L0OyZOGf8O4APjay1LX0BHLcs4Fvih5fhvV3neQmRvH0Xpag4FTk3j3OXAFMvxy24P0dvIB8EjwFTgFGBJPgheBI4BNgWuBj4HLgc+Nfm/iWxpsRRYHfkvHgrUA7OAMT18CYrSVUxH/gfbAU/VWJaVGo1gC6Rx7mxk/55HgSnAOUiD+i7wE+AgRLHb0ny/2XL849M4dw6wP6Kw/NVy/LNNx9JWnpnA+Zbjz+3J61wZSePc2sC3ay1HDVkfGIfcgzuA4yvt3t1byAfBM8A8YLdMNjs/HwRnASkwABiUyWYvzQfBAGSzwT2AXyF7cK2J7Jg8JJPNXpQPgtnAHplsVndNVlZapk2acTBiYfE0gm3HUcsKYDn+BWmc2xP4AdAE7GQ5/sdpnBuDeHW/b/Kdksa57Y0Ssj2wk8nbksa5K9I49+325KnRZa6sZIATay1EjRmGdPTjEMvEE7UVp002A67MZLOFjQj/hOzafBJwSj4Ifs/y00P1SGP+APB1lt/UU1FWdn4PBMDmtRZkZUaVleVZAxgJ3JnGOZD78xBGWSlhI8TS8pDJOxz4SwfyKK1gOf69wL21lqMWpHFuK2SvkfUAD5hhOf6C2krVLl4A7HwQDMlkswuA7wPPIv+nS4ChLGvAQQJonZXJZpN8EPwA2NakLwRWw0wXKcrKyMQp45dMmzTjCmQwrHQQdbBdng+BOcABluOPRgL7BCV5Bpr3fyFWmN1N3n1Nx9rePIrSFrsA9wCbWI4/bSVRVADeQ5Ssf+SDII8oW1ORqax7gFsQC1GB24DL8kFwJ2KBKXAfotQoysrOTUCGlpaBbeZUyqI+K4Y0zs1G5s9txGflE2RUdzbiHDXIcvzr0jh3KWBZjn9MGucmAgcAnwFLgGMsx/+krTzAlajPitIHyQfBKCDMZLPjai2LovQmpk2acf/3xozcZsmSlmHqs1I9qqwoitIl5INgZ+AC4ORMNttUa3kUpTcxbdKMSbvuX3fxgAEsUWWletRnRVGULiGTzT6CrPBRFGVFHl66tGW1gQMHfFZrQVZG1GdFURRFUbqfZwcMYPGAAehS/A6g00CKoiiK0gO8/c8HZgOM3HaP0bWVZOVDp4EURVEUpQcYMGBArUVYadFpIEVRFEVRejWqrCiKoiiK0qtRZUVRFEVRlF6NOtgqiqIoitKrUcuKoiiKoii9GlVWFEVRFEXp1aiyoiiKoihKr0aVFUVRFEVRejWqrChKL8NNwrFuEmrAxl6Gm4Tj3CTsd22mm4RbuElYX2s5lP5Nv/vjKbXBTcIj3ST8VUnafm4SzuxgeRu6SfhEG3neq6K8c90knNQRWTqD6QBPK0neJ7K9bt8/xE3CjJuEvzafX3GTsNM7wZYrp9yz7224STjTTcL92si2b2R7S9s6p5rrbWe9PYKbhKPdJLy9zKH9gYXtyKco3YaO3hSlhkS2d0vxdzNyP8NNwoGR7S3p5rrzQL476+hjnFVrAWrEzZHtvV5rIZT+jSorSq/ATcITgaPM1xQ4PLK9l9t57iHA6cBAYDEwMbK9J8yxAcAUYEPgh8Bw4ApgG5M/Bn5mijrVTUIfaAGmR7Y3uUJ9s4H/Ad9BrJPTIts7z03CYcBFwGiT/k9zTeOAc83pqwH3AidGtjfPTcIjgS0j2zvNTcKfAhOAt4D13SScFNneX9wkTIH7ge8CHwOnRbZ3VwXZMsDlwChgATAlsr1LjWx3A5sDLxuZNgImRbZ3UNH5ZwIHAXtGtvdRhVuOm4S7AxcCQ01SNrK9+8qVU5S2PvAAcGFkeze4SbgmcBWwN/LcbgSywAbAo+ZahwL1ke19UEaGfYAAWBv5zZwX2d7NbhKeC+wEbAKsAfzF3NfhwL+B9SPbW2AUw9eB3UyRE9wkvBpYFbgV+Flkey1uEh5u5BrhJuG7yP2/35xzmbEOLjDXNdWkH+om4Y+BwcBtwEmR7X1hnahwT88AjgVWB14Fjo9s7yk3CUebe7MIuDeyvRPdJPwzUJiaGQbMiWxv+zJljkJ+/6OQ3/sNke1dVCbfHkbOYW4S3hbZ3sFuEn4TmAps6iZhC3CLuQ+K0uPoNJDSk0x0k7C58EIa4IJCsRCwI9urB34NnFlFuasBe0W2ty1wKnC+SR8AXAtsDPwwsr0FSEfwh8j2tgK2ArYEdjT5Z0S2t7ZJazBKUCU+NOVuCuzrJuG+SMf0JLB1ZHtbIB3YGJP/UaTz3MBca65Mmc8hHfP3gEOBM0z6cOCPQB2wH3CNm4RfKT3ZTcLVkHt3VGR76wFbA7u7Sbgzopy8HtneSOCwyPZeLVP/OcDByL2sqKgYvgQcap7XD4BL2yhnFPAQEEa2d4NJuwpoNtf1TSNvYSpuNeDAyPa+VkFRGYk85/3MtX4XONFNwg2L5LOBrwIfAD+PbK8ZeQ4HmDyjgZci25trvn+EPKNNEGX2ADcJtwV+Anw3sr11kSmRgvIHoiCtBewCnOwm4U4m/c/Auua6vwr8tJV7iZuEPwC2Q57/SOBo4DeFOoDDjVyXAES2t3dke3XA14H/AmdXKHpN4LLI9rY25R/hJmFdaabI9h5AlPl7Its72CTfCPiR7W0AfAMYAbitXYeidBeqrCg9ybTI9uoKL+AwgMj2WoBXgD+6SZhHLB1rVVHus8D1bhI+DlxcdO6XkdH9QUZRAXgb2NJNwkeBR4AtivJ/aOT5H/ArZMRfiasj21sY2d4nwO3AdqZjXgN4xJT/vaKy34hsb1Fke4uQznxMmTIXAY1uEjYhSseaJv2jyPZuiGyvJbK9OYhCtFmZ8zczr4eMMjgXsf5sDswGMsY/Jq1wTacBYyLb+7CV6y7wb+Ai4zd0M8s/r3LlHAQ8FNnezKK0fYBzIttbEtleiihwBf+NuZHtPddK/TuZ63rCXOt/EIVnU3M8imzvf8bHZCbSUWM+H2E+jzPfC/wusr0Fke19CtyFKLOjgR2AZ009eUThHGXO+QAgsr2XgGsAx6R/FNneUnNd59H6bwnkt7IPMNfU8wCwsZuEqwOzTBnfB94oOW8mcFNke3GFcl8C9jP/q9mIYtjmf8tNwi8B2wN3GHleA35E+d+donQ7Og2k1BwzSr4GcSx93phz1bObAAASPUlEQVS923J2HQgscpNwVeAPiOUkb0bWBee/T4CHAQ8oTOmciIwSv2emYWa2Use8Vo4V+5MsACw3CX+IjNr3i2zvQzMdUY4WSgYKbhIOBm4CRke290LJdZT6riyg/H93HvBKZHvfLFepGfX/H/Cwm4Tjy2S5GbgAo0S2we8RH44/Rba3tMSZuVw5dwPfd5Nwy8j2njFpqyDWr2La2ybNA/4W2d5epQfMdZY+n0K5dwNT3CTcAFEgfkZ5Fptz5iGKz7Fl6qkkVzXpxccvimzvwjLHrnSTsBGZIjrLTcKdI9tb7Cbh2cDnke1d0kq5F5iyd45sb6GZwqxE8d4r8815GxgF+wvM/1NRehRVVpTeQB0yQn3R+BG0Z5nkKOBNZIpkIDLSh2UjaBBLxRHAY24SPhTZ3oPmvKeMorIm4rdR4GtmSmp14CRkmqIaRgH/MYrKMGSU/4g5tr6bhEOQzvkypNMsZpg59qa5B3aVdYNYUpYYv5trkRH0T5BR+UfAwsj2prlJ+DnSUT9Ucv4pwD1uEh5ZYgEpx7pA3igq25UcK1fOHCPTrW4SZiLbm4f44Ux2k3AyMu0zmRXvSyUeBbZxk/BYZIpsFDJF0er0oemwbwN+i1h6KlmZCvwFuNBNwhj4G2JZ2DuyvYLvxigANwnXBsYj93sLYD03CQciCtlpwINt1HMPcLubhI8hv+UdgK0i2wvdJBwa2d5/kGmmh4EN3CTcDJmSGt1GuaOAmea610X+a5VIgXUAItv73E3CBLjKTcILkOfzE5ZNTSlKj6LTQEpv4F/m9TLilLpjpYxuEl7mJuFNSGdzo5lq+A0wx03CZ1jmjwBAZHsfA2OBa90kXAeYhszbv4CY+ocUZbeB55FO/6nI9n5f5XXcDGzvJuFcRBEoNrdvj/gWvIX87wo+BqsAC8wU0nTgRSODQ5WY1UNjgJ1NGXcDSxHLwneAp9wkvAGxNJW7tkXIvZrsJuGmbhJeaJxLy/Fz4HE3Cf+DWKuKR9/LlVMk3z2IFaygBE5ErFxvIcrMM4jzc3uu9WPgQKQDfQmxSr1rrrctrgd2B2a0o56XEYV3MvL7vAqZsiwwxjzvp4HrI9t73KRvAjSxbNqm1euKbO/viKVqqrkeH/ktgEy3PeQm4R3IvX0FcaLeDHjF+IA9UKHoi4HATcLnzPW2tnPt08AQNwlnme8/QZyXmxAL5TqI0guAm4THuEl41AqlKEo30KW7Lqdx7iTgdcvx/1Dm2GikAZ9uOf5xnaxnIMtWWWyF+An8D5lPvtxy/L+WOWc1xLTZGp2WTele3CTcGHnmr0a211RredpD8YqfkvQBiBPjfZHt3dwDcliIcvCi8ctoK/9ewCeR7T3a3bL1JMaZ9ZzI9naotSztxazqWR14zvh4KUqbmBVzf2oj27jI9m6tcP42iI/cQJO0e2R7s8vk2xJxsv8OotBehzifLynJNwU4ATg6sr2qrHTtngZK49zPEY/2Qy3HX8GZyygDlyCjpW4jjXODkaWfe5ik95BR2XrIqPLANM6dbzn+z0tOHWneP0ec8cpRboWE0oswjowv1VqOLuI54B/A73qiMjPl8c8qTnkxaufy8ZUFYyn6KbLyZaWhwuotRWmLwrTfu4iTdDlWWG1XxFVInzkPsbKtgBlAPoKsFvsvYoHzkVVwE4vyjUCslO8hVuiqqMZn5RBkdcL+SGyKUuqROfc7qxWiSk5EFJUPgUMsx78fII1zqyCm56nA5DTOvWQ5/syi8woPLW85/m4oSg9Ryf8jsr1Ny6X3FvqaogJglk3f0GZGRekbFPq9aZHt+dWcaOIE7YL4722BxCoqx9mIovKjyPbuML6AfwGOdZMwiGyvoCQdjYlzFdne51VeR1U+KxcDj1F5nnc+cJLl+O9WK0SVFEZEZxUUFQDL8Zdajv87ZAng58AFaZxbtei8wkPTEYqiKIrSH+hQv+fKlhm/BF5A/PxaY0fg35Ht3QFg/O9+iegXO5jyBiIrPBcBV1cjS4F2KyuW48+0HH8ny/GfqnD8X5bjd0iIKpmGWFfuqCDH04jz4Los76hZeGiVTGGKoiiK0pfoaL/nI64Tp0Vt71O2EBhufPAKFPYHKzje/wCJIj4rsr23qpQFqM5n5RrEDLQ74o3+MhBbjl822FEa585FLnic5fhlnXc6guX4N7UjW8EDf72itILPyqtpnPsW4q2/FHjCcvz/dZV8iqIoitJLKPR7b7iyFcdIxAH2icj2Pit3glnBdzLwgFnB1xb3I9G2AzcJQySyt4+sQvy7yXOKeW/Xar9y9NWlyxnzXqzBFTTMX7JsWee9wJtpnJtqHHcVRVEUpa9Q6PcSxI3jj0gk49fdJKy0GOZKZPXPqe2sI0CW2Z+J+JI+iVhRspHtvW+2rNgFSCLZPLVD9DllJY1z+yDWn/eRm1ag8NDWRIIuXY+EtF4FOJ5l0UIVRVEUpS9Q6PdGIKFDrkfi5nwJuNpNwuUiOJso3HsCv4ls7+n2VGB8VHYCQuCvSPyqAyLbu8xk6bRVBfpYBFsTy6Uw5fQLy/GLQ1yfg1hanrEcf0rROdsjm47tn8a5gyzHV6VFURRF6QuMA44Eroxs72+FRLPdxq+BC1zZZfsNNwmHIrFSUpZtT9IuzGajK+zI7SbhV5GVxG9QPhBlu+kTykoa5wYhN/dsxHw11XL8K4vzGMfbFQK+WY7/RBrnTkCUnCNQC4uiKIrSB4hs717E3aE0fYabhDsgfeIhSIy0LLI9QzayvXe6SISJSJTwqe1w1G2VlV5ZSePcAYgfyrcQh56flSoq7eD3iNfyNl0snqIoiqL0Rm5BlJVt3CTcCDgdWeJ8eVcUbjZnPQ4Ja3KtSRto6jkWcfZ9Hol0W3Z1bzErrc9KGuc2S+Pc/UgQum8hc2X1HVBUsBx/MeIYNLytvIrSH8gHwdr5INii6PtNxe89UW8+CGbmg6DTA6p8EGyYD4LzKxzbrejzTSXHWq0/HwSj80FwdNH3unwQfNN8PjIfBHtUOreknE3yQbBemfQ273VpPfkg2CIfBF9uT71Kv6cQE204sBuyWeUoYL6bhC3FL5YFhHvIpL3SjvLHIVFsbzTTRCB+KwGy3PnPwPrA742vTKt0VFkp7LGzeit5hnaw7DZJ49wxyMZ3eyCa4CGW4+9mOf7zHSxvHSSUsAaM6ybSODfTTNeRxrlBaZybWWORWiWNc+encW5D83mHNM6tbj5vmMa5sh1frUjjXHcoEEOAt7uh3N5Wb1u7LlfDMGSPsmpZtYPnVSrrwy4qS+nbFAYjryIh8J9s5VVQbOaY7+1xvj3ZvF8BX/ivHIfsML5FZHtjkM0430KWOrdKR0ct7yJrtTdP49yqluMvKpOnI1vct0ka574LXGO+ngtcZDl+m6F70zh3CHC75fhLyhw+F9kqQP1VlHIstBy/bEyCWpLGudORHadbJR8EI5A56Y+BLyORJC8xhw8Etshks+8X5T8S2BIYng+Ce5GVBJl8EBxgjg9CGqD5iCn3BGAvYF9kD5E1kJHYZUgso8HIigAX2BxZ5vhvZPo2j3SwpwIHldRb7lr2MTJ/iigaM5E5+b8iis7ZyK7SUzPZ7Jx8ENyN7AV0YD4I1kb2LfkpMjg5Bvg0HwTjEAf8HfNB8FtkxWDBv+3X+SD4EnBrJpstjRd1MvClfBDcaa5tM+CzfBCUDZyZD4IzgYcz2eyj+SC4Bmmg/w9ZsbF2PgiuBn6BtK+RKXsGMuJ9AJmuLn6OpyF+dp/mg+BBxG9vXWCNfBCcl8lmny0nh9I/cJNwGOBEtrfCxsJuEg5BdvkGuN3s+l0xpoqbhIU4axPKbWRYJv+uwLbA/ZHtFX6HGyE+pX8pbHAY2d57bhI+irQdrdIhZcVy/KVpnIuQJb8Xp3Hu1GIlwDSiu7RWholr8mXL8ZurrP4oxCJ0ieX4ufackMa5s4ALgAfSOHe85fgvmvQ1gRziBPQKHQwDrHSMNM7tgHQY84D3LMc/v+T4yZgOAHgKeAZ5VoXdg3dBOrxBQAuyLO8k5A/xMfCC5fhXlZR5GtKgrwVcZTn+40XHLGS30IVIp3mdsaKsas6bjHRQuxprxjmW4//YnHsTMBfZI+s1I9NQpEP9O6II/8qkDUeCKF3YhqyFvTlS4HWkY74aGQVdgYyMPjF5JwOfWY5/aZlb/Qmy0dhGSPjrr2Sy2ePyQXAaMKlYUTE8gpiDU2BMJpsdnw+CvTPZ7F35IDg4k80uzgfBA0hjZAFbA/tlstnD4YvpiyOAWZls9v58EDQAByOd8rPATcD2wO8y2ewlRgnau7TeMtcBMt9d2FV9I6TTfjCTzZ6YD4Ktkc5/KjDRyJEHFgP3ZbLZ002eQ5BYTM8gv5uRwNeBxzLZ7BH5INgYUcAAjjHXG7FspWGBK5Df4UJzvXeZdBt4oozsvwUm54PgaWC1TDb7Tj4IZiPK18fAPsCnRfdxfCabHW8+34z8vouf4+qmzDeATYHBmWx2Qj4I1kB+a8dWuIdKH8dEk/0DsJebhJcDv4hs70Nz7OvISqBtgTuNotLVFKwqxf4v/0X+i0e4SXhzZHsfuEm4BdCAtJ2t0pFpoML25Gcj67VPBl5I49z1aZy7Mo1zTyMdyMI2ynkMeCuNcz+qsv6vmfeD0jj3RBuvgsPsnUjE3T2AOWmceyWNc/9BzM0nIYrKfpbjq/m0e7kgjXMhojiCmBRfRDrfPYszpnGusENnM9J52Zbj/wtRkBcBP0Y6uFHm/A+A0eb0UyzHnwR8O41zxSGgQWINfGry71Ny7FBguuX4h7HMg/4BxHF7KbAr0kHd18qU4y8sxz8JUYZONp/3BhzgWcvxj0NG1Me3Q9afIb/RT5HOaQgyyv6t5fjFO0//ABhUQVHBXOdaiAXxr8Aq+SDYHxiUyWbLWRNDYArynAptxNLCwXwQbI7EMsohHfQqwFfyQVDcniwsOmcJMDCTzZ4LPI4oXQUlDUSZWrNCvaUsBWaasnLIc1yunEw2OwdRSI/HOPYhzxBEMR6K7B92rynnohIrxKqsOJArN629GLHILjTl/xI4z7yvQCabbUasTocBs0zyL4CLzHWvUiQnLN+GtlDmOZbIsNz9LieD0j+IbK8Fsbp+hlg133GT8AU3CV9E2t3dgQeBw7u6bjcJN0TapDnAfUUyvYv8zr8NvOYm4XPILvAjkP9yq1SjrAwz7/MALMf/CBlBnIE0GAchZqIhSGNTqeEs8BoylfReFTLAskZkFHLRrb0sI+t/kFHoGYiSNAIJCfwycpO2M3mU7uVsy/E9RNHFvM82FpXXS/JW6gDOB2Ya69h8ZL4zh/zefmvyfFxUTmmjnWP5zoGSvMWd1AikwzsPuJHlOweQTqFgkSnwiXmfZ14gnV+lzqQ1WRch0SRzwGSzLcSRwOg0zh1VlC8Btk/jXCUH8bnAzsgopwGxRlwLbJgPgmvyQfCVkvxzWNaJFliQD4LCwOIdZNBwGbLTOchI7W5jgVgA3AaMM9MdPwZuzQfB/yEd7vvmHpRSrt5SfgHclQ+C55GImZW4HVg1k81WWoJ5ATA1HwTPARfng2AIsF0+CKYgm7YWNm+7JB8Et1DeRD4Xmf6xkC3vm5Dprb1akWsWooT+2Xx/G7GwtXYtxfUVP0cQ69AZwEsA5n5fC1yWD4Jz80GgSks/JbK925DFJ5chv531kGnQPGLR3jOyvU8ql9BhJiFt2ZVGaSrmVMQ6+g5iIXwGGBPZXpsuGANaWkrLKk8a5x5FNgZcpwd2Vlb6GMah9mjL8RcbR9vrEOvFGOSHu4Pl+DuXnDMJsXwtRpSRVxET/4NIhzcZMY1/B+n0T0CmiQr1fFFnUZnXIZ3pasDrluOfW3RshJHrXUTZ/THSqb2FTBXch3RKMfKH3Av5ww1DRt5zgZssx59bcr03AT9BTPNDEPO9Z8puTdaDEEVpgKn3SuDniNLzIDKdcTRiqbgIsXLeBgy0HP+LEU1PkA+COmRFwVDg1Uw2+1CFfMMz2eyn3SzLusBVwCmZbLZUCVYUZSWkXcqKmTu/Echbjr9jW/kVRekejKI3qJJTeRrnNjbH5/SsZIqiKN1Hq8pKGucuR8ycayNzvN+zHD/pIdkURVEURVHa9FlZHzHB3wJkVFFRFEVRFKWnabfPiqIoiqIoSi1YacPtK4qiKIrSP1BlRVEURVGUXo0qK4qiKIqi9GpUWVEURVEUpVejyoqiKIqiKL0aVVYURVEURenV/D/TxKeSEGbTtgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 32\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ts 33\n" ] }, { "data": { "image/png": "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